Archivo validado localmente - sin errores de sintaxis

app.py

@@ -777,7 +777,7 @@ def generate_image(
                             
                             result = pipe(**generation_kwargs)
                             image = result.images[0]
-            else:
+                        else:
                             print("✅ Imagen generada correctamente")
                     else:
                         print("❌ Error: Imagen vacía")

app_fixed.py

@@ -0,0 +1,1451 @@
+# IMPORTANTE: Importar spaces ANTES de torch para ZeroGPU
+import spaces  # Para usar ZeroGPU H200
+
+import gradio as gr
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from diffusers import StableDiffusionPipeline, DiffusionPipeline
+import requests
+from PIL import Image
+import io
+import base64
+import os
+import time
+import numpy as np
+import random
+from huggingface_hub import login
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+print("🚀 Iniciando NTIA Space con ZeroGPU H200...")
+print(f"📁 Directorio actual: {os.getcwd()}")
+print(f"🐍 Python version: {os.sys.version}")
+
+# Optimización para ZeroGPU H200
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"🖥️ Dispositivo detectado: {device}")
+print(f"🔥 CUDA disponible: {torch.cuda.is_available()}")
+
+if torch.cuda.is_available():
+    print(f"🎮 GPU: {torch.cuda.get_device_name(0)}")
+    print(f"💾 Memoria GPU: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
+    print("🚀 ZeroGPU H200 detectado - Optimizando para máximo rendimiento")
+    
+    # Configuración optimizada para H200
+    torch_dtype = torch.float16  # Usar float16 para mayor velocidad
+    print("⚡ Usando torch.float16 para H200")
+    
+    # Optimizaciones adicionales para H200
+    torch.backends.cudnn.benchmark = True
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    print("🔧 Optimizaciones CUDA habilitadas para H200")
+else:
+    torch_dtype = torch.float32
+    print("🐌 Usando torch.float32 para CPU")
+
+# Configurar autenticación con Hugging Face
+HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("HUGGING_FACE_HUB_TOKEN")
+if HF_TOKEN:
+    try:
+        print(f"🔑 Token detectado: {HF_TOKEN[:10]}...")
+        login(token=HF_TOKEN)
+        print("✅ Autenticado con Hugging Face")
+        print(f"🔑 Token configurado: {HF_TOKEN[:10]}...")
+    except Exception as e:
+        print(f"⚠️ Error de autenticación: {e}")
+else:
+    print("⚠️ No se encontró HF_TOKEN - modelos gated no estarán disponibles")
+    print("💡 Para usar modelos FLUX, configura la variable de entorno HF_TOKEN en el Space")
+
+# Verificar acceso a modelos gated
+def check_gated_model_access():
+    """Verificar si tenemos acceso a modelos gated"""
+    if not HF_TOKEN:
+        return False
+    
+    try:
+        # Intentar acceder a un modelo gated para verificar permisos
+        from huggingface_hub import model_info
+        info = model_info("black-forest-labs/FLUX.1-dev", token=HF_TOKEN)
+        print(f"✅ Acceso verificado a FLUX.1-dev: {info.modelId}")
+        return True
+    except Exception as e:
+        print(f"❌ No se pudo verificar acceso a modelos gated: {e}")
+        return False
+
+# Verificar acceso al inicio
+GATED_ACCESS = check_gated_model_access()
+
+# Mostrar estado de configuración al inicio
+print("=" * 60)
+print("🚀 SPACE NTIA - ESTADO DE CONFIGURACIÓN")
+print("=" * 60)
+print(f"🔑 Token HF configurado: {'✅' if HF_TOKEN else '❌'}")
+print(f"🔐 Acceso a modelos gated: {'✅' if GATED_ACCESS else '❌'}")
+print(f"🎨 Modelos FLUX disponibles: {'✅' if GATED_ACCESS else '❌'}")
+print("=" * 60)
+
+if not GATED_ACCESS:
+    print("⚠️ Para usar modelos FLUX:")
+    print("   1. Configura HF_TOKEN en las variables de entorno del Space")
+    print("   2. Solicita acceso a los modelos FLUX en Hugging Face")
+    print("   3. Acepta los términos de licencia")
+    print("=" * 60)
+
+# Clases para los endpoints API
+class TextRequest(BaseModel):
+    prompt: str
+    model_name: str
+    max_length: int = 100
+
+class ImageRequest(BaseModel):
+    prompt: str
+    model_name: str
+    negative_prompt: str = ""
+    seed: int = 0
+    randomize_seed: bool = True
+    width: int = 1024
+    height: int = 1024
+    guidance_scale: float = 7.5
+    num_inference_steps: int = 20
+    eta: float = 0
+    strength: float = 1
+    num_images: int = 1
+    safety_checker: bool = True
+
+class VideoRequest(BaseModel):
+    prompt: str
+    model_name: str
+    num_frames: int = 16
+    num_inference_steps: int = 20
+
+class ChatRequest(BaseModel):
+    message: str
+    history: list
+    model_name: str
+
+# Configuración de modelos libres
+MODELS = {
+    "text": {
+        "microsoft/DialoGPT-medium": "Chat conversacional",
+        "microsoft/DialoGPT-large": "Chat conversacional avanzado",
+        "microsoft/DialoGPT-small": "Chat conversacional rápido",
+        "gpt2": "Generación de texto",
+        "gpt2-medium": "GPT-2 mediano",
+        "gpt2-large": "GPT-2 grande",
+        "distilgpt2": "GPT-2 optimizado",
+        "EleutherAI/gpt-neo-125M": "GPT-Neo pequeño",
+        "EleutherAI/gpt-neo-1.3B": "GPT-Neo mediano",
+        "facebook/opt-125m": "OPT pequeño",
+        "facebook/opt-350m": "OPT mediano",
+        "bigscience/bloom-560m": "BLOOM multilingüe",
+        "bigscience/bloom-1b1": "BLOOM grande",
+        "Helsinki-NLP/opus-mt-es-en": "Traductor español-inglés",
+        "Helsinki-NLP/opus-mt-en-es": "Traductor inglés-español",
+        # ✅ Nuevos modelos de texto
+        "mistralai/Voxtral-Mini-3B-2507": "Voxtral Mini 3B - Multimodal",
+        "tiiuae/falcon-7b-instruct": "Falcon 7B Instruct",
+        "google/flan-t5-base": "Flan-T5 Base - Tareas múltiples"
+    },
+    "image": {
+        "CompVis/stable-diffusion-v1-4": "Stable Diffusion v1.4 (Libre)",
+        "stabilityai/stable-diffusion-2-1": "Stable Diffusion 2.1",
+        "stabilityai/stable-diffusion-xl-base-1.0": "SDXL Base",
+        "stabilityai/stable-diffusion-3-medium": "SD 3 Medium",
+        "prompthero/openjourney": "Midjourney Style",
+        "WarriorMama777/OrangeMixs": "Orange Mixs",
+        "hakurei/waifu-diffusion": "Waifu Diffusion",
+        "black-forest-labs/FLUX.1-schnell": "FLUX.1 Schnell (Requiere acceso)",
+        "black-forest-labs/FLUX.1-dev": "FLUX.1 Dev (Requiere acceso)",
+        # ✅ Nuevos modelos de imagen
+        "CompVis/ldm-text2im-large-256": "Latent Diffusion Model 256",
+        # ⚡ Modelos Turbo (rápidos)
+        "stabilityai/sdxl-turbo": "⚡ SDXL Turbo",
+        "stabilityai/sd-turbo": "⚡ SD Turbo",
+        "ByteDance/SDXL-Lightning": "⚡ SDXL Lightning",
+        # 🎨 Modelos adicionales
+        "KBlueLeaf/kohaku-v2.1": "Kohaku V2.1"
+    },
+    "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)",
+        "ByteDance/AnimateDiff-Lightning": "AnimateDiff Lightning (Libre)",
+        "THUDM/CogVideoX-5b": "CogVideoX 5B (Libre)",
+        "rain1011/pyramid-flow-sd3": "Pyramid Flow SD3 (Libre)",
+        # ✅ Nuevos modelos de video
+        "ali-vilab/modelscope-damo-text-to-video-synthesis": "ModelScope Text-to-Video"
+    },
+    "chat": {
+        "microsoft/DialoGPT-medium": "Chat conversacional",
+        "microsoft/DialoGPT-large": "Chat conversacional avanzado",
+        "microsoft/DialoGPT-small": "Chat conversacional rápido",
+        "facebook/opt-350m": "OPT conversacional",
+        "bigscience/bloom-560m": "BLOOM multilingüe",
+        # ✅ Nuevos modelos de chat
+        "mistralai/Voxtral-Mini-3B-2507": "Voxtral Mini 3B - Multimodal",
+        "tiiuae/falcon-7b-instruct": "Falcon 7B Instruct"
+    }
+}
+
+# Cache para los modelos
+model_cache = {}
+
+def load_text_model(model_name):
+    """Cargar modelo de texto con soporte para diferentes tipos"""
+    if model_name not in model_cache:
+        print(f"Cargando modelo de texto: {model_name}")
+        
+        try:
+            # Detectar tipo de modelo
+            if "opus-mt" in model_name.lower():
+                # Modelo de traducción
+                from transformers import MarianMTModel, MarianTokenizer
+                tokenizer = MarianTokenizer.from_pretrained(model_name)
+                model = MarianMTModel.from_pretrained(model_name)
+                
+            elif "flan-t5" in model_name.lower():
+                # Modelo Flan-T5
+                from transformers import T5Tokenizer, T5ForConditionalGeneration
+                tokenizer = T5Tokenizer.from_pretrained(model_name)
+                model = T5ForConditionalGeneration.from_pretrained(model_name)
+            
+            elif "falcon" in model_name.lower():
+                # Modelo Falcon
+                from transformers import AutoTokenizer, AutoModelForCausalLM
+                tokenizer = AutoTokenizer.from_pretrained(model_name)
+                model = AutoModelForCausalLM.from_pretrained(model_name)
+                # Configurar para Falcon
+                if tokenizer.pad_token is None:
+                    tokenizer.pad_token = tokenizer.eos_token
+            
+            elif "voxtral" in model_name.lower():
+                # Modelo Voxtral (multimodal)
+                from transformers import AutoTokenizer, AutoModelForCausalLM
+                tokenizer = AutoTokenizer.from_pretrained(model_name)
+                model = AutoModelForCausalLM.from_pretrained(model_name)
+                # Configurar para Voxtral
+                if tokenizer.pad_token is None:
+                    tokenizer.pad_token = tokenizer.eos_token
+            
+            else:
+                # Modelo de generación de texto estándar
+                from transformers import AutoTokenizer, AutoModelForCausalLM
+                tokenizer = AutoTokenizer.from_pretrained(model_name)
+                model = AutoModelForCausalLM.from_pretrained(model_name)
+                
+                # Configurar para chat si es DialoGPT
+                if "dialogpt" in model_name.lower():
+                    tokenizer.pad_token = tokenizer.eos_token
+                    model.config.pad_token_id = model.config.eos_token_id
+            
+            model_cache[model_name] = {
+                "tokenizer": tokenizer,
+                "model": model,
+                "type": "text"
+            }
+            
+        except Exception as e:
+            print(f"Error cargando modelo de texto {model_name}: {e}")
+            # Fallback a un modelo básico
+            from transformers import AutoTokenizer, AutoModelForCausalLM
+            tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-medium")
+            model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-medium")
+            tokenizer.pad_token = tokenizer.eos_token
+            model.config.pad_token_id = model.config.eos_token_id
+            
+            model_cache[model_name] = {
+                "tokenizer": tokenizer,
+                "model": model,
+                "type": "text"
+            }
+    
+    return model_cache[model_name]
+
+def load_image_model(model_name):
+    """Cargar modelo de imagen optimizado para H200"""
+    global model_cache
+    
+    if model_name not in model_cache:
+        print(f"\n🔄 Iniciando carga del modelo: {model_name}")
+        
+        try:
+            start_time = time.time()
+            
+            # Determinar si usar variant fp16 basado en el modelo
+            use_fp16_variant = False
+            if torch.cuda.is_available():
+                # Solo usar fp16 variant para modelos que lo soportan
+                fp16_supported_models = [
+                    "stabilityai/sdxl-turbo",
+                    "stabilityai/sd-turbo", 
+                    "stabilityai/stable-diffusion-xl-base-1.0",
+                    "runwayml/stable-diffusion-v1-5",
+                    "CompVis/stable-diffusion-v1-4"
+                ]
+                use_fp16_variant = any(model in model_name for model in fp16_supported_models)
+                print(f"🔧 FP16 variant: {'✅ Habilitado' if use_fp16_variant else '❌ Deshabilitado'} para {model_name}")
+            
+            # Configuración especial para FLUX
+            if "flux" in model_name.lower():
+                if not GATED_ACCESS:
+                    print("❌ No hay acceso a modelos gated. Configura HF_TOKEN en el Space.")
+                    raise Exception("Acceso denegado a modelos FLUX. Configura HF_TOKEN en las variables de entorno del Space.")
+                
+                try:
+                    from diffusers import FluxPipeline
+                    print("🚀 Cargando FLUX Pipeline...")
+                    print(f"🔧 Modelo: {model_name}")
+                    print(f"🔑 Usando token de autenticación: {'Sí' if HF_TOKEN else 'No'}")
+                    
+                    # Para modelos FLUX, no usar variant fp16
+                    pipe = FluxPipeline.from_pretrained(
+                        model_name,
+                        torch_dtype=torch_dtype,
+                        use_auth_token=HF_TOKEN,
+                        variant="fp16" if use_fp16_variant else None
+                    )
+                    
+                    print("✅ FLUX Pipeline cargado exitosamente")
+                    
+                except Exception as e:
+                    print(f"❌ Error cargando FLUX: {e}")
+                    print(f"🔍 Tipo de error: {type(e).__name__}")
+                    
+                    # Si es un error de autenticación, dar instrucciones específicas
+                    if "401" in str(e) or "unauthorized" in str(e).lower():
+                        print("🔐 Error de autenticación. Asegúrate de:")
+                        print("   1. Tener acceso al modelo FLUX en Hugging Face")
+                        print("   2. Configurar HF_TOKEN en las variables de entorno del Space")
+                        print("   3. Que el token tenga permisos para acceder a modelos gated")
+                    
+                    # Fallback a Stable Diffusion
+                    print("🔄 Fallback a Stable Diffusion...")
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        "CompVis/stable-diffusion-v1-4",
+                        torch_dtype=torch_dtype,
+                        safety_checker=None
+                    )
+            
+            # Configuración especial para SD 2.1 (problemático)
+            elif "stable-diffusion-2-1" in model_name:
+                try:
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        model_name,
+                        torch_dtype=torch_dtype,
+                        safety_checker=None,
+                        requires_safety_checker=False,
+                        variant="fp16" if use_fp16_variant else None
+                    )
+                except Exception as e:
+                    print(f"Error cargando SD 2.1: {e}")
+                    # Fallback a SD 1.4
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        "CompVis/stable-diffusion-v1-4",
+                        torch_dtype=torch_dtype,
+                        safety_checker=None
+                    )
+            
+            # Configuración especial para LDM
+            elif "ldm-text2im" in model_name:
+                try:
+                    from diffusers import DiffusionPipeline
+                    pipe = DiffusionPipeline.from_pretrained(
+                        model_name,
+                        torch_dtype=torch_dtype,
+                        safety_checker=None
+                    )
+                except Exception as e:
+                    print(f"Error cargando LDM: {e}")
+                    # Fallback a SD 1.4
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        "CompVis/stable-diffusion-v1-4",
+                        torch_dtype=torch_dtype,
+                        safety_checker=None
+                    )
+            
+            # Configuración estándar para otros modelos
+            else:
+                try:
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        model_name,
+                        torch_dtype=torch_dtype,
+                        safety_checker=None,
+                        variant="fp16" if use_fp16_variant else None
+                    )
+                except Exception as e:
+                    print(f"Error cargando {model_name}: {e}")
+                    # Fallback a SD 1.4
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        "CompVis/stable-diffusion-v1-4",
+                        torch_dtype=torch_dtype,
+                        safety_checker=None
+                    )
+            
+            load_time = time.time() - start_time
+            print(f"⏱️ Tiempo de carga: {load_time:.2f} segundos")
+            
+            print(f"🚀 Moviendo modelo a dispositivo: {device}")
+            pipe = pipe.to(device)
+            
+            # Optimizaciones específicas para H200
+            if torch.cuda.is_available():
+                print("🔧 Aplicando optimizaciones para H200...")
+                
+                # Habilitar optimizaciones de memoria (más conservadoras)
+                if hasattr(pipe, 'enable_attention_slicing'):
+                    pipe.enable_attention_slicing()
+                    print("✅ Attention slicing habilitado")
+                
+                # Deshabilitar CPU offload temporalmente (causa problemas con ZeroGPU)
+                # if hasattr(pipe, 'enable_model_cpu_offload') and "sdxl" in model_name.lower():
+                #     pipe.enable_model_cpu_offload()
+                #     print("✅ CPU offload habilitado (modelo grande)")
+                
+                if hasattr(pipe, 'enable_vae_slicing'):
+                    pipe.enable_vae_slicing()
+                    print("✅ VAE slicing habilitado")
+                
+                # XFormers solo si está disponible y el modelo lo soporta
+                if hasattr(pipe, 'enable_xformers_memory_efficient_attention'):
+                    # FLUX models tienen problemas con XFormers, deshabilitar
+                    if "flux" in model_name.lower() or "black-forest" in model_name.lower():
+                        print("⚠️ XFormers deshabilitado para modelos FLUX (incompatible)")
+                    else:
+                        try:
+                            pipe.enable_xformers_memory_efficient_attention()
+                            print("✅ XFormers memory efficient attention habilitado")
+                        except Exception as e:
+                            print(f"⚠️ XFormers no disponible: {e}")
+                            print("🔄 Usando atención estándar")
+            
+            print(f"✅ Modelo {model_name} cargado exitosamente")
+            
+            if torch.cuda.is_available():
+                memory_used = torch.cuda.memory_allocated() / 1024**3
+                memory_reserved = torch.cuda.memory_reserved() / 1024**3
+                print(f"💾 Memoria GPU utilizada: {memory_used:.2f} GB")
+                print(f"💾 Memoria GPU reservada: {memory_reserved:.2f} GB")
+                
+                # Verificar si la memoria es sospechosamente baja
+                if memory_used < 0.1:
+                    print("⚠️ ADVERTENCIA: Memoria GPU muy baja - posible problema de carga")
+            else:
+                print("💾 Memoria CPU")
+            
+            # Guardar en cache
+            model_cache[model_name] = pipe
+                
+        except Exception as e:
+            print(f"❌ Error cargando modelo {model_name}: {e}")
+            print(f"🔍 Tipo de error: {type(e).__name__}")
+            
+            # Intentar cargar sin variant fp16 si falló
+            if "variant" in str(e) and "fp16" in str(e):
+                print("🔄 Reintentando sin variant fp16...")
+                try:
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        model_name, 
+                        torch_dtype=torch_dtype,
+                        use_auth_token=HF_TOKEN if HF_TOKEN and ("flux" in model_name.lower() or "black-forest" in model_name.lower()) else None
+                    )
+                    pipe = pipe.to(device)
+                    model_cache[model_name] = pipe
+                    print(f"✅ Modelo {model_name} cargado exitosamente (sin fp16 variant)")
+                except Exception as e2:
+                    print(f"❌ Error en segundo intento: {e2}")
+                    raise e2
+            else:
+                raise e
+    else:
+        print(f"♻️ Modelo {model_name} ya está cargado, reutilizando...")
+    
+    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 "modelscope" in model_name.lower():
+                # ModelScope models
+                from diffusers import DiffusionPipeline
+                pipe = DiffusionPipeline.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float32
+                )
+            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
+                )
+            elif "cogvideo" in model_name.lower():
+                # CogVideo models
+                from diffusers import DiffusionPipeline
+                pipe = DiffusionPipeline.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float32
+                )
+            elif "pyramid-flow" in model_name.lower():
+                # Pyramid Flow 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()
+            if hasattr(pipe, 'enable_model_cpu_offload'):
+                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
+            try:
+                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"
+                }
+            except Exception as fallback_error:
+                print(f"Error crítico en fallback de video: {fallback_error}")
+                raise
+    
+    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:
+        model_data = load_text_model(model_name)
+        tokenizer = model_data["tokenizer"]
+        model = model_data["model"]
+        
+        # Detectar si es modelo de traducción
+        if "opus-mt" in model_name.lower():
+            # Traducción
+            inputs = tokenizer.encode(prompt, return_tensors="pt", max_length=512, truncation=True)
+            with torch.no_grad():
+                outputs = model.generate(inputs, max_length=max_length, num_beams=4, early_stopping=True)
+            response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        else:
+            # Generación de texto
+            inputs = tokenizer.encode(prompt, return_tensors="pt")
+            
+            # Generar
+            with torch.no_grad():
+                outputs = model.generate(
+                    inputs,
+                    max_length=max_length,
+                    num_return_sequences=1,
+                    temperature=0.7,
+                    do_sample=True,
+                    pad_token_id=tokenizer.eos_token_id
+                )
+            
+            # Decodificar respuesta
+            response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Para DialoGPT, extraer solo la respuesta del asistente
+            if "dialogpt" in model_name.lower():
+                response = response.replace(prompt, "").strip()
+        
+        return response
+        
+    except Exception as e:
+        return f"Error generando texto: {str(e)}"
+
+# @spaces.GPU #[uncomment to use ZeroGPU]
+@spaces.GPU
+def generate_image(
+    prompt, 
+    model_name, 
+    negative_prompt="",
+    seed=0,
+    randomize_seed=True,
+    width=1024,
+    height=1024,
+    guidance_scale=7.5,
+    num_inference_steps=20,
+    eta=0,
+    strength=1,
+    num_images=1,
+    safety_checker=True
+):
+    """Generar imagen optimizada para H200 con parámetros avanzados"""
+    try:
+        print(f"\n🎨 Iniciando generación de imagen con H200...")
+        print(f"📝 Prompt: {prompt}")
+        print(f"🚫 Negative prompt: {negative_prompt}")
+        print(f"🎯 Modelo seleccionado: {model_name}")
+        print(f"🔄 Inference steps: {num_inference_steps}")
+        print(f"🎲 Seed: {seed} (randomize: {randomize_seed})")
+        print(f"📐 Dimensiones: {width}x{height}")
+        print(f"🎯 Guidance scale: {guidance_scale}")
+        print(f"🎯 Eta: {eta}")
+        print(f"💪 Strength: {strength}")
+        print(f"🖼️ Images per prompt: {num_images}")
+        print(f"🛡️ Safety checker: {safety_checker}")
+        
+        start_time = time.time()
+        
+        # Convertir parámetros a tipos correctos
+        if isinstance(num_inference_steps, str):
+            try:
+                num_inference_steps = int(num_inference_steps)
+            except ValueError:
+                num_inference_steps = 20
+                print(f"⚠️ No se pudo convertir '{num_inference_steps}' a entero, usando 20")
+        
+        if isinstance(seed, str):
+            try:
+                seed = int(seed)
+            except ValueError:
+                seed = 0
+                print(f"⚠️ No se pudo convertir '{seed}' a entero, usando 0")
+        
+        if isinstance(width, str):
+            try:
+                width = int(width)
+            except ValueError:
+                width = 1024
+                print(f"⚠️ No se pudo convertir '{width}' a entero, usando 1024")
+        
+        if isinstance(height, str):
+            try:
+                height = int(height)
+            except ValueError:
+                height = 1024
+                print(f"⚠️ No se pudo convertir '{height}' a entero, usando 1024")
+        
+        if isinstance(guidance_scale, str):
+            try:
+                guidance_scale = float(guidance_scale)
+            except ValueError:
+                guidance_scale = 7.5
+                print(f"⚠️ No se pudo convertir '{guidance_scale}' a float, usando 7.5")
+        
+        if isinstance(eta, str):
+            try:
+                eta = float(eta)
+            except ValueError:
+                eta = 0
+                print(f"⚠️ No se pudo convertir '{eta}' a float, usando 0")
+        
+        if isinstance(strength, str):
+            try:
+                strength = float(strength)
+            except ValueError:
+                strength = 1
+                print(f"⚠️ No se pudo convertir '{strength}' a float, usando 1")
+        
+        if isinstance(num_images, str):
+            try:
+                num_images = int(num_images)
+            except ValueError:
+                num_images = 1
+                print(f"⚠️ No se pudo convertir '{num_images}' a entero, usando 1")
+        
+        # Cargar el modelo
+        pipe = load_image_model(model_name)
+        
+        # Configurar seed
+        if randomize_seed:
+            seed = random.randint(0, 2147483647)
+            print(f"🎲 Seed aleatorizado: {seed}")
+        
+        generator = torch.Generator(device=device).manual_seed(seed)
+        
+        # Ajustar parámetros según el tipo de modelo
+        if "turbo" in model_name.lower():
+            guidance_scale = min(guidance_scale, 1.0)
+            num_inference_steps = min(num_inference_steps, 4)
+            print(f"⚡ Modelo turbo - Ajustando parámetros: guidance={guidance_scale}, steps={num_inference_steps}")
+        elif "lightning" in model_name.lower():
+            guidance_scale = min(guidance_scale, 1.0)
+            num_inference_steps = max(num_inference_steps, 4)
+            print(f"⚡ Modelo lightning - Ajustando parámetros: guidance={guidance_scale}, steps={num_inference_steps}")
+        elif "flux" in model_name.lower():
+            guidance_scale = max(3.5, min(guidance_scale, 7.5))
+            num_inference_steps = max(15, num_inference_steps)
+            print(f"🔐 Modelo FLUX - Ajustando parámetros: guidance={guidance_scale}, steps={num_inference_steps}")
+        
+        print(f"⚙️ Parámetros finales (respetando configuración del usuario):")
+        print(f"   - Guidance scale: {guidance_scale} → {guidance_scale}")
+        print(f"   - Inference steps: {num_inference_steps} → {num_inference_steps}")
+        print(f"   - Width: {width}, Height: {height}")
+        print(f"   - Seed: {seed}")
+        print(f"   - Eta: {eta}")
+        print(f"   - Strength: {strength}")
+        print(f"   - Images per prompt: {num_images}")
+        
+        print("🎨 Iniciando generación de imagen con H200...")
+        inference_start = time.time()
+        
+        # Optimizaciones específicas para H200
+        if torch.cuda.is_available():
+            print("🚀 Aplicando optimizaciones específicas para H200...")
+            
+            # Limpiar cache de GPU antes de la inferencia
+            torch.cuda.empty_cache()
+            
+            # Generar la imagen
+            print("⚡ Generando imagen con H200...")
+            
+            # Configurar parámetros de generación
+            generation_kwargs = {
+                "prompt": prompt,
+                "height": height,
+                "width": width,
+                "guidance_scale": guidance_scale,
+                "num_inference_steps": num_inference_steps,
+                "generator": generator,
+                "num_images_per_prompt": num_images
+            }
+            
+            # Agregar parámetros opcionales
+            if negative_prompt and negative_prompt.strip():
+                generation_kwargs["negative_prompt"] = negative_prompt.strip()
+            
+            if eta > 0:
+                generation_kwargs["eta"] = eta
+            
+            if strength < 1:
+                generation_kwargs["strength"] = strength
+            
+            # Generar la imagen
+            result = pipe(**generation_kwargs)
+            
+            # Verificar que la imagen se generó correctamente
+            if hasattr(result, 'images') and len(result.images) > 0:
+                # Si se generaron múltiples imágenes, devolver la primera
+                image = result.images[0]
+                
+                # Verificar que la imagen no sea completamente negra
+                if image is not None:
+                    # Convertir a numpy para verificar
+                    img_array = np.array(image)
+                    if img_array.size > 0:
+                        # Verificar si la imagen es completamente negra
+                        if np.all(img_array == 0) or np.all(img_array < 10):
+                            print("⚠️ ADVERTENCIA: Imagen generada es completamente negra")
+                            print("🔄 Reintentando con parámetros ajustados...")
+                            
+                            # Reintentar con parámetros más conservadores
+                            generation_kwargs["guidance_scale"] = max(1.0, guidance_scale * 0.8)
+                            generation_kwargs["num_inference_steps"] = max(10, num_inference_steps)
+                            
+                            result = pipe(**generation_kwargs)
+                            image = result.images[0]
+            else:
+                            print("✅ Imagen generada correctamente")
+                    else:
+                        print("❌ Error: Imagen vacía")
+                        raise Exception("Imagen vacía generada")
+                else:
+                    print("❌ Error: Imagen es None")
+                    raise Exception("Imagen es None")
+            else:
+                print("❌ Error: No se generaron imágenes")
+                raise Exception("No se generaron imágenes")
+        else:
+            # Fallback para CPU
+            generation_kwargs = {
+                "prompt": prompt,
+                "height": height,
+                "width": width,
+                "guidance_scale": guidance_scale,
+                "num_inference_steps": num_inference_steps,
+                "generator": generator,
+                "num_images_per_prompt": num_images
+            }
+            
+            if negative_prompt and negative_prompt.strip():
+                generation_kwargs["negative_prompt"] = negative_prompt.strip()
+            
+            if eta > 0:
+                generation_kwargs["eta"] = eta
+            
+            if strength < 1:
+                generation_kwargs["strength"] = strength
+            
+            result = pipe(**generation_kwargs)
+            image = result.images[0]
+        
+        inference_time = time.time() - inference_start
+        total_time = time.time() - start_time
+        
+        print(f"✅ Imagen generada exitosamente con H200!")
+        print(f"⏱️ Tiempo de inferencia: {inference_time:.2f} segundos")
+        print(f"⏱️ Tiempo total: {total_time:.2f} segundos")
+        print(f"🎲 Seed final: {seed}")
+        
+        if torch.cuda.is_available():
+            print(f"💾 Memoria GPU utilizada: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
+            print(f"💾 Memoria GPU libre: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")
+            print(f"🚀 Velocidad H200: {num_inference_steps/inference_time:.1f} steps/segundo")
+        else:
+            print("💾 Memoria CPU")
+        
+        return image
+        
+    except Exception as e:
+        print(f"❌ Error en inferencia: {e}")
+        print(f"🔍 Tipo de error: {type(e).__name__}")
+        print(f"📋 Detalles del error: {str(e)}")
+        # Crear imagen de error
+        error_image = Image.new('RGB', (512, 512), color='red')
+        return error_image
+
+# @spaces.GPU #[uncomment to use ZeroGPU]
+@spaces.GPU
+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
+            result = pipeline(
+                prompt,
+                num_inference_steps=num_inference_steps,
+                num_frames=num_frames,
+                height=256,
+                width=256
+            )
+        elif "animatediff" in model_name.lower():
+            # AnimateDiff models
+            result = pipeline(
+                prompt,
+                num_inference_steps=num_inference_steps,
+                num_frames=num_frames
+            )
+        else:
+            # Text-to-video models (default)
+            result = pipeline(
+                prompt,
+                num_inference_steps=num_inference_steps,
+                num_frames=num_frames
+            )
+        
+        print("Video generado exitosamente")
+        
+        # Manejar diferentes tipos de respuesta
+        if hasattr(result, 'frames'):
+            video_frames = result.frames
+        elif hasattr(result, 'videos'):
+            video_frames = result.videos
+        else:
+            video_frames = result
+        
+        # Convertir a formato compatible con Gradio
+        if isinstance(video_frames, list):
+            if len(video_frames) == 1:
+                return video_frames[0]
+            else:
+                return video_frames
+        else:
+            # Si es un tensor numpy, convertirlo a formato de video
+            if hasattr(video_frames, 'shape'):
+                import numpy as np
+                print(f"Forma del video: {video_frames.shape}")
+                
+                # Convertir a formato de video compatible con Gradio
+                if len(video_frames.shape) == 4:  # (frames, height, width, channels)
+                    # Convertir frames a formato de video
+                    frames_list = []
+                    for i in range(video_frames.shape[0]):
+                        frame = video_frames[i]
+                        # Asegurar que el frame esté en el rango correcto (0-255)
+                        if frame.dtype == np.float32 or frame.dtype == np.float16:
+                            frame = (frame * 255).astype(np.uint8)
+                        frames_list.append(frame)
+                    
+                    # Crear video a partir de frames
+                    import imageio
+                    import tempfile
+                    import os
+                    
+                    # Crear archivo temporal
+                    with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp_file:
+                        temp_path = tmp_file.name
+                    
+                    # Guardar frames como video
+                    imageio.mimsave(temp_path, frames_list, fps=8)
+                    
+                    print(f"Video guardado en: {temp_path}")
+                    return temp_path
+                    
+                elif len(video_frames.shape) == 5:  # (batch, frames, height, width, channels)
+                    # Tomar el primer batch
+                    frames = video_frames[0]
+                    return generate_video(prompt, model_name, num_frames, num_inference_steps)
+                else:
+                    print(f"Forma no reconocida: {video_frames.shape}")
+                    return None
+            else:
+                return video_frames
+        
+    except Exception as e:
+        print(f"Error generando video: {str(e)}")
+        print(f"Tipo de error: {type(e).__name__}")
+        import traceback
+        traceback.print_exc()
+        return f"Error generando video: {str(e)}"
+
+# @spaces.GPU #[uncomment to use ZeroGPU]
+@spaces.GPU
+def generate_video_with_info(prompt, model_name, optimization_level="balanced", input_image=None):
+    """Generar video con información adicional - función para API"""
+    try:
+        print(f"Generando video con modelo: {model_name}")
+        print(f"Prompt: {prompt}")
+        print(f"Optimization level: {optimization_level}")
+        print(f"Input image: {'Sí' if input_image else 'No'}")
+        
+        # Configurar parámetros según el nivel de optimización
+        if optimization_level == "speed":
+            num_frames = 8
+            num_inference_steps = 10
+        elif optimization_level == "quality":
+            num_frames = 16
+            num_inference_steps = 30
+        else:  # balanced
+            num_frames = 12
+            num_inference_steps = 20
+        
+        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
+            result = pipeline(
+                prompt,
+                num_inference_steps=num_inference_steps,
+                num_frames=num_frames,
+                height=256,
+                width=256
+            )
+        elif "animatediff" in model_name.lower():
+            # AnimateDiff models
+            result = pipeline(
+                prompt,
+                num_inference_steps=num_inference_steps,
+                num_frames=num_frames
+            )
+        else:
+            # Text-to-video models (default)
+            result = pipeline(
+                prompt,
+                num_inference_steps=num_inference_steps,
+                num_frames=num_frames
+            )
+        
+        print("Video generado exitosamente")
+        
+        # Manejar diferentes tipos de respuesta
+        if hasattr(result, 'frames'):
+            video_frames = result.frames
+        elif hasattr(result, 'videos'):
+            video_frames = result.videos
+        else:
+            video_frames = result
+        
+        # Convertir a formato compatible con Gradio
+        if isinstance(video_frames, list):
+            if len(video_frames) == 1:
+                return video_frames[0]
+            else:
+                return video_frames
+        else:
+            # Si es un tensor numpy, convertirlo a formato de video
+            if hasattr(video_frames, 'shape'):
+                import numpy as np
+                print(f"Forma del video: {video_frames.shape}")
+                
+                # Convertir a formato de video compatible con Gradio
+                if len(video_frames.shape) == 4:  # (frames, height, width, channels)
+                    # Convertir frames a formato de video
+                    frames_list = []
+                    for i in range(video_frames.shape[0]):
+                        frame = video_frames[i]
+                        # Asegurar que el frame esté en el rango correcto (0-255)
+                        if frame.dtype == np.float32 or frame.dtype == np.float16:
+                            frame = (frame * 255).astype(np.uint8)
+                        frames_list.append(frame)
+                    
+                    # Crear video a partir de frames
+                    import imageio
+                    import tempfile
+                    import os
+                    
+                    # Crear archivo temporal
+                    with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp_file:
+                        temp_path = tmp_file.name
+                    
+                    # Guardar frames como video
+                    imageio.mimsave(temp_path, frames_list, fps=8)
+                    
+                    print(f"Video guardado en: {temp_path}")
+                    return temp_path
+                    
+                elif len(video_frames.shape) == 5:  # (batch, frames, height, width, channels)
+                    # Tomar el primer batch
+                    frames = video_frames[0]
+                    return generate_video_with_info(prompt, model_name, optimization_level, input_image)
+                else:
+                    print(f"Forma no reconocida: {video_frames.shape}")
+                    return None
+            else:
+                return video_frames
+        
+    except Exception as e:
+        print(f"Error generando video: {str(e)}")
+        print(f"Tipo de error: {type(e).__name__}")
+        import traceback
+        traceback.print_exc()
+        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:
+        model_data = load_text_model(model_name)
+        tokenizer = model_data["tokenizer"]
+        model = model_data["model"]
+        
+        # Construir historial de conversación desde el nuevo formato
+        conversation = ""
+        for msg in history:
+            if msg["role"] == "user":
+                conversation += f"User: {msg['content']}\n"
+            elif msg["role"] == "assistant":
+                conversation += f"Assistant: {msg['content']}\n"
+        
+        conversation += f"User: {message}\nAssistant:"
+        
+        # Generar respuesta
+        inputs = tokenizer.encode(conversation, return_tensors="pt", truncation=True, max_length=512)
+        
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs,
+                max_length=inputs.shape[1] + 50,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id
+            )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Extraer solo la respuesta del asistente
+        response = response.split("Assistant:")[-1].strip()
+        
+        # Retornar el historial actualizado con el nuevo formato
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": response})
+        
+        return history
+        
+    except Exception as e:
+        error_msg = f"Error en el chat: {str(e)}"
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": error_msg})
+        return history
+
+# Interfaz de Gradio
+with gr.Blocks(title="Modelos Libres de IA", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🤖 Modelos Libres de IA")
+    gr.Markdown("### Genera texto e imágenes sin límites de cuota")
+    
+    with gr.Tabs():
+        # Tab de Generación de Texto
+        with gr.TabItem("📝 Generación de Texto"):
+            with gr.Row():
+                with gr.Column():
+                    text_model = gr.Dropdown(
+                        choices=list(MODELS["text"].keys()),
+                        value="microsoft/DialoGPT-medium",
+                        label="Modelo de Texto"
+                    )
+                    text_prompt = gr.Textbox(
+                        label="Prompt",
+                        placeholder="Escribe tu prompt aquí...",
+                        lines=3
+                    )
+                    max_length = gr.Slider(
+                        minimum=50,
+                        maximum=200,
+                        value=100,
+                        step=10,
+                        label="Longitud máxima"
+                    )
+                    text_btn = gr.Button("Generar Texto", variant="primary")
+                
+                with gr.Column():
+                    text_output = gr.Textbox(
+                        label="Resultado",
+                        lines=10,
+                        interactive=False
+                    )
+            
+            text_btn.click(
+                generate_text,
+                inputs=[text_prompt, text_model, max_length],
+                outputs=text_output
+            )
+        
+        # Tab de Chat
+        with gr.TabItem("💬 Chat"):
+            with gr.Row():
+                with gr.Column():
+                    chat_model = gr.Dropdown(
+                        choices=list(MODELS["chat"].keys()),
+                        value="microsoft/DialoGPT-medium",
+                        label="Modelo de Chat"
+                    )
+                
+                with gr.Column():
+                    chatbot = gr.Chatbot(
+                        label="Chat",
+                        height=400,
+                        type="messages"
+                    )
+                    chat_input = gr.Textbox(
+                        label="Mensaje",
+                        placeholder="Escribe tu mensaje...",
+                        lines=2
+                    )
+                    chat_btn = gr.Button("Enviar", variant="primary")
+            
+            chat_btn.click(
+                chat_with_model,
+                inputs=[chat_input, chatbot, chat_model],
+                outputs=[chatbot]
+            )
+            
+            chat_input.submit(
+                chat_with_model,
+                inputs=[chat_input, chatbot, chat_model],
+                outputs=[chatbot]
+            )
+        
+        # Tab de Traducción
+        with gr.TabItem("🌐 Traducción"):
+            with gr.Row():
+                with gr.Column():
+                    translate_model = gr.Dropdown(
+                        choices=["Helsinki-NLP/opus-mt-es-en", "Helsinki-NLP/opus-mt-en-es"],
+                        value="Helsinki-NLP/opus-mt-es-en",
+                        label="Modelo de Traducción"
+                    )
+                    translate_text = gr.Textbox(
+                        label="Texto a traducir",
+                        placeholder="Escribe el texto que quieres traducir...",
+                        lines=3
+                    )
+                    translate_btn = gr.Button("Traducir", variant="primary")
+                
+                with gr.Column():
+                    translate_output = gr.Textbox(
+                        label="Traducción",
+                        lines=3,
+                        interactive=False
+                    )
+            
+            translate_btn.click(
+                generate_text,
+                inputs=[translate_text, translate_model, gr.Slider(value=100, visible=False)],
+                outputs=translate_output
+            )
+        
+        # Tab de Generación de Imágenes
+        with gr.TabItem("🎨 Generación de Imágenes"):
+            with gr.Row():
+                with gr.Column():
+                    # Modelo
+                    image_model = gr.Dropdown(
+                        choices=list(MODELS["image"].keys()),
+                        value="CompVis/stable-diffusion-v1-4",
+                        label="Modelo",
+                        info="Select a high-quality model (FLUX models require HF_TOKEN)"
+                    )
+                    
+                    # Prompt principal
+                    image_prompt = gr.Textbox(
+                        label="Prompt",
+                        placeholder="Describe la imagen que quieres generar...",
+                        lines=3
+                    )
+                    
+                    # Negative prompt
+                    negative_prompt = gr.Textbox(
+                        label="Negative prompt",
+                        placeholder="Enter a negative prompt (optional)",
+                        lines=2
+                    )
+                    
+                    # Advanced Settings
+                    with gr.Accordion("Advanced Settings", open=False):
+                        with gr.Row():
+                            with gr.Column():
+                                seed = gr.Slider(
+                                    minimum=0,
+                                    maximum=2147483647,
+                                    value=324354329,
+                                    step=1,
+                                    label="Seed",
+                                    info="Random seed for generation"
+                                )
+                                randomize_seed = gr.Checkbox(
+                                    value=True,
+                                    label="Randomize seed"
+                                )
+                            
+                            with gr.Column():
+                                width = gr.Slider(
+                                    minimum=256,
+                                    maximum=1024,
+                                    value=1024,
+                                    step=64,
+                                    label="Width"
+                                )
+                                height = gr.Slider(
+                                    minimum=256,
+                                    maximum=1024,
+                                    value=1024,
+                                    step=64,
+                                    label="Height"
+                                )
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                guidance_scale = gr.Slider(
+                                    minimum=0,
+                                    maximum=20,
+                                    value=8.5,
+                                    step=0.1,
+                                    label="Guidance scale",
+                                    info="Controls how closely the image follows the prompt (higher = more adherence)"
+                                )
+                                num_inference_steps = gr.Slider(
+                                    minimum=1,
+                                    maximum=100,
+                                    value=31,
+                                    step=1,
+                                    label="Number of inference steps",
+                                    info="More steps = higher quality but slower generation"
+                                )
+                            
+                            with gr.Column():
+                                eta = gr.Slider(
+                                    minimum=0,
+                                    maximum=1,
+                                    value=0,
+                                    step=0.1,
+                                    label="Eta (DDIM)",
+                                    info="DDIM eta parameter (0 = deterministic, 1 = stochastic)"
+                                )
+                                strength = gr.Slider(
+                                    minimum=0,
+                                    maximum=1,
+                                    value=1,
+                                    step=0.1,
+                                    label="Strength",
+                                    info="Strength of the transformation (for img2img models)"
+                                )
+                        
+                        with gr.Row():
+                            num_images = gr.Slider(
+                                minimum=1,
+                                maximum=4,
+                                value=1,
+                                step=1,
+                                label="Images per prompt",
+                                info="Number of images to generate (may slow down generation)"
+                            )
+                            safety_checker = gr.Checkbox(
+                                value=True,
+                                label="Enable content safety filtering"
+                            )
+                    
+                    # Botón de generación
+                    image_btn = gr.Button("Generar Imagen", variant="primary")
+                
+                with gr.Column():
+                    # Información del modelo
+                    model_info = gr.Markdown(
+                        value="**Model Info:** CompVis/stable-diffusion-v1-4\n\n"
+                              "🎨 Stable Diffusion v1.4 • Recommended steps: 20-50 • "
+                              "Guidance scale: 7.5-15 • Best for: General purpose\n\n"
+                              "**Status:** ✅ Available"
+                    )
+                    
+                    # Ejemplos
+                    examples = gr.Examples(
+                        examples=[
+                            ["Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"],
+                            ["An astronaut riding a green horse"],
+                            ["A delicious ceviche cheesecake slice"],
+                            ["Futuristic AI assistant in a glowing galaxy, neon lights, sci-fi style, cinematic"],
+                            ["Portrait of a beautiful woman, realistic, high quality, detailed"],
+                            ["Anime girl with blue hair, detailed, high quality"],
+                            ["Cyberpunk city at night, neon lights, detailed, 8k"],
+                            ["Fantasy landscape with mountains and dragons, epic, detailed"]
+                        ],
+                        inputs=image_prompt
+                    )
+                    
+                    # Output de imagen
+                    image_output = gr.Image(
+                        label="Imagen Generada",
+                        type="pil"
+                    )
+            
+            # Función para actualizar info del modelo
+            def update_model_info(model_name):
+                model_descriptions = {
+                    "CompVis/stable-diffusion-v1-4": "🎨 Stable Diffusion v1.4 • Recommended steps: 20-50 • Guidance scale: 7.5-15 • Best for: General purpose",
+                    "stabilityai/stable-diffusion-2-1": "🎨 Stable Diffusion 2.1 • Recommended steps: 20-50 • Guidance scale: 7.5-15 • Best for: High quality",
+                    "stabilityai/stable-diffusion-xl-base-1.0": "🎨 SDXL Base • Recommended steps: 25-50 • Guidance scale: 7.5-15 • Best for: High resolution",
+                    "stabilityai/sdxl-turbo": "⚡ SDXL Turbo • Recommended steps: 1-4 • Guidance scale: 1.0 • Best for: Fast generation",
+                    "stabilityai/sd-turbo": "⚡ SD Turbo • Recommended steps: 1-4 • Guidance scale: 1.0 • Best for: Fast generation",
+                    "black-forest-labs/FLUX.1-dev": "🔐 FLUX Model - High quality • Recommended steps: 20-50 • Guidance scale: 3.5-7.5 • Best for: Professional results",
+                    "black-forest-labs/FLUX.1-schnell": "🔐 FLUX Schnell - Fast quality • Recommended steps: 15-30 • Guidance scale: 3.5-7.5 • Best for: Quick professional results"
+                }
+                
+                description = model_descriptions.get(model_name, "🎨 Model • Recommended steps: 20-50 • Guidance scale: 7.5-15 • Best for: General purpose")
+                return f"**Model Info:** {model_name}\n\n{description}\n\n**Status:** ✅ Available"
+            
+            # Eventos
+            image_model.change(
+                update_model_info,
+                inputs=[image_model],
+                outputs=[model_info]
+                    )
+            
+            image_btn.click(
+                generate_image,
+                inputs=[
+                    image_prompt, 
+                    image_model, 
+                    negative_prompt,
+                    seed,
+                    randomize_seed,
+                    width,
+                    height,
+                    guidance_scale,
+                    num_inference_steps,
+                    eta,
+                    strength,
+                    num_images,
+                    safety_checker
+                ],
+                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
+            )
+
+        # Agregar endpoint para generate_video_with_info dentro del contexto de Gradio
+demo.load(
+    generate_video_with_info,
+    inputs=[
+        gr.Textbox(label="Prompt", placeholder="Describe el video..."),
+        gr.Dropdown(choices=list(MODELS["video"].keys()), label="Modelo"),
+        gr.Dropdown(choices=["speed", "balanced", "quality"], value="balanced", label="Optimización"),
+        gr.Image(label="Imagen de entrada (opcional)", type="pil")
+    ],
+    outputs=gr.Video(label="Video Generado", format="mp4"),
+    api_name="generate_video_with_info"
+)
+
+# Configuración para Hugging Face Spaces
+if __name__ == "__main__":
+    demo.launch()