Delen via

De ML.NET AutoML-API (Automated Machine Learning) gebruiken

  • Artikel

In dit artikel leert u hoe u de ML.NET Automated ML (AutoML API) gebruikt.

Voorbeelden voor de AutoML-API vindt u in de opslagplaats dotnet/machinelearning-samples .

Installatie

Als u de AutoML-API wilt gebruiken, installeert u het Microsoft.ML.AutoML NuGet-pakket in het .NET-project waarin u ernaar wilt verwijzen.

Notitie

In deze handleiding wordt versie 0.20.0 en hoger van het Microsoft.ML.AutoML NuGet-pakket gebruikt. Hoewel voorbeelden en code uit eerdere versies nog steeds werken, wordt het ten zeerste aanbevolen om de API's te gebruiken die in deze versie zijn geïntroduceerd voor nieuwe projecten.

Zie de volgende handleidingen voor meer informatie over het installeren van NuGet-pakketten:

Snel starten

AutoML biedt verschillende standaardinstellingen voor het snel trainen van machine learning-modellen. In deze sectie leert u het volgende:

  • Uw gegevens laden
  • Uw pijplijn definiëren
  • Uw experiment configureren
  • Uw experiment uitvoeren
  • Het beste model gebruiken om voorspellingen te doen

Uw probleem definiëren

Gezien een gegevensset die is opgeslagen in een door komma's gescheiden bestand met de naam taxi-fare-train.csv dat er als volgt uitziet:

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

Uw gegevens laden

Begin met het initialiseren van uw MLContext. MLContext is een uitgangspunt voor alle ML.NET bewerkingen. Bij het initialiseren van mlContext wordt een nieuwe ML.NET omgeving gemaakt die kan worden gedeeld met de werkstroomobjecten voor het maken van modellen. Het is vergelijkbaar, conceptueel gezien, met DBContext in Entity Framework.

Gebruik vervolgens de InferColumns methode om uw gegevens te laden.

// 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 laadt een paar rijen uit de gegevensset. Vervolgens worden de gegevens gecontroleerd en wordt geprobeerd het gegevenstype voor elk van de kolommen te raden of af te stellen op basis van hun inhoud.

Het standaardgedrag is om kolommen van hetzelfde type te groeperen in functievectoren of matrices die de elementen voor elk van de afzonderlijke kolommen bevatten. Instellen groupColumns dat false standaardgedrag wordt overschreven en alleen kolomdeductie uitvoert zonder kolommen te groeperen. Door kolommen gescheiden te houden, kunt u verschillende gegevenstransformaties toepassen bij het vooraf verwerken van de gegevens op het niveau van de afzonderlijke kolom in plaats van de kolomgroepering.

Het resultaat is InferColumns een ColumnInferenceResults object dat de opties bevat die nodig zijn voor het maken van een TextLoader en kolomgegevens.

Voor de voorbeeldgegevensset in taxi-fare-train.csv ziet kolomgegevens er mogelijk als volgt uit:

Zodra u uw kolomgegevens hebt, gebruikt u de TextLoader.Options gedefinieerde door de ColumnInferenceResults functie om een TextLoader gegevens te maken om uw gegevens in een IDataViewte laden.

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

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

Het is vaak raadzaam om uw gegevens op te splitsen in trainings- en validatiesets. Gebruik TrainTestSplit dit om een 80% trainings- en 20% validatiesplitsing van uw gegevensset te maken.

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

Uw pijplijn definiëren

Uw pijplijn definieert de stappen voor gegevensverwerking en machine learning-pijplijn die moeten worden gebruikt voor het trainen van uw model.

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

A SweepablePipeline is een verzameling van SweepableEstimator. A SweepableEstimator is een ML.NET Estimator met een SearchSpace.

De Featurizer api is een handige API waarmee een opruimende pijplijn wordt gebouwd voor gegevensverwerking op basis van de kolomgegevens die u opgeeft. In plaats van een volledig nieuwe pijplijn te bouwen, Featurizer automatiseert u de stap voorverwerking van gegevens. Zie de handleiding voor gegevenstransformaties voor meer informatie over ondersteunde transformaties door ML.NET.

De Featurizer uitvoer is één kolom met een numerieke functievector die de getransformeerde gegevens voor elk van de kolommen vertegenwoordigt. Deze functievector wordt vervolgens gebruikt als invoer voor de algoritmen die worden gebruikt om een machine learning-model te trainen.

Als u meer controle wilt over uw gegevensvoorverwerking, kunt u een pijplijn maken met elk van de afzonderlijke voorverwerkingsstappen. Zie de voorbereidingsgegevens voor het bouwen van een modelhandleiding voor meer informatie.

Tip

Gebruik Featurizer dit om ColumnInferenceResults het hulpprogramma van AutoML te maximaliseren.

Voor training biedt AutoML een opruimende pijplijn met standaardtrainers en zoekruimteconfiguraties voor de volgende machine learning-taken:

Voor het probleem met het taxitarief, omdat het doel is om een numerieke waarde te voorspellen, gebruikt Regressionu . Zie Machine Learning-taken in ML.NET voor meer informatie over het kiezen van een taak

Uw experiment configureren

Maak eerst een AutoML-experiment. Een AutoMLExperiment is een verzameling van TrialResult.

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

Zodra uw experiment is gemaakt, gebruikt u de extensiemethoden die het biedt om verschillende instellingen te configureren.

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

In dit voorbeeld gaat u als volgt te werk:

Zodra uw experiment is gedefinieerd, wilt u de voortgang ervan bijhouden. De snelste manier om de voortgang bij te houden is door de Log gebeurtenis te wijzigen van MLContext.

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

Uw experiment uitvoeren

Nu u uw experiment hebt gedefinieerd, gebruikt u de RunAsync methode om uw experiment te starten.

TrialResult experimentResults = await experiment.RunAsync();

Zodra de tijd om te trainen is verlopen, is het resultaat een TrialResult voor het beste model dat tijdens de training wordt gevonden.

Op dit moment kunt u uw model opslaan of gebruiken voor het maken van voorspellingen. Zie de volgende handleidingen voor meer informatie over het gebruik van een ML.NET model:

Resultaten van kolomdeductie wijzigen

Omdat InferColumns alleen een subset van uw gegevens wordt geladen, is het mogelijk dat randcases buiten de voorbeelden die worden gebruikt om kolommen af te stellen, niet worden afgevangen en dat de verkeerde gegevenstypen zijn ingesteld voor uw kolommen. U kunt de eigenschappen bijwerken om ColumnInformation rekening te houden met die gevallen waarin de resultaten van de kolomdeductie niet juist zijn.

In de gegevensset taxirit is de gegevens in de rate_code kolom bijvoorbeeld een getal. Deze numerieke waarde vertegenwoordigt echter een categorie. InferColumns Standaard wordt bellen in de rate_code eigenschap in NumericColumnNames plaats van CategoricalColumnNamesin . Omdat deze eigenschappen .NET-verzamelingen zijn, kunt u standaardbewerkingen gebruiken om items eraan toe te voegen en te verwijderen.

U kunt het volgende doen om de ColumnInformation for bij rate_codete werken.

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

Trainers uitsluiten

AutoML probeert standaard meerdere trainers als onderdeel van het trainingsproces om te zien welke het beste werkt voor uw gegevens. Tijdens het trainingsproces kunt u echter ontdekken dat er een aantal trainers zijn die te veel rekenresources gebruiken of geen goede metrische evaluatiegegevens bieden. U hebt de mogelijkheid om trainers uit te sluiten van het trainingsproces. Welke trainers worden gebruikt, is afhankelijk van de taak. Zie de machine learning-taken in ML.NET handleiding voor een lijst met ondersteunde trainers in ML.NET.

Stel bijvoorbeeld in het scenario voor taxiritme de parameter useLgbmin op regressie om het LightGBM-algoritme uit te sluitenfalse.

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

Het proces voor het uitsluiten van trainers in andere taken, zoals binaire en multiklasseclassificatie, werkt op dezelfde manier.

Een veegbare estimator aanpassen

Als u meer gedetailleerde aanpassing van de estimatoropties wilt opnemen als onderdeel van uw opruimende pijplijn, moet u het volgende doen:

  1. Een zoekruimte initialiseren
  2. De zoekruimte gebruiken om een aangepaste factory te definiëren
  3. Een veegbare estimator maken
  4. Uw opruimende estimator toevoegen aan uw opruimende pijplijn

AutoML biedt een set vooraf geconfigureerde zoekruimten voor trainers in de volgende machine learning-taken:

In dit voorbeeld is de gebruikte zoekruimte voor de SdcaRegressionTrainer. Initialiseer het met behulp van SdcaOption.

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Gebruik vervolgens de zoekruimte om een aangepaste factorymethode te definiëren om de SdcaRegressionTrainer. In dit voorbeeld worden de waarden van L1Regularization en L2Regularization beide ingesteld op iets anders dan de standaardwaarde. Voor L1Regularization, de waarde set wordt bepaald door de tuner tijdens elke proefversie. De L2Regularization waarde is vast voor elke proefversie op de in code vastgelegde waarde. Tijdens elke proefversie is de uitvoer van de aangepaste factory een SdcaRegressionTrainer met de geconfigureerde hyperparameters.

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

Een opruimende estimator is de combinatie van een estimator en een zoekruimte. Nu u een zoekruimte hebt gedefinieerd en deze hebt gebruikt om een aangepaste fabrieksmethode te maken voor het genereren van trainers, gebruikt u de CreateSweepableEstimator methode om een nieuwe opruimende estimator te maken.

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

Als u uw opruimende estimator in uw experiment wilt gebruiken, voegt u deze toe aan uw opruimende pijplijn.

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

Omdat opruimende pijplijnen een verzameling van sweepable estimators zijn, kunt u zo veel van deze opruimende schattingen configureren en aanpassen als u nodig hebt.

Uw zoekruimte aanpassen

Er zijn scenario's waarin u verder wilt gaan dan het aanpassen van de veegbare schattingen die in uw experiment worden gebruikt en het bereik van de zoekruimte wilt beheren. U kunt dit doen door toegang te krijgen tot de eigenschappen van de zoekruimte met behulp van sleutels. In dit geval is de L1Regularization parameter een float. Gebruik daarom om het zoekbereik UniformSingleOptionaan te passen.

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

Afhankelijk van het gegevenstype van de hyperparameter die u wilt instellen, kunt u kiezen uit de volgende opties:

Zoekruimten kunnen ook geneste zoekruimten bevatten.

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;

Een andere optie voor het aanpassen van zoekbereiken is door ze uit te breiden. Geeft bijvoorbeeld SdcaOption alleen de L1Regularization en L2Regularization parameters op. SdcaRegressionTrainer Heeft echter meer parameters die u kunt instellen, zoals BiasLearningRate.

Als u de zoekruimte wilt uitbreiden, maakt u een nieuwe klasse, zoals SdcaExtendedOption, die overdrat van SdcaOption.

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

Als u het bereik van de zoekruimte wilt opgeven, gebruikt RangeAttributeu , wat gelijk is aan Microsoft.ML.SearchSpace.Option.

Wanneer u vervolgens uw zoekruimte gebruikt, verwijst u naar de SdcaExtendedOption plaats van SdcaOption.

Wanneer u bijvoorbeeld uw zoekruimte initialiseert, kunt u dit als volgt doen:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Uw eigen proefloper maken

AutoML biedt standaard ondersteuning voor binaire classificatie, classificatie van meerdere klassen en regressie. ML.NET ondersteunt echter nog veel meer scenario's, zoals:

  • Aanbeveling
  • Prognoses opstellen
  • Rangorde
  • Afbeeldingsclassificatie
  • Tekstclassificatie
  • Gelijkenis van zin

Voor scenario's die geen vooraf geconfigureerde zoekruimten en opruimende schattingen hebben, kunt u uw eigen zoekruimte maken en een proefloper gebruiken om AutoML voor dat scenario in te schakelen.

Als u bijvoorbeeld gegevens van een restaurant bekijkt die er als volgt uitziet:

Wauw... Ik hield van deze plek.

1

Korst is niet goed.

0

U wilt de TextClassificationTrainer trainer gebruiken om gevoel te analyseren waarbij 0 negatief is en 1 positief is. Er is echter geen ctx.Auto().TextClassification() configuratie.

Als u AutoML wilt gebruiken met de trainer voor tekstclassificatie, moet u het volgende doen:

  1. Maak uw eigen zoekruimte.

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

    In dit geval zoekt AutoML naar verschillende configuraties van de BatchSize hyperparameter.

  2. Maak een opruimende estimator en voeg deze toe aan uw pijplijn.

    // 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 dit voorbeeld worden de TCOption zoekruimte en een aangepaste TextClassificationTrainer fabriek gebruikt om een veegbare estimator te maken.

  3. Een aangepaste proefloper maken

    Als u een aangepaste proefloper wilt maken, implementeert u 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(),
        };
    }
}

    De TCRunner implementatie in dit voorbeeld:

    • Extraheert de hyperparameters die zijn gekozen voor die proefversie
    • Gebruikt de hyperparameters om een ML.NET-pijplijn te maken
    • Gebruikt de ML.NET-pijplijn om een model te trainen
    • Evalueert het model
    • Retourneert een TrialResult object met de informatie voor die proefversie

  4. Uw aangepaste proefloper initialiseren

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

  5. Uw experiment maken en configureren. Gebruik de SetTrialRunner extensiemethode om uw aangepaste proefloper toe te voegen aan uw experiment.

    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. Uw experiment uitvoeren

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

Kies een andere tuner

AutoML ondersteunt verschillende afstemmingsalgoritmen om de zoekruimte te herhalen bij het zoeken naar de optimale hyperparameters. Standaard wordt de Eci Cost Frugal-tuner gebruikt. Met behulp van experimentextensiemethoden kunt u een andere tuner kiezen die het beste bij uw scenario past.

Gebruik de volgende methoden om uw tuner in te stellen:

Als u bijvoorbeeld de grid search tuner wilt gebruiken, kan uw code er als volgt uitzien:

experiment.SetGridSearchTuner();

Experimentbewaking configureren

De snelste manier om de voortgang van een experiment te bewaken, is door de Log gebeurtenis te definiëren van MLContext. De Log gebeurtenis voert echter een onbewerkte dump uit van de logboeken die tijdens elke proefversie door AutoML worden gegenereerd. Vanwege de grote hoeveelheid niet-opgemaakte informatie is het moeilijk.

Implementeer een klasse met de IMonitor interface voor een meer gecontroleerde bewakingservaring.

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

De IMonitor interface heeft vier levenscyclusgebeurtenissen:

Tip

Hoewel dit niet vereist is, neemt u uw SweepablePipeline monitor op, zodat u de pijplijn kunt inspecteren die is gegenereerd voor een proefversie met behulp van de Parameter eigenschap van de TrialSettings.

In dit voorbeeld worden alleen de ReportCompletedTrial en ReportFailTrial geïmplementeerd.

Nadat u uw monitor hebt geïmplementeerd, stelt u deze in als onderdeel van uw experimentconfiguratie met behulp van SetMonitor.

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

Voer vervolgens uw experiment uit:

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

Wanneer u het experiment met deze implementatie uitvoert, moet de uitvoer er ongeveer als volgt uitzien:

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

Proefprojecten behouden

Standaard slaat AutoML alleen het TrialResult beste model op. Als u echter elk van de proefversies wilt behouden, kunt u dit doen vanuit uw monitor.

Binnen uw monitor:

  1. Definieer een eigenschap voor uw voltooide proefversies en een methode om deze te openen.

    private readonly List<TrialResult> _completedTrials;

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

  2. Initialiseer deze in uw constructor

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

  3. Voeg elk proefresultaat toe aan uw ReportCompletedTrial levenscyclusmethode.

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

  4. Wanneer de training is voltooid, hebt u toegang tot alle voltooide proefversies door aan te roepen GetCompletedTrials

    var completedTrials = monitor.GetCompletedTrials();

Op dit moment kunt u aanvullende verwerking uitvoeren voor de verzameling voltooide proefversies. U kunt bijvoorbeeld een ander model kiezen dan het model dat is geselecteerd door AutoML, resultaten van proefabonnementen vastleggen in een database of de pijplijn opnieuw bouwen vanuit een van de voltooide proefversies.

Experimenten annuleren

Wanneer u experimenten asynchroon uitvoert, moet u het proces op schone wijze beëindigen. Gebruik hiervoor een CancellationToken.

Waarschuwing

Als u een experiment annuleert, worden geen tussenliggende uitvoer opgeslagen. Stel een controlepunt in om intermediaire uitvoer op te slaan.

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

Controlepunten instellen

Controlepunten bieden een manier om tussenliggende uitvoer van het trainingsproces op te slaan in het geval van een vroegtijdige beëindiging of fout. Als u een controlepunt wilt instellen, gebruikt u de SetCheckpoint extensiemethode en geeft u een map op om de tussenliggende uitvoer op te slaan.

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

Het belang van functies bepalen

Omdat machine learning wordt geïntroduceerd in meer aspecten van het dagelijkse leven, zoals gezondheidszorg, is het van het grootste belang om te begrijpen waarom een machine learning-model de beslissingen neemt die het doet. PFI (Permutation Feature Importance) is een techniek die wordt gebruikt om classificatie-, classificatie- en regressiemodellen uit te leggen. Op een hoog niveau is de manier waarop het werkt door willekeurig gegevens één functie tegelijk te shuffling voor de hele gegevensset en door te berekenen hoeveel de metrische prestatiegegevens van belang afnemen. Hoe groter de wijziging, hoe belangrijker die functie is. Zie modelvoorspellingen interpreteren met behulp van Het belang van permutatiefuncties voor meer informatie over PFI.

Notitie

Het berekenen van PFI kan een tijdrovende bewerking zijn. Hoeveel tijd het kost om te berekenen, is evenredig met het aantal functiekolommen dat u hebt. Hoe meer functies, hoe langer het duurt om PFI uit te voeren.

Het belang van functies bepalen met Behulp van AutoML:

  1. Haal het beste model op.

    var bestModel = expResult.Model;

  2. Pas het model toe op uw gegevensset.

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

  3. Het belang van functies berekenen met behulp van PermutationFeatureImportance

    In dit geval is de taak regressie, maar hetzelfde concept is van toepassing op andere taken, zoals rangschikking en classificatie.

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

  4. Het belang van de functie ordenen door wijzigingen in metrische evaluatiegegevens.

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