Tu, io e anche John della porta accanto sappiamo che l'apprendimento automatico ha reso le tue macchine "più intelligenti" prevedendo risultati futuri, utilizzando i dati forniti loro. ML.NET è lo standard de facto in .NET per l'apprendimento automatico, che consente di addestrare i modelli in anticipo e fare previsioni accurate.
Supponiamo di avere un'applicazione ML.NET per prevedere le tariffe dei taxi, in base ai dati sui viaggi precedenti e al traffico attuale. Data l'attuale pandemia di COVID-19, abbiamo assistito a un enorme cambiamento nel comportamento dei consumatori: i viaggi a lunga distanza sono ridotti al minimo, vengono effettuate più consegne per consegnare cibo/generi alimentari, alcune aree sono completamente transennate e così via. I dati in entrata per questa applicazione sono rapidi e cambiano continuamente, quindi il modello di apprendimento automatico viene riqualificato frequentemente. Se il lato Machine Learning legge questi dati, può causare rallentamenti.
Per affrontare tali problemi, è necessario memorizzare nella cache i dati di viaggio in modo che i dati siano accessibili all'applicazione ML.NET senza colli di bottiglia. ML.NET fornisce la memorizzazione nella cache predefinita, ma non è scalabile. NCache offre cache distribuita in memoria in .NET. Usando NCache per l'elaborazione dei dati aumenta le prestazioni dell'applicazione in quanto fornisce operazioni di lettura/scrittura rapide poiché è in memoria. Essendo distribuito, NCache può essere ridimensionato in runtime se i set di dati diventano troppo grandi.
utilizzando NCache per scalare e riqualificare i modelli di machine learning
Per descrivere come NCache può rendere questa applicazione ML.NET più scalabile e riqualificare i modelli più velocemente in runtime, abbiamo esteso il progetto TaxiFarePrediction ampiamente utilizzato da Microsoft per integrarlo NCache. Puoi trovare questo progetto esteso con NCache on GitHub.
L'applicazione funziona in questo modo, come illustrato sopra in Figure 1 :
- I dati del viaggio in taxi vengono memorizzati nella cache come a Elenca il tipo di dati che è un'estensione di
IEnumerable IList
. Supporta ML.NETLoadFromEnumerable()
metodo, quindi non è necessaria alcuna manipolazione aggiuntiva dei dati. - L'applicazione ML.NET si iscrive al Pub / Sub topic per ricevere aggiornamenti quando vengono aggiunti alla cache più blocchi di dati della dimensione specificata.
- Per il set di dati iniziale, i dati (memorizzati come elenco) vengono recuperati dall'applicazione ML.Net per addestrare il modello di apprendimento automatico. Dopo l'addestramento, il modello viene archiviato in un archivio modelli locale e memorizza nella cache il percorso del modello.
- Dopo aver aggiunto un nuovo blocco di dati alla cache, Pub/Sub notifica l'aggiornamento dei dati all'applicazione del modello di riqualificazione. Quando l'applicazione ottiene nuovi dati, una parte del blocco di dati precedente viene rimossa, in base al concetto di finestra scorrevole. In questo, la prima parte dei dati precedentemente utilizzati viene rimossa in base alla lunghezza del nuovo set di dati. Questi dati tagliati vengono uniti ai nuovi dati e aggiunti alla cache. Ora, questo blocco di dati e il modello già addestrato verranno utilizzati durante la riqualificazione del nuovo modello.
- Dopo ogni training/retraining del modello, vengono effettuate previsioni di valore singolo sui dati trasformati per testare l'accuratezza del modello.
NCache Dettagli NCache Soluzione GitHub di apprendimento automatico
Utilizzo delle strutture dati per memorizzare nella cache i dati di viaggio
NCache offre il IEnumerable
strutture dati distribuite, che rendono molto semplice per ML.NET recuperare e leggere direttamente i dati grazie al supporto di ML.NET per LoadFromEnumerable()
. I dati possono essere comodamente archiviati in un tipo di dati List e caricati direttamente nel modello ML.NET per l'addestramento.
Il frammento di codice seguente mostra come i dati possono essere archiviati nella cache usando le strutture di dati List.
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 Dettagli NCache Soluzione GitHub di apprendimento automatico
Recupero dei dati in memoria per addestrare il modello
Per addestrare inizialmente il modello ML.NET, l'applicazione recupera prima i dati archiviati come file a Elenca il tipo di dati da NCache. Il modello viene addestrato in base a StocasticoDualCoordinateAscent (SDCA) algoritmo di regressione e salvato sotto forma di file .zip per un uso successivo. Questi file salvati vengono utilizzati per riqualificare i modelli in futuro. Anche il percorso del modello viene memorizzato nella cache per essere utilizzato in seguito.
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); |
Utilizzo delle notifiche Pub/Sub sull'aggiornamento dei dati per riqualificare il modello
utilizzando NCache'S Pub / Sub, gli eventi vengono attivati nell'applicazione per riqualificare i dati man mano che vengono aggiornati più dati nella cache. L'applicazione ML.NET si iscrive al NCache argomento per le notifiche sull'aggiornamento dei dati. Se i dati vengono aggiornati nella cache, NCache Pub/Sub notifica all'applicazione che i dati sono stati aggiornati e che i dati sono stati riqualificati.
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)); } |
Dati scorrevoli con elenchi per il modello di riqualificazione
Una volta aggiunti nuovi dati alla cache, i dati di addestramento vengono popolati utilizzando il concetto di finestra scorrevole per recuperare i dati più recenti. Ciò mantiene una parte dei dati precedenti nell'elenco insieme ai nuovi dati. Una volta aggiornati i dati, viene pubblicato un messaggio per gli abbonati che utilizzano NCache'S Pub / Sub meccanismo per consentire la riqualificazione. Il modello e la pipeline vengono caricati dai file .zip e riqualificati in base all'algoritmo di riqualificazione ML.NET.
Passaggio 1: far scorrere i dati e notificare tramite 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); } |
Passaggio 2: carica i dati di viaggio dalla cache e retrain il modello
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 Dettagli NCache Soluzione GitHub di apprendimento automatico
Riassumendo…
Di solito, quando i dati vengono elaborati per l'apprendimento automatico, vengono caricati in modo asincrono in modo che i modelli di addestramento carichino i dati dal disco ed eseguano i loro algoritmi più volte su di esso. Quindi, memorizzare nella cache i set di dati in memoria con NCache aiuta a ridurre il caricamento non necessario dei dati dal disco e rende più semplice notificare alle applicazioni ML.NET l'avvio immediato della riqualificazione tramite il meccanismo Pub/Sub. Inoltre, essendo distribuito, si ridimensiona in runtime se i set di dati diventano troppo grandi. Quindi, vai alla cassa NCache e come può migliorare le prestazioni delle tue applicazioni di machine learning!