<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 10</font>
Download
Step1:  Carregando os Dados
Boston House Prices Dataset
https
Step2:  Vamos dividir os dados em treino e teste com proporção 80/20.
Step3:  Modelagem Preditiva - Regressão Linear Simples
Na regressão linear simples desejamos modelar a relação entre a variável dependente (y) e uma variável independente (x).
Variável independente
Step4:  Vamos separar x e y.
Step5:  Criação do Modelo
Queremos encontrar os parâmetros (W) que permitem prever a saída y a partir da entrada x
Step6:  MAE = Mean Absolute Error
MSE = Mean Squared Error
Step7:  Treinamento do Modelo
Step8:  MSE = Mean Squared Error
<ASSISTANT_TASK:>
Python Code:
# Versão da Linguagem Python
from platform import python_version
print('Versão da Linguagem Python Usada Neste Jupyter Notebook:', python_version())
# Instala o TensorFlow
!pip install -q tensorflow==2.5
# Instala o Pydot
!pip install -q pydot
# Imports
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
# Imports
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
Explanation: <font color='blue'>Data Science Academy - Python Fundamentos - Capítulo 10</font>
Download: http://github.com/dsacademybr
Mini-Projeto 3 - Guia de Modelagem Preditiva com Linguagem Python e TensorFlow
Neste Mini-Projeto vamos apresentar um guia básico de modelagem preditiva usando Linguagem Python e TensorFlow, o principal framework para construção de modelos de Machine Learning e Deep Learning e para construir aplicações comerciais de Inteligência Artificial.
Este é um guia básico pois o TensorFlow é um framework extenso. O TensorFlow é abordado em detalhes nos cursos da <a href="https://www.datascienceacademy.com.br/bundle/formacao-inteligencia-artificial">Formação Inteligência Artificial</a> (especialmente no curso Deep Learning Frameworks) e na <a href="https://www.datascienceacademy.com.br/bundle/formacao-inteligencia-artificial-aplicada-a-medicina">Formação IA Aplicada à Medicina</a>.
Na <a href="https://www.datascienceacademy.com.br/bundle/formacao-cientista-de-dados">Formação Cientista de Dados</a>, no curso de Machine Learning também há um módulo sobre TensorFlow. Alguns projetos com TensorFlow podem ser encontrados no curso de IA Aplicada a Finanças da <a href="https://www.datascienceacademy.com.br/bundle/formacao-engenheiro-blockchain">Formação Engenheiro Blockchain</a>.
Instalando e Carregando Pacotes
End of explanation
# Download dos dados
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
dataset_path = keras.utils.get_file("housing.data", "https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.data")
# Nomes das colunas
nomes_colunas = ['CRIM',
                 'ZN',
                 'INDUS',
                 'CHAS',
                 'NOX',
                 'RM', 
                 'AGE', 
                 'DIS',
                 'RAD',
                 'TAX',
                 'PTRATION', 
                 'B', 
                 'LSTAT', 
                 'MEDV']
# Carrega os dados
dataset = pd.read_csv(dataset_path, 
                      names = nomes_colunas,
                      na_values = "?", 
                      comment = '\t',
                      sep = " ", 
                      skipinitialspace = True)
# Shape
dataset.shape
# Visualiza os dados
dataset.head()
Explanation: Carregando os Dados
Boston House Prices Dataset
https://www.cs.toronto.edu/~delve/data/boston/bostonDetail.html
Características:
Número de Observções: 506
Os primeiros 13 recursos são recursos preditivos numéricos / categóricos. 
O último (atributo 14): o valor mediano é a variável de destino.
End of explanation
# Split dos dados
dados_treino = dataset.sample(frac = 0.8, random_state = 0)
dados_teste = dataset.drop(dados_treino.index)
Explanation: Vamos dividir os dados em treino e teste com proporção 80/20.
End of explanation
# Representação visual dos dados de treino
fig, ax = plt.subplots()
x = dados_treino['RM']
y = dados_treino['MEDV']
ax.scatter(x, y, edgecolors = (0, 0, 0))
ax.set_xlabel('RM')
ax.set_ylabel('MEDV')
plt.show()
Explanation: Modelagem Preditiva - Regressão Linear Simples
Na regressão linear simples desejamos modelar a relação entre a variável dependente (y) e uma variável independente (x).
Variável independente: 'RM'
Variável dependente: 'MEDV'
Queremos prever o valor da mediana das casas ocupadas por proprietários com base no número de quartos.
Vamos criar um plot mostrando a relação atual entre as variáveis.
Basicamente temos $MEDV=f(RM)$ e queremos estimar a função $f()$ usando regressão linear.
End of explanation
# Divisão
x_treino = dados_treino['RM']
y_treino = dados_treino['MEDV']
x_teste = dados_teste['RM']
y_teste = dados_teste['MEDV']
Explanation: Vamos separar x e y.
End of explanation
# Função para construir o modelo
def modelo_linear():
    
    # Cria o modelo
    model = keras.Sequential([layers.Dense(1, use_bias = True, input_shape = (1,), name = 'layer')])
    # Otimizador
    optimizer = tf.keras.optimizers.Adam(learning_rate = 0.01, 
                                         beta_1 = 0.9, 
                                         beta_2 = 0.99, 
                                         epsilon = 1e-05, 
                                         amsgrad = False, 
                                         name = 'Adam')
    
    # Compila o modelo
    model.compile(loss = 'mse', 
                  optimizer = optimizer, 
                  metrics = ['mae','mse'])
    return model
Explanation: Criação do Modelo
Queremos encontrar os parâmetros (W) que permitem prever a saída y a partir da entrada x:
$y = w_1 x + w_0$
A fórmula acima pode ser definida com a seguinte camada densa em um modelo de rede neural artificial:
layers.Dense(1, use_bias=True, input_shape=(1,))
End of explanation
# Cria o modelo 
modelo = modelo_linear()
# Plot do modelo
tf.keras.utils.plot_model(modelo, 
                          to_file = 'imagens/modelo.png', 
                          show_shapes = True, 
                          show_layer_names = True,
                          rankdir = 'TB', 
                          expand_nested = False, 
                          dpi = 100)
Explanation: MAE = Mean Absolute Error
MSE = Mean Squared Error
End of explanation
# Hiperparâmetros
n_epochs = 4000
batch_size = 256
n_idle_epochs = 100
n_epochs_log = 200
n_samples_save = n_epochs_log * x_treino.shape[0]
print('Checkpoint salvo a cada {} amostras'.format(n_samples_save))
# Callback
earlyStopping = tf.keras.callbacks.EarlyStopping(monitor = 'val_loss', 
                                                 patience = n_idle_epochs, 
                                                 min_delta = 0.001)
# Lista para as previsões
predictions_list = []
# Caminho ppara salvar o checkpoint
checkpoint_path = "dados/"
# Create a callback that saves the model's weights every n_samples_save
checkpointCallback = tf.keras.callbacks.ModelCheckpoint(filepath = "dados/", 
                                                        verbose = 1, 
                                                        save_weights_only = True,
                                                        save_freq = n_samples_save)
# Salva a primeira versão do modelo
modelo.save_weights(checkpoint_path.format(epoch = 0))
# Treinamento
history = modelo.fit(x_treino, 
                     y_treino, 
                     batch_size = batch_size,
                     epochs = n_epochs, 
                     validation_split = 0.1, 
                     verbose = 1, 
                     callbacks = [earlyStopping, checkpointCallback])
# Métricas do histórico de treinamento
print('keys:', history.history.keys())
Explanation: Treinamento do Modelo
End of explanation
# Retornando os valores desejados para o plot
mse = np.asarray(history.history['mse'])
val_mse = np.asarray(history.history['val_mse'])
# Prepara os valores para o dataframe
num_values = (len(mse))
values = np.zeros((num_values, 2), dtype = float)
values[:,0] = mse
values[:,1] = val_mse
# Cria o dataframe
steps = pd.RangeIndex(start = 0, stop = num_values)
df = pd.DataFrame(values, steps, columns = ["MSE em Treino", "MSE em Validação"])
df.head()
# Plot
sns.set(style = "whitegrid")
sns.lineplot(data = df, palette = "tab10", linewidth  = 2.5)
# Previsões com o modelo treinado
previsoes = modelo.predict(x_teste).flatten()
# Imprime as previsões
previsoes
Explanation: MSE = Mean Squared Error
End of explanation
<END_TASK>