Tutoriel : Catégoriser les fleurs d’iris à l’aide d’un clustering par k-moyennes avec ML.NET

Ce tutoriel montre comment utiliser ML.NET pour créer un modèle de clustering pour le jeu de données de fleur d’iris.

Dans ce tutoriel, vous allez apprendre à :

Comprendre le problème
Sélectionner la tâche machine learning appropriée
Préparer les données
Charger et transformer les données
Choisir un algorithme d’apprentissage
Entraîner le modèle
Utiliser le modèle pour les prédictions

Prerequisites

Visual Studio 2022 ou version ultérieure.

Comprendre le problème

Ce problème consiste à diviser l’ensemble de fleurs d’iris dans différents groupes en fonction des caractéristiques des fleurs. Ces caractéristiques sont la longueur et la largeur d’un sépale et la longueur et la largeur d’un pétale. Pour ce tutoriel, supposons que le type de chaque fleur est inconnu. Vous souhaitez apprendre la structure d’un jeu de données à partir des fonctionnalités et prédire la façon dont une instance de données correspond à cette structure.

Sélectionner la tâche machine learning appropriée

Comme vous ne savez pas quel groupe appartient à chaque fleur, vous choisissez la tâche Machine Learning non supervisée . Pour diviser un jeu de données dans des groupes de manière à ce que les éléments du même groupe soient plus similaires à ceux d’autres groupes, utilisez une tâche de machine learning de clustering .

Création d’une application console

Créez une application console C# appelée « IrisFlowerClustering ». Cliquez sur le bouton Suivant .
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 :

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Ajouter>un nouveau dossier. Tapez « Données », puis sélectionnez Entrée.
Installez le package NuGet Microsoft.ML :

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 et 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.

Préparer les données

Téléchargez le jeu de données iris.data et enregistrez-le dans le dossier Données que vous avez créé à l’étape précédente. Pour plus d’informations sur le jeu de données iris, consultez la page Wikipédia du jeu de données des fleurs d’Iris et la page Jeu de données Iris, qui est la source du jeu de données.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le fichier iris.data et 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.

Le fichier iris.data contient cinq colonnes qui représentent :

longueur sépale en centimètres
largeur du sépale en centimètres
Longueur pétale en centimètres
Largeur pétale en centimètres
type de fleur d’iris

Pour l’exemple de clustering, ce didacticiel ignore la dernière colonne.

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 IrisData.cs. Ensuite, sélectionnez Ajouter.
Ajoutez la directive suivante using au nouveau fichier :
```
using Microsoft.ML.Data;
```

Supprimez la définition de classe existante et ajoutez le code suivant, qui définit les classes IrisData et ClusterPrediction, au fichier IrisData.cs :

public class IrisData
{
    [LoadColumn(0)]
    public float SepalLength;

    [LoadColumn(1)]
    public float SepalWidth;

    [LoadColumn(2)]
    public float PetalLength;

    [LoadColumn(3)]
    public float PetalWidth;
}

public class ClusterPrediction
{
    [ColumnName("PredictedLabel")]
    public uint PredictedClusterId;

    [ColumnName("Score")]
    public float[]? Distances;
}

IrisData est la classe de données d’entrée et a des définitions pour chaque fonctionnalité du jeu de données. Utilisez l’attribut LoadColumn pour spécifier les index des colonnes sources dans le fichier de jeu de données.

La ClusterPrediction classe représente la sortie du modèle de clustering appliqué à une IrisData instance. Utilisez l’attribut ColumnName pour lier les PredictedClusterId champs Distances aux colonnes PredictedLabel et Score respectivement. Dans le cas de la tâche de clustering, ces colonnes ont la signification suivante :

La colonne PredictedLabel contient l’ID du cluster prédit.
La colonne score contient un tableau avec des distances euclidees carrées vers les centroïdes du cluster. La longueur du tableau est égale au nombre de clusters.

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

Revenez au fichier Program.cs et ajoutez deux champs pour contenir les chemins d’accès au fichier de jeu de données et au fichier pour enregistrer le modèle :

_dataPath contient le chemin d’accès au fichier avec le jeu de données utilisé pour entraîner 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 sous les using directives pour spécifier ces chemins d’accès :

string _dataPath = Path.Combine(Environment.CurrentDirectory, "Data", "iris.data");
string _modelPath = Path.Combine(Environment.CurrentDirectory, "Data", "IrisClusteringModel.zip");

Créer un contexte ML

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

using Microsoft.ML;
using IrisFlowerClustering;

Remplacez la Console.WriteLine("Hello World!"); ligne par le code suivant :

var mlContext = new MLContext(seed: 0);

La Microsoft.ML.MLContext classe représente l’environnement Machine Learning et fournit des mécanismes pour la journalisation et les points d’entrée pour le chargement des données, l’entraînement du modèle, la prédiction et d’autres tâches. Cela est comparable conceptuellement à l’utilisation DbContext dans Entity Framework.

Configurer le chargement des données

Ajoutez le code suivant ci-dessous MLContext pour configurer la façon de charger des données :

IDataView dataView = mlContext.Data.LoadFromTextFile<IrisData>(_dataPath, hasHeader: false, separatorChar: ',');

La méthode d’extension génériqueMLContext.Data.LoadFromTextFile déduit le schéma du jeu de données à partir du type fourni IrisData et retourne IDataView qui peut être utilisé comme entrée pour les transformateurs.

Créer un pipeline d’apprentissage

Pour ce tutoriel, le pipeline d’apprentissage de la tâche de clustering comprend deux étapes suivantes :

concaténer des colonnes chargées en une seule colonne Caractéristiques , utilisée par un formateur de clustering ;
utilisez un KMeansTrainer formateur pour entraîner le modèle à l’aide de l’algorithme de clustering k-moyennes++.

Ajoutez les éléments suivants après le chargement des données :

string featuresColumnName = "Features";
var pipeline = mlContext.Transforms
    .Concatenate(featuresColumnName, "SepalLength", "SepalWidth", "PetalLength", "PetalWidth")
    .Append(mlContext.Clustering.Trainers.KMeans(featuresColumnName, numberOfClusters: 3));

Le code spécifie que le jeu de données doit être divisé en trois clusters.

Entraîner le modèle

Les étapes ajoutées dans les sections précédentes ont préparé le pipeline pour l’entraînement, mais aucune n’a été exécutée. Ajoutez la ligne suivante en bas du fichier pour effectuer le chargement des données et l’entraînement du modèle :

var model = pipeline.Fit(dataView);

Enregistrer le modèle

À ce stade, vous disposez d’un modèle qui peut être intégré à l’une de vos applications .NET existantes ou nouvelles. Pour enregistrer votre modèle dans un fichier .zip, ajoutez le code suivant ci-dessous appelant la Fit méthode :

using (var fileStream = new FileStream(_modelPath, FileMode.Create, FileAccess.Write, FileShare.Write))
{
    mlContext.Model.Save(model, dataView.Schema, fileStream);
}

Utiliser le modèle pour les prédictions

Pour effectuer des prédictions, utilisez la PredictionEngine<TSrc,TDst> classe qui prend des instances du type d’entrée via le pipeline de transformateur et produit des instances du type de sortie. Ajoutez la ligne suivante pour créer une instance de cette classe :

var predictor = mlContext.Model.CreatePredictionEngine<IrisData, ClusterPrediction>(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.

Créez la TestIrisData classe pour héberger des instances de données de test :

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 TestIrisData.cs. Ensuite, sélectionnez Ajouter.
Modifiez la classe pour qu'elle soit statique, comme dans l'exemple suivant :
```
static class TestIrisData
```

Ce didacticiel présente une instance de données iris au sein de cette classe. Vous pouvez ajouter d’autres scénarios pour expérimenter le modèle. Ajoutez le code suivant dans la TestIrisData classe :

internal static readonly IrisData Setosa = new IrisData
{
    SepalLength = 5.1f,
    SepalWidth = 3.5f,
    PetalLength = 1.4f,
    PetalWidth = 0.2f
};

Pour connaître le cluster auquel appartient l’élément spécifié, revenez au fichier Program.cs et ajoutez le code suivant en bas du fichier :

var prediction = predictor.Predict(TestIrisData.Setosa);
Console.WriteLine($"Cluster: {prediction.PredictedClusterId}");
Console.WriteLine($"Distances: {string.Join(" ", prediction.Distances ?? Array.Empty<float>())}");

Exécutez le programme pour voir quel cluster contient l’instance de données spécifiée et les distances carrées entre cette instance et les centroïdes du cluster. Vos résultats doivent être similaires à ce qui suit :

Cluster: 2
Distances: 11.69127 0.02159119 25.59896

Félicitations! Vous avez maintenant créé un modèle d'apprentissage automatique pour le regroupement d'iris et l'avez utilisé pour 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 à :

Comprendre le problème
Sélectionner la tâche machine learning appropriée
Préparer les données
Charger et transformer les données
Choisir un algorithme d’apprentissage
Entraîner le modèle
Utiliser le modèle pour les prédictions

Consultez le référentiel GitHub dotnet/machinelearning pour poursuivre l’apprentissage et trouver d’autres exemples.

dépôt GitHub dotnet/machinelearning

Rétroaction

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

Last updated on 2025-12-06