Dela via

Så här använder du API:et ML.NET Automated Machine Learning (AutoML)

  • Artikel

I den här artikeln får du lära dig hur du använder ML.NET Automatiserad ML (AutoML API).

Exempel för AutoML-API:et finns på lagringsplatsen dotnet/machinelearning-samples .

Installation

Om du vill använda AutoML-API:et Microsoft.ML.AutoML installerar du NuGet-paketet i det .NET-projekt som du vill referera till det i.

Kommentar

Den här guiden använder version 0.20.0 och senare av Microsoft.ML.AutoML NuGet-paketet. Även om exempel och kod från tidigare versioner fortfarande fungerar rekommenderar vi starkt att du använder API:erna som introducerades i den här versionen för nya projekt.

Mer information om hur du installerar NuGet-paket finns i följande guider:

Snabbstart

AutoML innehåller flera standardinställningar för att snabbt träna maskininlärningsmodeller. I det här avsnittet får du lära dig att:

  • Läs in dina data
  • Definiera din pipeline
  • Konfigurera experimentet
  • Kör experimentet
  • Använd den bästa modellen för att göra förutsägelser

Definiera ditt problem

Med tanke på en datauppsättning som lagras i en kommaavgränsad fil med namnet taxi-fare-train.csv som ser ut så här:

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

Läs in dina data

Börja med att initiera .MLContext MLContext är en startpunkt för alla ML.NET åtgärder. När mlContext initieras skapas en ny ML.NET miljö som kan delas mellan arbetsflödesobjekten för modellskapande. Det liknar konceptuellt DBContext i Entity Framework.

Använd sedan metoden för att läsa in dina data 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 läser in några rader från datauppsättningen. Den inspekterar sedan data och försöker gissa eller härleda datatypen för var och en av kolumnerna baserat på deras innehåll.

Standardbeteendet är att gruppera kolumner av samma typ i funktionsvektorer eller matriser som innehåller elementen för var och en av de enskilda kolumnerna. Inställningen groupColumns åsidosätter false standardbeteendet och utför endast kolumninferens utan att gruppera kolumner. Genom att hålla kolumnerna åtskilda kan du använda olika datatransformeringar när du förbearbetar data på enskild kolumnnivå i stället för kolumngruppering.

Resultatet av InferColumns är ett ColumnInferenceResults objekt som innehåller de alternativ som behövs för att skapa en TextLoader samt kolumninformation.

För exempeldatauppsättningen i taxi-fare-train.csv kan kolumninformationen se ut så här:

När du har din kolumninformation använder du den TextLoader.Options som definierats av ColumnInferenceResults för att skapa en TextLoader för att läsa in dina data i en IDataView.

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

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

Det är ofta bra att dela upp dina data i tränings- och valideringsuppsättningar. Använd TrainTestSplit för att skapa en 80 % träning och 20 % valideringsdelning av din datauppsättning.

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

Definiera din pipeline

Din pipeline definierar de steg för databearbetning och maskininlärningspipeline som ska användas för att träna din modell.

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

A SweepablePipeline är en samling med SweepableEstimator. A SweepableEstimator är en ML.NET Estimator med en SearchSpace.

Featurizer är ett bekvämlighets-API som skapar en svepbar pipeline med databearbetningsbara skattningar baserat på den kolumninformation du anger. I stället för att skapa en pipeline från grunden automatiserar Featurizer du förbearbetningssteget för data. Mer information om transformeringar som stöds av ML.NET finns i guiden för datatransformeringar.

Utdata Featurizer är en enda kolumn som innehåller en numerisk funktionsvektor som representerar transformerade data för var och en av kolumnerna. Den här funktionsvektorn används sedan som indata för de algoritmer som används för att träna en maskininlärningsmodell.

Om du vill ha bättre kontroll över förbearbetningen av dina data kan du skapa en pipeline med var och en av de enskilda förbearbetningsstegen. Mer information finns i förbereda data för att skapa en modellguide.

Dricks

Använd Featurizer med ColumnInferenceResults för att maximera verktyget AutoML.

För träning tillhandahåller AutoML en svepbar pipeline med standardtränings- och sökutrymmeskonfigurationer för följande maskininlärningsuppgifter:

För förutsägelseproblemet med taxipriser, eftersom målet är att förutsäga ett numeriskt värde, använder du Regression. Mer information om hur du väljer en uppgift finns i Maskininlärningsuppgifter i ML.NET.

Konfigurera experimentet

Skapa först ett AutoML-experiment. En AutoMLExperiment är en samling med TrialResult.

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

När experimentet har skapats använder du tilläggsmetoderna för att konfigurera olika inställningar.

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

I det här exemplet:

  • Ange att den svepbara pipelinen ska köras under experimentet genom att anropa SetPipeline.
  • Välj RSquared som mått för att optimera under träningen genom att anropa SetRegressionMetric. Mer information om utvärderingsmått finns i guiden utvärdera din ML.NET modell med mått .
  • Ange 60 sekunder som den tid du vill träna för genom att anropa SetTrainingTimeInSeconds. En bra heuristisk för att avgöra hur länge du ska träna för är storleken på dina data. Vanligtvis kräver större datamängder längre träningstid. Mer information finns i vägledning för träningstid.
  • Ange de tränings- och valideringsdatauppsättningar som ska användas genom att anropa SetDataset.

När experimentet har definierats vill du ha ett sätt att spåra dess förlopp. Det snabbaste sättet att spåra förloppet är genom att Log ändra händelsen från MLContext.

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

Kör experimentet

Nu när du har definierat experimentet RunAsync använder du metoden för att starta experimentet.

TrialResult experimentResults = await experiment.RunAsync();

När tiden för träning upphör är resultatet en TrialResult för den bästa modellen som hittas under träningen.

Nu kan du spara din modell eller använda den för att göra förutsägelser. Mer information om hur du använder en ML.NET modell finns i följande guider:

Ändra resultat av kolumninferens

Eftersom InferColumns endast läser in en delmängd av dina data är det möjligt att gränsfall som finns utanför de exempel som används för att härleda kolumner inte fångas och att fel datatyper har angetts för dina kolumner. Du kan uppdatera egenskaperna ColumnInformation för att ta hänsyn till de fall där kolumninferensresultaten inte är korrekta.

I datamängden taxipris är till exempel data i rate_code kolumnen ett tal. Det numeriska värdet representerar dock en kategori. Som standard sker InferColumns anropet rate_codeNumericColumnNames i egenskapen i stället CategoricalColumnNamesför . Eftersom dessa egenskaper är .NET-samlingar kan du använda standardåtgärder för att lägga till och ta bort objekt från dem.

Du kan göra följande för att uppdatera ColumnInformation för rate_code.

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

Exkludera utbildare

Som standard provar AutoML flera utbildare som en del av träningsprocessen för att se vilken som fungerar bäst för dina data. Under hela träningsprocessen kan du dock upptäcka att det finns vissa utbildare som använder för många beräkningsresurser eller inte tillhandahåller några bra utvärderingsmått. Du har möjlighet att undanta utbildare från träningsprocessen. Vilka tränare som används beror på uppgiften. En lista över utbildare som stöds i ML.NET finns i guiden Maskininlärningsuppgifter i ML.NET.

I scenariot med regression av taxipriser kan du till exempel ange parametern till useLgbmför att exkludera LightGBM-algoritmenfalse.

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

Processen för att exkludering av utbildare i andra uppgifter som binär klassificering och klassificering i flera klasser fungerar på samma sätt.

Anpassa en estimator som kan rensas

När du vill ha mer detaljerad anpassning av beräkningsalternativ som ingår som en del av din svepbara pipeline måste du:

  1. Initiera ett sökutrymme
  2. Använd sökutrymmet för att definiera en anpassad fabrik
  3. Skapa en estimator som kan rensas
  4. Lägg till din svepbara uppskattning i din svepbara pipeline

AutoML tillhandahåller en uppsättning förkonfigurerade sökutrymmen för utbildare i följande maskininlärningsuppgifter:

I det här exemplet används sökutrymmet för SdcaRegressionTrainer. Initiera det med hjälp SdcaOptionav .

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Använd sedan sökutrymmet för att definiera en anpassad fabriksmetod för att skapa SdcaRegressionTrainer. I det här exemplet anges värdena L1Regularization för och L2Regularization båda till något annat än standardvärdet. För L1Regularizationbestäms värdeuppsättningen av tunern under varje utvärderingsversion. L2Regularization Har korrigerats för varje utvärderingsversion till det hårdkodade värdet. Under varje utvärderingsversion är den anpassade fabrikens utdata en SdcaRegressionTrainer med de konfigurerade hyperparametrarna.

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

En svepbar skattningsfaktor är kombinationen av en skattare och ett sökutrymme. Nu när du har definierat ett sökutrymme och använt det för att skapa en anpassad fabriksmetod för att generera utbildare använder CreateSweepableEstimator du metoden för att skapa en ny svepbar skattare.

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

Om du vill använda din svepbara skattning i experimentet lägger du till den i din svepbara pipeline.

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

Eftersom svepbara pipelines är en samling svepbara skattningar kan du konfigurera och anpassa så många av dessa svepbara skattningar som du behöver.

Anpassa sökutrymmet

Det finns scenarier där du vill gå längre än att anpassa de svepbara skattningsfaktorer som används i experimentet och som vill kontrollera sökområdet. Du kan göra det genom att komma åt sökutrymmets egenskaper med hjälp av nycklar. I det här fallet är parametern L1Regularization en float. Om du vill anpassa sökområdet använder du UniformSingleOptiondärför .

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

Beroende på datatypen för den hyperparameter som du vill ange kan du välja bland följande alternativ:

Sökutrymmen kan också innehålla kapslade sökutrymmen.

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;

Ett annat alternativ för att anpassa sökintervall är genom att utöka dem. Till exempel SdcaOption tillhandahåller endast parametrarna L1Regularization och L2Regularization . Det finns dock SdcaRegressionTrainer fler parametrar som du kan ange, till exempel BiasLearningRate.

Om du vill utöka sökutrymmet skapar du en ny klass, till exempel SdcaExtendedOption, som ärver från SdcaOption.

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

Om du vill ange sökområdet använder du RangeAttribute, vilket motsvarar Microsoft.ML.SearchSpace.Option.

Var du än använder sökutrymmet refererar du sedan till SdcaExtendedOption i stället för SdcaOption.

När du till exempel initierar sökutrymmet kan du göra det på följande sätt:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Skapa en egen utvärderingsversion

Som standard stöder AutoML binär klassificering, klassificering av flera klasser och regression. Men ML.NET stöder många fler scenarier, till exempel:

  • Rekommendation
  • Prognostisering
  • Rangordning
  • Bildklassificering
  • Textklassificering
  • Meningslikhet

För scenarier som inte har förkonfigurerade sökutrymmen och svepbara skattningsfaktorer kan du skapa egna och använda en utvärderingsversion för att aktivera AutoML för det scenariot.

Till exempel, med tanke på restauranggranskningsdata som ser ut så här:

Oj... Älskade det här stället.

1

Skorpa är inte bra.

0

Du vill använda TextClassificationTrainer tränaren för att analysera sentiment där 0 är negativt och 1 är positiv. Det finns dock ingen ctx.Auto().TextClassification() konfiguration.

Om du vill använda AutoML med textklassificeringstränaren måste du:

  1. Skapa ett eget sökutrymme.

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

    I det här fallet söker AutoML efter olika konfigurationer av BatchSize hyperparametern.

  2. Skapa en estimator som kan rensas och lägg till den i din 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);

    I det här exemplet TCOption används sökutrymmet och en anpassad TextClassificationTrainer fabrik för att skapa en svepbar uppskattning.

  3. Skapa en anpassad utvärderingsversion

    Om du vill skapa en anpassad provkörare implementerar du 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(),
        };
    }
}

    Implementeringen TCRunner i det här exemplet:

    • Extraherar de hyperparametrar som valts för den utvärderingsversionen
    • Använder hyperparametrar för att skapa en ML.NET pipeline
    • Använder ML.NET pipeline för att träna en modell
    • Utvärderar modellen
    • Returnerar ett TrialResult objekt med informationen för utvärderingsversionen

  4. Initiera din anpassade utvärderingsversion

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

  5. Skapa och konfigurera experimentet. SetTrialRunner Använd tilläggsmetoden för att lägga till din anpassade utvärderingsversion i experimentet.

    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. Kör experimentet

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

Välj en annan tuner

AutoML stöder olika justeringsalgoritmer för att iterera genom sökutrymmet på jakt efter optimala hyperparametrar. Som standard använder den Eci Cost Frugal-tunern. Med hjälp av experimenttilläggsmetoder kan du välja en annan tuner som passar bäst för ditt scenario.

Använd följande metoder för att ange din tuner:

Om du till exempel vill använda rutnätssökmottagaren kan koden se ut så här:

experiment.SetGridSearchTuner();

Konfigurera experimentövervakning

Det snabbaste sättet att övervaka förloppet för ett experiment är att definiera Log händelsen från MLContext. Händelsen matar dock Log ut en rådump av loggarna som genereras av AutoML under varje utvärderingsversion. På grund av den stora mängden oformaterad information är det svårt.

För en mer kontrollerad övervakningsupplevelse implementerar du en klass med IMonitor gränssnittet.

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

Gränssnittet IMonitor har fyra livscykelhändelser:

Dricks

Även om det inte krävs kan du ta med din SweepablePipeline i övervakaren Parameterså att du kan inspektera pipelinen som genererades för en utvärderingsversion med egenskapen TrialSettings för .

I det här exemplet implementeras ReportCompletedTrial endast och ReportFailTrial .

När du har implementerat övervakaren anger du den som en del av experimentkonfigurationen med hjälp av SetMonitor.

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

Kör sedan experimentet:

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

När du kör experimentet med den här implementeringen bör utdata se ut ungefär så här:

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

Spara utvärderingsversioner

Som standard lagrar TrialResult AutoML endast för den bästa modellen. Men om du vill bevara var och en av utvärderingsversionerna kan du göra det från din övervakare.

Inuti bildskärmen:

  1. Definiera en egenskap för dina slutförda utvärderingsversioner och en metod för att komma åt dem.

    private readonly List<TrialResult> _completedTrials;

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

  2. Initiera den i konstruktorn

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

  3. Lägg till varje utvärderingsresultat i livscykelmetoden ReportCompletedTrial .

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

  4. När träningen är klar kan du komma åt alla slutförda utvärderingsversioner genom att anropa GetCompletedTrials

    var completedTrials = monitor.GetCompletedTrials();

Nu kan du utföra ytterligare bearbetning av samlingen av slutförda utvärderingsversioner. Du kan till exempel välja en annan modell än den som valts av AutoML, logga utvärderingsresultat till en databas eller återskapa pipelinen från någon av de slutförda utvärderingsversionerna.

Avbryt experiment

När du kör experiment asynkront måste du avsluta processen på ett rent sätt. Om du vill göra det använder du en CancellationToken.

Varning

Om du avbryter ett experiment sparas inte någon av de mellanliggande utdata. Ange en kontrollpunkt för att spara mellanliggande utdata.

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

Ange kontrollpunkter

Med kontrollpunkter kan du spara mellanliggande utdata från träningsprocessen i händelse av en tidig avslutning eller ett fel. Om du vill ange en kontrollpunkt använder du SetCheckpoint tilläggsmetoden och tillhandahåller en katalog för att lagra mellanliggande utdata.

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

Fastställa funktionsvikt

När maskininlärning introduceras i fler aspekter av vardagen, till exempel sjukvård, är det av yttersta vikt att förstå varför en maskininlärningsmodell fattar de beslut den gör. Permutation Feature Importance (PFI) är en teknik som används för att förklara klassificerings-, rangordnings- och regressionsmodeller. På en hög nivå fungerar det genom att slumpmässigt blanda data en funktion i taget för hela datamängden och beräkna hur mycket prestandamåttet av intresse minskar. Ju större förändring, desto viktigare är funktionen. Mer information om PFI finns i tolka modellförutsägelser med hjälp av funktionsvikt för permutation.

Kommentar

Att beräkna PFI kan vara en tidskrävande åtgärd. Hur lång tid det tar att beräkna är proportionellt mot antalet funktionskolumner du har. Ju fler funktioner, desto längre tid tar det att köra PFI.

Så här fastställer du funktionsvikt med Hjälp av AutoML:

  1. Hämta den bästa modellen.

    var bestModel = expResult.Model;

  2. Tillämpa modellen på din datauppsättning.

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

  3. Beräkna funktionsvikt med hjälp av PermutationFeatureImportance

    I det här fallet är uppgiften regression men samma begrepp gäller för andra uppgifter som rangordning och klassificering.

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

  4. Beställ funktionsvikt genom ändringar i utvärderingsmått.

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