Éthique et biais

Science sans conscience n’est que ruine de l’âme.

— Rabelais, Pantagruel

L’apprentissage automatique est passé en quelques années du laboratoire de recherche aux décisions qui affectent la vie quotidienne de millions de personnes : octroi de crédit, diagnostic médical, recrutement, justice pénale, modération de contenus. Cette omniprésence confère aux praticiens du machine learning une responsabilité considérable. Un modèle entraîné sur des données biaisées reproduit et amplifie les injustices historiques ; un système opaque prive les personnes affectées de tout recours. Ce chapitre — le dernier de cet ouvrage — aborde les questions d”éthique, de biais, d”équité algorithmique et de vie privée qui doivent accompagner chaque étape du cycle de vie d’un modèle, depuis la collecte des données jusqu’à son déploiement en production.

Show code cell source

Hide code cell source

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (
    accuracy_score, confusion_matrix, classification_report
)
from sklearn.preprocessing import StandardScaler

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)
np.random.seed(42)

Introduction : pourquoi l’éthique compte

Des controverses révélatrices

Plusieurs affaires médiatisées ont mis en lumière les risques des systèmes d’apprentissage automatique déployés sans garde-fous suffisants.

COMPAS (Correctional Offender Management Profiling for Alternative Sanctions). Ce logiciel, utilisé par des tribunaux américains pour évaluer le risque de récidive, a été analysé en 2016 par l’organisation ProPublica. L’enquête a révélé que le système attribuait aux accusés noirs un risque de récidive deux fois plus élevé qu’aux accusés blancs, à profil criminel comparable. Le score était présenté aux juges comme une aide à la décision pour fixer les peines et les conditions de libération.

Reconnaissance faciale. Plusieurs études, notamment les travaux de Joy Buolamwini et Timnit Gebru (Gender Shades, 2018), ont montré que les systèmes commerciaux de reconnaissance faciale présentaient des taux d’erreur pouvant atteindre 34,7 % pour les femmes à peau foncée, contre moins de 1 % pour les hommes à peau claire. Ces disparités s’expliquent par le manque de diversité dans les jeux de données d’entraînement.

Outil de recrutement d’Amazon. En 2018, il a été révélé qu’Amazon avait abandonné un outil interne de tri automatique de CV après avoir constaté qu’il pénalisait systématiquement les candidatures féminines. Le modèle, entraîné sur dix années de données de recrutement dominées par des profils masculins, avait appris à associer le genre féminin à un signal négatif.

Remarque 272

Ces exemples ne sont pas des défaillances techniques isolées : ils sont la conséquence directe de choix humains — choix des données, des variables, des métriques d’optimisation, du cadre de déploiement. L’éthique en apprentissage automatique n’est pas un supplément optionnel ; elle fait partie intégrante de la compétence du praticien.

La responsabilité du praticien

Le développeur d’un modèle de machine learning n’est pas un simple technicien : il fait des choix qui ont des conséquences sociales. Quelles données collecter ? Quelles variables inclure ? Quelle métrique optimiser ? Comment interpréter et communiquer les résultats ? À chacune de ces étapes, des décisions apparemment techniques encodent des valeurs et des hypothèses sur le monde.

Biais dans les données

Sources de biais

Les biais dans les données d’entraînement constituent la source la plus fréquente d’injustice algorithmique. On distingue plusieurs catégories.

Définition 324 (Principales sources de biais dans les données)

1. Biais historique (historical bias) : les données reflètent des inégalités ou des discriminations passées. Exemple : si les femmes ont historiquement été sous-représentées dans les postes de direction, un modèle entraîné sur ces données associera le genre féminin à une moindre probabilité de promotion.

2. Biais de représentation (representation bias) : certains groupes sont sous-représentés dans les données collectées. Exemple : un jeu de données d’images faciales contenant 80 % de visages à peau claire.

3. Biais de mesure (measurement bias) : les variables mesurées ne capturent pas fidèlement le phénomène d’intérêt, et les erreurs de mesure sont corrélées à l’appartenance à un groupe. Exemple : utiliser le nombre d’arrestations comme proxy de la criminalité réelle, alors que les pratiques policières varient selon les quartiers.

4. Biais d’agrégation (aggregation bias) : un modèle unique est appliqué à des populations hétérogènes pour lesquelles les relations entre variables diffèrent. Exemple : un même modèle de diagnostic pour des populations ayant des prévalences très différentes d’une maladie.

5. Biais de sélection (selection bias) : l’échantillon de données n’est pas représentatif de la population cible. Exemple : un modèle de détection de fraude entraîné uniquement sur les transactions ayant déjà fait l’objet d’une enquête.

6. Biais d’étiquetage (label bias) : les étiquettes elles-mêmes sont biaisées par les jugements humains. Exemple : des annotateurs qui attribuent plus facilement l’étiquette « toxique » à des textes en dialecte afro-américain.

Exemple 49 (Biais de survie)

Le biais de survie (survivorship bias) est un cas particulier de biais de sélection : on n’observe que les individus ayant « survécu » à un processus de filtrage. L’exemple classique est celui d’Abraham Wald durant la Seconde Guerre mondiale : les militaires voulaient renforcer les zones des avions les plus touchées par les impacts de balles sur les appareils revenus de mission. Wald fit remarquer qu’il fallait au contraire renforcer les zones sans impacts — car les avions touchés à ces endroits n’étaient pas revenus. En machine learning, un modèle de crédit entraîné uniquement sur les clients ayant obtenu un prêt souffre du même biais : il ne sait rien des clients refusés.

Démonstration : biais dans un jeu de données synthétique

Construisons un jeu de données synthétique simulant un processus de sélection biaisé. Nous modélisons un scénario d’admission universitaire où un attribut sensible (le groupe d’appartenance) influence à la fois la variable observée (le score au test) et la décision finale.

Show code cell source

Hide code cell source

# Génération d'un jeu de données synthétique biaisé
n = 2000
groupe = np.random.choice(['A', 'B'], size=n, p=[0.5, 0.5])

# Compétence réelle (identiquement distribuée)
competence = np.random.randn(n)

# Le score observé est bruité ET systématiquement décalé pour le groupe B
bruit = np.random.randn(n) * 0.5
score = competence + bruit + np.where(groupe == 'B', -0.8, 0.0)

# La décision historique est basée sur le score observé (biaisé)
seuil = 0.0
decision = (score > seuil).astype(int)

df_biais = pd.DataFrame({
    'groupe': groupe,
    'competence': competence,
    'score': score,
    'admis': decision
})

print("Taux d'admission par groupe :")
print(df_biais.groupby('groupe')['admis'].mean().round(3))
print(f"\nDifférence de compétence réelle moyenne : "
      f"{df_biais.groupby('groupe')['competence'].mean().diff().iloc[-1]:.3f}")

Taux d'admission par groupe :
groupe
A    0.496
B    0.224
Name: admis, dtype: float64

Différence de compétence réelle moyenne : 0.025

Show code cell source

Hide code cell source

# Visualisation du biais
fig, axes = plt.subplots(3, 1, figsize=(9, 12))

# Distribution de la compétence réelle (identique)
for g, color in [('A', '#4C72B0'), ('B', '#DD8452')]:
    mask = df_biais['groupe'] == g
    axes[0].hist(df_biais.loc[mask, 'competence'], bins=30, alpha=0.5,
                 color=color, label=f'Groupe {g}', density=True)
axes[0].set_title("Compétence réelle (identique)")
axes[0].set_xlabel("Compétence"); axes[0].legend()

# Distribution du score observé (biaisé)
for g, color in [('A', '#4C72B0'), ('B', '#DD8452')]:
    mask = df_biais['groupe'] == g
    axes[1].hist(df_biais.loc[mask, 'score'], bins=30, alpha=0.5,
                 color=color, label=f'Groupe {g}', density=True)
axes[1].axvline(seuil, color='red', linestyle='--', label='Seuil')
axes[1].set_title("Score observé (biaisé)")
axes[1].set_xlabel("Score"); axes[1].legend()

# Taux d'admission par groupe
taux = df_biais.groupby('groupe')['admis'].mean()
axes[2].bar(taux.index, taux.values, color=['#4C72B0', '#DD8452'], width=0.5)
axes[2].set_title("Taux d'admission par groupe")
axes[2].set_ylabel("Taux d'admission")
axes[2].set_ylim(0, 1)
for i, (g, v) in enumerate(taux.items()):
    axes[2].text(i, v + 0.02, f'{v:.1%}', ha='center', fontsize=12)

plt.suptitle("Biais de mesure : compétence égale, scores inégaux", fontsize=13, y=1.02)
plt.tight_layout()
plt.show()

Remarque 273

Dans cet exemple, la compétence réelle des deux groupes est identique par construction. Pourtant, le biais de mesure (le décalage de \(-0.8\) sur le score du groupe B) produit une disparité d’admission considérable. Si l’on entraîne un modèle sur ces données historiques, il apprendra à reproduire et renforcer cette inégalité. Le biais est d’autant plus pernicieux qu’il est invisible si l’on ne dispose pas d’une mesure indépendante de la compétence réelle.

Biais dans les modèles

Amplification des biais

Un modèle d’apprentissage automatique ne se contente pas de reproduire les biais présents dans les données : il peut les amplifier. Ce phénomène s’explique par le fait que l’optimisation pousse le modèle à exploiter toute corrélation statistique présente dans les données, y compris les corrélations spurieuses liées à l’appartenance à un groupe protégé.

Définition 325 (Discrimination par proxy)

La discrimination par proxy (proxy discrimination) survient lorsqu’un modèle utilise des variables qui, bien que neutres en apparence, sont fortement corrélées à un attribut sensible. Par exemple :

• Le code postal est souvent un proxy de l’origine ethnique en raison de la ségrégation résidentielle.

• Le prénom peut être un proxy du genre ou de l’origine culturelle.

• Le type de navigateur web a été utilisé comme proxy du niveau socio-économique.

Supprimer l’attribut sensible des données d’entraînement (approche dite fairness through unawareness) ne suffit donc pas à éliminer la discrimination.

Boucles de rétroaction

Définition 326 (Boucle de rétroaction)

Une boucle de rétroaction (feedback loop) apparaît lorsque les prédictions d’un modèle influencent les données futures sur lesquelles il sera réentraîné, créant un cycle auto-renforçant :

\[\text{Données biaisées} \xrightarrow{\text{entraînement}} \text{Modèle biaisé} \xrightarrow{\text{déploiement}} \text{Décisions biaisées} \xrightarrow{\text{collecte}} \text{Données encore plus biaisées}\]

Exemple : un algorithme de police prédictive envoie davantage de patrouilles dans certains quartiers. Ces patrouilles supplémentaires entraînent mécaniquement plus d’arrestations dans ces quartiers, ce qui renforce la prédiction initiale, indépendamment du taux de criminalité réel.

Démonstration : impact disparate d’un classifieur biaisé

Entraînons un classifieur sur les données biaisées construites précédemment et mesurons l”impact disparate (disparate impact) de ses prédictions.

Show code cell source

Hide code cell source

# Préparation des données
X = df_biais[['score']].values
y = df_biais['admis'].values
groupes = df_biais['groupe'].values

X_train, X_test, y_train, y_test, g_train, g_test = train_test_split(
    X, y, groupes, test_size=0.3, random_state=42
)

# Entraînement d'une régression logistique
model = LogisticRegression(random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# Taux de prédiction positive par groupe
print("=== Impact disparate ===")
for g in ['A', 'B']:
    mask = g_test == g
    taux_pos = y_pred[mask].mean()
    taux_vrai = y_test[mask].mean()
    print(f"Groupe {g} : taux prédit positif = {taux_pos:.3f}, "
          f"taux réel positif = {taux_vrai:.3f}")

# Calcul du ratio d'impact disparate (règle des 80 %)
taux_A = y_pred[g_test == 'A'].mean()
taux_B = y_pred[g_test == 'B'].mean()
ratio = min(taux_A, taux_B) / max(taux_A, taux_B)
print(f"\nRatio d'impact disparate : {ratio:.3f}")
print(f"Règle des 80 % respectée : {'Oui' if ratio >= 0.8 else 'Non'}")

=== Impact disparate ===
Groupe A : taux prédit positif = 0.510, taux réel positif = 0.510
Groupe B : taux prédit positif = 0.213, taux réel positif = 0.213

Ratio d'impact disparate : 0.417
Règle des 80 % respectée : Non

Définition 327 (Règle des quatre cinquièmes (80 %))

La règle des quatre cinquièmes (four-fifths rule), issue du droit américain de l’emploi, stipule qu’un processus de sélection est présumé discriminatoire si le taux de sélection du groupe le moins favorisé est inférieur à 80 % du taux de sélection du groupe le plus favorisé :

\[\text{Impact disparate} = \frac{\min(\hat{P}(Y=1 \mid G=a), \hat{P}(Y=1 \mid G=b))}{\max(\hat{P}(Y=1 \mid G=a), \hat{P}(Y=1 \mid G=b))} < 0.8\]

où \(G\) désigne l’attribut sensible et \(\hat{P}(Y=1 \mid G=g)\) le taux de prédiction positive pour le groupe \(g\).

Show code cell source

Hide code cell source

# Visualisation de l'impact disparate
fig, axes = plt.subplots(1, 2, figsize=(11, 5))

# Matrice de confusion par groupe
for idx, g in enumerate(['A', 'B']):
    mask = g_test == g
    cm = confusion_matrix(y_test[mask], y_pred[mask])
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[idx],
                xticklabels=['Refusé', 'Admis'],
                yticklabels=['Refusé', 'Admis'])
    axes[idx].set_title(f"Groupe {g}")
    axes[idx].set_xlabel("Prédiction"); axes[idx].set_ylabel("Réalité")

plt.suptitle("Matrices de confusion par groupe", fontsize=13, y=1.02)
plt.tight_layout()
plt.show()

Équité algorithmique

Définitions formelles de l’équité

L’équité algorithmique (algorithmic fairness) est un domaine de recherche actif qui vise à formaliser mathématiquement la notion de « justice » dans les systèmes décisionnels automatisés. Plusieurs définitions coexistent, chacune capturant un aspect différent de l’équité.

Notons \(Y\) la variable cible réelle, \(\hat{Y}\) la prédiction du modèle et \(G\) l’attribut sensible (genre, origine, etc.).

Définition 328 (Parité démographique)

La parité démographique (demographic parity ou statistical parity) exige que la prédiction du modèle soit indépendante de l’attribut sensible :

\[P(\hat{Y} = 1 \mid G = a) = P(\hat{Y} = 1 \mid G = b) \quad \forall\, a, b\]

Autrement dit, chaque groupe doit recevoir le même taux de prédictions positives, indépendamment de la réalité.

Définition 329 (Égalité des chances)

L”égalité des chances (equalized odds) exige que les taux de vrais positifs et de faux positifs soient identiques entre les groupes :

\[P(\hat{Y} = 1 \mid Y = y, G = a) = P(\hat{Y} = 1 \mid Y = y, G = b) \quad \forall\, y \in \{0, 1\}\]

Une version relâchée, l”égalité d’opportunité (equal opportunity), n’impose cette condition que pour \(Y = 1\) (les vrais positifs).

Définition 330 (Parité prédictive)

La parité prédictive (predictive parity) exige que la valeur prédictive positive (positive predictive value, PPV) soit identique entre les groupes :

\[P(Y = 1 \mid \hat{Y} = 1, G = a) = P(Y = 1 \mid \hat{Y} = 1, G = b) \quad \forall\, a, b\]

Autrement dit, lorsque le modèle prédit un résultat positif, la probabilité que cette prédiction soit correcte doit être la même quel que soit le groupe.

Théorème d’impossibilité

L’un des résultats les plus importants de la recherche sur l’équité algorithmique est le théorème d’impossibilité, établi indépendamment par Chouldechova (2017) et Kleinberg, Mullainathan et Raghavan (2016).

Définition 331 (Théorème d’impossibilité de l’équité)

Sauf dans les cas triviaux où les taux de base sont identiques entre les groupes (\(P(Y=1 \mid G=a) = P(Y=1 \mid G=b)\)) ou le classifieur est parfait, il est impossible de satisfaire simultanément les trois critères suivants :

1. Calibration : \(P(Y=1 \mid S=s, G=a) = P(Y=1 \mid S=s, G=b)\) pour tout score \(s\)

2. Équilibre pour les positifs : \(\mathbb{E}[S \mid Y=1, G=a] = \mathbb{E}[S \mid Y=1, G=b]\)

3. Équilibre pour les négatifs : \(\mathbb{E}[S \mid Y=0, G=a] = \mathbb{E}[S \mid Y=0, G=b]\)

Ce résultat implique que le choix d’une notion d’équité est nécessairement un choix de valeurs, pas un choix technique.

Remarque 274

Le théorème d’impossibilité ne signifie pas qu’il faut renoncer à l’équité. Il signifie qu’il faut expliciter la définition d’équité retenue et justifier ce choix en fonction du contexte d’application. Dans un système de justice pénale, on pourra privilégier l’égalité des taux de faux positifs (ne pas sur-pénaliser un groupe) ; dans un système d’admission, on pourra privilégier la parité démographique (représentation équitable).

Calcul des métriques d’équité

Show code cell source

Hide code cell source

def fairness_metrics(y_true, y_pred, group, group_values=('A', 'B')):
    """Calcule les principales métriques d'équité."""
    results = {}
    for g in group_values:
        mask = group == g
        yt, yp = y_true[mask], y_pred[mask]

        tp = ((yp == 1) & (yt == 1)).sum()
        fp = ((yp == 1) & (yt == 0)).sum()
        fn = ((yp == 0) & (yt == 1)).sum()
        tn = ((yp == 0) & (yt == 0)).sum()

        tpr = tp / (tp + fn) if (tp + fn) > 0 else 0
        fpr = fp / (fp + tn) if (fp + tn) > 0 else 0
        ppv = tp / (tp + fp) if (tp + fp) > 0 else 0
        selection_rate = yp.mean()

        results[g] = {
            'Taux de sélection': selection_rate,
            'TPR (Sensibilité)': tpr,
            'FPR (Taux faux positifs)': fpr,
            'PPV (Précision)': ppv
        }

    df_res = pd.DataFrame(results).T
    df_res.index.name = 'Groupe'
    return df_res


metrics = fairness_metrics(y_test, y_pred, g_test)
print("=== Métriques d'équité ===")
print(metrics.round(3))
print()

# Évaluation des critères
sr_diff = abs(metrics.loc['A', 'Taux de sélection']
              - metrics.loc['B', 'Taux de sélection'])
tpr_diff = abs(metrics.loc['A', 'TPR (Sensibilité)']
               - metrics.loc['B', 'TPR (Sensibilité)'])
fpr_diff = abs(metrics.loc['A', 'FPR (Taux faux positifs)']
               - metrics.loc['B', 'FPR (Taux faux positifs)'])
ppv_diff = abs(metrics.loc['A', 'PPV (Précision)']
               - metrics.loc['B', 'PPV (Précision)'])

print(f"Écart de parité démographique : {sr_diff:.3f}")
print(f"Écart de TPR (égalité d'opportunité) : {tpr_diff:.3f}")
print(f"Écart de FPR : {fpr_diff:.3f}")
print(f"Écart de parité prédictive (PPV) : {ppv_diff:.3f}")

=== Métriques d'équité ===
        Taux de sélection  TPR (Sensibilité)  FPR (Taux faux positifs)  \
Groupe                                                                   
A                   0.510                1.0                       0.0   
B                   0.213                1.0                       0.0   

        PPV (Précision)  
Groupe                   
A                   1.0  
B                   1.0  

Écart de parité démographique : 0.297
Écart de TPR (égalité d'opportunité) : 0.000
Écart de FPR : 0.000
Écart de parité prédictive (PPV) : 0.000

Show code cell source

Hide code cell source

# Visualisation radar des métriques d'équité
categories = list(metrics.columns)
N = len(categories)

fig, ax = plt.subplots(figsize=(7, 7), subplot_kw=dict(polar=True))
angles = np.linspace(0, 2 * np.pi, N, endpoint=False).tolist()
angles += angles[:1]

for g, color in [('A', '#4C72B0'), ('B', '#DD8452')]:
    values = metrics.loc[g].values.tolist()
    values += values[:1]
    ax.plot(angles, values, 'o-', linewidth=2, label=f'Groupe {g}', color=color)
    ax.fill(angles, values, alpha=0.15, color=color)

ax.set_xticks(angles[:-1])
ax.set_xticklabels(categories, size=9)
ax.set_ylim(0, 1)
ax.set_title("Comparaison des métriques d'équité par groupe", pad=20, fontsize=12)
ax.legend(loc='upper right', bbox_to_anchor=(1.3, 1.1))
plt.tight_layout()
plt.show()

Techniques d’atténuation des biais

Les techniques d’atténuation des biais se classent en trois catégories selon le moment de leur application dans le pipeline d’apprentissage.

Pré-traitement

Les méthodes de pré-traitement agissent sur les données avant l’entraînement du modèle.

Définition 332 (Techniques de pré-traitement)

1. Rééchantillonnage (resampling) : sur-échantillonner le groupe sous-représenté ou sous-échantillonner le groupe sur-représenté pour équilibrer les taux de base.

2. Repondération (reweighting) : attribuer à chaque exemple un poids inversement proportionnel à la fréquence de sa combinaison (groupe, étiquette), de sorte que chaque sous-groupe contribue équitablement à la fonction de coût.

3. Transformation des données : projeter les données dans un espace de représentation où l’attribut sensible n’est plus prédictible, tout en préservant l’information utile pour la tâche cible.

Show code cell source

Hide code cell source

# Technique de repondération
def compute_sample_weights(groups, labels):
    """Calcule des poids d'échantillon pour l'équité."""
    weights = np.ones(len(groups))
    for g in np.unique(groups):
        for y in [0, 1]:
            mask = (groups == g) & (labels == y)
            expected = len(groups) / (len(np.unique(groups)) * 2)
            actual = mask.sum()
            if actual > 0:
                weights[mask] = expected / actual
    return weights

# Entraînement avec repondération
weights_train = compute_sample_weights(g_train, y_train)
model_reweighted = LogisticRegression(random_state=42)
model_reweighted.fit(X_train, y_train, sample_weight=weights_train)
y_pred_rw = model_reweighted.predict(X_test)

print("=== Après repondération ===")
metrics_rw = fairness_metrics(y_test, y_pred_rw, g_test)
print(metrics_rw.round(3))

taux_A_rw = y_pred_rw[g_test == 'A'].mean()
taux_B_rw = y_pred_rw[g_test == 'B'].mean()
ratio_rw = min(taux_A_rw, taux_B_rw) / max(taux_A_rw, taux_B_rw)
print(f"\nRatio d'impact disparate après repondération : {ratio_rw:.3f}")

=== Après repondération ===
        Taux de sélection  TPR (Sensibilité)  FPR (Taux faux positifs)  \
Groupe                                                                   
A                   0.514                1.0                     0.007   
B                   0.223                1.0                     0.012   

        PPV (Précision)  
Groupe                   
A                 0.993  
B                 0.957  

Ratio d'impact disparate après repondération : 0.433

In-processing

Les méthodes in-processing modifient l’algorithme d’apprentissage lui-même pour intégrer des contraintes d’équité directement dans la fonction objectif.

Définition 333 (Apprentissage sous contrainte d’équité)

L’approche par optimisation sous contrainte reformule le problème d’entraînement comme :

\[\min_\theta \; \mathcal{L}(\theta) \quad \text{sous contrainte} \quad \Delta_{\text{fairness}}(\theta) \leq \varepsilon\]

où \(\mathcal{L}\) est la perte habituelle et \(\Delta_{\text{fairness}}\) mesure la violation de la contrainte d’équité choisie (par exemple, l’écart de parité démographique). Le paramètre \(\varepsilon\) contrôle le compromis entre performance et équité.

Le débiaisage adversarial (adversarial debiasing) utilise une architecture à deux têtes :

• Un prédicteur qui maximise la performance sur la tâche cible ;

• Un adversaire qui tente de prédire l’attribut sensible à partir des représentations internes.

L’entraînement conjoint force le prédicteur à produire des représentations dont l’adversaire ne peut extraire l’information sur le groupe, tout en maintenant la performance sur la tâche.

Post-traitement

Les méthodes de post-traitement ajustent les prédictions après l’entraînement du modèle, sans modifier le modèle lui-même.

Définition 334 (Ajustement de seuil)

L”ajustement de seuil (threshold adjustment) consiste à appliquer un seuil de décision différent pour chaque groupe, de façon à égaliser une métrique d’équité choisie. Pour un classifieur produisant un score \(s(\mathbf{x}) \in [0, 1]\) :

\[\begin{split}\hat{Y} = \begin{cases} 1 & \text{si } s(\mathbf{x}) \geq \tau_g \\ 0 & \text{sinon} \end{cases}\end{split}\]

où \(\tau_g\) est le seuil spécifique au groupe \(g\). Les seuils \(\tau_a\) et \(\tau_b\) sont choisis pour satisfaire la contrainte d’équité retenue.

Show code cell source

Hide code cell source

# Post-traitement : ajustement de seuil pour la parité démographique
scores = model.predict_proba(X_test)[:, 1]

def find_threshold_for_rate(scores, target_rate):
    """Trouve le seuil produisant un taux de sélection cible."""
    thresholds = np.linspace(0, 1, 1000)
    for t in thresholds:
        if (scores >= t).mean() <= target_rate:
            return t
    return 0.5

# Taux de sélection cible : moyenne des deux groupes
target = 0.5 * (scores[g_test == 'A'].mean() + scores[g_test == 'B'].mean())

# Un seuil par groupe
seuil_A = find_threshold_for_rate(scores[g_test == 'A'], target + 0.05)
seuil_B = find_threshold_for_rate(scores[g_test == 'B'], target + 0.05)

y_pred_post = np.zeros_like(y_pred)
y_pred_post[g_test == 'A'] = (scores[g_test == 'A'] >= seuil_A).astype(int)
y_pred_post[g_test == 'B'] = (scores[g_test == 'B'] >= seuil_B).astype(int)

print(f"Seuils ajustés : Groupe A = {seuil_A:.3f}, Groupe B = {seuil_B:.3f}")
print()
metrics_post = fairness_metrics(y_test, y_pred_post, g_test)
print("=== Après ajustement de seuil ===")
print(metrics_post.round(3))

Seuils ajustés : Groupe A = 0.925, Groupe B = 0.002

=== Après ajustement de seuil ===
        Taux de sélection  TPR (Sensibilité)  FPR (Taux faux positifs)  \
Groupe                                                                   
A                    0.41              0.804                      0.00   
B                    0.41              1.000                      0.25   

        PPV (Précision)  
Groupe                   
A                  1.00  
B                  0.52  

Show code cell source

Hide code cell source

# Comparaison des trois approches
fig, axes = plt.subplots(1, 3, figsize=(14, 5))
titles = ['Modèle original', 'Repondération', 'Ajustement de seuil']
predictions = [y_pred, y_pred_rw, y_pred_post]

for ax, title, preds in zip(axes, titles, predictions):
    rates = []
    for g in ['A', 'B']:
        mask = g_test == g
        rates.append(preds[mask].mean())
    bars = ax.bar(['Groupe A', 'Groupe B'], rates,
                  color=['#4C72B0', '#DD8452'], width=0.5)
    ax.set_title(title)
    ax.set_ylabel("Taux de sélection")
    ax.set_ylim(0, 1)
    for bar, r in zip(bars, rates):
        ax.text(bar.get_x() + bar.get_width() / 2, r + 0.02,
                f'{r:.1%}', ha='center', fontsize=11)
    # Ligne de parité
    ax.axhline(y=np.mean(rates), color='gray', linestyle='--', alpha=0.5)

plt.suptitle("Taux de sélection par groupe selon la technique d'atténuation",
             fontsize=13, y=1.02)
plt.tight_layout()
plt.show()

Remarque 275

Toute technique d’atténuation implique un compromis entre performance et équité. La repondération et l’ajustement de seuil réduisent la disparité entre groupes, mais au prix d’une potentielle diminution de la précision globale. Ce compromis est inévitable et doit être documenté et discuté avec les parties prenantes. Le choix de la technique et du niveau d’atténuation est, in fine, un choix de politique, pas uniquement un choix technique.

Vie privée

Le défi de l’anonymisation

La protection des données personnelles est un pilier de l’éthique en apprentissage automatique. L”anonymisation — la suppression des identifiants directs (nom, adresse, numéro de sécurité sociale) — est souvent insuffisante.

Définition 335 (\(k\)-anonymat et \(\ell\)-diversité)

Le \(k\)-anonymat exige que chaque combinaison de quasi-identifiants (âge, code postal, genre…) apparaisse dans au moins \(k\) enregistrements du jeu de données :

\[\forall\, \text{combinaison } q \text{ de quasi-identifiants}, \quad |\{i : q_i = q\}| \geq k\]

La \(\ell\)-diversité renforce le \(k\)-anonymat en exigeant que, au sein de chaque groupe de \(k\) enregistrements partageant les mêmes quasi-identifiants, l’attribut sensible prenne au moins \(\ell\) valeurs distinctes « bien représentées ».

Ces approches restent vulnérables aux attaques par composition : en combinant plusieurs jeux de données \(k\)-anonymes, un attaquant peut réidentifier des individus (attaque de Sweeney, 2000).

Confidentialité différentielle

Définition 336 (Confidentialité différentielle (\(\varepsilon\)-DP))

Un mécanisme randomisé \(\mathcal{M}\) satisfait la \(\varepsilon\)-confidentialité différentielle (\(\varepsilon\)-differential privacy) si, pour tous jeux de données voisins \(D\) et \(D'\) (différant d’un seul enregistrement) et pour tout ensemble de sorties \(S\) :

\[P(\mathcal{M}(D) \in S) \leq e^\varepsilon \cdot P(\mathcal{M}(D') \in S)\]

Le paramètre \(\varepsilon > 0\) est le budget de confidentialité (privacy budget) : plus \(\varepsilon\) est petit, plus la garantie de confidentialité est forte. En pratique, \(\varepsilon \in [0.1, 10]\).

Interprétation : la présence ou l’absence d’un individu dans le jeu de données ne modifie que marginalement (facteur \(e^\varepsilon\)) la distribution des sorties du mécanisme. Un observateur ne peut donc pas déterminer si un individu spécifique est dans les données.

Show code cell source

Hide code cell source

# Illustration : mécanisme de Laplace pour la confidentialité différentielle
def laplace_mechanism(true_value, sensitivity, epsilon):
    """Ajoute du bruit de Laplace pour garantir l'epsilon-DP."""
    scale = sensitivity / epsilon
    noise = np.random.laplace(0, scale)
    return true_value + noise

# Exemple : estimation de la moyenne d'un attribut
true_mean = df_biais['score'].mean()
sensitivity = (df_biais['score'].max() - df_biais['score'].min()) / len(df_biais)

epsilons = [0.1, 0.5, 1.0, 2.0, 5.0, 10.0]
n_trials = 500

fig, axes = plt.subplots(1, 2, figsize=(13, 5))

# Distribution des estimations bruitées pour différents epsilon
for eps in [0.1, 1.0, 10.0]:
    estimates = [laplace_mechanism(true_mean, sensitivity, eps)
                 for _ in range(n_trials)]
    axes[0].hist(estimates, bins=40, alpha=0.4, density=True,
                 label=f'$\\varepsilon = {eps}$')
axes[0].axvline(true_mean, color='red', linestyle='--', linewidth=2,
                label='Vraie moyenne')
axes[0].set_xlabel("Estimation bruitée")
axes[0].set_ylabel("Densité")
axes[0].set_title("Mécanisme de Laplace : distribution des estimations")
axes[0].legend()

# Erreur en fonction d'epsilon
errors = []
for eps in epsilons:
    estimates = [laplace_mechanism(true_mean, sensitivity, eps)
                 for _ in range(n_trials)]
    errors.append(np.std(estimates))

axes[1].plot(epsilons, errors, 'o-', color='#4C72B0', linewidth=2, markersize=8)
axes[1].set_xlabel("$\\varepsilon$ (budget de confidentialité)")
axes[1].set_ylabel("Écart-type de l'estimation")
axes[1].set_title("Compromis confidentialité-utilité")
axes[1].set_xscale('log')

plt.tight_layout()
plt.show()

Remarque 276

La confidentialité différentielle illustre un compromis fondamental entre vie privée et utilité. Un \(\varepsilon\) petit offre une protection forte mais dégrade la qualité des résultats ; un \(\varepsilon\) grand préserve l’utilité mais affaiblit les garanties. Dans le contexte de l’apprentissage automatique, le DP-SGD (Differentially Private Stochastic Gradient Descent) permet d’entraîner des modèles avec des garanties de confidentialité différentielle, au prix d’une diminution de la précision.

Apprentissage fédéré

Définition 337 (Apprentissage fédéré)

L”apprentissage fédéré (federated learning) est un paradigme d’entraînement distribué dans lequel les données restent sur les appareils locaux (téléphones, hôpitaux, entreprises) et seuls les gradients ou les mises à jour de paramètres sont échangés avec un serveur central :

1. Le serveur distribue le modèle global \(\theta_t\) à un sous-ensemble de clients.

2. Chaque client \(k\) entraîne le modèle sur ses données locales \(\mathcal{D}_k\) pendant quelques itérations et calcule une mise à jour \(\Delta\theta_k\).

3. Le serveur agrège les mises à jour : \(\theta_{t+1} = \theta_t + \frac{1}{K}\sum_{k=1}^K \Delta\theta_k\).

4. Le processus est répété jusqu’à convergence.

L’apprentissage fédéré ne constitue pas en soi une garantie de confidentialité — les gradients échangés peuvent encore révéler des informations sur les données locales — mais il peut être combiné avec la confidentialité différentielle et le chiffrement homomorphe pour renforcer les protections.

Cadre réglementaire

RGPD (Règlement Général sur la Protection des Données)

Le RGPD, en vigueur depuis mai 2018 dans l’Union européenne, établit plusieurs principes directement pertinents pour l’apprentissage automatique.

Définition 338 (Principes du RGPD applicables au ML)

1. Minimisation des données (art. 5) : ne collecter que les données strictement nécessaires à la finalité déclarée.

2. Limitation de la finalité (art. 5) : les données collectées pour une finalité ne peuvent être réutilisées pour un autre objectif incompatible.

3. Droit à l’explication (art. 22) : toute personne faisant l’objet d’une décision automatisée a le droit d’obtenir une « explication de la logique sous-jacente » et de contester cette décision.

4. Protection des données dès la conception (privacy by design, art. 25) : les mesures de protection doivent être intégrées dès la conception du système, pas ajoutées a posteriori.

5. Analyse d’impact (art. 35) : une analyse d’impact relative à la protection des données (AIPD) est obligatoire pour les traitements présentant un risque élevé.

Règlement européen sur l’IA (AI Act)

Le Règlement européen sur l’intelligence artificielle (AI Act), adopté en 2024, établit une classification des systèmes d’IA selon leur niveau de risque.

Exemple 50 (Classification des risques selon l’AI Act)

1. Risque inacceptable (interdit) : notation sociale (social scoring) par les autorités publiques, reconnaissance faciale en temps réel dans l’espace public (sauf exceptions), manipulation subliminale.

2. Risque élevé : systèmes d’IA utilisés dans le recrutement, l’éducation, la justice, la santé, les infrastructures critiques. Ces systèmes doivent satisfaire des exigences strictes :

   • Évaluation de conformité avant mise sur le marché

   • Système de gestion des risques

   • Gouvernance des données

   • Documentation technique détaillée

   • Transparence et information des utilisateurs

   • Supervision humaine

3. Risque limité : systèmes avec obligations de transparence (par exemple, indiquer qu’un texte est généré par une IA).

4. Risque minimal : la majorité des systèmes d’IA, sans obligation spécifique.

Autres cadres de référence

Plusieurs organisations internationales ont publié des cadres éthiques pour l’IA :

• IEEE : Ethically Aligned Design — principes pour des systèmes autonomes alignés sur les valeurs humaines.

• NIST (États-Unis) : AI Risk Management Framework — cadre de gestion des risques liés à l’IA, structuré autour des fonctions Gouverner, Cartographier, Mesurer et Gérer.

• OCDE : principes de l’IA adoptés en 2019, promouvant une IA inclusive, transparente, robuste et responsable.

• UNESCO : Recommandation sur l’éthique de l’IA (2021), premier instrument normatif mondial sur le sujet.

Remarque 277

Le cadre réglementaire évolue rapidement. Le praticien en apprentissage automatique doit maintenir une veille active sur ces évolutions, car elles déterminent les obligations concrètes applicables à ses systèmes. La conformité réglementaire n’est pas un obstacle à l’innovation : elle est un facteur de confiance et de pérennité.

IA responsable en pratique

Fiches de modèle et fiches de données

Définition 339 (Fiche de modèle (Model Card))

Une fiche de modèle (model card), proposée par Mitchell et al. (2019), est un document standardisé accompagnant un modèle de machine learning. Elle doit contenir au minimum :

• Description du modèle : architecture, algorithme, version, date d’entraînement.

• Usage prévu : cas d’utilisation primaires, utilisateurs cibles, usages hors périmètre.

• Données d’entraînement : source, taille, distribution, processus de collecte et de nettoyage.

• Métriques de performance : résultats globaux et ventilés par sous-groupe pertinent.

• Considérations éthiques : biais connus, limitations, risques identifiés.

• Recommandations : précautions d’emploi, conditions de monitoring.

Définition 340 (Fiche de données (Datasheet))

Une fiche de données (datasheet for datasets), proposée par Gebru et al. (2021), documente un jeu de données selon les axes suivants :

• Motivation : pourquoi le jeu de données a été créé, par qui et pour qui.

• Composition : nombre d’instances, types de données, attributs sensibles, étiquettes.

• Collecte : méthodologie, période, consentement, compensation des participants.

• Prétraitement : nettoyage, filtrage, anonymisation.

• Utilisations : tâches prévues, utilisations à éviter.

• Distribution : licence, restrictions d’accès.

• Maintenance : responsable, fréquence de mise à jour, mécanisme de correction.

Audit de biais

L’audit de biais est un processus systématique d’évaluation d’un modèle sous l’angle de l’équité. Il doit être mené avant le déploiement et répété régulièrement.

Show code cell source

Hide code cell source

def bias_audit(y_true, y_pred, y_scores, groups, group_names=('A', 'B')):
    """Réalise un audit de biais complet."""
    print("=" * 60)
    print("         RAPPORT D'AUDIT DE BIAIS")
    print("=" * 60)

    # 1. Métriques de performance globale
    print("\n--- Performance globale ---")
    print(f"Exactitude : {accuracy_score(y_true, y_pred):.3f}")

    # 2. Performance par groupe
    print("\n--- Performance par groupe ---")
    for g in group_names:
        mask = groups == g
        acc = accuracy_score(y_true[mask], y_pred[mask])
        print(f"  Groupe {g} : exactitude = {acc:.3f}, "
              f"n = {mask.sum()}")

    # 3. Métriques d'équité
    print("\n--- Métriques d'équité ---")
    metrics = fairness_metrics(y_true, y_pred, groups, group_names)
    print(metrics.round(3))

    # 4. Impact disparate
    rates = [y_pred[groups == g].mean() for g in group_names]
    di_ratio = min(rates) / max(rates) if max(rates) > 0 else 0
    print(f"\n--- Impact disparate ---")
    print(f"  Ratio : {di_ratio:.3f}")
    print(f"  Règle des 80 % : {'CONFORME' if di_ratio >= 0.8 else 'NON CONFORME'}")

    # 5. Calibration par groupe
    print("\n--- Calibration par groupe ---")
    for g in group_names:
        mask = groups == g
        if y_scores is not None:
            mean_score = y_scores[mask].mean()
            mean_outcome = y_true[mask].mean()
            print(f"  Groupe {g} : score moyen = {mean_score:.3f}, "
                  f"taux positif réel = {mean_outcome:.3f}")

    print("\n" + "=" * 60)
    return metrics

# Exécution de l'audit
_ = bias_audit(y_test, y_pred, scores, g_test)

============================================================
         RAPPORT D'AUDIT DE BIAIS
============================================================

--- Performance globale ---
Exactitude : 1.000

--- Performance par groupe ---
  Groupe A : exactitude = 1.000, n = 290
  Groupe B : exactitude = 1.000, n = 310

--- Métriques d'équité ---
        Taux de sélection  TPR (Sensibilité)  FPR (Taux faux positifs)  \
Groupe                                                                   
A                   0.510                1.0                       0.0   
B                   0.213                1.0                       0.0   

        PPV (Précision)  
Groupe                   
A                   1.0  
B                   1.0  

--- Impact disparate ---
  Ratio : 0.417
  Règle des 80 % : NON CONFORME

--- Calibration par groupe ---
  Groupe A : score moyen = 0.504, taux positif réel = 0.510
  Groupe B : score moyen = 0.217, taux positif réel = 0.213

============================================================

Évaluation d’impact

Exemple 51 (Liste de vérification pour le déploiement responsable)

Avant de déployer un modèle d’apprentissage automatique, le praticien devrait vérifier les points suivants :

Données

• Les sources de données sont documentées et traçables

• Les biais potentiels dans les données ont été identifiés et documentés

• Le consentement pour l’utilisation des données a été vérifié

• Les données sensibles sont protégées (anonymisation, chiffrement)

Modèle

• La fiche de modèle (model card) est rédigée et à jour

• Les performances sont évaluées par sous-groupe pertinent

• Un audit de biais a été réalisé

• Le modèle est interprétable ou accompagné d’explications

Déploiement

• Un mécanisme de recours est prévu pour les personnes affectées

• Un système de monitoring détecte les dérives (drift)

• Les boucles de rétroaction sont identifiées et surveillées

• Un plan de retrait ou de correction est défini

Conformité

• La conformité au RGPD est vérifiée (analyse d’impact si nécessaire)

• La classification de risque selon l’AI Act est déterminée

• Les obligations de transparence sont satisfaites

Show code cell source

Hide code cell source

# Visualisation : tableau de bord synthétique d'audit
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# 1. Taux de sélection par groupe et par méthode
methods = ['Original', 'Repondéré', 'Post-traité']
all_preds = [y_pred, y_pred_rw, y_pred_post]
rates_A = [p[g_test == 'A'].mean() for p in all_preds]
rates_B = [p[g_test == 'B'].mean() for p in all_preds]

x_pos = np.arange(len(methods))
w = 0.3
axes[0, 0].bar(x_pos - w/2, rates_A, w, label='Groupe A', color='#4C72B0')
axes[0, 0].bar(x_pos + w/2, rates_B, w, label='Groupe B', color='#DD8452')
axes[0, 0].set_xticks(x_pos)
axes[0, 0].set_xticklabels(methods)
axes[0, 0].set_ylabel("Taux de sélection")
axes[0, 0].set_title("Taux de sélection par méthode")
axes[0, 0].legend()
axes[0, 0].set_ylim(0, 1)

# 2. Impact disparate par méthode
di_ratios = [min(a, b) / max(a, b) if max(a, b) > 0 else 0
             for a, b in zip(rates_A, rates_B)]
colors_di = ['#E24A33' if r < 0.8 else '#55A868' for r in di_ratios]
axes[0, 1].bar(methods, di_ratios, color=colors_di, width=0.5)
axes[0, 1].axhline(y=0.8, color='red', linestyle='--', label='Seuil 80 %')
axes[0, 1].set_ylabel("Ratio d'impact disparate")
axes[0, 1].set_title("Conformité à la règle des 80 %")
axes[0, 1].legend()
axes[0, 1].set_ylim(0, 1.1)

# 3. Exactitude par groupe et par méthode
acc_A = [accuracy_score(y_test[g_test == 'A'], p[g_test == 'A'])
         for p in all_preds]
acc_B = [accuracy_score(y_test[g_test == 'B'], p[g_test == 'B'])
         for p in all_preds]
axes[1, 0].bar(x_pos - w/2, acc_A, w, label='Groupe A', color='#4C72B0')
axes[1, 0].bar(x_pos + w/2, acc_B, w, label='Groupe B', color='#DD8452')
axes[1, 0].set_xticks(x_pos)
axes[1, 0].set_xticklabels(methods)
axes[1, 0].set_ylabel("Exactitude")
axes[1, 0].set_title("Exactitude par groupe et par méthode")
axes[1, 0].legend()
axes[1, 0].set_ylim(0, 1)

# 4. Compromis équité-performance
global_acc = [accuracy_score(y_test, p) for p in all_preds]
axes[1, 1].scatter(di_ratios, global_acc, s=150, c=['#E24A33', '#DD8452', '#55A868'],
                   zorder=5, edgecolors='black', linewidths=1.5)
for i, method in enumerate(methods):
    axes[1, 1].annotate(method, (di_ratios[i], global_acc[i]),
                        textcoords="offset points", xytext=(10, 5), fontsize=10)
axes[1, 1].axvline(x=0.8, color='red', linestyle='--', alpha=0.5)
axes[1, 1].set_xlabel("Ratio d'impact disparate (équité)")
axes[1, 1].set_ylabel("Exactitude globale (performance)")
axes[1, 1].set_title("Compromis équité-performance")
axes[1, 1].set_xlim(0, 1.1)

plt.suptitle("Tableau de bord d'audit de biais", fontsize=14, y=1.02)
plt.tight_layout()
plt.show()

Remarque 278

L’audit de biais n’est pas un événement ponctuel mais un processus continu. Les distributions de données évoluent dans le temps (data drift), les populations servies changent, et les boucles de rétroaction peuvent dégrader progressivement l’équité du système. Un monitoring en production, avec des alertes automatiques lorsque les métriques d’équité franchissent des seuils prédéfinis, est indispensable.

Résumé

Ce chapitre a abordé les enjeux éthiques fondamentaux de l’apprentissage automatique, qui constituent le cadre indispensable de toute pratique responsable.

1. Les controverses (COMPAS, reconnaissance faciale, recrutement automatisé) montrent que les biais algorithmiques ont des conséquences concrètes sur la vie des personnes. Le praticien porte une responsabilité directe dans les choix qui les produisent.

2. Les biais dans les données — historiques, de représentation, de mesure, de sélection, d’étiquetage — sont omniprésents et se transmettent mécaniquement aux modèles. Leur identification exige une analyse critique des données avant tout entraînement.

3. Les biais dans les modèles ne se limitent pas à refléter les données : la discrimination par proxy et les boucles de rétroaction peuvent les amplifier considérablement.

4. L”équité algorithmique repose sur des définitions formelles (parité démographique, égalité des chances, parité prédictive) dont le théorème d’impossibilité montre qu’elles ne peuvent être satisfaites simultanément. Le choix d’un critère d’équité est un choix de valeurs.

5. Les techniques d’atténuation (pré-traitement, in-processing, post-traitement) permettent de réduire les disparités, au prix d’un compromis explicite entre performance et équité.

6. La vie privée est protégée par des outils formels comme la confidentialité différentielle (\(\varepsilon\)-DP) et des paradigmes comme l’apprentissage fédéré, avec un compromis entre protection et utilité.

7. Le cadre réglementaire (RGPD, AI Act) impose des obligations concrètes que le praticien doit connaître et respecter, notamment le droit à l’explication et la classification des risques.

8. L”IA responsable en pratique passe par des fiches de modèle, des fiches de données, des audits de biais systématiques et des listes de vérification avant déploiement.

Remarque 279

Ce chapitre clôt notre parcours des données à l’intelligence. Depuis les premières lignes de code pour charger un jeu de données (chapitre 1) jusqu’aux questions d’équité et de responsabilité qui entourent le déploiement d’un modèle, nous avons traversé l’ensemble du spectre de l’apprentissage automatique : les fondations (exploration, prétraitement), l’apprentissage supervisé (régression, classification, SVM, arbres, ensembles), l’apprentissage non supervisé (réduction de dimensionnalité, clustering, détection d’anomalies), les réseaux de neurones (perceptron, CNN, RNN, Transformers), et enfin les enjeux de mise en production (interprétabilité, MLOps, éthique).

S’il y a une leçon à retenir de ce dernier chapitre, c’est que la maîtrise technique — aussi poussée soit-elle — ne suffit pas. Un modèle performant mais biaisé, opaque ou attentatoire à la vie privée n’est pas un bon modèle. L’intelligence artificielle n’est qu’un outil, et comme tout outil puissant, elle requiert discernement, humilité et vigilance de la part de ceux qui la conçoivent. Les données sont le matériau brut ; l’intelligence — la vraie — reste humaine.