AutoMLExperiment Třída

Reference

Definice

Obor názvů:: Microsoft.ML.AutoML

Sestavení:: Microsoft.ML.AutoML.dll

Balíček:: Microsoft.ML.AutoML v0.21.1

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Třída experimentu AutoML

public class AutoMLExperiment

type AutoMLExperiment = class

Public Class AutoMLExperiment

Dědičnost: Object
AutoMLExperiment

Příklady

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());
        }
    }
}

Konstruktory

AutoMLExperiment(MLContext, AutoMLExperiment+AutoMLExperimentSettings)

Třída experimentu AutoML

Metody

AddSearchSpace(String, SearchSpace)	Třída experimentu AutoML
Run()	Spusťte experiment a sesynchronně vraťte nejlepší výsledek zkušební verze.
RunAsync(CancellationToken)	Spusťte experiment a asynchronně vraťte nejlepší výsledek zkušební verze. Experiment vrátí aktuální nejlepší výsledek zkušební verze, pokud se při `ct` zrušení nějaké zkušební verze dokončí, a zobrazí TimeoutException se zpráva "Trénování bylo dokončeno bez dokončení zkušebního běhu", pokud se žádná zkušební verze nedokončila. Další věc, kterou je potřeba si všimnout, je, že tato funkce se po `ct` zrušení nevrátí okamžitě. Místo toho se zavolá Microsoft.ML.MLContext.CancelExecution ke zrušení veškerého procesu trénování a čekání na zrušení nebo dokončení všech spuštěných zkušebních verzí.
SetMaximumMemoryUsageInMegaByte(Double)	Třída experimentu AutoML
SetMaxModelToExplore(Int32)	Třída experimentu AutoML
SetMonitor<TMonitor>()	Třída experimentu AutoML
SetMonitor<TMonitor>(Func<IServiceProvider,TMonitor>)	Třída experimentu AutoML
SetMonitor<TMonitor>(TMonitor)	Třída experimentu AutoML
SetTrainingTimeInSeconds(UInt32)	Třída experimentu AutoML
SetTrialRunner<TTrialRunner>()	Třída experimentu AutoML
SetTrialRunner<TTrialRunner>(Func<IServiceProvider,TTrialRunner>)	Třída experimentu AutoML
SetTrialRunner<TTrialRunner>(TTrialRunner)	Třída experimentu AutoML
SetTuner<TTuner>()	Třída experimentu AutoML
SetTuner<TTuner>(Func<IServiceProvider,TTuner>)	Třída experimentu AutoML
SetTuner<TTuner>(TTuner)	Třída experimentu AutoML

Metody rozšíření

SetBinaryClassificationMetric(AutoMLExperiment, BinaryClassificationMetric, String, String)	Nastavit Microsoft.ML.AutoML.BinaryMetricManager jako správce hodnocení pro AutoMLExperiment. Tím se AutoMLExperiment použije `metric` jako metrika vyhodnocení.
SetCheckpoint(AutoMLExperiment, String)	Nastavte složku kontrolních bodů pro AutoMLExperiment. Složka kontrolních bodů se použije k uložení dočasného výstupu, historie spuštění a mnoha dalších věcí, které se použijí k obnovení trénovacího procesu z posledního kontrolního bodu a k pokračování trénování.
SetCostFrugalTuner(AutoMLExperiment)	Nastavit Microsoft.ML.AutoML.CostFrugalTuner jako tuner pro optimalizaci hyperparametrů.
SetDataset(AutoMLExperiment, DataOperationsCatalog+TrainTestData)	Nastavte trénovací a ověřovací datovou sadu pro AutoMLExperiment. Použije se AutoMLExperiment TrainSet`trainValidationSplit` k trénování modelu a k vyhodnocení modelu použijete metodu TestSet z .`trainValidationSplit`
SetDataset(AutoMLExperiment, IDataView, IDataView, Boolean)	Nastavte trénovací a ověřovací datovou sadu pro AutoMLExperiment. Použije se AutoMLExperiment`train` k trénování modelu a k `validation` vyhodnocení modelu.
SetDataset(AutoMLExperiment, IDataView, Int32, String)	Nastavte datovou sadu křížového ověření pro AutoMLExperiment. K trénování a vyhodnocení modelu se tak použije AutoMLExperiment rozdělení `dataset` n=`fold` křížového ověření.
SetEciCostFrugalTuner(AutoMLExperiment)	nastavit Microsoft.ML.AutoML.EciCostFrugalTuner jako tuner pro optimalizaci hyperparametrů. Tento tuner funguje pouze s vyhledávacím prostorem z .SweepablePipeline
SetGridSearchTuner(AutoMLExperiment, Int32)	nastaveno Microsoft.ML.AutoML.GridSearchTuner jako tuner pro optimalizaci hyperparametrů.
SetMulticlassClassificationMetric(AutoMLExperiment, MulticlassClassificationMetric, String, String)	Nastavit Microsoft.ML.AutoML.MultiClassMetricManager jako správce hodnocení pro AutoMLExperiment. Tím se AutoMLExperiment použije `metric` jako metrika vyhodnocení.
SetPerformanceMonitor(AutoMLExperiment, Int32)	Nastavte DefaultPerformanceMonitor jako IPerformanceMonitor pro AutoMLExperiment.
SetPerformanceMonitor<TPerformanceMonitor>(AutoMLExperiment, Func<IServiceProvider,TPerformanceMonitor>)	Nastavte vlastní monitorování výkonu jako IPerformanceMonitor pro AutoMLExperiment.
SetPerformanceMonitor<TPerformanceMonitor>(AutoMLExperiment)	Nastavte vlastní monitorování výkonu jako IPerformanceMonitor pro AutoMLExperiment.
SetPipeline(AutoMLExperiment, SweepablePipeline)	Nastaveno `pipeline` pro trénování. To také umožňuje AutoMLExperiment používat Microsoft.ML.AutoML.SweepablePipelineRunner , Microsoft.ML.AutoML.MLContextMonitor a Microsoft.ML.AutoML.EciCostFrugalTuner také pro trénování automatizovaného strojového učení.
SetRandomSearchTuner(AutoMLExperiment, Nullable<Int32>)	nastaveno Microsoft.ML.AutoML.RandomSearchTuner jako tuner pro optimalizaci hyperparametrů. Pokud `seed` je zadaný, použije tento předsadek k inicializaci Microsoft.ML.AutoML.RandomSearchTuner. Seed V opačném případě se použije .
SetRegressionMetric(AutoMLExperiment, RegressionMetric, String, String)	Nastavit Microsoft.ML.AutoML.RegressionMetricManager jako správce hodnocení pro AutoMLExperiment. Tím se AutoMLExperiment použije `metric` jako metrika vyhodnocení.
SetSmacTuner(AutoMLExperiment, Int32, Int32, Int32, Int32, Single, Int32, Int32, Double, Int32)	Nastavit Microsoft.ML.AutoML.SmacTuner jako tuner pro optimalizaci hyperparametrů. Výkon nástroje smac je ve velkém rozsahu, který `numberOfTrees`určuje , `nMinForSpit` a `splitRatio`, které se používají k přizpůsobení vnitřního regresoru smacu.

Platí pro

Sdílet prostřednictvím