Le défi de la recommandation pertinente d'exercices similaires

Les fonctionnalités traditionnelles de cahier d'erreurs se contentent souvent d'une correspondance basée sur des mots-clés pour proposer des exercices dits « similaires ». Cette approche superficielle conduit fréquemment à des recommandations inadéquates : exercices trop simples, trop complexes ou évaluant des concepts totalement différents de celui de l'erreur initiale. Pour un apprentissage efficace, il est crucial que les exercices recommandés partagent un noyau sémantique commun avec le problème erroné — structure similaire, points de connaissance identiques et niveau de difficulté comparable.

Le modèle Qwen3-Reranker-0.6B, avec ses 600 millions de paramètres, offre une solution précise à ce problème. Sa force réside dans sa capacité à analyser et comprendre la relation sémantique profonde entre une requête (le problème erroné) et une liste de documents (les candidats). Il effectue un réordonnancement intelligent, priorisant les exercices les plus pertinents pour un apprentissage ciblé.

Déploiement rapide du service de réordonnancement

Le déploiement d'un service basé sur Qwen3-Reranker-0.6B est conçu pour être simple, grâce à des images préconfigurées.

Configuration de l'environnement

Après avoir obtenu l'image du modèle, l'environnement s'exécute de manière autonome. Les étapes typiques dans le conteneur sont les suivantes :

cd /opt/qwen3-reranker
chmod +x launch_service.sh
./launch_service.sh

Alternativement, le serveur peut être démarré directement via Python :

python3 -m uvicorn main:app --host 0.0.0.0 --port 7860

Le chargement initial du modèle (environ 1.2 GB) prend entre 30 et 60 secondes. Une fois prêt, l'interface web est accessible via un navigateur sur le port configuré.

Utilisation de l'interface de démonstration

L'interface web propose trois champs principaux :

• Requête : à coller avec l'énoncé du problème erroné.
• Documents : la liste des exercices candidats, un par ligne.
• Instruction de tâche (optionnel) : une directive pour guider le modèle.

Cas d'application concrets

Scénario 1 : Géométrie - Calcul d'aire d'un triangle isocèle

Problème erroné : « Un triangle isocèle a une base de 10 cm et des côtés latéraux de 13 cm. Calculer son aire. »

Liste de candidats initiale :

1. Trouver l'aire d'un triangle isocèle de base 6 cm et de côté latéral 5 cm.
2. Démontrer que les angles à la base d'un triangle isocèle sont égaux.
3. Calculer l'aire d'un triangle de base 8 cm et de hauteur 6 cm.
4. Dans un traingle isocèle, la hauteur à la base vaut 12 cm et le côté latéral 13 cm. En déduire la longueur de la base.
5. Un triangle isocèle a un périmètre de 30 cm. Le côté latéral dépasse la base de 3 cm. Trouver les longueurs des côtés.

Instruction de tâche : « Étant donné un problème de mathématiques erroné, réordonner les exercices de pratique du plus pertinent au moins pertinent. La pertinence implique une structure de problème similaire, les mêmes points de connaissance et un niveau de difficulté approprié. »

Résultat probable du réordonnancement :

1. Trouver l'aire d'un triangle isocèle de base 6 cm et de côté latéral 5 cm. (Très pertinent : même type de problème, même méthode, données différentes).
2. Dans un triangle isocèle, la hauteur à la base vaut 12 cm et le côté latéral 13 cm. En déduire la longueur de la base. (Pertinent : concerne la hauteur et le côté, utilise le théorème de Pythagore, mais l'objectif final diffère).
3. Un triangle isocèle a un périmètre de 30 cm. Le côté latéral dépasse la base de 3 cm. Trouver les longueurs des côtés. (Partiellement pertinent : concerne le calcul des côtés, mais étend le champ des connaissances).
4. Calculer l'aire d'un triangle de base 8 cm et de hauteur 6 cm. (Faiblement pertinent : calcul d'aire générale, sans spécificité isocèle).
5. Démontrer que les angles à la base d'un triangle isocèle sont égaux. (Non pertinent : concept théorique, sans calcul).

Scénario 2 : Physique - Seconde Loi de Newton avec frottement

Problème erroné : « Un objet de 2 kg, posé sur un plan horizontal, est tiré par une force de 10 N formant un angle de 30° avec l'horizontale. Le coefficient de frottement est de 0,1. Calculer l'accélération. (g = 10 m/s²) »

Extrait de la liste de candidats :

• A : Calculer l'accélération d'un objet de 5 kg sur un plan horizontal sans frottement, soumis à une force horizontale de 20 N.
• B : Prouver la formule F = m·a.
• C : Comment trouver la force résultante sur un objet soumis à plusieurs forces ?
• D : Un objet de 2 kg glisse sur un plan incliné à 30°, avec un coefficient de frottement de 0,1. Calculer son accélération.

Analyse du réordonnancement : Le modèle identifie que le noyau du problème est « plan horizontal, force oblique, frottement, application de la seconde loi ». Il classera probablement l'exercice D en premier (bien que le cadre passe à un plan incliné, la complexité de l'analyse des forces, le calcul du frottement et l'application de la loi de Newton sont extrêmement similaires, constituant une excellente variante), suivi de C (connaissance préalable essentielle), puis de A (application simple mais sans frottement), et enfin de B (purement théorique).

Intégration via API dans une plateforme éducative

Pour une intégration dans le back end d'une application, une API est nécessaire. Voici un exemple d'appel Python.

import requests
import json

def réordonner_exercices(problème_erreur: str, liste_candidats: list[str], instruction: str = "") -> list[str]:
    """
    Appelle le service de réordonnancement et retourne les exercices triés par pertinence.
    """
    # Préparer le corps de la requête au format attendu par l'API
    documents_concaténés = "\n".join(liste_candidats)
    corps_requête = {
        "inputs": {
            "query": problème_erreur,
            "documents": documents_concaténés,
            "instruction": instruction
        },
        "parameters": {
            "top_k": 10  # Nombre maximum d'exercices à retourner
        }
    }
    
    url_api = "http://localhost:7860/rerank"
    
    try:
        réponse = requests.post(url_api, json=corps_requête, timeout=30)
        réponse.raise_for_status()
        données = réponse.json()
        
        # Extraire la liste ordonnée des documents pertinents
        if "ranked_documents" in données:
            return données["ranked_documents"]
        # En cas de format de réponse différent, retourner une liste vide
        return []
        
    except requests.exceptions.RequestException as erreur:
        print(f"Échec de l'appel API : {erreur}")
        # Retourner une liste vide en cas d'échec
        return []

# Exemple d'utilisation
erreur = "Un triangle isocèle a une base de 10 cm et des côtés latéraux de 13 cm. Calculer son aire."
candidats = [
    "Trouver l'aire d'un triangle isocèle de base 6 cm et de côté latéral 5 cm.",
    "Démontrer que les angles à la base d'un triangle isocèle sont égaux.",
    "Calculer l'aire d'un triangle de base 8 cm et de hauteur 6 cm."
]
directive = "Réordonner les exercices de géométrie pour un collégien, en se concentrant sur des problèmes de même nature et difficulté similaire."

exercices_tries = réordonner_exercices(erreur, candidats, directive)
print("Recommandations triées :")
for idx, exo in enumerate(exercices_tries, 1):
    print(f"{idx}. {exo}")

Architecture d'un pipeline de recommandation complet

Dans un système de production, la recommandation est un processus en chaîne :

1. Recouvrement grossier (Rappel) : À partir de l'erreur de l'élève, un moteur de recherche classique (type Elasticsearch) ou une recherche vectorielle récupère rapidement 100 à 200 exercices potentiels depuis la base de données. L'objectif est de ne rien oublier.
2. Classement fin (Réordonnancement) : Le modèle Qwen3-Reranker-0.6B prend en entrée l'erreur et la liste des candidats. Il évalue leur similarité sémantique profonde et les réordonne par score de pertinence.
3. Post-traitement : On sélectionne le Top 10 des résultats. On applique éventuellement une diversification pour éviter les exercices trop redondants et proposer différentes approches.
4. Présentation : Une sélection finale de 5 à 8 exercices optimale est présentée à l'élève.

def pipeline_recommandation(problème: str, niveau: str, matière: str) -> list[str]:
    # Étape 1 : Récupération de candidats par recherche traditionnelle
    candidats_bruts = recherche_par_mots_clefs(problème, matière, limite=150)
    
    # Étape 2 : Réordonnancement sémantique
    instruction = f"Réordonner les problèmes de {matière} pour un élève de {niveau}. Prioriser la similarité structurelle et la difficulté adaptée."
    candidats_ordonnés = appeler_reranker(problème, candidats_bruts, instruction)
    
    # Étape 3 : Sélection et diversification
    top_candidats = candidats_ordonnés[:20]
    recommandations_finales = appliquer_diversification(top_candidats, objectif=8)
    
    return recommandations_finales

Optimisation des performances

Ajustement de la taille des lots (Batch Size)

Le paramètre batch_size dans l'appel API ou la configuration du service contrôle le nombre de documents traités simultanément.

• Valeur par défaut (8) : Offre un bon équilibre entre vitesse et consommation mémoire.
• Augmenter (à 16 ou 32) : Sur un GPU avec suffisamment de VRAM, cela améliore le débit global.
• Diminuer (à 4 ou 2) : Pour éviter les erreurs de mémoire insuffisante (OOM) sur les ressources limitées.

Conception des instructions de tâche

Une instruction bien formulée améliore significativement la pertinence des résultats. Exemples pour le domaine éducatif :

• Renforcement d'un concept : « Pour un problème portant sur le théorème de Pythagore, classer les exercices par leur capacité à consolider ce théorème et la démarche de résolution associée. »
• Adaptation au niveau : « Pour un élève de terminale, trier ces problèmes de physique du plus pertinent au moins pertinent pour réviser les forces de Lorentz. »

Gestion du volume de documents

Bien que le modèle supporte de longs contextes (jusqu'à 32k tokens), il est optimal de limiter le nombre de documents par lot pour des raisons d'efficacité et de qualité. La pratique recommandée est de fournir entre 10 et 50 documents par appel API. Pour un pipeline complet, il est donc préférable de réaliser un pré-filtrage robuste pour ramener les candidats à un nombre gérable avant la phase de réordonnancement.