13.5 Evaluación y Despliegue del Tablero

En esta sección, nos enfocaremos en evaluar el rendimiento del tablero de análisis de sentimiento y desplegarlo en una plataforma adecuada. La evaluación ayuda a garantizar que el tablero cumpla con las expectativas de los usuarios y funcione bien bajo diversas condiciones. El despliegue hace que el tablero sea accesible a los usuarios, permitiéndoles beneficiarse de sus funcionalidades.

13.5.1 Evaluación del Tablero

La evaluación implica medir el rendimiento del tablero en términos de precisión, capacidad de respuesta y satisfacción del usuario. Usaremos diferentes métricas y métodos para evaluar estos aspectos.

1. Métricas de Precisión

Las métricas de precisión evalúan qué tan bien los modelos de análisis de sentimiento clasifican el sentimiento de los datos de texto. Las métricas comunes incluyen precisión, precisión, recall, F1-score y matriz de confusión.

Ejemplo: Evaluación de Modelos de Análisis de Sentimiento

Podemos usar la biblioteca sklearn para calcular precisión, recall, F1-score y matriz de confusión para los modelos de análisis de sentimiento.

evaluate_models.py:

import pandas as pd
import pickle
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt

# Load test data and preprocessed text
test_data = pd.read_csv('data/processed_data/test_data_preprocessed.csv')
with open('data/processed_data/X_test.pickle', 'rb') as file:
    X_test = pickle.load(file)

y_test = test_data['sentiment'].apply(lambda x: 1 if x == 'positive' else 0)

# Load Logistic Regression model
with open('models/best_logistic_regression_model.pickle', 'rb') as file:
    logistic_regression_model = pickle.load(file)

# Evaluate Logistic Regression model
y_pred_lr = logistic_regression_model.predict(X_test)
accuracy_lr = accuracy_score(y_test, y_pred_lr)
print(f'Logistic Regression Accuracy: {accuracy_lr}')
print(classification_report(y_test, y_pred_lr))
cm_lr = confusion_matrix(y_test, y_pred_lr, labels=[0, 1])
disp_lr = ConfusionMatrixDisplay(confusion_matrix=cm_lr, display_labels=['Negative', 'Positive'])
disp_lr.plot(cmap=plt.cm.Blues)
plt.title('Logistic Regression Confusion Matrix')
plt.show()

# Load LSTM model
from tensorflow.keras.models import load_model
lstm_model = load_model('models/lstm_model.h5')

# Evaluate LSTM model
y_pred_prob_lstm = lstm_model.predict(X_test)
y_pred_lstm = (y_pred_prob_lstm > 0.5).astype(int)
accuracy_lstm = accuracy_score(y_test, y_pred_lstm)
print(f'LSTM Accuracy: {accuracy_lstm}')
print(classification_report(y_test, y_pred_lstm))
cm_lstm = confusion_matrix(y_test, y_pred_lstm, labels=[0, 1])
disp_lstm = ConfusionMatrixDisplay(confusion_matrix=cm_lstm, display_labels=['Negative', 'Positive'])
disp_lstm.plot(cmap=plt.cm.Blues)
plt.title('LSTM Confusion Matrix')
plt.show()

En este script, evaluamos los modelos de Regresión Logística y LSTM en el conjunto de prueba, calculamos varias métricas y trazamos las matrices de confusión para visualizar el rendimiento.

2. Retroalimentación del Usuario

La retroalimentación del usuario es esencial para evaluar la usabilidad y satisfacción del tablero. Podemos recolectar retroalimentación a través de encuestas o calificaciones directas.

Ejemplo: Recolectando Retroalimentación del Usuario

Podemos modificar nuestra aplicación Flask para incluir un formulario de retroalimentación donde los usuarios pueden calificar su experiencia y proporcionar comentarios.

app.py (continuación):

feedback_data = []

@app.route('/feedback', methods=['POST'])
def feedback():
    user_feedback = request.json
    feedback_data.append(user_feedback)
    return jsonify({'message': 'Thank you for your feedback!'})

# HTML template for feedback form
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Sentiment Analysis Dashboard</title>
    <link rel="stylesheet" href="<https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css>">
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Sentiment Analysis Dashboard</h1>
        <form id="feedback-form" class="mt-4">
            <div class="form-group">
                <label for="rating">Rate your experience:</label>
                <select class="form-control" id="rating" name="rating">
                    <option value="1">1 - Poor</option>
                    <option value="2">2 - Fair</option>
                    <option value="3">3 - Good</option>
                    <option value="4">4 - Very Good</option>
                    <option value="5">5 - Excellent</option>
                </select>
            </div>
            <div class="form-group">
                <label for="comments">Comments:</label>
                <textarea class="form-control" id="comments" name="comments" rows="3"></textarea>
            </div>
            <button type="submit" class="btn btn-primary">Submit Feedback</button>
        </form>
        <div id="feedback-result" class="mt-4"></div>
    </div>

    <script src="<https://code.jquery.com/jquery-3.5.1.min.js>"></script>
    <script>
        $(document).ready(function() {
            $('#feedback-form').on('submit', function(event) {
                event.preventDefault();
                const formData = $(this).serializeArray().reduce((obj, item) => {
                    obj[item.name] = item.value;
                    return obj;
                }, {});
                $.post('/feedback', JSON.stringify(formData), function(data) {
                    $('#feedback-result').html(`<h4>${data.message}</h4>`);
                });
            });
        });
    </script>
</body>
</html>

En este ejemplo, creamos un formulario de retroalimentación donde los usuarios pueden calificar su experiencia y proporcionar comentarios. La retroalimentación se envía al endpoint /feedback y se almacena para su posterior análisis.

3. Tiempo de Respuesta

El tiempo de respuesta es crítico para la experiencia del usuario. Necesitamos asegurar que el panel responda rápidamente a las consultas de los usuarios.

Ejemplo: Medición del Tiempo de Respuesta

Podemos medir el tiempo de respuesta para diferentes consultas usando el módulo time de Python.

evaluate_response_time.py:

import time
import requests

# Function to measure response time
def measure_response_time(endpoint, data):
    start_time = time.time()
    response = requests.post(endpoint, data=data)
    end_time = time.time()
    response_time = end_time - start_time
    return response_time

# Measure response time for sentiment analysis
data = {'text': 'This is a great product!', 'model_type': 'logistic_regression'}
response_time = measure_response_time('<http://localhost:5000/analyze>', data)
print(f'Sentiment Analysis Response Time: {response_time} seconds')

Al medir el tiempo de respuesta, podemos asegurarnos de que el panel cumpla con los criterios de rendimiento deseados.

13.5.2 Despliegue del Panel

Una vez que el panel se evalúe y funcione satisfactoriamente, el siguiente paso es el despliegue. Desplegaremos el panel en una plataforma adecuada donde los usuarios puedan interactuar con él.

1. Despliegue de la Aplicación Web

Podemos desplegar el panel como una aplicación web utilizando una plataforma en la nube como Heroku, AWS o Google Cloud.

Ejemplo: Despliegue en Heroku

Para desplegar el panel en Heroku, sigue estos pasos:

Instalar Heroku CLI: Descarga e instala el Heroku CLI desde Heroku.
Iniciar sesión en Heroku: Abre una terminal e inicia sesión en tu cuenta de Heroku.
heroku login
Crear una App en Heroku: Crea una nueva app en Heroku.
heroku create your-app-name
Preparar el Proyecto para el Despliegue: Crea un Procfile y un requirements.txt en el directorio del proyecto.

Procfile:

```
web: python app.py
```

requirements.txt:

```
Flask
requests
pandas
scikit-learn
tensorflow
plotly
```

5. Enviar el Proyecto a Heroku: Inicializa un repositorio Git, añade los archivos del proyecto y envíalos a Heroku.

```sh
git init
git add .
git commit -m "Initial commit"
git push heroku master
```

6. Abrir la App en Heroku: Abre la app desplegada en tu navegador.

```sh
heroku open
```

Siguiendo estos pasos, el panel se desplegará en Heroku y será accesible a través de una URL pública.

2. Integración con Apps de Mensajería

También podemos integrar el panel con aplicaciones de mensajería como Slack o Microsoft Teams para actualizaciones en tiempo real del análisis de sentimientos.

Ejemplo: Integración con Slack

Para integrar el panel con Slack, sigue estos pasos:

Crear una App de Slack: Crea una nueva app en la API de Slack.
Habilitar Webhooks: Habilita los webhooks entrantes para tu app.
Configurar la URL del Webhook: Configura una URL para recibir mensajes de Slack.

slack_integration.py:

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

SLACK_WEBHOOK_URL = 'your_slack_webhook_url'

@app.route('/slack', methods=['POST'])
def slack():
    data = request.json
    text = data['text']

    # Realizar análisis de sentimientos (usando el modelo de regresión logística como ejemplo)
    preprocessed_text = preprocess_text(text)
    prediction = logistic_regression_model.predict(preprocessed_text)
    sentiment = 'Positive' if prediction[0] == 1 else 'Negative'

    # Enviar resultado de vuelta a Slack
    response = {
        'response_type': 'in_channel',
        'text': f'Sentiment: {sentiment}'
    }
    return jsonify(response)

if __name__ == '__main__':
    app.run(debug=True)

En este script, creamos una ruta /slack para recibir mensajes de Slack, realizar análisis de sentimientos y enviar el resultado de vuelta a Slack.

Cubrimos la evaluación y el despliegue de nuestro panel de análisis de sentimientos. Discutimos varias métricas y métodos para evaluar su rendimiento, incluyendo métricas de precisión, comentarios de usuarios y tiempo de respuesta. Proporcionamos ejemplos de cómo desplegar el panel como una aplicación web utilizando Heroku e integrarlo con Slack para actualizaciones en tiempo real del análisis de sentimientos.

Siguiendo estos pasos, puedes asegurarte de que tu panel funcione bien en escenarios del mundo real y sea accesible para los usuarios en diferentes plataformas. El proceso de despliegue hace que el panel esté disponible para los usuarios, permitiéndoles interactuar con él y beneficiarse de sus funcionalidades.