# Instalación

Esta guía utiliza `conda` (vía miniforge) para gestionar entornos (recomendado). Si prefieres otro gestor de entornos (p. ej. `uv`, `venv`), asegúrate de tener Python >=3.12 y luego salta a [Configuración del entorno](#step-2-environment-setup).

## Paso 1 (solo `conda`): Instale [`miniforge`](https://conda-forge.org/download/)

```bash
wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh
```

## Paso 2: Configuración del entorno

Crea un entorno virtual con Python 3.12:

```bash
conda create -y -n lerobot python=3.12
```

= solo 2.10)>
```bash
uv python install 3.12
uv venv --python 3.12
```

Luego, activa tu entorno virtual; debes hacer esto cada vez que abras una shell para usar lerobot:

```bash
conda activate lerobot
```

> [!NOTE]
> Al instalar LeRobot dentro de WSL (Windows Subsystem for Linux), asegúrate de instalar también `evdev`:
>
> ```bash
> conda install evdev -c conda-forge
> ```

= solo 2.10)>
```bash
# Linux/macOS
source .venv/bin/activate
# Windows PowerShell
.venv\Scripts\activate
```

> [!NOTE]
> Al instalar LeRobot dentro de WSL (Windows Subsystem for Linux), asegúrate de instalar también `evdev`:
>
> ```bash
> sudo apt install libevdev-dev
> uv pip install evdev
> ```

### Requisitos de la plataforma

En Apple Silicon, PyTorch requiere **macOS 14 o una versión más reciente**, y la aceleración MPS **macOS 15 o una versión más reciente** (en macOS 14, LeRobot recurre a CPU). En Linux, las ruedas de PyTorch predeterminadas necesitan un controlador NVIDIA de **580.65 o una versión más reciente**; para controladores más antiguos, consulte [variante CUDA de PyTorch](#pytorch-cuda-variant-linux-only).

### Instale `ffmpeg` (para la decodificación de video)

LeRobot utiliza [TorchCodec](https://github.com/meta-pytorch/torchcodec) para la decodificación de video de forma predeterminada, lo que requiere `ffmpeg`.

> [!NOTE]
> **Soporte de plataforma:** TorchCodec no está **disponible** en macOS Intel (x86_64) ni en Linux armv7l. En estas plataformas, LeRobot vuelve automáticamente a `pyav`, por lo que no es necesario instalar `ffmpeg` y se puede pasar directamente al paso 3.
>
> **Jetson (aarch64 + CUDA):** la decodificación de video se ejecuta en la CPU de forma predeterminada. [`docker/Dockerfile.jetson`](https://github.com/huggingface/lerobot/blob/main/docker/Dockerfile.jetson) compila `torch`/`torchcodec` desde el código fuente con soporte para CUDA para JetPack 6.2 — mantenido por la comunidad, consulte [`ravediamond/lerobot-jetson`](https://github.com/ravediamond/lerobot-jetson) para la imagen precompilada y el problema [#819](https://github.com/huggingface/lerobot/issues/819) para más contexto.

Si su plataforma es compatible con TorchCodec, instale `ffmpeg` usando uno de los métodos siguientes:

Instale `ffmpeg` en su entorno conda. Esto funciona con **todas las versiones de PyTorch** y es **obligatorio para PyTorch < 2.10**:

```bash
conda install ffmpeg -c conda-forge
```

> [!TIP]
> Esto normalmente instala `ffmpeg 8.X` con el codificador `libsvtav1`. Si tienes problemas (p. ej., falta `libsvtav1` — compruébalo con `ffmpeg -encoders` — o hay una incompatibilidad de versiones con `torchcodec`), puedes instalar explícitamente `ffmpeg 7.1.1` usando:
>
> ```bash
> conda install ffmpeg=7.1.1 -c conda-forge
> ```

= solo 2.10)>

A partir de **PyTorch >= 2.10** (TorchCodec ≥ 0.10), TorchCodec puede enlazar dinámicamente con una instalación de `ffmpeg` a nivel de sistema. Esto es útil al usar `uv` u otros gestores de entornos que no son `conda`:

```bash
# Ubuntu/Debian
sudo apt install ffmpeg

# macOS (Apple Silicon)
brew install ffmpeg
```

> [!IMPORTANT]
> El `ffmpeg` del sistema es **compatible únicamente con PyTorch >= 2.10** (TorchCodec ≥ 0.10). Para versiones anteriores de PyTorch, **debe** utilizar `conda install ffmpeg -c conda-forge` en su lugar.

## Paso 3: Instalar LeRobot 🤗

La instalación base de `lerobot` es intencionalmente **ligera**: solo incluye las dependencias de ML esenciales (PyTorch, torchvision, numpy, opencv, einops, draccus, huggingface-hub, gymnasium, safetensors). Las dependencias más pesadas están detrás de extras opcionales para que solo instales lo que necesitas.

### Desde la fuente

Primero, clona el repositorio y navega al directorio:

```bash
git clone https://github.com/huggingface/lerobot.git
cd lerobot
```

Luego, instala la biblioteca en modo editable. Esto es útil si planeas contribuir al código.

```bash
pip install -e ".[core_scripts]"  # For robot workflows (recording, replaying, calibrate)
pip install -e ".[training]"      # For training policies
pip install -e ".[all]"           # Everything (all policies, envs, hardware, dev tools)
```

```bash
uv pip install -e ".[core_scripts]"  # For robot workflows (recording, replaying, calibrate)
uv pip install -e ".[training]"      # For training policies
uv pip install -e ".[all]"           # Everything (all policies, envs, hardware, dev tools)
```

### Instalación desde PyPI

**Biblioteca principal:** instala el paquete base con:

```bash
pip install lerobot
```

```bash
uv pip install lerobot
```

_Esto instala solo las dependencias de ML principales. Necesitarás agregar extras para la mayoría de los flujos de trabajo._

**Extras de funciones:** LeRobot ofrece **extras por función** que se corresponden con flujos de trabajo habituales. Si estás usando `uv`, sustituye `pip install` por `uv pip install` en los comandos siguientes.

| Extra      | Lo que añade                                | Caso de uso típico                    |
| ---------- | ------------------------------------------- | ----------------------------------- |
| `dataset`  | `datasets`, `av`, `torchcodec`, `jsonlines` | Carga y creación de conjuntos de datos         |
| `training` | `dataset` + `accelerate`, `trackio`         | Políticas de entrenamiento                   |
| `hardware` | `pynput`, `pyserial`, `deepdiff`            | Conexión con robots reales           |
| `viz`      | `rerun-sdk`, `foxglove-sdk`                 | Visualización durante la grabación/evaluación |

Los **Composite Extras** combinan los extras de funciones para los scripts de CLI comunes:

| Extra          | Incluye                       | Caso de uso típico                                        |
| -------------- | ------------------------------ | ------------------------------------------------------- |
| `core_scripts` | `dataset` + `hardware` + `viz` | `lerobot-record`, `lerobot-replay`, `lerobot-calibrate` |
| `evaluation`   | `av`                           | `lerobot-eval` (añada extras de política y entorno según sea necesario)      |
| `dataset_viz`  | `dataset` + `viz`              | `lerobot-dataset-viz`, `lerobot-imgtransform-viz`       |

```bash
pip install 'lerobot[core_scripts]'          # Record, replay, calibrate
pip install 'lerobot[training]'              # Train policies
pip install 'lerobot[core_scripts,training]' # Record + train
pip install 'lerobot[all]'                   # Everything
```

Los **extras de política, entorno y hardware** siguen disponibles para dependencias específicas:

```bash
pip install 'lerobot[pi]'             # Pi0/Pi0.5/Pi0-FAST policy deps
pip install 'lerobot[smolvla]'        # SmolVLA policy deps
pip install 'lerobot[diffusion]'      # Diffusion policy deps (diffusers)
pip install 'lerobot[aloha,pusht]'    # Simulation environments
pip install 'lerobot[feetech]'        # Feetech motor support
```

_Se pueden combinar varios extras (p. ej., `.[core_scripts,pi,pusht]`). Para obtener la lista completa de extras disponibles, consulte `pyproject.toml`._

### Variante de PyTorch CUDA (solo Linux)

En Linux, `torch` y `torchvision` provienen de PyPI, cuyos wheels por defecto son compilaciones de CUDA 13 (driver mínimo **580.65**). Las instalaciones en macOS y Windows usan los wheels por defecto de PyPI y pueden omitir esta sección.

Para un controlador o GPU más antiguos, instale primero PyTorch desde el [índice de PyTorch](https://pytorch.org/get-started/locally/) correspondiente y luego LeRobot. El TorchCodec de Linux en PyPI también es una compilación de CUDA 13, así que obténgalo del índice de CPU (con torch por debajo de 2.11, elija la versión correspondiente de la [tabla de compatibilidad de TorchCodec](https://github.com/meta-pytorch/torchcodec#installing-torchcodec)):

```bash
pip install --index-url https://download.pytorch.org/whl/cu126 torch torchvision
pip install --index-url https://download.pytorch.org/whl/cpu torchcodec
pip install -e ".[all]"          # source
# — or —
pip install lerobot              # from PyPI
```

> [!NOTE]
> `cu126` es la compilación que PyTorch mantiene para controladores que solo admiten CUDA 12. torch 2.15 no tiene una compilación para CUDA 12, por lo que este índice instala torch 2.14, y permanecer en CUDA 12 significa permanecer en torch 2.14 o una versión anterior.

Con `uv pip`, `--torch-backend` selecciona el índice en un solo paso, por ejemplo, `uv pip install --torch-backend cu126 lerobot`. `uv sync` siempre instala el lock comprometido: para cambiar la compilación de CUDA allí, añade el índice a `[tool.uv.index]` y `[tool.uv.sources]` en `pyproject.toml` y vuelve a ejecutar `uv lock`.

### Solución de problemas

Si encuentras errores de compilación, es posible que necesites instalar dependencias del sistema adicionales: `cmake`, `build-essential` y `ffmpeg libs`. Para instalarlos en Linux, ejecuta:

```bash
sudo apt-get install cmake build-essential python3-dev pkg-config libavformat-dev libavcodec-dev libavdevice-dev libavutil-dev libswscale-dev libswresample-dev libavfilter-dev
```

Para otros sistemas, consulte: [Compilar PyAV](https://pyav.org/docs/develop/overview/installation.html#bring-your-own-ffmpeg)

## Dependencias opcionales

LeRobot ofrece extras opcionales para funcionalidades específicas. Se pueden combinar varios extras (p. ej., `.[aloha,feetech]`). Para ver todos los extras disponibles, consulte `pyproject.toml`. Si está usando `uv`, reemplace `pip install` por `uv pip install` en los comandos siguientes.

### Simulaciones

Instale los paquetes del entorno: `aloha` ([gym-aloha](https://github.com/huggingface/gym-aloha)), `pusht` ([gym-pusht](https://github.com/huggingface/gym-pusht)), [`libero`](./libero) (solo Linux) o [`metaworld`](./metaworld). Estos incluyen automáticamente el extra `dataset`.

```bash
pip install -e ".[aloha]" # or "[pusht]" for example
```

### Control de motores

Instale el extra para sus motores: `dynamixel` para Koch v1.1, `feetech` para SO100/SO101/Moss. Ambos se comunican con los motores a través de [rustypot](https://github.com/pollen-robotics/rustypot).

```bash
pip install -e ".[feetech]" # or "[dynamixel]" for example
```

### Seguimiento de experimentos

[Trackio](https://huggingface.co/docs/trackio) se incluye en el extra `training`. Las ejecuciones locales no requieren cuenta ni inicio de sesión: se almacenan en una base de datos SQLite local bajo `~/.cache/huggingface/trackio`. Abre el panel de control con:

```bash
trackio show --project lerobot
```

Para sincronizar las ejecuciones con un Space de Hugging Face (se crea si no existe), ejecute `hf auth login` y pase `--trackio.space_id=<user>/<space>`. Los trabajos remotos (`--job.target`) con seguimiento habilitado requieren `space_id`, porque la base de datos local del pod se pierde cuando el trabajo termina.

La privacidad de Space predeterminada es `None`: los nuevos Spaces son públicos a menos que el valor predeterminado de la organización sea privado. Pasa `--trackio.private=true` para crear un Space privado.

Cada ejecución registra el comando que la inició y su salida de consola (impresiones, registros, trazas de errores), ambos mostrados en la página de la ejecución en el panel de control. En un Space, son tan visibles como el propio Space; pasa `--trackio.capture_console=false` para mantener la salida de consola fuera de la ejecución.

#### Migrar desde Weights & Biases

| Configuración de W&B                     | Configuración de Trackio                                                                                  |
| ------------------------------- | ------------------------------------------------------------------------------------------------ |
| `--wandb.enable=true`           | `--trackio.enable=true`                                                                          |
| `--wandb.project=<project>`     | `--trackio.project=<project>`                                                                    |
| `--wandb.disable_artifact=true` | Ya es el valor predeterminado; use `--trackio.disable_artifact=false` para activarlo                            |
| `--wandb.entity=<team>`         | Elija `--trackio.space_id=<user-or-org>/<space>` para el registro alojado                             |
| `--wandb.run_id=<id>`           | Usa `--trackio.run_name=<name>` para una ejecución existente de **Trackio**                                  |
| `--wandb.mode=offline`          | Omite `space_id` para el registro local; también desestablece `TRACKIO_SPACE_ID` y `TRACKIO_SERVER_URL` si están establecidos |
| `--wandb.mode=disabled`         | `--trackio.enable=false`                                                                         |
| `--wandb.console=off`           | `--trackio.capture_console=false`                                                                |

## Próximos pasos

- **¿Tienes un robot?** Ensámblalo y calíbralo siguiendo su página en la sección **Robots** de la barra lateral (por ejemplo, [SO-101](./so101)), luego registra un conjunto de datos y entrena tu primera política con el [tutorial de aprendizaje por imitación](./il_robots).
- **¿Aún no tienes hardware?** Entrena y evalúa una política en simulación con [LIBERO](./libero), o prueba los [notebooks de Colab](./notebooks).
- **¿Quieres contribuir?** Lee la [guía de contribución](./contributing).
- Tenga a mano la [hoja de trucos](./cheat-sheet): enumera todos los comandos de LeRobot en un solo lugar.