| """Write expert episodes as a LeRobot v3.0 dataset. |
| |
| Per frame: the three policy cameras with the red source square and blue |
| destination square drawn on, joint state and next joint targets in LeRobot's |
| SO-101 units (arm joints in degrees as with use_degrees=True, gripper 0-100), |
| and the fixed instruction. Contact hulls (geom group 3) are hidden in every image. |
| """ |
| from __future__ import annotations |
|
|
| import json |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| from camera_effects import WebcamLook |
| from episode import FEATURE_NAMES, EpisodeRunner, Highlighter, Task |
|
|
|
|
| def features(cfg: dict) -> dict: |
| ds = cfg["dataset"] |
| shape = (ds["image_height"], ds["image_width"], 3) |
| out = {f"observation.images.{c}": {"dtype": "video", "shape": shape, "names": ["height", "width", "channels"]} |
| for c in ds["cameras"]} |
| out["observation.state"] = {"dtype": "float32", "shape": (6,), "names": FEATURE_NAMES} |
| out["action"] = {"dtype": "float32", "shape": (6,), "names": FEATURE_NAMES} |
| return out |
|
|
|
|
| def video_settings(cfg: dict) -> tuple[int, str]: |
| """(crf, pix_fmt) the dataset videos are encoded with; LeRobot's defaults unless set.""" |
| ds = cfg["dataset"] |
| return int(ds.get("video_crf", 30)), ds.get("video_pix_fmt", "yuv420p") |
|
|
|
|
| def use_video_settings(cfg: dict): |
| """LeRobot 0.4.4 always encodes episodes at its defaults (CRF 30, 4:2:0), which wash |
| out the small red and blue squares. Its episode encoder calls encode_video_frames |
| through the lerobot_dataset module, so rebinding that name sets the quality.""" |
| import functools |
|
|
| import lerobot.datasets.lerobot_dataset as lds |
| from lerobot.datasets.video_utils import encode_video_frames |
|
|
| crf, pix_fmt = video_settings(cfg) |
| lds.encode_video_frames = functools.partial(encode_video_frames, crf=crf, pix_fmt=pix_fmt) |
|
|
|
|
| def create_dataset(cfg: dict, repo_id: str, root: Path): |
| from lerobot.datasets.lerobot_dataset import LeRobotDataset |
|
|
| use_video_settings(cfg) |
| ds = cfg["dataset"] |
| return LeRobotDataset.create(repo_id=repo_id, fps=ds["fps"], features=features(cfg), root=root, |
| robot_type="so101_follower", use_videos=True, vcodec=ds["vcodec"], |
| image_writer_threads=4) |
|
|
|
|
| class Recorder: |
| """Feeds frames to a LeRobotDataset (or keeps them in memory with dataset=None).""" |
|
|
| def __init__(self, cfg: dict, dataset=None): |
| self.cfg = cfg |
| self.dataset = dataset |
| self.cameras = cfg["dataset"]["cameras"] |
| self.instruction = cfg["dataset"]["instruction"] |
| self.frames = [] |
|
|
| def begin(self, runner: EpisodeRunner, task: Task, rng): |
| self.highlight = Highlighter(runner, task, rng) |
| self.looks = {c: WebcamLook.sample(rng, self.cfg) for c in self.cameras} |
| runner.episode_info["webcam"] = {c: look.describe() for c, look in self.looks.items()} |
| self.rng = rng |
| self.frames = [] |
|
|
| def observe(self, runner: EpisodeRunner, name: str): |
| """What camera `name` delivers: the render, through the webcam, with the squares.""" |
| return self.highlight.apply(runner, name, self.looks[name].apply(runner.render(name), self.rng)) |
|
|
| def frame(self, runner: EpisodeRunner, task: Task, action_q6): |
| f = {f"observation.images.{c}": self.observe(runner, c) for c in self.cameras} |
| f["observation.state"] = runner.to_lerobot(runner.d.qpos[runner.qadr]) |
| f["action"] = runner.to_lerobot(action_q6) |
| f["task"] = self.instruction |
| if self.dataset is not None: |
| self.dataset.add_frame(f) |
| else: |
| self.frames.append(f) |
|
|
| def discard(self): |
| """Drop a buffered episode, including the temporary frames of video features.""" |
| if self.dataset is None: |
| self.frames = [] |
| return |
| ds = self.dataset |
| if ds.image_writer is not None: |
| ds._wait_image_writer() |
| idx = ds.episode_buffer["episode_index"] |
| for key in ds.meta.camera_keys: |
| d = ds._get_image_file_dir(idx, key) |
| if d.is_dir(): |
| for p in d.iterdir(): |
| p.unlink() |
| d.rmdir() |
| ds.clear_episode_buffer(delete_images=False) |
|
|
|
|
| def append_jsonl(path: Path, record: dict): |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("a") as f: |
| f.write(json.dumps(record, default=lambda o: o.tolist() if isinstance(o, np.ndarray) else str(o)) + "\n") |
|
|
