Pipeline AutoML + DEFT

Une skill de pont de flux de travail qui exécute trois phases en séquence en déléguant à deux skills existants — tao-run-automl pour l'HPO et une skill d'application DEFT (par défaut tao-run-deft-aoi pour AOI ; autres skills skills/applications/deft-* pour les cas non-AOI) pour la boucle d'amélioration itérative des données.

Cette skill ne réimplémente pas AutoML ou DEFT. Elle ne possède que le tissu conjonctif : les entrées de spec HPO, le transfert de spec entre AutoML et DEFT, et la réexécution AutoML post-DEFT sur le dataset augmenté.

Quand cette skill s'applique

L'utilisateur demande d'« exécuter le flux de travail AOI » ou d'« améliorer mon modèle ChangeNet AOI » — utiliser par défaut cette skill, pas tao-run-deft-aoi directement. La boucle DEFT simple est l'étape interne de ce pipeline.
L'utilisateur veut AutoML et DEFT chaînés sur le même modèle/dataset
L'utilisateur dit « AutoML aux deux extrémités », « affiner les HPs puis DEFT », « warm-start DEFT », « AutoML avant et après DEFT »
L'utilisateur a une spec réglée par AutoML et demande comment la transmettre à DEFT

Quand cette skill ne s'applique PAS

L'utilisateur demande explicitement la boucle DEFT seule (« exécuter JUSTE la boucle DEFT », « ignorer AutoML ») → utiliser tao-run-deft-aoi directement
L'utilisateur veut seulement AutoML sans DEFT ultérieur → utiliser tao-run-automl directement
L'utilisateur fait de l'éval zero-shot, RAG, ou des flux de travail non-entraînement

Le modèle conceptuel

Phase 1 (baseline AutoML)        Phase 2 (boucle DEFT, train simple)        Phase 3 (affinage AutoML)
──────────────────────────        ─────────────────────────────────────        ─────────────────────────
specs/baseline_spec.yaml         (le gagnant Phase 1 pré-initialise          ${RESULTS_DIR}/iter${N}/dataset/
train/base/training_set.csv       le baseline — DEFT ignore son train         train_combined_iter${N}.csv
        │                          baseline)
        │                                       │                                       │
        ▼                                       ▼                                       ▼
[ Balayage HPO AutoML ]            [ DEFT : inférence baseline → RCA       [ Balayage HPO AutoML ]
   N recommandations                 → iter 1..N (retrain simple) ]        ré-accorde les HPs contre
   sélectionner la meilleure        RCA / routage / SDG / mining            le dataset augmenté DEFT
   par val_loss / FAR                       │                                       │
        │                                   ▼                                       ▼
        ▼                                                                    point de contrôle final
HPs spec meilleurs + ckpt ─────►      CSV augmenté DEFT ───────────►      (le livrable ; pas
                                     + point de contrôle iter winner       de retrain ultérieur)
                                     (Phase 3 warm-start à partir)

Les transferts sont :

Phase 1 → Phase 2 : un fichier spec ET le point de contrôle gagnant. Au lieu de réentraîner les mêmes HPs à l'étape baseline de DEFT, pré-initialiser l'état baseline de DEFT à partir des sorties Phase 1 pour que DEFT commence à inférence baseline → évaluer → RCA → iter 1. Les quatre étapes — écrire la baseline_spec_automl.yaml fusionnée, copier le point de contrôle gagnant dans ${RESULTS_DIR}/baseline/train/ sous le nom que DEFT attend, initialiser deft_state.json avec iterations.baseline.stage_completed == "train" (et ajouter l'entrée loop_log.jsonl correspondante), puis invoquer DEFT — sont données verbatim avec le code exact dans references/handoff.md. automl_policy: off à l'intérieur de la boucle est conservé.
Phase 2 → Phase 3 : un CSV d'entraînement ET le point de contrôle gagnant de l'iter. Le CSV (train_combined_iter${N_final}.csv) sont les données d'entraînement d'AutoML ; le point de contrôle (iterations.<best>.best_ckpt_path de deft_state.json) est câblé dans le train.pretrained_model_path de chaque rec pour que Phase 3 fine-tune à partir du gagnant Phase 2 plutôt que de zéro. Sans ce warm-start la Phase 3 régresse couramment par rapport au gagnant iter. Le point de contrôle gagnant Phase 3 est le livrable — pas de retrain séparé après Phase 3. Voir references/handoff.md.

Pourquoi trois phases au lieu de deux

Phase 1 seule trouve de bons HPs sur la distribution d'entraînement d'origine, mais le modèle a toujours les écarts distributionnels que DEFT est conçu pour combler.
Phase 2 seule (juste DEFT) comble les écarts mais utilise les HPs que specs/baseline_spec.yaml a été rédigé à la main avec — généralement pas optimal.
Phase 3 seule exécuterait AutoML contre le dataset augmenté, mais sans baseline accordée le coût d'itération de la boucle DEFT est plus élevé (convergence plus lente, plus d'itérations pour atteindre le KPI).

Exécuter les trois : AutoML accorde bon marché une fois sur les données d'origine, DEFT fait le travail de données lourd avec des HPs raisonnables, puis AutoML accorde à nouveau sur le dataset maintenant plus riche. Phase 3 est la plus importante des trois pour le FAR/rappel final en déploiement.

Coût initial

Le pipeline est séquentiel. Wall-clock total ≈ Phase 1 (N_automl × train par rec) + Phase 2 (M itérations × coût par iter) + Phase 3 (N_automl × train par rec).

Notez que Phase 2 n'a pas de train baseline séparé — le point de contrôle gagnant Phase 1 est réutilisé comme baseline de DEFT, le coût baseline s'inscrit donc dans les N_automl d'entraînements Phase 1 plutôt que comme un retrain supplémentaire. Exposer cela à l'utilisateur avant le démarrage. Généralement les itérations Phase 2 dominent toujours (chacune inclut SDG + retrain), mais Phase 1 et Phase 3 ajoutent chacune plusieurs heures sur une boîte mono-GPU. Utiliser l'estimation par job depuis la configuration de l'utilisateur (s'il en a une) plutôt que de deviner des minutes. Voir references/pitfalls.md pour la répartition des coûts par phase.

Pré-vol consolidé — une seule porte, les trois phases

Le pipeline a exactement une porte utilisateur. Avant toute action ayant des effets (docker pull, docker login, tout appel de lancement de job délégué à une skill en aval, mutations de fichiers sous ${RESULTS_DIR}/), l'agent doit produire un seul Résumé de Pré-vol Consolidé qui subsume le pré-vol de chaque skill en aval. Une fois l'utilisateur approuve, la run est autonome à travers les trois phases — pas de pauses interactives ultérieures.

L'utilisateur n'a explicitement pas envie d'être sollicité entre les phases. La propre porte ## Pre-Flight Summary en ligne de la boucle DEFT devient une étape d'affichage zéro-question (chaque valeur pré-fournie), tout comme le pré-vol de lancement partagé d'tao-run-automl dans les Phases 1 et 3.

Avant d'imprimer la porte, l'agent doit lire chaque section de pré-vol en aval en entier et exécuter chaque vérification en lecture seule que ces sections prescrivent, exposant chaque résultat dans le résumé. Exécuter chaque étape du ## Pre-Flight de la skill DEFT est obligatoire — si une étape est ignorée le pré-vol consolidé est invalide et le pipeline ne doit pas avancer. Le résumé doit inclure, dans l'ordre : (1) espace de travail/hôte/plateforme/réseau, (2) statut des credentials DÉFINI/NON DÉFINI, (3) URIs d'images conteneur résolues avec PRÉSENT/MANQUANT, (4) tableau de dataset avec vérification de fuite, (5) config Phase 1, (6) config Phase 2 incl. source baseline pré-initialisée, (7) config Phase 3, (8) estimation de calcul, (9) la ligne de confirmation. Après la porte, passer chaque valeur collectée à chaque skill en aval pour qu'elle n'ait rien à demander. Les seules pauses post-porte autorisées sont les portes de sécurité d'arrêt dur en exécution (p. ex. porte de régression KPI de DEFT) ; les appeler dans le résumé.

Voir references/preflight.md pour la procédure complète de construction, le contenu exact obligatoire de chaque section résumé (avec la règle empirique de mémoire GPU, les défauts de boucle DEFT, et les entrées requises verbatim), les entrées de suppression de porte en aval, et le repli quand une version skill-bank plus ancienne code en dur sa propre porte STOP.

Phase 1 — Baseline AutoML

Invoquer tao-skill-bank:tao-run-automl avec :

Entrée	Défaut AOI	Notes
`network_arch`	`visual-changenet`	Même modèle que la boucle DEFT attend
`train_dataset_uri`	`<workspace>/train/base/training_set.csv`	Même ensemble d'entraînement par lequel DEFT commencera
`eval_dataset_uri`	`<workspace>/train/base/validation_set.csv`	Retenu — ne DOIT PAS être l'ensemble de test KPI (`<workspace>/kpi/testing_set.csv`), puisque cet ensemble est réservé pour le rapport final de DEFT
`metric`	FAR @ 100% de rappel (préféré) ou `val_loss`	Voir `references/pitfalls.md` — ChangeNet AOI est déséquilibré en classe, `val_loss` seul peut mode-collapse
`algorithm`	`bayesian`	Cerveau LLM ou `autoresearch` si le calcul est serré
`automl_max_recommendations`	5–10 pour AOI	Plus de recs = meilleurs HPs mais linéaire en calcul
`spec_overrides`	Épingler les epochs / batch_size ; balayer seulement les HPs liés à l'optimizer	Sinon AutoML erre dans les régimes d'entraînement long qui dépassent le budget Phase 2

Après la fin du balayage, le result["best"]["specs"] d'AutoML est le dict hyperparamètre gagnant.

Transfert vers Phase 2

Phase 1 transmet deux artefacts : la spec gagnante et le point de contrôle gagnant. Au lieu de réentraîner les mêmes HPs à l'étape baseline de DEFT, pré-initialiser l'état baseline de DEFT à partir des sorties Phase 1 pour que DEFT commence à inférence baseline → évaluer → RCA → iter 1. Les quatre étapes — écrire la baseline_spec_automl.yaml fusionnée, copier le point de contrôle gagnant dans ${RESULTS_DIR}/baseline/train/, initialiser deft_state.json avec iterations.baseline.stage_completed == "train" (et ajouter l'entrée loop_log.jsonl correspondante), puis invoquer DEFT — sont données verbatim avec le code exact dans references/handoff.md. automl_policy: off à l'intérieur de la boucle est conservé.

Vérification de qualité avant transfert

Exécuter une éval rapide du point de contrôle gagnant contre l'ensemble retenu : comptages de prédiction par classe (s'il s'est effondré à une classe, évaluer le 2e ou 3e meilleur à la place) et une comparaison à un baseline ChangeNet zero-shot (si AutoML n'a pas amélioré par rapport au zero-shot, l'exposer et faire une pause). Voir references/handoff.md.

Phase 2 — Boucle DEFT (train simple, baseline pré-initialisée depuis Phase 1)

Invoquer tao-skill-bank:tao-run-deft-aoi (lire son SKILL.md pour l'interface complète). Pour les applications non-AOI, invoquer la skill DEFT correspondante ; la forme de transfert est la même.

L'étape baseline-train de la boucle DEFT est ignorée. Phase 1 a déjà produit un point de contrôle entraîné aux HPs gagnants, et le transfert Phase 1 (voir ci-dessus) a pré-rempli ${RESULTS_DIR}/baseline/train/ et ${RESULTS_DIR}/deft_state.json pour que DEFT reprenne à inférence baseline → évaluer → RCA → iter 1. Le reste de la boucle DEFT s'exécute inchangé. Ne pas modifier son invariant automl_policy: off.

La boucle DEFT possède :

L'étape d'affichage du Résumé de Pré-vol — pas une nouvelle porte utilisateur. Le Pré-vol Consolidé (ci-dessus) est la seule porte ; le résumé DEFT s'affiche toujours comme une trace d'audit de la source baseline/train/ pré-initialisée mais ne doit pas re-demander, puisque chaque entrée a été collectée dans la porte consolidée.
Inférence baseline → évaluer → RCA sur le point de contrôle pré-initialisé, et le cycle complet par itération RCA → routage → SDG → mining → assemblage → train.
Gating KPI et conditions d'arrêt ; layout ${RESULTS_DIR}/, deft_state.json, loop_log.jsonl, DEFT_Loop_Report.html.

Après la sortie de la boucle (KPI atteint ou max_iterations reached), capturer deux valeurs de deft_state.json :

iterations.<best>.best_ckpt_path — le meilleur point de contrôle train simple de la boucle
L'étiquette d'itération finale N_final — utilisée pour localiser le CSV d'entraînement augmenté

Si la boucle DEFT s'arrête dur sur une porte irrécupérable, ignorer Phase 3. Il n'y a pas de CSV augmenté validé pour transmettre à AutoML.

Phase 3 — Affinage AutoML sur le dataset augmenté DEFT

Réinvoquer tao-skill-bank:tao-run-automl avec le CSV d'entraînement augmenté comme dataset d'entraînement, le même CSV de validation retenu qu'avant, et le point de contrôle gagnant iter Phase 2 comme warm-start :

Entrée	Valeur AOI
`network_arch`	`visual-changenet`
`train_dataset_uri`	`${RESULTS_DIR}/iter${N_final}/dataset/train_combined_iter${N_final}.csv`
`eval_dataset_uri`	Même que Phase 1 (`<workspace>/train/base/validation_set.csv`) — garder la comparaison apples-to-apples
`metric`	Même métrique que Phase 1
`algorithm`	Même que Phase 1
`automl_max_recommendations`	5–10
Spec initiale	Commencer depuis `<workspace>/specs/baseline_spec_automl.yaml` (gagnant Phase 1) — donne au balayage un centroïde fort pour affiner autour
Point de contrôle warm-start	`iterations.<best>.best_ckpt_path` de `${RESULTS_DIR}/deft_state.json` — définir `spec_overrides["train"]["pretrained_model_path"]` à ce chemin. Chaque rec Phase 3 fine-tune alors à partir du gagnant Phase 2 au lieu de s'entraîner de zéro.

Le warm-start est obligatoire : sans warm-start, chaque rec commence d'une init aléatoire avec seulement 10-20 epochs pour reconverger, la val_loss Phase 3 régresse 0,03–0,05 vs iter1, et le filet de sécurité _pick_best revient silencieusement au gagnant iter — gaspillant le calcul Phase 3. Le code concret spec_overrides (sélection de l'itération avec le far_pct le plus bas, exclusion de tout final_automl antérieur), le compromis large-exploration, sortie vers ${RESULTS_DIR}/final_automl/, et câblage du point de contrôle Phase 3 dans le rapport DEFT via iterations.final_automl + réexécution de prepare_inference_spec.py (avec le filet de sécurité régression _pick_best) sont tous dans references/handoff.md.

Pièges et vérifications de qualité

Ceux-ci s'appliquent aux deux phases AutoML — les intégrer au comportement de l'agent, ne pas seulement coller une fois. Le détail complet est dans references/pitfalls.md :

Pièges de métrique (AOI est déséquilibré en classe). ChangeNet AOI est dominant PASS ; val_loss peut mode-collapse à un modèle PASS-tout avec zéro-rappel. Préférer FAR @ 100%-rappel directement, ou gater val_loss avec une vérification de santé pred_counts, ou décider top-K par FAR @ 100%-rappel. Pour les tâches équilibrées / régression, val_loss va bien.
Bruit run-to-run. AutoML peut montrer une variance de métrique 2–3× pour la même config. Si le gagnant paraît suspecte ment meilleur que le runner-up, réexécuter avec une seed fraîche avant de commiter la spec à Phase 2.
Propreté (fuite de données). Les deux phases AutoML utilisent un ensemble de validation distinct de l'ensemble de test KPI (kpi/testing_set.csv), qui reste intouché jusqu'à l'étape d'évaluation DEFT. Phase 3 s'entraîne sur le CSV augmenté mais garde le même val set pour que les nombres Phase 1 et Phase 3 restent comparables.
Budget de calcul. Exposer la structure par phase en amont et ne donner une plage wall-clock qu'après que l'utilisateur fournisse son temps par job.

Quick Start (exemple travaillé AOI)

Au démarrage frais depuis « exécuter le flux de travail AOI », l'agent délivre un message en trois phases à l'utilisateur (baseline AutoML Phase 1 → boucle DEFT Phase 2 → affinage AutoML Phase 3, avec le cadrage de coût et la fermeture « OK pour procéder ? »), puis après confirmation invoque tao-run-automl (Phase 1), écrit la spec fusionnée, pré-initialise deft_state.json, invoque tao-run-deft-aoi (Phase 2) avec chaque entrée pré-fournie, et invoque tao-run-automl de nouveau (Phase 3) — sans pauses ultérieures sauf si une skill en aval frappe une porte d'arrêt dur irrécupérable — puis résume la trajectoire (baseline AutoML meilleur → iter DEFT 1 → ... → iter DEFT N_final → Phase 3 meilleur).

Voir references/quick-start.md pour le message exactement client-facing et la séquence d'invocation post-confirmation exacte.

Applications DEFT non-AOI

Le même modèle trois-phase s'applique aux autres skills DEFT — permuter network_arch, la skill DEFT Phase 2, les conventions de chemin spec/checkpoint, et le chemin CSV augmenté Phase 3. La forme de transfert (Phase 1 émet spec + checkpoint qui pré-initialise le baseline DEFT, Phase 2 émet un dataset augmenté, Phase 3 émet le point de contrôle final) est identique, et le mécanisme baseline-skip est générique à toute boucle de type DEFT avec un état baseline reprise. Voir references/quick-start.md.

Voir aussi

tao-skill-bank:tao-run-automl — interface AutoML, algorithmes, plages HP
tao-skill-bank:tao-run-deft-aoi — boucle DEFT AOI complet (cible Phase 2 défaut)
tao-skill-bank:tao-train-visual-changenet — skill train/eval/infer ChangeNet sous-jacent (utilisé par AutoML et DEFT)
Autres skills skills/applications/deft-* — cibles Phase 2 non-AOI
references/preflight.md — construction du pré-vol consolidé gate
references/handoff.md — pré-seed Phase 1→2, vérification de qualité Phase 2, Phase 3 warm-start + câblage de rapport
references/pitfalls.md — métrique, bruit, fuite, et guidance budget de calcul
references/quick-start.md — message d'exemple travaillé verbatim et variante non-AOI

tao-run-automl-deft-pipeline