<jupyter_start><jupyter_text><jupyter_code>import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import datetime
import seaborn as sns
from google.colab import files

upload = files.upload()

data = pd.read_csv('international-airline-passengers.csv', names = ['Month', 'Passengers'])
data.head()
data = data.iloc[1:, :]
data = data.dropna().reset_index(drop = True)
data.head()
data.info()
 data.Passengers = pd.to_numeric(data.Passengers)
data.info()
data['datetime'] = pd.to_datetime(data['Month'])
data.head()
data.info()
plt.figure(figsize = (10, 8))
g = sns.boxplot(data['Passengers'])
g.set_title('Box plot para o embarque de passageiros')
plt.figure(figsize = (20, 10))
g = sns.lineplot(x = data.index, y = data['Passengers'])
g.set_title('Série temporal do embarque de passageiros')
g.set_xlabel('Indica')
g.set_ylabel('Numero de passageiros de viagens de aviao')
plt.show()
# Realizando a decomposição da serie temporal

from statsmodels.tsa.seasonal import seasonal_decompose

data_temporal = data.set_index('datetime')
data_temporal.columns
data_temporal.drop('Month', axis = 1, inplace = True)
data_temporal.head()
# realizando a construção do modelo de decomposição da série temporal

decomposicao_aditiva = seasonal_decompose(data_temporal, model = 'aditive', extrapolate_trend= 'freq') # aplica o modelo de decomposição aditiva
# realiza o plot da decomposição
from pylab import rcParams
rcParams['figure.figsize'] = 18, 8
fig = decomposicao_aditiva.plot()
plt.show()

# testando a estacionaridade da série temporal

from statsmodels.tsa.stattools import adfuller # importando o teste ADF


resultado_ADF = adfuller(data_temporal.Passengers.values, autolag = 'AIC') # aplica o teste adf
# para o test ADF a hipotese nula é que existe, pelo menos, uma raiz negativa na série temporal ( série é não estacionaira )

print(f'ADF P-valor: {resultado_ADF[1]}' ) # p - value  é o segundo parametro que retorna da função
# com o p-value maior que 0.05 a hipotese nula não é rejeitada, logo nao é estacionaria
resultado_ADF
# retirando a tendencia da nossa serie

detrended = data_temporal - decomposicao_aditiva.trend
plt.plot(detrended)
# retirando a sazonalidade da serie

deseasonalized = data_temporal - decomposicao_aditiva.seasonal
plt.plot(deseasonalized)
# realizando a análise de autocorrelação nos dados

from statsmodels.graphics.tsaplots import plot_acf  # importando a biblioteca para o plot de autocorrelação
plot_acf(data_temporal, lags = 50) # aplica a autocorrelação entre os dados
plt.show() # mostra uma correlação significativa com 14 lags
# transformando a serie em estacionaria

data_temporal['Passengers_diff'] = data_temporal['Passengers'] - data_temporal['Passengers'].shift(1) # aplica o primeiro shift (derivada para o tempo discreto) 
data_temporal['Passengers_diff'] = data_temporal['Passengers_diff'].dropna() 
data_temporal['Passengers_diff'].plot()
# Conferindo se agora a series está estacionaria

x_diff = data_temporal['Passengers_diff'].dropna().values
resultado_primeira_diff = adfuller(x_diff)
print(f'p-valor: {resultado_primeira_diff[1]}')
import tensorflow as tf
import math

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, LSTM, Input
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import MinMaxScaler
# volta o dataset para o formato original
serie_passageiros = data_temporal['Passengers'].values
# normalização do banco de dados, necessario para que os algoritmos possam ter um comportamento mais previsivel
scaler = MinMaxScaler(feature_range = (0, 1)) # cria o objeto que realiza a normalização dos dados por meios dos valores minimos e maximos
dataset = scaler.fit_transform(serie_passageiros.reshape(-1, 1))
print(dataset[0:20])
# divide o conjunto de dados em treinamento e test
train_size = int(len(dataset) * 0.67) # encontra o valor maximo para o treinamento
test_size = len(dataset) - train_size
train, test = dataset[0: train_size, :] , dataset[train_size: len(dataset), :]
print(len(train), len(test))
# Cria a matrix necessaria para a entrada de dados

def create_dataset(dataset, look_back = 1):
  dataX, dataY = [], []
  for i in range(len(dataset) - look_back - 1):
    a = dataset[i: (i + look_back), 0]
    dataX.append(a)
    dataY.append(dataset[i + look_back, 0])
  return np.array(dataX), np.array(dataY)
# cria o reshape para que os dados estejam em um formato ideal : N x T x D
look_back = 14 # sera utilizado apenas um passo anterior para a previsao
trainX, trainY = create_dataset(train , look_back)
testX, testY = create_dataset(test, look_back)
trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))
trainX.shape
# cria o modelo utilizando RNN (LSTM)
i = Input(shape = (1, look_back))
x = LSTM(4)(i)
x = Dense(1)(x)

model = Model(i, x)

model.summary()

model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainX, trainY, epochs = 100, batch_size = 1, verbose = 2)
# realiza as previsoes
train_predict = model.predict(trainX)
test_predict = model.predict(testX)
# coloca os dados no formato original
train_predict =  scaler.inverse_transform(train_predict)
trainY = scaler.inverse_transform([trainY])
test_predict = scaler.inverse_transform(test_predict)
testY = scaler.inverse_transform([testY])
# Realiza a mudança dos dados para a previsao

train_predict_plot = np.empty_like(dataset)
train_predict_plot[:, :] = np.nan
train_predict_plot[look_back: len(train_predict) + look_back, :] = train_predict

# shift para os dados de test
test_predict_plot = np.empty_like(dataset)
test_predict_plot[:, :] = np.nan
test_predict_plot[len(train_predict) + (look_back*2) + 1 : len(dataset) - 1, :] = test_predict
# Realiza o plot dos dados de previsao e real

plt.plot(scaler.inverse_transform(dataset), label = 'Dataset' )
plt.plot(train_predict_plot, label = 'Training')
plt.plot(test_predict_plot, label = 'Predictions')
plt.xlabel('time')
plt.ylabel('Number of sold tickets')
plt.legend(loc = 'best')
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10682638660978011, 'fraction_numerical': 0.009189366590088613, 'mean_word_length': 5.91827468785471, 'pattern_counts': {'":': 0, '<': 5, '<?xml version=': 0, '>': 5, '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': '1', 'dir': 'jupyter-structured-clean-dedup', 'id': '226139', 'license': 'MIT', 'n_tokens_mistral': 2195, 'n_tokens_neox': 2096, 'n_words': 589, 'path': 'SerieTemporal_Previsao_Passageiros.ipynb', 'repo_name': 'rodrigoamorimml/IGTIBootcamp', 'size': '6094'}