Enseignant : générer des exercices

#Pourquoi préparer ses exercices avec un modèle local

Le cadre d'usage de l'IA en éducation publié par le ministère en juin 2025, tel que le résument les académies, autorise l'usage pour la préparation de cours, l'évaluation et la correction, avec deux obligations pour l'enseignant : vérifier systématiquement les productions de l'IA et être transparent sur leur utilisation. Il interdit formellement d'utiliser des données personnelles ou confidentielles dans les IA grand public, et invite à privilégier les solutions libres. Un modèle local répond à ces trois points : rien ne sort de l'ordinateur, aucune inscription n'est nécessaire, et les modèles open-weight sont des solutions libres au sens courant du terme.

Il faut nuancer un argument souvent avancé : préparer un exercice de mathématiques avec un service grand public reste permis tant qu'aucune donnée personnelle n'est saisie. L'intérêt du local se joue ailleurs. Il permet de travailler sur des documents contenant des noms, comme des copies ou des appréciations, sans exposer d'élèves. Il fonctionne sans connexion. Et il donne un comportement stable : une consigne sauvegardée, un modèle qui ne change pas d'un mois à l'autre.

Élèves et copies

Ne jamais saisir de nom, de copie identifiable ou d'appréciation dans un service en ligne. En local, le risque de transfert disparaît, mais la règle de minimisation reste une bonne habitude.

Coût

Aucun abonnement. Le matériel existe déjà si votre ordinateur récent dispose de 16 Go de mémoire ; sinon un petit modèle suffit pour les exercices simples.

Hors ligne

Utile en salle des professeurs ou dans un établissement dont le réseau filtre les services d'IA.

Stabilité

Une consigne sauvegardée dans un modèle personnalisé donne des fiches homogènes d'une semaine à l'autre.

#La pile minimale

Deux logiciels au choix pour servir le modèle : Ollama, en ligne de commande, ou LM Studio, avec une interface graphique plus accessible si le terminal vous rebute. Côté modèle, Qwen 3.5 en 9 milliards de paramètres pèse 6,6 Go dans la bibliothèque Ollama et annonce 256 000 tokens de contexte : il tient sur une carte de 8 Go ou dans la mémoire d'un ordinateur récent. Mistral Small 24B pèse 14 Go et demande plus de mémoire. Un modèle plus gros n'est pas une garantie d'exactitude ; c'est votre relecture qui l'est.

Pour ne pas retaper votre consigne, créez un modèle personnalisé avec un fichier Modelfile : l'instruction SYSTEM y définit le message système appliqué à chaque conversation. Le fichier ci-dessous fige le rôle, le niveau et le style de vos fiches.

FROM qwen3.5:9b
PARAMETER temperature 0.4
PARAMETER num_ctx 8192
SYSTEM """Tu aides un professeur de collège à préparer des exercices conformes aux programmes
français du cycle 4. Vocabulaire adapté à l'âge des élèves. Tu ne donnes que des
corrigés dont tu es sûr ; sinon tu écris : à vérifier. Tu n'inventes jamais de citation,
de date ou de source."""

ollama create prof-exos -f Modelfile
ollama run prof-exos

#Générer des QCM exploitables, pas seulement lisibles

Un QCM demandé en texte libre est difficile à réutiliser : il faut le retaper dans l'outil de la classe. Mieux vaut demander un format structuré, que le code contrôle ensuite. Ollama peut contraindre la réponse à un schéma JSON : d'après sa documentation, on le passe dans le champ format. Le modèle rédige les questions ; le script vérifie qu'il y a quatre choix distincts et une seule bonne réponse, puis écrit un fichier importable.

import json, requests, re

SCHEMA = {'type': 'object', 'properties': {'questions': {'type': 'array', 'items': {
  'type': 'object', 'properties': {
    'enonce': {'type': 'string'},
    'choix': {'type': 'array', 'items': {'type': 'string'}},
    'bonne_reponse': {'type': 'integer'},
    'explication': {'type': 'string'}},
  'required': ['enonce', 'choix', 'bonne_reponse', 'explication']}}},
  'required': ['questions']}

def generer(sujet, niveau, n=10, modele='prof-exos'):
    consigne = (f'Rédige {n} questions à choix multiple sur : {sujet}. Niveau : {niveau}. '
      'Quatre choix par question, dont un seul correct ; bonne_reponse est l\'indice (0 à 3). '
      'Les mauvais choix doivent être plausibles. Une phrase d\'explication. '
      'Réponds par un JSON conforme à : ' + json.dumps(SCHEMA))
    r = requests.post('http://localhost:11434/api/chat', json={
        'model': modele, 'stream': False, 'format': SCHEMA,
        'messages': [{'role': 'user', 'content': consigne}]})
    return json.loads(r.json()['message']['content'])['questions']

def valides(questions):
    ok, rejets, vus = [], [], set()
    for q in questions:
        c = q.get('choix', [])
        if (len(c) != 4 or len({x.strip().lower() for x in c}) != 4
                or q.get('bonne_reponse') not in (0, 1, 2, 3) or q['enonce'].strip().lower() in vus):
            rejets.append(q); continue
        vus.add(q['enonce'].strip().lower()); ok.append(q)
    return ok, rejets

def esc(s):
    return re.sub(r'([~=#{}:])', r'\\\1', s)

def vers_gift(questions):
    blocs = []
    for i, q in enumerate(questions, 1):
        lignes = [('=' if j == q['bonne_reponse'] else '~') + esc(c) for j, c in enumerate(q['choix'])]
        blocs.append(f"::Q{i}::{esc(q['enonce'])} {{\n" + '\n'.join(lignes) + '\n}\n')
    return '\n'.join(blocs)

Le format GIFT, utilisé par Moodle, est un fichier texte simple qui s'importe dans une banque de questions. Si votre établissement utilise un autre outil, adaptez la dernière fonction : le principe reste de produire un fichier depuis les données contrôlées, pas de copier-coller du texte du modèle. Ce que le script ne contrôle pas, c'est la vérité des questions : d'où la section sur la vérification.

#Ancrer chaque question sur un passage de votre cours

La méthode la plus sûre contre les faits inventés consiste à exiger, pour chaque question, le passage du cours qui la justifie. Vous collez votre texte, vous ajoutez au schéma un champ passage, et le script vérifie que ce passage existe mot pour mot dans le texte fourni. Une question dont le passage est introuvable est écartée : soit le modèle a inventé, soit il a paraphrasé sans source. Cette vérification ne prouve pas que la question est bonne, mais elle garantit qu'elle est fondée sur votre cours et non sur la mémoire approximative du modèle.

def normaliser(t):
    return ' '.join(t.split()).lower()

def ancrees(questions, cours):
    base = normaliser(cours)
    bonnes, douteuses = [], []
    for q in questions:
        (bonnes if normaliser(q.get('passage', '')) in base else douteuses).append(q)
    return bonnes, douteuses

Le schéma et la consigne se complètent en conséquence : ajoutez passage dans les propriétés et les champs requis, et écrivez dans la consigne « recopie mot pour mot le passage du texte qui justifie la bonne réponse ». Les questions sur des faits absents du cours, par exemple des dates jamais évoquées, ne passeront pas le filtre, ce qui est précisément le but.

#Exercices de mathématiques : Python calcule, le modèle habille

Un modèle de 9 milliards de paramètres se trompe sur des opérations simples, surtout avec des décimaux et des retenues. Pour des exercices de calcul, il vaut mieux inverser les rôles : le code tire les nombres au hasard, calcule le résultat exact et génère le corrigé ; le modèle sert à rédiger des énoncés de problème autour de ces nombres, ce qu'il fait bien. Ainsi, les réponses de vos fiches ne dépendent jamais de son arithmétique.

import random
from decimal import Decimal

def fr(d):
    return str(d.normalize() if d == d.to_integral() else d).replace('.', ',')

def exercices_decimaux(n=8, graine=None):
    hasard = random.Random(graine)
    sortie = []
    for i in range(n):
        nb = 2 if i < 2 else hasard.choice([3, 3, 4])
        vals = [Decimal(hasard.randint(10, 9999)) / hasard.choice([10, 100]) for _ in range(nb)]
        signes = ['+'] + [hasard.choice(['+', '-']) for _ in vals[1:]]
        total = sum(v if s == '+' else -v for v, s in zip(vals, signes))
        if total < 0:
            continue
        enonce = ' '.join((s + ' ' if k else '') + fr(v) for k, (v, s) in enumerate(zip(vals, signes)))
        sortie.append((enonce, fr(total)))
    return sortie

for e, r in exercices_decimaux(graine=42):
    print(e, '=', r)

La graine fixe permet de régénérer exactement la même fiche, par exemple pour produire la version corrigée le lendemain. Le même principe s'applique aux conversions d'unités, aux pourcentages, aux équations du premier degré, à tout ce qui se calcule : le code produit et vérifie, le modèle met en forme. Pour les langues, en revanche, le modèle est dans son domaine : il produit les phrases à compléter, les dialogues à trous et les consignes, qu'il faut relire.

Prépare pour des élèves de 5e (niveau A2 du CECRL) une fiche sur le present simple
et le present continuous : 5 phrases à conjuguer, 3 phrases à transformer, un court
dialogue à trous. Vocabulaire courant uniquement. Donne le corrigé à la fin, séparé
par une ligne « CORRIGÉ », et signale entre crochets toute phrase où les deux temps
sont possibles.

#Corrigés : demander, puis recouper

Le corrigé se demande dans un second message pour que le modèle garde l'énoncé en contexte, en précisant ce que vous attendez : la réponse finale, le raisonnement en étapes, la règle appliquée et l'erreur typique à éviter. Le corrigé est la partie la plus risquée de la fiche : un élève apprend la mauvaise réponse avec confiance. Deux pratiques réduisent le risque.

Calculer plutôt que faire calculer

Quand la réponse se calcule, prenez-la du code, pas du modèle.

Générer deux fois et comparer

Sur les exercices de raisonnement, demandez le corrigé deux fois, avec des consignes légèrement différentes. Si les réponses finales divergent, l'exercice est à revoir à la main.

Faire résoudre par un autre modèle

Un second modèle, de taille ou de famille différente, résout l'énoncé sans voir le corrigé. Le désaccord signale les erreurs probables. Ce n'est pas une preuve, seulement un filtre.

Relire tout ce qui sera distribué

Aucune vérification automatique ne remplace la lecture de l'enseignant, qui reste responsable du contenu.

#Adapter une fiche au niveau des élèves

La différenciation est l'usage où le modèle apporte le plus, car reformuler est sa force. Il suffit de partir d'une fiche validée et de demander des variantes, en gardant les mêmes nombres et les mêmes réponses pour que le corrigé reste valable. Faites relire la variante par un collègue avant de la diffuser : une reformulation plus simple peut modifier le sens d'un énoncé, ce qui est un défaut classique de ces réécritures.

#Vérifier la justesse, discipline par discipline

Le point commun est que le modèle écrit avec le même aplomb quand il a raison et quand il se trompe. Le cadre ministériel demande d'ailleurs une vérification systématique des productions de l'IA. Concrètement, prévoyez cinq minutes de relecture par fiche, et tenez un petit journal des erreurs trouvées : au bout d'un mois, vous saurez dans quelles disciplines le modèle est fiable pour vous.

#Un rythme de production réaliste

1. 01
   Lister les notions de la semaine

   Trois à cinq notions, avec les extraits de cours à utiliser comme source.
2. 02
   Générer à partir de vos sources

   Collez l'extrait de cours dans la consigne : les questions restent ancrées sur ce que vous avez enseigné.
3. 03
   Faire calculer les corrigés par le code

   Pour tout ce qui est chiffré, utilisez un script comme ci-dessus.
4. 04
   Relire et corriger

   Lisez la fiche comme le ferait un élève : une erreur de corrigé coûte cher.
5. 05
   Mettre en page et déclarer l'usage

   Exportez en PDF ou vers votre outil de classe, et indiquez aux élèves qu'une IA a aidé à préparer la fiche, conformément à l'exigence de transparence.

• Les bases du prompting
• Maîtriser les system prompts
• Ollama Modelfile : créer et personnaliser son modèle
• LM Studio pour débutants
• Limiter les hallucinations d'un LLM local
• Sorties JSON structurées avec Ollama

• Source : synthèse du cadre d'usage de l'IA en éducation (académie de Normandie)
• Source : cadre d'usage de l'IA en éducation (ministère)
• Source : le fichier Modelfile d'Ollama
• Source : sorties structurées d'Ollama
• Source : Qwen 3.5 dans la bibliothèque Ollama