Tutorial: Categorizar problemas de suporte usando a classificação multiclasse com ML.NET

Este tutorial de exemplo ilustra o uso de ML.NET para criar um classificador de problemas do GitHub para treinar um modelo que classifica e prevê o rótulo área para um problema do GitHub por meio de um aplicativo de console .NET usando C# no Visual Studio.

Neste tutorial, você aprenderá como:

Você pode encontrar o código-fonte deste tutorial no repositório dotnet/samples .

Pré-requisitos

• Visual Studio 2022 ou posterior com a carga de trabalho "Desenvolvimento da Área de Trabalho do .NET" instalada.
• O GitHub emite um arquivo separado por guia de treinamento (issues_train.tsv).
• O GitHub emite um arquivo separado por guia de teste (issues_test.tsv).

Criar um aplicativo de console

Criar um projeto

1. Crie um aplicativo de console C# chamado "GitHubIssueClassification". Selecione Próximo.

2. Escolha o .NET 7 como a estrutura a ser usada. Selecione Criar.

3. Crie um diretório chamado Dados em seu projeto para salvar os arquivos do conjunto de dados:

   No Gerenciador de Soluções, clique com o botão direito do mouse em seu projeto e selecione Adicionar>Nova Pasta. Digite "Dados" e pressione Enter.

4. Crie um diretório chamado Modelos em seu projeto para salvar seu modelo:

   No Gerenciador de Soluções, clique com o botão direito do mouse em seu projeto e selecione Adicionar>Nova Pasta. Digite "Modelos" e pressione Enter.

5. Instale o Microsoft.ML Pacote NuGet:

   Observação

   Este exemplo usa a versão estável mais recente dos pacotes NuGet mencionados, a menos que indicado de outra forma.

   No Gerenciador de Soluções, clique com o botão direito do mouse em seu projeto e selecione Gerenciar Pacotes NuGet. Escolha "nuget.org" como a origem do pacote, selecione a guia Procurar, pesquise Microsoft.ML e selecione Instalar. Selecione o botão OK na caixa de diálogo Alterações de Visualização e, em seguida, selecione o botão I Accept na caixa de diálogo Aceitação da Licença se você concordar com os termos de licença dos pacotes listados.

Preparar seus dados

1. Baixe os conjuntos de dados issues_train.tsv e issues_test.tsv e salve-os na pasta Dados criada anteriormente. O primeiro conjunto de dados treina o modelo de machine learning e o segundo pode ser usado para avaliar a precisão do modelo.

2. No Gerenciador de Soluções, clique com o botão direito do mouse em cada um dos arquivos *.tsv e selecione Propriedades. Em Avançado, altere o valor de Copiar para Diretório de Saída para Copiar se for mais recente.

Criar classes e definir caminhos

Adicione as seguintes diretivas adicionais using à parte superior do arquivo Program.cs :

using Microsoft.ML;
using GitHubIssueClassification;

Crie três campos globais para manter os caminhos para os arquivos baixados recentemente e variáveis globais para o MLContext, DataViewe PredictionEngine:

• _trainDataPath tem o caminho para o conjunto de dados usado para treinar o modelo.
• _testDataPath tem o caminho para o conjunto de dados usado para avaliar o modelo.
• _modelPath tem o caminho onde o modelo treinado é salvo.
• _mlContext é o que fornece o MLContext contexto de processamento.
• _trainingDataView é o IDataView usado para processar o conjunto de dados de treinamento.
• _predEngine é o PredictionEngine<TSrc,TDst> usado para previsões simples.

Adicione o seguinte código à linha diretamente abaixo das using diretivas para especificar esses caminhos e as outras variáveis:

string _appPath = Path.GetDirectoryName(Environment.GetCommandLineArgs()[0]) ?? ".";
string _trainDataPath = Path.Combine(_appPath, "..", "..", "..", "Data", "issues_train.tsv");
string _testDataPath = Path.Combine(_appPath, "..", "..", "..", "Data", "issues_test.tsv");
string _modelPath = Path.Combine(_appPath, "..", "..", "..", "Models", "model.zip");

MLContext _mlContext;
PredictionEngine<GitHubIssue, IssuePrediction> _predEngine;
ITransformer _trainedModel;
IDataView _trainingDataView;

Crie algumas classes para seus dados de entrada e previsões. Adicione uma nova classe ao seu projeto:

1. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto e selecione Adicionar>Novo Item.

2. Na caixa de diálogo Adicionar Novo Item , selecione Classe e altere o campo Nome para GitHubIssueData.cs. Em seguida, selecione Adicionar.

   O arquivo GitHubIssueData.cs é aberto no editor de código. Adicione a seguinte using diretiva à parte superior do GitHubIssueData.cs:

   using Microsoft.ML.Data;
   

3. Remova a definição de classe existente e adicione o código a seguir ao arquivo GitHubIssueData.cs . Esse código tem duas classes GitHubIssue e IssuePrediction.

   public class GitHubIssue
   {
       [LoadColumn(0)]
       public string? ID { get; set; }
       [LoadColumn(1)]
       public string? Area { get; set; }
       [LoadColumn(2)]
       public required string Title { get; set; }
       [LoadColumn(3)]
       public required string Description { get; set; }
   }
   
   public class IssuePrediction
   {
       [ColumnName("PredictedLabel")]
       public string? Area;
   }
   

   A label coluna que você deseja prever. As entradas identificadas Features são as que você fornece ao modelo para prever o Rótulo.

   Use LoadColumnAttribute para especificar os índices das colunas de origem no conjunto de dados.

   GitHubIssue é a classe de conjunto de dados de entrada e tem os seguintes String campos:

   • A primeira coluna ID (ID do Problema do GitHub).
   • A segunda coluna Area (a previsão para treinamento).
   • A terceira coluna Title (título da issue do GitHub) é a primeira feature usada para prever o Area.
   • A quarta coluna Description é a segunda feature usada para prever o Area.

   IssuePrediction é a classe usada para previsão depois que o modelo é treinado. Ele tem um único string (Area) e um PredictedLabelColumnName atributo. O PredictedLabel é usado durante a previsão e a avaliação. Para avaliação, uma entrada com dados de treinamento, os valores previstos e o modelo são usados.

   Todas as operações de ML.NET começam na classe MLContext . A inicialização mlContext cria um novo ambiente ML.NET que pode ser compartilhado entre os objetos de fluxo de trabalho de criação de modelo. É semelhante, conceitualmente, a DBContext entrar Entity Framework.

Inicializar variáveis

Inicialize a _mlContext variável global com uma nova instância de MLContext com uma semente aleatória (seed: 0) por resultados repetíveis/determinísticos em múltiplos treinamentos. Substitua a Console.WriteLine("Hello World!") linha pelo seguinte código:

_mlContext = new MLContext(seed: 0);

Carregar os dados

ML.NET usa a interface IDataView como uma maneira flexível e eficiente de descrever dados numéricos ou tabulares de texto. IDataView pode carregar arquivos de texto ou em tempo real (por exemplo, banco de dados SQL ou arquivos de log).

Para inicializar e carregar a _trainingDataView variável global para usá-la para o pipeline, adicione o seguinte código após a mlContext inicialização:

_trainingDataView = _mlContext.Data.LoadFromTextFile<GitHubIssue>(_trainDataPath,hasHeader: true);

O LoadFromTextFile() define o esquema de dados e as leituras no arquivo. Ele recebe as variáveis de caminho de dados e retorna um IDataView.

Adicione o seguinte depois de chamar o LoadFromTextFile() método:

var pipeline = ProcessData();

O ProcessData método executa as seguintes tarefas:

• Extrai e transforma os dados.
• Retorna o pipeline de processamento.

Crie o ProcessData método na parte inferior do arquivo Program.cs usando o seguinte código:

IEstimator<ITransformer> ProcessData()
{

}

Extrair recursos e transformar os dados

Como você deseja prever o rótulo do GitHub para uma área GitHubIssue, use o método MapValueToKey() para transformar a coluna Area em uma coluna de tipo de chave numérica Label (um formato aceito por algoritmos de classificação) e adicioná-la como uma nova coluna no conjunto de dados:

var pipeline = _mlContext.Transforms.Conversion.MapValueToKey(inputColumnName: "Area", outputColumnName: "Label")

Em seguida, chame mlContext.Transforms.Text.FeaturizeText, que transforma as colunas de texto (Title e Description) em um vetor numérico para cada chamado TitleFeaturized e DescriptionFeaturized. Acrescente a featurização de ambas as colunas ao pipeline com o seguinte código:

.Append(_mlContext.Transforms.Text.FeaturizeText(inputColumnName: "Title", outputColumnName: "TitleFeaturized"))
.Append(_mlContext.Transforms.Text.FeaturizeText(inputColumnName: "Description", outputColumnName: "DescriptionFeaturized"))

A última etapa na preparação de dados combina todas as colunas de recursos na coluna Recursos usando o método Concatenate( ). Por padrão, um algoritmo de aprendizado processa apenas recursos da coluna Recursos . Acrescente essa transformação ao pipeline com o seguinte código:

.Append(_mlContext.Transforms.Concatenate("Features", "TitleFeaturized", "DescriptionFeaturized"))

Em seguida, acrescente um AppendCacheCheckpoint para armazenar em cache o DataView para que, quando você iterar sobre os dados várias vezes usando o cache, possa obter um melhor desempenho, como com o seguinte código:

.AppendCacheCheckpoint(_mlContext);

Retorne o pipeline no final do ProcessData método.

return pipeline;

Esta etapa trata do pré-processamento/da apresentação. Usar componentes adicionais disponíveis em ML.NET pode habilitar melhores resultados com seu modelo.

Compilar e treinar o modelo

Adicione a seguinte chamada ao BuildAndTrainModelmétodo como a próxima linha após a chamada ao ProcessData() método:

var trainingPipeline = BuildAndTrainModel(_trainingDataView, pipeline);

O BuildAndTrainModel método executa as seguintes tarefas:

• Cria a classe de algoritmo de treinamento.
• Treina o modelo.
• Prevê a área com base nos dados de treinamento.
• Retorna o modelo.

Crie o BuildAndTrainModel método, logo após a declaração do ProcessData() método, usando o seguinte código:

IEstimator<ITransformer> BuildAndTrainModel(IDataView trainingDataView, IEstimator<ITransformer> pipeline)
{

}

Sobre a tarefa de classificação

A classificação é uma tarefa de machine learning que usa dados para determinar a categoria, o tipo ou a classe de um item ou linha de dados e é frequentemente um dos seguintes tipos:

• Binário: A ou B.
• Multiclasse: várias categorias que podem ser previstas usando um único modelo.

Para esse tipo de problema, use um algoritmo de aprendizado de classificação multiclasse, já que a previsão da categoria do problema pode ser uma de várias categorias (multiclasse), em vez de apenas duas (binária).

Acrescente o algoritmo de machine learning às definições de transformação de dados adicionando o seguinte como a primeira linha de código em BuildAndTrainModel():

var trainingPipeline = pipeline.Append(_mlContext.MulticlassClassification.Trainers.SdcaMaximumEntropy("Label", "Features"))
        .Append(_mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));

O SdcaMaximumEntropy é o algoritmo de treinamento de classificação multiclasse. É acrescentado ao pipeline e aceita os parâmetros com funcionalidades destacadas Title e Description (Features) e a entrada de Label para aprender com os dados históricos.

Treinar o modelo

Ajuste o modelo aos splitTrainSet dados e retorne o modelo treinado adicionando o seguinte como a próxima linha de código no BuildAndTrainModel() método:

_trainedModel = trainingPipeline.Fit(trainingDataView);

O Fit()método treina seu modelo transformando o conjunto de dados e aplicando o treinamento.

O PredictionEngine é uma API de conveniência que permite que você passe e execute uma previsão em uma única instância de dados. Adicione isso como a próxima linha no BuildAndTrainModel() método:

_predEngine = _mlContext.Model.CreatePredictionEngine<GitHubIssue, IssuePrediction>(_trainedModel);

Prever com o modelo treinado

Adicione um problema do GitHub para testar a previsão do modelo treinado no Predict método criando uma instância de GitHubIssue:

GitHubIssue issue = new GitHubIssue() {
    Title = "WebSockets communication is slow in my machine",
    Description = "The WebSockets communication used under the covers by SignalR looks like is going slow in my development machine.."
};

Use a função Predict() para fazer uma previsão em uma única linha de dados:

var prediction = _predEngine.Predict(issue);

Usar o modelo: resultados da previsão

Exiba GitHubIssue e a previsão de rótulo correspondente Area para compartilhar os resultados e agir sobre eles adequadamente. Crie uma exibição para os resultados usando o seguinte Console.WriteLine() código:

Console.WriteLine($"=============== Single Prediction just-trained-model - Result: {prediction.Area} ===============");

Retornar o modelo treinado para uso para avaliação

Retorne o modelo no final do BuildAndTrainModel método.

return trainingPipeline;

Avaliar o modelo

Agora que você criou e treinou o modelo, precisa avaliá-lo com um conjunto de dados diferente para garantia e validação de qualidade. No método Evaluate, o modelo criado em BuildAndTrainModel é passado para ser avaliado. Crie o Evaluate método, logo depois BuildAndTrainModel, como no seguinte código:

void Evaluate(DataViewSchema trainingDataViewSchema)
{

}

O Evaluate método executa as seguintes tarefas:

• Carrega o conjunto de dados de teste.
• Cria o avaliador de várias classes.
• Avalia o modelo e cria métricas.
• Exibe as métricas.

Adicione uma chamada ao novo método, diretamente na chamada do BuildAndTrainModel método, usando o seguinte código:

Evaluate(_trainingDataView.Schema);

Como você fez anteriormente com o conjunto de dados de treinamento, carregue o conjunto de dados de teste adicionando o seguinte código ao Evaluate método:

var testDataView = _mlContext.Data.LoadFromTextFile<GitHubIssue>(_testDataPath,hasHeader: true);

O método Evaluate() calcula as métricas de qualidade do modelo usando o conjunto de dados especificado. Ele retorna um MulticlassClassificationMetrics objeto que contém as métricas gerais computadas por avaliadores de classificação multiclasse. Para exibir as métricas para determinar a qualidade do modelo, você precisa obtê-las primeiro. Observe o uso do método Transform() da variável global de machine learning _trainedModel (um ITransformer) para inserir os recursos e retornar previsões. Adicione o seguinte código ao Evaluate método como a próxima linha:

var testMetrics = _mlContext.MulticlassClassification.Evaluate(_trainedModel.Transform(testDataView));

As seguintes métricas são avaliadas para classificação multiclasse:

• Precisão Micro – cada par de amostra e classe contribui igualmente para a métrica de precisão. Você deseja que a Micro Precisão esteja o mais próximo possível de uma.
• Precisão da macro – cada classe contribui igualmente para a métrica de precisão. Classes minoritárias recebem o mesmo peso que as classes maiores. Você deseja que a Precisão Macro esteja o mais próxima possível de um.
• Perda de log – consulte Perda de Log. Você quer que o log loss esteja o mais próximo possível de zero.
• Redução de perda logarítmica – varia de [-inf, 1,00], onde 1,00 indica previsão perfeita e 0 indica previsão média. Você deseja que a redução de log-loss seja o mais próximo de um quanto possível.

Exibir as métricas para validação de modelo

Use o código a seguir para exibir as métricas, compartilhar os resultados e, em seguida, agir sobre elas:

Console.WriteLine($"*************************************************************************************************************");
Console.WriteLine($"*       Metrics for Multi-class Classification model - Test Data     ");
Console.WriteLine($"*------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"*       MicroAccuracy:    {testMetrics.MicroAccuracy:0.###}");
Console.WriteLine($"*       MacroAccuracy:    {testMetrics.MacroAccuracy:0.###}");
Console.WriteLine($"*       LogLoss:          {testMetrics.LogLoss:#.###}");
Console.WriteLine($"*       LogLossReduction: {testMetrics.LogLossReduction:#.###}");
Console.WriteLine($"*************************************************************************************************************");

Salvar o modelo em um arquivo

Uma vez satisfeito com seu modelo, salve-o em um arquivo para fazer previsões posteriormente ou em outro aplicativo. Adicione o seguinte código ao Evaluate método.

SaveModelAsFile(_mlContext, trainingDataViewSchema, _trainedModel);

Crie o método abaixo do SaveModelAsFile método Evaluate .

void SaveModelAsFile(MLContext mlContext,DataViewSchema trainingDataViewSchema, ITransformer model)
{

}

Adicione o código a seguir ao método SaveModelAsFile. Esse código usa o Save método para serializar e armazenar o modelo treinado como um arquivo zip.

mlContext.Model.Save(model, trainingDataViewSchema, _modelPath);

Implantar e prever com um modelo

Adicione uma chamada ao novo método, diretamente na chamada do Evaluate método, usando o seguinte código:

PredictIssue();

Crie o PredictIssue método, logo após o Evaluate método (e pouco antes do SaveModelAsFile método), usando o seguinte código:

void PredictIssue()
{

}

O PredictIssue método executa as seguintes tarefas:

• Carrega o modelo salvo.
• Cria um único problema de dados de teste.
• Prevê a área com base nos dados de teste.
• Combina dados de teste e previsões para relatórios.
• Exibe os resultados previstos.

Carregue o modelo salvo em seu aplicativo adicionando o seguinte código ao PredictIssue método:

ITransformer loadedModel = _mlContext.Model.Load(_modelPath, out var modelInputSchema);

Adicione um problema do GitHub para testar a previsão do modelo treinado no Predict método criando uma instância de GitHubIssue:

GitHubIssue singleIssue = new GitHubIssue() { Title = "Entity Framework crashes", Description = "When connecting to the database, EF is crashing" };

Como você fez anteriormente, crie uma PredictionEngine instância com o seguinte código:

_predEngine = _mlContext.Model.CreatePredictionEngine<GitHubIssue, IssuePrediction>(loadedModel);

O PredictionEngine é uma API de conveniência que permite que você execute uma previsão em uma única instância de dados. PredictionEngine não é thread-safe. É aceitável usar em ambientes monothread ou de protótipo. Para melhorar o desempenho e a segurança de threads em ambientes de produção, use o PredictionEnginePool serviço, que cria um ObjectPool dos PredictionEngine objetos para uso em todo o aplicativo. Consulte este guia sobre como usar PredictionEnginePool em uma API Web do ASP.NET Core.

Use o PredictionEngine para prever o rótulo Area do GitHub, adicionando o seguinte código ao método de previsão PredictIssue:

var prediction = _predEngine.Predict(singleIssue);

Usar o modelo carregado para previsão

Exiba Area para categorizar o problema e agir sobre ele adequadamente. Crie uma exibição para os resultados usando o seguinte Console.WriteLine() código:

Console.WriteLine($"=============== Single Prediction - Result: {prediction.Area} ===============");

Results

Seus resultados devem ser semelhantes aos seguintes. À medida que o pipeline está em andamento, ele exibe mensagens. Você pode ver avisos ou mensagens de processamento. Essas mensagens foram removidas dos seguintes resultados para maior clareza.

=============== Single Prediction just-trained-model - Result: area-System.Net ===============
*************************************************************************************************************
*       Metrics for Multi-class Classification model - Test Data
*------------------------------------------------------------------------------------------------------------
*       MicroAccuracy:    0.738
*       MacroAccuracy:    0.668
*       LogLoss:          .919
*       LogLossReduction: .643
*************************************************************************************************************
=============== Single Prediction - Result: area-System.Data ===============

Parabéns! Agora você criou com êxito um modelo de machine learning para classificar e prever um rótulo de área para um problema do GitHub. Você pode encontrar o código-fonte deste tutorial no repositório dotnet/samples .

Próximas etapas

Neste tutorial, você aprendeu a:

Avance para o próximo tutorial para saber mais.