Previsão de Séries Temporais com statsmodels e Prophet

As séries temporais são um conjunto de dados exclusivo no campo da ciência de dados. Os dados são registrados na frequência de tempo (por exemplo, diariamente, semanalmente, mensalmente, etc.), e cada observação está relacionada com a outra. Os dados da série temporal são valiosos quando você deseja analisar o que acontece com seus dados ao longo do tempo e criar previsões futuras. 

A previsão de séries temporais é um método para criar previsões futuras com base em dados históricos de séries temporais. Existem muitos métodos estatísticos para previsão de séries temporais, como ARIMA or Suavização Exponencial.

A previsão de série temporal é frequentemente encontrada nos negócios, portanto, é benéfico para o cientista de dados saber como desenvolver um modelo de série temporal. Neste artigo, aprenderemos como prever séries temporais usando dois pacotes Python populares de previsão; statsmodels e Profeta. Vamos entrar nisso.

A modelos estatísticos O pacote Python é um pacote de código aberto que oferece vários modelos estatísticos, incluindo o modelo de previsão de séries temporais. Vamos experimentar o pacote com um conjunto de dados de exemplo. Este artigo usará o Série temporal de moeda digital dados do Kaggle (CC0: Domínio público). 

Vamos limpar os dados e dar uma olhada no conjunto de dados que temos.

import pandas as pd df = pd.read_csv('dc.csv') df = df.rename(columns = {'Unnamed: 0' : 'Time'})
df['Time'] = pd.to_datetime(df['Time'])
df = df.iloc[::-1].set_index('Time') df.head()

Para o nosso exemplo, digamos que queremos prever a variável 'close_USD'. Vamos ver como o padrão de dados ao longo do tempo.

import matplotlib.pyplot as plt plt.plot(df['close_USD'])
plt.show()

Vamos construir o modelo de previsão com base em nossos dados acima. Antes de modelar, vamos dividir os dados em dados de treinamento e teste.

# Split the data
train = df.iloc[:-200] test = df.iloc[-200:]

Não dividimos os dados aleatoriamente porque são dados de séries temporais e precisamos preservar a ordem. Em vez disso, tentamos obter os dados do trem anteriores e os dados de teste dos dados mais recentes.

Vamos usar statsmodels para criar um modelo de previsão. O modelo estatístico fornece muitas APIs de modelo de série temporal, mas usaríamos o modelo ARIMA como nosso exemplo.

from statsmodels.tsa.arima.model import ARIMA #sample parameters
model = ARIMA(train, order=(2, 1, 0)) results = model.fit() # Make predictions for the test set
forecast = results.forecast(steps=200)
forecast

Em nosso exemplo acima, usamos o modelo ARIMA de statsmodels como modelo de previsão e tentamos prever os próximos 200 dias.

O resultado do modelo é bom? Vamos tentar avaliá-los. A avaliação do modelo de série temporal geralmente usa um gráfico de visualização para comparar o real e a previsão com métricas de regressão, como erro absoluto médio (MAE), erro quadrático médio raiz (RMSE) e MAPE (erro percentual médio absoluto).

from sklearn.metrics import mean_squared_error, mean_absolute_error
import numpy as np #mean absolute error
mae = mean_absolute_error(test, forecast) #root mean square error
mse = mean_squared_error(test, forecast)
rmse = np.sqrt(mse) #mean absolute percentage error
mape = (forecast - test).abs().div(test).mean() print(f"MAE: {mae:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"MAPE: {mape:.2f}%")

MAE: 7956.23 RMSE: 11705.11 MAPE: 0.35%

A partitura acima parece boa, mas vamos ver como fica quando visualizamos.

plt.plot(train.index, train, label='Train')
plt.plot(test.index, test, label='Test')
plt.plot(forecast.index, forecast, label='Forecast')
plt.legend()
plt.show()

Como podemos ver, a previsão foi pior porque nosso modelo não pode prever a tendência de aumento. O modelo ARIMA que usamos parece muito simples para fazer previsões.

Talvez seja melhor tentarmos usar outro modelo fora de statsmodels. Vamos experimentar o famoso pacote profeta do Facebook.

Profeta é um pacote de modelo de previsão de série temporal que funciona melhor em dados com efeitos sazonais. O Prophet também foi considerado um modelo de previsão robusto porque podia lidar com dados ausentes e discrepantes.

Vamos experimentar o pacote Profeta. Primeiro, precisamos instalar o pacote.

pip install prophet

Depois disso, devemos preparar nosso conjunto de dados para o treinamento do modelo de previsão. O Prophet tem um requisito específico: a coluna de tempo precisa ser nomeada como 'ds' e o valor como 'y'.

df_p = df.reset_index()[["Time", "close_USD"]].rename( columns={"Time": "ds", "close_USD": "y"}
)

Com nossos dados prontos, vamos tentar criar uma previsão de previsão com base nos dados.

import pandas as pd
from prophet import Prophet model = Prophet() # Fit the model
model.fit(df_p) # create date to predict
future_dates = model.make_future_dataframe(periods=365) # Make predictions
predictions = model.predict(future_dates) predictions.head()

O que era ótimo no Profeta era que cada ponto de dados de previsão era detalhado para nós, usuários, entendermos. No entanto, é difícil entender o resultado apenas a partir dos dados. Assim, poderíamos tentar visualizá-los usando o Profeta.

model.plot(predictions)

A função de gráfico de previsões do modelo nos forneceria a confiança das previsões. No gráfico acima, podemos ver que a previsão tem uma tendência ascendente, mas com maior incerteza quanto mais longas forem as previsões.

Também é possível examinar os componentes de previsão com a seguinte função.

model.plot_components(predictions)

Por padrão, obteríamos a tendência dos dados com sazonalidade anual e semanal. É uma boa maneira de explicar o que acontece com nossos dados.

Seria possível avaliar também o modelo do Profeta? Absolutamente. O Profeta inclui uma medida de diagnóstico que podemos usar: validação cruzada de série temporal. O método utiliza parte dos dados históricos e ajusta o modelo a cada vez utilizando os dados até o ponto de corte. Então o Profeta comparava as previsões com as reais. Vamos tentar usar o código.

from prophet.diagnostics import cross_validation, performance_metrics # Perform cross-validation with initial 365 days for the first training data and the cut-off for every 180 days. df_cv = cross_validation(model, initial='365 days', period='180 days', horizon = '365 days') # Calculate evaluation metrics
res = performance_metrics(df_cv) res

No resultado acima, adquirimos o resultado da avaliação do resultado real em comparação com a previsão em cada dia de previsão. Também é possível visualizar o resultado com o seguinte código.

from prophet.plot import plot_cross_validation_metric
#choose between 'mse', 'rmse', 'mae', 'mape', 'coverage' plot_cross_validation_metric(df_cv, metric= 'mape')

Se observarmos o gráfico acima, podemos ver que o erro de previsão variou após os dias e pode chegar a 50% de erro em alguns pontos. Dessa forma, podemos querer ajustar o modelo ainda mais para corrigir o erro. Você pode verificar o documentação para mais exploração.

A previsão é um dos casos comuns que ocorrem no negócio. Uma maneira fácil de desenvolver um modelo de previsão é usar os pacotes statsforecast e Prophet Python. Neste artigo, aprendemos como criar um modelo de previsão e avaliá-lo com statsforecast e Prophet.
 
 
Cornélio Yudha Wijaya é gerente assistente de ciência de dados e redator de dados. Enquanto trabalhava em período integral na Allianz Indonésia, ele adora compartilhar dicas sobre Python e dados nas mídias sociais e na mídia escrita.
 

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• Platoblockchain. Inteligência Metaverso Web3. Conhecimento Ampliado. Acesse aqui.
• Fonte: https://www.kdnuggets.com/2023/03/time-series-forecasting-statsmodels-prophet.html?utm_source=rss&utm_medium=rss&utm_campaign=time-series-forecasting-with-statsmodels-and-prophet