Hanyuyuan6/remote-gpu-trainer

remote-gpu-trainer — le cycle de vie d'une expérience DL

Aperçu

Une compétence pour l'ensemble du cycle de vie d'une expérience DL : EXÉCUTER → VÉRIFIER → LIVRER.

• EXÉCUTER — faire démarrer, survivre et terminer un long travail GPU, puis récupérer le résultat de la machine. Sur une machine que vous possédez, il n'y a pas de compteur ; sur une machine louée, l'idée centrale est que vous êtes un locataire de courte durée sur la machine de quelqu'un d'autre — il s'agit donc de détacher le travail, faire en sorte que le résultat survive à l'instance et arrêter le compteur en toute sécurité, et non de provisionner un cluster. Spécifique à la plateforme sur les bords (un fichier profiles/<platform.md> possède chaque chemin, proxy, verbe de facturation et règle spot), invariant au cœur.
• VÉRIFIER — ce nombre est-il un bug, un effet réel ou du bruit ? Un résultat surprenant est une hypothèse, pas un fait à rapporter. Indépendant de la plateforme.
• LIVRER — organiser le résultat de sorte que chaque nombre/figure/tableau livré soit une fonction déterministe d'une couche de preuve immuable ; la provenance et la cohérence entre documents sont verrouillées par mécanisme, et non par un humain qui se souvient de mettre à jour trois documents. Indépendant de la plateforme.

Deux postures traversent VÉRIFIER et LIVRER : la souveraineté de l'utilisateur (la science — nombre de graines, quels échantillons, si un canal aux existe — est la décision de l'utilisateur ; la compétence organise et divulgue un compromis une fois, puis cesse de harceler) et auditer → divulguer, pas imposer (la compétence est un auditeur honnête, pas un gardien — un problème d'intégrité doit apparaître avec la conclusion qu'il affecte, mais la compétence n'empêche jamais l'utilisateur de livrer). Mantra : "divulguez-le, ou ne le revendiquez pas."

D'abord, l'orientation

1. EXÉCUTER — possédez-vous la machine ou la louez-vous ?
   • Local (une station de travail/portable que vous possédez, pas de compteur) → references/run-local/ et profiles/local.md.
   • Loué / distant (toute machine avec compteur ou partagée que vous ne possédez pas) → references/run-remote/, et choisissez d'abord votre profiles/<platform.md> (elle possède chaque chemin/verbe/proxy auquel les phases délèguent).
2. Ensuite, TOUJOURS → VÉRIFIER le résultat (references/verifying/) → LIVRER-le (references/delivering/). Ces deux étapes sont indépendantes de la plateforme ; elles s'exécutent de la même manière que le travail se soit entraîné localement ou sur une location. Ne sautez rien ici simplement parce que l'exécution a réussi — une exécution verte n'est pas un nombre réel, et un nombre réel n'est pas encore un livrable propre.

Vous déboguez déjà un modèle qui ne converge pas / fait un OOM / se bloque / produit des NaN, peu importe où il s'exécute ? Allez directement à references/training/ (la couche de débogage en 8 fichiers), puis revenez à VÉRIFIER avant de faire un rapport.

Principes de fonctionnement (l'épine dorsale)

Les invariants porteurs de charge. Une ligne chacun ; l'ensemble complet multi-plateforme (10 invariants pour le cycle de vie distant) se trouve dans references/run-remote/principles.md — lisez-le avant la phase 0 d'une exécution distante.

• Point de contrôle vers un stockage durable + reprise idempotente est l'épine dorsale universelle. Point de contrôle de fichier vers l'emplacement durable + chargement inconditionnel du dernier point au démarrage est le seul mécanisme qui survit à une chute SSH, à un kill de temps d'exécution Slurm, à une reschedule K8s, à une préemption spot, à une déconnexion Colab. La primitive de détachement (tmux / sbatch / Job) est le plugin interchangeable ; c'est l'invariant.
• Faites confiance à l'artefact que vous avez chargé, pas à une ligne de log qui prétend avoir réussi. "synchronisé / sauvegardé / terminé" ment lors d'une écriture qui échoue silencieusement ; l'état propre d'un observateur est aussi une revendication — réconciliez-le avec le vrai processus / artefact / pixels / octets.
• Vérifications bon marché avant le calcul coûteux. Une fumée CPU de 1 à 2 lots (logger désactivé) tue les bugs d'import/config/forme/échelle pour ~gratuit, avant qu'ils ne facturent des heures GPU.
• Les actions coûteuses et destructrices sont la décision de l'utilisateur. Ne jamais libérer/terminer automatiquement, ne jamais supprimer des fichiers durables sans confirmation ; si le nettoyage ne peut pas libérer d'espace, demandez d'étendre le disque, ne réduisez pas silencieusement l'expérience.
• Auditer → divulguer, pas imposer. Ce qui est obligatoire, c'est la divulgation, pas la correction. Un constat d'intégrité (pas de validation disjointe, fuite, test touché pendant la sélection, un nombre que vous ne pouvez pas redériver) doit accompagner avec la conclusion — mais la compétence divulgue, elle ne bloque pas.

EXÉCUTER — local (une machine que vous possédez)

Pas de compteur, pas d'horloge d'arrêt — les risques passent de l'argent à la contention de ressources et la stabilité de votre machine. La discipline qui ne se relâche pas : hygiène de l'environnement, conscience des ressources, soin des artefacts/points de contrôle, et "indiquez la graine". Commencez par profiles/local.md, puis le document correspondant :

• Hygiène de l'environnement — ne jamais s'entraîner/installer dans conda base sur une machine persistante ; la barrière en 4 étapes (énumérer → choisir l'environnement du projet → confirmer sys.executable → exécuter) → references/run-local/env-hygiene.md.
• Lancement et détachement — nohup/tmux, log + sonde de vie, ne pas bloquer au premier plan → references/run-local/launch.md.
• Multi-GPU sur un seul nœud — contrat d'environnement torchrun/accelerate DDP, les bases du hang au premier rang → references/run-local/multi-gpu.md (multi-nœud → references/run-remote/multinode.md).
• OOM local — l'échelle de réparation sur du matériel que vous ne pouvez pas louer plus grand → references/run-local/local-oom.md.

EXÉCUTER — distant (une machine que vous louez)

Choisissez votre profil D'ABORD — il lie chaque chemin/concret/identifiant/verbe de facturation/règle spot auquel les phases délèguent. Modèle de verbe mental (une API à travers les plateformes ; le profil lie chaque verbe à des commandes réelles) : up (louer+atteindre) → push (code/données sur) → run (détaché + points de contrôle) → watch (moniteur durable) → pull (résultats hors + vérifier) → down (arrêter le compteur).

Vous êtes sur…	Profil	Verbe d'arrêt du compteur (le piège)
AutoDL (le plus profond, éprouvé)	profiles/autodl.md	关机 arrête le compteur, garde le disque (l'exception AutoDL)
RunPod	profiles/runpod.md	terminer (arrêter facture encore 2× ; détruit le volume disque)
vast.ai	profiles/vastai.md	détruire (arrêter facture le disque pour toujours)
Lambda	profiles/lambda.md	terminer (pas d'état arrêté)
Paperspace	profiles/paperspace.md	détruire + libérer IP + supprimer le stockage
恒源云 / 矩池云 / Featurize / 揽睿星舟	profiles/china.md	par plateforme (le disque de données facture souvent à l'arrêt)
SSH nue / Slurm / K8s / Colab	profiles/generic-ssh.md	manuel (une machine oubliée facture 24/7)

Le cycle de vie en 6 phases (liste de contrôle complète par plateforme → references/run-remote/lifecycle_checklist.md) : 0 audit de l'environnement (df -i pas seulement df -h, cgroup memory.max, budget disque des points de contrôle) · 1 SSH + identifiants (l'image préconstruite est l'environnement — ne faites pas conda create sur une location ; secrets via stdin) · 2 wrapper + barrière de fumée CPU avant de louer · 3 lancement détaché (sonde, puis rendez la main — jamais un sleep bloquant) · 4 surveillance durable (l'architecture en quatre couches → references/run-remote/monitoring_patterns.md ; un observateur lié à une session meurt avec la session) · 5 agréger + vérifier + démonter.

Loi de Fer — barrière de démontage : PAS de release / terminate / destroy / suppression de fichier tant que les points de contrôle ne sont pas tirés vers le local ET vérifiés par chargement (scripts/verify_local.py), et que l'utilisateur n'a pas explicitement approuvé l'action affectant les coûts. "Ça avait l'air terminé dans le log" n'est pas une preuve. Sur la plupart des plateformes, l'action d'arrêt du compteur est irréversible (supprime le disque) — la confirmation est plus importante, pas moins.

Autres références distantes : ssh_transport.md (rsync/scp reprenable, secrets-via-stdin, CRLF) · spot-resilience.md (grâce de préemption, cadence Young/Daly, reprise par écriture atomique) · china-network.md (miroirs + HF_ENDPOINT + le piège no_proxy) · parallel_ablation.md (indépendance en éventail + réconciliation) · multinode.md (NCCL/fabric, avancé) · gotchas_universal.md (le catalogue complet U1–U43 avec un index grep).

Quand l'entraînement lui-même se casse (le modèle, pas la plateforme)

Une fois que la machine tourne, l'entraînement se casse de ses propres manières — local ou distant, la même couche de débogage (references/training/, 8 fichiers ; chaque entrée symptôme → cause racine → correctif avec documents cités). Orientez-vous par symptôme :

• OOM / ne tient pas (CUDA-VRAM ou RAM hôte, OOM à une étape, l'échelle de réparation) → oom-memory.md.
• Lancement multi-GPU / SE BLOQUE (contrat d'environnement torchrun/accelerate/deepspeed, DDP/FSDP/ZeRO) → distributed-launch.md.
• NaN / Inf / pics de perte (fp16/bf16/tf32, AMP/GradScaler, divergence LLM) → precision-stability.md.
• Trop lent (lié au GPU vs aux données vs à la communication, boutons du dataloader, pièges torch.compile) → throughput-profiling.md.
• Bugs de reprise (sauvegarde/reprise d'état complet + fragmenté ; redémarrage d'époque, remélange, perte du scaler/EMA) → checkpoint-resume.md.
• Pièges par domaine (LLM, vision det/seg, diffusion, RL, multimodal/VLM) → by-domain.md.
• Tourne mais n'apprend pas (surapprentissage d'un lot, paramètres qui ne se mettent pas à jour, LR/planification, footguns de fonction de perte, gel) → convergence-debugging.md.
• Correction du dataloader (duplication d'augmentation par RNG worker, partitionnement IterableDataset, RGB-vs-BGR / ÷255 / set_epoch) → data-pipeline.md.

VÉRIFIER — le nombre est-il réel ?

Avant de faire confiance ou de rapporter une quelconque métrique, delta d'ablation, ou "ça marche maintenant" : classez-le comme bug / effet / bruit, maintenez une comparaison avec exactement une variable changée, et sondez les fuites / la comparaison équitable / la variance / la direction de la métrique. Un nombre que vous ne pouvez pas redériver à partir de l'artefact sauvegardé n'est pas encore un résultat. Posture : auditer → divulguer — faites remonter un problème d'intégrité avec la conclusion, ne passez jamais silencieusement ou ne bloquez pas durement.

• Méthodologie complète (l'échelle de sonde en 14 sections + les 6 invariants) → references/verifying/methodology.md.
• Sortie constante / dégénérée, real == shuffle, modèle qui ignore l'entrée → references/verifying/representation-collapse.md.
• Une fumée verte qui cache un sous-entraînement vs un vrai bug ; perte-faible-mais-échantillons-mauvais → references/verifying/smoke-hidden-failures.md.

Indiquez la direction de la métrique lors de la comparaison (PSNR/SSIM/mAP ↑ mieux ; LPIPS/NMSE/perte ↓ mieux) — ne présumez jamais. Forensique de tracker / élagage des exécutions en double → scripts/wandb_forensics.py.

LIVRER — organiser → source unique → figures

Faites du livrable une fonction déterministe d'une couche de preuve immuable et versionnée ; verrouillez la provenance et la cohérence entre documents par mécanisme, et non à la main. Huit principes, hiérarchisés (references/delivering/principles.md) :

• CŒUR (câblez à partir du premier nombre réel) — P1 couches de preuve/présentation proprement séparées (zéro nombre tapé à la main dans la couche de présentation) · P2 nombres générés à partir de results.json, pas retranscrits (donc un nombre obsolète est physiquement impossible) · P3 exécutions immuables adressées par contenu + ajout seul (ré-exécuter crée un nouveau <run-id>, jamais d'écrasement) · P7 traçabilité de la chaîne de figure (results.json → source_data.csv → figure + side-car .provenance) + la barrière de réouverture de pixel (une figure qui a été sauvegardée n'est pas une figure qui est correcte) · P8 livraison = une barrière de divulgation, pas une barrière bloquante.
• Avancé (activez près de la soumission — YAGNI s'applique aussi à la provenance) — P4 données/partition versionnées + hachage épinglé (les fuites deviennent vérifiables par machine) · P5 reproduction en une commande à partir d'un clone propre (scripts/repro.sh.template).

Mécanique : l'arborescence sur disque → references/delivering/data-architecture.md ; les deux schémas de manifeste → references/delivering/evidence-manifest-schema.md ; la convention un dossier par figure + barrière de pixel → references/delivering/figures.md ; la liste de contrôle de divulgation par nombre → references/delivering/delivery-gate.md.

EVIDENCE.json est la source unique de vérité au niveau du projet — une carte machine-lisible revendications↔preuve (chaque revendication ← l'exp-id / métrique / figure de support + un ancrage de papier + le file:line du dépôt). scripts/reconcile.py grep tout le dépôt par rapport à ses valeurs faisant autorité pour détecter les dérives entre documents ; scripts/manifest_scaffold.py estampe la structure.

Compétences compagnons (toutes OPTIONNELLES — cette compétence est autonome)

Installations séparées recommandées qui approfondissent EXÉCUTER / VÉRIFIER / LIVRER ; la compétence n'en a besoin d'aucune et fonctionne complètement seule. Liste d'une ligne chacun, ce que chacun ajoute, et le repli sans compagnon → references/companions.md. En bref : dessin de figures (nature-figure / publication-chart / scipilot-figure), vérification d'expérience (l'agent experiment-verifier), ablation parallèle (superpowers:dispatching-parallel-agents), transport HF + tracker hébergé (huggingface-skills:hf-cli / huggingface-trackio).

S'améliorer avec le temps

La compétence est statique, mais chaque exécution peut lui apprendre un piège — sans le corrompre. Protocole → references/self-improvement.md : ne sédimenter qu'un piège dont la cause racine est trouvée, reproduit et généralisable (un caprice ponctuel est une hypothèse, pas un piège) ; orienter les faits spécifiques à l'utilisateur/projet vers la mémoire de l'hôte et les faits généralisables vers une édition de catalogue proposée ; ne jamais réécrire silencieusement un fichier de compétence — rédiger le symptôme → cause racine → correctif et laisser l'utilisateur approuver. Les faits de plateforme portent un timbre vérifié <mois> — revérifiez tout fait d'arrêt/facturation par rapport à la documentation actuelle avant de parier de l'argent ou des données (scripts/check_staleness.py).

Ressources groupées

Ne chargez que ce dont la phase actuelle a besoin (les sections du corps ci-dessus nomment les fichiers individuels).

• references/run-local/ — posséder-une-machine : env-hygiene · launch · multi-gpu · local-oom.
• references/run-remote/ — machine-louée : principles · lifecycle_checklist · monitoring_patterns · ssh_transport · spot-resilience · china-network · parallel_ablation · multinode · gotchas_universal (U1–U43).
• references/training/ — la couche de débogage d'entraînement DL (8 fichiers ; indépendant local/distant) — routée ci-dessus.
• references/verifying/ — le-nombre-est-il-réel : methodology · representation-collapse · smoke-hidden-failures.
• references/delivering/ — livrable : principles · data-architecture (+EVIDENCE.json) · evidence-manifest-schema · figures · delivery-gate.
• references/companions.md (compétences optionnelles + replis) · references/self-improvement.md (boucle de capture d'un piège).
• profiles/<platform.md> — substrat par plateforme (7 profils de location + local.md ; _schema.md = les champs).
• scripts/ — wrappers (run_one.sh / verify_local.py / reconcile.py / manifest_scaffold.py / check_staleness.py / wandb_forensics.py).

L'exécution est planifiée ; maintenant, allez lire references/run-remote/principles.md (pour les exécutions distantes) ou profiles/local.md (pour les exécutions locales), ou directement à references/training/oom-memory.md si un OOM bloque tout.