Comment utiliser l’API Machine Learning automatisé (AutoML) ML.NET

Dans cet article, vous allez apprendre à utiliser l’API de ML automatisé (AutoML) ML.NET.

Vous trouverez des exemples sur l’API AutoML dans le référentiel dotnet/machinelearning-samples.

Installation

Pour utiliser l’API AutoML, installez le package NuGet Microsoft.ML.AutoML dans le projet .NET qui devra y faire référence.

Notes

Ce guide utilise la version 0.20.0 (et les versions ultérieures) du package NuGet Microsoft.ML.AutoML. Bien que les exemples et le code des versions antérieures fonctionnent toujours, il est vivement recommandé d’utiliser les API introduites dans cette version pour les nouveaux projets.

Pour plus d’informations sur l’installation des packages NuGet, consultez les guides suivants :

• Installer et utiliser un package NuGet dans Visual Studio
• Installer et utiliser un package (interface CLI dotnet)

Démarrage rapide

AutoML fournit plusieurs valeurs par défaut pour effectuer rapidement l’apprentissage des modèles Machine Learning. Dans cette section, vous allez apprendre à mener à bien les actions suivantes :

• Charger vos données
• Définir votre pipeline
• Configurer votre expérience
• Exécuter votre expérience
• Utiliser le meilleur modèle pour élaborer des prédictions

Définir votre problème

Prenons un jeu de données stocké dans un fichier séparé par des virgules appelé taxi-fare-train.csv :

vendor_id	rate_code	passenger_count	trip_time_in_secs	trip_distance	payment_type	fare_amount
CMT	1	1	1271	3.8	CRD	17.5
CMT	1	1	474	1.5	CRD	8
CMT	1	1	637	1.4	CRD	8.5

Charger vos données

Commencez par initialiser votre MLContext. MLContext constitue le point de départ de toutes les opérations ML.NET. En l’initialisant, vous créez un environnement ML.NET qui peut être partagé par les objets du workflow de création de modèle. Sur le plan conceptuel, elle est similaire à DBContext dans Entity Framework.

Ensuite, pour charger vos données, utilisez la méthode InferColumns.

// Initialize MLContext
MLContext ctx = new MLContext();

// Define data path
var dataPath = Path.GetFullPath(@"..\..\..\..\Data\taxi-fare-train.csv");

// Infer column information
ColumnInferenceResults columnInference =
    ctx.Auto().InferColumns(dataPath, labelColumnName: "fare_amount", groupColumns: false);

InferColumns charge quelques lignes du jeu de données. Elle inspecte ensuite les données et tente de deviner ou de déduire le type de données de chacune des colonnes en fonction de leur contenu.

Le comportement par défaut consiste à regrouper les colonnes du même type dans des vecteurs de caractéristiques ou des tableaux contenant les éléments de chacune des colonnes. Si groupColumns est défini sur false, ce comportement est remplacé par une simple inférence de colonne, sans regroupement. En conservant les colonnes distinctes, vous pouvez appliquer différentes transformations de données lors de leur prétraitement au niveau de chaque colonne plutôt qu’au niveau du regroupement de colonnes.

Le résultat de InferColumns est un objet ColumnInferenceResults qui contient les options nécessaires pour créer un TextLoader ainsi que des informations de colonne.

Dans l’exemple de jeu de données taxi-fare-train.csv, les informations de colonne pourraient être les suivantes :

• LabelColumnName : fare_amount
• CategoricalColumnNames : vendor_id, payment_type
• NumericColumnNames : rate_code, passenger_count, trip_time_in_secs, trip_distance

Une fois que vous disposez de vos informations de colonne, utilisez TextLoader.Options (défini par ColumnInferenceResults) pour créer un TextLoader permettant charger vos données dans un IDataView.

// Create text loader
TextLoader loader = ctx.Data.CreateTextLoader(columnInference.TextLoaderOptions);

// Load data into IDataView
IDataView data = loader.Load(dataPath);

Il est souvent recommandé de fractionner les données en un jeu d’apprentissage et un jeu de validation. Utilisez TrainTestSplit pour créer une répartition 80 % apprentissage, 20 % validation dans votre jeu de données.

TrainTestData trainValidationData = ctx.Data.TrainTestSplit(data, testFraction: 0.2);

Définition du pipeline

Votre pipeline définit les étapes de traitement des données et le pipeline Machine Learning à utiliser pour effectuer l’apprentissage de votre modèle.

SweepablePipeline pipeline =
    ctx.Auto().Featurizer(data, columnInformation: columnInference.ColumnInformation)
        .Append(ctx.Auto().Regression(labelColumnName: columnInference.ColumnInformation.LabelColumnName));

Un SweepablePipeline est une collection de SweepableEstimator. Un SweepableEstimator est un Estimator ML.NET avec un SearchSpace.

Featurizer est une API pratique qui génère un pipeline balayable d’estimateurs de traitement des données en fonction des informations de colonne fournies. Au lieu de créer un pipeline à partir de zéro, Featurizer automatise l’étape de prétraitement des données. Pour plus d’informations sur les transformations prises en charge par ML.NET, consultez le guide des transformations de données.

La sortie Featurizer consiste en une seule colonne contenant un vecteur de caractéristiques numérique qui représente les données transformées pour chacune des colonnes. Ce vecteur de caractéristiques est ensuite utilisé comme entrée dans les algorithmes servant à effectuer l’apprentissage d’un modèle Machine Learning.

Si vous souhaitez contrôler plus finement le prétraitement de vos données, vous pouvez créer un pipeline comportant chacune des étapes de prétraitement. Pour plus d’informations, consultez le guide Préparation des données pour la création d’un modèle.

Conseil

Utilisez Featurizer avec ColumnInferenceResults pour optimiser l’utilité d’AutoML.

En ce qui concerne l’apprentissage, AutoML fournit un pipeline balayable avec des entraîneurs par défaut et des configurations d’espace de recherche pour les tâches Machine Learning suivantes :

• BinaryClassification
• MultiClassification
• Regression

Dans le problème de prédiction des tarifs de taxi, utilisez Regressiondans la mesure où l’objectif consiste à prédire une valeur numérique. Pour plus d’informations sur le choix d’une tâche, consultez Tâches Machine Learning dans ML.NET

Configurer votre expérience

Tout d’abord, créez une expérience AutoML. Une AutoMLExperiment est une collection de TrialResult.

AutoMLExperiment experiment = ctx.Auto().CreateExperiment();

Une fois votre expérience créée, utilisez les méthodes d’extension qu’elle fournit pour configurer différents paramètres.

experiment
    .SetPipeline(pipeline)
    .SetRegressionMetric(RegressionMetric.RSquared, labelColumn: columnInference.ColumnInformation.LabelColumnName)
    .SetTrainingTimeInSeconds(60)
    .SetDataset(trainValidationData);

Dans cet exemple, vous effectuez les opérations suivantes :

• Définissez le pipeline balayable à exécuter pendant l’expérience en appelant SetPipeline.
• Choisissez RSquared comme métrique à optimiser pendant l’apprentissage en appelant SetRegressionMetric. Pour plus d’informations sur les métriques d’évaluation, consultez le guide Évaluation d’un modèle ML.NET avec des métriques.
• Fixez à 60 secondes le temps d’apprentissage en appelant SetTrainingTimeInSeconds. La taille des données constitue une bonne heuristique pour déterminer cette durée. En règle générale, plus les jeux de données sont volumineux, plus l’apprentissage est long. Pour plus d’informations, consultez Conseils sur le temps d’apprentissage.
• Fournissez les jeux de données d’apprentissage et de validation à utiliser en appelant SetDataset.

Une fois l’expérience définie, il est important de suivre sa progression. Le moyen le plus rapide consiste à modifier l’événement Log de MLContext.

// Log experiment trials
ctx.Log += (_, e) => {
    if (e.Source.Equals("AutoMLExperiment"))
    {
        Console.WriteLine(e.RawMessage);
    }
};

Exécuter votre expérience

Maintenant que vous avez défini votre expérience, utilisez la méthode RunAsync pour la lancer.

TrialResult experimentResults = await experiment.RunAsync();

Il en résulte, une fois le temps d’apprentissage expiré, un TrialResult du meilleur modèle trouvé pendant l’apprentissage.

À ce stade, vous pouvez enregistrer votre modèle ou l’utiliser pour effectuer des prédictions. Pour plus d’informations sur l’utilisation d’un modèle ML.NET, consultez les guides suivants :

• Enregistrer et charger des modèles entraînés
• Effectuer des prédictions avec un modèle entraîné

Modification des résultats de l’inférence de colonne

Étant donné que InferColumns ne charge qu’une partie des données, il est possible que des cas limites absents des exemples utilisés pour l’inférence des colonnes ne soient pas interceptés et que les types de données définis pour les colonnes se révèlent incorrects. Vous pouvez mettre à jour les propriétés de ColumnInformation pour tenir compte de ces cas de résultats inexacts.

Par exemple, dans le jeu de données des tarifs de taxi, les données de la colonne rate_code se présentent sous la forme d’un nombre. Toutefois, cette valeur numérique représente une catégorie. Par défaut, InferColumns place rate_code dans la propriété NumericColumnNames au lieu de CategoricalColumnNames. Étant donné que ces propriétés constituent des collections .NET, vous pouvez utiliser des opérations standard pour y ajouter et en supprimer des éléments.

Vous pouvez effectuer les opérations suivantes pour mettre à jour la valeur ColumnInformation de rate_code.

columnInference.ColumnInformation.NumericColumnNames.Remove("rate_code");
columnInference.ColumnInformation.CategoricalColumnNames.Add("rate_code");

Exclusion des entraîneurs

Par défaut, AutoML essaie plusieurs entraîneurs dans le cadre du processus d’apprentissage pour déterminer celui qui convient le mieux à vos données. Il est toutefois possible, tout au long du processus, que vous découvriez que certains entraîneurs utilisent trop de ressources de calcul ou ne fournissent pas de bonnes métriques d’évaluation. Vous avez la possibilité d’exclure des entraîneurs du processus d’apprentissage. Les entraîneurs utilisés dépendent de la tâche. Pour connaître la liste des entraîneurs pris en charge dans ML.NET, consultez le guide Tâches de Machine Learning dans ML.NET.

Par exemple, dans le scénario de régression des tarifs de taxi, définissez le paramètre useLgbm sur false pour exclure l’algorithme LightGBM.

ctx.Auto().Regression(labelColumnName: columnInference.ColumnInformation.LabelColumnName, useLgbm:false)

Le processus d’exclusion des entraîneurs fonctionne de la même façon dans d’autres tâches telles que la classification binaire et la classification multiclasse.

Personnalisation d’un estimateur balayable

Lorsque vous souhaitez personnaliser plus précisément les options d’estimateur incluses dans votre pipeline balayable, vous devez effectuer les opérations suivantes :

1. Initialiser un espace de recherche
2. Utiliser l’espace de recherche pour définir une fabrique personnalisée
3. Créer un estimateur balayable
4. Ajouter votre estimateur balayable à votre pipeline balayable

AutoML fournit un ensemble d’espaces de recherche préconfigurés pour les entraîneurs dans les tâches Machine Learning suivantes :

• BinaryClassification
• MultiClassification
• Regression

Dans cet exemple, l’espace de recherche utilisé concerne SdcaRegressionTrainer. Initialisez-le à l’aide de SdcaOption.

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Ensuite, utilisez l’espace de recherche pour définir une méthode de fabrique personnalisée permettant de créer le SdcaRegressionTrainer. Dans cet exemple, L1Regularization et L2Regularization sont toutes deux définies sur une valeur autre que la valeur par défaut. Pour L1Regularization, la valeur établie est déterminée par le paramétreur au cours de chaque test. L2Regularization est fixée pour tous les tests à la valeur codée en dur. Au cours de chaque test, la sortie de la fabrique personnalisée est un SdcaRegressionTrainer doté des hyperparamètres configurés.

// Use the search space to define a custom factory to create an SdcaRegressionTrainer
var sdcaFactory = (MLContext ctx, SdcaOption param) =>
{
    var sdcaOption = new SdcaRegressionTrainer.Options();
    sdcaOption.L1Regularization = param.L1Regularization;
    sdcaOption.L2Regularization = 0.02f;

    sdcaOption.LabelColumnName = columnInference.ColumnInformation.LabelColumnName;

    return ctx.Regression.Trainers.Sdca(sdcaOption);
};

Un estimateur balayable correspond à la combinaison d’un estimateur et d’un espace de recherche. Maintenant que vous avez défini un espace de recherche qui vous a servi à créer une méthode de fabrique personnalisée permettant de générer des entraîneurs, utilisez la méthode CreateSweepableEstimator pour créer un estimateur balayable.

// Define Sdca sweepable estimator (SdcaRegressionTrainer + SdcaOption search space)
var sdcaSweepableEstimator = ctx.Auto().CreateSweepableEstimator(sdcaFactory, sdcaSearchSpace);

Pour utiliser votre estimateur balayable dans votre expérience, ajoutez-le à votre pipeline balayable.

SweepablePipeline pipeline =
    ctx.Auto().Featurizer(data, columnInformation: columnInference.ColumnInformation)
        .Append(sdcaSweepableEstimator);

Étant donné que les pipelines balayables constituent une collection d’estimateurs balayables, vous pouvez configurer et personnaliser autant de ces estimateurs que nécessaire.

Personnalisation de l’espace de recherche

Il existe des scénarios qui impliquent d’aller au-delà de la personnalisation des estimateurs balayables utilisés dans l’expérience et de contrôler la plage de l’espace de recherche. Pour cela, accédez aux propriétés de l’espace de recherche à l’aide de clés. Le paramètre L1Regularization est, dans ce cas, un float. Par conséquent, utilisez UniformSingleOption pour personnaliser la plage de recherche.

sdcaSearchSpace["L1Regularization"] = new UniformSingleOption(min: 0.01f, max: 2.0f, logBase: false, defaultValue: 0.01f);

Selon le type de données de l’hyperparamètre que vous souhaitez définir, vous pouvez choisir parmi les options suivantes :

• Numéros
  • UniformIntOption
  • UniformSingleOption
  • UniformDoubleOption
• Booléens et chaînes :
  • ChoiceOption

Les espaces de recherche peuvent également contenir des espaces de recherche imbriqués.

var searchSpace = new SearchSpace();
searchSpace["SingleOption"] = new UniformSingleOption(min:-10f, max:10f, defaultValue=0f) 
var nestedSearchSpace = new SearchSpace();
nestedSearchSpace["IntOption"] = new UniformIntOption(min:-10, max:10, defaultValue=0);
searchSpace["Nest"] = nestedSearchSpace;

Une autre option pour personnaliser les plages de recherche consiste à les étendre. Par exemple, SdcaOption ne fournit que les paramètres L1Regularization et L2Regularization. SdcaRegressionTrainer, en revanche, propose d’autres paramètres à définir, notamment BiasLearningRate.

Pour étendre l’espace de recherche, créez une classe, par exemple SdcaExtendedOption, qui hérite de SdcaOption.

public class SdcaExtendedOption : SdcaOption
{
    [Range(0.10f, 1f, 0.01f)]
    public float BiasLearningRate {get;set;}   
}

Pour spécifier la plage de l’espace de recherche, utilisez RangeAttribute, qui équivaut à Microsoft.ML.SearchSpace.Option.

Ensuite, partout où vous utilisez votre espace de recherche, faites référence à SdcaExtendedOption au lieu de SdcaOption.

Par exemple, vous pouvez initialiser votre espace de recherche comme suit :

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Création d’un exécuteur de test

Par défaut, AutoML prend en charge la classification binaire, la classification multiclasse et la régression. ML.NET est néanmoins compatible avec de nombreux autres scénarios :

• Recommandation
• Prévisions
• Classement
• Classification d’images
• Classification de texte
• Similarité de phrases

Dans les cas de figure sans espaces de recherche préconfigurés ni estimateurs balayables, vous pouvez créer votre propre exécuteur de test et vous en servir pour rendre AutoML compatible avec votre scénario.

Prenons par exemple les données suivantes, portant sur des critiques de restaurants :

Waouh... J’ai adoré cet endroit.

1

La pâte n’est pas bonne.

0

Vous souhaitez utiliser l’entraîneur TextClassificationTrainer pour analyser le sentiment (0 est négatif, 1 positif). Toutefois, il n’existe aucune configuration ctx.Auto().TextClassification().

Pour utiliser AutoML avec l’entraîneur de classification de texte, procédez comme suit :

1. Créez votre propre espace de recherche.

   // Define TextClassification search space
   public class TCOption
   {
       [Range(64, 128, 32)]
       public int BatchSize { get; set; }
   }
   

   Dans ce cas, AutoML recherche différentes configurations de l’hyperparamètre BatchSize.

2. Créez un estimateur balayable et ajoutez-le à votre pipeline.

   // Initialize search space
   var tcSearchSpace = new SearchSpace<TCOption>();
   
   // Create factory for Text Classification trainer
   var tcFactory = (MLContext ctx, TCOption param) =>
   {
       return ctx.MulticlassClassification.Trainers.TextClassification(
           sentence1ColumnName: textColumnName,
           batchSize:param.BatchSize);
   };
   
   // Create text classification sweepable estimator
   var tcEstimator = 
       ctx.Auto().CreateSweepableEstimator(tcFactory, tcSearchSpace);
   
   // Define text classification pipeline
   var pipeline =
       ctx.Transforms.Conversion.MapValueToKey(columnInference.ColumnInformation.LabelColumnName)
           .Append(tcEstimator);
   

   Dans cet exemple, l’espace de recherche TCOption et une fabrique TextClassificationTrainer personnalisée sont utilisés pour créer un estimateur balayable.

3. Créez un exécuteur de test personnalisé.

   Pour créer un exécuteur de test personnalisé, implémentez ITrialRunner :

   public class TCRunner : ITrialRunner
   {
       private readonly MLContext _context;
       private readonly TrainTestData _data;
       private readonly IDataView _trainDataset;
       private readonly IDataView _evaluateDataset;
       private readonly SweepablePipeline _pipeline;
       private readonly string _labelColumnName;
       private readonly MulticlassClassificationMetric _metric;
   
       public TCRunner(
           MLContext context, 
           TrainTestData data, 
           SweepablePipeline pipeline,
           string labelColumnName = "Label", 
           MulticlassClassificationMetric metric = MulticlassClassificationMetric.MicroAccuracy)
       {
           _context = context;
           _data = data;
           _trainDataset = data.TrainSet;
           _evaluateDataset = data.TestSet;
           _labelColumnName = labelColumnName;
           _pipeline = pipeline;
           _metric = metric;
       }
   
       public void Dispose()
       {
           return;
       }
   
       // Run trial asynchronously
       public Task<TrialResult> RunAsync(TrialSettings settings, CancellationToken ct)
       {
           try
           {
               return Task.Run(() => Run(settings));
           }
           catch (Exception ex) when (ct.IsCancellationRequested)
           {
               throw new OperationCanceledException(ex.Message, ex.InnerException);
           }
           catch (Exception)
           {
               throw;
           }
       }
   
       // Helper function to define trial run logic
       private TrialResult Run(TrialSettings settings)
       {
           try
           {
               // Initialize stop watch to measure time
               var stopWatch = new Stopwatch();
               stopWatch.Start();
   
               // Get pipeline parameters
               var parameter = settings.Parameter["_pipeline_"];
   
               // Use parameters to build pipeline
               var pipeline = _pipeline.BuildFromOption(_context, parameter);
   
               // Train model
               var model = pipeline.Fit(_trainDataset);
   
               // Evaluate the model
               var predictions = model.Transform(_evaluateDataset);
   
               // Get metrics
               var evaluationMetrics = _context.MulticlassClassification.Evaluate(predictions, labelColumnName: _labelColumnName);
               var chosenMetric = GetMetric(evaluationMetrics);
   
               return new TrialResult()
               {
                   Metric = chosenMetric,
                   Model = model,
                   TrialSettings = settings,
                   DurationInMilliseconds = stopWatch.ElapsedMilliseconds
               };
           }
           catch (Exception)
           {
               return new TrialResult()
               {
                   Metric = double.MinValue,
                   Model = null,
                   TrialSettings = settings,
                   DurationInMilliseconds = 0,
               };
           }
       }
   
       // Helper function to choose metric used by experiment
       private double GetMetric(MulticlassClassificationMetrics metric)
       {
           return _metric switch
           {
               MulticlassClassificationMetric.MacroAccuracy => metric.MacroAccuracy,
               MulticlassClassificationMetric.MicroAccuracy => metric.MicroAccuracy,
               MulticlassClassificationMetric.LogLoss => metric.LogLoss,
               MulticlassClassificationMetric.LogLossReduction => metric.LogLossReduction,
               MulticlassClassificationMetric.TopKAccuracy => metric.TopKAccuracy,
               _ => throw new NotImplementedException(),
           };
       }
   }
   

   Dans cet exemple, l’implémentation de TCRunner effectue les opérations suivantes :

   • Elle extrait les hyperparamètres choisis pour ce test.
   • Elle utilise les hyperparamètres pour créer un pipeline ML.NET.
   • Elle utilise le pipeline ML.NET pour effectuer l’apprentissage d’un modèle.
   • Elle évalue le modèle.
   • Elle retourne un objet TrialResult comportant les informations de ce test.

4. Initialisez votre exécuteur de test personnalisé.

   var tcRunner = new TCRunner(context: ctx, data: trainValidationData, pipeline: pipeline);
   

5. Créez et configurez votre expérience. Utilisez la méthode d’extension SetTrialRunner pour ajouter votre exécuteur de test personnalisé à votre expérience.

   AutoMLExperiment experiment = ctx.Auto().CreateExperiment();
   
   // Configure AutoML experiment
   experiment
       .SetPipeline(pipeline)
       .SetMulticlassClassificationMetric(MulticlassClassificationMetric.MicroAccuracy, labelColumn: columnInference.ColumnInformation.LabelColumnName)
       .SetTrainingTimeInSeconds(120)
       .SetDataset(trainValidationData)
       .SetTrialRunner(tcRunner);
   

6. Exécuter votre expérience

   var tcCts = new CancellationTokenSource();
   TrialResult textClassificationExperimentResults = await experiment.RunAsync(tcCts.Token);
   

Choix d’un autre paramétreur

AutoML prend en charge différents algorithmes de réglage pour trouver les hyperparamètres optimaux par itérations successives dans l’espace de recherche. Par défaut, il utilise le paramétreur Eci Cost Frugal. À l’aide des méthodes d’extension d’expérience, vous pouvez en choisir un autre, plus adapté à votre scénario.

Utilisez les méthodes suivantes pour définir votre paramétreur :

• SMAC - SetSmacTuner
• Grid Search - SetGridSearchTuner
• Random Search - SetRandomSearchTuner
• Cost Frugal - SetCostFrugalTuner
• Eci Cost Frugal - SetEciCostFrugalTuner

Par exemple, pour utiliser le paramétreur Grid Search, le code se présente ainsi :

experiment.SetGridSearchTuner();

Configuration de la surveillance de l’expérience

Le moyen le plus rapide de surveiller la progression d’une expérience consiste à définir l’événement Log à partir de MLContext. Toutefois, l’événement Log génère une image mémoire brute des journaux générés par AutoML pendant chaque test. Cette opération est difficile en raison de la grande quantité d’informations non mises en forme.

Pour une expérience de surveillance plus contrôlée, implémentez une classe dotée de l’interface IMonitor.

public class AutoMLMonitor : IMonitor
{
    private readonly SweepablePipeline _pipeline;

    public AutoMLMonitor(SweepablePipeline pipeline)
    {
        _pipeline = pipeline;
    }

    public IEnumerable<TrialResult> GetCompletedTrials() => _completedTrials;

    public void ReportBestTrial(TrialResult result)
    {
        return;
    }

    public void ReportCompletedTrial(TrialResult result)
    {
        var trialId = result.TrialSettings.TrialId;
        var timeToTrain = result.DurationInMilliseconds;
        var pipeline = _pipeline.ToString(result.TrialSettings.Parameter);
        Console.WriteLine($"Trial {trialId} finished training in {timeToTrain}ms with pipeline {pipeline}");
    }

    public void ReportFailTrial(TrialSettings settings, Exception exception = null)
    {
        if (exception.Message.Contains("Operation was canceled."))
        {
            Console.WriteLine($"{settings.TrialId} cancelled. Time budget exceeded.");
        }
        Console.WriteLine($"{settings.TrialId} failed with exception {exception.Message}");
    }

    public void ReportRunningTrial(TrialSettings setting)
    {
        return;
    }
}

L’interface IMonitor comporte quatre événements de cycle de vie :

• ReportBestTrial
• ReportCompletedTrial
• ReportFailTrial
• ReportRunningTrial

Conseil

Bien que ce ne soit pas obligatoire, incluez votre SweepablePipeline dans votre moniteur. Cela vous permettra d’inspecter le pipeline généré pour un test à l’aide de la propriété Parameter de TrialSettings.

Dans cet exemple, seuls ReportCompletedTrial et ReportFailTrial sont implémentés.

Une fois que vous avez implémenté votre moniteur, définissez-le dans le cadre de votre configuration d’expérience à l’aide de SetMonitor.

var monitor = new AutoMLMonitor(pipeline);
experiment.SetMonitor(monitor);

Ensuite, exécutez votre expérience :

var cts = new CancellationTokenSource();
TrialResult experimentResults = await experiment.RunAsync(cts.Token);

Lorsque vous exécutez l’expérience avec cette implémentation, la sortie se présente ainsi :

Trial 0 finished training in 5835ms with pipeline ReplaceMissingValues=>OneHotEncoding=>Concatenate=>FastForestRegression
Trial 1 finished training in 15080ms with pipeline ReplaceMissingValues=>OneHotEncoding=>Concatenate=>SdcaRegression
Trial 2 finished training in 3941ms with pipeline ReplaceMissingValues=>OneHotHashEncoding=>Concatenate=>FastTreeRegression

Persistance des tests

Par défaut, AutoML stocke uniquement le TrialResult du meilleur modèle. Vous pouvez si vous souhaitez conserver chacun des tests dans votre moniteur.

À l’intérieur de votre moniteur, procédez comme suit :

1. Définissez une propriété pour vos tests effectués et une méthode pour y accéder.

   private readonly List<TrialResult> _completedTrials;
   
   public IEnumerable<TrialResult> GetCompletedTrials() => _completedTrials;
   

2. Initialisez-la dans votre constructeur.

   public AutoMLMonitor(SweepablePipeline pipeline)
   {
       //...
       _completedTrials = new List<TrialResult>();
       //...
   }
   

3. Ajoutez chaque résultat du test à l’intérieur de votre méthode de cycle de vie ReportCompletedTrial.

   public void ReportCompletedTrial(TrialResult result)
   {
       //...
       _completedTrials.Add(result);
   }
   

4. Une fois l’apprentissage terminé, vous pouvez accéder à tous les tests effectués en appelant GetCompletedTrials.

   var completedTrials = monitor.GetCompletedTrials();
   

Vous pouvez à ce stade effectuer un traitement supplémentaire sur la collection de tests effectués. Par exemple, choisissez un autre modèle que celui sélectionné par AutoML, journalisez les résultats des tests dans une base de données ou reconstruisez le pipeline à partir d’un des tests effectués.

Annulation des expériences

Lorsque vous exécutez des expériences de manière asynchrone, veillez à mettre fin au processus proprement. Pour ce faire, utilisez un CancellationToken.

Avertissement

Lorsque vous annulez une expérience, aucune des sorties intermédiaires n’est enregistrée. Définissez un point de contrôle pour les enregistrer.

var cts = new CancellationTokenSource();
TrialResult experimentResults = await experiment.RunAsync(cts.Token);

Définition de points de contrôle

Les points de contrôle vous permettent d’enregistrer les sorties intermédiaires du processus d’apprentissage pour le cas où un arrêt anticipé ou une erreur se produirait. Pour définir un point de contrôle, utilisez la méthode d’extension SetCheckpoint et indiquez dans quel répertoire stocker les sorties intermédiaires.

var checkpointPath = Path.Join(Directory.GetCurrentDirectory(), "automl");
experiment.SetCheckpoint(checkpointPath);

Détermination de l’importance d’une caractéristique

Le machine learning faisant petit à petit son apparition dans les différents aspects de la vie quotidienne, tels que la santé, il est extrêmement important de comprendre pourquoi un modèle Machine Learning prend telle ou telle décision. La technique PFI (Permutation Feature Importance, importance d’une caractéristique de permutation) est une technique utilisée pour expliquer les modèles de classification, de classement et de régression. À un niveau élevé, il fonctionne en permutant aléatoirement les données d’une fonctionnalité à la fois pour l’ensemble du jeu de données et en calculant dans quelle mesure la métrique de performance utile diminue. Plus la modification est importante, et plus la fonctionnalité l’est également. Pour plus d’informations sur la technique PFI, consultez Interprétation des prédictions de modèle à l’aide de la technique PFI (Permutation Feature Importance).

Notes

Le calcul de l’importance d’une caractéristique de permutation peut prendre du temps. Le temps nécessaire est proportionnel au nombre de colonnes de caractéristiques. Plus le nombre de caractéristiques est grand, plus l’exécution est longue.

Pour déterminer l’importance d’une caractéristique à l’aide d’AutoML, procédez comme suit :

1. Trouvez le meilleur modèle.

   var bestModel = expResult.Model;
   

2. Appliquez le modèle à votre jeu de données.

   var transformedData = bestModel.Transform(trainValidationData.TrainSet);
   

3. Calculez l’importance des caractéristiques à l’aide de PermutationFeatureImportance.

   Il s’agit dans ce cas d’une tâche de régression, mais le même concept s’applique à d’autres tâches (par exemple de classement ou de classification).

   var pfiResults = 
       mlContext.Regression.PermutationFeatureImportance(bestModel, transformedData, permutationCount:3);
   

4. Classez l’importance des caractéristiques en fonction des modifications apportées aux métriques d’évaluation.

   var featureImportance = 
       pfiResults.Select(x => Tuple.Create(x.Key, x.Value.Regression.RSquared))
           .OrderByDescending(x => x.Item2);