Formation à l’IA · Étude et ajustement de modèles de langage

• Un modèle de langage prédit la suite la plus probable d’une séquence de tokens en fonction d’un contexte.
• Ce type de modèle ne fonctionne pas comme une base de données et ne « connaît » pas des faits au sens humain du terme.
• Les erreurs et hallucinations sont une conséquence naturelle d’un système probabiliste de génération.
• Les notions clés de l’apprentissage profond (réseau, neurones, couches, rétropropagation, poids, paramètres, hyperparamètres) structurent la compréhension du fonctionnement.

À un niveau conceptuel, un réseau de neurones peut être décrit comme un système de transformation d’entrées en sorties :

• Les entrées sont des valeurs numériques (dans le cas du langage, des tokens encodés).
• Les couches cachées appliquent des transformations successives.
• Les sorties correspondent à une distribution de probabilité sur le token suivant, ou à une valeur de prédiction selon la tâche.

Les poids sont ajustés pour minimiser une fonction de perte. L’algorithme de rétropropagation calcule les gradients, puis une méthode de descente de gradient met à jour les poids.

Objectif : minimiser une perte L(θ) sur des données (x, y)
1) Calculer la prédiction ŷ = f(x; θ)
2) Calculer la perte L(θ) = perte(ŷ, y)
3) Calculer le gradient ∇θ L(θ)
4) Mettre à jour les paramètres : θ ← θ − η · ∇θ L(θ)
  où η est le taux d’apprentissage

Un modèle de langage génère une suite de tokens en suivant une distribution de probabilité conditionnelle au contexte. Lorsque le contexte est ambigu, incomplet, ou lorsque le modèle a appris des associations erronées, il peut produire une réponse qui paraît plausible mais qui ne correspond pas à un fait vérifiable.

Il faut donc traiter une sortie de modèle comme une proposition à vérifier, et non comme un résultat intrinsèquement exact.

• Le prompt est une spécification : rôle attendu, objectif, contraintes, format de sortie, exemples.
• Les approches de type chaîne de réflexion et enchaînement de prompts servent à stabiliser l’exécution d’une tâche complexe.
• La rétro-ingénierie de prompt part d’un résultat et infère les éléments de prompt qui ont produit ce résultat.

Chaîne de réflexion : demander explicitement au modèle de décomposer son raisonnement pour contrôler la conformité au prompt et détecter des sources de biais dans la génération.

Enchaînement de prompts : découper une tâche complexe en sous-tâches ordonnées. La sortie d’une étape devient l’entrée de l’étape suivante.

Étape 1 : diagnostiquer le besoin (lecture, compréhension, orthographe)
Étape 2 : choisir un niveau d’exercice adapté
Étape 3 : récupérer un exercice (appel de fonction)
Étape 4 : présenter l’exercice (consignes, exemple résolu)
Étape 5 : fournir un retour et proposer une question de suivi

La rétro-ingénierie de prompt renverse la logique : au lieu de concevoir le prompt pour obtenir une sortie, on part d’une sortie et l’on cherche à identifier les éléments du prompt qui l’ont produite. Une méthode pratique consiste à générer plusieurs sorties à partir d’entrées proches, puis à analyser les corrélations entre réponses (souvent entre cinq et vingt générations) afin d’inférer des composantes communes.

Référence mentionnée dans le support : Wu, Terry et Cai (2022), « AI Chains » (CHI).

• L’usage des modèles génératifs est massif côté étudiants. Les usages varient selon les filières et les attentes d’évaluation.
• Les usages côté personnels administratifs et enseignants existent mais sont moins généralisés, souvent par manque de temps, de formation, de cadre ou de confiance.
• Le principal enjeu n’est pas l’outil mais la capacité de cadrage : objectifs pédagogiques explicites, transparence des critères, et conception d’évaluations robustes.

Compétences et formation : la priorité est d’accompagner les étudiants pour qu’ils comprennent ce que l’outil fait, ce qu’il ne fait pas, et comment l’utiliser de manière responsable. Du côté des équipes pédagogiques, la formation doit être adaptée au temps disponible et au contexte disciplinaire.

Qualité des évaluations : il est préférable de concevoir des modalités d’évaluation qui valorisent le raisonnement, l’argumentation, la justification et la contextualisation, plutôt que de se reposer sur des tâches uniquement reproductibles.

Rapport au risque : l’enjeu n’est pas d’interdire, mais de définir des usages autorisés, d’identifier les zones à risque (tricherie, dépendance, biais, confidentialité), et d’outiller l’institution.

Dimensions écologiques et industrielles : la discussion évoque la matérialité des infrastructures (puissance de calcul, centres de données, coûts) et les arbitrages liés au déploiement à grande échelle.

• Brooks, R. « The Seven Deadly Sins of AI Predictions » (2017).
• Lepage, S. « Ce que les intelligences artificielles disent de nous » (France Culture, 2023).
• Klein, M. « Bring Your Own AI: The Rise of Shadow AI » (Wired, 2024).
• Bender, E. M. et Koller, A. « Climbing towards NLU: On Meaning, Form, and Understanding in the Age of Data » (ACL, 2020).
• Dwivedi, Y. K. et al. « So what if ChatGPT wrote it? Multidisciplinary perspectives on opportunities, challenges and implications of generative conversational AI for research, practice and policy » (International Journal of Information Management, 2023).
• Moorhouse, B. L. et Kohnke, L. « Using large language models in academic writing: a tool for outlining, paraphrasing, and summarizing » (Computers and Education: Artificial Intelligence, 2024).
• Chan, C. K. Y. et al. « The potential of ChatGPT for fostering critical thinking in education » (2024).
• Schmidt, J. « Artificial Intelligence: A Negative Externality » (2024).
• Griffin, D. « Research on the effects of AI in writing education: a review » (2024).

Remarque : certaines références existent sous plusieurs versions (prépublication, version revue). Il est conseillé de vérifier la version exacte utilisée dans votre bibliographie finale.

• Construire des indicateurs quantitatifs pour caractériser un texte (lisibilité, longueur, richesse lexicale).
• Comprendre le score de lisibilité de Flesch et le rôle des composants (mots, phrases, syllabes).
• Produire des signaux supplémentaires (fréquences lexicales, longueur moyenne des phrases, variance) utiles pour l’analyse ou la personnalisation.
• Introduire des notions probabilistes (marche aléatoire, mouvement brownien, distribution normale) comme outils de modélisation.

Le support introduit une forme discrète de marche aléatoire et le mouvement brownien comme modèle limite :

Marche aléatoire simple :
X_{n+1} = X_n + ε_n
où ε_n ∈ {−1, +1} est une variable aléatoire symétrique.

Mouvement brownien (définition qualitative) :
B(0) = 0
B(t) a des accroissements indépendants et stationnaires
B(t) est presque sûrement continu
et B(t) − B(s) suit une loi normale de moyenne 0 et de variance t−s, pour t > s

Ces notions servent ici principalement à donner un cadre mathématique à l’idée de bruit et de variabilité dans les données.

Références citées dans le support : Øksendal (2000) ; Engbert, Nuthmann, Richter et Kliegl (2005).

f(x) = (1 / (σ √(2π))) · exp( − (x − μ)² / (2σ²) )
μ : moyenne
σ : écart-type

La moyenne et la variance sont rappelées comme des statistiques descriptives de base.

• Structurer une base de données d’exercices (texte, consignes, type de dyslexie ciblée, niveau).
• Définir les champs nécessaires pour relier réponses d’élèves, profils et recommandations.
• Préparer le stockage des embeddings pour la recherche par similarité et la personnalisation.

Une base d’exercices utile doit répondre à des exigences pratiques :

• une structure stable (identifiants, niveaux, types, versions) ;
• des métadonnées exploitables (type d’exercice, compétences mobilisées, difficulté) ;
• des champs textuels propres (consignes, contenus) ;
• une stratégie de stockage des représentations vectorielles (embeddings) pour comparer ou recommander.

Le support indique un fichier de travail associé (lien interne). Dans cette version éditée, le lien est conservé tel qu’il apparaît dans le document source lorsqu’il est disponible.

• Créer des embeddings pour des textes, puis mesurer leur proximité via la similarité cosinus.
• Projeter des embeddings en deux dimensions pour visualiser des structures (UMAP, PCA).
• Utiliser un clustering hiérarchique (méthode de Ward) pour suggérer des regroupements de textes.
• Interpréter des distributions de similarité (histogrammes) et leurs implications.

sim(u, v) = (u · v) / (||u|| · ||v||)
où u et v sont des vecteurs (embeddings)

Une valeur proche de 1 indique des vecteurs très alignés (textes proches selon l’espace d’embedding), une valeur proche de 0 indique une faible relation linéaire, et une valeur négative indique une opposition.

• Chaque question produit un signal d’erreur combinant exactitude et similarité textuelle.
• Un score par profil de dyslexie est calculé par combinaison pondérée des erreurs observées.
• Les scores sont normalisés pour obtenir une distribution exploitable lors de la recommandation.
• Les embeddings peuvent aider à apparier un profil et une explication d’exercice adaptée.

On définit d’abord un indicateur d’exactitude, puis une mesure d’erreur textuelle :

Indicateur d’exactitude :
1_{exact} = 1 si la réponse correspond exactement à la réponse attendue, sinon 0

Erreur d’exactitude :
err_exact = 1 − 1_{exact}

Erreur textuelle (mesure basée sur une similarité ratio ∈ [0, 1]) :
text_err = 1 − ratio

Le signal d’erreur final par question combine les deux composantes :

r_j = 0.7 · err_exact + 0.3 · text_err

Pour chaque profil i, le score total est une somme pondérée des erreurs sur les questions posées :

S_i = Σ_{j ∈ questions_posées} w_{ij} · r_j

Contrainte sur les poids :
pour toute question j, Σ_i w_{ij} = 1

Enfin, une normalisation produit une distribution interprétable :

Si Σ_k S_k > 0 :
S̃_i = S_i / Σ_k S_k

Sinon (aucune erreur détectée) :
S̃_i = 1 / nombre_de_profils

Ces scores peuvent ensuite alimenter un module de recommandation d’exercices ou d’explications associées.

• Créer une base SQLite pour stocker exercices, explications, profils, questions et réponses.
• Ajouter des champs pour stocker des embeddings (vecteurs) et faciliter la recherche par similarité.
• Prévoir des index, puis adapter aux capacités réelles du moteur choisi.
• Introduire un exemple de composition de requêtes et d’insertion de données.

Le support fournit un schéma structuré pour relier profils, questions, réponses et exercices. Ci-dessous, un extrait réécrit pour être directement lisible et exécutable dans un contexte SQLite. Les types et index sont à ajuster si vous utilisez PostgreSQL ou un autre moteur.

-- SQLite : activer les clés étrangères
PRAGMA foreign_keys = ON;

-- Table des profils (types de dyslexie)
CREATE TABLE IF NOT EXISTS dyslexie_type (
 dyslexie_type_id INTEGER PRIMARY KEY,
 nom TEXT NOT NULL UNIQUE,
 description TEXT
);

-- Table des questions posées à l'élève
CREATE TABLE IF NOT EXISTS question (
 question_id INTEGER PRIMARY KEY,
 texte TEXT NOT NULL,
 reponse_attendue TEXT,
 niveau INTEGER
);

-- Lien question → profil avec un poids w_ij
CREATE TABLE IF NOT EXISTS question_profil_poids (
 question_id INTEGER NOT NULL,
 dyslexie_type_id INTEGER NOT NULL,
 poids REAL NOT NULL CHECK (poids >= 0.0),
 PRIMARY KEY (question_id, dyslexie_type_id),
 FOREIGN KEY (question_id) REFERENCES question(question_id),
 FOREIGN KEY (dyslexie_type_id) REFERENCES dyslexie_type(dyslexie_type_id)
);

-- Table des exercices
CREATE TABLE IF NOT EXISTS exercice (
 exercice_id INTEGER PRIMARY KEY,
 titre TEXT NOT NULL,
 consigne TEXT NOT NULL,
 niveau INTEGER,
 dyslexie_type_id INTEGER,
 FOREIGN KEY (dyslexie_type_id) REFERENCES dyslexie_type(dyslexie_type_id)
);

-- Table des réponses d'élèves (une réponse par question)
CREATE TABLE IF NOT EXISTS reponse_eleve (
 reponse_id INTEGER PRIMARY KEY,
 eleve_id TEXT NOT NULL,
 question_id INTEGER NOT NULL,
 reponse TEXT NOT NULL,
 date_reponse TEXT,
 FOREIGN KEY (question_id) REFERENCES question(question_id)
);

Pour exploiter des embeddings, deux approches sont courantes :

• Stocker le vecteur sous forme de tableau sérialisé (JSON) ou de blob binaire dans SQLite.
• Stocker l’embedding dans un système spécialisé (base vectorielle) et garder seulement les identifiants dans SQLite.

Le support s’oriente vers un stockage local simple. Un exemple minimal en JSON :

ALTER TABLE exercice ADD COLUMN embedding_json TEXT;

-- Exemple d'insertion (embedding fictif)
UPDATE exercice
SET embedding_json = '[0.12, 0.04, -0.31]'
WHERE exercice_id = 1;

Le support mentionne l’index GIN, qui est spécifique à PostgreSQL et généralement utilisé pour des index inversés (textes, tableaux, JSONB). Si l’objectif est une recherche sémantique par embeddings, il faut vérifier que l’infrastructure choisie est cohérente : SQLite seul ne fournit pas nativement une recherche vectorielle performante sans extension. En contexte de prototype, le compromis peut rester acceptable, mais il faut anticiper la montée en charge.