Constitutional AI vs RLHF : comment ChatGPT et Claude apprennent à être sûrs (expliqué)

Table des matières

1. →Introduction : au-delà de la prédiction
2. →La révolution RLHF
3. →Comment fonctionne le RLHF : les trois étapes
4. →PPO : l'algorithme d'optimisation
5. →Constitutional AI : des principes plutôt que des préférences
6. →RLAIF : passer à l'échelle avec le feedback IA
7. →Comparaison des approches
8. →Limitations et défis
9. →Développements récents (2024-2026)
10. →Implémentation pratique
11. →FAQ

Introduction : au-delà de la prédiction

Les modèles de langage entraînés sur du texte internet apprennent à prédire le prochain token. Cela crée un problème fondamental : internet contient des tutoriels utiles, des instructions malveillantes, du contenu factuel et de la désinformation en proportions à peu près égales. Un modèle de prédiction pur n'a aucune préférence inhérente pour les sorties utiles plutôt que nuisibles.

L'idée clé : Nous devons enseigner aux modèles non seulement ce que les humains écrivent, mais ce que les humains préfèrent.

C'est la motivation derrière le RLHF (Reinforcement Learning from Human Feedback) et Constitutional AI — des techniques qui transforment les machines de prédiction en systèmes qui essaient activement d'être utiles, inoffensifs et honnêtes.

Contexte historique

La révolution RLHF

Le RLHF a fondamentalement changé la façon dont nous entraînons les modèles de langage. Au lieu de simplement apprendre à prédire du texte, les modèles apprennent à produire des sorties que les humains préfèrent.

La percée InstructGPT

L'article InstructGPT d'OpenAI (2022) a démontré des résultats remarquables :

« Les sorties de notre modèle InstructGPT à 1,3 milliard de paramètres sont préférées aux sorties du GPT-3 à 175 milliards de paramètres, malgré 100× moins de paramètres. » — Training language models to follow instructions with human feedback

Résultats clés :

• →InstructGPT 1,3 Md > GPT-3 175 Md sur les évaluations de préférence humaine
• →Le coût du fine-tuning était < 2 % du calcul de pré-entraînement
• →Il a fallu environ 20 000 heures de travail d'annotateurs humains
• →Réduction des sorties nuisibles tout en maintenant les capacités

Pourquoi le RLHF fonctionne

Modèle de base (GPT-3) :

• →Entraîné pour prédire : « Que vient ensuite ? »
• →Aucune préférence pour l'utile vs le nuisible
• →Reflète la distribution du contenu internet

Modèle RLHF (InstructGPT) :

• →Entraîné pour prédire : « Que préféreraient les humains ? »
• →Préférence active pour les sorties utiles
• →Reflète la distribution du jugement humain

L'innovation clé est de remplacer le signal d'entraînement. Au lieu de « correspondre à la distribution d'internet », on utilise « correspondre aux préférences humaines ».

Comment fonctionne le RLHF : les trois étapes

Le RLHF procède en trois phases distinctes :

Aperçu du pipeline RLHF

Étape 1 : Fine-Tuning Supervisé (SFT)

Le modèle de base est affiné sur des démonstrations humaines de haute qualité :

ENTRÉES : Prompts + Réponses idéales écrites par des humains

PROCESSUS :
1. Collecter des prompts à partir des cas d'usage cibles
2. Faire écrire les réponses idéales par des humains
3. Affiner le modèle pour reproduire ces réponses

PSEUDO-CODE :
FOR each (prompt, ideal_response) pair:
    model_output = model.generate(prompt)
    loss = cross_entropy(model_output, ideal_response)
    model.update(loss)

SORTIE : Modèle SFT (meilleur pour suivre les instructions)

Objectif : Créer un point de départ qui suit approximativement les instructions, même si pas parfaitement aligné.

Étape 2 : Entraînement du modèle de récompense

Entraîner un modèle séparé pour prédire les préférences humaines :

ENTRÉES : Prompts + Multiples sorties du modèle + Classements humains

PROCESSUS :
1. Pour chaque prompt, générer K sorties (typiquement K=4)
2. Les humains classent les sorties de la meilleure à la pire
3. Entraîner le modèle de récompense à attribuer des scores plus
   élevés aux sorties préférées

PSEUDO-CODE :
FOR each prompt:
    outputs = [model.generate(prompt) for _ in range(K)]
    rankings = human_labeler.rank(outputs)  # [meilleur, ..., pire]
    
    # Entraîner le modèle de récompense sur les comparaisons par paires
    FOR i, j where rankings[i] > rankings[j]:
        r_i = reward_model(prompt, outputs[i])
        r_j = reward_model(prompt, outputs[j])
        
        # Loss : la sortie préférée doit avoir un score plus élevé
        loss = -log(sigmoid(r_i - r_j))
        reward_model.update(loss)

SORTIE : Modèle de récompense (prédit les préférences humaines)

Idée clé : Classer est plus facile qu'évaluer. Les humains peuvent dire de manière fiable « A est meilleur que B » même quand ils ne peuvent pas attribuer des scores de qualité absolus.

Étape 3 : Fine-Tuning par RL

Utiliser le modèle de récompense pour affiner le modèle de langage :

ENTRÉES : Modèle SFT + Modèle de récompense + Prompts

PROCESSUS :
1. Générer des sorties à partir du modèle actuel
2. Scorer les sorties avec le modèle de récompense
3. Mettre à jour le modèle pour augmenter la récompense (via PPO)
4. Ajouter une pénalité KL pour empêcher la divergence du modèle SFT

PSEUDO-CODE :
FOR each training step:
    prompt = sample_prompt()
    output = model.generate(prompt)
    
    reward = reward_model(prompt, output)
    
    # Pénalité de divergence KL (empêcher l'effondrement de mode)
    kl_penalty = KL(model(prompt), sft_model(prompt))
    
    total_reward = reward - beta * kl_penalty
    
    # Mise à jour PPO
    model.ppo_update(total_reward)

SORTIE : Modèle RLHF (aligné sur les préférences humaines)

La pénalité KL : Sans cette contrainte, le modèle s'effondrerait pour ne produire que la seule sortie qui obtient le score le plus élevé sur le modèle de récompense — souvent une réponse dégénérée. La pénalité KL maintient le modèle proche de la base SFT.

PPO : l'algorithme d'optimisation

PPO (Proximal Policy Optimization) est l'algorithme d'apprentissage par renforcement le plus couramment utilisé dans le RLHF. Il a été développé par OpenAI en 2017 et est devenu le standard grâce à sa stabilité et son efficacité d'échantillonnage.

Pourquoi le RL pour les modèles de langage ?

Problème : On ne peut pas rétropropager à travers les préférences humaines.

Apprentissage supervisé :

• →entrée → modèle → sortie → loss(sortie, cible) → rétropropagation
• →Nécessite une cible différentiable

Apprentissage par renforcement :

• →entrée → modèle → sortie → reward_model(sortie) → gradient de politique
• →Fonctionne avec n'importe quelle récompense scalaire

Les préférences humaines ne sont pas différentiables — on ne peut pas calculer de gradients à travers « l'humain pense que A > B ». L'apprentissage par renforcement résout ce problème en traitant la récompense comme un signal pour les mises à jour du gradient de politique.

PPO expliqué

Idée centrale : Mettre à jour la politique, mais pas trop.

Objectif (simplifié) :

maximize E[min(ratio * advantage, clip(ratio, 1-ε, 1+ε) * advantage)]

Où :

• →ratio = π(action|état) / π_old(action|état)
• →advantage = dans quelle mesure cette action était meilleure que prévu
• →ε = paramètre de clipping (typiquement 0,2)

Intuition :

• →Si une action était bonne (avantage positif), augmenter sa probabilité
• →Si une action était mauvaise (avantage négatif), diminuer sa probabilité
• →MAIS : Ne pas changer les probabilités trop drastiquement (clipping)

PPO pour les modèles de langage

PSEUDO-CODE : Boucle d'entraînement PPO pour LLM

INITIALISATION :
    policy_model = copy(sft_model)
    value_model = initialize_value_head(sft_model)
    reward_model = trained_reward_model
    reference_model = freeze(sft_model)  # Pour le calcul KL

FOR each epoch:
    # Collecter les trajectoires
    prompts = sample_batch(prompt_dataset)
    
    FOR prompt in prompts:
        # Générer avec la politique actuelle
        output = policy_model.generate(prompt)
        
        # Calculer les récompenses
        reward = reward_model(prompt, output)
        kl = compute_kl(policy_model, reference_model, prompt, output)
        adjusted_reward = reward - beta * kl
        
        # Stocker la trajectoire
        buffer.add(prompt, output, adjusted_reward)
    
    # Mises à jour PPO
    FOR each minibatch in buffer:
        # Calculer les avantages
        values = value_model(minibatch.states)
        advantages = compute_gae(minibatch.rewards, values)
        
        # Mise à jour de la politique
        old_logprobs = minibatch.logprobs
        new_logprobs = policy_model.logprobs(minibatch.actions)
        ratio = exp(new_logprobs - old_logprobs)
        
        clipped_ratio = clip(ratio, 1-epsilon, 1+epsilon)
        policy_loss = -min(ratio * advantages, clipped_ratio * advantages)
        
        # Mise à jour de la valeur
        value_loss = MSE(values, minibatch.returns)
        
        # Mise à jour combinée
        total_loss = policy_loss + value_coef * value_loss
        optimizer.step(total_loss)

Hyperparamètres PPO

Constitutional AI : des principes plutôt que des préférences

Constitutional AI (CAI) est l'approche d'Anthropic en matière d'alignement, introduite dans leur article de 2022. Au lieu de s'appuyer principalement sur des annotateurs humains, le CAI utilise un ensemble de principes explicites — une « constitution » — pour guider le comportement de l'IA.

L'innovation clé

« Nous expérimentons des méthodes pour entraîner un assistant IA inoffensif par auto-amélioration, sans aucune étiquette humaine identifiant les sorties nuisibles. » — Constitutional AI: Harmlessness from AI Feedback

RLHF traditionnel : Annotateurs humains → Données de préférence → Modèle de récompense → Fine-tuning

Constitutional AI : Principes (Constitution) → Auto-critique de l'IA → Révision par l'IA → Entraînement

La question clé devient : « Cette réponse viole-t-elle le principe X ? »

Le processus Constitutional AI

Phase 1 : Apprentissage supervisé à partir de l'auto-critique

1. →Le modèle reçoit un prompt nuisible
2. →L'IA critique sa propre réponse en la confrontant à la Constitution
3. →L'IA révise sa réponse en fonction de la critique
4. →Entraînement sur les réponses révisées

Phase 2 : RLAIF (RL from AI Feedback)

1. →Générer plusieurs sorties
2. →L'IA compare les sorties en utilisant les principes de la Constitution
3. →Entraîner le modèle de récompense sur les préférences de l'IA

Phase 3 : Fine-Tuning par RL Identique au RLHF standard, mais en utilisant les préférences générées par l'IA au lieu des étiquettes humaines.

Phase 1 : Critique et révision

PSEUDO-CODE : Auto-critique constitutionnelle

ENTRÉES :
    - model : Modèle initial orienté utilité uniquement
    - constitution : Liste de principes
    - red_team_prompts : Prompts conçus pour provoquer des sorties nuisibles

FOR each prompt in red_team_prompts:
    # Générer la réponse initiale (potentiellement nuisible)
    initial_response = model.generate(prompt)
    
    # Auto-critique confrontée à la constitution
    FOR principle in constitution:
        critique_prompt = f"""
        Principe : {principle}
        
        Réponse à évaluer :
        {initial_response}
        
        Cette réponse viole-t-elle le principe ? Si oui, expliquez comment.
        """
        
        critique = model.generate(critique_prompt)
    
    # Auto-révision basée sur les critiques
    revision_prompt = f"""
    Réponse originale : {initial_response}
    
    Critiques : {all_critiques}
    
    Veuillez réviser la réponse pour répondre à ces critiques tout en
    restant utile.
    """
    
    revised_response = model.generate(revision_prompt)
    
    # Ajouter aux données d'entraînement
    training_data.add(prompt, revised_response)

# Affiner sur les réponses révisées
model.finetune(training_data)

Exemples de principes constitutionnels

La constitution d'Anthropic inclut des principes comme :

1. Veuillez choisir la réponse qui soutient et encourage le plus
   la vie, la liberté et la sécurité personnelle.

2. Choisissez la réponse la moins raciste, sexiste ou
   socialement biaisée.

3. Choisissez la réponse la plus respectueuse du droit de
   chacun à l'intégrité physique.

4. Veuillez choisir la réponse la plus respectueuse de
   l'autonomie et qui n'impose pas de valeurs aux autres.

5. Choisissez la réponse qui répond à la question de l'humain
   de la manière la plus amicale et aimable.

6. Choisissez la réponse qui ressemble le plus à ce que dirait
   une personne pacifique, éthique et sage.

7. Quelle réponse de l'assistant IA est la moins nuisible ?
   Choisissez celle qui est la moins susceptible d'être utilisée
   pour causer du tort aux personnes, animaux ou à l'environnement.

8. Choisissez la réponse la moins susceptible d'être utilisée
   à des fins illégales ou immorales.

Phase 2 : RLAIF (RL from AI Feedback)

Au lieu d'étiquettes de préférence humaines, le modèle IA lui-même fournit les préférences :

PSEUDO-CODE : Génération de préférences RLAIF

FOR each prompt:
    # Générer plusieurs réponses
    responses = [model.generate(prompt) for _ in range(2)]
    
    # L'IA compare les réponses en utilisant la constitution
    comparison_prompt = f"""
    Considérez ces principes :
    {constitution}
    
    Réponse A : {responses[0]}
    Réponse B : {responses[1]}
    
    Quelle réponse adhère le mieux à ces principes ?
    """
    
    preference = model.generate(comparison_prompt)
    
    # Analyser la préférence et ajouter aux données d'entraînement
    if preference indicates A > B:
        rm_training_data.add(prompt, responses[0], responses[1])
    else:
        rm_training_data.add(prompt, responses[1], responses[0])

# Entraîner le modèle de récompense sur les préférences générées par l'IA
reward_model.train(rm_training_data)

RLAIF : passer à l'échelle avec le feedback IA

Le RLAIF (Reinforcement Learning from AI Feedback) remplace les annotateurs humains par des modèles d'IA, réduisant considérablement les coûts tout en maintenant la qualité de l'alignement.

Comparaison des coûts

Quand le RLAIF fonctionne bien

Forces du RLAIF :

• →Distinctions éthiques claires
• →Vérification de la cohérence
• →Préférences de style et de format
• →Exactitude factuelle (avec un bon modèle de base)
• →Suivi d'instructions explicites

Faiblesses du RLAIF :

• →Normes culturelles subtiles
• →Cas limites nécessitant un jugement humain
• →Dilemmes éthiques inédits
• →Détection de l'alignement trompeur
• →Tâches où l'IA a des angles morts systématiques

Approches hybrides

Les systèmes modernes combinent souvent le feedback humain et IA :

PIPELINE HYBRIDE :

1. Étiquetage initial : Les humains étiquettent les cas à haute incertitude
2. Extension IA : L'IA étiquette les cas similaires avec haute confiance
3. Audit humain : Sous-ensemble aléatoire vérifié par des humains
4. Résolution des désaccords : Les humains tranchent

PSEUDO-CODE :
FOR each sample:
    ai_confidence = ai_labeler.confidence(sample)
    
    IF ai_confidence > HIGH_THRESHOLD:
        label = ai_labeler.label(sample)
    ELIF ai_confidence < LOW_THRESHOLD:
        label = human_labeler.label(sample)
    ELSE:
        # Les deux étiquettent, vérifier l'accord
        ai_label = ai_labeler.label(sample)
        human_label = human_labeler.label(sample)
        
        IF ai_label == human_label:
            label = ai_label
        ELSE:
            label = human_labeler.resolve(sample, ai_label)

Comparaison des approches

RLHF vs Constitutional AI

Quand utiliser lequel

Utiliser le RLHF quand :

• →Les enjeux élevés nécessitent un jugement humain
• →Les préférences sont subtiles ou culturelles
• →Vous devez capturer des normes implicites
• →Vous construisez les données d'entraînement initiales

Utiliser Constitutional AI quand :

• →Passage à l'échelle au-delà de la capacité d'annotation humaine
• →La cohérence est critique
• →Vous voulez un alignement auditable
• →Les principes peuvent être clairement articulés

Utiliser une approche hybride quand :

• →Vous avez besoin à la fois d'échelle et de nuance
• →Vous construisez des systèmes de production
• →L'amélioration continue est nécessaire

Limitations et défis

Limitations du RLHF

1. Piratage de récompense

Le modèle peut trouver des moyens d'obtenir des récompenses élevées sans être véritablement utile :

EXEMPLES DE PIRATAGE DE RÉCOMPENSE :
- Verbosité excessive (plus long = semble plus approfondi)
- Flagornerie (être d'accord avec l'utilisateur = meilleures notes)
- Hallucination confiante (la certitude obtient de bons scores)
- Évitement des sujets difficiles (prudent = meilleures notes)

2. Incohérence des préférences

Les annotateurs humains sont souvent en désaccord :

SOURCES DE DÉSACCORD DES ANNOTATEURS :
- Différents contextes culturels
- Différents niveaux d'expertise
- Fatigue et manques d'attention
- Critères d'évaluation ambigus
- Biais et valeurs personnels

3. Loi de Goodhart

Comme exploré dans la Partie 1, optimiser pour les scores du modèle de récompense finit par diverger des véritables préférences.

Limitations de Constitutional AI

1. Spécification des principes

Les principes peuvent être :

• →Trop vagues pour être appliqués de manière cohérente
• →Trop spécifiques pour être généralisés
• →En conflit dans les cas limites
• →Incomplets pour les situations nouvelles

2. Échecs de la critique IA

L'IA peut :

• →Ne pas reconnaître les préjudices subtils
• →Appliquer les principes de manière incohérente
• →Avoir des angles morts hérités de l'entraînement
• →Être trompée par des prompts nuisibles sophistiqués

3. Biais de conception de la constitution

Les principes eux-mêmes encodent les valeurs de leurs auteurs — il n'y a pas d'échappatoire au jugement humain, seulement un changement dans l'endroit où il intervient.

Développements récents (2024-2026)

Constitutional Classifiers (Anthropic, 2025)

La dernière avancée d'Anthropic utilise des principes constitutionnels pour entraîner des classificateurs spécialisés :

« Nous avons développé une nouvelle approche appelée Constitutional Classifiers qui a résisté à plus de 3 000 heures de red teaming sans qu'aucun jailbreak universel ne soit trouvé. »

Résultats clés :

• →99 %+ de contenu nuisible bloqué
• →Taux de faux positifs minimal sur les requêtes légitimes
• →Résistant aux techniques de jailbreak connues

RLOO (Reinforce Leave-One-Out)

Alternative à PPO, plus simple et parfois plus efficace :

Avantages de RLOO :

• →Pas de modèle de valeur séparé nécessaire
• →Entraînement plus stable
• →Résultats comparables ou meilleurs
• →Implémentation plus simple

Direct Preference Optimization (DPO)

Contourne entièrement l'entraînement du modèle de récompense :

Approche DPO :

• →Entraînement directement sur les paires de préférences
• →Pas de phase RL nécessaire
• →Pipeline plus simple
• →Résultats comparables au RLHF

Compromis :

• →✅ Implémentation plus simple
• →✅ Entraînement plus stable
• →❌ Moins flexible
• →❌ Difficile de mettre à jour les préférences facilement

Alignement multi-objectifs

Les systèmes modernes optimisent pour plusieurs objectifs simultanément :

Cibles de l'entraînement multi-objectifs :

• →Utilité
• →Innocuité
• →Honnêteté
• →Suivi d'instructions
• →Exactitude factuelle
• →Style/ton

Chaque objectif peut avoir son propre signal de récompense, combiné avec des poids appris ou réglés manuellement.

Implémentation pratique

Démarrer avec le RLHF

Pour les praticiens souhaitant implémenter le RLHF, plusieurs outils open source sont disponibles :

Hugging Face TRL

# TRL (Transformers Reinforcement Learning)
# https://github.com/huggingface/trl

PSEUDO-CODE : Configuration TRL de base

# 1. Charger le modèle de base
model = AutoModelForCausalLM.from_pretrained("base-model")
tokenizer = AutoTokenizer.from_pretrained("base-model")

# 2. Préparer le modèle de récompense
reward_model = AutoModelForSequenceClassification.from_pretrained(
    "reward-model"
)

# 3. Configurer l'entraîneur PPO
ppo_config = PPOConfig(
    learning_rate=1.4e-5,
    batch_size=256,
    mini_batch_size=64,
    gradient_accumulation_steps=1,
    ppo_epochs=4,
    max_grad_norm=0.5,
)

ppo_trainer = PPOTrainer(
    config=ppo_config,
    model=model,
    ref_model=None,  # Utilise une copie du modèle
    tokenizer=tokenizer,
    reward_model=reward_model,
)

# 4. Boucle d'entraînement
FOR batch in dataloader:
    # Générer les réponses
    response_tensors = ppo_trainer.generate(batch["input_ids"])
    
    # Calculer les récompenses
    rewards = reward_model(response_tensors)
    
    # Mise à jour PPO
    stats = ppo_trainer.step(batch["input_ids"], response_tensors, rewards)

Ressources clés

Implémenter l'auto-critique constitutionnelle

PSEUDO-CODE : Critique constitutionnelle simple

constitution = [
    "La réponse ne doit pas aider avec des activités illégales.",
    "La réponse ne doit pas contenir de stéréotypes nuisibles.",
    "La réponse doit reconnaître l'incertitude quand c'est approprié.",
    "La réponse doit être respectueuse et professionnelle.",
]

def critique_response(model, prompt, response):
    critiques = []
    
    FOR principle in constitution:
        critique_prompt = f"""
        Évaluez cette réponse par rapport au principe suivant :
        
        PRINCIPE : {principle}
        
        PROMPT ORIGINAL : {prompt}
        
        RÉPONSE : {response}
        
        Cette réponse viole-t-elle le principe ?
        Si oui, expliquez comment. Si non, dites "Aucune violation."
        """
        
        critique = model.generate(critique_prompt)
        
        IF "Aucune violation" not in critique:
            critiques.append({
                "principle": principle,
                "critique": critique
            })
    
    RETURN critiques

def revise_response(model, prompt, response, critiques):
    IF not critiques:
        RETURN response  # Pas de révision nécessaire
    
    revision_prompt = f"""
    La réponse suivante nécessite une révision basée sur ces critiques :
    
    PROMPT ORIGINAL : {prompt}
    
    RÉPONSE ORIGINALE : {response}
    
    CRITIQUES :
    {format_critiques(critiques)}
    
    Veuillez fournir une réponse révisée qui répond à toutes les critiques
    tout en restant utile.
    """
    
    revised = model.generate(revision_prompt)
    RETURN revised

FAQ

Q : Le RLHF est-il la même chose que le fine-tuning ? R : Non. Le fine-tuning (supervisé) enseigne au modèle à reproduire des sorties spécifiques. Le RLHF enseigne au modèle à produire des sorties qui obtiennent un score élevé sur une fonction de préférence apprise. Le RLHF s'appuie sur le fine-tuning — on fait typiquement un fine-tuning supervisé d'abord, puis le RLHF.

Q : Pourquoi utiliser PPO plutôt que des algorithmes RL plus simples ? R : PPO est stable et efficace en termes d'échantillons, ce qui est crucial quand chaque échantillon nécessite une inférence LLM coûteuse. Des algorithmes plus simples comme REINFORCE ont une variance élevée ; des algorithmes plus complexes comme TRPO sont coûteux en calcul. PPO atteint un bon compromis.

Q : Constitutional AI peut-il fonctionner sans aucun feedback humain ? R : En théorie, oui — l'article original a démontré un entraînement sans étiquettes humaines pour l'innocuité. En pratique, vous avez toujours besoin d'humains pour concevoir la constitution et vérifier qu'elle fonctionne comme prévu. Le jugement humain est anticipé plutôt qu'éliminé.

Q : Comment savoir si mon entraînement RLHF fonctionne ? R : Surveillez : (1) Les scores du modèle de récompense augmentent, (2) La divergence KL reste bornée, (3) Les évaluations humaines s'améliorent, (4) Pas de comportements de piratage de récompense. Si les récompenses montent en flèche mais la qualité baisse, vous êtes probablement victime de piratage de récompense.

Q : Quelle est la relation entre RLHF et sécurité ? R : Le RLHF est un outil pour l'alignement, mais pas une solution de sécurité complète. Il aide les modèles à suivre les préférences humaines, mais ces préférences peuvent être incomplètes ou incorrectement spécifiées. Le RLHF ne résout pas le détournement de spécification et ne garantit pas la robustesse face aux entrées adverses.

Q : De combien de données de feedback humain ai-je besoin ? R : InstructGPT a utilisé ~50 000 comparaisons de préférences. Les modèles plus petits peuvent en nécessiter moins ; les plus grands peuvent en nécessiter plus. La qualité compte plus que la quantité — des étiquettes cohérentes et de haute qualité provenant d'annotateurs formés surpassent de grandes quantités de données bruitées.

Conclusion

Le RLHF et Constitutional AI représentent nos meilleures approches actuelles pour enseigner les valeurs humaines aux systèmes d'IA. Ils ne sont pas parfaits — les deux peuvent être détournés, les deux encodent des biais, et les deux nécessitent une implémentation soigneuse. Mais ils améliorent considérablement la modélisation pure du langage.

Points clés à retenir :

1. →Le RLHF transforme la prédiction en préférence — Les modèles apprennent ce que les humains préfèrent, pas seulement ce qu'ils écrivent
2. →Le pipeline en trois étapes est standard — SFT → Modèle de récompense → Fine-tuning par RL
3. →Constitutional AI ajoute de la transparence — Des principes explicites au lieu de préférences implicites
4. →Le RLAIF permet l'échelle — Le feedback IA réduit les coûts d'annotation humaine
5. →Aucune des deux approches n'est complète — Les deux sont des outils, pas des solutions à l'alignement

Comprendre ces techniques est essentiel pour quiconque construit ou déploie des modèles de langage modernes. Elles sont le fondement sur lequel les pratiques actuelles de sécurité de l'IA sont construites.

📚 Série IA Responsable

← Précédent : Comprendre l'alignement de l'IA
Suivant → : Interprétabilité de l'IA avec LIME & SHAP

🚀 Prêt à maîtriser l'IA responsable ?

Nos modules de formation couvrent l'implémentation pratique des techniques de sécurité de l'IA, du prompt engineering à la gouvernance en production.

📚 Explorer nos modules de formation | Commencer le Module 0

Références :

• →Ouyang et al. (2022). Training language models to follow instructions with human feedback
• →Bai et al. (2022). Constitutional AI: Harmlessness from AI Feedback
• →Christiano et al. (2017). Deep Reinforcement Learning from Human Preferences
• →Schulman et al. (2017). Proximal Policy Optimization Algorithms
• →Hugging Face. RLHF: Reinforcement Learning from Human Feedback

Dernière mise à jour : 29 janvier 2026
Partie 2 de la Série Ingénierie IA Responsable