<jupyter_start><jupyter_text>7. Series Temporais<jupyter_code>import pandas as pd 
import numpy as np
from matplotlib import pyplot as plt
import seaborn as sns
import datetime<jupyter_output><empty_output><jupyter_text>Lendo o dataset para o formato de dataframe<jupyter_code>df_poluicao_beijing = pd.read_csv("PRSA_data_2010.1.1-2014.12.31.csv")<jupyter_output><empty_output><jupyter_text>Conhecendo o dataset<jupyter_code>df_poluicao_beijing.head()<jupyter_output><empty_output><jupyter_text>Verificando o shape do dataset<jupyter_code>df_poluicao_beijing.shape<jupyter_output><empty_output><jupyter_text>Verificando o formato do dataset<jupyter_code>df_poluicao_beijing.info()<jupyter_output><class 'pandas.core.frame.DataFrame'>
RangeIndex: 43824 entries, 0 to 43823
Data columns (total 13 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   No      43824 non-null  int64  
 1   year    43824 non-null  int64  
 2   month   43824 non-null  int64  
 3   day     43824 non-null  int64  
 4   hour    43824 non-null  int64  
 5   pm2.5   41757 non-null  float64
 6   DEWP    43824 non-null  int64  
 7   TEMP    43824 non-null  float64
 8   PRES    43824 non-null  float64
 9   cbwd    43824 non-null  object 
 10  Iws     43824 non-null  float64
 11  Is      43824 non-null  int64  
 12  Ir      43824 non-null  int64  
dtypes: float64(4), int64(8), object(1)
memory usage: 4.3+ MB<jupyter_text>Contando valores nulos<jupyter_code>df_poluicao_beijing.isnull().sum()<jupyter_output><empty_output><jupyter_text>Obtendo os dados em formato de datetime<jupyter_code>df_poluicao_beijing['datetime'] = df_poluicao_beijing[['year', 'month', 'day', 'hour']].apply(lambda row: datetime.datetime(year=row['year'],month=row['month'], day=row['day'],hour=row['hour']), axis=1)<jupyter_output><empty_output><jupyter_text>Mostrando a modificação<jupyter_code>df_poluicao_beijing.head()<jupyter_output><empty_output><jupyter_text>Encontrando as datas máximas e mínimas do dataset<jupyter_code>print('Data inicial de coleta',df_poluicao_beijing['datetime'].min())
print('Data final de coleta',df_poluicao_beijing['datetime'].max())
df_pressao_atmosferica = df_poluicao_beijing[['datetime','PRES']] #pressão em hPa
df_pressao_atmosferica.head()
df_pressao_atmosferica.sort_values('datetime', ascending=True, inplace=True) #ordenando os valores pela data
df_pressao_atmosferica.head()<jupyter_output><empty_output><jupyter_text>Verificando possíveis outlier com o boxplot<jupyter_code>plt.figure(figsize=(7, 7))
g = sns.boxplot(df_pressao_atmosferica['PRES'])
g.set_title('Box plot para a Pressão Atmosférica')<jupyter_output>C:\Users\Vithep\anaconda3\lib\site-packages\seaborn\_decorators.py:36: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.
  warnings.warn(<jupyter_text>Plotando os valores de pressão atmosférica<jupyter_code>plt.figure(figsize=(7, 7))
g = sns.lineplot(x=df_pressao_atmosferica.index,y=df_pressao_atmosferica['PRES'])
g.set_title('Serie temporal para a pressão atmosférica')
g.set_xlabel('Indice do dataset')
g.set_ylabel('Pressão Atmosférica em hPa')<jupyter_output><empty_output><jupyter_text>**Preparando os dados para serem utilizados no modelo de previsão via MLP**<jupyter_code>from sklearn.preprocessing import MinMaxScaler  #aplicando a normalização dos dados
scaler = MinMaxScaler(feature_range=(0, 1))  #define o intervalor entre 0 e 1 para os dados serem normalizados
df_pressao_atmosferica['PRES_normalizado'] = scaler.fit_transform(np.array(df_pressao_atmosferica['PRES']).reshape(-1, 1))
df_pressao_atmosferica.head()<jupyter_output><empty_output><jupyter_text>Dividindo os dados entre treinamento e teste<jupyter_code>data_de_corte = datetime.datetime(year=2014, month=1, day=1, hour=0)  #difine a data de corte para 01/01/2014
df_treinamento = df_pressao_atmosferica.loc[df_pressao_atmosferica['datetime']<data_de_corte]
df_teste = df_pressao_atmosferica.loc[df_pressao_atmosferica['datetime']>=data_de_corte]
print('Quantidade de dados para treinamento:', df_treinamento.shape)
print('Quantidade de dados para teste:', df_teste.shape)<jupyter_output>Quantidade de dados para treinamento: (35064, 3)
Quantidade de dados para teste: (8760, 3)<jupyter_text>Verificando "a cara" dos dados de treinamento<jupyter_code>plt.figure(figsize=(7, 7))
g = sns.lineplot(x=df_treinamento.index,y=df_treinamento['PRES_normalizado'], color='b')
g.set_title('Série Temporal para a pressão normalizada no treinamento do modelo')
g.set_xlabel('Indices')
g.set_ylabel('Leituras normalizadas')<jupyter_output><empty_output><jupyter_text>Verificando "a cara" dos dados de teste<jupyter_code>plt.figure(figsize=(7, 7))
g = sns.lineplot(x=df_teste.index,y=df_teste['PRES_normalizado'], color='r')
g.set_title('Série Temporal para a pressão normalizada no teste do modelo')
g.set_xlabel('Indices')
g.set_ylabel('Leituras normalizadas')<jupyter_output><empty_output><jupyter_text>Definindo o número de valores a serem utilizados para a previsão<jupyter_code>def formata_entrada_saida(serie_temporal_original, numero_de_passos):
    
    X = []
    y = []
    for i in range(numero_de_passos, serie_temporal_original.shape[0]):
        X.append(list(serie_temporal_original.loc[i-numero_de_passos:i-1]))
        y.append(serie_temporal_original.loc[i])
    X, y = np.array(X), np.array(y)
    return X, y<jupyter_output><empty_output><jupyter_text>Formata os dados para o treinamento do modelo<jupyter_code>X_train, y_train = formata_entrada_saida(df_treinamento['PRES_normalizado'], 10)
print('Formato dos dados:', X_train.shape, y_train.shape)
X_train[1:15,:]
X_teste, y_teste = formata_entrada_saida(df_teste['PRES_normalizado'].reset_index(drop=True),10)
print('Formato dos dados de normalizacao:', X_teste.shape, y_teste.shape)
X_teste[1:15,:]<jupyter_output><empty_output><jupyter_text>**Inicia o processo de construção da Previsão via MLP**  Importando as bibliotecas<jupyter_code>import tensorflow as tf
from tensorflow.keras.layers import Dense, Input, Dropout  #define os tipos de camadas a serem utilizadas pelo modelo
from tensorflow.keras.optimizers import SGD  #define o modelo de otimização via gradiente descendente<jupyter_output><empty_output><jupyter_text>Define a camada de entrada<jupyter_code>camada_entrada = Input(shape=(10,), dtype='float32')<jupyter_output><empty_output><jupyter_text>Adiciona as camadas escondidas<jupyter_code>densa1 = Dense(32, activation='linear')(camada_entrada)
densa2 = Dense(16, activation='linear')(densa1)
densa3 = Dense(16, activation='linear')(densa2)<jupyter_output><empty_output><jupyter_text>Adiciona a camada de dropout como forma de regularização do modelo (ajuda a evitar overfitting)<jupyter_code>camada_dropout = Dropout(0.2)(densa3)<jupyter_output><empty_output><jupyter_text>Camada de saída da rede (1 dimensão, pois queremos prever a pressão atmosférica baseada em valores anteriores)<jupyter_code>camada_de_saida = Dense(1, activation='linear')(camada_dropout)<jupyter_output><empty_output><jupyter_text>Definindo o modelo MLP<jupyter_code>modelo_MLP = tf.keras.Model(inputs=camada_entrada, outputs=camada_de_saida)<jupyter_output><empty_output><jupyter_text>Mostrando as características do modelo<jupyter_code>modelo_MLP.summary()<jupyter_output>Model: "model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         [(None, 10)]              0         
_________________________________________________________________
dense (Dense)                (None, 32)                352       
_________________________________________________________________
dense_1 (Dense)              (None, 16)                528       
_________________________________________________________________
dense_2 (Dense)              (None, 16)                272       
_________________________________________________________________
dropout (Dropout)            (None, 16)                0         
_________________________________________________________________
dense_3 (Dense)              (None, 1)                 17        
=============================================================[...]<jupyter_text>Definindo a função de erro e o otimizador a ser utilizado<jupyter_code>modelo_MLP.compile(loss='mean_squared_error', optimizer='adam')  #função perda MSE e otimizador de Adam<jupyter_output><empty_output><jupyter_text>Treina o modelo<jupyter_code>modelo_MLP.fit(x=X_train, y=y_train, batch_size=16, epochs=20,verbose=1, shuffle=True)<jupyter_output>Epoch 1/20
2191/2191 [==============================] - 4s 1ms/step - loss: 0.0264
Epoch 2/20
2191/2191 [==============================] - 3s 1ms/step - loss: 0.0019
Epoch 3/20
2191/2191 [==============================] - 3s 1ms/step - loss: 9.3029e-04
Epoch 4/20
2191/2191 [==============================] - 3s 1ms/step - loss: 8.6268e-04
Epoch 5/20
2191/2191 [==============================] - 3s 1ms/step - loss: 8.4127e-04
Epoch 6/20
2191/2191 [==============================] - 3s 1ms/step - loss: 7.9504e-04
Epoch 7/20
2191/2191 [==============================] - 3s 1ms/step - loss: 7.9002e-04
Epoch 8/20
2191/2191 [==============================] - 3s 1ms/step - loss: 7.8261e-04
Epoch 9/20
2191/2191 [==============================] - 3s 1ms/step - loss: 7.9185e-04
Epoch 10/20
2191/2191 [==============================] - 3s 1ms/step - loss: 7.9024e-04
Epoch 11/20
2191/2191 [==============================] - 3s 1ms/step - loss: 7.8194e-04
Epoch 12/20
2191/2191 [==========================[...]<jupyter_text>Realiza a previsão com o modelo MLP<jupyter_code>previsao = modelo_MLP.predict(X_teste)
previsao_PRES = scaler.inverse_transform(previsao)  #aplica o inverso da transformação
previsao_PRES.shape
previsao_PRES = np.squeeze(previsao_PRES)  #remove entradas de uma dimensão
previsao_PRES.shape
from sklearn.metrics import r2_score  #importa o coeficiente de determinação
r2 = r2_score(df_teste['PRES'].iloc[10:], previsao_PRES)
print('Coeficiente de Determinação Para o Teste (MLP):', round(r2,4))<jupyter_output>Coeficiente de Determinação Para o Teste (MLP): 0.9893<jupyter_text>Plotando os valores reais x previstos<jupyter_code>plt.figure(figsize=(7,7))
plt.plot(range(50), df_teste['PRES'].iloc[10:60], linestyle='-', marker='*', color='r')
plt.plot(range(50), previsao_PRES[:50], linestyle='-', marker='.', color='b')
plt.legend(['Real','Previsto'], loc=2)
plt.title('Valor de Pressão Atmosferica Medido vs Valor de Pressão Atmosférica Previsto (MLP)')
plt.ylabel('Pressão Atmosférica')
plt.xlabel('Indice')<jupyter_output><empty_output><jupyter_text>**Inciando o processo de previsão via CNN**<jupyter_code>from tensorflow.keras.layers import Flatten  #camada flatten para transformar os dados em uma dimensão 
from tensorflow.keras.layers import ZeroPadding1D  #completa os dados após a convolução
from tensorflow.keras.layers import Conv1D  #camada de convolução
from tensorflow.keras.layers import AveragePooling1D  #camada de redução (média dos dados encontrados)<jupyter_output><empty_output><jupyter_text>Define a camada de entrada<jupyter_code>camada_entrada = Input(shape=(10,1), dtype='float32')<jupyter_output><empty_output><jupyter_text>Adiciona a camada de padding<jupyter_code>camada_padding = ZeroPadding1D(padding=1)(camada_entrada)  #matém a quantidade de dados<jupyter_output><empty_output><jupyter_text>Adiciona a camada de convolução<jupyter_code>camada_convolucao_1D = Conv1D(64, 3, strides=1, use_bias=True)(camada_padding) #adiciona 64 filtros com uma janela de convolução=3<jupyter_output><empty_output><jupyter_text>Camada de pooling<jupyter_code>camada_pooling = AveragePooling1D(pool_size=3, strides=1)(camada_convolucao_1D)  #reduz através do valor médio encontrado para a convolução (pode ser também o valor máximo)<jupyter_output><empty_output><jupyter_text>Camada flatten<jupyter_code>camada_flatten = Flatten()(camada_pooling) #utilizada para realizar o "reshape" dos dados para um vetor<jupyter_output><empty_output><jupyter_text>Adicionando a camada de dropout<jupyter_code>camada_dropout_cnn = Dropout(0.2)(camada_flatten)<jupyter_output><empty_output><jupyter_text>Camada de saída<jupyter_code>camada_saida = Dense(1, activation='linear')(camada_dropout_cnn)<jupyter_output><empty_output><jupyter_text>Contruindo o modelo<jupyter_code>modelo_CNN = tf.keras.Model(inputs=camada_entrada, outputs=camada_saida)<jupyter_output><empty_output><jupyter_text>Mostrando o modelo<jupyter_code>modelo_CNN.summary()<jupyter_output>Model: "model_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_2 (InputLayer)         [(None, 10, 1)]           0         
_________________________________________________________________
zero_padding1d (ZeroPadding1 (None, 12, 1)             0         
_________________________________________________________________
conv1d (Conv1D)              (None, 10, 64)            256       
_________________________________________________________________
average_pooling1d (AveragePo (None, 8, 64)             0         
_________________________________________________________________
flatten (Flatten)            (None, 512)               0         
_________________________________________________________________
dropout_1 (Dropout)          (None, 512)               0         
___________________________________________________________[...]<jupyter_text>Adionando a função perda e o otimizados<jupyter_code>modelo_CNN.compile(loss='mean_absolute_error', optimizer='adam')<jupyter_output><empty_output><jupyter_text>Transforma os dados de treinamento e teste para o 3D, pois a rede CNN exige essa transformação<jupyter_code>X_train, X_teste = X_train.reshape((X_train.shape[0], X_train.shape[1], 1)),X_teste.reshape((X_teste.shape[0], X_teste.shape[1], 1))
print('Formatos para o treinamento e teste:', X_train.shape, X_teste.shape)<jupyter_output>Formatos para o treinamento e teste: (35054, 10, 1) (8750, 10, 1)<jupyter_text>Realizando o treinamento do modelo<jupyter_code>modelo_CNN.fit(x=X_train, y=y_train, batch_size=16, epochs=20,verbose=1,shuffle=True)<jupyter_output>Epoch 1/20
2191/2191 [==============================] - 6s 2ms/step - loss: 0.0421
Epoch 2/20
2191/2191 [==============================] - 5s 2ms/step - loss: 0.0188
Epoch 3/20
2191/2191 [==============================] - 5s 2ms/step - loss: 0.0157
Epoch 4/20
2191/2191 [==============================] - 4s 2ms/step - loss: 0.0151
Epoch 5/20
2191/2191 [==============================] - 4s 2ms/step - loss: 0.0141
Epoch 6/20
2191/2191 [==============================] - 5s 2ms/step - loss: 0.0138
Epoch 7/20
2191/2191 [==============================] - 5s 2ms/step - loss: 0.0136
Epoch 8/20
2191/2191 [==============================] - 4s 2ms/step - loss: 0.0135
Epoch 9/20
2191/2191 [==============================] - 4s 2ms/step - loss: 0.0137
Epoch 10/20
2191/2191 [==============================] - 4s 2ms/step - loss: 0.0135
Epoch 11/20
2191/2191 [==============================] - 4s 2ms/step - loss: 0.0134
Epoch 12/20
2191/2191 [==============================] - 4s 2ms/step - loss: 0.0132
E[...]<jupyter_text>Previsão CNN<jupyter_code>previsao_cnn = modelo_CNN.predict(X_teste)
PRES_cnn = np.squeeze(scaler.inverse_transform(previsao_cnn))
r2_cnn = r2_score(df_teste['PRES'].iloc[10:], PRES_cnn)
print('Coeficiente de Determinação Para o Teste (CNN):', round(r2, 4))<jupyter_output>Coeficiente de Determinação Para o Teste (CNN): 0.9893<jupyter_text>Plotando os valores reais x previstos<jupyter_code>plt.figure(figsize=(7,7))
plt.plot(range(50), df_teste['PRES'].iloc[10:60], linestyle='-', marker='*', color='r')
plt.plot(range(50), PRES_cnn[:50], linestyle='-', marker='.', color='b')
plt.legend(['Real','Previsto'], loc=2)
plt.title('Valor de Pressão Atmosferica Medido vs Valor de Pressão Atmosférica Previsto (CNN)')
plt.ylabel('Pressão Atmosférica')
plt.xlabel('Indice')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1604235524544008, 'fraction_numerical': 0.051536295752234056, 'mean_word_length': 6.333482944344704, 'pattern_counts': {'":': 0, '<': 165, '<?xml version=': 0, '>': 165, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '43', 'dir': 'jupyter-structured-clean-dedup', 'id': '572606', 'license': 'MIT', 'n_tokens_mistral': 6384, 'n_tokens_neox': 5741, 'n_words': 1116, 'path': '02. Processamento de Linguagem Natural/07. Series Temporais.ipynb', 'repo_name': 'vithep/Bootcamp-MachineLearning', 'size': '16338'}