Tutorial: Criar um aplicativo de aprendizado de máquina Apache Spark no Azure HDInsight

Neste tutorial, você aprenderá a usar o Jupyter Notebook para criar um aplicativo de aprendizado de máquina Apache Spark para o Azure HDInsight.

MLlib é a biblioteca de aprendizado de máquina adaptável do Spark que consiste em algoritmos e utilitários de aprendizado comuns. (Classificação, regressão, agrupamento, filtragem colaborativa e redução de dimensionalidade. Além disso, primitivos de otimização subjacentes.)

Neste tutorial, irá aprender a:

Pré-requisitos

• Um cluster do Apache Spark no HDInsight. Consulte Criar um cluster do Apache Spark.

• Familiaridade com a utilização de Jupyter Notebooks com o Spark no HDInsight. Para obter mais informações, consulte Carregar dados e executar consultas com o Apache Spark no HDInsight.

Compreender o conjunto de dados

A aplicação utiliza os dados de exemplo HVAC.csv que estão disponíveis em todos os clusters por predefinição. O arquivo está localizado em \HdiSamples\HdiSamples\SensorSampleData\hvac. Os dados mostram a temperatura pretendida e a temperatura real de alguns edifícios que têm sistemas HVAC instalados. A coluna System (Sistema) representa o ID do sistema e a coluna SystemAge (Idade do sistema) representa há quanto anos o sistema HVAC foi implementado nesse edifício. Você pode prever se um edifício será mais quente ou mais frio com base na temperatura alvo, no ID do sistema e na idade do sistema.

Desenvolver uma aplicação de machine learning do Spark com a MLlib do Spark

Esta aplicação utiliza um pipeline ML do Spark para realizar a classificação de documentos. Os Pipelines de ML fornecem um conjunto uniforme de APIs de alto nível criadas sobre DataFrames. Os DataFrames ajudam os usuários a criar e ajustar pipelines práticos de aprendizado de máquina. No pipeline, o documento é dividido em palavras, estas são convertidas num vetor de numérico de características e, por fim, é criado um modelo de previsão que utiliza os vetores de características e as etiquetas. Execute as etapas a seguir para criar o aplicativo.

1. Crie um Jupyter Notebook usando o kernel PySpark. Para obter instruções, consulte Criar um arquivo do Jupyter Notebook.

2. Importe os tipos necessários para este cenário. Cole o seguinte fragmento numa célula vazia e prima SHIFT + ENTER.

   from pyspark.ml import Pipeline
   from pyspark.ml.classification import LogisticRegression
   from pyspark.ml.feature import HashingTF, Tokenizer
   from pyspark.sql import Row
   
   import os
   import sys
   from pyspark.sql.types import *
   
   from pyspark.mllib.classification import LogisticRegressionWithLBFGS
   from pyspark.mllib.regression import LabeledPoint
   from numpy import array
   

3. Carregue os dados (hvac.csv), analise-os e utilize-os para preparar o modelo.

   # Define a type called LabelDocument
   LabeledDocument = Row("BuildingID", "SystemInfo", "label")
   
   # Define a function that parses the raw CSV file and returns an object of type LabeledDocument
   def parseDocument(line):
       values = [str(x) for x in line.split(',')]
       if (values[3] > values[2]):
           hot = 1.0
       else:
           hot = 0.0
   
       textValue = str(values[4]) + " " + str(values[5])
   
       return LabeledDocument((values[6]), textValue, hot)
   
   # Load the raw HVAC.csv file, parse it using the function
   data = sc.textFile("/HdiSamples/HdiSamples/SensorSampleData/hvac/HVAC.csv")
   
   documents = data.filter(lambda s: "Date" not in s).map(parseDocument)
   training = documents.toDF()
   

   No fragmento de código, vai definir uma função que compara a temperatura real com a temperatura pretendida. Se a temperatura real for superior, o edifício está quente, o que é mostrado pelo valor 1.0. Caso contrário, o edifício está frio, o que é mostrado pelo valor 0.0.

4. Configure o pipeline de aprendizado de máquina do Spark que consiste em três estágios: tokenizer, hashingTFe lr.

   tokenizer = Tokenizer(inputCol="SystemInfo", outputCol="words")
   hashingTF = HashingTF(inputCol=tokenizer.getOutputCol(), outputCol="features")
   lr = LogisticRegression(maxIter=10, regParam=0.01)
   pipeline = Pipeline(stages=[tokenizer, hashingTF, lr])
   

   Para obter mais informações sobre pipeline e como ele funciona, consulte Apache Spark machine learning pipeline.

5. Ajuste o pipeline ao documento de treino.

   model = pipeline.fit(training)
   

6. Verifique o documento de preparação para registar o progresso com a aplicação.

   training.show()
   

   O resultado é semelhante a:

   +----------+----------+-----+
   |BuildingID|SystemInfo|label|
   +----------+----------+-----+
   |         4|     13 20|  0.0|
   |        17|      3 20|  0.0|
   |        18|     17 20|  1.0|
   |        15|      2 23|  0.0|
   |         3|      16 9|  1.0|
   |         4|     13 28|  0.0|
   |         2|     12 24|  0.0|
   |        16|     20 26|  1.0|
   |         9|      16 9|  1.0|
   |        12|       6 5|  0.0|
   |        15|     10 17|  1.0|
   |         7|      2 11|  0.0|
   |        15|      14 2|  1.0|
   |         6|       3 2|  0.0|
   |        20|     19 22|  0.0|
   |         8|     19 11|  0.0|
   |         6|      15 7|  0.0|
   |        13|      12 5|  0.0|
   |         4|      8 22|  0.0|
   |         7|      17 5|  0.0|
   +----------+----------+-----+
   

   Compare o resultado com o ficheiro CSV não processado. Por exemplo, a primeira linha do ficheiro CSV tem estes dados:

   

   Repare como a temperatura real é inferior à pretendida, o que sugere que o edifício está frio. O valor para rótulo na primeira linha é 0,0, o que significa que o edifício não está quente.

7. Prepare um conjunto de dados no qual executar o modelo preparado. Para fazer isso, você passa um ID do sistema e idade do sistema (indicado como SystemInfo na saída do treinamento). O modelo prevê se o edifício com esse ID de sistema e idade do sistema será mais quente (indicado por 1,0) ou mais frio (indicado por 0,0).

   # SystemInfo here is a combination of system ID followed by system age
   Document = Row("id", "SystemInfo")
   test = sc.parallelize([("1L", "20 25"),
                   ("2L", "4 15"),
                   ("3L", "16 9"),
                   ("4L", "9 22"),
                   ("5L", "17 10"),
                   ("6L", "7 22")]) \
       .map(lambda x: Document(*x)).toDF()
   

8. Por fim, faça predições nos dados de teste.

   # Make predictions on test documents and print columns of interest
   prediction = model.transform(test)
   selected = prediction.select("SystemInfo", "prediction", "probability")
   for row in selected.collect():
       print (row)
   

   O resultado é semelhante a:

   Row(SystemInfo=u'20 25', prediction=1.0, probability=DenseVector([0.4999, 0.5001]))
   Row(SystemInfo=u'4 15', prediction=0.0, probability=DenseVector([0.5016, 0.4984]))
   Row(SystemInfo=u'16 9', prediction=1.0, probability=DenseVector([0.4785, 0.5215]))
   Row(SystemInfo=u'9 22', prediction=1.0, probability=DenseVector([0.4549, 0.5451]))
   Row(SystemInfo=u'17 10', prediction=1.0, probability=DenseVector([0.4925, 0.5075]))
   Row(SystemInfo=u'7 22', prediction=0.0, probability=DenseVector([0.5015, 0.4985]))
   

   Observe a primeira linha da previsão. Para um sistema AVAC com ID 20 e idade do sistema de 25 anos, o edifício está quente (previsão=1,0). O primeiro valor para DenseVector (0.49999) corresponde à predição 0.0 e o segundo valor (0.5001) corresponde à predição 1.0. Na saída, apesar de o segundo valor ser apenas marginalmente superior, o modelo mostra prediction=1.0.

9. Encerre o bloco de notas para libertar os recursos. Para tal, no menu File (Ficheiro) do bloco de notas, selecione Close and Halt (Fechar e Parar). Esta ação encerra e fecha o bloco de notas.

Utilizar a biblioteca scikit-learn de Anaconda para machine learning do Spark

Os clusters do Apache Spark no HDInsight incluem bibliotecas de Anaconda. Também inclui a biblioteca scikit-learn para machine learning. A biblioteca também inclui vários conjuntos de dados que você pode usar para criar aplicativos de exemplo diretamente de um Jupyter Notebook. Para obter exemplos de como utilizar a biblioteca scikit-learn, veja https://scikit-learn.org/stable/auto_examples/index.html.

Limpar recursos

Se não pretender continuar a utilizar esta aplicação, elimine o cluster que criou com os seguintes passos:

1. Inicie sessão no portal do Azure.

2. Na caixa Pesquisar na parte superior, digite HDInsight.

3. Selecione HDInsight clusters em Serviços.

4. Na lista de clusters HDInsight exibida, seleciona o ... ao lado do cluster que tu criaste para este tutorial.

5. Selecione Eliminar. Selecione Yes (Sim).

Próximos passos

Neste tutorial, você aprendeu como usar o Jupyter Notebook para criar um aplicativo de aprendizado de máquina Apache Spark para o Azure HDInsight. Avance para o próximo tutorial para saber como utilizar o IntelliJ IDEA para trabalhos do Spark.