🚀 Versão inicial do dashboard interativo com ARIMA e SARIMA + Bootstrap

Dashboard_ARIMA_SARIMA.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# ![MARCADOR.png](attachment:1d2ba8b3-2364-4376-8dfb-789c18bb0d24.png)
+
+# # Dashboard -  Séries Temporais Financeiras (Previsão)
+
+# In[5]:
+
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import plotly.graph_objects as go
+
+from yahooquery import Ticker
+from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
+from pmdarima import auto_arima
+from statsmodels.tsa.statespace.sarimax import SARIMAX
+from statsmodels.stats.diagnostic import acorr_ljungbox
+import io
+from PIL import Image
+
+import warnings
+
+warnings.filterwarnings("ignore")
+
+import subprocess
+
+
+# ## Dashboard
+
+# In[12]:
+
+
+# Função com cache
+@st.cache_data(ttl=3600)
+def carregar_dados(ativo):
+    ticker = Ticker(ativo)
+    df_raw = ticker.history(start='2012-01-01', interval='1d').reset_index()
+    df_raw['date'] = pd.to_datetime(df_raw['date'], utc=True, errors='coerce').dt.tz_convert(None)
+    df_prices = df_raw[df_raw['adjclose'].notna()][['date', 'adjclose']].rename(columns={'date': 'Data', 'adjclose': 'Preco'})
+    df_prices.set_index('Data', inplace=True)
+    df_prices = df_prices[~df_prices.index.duplicated()]
+    return df_prices
+
+# Função para diagnosticar FAC/FACP
+def plot_diagnostico(serie):
+    fig, axs = plt.subplots(2, 1, figsize=(10, 6))
+    plot_acf(serie.dropna(), lags=36, ax=axs[0])
+    axs[0].set_title("FAC")
+    plot_pacf(serie.dropna(), lags=36, ax=axs[1])
+    axs[1].set_title("FACP")
+    fig.tight_layout()
+    return fig
+
+# Função para simulação bootstrap
+def bootstrap_previsao(modelo_base, treino, steps, order, seasonal_order, n_sim=10):
+    resid = modelo_base.resid.dropna()
+    sim_matrix = []
+    for _ in range(n_sim):
+        shocks = np.random.choice(resid, size=steps, replace=True)
+        history = list(treino)
+        sim = []
+        for i in range(steps):
+            mod = SARIMAX(history, order=order, seasonal_order=seasonal_order, trend='c').filter(modelo_base.params)
+            next_val = mod.forecast(steps=1)[0]
+            val = next_val + shocks[i]
+            sim.append(val)
+            history.append(val)
+        sim_matrix.append(sim)
+    sim_df = pd.DataFrame(sim_matrix).T
+    return sim_df
+
+# Configuração da página
+st.set_page_config(page_title="Previsão SARIMA com Bootstrap", layout="wide")
+st.title("📈 Dashboard de Séries Temporais com SARIMA + Bootstrap")
+
+# Sidebar
+st.sidebar.header("Configurações do Modelo")
+ativo = st.sidebar.selectbox("Escolha o ativo:", ["PETR4.SA", "NG=F", "WEAT", "AMZN", "WMT"])
+auto = st.sidebar.radio("Seleção do modelo:", ["AutoARIMA", "Manual"])
+
+# Carregar série
+df_diaria = carregar_dados(ativo)
+serie = df_diaria['Preco'].resample('M').mean().dropna()
+
+st.subheader("📊 Série histórica (mensal)")
+st.line_chart(serie)
+
+# Diagnóstico FAC/FACP
+if st.button("🔍 Ver Diagnóstico FAC/FACP"):
+    st.subheader("FAC e FACP da série diferenciada")
+    fig_diag = plot_diagnostico(serie.diff().dropna())
+    st.pyplot(fig_diag)
+
+# Definição do modelo
+if auto == "AutoARIMA":
+    model_arima = auto_arima(serie, seasonal=True, m=12, trace=False, suppress_warnings=True)
+    order = model_arima.order
+    seasonal_order = model_arima.seasonal_order[:3] + (12,)
+else:
+    order = tuple(map(int, st.sidebar.text_input("Order (p,d,q):", "1,1,1").split(",")))
+    seasonal_order = tuple(map(int, st.sidebar.text_input("Seasonal Order (P,D,Q,s):", "1,1,1,12").split(",")))
+
+modelo = SARIMAX(serie, order=order, seasonal_order=seasonal_order, trend='c').fit(disp=False)
+
+# Ljung-Box
+if st.button("📈 Testar Ljung-Box nos resíduos"):
+    st.subheader("📈 Teste de Ljung-Box nos resíduos")
+    alpha = st.slider("Escolha o nível de significância (α)", 0.01, 0.10, 0.05, step=0.01)
+    lb_test = acorr_ljungbox(modelo.resid.dropna(), lags=[12], return_df=True)
+    st.dataframe(lb_test)
+    pval = lb_test['lb_pvalue'].values[0]
+    if pval < alpha:
+        st.error(f"p-valor = {pval:.4f} < {alpha:.2f} → Rejeitamos H₀: resíduos não são ruído branco.")
+    else:
+        st.success(f"p-valor = {pval:.4f} ≥ {alpha:.2f} → Não rejeitamos H₀: resíduos são ruído branco.")
+
+# Parâmetros de previsão
+n_passos = st.sidebar.slider("Horizonte de previsão (meses)", 6, 36, 12)
+n_sim = st.sidebar.slider("Nº simulações bootstrap", 5, 50, 10)
+
+# Previsão e gráfico final
+if st.button("📈 Gerar Previsão com IC (Bootstrap)"):
+    forecast_index = pd.date_range(serie.index[-1] + pd.DateOffset(months=1), periods=n_passos, freq="M")
+    sim_df = bootstrap_previsao(modelo, list(serie), n_passos, order, seasonal_order, n_sim=n_sim)
+    ci_lower = sim_df.quantile(0.025, axis=1)
+    ci_upper = sim_df.quantile(0.975, axis=1)
+    median = sim_df.median(axis=1)
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=serie.index, y=serie, name="Histórico", line=dict(color="blue")))
+    fig.add_trace(go.Scatter(x=forecast_index, y=median, name="Previsão", line=dict(color="red")))
+    fig.add_trace(go.Scatter(
+        x=list(forecast_index) + list(forecast_index[::-1]),
+        y=list(ci_lower) + list(ci_upper[::-1]),
+        fill='toself',
+        fillcolor='rgba(255,182,193,0.3)',
+        line=dict(color='rgba(255,255,255,0)'),
+        name='IC 95%',
+        hoverinfo='skip'
+    ))
+    fig.update_layout(title=f"Previsão SARIMA + Bootstrap ({ativo})",
+                      xaxis_title="Data", yaxis_title="Preço Ajustado",
+                      template="plotly_white", height=500)
+    st.plotly_chart(fig, use_container_width=True)

Dashboard_Diagnostico_ST.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python
-# coding: utf-8
-
-import streamlit as st
-import pandas as pd
-import numpy as np
-from yahooquery import Ticker
-import plotly.graph_objects as go
-from statsmodels.tsa.stattools import adfuller, kpss, acf, pacf
-from statsmodels.stats.diagnostic import acorr_ljungbox, het_arch
-from statsmodels.stats.stattools import jarque_bera
-from PIL import Image
-
-# Configuração da página
-st.set_page_config(
-    page_title="Diagnóstico de Séries Temporais Financeiras",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Estilo do slider
-st.markdown("""
-    <style>
-    .stSlider > div > div > div > div > div > div {
-        background-color: #4CAF50 !important;
-    }
-    </style>
-    """, unsafe_allow_html=True)
-
-# Logo
-logo_unb = Image.open("Logo/MARCADOR.png")
-col1, col2, col3 = st.columns([1, 6, 1])
-with col1:
-    st.image(logo_unb, use_column_width=True)
-with col2:
-    st.markdown("<h1 style='text-align: center; color: #003366;'>Diagnóstico de Séries Temporais Financeiras</h1>", unsafe_allow_html=True)
-    st.markdown("<h3 style='text-align: center; color: #003366;'>Professor João Gabriel de Moraes Souza</h3>", unsafe_allow_html=True)
-with col3:
-    st.image(logo_unb, use_column_width=True)
-
-# Interface
-ativos = ['ITUB4.SA', 'BBAS3.SA', 'BBDC4.SA', 'PETR3.SA', 'CSNA3.SA']
-ativo = st.selectbox("Escolha um ativo:", ativos)
-tipo_serie = st.radio("Tipo de série:", ["Preços", "Retornos"])
-alpha = st.slider("Nível de significância (α):", min_value=0.01, max_value=0.10, value=0.01, step=0.01)
-diagnostico = st.selectbox("Escolha o tipo de diagnóstico:", [
-    "Estacionariedade",
-    "Ergodicidade",
-    "Autocorrelação",
-    "Heterocedasticidade",
-    "Normalidade"
-])
-
-# Cache para download de dados
-@st.cache_data(ttl=3600)
-def carregar_dados(ativo):
-    ticker = Ticker(ativo)
-    df_raw = ticker.history(start='2012-01-01', interval='1d').reset_index()
-    df_raw['date'] = pd.to_datetime(df_raw['date'], utc=True, errors='coerce').dt.tz_convert(None)
-    df_prices = df_raw[df_raw['adjclose'].notna()][['date', 'adjclose']].rename(columns={'date': 'Data', 'adjclose': 'Preco'})
-    df_prices.set_index('Data', inplace=True)
-    df_prices = df_prices[~df_prices.index.duplicated()]
-    return df_prices
-
-# Carregar dados cacheados
-df_prices = carregar_dados(ativo)
-
-# Calcular série conforme tipo
-if tipo_serie == "Retornos":
-    serie = np.log(df_prices / df_prices.shift(1)).dropna()
-else:
-    serie = df_prices.copy()
-
-# Visualização da série
-st.markdown("### Dados Históricos")
-st.line_chart(serie)
-
-# Diagnóstico
-st.markdown(f"### Diagnóstico: {diagnostico}")
-
-if diagnostico == "Estacionariedade":
-    try:
-        adf_stat, adf_p, *_ = adfuller(serie.values.flatten())
-        if adf_p < alpha:
-            st.success(f"ADF: p-valor = {adf_p:.4f} < α → estacionária ao nível de {alpha*100:.0f}%")
-        else:
-            st.warning(f"ADF: p-valor = {adf_p:.4f} ≥ α → não estacionária ao nível de {alpha*100:.0f}%")
-    except Exception as e:
-        st.error(f"Erro no teste ADF: {e}")
-
-    try:
-        kpss_stat, kpss_p, *_ = kpss(serie.values.flatten(), nlags='auto')
-        if kpss_p < alpha:
-            st.warning(f"KPSS: p-valor = {kpss_p:.4f} < α → rejeita estacionariedade ao nível de {alpha*100:.0f}%")
-        else:
-            st.success(f"KPSS: p-valor = {kpss_p:.4f} ≥ α → estacionariedade não rejeitada")
-    except Exception as e:
-        st.error(f"Erro no teste KPSS: {e}")
-
-elif diagnostico == "Ergodicidade":
-    expanding_mean = serie.expanding().mean()
-    fig = go.Figure([go.Scatter(x=expanding_mean.index, y=expanding_mean.values.flatten())])
-    fig.update_layout(title="Média Acumulada (Ergodicidade)", xaxis_title="Data", yaxis_title="Média")
-    st.plotly_chart(fig)
-
-elif diagnostico == "Autocorrelação":
-    try:
-        serie_valida = serie.values.flatten()
-        serie_valida = serie_valida[~np.isnan(serie_valida)]
-        serie_valida = serie_valida[~np.isinf(serie_valida)]
-
-        if len(serie_valida) > 30 and np.std(serie_valida) > 0:
-            lb_p = acorr_ljungbox(serie_valida, lags=[10], return_df=True)['lb_pvalue'].iloc[0]
-            if lb_p < alpha:
-                st.warning(f"Ljung-Box: p-valor = {lb_p:.4f} < α → autocorrelação presente")
-            else:
-                st.success(f"Ljung-Box: p-valor = {lb_p:.4f} ≥ α → sem evidência de autocorrelação")
-        else:
-            st.warning("Série inválida para o teste de Ljung-Box: tamanho insuficiente ou variância nula.")
-    except Exception as e:
-        st.error(f"Erro no teste Ljung-Box: {e}")
-
-    try:
-        acf_vals = acf(serie_valida, nlags=30)
-        pacf_vals = pacf(serie_valida, nlags=30)
-        lags = list(range(len(acf_vals)))
-
-        fig_acf = go.Figure([go.Bar(x=lags, y=acf_vals)])
-        fig_acf.update_layout(title="Autocorrelação (ACF)", xaxis_title="Lag", yaxis_title="ACF")
-        st.plotly_chart(fig_acf)
-
-        fig_pacf = go.Figure([go.Bar(x=lags, y=pacf_vals)])
-        fig_pacf.update_layout(title="Autocorrelação Parcial (PACF)", xaxis_title="Lag", yaxis_title="PACF")
-        st.plotly_chart(fig_pacf)
-
-    except Exception as e:
-        st.error(f"Erro nos gráficos ACF/PACF: {e}")
-
-elif diagnostico == "Heterocedasticidade":
-    try:
-        serie_valida = serie.values.flatten()
-        serie_valida = serie_valida[~np.isnan(serie_valida)]
-        serie_valida = serie_valida[~np.isinf(serie_valida)]
-
-        if len(serie_valida) > 30 and np.std(serie_valida) > 0:
-            p_arch = het_arch(serie_valida)[1]
-            if p_arch < alpha:
-                st.warning(f"ARCH: p-valor = {p_arch:.4f} < α → heterocedasticidade condicional presente")
-            else:
-                st.success(f"ARCH: p-valor = {p_arch:.4f} ≥ α → sem evidência de heterocedasticidade")
-        else:
-            st.warning("Série inválida para o teste ARCH: tamanho insuficiente ou variância nula.")
-    except Exception as e:
-        st.error(f"Erro no teste ARCH: {e}")
-
-elif diagnostico == "Normalidade":
-    try:
-        jb_stat, jb_p, *_ = jarque_bera(serie.values.flatten())
-        if jb_p < alpha:
-            st.warning(f"Jarque-Bera: p-valor = {jb_p:.4f} < α → distribuição não normal")
-        else:
-            st.success(f"Jarque-Bera: p-valor = {jb_p:.4f} ≥ α → distribuição aproximadamente normal")
-    except Exception as e:
-        st.error(f"Erro no teste Jarque-Bera: {e}")
-

Dockerfile

@@ -1,7 +1,6 @@
-# Dockerfile para Diagnóstico de Séries Temporais com Streamlit
+# Dockerfile para Dashboard ARIMA + SARIMA com Bootstrap (Streamlit)
 
 # syntax=docker/dockerfile:1
-
 FROM python:3.10-slim
 
 ENV PYTHONUNBUFFERED=1 \
@@ -9,15 +8,16 @@ ENV PYTHONUNBUFFERED=1 \
 
 WORKDIR /app
 
-# Copiar e instalar dependências
+# Instalar dependências
 COPY requirements.txt .
 RUN pip install --upgrade pip && pip install --no-cache-dir -r requirements.txt
 
-# Copiar código e recursos
+# Copiar arquivos da aplicação
 COPY Logo ./Logo
-COPY Dashboard_Diagnostico_ST.py .
+COPY Dashboard_ARIMA_SARIMA.py .
 
+# Porta padrão do Streamlit
 EXPOSE 8501
 
-CMD ["streamlit", "run", "Dashboard_Diagnostico_ST.py", "--server.port=8501", "--server.enableCORS=false", "--server.address=0.0.0.0"]
+CMD ["streamlit", "run", "Dashboard_ARIMA_SARIMA.py", "--server.port=8501", "--server.enableCORS=false", "--server.address=0.0.0.0"]
 

README.md

@@ -1,20 +1,23 @@
 ---
-title: "Diagnóstico de Séries Temporais"
+title: "📈 Dashboard ARIMA + SARIMA + Bootstrap"
 emoji: "📊"
-colorFrom: "indigo"
-colorTo: "green"
+colorFrom: "red"
+colorTo: "black"
 sdk: "docker"
 app_file: "Dockerfile"
 app_port: 8501
 tags:
  - streamlit
  - séries temporais
- - econometria
- - testes estatísticos
- - machine-learning
+ - previsão
+ - ARIMA
+ - SARIMA
+ - bootstrap
+ - estatística
  - finanças
  - UnB
-pinned: false
-short_description: "Diagnóstico de séries temporais financeiras"
+pinned: true
+short_description: "Previsão com ARIMA e SARIMA"
 license: mit
 ---
+