Como usar a API de AutoML (machine learning automatizado) do ML.NET

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

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

Instalação

Para usar a API de AutoML, instale o pacote NuGet Microsoft.ML.AutoML no projeto .NET no qual deseja referenciá-lo.

Observação

Este guia usa a versão 0.20.0 e posterior do pacote NuGet Microsoft.ML.AutoML. Embora exemplos e código 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:

Início Rápido

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

  • Carregar os dados
  • Definir o pipeline
  • Configurar seu experimento
  • Executar o experimento
  • Usar o melhor modelo para fazer previsões

Definir o 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 CRD 17.5
CMT 1 1 474 1.5 CRD 8
CMT 1 1 637 1.4 CRD 8.5

Carregar os dados

Comece inicializando seu MLContext. MLContext é um ponto de partida para todas as operações do ML.NET. Inicializar mlContext cria um ambiente do ML.NET que pode ser compartilhado entre os objetos do fluxo de trabalho de criação de modelo. Ele é semelhante, conceitualmente, a DBContext no Entity Framework.

Em seguida, para carregar os dados, use o método 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 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 recurso ou matrizes que contêm os elementos de cada uma das colunas individuais. Definir groupColumns como false substitui esse comportamento padrão e executa apenas a inferência de coluna sem agrupar as colunas. Manter as colunas separadas permite que você aplique diferentes transformações de dados ao pré-processar os dados no nível da coluna individual, em vez do agrupamento de colunas.

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

Para o conjunto de dados de exemplo em taxi-fare-train.csv, as informações da coluna podem ser semelhantes às seguintes:

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

Quando tiver suas informações de coluna, use o TextLoader.Options definido pelo ColumnInferenceResults para criar um TextLoader para carregar os dados em um IDataView.

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

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

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

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

Definir o pipeline

O pipeline define as etapas de processamento de dados e o pipeline de machine learning a serem usados para treinar o modelo.

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

Um SweepablePipeline é uma coleção de SweepableEstimator. Um SweepableEstimator é um ML.NET Estimator com um SearchSpace.

O Featurizer é uma API de conveniência que cria um pipeline com varredura de avaliadores de processamento de dados com varredura baseado 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 as transformações com suporte de ML.NET, consulte o guia de transformações de dados.

A saída Featurizer é uma coluna que contém um vetor de recurso numérico que representa os dados transformados para cada uma das colunas. Esse vetor de recurso é usado como entrada para os algoritmos usados para treinar um modelo de machine learning.

Se você quiser ter um controle mais fino sobre o pré-processamento de dados, poderá criar um pipeline com cada uma das etapas de pré-processamento individuais. Para obter mais informações, consulte o guia de preparação de dados para a criação de um modelo.

Dica

Use Featurizer com ColumnInferenceResults para maximizar o utilitário do AutoML.

Para treinamento, o AutoML fornece um pipeline com varredura com configurações padrão de treinadores e espaço de pesquisa para as seguintes tarefas de machine learning:

Para o problema de previsão de tarifas de táxi, como a meta é prever um valor numérico, use Regression. Para obter mais informações sobre como escolher uma tarefa, confira Tarefas de machine learning no ML.NET

Configurar seu experimento

Primeiro, crie um experimento de AutoML. Um 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ê:

  • Define o pipeline com varredura para ser executado durante o experimento chamando SetPipeline.
  • Escolha RSquared como a métrica a ser otimizada durante o treinamento chamando SetRegressionMetric. Para obter mais informações sobre as métricas de avaliação, confira 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 dados. Normalmente, conjuntos de dados maiores exigem mais tempo de treinamento. Para obter mais informações, consulte diretrizes de tempo de treinamento.
  • Forneça os conjuntos de dados de treinamento e validação a serem usados chamando SetDataset.

Depois que o experimento for definido, você precisará ter uma maneira de acompanhar o progresso. A maneira mais rápida de acompanhar o progresso é modificando o evento Log de MLContext.

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

Executar o experimento

Agora que você definiu o experimento, use o método RunAsync para iniciá-lo.

TrialResult experimentResults = await experiment.RunAsync();

Depois que o tempo de treinamento expirar, o resultado será um TrialResult para o melhor modelo encontrado durante o treinamento.

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

Modificar resultados da inferência de coluna

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

Por exemplo, no conjunto de dados de tarifas de táxi, os dados na coluna rate_code são um número. No entanto, esse valor numérico representa uma categoria. Por padrão, chamar InferColumns colocará rate_code na propriedade NumericColumnNames em vez de CategoricalColumnNames. Como essas propriedades são coleções do .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 treinadores

Por padrão, o AutoML tenta vários treinadores como parte do processo de treinamento para ver qual deles funciona melhor para os dados. No entanto, ao longo do processo de treinamento, você pode descobrir que há alguns treinadores que usam muitos recursos de computação ou não fornecem boas métricas de avaliação. Você tem a opção de excluir treinadores do processo de treinamento. Os treinadores usados dependem da tarefa. Para obter uma lista de treinadores com suporte no ML.NET, consulte o Guia de tarefas de machine learning no ML.NET.

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

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

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

Personalizar um avaliador com varredura

Quando deseja personalizar com mais detalhes as opções do avaliador incluídas como parte do pipeline com varredura, você precisa:

  1. Inicializar um espaço de pesquisa
  2. Usar o espaço de pesquisa para definir um alocador personalizado
  3. Criar um avaliador com varredura
  4. Adicionar o avaliador com varredura ao pipeline com varredura

O AutoML fornece um conjunto de espaços de pesquisa pré-configurados para treinadores nas seguintes tarefas de machine learning:

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 como algo diferente do padrão. Para L1Regularization, o valor definido é determinado pelo sintonizador durante cada avaliação. O L2Regularization é fixo para cada avaliação como o valor embutido em código. Durante cada avaliação, a saída do alocador personalizado é 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 avaliador com varredura é a combinação de um avaliador 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 método CreateSweepableEstimator para criar um avaliador com varredura.

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

Para usar o avaliador com varredura no experimento, adicione-o ao pipeline com varredura.

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

Como os pipelines com varredura são uma coleção de avaliadores com varredura, você pode configurar e personalizar quantos desses avaliadores com varredura forem necessários.

Personalizar o espaço de pesquisa

Há cenários em que você deseja ir além da personalização dos avaliadores com varredura usados em seu experimento e deseja controlar o intervalo de espaço de pesquisa. Faça isso acessando as propriedades do espaço de pesquisa usando chaves. Nesse caso, o parâmetro L1Regularization é um float. 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:

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 parâmetros L1Regularization e L2Regularization. No entanto, SdcaRegressionTrainer tem mais parâmetros do que você pode definir, como BiasLearningRate.

Para estender o espaço de pesquisa, crie uma 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 do espaço de pesquisa, use RangeAttribute, que é equivalente a Microsoft.ML.SearchSpace.Option.

Em seguida, em qualquer lugar em que você usar o espaço de pesquisa, faça referência a 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>();

Criar seu executor de avaliação

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

  • Recomendação
  • Previsão
  • Classificação
  • Classificação de imagens
  • Classificação de texto
  • Similaridade de frase

Para cenários que não têm espaços de pesquisa pré-configurados e avaliadores com varredura, você pode criar os seus e usar um executor de avaliação para habilitar o AutoML para esse cenário.

Por exemplo, diante de dados de resenhas de restaurantes que se parecem com o seguinte:

Uau! Adorei esse lugar.

1

A torrada não é boa.

0

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

Para usar o AutoML com o treinador de classificação de texto, você precisará:

  1. Criar seu espaço de pesquisa.

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

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

  2. Criar um avaliador com varredura e adicioná-lo ao 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 espaço de pesquisa TCOption e um alocador TextClassificationTrainer personalizado são usados para criar um avaliador com varredura.

  3. Criar um executor 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 implementação TCRunner neste exemplo:

    • Extrai os hiperparâmetros escolhidos para essa avaliação
    • 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 objeto TrialResult com as informações para essa avaliação
  4. Inicializar seu executor de avaliação personalizado

    var tcRunner = new TCRunner(context: ctx, data: trainValidationData, pipeline: pipeline);
    
  5. Crie e configure seu experimento. Use o método de extensão SetTrialRunner para adicionar o 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);
    
  6. Executar o experimento

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

Escolher um sintonizador diferente

O AutoML dá suporte a vários algoritmos de ajuste para iterar no espaço de pesquisa em busca dos hiperparâmetros ideais. Por padrão, ele usa o sintonizador Eci Cost Frugal. Usando métodos de extensão experimentais, você pode escolher outro sintonizador que melhor se ajuste ao seu cenário.

Use os seguintes métodos para definir o sintonizador:

Por exemplo, para usar o sintonizador de pesquisa de grade, seu código pode ser semelhante ao seguinte:

experiment.SetGridSearchTuner();

Configurar o monitoramento de experimentos

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

Para uma experiência de monitoramento mais controlada, implemente uma classe com a interface 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;
    }
}

A interface IMonitor tem quatro eventos de ciclo de vida:

Dica

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

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

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

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

Persistir avaliações

Por padrão, o AutoML armazena apenas o TrialResult para o melhor modelo. No entanto, se você quiser persistir cada uma das avaliações, poderá fazer isso de dentro do monitor.

Dentro do monitor:

  1. Defina uma propriedade para as avaliações concluídas e um método para acessá-las.

    private readonly List<TrialResult> _completedTrials;
    
    public IEnumerable<TrialResult> GetCompletedTrials() => _completedTrials;
    
  2. Inicialize-a no construtor

    public AutoMLMonitor(SweepablePipeline pipeline)
    {
        //...
        _completedTrials = new List<TrialResult>();
        //...
    }
    
  3. Acrescente cada resultado de avaliação dentro do método ReportCompletedTrial do ciclo de vida.

    public void ReportCompletedTrial(TrialResult result)
    {
        //...
        _completedTrials.Add(result);
    }
    
  4. Quando o treinamento for concluído, você poderá acessar todas as avaliações concluídas chamando 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 do selecionado pelo AutoML, registrar os resultados da avaliação em um banco de dados ou recompilar o pipeline de qualquer uma das avaliações concluídas.

Cancelar experimentos

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

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 proporcionam uma maneira de salvar saídas intermediárias do processo de treinamento no caso de um encerramento antecipado ou erro. Para definir um ponto de verificação, use o método de extensão SetCheckpoint 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

Conforme o aprendizado de máquina é introduzido em mais aspectos da vida diária, como serviços de saúde, é de extrema importância entender por que um modelo de machine learning toma as decisões que ele toma. A PFI (Importância do Recurso de Permutação) é uma técnica usada para explicar modelos de classificação, priorização e regressão. Em um alto nível, a maneira como eles funcionam é embaralhando aleatoriamente um recurso de dados por vez para todo o conjunto de dados e calculando o quanto a métrica de desempenho de interesse diminui. Quanto maior a alteração, mais importante é esse recurso. Para obter mais informações sobre a PFI, confira Interpretar previsões do modelo usando a importância do recurso de permutação.

Observação

Calcular a 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 a PFI levará para ser executada.

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

  1. Obtenha o melhor modelo.

    var bestModel = expResult.Model;
    
  2. Aplique o modelo ao conjunto de dados.

    var transformedData = bestModel.Transform(trainValidationData.TrainSet);
    
  3. Calcular a importância do recurso usando PermutationFeatureImportance

    Nesse caso, a tarefa é a regressão, mas o mesmo conceito se aplica a outras tarefas, como priorização e classificação.

    var pfiResults = 
        mlContext.Regression.PermutationFeatureImportance(bestModel, transformedData, permutationCount:3);
    
  4. Ordene 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);