BT

Disseminando conhecimento e inovação em desenvolvimento de software corporativo.

Contribuir

Tópicos

Escolha a região

Início Artigos COVID-19 e Mineração de Redes Sociais - Habilitando Cargas de Trabalho de Aprendizado de Máquina com Big Data

COVID-19 e Mineração de Redes Sociais - Habilitando Cargas de Trabalho de Aprendizado de Máquina com Big Data

Favoritos

Pontos Principais

  • A arquitetura de pipeline de dados inclui cinco camadas: 1) ingerir dados, 2) coletar, analisar, e processar dados, 3) enriquecer os dados, 4) treinar e avaliar modelos de aprendizado de máquina, e 5) implantar em produção.
  • Use métodos de pré-processamento de dados e modelos de aprendizado de máquina para categorizar, agrupar, e filtrar, e posteriormente servir os modelos e fornecer acesso a eles.

  • A análise preditiva usa técnicas de aprendizado de máquina, como mineração de dados e modelagem preditiva, para analisar fatos atuais e históricos e fazer previsões sobre eventos futuros ou desconhecidos.

  • A solução de código aberto Apache Spark, que tem uma API integrada para processamento em lote, processamento de stream, treinamento de aprendizado de máquina, e uso de modelos de aprendizado de máquina em escala.

  • Aprenda a usar Spark MLlib com Pyspark usando MLFlow na plataforma Azure Databricks.

O COVID-19 mudou nossas vidas, ainda não entendemos as implicações, mas sabemos que o mundo nunca mais será o mesmo. Estamos entrando em um novo mundo, um mundo desconhecido. Nosso processo de tomada de decisão virou de cabeça para baixo e todos estão desacelerando suas operações e criando ajustes mais focados.

Esse "novo normal" elevou a discussão online um ponto mais alto nos Estados Unidos, à medida que mais pessoas estão usando a internet para expressar seus pensamentos, dúvidas, e preocupações. As pessoas hoje estão usando canais de mídia social como Reddit, Facebook, Twitter, Instagram, e muito mais

As redes sociais se dividem aproximadamente em seis grupos:

  1. Plataformas de microblogging, como Twitter e Reddit.
  2. Plataformas de blogging, como Medium e Dev.to.
  3. Aplicativos de mensagens instantâneas (WhatsApp e Telegram).
  4. Plataformas de redes sociais como Facebook e LinkedIn.
  5. Plataformas de colaboração de software, como GitHub.
  6. Plataformas de compartilhamento de fotos / vídeos, como Instagram e YouTube.

Muitos pesquisadores estão trabalhando neste campo, analisando e sugerindo novos algoritmos baseados em estatísticas para responder às perguntas mais urgentes.

Neste artigo, discutirei como habilitar cargas de trabalho de aprendizado de máquina (ML) com big data em um ambiente de produção para consultar e analisar Tweets sobre COVID-19 para entender o sentimento social em relação ao COVID-19.

Motivação e Inspiração

O artigo Towards detecting influenza epidemics by analyzing Twitter messages, de Aron Culotta, publicados no SOMA '10, e também parte da conferência KDD em 2010, discutiu como uma resposta rápida a epidemias de saúde é crucial para salvar vidas. Em seu artigo, eles processaram 500.000 mensagens durante 10 semanas. Isso foi em 2010, hoje estamos discutindo a escala de dezenas de milhões de tweets por dia. A escala é alta e o Twitter até criou uma Stream API para consultar e analisar tweets.

Outro trabalho de pesquisa é o Surveillance Sans Frontières: Internet-Based Emerging Infectious Disease Intelligence and the HealthMap Project, publicado no jornal de pesquisa Plos Medicine, por John S. Brownstein e equipe em 2008. O sistema de pesquisa que eles publicaram ainda é relevante nos dias de hoje, para a pandemia do COVID19.

Aqui está um diagrama de alto nível dos objetivos do sistema, de uma perspectiva da pesquisa:

Figura 1. Diagrama de alto nível de John S. Brownstein e equipe, sistema e projeto de pesquisa publicado em 2008.

Em sua abordagem, em 2008, eles se referiram a adquirir os dados, categorizá-los, agrupá-los, e filtrá-los em cinco categorias:

  1. Notícias de Última Hora
  2. Atenção
  3. Notícias antigas
  4. Contexto
  5. Não relacionado a doenças

No nosso caso, queremos criar um sistema para analisar os dados do Twitter, mas não se limita apenas ao Twitter, uma vez que projetamos a arquitetura, podemos alavancar e criar um pipeline de dados para outras mídias sociais.

Vamos pensar sobre qual será a arquitetura de software ideal para potencializar essa abordagem.

Ela precisa oferecer suporte a novos fluxos de dados de novos recursos de dados (aquisição) e analisá-los em escala (os dados de mídia social hoje em dia estão explodindo). Use métodos de pré-processamento de dados e modelos de aprendizado de máquina para categorizar, agrupar, e filtrar, e posteriormente disponibilizar os modelos e fornecer acesso a eles.

Vamos simplificar e focar no Twitter como um exemplo de fluxo de entrada. Em nosso cenário, estamos interessados não apenas em analisar o passado, mas também em prever o futuro! Essa abordagem é chamada de Análise Preditiva.

A análise preditiva usa técnicas de aprendizado de máquina, como mineração de dados e modelagem preditiva, para analisar fatos atuais e históricos e fazer previsões sobre eventos futuros ou desconhecidos. Como casos de uso de análise preditiva baseada em ML, vamos prever se um tweet será retuitado com base em hashtags, sentimento, e localização.

Vamos dividir a arquitetura nas seguintes camadas, e ver como nossos dados se comportam numa abordagem Data Lake para cada camada:

  • Ingerir os dados.
  • Coletar, analisar, e processar os dados.
  • Enriquecer os dados - no caso de adicionarmos análise de sentimento com base no texto do tweet.
  • Treinar e avaliar modelos de aprendizado de máquina.
  • Implantar em produção.

Acesse o projeto no GitHub para obter mais detalhes sobre a aplicação discutida neste artigo. O repositório contém código, notas, e arquivos YAML para implantação.

Camadas de software para sistema baseado em aprendizado de máquina

Ingestão de Dados

Esta é a camada que consulta o Twitter usando a API de desenvolvedor do Twitter para extrair dados e inserir os dados em nosso sistema. Uma solução comum para construir isso é usar um cliente Kafka. Para saber mais sobre como trabalhar com Kafka, clique aqui. Essa camada também é responsável por filtrar os dados que não podemos armazenar, dependendo da privacidade, requisitos governamentais e assim por diante. Em nosso Data Lake, esses dados estão sendo espelhados e salvos para armazenamento, no diretório RAW para necessidades futuras.

Coleta, Análise, e Processo

Esta camada tem várias responsabilidades:

  • Consumir os dados de nossa parte de ingestão de dados, processá-los, e salvá-los no armazenamento.
  • Fornecer os dados em tempo real, ou quase real, para um modelo de aprendizado de máquina calcular previsões em tempo real, agrupamento, e categorização.
  • Limpar e preparar os dados para treinar novos modelos de aprendizado de máquina dividindo-os em conjuntos de dados e mesclando dados históricos com novos.

Para conseguir isso, podemos usar soluções open source, como Apache Spark, que tem API integrada para processamento em lote, processamento de fluxo, treinamento de ML, e uso de modelos de aprendizado de máquina em escala.

Uma de nossas opções para trabalhar com o Apache Spark na nuvem pública é usar o Databricks, que é uma solução gerenciada e otimizada para executar o Apache Spark.

Para dados offline e análises futuras, e construção de modelo de aprendizado de máquina, salvamos os dados no diretório CURATED ou PROCESSED.

Às vezes, mesclaremos os dados com outras fontes de dados e enriqueceremos os dados existentes. Esses dados geralmente serão salvos no diretório REFINED. Clique aqui para baixar o código de exemplo. No exemplo, enriquecemos os dados usando Análise de Texto e Análise de Sentimento dos Serviços Cognitivos do Azure, isso nos permitiu adicionar uma nova coluna para pontuação de sentimento positivo com base na coluna de texto dos dados fornecidos, que representa o tweet que o usuário escreveu.

Treino e avaliação dos modelos de ML

Essa é a camada principal com a qual nossa equipe interagiu. Depois de coletar, analisar, e processar os dados e disponibilizá-los para ML, nossa equipe pode acessá-los para exploração de dados e experimentos de ML.

Nossa equipe pode trabalhar com várias ferramentas para construir seus experimentos. Eles podem alavancar o Apache Spark ML para construir modelos de aprendizado de máquina de maneira distribuída. Ou, se os dados couberem na memória e não precisarem de uma estrutura de computação distribuída, como Apache Spark, eles podem aproveitar a construção de modelos de aprendizado de máquina (ML) com menos poder de computação e usar o scikit-learn SDK para construir modelos de ML. A Scikit-learn é uma biblioteca de aprendizado de máquina open source para a linguagem de programação Python. Ela disponibiliza vários algoritmos e ferramentas de ML para análise preditiva de dados e muito mais.

Vamos dar uma olhada em um exemplo de Spark MLlib com Pyspark em como executar um experimento de ML, usando MLFlow no Azure Databricks para rastrear as métricas do experimento. O MLFlow com Databricks nos permite criar experimentos fora-da-caixa para aproveitar a UI do Databricks.

Neste cenário, tente prever se um tweet será retuitado com base no sentimento positivo e negativo, hashtags usadas, contagem de seguidores do usuário, contagem de amigos do usuário, e favoritos do usuário.

Para isso, usamos Spark mllib com Pipeline para orquestrar o fluxo de ML. Fornecemos a classe de pipeline com os vários estágios e, posteriormente, rodamos o método fit para iniciar os estágios de construção do modelo, e o método transform para executar o modelo em novos dados e obter previsões.

Neste trecho de código, você pode ver como usamos a pipeline para treinar o DecisionTreeClassifier, construir o próprio modelo de aprendizado de máquina, e registrá-lo com MLFlow para acesso futuro.

from pyspark.ml.classification import DecisionTreeClassifier, DecisionTreeClassificationModel
from pyspark.ml.feature import StringIndexer
from pysp
ark.ml import Pipeline
from pyspark.mllib.linalg import Vectors
from pyspark.ml.feature import VectorAssembler
from pyspark.ml.feature import Normalizer


#start mlflow model for tracking the experiment
with mlflow.start_run():
   #create experiment name
   mlflow.create_experiment("/retweets-sentiment-based-decision-tree")
   mlflow.spark.autolog
   # Read input columns location and hashtags - and annotate them as categorical values
   indexLocation = StringIndexer(inputCol="user_location",outputCol="indexedLocations").setHandleInvalid("keep")
   indexHashtages = StringIndexer(inputCol="hashtags",outputCol="indexedhashtags").setHandleInvalid("keep")


   # assemble multiple columns into one feature column, we often use this with many Spark mllib out of the box machine learning models
   assembler = VectorAssembler(inputCols=[ "indexedLocations","indexedhashtags","user_followers", "user_friends","user_favourites","positive_sentiment","negative_sentiment","user_verified"], outputCol="features")


   # StringIndexer: Read input column "is_retweet" (true/false) and annotate them as categorical values.
   indexLabel = StringIndexer(inputCol="is_retweet", outputCol="indexedRetweetLabel").setHandleInvalid("keep")


   # most often with decision tree we would want to normalize the data to make it fit into the bins:
   normalizer = Normalizer(inputCol="features", outputCol="normFeatures", p=1.0)


   # DecisionTreeClassifier: Learn to predict column "indexedRetweetLabel" using the "normFeatures" column.
   dtc = DecisionTreeClassifier(labelCol="indexedRetweetLabel",featuresCol="normFeatures")


   # Chain indexer + dtc together into a single ML Pipeline.
   pipeline = Pipeline(stages=[indexLocation,indexHashtages,assembler,indexLabel,normalizer, dtc])


   # train the model
   model = pipeline.fit(tweets)
   # use the model - only for demo, for other cases we will use multiple datasets for testing and training
   prediction = model.transform(tweets)
  
   #path to persiste the model to
   model_path = "/mnt/root/COVID19_TWEETS/ML-Models/V1"
   # register the model with ml flow as well
   mlflow.register_model("retweet-sentiment-decision-tree","retweet-sentiment-based-decision-tree-v1")
   # persist the model to disk
   model.save(model_path)

Código 1. Este trecho de código demonstra como construir classificadores de árvore de decisão com spark mllib, persistir no disco, e registrar o experimento com MLflow.

Este é um exemplo relativamente simples de como a ciência de dados pode funcionar com Spark mllib, mas, como mencionado antes, há muitas outras bibliotecas que a equipe de cientistas de dados podem aproveitar para construir os modelos de ML.

Para avaliar e calcular a taxa de erro do modelo, usamos Spark mllib MulticlassClassificationEvaluator, desta forma:

from pyspark.ml.evaluation import MulticlassClassificationEvaluator
# Select (prediction, true label) and compute test error
evaluator = MulticlassClassificationEvaluator(
   labelCol="indexedRetweetLabel", predictionCol="prediction", metricName="accuracy")
accuracy = evaluator.evaluate(prediction)
print("Test Error = %g " % (1.0 - accuracy))

Código 2. Este trecho de código demonstra como alavancar a classe do avaliador spark mllib para classificação multiclasse.

Em nosso caso, a taxa de erro foi de ~ 0,09, o que significa que 9% de nossas previsões estavam erradas, o que é uma taxa de erro bastante alta, logo requer mais trabalho de ciência de dados e especialistas em ML. Não vamos nos aprofundar nesse problema, pois este foi apenas um exemplo de como podemos conectar tudo e fazer com que as camadas de arquitetura funcionem bem juntas.

Como disponibilizar o modelo

Depois que nosso modelo de aprendizado de máquina passa em todos os testes de ciência de dados, avaliadores e garantia de qualidade, ele está pronto para o próximo estágio a ser testado no ambiente de teste. Se for bem-sucedido lá, ele segue para produção. O ambiente de teste é uma réplica simplificada do ambiente de produção e é usado como um portal para testes de software adicionais antes de implantar na produção.

Para implantar nosso modelo de ML em produção, precisamos definir como o serviremos. A saída do nosso modelo em si é um arquivo, que pode assumir vários formatos, como: arquivo pkl, arquivo onnx, arquivo pmml, arquivo zip, e outros. Esses arquivos são empacotados com trechos de código que podem ser carregados e usados. A maneira mais comum de utilizá-los é através de uma API REST, ou aproveitando a estrutura com a qual foram construídos. Em nosso exemplo, usamos Spark mllib, ao salvar o modelo, ele criou dois diretórios, metadata e stages.

Metadata contêm as informações da classe e o que mais utilizamos, estes são os metadados de nosso caso de uso:

{"class":"org.apache.spark.ml.PipelineModel","timestamp":1599589163673,"sparkVersion":"3.0.0","uid":"PipelineModel_569e70a7c84c","paramMap":{"stageUids":["StringIndexer_e0d104fabbc3","StringIndexer_ee814705beb3","VectorAssembler_bba4398a7d92","StringIndexer_81179a3a495e","Normalizer_0a5944f286e5","DecisionTreeClassifier_b9a126fc8dea"]},"defaultParamMap":{}}

Figura 2. Arquivo metadata criado pela persistência do pipeline do modelo Spark mllib no disco, ele contém todos os estágios e informações necessárias para recriar o próprio modelo de ML.

Stages contém diretórios com os diferentes estágios do pipeline para a criação do modelo.

Esta é a estrutura do diretório:

Figura 3. Arquivos criados persistindo o pipeline do modelo Spark ML no disco, cada estágio recebeu seu próprio diretório.

Cada um deles contém seus próprios diretórios data e metadados.

Data está em formato binário e contêm as informações que o modelo de pipeline precisa para se reconstruir.

Metadata aqui contém informações como classe, coluna de saída, e outros parâmetros de ajuste.

Abaixo está um trecho de código de como podemos servir nosso modelo de aprendizado de máquina. A função init inicia o componente e o modelo lendo-o do arquivo, e a função run obtém os dados de entrada e retorna os resultados.

import os , shutil , json
 
import pyspark
from azureml.core.model import Model
from pyspark.ml import PipelineModel


def init():
  global model
  global spark
 
 #Creating an spark session
  spark = pyspark.sql.SparkSession.builder.appName("tweets_decision_tree").getOrCreate()
  model_name = "tweets_decision_tree"
 
  #Loading the model
  #My model is stored in Azure Machine Learning Services. If not your case, replace accordingly
  model_path = Model.get_model_path(model_name)
  model_unpacked = "./" + model_name
 
  #Unpacking archive
  shutil.unpack_archive(model_path, model_unpacked)


  #Creating the PipelineModel object from path
  model = PipelineModel.load(model_unpacked)


# when our server gets new request for classification/prediction/scoring, it calls the model run functionally with the raw_data
def run(raw_data):
  # validate that the model is up
  if isinstance(trainedModel, Exception):
      #Loading routine failed to load the model
      return json.dumps({{"trainedModel":str(trainedModel)}})
  try:
      #Converting raw data into Dataframe (Spark)
      input_df = spark.createDataFrame(input_data)
      # Score using spark mllib decision tree pipeline - compute prediction
      result = model.transform(input_df).collect()
      # you can return any data type as long as it is JSON-serializable

      return result

  except Exception as e:
      print('[ERR] Exception happened: ' + str(e))
      result = 'Input ' + str(input_data) + '. Exception was: ' + str(e)
      return result

Código 3. Este trecho de código demonstra como carregar e usar o modelo que construímos no ambiente de produção. Para obter mais exemplos sobre como portar SparkML com o Azure Machine Learning, verifique este repositório no GitHub.

Este código usa nosso modelo de aprendizado de máquina escolhido, como o iniciamos, e como o executamos. Vamos adicionar outra camada ou APIs REST, e empacotá-lo para que fique pronto para implantar em qualquer lugar.

Para empacotar e implantar, usamos o Azure Machine Learning (AML), que nos ajuda a gerenciar nossos modelos de aprendizado de máquina. Aqui está um tutorial passo a passo sobre como aproveitar a AML para empacotar e implantar modelos no ambiente Kubernetes. Para uma solução completa de código aberto que é agnóstica na nuvem, verifique este tutorial do Facundo Santiago.

Este artigo não cobre tudo, um componente crucial para trabalhar com aprendizado de máquina na produção é poder monitorá-lo e decidir quando substituí-lo.

Conseguimos isso implementando observabilidade e monitoramento de todo o sistema. Nosso aplicativo empacotado que atende ao modelo de aprendizado de máquina precisa ter certeza de gravar as informações que precisamos rastrear nos registros e sistemas de monitoramento.

Observabilidade e monitoramento

Nosso sistema de alerta deve ser ajustado para coletar e monitorar nossos modelos de aprendizado de máquina em produção. Fazemos isso coletando logs distribuídos de várias máquinas, rastreando-os, e criando uma API simples para consultar e construir nossos alertas. Usamos o ELK stack (Elasticsearch, Logstash e Kibana) para este requisito. Elasticsearch é um mecanismo de busca para executar análises de texto completo, e o Logstash nos ajuda a criar pipelines de dados para rotear os dados para elasticsearch, e o Kibana fornece o painel de visualização de dados no topo do Elasticsearch.

Figura 4. Este diagrama é do site Logz.io. O Logz.io fornece uma solução gerenciada para observabilidade na nuvem.

No diagrama abaixo, você pode ver o ciclo de vida do modelo de aprendizado de máquina em alto nível. Os principais fatores para acionar um novo processo de treinamento de aprendizado de máquina geralmente são baseados em camadas de monitoramento e observabilidade.

Os três principais gatilhos são:

  • Orientado por dados, detectamos nova variabilidade de dados em nossos sistemas.
  • Com base em uma programação, queremos lançar um modelo de aprendizado de máquina atualizado a cada x dias.
  • Com base nas métricas, detectamos muitos erros e precisamos de um modelo de aprendizado de máquina atualizado.

Figura 5. Visão geral de alto nível do ciclo de aprendizado de máquina

Conclusões

Neste artigo, vimos como você pode arquitetar seu sistema com big data e aprendizado de máquina para permitir a análise preditiva em sua empresa. Criamos um modelo de aprendizado de máquina simples para decidir se um tweet com a palavra-chave COVID19 será retuitado ou não, com base na análise de sentimento e outros parâmetros. O aprendizado de máquina está desempenhando um papel crítico na luta contra a pandemia COVID19, e na melhor compreensão de como remediar a pandemia usando software.

Se você estiver interessado em aprender mais, verifique o projeto completo no github. Este é um projeto vivo, em constante evolução. Ele contém o código, as etapas, e as informações para que você possa começar. O projeto no GitHub não contém os dados em si. Se você quiser testar seu sistema com dados reais e seguir nossos passos, verifique o dataset do Twitter no site do Kaggle - tweets covid19.

Sobre a autora

Adi Polak é Engenheira de Software Senior e Developer Advocate na Azure, Microsoft. Seu trabalho se concentra em sistemas distribuídos, processamento em tempo real, análise de big data e aprendizado de máquina. Em seu trabalho de Advocate, ela traz sua vasta experiência em pesquisa e engenharia da indústria para ajudar as equipes a projetar, arquitetar e construir soluções de software e infraestrutura de baixo custo que enfatizam a escalabilidade, a experiência da equipe e a eficiência de custos. Adi tem mestrado em ciência da computação e sistemas de informação.

Avalie esse artigo

Relevância
Estilo/Redação

Olá visitante

Você precisa cadastrar-se no InfoQ Brasil ou para enviar comentários. Há muitas vantagens em se cadastrar.

Obtenha o máximo da experiência do InfoQ Brasil.

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

Comentários da comunidade

  • Interessante Curti muito

    by Robo Bitcoin,

    Seu comentário está aguardando aprovação dos moderadores. Obrigado por participar da discussão!

    Parabéns, excelente tópico!

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

BT