Analisar sentimentos com a CLI do ML.NET

Artigo
04/11/2023

Saiba como utilizar ML.NET CLI para gerar automaticamente um modelo de ML.NET e código C# subjacente. Fornece o conjunto de dados e a tarefa de machine learning que pretende implementar e a CLI utiliza o motor de AutoML para criar código fonte de geração e implementação de modelos, bem como o modelo de classificação.

Neste tutorial, irá seguir os seguintes passos:

Preparar os seus dados para a tarefa de machine learning selecionada
Execute o comando "classificação mlnet" a partir da CLI
Rever os resultados da métrica de qualidade
Compreender o código C# gerado para utilizar o modelo na sua aplicação
Explorar o código C# gerado que foi utilizado para preparar o modelo

Nota

Este tópico refere-se à ferramenta da CLI ML.NET, que está atualmente em Pré-visualização, e o material pode estar sujeito a alterações. Para obter mais informações, visite a página ML.NET .

A CLI ML.NET faz parte do ML.NET e o seu principal objetivo é "democratizar" ML.NET para programadores de .NET ao aprender ML.NET, pelo que não precisa de codificar do zero para começar.

Pode executar o ML.NET CLI em qualquer linha de comandos (Windows, Mac ou Linux) para gerar modelos de ML.NET de boa qualidade e código fonte com base nos conjuntos de dados de preparação que fornecer.

Pré-requisitos

SDK .NET Core 6 ou posterior
(Opcional) Visual Studio
ML.NET CLI

Pode executar os projetos de código C# gerados a partir do Visual Studio ou com dotnet run a CLI do (.NET).

Preparar os dados

Vamos utilizar um conjunto de dados existente utilizado para um cenário de "Análise de Sentimentos", que é uma tarefa de machine learning de classificação binária. Pode utilizar o seu próprio conjunto de dados de forma semelhante e o modelo e o código serão gerados automaticamente.

Transfira o ficheiro zip do conjunto de dados Do Sentimento de Sentimento UCI (veja citações na nota seguinte) e deszipe-o em qualquer pasta que escolher.

Nota

Os conjuntos de dados deste tutorial utilizam um conjunto de dados de "De Grupo a Etiquetas Individuais com Funcionalidades Profundas", Kotzias et al,. KDD 2015 e alojado no UCI Machine Learning Repository - Dua, D. e Karra Taniskidou, E. (2017). Repositório de Machine Learning da UCI [http://archive.ics.uci.edu/ml]. Irvine, AC: Universidade da Califórnia, Escola de Informação e Ciências da Computação.
Copie o yelp_labelled.txt ficheiro para qualquer pasta que tenha criado anteriormente (como /cli-test).

Abra a linha de comandos preferencial e mude para a pasta onde copiou o ficheiro do conjunto de dados. Por exemplo:

cd /cli-test

Com qualquer editor de texto, como o Visual Studio Code, pode abrir e explorar o ficheiro do yelp_labelled.txt conjunto de dados. Pode ver que a estrutura é:

O ficheiro não tem cabeçalho. Irá utilizar o índice da coluna.

Existem apenas duas colunas:

Texto (Índice de colunas 0)	Etiqueta (Índice de coluna 1)
Uau... Adorei este lugar.	1
A crosta não é boa.	0
Não saboroso e a textura era apenas desagradável.	0
... MUITAS MAIS LINHAS DE TEXTO...	... (1 ou 0)...

Certifique-se de que fecha o ficheiro do conjunto de dados a partir do editor.

Agora, está pronto para começar a utilizar a CLI para este cenário de "Análise de Sentimentos".

Nota

Depois de concluir este tutorial, também pode experimentar com os seus próprios conjuntos de dados, desde que estejam prontos para serem utilizados para qualquer uma das tarefas de ML atualmente suportadas pela Pré-visualização da CLI de ML.NET que são "Classificação Binária", "Classificação", "Regressão" e "Recomendação".

Executar o comando "classificação mlnet"

Execute o seguinte comando ML.NET CLI:
```
mlnet classification --dataset "yelp_labelled.txt" --label-col 1 --has-header false --train-time 10
```
Este comando executa o mlnet classification comando:
- para a tarefa ML de classificação
- utiliza o ficheiro do conjunto yelp_labelled.txtde dados como conjunto de dados de preparação e teste (internamente, a CLI irá utilizar a validação cruzada ou dividi-lo em dois conjuntos de dados, um para preparação e outro para teste)
- em que a coluna de objetivo/destino que pretende prever (normalmente denominada "etiqueta") é a coluna com o índice 1 (que é a segunda coluna, uma vez que o índice é baseado em zero)
- não utiliza um cabeçalho de ficheiro com nomes de coluna, uma vez que este ficheiro de conjunto de dados específico não tem um cabeçalho
- o tempo de exploração/comboio direcionado para a experimentação é de 10 segundos
Verá o resultado da CLI, semelhante a:

Neste caso específico, em apenas 10 segundos e com o pequeno conjunto de dados fornecido, a ferramenta CLI conseguiu executar bastantes iterações, o que significa que a preparação foi múltiplas vezes baseada em diferentes combinações de algoritmos/configuração com diferentes transformações de dados internas e hiperparâmetres do algoritmo.

Por fim, o modelo de "melhor qualidade" encontrado em 10 segundos é um modelo que utiliza um determinado formador/algoritmo com qualquer configuração específica. Dependendo do tempo de exploração, o comando pode produzir um resultado diferente. A seleção baseia-se nas múltiplas métricas apresentadas, como Accuracy.

Compreender as métricas de qualidade do modelo

A primeira e mais fácil métrica para avaliar um modelo de classificação binária é a precisão, que é simples de compreender. "A precisão é a proporção de predições corretas com um conjunto de dados de teste." Quanto mais perto dos 100% (1,00), melhor.

No entanto, existem casos em que apenas medir com a métrica Precisão não é suficiente, especialmente quando a etiqueta (0 e 1 neste caso) está desequilibrada no conjunto de dados de teste.

Para obter métricas adicionais e informações mais detalhadas sobre as métricas como Precisão, AUC, AUCPR e classificação F1 utilizadas para avaliar os diferentes modelos, veja Compreender as métricas ML.NET.

Nota

Pode experimentar este mesmo conjunto de dados e especificar alguns minutos para (por exemplo, três minutos, --max-exploration-time por isso, especifique 180 segundos), o que irá encontrar um melhor "melhor modelo" para si com uma configuração de pipeline de preparação diferente para este conjunto de dados (que é bastante pequeno, 1000 linhas).

Para encontrar um modelo de "melhor/boa qualidade" que seja um "modelo pronto para produção" destinado a conjuntos de dados maiores, deve fazer experimentações com a CLI, normalmente especificando muito mais tempo de exploração, dependendo do tamanho do conjunto de dados. Na verdade, em muitos casos, pode exigir várias horas de tempo de exploração, especialmente se o conjunto de dados for grande em linhas e colunas.
A execução de comandos anterior gerou os seguintes recursos:
- Um modelo serializado .zip ("melhor modelo") pronto a utilizar.
- Código C# para executar/classificar o modelo gerado (para fazer predições nas suas aplicações de utilizador final com esse modelo).
- Código de preparação C# utilizado para gerar esse modelo (Objetivos de aprendizagem).
- Um ficheiro de registo com todas as iterações exploradas com informações detalhadas específicas sobre cada algoritmo tentado com a combinação de hyper-parâmetros e transformações de dados.
Os dois primeiros recursos (.ZIP modelo de ficheiro e código C# para executar esse modelo) podem ser utilizados diretamente nas suas aplicações de utilizador final (ASP.NET Core aplicação Web, serviços, aplicação de ambiente de trabalho, etc.) para fazer predições com esse modelo de ML gerado.

O terceiro recurso, o código de preparação, mostra-lhe que ML.NET código da API foi utilizado pela CLI para preparar o modelo gerado, para que possa investigar que formador/algoritmo específico e hiperparâmetres foram selecionados pela CLI.

Esses recursos enumerados são explicados nos seguintes passos do tutorial.

Explorar o código C# gerado a utilizar para executar o modelo para fazer predições

No Visual Studio, abra a solução gerada na pasta com o nome SampleClassification na pasta de destino original (foi nomeada /cli-test no tutorial). Deverá ver uma solução semelhante a:

Nota

No tutorial, sugerimos que utilize o Visual Studio, mas também pode explorar o código C# gerado (dois projetos) com qualquer editor de texto e executar a aplicação de consola gerada com o dotnet CLI num computador macOS, Linux ou Windows.
- A aplicação de consola gerada contém o código de execução que tem de rever e, em seguida, normalmente reutiliza o "código de classificação" (código que executa o modelo de ML para fazer predições) ao mover esse código simples (apenas algumas linhas) para a sua aplicação de utilizador final onde pretende fazer as predições.
- O ficheiro mbconfig gerado é um ficheiro de configuração que pode ser utilizado para preparar novamente o modelo, seja através da CLI ou através do Model Builder. Isto também terá dois ficheiros de código associados ao mesmo e um ficheiro zip.
  - O ficheiro de preparação contém o código para criar o pipeline de modelo com a API ML.NET.
  - O ficheiro de consumo contém o código para consumir o modelo.
  - O ficheiro zip que é o modelo gerado da CLI.
Abra o ficheiro SampleClassification.consumption.cs no ficheiro mbconfig . Verá que existem classes de entrada e saída. Trata-se de classes de dados, ou classes POCO, utilizadas para armazenar dados. As classes contêm código automático que é útil se o conjunto de dados tiver dezenas ou até centenas de colunas.
- A ModelInput classe é utilizada ao ler dados do conjunto de dados.
- A ModelOutput classe é utilizada para obter o resultado de predição (dados de predição).

Abra o ficheiro Program.cs e explore o código. Em apenas algumas linhas, pode executar o modelo e fazer uma predição de exemplo.

static void Main(string[] args)
{
    // Create single instance of sample data from first line of dataset for model input
    ModelInput sampleData = new ModelInput()
    {
        Col0 = @"Wow... Loved this place.",
    };

    // Make a single prediction on the sample data and print results
    var predictionResult = SampleClassification.Predict(sampleData);

    Console.WriteLine("Using model to make single prediction -- Comparing actual Col1 with predicted Col1 from sample data...\n\n");
    Console.WriteLine($"Col0: {sampleData.Col0}");
    Console.WriteLine($"\n\nPredicted Col1 value {predictionResult.PredictedLabel} \nPredicted Col1 scores: [{String.Join(",", predictionResult.Score)}]\n\n");
    Console.WriteLine("=============== End of process, hit any key to finish ===============");
    Console.ReadKey();
}

As primeiras linhas de código criam um único exemplo de dados, neste caso, com base na primeira linha do conjunto de dados a utilizar para a predição. Também pode criar os seus próprios dados "hard-coded" ao atualizar o código:
```
ModelInput sampleData = new ModelInput()
{
    Col0 = "The ML.NET CLI is great for getting started. Very cool!"
};
```
A linha de código seguinte utiliza o SampleClassification.Predict() método nos dados de entrada especificados para fazer uma predição e devolver os resultados (com base no esquema ModelOutput.cs).
As últimas linhas de código imprime as propriedades dos dados de exemplo (neste caso, o Comentário), bem como a predição de Sentimentos e as Pontuações correspondentes para sentimento positivo (1) e sentimento negativo (2).

Execute o projeto, utilizando os dados de exemplo originais carregados a partir da primeira linha do conjunto de dados ou fornecendo os seus próprios dados de exemplo hard-coded personalizados. Deverá obter uma predição comparável a:

ML.NET CLI executar a aplicação a partir do Visual Studio )

Experimente alterar os dados de exemplo codificados para outras frases com sentimentos diferentes e veja como o modelo prevê sentimentos positivos ou negativos.

Infundir as suas aplicações de utilizador final com predições de modelos de ML

Pode utilizar um "código de classificação de modelo ML" semelhante para executar o modelo na sua aplicação de utilizador final e fazer predições.

Por exemplo, pode mover diretamente esse código para qualquer aplicação de ambiente de trabalho do Windows, como WPF e WinForms , e executar o modelo da mesma forma que foi feito na aplicação de consola.

No entanto, a forma como implementa essas linhas de código para executar um modelo ML deve ser otimizada (ou seja, colocar em cache o modelo .zip ficheiro e carregá-lo uma vez) e ter objetos singleton em vez de os criar em todos os pedidos, especialmente se a sua aplicação precisar de ser dimensionável, como uma aplicação Web ou um serviço distribuído, conforme explicado na secção seguinte.

Executar modelos ML.NET em serviços e aplicações Web dimensionáveis ASP.NET Core (aplicações com vários threads)

A criação do objeto de modelo (ITransformer carregado a partir do ficheiro de .zip de um modelo) e o PredictionEngine objeto devem ser otimizados especialmente quando é executado em aplicações Web dimensionáveis e serviços distribuídos. No primeiro caso, o objeto de modelo (ITransformer) a otimização é simples. Uma vez que o ITransformer objeto é seguro para threads, pode colocar o objeto em cache como um objeto singleton ou estático para carregar o modelo uma vez.

Para o segundo objeto, o PredictionEngine objeto, não é tão fácil porque o PredictionEngine objeto não é seguro para threads, pelo que não pode instanciar este objeto como um objeto singleton ou estático numa aplicação ASP.NET Core. Este problema de escalabilidade e segurança de threads é profundamente abordado nesta Publicação de Blogue.

No entanto, as coisas ficaram muito mais fáceis para si do que as explicadas nessa publicação de blogue. Trabalhámos numa abordagem mais simples para si e criámos um bom "Pacote de Integração.NET Core" que pode utilizar facilmente no seu ASP.NET Core aplicações e serviços ao registá-lo nos serviços de DI da aplicação (serviços de Injeção de Dependência) e, em seguida, utilizá-lo diretamente a partir do seu código. Veja o tutorial e o exemplo seguintes para o fazer:

Explorar o código C# gerado que foi utilizado para preparar o modelo de "melhor qualidade"

Para fins de aprendizagem mais avançados, também pode explorar o código C# gerado que foi utilizado pela ferramenta da CLI para preparar o modelo gerado.

Esse código de modelo de preparação é gerado no ficheiro com o nome SampleClassification.training.cs, para que possa investigar esse código de preparação.

Mais importante ainda, para este cenário específico (modelo de Análise de Sentimentos), também pode comparar o código de preparação gerado com o código explicado no seguinte tutorial:

Comparar: Tutorial: utilize ML.NET num cenário de classificação binária de análise de sentimentos.

É interessante comparar o algoritmo escolhido e a configuração do pipeline no tutorial com o código gerado pela ferramenta CLI. Consoante o tempo que passa a iterar e a procurar modelos melhores, o algoritmo escolhido pode ser diferente juntamente com os seus hipermetrizadores específicos e a configuração do pipeline.

Neste tutorial, ficou a saber como:

Preparar os seus dados para a tarefa de ML selecionada (problema a resolver)
Execute o comando "classificação mlnet" na ferramenta da CLI
Rever os resultados da métrica de qualidade
Compreender o código C# gerado para executar o modelo (Código a utilizar na sua aplicação de utilizador final)
Explore o código C# gerado que foi utilizado para preparar o modelo de "melhor qualidade" (fins de ganhos)