Scikit-LLM permet de classer des textes avec un modèle de langage sans constituer un vaste jeu de données ni entraîner un modèle dédié. Je montre comment distinguer zéro-shot et few-shot, puis préparer dans Google Colab un exemple de tickets d’assistance classés avec Groq.
Pourquoi utiliser le few-shot pour classer des textes ?
Le few-shot permet de classer des textes avec quelques exemples étiquetés, sans constituer un grand jeu de données ni entraîner un modèle dédié. C’est utile quand les catégories sont définies, mais que les données d’apprentissage manquent ou coûtent cher à annoter.
Dans un pipeline classique, il faut d’abord réunir un volume suffisant de textes, associer une catégorie à chacun, puis entraîner un modèle de classification. Cette approche fonctionne, mais elle demande des données représentatives et un travail de préparation important. Pour un cas d’usage spécialisé, les exemples pertinents peuvent être rares, et les nuances difficiles à formaliser dans des règles.
Entre nous, on le sait bien, faire appel à un consultant en automatisation intelligente et en agent IA, c’est souvent le raccourci le plus malin. On en parle ?
Comment utiliser Gemini 4 Argon dans n8n ?
Scikit-LLM intègre des modèles de langage pré-entraînés à l’interface familière de scikit-learn. On utilise notamment fit() pour fournir les informations nécessaires au classifieur, puis predict() pour attribuer une catégorie à de nouveaux textes. Dans une configuration few-shot, fit() ne réentraîne pas le modèle : les exemples servent de contexte à la classification.
La différence entre zéro-shot et few-shot tient aux exemples fournis. En zéro-shot, on transmet le texte à classer et la liste des catégories, sans exemple étiqueté. En few-shot, on ajoute quelques textes accompagnés de leur catégorie. Le modèle peut alors s’appuyer sur ces cas pour mieux interpréter la frontière entre les catégories.
C’est particulièrement utile dans un domaine spécialisé, où un terme technique peut avoir un sens précis ou où une nuance change la catégorie attendue. Quelques exemples choisis avec soin montrent au modèle comment ces catégories sont appliquées dans votre contexte. Vous adaptez ainsi la classification à votre tâche, sans réentraîner le modèle.
Comment préparer Google Colab et Groq ?
Comment passer un prototype IA en production SaaS ?
Je prépare Google Colab, j’installe Scikit-LLM et je configure l’API OpenAI-compatible de Groq via son endpoint officiel. La clé reste dans les secrets Colab, jamais dans une cellule du notebook.
Dans Colab, ouvrez l’onglet Secrets, ajoutez une entrée nommée GROQ_API_KEY, puis autorisez le notebook à y accéder. Installez ensuite les dépendances dans une cellule distincte.
%pip install -q scikit-llm openaiLe code suivant récupère le secret sans l’afficher. Il configure l’URL Groq utilisée par le SDK OpenAI et transmet la clé à l’interface de configuration de Scikit-LLM.
import os
from google.colab import userdata
key = userdata.get("GROQ_API_KEY")
if not key:
raise RuntimeError("Le secret GROQ_API_KEY est absent ou inaccessible.")
# L'OpenAI Python SDK utilise cette URL pour joindre Groq.
os.environ["OPENAI_API_KEY"] = key
os.environ["OPENAI_BASE_URL"] = "https://api.groq.com/openai/v1"
from skllm.config import SKLLMConfig
SKLLMConfig.set_openai_key(key)
Que faut-il savoir sur IQuest-Q1, le modèle MoE ?
Pour vérifier séparément que le compte Groq et le modèle fonctionnent, le client officiel OpenAI accepte explicitement base_url. Remplacez le nom du modèle par un modèle actuellement disponible dans votre compte Groq.
from openai import OpenAI
client = OpenAI(
api_key=key,
base_url="https://api.groq.com/openai/v1",
)
response = client.chat.completions.create(
model="llama-3.3-70b-versatile", # À adapter selon les modèles Groq disponibles.
messages=[{"role": "user", "content": "Réponds uniquement : OK"}],
max_tokens=10,
)
print(response.choices[0].message.content)Scikit-LLM expose SKLLMConfig.set_openai_key, mais la prise en charge de l’URL personnalisée dépend de la version installée et de la façon dont elle crée le client OpenAI. Les variables d’environnement fonctionnent si cette version s’appuie sur les paramètres par défaut du SDK. Si elle impose son propre client ou utilise une ancienne interface, vérifiez sa documentation et ses versions compatibles avant de poursuivre ; je ne suppose pas l’existence d’un paramètre Scikit-LLM pour l’URL. Gardez aussi en tête que les noms de modèles Groq évoluent.
Comment construire les exemples et les tickets ?
Je construis le jeu few-shot avec des exemples courts, représentatifs et étiquetés uniquement avec Matériel, Logiciel ou Accès. Les exemples servent de références au modèle : ils lui montrent comment associer un ticket à un libellé. Les tickets à prédire restent séparés et ne sont pas utilisés pendant l’apprentissage.
Quand choisir un RAG vectoriel ou un graphe ?
Le code prépare les textes et les étiquettes dans deux listes alignées, comme attendu par l’interface Scikit-LLM. Il stocke les trois tickets dans une liste distincte, prête à être passée à predict.
import os
from skllm import FewShotGPTClassifier
from skllm.config import SKLLMConfig
# La clé API est lue depuis une variable d’environnement.
SKLLMConfig.set_openai_key(os.environ["OPENAI_API_KEY"])
# Exemples few-shot : chaque texte est associé à un libellé cohérent.
exemples = [
("L’écran du poste reste noir au démarrage.", "Matériel"),
("Le clavier ne répond plus.", "Matériel"),
("L’application de messagerie plante à l’ouverture.", "Logiciel"),
("Le tableur affiche une erreur au lancement.", "Logiciel"),
("Je n’arrive plus à me connecter à mon compte.", "Accès"),
("Mon compte est bloqué après plusieurs tentatives.", "Accès"),
]
# Scikit-LLM reçoit les textes et les libellés dans deux listes alignées.
X_train = [texte for texte, libelle in exemples]
y_train = [libelle for texte, libelle in exemples]
# Ces tickets sont distincts des exemples et destinés à la prédiction.
tickets = [
"Le portable ne charge plus, même branché.",
"Le navigateur se ferme dès que je l’ouvre.",
"Je n’ai pas les droits pour accéder au dossier partagé.",
]
# Le modèle apprend les associations, puis classe les nouveaux tickets.
classifieur = FewShotGPTClassifier(model="gpt-4o-mini")
classifieur.fit(X_train, y_train)
predictions = classifieur.predict(tickets)
for ticket, prediction in zip(tickets, predictions):
print(f"{prediction} : {ticket}")Les libellés des exemples définissent les catégories que le modèle peut renvoyer. Gardez-les strictement identiques, y compris dans leur orthographe : une variante comme « Logiciels » créerait une classe différente. Les trois tickets couvrent ici une panne physique, un dysfonctionnement applicatif et un problème de droits, sans ajouter de catégorie métier.
Le modèle utilisé doit être disponible pour votre compte API. L’installation de Scikit-LLM et la variable d’environnement OPENAI_API_KEY sont nécessaires à l’exécution.
Comment lancer la classification avec Scikit-LLM ?
Pour lancer la classification, j’instancie FewShotGPTClassifier, je lui passe les textes et leurs étiquettes avec fit(), puis je soumets les trois tickets à predict(). Les exemples servent de contexte à la prédiction : ils ne modifient pas les poids du modèle. fit() prépare donc les exemples few-shot, il ne réalise pas un entraînement traditionnel.
Le code reprend la signature documentée avec le paramètre openai_model. La version de Scikit-LLM du chapitre précédent n’étant pas précisée ici, vérifiez que cette signature existe dans votre installation. Le nom du modèle doit aussi être disponible pour votre compte. Les identifiants API doivent être configurés avant l’exécution.
from skllm import FewShotGPTClassifier
# Remplacez ces exemples par le jeu étiqueté du chapitre précédent.
X_exemples = [
"Je ne reconnais pas le prélèvement sur ma facture.",
"L'application affiche une erreur au démarrage.",
"Je souhaite modifier l'adresse e-mail de mon compte.",
"Ma facture contient un montant incorrect.",
]
y_exemples = [
"facturation",
"incident_technique",
"gestion_compte",
"facturation",
]
# Remplacez ces tickets par les trois tickets préparés précédemment.
X_tickets = [
"Impossible de me connecter depuis la dernière mise à jour.",
"Je veux contester les frais ajoutés à ma facture.",
"Comment changer mon adresse e-mail ?",
]
clf = FewShotGPTClassifier(openai_model="gpt-4o-mini")
clf.fit(X_exemples, y_exemples)
predictions = clf.predict(X_tickets)
for ticket, etiquette in zip(X_tickets, predictions):
print(f"{etiquette} — {ticket}")
Les deux listes d’exemples doivent être alignées : chaque texte de X_exemples correspond à l’étiquette placée au même index dans y_exemples. predict() renvoie une étiquette par ticket, dans le même ordre que les entrées. Il ne faut pas supposer que les catégories sont toujours prédites correctement : les exemples doivent être représentatifs et les libellés cohérents.
Entrées : des textes étiquetés pour le contexte, puis trois tickets à classer. Sorties : trois étiquettes prédites, une par ticket.
Le few-shot répond-il à votre besoin de classification ?
Scikit-LLM rend la classification par modèle de langage accessible avec une interface familière à celles et ceux qui utilisent scikit-learn. Le zéro-shot convient quand les catégories suffisent à guider le modèle ; le few-shot ajoute quelques exemples étiquetés pour mieux orienter les cas spécialisés, sans réentraîner le modèle. Avec Google Colab, une clé Groq stockée dans les secrets et FewShotGPTClassifier, on peut tester le principe sur des tickets classés en Matériel, Logiciel et Accès. Le point décisif reste la qualité des exemples et la vérification de la configuration API utilisée. Vous pouvez ainsi évaluer rapidement une approche de classification sans monter d’emblée un vaste jeu d’entraînement.
FAQ
-
Qu’est-ce que la classification few-shot ?
Elle consiste à fournir au modèle quelques exemples de textes déjà associés à des catégories pour guider la classification de nouveaux textes. -
Quelle différence entre zéro-shot et few-shot ?
En zéro-shot, le modèle reçoit le texte et les catégories sans exemple. En few-shot, on lui ajoute quelques exemples étiquetés. -
Pourquoi utiliser le few-shot pour un domaine spécialisé ?
Quelques exemples peuvent aider à orienter le modèle face à des termes techniques ou à des nuances propres au domaine, sans réentraîner le modèle. -
À quoi sert Scikit-LLM dans ce workflow ?
Scikit-LLM intègre des modèles pré-entraînés dans une interface familière de type scikit-learn, avec notamment les méthodes fit() et predict(). -
Comment configurer Groq dans Google Colab ?
Le workflow utilise l’API compatible OpenAI de Groq. La clé API doit être enregistrée dans les secrets de Colab, puis récupérée dans le notebook pour configurer l’accès.
A propos de l’auteur
Franck Scandolera est expert en data engineering et en automatisation IA. Il conçoit des workflows et des applications métier intelligentes, notamment autour de l’exploitation des modèles de langage pour traiter et classer des données textuelles.
⭐ Data Analyst, Analytics Engineer et expert dans l’automatisation IA ⭐
Ref clients : Logis Hôtel, Yelloh Village, BazarChic, Fédération Football Français, Texdecor…
Mon terrain de jeu :
Data Analyst & Analytics engineering : tracking propre RGPD, entrepôt de données (GTM server, BigQuery…), modèles (dbt/Dataform), dashboards décisionnels (Looker, SQL, Python).
Automatisation IA des taches Data, Marketing, RH, compta etc : conception de workflows intelligents robustes (n8n, Make, App Script, scraping) connectés aux API de vos outils et LLM (OpenAI, Mistral, Claude…).
Engineering IA pour créer des applications et agent IA sur mesure : intégration de LLM (OpenAI, Mistral…), RAG, assistants métier, génération de documents complexes, APIs, backends Node.js/Python.