ML-1 : Introduction au Machine Learning avec ML.NET

Navigation : Index | Suivant >>

Objectifs d’apprentissage

A la fin de ce notebook, vous saurez : 1. Expliquer les étapes d’un pipeline ML : données -> entraînement -> évaluation -> déploiement 2. Créer un MLContext et charger des données avec IDataView 3. Construire un pipeline de régression linéaire avec SDCA 4. Evaluer un modèle avec le coefficient de détermination R² 5. Utiliser PredictionEngine pour faire des prédictions

Prérequis

  • .NET SDK 9.0
  • Notions de programmation C#

Durée estimée : 30-40 minutes

Qu’est-ce que le Machine Learning ?

Le Machine Learning (ML) est une méthode de création de modèles prédictifs en utilisant des algorithmes pour apprendre à partir de données. Contrairement à la programmation traditionnelle, où les développeurs définissent les étapes de l’algorithme, le ML permet à la machine d’apprendre ces étapes à partir des données.

Quelles sont les étapes à suivre ?

  1. Source et Préparation des Données d’Entraînement
    Pour entraîner le modèle, nous avons besoin de données étiquetées. Les données étiquetées signifient simplement un ensemble de données qui contient la colonne à prédire déjà présente afin que l’algorithme d’entraînement puisse apprendre à prédire les valeurs.

  2. Choisir l’Algorithme d’Entraînement et Entraîner
    >Spoiler Alert
    >Dans la plupart de nos exemples, nous utiliserons AutoML pour simplifier ce processus. AutoML essaie stratégiquement divers algorithmes et paramètres pour une tâche donnée afin de trouver celui qui fonctionne le mieux pour vos données !
    >
    >Vous pouvez penser à cela comme une boucle qui essaie toutes les options. Notre AutoML est un peu plus intelligent que cela … mais c’est essentiellement ce qu’il fait !
    > > Pour l’exemple ci-dessous, nous entraînerons un algorithme spécifique - pour que vous puissiez voir comment cela fonctionne !

    1. Choisir une Tâche - Tâches ML.NET
    2. Choisir un Algorithme - Algorithmes ML.NET
    3. Définir les Paramètres de l’Algorithme Glossaire - Hyperparamètres
    4. Entraîner - C’est ici que les données sont réellement alimentées dans l’algorithme pour entraîner le modèle. Cela peut prendre du temps en fonction de la quantité de données, de l’algorithme et des paramètres de cet algorithme.

  3. Évaluer
    Une fois que vous avez entraîné un modèle - comment savez-vous qu’il fonctionne ? Il existe de nombreuses techniques pour évaluer les performances de vos modèles. Si vous souhaitez approfondir - consultez Les Métriques d’Évaluation. Sinon, nous donnerons des exemples tout au long de ces tutoriels.

  4. Déployer
    Après avoir entraîné un modèle … c’est juste du code .NET ! Déployez-le comme vous le feriez pour toute autre application.

Comment commencer ?

Ci-dessous, nous avons une introduction rapide à ML.NET - “Hello ML.NET World!” et les trois prochains notebooks de la série plongent en profondeur dans la Préparation des Données et l’Ingénierie des Caractéristiques, L’Entraînement et AutoML, et L’Évaluation des Modèles.

Hello ML.NET World!

Le code dans l’extrait suivant démontre l’application ML.NET la plus simple. Cet exemple construit un modèle de régression linéaire pour prédire les prix des maisons en utilisant les données de taille et de prix des maisons.

Première étape, référencer le package Microsoft.ML.

#r "nuget: Microsoft.ML, 5.0.0"
Console.WriteLine("Microsoft.ML package charge");
Installed Packages
  • Microsoft.ML, 5.0.0
Microsoft.ML package charge

La deuxième étape est de référencer les espaces de noms ML.NET.

using Microsoft.ML;
using Microsoft.ML.Data;
Console.WriteLine("Espaces de noms Microsoft.ML importes");
Espaces de noms Microsoft.ML importes

Maintenant, nous sommes prêts à écrire le code pour accomplir la tâche de machine learning dont nous avons besoin. Toujours commencer par créer le MLContext qui est le contexte commun pour toutes les opérations ML.NET.

MLContext mlContext = new MLContext();
Console.WriteLine($"MLContext cree (seed: {mlContext})");
MLContext cree (seed: Microsoft.ML.MLContext)

Ensuite, définissez les structures de données pour les données que nous allons utiliser. Cet exemple concerne la prédiction des prix des maisons. Commencez par définir la structure de données suivante qui contient la taille et le prix des maisons :

public class HouseData
{
    public float Size { get; set; }
    public float Price { get; set; }
}
Console.WriteLine("Classe HouseData definie (Size, Price)");
Classe HouseData definie (Size, Price)

Définissez ensuite la structure de données pour les prédictions de prix des maisons :

public class Prediction
{
    [ColumnName("Score")]
    public float Price { get; set; }
}
Console.WriteLine("Classe Prediction definie (Score -> Price)");
Classe Prediction definie (Score -> Price)

Maintenant, nous sommes prêts à entraîner les données pré-collectées que nous utiliserons pour le scénario de prédiction des prix des maisons :

HouseData[] houseData = {
    new HouseData() { Size = 1.1F, Price = 1.2F },
    new HouseData() { Size = 1.9F, Price = 2.3F },
    new HouseData() { Size = 2.8F, Price = 3.0F },
    new HouseData() { Size = 3.4F, Price = 3.7F }
};

IDataView trainingData = mlContext.Data.LoadFromEnumerable(houseData);
Console.WriteLine($"Donnees d'entrainement chargees : {houseData.Length} exemples");
Donnees d'entrainement chargees : 4 exemples

En utilisant le MLContext que nous avons précédemment créé, chargez les données d’entraînement dans le IDataView ML.NET, qui est le type de données fondamental de ML.NET.

Maintenant que nous avons les données prêtes, nous allons créer le pipeline ML.NET en spécifiant le formateur que nous allons utiliser pour construire notre modèle de machine learning. Pour la prédiction des prix des maisons, nous allons utiliser le formateur de régression. ML.NET prend en charge d’autres formateurs de machine learning qui peuvent être utilisés pour d’autres scénarios selon les besoins. Le pipeline créera ce que l’on appelle un Estimator, utilisé pour définir les opérations appliquées aux données.

var pipeline = mlContext.Transforms.Concatenate("Features", new[] { "Size" })
               .Append(mlContext.Regression.Trainers.Sdca(labelColumnName: "Price", maximumNumberOfIterations: 100));
Console.WriteLine("Pipeline ML.NET cree : Concatenate + SDCA Regression");
Pipeline ML.NET cree : Concatenate + SDCA Regression

Après avoir créé l’estimateur, nous sommes prêts à appliquer les transformations et le formateur définis dans le pipeline aux données. Pour ce faire, appelez la méthode Fit.

var model = pipeline.Fit(trainingData);
Console.WriteLine("Modele entraite avec succes");
Modele entraite avec succes

Maintenant, nous pouvons évaluer le modèle entraîné. Pour ce faire, nous chargerons des données de test préparées et ensuite nous appellerons la méthode [Evaluate](https://docs.microsoft.com/dotnet/api/microsoft.ml.regression

catalog.evaluate?view=ml-dotnet), puis nous afficherons le Coefficient de Détermination pour savoir comment le modèle s’ajuste aux données de test. Plus le coefficient de détermination est proche de 1, mieux le modèle est ajusté. Répétez les étapes d’entraînement et d’évaluation jusqu’à obtenir un résultat satisfaisant du modèle entraîné.

HouseData[] testData = {
    new HouseData() { Size = 1.1F, Price = 1.2F },
    new HouseData() { Size = 1.2F, Price = 1.5F },
    new HouseData() { Size = 1.4F, Price = 1.7F },
    new HouseData() { Size = 1.6F, Price = 1.9F },
    new HouseData() { Size = 1.9F, Price = 2.3F },
    new HouseData() { Size = 2.8F, Price = 3.0F },
    new HouseData() { Size = 3.2F, Price = 3.5F },
    new HouseData() { Size = 3.3F, Price = 3.6F },
    new HouseData() { Size = 3.5F, Price = 3.9F },
    new HouseData() { Size = 3.7F, Price = 4.3F },
    new HouseData() { Size = 4.0F, Price = 6.1F },
    new HouseData() { Size = 5.0F, Price = 7.2F },
    new HouseData() { Size = 6.0F, Price = 8.5F },
    new HouseData() { Size = 7.0F, Price = 9.8F },
    new HouseData() { Size = 8.0F, Price = 10.3F }
    };

IDataView trainingTestData = mlContext.Data.LoadFromEnumerable(testData);
IDataView transformedTestData = model.Transform(trainingTestData);
RegressionMetrics trainedModelMetrics = mlContext.Regression.Evaluate(transformedTestData, labelColumnName: "Price");
Console.WriteLine($"Coefficient de détermination pour le modèle entraîné : {trainedModelMetrics.RSquared:0.00}");
Coefficient de détermination pour le modèle entraîné : 0,85

Interpretation : Evaluation du modèle de regression

résultat obtenu : Le coefficient de determination R² (Wright, 1921) = 0,85 indique que le modèle explique 85 % de la variance des données de test — un ajustement correct, mais non parfait.

Metrique Valeur Signification
R² 0,85 Ajustement correct (85 % de variance expliquée)
données d’entrainement 4 exemples Dataset minimal pour une demonstration
données de test 15 exemples Couvrent la plage 1,1 a 8,0 en taille

Points cles :

  1. R² de 0,85, pas 1 : Le modèle linéaire, entraîné sur 4 points seulement (tailles 1,1 à 3,4), doit extrapoler vers les grandes maisons (jusqu’à 8,0) où le prix au pied carré augmente (effet « premium ») — une relation légèrement non linéaire qu’une droite ne capture pas parfaitement
  2. Biais potentiel : Les données d’entrainement et de test se chevauchent partiellement, ce qui peut surerestimer la qualite du modèle
  3. Generalisation : Un R² eleve sur un petit dataset ne garantit pas la performance sur des données reelles plus complexes

Maintenant, nous avons le modèle entraîné prêt pour la prédiction. Utilisons ce modèle pour prédire le prix d’une maison. Pour ce faire, créez l’objet PredictionEngine<TSrc,TDst>. Le moteur de prédiction est la classe utilisée pour faire des prédictions uniques sur un modèle précédemment entraîné (et le pipeline de transformation précédent). La création du moteur de prédiction à partir du modèle entraîné peut se faire avec le code suivant :

var predictionEngine = mlContext.Model.CreatePredictionEngine<HouseData, Prediction>(model);
Console.WriteLine("PredictionEngine cree");
PredictionEngine cree

Ensuite, en utilisant le moteur de prédiction créé, nous pouvons prédire le prix de la maison comme suit :

var size = new HouseData() { Size = 2.5F };
var price = predictionEngine.Predict(size);
Console.WriteLine($"Prix prédit pour une taille de {size.Size * 1000} pieds carrés : {price.Price * 100:C}k");
Prix prédit pour une taille de 2500 pieds carrés : 276,18 €k

Interprétation : la prédiction, l’interpolation et l’extrapolation

La prédiction de 276,18 €k pour 2 500 pieds carrés (Size = 2,5) tombe entre les données d’entraînement : le jeu d’apprentissage couvre les tailles 1,1 à 3,4 (soit 1 100 à 3 400 pieds carrés). Il s’agit d’une interpolation — la zone où un modèle linéaire est le plus fiable, car il n’a pas à deviner la pente au-delà de ce qu’il a vu.

La droite apprise passe environ par Prix ≈ 1,05 × Size + 0,14 (soit ~2,76 à Size = 2,5, ce qui correspond bien à la sortie ci-dessus). À l’inverse, les données de test s’étendent jusqu’à Size = 8,0 (8 000 pieds carrés), largement au-delà de la plage d’entraînement : c’est de l’extrapolation. Les grands points de test s’écartent alors de la droite :

Size Prix réel (test) Prix prédit par la droite Écart
4,0 6,1 ~4,3 sous-estimé
8,0 10,3 ~8,5 sous-estimé

Le vrai prix monte plus vite qu’une ligne droite — effet « premium » des grandes surfaces. C’est précisément ce phénomène non linéaire qui plafonne le R² à 0,85 plutôt qu’à 1 : la droite, ajustée sur le segment 1,1–3,4, sous-estime systématiquement les grandes maisons.

Règle pratique : un modèle de régression linéaire mérite une confiance élevée à l’intérieur du domaine d’entraînement (interpolation) et doit être utilisé avec prudence dès qu’on extrapole au-delà. C’est pourquoi la prédiction à 2 500 pieds carrés est crédible, tandis qu’une prédiction pour 9 000 pieds carrés le serait beaucoup moins.

Félicitations ! Vous avez entraîné avec succès un modèle de régression ML.NET en utilisant vos propres données, puis utilisé ce modèle pour prédire les prix des maisons. Voici un diagramme résumant l’opération de bout en bout de création et d’entraînement d’un modèle ML.NET, puis de l’utiliser pour prédire les prix des maisons.

ML.NET Workflow

Module suivant

Module Suivant - Préparation des Données et Ingénierie des Caractéristiques

Exemple guide 2 : Prediction de temps de trajet

Soumis par Robin Lamy (Gr02)

modèle de regression ML.NET pour predire le temps de trajet en fonction de la distance. Utilise un dataset personnalise TripData et le trainer SDCA avec normalisation.

// Exemple guide 2 - Prediction temps de trajet (Robin Lamy, Gr02)

public class TripData
{
    public float Distance { get; set; }
    public float Temps { get; set; }
}

public class TripPrediction
{
    [ColumnName("Score")]
    public float Temps { get; set; }
}

var mlContext = new MLContext(seed: 0);

var tripData = new List<TripData>
{
    new TripData { Distance = 5f, Temps = 15f },
    new TripData { Distance = 10f, Temps = 30f },
    new TripData { Distance = 14f, Temps = 41f },
    new TripData { Distance = 20f, Temps = 60f },
    new TripData { Distance = 26f, Temps = 79f },
    new TripData { Distance = 32f, Temps = 95f },
    new TripData { Distance = 40f, Temps = 121f }
};

IDataView trainingData = mlContext.Data.LoadFromEnumerable(tripData);

var pipeline = mlContext.Transforms.Concatenate("Features", nameof(TripData.Distance))
    .Append(mlContext.Transforms.NormalizeMeanVariance("Features"))
    .Append(mlContext.Regression.Trainers.Sdca(
        new Microsoft.ML.Trainers.SdcaRegressionTrainer.Options
        {
            LabelColumnName = nameof(TripData.Temps),
            FeatureColumnName = "Features",
            MaximumNumberOfIterations = 1000
        }));

var model = pipeline.Fit(trainingData);
var predictionEngine = mlContext.Model.CreatePredictionEngine<TripData, TripPrediction>(model);

var distanceTest = new TripData { Distance = 25f };
var tempsPrevu = predictionEngine.Predict(distanceTest);
Console.WriteLine($"Temps predit pour 25 km : {tempsPrevu.Temps:F1} minutes");
Temps predit pour 25 km : 69,4 minutes

Exemple guide 3 : Classification binaire de transactions

Soumis par Benoit Poulet (Gr03)

modèle de classification binaire ML.NET pour detecter si une transaction bancaire est suspecte. Utilise les features Montant et Heure avec le trainer SDCA Logistic Regression.

// Exemple guide 3 - Classification binaire de transactions (Benoit Poulet, Gr03)

using System;
using System.Collections.Generic;

public class TransactionData
{
    public float Montant { get; set; }
    public float Heure { get; set; }
    public bool IsSuspecte { get; set; }
}

public class TransactionPrediction
{
    [ColumnName("PredictedLabel")]
    public bool Prediction { get; set; }
    public float Probability { get; set; }
    public float Score { get; set; }
}

var mlContext = new MLContext(seed: 0);

var transactions = new List<TransactionData>
{
    new TransactionData { Montant = 120f, Heure = 9f, IsSuspecte = false },
    new TransactionData { Montant = 450f, Heure = 14f, IsSuspecte = false },
    new TransactionData { Montant = 50f, Heure = 11f, IsSuspecte = false },
    new TransactionData { Montant = 300f, Heure = 17f, IsSuspecte = false },
    new TransactionData { Montant = 200f, Heure = 15f, IsSuspecte = false },
    new TransactionData { Montant = 490f, Heure = 8f, IsSuspecte = false },
    new TransactionData { Montant = 2500f, Heure = 2f, IsSuspecte = true },
    new TransactionData { Montant = 3100f, Heure = 4f, IsSuspecte = true },
    new TransactionData { Montant = 4000f, Heure = 3f, IsSuspecte = true },
    new TransactionData { Montant = 2100f, Heure = 1f, IsSuspecte = true },
    new TransactionData { Montant = 5000f, Heure = 5f, IsSuspecte = true },
    new TransactionData { Montant = 2800f, Heure = 2.5f, IsSuspecte = true }
};

IDataView trainingData = mlContext.Data.LoadFromEnumerable(transactions);
var pipeline = mlContext.Transforms.Concatenate("Features", nameof(TransactionData.Montant), nameof(TransactionData.Heure))
    .Append(mlContext.Transforms.NormalizeMeanVariance("Features"))
    .Append(mlContext.BinaryClassification.Trainers.SdcaLogisticRegression(
        labelColumnName: nameof(TransactionData.IsSuspecte),
        featureColumnName: "Features"));

var model = pipeline.Fit(trainingData);
var predictions = model.Transform(trainingData);
var metrics = mlContext.BinaryClassification.Evaluate(data: predictions, labelColumnName: nameof(TransactionData.IsSuspecte));

Console.WriteLine("\n--- Evaluation du Modele ---");
Console.WriteLine($"Precision (Accuracy) : {metrics.Accuracy:P2}");
Console.WriteLine($"Aire sous la courbe (AUC) : {metrics.AreaUnderRocCurve:P2}");

var predictionEngine = mlContext.Model.CreatePredictionEngine<TransactionData, TransactionPrediction>(model);
Console.WriteLine("\n--- Tests de Prediction ---");
var testSuspect = new TransactionData { Montant = 3500f, Heure = 3f };
var predSuspect = predictionEngine.Predict(testSuspect);
Console.WriteLine($"Test 1 (Montant={testSuspect.Montant}, Heure={testSuspect.Heure}h) -> Suspecte ? {predSuspect.Prediction} (Probabilite : {predSuspect.Probability:P2})");
var testNormal = new TransactionData { Montant = 150f, Heure = 10f };
var predNormal = predictionEngine.Predict(testNormal);
Console.WriteLine($"Test 2 (Montant={testNormal.Montant}, Heure={testNormal.Heure}h) -> Suspecte ? {predNormal.Prediction} (Probabilite : {predNormal.Probability:P2})");

--- Evaluation du Modele ---
Precision (Accuracy) : 100,00 %
Aire sous la courbe (AUC) : 100,00 %

--- Tests de Prediction ---
Test 1 (Montant=3500, Heure=3h) -> Suspecte ? True (Probabilite : 99,99 %)
Test 2 (Montant=150, Heure=10h) -> Suspecte ? False (Probabilite : 0,04 %)

Interpretation : Evaluation du modèle de classification

résultats obtenus : Le modèle de classification binaire atteint une precision parfaite sur les données de test.

Metrique Valeur Signification
Accuracy 100 % Toutes les transactions sont correctement classees
AUC 100 % Separation parfaite entre transactions normales et suspectes
Probabilite suspecte 99,99 % Forte confiance pour Montant=3500, Heure=3h
Probabilite normale ~0,04 % Forte confiance pour Montant=150, Heure=10h

Points cles :

  1. Separation nette : Les transactions suspectes (montant eleve + heures nocturnes) sont clairement distinctes des normales dans ce jeu de données
  2. Surapprentissage probable : Performance parfaite sur les données d’entrainement — un jeu de test indépendant serait necessaire pour evaluer la generalisation
  3. Features discriminantes : Le montant et l’heure suffisent a separer les deux classes dans cet exemple simplifie
  4. Limites : En conditions reelles, les motifs de fraude sont plus subtils et les données sont souvent fortement desequilibrees
  5. Variance d’execution : la probabilite exacte pour une transaction normale fluctue d’une execution a l’autre (observe entre ~0,04 % et ~0,11 % sur 3 runs, malgre new MLContext(seed: 0) – SDCA n’est pas pleinement deterministe). Seul l’ordre de grandeur (bien inferieur a 1 %) est stable ; la decision de classification (False) ne change pas.

Exercices supplémentaires

Les exercices suivants approfondissent les concepts vus dans ce notebook. Ils utilisent les données et le contexte ML.NET définis precedemment.

Exercice 1 : Analyse de l’importance des features

Entrainement d’un modèle de regression, puis analyse de l’importance relative de chaque feature avec PermutationFeatureImportance (PFI).

Objectifs : 1. Reutiliser le MLContext et les données HouseData définis precedemment 2. Entrainer un modèle de regression (SDCA ou FastTree) 3. Appeler PermutationFeatureImportance pour classer les features par impact 4. Afficher les résultats tries par importance decroissante

Indice : Utilisez mlContext.Regression.PermutationFeatureImportance(model, data, permutationCount: 3). Chaque résultat contient un dictionnaire de metriques par feature.

// Exercice 1 : Analyse de l'importance des features
// TODO etudiant : Entrainez un modele et analysez l'importance des features
// Indice : utilisez mlContext.Regression.PermutationFeatureImportance()
// Etape 1 : reutilisez le MLContext et les donnees HouseData definis plus haut
// Etape 2 : entrainez un modele FastTree ou SDCA sur les donnees de test
// Etape 3 : appelez PermutationFeatureImportance pour obtenir les scores
// Etape 4 : affichez les features triees par importance (descroissante)
// var featureImportance = ... // TODO etudiant : resultat PFI
Console.WriteLine("Exercice a completer : analyse de l'importance des features");
Exercice a completer : analyse de l'importance des features

Exercice 2 : Exploration statistique des données

créez un DataFrame avec des données d’employes et calculez des statistiques descriptives pour mieux comprendre vos données avant l’entrainement.

Objectifs : 1. créer un DataFrame avec des colonnes numériques (expérience, salaire) et categorielles (departement, niveau) 2. Calculer les statistiques descriptives (moyenne, ecart-type, min, max) pour chaque colonne numérique 3. Compter les valeurs uniques pour les colonnes categorielles 4. Afficher un resume structure des résultats

Indice : Utilisez DataFrameColumn.Create() pour construire le DataFrame, puis les méthodes .Mean(), .StandardDeviation(), .Min(), .Max() sur chaque colonne.

// Exercice 2 : Exploration statistique des donnees
// TODO etudiant : Utilisez DataFrame pour calculer des statistiques descriptives
// Indice : DataFrame.LoadCsv() puis df[\"col\"].Mean(), df[\"col\"].StdDev(), df[\"col\"].Min(), df[\"col\"].Max()
// Etape 1 : creer un DataFrame avec des donnees d'employes (experience, education, taille societe, salaire)
// Etape 2 : calculer mean, std, min, max pour chaque colonne numerique
// Etape 3 : compter les valeurs uniques pour les colonnes categorielles
// Etape 4 : afficher un resume sous forme de tableau

Console.WriteLine("Exercice a completer : exploration statistique des donnees");
Exercice a completer : exploration statistique des donnees

Exercice : Regression multi-features - Prediction de salaire

créez un modèle ML.NET de regression pour predire le salaire annuel d’un employe en fonction de plusieurs caractéristiques.

Objectifs

  1. définir une classe EmployeeData avec les features :
    • AnneeExperience (float)
    • NiveauEducation (float : 1=Bac, 2=Master, 3=PhD)
    • TailleSociete (float : 1=PME, 2=Grande, 3=CAC40)
    • Salaire (float, le label a predire)
  2. définir SalairePrediction avec [ColumnName("Score")] public float Salaire
  3. créer un dataset de 10+ employes avec des salaires realistes (30k-120k)
  4. Construire un pipeline : Concatenate + NormalizeMeanVariance + Sdca (regression)
  5. Evaluer avec mlContext.Regression.Evaluate() : afficher R², MAE, RMSE
  6. Predire pour : 5 ans expérience, Master (2), Grande societe (2)

Indice : Utilisez mlContext.Regression.Trainers.Sdca(labelColumnName: nameof(EmployeeData.Salaire))

// Exercice : Regression multi-features - Prediction de salaire
Console.WriteLine("Exercice a completer");

// TODO: Definir EmployeeData avec AnneeExperience (float), NiveauEducation (float),
//       TailleSociete (float), Salaire (float)


// TODO: Definir SalairePrediction
// Indice: [ColumnName("Score")] public float Salaire


// TODO: Creer un dataset de 10+ employes
// Exemples de valeurs :
//   {AnneeExperience=2, NiveauEducation=1, TailleSociete=1, Salaire=32000}
//   {AnneeExperience=10, NiveauEducation=3, TailleSociete=3, Salaire=110000}


// TODO: Construire le pipeline (Concatenate + NormalizeMeanVariance + Sdca Regression)
// Indice: mlContext.Regression.Trainers.Sdca(labelColumnName: nameof(EmployeeData.Salaire))


// TODO: Entrainer le modele et evaluer
// Afficher: metrics.RSquared, metrics.MeanAbsoluteError, metrics.RootMeanSquaredError


// TODO: Predire le salaire pour AnneeExperience=5, NiveauEducation=2 (Master), TailleSociete=2 (Grande)
Exercice a completer

Résumé

Ce notebook a introduit les bases de ML.NET :

Concept Description
MLContext Point d’entrée pour toutes les opérations ML.NET
IDataView Structure de données colonnaire pour le ML
Pipeline Enchaînement transformations + trainer
PredictionEngine Moteur de prédiction pour l’inférence

Points clés : - ML.NET suit un workflow en 4 étapes : Données -> Entraînement -> Evaluation -> Prédiction - L’algorithme SDCA (Stochastic Dual Coordinate Ascent, Shalev-Shwartz & Zhang, 2013) est adapté aux problèmes de régression linéaire - Le coefficient R² mesure la qualité de l’ajustement (1.0 = parfait)

Navigation : Index | Suivant >> ML-2 Data & Features

Références

Algorithme (SDCA) - Shalev-Shwartz, S., & Zhang, T. (2013). Stochastic Dual Coordinate Ascent Methods for Regularized Loss Minimization. Journal of Machine Learning Research, 14, 567-599. — algorithme SDCA, trainer linéaire par défaut de ML.NET pour la régression et la classification.

Métriques d’évaluation - Wright, S. (1921). Correlation and Causation. Journal of Agricultural Research, 20(7), 557-585. — coefficient de détermination R². - Fawcett, T. (2006). An Introduction to ROC Analysis. Pattern Recognition Letters, 27(8), 861-874. — courbe ROC et aire sous la courbe (AUC), utilisée pour l’évaluation de la classification binaire.

Framework (ML.NET) - Ahmed, Z., Amizadeh, S., Bilenko, M., et al. (2019). DOI: 10.1145/3292500.3330667 — Machine Learning at Microsoft with ML.NET. ACM SIGKDD (KDD). — framework ML.NET utilisé tout au long du notebook.

Automated Machine Learning (AutoML) - Hutter, F., Kotthoff, L., & Vanschoren, J. (2019). Automated Machine Learning: Methods, Systems, Challenges. Springer. — mentionné comme approche de sélection automatique d’algorithmes.

Retour au sommet