Auto Recipe — Index de recettes et recommandations

Cette skill indexe chaque recette livrée et aide les utilisateurs à choisir la bonne configuration de démarrage, à ajuster le parallélisme et à éviter les pièges courants.

Comment utiliser cette skill

1. Demandez à l'utilisateur : nom/taille du modèle, nombre et type de GPU, objectif d'entraînement (pretrain / SFT / PEFT), et longueur de séquence (si non-défaut).
2. Recherchez la meilleure recette correspondante dans l'index ci-dessous.
3. Recommandez le nom de la fonction de recette + la commande d'entrée.
4. Fournissez des conseils d'ajustement (redimensionnement du parallélisme, tuning de batch, pièges).

Points d'entrée

Recettes de bibliothèque (entraînement fonctionnel)

# Pretrain avec données factices
uv run python -m torch.distributed.run --nproc_per_node=8 scripts/training/run_recipe.py \
    --recipe <recipe_function_name> \
    --dataset llm-pretrain-mock

# SFT avec SQuAD
uv run python -m torch.distributed.run --nproc_per_node=8 scripts/training/run_recipe.py \
    --recipe <recipe_function_name> \
    --dataset llm-finetune

# Remplacer n'importe quel champ via CLI
uv run python -m torch.distributed.run --nproc_per_node=8 scripts/training/run_recipe.py \
    --recipe llama3_8b_pretrain_config \
    --dataset llm-pretrain-mock \
    'model.tensor_model_parallel_size=2' \
    'training.global_batch_size=64'

Recettes de performance (benchmarks de débit)

python scripts/performance/run_script.py \
    --recipe <model_family> \
    --gpu_type h100 \
    --num_gpus 64 \
    --data mock

Les recettes Perf ne sont PAS entièrement validées pour la correction. La plupart des conversations et tests ont été sur des données factices. Elles sont conçues pour la mesure du débit maximum, pas pour l'entraînement en production. Validez toujours les courbes de perte et la convergence indépendamment.

Unification des recettes (À venir — PR #2803)

La PR #2803 unifie les recettes de performance au même format fonction Python utilisé par les recettes de bibliothèque. Changements clés :

• Les recettes Perf passent de scripts/performance/configs/ → src/megatron/bridge/recipes/<family>/<model>_perf.py
• Chaque recette perf devient une fonction Python autonome (p. ex. llama3_8b_h100_bf16_pretrain_config())
• Le pipeline ancien WorkloadBaseConfig → set_workload_base_configs → get_perf_optimized_recipe est supprimé
• Helpers partagés : _benchmark_common() (50 itérations, timing, TE RNG), _perf_precision() (bf16 / fp8_cs / fp8_mx / nvfp4)

Pourquoi Python, pas YAML ? Les approches précédentes basées sur YAML avaient des problèmes : la logique des recettes était fractionnée sur plusieurs couches indirectes, les configs n'étaient pas autonomes, et le pipeline à deux niveaux rendait la maintenance et le débogage difficiles. Les fonctions Python sont explicites, cherchables et composables.

Après le merge de #2803, les recettes de bibliothèque et perf seront invocables via le même point d'entrée run_recipe.py.

Index des recettes de bibliothèque

Toutes les recettes se trouvent sous src/megatron/bridge/recipes/. Chaque fonction retourne un ConfigContainer avec les paramètres de modèle, entraînement, optimiseur et données.

Llama

Qwen2 / Qwen2.5

Qwen3 (Dense)

Qwen3 MoE

Qwen3-Next

DeepSeek

GLM-4.5

Gemma

NemotronH / Nemotron

Autres modèles

Recettes VLM

Recettes Diffusion

Index des recettes de performance

Toutes les recettes perf se trouvent sous scripts/performance/. Elles sont invoquées via run_script.py et utilisent des présets WorkloadBaseConfig par type de GPU.

Important : Les recettes Perf sont conçues pour les benchmarks de débit maximum, pas pour l'entraînement en production. Elles exécutent 50 itérations sur des données factices par défaut. Les chiffres de débit sont des cibles aspirationnelles, pas des configurations de convergence validées.

Llama 3 / 3.1

Des variantes SFT/LoRA existent aussi (p. ex. 8B SFT avec packed sequences, 70B SFT sur 32 GPUs).

DeepSeek V3

Qwen3 MoE

Qwen3-VL

Kimi K2

NemotronH

GPT-OSS

Arbre de décision pour les recommandations

L'utilisateur veut entraîner un modèle
│
├─ Connaît le nom du modèle ?
│   ├─ Oui → Recherchez dans l'Index des recettes de bibliothèque ci-dessus
│   │   ├─ A une recette pour sa taille + mode ? → L'utiliser directement
│   │   └─ Pas de correspondance exacte ? → Utiliser la taille la plus proche, ajuster le parallélisme
│   └─ Non → Demander le nom du modèle, la taille et l'ID du modèle HF
│
├─ Quel est l'objectif d'entraînement ?
│   ├─ Pretrain → Utiliser *_pretrain_config
│   ├─ SFT (fine-tune complet) → Utiliser *_sft_config
│   └─ PEFT (LoRA/DoRA) → Utiliser *_peft_config (besoin GPU minimal)
│
├─ Combien de GPUs ?
│   ├─ 1 GPU → Seules les recettes PEFT fonctionnent (TP=1, PP=1)
│   ├─ 8 GPUs (1 nœud) → Plupart des modèles 8B–16B, petit MoE (EP=8)
│   ├─ 16–64 GPUs → 70B dense, MoE moyen
│   └─ 128+ GPUs → 405B+, grand MoE (DeepSeek V3, Kimi K2)
│
├─ Vouloir des benchmarks de débit ?
│   ├─ Oui → Utiliser des recettes perf (scripts/performance/)
│   │   └─ ⚠️ Ces recettes exécutent sur données factices pour perf upper-bound uniquement
│   └─ Non → Utiliser des recettes de bibliothèque (scripts/training/run_recipe.py)
│
└─ Contexte long ?
    ├─ > 8K → Besoin CP (context parallelism), vérifier variantes *_16k / *_64k / *_128k
    └─ ≤ 8K → Les recettes par défaut fonctionnent

Conseils d'ajustement (lors de la recommandation)

Règles de redimensionnement du parallélisme

Quand le nombre de GPU de l'utilisateur diffère du défaut de la recette :

1. TP doit diviser num_key_value_heads (contrainte GQA). Par exemple, si num_key_value_heads=8, TP valide = {1, 2, 4, 8}.
2. TP doit rester dans un seul nœud (NVLink). TP > 8 nécessite NVLink inter-nœuds (p. ex., GB200 NVL72).
3. PP ajoute des bulles de pipeline. Minimiser PP ; augmenter seulement si TP seul ne peut pas tenir le modèle. Utiliser VP (virtual pipeline) pour atténuer le surcoût de bulle.
4. EP ne réduit pas la mémoire des couches denses. Seuls les paramètres d'expert sont fragmentés avec EP. L'attention partagée/embeddings sont répliqués. Pour "OOM avec MoE", augmenter EP d'abord, pas TP.
5. SP doit être True chaque fois que TP > 1. Cela élimine les copies d'activation redondantes et est essentiellement gratuit.
6. CP nécessite all-to-all ou ring attention. Vérifier cp_comm_type. Pour les modèles GQA, a2a+p2p hierarchical CP permet CP > num_kv_heads.
7. world_size = DP × TP × PP × CP × EP. DP est implicite. S'assurer que le produit des parallélismes explicites divise votre compte total de GPU.

Tuning de la taille de batch

• Commencer avec le micro_batch_size de la recette. Si OOM, réduire à 1.
• global_batch_size détermine la dynamique d'apprentissage. Échelonner avec DP : GBS = micro_batch_size × DP × gradient_accumulation_steps.
• Pour MoE, micro_batch_size=1 est typique à grande échelle.

Pièges courants à avertir

Exemples de remplacement de recette

# Échelonner Llama3 8B de 2 GPUs à 8 GPUs (augmenter DP)
uv run python -m torch.distributed.run --nproc_per_node=8 scripts/training/run_recipe.py \
    --recipe llama3_8b_pretrain_config \
    --dataset llm-pretrain-mock

# Réduire le parallélisme pour Qwen3-MoE 30B pour tenir sur 4 GPUs
uv run python -m torch.distributed.run --nproc_per_node=4 scripts/training/run_recipe.py \
    --recipe qwen3_30b_a3b_sft_config \
    --dataset llm-finetune \
    'model.expert_model_parallel_size=4'

# Ajouter long context à une recette existante
uv run python -m torch.distributed.run --nproc_per_node=8 scripts/training/run_recipe.py \
    --recipe llama3_8b_pretrain_config \
    --dataset llm-pretrain-mock \
    'model.seq_length=32768' \
    'model.context_parallel_size=4'

# Activer CUDA graphs sur n'importe quelle recette
uv run python -m torch.distributed.run --nproc_per_node=8 scripts/training/run_recipe.py \
    --recipe qwen3_30b_a3b_pretrain_config \
    --dataset llm-pretrain-mock \
    'model.cuda_graph_impl=transformer_engine' \
    'model.cuda_graph_scope=[attn,moe_router,moe_preprocess]' \
    'model.use_te_rng_tracker=True' \
    'rng.te_rng_tracker=True'

Référence rapide : Quelle recette pour ma situation ?

Ancres de code