ARIMA-GARCH Forecasting in Python

Python is a high-level, interpreted programming language acknowledged for its simplicity and clarity. Created by Guido van Rossum and primarily released in 1991, Python emphasizes code readability and syntax that lets programmers to express standards in fewer strains of code compared to languages like C++ or Java. It supports multiple programming paradigms, consisting of procedural, item-orientated, and functional programming.

Python's substantial trendy library and tremendous ecosystem of third-party programs make it appropriate for a wide range of applications, from web development and records evaluation to artificial intelligence and scientific computing. The language's dynamic typing and automatic memory management features make a contribution to its ease of use, making it a popular preference for novices and experienced builders alike. Python's network-driven improvement ensures non-stop upgrades and full-size support throughout various systems.

ARIMA-GARCH

ARIMA-GARCH forecasting is a combination of two fashions in order to improve the accuracy of time series predictions, primarily for economic records with volatility clustering.

ARIMA (AutoRegressive Integrated Moving Average)

ARIMA fashions are exercised in order to identify and guess destiny points in a time series with the assistance of illustrating the autocorrelations within the data.

Components

AR (AutoRegressive): This a part of the model explains the connection between a statement and several lagged observations (previous facts points).
I (Integrated): This part entails differencing the raw observations to make the time series stationary, which means that its statistical residences like imply, and variance is steady over time.
MA (Moving Average): This element models the connection between a statement and a residual error from a transferring average version carried out to lagged observations.

GARCH (Generalized Autoregressive Conditional Heteroskedasticity)

GARCH fashions are exercised in order to version and forecast the volatility of a time series, which can range through the years.

Components

GARCH: It explains the modern variance (volatility) of the series as a characteristic of beyond errors (returns or residuals) and past variances.

Combining ARIMA and GARCH

Fit ARIMA Model: Begin by fitting an ARIMA version to the time collection information. This version captures the linear shape within the suggestion of the series.
Extract Residuals: After becoming the ARIMA model, extract the residuals (mistakes). These residuals represent a part of the time collection that the ARIMA version could not give an explanation for.
Fit GARCH Model: Apply a GARCH version to the residuals to version the volatility clustering inside the time series.
Forecast:
- Mean Forecast: Use the ARIMA version to forecast the suggest values of the time series.
- Volatility Forecast: Use the GARCH version to forecast the destiny volatility.
Combine Forecasts: Combine the ARIMA suggest forecasts and the GARCH volatility forecasts to reap a comprehensive forecast that consists of each anticipated value and their associated volatility.

Benefits

Capturing Mean and Volatility: By combining ARIMA and GARCH, the model can efficiently seize each the implied shape and the volatility inside the records, leading to greater accurate forecasts.
Applicability: This method is especially beneficial in financial time series forecasting, wherein the volatility of asset costs often changes over time.

Application

This mixed approach is extensively utilized in financial markets for obligations consisting of chance control, choice pricing, and algorithmic buying and selling, wherein expertise each the anticipated returns and their volatility is vital.

Example

 
!pip install arch
# Import necessary libraries
import numpy as np
import pandas as pd
import statsmodels.api as sm
from arch import arch_model
import matplotlib.pyplot as plt
# Generate synthetic time series data (for illustration)
np.random.seed(42)
n = 1000
ts = pd.Series(np.random.randn(n).cumsum(), index=pd.date_range('2000-01-01', periods=n, freq='D'))
# Step 1: Fit ARIMA model
arima_order = (1, 1, 1)
arima_model = sm.tsa.ARIMA(ts, order=arima_order)
arima_result = arima_model.fit()
# Step 2: Extract ARIMA residuals
residuals = arima_result.resid
# Step 3: Fit GARCH model to ARIMA residuals
garch_model = arch_model(residuals, vol='Garch', p=1, q=1)
garch_result = garch_model.fit(disp='off')
# Step 4: Forecast future values
n_forecast = 10
arima_forecast = arima_result.forecast(steps=n_forecast)
garch_forecast = garch_result.forecast(horizon=n_forecast)
mean_forecast = arima_forecast.values[-1]
volatility_forecast = np.sqrt(garch_forecast.variance.values[-1, :])
combined_forecast = mean_forecast + volatility_forecast
# Output
print("ARIMA Mean Forecast:\n", mean_forecast)
print("GARCH Volatility Forecast:\n", volatility_forecast)
print("Combined Forecast:\n", combined_forecast)
# Visualization
plt.figure(figsize=(10, 5))
plt.plot(ts, label='Actual')
plt.plot(arima_result.predict(start=0, end=len(ts)-1), label='ARIMA Fit')
forecast_index = pd.date_range(start=ts.index[-1], periods=n_forecast+1, freq='D')[1:]
plt.plot(pd.Series(mean_forecast, index=forecast_index), label='ARIMA Mean Forecast')
plt.fill_between(forecast_index, mean_forecast-volatility_forecast, mean_forecast+volatility_forecast, color='gray', alpha=0.2, label='Forecast Volatility')
plt.legend()
plt.show()   

Output:

 
ARIMA Mean Forecast:
 19.3284217264986
GARCH Volatility Forecast:
 [0.98607856 0.98607858 0.98607861 0.98607863 0.98607866 0.98607868
 0.98607871 0.98607873 0.98607876 0.98607878]
Combined Forecast:
 [20.31450028 20.31450031 20.31450034 20.31450036 20.31450039 20.31450041
 20.31450044 20.31450046 20.31450048 20.31450051]

Explanation

Import Libraries:
- Necessary libraries for records manipulation (`pandas`, `numpy`), modeling (`statsmodels`, `arch`), and plotting (`matplotlib`) are imported.
Generate Synthetic Data:
- For illustration functions, artificial time collection facts are generated using a random walk model.
Fit ARIMA Model:
- Define the ARIMA order (p, d, q) as (1, 1, 1).
- Fit the ARIMA version to the time collection facts.
- Extract residuals from the ARIMA version match, so that you can be used to fit the GARCH version.
Fit GARCH Model:
- Define and suit a GARCH(1, 1) model to the ARIMA residuals to version the volatility.
Forecast:
- Use the ARIMA model to forecast the implied values of the time series.
- Use the GARCH model to forecast the volatility (general deviation).
- Combine the ARIMA suggest forecast and the GARCH volatility forecast to attain the final forecast.
Output:
- Print the ARIMA suggest forecast, GARCH volatility forecast, and combined forecast.
Visualization:
- Plot the actual time series, ARIMA healthy, ARIMA suggest forecast, and forecast volatility to visualize the consequences.