Upload 6 files

Dockerfile.1

@@ -0,0 +1,37 @@
+FROM nvidia/cuda:12.4.1-devel-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV HF_HOME=/app/model_cache
+ENV HF_HUB_CACHE=/app/model_cache/hub
+ENV TORCH_HOME=/app/model_cache/torch
+WORKDIR /app
+
+# Sistema e toolchain
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3.10 python3.10-dev python3.10-distutils python3-pip \
+    git wget curl ffmpeg libglib2.0-0 libsm6 libxext6 libxrender-dev \
+    libgomp1 build-essential ninja-build cmake \
+ && 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 2.6.0 + cu124
+RUN pip install --no-cache-dir --index-url https://download.pytorch.org/whl/cu124 \
+      torch==2.6.0 torchvision torchaudio
+
+# Dependências Python base do app (sem FA/Apex aqui)
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt \
+ && pip install --no-cache-dir "tiktoken>=0.7,<0.9"
+
+# Copiar app e start
+COPY . .
+RUN chmod +x ./start.sh
+
+# Usuário não-root
+RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
+USER appuser
+ENV PORT=7860
+CMD ["./start.sh"]

app.py

@@ -1,13 +1,18 @@
 #!/usr/bin/env python3
+import os
+import glob
 import gradio as gr
 from pathlib import Path
-from typing import List
+from typing import List, Tuple, Optional
+
 from vincie_service import VincieService
 
-svc = VincieService()
+svc = VincieService()  # usa /app/VINCIE e /app/ckpt/VINCIE-3B por padrão
 
-def setup():
-    # opcional: preparar ambiente na primeira execução
+def setup() -> str:
+    """
+    Prepara repositório e modelos (idempotente).
+    """
     try:
         svc.ensure_repo()
         svc.ensure_model()
@@ -15,64 +20,95 @@ def setup():
         return f"Setup falhou: {e}"
     return "Setup OK"
 
+def _list_media(out_dir: Path, max_images: int = 24) -> Tuple[List[str], Optional[str]]:
+    """
+    Varre o diretório de saída por imagens e vídeo, retornando caminhos ordenados.
+    """
+    exts_img = ("*.png", "*.jpg", "*.jpeg", "*.webp")
+    imgs: List[Path] = []
+    for pat in exts_img:
+        imgs += list(out_dir.rglob(pat))
+    imgs = sorted(imgs, key=lambda p: p.stat().st_mtime)
+    imgs_paths = [str(p) for p in imgs[-max_images:]] if imgs else []
+
+    vids = sorted(out_dir.rglob("*.mp4"), key=lambda p: p.stat().st_mtime)
+    vid_path = str(vids[-1]) if vids else None
+    return imgs_paths, vid_path
+
 def ui_multi_turn(input_image, turns_text):
-    if not input_image or not turns_text.strip():
-        return "Forneça imagem e turns (um por linha)."
+    """
+    Executa multi-turn editing e retorna mídia do diretório de saída.
+    """
+    if not input_image or not str(input_image).strip():
+        return [], None, "Forneça uma imagem."
+    if not turns_text or not turns_text.strip():
+        return [], None, "Forneça turns (um por linha)."
+
     turns = [ln.strip() for ln in turns_text.splitlines() if ln.strip()]
-    out_dir = svc.multi_turn_edit(input_image, turns)
-    return f"Gerado em: {str(out_dir)}"
+    try:
+        out_dir = svc.multi_turn_edit(input_image, turns)
+    except Exception as e:
+        return [], None, f"Erro na geração: {e}"
+
+    imgs, vid = _list_media(Path(out_dir))
+    status = f"Gerado em: {str(out_dir)}"
+    return imgs, vid, status
 
 def ui_multi_concept(files, descs_text, final_prompt):
-    if not files or not descs_text.strip() or not final_prompt.strip():
-        return "Envie imagens, descrições (uma por linha) e o prompt final."
+    """
+    Executa composição multi-conceito e retorna mídia do diretório de saída.
+    """
+    if not files:
+        return [], None, "Envie imagens de conceito."
+    if not descs_text or not descs_text.strip():
+        return [], None, "Forneça descrições (uma por linha)."
+    if not final_prompt or not final_prompt.strip():
+        return [], None, "Forneça o prompt final."
+
     descs = [ln.strip() for ln in descs_text.splitlines() if ln.strip()]
     if len(descs) != len(files):
-        return f"Número de descrições ({len(descs)}) difere do número de imagens ({len(files)})."
-    out_dir = svc.multi_concept_compose([f.name if hasattr(f, 'name') else str(f) for f in files],
-                                        descs, final_prompt)
-    return f"Gerado em: {str(out_dir)}"
+        return [], None, f"Número de descrições ({len(descs)}) difere do número de imagens ({len(files)})."
+
+    try:
+        out_dir = svc.multi_concept_compose(files, descs, final_prompt)
+    except Exception as e:
+        return [], None, f"Erro na geração: {e}"
+
+    imgs, vid = _list_media(Path(out_dir))
+    status = f"Gerado em: {str(out_dir)}"
+    return imgs, vid, status
 
 with gr.Blocks(title="VINCIE Service") as demo:
-    gr.Markdown("# 🎨 VINCIE Service")
-    setup_btn = gr.Button("Preparar repositório e modelo (uma vez)")
-    setup_out = gr.Textbox(label="Status")
+    gr.Markdown("# 🎨 VINCIE Service — Multi-turn e Multi-concept")
+
+    with gr.Row():
+        setup_btn = gr.Button("Preparar (repo + modelos)")
+        setup_out = gr.Textbox(label="Status", interactive=False)
     setup_btn.click(fn=setup, outputs=setup_out)
 
     with gr.Tab("🔄 Multi-turn Editing"):
-        img = gr.Image(type="filepath", label="Imagem inicial")
-        turns = gr.Textbox(lines=6, label="Turns (um por linha)")
+        with gr.Row():
+            img = gr.Image(type="filepath", label="Imagem inicial")
+            turns = gr.Textbox(lines=8, label="Turns (um por linha)")
         run1 = gr.Button("Executar")
-        out1 = gr.Textbox(label="Saída")
-        run1.click(ui_multi_turn, inputs=[img, turns], outputs=out1)
+        out_gallery = gr.Gallery(label="Imagens", columns=4, height="auto")
+        out_video = gr.Video(label="Vídeo (se houver)")
+        out_status = gr.Textbox(label="Saída", interactive=False)
+        run1.click(ui_multi_turn, inputs=[img, turns], outputs=[out_gallery, out_video, out_status])
 
-    with gr.Tab("🎭 Multi-concept Composition"):
-        files = gr.File(file_count="multiple", file_types=["image"], label="Imagens conceito")
-        descs = gr.Textbox(lines=6, label="Descrições p/ <IMG0>, <IMG1>, ... (uma por linha)")
-        finalp = gr.Textbox(lines=3, label="Prompt final")
+    with gr.Tab("🧩 Multi-concept Compose"):
+        files = gr.File(file_count="multiple", type="filepath", label="Imagens de conceito")
+        descs = gr.Textbox(lines=8, label="Descrições (uma por linha, na mesma ordem das imagens)")
+        final_prompt = gr.Textbox(lines=2, label="Prompt final")
         run2 = gr.Button("Executar")
-        out2 = gr.Textbox(label="Saída")
-        run2.click(ui_multi_concept, inputs=[files, descs, finalp], outputs=out2)
+        out_gallery2 = gr.Gallery(label="Imagens", columns=4, height="auto")
+        out_video2 = gr.Video(label="Vídeo (se houver)")
+        out_status2 = gr.Textbox(label="Saída", interactive=False)
+        run2.click(ui_multi_concept, inputs=[files, descs, final_prompt], outputs=[out_gallery2, out_video2, out_status2])
 
-# --- <INÍCIO DA ATUALIZAÇÃO> ---
 if __name__ == "__main__":
-    import sys
-    
-    # Define os padrões de inicialização
-    share_option = False
-    server_name = "127.0.0.1"
-
-    # Verifica se argumentos foram passados na linha de comando
-    if '--share' in sys.argv:
-        share_option = True
-        print("Iniciando com a opção de compartilhamento público (share=True)")
-
-    if '--listen' in sys.argv:
-        server_name = "0.0.0.0"
-        print("Iniciando para ser acessível na rede local (listen)")
-
-    # Inicia a aplicação com as opções definidas
-    demo.queue().launch(
-        debug=True, 
-        share=share_option,
-        server_name=server_name
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.getenv("PORT", "7860")),
+        allowed_paths=["/app/outputs", "/app/ckpt"]
     )

start.sh

@@ -1,95 +1,163 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-echo "🚀 Complete AI Video Suite - Docker Container Starting..."
-echo "🐳 Container: $(hostname)"
-echo "👤 User: $(whoami)"
-echo "🎮 GPUs: $(nvidia-smi --list-gpus | wc -l || echo '0')"
-
-if command -v nvidia-smi >/dev/null 2>&1; then
-  echo "💾 CUDA Memory:"
-  nvidia-smi --query-gpu=memory.total,memory.used --format=csv,noheader,nounits | nl
-fi
+echo "🚀 Starting runtime bootstrap..."
 
-# Básico
-export CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES:-0,1,2,3,4,5,6,7}
-export HF_HOME=${HF_HOME:-/app/model_cache}
-export OUTPUT_DIR=${OUTPUT_DIR:-/app/outputs}
-mkdir -p "$HF_HOME" "$OUTPUT_DIR" /app/ckpt/VINCIE-3B
+# ========= Config gerais =========
+# Repo no Hub que hospeda os wheels pré-compilados (altere se necessário)
+export SELF_HF_REPO_ID="${SELF_HF_REPO_ID:-XCarleX/Apex-l40s}"
 
-# Clonar VINCIE se não existir
-if [ ! -d "/app/VINCIE" ]; then
-  echo "📦 Clonando VINCIE..."
-  git clone https://github.com/ByteDance-Seed/VINCIE /app/VINCIE
-fi
+# Aceleração para Ada / L40S
+export TORCH_CUDA_ARCH_LIST="${TORCH_CUDA_ARCH_LIST:-8.9}"
 
-# Baixar modelo
-python3 - <<'PY'
-from huggingface_hub import snapshot_download
-import os
-save_dir = '/app/ckpt/VINCIE-3B'
-os.makedirs(save_dir, exist_ok=True)
-try:
-    print('📥 Baixando VINCIE-3B...')
-    snapshot_download(
-        repo_id='ByteDance-Seed/VINCIE-3B',
-        local_dir=save_dir,
-        resume_download=True,
-        local_dir_use_symlinks=False
-    )
-    print('✅ Modelo ok')
-except Exception as e:
-    print(f'⚠️ Download falhou: {e}')
-PY
+# Paralelismo (ajuste conforme a máquina)
+export MAX_JOBS="${MAX_JOBS:-64}"
+export CMAKE_BUILD_PARALLEL_LEVEL="${CMAKE_BUILD_PARALLEL_LEVEL:-64}"
+export NVCC_APPEND_FLAGS="${NVCC_APPEND_FLAGS:---threads 16}"
 
+# Caches persistentes
+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}"
+mkdir -p /app/wheels /app/cuda_cache "$HF_HOME" "$TORCH_HOME"
+export CUDA_CACHE_PATH="/app/cuda_cache"
 
-# Garantir dit.pth e vae.pth por nome
-python3 - <<'PY'
-import os
-from huggingface_hub import hf_hub_download
-
-save_dir = '/app/ckpt/VINCIE-3B'
-os.makedirs(save_dir, exist_ok=True)
-
-needed = ['dit.pth', 'vae.pth']
-for fn in needed:
-    p = os.path.join(save_dir, fn)
-    if not (os.path.exists(p) and os.path.getsize(p) > 1024*1024):
-        print(f'Baixando {fn}...')
-        hf_hub_download(repo_id='ByteDance-Seed/VINCIE-3B', filename=fn, local_dir=save_dir)
-print('✅ Checkpoints ok')
+# Mostrar estado do Torch/ABI
+python - <<'PY'
+import torch, os
+print("Torch:", torch.__version__, "CUDA:", torch.version.cuda, "SM:", os.environ.get("TORCH_CUDA_ARCH_LIST"))
+print("ABI:", int(torch._C._GLIBCXX_USE_CXX11_ABI))
 PY
 
-# Compatibilidade com caminho relativo do repo (ckpt/VINCIE-3B)
-mkdir -p /app/VINCIE/ckpt
-ln -sfn /app/ckpt/VINCIE-3B /app/VINCIE/ckpt/VINCIE-3B
-
-
-# Verificar flash-attn (sem reinstalar em user site)
-python - <<'PY'
+# ========= Hugging Face Hub utils (com aceleração opcional) =========
+python -m pip install -q -U "huggingface_hub[hf_transfer]" || python -m pip install -q -U huggingface_hub
+export HF_HUB_ENABLE_HF_TRANSFER="${HF_HUB_ENABLE_HF_TRANSFER:-1}"
+
+# Função: baixar wheel do próprio repo (pasta wheels/)
+fetch_wheel () {
+  local KIND="$1"  # "flash" | "apex"
+  python - <<'PY'
+import os, re
+from huggingface_hub import HfApi, hf_hub_download
+repo_id = os.environ["SELF_HF_REPO_ID"]
+kind = os.environ["KIND"]
+pat = r"wheels/flash_attn-.*\.whl" if kind=="flash" else r"wheels/apex-.*\.whl"
+api = HfApi()
 try:
-    import torch, flash_attn
-    print(f"✅ Flash-attn pronto (Torch {torch.__version__}, CUDA {torch.version.cuda})")
+    files = api.list_repo_files(repo_id=repo_id, repo_type="model")
+    cands = [f for f in files if re.match(pat, f)]
+    if cands:
+        target = sorted(cands)[-1]
+        p = hf_hub_download(repo_id=repo_id, filename=target, repo_type="model")
+        print(p)
 except Exception as e:
-    print(f"⚠️ Flash-attn indisponível: {e}")
-    print("➡️ Seguindo com fallback (atenção nativa do PyTorch).")
+    pass
 PY
+}
+
+# Função: enviar wheel recém-compilada para o repo (requer HF_TOKEN com write)
+upload_wheel () {
+  local WHEEL_PATH="$1"
+  if [ "${HF_UPLOAD_WHEELS:-0}" != "1" ]; then
+    return 0
+  fi
+  python - <<'PY'
+import os
+from huggingface_hub import HfApi
+repo_id = os.environ["SELF_HF_REPO_ID"]
+wheel = os.environ["WHEEL_PATH"]
+dst = "wheels/" + os.path.basename(wheel)
+api = HfApi()
+api.upload_file(path_or_fileobj=wheel, path_in_repo=dst, repo_id=repo_id, repo_type="model")
+print("Uploaded:", dst)
+PY
+}
 
+# ========= FlashAttention (reuso de wheel ou build) =========
+if python - >/dev/null 2>&1 <<'PY'
+import flash_attn, torch
+print("ok")
+PY
+then
+  echo "✅ flash-attn já instalado"
+else
+  echo "ℹ️ Buscando wheel de flash-attn em ${SELF_HF_REPO_ID}..."
+  if W=$(KIND=flash fetch_wheel) && [ -n "${W:-}" ]; then
+    echo "📦 Instalando flash-attn do repo: $W"
+    python -m pip install -U "$W"
+  else
+    echo "⚙️ Compilando flash-attn e salvando wheel local..."
+    python -m pip wheel --no-build-isolation --no-binary :all: flash-attn==2.7.4.post1 -w /app/wheels
+    python -m pip install -U /app/wheels/flash_attn-2.7.4.post1-*.whl
+    if WHEEL_PATH=$(ls /app/wheels/flash_attn-2.7.4.post1-*.whl 2>/dev/null | head -n1); then
+      WHEEL_PATH="$WHEEL_PATH" upload_wheel || true
+    fi
+  fi
+fi
 
+# ========= NVIDIA Apex (núcleo; reuso de wheel ou build) =========
+# Testar se fused_layer_norm_cuda está presente
+if python - >/dev/null 2>&1 <<'PY'
+import importlib
+from apex.normalization import FusedLayerNorm
+importlib.import_module("fused_layer_norm_cuda")
+print("ok")
+PY
+then
+  echo "✅ Apex com fused_layer_norm_cuda já instalado"
+else
+  echo "ℹ️ Buscando wheel de Apex em ${SELF_HF_REPO_ID}..."
+  if W=$(KIND=apex fetch_wheel) && [ -n "${W:-}" ]; then
+    echo "📦 Instalando Apex do repo: $W"
+    python -m pip install -U "$W" || true
+  fi
+
+  # Validar após tentativa do repo
+  if ! python - >/dev/null 2>&1 <<'PY'
+import importlib
+from apex.normalization import FusedLayerNorm
+importlib.import_module("fused_layer_norm_cuda")
+print("ok")
+PY
+  then
+    echo "⚙️ Compilando Apex (core) e salvando wheel local..."
+    rm -rf /tmp/apex && git clone --depth 1 https://github.com/NVIDIA/apex /tmp/apex
+    pushd /tmp/apex >/dev/null
+    export APEX_CPP_EXT=1 APEX_CUDA_EXT=1 APEX_ALL_CONTRIB_EXT=0
+    python -m pip wheel --no-build-isolation . -w /app/wheels
+    python -m pip install -U /app/wheels/apex-0.1-*.whl || python -m pip install -v --no-build-isolation .
+    popd >/dev/null
+
+    # Upload opcional do wheel
+    if WHEEL_PATH=$(ls /app/wheels/apex-0.1-*.whl 2>/dev/null | head -n1); then
+      WHEEL_PATH="$WHEEL_PATH" upload_wheel || true
+    fi
+
+    # Validação final
+    python - <<'PY'
+import importlib
+from apex.normalization import FusedLayerNorm, FusedRMSNorm
+print("Apex OK:", FusedLayerNorm, FusedRMSNorm)
+importlib.import_module("fused_layer_norm_cuda")
+print("fused_layer_norm_cuda OK")
+PY
+  fi
+fi
 
-# Copiar arquivos do serviço
-cp /app/vincie_service.py /app/VINCIE/ 2>/dev/null || echo "vincie_service.py não encontrado"
-cp /app/app.py /app/VINCIE/ 2>/dev/null || echo "app.py não encontrado"
+# ========= Vincie: garantir repo e checkpoints (hf_hub_download + local_dir) =========
+python - <<'PY'
+from vincie_service import VincieService
+svc = VincieService()
+svc.ensure_repo()
+svc.ensure_model()
+print("Service pronto:", svc.ready())
+PY
 
-# Determinar qual app executar
-if [ -f "/app/VINCIE/app.py" ]; then
-    echo "🚀 Iniciando VINCIE Service..."
-    cd /app/VINCIE
-    python3 app.py --listen --port ${PORT:-7861}
-elif [ -f "/app/app.py" ]; then
-    echo "🚀 Iniciando app.py..."
-    python3 /app/app.py --listen --port ${PORT:-7860}
+# ========= Iniciar app (ou Vince.sh se existir) =========
+if [ -x "./Vince.sh" ]; then
+  echo "▶️ Executando Vince.sh"
+  exec ./Vince.sh
 else
-    echo "❌ Nenhum app.py encontrado"
-    exit 1
+  echo "▶️ Executando app-32.py"
+  exec python app-32.py
 fi

vince.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "🚀 Complete AI Video Suite - Docker Container Starting..."
+echo "🐳 Container: $(hostname)"
+echo "👤 User: $(whoami)"
+echo "🎮 GPUs: $(nvidia-smi --list-gpus | wc -l || echo '0')"
+
+if command -v nvidia-smi >/dev/null 2>&1; then
+  echo "💾 CUDA Memory:"
+  nvidia-smi --query-gpu=memory.total,memory.used --format=csv,noheader,nounits | nl
+fi
+
+# Básico
+export CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES:-0,1,2,3,4,5,6,7}
+export HF_HOME=${HF_HOME:-/app/model_cache}
+export OUTPUT_DIR=${OUTPUT_DIR:-/app/outputs}
+mkdir -p "$HF_HOME" "$OUTPUT_DIR" /app/ckpt/VINCIE-3B
+
+# Clonar VINCIE se não existir
+if [ ! -d "/app/VINCIE" ]; then
+  echo "📦 Clonando VINCIE..."
+  git clone https://github.com/ByteDance-Seed/VINCIE /app/VINCIE
+fi
+
+# Baixar modelo
+python3 - <<'PY'
+from huggingface_hub import snapshot_download
+import os
+save_dir = '/app/ckpt/VINCIE-3B'
+os.makedirs(save_dir, exist_ok=True)
+try:
+    print('📥 Baixando VINCIE-3B...')
+    snapshot_download(
+        repo_id='ByteDance-Seed/VINCIE-3B',
+        local_dir=save_dir,
+        resume_download=True,
+        local_dir_use_symlinks=False
+    )
+    print('✅ Modelo ok')
+except Exception as e:
+    print(f'⚠️ Download falhou: {e}')
+PY
+
+
+# Garantir dit.pth e vae.pth por nome
+python3 - <<'PY'
+import os
+from huggingface_hub import hf_hub_download
+
+save_dir = '/app/ckpt/VINCIE-3B'
+os.makedirs(save_dir, exist_ok=True)
+
+needed = ['dit.pth', 'vae.pth']
+for fn in needed:
+    p = os.path.join(save_dir, fn)
+    if not (os.path.exists(p) and os.path.getsize(p) > 1024*1024):
+        print(f'Baixando {fn}...')
+        hf_hub_download(repo_id='ByteDance-Seed/VINCIE-3B', filename=fn, local_dir=save_dir)
+print('✅ Checkpoints ok')
+PY
+
+# Compatibilidade com caminho relativo do repo (ckpt/VINCIE-3B)
+mkdir -p /app/VINCIE/ckpt
+ln -sfn /app/ckpt/VINCIE-3B /app/VINCIE/ckpt/VINCIE-3B
+
+
+# Verificar flash-attn (sem reinstalar em user site)
+python - <<'PY'
+try:
+    import torch, flash_attn
+    print(f"✅ Flash-attn pronto (Torch {torch.__version__}, CUDA {torch.version.cuda})")
+except Exception as e:
+    print(f"⚠️ Flash-attn indisponível: {e}")
+    print("➡️ Seguindo com fallback (atenção nativa do PyTorch).")
+PY
+
+
+
+# Copiar arquivos do serviço
+cp /app/vincie_service.py /app/VINCIE/ 2>/dev/null || echo "vincie_service.py não encontrado"
+cp /app/app.py /app/VINCIE/ 2>/dev/null || echo "app.py não encontrado"
+
+# Determinar qual app executar
+if [ -f "/app/VINCIE/app.py" ]; then
+    echo "🚀 Iniciando VINCIE Service..."
+    cd /app/VINCIE
+    python3 app.py --listen --port ${PORT:-7861}
+elif [ -f "/app/app.py" ]; then
+    echo "🚀 Iniciando app.py..."
+    python3 /app/app.py --listen --port ${PORT:-7860}
+else
+    echo "❌ Nenhum app.py encontrado"
+    exit 1
+fi

vincie_service.py

@@ -12,10 +12,10 @@ class VincieService:
     """
     Serviço que:
     - garante que o repo VINCIE está presente
-    - baixa dit.pth e vae.pth de ByteDance-Seed/VINCIE-3B com hf_token (runtime)
-    - cria symlink de compatibilidade para ckpt/VINCIE-3B dentro do repo
-    - executa main.py com overrides oficiais (Hydra) para edição multi-turn e composição multi-conceito
-    - fornece um fallback (shim) para apex.normalization.FusedRMSNorm quando Apex não está instalado
+    - baixa dit.pth e vae.pth via hf_hub_download (local_dir)
+    - cria symlink /app/VINCIE/ckpt/VINCIE-3B -> /app/ckpt/VINCIE-3B
+    - executa main.py com overrides Hydra/YACS (multi-turn e multi-concept)
+    - fornece fallback (shim) para apex.normalization se Apex não existir
     """
 
     def __init__(
@@ -34,8 +34,6 @@ class VincieService:
         self.assets_dir = self.repo_dir / "assets"
         self.output_root = Path("/app/outputs")
         self.output_root.mkdir(parents=True, exist_ok=True)
-
-        # Garantir existência de pasta de ckpt relativa no repo para symlink
         (self.repo_dir / "ckpt").mkdir(parents=True, exist_ok=True)
 
     # ---------- Setup ----------
@@ -45,56 +43,21 @@ class VincieService:
         if not self.repo_dir.exists():
             subprocess.run(["git", "clone", git_url, str(self.repo_dir)], check=True)
 
-    def ensure_apex(self, enable_shim: bool = True) -> None:
-        """
-        Garante que apex.normalization.FusedRMSNorm está importável.
-        Se Apex não estiver instalado e enable_shim=True, cria um shim baseado em nn.RMSNorm.
-        """
-        try:
-            import importlib
-            importlib.import_module("apex.normalization")
-            return
-        except Exception:
-            if not enable_shim:
-                return
-
-        # Criar shim em /app/shims/apex/normalization.py
-        shim_root = Path("/app/shims")
-        apex_pkg = shim_root / "apex"
-        apex_pkg.mkdir(parents=True, exist_ok=True)
-
-        (apex_pkg / "__init__.py").write_text("from .normalization import *\n")
-
-        (apex_pkg / "normalization.py").write_text(
-            "import torch\n"
-            "import torch.nn as nn\n"
-            "\n"
-            "class FusedRMSNorm(nn.Module):\n"
-            "    def __init__(self, normalized_shape, eps=1e-6, elementwise_affine=True):\n"
-            "        super().__init__()\n"
-            "        self.mod = nn.RMSNorm(normalized_shape, eps=eps, elementwise_affine=elementwise_affine)\n"
-            "    def forward(self, x):\n"
-            "        return self.mod(x)\n"
-        )
-
-        # Tornar o shim visível neste processo e nos subprocessos
-        sys.path.insert(0, str(shim_root))
-        os.environ["PYTHONPATH"] = f"{str(shim_root)}:{os.environ.get('PYTHONPATH','')}"
-
     def ensure_model(self, hf_token: Optional[str] = None) -> None:
         """
         Baixa apenas os arquivos necessários do repo ByteDance-Seed/VINCIE-3B:
         - dit.pth
         - vae.pth
-        Usa hf_token (parâmetro ou variáveis HF_TOKEN/HUGGINGFACE_TOKEN).
-        Cria symlink de compatibilidade em /app/VINCIE/ckpt/VINCIE-3B -> /app/ckpt/VINCIE-3B.
+        Usa hf_hub_download com local_dir e cria symlink de compatibilidade.
         """
         self.ckpt_dir.mkdir(parents=True, exist_ok=True)
-
         token = hf_token or os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_TOKEN")
 
         def _need(p: Path) -> bool:
-            return not (p.exists() and p.stat().st_size > 1_000_000)
+            try:
+                return not (p.exists() and p.stat().st_size > 1_000_000)
+            except FileNotFoundError:
+                return True
 
         for fname in ["dit.pth", "vae.pth"]:
             dst = self.ckpt_dir / fname
@@ -113,19 +76,58 @@ class VincieService:
         link = self.repo_dir / "ckpt" / "VINCIE-3B"
         try:
             if link.is_symlink() or link.exists():
-                # Remover link anterior inválido
                 try:
                     link.unlink()
                 except IsADirectoryError:
-                    # Se for diretório, não remover conteúdos; só criar link se não existir
                     pass
             if not link.exists():
                 link.symlink_to(self.ckpt_dir, target_is_directory=True)
         except Exception as e:
             print("Aviso: falha ao criar symlink de ckpt:", e)
 
+    def ensure_apex(self, enable_shim: bool = True) -> None:
+        """
+        Se Apex não estiver presente, injeta um shim mínimo para FusedRMSNorm/FusedLayerNorm
+        usando torch.nn, evitando falhas de import nos caminhos que dependem de apex.normalization.
+        """
+        try:
+            import importlib
+            importlib.import_module("apex.normalization")
+            return
+        except Exception:
+            if not enable_shim:
+                return
+
+        shim_root = Path("/app/shims")
+        apex_pkg = shim_root / "apex"
+        apex_pkg.mkdir(parents=True, exist_ok=True)
+        (apex_pkg / "__init__.py").write_text("from .normalization import *\n")
+
+        (apex_pkg / "normalization.py").write_text(
+            "import torch\n"
+            "import torch.nn as nn\n"
+            "\n"
+            "class FusedRMSNorm(nn.Module):\n"
+            "    def __init__(self, normalized_shape, eps=1e-6, elementwise_affine=True):\n"
+            "        super().__init__()\n"
+            "        self.mod = nn.RMSNorm(normalized_shape, eps=eps, elementwise_affine=elementwise_affine)\n"
+            "    def forward(self, x):\n"
+            "        return self.mod(x)\n"
+            "\n"
+            "class FusedLayerNorm(nn.Module):\n"
+            "    def __init__(self, normalized_shape, eps=1e-5, elementwise_affine=True):\n"
+            "        super().__init__()\n"
+            "        self.mod = nn.LayerNorm(normalized_shape, eps=eps, elementwise_affine=elementwise_affine)\n"
+            "    def forward(self, x):\n"
+            "        return self.mod(x)\n"
+        )
+
+        # Tornar o shim visível neste processo e nos subprocessos
+        sys.path.insert(0, str(shim_root))
+        os.environ["PYTHONPATH"] = f"{str(shim_root)}:{os.environ.get('PYTHONPATH','')}"
+
     def ready(self) -> bool:
-        """Verifica se o repo, config e checkpoints obrigatórios existem."""
+        """Verifica se repo/config e checkpoints obrigatórios existem."""
         have_repo = self.repo_dir.exists() and self.generate_yaml.exists()
         dit_ok = (self.ckpt_dir / "dit.pth").exists()
         vae_ok = (self.ckpt_dir / "vae.pth").exists()
@@ -144,7 +146,6 @@ class VincieService:
             *overrides,
             f"generation.output.dir={str(work_output)}",
         ]
-        # Herdar ambiente (inclui PYTHONPATH do shim, se aplicado)
         env = os.environ.copy()
         subprocess.run(cmd, cwd=self.repo_dir, check=True, env=env)
 
@@ -157,11 +158,9 @@ class VincieService:
         out_dir_name: Optional[str] = None,
     ) -> Path:
         """
-        Equivalente ao exemplo:
-        python main.py configs/generate.yaml \
-          generation.positive_prompt.image_path="[...]"
-          generation.positive_prompt.prompts="[...]"
-          generation.output.dir=...
+        Equivalente ao exemplo oficial:
+          generation.positive_prompt.image_path=[...]
+          generation.positive_prompt.prompts=[...]
         """
         out_dir = self.output_root / (out_dir_name or f"multi_turn_{self._slug(input_image)}")
         image_json = json.dumps([str(input_image)])
@@ -184,9 +183,8 @@ class VincieService:
         out_dir_name: Optional[str] = None,
     ) -> Path:
         """
-        Uso inspirado no README do VINCIE:
-        - image_path: lista de imagens dos conceitos
-        - prompts: [p1, p2, ..., final_prompt]
+        Usa image_path como lista de imagens de conceito e prompts = [p1, p2, ..., final],
+        mantendo compatibilidade com o pipeline do VINCIE.
         """
         out_dir = self.output_root / (out_dir_name or "multi_concept")
         imgs_json = json.dumps([str(p) for p in concept_images])