Gewusst wie: Verwenden der API für automatisiertes maschinelles Lernen (AutoML) von ML.NET

Artikel
06/05/2023

In diesem Artikel erfahren Sie, wie Sie die AutoML-API (automatisiertes maschinelles Lernen) von ML.NET verwenden.

Beispiele für die AutoML-API finden Sie im Repository dotnet/machinelearning-samples.

Installation

Um die AutoML-API verwenden zu können, installieren Sie das NuGet-Paket Microsoft.ML.AutoML im .NET-Projekt, in dem Sie darauf verweisen möchten.

Hinweis

In diesem Leitfaden wird Version 0.20.0 und höher des NuGet-Pakets Microsoft.ML.AutoML verwendet. Obwohl Beispiele und Code aus früheren Versionen noch funktionieren, wird dringend empfohlen, für neue Projekte die in dieser Version eingeführten APIs zu verwenden.

Weitere Informationen zum Installieren von NuGet-Paketen finden Sie in den folgenden Anleitungen:

Schnellstart

AutoML bietet mehrere Standardeinstellungen für das schnelle Trainieren von Machine Learning-Modellen. In diesem Abschnitt wird Folgendes erläutert:

Laden von Daten
Definieren der Pipeline
Konfigurieren Sie Ihr Experiment
Führen Sie Ihr Experiment durch
Verwenden des besten Modells zum Treffen von Vorhersagen

Definieren des Problems

Bei einem Dataset, das in einer durch Trennzeichen getrennten Datei namens taxi-fare-train.csv gespeichert ist, sieht das wie folgt aus:

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

Laden von Daten

Initialisieren Sie zunächst MLContext. MLContext ist der Ausgangspunkt für alle ML.NET-Vorgänge. Beim Initialisieren von mlContext wird eine neue ML.NET-Umgebung erstellt, die von allen Objekte des Workflows zur Modellerstellung gemeinsam genutzt werden kann. Die Klasse ähnelt dem Konzept von DBContext in Entity Framework.

Laden Sie dann Ihre Daten mit der InferColumns-Methode.

// 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 lädt einige Zeilen aus dem Dataset. Dann untersucht es die Daten und versucht, den Datentyp für jede der Spalten anhand ihres Inhalts zu erraten oder rückzuschließen.

Standardmäßig werden Spalten desselben Typs in Featurevektoren oder Arrays gruppiert, die die Elemente der einzelnen Spalten enthalten. Wenn Sie groupColumns auf false festlegen, wird dieses Standardverhalten außer Kraft gesetzt und nur der Spaltenrückschluss ohne Gruppierung von Spalten durchgeführt. Indem Sie Spalten getrennt halten, können Sie bei der Vorverarbeitung der Daten verschiedene Datentransformationen auf Ebene einzelner Spalten vornehmen, anstatt eine Spaltengruppierung vorzunehmen.

Das Ergebnis von InferColumns ist ein ColumnInferenceResults-Objekt, das die zum Erstellen einer TextLoader-Instanz erforderlichen Optionen sowie die Informationen zu den Spalten enthält.

Im Beispieldataset in taxi-fare-train.csv können Spalteninformationen wie folgt aussehen:

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

Sobald Sie Ihre Spalteninformationen haben, erstellen Sie mithilfe der von ColumnInferenceResults definierten TextLoader.Options einen TextLoader, um Ihre Daten in eine IDataView zu laden.

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

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

Häufig empfiehlt es sich, Ihre Daten in Datasets für Training und Validierung aufzuteilen. Verwenden Sie TrainTestSplit, um eine Aufteilung Ihres Datasets in 80 % für das Training und 20 % für die Validierung zu erstellen.

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

Definieren der Pipeline

Ihre Pipeline definiert die Datenverarbeitungsschritte und die Pipeline für maschinelles Lernen zum Trainieren Ihres Modells.

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

SweepablePipeline ist eine Sammlung von SweepableEstimator. SweepableEstimator ist ein ML.NET-Estimator mit einem SearchSpace.

Featurizer ist eine praktische API, die auf der Grundlage der von Ihnen zur Verfügung gestellten Spalteninformationen eine Pipeline von sweepfähigen Schätzern zur Datenverarbeitung aufbaut. Anstatt eine Pipeline von Grund auf neu aufzubauen, automatisiert Featurizer den Schritt zur Datenvorverarbeitung. Weitere Informationen zu von ML.NET unterstützten Transformationen finden Sie im Leitfaden zu Datentransformationen.

Die Ausgabe von Featurizer ist eine einzelne Spalte mit einem numerischen Featurevektor, der die transformierten Daten für jede der Spalten darstellt. Dieser Featurevektor wird dann als Eingabe in die Algorithmen zum Trainieren eines Machine Learning-Modells verwendet.

Wenn Sie die Datenvorverarbeitung genauer steuern möchten, können Sie bei jedem einzelnen Vorverarbeitungsschritt eine Pipeline erstellen. Weitere Informationen finden Sie im Leitfaden zum Vorbereiten von Daten für die Erstellung eines Modells.

Tipp

Mithilfe von Featurizer mit ColumnInferenceResults können Sie den Nutzen von AutoML maximieren.

Für das Training stellt AutoML eine sweepfähige Pipeline mit Standardtrainern und Suchbereichskonfigurationen für die folgenden Machine Learning-Aufgaben bereit:

Für das Problem der Vorhersage des Taxifahrpreises verwenden Sie Regression, da das Ziel die Vorhersage eines numerischen Werts ist. Weitere Informationen zum Auswählen einer Aufgabe finden Sie unter Machine Learning-Aufgaben in ML.NET.

Konfigurieren Sie Ihr Experiment

Erstellen Sie zunächst ein AutoML-Experiment. AutoMLExperiment ist eine Sammlung von TrialResult.

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

Sobald Sie Ihr Experiment erstellt haben, können Sie mit den zur Verfügung stehenden Erweiterungsmethoden verschiedene Einstellungen konfigurieren.

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

Gehen Sie bei diesem Beispiel so vor:

Legen Sie die sweefähige Pipeline so fest, dass sie während des Experiments ausgeführt wird, indem Sie SetPipeline aufrufen.
Wählen Sie RSquared als Metrik aus, die während des Trainings optimiert werden soll, indem Sie SetRegressionMetric aufrufen. Weitere Informationen zu Auswertungsmetriken finden Sie im Leitfaden Auswerten des ML.NET-Modells mit Metriken.
Legen Sie 60 Sekunden als Trainingsdauer fest, indem Sie SetTrainingTimeInSeconds aufrufen. Eine gute Heuristik zur Bestimmung der Dauer des Trainings ist der Umfang Ihrer Daten. In der Regel erfordern größere Datasets eine längere Trainingsdauer. Weitere Informationen finden Sie unter Leitfaden zur Trainingsdauer.
Stellen Sie die für Training und Validierung verwendenden Datasets bereit, indem Sie SetDataset aufrufen.

Nachdem Ihr Experiment definiert wurde, sollten Sie den Fortschritt nachverfolgen. Die schnellste Möglichkeit zum Nachverfolgen des Fortschritts besteht darin, das Log-Ereignis von MLContext zu ändern.

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

Führen Sie Ihr Experiment durch

Nachdem Sie Ihr Experiment definiert haben, starten Sie Ihr Experiment mithilfe der RunAsync-Methode.

TrialResult experimentResults = await experiment.RunAsync();

Wenn die Trainingsdauer abgelaufen ist, ist TrialResult das Ergebnis für das beste Modell, das während des Trainings gefunden wurde.

An diesem Punkt können Sie Ihr Modell speichern oder zum Treffen von Vorhersagen verwenden. Weitere Informationen zur Verwendung eines ML.NET-Modells finden Sie in den folgenden Leitfäden:

Ändern von Spaltenrückschlussergebnissen

Da InferColumns nur eine Teilmenge Ihrer Daten lädt, ist es möglich, dass Randfälle außerhalb der Beispiele, die zum Ableiten von Spalten verwendet werden, nicht erfasst und die falschen Datentypen für Ihre Spalten festgelegt werden. Sie können die Eigenschaften von ColumnInformation aktualisieren, um die Fälle zu berücksichtigen, in denen die Ergebnisse des Spaltenrückschlusses nicht stimmen.

Im Dataset mit den Taxifahrpreisen sind beispielsweise die Daten in der Spalte rate_code eine Zahl. Dieser numerische Wert stellt jedoch eine Kategorie dar. Standardmäßig wird rate_code beim Aufrufen von InferColumns in die Eigenschaft NumericColumnNames statt CategoricalColumnNames eingefügt. Da es sich bei diesen Eigenschaften um .NET-Auflistungen handelt, können Sie Elemente mithilfe von Standardvorgängen hinzufügen und entfernen.

Sie können wie folgt vorgehen, um ColumnInformation für rate_codezu aktualisieren.

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

Ausschließen von Trainern

Standardmäßig probiert AutoML im Rahmen des Trainingsprozesses mehrere Trainer aus, um zu sehen, welche davon am besten für Ihre Daten geeignet ist. Im Laufe des Trainingsprozesses stellen Sie jedoch möglicherweise fest, dass einige Trainer zu viele Computeressourcen in Anspruch nehmen oder keine guten Auswertungsmetriken liefern. Sie haben die Möglichkeit, Trainer vom Trainingsprozess auszuschließen. Welche Trainer verwendet werden, hängt von der Aufgabe ab. Eine Liste der unterstützten Trainer in ML.NET finden Sie im Leitfaden Machine Learning-Aufgaben in ML.NET.

Legen Sie beispielsweise im Szenario der Taxifahrpreisregression den Parameter useLgbm auf false fest, um den LightGBM-Algorithmus auszuschließen.

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

Der Prozess zum Ausschließen von Trainern in anderen Aufgaben wie binäre und Multiklassen-Klassifizierung funktioniert auf die gleiche Weise.

Anpassen eines sweepfähigen Schätzers

Wenn Sie eine detailliertere Anpassung der Schätzeroptionen wünschen, die Teil Ihrer sweepfähigen Pipeline sind, müssen Sie Folgendes tun:

Initialisieren eines Suchbereichs
Definieren einer benutzerdefinierten Factory im Suchbereich
Erstellen eines sweepfähigen Schätzers
Hinzufügen des sweepfähigen Schätzers zur sweepfähigen Pipeline

AutoML stellt in den folgenden Machine Learning-Aufgaben mehrere vorkonfigurierte Suchbereiche für Trainer bereit:

In diesem Beispiel wird der Suchbereich für SdcaRegressionTrainer verwendet. Initialisieren Sie ihn mithilfe von SdcaOption.

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Definieren Sie dann im Suchbereich eine benutzerdefinierte Factorymethode, um SdcaRegressionTrainer zu erstellen. In diesem Beispiel sind die Werte von L1Regularization und L2Regularization auf einen anderen Wert als den Standardwert festgelegt. Für L1Regularization wird der festgelegte Wert bei jedem Versuch vom Optimierer bestimmt. L2Regularization ist für jeden Versuch auf den hartcodierten Wert festgelegt. Bei jedem Versuch ist die Ausgabe der benutzerdefinierten Factory SdcaRegressionTrainer mit den konfigurierten Hyperparametern.

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

Ein sweepfähiger Schätzer ist die Kombination aus Schätzer und Suchbereich. Nachdem Sie einen Suchbereich definiert und damit eine benutzerdefinierte Factorymethode zum Generieren von Trainern erstellt haben, können Sie nun mit der CreateSweepableEstimator-Methode einen neuen sweepfähigen Schätzer erstellen.

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

Um Ihren sweepfähigen Schätzer im Experiment zu verwenden, fügen Sie ihn Ihrer sweepfähigen Pipeline hinzu.

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

Da sweepfähige Pipelines eine Sammlung sweepfähiger Schätzer sind, können Sie so viele dieser sweepfähigen Schätzer konfigurieren und anpassen, wie Sie benötigen.

Anpassen des Suchbereichs

Es gibt Szenarien, in denen Sie die in Ihrem Experiment verwendeten sweepfähigen Schätzer nicht nur anpassen, sondern auch den Suchbereich steuern möchten. Dazu können Sie mithilfe von Schlüsseln auf die Eigenschaften des Suchbereichs zugreifen. In diesem Fall ist der L1Regularization-Parameter float. Passen Sie daher den Suchbereich mithilfe von UniformSingleOption an.

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

Abhängig vom Datentyp des Hyperparameters, den Sie festlegen möchten, können Sie aus den folgenden Optionen wählen:

Zahlen
Boolesche Werte und Zeichenfolgen
- ChoiceOption

Suchbereiche können auch geschachtelte Suchbereiche enthalten.

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;

Eine weitere Möglichkeit zum Anpassen von Suchbereichen ist ihre Erweiterung. SdcaOption stellt beispielsweise nur die Parameter L1Regularization und L2Regularization bereit. Allerdings bietet SdcaRegressionTrainer mehr Parameter, die Sie festlegen können, wie z. B. BiasLearningRate.

Um den Suchbereich zu erweitern, erstellen Sie eine neue Klasse, z. B. SdcaExtendedOption, die von SdcaOption erbt.

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

Um den Suchbereich anzugeben, verwenden Sie RangeAttribute, was Microsoft.ML.SearchSpace.Option entspricht.

Verweisen Sie anschließend überall dort, wo Sie Ihren Suchbereich verwenden, auf SdcaExtendedOption statt auf SdcaOption.

Wenn Sie beispielsweise Ihren Suchbereich initialisieren, können Sie dies wie folgt tun:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Erstellen eines eigenen Testrunners

Standardmäßig unterstützt AutoML binäre Klassifizierung, Multiklassen-Klassifizierung und Regression. ML.NET unterstützt jedoch noch viele weitere Szenarien wie z. B.:

Empfehlung
Vorhersagen
Rangfolge
Bildklassifizierung
Textklassifizierung
Ähnlichkeit von Sätzen

Für Szenarien ohne vorkonfigurierte Suchbereiche und sweepfähige Schätzer können Sie Ihre eigenen erstellen und mit einem Testrunner AutoML für dieses Szenario aktivieren.

Angenommen, Sie haben Restaurantbewertungsdaten, die wie folgt aussehen:

Toll... Mir hat das Restaurant gefallen.

Die Kruste ist nicht gut.

Sie möchten den Trainer TextClassificationTrainer verwenden, um die Stimmung zu analysieren, wobei 0 negativ und 1 positiv ist. Es gibt jedoch keine ctx.Auto().TextClassification()-Konfiguration.

Um AutoML mit dem Textklassifizierungstrainer zu verwenden, gehen Sie so vor:

Erstellen Sie einen eigenen Suchbereich.

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

In diesem Fall sucht AutoML nach verschiedenen Konfigurationen des Hyperparameters BatchSize.

Erstellen Sie einen sweepfähigen Schätzer, und fügen Sie ihn Ihrer Pipeline hinzu.

// 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);

In diesem Beispiel werden der Suchbereich TCOption und die benutzerdefinierte Factory TextClassificationTrainer verwendet, um einen sweepfähigen Schätzer zu erstellen.

Erstellen eines benutzerdefinierten Testrunners

Um einen benutzerdefinierten Testrunner zu erstellen, implementieren Sie 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(),
        };
    }
}

Die Implementierung TCRunner in diesem Beispiel bewirkt Folgendes:

Extrahiert die für diesen Test ausgewählten Hyperparameter
Erstellt eine ML.NET-Pipeline anhand der Hyperparameter
Trainiert ein Modell mithilfe der ML.NET-Pipeline
Wertet das Modell aus
Gibt ein TrialResult-Objekt mit den Informationen für diesen Test zurück

Initialisieren des benutzerdefinierten Testrunners

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

Erstellen und konfigurieren Sie Ihr Experiment. Fügen Sie mit der Erweiterungsmethode SetTrialRunner Ihren benutzerdefinierten Testrunner Ihrem Experiment hinzu.

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

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

Führen Sie Ihr Experiment durch

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

Wählen eines anderen Optimierers

AutoML unterstützt verschiedene Optimierungsalgorithmen, um den Suchbereich bei der Suche nach den optimalen Hyperparametern zu durchlaufen. Standardmäßig wird der Optimierer „Eci Cost Frugal“ verwendet. Mithilfe von Experimenterweiterungsmethoden können Sie einen anderen Optimierer wählen, der am besten zu Ihrem Szenario passt.

Verwenden Sie die folgenden Methoden, um Ihren Optimierer festzulegen:

SMAC - SetSmacTuner
Rastersuche - SetGridSearchTuner
Zufällige Suche - SetRandomSearchTuner
Cost Frugal - SetCostFrugalTuner
Eci Cost Frugal - SetEciCostFrugalTuner

Wenn Sie beispielsweise den Optimierer „Rastersuche“ verwenden möchten, kann Ihr Code wie folgt aussehen:

experiment.SetGridSearchTuner();

Konfigurieren der Experimentüberwachung

Die schnellste Möglichkeit zum Überwachen des Fortschritts eines Experiments besteht darin, das Log-Ereignis von MLContext zu definieren. Das Log-Ereignis gibt jedoch unformatierte Protokolldaten aus, die von AutoML während jedes Tests generiert wurden. Aufgrund der großen Menge unformatierter Informationen ist dies schwierig.

Implementieren Sie für eine bessere Möglichkeit der kontrollierten Überwachung mit der IMonitor-Schnittstelle eine Klasse.

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

Die IMonitor-Schnittstelle weist vier Lebenszyklusereignisse auf:

Tipp

Obwohl nicht erforderlich, fügen Sie Ihre SweepablePipeline in Ihren Monitor ein, damit Sie die Pipeline, die für einen Test generiert wurde, anhand der Parameter-Eigenschaft von TrialSettings überprüfen können.

In diesem Beispiel werden nur ReportCompletedTrial und ReportFailTrial implementiert.

Nachdem Sie Ihren Monitor implementiert haben, legen Sie ihn mithilfe von SetMonitor als Teil der Experimentkonfiguration fest.

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

Führen Sie dann Ihr Experiment aus:

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

Wenn Sie das Experiment mit dieser Implementierung ausführen, sollte die Ausgabe wie folgt aussehen:

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

Dauerhaftes Speichern von Tests

Standardmäßig speichert AutoML nur das TrialResult für das beste Modell. Wenn Sie jedoch die einzelnen Tests beibehalten möchten, können Sie dies in Ihrem Monitor tun.

Gehen Sie in Ihrem Monitor so vor:

Definieren Sie eine Eigenschaft für Ihre abgeschlossenen Tests und eine Methode für den Zugriff darauf.

private readonly List<TrialResult> _completedTrials;

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

Initialisieren Sie sie in Ihrem Konstruktor.

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

Fügen Sie jedes Testergebnis innerhalb Ihrer ReportCompletedTrial-Lebenszyklusmethode an.

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

Wenn das Training abgeschlossen ist, können Sie auf alle abgeschlossenen Tests zugreifen, indem Sie GetCompletedTrials aufrufen.
```
var completedTrials = monitor.GetCompletedTrials();
```

An diesem Punkt können Sie eine zusätzliche Verarbeitung auf die Sammlung abgeschlossener Tests anwenden. Sie können z. B. ein anderes Modell als das von AutoML ausgewählte wählen, Testergebnisse in einer Datenbank protokollieren oder die Pipeline anhand abgeschlossener Tests neu erstellen.

Abbrechen von Experimenten

Wenn Sie Experimente asynchron ausführen, achten Sie darauf, den Prozess ordnungsgemäß zu beenden. Verwenden Sie hierzu ein CancellationToken.

Warnung

Wenn Sie ein Experiment abbrechen, werden keine Zwischenausgaben gespeichert. Legen Sie einen Prüfpunkt fest, um Zwischenausgaben zu speichern.

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

Festlegen von Prüfpunkten

Prüfpunkte bieten eine Möglichkeit, Zwischenausgaben im Trainingsprozess im Falle einer vorzeitigen Beendigung oder eines Fehlers zu speichern. Legen Sie mit der Erweiterungsmethode SetCheckpoint einen Prüfpunkt fest, und geben Sie ein Verzeichnis an, in dem die Zwischenausgaben gespeichert werden.

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

Bestimmen der Featurerelevanz

Da das maschinelle Lernen in immer mehr Bereichen des täglichen Lebens, wie beispielsweise im Gesundheitswesen, zum Einsatz kommt, ist es von größter Bedeutung zu verstehen, warum ein Machine Learning-Modell die Entscheidungen trifft, die es trifft. Permutation Feature Importance (PFI) ist ein Verfahren zum Erklären von Klassifizierungs-, Bewertungs- und Regressionsmodellen. Allgemein funktioniert die Technik so, das Daten für das gesamte Dataset einzeln zufällig gemischt werden und anschließend berechnet wird, wie stark die Leistungsmetrik von Interesse abnimmt. Je größer die Änderung, desto wichtiger ist dieses Feature. Weitere Informationen zu PFI finden Sie unter Interpretieren von Modellvorhersagen mit PFI (Permutation Feature Importance).

Hinweis

Das Berechnen der PFI kann zeitaufwendig sein. Die Dauer der Berechnung ist proportional zur Anzahl vorhandener Featurespalten. Je mehr Features, desto länger die Dauer von PFI.

So bestimmen Sie die Featurerelevanz mithilfe von AutoML

Rufen Sie das beste Modell ab.
```
var bestModel = expResult.Model;
```

Wenden Sie das Modell auf Ihr Dataset an.

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

Berechnen Sie die Featurerelevanz mithilfe von PermutationFeatureImportance.

In diesem Fall ist die Aufgabe eine Regression, aber das gleiche Konzept gilt für andere Aufgaben wie Bewertung und Klassifizierung.
```
var pfiResults = 
    mlContext.Regression.PermutationFeatureImportance(bestModel, transformedData, permutationCount:3);
```

Ordnen Sie die Featurerelevanz anhand von Änderungen an Auswertungsmetriken an.

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

Freigeben über

Gewusst wie: Verwenden der API für automatisiertes maschinelles Lernen (AutoML) von ML.NET

Installation

Schnellstart

Definieren des Problems

Laden von Daten

Definieren der Pipeline

Konfigurieren Sie Ihr Experiment

Führen Sie Ihr Experiment durch

Ändern von Spaltenrückschlussergebnissen

Ausschließen von Trainern

Anpassen eines sweepfähigen Schätzers

Anpassen des Suchbereichs

Erstellen eines eigenen Testrunners

Wählen eines anderen Optimierers

Konfigurieren der Experimentüberwachung

Dauerhaftes Speichern von Tests

Abbrechen von Experimenten

Festlegen von Prüfpunkten

Bestimmen der Featurerelevanz

Zusätzliche Ressourcen