Tutorial: Construir uma aplicação de aprendizagem automática Apache Spark em Azure HDInsight

Neste tutorial, você aprende a usar o Jupyter Notebook para construir uma aplicação de aprendizagem automática Apache Spark para Azure HDInsight.

MLlib é a biblioteca de aprendizagem automática adaptável da Spark, composta por algoritmos de aprendizagem comuns e utilitários. (Classificação, regressão, agrupamento, filtragem colaborativa e redução da dimensionalidade. Além disso, primitivos de otimização subjacentes.)

Neste tutorial, ficará a saber como:

  • Desenvolver uma aplicação de aprendizagem automática Apache Spark

Pré-requisitos

Compreender o conjunto de dados

A aplicação utiliza a amostra HVAC.csv dados que estão disponíveis em todos os clusters por padrão. O ficheiro 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 frio com base na temperatura-alvo, dada a identificação do sistema, e a idade do sistema.

Instantâneo de dados utilizados para exemplo de aprendizagem de máquinas de faísca

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

Esta aplicação utiliza um oleoduto Spark ML para fazer uma classificação de documento. Os gasodutos ML fornecem um conjunto uniforme de APIs de alto nível construído em cima de DataFrames. Os DataFrames ajudam os utilizadores a criar e afinar oleodutos práticos de aprendizagem de máquinas. 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. Faça os seguintes passos para criar a aplicação.

  1. Crie um Caderno Jupyter utilizando o núcleo PySpark. Para obter as instruções, consulte Criar um ficheiro de caderno Jupyter.

  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 LogisticRegressionWithSGD
    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 machine learning do Spark, que consiste em três etapas: tokenizer, hashingTF e 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 o oleoduto e como funciona, consulte o oleoduto de aprendizagem da máquina Apache Spark.

  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:

    Instantâneo de dados de saída para exemplo de aprendizagem de máquinas de faísca

    Repare como a temperatura real é inferior à pretendida, o que sugere que o edifício está frio. O valor para o 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 tal, transmite-se uma ID do sistema e idade do sistema (denotada como SystemInfo na saída de treino). O modelo prevê se o edifício com esse ID do sistema e a idade do sistema serão mais quentes (denotados por 1.0) ou mais frio (denotado 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 de AVAC com ID 20 e idade do sistema de 25 anos, o edifício é 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 pode usar para construir aplicações de amostra diretamente de um Caderno Jupyter. Por exemplo, sobre a utilização da biblioteca de aprendizagem de scikit, consulte https://scikit-learn.org/stable/auto_examples/index.html .

Limpar os recursos

Se não 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 de pesquisa no topo, escreva HDInsight.

  3. Selecione clusters HDInsight em Serviços.

  4. Na lista de clusters HDInsight que aparecem, selecione o ... ao lado do cluster que criou para este tutorial.

  5. Selecione Eliminar. Selecione Yes (Sim).

Portal Azure elimina um cluster HDInsight

Passos seguintes

Neste tutorial, aprendeu a usar o Jupyter Notebook para construir uma aplicação de aprendizagem automática Apache Spark para Azure HDInsight. Avance para o próximo tutorial para saber como utilizar o IntelliJ IDEA para trabalhos do Spark.