Tutoriel : Prédire les prix à l’aide de la régression avec ML.NET

Ce tutoriel montre comment créer un modèle de régression à l’aide de ML.NET pour prédire les prix, en particulier les tarifs des taxis de New York.

Dans ce tutoriel, vous allez apprendre à :

Préparer et comprendre les données
Charger et transformer les données
Choisir un algorithme d’apprentissage
Entraîner le modèle
Évaluer le modèle
Utiliser le modèle pour les prédictions

Prerequisites

Visual Studio 2022 ou version ultérieure avec la charge de travail développement .NET Desktop installée.

Création d’une application console

Créez une application console C# appelée « TaxiFarePrediction ».
Choisissez .NET 8 comme framework à utiliser. Cliquez sur le bouton Créer.
Créez un répertoire nommé Data dans votre projet pour stocker le jeu de données et les fichiers de modèle.
Installez le package NuGet Microsoft.ML et Microsoft.ML.FastTree :

Note

Cet exemple utilise la dernière version stable des packages NuGet mentionnés, sauf indication contraire.

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Gérer les packages NuGet. Choisissez « nuget.org » comme source du package, sélectionnez l’onglet Parcourir, recherchezMicrosoft.ML, sélectionnez le package dans la liste, puis sélectionnez Installer. Sélectionnez le bouton OK dans la boîte de dialogue Aperçu des modifications , puis sélectionnez le bouton J’acceptedans la boîte de dialogue Acceptation de licence si vous acceptez les termes du contrat de licence pour les packages répertoriés. Procédez de la même façon pour le package NuGet Microsoft.ML.FastTree .

Préparer et comprendre les données

Téléchargez les taxi-fare-train.csv et les jeux de données taxi-fare-test.csv et enregistrez-les dans le dossier Données que vous avez créé à l’étape précédente. Nous utilisons ces jeux de données pour entraîner le modèle Machine Learning, puis évaluer la précision du modèle. Ces ensembles de données proviennent à l’origine de l’ensemble de données NYC TLC Taxi Trip.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur chacun des fichiers *.csv, puis sélectionnez Propriétés. Sous Avancé, modifiez la valeur de Copie dans le répertoire de sortie pour copier si elle est plus récente.
Ouvrez le jeu de données taxi-fare-train.csv et examinez les en-têtes de colonne de la première ligne. Examinez chacune des colonnes. Comprendre les données et déterminer les colonnes qui sont des caractéristiques et l’étiquette.

Il label s’agit de la colonne que vous souhaitez prédire. Les entrées identifiées Featuressont les entrées que vous donnez au modèle pour prédire le Label.

Le jeu de données fourni contient les colonnes suivantes :

vendor_id : L’ID du fournisseur de taxi est une fonctionnalité.
rate_code : Le type de tarif du trajet en taxi est une fonctionnalité.
passenger_count : Le nombre de passagers sur le voyage est une fonctionnalité.
trip_time_in_secs : La durée du trajet a pris. Vous souhaitez prédire le tarif du voyage avant la fin du voyage. À ce moment-là, vous ne savez pas combien de temps le voyage prendra. Par conséquent, le temps de trajet n’est pas une fonctionnalité et vous excluez cette colonne du modèle.
trip_distance : La distance du voyage est une fonctionnalité.
payment_type : Le mode de paiement (espèces ou carte de crédit) est une fonctionnalité.
fare_amount : Le prix total du taxi payé est l’étiquette.

Créer des classes de données

Créez des classes pour les données d’entrée et les prédictions :

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Ajouter>un nouvel élément.
Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez Classe et remplacez le champ Nom par TaxiTrip.cs. Ensuite, sélectionnez Ajouter.
Ajoutez les directives suivantes using au nouveau fichier :
```
using Microsoft.ML.Data;
```

Supprimez la définition de classe existante et ajoutez le code suivant, qui comporte deux classes TaxiTrip et TaxiTripFarePrediction, au fichier 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 est la classe de données d’entrée et a des définitions pour chacune des colonnes du jeu de données. Utilisez l’attribut LoadColumnAttribute pour spécifier les index des colonnes sources dans le jeu de données.

La TaxiTripFarePrediction classe représente les résultats prédits. Il a un champ float unique, FareAmountavec un ScoreColumnNameAttribute attribut appliqué. Dans le cas de la tâche de régression, la colonne Score contient des valeurs d’étiquette prédites.

Note

Utilisez le float type pour représenter des valeurs à virgule flottante dans les classes de données d’entrée et de prédiction.

Définir des chemins de données et de modèle

Ajoutez les directives supplémentaires using suivantes en haut du fichier Program.cs :

using Microsoft.ML;
using TaxiFarePrediction;

Vous devez créer trois champs pour contenir les chemins d’accès aux fichiers avec des jeux de données et le fichier pour enregistrer le modèle :

_trainDataPath contient le chemin d’accès au fichier avec le jeu de données utilisé pour entraîner le modèle.
_testDataPath contient le chemin d’accès au fichier avec le jeu de données utilisé pour évaluer le modèle.
_modelPath contient le chemin d’accès au fichier dans lequel le modèle entraîné est stocké.

Ajoutez le code suivant juste en dessous de la section Usings pour spécifier ces chemins et pour la _textLoader variable :

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");

Toutes les opérations ML.NET démarrent dans la classe MLContext. L’initialisation mlContext crée un environnement ML.NET qui peut être partagé entre les objets de flux de travail de création de modèle. Il est similaire, conceptuellement, à DBContext entity Framework.

Initialiser les variables

Remplacez la Console.WriteLine("Hello World!") ligne par le code suivant pour déclarer et initialiser la mlContext variable :

MLContext mlContext = new MLContext(seed: 0);

Ajoutez ce qui suit comme ligne de code suivante pour appeler la Train méthode :

var model = Train(mlContext, _trainDataPath);

La Train() méthode exécute les tâches suivantes :

Charge les données.
Extrait et transforme les données.
Effectue l’apprentissage du modèle.
Retourne le modèle.

La Train méthode entraîne le modèle. Créez cette méthode juste en dessous à l’aide du code suivant :

ITransformer Train(MLContext mlContext, string dataPath)
{

}

Charger et transformer des données

ML.NET utilise l’interface IDataView comme moyen flexible et efficace de décrire des données tabulaires numériques ou textuelles. IDataView peut charger des fichiers texte ou en temps réel (par exemple, une base de données SQL ou des fichiers journaux). Ajoutez le code suivant comme première ligne de la Train() méthode :

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

Comme vous souhaitez prédire le prix du trajet de taxi, la FareAmount colonne est celle Label que vous allez prédire (la sortie du modèle). Utilisez la CopyColumnsEstimator classe de transformation pour copier FareAmount, puis ajoutez le code suivant :

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

L’algorithme qui entraîne le modèle nécessite des fonctionnalités numériques . Vous devez donc transformer les valeurs de données catégorielles (VendorId, RateCodeet PaymentType) en nombres (VendorIdEncoded, RateCodeEncodedet PaymentTypeEncoded). Pour ce faire, utilisez la classe de transformation OneHotEncodingTransformer , qui affecte différentes valeurs de clé numérique aux différentes valeurs de chacune des colonnes et ajoutez le code suivant :

.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"))

La dernière étape de la préparation des données combine toutes les colonnes de caractéristiques dans la colonne Features à l’aide de la mlContext.Transforms.Concatenate classe de transformation. Par défaut, un algorithme d’apprentissage traite uniquement les fonctionnalités de la colonne Fonctionnalités . Ajoutez le code suivant :

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

Choisir un algorithme d’apprentissage

Ce problème concerne la prédiction d’un trajet en taxi à New York. À première vue, il peut sembler dépendre simplement de la distance parcourue. Toutefois, les vendeurs de taxis à New York facturent des montants variables pour d’autres facteurs tels que des passagers supplémentaires ou payer avec une carte de crédit au lieu de l’argent. Vous souhaitez prédire la valeur du prix, qui est une valeur réelle, en fonction des autres facteurs du jeu de données. Pour ce faire, vous choisissez une tâche de machine learning de régression .

Ajoutez la tâche Machine Learning FastTreeRegressionTrainer aux définitions de transformation de données en ajoutant ce qui suit comme ligne de code suivante dans Train():

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

Entraîner le modèle

Ajustez le modèle à l’entraînement dataview et retournez le modèle entraîné en ajoutant la ligne de code suivante dans la Train() méthode :

var model = pipeline.Fit(dataView);

La méthode Fit() entraîne votre modèle en transformant le jeu de données et en appliquant l’entraînement.

Retournez le modèle entraîné avec la ligne de code suivante dans la Train() méthode :

return model;

Évaluer le modèle

Ensuite, évaluez les performances de votre modèle avec vos données de test pour l’assurance qualité et la validation. Créez la Evaluate() méthode, juste après Train(), avec le code suivant :

void Evaluate(MLContext mlContext, ITransformer model)
{

}

La Evaluate méthode exécute les tâches suivantes :

Charge le jeu de données de test.
Crée l’évaluateur de régression.
Évalue le modèle et crée des métriques.
Affiche les métriques.

Ajoutez un appel à la nouvelle méthode juste sous l’appel Train de méthode, à l’aide du code suivant :

Evaluate(mlContext, model);

Chargez le jeu de données de test à l’aide de la méthode LoadFromTextFile(). Évaluez le modèle à l’aide de ce jeu de données comme contrôle de qualité en ajoutant le code suivant dans la Evaluate méthode :

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

Ensuite, transformez les Test données en ajoutant le code suivant à Evaluate():

var predictions = model.Transform(dataView);

La méthode Transform() effectue des prédictions pour les lignes d’entrée du jeu de données de test.

La RegressionContext.Evaluate méthode calcule les métriques de qualité pour l’utilisation PredictionModel du jeu de données spécifié. Elle retourne un RegressionMetrics objet qui contient les métriques globales calculées par les évaluateurs de régression.

Pour les afficher pour déterminer la qualité du modèle, vous devez d’abord obtenir les métriques. Ajoutez le code suivant comme ligne suivante dans la Evaluate méthode :

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

Une fois que vous avez le jeu de prédictions, la méthode Evaluate() évalue le modèle, qui compare les valeurs prédites avec la valeur réelle Labels dans le jeu de données de test et retourne des métriques sur la façon dont le modèle fonctionne.

Ajoutez le code suivant pour évaluer le modèle et produire les métriques d’évaluation :

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

RSquared est une autre métrique d’évaluation des modèles de régression. RSquared prend des valeurs comprises entre 0 et 1. Plus sa valeur est proche de 1, mieux le modèle est. Ajoutez le code suivant dans la Evaluate méthode pour afficher la valeur RSquared :

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

RMS est l’une des métriques d’évaluation du modèle de régression. Plus il est bas, mieux le modèle est. Ajoutez le code suivant dans la Evaluate méthode pour afficher la valeur RMS :

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

Utiliser le modèle pour les prédictions

Créez la TestSinglePrediction méthode, juste après la Evaluate méthode, à l’aide du code suivant :

void TestSinglePrediction(MLContext mlContext, ITransformer model)
{

}

La TestSinglePrediction méthode exécute les tâches suivantes :

Crée un commentaire unique de données de test.
Prédit la quantité de prix en fonction des données de test.
Combine les données de test et les prédictions pour la création de rapports.
Affiche les résultats prédits.

Ajoutez un appel à la nouvelle méthode juste sous l’appel Evaluate de méthode, à l’aide du code suivant :

TestSinglePrediction(mlContext, model);

Utilisez la PredictionEngine méthode pour prédire le tarif en ajoutant le code suivant à TestSinglePrediction():

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

PredictionEngine est une API pratique, qui vous permet d’effectuer une prédiction sur une seule instance de données. PredictionEngine n’est pas thread-safe. Il est acceptable d’utiliser dans des environnements monothreads ou prototypes. Pour améliorer les performances et la sécurité des threads dans les environnements de production, utilisez le PredictionEnginePool service, qui crée un ObjectPool objet PredictionEngine à utiliser dans votre application. Consultez ce guide sur l’utilisation PredictionEnginePool dans une API web ASP.NET Core.

Note

PredictionEnginePool l’extension de service est actuellement en préversion.

Ce tutoriel utilise un voyage de test au sein de cette classe. Plus tard, vous pouvez ajouter d’autres scénarios pour expérimenter le modèle. Ajoutez un voyage pour tester la prédiction du coût du modèle entraîné dans la TestSinglePrediction() méthode en créant une instance 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
};

Ensuite, prédire le tarif en fonction d’une seule instance des données de trajet de taxi et le transmettre à PredictionEngine en ajoutant les lignes de code suivantes dans la méthode TestSinglePrediction() :

var prediction = predictionFunction.Predict(taxiTripSample);

La fonction Predict() effectue une prédiction sur une seule instance de données.

Pour afficher le tarif prédit du voyage spécifié, ajoutez le code suivant dans la TestSinglePrediction méthode :

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

Exécutez le programme pour voir le tarif prédit du taxi pour votre cas de test.

Félicitations! Vous avez maintenant créé un modèle Machine Learning pour prédire les tarifs des courses de taxi, évalué sa précision et l’avez utilisé pour effectuer des prédictions. Vous trouverez le code source de ce didacticiel dans le dépôt GitHub dotnet/samples .

Étapes suivantes

Dans ce didacticiel, vous avez appris à :

Préparer et comprendre les données
Créer un pipeline d’apprentissage
Charger et transformer les données
Choisir un algorithme d’apprentissage
Entraîner le modèle
Évaluer le modèle
Utiliser le modèle pour les prédictions

Passez au tutoriel suivant pour en savoir plus.

Classification des Iris

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-12-06