# Entraîner le RL en simulation

Ce guide explique comment utiliser les environnements de simulation `gym_hil` comme alternative aux robots réels lors de l'utilisation du framework LeRobot pour l'apprentissage par renforcement avec boucle humaine (Human-In-the-Loop, HIL).

`gym_hil` est un package qui fournit des environnements de simulation compatibles avec Gymnasium, conçus spécifiquement pour l'apprentissage par renforcement avec intervention humaine (Human-In-the-Loop). Ces environnements vous permettent de :

- Entraînez des politiques en simulation pour tester la pile RL avant l'entraînement sur des robots réels

- Collecter des démonstrations dans la simulation à l'aide d'appareils externes tels que des manettes ou des claviers
- Effectuer des interventions humaines pendant l’apprentissage de la politique

Actuellement, l'environnement principal est une simulation du robot Franka Panda basée sur MuJoCo, avec des tâches telles que la prise d'un cube.

## Installation

Installez d'abord le package `gym_hil` dans l'environnement LeRobot :

```bash
pip install -e ".[hilserl]"
```

## De quoi ai-je besoin ?

- Une manette de jeu ou un clavier pour contrôler le robot
- Un GPU Nvidia

## Configuration

Pour utiliser `gym_hil` avec LeRobot, vous devez créer un fichier de configuration. Un exemple est fourni [ici](https://huggingface.co/datasets/lerobot/config_examples/resolve/main/rl/gym_hil/env_config.json). Les sections de configuration principales incluent :

### Type d'environnement et tâche

```json
{
  "env": {
    "type": "gym_manipulator",
    "name": "gym_hil",
    "task": "PandaPickCubeGamepad-v0",
    "fps": 10
  },
  "device": "cuda"
}
```

Tâches disponibles :

- `PandaPickCubeBase-v0` : Environnement de base
- `PandaPickCubeGamepad-v0` : avec contrôle par manette
- `PandaPickCubeKeyboard-v0` : avec contrôle au clavier

### Configuration du processeur

```json
{
  "env": {
    "processor": {
      "control_mode": "gamepad",
      "gripper": {
        "use_gripper": true,
        "gripper_penalty": -0.02
      },
      "reset": {
        "control_time_s": 15.0,
        "fixed_reset_joint_positions": [
          0.0, 0.195, 0.0, -2.43, 0.0, 2.62, 0.785
        ]
      },
      "inverse_kinematics": {
        "end_effector_step_sizes": {
          "x": 0.025,
          "y": 0.025,
          "z": 0.025
        }
      }
    }
  }
}
```

Paramètres importants :

- `gripper.gripper_penalty` : Pénalité pour un mouvement excessif du gripper
- `gripper.use_gripper` : Indique si le contrôle de la pince doit être activé
- `inverse_kinematics.end_effector_step_sizes` : Taille des pas sur les axes x, y, z de l'effecteur terminal
- `control_mode` : Définir sur `"gamepad"` pour utiliser un contrôleur manette

## Exécution avec le RL HIL de LeRobot

### Utilisation de base

Pour exécuter l'environnement, définissez le mode sur null :

```bash
python -m lerobot.rl.gym_manipulator --config_path path/to/gym_hil_env.json
```

### Enregistrer un jeu de données

Pour collecter un jeu de données, définissez le mode sur `record` en précisant le repo_id et le nombre d'épisodes à enregistrer :

```json
{
  "env": {
    "type": "gym_manipulator",
    "name": "gym_hil",
    "task": "PandaPickCubeGamepad-v0"
  },
  "dataset": {
    "repo_id": "username/sim_dataset",
    "root": null,
    "task": "pick_cube",
    "num_episodes_to_record": 10,
    "replay_episode": null,
    "push_to_hub": true
  },
  "mode": "record"
}
```

```bash
python -m lerobot.rl.gym_manipulator --config_path path/to/gym_hil_env.json
```

### Entraîner une politique

Pour entraîner une politique, consultez l'exemple de configuration disponible [ici](https://huggingface.co/datasets/lerobot/config_examples/resolve/main/rl/gym_hil/train_config.json) et lancez les serveurs learner et actor. Commencez par le learner, car l'actor s'y connecte :

```bash
python -m lerobot.rl.learner --config_path path/to/train_gym_hil_env.json
```

Dans un autre terminal, exécutez le serveur d'acteur :

```bash
python -m lerobot.rl.actor --config_path path/to/train_gym_hil_env.json
```

L'environnement de simulation offre une méthode sûre et reproductible pour développer et tester vos composants d'apprentissage par renforcement avec intervention humaine (Human-In-the-Loop) avant le déploiement sur des robots réels.

Félicitations 🎉, vous avez terminé ce tutoriel !

> [!TIP]
> Si vous avez des questions ou besoin d'aide, n'hésitez pas à nous contacter sur [Discord](https://discord.com/invite/s3KuuzsPFb).

Citation de l'article :

```
@article{luo2024precise,
  title={Precise and Dexterous Robotic Manipulation via Human-in-the-Loop Reinforcement Learning},
  author={Luo, Jianlan and Xu, Charles and Wu, Jeffrey and Levine, Sergey},
  journal={arXiv preprint arXiv:2410.21845},
  year={2024}
}
```