Salvar e carregar modelos treinados

Saiba como salvar e carregar modelos treinados em seu aplicativo.

Ao longo do processo de criação de modelos, um modelo reside na memória e é acessível durante todo o ciclo de vida do aplicativo. No entanto, depois que o aplicativo parar de ser executado, se o modelo não for salvo em algum lugar local ou remotamente, ele não estará mais acessível. Normalmente, os modelos são usados em algum momento após o treinamento em outros aplicativos para inferência ou retreinamento. Portanto, é importante armazenar o modelo. Salve e carregue modelos usando as etapas descritas nas seções subsequentes deste artigo ao usar pipelines de preparação de dados e treinamento de modelo, como o mostrado aqui. Embora este exemplo use um modelo de regressão linear, o mesmo processo se aplica a outros algoritmos de ML.NET.

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

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

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

// Define data preparation estimator
EstimatorChain<RegressionPredictionTransformer<LinearRegressionModelParameters>> pipelineEstimator =
    mlContext.Transforms.Concatenate("Features", new string[] { "Size", "HistoricalPrices" })
        .Append(mlContext.Transforms.NormalizeMinMax("Features"))
        .Append(mlContext.Regression.Trainers.Sdca());

// Train model
ITransformer trainedModel = pipelineEstimator.Fit(data);

// Save model
mlContext.Model.Save(trainedModel, data.Schema, "model.zip");

Como a maioria dos modelos e os pipelines de preparação de dados herdam do mesmo conjunto de classes, as assinaturas do método save e load para esses componentes são as mesmas. Dependendo do seu caso de uso, você pode combinar o pipeline de preparação de dados e o modelo em um único EstimatorChain que geraria um único ITransformer ou os separaria, criando assim um separado ITransformer para cada um.

Salvar um modelo localmente

Ao salvar um modelo, você precisa de duas coisas:

1. O ITransformer do modelo.
2. O DataViewSchema da entrada esperada de ITransformer.

Depois de treinar o modelo, use o Save método para salvar o modelo treinado em um arquivo chamado model.zip usando os DataViewSchema dados de entrada.

// Save Trained Model
mlContext.Model.Save(trainedModel, data.Schema, "model.zip");

Salvar um modelo ONNX localmente

Para salvar uma versão do ONNX (Open Neural Network Exchange) do modelo localmente, você deve instalar o pacote NuGet Microsoft.ML.OnnxConverter.

Com o OnnxConverter pacote instalado, você pode usá-lo para salvar seu modelo no formato ONNX. Isso requer um objeto Stream, que você pode fornecer na forma de FileStream usando o método File.Create. O File.Create método usa um parâmetro de cadeia de caracteres que representa o caminho do modelo ONNX.

using FileStream stream = File.Create("./onnx_model.onnx");

Com o fluxo criado, você pode chamar o ConvertToOnnx método e fornecer o modelo treinado, os dados usados para treinar o modelo e o fluxo. No entanto, nem todos os treinadores e transformadores podem ser exportados para ONNX. Para obter uma lista completa, consulte os guias Transforms e How to Choose an ML.NET Algorithm.

mlContext.Model.ConvertToOnnx(trainedModel, data, stream);

Carregar um modelo armazenado localmente

Modelos armazenados localmente podem ser usados em outros processos ou aplicativos, como ASP.NET Core e aplicativos Web sem servidor. Para obter mais informações, consulte Use ML.NET na API Web e Deploy ML.NET Aplicativo Web sem Servidor.

Em um aplicativo ou processo separado, use o Load método junto com o caminho do arquivo para colocar o modelo treinado em seu aplicativo.

//Define DataViewSchema for data preparation pipeline and trained model
DataViewSchema modelSchema;

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

Carregar um modelo ONNX localmente

Para carregar um modelo ONNX para fazer previsões, instale o pacote NuGet Microsoft.ML.OnnxTransformer.

Com o OnnxTransformer pacote instalado, você pode carregar um modelo ONNX existente usando o ApplyOnnxModel método. O parâmetro necessário é uma cadeia de caracteres que é o caminho do modelo ONNX local.

OnnxScoringEstimator estimator = mlContext.Transforms.ApplyOnnxModel("./onnx_model.onnx");

O ApplyOnnxModel método retorna um OnnxScoringEstimator objeto. Primeiro, você precisa carregar os novos dados.

HousingData[] newHousingData = new HousingData[]
{
    new()
    {
        Size = 1000f,
        HistoricalPrices = new[] { 300_000f, 350_000f, 450_000f },
        CurrentPrice = 550_00f
    }
};

Carregue os novos dados em um IDataView usando o método LoadFromEnumerable.

IDataView newHousingDataView = mlContext.Data.LoadFromEnumerable(newHousingData);

Agora você pode usar o novo IDataView para se adaptar aos novos dados.

estimator.Fit(newHousingDataView);

Depois de usar o método Fit em um estimador de ApplyOnnxModel, ele pode ser salvo como um novo modelo usando o método Save descrito na seção salvar um modelo localmente.

Carregar um modelo armazenado remotamente

Para carregar no seu aplicativo pipelines de preparação de dados e modelos armazenados em um local remoto, use um Stream em vez de um caminho de arquivo no método Load.

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

// Define DataViewSchema and ITransformers
DataViewSchema modelSchema;
ITransformer trainedModel;

// Load data prep pipeline and trained model
using (HttpClient client = new HttpClient())
{
    Stream modelFile = await client.GetStreamAsync("<YOUR-REMOTE-FILE-LOCATION>");

    trainedModel = mlContext.Model.Load(modelFile, out modelSchema);
}

Trabalhar com pipelines separados de preparação de dados e de modelos

Ao trabalhar com pipelines e modelos de preparação de dados separados, o mesmo processo aplicado a pipelines individuais se aplica. A diferença é que ambos os pipelines precisam ser salvos e carregados simultaneamente.

Determinados pipelines de preparação de dados separados e treinamento de modelo:

// Define data preparation estimator
IEstimator<ITransformer> dataPrepEstimator =
    mlContext.Transforms.Concatenate("Features", new string[] { "Size", "HistoricalPrices" })
        .Append(mlContext.Transforms.NormalizeMinMax("Features"));

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

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

// Pre-process data using data prep operations
IDataView transformedData = dataPrepTransformer.Transform(data);

// Train regression model
RegressionPredictionTransformer<LinearRegressionModelParameters> trainedModel = sdcaEstimator.Fit(transformedData);

Salvar o pipeline de preparação de dados e o modelo treinado

Para salvar o pipeline de preparação de dados e o modelo treinado, use os seguintes comandos:

// Save Data Prep transformer
mlContext.Model.Save(dataPrepTransformer, data.Schema, "data_preparation_pipeline.zip");

// Save Trained Model
mlContext.Model.Save(trainedModel, transformedData.Schema, "model.zip");

Carregar o pipeline de preparação de dados e o modelo treinado

Em um processo ou aplicativo separado, carregue o pipeline de preparação de dados e o modelo treinado simultaneamente da seguinte maneira:

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

// Define data preparation and trained model schemas
DataViewSchema dataPrepPipelineSchema, modelSchema;

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