| --- |
| 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. |
|
|
