Upload 18 files

README.md

@@ -1,12 +1,7 @@
----
-title: Trabalho Series Temporais
-emoji: 🐨
-colorFrom: green
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.21.0
-app_file: app.py
-pinned: false
----
+# Trabalho Séries Temporais - 1S 2023
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+### Esse repositório armazena os principais códigos responsáveis pela análise, modelagem e diagóstico de uma série temporal.
+
+Esses dados foram coletados a partir da biblioteca meteostat, do python, que fornece informações acerca do clima de diversos pontos do mundo. Nesse caso a cidade escolhida foi Vancouver, por conta da quantidade de dados disponíveis e ausência de falhas na coleta (como apresntadas em Campinas em São Paulo).
+
+O foco do trabalho é predizer a temperatura média do dia seguinte, usando as temperaturas anteriores e com auxílio da variável precipitação. Outras variáveis não foram consideradas ou por se mostrarem ineficiêntes, ou por possuírem muitos valores faltantes.

data/comparacao_cv_30.csv

@@ -0,0 +1,3 @@
+,11,12,4,10,1,2,3,9,0,6,8,7,5
+Model,sarima,ARIMAX-precp,AutoARIMA,Seu ARIMA,Naive,Drift,ExpSmo,ARIMA-GARCH,Media,ARCH2,GARCH22,GARCH11,ARCH1
+m5_rmse,1.4216997766664468,1.4405214459890654,1.4867429183071361,1.4931783954737987,1.671428442001343,1.671835810797555,1.7179135731288364,3.0421461080979126,5.066647263935635,6.231218099889622,6.2312442352950255,6.231574173609016,6.231589827422044

diagnostics.py

@@ -0,0 +1,123 @@
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import urllib.request
+import json
+import plotly.express as px
+import matplotlib.pyplot as plt
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+import statsmodels.api as sm
+
+from sklearn.linear_model import LinearRegression
+from statsmodels.tsa.seasonal import seasonal_decompose
+from sklearn.model_selection import TimeSeriesSplit
+from sklearn.metrics import mean_squared_error
+
+from statsforecast.models import HistoricAverage
+from statsforecast.models import Naive
+from statsforecast.models import RandomWalkWithDrift
+from statsforecast.models import SeasonalNaive
+from statsforecast.models import SimpleExponentialSmoothing
+from statsforecast.models import HoltWinters
+from statsforecast.models import AutoARIMA
+from statsforecast.models import ARIMA
+from statsforecast.models import GARCH
+from statsforecast.models import ARCH
+
+from statsmodels.graphics.tsaplots import plot_pacf
+from statsmodels.graphics.tsaplots import plot_acf
+
+from scipy.stats import shapiro
+from datetime import datetime
+import matplotlib.pyplot as plt
+from meteostat import Point, Daily
+
+from statsmodels.graphics.tsaplots import plot_pacf
+from statsmodels.graphics.tsaplots import plot_acf
+from statsmodels.tsa.statespace.sarimax import SARIMAX
+from statsmodels.tsa.holtwinters import ExponentialSmoothing
+from statsmodels.tsa.stattools import adfuller
+import matplotlib.pyplot as plt
+from tqdm import tqdm_notebook
+from itertools import product
+
+from PIL import Image
+
+from funcoes_modelos import montar_dataframe_temp
+from funcoes_modelos import predict_ARIMA_GARCH
+from funcoes_modelos import return_exog
+
+import warnings
+warnings.filterwarnings('ignore')
+
+from tscv import TimeBasedCV
+
+import pickle
+
+
+#########################################################################
+def read_data():
+        # Set time period
+    start = datetime(2010, 1, 1)
+    end = pd.to_datetime(datetime.now().strftime("%Y-%m-%d"))
+    # Create Point for Vancouver, BC
+    vancouver = Point(49.2497, -123.1193, 70)
+    #campinas = Point(-22.9056, -47.0608, 686)
+    #saopaulo = Point(-23.5475, -46.6361, 769)
+
+    # Get daily data for 2018
+    data = Daily(vancouver, start, end)
+    data = data.fetch()
+    data = data[['tavg', 'prcp']]
+
+    return data
+
+
+data = read_data()
+returns = data['tavg']
+
+#plot_acf(returns, lags = 400, zero = False)
+#plt.show()
+#plot_pacf(returns, lags = 400, zero = False)
+#plt.show()
+#plot_acf(returns.diff(1).dropna(), lags = 400, zero = False)
+#plt.show()
+#plot_pacf(returns.diff(1).dropna(), lags = 400, zero = False)
+#plt.show()
+
+model =  sm.tsa.statespace.SARIMAX(returns , order=(1,1,3), seasonal_order=(0,1,1,7),
+                                    enforce_stationarity=False, enforce_invertibility=False, freq='D')
+model = model.fit()
+
+
+pred = model.forecast(1)
+
+model.plot_diagnostics(figsize=(15, 12))
+#plt.show()
+
+print(shapiro(model.resid))
+
+print(sm.stats.acorr_ljungbox(model.resid, return_df=True, boxpierce = True))
+
+with open('./models/model_sarima_summary.pickle', 'wb') as file:
+    f = pickle.dump(model.summary(), file)
+
+
+
+
+
+
+
+
+
+
+
+
+
+

experiments.py

@@ -0,0 +1,164 @@
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import urllib.request
+import json
+import plotly.express as px
+import matplotlib.pyplot as plt
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+import statsmodels.api as sm
+
+from sklearn.linear_model import LinearRegression
+from statsmodels.tsa.seasonal import seasonal_decompose
+from sklearn.model_selection import TimeSeriesSplit
+from sklearn.metrics import mean_squared_error
+
+from statsforecast.models import HistoricAverage
+from statsforecast.models import Naive
+from statsforecast.models import RandomWalkWithDrift
+from statsforecast.models import SeasonalNaive
+from statsforecast.models import SimpleExponentialSmoothing
+from statsforecast.models import HoltWinters
+from statsforecast.models import AutoARIMA
+from statsforecast.models import ARIMA
+from statsforecast.models import GARCH
+from statsforecast.models import ARCH
+
+from statsmodels.graphics.tsaplots import plot_pacf
+from statsmodels.graphics.tsaplots import plot_acf
+
+from scipy.stats import shapiro
+from datetime import datetime
+import matplotlib.pyplot as plt
+from meteostat import Point, Daily
+
+from statsmodels.graphics.tsaplots import plot_pacf
+from statsmodels.graphics.tsaplots import plot_acf
+from statsmodels.tsa.statespace.sarimax import SARIMAX
+from statsmodels.tsa.holtwinters import ExponentialSmoothing
+from statsmodels.tsa.stattools import adfuller
+import matplotlib.pyplot as plt
+from tqdm import tqdm_notebook
+from itertools import product
+
+from funcoes_modelos import montar_dataframe_temp
+from funcoes_modelos import predict_ARIMA_GARCH
+from funcoes_modelos import return_exog
+
+import warnings
+warnings.filterwarnings('ignore')
+
+from tscv import TimeBasedCV
+
+
+#########################################################################
+def read_data():
+        # Set time period
+    start = datetime(2010, 1, 1)
+    end = pd.to_datetime(datetime.now().strftime("%Y-%m-%d"))
+    # Create Point for Vancouver, BC
+    vancouver = Point(49.2497, -123.1193, 70)
+    #campinas = Point(-22.9056, -47.0608, 686)
+    #saopaulo = Point(-23.5475, -46.6361, 769)
+
+    # Get daily data for 2018
+    data = Daily(vancouver, start, end)
+    data = data.fetch()
+    data = data[['tavg', 'prcp']]
+
+    return data
+
+data = read_data()
+returns = data['tavg']
+
+
+modelos = [HistoricAverage(),
+           Naive(),
+          # SeasonalNaive(365),
+          # SeasonalNaive(30),
+           RandomWalkWithDrift(),
+           SimpleExponentialSmoothing(0.9),
+           #HoltWinters(season_length=180, error_type='A'),
+           #HoltWinters(season_length=30, error_type='A') ,
+           AutoARIMA(),
+           ARCH(p = 1),
+           ARCH(p = 2),
+           GARCH(1,1),
+           GARCH(2,2),
+           [AutoARIMA(), GARCH(2, 2)],
+           #SARIMAX(returns.values, order=(1,1,1), seasonal_order=(1,1,1, 365)),
+           ARIMA(order = (1,1, 1)),
+           ARIMA(order = (1,1,3), seasonal_order = (0,1,1), season_length = 7)
+           ]
+
+
+model_names = ['Media', 'Naive', 'Drift','ExpSmo', #'HoltWin180','HoltWin30',
+               'AutoARIMA','ARCH1','ARCH2', 'GARCH11', 'GARCH22', 'ARIMA-GARCH',
+               'Seu ARIMA', 'sarima']
+
+modelos.append('ourmodel')
+model_names.append('ARIMAX-precp')
+
+
+
+datatrain = data.reset_index()[['time', 'tavg']]
+datatrain['time'] = pd.to_datetime(datatrain['time'])
+
+from tscv import TimeBasedCV
+n_cv = 5
+
+#tscv = TimeSeriesSplit(n_splits = n_cv, max_train_size= 740, )
+tscv = TimeBasedCV(train_period= len(data) - n_cv,
+                test_period=1,
+                freq='days')
+erros = pd.DataFrame(columns = ['Model', 'm5_rmse'])
+n = 1
+
+for i, model in enumerate(modelos):
+
+    model_name = model_names[i]
+    rmse = []
+    for train_index, test_index in tscv.split(data = datatrain , date_column='time'):
+        cv_train, cv_test = returns.iloc[train_index], returns.iloc[test_index]
+
+        if model_name == 'ARIMA-GARCH':
+
+            temp_train = montar_dataframe_temp(cv_train)
+
+            predictions = predict_ARIMA_GARCH(model, temp_train, n)
+
+        elif model_name == 'ARIMAX-precp':
+
+            temp_train = montar_dataframe_temp(cv_train)
+
+            sarimax = sm.tsa.statespace.SARIMAX(temp_train['tavg'] , order=(3,0,1), exog = temp_train[['precip_ontem', 'precip_media_semana']],
+                                    enforce_stationarity=False, enforce_invertibility=False, freq='D', simple_differencing=True).fit(low_memory=True, cov_type='none')
+            
+            #mod = sm.tsa.arima.ARIMA(temp_train['tavg'], order=(3, 0, 1), seasonal_order=(0,1,0,365))
+            #res = mod.fit(method='innovations_mle', low_memory=True, cov_type='none')
+
+            predictions = sarimax.forecast(n, exog = return_exog(temp_train, n).values).values
+            #predictions = res.forecast(n).values
+        else:
+            model = model.fit(cv_train.values)
+
+            predictions = model.predict(n)
+            predictions = predictions['mean']#[0]
+
+
+        true_values = cv_test.values[0:n]
+        rmse.append(np.sqrt(mean_squared_error(true_values, predictions)))
+
+
+    erros = pd.concat([erros, pd.DataFrame([{'Model': model_name,'m5_rmse': np.mean(rmse)}])],
+                                ignore_index = True)
+
+
+print(erros.sort_values('m5_rmse').T)
+erros.sort_values('m5_rmse').T.to_csv(f'comparacao_cv_{n_cv}.csv')

models/model_sarima_summary.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15ceef30812813136f63ab93011f371affa7e88d606cc3b901213194bc1dec2e
+size 7876

predict_model.py

@@ -0,0 +1,97 @@
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import urllib.request
+import json
+import plotly.express as px
+import matplotlib.pyplot as plt
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+import statsmodels.api as sm
+import pickle
+
+from sklearn.linear_model import LinearRegression
+from statsmodels.tsa.seasonal import seasonal_decompose
+from sklearn.model_selection import TimeSeriesSplit
+from sklearn.metrics import mean_squared_error
+
+from statsforecast.models import HistoricAverage
+from statsforecast.models import Naive
+from statsforecast.models import RandomWalkWithDrift
+from statsforecast.models import SeasonalNaive
+from statsforecast.models import SimpleExponentialSmoothing
+from statsforecast.models import HoltWinters
+from statsforecast.models import AutoARIMA
+from statsforecast.models import ARIMA
+from statsforecast.models import GARCH
+from statsforecast.models import ARCH
+
+from statsmodels.graphics.tsaplots import plot_pacf
+from statsmodels.graphics.tsaplots import plot_acf
+
+from scipy.stats import shapiro
+from datetime import datetime
+import matplotlib.pyplot as plt
+from meteostat import Point, Daily
+
+from statsmodels.graphics.tsaplots import plot_pacf
+from statsmodels.graphics.tsaplots import plot_acf
+from statsmodels.tsa.statespace.sarimax import SARIMAX
+from statsmodels.tsa.holtwinters import ExponentialSmoothing
+from statsmodels.tsa.stattools import adfuller
+import matplotlib.pyplot as plt
+from tqdm import tqdm_notebook
+from itertools import product
+
+from PIL import Image
+
+from funcoes_modelos import montar_dataframe_temp
+from funcoes_modelos import predict_ARIMA_GARCH
+from funcoes_modelos import return_exog
+
+import warnings
+warnings.filterwarnings('ignore')
+
+from tscv import TimeBasedCV
+
+
+#########################################################################
+def read_data():
+        # Set time period
+    start = datetime(2010, 1, 1)
+    end = pd.to_datetime(datetime.now().strftime("%Y-%m-%d"))
+    # Create Point for Vancouver, BC
+    vancouver = Point(49.2497, -123.1193, 70)
+    #campinas = Point(-22.9056, -47.0608, 686)
+    #saopaulo = Point(-23.5475, -46.6361, 769)
+
+    # Get daily data for 2018
+    data = Daily(vancouver, start, end)
+    data = data.fetch()
+    data = data[['tavg', 'prcp']]
+
+    return data
+
+data = read_data()
+returns = data['tavg']
+print(returns.tail(1))
+
+model =  sm.tsa.statespace.SARIMAX(returns , order=(1,1,3), seasonal_order=(0,1,1,7),
+                                    enforce_stationarity=False, enforce_invertibility=False, freq='D')
+model = model.fit()
+
+
+pred = model.forecast(1)
+print(returns.tail(1))
+print(pred)
+
+#model.save('./models/model_sarima.pickle')
+
+
+#print(model.test_normality('jarquebera'))
+#print(model.test_serial_correlation('ljungbox', 10))

requirements.txt

@@ -11,4 +11,5 @@ scikit-learn
 statsforecast
 scipy
 meteostat
-tqdm
+tqdm
+pickle

streamlit_app.py

@@ -0,0 +1,267 @@
+#import altair as alt
+#import pandas as pd
+#import streamlit as st
+#
+#st.set_page_config(
+#    page_title="Trabalho Final Séries Temporais - 2s 2023", page_icon="⬇", layout="centered"
+#)
+#
+#
+#st.title("Trabalho final Séries Temporais")
+#
+#st.write("Começo dos testes para criação do DashBoard")
+import pickle
+import streamlit as st
+import pandas as pd
+import numpy as np
+import urllib.request
+import json
+import plotly.express as px
+import matplotlib.pyplot as plt
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+import statsmodels.api as sm
+
+from sklearn.linear_model import LinearRegression
+from statsmodels.tsa.seasonal import seasonal_decompose
+from sklearn.model_selection import TimeSeriesSplit
+from sklearn.metrics import mean_squared_error
+
+from statsforecast.models import HistoricAverage
+from statsforecast.models import Naive
+from statsforecast.models import RandomWalkWithDrift
+from statsforecast.models import SeasonalNaive
+from statsforecast.models import SimpleExponentialSmoothing
+from statsforecast.models import HoltWinters
+from statsforecast.models import AutoARIMA
+from statsforecast.models import ARIMA
+from statsforecast.models import GARCH
+from statsforecast.models import ARCH
+
+from statsmodels.graphics.tsaplots import plot_pacf
+from statsmodels.graphics.tsaplots import plot_acf
+
+from scipy.stats import shapiro
+from datetime import datetime
+import matplotlib.pyplot as plt
+from meteostat import Point, Daily
+
+from statsmodels.graphics.tsaplots import plot_pacf
+from statsmodels.graphics.tsaplots import plot_acf
+from statsmodels.tsa.statespace.sarimax import SARIMAX
+from statsmodels.tsa.holtwinters import ExponentialSmoothing
+from statsmodels.tsa.stattools import adfuller
+import matplotlib.pyplot as plt
+from tqdm import tqdm_notebook
+from itertools import product
+
+from funcoes_modelos import montar_dataframe_temp
+from funcoes_modelos import predict_ARIMA_GARCH
+from funcoes_modelos import return_exog
+
+from PIL import Image
+import plotly.graph_objects as go
+
+
+import warnings
+warnings.filterwarnings('ignore')
+
+
+st.set_page_config('Séries Tempoais', page_icon=	':chart_with_upwards_trend:')
+
+with st.sidebar:
+    st.markdown("# ME607")
+    st.markdown("A seguir podem ser encontrados alguns links útis referente ao trabalho aqui apresentado:")
+    st.markdown('[Github](https://github.com/GabrielTalasso/trabalho-series)')
+
+st.title(':chart_with_upwards_trend: Trabalho Final Séries Temporais' )
+st.error('Aguarde o simbolo de "Running" no canto superior para a visualização completa.')
+st.markdown('Grupo: Gabriel Ukstin Talasso - 235078 ; Tiago Henrique Silva Monteiro - 217517....')
+st.markdown("## Visão geral dos dados")
+st.markdown("### Alterne entre as abas para as visualizações!")
+
+@st.cache_data # 👈 Add the caching decorator
+def read_data():
+        # Set time period
+    start = datetime(2010, 1, 1)
+    end = pd.to_datetime(datetime.now().strftime("%Y-%m-%d"))
+    # Create Point for Vancouver, BC
+    vancouver = Point(49.2497, -123.1193, 70)
+    #campinas = Point(-22.9056, -47.0608, 686)
+    #saopaulo = Point(-23.5475, -46.6361, 769)
+
+    # Get daily data for 2018
+    data = Daily(vancouver, start, end)
+    data = data.fetch()
+    data = data[['tavg', 'prcp']]
+
+    return data
+
+data = read_data()
+
+returns = data['tavg']
+
+if data not in st.session_state:
+    st.session_state['df'] = data
+
+st.markdown("#### :mostly_sunny: Visão geral -Temperaturas média diária - Vancouver")
+
+tab1, tab2, tab3 = st.tabs([ "Grafico da Série", 
+                      "Grafico Diferenciada",
+                      "Tabela dos dados"])
+
+with tab1:
+    fig = px.line(returns, title='Temperatura Média Diária - Vancouver', 
+                  labels=({'value':'Temperatura Média', 'time':'Data'}))
+    fig.update_layout(showlegend=False)
+    st.plotly_chart(fig)
+
+with tab2:
+    fig = px.line(returns.diff(1).dropna(), title='Temperatura Média Diária - Vancouver - Diferenciada',
+                  labels = {'value':'Diferença da temperatura', 'time':'Data'})
+    fig.update_layout(showlegend=False)
+    st.plotly_chart(fig)
+
+with tab3:
+    st.write(data.tail(10))
+
+st.markdown("#### :bar_chart: Médias móveis -Temperaturas média diária - Vancouver")
+
+
+tab1, tab2, tab3 = st.tabs(['Média Móvel 7', 'Média Móvel 30', 'Média Móvel 300'] )
+with tab1:
+    fig = px.scatter(returns, trendline="rolling", title = 'Média Móvel de 3 dias da temperatura média.',
+                     trendline_options=dict(window=7),
+                      trendline_color_override="red")
+    fig.update_layout(showlegend=False)
+    st.plotly_chart(fig)
+
+with tab2:
+    fig = px.scatter(returns, trendline="rolling",title = 'Média Móvel de 30 dias da temperatura média.',
+                      trendline_options=dict(window=30),
+                       trendline_color_override="red")
+    fig.update_layout(showlegend=False)
+    st.plotly_chart(fig)
+
+
+with tab3:
+    fig = px.scatter(returns, trendline="rolling", title = 'Média Móvel de 300 dias da temperatura média.',
+                     trendline_options=dict(window=300),
+                      trendline_color_override="red")
+    fig.update_layout(showlegend=False)
+    st.plotly_chart(fig)
+
+
+st.markdown("#### :umbrella_with_rain_drops: Visão geral - Precipitação diária - Vancouver")
+
+
+tab1, tab2= st.tabs([ "Grafico da Série", 
+                      "Matriz de correlação"])
+with tab1:
+    fig = px.line(data['prcp'], title='Precipitação diária - Vancouver', 
+                  labels=({'value':'Precipitação diária', 'time':'Data'}))
+    fig.update_layout(showlegend=False)
+    st.plotly_chart(fig)
+
+with tab2:
+    df_corr = data.corr()
+    fig = go.Figure()
+    fig.add_trace(
+        go.Heatmap(
+            x = df_corr.columns,
+            y = df_corr.index,
+            z = np.array(df_corr),
+            text=df_corr.values,
+            texttemplate='%{text:.2f}'
+        )
+    )
+    fig.update_layout(showlegend=False)
+    st.plotly_chart(fig)
+
+
+
+c0 = st.checkbox('Mais informações sobre os dados.', help = 'Clique para saber mais sobre os dados do projeto.')
+
+if c0:
+
+    st.markdown('Esses dados foram coletados a partir da biblioteca meteostat, do python, que fornece informações acerca do clima de diversos pontos do mundo.')
+    st.markdown('Nesse caso a cidade escolhida foi Vancouver, por conta da quantidade de dados disponíveis e ausência de falahas na coleta (como apresntadas em Campinas em São Paulo).')
+    st.markdown('O foco do trabalho é predizer a temperatura média do dia seguinte, usando as temperaturas anteriores e com auxílio da variável precipitação. Outras variáveis não foram consideradas ou por se mostrarem ineficiẽntes, ou por possírem muitos valores faltantes.')
+
+st.markdown('### :calendar: Para um vislumbre da dinâmica dos dados, a seguir podemos ver os seguintes gráficos:')
+
+tab1, tab2, tab3, tab4 = st.tabs([ "ACF - Original", 
+                      "PACF - Original",
+                      "ACF - Diferenciada",
+                      "PACF - DIferenciada"])
+with tab1:
+    image = Image.open('images/acf.png')
+    st.image(image = image, caption='ACF. Teste de Ljung-Box rejeita que são não correlacionados.')
+with tab2:
+    image = Image.open('images/pacf.png')
+    st.image(image = image)
+
+with tab3:
+    image = Image.open('images/acfdiff.png')
+    st.image(image = image, caption='ACF. Teste de Ljung-Box rejeita que são não correlacionados. ')
+with tab4:
+    image = Image.open('images/pacfdiff.png')
+    st.image(image = image)
+
+st.markdown('### :computer: Modelagem')
+st.markdown(' A seguir podemos ver o resulado do teste de diversos modelos, comparados atravez de uma validação cruzada de janela deslizante.')
+st.markdown(' Cada modelo foi testado 30 vezes, predizedo sempre um passo a frente a raiz do erro quadratico médio (RMSE) de cada um pode ser visto na tabela abaixo')
+
+results = pd.read_csv('data/comparacao_cv_30.csv').T
+results = results.replace({'Seu ARIMA': 'ARIMA111', 'm5_rmse':'RMSE', 'sarima': 'SARIMA'})
+results.columns = results.iloc[0]
+results = results.drop(results.index[0])
+results = results.set_index('Model')
+results['RMSE'] = results['RMSE'].apply(lambda x: round(float(x), 3))
+
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    st.write(' ')
+
+with col2:
+    st.write(results)
+
+with col3:
+    st.write(' ')
+
+c1 = st.checkbox('Mostrar mais sobre os testes.', help = 'Clique para mais informações a cerca dos experimentos para testes de modelos.')
+if c1:
+    st.write('O melhor modelo encontrado foi um SARIMA(1,1,3)(0,1,1)7, que desempenhou melhor nos nossos testes. '+
+                'Além disso, o segundo melhor modelo foi um ARIMAX(1,0,1), usando a precipitação do dia anterior e a média da precipitação semanal como covariáveis.')
+    st.markdown('OBS: Outros modelos também foram testados mas não mostrados na tabela, os apresentados são os modelos de cada tipo que tiveram melhor desempenho nos testes realizados. Modelos com período sazonal 365 dias ou não bateram os baselines ou demoravam horas para rodar, por isso foram descartados de uma anpalise diária.')
+
+st.markdown('### :white_check_mark: Diagnóstico do modelo: SARIMA(1,1,3)(0,1,1)7')
+
+image = Image.open('images/sarima_diags.png')
+st.image(image = image, caption='Diagnóstico do modelo. Rejeita-se normalidade dos resíduos à 5%.')
+
+c2 = st.checkbox('Mostrar mais sobre o diagnóstico.', help = 'Clique para mais informações a cerca do diagnóstico do modelo.')
+
+if c2:
+    st.markdown('Mesmo esse sendo o melhor modelo nos testes visualmente adequado nos gráficos. Ainda rejeitamos a normalidade dos resíduos, ou seja, o modelo ainda ainda não capturou complemente a dinâmica dos dados. Porém o modelo não rejeita que os resíduos são descorrelacionados, o que é um bom sinal de ajuste.')
+    st.markdown('OBS: Por se tratar de um problema complexo e que envolve muitas variáveis não disponíveis, nenhum dos modelos testados obteve resíduos normais.')
+
+
+st.markdown('### :clipboard: Informações ténicas sobre o modelo.')
+
+with open('./models/model_sarima_summary.pickle', 'rb') as file:
+    f = pickle.load(file)
+    
+st.write(f)
+
+c3 = st.checkbox('Mais informações sobre os parâmetros do modelo.')
+
+if c3:
+    st.markdown('Acima podemos ver as as estimativas para todos os parâmetros do modelo, além disso é possível visualizar também as principais métricas de performance do modelo estudado, assim os testes comentados anteriormente.')
+    st.markdown('Apesar de parte MA sasonal não se mostrar significativa, ela melhorou a desenpenho do modelo ns testes e por isso for mantida. Lembrando que esse p-valor apresentado se refere a significância da variável dado que todas outras já foram colocadas no modelo.')
+

tscv.py

@@ -0,0 +1,106 @@
+import pandas as pd
+import datetime
+from datetime import datetime as dt
+from dateutil.relativedelta import *
+
+class TimeBasedCV(object):
+    '''
+    Parameters 
+    ----------
+    train_period: int
+        number of time units to include in each train set
+        default is 30
+    test_period: int
+        number of time units to include in each test set
+        default is 7
+    freq: string
+        frequency of input parameters. possible values are: days, months, years, weeks, hours, minutes, seconds
+        possible values designed to be used by dateutil.relativedelta class
+        deafault is days
+    '''
+    
+    
+    def __init__(self, train_period=30, test_period=7, freq='days'):
+        self.train_period = train_period
+        self.test_period = test_period
+        self.freq = freq
+
+        
+        
+    def split(self, data, validation_split_date=None, date_column='record_date', gap=0):
+        '''
+        Generate indices to split data into training and test set
+        
+        Parameters 
+        ----------
+        data: pandas DataFrame
+            your data, contain one column for the record date 
+        validation_split_date: datetime.date()
+            first date to perform the splitting on.
+            if not provided will set to be the minimum date in the data after the first training set
+        date_column: string, deafult='record_date'
+            date of each record
+        gap: int, default=0
+            for cases the test set does not come right after the train set,
+            *gap* days are left between train and test sets
+        
+        Returns 
+        -------
+        train_index ,test_index: 
+            list of tuples (train index, test index) similar to sklearn model selection
+        '''
+        
+        # check that date_column exist in the data:
+        try:
+            data[date_column]
+        except:
+            raise KeyError(date_column)
+                    
+        train_indices_list = []
+        test_indices_list = []
+
+        if validation_split_date==None:
+            validation_split_date = data[date_column].min().date() + eval('relativedelta('+self.freq+'=self.train_period)')
+        
+        start_train = validation_split_date - eval('relativedelta('+self.freq+'=self.train_period)')
+        end_train = start_train + eval('relativedelta('+self.freq+'=self.train_period)')
+        start_test = end_train + eval('relativedelta('+self.freq+'=gap)')
+        end_test = start_test + eval('relativedelta('+self.freq+'=self.test_period)')
+
+        while end_test < data[date_column].max().date():
+            # train indices:
+            cur_train_indices = list(data[(data[date_column].dt.date>=start_train) & 
+                                     (data[date_column].dt.date<end_train)].index)
+
+            # test indices:
+            cur_test_indices = list(data[(data[date_column].dt.date>=start_test) &
+                                    (data[date_column].dt.date<end_test)].index)
+            
+            print("Train period:",start_train,"-" , end_train, ", Test period", start_test, "-", end_test,
+                  "# train records", len(cur_train_indices), ", # test records", len(cur_test_indices))
+
+            train_indices_list.append(cur_train_indices)
+            test_indices_list.append(cur_test_indices)
+
+            # update dates:
+            start_train = start_train + eval('relativedelta('+self.freq+'=self.test_period)')
+            end_train = start_train + eval('relativedelta('+self.freq+'=self.train_period)')
+            start_test = end_train + eval('relativedelta('+self.freq+'=gap)')
+            end_test = start_test + eval('relativedelta('+self.freq+'=self.test_period)')
+
+        # mimic sklearn output  
+        index_output = [(train,test) for train,test in zip(train_indices_list,test_indices_list)]
+
+        self.n_splits = len(index_output)
+        
+        return index_output
+    
+    
+    def get_n_splits(self):
+        """Returns the number of splitting iterations in the cross-validator
+        Returns
+        -------
+        n_splits : int
+            Returns the number of splitting iterations in the cross-validator.
+        """
+        return self.n_splits