previsao_precos_casas_PySpark.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Previsão de Preço de Casas com Apache Spark\n",
    "\n",
    "Regressão Linear\n",
    "\n",
    "Neste artigo, usaremos o conjunto de dados da California Housing. Observe, é claro, que esses dados são realmente 'pequenos' e que o uso do Spark nesse contexto pode ser um exagero, porém este notebook é apenas para fins educacionais e deve nos dar uma idéia de como podemos usar o PySpark para construir um modelo de aprendizado de máquina.\n",
    "\n",
    "Este modelo foi criado com base num estudo do Kaggle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Compreendendo o conjunto de dados\n",
    "O conjunto de dados da California Housing apareceu em um artigo de 1997 intitulado Sparse Spatial Autoregressions, escrito por Pace, R. Kelley e Ronald Barry e publicado na revista Statistics and Probability Letters. Os pesquisadores construíram esse conjunto de dados usando os dados do censo da Califórnia em 1990.\n",
    "\n",
    "Os dados contêm uma linha por grupo de blocos censitários. Um grupo de blocos é a menor unidade geográfica para a qual o US Census Bureau publica dados de amostra (um grupo de blocos normalmente tem uma população de 600 a 3.000 pessoas). Nesta amostra, um grupo de blocos inclui, em média, 1425,5 indivíduos que vivem em uma área geograficamente compacta.\n",
    "\n",
    "Esses dados espaciais contêm 20.640 observações sobre os preços da habitação com 9 variáveis econômicas:\n",
    "  - Longitude: refere-se à distância angular de um local geográfico ao norte ou ao sul do equador da Terra para cada grupo de blocos\n",
    "  - Latitude: refere-se à distância angular de um local geográfico a leste ou oeste do equador da Terra para cada grupo de blocos\n",
    "  - Idade média da moradia: é a idade média das pessoas que pertencem a um grupo de quarteirões. Observe que a mediana é o valor que fica no ponto médio de uma distribuição de frequência dos valores observados\n",
    "  - Total de quartos-de-dormir: é o número total de quartos-de-dormir nas casas por grupo de blocos\n",
    "  - Total de quartos: é o número total de quartos nas casas por grupo de blocos\n",
    "  - População: é o número de habitantes de um grupo de blocos\n",
    "  - Famílias: refere-se a unidades de casas e seus ocupantes por grupo de blocos\n",
    "  - Renda mediana: é usada para registrar a renda mediana das pessoas que pertencem a um grupo de blocos\n",
    "  - Valor médio da casa: é a variável dependente e refere-se ao valor médio da casa por grupo de blocos\n",
    "\n",
    "Além disso, também aprendemos que todos os grupos de blocos têm zero entradas, pois as variáveis independentes e dependentes foram excluídas dos dados.\n",
    "\n",
    "O valor médio da casa é a variável dependente e será atribuído o papel da variável de destino em nosso modelo de ML.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pyspark in /home/nelson/anaconda3/lib/python3.7/site-packages (2.4.4)\n",
      "Requirement already satisfied: py4j==0.10.7 in /home/nelson/anaconda3/lib/python3.7/site-packages (from pyspark) (0.10.7)\n"
     ]
    }
   ],
   "source": [
    "!pip install pyspark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importar as Bibliotecas necessárias\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "from pyspark import SparkConf, SparkContext\n",
    "from pyspark.sql import SparkSession, SQLContext\n",
    "\n",
    "from pyspark.sql.types import *\n",
    "import pyspark.sql.functions as F\n",
    "from pyspark.sql.functions import udf, col\n",
    "\n",
    "from pyspark.ml.regression import LinearRegression\n",
    "from pyspark.mllib.evaluation import RegressionMetrics\n",
    "\n",
    "from pyspark.ml.tuning import ParamGridBuilder, CrossValidator, CrossValidatorModel\n",
    "from pyspark.ml.feature import VectorAssembler, StandardScaler\n",
    "from pyspark.ml.evaluation import RegressionEvaluator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Visualização\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "\n",
    "pd.set_option('display.max_columns', 200)\n",
    "pd.set_option('display.max_colwidth', 400)\n",
    "\n",
    "from matplotlib import rcParams\n",
    "sns.set(context='notebook', style='whitegrid', rc={'figure.figsize': (18,4)})\n",
    "rcParams['figure.figsize'] = 18,4\n",
    "\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo semente aleatória para reprodutibilidade do notebook\n",
    "rnd_seed=23\n",
    "np.random.seed=rnd_seed\n",
    "np.random.set_state=rnd_seed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Criando a sessão Spark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark = SparkSession.builder.master(\"local[2]\").appName(\"Regressao-Linear-Casas-California\").getOrCreate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <div>\n",
       "                <p><b>SparkSession - in-memory</b></p>\n",
       "                \n",
       "        <div>\n",
       "            <p><b>SparkContext</b></p>\n",
       "\n",
       "            <p><a href=\"http://192.168.0.15:4040\">Spark UI</a></p>\n",
       "\n",
       "            <dl>\n",
       "              <dt>Version</dt>\n",
       "                <dd><code>v2.4.4</code></dd>\n",
       "              <dt>Master</dt>\n",
       "                <dd><code>local[2]</code></dd>\n",
       "              <dt>AppName</dt>\n",
       "                <dd><code>Regressao-Linear-Casas-California</code></dd>\n",
       "            </dl>\n",
       "        </div>\n",
       "        \n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "<pyspark.sql.session.SparkSession at 0x7fae3a9bd0d0>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <div>\n",
       "            <p><b>SparkContext</b></p>\n",
       "\n",
       "            <p><a href=\"http://192.168.0.15:4040\">Spark UI</a></p>\n",
       "\n",
       "            <dl>\n",
       "              <dt>Version</dt>\n",
       "                <dd><code>v2.4.4</code></dd>\n",
       "              <dt>Master</dt>\n",
       "                <dd><code>local[2]</code></dd>\n",
       "              <dt>AppName</dt>\n",
       "                <dd><code>Regressao-Linear-Casas-California</code></dd>\n",
       "            </dl>\n",
       "        </div>\n",
       "        "
      ],
      "text/plain": [
       "<SparkContext master=local[2] appName=Regressao-Linear-Casas-California>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sc = spark.sparkContext\n",
    "sc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pyspark.sql.context.SQLContext at 0x7fae3a95f450>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqlContext = SQLContext(spark.sparkContext)\n",
    "sqlContext"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Carregar os dados de um arquivo em um Data Frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "CASAS_DATA = '/home/nelson/Documents/Script Python/Predictive_House_Price_Spark/cal_housing.data'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A especificação do esquema ao carregar dados em um DataFrame fornecerá melhor desempenho do que a inferência do esquema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define o esquema, correspondente a uma linha no arquivo de dados csv.\n",
    "schema = StructType([\n",
    "    StructField(\"long\", FloatType(), nullable=True),\n",
    "    StructField(\"lat\", FloatType(), nullable=True),\n",
    "    StructField(\"medage\", FloatType(), nullable=True),\n",
    "    StructField(\"totrooms\", FloatType(), nullable=True),\n",
    "    StructField(\"totbdrms\", FloatType(), nullable=True),\n",
    "    StructField(\"pop\", FloatType(), nullable=True),\n",
    "    StructField(\"houshlds\", FloatType(), nullable=True),\n",
    "    StructField(\"medinc\", FloatType(), nullable=True),\n",
    "    StructField(\"medhv\", FloatType(), nullable=True)]\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Carregar dados das casas\n",
    "casas_df = spark.read.csv(path=CASAS_DATA, schema=schema).cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(long=-122.2300033569336, lat=37.880001068115234, medage=41.0, totrooms=880.0, totbdrms=129.0, pop=322.0, houshlds=126.0, medinc=8.325200080871582, medhv=452600.0),\n",
       " Row(long=-122.22000122070312, lat=37.86000061035156, medage=21.0, totrooms=7099.0, totbdrms=1106.0, pop=2401.0, houshlds=1138.0, medinc=8.301400184631348, medhv=358500.0),\n",
       " Row(long=-122.23999786376953, lat=37.849998474121094, medage=52.0, totrooms=1467.0, totbdrms=190.0, pop=496.0, houshlds=177.0, medinc=7.257400035858154, medhv=352100.0),\n",
       " Row(long=-122.25, lat=37.849998474121094, medage=52.0, totrooms=1274.0, totbdrms=235.0, pop=558.0, houshlds=219.0, medinc=5.643099784851074, medhv=341300.0),\n",
       " Row(long=-122.25, lat=37.849998474121094, medage=52.0, totrooms=1627.0, totbdrms=280.0, pop=565.0, houshlds=259.0, medinc=3.8461999893188477, medhv=342200.0)]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Inspecionando as 5 primeiras linhas\n",
    "casas_df.take(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-----+------+--------+--------+------+--------+------+--------+\n",
      "|   long|  lat|medage|totrooms|totbdrms|   pop|houshlds|medinc|   medhv|\n",
      "+-------+-----+------+--------+--------+------+--------+------+--------+\n",
      "|-122.23|37.88|  41.0|   880.0|   129.0| 322.0|   126.0|8.3252|452600.0|\n",
      "|-122.22|37.86|  21.0|  7099.0|  1106.0|2401.0|  1138.0|8.3014|358500.0|\n",
      "|-122.24|37.85|  52.0|  1467.0|   190.0| 496.0|   177.0|7.2574|352100.0|\n",
      "|-122.25|37.85|  52.0|  1274.0|   235.0| 558.0|   219.0|5.6431|341300.0|\n",
      "|-122.25|37.85|  52.0|  1627.0|   280.0| 565.0|   259.0|3.8462|342200.0|\n",
      "+-------+-----+------+--------+--------+------+--------+------+--------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Mostrar as primeiras cinco linhas\n",
    "casas_df.show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['long',\n",
       " 'lat',\n",
       " 'medage',\n",
       " 'totrooms',\n",
       " 'totbdrms',\n",
       " 'pop',\n",
       " 'houshlds',\n",
       " 'medinc',\n",
       " 'medhv']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mostra as colunas do Data Frame\n",
    "casas_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- long: float (nullable = true)\n",
      " |-- lat: float (nullable = true)\n",
      " |-- medage: float (nullable = true)\n",
      " |-- totrooms: float (nullable = true)\n",
      " |-- totbdrms: float (nullable = true)\n",
      " |-- pop: float (nullable = true)\n",
      " |-- houshlds: float (nullable = true)\n",
      " |-- medinc: float (nullable = true)\n",
      " |-- medhv: float (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# mostra o esquema do Data Frame\n",
    "casas_df.printSchema()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Exploração de Dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------+--------+\n",
      "|   pop|totbdrms|\n",
      "+------+--------+\n",
      "| 322.0|   129.0|\n",
      "|2401.0|  1106.0|\n",
      "| 496.0|   190.0|\n",
      "| 558.0|   235.0|\n",
      "| 565.0|   280.0|\n",
      "| 413.0|   213.0|\n",
      "|1094.0|   489.0|\n",
      "|1157.0|   687.0|\n",
      "|1206.0|   665.0|\n",
      "|1551.0|   707.0|\n",
      "+------+--------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# executar uma seleção de amostra\n",
    "casas_df.select('pop','totbdrms').show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4.1 Distribuição da idade média das pessoas que vivem na área:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Agrupar por housingmedianage e ver a distribuição\n",
    "resultado_df = casas_df.groupBy(\"medage\").count().sort(\"medage\", ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------+-----+\n",
      "|medage|count|\n",
      "+------+-----+\n",
      "|  52.0| 1273|\n",
      "|  51.0|   48|\n",
      "|  50.0|  136|\n",
      "|  49.0|  134|\n",
      "|  48.0|  177|\n",
      "|  47.0|  198|\n",
      "|  46.0|  245|\n",
      "|  45.0|  294|\n",
      "|  44.0|  356|\n",
      "|  43.0|  353|\n",
      "+------+-----+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "resultado_df.show(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fae3a11ced0>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 390,
       "width": 833
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "resultado_df.toPandas().plot.bar(x='medage', figsize=(14,6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A maioria dos residentes está na juventude ou decide morar aqui durante a terceira idade. Alguns dados mostram idade média <10, que parece estar fora do padrão."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4.2 Resumo das estatísticas:\n",
    "Os DataFrames do Spark incluem algumas funções internas para processamento estatístico. A função describe() executa cálculos estatísticos resumidos em todas as colunas numéricas e os retorna como um DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-------+---------+--------+---------+--------+-------+-----------+\n",
      "|summary| medage| totrooms|totbdrms|      pop|houshlds| medinc|      medhv|\n",
      "+-------+-------+---------+--------+---------+--------+-------+-----------+\n",
      "|  count|20640.0|  20640.0| 20640.0|  20640.0| 20640.0|20640.0|    20640.0|\n",
      "|   mean|28.6395|2635.7631| 537.898|1425.4767|499.5397| 3.8707|206855.8169|\n",
      "| stddev|12.5856|2181.6153|421.2479|1132.4621|382.3298| 1.8998|115395.6159|\n",
      "|    min|    1.0|      2.0|     1.0|      3.0|     1.0| 0.4999|    14999.0|\n",
      "|    max|   52.0|  39320.0|  6445.0|  35682.0|  6082.0|15.0001|   500001.0|\n",
      "+-------+-------+---------+--------+---------+--------+-------+-----------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "(casas_df.describe().select(\n",
    "                    \"summary\",\n",
    "                    F.round(\"medage\", 4).alias(\"medage\"),\n",
    "                    F.round(\"totrooms\", 4).alias(\"totrooms\"),\n",
    "                    F.round(\"totbdrms\", 4).alias(\"totbdrms\"),\n",
    "                    F.round(\"pop\", 4).alias(\"pop\"),\n",
    "                    F.round(\"houshlds\", 4).alias(\"houshlds\"),\n",
    "                    F.round(\"medinc\", 4).alias(\"medinc\"),\n",
    "                    F.round(\"medhv\", 4).alias(\"medhv\"))\n",
    "                    .show())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veja os valores mínimo e máximo de todos os atributos (numéricos). Vemos que vários atributos têm uma ampla gama de valores: precisamos normalizar este conjunto de dados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Pré-processamento de Dados\n",
    "Com todas essas informações que coletamos de nossa pequena análise exploratória de dados, sabemos o suficiente para pré-processar nossos dados para alimentá-los com o modelo.\n",
    "  - não devemos nos preocupar com valores ausentes; todos os valores zero foram excluídos do conjunto de dados.\n",
    "  - Provavelmente, devemos padronizar nossos dados, pois vimos que a faixa de valores mínimos e máximos é bastante grande.\n",
    "  - Possivelmente, podemos adicionar alguns atributos adicionais, como um recurso que registra o número de quartos-de-dormir por quartos ou os quartos por família.\n",
    "  - Nossa variável dependente também é bastante grande; Para facilitar nossa vida, teremos que ajustar um pouco os valores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.1 Pré-processamento dos valores alvo\n",
    "Primeiro, vamos começar com o medianHouseValue, nossa variável dependente. Para facilitar o trabalho com os valores teóricos, expressaremos os valores da casa em unidades de 100.000. Isso significa que um destino como 452600.000000 deve se tornar 4.526:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ajustando os valores de `medianHouseValue`\n",
    "casas_df = casas_df.withColumn(\"medhv\", col(\"medhv\")/100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-----+------+--------+--------+------+--------+------+-----+\n",
      "|   long|  lat|medage|totrooms|totbdrms|   pop|houshlds|medinc|medhv|\n",
      "+-------+-----+------+--------+--------+------+--------+------+-----+\n",
      "|-122.23|37.88|  41.0|   880.0|   129.0| 322.0|   126.0|8.3252|4.526|\n",
      "|-122.22|37.86|  21.0|  7099.0|  1106.0|2401.0|  1138.0|8.3014|3.585|\n",
      "+-------+-----+------+--------+--------+------+--------+------+-----+\n",
      "only showing top 2 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Exibir as 2 primeiras linhas de 'df'\n",
    "casas_df.show(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos ver claramente que os valores foram ajustados corretamente quando analisamos o resultado do método show():"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Engenharia de recursos\n",
    "Agora que ajustamos os valores em medianHouseValue, adicionaremos as seguintes colunas ao conjunto de dados:\n",
    "  - Quartos por domicílio, que se refere ao número de quartos em domicílios por grupo de blocos;\n",
    "  - População por domicílio, o que basicamente nos dá uma indicação de quantas pessoas vivem em domicílios por grupo de quarteirões; E\n",
    "  - Quartos-de-dormir por quarto, o que nos dará uma idéia de quantos quartos são quartos por grupo de blocos;\n",
    "  \n",
    "Como estamos trabalhando com DataFrames, podemos usar melhor o método select() para selecionar as colunas com as quais trabalharemos, ou seja, totalRooms, households e population. Além disso, temos que indicar que estamos trabalhando com colunas adicionando a função col() ao nosso código. Caso contrário, não poderemos executar operações por elementos, como a divisão que temos em mente para essas três variáveis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['long',\n",
       " 'lat',\n",
       " 'medage',\n",
       " 'totrooms',\n",
       " 'totbdrms',\n",
       " 'pop',\n",
       " 'houshlds',\n",
       " 'medinc',\n",
       " 'medhv']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "casas_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adicionando novas colunas ao data frame 'df'\n",
    "casas_df = (casas_df.withColumn(\"rmsperhh\", F.round(col(\"totrooms\")/col(\"houshlds\"), 2))\n",
    "                       .withColumn(\"popperhh\", F.round(col(\"pop\")/col(\"houshlds\"), 2))\n",
    "                       .withColumn(\"bdrmsperrm\", F.round(col(\"totbdrms\")/col(\"totrooms\"), 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-----+------+--------+--------+------+--------+------+-----+--------+--------+----------+\n",
      "|   long|  lat|medage|totrooms|totbdrms|   pop|houshlds|medinc|medhv|rmsperhh|popperhh|bdrmsperrm|\n",
      "+-------+-----+------+--------+--------+------+--------+------+-----+--------+--------+----------+\n",
      "|-122.23|37.88|  41.0|   880.0|   129.0| 322.0|   126.0|8.3252|4.526|    6.98|    2.56|      0.15|\n",
      "|-122.22|37.86|  21.0|  7099.0|  1106.0|2401.0|  1138.0|8.3014|3.585|    6.24|    2.11|      0.16|\n",
      "|-122.24|37.85|  52.0|  1467.0|   190.0| 496.0|   177.0|7.2574|3.521|    8.29|     2.8|      0.13|\n",
      "|-122.25|37.85|  52.0|  1274.0|   235.0| 558.0|   219.0|5.6431|3.413|    5.82|    2.55|      0.18|\n",
      "|-122.25|37.85|  52.0|  1627.0|   280.0| 565.0|   259.0|3.8462|3.422|    6.28|    2.18|      0.17|\n",
      "+-------+-----+------+--------+--------+------+--------+------+-----+--------+--------+----------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Inspecionando o resultado\n",
    "casas_df.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos ver que, na primeira linha, existem cerca de 6,98 quartos por domicílio, os domicílios do grupo de blocos são compostos por cerca de 2,5 pessoas e a quantidade de quartos é bastante baixa com 0,14:\n",
    "\n",
    "Como não queremos necessariamente padronizar nossos valores-alvo, queremos garantir o isolamento dos valores em nosso conjunto de dados. Observe também que este é o momento de deixar de fora as variáveis que talvez não desejemos considerar em nossa análise. Nesse caso, vamos deixar de fora variáveis como longitude, latitude, HousingMedianAge e totalRooms.\n",
    "\n",
    "Nesse caso, usaremos o método select() e passaremos os nomes das colunas na ordem que for mais apropriada. Nesse caso, a variável de destino medianHouseValue é colocada em primeiro lugar, para que não seja afetada pela padronização."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reordenação e seleção das colunas\n",
    "casas_df = casas_df.select(\"medhv\", \n",
    "                              \"totbdrms\", \n",
    "                              \"pop\", \n",
    "                              \"houshlds\", \n",
    "                              \"medinc\", \n",
    "                              \"rmsperhh\", \n",
    "                              \"popperhh\", \n",
    "                              \"bdrmsperrm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.1 Extração de recursos\n",
    "Agora que reorganizamos os dados, estamos prontos para normalizar os dados. Vamos escolher os recursos a serem normalizados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "featureCols = [\"totbdrms\", \"pop\", \"houshlds\", \"medinc\", \"rmsperhh\", \"popperhh\", \"bdrmsperrm\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use um VectorAssembler para colocar recursos em uma coluna de vetor de recursos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# coloca recursos em uma coluna de vetor de recursos\n",
    "assembler = VectorAssembler(inputCols=featureCols, outputCol=\"features\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "assembled_df = assembler.transform(casas_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+--------+------+--------+------+--------+--------+----------+-------------------------------------------------------+\n",
      "|medhv|totbdrms|pop   |houshlds|medinc|rmsperhh|popperhh|bdrmsperrm|features                                               |\n",
      "+-----+--------+------+--------+------+--------+--------+----------+-------------------------------------------------------+\n",
      "|4.526|129.0   |322.0 |126.0   |8.3252|6.98    |2.56    |0.15      |[129.0,322.0,126.0,8.325200080871582,6.98,2.56,0.15]   |\n",
      "|3.585|1106.0  |2401.0|1138.0  |8.3014|6.24    |2.11    |0.16      |[1106.0,2401.0,1138.0,8.301400184631348,6.24,2.11,0.16]|\n",
      "|3.521|190.0   |496.0 |177.0   |7.2574|8.29    |2.8     |0.13      |[190.0,496.0,177.0,7.257400035858154,8.29,2.8,0.13]    |\n",
      "|3.413|235.0   |558.0 |219.0   |5.6431|5.82    |2.55    |0.18      |[235.0,558.0,219.0,5.643099784851074,5.82,2.55,0.18]   |\n",
      "|3.422|280.0   |565.0 |259.0   |3.8462|6.28    |2.18    |0.17      |[280.0,565.0,259.0,3.8461999893188477,6.28,2.18,0.17]  |\n",
      "|2.697|213.0   |413.0 |193.0   |4.0368|4.76    |2.14    |0.23      |[213.0,413.0,193.0,4.036799907684326,4.76,2.14,0.23]   |\n",
      "|2.992|489.0   |1094.0|514.0   |3.6591|4.93    |2.13    |0.19      |[489.0,1094.0,514.0,3.65910005569458,4.93,2.13,0.19]   |\n",
      "|2.414|687.0   |1157.0|647.0   |3.12  |4.8     |1.79    |0.22      |[687.0,1157.0,647.0,3.119999885559082,4.8,1.79,0.22]   |\n",
      "|2.267|665.0   |1206.0|595.0   |2.0804|4.29    |2.03    |0.26      |[665.0,1206.0,595.0,2.080399990081787,4.29,2.03,0.26]  |\n",
      "|2.611|707.0   |1551.0|714.0   |3.6912|4.97    |2.17    |0.2       |[707.0,1551.0,714.0,3.691200017929077,4.97,2.17,0.2]   |\n",
      "+-----+--------+------+--------+------+--------+--------+----------+-------------------------------------------------------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "assembled_df.show(10, truncate=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todos os recursos se transformaram em um vetor denso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.2 Padronização\n",
    "Em seguida, podemos finalmente escalar os dados usando o StandardScaler. As colunas de entrada são os recursos e a coluna de saída com o redimensionado que será incluído no  será denominada \"features_escaladas\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inicialize o `standardScaler`\n",
    "standardScaler = StandardScaler(inputCol=\"features\", outputCol=\"features_escaladas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ajuste o DataFrame ao redimensionador\n",
    "escalar_df = standardScaler.fit(assembled_df).transform(assembled_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------+\n",
      "|features                                               |features_escaladas                                                                                                                    |\n",
      "+-------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------+\n",
      "|[129.0,322.0,126.0,8.325200080871582,6.98,2.56,0.15]   |[0.30623297630686513,0.2843362208866199,0.3295584480852433,4.38209543579743,2.8211223886115664,0.24648542140099877,2.5828740130262697]|\n",
      "|[1106.0,2401.0,1138.0,8.301400184631348,6.24,2.11,0.16]|[2.6255323394991694,2.1201592122632746,2.9764882057222772,4.36956799913841,2.522034914747303,0.20315790592035446,2.755065613894688]   |\n",
      "|[190.0,496.0,177.0,7.257400035858154,8.29,2.8,0.13]    |[0.451040817816313,0.4379837439744208,0.4629511532626037,3.820042673324032,3.3505880518037077,0.2695934296573424,2.238490811289434]   |\n",
      "|[235.0,558.0,219.0,5.643099784851074,5.82,2.55,0.18]   |[0.557866274667545,0.4927317119712234,0.5728039692910182,2.970331231769803,2.3522825647162344,0.2455225877236511,3.099448815631524]   |\n",
      "|[280.0,565.0,259.0,3.8461999893188477,6.28,2.18,0.17]  |[0.664691731518777,0.4989129341644108,0.6774256988418891,2.024505748166202,2.538201805226452,0.20989774166178804,2.9272572147631064]  |\n",
      "|[213.0,413.0,193.0,4.036799907684326,4.76,2.14,0.23]   |[0.5056404957624983,0.364692109398056,0.5047998450829521,2.124830908428931,1.9238599670187757,0.20604640695239743,3.960406819973614]  |\n",
      "|[489.0,1094.0,514.0,3.65910005569458,4.93,2.13,0.19]   |[1.1608366311167213,0.9660367256210006,1.344389224728691,1.9260228580003875,1.9925692515551605,0.20508357327504975,3.271640416499942] |\n",
      "|[687.0,1157.0,647.0,3.119999885559082,4.8,1.79,0.22]   |[1.6308686412621423,1.021667725359687,1.6922564754853369,1.6422593001231023,1.9400268574979251,0.1723472282452296,3.788215219105196]  |\n",
      "|[665.0,1206.0,595.0,2.080399990081787,4.29,2.03,0.26]  |[1.5786428623570954,1.0649362807119989,1.5562482270692046,1.0950501144251168,1.7338990038887707,0.19545523650157323,4.476981622578868]|\n",
      "|[707.0,1551.0,714.0,3.691200017929077,4.97,2.17,0.2]   |[1.678346622084912,1.3695822316619488,1.8674978724830456,1.9429191603871925,2.00873614203431,0.20893490798444037,3.44383201736836]    |\n",
      "+-------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Inspecionando o resultado\n",
    "escalar_df.select(\"features\", \"features_escaladas\").show(10, truncate=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Construindo um modelo de aprendizado de máquina com Spark ML\n",
    "\n",
    "Com todo o pré-processamento concluído, finalmente chegou a hora de começar a construir nosso modelo de regressão linear! Como sempre, primeiro precisamos dividir os dados em conjuntos de treinamento e teste. Felizmente, isso não é problema com o método randomSplit():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Divida os dados em conjuntos de treino e teste\n",
    "treino_data, teste_data = escalar_df.randomSplit([.8,.2], seed=rnd_seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Passamos em uma lista com dois números que representam o tamanho que queremos que seus conjuntos de treinamento e teste tenham e uma semente, necessária para fins de reprodutibilidade.\n",
    "\n",
    "Observe que o argumento elasticNetParam corresponde a α ou a interceptação vertical e que o regParam ou o parâmetro de regularização corresponde a λ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['medhv',\n",
       " 'totbdrms',\n",
       " 'pop',\n",
       " 'houshlds',\n",
       " 'medinc',\n",
       " 'rmsperhh',\n",
       " 'popperhh',\n",
       " 'bdrmsperrm',\n",
       " 'features',\n",
       " 'features_escaladas']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "treino_data.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Criação de um modelo ElasticNet:\n",
    "    \n",
    "ElasticNet é um modelo de regressão linear treinado com L1 e L2 como regularizador. Essa combinação permite aprender um modelo esparso, em que poucos pesos são diferentes de zero como Lasso, mantendo as propriedades de regularização do Ridge. Controlamos a combinação convexa de L1 e L2 usando o parâmetro l1_ratio.    \n",
    "\n",
    "A rede elástica é útil quando existem vários recursos correlacionados entre si. É provável que o Lasso escolha um deles aleatoriamente, enquanto a rede elástica provavelmente escolha ambos.\n",
    "\n",
    "Uma vantagem prática da troca entre Lasso e Ridge é que ela permite que a Elastic-Net herde parte da estabilidade de Ridge em rotação."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Inicializar 'lr'\n",
    "lr = (LinearRegression(featuresCol='features_escaladas', labelCol=\"medhv\", predictionCol='predmedhv', \n",
    "                               maxIter=10, regParam=0.3, elasticNetParam=0.8, standardization=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ajustando os dados ao modelo\n",
    "linearModel = lr.fit(treino_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Avaliando o modelo\n",
    "\n",
    "Com nosso modelo, podemos gerar previsões para nossos dados de teste: use o método transform() para prever os rótulos para nossos dados de teste. Em seguida, podemos usar operações RDD para extrair as previsões e os rótulos verdadeiros do DataFrame."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.1 Inspecionar os coeficientes do modelo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DenseVector([0.0, 0.0, 0.0, 0.526, 0.0, 0.0, 0.0])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Coeficientes para o modelo\n",
    "linearModel.coefficients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['totbdrms', 'pop', 'houshlds', 'medinc', 'rmsperhh', 'popperhh', 'bdrmsperrm']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "featureCols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.989875772139301"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Interceptação para o modelo\n",
    "linearModel.intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "coeff_df = pd.DataFrame({\"Feature\": [\"Intercept\"] + featureCols, \"Co-efficients\": np.insert(linearModel.coefficients.toArray(), 0, linearModel.intercept)})\n",
    "coeff_df = coeff_df[[\"Feature\", \"Co-efficients\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Feature</th>\n",
       "      <th>Co-efficients</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>Intercept</td>\n",
       "      <td>0.989876</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>totbdrms</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>pop</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>houshlds</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>medinc</td>\n",
       "      <td>0.526024</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>rmsperhh</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>popperhh</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>bdrmsperrm</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Feature  Co-efficients\n",
       "0   Intercept       0.989876\n",
       "1    totbdrms       0.000000\n",
       "2         pop       0.000000\n",
       "3    houshlds       0.000000\n",
       "4      medinc       0.526024\n",
       "5    rmsperhh       0.000000\n",
       "6    popperhh       0.000000\n",
       "7  bdrmsperrm       0.000000"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coeff_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.2 Gerando previsões"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# geração de previsões\n",
    "predictions = linearModel.transform(teste_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extração das previsões e os rótulos corretos \"conhecidos\"\n",
    "predandlabels = predictions.select(\"predmedhv\", \"medhv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------------------+-----+\n",
      "|         predmedhv|medhv|\n",
      "+------------------+-----+\n",
      "|1.5977678077735522|0.269|\n",
      "|1.3402962575651638|0.275|\n",
      "|1.7478926681617617|0.283|\n",
      "|1.5026315463850333|0.325|\n",
      "|1.5840068859455108|0.344|\n",
      "|1.4744173855604754|0.379|\n",
      "|1.5274954532293994|0.388|\n",
      "|1.3578228236744827|0.394|\n",
      "|1.6929041021688493|  0.4|\n",
      "| 2.010874171848204|  0.4|\n",
      "|1.3656308740705367| 0.41|\n",
      "|1.4496919091430263|0.421|\n",
      "| 1.380970081002033|0.425|\n",
      "|1.3394379493101451| 0.43|\n",
      "| 1.722973408950696|0.435|\n",
      "|1.5529131147882111|0.439|\n",
      "| 1.323489602290725| 0.44|\n",
      "|1.4030651812673915|0.444|\n",
      "|1.5111871672959283|0.446|\n",
      "|1.5996783060975408| 0.45|\n",
      "+------------------+-----+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "predandlabels.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.3 Inspecionar as métricas\n",
    "Observar os valores previstos é uma coisa, mas outra coisa melhor é observar algumas métricas para ter uma idéia melhor de quão bom é o seu modelo.\n",
    "\n",
    "Usando o atributo LinearRegressionModel.summary:\n",
    "Em seguida, também podemos usar o atributo summary para acessar o rootMeanSquaredError e o r2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE: 0.8729980899366503\n"
     ]
    }
   ],
   "source": [
    "# Obter o RMSE\n",
    "print(\"RMSE: {0}\".format(linearModel.summary.rootMeanSquaredError))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE: 0.6714989215155925\n"
     ]
    }
   ],
   "source": [
    "print(\"MAE: {0}\".format(linearModel.summary.meanAbsoluteError))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R2: 0.42213332730120356\n"
     ]
    }
   ],
   "source": [
    "# Obter o R2\n",
    "print(\"R2: {0}\".format(linearModel.summary.r2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  - O RMSE mede quanto erro há entre dois conjuntos de dados comparando um valor previsto e um valor observado ou conhecido. Quanto menor um valor RMSE, mais próximos são os valores previstos e observados.\n",
    "  \n",
    "  - O R2 (\"R ao quadrado\") ou o coeficiente de determinação é uma medida que mostra quão próximos os dados estão da linha de regressão ajustada. Essa pontuação sempre estará entre 0 e 100% (neste caso, de 0 a 1), onde 0% indica que o modelo não explica a variabilidade dos dados de resposta em torno de sua média e 100% indica o contrário: explica toda a variabilidade. Isso significa que, em geral, quanto maior o quadrado R, melhor o modelo se ajusta aos nossos dados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando o pacote RegressionEvaluator do pyspark.ml:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE: 0.9033627063798556\n"
     ]
    }
   ],
   "source": [
    "evaluator = RegressionEvaluator(predictionCol=\"predmedhv\", labelCol='medhv', metricName='rmse')\n",
    "print(\"RMSE: {0}\".format(evaluator.evaluate(predandlabels)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE: 0.6888437385796472\n"
     ]
    }
   ],
   "source": [
    "evaluator = RegressionEvaluator(predictionCol=\"predmedhv\", labelCol='medhv', metricName='mae')\n",
    "print(\"MAE: {0}\".format(evaluator.evaluate(predandlabels)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R2: 0.40877519027090536\n"
     ]
    }
   ],
   "source": [
    "evaluator = RegressionEvaluator(predictionCol=\"predmedhv\", labelCol='medhv', metricName='r2')\n",
    "print(\"R2: {0}\".format(evaluator.evaluate(predandlabels)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando o pacote RegressionMetrics do pyspark.mllib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mllib é antigo, portanto os métodos estão disponíveis no rdd\n",
    "metrics = RegressionMetrics(predandlabels.rdd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE: 0.9033627063798556\n"
     ]
    }
   ],
   "source": [
    "print(\"RMSE: {0}\".format(metrics.rootMeanSquaredError))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE: 0.6888437385796472\n"
     ]
    }
   ],
   "source": [
    "print(\"MAE: {0}\".format(metrics.meanAbsoluteError))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R2: 0.40877519027090536\n"
     ]
    }
   ],
   "source": [
    "print(\"R2: {0}\".format(metrics.r2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definitivamente, existem algumas melhorias necessárias para o nosso modelo! Se quisermos continuar com esse modelo, podemos brincar com os parâmetros que passamos para o seu modelo, as variáveis que incluímos no seu DataFrame original."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Para o serviço do PySpark\n",
    "spark.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dê sua opinião e possíveis melhorias no nosso modelo.\n",
    "Comente no artigo do blog\n",
    "\n",
    "Referencias:\n",
    "https://www.kaggle.com/\n",
    "https://scikit-learn.org/stable/modules/linear_model.html#elastic-net\n",
    "\n",
    "Obrigado, e bons estudos"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}