Treinar e avaliar um modelo

Saiba como criar modelos de aprendizado de máquina, coletar métricas e medir o desempenho com ML.NET. Embora esta amostra treine um modelo de regressão, os conceitos são aplicáveis na maioria dos outros algoritmos.

Dividir dados para treinamento e testes

O objetivo de um modelo de aprendizado de máquina é identificar padrões nos dados de treinamento. Esses padrões são usados para fazer previsões usando novos dados.

Os dados podem ser modelados por uma classe como HousingData.

public class HousingData
{
    [LoadColumn(0)]
    public float Size { get; set; }

    [LoadColumn(1, 3)]
    [VectorType(3)]
    public float[] HistoricalPrices { get; set; }

    [LoadColumn(4)]
    [ColumnName("Label")]
    public float CurrentPrice { get; set; }
}

Dado os seguintes dados que são carregados em um IDataViewarquivo .

HousingData[] housingData = new HousingData[]
{
    new HousingData
    {
        Size = 600f,
        HistoricalPrices = new float[] { 100000f ,125000f ,122000f },
        CurrentPrice = 170000f
    },
    new HousingData
    {
        Size = 1000f,
        HistoricalPrices = new float[] { 200000f, 250000f, 230000f },
        CurrentPrice = 225000f
    },
    new HousingData
    {
        Size = 1000f,
        HistoricalPrices = new float[] { 126000f, 130000f, 200000f },
        CurrentPrice = 195000f
    },
    new HousingData
    {
        Size = 850f,
        HistoricalPrices = new float[] { 150000f,175000f,210000f },
        CurrentPrice = 205000f
    },
    new HousingData
    {
        Size = 900f,
        HistoricalPrices = new float[] { 155000f, 190000f, 220000f },
        CurrentPrice = 210000f
    },
    new HousingData
    {
        Size = 550f,
        HistoricalPrices = new float[] { 99000f, 98000f, 130000f },
        CurrentPrice = 180000f
    }
};

Use o TrainTestSplit método para dividir os dados em conjuntos de trem e teste. O resultado será um TrainTestData objeto que contém dois IDataView membros, um para o conjunto de comboios e outro para o conjunto de ensaios. A percentagem de divisão de testFraction dados é determinada pelo parâmetro. O trecho abaixo contém 20% dos dados originais do conjunto de testes.

DataOperationsCatalog.TrainTestData dataSplit = mlContext.Data.TrainTestSplit(data, testFraction: 0.2);
IDataView trainData = dataSplit.TrainSet;
IDataView testData = dataSplit.TestSet;

Preparar os dados

Os dados precisam ser pré-processados antes de treinar um modelo de aprendizado de máquina. Mais informações sobre a preparação de dados podem ser encontradas no artigo de instruções de preparação de dados, bem como no transforms page.

ML.NET algoritmos têm restrições nos tipos de colunas de entrada. Além disso, os valores padrão são usados para nomes de colunas de entrada e saída quando nenhum valor é especificado.

Trabalhar com tipos de coluna esperados

Os algoritmos de aprendizado de máquina em ML.NET esperam um vetor flutuante de tamanho conhecido como entrada. Aplique o VectorType atributo ao seu modelo de dados quando todos os dados já estiverem em formato numérico e se destinarem a ser processados em conjunto (ou seja, pixels de imagem).

Se os dados não forem todos numéricos e você quiser aplicar transformações de dados diferentes em cada uma das colunas individualmente, use o Concatenate método depois que todas as colunas tiverem sido processadas para combinar todas as colunas individuais em um único vetor de recurso que é gerado para uma nova coluna.

O trecho a seguir combina as colunas e HistoricalPrices em Size um único vetor de recurso que é gerado para uma nova coluna chamada Features. Como há uma diferença nas escalas, NormalizeMinMax é aplicado à Features coluna para normalizar os dados.

// Define Data Prep Estimator
// 1. Concatenate Size and Historical into a single feature vector output to a new column called Features
// 2. Normalize Features vector
IEstimator<ITransformer> dataPrepEstimator =
    mlContext.Transforms.Concatenate("Features", "Size", "HistoricalPrices")
        .Append(mlContext.Transforms.NormalizeMinMax("Features"));

// Create data prep transformer
ITransformer dataPrepTransformer = dataPrepEstimator.Fit(trainData);

// Apply transforms to training data
IDataView transformedTrainingData = dataPrepTransformer.Transform(trainData);

Trabalhar com nomes de colunas predefinidos

ML.NET algoritmos usam nomes de coluna padrão quando nenhum é especificado. Todos os treinadores têm um parâmetro chamado featureColumnName para as entradas do algoritmo e, quando aplicável, eles também têm um parâmetro para o valor esperado chamado labelColumnName. Por padrão, esses valores são Features e Label respectivamente.

Usando o método durante o Concatenate pré-processamento para criar uma nova coluna chamada Features, não há necessidade de especificar o nome da coluna do recurso nos parâmetros do algoritmo, uma vez que ele já existe no pré-processado IDataView. A coluna de rótulo é CurrentPrice, mas como o ColumnName atributo é usado no modelo de dados, ML.NET renomeia a coluna para Label a CurrentPrice qual elimina a necessidade de fornecer o labelColumnName parâmetro ao estimador de algoritmo de aprendizado de máquina.

Se você não quiser usar os nomes de coluna padrão, passe os nomes das colunas de recurso e rótulo como parâmetros ao definir o estimador de algoritmo de aprendizado de máquina, conforme demonstrado pelo trecho subsequente:

var UserDefinedColumnSdcaEstimator = mlContext.Regression.Trainers.Sdca(labelColumnName: "MyLabelColumnName", featureColumnName: "MyFeatureColumnName");

Colocar dados em cache

Por padrão, quando os dados são processados, eles são carregados ou transmitidos com preguiça, o que significa que os instrutores podem carregar os dados do disco e iterar sobre ele várias vezes durante o treinamento. Portanto, o cache é recomendado para conjuntos de dados que cabem na memória para reduzir o número de vezes que os dados são carregados do disco. O armazenamento em cache é feito como parte de um EstimatorChain usando AppendCacheCheckpointo .

Recomenda-se usar AppendCacheCheckpoint antes de qualquer treinador na calha.

Usando o seguinte EstimatorChain, adicionando AppendCacheCheckpoint antes que o StochasticDualCoordinateAscent treinador armazene em cache os resultados dos estimadores anteriores para uso posterior pelo treinador.

// 1. Concatenate Size and Historical into a single feature vector output to a new column called Features
// 2. Normalize Features vector
// 3. Cache prepared data
// 4. Use Sdca trainer to train the model
IEstimator<ITransformer> dataPrepEstimator =
    mlContext.Transforms.Concatenate("Features", "Size", "HistoricalPrices")
        .Append(mlContext.Transforms.NormalizeMinMax("Features"))
        .AppendCacheCheckpoint(mlContext);
        .Append(mlContext.Regression.Trainers.Sdca());

Treinar o modelo de aprendizado de máquina

Depois que os dados forem pré-processados, use o Fit método para treinar o modelo de aprendizado de máquina com o StochasticDualCoordinateAscent algoritmo de regressão.

// Define StochasticDualCoordinateAscent regression algorithm estimator
var sdcaEstimator = mlContext.Regression.Trainers.Sdca();

// Build machine learning model
var trainedModel = sdcaEstimator.Fit(transformedTrainingData);

Extrair parâmetros do modelo

Após o modelo ter sido treinado, extraia o aprendido ModelParameters para inspeção ou reciclagem. O LinearRegressionModelParameters fornece o viés e os coeficientes ou pesos aprendidos do modelo treinado.

var trainedModelParameters = trainedModel.Model as LinearRegressionModelParameters;

Avaliar a qualidade do modelo

Para ajudar a escolher o modelo com melhor desempenho, é essencial avaliar o seu desempenho com base nos dados de teste. Use o Evaluate método, para medir várias métricas para o modelo treinado.

// Measure trained model performance
// Apply data prep transformer to test data
IDataView transformedTestData = dataPrepTransformer.Transform(testData);

// Use trained model to make inferences on test data
IDataView testDataPredictions = trainedModel.Transform(transformedTestData);

// Extract model metrics and get RSquared
RegressionMetrics trainedModelMetrics = mlContext.Regression.Evaluate(testDataPredictions);
double rSquared = trainedModelMetrics.RSquared;

No exemplo de código anterior:

1. O conjunto de dados de teste é pré-processado usando as transformações de preparação de dados previamente definidas.
2. O modelo de aprendizado de máquina treinado é usado para fazer previsões sobre os dados de teste.
3. Evaluate No método, os valores na CurrentPrice coluna do conjunto de dados de teste são comparados com a Score coluna das previsões de saída recém-saídas para calcular as métricas para o modelo de regressão, uma das quais, R-Squared é armazenada na rSquared variável.