Delete copia_de_modelo_chatbot_final_3_con_gradio.py

copia_de_modelo_chatbot_final_3_con_gradio.py

@@ -1,578 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Copia de Modelo_Chatbot_Final_3_con_Gradio.ipynb
-
-Automatically generated by Colab.
-
-Original file is located at
-    https://colab.research.google.com/drive/1sFAltehLtdNpHoQVsiDeikgSJkIDTWrD
-"""
-
-!pip install language-tool-python
-
-!pip install transformers==4.17
-
-import warnings
-warnings.filterwarnings('ignore')
-
-import json
-import numpy as np
-import pandas as pd
-import random
-from matplotlib import pyplot as plt
-import seaborn as sns
-from wordcloud import WordCloud,STOPWORDS
-import missingno as msno
-
-from sklearn.feature_extraction.text import CountVectorizer
-from sklearn.model_selection import train_test_split
-from sklearn.metrics import accuracy_score, precision_recall_fscore_support
-
-#from keras.preprocessing import text
-import keras
-from keras.models import Sequential
-from keras.layers import Dense,Embedding,LSTM,Dropout
-from keras.callbacks import ReduceLROnPlateau
-
-from tensorflow.keras.preprocessing.sequence import pad_sequences
-import nltk
-from nltk import word_tokenize
-from nltk.stem import PorterStemmer
-
-import torch
-from torch.utils.data import Dataset
-
-from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
-from transformers import pipeline
-from transformers import DistilBertTokenizerFast
-from transformers import BertForSequenceClassification, BertTokenizerFast
-from transformers import TFDistilBertForSequenceClassification, Trainer, TFTrainingArguments
-from transformers import BertTokenizer, TFBertForSequenceClassification, BertConfig
-from transformers import TrainingArguments, Trainer, EarlyStoppingCallback
-
-import re
-
-import language_tool_python
-import logging
-import spacy
-
-def load_json_file(filename):
-    with open(filename) as f:
-        file = json.load(f)
-    return file
-
-filename = '/content/intents_aumentado.json'
-
-intents = load_json_file(filename)
-
-def create_df():
-    df = pd.DataFrame({
-        'Pattern' : [],
-        'Tag' : []
-    })
-
-    return df
-
-df = create_df()
-df
-
-def extract_json_info(json_file, df):
-
-    for intent in json_file['intents']:
-
-        for pattern in intent['patterns']:
-
-            sentence_tag = [pattern, intent['tag']]
-            df.loc[len(df.index)] = sentence_tag
-
-    return df
-
-df = extract_json_info(intents, df)
-df.head()
-
-df2 = df.copy()
-df2.head()
-
-import nltk
-nltk.download('punkt_tab')
-
-stemmer = PorterStemmer()
-ignore_words=['?', '!', ',', '.']
-
-def preprocess_pattern(pattern):
-    words = word_tokenize(pattern.lower())
-    stemmed_words = [stemmer.stem(word) for word in words if word not in ignore_words]
-    return " ".join(stemmed_words)
-
-df['Pattern'] = df['Pattern'].apply(preprocess_pattern)
-
-df2.head()
-
-labels = df2['Tag'].unique().tolist()
-labels = [s.strip() for s in labels]
-labels
-
-num_labels = len(labels)
-id2label = {id:label for id, label in enumerate(labels)}
-label2id = {label:id for id, label in enumerate(labels)}
-
-id2label
-
-label2id
-
-df2['labels'] = df2['Tag'].map(lambda x: label2id[x.strip()])
-df2.head()
-
-X = list(df2['Pattern'])
-X[:5]
-
-y = list(df2['labels'])
-y[:5]
-
-X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 123)
-
-model_name = "dccuchile/bert-base-spanish-wwm-cased"
-max_len = 256
-
-tokenizer = BertTokenizer.from_pretrained(model_name,
-                                          max_length=max_len)
-
-model = BertForSequenceClassification.from_pretrained(model_name,
-                                                      num_labels=num_labels,
-                                                      id2label=id2label,
-                                                      label2id = label2id)
-
-train_encoding = tokenizer(X_train, truncation=True, padding=True)
-test_encoding = tokenizer(X_test, truncation=True, padding=True)
-
-full_data = tokenizer(X, truncation=True, padding=True)
-
-class DataLoader(Dataset):
-
-    def __init__(self, encodings, labels):
-
-        self.encodings = encodings
-        self.labels = labels
-
-    def __getitem__(self, idx):
-
-        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
-        item['labels'] = torch.tensor(self.labels[idx])
-        return item
-
-    def __len__(self):
-
-        return len(self.labels)
-
-train_dataloader = DataLoader(train_encoding, y_train)
-test_dataloader = DataLoader(test_encoding, y_test)
-
-fullDataLoader = DataLoader(full_data, y_test)
-
-def compute_metrics(pred):
-
-    labels = pred.label_ids
-    preds = pred.predictions.argmax(-1)
-    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='macro')
-    acc = accuracy_score(labels, preds)
-
-    return {
-        'accuracy': acc,
-        'f1': f1,
-        'precision': precision,
-        'recall': recall
-    }
-
-# Parametros finales del modelo
-training_args = TrainingArguments(
-    output_dir='./output',                         # Carpeta donde se guardarán los modelos entrenados y checkpoints
-    do_train=True,
-    do_eval=True,
-    num_train_epochs=30,                           # Número total de épocas (pasadas completas por el dataset de entrenamiento)
-    per_device_train_batch_size=8,                 # Tamaño del batch de entrenamiento por dispositivo (GPU o CPU)
-    per_device_eval_batch_size=32,                 # Tamaño del batch de evaluación por dispositivo (mayor para evaluar más rápido)
-    gradient_accumulation_steps=4,                 # Acumula gradientes por 4 pasos antes de hacer una actualización (simula batch más grande)
-    learning_rate=2e-5,                            # Tasa de aprendizaje inicial
-    warmup_ratio=0.1,                              # Porcentaje de pasos de calentamiento (warmup) sobre el total de pasos de entrenamiento
-    weight_decay=0.1,                              # Regularización para evitar overfitting penalizando grandes pesos
-    lr_scheduler_type="cosine",                    # Tipo de scheduler para modificar la tasa de aprendizaje (coseno en este caso)
-    fp16=True,                                     # Usa precisión mixta (float16) para acelerar entrenamiento si hay soporte (ej. en GPUs)
-    evaluation_strategy="steps",
-    eval_steps=50,                                 # Evalúa el modelo cada 50 pasos de entrenamiento
-    save_strategy="steps",
-    save_steps=50,                                 # Guarda el modelo cada 50 pasos
-    save_total_limit=3,                            # Mantiene solo los últimos 3 checkpoints, borra los anteriores
-    logging_strategy="steps",
-    logging_dir='./multi-class-logs',              # Carpeta donde se guardarán los logs de entrenamiento cada 50 pasos
-    logging_steps=50,                              #
-    load_best_model_at_end=True,                   # Carga automáticamente el mejor modelo evaluado al finalizar el entrenamiento
-    metric_for_best_model="f1",                    # Métrica que se usa para definir cuál fue el "mejor" modelo
-    greater_is_better=True
-)
-
-trainer = Trainer(
-    model=model,
-    args=training_args,
-    train_dataset=train_dataloader,
-    eval_dataset=test_dataloader,
-    compute_metrics=compute_metrics,
-    callbacks=[EarlyStoppingCallback(early_stopping_patience=3)] # Frena el entrenamiento si no mejora la métrica de evaluación después de 3 evaluaciones consecutiva
-)
-
-import os
-
-os.environ["WANDB_API_KEY"] = "4fb9dff0336a34ab812e86f91b6c3a877cb25b36"
-
-import wandb
-wandb.login()
-
-trainer.train()
-
-q=[trainer.evaluate(eval_dataset=df2) for df2 in [train_dataloader, test_dataloader]]
-
-pd.DataFrame(q, index=["train","test"]).iloc[:,:5]
-
-def predict(text):
-
-    inputs = tokenizer(text, padding=True, truncation=True, max_length=512, return_tensors="pt").to("cuda")
-    outputs = model(**inputs)
-
-    probs = outputs[0].softmax(1)
-    pred_label_idx = probs.argmax()
-    pred_label = model.config.id2label[pred_label_idx.item()]
-
-    return probs, pred_label_idx, pred_label
-
-text = "Hola"
-predict(text)
-
-model_path = "chatbot"
-trainer.save_model(model_path)
-tokenizer.save_pretrained(model_path)
-
-!kaggle kernels output eyadgk/build-a-chatbot-with-bert-eda-vis -p /path/to/dest
-
-model_path = "/content/chatbot"
-
-
-model = BertForSequenceClassification.from_pretrained(model_path)
-tokenizer= BertTokenizerFast.from_pretrained(model_path)
-chatbot= pipeline("text-classification", model=model, tokenizer=tokenizer)
-
-chatbot("Hola")
-
-negaciones = [
-    "no", "nunca", "nadie", "ningún", "ninguna", "nada",
-    "jamás", "jamas", "ni", "tampoco", "de ninguna manera",
-    "en absoluto", "en ningún caso", "no es cierto",
-    "no estoy de acuerdo", "no me parece", "no creo",
-    "no quiero", "no puedo", "no quiero hacerlo", "no acepto", "no gracias"
-]
-
-afirmaciones = [
-    "sí", "si", "claro", "por supuesto", "entendido", "estoy de acuerdo",
-    "acepto", "exacto", "correcto", "eso es", "está bien", "esta bien",
-    "claro que sí", "lo creo", "es cierto", "sin duda", "así es", "claro que si"
-    "perfecto", "me parece bien", "seguro", "definitivamente", "por supuesto"
-]
-
-# Asumiendo que intents ya está definido
-def obtener_respuesta_aleatoria(tag):
-    """Busca el intent correspondiente al tag y devuelve una respuesta aleatoria."""
-    for intent in intents['intents']:
-        if intent['tag'] == tag:
-            return random.choice(intent['responses'])
-    return "No tengo respuesta para eso."
-
-# Asumiendo que intents ya está definido
-def obtener_lista_de_respuesta(tag):
-    """Busca el intent correspondiente al tag y devuelve una respuesta aleatoria."""
-    for intent in intents['intents']:
-        if intent['tag'] == tag:
-            return intent['responses']
-    return "No tengo respuesta para eso."
-
-historial_respuestas = {}
-
-def obtener_respuesta_sin_repetir(label):
-    global historial_respuestas
-
-    # Si es la primera vez que se usa el label, inicializar historial
-    if label not in historial_respuestas:
-        historial_respuestas[label] = []
-
-    respuestas_posibles = obtener_lista_de_respuesta(label)  # Lista de respuestas disponibles para el tag
-
-    # Filtrar respuestas que aún no se usaron
-    respuestas_disponibles = [r for r in respuestas_posibles if r not in historial_respuestas[label]]
-
-    if not respuestas_disponibles:
-        historial_respuestas[label] = []  # Resetear historial cuando se agoten todas
-
-    # Elegir una nueva respuesta sin repetir
-    nueva_respuesta = random.choice([r for r in respuestas_posibles if r not in historial_respuestas[label]])
-
-    # Agregarla al historial
-    historial_respuestas[label].append(nueva_respuesta)
-
-    return nueva_respuesta
-
-def corregir_preguntas(texto, idioma='es'):
-    """
-    Corrige la ortografía y gramática del texto usando LanguageTool.
-    También ajusta signos de interrogación y acentos en palabras interrogativas.
-    Ignora correcciones sobre las palabras: 'unaj', 'arturo', 'jauretche'.
-    """
-    try:
-        # Agregar "?" si el texto tiene 3 o más palabras y no termina con "?"
-        if len(texto.split()) >= 3 and not texto.endswith("?"):
-            texto += "?"
-
-        # Palabras a ignorar (en minúsculas)
-        palabras_ignorar = ["unaj", "arturo", "jauretche", "profode"]
-        reemplazos = {}
-
-        # Reemplazar palabras ignoradas por marcadores temporales
-        def reemplazar_ignoradas(match):
-            palabra = match.group(0)
-            marcador = f"__IGNORAR_{len(reemplazos)}__"
-            reemplazos[marcador] = palabra
-            return marcador
-
-        patron_ignorar = re.compile(r'\b(' + '|'.join(palabras_ignorar) + r')\b', re.IGNORECASE)
-        texto_temporal = patron_ignorar.sub(reemplazar_ignoradas, texto)
-
-        # Inicializar el corrector de LanguageTool
-        tool = language_tool_python.LanguageToolPublicAPI(idioma)
-
-        # Obtener las correcciones sugeridas
-        texto_corregido = tool.correct(texto_temporal)
-
-        # Restaurar las palabras ignoradas
-        for marcador, palabra_original in reemplazos.items():
-            texto_corregido = texto_corregido.replace(marcador, palabra_original)
-
-        # Diccionario con palabras interrogativas y sus versiones acentuadas
-        palabras_interrogativas = {
-            "como": "cómo", "cuando": "cuándo", "donde": "dónde", "que": "qué",
-            "quien": "quién", "cual": "cuál", "cuanto": "cuánto"
-        }
-
-        # Si la oración es interrogativa, corregir solo la primera palabra interrogativa
-        if texto_corregido.endswith("?"):
-            palabras = texto_corregido[:-1].split()  # Remover "?" y dividir en palabras
-            primera_encontrada = False
-
-            for i, palabra in enumerate(palabras):
-                palabra_limpia = palabra.lower().strip("¿")  # Remover el signo "¿" si existe
-
-                # Si es una palabra interrogativa y es la primera encontrada, corregir
-                if palabra_limpia in palabras_interrogativas:
-                    if not primera_encontrada:
-                        palabras[i] = palabras_interrogativas[palabra_limpia]
-                        primera_encontrada = True
-
-            texto_corregido = " ".join(palabras) + "?"
-
-            # Asegurar que la oración comienza con "¿"
-            if not texto_corregido.startswith("¿"):
-                texto_corregido = "¿" + texto_corregido
-
-        # Mantener solo el último signo "¿" y eliminar los anteriores
-        if texto_corregido.count("¿") > 1:
-            ultima_pos = texto_corregido.rfind("¿")
-            texto_corregido = texto_corregido[:ultima_pos].replace("¿", "") + texto_corregido[ultima_pos:]
-
-        return texto_corregido
-
-    except Exception:
-        return texto
-
-def normalizar_clave(texto):
-    reemplazos = {
-        "á": "a", "é": "e", "í": "i", "ó": "o", "ú": "u",
-        "ä": "a", "ë": "e", "ï": "i", "ö": "o", "ü": "u"
-    }
-    for acentuada, normal in reemplazos.items():
-        texto = texto.replace(acentuada, normal)
-
-    return texto.strip().replace(" ", "+")
-
-estado_chatbot = {
-    "esperando_confirmacion": False,
-    "opciones": [],
-    "texto_original": ""
-}
-
-def obtener_respuesta_chatbot(text):
-    global estado_chatbot
-
-        # Si no está esperando confirmación, resetea su estado antes de procesar la nueva consulta
-    if not estado_chatbot["esperando_confirmacion"]:
-        estado_chatbot["opciones"] = []  # Limpia opciones anteriores
-        estado_chatbot["texto_original"] = ""  # Resetea el estado previo
-
-    if estado_chatbot["esperando_confirmacion"]:
-        if text.lower() in afirmaciones:
-            estado_chatbot["esperando_confirmacion"] = False  # Se resetea el estado
-            respuesta = obtener_respuesta_sin_repetir(estado_chatbot["opciones"][0]["label"])
-            estado_chatbot["opciones"] = []  # Limpia opciones anteriores
-            estado_chatbot["texto_original"] = ""  # Resetea el estado previo
-            return respuesta
-        elif text.lower() in negaciones:
-            if len(estado_chatbot["opciones"]) > 1:
-                estado_chatbot["esperando_confirmacion"] = False  # Se resetea el estado
-                return obtener_respuesta_sin_repetir(estado_chatbot["opciones"][1]["label"])
-            else:
-                estado_chatbot["esperando_confirmacion"] = False  # Se resetea el estado
-                return "No tengo más opciones, ¿podés reformular la pregunta?"
-
-        else:
-            return "Por favor, respondé 'sí' o 'no'."
-
-    prediction = chatbot(text)
-    prediction = sorted(prediction, key=lambda x: x["score"], reverse=True)  # Ordenar por score
-
-    label_principal = prediction[0]["label"]
-    score_principal = prediction[0]["score"]
-
-    if score_principal >= 0.1:
-        print("(Grado de seguridad en la respuesta: ", score_principal, ")")
-        return obtener_respuesta_sin_repetir(label_principal)
-
-    elif 0.20 <= score_principal < 0.4:
-        estado_chatbot["esperando_confirmacion"] = True
-        estado_chatbot["opciones"] = prediction[:2]
-        estado_chatbot["texto_original"] = text
-
-        opciones_texto = ", ".join(
-            [f"{alt['label']} ({alt['score']:.2f})" for alt in estado_chatbot["opciones"]]
-        )
-        return f"No estoy seguro de la respuesta correscta. ¿Te referís a alguna de estas opciones? Opción 1: {opciones_texto} (Si/No)"
-
-    else:
-        print(f"No tengo una respuesta precisa. ¿Puedes decirme una palabra clave de tu pregunta para que pueda ayudarte? Ingresa una o dos palabras:")
-        clave = input().lower()  # No es necesario str()
-        clave = normalizar_clave(clave)
-
-        # Verificar si la palabra clave no es una negación
-        if clave not in negaciones:
-            # Si no es una negación, proporcionar el enlace
-            return f"Prueba consultando el siguiente enlace: https://www.unaj.edu.ar/?s={clave} o reformula tu pregunta. Escribela a continuación:"
-        else:
-            # Si la clave es una negación, podrías manejarlo aquí
-            return "Comprendo, intenta reformular tu pregunta por favor para que pueda entenderla. Prueba usando frases cortas y claras."
-
-faq = ['¿Cuándo puedo inscribirme a carreras?', '¿Qué carreras tiene la UNAJ?', '¿Qué posgrados tiene la UNAJ?', '¿Qué cursos de oficios tiene la UNAJ y cómo puedo inscribirme?', '¿Qué otras propuestas de formación ofrece la UNAJ?', '¿Puedo estudiar idiomas en la UNAJ?', '¿Qué hago si no puedo ingresar al SIU GUARANÍ?', '¿Cuándo comienza y termina el cuatrimestre?', '¿Dónde encuentro el calendario académico?', '¿Cuándo puedo reincorporarme?', '¿Cuándo puedo cambiar de carrera?', '¿Cómo pido equivalencias?', '¿Cómo pido una licencia estudiantil?']
-
-for f in faq:
-    print(f)
-    print(obtener_respuesta_chatbot(corregir_preguntas(f.lower())))
-    print("-------------------------------------------------------------------------------------------------------------------------------------")
-
-# Instalar librerías necesarias
-!pip install gradio pyngrok
-
-import gradio as gr
-from pyngrok import ngrok
-
-!ngrok authtoken 2joTtbK1dLq8wGpfwu3aUzz3r83_3RtvMEa2QazhDFauAHHaG
-
-import pandas as pd
-from datetime import datetime
-from bs4 import BeautifulSoup
-
-# Nombre del archivo CSV
-feedback_file = "feedback.csv"
-
-# Inicializar CSV si no existe
-def init_csv():
-    try:
-        pd.read_csv(feedback_file)
-    except FileNotFoundError:
-        df = pd.DataFrame(columns=["timestamp", "question", "response", "feedback"])
-        df.to_csv(feedback_file, index=False)
-
-# Extrae el texto de la respuesta HTML
-def limpiar_html(texto_html):
-    return BeautifulSoup(texto_html, "html.parser").get_text()
-
-# Guardar el feedback cuando se hace clic en "Nuevo Mensaje"
-def guardar_feedback(question, response, feedback):
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    response_limpia = limpiar_html(response)
-    new_data = pd.DataFrame([[timestamp, question, response_limpia, feedback]],
-                            columns=["timestamp", "question", "response", "feedback"])
-    new_data.to_csv(feedback_file, mode='a', header=False, index=False)
-    return "", "", 10, gr.update(interactive=False)  # limpia todo y desactiva "Nuevo Mensaje"
-
-# Convierte las URL en hipervinculos clickeables
-def convertir_urls_a_links(texto):
-    # Expresión regular para encontrar URLs
-    url_pattern = r"(https?://[^\s]+)"
-    # Reemplaza cada URL por una etiqueta <a>
-    return re.sub(url_pattern, r'<a href="\1" target="_blank">\1</a>', texto)
-
-# Simulación de respuesta del chatbot (reemplazar por tu modelo real)
-def chatbot_response(question):
-    mensaje_corregido = corregir_preguntas(question)
-    respuesta_raw = obtener_respuesta_chatbot(mensaje_corregido)
-    respuesta = convertir_urls_a_links(respuesta_raw)
-
-    # Agrega un contenedor con estilo para simular una caja
-    respuesta_contenedor = f"""
-    <div style='background-color:#2b2b2b; color:#f1f1f1; border:0px solid #515057;
-                padding:10px; border-radius:5px; white-space:pre-wrap'>
-        {respuesta}
-    </div>
-    """
-
-    return respuesta_contenedor, gr.update(visible=True, interactive=True)
-
-# Inicializamos el CSV
-init_csv()
-
-# Interfaz Gradio
-with gr.Blocks(css="""
-body {
-  background-color: black;
-  color: #00ffff;
-}
-.gr-button {
-  background-color: #00ffff !important;
-  color: black !important;
-}
-.gr-textbox textarea, .gr-number input {
-  background-color: #111;
-  color: #00ffff;
-  border: 1px solid #00ffff;
-}
-""") as demo:
-    with gr.Row():
-        gr.HTML("<div style='flex:1'></div><img src='https://guarani.unaj.edu.ar/_comp/unaj/img/logo-transparente.png' height='60px' style='margin:10px'/>")
-
-    gr.Markdown("# Chatbot UNAJ\n## Hola! Soy Arturito, el bot de la UNAJ y estoy para responder tus preguntas sobre la Universidad Nacional Arturo Jauretche")
-
-    question_input = gr.Textbox(label="Mensaje", placeholder="Escribí tu consulta...")
-    submit_btn = gr.Button("Enviar Mensaje")
-
-    # Se usa un HTML para que los links de la respuesta sean clickeables
-    response_output = gr.HTML()
-
-    # Se coloca un slider que permite captar el feedback de la respuesta
-    feedback_slider = gr.Slider(minimum=1, maximum=10, value=10, step=1,
-                                label="¿Qué tan útil fue la respuesta? (1 = Nada útil, 10 = Muy útil)", interactive=True)
-
-    # Aparece un boton para "Nuevo Mensaje" que limpia el cuadro de "Mensaje" y guarda la respuesta y puntuación.
-    new_message_btn = gr.Button("Nuevo Mensaje", visible=False)
-
-    # Evento al hacer clic en "Enviar Mensaje"
-    submit_btn.click(fn=chatbot_response,
-                     inputs=question_input,
-                     outputs=[response_output, new_message_btn])
-
-    # Evento al hacer clic en "Nuevo Mensaje"
-    new_message_btn.click(fn=guardar_feedback,
-                          inputs=[question_input, response_output, feedback_slider],
-                          outputs=[question_input, response_output, feedback_slider, new_message_btn])
-
-demo.launch(share=True)