Upload 4 files

Dockerfile

@@ -0,0 +1,119 @@
+# =============================================================================
+# ADUC-SDR Video Suite — High-Perf Diffusers for 8× L40S (SM 8.9)
+# CUDA 12.8 | PyTorch 2.8.0+cu128 | Ubuntu 22.04
+# =============================================================================
+FROM nvidia/cuda:12.8.0-devel-ubuntu22.04
+
+LABEL maintainer="Carlos Rodrigues dos Santos & Development Partner"
+LABEL description="High-performance Diffusers stack with FA2/SDPA, 8×L40S"
+LABEL version="4.4.0"
+LABEL cuda_version="12.8.0"
+LABEL python_version="3.10"
+LABEL pytorch_version="2.8.0+cu128"
+LABEL gpu_optimized_for="8x_NVIDIA_L40S"
+
+# ---------------- Core env & caches ----------------
+ENV DEBIAN_FRONTEND=noninteractive TZ=UTC LANG=C.UTF-8 LC_ALL=C.UTF-8 \
+    PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# GPU/Compute
+ENV NVIDIA_VISIBLE_DEVICES=all
+ENV CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+ENV TORCH_CUDA_ARCH_LIST="8.9"
+ENV CUDA_DEVICE_ORDER=PCI_BUS_ID
+ENV CUDA_DEVICE_MAX_CONNECTIONS=32
+
+# Threads
+ENV OMP_NUM_THREADS=8 MKL_NUM_THREADS=8 MAX_JOBS=160
+
+# Alloc/caches
+ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512,garbage_collection_threshold:0.8
+ENV CUDA_LAUNCH_BLOCKING=0 CUDA_CACHE_MAXSIZE=2147483648 CUDA_CACHE_DISABLE=0
+
+# Hugging Face caches
+ENV APP_HOME=/app
+WORKDIR $APP_HOME
+
+
+ENV MODELS_DIR=/app/models
+RUN mkdir -p /home/user/.cache/models && ln -sf /home/user/.cache/models /app/models
+
+
+
+# ---------------- Sistema & Python ----------------
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential tree cmake git git-lfs curl wget ffmpeg ninja-build \
+    python3.10 python3.10-dev python3.10-distutils python3-pip \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+RUN ln -sf /usr/bin/python3.10 /usr/bin/python3 && \
+    ln -sf /usr/bin/python3.10 /usr/bin/python && \
+    python3 -m pip install --upgrade pip
+
+
+# ---------------- PyTorch cu128 (pinado) ----------------
+RUN pip install --index-url https://download.pytorch.org/whl/cu128 \
+    torch==2.8.0+cu128 torchvision==0.23.0+cu128 torchaudio==2.8.0+cu128
+
+# ---------------- Toolchain, Triton, FA2 (sem bnb) ----------------
+RUN pip install packaging ninja cmake pybind11 scikit-build cython hf_transfer numpy==1.24.4
+
+# Triton 3.x (sem triton.ops)
+RUN pip uninstall -y triton || true && \
+    pip install -v --no-build-isolation triton==3.4.0
+
+# FlashAttention 2.8.x
+RUN pip install flash-attn==2.8.3 --no-build-isolation || \
+    pip install flash-attn==2.8.2 --no-build-isolation || \
+    pip install flash-attn==2.8.1 --no-build-isolation || \
+    pip install flash-attn==2.8.0.post2 --no-build-isolation
+
+# Diffusers/Transformers estáveis (sem dev)
+RUN pip install --no-cache-dir diffusers==0.31.0 transformers==4.44.2 accelerate==0.34.2 omegaconf==2.3.0
+
+# Opcional: seu fork de otimizações
+RUN pip install -U git+https://github.com/carlex22/diffusers-aduc-sdr
+
+# ---------------- Dependências da aplicação ----------------
+COPY requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+RUN pip install --upgrade bitsandbytes
+
+# Scripts e configs
+COPY info.sh ./app/info.sh
+COPY builder.sh ./app/builder.sh
+COPY start_seedvr.sh ./app/start_seedvr.sh
+
+# ---------------- Código e permissões ----------------
+COPY . .
+RUN useradd -m -u 1000 -s /bin/bash appuser && \
+    chown -R appuser:appuser /app && \
+    chmod 0755 /app/start_seedvr.sh /app/info.sh /app/builder.sh || true
+
+USER appuser
+
+# Declara volume persistente para HF Spaces
+VOLUME /data
+
+# Env vars para caches em /data
+ENV HF_HOME=/data/.cache/huggingface
+ENV TORCH_HOME=/data/.cache/torch
+ENV HF_DATASETS_CACHE=/data/.cache/datasets
+ENV TRANSFORMERS_CACHE=/data/.cache/transformers
+ENV DIFFUSERS_CACHE=/data/.cache/diffusers
+ENV HF_HUB_ENABLE_HF_TRANSFER=1
+ENV TOKENIZERS_PARALLELISM=false
+
+
+
+
+VOLUME ["/data/.cache/huggingface/hub", "/data/ckpt/VINCIE-3B" ]
+
+  
+
+
+# ---------------- Entry ----------------
+ENTRYPOINT ["/app/start.sh"]
+CMD [""]

builder.sh

@@ -0,0 +1,351 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "🚀 Builder (FlashAttn LayerNorm extra + Apex + Q8) — runtime com GPU visível"
+
+# ===== Config e diretórios =====
+export SELF_HF_REPO_ID="${SELF_HF_REPO_ID:-euIaxs22/Aduc-sdr}"  # Repo no HF para wheels
+export HF_HOME="${HF_HOME:-/app/model_cache}"
+export HF_HUB_CACHE="${HF_HUB_CACHE:-$HF_HOME/hub}"
+export TORCH_HOME="${TORCH_HOME:-$HF_HOME/torch}"
+export HF_HUB_ENABLE_HF_TRANSFER="${HF_HUB_ENABLE_HF_TRANSFER:-1}"
+export PATH="$HOME/.local/bin:$PATH"
+
+mkdir -p /app/wheels /app/cuda_cache "$HF_HOME" "$TORCH_HOME" /app/wheels/src
+chmod -R 777 /app/wheels || true
+export CUDA_CACHE_PATH="/app/cuda_cache"
+
+# Preserva licença NGC (se existir)
+if [ -f "/NGC-DL-CONTAINER-LICENSE" ]; then
+  cp -f /NGC-DL-CONTAINER-LICENSE /app/wheels/NGC-DL-CONTAINER-LICENSE || true
+fi
+
+# ===== Dependências mínimas =====
+python -m pip install -v -U pip build setuptools wheel hatchling hatch-vcs scikit-build-core cmake ninja packaging "huggingface_hub[hf_transfer]" || true
+
+# ===== Tags de ambiente (Python/CUDA/Torch) =====
+PY_TAG="$(python -c 'import sys; print(f"cp{sys.version_info[0]}{sys.version_info[1]}")' 2>/dev/null || echo cp310)"
+TORCH_VER="$(python - <<'PY'
+try:
+    import torch, re
+    v = torch.__version__
+    print(re.sub(r'\+.*$', '', v))
+except Exception:
+    print("unknown")
+PY
+)"
+CU_TAG="$(python - <<'PY'
+try:
+    import torch
+    cu = getattr(torch.version, "cuda", None)
+    print("cu"+cu.replace(".","")) if cu else print("")
+except Exception:
+    print("")
+PY
+)"
+echo "[env] PY_TAG=${PY_TAG} TORCH_VER=${TORCH_VER} CU_TAG=${CU_TAG}"
+
+# ============================================================================
+#                               CHECKERS
+# ============================================================================
+
+# Checa especificamente o módulo nativo requerido pelo layer_norm (sem checar 'flash-attn' geral)
+check_flash_layer_norm_bin () {
+python - <<'PY'
+import importlib
+ok = False
+# extensões conhecidas produzidas por csrc/layer_norm
+for name in [
+    "dropout_layer_norm",                 # nome do módulo nativo
+    "flash_attn.ops.layer_norm",          # wrapper python que usa o nativo
+    "flash_attn.ops.rms_norm",            # pode depender do mesmo backend em alguns empacotamentos
+]:
+    try:
+        importlib.import_module(name)
+        ok = True
+        break
+    except Exception:
+        pass
+raise SystemExit(0 if ok else 1)
+PY
+}
+
+check_apex () {
+python - <<'PY'
+try:
+    from apex.normalization import FusedLayerNorm
+    import importlib; importlib.import_module("fused_layer_norm_cuda")
+    ok = True
+except Exception:
+    ok = False
+raise SystemExit(0 if ok else 1)
+PY
+}
+
+check_q8 () {
+python - <<'PY'
+import importlib.util
+spec = importlib.util.find_spec("ltx_q8_kernels") or importlib.util.find_spec("q8_kernels")
+raise SystemExit(0 if spec else 1)
+PY
+}
+
+# ============================================================================
+#                         DOWNLOAD DO HUB (GENÉRICO)
+# ============================================================================
+
+# Instala uma wheel do HF por prefixo simples (ex.: apex-, q8_kernels-)
+install_from_hf_by_prefix () {
+  local PREFIX="$1"
+  echo "[hub] Procurando wheels '${PREFIX}-*.whl' em ${SELF_HF_REPO_ID} com tags ${PY_TAG}/${CU_TAG}"
+  python - "$PREFIX" "$PY_TAG" "$CU_TAG" <<'PY' || exit 0
+import os, sys
+from huggingface_hub import HfApi, hf_hub_download, HfFolder
+
+prefix, py_tag, cu_tag = sys.argv[1], sys.argv[2], sys.argv[3]
+repo = os.environ.get("SELF_HF_REPO_ID","euIaxs22/Aduc-sdr")
+api = HfApi(token=os.getenv("HF_TOKEN") or HfFolder.get_token())
+try:
+    files = api.list_repo_files(repo_id=repo, repo_type="model")
+except Exception:
+    raise SystemExit(0)
+
+def match(name: str) -> bool:
+    return name.endswith(".whl") and name.rsplit("/",1)[-1].startswith(prefix + "-") and (py_tag in name)
+
+cands = [f for f in files if match(f)]
+pref = [f for f in cands if cu_tag and cu_tag in f] or cands
+if not pref:
+    raise SystemExit(0)
+
+target = sorted(pref, reverse=True)[0]
+print(target)
+path = hf_hub_download(repo_id=repo, filename=target, repo_type="model", local_dir="/app/wheels")
+print(path)
+PY
+}
+
+# Instala wheels do submódulo layer_norm aceitando variantes de nome
+install_flash_layer_norm_from_hf () {
+  echo "[hub] Procurando wheels FlashAttention LayerNorm em ${SELF_HF_REPO_ID}"
+  python - "$PY_TAG" "$CU_TAG" <<'PY' || exit 0
+import os, sys, re
+from huggingface_hub import HfApi, hf_hub_download, HfFolder
+
+py_tag, cu_tag = sys.argv[1], sys.argv[2]
+repo = os.environ.get("SELF_HF_REPO_ID","euIaxs22/Aduc-sdr")
+api = HfApi(token=os.getenv("HF_TOKEN") or HfFolder.get_token())
+try:
+    files = api.list_repo_files(repo_id=repo, repo_type="model")
+except Exception:
+    raise SystemExit(0)
+
+pats = [
+    r"^flash[_-]?attn[_-]?.*layer[_-]?norm-.*\.whl$",
+    r"^dropout[_-]?layer[_-]?norm-.*\.whl$",
+]
+def ok(fn: str) -> bool:
+    name = fn.rsplit("/",1)[-1]
+    if py_tag not in name: return False
+    return any(re.search(p, name, flags=re.I) for p in pats)
+
+cands = [f for f in files if ok(f)]
+pref = [f for f in cands if cu_tag and cu_tag in f] or cands
+if not pref:
+    raise SystemExit(0)
+
+target = sorted(pref, reverse=True)[0]
+print(target)
+path = hf_hub_download(repo_id=repo, filename=target, repo_type="model", local_dir="/app/wheels")
+print(path)
+PY
+}
+
+# ============================================================================
+#                                BUILDERS
+# ============================================================================
+
+# Passo extra: SIEMPRE tenta instalar o submódulo layer_norm via wheel do HF;
+# se não houver wheel compatível, compila a partir de csrc/layer_norm e gera wheel.
+build_or_install_flash_layer_norm () {
+  echo "[flow] === FlashAttn LayerNorm (passo extra) ==="
+
+  # 1) Tentar instalar wheel do HF primeiro (evita recompilar)
+  HF_OUT="$(install_flash_layer_norm_from_hf || true)"
+  if [ -n "${HF_OUT:-}" ]; then
+    WHEEL_PATH="$(printf "%s\n" "${HF_OUT}" | tail -n1)"
+    echo "[hub] Baixado: ${WHEEL_PATH}"
+    python -m pip install -v -U --no-build-isolation --no-deps "${WHEEL_PATH}" || true
+    if check_flash_layer_norm_bin; then
+      echo "[flow] FlashAttn LayerNorm: OK via wheel do Hub"
+      return 0
+    fi
+    echo "[flow] Wheel do Hub não resolveu import; seguirá com build"
+  else
+    echo "[hub] Nenhuma wheel compatível encontrada para FlashAttn LayerNorm"
+  fi
+
+  # 2) Build from source do submódulo csrc/layer_norm -> wheel
+  local SRC="/app/wheels/src/flash-attn"
+  echo "[build] Preparando fonte FlashAttention (layer_norm) em ${SRC}"
+  if [ -d "$SRC/.git" ]; then
+    git -C "$SRC" fetch --all -p || true
+    git -C "$SRC" reset --hard origin/main || true
+    git -C "$SRC" clean -fdx || true
+  else
+    rm -rf "$SRC"
+    git clone --depth 1 https://github.com/Dao-AILab/flash-attention "$SRC"
+  fi
+
+  # Define CC alvo a partir da GPU ativa (reduz tempo/ruído de build)
+  export TORCH_CUDA_ARCH_LIST="$(python - <<'PY'
+import torch
+try:
+    cc = "%d.%d" % torch.cuda.get_device_capability(0)
+    print(cc)
+except Exception:
+    print("8.9")  # fallback p/ Ada (L40S) caso build sem GPU visível
+PY
+  )"
+  echo "[build] TORCH_CUDA_ARCH_LIST=${TORCH_CUDA_ARCH_LIST}"
+
+  pushd "$SRC/csrc/layer_norm" >/dev/null
+  export MAX_JOBS="${MAX_JOBS:-90}"
+  # Gera wheel reutilizável
+  python -m pip wheel -v --no-build-isolation --no-deps . -w /app/wheels || true
+  popd >/dev/null
+
+  # Instala a wheel gerada
+  local W="$(ls -t /app/wheels/*flash*attn*layer*norm*-*.whl 2>/dev/null | head -n1 || true)"
+  if [ -z "${W}" ]; then
+    W="$(ls -t /app/wheels/*dropout*layer*norm*-*.whl 2>/dev/null | head -n1 || true)"
+  fi
+  if [ -z "${W}" ]; then
+    # fallback para qualquer .whl recém gerado
+    W="$(ls -t /app/wheels/*.whl 2>/dev/null | head -n1 || true)"
+  fi
+
+  if [ -n "${W}" ]; then
+    python -m pip install -v -U --no-deps "${W}" || true
+    echo "[build] FlashAttn LayerNorm instalado da wheel: ${W}"
+  else
+    echo "[build] Nenhuma wheel gerada; instalando direto do source (último recurso)"
+    python -m pip install -v --no-build-isolation "$SRC/csrc/layer_norm" || true
+  fi
+
+  # Checagem final do binário
+  if check_flash_layer_norm_bin; then
+    echo "[flow] FlashAttn LayerNorm: import OK após build"
+    return 0
+  fi
+  echo "[flow] FlashAttn LayerNorm: falhou import após build"
+  return 1
+}
+
+build_apex () {
+  local SRC="/app/wheels/src/apex"
+  echo "[build] Preparando fonte Apex em ${SRC}"
+  if [ -d "$SRC/.git" ]; then
+    git -C "$SRC" fetch --all -p || true
+    git -C "$SRC" reset --hard HEAD || true
+    git -C "$SRC" clean -fdx || true
+  else
+    rm -rf "$SRC"
+    git clone --depth 1 https://github.com/NVIDIA/apex "$SRC"
+  fi
+  echo "[build] Compilando Apex -> wheel"
+  export APEX_CPP_EXT=1 APEX_CUDA_EXT=1 APEX_ALL_CONTRIB_EXT=0
+  python -m pip wheel -v --no-build-isolation --no-deps "$SRC" -w /app/wheels || true
+  local W="$(ls -t /app/wheels/apex-*.whl 2>/dev/null | head -n1 || true)"
+  if [ -n "${W}" ]; then
+    python -m pip install -v -U --no-deps "${W}" || true
+    echo "[build] Apex instalado da wheel recém-compilada: ${W}"
+  else
+    echo "[build] Nenhuma wheel Apex gerada; instalando do source"
+    python -m pip install -v --no-build-isolation "$SRC" || true
+  fi
+}
+
+Q8_REPO="${Q8_REPO:-https://github.com/Lightricks/LTX-Video-Q8-Kernels.git}"
+Q8_COMMIT="${Q8_COMMIT:-f3066edea210082799ca5a2bbf9ef0321c5dd8fc}"
+build_q8 () {
+  local SRC="/app/wheels/src/q8_kernels"
+  rm -rf "$SRC"
+  git clone --filter=blob:none "$Q8_REPO" "$SRC"
+  git -C "$SRC" checkout "$Q8_COMMIT"
+  git -C "$SRC" submodule update --init --recursive
+  echo "[build] Compilando Q8 Kernels -> wheel"
+  python -m pip wheel -v --no-build-isolation "$SRC" -w /app/wheels || true
+  local W="$(ls -t /app/wheels/q8_kernels-*.whl 2>/dev/null | head -n1 || true)"
+  if [ -n "${W}" ]; then
+    python -m pip install -v -U --no-deps "${W}" || true
+    echo "[build] Q8 instalado da wheel recém-compilada: ${W}"
+  else
+    echo "[build] Nenhuma wheel q8_kernels gerada; instalando do source"
+    python -m pip install -v --no-build-isolation "$SRC" || true
+  fi
+}
+
+# ============================================================================
+#                               EXECUÇÃO
+# ============================================================================
+
+# Passo adicional SEM depender de "flash-attn" já instalado: trata somente o layer_norm
+build_or_install_flash_layer_norm || true
+
+# Apex (mantido)
+# Tenta primeiro via wheel no HF e, se não houver, compila e instala em wheel
+echo "[flow] === apex ==="
+HF_OUT="$(install_from_hf_by_prefix "apex" || true)"
+if [ -n "${HF_OUT:-}" ]; then
+  WHEEL_PATH="$(printf "%s\n" "${HF_OUT}" | tail -n1)"
+  echo "[hub] Baixado: ${WHEEL_PATH}"
+  python -m pip install -v -U --no-build-isolation "${WHEEL_PATH}" || true
+  if ! check_apex; then
+    echo "[flow] apex: import falhou após wheel; compilando"
+    build_apex || true
+  fi
+else
+  echo "[hub] Nenhuma wheel apex compatível; compilando"
+  build_apex || true
+fi
+
+# Q8 (opcional)
+# echo "[flow] === q8_kernels ==="
+# HF_OUT="$(install_from_hf_by_prefix "q8_kernels" || true)"
+# if [ -n "${HF_OUT:-}" ]; then
+#   WHEEL_PATH="$(printf "%s\n" "${HF_OUT}" | tail -n1)"
+#   echo "[hub] Baixado: ${WHEEL_PATH}"
+#   python -m pip install -v -U --no-build-isolation "${WHEEL_PATH}" || true
+#   if ! check_q8; then
+#     echo "[flow] q8_kernels: import falhou após wheel; compilando"
+#     build_q8 || true
+#   fi
+# else
+#   echo "[hub] Nenhuma wheel q8_kernels compatível; compilando"
+#   build_q8 || true
+# fi
+
+# Upload de wheels produzidas para o HF (cache cross-restarts)
+python - <<'PY'
+import os
+from huggingface_hub import HfApi, HfFolder
+
+repo = os.environ.get("SELF_HF_REPO_ID","euIaxs22/Aduc-sdr")
+token = os.getenv("HF_TOKEN") or HfFolder.get_token()
+if not token:
+    raise SystemExit("HF_TOKEN ausente; upload desabilitado")
+
+api = HfApi(token=token)
+api.upload_folder(
+    folder_path="/app/wheels",
+    repo_id=repo,
+    repo_type="model",
+    allow_patterns=["*.whl","NGC-DL-CONTAINER-LICENSE"],
+    ignore_patterns=["**/src/**","**/*.log","**/logs/**",".git/**"],
+)
+print("Upload concluído (wheels + licença).")
+PY
+
+chmod -R 777 /app/wheels || true
+echo "✅ Builder finalizado."

info.sh

@@ -0,0 +1,154 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+echo "================= RUNTIME CAPABILITIES ================="
+date
+
+echo
+if command -v nvidia-smi >/dev/null 2>&1; then
+  nvidia-smi
+else
+  echo "nvidia-smi: not available"
+fi
+echo
+
+echo "CUDA_HOME: ${CUDA_HOME:-/usr/local/cuda}"
+if command -v nvcc >/dev/null 2>&1; then
+  nvcc --version || true
+else
+  echo "nvcc: not available"
+fi
+echo
+
+echo "[PyTorch / CUDA backend]"
+python3 - <<'PY'
+import json, os, torch, inspect
+
+def to_bool(x):
+    try:
+        if callable(x):
+            try:
+                sig = inspect.signature(x)
+                if len(sig.parameters)==0:
+                    return bool(x())
+            except Exception:
+                pass
+            return True
+        return bool(x)
+    except Exception:
+        return None
+
+info = {
+    "torch": getattr(torch, "__version__", None),
+    "cuda_available": torch.cuda.is_available(),
+    "cuda_device_count": torch.cuda.device_count(),
+    "cuda_runtime_version": getattr(torch.version, "cuda", None),
+    "cudnn_version": torch.backends.cudnn.version() if torch.backends.cudnn.is_available() else None,
+    "tf32": (torch.backends.cuda.matmul.allow_tf32 if torch.cuda.is_available() else None),
+    "flash_sdp": (to_bool(getattr(torch.backends.cuda, "enable_flash_sdp", None)) if torch.cuda.is_available() else None),
+    "mem_efficient_sdp": (to_bool(getattr(torch.backends.cuda, "enable_mem_efficient_sdp", None)) if torch.cuda.is_available() else None),
+    "math_sdp": (to_bool(getattr(torch.backends.cuda, "enable_math_sdp", None)) if torch.cuda.is_available() else None),
+}
+print(json.dumps(info, indent=2))
+for i in range(min(torch.cuda.device_count(), 16)):
+    print(f"GPU {i}: {torch.cuda.get_device_name(i)}")
+PY
+echo
+
+echo "[Apex (FusedLayerNorm/RMSNorm)]"
+python3 - <<'PY'
+try:
+    from apex.normalization import FusedLayerNorm, FusedRMSNorm
+    import importlib; importlib.import_module("fused_layer_norm_cuda")
+    print("apex.normalization: OK")
+except Exception as e:
+    print("apex.normalization: FAIL ->", e)
+PY
+echo
+
+echo "[FlashAttention (CUDA/Triton/RMSNorm)]"
+python3 - <<'PY'
+import importlib
+mods = [
+    'flash_attn', 'flash_attn_2_cuda',
+    'flash_attn.ops.rms_norm', 'flash_attn.ops.layer_norm',
+    'flash_attn.layers.layer_norm'
+]
+for m in mods:
+    try:
+        importlib.import_module(m)
+        print(f"{m}: OK")
+    except Exception as e:
+        print(f"{m}: FAIL -> {e}")
+PY
+echo
+
+echo "[FlashAttention versão/details]"
+python3 - <<'PY'
+try:
+    import flash_attn
+    fa_ver = getattr(flash_attn, "__version__", None)
+    print(f"flash_attn: {fa_ver}")
+except Exception:
+    print("flash_attn: not importable.")
+try:
+    import torch
+    print(f"torch: {torch.__version__} | cuda: {getattr(torch.version, 'cuda', None)}")
+except Exception:
+    pass
+PY
+echo
+
+echo "[Triton]"
+python3 - <<'PY'
+try:
+    import triton
+    print("triton:", triton.__version__)
+    try:
+        import triton.ops as _; print("triton.ops: OK")
+    except Exception:
+        print("triton.ops: not present (ok on Triton>=3.x)")
+except Exception as e:
+    print("triton: FAIL ->", e)
+PY
+echo
+
+echo "[BitsAndBytes (Q8/Q4)]"
+python3 - <<'PY'
+try:
+    import bitsandbytes as bnb
+    print("bitsandbytes:", bnb.__version__)
+    try:
+        from bitsandbytes.triton import _custom_ops as _; print("bnb.triton._custom_ops: OK")
+    except Exception as e:
+        print("bnb.triton: partial ->", e)
+except Exception as e:
+    print("bitsandbytes: FAIL ->", e)
+PY
+echo
+
+echo "[Transformers / Diffusers / XFormers / EcoML]"
+python3 - <<'PY'
+def _v(m):
+    try:
+        mod = __import__(m)
+        print(f"{m}: {getattr(mod, '__version__', 'unknown')}")
+    except Exception as e:
+        print(f"{m}: FAIL -> {e}")
+for m in ("transformers", "diffusers", "xformers", "ecuml", "mlx", "ecobase"):
+    _v(m)
+PY
+echo
+
+echo "[Distribuído / NCCL Env]"
+env | grep -E '^(CUDA_VISIBLE_DEVICES|NCCL_|TORCH_|ENABLE_.*SDP|HF_HUB_.*|CUDA_|NV_.*NCCL.*|PYTORCH_CUDA_ALLOC_CONF)=' | sort
+echo
+
+echo "[Output dir/perms]"
+OUT="/app/outputs"
+echo "OUT dir: $OUT"
+mkdir -p "$OUT"
+ls -la "$OUT" || true
+
+echo "================= END CAPABILITIES ================="

start.sh

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# =======================
+# SeedVR — start UI
+# =======================
+
+
+# 1) Builder (garante Apex/Flash e deps CUDA)
+echo "🛠️  Iniciando o builder.sh para compilar/instalar dependências CUDA..."
+if [ -f "/app/builder.sh" ]; then
+  /bin/bash /app/builder.sh
+  echo "✅ Builder finalizado."
+else
+  echo "⚠️  Aviso: builder.sh não encontrado. Pulando etapa de compilação de dependências."
+fi
+
+# Pastas e variáveis (podem ser sobrescritas via env)
+export SEEDVR_ROOT="${SEEDVR_ROOT:-/data/SeedVR}"
+export CKPTS_ROOT="${CKPTS_ROOT:-/data/ckpts/SeedVR2-3B}"
+export OUTPUT_ROOT="${OUTPUT_ROOT:-/app/outputs}"
+export INPUT_ROOT="${INPUT_ROOT:-/app/inputs}"
+
+# Transformers v5 recomenda HF_HOME
+export HF_HOME="${HF_HOME:-/data/.cache/huggingface}"
+export HF_TOKEN="${HF_TOKEN:-${HUGGINGFACE_TOKEN:-}}"
+
+# Repo/model identifiers
+export SEEDVR_GIT_URL="${SEEDVR_GIT_URL:-https://github.com/ByteDance-Seed/SeedVR.git}"
+export SEEDVR_REPO_ID="${SEEDVR_REPO_ID:-ByteDance-Seed/SeedVR2-3B}"
+
+# Multi-GPU / torchrun
+export NUM_GPUS="${NUM_GPUS:-8}"
+export NCCL_P2P_LEVEL="${NCCL_P2P_LEVEL:-NVL}"
+export NCCL_ASYNC_ERROR_HANDLING="${NCCL_ASYNC_ERROR_HANDLING:-1}"
+export OMP_NUM_THREADS="${OMP_NUM_THREADS:-8}"
+
+# Gradio
+export GRADIO_SERVER_NAME="${GRADIO_SERVER_NAME:-0.0.0.0}"
+export GRADIO_SERVER_PORT="${GRADIO_SERVER_PORT:-7860}"
+
+mkdir -p "$SEEDVR_ROOT" "$CKPTS_ROOT" "$OUTPUT_ROOT" "$INPUT_ROOT" "$HF_HOME"
+
+echo "[seedvr][start] checking environment..."
+command -v python >/dev/null || { echo "[seedvr][start] python not found"; exit 1; }
+command -v nvidia-smi >/dev/null && nvidia-smi || echo "[seedvr][start] warn: nvidia-smi not available"
+
+echo "[seedvr][start] cloning repo if missing: $SEEDVR_ROOT"
+if [ ! -d "$SEEDVR_ROOT/.git" ]; then
+  git clone "$SEEDVR_GIT_URL" "$SEEDVR_ROOT"
+else
+  echo "[seedvr][start] repo present"
+fi
+
+echo "[seedvr][start] downloading model (snapshot_download) into $CKPTS_ROOT"
+python - <<PY
+import os
+from pathlib import Path
+from huggingface_hub import snapshot_download
+
+repo_id = os.environ["SEEDVR_REPO_ID"]
+save_dir = os.environ["CKPTS_ROOT"]
+cache_dir = os.environ["HF_HOME"]
+token = os.environ.get("HF_TOKEN") or None
+
+Path(save_dir).mkdir(parents=True, exist_ok=True)
+snapshot_download(
+  repo_id=repo_id,
+  cache_dir=cache_dir,
+  local_dir=save_dir,
+  local_dir_use_symlinks=False,
+  resume_download=True,
+  allow_patterns=["*.json", "*.safetensors", "*.pth", "*.bin", "*.py", "*.md", "*.txt"],
+  token=token,
+)
+print("[seedvr][start] snapshot_download ok:", save_dir)
+PY
+
+
+export OUTPUT_ROOT=/app/outputs
+mkdir -p "$OUTPUT_ROOT" && chmod -R 777 "$OUTPUT_ROOT" || true
+
+
+echo "[seedvr][start] ensuring ckpt symlink SeedVR/ckpts/SeedVR2-3B -> $CKPTS_ROOT"
+mkdir -p "$SEEDVR_ROOT/ckpts"
+if [ -L "$SEEDVR_ROOT/ckpts/SeedVR2-3B" ]; then
+  target="$(readlink -f "$SEEDVR_ROOT/ckpts/SeedVR2-3B" || true)"
+  if [ "$target" != "$CKPTS_ROOT" ]; then
+    rm -f "$SEEDVR_ROOT/ckpts/SeedVR2-3B"
+  fi
+fi
+if [ ! -e "$SEEDVR_ROOT/ckpts/SeedVR2-3B" ]; then
+  ln -s "$CKPTS_ROOT" "$SEEDVR_ROOT/ckpts/SeedVR2-3B"
+fi
+
+echo "[seedvr][start] launching app_seedvr.py at ${GRADIO_SERVER_NAME}:${GRADIO_SERVER_PORT}"
+exec python app_seedvr.py