Salvare e caricare modelli sottoposti a training

Informazioni su come salvare e caricare modelli sottoposti a training nell'applicazione.

Durante il processo di compilazione del modello, un modello vive in memoria ed è accessibile per tutto il ciclo di vita dell'applicazione. Tuttavia, una volta arrestata l'esecuzione dell'applicazione, se il modello non viene salvato in locale o in remoto, non è più accessibile. In genere, i modelli vengono usati a un certo punto dopo il training in altre applicazioni per l'inferenza o il nuovo training. È quindi importante archiviare il modello. Salvare e caricare modelli utilizzando i passaggi descritti nelle sezioni successive di questo articolo quando si utilizzano pipeline di preparazione e addestramento dei modelli come quella illustrata qui. Anche se questo esempio usa un modello di regressione lineare, lo stesso processo si applica ad altri algoritmi di 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");

Poiché la maggior parte dei modelli e delle pipeline di preparazione dei dati eredita dallo stesso set di classi, le definizioni dei metodi di salvataggio e caricamento per questi componenti sono identiche. A seconda del caso d'uso, è possibile combinare la pipeline di preparazione dei dati e il modello in un'unica EstimatorChain che restituisce un singolo ITransformer o separarli creando così un ITransformer separato per ognuno.

Salvare un modello in locale

Quando si salva un modello, sono necessari due elementi:

1. Il ITransformer del modello.
2. Il DataViewSchema dell'input previsto del ITransformer.

Dopo l'addestramento del modello, utilizzare il metodo Save per salvare il modello addestrato in un file denominato model.zip usando il DataViewSchema dei dati di input.

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

Salvare un modello ONNX in locale

Per salvare una versione Open Neural Network Exchange (ONNX) del modello in locale, è necessario installare il pacchetto NuGet Microsoft.ML.OnnxConverter.

Con il pacchetto OnnxConverter installato, è possibile usarlo per salvare il modello nel formato ONNX. Questo richiede un oggetto Stream, che è possibile fornire come FileStream usando il metodo File.Create. Il metodo File.Create accetta un parametro stringa che rappresenta il percorso del modello ONNX.

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

Dopo aver creato il flusso, è possibile chiamare il metodo ConvertToOnnx e assegnargli il modello sottoposto a training, i dati usati per eseguire il training del modello e il flusso. Tuttavia, non tutti i trainer e trasformatori sono esportabili in ONNX. Per un elenco completo, vedere le guide transforms e How to Choose an ML.NET Algorithm guide (Come scegliere un algoritmo ML.NET).

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

Caricare un modello archiviato in locale

I modelli archiviati in locale possono essere usati in altri processi o applicazioni come ASP.NET Core e app Web serverless. Per altre informazioni, vedere Usare ML.NET nell'API Web e Distribuire la app Web serverless ML.NET.

In un'applicazione o un processo separato, usare il metodo Load insieme al percorso del file per importare il modello addestrato nella tua applicazione.

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

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

Caricare un modello ONNX in locale

Per caricare un modello ONNX per le previsioni, installare il pacchetto NuGet Microsoft.ML.OnnxTransformer.

Con il pacchetto OnnxTransformer installato, è possibile caricare un modello ONNX esistente usando il metodo ApplyOnnxModel. Il parametro obbligatorio è una stringa che rappresenta il percorso del modello ONNX locale.

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

Il metodo ApplyOnnxModel restituisce un oggetto OnnxScoringEstimator. Prima di tutto, è necessario caricare i nuovi dati.

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

Carica i nuovi dati in un IDataView usando il metodo LoadFromEnumerable.

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

È ora possibile usare il nuovo IDataView per adattarsi ai nuovi dati.

estimator.Fit(newHousingDataView);

Dopo aver usato il metodo Fit su un estimator da ApplyOnnxModel, è possibile salvarlo come nuovo modello usando il metodo Save descritto nella sezione salvare un modello localmente.

Caricare un modello archiviato in remoto

Per caricare pipeline e modelli di preparazione dei dati archiviati in una posizione remota nella tua applicazione, utilizzare un Stream anziché un percorso di file nel metodo 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);
}

Lavorare con pipeline separate di preparazione dei dati e modelli

Nota

Il lavoro con pipeline separate per la preparazione dei dati e l'addestramento dei modelli è facoltativo. La separazione delle pipeline semplifica l'ispezione dei parametri del modello appreso. Per le stime, è più semplice salvare e caricare una singola pipeline che include le operazioni di preparazione dei dati e training del modello.

Quando si lavora con pipeline separate e modelli di preparazione dei dati, si applica lo stesso processo utilizzato per le pipeline singole. La differenza è che entrambe le pipeline devono essere salvate e caricate contemporaneamente.

Date pipeline separate per la preparazione dei dati e l'addestramento del modello.

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

Salvare la pipeline di preparazione dei dati e il modello addestrato

Per salvare sia la pipeline di preparazione dei dati che il modello sottoposto a training, usare i comandi seguenti:

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

Caricare il flusso di preparazione dei dati e il modello addestrato

In un processo o un'applicazione separata caricare la pipeline di preparazione dei dati e il modello sottoposto a training contemporaneamente come indicato di seguito:

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