Sdílet prostřednictvím

Jak používat rozhraní API ML.NET automatizovaného strojového učení (AutoML)

  • Článek

V tomto článku se dozvíte, jak používat ML.NET automatizované strojové učení (AutoML API).

Ukázky pro rozhraní API AutoML najdete v úložišti dotnet/machinelearning-samples .

Instalace

Pokud chcete použít rozhraní API AutoML, nainstalujte Microsoft.ML.AutoML balíček NuGet do projektu .NET, ve který chcete odkazovat.

Poznámka:

Tato příručka používá verzi 0.20.0 a novější balíčku Microsoft.ML.AutoML NuGet. I když ukázky a kódy ze starších verzí stále fungují, důrazně doporučujeme používat rozhraní API zavedená v této verzi pro nové projekty.

Další informace o instalaci balíčků NuGet najdete v následujících příručkách:

Rychlé spuštění

AutoML nabízí několik výchozích hodnot pro rychlé trénování modelů strojového učení. V této části se dozvíte, jak:

  • Načtení dat
  • Definování kanálu
  • Konfigurace experimentu
  • Spuštění experimentu
  • Použití nejlepšího modelu k předpovědím

Definování problému

Pokud je datová sada uložená v souboru odděleném čárkami s názvem taxi-fare-train.csv , která vypadá takto:

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

Načtení dat

Začněte inicializací souboru MLContext. MLContext je výchozím bodem pro všechny operace ML.NET. Inicializace mlContext vytvoří nové ML.NET prostředí, které lze sdílet napříč objekty pracovního postupu vytváření modelu. Je to podobné, koncepčně, jako DBContext v Entity Frameworku.

Pak k načtení dat použijte metodu 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 načte z datové sady několik řádků. Pak zkontroluje data a pokusí se odhadnout nebo odvodit datový typ pro každý sloupec na základě jejich obsahu.

Výchozím chováním je seskupit sloupce stejného typu do vektorů funkcí nebo polí obsahujících prvky pro každý z jednotlivých sloupců. Nastavení groupColumns pro false přepsání výchozího chování a provádí odvozování sloupců pouze bez seskupení sloupců. Díky oddělení sloupců můžete při předběžném zpracování dat na úrovni jednotlivých sloupců místo seskupení sloupců použít různé transformace dat.

Výsledkem InferColumns je ColumnInferenceResults objekt, který obsahuje možnosti potřebné k vytvoření TextLoader a informace o sloupci.

U ukázkové datové sady v taxi-fare-train.csv můžou informace o sloupcích vypadat takto:

Jakmile budete mít informace o sloupci, použijte TextLoader.Options definici definovanou ColumnInferenceResults objektem TextLoader k vytvoření načtení dat do objektu IDataView.

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

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

Často je vhodné data rozdělit do trénovacích a ověřovacích sad. Slouží TrainTestSplit k vytvoření 80% trénování a 20% rozdělení datové sady.

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

Definování kanálu

Váš kanál definuje kroky zpracování dat a kanál strojového učení, který se má použít pro trénování modelu.

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

A SweepablePipeline je kolekce SweepableEstimator. A SweepableEstimator je ML.NET Estimator s SearchSpace.

Jedná se Featurizer o snadno použitelné rozhraní API, které vytváří kanál ukliditelného estimátoru zpracování dat na základě vámi zadaných informací o sloupci. Místo vytvoření kanálu úplně od začátku Featurizer automatizuje krok předběžného zpracování dat. Další informace o podporovaných transformacích podle ML.NET najdete v průvodci transformacemi dat.

Výstup Featurizer je jeden sloupec obsahující číselný vektor funkce představující transformovaná data pro každý sloupec. Tento vektor funkce se pak použije jako vstup pro algoritmy použité k trénování modelu strojového učení.

Pokud chcete jemně řídit předzpracování dat, můžete vytvořit kanál s jednotlivými kroky předběžného zpracování. Další informace najdete v přípravě dat pro vytvoření průvodce modelem.

Tip

Featurizer Slouží ColumnInferenceResults k maximalizaci nástroje AutoML.

Pro trénování poskytuje AutoML kanál s výchozími trenéry a konfigurací vyhledávacího prostoru pro následující úlohy strojového učení:

Pro predikci predikce jízdy taxíkem, protože cílem je předpovědět číselnou hodnotu, použijte Regression. Další informace o výběru úkolu najdete v tématu úlohy strojového učení v ML.NET.

Konfigurace experimentu

Nejprve vytvořte experiment AutoML. An AutoMLExperiment je kolekce TrialResult.

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

Po vytvoření experimentu použijte metody rozšíření, které poskytuje ke konfiguraci různých nastavení.

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

V tomto příkladu:

  • Nastavte zametací kanál, který se má spustit během experimentu voláním SetPipeline.
  • Zvolte RSquared jako metriku, která se má optimalizovat během trénování voláním SetRegressionMetric. Další informace o metrikách vyhodnocení najdete v průvodci metrikami k vyhodnocení modelu ML.NET.
  • Nastavte 60 sekund jako dobu, pro kterou chcete trénovat voláním SetTrainingTimeInSeconds. Dobrý heuristický způsob určení, jak dlouho se má trénovat, je velikost vašich dat. Větší datové sady obvykle vyžadují delší dobu trénování. Další informace najdete v doprovodných materiálech k trénování.
  • Zadejte trénovací a ověřovací datové sady, které se mají použít voláním SetDataset.

Po definování experimentu budete chtít nějaký způsob, jak sledovat jeho průběh. Nejrychlejší způsob, jak sledovat průběh, je úprava Log události z MLContext.

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

Spuštění experimentu

Teď, když jste definovali experiment, použijte metodu RunAsync ke spuštění experimentu.

TrialResult experimentResults = await experiment.RunAsync();

Jakmile vyprší platnost času na trénování, výsledkem je TrialResult nejlepší model nalezený během trénování.

V tomto okamžiku můžete model uložit nebo ho použít k vytváření předpovědí. Další informace o tom, jak používat model ML.NET, najdete v následujících příručkách:

Úprava výsledků odvození sloupců

Vzhledem k tomu InferColumns , že se načte jenom podmnožina dat, je možné, že hraniční případy obsažené mimo vzorky použité k odvození sloupců se nezachytí a pro sloupce jsou nastavené nesprávné datové typy. Vlastnosti ColumnInformation , které se mají zohlednit, můžete aktualizovat v případech, kdy výsledky odvozování sloupce nejsou správné.

Například v datové sadě jízdného taxislužby jsou data ve rate_code sloupci číslo. Tato číselná hodnota ale představuje kategorii. Ve výchozím nastavení se volání InferColumns umístí rate_code do NumericColumnNames vlastnosti místo CategoricalColumnNames. Vzhledem k tomu, že tyto vlastnosti jsou kolekce .NET, můžete z nich přidávat a odebírat položky pomocí standardních operací.

Můžete provést následující kroky, které aktualizují ColumnInformation for rate_code.

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

Vyloučení trenérů

AutoML ve výchozím nastavení zkouší v rámci trénovacího procesu více trenérů a zjistí, který z nich je pro vaše data nejvhodnější. Během celého procesu trénování ale můžete zjistit, že některé trenéry využívají příliš mnoho výpočetních prostředků nebo neposkytují dobré metriky hodnocení. Máte možnost vyloučit trenéry z procesu trénování. Které trenéry se používají, závisí na úkolu. Seznam podporovaných trenérů v ML.NET najdete v ML.NET příručce k úlohám strojového učení.

Například ve scénáři regrese jízdy taxíkem vyloučíte algoritmus LightGBM parametr na useLgbmhodnotu false .

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

Proces vyloučení trenérů v jiných úkolech, jako je binární a vícetřídová klasifikace, funguje stejným způsobem.

Přizpůsobení ukliditelného odhadce

Pokud chcete podrobnější přizpůsobení možností estimátoru, které jsou součástí zametacího kanálu, musíte:

  1. Inicializace vyhledávacího prostoru
  2. Použití vyhledávacího prostoru k definování vlastní továrny
  3. Vytvoření ukliditelného odhadce
  4. Přidání ukliditelného estimátoru do kanálu s možností úklidu

AutoML poskytuje sadu předkonfigurovaných prostorů hledání pro trenéry v následujících úlohách strojového učení:

V tomto příkladu je použitý vyhledávací prostor pro SdcaRegressionTrainer. Inicializace pomocí .SdcaOption

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Pak pomocí vyhledávacího prostoru definujte vlastní metodu SdcaRegressionTrainertovárny k vytvoření . V tomto příkladu jsou hodnoty L1Regularization a L2Regularization obě jsou nastaveny na něco jiného než výchozí. Sada L1Regularizationhodnot je určena tunerem během každého zkušebního období. Pro L2Regularization každou zkušební verzi je opravena pevně zakódovaná hodnota. Během každé zkušební verze je SdcaRegressionTrainer výstupem vlastní továrny nakonfigurované hyperparametry.

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

Ukliditelný estimátor je kombinace estimátoru a vyhledávacího prostoru. Teď, když jste definovali vyhledávací prostor a použili ho k vytvoření vlastní metody továrny pro generování trenérů, použijte metodu CreateSweepableEstimator k vytvoření nového zametacího estimátoru.

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

Pokud chcete ve svém experimentu použít ukliditelného estimátoru, přidejte ho do kanálu s možností úklidu.

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

Protože ukliditelné kanály představují kolekci ukliditelných estimátorů, můžete nakonfigurovat a přizpůsobit tolik z těchto ukliditelných estimátorů, kolik potřebujete.

Přizpůsobení vyhledávacího prostoru

Existují scénáře, ve kterých chcete nad rámec přizpůsobení uklidněných estimátorů použitých v experimentu použít a chcete řídit rozsah vyhledávacího prostoru. Můžete to udělat tak, že pomocí klíčů získáte přístup k vlastnostem vyhledávacího prostoru. V tomto případě L1Regularization je parametr .float Proto k přizpůsobení rozsahu hledání použijte UniformSingleOption.

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

V závislosti na datovém typu hyperparametru, který chcete nastavit, si můžete vybrat z následujících možností:

Vyhledávací prostory můžou obsahovat také vnořené vyhledávací prostory.

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;

Další možností přizpůsobení rozsahů hledání je jejich rozšíření. Například SdcaOption poskytuje pouze parametry L1Regularization a L2Regularization parametry. Má však více parametrů, SdcaRegressionTrainer které můžete nastavit například BiasLearningRate.

Pokud chcete rozšířit vyhledávací prostor, vytvořte novou třídu, například SdcaExtendedOption, která dědí z SdcaOption.

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

Chcete-li zadat rozsah vyhledávacího prostoru, použijte RangeAttribute, který je ekvivalentní Microsoft.ML.SearchSpace.Option.

Pak kdekoli použijete vyhledávací prostor, místo na něj SdcaExtendedOptionodkazujte SdcaOption .

Když například inicializujete vyhledávací prostor, můžete to udělat takto:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Vytvoření vlastního zkušebního spouštěče

AutoML ve výchozím nastavení podporuje binární klasifikaci, klasifikaci s více třídami a regresi. ML.NET však podporuje mnoho dalších scénářů, například:

  • Doporučení
  • Prognostika
  • Hodnocení
  • Klasifikace obrázku
  • Klasifikace textu
  • Podobnost vět

Ve scénářích, které nemají předkonfigurované vyhledávací prostory a smetitelné estimátory, můžete vytvořit vlastní a použít spouštěč zkušebních verzí k povolení AutoML pro tento scénář.

Například v dané restauraci zkontrolujte data, která vypadají takto:

Páni... Miloval jsem toto místo.

1

Kůra není dobrá.

0

Chcete použít TextClassificationTrainer trenéra k analýze mínění, kde je 0 záporné a 1 je pozitivní. Neexistuje však žádná ctx.Auto().TextClassification() konfigurace.

Pokud chcete autoML používat s trenérem klasifikace textu, budete muset:

  1. Vytvořte si vlastní vyhledávací prostor.

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

    V tomto případě AutoML vyhledá různé konfigurace hyperparametru BatchSize .

  2. Vytvořte ukliditelné estimátor a přidejte ho do kanálu.

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

    V tomto příkladu TCOption se k vytvoření ukliditelného estimátoru používá vyhledávací prostor a vlastní TextClassificationTrainer továrna.

  3. Vytvoření vlastního spouštěče zkušebních verzí

    Pokud chcete vytvořit vlastní spouštěč zkušebních verzí, implementujte 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(),
        };
    }
}

    Implementace TCRunner v tomto příkladu:

    • Extrahuje hyperparametry vybrané pro danou zkušební verzi.
    • Vytvoří kanál ML.NET pomocí hyperparametrů.
    • Používá kanál ML.NET k trénování modelu.
    • Vyhodnotí model.
    • Vrátí objekt s informacemi pro danou TrialResult zkušební verzi.

  4. Inicializace vlastního spouštěče zkušebních verzí

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

  5. Vytvořte a nakonfigurujte experiment. SetTrialRunner Pomocí metody rozšíření můžete do experimentu přidat vlastní spouštěč zkušebních verzí.

    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. Spuštění experimentu

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

Volba jiného tuneru

AutoML podporuje různé algoritmy ladění pro iteraci vyhledávacího prostoru při hledání optimálních hyperparametrů. Ve výchozím nastavení používá tuner Eci Cost Frugal. Pomocí metod rozšíření experimentu můžete zvolit jiný tuner, který nejlépe vyhovuje vašemu scénáři.

K nastavení tuneru použijte následující metody:

Pokud chcete například použít tuner vyhledávání v mřížce, může váš kód vypadat takto:

experiment.SetGridSearchTuner();

Konfigurace monitorování experimentů

Nejrychlejší způsob, jak monitorovat průběh experimentu, je definovat Log událost z MLContext. Událost Log však vypíše nezpracovaný výpis protokolů vygenerovaných službou AutoML během každé zkušební verze. Vzhledem k velkému množství neformátovaných informací je obtížné.

Pro více řízené prostředí monitorování implementujte třídu s rozhraním IMonitor .

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

Rozhraní IMonitor má čtyři události životního cyklu:

Tip

I když to není nutné, zahrňte ho SweepablePipeline do svého monitoru, abyste mohli zkontrolovat kanál, který byl vygenerován pro zkušební verzi, pomocí Parameter vlastnosti TrialSettings.

V tomto příkladu jsou implementovány ReportCompletedTrial pouze a ReportFailTrial implementované.

Po implementaci monitoru ho nastavte jako součást konfigurace experimentu pomocí SetMonitor.

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

Pak spusťte experiment:

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

Při spuštění experimentu s touto implementací by měl výstup vypadat nějak takto:

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

Trvalé pokusy

AutoML ve výchozím nastavení ukládá TrialResult pouze nejlepší model. Pokud ale chcete zachovat každou z těchto pokusů, můžete to udělat ze svého monitoru.

Uvnitř monitoru:

  1. Definujte vlastnost pro dokončené zkušební verze a metodu pro přístup k nim.

    private readonly List<TrialResult> _completedTrials;

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

  2. Inicializace v konstruktoru

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

  3. Připojte ReportCompletedTrial každý výsledek zkušební verze do své metody životního cyklu.

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

  4. Po dokončení trénování můžete získat přístup ke všem dokončeným zkušebním verzím voláním GetCompletedTrials

    var completedTrials = monitor.GetCompletedTrials();

V tomto okamžiku můžete provést další zpracování u kolekce dokončených zkušebních verzí. Můžete například zvolit jiný model než model vybraný službou AutoML, protokolovat výsledky zkušební verze do databáze nebo znovu sestavit kanál z některé z dokončených zkušebních verzí.

Zrušení experimentů

Při asynchronním spouštění experimentů nezapomeňte proces čistě ukončit. Uděláte to tak, že použijete .CancellationToken

Upozorňující

Zrušením experimentu se neuloží žádný z zprostředkujících výstupů. Nastavte kontrolní bod pro uložení zprostředkujících výstupů.

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

Nastavení kontrolních bodů

Kontrolní body poskytují způsob, jak uložit zprostředkující výstupy z procesu trénování v případě předčasného ukončení nebo chyby. Pokud chcete nastavit kontrolní bod, použijte metodu SetCheckpoint rozšíření a zadejte adresář pro uložení zprostředkující výstupy.

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

Určení důležitosti funkce

Vzhledem k tomu, že strojové učení je zavedeno do více aspektů každodenního života, jako je zdravotní péče, je nanejvýš důležité pochopit, proč model strojového učení dělá rozhodnutí. Permutation Feature Importance (PFI) je technika, která slouží k vysvětlení klasifikačních, řazení a regresních modelů. Na vysoké úrovni je způsob, jakým funguje, náhodným náhodném prohazování jedné funkce pro celou datovou sadu a výpočtu toho, kolik metrik výkonu zájmu klesá. Čím větší je změna, tím důležitější je tato funkce. Další informace o PFI naleznete v tématu Interpretace predikcí modelu pomocí permutation Feature Importance.

Poznámka:

Výpočet PFI může být časově náročná operace. Kolik času k výpočtu je úměrné počtu sloupců funkcí, které máte. Čím více funkcí, tím delší bude pfii trvat.

Určení důležitosti funkcí pomocí AutoML:

  1. Získejte nejlepší model.

    var bestModel = expResult.Model;

  2. Použijte model na datovou sadu.

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

  3. Výpočet důležitosti funkcí pomocí PermutationFeatureImportance

    V tomto případě je úkol regrese, ale stejný koncept se vztahuje na jiné úkoly, jako je řazení a klasifikace.

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

  4. Pořadí důležitosti funkcí podle změn v metrikách vyhodnocení

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