Intermédiaire2 joursEU AI Act 2026

AI Act 2026 : Guide de Mise en Conformité Pratique

Dépassez les checklists de conformité. Construisez de véritables analyses de risques, modèles AIPD, journaux d'audit et systèmes de détection de dérive pour vos systèmes IA déployés dans l'UE — avec du code fonctionnel pour chaque livrable.

1 490 €Réserver une session

Cette formation est éligible au financement OPCO. Prix de référence 1 490 €.

Ce que vous allez construire

✓Classifier n'importe quel système IA (IA générative, RAG, agents vocaux) selon l'AI Act UE avec des preuves documentées

✓Compléter une AIPD pour les systèmes IA — modèles pré-remplis pour trois scénarios

✓Générer des fiches système et la documentation technique satisfaisant l'Annexe IV

✓Exécuter des suites de détection automatisée des biais et de surveillance de la dérive en production

✓Implémenter une journalisation d'audit conforme à l'Article 12 avec protection des données personnelles

✓Produire une analyse de risques complète pour un système RAG avec des scores de risque réels

Pour qui

→Responsables conformité et DPD préparant les obligations des systèmes à haut risque d'août 2026
→Développeurs construisant des systèmes IA déployés auprès d'utilisateurs UE
→Équipes juridiques conseillant les organisations sur la mise en conformité AI Act
→CTO et chefs de produit lançant des fonctionnalités IA potentiellement à haut risque

Prérequis

·Compréhension de base du RGPD (personnes concernées, base juridique, sous-traitant vs. responsable)
·Familiarité avec au moins un pattern de déploiement IA (chatbot, RAG, modèle de scoring)
·Bases Python pour exécuter les exemples de code (vous n'avez pas besoin d'être développeur)

Modules

Taxonomie des Risques : Classifier Correctement Vos Systèmes IA

2h30

Appliquez le modèle à quatre niveaux de l'AI Act à des architectures réelles — IA générative, pipelines RAG, agents vocaux — et produisez une classification défendable avec les preuves documentées.

Taxonomie des Risques : Classifier Correctement Vos Systèmes IA

À la fin de ce module, vous saurez : classifier correctement un chatbot IA générative, un pipeline RAG et un agent vocal selon l'AI Act ; identifier quelle classification déclenche les obligations de haut risque ; et produire un document de classification avec preuves qui résistera à un audit.

Le modèle de risque de l'AI Act est fondé sur le risque, non sur la technologie. Le même modèle sous-jacent — par exemple un appel à l'API Claude — peut être à risque minimal dans un contexte (résumer des documents internes) et à haut risque dans un autre (noter des candidats à l'embauche). Les erreurs de classification dans les deux sens sont coûteuses : sous-classifier expose à des amendes jusqu'à 15 millions d'euros ou 3 % du chiffre d'affaires mondial ; sur-classifier impose une charge de conformité inutile aux équipes. La décision de classification doit être documentée, révisée annuellement et défendable devant une autorité de surveillance du marché.

Les Quatre Niveaux de Risque avec Exemples Réels

Risque inacceptable (INTERDIT depuis février 2025) : Identification biométrique à distance en temps réel dans les espaces publics sans autorisation judiciaire ; systèmes de notation sociale attribuant aux citoyens un score de réputation affectant leur accès aux services ; IA exploitant des vulnérabilités psychologiques pour manipuler les comportements. Exemple interdit : une plateforme d'analyse retail utilisant la reconnaissance faciale pour confronter les clients à une base de données policière et alerter les agents de sécurité en temps réel.
Haut risque (évaluation de conformité complète requise avant août 2026) : Tri automatisé de CV et classement de candidats (Annexe III point 4) ; scoring de crédit automatisé utilisé dans les décisions de prêt (Annexe III point 5b) ; logiciels dispositifs médicaux influençant des décisions diagnostiques ou thérapeutiques (Annexe III point 6) ; IA utilisée dans la gestion d'infrastructures critiques — réseaux électriques, systèmes d'eau (Annexe III point 2). Exemple haut risque : un SaaS de recrutement qui prend des CV et produit une shortlist classée, même si un humain prend la décision finale d'embauche.
Risque limité (obligations de transparence uniquement) : Les chatbots interagissant avec des personnes physiques doivent divulguer qu'ils sont une IA. Les deepfakes doivent être étiquetés. Les textes générés par IA dans le journalisme ou le marketing doivent être divulgués. Exemple : un chatbot de support client basé sur Claude doit indiquer aux utilisateurs qu'ils parlent à une IA — mais le système lui-même ne nécessite pas d'évaluation de conformité.
Risque minimal (aucune obligation obligatoire) : Moteurs de recommandation de produits, filtres anti-spam, recherche IA, traduction de contenu, correction grammaticale. Exemple : un outil interne de résumé de documents utilisant un pipeline RAG sur la base de connaissances de l'entreprise — risque minimal s'il ne prend pas de décisions conséquentes concernant des individus.

Classification des Systèmes IA Générative (GPAI)

L'AI Act ajoute une filière spécifique pour les modèles d'IA à usage général (GPAI) — des modèles entraînés sur des données larges et utilisables pour de nombreuses tâches. Si vous déployez un modèle GPAI (Claude, GPT-4, Llama 3) ou construisez au-dessus, la classification fonctionne différemment : le modèle lui-même relève des obligations GPAI (responsabilité du fournisseur), mais votre couche application relève du modèle à quatre niveaux. Un modèle GPAI à risque systémique (puissance de calcul d'entraînement supérieure à 10^25 FLOPs) comporte des exigences supplémentaires : tests adversariaux, signalement d'incidents et divulgation de consommation énergétique.

Arbre de Décision pour la Classification d'un Pipeline RAG

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
# Outil de classification des risques AI Act
# Exécutez ce script sur votre spécification système pour obtenir un rapport de classification
# Couvre les patterns de déploiement les plus courants en IA d'entreprise (2026)

from dataclasses import dataclass
from typing import Optional
import json

@dataclass
class SpecificationSystemeIA:
    nom: str
    description: str
    prend_decisions_sur_individus: bool
    domaine_decision: Optional[str]  # "emploi", "credit", "sante", "education", "justice"
    decision_automatisee: bool
    utilise_donnees_biometriques: bool
    deploye_infrastructure_critique: bool
    base_gpai: bool
    fournisseur_gpai: Optional[str]
    type_sortie: str  # "recommandation", "score", "decision", "contenu", "transcription"
    utilisation_sortie: str

DOMAINES_HAUT_RISQUE = {
    "emploi": "Annexe III §4 — Décisions de recrutement, promotion ou licenciement",
    "credit": "Annexe III §5b — Évaluation de solvabilité",
    "sante": "Annexe III §6 — Dispositif médical ou aide à la décision clinique",
    "education": "Annexe III §3 — Notation d'examens ou décisions d'admission",
    "justice": "Annexe III §8 — Décisions judiciaires ou résolution de litiges",
    "migration": "Annexe III §7 — Traitement des demandes d'asile ou de visa",
}

def classifier_systeme_ia(spec: SpecificationSystemeIA) -> dict:
    preuves = []
    niveau_risque = "minimal"
    obligations = []

    # Étape 1 : Vérifier les pratiques interdites
    if spec.utilise_donnees_biometriques and "espace public" in spec.description.lower():
        return {
            "niveau_risque": "inacceptable",
            "interdit": True,
            "raison": "Identification biométrique à distance en temps réel dans les espaces publics — interdit par l'Article 5(1)(d)",
            "action": "Le système ne doit pas être déployé. Reconcevoir ou abandonner.",
        }

    # Étape 2 : Vérifier les domaines à haut risque
    if spec.prend_decisions_sur_individus and spec.domaine_decision in DOMAINES_HAUT_RISQUE:
        niveau_risque = "haut"
        ref = DOMAINES_HAUT_RISQUE[spec.domaine_decision]
        preuves.append(f"Domaine à haut risque : {spec.domaine_decision} — {ref}")
        obligations += [
            "Réaliser une évaluation de conformité avant le déploiement (Article 43)",
            "Enregistrer le système dans la base de données AI Act de l'UE avant août 2026 (Article 71)",
            "Mettre en place un mécanisme de supervision humaine — réviseur nommé avec autorité de substitution (Article 14)",
            "Journaliser toutes les paires entrée/sortie avec horodatage et contexte utilisateur (Article 12)",
            "Produire la documentation technique : fiche système, provenance des données d'entraînement, métriques de performance par groupe démographique (Article 11)",
            "Réaliser une AIPD en vertu du RGPD si des données personnelles sont traitées (Article 35 RGPD)",
        ]

    # Étape 3 : Obligations de transparence pour les chatbots
    if "chatbot" in spec.description.lower() or "conversation" in spec.utilisation_sortie.lower():
        if niveau_risque == "minimal":
            niveau_risque = "limité"
        obligations.append(
            "Divulguer la nature IA aux utilisateurs au début de l'interaction (Article 50(1)) — le chatbot doit s'identifier comme IA"
        )
        preuves.append("Système IA conversationnel — obligation de transparence Article 50 applicable")

    return {
        "nom_systeme": spec.nom,
        "niveau_risque": niveau_risque,
        "preuves": preuves,
        "obligations": obligations,
        "date_classification": "2026-05-08",
        "revision_prevue": "2027-05-08",
    }

# Exemple : Pipeline RAG pour requêtes RH internes
rag_rh = SpecificationSystemeIA(
    nom="Assistant RAG Politique RH",
    description="Chatbot interne qui répond aux questions des employés sur les politiques RH via un pipeline RAG",
    prend_decisions_sur_individus=False,
    domaine_decision=None,
    decision_automatisee=False,
    utilise_donnees_biometriques=False,
    deploye_infrastructure_critique=False,
    base_gpai=True,
    fournisseur_gpai="Anthropic Claude",
    type_sortie="recommandation",
    utilisation_sortie="Questions en libre-service sur les politiques. Aucune décision conséquente prise par le système.",
)

resultat = classifier_systeme_ia(rag_rh)
print(json.dumps(resultat, indent=2, ensure_ascii=False))

Agents vocaux — attention particulière : un agent vocal qui contacte des clients par téléphone pour proposer une restructuration de crédit est à haut risque (domaine crédit, sortie automatisée). Un agent vocal qui répond aux appels FAQ d'une entreprise logicielle est à risque limité (obligation de transparence chatbot uniquement). La différence est le domaine d'application et l'impact sur la personne — pas la technologie.

🛠️ Exercice 1 : Workbench de Classification AI Act

Exécutez ce code sur trois scénarios réels préconfigurés, puis ajoutez votre propre système en Scénario 4. Le classificateur reproduit la logique utilisée par les équipes conformité lors des audits AI Act réels. Observez comment un seul paramètre modifie le niveau de risque — et les obligations qui en découlent.

Exercice pratique

Exécutez le code et examinez chaque classification. Puis : (1) Scénario 1 — passez `utilise_biometrie=False` : le risque reste-t-il élevé ? Pourquoi ? (2) Scénario 2 — passez `domaine_decision` à `None` : comptez combien d'obligations disparaissent. (3) Ajoutez votre propre système réel ou hypothétique en Scénario 4 et justifiez votre classification par écrit.

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
# Workbench de Classification AI Act
# Exécutez tel quel pour classifier 3 scénarios. Ajoutez votre propre système en Scénario 4.
import json

DOMAINES_HAUT_RISQUE = {
    "emploi", "credit", "sante", "education",
    "forces_de_lordre", "migration", "justice"
}

def classifier(nom, description, decisions_sur_individus,
               domaine_decision, utilise_biometrie, type_sortie, chatbot=False):
    risque = "minimal"
    obligations = []
    preuves = []

    # Vérifier pratiques interdites (Article 5)
    if utilise_biometrie and "espace public" in description.lower() and "forces de l" in description.lower():
        return {"systeme": nom, "risque": "INTERDIT",
                "raison": "Article 5(1)(d) — identification biométrique temps réel dans espaces publics à fins répressives"}

    # Vérifier domaines haut risque (Annexe III)
    if decisions_sur_individus and domaine_decision in DOMAINES_HAUT_RISQUE:
        risque = "eleve"
        preuves.append(f"Annexe III — domaine : {domaine_decision}")
        obligations += [
            "Évaluation de conformité avant déploiement (Article 43)",
            "Enregistrement base de données UE avant août 2026 (Article 71)",
            "Réviseur humain nommé avec autorité de substitution (Article 14)",
            "Journalisation complète : entrées, sorties, horodatages (Article 12)",
            "Documentation technique selon Annexe IV (Article 11)",
            "Plan de surveillance post-commercialisation trimestriel (Article 72)",
        ]

    # Systèmes biométriques hors forces de l'ordre — haut risque Annexe III §1
    if utilise_biometrie and risque != "eleve":
        risque = "eleve"
        preuves.append("Annexe III §1 — système de catégorisation ou d'identification biométrique")
        obligations += ["Évaluation de conformité (Article 43)", "AIPD au titre Article 35 RGPD"]

    # Obligation de transparence chatbot (Article 50)
    if chatbot or "chatbot" in description.lower():
        if risque == "minimal":
            risque = "limite"
        obligations.append("Divulguer la nature IA dès le début de l'interaction (Article 50(1))")
        preuves.append("IA conversationnelle — obligation de transparence Article 50")

    return {"systeme": nom, "risque": risque, "preuves": preuves, "obligations": obligations}

# ── Scénario 1 : Reconnaissance faciale pour le pointage des salariés ─────────
s1 = classifier(
    nom="Système de Pointage Biométrique",
    description="Les salariés scannent leur visage pour pointer. Aucun usage forces de l'ordre.",
    decisions_sur_individus=True,
    domaine_decision="emploi",
    utilise_biometrie=True,   # TODO : changez en False — le risque reste-t-il élevé ?
    type_sortie="decision",
)

# ── Scénario 2 : IA de pré-sélection crédit pour demandes hypothécaires ───────
s2 = classifier(
    nom="IA de Pré-qualification Hypothécaire",
    description="Analyse revenus, dettes et dépenses pour pré-qualifier les demandeurs.",
    decisions_sur_individus=True,
    domaine_decision="credit",   # TODO : changez en None — combien d'obligations disparaissent ?
    utilise_biometrie=False,
    type_sortie="score",
)

# ── Scénario 3 : Chatbot de résumé de documents internes ──────────────────────
s3 = classifier(
    nom="Résumeur de Documents Juridiques",
    description="Chatbot interne résumant des contrats pour les juristes. Pas de décisions RH/crédit.",
    decisions_sur_individus=False,
    domaine_decision=None,
    utilise_biometrie=False,
    type_sortie="resume",
    chatbot=True,   # TODO : passez à False — le niveau de risque change-t-il ?
)

# ── Scénario 4 : VOTRE SYSTÈME — complétez les paramètres ────────────────────
s4 = classifier(
    nom="NOM DE VOTRE SYSTÈME",                        # TODO : nom du système
    description="Décrivez ce que fait le système",     # TODO : incluez le contexte de déploiement
    decisions_sur_individus=True,                       # TODO : affecte-t-il des individus ?
    domaine_decision="emploi",                          # TODO : emploi/credit/sante/education/None
    utilise_biometrie=False,                            # TODO : visage, empreinte, voix ?
    type_sortie="score",                                # TODO : recommendation/score/decision/contenu
    chatbot=False,
)

for scenario in [s1, s2, s3, s4]:
    print(json.dumps(scenario, indent=2, ensure_ascii=False))
    print("---")

🛠️ Exercice 2 : Générez Votre Documentation Technique Article 11

Les systèmes IA à haut risque doivent produire une documentation technique avant le premier déploiement en production. Les autorités de surveillance du marché demandent ce document lors des audits. Complétez les champs ci-dessous pour un outil de filtrage de CV réel ou hypothétique.

Exercice pratique

Complétez tous les champs TODO pour un outil de filtrage de CV réel ou hypothétique. Portez une attention particulière aux métriques §4 — elles doivent être ventilées par groupe démographique. Une fois terminé, comptez combien de champs ont nécessité des recherches : ces champs sont vos angles morts de conformité.

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
# Générateur de Documentation Technique Article 11 / Annexe IV
# Complétez les champs TODO pour votre système IA à haut risque.
from datetime import date, timedelta

systeme = {
    # ── Identification ────────────────────────────────────────────────────────
    "nom": "TODO : Nom de votre système IA",
    "version": "1.0.0",
    "finalite_prevue": "TODO : Quelles décisions ce système appuie-t-il ? Qui sont les individus concernés ?",
    "organisation_deploiement": "TODO : Nom de votre entreprise",
    "reviseur_classification": "TODO : Prénom Nom (DPO ou Responsable Conformité)",
    "date_deploiement": str(date.today()),

    # ── Annexe IV §1 — Logique du système ────────────────────────────────────
    "logique_systeme": "TODO : Type de modèle, variables d'entrée, format de sortie en 2-3 phrases",

    # ── Annexe IV §2 — Données d'entraînement ────────────────────────────────
    "donnees_entrainement": {
        "source": "TODO : Provenance des données (ex. CV historiques 2018-2023)",
        "volume": "TODO : Nombre d'enregistrements (ex. 450 000 paires CV-résultat anonymisées)",
        "couverture_demographique": "TODO : Quels groupes sont représentés ? Lacunes connues ?",
        "date_coupure": "TODO : AAAA-MM-JJ",
        "evaluation_biais": "TODO : Des tests de biais ont-ils été effectués ? Par qui ? Résultats clés ?",
    },

    # ── Annexe IV §4 — Métriques de performance (OBLIGATOIREMENT ventilées) ──
    "performance": {
        "precision_globale": "TODO : ex. 89% — mesurée sur jeu de test",
        "taux_faux_positifs": "TODO : Taux auquel des candidats non qualifiés passent incorrectement",
        "taux_faux_negatifs": "TODO : Taux auquel des candidats qualifiés sont incorrectement rejetés",
        "precision_par_genre": {"masculin": "TODO", "feminin": "TODO", "non_binaire": "TODO"},
        "precision_par_age": {"18_30": "TODO", "31_50": "TODO", "51_plus": "TODO"},
        "ecart_demographique_max": "TODO : Plus grand écart de précision entre groupes (ex. 4,2 pp H/F)",
    },

    # ── Annexe IV §5 — Supervision humaine ───────────────────────────────────
    "supervision_humaine": {
        "nom_reviseur": "TODO : Prénom Nom",
        "role_reviseur": "TODO : ex. Responsable RH Senior",
        "procedure_substitution": "TODO : Comment le réviseur peut-il annuler une décision IA ?",
        "frequence_revision": "TODO : Chaque décision / Lot quotidien / Échantillon hebdomadaire 10%",
        "chemin_escalade": "TODO : Qui est notifié si le réviseur conteste >20% des décisions ?",
    },

    # ── Annexe IV §6 — Surveillance post-commercialisation ───────────────────
    "surveillance": {
        "cadence_revision": "Trimestrielle",
        "methode_detection_derive": "TODO : Comment détecterez-vous la dégradation des performances ?",
        "seuil_escalade": "TODO : À quelle baisse de précision suspendez-vous le système ?",
        "prochaine_revision": str(date.today() + timedelta(days=90)),
    },
}

# ── Générer l'outline de documentation ───────────────────────────────────────
SEPARATEUR = "-" * 55
print(f"DOCUMENTATION TECHNIQUE ANNEXE IV — {systeme['nom'].upper()}")
print(f"Version {systeme['version']} | Généré : {date.today()}")
print(f"Réviseur classification : {systeme['reviseur_classification']}")
print()

sections = [
    ("§1 Description Générale", [
        ("Nom du système", systeme["nom"]),
        ("Finalité prévue", systeme["finalite_prevue"]),
        ("Organisation", systeme["organisation_deploiement"]),
        ("Logique système", systeme["logique_systeme"]),
    ]),
    ("§2 Données d'Entraînement", [
        ("Source", systeme["donnees_entrainement"]["source"]),
        ("Volume", systeme["donnees_entrainement"]["volume"]),
        ("Couverture démographique", systeme["donnees_entrainement"]["couverture_demographique"]),
        ("Date de coupure", systeme["donnees_entrainement"]["date_coupure"]),
        ("Évaluation biais", systeme["donnees_entrainement"]["evaluation_biais"]),
    ]),
    ("§4 Performance (Ventilée par Groupe)", [
        ("Précision globale", systeme["performance"]["precision_globale"]),
        ("Taux faux positifs", systeme["performance"]["taux_faux_positifs"]),
        ("Taux faux négatifs", systeme["performance"]["taux_faux_negatifs"]),
        ("Par genre", str(systeme["performance"]["precision_par_genre"])),
        ("Par groupe d'âge", str(systeme["performance"]["precision_par_age"])),
        ("Écart démographique max.", systeme["performance"]["ecart_demographique_max"]),
    ]),
    ("§5 Supervision Humaine", [
        ("Réviseur nommé", systeme["supervision_humaine"]["nom_reviseur"]),
        ("Rôle", systeme["supervision_humaine"]["role_reviseur"]),
        ("Procédure de substitution", systeme["supervision_humaine"]["procedure_substitution"]),
        ("Fréquence de révision", systeme["supervision_humaine"]["frequence_revision"]),
        ("Chemin d'escalade", systeme["supervision_humaine"]["chemin_escalade"]),
    ]),
    ("§6 Surveillance Post-Commercialisation", [
        ("Cadence de révision", systeme["surveillance"]["cadence_revision"]),
        ("Détection de dérive", systeme["surveillance"]["methode_detection_derive"]),
        ("Seuil d'escalade", systeme["surveillance"]["seuil_escalade"]),
        ("Prochaine révision", systeme["surveillance"]["prochaine_revision"]),
    ]),
]

toutes_valeurs = []
for titre, items in sections:
    print(SEPARATEUR)
    print(f"  {titre}")
    print(SEPARATEUR)
    for label, valeur in items:
        toutes_valeurs.append(str(valeur))
        print(f"  {label:<35} {valeur}")
    print()

# Vérification de complétude
todos = sum(1 for v in toutes_valeurs if "TODO" in v)
if todos == 0:
    print("SUCCÈS — Tous les champs sont remplis. Soumettez au DPO pour révision avant déploiement.")
else:
    print(f"ATTENTION — {todos} champ(s) encore marqués TODO. Ne soumettez pas tant que le dossier est incomplet.")
    print("Les autorités de surveillance du marché rejettent les dossiers techniques incomplets.")

Quiz disponible

Terminez la lecture de ce module puis validez vos connaissances avec le quiz.

Modèles AIPD : Pré-remplis pour Trois Scénarios Courants

Rédigez des Analyses d'Impact sur la Protection des Données conformes pour les trois patterns de déploiement IA qui en nécessitent le plus souvent une : pipelines RAG traitant des données personnelles, agents vocaux enregistrant des conversations, et systèmes de notation automatisée.

Modèles AIPD : Pré-remplis pour Trois Scénarios Courants

Une AIPD est obligatoire en vertu de l'Article 35 RGPD dès que le traitement IA est 'susceptible d'engendrer un risque élevé pour les droits et libertés des personnes physiques.' Pour les systèmes IA, la CNIL et les autorités équivalentes considèrent trois déclencheurs automatiques : (1) surveillance systématique d'individus à grande échelle, (2) traitement de catégories particulières de données (santé, biométrique, politique), (3) prise de décision automatisée avec effets juridiques ou similaires. Si votre système IA satisfait l'un de ces critères, une AIPD est requise avant de traiter un seul enregistrement en production.

AIPD Scénario 1 — Pipeline RAG Traitant des Données Personnelles d'Employés

Json
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
{
  "reference_aipd": "AIPD-2026-RAG-001",
  "version": "1.0",
  "date_creation": "2026-05-08",
  "date_revision": "2027-05-08",
  "responsable_traitement": "Acme Corp SA",
  "dpd_consulte": true,
  "nom_dpd": "Marie Lefebvre",
  "date_consultation_dpd": "2026-05-01",

  "section_1_description": {
    "nom_systeme": "Assistant RAG Avantages Employés",
    "finalite": "Répondre aux questions des employés sur les avantages, droits à congés et politiques de l'entreprise via un pipeline RAG sur les documents RH. Réduire la charge de l'équipe RH de 40% sur les requêtes FAQ.",
    "activites_traitement": [
      "Les requêtes des employés sont envoyées au système RAG (texte libre, peut contenir des données personnelles)",
      "Les requêtes sont vectorisées et recherchées dans un vector store de documents RH",
      "Contexte récupéré et requête envoyés à l'API Claude (Anthropic, sous-traitant US) pour générer la réponse",
      "Requête + réponse journalisées pour le contrôle qualité (rétention 30 jours)",
      "Statistiques d'utilisation anonymisées conservées indéfiniment pour l'amélioration du système"
    ],
    "categories_donnees": [
      "Nom de l'employé (déduit du token d'authentification, non stocké dans la requête)",
      "Contenu de la requête (peut contenir des informations sensibles : conditions de santé, situations familiales, discussions salariales)",
      "Identifiant employé (pour le journal d'audit)",
      "Horodatage et identifiant de session"
    ],
    "categories_particulieres": "Le contenu des requêtes peut contenir incidemment des données de santé (ex. : 'combien de jours maladie puis-je prendre pour une maladie chronique'). Le système n'est pas conçu pour traiter des données de santé mais ne peut pas empêcher la divulgation incidente.",
    "destinataires": [
      "Anthropic (API Claude) — sous-traitant, CCT UE signées, accord de sous-traitance en place",
      "Pinecone (vector store) — sous-traitant, région UE sélectionnée, accord de sous-traitance en place",
      "Équipe RH — administrateurs système avec accès aux journaux d'audit uniquement"
    ],
    "transferts_hors_ue": "Appels API Claude : données transmises à Anthropic (USA). Couvert par les Clauses Contractuelles Types (CCT) signées le 2026-03-15. Analyse d'impact du transfert réalisée : risque faible compte tenu des garanties techniques.",
    "retention": {
      "requetes_brutes": "30 jours — puis suppression",
      "journaux_audit_anonymises": "3 ans — pour conformité et résolution de litiges",
      "documents_vector_store": "Conservés tant que le document RH source est actuel ; supprimés dans les 48h suivant la suppression du document source"
    }
  },

  "section_2_necessite_proportionnalite": {
    "base_juridique": "Article 6(1)(b) RGPD — traitement nécessaire à l'exécution du contrat de travail (fournir des informations sur les avantages fait partie de la relation d'emploi)",
    "limitation_finalite": "Données de requête utilisées exclusivement pour générer des réponses et le contrôle qualité. Aucune utilisation pour l'évaluation des performances, mesures disciplinaires ou profilage.",
    "minimisation_donnees": "Le nom de l'employé n'est pas stocké dans la requête. L'identifiant employé n'est journalisé que dans la piste d'audit (non envoyé au LLM). Requêtes traitées de façon éphémère — non conservées dans le contexte LLM après la fin de session.",
    "alternatives_envisagees": [
      "Recherche traditionnelle : rejetée — ne gère pas les requêtes en langage naturel, taux d'abandon plus élevé",
      "Page FAQ statique étendue : rejetée — ne s'adapte pas à la complexité des politiques",
      "Ligne d'assistance RH humaine uniquement : conservée comme chemin d'escalade aux côtés du système IA"
    ]
  },

  "section_3_analyse_risques": {
    "risques_identifies": [
      {
        "risque": "Traitement inadvertant de données de santé dans le contenu des requêtes",
        "probabilite": "moyenne",
        "gravite": "élevée",
        "score_risque": 12,
        "mesures": [
          "Contenu des requêtes filtré par un détecteur de PII avant journalisation (modèle NER spaCy identifiant les termes liés à la santé)",
          "Politique de journalisation exclut le texte de la requête si des mots-clés de santé sont détectés — seule la catégorie de requête est journalisée",
          "Avis de confidentialité informe explicitement les employés de ne pas inclure de données de santé sensibles dans les requêtes"
        ],
        "risque_residuel": "faible"
      },
      {
        "risque": "Violation de données au niveau de l'API Anthropic — contenu des requêtes exposé",
        "probabilite": "faible",
        "gravite": "élevée",
        "score_risque": 8,
        "mesures": [
          "CCT et accord de sous-traitance avec Anthropic",
          "Aucun identifiant d'employé envoyé à l'API — uniquement le texte de la requête",
          "Option API sans rétention d'Anthropic activée (requêtes non stockées au-delà de la génération de réponse)",
          "Plan de réponse aux incidents couvre le scénario de violation chez le fournisseur API"
        ],
        "risque_residuel": "faible"
      }
    ],
    "risque_residuel_global": "faible",
    "avis_dpd": "Approuvé sous conditions : (1) le filtre mots-clés santé doit être implémenté avant la mise en production ; (2) l'audit de précision trimestriel doit être documenté et partagé avec le DPD ; (3) l'avis de confidentialité doit être mis à jour avant le premier accès utilisateur."
  }
}

Agents vocaux : les agents vocaux qui enregistrent et transcrivent des conversations nécessitent une AIPD dans pratiquement tous les déploiements UE. Les enregistrements audio sont des données personnelles au sens du RGPD. Les empreintes vocales peuvent qualifier comme données biométriques (catégorie particulière) si utilisées pour l'identification. Même si vous 'transcrivez seulement' à des fins qualité, l'enregistrement lui-même déclenche les obligations RGPD, y compris le consentement explicite ou une analyse solide d'intérêt légitime.

🛠️ Exercice 3 : Matrice de Risques AIPD — Surveillance Biométrique des Salariés

Votre entreprise souhaite déployer un système de reconnaissance faciale pour le pointage de 800 salariés dans 3 bureaux en UE. Avant que le DPO puisse approuver, vous devez compléter la matrice de risques AIPD au titre de l'Article 35 RGPD. Évaluez les trois risques que les autorités de contrôle examinent systématiquement pour les systèmes biométriques.

Exercice pratique

Complétez les trois entrées de risque : définissez la vraisemblance, la gravité, ajoutez deux mesures d'atténuation concrètes chacune, puis le risque résiduel après atténuation. Une fois terminé : (1) Le risque R-002 (taux d'erreur discriminatoires) justifie-t-il d'exiger des tests de performance par sous-groupe comme condition de déploiement ? (2) Pour R-003 (extension rampante), quelle mesure technique rendrait l'extension impossible sans déclencher une nouvelle AIPD ?

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
# Matrice de Risques AIPD — Reconnaissance Faciale Salariés
# Scénario : Système de pointage biométrique pour 800 salariés, 3 bureaux UE
# Complétez les champs TODO puis exécutez pour évaluer la faisabilité de l'approbation DPD.

RISQUES = [
    {
        "id": "R-001",
        "risque": "Violation de la base de données biométrique — modèles de reconnaissance faciale exposés",
        "categorie_donnees": "Données biométriques (Article 9 RGPD — catégorie particulière)",
        # TODO : Définissez la vraisemblance : "faible" | "moyen" | "eleve"
        # Indice : Les bases de données sont des cibles privilégiées. Les données biométriques sont irremplaçables.
        "vraisemblance": "TODO",
        # TODO : Définissez la gravité : "faible" | "moyen" | "eleve"
        # Indice : Une fuite biométrique permet la fraude d'identité permanente — plus grave qu'un mot de passe.
        "gravite": "TODO",
        "mesures_dattenuation": [
            # TODO : Mesure technique (ex. traitement sur l'appareil, chiffrement au repos)
            "TODO : Mesure technique",
            # TODO : Mesure organisationnelle (ex. contrôles d'accès, plan de réponse aux incidents)
            "TODO : Mesure organisationnelle",
        ],
        # TODO : Après atténuation, quel est le risque résiduel ? "faible" | "moyen" | "eleve"
        "risque_residuel": "TODO",
    },
    {
        "id": "R-002",
        "risque": "Taux d'erreur discriminatoires — le système performe moins bien pour certains groupes démographiques",
        "categorie_donnees": "Biométrique (Article 9) — intersecte avec des caractéristiques protégées",
        # Indice : Les études académiques montrent des taux d'erreur significativement différents selon la couleur de peau et le genre.
        "vraisemblance": "TODO",
        # Indice : Des pointages incorrects affectent la rémunération — impact élevé sur les salariés concernés.
        "gravite": "TODO",
        "mesures_dattenuation": [
            # TODO : Mesure technique (ex. tests de performance par sous-groupe démographique avant déploiement)
            "TODO : Tests de référence sur sous-groupes démographiques — précision minimale 95% pour tous",
            # TODO : Mesure procédurale (ex. substitution manuelle pour les cas signalés)
            "TODO : Mesure procédurale",
        ],
        "risque_residuel": "TODO",
    },
    {
        "id": "R-003",
        "risque": "Extension rampante — système étendu du pointage vers la surveillance de la productivité",
        "categorie_donnees": "Données de surveillance comportementale — peut constituer une surveillance au sens du BetrVG/droit du travail",
        # Indice : L'extension des fonctionnalités est extrêmement fréquente dans les systèmes déployés.
        "vraisemblance": "TODO",
        # Indice : La surveillance du comportement au travail a des implications importantes (Article 8 CEDH).
        "gravite": "TODO",
        "mesures_dattenuation": [
            # TODO : Mesure contractuelle/politique
            "TODO : Mesure contractuelle/politique",
            # TODO : Limitation technique (verrouiller le périmètre du système)
            "TODO : Limitation technique empêchant toute extension sans nouvelle AIPD",
        ],
        "risque_residuel": "TODO",
    },
]

SCORES = {"faible": 1, "moyen": 2, "eleve": 3}

print("Matrice de Risques AIPD — Reconnaissance Faciale Salariés")
print("=" * 58)
print()

incomplets = []
risques_residuels_eleves = []

for risque in RISQUES:
    vraisemblance = risque["vraisemblance"]
    gravite = risque["gravite"]
    residuel = risque["risque_residuel"]

    if vraisemblance == "TODO" or gravite == "TODO":
        score_str = "Définissez vraisemblance + gravite"
        incomplets.append(risque["id"])
    else:
        score = SCORES.get(vraisemblance, 0) * SCORES.get(gravite, 0)
        score_str = f"Score de risque : {score}/9"

    print(f"[{risque['id']}] {risque['risque']}")
    print(f"  Catégorie :    {risque['categorie_donnees']}")
    print(f"  Vraisemblance : {vraisemblance}  |  Gravité : {gravite}  |  {score_str}")
    print(f"  Mesures d'atténuation :")
    for m in risque["mesures_dattenuation"]:
        fait = "TODO" not in m
        print(f"    {'OK' if fait else 'TODO'} {m}")
    print(f"  Risque résiduel : {residuel}")

    if residuel == "eleve":
        risques_residuels_eleves.append(risque["id"])
    print()

# Évaluation de l'état de préparation DPD
print("-" * 58)
if incomplets:
    print(f"BLOQUÉ — Évaluations incomplètes pour : {', '.join(incomplets)}")
    print("  Complétez tous les champs vraisemblance, gravite et risque_residuel.")
elif risques_residuels_eleves:
    print(f"REJET DPD PROBABLE — Risque résiduel élevé pour : {', '.join(risques_residuels_eleves)}")
    print("  Renforcez les atténuations ou reconsidérez la conception avant soumission.")
else:
    print("PRÊT POUR RÉVISION DPD — Tous les risques résiduels sont faibles ou moyens.")
    print("  Joignez cette matrice à votre Section 3 AIPD et demandez la validation DPD.")
    print()
    print("  Rappel : Article 36 RGPD — si UN risque résiduel reste élevé après atténuation,")
    print("  vous devez consulter l'autorité de contrôle AVANT le déploiement.")

Patterns de Documentation : Fiches Système, Dossiers Techniques et Model Cards

1h30

Construisez les trois artefacts de documentation requis par l'Article 11 de l'AI Act : une fiche système (niveau métier), un dossier technique (niveau ingénierie) et une model card (niveau modèle). Inclut des scripts d'automatisation.

Documentation : Ce que l'AI Act Exige Réellement

L'Article 11 de l'AI Act exige que les systèmes IA à haut risque maintiennent une documentation technique avant la mise sur le marché — et la tiennent à jour tout au long du cycle de vie du système. Le règlement précise ce qui doit être documenté (Annexe IV) mais pas le format. Ce module établit trois types de documents pratiques qui, ensemble, satisfont l'Annexe IV, sont maintenables par les équipes d'ingénierie et peuvent être versionnés aux côtés du code.

La Fiche Système (Niveau Métier, pour le DPD et la Direction)

Yaml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# fiche-systeme.yaml — Document de conformité AI Act Annexe IV
# Placer à la racine du dépôt. Versionner avec git. Mettre à jour avant chaque release.

systeme:
  nom: "Modèle de Prédiction du Taux de Désabonnement"
  version: "2.4.1"
  date_release: "2026-05-08"
  responsables:
    equipe: "Data Science — Intelligence Client"
    responsable_produit: "Laurent Dupont <l.dupont@entreprise.com>"
    responsable_conformite: "Marie Chen <m.chen@legal.entreprise.com>"
    derniere_revue: "2026-05-01"

classification:
  niveau_risque_ai_act: "haut"
  annexe_ai_act: "Annexe III §5b — solvabilité / notation clients dans les services financiers"
  base_gpai: true
  fournisseur_gpai: "Anthropic Claude claude-3-haiku (couche d'extraction de features)"
  preuves: "Le système produit un score de probabilité de désabonnement utilisé par l'équipe rétention pour prioriser les appels sortants. Les scores influencent quels clients reçoivent des offres de remise (avantage financier) et lesquels n'en reçoivent pas. Constitue une décision avec des effets 'similairement significatifs' au sens de l'Article 22 RGPD."
  date_classification: "2026-03-15"
  reviseur_classification: "Marie Chen (DPD)"

finalite:
  usage_prevu: "Prédire la probabilité de désabonnement à 30 jours des clients B2C télécom. Le score est utilisé par l'équipe rétention pour prioriser les appels d'intervention."
  hors_perimetre:
    - "Résiliation automatisée de contrats clients"
    - "Modifications automatisées de tarification"
    - "Utilisation pour l'évaluation des performances des employés"
  limitations_connues:
    - "Modèle entraîné sur des clients avec plus de 6 mois d'ancienneté. Performance sur les nouveaux clients (0-6 mois) inférieure de 18% en précision."
    - "Modèle présente un taux de faux positifs 12% plus élevé pour les clients en zones rurales — en cours d'investigation (voir rapport-biais-2026-T1.md)"

performance:
  metriques:
    auc_roc: 0.847
    precision_k10: 0.612
    rappel_k10: 0.534
    taux_faux_positifs: 0.143
  jeu_evaluation: "Jeu de holdout : cohorte T4 2025, 45 000 clients, taux de désabonnement réel 8,3%"
  performance_par_sous_groupe:
    clients_ruraux: {auc_roc: 0.791, taux_faux_positifs: 0.198}
    clients_urbains: {auc_roc: 0.861, taux_faux_positifs: 0.131}

supervision_humaine:
  mecanisme: "Les agents de rétention examinent chaque score avant d'effectuer des appels sortants. Les agents peuvent substituer le score et signaler pour révision du modèle."
  taux_substitution_dernier_trimestre: "7,2%"
  chemin_escalade: "Agent signale le client → Revue Chef d'équipe → Exclu de la liste automatique"

conformite:
  reference_aipd: "AIPD-2026-CHURN-001 (approuvée le 2026-03-20)"
  date_evaluation_conformite: "2026-04-15"
  enregistrement_base_donnees_ai_act: "en attente — requis avant août 2026"
  prochain_audit: "2026-11-01"

Frameworks de Test : Détection des Biais et Surveillance de la Dérive

Construisez des suites de tests automatisées pour les biais démographiques et la dérive en production — les deux causes les plus fréquentes de non-conformité à l'AI Act découvertes lors de la surveillance post-commercialisation.

Frameworks de Test : Biais et Dérive en Production

L'AI Act exige une surveillance post-commercialisation continue (Article 72) — pas seulement des tests avant déploiement. Vous avez besoin de tests automatisés qui s'exécutent en production et vous alertent lorsque les performances se dégradent, les biais augmentent ou la distribution des entrées dérive. Ce module construit une stack de monitoring complète utilisant des outils open-source : Evidently pour la détection de dérive, et un framework de test d'équité personnalisé.

Suite de Tests de Parité Démographique

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
# suite_tests_equite.py
# Détection automatisée des biais pour la surveillance post-commercialisation AI Act
# Exécuter hebdomadairement dans le pipeline CI/CD ou de monitoring
# pip install pandas scipy scikit-learn

import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import Literal

@dataclass
class ResultatTestEquite:
    nom_test: str
    attribut_protege: str
    reussi: bool
    valeur_metrique: float
    seuil: float
    details: str

class SuiteTestsEquite:
    """
    Tests de biais conformes à l'AI Act pour les modèles de classification.
    Couvre les trois métriques d'équité les plus scrutinées par les régulateurs UE :
    parité démographique, égalité des chances, et équité individuelle.
    """

    ECHELLE = {"faible": 1, "moyenne": 2, "elevee": 3}

    def __init__(
        self,
        predictions: pd.Series,
        verite_terrain: pd.Series,
        attributs_proteges: pd.DataFrame,
        max_dispersion_demographique: float = 0.10,
        max_dispersion_faux_positifs: float = 0.08,
    ):
        self.predictions = predictions
        self.verite_terrain = verite_terrain
        self.attributs_proteges = attributs_proteges
        self.max_dispersion_demo = max_dispersion_demographique
        self.max_dispersion_fp = max_dispersion_faux_positifs
        self.resultats: list[ResultatTestEquite] = []

    def tester_parite_demographique(self, attribut: str) -> ResultatTestEquite:
        """
        Parité démographique : le taux de résultats positifs doit être similaire entre les groupes.
        Seuil réglementaire : généralement ≤10% de différence absolue.
        """
        groupes = self.attributs_proteges[attribut].unique()
        taux = {g: self.predictions[self.attributs_proteges[attribut] == g].mean() for g in groupes}
        dispersion = max(taux.values()) - min(taux.values())
        groupe_min = min(taux, key=taux.get)
        groupe_max = max(taux, key=taux.get)
        reussi = dispersion <= self.max_dispersion_demo

        return ResultatTestEquite(
            nom_test="parite_demographique",
            attribut_protege=attribut,
            reussi=reussi,
            valeur_metrique=round(dispersion, 4),
            seuil=self.max_dispersion_demo,
            details=f"Dispersion max entre {groupe_max} ({taux[groupe_max]:.3f}) et {groupe_min} ({taux[groupe_min]:.3f})",
        )

    def executer_tous(self, attributs: list[str]) -> dict:
        for attr in attributs:
            self.resultats.append(self.tester_parite_demographique(attr))

        echecs = [r for r in self.resultats if not r.reussi]
        statut = "CONFORME" if not echecs else "NON CONFORME"

        rapport = {
            "total_tests": len(self.resultats),
            "reussis": len(self.resultats) - len(echecs),
            "echecs": len(echecs),
            "statut_conformite": statut,
            "non_conformites": [
                {
                    "test": r.nom_test,
                    "attribut": r.attribut_protege,
                    "valeur": r.valeur_metrique,
                    "seuil": r.seuil,
                    "details": r.details,
                }
                for r in echecs
            ],
        }

        if echecs:
            print(f"❌ TEST DE BIAIS ÉCHOUÉ — {len(echecs)} tests non conformes")
            for e in rapport["non_conformites"]:
                print(f"   {e['test']} ({e['attribut']}) : {e['valeur']:.4f} > seuil {e['seuil']}")
            print("   Action requise : réviser le modèle et corriger avant le prochain déploiement.")
        else:
            print(f"✅ Tous les {len(self.resultats)} tests de biais réussis")

        return rapport

# Exemple d'utilisation
np.random.seed(42)
n = 2000
genre = np.random.choice(["H", "F"], n, p=[0.55, 0.45])
predictions = np.random.binomial(1, np.where(genre == "H", 0.55, 0.40))
verite = np.random.binomial(1, 0.48, n)
df_attributs = pd.DataFrame({"genre": genre, "region": np.random.choice(["urbain", "rural"], n)})

suite = SuiteTestsEquite(
    predictions=pd.Series(predictions),
    verite_terrain=pd.Series(verite),
    attributs_proteges=df_attributs,
)
rapport = suite.executer_tous(["genre", "region"])
print(f"\nRapport : {rapport['statut_conformite']} ({rapport['reussis']}/{rapport['total_tests']} tests réussis)")

Journalisation d'Audit : Quoi Journaliser, Comment Structurer, Combien de Temps Conserver

1h30

Implémentez l'infrastructure de journalisation requise par l'Article 12 de l'AI Act pour les systèmes à haut risque. Couvre la conception du schéma de journaux, les exigences d'immuabilité, et une implémentation middleware FastAPI.

Journalisation d'Audit pour l'Article 12 de l'AI Act

L'Article 12 de l'AI Act exige que les systèmes IA à haut risque 'enregistrent automatiquement les événements' pour permettre la surveillance post-commercialisation et l'investigation des incidents. Les journaux doivent être : (1) générés automatiquement — pas écrits manuellement, (2) suffisants pour reconstituer le fonctionnement du système à tout moment donné, (3) conservés pendant la durée de vie opérationnelle du système (minimum 6 mois pour la plupart des systèmes, 10 ans pour les systèmes d'infrastructures critiques).

Schéma de Journal Conforme à l'AI Act

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
# journaliseur_audit_ia.py
# Journalisation d'audit conforme à l'Article 12 pour les systèmes IA à haut risque
# Produit des journaux structurés adaptés à l'archivage long terme et aux requêtes d'audit

import hashlib
import json
from datetime import datetime, timezone
from dataclasses import dataclass, asdict
from typing import Optional

@dataclass
class EvenementAuditIA:
    """
    Entrée de journal structurée pour la conformité Article 12 de l'AI Act.
    Chaque champ correspond à une exigence spécifique de l'Annexe IV ou de l'Article 12.
    """
    # Identification
    identifiant_evenement: str        # ULID unique globalement
    identifiant_systeme: str          # Identifiant du système IA depuis la fiche système
    version_systeme: str              # Version du modèle déployé

    # Temporel
    horodatage_utc: str              # ISO 8601 UTC — requis par l'Article 12
    duree_traitement_ms: int

    # Contexte de requête
    identifiant_session: str          # Pseudonymisé
    hash_requete: str                 # SHA-256 de l'entrée — sans stocker les données personnelles
    categorie_entree: str             # Catégorie sémantique de l'entrée

    # Décision
    etiquette_sortie: Optional[str]   # Décision ou classification du modèle
    score_sortie: Optional[float]     # Score de confiance
    categorie_sortie: str             # "decision_automatisee" | "recommandation" | "generation"

    # Supervision humaine
    substitution_humaine: bool        # La décision a-t-elle été substituée par un humain ?
    raison_substitution: Optional[str]

    # Indicateurs de conformité
    niveau_risque: str                # "haut" | "limite" | "minimal"
    reference_aipd: Optional[str]
    base_juridique_rgpd: str

    # Suivi des incidents
    erreur_survenue: bool
    code_erreur: Optional[str]

def creer_evenement_audit(
    identifiant_systeme: str,
    version_systeme: str,
    identifiant_session: str,
    entree_brute: any,
    etiquette_sortie: Optional[str],
    score_sortie: Optional[float],
    categorie_sortie: str,
    categorie_entree: str,
    niveau_risque: str = "haut",
    reference_aipd: Optional[str] = None,
    base_juridique_rgpd: str = "Article 6(1)(b)",
    substitution_humaine: bool = False,
    raison_substitution: Optional[str] = None,
    duree_traitement_ms: int = 0,
    code_erreur: Optional[str] = None,
) -> EvenementAuditIA:
    """
    Crée un événement d'audit avec protection automatique des données personnelles :
    l'entrée brute est hachée (SHA-256), jamais stockée dans le journal.
    """
    from ulid import ULID
    hash_entree = hashlib.sha256(
        json.dumps(entree_brute, sort_keys=True).encode()
    ).hexdigest()

    return EvenementAuditIA(
        identifiant_evenement=str(ULID()),
        identifiant_systeme=identifiant_systeme,
        version_systeme=version_systeme,
        horodatage_utc=datetime.now(timezone.utc).isoformat(),
        duree_traitement_ms=duree_traitement_ms,
        identifiant_session=identifiant_session,
        hash_requete=hash_entree,
        categorie_entree=categorie_entree,
        etiquette_sortie=etiquette_sortie,
        score_sortie=score_sortie,
        categorie_sortie=categorie_sortie,
        substitution_humaine=substitution_humaine,
        raison_substitution=raison_substitution,
        niveau_risque=niveau_risque,
        reference_aipd=reference_aipd,
        base_juridique_rgpd=base_juridique_rgpd,
        erreur_survenue=code_erreur is not None,
        code_erreur=code_erreur,
    )

Configuration de rétention pour la conformité Article 12 : pour les systèmes à haut risque dans la plupart des domaines, conservez les journaux pendant la durée de vie opérationnelle du système + 10 ans. Utilisez S3 Object Lock (mode COMPLIANCE) ou Azure Immutable Blob Storage pour empêcher la suppression. Testez votre politique de rétention des journaux annuellement — un journal inaccessible équivaut à aucun journal lors d'un audit.

Projet Final : Analyse de Risques Complète pour un Système RAG en Production

2h30

Réalisez une analyse de risques complète AI Act + RGPD pour un système RAG d'analyse de documents juridiques — le type le plus fréquemment scrutiné par les régulateurs. Produisez des scores de risque réels, identifiez les mesures d'atténuation et générez le certificat de conformité.

Projet Final : Analyse de Risques pour un RAG Juridique en Production

Scénario : votre entreprise a développé un système RAG qui analyse les contrats juridiques et signale les clauses non standard. Les juristes l'utilisent pour prioriser leurs efforts de révision. Vous êtes sur le point de le déployer auprès de 40 cabinets d'avocats dans l'UE. Avant la mise en production, vous avez besoin d'une analyse de risques complète.

Étape 1 — Classification des Risques avec Score de Preuve

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
# analyse_risques_rag_juridique.py
# Analyse de risques complète pour un système RAG d'analyse de documents juridiques

from dataclasses import dataclass, field
from typing import Literal
import json
from datetime import date

@dataclass
class RisqueIdentifie:
    domaine: str
    description: str
    probabilite: Literal["faible", "moyenne", "elevee"]
    gravite: Literal["faible", "moyenne", "elevee"]
    score: int = field(init=False)
    mesures: list[str] = field(default_factory=list)
    probabilite_residuelle: Literal["faible", "moyenne", "elevee"] = "faible"
    gravite_residuelle: Literal["faible", "moyenne", "elevee"] = "faible"
    score_residuel: int = field(init=False)
    reference_reglementaire: str = ""

    ECHELLE = {"faible": 1, "moyenne": 2, "elevee": 3}

    def __post_init__(self):
        self.score = self.ECHELLE[self.probabilite] * self.ECHELLE[self.gravite]
        self.score_residuel = self.ECHELLE[self.probabilite_residuelle] * self.ECHELLE[self.gravite_residuelle]

    def niveau_risque(self, score: int) -> str:
        if score >= 6: return "ÉLEVÉ"
        if score >= 3: return "MOYEN"
        return "FAIBLE"

SYSTEME = {
    "nom": "LexAnalyse — RAG Analyse de Contrats",
    "version": "1.3.0",
    "deploiement": "SaaS, 40 cabinets d'avocats UE, ~200 utilisateurs actifs/jour",
    "classification_ai_act": "HAUT RISQUE — Annexe III §8 (administration de la justice)",
    "fournisseur_gpai": "Anthropic Claude claude-3-5-sonnet (couche d'analyse)",
    "date_evaluation": str(date.today()),
}

REGISTRE_RISQUES: list[RisqueIdentifie] = [

    RisqueIdentifie(
        domaine="Classification AI Act",
        description="Système utilisé dans l'analyse juridique — risque Annexe III §8. Si la sortie influence un conseil juridique substantiel donné aux clients, la classification haut risque s'applique.",
        probabilite="elevee",
        gravite="elevee",
        mesures=[
            "Système positionné comme 'assistant de signalement de clauses' et non comme 'outil de conseil juridique' — les CGU interdisent l'utilisation comme opinion juridique principale",
            "Chaque sortie inclut l'avertissement obligatoire : 'Cette analyse est une aide à la révision. Les conclusions juridiques nécessitent une vérification par un juriste qualifié.'",
            "Les juristes doivent documenter qu'ils ont révisé et validé indépendamment chaque clause signalée avant de s'y fier",
            "Évaluation de conformité complétée le 2026-04-30 selon les exigences de l'Annexe III §8",
        ],
        probabilite_residuelle="moyenne",
        gravite_residuelle="moyenne",
        reference_reglementaire="AI Act Annexe III §8, Article 43",
    ),

    RisqueIdentifie(
        domaine="Hallucinations dans l'Analyse de Clauses",
        description="Le LLM peut halluciner des interprétations de clauses, manquer des obligations, ou signaler incorrectement des clauses bénignes comme problématiques.",
        probabilite="moyenne",
        gravite="elevee",
        mesures=[
            "Récupération RAG limitée au texte de la clause uniquement — le modèle ne peut pas introduire d'informations absentes du contrat",
            "Seuil de score de fondement : les réponses avec similarité de récupération < 0,75 déclenchent un avertissement 'faible confiance'",
            "Vérification automatique de cohérence factuelle par modèle NLI : la revendication de sortie est vérifiée par rapport à la clause source",
            "Évaluation mensuelle en mode red team : 50 contrats synthétiques avec analyse correcte connue, précision cible ≥95%",
        ],
        probabilite_residuelle="faible",
        gravite_residuelle="moyenne",
        reference_reglementaire="AI Act Article 9 (gestion des risques), Article 15 (précision)",
    ),

    RisqueIdentifie(
        domaine="Exposition de Données Clients Confidentielles",
        description="Les cabinets d'avocats téléversent des contrats clients confidentiels. Les données ne doivent pas fuiter vers d'autres cabinets via le vector store partagé.",
        probabilite="faible",
        gravite="elevee",
        mesures=[
            "Multi-tenant strict : données de chaque cabinet dans un espace de noms isolé du vector store avec clé API séparée",
            "API sans rétention : API Claude configurée sans stockage des entrées",
            "Contrats supprimés du vector store dans les 30 jours suivant le téléversement (configurable par cabinet)",
            "Test de pénétration annuel incluant la vérification de l'isolation des données inter-tenant",
        ],
        probabilite_residuelle="faible",
        gravite_residuelle="faible",
        reference_reglementaire="RGPD Article 32 (sécurité), AI Act Article 10 (gouvernance des données)",
    ),

    RisqueIdentifie(
        domaine="RGPD — Données Personnelles dans les Contrats",
        description="Les contrats téléversés contiennent fréquemment des données personnelles (noms des parties, signatures, adresses). Leur traitement déclenche les obligations RGPD.",
        probabilite="elevee",
        gravite="moyenne",
        mesures=[
            "AIPD complétée : AIPD-2026-LEGAL-001 (approuvée par DPD le 2026-04-15)",
            "PII détectées dans les contrats signalées à l'utilisateur avant analyse — l'utilisateur confirme que le traitement est approprié",
            "Accord de sous-traitance signé avec chaque cabinet (ils sont responsables du traitement ; nous sommes sous-traitants)",
            "Accord de sous-traitance avec Anthropic (CCT signées le 2026-03-15)",
            "Rétention : données contractuelles supprimées 30 jours après téléversement ou sur demande explicite de l'utilisateur",
        ],
        probabilite_residuelle="faible",
        gravite_residuelle="faible",
        reference_reglementaire="RGPD Article 28 (sous-traitant), Article 35 (AIPD), AI Act Article 10",
    ),
]

def generer_rapport(systeme: dict, risques: list[RisqueIdentifie]) -> dict:
    risques_critiques_residuels = [r for r in risques if r.niveau_risque(r.score_residuel) == "ÉLEVÉ"]
    statut = "BLOQUÉ — résoudre les risques critiques" if risques_critiques_residuels else "APPROUVÉ POUR DÉPLOIEMENT"

    rapport = {
        "systeme": systeme,
        "resume": {
            "total_risques": len(risques),
            "risques_initiaux_eleves": sum(1 for r in risques if r.niveau_risque(r.score) == "ÉLEVÉ"),
            "risques_residuels_eleves": len(risques_critiques_residuels),
            "statut": statut,
        },
        "certificat": {
            "emis": statut == "APPROUVÉ POUR DÉPLOIEMENT",
            "valide_jusqu_au": "2027-05-08",
            "conditions": [
                "Tests de biais mensuels obligatoires",
                "Rapport de surveillance de dérive trimestriel",
                "AIPD révisée annuellement ou lors de changement matériel",
                "Enregistrement dans la base de données AI Act UE avant août 2026",
            ] if statut == "APPROUVÉ POUR DÉPLOIEMENT" else [],
        },
    }

    print(f"\n{'='*60}")
    print(f"RAPPORT D'ANALYSE DE RISQUES — {systeme['nom']}")
    print(f"{'='*60}")
    print(f"Total risques évalués : {rapport['resume']['total_risques']}")
    print(f"Risques initiaux élevés : {rapport['resume']['risques_initiaux_eleves']}")
    print(f"Risques résiduels élevés : {rapport['resume']['risques_residuels_eleves']}")
    print(f"\n⚖️  STATUT : {statut}")

    if rapport["certificat"]["emis"]:
        print(f"\n✅ Certificat de conformité émis — valide jusqu'au {rapport['certificat']['valide_jusqu_au']}")

    return rapport

rapport = generer_rapport(SYSTEME, REGISTRE_RISQUES)

Étape 2 — Checklist Avant Mise en Production

Classification des risques documentée et signée par le responsable conformité — fichier de preuves stocké en gestion de version
AIPD complétée et approuvée par le DPD — stockée dans le registre de confidentialité avec date d'expiration
Évaluation de conformité complétée (pour les systèmes à haut risque) — certificat émis
Enregistrement dans la base de données AI Act de l'UE soumis (obligatoire avant août 2026 pour les systèmes à haut risque)
Mécanisme de supervision humaine testé — workflow de substitution vérifié de bout en bout
Journalisation d'audit en fonctionnement — journal échantillon révisé par l'équipe conformité, politique de rétention confirmée
Suite de tests de biais en fonctionnement — rapport de référence généré, seuils documentés
Moniteur de dérive configuré — premier snapshot du jeu de données de référence sauvegardé
Accords de sous-traitance signés avec tous les sous-traitants (API LLM, vector store, fournisseur cloud)
Divulgation côté utilisateur implémentée — notice 'Ceci est un système IA' vérifiée dans l'interface
Plan de réponse aux incidents documenté — qui notifier, dans quel délai (Article 73 : incidents graves dans les 15 jours ouvrables à l'autorité de surveillance du marché)
Calendrier de surveillance post-commercialisation défini — revue trimestrielle minimum pour les systèmes à haut risque

Sauvegardez cette checklist comme modèle d'issue GitHub ou ticket JIRA. Exécutez-la pour chaque nouveau déploiement IA et à chaque release majeure. Attachez la checklist complétée à votre PR de release — elle devient la piste d'audit.

Quiz disponible

Terminez la lecture de ce module puis validez vos connaissances avec le quiz.

Prêt à mettre en conformité vos systèmes IA ?

En présentiel ou distanciel. Groupes de 4 à 12 personnes. Contactez-nous pour organiser une session pour votre équipe.

Nous contacter