Partilhar via

Retreinar um modelo

  • Artigo

Saiba como treinar novamente um modelo de aprendizado de máquina no ML.NET.

O mundo e seus dados mudam constantemente. Como tal, os modelos também precisam de ser alterados e atualizados. ML.NET fornece funcionalidade para retreinar modelos usando parâmetros de modelo aprendidos como ponto de partida para desenvolver continuamente a experiência anterior, em vez de começar do zero sempre.

Os seguintes algoritmos são treináveis em ML.NET:

Carregar modelo pré-treinado

Primeiro, carregue o modelo pré-treinado em seu aplicativo. Para saber mais sobre como carregar pipelines e modelos treinados, consulte Guardar e carregar um modelo treinado.

// Create MLContext
MLContext mlContext = new MLContext();

// Define DataViewSchema of data prep pipeline and trained model
DataViewSchema dataPrepPipelineSchema, modelSchema;

// Load data preparation pipeline
ITransformer dataPrepPipeline = mlContext.Model.Load("data_preparation_pipeline.zip", out dataPrepPipelineSchema);

// Load trained model
ITransformer trainedModel = mlContext.Model.Load("ogd_model.zip", out modelSchema);

Extrair parâmetros de modelo pré-treinados

Depois que o modelo for carregado, extraia os parâmetros do modelo aprendidos acessando a propriedade Model do modelo pré-treinado. O modelo pré-treinado foi treinado usando o modelo de regressão linear OnlineGradientDescentTrainer, que cria uma RegressionPredictionTransformer que produz LinearRegressionModelParameters. Esses parâmetros do modelo contêm o viés aprendido e pesos ou coeficientes do modelo. Esses valores são usados como ponto de partida para o novo modelo retreinado.

// Extract trained model parameters
LinearRegressionModelParameters originalModelParameters =
    ((ISingleFeaturePredictionTransformer<object>)trainedModel).Model as LinearRegressionModelParameters;

Observação

A saída dos parâmetros do modelo depende do algoritmo utilizado. Por exemplo, OnlineGradientDescentTrainer usa LinearRegressionModelParameters, enquanto LbfgsMaximumEntropyMulticlassTrainer gera MaximumEntropyModelParameters. Ao extrair parâmetros do modelo, formate para o tipo apropriado.

Retreinar um modelo

O processo de reciclagem de um modelo não é diferente do processo de formação de um modelo. A única diferença é que você passa um argumento adicional para o método Fit(IDataView, LinearModelParameters): os parâmetros originais do modelo aprendido. Fit() utiliza-os como ponto de partida no processo de re-treinamento.

// New Data
HousingData[] housingData = new HousingData[]
{
    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
    }
};

//Load New Data
IDataView newData = mlContext.Data.LoadFromEnumerable<HousingData>(housingData);

// Preprocess Data
IDataView transformedNewData = dataPrepPipeline.Transform(newData);

// Retrain model
RegressionPredictionTransformer<LinearRegressionModelParameters> retrainedModel =
    mlContext.Regression.Trainers.OnlineGradientDescent()
        .Fit(transformedNewData, originalModelParameters);

Neste ponto, você pode salvar seu modelo retreinado e usá-lo em seu aplicativo. Para obter mais informações, consulte Salvar e carregar um modelo treinado e Fazer previsões com um modelo treinado.

Comparar parâmetros do modelo

Como saber se a reciclagem realmente aconteceu? Uma maneira é comparar se os parâmetros do modelo retreinado são diferentes dos do modelo original. O exemplo de código a seguir compara o modelo original com os pesos do modelo retreinado e apresenta os resultados no console.

// Extract Model Parameters of re-trained model
LinearRegressionModelParameters retrainedModelParameters = retrainedModel.Model as LinearRegressionModelParameters;

// Inspect Change in Weights
var weightDiffs =
    originalModelParameters.Weights.Zip(
        retrainedModelParameters.Weights, (original, retrained) => original - retrained).ToArray();

Console.WriteLine("Original | Retrained | Difference");
for(int i=0;i < weightDiffs.Count();i++)
{
    Console.WriteLine($"{originalModelParameters.Weights[i]} | {retrainedModelParameters.Weights[i]} | {weightDiffs[i]}");
}

A tabela a seguir mostra como poderá ser a saída.

Original Retreinado Diferença
33039.86 56293.76 -23253.9
29099.14 49586.03 -20486.89
28 938,38 48609.23 -19670.85
30484.02 53745.43 -23261.41