Blame for README.md

---
license: mit
language:
- vi
task_categories:
- text-generation
tags:
- robotics
- navigation
- grid-navigation
- path-planning
- multi-goal
- planning
- synthetic
size_categories:
- 100K<n<1M
pretty_name: ISB GridNavLM Dataset
configs:
- config_name: all_tasks
  default: true
  data_files:
  - split: train
    path: data/*/train-*.jsonl.gz
  - split: validation
    path: data/*/validation-*.jsonl.gz
  - split: test
    path: data/*/test-*.jsonl.gz
- config_name: single_goal
  data_files:
  - split: train
    path: data/single_goal/train-*.jsonl.gz
  - split: validation
    path: data/single_goal/validation-*.jsonl.gz
  - split: test
    path: data/single_goal/test-*.jsonl.gz
- config_name: ordered_goals
  data_files:
  - split: train
    path: data/ordered_goals/train-*.jsonl.gz
  - split: validation
    path: data/ordered_goals/validation-*.jsonl.gz
  - split: test
    path: data/ordered_goals/test-*.jsonl.gz
- config_name: visit_all_goals
  data_files:
  - split: train
    path: data/visit_all_goals/train-*.jsonl.gz
  - split: validation
    path: data/visit_all_goals/validation-*.jsonl.gz
  - split: test
    path: data/visit_all_goals/test-*.jsonl.gz
---

# ISB GridNavLM: bộ dữ liệu dạy mô hình ngôn ngữ tìm đường cho robot

> Hugging Face: [PhysicalSI/ISB_GridNavLM_Dataset](https://huggingface.co/datasets/PhysicalSI/ISB_GridNavLM_Dataset) · License: MIT

## 1. Bộ dữ liệu này là gì?

Hãy tưởng tượng một robot hút bụi đứng trong một văn phòng. Ta chia sàn nhà thành các ô vuông như bàn cờ:
ô có bàn ghế, tường là **ô chặn** (`#`), ô trống là **ô đi được** (`.`). Robot đứng ở ô `A` và phải đi tới
ô đích `G`, mỗi lượt chỉ được đi một ô theo một trong bốn hướng `up`, `down`, `left`, `right`.

```
#####
##..#
#AG.#        Robot ở A = [2,1], đích G = [2,2]
#####        Đáp án ngắn nhất: right (1 bước)
```

Bộ dữ liệu gồm **198.000 bài toán** như vậy, **viết bằng tiếng Việt** để đưa cho mô hình ngôn ngữ (LLM), kèm
**đáp án tối ưu** để chấm điểm. Bản đồ không phải vẽ tay: chúng được cắt từ **1.000 căn phòng 3D** (văn phòng,
bệnh viện, nhà kho, nhà ở) dựng trong NVIDIA Isaac Sim, rồi chia ô theo kích thước thật của **11 mẫu robot**
(TurtleBot, Clearpath Husky, Jackal, ...). Robot to thì ô to, nên cùng một căn phòng sẽ cho bản đồ khác nhau
với từng robot.

Mỗi bài toán còn mô tả **phòng nào, đồ vật gì nằm ở ô nào** (bàn, ghế, tủ, cây, cửa, tường), nên mô hình có thể
học liên hệ giữa ngôn ngữ, không gian và đồ vật, không chỉ giải mê cung.

## 2. Dùng để làm gì?

| Mục đích | Cách dùng |
|---|---|
| **Fine-tune (SFT) một LLM** để lập kế hoạch đường đi | Đầu vào = `text` (hoặc một phần, xem mục 5), đầu ra = chuỗi hành động trong `ground_truth_json` |
| **Đánh giá (benchmark) LLM** về suy luận không gian | Cho mô hình giải tập `test`, chấm bằng đoạn code ở mục 6 |
| **Học theo độ khó tăng dần** (curriculum) | Bắt đầu từ `single_goal`, bản đồ nhỏ, đường ngắn; sau đó tới 3 rồi 5 đích |
| **So sánh mô hình với thuật toán cổ điển** | Đáp án là tối ưu (BFS / Held-Karp), nên đo được mô hình đi dài hơn tối ưu bao nhiêu |
| **Nghiên cứu robot / RL / planner cổ điển** | Dùng thư mục `navigation_tasks/` (48.180 bài toán dạng lưới, định dạng navsim), xem mục 8 |

## 3. Ba loại nhiệm vụ

| Loại (`task_type`) | Ý nghĩa | Số đích | Số bài |
|---|---|---|---:|
| `single_goal` | Đi tới một đích | 1 | 66.000 |
| `ordered_goals` | Ghé các đích **theo đúng thứ tự cho trước**. Đi ngang qua đích sau trước khi tới lượt thì **không tính** | 2, 3, 5 | 66.000 (22.000 mỗi mức) |
| `visit_all_goals` | Ghé **tất cả** các đích, **thứ tự tuỳ ý** | 2, 3, 5 | 66.000 (22.000 mỗi mức) |

Luật chung:
- Toạ độ là `[hàng, cột]`, đếm từ 0, ô `[0,0]` ở góc trên bên trái; `down` làm tăng hàng, `right` làm tăng cột.
- Đi vào ô chặn hoặc ra ngoài bản đồ: robot **đứng yên nhưng vẫn mất một lượt**. Hành động viết sai cũng vậy.
- Đích được tính ngay khi robot **bước vào** ô đó; không cần lệnh dừng và không phải quay về điểm xuất phát.
- Mỗi bài có ngân sách tối đa (`budget`, hiện là 200 lượt) cho toàn bộ nhiệm vụ.

Mỗi bài `ordered_goals` có một bài `visit_all_goals` "anh em" dùng cùng bản đồ, cùng điểm xuất phát và cùng
các đích (chung `scenario_id`), nên có thể so sánh trực tiếp hai kiểu nhiệm vụ.

## 4. Trong repo có gì?

```
data/                         ← các bài toán (đây là phần chính)
  single_goal/     train-00000.jsonl.gz ... validation-... test-...
  ordered_goals/   ...
  visit_all_goals/ ...
maps/<robot>/<map_id>.json.gz ← bản đồ dạng số (0 = đi được, 1 = chặn) + chú thích phòng / đồ vật
robots/<robot>.json           ← thông số robot (kích thước, kiểu dẫn động, LiDAR, tốc độ)
examples/                     ← ví dụ dễ đọc: file .txt là đề bài, file .json cùng tên có đáp án
metadata/                     ← thống kê, cách chia tập, checksum, kết quả kiểm tra
schema/record.json            ← mô tả từng trường
navigation_tasks/             ← bộ 48.180 bài toán cân bằng dạng lưới (xem mục 8)
```

**Mở `examples/single_goal.txt` trước** để xem nguyên văn một đề bài mà mô hình nhận được.

### Cách đặt tên

- Căn phòng (scene): `scene_<cạnh, mét>m_<số thứ tự>`. Ví dụ `scene_05m_000` là căn phòng 5 m × 5 m đầu tiên.
- Bản đồ của một robot: `<scene>__<robot>`. Ví dụ `scene_05m_000__clearpath_dingo`.
- 11 robot: `clearpath_dingo`, `clearpath_husky`, `clearpath_jackal`, `clearpath_ridgeback`, `jetauto_pro`,
  `jetbot`, `pal_tiago`, `turtlebot3_burger`, `turtlebot3_waffle_pi`, `turtlebot4`, `turtlebot4_lite`.

### Chia tập train / validation / test

| Tập | Số căn phòng | Số bài |
|---|---:|---:|
| `train` | 782 | 158.393 |
| `validation` | 98 | 19.801 |
| `test` | 98 | 19.806 |

Chia **theo căn phòng**: một căn phòng (với mọi robot và mọi biến thể nhiệm vụ) chỉ nằm trong đúng một tập.
Vì vậy điểm trên `test` đo khả năng giải **căn phòng chưa từng thấy**, không phải khả năng nhớ bản đồ.

### Các trường của một bài toán

| Trường | Ý nghĩa | Đưa cho mô hình? |
|---|---|---|
| `text` | Đề bài đầy đủ bằng tiếng Việt: hệ toạ độ, luật, robot, bản đồ, phòng, đồ vật, nhiệm vụ | **Có** |
| `sections_json` | Cùng nội dung với `text` nhưng tách thành từng mục, để tự ghép đề bài ngắn hơn | **Có** (tuỳ chọn mục) |
| `task_json` | Điểm xuất phát, các đích, thứ tự bắt buộc (`required_order`), ngân sách | Có (đã nằm trong `text`) |
| `ground_truth_json` | Đáp án: một đường đi tối ưu (`path_coordinates`, `actions`, `path_text`), thứ tự ghé đích | **Không**, chỉ để huấn luyện / chấm |
| `shortest_length_path`, `shortest_path_length_m` | Độ dài tối ưu, tính bằng số bước và bằng mét | **Không** |
| `task_type`, `goal_count`, `split`, `robot_id`, `map_id`, `source_scene_id` | Dùng để lọc, thống kê | Không cần |
| `map_ref`, `robot_ref` | Đường dẫn tới file bản đồ / robot trong repo | Không cần |

Các trường `*_json` là **chuỗi JSON**, cần `json.loads(...)` trước khi dùng.

## 5. Bắt đầu nhanh

Cài thư viện:

```bash
pip install datasets huggingface_hub
```

### Đọc dữ liệu

```python
import json
from datasets import load_dataset

# Config: "all_tasks" (mặc định), "single_goal", "ordered_goals", "visit_all_goals"
ds = load_dataset("PhysicalSI/ISB_GridNavLM_Dataset", "single_goal", split="validation", streaming=True)

row = next(iter(ds))
print(row["task_type"], row["robot_id"], row["map_id"])
print(row["text"][:500])                                  # đề bài
print(json.loads(row["ground_truth_json"])["path_text"])  # đáp án, ví dụ "right"
```

`streaming=True` đọc dần, không phải tải hết 2,4 GB. Bỏ tham số này nếu muốn tải về máy một lần.

### Đề bài ngắn hay đề bài đầy đủ?

`text` rất chi tiết (trung vị khoảng 40.000 ký tự, dài nhất khoảng 220.000) vì liệt kê từng phòng, đồ vật và ô.
Nếu mô hình có cửa sổ ngữ cảnh nhỏ, hãy chỉ ghép các mục cần thiết từ `sections_json`; đề bài khi đó chỉ còn
khoảng 700–950 ký tự:

```python
def short_prompt(row):
    s = json.loads(row["sections_json"])
    return "\n\n".join([
        "HỆ TOẠ ĐỘ\n" + s["coordinate_system"],
        "QUY TẮC\n" + s["movement_rules"],
        "BẢN ĐỒ (#=chặn, .=trống, A=xuất phát, G=đích)\n" + s["map_layout"],
        "ĐÍCH\n" + "\n".join(s["goal_legend"]),
        "NHIỆM VỤ\n" + s["task"],
        "Trả lời bằng chuỗi hành động up/down/left/right, cách nhau bởi dấu cách.",
    ])
```

Các mục khác trong `sections_json`: `robot`, `map_summary`, `map_rows`, `rooms`, `objects`, `structures`,
`openings`, `cells`, `annotation_quality`, `initial_state`. Thêm `rooms` và `objects` khi muốn mô hình
dùng thông tin ngữ nghĩa (ví dụ "đi tới cạnh cái bàn").

### Tạo dữ liệu fine-tune (SFT)

```python
def to_chat(row):
    answer = json.loads(row["ground_truth_json"])["path_text"]   # ví dụ "up down left left"
    return {"messages": [
        {"role": "user", "content": short_prompt(row)},
        {"role": "assistant", "content": answer},
    ]}

train = load_dataset("PhysicalSI/ISB_GridNavLM_Dataset", "all_tasks", split="train")
train_chat = train.map(to_chat, remove_columns=train.column_names)
```

Một bài có thể có **nhiều đáp án tối ưu**; `ground_truth_json` chỉ ghi một đáp án. Khi đánh giá, đừng so
khớp chuỗi với đáp án mẫu mà hãy chấm bằng mô phỏng (mục 6).

## 6. Chấm điểm câu trả lời của mô hình

Đoạn code dưới đây cho robot đi theo câu trả lời trên bản đồ thật và áp dụng đúng luật ở mục 3.

```python
import gzip, json
from functools import lru_cache
from huggingface_hub import hf_hub_download

REPO = "PhysicalSI/ISB_GridNavLM_Dataset"
MOVES = {"up": (-1, 0), "down": (1, 0), "left": (0, -1), "right": (0, 1)}

@lru_cache(maxsize=256)
def load_grid(map_ref):
    path = hf_hub_download(REPO, map_ref, repo_type="dataset")
    with gzip.open(path, "rt", encoding="utf-8") as fh:
        return json.load(fh)["grid"]          # grid[hàng][cột]: 0 = đi được, 1 = chặn

def score(row, answer: str) -> dict:
    task = json.loads(row["task_json"])
    grid = load_grid(row["map_ref"])
    goals = {g["id"]: tuple(g["cell"]) for g in task["goals"]}
    order = task["required_order"] or [g["id"] for g in task["goals"]]
    pos, done, steps = tuple(task["start"]), [], 0
    for action in answer.split()[: task["budget"]]:
        steps += 1
        dr, dc = MOVES.get(action, (0, 0))    # hành động sai: đứng yên, vẫn mất lượt
        r, c = pos[0] + dr, pos[1] + dc
        if 0 <= r < len(grid) and 0 <= c < len(grid[0]) and grid[r][c] == 0:
            pos = (r, c)
        if task["task_type"] == "visit_all_goals":
            done += [g for g, cell in goals.items() if cell == pos and g not in done]
        elif len(done) < len(order) and goals[order[len(done)]] == pos:
            done.append(order[len(done)])     # single / ordered: chỉ tính đích kế tiếp
        if len(done) == len(goals):
            break
    success = len(done) == len(goals)
    best = row["shortest_length_path"]
    return {"success": success,
            "steps": steps,
            "optimal": success and steps == best,
            "spl": best / max(steps, best) if success else 0.0}   # 1.0 = đi đúng đường ngắn nhất

row = next(iter(load_dataset(REPO, "visit_all_goals", split="test", streaming=True)))
print(score(row, json.loads(row["ground_truth_json"])["path_text"]))
# {'success': True, 'steps': ..., 'optimal': True, 'spl': 1.0}
```

Chỉ số nên báo cáo:
- **Success rate**: tỉ lệ bài giải xong.
- **Optimal rate**: tỉ lệ bài giải xong với đúng số bước tối ưu.
- **SPL**: trung bình `spl`; điểm cao khi vừa tới đích vừa đi ngắn.

Nên báo cáo riêng theo `task_type` và `goal_count`, vì bài 5 đích khó hơn nhiều so với bài 1 đích.

## 7. Bộ dữ liệu được tạo và kiểm tra thế nào?

1. **Dựng căn phòng 3D**: 1.000 căn phòng, 10 kích thước từ 2 m đến 17 m, 4 chủ đề, đặt đồ đạc ngẫu nhiên có
   kiểm soát mật độ.
2. **Chia ô theo từng robot**: chụp bản đồ nhìn từ trên xuống, chia thành ô có cạnh theo cỡ thân robot (tối đa
   15 × 15 ô bên trong); ô nào chạm vật cản (cộng lề an toàn 5 cm) thì bị chặn.
3. **Sinh nhiệm vụ**: chọn điểm xuất phát và các đích trong vùng liên thông, cân bằng theo robot, loại nhiệm vụ,
   số đích và độ dài đường đi.
4. **Tính đáp án tối ưu**: BFS trên lưới 4 hướng cho bài 1 đích và bài có thứ tự; với bài ghé tất cả thì dùng
   BFS kết hợp thuật toán Held-Karp để chọn thứ tự tốt nhất.
5. **Kiểm tra**: toàn bộ 198.000 đáp án được kiểm lại là hợp lệ và tối ưu; không có bài trùng; không có căn
   phòng nào xuất hiện ở hai tập. Chi tiết trong `metadata/audit.json` và `metadata/manifest.json`.

## 8. Bộ phụ: `navigation_tasks/` (48.180 bài, dạng lưới)

Đây là bộ bài toán **một đích** ở dạng số, không có văn bản, dành cho planner cổ điển, học tăng cường hoặc
môi trường mô phỏng navsim.

- Mỗi kích thước phòng (2, 3, 4, 5, 6, 8, 10, 12, 15, 17 m) có đúng 4.818 bài, chia đều đường ngắn / vừa / dài.
- Độ khó dễ / vừa / khó theo tỉ lệ 60 / 30 / 10, đo bằng xác suất một robot đi ngẫu nhiên tình cờ tới đích.
- `navigation_tasks/tasks/<robot>/<map_id>.json`: điểm đầu, điểm đích (ô và toạ độ mét), đường đi ngắn nhất
  `path_cells`, nhãn độ khó.
- `navigation_tasks/grids/<map_id>.npz`: lưới số (0 = trống, 1 = chặn).
- `navigation_tasks/task_list.csv`: bảng tra một dòng một bài.
- Bộ này **chưa chia tập**. Nếu tự chia, hãy chia theo `source_scene_id` (theo căn phòng).
- Số bài giữa các robot không đều: phòng 17 m chỉ vừa với Clearpath Husky (10.003 bài), trong khi Jetbot và
  TurtleBot 4 mỗi loại có 482 bài.

Hướng dẫn chi tiết ở `navigation_tasks/README.md`.

## 9. Giới hạn cần biết

- Bản đồ là **dữ liệu tổng hợp**. Các đường đi chưa được thử bằng mô phỏng vật lý hay robot thật.
- Đường đi tối ưu theo **số ô trên lưới**, không phải quỹ đạo mượt hay nhanh nhất của robot thật.
- Thông số LiDAR và tốc độ trong `robots/` là **thông số kỹ thuật của nhà sản xuất**, không phải dữ liệu cảm biến.
- Nhiều bài có đường đi rất ngắn. Nhãn độ dài và độ khó chỉ so sánh **trong cùng nhóm** (robot, loại nhiệm vụ,
  số đích), không phải thang độ khó chung.
- Repo không chứa mô hình 3D (USD) và texture của các căn phòng.

## 10. Câu hỏi thường gặp

**Có nên gộp `all_tasks` với `single_goal` không?**
Không. `single_goal`, `ordered_goals` và `visit_all_goals` là các phần con của `all_tasks`; gộp lại sẽ bị trùng.

**Vì sao đáp án mẫu của mô hình khác `ground_truth_json` mà vẫn đúng?**
Thường có nhiều đường cùng độ dài tối ưu. Hãy chấm bằng hàm `score` ở mục 6.

**Toạ độ ô đổi ra mét thế nào?**
Mục `coordinate_system` của mỗi bài ghi công thức, ví dụ `x = 0.0875 + cột × 0.575`, `y = 2.3375 − hàng × 0.575`.

**Robot có quay đầu không?**
Không. Hành động là hướng trên bản đồ (lên / xuống / trái / phải), không phụ thuộc hướng mặt của robot.

## License

MIT.