En bref (TL;DR)
- Installez Isaac Lab via Omniverse Launcher ou Docker pour un entraînement par renforcement (RL) accéléré par GPU.
- Concevez des environnements en utilisant des scènes USD et Hydra pour une randomisation de domaine.
- Entraînez des politiques PPO/RSL-RL avec
isaaclab trainet scalez jusqu’à 1000+ robots en parallèle. - Exportez les politiques vers ROS 2 ou Omniverse pour une déploiement en conditions réelles.
- Benchmarkez les performances avec
isaaclab benchmarket optimisez l’utilisation du GPU.
1. Installation et dépendance à Isaac Sim
Isaac Lab repose sur Isaac Sim, il est donc nécessaire d’installer les deux. Voici les étapes pour une configuration Linux (Ubuntu 22.04 LTS), plateforme officiellement supportée.
Option 1 : Omniverse Launcher (Recommandé)
# Télécharger et installer Omniverse Launcher
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin
sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600
sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/3bf863cc.pub
sudo add-apt-repository "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/ /"
sudo apt-get update
sudo apt-get -y install cuda
# Installer Omniverse Launcher
wget https://developer.download.nvidia.com/compute/cuda/repos/omniverse2026.1/ubuntu2204/omniverse-launcher_2026.1.0-1_amd64.deb
sudo dpkg -i omniverse-launcher_2026.1.0-1_amd64.deb
sudo apt install -f
# Lancer Omniverse Launcher et installer Isaac Sim 2026.1 + extension Isaac Lab
omniverse-launcher
- Dans le Launcher, allez dans Isaac Sim 2026.1 → Extensions → Activez Isaac Lab.
- Lancez Isaac Sim et vérifiez que l’onglet Isaac Lab apparaît.
Option 2 : Docker (Pour le Cloud/Reproductibilité)
# Récupérer le conteneur Isaac Lab le plus récent
docker pull nvcr.io/nvidia/isaac-sim:2026.1.0-isaaclab
# Exécuter avec accès GPU (remplacez `your_username` par votre nom d’utilisateur réel)
docker run --gpus all -it --rm \
-v /tmp/.X11-unix:/tmp/.X11-unix \
-e DISPLAY=$DISPLAY \
-e NVIDIA_DRIVER_CAPABILITIES=compute,utility \
-e NVIDIA_VISIBLE_DEVICES=all \
--name isaaclab \
nvcr.io/nvidia/isaac-sim:2026.1.0-isaaclab
# À l’intérieur du conteneur, vérifier l’installation
isaaclab --version
Résultat attendu :
Isaac Lab v1.2 (Isaac Sim 2026.1.0)
Option 3 : Installation à partir des sources (Avancé)
git clone https://github.com/isaac-sim/IsaacLab.git
cd IsaacLab
./isaaclab.sh --install
- Nécessite Python 3.10+, PyTorch 2.1.0 et CUDA 12.4.
- Consultez le guide d’installation des sources pour les dépendances.
2. Conception de l’environnement et des tâches
Isaac Lab utilise USD (Universal Scene Description) pour composer les scènes. Concevez votre environnement robotique avec Hydra ou USD Composer.
Étape 1 : Créer une scène USD de base
# Accéder aux exemples Isaac Lab
cd ~/isaaclab/examples/rl
# Lancer un environnement préconstruit (ex. Franka Cube)
isaaclab launch --scene franka_cube.usd
Résultat attendu :
- Une fenêtre de simulation s’ouvre avec un robot Franka et un cube.
Étape 2 : Personnaliser votre environnement
Modifiez le fichier de scène USD (franka_cube.usd) ou créez-en un nouveau :
# Exemple : Modifier la scène avec l’API Python USD
from pxr import Usd, UsdGeom, Sdf
stage = Usd.Stage.CreateNew("custom_scene.usd")
robot = Sdf.CreatePrim("/World/Franka", "Xform")
robot.AddAttribute("type", "franka_emika_panda")
stage.GetRootLayer().Save()
- Utilisez USD Composer (inclus dans Omniverse) pour une édition visuelle.
Étape 3 : Définir les observations et actions
Configurez les observations (caméra, proprioception) et les actions (couples articulaires) dans un fichier de configuration Hydra (config.yaml) :
# ~/isaaclab/configs/franka_cube/config.yaml
env:
name: "FrankaCubeEnv"
num_envs: 1024 # Environnements parallèles
obs:
type: "camera"
resolution: [256, 256]
num_cameras: 2
act:
type: "joint_torques"
dof: 7
- Enregistrez le fichier dans
~/isaaclab/configs/your_env/.
3. Apprentissage par renforcement massivement parallèle (PPO, RSL-RL)
Isaac Lab prend en charge Proximal Policy Optimization (PPO) et RSL-RL (bibliothèque RL de NVIDIA).
Étape 1 : Entraîner une politique PPO
# Entraîner PPO sur la tâche Franka Cube
isaaclab train \
--config configs/franka_cube/config.yaml \
--algorithm ppo \
--num_steps 1e6 \
--save_freq 10000 \
--output_dir ~/isaaclab_runs/franka_ppo
Arguments clés :
--algorithm:ppooursl_rl(bibliothèque RL optimisée de NVIDIA).--num_steps: Nombre total d’étapes d’entraînement (ex.1e6).--num_envs: Environnements parallèles (par défaut :1024).
Étape 2 : Surveiller l’entraînement
# Lancer TensorBoard pour visualiser les métriques
isaaclab tensorboard --logdir ~/isaaclab_runs/franka_ppo
Résultat attendu :
- Ouvrez
http://localhost:6006pour consulter les courbes d’entraînement (récompense, perte, etc.).
Étape 3 : Scale sur plusieurs GPU
# Entraîner sur 4 GPU (nécessite NCCL et CUDA 12.4)
isaaclab train \
--config configs/franka_cube/config.yaml \
--algorithm ppo \
--num_gpus 4 \
--num_envs_per_gpu 256 \
--num_steps 1e7
Piège à éviter : Si l’entraînement bloque, définissez NCCL_DEBUG=INFO :
export NCCL_DEBUG=INFO
4. Workflows d’apprentissage par imitation
Isaac Lab supporte l’apprentissage par imitation via Behavior Cloning (BC) et DDPG.
Étape 1 : Préparer un jeu de données
# Enregistrer des démonstrations d’experts (ex. depuis un robot réel ou un solveur cinématique)
isaaclab record \
--scene franka_cube.usd \
--output_dir ~/expert_demos \
--num_episodes 100
Résultat : Sauvegarde des trajectoires dans ~/expert_demos/trajectories.hdf5.
Étape 2 : Entraîner une politique BC
isaaclab train \
--config configs/franka_cube/config.yaml \
--algorithm bc \
--dataset ~/expert_demos/trajectories.hdf5 \
--batch_size 256
Arguments clés :
--algorithm:bc(Behavior Cloning) ouddpg(Deep Deterministic Policy Gradient).
5. Randomisation de domaine et curricula
La randomisation de domaine améliore la généralisation en variant les paramètres de simulation.
Étape 1 : Activer la randomisation
Modifiez config.yaml :
env:
randomization:
enable: true
ranges:
friction: [0.5, 1.5]
mass: [0.8, 1.2]
lighting: [0.7, 1.3]
Étape 2 : Apprentissage par curriculum
Utilisez un script de curriculum (curriculum.py) pour augmenter progressivement la difficulté de la tâche :
def get_curriculum(env, step):
if step < 1e5:
return {"target_pos": [0.1, 0, 0.1]} # Facile
elif step < 5e5:
return {"target_pos": [0.2, 0, 0.2]} # Moyen
else:
return {"target_pos": [0.3, 0, 0.3]} # Difficile
- Transmettez le curriculum à l’entraînement :
isaaclab train \
--config configs/franka_cube/config.yaml \
--algorithm ppo \
--curriculum curriculum.py
6. Exportation des politiques pour déploiement
Exportez les politiques formées vers ROS 2 ou Omniverse pour un déploiement en conditions réelles.
Étape 1 : Exportation vers ROS 2
# Exporter la politique formée dans un package ROS 2
isaaclab export \
--input_dir ~/isaaclab_runs/franka_ppo \
--output_dir ~/franka_ros2_policy \
--format ros2 \
--robot_model franka_emika_panda
Résultat : Génère un nœud ROS 2 avec la politique.
Étape 2 : Déploiement sur un robot réel
# Exécuter la politique sur un robot Franka réel (nécessite Isaac ROS)
ros2 launch franka_ros2_policy franka_policy.launch.py
Étape 3 : Exportation vers Omniverse
isaaclab export \
--input_dir ~/isaaclab_runs/franka_ppo \
--output_dir ~/omniverse_policy \
--format omniverse
Résultat : Une politique basée sur USD chargeable dans Omniverse Kit.
7. Benchmark des performances d’entraînement
Mesurez l’utilisation du GPU et la vitesse d’entraînement.
Étape 1 : Benchmark des environnements parallèles
isaaclab benchmark \
--config configs/franka_cube/config.yaml \
--num_envs 1024 \
--num_gpus 1
Résultat attendu :
Débit : 1200 étapes/env/seconde
Utilisation du GPU : 92%
Étape 2 : Optimisation des performances
- Réduisez la résolution des observations si la mémoire GPU est limitée.
- Utilisez la précision mixte (
fp16) :algorithm: ppo: use_fp16: true
Que faire ensuite ?
- Essayer une politique pré-entraînée : Chargez une politique pré-entraînée depuis les Modèles Isaac Lab de NVIDIA.
- Expérimenter avec les politiques de diffusion : Utilisez le nouvel algorithme
diffusiondans Isaac Lab v1.2 pour la manipulation dexterous. - Déployer dans le Cloud : Scalez l’entraînement sur AWS/GCP en utilisant les conteneurs NVIDIA NGC.
Pour des services de conseil en outils d’IA ou une infrastructure Physical AI, consultez Hyperion Consulting.
