Workshop Como Construir um Painel de Previsões Macroeconômicas em Python

Autor

Fernando da Silva

Resumo
Nesta aula será desenvolvida uma dashboard interativa que integra modelos preditivos, permitindo parametrização e apresentação de resultados.

Requisitos

  1. Conta GitHub

    1. Acesse http://github.com/
    2. Clique em Sign up
    3. Preencha suas informações/complete o cadastro
  2. Conta Shinyapps.io

    1. Acesse https://www.shinyapps.io/

    2. Clique em Sign up

    3. Preencha suas informações/complete o cadastro

  3. Conta Google

    1. Acesse http://google.com/

    2. Clique em Fazer login

    3. Clique em Criar conta

    4. Selecione o tipo de uso

    5. Preencha suas informações/complete o cadastro

Passo 01: criar repositório GitHub

O repositório será a central de arquivos e de automação do projeto.

  1. Acesse o site: https://github.com/new
  2. Digite um nome de repositório em “Repository name”
  3. Marque a opção “Add a README file”
  4. Escolha entre repositório público ou privado (recomendamos público)
  5. Leia as demais opções e finalize ao clicar em “Create repository”

Passo 02: organizar código

Aqui convertermos o código criado previamente no Google Colab para arquivos organizados de Python (.py). Você pode fazer isso usando um Bloco de Notas ou qualquer IDE, como o VS Code.

No final, você deve ter a seguinte estrutura de arquivos:

Código
01-bibliotecas.py
# Importa bibliotecas
import pandas as pd
import numpy as np
import os, time
from datetime import datetime, timedelta
Código
02-funcoes.py
# Retenta ler um CSV se falhar download
def ler_csv(*args, **kwargs):
  max_tentativas = 5
  intervalo = 2
  tentativas = 0
  while tentativas < max_tentativas:
      try:
          df = pd.read_csv(*args, **kwargs)
          return df
      except Exception as e:
          tentativas += 1
          print(f"Tentativa {tentativas} falhou: {e}")
          time.sleep(intervalo)
  print(f"Falha após {max_tentativas} tentativas.")
  return None

# Coleta dados da API do Banco Central (SGS)
def coleta_bcb_sgs(codigo, nome, freq, data_inicio = "01/01/2000", data_fim = (pd.to_datetime("today") + pd.offsets.DateOffset(months = 36)).strftime("%d/%m/%Y")):
  
  if freq == "Diária":
    datas_inicio = split_date_range(data_inicio, data_fim)
  else:
    datas_inicio = [(data_inicio, data_fim)]

  try:
    print(f"Coletando a série {codigo} ({nome})")
    resposta = []
    for d in datas_inicio:
      url = f"https://api.bcb.gov.br/dados/serie/bcdata.sgs.{codigo}/dados?formato=csv&dataInicial={d[0]}&dataFinal={d[1]}"
      resposta.append(ler_csv(filepath_or_buffer = url, sep = ";", decimal = ","))
    resposta = pd.concat(resposta)
  except:
    raise Exception(f"Falha na coleta da série {codigo} ({nome})")
  else:
    return (
        resposta
        .rename(columns = {"valor": nome})
        .assign(data = lambda x: pd.to_datetime(x.data, format = "%d/%m/%Y"))
        .set_index("data")
    )

# Coleta dados da API do Banco Central (ODATA)
def coleta_bcb_odata(codigo, nome):

  url = codigo

  try:
    print(f"Coletando a série {codigo} ({nome})")
    resposta = ler_csv(
        filepath_or_buffer = url,
        sep = ",", decimal = ",",
        converters = {"Data": lambda x: pd.to_datetime(x)}
        )
  except:
    raise Exception(f"Falha na coleta da série {codigo} ({nome})")
  else:
    return resposta.rename(columns = {"Mediana": nome})

# Coleta dados da API do IPEA (IPEADATA)
def coleta_ipeadata(codigo, nome):

  url = f"http://www.ipeadata.gov.br/api/odata4/ValoresSerie(SERCODIGO='{codigo}')"
  try:
    print(f"Coletando a série {codigo} ({nome})")
    resposta = pd.read_json(url)
  except:
    raise Exception(f"Falha na coleta da série {codigo} ({nome})")
  else:
    return (
        pd.DataFrame.from_records(resposta["value"])
        .rename(columns = {"VALVALOR": nome, "VALDATA": "data"})
        .filter(["data", nome])
      )

# Coleta dados da API do IBGE (SIDRA)
def coleta_ibge_sidra(codigo, nome):

  url = f"{codigo}?formato=json"
  try:
    print(f"Coletando a série {codigo} ({nome})")
    resposta = pd.read_json(url)
  except:
    raise Exception(f"Falha na coleta da série {codigo} ({nome})")
  else:
    df = (
        resposta
        .rename(columns = {"D3C": "data", "V": nome})
        .filter(["data", nome])
      )
    df = df[-df[nome].isin(["Valor", "...", "-"])]
    df[nome] = pd.to_numeric(df[nome])
    return df

# Coleta dados da API do FRED
def coleta_fred(codigo, nome):

  url = f"https://fred.stlouisfed.org/graph/fredgraph.csv?id={codigo}"

  try:
    print(f"Coletando a série {codigo} ({nome})")
    resposta = ler_csv(
        filepath_or_buffer = url,
        converters = {"DATE": lambda x: pd.to_datetime(x)}
        )
  except:
    raise Exception(f"Falha na coleta da série {codigo} ({nome})")
  else:
    return resposta.rename(columns = {"DATE": "data", codigo: nome})

# Coleta dados via link da IFI
def coleta_ifi(codigo, nome):

  try:
    print(f"Coletando a série {codigo} ({nome})")
    resposta = pd.read_excel(
        io = codigo,
        sheet_name = "Hiato do Produto",
        names = ["data", "lim_inf", nome, "lim_sup"],
        skiprows = 2
        )
  except:
    raise Exception(f"Falha na coleta da série {codigo} ({nome})")
  else:
    return resposta

# Separa intervalo de datas em janelas de 10 anos para coleta de dados em blocos
# na API do BCB/SGS
def split_date_range(start_date_str, end_date_str, interval_years=5):
  start_date = datetime.strptime(start_date_str, "%d/%m/%Y")
  end_date = datetime.strptime(end_date_str, "%d/%m/%Y")

  result = []
  current_start = start_date

  while current_start < end_date:
    try:
      current_end = current_start.replace(year=current_start.year + interval_years)
    except ValueError:
      current_end = current_start + timedelta(days=365 * interval_years)

    if current_end > end_date:
      current_end = end_date

    result.append((
      current_start.strftime("%d/%m/%Y"),
      current_end.strftime("%d/%m/%Y")
    ))
    current_start = current_end

  return result
Código
03-coleta.py
# Planilha de metadados
df_metadados = pd.read_excel(
    io = "https://docs.google.com/spreadsheets/d/1x8Ugm7jVO7XeNoxiaFPTPm1mfVc3JUNvvVqVjCioYmE/export?format=xlsx",
    sheet_name = "Metadados"
    )


# Coleta dados do BCB/SGS
input_bcb_sgs = (
    df_metadados
    .query("Fonte == 'BCB/SGS' and `Forma de Coleta` == 'API'")
    .reset_index(drop = True)
)

df_bruto_bcb_sgs = {"Diária": [], "Mensal": [], "Trimestral": [], "Anual": []}

for serie in input_bcb_sgs.index:
  ser = input_bcb_sgs.iloc[serie]
  df_temp = coleta_bcb_sgs(
      codigo = ser["Input de Coleta"],
      nome = ser["Identificador"], 
      freq = ser["Frequência"]
      )
  df_bruto_bcb_sgs[ser["Frequência"]].append(df_temp)


# Coleta dados do BCB/ODATA
input_bcb_odata = (
    df_metadados
    .query("Fonte == 'BCB/ODATA' and `Forma de Coleta` == 'API'")
    .reset_index(drop = True)
)

df_bruto_bcb_odata = []

for serie in input_bcb_odata.index:
  ser = input_bcb_odata.iloc[serie]
  df_temp = coleta_bcb_odata(
      codigo = ser["Input de Coleta"],
      nome = ser["Identificador"]
      )
  df_bruto_bcb_odata.append(df_temp)


# Coleta dados do IPEADATA
input_ipeadata = (
    df_metadados
    .query("Fonte == 'IPEADATA' and `Forma de Coleta` == 'API'")
    .reset_index(drop = True)
)

df_bruto_ipeadata = {"Diária": [], "Mensal": []}

for serie in input_ipeadata.index:
  ser = input_ipeadata.iloc[serie]
  df_temp = coleta_ipeadata(
      codigo = ser["Input de Coleta"],
      nome = ser["Identificador"]
      )
  df_bruto_ipeadata[ser["Frequência"]].append(df_temp)


# Coleta dados do IBGE/SIDRA
input_sidra = (
    df_metadados
    .query("Fonte == 'IBGE/SIDRA' and `Forma de Coleta` == 'API'")
    .reset_index(drop = True)
)

df_bruto_ibge_sidra = {"Mensal": [], "Trimestral": []}

for serie in input_sidra.index:
  ser = input_sidra.iloc[serie]
  df_temp = coleta_ibge_sidra(
      codigo = ser["Input de Coleta"],
      nome = ser["Identificador"]
      )
  df_bruto_ibge_sidra[ser["Frequência"]].append(df_temp)


# Coleta dados do FRED
input_fred = (
    df_metadados
    .query("Fonte == 'FRED' and `Forma de Coleta` == 'API'")
    .reset_index(drop = True)
)

df_bruto_fred = {"Diária": [], "Mensal": [], "Trimestral": []}

for serie in input_fred.index:
  ser = input_fred.iloc[serie]
  df_temp = coleta_fred(
      codigo = ser["Input de Coleta"],
      nome = ser["Identificador"]
      )
  df_bruto_fred[ser["Frequência"]].append(df_temp)


# Coleta dados do IFI
input_ifi = (
    df_metadados
    .query("Fonte == 'IFI'")
    .reset_index(drop = True)
)

df_bruto_ifi = coleta_ifi(input_ifi["Input de Coleta"][0], input_ifi["Identificador"][0])
Código
04-tratamento.py
# Cruza dados do BCB/SGS
df_tratado_bcb_sgs = df_bruto_bcb_sgs.copy()

for f in df_tratado_bcb_sgs.items():
  df_temp = f[1][0]
  for df in f[1][1:]:
    df_temp = df_temp.join(other = df, how = "outer")
  df_tratado_bcb_sgs[f[0]] = df_temp

# Agrega dados de frequência diária para mensal por média ou início de mês
df_tratado_bcb_sgs["Mensal"] = df_tratado_bcb_sgs["Mensal"].join(
    other = (
        df_tratado_bcb_sgs["Diária"]
        .astype(float)
        .filter(input_bcb_sgs.query("Identificador != 'selic'")["Identificador"].to_list())
        .resample("MS")
        .mean()
        .join(
            other = (
                df_tratado_bcb_sgs["Diária"]
                .filter(["selic"])
                .reset_index()
                .assign(data = lambda x: x.data.dt.to_period("M").dt.to_timestamp())
                .groupby("data")
                .head(1)
                .set_index("data")
            ),
            how = "outer"
        )
        .query("index >= '2000-01-01'")
    ),
    how = "outer"
).astype(float)


# Filtra expectativas curto prazo ~1 mês à frente e agrega pela média
df_tratado_bcb_odata_ipca_cp = (
    df_bruto_bcb_odata[0]
    .assign(
        DataReferencia = lambda x: pd.to_datetime(x.DataReferencia, format = "%m/%Y"),
        horizonte = lambda x: ((x.DataReferencia - x.Data) / np.timedelta64(30, "D")).astype(int),
        data = lambda x: x.Data.dt.to_period("M").dt.to_timestamp()
        )
    .query("horizonte == 1")
    .groupby(["data"], as_index = False)["expec_ipca_top5_curto_prazo"]
    .mean()
)

# Filtra expectativas médio prazo ~6 mês à frente e agrega pela média
df_tratado_bcb_odata_ipca_mp = (
    df_bruto_bcb_odata[1]
    .assign(
        DataReferencia = lambda x: pd.to_datetime(x.DataReferencia, format = "%m/%Y"),
        horizonte = lambda x: ((x.DataReferencia - x.Data) / np.timedelta64(30, "D")).astype(int),
        data = lambda x: x.Data.dt.to_period("M").dt.to_timestamp()
        )
    .query("horizonte == 6")
    .groupby(["data"], as_index = False)["expec_ipca_top5_medio_prazo"]
    .mean()
)

# Filtra expectativas longo prazo ~1 ano à frente e agrega pela média
df_tratado_bcb_odata_selic = (
    df_bruto_bcb_odata[2]
    .assign(
        DataReferencia = lambda x: pd.to_datetime(x.DataReferencia, format = "%Y"),
        data = lambda x: x.Data.dt.to_period("M").dt.to_timestamp(),
        horizonte = lambda x: ((x.DataReferencia - x.Data) / np.timedelta64(365, "D")).astype(int)
        )
    .query("horizonte == 1")
    .groupby(["data"], as_index = False)["expec_selic"]
    .mean()
)

# Filtra expectativas curto prazo ~1 mês à frente e agrega pela média
df_tratado_bcb_odata_cambio = (
    df_bruto_bcb_odata[3]
    .assign(
        DataReferencia = lambda x: pd.to_datetime(x.DataReferencia, format = "%m/%Y"),
        horizonte = lambda x: ((x.DataReferencia - x.Data) / np.timedelta64(30, "D")).astype(int),
        data = lambda x: x.Data.dt.to_period("M").dt.to_timestamp()
        )
    .query("horizonte == 1")
    .groupby(["data"], as_index = False)["expec_cambio"]
    .mean()
)

# Filtra expectativas curto prazo ~12 meses à frente e agrega pela média
df_tratado_bcb_odata_ipca_lp = (
    df_bruto_bcb_odata[4]
    .assign(data = lambda x: x.Data.dt.to_period("M").dt.to_timestamp())
    .groupby(["data"], as_index = False)["expec_ipca_12m"]
    .mean()
)

# Filtra expectativas médio prazo ~9 meses à frente e agrega pela média
df_tratado_bcb_odata_pib = (
    df_bruto_bcb_odata[5]
    .assign(
        DataReferencia = lambda x: pd.PeriodIndex(
            x.DataReferencia.str.replace(r"(\d{1})/(\d{4})", r"\2-Q\1", regex = True),
            freq = "Q"
            ).to_timestamp(),
        data = lambda x: x.Data.dt.to_period("Q").dt.to_timestamp(),
        horizonte = lambda x: ((x.DataReferencia - x.Data) / np.timedelta64(30, "D")).astype(int)
      )
    .query("horizonte == 9")
    .groupby(["data"], as_index = False)["expec_pib"]
    .mean()
)

# Filtra expectativas longo prazo ~1 ano à frente e agrega pela média
df_tratado_bcb_odata_primario = (
    df_bruto_bcb_odata[6]
    .assign(
        DataReferencia = lambda x: pd.to_datetime(x.DataReferencia, format = "%Y"),
        data = lambda x: x.Data.dt.to_period("M").dt.to_timestamp(),
        horizonte = lambda x: ((x.DataReferencia - x.Data) / np.timedelta64(365, "D")).astype(int)
        )
    .query("horizonte == 1")
    .groupby(["data"], as_index = False)["expec_primario"]
    .mean()
)

# Cruza dados de mesma frequência
df_tratado_bcb_odata_lista = [
    df_tratado_bcb_odata_ipca_mp,
    df_tratado_bcb_odata_ipca_lp,
    df_tratado_bcb_odata_selic,
    df_tratado_bcb_odata_cambio,
    df_tratado_bcb_odata_primario
  ]

df_tratado_bcb_odata_mensal = df_tratado_bcb_odata_ipca_cp.set_index("data")

for df in df_tratado_bcb_odata_lista:
  df_tratado_bcb_odata_mensal = df_tratado_bcb_odata_mensal.join(
      other = df.set_index("data"),
      how = "outer"
      )


# Cruza dados do IPEADATA
df_tratado_ipeadata = df_bruto_ipeadata.copy()

for f in df_tratado_ipeadata.items():
  df_temp = f[1][0].assign(data = lambda x: pd.to_datetime(x.data, utc = True)).set_index("data")
  for df in f[1][1:]:
    df_temp = df_temp.join(
        other = df.assign(data = lambda x: pd.to_datetime(x.data, utc = True)).set_index("data"),
        how = "outer"
        )
  df_tratado_ipeadata[f[0]] = df_temp

# Agrega dados de frequência diária para mensal por média
df_tratado_ipeadata["Mensal"] = (
    df_tratado_ipeadata["Mensal"]
    .reset_index()
    .assign(data = lambda x: x.data.dt.to_period("M").dt.to_timestamp())
    .set_index("data")
    .join(
        other = (
            df_tratado_ipeadata["Diária"]
            .reset_index()
            .assign(data = lambda x: x.data.dt.to_period("M").dt.to_timestamp())
            .set_index("data")
            .resample("MS")
            .mean()
        ),
        how = "outer"
      )
    .query("index >= '2000-01-01'")
)


# Cruza dados do IBGE/SIDRA
df_tratado_ibge_sidra = df_bruto_ibge_sidra.copy()

for f in df_tratado_ibge_sidra.items():
  df_temp = (
      f[1][0]
      .iloc[1:]
      .assign(
          data = lambda x: pd.PeriodIndex(
            x.data.str.replace(r"(\d{4})(\d{1})(\d{1})", r"\1-\2\3" if f[0] == "Mensal" else r"\1-Q\3", regex = True),
            freq = "M" if f[0] == "Mensal" else "Q"
            ).to_timestamp()
        )
      .set_index("data")
  )
  for df in f[1][1:]:
    df_temp = df_temp.join(
        other = (
            df
            .iloc[1:]
            .assign(
                data = lambda x: pd.PeriodIndex(
                  x.data.str.replace(r"(\d{4})(\d{1})(\d{1})", r"\1-\2\3" if f[0] == "Mensal" else r"\1-Q\3", regex = True),
                  freq = "M" if f[0] == "Mensal" else "Q"
                  ).to_timestamp()
              )
            .set_index("data")
        ),
        how = "outer"
        )
  df_tratado_ibge_sidra[f[0]] = df_temp


# Cruza dados do FRED
df_tratado_fred = df_bruto_fred.copy()

for f in df_tratado_fred.items():
  df_temp = f[1][0].assign(observation_date = lambda x: pd.to_datetime(x.observation_date)).set_index("observation_date")
  for df in f[1][1:]:
    df_temp = df_temp.join(
        other = df.assign(observation_date = lambda x: pd.to_datetime(x.observation_date)).set_index("observation_date"),
        how = "outer"
        )
  df_temp = df_temp.rename_axis(index='data')  
  df_tratado_fred[f[0]] = df_temp

# Agrega dados de frequência diária para mensal por média
df_tratado_fred["Mensal"] = (
    df_tratado_fred["Mensal"]
    .set_index(pd.to_datetime(df_tratado_fred["Mensal"].index))
    .join(
        other = (
            df_tratado_fred["Diária"]
            .set_index(pd.to_datetime(df_tratado_fred["Diária"].index))
            .resample("MS")
            .mean()
        ),
        how = "outer"
      )
    .query("index >= '2000-01-01'")
)

# Representa em porcentagem dados do IFI
df_tratado_ifi = (
    df_bruto_ifi
    .assign(hiato_produto = lambda x: x.hiato_produto.mul(100))
    .query("data >= '2000-01-01'")
    .drop(labels = ["lim_inf", "lim_sup"], axis = "columns")
    .set_index("data")
)
Código
05-disponibilizacao.py
# Cria pasta dados se não existir
pasta = "dados"
if not os.path.exists(pasta):
  os.makedirs(pasta)


# Diária
df_diaria = (
    df_tratado_bcb_sgs["Diária"]
    .join(
        other=df_tratado_ipeadata["Diária"].reset_index().assign(
            data=lambda x: pd.to_datetime(x['data'].dt.strftime("%Y-%m-%d"))
        ).set_index("data"),
        how="outer"
    )
    .join(other=df_tratado_fred["Diária"], how="outer")
    .reset_index()
    .assign(data=lambda x: pd.to_datetime(x['data']))  
    .query("data >= @pd.to_datetime('2000-01-01')")
    .set_index('data')
)
df_diaria.to_parquet(f"{pasta}/df_diaria.parquet")

# Mensal
temp_lista = [
    df_tratado_bcb_sgs["Mensal"],
    df_tratado_bcb_odata_mensal,
    df_tratado_ipeadata["Mensal"],
    df_tratado_ibge_sidra["Mensal"],
    df_tratado_fred["Mensal"]
]

df_mensal = (
  temp_lista[0]
  .join(other = temp_lista[1:], how = "outer")
  .query("index >= @pd.to_datetime('2000-01-01')")
  .astype(float)
  )
df_mensal.to_parquet(f"{pasta}/df_mensal.parquet")

# Trimestral
temp_lista = [
    df_tratado_bcb_sgs["Trimestral"],
    df_tratado_bcb_odata_pib.set_index("data"),
    df_tratado_ibge_sidra["Trimestral"],
    df_tratado_fred["Trimestral"],
    df_tratado_ifi
]

df_trimestral = (
  temp_lista[0]
  .join(other = temp_lista[1:], how = "outer")
  .query("index >= @pd.to_datetime('2000-01-01')")
  .astype(float)
)
df_trimestral.index = pd.to_datetime(df_trimestral.index)
df_trimestral.to_parquet(f"{pasta}/df_trimestral.parquet")

# Anual
df_anual = (
  df_tratado_bcb_sgs["Anual"]
  .query("index >= @pd.to_datetime('2000-01-01')")
  .astype(float)
)
df_anual.to_parquet(f"{pasta}/df_anual.parquet")
Código
06-ipca.py
# Bibliotecas
from skforecast.ForecasterAutoreg import ForecasterAutoreg
from sklearn.linear_model import Ridge, HuberRegressor
from sklearn.preprocessing import PowerTransformer
from io import StringIO
import google.generativeai as genai
import pandas as pd
import numpy as np
import os


# Definições e configurações globais
h = 12 # horizonte de previsão
inicio_treino = pd.to_datetime("2004-01-01") # amostra inicial de treinamento
semente = 1984 # semente para reprodução


# Função para transformar dados, conforme definido nos metadados
def transformar(x, tipo):

  switch = {
      "1": lambda x: x,
      "2": lambda x: x.diff(),
      "3": lambda x: x.diff().diff(),
      "4": lambda x: np.log(x),
      "5": lambda x: np.log(x).diff(),
      "6": lambda x: np.log(x).diff().diff()
  }

  if tipo not in switch:
      raise ValueError("Tipo inválido")

  return switch[tipo](x)


# Planilha de metadados
metadados = (
    pd.read_excel(
        io = "https://docs.google.com/spreadsheets/d/1x8Ugm7jVO7XeNoxiaFPTPm1mfVc3JUNvvVqVjCioYmE/export?format=xlsx",
        sheet_name = "Metadados",
        dtype = str,
        index_col = "Identificador"
        )
    .filter(["Transformação"])
)


# Importa dados online
dados_brutos = pd.read_parquet("dados/df_mensal.parquet")


# Converte frequência
dados_tratados = dados_brutos.asfreq("MS")

# Separa Y
y = dados_tratados.ipca.dropna()

# Separa X
x = dados_tratados.drop(labels = "ipca", axis = "columns").copy()

# Concatena saldo do CAGED antigo com novo
x = (
    x
    .assign(saldo_caged = transformar(x.saldo_caged_antigo.combine_first(x.saldo_caged_novo), "5"))
    .drop(labels = ["saldo_caged_antigo", "saldo_caged_novo"], axis = "columns")
)

# Computa transformações
for col in x.drop(labels = "saldo_caged", axis = "columns").columns.to_list():
  x[col] = transformar(x[col], metadados.loc[col, "Transformação"])

# Filtra amostra
y = y[y.index >= inicio_treino]
x_alem_de_y = x.query("index >= @y.index.max()")
x = x.query("index >= @inicio_treino and index <= @y.index.max()")

# Conta por coluna proporção de NAs em relação ao nº de obs. do IPCA
prop_na = x.isnull().sum() / y.shape[0]

# Remove variáveis que possuem mais de 20% de NAs
x = x.drop(labels = prop_na[prop_na >= 0.2].index.to_list(), axis = "columns")

# Preenche NAs restantes com a vizinhança
x = x.bfill().ffill()

# Adiciona dummies sazonais
dummies_sazonais = (
    pd.get_dummies(y.index.month_name())
    .astype(int)
    .drop(labels = "December", axis = "columns")
    .set_index(y.index)
)
x = x.join(other = dummies_sazonais, how = "outer")

# Seleção final de variáveis
x_reg = [
    "expec_ipca_top5_curto_prazo",
    "ic_br",
    "cambio_brl_eur",
    "ipc_s"
    ] + dummies_sazonais.columns.to_list()
# + 1 lag


# Reestima os 2 melhores modelos com amostra completa
modelo1 = ForecasterAutoreg(
    regressor = Ridge(random_state = semente),
    lags = 1,
    transformer_y = PowerTransformer(),
    transformer_exog = PowerTransformer()
    )
modelo1.fit(y, x[x_reg])

modelo2 = ForecasterAutoreg(
    regressor = HuberRegressor(),
    lags = 1,
    transformer_y = PowerTransformer(),
    transformer_exog = PowerTransformer()
    )
modelo2.fit(y, x[x_reg])


# Período de previsão fora da amostra
periodo_previsao = pd.date_range(
    start = modelo1.last_window.index[0] + pd.offsets.MonthBegin(1),
    end = modelo1.last_window.index[0] + pd.offsets.MonthBegin(h),
    freq = "MS"
    )

# Coleta dados de expectativas de inflação (expec_ipca_top5_curto_prazo)
dados_focus_exp_ipca = (
    pd.read_csv(
        filepath_or_buffer = f"https://olinda.bcb.gov.br/olinda/servico/Expectativas/versao/v1/odata/ExpectativasMercadoTop5Mensais?$filter=Indicador%20eq%20'IPCA'%20and%20tipoCalculo%20eq%20'C'%20and%20Data%20ge%20'{periodo_previsao.min().strftime('%Y-%m-%d')}'&$format=text/csv",
        decimal = ",",
        converters = {
            "Data": pd.to_datetime,
            "DataReferencia": lambda x: pd.to_datetime(x, format = "%m/%Y")
            }
        ))

# Data do relatório Focus usada para construir cenário para expectativas de inflação
data_focus_exp_ipca = (
    dados_focus_exp_ipca
    .query("DataReferencia in @periodo_previsao")
    .Data
    .value_counts()
    .to_frame()
    .reset_index()
    .query("count == @h").query("Data == Data.max()")
    .Data
    .to_list()[0]
)

# Constrói cenário para expectativas de inflação (expec_ipca_top5_curto_prazo)
dados_cenario_exp_ipca = (
    dados_focus_exp_ipca
    .query("DataReferencia in @periodo_previsao")
    .query("Data == @data_focus_exp_ipca")
    .set_index("DataReferencia")
    .filter(["Mediana"])
    .rename(columns = {"Mediana": "expec_ipca_top5_curto_prazo"})
)

# Constrói cenário para commodities (ic_br)
dados_cenario_ic_br = (
    x
    .filter(["ic_br"])
    .dropna()
    .query("index >= @inicio_treino")
    .assign(mes = lambda x: x.index.month_name())
    .groupby(["mes"], as_index = False)
    .ic_br
    .median()
    .set_index("mes")
    .join(
        other = (
            periodo_previsao
            .rename("data")
            .to_frame()
            .assign(mes = lambda x: x.data.dt.month_name())
            .drop("data", axis = "columns")
            .reset_index()
            .set_index("mes")
        ),
        how = "outer"
    )
    .set_index("data")
)

# Coleta dados de expectativas do câmbio (cambio_brl_eur)
dados_focus_cambio = (
    pd.read_csv(
        filepath_or_buffer = f"https://olinda.bcb.gov.br/olinda/servico/Expectativas/versao/v1/odata/ExpectativasMercadoTop5Mensais?$filter=Indicador%20eq%20'C%C3%A2mbio'%20and%20tipoCalculo%20eq%20'M'%20and%20Data%20ge%20'{modelo1.last_window.index[0].strftime('%Y-%m-%d')}'&$format=text/csv",
        decimal = ",",
        converters = {
            "Data": pd.to_datetime,
            "DataReferencia": lambda x: pd.to_datetime(x, format = "%m/%Y")
            }
        ))

# Data do relatório Focus usada para construir cenário para câmbio
data_focus_cambio = (
    dados_focus_cambio
    .query("DataReferencia in @periodo_previsao or DataReferencia == @modelo1.last_window.index[0]")
    .Data
    .value_counts()
    .to_frame()
    .reset_index()
    .query("count == @h+1").query("Data == Data.max()")
    .Data
    .to_list()[0]
)

# Constrói cenário para câmbio (cambio_brl_eur)
dados_cenario_cambio = (
    dados_focus_cambio
    .query("DataReferencia in @periodo_previsao or DataReferencia == @modelo1.last_window.index[0]")
    .query("Data == @data_focus_cambio")
    .set_index("DataReferencia")
    .filter(["Mediana"])
    .rename(columns = {"Mediana": "cambio_brl_eur"})
    .assign(
        cambio_brl_eur = lambda x: transformar(x.cambio_brl_eur, metadados.loc["cambio_brl_eur"].iloc[0])
        )
    .dropna()
)

# Constrói cenário para prévia de preços (ipc_s)
dados_cenario_ipc_s = (
    x
    .filter(["ipc_s"])
    .dropna()
    .query("index >= @inicio_treino")
    .assign(mes = lambda x: x.index.month_name())
    .groupby(["mes"], as_index = False)
    .ipc_s
    .median()
    .set_index("mes")
    .join(
        other = (
            periodo_previsao
            .rename("data")
            .to_frame()
            .assign(mes = lambda x: x.data.dt.month_name())
            .drop("data", axis = "columns")
            .reset_index()
            .set_index("mes")
        ),
        how = "outer"
    )
    .set_index("data")
)

# Junta cenários e gera dummies sazonais
dados_cenarios = (
    dados_cenario_exp_ipca
    .join(
        other = [
            dados_cenario_ic_br,
            dados_cenario_cambio,
            dados_cenario_ipc_s,
            (
                pd.get_dummies(dados_cenario_exp_ipca.index.month_name())
                .astype(int)
                .drop(labels = "December", axis = "columns")
                .set_index(dados_cenario_exp_ipca.index)
            )
            ],
        how = "outer"
        )
)

# Produz previsões
previsao1 = (
   modelo1.predict_interval(
      steps = h,
      exog = dados_cenarios,
      n_boot = 5000,
      random_state = semente
      )
    .assign(Tipo = "Ridge")
    .rename(
       columns = {
          "pred": "Valor", 
          "lower_bound": "Intervalo Inferior", 
          "upper_bound": "Intervalo Superior"
          }
    )
)

previsao2 = (
   modelo2.predict_interval(
      steps = h,
      exog = dados_cenarios,
      n_boot = 5000,
      random_state = semente
      )
    .assign(Tipo = "Huber")
    .rename(
       columns = {
          "pred": "Valor", 
          "lower_bound": "Intervalo Inferior", 
          "upper_bound": "Intervalo Superior"
          }
    )
)

y.to_frame().join(x[x_reg]).to_csv("dados/ipca.csv")
prompt = f"""
Assume that you are in {pd.to_datetime("today").strftime("%B %d, %Y")}. 
Please give me your best forecast of month-over-month IPCA inflation rate in 
Brazil, published by IBGE, for {periodo_previsao.min().strftime("%B %Y")} to 
{periodo_previsao.max().strftime("%B %Y")}. Use the historical IPCA data from 
the attached CSV file named "ipca.csv", where "ipca" is the target 
column, "data" is the date column and the others are exogenous variables. 
Please give me numeric values for these forecasts, in a CSV like format with 
a header, and nothing more. Do not use any information that was not available 
to you as of {pd.to_datetime("today").strftime("%B %d, %Y")} to formulate these 
forecasts.
"""

genai.configure(api_key = os.environ["GEMINI_API_KEY"])
modelo_ia = genai.GenerativeModel(model_name = "gemini-1.5-pro")
arquivo = genai.upload_file("dados/ipca.csv")
previsao3 = pd.read_csv(
    filepath_or_buffer = StringIO(modelo_ia.generate_content([prompt, arquivo]).text),
    names = ["date", "Valor"],
    skiprows = 1,
    index_col = "date",
    converters = {"date": pd.to_datetime}
    ).assign(Tipo = "IA")

# Salvar previsões
pasta = "previsao"
if not os.path.exists(pasta):
  os.makedirs(pasta)
  
pd.concat([
    y.rename("Valor").to_frame().assign(Tipo = "IPCA"),
    previsao1,
    previsao2,
    previsao3
    ]).to_parquet("previsao/ipca.parquet")
Código
07-cambio.py
# Bibliotecas
from skforecast.ForecasterAutoreg import ForecasterAutoreg
from sklearn.linear_model import BayesianRidge, HuberRegressor
from sklearn.preprocessing import PowerTransformer
from io import StringIO
import google.generativeai as genai
import pandas as pd
import numpy as np
import os


# Definições e configurações globais
h = 12 # horizonte de previsão
inicio_treino = pd.to_datetime("2004-01-01") # amostra inicial de treinamento
semente = 1984 # semente para reprodução


# Função para transformar dados, conforme definido nos metadados
def transformar(x, tipo):

  switch = {
      "1": lambda x: x,
      "2": lambda x: x.diff(),
      "3": lambda x: x.diff().diff(),
      "4": lambda x: np.log(x),
      "5": lambda x: np.log(x).diff(),
      "6": lambda x: np.log(x).diff().diff()
  }

  if tipo not in switch:
      raise ValueError("Tipo inválido")

  return switch[tipo](x)


# Planilha de metadados
metadados = (
    pd.read_excel(
        io = "https://docs.google.com/spreadsheets/d/1x8Ugm7jVO7XeNoxiaFPTPm1mfVc3JUNvvVqVjCioYmE/export?format=xlsx",
        sheet_name = "Metadados",
        dtype = str,
        index_col = "Identificador"
        )
    .filter(["Transformação"])
)

# Importa dados online
dados_brutos_m = pd.read_parquet("dados/df_mensal.parquet")
dados_brutos_t = pd.read_parquet("dados/df_trimestral.parquet")
dados_brutos_a = pd.read_parquet("dados/df_anual.parquet")

# Converte frequência
dados_tratados = (
    dados_brutos_m
    .asfreq("MS")
    .join(
        other = dados_brutos_a.asfreq("MS").ffill(),
        how = "outer"
        )
    .join(
        other = (
            dados_brutos_t
            .filter(["us_gdp", "pib"])
            .dropna()
            .assign(us_gdp = lambda x: ((x.us_gdp.rolling(4).mean() / x.us_gdp.rolling(4).mean().shift(4)) - 1) * 100)
            .asfreq("MS")
            .ffill()
        ),
        how = "outer"
    )
    .rename_axis("data", axis = "index")
)

# Separa Y
y = dados_tratados.cambio.dropna()

# Separa X
x = dados_tratados.drop(labels = "cambio", axis = "columns").copy()

# Computa transformações
for col in x.drop(labels = ["saldo_caged_antigo", "saldo_caged_novo"], axis = "columns").columns.to_list():
  x[col] = transformar(x[col], metadados.loc[col, "Transformação"])

# Filtra amostra
y = y[y.index >= inicio_treino]
x_alem_de_y = x.query("index >= @y.index.max()")
x = x.query("index >= @inicio_treino and index <= @y.index.max()")

# Conta por coluna proporção de NAs em relação ao nº de obs. do IPCA
prop_na = x.isnull().sum() / y.shape[0]

# Remove variáveis que possuem mais de 20% de NAs
x = x.drop(labels = prop_na[prop_na >= 0.2].index.to_list(), axis = "columns")

# Preenche NAs restantes com a vizinhança
x = x.bfill().ffill()


# Seleção final de variáveis
x_reg = [
    "selic",
    "expec_cambio",
    "ic_br_agro",
    "cotacao_petroleo_fmi"
    ]
# + 1 lag


# Reestima os 2 melhores modelos com amostra completa
modelo1 = ForecasterAutoreg(
    regressor = BayesianRidge(),
    lags = 1,
    transformer_y = PowerTransformer(),
    transformer_exog = PowerTransformer()
    )
modelo1.fit(y, x[x_reg])

modelo2 = ForecasterAutoreg(
    regressor = HuberRegressor(),
    lags = 1,
    transformer_y = PowerTransformer(),
    transformer_exog = PowerTransformer()
    )
modelo2.fit(y, x[x_reg])

# Período de previsão fora da amostra
periodo_previsao = pd.date_range(
    start = modelo1.last_window.index[0] + pd.offsets.MonthBegin(1),
    end = modelo1.last_window.index[0] + pd.offsets.MonthBegin(h),
    freq = "MS"
    )

# Coleta dados de expectativas da Selic (selic)
dados_focus_selic = (
    pd.read_csv(
        filepath_or_buffer = f"https://olinda.bcb.gov.br/olinda/servico/Expectativas/versao/v1/odata/ExpectativasMercadoTop5Selic?$filter=Data%20ge%20'{modelo1.last_window.index[0].strftime('%Y-%m-%d')}'%20and%20tipoCalculo%20eq%20'C'&$format=text/csv",
        decimal = ",",
        converters = {
            "Data": pd.to_datetime,
            "DataReferencia": lambda x: pd.to_datetime(x, format = "%m/%Y")
            }
        ))

# Constrói cenário para expectativas de juros (selic)
dados_cenario_selic = (
    dados_focus_selic
    .query("Data == Data.max()")
    .rename(columns = {"mediana": "selic"})
    .head(12)
    .filter(["selic"])
    .set_index(periodo_previsao)
)

# Coleta dados de expectativas do câmbio (expec_cambio)
dados_focus_cambio = (
    pd.read_csv(
        filepath_or_buffer = f"https://olinda.bcb.gov.br/olinda/servico/Expectativas/versao/v1/odata/ExpectativaMercadoMensais?$filter=Indicador%20eq%20'C%C3%A2mbio'%20and%20baseCalculo%20eq%200%20and%20Data%20ge%20'{modelo1.last_window.index[0].strftime('%Y-%m-%d')}'&$format=text/csv",
        decimal = ",",
        converters = {
            "Data": pd.to_datetime,
            "DataReferencia": lambda x: pd.to_datetime(x, format = "%m/%Y")
            }
        ))

# Data do relatório Focus usada para construir cenário para câmbio
data_focus_cambio = (
    dados_focus_cambio
    .query("DataReferencia in @periodo_previsao or DataReferencia == @modelo1.last_window.index[0]")
    .Data
    .value_counts()
    .to_frame()
    .reset_index()
    .query("count == @h")
    .query("Data == Data.max()")
    .Data
    .to_list()[0]
)

# Constrói cenário para câmbio (expec_cambio)
dados_cenario_cambio = (
    dados_focus_cambio
    .query("DataReferencia in @periodo_previsao or DataReferencia == @modelo1.last_window.index[0]")
    .query("Data == @data_focus_cambio")
    .sort_values(by = "DataReferencia")
    .set_index("DataReferencia")
    .filter(["Mediana"])
    .rename(columns = {"Mediana": "expec_cambio"})
    .dropna()
)

# Constrói cenário para commodities (ic_br_agro)
dados_cenario_ic_br_agro = (
    x
    .filter(["ic_br_agro"])
    .dropna()
    .query("index >= @inicio_treino")
    .assign(mes = lambda x: x.index.month_name())
    .groupby(["mes"], as_index = False)
    .ic_br_agro
    .median()
    .set_index("mes")
    .join(
        other = (
            periodo_previsao
            .rename("data")
            .to_frame()
            .assign(mes = lambda x: x.data.dt.month_name())
            .drop("data", axis = "columns")
            .reset_index()
            .set_index("mes")
        ),
        how = "outer"
    )
    .sort_values(by = "data")
    .set_index("data")
)

# Constrói cenário para Petróleo (cotacao_petroleo_fmi)
dados_cenario_cotacao_petroleo_fmi = (
    x
    .filter(["cotacao_petroleo_fmi"])
    .dropna()
    .query("index >= @inicio_treino")
    .assign(mes = lambda x: x.index.month_name())
    .groupby(["mes"], as_index = False)
    .cotacao_petroleo_fmi
    .median()
    .set_index("mes")
    .join(
        other = (
            periodo_previsao
            .rename("data")
            .to_frame()
            .assign(mes = lambda x: x.data.dt.month_name())
            .drop("data", axis = "columns")
            .reset_index()
            .set_index("mes")
        ),
        how = "outer"
    )
    .sort_values(by = "data")
    .set_index("data")
)

# Junta cenários e gera dummies sazonais
dados_cenarios = (
    dados_cenario_selic
    .join(
        other = [
            dados_cenario_cambio,
            dados_cenario_ic_br_agro,
            dados_cenario_cotacao_petroleo_fmi
            ],
        how = "outer"
        )
)

# Produz previsões
previsao1 = (
   modelo1.predict_interval(
      steps = h,
      exog = dados_cenarios,
      n_boot = 5000,
      random_state = semente
      )
    .assign(Tipo = "Bayesian Ridge")
    .rename(
       columns = {
          "pred": "Valor", 
          "lower_bound": "Intervalo Inferior", 
          "upper_bound": "Intervalo Superior"
          }
    )
)

previsao2 = (
   modelo2.predict_interval(
      steps = h,
      exog = dados_cenarios,
      n_boot = 5000,
      random_state = semente
      )
    .assign(Tipo = "Huber")
    .rename(
       columns = {
          "pred": "Valor", 
          "lower_bound": "Intervalo Inferior", 
          "upper_bound": "Intervalo Superior"
          }
    )
)

y.to_frame().join(x[x_reg]).to_csv("dados/cambio.csv")
prompt = f"""
Assume that you are in {pd.to_datetime("today").strftime("%B %d, %Y")}. 
Please give me your best forecast of Exchange Rate for Brazil, measured in BRL/USD 
and published by Banco Central do Brasil, for {periodo_previsao.min().strftime("%B %Y")} 
to {periodo_previsao.max().strftime("%B %Y")}. Use the historical Exchange Rate 
data from the attached CSV file named "cambio.csv", where "cambio" is the target 
column, "data" is the date column and the others are exogenous variables. 
Please give me numeric values for these forecasts, in a CSV like format with 
a header, and nothing more. Do not use any information that was not available 
to you as of {pd.to_datetime("today").strftime("%B %d, %Y")} to formulate these 
forecasts.
"""

genai.configure(api_key = os.environ["GEMINI_API_KEY"])
modelo_ia = genai.GenerativeModel(model_name = "gemini-1.5-pro")
arquivo = genai.upload_file("dados/cambio.csv")
previsao3 = pd.read_csv(
    filepath_or_buffer = StringIO(modelo_ia.generate_content([prompt, arquivo]).text),
    names = ["date", "Valor"],
    skiprows = 1,
    index_col = "date",
    converters = {"date": pd.to_datetime}
    ).assign(Tipo = "IA")

# Salvar previsões
pasta = "previsao"
if not os.path.exists(pasta):
  os.makedirs(pasta)
  
pd.concat(
    [y.rename("Valor").to_frame().assign(Tipo = "Câmbio"),
    previsao1,
    previsao2,
    previsao3
    ]).to_parquet("previsao/cambio.parquet")
Código
08-pib.py
# Bibliotecas
from skforecast.ForecasterAutoreg import ForecasterAutoreg
from sklearn.linear_model import Ridge, BayesianRidge
from sklearn.preprocessing import PowerTransformer
from io import StringIO
import google.generativeai as genai
import pandas as pd
import numpy as np
import os

# Definições e configurações globais
h = 4 # horizonte de previsão
inicio_treino = pd.to_datetime("1997-10-01") # amostra inicial de treinamento
semente = 1984 # semente para reprodução

# Função para transformar dados, conforme definido nos metadados
def transformar(x, tipo):

  switch = {
      "1": lambda x: x,
      "2": lambda x: x.diff(),
      "3": lambda x: x.diff().diff(),
      "4": lambda x: np.log(x),
      "5": lambda x: np.log(x).diff(),
      "6": lambda x: np.log(x).diff().diff()
  }

  if tipo not in switch:
      raise ValueError("Tipo inválido")

  return switch[tipo](x)

# Planilha de metadados
metadados = (
    pd.read_excel(
        io = "https://docs.google.com/spreadsheets/d/1x8Ugm7jVO7XeNoxiaFPTPm1mfVc3JUNvvVqVjCioYmE/export?format=xlsx",
        sheet_name = "Metadados",
        dtype = str,
        index_col = "Identificador"
        )
    .filter(["Transformação"])
)

# Importa dados online
dados_brutos_m = pd.read_parquet("dados/df_mensal.parquet")
dados_brutos_t = pd.read_parquet("dados/df_trimestral.parquet")

# Converte frequência
dados_tratados = (
    dados_brutos_m
    .resample("QS")
    .mean()
    .join(
        other = (
            dados_brutos_t
            .set_index(pd.PeriodIndex(dados_brutos_t.index, freq = "Q").to_timestamp())
            .resample("QS")
            .mean()
            ),
        how = "outer"
    )
    .rename_axis("data", axis = "index")
)

# Separa Y
y = dados_tratados.pib.dropna()

# Separa X
x = dados_tratados.drop(labels = ["pib"], axis = "columns").copy()

# Computa transformações
for col in x.drop(labels = ["saldo_caged_antigo", "saldo_caged_novo"], axis = "columns").columns.to_list():
  x[col] = transformar(x[col], metadados.loc[col, "Transformação"])

# Filtra amostra
y = y[y.index >= inicio_treino]
x_alem_de_y = x.query("index >= @y.index.max()")
x = x.query("index >= @inicio_treino and index <= @y.index.max()")

# Conta por coluna proporção de NAs em relação ao nº de obs. de Y
prop_na = x.isnull().sum() / y.shape[0]

# Remove variáveis que possuem mais de 20% de NAs
x = x.drop(labels = prop_na[prop_na >= 0.2].index.to_list(), axis = "columns")

# Preenche NAs restantes com a vizinhança
x = x.bfill().ffill()

# Seleção final de variáveis
x_reg = [
    "uci_ind_fgv",
    "expec_pib",
    "prod_ind_metalurgia"
    ]
# + 2 lags


# Reestima os 2 melhores modelos com amostra completa
modelo1 = ForecasterAutoreg(
    regressor = Ridge(),
    lags = 2,
    transformer_y = PowerTransformer(),
    transformer_exog = PowerTransformer()
    )
modelo1.fit(y, x[x_reg])

modelo2 = ForecasterAutoreg(
    regressor = BayesianRidge(),
    lags = 2,
    transformer_y = PowerTransformer(),
    transformer_exog = PowerTransformer()
    )
modelo2.fit(y, x[x_reg])


# Período de previsão fora da amostra
periodo_previsao = pd.date_range(
    start = modelo1.last_window.index[1] + pd.offsets.QuarterBegin(1),
    end = modelo1.last_window.index[1] + pd.offsets.QuarterBegin(h + 1),
    freq = "QS"
    )


# Constrói cenário para Utilização da Capacidade Instalada (uci_ind_fgv)
dados_cenario_uci_ind_fgv = (
    x
    .filter(["uci_ind_fgv"])
    .dropna()
    .query("index >= @inicio_treino")
    .assign(trim = lambda x: x.index.quarter)
    .groupby(["trim"], as_index = False)
    .uci_ind_fgv
    .median()
    .set_index("trim")
    .join(
        other = (
            periodo_previsao
            .rename("data")
            .to_frame()
            .assign(trim = lambda x: x.data.dt.quarter)
            .drop("data", axis = "columns")
            .reset_index()
            .set_index("trim")
        ),
        how = "outer"
    )
    .sort_values(by = "data")
    .set_index("data")
)

# Coleta dados de expectativas do PIB (expec_pib)
dados_focus_expec_pib = pd.read_csv(
    filepath_or_buffer = f"https://olinda.bcb.gov.br/olinda/servico/Expectativas/versao/v1/odata/ExpectativasMercadoTrimestrais?$filter=Indicador%20eq%20'PIB%20Total'%20and%20baseCalculo%20eq%200%20and%20Data%20ge%20'{periodo_previsao.min().strftime('%Y-%m-%d')}'&$format=text/csv",
    decimal = ",",
    converters = {"Data": pd.to_datetime}
    )

# Data do relatório Focus usada para construir cenário para Expectativas PIB (expec_pib)
data_focus_expec_pib = (
    dados_focus_expec_pib
    .assign(
        DataReferencia = lambda x: pd.PeriodIndex(
            x.DataReferencia.str.replace(r"(\d{1})/(\d{4})", r"\2-Q\1", regex = True),
            freq = "Q"
            ).to_timestamp()
    )
    .query("DataReferencia in @periodo_previsao or DataReferencia == @modelo1.last_window.index[1]")
    .Data
    .value_counts()
    .to_frame()
    .reset_index()
    .query("count >= @h")
    .query("Data == Data.max()")
    .head(1)
    .Data
    .to_list()[0]
)

# Constrói cenário para expectativas do PIB (expec_pib)
dados_cenario_expec_pib = (
    dados_focus_expec_pib
    .assign(
        DataReferencia = lambda x: pd.PeriodIndex(
            x.DataReferencia.str.replace(r"(\d{1})/(\d{4})", r"\2-Q\1", regex = True),
            freq = "Q"
            ).to_timestamp()
    )
    .query("DataReferencia in @periodo_previsao or DataReferencia == @modelo1.last_window.index[1]")
    .query("Data == @data_focus_expec_pib")
    .query("DataReferencia in @periodo_previsao")
    .sort_values(by = "DataReferencia")
    .set_index("DataReferencia")
    .filter(["Mediana"])
    .rename(columns = {"Mediana": "expec_pib"})
    .dropna()
)

# Constrói cenário para Produção Industrial (prod_ind_metalurgia)
dados_cenario_prod_ind_metalurgia = (
    x
    .filter(["prod_ind_metalurgia"])
    .dropna()
    .query("index >= @inicio_treino")
    .assign(trim = lambda x: x.index.quarter)
    .groupby(["trim"], as_index = False)
    .prod_ind_metalurgia
    .median()
    .set_index("trim")
    .join(
        other = (
            periodo_previsao
            .rename("data")
            .to_frame()
            .assign(trim = lambda x: x.data.dt.quarter)
            .drop("data", axis = "columns")
            .reset_index()
            .set_index("trim")
        ),
        how = "outer"
    )
    .sort_values(by = "data")
    .set_index("data")
)

# Junta cenários e gera dummies sazonais
dados_cenarios = (
    dados_cenario_uci_ind_fgv
    .join(
        other = [
            dados_cenario_expec_pib,
            dados_cenario_prod_ind_metalurgia
            ],
        how = "outer"
        )
    .asfreq("QS")
)

# Produz previsões
previsao1 = (
   modelo1.predict_interval(
      steps = h,
      exog = dados_cenarios,
      n_boot = 5000,
      random_state = semente
      )
    .assign(Tipo = "Ridge")
    .rename(
       columns = {
          "pred": "Valor", 
          "lower_bound": "Intervalo Inferior", 
          "upper_bound": "Intervalo Superior"
          }
    )
)

previsao2 = (
   modelo2.predict_interval(
      steps = h,
      exog = dados_cenarios,
      n_boot = 5000,
      random_state = semente
      )
    .assign(Tipo = "Bayesian Ridge")
    .rename(
       columns = {
          "pred": "Valor", 
          "lower_bound": "Intervalo Inferior", 
          "upper_bound": "Intervalo Superior"
          }
    )
)

y.to_frame().join(x[x_reg]).to_csv("dados/pib.csv")
prompt = f"""
Assume that you are in {pd.to_datetime("today").strftime("%B %d, %Y")}. 
Please give me your best forecast of Gross Domestic Product (GDP) for Brazil, 
measured in annual percentage variation (accumulated rate in four quarters in 
relation to the same period of the previous year) and published by IBGE, for 
{periodo_previsao.min().to_period(freq = "Q").strftime("%Y Q%q")} to {periodo_previsao.max().to_period(freq = "Q").strftime("%Y Q%q")}. 
Use the historical GDP data from the attached CSV file named "pib.csv", where "pib" 
is the target column, "data" is the date column and the others are exogenous variables. 
Please give me numeric values for these forecasts, in a CSV like format with 
a header, and nothing more. Do not use any information that was not available 
to you as of {pd.to_datetime("today").strftime("%B %d, %Y")} to formulate these 
forecasts.
"""

genai.configure(api_key = os.environ["GEMINI_API_KEY"])
modelo_ia = genai.GenerativeModel(model_name = "gemini-1.5-pro")
arquivo = genai.upload_file("dados/pib.csv")
previsao3 = pd.read_csv(
    filepath_or_buffer = StringIO(modelo_ia.generate_content([prompt, arquivo]).text),
    names = ["date", "Valor"],
    skiprows = 1,
    index_col = "date",
    converters = {"date": pd.to_datetime}
    ).assign(Tipo = "IA")

# Salvar previsões
pasta = "previsao"
if not os.path.exists(pasta):
  os.makedirs(pasta)
  
pd.concat(
    [y.rename("Valor").to_frame().assign(Tipo = "PIB"),
    previsao1,
    previsao2,
    previsao3
    ]).to_parquet("previsao/pib.parquet")
Código
09-selic.py
# Bibliotecas
from skforecast.ForecasterAutoreg import ForecasterAutoreg
from sklearn.ensemble import VotingRegressor
from sklearn.linear_model import Ridge, BayesianRidge
from sklearn.svm import LinearSVR
from sklearn.preprocessing import PowerTransformer
from io import StringIO
import google.generativeai as genai
import statsmodels.api as sm
import pandas as pd
import numpy as np
import os

# Definições e configurações globais
h = 12 # horizonte de previsão
inicio_treino = pd.to_datetime("2004-01-01") # amostra inicial de treinamento
semente = 1984 # semente para reprodução

# Função para transformar dados, conforme definido nos metadados
def transformar(x, tipo):

  switch = {
      "1": lambda x: x,
      "2": lambda x: x.diff(),
      "3": lambda x: x.diff().diff(),
      "4": lambda x: np.log(x),
      "5": lambda x: np.log(x).diff(),
      "6": lambda x: np.log(x).diff().diff()
  }

  if tipo not in switch:
      raise ValueError("Tipo inválido")

  return switch[tipo](x)

# Planilha de metadados
metadados = (
    pd.read_excel(
        io = "https://docs.google.com/spreadsheets/d/1x8Ugm7jVO7XeNoxiaFPTPm1mfVc3JUNvvVqVjCioYmE/export?format=xlsx",
        sheet_name = "Metadados",
        dtype = str,
        index_col = "Identificador"
        )
    .filter(["Transformação"])
)

# Importa dados online
dados_brutos_m = pd.read_parquet("dados/df_mensal.parquet")
dados_brutos_a = pd.read_parquet("dados/df_anual.parquet")

# Converte frequência
dados_tratados = (
    dados_brutos_m
    .asfreq("MS")
    .join(
        other = dados_brutos_a.asfreq("MS").ffill(),
        how = "outer"
        )
    .rename_axis("data", axis = "index")
)

# Separa Y
y = dados_tratados.selic.dropna()

# Separa X
x = dados_tratados.drop(labels = "selic", axis = "columns").copy()

# Cria variáveis para modelos teóricos
x_teorico = (
    x
    .copy()
    .join(other = y, how = "outer")
    .assign(
        selic_lag1 = lambda x: x.selic.shift(1),
        selic_lag2 = lambda x: x.selic.shift(2),
        pib_potencial = lambda x: sm.tsa.filters.hpfilter(x.pib_acum12m.ffill(), 14400)[1],
        pib_hiato = lambda x: (x.pib_acum12m / x.pib_potencial - 1) * 100,
        pib_hiato_lag1 = lambda x: x.pib_hiato.shift(1),
        inflacao_hiato = lambda x: x.expec_ipca_12m - x.meta_inflacao.shift(-12)
    )
    .filter([
        "selic_lag1",
        "selic_lag2",
        "pib_hiato",
        "pib_hiato_lag1",
        "inflacao_hiato"
        ])
)

# Computa transformações
for col in x.drop(labels = ["saldo_caged_antigo", "saldo_caged_novo"], axis = "columns").columns.to_list():
  x[col] = transformar(x[col], metadados.loc[col, "Transformação"])

# Filtra amostra
y = y[y.index >= inicio_treino]
x_alem_de_y = x.query("index >= @y.index.max()")
x = x.query("index >= @inicio_treino and index <= @y.index.max()")
x_teorico = x_teorico.query("index >= @inicio_treino and index <= @y.index.max()")

# Conta por coluna proporção de NAs em relação ao nº de obs. de Y
prop_na = x.isnull().sum() / y.shape[0]

# Remove variáveis que possuem mais de 20% de NAs
x = x.drop(labels = prop_na[prop_na >= 0.2].index.to_list(), axis = "columns")

# Preenche NAs restantes com a vizinhança
x = x.bfill().ffill()
x_teorico = x_teorico.bfill().ffill()


# Reestima os 2 melhores modelos com amostra completa
modelo1 = ForecasterAutoreg(
    regressor = VotingRegressor([
        ("bayes", BayesianRidge()),
        ("svr", LinearSVR(random_state = semente, dual = True, max_iter = 100000)),
        ("ridge", Ridge(random_state = semente))
        ]),
    lags = 2,
    transformer_y = PowerTransformer(),
    transformer_exog = PowerTransformer()
    )
modelo1.fit(y, x_teorico)

modelo2 = ForecasterAutoreg(
    regressor = BayesianRidge(),
    lags = 2,
    transformer_y = PowerTransformer(),
    transformer_exog = PowerTransformer()
    )
modelo2.fit(y, x_teorico)


# Período de previsão fora da amostra
periodo_previsao = pd.date_range(
    start = modelo1.last_window.index[1] + pd.offsets.MonthBegin(1),
    end = modelo1.last_window.index[1] + pd.offsets.MonthBegin(h),
    freq = "MS"
    )

# Constrói cenários constantes (selic_lag1, selic_lag2, pib_hiato, pib_hiato_lag1)
dados_cenario_constante = (
    x_teorico
    .drop("inflacao_hiato", axis = "columns")
    .join(
        other = periodo_previsao.rename("data").to_frame(),
        how = "outer"
        )
    .ffill()
    .query("index >= @periodo_previsao.min()")
    .drop("data", axis = "columns")
)

# Coleta dados de expectativas de inflação (expec_ipca_12m)
dados_focus_expec_ipca_12m = (
    pd.read_csv(
        filepath_or_buffer = f"https://olinda.bcb.gov.br/olinda/servico/Expectativas/versao/v1/odata/ExpectativasMercadoInflacao12Meses?$filter=Indicador%20eq%20'IPCA'%20and%20Suavizada%20eq%20'S'%20and%20baseCalculo%20eq%200%20and%20Data%20ge%20'{(periodo_previsao.min() - pd.offsets.MonthBegin(3)).strftime('%Y-%m-%d')}'&$format=text/csv",
        decimal = ",",
        converters = {"Data": pd.to_datetime}
        )
    )

# Constrói cenários para Hiato da inflação (inflacao_hiato)
dados_cenario_inflacao_hiato = (
    dados_focus_expec_ipca_12m
    .assign(
        data = lambda x: x.Data.dt.to_period("M").dt.to_timestamp(),
        expec_ipca_12m = lambda x: x.Mediana
        )
    .groupby("data", as_index = False)
    .expec_ipca_12m
    .mean()
    .set_index("data")
    .join(
        other = (
            pd.concat([
                periodo_previsao.to_series(),
                (periodo_previsao + pd.offsets.MonthBegin(h)).to_series()
                ])
            .index
            .rename("data")
            .to_frame()
        ),
        how = "outer"
        )
    .ffill()
    .query("index >= @periodo_previsao.min()")
    .drop("data", axis = "columns")
    .join(
        other = pd.Series(
            dados_tratados.filter(["meta_inflacao"]).dropna().iloc[-1].to_list() * periodo_previsao.shape[0], 
            index = periodo_previsao,
            name = "meta_inflacao"
            ),
        how = "left"
        )
    .ffill()
    .assign(inflacao_hiato = lambda x: x.expec_ipca_12m - x.meta_inflacao.shift(-h))
    .query("index <= @periodo_previsao.max()")
    .filter(["inflacao_hiato"])
)

# Junta cenários
dados_cenarios = dados_cenario_constante.join(
    other = dados_cenario_inflacao_hiato,
    how = "outer"
    )

# Produz previsões
previsao1 = (
   modelo1.predict_interval(
      steps = h,
      exog = dados_cenarios,
      n_boot = 5000,
      random_state = semente
      )
    .assign(Tipo = "Ensemble")
    .rename(
       columns = {
          "pred": "Valor", 
          "lower_bound": "Intervalo Inferior", 
          "upper_bound": "Intervalo Superior"
          }
    )
)

previsao2 = (
   modelo2.predict_interval(
      steps = h,
      exog = dados_cenarios,
      n_boot = 5000,
      random_state = semente
      )
    .assign(Tipo = "Bayesian Ridge")
    .rename(
       columns = {
          "pred": "Valor", 
          "lower_bound": "Intervalo Inferior", 
          "upper_bound": "Intervalo Superior"
          }
    )
)

y.to_frame().join(x_teorico).to_csv("dados/selic.csv")
prompt = f"""
Assume that you are in {pd.to_datetime("today").strftime("%B %d, %Y")}. 
Please give me your best forecast of Selic Target Interest Rate for Brazil, 
measured in % per annum and published by Banco Central do Brasil, for {periodo_previsao.min().strftime("%B %Y")} 
to {periodo_previsao.max().strftime("%B %Y")}. 
Use the historical Selic Target Interest Rate data from the attached CSV file 
named "selic.csv", where "selic" is the target column, "data" is the date column 
and the others are exogenous variables. Please give me numeric values for these 
forecasts, in a CSV like format with a header, and nothing more. Do not use any 
information that was not available to you as of {pd.to_datetime("today").strftime("%B %d, %Y")} 
to formulate these forecasts.
"""

genai.configure(api_key = os.environ["GEMINI_API_KEY"])
modelo_ia = genai.GenerativeModel(model_name = "gemini-1.5-pro")
arquivo = genai.upload_file("dados/selic.csv")
previsao3 = pd.read_csv(
    filepath_or_buffer = StringIO(modelo_ia.generate_content([prompt, arquivo]).text),
    names = ["date", "Valor"],
    skiprows = 1,
    index_col = "date",
    converters = {"date": pd.to_datetime}
    ).assign(Tipo = "IA")

# Salvar previsões
pasta = "previsao"
if not os.path.exists(pasta):
  os.makedirs(pasta)
  
pd.concat(
    [y.rename("Valor").to_frame().assign(Tipo = "Selic"),
    previsao1,
    previsao2,
    previsao3
    ]).to_parquet("previsao/selic.parquet")

Passo 03: enviar arquivos

Aqui vamos começar a trabalhar online pelo GitHub, enviando nossos arquivos de código do computador para a plataforma online.

Na página do repositório criado anteriormente:

  1. Acesse o VS Code clicando em Code > Codespaces > Create codespace on main/master
  2. Localize os arquivos/pastas no seu PC, selecione-os, clique, arraste para a página do VS Code e solte no painel Explorer (ou crie os arquivos na própria IDE)
  3. Clique em Source Control, clique em “+” (Stage all changes), digite uma mensagem para o histórico do repositório, clique em Commit e depois em Sync changes e OK.

Recomendação: crie e utilize o ambiente Codespaces quando precisar, mas faça o Stop e delete o ambiente no término do uso1. Para gerenciar (stop & delete) os ambientes acesse: https://github.com/codespaces

  1. Caso contrário o limite de recursos da conta GitHub continuará em uso e pode, eventualmente, atingir o máximo.

Passo 04: gerenciar dependências

Aqui vamos “congelar” as versões das bibliotecas que estamos usando no projeto. Dessa forma, mudanças que ocorrerem nas bibliotecas e funções tendem a não afetar nosso código (como desvantagem, perdemos atualizações importantes).

Na tela do VS Code online (GitHub Codespaces):

  1. Acesse o terminal usando o atalho Ctrl + ’

  2. Instale o gerenciador de dependências Poetry com o comando curl -sSL https://install.python-poetry.org | python3 -

  3. Localize o arquivo pyproject.toml no material desta aula, clique sobre o mesmo e arraste para o painel Explorer do VS Code online

    Código
    pyproject.toml
    [tool.poetry]
    name = "previsao-macro"
    version = "0.1.0"
    description = "Projeto de curso da Análise Macro."
    authors = ["Fernando da Silva <fernando@fortietwo.com>"]
    license = "N/A"
    readme = "README.md"
    
    [tool.poetry.dependencies]
    python = "^3.12"
    numpy = "^2.1.0"
    pandas = "^2.2.2"
    openpyxl = "^3.1.5"
    pyarrow = "^17.0.0"
    fastparquet = "^2024.5.0"
    skforecast = "^0.13.0"
    scikit-learn = "^1.5.1"
    statsmodels = "^0.14.2"
    shiny = "^1.0.0"
    shinyswatch = "^0.7.0"
    plotnine = "^0.13.6"
    google-generativeai = "^0.7.2"
    faicons = "^0.2.2"
    
    
    [build-system]
    requires = ["poetry-core"]
    build-backend = "poetry.core.masonry.api"
  4. No Terminal, execute o comando poetry lock

  5. No Terminal, execute o comando poetry self add poetry-plugin-export

  6. No Terminal, execute o comando poetry export -f requirements.txt --output requirements.txt --without-hashes

  7. Abrir o arquivo requirements.txt criado e editar o mesmo de forma a manter somente dependências necessárias para a dashboard, tal como abaixo:

    Código
    requirements.txt
    fastparquet==2024.5.0
    mizani==0.11.4
    pandas==2.2.2
    plotnine==0.13.6
    pyarrow==17.0.0
    shiny==1.0.0
    shinyswatch==0.7.0
    faicons==0.2.2
    numpy==2.1.0
    skforecast==0.13.0
    statsmodels==0.14.2
    scikit-learn==1.5.1
    openpyxl==3.1.5
    jinja2==3.1.2

Passo 05: criar dashboard

Aqui vamos desenvolver uma dashboard simples usando o framework Shiny. A ideia é criar uma interface simples com alguns campos de interatividade (horizonte de previsão, período, etc.) e com 4 gráficos para as previsões macroeconômicas.

A dashboard vai ler os dados e as previsões salvas em arquivos previamente (adiante veremos como isso será feito) e, então, vai processar e apresentar as informações. No final, faremos o deploy dessa dashboard, para que usuários interessados possam acessar via link.

Na tela do VS Code online (GitHub Codespaces):

  1. Localize o arquivo app.py no material desta aula, clique sobre o mesmo e arraste para o painel Explorer.

    Código
    app.py
    # Bibliotecas ----
    from shiny import App, ui, render
    from faicons import icon_svg
    from shinyswatch import theme
    import pandas as pd
    import plotnine as p9
    from mizani import breaks
    
    
    # Dados ----
    cambio = pd.read_parquet("previsao/cambio.parquet")
    ipca = pd.read_parquet("previsao/ipca.parquet")
    pib = pd.read_parquet("previsao/pib.parquet")
    selic = pd.read_parquet("previsao/selic.parquet")
    
    datas = {
        "min": pib.index.min().date(),
        "max": selic.index.max().date(),
        "value": pib.index[-36].date()
    }
    
    modelos = (
        pd.concat([
            cambio,
            ipca,
            pib,
            selic
        ])
        .query("Tipo not in ['Câmbio', 'IPCA', 'PIB', 'Selic']")
        .Tipo
        .unique()
        .tolist()
    )
    
    
    # Interface do Usuário ----
    app_ui = ui.page_navbar(
        # Outputs
        ui.nav_panel(
            "",
            ui.layout_columns(
                ui.navset_card_underline(
                    ui.nav_panel("", ui.output_plot("ipca_plt"), icon = icon_svg("chart-line"), value = "plt"),
                    ui.nav_panel("", ui.output_data_frame("ipca_tbl"), icon = icon_svg("table"), value = "tbl"),
                    title = "Inflação (IPCA)",
                    selected = "plt"
                ),
                ui.navset_card_underline(
                    ui.nav_panel("", ui.output_plot("cambio_plt"), icon = icon_svg("chart-line"), value = "plt"),
                    ui.nav_panel("", ui.output_data_frame("cambio_tbl"), icon = icon_svg("table"), value = "tbl"),
                    title = "Taxa de Câmbio (BRL/USD)",
                    selected = "plt"
                )
            ),
            ui.layout_columns(
                ui.navset_card_underline(
                    ui.nav_panel("", ui.output_plot("pib_plt"), icon = icon_svg("chart-line"), value = "plt"),
                    ui.nav_panel("", ui.output_data_frame("pib_tbl"), icon = icon_svg("table"), value = "tbl"),
                    title = "Atividade Econômica (PIB)",
                    selected = "plt"
                ),
                ui.navset_card_underline(
                    ui.nav_panel("", ui.output_plot("selic_plt"), icon = icon_svg("chart-line"), value = "plt"),
                    ui.nav_panel("", ui.output_data_frame("selic_tbl"), icon = icon_svg("table"), value = "tbl"),
                    title = "Taxa de Juros (SELIC)",
                    selected = "plt"
                )
            )
        ),
        title = ui.img(
            src = "https://aluno.analisemacro.com.br/download/59787/?tmstv=1712933415",
            height = 35
            ),
        window_title = "Painel de Previsões",
        fillable = True,
        fillable_mobile = True,
        theme = theme.minty,
        sidebar = ui.sidebar(
            ui.markdown("Acompanhe as previsões automatizadas dos principais indicadores macroeconômicos do Brasil e simule cenários alternativos em um mesmo dashboard."),
            # Inputs
            ui.input_selectize(
                id = "modelo",
                label = ui.strong("Selecionar modelos:"),
                choices = modelos,
                selected = modelos,
                multiple = True,
                width = "100%",
                options = {"plugins": ["clear_button"]}
            ),
            ui.input_date(
                id = "inicio",
                label = ui.strong("Início do gráfico:"),
                value = datas["value"],
                min = datas["min"],
                max = datas["max"],
                format = "mm/yyyy",
                startview = "year",
                language = "pt-BR",
                width = "100%"
            ),
            ui.input_checkbox(
                id = "ic",
                label = ui.strong("Intervalo de confiança"),
                value = True,
                width = "100%"
            ),
            ui.markdown("Elaboração: Análise Macro")
        )
    )
    
    
    # Servidor ----
    def server(input, output, session):
    
        def plotar_grafico(y, df, y_label):
    
            modelos1 = [y] + list(input.modelo())
            modelos2 = df.query("Tipo != @y").Tipo.unique().tolist()
    
            data = input.inicio()
    
            df_tmp = (
                df
                .query("index >= @data")
                .reset_index()
                .assign(Tipo = lambda x: pd.Categorical(x.Tipo, [y] + modelos2))
                .query("Tipo in @modelos1")
            )
    
            def plotar_ic():
    
                ic = p9.geom_ribbon(
                    mapping = p9.aes(ymin = "Intervalo Inferior", ymax = "Intervalo Superior", fill = "Tipo"),
                    show_legend = False,
                    color = "none",
                    alpha = 0.25
                )
    
                if input.ic():
                    return ic
                else:
                    return None
    
            plt = (
                p9.ggplot(df_tmp) +
                p9.aes(x = "index", y = "Valor", color = "Tipo") +
                plotar_ic() +
                p9.geom_line() +
                p9.scale_x_date(date_breaks = "1 year", date_labels = "%Y") + 
                p9.scale_y_continuous(breaks = breaks.breaks_extended(n = 6)) +
                p9.scale_color_manual(
                    values = {
                        "IPCA": "black", 
                        "Câmbio": "black",
                        "PIB": "black",
                        "Selic": "black",
                        "IA": "green",
                        "Ridge": "blue",
                        "Bayesian Ridge": "orange",
                        "Huber": "red",
                        "Ensemble": "brown"
                    }
                ) +
                p9.scale_fill_manual(
                    values = {
                        "IA": "green",
                        "Ridge": "blue",
                        "Bayesian Ridge": "orange",
                        "Huber": "red",
                        "Ensemble": "brown"
                    }
                ) +
                p9.labs(
                    y = y_label,
                    x = "",
                    color = ""
                ) +
                p9.theme(legend_position = "bottom")
            )
    
            return plt
    
        def imprimir_tabela(df, y):
            df = (
                df
                .reset_index()
                .rename(columns = {"index": "Data", "Valor": "Previsão", "Tipo": "Modelo"})
                .query("Modelo != @y")
                .assign(Data = lambda x: x.Data.dt.strftime("%m/%Y"))
                .round(2)
            )
            return render.DataGrid(df, summary = False)
    
    
        @render.plot
        def ipca_plt():
            return plotar_grafico(y = "IPCA", df = ipca, y_label = "Var. %")
    
        @render.plot
        def cambio_plt():
            return plotar_grafico(y = "Câmbio", df = cambio, y_label = "R\\$/US\\$")
    
        @render.plot
        def pib_plt():
            return plotar_grafico(y = "PIB", df = pib, y_label = "Var. % anual")
    
        @render.plot
        def selic_plt():
            return plotar_grafico(y = "Selic", df = selic, y_label = "% a.a.")
    
        @render.data_frame
        def ipca_tbl():
            return imprimir_tabela(ipca, "IPCA")
    
        @render.data_frame
        def cambio_tbl():
            return imprimir_tabela(cambio, "Câmbio")
    
        @render.data_frame
        def pib_tbl():
            return imprimir_tabela(pib, "PIB")
    
        @render.data_frame
        def selic_tbl():
            return imprimir_tabela(selic, "Selic")
    
    # Shiny dashboard ----
    app = App(app_ui, server)

Passo 06: automatizar processos

Aqui vamos utilizar o GitHub Actions para criar automatizações de 3 processos:

  • Atualização da base de dados
  • Atualização dos modelos de previsão
  • Publicação/deploy da dashboard

Dessa forma, todo o processo de modelagem preditiva está automatizado, sem necessidade de interferência humana. Para fazer isso, basta adicionar 3 arquivos com as definições das etapas de automação.

Na tela do VS Code online (GitHub Codespaces):

  1. Clique no painel Explorer
  2. Clique no botão New Folder…
  3. Digite “.github” e pressione Enter
  4. Clique no botão New Folder… (criando uma subpasta)
  5. Digite “workflows” e pressione Enter
  6. Localize os arquivos abaixo no material desta aula, clique sobre os mesmos e arraste para o painel Explorer, dentro da subpasta “workflows”
    • base_de_dados.yml

      Código
      base_de_dados.yml
      name: Automação da base de dados
      
      on:
        push:
          branches: [ 'main' ]
        schedule:
          - cron: '0 0 * * *'
        workflow_dispatch:
      
      
      jobs:
        Pipeline:
          runs-on: ubuntu-22.04
      
          steps:
            - name: Clonar repositório
              uses: actions/checkout@v4
      
            - name: Instalar Python
              uses: actions/setup-python@v5
              with:
                python-version: '3.12'
      
            - name: Instalar Poetry
              uses: snok/install-poetry@v1
              with:
                version: 1.8.3
      
            - name: Instalar pacotes Python
              run: poetry install --no-root
      
            - name: Atualizar base de dados
              run: |
                poetry config virtualenvs.prefer-active-python true
                poetry run python -c "exec(open('01-bibliotecas.py').read());
                exec(open('02-funcoes.py').read()); \
                exec(open('03-coleta.py').read()); \
                exec(open('04-tratamento.py').read()); \
                exec(open('05-disponibilizacao.py').read())"
      
            - name: Commit & Push
              uses: stefanzweifel/git-auto-commit-action@v5
              with:
                commit_message: Atualização automática de dados
  7. Clique no botão Settings do repositório GitHub
  8. Clique na opção Actions na seção Code and automation
  9. Clique na opção General dentro de Actions
  10. Marque a opção Read and write permissions na seção Workflow permissions
  11. Clique no botão Save
  12. Na tela do VS Code online (GitHub Codespaces), clique em Source Control, clique em “+” (Stage all changes), digite uma mensagem para o histórico do repositório, clique em Commit e depois em Sync changes e OK.

Passo 07: criar chaves Shinyapps.io

Aqui vamos usar o serviço Shinyapps.io para deploy da dashboard. Como o GitHub e o Shinyapps.io são serviços separados, precisamos de chaves de autenticação para realizar a comunicação entre os dois.

O procedimento é feito em duas etapas, primeiro criamos as chaves no Shinyapps.io e depois salvamos elas como segredos no Github:

  1. Acesse o site https://shinyapps.io/

  2. Faça o login na sua conta de usuário (caso seja seu primeiro acesso, faça a configuração auto-guiada)

  3. Clique no ícone da sua foto ao lado do nome, no canto superior direito da tela

  4. Clique no botão Tokens

  5. Clique no botão Show

  6. Clique na opção With Python

  7. Clique no botão Show secret

  8. Clique no botão Copy do clipboard e copie/salve os comandos exibidos em local seguro

  9. Acesse o repositório GitHub criado no Passo 01

  10. Clique no botão Settings

  11. Clique na opção Secrets and variables na seção Security

  12. Clique na opção Actions dentro de Secrets and variables

  13. Clique no botão New repository secret

  14. Digite ACCOUNT no campo Name *

  15. Digite no campo Secret * o valor que aparece em frente de –account dos comandos copiados acima

  16. Clique no botão Add secret

  17. Repita os passos 13 até 16 para o restantes das informações do Shinyapps.io, colocando no campo Name * o nome da informação em maiúsculo e no campo Secret * o valor correspondente, tal como abaixo

Passo 08: acessar dashboard

Por fim, vamos registrar os novos arquivos no repositório, disparar as automatizações e, então acessar a dashboard com as previsões.

  1. Localize os arquivos abaixo no material desta aula, clique sobre os mesmos e arraste para o painel Explorer do VS Code online (GitHub Codespaces), dentro da subpasta “workflows”

    • modelos.yml

      Código
      modelos.yml
      name: Automação das previsões
      
      on:
        push:
          branches: [ 'main' ]
        schedule:
          - cron: '0 1 * * *'
        workflow_dispatch:
      
      
      jobs:
        Modelagem:
          runs-on: ubuntu-22.04
      
          steps:
            - name: Clonar repositório
              uses: actions/checkout@v4
      
            - name: Instalar Python
              uses: actions/setup-python@v5
              with:
                python-version: '3.12'
      
            - name: Instalar Poetry
              uses: snok/install-poetry@v1
              with:
                version: 1.8.3
      
            - name: Instalar pacotes Python
              run: poetry install --no-root
      
            - name: Atualizar previsões
              env:
                GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
              run: |
                poetry config virtualenvs.prefer-active-python true
                poetry run python 06-ipca.py
                poetry run python -c "exec('import time;time.sleep(61)')"
                poetry run python 07-cambio.py
                poetry run python -c "exec('import time;time.sleep(61)')"
                poetry run python 08-pib.py
                poetry run python -c "exec('import time;time.sleep(61)')"
                poetry run python 09-selic.py
      
            - name: Commit & Push
              uses: stefanzweifel/git-auto-commit-action@v5
              with:
                commit_message: Atualização automática de previsões
  2. Acesse o repositório GitHub criado no Passo 01

  3. Clique no botão Settings

  4. Clique na opção Secrets and variables na seção Security

  5. Clique na opção Actions dentro de Secrets and variables

  6. Clique no botão New repository secret

  7. Digite GEMINI_API_KEY no campo Name *

  8. Digite no campo Secret * a chave de API obtida por estes procedimentos:

    1. Acesse https://aistudio.google.com/app/apikey

    2. Clique em Criar chave de API

    3. Clique em Criar uma chave de API em um novo projeto

    4. Clique em Copiar e salve a informação em local seguro

  9. Clique no botão Add secret

  10. Clique em Source Control, clique em “+” (Stage all changes), digite uma mensagem para o histórico do repositório, clique em Commit e depois em Sync changes e OK (talvez seja necessário realizar um git pull primeiro).

  11. Localize os arquivos abaixo no material desta aula, clique sobre os mesmos e arraste para o painel Explorer do VS Code online (GitHub Codespaces), dentro da subpasta “workflows”

    • dashboard.yml

      Código
      dashboard.yml
      name: Automação de deploy
      
      on:
        push:
          branches: [ 'main' ]
        schedule:
          - cron: '0 2 * * *'
        workflow_dispatch:
      
      
      jobs:
        Shinyapps:
          runs-on: ubuntu-22.04
      
          steps:
            - name: Clonar repositório
              uses: actions/checkout@v4
      
            - name: Publicar dashboard
              run: |
                pip install rsconnect-python
                rsconnect add --account ${{ secrets.ACCOUNT }} --name ${{ secrets.NAME }} --token ${{ secrets.TOKEN }} --secret ${{ secrets.SECRET }}
                rsconnect deploy shiny . --title previsao_macro
      
            - name: Commit & Push
              uses: stefanzweifel/git-auto-commit-action@v5
              with:
                commit_message: Deploy automático
  12. Clique em Source Control, clique em “+” (Stage all changes), digite uma mensagem para o histórico do repositório, clique em Commit e depois em Sync changes e OK (talvez seja necessário realizar um git pull primeiro).

  13. Na tela do repositório GitHub, clique na aba Actions

  14. Aguarde todos os fluxos concluírem (cor verde)

  15. Acesse a dashboard por um link que segue este padrão:

    https://SEU-NOME-DE-USUÁRIO.shinyapps.io/previsao_macro/