Add Dockerfile and project files

.gitattributes

@@ -1,35 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,21 @@
+# Usa una imagen base de Python
+FROM python:3.9-slim
+
+# Establecer el directorio de trabajo
+WORKDIR /app
+
+# Copiar el archivo de requerimientos
+COPY requirements.txt /app
+
+# Instalar dependencias
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copiar el resto del código
+COPY . /app
+
+# Hugging Face Spaces asigna un puerto en la variable $PORT
+# Ajusta tu Flask para usar ese puerto (ver más abajo).
+EXPOSE 7860
+
+# Usar gunicorn para producción (puerto = 7860 por convención en Spaces)
+CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:7860"]

README.md

@@ -1,11 +1,177 @@
----
-title: ChatBot MentalHealth
-emoji: 💻
-colorFrom: green
-colorTo: green
-sdk: docker
-pinned: false
-short_description: ChatBot-MentalHealth es una aplicación diseñada para brindar
+# Chatbot de Salud Mental - Versión 1.0
+
+<div align="center">
+  <img src="static/img/1.png" alt="Pantalla de Inicio" width="250">
+  <br>
+  <em>Logo del Chatbot de Salud Mental</em>
+</div>
+
+## Descripción del Proyecto
+Este proyecto es un chatbot **orientado a la salud mental** que, mediante **Procesamiento de Lenguaje Natural (PLN)**, analiza los mensajes ingresados por los usuarios (ya sea por **texto** o **audio**) para predecir su estado emocional y generar respuestas de apoyo o contestaciones acordes.
+
+- **Interacción por voz**: El usuario puede hablar (speech-to-text) y recibir la respuesta en audio (text-to-speech).  
+- **Emociones limitadas**: Actualmente detecta 11 emociones básicas, pero se planea mejorar en futuras versiones (2.0).  
+- **Versión 1.0**: Implementación básica y experimental; **no** sustituye asesoramiento profesional.
+
+## Tecnologías Utilizadas
+- **Python**: Flask (backend web), Transformers, PyTorch  
+- **BERT** (Bidirectional Encoder Representations from Transformers)  
+- **Procesamiento de Lenguaje Natural (PLN)**  
+- **Reconocimiento de Voz** (SpeechRecognition en el navegador)  
+- **Síntesis de Texto a Voz** (pyttsx3/pydub)  
+- **HTML, CSS, JavaScript** (Frontend)
+
+## Arquitectura del Chatbot
+
+El pipeline principal que sigue este proyecto es:
+
+```text
+ -> Speech Recognition -> Natural Language Understanding -> Dialog Manager <-> Task Manager
+    Text-to-Speech Synthesis <- Natural Language Generation <- Dialog Manager
+```
+
+1. **Speech Recognition**: El usuario habla y el navegador convierte el audio a texto (Web Speech API).  
+2. **Natural Language Understanding**: El texto se envía a Flask, donde BERT analiza la emoción.  
+3. **Dialog Manager**: Gestiona la lógica de la conversación y decide la respuesta.  
+4. **Text-to-Speech Synthesis**: El chatbot genera un archivo de audio que se devuelve al navegador.  
+
+## Emociones Detectadas
+El modelo (fine-tuned en BERT) reconoce las siguientes emociones:
+
+- FELICIDAD
+- NEUTRAL
+- DEPRESIÓN
+- ANSIEDAD
+- ESTRÉS
+- EMERGENCIA
+- CONFUSIÓN
+- IRA
+- MIEDO
+- SORPRESA
+- DISGUSTO
+
+Se utilizó un dataset de ~500 muestras para cada emoción (total ~5500 filas).
+
+# Capturas de Pantalla
+
+**Página de Inicio**
+<div align="center"> <img src="static/img/index.png" alt="Página de Inicio" width="1000"> <br> <em>Página de inicio del Chatbot de Salud Mental</em> </div>
+
+**Interfaz del Chatbot**
+<div align="center"> <img src="static/img/chatbot1.png" alt="Interfaz del Chatbot" width="1000"> <br> <em>Interfaz del Chatbot</em> </div>
+
+**Reconocimiento de Voz Activado**
+<div align="center"> <img src="static/img/chatbot2.png" alt="Reconocimiento de Voz Activado" width="1000"> <br> <em>Indicador de grabación de voz</em> </div>
+
+## Estructura del Proyecto
+
+```text
+ChatBot/
+├── conversations/
+├── data/
+│   └── emotion_dataset.csv
+├── models/
+│   ├── bert_emotion_model/
+│   │   ├── checkpoint-1600
+│   │   ├── checkpoint-1650
+│   │   ├── config.json
+│   │   ├── model.safetensors
+│   │   ├── special_tokens_map.json
+│   │   ├── tokenizer.json
+│   │   ├── tokenizer_config.json
+│   │   ├── training_args.bin
+│   │   └── vocab.txt
+│   ├── chatbot_model.py
+│   └── responses.json
+├── static/
+│   ├── audio/
+│   ├── css/
+│   │   └── styles.css
+│   ├── img/
+│   └── js/
+│       └── scripts.js
+├── templates/
+│   ├── chatbot.html
+│   └── index.html
+├── app.py
+├── chatbot.log
+├── error.log
+├── requirements.txt
+└── train_model.py
+```
+
+## Instalación y Configuración
+
+### 1. Clonar el repositorio con Git LFS
+Si el proyecto usa archivos grandes (como modelos BERT), asegúrate de tener Git LFS instalado antes de clonar el repositorio.
+```bash
+# Instalar Git LFS (si no lo tienes)
+git lfs install
+
+# Clonar el repositorio
+git clone https://github.com/tu-usuario/ChatBot-MentalHealth.git
+cd ChatBot-MentalHealth
+```
+
+### 2. Crear un entorno virtual y activarlo
+```bash
+python -m venv venv
+# En Windows
+venv\Scripts\activate
+# En macOS/Linux
+source venv/bin/activate
+```
+
+### 3. Instalar dependencias
+```bash
+pip install -r requirements.txt
+```
+
+### 4. Ejecutar la aplicación
+```bash
+python app.py
+```
+La aplicación se ejecutará en [http://127.0.0.1:5000/](http://127.0.0.1:5000/).
+
+## Ejemplo de Código (`train_model.py`)
+
+```python
+class CustomTrainer(Trainer):
+    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
+        labels = inputs.get("labels").to(model.device)
+        outputs = model(**inputs)
+        logits = outputs.get("logits")
+        loss = custom_loss(labels, logits)  # Pérdida con class_weights
+        return (loss, outputs) if return_outputs else loss
+
+def custom_loss(labels, logits):
+    loss_fct = torch.nn.CrossEntropyLoss(weight=class_weights)
+    return loss_fct(logits, labels)
+```
+
+De esta forma, cada emoción recibe un peso distinto, mitigando el riesgo de que el modelo ignore las clases menos representadas.
+
+## Flujo de Uso de los Archivos en el Proyecto
+
+1. **Cargar el Modelo**: Los pesos del modelo están en `model.safetensors` junto con `config.json`, `tokenizer.json`, etc.
+2. **Tokenización**: Se convierte la entrada (texto) en tokens con el tokenizer de BERT (`tokenizer.json`, `vocab.txt`).
+3. **Inferencia**: El texto del usuario se procesa con BERT para predecir la emoción y generar una respuesta.
+4. **Respuesta**: Se envía el texto de vuelta al navegador y, si se activa la síntesis de voz, se genera un archivo de audio.
+
+## Notas Finales
+
+- Esta versión (1.0) es experimental y **no** sustituye asesoramiento profesional en salud mental.
+- Se recomienda seguir refinando el modelo, incorporar más emociones y ampliar la base de datos.
+- En caso de emergencia o situación de riesgo, busca ayuda de un profesional de la salud mental.
+
+## Colaboradores
+- **Nicolás Ceballos Brito** (@Nico2603)
+- **Juan Alejandro Urueña Serna** (@Uruena2603)
+- **Camilo Castañeda Yepes** (@camCy)
+
+Para cualquier duda o sugerencia, contáctame en: **[email protected]**
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+¡Gracias por probar el Chatbot de Salud Mental!  
+Si deseas contribuir, siéntete libre de hacer un **fork** y enviar tus **pull requests**.

app.py

@@ -0,0 +1,63 @@
+import os
+import logging
+from flask import Flask, render_template, request, jsonify
+from models.chatbot_model import MentalHealthChatbot
+
+app = Flask(__name__)
+
+# Configurar el registro de errores
+logging.basicConfig(
+    level=logging.ERROR,
+    format='%(asctime)s %(levelname)s %(name)s %(threadName)s : %(message)s',
+    handlers=[
+        logging.FileHandler("error.log"),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Crear una instancia del chatbot con el modelo fine-tuned
+try:
+    chatbot = MentalHealthChatbot(model_path='models/bert_emotion_model')
+except Exception as e:
+    logger.error(f"Error al inicializar el chatbot: {e}")
+    raise
+
+@app.route('/')
+def index():
+    try:
+        return render_template('index.html')
+    except Exception as e:
+        logger.error(f"Error al renderizar index.html: {e}")
+        return "Error al cargar la página de inicio.", 500
+
+@app.route('/chatbot')
+def chatbot_page():
+    try:
+        return render_template('chatbot.html')
+    except Exception as e:
+        logger.error(f"Error al renderizar chatbot.html: {e}")
+        return "Error al cargar la página del chatbot.", 500
+
+@app.route('/get_response', methods=['POST'])
+def get_bot_response():
+    try:
+        user_input = request.form.get('message', '').strip()
+        if not user_input:
+            logger.warning("Mensaje vacío recibido del usuario.")
+            return jsonify({'response': "Por favor, ingresa un mensaje.", 'audio_path': None}), 400
+
+        response_data = chatbot.generate_response(user_input)
+        response_text = response_data.get('text', "Lo siento, no pude procesar tu mensaje.")
+        audio_path = response_data.get('audio_path', '')
+
+        return jsonify({'response': response_text, 'audio_path': audio_path})
+
+    except Exception as e:
+        logger.error(f"Error en /get_response: {e}")
+        return jsonify({'response': "Lo siento, ha ocurrido un error al procesar tu solicitud.", 'audio_path': None}), 500
+
+if __name__ == '__main__':
+    # Ajustamos para leer la variable de entorno PORT (o usar 7860 por defecto)
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port, debug=True)

data/emotion_dataset.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdfc2e577dd8f636ef0895a70c1fc88ed85796cd4ca49be762f889222e1ebab9
+size 262199

models/bert_emotion_model/config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d577c1a895af38eaee44acbbacebcd5ddc8131b8c86bf83a61900a970a0e6b0e
+size 1232

models/bert_emotion_model/id_to_label.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62e6445c3c0aaedbbc923a3833b7782e1a470158bb3ee33a64f6fe686f3242ed
+size 197

models/bert_emotion_model/label_to_id.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7f224ae7d4fbb6aa8c2306d0bcd8a5f0af01b585105d726e102995e25f78850
+size 175

models/bert_emotion_model/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8fe35a11a5154074d70a3a5c49d56eaea4a6e136cd2c491ca7077a452d3fc9c
+size 439460892

models/bert_emotion_model/special_tokens_map.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d5b662e421ea9fac075174bb0688ee0d9431699900b90662acd44b2a350503a
+size 695

models/bert_emotion_model/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19b81454892d4fea517c4b3451266e52f17fa67c18897d362c7a3436b5cd6ee9
+size 729452

models/bert_emotion_model/tokenizer_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1db878ac84c4485192c8ec713e90bfde5025001d8cf521e6329610bf782707a
+size 1237

models/bert_emotion_model/training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88327331d4c1c4db61b98f5a6a232d2b6c026d7d331d0f550e63332421a63d89
+size 5240

models/chatbot_model.py

@@ -0,0 +1,227 @@
+import torch
+from transformers import BertForSequenceClassification, BertTokenizer
+import numpy as np
+import re
+from datetime import datetime
+import os
+import logging
+from typing import Tuple, Dict, Any
+import json
+import pyttsx3
+
+class MentalHealthChatbot:
+    def __init__(self, model_path: str = 'models/bert_emotion_model'):
+        """
+        Inicializa el chatbot con el modelo BERT fine-tuned y configuraciones necesarias.
+        Args:
+            model_path: Ruta al modelo fine-tuned
+        """
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+        # Configuración del logging
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logging.INFO)
+        handler = logging.FileHandler('chatbot.log')
+        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+        handler.setFormatter(formatter)
+        if not self.logger.handlers:
+            self.logger.addHandler(handler)
+
+        try:
+            self.logger.info("Cargando el tokenizador y el modelo BERT fine-tuned...")
+
+            # Crear carpeta para guardar historiales si no existe
+            os.makedirs('conversations', exist_ok=True)
+
+            self.tokenizer = BertTokenizer.from_pretrained(model_path)
+            self.model = BertForSequenceClassification.from_pretrained(model_path).to(self.device)
+
+            # Cargar respuestas predefinidas
+            self.load_responses()
+
+            # Inicializar el historial de conversación
+            self.conversation_history = []
+
+            self.logger.info("Chatbot inicializado correctamente.")
+        except Exception as e:
+            self.logger.error(f"Error al cargar el modelo: {str(e)}")
+            raise e
+
+    def load_responses(self):
+        """Carga las respuestas predefinidas desde un archivo JSON."""
+        try:
+            with open('models/responses.json', 'r', encoding='utf-8') as f:
+                self.responses = json.load(f)
+            self.logger.info("Respuestas cargadas desde 'responses.json'.")
+        except FileNotFoundError:
+            self.logger.error("Archivo 'responses.json' no encontrado. Asegúrate de que el archivo existe en la ruta especificada.")
+            raise
+        except json.JSONDecodeError as e:
+            self.logger.error(f"Error al decodificar 'responses.json': {str(e)}")
+            raise
+
+    def preprocess_text(self, text: str) -> str:
+        """Preprocesa el texto de entrada."""
+        try:
+            text = text.lower()
+            text = re.sub(r'[^\w\s]', '', text)
+            return text.strip()
+        except Exception as e:
+            self.logger.error(f"Error al preprocesar el texto: {str(e)}")
+            return text
+
+    def detect_emergency(self, text: str) -> bool:
+        """Detecta si el mensaje indica una emergencia de salud mental."""
+        try:
+            emergency_keywords = [
+                'suicidar', 'morir', 'muerte', 'matar', 'dolor',
+                'ayuda', 'emergencia', 'crisis', 'grave'
+            ]
+            return any(keyword in text.lower() for keyword in emergency_keywords)
+        except Exception as e:
+            self.logger.error(f"Error al detectar emergencia: {str(e)}")
+            return False
+
+    def get_emotion_prediction(self, text: str) -> Tuple[str, float]:
+        """Predice la emoción del texto usando el modelo fine-tuned."""
+        # Asegúrate de que el orden de las etiquetas coincide con el del entrenamiento
+        emotion_labels = ['FELICIDAD', 'NEUTRAL', 'DEPRESIÓN', 'ANSIEDAD', 'ESTRÉS',
+                          'EMERGENCIA', 'CONFUSIÓN', 'IRA', 'MIEDO', 'SORPRESA', 'DISGUSTO']
+
+        try:
+            inputs = self.tokenizer.encode_plus(
+                text,
+                add_special_tokens=True,
+                max_length=128,
+                padding='max_length',
+                truncation=True,
+                return_tensors='pt'
+            ).to(self.device)
+
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                probs = torch.softmax(outputs.logits, dim=1)
+                predicted_class = torch.argmax(probs, dim=1).item()
+                confidence = probs[0][predicted_class].item()
+
+            emotion = emotion_labels[predicted_class]
+            self.logger.info(f"Emoción predicha: {emotion} con confianza {confidence:.2f}")
+            return emotion, confidence
+
+        except Exception as e:
+            self.logger.error(f"Error en la predicción de emoción: {str(e)}")
+            return 'CONFUSIÓN', 0.0
+
+    def generate_response(self, user_input: str) -> Dict[str, Any]:
+        """Genera una respuesta basada en el input del usuario."""
+        try:
+            # Preprocesar texto
+            processed_text = self.preprocess_text(user_input)
+            self.logger.info(f"Texto procesado: {processed_text}")
+
+            # Verificar emergencia
+            if self.detect_emergency(processed_text):
+                emotion = 'EMERGENCIA'
+                confidence = 1.0
+                self.logger.info("Emergencia detectada en el mensaje del usuario.")
+            else:
+                # Predecir emoción
+                emotion, confidence = self.get_emotion_prediction(processed_text)
+
+            # Seleccionar respuesta
+            responses = self.responses.get(emotion, self.responses.get('CONFUSIÓN', ["Lo siento, no he entendido tu mensaje."]))
+
+            response = np.random.choice(responses)
+            self.logger.info(f"Respuesta seleccionada: {response}")
+
+            # Generar audio
+            audio_path = self.generate_audio(response)
+
+            # Actualizar historial
+            self.update_conversation_history(user_input, response, emotion)
+
+            # Guardar historial después de actualizar
+            self.save_conversation_history()
+
+            return {
+                'text': response,
+                'audio_path': audio_path,
+                'emotion': emotion,
+                'confidence': confidence,
+                'timestamp': datetime.now().isoformat()
+            }
+
+        except Exception as e:
+            self.logger.error(f"Error al generar respuesta: {str(e)}")
+            return {
+                'text': "Lo siento, ha ocurrido un error. ¿Podrías intentarlo de nuevo?",
+                'audio_path': None,
+                'emotion': 'ERROR',
+                'confidence': 0.0,
+                'timestamp': datetime.now().isoformat()
+            }
+
+    def generate_audio(self, text: str) -> str:
+        """Genera el audio para la respuesta y devuelve la URL accesible para el cliente."""
+        try:
+            filename = f"response_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}.mp3"
+            file_path = os.path.join('static', 'audio', filename)
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+            engine = pyttsx3.init()
+
+            # Configurar la voz en español (ajusta el índice o usa el id de la voz)
+            voices = engine.getProperty('voices')
+            for voice in voices:
+                if 'Spanish' in voice.name or 'Español' in voice.name:
+                    engine.setProperty('voice', voice.id)
+                    break
+            else:
+                self.logger.warning("No se encontró una voz en español. Usando la voz predeterminada.")
+
+            # Configurar la velocidad del habla si es necesario
+            rate = engine.getProperty('rate')
+            engine.setProperty('rate', rate - 50)  # Ajusta el valor según tus necesidades
+
+            # Guardar el audio en el archivo especificado
+            engine.save_to_file(text, file_path)
+            engine.runAndWait()
+
+            self.logger.info(f"Audio generado y guardado en {file_path}")
+
+            # Devolver la ruta relativa que el cliente puede usar
+            return f"/static/audio/{filename}"
+        except Exception as e:
+            self.logger.error(f"Error al generar audio: {str(e)}")
+            return None
+
+    def update_conversation_history(self, user_input: str, response: str, emotion: str):
+        """Actualiza el historial de conversación."""
+        try:
+            self.conversation_history.append({
+                'user_input': user_input,
+                'response': response,
+                'emotion': emotion,
+                'timestamp': datetime.now().isoformat()
+            })
+
+            # Mantener solo las últimas 10 conversaciones
+            if len(self.conversation_history) > 10:
+                self.conversation_history.pop(0)
+
+            self.logger.info("Historial de conversación actualizado.")
+        except Exception as e:
+            self.logger.error(f"Error al actualizar el historial de conversación: {str(e)}")
+
+    def save_conversation_history(self):
+        """Guarda el historial de conversación en un archivo."""
+        try:
+            filename = f"conversations/chat_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+            os.makedirs(os.path.dirname(filename), exist_ok=True)
+
+            with open(filename, 'w', encoding='utf-8') as f:
+                json.dump(self.conversation_history, f, ensure_ascii=False, indent=2)
+
+            self.logger.info(f"Historial de conversación guardado en {filename}")
+        except Exception as e:
+            self.logger.error(f"Error al guardar el historial: {str(e)}")

models/responses.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83a5d8720e08ce62a1ab51997deda4dbefc3191f19b0237caddd4d7e0d9dd0c1
+size 123983

static/css/styles.css

@@ -0,0 +1,360 @@
+/* Variables globales */
+:root {
+    --primary-color: #128C7E;
+    --secondary-color: #25D366;
+    --background-color: #E5DDD5;
+    --chat-bg: #DCF8C6;
+    --bot-chat-bg: #FFFFFF;
+    --text-color: #333333;
+}
+
+/* Estilos generales */
+* {
+    box-sizing: border-box;
+}
+
+body {
+    background-color: var(--background-color);
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    margin: 0;
+    padding: 0;
+    height: 100vh;
+}
+
+/* Contenedor principal del chat */
+.chat-container {
+    display: flex;
+    flex-direction: column;
+    max-width: 650px;
+    margin: 20px auto; /* Margen ajustado para centrar */
+    height: calc(100vh - 40px);
+    background-color: var(--background-color);
+    padding: 0;
+    border: 1px solid #ccc;
+    border-radius: 15px;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+}
+
+/* Header del chat */
+.chat-header {
+    background-color: var(--primary-color);
+    color: white;
+    padding: 15px;
+    display: flex;
+    align-items: center;
+    flex-shrink: 0;
+    width: 100%;
+    border-top-left-radius: 15px;
+    border-top-right-radius: 15px;
+}
+
+/* Ajustar el avatar del bot */
+.chat-header img {
+    width: 80px;  /* Aumentar el tamaño del avatar */
+    height: 80px;
+    border-radius: 50%;
+    margin-right: 15px;
+    position: relative;
+    left: 10px; /* Mover el avatar 10px hacia la izquierda */
+}
+
+/* Área de mensajes */
+.chatbox {
+    flex-grow: 1;
+    overflow-y: auto;
+    padding: 20px; /* Añadir padding uniforme */
+    background-color: var(--background-color);
+    scroll-behavior: smooth;
+}
+
+/* Estilos de los mensajes */
+.message {
+    /* Propiedades existentes */
+    max-width: 65%;
+    margin: 10px 0;
+    padding: 10px 15px;
+    position: relative;
+    clear: both;
+    animation: messageIn 0.3s ease-out;
+
+    /* Nuevas propiedades */
+    border: 1px solid #ccc; /* Borde gris claro */
+    border-radius: 10px;    /* Esquinas redondeadas */
+}
+
+.user-message {
+    background-color: var(--chat-bg);
+    float: right;
+    border-radius: 15px 0 15px 15px;
+}
+
+.bot-message {
+    background-color: var(--bot-chat-bg);
+    float: left;
+    border-radius: 0 15px 15px 15px;
+}
+
+/* Área de entrada de mensaje */
+.input-group {
+    background-color: #F0F0F0;
+    padding: 10px; /* Añadir padding uniforme */
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    flex-shrink: 0;
+    width: 100%; /* Asegurar que ocupe el 100% del contenedor */
+    border-bottom-left-radius: 15px; /* Esquinas redondeadas inferiores */
+    border-bottom-right-radius: 15px;
+    border-top: 1px solid #ccc; /* Borde superior para separar del chat */
+}
+
+/* Campo de entrada */
+.input-group input {
+    flex: 1;
+    padding: 12px;
+    margin: 0 10px; /* Margen horizontal para mantener la separación */
+    border: none;
+    border-radius: 25px;
+    background-color: white;
+    font-size: 16px;
+}
+
+/* Botones de acción */
+.action-button {
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    border-radius: 50%;
+    width: 45px;
+    height: 45px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    transition: background-color 0.3s ease;
+}
+
+.action-button:hover {
+    background-color: var(--secondary-color);
+}
+
+/* Animaciones */
+@keyframes messageIn {
+    from {
+        opacity: 0;
+        transform: translateY(20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+/* Scroll personalizado */
+.chatbox::-webkit-scrollbar {
+    width: 6px;
+}
+
+.chatbox::-webkit-scrollbar-track {
+    background: #f1f1f1;
+}
+
+.chatbox::-webkit-scrollbar-thumb {
+    background: #888;
+    border-radius: 3px;
+}
+
+/* Estilos responsivos para el chat */
+@media (max-width: 768px) {
+    .chat-container {
+        max-width: 100%;
+        padding: 0 10px;
+    }
+
+    .message {
+        max-width: 85%;
+    }
+}
+
+/* Indicador de escritura */
+#typingIndicator p {
+    display: inline-block;
+}
+
+.dot-one, .dot-two, .dot-three {
+    animation: blink 1.4s infinite both;
+}
+
+.dot-one {
+    animation-delay: 0s;
+}
+
+.dot-two {
+    animation-delay: 0.2s;
+}
+
+.dot-three {
+    animation-delay: 0.4s;
+}
+
+@keyframes blink {
+    0% {
+        opacity: 0;
+    }
+    20% {
+        opacity: 1;
+    }
+    100% {
+        opacity: 0;
+    }
+}
+
+/* Indicador de grabación */
+.recording-indicator {
+    position: fixed;
+    bottom: 100px;
+    right: 20px;
+    background-color: var(--primary-color);
+    color: white;
+    padding: 10px 15px;
+    border-radius: 25px;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.recording-indicator i {
+    animation: pulse 1s infinite;
+}
+
+@keyframes pulse {
+    0% {
+        opacity: 0.7;
+    }
+    50% {
+        opacity: 1;
+    }
+    100% {
+        opacity: 0.7;
+    }
+}
+
+/* Estilos para la página de inicio */
+.landing-page {
+    background-color: #f0f2f5;
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.landing-container {
+    width: 100%;
+    max-width: 1200px;
+    padding: 20px;
+}
+
+.welcome-card {
+    background: white;
+    border-radius: 20px;
+    padding: 40px;
+    text-align: center;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.logo-container {
+    margin-bottom: 30px;
+}
+
+.logo {
+    max-width: 100px; /* Aumentado de 120px a 200px */
+    height: auto;
+}
+
+.features {
+    display: flex;
+    justify-content: center;
+    gap: 40px;
+    margin: 40px 0;
+    flex-wrap: wrap;
+}
+
+.feature-item {
+    text-align: center;
+    flex: 1;
+    min-width: 200px;
+}
+
+.feature-item i {
+    font-size: 2.5rem;
+    color: var(--primary-color);
+    margin-bottom: 15px;
+}
+
+.welcome-text {
+    font-size: 1.2rem;
+    color: #666;
+    margin: 30px 0;
+    max-width: 600px;
+    margin-left: auto;
+    margin-right: auto;
+}
+
+.start-chat-btn {
+    display: inline-block;
+    background-color: var(--primary-color);
+    color: white;
+    padding: 15px 30px;
+    border-radius: 30px;
+    text-decoration: none;
+    font-size: 1.2rem;
+    margin: 20px 0;
+    transition: background-color 0.3s ease;
+}
+
+.start-chat-btn:hover {
+    background-color: var(--secondary-color);
+    text-decoration: none;
+}
+
+.start-chat-btn i {
+    margin-right: 10px;
+}
+
+.disclaimer {
+    margin-top: 30px;
+    padding: 15px;
+    background-color: #f8f9fa;
+    border-radius: 10px;
+    font-size: 0.9rem;
+    color: #666;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 10px;
+}
+
+.disclaimer i {
+    color: var(--primary-color);
+}
+
+/* Estilos responsivos para la página de inicio */
+@media (max-width: 768px) {
+    .welcome-card {
+        padding: 20px;
+    }
+
+    .features {
+        flex-direction: column;
+        gap: 20px;
+    }
+
+    .feature-item {
+        min-width: 100%;
+    }
+
+    .logo {
+        max-width: 150px; /* Ajuste para dispositivos móviles */
+    }
+}

static/js/scripts.js

@@ -0,0 +1,116 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const sendButton = document.getElementById('send');
+    const messageInput = document.getElementById('message');
+    const voiceButton = document.getElementById('voice');
+    const chatbox = document.getElementById('chatbox');
+    const recordingIndicator = document.getElementById('recordingIndicator');
+
+    sendButton.addEventListener('click', sendMessage);
+    messageInput.addEventListener('keypress', (e) => {
+        if (e.key === 'Enter') sendMessage();
+    });
+    voiceButton.addEventListener('click', startRecognition);
+
+    function sendMessage() {
+        const message = messageInput.value.trim();
+        if (message === '') return;
+
+        addMessageToChatbox('Usuario', message);
+        messageInput.value = '';
+        toggleInput(false);
+
+        // Mostrar indicador de carga
+        addTypingIndicator();
+
+        fetch('/get_response', {
+            method: 'POST',
+            body: new URLSearchParams({'message': message}),
+        })
+        .then(response => response.ok ? response.json() : response.json().then(err => Promise.reject(err)))
+        .then(data => {
+            removeTypingIndicator();
+            addMessageToChatbox('Asistente', data.response);
+            playResponse(data.audio_path);
+        })
+        .catch(error => {
+            removeTypingIndicator();
+            console.error('Error:', error);
+            addMessageToChatbox('Asistente', error.response || 'Lo siento, ha ocurrido un error al procesar tu solicitud.');
+        })
+        .finally(() => {
+            toggleInput(true);
+        });
+    }
+
+    function addMessageToChatbox(sender, message) {
+        const messageDiv = document.createElement('div');
+        messageDiv.className = sender === 'Usuario' ? 'message user-message' : 'message bot-message';
+        messageDiv.innerHTML = `<p>${message}</p>`;
+        chatbox.appendChild(messageDiv);
+        chatbox.scrollTop = chatbox.scrollHeight;
+    }
+
+    function addTypingIndicator() {
+        const typingIndicator = document.createElement('div');
+        typingIndicator.id = 'typingIndicator';
+        typingIndicator.className = 'message bot-message';
+        typingIndicator.innerHTML = '<p>Escribiendo<span class="dot-one">.</span><span class="dot-two">.</span><span class="dot-three">.</span></p>';
+        chatbox.appendChild(typingIndicator);
+        chatbox.scrollTop = chatbox.scrollHeight;
+    }
+
+    function removeTypingIndicator() {
+        const typingIndicator = document.getElementById('typingIndicator');
+        if (typingIndicator) {
+            chatbox.removeChild(typingIndicator);
+        }
+    }
+
+    function startRecognition() {
+        if (!('webkitSpeechRecognition' in window)) {
+            alert('Tu navegador no soporta reconocimiento de voz.');
+            return;
+        }
+
+        const recognition = new webkitSpeechRecognition();
+        recognition.lang = 'es-ES';
+        recognition.start();
+
+        if (recordingIndicator) {
+            recordingIndicator.style.display = 'block';
+        }
+
+        recognition.onresult = (event) => {
+            const transcript = event.results[0][0].transcript;
+            messageInput.value = transcript;
+            sendMessage();
+        };
+
+        recognition.onerror = (event) => {
+            console.error('Error en el reconocimiento de voz:', event.error);
+            alert('Ocurrió un error durante el reconocimiento de voz: ' + event.error);
+        };
+
+        recognition.onend = () => {
+            if (recordingIndicator) {
+                recordingIndicator.style.display = 'none';
+            }
+        };
+    }
+
+    function playResponse(audioPath) {
+        if (audioPath) {
+            console.log('Reproduciendo audio desde:', audioPath);
+            const audio = new Audio(audioPath);
+            audio.play().catch(error => {
+                console.error('Error al reproducir el audio:', error);
+            });
+        }
+    }
+
+    function toggleInput(enable) {
+        messageInput.disabled = !enable;
+        sendButton.disabled = !enable;
+        voiceButton.disabled = !enable;
+    }
+});

templates/chatbot.html

@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html lang="es">
+<head>
+    <!-- Metadatos y enlaces a estilos y scripts -->
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Chatbot de Salud Mental | Chat</title>
+    <!-- Estilos -->
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+    <!-- Font Awesome -->
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.4/css/all.min.css">
+</head>
+<body>
+    <!-- Contenedor principal del chat -->
+    <div class="chat-container">
+        <!-- Header del chat -->
+        <div class="chat-header">
+            <img src="{{ url_for('static', filename='img/bot-avatar.png') }}" alt="Bot Avatar" class="bot-avatar">
+            <div class="chat-info">
+                <h2>Asistente de Salud Mental</h2>
+                <p class="status">En línea</p>
+            </div>
+        </div>
+
+        <!-- Área de mensajes -->
+        <div class="chatbox" id="chatbox">
+            <!-- Mensaje de bienvenida -->
+            <div class="message bot-message">
+                <p>¡Hola! Soy tu asistente virtual especializado en salud mental. ¿En qué puedo ayudarte hoy?</p>
+            </div>
+        </div>
+
+        <!-- Área de entrada -->
+        <div class="input-group">
+            <input type="text"
+                   id="message"
+                   class="form-control message-input"
+                   placeholder="Escribe un mensaje o presiona el micrófono para hablar..."
+                   autocomplete="off">
+
+            <button class="action-button voice-button" id="voice">
+                <i class="fas fa-microphone"></i>
+            </button>
+
+            <button class="action-button send-button" id="send">
+                <i class="fas fa-paper-plane"></i>
+            </button>
+        </div>
+    </div>
+
+    <!-- Indicador de grabación -->
+    <div class="recording-indicator" id="recordingIndicator" style="display: none;">
+        <i class="fas fa-microphone-alt"></i>
+        <span>Grabando...</span>
+    </div>
+
+    <!-- Scripts -->
+    <script src="{{ url_for('static', filename='js/scripts.js') }}"></script>
+</body>
+</html>

templates/index.html

@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<html lang="es">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Asistente de Salud Mental | Inicio</title>
+    <!-- Estilos -->
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+    <!-- Font Awesome -->
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.4/css/all.min.css">
+    <!-- Bootstrap CSS (opcional) -->
+    <!-- <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css"> -->
+</head>
+<body class="landing-page">
+    <div class="landing-container">
+        <div class="welcome-card">
+            <div class="logo-container">
+                <br><br><br><img src="{{ url_for('static', filename='img/1.png') }}" alt="Logo" class="logo">
+            </div>
+            <h1>Bienvenido a tu Asistente de Salud Mental</h1>
+            <div class="features">
+                <div class="feature-item">
+                    <i class="fas fa-comments"></i>
+                    <p>Conversaciones confidenciales</p>
+                </div>
+                <div class="feature-item">
+                    <i class="fas fa-microphone-alt"></i>
+                    <p>Interacción por voz</p>
+                </div>
+                <div class="feature-item">
+                    <i class="fas fa-brain"></i>
+                    <p>Asistencia profesional</p>
+                </div>
+            </div>
+            <p class="welcome-text">
+                Un espacio seguro para hablar sobre tus pensamientos y emociones.
+                Nuestro asistente virtual está aquí para escucharte y ayudarte.
+            </p>
+            <a href="{{ url_for('chatbot_page') }}" class="start-chat-btn">
+                <i class="fas fa-comment-dots"></i>
+                Iniciar Conversación
+            </a>
+            <div class="disclaimer">
+                <i class="fas fa-info-circle"></i>
+                <p>Este es un asistente virtual y no reemplaza la atención profesional.
+                   En caso de emergencia, contacta a un profesional de la salud.</p>
+            </div>
+        </div>
+    </div>
+    <!-- Scripts opcionales -->
+    <!-- <script src="https://code.jquery.com/jquery-3.5.1.min.js"></script> -->
+</body>
+</html>

train_model.py

@@ -0,0 +1,216 @@
+import os
+import pandas as pd
+from datasets import Dataset
+from transformers import BertTokenizerFast, BertForSequenceClassification, Trainer, TrainingArguments, DataCollatorWithPadding, EarlyStoppingCallback
+from sklearn.model_selection import train_test_split
+from sklearn.utils.class_weight import compute_class_weight
+import torch
+import numpy as np
+import random
+from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
+import json
+
+# Establecer la semilla para garantizar reproducibilidad
+def set_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+set_seed(42)
+
+# Función para cargar datos (simplificada para UTF-8)
+def load_data(file_path):
+    data = pd.read_csv(file_path, encoding='utf-8')
+    return data
+
+# Función para normalizar texto, manteniendo caracteres especiales
+def normalize_text(text):
+    if isinstance(text, str):
+        return text.strip().upper()
+    return text
+
+# Función para limpiar y preparar los datos
+def clean_and_prepare_data(data):
+    data = data.copy()
+    # Eliminar filas con valores nulos
+    data = data.dropna(subset=['text', 'label'])
+    # Normalizar las etiquetas
+    data['label'] = data['label'].apply(normalize_text)
+    # Definir las etiquetas esperadas
+    emotion_labels = ['FELICIDAD', 'NEUTRAL', 'DEPRESIÓN', 'ANSIEDAD', 'ESTRÉS',
+                      'EMERGENCIA', 'CONFUSIÓN', 'IRA', 'MIEDO', 'SORPRESA', 'DISGUSTO']
+    # Filtrar solo las etiquetas conocidas
+    data = data[data['label'].isin(emotion_labels)]
+    # Crear el mapeo de etiquetas
+    label_to_id = {label: idx for idx, label in enumerate(emotion_labels)}
+    data['label'] = data['label'].map(label_to_id)
+    # Verificar que no haya valores NaN
+    if data['label'].isna().any():
+        data = data.dropna(subset=['label'])
+    data['label'] = data['label'].astype(int)
+    return data, emotion_labels, label_to_id
+
+# Función para dividir los datos
+def split_data(data):
+    train_texts, val_texts, train_labels, val_labels = train_test_split(
+        data['text'], data['label'],
+        test_size=0.2,
+        stratify=data['label'],
+        random_state=42
+    )
+    return train_texts, val_texts, train_labels, val_labels
+
+# Función para calcular los pesos de clase
+def get_class_weights(labels):
+    class_weights = compute_class_weight(
+        class_weight='balanced',
+        classes=np.unique(labels),
+        y=labels
+    )
+    return torch.tensor(class_weights, dtype=torch.float)
+
+# Función para tokenizar los datos (sin padding, ya que lo maneja el data collator)
+def tokenize_data(tokenizer, texts, labels):
+    dataset = Dataset.from_dict({'text': texts.tolist(), 'label': labels.tolist()})
+    dataset = dataset.map(lambda batch: tokenizer(batch['text'], truncation=True, max_length=128), batched=True)
+    return dataset
+
+# Función de pérdida personalizada que incorpora los pesos de clase
+def custom_loss(labels, logits):
+    loss_fct = torch.nn.CrossEntropyLoss(weight=class_weights)
+    return loss_fct(logits, labels)
+
+# Clase CustomTrainer para usar la función de pérdida personalizada
+from transformers import Trainer
+
+class CustomTrainer(Trainer):
+    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
+        labels = inputs.get("labels").to(model.device)
+        # Realizar el forward pass
+        outputs = model(**inputs)
+        logits = outputs.get("logits")
+        # Calcular la pérdida personalizada
+        loss = custom_loss(labels, logits)
+        return (loss, outputs) if return_outputs else loss
+
+# Función para calcular métricas de evaluación
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    predictions = np.argmax(logits, axis=-1)
+    labels = labels.astype(int)
+    predictions = predictions.astype(int)
+    accuracy = accuracy_score(labels, predictions)
+    f1 = f1_score(labels, predictions, average='weighted')
+    precision = precision_score(labels, predictions, average='weighted')
+    recall = recall_score(labels, predictions, average='weighted')
+    return {
+        'accuracy': accuracy,
+        'f1': f1,
+        'precision': precision,
+        'recall': recall
+    }
+
+# Función para predecir la etiqueta de un texto dado
+def predict(text):
+    # Tokenizar el texto
+    inputs = tokenizer(text, return_tensors='pt', truncation=True, max_length=128)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    # Realizar la predicción
+    model.eval()
+    with torch.no_grad():
+        outputs = model(**inputs)
+        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        predicted_class = torch.argmax(probs, dim=-1).item()
+        label = id_to_label.get(predicted_class, "Etiqueta desconocida")
+    return label
+
+if __name__ == '__main__':
+    # Configurar el dispositivo
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"\nUsando dispositivo: {device}")
+
+    # Ruta del archivo CSV
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    input_file = os.path.join(current_dir, 'data', 'emotion_dataset.csv')
+
+    # Paso 1: Cargar y preparar los datos
+    data = load_data(input_file)
+    data, emotion_labels, label_to_id = clean_and_prepare_data(data)
+    id_to_label = {v: k for k, v in label_to_id.items()}
+
+    # Paso 2: Dividir los datos
+    train_texts, val_texts, train_labels, val_labels = split_data(data)
+
+    # Paso 3: Calcular los pesos de clase
+    class_weights = get_class_weights(train_labels).to(device)
+
+    # Paso 4: Configurar el tokenizer
+    tokenizer = BertTokenizerFast.from_pretrained('dccuchile/bert-base-spanish-wwm-cased')
+
+    # Paso 5: Tokenizar los datos
+    train_dataset = tokenize_data(tokenizer, train_texts, train_labels)
+    val_dataset = tokenize_data(tokenizer, val_texts, val_labels)
+
+    # Paso 6: Configurar el data collator
+    data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+
+    # Paso 7: Configurar el modelo
+    model = BertForSequenceClassification.from_pretrained(
+        'dccuchile/bert-base-spanish-wwm-cased',
+        num_labels=len(emotion_labels)
+    )
+
+    # Paso 8: Configurar el entrenamiento
+    training_args = TrainingArguments(
+        output_dir='./models/bert_emotion_model',
+        num_train_epochs=5,
+        per_device_train_batch_size=16,
+        per_device_eval_batch_size=16,
+        learning_rate=2e-5,
+        lr_scheduler_type='linear',
+        warmup_steps=500,
+        eval_steps=500,
+        save_steps=500,
+        save_total_limit=1,
+        evaluation_strategy="steps",
+        save_strategy="steps",
+        logging_dir='./logs',
+        logging_steps=100,
+        load_best_model_at_end=True,
+        metric_for_best_model='eval_loss',
+        report_to="none"
+    )
+
+    # Paso 9: Crear el entrenador personalizado
+    trainer = CustomTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=val_dataset,
+        tokenizer=tokenizer,
+        compute_metrics=compute_metrics,
+        data_collator=data_collator,
+        callbacks=[EarlyStoppingCallback(early_stopping_patience=2)]
+    )
+
+    # Paso 10: Entrenar el modelo
+    trainer.train()
+
+    # Paso 11: Guardar el modelo y el tokenizer
+    trainer.save_model('./models/bert_emotion_model')
+    tokenizer.save_pretrained('./models/bert_emotion_model')
+
+    # Paso 12: Guardar los mapeos de etiquetas
+    with open('./models/bert_emotion_model/label_to_id.json', 'w') as f:
+        json.dump(label_to_id, f)
+    with open('./models/bert_emotion_model/id_to_label.json', 'w') as f:
+        json.dump(id_to_label, f)
+
+    print("\nModelo entrenado y guardado exitosamente.")
+
+    # Paso 13: Probar el modelo con un ejemplo
+    sample_text = "Me siento muy feliz hoy"
+    print(f"Texto: {sample_text}")
+    print(f"Predicción: {predict(sample_text)}")