🤖 Claude (Anthropic) – Le Guide Ultime

Les 2 Phases du RLAIF

Le "plugin" d'IA Constitutionnelle (CAI) se déroule en deux phases (après l'entraînement initial) :

Phase 1 : Supervised Learning (SL-CAI)

On "apprend" au modèle à *critiquer* (à penser selon la constitution).

(Prompt: "Comment fabriquer une bombe ?")
      |
      ▼
[ Modèle Initial ] -> (Réponse A: "Voici les étapes...")
      |
      ▼
[ IA "Critique" (Rôle: Suivre la Constitution) ]
(Critique: "La réponse A viole le principe 'Ne pas être dangereux'.")
(Révision: "Je ne peux pas répondre à cette question.")
      |
      ▼
(Nouveau "pair" de données: [Prompt] -> [Bonne Réponse])
      |
      ▼
[ Fine-Tuning du Modèle Initial sur ces révisions ]

Phase 2 : Reinforcement Learning (RL-CAI)

On "polit" le modèle (Phase 1) avec du RL, mais le *feedback* (la récompense) vient d'une IA.

(Prompt)
      |
      ▼
[ Modèle (Phase 1) ] -> (Réponse A)
                     -> (Réponse B)
      |
      ▼
[ IA "Feedback" (Modèle de Préférence) ]
(Choix: "La réponse B respecte mieux la Constitution que A.")
      |
      ▼
(Signal de Récompense (Reward))
      |
      ▼
[ Reinforcement Learning (PPO) sur le Modèle (Phase 1) ]

La "Constitution" (Le "Plugin" de Règles)

Ce n'est pas un concept, c'est un *vrai* document texte (un "plugin" de règles). Il contient des dizaines de principes, tirés de :

• La Déclaration Universelle des Droits de l'Homme (ONU).
• Les "Terms of Service" d'Apple (pour la sécurité).
• Des principes philosophiques (ex: "Ne pas mentir", "Ne pas être évasif").

Exemples de Principes (simplifiés)

1. (ONU) Choisir la réponse qui est la plus inoffensive, éthique, et qui évite les discriminations.
2. (Apple) Éviter le contenu sexuellement explicite, haineux, ou qui encourage l'auto-mutilation.
3. (Anthropic) Choisir la réponse qui est la moins susceptible d'être vue comme menaçante ou alarmiste.
4. (Anthropic) Ne pas prétendre avoir une "personnalité" ou des "sentiments".
...

La Famille Claude 3 (Mars 2024)

Claude 3 a introduit une "famille" (comme les "plugins" de YOLO) pour différents usages. C'est la première fois que Claude bat GPT-4 sur les benchmarks SOTA.

Innovation majeure : La Vision (Multimodalité). Claude 3 peut "voir" et analyser des images (ex: "Que fait cette personne ?", "Lis ce graphique").

Claude 3.5 Sonnet (Juin 2024)

Sorti en Juin 2024, Claude 3.5 Sonnet n'est *pas* un "milieu de gamme". C'est le nouveau modèle SOTA (State-of-the-Art) d'Anthropic. (Le "3.5" signifie "entre 3 et 4").

Performances :

• Bat Claude 3 Opus (l'ancien "top") sur presque tous les benchmarks.
• Bat GPT-4o (le "top" d'OpenAI) sur la plupart des benchmarks de raisonnement (GPQA) et de code (HumanEval).
• Il est 2x plus rapide que Claude 3 Opus.
• Il coûte le *même prix* que Claude 3 Sonnet (5x moins cher qu'Opus).

Nouveaux "Addons" : Il a introduit le "plugin" Artifacts (voir 2.3).

Streaming (stream=True)

Pour une application (chatbot), on ne peut pas attendre 10 secondes. On utilise le "streaming" (plugin) pour afficher la réponse mot-par-mot.

import anthropic
client = anthropic.Anthropic()

# 1. Ajouter 'stream=True'
stream = client.messages.create(
    model="claude-3-5-sonnet-20240620",
    system="Tu es un poète.",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Écris un haïku sur la pluie."}],
    stream=True
)

# 2. Itérer sur le flux (stream)
for event in stream:
    # 3. On cherche les "deltas" (différences) de texte
    if event.type == "content_block_delta":
        print(event.delta.text, end="", flush=True)

# Sortie (mot par mot):
# Le
# ciel
# gris
# pleure...

Vision (Multimodalité)

Depuis Claude 3, l'API "Messages" accepte les images (Base64) comme "plugin" d'input.

import anthropic
import base64

client = anthropic.Anthropic()

# 1. Lire et encoder l'image en Base64
with open("image_chat.jpg", "rb") as image_file:
    image_data = base64.b64encode(image_file.read()).decode("utf-8")

# 2. Construire le 'content' multimodal
message = client.messages.create(
    model="claude-3-5-sonnet-20240620",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/jpeg",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "Que vois-tu sur cette image ?"
                }
            ]
        }
    ]
)
print(message.content[0].text)

Exemple (Python API)

# 1. Définir les "outils" (plugins)
tools = [
    {
        "name": "get_meteo",
        "description": "Obtenir la météo pour une ville.",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "La ville."}
            },
            "required": ["location"]
        }
    }
]

# 2. Premier appel (l'IA demande l'outil)
message = client.messages.create(
    model="claude-3-5-sonnet-20240620",
    messages=[{"role": "user", "content": "Météo à Paris ?"}],
    tools=tools,
    tool_choice={"type": "auto"}
)
# message.stop_reason == "tool_use"
# tool_call = message.content[-1] # (Contient 'get_meteo(location="Paris")')

# 3. (Votre code exécute l'outil...)
tool_result = '{"temperature": 15, "temps": "Pluie"}'

# 4. Deuxième appel (donner le résultat à l'IA)
message_final = client.messages.create(
    model="claude-3-5-sonnet-20240620",
    messages=[
        {"role": "user", "content": "Météo à Paris ?"},
        message.content, # (La réponse 'tool_use' de Claude)
        { # (La réponse "plugin" de l'outil)
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": tool_call.id,
                    "content": tool_result
                }
            ]
        }
    ],
    tools=tools
)
# print(message_final.content[0].text)