simple modelo

app.py

@@ -1,136 +1,23 @@
-import warnings
-warnings.filterwarnings("ignore", message="Can't initialize NVML")
-
-import datetime
-import requests
+from transformers import pipeline
 import gradio as gr
-import torch
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-
-# Detectar si hay GPU disponible, de lo contrario usar CPU (-1)
-device = 0 if torch.cuda.is_available() else -1
-
-# Cargar el modelo y el tokenizador (se usará CPU si no hay GPU)
-model_name = "microsoft/Phi-4-mini-instruct"
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForCausalLM.from_pretrained(model_name)
-if device == 0:
-    model.to("cuda")
-
-# Crear un pipeline de generación de texto utilizando el dispositivo adecuado
-generator = pipeline("text-generation", model=model, tokenizer=tokenizer, device=device)
-
-# Función para obtener las reservaciones de hotel filtradas por título
-def get_hotel_reservations(title_filter):
-    url = "http://127.0.0.1:4000/api/accommodations"
-    try:
-        response = requests.get(url)
-        if response.status_code == 200:
-            data = response.json()  # Se espera que 'data' sea una lista de reservaciones
-            summary = "Reservaciones de Hotel:\n\n"
-            found = False
-            for reservation in data:
-                hotel_title = reservation.get("title", "N/A")
-                # Filtrar solo las reservaciones que contengan el filtro en el título
-                if title_filter.lower() not in hotel_title.lower():
-                    continue
-
-                found = True
-                hotel_id = reservation.get("id", "N/A")
-
-                address = reservation.get("address", {})
-                street = address.get("street", "N/A")
-                zip_code = address.get("zip_code", "N/A")
-                latitude = address.get("latitude", "N/A")
-                longitude = address.get("longitude", "N/A")
-
-                guests = reservation.get("guests", {})
-                adult = guests.get("adult", "N/A")
-                child = guests.get("child", "N/A")
-
-                price = reservation.get("price", "N/A")
-
-                summary += (
-                    f"Reservación {hotel_id}:\n"
-                    f"  - Hotel: {hotel_title}\n"
-                    f"  - Dirección: {street}, Código Postal: {zip_code}\n"
-                    f"    (Latitud: {latitude}, Longitud: {longitude})\n"
-                    f"  - Huéspedes: {adult} adultos, {child} niños\n"
-                    f"  - Precio: {price}\n\n"
-                )
-            if not found:
-                summary += f"No se encontraron reservaciones que coincidan con el filtro '{title_filter}'.\n"
-            return summary
-        else:
-            return "Lo sentimos, no se pudieron obtener las reservaciones de hotel."
-    except Exception as e:
-        return f"Error al conectar con la API: {e}"
-
-# Diccionario que asocia nombres de funciones a sus implementaciones
-function_map = {
-    "get_hotel_reservations": get_hotel_reservations,
-}
-
-# Definir la herramienta para function calling (útil para documentar la función)
-tools = [
-    {
-        "type": "function",
-        "function": {
-            "name": "get_hotel_reservations",
-            "description": "Obtiene una lista de reservaciones de hotel filtradas por un título. El parámetro 'title' permite especificar parte del nombre del hotel o región.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "title": {
-                        "type": "string",
-                        "description": "Parte del nombre del hotel o región, e.g., Medellín, Bogotá, Cartagena"
-                    }
-                },
-                "required": ["title"]
-            }
-        }
-    }
-]
-
-def process_instruction(instruction: str):
-    """
-    Envía la instrucción al modelo y verifica si se debe llamar a una función.
-    Se espera que el modelo devuelva una cadena que contenga un llamado a función en el siguiente formato:
-    "Llamada a función: get_hotel_reservations(Bogotá)"
-    """
-    output = ""
-    result = generator(instruction, max_length=150)[0]['generated_text']
-    output += "Respuesta generada:\n" + result + "\n\n"
-    
-    if "Llamada a función:" in result:
-        try:
-            # Extraer la parte de la cadena que contiene el llamado a función
-            start_index = result.find("Llamada a función:") + len("Llamada a función:")
-            # Se asume que el llamado está en una única línea, por ejemplo: get_hotel_reservations(Bogotá)
-            call_str = result[start_index:].strip().split()[0]
-            func_name, params = call_str.split("(", 1)
-            params = params.rstrip(")")
-            func_name = func_name.strip()
-            params = params.strip()
-            
-            if func_name in function_map:
-                function_result = function_map[func_name](params)
-                output += "Resultado de la función:\n" + str(function_result)
-            else:
-                output += "Función no encontrada: " + func_name
-        except Exception as e:
-            output += "Error al procesar la llamada a función: " + str(e)
-    else:
-        output += "No se encontró ninguna llamada a función en la respuesta."
-    return output
 
-# Crear una interfaz Gradio para interactuar con el sistema
-iface = gr.Interface(
-    fn=process_instruction,
-    inputs=gr.Textbox(lines=5, placeholder="Escribe tu instrucción aquí...", label="Instrucción"),
-    outputs="text",
-    title="Demo de Function Calling con Phi-4-mini-instruct (CPU)"
+# Cargar un modelo de texto de Hugging Face (puede ser de completado, traducción, etc.)
+modelo = pipeline("text-generation", model="microsoft/Phi-4-multimodal-instruct")  # Cambia el modelo si lo deseas
+
+# Función para generar texto
+def generar_texto(prompt):
+    resultado = modelo(prompt, max_length=100, do_sample=True)
+    return resultado[0]["generated_text"]
+
+# Interfaz con Gradio
+interfaz = gr.Interface(
+    fn=generar_texto,
+    inputs=gr.Textbox(label="Introduce tu texto"),
+    outputs=gr.Textbox(label="Texto generado"),
+    title="Generador de Texto con Hugging Face",
+    description="Escribe un prompt y el modelo generará un texto basado en él."
 )
 
+# Ejecutar la app
 if __name__ == "__main__":
-    iface.launch(share=True)
+    interfaz.launch()