<jupyter_start><jupyter_text>Há uma tendencia geral crescente nos dados com provaveis variações sazonais<jupyter_code>def test_stationarity(serie):
    #Determinando as estatisticas de rolamento
    rol_mean = serie.rolling(window=12).mean()
    rol_std = serie.rolling(window=12).std()
    plt.plot(serie, color='black',label='Original')
    plt.plot(rol_mean, color='red', label='Média')
    plt.plot(rol_std, color='blue', label='Desvio Padrão')
    plt.xlabel('Data')
    plt.ylabel("Passageiros por dia")
    plt.legend(loc='best')
    plt.tight_layout()
    plt.show()
    return [rol_mean.index,serie,rol_mean,rol_std]
indice, serie, media_serie,std_serie = test_stationarity(dados_soma)
dic_serie = {"Original" : list(serie.values), "Media" : list(media_serie.values), "STD" : list(std_serie.values)}
pd_dic_serie = pd.DataFrame(dic_serie)#,index=indice)
pd_dic_serie.to_csv("Estacionariedade.csv",index=True)<jupyter_output><empty_output><jupyter_text>Série temporal será constante quando: a) possuir média constante     b) variância constante     c) autocovariância não dependente do tempo     Duas razões para não ser estácionária:  a) tendencia - média varia no tempo  b) sazonalidade - variações em prazos específicos<jupyter_code>intervalo=1
indice = list(dados_soma.index)
diferenca = list()
for i in range(intervalo, len(dados_soma)):
        valor = dados_soma["Count"][i] - dados_soma["Count"][i - intervalo]
        diferenca.append(valor)
plt.plot(diferenca)
plt.tight_layout()
plt.show()<jupyter_output><empty_output><jupyter_text>Penalizando valores altos mais do que valores baixos<jupyter_code>dados_log = np.log(dados_soma)
plt.title("Log(Número de Passageiros)")
plt.plot(dados_log)
plt.tight_layout()
plt.show()
dados_log.to_csv("Dados_logscale.csv",index=True)
#Média móvel
media_movel = dados_log.rolling(30).mean()
plt.plot(dados_log)
plt.title("1 mês de série móvel")
plt.plot(media_movel, color='blue')
plt.tight_layout()
plt.show()
media_movel.to_csv("Media_Movel.csv",index=True)<jupyter_output><empty_output><jupyter_text>Subtraindo média movel dos dados originais<jupyter_code>dados_log_media_movel_diff = dados_log - media_movel
dados_log_media_movel_diff.dropna(inplace=True)
indice_log, serie_log, media_serie_log,std_serie_log = test_stationarity(dados_log_media_movel_diff)<jupyter_output><empty_output><jupyter_text>Média móvel ponderada: Valores mais recentes recebem um peso maior<jupyter_code>dados_log_exp_avg = dados_log.ewm(halflife=30).mean()
plt.plot(dados_log)
plt.plot(dados_log_exp_avg, color='red')
plt.tight_layout()
plt.show()
dados_log_ewma_diff = dados_log - dados_log_exp_avg
indice_log_ewma, serie_log_ewma, media_serie_log_ewma,std_serie_log_ewma = test_stationarity(dados_log_ewma_diff)<jupyter_output><empty_output><jupyter_text>Eliminando tendencia e sazonalidadeNem sempre a tecnica de redução da tendencia funciona, particularmente naqueles com alta sazonalidade. Existem dois modos de reduzirmos tendencia e sazonalidade:Diferenciação: pegar a diferença num intervalo de tempo específicoDecomposição: modelar ambas tendencia e sazonalidade e remove-las do modelo<jupyter_code>#Diferenciação
dados_log_diff = dados_log - dados_log.shift()
plt.plot(dados_log_diff)
plt.show()
dados_log_diff.dropna(inplace=True)
indice_log_diff, serie_log_diff, media_serie_log_diff,std_serie_log_diff =test_stationarity(dados_log_diff)
#Decomposição
decomposicao = seasonal_decompose(dados_log)
tendencia = decomposicao.trend
sazonalidade = decomposicao.seasonal
residuo = decomposicao.resid
tendencia.to_csv("Tendencia.csv",index=True)
sazonalidade.to_csv("Sazonalidade.csv",index=True)
residuo.to_csv("Residuo.csv",index=True)
plt.subplot(411)
plt.plot(dados_log, label='Original')
plt.legend(loc='best')
plt.subplot(412)
plt.plot(tendencia, label='Tendencia')
plt.legend(loc='best')
plt.subplot(413)
plt.plot(sazonalidade,label='Sazonalidade')
plt.legend(loc='best')
plt.subplot(414)
plt.plot(residuo, label='Residuos')
plt.legend(loc='best')
plt.show()
plt.tight_layout()<jupyter_output><empty_output><jupyter_text>Notamos que tendencia e sazonalidade estão separados dos dados e desta forma podemos modelar os residuos<jupyter_code>dados_log_decomposto = residuo
dados_log_decomposto.dropna(inplace=True)
indice_res, serie_res, media_res, std_res = test_stationarity(dados_log_decomposto)<jupyter_output><empty_output><jupyter_text>A previsão ARIMA para séries temporais estacionárias é uma equação linear (regressão linear). A previsão depende dos parâmetros (p,q,d) do modelo ARIMA: Número de termos auto-regressivos (AR) (p): termos AR são apenas os atrasos das variáveis dependentes. Por exemplo se p é 5, os previsores para x(t) serão x(t-1)...x(t-5). Número de termos de média móvel (MA) (q): termos MA são os erros da previsão atrasados na equação da previsão. Por exemplo se q é 5, a previsão para x(t) será e(t-1)...e(t-5), onde e(i) é a diferença entre a média móvel no instante i e o valor atual. Número de diferenças (d): eles são os números de diferenças não sazonais, i.e. neste caso pegamos a diferença de primeira ordem. Então podemos passar aquela variável e colocar d=o ou passar a variável original e colocar d=1. MAbos irão gerar o mesmo resultado. Uma preocupação importante aqui é como determinar os valores de p e q. Utilizamos dois gráficos para determinar estes números. Função de autocorrelação (ACF): é uma medida da correlação entre a série temporal com a versão atrasada dela mesma. Por exemplo um atraso de 5 ACF compararia as séries nos instante de tempo t1...t2 com as séries nos instantes t1-5...t2-5 (t1-5 e t2 sendo os pontos finais). Função de autocorrelação parcial (PACF): mede a correlação entre a série temporal com a versão atrasada mas depois de eliminar as variações já explicadas pelas comparações intervenientes.<jupyter_code>atraso_acf = acf(dados_log_diff, nlags=20)
atraso_pacf = pacf(dados_log_diff, nlags=20, method='ols')
pd_atraso_acf = pd.DataFrame(atraso_acf)
pd_atraso_pacf = pd.DataFrame(atraso_pacf)
pd_atraso_acf.to_csv("Atravo_ACF.csv",index=True)
pd_atraso_pacf.to_csv("Atravo_PACF.csv",index=True)
plt.plot(atraso_acf)
plt.axhline(y=0,linestyle='--',color='gray')
plt.axhline(y=-1.96/np.sqrt(len(dados_log_diff)),linestyle='--',color='gray')
plt.axhline(y=1.96/np.sqrt(len(dados_log_diff)),linestyle='--',color='gray')
plt.title('Função de autocorrelação')
plt.xlim([0,5])
plt.tight_layout()
plt.show()
plt.plot(atraso_pacf)
plt.axhline(y=0,linestyle='--',color='gray')
plt.axhline(y=-1.96/np.sqrt(len(dados_log_diff)),linestyle='--',color='gray')
plt.axhline(y=1.96/np.sqrt(len(dados_log_diff)),linestyle='--',color='gray')
plt.title('Função de autocorrelação parcial')
plt.xlim([0,5])
plt.tight_layout()
plt.show()
dados_soma = dados_soma.astype(float)<jupyter_output><empty_output><jupyter_text>Modelo de AutoRegressão<jupyter_code>modelo = ARIMA(dados_soma, order=(1, 0, 0), freq=dados_soma.index.inferred_freq)  
resultado_AR100 = modelo.fit(disp=-1)  
plt.plot(dados_soma)
plt.plot(resultado_AR100.fittedvalues, color='red')
plt.tight_layout()
plt.show()
arima100 = pd.DataFrame(resultado_AR100.fittedvalues,columns=["Contagem"])
arima100.to_csv("Arima100.csv",index=True)
modelo = ARIMA(dados_soma, order=(1, 1, 0), freq=dados_soma.index.inferred_freq)  
resultado_AR110 = modelo.fit(disp=-1)  
plt.plot(dados_soma)
plt.plot(resultado_AR110.fittedvalues, color='red')
plt.tight_layout()
plt.show()
arima110 = pd.DataFrame(resultado_AR110.fittedvalues,columns=["Contagem"])
arima110.to_csv("Arima110.csv",index=True)<jupyter_output><empty_output><jupyter_text>Média móvel<jupyter_code>modelo = ARIMA(dados_soma, order=(0, 0, 1), freq=dados_soma.index.inferred_freq)  
resultado_AR001 = modelo.fit(disp=-1)  
plt.plot(dados_soma)
plt.plot(resultado_AR001.fittedvalues, color='red')
plt.tight_layout()
plt.show()
arima001 = pd.DataFrame(resultado_AR001.fittedvalues,columns=["Contagem"])
arima001.to_csv("Arima001.csv",index=True)
modelo = ARIMA(dados_soma, order=(1, 0, 1), freq=dados_soma.index.inferred_freq)  
resultado_AR101 = modelo.fit(disp=-1)  
plt.plot(dados_soma)
plt.plot(resultado_AR101.fittedvalues, color='red')
plt.tight_layout()
plt.show()
arima101 = pd.DataFrame(resultado_AR101.fittedvalues,columns=["Contagem"])
arima101.to_csv("Arima101.csv",index=True)
modelo = ARIMA(dados_soma, order=(1, 1, 1), freq=dados_soma.index.inferred_freq)  
resultado_AR111 = modelo.fit(disp=-1)  
plt.plot(dados_soma)
plt.plot(resultado_AR111.fittedvalues, color='red')
plt.tight_layout()
plt.show()
arima111 = pd.DataFrame(resultado_AR111.fittedvalues,columns=["Contagem"])
arima111.to_csv("Arima111.csv",index=True)<jupyter_output><empty_output><jupyter_text>Modelo (1,0,1) ajustou melhor os dados Carregando arquivo com os dados para testar o modelo<jupyter_code>#lendo arquivo Test_0qrQsBZ.csv
dateparse = lambda dates: pd.datetime.strptime(dates, '%d-%m-%Y %H:%M')
dados_teste = pd.read_csv('Test_0qrQsBZ.csv',parse_dates=['Datetime'], index_col='Datetime',date_parser=dateparse)
dados_teste.head()
dados_teste['Count'] =  [0 for x in dados_teste.index] 
dados_teste = dados_teste.astype(float)
dados_teste_soma = dados_teste.resample('D').sum()
dados_teste_soma = dados_teste_soma.drop('ID',axis=1)
print(dados_teste_soma.head())
dados_teste_soma.info()
t_previsao = list()
previsao = list()
modelo = ARIMA(np.log(dados_soma), order=(1, 0, 1), freq=dados_soma.index.inferred_freq)
modelo_fit = modelo.fit(disp=-1) 
previsao_log = modelo_fit.plot_predict(start=1,end=1000,dynamic=False) 
plt.tight_layout()
plt.show()<jupyter_output>/anaconda3/lib/python3.7/site-packages/statsmodels/tsa/base/tsa_model.py:320: FutureWarning: Creating a DatetimeIndex by passing range endpoints is deprecated.  Use `pandas.date_range` instead.
  freq=base_index.freq)
StarcoderdataJupyterStructuredCleanDedup