Código
01-bibliotecas.py
# Importa bibliotecas
import pandas as pd
import numpy as np
import os, time
from datetime import datetime, timedeltaConta GitHub
Conta Shinyapps.io
Acesse https://www.shinyapps.io/
Clique em Sign up
Preencha suas informações/complete o cadastro
Conta Google
Acesse http://google.com/
Clique em Fazer login
Clique em Criar conta
Selecione o tipo de uso
Preencha suas informações/complete o cadastro
O repositório será a central de arquivos e de automação do projeto.
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:
01-bibliotecas.py
# Importa bibliotecas
import pandas as pd
import numpy as np
import os, time
from datetime import datetime, timedelta02-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 result03-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])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")
)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")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")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")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")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")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:
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
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):
Acesse o terminal usando o atalho Ctrl + ’
Instale o gerenciador de dependências Poetry com o comando curl -sSL https://install.python-poetry.org | python3 -
Localize o arquivo pyproject.toml no material desta aula, clique sobre o mesmo e arraste para o painel Explorer do VS Code online
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"No Terminal, execute o comando poetry lock
No Terminal, execute o comando poetry self add poetry-plugin-export
No Terminal, execute o comando poetry export -f requirements.txt --output requirements.txt --without-hashes
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:
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.2Aqui 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):
Localize o arquivo app.py no material desta aula, clique sobre o mesmo e arraste para o painel Explorer.
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)Aqui vamos utilizar o GitHub Actions para criar automatizações de 3 processos:
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):
.github” e pressione Enterworkflows” e pressione Enterworkflows”
base_de_dados.yml
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 dadosAqui 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:
Acesse o site https://shinyapps.io/
Faça o login na sua conta de usuário (caso seja seu primeiro acesso, faça a configuração auto-guiada)
Clique no ícone da sua foto ao lado do nome, no canto superior direito da tela
Clique no botão Tokens
Clique no botão Show
Clique na opção With Python
Clique no botão Show secret
Clique no botão Copy do clipboard e copie/salve os comandos exibidos em local seguro
Acesse o repositório GitHub criado no Passo 01
Clique no botão Settings
Clique na opção Secrets and variables na seção Security
Clique na opção Actions dentro de Secrets and variables
Clique no botão New repository secret
Digite ACCOUNT no campo Name *
Digite no campo Secret * o valor que aparece em frente de –account dos comandos copiados acima
Clique no botão Add secret
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
Por fim, vamos registrar os novos arquivos no repositório, disparar as automatizações e, então acessar a dashboard com as previsões.
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
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õesAcesse o repositório GitHub criado no Passo 01
Clique no botão Settings
Clique na opção Secrets and variables na seção Security
Clique na opção Actions dentro de Secrets and variables
Clique no botão New repository secret
Digite GEMINI_API_KEY no campo Name *
Digite no campo Secret * a chave de API obtida por estes procedimentos:
Clique em Criar chave de API
Clique em Criar uma chave de API em um novo projeto
Clique em Copiar e salve a informação em local seguro
Clique no botão Add secret
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).
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
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áticoClique 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).
Na tela do repositório GitHub, clique na aba Actions
Aguarde todos os fluxos concluírem (cor verde)
Acesse a dashboard por um link que segue este padrão: