Outils d'Ingénierie Physical AI

Calculateur VRAM & Taille de Lot Max pour Fine-Tuning VLA

Dimensionnement mémoire pour le fine-tuning sur GPU unique de modèles robotiques Vision-Language-Action (VLA) tels que SmolVLA et OpenVLA. Calcule la mémoire fixe d'Adam en précision mixte et déduit la taille de lot maximale sans OOM (B_max).

1. Configuration du Modèle & Fine-Tuning

ex. SmolVLA compte 450M (0,45B), OpenVLA 7 000M (7B).

SmolVLA par défaut (expert action seul) entraîne ~100M ; entraînement complet 450M.

2. Mesures Réelles de Pic VRAM (Sonde)

Exécutez des passes courtes avec des lots de 1, 2 ou 4 et relevez le pic VRAM avec nvidia-smi pour déduire la pente mémoire d'activation.

B = Go
B = Go

3. GPU Cible & Marge de Sécurité

Go
90 %

Viser <= 90% de la VRAM évite les erreurs OOM causées par la fragmentation mémoire CUDA et les pics temporaires.

4. Résultats du Calcul

Taille de Lot Maximale (B_max) 8
Pic VRAM à B_max 20.0 GB
Mémoire Fixe (Poids + Opt) 2.30 GB
Faisabilité sur GPU Unique Faisable sur GPU unique
Mémoire des Poids Gelés 0.70 GB
État Entraînable (Poids + Grad + Opt) 1.60 GB
Terme Fixe Total (M_fixed) 2.30 GB
Pente d'Activation (a) 2.00 GB/batch
Ordonnée à l'Origine (M_0) 4.00 GB
Limite Mémoire Sûre (V × Marge) 21.6 GB
Marge VRAM Résiduelle 1.6 GB

* Remarque : Les résultats sont des estimations d'ingénierie basées sur une extrapolation linéaire. La consommation réelle dépend de la résolution d'image et du framework d'entraînement.

Principes VRAM & Guide d'Ingénierie pour le Fine-Tuning VLA

Lors du fine-tuning de grands modèles Vision-Language-Action (VLA) comme SmolVLA ou OpenVLA sur un GPU unique, le principal goulot d'étranglement mémoire n'est pas seulement le modèle, mais les états de l'optimiseur et la mémoire d'activation qui croît avec la taille du lot.

1. Formule de Décomposition Mémoire (ZeRO Adam Précision Mixte)

La mémoire d'entraînement GPU se compose d'un terme fixe (poids + gradients + optimiseur), de la mémoire d'activation proportionnelle au lot, et de la surcharge CUDA :

M_train ≈ (P_frozen × b_w + P_train × 16) + M_act(B) + M_overhead M_fixed = (P_frozen × b_w + P_train × 16) / 10^9 [GB]

* ZeRO 논문(arXiv:1910.02054) 기준: 혼합 정밀도 Adam은 FP16 가중치(2B) + FP16 그래디언트(2B) + FP32 마스터 가중치/모멘텀/분산(12B) = 파라미터당 16바이트를 점유합니다.

2. Dérivation de la Taille de Lot Max (B_max) par 2 Sondes Courtes

La mémoire d'activation variant avec le nombre de caméras, la résolution et la taille du chunk d'action, une formule purement théorique est imprécise. Deux sondes courtes à batch 2 et 4 permettent une extrapolation linéaire fiable :

a = (M(B2) − M(B1)) ÷ (B2 − B1) [GB / 배치] M_0 = M(B1) − a × B1 [GB, 베이스 오버헤드 절편] B_max = ⌊ (Safety_Margin × V − M_0) ÷ a ⌋

3. Script Python pour Compter les Paramètres Entraînables

Dans LeRobot, comptez directement les paramètres requires_grad pour calculer avec précision le terme fixe :

from lerobot.policies.smolvla.modeling_smolvla import SmolVLAPolicy policy = SmolVLAPolicy.from_pretrained("lerobot/smolvla_base") total = sum(p.numel() for p in policy.parameters()) train = sum(p.numel() for p in policy.parameters() if p.requires_grad) print(f"Total: {total/1e6:.0f}M, Trainable: {train/1e6:.0f}M") print(f"Fixed Term: {((total-train)*2 + train*16)/1e9:.2f} GB (frozen BF16)")

4. Foire Aux Questions (FAQ)

SmolVLA peut-il être entraîné sur un seul GPU de 24 Go (RTX 3090/4090) ?

Oui. Avec la configuration par défaut (encodeur visuel gelé, entraînement de l'expert d'action de ~100M seul), la mémoire fixe n'est que d'environ 2,3 Go. Cela laisse une marge suffisante sur une carte de 24 Go pour des tailles de lot de 4 à 8. Un entraînement complet élève le terme fixe à environ 7,2 Go.

Pourquoi Adam en précision mixte consomme-t-il 16 octets par paramètre ?

Selon l'article ZeRO (arXiv:1910.02054), Adam en précision mixte nécessite 2 octets pour les poids FP16, 2 octets pour les gradients, 4 octets pour la copie maître FP32, 4 octets pour le momentum et 4 octets pour la variance, soit un total de 16 octets par paramètre.

Quelle est la différence entre la VRAM d'inférence et d'entraînement ?

L'inférence ne nécessite aucun état d'optimiseur ni graphe de rétropropagation, seulement les poids du modèle (~2 Go par milliard de paramètres en FP16) et le cache KV. L'entraînement requiert 16 octets par paramètre et de volumineux tampons d'activation.