Replace dataset card with Vietnamese README

README.md

@@ -51,139 +51,281 @@ configs:
     path: data/visit_all_goals/test-*.jsonl.gz
 ---
 
-# ISB GridNavLM Dataset
+# ISB GridNavLM: bộ dữ liệu dạy mô hình ngôn ngữ tìm đường cho robot
 
-Grid navigation tasks for language models, built from 1,000 synthetic indoor scenes (generated with
-Isaac Scene Builder for Isaac Sim) and rasterised into occupancy grids for 11 mobile robots.
+> Hugging Face: [PhysicalSI/ISB_GridNavLM_Dataset](https://huggingface.co/datasets/PhysicalSI/ISB_GridNavLM_Dataset) · License: MIT
 
-The repository has two parts:
+## 1. Bộ dữ liệu này là gì?
 
-| Part | Content | Size |
+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? |
 |---|---|---|
-| `data/`, `maps/`, `robots/`, `metadata/`, `schema/`, `examples/` | **198,000 Vietnamese text tasks** (single goal, ordered goals, visit all goals) with exact ground truth, fixed scene-grouped train / validation / test split | ~2.4 GB |
-| `navigation_tasks/` | **48,180 balanced start/goal tasks** on 1,592 robot grids, in the navsim 2.0 dataset format, no split | ~69 MB |
+| `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
 
-## Quick start
+Cài thư viện:
+
+```bash
+pip install datasets huggingface_hub
+```
+
+### Đọc dữ liệu
 
 ```python
+import json
 from datasets import load_dataset
 
-rows = load_dataset("PhysicalSI/ISB_GridNavLM_Dataset", "all_tasks", split="train", streaming=True)
-for row in rows:
-    prompt_context = row["text"]          # model input (Vietnamese), or json.loads(row["sections_json"])
-    answer = row["ground_truth_json"]     # answer: never give it to the model
-    break
+# 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"
 ```
 
-Configurations: `all_tasks` (default), `single_goal`, `ordered_goals`, `visit_all_goals`. The three task
-configurations are subsets of `all_tasks`; do not concatenate them with it. `navigation_tasks/task_list.csv`
-is a table with one row per task of `navigation_tasks/`.
+`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.
 
-## Names
+### Đề bài ngắn hay đề bài đầy đủ?
 
-- Scene: `scene_<side length in metres>m_<number>`. For example, `scene_05m_000` is the first 5 m x 5 m scene.
-- Robot map: `<scene>__<robot>`. For example, `scene_05m_000__clearpath_dingo`.
-- Robots: `clearpath_dingo`, `clearpath_husky`, `clearpath_jackal`, `clearpath_ridgeback`, `jetauto_pro`,
-  `jetbot`, `pal_tiago`, `turtlebot3_burger`, `turtlebot3_waffle_pi`, `turtlebot4`, `turtlebot4_lite`.
+`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ự:
 
-## Text tasks
+```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.",
+    ])
+```
 
-### Files
+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").
 
-- `data/<task_type>/<split>-NNNNN.jsonl.gz`: one task per line.
-- `maps/<robot>/<map>.json.gz`: the grid, coordinate frame and semantic annotations (rooms, objects, walls, doors).
-- `robots/<robot>.json`: robot profiles (footprint, drive type, sensor and speed specifications from the source).
-- `metadata/`: generation settings, distribution audit, split assignment, manifest and checksums.
-- `schema/record.json`: field list and rules.
-- `examples/`: readable examples of every task type, with ground truth.
+### Tạo dữ liệu fine-tune (SFT)
 
-### Counts
+```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)
+```
 
-| Task type | Goals | Tasks |
-|---|---:|---:|
-| `single_goal` | 1 | 66,000 |
-| `ordered_goals` | 2 / 3 / 5 | 22,000 each |
-| `visit_all_goals` | 2 / 3 / 5 | 22,000 each |
+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).
 
-198,000 tasks from 132,000 scenarios: each multi-goal scenario is exported once as an ordered task and
-once as a visit-all task. Every robot has 18,000 tasks. Sources: 4,474 robot grids from 978 scenes.
+## 6. Chấm điểm câu trả lời của mô hình
 
-| Split | Scenes | Tasks |
-|---|---:|---:|
-| train | 782 | 158,393 |
-| validation | 98 | 19,801 |
-| test | 98 | 19,806 |
+Đ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.
 
-The split is grouped by scene (seed `20261101`, scene ratio 80/10/10): every scene and all of its robot
-grids and task variants belong to exactly one split.
+```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}
+```
 
-### Fields
+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.
 
-| Field | Meaning |
-|---|---|
-| `id`, `scenario_id` | task id; ordered and visit-all variants of one scenario share `scenario_id` |
-| `source_scene_id`, `map_id`, `robot_id` | scene, robot grid and robot |
-| `task_type`, `goal_count`, `split`, `language` | |
-| `start_row`, `start_column`, `goals_json`, `task_json` | the task: start cell, goal cells, order rule, step budget |
-| `text` | ready-to-use Vietnamese description of the coordinate system, rules, robot, map and task |
-| `sections_json` | the same text split into named sections, to build your own prompt |
-| `ground_truth_json` | one optimal path (cells and actions) and its length: **answer** |
-| `shortest_length_path`, `shortest_path_length_m` | optimal length in steps and metres: **answer** |
-| `metadata_json`, `map_ref`, `robot_ref` | provenance, links to `maps/` and `robots/` |
-
-`task_json`, `goals_json`, `ground_truth_json`, `sections_json` and `metadata_json` are JSON strings so
-the Arrow schema stays fixed.
-
-### Rules and ground truth
-
-- Actions are `up`, `down`, `left`, `right`, one cell per step, no diagonal moves. Cells are zero-based
-  `[row, column]` with row 0 at the top.
-- Every goal is a distinct free cell, different from the start. A goal counts when the robot enters its
-  cell. No return to the start.
-- Ordered tasks count only the next required goal. Visit-all tasks count every goal reached, in any order.
-- Ground truth is exact on the static 4-connected unit-cost grid: BFS for single and ordered tasks, BFS
-  distances plus open-path Held-Karp for visit-all. Any route of the same optimal length is correct.
-- Grids are conservative full-height occupancy maps with a safety margin for each robot. They are not
-  continuous robot trajectories or time-optimal motion plans.
-
-## Balanced navigation tasks (`navigation_tasks/`)
-
-- 4,818 tasks for each map size (2, 3, 4, 5, 6, 8, 10, 12, 15, 17 m), split equally into short, medium and
-  long routes relative to the grid diameter.
-- Difficulty easy / medium / hard: 28,908 / 14,454 / 4,818 (60/30/10), measured as the probability that a
-  random walker reaches the goal within the step budget.
-- Each task has start and goal (cell and metric coordinates), `path_cells` (one shortest path),
-  `geodesic_m`, `euclidean_m` and labels. Grids are in `navigation_tasks/grids/<map_id>.npz`
-  (0 = free, 1 = blocked) with a JSON metric frame.
-- No split is assigned. If you split it, group by `source_scene_id`.
-- Robot counts are not equal (Clearpath Husky 10,003 tasks; Jetbot and TurtleBot 4 482 each), because only
-  large robots fit the largest scenes within the 15 x 15 cell limit.
-
-See `navigation_tasks/README.md` for loading with navsim and full label definitions.
-
-## Verification
-
-- Text tasks: 198,000 routes checked for validity and exact optimality; 0 invalid routes, 0 duplicate tasks;
-  no scene or scenario shared between splits.
-- Balanced tasks: every path checked for free cells, adjacent moves, BFS-optimal length and metric
-  coordinates; no repeated ordered start/goal pair in a grid. 33 oracle episodes across all 11 robots
-  reached their goals with zero collisions in the navsim grid environment.
-- Checksums: `metadata/checksums.json` and `navigation_tasks/manifest.json` (`files`).
-
-## Limitations
-
-- Synthetic scenes; no physics simulation, sensor simulation or real-robot validation of the routes.
-- Robot sensor and speed values are source specifications, not simulated readings.
-- Many short tasks: difficulty and length labels are relative to their group, not a universal difficulty.
-- The 3D scenes (USD) and their meshes are not included.
-
-## Hướng dẫn nhanh (tiếng Việt)
-
-Bộ dữ liệu điều hướng trên lưới cho mô hình ngôn ngữ. Cột `text` mô tả bằng tiếng Việt hệ toạ độ, luật di
-chuyển, robot, bản đồ và nhiệm vụ. Dùng `text` (hoặc `sections_json`) làm đầu vào. `ground_truth_json`,
-`shortest_length_path` và `shortest_path_length_m` là đáp án để chấm điểm, không đưa vào mô hình. Xem
-`examples/ordered_goals_5_goals.txt` để thấy một nhiệm vụ năm goal theo thứ tự.
+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, as declared for this repository.
+MIT.