Que fait assistant-lab ?
Atelier d'auto-amélioration pour /assistant. C'est le laboratoire où
/assistant diagnostique les problèmes, entraîne de nouveaux modèles, les évalue,
et promeut les modèles réussis dans le registre en direct.
À ne pas confondre avec /monitor-skills qui est le démon d'observabilité
qui surveille TOUTES les compétences pour la santé, la dérive et les problèmes de synchronisation.
/assistant-lab est spécifiquement la boîte à outils d'auto-amélioration.
La Boucle d'Auto-Amélioration
/monitor-skills détecte un problème ← observabilité
↓
/assistant-lab diagnostique la cause racine ← cette compétence
↓
Mode ombre : l'enseignant (scillm) étiquette les flux dans shadow.jsonl
↓
ModelFactory.auto_improve(tâche)
├─ lit le taux d'accord de l'ombre
├─ >= 90 % : promouvoir → mettre à jour model_registry.json
├─ 80-90 % : plateau → /prompt-lab reconception
├─ 70-80 % : réentraîner → /create-gpt ou /create-classifier
└─ < 70 % : réentraînement agressif + changement d'architecture
↓
/gpt-lab benchmark ou /classifier-lab évaluation
↓ réussi ? → promouvoir dans le registre en direct
↓
/assistant utilise le modèle amélioré lors de l'inférence
Outils Disponibles
| Outil | Objectif | Quand l'utiliser |
|---|---|---|
/create-gpt | Entraîner QLoRA/SFT/GRPO GPT (Tier 1.5) | Accord < 80 % ou aucun modèle existant |
/create-classifier | Entraîner un classifieur DistilBERT/sklearn (Tier 0.5) | Tâches de classification de texte |
/create-regressor | Entraîner un régresseur sklearn/XGB (Tier 0.75) | Tâches de prédiction continue |
| RunPod Flash | Entraînement GPU serverless via SDK Python (7B–70B) | Modèle trop grand pour A5000 local — remplace /ops-runpod pour l'entraînement |
/gpt-lab | Benchmarker GPT par rapport à la référence de l'enseignant | Après l'entraînement, avant la promotion |
/classifier-lab | Évaluer la précision/F1 du classifieur | Après l'entraînement du classifieur |
/prompt-lab | Reconcevoir les invites lorsqu'un plateau est détecté | Accord bloqué à 80-90 % |
/scillm | Enseignant Tier 2 — crée les étiquettes | Toujours (l'enseignant est la vérité terrain) |
Utilisation
CLI
# Diagnostiquer ce dont une tâche a besoin
./run.sh diagnose --task stress-test-grader
# Boucle d'amélioration autonome complète
./run.sh auto-improve --task stress-test-grader
# Entraîner un type de modèle spécifique
./run.sh train --task stress-test-grader --type gpt
./run.sh train --task sparta-ambiguity --type classifier
# Évaluer un modèle
./run.sh evaluate --task stress-test-grader --type gpt
# Promouvoir un modèle réussi (désactive le mode ombre)
./run.sh promote --task stress-test-grader --type gpt
# Récolter les étiquettes de l'enseignant depuis shadow.jsonl
./run.sh harvest --task stress-test-grader --since 24h
# Afficher les statistiques d'accord de l'ombre pour toutes les tâches
./run.sh status
# Exécuter l'auto-test complet (cycle entraînement → évaluation → promotion sur données de test)
./run.sh self-test
API Python
from assistant_lab import AssistantLab
lab = AssistantLab()
# Diagnostiquer : de quoi cette tâche a-t-elle besoin ?
diagnosis = lab.diagnose("stress-test-grader")
# → {"has_gpt": False, "has_classifier": False, "shadow_agreement": 0.0, ...}
# Auto-amélioration : décider + entraîner + évaluer + promouvoir
result = lab.auto_improve("stress-test-grader")
# → {"actions": ["trained gpt", "evaluated (passing=True)", "promoted"]}
# Étapes manuelles
lab.train("stress-test-grader", model_type="gpt")
lab.evaluate("stress-test-grader", model_type="gpt")
lab.promote("stress-test-grader", model_type="gpt")
Fabrique de Modèles
Le moteur principal est ModelFactory (depuis /common/model_factory.py).
/assistant-lab l'enveloppe avec CLI + diagnostics + rapports.
Seuils d'Accord de l'Ombre
| Taux d'Accord | Action | Justification |
|---|---|---|
| >= 90 % | Promouvoir | L'élève correspond de manière fiable à l'enseignant |
| 80-90 % | /prompt-lab reconception | Plateau — les invites peuvent être le plafond |
| 70-80 % | Réentraîner avec plus d'étiquettes | Plus de données aident probablement |
| < 70 % | Réentraînement agressif | Changer d'architecture ou de modèle de base |
| < 50 échantillons | Attendre | Pas assez de données pour décider |
Données d'Entraînement Minimales (NON NÉGOCIABLES)
N'appelez PAS /create-gpt train ou /create-classifier train avec des données insuffisantes.
| Type de Modèle | Échantillons Minimaux | Règle |
|---|---|---|
| GPT (QLoRA SFT) | 1 000+ total | < 1 000 → reste à l'enseignant Tier 2 |
| Classifieur (sklearn/SetFit) | 200 par classe | n_échantillons / n_classes >= 200 |
| Régresseur | 100+ total | Directive sklearn standard |
Preuve : sparta_stress_grading a été entraîné sur 246 échantillons → 33,7 % d'accord.
Ce sont 4 mois d'étiquettes d'ombre gaspillés parce que le modèle a été entraîné trop tôt.
Collectez d'abord, entraînez quand vous êtes prêt.
Flux de Données d'Entraînement
Enseignant Tier 2 (scillm via persona)
↓ étiquettes sauvegardées dans shadow.jsonl
↓
/assistant-lab harvest --task X
↓ extrait les paires entrée+sortie
↓
/create-gpt train --task X --data labels.jsonl
↓ QLoRA sur Qwen2.5-1.5B (par défaut)
↓
/gpt-lab benchmark --task X
↓ compare l'élève vs l'enseignant
↓
/assistant-lab promote --task X --type gpt
↓ met à jour model_registry.json, shadow_mode=false
Entraînement à Distance (RunPod Flash)
Pour les modèles trop grands pour la RTX A5000 locale (24 Go VRAM, max ~1,7B avec LoRA),
assistant-lab utilise RunPod Flash — le SDK Python serverless sans Docker,
sans SSH et sans surcharge rsync. Flash remplace /ops-runpod pour tous les chemins
d'entraînement. /ops-runpod est conservé uniquement pour les serveurs d'inférence persistants.
Quand Utiliser Flash
| Taille du Modèle | A5000 Local | Flash Nécessaire | GPU |
|---|---|---|---|
| 0,5–1,7B | LoRA tient | Non | ./run.sh train (local) |
| 3–7B | Ne tient pas | Oui | B200 (préféré) ou H200 |
| 8–13B | Impossible | Oui | B200 (préféré) ou H200 |
Types de GPU Flash
| GPU | VRAM | Notes |
|---|---|---|
B200 | 192 Go HBM3e | Le plus rapide ; 3–5× H200 sur MoE / contexte long |
H200 | 192 Go HBM3 | Bonne disponibilité ; référence solide |
Facturation : à la seconde, exécution maximale de 7 jours par tâche.
Estimations de coût Flash (approximatives)
| Taille du Modèle | GPU | Temps d'Entraînement Estimé | Coût Estimé |
|---|---|---|---|
| 7B QLoRA SFT | B200 | ~1–2 h | ~5–15 $ |
| 7B QLoRA SFT | H200 | ~2–3 h | ~8–20 $ |
| 13B QLoRA SFT | B200 | ~2–4 h | ~10–25 $ |
| 13B QLoRA SFT | H200 | ~3–5 h | ~12–30 $ |
Commandes
# Étape 1 : Toujours estimer le coût d'abord
./run.sh estimate --task taxonomy-assessor --target flash --gpu B200 --size 7B
# Étape 2 : Entraîner sur Flash B200 (nécessite --confirm pour la sécurité)
./run.sh train --task taxonomy-assessor --target flash --gpu B200 --size 7B --confirm
# Entraîner sur Flash H200
./run.sh train --task taxonomy-assessor --target flash --gpu H200 --size 13B --confirm
# Avec un modèle de base personnalisé
./run.sh train --task taxonomy-assessor --target flash --gpu B200 --size 8B \
--base-model meta-llama/Llama-3.1-8B-Instruct --confirm
# Avec une quantification différente
./run.sh train --task qra-validator --target flash --gpu B200 --size 7B \
--quantize Q5_K_M --confirm
Pipeline d'Entraînement Flash
estimate --target flash --gpu B200 --size 7B
↓
train --target flash --gpu B200 --confirm
├─ 1. Estimation du coût + seuil budgétaire
├─ 2. Tâche Flash serverless soumise (SDK Python — pas de Docker/SSH)
├─ 3. Jeu de données diffusé vers le worker Flash
├─ 4. Entraînement QLoRA / SFT s'exécute sur B200/H200 (192 Go VRAM)
├─ 5. Poids du modèle récupérés dans /mnt/storage12tb/models/
├─ 6. create-gpt export --quantize Q4_K_M (GGUF)
└─ 7. Évaluer + promouvoir automatiquement si réussi
Barrières de Sécurité
- Plafond budgétaire :
--max-cost(par défaut 15,00 $) bloque l'entraînement si l'estimation dépasse la limite - Confirmation : Doit passer
--confirm— sans cela, affiche le coût et se termine - Arrêt automatique : La tâche Flash est annulée à la sortie (même en cas d'erreur, via trap)
- Journalisation des métriques : Chaque exécution d'entraînement Flash est enregistrée dans
lab_metrics.jsonl
Intégration avec la Boucle d'Auto-Amélioration
Les modèles entraînés à distance s'intègrent avec la même cascade que les modèles locaux :
Tier 0 : Heuristique (gratuit, instantané)
Tier 0.5 : Classifieur (local, gratuit)
Tier 1.5 : GPT local ≤1,7B (create-gpt, gratuit après entraînement)
Tier 1.5 : GPT distant 3-13B (train-remote, gratuit après entraînement) ← NOUVEAU
Tier 2 : scillm/DeepSeek V3 (Chutes, 0,12 $ / 1K appels)
Un modèle 7-13B au Tier 1.5 peut réduire considérablement les escalades vers Tier 2 (Chutes), potentiellement en remboursant son coût d'entraînement grâce à la réduction des dépassements.
Relations avec les Autres Compétences
/monitor-skills ──→ "la compétence X est malsaine"
↓
/assistant-lab ──→ diagnostiquer → entraîner → évaluer → promouvoir
↓
/assistant ──────→ utilise le modèle promu lors de l'inférence
/monitor-skills: Observe TOUTES les compétences. Détecte les problèmes. Rapporte la santé./assistant-lab: Corrige les modèles de /assistant. Entraîne, évalue, promeut./assistant: Exécute l'inférence. Utilise les modèles que le laboratoire a produits.
Contrat
- Entrée : Nom de la tâche + type de modèle optionnel
- Sortie : Diagnostic, résultats d'entraînement, résultats d'évaluation, statut de promotion
- Dépendances : model_factory.py (depuis /common), compétences create-* et *-lab
- Métriques : Ajoute à
~/.pi/assistant/lab_metrics.jsonl