# Bảng tra cứu nhanh

Tất cả các lệnh LeRobot được tập hợp tại một nơi. Nếu bạn quên cách sử dụng một lệnh cụ thể hoặc muốn tìm hiểu về một lệnh mới, bạn có thể thực hiện điều đó tại đây.

> [!WARNING]
> Đối với tất cả các lệnh được liệt kê bên dưới, hãy nhớ thay đổi các cổng/tên/id thành giá trị của riêng bạn!

> [!TIP]
> Một cách tuyệt vời khác để xem tất cả các lệnh và cấu hình chúng cho thiết lập cụ thể của bạn là sử dụng [Jupyter Notebook](https://github.com/huggingface/lerobot/blob/main/examples/notebooks/quickstart.ipynb) này.

### Cài đặt và thiết lập

Để cài đặt, hãy xem [Cài đặt LeRobot](./installation).

### Công cụ hữu ích

###### Tìm cổng

Sử dụng lệnh này để xác định cổng serial mà robot của bạn được kết nối. Làm theo các hướng dẫn trong terminal: bạn sẽ được yêu cầu rút cáp USB và nhấn Enter. Sau đó, script sẽ phát hiện và in ra cổng serial chính xác cho robot đó.

```bash
lerobot-find-port
```

###### Tìm camera

Tìm nhanh chỉ số camera và xác minh đầu ra của chúng. Lệnh này in thông tin camera ra terminal và lưu các khung hình thử nghiệm từ mỗi camera được phát hiện vào `outputs/captured_images`

```bash
lerobot-find-cameras
```

### Hiệu chuẩn

Trong hầu hết các trường hợp, bạn sẽ chỉ cần thực hiện hiệu chuẩn một lần cho mỗi robot và thiết bị điều khiển từ xa. Trước khi thực hiện hiệu chuẩn, hãy đảm bảo rằng tất cả các khớp đều ở vị trí trung tâm xấp xỉ.

```bash
lerobot-calibrate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm
```

Hãy đảm bảo rằng bạn sử dụng cùng các ID đã dùng trong quá trình hiệu chuẩn cho các script khác sau đó. Đó là cách LeRobot tìm thấy các tệp hiệu chuẩn.

### Điều khiển từ xa

Điều khiển từ xa bằng hai camera và hiển thị dữ liệu bằng Rerun.

```bash
lerobot-teleoperate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_leader_arm \
    --display_data=true
```

### Ghi lại một tập dữ liệu

Bộ dữ liệu sẽ được tải lên Hugging Face Hub một cách tự động dưới `repo_id`. Hãy đảm bảo bạn đã đăng nhập vào tài khoản HF của mình bằng CLI (bạn có thể lấy token từ [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)), và lưu tên người dùng của bạn vào `HF_USER`, các lệnh bên dưới sẽ sử dụng biến này:

```bash
lerobot-record \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_leader_arm \
    --dataset.repo_id=${HF_USER}/so101_dataset_test \
    --dataset.num_episodes=30 \
    --dataset.single_task="put the red brick in a bowl" \
    --dataset.streaming_encoding=true \
    --display_data=true
```

Trong khi thu thập bộ dữ liệu, bạn có thể kiểm soát quy trình bằng bàn phím:

- Nhấn **Mũi tên phải (`→`)** hoặc **`n`**: Lưu tập và chuyển sang tập tiếp theo.
- Nhấn **Phím mũi tên trái (`←`)** hoặc **`r`**: Xóa tập hiện tại và thử lại.
- Nhấn **Escape (`ESC`)** hoặc **`q`**: Dừng, mã hóa video và tải lên.

> [!WARNING]
> `lerobot-record` thêm ngày và giờ của phiên vào cuối `--dataset.repo_id`, do đó `${HF_USER}/so101_dataset_test` được lưu dưới dạng `${HF_USER}/so101_dataset_test_YYYYMMDD_HHMMSS`. Tìm tên đầy đủ trên hồ sơ Hugging Face của bạn hoặc bằng `ls ~/.cache/huggingface/lerobot/${HF_USER}`, và sử dụng nó trong các lệnh huấn luyện bên dưới. Thêm `--dataset.no_stamp=true` để giữ nguyên tên chính xác.

### Độ sâu ghi

Camera Intel RealSense (`type: intelrealsense`) ghi lại luồng chiều sâu khi bạn đặt `use_depth: true`. Chiều sâu được lượng tử hóa thành mã 12-bit và được lưu trữ dưới dạng video riêng.

```bash
lerobot-record \
    ... \
    --robot.cameras="{ head: {type: intelrealsense, serial_number_or_name: \"0123456789\", width: 640, height: 480, fps: 30, use_depth: true} }" \
    --dataset.repo_id=${HF_USER}/so101_depth_test \
    --dataset.single_task="put the red brick in a bowl" \
    --dataset.depth_encoder.depth_min=0.01 \
    --dataset.depth_encoder.depth_max=10.0 \
    --dataset.depth_encoder.shift=0.0 \
    --dataset.depth_encoder.use_log=true
```

### Tham số mã hóa video

Các luồng RGB và chiều sâu được mã hóa độc lập thông qua các khóa `--dataset.rgb_encoder.*` và `--dataset.depth_encoder.*`.

```bash
lerobot-record \
    ... \
    --dataset.rgb_encoder.vcodec=h264 \
    --dataset.rgb_encoder.pix_fmt=yuv420p \
    --dataset.rgb_encoder.crf=23 \
    --dataset.depth_encoder.vcodec=hevc \
    --dataset.depth_encoder.extra_options='{"x265-params": "lossless=1"}'
```

### Huấn luyện

Tùy thuộc vào phần cứng của bạn, việc huấn luyện chính sách có thể mất vài giờ. Đó là cách bạn huấn luyện chính sách `ACT` đơn giản:

```bash
lerobot-train \
    --dataset.repo_id=${HF_USER}/so101_dataset_test_YYYYMMDD_HHMMSS \
    --policy.type=act \
    --output_dir=outputs/train/act_so101_test \
    --job_name=act_so101_test \
    --policy.device=cuda \
    --trackio.enable=true \
    --policy.repo_id=${HF_USER}/policy_test \
    --steps=20000
```

- Các loại policy phổ biến: `act`, `diffusion`, `multi_task_dit`, `smolvla`, `pi0`, `pi05`, `pi0_fast`, `groot`, `xvla`. Mỗi policy có trang riêng dưới **Policies** trong thanh bên, và [Compute & Hardware Guide](./hardware_guide) cho biết loại nào phù hợp với GPU của bạn.
- Thiết bị: `cuda` (NVIDIA), `mps` (Apple Silicon), `cpu`

`--policy.type` tạo một policy mới có kiểu đó và huấn luyện nó từ đầu trên dataset của bạn (một số policy vẫn bắt đầu từ các backbone thị giác hoặc ngôn ngữ đã được huấn luyện trước, như được cấu hình trong config của chúng). Để fine-tune một model hiện có, hãy truyền `--policy.path` kèm theo một checkpoint cục bộ hoặc một Hub repo id: kiểu policy và config sẽ được đọc từ đó, do đó không cần `--policy.type`.

```bash
lerobot-train \
    --dataset.repo_id=${HF_USER}/so101_dataset_test_YYYYMMDD_HHMMSS \
    --policy.path=username/the_policy_to_finetune \
    --policy.device=cuda \
    --policy.repo_id=${HF_USER}/policy_finetuned_test \
    --output_dir=outputs/train/finetuned_so101_test \
    --steps=20000
```

Không có GPU cục bộ? Thêm `--job.target=<flavor>` (ví dụ `a10g-small`) vào một trong hai lệnh và `lerobot-train` sẽ chạy nó trên [Hugging Face Jobs](https://huggingface.co/docs/hub/jobs) thay thế — công cụ sẽ tải lên một dataset chỉ dùng cục bộ cho bạn và đẩy mô hình đã huấn luyện. Liệt kê các flavor bằng `hf jobs hardware`. Để theo dõi các chỉ số của job, thêm `--trackio.enable=true --trackio.space_id=<user>/<space>`: cơ sở dữ liệu Trackio cục bộ của pod sẽ không tồn tại sau khi job kết thúc.

Để tiếp tục, chỉ `--config_path` đến một checkpoint và thêm `--resume=true`. Nó chấp nhận một đường dẫn cục bộ hoặc id repo trên Hub (checkpoint mới nhất sẽ được tải về), và hoạt động cục bộ hoặc trên một job bằng cách thêm `--job.target=<flavor>`:

```bash
lerobot-train --config_path=${HF_USER}/policy_test --resume=true --job.target=a10g-small
```

### Suy luận

Inference có nghĩa là chạy chính sách/mô hình đã được huấn luyện trên robot. Để làm điều này, chúng ta sử dụng `lerobot-rollout`. Bạn cần cung cấp đường dẫn đến chính sách của mình. Đó có thể là đường dẫn cục bộ hoặc id kho Hugging Face, ví dụ `${HF_USER}/policy_test` từ lệnh huấn luyện ở trên. Hãy sử dụng cùng cổng, `--robot.id`, cấu hình camera và mô tả tác vụ như khi thu thập bộ dữ liệu. `--duration` được tính bằng giây; nếu không được chỉ định, chính sách sẽ chạy cho đến khi bạn dừng nó.

> [!TIP]
> Trên v0.5.x và các phiên bản trước đó, `lerobot-rollout` không tồn tại và bạn cần sử dụng `lerobot-record` thay thế. Thông tin chi tiết [tại đây](https://huggingface.co/docs/lerobot/v0.5.1/en/il_robots#run-inference-and-evaluate-your-policy).

```bash
lerobot-rollout \
    --strategy.type=base \
    --policy.path=${HF_USER}/policy_test \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ top: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
    --task="put the red brick in a bowl" \
    --duration=60
```