Tutorial: Analisar o sentimento dos comentários do site numa aplicação Web com o ML.NET Model Builder

Artigo
04/11/2023

Saiba como analisar sentimentos de comentários em tempo real dentro de uma aplicação Web.

Este tutorial mostra-lhe como criar uma aplicação ASP.NET Core Razor Pages que classifica o sentimento dos comentários do site em tempo real.

Neste tutorial, ficará a saber como:

Criar uma aplicação ASP.NET Core Razor Pages
Preparar e compreender os dados
Escolher um cenário
Carregar os dados
Preparar o modelo
Avaliar o modelo
Utilizar o modelo para predições

Pode encontrar o código fonte deste tutorial no repositório dotnet/machinelearning-samples .

Pré-requisitos

Para obter uma lista de pré-requisitos e instruções de instalação, visite o Guia de instalação do Model Builder.

Criar uma aplicação do Razor Pages

Crie uma aplicação ASP.NET Core Razor Pages.

No Visual Studio, abra a caixa de diálogo Criar um novo projeto .
Na caixa de diálogo "Criar um novo projeto", selecione o modelo de projeto ASP.NET Core Web App.
Na caixa de texto Nome , escreva "SentimentRazor" e selecione o botão Seguinte .
Na caixa de diálogo Informações adicionais, deixe todas as predefinições tal como estão e selecione o botão Criar .

Preparar e compreender os dados

Transfira o conjunto de dados de desintoxicação da Wikipédia. Quando a página Web abrir, clique com o botão direito do rato na página, selecione Guardar Como e guarde o ficheiro em qualquer parte do computador.

Cada linha no conjunto de dados wikipedia-desintoxicação-250-line-data.tsv representa uma crítica diferente deixada por um utilizador na Wikipédia. A primeira coluna representa o sentimento do texto (0 não é tóxico, 1 é tóxico) e a segunda coluna representa o comentário deixado pelo utilizador. As colunas são separadas por separadores. Os dados têm o seguinte aspeto:

Sentimento	SentimentText
1	==RUDE== Cara, você é rude carregar aquela imagem carl de volta, ou então.
1	== OK! == IM GO TO VANDALIZE WILD ONES WIKI THEN!!!
0	Espero que isto ajude.

Criar um ficheiro de configuração do Model Builder

Quando adicionar pela primeira vez um modelo de machine learning à solução, irá pedir-lhe para criar um mbconfig ficheiro. O mbconfig ficheiro controla tudo o que faz no Model Builder para permitir que reabra a sessão.

No Explorador de Soluções, clique com o botão direito do rato no projeto SentimentRazor e selecione Adicionar>Modelo de Machine Learning....
Na caixa de diálogo, atribua o nome SentimentAnalysis.mbconfig ao projeto do Model Builder e selecione Adicionar.

Escolher um cenário

Para preparar o modelo, tem de selecionar a partir da lista de cenários de machine learning disponíveis fornecidos pelo Model Builder.

Para este exemplo, a tarefa é a classificação de textos. No passo Cenário da extensão do Model Builder, selecione o cenário de classificação de textos .

Selecionar um ambiente

O Model Builder pode preparar ambientes diferentes consoante o cenário selecionado.

Selecione Local (GPU) como ambiente e clique no botão Passo seguinte .

Nota

Este cenário utiliza técnicas de aprendizagem profunda que funcionam melhor em ambientes de GPU. Se não tiver uma GPU, selecione o ambiente Local (CPU), mas tenha em atenção que o tempo esperado para preparar será significativamente mais longo. Para obter mais informações sobre como utilizar GPUs com o Model Builder, veja o guia suporte de GPU no Model Builder.

Carregar os dados

O Model Builder aceita dados de duas origens, uma base de dados SQL Server ou um ficheiro local no formato ou tsv no csv formato.

No passo de dados da ferramenta Model Builder, selecione Ficheiro nas opções da origem de dados.
Selecione o botão junto à caixa de texto Selecionar um ficheiro e utilize Explorador de Ficheiros para procurar e selecionar o ficheiro wikipedia-desintoxica-250-line-data.tsv.
Selecione Sentimento na lista pendente Coluna para prever (Etiqueta).
Selecione SentimentText na lista pendente Coluna de Texto.
Selecione o botão Passo seguinte para avançar para o passo seguinte no Construtor de Modelos.

Preparar o modelo

A tarefa de machine learning utilizada para preparar o modelo de análise de sentimentos neste tutorial é a classificação de textos. Durante o processo de preparação de modelos, o Model Builder prepara um modelo de classificação de textos para o seu conjunto de dados com a arquitetura de rede neural NAS-BERT .

Selecione Iniciar Formação.
Quando a preparação estiver concluída, os resultados do processo de preparação são apresentados na secção Resultados da preparação do ecrã Preparar . Além de fornecer resultados de preparação, são criados três ficheiros protegidos por código no ficheiro SentimentAnalysis.mbconfig .
- SentimentAnalysis.consumption.cs – este ficheiro contém os ModelInput esquemas e ModelOutput , bem como a Predict função gerada para consumir o modelo.
- SentimentAnalysis.training.cs - Este ficheiro contém o pipeline de preparação (transformações de dados, formador, hiperparâmetros do formador) escolhido pelo Model Builder para preparar o modelo. Pode utilizar este pipeline para voltar a preparar o modelo.
- *SentimentAnalysis.zip – este é um ficheiro zip serializado que representa o modelo de ML.NET preparado.
Selecione o botão Passo seguinte para avançar para o passo seguinte.

Avaliar o modelo

O resultado do passo de preparação será um modelo que tem o melhor desempenho. No passo de avaliação da ferramenta Model Builder, a secção de saída irá conter o formador utilizado pelo modelo com melhor desempenho nas métricas de avaliação, bem como as métricas de avaliação.

Se não estiver satisfeito com as métricas de avaliação, algumas formas fáceis de tentar melhorar o desempenho do modelo são utilizar mais dados.

Caso contrário, selecione o botão Passo seguinte para ir para o passo Consumir no Construtor de Modelos.

Adicionar modelos de projeto de consumo (Opcional)

No passo Consumir , o Model Builder fornece modelos de projeto que pode utilizar para consumir o modelo. Este passo é opcional e pode escolher o método que melhor se adequa às suas necessidades para utilizar o modelo.

Aplicação de consola
API Web

Adicionar o código para fazer predições

Configurar o conjunto PredictionEngine

Para fazer uma única predição, tem de criar um PredictionEngine<TSrc,TDst>. PredictionEngine<TSrc,TDst> não é seguro para threads. Além disso, tem de criar uma instância da mesma onde quer que seja necessária na sua aplicação. À medida que a sua aplicação cresce, este processo pode tornar-se incontrolável. Para melhorar o desempenho e a segurança dos threads, utilize uma combinação de injeção de dependências e o PredictionEnginePool serviço, que cria um ObjectPool<T> dos PredictionEngine<TSrc,TDst> objetos para utilização em toda a aplicação.

Instale o pacote NuGet Microsoft.Extensions.ML :
1. No Explorador de Soluções, clique com o botão direito do rato no projeto e selecione Gerir Pacotes NuGet.
2. Selecione "nuget.org" como origem do pacote.
3. Selecione o separador Procurar e procure Microsoft.Extensions.ML.
4. Selecione o pacote na lista e selecione o botão Instalar.
5. Selecione o botão OK na caixa de diálogo Pré-visualizar Alterações
6. Selecione o botão Aceito na caixa de diálogo Aceitação da Licença se concordar com os termos de licenciamento dos pacotes listados.
Abra o ficheiro Program.cs no projeto SentimentRazor .
Adicione as seguintes instruções using para referenciar o pacote NuGet Microsoft.Extensions.ML e o projeto SentimentRazorML.Model :
```
using Microsoft.Extensions.ML;
using static SentimentRazor.SentimentAnalysis;
```

Configure o para a sua aplicação PredictionEnginePool<TData,TPrediction> no ficheiro Program.cs :

builder.Services.AddPredictionEnginePool<ModelInput, ModelOutput>()
    .FromFile("SentimentAnalysis.zip");

Criar processador de análise de sentimentos

As predições serão feitas dentro da página principal da aplicação. Por conseguinte, um método que utiliza a entrada do utilizador e utiliza o PredictionEnginePool<TData,TPrediction> para devolver uma predição tem de ser adicionado.

Abra o ficheiro Index.cshtml.cs localizado no diretório Páginas e adicione o seguinte com instruções:
```
using Microsoft.Extensions.ML;
using static SentimentRazor.SentimentAnalysis;
```
Para utilizar o PredictionEnginePool<TData,TPrediction> configurado no ficheiro Program.cs , tem de injetá-lo no construtor do modelo onde pretende utilizá-lo.
Adicione uma variável para referenciar o PredictionEnginePool<TData,TPrediction> interior da IndexModel classe no ficheiro Pages/Index.cshtml.cs .
```
private readonly PredictionEnginePool<ModelInput, ModelOutput> _predictionEnginePool;
```

Modifique o construtor na IndexModel classe e injete-o PredictionEnginePool<TData,TPrediction> no mesmo.

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

Crie um processador de métodos que utilize o PredictionEnginePool para efetuar predições a partir de entradas de utilizador recebidas da página Web.
1. Abaixo do OnGet método, crie um novo método chamado OnGetAnalyzeSentiment
```
public IActionResult OnGetAnalyzeSentiment([FromQuery] string text)
{

}
```
2. Dentro do OnGetAnalyzeSentiment método, devolva sentimento neutro se a entrada do utilizador estiver em branco ou nula.
```
if (String.IsNullOrEmpty(text)) return Content("Neutral");
```
3. Dada uma entrada válida, crie uma nova instância de ModelInput.
```
var input = new ModelInput { SentimentText = text };
```
4. Utilize o para prever o PredictionEnginePool<TData,TPrediction> sentimento.
```
var prediction = _predictionEnginePool.Predict(input);
```
5. Converta o valor previsto bool em tóxico ou não tóxico com o seguinte código.
```
var sentiment = Convert.ToBoolean(prediction.PredictedLabel) ? "Toxic" : "Not Toxic";
```
6. Por fim, volte a devolver o sentimento à página Web.
```
return Content(sentiment);
```

Configurar a página Web

Os resultados devolvidos pelo OnGetAnalyzeSentiment serão apresentados dinamicamente na Index página Web.

Abra o ficheiro Index.cshtml no diretório Páginas e substitua o respetivo conteúdo pelo seguinte código:

@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>

Em seguida, adicione o código de estilo css ao final da página site.css no diretório 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;
}

Depois disso, adicione código para enviar entradas da página Web para o OnGetAnalyzeSentiment processador.

No ficheiro site.js localizado no diretório wwwroot\js , crie uma função chamada getSentiment para fazer um pedido GET HTTP com a entrada do utilizador para o OnGetAnalyzeSentiment processador.
```
function getSentiment(userInput) {
    return fetch(`Index?handler=AnalyzeSentiment&text=${userInput}`)
        .then((response) => {
            return response.text();
        })
}
```

Abaixo, adicione outra função chamada updateMarker para atualizar dinamicamente a posição do marcador na página Web à medida que o sentimento é previsto.

function updateMarker(markerPosition, sentiment) {
    $("#markerPosition").attr("style", `left:${markerPosition}%`);
    $("#markerValue").text(sentiment);
}

Crie uma função de processador de eventos chamada updateSentiment para obter a entrada do utilizador, enviá-la para a OnGetAnalyzeSentiment função com a getSentiment função e atualizar o marcador com a updateMarker função.

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 fim, registe o processador de eventos e vinculte-o ao textarea elemento com o id=Message atributo .
```
$("#Message").on('change input paste', updateSentiment)        
```

Executar a aplicação

Agora que a sua aplicação está configurada, execute a aplicação, que deverá ser iniciada no browser.

Quando a aplicação for iniciada, introduza Este modelo não tem dados suficientes! na área de texto. O sentimento previsto apresentado deve ser tóxico.

Janela em execução com a janela de sentimento previsto