Salvare e caricare i modelli con training

Articolo
05/10/2023

Di seguito viene descritto come salvare e caricare i modelli con training nell'applicazione.

Durante il processo di creazione del modello, un modello si trova in memoria ed è accessibile per l'intero ciclo di vita dell'applicazione. Tuttavia, quando l'esecuzione dell'applicazione viene arrestata, se il modello non viene salvato in una posizione locale o remota, il modello non sarà più accessibile. I modelli vengono in genere usati dopo il training in altre applicazioni per inferenza o per ripetere il training. Per questa ragione, è importante archiviare il modello. Salvare e caricare i modelli usando le procedure descritte nelle sezioni successive di questo documento quando si usano pipeline di preparazione dei dati e training dei modelli simili a quella illustrata di seguito. Anche se in questo esempio viene usato un modello di regressione lineare, lo stesso processo è valido per 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 ereditano dallo stesso set di classi, le firme del metodo di salvataggio e caricamento per questi componenti sono le stesse. A seconda del caso d'uso, è possibile riunire la pipeline di preparazione dei dati e il modello in un unico EstimatorChain che genererà un singolo ITransformer o separarli creando un'interfaccia ITransformer distinta per ognuno dei due elementi.

Salvare un modello in locale

Quando si salva un modello sono necessari due elementi:

L'interfaccia ITransformer del modello.
La classe DataViewSchema dell'input previsto di ITransformer.

Dopo aver eseguito il training del modello, usare il metodo Save per salvare il modello con training in un file denominato model.zip usando 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 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. Ciò richiede un oggetto Stream che è possibile fornire come FileStream utilizzando il metodo File.Create. Il metodo File.Create accetta una stringa come parametro che sarà il percorso del modello ONNX.

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

Una volta 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 gli algoritmi di training e i trasformatori sono esportabili in ONNX. Per un elenco completo, visitare le guide Trasformazioni e 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 Serverless Web Applications. Per altre informazioni, vedere gli articoli su come usare ML.NET nell'API Web e distribuire l'app Web serverless ML.NET.

In un'applicazione o processo separato usare il metodo Load con il percorso di file per ottenere il modello con training nell'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 in un modello ONNX per le stime, è necessario 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
    }
};

Con i nuovi dati è possibile caricarli in un oggetto IDataView usando il metodo LoadFromEnumerable.

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

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

estimator.Fit(newHousingDataView);

Dopo aver usato il metodo Fit su un oggetto stima da ApplyOnnxModel, è possibile salvarlo come nuovo modello usando il metodo Salva indicato nella sezione salva un modello in locale.

Caricare un modello archiviato in remoto

Per caricare le pipeline di preparazione dei dati e i modelli archiviati in una posizione remota all'interno dell'applicazione, usare una classe 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);
}

Usare pipeline di preparazione dei dati e di modello separate

Nota

L'uso di pipeline di preparazione dei dati e di training del modello separate è facoltativo. La separazione delle pipeline rende più semplice esaminare i parametri di modello appresi. Per le previsioni, risulta più semplice salvare e caricare una singola pipeline che include le operazioni di preparazione dei dati e di training del modello.

Quando si usano pipeline di preparazione dei dati e modelli separati, viene applicato lo stesso processo delle pipeline singole, a meno che entrambe le pipeline non debbano essere salvate e caricate contemporaneamente.

Dopo aver specificato pipeline di preparazione dei dati e di training del modello separate:

// 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 con training

Per salvare la pipeline di preparazione dei dati e il modello con 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 la pipeline di preparazione dei dati e il modello con training

In un processo o un'applicazione separata, caricare la pipeline di preparazione dei dati e il modello con training contemporaneamente come illustrato 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);