Você, eu e até o vizinho John sabemos que o aprendizado de máquina tornou suas máquinas “mais inteligentes” ao prever resultados futuros, usando os dados fornecidos a elas. ML.NET é o padrão de fato em .NET para aprendizado de máquina, que permite treinar modelos antecipadamente e fazer previsões com precisão.
Vamos supor que você tenha um aplicativo ML.NET para prever tarifas de táxi, com base em dados de viagens anteriores e tráfego atual. Dada a atual pandemia do COVID-19, vimos uma grande mudança no comportamento do consumidor: as viagens de longa distância são minimizadas, mais entregas estão sendo feitas para deixar alimentos / mantimentos, algumas áreas são completamente isoladas e assim por diante. Os dados de entrada para este aplicativo são rápidos e mudam continuamente, de modo que o modelo de aprendizado de máquina é retreinado com frequência. Se o lado do Machine Learning ler esses dados, isso poderá causar lentidão.
Para resolver esses problemas, você precisa armazenar em cache seus dados de viagem para que os dados possam ser acessados pelo aplicativo ML.NET sem gargalos. O ML.NET fornece cache padrão, mas isso não é escalável. NCache é um cache distribuído na memória na rede. Usando NCache para processamento de dados aumenta o desempenho do aplicativo, pois fornece operações de leitura/gravação rápidas, pois está na memória. Sendo distribuído, NCache pode ser dimensionado em tempo de execução se os conjuntos de dados se tornarem muito grandes.
utilização NCache para dimensionar e retreinar modelos de aprendizado de máquina
Para retratar como NCache pode tornar esse aplicativo ML.NET mais escalável e treinar modelos mais rapidamente em tempo de execução, estendemos o projeto TaxiFarePrediction amplamente utilizado pela Microsoft para integrar NCache. Você pode encontrar este projeto estendido com NCache on GitHub.
O aplicativo funciona assim, conforme ilustrado acima em Figura 1:
- Os dados da viagem de táxi são armazenados no cache como Tipo de dados da lista que é uma extensão de
IEnumerable IList
. ML.NET suportaLoadFromEnumerable()
método, portanto, nenhuma manipulação extra dos dados é necessária. - O aplicativo ML.NET se inscreve no Pub / Sub tópico para receber atualizações quando mais blocos de dados do tamanho especificado forem adicionados ao cache.
- Para o conjunto de dados inicial, os dados (armazenados como uma lista) são buscados pelo aplicativo ML.Net para treinar o modelo de aprendizado de máquina. Após o treinamento, o modelo é armazenado em um armazenamento de modelo local e armazena em cache o caminho do modelo.
- Depois que um novo bloco de dados é adicionado ao cache, o Pub/Sub notifica o aplicativo de modelo de retreinamento sobre a atualização dos dados. Quando o aplicativo obtém novos dados, uma parte do bloco de dados anterior é removida, com base no conceito de janela deslizante. Neste, a primeira parte dos dados usados anteriormente é removida de acordo com o comprimento do novo conjunto de dados. Esses dados aparados são mesclados com os novos dados e adicionados ao cache. Agora, esse pedaço de dados e o modelo já treinado serão usados durante o retreinamento do novo modelo.
- Após cada treinamento/retreinamento do modelo, são feitas previsões de valor único nos dados transformados para testar a precisão do modelo.
NCache Adicionar ao carrinho NCache Solução GitHub de aprendizado de máquina
Usando estruturas de dados para armazenar dados de viagem em cache
NCache ofertas IEnumerable
estruturas de dados distribuídas, que tornam muito simples para o ML.NET buscar e ler dados diretamente devido ao suporte do ML.NET para LoadFromEnumerable()
. Os dados podem ser convenientemente armazenados em um tipo de dados List e carregados diretamente no modelo ML.NET para treinamento.
O trecho de código a seguir mostra como os dados podem ser armazenados no cache usando estruturas de dados 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 Adicionar ao carrinho NCache Solução GitHub de aprendizado de máquina
Buscando dados na memória para treinar o modelo
Para treinar inicialmente o modelo ML.NET, o aplicativo primeiro busca os dados armazenados como um Tipo de dados da lista da NCache. O modelo é treinado com base em EstocásticoDualCoordenadaAscensão (SDCA) algoritmo de regressão e salvo na forma de um arquivo .zip para uso posterior. Esses arquivos salvos são usados para retreinar modelos no futuro. O caminho do modelo também é armazenado em cache para ser usado posteriormente.
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); |
Como usar notificações do Pub/Sub na atualização de dados para treinar novamente o modelo
utilização NCache'S Pub / Sub, os eventos são acionados para o aplicativo para treinar novamente os dados à medida que mais dados são atualizados no cache. O aplicativo ML.NET se inscreve no NCache tópico para notificações sobre os dados que estão sendo atualizados. Se os dados forem atualizados no cache, NCache O Pub/Sub notifica o aplicativo de que os dados foram atualizados e os dados são treinados novamente.
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)); } |
Deslizando dados com listas para modelo de retreinamento
Depois que novos dados são adicionados ao cache, os dados de treinamento são preenchidos usando o conceito de janela deslizante para buscar os dados mais recentes. Isso mantém um pedaço dos dados anteriores na lista junto com os novos dados. Uma vez que os dados são atualizados, uma mensagem é publicada para os assinantes usando NCache'S Pub / Sub mecanismo para que a reciclagem possa ocorrer. O modelo e o pipeline são carregados dos arquivos .zip e retreinados de acordo com o algoritmo de retreinamento ML.NET.
Etapa 1: dados do slide e notificação via 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); } |
Etapa 2: carregar dados de viagem do modelo de cache e retreinar
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 Adicionar ao carrinho NCache Solução GitHub de aprendizado de máquina
Resumindo…
Normalmente, quando os dados são processados para aprendizado de máquina, eles são carregados de forma assíncrona para que os modelos de treinamento carreguem os dados do disco e executem seus algoritmos várias vezes nele. Portanto, armazenar em cache conjuntos de dados na memória com NCache ajuda a reduzir o carregamento desnecessário de dados do disco e facilita a notificação de aplicativos ML.NET para iniciar o retreinamento instantaneamente por meio do mecanismo Pub/Sub. Além disso, sendo distribuído, ele é dimensionado em tempo de execução se os conjuntos de dados ficarem muito grandes. Então, vá para o checkout NCache e como ele pode melhorar o desempenho do seu aplicativo de aprendizado de máquina!
NCache Adicionar ao carrinho Baixar NCache Comparação de edições