Speichern und Laden trainierter Modelle

Artikel
05/10/2023

Erfahren Sie, wie Sie trainierte Modelle in Ihre Anwendung laden und dort speichern.

Im gesamten Modellerstellungsprozess liegt ein Modell im Arbeitsspeicher vor, auf das während des gesamten Lebenszyklus der Anwendung zugegriffen werden kann. Doch sobald die Ausführung der Anwendung beendet wird, kann auf das Modell nicht mehr zugegriffen werden, wenn es nicht lokal oder remote gespeichert wird. Modelle werden in der Regel ab einem bestimmten Punkt nach dem Training entweder für Rückschlüsse oder erneutes Training in anderen Anwendungen verwendet. Aus diesem Grund ist es wichtig, das Modell zu speichern. Speichern und laden Sie Modelle mithilfe der in den nachfolgenden Abschnitten dieses Dokuments beschriebenen Schritte, wenn Sie Datenvorbereitungs- und Modelltrainingpipelines wie die nachfolgend beschriebenen verwenden. Obwohl in diesem Beispiel ein lineares Regressionsmodell verwendet wird, gilt der gleiche Prozess für andere ML.NET-Algorithmen.

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

Da die meisten Modelle und Datenvorbereitungspipelines von demselben Klassensatz erben, sind die Speicher- und Lademethodensignaturen für diese Komponenten identisch. Abhängig von Ihrem Anwendungsfall können Sie entweder Datenvorbereitungspipeline und Modell in einer einzelnen EstimatorChain kombinieren, sodass ein einzelner ITransformer ausgeben würde, oder sie trennen und für beide jeweils einen separaten ITransformer erstellen.

Lokales Speichern eines Modells

Beim Speichern eines Modells benötigen Sie zwei Dinge:

Den ITransformer des Modells.
Das DataViewSchema der erwarteten Eingabe des ITransformer.

Speichern Sie nach dem Training des Modells das trainierte Modell mit der Save-Methode in einer Datei namens model.zip unter Verwendung des DataViewSchema der Eingabedaten.

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

Lokales Speichern eines ONNX-Modells

Um eine ONNX-Version Ihres Modells lokal zu speichern, muss das NuGet-Paket Microsoft.ML.OnnxConverter installiert sein.

Wenn das Paket OnnxConverter installiert ist, können wir damit unser Modell im ONNX-Format speichern. Dazu ist ein Stream-Objekt erforderlich, das wir mit der File.Create-Methode als FileStream bereitstellen können. Die Methode File.Create akzeptiert eine Zeichenfolge als Parameter, die den Pfad des ONNX-Modells angibt.

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

Nachdem der Stream erstellt wurde, können wir die Methode ConvertToOnnx aufrufen und an diese das trainierte Modell, die zum Trainieren des Modells verwendeten Daten und den Stream übergeben. Allerdings können nicht alle Trainer und Transformer nach ONNX exportiert werden. Eine vollständige Liste finden Sie in den Leitfäden Transformationen und Auswählen eines ML.NET-Algorithmus.

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

Laden eines lokal gespeicherten Modells

Lokal gespeicherte Modelle können in anderen Prozessen oder Anwendungen wie ASP.NET Core und Serverless Web Applications verwendet werden. Unter Vorgehensweise: Bereitstellen eines Machine Learning-Modells über die ASP.NET Core-Web-API und Vorgehensweise: Verwenden des ML.NET-Modells in Azure Functions finden Sie nähere Anleitungen.

Verwenden Sie in separaten Anwendungen oder Prozessen die Load-Methode zusammen mit den Dateipfad, um das trainierte Modell in Ihre Anwendung zu laden.

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

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

Lokales Laden eines ONNX-Modells

Um ein ONNX-Modell für Vorhersagen zu laden, benötigen Sie das NuGet-Paket Microsoft.ML.OnnxTransformer.

Wenn das Paket OnnxTransformer installiert ist, können Sie ein bestehendes ONNX-Modell mithilfe der Methode ApplyOnnxModel laden. Der erforderliche Parameter ist eine Zeichenfolge, die den Pfad des lokalen ONNX-Modells darstellt.

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

Die ApplyOnnxModel-Methode gibt ein OnnxScoringEstimator-Objekt zurück. Zunächst müssen wir die neuen Daten laden.

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

Mit den neuen Daten ist ein Ladevorgang in IDataView mit der Methode LoadFromEnumerable möglich.

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

Jetzt können wir die neue IDataView verwenden, um sie an die neuen Daten anzupassen.

estimator.Fit(newHousingDataView);

Nachdem Sie die Fit-Methode für einen Schätzer aus ApplyOnnxModel ausgeführt haben, können Sie das neue Modell mithilfe der Save-Methode speichern, die im Abschnitt zum lokalen Speichern eines Modells erwähnt wird.

Laden eines remote gespeicherten Modells

Um Datenvorbereitungspipelines und an einem Remotespeicherort gespeicherte Modelle in Ihre Anwendung zu laden, verwenden Sie einen Stream anstatt eines Dateipfads in der Load-Methode.

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

Arbeiten mit separaten Datenvorbereitungs- und Modellpipelines

Hinweis

Arbeiten mit separaten Datenvorbereitungs- und Modelltrainingspipelines ist optional. Die Trennung von Pipelines erleichtert die Überprüfung der gelernten Modellparameter. Für Vorhersagen ist es einfacher, eine einzelne Pipeline zu speichern und zu laden, die die Datenvorbereitungs- und Modelltrainingsvorgänge enthält.

Bei der Arbeit mit separaten Datenvorbereitungspipelines und Modellen wird derselbe Prozess wie bei einzelnen Pipelines durchgeführt, mit dem Unterschied, dass nun beide Pipelines gleichzeitig gespeichert und geladen werden müssen.

Bei separaten Datenvorbereitungs- und Modelltrainingspipelines:

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

Speichern von Datenvorbereitungspipeline und trainiertem Modell

Um Datenvorbereitungspipeline und trainiertes Modell zu speichern, verwenden Sie die folgenden Befehle:

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

Laden von Datenvorbereitungspipeline und trainiertem Modell

Laden Sie in einem separaten Prozess oder einer separaten Anwendung die Datenvorbereitungspipeline und das trainierte Modell gleichzeitig wie folgt:

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