Mejora configuración FLUX: autenticación, manejo de errores y optimización de memoria

README.md

@@ -46,7 +46,29 @@ git push
 
 ### Variables de Entorno
 
-- `HF_TOKEN`: Token de Hugging Face para modelos gated
+Para usar modelos gated como **FLUX.1-dev** y **FLUX.1-schnell**, necesitas configurar:
+
+#### 1. Obtener Token de Hugging Face
+1. Ve a [Hugging Face Settings](https://huggingface.co/settings/tokens)
+2. Crea un nuevo token con permisos de **read**
+3. Copia el token generado
+
+#### 2. Configurar Token en el Space
+1. Ve a tu Space: https://huggingface.co/spaces/Ntdeseb/ntia
+2. Haz clic en **Settings** (⚙️)
+3. En la sección **Variables and secrets**
+4. Agrega una nueva variable:
+   - **Name**: `HF_TOKEN`
+   - **Value**: `hf_tu_token_aqui`
+   - **Type**: `Secret` ✅
+5. Guarda los cambios
+6. Reinicia el Space
+
+#### 3. Verificar Acceso a Modelos FLUX
+1. Ve a [FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev)
+2. Haz clic en **Access** para solicitar acceso
+3. Acepta los términos de licencia
+4. Repite para [FLUX.1-schnell](https://huggingface.co/black-forest-labs/FLUX.1-schnell)
 
 ### Dependencias
 

app.py

@@ -18,10 +18,47 @@ if HF_TOKEN:
     try:
         login(token=HF_TOKEN)
         print("✅ Autenticado con Hugging Face")
+        print(f"🔑 Token configurado: {HF_TOKEN[:10]}...{HF_TOKEN[-10:] if len(HF_TOKEN) > 20 else '***'}")
     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):
@@ -192,29 +229,66 @@ def load_image_model(model_name):
         try:
             # 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'}")
+                    
+                    # Configuración optimizada para Spaces
                     pipe = FluxPipeline.from_pretrained(
                         model_name,
-                        torch_dtype=torch.float32,  # ✅ Cambiado a float32 para ahorrar memoria
-                        use_auth_token=HF_TOKEN if HF_TOKEN else None
+                        torch_dtype=torch.float32,  # ✅ Usar float32 para ahorrar memoria
+                        use_auth_token=HF_TOKEN,
+                        device_map="auto",  # ✅ Distribuir automáticamente en GPU/CPU
+                        low_cpu_mem_usage=True  # ✅ Reducir uso de memoria CPU
                     )
-                    # Solo usar enable_model_cpu_offload si hay acelerador disponible
+                    
+                    print("✅ FLUX Pipeline cargado exitosamente")
+                    
+                    # Optimizaciones de memoria solo si están disponibles
+                    try:
+                        pipe.enable_attention_slicing()
+                        print("✅ Attention slicing habilitado")
+                    except Exception as e:
+                        print(f"⚠️ No se pudo habilitar attention slicing: {e}")
+                    
+                    try:
+                        pipe.enable_vae_slicing()
+                        print("✅ VAE slicing habilitado")
+                    except Exception as e:
+                        print(f"⚠️ No se pudo habilitar VAE slicing: {e}")
+                    
+                    # CPU offload solo si hay suficiente memoria
                     try:
                         pipe.enable_model_cpu_offload()
-                        print("✅ FLUX con CPU offload habilitado")
+                        print("✅ CPU offload habilitado")
                     except Exception as offload_error:
                         print(f"⚠️ No se pudo habilitar CPU offload: {offload_error}")
-                        print("✅ FLUX cargado sin CPU offload")
+                        print("✅ FLUX funcionará sin CPU offload")
                     
-                    # Optimizaciones adicionales para ahorrar memoria
-                    pipe.enable_attention_slicing()
-                    pipe.enable_vae_slicing()
-                    print("✅ Optimizaciones de memoria aplicadas a FLUX")
+                    print("✅ FLUX completamente configurado y listo")
                     
                 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")
+                    
+                    # Si es un error de memoria, sugerir optimizaciones
+                    elif "out of memory" in str(e).lower() or "cuda" in str(e).lower():
+                        print("💾 Error de memoria. El modelo FLUX requiere mucha memoria.")
+                        print("   Considera usar un Space con más GPU o usar FLUX.1-schnell en su lugar.")
+                    
                     # Fallback a Stable Diffusion
                     print("🔄 Fallback a Stable Diffusion...")
                     pipe = StableDiffusionPipeline.from_pretrained(
@@ -495,18 +569,45 @@ def generate_image(prompt, model_name, num_inference_steps=20):
             # Generar un seed aleatorio para cada imagen
             random_seed = random.randint(0, 999999)
             print(f"🎲 Usando seed aleatorio para FLUX: {random_seed}")
-            print(f"🔧 Parámetros FLUX OPTIMIZADOS: guidance_scale=3.5, steps=25, max_seq=256, height=512")
+            print(f"🔧 Parámetros FLUX OPTIMIZADOS: guidance_scale=3.5, steps=15, max_seq=256, height=512")
             
-            # Parámetros optimizados para reducir memoria y tiempo
-            image = pipeline(
-                prompt,
-                height=512,  # ✅ Reducido de 1024 a 512 para ahorrar memoria
-                width=512,   # ✅ Reducido de 1024 a 512 para ahorrar memoria
-                guidance_scale=3.5,  # ✅ Valor recomendado por la documentación
-                num_inference_steps=25,  # ✅ Reducido de 50 a 25 para ahorrar tiempo
-                max_sequence_length=256,  # ✅ Reducido de 512 a 256 para ahorrar memoria
-                generator=torch.Generator("cpu").manual_seed(random_seed)  # ✅ Seed aleatorio
-            ).images[0]
+            try:
+                # Parámetros optimizados para reducir memoria y tiempo
+                image = pipeline(
+                    prompt,
+                    height=512,  # ✅ Reducido de 1024 a 512 para ahorrar memoria
+                    width=512,   # ✅ Reducido de 1024 a 512 para ahorrar memoria
+                    guidance_scale=3.5,  # ✅ Valor recomendado por la documentación
+                    num_inference_steps=15,  # ✅ Reducido de 25 a 15 para ahorrar tiempo
+                    max_sequence_length=256,  # ✅ Reducido de 512 a 256 para ahorrar memoria
+                    generator=torch.Generator("cpu").manual_seed(random_seed)  # ✅ Seed aleatorio
+                ).images[0]
+                
+                print("✅ Imagen FLUX generada exitosamente")
+                
+            except Exception as e:
+                print(f"❌ Error generando imagen FLUX: {e}")
+                print(f"🔍 Tipo de error: {type(e).__name__}")
+                
+                # Si es un error de memoria, intentar con parámetros más conservadores
+                if "out of memory" in str(e).lower() or "cuda" in str(e).lower():
+                    print("💾 Error de memoria, intentando con parámetros más conservadores...")
+                    try:
+                        image = pipeline(
+                            prompt,
+                            height=384,  # ✅ Aún más pequeño
+                            width=384,   # ✅ Aún más pequeño
+                            guidance_scale=3.0,  # ✅ Reducido
+                            num_inference_steps=10,  # ✅ Menos pasos
+                            max_sequence_length=128,  # ✅ Secuencia más corta
+                            generator=torch.Generator("cpu").manual_seed(random_seed)
+                        ).images[0]
+                        print("✅ Imagen FLUX generada con parámetros conservadores")
+                    except Exception as e2:
+                        print(f"❌ Error incluso con parámetros conservadores: {e2}")
+                        raise e2
+                else:
+                    raise e
         
         # Configuración específica para modelos Turbo (rápidos)
         elif any(turbo_model in model_name.lower() for turbo_model in ["sdxl-turbo", "sd-turbo", "sdxl-lightning"]):

check_config.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+Script para verificar la configuración del Space NTIA
+"""
+
+import os
+import sys
+from huggingface_hub import login, model_info
+
+def check_hf_token():
+    """Verificar si el token de Hugging Face está configurado"""
+    token = os.getenv("HF_TOKEN")
+    if not token:
+        print("❌ HF_TOKEN no está configurado")
+        print("💡 Configura la variable de entorno HF_TOKEN en el Space")
+        return False
+    
+    print(f"✅ HF_TOKEN encontrado: {token[:10]}...{token[-10:] if len(token) > 20 else '***'}")
+    return True
+
+def check_flux_access():
+    """Verificar acceso a modelos FLUX"""
+    token = os.getenv("HF_TOKEN")
+    if not token:
+        print("❌ No se puede verificar acceso sin HF_TOKEN")
+        return False
+    
+    try:
+        # Intentar acceder a FLUX.1-dev
+        print("🔍 Verificando acceso a FLUX.1-dev...")
+        info = model_info("black-forest-labs/FLUX.1-dev", token=token)
+        print(f"✅ Acceso a FLUX.1-dev: {info.modelId}")
+        
+        # Intentar acceder a FLUX.1-schnell
+        print("🔍 Verificando acceso a FLUX.1-schnell...")
+        info = model_info("black-forest-labs/FLUX.1-schnell", token=token)
+        print(f"✅ Acceso a FLUX.1-schnell: {info.modelId}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error verificando acceso a FLUX: {e}")
+        print("💡 Asegúrate de:")
+        print("   1. Tener acceso a los modelos FLUX en Hugging Face")
+        print("   2. Que el token tenga permisos de lectura")
+        print("   3. Haber aceptado los términos de licencia")
+        return False
+
+def check_dependencies():
+    """Verificar dependencias necesarias"""
+    try:
+        import torch
+        print(f"✅ PyTorch: {torch.__version__}")
+        
+        import diffusers
+        print(f"✅ Diffusers: {diffusers.__version__}")
+        
+        from diffusers import FluxPipeline
+        print("✅ FluxPipeline disponible")
+        
+        return True
+        
+    except ImportError as e:
+        print(f"❌ Dependencia faltante: {e}")
+        return False
+
+def main():
+    """Función principal"""
+    print("🔧 Verificando configuración del Space NTIA...")
+    print("=" * 50)
+    
+    # Verificar token
+    token_ok = check_hf_token()
+    print()
+    
+    # Verificar dependencias
+    deps_ok = check_dependencies()
+    print()
+    
+    # Verificar acceso a FLUX
+    if token_ok:
+        flux_ok = check_flux_access()
+    else:
+        flux_ok = False
+    print()
+    
+    # Resumen
+    print("=" * 50)
+    print("📊 RESUMEN DE CONFIGURACIÓN:")
+    print(f"   Token HF: {'✅' if token_ok else '❌'}")
+    print(f"   Dependencias: {'✅' if deps_ok else '❌'}")
+    print(f"   Acceso FLUX: {'✅' if flux_ok else '❌'}")
+    
+    if token_ok and deps_ok and flux_ok:
+        print("\n🎉 ¡Todo configurado correctamente!")
+        print("   Los modelos FLUX deberían funcionar en el Space")
+    else:
+        print("\n⚠️ Hay problemas de configuración:")
+        if not token_ok:
+            print("   - Configura HF_TOKEN en las variables de entorno del Space")
+        if not deps_ok:
+            print("   - Instala las dependencias necesarias")
+        if not flux_ok:
+            print("   - Solicita acceso a los modelos FLUX en Hugging Face")
+
+if __name__ == "__main__":
+    main()