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

  • Artigo

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:

  • Desenvolver um aplicativo de aprendizado de máquina Apache Spark

Pré-requisitos

Compreender o conjunto de dados

O aplicativo usa os dados de HVAC.csv de exemplo que estão disponíveis em todos os clusters por padrã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.

Snapshot of data used for Spark machine learning example.

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

Este aplicativo usa um pipeline do Spark ML para fazer uma classificação de documento. 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 preparação.

    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:

    Output data snapshot for Spark machine learning example.

    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.

Clean up resources (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 Clusters HDInsight em Serviços.

  4. Na lista de clusters HDInsight exibida, selecione o botão ... ao lado do cluster que você criou para este tutorial.

  5. Selecione Eliminar. Selecione Yes (Sim).

Azure portal deletes an HDInsight cluster.

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.

Criar um aplicativo Scala Maven usando o IntelliJ