Como fazer previsão de séries temporais com Prophet em Machine Learning

João Barros 04 de August de 2026 4 min de leitura

Este tutorial mostra como fazer previsão de séries temporais com Prophet em Machine Learning para obter previsões simples, interpretar sazonalidade e lidar com feriados. É útil para planear inventário, vendas ou capacidade com um método robusto e fácil de usar.

Pré-requisitos

Python 3.8+ e pip
Bibliotecas: pandas, prophet, matplotlib (instalar via pip)
Um conjunto de dados com datas e um valor (ex.: vendas_diarias.csv)

Passo 1: Instalar e importar as bibliotecas

Instalar Prophet (o pacote chama-se prophet) mais pandas e matplotlib. Depois importar o essencial. Se houver problemas na instalação, verificar o compilador C++ ou usar uma distribuição conda.

pip install pandas prophet matplotlib

import pandas as pd
from prophet import Prophet
import matplotlib.pyplot as plt

Passo 2: Preparar os dados no formato que Prophet exige

Prophet espera duas colunas: ds (datas) e y (valor). Carregar o ficheiro, converter a coluna de data e resumir por dia se necessário.

# Exemplo mínimo
df = pd.read_csv('vendas_diarias.csv')
df['ds'] = pd.to_datetime(df['data'])
df = df[['ds', 'vendas']].rename(columns={'vendas':'y'})
# Opcional: ordenar e preencher dias em falta
df = df.sort_values('ds').reset_index(drop=True)

Passo 3: Explorar a série e lidar com valores extremos

Visualizar a série para perceber tendências, sazonalidade e outliers. Decidir se deve imputar valores nulos ou winsorizar outliers antes de treinar.

df.plot(x='ds', y='y', figsize=(10,4))
plt.title('Série temporal de vendas')
plt.show()

# Exemplo simples de imputação
df['y'] = df['y'].fillna(method='ffill')

Passo 4: Criar e ajustar o modelo Prophet

Criar um modelo Prophet básico. Pode configurar sazonalidade anual, semanal, e adicionar feriados. Ajustar changepoint_prior_scale para controlar sensibilidade a mudanças bruscas (overfitting vs underfitting).

# Modelo básico com sazonalidade semanal e anual
m = Prophet(yearly_seasonality=True, weekly_seasonality=True, daily_seasonality=False)
# Se tiver feriados, criar DataFrame de feriados e adicionar
# feriados = pd.DataFrame({'ds': [...], 'holiday': [...]})
# m.add_country_holidays(country_name='PT')

# Ajuste do modelo
m.fit(df)

Passo 5: Gerar previsões e intervalos de confiança

Criar um DataFrame de futuro com período desejado (por ex. 30 dias) e prever. Prophet devolve previsão com intervalo (yhat, yhat_lower, yhat_upper).

future = m.make_future_dataframe(periods=30, freq='D')
forecast = m.predict(future)

# Ver algumas colunas úteis
print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail())

Passo 6: Visualizar e interpretar resultados

Visualizar previsão e componentes para ver tendência, sazonalidade e efeitos de feriados. Isto ajuda a interpretar o porquê das previsões.

m.plot(forecast)
plt.title('Previsão com Prophet')
plt.show()

m.plot_components(forecast)
plt.show()

Passo 7: Validar o modelo (backtesting simples)

Fazer validação temporal: separar os últimos N dias como teste, treinar no resto e comparar previsões com valores reais usando métricas como MAE ou RMSE.

from sklearn.metrics import mean_absolute_error, mean_squared_error

# Exemplo: validar últimos 30 dias
train = df.iloc[:-30]
test = df.iloc[-30:]

m2 = Prophet(yearly_seasonality=True, weekly_seasonality=True)
m2.fit(train)
future2 = m2.make_future_dataframe(periods=30, freq='D')
forecast2 = m2.predict(future2)
pred = forecast2.set_index('ds').loc[test['ds'], 'yhat']

mae = mean_absolute_error(test['y'], pred)
rmse = mean_squared_error(test['y'], pred, squared=False)
print('MAE:', mae, 'RMSE:', rmse)

Verificar o resultado

Confirmar que o gráfico de previsão inclui a linha yhat e que os componentes mostram sazonalidade. Validar com MAE/RMSE e verificar se os erros estão dentro da tolerância de negócio. Se os intervalos yhat_lower/upper cobrirem a maioria dos pontos reais, o modelo está calibrado.

Conclusão

Aprendeste a preparar dados, treinar Prophet, gerar previsões e validar com backtesting. Próximos passos: experimentar changepoint_prior_scale, adicionar regressors externos (promoções, preços) e usar cross-validation avançada do Prophet. Dica: começa com modelos simples e adiciona complexidade só quando os erros justificarem.