Compartilhar via

Tutorial: Prever preços usando regressão com ML.NET

Este tutorial ilustra como criar um modelo de regressão usando ML.NET para prever preços, especificamente, tarifas de táxi da cidade de Nova York.

Neste tutorial, você aprenderá como:

  • Preparar e entender os dados
  • Carregar e transformar os dados
  • Escolher um algoritmo de aprendizado
  • Treinar o modelo
  • Avaliar o modelo
  • Usar o modelo para previsões

Pré-requisitos

Criar um aplicativo de console

  1. Crie um aplicativo de console C# chamado "TaxiFarePrediction".

  2. Escolha .NET 8 como a estrutura a ser usada. Clique no botão Criar .

  3. Crie um diretório chamado Dados em seu projeto para armazenar o conjunto de dados e os arquivos de modelo.

  4. Instale o Microsoft.ML e o Pacote NuGet Microsoft.ML.FastTree :

    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 no projeto e escolha Gerenciar Pacotes NuGet. Escolha "nuget.org" como a origem do pacote, selecione a guia Procurar , pesquise Microsoft.ML, selecione o pacote na lista 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. Faça o mesmo para o pacote NuGet Microsoft.ML.FastTree .

Preparar e entender os dados

  1. Baixe o arquivo taxi-fare-train.csv e o taxi-fare-test.csv e salve-os na pasta Dados que você criou na etapa anterior. Usamos esses conjuntos de dados para treinar o modelo de machine learning e, em seguida, avaliar o quão preciso é o modelo. Esses conjuntos de dados são originalmente do conjunto de dados nyc TLC Taxi Trip.

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

  3. Abra o arquivo de conjunto de dados taxi-fare-train.csv e examine os cabeçalhos de coluna na primeira linha. Dê uma olhada em cada uma das colunas. Entenda os dados e decida quais colunas são atributos e qual delas é o rótulo.

A label coluna que você deseja prever. As identificações Featuressão as entradas que você fornece ao modelo para prever o Label.

O conjunto de dados fornecido contém as seguintes colunas:

  • vendor_id: A ID do vendedor de táxi é um recurso.
  • rate_code: O tipo de taxa da viagem de táxi é um recurso.
  • passenger_count: O número de passageiros na viagem é um recurso.
  • trip_time_in_secs: O tempo que a viagem levou. Você deseja prever a tarifa da viagem antes que a viagem seja concluída. Naquele momento, você não sabe quanto tempo a viagem levaria. Portanto, o tempo de viagem não é um recurso e você excluirá essa coluna do modelo.
  • trip_distance: A distância da viagem é um recurso.
  • payment_type: A forma de pagamento (em dinheiro ou cartão de crédito) é um recurso.
  • fare_amount: A tarifa total de táxi paga é a etiqueta.

Criar classes de dados

Crie classes para os dados de entrada e as previsões:

  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 TaxiTrip.cs. Em seguida, selecione Adicionar.

  3. Adicione as seguintes using diretivas ao novo arquivo:

    using Microsoft.ML.Data;

Remova a definição de classe existente e adicione o seguinte código, que tem duas classes TaxiTrip e TaxiTripFarePrediction, ao arquivo TaxiTrip.cs :

public class TaxiTrip
{
    [LoadColumn(0)]
    public string? VendorId;

    [LoadColumn(1)]
    public string? RateCode;

    [LoadColumn(2)]
    public float PassengerCount;

    [LoadColumn(3)]
    public float TripTime;

    [LoadColumn(4)]
    public float TripDistance;

    [LoadColumn(5)]
    public string? PaymentType;

    [LoadColumn(6)]
    public float FareAmount;
}

public class TaxiTripFarePrediction
{
    [ColumnName("Score")]
    public float FareAmount;
}

TaxiTrip é a classe de dados de entrada e tem definições para cada uma das colunas do conjunto de dados. Use o LoadColumnAttribute atributo para especificar os índices das colunas de origem no conjunto de dados.

A TaxiTripFarePrediction classe representa os resultados previstos. Ele tem um único campo flutuante, FareAmountcom um ScoreColumnNameAttribute atributo aplicado. No caso da tarefa de regressão, a coluna Pontuação contém valores de rótulo previstos.

Observação

Use o float tipo para representar valores de ponto flutuante nas classes de dados de entrada e previsão.

Definir dados e caminhos de modelo

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

using Microsoft.ML;
using TaxiFarePrediction;

Você precisa criar três campos para manter os caminhos para os arquivos com conjuntos de dados e o arquivo para salvar o modelo:

  • _trainDataPath contém o caminho para o arquivo com o conjunto de dados usado para treinar o modelo.
  • _testDataPath contém o caminho para o arquivo com o conjunto de dados usado para avaliar o modelo.
  • _modelPath contém o caminho para o arquivo em que o modelo treinado é armazenado.

Adicione o seguinte código logo abaixo da seção usos para especificar esses caminhos e para a _textLoader variável:

string _trainDataPath = Path.Combine(Environment.CurrentDirectory, "Data", "taxi-fare-train.csv");
string _testDataPath = Path.Combine(Environment.CurrentDirectory, "Data", "taxi-fare-test.csv");
string _modelPath = Path.Combine(Environment.CurrentDirectory, "Data", "Model.zip");

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, ao DBContext Entity Framework.

Inicializar variáveis

Substitua a Console.WriteLine("Hello World!") linha pelo seguinte código para declarar e inicializar a mlContext variável:

MLContext mlContext = new MLContext(seed: 0);

Adicione o seguinte como a próxima linha de código para chamar o Train método:

var model = Train(mlContext, _trainDataPath);

O Train() método executa as seguintes tarefas:

  • Carrega os dados.
  • Extrai e transforma os dados.
  • Treina o modelo.
  • Retorna o modelo.

O Train método treina o modelo. Crie esse método logo abaixo usando o seguinte código:

ITransformer Train(MLContext mlContext, string dataPath)
{

}

Carregar e transformar 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). Adicione o seguinte código como a primeira linha do Train() método:

IDataView dataView = mlContext.Data.LoadFromTextFile<TaxiTrip>(dataPath, hasHeader: true, separatorChar: ',');

Como você deseja prever a tarifa de corrida de táxi, a coluna FareAmount é o Label que você vai prever (o resultado do modelo). Use a CopyColumnsEstimator classe de transformação para copiar FareAmounte adicionar o seguinte código:

var pipeline = mlContext.Transforms.CopyColumns(outputColumnName: "Label", inputColumnName:"FareAmount")

O algoritmo que treina o modelo requer recursos numéricos, portanto, você precisa transformar os valores de dados categóricos (VendorIdRateCodee PaymentType) em números (VendorIdEncodedeRateCodeEncodedPaymentTypeEncoded). Para fazer isso, use a classe de transformação OneHotEncodingTransformer , que atribui valores de chave numérica diferentes aos diferentes valores em cada uma das colunas e adicione o seguinte código:

.Append(mlContext.Transforms.Categorical.OneHotEncoding(outputColumnName: "VendorIdEncoded", inputColumnName:"VendorId"))
.Append(mlContext.Transforms.Categorical.OneHotEncoding(outputColumnName: "RateCodeEncoded", inputColumnName: "RateCode"))
.Append(mlContext.Transforms.Categorical.OneHotEncoding(outputColumnName: "PaymentTypeEncoded", inputColumnName: "PaymentType"))

A última etapa na preparação de dados combina todas as colunas de recursos na coluna Recursos usando a mlContext.Transforms.Concatenate classe de transformação. Por padrão, um algoritmo de aprendizado processa apenas recursos da coluna Recursos . Adicione o seguinte código:

.Append(mlContext.Transforms.Concatenate("Features", "VendorIdEncoded", "RateCodeEncoded", "PassengerCount", "TripDistance", "PaymentTypeEncoded"))

Escolher um algoritmo de aprendizado

Este problema é sobre prever uma tarifa de táxi em Nova York. À primeira vista, pode parecer depender simplesmente da distância percorrida. No entanto, os vendedores de táxis em Nova York cobram quantias variadas por outros fatores, como passageiros adicionais ou pagamento com um cartão de crédito em vez de dinheiro. Você deseja prever o valor do preço, que é um valor real, com base nos outros fatores no conjunto de dados. Para fazer isso, escolha uma tarefa de aprendizado de máquina de regressão .

Acrescente a tarefa de aprendizado de máquina FastTreeRegressionTrainer às definições de transformação de dados adicionando o seguinte como a próxima linha de código em Train():

.Append(mlContext.Regression.Trainers.FastTree());

Treinar o modelo

Ajuste o modelo ao treinamento dataview e retorne o modelo treinado adicionando a seguinte linha de código no Train() método:

var model = pipeline.Fit(dataView);

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

Retorne o modelo treinado com a seguinte linha de código no Train() método:

return model;

Avaliar o modelo

Em seguida, avalie o desempenho do modelo com os dados de teste para garantia e validação de qualidade. Crie o Evaluate() método, logo depois Train(), com o seguinte código:

void Evaluate(MLContext mlContext, ITransformer model)
{

}

O Evaluate método executa as seguintes tarefas:

  • Carrega o conjunto de dados de teste.
  • Cria o avaliador de regressão.
  • Avalia o modelo e cria métricas.
  • Exibe as métricas.

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

Evaluate(mlContext, model);

Carregue o conjunto de dados de teste usando o método LoadFromTextFile(). Avalie o modelo usando esse conjunto de dados como uma verificação de qualidade adicionando o seguinte código no Evaluate método:

IDataView dataView = mlContext.Data.LoadFromTextFile<TaxiTrip>(_testDataPath, hasHeader: true, separatorChar: ',');

Em seguida, transforme os Test dados adicionando o seguinte código a Evaluate():

var predictions = model.Transform(dataView);

O método Transform() faz previsões para as linhas de entrada do conjunto de dados de teste.

O RegressionContext.Evaluate método calcula as métricas de qualidade para o PredictionModel uso do conjunto de dados especificado. Ele retorna um RegressionMetrics objeto que contém as métricas gerais computadas por avaliadores de regressão.

Para exibi-los para determinar a qualidade do modelo, primeiro você precisa obter as métricas. Adicione o seguinte código como a próxima linha no Evaluate método:

var metrics = mlContext.Regression.Evaluate(predictions, "Label", "Score");

Depois que você tiver o conjunto de previsões, o método Evaluate() avaliará o modelo, que compara os valores previstos com o real Labels no conjunto de dados de teste e retorna métricas sobre como o modelo está sendo executado.

Adicione o seguinte código para avaliar o modelo e produzir as métricas de avaliação:

Console.WriteLine();
Console.WriteLine($"*************************************************");
Console.WriteLine($"*       Model quality metrics evaluation         ");
Console.WriteLine($"*------------------------------------------------");

RSquared é outra métrica de avaliação dos modelos de regressão. O RSquared usa valores entre 0 e 1. Quanto mais próximo seu valor for 1, melhor será o modelo. Adicione o seguinte código ao Evaluate método para exibir o valor RSquared:

Console.WriteLine($"*       RSquared Score:      {metrics.RSquared:0.##}");

O RMS é uma das métricas de avaliação do modelo de regressão. Quanto menor for, melhor será o modelo. Adicione o seguinte código ao Evaluate método para exibir o valor RMS:

Console.WriteLine($"*       Root Mean Squared Error:      {metrics.RootMeanSquaredError:0.##}");

Usar o modelo para previsões

Crie o TestSinglePrediction método, logo após o Evaluate método, usando o seguinte código:

void TestSinglePrediction(MLContext mlContext, ITransformer model)
{

}

O TestSinglePrediction método executa as seguintes tarefas:

  • Cria um único comentário de dados de teste.
  • Prevê o valor da tarifa com base nos dados de teste.
  • Combina dados de teste e previsões para relatórios.
  • Exibe os resultados previstos.

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

TestSinglePrediction(mlContext, model);

Use a PredictionEngine tarifa para prever a adição do seguinte código a TestSinglePrediction():

var predictionFunction = mlContext.Model.CreatePredictionEngine<TaxiTrip, TaxiTripFarePrediction>(model);

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.

Observação

PredictionEnginePool A extensão de serviço está atualmente em versão prévia.

Este tutorial usa uma viagem de teste dentro dessa classe. Posteriormente, você pode adicionar outros cenários para experimentar o modelo. Adicione uma viagem para testar a previsão de custo do modelo treinado no TestSinglePrediction() método criando uma instância de TaxiTrip:

var taxiTripSample = new TaxiTrip()
{
    VendorId = "VTS",
    RateCode = "1",
    PassengerCount = 1,
    TripTime = 1140,
    TripDistance = 3.75f,
    PaymentType = "CRD",
    FareAmount = 0 // To predict. Actual/Observed = 15.5
};

Em seguida, preveja a tarifa com base em uma única instância dos dados de corrida de táxi e passe-a para a PredictionEngine, adicionando as seguintes linhas de código no método TestSinglePrediction().

var prediction = predictionFunction.Predict(taxiTripSample);

A função Predict() faz uma previsão em uma única instância de dados.

Para exibir a tarifa prevista da viagem especificada, adicione o seguinte código ao TestSinglePrediction método:

Console.WriteLine($"**********************************************************************");
Console.WriteLine($"Predicted fare: {prediction.FareAmount:0.####}, actual fare: 15.5");
Console.WriteLine($"**********************************************************************");

Execute o programa para ver a tarifa de táxi prevista para o caso de teste.

Parabéns! Agora você criou com êxito um modelo de machine learning para prever tarifas de corrida de táxi, avaliou sua precisão e o usou para fazer previsões. Você pode encontrar o código-fonte deste tutorial no repositório GitHub dotnet/samples .

Próximas etapas

Neste tutorial, você aprendeu a:

  • Preparar e entender os dados
  • Criar um pipeline de aprendizado
  • Carregar e transformar os dados
  • Escolher um algoritmo de aprendizado
  • Treinar o modelo
  • Avaliar o modelo
  • Usar o modelo para previsões

Avance para o próximo tutorial para saber mais.

Agrupamento de Iris

  • Last updated on