Partilhar via

Treinar e avaliar um modelo

  • Artigo

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 IDataView.

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

Utilize o método TrainTestSplit para dividir os dados em conjuntos de treino e teste. O resultado é um objeto TrainTestData que contém dois membros IDataView, um para o conjunto de trens e outro para o conjunto de teste. A percentagem de divisão de dados é determinada pelo parâmetro testFraction. O trecho a seguir 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 e no transforms page.

ML.NET algoritmos têm restrições aos 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 atributo VectorType ao seu modelo de dados quando todos os dados já estiverem em formato numérico e se destinarem a ser processados juntos (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 método Concatenate depois que todas as colunas tiverem sido processadas para combinar todas as colunas individuais em um único vetor de recurso que é saída para uma nova coluna.

O trecho a seguir combina as colunas Size e HistoricalPrices em um único vetor de recurso que é gerado para uma nova coluna chamada Features. Como há uma diferença nas escalas, NormalizeMinMax é aplicado à coluna Features 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, 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 Concatenate durante o 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, pois ele já existe no IDataViewpré-processado. A coluna de rótulo é CurrentPrice, mas como o atributo ColumnName é usado no modelo de dados, ML.NET renomeia a coluna CurrentPrice para Label, o que elimina a necessidade de fornecer o parâmetro labelColumnName 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");

Armazenamento em cache de dados

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 AppendCacheCheckpoint.

Recomenda-se usar AppendCacheCheckpoint antes de qualquer treinador no fluxo de processamento.

Ao usar o seguinte EstimatorChaine adicionar AppendCacheCheckpoint antes de StochasticDualCoordinateAscent, o treinador armazena em cache os resultados dos estimadores anteriores para uso posterior.

// 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 método Fit para treinar o modelo de aprendizado de máquina com o algoritmo de regressão StochasticDualCoordinateAscent.

// 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 ModelParameters aprendido para inspeção ou reciclagem. Os LinearRegressionModelParameters fornecem o viés e os coeficientes ou pesos aprendidos do modelo treinado.

var trainedModelParameters = trainedModel.Model as LinearRegressionModelParameters;

Observação

Outros modelos têm parâmetros específicos para as suas tarefas. Por exemplo, o algoritmo K-Means coloca dados em cluster com base em centróides e o KMeansModelParameters contém uma propriedade que armazena esses centróides aprendidos. Para saber mais, visite a documentação da API Microsoft.ML.Trainers e procure classes que contenham ModelParameters no seu nome.

Avaliar a qualidade do modelo

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

Observação

O método Evaluate produz métricas diferentes dependendo de qual tarefa de aprendizado de máquina foi executada. Para obter mais detalhes, visite a Documentação da API Microsoft.ML.Data e procure por classes que contenham Metrics no seu nome.

// 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. No método Evaluate, os valores na coluna CurrentPrice do conjunto de dados de teste são comparados com a coluna Score 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 variável rSquared.

Observação

Neste pequeno exemplo, o R-Squared é um número que não está no intervalo de 0-1 devido ao tamanho limitado dos dados. Em um cenário do mundo real, você deve esperar ver um valor entre 0 e 1.