import logging import gradio as gr from ctransformers import AutoModelForCausalLM import threading from langdetect import detect, DetectorFactory from langid import classify import spacy import os import psutil import time # Obtener el proceso actual process = psutil.Process(os.getpid()) # Función para imprimir el uso de CPU y RAM def print_resource_usage(): while True: # Crear un bucle infinito para que se ejecute continuamente cpu_usage = process.cpu_percent(interval=1) ram_usage = process.memory_info().rss / (1024 * 1024) # Convertir bytes a MB pid = str(process.pid) print(f"Uso de CPU: {cpu_usage}%") print(f"Uso de RAM: {ram_usage} MB") print(f"PID: {pid}") time.sleep(10) # Esperar 2 segundos antes de la próxima impresión # Crear y empezar un hilo para el monitoreo de recursos monitoring_thread = threading.Thread(target=print_resource_usage) monitoring_thread.daemon = True # Establecer como un daemon para que no bloquee el programa de terminar monitoring_thread.start() # Configuración del logger logging.basicConfig(filename='chatterIA_logs.txt', level=logging.INFO, format='%(asctime)s %(levelname)s:%(message)s') DetectorFactory.seed = 0 # Para obtener resultados consistentes en la detección del idioma (outputs) # Introducimos un mensaje para el modelo para que hable solo en español y con respeto system_message ="Eres un asistente que siempre responde en español. A cualquiera de sus peticiones y nunca hablas en ningún otro idioma" # Cargar el modelo una sola vez model_instance = None # Cargar el modelo que detecta el idioma de los mensajes solo 1 vez. (inputs) nlp_sm = spacy.load("es_core_news_sm") def load_llm(): global model_instance if model_instance is None: print("Cargando el modelo...") model_instance = AutoModelForCausalLM.from_pretrained( #"TheBloke/Llama-2-7B-Chat-GGUF", "TheBloke/Llama-2-7B-Chat-GGUF", #model_file='llama-2-7b-chat.Q5_K_M.gguf', model_file='llama-2-7b-chat.Q3_K_M.gguf', model_type='llama', max_new_tokens=2048, context_length = 4096, repetition_penalty=1.13, temperature=0.1 ) print("Modelo cargado éxitosamente") else: print("Ya se ha cargado el modelo anteriormente") return model_instance def truncate_history(history, max_tokens=2048): truncated_history = [] total_tokens = 0 for user_msg, bot_msg in reversed(history): # Asegurarse de que ni user_msg ni bot_msg sean None user_msg = user_msg if user_msg is not None else "" bot_msg = bot_msg if bot_msg is not None else "" msg_tokens = len(user_msg.split()) + len(bot_msg.split()) if total_tokens + msg_tokens > max_tokens: break truncated_history.insert(0, (user_msg, bot_msg)) total_tokens += msg_tokens return truncated_history def clean_response(response): code_block_count = response.count("```") if code_block_count % 2 != 0: last_occurrence_index = response.rfind("```") response = response[:last_occurrence_index] + response[last_occurrence_index+3:] return response def format_history_for_model(history): new_history = "\n".join(f"{user_msg}\n{bot_msg}".strip() for user_msg, bot_msg in history) new_history += "\nRespuesta:" return new_history def detectar_idioma_con_spacy(texto): doc = nlp_sm(texto, disable=["parser","ner"]) return True def prepare_message(message): # Primero, intenta detectar el idioma con langid lang, confidence = classify(message) if lang == 'es': return str(message) # Si langid está seguro de que es español, retorna el mensaje # Si el mensaje es muy corto y langid no lo clasifica definitivamente como español, # utiliza SpaCy como una verificación adicional. if len(message.split()) <= 3: # Considera ajustar este umbral según tus necesidades es_espanol_spacy = detectar_idioma_con_spacy(message) if es_espanol_spacy: return str(message) # Si SpaCy procesa el texto sin problemas, asume que es español # Si ninguna de las verificaciones anteriores concluye que el mensaje es en español, retorna None return None def llm_function(message, chat_history ): try: print(f"Mensaje principal:{message}") logging.info(f"Tipo de Message: {type(message)}, Message: {message}") message = str(message) message_str = str(message) # Aquí puedes añadir cualquier validación adicional del mensaje if not message_str.strip(): logging.info("El mensaje está vacío o solo contiene espacios.") return "Por favor, envía un mensaje no vacío.", chat_history # Continuar con el procesamiento... logging.info(f"Message: {message_str}") print(f"Historial del Chat (segun el chatbot)") for i in chat_history: print (i) print("Fin de variables desde el chat") llm = load_llm() message = prepare_message(message) if message is None: return f"Por favor, envía tu mensaje en español. Actualmente idioma es: {detect(message)}" chat_history = truncate_history(chat_history + [(message, "")]) # Añadir el mensaje actual al historial print("Historial del chat antes de formateo") for i in chat_history: print (i) print("Fin de historial previo a formateo") formatted_history = format_history_for_model(chat_history) # Formatear el historial para el modelo full_message = f"{system_message}\n{formatted_history}" print (f"Mensaje completo: {full_message}") response = llm(full_message) # Generar respuesta cleaned_response = clean_response(response) logging.info(f"Message: {message}") logging.info(f"Response: {response}") try: response_language = detect(response) print(f"Idioma en response_language: {response_language}") print(f"Response:{response}") if response_language != 'es': return "Lo siento, pero no puedo responder correctamente en español a esa pregunta." else: cleaned_response = clean_response(response) return cleaned_response except Exception as e: logging.error(f"Error al detectar el idioma: {e}") return "Hubo un error al procesar tu mensaje." except Exception as e: logging.error(f"Error al procesar el mensaje: {e}") return f"Hubo un error al procesar tu mensaje, revisa que sea un mensaje completo. {e}" def llm_function_with_timeout(message, chat_history, timeout=180): result = [None] # Lista para almacenar el resultado def target(): # Intentar adquirir el semáforo antes de ejecutar la función result[0] = llm_function(message, chat_history) thread = threading.Thread(target=target) thread.start() thread.join(timeout) if thread.is_alive(): # Si el thread todavía está vivo después del timeout, se asume que está bloqueado y se debe manejar thread.join() return "Tu pregunta no ha podido ser respondida en el tiempo estimado. Por favor, intenta de nuevo o reformula tu pregunta." return result[0] title = "ChatterIA" description = """ ChatterIA es un modelo de lenguaje que funciona como un asistente con infinidad de conocimientos, pero no infalible. Si desconoces el uso de este modelo, aquí tienes unas instrucciones para optimizar su uso: """ theme = 'Taithrah/Minimal' examples = [ 'Escribe un código de python para conectarte con una base de datos en MySQL y liste todas las tablas.', 'Escribe un poema sobre el otoño con rima consonante y en forma de soneto.', 'Resume el argumento de "El Quijote", y explícaselo a un niño de 5 años para que le interese.', 'Dime como fusionar dos diccionarios en Python y diferentes usos que puede tener esto.', 'Dime que debo considerar al comprar un coche usado y que me recomiendas saber al respecto.', 'Explica la teoría de la relatividad de Einstein para estudiantes de primaria.', 'Dime cuáles podrían ser las implicaciones de la inteligencia artificial en el empleo.', 'Redacta un correo para mi jefe en el cual, quiero pedirle un aumento de salario.', 'Escribe una cancion que dure aproximadamente 2 minutos y que trate sobre la desigualdad en España.' ] css = """ #component-0 { height:auto !important; min-height:400px !important; overflow:auto !important; } #component-0 .chatbot{ text-align:justify !important; padding: 5px 20px !important; } #component-3 div{ display:flex; justify-content:center; } #component-3 h1{ font-size:2rem; text-align:center !important; } #component-4 p{ font-size:18px; margin-bottom:25px; } #component-4 ul{ padding-left:5%; } #component-4 li{ font-size:16px; } #component-4 li::first-letter{ margin-left:-10px; } .gallery-item{ flex:1 0 33%; align-self:center; height:75px; } .gallery-item div, .svelte-1viwdyg, .gallery .gallery-item .gallery{ white-space: unset; } footer{ display:none !important; } @media only screen and (max-width:600px){ #component-0 .chatbot{ text-align:justify !important; padding: 5px 20px !important; } #component-3 h1{ font-size:1.5rem; text-align:center !important; } #component-4 p{ font-size:14px; text-align:justify; } #component-4 li{ font-size:12px; paddding:20px; } #component-4 li::first-letter{ margin-left:-10px; } #component-5{ display:flex; flex-direction:row; } #component-5 button{ flex: 1 1 30%; } .gallery-item{ flex:1 0 100%; height:100px; } .gallery-item div, .svelte-1viwdyg, .gallery .gallery-item .gallery{ white-space: unset; } /* Este último es para que el texto de los ejemplos no se salga del contenedor y se quede correcto cuando lo importas como iframe, ya que son estilos que aplica huggingface localmente pero no lo hace cuando lo importas en un iframe*/ #component-0 pre, #component-0 code{ max-width: 100%; /* Asegura que el bloque de código no sea más ancho que su contenedor */ box-sizing: border-box; /* Incluye padding y border dentro del ancho y alto del elemento */ white-space: pre-wrap; /* Mantiene el formato pero permite el ajuste de palabras */ word-break: break-all; /* Permite que las palabras se rompan para evitar desbordamiento */ overflow-x: auto; /* Permite desplazamiento horizontal dentro del bloque de código si es necesario */ overflow-y: hidden; /* Oculta el desbordamiento vertical, no debería ser necesario con pre-wrap */ } } """ demo= gr.ChatInterface( fn = llm_function_with_timeout, chatbot=gr.Chatbot(label="ChatterIA"), textbox= gr.Textbox(placeholder="Envía tu mensaje...", lines=3, max_lines=10), title=title, description = description, theme = theme, examples = examples, css = css, cache_examples=False, submit_btn = "📤 Enviar", retry_btn = "🔁 Reenviar", undo_btn = "🔙 Deshacer", clear_btn= "🗑 Limpiar", ).launch()