FTH 1 · Enseñar a caminar|INEMA.CLUB-PRO

Clase 5 · 16 min

PPO con miles de robots en paralelo

El algoritmo que entrena casi toda marcha de humanoide hoy es el PPO, que corre miles de copias del robot en la GPU. En esta clase entiendes el ciclo recolectar, estimar y actualizar, ejecutas un PPO de ~120 líneas con los valores de mjlab en CPU, con 16 robots, y ves el comando que hace lo mismo con 4.096.

Comenzar la clase
Monitor en una sala oscura que muestra decenas de pequeños robots humanoides idénticos caminando en simulación, organizados en cuadrícula.

En esta clase vas a

  1. 1El ciclo: recolectar 24 pasos por robot, estimar la ventaja, actualizar la red
  2. 2Los hiperparámetros del G1 en mjlab: lr 1e-3 adaptativo, clip 0,2, 5 épocas
  3. 320 iteraciones en CPU: checkpoint y progresso.csv
  4. 4A escala (mostrado): 4.096 entornos en la GPU, 30.000 iteraciones

Objetivo: ejecutar un entrenamiento corto de PPO en CPU que guarda checkpoint y log, y leer los valores de un entrenamiento real en mjlab.

01Una iteración de PPO

Haz clic en cada bloque. El entrenamiento repite este ciclo miles de veces.

Haz clic en cada bloque del diagrama para ver qué hace.

Red del actor y del crítico: 512-256-128 con ELU, observaciones normalizadas, como en mjlab para el G1.

02Los valores, copiados de mjlab

kit/ppo.py usa los nombres y los valores por defecto del rl_cfg.py del G1 en mjlab (commit 8bb2bc9, 18/10/2026; biblioteca rsl-rl-lib 5.5.1).

Fragmento · kit/ppo.py
PADRAO = dict(clip_param=0.2, entropy_coef=0.01, value_loss_coef=1.0, num_learning_epochs=5,
              num_mini_batches=4, learning_rate=1.0e-3, desired_kl=0.01, gamma=0.99, lam=0.95,
              max_grad_norm=1.0, num_steps_per_env=24, init_std=1.0, hidden_dims=(512, 256, 128))

03Entrenar 20 iteraciones en CPU

16 G1 en paralelo en MuJoCo, un núcleo, con la recompensa de la clase 4. El tope de 900 s es holgura: aquí tardó segundos.

Terminal · entrenamiento corto
F=${FTH:-$HOME/fth}; cd $F/locomocao && . $F/.venv/bin/activate
timeout 900 python3 kit/treinar.py --iters 20; echo "saída: $?"
test -f $F/treino/ppo/modelo_20.pt && echo "arquivo existe: modelo_20.pt"
wc -l < $F/treino/ppo/progresso.csv
Ejemplo del repositorio
PPO em CPU: 16 ambientes × 24 passos = 384 amostras por iteração · obs 96 → ação 29
it   1/20 · recompensa média  -1.75 · episódio médio  24.0 passos · quedas  0
it   2/20 · recompensa média  -3.33 · episódio médio  42.8 passos · quedas  5
it   3/20 · recompensa média  -4.85 · episódio médio  58.6 passos · quedas 10
it   4/20 · recompensa média  -3.90 · episódio médio  50.2 passos · quedas  4
it   5/20 · recompensa média  -4.38 · episódio médio  52.6 passos · quedas  7
it   6/20 · recompensa média  -4.38 · episódio médio  56.5 passos · quedas  4
it   7/20 · recompensa média  -5.37 · episódio médio  69.7 passos · quedas  9
it   8/20 · recompensa média  -5.28 · episódio médio  68.0 passos · quedas  4
it   9/20 · recompensa média  -4.68 · episódio médio  56.8 passos · quedas  9
it  10/20 · recompensa média  -4.73 · episódio médio  61.6 passos · quedas  7
it  11/20 · recompensa média  -4.45 · episódio médio  52.6 passos · quedas  5
it  12/20 · recompensa média  -4.68 · episódio médio  56.9 passos · quedas  9
it  13/20 · recompensa média  -4.22 · episódio médio  52.6 passos · quedas  7
it  14/20 · recompensa média  -4.56 · episódio médio  55.0 passos · quedas  5
it  15/20 · recompensa média  -4.81 · episódio médio  57.1 passos · quedas  8
it  16/20 · recompensa média  -4.88 · episódio médio  59.0 passos · quedas  4
it  17/20 · recompensa média  -4.56 · episódio médio  56.6 passos · quedas  9
it  18/20 · recompensa média  -5.19 · episódio médio  63.4 passos · quedas  7
it  19/20 · recompensa média  -4.47 · episódio médio  51.8 passos · quedas  6
it  20/20 · recompensa média  -4.64 · episódio médio  57.5 passos · quedas  8
checkpoint salvo: ~/fth/treino/ppo/modelo_20.pt
log: ~/fth/treino/ppo/progresso.csv (20 linhas) · tempo total: 9 s
saída: 0
arquivo existe: modelo_20.pt
21

Revisa el formato, no el valor: 20 líneas it, checkpoint salvo:, el archivo existe y progresso.csv tiene 21 líneas (encabezado + 20). La recompensa media negativa y las caídas muestran que 20 iteraciones no le enseñan al G1 a caminar; mjlab usa max_iterations=30_000. El tiempo total cambia de una máquina a otra.

04El mismo entrenamiento a escala (mostrado, no se ejecuta aquí)

Comandos de los README oficiales. Piden GPU NVIDIA y un entorno propio para cada herramienta: no los mezcles en el venv del curso.

Mostrado · mjlab (README, commit 8bb2bc9)
uv run train Mjlab-Velocity-Flat-Unitree-G1 --env.scene.num-envs 4096
Mostrado · unitree_rl_lab (README, Isaac Lab)
python scripts/rsl_rl/train.py --headless --task Unitree-G1-29dof-Velocity

05Dónde corre el entrenamiento de verdad

Tres caminos actuales, todos en la GPU. Haz clic en cada uno.

1. mjlab

La API "manager-based" de Isaac Lab sobre MuJoCo Warp 3.16, Apache-2.0, con uv. Exige GPU NVIDIA (en macOS, solo evalúa). Es el pariente más cercano de este kit: los mismos nombres de términos.

06Práctica

Ver el bucle correr completo antes de intentar hacerlo aprender.

E1 · Entrenamiento corto

5 min

Ejecuta el bloque del entrenamiento de 20 iteraciones.

Listo cuando: timeout 900 python3 kit/treinar.py --iters 20; echo "saída: $?" → checkpoint salvo: ~/fth/treino/ppo/modelo_20.pt, saída: 0, arquivo existe: modelo_20.pt y 21.

E2 · Más robots

10 min

Ejecútalo de nuevo con --envs 32 --iters 10 --saida ~/fth/treino/ppo32 y compara las muestras por iteración y el tiempo total.

Listo cuando: la primera línea dice 32 ambientes × 24 passos = 768 amostras por iteração y existe ~/fth/treino/ppo32/modelo_10.pt.

E3 · Cuenta de la escala

5 min

Con los valores de mjlab (4.096 entornos, 24 pasos, 30.000 iteraciones), calcula cuántas muestras recoge un entrenamiento completo. Escribe cuántas veces es mayor que tu entrenamiento de 20 iteraciones.

Listo cuando: escribiste 98.304 muestras por iteración y cerca de 2,9 mil millones en el entrenamiento completo (384 × 20 = 7.680 en el tuyo: unas 384 mil veces más).

07Prueba de la clase

La explicación aparece después de tu respuesta.

Pregunta 1 de 3

¿Qué hace el recorte (clip 0,2) en PPO?competencia

08En tres frases

BucleRecoger 24 pasos por robot, estimar la ventaja con GAE, actualizar con recorte y tasa adaptativa.
Práctica20 iteraciones en CPU guardan checkpoint y log; se comprueba el formato, no el valor.
Escalamjlab usa los mismos valores con 4.096 robots en la GPU y 30.000 iteraciones.

Para ir más allá

mjlab: rl_cfg.py del G1 (PPO)Schulman et al., Proximal Policy Optimization Algorithms (2017)MuJoCo Playgroundunitree_rl_lab: entrenamiento en Isaac Lab
Clase anteriorPróxima clase