Agregados todos los modelos exitosos del Space test - FLUX, Turbo, Lightning, optimizaciones H200 completas

app.py

@@ -61,19 +61,75 @@ else:
 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",
-        "distilgpt2": "GPT-2 optimizado"
+        "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",
+        # ⚡ Modelos Turbo (rápidos) - Optimizados para H200
+        "stabilityai/sdxl-turbo": "⚡ SDXL Turbo",
+        "stabilityai/sd-turbo": "⚡ SD Turbo",
+        "ByteDance/SDXL-Lightning": "⚡ SDXL Lightning",
+        
+        # 🎨 Modelos base de alta calidad
         "stabilityai/stable-diffusion-xl-base-1.0": "SDXL Base",
+        "stabilityai/stable-diffusion-2-1": "Stable Diffusion 2.1",
+        "CompVis/stable-diffusion-v1-4": "Stable Diffusion v1.4 (Libre)",
+        "runwayml/stable-diffusion-v1-5": "Stable Diffusion v1.5",
+        
+        # 🎭 Modelos de estilo específico
         "prompthero/openjourney": "Midjourney Style",
-        "hakurei/waifu-diffusion": "Waifu Diffusion"
+        "prompthero/openjourney-v4": "OpenJourney v4",
+        "WarriorMama777/OrangeMixs": "Orange Mixs",
+        "hakurei/waifu-diffusion": "Waifu Diffusion",
+        "SG161222/Realistic_Vision_V5.1_noVAE": "Realistic Vision",
+        "Linaqruf/anything-v3.0": "Anything v3",
+        "XpucT/deliberate-v2": "Deliberate v2",
+        "dreamlike-art/dreamlike-diffusion-1.0": "Dreamlike Diffusion",
+        "KBlueLeaf/kohaku-v2.1": "Kohaku V2.1",
+        
+        # 🔐 Modelos FLUX (requieren HF_TOKEN)
+        "black-forest-labs/FLUX.1-dev": "FLUX.1 Dev (Requiere acceso)",
+        "black-forest-labs/FLUX.1-schnell": "FLUX.1 Schnell (Requiere acceso)",
+        
+        # 📦 Modelos adicionales
+        "CompVis/ldm-text2im-large-256": "Latent Diffusion Model 256"
     },
     "video": {
         "damo-vilab/text-to-video-ms-1.7b": "Text-to-Video MS 1.7B (Libre)",
-        "cerspense/zeroscope_v2_576w": "Zeroscope v2 576w (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"
     }
 }
 
@@ -118,43 +174,392 @@ def load_text_model(model_name):
 def load_image_model(model_name):
     """Cargar modelo de imagen optimizado para H200"""
     if model_name not in model_cache:
-        print(f"Cargando modelo de imagen: {model_name}")
+        print(f"\n🔄 Iniciando carga del modelo: {model_name}")
         
         try:
-            pipe = StableDiffusionPipeline.from_pretrained(
-                model_name,
-                torch_dtype=torch_dtype,
-                safety_checker=None
-            )
+            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() or "black-forest" in model_name.lower():
+                if not HF_TOKEN:
+                    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 para H200
+            # Optimizaciones específicas para H200
             if torch.cuda.is_available():
-                pipe.enable_attention_slicing()
-                pipe.enable_vae_slicing()
+                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'):
-                    try:
-                        pipe.enable_xformers_memory_efficient_attention()
-                    except:
-                        pass
+                    # 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 {model_name}: {e}")
-            # Fallback
-            pipe = StableDiffusionPipeline.from_pretrained(
-                "CompVis/stable-diffusion-v1-4",
-                torch_dtype=torch_dtype,
-                safety_checker=None
-            )
-            pipe = pipe.to(device)
-            model_cache[model_name] = pipe
+            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]
 
+@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)}"
+
 def generate_text(prompt, model_name, max_length=100):
     """Generar texto con el modelo seleccionado"""
     try:
@@ -188,28 +593,172 @@ def generate_text(prompt, model_name, max_length=100):
 def generate_image(prompt, model_name, negative_prompt="", seed=0, width=1024, height=1024, guidance_scale=7.5, num_inference_steps=20):
     """Generar imagen optimizada para H200"""
     try:
-        print(f"Generando imagen: {prompt}")
+        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}")
+        print(f"📐 Dimensiones: {width}x{height}")
+        print(f"🎯 Guidance scale: {guidance_scale}")
+        
+        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")
+        
+        # Cargar el modelo
         pipe = load_image_model(model_name)
         
+        # 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}")
+        
         generator = torch.Generator(device=device).manual_seed(seed)
         
-        result = pipe(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            height=height,
-            width=width,
-            guidance_scale=guidance_scale,
-            num_inference_steps=num_inference_steps,
-            generator=generator
-        )
-        
-        image = result.images[0]
-        print("✅ Imagen generada exitosamente")
+        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
+            }
+            
+            # Agregar parámetros opcionales
+            if negative_prompt and negative_prompt.strip():
+                generation_kwargs["negative_prompt"] = negative_prompt.strip()
+            
+            # Generar la imagen
+            result = pipe(**generation_kwargs)
+            
+            # Verificar que la imagen se generó correctamente
+            if hasattr(result, 'images') and len(result.images) > 0:
+                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
+            }
+            
+            if negative_prompt and negative_prompt.strip():
+                generation_kwargs["negative_prompt"] = negative_prompt.strip()
+            
+            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 generando imagen: {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
 
@@ -254,10 +803,45 @@ def chat_with_model(message, history, model_name):
         history.append({"role": "assistant", "content": error_msg})
         return history
 
+# 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)
+
 # 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")
+    gr.Markdown("### Genera texto, imágenes y videos sin límites de cuota")
     
     with gr.Tabs():
         # Tab de Generación de Texto
@@ -301,7 +885,7 @@ with gr.Blocks(title="Modelos Libres de IA", theme=gr.themes.Soft()) as demo:
             with gr.Row():
                 with gr.Column():
                     chat_model = gr.Dropdown(
-                        choices=list(MODELS["text"].keys()),
+                        choices=list(MODELS["chat"].keys()),
                         value="microsoft/DialoGPT-medium",
                         label="Modelo de Chat"
                     )
@@ -331,86 +915,166 @@ with gr.Blocks(title="Modelos Libres de IA", theme=gr.themes.Soft()) as demo:
                 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"
+                        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
                     )
                     
-                    with gr.Row():
-                        seed = gr.Slider(
-                            minimum=0,
-                            maximum=2147483647,
-                            value=324354329,
-                            step=1,
-                            label="Seed"
-                        )
-                        guidance_scale = gr.Slider(
-                            minimum=0,
-                            maximum=20,
-                            value=7.5,
-                            step=0.1,
-                            label="Guidance scale"
-                        )
-                    
-                    with gr.Row():
-                        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"
-                        )
-                    
-                    num_inference_steps = gr.Slider(
-                        minimum=1,
-                        maximum=100,
-                        value=20,
-                        step=1,
-                        label="Number of inference steps"
-                    )
+                    # 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"
+                                )
+                            
+                            with gr.Column():
+                                guidance_scale = gr.Slider(
+                                    minimum=0,
+                                    maximum=20,
+                                    value=7.5,
+                                    step=0.1,
+                                    label="Guidance scale",
+                                    info="Controls how closely the image follows the prompt (higher = more adherence)"
+                                )
+                        
+                        with gr.Row():
+                            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.Column():
+                                num_inference_steps = gr.Slider(
+                                    minimum=1,
+                                    maximum=100,
+                                    value=20,
+                                    step=1,
+                                    label="Number of inference steps",
+                                    info="More steps = higher quality but slower generation"
+                                )
                     
+                    # 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"]
+                            ["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=[
@@ -425,6 +1089,48 @@ with gr.Blocks(title="Modelos Libres de IA", theme=gr.themes.Soft()) as demo:
                 ],
                 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__":