feat: add new article

Author: DiogoRibeiro7

_posts/2025-07-23-multivariate_time_series_forecasting_var_and_vecm_models_explained.md

@@ -0,0 +1,345 @@
+---
+title: 'Multivariate Time Series Forecasting: VAR and VECM Models Explained'
+categories:
+  - Time Series
+  - Econometrics
+  - Forecasting
+tags:
+  - VAR
+  - VECM
+  - cointegration
+  - Johansen test
+  - Python
+  - stationarity
+author_profile: false
+seo_title: 'Multivariate Time Series Forecasting: VAR vs VECM with Python'
+seo_description: >-
+  Learn how VAR and VECM model multivariate time series. Understand assumptions,
+  cointegration, model selection, and see complete Python implementations.
+excerpt: >-
+  A practical guide to VAR and VECM for multivariate time series forecasting,
+  including math, assumptions, cointegration testing, and Python code.
+summary: >-
+  This article explains Vector Autoregressive (VAR) and Vector Error Correction
+  Models (VECM) for multivariate time series. It covers model intuition,
+  mathematical form, stationarity and cointegration, when to use each model, and
+  end-to-end Python examples with diagnostics and interpretation tools.
+keywords:
+  - multivariate time series
+  - VAR model
+  - VECM model
+  - cointegration
+  - Johansen test
+  - forecasting in Python
+classes: wide
+date: '2025-07-23'
+header:
+  image: /assets/images/data_science_3.jpg
+  og_image: /assets/images/data_science_3.jpg
+  overlay_image: /assets/images/data_science_3.jpg
+  show_overlay_excerpt: false
+  teaser: /assets/images/data_science_3.jpg
+  twitter_image: /assets/images/data_science_3.jpg
+---
+
+Multivariate time series forecasting is essential when dealing with multiple interrelated variables that evolve over time. Vector Autoregressive (VAR) and Vector Error Correction Models (VECM) are powerful frameworks for modeling these complex relationships. Let me explain these models, their applications, and provide Python implementations.
+
+## Vector Autoregressive (VAR) Model
+
+VAR models extend univariate autoregressive models to capture linear interdependencies among multiple time series. Each variable is modeled as a function of past values of itself and past values of other variables in the system.
+
+## Mathematical Representation
+
+For a k-dimensional time series $$Y_t = (y_{1t}, y_{2t}, ..., y_{kt})'$$, a VAR(p) model is expressed as:
+
+$$Y_t = c + A_1 Y_{t-1} + A_2 Y_{t-2} + ... + A_p Y_{t-p} + ε_t$$
+
+Where:
+
+- $$c$$ is a k×1 vector of constants
+- $$A_i$$ are k×k coefficient matrices
+- $$ε_t$$ is a k×1 vector of error terms
+
+## Key Characteristics
+
+- Treats all variables symmetrically without prior assumptions about dependencies
+- Captures feedback effects between variables
+- Requires stationarity of time series data
+- Model order (p) selection typically uses information criteria (AIC, BIC)
+
+## Vector Error Correction Model (VECM)
+
+When time series are cointegrated (share long-term equilibrium relationships despite being individually non-stationary), VECM is more appropriate than VAR.
+
+### Mathematical Representation
+
+VECM extends VAR by incorporating error correction terms:
+
+$$ΔY_t = c + Π Y_{t-1} + Γ_1 ΔY_{t-1} + ... + Γ_{p-1} ΔY_{t-p+1} + ε_t$$
+
+Where:
+
+- $$ΔY_t$$ represents first differences
+- $$Π$$ contains information about long-run relationships
+- $$Γ_i$$ captures short-run dynamics
+
+### Key Characteristics
+
+- Distinguishes between long-run equilibrium and short-run dynamics
+- Appropriate for cointegrated non-stationary series
+- Requires cointegration testing (Johansen test)
+- Maintains information about levels that would be lost in a differenced VAR
+
+## Python Implementation
+
+Let's implement both models with practical examples:
+
+### VAR Model Example
+
+```python
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from statsmodels.tsa.api import VAR
+from statsmodels.tsa.stattools import adfuller
+from statsmodels.tools.eval_measures import rmse, aic
+
+# Load example data (you can replace with your own dataset)
+# For example: economic indicators like GDP, inflation, unemployment
+data = pd.read_csv('economic_indicators.csv', index_col=0, parse_dates=True)
+# If you don't have data, create synthetic data:
+# np.random.seed(1)
+# dates = pd.date_range('1/1/2000', periods=100, freq='Q')
+# data = pd.DataFrame(np.random.randn(100, 3).cumsum(axis=0), 
+#                    columns=['GDP', 'Inflation', 'Unemployment'], index=dates)
+
+# Check stationarity for each series
+def check_stationarity(series, name):
+    result = adfuller(series)
+    print(f'ADF Statistic for {name}: {result[0]}')
+    print(f'p-value: {result[1]}')
+    print(f'Critical Values: {result[4]}')
+
+for column in data.columns:
+    check_stationarity(data[column], column)
+
+# Make data stationary if needed (differencing)
+# If series are non-stationary:
+df_differenced = data.diff().dropna()
+
+# Fit VAR model
+model = VAR(df_differenced)
+
+# Select lag order
+lag_order_results = model.select_order(maxlags=15)
+print(f'Suggested lag order by AIC: {lag_order_results.aic}')
+print(f'Suggested lag order by BIC: {lag_order_results.bic}')
+
+# Fit the model with selected lag order
+lag_order = lag_order_results.aic
+var_model = model.fit(lag_order)
+print(var_model.summary())
+
+# Forecast
+forecast_steps = 10
+forecast = var_model.forecast(df_differenced.values, forecast_steps)
+forecast_df = pd.DataFrame(forecast, 
+                          index=pd.date_range(start=data.index[-1], 
+                                             periods=forecast_steps+1, 
+                                             freq=data.index.freq)[1:],
+                          columns=data.columns)
+
+# Convert back to original scale (if differenced)
+forecast_original_scale = data.iloc[-1] + forecast_df.cumsum()
+
+# Plot forecasts
+plt.figure(figsize=(12, 8))
+for i, col in enumerate(data.columns):
+    plt.subplot(len(data.columns), 1, i+1)
+    plt.plot(data[col], label='Observed')
+    plt.plot(forecast_original_scale[col], label='Forecast')
+    plt.title(f'VAR Forecast for {col}')
+    plt.legend()
+plt.tight_layout()
+plt.show()
+
+# Impulse Response Analysis
+irf = var_model.irf(10)
+irf.plot(orth=False)
+plt.show()
+
+# Forecast Error Variance Decomposition
+fevd = var_model.fevd(10)
+fevd.plot()
+plt.show()
+```
+
+### VECM Model Example
+
+```python
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from statsmodels.tsa.vector_ar.vecm import VECM
+from statsmodels.tsa.stattools import adfuller, coint
+from statsmodels.tsa.vector_ar.var_model import VAR
+
+# Load or create data (non-stationary but cointegrated series)
+# Example: stock prices of related companies or exchange rates
+data = pd.read_csv('financial_data.csv', index_col=0, parse_dates=True)
+# If you don't have data, create synthetic cointegrated series:
+# np.random.seed(1)
+# dates = pd.date_range('1/1/2000', periods=200, freq='B')
+# common_trend = np.random.randn(200).cumsum()
+# series1 = common_trend + np.random.randn(200)*0.5
+# series2 = 0.7*common_trend + np.random.randn(200)*0.3
+# series3 = 1.3*common_trend + np.random.randn(200)*0.8
+# data = pd.DataFrame({'Asset1': series1, 'Asset2': series2, 'Asset3': series3}, index=dates)
+
+# Test for cointegration (Engle-Granger method for demonstration)
+def test_cointegration(series1, series2):
+    result = coint(series1, series2)
+    print(f'p-value: {result[1]}')
+    if result[1] < 0.05:
+        print("Series are cointegrated at 5% significance level")
+    else:
+        print("No cointegration found")
+
+# Test pairs of series
+pairs = [(i, j) for i in range(len(data.columns)) for j in range(i+1, len(data.columns))]
+for i, j in pairs:
+    print(f"Testing cointegration between {data.columns[i]} and {data.columns[j]}")
+    test_cointegration(data.iloc[:, i], data.iloc[:, j])
+
+# Johansen test is more appropriate for multivariate cointegration
+# This is built into the VECM model
+
+# Determine cointegration rank (number of cointegrating relationships)
+# Let statsmodels determine optimal rank, or specify based on testing
+model = VECM(data, deterministic="ci", k_ar_diff=2)
+vecm_results = model.fit()
+print(vecm_results.summary())
+
+# Get the cointegrating vector
+print("Cointegrating vector:")
+print(vecm_results.beta)
+
+# Get the adjustment coefficients
+print("Adjustment coefficients:")
+print(vecm_results.alpha)
+
+# Forecast using VECM
+forecast_steps = 10
+forecast = vecm_results.predict(steps=forecast_steps)
+forecast_df = pd.DataFrame(forecast, 
+                          index=pd.date_range(start=data.index[-1], 
+                                             periods=forecast_steps+1, 
+                                             freq=data.index.freq)[1:],
+                          columns=data.columns)
+
+# Plot forecasts
+plt.figure(figsize=(12, 8))
+for i, col in enumerate(data.columns):
+    plt.subplot(len(data.columns), 1, i+1)
+    plt.plot(data[col], label='Observed')
+    plt.plot(forecast_df[col], label='Forecast')
+    plt.title(f'VECM Forecast for {col}')
+    plt.legend()
+plt.tight_layout()
+plt.show()
+
+# Impulse Response Analysis
+irf = vecm_results.irf(10)
+irf.plot()
+plt.show()
+
+# Forecast Error Variance Decomposition
+fevd = vecm_results.fevd(10)
+fevd.plot()
+plt.show()
+```
+
+## Real-World Applications
+
+### Economics and Finance
+
+1. **Macroeconomic Forecasting**:
+
+  - Model relationships between GDP, inflation, unemployment, and interest rates
+  - Central banks use these models for monetary policy decisions
+  - Analyze how policy changes in one variable affect others over time
+
+2. **Financial Markets**:
+
+  - Model relationships between stock prices, exchange rates, and commodity prices
+  - VECM especially useful for asset pricing and portfolio management
+  - Capture long-term equilibrium between cointegrated financial series
+
+3. **Risk Management**:
+
+  - Forecast volatility and correlations between assets
+  - Model systemic risk propagation across markets
+  - Stress testing financial portfolios
+
+## Weather and Environmental Forecasting
+
+1. **Climate Analysis**:
+
+  - Model relationships between temperature, precipitation, humidity, and wind
+  - Capture seasonal patterns and long-term climate trends
+  - Study impact of climate variables on each other
+
+2. **Agricultural Planning**:
+
+  - Forecast crop yields based on multiple weather variables
+  - Analyze soil moisture, temperature, and precipitation interdependencies
+  - Optimize irrigation and planting schedules
+
+3. **Energy Demand Forecasting**:
+
+  - Model relationship between weather variables and energy consumption
+  - Forecast renewable energy generation (wind, solar)
+  - Optimize energy grid management
+
+## Comparing VAR and VECM
+
+Aspect                  | VAR                                             | VECM
+----------------------- | ----------------------------------------------- | --------------------------------------------------------
+Data Requirements       | Stationary time series                          | Non-stationary but cointegrated series
+Long-term Relationships | Not explicitly modeled                          | Explicitly modeled through cointegration
+Preprocessing           | Often requires differencing                     | Works with levels and differences
+Complexity              | Simpler to implement                            | More complex, requires cointegration testing
+Information Retention   | May lose level information through differencing | Preserves long-run information
+Typical Applications    | Short-term forecasting, impulse analysis        | Long-term equilibrium analysis, structural relationships
+
+## Key Considerations for Implementation
+
+1. **Stationarity Testing**: Always check stationarity using tests like Augmented Dickey-Fuller before VAR modeling.
+
+2. **Cointegration Testing**: For non-stationary series, test for cointegration using Johansen tests before deciding between VAR (on differenced data) and VECM.
+
+3. **Lag Selection**: Use information criteria (AIC, BIC, HQ) to select appropriate lag order.
+
+4. **Model Validation**: Check residual diagnostics (autocorrelation, normality) and out-of-sample forecast performance.
+
+5. **Interpretation Tools**: Use impulse response functions and forecast error variance decomposition to understand variable interactions.
+
+6. **Data Preprocessing**: Address outliers, missing values, and seasonal patterns before modeling.
+
+7. **Structural Breaks**: Test for and account for structural breaks that may affect model stability.
+
+8. **Parsimony vs. Complexity**: Balance model complexity with the risk of overfitting.
+
+9. **Forecast Horizon**: Consider that accuracy typically decreases with longer forecast horizons.
+
+10. **Exogenous Variables**: Determine whether to include exogenous variables using VARX/VECMX models.
+
+11. **Granger Causality**: Test for Granger causality to understand directional relationships.
+
+12. **Rolling Window Analysis**: Consider using rolling window estimation for evolving relationships.
+
+13. **Bayesian Approaches**: Explore Bayesian VAR for handling high-dimensional data with shorter time series.
+
+14. **Non-linear Extensions**: Consider non-linear extensions like Threshold VAR or Markov-Switching VAR for regime-dependent dynamics.
+
+15. **Computational Efficiency**: Implement efficient algorithms for large-scale multivariate systems.