AutoMLExperiment Classe

Définition

Espace de noms:

Microsoft.ML.AutoML

Assembly:

Microsoft.ML.AutoML.dll

Paquet:

Microsoft.ML.AutoML v0.21.1

Classe pour l’expérience AutoML

public class AutoMLExperiment

type AutoMLExperiment = class

Public Class AutoMLExperiment

Héritage

Object

AutoMLExperiment

Exemples

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.ML.Data;

namespace Microsoft.ML.AutoML.Samples
{
    public static class AutoMLExperiment
    {
        public static async Task RunAsync()
        {
            var seed = 0;

            // Create a new context for ML.NET operations. It can be used for
            // exception tracking and logging, as a catalog of available operations
            // and as the source of randomness. Setting the seed to a fixed number
            // in this example to make outputs deterministic.
            var context = new MLContext(seed);

            // Create a list of training data points and convert it to IDataView.
            var data = GenerateRandomBinaryClassificationDataPoints(100, seed);
            var dataView = context.Data.LoadFromEnumerable(data);

            var trainTestSplit = context.Data.TrainTestSplit(dataView);

            // Define the sweepable pipeline using predefined binary trainers and search space.
            var pipeline = context.Auto().BinaryClassification(labelColumnName: "Label", featureColumnName: "Features");

            // Create an AutoML experiment
            var experiment = context.Auto().CreateExperiment();

            // Redirect AutoML log to console
            context.Log += (object o, LoggingEventArgs e) =>
            {
                if (e.Source == nameof(AutoMLExperiment) && e.Kind > Runtime.ChannelMessageKind.Trace)
                {
                    Console.WriteLine(e.RawMessage);
                }
            };

            // Config experiment to optimize "Accuracy" metric on given dataset.
            // This experiment will run hyper-parameter optimization on given pipeline
            experiment.SetPipeline(pipeline)
                      .SetDataset(trainTestSplit.TrainSet, fold: 5) // use 5-fold cross validation to evaluate each trial
                      .SetBinaryClassificationMetric(BinaryClassificationMetric.Accuracy, "Label")
                      .SetMaxModelToExplore(100); // explore 100 trials

            // start automl experiment
            var result = await experiment.RunAsync();

            // Expected output samples during training:
            //      Update Running Trial - Id: 0
            //      Update Completed Trial - Id: 0 - Metric: 0.5536912515402218 - Pipeline: FastTreeBinary - Duration: 595 - Peak CPU: 0.00 % -Peak Memory in MB: 35.81
            //      Update Best Trial - Id: 0 - Metric: 0.5536912515402218 - Pipeline: FastTreeBinary

            // evaluate test dataset on best model.
            var bestModel = result.Model;
            var eval = bestModel.Transform(trainTestSplit.TestSet);
            var metrics = context.BinaryClassification.Evaluate(eval);

            PrintMetrics(metrics);

            // Expected output:
            //  Accuracy: 0.67
            //  AUC: 0.75
            //  F1 Score: 0.33
            //  Negative Precision: 0.88
            //  Negative Recall: 0.70
            //  Positive Precision: 0.25
            //  Positive Recall: 0.50

            //  TEST POSITIVE RATIO: 0.1667(2.0 / (2.0 + 10.0))
            //  Confusion table
            //            ||======================
            //  PREDICTED || positive | negative | Recall
            //  TRUTH     ||======================
            //   positive || 1 | 1 | 0.5000
            //   negative || 3 | 7 | 0.7000
            //            ||======================
            //  Precision || 0.2500 | 0.8750 |
        }

        private static IEnumerable<BinaryClassificationDataPoint> GenerateRandomBinaryClassificationDataPoints(int count,
            int seed = 0)

        {
            var random = new Random(seed);
            float randomFloat() => (float)random.NextDouble();
            for (int i = 0; i < count; i++)
            {
                var label = randomFloat() > 0.5f;
                yield return new BinaryClassificationDataPoint
                {
                    Label = label,
                    // Create random features that are correlated with the label.
                    // For data points with false label, the feature values are
                    // slightly increased by adding a constant.
                    Features = Enumerable.Repeat(label, 50)
                        .Select(x => x ? randomFloat() : randomFloat() +
                        0.1f).ToArray()

                };
            }
        }

        // Example with label and 50 feature values. A data set is a collection of
        // such examples.
        private class BinaryClassificationDataPoint
        {
            public bool Label { get; set; }

            [VectorType(50)]
            public float[] Features { get; set; }
        }

        // Class used to capture predictions.
        private class Prediction
        {
            // Original label.
            public bool Label { get; set; }
            // Predicted label from the trainer.
            public bool PredictedLabel { get; set; }
        }

        // Pretty-print BinaryClassificationMetrics objects.
        private static void PrintMetrics(BinaryClassificationMetrics metrics)
        {
            Console.WriteLine($"Accuracy: {metrics.Accuracy:F2}");
            Console.WriteLine($"AUC: {metrics.AreaUnderRocCurve:F2}");
            Console.WriteLine($"F1 Score: {metrics.F1Score:F2}");
            Console.WriteLine($"Negative Precision: " +
                $"{metrics.NegativePrecision:F2}");

            Console.WriteLine($"Negative Recall: {metrics.NegativeRecall:F2}");
            Console.WriteLine($"Positive Precision: " +
                $"{metrics.PositivePrecision:F2}");

            Console.WriteLine($"Positive Recall: {metrics.PositiveRecall:F2}\n");
            Console.WriteLine(metrics.ConfusionMatrix.GetFormattedConfusionTable());
        }
    }
}

Constructeurs

AutoMLExperiment(MLContext, AutoMLExperiment+AutoMLExperimentSettings)

Classe pour l’expérience AutoML

Méthodes

AddSearchSpace(String, SearchSpace)	Classe pour l’expérience AutoML
Run()	Exécutez l’expérience et retournez le meilleur résultat d’essai de manière synchronisée.
RunAsync(CancellationToken)	Exécutez l’expérience et retournez le meilleur résultat de l’essai de manière asynchrone. L’expérience retourne le meilleur résultat d’essai actuel s’il y a une version d’évaluation terminée lors ct de l’annulation, et génère TimeoutException le message « Temps d’entraînement terminé sans exécution d’essai » quand aucun essai n’est terminé. Une autre chose à noter est que cette fonction ne reviendra pas immédiatement après ct l’annulation. Au lieu de cela, il appelle Microsoft.ML.MLContext.CancelExecution pour annuler tout le processus d’entraînement et attendre que tous les essais en cours d’exécution soient annulés ou terminés.
SetMaximumMemoryUsageInMegaByte(Double)	Classe pour l’expérience AutoML
SetMaxModelToExplore(Int32)	Classe pour l’expérience AutoML
SetMonitor<TMonitor>()	Classe pour l’expérience AutoML
SetMonitor<TMonitor>(Func<IServiceProvider,TMonitor>)	Classe pour l’expérience AutoML
SetMonitor<TMonitor>(TMonitor)	Classe pour l’expérience AutoML
SetTrainingTimeInSeconds(UInt32)	Classe pour l’expérience AutoML
SetTrialRunner<TTrialRunner>()	Classe pour l’expérience AutoML
SetTrialRunner<TTrialRunner>(Func<IServiceProvider,TTrialRunner>)	Classe pour l’expérience AutoML
SetTrialRunner<TTrialRunner>(TTrialRunner)	Classe pour l’expérience AutoML
SetTuner<TTuner>()	Classe pour l’expérience AutoML
SetTuner<TTuner>(Func<IServiceProvider,TTuner>)	Classe pour l’expérience AutoML
SetTuner<TTuner>(TTuner)	Classe pour l’expérience AutoML

Méthodes d’extension

SetBinaryClassificationMetric(AutoMLExperiment, BinaryClassificationMetric, String, String)	Définissez Microsoft.ML.AutoML.BinaryMetricManager comme gestionnaire d’évaluation pour AutoMLExperiment. Cela permet d’utiliser AutoMLExperimentmetric comme métrique d’évaluation.
SetCheckpoint(AutoMLExperiment, String)	Définissez le dossier de point de contrôle pour AutoMLExperiment. Le dossier de point de contrôle sera utilisé pour enregistrer la sortie temporaire, l’historique des exécutions et de nombreux autres éléments qui seront utilisés pour restaurer le processus d’entraînement à partir du dernier point de contrôle et poursuivre l’entraînement.
SetCostFrugalTuner(AutoMLExperiment)	Définissez Microsoft.ML.AutoML.CostFrugalTuner comme tuner pour l’optimisation des hyperparamètres.
SetDataset(AutoMLExperiment, DataOperationsCatalog+TrainTestData)	Définissez le jeu de données d’apprentissage et de validation pour AutoMLExperiment. Cela permet AutoMLExperiment d’utiliser TrainSet à partir de trainValidationSplit pour entraîner un modèle, et d’utiliser TestSet pour trainValidationSplit évaluer le modèle.
SetDataset(AutoMLExperiment, IDataView, IDataView, Boolean)	Définissez le jeu de données d’apprentissage et de validation pour AutoMLExperiment. Cela permet AutoMLExperiment d’effectuer train l’apprentissage d’un modèle et d’utiliser validation pour évaluer le modèle.
SetDataset(AutoMLExperiment, IDataView, Int32, String)	Définissez le jeu de données de validation croisée pour AutoMLExperiment. Cela permet AutoMLExperiment d’utiliser n=fold fractionnement de validation croisée sur dataset pour entraîner et évaluer un modèle.
SetEciCostFrugalTuner(AutoMLExperiment)	défini Microsoft.ML.AutoML.EciCostFrugalTuner comme tuner pour l’optimisation des hyperparamètres. Ce tuner fonctionne uniquement avec l’espace de recherche de SweepablePipeline.
SetGridSearchTuner(AutoMLExperiment, Int32)	défini Microsoft.ML.AutoML.GridSearchTuner comme tuner pour l’optimisation des hyperparamètres.
SetMulticlassClassificationMetric(AutoMLExperiment, MulticlassClassificationMetric, String, String)	Définissez Microsoft.ML.AutoML.MultiClassMetricManager comme gestionnaire d’évaluation pour AutoMLExperiment. Cela permet d’utiliser AutoMLExperimentmetric comme métrique d’évaluation.
SetPerformanceMonitor(AutoMLExperiment, Int32)	Définissez DefaultPerformanceMonitor comme IPerformanceMonitor pour AutoMLExperiment.
SetPerformanceMonitor<TPerformanceMonitor>(AutoMLExperiment, Func<IServiceProvider,TPerformanceMonitor>)	Définissez un moniteur de performances personnalisé comme IPerformanceMonitor pour AutoMLExperiment.
SetPerformanceMonitor<TPerformanceMonitor>(AutoMLExperiment)	Définissez un moniteur de performances personnalisé comme IPerformanceMonitor pour AutoMLExperiment.
SetPipeline(AutoMLExperiment, SweepablePipeline)	Défini pipeline pour l’entraînement. Cela permet AutoMLExperiment également d’utiliser Microsoft.ML.AutoML.SweepablePipelineRunner , Microsoft.ML.AutoML.MLContextMonitor et Microsoft.ML.AutoML.EciCostFrugalTuner pour automl traininng.
SetRandomSearchTuner(AutoMLExperiment, Nullable<Int32>)	défini Microsoft.ML.AutoML.RandomSearchTuner comme tuner pour l’optimisation des hyperparamètres. Si seed est fourni, il utilise cette valeur initiale pour initialiser Microsoft.ML.AutoML.RandomSearchTuner. Sinon, Seed sera utilisé.
SetRegressionMetric(AutoMLExperiment, RegressionMetric, String, String)	Définissez Microsoft.ML.AutoML.RegressionMetricManager comme gestionnaire d’évaluation pour AutoMLExperiment. Cela permet d’utiliser AutoMLExperimentmetric comme métrique d’évaluation.
SetSmacTuner(AutoMLExperiment, Int32, Int32, Int32, Int32, Single, Int32, Int32, Double, Int32)	Définissez Microsoft.ML.AutoML.SmacTuner comme tuner pour l’optimisation des hyperparamètres. Les performances de smac sont dans une grande étendue déterminée par numberOfTrees, nMinForSpit et splitRatio, qui sont utilisés pour ajuster le régresseur interne de smac.