Simulare istorică și Monte Carlo

Managementul Cantitativ al Riscului în Python

Jamsheed Shorish

Computational Economist

Simulare istorică

Nicio distribuție potrivită?
Simulare istorică: folosiți trecutul pentru a anticipa viitorul
- Nu necesită ipoteze de distribuție
- Pierderile anterioare devin pierderi simulate pentru ziua următoare

Simulare istorică în Python

VaR: porniți de la randamentele din asset_returns
Calculați portfolio_returns folosind weights ale portofoliului
Convertiți portfolio_returns în losses
VaR: calculați np.quantile() pentru losses la nivelul de încredere de ex. 95%
Presupune că distribuția viitoare a pierderilor este identică cu cea din trecut

weights = [0.25, 0.25, 0.25, 0.25]

portfolio_returns = asset_returns.dot(weights)

losses = - portfolio_returns

VaR_95 = np.quantile(losses, 0.95)

Simulare Monte Carlo

Simulare Monte Carlo: combinație puternică între estimare parametrică și simulare
- Presupune distribuții pentru pierderea portofoliului și/sau factorii de risc
- Utilizează extrageri aleatorii pentru a crea o traiectorie aleatorie, numită rulare
- Repetarea extragerilor $\Rightarrow$ creează un set de rulări de simulare
Calculați pierderea simulată a portofoliului pentru fiecare rulare până la orizontul dorit
Determinați VaR ca quantilă a pierderilor simulate

Simulare Monte Carlo în Python

Pasul unu:
- Importați distribuția normală norm din scipy.stats
- Definiți total_steps (1 zi = 1440 minute)
- Definiți numărul de rulări N
- Calculați media mu și deviația standard sigma ale datelor portfolio_losses

from scipy.stats import norm

total_steps = 1440

N = 10000

mu = portfolio_losses.mean()
sigma = portfolio_losses.std()

Simulare Monte Carlo în Python

Pasul doi:
- Inițializați vectorul daily_loss pentru N rulări
- Iterați peste N rulări
  - Calculați vectorul loss simulat Monte Carlo
    - Folosiți norm.rvs() pentru extrageri din distribuția normală standard
    - Extragerile corespund datelor folosind mu și sigma scalate cu 1/total_steps

daily_loss = np.zeros(N)

for n in range(N):

    loss = ( mu * (1/total_steps) + 
      norm.rvs(size=total_steps) * sigma * np.sqrt(1/total_steps) )

Simulare Monte Carlo în Python

Pasul trei:
- Generați daily_loss cumulat pentru fiecare rulare n
- Utilizați np.quantile() pentru VaR la nivelul de încredere de ex. 95%, pe daily_loss

daily_loss = np.zeros(N)
for n in range(N):

    loss = mu * (1/total_steps) + ...
      norm.rvs(size=total_steps) * sigma * np.sqrt(1/total_steps)

    daily_loss[n] = sum(loss)

VaR_95 = np.quantile(daily_loss, 0.95)

Simularea randamentelor activelor

Rafinare: generați traiectorii aleatorii ale randamentelor activelor din portofoliu
- Mai realist: randamentele pot fi simulate individual
- Randamentele pot fi corelate
  - Reamintire: matricea de covarianță eficientă e_cov
  - Utilizată în Pasul 2 pentru calculul randamentelor
Exerciții: simulare Monte Carlo cu simularea randamentelor activelor

Să exersăm!

Managementul Cantitativ al Riscului în Python