Update app.py

app.py

@@ -1,64 +1,144 @@
 import gradio as gr
-from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForCausalLM
-from transformers import T5Tokenizer # Import T5Tokenizer directly
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
 import torch
 
-# ---------- MODELO DE SIMPLIFICACIÓN ----------
-simplifier_model_name = "mrm8488/t5-base-finetuned-summarize-news"
-# Use T5Tokenizer directly instead of AutoTokenizer
-simplifier_tokenizer = T5Tokenizer.from_pretrained(simplifier_model_name)
-simplifier_model = AutoModelForSeq2SeqLM.from_pretrained(simplifier_model_name)
+# Configurar el dispositivo (CPU)
+device = torch.device("cpu")
 
-def simplificar_texto(texto, nivel):
-    niveles = {
-        "Bajo": "Rephrase this text with slightly simpler words:",
-        "Medio": "Rephrase this text in a simple and clear way:",
-        "Alto": "Rephrase this text in very simple and easy-to-understand words for a person with cognitive difficulties:"
-    }
-    prompt = f"{niveles[nivel]}\n\n{texto}"
-    inputs = simplifier_tokenizer(prompt, return_tensors="pt", truncation=True)
-    outputs = simplifier_model.generate(
-        **inputs,
-        max_new_tokens=120,
-        num_beams=4,
-        temperature=0.7,
-        repetition_penalty=1.2,
-        early_stopping=True
-    )
-    resultado = simplifier_tokenizer.decode(outputs[0], skip_special_tokens=True)
-    return resultado
+# Cargar el modelo y tokenizer
+print("Cargando modelo DistilGPT-2...")
+model_name = "distilgpt2"
+tokenizer = GPT2Tokenizer.from_pretrained(model_name)
+model = GPT2LMHeadModel.from_pretrained(model_name)
 
-# ---------- MODELO DE PREDICCIÓN DE TEXTO ----------
-predictor_model_name = "distilgpt2"
-predictor_tokenizer = AutoTokenizer.from_pretrained(predictor_model_name)
-predictor_model = AutoModelForCausalLM.from_pretrained(predictor_model_name)
+# Mover modelo a CPU y ponerlo en modo evaluación
+model.to(device)
+model.eval()
 
-def predecir_texto(texto_inicial):
-    inputs = predictor_tokenizer.encode(texto_inicial, return_tensors="pt")
-    outputs = predictor_model.generate(inputs, max_new_tokens=20, do_sample=True, top_k=50)
-    texto_generado = predictor_tokenizer.decode(outputs[0], skip_special_tokens=True)
-    return texto_generado[len(texto_inicial):]  # Solo mostrar lo nuevo
+# Configurar pad_token si no existe
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
 
-# ---------- INTERFAZ GRADIO ----------
-with gr.Blocks() as demo:
-    gr.Markdown("## 🧠 Chatbot Simplificador y Teclado Predictivo")
-    with gr.Tab("Simplificación de texto"):
-        gr.Markdown("Introduce un texto complejo y obtén una versión más sencilla.")
-        entrada_simplificar = gr.Textbox(label="Texto original", lines=4, placeholder="Ej. Un párrafo de un documento legal...")
-        nivel_dropdown = gr.Dropdown(choices=["Bajo", "Medio", "Alto"], label="Nivel de simplicidad", value="Medio")
-        boton_simplificar = gr.Button("Simplificar")
-        salida_simplificar = gr.Textbox(label="Texto simplificado")
+def autocomplete_text(input_text, max_tokens=20):
+    """
+    Autocompleta el texto de entrada usando DistilGPT-2
+    
+    Args:
+        input_text (str): Texto inicial a completar
+        max_tokens (int): Número máximo de tokens a generar
+    
+    Returns:
+        str: Solo la parte nueva generada (sin el input original)
+    """
+    if not input_text.strip():
+        return "Por favor, ingresa algún texto para completar."
+    
+    try:
+        # Tokenizar el texto de entrada
+        inputs = tokenizer.encode(input_text, return_tensors="pt", padding=True)
+        inputs = inputs.to(device)
+        
+        # Generar texto
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs,
+                max_new_tokens=max_tokens,
+                num_return_sequences=1,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                attention_mask=torch.ones_like(inputs)
+            )
+        
+        # Decodificar el resultado completo
+        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Extraer solo la parte nueva (sin el input original)
+        new_text = generated_text[len(input_text):].strip()
+        
+        if not new_text:
+            return "No se pudo generar texto adicional."
+        
+        return new_text
+        
+    except Exception as e:
+        return f"Error al generar texto: {str(e)}"
 
-        boton_simplificar.click(
-            fn=simplificar_texto,
-            inputs=[entrada_simplificar, nivel_dropdown],
-            outputs=salida_simplificar
-        )
-    with gr.Tab("Texto Predictivo"):
-        gr.Markdown("Escribe el inicio de una frase y recibe sugerencias.")
-        entrada_predecir = gr.Textbox(label="Frase incompleta", placeholder="Ej. Me gustaría ir a la...")
-        salida_predecir = gr.Textbox(label="Sugerencia")
-        boton_predecir = gr.Button("Predecir")
-        boton_predecir.click(fn=predecir_texto, inputs=entrada_predecir, outputs=salida_predecir)
+def create_autocomplete_interface():
+    """
+    Crea la interfaz de autocompletar dentro de gr.Blocks()
+    """
+    
+    with gr.Blocks(title="Autocompletar Texto") as demo:
+        
+        gr.Markdown("# 🤖 Autocompletar Texto")
+        gr.Markdown("Escribe el inicio de una frase y la IA la completará por ti.")
+        
+        with gr.Tab("Autocompletar"):
+            with gr.Row():
+                with gr.Column():
+                    input_textbox = gr.Textbox(
+                        label="Texto a completar",
+                        placeholder="Escribe el inicio de tu frase aquí...",
+                        lines=3,
+                        max_lines=5
+                    )
+                    
+                    generate_btn = gr.Button("Completar Texto", variant="primary")
+                    
+                with gr.Column():
+                    output_textbox = gr.Textbox(
+                        label="Texto generado",
+                        placeholder="Aquí aparecerá la continuación...",
+                        lines=3,
+                        max_lines=5,
+                        interactive=False
+                    )
+            
+            # Conectar el botón con la función
+            generate_btn.click(
+                fn=autocomplete_text,
+                inputs=[input_textbox],
+                outputs=[output_textbox]
+            )
+            
+            # También permitir Enter para generar
+            input_textbox.submit(
+                fn=autocomplete_text,
+                inputs=[input_textbox],
+                outputs=[output_textbox]
+            )
+            
+        # Pestaña adicional con ejemplos
+        with gr.Tab("Ejemplos"):
+            gr.Markdown("""
+            ### Ejemplos de uso:
+            
+            **Entrada:** "El clima de hoy está"
+            **Salida:** "muy agradable y soleado"
+            
+            **Entrada:** "Me gusta mucho"
+            **Salida:** "pasar tiempo con mi familia"
+            
+            **Entrada:** "Para hacer una buena comida necesitas"
+            **Salida:** "ingredientes frescos y mucha paciencia"
+            """)
+    
+    return demo
 
-demo.launch()
+# Crear y lanzar la aplicación
+if __name__ == "__main__":
+    print("Iniciando aplicación de autocompletar...")
+    
+    # Crear la interfaz
+    app = create_autocomplete_interface()
+    
+    # Lanzar la aplicación
+    app.launch(
+        share=False,  # Cambiar a True si quieres compartir públicamente
+        server_name="0.0.0.0",  # Permite acceso desde otras máquinas en la red local
+        server_port=7860,  # Puerto por defecto de Gradio
+        show_error=True,
+        debug=False
+    )