Sie, ich und sogar John von nebenan wissen, dass maschinelles Lernen Ihre Maschinen „intelligenter“ gemacht hat, indem es mithilfe der ihnen zugeführten Daten zukünftige Ergebnisse vorhersagt. ML.NET ist der De-facto-Standard in .NET für maschinelles Lernen, der es Ihnen ermöglicht, Modelle im Voraus zu trainieren und genaue Vorhersagen zu treffen.
Nehmen wir an, Sie verfügen über eine ML.NET-Anwendung zur Vorhersage von Taxipreisen auf der Grundlage früherer Fahrtdaten und des aktuellen Verkehrs. Angesichts der aktuellen COVID-19-Pandemie beobachten wir einen massiven Wandel im Verbraucherverhalten: Fernreisen werden minimiert, es werden mehr Lieferungen zur Abgabe von Lebensmitteln/Lebensmitteln durchgeführt, einige Bereiche werden komplett abgeriegelt und so weiter. Die eingehenden Daten für diese Anwendung sind schnell und ändern sich ständig, sodass das Modell für maschinelles Lernen häufig neu trainiert wird. Wenn die Seite des maschinellen Lernens diese Daten liest, kann es zu Verlangsamungen kommen.
Um solche Probleme zu lösen, müssen Sie Ihre Reisedaten zwischenspeichern, damit die ML.NET-Anwendung ohne Engpässe auf die Daten zugreifen kann. ML.NET bietet Standard-Caching, das jedoch nicht skalierbar ist. NCache ist ein In-Memory, verteilter Cache in .NET. Benutzen NCache für die Datenverarbeitung erhöht die Anwendungsleistung, da es schnelle Lese-/Schreibvorgänge ermöglicht, da es sich im Arbeitsspeicher befindet. Wird verteilt, NCache kann zur Laufzeit skaliert werden, wenn die Datensätze zu groß werden.
Die richtigen NCache um Modelle für maschinelles Lernen zu skalieren und neu zu trainieren
Um darzustellen, wie NCache Um diese ML.NET-Anwendung skalierbarer zu machen und Modelle zur Laufzeit schneller neu zu trainieren, haben wir das weit verbreitete TaxiFarePrediction-Projekt von Microsoft zur Integration erweitert NCache. Dieses erweiterte Projekt finden Sie unter NCache on GitHub.
Die Anwendung funktioniert so, wie oben in dargestellt Figure 1:
- Die Taxifahrtdaten werden im Cache als gespeichert Datentyp auflisten Das ist eine Erweiterung von
IEnumerable IList
. ML.NET unterstütztLoadFromEnumerable()
Methode, sodass keine zusätzliche Manipulation der Daten erforderlich ist. - Die ML.NET-Anwendung abonniert die Pub / Sub Thema, um Aktualisierungen zu erhalten, wenn dem Cache weitere Datenblöcke der angegebenen Größe hinzugefügt werden.
- Für den anfänglichen Datensatz werden die Daten (als Liste gespeichert) von der ML.Net-Anwendung abgerufen, um das Modell für maschinelles Lernen zu trainieren. Nach dem Training wird das Modell in einem lokalen Modellspeicher gespeichert und der Modellpfad zwischengespeichert.
- Sobald ein neuer Datenblock zum Cache hinzugefügt wird, benachrichtigt Pub/Sub die Neutrainingsmodellanwendung über die Datenaktualisierung. Wenn die Anwendung neue Daten erhält, wird basierend auf dem Schiebefensterkonzept ein Teil des vorherigen Datenblocks entfernt. Dabei wird der erste Teil der bisher verwendeten Daten entsprechend der Länge des neuen Datensatzes entfernt. Diese gekürzten Daten werden mit den neuen Daten zusammengeführt und dem Cache hinzugefügt. Dieser Datenblock und das bereits trainierte Modell werden nun beim Neutraining des neuen Modells verwendet.
- Nach jedem Training/Neutraining des Modells werden Einzelwertvorhersagen für die transformierten Daten erstellt, um die Modellgenauigkeit zu testen.
NCache Details NCache GitHub-Lösung für maschinelles Lernen
Verwenden von Datenstrukturen zum Zwischenspeichern von Reisedaten
NCache bietet IEnumerable
verteilte Datenstrukturen, die es ML.NET aufgrund der Unterstützung von ML.NET sehr einfach machen, Daten direkt abzurufen und zu lesen LoadFromEnumerable()
. Die Daten können bequem in einem List-Datentyp gespeichert und zum Training direkt in das ML.NET-Modell geladen werden.
Der folgende Codeausschnitt zeigt, wie Daten mithilfe von Listendatenstrukturen im Cache gespeichert werden können.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Create lists in cache to add trip data IDistributedList initialDataList = Cache.DataTypeManager.CreateList(initialData); IDistributedList TrainingData = Cache.DataTypeManager.CreateList(datasetKey); using (StreamReader r = new StreamReader(filepath)) { while ((currentLine = r.ReadLine()) != null) { string[] incomingData = currentLine.Split(","); TaxiTrip data = new TaxiTrip(); data.TripTime = float.Parse(incomingData[0]); ... initialDataList.Add(data); TrainingData.Add(data); } } |
NCache Details NCache GitHub-Lösung für maschinelles Lernen
Abrufen von In-Memory-Daten zum Trainieren des Modells
Um das ML.NET-Modell zunächst zu trainieren, ruft die Anwendung zunächst die als gespeicherten Daten ab Datentyp auflisten für NCache. Das Modell wird basierend darauf trainiert StochasticDualCoordinateAscent (SDCA)-Regressionsalgorithmus analysiert und zur späteren Verwendung in Form einer ZIP-Datei gespeichert. Diese gespeicherten Dateien werden für die zukünftige Neuschulung von Modellen verwendet. Der Modellpfad wird auch zur späteren Verwendung zwischengespeichert.
1 2 3 4 5 6 7 8 9 10 11 |
// Get initial data for training from cache as list var datasetTraining = Cache.DataTypeManager.GetList(initialdataKey); var inputDataView = mlContext.Data.LoadFromEnumerable(datasetTraining); // ... Train Model logic here mlContext.Model.Save(trainedModel, transformedData.Schema, ModelPath); ModelTrained = true; // Save ModelPath in cache to use for retraining Cache.Add(ModelPath, ModelPath); |
Verwenden von Pub/Sub-Benachrichtigungen zur Datenaktualisierung, um das Modell neu zu trainieren
Die richtigen NCache Pub / Subwerden Ereignisse für die Anwendung ausgelöst, um Daten neu zu trainieren, wenn mehr Daten im Cache aktualisiert werden. Die ML.NET-Anwendung abonniert die NCache Thema für Benachrichtigungen über die aktualisierten Daten. Wenn Daten im Cache aktualisiert werden, NCache Pub/Sub benachrichtigt die Anwendung, dass Daten aktualisiert wurden und die Daten neu trainiert werden.
1 2 3 4 5 6 7 8 9 10 11 12 |
Cache = CacheManager.GetCache("myPartitionedCache"); // Create topic so ML.NET app subscribes for data update notifications Topic = Cache.MessagingService.CreateTopic("TaxiFareNotifications"); Topic.CreateSubscription(TaxiFareDataUpdated); ... // Retrain model when new data is updated static void TaxiFareDataUpdated(object sender, MessageEventArgs args) { RetrainModel(new MLContext(seed: 0)); } |
Gleitende Daten mit Listen für das Umschulungsmodell
Sobald dem Cache neue Daten hinzugefügt werden, werden die Trainingsdaten mithilfe des Schiebefensterkonzepts gefüllt, um die neuesten Daten abzurufen. Dadurch bleibt ein Teil der vorherigen Daten zusammen mit den neuen Daten in der Liste. Sobald die Daten aktualisiert sind, wird eine Nachricht an die Abonnenten veröffentlicht NCache Pub / Sub Mechanismus, damit eine Umschulung stattfinden kann. Das Modell und die Pipeline werden aus den ZIP-Dateien geladen und gemäß dem ML.NET-Umschulungsalgorithmus neu trainiert.
Schritt 1: Schieben Sie die Daten und benachrichtigen Sie sie über Pub/Sub
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
TaxiTrip data = new TaxiTrip(); ... dataList.Add(data); if(dataList.Count > 100) { // Move sliding window if (TrainingData.Count > dataList.Count) TrainingData.RemoveRange(0, dataList.Count); TrainingData.AddRange(dataList); // Publish message for notifying data update Topic.Publish(new Message("DataSet has been updated."), DeliveryOption.All); } |
Schritt 2: Reisedaten aus dem Cache laden und Modell neu trainieren
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
//Load new data from List in Cache IDataView newData = mlContext.Data.LoadFromEnumerable(TrainingData); IDataView transformedNewData = dataPrepPipeline.Transform(newData); // Retrain model RegressionPredictionTransformer retrainedModel = mlContext.Regression.Trainers.OnlineGradientDescent() .Fit(transformedNewData, originalModelParameters); LinearRegressionModelParameters retrainedModelParameters = retrainedModel.Model as LinearRegressionModelParameters; IEstimator dataPrepEstimator = mlContext.Transforms.Concatenate("Features", new string[] { "PassengerCount", "TripTime", "TripDistance", "FareAmount" }) .Append(mlContext.Transforms.NormalizeMinMax("Features")); ... mlContext.Model.Save(retrainedModel, transformedNewData.Schema, ModelPath); |
NCache Details NCache GitHub-Lösung für maschinelles Lernen
Etwas zusammenfassen…
Wenn Daten für maschinelles Lernen verarbeitet werden, werden sie normalerweise asynchron geladen, sodass die Trainingsmodelle Daten von der Festplatte laden und ihre Algorithmen mehrmals darauf ausführen. Daher werden Datensätze im Speicher mit zwischengespeichert NCache Reduziert das unnötige Laden von Daten von der Festplatte und erleichtert die Benachrichtigung von ML.NET-Anwendungen, damit sie über den Pub/Sub-Mechanismus sofort mit der Umschulung beginnen können. Da es verteilt ist, skaliert es außerdem zur Laufzeit, wenn die Datensätze zu groß werden. Gehen Sie also zur Kasse NCache und wie es die Leistung Ihrer Machine-Learning-Anwendung verbessern kann!