Upload 6 files

Dockerfile.txt

@@ -0,0 +1,126 @@
+# =============================================================================
+# 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 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
+
+# App paths
+ENV APP_HOME=/app
+WORKDIR $APP_HOME
+
+# Persistent data and caches in /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
+
+# Create non-root user and data dirs early, fix ownership
+RUN useradd -m -u 1000 -s /bin/bash appuser && \
+    mkdir -p /data /data/models \
+             /data/.cache/huggingface /data/.cache/torch \
+             /data/.cache/datasets /data/.cache/transformers /data/.cache/diffusers && \
+    chown -R appuser:appuser /data
+
+# Models live in /data/models and are visible at /app/models
+ENV MODELS_DIR=/data/models
+RUN ln -sf /data/models /app/models
+
+# ---------------- System & Python ----------------
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential gosu tree cmake git git-lfs curl wget ffmpeg ninja-build \
+    python3.10 python3.10-dev python3.10-distutils python3-pip \
+    ca-certificates libglib2.0-0 libgl1 \
+ && 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 (pinned) ----------------
+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 (no bnb build) ----------------
+RUN pip install packaging ninja cmake pybind11 scikit-build cython hf_transfer "numpy>=1.24.4"
+
+# Triton 3.x (no 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
+
+# ---------------- App dependencies ----------------
+COPY requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Pin bnb to avoid surprise CUDA/PTX mismatches (adjust as needed)
+RUN pip install --upgrade bitsandbytes
+
+# Custom .whl (Apex + dropout_layer_norm)
+RUN echo "Installing custom wheels..." && \
+    pip install --no-cache-dir \
+      "https://huggingface.co/euIaxs22/Aduc-sdr/resolve/main/apex-0.1-cp310-cp310-linux_x86_64.whl" \
+      "https://huggingface.co/euIaxs22/Aduc-sdr/resolve/main/dropout_layer_norm-0.1-cp310-cp310-linux_x86_64.whl"
+
+# ====================================================================
+# Optional: q8_kernels + LTX-Video (enable if needed; ensure wheel ABI)
+RUN pip install --no-cache-dir \
+   "https://huggingface.co/euIaxs22/Aduc-sdr/resolve/main/q8_kernels-0.0.5-cp310-cp310-linux_x86_64.whl"
+# RUN git clone https://github.com/Lightricks/LTX-Video.git /data/LTX-Video && \
+#     cd /data/LTX-Video && python -m pip install -e .[inference]
+# ====================================================================
+
+# Scripts and app
+COPY info.sh ./app/info.sh
+COPY builder.sh ./app/builder.sh
+COPY start.sh ./app/start.sh
+COPY entrypoint.sh ./app/entrypoint.sh
+
+# Copy the rest of the source last for better caching
+COPY . .
+
+# Permissions on app tree
+RUN chown -R appuser:appuser /app /data && \
+    chmod 0755 /app/entrypoint.sh /app/start.sh /app/info.sh /app/builder.sh
+
+VOLUME /data
+
+ENTRYPOINT ["/app/entrypoint.sh"]
+USER appuser
+
+# ---------------- Entry ----------------
+CMD ["/app/start.sh"]

builder.sh

@@ -0,0 +1,346 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "🚀 Builder (FlashAttn LayerNorm extra + Apex + Q8) — runtime com GPU visível"
+
+# ===== Config e diretórios =====
+
+
+mkdir -p /app/wheels /app/cuda_cache /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}"
+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_q8 || 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."

compose.yaml.txt

@@ -0,0 +1,26 @@
+services:
+  vincie:
+    image: img2img:edit
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - capabilities: [gpu]
+    ports:
+      - "7860:7860"
+    environment:
+      GRADIO_SERVER_PORT: "7860"
+      HF_HUB_CACHE: "/data/.cache/huggingface/hub"
+      CKPT_ROOT: "/data/ckpt/VINCIE-3B"
+      VINCIE_ROOT: "/data/VINCIE"
+    volumes:
+      - vincie_hub:/data/.cache/huggingface/hub
+      - vincie_ckpt:/data/ckpt/VINCIE-3B
+      - vincie_out:/app/outputs
+      - vincie_repo:/data/VINCIE
+volumes:
+  vincie_hub: {}
+  vincie_ckpt: {}
+  vincie_out: {}
+  vincie_repo: {}
+  

entrypoint.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+# entrypoint.sh - Executado como root para corrigir permissões.
+set -e
+
+echo "🔐 ENTRYPOINT (root): Corrigindo permissões para os diretórios de dados e saída..."
+
+# Lista de diretórios a serem criados e terem suas permissões ajustadas
+# Usamos os valores padrão, pois as variáveis de ambiente podem não estar disponíveis aqui.
+DIRS_TO_OWN="/app/outputs /app/inputs"
+
+# Garante que os diretórios existam
+mkdir -p $DIRS_TO_OWN
+
+# Muda o proprietário para o UID e GID 1000, que corresponde ao 'appuser'
+# Usar UID/GID é mais robusto em ambientes de contêiner.
+chown -R 1000:1000 $DIRS_TO_OWN
+
+echo "✅ ENTRYPOINT (root): Permissões corrigidas."
+
+# Passa a execução para o comando principal (CMD) definido no Dockerfile.
+exec "$@"

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,54 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+tree -L 4 /app
+tree -L 4 /data
+
+echo "🚀 Iniciando o script de setup e lançamento do LTX-Video..."
+echo "Usuário atual: $(whoami)"
+
+# Define as variáveis de ambiente que o LTXServer irá consumir
+export HF_HOME="${HF_HOME:-/data/.cache/huggingface}"
+export OUTPUT_ROOT="${OUTPUT_ROOT:-/app/outputs/ltx}"
+export LTXV_FRAME_LOG_EVERY=8
+export LTXV_DEBUG=1
+
+
+# --- Garante que Diretórios Existam ---
+mkdir -p "$OUTPUT_ROOT" "$HF_HOME"
+
+
+# 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
+
+#python3 - <<'PY'
+#import os
+#from services.ltx_server import ltx_server_singleton as server
+#try:
+#  server.setup_dependencies()
+#except Exception as e:
+#  print("Erro no setup")
+#PY
+
+cp -rfv /app/LTX-Video/ /data/
+
+export OUTPUT_ROOT="${OUTPUT_ROOT:-/app/outputs}"
+export INPUT_ROOT="${INPUT_ROOT:-/app/inputs}"
+
+mkdir -p "$OUTPUT_ROOT" "$INPUT_ROOT"
+echo "[aduc][start] Verificando ambiente como usuário: $(whoami)"
+
+# Env da UI
+export GRADIO_SERVER_NAME="0.0.0.0"
+export GRADIO_SERVER_PORT="${PORT:-7860}"
+export GRADIO_ENABLE_QUEUE="True"
+
+echo "[ltx][start] Lançando app_ltx.py..."
+# Executa diretamente o python.
+exec python /app/app.py