<jupyter_start><jupyter_text>**`ARIMA`**Método estatístico que utiliza autoregressão e médias móveis para previsão de séries temporais. Um modelo linear é construído incluindo um número especificado de termos e os dados são preparados por um nível de diferenciação afim de tornar este estacionário.Podemos usar um valor 0 para desligar um parâmetro, dessa forma, aquela função em questão não será feita, por exemplo, se no parâmetro d definirmos 0 não será realizada uma diferenciação nos dados. Neste exemplo teríamos um modelo **ARMA**.---*   **AR**: *Autoregression* : Um modelo que usa a relação dependende entre uma observação e alguns lags.*   **I**: *Integrated*  : Uso de diferenciação nas observações brutas, exemplo: subtração do valor de uma observação com sua observação anterior. O objetivo é transformar a série temporal em estacionária.*  **MA**: *Moving Average* : Um modelo que usa a dependência entre a observação e o erro residual a partir de um modelo de média móvel aplicado a lags.          residual error = expected − predicted    - Isso é diferente de **Moving Average Smoothing.**- Erros residuais contém estruturas temporais que podem ser modeladas.- Existem sinais complexos nos erros residuais.- Um modelo que prever o erro residual pode ser usado para ajustar os próximos erros e melhorar um modelo que aprende com o histórico.---O modelo arima contém alguns parâmetros``` ARIMA(p,d,q)```*   **p:** O número de lags que foram devem ser incluídos no modelo.*   **d:** O número de vezes que as observações serão diferenciadas.*   **q:** O tamanho de uma janela de média móvel. Também chamada de ordem de média móvel.<jupyter_code>from google.colab import drive
drive.mount('/content/drive') 
import pandas as pd
series = pd.read_csv('champagne_sales.csv', header=0, index_col=0, parse_dates=True, squeeze=True)
# elimina os warnings das bibliotecas
import warnings
warnings.filterwarnings("ignore")
from pandas.plotting import autocorrelation_plot
from matplotlib import pyplot
# autocorrelation plot 
autocorrelation_plot(series)
pyplot.show()
import pandas.util.testing as tm
from statsmodels.graphics.tsaplots import plot_acf
from statsmodels.graphics.tsaplots import plot_pacf
from matplotlib import pyplot
plot_acf(series, lags=40)
pyplot.show()<jupyter_output><empty_output><jupyter_text>Modelo ARIMA para análise de dados<jupyter_code># fit model
from statsmodels.tsa.arima_model import ARIMA
from matplotlib import pyplot
# ARIMA(p,d,q)
model = ARIMA(series, order=(7,1,1))
model_fit = model.fit()
# summary 
print(model_fit.summary())
# plot residuais
from pandas import DataFrame
residuals = DataFrame(model_fit.resid)
residuals.plot()
pyplot.show()
# gráficos de densidade dos residuais
residuals.plot(kind='kde')
pyplot.show()
# estatística descritiva dos residuos
print(residuals.describe())<jupyter_output>0
count   104.000000
mean    157.073949
std    1981.386471
min   -5258.539300
25%    -388.859857
50%     327.225254
75%     988.695494
max    5283.486526<jupyter_text>**Prevendo dados com ARIMA utilizando Walk Forward** Separando os dados de treino e teste<jupyter_code># a variável X recebe os dados da série
X = series.values
X = X.astype('float32')
# Separa os dados com 50% dos dados para treino e 50% dos dados para teste
size = int(len(X) * 0.50)
# Separa dados de treino e teste
train = X[0:size]
test =  X[size:]
# cria a variável history
history = [x for x in train]
# cria lista de previsões
predictions = list()
# Cria a função que faz a diferenciação
def difference(dataset, interval=1):
  diff = list() 
  for i in range(interval, len(dataset)):
    value = dataset[i] - dataset[i - interval]
    diff.append(value)
  return diff

# cria função que reverte o valor diferenciado para o original
def inverse_difference(history, previsao, interval=1):
  return previsao + history[-interval]
from statsmodels.tsa.arima_model import ARIMA
from matplotlib import pyplot
# inicia Walk-Forward
for t in range(len(test)):
  
  # difference data
  meses_no_ano = 12
  diff = difference(history, meses_no_ano)
  
  # cria um modelo ARIMA com os dados de history
  model = ARIMA(diff, order=(0,0,1))
  
  # treina o modelo ARIMA
  model_fit = model.fit(trend='nc', disp=0)
  
  # a variável valor_predito recebe o valor previsto pelo modelo
  valor_predito = model_fit.forecast()[0]

  # valor_predito recebe o valor revertido (escala original)
  valor_predito = inverse_difference(history, valor_predito, meses_no_ano)
   
  # adiciona o valor predito na lista de predicões
  predictions.append(valor_predito)
  
  # a variável valor_real recebe o valor real do teste
  valor_real = test[t]
  
  # adiciona o valor real a variável history
  history.append(valor_real)

  # imprime valor predito e valor real
  print('Valor predito=%.3f, Valor esperado=%3.f' % (valor_predito, valor_real))
# Avaliando os resultados
from numpy import sqrt
from sklearn.metrics import mean_squared_error
rmse = sqrt(mean_squared_error(test, predictions))
print('Test RMSE: %.3f' % rmse)
# plot forecasts against actual outcomes 
pyplot.plot(test)
pyplot.plot(predictions, color='red')
pyplot.show()<jupyter_output><empty_output><jupyter_text>`Analisando Resíduos`      Erro Residual = Valor esperado − Valor Predito- Erros residuais são erros em previsões de séries temporais.- Uma análise dos erros pode sugerir melhoras no modelo.  - Tendências.  - Sazonalidades.<jupyter_code># erros residuais 
residuals = [test[i] - predictions[i] for i in range(len(test))]
# converte a lista em um dataframe
residuals = pd.DataFrame(residuals)
# imprime as 5 primeiras linhas
residuals.head()
# estatística descritiva
residuals.describe()
# plot residuals
residuals.plot()
pyplot.show()
# plots histograma
pyplot.figure()
pyplot.subplot(211)
residuals.hist(ax=pyplot.gca())

pyplot.subplot(212)
residuals.plot(kind='kde', ax=pyplot.gca())
pyplot.show()
# importa os pacotes de autocorrelação
from statsmodels.graphics.tsaplots import plot_acf
from statsmodels.graphics.tsaplots import plot_pacf
# plots de autocorrelação
pyplot.figure() 
pyplot.subplot(211)
plot_acf(residuals, ax=pyplot.gca())
pyplot.subplot(212)
plot_pacf(residuals, ax=pyplot.gca())
pyplot.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.08735521235521236, 'fraction_numerical': 0.02027027027027027, 'mean_word_length': 5.131163708086785, 'pattern_counts': {'":': 0, '<': 16, '<?xml version=': 0, '>': 16, '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': '4', 'dir': 'jupyter-structured-clean-dedup', 'id': '54505', 'license': 'MIT', 'n_tokens_mistral': 2261, 'n_tokens_neox': 2141, 'n_words': 686, 'path': 'Arima-Tutorial.ipynb', 'repo_name': 'palhaogv/Forecasting-Future-Sales---ARIMA', 'size': '6216'}