Condividi tramite

Come usare l'API di Machine Learning automatizzato (AutoML) ML.NET

  • Articolo

Questo articolo illustra come usare il ML.NET ML automatizzato (API AutoML).

I campioni per l'API AutoML sono disponibili nel repository dotnet/machinelearning-samples.

Installazione

Per usare l'API AutoML, installare il pacchetto NuGet Microsoft.ML.AutoML nel progetto .NET a cui si vuole fare riferimento.

Nota

Questa guida usa la versione 0.20.0 e successive del pacchetto NuGet Microsoft.ML.AutoML. Sebbene gli esempi e il codice delle versioni precedenti funzionino ancora, è consigliabile usare le API introdotte in questa versione per nuovi progetti.

Per ulteriori informazioni sull'installazione di pacchetti NuGet, consultare le seguenti guide:

Guida introduttiva

AutoML offre diverse impostazioni predefinite per il training rapido dei modelli di Machine Learning. In questa sezione si imparerà come effettuare le seguenti operazioni:

  • Caricare i dati
  • Definire la pipeline
  • Configurare l'esperimento
  • Eseguire l'esperimento
  • Usare il modello più efficace per effettuare previsioni

Definire il problema

Dato un set di dati archiviato in un file delimitato da virgole denominato taxi-fare-train.csv simile al seguente:

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

Caricare i dati

Cominciare inizializzando MLContext. MLContext è un punto di partenza per tutte le operazioni di ML.NET. L'inizializzazione di mlContext crea un nuovo ambiente ML.NET che può essere condiviso tra gli oggetti del flusso di lavoro di creazione del modello. Dal punto di vista concettuale è simile a DBContext in Entity Framework.

Quindi, per caricare i dati, usare il metodo 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 carica alcune righe dal set di dati. Quindi, esamina i dati e tenta di indovinare o dedurre il tipo di dati per ognuna delle colonne in base al relativo contenuto.

Il comportamento predefinito consiste nel raggruppare le colonne dello stesso tipo in vettori di funzionalità o matrici contenenti gli elementi di ognuna delle singole colonne. L'impostazione di groupColumns su false esegue l'override del comportamento predefinito ed esegue solo l'inferenza delle colonne senza raggrupparle. Mantenendo separate le colonne, è possibile applicare diverse trasformazioni di dati durante la pre-elaborazione dei dati a livello di singola colonna anziché del gruppo di colonne.

Il risultato di InferColumns è un oggetto ColumnInferenceResults contenente le opzioni necessarie per creare un oggetto TextLoader e informazioni sulle colonne.

Per il set di dati campione in taxi-fare-train.csv, le informazioni sulla colonna potrebbero essere simili alle seguenti:

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

Dopo aver ottenuto le informazioni sulla colonna, usare il TextLoader.Options definito da ColumnInferenceResults per creare un TextLoader per caricare i dati in un IDataView.

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

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

Spesso, è consigliabile suddividere i dati in set di training e convalida. Usare TrainTestSplit per creare dividere il set di dati in 80% training e 20% convalida.

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

Definire la pipeline

La pipeline definisce i passaggi di elaborazione dei dati e la pipeline di Machine Learning da usare per il training del modello.

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

Un SweepablePipeline è una raccolta di SweepableEstimator. Un SweepableEstimator è un ML.NET Estimator con un SearchSpace.

Featurizer è un pratica API che crea una pipeline spazzabile di estimatori spazzabili per l'elaborazione dei dati in base alle informazioni sulla colonna fornite. Anziché creare una pipeline da zero, Featurizer automatizza il passaggio di pre-elaborazione dei dati. Per ulteriori informazioni sulle trasformazioni supportate da ML.NET, consultare la guida alle trasformazioni dei dati.

L'output Featurizer è una singola colonna contenente un vettore di funzionalità numerico che rappresenta i dati trasformati per ognuna delle colonne. Questo vettore di funzionalità viene quindi usato come input per gli algoritmi impiegati per eseguire il training di un modello di Machine Learning.

Se desidera miglior controllo sulla pre-elaborazione dei dati, è possibile creare una pipeline con ognuno dei singoli passaggi di pre-elaborazione. Per ulteriori informazioni, consultare la guida alla preparazione dei dati per la compilazione di un modello.

Suggerimento

Usare Featurizer con ColumnInferenceResults per ottimizzare l'utilità di AutoML.

Per il training, AutoML offre una pipeline spazzabile con trainer predefiniti e configurazioni dello spazio di ricerca per le seguenti attività di Machine Learning:

Per il problema di stima delle tariffe dei taxi, poiché l'obiettivo è stimare un valore numerico, usare Regression. Per ulteriori informazioni sulla scelta di un'attività, consultare Attività di Machine Learning in ML.NET

Configurare l'esperimento

Prima di tutto, creare un esperimento AutoML. Un AutoMLExperiment è una raccolta di TrialResult.

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

Dopo aver creato l'esperimento, usare i metodi di estensione forniti per configurare diverse impostazioni.

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

In questo esempio:

  • Impostare la pipeline spazzabile da eseguire durante l'esperimento chiamando SetPipeline.
  • Scegliere RSquared come metrica da ottimizzare durante il training chiamando SetRegressionMetric. Per ulteriori informazioni sulle metriche di valutazione, consultare la guida su come valutare il modello di ML.NET con le metriche.
  • Impostare 60 secondi come intervallo di tempo per cui si desidera eseguire il training chiamando SetTrainingTimeInSeconds. Un'euristica efficace per determinare per quanto tempo eseguire il training è la dimensione dei dati. In genere, set di dati di dimensioni maggiori richiedono tempi di training più lunghi. Per ulteriori informazioni, consultare Linee guida sul tempo di training.
  • Fornire i set di dati di training e convalida da usare chiamando SetDataset.

Dopo aver definito l'esperimento, è necessario monitorare lo stato di avanzamento. Il modo più rapido per monitorare lo stato di avanzamento consiste nel modificare l'evento Log da MLContext.

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

Eseguire l'esperimento

Dopo aver definito l'esperimento, usare il metodo RunAsync per avviarlo.

TrialResult experimentResults = await experiment.RunAsync();

Una volta scaduto il tempo di training, il risultato è un TrialResult per il miglior modello trovato durante il training.

A questo punto, è possibile salvare il modello o usarlo per eseguire stime. Per ulteriori informazioni sull'uso di un modello di ML.NET, consultare le seguenti guide:

Modificare i risultati dell'inferenza della colonna

Poiché InferColumns carica solo un sottoinsieme di dati, è possibile che i casi perimetrali contenuti all'esterno dei campioni usati per dedurre colonne non vengano intercettati e che tipi di dati errati siano impostati per le colonne. È possibile aggiornare le proprietà di ColumnInformation in modo che tengano conto dei casi in cui i risultati dell'inferenza della colonna non sono corretti.

Nel set di dati relativo alle tariffe dei taxi, ad esempio, i dati nella colonna rate_code consistono in un numero. Tuttavia, tale valore numerico rappresenta una categoria. Per impostazione predefinita, la chiamata InferColumns inserirà rate_code nella proprietà NumericColumnNames anziché in CategoricalColumnNames. Poiché queste proprietà sono raccolte .NET, è possibile usare operazioni standard per aggiungere e rimuovere elementi da esse.

Eseguire le seguenti operazioni per aggiornare il ColumnInformation per rate_code.

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

Escludere trainer

Per impostazione predefinita, AutoML prova diversi trainer come parte del processo di training per verificare quale sia la soluzione migliore per i dati. Tuttavia, è possibile che durante il processo di training alcuni trainer usino troppe risorse di calcolo o che non forniscano metriche di valutazione valide. È possibile escludere trainer dal processo di training. I trainer usati dipendono dall'attività. Per un elenco dei trainer supportati in ML.NET, consultare la Guida alle attività di Machine Learning in ML.NET.

Ad esempio, nello scenario di regressione delle tariffe dei taxi, impostare il parametro useLgbm su false per escludere l'algoritmo LightGBM.

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

Il processo per l’esclusione di trainer in altre attività (ad esempio, la classificazione binaria e multiclasse) funziona allo stesso modo.

Personalizzare uno strumento di stima spazzabile

Quando si desidera una personalizzazione più granulare delle opzioni dello strumento di stima incluse nell'ambito della pipeline spazzabile, è necessario:

  1. Inizializzare uno spazio di ricerca
  2. Usare lo spazio di ricerca per definire una factory personalizzata
  3. Creare uno strumento di stima spazzabile
  4. Aggiungere lo strumento di stima spazzabile alla pipeline spazzabile

AutoML offre un set di spazi di ricerca preconfigurati per i trainer nelle seguenti attività di Machine Learning:

In questo esempio, lo spazio di ricerca usato è per il SdcaRegressionTrainer. Inizializzarlo usando SdcaOption.

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Usare quindi lo spazio di ricerca per definire un metodo factory personalizzato per creare SdcaRegressionTrainer. In questo esempio, i valori di L1Regularization e L2Regularization vengono entrambi impostati su un valore diverso da quello predefinito. Per L1Regularization, il set di valori è determinato dal tuner durante ciascuna versione di valutazione. L2Regularization è fissato sul valore hardcoded per ogni versione di valutazione. Durante ogni versione di valutazione, l'output della factory personalizzata è un SdcaRegressionTrainer con gli iperparametri configurati.

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

Uno strumento di stima spazzabile consiste nella combinazione di uno strumento di stima e di uno spazio di ricerca. Dopo aver definito uno spazio di ricerca e averlo usato per creare un metodo factory personalizzato per la generazione di trainer, usare il metodo CreateSweepableEstimator per creare un nuovo strumento di stima spazzabile.

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

Per usare lo strumento di stima spazzabile nell'esperimento, aggiungerlo alla pipeline spazzabile.

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

Poiché le pipeline spazzabili sono una raccolta di estimatori spazzabili, è possibile configurare e personalizzare quanti di questi estimatori spazzabili sono necessari.

Personalizzare lo spazio di ricerca

In alcuni scenari si potrebbe voler andare oltre la personalizzazione degli estimatori spazzabili usati nell'esperimento e controllare l'intervallo di spazio di ricerca. A tale scopo, è possibile accedere alle proprietà dello spazio di ricerca usando le chiavi. In questo caso, il parametro L1Regularization è float. Pertanto, per personalizzare l'intervallo di ricerca, usare UniformSingleOption.

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

A seconda del tipo di dati dell'iperparametro da impostare, è possibile scegliere tra le seguenti opzioni:

Gli spazi di ricerca possono contenere anche spazi di ricerca annidati.

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;

Un'altra opzione per personalizzare gli intervalli di ricerca consiste nell'estenderli. Ad esempio, SdcaOption fornisce solo i parametri L1Regularization e L2Regularization. Tuttavia, SdcaRegressionTrainer include più parametri che possono essere impostati (ad esempio, BiasLearningRate).

Per estendere lo spazio di ricerca, creare una nuova classe (ad esempio, SdcaExtendedOption) che eredita da SdcaOption.

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

Per specificare l'intervallo di spazio di ricerca, usare RangeAttribute, equivalente a Microsoft.ML.SearchSpace.Option.

Quindi, ovunque si usi lo spazio di ricerca, fare riferimento a SdcaExtendedOption anziché a SdcaOption.

Ad esempio, è possibile inizializzare lo spazio di ricerca come segue:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Creare uno strumento di esecuzione della versione di valutazione

Per impostazione predefinita, AutoML supporta la classificazione binaria, la classificazione multiclasse e la regressione. Tuttavia, ML.NET supporta molti altri scenari, ad esempio:

  • Elemento consigliato
  • Previsioni
  • Classifica
  • Classificazione immagini
  • Classificazione testo
  • Somiglianza di frasi

In scenari che non dispongono di spazi di ricerca preconfigurati e estimatori spazzabili, è possibile crearne uno usare uno strumento di esecuzione di una versione di valutazione per abilitare AutoML per tale scenario.

Si supponga, ad esempio, che i dati relativi alla revisione del ristorante siano simili ai seguenti:

Wow... Mi è piaciuto molto questo posto.

1

Crust is not good.

0

Si desidera usare il trainer per analizzare la valutazione TextClassificationTrainer, in cui 0 è negativo e 1 è positivo. Tuttavia, non è disponibile alcuna configurazione ctx.Auto().TextClassification().

Per usare AutoML con il trainer di classificazione del testo, è necessario:

  1. Creare uno spazio di ricerca personalizzato.

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

    In questo caso, AutoML cercherà diverse configurazioni dell'iperparametro BatchSize.

  2. Creare uno strumento di stima spazzabile e aggiungerlo alla 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);

    In questo esempio vengono usati lo spazio di ricerca TCOption e una factory personalizzata TextClassificationTrainer per creare uno strumento di stima spazzabile.

  3. Creare uno strumento di esecuzione della versione di valutazione personalizzato

    Per creare uno strumento di esecuzione della versione di valutazione personalizzato, implementare 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(),
        };
    }
}

    L’implementazione TCRunner in questo esempio:

    • Estrae gli iperparametri scelti per le versione di valutazione
    • Usa gli iperparametri per creare una pipeline di ML.NET
    • Usa la pipeline di ML.NET per eseguire il training di un modello
    • Valuta il modello
    • Restituisce un oggetto TrialResult con le informazioni per tale versione di valutazione

  4. Inizializzare lo strumento di esecuzione della versione di valutazione personalizzata

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

  5. Creare e configurare l'esperimento. Usare il metodo di estensione SetTrialRunner per aggiungere lo strumento di esecuzione della versione di valutazione personalizzato all'esperimento.

    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. Eseguire l'esperimento

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

Scegliere un altro tuner

AutoML supporta vari algoritmi di ottimizzazione per eseguire l’iterazione dello spazio di ricera per trovare gli iperparametri ottimali. Per impostazione predefinita, usa il tuner Eci Cost Frugal. Usando i metodi di estensione dell'esperimento, è possibile scegliere un altro tuner più adatto allo scenario.

Usare i seguenti metodi per impostare il tuner:

Ad esempio, per usare il tuner di ricerca griglia, il codice potrebbe essere simile al seguente:

experiment.SetGridSearchTuner();

Configurare il monitoraggio dell'esperimento

Il modo più rapido per monitorare lo stato di avanzamento di un esperimento consiste nel definire l'evento Log da MLContext. Tuttavia, l'evento Log restituisce un dump non elaborato dei log generati da AutoML durante ogni versione di valutazione. La grande quantità di informazioni non formattate può creare difficoltà.

Per un'esperienza di monitoraggio più controllata, implementare una classe con l'interfaccia 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;
    }
}

L'interfaccia IMonitor ha quattro eventi di ciclo di vita:

Suggerimento

Sebbene non sia obbligatorio, includere SweepablePipeline nel monitoraggio in modo da poter esaminare la pipeline generata per una versione di valutazione usando la proprietà Parameter di TrialSettings.

In questo esempio vengono implementati solo ReportCompletedTrial e ReportFailTrial.

Dopo aver implementato il monitoraggio, impostarlo come parte della configurazione dell'esperimento usando SetMonitor.

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

Quindi, eseguire l'esperimento:

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

Quando si esegue l'esperimento con questa implementazione, l'output dovrebbe essere simile al seguente:

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

Rendere persistenti le versioni di valutazione

Per impostazione predefinita, AutoML archivia TrialResult solo per il modello migliore. Tuttavia, se si vuole rendere persistenti ognuna delle versioni di valutazione, è possibile farlo dall'interno del monitor.

All'interno del monitor:

  1. Definire una proprietà per le versioni di valutazione completate e un metodo per accedervi.

    private readonly List<TrialResult> _completedTrials;

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

  2. Inizializzarlo nel costruttore

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

  3. Aggiungere i risultati di ogni versione di valutazione all'interno del metodo del ciclo di vita ReportCompletedTrial.

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

  4. Al termine del training, è possibile accedere a tutte le versioni di valutazione completate chiamando GetCompletedTrials

    var completedTrials = monitor.GetCompletedTrials();

A questo punto, è possibile eseguire ulteriori elaborazioni sulla raccolta di versioni di valutazione completate. Ad esempio, è possibile scegliere un modello diverso da quello selezionato da AutoML, registrare i risultati della versione di valutazione in un database o ricompilare la pipeline da una delle versioni di valutazione completate.

Annullare esperimenti

Quando si eseguono esperimenti in modo asincrono, assicurarsi di terminare il processo in modo netto. A tale scopo, usare un CancellationToken.

Avviso

L'annullamento di un esperimento non salverà alcun output intermedio. Impostare un checkpoint per salvare gli output intermedi.

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

Impostare checkpoint

I checkpoint consentono di salvare gli output intermedi dal processo di training in caso di chiusura anticipata o di errore. Per impostare un checkpoint, usare il metodo di estensione SetCheckpoint e fornire una directory per archiviare gli output intermedi.

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

Determinare l'importanza di funzionalità

Poiché il Machine Learning viene ora applicato a più aspetti delle attività quotidiane, ad esempio nel settore sanitario, è di importanza fondamentale comprenderne in che modo un modello di Machine Learning prende le decisioni. L’importanza della funzionalità di permutazione (PFI) è una tecnica usata per spiegare i modelli di classificazione, classificazione in ordine di proprietà, e regressione. A livello generale, il funzionamento è basato sulla selezione in ordine casuale dei dati una caratteristica alla volta per l'intero set di dati e sul calcolo della diminuzione della metrica delle prestazioni dell'interesse. Maggiore è la modifica, maggiore è l'importanza della funzionalità. Per ulteriori informazioni su PFI, consultare Interpretare le stime del modello usando l’Importanza della funzionalità di permutazione.

Nota

Il calcolo di PFI potrebbe richiedere molto tempo. Il tempo necessario per il calcolo è proporzionale al numero di colonne di funzionalità disponibili. Maggiore è il numero di funzionalità, maggiore sarà la durata dell'esecuzione del file PFI.

Per determinare l'importanza della funzionalità tramite AutoML:

  1. Ottenere il modello migliore.

    var bestModel = expResult.Model;

  2. Applicare il modello al set di dati.

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

  3. Calcolare l'importanza della funzionalità usando PermutationFeatureImportance

    In questo caso, l'attività consiste nella regressione, ma lo stesso concetto è applicabile ad altre attività, come la classificazione in ordine di priorità e la classificazione.

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

  4. Ordinare l'importanza delle funzionalità in base alle modifiche apportate alle metriche di valutazione.

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