Add files using upload-large-folder tool

code/reveal_vla_bimanual/eval/run_rlbench_knn_eval.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, Subset
+
+from eval.run_rlbench_rollout_eval import (
+    BimanualEndEffectorPoseViaIK,
+    _episode_language_goal,
+    _load_compatible_state_dict,
+    _policy_config_from_checkpoint,
+    _reset_task_with_retries,
+    _step_bimanual_chunk,
+    _trainer_config_from_checkpoint,
+)
+from rlbench.action_modes.action_mode import BimanualMoveArmThenGripper
+from rlbench.action_modes.arm_action_modes import BimanualEndEffectorPoseViaPlanning
+from rlbench.action_modes.gripper_action_modes import BimanualDiscrete
+from rlbench.environment import Environment
+from sim_rlbench.camera_spec import default_three_camera_spec
+from sim_rlbench.dataset import RLBenchOfflineChunkDataset, bimanual_proprio_from_obs, stack_live_rgb_obs
+from sim_rlbench.obs_config import build_obs_config
+from sim_rlbench.task_resolver import resolve_task_class
+from train.trainer import build_policy
+
+
+def _make_bank_loader(dataset: RLBenchOfflineChunkDataset, bank_stride: int, batch_size: int, num_workers: int) -> DataLoader:
+    indices = list(range(0, len(dataset), max(1, bank_stride)))
+    subset = Subset(dataset, indices)
+    return DataLoader(
+        subset,
+        batch_size=batch_size,
+        shuffle=False,
+        num_workers=num_workers,
+        pin_memory=torch.cuda.is_available(),
+    )
+
+
+def _encode_bank(
+    model: torch.nn.Module,
+    dataset: RLBenchOfflineChunkDataset,
+    device: torch.device,
+    batch_size: int,
+    bank_stride: int,
+    num_workers: int,
+) -> dict[str, torch.Tensor]:
+    loader = _make_bank_loader(dataset, bank_stride=bank_stride, batch_size=batch_size, num_workers=num_workers)
+    feature_chunks: list[torch.Tensor] = []
+    action_chunks: list[torch.Tensor] = []
+    step_chunks: list[torch.Tensor] = []
+    with torch.no_grad():
+        for batch in loader:
+            images = batch["images"].to(device)
+            proprio = batch["proprio"].to(device)
+            texts = list(batch["texts"])
+            scene_tokens = model.encode_scene(images, proprio, texts=texts)
+            pooled = F.normalize(scene_tokens.mean(dim=1), dim=-1)
+            feature_chunks.append(pooled.cpu())
+            action_chunks.append(batch["action_chunk"][:, 0].cpu())
+            step_chunks.append(batch["step_index"].cpu())
+    return {
+        "features": torch.cat(feature_chunks, dim=0),
+        "actions": torch.cat(action_chunks, dim=0),
+        "steps": torch.cat(step_chunks, dim=0),
+    }
+
+
+def _choose_action(
+    bank: dict[str, torch.Tensor],
+    query_feature: torch.Tensor,
+    timestep: int,
+    top_k: int,
+    time_window: int,
+) -> np.ndarray:
+    features = bank["features"]
+    actions = bank["actions"]
+    steps = bank["steps"]
+    if time_window >= 0:
+        mask = (steps - int(timestep)).abs() <= int(time_window)
+        if mask.any():
+            features = features[mask]
+            actions = actions[mask]
+    similarities = torch.matmul(features, query_feature.cpu())
+    k = min(int(top_k), similarities.numel())
+    top_values, top_indices = torch.topk(similarities, k=k, largest=True)
+    top_actions = actions[top_indices]
+    weights = torch.softmax(top_values.float(), dim=0).unsqueeze(-1)
+    return torch.sum(top_actions.float() * weights, dim=0).numpy().astype(np.float32)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--checkpoint", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--task", required=True)
+    parser.add_argument("--train-episodes", nargs="+", type=int, required=True)
+    parser.add_argument("--episodes-per-task", type=int, default=1)
+    parser.add_argument("--episode-length", type=int, default=180)
+    parser.add_argument("--resolution", type=int, default=224)
+    parser.add_argument("--device", default="cuda")
+    parser.add_argument("--arm-mode", choices=("planning", "ik"), default="ik")
+    parser.add_argument("--delta-scale", type=float, default=1.0)
+    parser.add_argument("--bank-batch-size", type=int, default=32)
+    parser.add_argument("--bank-stride", type=int, default=4)
+    parser.add_argument("--bank-num-workers", type=int, default=4)
+    parser.add_argument("--top-k", type=int, default=5)
+    parser.add_argument("--time-window", type=int, default=8)
+    parser.add_argument("--reset-retries", type=int, default=20)
+    parser.add_argument("--headless", action="store_true", default=True)
+    args = parser.parse_args()
+
+    checkpoint = torch.load(Path(args.checkpoint), map_location="cpu", weights_only=False)
+    policy_config = _policy_config_from_checkpoint(checkpoint)
+    trainer_config = _trainer_config_from_checkpoint(checkpoint)
+    device = torch.device("cuda" if torch.cuda.is_available() and args.device == "cuda" else "cpu")
+    model = build_policy(policy_config, trainer_config).to(device)
+    incompatible, skipped_shape_mismatches = _load_compatible_state_dict(model, checkpoint["state_dict"])
+    if incompatible.unexpected_keys or incompatible.missing_keys:
+        raise RuntimeError(
+            f"Checkpoint incompatibility for kNN eval. Missing={list(incompatible.missing_keys)} unexpected={list(incompatible.unexpected_keys)}"
+        )
+    if skipped_shape_mismatches:
+        raise RuntimeError(f"kNN eval does not support shape-mismatch loads: {skipped_shape_mismatches}")
+    model.eval()
+
+    bank_dataset = RLBenchOfflineChunkDataset(
+        dataset_root="/workspace/data/rlbench2",
+        tasks=[args.task],
+        episode_indices=args.train_episodes,
+        resolution=args.resolution,
+        chunk_size=policy_config.decoder.chunk_size,
+        proprio_dim=policy_config.fusion.proprio_dim,
+        history_steps=policy_config.memory.history_steps,
+    )
+    bank = _encode_bank(
+        model=model,
+        dataset=bank_dataset,
+        device=device,
+        batch_size=args.bank_batch_size,
+        bank_stride=args.bank_stride,
+        num_workers=args.bank_num_workers,
+    )
+
+    camera_spec = default_three_camera_spec(args.resolution)
+    task_class = resolve_task_class(args.task)
+    obs_config = build_obs_config(list(camera_spec.upstream_cameras), args.resolution)
+    if args.arm_mode == "ik":
+        arm_action_mode: Any = BimanualEndEffectorPoseViaIK(absolute_mode=True, frame="world", collision_checking=False)
+    else:
+        arm_action_mode = BimanualEndEffectorPoseViaPlanning(absolute_mode=True, frame="world", collision_checking=False)
+    action_mode = BimanualMoveArmThenGripper(arm_action_mode, BimanualDiscrete())
+    env = Environment(
+        action_mode=action_mode,
+        obs_config=obs_config,
+        headless=args.headless,
+        robot_setup="dual_panda",
+    )
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    results: dict[str, Any] = {
+        "checkpoint": str(Path(args.checkpoint).resolve()),
+        "task": args.task,
+        "train_episodes": list(args.train_episodes),
+        "episodes_per_task": args.episodes_per_task,
+        "episode_length": args.episode_length,
+        "resolution": args.resolution,
+        "arm_mode": args.arm_mode,
+        "delta_scale": args.delta_scale,
+        "bank_stride": args.bank_stride,
+        "top_k": args.top_k,
+        "time_window": args.time_window,
+        "bank_size": int(bank["features"].shape[0]),
+    }
+    env.launch()
+    try:
+        task = env.get_task(task_class)
+        successes: list[float] = []
+        returns: list[float] = []
+        path_recoveries: list[int] = []
+        noop_fallbacks: list[int] = []
+        episode_errors: list[str | None] = []
+        for _ in range(args.episodes_per_task):
+            total_reward = 0.0
+            success = 0.0
+            episode_recoveries = 0
+            episode_noops = 0
+            episode_error: str | None = None
+            try:
+                descriptions, obs, _reset_count = _reset_task_with_retries(task, max_attempts=max(1, args.reset_retries))
+                language_goal = _episode_language_goal(descriptions)
+                for timestep in range(args.episode_length):
+                    images = stack_live_rgb_obs(obs, resolution=args.resolution).unsqueeze(0).to(device)
+                    proprio = torch.from_numpy(
+                        bimanual_proprio_from_obs(
+                            obs,
+                            timestep=timestep,
+                            episode_length=args.episode_length,
+                            target_dim=policy_config.fusion.proprio_dim,
+                        )
+                    ).unsqueeze(0).to(device)
+                    with torch.no_grad():
+                        scene_tokens = model.encode_scene(images, proprio, texts=[language_goal])
+                        query_feature = F.normalize(scene_tokens.mean(dim=1), dim=-1)[0]
+                    step_action = _choose_action(
+                        bank=bank,
+                        query_feature=query_feature,
+                        timestep=timestep,
+                        top_k=args.top_k,
+                        time_window=args.time_window,
+                    )
+                    obs, reward, done, recovered_steps, noop_count = _step_bimanual_chunk(
+                        task,
+                        obs,
+                        step_action,
+                        delta_scale=args.delta_scale,
+                    )
+                    episode_recoveries += int(recovered_steps)
+                    episode_noops += int(noop_count)
+                    total_reward += float(reward)
+                    if reward >= 1.0:
+                        success = 1.0
+                    if done or success >= 1.0:
+                        break
+            except Exception as exc:  # pragma: no cover - live RLBench failure path
+                episode_error = str(exc)
+            successes.append(success)
+            returns.append(total_reward)
+            path_recoveries.append(episode_recoveries)
+            noop_fallbacks.append(episode_noops)
+            episode_errors.append(episode_error)
+        results["successes"] = successes
+        results["returns"] = returns
+        results["path_recoveries"] = path_recoveries
+        results["noop_fallbacks"] = noop_fallbacks
+        results["episode_errors"] = episode_errors
+        results["mean_success"] = float(np.mean(successes)) if successes else 0.0
+        results["mean_return"] = float(np.mean(returns)) if returns else 0.0
+    finally:
+        env.shutdown()
+
+    (output_dir / "rollout_eval.json").write_text(json.dumps(results, indent=2), encoding="utf-8")
+    print(json.dumps(results, indent=2))
+
+
+if __name__ == "__main__":
+    main()

code/reveal_vla_bimanual/eval/run_rlbench_rollout_eval.py

@@ -8,7 +8,14 @@ from typing import Any, Sequence
 import numpy as np
 import torch
 from rlbench.action_modes.action_mode import BimanualMoveArmThenGripper
-from rlbench.action_modes.arm_action_modes import BimanualEndEffectorPoseViaPlanning
+from rlbench.action_modes.arm_action_modes import (
+    BimanualEndEffectorPoseViaPlanning,
+    EndEffectorPoseViaIK,
+    IKError,
+    InvalidActionError,
+    assert_action_shape,
+    assert_unit_quaternion,
+)
 from rlbench.action_modes.gripper_action_modes import BimanualDiscrete
 from rlbench.environment import Environment
 
@@ -31,6 +38,51 @@ from sim_rlbench.task_resolver import resolve_task_class
 from train.trainer import TrainerConfig, build_policy, planner_enabled, policy_supports_planning
 
 
+class BimanualEndEffectorPoseViaIK(EndEffectorPoseViaIK):
+    def action(self, scene: Any, action: np.ndarray, ignore_collisions: Sequence[bool] | None = None) -> None:
+        assert_action_shape(action, (14,))
+        right_action = action[:7]
+        left_action = action[7:]
+        assert_unit_quaternion(right_action[3:])
+        assert_unit_quaternion(left_action[3:])
+
+        target_positions: list[np.ndarray] = []
+        for arm_action, arm in ((right_action, scene.robot.right_arm), (left_action, scene.robot.left_arm)):
+            try:
+                joint_positions = arm.solve_ik_via_jacobian(
+                    arm_action[:3],
+                    quaternion=arm_action[3:],
+                    relative_to=None,
+                )
+                target_positions.append(np.asarray(joint_positions, dtype=np.float32))
+                arm.set_joint_target_positions(joint_positions)
+            except IKError as exc:
+                raise InvalidActionError(
+                    "Could not perform bimanual IK via Jacobian; target pose is likely too far from the current pose."
+                ) from exc
+
+        done = False
+        prev_right = None
+        prev_left = None
+        while not done:
+            scene.step()
+            cur_right = np.asarray(scene.robot.right_arm.get_joint_positions(), dtype=np.float32)
+            cur_left = np.asarray(scene.robot.left_arm.get_joint_positions(), dtype=np.float32)
+            reached = np.allclose(cur_right, target_positions[0], atol=0.01) and np.allclose(cur_left, target_positions[1], atol=0.01)
+            not_moving = False
+            if prev_right is not None and prev_left is not None:
+                not_moving = np.allclose(cur_right, prev_right, atol=0.001) and np.allclose(cur_left, prev_left, atol=0.001)
+            prev_right = cur_right
+            prev_left = cur_left
+            done = reached or not_moving
+
+    def action_shape(self, scene: Any) -> tuple[int]:
+        return (14,)
+
+    def unimanual_action_shape(self, scene: Any) -> tuple[int]:
+        return (7,)
+
+
 def _policy_config_from_checkpoint(checkpoint: dict[str, Any]) -> PolicyConfig:
     cfg = checkpoint["policy_config"]
     return PolicyConfig(
@@ -48,6 +100,26 @@ def _trainer_config_from_checkpoint(checkpoint: dict[str, Any]) -> TrainerConfig
     return TrainerConfig(**checkpoint["trainer_config"])
 
 
+def _load_compatible_state_dict(
+    model: torch.nn.Module,
+    checkpoint_state: dict[str, Any],
+) -> tuple[Any, list[str]]:
+    model_state = model.state_dict()
+    compatible_state: dict[str, Any] = {}
+    skipped_shape_mismatches: list[str] = []
+    for key, value in checkpoint_state.items():
+        target = model_state.get(key)
+        if target is None:
+            compatible_state[key] = value
+            continue
+        if hasattr(value, "shape") and tuple(value.shape) != tuple(target.shape):
+            skipped_shape_mismatches.append(key)
+            continue
+        compatible_state[key] = value
+    incompatible = model.load_state_dict(compatible_state, strict=False)
+    return incompatible, skipped_shape_mismatches
+
+
 def _episode_language_goal(descriptions: Sequence[str]) -> str:
     return str(descriptions[0]) if descriptions else ""
 
@@ -92,13 +164,23 @@ def _scaled_bimanual_delta(delta_action: np.ndarray, scale: float) -> np.ndarray
     return scaled
 
 
-def _step_bimanual_chunk(task: Any, obs: Any, delta_action: np.ndarray) -> tuple[Any, float, bool, int, int]:
+def _step_bimanual_chunk(
+    task: Any,
+    obs: Any,
+    delta_action: np.ndarray,
+    delta_scale: float = 1.0,
+) -> tuple[Any, float, bool, int, int]:
     last_error: Exception | None = None
-    for scale in (1.0, 0.5, 0.25, 0.1):
+    for scale in (1.0, 0.5, 0.25, 0.1, 0.05, 0.02, 0.01):
         try:
-            env_action = absolute_action_from_delta(obs, _scaled_bimanual_delta(delta_action, scale), ignore_collisions=True)
+            effective_scale = float(delta_scale) * float(scale)
+            env_action = absolute_action_from_delta(
+                obs,
+                _scaled_bimanual_delta(delta_action, effective_scale),
+                ignore_collisions=True,
+            )
             next_obs, reward, done = task.step(env_action)
-            recovered_steps = 1 if scale < 1.0 else 0
+            recovered_steps = 1 if effective_scale < 1.0 else 0
             return next_obs, float(reward), bool(done), recovered_steps, 0
         except Exception as exc:  # pragma: no cover - live RLBench failure path
             last_error = exc
@@ -131,6 +213,8 @@ def main() -> None:
     parser.add_argument("--reset-retries", type=int, default=20)
     parser.add_argument("--no-geometry", action="store_true")
     parser.add_argument("--compact-world-model", action="store_true")
+    parser.add_argument("--arm-mode", choices=("planning", "ik"), default="planning")
+    parser.add_argument("--delta-scale", type=float, default=1.0)
     args = parser.parse_args()
 
     checkpoint = torch.load(Path(args.checkpoint), map_location="cpu", weights_only=False)
@@ -138,7 +222,7 @@ def main() -> None:
     trainer_config = _trainer_config_from_checkpoint(checkpoint)
     device = torch.device("cuda" if torch.cuda.is_available() and args.device == "cuda" else "cpu")
     model = build_policy(policy_config, trainer_config).to(device)
-    incompatible = model.load_state_dict(checkpoint["state_dict"], strict=False)
+    incompatible, skipped_shape_mismatches = _load_compatible_state_dict(model, checkpoint["state_dict"])
     allowed_missing = {
         key
         for key in incompatible.missing_keys
@@ -148,6 +232,8 @@ def main() -> None:
         or key.startswith("elastic_state_head.decoder.task_")
         or key.startswith("world_model.task_")
         or key.startswith("world_model.spatial_")
+        or key.startswith("decoder.proposal_score.")
+        or key.startswith("world_model.initial.")
     }
     missing_other = sorted(set(incompatible.missing_keys) - allowed_missing)
     if missing_other or incompatible.unexpected_keys:
@@ -182,12 +268,24 @@ def main() -> None:
         "episode_length": args.episode_length,
         "resolution": args.resolution,
         "reset_retries": args.reset_retries,
+        "arm_mode": args.arm_mode,
+        "delta_scale": args.delta_scale,
         "cameras": list(camera_spec.cameras),
         "tasks": {},
     }
+    if skipped_shape_mismatches:
+        results["skipped_shape_mismatches"] = skipped_shape_mismatches
     if planning_note is not None:
         results["planning_note"] = planning_note
 
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    def write_results(filename: str = "rollout_eval.partial.json") -> None:
+        task_scores = [task_data["mean_success"] for task_data in results["tasks"].values()]
+        results["mean_success"] = float(np.mean(task_scores)) if task_scores else 0.0
+        (output_dir / filename).write_text(json.dumps(results, indent=2), encoding="utf-8")
+
     for task_name in args.tasks:
         task_successes: list[float] = []
         task_returns: list[float] = []
@@ -195,8 +293,13 @@ def main() -> None:
         try:
             task_class = resolve_task_class(task_name)
             obs_config = build_obs_config(list(camera_spec.upstream_cameras), args.resolution)
+            arm_action_mode: Any
+            if args.arm_mode == "ik":
+                arm_action_mode = BimanualEndEffectorPoseViaIK(absolute_mode=True, frame="world", collision_checking=False)
+            else:
+                arm_action_mode = BimanualEndEffectorPoseViaPlanning(absolute_mode=True, frame="world", collision_checking=False)
             action_mode = BimanualMoveArmThenGripper(
-                BimanualEndEffectorPoseViaPlanning(absolute_mode=True, frame="world", collision_checking=False),
+                arm_action_mode,
                 BimanualDiscrete(),
             )
             env = Environment(
@@ -323,7 +426,12 @@ def main() -> None:
                             history_images.append(live_images)
                             history_proprio.append(live_proprio)
                             history_actions.append(step_action.astype(np.float32))
-                        obs, reward, done, recovered_steps, noop_fallbacks = _step_bimanual_chunk(task, obs, step_action)
+                        obs, reward, done, recovered_steps, noop_fallbacks = _step_bimanual_chunk(
+                            task,
+                            obs,
+                            step_action,
+                            delta_scale=args.delta_scale,
+                        )
                         episode_recoveries += recovered_steps
                         episode_noop_fallbacks += noop_fallbacks
                         episode_trace["steps"].append(
@@ -368,14 +476,21 @@ def main() -> None:
         except Exception as exc:
             results["tasks"][task_name] = {"error": str(exc), "mean_success": 0.0, "mean_return": 0.0}
         finally:
+            write_results()
+            task_result = results["tasks"][task_name]
+            if "error" in task_result:
+                print(f"[task] {task_name}: error={task_result['error']}", flush=True)
+            else:
+                print(
+                    f"[task] {task_name}: mean_success={task_result['mean_success']:.3f} "
+                    f"mean_return={task_result['mean_return']:.3f}",
+                    flush=True,
+                )
             if env is not None:
                 env.shutdown()
 
     task_scores = [task_data["mean_success"] for task_data in results["tasks"].values()]
     results["mean_success"] = float(np.mean(task_scores)) if task_scores else 0.0
-
-    output_dir = Path(args.output_dir)
-    output_dir.mkdir(parents=True, exist_ok=True)
     (output_dir / "rollout_eval.json").write_text(json.dumps(results, indent=2), encoding="utf-8")
     lines = [
         "# RLBench Rollout Eval",

code/reveal_vla_bimanual/sim_rlbench/dataset.py

@@ -287,6 +287,7 @@ class RLBenchOfflineChunkDataset(Dataset[dict[str, Any]]):
         proprio_dim: int = 32,
         cameras: Sequence[str] = THREE_CAMERAS,
         history_steps: int = 2,
+        supervise_action_steps: int | None = None,
         max_samples: int | None = None,
     ) -> None:
         self.dataset_root = Path(dataset_root)
@@ -297,6 +298,9 @@ class RLBenchOfflineChunkDataset(Dataset[dict[str, Any]]):
         self.proprio_dim = int(proprio_dim)
         self.cameras = tuple(cameras)
         self.history_steps = int(history_steps)
+        self.supervise_action_steps = (
+            None if supervise_action_steps is None else max(1, min(int(supervise_action_steps), self.chunk_size))
+        )
         self._episodes: dict[str, EpisodeRecord] = {}
         self._samples: list[SampleRecord] = []
 
@@ -362,6 +366,13 @@ class RLBenchOfflineChunkDataset(Dataset[dict[str, Any]]):
             actions.append(action)
         return torch.from_numpy(np.stack(actions, axis=0))
 
+    def _action_mask(self) -> torch.Tensor:
+        mask = torch.ones((self.chunk_size,), dtype=torch.float32)
+        if self.supervise_action_steps is None:
+            return mask
+        mask[self.supervise_action_steps :] = 0.0
+        return mask
+
     def _history_rgb_stack(self, episode_dir: Path, step_index: int) -> torch.Tensor:
         if self.history_steps <= 0:
             return torch.zeros((0, len(self.cameras), 3, self.resolution, self.resolution), dtype=torch.float32)
@@ -423,6 +434,7 @@ class RLBenchOfflineChunkDataset(Dataset[dict[str, Any]]):
             ),
             "texts": episode.language_goal,
             "action_chunk": self._action_chunk(observations, sample.step_index),
+            "action_mask": self._action_mask(),
             "task": sample.task,
             "episode_index": sample.episode_index,
             "step_index": sample.step_index,
@@ -439,4 +451,5 @@ class RLBenchOfflineChunkDataset(Dataset[dict[str, Any]]):
             "chunk_size": self.chunk_size,
             "proprio_dim": self.proprio_dim,
             "history_steps": self.history_steps,
+            "supervise_action_steps": self.supervise_action_steps,
         }

code/reveal_vla_bimanual/sim_rlbench/dataset_download.py

@@ -85,12 +85,14 @@ def main() -> None:
         archive_path = archive_root / filename
         expected_sha = checksums[filename]
         url = f"{base_url}/{filename}"
+        task_name = filename.split(".", 1)[0]
+        task_extract_root = extract_root / task_name
 
         print(f"[plan] {filename}", flush=True)
         print(f"       url={url}", flush=True)
         print(f"       archive={archive_path}", flush=True)
         if args.extract:
-            print(f"       extract_root={extract_root}", flush=True)
+            print(f"       extract_root={task_extract_root}", flush=True)
 
         if args.dry_run:
             continue
@@ -112,8 +114,9 @@ def main() -> None:
             print(f"[done] downloaded {filename}", flush=True)
 
         if args.extract:
+            task_extract_root.mkdir(parents=True, exist_ok=True)
             subprocess.run(
-                ["unsquashfs", "-f", "-d", str(extract_root), str(archive_path)],
+                ["unsquashfs", "-f", "-q", "-no-progress", "-d", str(task_extract_root), str(archive_path)],
                 check=True,
             )
             print(f"[done] extracted {filename}", flush=True)