Introduction
Le Value at Risk (VaR) est une mesure clé en gestion des risques financiers. Il estime la perte maximale potentielle d'un portefeuille sur une période donnée (ex. : 1 jour) à un niveau de confiance spécifique (ex. : 95 % ou 99 %). Par exemple, un VaR à 95 % de 10 000 € signifie qu'il y a 5 % de chances de perdre plus de 10 000 € en une journée.
Pourquoi est-ce crucial en 2026 ? Avec la volatilité des marchés crypto, actions et obligations amplifiée par l'IA et les géopolitiques, les régulateurs comme Bâle III exigent des calculs VaR précis. Ce tutoriel beginner vous guide de A à Z en Python : méthodes paramétrique (normale), historique et Monte Carlo. Vous obtiendrez des codes complets et exécutables, des visualisations et des analogies simples (comme un 'filet de sécurité' probabiliste). À la fin, vous calculerez le VaR de n'importe quel actif. Idéal pour analystes juniors ou investisseurs personnels. (142 mots)
Prérequis
- Python 3.10+ installé
- Bibliothèques :
numpy,pandas,scipy,matplotlib(installées via pip) - Connaissances de base en probabilités (moyenne, écart-type) et finance (rendements)
- Un éditeur comme VS Code ou Jupyter Notebook
Installation des dépendances et génération de données
pip install numpy pandas scipy matplotlibInstallez les bibliothèques essentielles. numpy pour les calculs vectoriels, pandas pour les données tabulaires, scipy pour les stats avancées et matplotlib pour les graphiques.
Préparation des données de rendements
Avant tout calcul, générez ou chargez des rendements journaliers (returns = (prix_t - prix_{t-1}) / prix_{t-1}). Ici, nous simulons 1000 jours de rendements pour un portefeuille actions avec une moyenne de 0,1 % et volatilité 2 %, réaliste pour un indice comme le CAC40. Analogy : comme observer 1000 tirages d'une urne probabiliste.
Génération des données historiques simulées
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Paramètres : 1000 jours, mu=0.001 (rendement moyen), sigma=0.02 (volatilité)
np.random.seed(42)
returns = np.random.normal(0.001, 0.02, 1000)
# Portefeuille initial de 100 000 €
initial_value = 100000
values = initial_value * np.cumprod(1 + returns)
df = pd.DataFrame({'returns': returns, 'portfolio_value': values})
print(df.head())
# Sauvegarde pour réutilisation
df.to_csv('portfolio_returns.csv', index=False)
print('Données générées et sauvées.')Ce script génère des rendements gaussiens et calcule la valeur cumulée du portefeuille. np.cumprod accumule les rendements composés. Utilisez seed(42) pour reproductibilité. Exécutez-le une fois pour créer portfolio_returns.csv.
Méthode paramétrique : VaR sous loi normale
La méthode paramétrique assume des rendements normalement distribués. Formule : VaR = Valeur_initiale × (μ - z × σ), où z est le quantile (1,645 pour 95 %, 2,326 pour 99 %). Avantage : rapide. Limite : ignore les 'queues épaisses' des marchés réels (krachs). Analogy : comme prédire la pluie avec une moyenne météo, sans tempêtes extrêmes.
Calcul du VaR paramétrique
import numpy as np
import pandas as pd
from scipy.stats import norm
# Chargement des données
df = pd.read_csv('portfolio_returns.csv')
returns = df['returns'].values
initial_value = 100000
# Statistiques
mu = np.mean(returns)
sigma = np.std(returns)
print(f"Rendement moyen mu: {mu:.4f}, Volatilité sigma: {sigma:.4f}")
# Niveaux de confiance
confidence_levels = [0.95, 0.99]
for conf in confidence_levels:
z = norm.ppf(conf) # Quantile normal
var = initial_value * (mu - z * sigma)
print(f"VaR {int(conf*100)}%: {var:.2f} € (perte max attendue)")Calcule mu et sigma empiriques, puis applique la formule VaR. norm.ppf donne le z-score. Résultat typique : VaR 95% ~2 700 €, 99% ~4 500 €. Rapide pour gros volumes.
Méthode historique : Basée sur les données passées
VaR historique trie les pertes passées et prend le quantile. Non-paramétrique : capture les extrêmes réels. Exemple : pour 95 %, triez 1000 rendements descendants et prenez le 5e pire (position 50). Avantage : simple, robuste aux non-normalités. Limite : nécessite beaucoup de données historiques.
Calcul du VaR historique
import numpy as np
import pandas as pd
# Chargement
df = pd.read_csv('portfolio_returns.csv')
returns = df['returns'].values
initial_value = 100000
# Pertes (négatives)
losses = -returns * initial_value
losses_sorted = np.sort(losses)
confidence_levels = [0.95, 0.99]
for conf in confidence_levels:
index = int((1 - conf) * len(losses))
var = losses_sorted[index]
print(f"VaR historique {int(conf*100)}%: {var:.2f} €")
# Visualisation rapide
print("Top 5 pires pertes:", losses_sorted[:5])Transforme returns en pertes, trie et sélectionne le quantile. Pour 1000 obs, 95% = index 50. Capture les vrais chocs, souvent plus conservateur que paramétrique.
Méthode Monte Carlo : Simulations prospectives
Monte Carlo simule des milliers de scénarios futurs basés sur mu/sigma. Idéal pour portefeuilles complexes. Étapes : générer paths, calculer pertes, prendre quantile. Analogy : lancer 10 000 dés pondérés pour prédire la fortune future.
Calcul du VaR Monte Carlo
import numpy as np
import pandas as pd
from scipy.stats import norm
# Données empiriques
df = pd.read_csv('portfolio_returns.csv')
returns = df['returns'].values
mu, sigma = np.mean(returns), np.std(returns)
initial_value = 100000
# Simulations : 10000 paths, 1 jour
n_simulations = 10000
sim_returns = np.random.normal(mu, sigma, n_simulations)
losses_mc = -sim_returns * initial_value
losses_mc_sorted = np.sort(losses_mc)
confidence_levels = [0.95, 0.99]
for conf in confidence_levels:
index = int((1 - conf) * n_simulations)
var_mc = losses_mc_sorted[index]
print(f"VaR Monte Carlo {int(conf*100)}%: {var_mc:.2f} €")Simule 10 000 rendements futurs, trie pertes. Similaire à historique mais prospectif. Augmentez n_simulations pour précision (loi faible des grands nombres).
Visualisation comparative des méthodes
Visualisez pour comparer. Histogramme des pertes + lignes VaR aide à valider (ex. : queues normales ?).
Graphique des VaR et distribution des pertes
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# Données
df = pd.read_csv('portfolio_returns.csv')
returns = df['returns'].values
initial_value = 100000
losses = -returns * initial_value
plt.figure(figsize=(10, 6))
plt.hist(losses, bins=50, alpha=0.7, density=True, label='Distribution historique')
# VaR lignes
var_95 = np.percentile(losses, 5)
var_99 = np.percentile(losses, 1)
plt.axvline(var_95, color='red', linestyle='--', label=f'VaR 95%: {var_95:.0f}€')
plt.axvline(var_99, color='orange', linestyle='--', label=f'VaR 99%: {var_99:.0f}€')
plt.xlabel('Pertes (€)')
plt.ylabel('Densité')
plt.title('Distribution des pertes et seuils VaR')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()
print(f'VaR 95% visuel: {var_95:.2f}€')Histogramme + np.percentile pour VaR (équiv. historique). axvline trace les seuils. Sauvegardez avec plt.savefig('var_plot.png') pour rapports.
Bonnes pratiques
- Utilisez des données réelles : Remplacez simulations par
yfinancepour actions (ex. :pip install yfinance). - Backtestez : Comparez VaR prédit vs pertes réelles sur 1 an.
- Multi-actifs : Passez à matrices de covariance pour portefeuilles.
- Périodes adaptées : 1T pour trading, 10T pour fonds.
- Réglementaire : Alignez sur 99% / 10 jours pour Bâle.
Erreurs courantes à éviter
- Assume normale toujours : Marchés ont queues grasses → sous-estime VaR (utilisez historique/MC).
- Oublier composés : Calculez sur returns log, pas simples pour longues périodes.
- Peu de données : <500 obs → instable ; bootstrappez si besoin.
- Ignorer corrélations : Pour portefeuilles, covariance obligatoire.
Pour aller plus loin
Approfondissez avec Expected Shortfall (CVaR), VaR conditionnel ou GARCH pour volatilité dynamique. Ressources : livre 'Quantitative Risk Management' de McNeil ; docs NumPy, SciPy stats. Formations pro : Learni Group Formations Finance Quant. Testez sur données Bitcoin via yfinance !