Como usar a API do ML.NET Automated Machine Learning (AutoML)

Artigo
03/12/2024

Neste artigo, você aprenderá a usar o ML.NET ML automatizado (AutoML API).

Exemplos para a API AutoML podem ser encontrados no repositório dotnet/machinelearning-samples .

Instalação

Para usar a API AutoML, instale o Microsoft.ML.AutoML pacote NuGet no projeto .NET no qual você deseja fazer referência a ele.

Nota

Este guia usa a versão 0.20.0 e posterior do Microsoft.ML.AutoML pacote NuGet. Embora exemplos e códigos de versões anteriores ainda funcionem, é altamente recomendável usar as APIs introduzidas nesta versão para novos projetos.

Para obter mais informações sobre como instalar pacotes NuGet, consulte os seguintes guias:

Guia de Introdução

O AutoML fornece vários padrões para treinar rapidamente modelos de aprendizado de máquina. Nesta seção, você aprenderá a:

Carregue os seus dados
Defina seu pipeline
Configure seu experimento
Execute a sua experiência
Use o melhor modelo para fazer previsões

Defina o seu problema

Dado um conjunto de dados armazenado em um arquivo separado por vírgulas chamado taxi-fare-train.csv que se parece com o seguinte:

vendor_id	rate_code	passenger_count	trip_time_in_secs	trip_distance	payment_type	fare_amount
CMT	1	1	1271	3,8	DRFP	17.5
CMT	1	1	474	1.5	DRFP	8
CMT	1	1	637	1.4	DRFP	8.5

Carregue os seus dados

Comece inicializando o arquivo MLContext. MLContext é um ponto de partida para todas as operações ML.NET. A inicialização de mlContext cria um novo ambiente de ML.NET que pode ser compartilhado entre os objetos de fluxo de trabalho de criação de modelo. É semelhante, conceitualmente, ao DBContext Entity Framework.

Em seguida, para carregar seus dados, use o InferColumns método.

// 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 carrega algumas linhas do conjunto de dados. Em seguida, ele inspeciona os dados e tenta adivinhar ou inferir o tipo de dados para cada uma das colunas com base em seu conteúdo.

O comportamento padrão é agrupar colunas do mesmo tipo em vetores de feição ou matrizes contendo os elementos para cada uma das colunas individuais. A configuração groupColumns para false substitui esse comportamento padrão e executa apenas a inferência de coluna sem agrupar colunas. Ao manter colunas separadas, ele permite que você aplique diferentes transformações de dados ao pré-processar os dados no nível de coluna individual em vez do agrupamento de colunas.

O resultado de é um ColumnInferenceResults objeto que contém as opções necessárias para criar um e informações TextLoader de InferColumns coluna.

Para o conjunto de dados de exemplo no taxi-fare-train.csv, as informações da coluna podem ter a seguinte aparência:

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

Depois de ter as informações da coluna, use o TextLoader.Options ColumnInferenceResults definido pelo para criar um TextLoader para carregar seus dados em um IDataViewarquivo .

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

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

Muitas vezes, é uma boa prática dividir seus dados em conjuntos de treinamento e validação. Use TrainTestSplit para criar uma divisão de treinamento de 80% e validação de 20% do seu conjunto de dados.

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

Defina seu pipeline

Seu pipeline define as etapas de processamento de dados e o pipeline de aprendizado de máquina a ser usado para treinar seu modelo.

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

A SweepablePipeline é uma coleção de SweepableEstimator. A SweepableEstimator é um ML.NET Estimator com um SearchSpacearquivo .

A Featurizer é uma API de conveniência que cria um pipeline abrangente de estimadores varríveis de processamento de dados com base nas informações de coluna fornecidas. Em vez de criar um pipeline do zero, Featurizer automatiza a etapa de pré-processamento de dados. Para obter mais informações sobre transformações suportadas por ML.NET, consulte o guia de transformações de dados.

A Featurizer saída é uma única coluna contendo um vetor de recurso numérico que representa os dados transformados para cada uma das colunas. Esse vetor de recurso é então usado como entrada para os algoritmos usados para treinar um modelo de aprendizado de máquina.

Se quiser um controle mais preciso sobre o pré-processamento de dados, você pode criar um pipeline com cada uma das etapas individuais de pré-processamento. Para obter mais informações, consulte o guia preparar dados para criar um modelo.

Gorjeta

Use Featurizer com ColumnInferenceResults para maximizar a utilidade do AutoML.

Para treinamento, o AutoML fornece um pipeline abrangente com instrutores padrão e configurações de espaço de pesquisa para as seguintes tarefas de aprendizado de máquina:

Para o problema de previsão de tarifa de táxi, uma vez que o objetivo é prever um valor numérico, use Regression. Para obter mais informações sobre como escolher uma tarefa, consulte Tarefas de aprendizado de máquina no ML.NET

Configure seu experimento

Primeiro, crie um experimento AutoML. An AutoMLExperiment é uma coleção de TrialResult.

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

Depois que o experimento for criado, use os métodos de extensão que ele fornece para definir configurações diferentes.

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

Neste exemplo, você:

Defina o pipeline varredura para ser executado durante o experimento chamando SetPipeline.
Escolha RSquared como métrica otimizar durante o treinamento ligando SetRegressionMetricpara . Para obter mais informações sobre métricas de avaliação, consulte o guia Avaliar seu modelo de ML.NET com métricas .
Defina 60 segundos como a quantidade de tempo que você deseja treinar chamando SetTrainingTimeInSeconds. Uma boa heurística para determinar por quanto tempo treinar é o tamanho dos seus dados. Normalmente, conjuntos de dados maiores exigem mais tempo de treinamento. Para obter mais informações, consulte Orientação de tempo de treinamento.
Forneça os conjuntos de dados de treinamento e validação a serem usados chamando SetDataset.

Uma vez que seu experimento esteja definido, você vai querer alguma maneira de acompanhar seu progresso. A maneira mais rápida de acompanhar o progresso é modificando o evento de Log MLContext.

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

Execute a sua experiência

Agora que você definiu seu experimento, use o método para iniciar seu RunAsync experimento.

TrialResult experimentResults = await experiment.RunAsync();

Uma vez que o tempo para treinar expira, o resultado é um TrialResult para o melhor modelo encontrado durante o treinamento.

Neste ponto, você pode salvar seu modelo ou usá-lo para fazer previsões. Para obter mais informações sobre como usar um modelo ML.NET, consulte os seguintes guias:

Modificar resultados de inferência de coluna

Como InferColumns carrega apenas um subconjunto de seus dados, é possível que casos de borda contidos fora dos exemplos usados para inferir colunas não sejam capturados e os tipos de dados errados sejam definidos para suas colunas. Você pode atualizar as propriedades de para levar em conta os casos em que os resultados da inferência da ColumnInformation coluna não estão corretos.

Por exemplo, no conjunto de dados de tarifas de táxi, os rate_code dados na coluna são um número. No entanto, esse valor numérico representa uma categoria. Por padrão, a chamada InferColumns será feita rate_code na propriedade em vez de CategoricalColumnNames.NumericColumnNames Como essas propriedades são coleções .NET, você pode usar operações padrão para adicionar e remover itens delas.

Você pode fazer o seguinte para atualizar o ColumnInformation para rate_code.

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

Excluir formadores

Por padrão, o AutoML tenta vários instrutores como parte do processo de treinamento para ver qual deles funciona melhor para seus dados. No entanto, ao longo do processo de treinamento, você pode descobrir que existem alguns instrutores que usam muitos recursos de computação ou não fornecem boas métricas de avaliação. Tem a opção de excluir formadores do processo de formação. Os formadores utilizados dependem da tarefa. Para obter uma lista de instrutores suportados no ML.NET, consulte as tarefas de aprendizado de máquina no guia ML.NET.

Por exemplo, no cenário de regressão de tarifa de táxi, para excluir o algoritmo LightGBM, defina o useLgbm parâmetro como false.

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

O processo de exclusão de treinadores em outras tarefas, como classificação binária e multiclasse, funciona da mesma maneira.

Personalizar um estimador varrível

Quando quiser personalizar mais granularmente as opções do estimador incluídas como parte do seu pipeline varrível, você precisa:

Inicializar um espaço de pesquisa
Usar o espaço de pesquisa para definir uma fábrica personalizada
Criar um estimador varrível
Adicione seu estimador varrível ao seu pipeline varredura

O AutoML fornece um conjunto de espaços de pesquisa pré-configurados para instrutores nas seguintes tarefas de aprendizado de máquina:

Neste exemplo, o espaço de pesquisa usado é para o SdcaRegressionTrainer. Inicialize-o usando SdcaOption.

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Em seguida, use o espaço de pesquisa para definir um método de fábrica personalizado para criar o SdcaRegressionTrainer. Neste exemplo, os valores de L1Regularization e L2Regularization estão sendo definidos para algo diferente do padrão. Para L1Regularization, o valor definido é determinado pelo sintonizador durante cada ensaio. O L2Regularization é fixado para cada avaliação para o valor codificado. Durante cada teste, a saída da fábrica personalizada é um SdcaRegressionTrainer com os hiperparâmetros configurados.

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

Um estimador varredura é a combinação de um estimador e um espaço de pesquisa. Agora que você definiu um espaço de pesquisa e o usou para criar um método de fábrica personalizado para gerar treinadores, use o CreateSweepableEstimator método para criar um novo estimador varredor.

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

Para usar seu estimador varrível em seu experimento, adicione-o ao seu pipeline varrível.

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

Como os pipelines varredos são uma coleção de estimadores varríveis, você pode configurar e personalizar quantos desses estimadores varrer forem necessários.

Personalize o seu espaço de pesquisa

Há cenários em que você deseja ir além da personalização dos estimadores varríveis usados em seu experimento e deseja controlar o intervalo de espaço de pesquisa. Você pode fazer isso acessando as propriedades do espaço de pesquisa usando chaves. Neste caso, o L1Regularization parâmetro é um floatarquivo . Portanto, para personalizar o intervalo de pesquisa, use UniformSingleOption.

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

Dependendo do tipo de dados do hiperparâmetro que você deseja definir, você pode escolher entre as seguintes opções:

Números
Booleanos e cordas
- ChoiceOption

Os espaços de pesquisa também podem conter espaços de pesquisa aninhados.

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;

Outra opção para personalizar intervalos de pesquisa é estendê-los. Por exemplo, SdcaOption fornece apenas os L1Regularization parâmetros e L2Regularization . No entanto, SdcaRegressionTrainer tem mais parâmetros que você pode definir, como BiasLearningRate.

Para estender o espaço de pesquisa, crie uma nova classe, como SdcaExtendedOption, que herda de SdcaOption.

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

Para especificar o intervalo de espaço de pesquisa, use RangeAttribute, que é equivalente a Microsoft.ML.SearchSpace.Option.

Em seguida, em qualquer lugar que você use seu espaço de pesquisa, faça referência ao SdcaExtendedOption em vez de SdcaOption.

Por exemplo, ao inicializar o espaço de pesquisa, você pode fazer isso da seguinte maneira:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Crie o seu próprio corredor de teste

Por padrão, o AutoML oferece suporte à classificação binária, classificação multiclasse e regressão. No entanto, ML.NET suporta muitos outros cenários, tais como:

Recomendação
Previsão
Classificação
Classificação de imagens
Classificação de textos
Semelhança de frases

Para cenários que não têm espaços de pesquisa pré-configurados e estimadores varríveis, você pode criar o seu próprio e usar um executor de avaliação para habilitar o AutoML para esse cenário.

Por exemplo, determinados dados de avaliações de restaurantes são parecidos com os seguintes:

Uau... Adorei esse lugar.

Crosta não é boa.

Você quer usar o treinador para analisar o TextClassificationTrainer sentimento onde 0 é negativo e 1 é positivo. No entanto, não há configuração ctx.Auto().TextClassification() .

Para usar o AutoML com o instrutor de classificação de texto, você terá:

Crie o seu próprio espaço de pesquisa.

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

Neste caso, o AutoML procurará diferentes configurações do BatchSize hiperparâmetro.

Crie um estimador varrível e adicione-o ao seu 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);

Neste exemplo, o TCOption espaço de pesquisa e uma fábrica personalizada TextClassificationTrainer são usados para criar um estimador varrível.

Criar um corredor de avaliação personalizado

Para criar um executor de avaliação personalizado, implemente 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(),
        };
    }
}

A TCRunner implementação neste exemplo:

Extrai os hiperparâmetros escolhidos para esse ensaio
Usa os hiperparâmetros para criar um pipeline de ML.NET
Usa o pipeline de ML.NET para treinar um modelo
Avalia o modelo
Retorna um TrialResult objeto com as informações dessa avaliação

Inicializar seu corredor de avaliação personalizado

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

Crie e configure seu experimento. Use o SetTrialRunner método de extensão para adicionar seu executor de avaliação personalizado ao experimento.

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

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

Execute a sua experiência

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

Escolha um sintonizador diferente

O AutoML suporta vários algoritmos de ajuste para iterar através do espaço de pesquisa em busca dos hiperparâmetros ideais. Por predefinição, utiliza o sintonizador Eci Cost Frugal. Usando métodos de extensão de experimento, você pode escolher outro sintonizador que melhor se adapte ao seu cenário.

Utilize os seguintes métodos para definir o sintonizador:

SMAC - SetSmacTuner
Pesquisa em grelha - SetGridSearchTuner
Pesquisa aleatória - SetRandomSearchTuner
Custo Frugal - SetCostFrugalTuner
Eci Custo Frugal - SetEciCostFrugalTuner

Por exemplo, para usar o sintonizador de pesquisa de grade, seu código pode ter a seguinte aparência:

experiment.SetGridSearchTuner();

Configurar o monitoramento de experimentos

A maneira mais rápida de monitorar o progresso de um experimento é definir o Log evento de MLContext. No entanto, o Log evento gera um despejo bruto dos logs gerados pelo AutoML durante cada avaliação. Devido à grande quantidade de informações não formatadas, é difícil.

Para uma experiência de monitoramento mais controlada, implemente uma classe com a IMonitor interface.

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

A IMonitor interface tem quatro eventos de ciclo de vida:

Gorjeta

Embora não seja necessário, inclua o seu SweepablePipeline no monitor para que você possa inspecionar o pipeline que foi gerado para uma avaliação usando a Parameter propriedade do TrialSettings.

Neste exemplo, apenas o ReportCompletedTrial e ReportFailTrial são implementados.

Depois de implementar o monitor, defina-o como parte da configuração do experimento usando SetMonitoro .

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

Em seguida, execute o experimento:

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

Quando você executa o experimento com essa implementação, a saída deve ser semelhante à seguinte:

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

Ensaios persistentes

Por padrão, o AutoML armazena apenas o TrialResult melhor modelo. No entanto, se você quiser persistir cada uma das tentativas, você pode fazê-lo de dentro do seu monitor.

Dentro do monitor:

Defina uma propriedade para suas versões experimentais concluídas e um método para acessá-las.

private readonly List<TrialResult> _completedTrials;

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

Inicialize-o em seu construtor

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

Anexe cada resultado da avaliação dentro do seu ReportCompletedTrial método de ciclo de vida.

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

Quando o treinamento for concluído, você poderá acessar todas as avaliações concluídas ligando para GetCompletedTrials
```
var completedTrials = monitor.GetCompletedTrials();
```

Neste ponto, você pode executar processamento adicional na coleção de avaliações concluídas. Por exemplo, você pode escolher um modelo diferente daquele selecionado pelo AutoML, registrar os resultados da avaliação em um banco de dados ou reconstruir o pipeline a partir de qualquer uma das avaliações concluídas.

Cancelar experiências

Ao executar experimentos de forma assíncrona, certifique-se de encerrar o processo de forma limpa. Para fazer isso, use um CancellationTokenarquivo .

Aviso

Cancelar um experimento não salvará nenhuma das saídas intermediárias. Defina um ponto de verificação para salvar saídas intermediárias.

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

Definir pontos de verificação

Os pontos de verificação fornecem uma maneira de salvar saídas intermediárias do processo de treinamento no caso de uma rescisão antecipada ou erro. Para definir um ponto de verificação, use o SetCheckpoint método extension e forneça um diretório para armazenar as saídas intermediárias.

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

Determinar a importância do recurso

À medida que o aprendizado de máquina é introduzido em mais aspetos da vida cotidiana, como a saúde, é de extrema importância entender por que um modelo de aprendizado de máquina toma as decisões que toma. A Importância da Característica de Permutação (PFI) é uma técnica usada para explicar modelos de classificação, classificação e regressão. Em um nível alto, a maneira como ele funciona é embaralhando aleatoriamente os dados, um recurso de cada vez, para todo o conjunto de dados e calculando o quanto a métrica de desempenho de juros diminui. Quanto maior a mudança, mais importante é esse recurso. Para obter mais informações sobre PFI, consulte interpretar previsões de modelo usando a importância do recurso de permutação.

Nota

O cálculo do PFI pode ser uma operação demorada. O tempo necessário para calcular é proporcional ao número de colunas de recursos que você tem. Quanto mais recursos, mais tempo o PFI levará para ser executado.

Para determinar a importância do recurso usando o AutoML:

Obtenha o melhor modelo.
```
var bestModel = expResult.Model;
```

Aplique o modelo ao seu conjunto de dados.

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

Calcule a importância do recurso usando PermutationFeatureImportance

Neste caso, a tarefa é a regressão, mas o mesmo conceito se aplica a outras tarefas, como classificação e classificação.
```
var pfiResults = 
    mlContext.Regression.PermutationFeatureImportance(bestModel, transformedData, permutationCount:3);
```

Ordenar a importância do recurso por meio de alterações nas métricas de avaliação.

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

Partilhar via

Como usar a API do ML.NET Automated Machine Learning (AutoML)

Instalação

Guia de Introdução

Defina o seu problema

Carregue os seus dados

Defina seu pipeline

Configure seu experimento

Execute a sua experiência

Modificar resultados de inferência de coluna

Excluir formadores

Personalizar um estimador varrível

Personalize o seu espaço de pesquisa

Crie o seu próprio corredor de teste

Escolha um sintonizador diferente

Configurar o monitoramento de experimentos

Ensaios persistentes

Cancelar experiências

Definir pontos de verificação

Determinar a importância do recurso

Recursos adicionais