Tutorial: Análisis del sentimiento de los comentarios del sitio web en una aplicación web con el Generador de modelos de ML.NET

Artículo
10/09/2021
5 minutos para leer

Aprenda a analizar la opinión de los comentarios en tiempo real dentro de una aplicación web.

En este tutorial se muestra cómo crear una aplicación Razor Pages de ASP.NET Core que clasifica las opiniones de los comentarios del sitio web en tiempo real.

En este tutorial aprenderá a:

Crear una aplicación Razor Pages de ASP.NET Core
Preparar y entender los datos
Elección de un escenario
Carga de los datos
Entrenar el modelo
Evaluar el modelo
Usar el modelo para las predicciones

Nota

De momento, el Generador de modelos se encuentra en versión preliminar.

Puede encontrar el código fuente para este tutorial en el repositorio dotnet/machinelearning-samples.

Requisitos previos

Para obtener una lista de los requisitos previos e instrucciones de instalación, visite la Guía de instalación del Generador de modelos.

Creación de una aplicación Razor Pages

Cree una aplicación Razor Pages de ASP.NET Core.
1. Abra Visual Studio y seleccione Archivo > Nuevo > Proyecto en la barra de menús.
2. En el cuadro de diálogo Nuevo proyecto, seleccione el nodo Visual C# seguido del nodo Web.
3. Seleccione la plantilla de proyecto Aplicación web de ASP.NET Core.
4. En el cuadro de texto Nombre, escriba "SentimentRazor".
5. Asegúrese de que Colocar la solución y el proyecto en el mismo directorio está desactivado (VS 2019) o que Crear directorio para la solución está activado (VS 2017).
6. Seleccione el botón Aceptar.
7. Elija Aplicación web en la ventana que muestra los distintos tipos de proyectos de ASP.NET Core y, luego, haga clic en el botón Aceptar.

Preparar y entender los datos

Descargue el conjunto de datos detox de Wikipedia. Cuando se abra la página web, haga clic con el botón derecho en la página, seleccione Guardar como y guarde el archivo en cualquier parte del equipo.

Cada fila del conjunto de datos wikipedia-detox-250-line-data.tsv presenta una opinión distinta que un usuario deja en Wikipedia. La primera columna representa el sentimiento del texto (0 indica no tóxico, 1 indica tóxico) y la segunda columna representa el comentario que deja el usuario. Las columnas están separadas por tabulaciones. Los datos tienen un aspecto similar al siguiente:

Opinión	SentimentText
1	==RUDE== Dude, you are rude upload that carl picture back, or else. (Oye, vuelve a subir esa foto de Carl o te las verás conmigo).
1	== OK! == IM GOING TO VANDALIZE WILD ONES WIKI THEN!!! (BUENO, ENTONCES VOY A VANDALIZAR ALGUNAS WIKI).
0	I hope this helps. (Espero que esto ayude).

Elección de un escenario

Asistente para el generador de modelos en Visual Studio

Para entrenar el modelo, deberá seleccionarlo en la lista de escenarios de aprendizaje automático disponibles proporcionada por el Generador de modelos.

En el Explorador de soluciones, haga clic con el botón derecho en el proyecto SentimentRazor y seleccione Agregar > Modelo de Machine Learning.
En este ejemplo, el escenario es el análisis de sentimiento. En el paso Escenario de la herramienta Generador de modelos, seleccione el escenario Análisis de sentimiento.

Carga de los datos

El Generador de modelos acepta datos de dos orígenes, una base de datos de SQL Server o un archivo local en formato csv o tsv.

En el paso de datos de la herramienta Generador de modelos, seleccione Archivo en la lista desplegable origen de datos.
Seleccione el botón junto al cuadro de texto Seleccionar un archivo y use el Explorador de archivos para examinar y seleccionar el archivo wikipedia-detox-250-line-data.tsv.
Elija Sentimiento en el menú desplegable Column to Predict (Label) (Columna para la predicción [etiqueta]).
Deje los valores predeterminados del menú desplegable Input Columns (Features) (Columnas de entrada [características]).
Seleccione el vínculo Entrenar para ir al paso siguiente en la herramienta Generador de modelos.

Entrenar el modelo

La tarea de aprendizaje automático que se usa para entrenar el modelo de análisis de opinión en este tutorial es la clasificación binaria. Durante el proceso de entrenamiento de modelos, el Generador de modelos entrena modelos independientes con diferentes opciones y algoritmos de clasificación binaria para encontrar el modelo con mejor rendimiento para el conjunto de datos.

El tiempo necesario para el entrenamiento del modelo es proporcional a la cantidad de datos. El generador de modelos selecciona automáticamente un valor predeterminado para Tiempo de entrenamiento (segundos) en función del tamaño del origen de datos.

Aunque el Generador de modelos establezca el valor de Tiempo de entrenamiento (segundos) en 10 segundos, debe aumentarlo a 30 segundos. El entrenamiento durante un período de tiempo más prolongado permite que el Generador de modelos explore un mayor número de algoritmos y combinación de parámetros en la búsqueda del mejor modelo.
Seleccione Iniciar entrenamiento.

Durante el proceso de entrenamiento, los datos de progreso se muestran en la sección Progress del paso de entrenamiento.
- En Estado se muestra el grado de finalización del proceso de entrenamiento.
- En Mejor precisión se muestra la precisión del modelo con mejor rendimiento que ha encontrado el Generador de modelos hasta el momento. Una mayor precisión significa que el modelo realiza una predicción más correcta de los datos de prueba.
- En Mejor algoritmo se muestra el nombre del algoritmo con mejor rendimiento que ha encontrado el Generador de modelos hasta el momento.
- En Último algoritmo se muestra el nombre del algoritmo que ha usado más recientemente el Generador de modelos para entrenar el modelo.
Una vez que se complete el entrenamiento, seleccione el vínculo de evaluación para ir al paso siguiente.

Evaluar el modelo

El resultado del paso de entrenamiento será un modelo que tiene el mejor rendimiento. En el paso de evaluación de la herramienta Generador de modelos, la sección de salida contendrá el algoritmo que usa el modelo con el mejor rendimiento en la entrada Mejor modelo junto con las métricas de Modelo de mayor precisión. Además, se muestra una tabla de resumen que contiene los cinco mejores modelos y sus métricas.

Si no está satisfecho con las métricas de precisión, una forma sencilla de intentar mejorar la precisión del modelo es aumentar la cantidad de tiempo para entrenar el modelo o usar más datos. En caso contrario, seleccione el vínculo de código para ir al paso final de la herramienta Generador de modelos.

Incorporación del código para hacer predicciones

Se crearán dos proyectos como resultado del proceso de entrenamiento.

Referencia al modelo entrenado

En el paso de código de la herramienta Generador de modelos, seleccione Agregar proyectos para agregar los proyectos generados automáticamente a la solución.

Los proyectos siguientes deben aparecer en el Explorador de soluciones:
- SentimentRazorML.ConsoleApp: una aplicación de consola de .NET Core que contiene el entrenamiento del modelo y el código de predicción.
- SentimentRazorML.Model: Una biblioteca de clases .NET Standard que contienen los modelos de datos que definen el esquema de entrada y salida de los datos del modelo, así como la versión guardada del modelo con mejor rendimiento durante el entrenamiento.
En este tutorial, solo se usa el proyecto SentimentRazorML.Model, porque las predicciones se realizarán en la aplicación web SentimentRazor en lugar de hacerlo en la consola. Aunque SentimentRazorML.ConsoleApp no se usará para la puntuación, se puede usar para volver a entrenar el modelo con datos nuevos más adelante. No obstante, el reentrenamiento queda fuera del ámbito de este tutorial.

Configuración del grupo PredictionEngine

Para realizar una sola predicción, tendrá que crear un objeto PredictionEngine<TSrc,TDst>. PredictionEngine<TSrc,TDst> no es seguro para subprocesos. Además, tiene que crear una instancia en cualquier lugar en que se necesite dentro de la aplicación. A medida que crece la aplicación, este proceso puede volverse difícil de administrar. Para mejorar el rendimiento y la seguridad para subprocesos, use una combinación de inserción de dependencias y el servicio PredictionEnginePool, que crea un elemento ObjectPool<T> de objetos PredictionEngine<TSrc,TDst> para usarlo en toda la aplicación.

Instale el paquete Microsoft.Extensions.ML de NuGet:
1. En el Explorador de soluciones, haga clic con el botón derecho en el proyecto y seleccione Administrar paquetes NuGet.
2. Elija "nuget.org" como origen del paquete.
3. Seleccione la pestaña Examinar y busque Microsoft.Extensions.ML.
4. Seleccione el paquete en la lista y haga clic en el botón Instalar.
5. Haga clic en el botón Aceptar en el cuadro de diálogo Vista previa de los cambios.
6. Haga clic en el botón Acepto en el cuadro de diálogo Aceptación de la licencia si está de acuerdo con los términos de licencia de los paquetes que aparecen.
Abra el archivo Startup.cs en el proyecto SentimentRazor.
Agregue las instrucciones USING siguientes para hacer referencia al paquete de NuGet Microsoft.Extensions.ML y al proyecto SentimentRazorML.Model:
```
using System.IO;
using Microsoft.Extensions.ML;
using SentimentRazorML.Model;
```
Cree una variable global para almacenar la ubicación del archivo del modelo entrenado.
```
private readonly string _modelPath;
```

El archivo del modelo se almacena en el directorio de compilación junto con los archivos de ensamblado de la aplicación. Para facilitar el acceso, cree un método auxiliar llamado GetAbsolutePath después del método Configure.

public static string GetAbsolutePath(string relativePath)
{
    FileInfo _dataRoot = new FileInfo(typeof(Program).Assembly.Location);
    string assemblyFolderPath = _dataRoot.Directory.FullName;

    string fullPath = Path.Combine(assemblyFolderPath, relativePath);
    return fullPath;
}

Use el método GetAbsolutePath en el constructor de la clase Startup para establecer el _modelPath.
```
_modelPath = GetAbsolutePath("MLModel.zip");
```

Configure PredictionEnginePool para la aplicación en el método ConfigureServices:

services.AddPredictionEnginePool<ModelInput, ModelOutput>()
        .FromFile(_modelPath);

Creación de un controlador de análisis de sentimiento

Las predicciones se realizarán dentro de la página principal de la aplicación. Por tanto, se necesita un método que tome las entradas del usuario y use PredictionEnginePool para devolver una predicción.

Abra el archivo Index.cshtml.cs ubicado en el directorio Pages y agregue las instrucciones USING siguientes:
```
using Microsoft.Extensions.ML;
using SentimentRazorML.Model;
```
Para usar el PredictionEnginePool configurado en la clase Startup, debe insertarlo en el constructor del modelo donde quiere usarlo.
Agregue una variable para hacer referencia al PredictionEnginePool dentro de la clase IndexModel.
```
private readonly PredictionEnginePool<ModelInput, ModelOutput> _predictionEnginePool;
```

Cree un constructor en la clase IndexModel e inserte el servicio PredictionEnginePool en él.

public IndexModel(PredictionEnginePool<ModelInput, ModelOutput> predictionEnginePool)
{
    _predictionEnginePool = predictionEnginePool;
}

Cree un controlador de método que use PredictionEnginePool para hacer predicciones a partir de la información proporcionada por el usuario recibida desde la página web.
1. Debajo del método OnGet, cree un método nuevo denominado OnGetAnalyzeSentiment.
```
public IActionResult OnGetAnalyzeSentiment([FromQuery] string text)
{

}
```
2. Dentro del método OnGetAnalyzeSentiment, devuelva un sentimiento neutral si la información ingresada por el usuario es nula o está en blanco.
```
if (String.IsNullOrEmpty(text)) return Content("Neutral");
```
3. Dada una entrada válida, cree una instancia nueva de ModelInput.
```
var input = new ModelInput { SentimentText = text };
```
4. Use PredictionEnginePool para predecir el sentimiento.
```
var prediction = _predictionEnginePool.Predict(input);
```
5. Convierta el valor bool de predicción en Tóxico o No tóxico con el código siguiente.
```
var sentiment = Convert.ToBoolean(prediction.Prediction) ? "Toxic" : "Not Toxic";
```
6. Por último, devuelva el sentimiento a la página web.
```
return Content(sentiment);
```

Configuración de la página web

Los resultados que devuelve el OnGetAnalyzeSentiment se mostrarán de manera dinámica en la página web Index.

Abra el archivo Index.cshtml del directorio Pages y reemplace su contenido por el código siguiente:

@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
}

<div class="text-center">
    <h2>Live Sentiment</h2>

    <p><textarea id="Message" cols="45" placeholder="Type any text like a short review"></textarea></p>

    <div class="sentiment">
        <h4>Your sentiment is...</h4>
        <p>😡 😐 😍</p>

        <div class="marker">
            <div id="markerPosition" style="left: 45%;">
                <div>▲</div>
                <label id="markerValue">Neutral</label>
            </div>
        </div>
    </div>
</div>

A continuación, agregue el código de estilo CSS al final de la página site.css en el directorio wwwroot\css:

/* Style for sentiment display */

.sentiment {
    background-color: #eee;
    position: relative;
    display: inline-block;
    padding: 1rem;
    padding-bottom: 0;
    border-radius: 1rem;
}

.sentiment h4 {
    font-size: 16px;
    text-align: center;
    margin: 0;
    padding: 0;
}

.sentiment p {
    font-size: 50px;
}

.sentiment .marker {
    position: relative;
    left: 22px;
    width: calc(100% - 68px);
}

.sentiment .marker > div {
    transition: 0.3s ease-in-out;
    position: absolute;
    margin-left: -30px;
    text-align: center;
}

.sentiment .marker > div > div {
    font-size: 50px;
    line-height: 20px;
    color: green;
}

.sentiment .marker > div label {
    font-size: 30px;
    color: gray;
}

Después, agregue código para enviar entradas desde la página web al controlador OnGetAnalyzeSentiment.

En el archivo site.js que se encuentra en el directorio wwwroot\js, cree una función llamada getSentiment para realizar una solicitud HTTP GET con la entrada del usuario al controlador OnGetAnalyzeSentiment.
```
function getSentiment(userInput) {
    return fetch(`Index?handler=AnalyzeSentiment&text=${userInput}`)
        .then((response) => {
            return response.text();
        })
}
```
A continuación, agregue otra función llamada updateMarker para actualizar dinámicamente la posición del marcador en la página web cuando se predice el sentimiento.
```
function updateMarker(markerPosition, sentiment) {
    $("#markerPosition").attr("style", `left:${markerPosition}%`);
    $("#markerValue").text(sentiment);
}
```

Cree una función de controlador de eventos llamada updateSentiment para obtener la entrada del usuario, envíela a la función OnGetAnalyzeSentiment mediante la función getSentiment y actualice el marcador con la función updateMarker.

function updateSentiment() {

    var userInput = $("#Message").val();

    getSentiment(userInput)
        .then((sentiment) => {
            switch (sentiment) {
                case "Not Toxic":
                    updateMarker(100.0,sentiment);
                    break;
                case "Toxic":
                    updateMarker(0.0,sentiment);
                    break;
                default:
                    updateMarker(45.0, "Neutral");
            }
        });
}

Por último, registre el controlador de eventos y enlácelo al elemento textarea con el atributo id=Message.
```
$("#Message").on('change input paste', updateSentiment)
```

Ejecutar la aplicación

Ahora que la aplicación está configurada, ejecútela. Se debería iniciar en el explorador.

Cuando se inicie la aplicación, escriba ¡El Generador de modelos es genial! en el área de texto. El sentimiento de predicción que aparece debe ser Not Toxic (No tóxico).

Ventana en ejecución con la ventana de sentimiento de predicción

Si tiene que hacer referencia a los proyectos generados por el Generador de modelos más adelante en otra solución, puede encontrarlos en el directorio C:\Users\%USERNAME%\AppData\Local\Temp\MLVSTools.

Pasos siguientes

En este tutorial ha aprendido a:

Crear una aplicación Razor Pages de ASP.NET Core
Preparar y entender los datos
Elección de un escenario
Carga de los datos
Entrenar el modelo
Evaluar el modelo
Usar el modelo para las predicciones

Recursos adicionales

Para más información sobre los temas mencionados en este tutorial, visite estos recursos: