Agregando soporte completo para generacion de videos con modelos gratuitos

app.py

@@ -52,6 +52,19 @@ MODELS = {
         "black-forest-labs/FLUX.1-schnell": "FLUX.1 Schnell (Requiere acceso)",
         "black-forest-labs/FLUX.1-dev": "FLUX.1 Dev (Requiere acceso)"
     },
+    "video": {
+        "damo-vilab/text-to-video-ms-1.7b": "Text-to-Video MS 1.7B (Libre)",
+        "ali-vilab/text-to-video-ms-1.7b": "Text-to-Video MS 1.7B Alt",
+        "cerspense/zeroscope_v2_576w": "Zeroscope v2 576w (Libre)",
+        "cerspense/zeroscope_v2_XL": "Zeroscope v2 XL (Libre)",
+        "damo-vilab/text-to-video-ms-1.7b": "Text-to-Video MS 1.7B",
+        "ali-vilab/text-to-video-ms-1.7b": "Text-to-Video MS 1.7B Alt",
+        "cerspense/zeroscope_v2_576w": "Zeroscope v2 576w",
+        "cerspense/zeroscope_v2_XL": "Zeroscope v2 XL",
+        "ByteDance/AnimateDiff-Lightning": "AnimateDiff Lightning (Libre)",
+        "THUDM/CogVideoX-5b": "CogVideoX 5B (Libre)",
+        "rain1011/pyramid-flow-sd3": "Pyramid Flow SD3 (Libre)"
+    },
     "chat": {
         "microsoft/DialoGPT-medium": "Chat conversacional",
         "microsoft/DialoGPT-large": "Chat conversacional avanzado",
@@ -133,6 +146,69 @@ def load_image_model(model_name):
     
     return model_cache[model_name]
 
+def load_video_model(model_name):
+    """Cargar modelo de video con soporte para diferentes tipos"""
+    if model_name not in model_cache:
+        print(f"Cargando modelo de video: {model_name}")
+        
+        try:
+            # Detectar tipo de modelo de video
+            if "text-to-video" in model_name.lower():
+                # Modelos de texto a video
+                from diffusers import DiffusionPipeline
+                pipe = DiffusionPipeline.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float32,
+                    variant="fp16"
+                )
+            elif "zeroscope" in model_name.lower():
+                # Zeroscope models
+                from diffusers import DiffusionPipeline
+                pipe = DiffusionPipeline.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float32
+                )
+            elif "animatediff" in model_name.lower():
+                # AnimateDiff models
+                from diffusers import DiffusionPipeline
+                pipe = DiffusionPipeline.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float32
+                )
+            else:
+                # Fallback a text-to-video genérico
+                from diffusers import DiffusionPipeline
+                pipe = DiffusionPipeline.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float32
+                )
+            
+            # Optimizaciones básicas
+            pipe.enable_attention_slicing()
+            pipe.enable_model_cpu_offload()
+            
+            model_cache[model_name] = {
+                "pipeline": pipe,
+                "type": "video"
+            }
+            
+        except Exception as e:
+            print(f"Error cargando modelo de video {model_name}: {e}")
+            # Fallback a un modelo básico
+            from diffusers import DiffusionPipeline
+            pipe = DiffusionPipeline.from_pretrained(
+                "damo-vilab/text-to-video-ms-1.7b",
+                torch_dtype=torch.float32
+            )
+            pipe.enable_attention_slicing()
+            
+            model_cache[model_name] = {
+                "pipeline": pipe,
+                "type": "video"
+            }
+    
+    return model_cache[model_name]
+
 def generate_text(prompt, model_name, max_length=100):
     """Generar texto con el modelo seleccionado - mejorado para diferentes tipos"""
     try:
@@ -208,6 +284,49 @@ def generate_image(prompt, model_name, num_inference_steps=20):
         print(f"Error generando imagen: {str(e)}")
         return f"Error generando imagen: {str(e)}"
 
+def generate_video(prompt, model_name, num_frames=16, num_inference_steps=20):
+    """Generar video con el modelo seleccionado"""
+    try:
+        print(f"Generando video con modelo: {model_name}")
+        print(f"Prompt: {prompt}")
+        print(f"Frames: {num_frames}")
+        print(f"Pasos: {num_inference_steps}")
+        
+        model_data = load_video_model(model_name)
+        pipeline = model_data["pipeline"]
+        
+        # Configuración específica por tipo de modelo
+        if "zeroscope" in model_name.lower():
+            # Zeroscope models
+            video_frames = pipeline(
+                prompt,
+                num_inference_steps=num_inference_steps,
+                num_frames=num_frames,
+                height=256,
+                width=256
+            ).frames
+        elif "animatediff" in model_name.lower():
+            # AnimateDiff models
+            video_frames = pipeline(
+                prompt,
+                num_inference_steps=num_inference_steps,
+                num_frames=num_frames
+            ).frames
+        else:
+            # Text-to-video models (default)
+            video_frames = pipeline(
+                prompt,
+                num_inference_steps=num_inference_steps,
+                num_frames=num_frames
+            ).frames
+        
+        print("Video generado exitosamente")
+        return video_frames
+    
+    except Exception as e:
+        print(f"Error generando video: {str(e)}")
+        return f"Error generando video: {str(e)}"
+
 def chat_with_model(message, history, model_name):
     """Función de chat para DialoGPT con formato de mensajes actualizado"""
     try:
@@ -394,6 +513,48 @@ with gr.Blocks(title="Modelos Libres de IA", theme=gr.themes.Soft()) as demo:
                 inputs=[image_prompt, image_model, steps],
                 outputs=image_output
             )
+        
+        # Tab de Generación de Videos
+        with gr.TabItem("🎬 Generación de Videos"):
+            with gr.Row():
+                with gr.Column():
+                    video_model = gr.Dropdown(
+                        choices=list(MODELS["video"].keys()),
+                        value="damo-vilab/text-to-video-ms-1.7b",
+                        label="Modelo de Video"
+                    )
+                    video_prompt = gr.Textbox(
+                        label="Prompt de Video",
+                        placeholder="Describe el video que quieres generar...",
+                        lines=3
+                    )
+                    num_frames = gr.Slider(
+                        minimum=8,
+                        maximum=32,
+                        value=16,
+                        step=4,
+                        label="Número de frames"
+                    )
+                    video_steps = gr.Slider(
+                        minimum=10,
+                        maximum=50,
+                        value=20,
+                        step=5,
+                        label="Pasos de inferencia"
+                    )
+                    video_btn = gr.Button("Generar Video", variant="primary")
+                
+                with gr.Column():
+                    video_output = gr.Video(
+                        label="Video Generado",
+                        format="mp4"
+                    )
+            
+            video_btn.click(
+                generate_video,
+                inputs=[video_prompt, video_model, num_frames, video_steps],
+                outputs=video_output
+            )
 
 # Configuración para Hugging Face Spaces
 if __name__ == "__main__":

requirements.txt

@@ -8,4 +8,7 @@ numpy>=1.21.0
 requests>=2.28.0
 safetensors>=0.3.0
 xformers>=0.0.20
-huggingface_hub>=0.19.0 
+huggingface_hub>=0.19.0
+opencv-python>=4.8.0
+imageio>=2.31.0
+imageio-ffmpeg>=0.4.8