Update app.py

app.py

@@ -1,133 +1,95 @@
 import gradio as gr
 import joblib
 import numpy as np
-import os
 import requests
-import time
-import threading
-from datetime import datetime
-from sklearn.ensemble import RandomForestClassifier
+import torch
+import os
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from langchain.memory import ConversationBufferMemory
 
-# Configuración de la API de Node-RED
-NODE_RED_URL = "https://appairedecolmena.es/colmena1/datos"
-USERNAME = "user"
-PASSWORD = "velutina"
+# Configuración del modelo de lenguaje
+MODEL_NAME = "mistralai/Mistral-7B-Instruct"  # Puedes cambiar a LLaMA 2
+device = "cuda" if torch.cuda.is_available() else "cpu"
 
-# Ruta del modelo
-modelo_path = "modelo_colmena.pkl"
+print("🔄 Cargando modelo de lenguaje...")
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+model = AutoModelForCausalLM.from_pretrained(MODEL_NAME).to(device)
 
-# Cargar el modelo si existe, si no, crearlo vacío
+# Configuración de memoria conversacional con límite de contexto
+memory = ConversationBufferMemory(max_human_messages=10, max_ai_messages=10)
+
+# Cargar modelo de la colmena
+modelo_path = "modelo_colmena.pkl"
 if os.path.exists(modelo_path):
-    modelo = joblib.load(modelo_path)
+    modelo_colmena = joblib.load(modelo_path)
 else:
-    modelo = RandomForestClassifier(n_estimators=100)
+    modelo_colmena = None
 
-# Variable para rastrear el último timestamp y datos recientes
-datos_recientes = None
-ultimo_timestamp = None
+# API de Node-RED
+NODE_RED_URL = "https://appairedecolmena.es/colmena1/datos"
+USERNAME = "user"
+PASSWORD = "velutina"
 
 def obtener_datos_colmena():
-    """Obtiene los datos de Node-RED con autenticación."""
+    """Obtiene los datos más recientes de Node-RED con autenticación."""
     try:
         respuesta = requests.get(NODE_RED_URL, auth=(USERNAME, PASSWORD), timeout=5)
         if respuesta.status_code == 200:
-            return respuesta.json()
+            datos = respuesta.json()
+            if "data" in datos and isinstance(datos["data"], list) and datos["data"]:
+                return datos["data"][-1]  # Devuelve solo el último registro
+            return {"error": "No hay datos recientes en Node-RED."}
         else:
-            print(f"⚠️ Error en la API de Node-RED: {respuesta.status_code}")
-            return None
+            return {"error": f"Error en la API: {respuesta.status_code}"}
     except Exception as e:
-        print("❌ No se pudo conectar a Node-RED:", e)
-        return None
-
-def entrenar_nuevo_modelo(datos):
-    """Entrena un nuevo modelo con los datos recibidos."""
-    global modelo
+        return {"error": str(e)}
 
-    entrada = np.array([[float(datos["temperaturaInterior"]), float(datos["humedadInterior"]), float(datos["peso"]),
-                         float(datos["co2"]), float(datos["vco"]), float(datos["frecuencia"]),
-                         float(datos["voltaje"]), float(datos["temperatura_exterior"]),
-                         float(datos["humedad_exterior"]), float(datos["ver_tempSelect"])]])
-    
-    salida = np.array([[int(datos["ver_ultrasonido"]), int(datos["ver_calefactor"]), int(datos["ver_ventilador"])]])  
-    modelo.fit(entrada, salida)
-    joblib.dump(modelo, modelo_path)
-    print("✅ Modelo actualizado con nuevos datos.")
-
-def verificar_nuevos_datos():
-    """Consulta Node-RED cada hora y aprende si hay datos nuevos."""
-    global ultimo_timestamp, datos_recientes
-
-    while True:
-        datos = obtener_datos_colmena()
-        if datos and "data" in datos and isinstance(datos["data"], list) and len(datos["data"]) > 0:
-            ultimo_registro = datos["data"][-1]
-            if "timestamp" in ultimo_registro:
-                timestamp_actual = ultimo_registro["timestamp"]
-                if timestamp_actual != ultimo_timestamp:
-                    print(f"📌 Nuevos datos detectados: {timestamp_actual}")
-                    entrenar_nuevo_modelo(ultimo_registro)
-                    datos_recientes = ultimo_registro
-                    ultimo_timestamp = timestamp_actual
-                else:
-                    print("⏳ No hay datos nuevos, esperando la próxima consulta...")
-            else:
-                print(f"❌ No se encontró 'timestamp' en el último registro: {ultimo_registro}")
-        else:
-            print("❌ No hay datos válidos en la API de Node-RED.")
-        time.sleep(3600)
-
-def predecir(temp, humedad, peso, co2, vco, frecuencia, voltaje, temp_ext, humedad_ext, ver_tempSelect):
-    valores = [temp, humedad, peso, co2, vco, frecuencia, voltaje, temp_ext, humedad_ext, ver_tempSelect]
-    valores_limpios = [0 if v is None or np.isnan(v) else v for v in valores]
-    entrada = np.array([valores_limpios])
-    prediccion = modelo.predict(entrada)[0]
-    mensaje = f"🔹 Ultrasonido: {'ENCENDER' if prediccion[0] == 1 else 'APAGAR'}\n"
-    mensaje += f"🔹 Calefactor: {'ENCENDER' if prediccion[1] == 1 else 'APAGAR'}\n"
-    mensaje += f"🔹 Ventilador: {'ENCENDER' if prediccion[2] == 1 else 'APAGAR'}"
-    return mensaje
-
-def chat_ia(mensaje_usuario):
-    """Responde preguntas sobre la colmena basándose en los últimos datos disponibles."""
-    global datos_recientes
-    if datos_recientes is None:
-        return "No hay datos recientes disponibles. Esperando actualización de Node-RED."
-    
-    mensaje_usuario = mensaje_usuario.lower()
-    if "temperatura" in mensaje_usuario:
-        return f"🌡 La temperatura interior es {datos_recientes['temperaturaInterior']}°C y la exterior {datos_recientes['temperatura_exterior']}°C."
-    elif "humedad" in mensaje_usuario:
-        return f"💧 La humedad interior es {datos_recientes['humedadInterior']}% y la exterior {datos_recientes['humedad_exterior']}%."
-    elif "co2" in mensaje_usuario:
-        return f"🌿 El nivel de CO2 es {datos_recientes['co2']} ppm."
-    elif "ventilador" in mensaje_usuario:
-        estado = "ENCENDIDO" if int(datos_recientes['ver_ventilador']) == 1 else "APAGADO"
-        return f"🔄 El ventilador está {estado}."
-    elif "calefactor" in mensaje_usuario:
-        estado = "ENCENDIDO" if int(datos_recientes['ver_calefactor']) == 1 else "APAGADO"
-        return f"🔥 El calefactor está {estado}."
-    elif "ultrasonido" in mensaje_usuario:
-        estado = "ENCENDIDO" if int(datos_recientes['ver_ultrasonido']) == 1 else "APAGADO"
-        return f"🔊 El ultrasonido está {estado}."
+def filtrar_datos_por_pregunta(mensaje, datos):
+    """Filtra los datos de la colmena según la pregunta del usuario."""
+    if "temperatura" in mensaje:
+        return f"🌡 Temperatura interior: {datos['temperaturaInterior']}°C, exterior: {datos['temperatura_exterior']}°C."
+    elif "humedad" in mensaje:
+        return f"💧 Humedad interior: {datos['humedadInterior']}%, exterior: {datos['humedad_exterior']}%."
+    elif "co2" in mensaje:
+        return f"🌿 CO2: {datos['co2']} ppm."
+    elif "ventilador" in mensaje:
+        estado = "ENCENDIDO" if int(datos['ver_ventilador']) == 1 else "APAGADO"
+        return f"🔄 Ventilador: {estado}."
+    elif "calefactor" in mensaje:
+        estado = "ENCENDIDO" if int(datos['ver_calefactor']) == 1 else "APAGADO"
+        return f"🔥 Calefactor: {estado}."
+    elif "ultrasonido" in mensaje:
+        estado = "ENCENDIDO" if int(datos['ver_ultrasonido']) == 1 else "APAGADO"
+        return f"🔊 Ultrasonido: {estado}."
     else:
         return "🤖 No entiendo la pregunta. Puedes preguntar sobre temperatura, humedad, CO2, ventilador, calefactor o ultrasonido."
 
-# Iniciar proceso de actualización de datos
-thread = threading.Thread(target=verificar_nuevos_datos, daemon=True)
-thread.start()
+def conversar_con_colmena(mensaje):
+    """Genera una respuesta combinando el modelo de lenguaje con los datos de la colmena."""
+    datos = obtener_datos_colmena()
+    if "error" in datos:
+        return datos["error"]
+    
+    datos_relevantes = filtrar_datos_por_pregunta(mensaje.lower(), datos)
+    
+    contexto = f"Datos actuales de la colmena: {datos_relevantes}\nUsuario: {mensaje}\nColmena:"  
+    inputs = tokenizer(contexto, return_tensors="pt").to(device)
+    
+    with torch.no_grad():
+        output = model.generate(**inputs, max_length=150)  # Limitar longitud
+    
+    respuesta = tokenizer.decode(output[0], skip_special_tokens=True)
+    memory.save_context({"input": mensaje}, {"output": respuesta})
+    
+    return respuesta
 
-# Interfaz de Gradio con dos funciones: predicción y chat
-iface = gr.TabbedInterface([
-    gr.Interface(fn=predecir,
-                 inputs=["number", "number", "number", "number", "number", "number", "number", "number", "number", "number"],
-                 outputs="text",
-                 title="🐝 IA Inteligente para Colmenas",
-                 description="Introduce los datos de la colmena y la IA predecirá si es necesario activar ventilador, calefactor y ultrasonidos."),
-    gr.Interface(fn=chat_ia,
-                 inputs="text",
-                 outputs="text",
-                 title="💬 Chat con la IA de la Colmena",
-                 description="Haz preguntas sobre el estado de la colmena y la IA responderá basándose en los datos más recientes.")
-], title="🐝 Colmena Inteligente")
+iface = gr.Interface(
+    fn=conversar_con_colmena,
+    inputs="text",
+    outputs="text",
+    title="🐝 Chat con la Colmena",
+    description="Habla con la colmena en tiempo real sobre su estado."
+)
 
 iface.launch()