Diagnosing GARCH Volatility Initialization in Index Simulations
Summary
The document presents a simulation of index prices using log returns and a GARCH(1,1) variance recursion. The author selects parameters using the lowest Akaike information criterion and generates repeated paths by drawing innovations from a normal distribution. They report that the simulated volatility appears unusually high at the start and then declines, and ask whether the initialization is faulty or another model would be preferable.
The code initializes the first variance by dividing the initial return residual by a random normal draw and squaring the result. That makes the starting variance depend on a single random draw, which can create an unstable initial value and affect the early path. The document includes no answer, validation, or comparison against alternative models, so it does not establish a corrected initialization method or show whether the fitted specification is appropriate. Its evidence is limited to the described code and the author’s plot observation.
Key ideas
- The simulation applies a GARCH(1,1) recursion to log returns to generate index price paths.
- The reported volatility starts high and later becomes small, prompting a question about initialization or model choice.
- The initial variance calculation depends on one random normal draw and can produce an unstable starting value.
- The document provides no proposed correction or evidence comparing GARCH with alternative models.
Tags
Full text
# Time series analysis for stock prices
# Time series analysis for stock prices
I am using GARCH model to simulate price of an index for 7 years. For input I am using difference of Log of prices (log of return).
GARCH(1,1) has the lowest AIC, and I found parameters for the GARCH model and I simulated price of the index for 100 times using the following code using PYTHON.
```
mu = [0.000103]
omega = [0.000003]
alpha1 = [0.121624]
beta1 = [0.859032]
maturity = 21*12*7 +6*21
scenarios = 100
init_log_return =list(np.log(IDV).diff().iloc[-1,:])
monthlyreturn_GARCH = np.zeros((scenarios, maturity, len(Index)))
volatility_GARCH = np.zeros((scenarios, maturity, len(Index)))
monthly_prices_GARCH = np.zeros((scenarios, maturity, len(Index)))
for scenario in range(0, scenarios):
for index in range(len(Index)):
monthly_prices_GARCH[scenario][0][index] = IDV.iloc[-1,:][index]
monthlyreturn_GARCH[scenario][0][index] = init_log_return[index]
Ut = monthlyreturn_GARCH[scenario][0][index] - mu[index]
volatility_GARCH[scenario][0][index] = (Ut / np.random.normal(0, 1))**2
for day in range (1,maturity):
volatility_GARCH[scenario][day][index] = omega[index] + alpha1[index]* Ut**2 + beta1[index]*volatility_GARCH[scenario][day-1][index]
Ut = np.sqrt(volatility_GARCH[scenario][day][index] )* np.random.normal(0, 1)
monthlyreturn_GARCH[scenario][day][index] = mu[index] +Ut
monthly_prices_GARCH[scenario][day][index] = np.exp(np.log(monthly_prices_GARCH[scenario][day-1][index]) + monthlyreturn_GARCH[scenario][day][index])
```
However, when I plot variance over time I am getting the following output.
The daily volatility is very high at the beginning and then it will become very small. The results does not look right. Is there any methods other than GARCH that can give me better results? or do you have any idea what went wrong here? or do you have any suggestion for improvements?Shown in full with attribution under the source's licence. Licence: CC BY-SA 4.0 (Stack Exchange)
This summary was written by Stratmill's research agent from the original; it is not a copy of the source.