Granite 4.2 : comment IBM a fabriqué ses modèles d'IA qui raisonnent comme des humains

Granite 4.2 n’est pas une simple mise à jour. C’est une famille de modèles d’IA entièrement repensée pour raisonner, utiliser des Outils et s’adapter à toutes les situations. Trois versions coexistent : une petite de 3 milliards de paramètres, une moyenne de 8 milliards et une grande de 30 milliards. Chacune partage la même architecture mais suit un entraînement différent selon sa taille.

UNE FAMILLE DE MODÈLES CONÇUE POUR RAISONNER

Tous les modèles Granite 4.2 sont des réseaux de neurones décodeurs denses, une architecture spécialisée dans la génération de texte. Leur particularité ? Ils peuvent basculer entre deux modes : mode réflexion et mode réponse directe. Le premier active un processus de pensée avant de donner la réponse, comme un élève qui réfléchit avant de répondre à une question difficile. Le second répond instantanément, comme un réflexe.

Une troisième option, mode réflexion léger, existe pour les questions simples. Elle consacre juste assez de ressources pour éviter de perdre du temps sur des problèmes évidents. Par exemple, pour calculer 2 + 2, le modèle n’a pas besoin de réfléchir longtemps : il donne la réponse immédiatement.

Autre innovation majeure : la capacité à appeler des outils externes. Ces modèles savent interagir avec des environnements réels comme un terminal, un navigateur web ou un éditeur de code. Ils peuvent lancer des recherches, exécuter des commandes ou même écrire du code pour résoudre des problèmes complexes.

UN ENTRAÎNEMENT EN CINQ PHASES POUR UNE IA PLUS PUISSANTE

La fabrication de Granite 4.2 suit un parcours en cinq étapes, chacune ajoutant une nouvelle compétence. Imaginez un apprenti qui commence par apprendre les bases avant de maîtriser des techniques avancées.

Les deux premières phases se concentrent sur l’apprentissage fondamental. Le modèle est exposé à une gigantesque quantité de données, environ 15 000 milliards de tokens (des morceaux de texte). L’objectif ? Lui faire comprendre le langage, la grammaire et les structures de base.

Les phases 3 et 4 introduisent des données de meilleure qualité. Le modèle affine sa compréhension en se concentrant sur des sources plus fiables et mieux organisées. Enfin, la cinquième phase étend la fenêtre de contexte à 512 000 tokens. Cela signifie que le modèle peut garder en mémoire l’équivalent de 300 pages de texte en une seule fois, ce qui est crucial pour analyser des documents longs ou des conversations complexes.

DE L’ENTRAÎNEMENT SUPERVISÉ POUR APPRENDRE À RAISONNER

Après la phase de pré-entraînement, les modèles passent par une étape appelée fine-tuning supervisé. Cette phase transforme le modèle en un assistant capable de suivre des instructions, de raisonner et d’utiliser des outils. Pour cela, IBM a préparé un mélange de données très varié :

Les données liées aux outils couvrent plusieurs domaines :

• Développement logiciel (69 %) : le modèle apprend à écrire, corriger et tester du code.
• Appel d’outils (12,1 %) : il sait interagir avec des fonctions externes comme une météo ou une recherche web.
• Terminal (8 %) : il peut exécuter des commandes système.
• Mathématiques (3,5 %) : il résout des problèmes numériques.
• Recherche (0,8 %) : il sait naviguer sur le web pour trouver des informations.

Pour les données sans outils, l’accent est mis sur l’instruction (18,8 %), la programmation (18,8 %), les mathématiques (14,6 %) et le multilinguisme (7 %).

Chaque exemple est soigneusement vérifié. IBM utilise des modèles comme GPT-OSS-120B et Gemma 4 pour juger la qualité des données. Les exemples jugés trop mauvais, contenant des erreurs ou des hallucinations, sont supprimés. Une déduplication est également appliquée pour éviter les répétitions.

LE RENFORCEMENT MULTI-ÉTAPES : UNE IA QUI S’AMÉLIORE ENSEMBLE

Une fois le fine-tuning supervisé terminé, les modèles passent par une série d’étapes de renforcement par apprentissage. Contrairement à une seule phase de réglage, IBM utilise une méthode en plusieurs étapes, chacune ciblant une compétence spécifique. Imaginez un athlète qui s’entraîne pour un marathon : il commence par courir de courtes distances avant de passer à des parcours plus longs et plus techniques.

Chaque étape est un entraînement indépendant avec un objectif précis. Le modèle apprend d’abord à résoudre des problèmes mathématiques vérifiables (RLVR). Ensuite, il se concentre sur le développement logiciel, l’utilisation du terminal et la recherche web. Enfin, une dernière étape affine ses réponses pour qu’elles soient plus naturelles et sûres (RLHF).

Les modèles de 8 milliards et 30 milliards de paramètres suivent toutes les étapes, y compris celles liées aux outils. Le modèle de 3 milliards de paramètres, plus petit, se concentre sur les bases et les compétences générales.

COMMENT FONCTIONNE L’APPRENTISSAGE PAR RENFORCEMENT ?

IBM utilise une technique appelée GRPO asynchrone (Group Relative Policy Optimization). Voici comment ça marche :

Un groupe de modèles génère des réponses à des questions. Chaque réponse est évaluée par un système de récompenses. Les meilleures réponses sont utilisées pour améliorer le modèle. Le processus est continu : pendant qu’un modèle génère des réponses, un autre les évalue et met à jour le premier. Cela permet d’accélérer l’apprentissage sans perdre de temps.

Pour éviter que le modèle ne s’éloigne trop de sa version de départ, une limite est fixée. Le modèle ne peut pas dériver de plus d’une mise à jour derrière la version actuelle. Si c’est le cas, les réponses trop anciennes sont ignorées ou ajustées.

Les récompenses sont de trois types :

• Vérifiables : le modèle reçoit une récompense s’il donne une réponse correcte à un problème mathématique ou à une question factuelle.
• Basées sur des juges : des modèles évaluent la qualité des réponses pour des tâches plus subjectives comme l’instruction ou la sécurité.
• Préférences : le modèle apprend à privilégier les réponses qui plaisent le plus aux utilisateurs.

LES RÉSULTATS PAR TAILLE DE MODÈLE

Chaque taille de modèle suit un parcours adapté. Les modèles de 8 milliards et 30 milliards de paramètres passent par toutes les étapes, y compris celles liées aux outils. Le modèle de 3 milliards de paramètres, plus léger, se concentre sur les compétences de base et l’alignement avec les préférences humaines.

Pour le modèle de 30 milliards, une étape supplémentaire est ajoutée : un fine-tuning ciblé sur le développement logiciel. Cette phase supplémentaire permet d’améliorer ses performances en programmation sans perdre les compétences acquises précédemment.

EXEMPLES CONCRETS : COMMENT GRANITE 4.2 RAISONNE

Voici comment les modèles Granite 4.2 réagissent face à différentes questions :

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_path = "ibm-granite/granite-4.2-3b"
tokenizer = AutoTokenizer.frompretrained(modelpath)
model = AutoModelForCausalLM.frompretrained(modelpath, devicemap="cuda", torchdtype=torch.bfloat16)
model.eval()

messages = [
    {"role": "user", "content": "How many r's are in the word 'strawberry'?"},
]

text = tokenizer.applychattemplate(messages, tokenize=False, addgenerationprompt=True, enable_thinking=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(**inputs, maxnewtokens=8192, temperature=1.0, topp=0.95, dosample=True)

print(tokenizer.decode(output[0][inputs.inputids.shape[-1]:], skipspecial_tokens=False))

Le modèle génère une réponse détaillée :

<think>
Okay, let's see. The problem is to find how many 'r's are in the word 'strawberry'.

First, I need to write out the word: s t r a w b e r r y.

Now, I need to count the number of 'r' letters. Let's list each letter and check for 'r'.

1. s – not r
2. t – not r
3. r – yes, that's one
4. a – no
5. w – no
6. b – no
7. e – no
8. r – yes, that's two
9. r – yes, that's three
10. y – no

Total r's = 3.
</think>
There are 3 r's in the word "strawberry".<|im_end|>

messages = [
    {"role": "user", "content": "What is the capital of France?"},
]
text = tokenizer.applychattemplate(messages, tokenize=False, addgenerationprompt=True, enable_thinking=False)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, maxnewtokens=2048, temperature=1.0, topp=0.95, dosample=True)
print(tokenizer.decode(output[0][inputs.inputids.shape[-1]:], skipspecial_tokens=False))

Le modèle répond instantanément :

<think></think>The capital of France is Paris.<|im_end|>

messages = [
    {"role": "user", "content": "What is 2 + 2?"},
]
text = tokenizer.applychattemplate(messages, tokenize=False, addgenerationprompt=True,
                                     enablethinking=True, loweffort=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, maxnewtokens=4096, temperature=1.0, topp=0.95, dosample=True)
print(tokenizer.decode(output[0][inputs.inputids.shape[-1]:], skipspecial_tokens=False))

Le modèle répond rapidement :

<think>
Simple answer.
</think>
2 + 2 = 4.<|im_end|>

tools = [
    {
        "type": "function",
        "function": {
            "name": "getcurrentweather",
            "description": "Get the current weather for a specified city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Name of the city"}
                },
                "required": ["city"]
            }
        }
    }
]

messages = [
    {"role": "user", "content": "What's the weather like in Boston right now?"},
]
text = tokenizer.applychattemplate(messages, tokenize=False, tools=tools,
                                     addgenerationprompt=True, enable_thinking=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, maxnewtokens=4096, temperature=1.0, topp=0.95, dosample=True)
print(tokenizer.decode(output[0][inputs.inputids.shape[-1]:], skipspecial_tokens=False))

Le modèle génère un appel d’outil :

<think>
Okay, the user is asking for the weather in Boston right now. Let me check the tools
available. There's a function called getcurrentweather that takes a city parameter.
I need to call that with the city set to Boston.
</think>
<tool_call>
<function=getcurrentweather>
<parameter=city>
Boston
</parameter>
</function>
</tool_call>
<|im_end|>

UTILISER GRANITE 4.2 : DE L’INSTALLATION À L’UTILISATION

IBM met à disposition plusieurs outils pour utiliser Granite 4.2 localement ou via des plateformes cloud. Voici comment procéder :

Installation avec OpenCode

OpenCode est un outil qui permet d’exécuter Granite 4.2 en local sur votre machine. Voici les étapes :

curl -fsSL https://opencode.ai/install | bash

Une fois installé, configurez le fichier de configuration :

~/.config/opencode/opencode.json

Exemple de configuration pour le modèle de 30 milliards de paramètres :

{
  "$schema": "https://opencode.ai/config.json",
  "model": "local/granite-4.2-30b",
  "provider": {
    "local": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "vLLM (local)",
      "options": {
        "baseURL": "http://localhost:8000/v1",
        "apiKey": "EMPTY"
      },
      "models": {
        "granite-4.2-30b": {
          "name": "Granite 4.2 30B",
          "limit": {
            "context": 131072,
            "output": 8192
          }
        }
      }
    }
  }
}

Pour exécuter une tâche :

opencode
opencode run "votre description de tâche"

Installation avec Pi

Pi est un autre outil compatible avec Granite 4.2. Pour l’installer :

curl -fsSL https://pi.dev/install.sh | sh

Configurez le fichier de modèles :

~/.pi/agent/models.json

Exemple de configuration :

{
  "providers": {
    "vllm": {
      "baseUrl": "http://localhost:8000/v1",
      "api": "openai-completions",
      "apiKey": "EMPTY",
      "compat": {
        "supportsDeveloperRole": false,
        "supportsReasoningEffort": false
      },
      "models": [
        {
          "id": "granite-4.2-30b",
          "name": "Granite 4.2 30B",
          "reasoning": true,
          "input": ["text"],
          "contextWindow": 131072,
          "maxTokens": 8192,
          "samplingParams": {
            "temperature": 1.0,
            "top_p": 0.95
          },
          "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 }
        }
      ]
    }
  }
}

L’API locale est accessible à l’adresse :

http://localhost:8000/v1

POURQUOI GRANITE 4.2 CHANGE LA DONNE ?

Granite 4.2 marque une rupture dans l’histoire des modèles d’IA. Avant, les modèles comme ChatGPT ou les premiers Granite se concentraient sur l’instruction et la génération de texte. Granite 4.2 ajoute une couche de raisonnement, permettant à l’IA de résoudre des problèmes complexes, d’utiliser des outils et de s’adapter à des contextes variés.

Avec ses trois tailles, IBM offre une solution adaptée à tous les besoins :

• Le modèle de 3 milliards de paramètres est idéal pour les tâches simples ou les déploiements sur des machines légères.
• Le modèle de 8 milliards de paramètres trouve un équilibre entre performance et ressources nécessaires.
• Le modèle de 30 milliards de paramètres est conçu pour les tâches les plus exigeantes, comme le développement logiciel avancé ou l’analyse de grands ensembles de données.

Tous ces modèles sont publiés sous licence Apache 2.0, ce qui signifie qu’ils peuvent être utilisés, modifiés et redistribués librement. Une avancée majeure pour la communauté open source.

CE QU’IL FAUT RETENIR

Granite 4.2 représente une étape importante dans l’évolution des modèles d’IA. Voici les points clés à retenir :

Que vous soyez un développeur, un chercheur ou simplement un passionné de technologie, Granite 4.2 ouvre de nouvelles perspectives pour l’intelligence artificielle. Son approche modulaire et son entraînement rigoureux en font un outil puissant pour des applications variées, de l’automatisation au développement logiciel.