Simulation historique et Monte Carlo

Gestion quantitative des risques en Python

Jamsheed Shorish

Computational Economist

Simulation historique

Aucune famille de distributions adaptée ?
Simulation historique : utiliser le passé pour anticiper l'avenir
- Aucune hypothèse de distribution requise
- Les pertes passées deviennent des pertes simulées pour demain

Simulation historique en Python

VaR : partir des rendements dans asset_returns
Calculer portfolio_returns avec les weights du portefeuille
Convertir portfolio_returns en losses
VaR : calculer np.quantile() pour losses p. ex. au niveau de confiance 95 %
Suppose que la distribution future des pertes est exactement la même que la passée

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)

Simulation Monte Carlo

Simulation Monte Carlo : combinaison puissante d'estimation paramétrique et de simulation
- Suppose une ou des distributions pour la perte du portefeuille et/ou les facteurs de risque
- S'appuie sur des tirages aléatoires de ces distributions pour créer un trajet aléatoire, appelé une exécution
- Répéter les tirages $\Rightarrow$ crée un ensemble d'exécutions de simulation
Calculer la perte simulée du portefeuille à chaque exécution jusqu'à l'horizon souhaité
Estimer la VaR comme le quantile des pertes simulées

Simulation Monte Carlo en Python

Étape 1 :
- Importer la loi Normale norm depuis scipy.stats
- Définir total_steps (1 jour = 1 440 minutes)
- Définir le nombre d'exécutions N
- Calculer la moyenne mu et l'écart type sigma des portfolio_losses

from scipy.stats import norm

total_steps = 1440

N = 10000

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

Simulation Monte Carlo en Python

Étape 2 :
- Initialiser le vecteur daily_loss pour N exécutions
- Boucler sur N exécutions
  - Calculer le vecteur loss simulé par Monte Carlo
    - Utilise norm.rvs() pour tirer à répétition dans la Normale standard
    - Les tirages reflètent les données via mu et sigma à l'échelle 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) )

Simulation Monte Carlo en Python

Étape 3 :
- Générer la daily_loss cumulée pour chaque exécution n
- Utiliser np.quantile() pour obtenir la VaR, p. ex. au niveau 95 %, sur 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)

Simuler les rendements d'actifs

Affinage : générer des trajectoires aléatoires des rendements d'actifs du portefeuille
- Plus de réalisme : rendements simulés individuellement
- Les rendements peuvent être corrélés
  - Rappel : matrice de covariance efficiente e_cov
  - Utilisée à l'étape 2 pour calculer les rendements des actifs
Exercices : simulation Monte Carlo avec simulation des rendements d'actifs

Passons à la pratique !

Gestion quantitative des risques en Python