Variables aléatoires et espérance

Un nombre dont la valeur n'est pas encore connue

Une variable aléatoire est une grandeur dont la valeur dépend du hasard : le lancer d'un dé, le rendement de demain, le prix d'une action à l'échéance. Une variable aléatoire discrète prend une liste de valeurs possibles, chacune avec une probabilité. Les valeurs et les probabilités forment ensemble sa distribution. Les probabilités ne sont jamais négatives et leur somme vaut 1. En Python, ce sont simplement deux listes de même longueur, values et probs. Un dé équilibré est values = [1, 2, 3, 4, 5, 6] avec probs = [1/6] * 6.

import math

values = [1, 2, 3, 4, 5, 6]
probs = [1 / 6] * 6

# A valid distribution: no negatives, and the probabilities add up to 1
print(all(p >= 0 for p in probs))             # True
print(math.isclose(sum(probs), 1.0))          # True (compare floats with isclose)

# A stock tomorrow: down 5%, up 2% or up 8%
returns = [-0.05, 0.02, 0.08]
chances = [0.2, 0.5, 0.3]
print(math.isclose(sum(chances), 1.0))        # True

L'espérance : la moyenne pondérée par les probabilités

L'espérance E[X] est la moyenne obtenue sur un grand nombre de répétitions : multipliez chaque valeur par sa probabilité et additionnez, sum(v * p). Un dé a E[X] = 3.5, un nombre qu'il ne peut jamais montrer, et ce n'est pas un problème : c'est une moyenne à long terme, pas la prédiction d'un résultat. L'espérance est linéaire : E[a*X + b] = a*E[X] + b. L'espérance d'une fonction E[g(X)] applique d'abord g à chaque valeur : sum(g(v) * p). Attention : en général E[g(X)] n'est pas g(E[X]). Le gain d'une option max(S - K, 0) en est le cas classique.

def expected_value(values, probs):
    return sum(v * p for v, p in zip(values, probs))

die = [1, 2, 3, 4, 5, 6]
fair = [1 / 6] * 6
print(round(expected_value(die, fair), 4))            # 3.5

# E[g(X)]: apply g to each value first. Call payoff with strike 100:
prices = [90, 100, 110, 120]
chances = [0.1, 0.4, 0.3, 0.2]
mean_price = expected_value(prices, chances)
print(mean_price)                                      # 106.0
print(expected_value([max(s - 100, 0) for s in prices], chances))  # 7.0  = E[max(S - K, 0)]
print(max(mean_price - 100, 0))                        # 6.0  = max(E[S] - K, 0), not the same

La variance : quelle est la dispersion ?

Deux placements peuvent avoir la même espérance de rendement et des risques très différents. La variance mesure la dispersion autour de la moyenne : Var(X) = E[(X - mu)^2], qui se calcule aussi comme E[X^2] - E[X]^2. L'écart type en est la racine carrée, dans les mêmes unités que X ; pour des rendements, c'est la volatilité. Pour le dé, Var = 35/12 = 2.9167. Les deux se construisent à partir d'espérances de fonctions de X : une fonction expected_of(g, values, probs) bien écrite donne la moyenne, le moment d'ordre deux et tout le reste.

def expected_value(values, probs):
    return sum(v * p for v, p in zip(values, probs))

def expected_of(g, values, probs):
    return expected_value([g(v) for v in values], probs)

def variance(values, probs):
    mean = expected_of(lambda v: v, values, probs)
    return expected_of(lambda v: v * v, values, probs) - mean ** 2

die, fair = [1, 2, 3, 4, 5, 6], [1 / 6] * 6
print(round(variance(die, fair), 4))                   # 2.9167

returns, chances = [-0.05, 0.02, 0.08], [0.2, 0.5, 0.3]
print(round(expected_value(returns, chances), 4))      # 0.024
print(round(variance(returns, chances), 6))            # 0.002044

Simulation et loi des grands nombres

On peut aussi estimer une espérance en tirant des échantillons. rng.choices(values, weights=probs, k=n) renvoie n tirages, et la moyenne des tirages se rapproche de E[X] quand n grandit : c'est la loi des grands nombres. C'est le cœur de la valorisation par Monte Carlo. Utilisez votre propre random.Random(seed) pour que l'exécution soit répétable et ne perturbe pas le reste du code. Avec peu de tirages la moyenne est bruitée ; l'erreur ne diminue que comme l'inverse de la racine de n, donc 100 fois plus de tirages n'apportent que 10 fois plus de précision.

import random

die, fair = [1, 2, 3, 4, 5, 6], [1 / 6] * 6

def sample_mean(values, probs, n, seed):
    rng = random.Random(seed)                    # private, repeatable generator
    draws = rng.choices(values, weights=probs, k=n)
    return sum(draws) / n

for n in (10, 1000, 100000):
    print(n, round(sample_mean(die, fair, n, 1), 4))
# 10 3.1
# 1000 3.598
# 100000 3.5017       (closing in on 3.5)

print(sample_mean(die, fair, 1000, 1) == sample_mean(die, fair, 1000, 1))  # True: same seed, same answer

• Une distribution est values plus probs (sans négatifs, somme 1) ; E[X] = sum(v * p).
• E[g(X)] = sum(g(v) * p), qui n'est pas g(E[X]) ; Var = E[X^2] - E[X]^2.
• Les moyennes d'échantillon convergent vers E[X] (loi des grands nombres) ; utilisez votre propre random.Random(seed).

À suivre : les tableaux NumPy et les dtypes, les tableaux rapides et typés sur lesquels repose le reste du cours.

Lab : ce qui est noté

• Moyenner les issues selon leurs probabilités avec expected_value25 pts
• Calculer l'espérance d'un gain avec expected_of25 pts
• Mesurer la dispersion avec variance25 pts
• Estimer l'espérance par simulation avec sample_mean25 pts