Spark: trabalhando com regressão

Preparando os dados - Apresentação

Olá! Eu sou o Pedro Moura, instrutor de Data Science da Alura e gostaria de te convidar a aprender um pouco sobre modelos de regressão no Spark.

Pedro Moura é um homem jovem e branco de cabelos curtos e pretos. Usa óculos de grau com armação redonda em tons de marrom e preto, barba e bigode bem aparados e fones de ouvido pretos. Ele veste uma camiseta cinza com "alura" escrito em branco ao centro, com letras estilizadas. Está sentado em um cômodo iluminado por uma luz verde. Ao lado esquerdo, visualizamos uma janela grande e branca fechada. Ao fundo, uma parede branca com quadrados pretos, semelhante a um tabuleiro de xadrez.

Nosso objetivo no curso é criar modelos de regressão a partir do Spark utilizando Python. O problema que estamos tentando resolver é como prever preços de imóveis baseados nas suas características. Para fazer esse curso com bastante tranquilidade, é importante que você já tenha alguma vivência no Spark e saiba ao menos um pouco sobre modelos de machine learning.

Então, vamos aprender a criar esses modelos de regressão no Spark?

Preparando os dados - Objetivos e ferramentas

Agora que você já sabe sobre o que é o curso, quero apresentar com mais detalhes qual o seu objetivo, isto é, qual problema resolveremos e quais ferramentas utilizaremos na resolução desse problema.

O objetivo do curso é criar um modelo de regressão para prever preços de imóveis baseados nas suas características.

Nós faremos isso utilizando técnicas de aprendizado de máquina. Esperamos que você já tenha alguma vivência com aprendizado de máquina. A ferramenta que utilizaremos é o Pyspark, que é uma implementação do Spark com a qual conseguiremos criar aplicações Spark usando a linguagem Python. Como o foco do curso é criar o modelo de regressão, também é recomendável que você tenha alguma vivência com Spark.

Agora, gostaria de relembrar alguns pontos. Sempre que trabalhamos com machine learning, precisamos, primeiro, de uma ferramenta, que no nosso caso será o Pyspark e, segundo, dos dados. Antes de apresentar os dados, queria dizer que nós faremos todo o desenvolvimento do curso no Google Colab. Vamos conhecer os dados?

Preparando os dados - Apresentando os dados

Estamos no ambiente de desenvolvimento, o Google Colab, vamos retomar algumas ideias e conferir os nossos dados. Estamos trabalhando com o PySpark, que é uma implementação do Spark para Python e temos várias estruturas de dados possíveis dentro do Spark. Neste curso, especificamente, trabalharemos com o Spark SQL DataFrame.

Quando trabalhamos com o Spark dentro do Colab, precisamos seguir alguns passos, porque o Google Colab pegará uma máquina que está na nuvem da Google e alocará para que seja possível trabalhar com o código Python. Por isso, sempre que vamos para uma nova máquina, primeiro, conectamos e fazemos a instalação da biblioteca PySpark.

Quando finalizamos a conexão, portanto, rodaremos a célula pip install pyspark de instalação do PySpark. Pode demorar um pouco, mas não se preocupe.

Agora, a PySpark está instalada no notebook, podemos começar a codificação. Para iniciar qualquer codificação no Spark, precisamos criar uma sessão e é por meio dela que conseguiremos interagir com os dados. Portanto, rodaremos a Spark Session.

from pyspark.sql import SparkSession

spark = SparkSession.builder \
    .master('local[*]') \
    .appName("Regressão com Spark") \
    .getOrCreate()

spark

Com o trecho .master('local[*]') \ estamos colocando a master no Local e .appName se refere ao nome da aplicação que faremos agora, no nosso caso, a Regressão com Spark. Com geyOrCreat() faremos a criação da sessão. Além disso, escrevemos spark para visualizarmos a sessão. Está tudo correto, temos o nome da nossa aplicação que é "Regressão com Spark" e agora podemos partir para o carregamento dos dados.

Não se preocupe sobre onde estão os dados, porque esse notebook tem todo o código escrito e os dados estarão disponíveis nas próximas atividades. Nós estamos trabalhando com um conjunto de dados um pouco diferentes, para conhecê-los, nosso primeiro passo é rodar a célula a seguir:

from google.colab import drive
drive.mount('/content/drive')

Estamos importando o drive dentro da biblioteca do Colab e vamos montar o drive aqui, significa que daremos acesso desse notebook a todos os arquivos que estão no Google Drive. Aliás, esse é um procedimento recomendável: subir todos os arquivos no Google Drive.

Continuando, sempre que rodamos a célula, ela pedirá permissão da conta do google que é responsável pelo drive. Então, liberaremos o acesso para que o notebook consiga acessar os arquivos. Com a permissão feita, podemos passar a trabalhar com os dados. Para isso, na lateral superior esquerda da tela, temos quatro botões: um menu; uma lupa; um "x"; e uma pasta, que é o nosso principal interesse.

Nesse botão de pasta, está a pasta "drive". Dentro dela, precisamos localizar o arquivo. No nosso caso, ele está na pasta "Alura", é o "imoveis.json". Na pasta do drive com os arquivos de dados, temos o "imoveis.json" composto de todos os imóveis com os quais trabalharemos e analisaremos os cinco primeiros para compreendermos como o JSON é estruturado.

A visualização não é tão boa. Para melhorá-la, vamos até o navegador do Google, buscaremos "JSON Viewer" e acessaremos o site "Online JSON Viewer", disponível neste link. Este site nos permite trazer o JSON e visualizá-lo de forma mais amigável, não mais como um bloco de texto e, sim, melhor formatado. Então, vamos copiar o JSON inteiro, retornar à página do Online JSON Viewer e colá-lo.

Em seguida, apertaremos o botão "Format". Temos um trecho do resultado abaixo.

  },
    "address": {
       "city": "Rio de Janeiro",
         "location": {
            "lon": -43.413557,
                "lat": -22.909429
            },
            "zone": "Zona Oeste",
            "neighborhood": "Taquara"
        },

Neste formato, conseguimos perceber algum sentido dentro da estrutura. Há uma lista, e nela, algumas chaves, como no dicionário do Python. Melhor que essa visualização, será a que encontraremos na aba "Viewer", no canto superior esquerdo.

• JSON
  • {} 0
  • {} 1
  • {} 2
  • {} 3
  • {} 4
  • {} 5

Aqui, temos o JSON e nele vários objetos: 0, 1, 2, 3, 4 e 5. Portanto, 6 objetos no total. Agora, analisaremos o que há em cada objeto. Dentro do objeto número 0, temos o "ident" e nele o "customerID" do imóvel e também de onde ele vem, no caso, de um website, "source: 'website'".

Além disso, temos outra estrutura chamada "listing", onde encontramos: o tipo do imóvel, "types"; o endereço, "adress"; o preço dos impostos de condomínio, "prices > tax > iptu, condo"; e quais são suas "features", isto é, suas características, como "bedrooms", "Bathrooms", "suites", dentre outros.

Assim, notamos que há uma estrutura alinhada, ou seja, uma estrutura dentro de outra, e nelas os dados organizados. Agora que sabemos disso, conseguimos trabalhar com mais facilidade. Todos os imóveis seguirão a mesma estrutura, isto é, todos têm "listing", "ident" e assim por diante. Vamos voltar para o nosso projeto e dar início ao trabalho com os dados.

Podemos fechar a aba lateral de arquivos e retornar ao ambiente de desenvolvimento que é o Google Colab. Após ter montado o ambiente, precisamos localizar o arquivo "imoveis.json" e "três pontinhos (...)" ao lado dele. Vamos apertar esses três pontos com o botão direito e selecionar "Copiar caminho". Ao fazermos isso, um link será disponibilizado com o qual conseguiremos acessar o arquivo.

dados = spark.read.json(
    '/content/drive/MyDrive/Alura/imoveis.json',
    multiLine=False
)

Portanto, o Spark tem um leitor específico para JSON e precisamos passar a localização do arquivo que ele precisa ler. Vamos rodar essa célula, lembrando que estamos trabalhando com um volume maior de dados e o Spark trabalha de forma muito eficiente com volumes grandes de dados, ou seja, faz todo o sentido a sua utilização. Assim que ele rodou, podemos conferir o que é o nosso objeto dados.

dados 

DataFrame[ident: struct<customerID:string,source:string>, listing: struct<address:struct<city:string,location:struct<lat:double,lon:double>,neighborhood:string,zone:string>,features:struct<bathrooms:bigint,bedrooms:bigint,floors:bigint,parkingSpaces:bigint,suites:bigint,totalAreas:string,unitFloor:bigint,unitsOnTheFloor:bigint,usableAreas:string>,prices:struct<price:string,tax:struct<condo:string,iptu:string>>,types:struct<unit:string,usage:string>>]

Se trata de um DataFrame com ident, listing, mas essa não é a melhor forma de visualização do DataFrame Spark. Então, usaremos a função .show(), que mostra o que está dentro do Spark e passaremos um atributo chamado truncate=False, desta maneira garantimos, por exemplo, que se o nome da rua for muito grande, ele aparecerá inteiro.

dados.show(truncate=False)

Rodaremos a célula e conseguiremos acessar de forma visualmente mais interessante o nosso Dataset. Temos um trecho dele a seguir.

{775564-BOJSMVON, Website}|{{Rio de Janeiro, {-22.909429, -43.413557}, Taquara, Zona Oeste}, {0, 0, 0, 1, 0, 62, 0, 0, 62}, {45000, {150, 0}}, {Outros, Residencial}}                       
{660895-AUENKNYY, Website}|{{Rio de Janeiro, {-22.869698, -43.509141}, Santíssimo, Zona Oeste}, {1, 2, 0, 1, 0, 0, 0, 0, 44}, {45000, {120, 0}}, {Apartamento, Residencial}}                

Então, temos o ident, que já havíamos visualizado no JSON, e também o listing. Dentro, existe toda uma estrutura de dados que vimos anteriormente e que não está muito amigável. Por exemplo, não conseguimos entender facilmente o que o Rio de Janeiro significa, o que é o 22, 43, Taquara e Zona Oeste.

Nosso último passo, antes do próximo vídeo, é verificarmos a quantidade de dados que trabalharemos nesse DataFrame, porque quando rodamos a função .show(), visualizamos apenas os vinte primeiros dados. Queremos saber o total.

dados.count()

73615

A função .count fez a contagem de quantos registros existem no Dataset e o resultado é 73615 (setenta e três mil, seiscentos e quinze) imóveis diferentes. Nós trabalharemos nestes dados e nós próximos, tentaremos melhorar um pouco a visualização, deixando-a mais amigável, mais parecida com o que conhecemos. Por exemplo, no Dataset do Pandas. Vamos lá?

Sobre o curso Spark: trabalhando com regressão

O curso Spark: trabalhando com regressão possui 114 minutos de vídeos, em um total de 55 atividades. Gostou? Conheça nossos outros cursos de Engenharia de Dados em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Preparando os dados
• Regressão Linear
• Árvore de Decisão
• Random Forest
• Técnicas de Otimização