Upload 4 files

Dockerfile

@@ -0,0 +1,45 @@
+# Dockerfile (VERSÃO FINAL PARA API FASTAPI)
+
+# 1. COMEÇAR COM A BASE CORRETA
+FROM nvidia/cuda:12.1.1-devel-ubuntu22.04
+
+# 2. INSTALAR DEPENDÊNCIAS DO SISTEMA
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    wget \
+    git \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# 3. INSTALAR O MINICONDA
+RUN wget --quiet https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda.sh && \
+    /bin/bash ~/miniconda.sh -b -p /opt/conda && \
+    rm ~/miniconda.sh
+
+# 4. ADICIONAR CONDA AO PATH
+ENV PATH /opt/conda/bin:$PATH
+
+# 5. COPIAR TODOS OS ARQUIVOS DO REPOSITÓRIO
+COPY . /app
+WORKDIR /app
+
+# 6. ACEITAR OS TERMOS DE SERVIÇO
+RUN yes | conda tos accept
+
+# 7. ATUALIZAR O CONDA
+RUN conda update -n base -c defaults conda
+
+# 8. CRIAR O AMBIENTE CONDA
+RUN conda env create -f environment.yml && conda clean --all -y
+
+# 9. INSTALAR FLASH_ATTN SEM COMPILAR CUDA (PARA EVITAR ERRO DE MEMÓRIA)
+RUN conda run -n seedvr env FLASH_ATTENTION_SKIP_CUDA_BUILD=TRUE \
+    pip install "flash_attn==2.5.9.post1" --no-build-isolation --no-cache-dir
+
+# 10. BAIXAR O MODELO
+WORKDIR /app/SeedVR
+RUN huggingface-cli download ByteDance-Seed/SeedVR2-3B --local-dir ckpts --local-dir-use-symlinks False
+
+# 11. DEFINIR O COMANDO FINAL PARA INICIAR A API
+WORKDIR /app
+CMD ["conda", "run", "-n", "seedvr", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,13 +1,18 @@
 ---
-title: SeedVR2-3B
+title: SeedVR2 Inference
 emoji: 🎥
 colorFrom: blue
 colorTo: green
-sdk: gradio
-sdk_version: 5.29.0
+sdk: docker
+sdk_version: 5.44.1
 app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: SeedVR2-3B Image & Video API Demo
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Instruções de Uso:
+
+1.  **Faça o upload de um vídeo:** Use a caixa de upload para enviar seu arquivo de vídeo de entrada.
+2.  **Ajuste os parâmetros:** Configure o `seed`, dimensões de saída e `sp_size` conforme necessário.
+3.  **Clique em "Gerar Vídeo":** O processo de inferência será iniciado. Você pode acompanhar o progresso em tempo real na caixa de logs.
+4.  **Visualize o resultado:** O vídeo gerado aparecerá na galeria de saída quando o processo for concluído.
+
+**Nota Importante:** A primeira inicialização deste Space pode demorar vários minutos, pois ele precisa baixar o modelo de 3GB e instalar todas as dependências.

environment.yml

@@ -0,0 +1,55 @@
+# Nome do ambiente Conda que será criado
+name: seedvr
+
+# Canais de onde o Conda irá baixar os pacotes, em ordem de prioridade.
+# pytorch e nvidia são essenciais para obter as versões corretas com suporte a GPU.
+channels:
+  - pytorch
+  - nvidia
+  - defaults
+
+# Lista de todas as dependências
+dependencies:
+  # Pacotes principais instalados via Conda para máxima compatibilidade com a GPU
+  - python
+  - pytorch
+  - torchvision
+  - torchaudio
+  - pytorch-cuda  # Garante que o PyTorch seja compatível com a CUDA da imagem Docker
+  - pip                # Instala o gerenciador de pacotes pip dentro do ambiente
+
+  # Pacotes instalados via Pip
+  - pip:
+      # Dependências da API FastAPI
+      - fastapi
+      - uvicorn
+      - python-multipart
+
+      # Dependências do projeto SeedVR
+      - accelerate
+      - av
+      - beautifulsoup4
+      - controlnet_aux
+      - diffusers
+      - einops
+      - ftfy
+      - huggingface_hub
+      - iopath
+      - mediapy
+      - omegaconf
+      - opencv-python
+      - pandas
+      - pytorch-lightning
+      - pytorchvideo
+      - regex
+      - scikit-image
+      - timm
+      - tqdm
+      - transformers
+      - webdataset
+      - xformers
+
+# NOTA IMPORTANTE:
+# 'flash_attn' não está listado aqui de propósito.
+# Sua instalação requer flags especiais para evitar erros de memória durante a construção.
+# Por isso, ele é instalado separadamente com um comando RUN dedicado no Dockerfile.      # A linha do flash_attn foi REMOVIDA daqui

main.py

@@ -0,0 +1,108 @@
+# main.py (API com FastAPI)
+
+import os
+import uuid
+import shutil
+import subprocess
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.responses import FileResponse
+from fastapi.concurrency import run_in_threadpool
+
+# Diretório base onde o código do SeedVR está
+SEEDVR_DIR = "/app/SeedVR"
+
+app = FastAPI()
+
+def run_inference_blocking(input_video_path: str, output_dir: str, seed: int, res_h: int, res_w: int) -> str:
+    """
+    Função síncrona que executa o script torchrun.
+    Ela bloqueia a execução, por isso deve ser chamada em um thread separado.
+    """
+    # O script de inferência espera ser executado de dentro do diretório SeedVR
+    # e que os caminhos de entrada/saída sejam relativos a ele.
+    
+    # Constrói o caminho relativo para a pasta de entrada
+    input_folder_relative = os.path.relpath(os.path.dirname(input_video_path), SEEDVR_DIR)
+    
+    # Constrói o caminho relativo para a pasta de saída
+    output_folder_relative = os.path.relpath(output_dir, SEEDVR_DIR)
+    
+    command = [
+        "torchrun",
+        "--nproc-per-node=4",
+        "projects/inference_seedvr2_3b.py",
+        "--video_path", input_folder_relative,
+        "--output_dir", output_folder_relative,
+        "--seed", str(seed),
+        "--res_h", str(res_h),
+        "--res_w", str(res_w),
+        "--sp_size", "1",  # Mantido fixo ou pode se tornar um parâmetro
+    ]
+    
+    try:
+        print(f"Executando comando: {' '.join(command)}")
+        # Executa o subprocesso a partir do diretório do SeedVR
+        subprocess.run(command, cwd=SEEDVR_DIR, check=True, capture_output=True, text=True)
+    except subprocess.CalledProcessError as e:
+        # Se o script falhar, captura o erro e o log para depuração
+        print("Erro na execução do subprocesso!")
+        print(f"Stdout: {e.stdout}")
+        print(f"Stderr: {e.stderr}")
+        raise HTTPException(status_code=500, detail=f"A inferência falhou: {e.stderr}")
+
+    # Encontra o arquivo de saída gerado
+    output_files = [f for f in os.listdir(output_dir) if f.endswith(('.mp4', '.png'))]
+    if not output_files:
+        raise HTTPException(status_code=500, detail="A inferência foi concluída, mas nenhum arquivo de saída foi encontrado.")
+        
+    return os.path.join(output_dir, output_files[0])
+
+
+@app.get("/")
+async def root():
+    return {"message": "API de Inferência SeedVR2 está online. Use o endpoint /infer/ para processar vídeos."}
+
+
+@app.post("/infer/", response_class=FileResponse)
+async def create_inference_job(
+    video: UploadFile = File(...),
+    seed: int = Form(666),
+    res_h: int = Form(720),
+    res_w: int = Form(1280),
+):
+    """
+    Recebe um vídeo e parâmetros, executa a inferência e retorna o vídeo processado.
+    """
+    # Cria diretórios temporários únicos para esta requisição para evitar conflitos
+    job_id = str(uuid.uuid4())
+    input_dir = os.path.join("/app", "temp_inputs", job_id)
+    output_dir = os.path.join("/app", "temp_outputs", job_id)
+    os.makedirs(input_dir, exist_ok=True)
+    os.makedirs(output_dir, exist_ok=True)
+    
+    input_video_path = os.path.join(input_dir, video.filename)
+    
+    try:
+        # Salva o vídeo enviado para o disco
+        with open(input_video_path, "wb") as buffer:
+            shutil.copyfileobj(video.file, buffer)
+        
+        # Executa a função de inferência pesada em um thread separado
+        # para não bloquear o servidor da API
+        result_path = await run_in_threadpool(
+            run_inference_blocking, 
+            input_video_path=input_video_path, 
+            output_dir=output_dir, 
+            seed=seed,
+            res_h=res_h,
+            res_w=res_w
+        )
+        
+        # Retorna o arquivo de vídeo como uma resposta para download
+        return FileResponse(path=result_path, media_type='video/mp4', filename=os.path.basename(result_path))
+        
+    finally:
+        # Limpa os diretórios temporários após a conclusão ou falha
+        print("Limpando diretórios temporários...")
+        shutil.rmtree(input_dir, ignore_errors=True)
+        shutil.rmtree(output_dir, ignore_errors=True)