Actualizando con modelos IA personalizados

README.md

@@ -1,14 +1,122 @@
 ---
-title: Ntia
-emoji: 🖼
-colorFrom: purple
+title: Modelos Ia Simple
+emoji: 🦀
+colorFrom: indigo
 colorTo: red
 sdk: gradio
-sdk_version: 5.25.2
+sdk_version: 5.38.2
 app_file: app.py
 pinned: false
-license: apache-2.0
-short_description: ntdesweb
+license: mit
+short_description: Modelos libres de IA
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🤖 Modelos Libres de IA
+
+Un Space de Hugging Face que proporciona acceso gratuito a modelos de IA para generación de texto e imágenes sin límites de cuota.
+
+## 🚀 Características
+
+- **Generación de Texto**: Múltiples modelos de lenguaje como DialoGPT, GPT-2, y GPT-Neo
+- **Chat Conversacional**: Interfaz de chat con DialoGPT
+- **Generación de Imágenes**: Stable Diffusion v1.4 y v1.5
+- **Sin Límites**: Uso ilimitado sin costos
+- **Interfaz Intuitiva**: Gradio con diseño moderno
+
+## 📋 Modelos Disponibles
+
+### Texto
+- `microsoft/DialoGPT-medium` - Chat conversacional
+- `gpt2` - Generación de texto
+- `distilgpt2` - GPT-2 optimizado
+- `EleutherAI/gpt-neo-125M` - GPT-Neo pequeño
+
+### Imágenes
+- `runwayml/stable-diffusion-v1-5` - Stable Diffusion v1.5
+- `CompVis/stable-diffusion-v1-4` - Stable Diffusion v1.4
+
+## 🛠️ Instalación Local
+
+Si quieres ejecutar esto localmente:
+
+```bash
+# Clonar el repositorio
+git clone <tu-repositorio>
+cd huggingface-space
+
+# Instalar dependencias
+pip install -r requirements.txt
+
+# Ejecutar la aplicación
+python app.py
+```
+
+## 🌐 Uso en Hugging Face Spaces
+
+1. Ve a [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Haz clic en "Create new Space"
+3. Selecciona "Gradio" como SDK
+4. Sube estos archivos a tu Space
+5. ¡Listo! Tu aplicación estará disponible en `https://huggingface.co/spaces/tu-usuario/tu-space`
+
+## 💡 Consejos de Uso
+
+### Para Texto
+- Usa prompts claros y específicos
+- Ajusta la longitud máxima según tus necesidades
+- DialoGPT es mejor para conversaciones
+
+### Para Imágenes
+- Describe detalladamente lo que quieres ver
+- Ajusta los pasos de inferencia (más pasos = mejor calidad pero más lento)
+- Usa palabras descriptivas y específicas
+
+## 🔧 Configuración Avanzada
+
+### Agregar Nuevos Modelos
+
+Para agregar más modelos, edita el diccionario `MODELS` en `app.py`:
+
+```python
+MODELS = {
+    "text": {
+        "nuevo-modelo/texto": "Descripción",
+        # ... más modelos
+    },
+    "image": {
+        "nuevo-modelo/imagen": "Descripción",
+        # ... más modelos
+    }
+}
+```
+
+### Optimización de Rendimiento
+
+- Los modelos se cargan en caché para reutilización
+- Usa GPU si está disponible para mejor rendimiento
+- Ajusta los parámetros de generación según tus necesidades
+
+## 📝 Licencia
+
+Este proyecto está bajo la licencia MIT. Los modelos individuales tienen sus propias licencias.
+
+## 🤝 Contribuciones
+
+¡Las contribuciones son bienvenidas! Puedes:
+- Agregar nuevos modelos
+- Mejorar la interfaz
+- Optimizar el rendimiento
+- Reportar bugs
+
+## 📞 Soporte
+
+Si tienes problemas o preguntas:
+1. Revisa los logs del Space
+2. Verifica que todos los archivos estén subidos correctamente
+3. Asegúrate de que las dependencias estén actualizadas
+
+---
+
+**¡Disfruta usando modelos de IA sin límites! 🎉**
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference 

app.py

@@ -1,154 +1,274 @@
 import gradio as gr
-import numpy as np
-import random
-
-# import spaces #[uncomment to use ZeroGPU]
-from diffusers import DiffusionPipeline
 import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from diffusers import StableDiffusionPipeline, DiffusionPipeline
+import requests
+from PIL import Image
+import io
+import base64
 
-device = "cuda" if torch.cuda.is_available() else "cpu"
-model_repo_id = "stabilityai/sdxl-turbo"  # Replace to the model you would like to use
-
-if torch.cuda.is_available():
-    torch_dtype = torch.float16
-else:
-    torch_dtype = torch.float32
-
-pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype)
-pipe = pipe.to(device)
-
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
-
-
-# @spaces.GPU #[uncomment to use ZeroGPU]
-def infer(
-    prompt,
-    negative_prompt,
-    seed,
-    randomize_seed,
-    width,
-    height,
-    guidance_scale,
-    num_inference_steps,
-    progress=gr.Progress(track_tqdm=True),
-):
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-
-    generator = torch.Generator().manual_seed(seed)
-
-    image = pipe(
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        guidance_scale=guidance_scale,
-        num_inference_steps=num_inference_steps,
-        width=width,
-        height=height,
-        generator=generator,
-    ).images[0]
-
-    return image, seed
-
+# Configuración de modelos libres
+MODELS = {
+    "text": {
+        "microsoft/DialoGPT-medium": "Chat conversacional",
+        "gpt2": "Generación de texto",
+        "distilgpt2": "GPT-2 optimizado",
+        "EleutherAI/gpt-neo-125M": "GPT-Neo pequeño"
+    },
+    "image": {
+        "runwayml/stable-diffusion-v1-5": "Stable Diffusion v1.5",
+        "CompVis/stable-diffusion-v1-4": "Stable Diffusion v1.4"
+    }
+}
 
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
+# Cache para los modelos
+model_cache = {}
 
-css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 640px;
-}
-"""
+def load_text_model(model_name):
+    """Cargar modelo de texto"""
+    if model_name not in model_cache:
+        print(f"Cargando modelo de texto: {model_name}")
+        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"
+        }
+    
+    return model_cache[model_name]
 
-with gr.Blocks(css=css) as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(" # Text-to-Image Gradio Template")
+def load_image_model(model_name):
+    """Cargar modelo de imagen"""
+    if model_name not in model_cache:
+        print(f"Cargando modelo de imagen: {model_name}")
+        pipe = StableDiffusionPipeline.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
+        )
+        
+        if torch.cuda.is_available():
+            pipe = pipe.to("cuda")
+        
+        model_cache[model_name] = {
+            "pipeline": pipe,
+            "type": "image"
+        }
+    
+    return model_cache[model_name]
 
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
+def generate_text(prompt, model_name, max_length=100):
+    """Generar texto con el modelo seleccionado"""
+    try:
+        model_data = load_text_model(model_name)
+        tokenizer = model_data["tokenizer"]
+        model = model_data["model"]
+        
+        # Preparar input
+        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)}"
 
-            run_button = gr.Button("Run", scale=0, variant="primary")
-
-        result = gr.Image(label="Result", show_label=False)
+def generate_image(prompt, model_name, num_inference_steps=20):
+    """Generar imagen con el modelo seleccionado"""
+    try:
+        model_data = load_image_model(model_name)
+        pipeline = model_data["pipeline"]
+        
+        # Generar imagen
+        image = pipeline(
+            prompt,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=7.5
+        ).images[0]
+        
+        return image
+    
+    except Exception as e:
+        return f"Error generando imagen: {str(e)}"
 
-        with gr.Accordion("Advanced Settings", open=False):
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
+def chat_with_model(message, history, model_name):
+    """Función de chat para DialoGPT"""
+    try:
+        model_data = load_text_model(model_name)
+        tokenizer = model_data["tokenizer"]
+        model = model_data["model"]
+        
+        # Construir historial de conversación
+        conversation = ""
+        for user_msg, bot_msg in history:
+            conversation += f"User: {user_msg}\n"
+            if bot_msg:
+                conversation += f"Assistant: {bot_msg}\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()
+        
+        return response
+    
+    except Exception as e:
+        return f"Error en el chat: {str(e)}"
 
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
+# 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
             )
-
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-
+        
+        # Tab de Chat
+        with gr.TabItem("💬 Chat"):
             with gr.Row():
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
-
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=1024,  # Replace with defaults that work for your model
-                )
-
+                with gr.Column():
+                    chat_model = gr.Dropdown(
+                        choices=["microsoft/DialoGPT-medium"],
+                        value="microsoft/DialoGPT-medium",
+                        label="Modelo de Chat"
+                    )
+                
+                with gr.Column():
+                    chatbot = gr.Chatbot(
+                        label="Chat",
+                        height=400
+                    )
+                    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],
+                clear_input=True
+            )
+            
+            chat_input.submit(
+                chat_with_model,
+                inputs=[chat_input, chatbot, chat_model],
+                outputs=[chatbot],
+                clear_input=True
+            )
+        
+        # Tab de Generación de Imágenes
+        with gr.TabItem("🎨 Generación de Imágenes"):
             with gr.Row():
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
-                )
-
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=50,
-                    step=1,
-                    value=2,  # Replace with defaults that work for your model
-                )
-
-        gr.Examples(examples=examples, inputs=[prompt])
-    gr.on(
-        triggers=[run_button.click, prompt.submit],
-        fn=infer,
-        inputs=[
-            prompt,
-            negative_prompt,
-            seed,
-            randomize_seed,
-            width,
-            height,
-            guidance_scale,
-            num_inference_steps,
-        ],
-        outputs=[result, seed],
-    )
+                with gr.Column():
+                    image_model = gr.Dropdown(
+                        choices=list(MODELS["image"].keys()),
+                        value="runwayml/stable-diffusion-v1-5",
+                        label="Modelo de Imagen"
+                    )
+                    image_prompt = gr.Textbox(
+                        label="Prompt de Imagen",
+                        placeholder="Describe la imagen que quieres generar...",
+                        lines=3
+                    )
+                    steps = gr.Slider(
+                        minimum=10,
+                        maximum=50,
+                        value=20,
+                        step=5,
+                        label="Pasos de inferencia"
+                    )
+                    image_btn = gr.Button("Generar Imagen", variant="primary")
+                
+                with gr.Column():
+                    image_output = gr.Image(
+                        label="Imagen Generada",
+                        type="pil"
+                    )
+            
+            image_btn.click(
+                generate_image,
+                inputs=[image_prompt, image_model, steps],
+                outputs=image_output
+            )
 
+# Configuración para Hugging Face Spaces
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    ) 

requirements.txt

@@ -1,6 +1,8 @@
-accelerate
-diffusers
-invisible_watermark
-torch
-transformers
-xformers
+gradio>=4.0.0
+torch>=2.0.0
+transformers>=4.30.0
+diffusers>=0.20.0
+accelerate>=0.20.0
+Pillow>=9.0.0
+numpy>=1.21.0
+requests>=2.28.0