Partilhar via

Tutorial: Analisar o sentimento dos comentários do site em um aplicativo Web usando o ML.NET Construtor de Modelos

  • Artigo

Saiba como analisar o sentimento dos comentários em tempo real dentro de uma aplicação web.

Este tutorial mostra como criar um aplicativo ASP.NET Core Razor Pages que classifica o sentimento dos comentários do site em tempo real.

Neste tutorial, você aprenderá a:

  • Criar um aplicativo ASP.NET Core Razor Pages
  • Preparar e compreender os dados
  • Escolha um cenário
  • Carregue os dados
  • Treinar o modelo
  • Avaliar o modelo
  • Use o modelo para previsões

Você 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 um aplicativo Razor Pages

Crie um aplicativo ASP.NET Core Razor Pages.

  1. No Visual Studio, abra a caixa de diálogo Criar um novo projeto.
  2. Na caixa de diálogo "Criar um novo projeto", selecione o modelo de projeto ASP.NET Core Web App.
  3. Na caixa de texto Nome , digite "SentimentRazor" e selecione Avançar.
  4. Na caixa de diálogo Informações adicionais, deixe todos os valores predefinidos como estão e selecione Criar.

Preparar e compreender os dados

Download conjunto de dados de desintoxicação da Wikipédia. Quando a página da Web abrir, clique com o botão direito do mouse na página, selecione Salvar como e salve o arquivo em qualquer lugar do seu computador.

Cada linha no conjunto de dados wikipedia-detox-250-line-data.tsv representa uma revisão diferente deixada por um usuário 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 usuário. As colunas são separadas por tabulações. Os dados têm a seguinte aparência:

Sentimento SentimentText
1 Cara, tu és rude, carrega aquela foto do Carl de volta, ou então vai ver.
1 == Está bem! == VOU VANDALIZAR A WILD ONES WIKI ENTÃO!!!
0 Espero ter ajudado.

Criar um arquivo de configuração do Construtor de Modelos

Ao adicionar pela primeira vez um modelo de aprendizado de máquina à solução, ele solicitará que você crie um arquivo mbconfig. O arquivo mbconfig controla tudo o que você faz no Construtor de Modelos para permitir que você reabra a sessão.

  1. No Gerenciador de Soluções , clique com o botão direito do mouse no projeto SentimentRazor e selecione Adicionar >Modelo de Aprendizado de Máquina.
  2. Na caixa de diálogo, nomeie o projeto do Construtor de Modelos SentimentAnalysis.mbconfige selecione Adicionar.

Escolha um cenário

Ecrã do Cenário do Construtor de Modelos

Para treinar seu modelo, você precisa selecionar na lista de cenários de aprendizado de máquina disponíveis fornecidos pelo Construtor de Modelos.

Para este exemplo, a tarefa é a classificação de texto. Na etapa do cenário da extensão do Construtor de Modelos, selecione o cenário de Classificação de Texto .

Selecione um ambiente

O Construtor de Modelos pode treinar em diferentes ambientes, dependendo do cenário selecionado.

Selecione o ambiente Local (GPU) e clique no botão próxima etapa.

Observação

Este cenário utiliza técnicas de aprendizagem profunda que funcionam melhor em ambientes GPU. Se você não tiver uma GPU, escolha o ambiente Local (CPU), mas observe que o tempo esperado para treinar será significativamente maior. Para obter mais informações sobre como usar GPUs com o Model Builder, consulte o guia sobre suporte a GPUs no Model Builder.

Carregue os dados

O Construtor de Modelos aceita dados de duas fontes, um banco de dados do SQL Server ou um arquivo local no formato csv ou tsv.

  1. Na etapa de dados da ferramenta Construtor de Modelos, selecione o Arquivo nas opções da fonte de dados.
  2. Selecione o botão ao lado da caixa de texto Selecione um arquivo e use o Explorador de Arquivos para navegar e selecionar o arquivo wikipedia-detox-250-line-data.tsv .
  3. Escolha Sentimento da Coluna no menu suspenso para prever (Rótulo).
  4. Escolha SentimentText na lista suspensa Coluna de Texto.
  5. Selecione o botão próxima etapa para passar para a próxima etapa no Construtor de modelos.

Treinar o modelo

A tarefa de aprendizado de máquina usada para treinar o modelo de análise de sentimento neste tutorial é a classificação de texto. Durante o processo de treinamento do modelo, o Construtor de Modelos treina um modelo de classificação de texto para seu conjunto de dados usando a arquitetura de rede neural NAS-BERT .

  1. Selecione Iniciar Treino.

  2. Quando o treinamento é concluído, os resultados do processo de treinamento são exibidos na seção Resultados do treinamento da tela Train. Além de fornecer resultados de treinamento, três arquivos code-behind são criados sob o arquivo SentimentAnalysis.mbconfig.

    • SentimentAnalysis.consumption.cs - Este arquivo contém os esquemas ModelInput e ModelOutput, bem como a função Predict gerada para consumir o modelo.
    • SentimentAnalysis.training.cs - Este ficheiro contém o pipeline de treino (transformações de dados, treinador, hiperparâmetros do treinador) escolhido pelo Model Builder para treinar o modelo. Você pode usar esse pipeline para treinar novamente seu modelo.
    • * SentimentAnalysis.zip - Este é um arquivo zip serializado que representa seu modelo de ML.NET treinado.

  3. Selecione o botão Próxima etapa para passar para a próxima etapa.

Avaliar o modelo

O resultado da etapa de treinamento será um modelo que tenha o melhor desempenho. Na etapa de avaliação da ferramenta Construtor de Modelos, a seção de saída conterá o instrutor usado pelo modelo com melhor desempenho nas métricas de avaliação.

Se você não estiver satisfeito com suas métricas de avaliação, algumas maneiras fáceis de tentar melhorar o desempenho do modelo são usar mais dados.

Caso contrário, selecione o botão Próxima etapa para avançar para a etapa Consumir no Model Builder.

Adicionar modelos de projeto de consumo (Opcional)

Na etapa Consume, o Model Builder fornece modelos de projeto que pode utilizar para utilizar o modelo. Esta etapa é opcional e você pode escolher o método que melhor se adapta às suas necessidades para usar o modelo.

  • Aplicação de consola
  • Web API

Adicione o código para fazer previsões

Configurar o pool PredictionEngine

Para fazer uma única previsão, é necessário criar um PredictionEngine<TSrc,TDst>. PredictionEngine<TSrc,TDst> não é thread-safe. Além disso, você precisa criar uma instância dele em todos os lugares em que for necessário em seu aplicativo. À medida que seu aplicativo cresce, esse processo pode se tornar incontrolável. Para melhorar o desempenho e a segurança de threads, use uma combinação de injeção de dependência e o serviço PredictionEnginePool, que cria uma ObjectPool<T> de objetos PredictionEngine<TSrc,TDst> para uso em todo o aplicativo.

  1. Instale o Microsoft.Extensions.ML pacote NuGet:

    1. No Gerenciador de Soluções , clique com o botão direito do mouse no projeto e selecione Gerenciar pacotes NuGet.
    2. Escolha "nuget.org" como a fonte do pacote.
    3. Selecione o separador Explorar e procure Microsoft.Extensions.ML.
    4. Selecione o pacote na lista e selecione Instalar.
    5. Selecione o botão OK na caixa de diálogo Preview Changes
    6. Selecione o botão Aceito na caixa de diálogo de Aceitação de Licença se concordar com os termos de licença para os pacotes listados.

  2. Abra o arquivo Program.cs no projeto SentimentRazor.

  3. Adicione as seguintes diretivas using para fazer referência ao pacote NuGet Microsoft.Extensions.ML e ao projeto SentimentRazorML.Model:

    using Microsoft.Extensions.ML;
using static SentimentRazor.SentimentAnalysis;

  4. Configure o PredictionEnginePool<TData,TPrediction> para seu aplicativo no arquivo Program.cs:

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

Criar manipulador de análise de sentimento

As previsões serão feitas dentro da página principal do aplicativo. Portanto, um método que usa a entrada do usuário e usa o PredictionEnginePool<TData,TPrediction> para retornar uma previsão precisa ser adicionado.

  1. Abra o ficheiro Index.cshtml.cs localizado no diretório Pages e adicione as seguintes diretivas using:

    using Microsoft.Extensions.ML;
using static SentimentRazor.SentimentAnalysis;

    Para usar o PredictionEnginePool<TData,TPrediction> configurado no arquivo Program.cs, você tem que injetá-lo no construtor do modelo onde você deseja usá-lo.

  2. Adicione uma variável para fazer referência ao PredictionEnginePool<TData,TPrediction> dentro da classe IndexModel dentro do arquivo Pages/Index.cshtml.cs.

    private readonly PredictionEnginePool<ModelInput, ModelOutput> _predictionEnginePool;

  3. Modifique o construtor na classe IndexModel e injete o serviço PredictionEnginePool<TData,TPrediction> nele.

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

  4. Crie um manipulador de método que use o PredictionEnginePool para fazer previsões a partir da entrada do usuário recebida da página da Web.

    1. Abaixo do método OnGet, crie um novo método chamado OnGetAnalyzeSentiment

      public IActionResult OnGetAnalyzeSentiment([FromQuery] string text)
{

}

    2. Dentro do método OnGetAnalyzeSentiment, retorne sentimento de neutro se a entrada do usuário 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. Use o PredictionEnginePool<TData,TPrediction> para prever o sentimento.

      var prediction = _predictionEnginePool.Predict(input);

    5. Converta o valor de bool previsto em tóxico ou não tóxico com o código a seguir.

      var sentiment = Convert.ToBoolean(prediction.PredictedLabel) ? "Toxic" : "Not Toxic";

    6. Finalmente, devolva o sentimento de volta à página da Web.

      return Content(sentiment);

Configurar a página Web

Os resultados retornados pelo OnGetAnalyzeSentiment serão exibidos dinamicamente na página da Web Index.

  1. Abra o arquivo Index.cshtml no diretório Pages e substitua seu 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>

  2. 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;
}

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

    1. No arquivo site.js localizado no diretório wwwroot\js , crie uma função chamada para fazer uma solicitação HTTP GET com a entrada do usuário para o manipulador .

      function getSentiment(userInput) {
    return fetch(`Index?handler=AnalyzeSentiment&text=${userInput}`)
        .then((response) => {
            return response.text();
        })
}

    2. Abaixo disso, adicione outra função chamada updateMarker para atualizar dinamicamente a posição do marcador na página da Web conforme o sentimento é previsto.

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

    3. Crie uma função de manipulador de eventos chamada updateSentiment para obter a entrada do usuário, envie-a para a função OnGetAnalyzeSentiment usando a função getSentiment e atualize o marcador com a função 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");
            }
        });
}

    4. Finalmente, registre o manipulador de eventos e vincule-o ao elemento textarea com o atributo id=Message.

      $("#Message").on('change input paste', updateSentiment)

Execute o aplicativo

Agora que seu aplicativo está configurado, execute o aplicativo, que deve ser iniciado em seu navegador.

Quando o aplicativo for iniciado, digite Este modelo não tem dados suficientes! para a área de texto. O sentimento previsto exibido deve ser Toxic.

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

Observação

PredictionEnginePool<TData,TPrediction> cria várias instâncias de PredictionEngine<TSrc,TDst>. Devido ao tamanho do modelo, a primeira vez que você usá-lo para fazer uma previsão, pode levar alguns segundos. As previsões subsequentes devem ser instantâneas.

Próximos passos

Neste tutorial, você aprendeu como:

  • Criar um aplicativo ASP.NET Core Razor Pages
  • Preparar e compreender os dados
  • Escolha um cenário
  • Carregue os dados
  • Treinar o modelo
  • Avaliar o modelo
  • Use o modelo para previsões

Recursos adicionais

Para saber mais sobre os tópicos mencionados neste tutorial, visite os seguintes recursos: