Compartir a través de

Cómo usar la API de ML automatizado de ML.NET (AutoML)

  • Artículo

En este artículo aprenderá a usar el ML automatizado de ML.NET (API AutoML).

Puede encontrar ejemplos para la API AutoML en el repositorio dotnet/machinelearning-samples.

Instalación

Para usar la API AutoML, instale el paquete de NuGet Microsoft.ML.AutoML en el proyecto de .NET en el que quiere hacer referencia.

Nota

En esta guía se usa la versión 0.20.0 y posteriores del paquete de NuGet Microsoft.ML.AutoML. Aunque los ejemplos y el código de versiones anteriores siguen funcionando, se recomienda encarecidamente usar las API presentadas en esta versión para nuevos proyectos.

Para obtener más información sobre cómo instalar paquetes de NuGet, consulte las siguientes guías:

Inicio rápido

AutoML proporciona varios valores predeterminados para entrenar rápidamente modelos de aprendizaje automático. En esta sección aprenderá a:

  • Carga de los datos
  • Definir la canalización
  • Configuración del experimento
  • Ejecutar el experimento
  • Usar el mejor modelo para realizar predicciones

Definir el problema

Dado un conjunto de datos almacenado en un archivo separado por comas denominado taxi-fare-train.csv que tiene el siguiente aspecto:

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

Carga de los datos

Empiece por inicializar MLContext. MLContext es un punto de partida para todas las operaciones de ML.NET. La inicialización de mlContext crea un nuevo entorno de ML.NET que se puede compartir entre los objetos del flujo de trabajo de creación de modelos. Como concepto, se parece a DBContext en Entity Framework.

A continuación, para cargar los datos, use el 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 carga algunas filas desde el conjunto de datos. A continuación, inspecciona los datos e intenta adivinar o deducir el tipo de datos para cada una de las columnas en función de su contenido.

El comportamiento predeterminado es agrupar columnas del mismo tipo en vectores de características o matrices que contienen los elementos para cada una de las columnas individuales. Establecer groupColumns en false invalida ese comportamiento predeterminado y solo realiza la inferencia de columnas sin agrupar columnas. Al mantener separadas las columnas, permite aplicar diferentes transformaciones de datos al preprocesar los datos en el nivel de columna individual en lugar de la agrupación de columnas.

El resultado de InferColumns es un objeto ColumnInferenceResults que contiene las opciones necesarias para crear una TextLoader así como la información de columna.

Para el conjunto de datos de ejemplo de taxi-fare-train.csv, la información de columna puede tener el siguiente aspecto:

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

Una vez que tenga la información de columna, use la TextLoader.Options definida por ColumnInferenceResults para crear una TextLoader para cargar los datos en una IDataView.

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

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

A menudo, se recomienda dividir los datos en conjuntos de entrenamiento y validación. Use TrainTestSplit para crear una división del conjunto de datos de un 80 % para entrenamiento y un 20 % para validación.

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

Definir la canalización

La canalización define los pasos del procesamiento de datos y la canalización del aprendizaje automático que se van a usar para entrenar el modelo.

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

SweepablePipeline es una colección de SweepableEstimator. SweepableEstimator es una clase Estimator de ML.NET con una clase SearchSpace.

Featurizer es una API útil que crea una canalización de estimadores de procesamiento de datos que pueden rastrearse por barrido en función de la información de columna que proporcione. En lugar de compilar una canalización desde cero, Featurizer automatiza el paso de preprocesamiento de datos. Para obtener más información sobre las transformaciones admitidas por ML.NET, consulte la guía de transformaciones de datos.

La salida Featurizer es una sola columna que contiene un vector de características numérico que representa los datos transformados para cada una de las columnas. A continuación, este vector de características se usa como entrada para los algoritmos que se usan para entrenar un modelo de aprendizaje automático.

Si desea un control más preciso sobre el preprocesamiento de los datos, puede crear una canalización con cada uno de los pasos de preprocesamiento individuales. Para obtener más información, consulte la guía de preparación de datos para compilar un modelo.

Sugerencia

Use Featurizer con ColumnInferenceResults para maximizar la utilidad de AutoML.

Para el entrenamiento, AutoML proporciona una canalización rastreable por barrido con instructores predeterminados y configuraciones de espacio de búsqueda para las siguientes tareas de aprendizaje automático:

Para el problema de la predicción de tarifas de taxi, dado que el objetivo es predecir un valor numérico, use Regression. Para obtener más información sobre cómo elegir una tarea, consulteTareas de aprendizaje automático en ML.NET

Configuración del experimento

En primer lugar, cree un experimento de AutoML. AutoMLExperiment es una colección de TrialResult.

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

Una vez creado el experimento, use los métodos de extensión que proporciona para configurar diferentes opciones.

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

En este ejemplo, puede:

  • Establecer la canalización rastreable por barrido para que se ejecute durante el experimento llamando a SetPipeline.
  • Elegir RSquared como métrica para optimizar durante el entrenamiento llamando a SetRegressionMetric. Para más información sobre las métricas de evaluación, consulte la guía de evaluación del modelo de ML.NET con métricas.
  • Establezca 60 segundos como la cantidad de tiempo que desea entrenar llamando aSetTrainingTimeInSeconds. Una buena heurística para determinar cuánto tiempo se va a entrenar es el tamaño de los datos. Normalmente, los conjuntos de datos más grandes requieren más tiempo de entrenamiento. Para obtener más información, vea la guía de tiempo de entrenamiento.
  • Proporcione los conjuntos de datos de entrenamiento y validación que se usarán llamando a SetDataset.

Una vez definido el experimento, querrá realizar el seguimiento de su progreso de alguna manera. La forma más rápida de realizar un seguimiento del progreso es modificando el evento Log desde MLContext.

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

Ejecutar el experimento

Ahora que ha definido el experimento, use el método RunAsync para iniciar el experimento.

TrialResult experimentResults = await experiment.RunAsync();

Una vez que expire el tiempo de entrenamiento, el resultado es una TrialResult para el mejor modelo encontrado durante el entrenamiento.

En este punto, puede guardar el modelo o usarlo para realizar predicciones. Para obtener más información sobre cómo usar un modelo de ML.NET, consulte las siguientes guías:

Modificación de los resultados de la columna de inferencias

Dado que InferColumns solo carga un subconjunto de los datos, es posible que los casos extremos contenidos fuera de las muestras usadas para inferir columnas no se detecten, y que se hayan establecidos tipos de datos incorrectos para las columnas. Puede actualizar las propiedades de ColumnInformation para tener en cuenta esos casos en los que los resultados de la columna de inferencias no son correctos.

Por ejemplo, en el conjunto de datos de tarifas de taxi, los datos en la columna rate_code son un número. Sin embargo, ese valor numérico representa una categoría. De forma predeterminada, llamar a InferColumns colocará rate_code en la propiedad NumericColumnNames en lugar de CategoricalColumnNames. Dado que estas propiedades son colecciones de .NET, puede usar operaciones estándar para agregar y quitar elementos de ellas.

Puede hacer lo siguiente para actualizar ColumnInformation para rate_code.

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

Excluir instructores

De forma predeterminada, AutoML prueba varios instructores como parte del proceso de entrenamiento para ver cuál funciona mejor con los datos. Sin embargo, a lo largo del proceso de entrenamiento, es posible que descubra que hay algunos instructores que usan demasiados recursos de procesamiento o que no proporcionan buenas métricas de evaluación. Tiene la opción de excluir instructores del proceso de entrenamiento. Qué instructores se usan depende de la tarea. Para obtener una lista de los instructores admitidos en ML.NET, consulte la guía de tareas de aprendizaje automático en ML.NET.

Por ejemplo, en el escenario de regresión de tarifas de taxi, para excluir el algoritmo LightGBM, establezca el parámetro useLgbm en false.

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

El proceso para excluir instructores en otras tareas, como la clasificación binaria y multiclase, funciona de la misma manera.

Personalización de un estimador rastreable por barrido

Cuando quiera una personalización más pormenorizada de las opciones del estimador incluidas como parte de la canalización rastreable por barrido, debe hacer lo siguiente:

  1. Inicializar un espacio de búsqueda
  2. Usar el espacio de búsqueda para definir un generador personalizado
  3. Crear un estimador rastreable por barrido
  4. Agregar el estimador rastreable por barrido a la canalización rastreable por barrido

AutoML proporciona un conjunto de espacios de búsqueda preconfigurados para instructores en las siguientes tareas de aprendizaje automático:

En este ejemplo, el espacio de búsqueda usado es para SdcaRegressionTrainer. Inicialícelo mediante SdcaOption.

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

A continuación, use el espacio de búsqueda para definir un método generador personalizado para crear SdcaRegressionTrainer. En este ejemplo, los valores de L1Regularization y L2Regularization se establecen en algo distinto del valor predeterminado. Para L1Regularization, el valor establecido viene determinado por el optimizador durante cada prueba. L2Regularization se fija para cada prueba de acuerdo con el valor codificado de forma rígida. Durante cada prueba, la salida del generador personalizado es SdcaRegressionTrainer con los 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);
};

Un estimador rastreable por barrido es la combinación de un estimador y un espacio de búsqueda. Ahora que ha definido un espacio de búsqueda y lo ha usado para crear un método generador personalizado para generar instructores, use el método CreateSweepableEstimator para crear un nuevo estimador rastreable por barrido.

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

Para usar el estimador rastreable por barrido en el experimento, agréguelo a la canalización rastreable por barrido.

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

Dado que las canalizaciones rastreables por barrido son una colección de estimadores rastreables por barrido, puede configurar y personalizar tantos de estos estimadores rastreables por barrido como necesite.

Personalización del espacio de búsqueda

Hay escenarios en los que desea ir más allá de personalizar los estimadores rastreables por barrido usados en el experimento y desea controlar el intervalo del espacio de búsqueda. Para ello, puede acceder a las propiedades del espacio de búsqueda mediante claves. En este caso, el parámetro L1Regularization es un parámetro float. Por lo tanto, para personalizar el intervalo de búsqueda, use UniformSingleOption.

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

En función del tipo de datos del hiperparámetro que desee establecer, puede elegir entre las siguientes opciones:

Los espacios de búsqueda también pueden contener espacios de búsqueda anidados.

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;

Otra opción para personalizar los intervalos de búsqueda es ampliarlos. Por ejemplo, SdcaOption solo proporciona los parámetros L1Regularization y L2Regularization. Sin embargo, SdcaRegressionTrainer tiene más parámetros que puede establecer, como BiasLearningRate.

Para ampliar el espacio de búsqueda, cree una nueva clase, como SdcaExtendedOption, que hereda de SdcaOption.

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

Para especificar el intervalo del espacio de búsqueda use RangeAttribute, que es equivalente a Microsoft.ML.SearchSpace.Option.

A continuación, en cualquier lugar en el que use el espacio de búsqueda, haga referencia a SdcaExtendedOption en lugar de SdcaOption.

Por ejemplo, al inicializar el espacio de búsqueda, puede hacerlo de la siguiente manera:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Creación de su propio ejecutor de prueba

De forma predeterminada, AutoML admite la clasificación binaria, la clasificación multiclase y la regresión. Sin embargo, ML.NET admite muchos más escenarios, como:

  • Recomendación
  • Previsión
  • Clasificación
  • Clasificación de imágenes
  • Clasificación de textos
  • Similitud de oraciones

Para escenarios que no tienen espacios de búsqueda preconfigurados y estimadores rastreables por barrido, puede crearlos y usar un ejecutor de prueba para habilitar AutoML para ese escenario.

Por ejemplo, dados los datos de opiniones de restaurantes que tienen el siguiente aspecto:

¡Anda! Me encantó el lugar.

1

La corteza no es buena.

0

Quiere usar el instructor TextClassificationTrainer para analizar la opinión, donde 0 es negativo y 1 es positivo. Sin embargo, no hay ninguna configuración ctx.Auto().TextClassification().

Para usar AutoML con el instructor de clasificación de texto, tendrá que:

  1. Crear su propio espacio de búsqueda.

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

    En este caso, AutoML buscará configuraciones diferentes del hiperparámetro BatchSize.

  2. Cree un estimador rastreable por barrido y agréguelo a la canalización.

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

    En este ejemplo, se usan el espacio de búsqueda TCOption y un generador TextClassificationTrainer personalizado para crear un estimador rastreable por barrido.

  3. Creación de un ejecutor de prueba personalizado

    Para crear un ejecutor de prueba 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(),
        };
    }
}

    La implementación TCRunner en este ejemplo:

    • Extrae los hiperparámetros elegidos para esa prueba
    • Usa los hiperparámetros para crear una canalización de ML.NET
    • Usa la canalización de ML.NET para entrenar un modelo
    • Evalúa el modelo
    • Devuelve un objeto TrialResult con la información de esa prueba

  4. Inicializar el ejecutor de prueba personalizado

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

  5. Crear y configurar el experimento. Use el método de extensión SetTrialRunner para agregar el ejecutor de prueba personalizado al 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. Ejecutar el experimento

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

Elegir un optimizador diferente

AutoML admite diversos algoritmos de optimización para recorrer en iteración el espacio de búsqueda, en busca de los hiperparámetros óptimos. De forma predeterminada, usa el optimizador Eci Cost Frugal. Con métodos de extensión de experimento puede elegir otro optimizador que se adapte mejor a su escenario.

Use los métodos siguientes para establecer el optimizador:

Por ejemplo, para usar el optimizador de búsqueda de cuadrícula, el código podría ser similar al siguiente:

experiment.SetGridSearchTuner();

Configuración de la supervisión de experimentos

La forma más rápida de supervisar el progreso de un experimento es definir el evento Log desde MLContext. Sin embargo, el evento Log genera un volcado sin procesar de los registros generados por AutoML durante cada prueba. Debido a la gran cantidad de información sin formato, esto es difícil.

Para obtener una experiencia de supervisión más controlada, implemente una clase con la interfaz 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;
    }
}

La interfaz IMonitor tiene cuatro eventos de ciclo de vida:

Sugerencia

Aunque no es necesario, incluya SweepablePipeline en la supervisión para poder inspeccionar la canalización que se generó para una prueba mediante la propiedad Parameter de TrialSettings.

En este ejemplo, solo se implementan ReportCompletedTrial y ReportFailTrial.

Una vez implementada la supervisión, establézcala como parte de la configuración del experimento mediante SetMonitor.

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

A continuación, ejecute el experimento:

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

Al ejecutar el experimento con esta implementación, la salida debe ser similar a la siguiente:

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

Persistencia de las pruebas

De forma predeterminada, AutoML solo almacena TrialResult para el mejor modelo. Sin embargo, si desea conservar cada una de las pruebas, puede hacerlo desde el monitor.

Dentro del monitor:

  1. Defina una propiedad para las pruebas completadas y un método para acceder a ellas.

    private readonly List<TrialResult> _completedTrials;

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

  2. Inicialícelo en el constructor

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

  3. Anexe cada resultado de prueba dentro del método de ciclo de vida ReportCompletedTrial.

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

  4. Cuando se complete el entrenamiento, puede acceder a todas las pruebas completadas llamando a GetCompletedTrials

    var completedTrials = monitor.GetCompletedTrials();

En este momento, puede realizar un procesamiento adicional en la colección de pruebas completadas. Por ejemplo, puede elegir un modelo distinto del seleccionado por AutoML, registrar los resultados de prueba en una base de datos o recompilar la canalización a partir de cualquiera de las pruebas completadas.

Cancelación de experimentos

Al ejecutar experimentos de forma asincrónica, asegúrese de finalizar el proceso de forma limpia. Para ello, use CancellationToken.

Advertencia

La cancelación de un experimento no guardará ninguno de los resultados intermedios. Establezca un punto de control para guardar los resultados intermedios.

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

Establecimiento de puntos de control

Los puntos de control proporcionan una manera de guardar los resultados intermedios del proceso de entrenamiento en caso de que se produzca una terminación anticipada o un error. Para establecer un punto de control, use el método de extensión SetCheckpoint y proporcione un directorio para almacenar los resultados intermedios.

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

Determinar la importancia de características

A medida que el aprendizaje automático se introduce en otros aspectos de la vida diaria como la asistencia sanitaria, es de vital importancia comprender por qué un modelo de Machine Learning toma esas decisiones. La importancia de la característica de permutación (PFI) es una técnica que se usa para explicar los modelos de clasificación, orden y regresión. En un nivel alto, esto funciona de manera es revolviendo los datos de manera aleatoria en una característica a la vez para todo el conjunto de datos y calculando cuánto se reduce la métrica de rendimiento de interés. Cuanto mayor sea el cambio, más importante será esa característica. Para obtener más información sobre PFI, consulte Interpretación de las predicciones del modelo mediante la importancia de características de permutación.

Nota

El cálculo de PFI puede ser una operación que consume mucho tiempo. Cuánto tiempo se tarda en calcular es proporcional al número de columnas de características que tiene. Cuantos más características, la PFI más larga tardará en ejecutarse.

Para determinar la importancia de las características mediante AutoML:

  1. Obtenga el mejor modelo.

    var bestModel = expResult.Model;

  2. Aplique el modelo al conjunto de datos.

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

  3. Calcule la importancia de las características mediante PermutationFeatureImportance

    En este caso, la tarea es regresión, pero el mismo concepto se aplica a otras tareas, como clasificación y clasificación.

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

  4. Ordene la importancia de las características mediante cambios en las métricas de evaluación.

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