Jak używać interfejsu API zautomatyzowanego uczenia maszynowego (AutoML) ML.NET

Artykuł
03/12/2024

Z tego artykułu dowiesz się, jak używać ML.NET zautomatyzowanego uczenia maszynowego (interfejs API automatycznego uczenia maszynowego).

Przykłady dotyczące interfejsu API automatycznego uczenia maszynowego można znaleźć w repozytorium dotnet/machinelearning-samples .

Instalacja

Aby użyć interfejsu API automatycznego uczenia maszynowego, zainstaluj Microsoft.ML.AutoML pakiet NuGet w projekcie platformy .NET, w którym chcesz się do niego odwołać.

Uwaga

W tym przewodniku jest używana wersja 0.20.0 lub nowsza Microsoft.ML.AutoML pakietu NuGet. Mimo że przykłady i kod z wcześniejszych wersji nadal działają, zdecydowanie zaleca się używanie interfejsów API wprowadzonych w tej wersji dla nowych projektów.

Aby uzyskać więcej informacji na temat instalowania pakietów NuGet, zobacz następujące przewodniki:

Szybkie uruchamianie

Rozwiązanie AutoML udostępnia kilka wartości domyślnych do szybkiego trenowania modeli uczenia maszynowego. W tej sekcji dowiesz się, jak wykonywać następujące działania:

Ładowanie danych
Definiowanie potoku
Konfigurowanie eksperymentu
Uruchamianie eksperymentu
Używanie najlepszego modelu do przewidywania

Definiowanie problemu

Biorąc pod uwagę zestaw danych przechowywany w pliku rozdzielanym przecinkami o nazwie taxi-fare-train.csv , który wygląda następująco:

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

Ładowanie danych

Rozpocznij od zainicjowania elementu MLContext. MLContext jest punktem wyjścia dla wszystkich operacji ML.NET. Inicjowanie metody mlContext tworzy nowe środowisko ML.NET, które może być współużytkowane przez obiekty przepływu pracy tworzenia modelu. Jest ona podobna, koncepcyjnie, do DBContext w programie Entity Framework.

Następnie, aby załadować dane, użyj InferColumns metody .

// 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 ładuje kilka wierszy z zestawu danych. Następnie sprawdza dane i próbuje odgadnąć lub wywnioskować typ danych dla każdej kolumny na podstawie ich zawartości.

Domyślne zachowanie polega na grupowaniu kolumn tego samego typu na wektory funkcji lub tablice zawierające elementy dla każdej z poszczególnych kolumn. Ustawienie groupColumns na false przesłonięcia tego domyślnego zachowania i wykonuje tylko wnioskowanie kolumn bez grupowania kolumn. Dzięki oddzieleniu kolumn można zastosować różne przekształcenia danych podczas wstępnego przetwarzania danych na poziomie poszczególnych kolumn, a nie grupowania kolumn.

Wynikiem InferColumns jest ColumnInferenceResults obiekt, który zawiera opcje potrzebne do utworzenia TextLoader , a także informacji o kolumnie.

W przypadku przykładowego zestawu danych w taxi-fare-train.csv informacje o kolumnie mogą wyglądać następująco:

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

Gdy masz informacje o kolumnie, użyj elementu zdefiniowanego TextLoader.Options przez ColumnInferenceResults element , aby utworzyć obiekt TextLoader , aby załadować dane do elementu IDataView.

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

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

Często dobrym rozwiązaniem jest podzielenie danych na zestawy trenowania i sprawdzania poprawności. Użyj polecenia TrainTestSplit , aby utworzyć podział trenowania na 80% i 20% weryfikacji zestawu danych.

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

Definiowanie potoku

Potok definiuje kroki przetwarzania danych i potok uczenia maszynowego do użycia na potrzeby trenowania modelu.

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

A SweepablePipeline jest kolekcją SweepableEstimator. A SweepableEstimator to ML.NET Estimator z elementem SearchSpace.

Jest Featurizer to wygodny interfejs API, który tworzy zamiatany potok narzędzi do szacowania z możliwością zamiatania danych na podstawie podanych informacji o kolumnie. Zamiast tworzyć potok od podstaw, Featurizer automatyzuje krok przetwarzania wstępnego danych. Aby uzyskać więcej informacji na temat obsługiwanych przekształceń przez ML.NET, zobacz przewodnik przekształcania danych.

Dane Featurizer wyjściowe to pojedyncza kolumna zawierająca wektor cech liczbowych reprezentujący przekształcone dane dla każdej kolumny. Ten wektor funkcji jest następnie używany jako dane wejściowe dla algorytmów używanych do trenowania modelu uczenia maszynowego.

Jeśli chcesz mieć bardziej precyzyjną kontrolę nad przetwarzaniem wstępnego danych, możesz utworzyć potok z każdym z poszczególnych kroków przetwarzania wstępnego. Aby uzyskać więcej informacji, zobacz przygotowywanie danych do tworzenia przewodnika po modelu.

Napiwek

Użyj polecenia Featurizer , ColumnInferenceResults aby zmaksymalizować narzędzie rozwiązania AutoML.

Na potrzeby trenowania rozwiązanie AutoML udostępnia potok z możliwością zamiatania z domyślnymi trenerami i konfiguracjami przestrzeni wyszukiwania dla następujących zadań uczenia maszynowego:

W przypadku problemu z przewidywaniem taryf taksówek, ponieważ celem jest przewidywanie wartości liczbowej, użyj wartości Regression. Aby uzyskać więcej informacji na temat wybierania zadania, zobacz Zadania uczenia maszynowego w ML.NET

Konfigurowanie eksperymentu

Najpierw utwórz eksperyment rozwiązania AutoML. Element AutoMLExperiment to kolekcja TrialResult.

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

Po utworzeniu eksperymentu użyj metod rozszerzenia, które udostępnia, aby skonfigurować różne ustawienia.

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

W tym przykładzie wykonasz następujące elementy:

Ustaw potok z możliwością zamiatania do uruchomienia podczas eksperymentu, wywołując polecenie SetPipeline.
Wybierz RSquared jako metryka, która ma być zoptymalizowana podczas trenowania, wywołując polecenie SetRegressionMetric. Aby uzyskać więcej informacji na temat metryk oceny, zobacz przewodnik oceny modelu ML.NET za pomocą metryk .
Ustaw 60 sekund jako ilość czasu, dla którego chcesz trenować, wywołując polecenie SetTrainingTimeInSeconds. Dobry heurystyczny sposób określania, jak długo należy trenować, to rozmiar danych. Zazwyczaj większe zestawy danych wymagają dłuższego czasu trenowania. Aby uzyskać więcej informacji, zobacz wskazówki dotyczące czasu trenowania.
Podaj zestawy danych trenowania i walidacji do użycia przez wywołanie metody SetDataset.

Po zdefiniowaniu eksperymentu warto śledzić jego postęp. Najszybszym sposobem śledzenia postępu jest zmodyfikowanie Log zdarzenia z MLContext.

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

Uruchamianie eksperymentu

Po zdefiniowaniu eksperymentu RunAsync użyj metody , aby rozpocząć eksperyment.

TrialResult experimentResults = await experiment.RunAsync();

Po wygaśnięciu czasu trenowania wynik jest najlepszym modelem TrialResult znalezionym podczas trenowania.

W tym momencie możesz zapisać model lub użyć go do przewidywania. Aby uzyskać więcej informacji na temat korzystania z modelu ML.NET, zobacz następujące przewodniki:

Modyfikowanie wyników wnioskowania kolumn

Ponieważ InferColumns ładuje tylko podzbiór danych, możliwe jest, że przypadki brzegowe zawarte poza przykładami używanymi do wnioskowania kolumn nie są przechwytywane, a nieprawidłowe typy danych są ustawione dla kolumn. Możesz zaktualizować właściwości elementu ColumnInformation , aby uwzględnić te przypadki, w których wyniki wnioskowania kolumny nie są poprawne.

Na przykład w zestawie danych taryf taksówek dane w rate_code kolumnie są liczbą. Jednak ta wartość liczbowa reprezentuje kategorię. Domyślnie wywołanie InferColumns spowoduje umieszczenie rate_code we NumericColumnNames właściwości zamiast CategoricalColumnNames. Ponieważ te właściwości to kolekcje platformy .NET, możesz użyć standardowych operacji, aby dodawać i usuwać z nich elementy.

Możesz wykonać następujące czynności, aby zaktualizować element ColumnInformation dla elementu rate_code.

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

Wykluczanie trenerów

Domyślnie rozwiązanie AutoML próbuje wielu trenerów w ramach procesu trenowania, aby zobaczyć, który z nich działa najlepiej dla Twoich danych. Jednak w całym procesie trenowania możesz odkryć, że istnieje kilka trenerów, którzy używają zbyt wielu zasobów obliczeniowych lub nie zapewniają dobrych metryk oceny. Masz możliwość wykluczenia trenerów z procesu szkolenia. Które trenery są używane, zależy od zadania. Aby zapoznać się z listą obsługiwanych trenerów w ML.NET, zobacz artykuł Machine Learning tasks in ML.NET guide (Zadania uczenia maszynowego w przewodniku ML.NET).

Na przykład w scenariuszu regresji taryf taksówek, aby wykluczyć algorytm LightGBM, ustaw useLgbm parametr na falsewartość .

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

Proces wykluczania trenerów w innych zadaniach, takich jak klasyfikacja binarna i wieloklasowa, działa w taki sam sposób.

Dostosowywanie narzędzia do szacowania z możliwością zamiatania

Jeśli chcesz bardziej szczegółowe dostosowywanie opcji narzędzia do szacowania uwzględnionych w ramach potoku z możliwością zamiatania, musisz wykonać następujące czynności:

Inicjowanie obszaru wyszukiwania
Definiowanie fabryki niestandardowej przy użyciu obszaru wyszukiwania
Tworzenie narzędzia do szacowania z możliwością zamiatania
Dodawanie narzędzia do szacowania z możliwością zamiatania do potoku z możliwością zamiatania

Rozwiązanie AutoML udostępnia zestaw wstępnie skonfigurowanych przestrzeni wyszukiwania dla trenerów w następujących zadaniach uczenia maszynowego:

W tym przykładzie używane miejsce wyszukiwania dotyczy elementu SdcaRegressionTrainer. Zainicjuj go przy użyciu polecenia SdcaOption.

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Następnie użyj obszaru wyszukiwania, aby zdefiniować niestandardową metodę fabryki w celu utworzenia elementu SdcaRegressionTrainer. W tym przykładzie wartości L1Regularization i L2Regularization są ustawiane na wartość inną niż domyślna. Dla L1Regularizationparametru zestaw wartości jest określany przez tuner podczas każdej próby. Parametr L2Regularization jest stały dla każdej wersji próbnej z wartością zakodowaną na stałe. Podczas każdej wersji próbnej dane wyjściowe fabryki niestandardowej są elementem SdcaRegressionTrainer ze skonfigurowanymi hiperparametrami.

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

Narzędzie do szacowania z możliwością zamiatania to połączenie narzędzia do szacowania i przestrzeni wyszukiwania. Teraz, gdy zdefiniowano przestrzeń wyszukiwania i użyto jej do utworzenia niestandardowej metody fabryki na potrzeby generowania trenerów, użyj CreateSweepableEstimator metody , aby utworzyć nowy narzędzie do szacowania zamiatania.

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

Aby użyć zamiatanego narzędzia do szacowania w eksperymencie, dodaj go do potoku z możliwością zamiatania.

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

Ponieważ zamiatane potoki są kolekcją zamiatanych narzędzi do szacowania, można skonfigurować i dostosować dowolną liczbę zamiatanych narzędzi do szacowania zgodnie z potrzebami.

Dostosowywanie obszaru wyszukiwania

Istnieją scenariusze, w których chcesz przejść poza dostosowywanie zamiatanych narzędzi do szacowania używanych w eksperymencie i chcesz kontrolować zakres przestrzeni wyszukiwania. W tym celu można uzyskać dostęp do właściwości obszaru wyszukiwania przy użyciu kluczy. W tym przypadku L1Regularization parametr to float. W związku z tym, aby dostosować zakres wyszukiwania, użyj polecenia UniformSingleOption.

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

W zależności od typu danych hiperparametru, który chcesz ustawić, można wybrać spośród następujących opcji:

Liczby
Wartości logiczne i ciągi
- ChoiceOption

Spacje wyszukiwania mogą również zawierać zagnieżdżone przestrzenie wyszukiwania.

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;

Kolejną opcją dostosowywania zakresów wyszukiwania jest ich rozszerzenie. Na przykład SdcaOption udostępnia L1Regularization tylko parametry i .L2Regularization Ma jednak więcej parametrów, SdcaRegressionTrainer które można ustawić, na przykład BiasLearningRate.

Aby rozszerzyć przestrzeń wyszukiwania, utwórz nową klasę, taką jak SdcaExtendedOption, która dziedziczy z SdcaOptionklasy .

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

Aby określić zakres przestrzeni wyszukiwania, użyj elementu RangeAttribute, który jest odpowiednikiem Microsoft.ML.SearchSpace.Option.

Następnie w dowolnym miejscu wyszukiwania odwołujesz się SdcaExtendedOption do elementu zamiast SdcaOption.

Na przykład podczas inicjowania obszaru wyszukiwania można to zrobić w następujący sposób:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Tworzenie własnego modułu uruchamiającego wersję próbną

Domyślnie rozwiązanie AutoML obsługuje klasyfikację binarną, klasyfikację wieloklasową i regresję. Jednak ML.NET obsługuje wiele innych scenariuszy, takich jak:

Zalecenie
Prognozowanie
Rankingi
Klasyfikacja obrazów
Klasyfikacja tekstu
Podobieństwo zdań

W przypadku scenariuszy, w których nie skonfigurowano wstępnie skonfigurowanych przestrzeni wyszukiwania i zamiatanych narzędzi do szacowania, możesz utworzyć własne i użyć modułu uruchamiającego wersję próbną, aby włączyć rozwiązanie AutoML dla tego scenariusza.

Na przykład biorąc pod uwagę dane dotyczące przeglądu restauracji, które wyglądają następująco:

Wow... Kochał to miejsce.

Skorupa nie jest dobra.

Chcesz użyć trenera TextClassificationTrainer , aby przeanalizować tonację, w której wartość 0 jest ujemna, a 1 jest dodatnia. Nie ma ctx.Auto().TextClassification() jednak żadnej konfiguracji.

Aby używać rozwiązania AutoML z trenerem klasyfikacji tekstu, musisz wykonać następujące elementy:

Utwórz własną przestrzeń wyszukiwania.

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

W takim przypadku rozwiązanie AutoML wyszuka różne konfiguracje hiperparametru BatchSize .

Utwórz narzędzie do szacowania z możliwością zamiatania i dodaj go do potoku.

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

W tym przykładzie TCOption przestrzeń wyszukiwania i fabryka niestandardowa TextClassificationTrainer są używane do tworzenia zamiatanego narzędzia do szacowania.

Tworzenie niestandardowego modułu uruchamiającego wersję próbną

Aby utworzyć niestandardowy moduł uruchamiający wersję próbną, zaimplementuj polecenie 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(),
        };
    }
}

Implementacja TCRunner w tym przykładzie:

Wyodrębnia hiperparametry wybrane dla tej wersji próbnej
Używa hiperparametrów do utworzenia potoku ML.NET
Trenowanie modelu przy użyciu potoku ML.NET
Ocenia model
TrialResult Zwraca obiekt z informacjami dotyczącymi tej wersji próbnej

Inicjowanie niestandardowego modułu uruchamiającego wersję próbną

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

Utwórz i skonfiguruj eksperyment. SetTrialRunner Użyj metody rozszerzenia, aby dodać niestandardowy moduł uruchamiający wersję próbną do eksperymentu.

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

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

Uruchamianie eksperymentu

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

Wybieranie innego tunera

Rozwiązanie AutoML obsługuje różne algorytmy dostrajania w celu iteracji w przestrzeni wyszukiwania w poszukiwaniu optymalnych hiperparametrów. Domyślnie używa tunera Eci Cost Frugal. Za pomocą metod rozszerzenia eksperymentu można wybrać inny tuner, który najlepiej pasuje do twojego scenariusza.

Użyj następujących metod, aby ustawić tuner:

SMAC - SetSmacTuner
Wyszukiwanie siatki - SetGridSearchTuner
Wyszukiwanie losowe - SetRandomSearchTuner
Koszt oszczędny - SetCostFrugalTuner
Eci Cost Frugal - SetEciCostFrugalTuner

Na przykład aby użyć tunera wyszukiwania siatki, kod może wyglądać następująco:

experiment.SetGridSearchTuner();

Konfigurowanie monitorowania eksperymentów

Najszybszym sposobem monitorowania postępu eksperymentu jest zdefiniowanie Log zdarzenia z .MLContext Jednak Log zdarzenie generuje nieprzetworzone zrzuty dzienników generowanych przez rozwiązanie AutoML podczas każdej wersji próbnej. Ze względu na dużą ilość niesformatowanych informacji trudno jest.

Aby uzyskać bardziej kontrolowane środowisko monitorowania, zaimplementuj klasę za pomocą interfejsu 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;
    }
}

Interfejs IMonitor ma cztery zdarzenia cyklu życia:

Napiwek

Mimo że nie jest to wymagane, uwzględnij element SweepablePipeline w monitorze, aby można było sprawdzić potok wygenerowany na potrzeby wersji próbnej przy użyciu Parameter właściwości TrialSettings.

W tym przykładzie zaimplementowane są tylko wartości ReportCompletedTrial i ReportFailTrial .

Po zaimplementowaniu monitora ustaw go jako część konfiguracji eksperymentu przy użyciu polecenia SetMonitor.

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

Następnie uruchom eksperyment:

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

Po uruchomieniu eksperymentu z tą implementacją dane wyjściowe powinny wyglądać podobnie do następujących:

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

Utrwalanie prób

Domyślnie rozwiązanie AutoML przechowuje TrialResult tylko najlepszy model. Jeśli jednak chcesz zachować każdą z prób, możesz to zrobić z poziomu monitora.

Wewnątrz monitora:

Zdefiniuj właściwość ukończonych prób i metodę uzyskiwania do nich dostępu.

private readonly List<TrialResult> _completedTrials;

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

Zainicjuj go w konstruktorze

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

Dołącz każdy wynik wersji próbnej ReportCompletedTrial wewnątrz metody cyklu życia.

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

Po zakończeniu trenowania możesz uzyskać dostęp do wszystkich ukończonych wersji próbnych, wywołując wywołanie GetCompletedTrials
```
var completedTrials = monitor.GetCompletedTrials();
```

W tym momencie można wykonać dodatkowe przetwarzanie w kolekcji ukończonych prób. Na przykład możesz wybrać model inny niż wybrany przez rozwiązanie AutoML, wyniki wersji próbnej dziennika do bazy danych lub ponownie skompilować potok z dowolnej z ukończonych prób.

Anulowanie eksperymentów

Podczas asynchronicznego uruchamiania eksperymentów upewnij się, że proces zostanie wyczyszczony. W tym celu użyj elementu CancellationToken.

Ostrzeżenie

Anulowanie eksperymentu nie spowoduje zapisania żadnych danych wyjściowych pośredniczących. Ustaw punkt kontrolny, aby zapisać pośrednie dane wyjściowe.

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

Ustawianie punktów kontrolnych

Punkty kontrolne umożliwiają zapisywanie pośredniczących danych wyjściowych z procesu trenowania w przypadku wcześniejszego zakończenia lub błędu. Aby ustawić punkt kontrolny, użyj SetCheckpoint metody rozszerzenia i podaj katalog do przechowywania danych wyjściowych pośredniczących.

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

Określanie ważności funkcji

Ponieważ uczenie maszynowe jest wprowadzane do większej liczby aspektów codziennego życia, takich jak opieka zdrowotna, niezwykle ważne jest zrozumienie, dlaczego model uczenia maszynowego podejmuje decyzje, które wykonuje. Znaczenie funkcji permutacji (PFI) to technika służąca do objaśnienia modeli klasyfikacji, klasyfikacji i regresji. Na wysokim poziomie sposób, w jaki działa, polega na losowym przetasowaniu danych jednej funkcji naraz dla całego zestawu danych i obliczeniu, ile metryki wydajności odsetek spada. Większa zmiana, tym ważniejsze jest to, że funkcja jest. Aby uzyskać więcej informacji na temat interfejsu PFI, zobacz interpretowanie przewidywań modelu przy użyciu ważności funkcji permutacji.

Uwaga

Obliczanie pfI może być czasochłonną operacją. Ile czasu zajmuje obliczenie, jest proporcjonalne do liczby posiadanych kolumn funkcji. Tym więcej funkcji będzie trwać dłuższy interfejs PFI.

Aby określić znaczenie funkcji przy użyciu rozwiązania AutoML:

Uzyskaj najlepszy model.
```
var bestModel = expResult.Model;
```

Zastosuj model do zestawu danych.

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

Obliczanie ważności funkcji przy użyciu PermutationFeatureImportance

W takim przypadku zadanie jest regresją, ale ta sama koncepcja dotyczy innych zadań, takich jak klasyfikacja i klasyfikacja.
```
var pfiResults = 
    mlContext.Regression.PermutationFeatureImportance(bestModel, transformedData, permutationCount:3);
```

Określanie ważności funkcji kolejności według zmian metryk oceny.

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

Udostępnij za pośrednictwem

Jak używać interfejsu API zautomatyzowanego uczenia maszynowego (AutoML) ML.NET

Instalacja

Szybkie uruchamianie

Definiowanie problemu

Ładowanie danych

Definiowanie potoku

Konfigurowanie eksperymentu

Uruchamianie eksperymentu

Modyfikowanie wyników wnioskowania kolumn

Wykluczanie trenerów

Dostosowywanie narzędzia do szacowania z możliwością zamiatania

Dostosowywanie obszaru wyszukiwania

Tworzenie własnego modułu uruchamiającego wersję próbną

Wybieranie innego tunera

Konfigurowanie monitorowania eksperymentów

Utrwalanie prób

Anulowanie eksperymentów

Ustawianie punktów kontrolnych

Określanie ważności funkcji

Dodatkowe zasoby