Add insert_tube weighted policy retrain setup 20260729

experiments/h100/real150_insert_tube_weighted_policy_20260729/README.md

@@ -0,0 +1,20 @@
+# real150_insert_tube_weighted_policy_20260729
+
+Insert-tube focused ViTacDreamer+ACT policy retraining setup.
+
+Changes:
+- adds optional weighted gripper action loss (`gripper_loss_weight`, dim=7 when state_dim=8)
+- adds optional late/chunk action weighting (`late_action_loss_weight`, `late_action_loss_start_ratio`)
+- saves intermediate policy checkpoints when `save_step_ckpts: true`
+
+Configs:
+- 8 variants: kl={2.5,5,7.5,10}, lr={2e-5,3e-5,5e-5}, steps={8000,12000,16000} around the selected insert_tube grid.
+- All use history_len=5, sample_stride=5, state_dim=8, gripper_loss_weight=8, late_action_loss_weight=3, late start ratio=0.65.
+
+Original H100 local dependency paths before cleanup:
+- code root: /dev/shm/muse/src/ViTacDreamer_policy
+- ACT data: /dev/shm/muse/src/ViTacDreamer_policy/UniVTAC/policy/ACT/data/sim-insert_tube
+- real raw data: /dev/shm/muse/data/real_data_encoder_muse150_20260723/insert_tube
+- encoder: /dev/shm/muse/checkpoints/real_insert_tube_wipe_board_150_h32_20260725/stage2_prior512_hlen5_depthdelta_120train30val_b192_from_stage1_prior512_hlen5_120train30val_b192/stage2_v2_encoder_only.pth
+
+Note: The H100 run was intentionally stopped after only a few minutes; no usable new policy checkpoint is included here.

experiments/h100/real150_insert_tube_weighted_policy_20260729/code/act_policy.py

@@ -0,0 +1,339 @@
+import torch.nn as nn
+import os
+import torch
+import numpy as np
+import pickle
+from torch.nn import functional as F
+from pathlib import Path
+import sys
+
+sys.path.append(str(Path(__file__).resolve().parents[3]))
+from vitacdreamer.policy_wrapper import ViTacDreamerFeatureExtractor
+
+try:
+    from detr.main import (
+        build_ACT_model_and_optimizer,
+        build_CNNMLP_model_and_optimizer,
+    )
+except:
+    from .detr.main import (
+        build_ACT_model_and_optimizer,
+        build_CNNMLP_model_and_optimizer,
+    )
+import IPython
+
+e = IPython.embed
+
+
+class ACTPolicy(nn.Module):
+
+    def __init__(self, args_override, RoboTwin_Config=None):
+        super().__init__()
+        model, optimizer = build_ACT_model_and_optimizer(args_override, RoboTwin_Config)
+        self.model = model  # CVAE decoder
+        self.optimizer = optimizer
+        self.kl_weight = args_override["kl_weight"]
+        self.gripper_loss_weight = float(args_override.get("gripper_loss_weight", 1.0))
+        self.late_action_loss_weight = float(args_override.get("late_action_loss_weight", 1.0))
+        self.late_action_loss_start_ratio = float(args_override.get("late_action_loss_start_ratio", 1.0))
+        self.use_vitacdreamer_feature = args_override.get("use_vitacdreamer_feature", False)
+        self.use_cached_vitacdreamer_feature = bool(args_override.get("vitacdreamer_feature_cache_dir"))
+        self.finetune_vitacdreamer_encoder = bool(args_override.get("finetune_vitacdreamer_encoder", False))
+        self.feature_extractor = None
+        if self.finetune_vitacdreamer_encoder and self.use_cached_vitacdreamer_feature:
+            raise ValueError(
+                "finetune_vitacdreamer_encoder=True requires online ViTacDreamer inputs; "
+                "remove vitacdreamer_feature_cache_dir so encoder remains in the computation graph."
+            )
+        if self.use_vitacdreamer_feature and not self.use_cached_vitacdreamer_feature:
+            self.feature_extractor = ViTacDreamerFeatureExtractor(
+                checkpoint_path=args_override["vitacdreamer_checkpoint"],
+                freeze_encoder=not self.finetune_vitacdreamer_encoder,
+                device=args_override.get("device", "cuda:0")
+            )
+            if self.finetune_vitacdreamer_encoder:
+                encoder_lr = args_override.get("vitacdreamer_encoder_lr", args_override.get("lr", 1e-5))
+                encoder_params = [
+                    param for param in self.feature_extractor.parameters()
+                    if param.requires_grad
+                ]
+                if encoder_params:
+                    self.optimizer.add_param_group({"params": encoder_params, "lr": encoder_lr})
+        print(f"KL Weight {self.kl_weight}")
+
+    def forward(self, qpos, cam_image, tac_image, actions=None, is_pad=None, vitac_inputs=None, vitac_feature=None):
+        env_state = None
+        if self.use_vitacdreamer_feature:
+            if vitac_feature is None:
+                if vitac_inputs is None:
+                    raise ValueError("vitac_inputs or vitac_feature are required when use_vitacdreamer_feature=True")
+                if self.feature_extractor is None:
+                    raise ValueError(
+                        "Cached ViTacDreamer training expects vitac_feature tensors from the dataset. "
+                        "Check vitacdreamer_feature_cache_dir and cached feature files."
+                    )
+                vitac_feature = self.feature_extractor.extract_features_from_history(
+                    current_tactile=vitac_inputs["current_tactile"],
+                    visual_history=vitac_inputs["visual_history"],
+                    tactile_history=vitac_inputs["tactile_history"],
+                    action_history=vitac_inputs["action_history"],
+                    task_id=vitac_inputs.get("task_id"),
+                )
+        if actions is not None:  # training time
+            actions = actions[:, :self.model.num_queries]
+            is_pad = is_pad[:, :self.model.num_queries]
+
+            a_hat, is_pad_hat, (mu, logvar) = self.model(
+                qpos, cam_image, tac_image, env_state, actions, is_pad, vitac_feature=vitac_feature
+            )
+            total_kld, dim_wise_kld, mean_kld = kl_divergence(mu, logvar)
+            loss_dict = dict()
+            all_l1 = F.l1_loss(actions, a_hat, reduction="none")
+            valid = (~is_pad).unsqueeze(-1).to(dtype=all_l1.dtype)
+            weights = torch.ones_like(all_l1)
+            if self.gripper_loss_weight != 1.0 and all_l1.shape[-1] >= 8:
+                weights[..., 7] = self.gripper_loss_weight
+            if self.late_action_loss_weight != 1.0 and self.late_action_loss_start_ratio < 1.0:
+                t0 = int(round(all_l1.shape[1] * self.late_action_loss_start_ratio))
+                t0 = max(0, min(t0, all_l1.shape[1]))
+                weights[:, t0:, :] *= self.late_action_loss_weight
+            weighted_l1 = all_l1 * weights * valid
+            denom = (weights * valid).sum().clamp_min(1.0)
+            l1 = weighted_l1.sum() / denom
+            unweighted_l1 = (all_l1 * valid).sum() / valid.expand_as(all_l1).sum().clamp_min(1.0)
+            if all_l1.shape[-1] >= 8:
+                gripper_l1 = (all_l1[..., 7:8] * valid).sum() / valid.sum().clamp_min(1.0)
+                arm_valid = valid.expand(-1, -1, min(7, all_l1.shape[-1]))
+                arm_l1 = (all_l1[..., :7] * arm_valid).sum() / arm_valid.sum().clamp_min(1.0)
+            else:
+                gripper_l1 = torch.zeros((), device=all_l1.device, dtype=all_l1.dtype)
+                arm_l1 = unweighted_l1
+            loss_dict["l1"] = l1
+            loss_dict["l1_unweighted"] = unweighted_l1
+            loss_dict["arm_l1"] = arm_l1
+            loss_dict["gripper_l1"] = gripper_l1
+            loss_dict["kl"] = total_kld[0]
+            loss_dict["loss"] = loss_dict["l1"] + loss_dict["kl"] * self.kl_weight
+            return loss_dict
+        else:  # inference time
+            a_hat, _, (_, _) = self.model(
+                qpos, cam_image, tac_image, env_state, vitac_feature=vitac_feature
+            )  # no action, sample from prior
+            return a_hat
+
+    def configure_optimizers(self):
+        return self.optimizer
+
+
+class CNNMLPPolicy(nn.Module):
+
+    def __init__(self, args_override):
+        super().__init__()
+        model, optimizer = build_CNNMLP_model_and_optimizer(args_override)
+        self.model = model  # decoder
+        self.optimizer = optimizer
+
+    def __call__(self, qpos, image, actions=None, is_pad=None):
+        env_state = None  # TODO
+        if actions is not None:  # training time
+            actions = actions[:, 0]
+            a_hat = self.model(qpos, image, env_state, actions)
+            mse = F.mse_loss(actions, a_hat)
+            loss_dict = dict()
+            loss_dict["mse"] = mse
+            loss_dict["loss"] = loss_dict["mse"]
+            return loss_dict
+        else:  # inference time
+            a_hat = self.model(qpos, image, env_state)  # no action, sample from prior
+            return a_hat
+
+    def configure_optimizers(self):
+        return self.optimizer
+
+
+def kl_divergence(mu, logvar):
+    batch_size = mu.size(0)
+    assert batch_size != 0
+    if mu.data.ndimension() == 4:
+        mu = mu.view(mu.size(0), mu.size(1))
+    if logvar.data.ndimension() == 4:
+        logvar = logvar.view(logvar.size(0), logvar.size(1))
+
+    klds = -0.5 * (1 + logvar - mu.pow(2) - logvar.exp())
+    total_kld = klds.sum(1).mean(0, True)
+    dimension_wise_kld = klds.mean(0)
+    mean_kld = klds.mean(1).mean(0, True)
+
+    return total_kld, dimension_wise_kld, mean_kld
+
+
+class ACT:
+
+    def __init__(self, args_override=None, RoboTwin_Config=None):
+        if args_override is None:
+            args_override = {
+                "kl_weight": 0.1,  # Default value, can be overridden
+                "device": "cuda:0",
+            }
+        self.policy = ACTPolicy(args_override, RoboTwin_Config)
+        self.device = torch.device(args_override["device"])
+        self.policy.to(self.device)
+        self.policy.eval()
+
+        # Temporal aggregation settings
+        self.temporal_agg = args_override.get("temporal_agg", False)
+        self.num_queries = args_override["chunk_size"]
+        self.state_dim = args_override.get("state_dim", 14)  # TacArena: read from args
+        self.max_timesteps = 3000  # Large enough for deployment
+        self.camera_names = args_override.get("camera_names", ["cam_high"])  # TacArena: read from args
+        self.tactile_names = args_override.get("tactile_names", ["tac_left", "tac_right"])  # TacArena: read from args
+        self.use_vitacdreamer_feature = args_override.get("use_vitacdreamer_feature", False)
+
+        # Set query frequency based on temporal_agg - matching imitate_episodes.py logic
+        self.query_frequency = self.num_queries
+        if self.temporal_agg:
+            self.query_frequency = 1
+            # Initialize with zeros matching imitate_episodes.py format
+            self.all_time_actions = torch.zeros([
+                self.max_timesteps,
+                self.max_timesteps + self.num_queries,
+                self.state_dim,
+            ]).to(self.device)
+            print(f"Temporal aggregation enabled with {self.num_queries} queries")
+
+        self.t = 0  # Current timestep
+
+        # Load statistics for normalization
+        ckpt_dir = args_override.get("ckpt_dir", "")
+        explicit_stats_path = args_override.get("stats_path")
+        explicit_ckpt_path = args_override.get("policy_checkpoint")
+        if ckpt_dir:
+            # Load dataset stats for normalization
+            stats_path = explicit_stats_path or os.path.join(ckpt_dir, "dataset_stats.pkl")
+            if os.path.exists(stats_path):
+                with open(stats_path, "rb") as f:
+                    self.stats = pickle.load(f)
+                print(f"Loaded normalization stats from {stats_path}")
+            else:
+                print(f"Warning: Could not find stats file at {stats_path}")
+                self.stats = None
+
+            # Load policy weights
+            ckpt_path = explicit_ckpt_path or os.path.join(ckpt_dir, "policy_best.ckpt")
+            if not os.path.exists(ckpt_path):
+                ckpt_path = os.path.join(ckpt_dir, "policy_last.ckpt")
+            print("current pwd:", os.getcwd())
+            if os.path.exists(ckpt_path):
+                checkpoint_state = torch.load(ckpt_path)
+                loading_status = self.policy.load_state_dict(checkpoint_state, strict=False)
+                unexpected = list(loading_status.unexpected_keys)
+                missing = list(loading_status.missing_keys)
+                non_extractor_missing = [
+                    key for key in missing
+                    if not key.startswith("feature_extractor.")
+                ]
+                if unexpected or non_extractor_missing:
+                    raise RuntimeError(
+                        "Unexpected policy checkpoint mismatch. "
+                        f"missing(non-extractor)={non_extractor_missing[:20]}, "
+                        f"unexpected={unexpected[:20]}"
+                    )
+                print(f"Loaded policy weights from {ckpt_path}")
+                if missing and all(key.startswith("feature_extractor.") for key in missing):
+                    print(
+                        "Policy checkpoint was trained with cached ViTacDreamer features; "
+                        "online eval loads feature_extractor weights from vitacdreamer_checkpoint."
+                    )
+                print(f"Loading status: {loading_status}")
+            else:
+                 print(f"Warning: Could not find policy checkpoint at {ckpt_path}")
+        else:
+            self.stats = None
+
+    def pre_process(self, qpos):
+        """Normalize input joint positions"""
+        if self.stats is not None:
+            return (qpos - self.stats["qpos_mean"]) / self.stats["qpos_std"]
+        return qpos
+
+    def post_process(self, action):
+        """Denormalize model outputs"""
+        if self.stats is not None:
+            return action * self.stats["action_std"] + self.stats["action_mean"]
+        return action
+
+    def get_action(self, obs=None):
+        if obs is None:
+            return None
+
+        # Convert observations to tensors and normalize qpos - matching imitate_episodes.py
+        qpos_numpy = np.array(obs["qpos"])
+        qpos_normalized = self.pre_process(qpos_numpy)
+        qpos = torch.from_numpy(qpos_normalized).float().to(self.device).unsqueeze(0)
+
+        # Prepare images following imitate_episodes.py pattern
+        # Stack images from all cameras
+        if len(self.camera_names) > 0:
+            cam_image = []
+            for cam_name in self.camera_names:
+                cam_image.append(obs[cam_name])
+            cam_image = torch.stack(cam_image, dim=0).to(self.device).unsqueeze(0)
+        else:
+            cam_image = torch.tensor([]).to(self.device)
+        
+        if len(self.tactile_names) > 0:
+            tac_image = []
+            for tac_name in self.tactile_names:
+                tac_image.append(obs[tac_name])
+            tac_image = torch.stack(tac_image, dim=0).to(self.device).unsqueeze(0)
+        else:
+            tac_image = torch.tensor([]).to(self.device)
+
+        with torch.no_grad():
+            # Only query the policy at specified intervals - exactly like imitate_episodes.py
+            if self.t % self.query_frequency == 0:
+                vitac_inputs = obs.get("vitac_inputs") if self.use_vitacdreamer_feature else None
+                vitac_feature = obs.get("vitac_feature") if self.use_vitacdreamer_feature else None
+                if vitac_feature is not None:
+                    vitac_feature = vitac_feature.to(self.device).unsqueeze(0)
+                self.all_actions = self.policy(
+                    qpos, cam_image, tac_image, vitac_inputs=vitac_inputs, vitac_feature=vitac_feature
+                )
+
+            if self.temporal_agg:
+                # Match temporal aggregation exactly from imitate_episodes.py
+                self.all_time_actions[[self.t], self.t:self.t + self.num_queries] = (self.all_actions)
+                actions_for_curr_step = self.all_time_actions[:, self.t]
+                actions_populated = torch.all(actions_for_curr_step != 0, axis=1)
+                actions_for_curr_step = actions_for_curr_step[actions_populated]
+
+                # Use same weighting factor as in imitate_episodes.py
+                k = 0.01
+                exp_weights = np.exp(-k * np.arange(len(actions_for_curr_step)))
+                exp_weights = exp_weights / exp_weights.sum()
+                exp_weights = (torch.from_numpy(exp_weights).to(self.device).unsqueeze(dim=1))
+
+                raw_action = (actions_for_curr_step * exp_weights).sum(dim=0, keepdim=True)
+            else:
+                # Direct action selection, same as imitate_episodes.py
+                raw_action = self.all_actions[:, self.t % self.query_frequency]
+
+        # Denormalize action
+        raw_action = raw_action.cpu().numpy()
+        action = self.post_process(raw_action)
+
+        self.t += 1
+        return action
+
+    def reset(self):
+        """Reset temporal aggregation state and timestep counter"""
+        self.t = 0
+        feature_extractor = getattr(self.policy, "feature_extractor", None)
+        if feature_extractor is not None:
+            feature_extractor.reset()
+        if self.temporal_agg:
+            self.all_time_actions = torch.zeros([
+                self.max_timesteps,
+                self.max_timesteps + self.num_queries,
+                self.state_dim,
+            ]).to(self.device)

experiments/h100/real150_insert_tube_weighted_policy_20260729/code/imitate_episodes.py

@@ -0,0 +1,514 @@
+import os
+import torch
+import torch.distributed as dist
+import numpy as np
+import pickle
+import argparse
+import json
+import yaml
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+from copy import deepcopy
+from tqdm import tqdm
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data.distributed import DistributedSampler
+
+from utils import load_data  # data functions
+from utils import compute_dict_mean, set_seed, detach_dict  # helper functions
+from act_policy import ACTPolicy, CNNMLPPolicy
+
+import IPython
+e = IPython.embed
+_METRIC_PROCESS_GROUP = None
+
+
+def is_dist_enabled():
+    return dist.is_available() and dist.is_initialized()
+
+
+def is_main_process():
+    return not is_dist_enabled() or dist.get_rank() == 0
+
+
+def unwrap_model(model):
+    return model.module if isinstance(model, DDP) else model
+
+
+def setup_distributed(args):
+    global _METRIC_PROCESS_GROUP
+    world_size = int(os.environ.get("WORLD_SIZE", "1"))
+    if world_size <= 1:
+        args["distributed"] = False
+        args["rank"] = 0
+        args["local_rank"] = 0
+        return
+
+    args["distributed"] = True
+    args["rank"] = int(os.environ["RANK"])
+    args["local_rank"] = int(os.environ["LOCAL_RANK"])
+    torch.cuda.set_device(args["local_rank"])
+    dist.init_process_group(backend="nccl")
+    _METRIC_PROCESS_GROUP = dist.new_group(backend="gloo")
+    args["device"] = f"cuda:{args['local_rank']}"
+
+
+def cleanup_distributed():
+    if is_dist_enabled():
+        dist.destroy_process_group()
+
+
+def reduce_loss_dict(loss_dict, device):
+    if not is_dist_enabled():
+        return loss_dict
+    keys = sorted(loss_dict.keys())
+    values = torch.stack([loss_dict[key].detach().cpu().to(dtype=torch.float64) for key in keys])
+    dist.all_reduce(values, op=dist.ReduceOp.SUM, group=_METRIC_PROCESS_GROUP)
+    values /= dist.get_world_size()
+    return {key: value.to(device) for key, value in zip(keys, values)}
+
+
+def reduce_weighted_loss_dict(loss_sum_dict, count, device):
+    if not is_dist_enabled():
+        return {
+            key: value / max(count, 1)
+            for key, value in loss_sum_dict.items()
+        }
+
+    keys = sorted(loss_sum_dict.keys())
+    values = torch.stack([loss_sum_dict[key].detach().cpu().to(dtype=torch.float64) for key in keys])
+    count_tensor = torch.tensor(float(count), dtype=torch.float64)
+    dist.all_reduce(values, op=dist.ReduceOp.SUM, group=_METRIC_PROCESS_GROUP)
+    dist.all_reduce(count_tensor, op=dist.ReduceOp.SUM, group=_METRIC_PROCESS_GROUP)
+    count_tensor = count_tensor.clamp_min(1.0)
+    return {key: (value / count_tensor).to(device) for key, value in zip(keys, values)}
+
+
+def policy_state_dict_for_save(policy):
+    state_dict = policy.state_dict()
+    cleaned = {}
+    for key, value in state_dict.items():
+        key = key.replace("module.", "", 1)
+        key = key.replace("model.module.", "model.", 1)
+        cleaned[key] = value
+    return cleaned
+
+
+def _task_template_vars(task_name):
+    if not task_name.startswith("sim-"):
+        return {
+            "task_name_full": task_name,
+            "task_stem": task_name,
+            "task_config": "",
+            "expert_data_num": "",
+            "task_config_ep": "",
+        }
+    core = task_name[4:]
+
+    # Task names are sim-{task_stem}-{task_config}-{num_episodes}. Parse the
+    # episode count independently so path templates work for both 50 and 100
+    # demo policies without splitting default-balanced into default/balanced.
+    parts = core.rsplit("-", 1)
+    if len(parts) == 2 and parts[1].isdigit():
+        config_core, expert_data_num = parts
+        for suffix in ("-default-ee-balanced", "-default-balanced", "-default-ee", "-default"):
+            if config_core.endswith(suffix):
+                task_config = suffix[1:]
+                return {
+                    "task_name_full": task_name,
+                    "task_stem": config_core[: -len(suffix)],
+                    "task_config": task_config,
+                    "expert_data_num": expert_data_num,
+                    "task_config_ep": f"{task_config}-{expert_data_num}",
+                }
+
+    # Backward compatibility for legacy hard-coded 50-demo task names.
+    for suffix in ("-default-ee-balanced-50", "-default-balanced-50", "-default-ee-50", "-default-50"):
+        if core.endswith(suffix):
+            expert_data_num = suffix.rsplit("-", 1)[-1]
+            task_config_ep = suffix[1:]
+            task_config = task_config_ep[: -(len(expert_data_num) + 1)]
+            return {
+                "task_name_full": task_name,
+                "task_stem": core[: -len(suffix)],
+                "task_config": task_config,
+                "expert_data_num": expert_data_num,
+                "task_config_ep": task_config_ep,
+            }
+    parts = core.rsplit("-", 2)
+    if len(parts) < 3:
+        return {
+            "task_name_full": task_name,
+            "task_stem": core,
+            "task_config": "",
+            "expert_data_num": "",
+            "task_config_ep": "",
+        }
+    task_stem, task_config, expert_data_num = parts
+    return {
+        "task_name_full": task_name,
+        "task_stem": task_stem,
+        "task_config": task_config,
+        "expert_data_num": expert_data_num,
+        "task_config_ep": f"{task_config}-{expert_data_num}",
+    }
+
+
+def _resolve_path_template(path_value, task_name):
+    if not path_value:
+        return path_value
+    return path_value.format(**_task_template_vars(task_name))
+
+
+def _resolve_vitacdreamer_task_id(args, task_name):
+    task_order = args.get("vitacdreamer_task_order", None)
+    if task_order is None:
+        return None
+    task_stem = _task_template_vars(task_name)["task_stem"]
+    if task_stem not in task_order:
+        raise ValueError(f"Task {task_stem!r} is not in vitacdreamer_task_order={task_order}")
+    return task_order.index(task_stem)
+
+
+def main(args):
+    setup_distributed(args)
+    set_seed(1 + int(args.get("rank", 0)))
+    # command line parameters
+    is_eval = args["eval"]
+    ckpt_dir = args["ckpt_dir"]
+    policy_class = args["policy_class"]
+    onscreen_render = args["onscreen_render"]
+    task_name = args["task_name"]
+    batch_size_train = args["batch_size"]
+    batch_size_val = args["batch_size"]
+
+    # get task parameters
+    is_sim = task_name[:4] == "sim-"
+    if is_sim:
+        # TacArena: load from JSON file generated by process_data.py
+        SIM_TASK_CONFIGS_PATH = "./SIM_TASK_CONFIGS.json"
+        with open(SIM_TASK_CONFIGS_PATH, "r") as f:
+            SIM_TASK_CONFIGS = json.load(f)
+        task_config = SIM_TASK_CONFIGS[task_name]
+    else:
+        from aloha_scripts.constants import TASK_CONFIGS
+        task_config = TASK_CONFIGS[task_name]
+    
+    dataset_dir = task_config["dataset_dir"]
+    num_episodes = task_config["num_episodes"]
+    episode_len = task_config["episode_len"]
+    camera_names = args["camera_names"]
+
+    # fixed parameters
+    if policy_class == "CNNMLP":
+        policy_config = {
+            "lr": args["lr"],
+            "lr_backbone": args["lr_backbone"],
+            "backbone": args["backbone"],
+            "num_queries": 1,
+            "camera_names": camera_names,
+        }
+    elif policy_class != "ACT":
+        raise NotImplementedError
+
+    state_dim = args["state_dim"]
+    tactile_names = args["tactile_names"]
+    chunk_size = args["chunk_size"]
+    config = {
+        "num_epochs": 6000,
+        "ckpt_dir": ckpt_dir,
+        "episode_len": episode_len,
+        "state_dim": state_dim,
+        "lr": args["lr"],
+        "policy_class": policy_class,
+        "onscreen_render": onscreen_render,
+        "policy_config": args,
+        "task_name": task_name,
+        "seed": args["seed"],
+        "temporal_agg": args["temporal_agg"],
+        "camera_names": camera_names,
+        "real_robot": not is_sim,
+        "save_freq": args['save_freq'],
+        "num_steps": args['num_steps'],
+        "save_step_ckpts": args.get("save_step_ckpts", True),
+    }
+
+    if is_eval:
+        print("=" * 60)
+        print("TacArena ACT Policy Evaluation")
+        print("=" * 60)
+        print("Please use the unified evaluation script:")
+        print("  python scripts/eval_policy.py policy/ACT/deploy_policy_{task_name}.yml")
+        print("")
+        print("Note: TacArena uses IsaacLab simulation environment for evaluation.")
+        print("      The eval_bc() function is for RoboTwin's MuJoCo environment.")
+        print("=" * 60)
+        exit()
+
+    train_dataloader, val_dataloader, stats, _, train_sampler, _ = load_data(
+        dataset_dir, num_episodes, camera_names, tactile_names, batch_size_train, batch_size_val, chunk_size,
+        num_workers=args.get("num_workers", 0),
+        use_vitacdreamer_feature=args.get("use_vitacdreamer_feature", False),
+        vitacdreamer_history_len=args.get("vitacdreamer_history_len", 5),
+        vitacdreamer_feature_cache_dir=_resolve_path_template(
+            args.get("vitacdreamer_feature_cache_dir", None),
+            task_name,
+        ),
+        vitacdreamer_task_id=_resolve_vitacdreamer_task_id(args, task_name),
+        distributed=args.get("distributed", False),
+    )
+
+    # save dataset stats
+    if is_main_process() and not os.path.isdir(ckpt_dir):
+        os.makedirs(ckpt_dir)
+    stats_path = os.path.join(ckpt_dir, f"dataset_stats.pkl")
+    if is_main_process():
+        with open(stats_path, "wb") as f:
+            pickle.dump(stats, f)
+    config["train_sampler"] = train_sampler
+    best_ckpt_info = train_bc(train_dataloader, val_dataloader, config)
+    if is_main_process():
+        best_epoch, min_val_loss, best_state_dict = best_ckpt_info
+        ckpt_path = os.path.join(ckpt_dir, f"policy_best.ckpt")
+        torch.save(best_state_dict, ckpt_path)
+        print(f"Best ckpt, val loss {min_val_loss:.6f} @ epoch{best_epoch}")
+    cleanup_distributed()
+
+
+def make_policy(policy_class, policy_config):
+    if policy_class == "ACT":
+        policy = ACTPolicy(policy_config)
+    elif policy_class == "CNNMLP":
+        policy = CNNMLPPolicy(policy_config)
+    else:
+        raise NotImplementedError
+    return policy
+
+
+def make_optimizer(policy_class, policy):
+    if policy_class == "ACT":
+        optimizer = policy.configure_optimizers()
+    elif policy_class == "CNNMLP":
+        optimizer = policy.configure_optimizers()
+    else:
+        raise NotImplementedError
+    return optimizer
+
+
+def forward_pass(data, policy):
+    if len(data) == 6:
+        cam_data, tac_data, qpos_data, action_data, is_pad, vitac_data = data
+    else:
+        cam_data, tac_data, qpos_data, action_data, is_pad = data
+        vitac_data = None
+    device = next(policy.parameters()).device
+    cam_data, tac_data, qpos_data, action_data, is_pad = (
+        cam_data.to(device),
+        tac_data.to(device),
+        qpos_data.to(device),
+        action_data.to(device),
+        is_pad.to(device),
+    )
+    vitac_inputs = None
+    vitac_feature = None
+    if vitac_data is not None:
+        if isinstance(vitac_data, dict):
+            vitac_inputs = {
+                key: value.to(device)
+                for key, value in vitac_data.items()
+            }
+        else:
+            vitac_feature = vitac_data.to(device)
+    return policy(
+        qpos_data,
+        cam_data,
+        tac_data,
+        action_data,
+        is_pad,
+        vitac_inputs=vitac_inputs,
+        vitac_feature=vitac_feature,
+    )
+
+
+def train_bc(train_dataloader, val_dataloader, config):
+    ckpt_dir = config["ckpt_dir"]
+    seed = config["seed"]
+    policy_class = config["policy_class"]
+    policy_config = config["policy_config"]
+
+    set_seed(seed)
+
+    policy = make_policy(policy_class, policy_config)
+    policy.cuda()
+    local_rank = int(config.get("local_rank", 0))
+    if config.get("distributed", False):
+        if getattr(policy, "finetune_vitacdreamer_encoder", False):
+            policy = DDP(
+                policy,
+                device_ids=[local_rank],
+                output_device=local_rank,
+                find_unused_parameters=True,
+            )
+        else:
+            policy.model = DDP(
+                policy.model,
+                device_ids=[local_rank],
+                output_device=local_rank,
+                find_unused_parameters=False,
+            )
+    optimizer = make_optimizer(policy_class, unwrap_model(policy))
+
+    train_history = []
+    validation_history = []
+    min_val_loss = np.inf
+    best_ckpt_info = None
+
+    step_count = 0
+    num_steps = config['num_steps']
+    epoch = 0
+    
+    pbar = tqdm(range(num_steps), total=num_steps, leave=False, disable=not is_main_process())
+    while step_count < num_steps:
+        policy.train()
+        optimizer.zero_grad()
+        if isinstance(train_dataloader.sampler, DistributedSampler):
+            train_dataloader.sampler.set_epoch(epoch)
+        for batch_idx, data in enumerate(train_dataloader):
+            forward_dict = forward_pass(data, policy)
+            # backward
+            loss = forward_dict["loss"]
+            loss.backward()
+            optimizer.step()
+            optimizer.zero_grad()
+            if is_main_process():
+                train_history.append(detach_dict(forward_dict))
+
+            if is_main_process():
+                pbar.set_postfix({'epoch': epoch, 'loss': loss.item()})
+                pbar.update(1)
+
+            step_count += 1
+            if is_main_process() and step_count % config['save_freq'] == 0:
+                state_to_save = policy_state_dict_for_save(policy)
+                ckpt_path = os.path.join(ckpt_dir, f"policy_epoch_{epoch + 1}_seed_{seed}.ckpt")
+                torch.save(state_to_save, ckpt_path)
+                if config.get("save_step_ckpts", True):
+                    step_ckpt_path = os.path.join(ckpt_dir, f"policy_step_{step_count}_seed_{seed}.ckpt")
+                    torch.save(state_to_save, step_ckpt_path)
+                plot_history(train_history, validation_history, epoch, ckpt_dir, seed)
+
+            if step_count >= num_steps:
+                break
+
+        stop_after_train = step_count >= num_steps
+        if is_dist_enabled():
+            stop_tensor = torch.tensor(float(stop_after_train), dtype=torch.float64)
+            dist.all_reduce(stop_tensor, op=dist.ReduceOp.MAX, group=_METRIC_PROCESS_GROUP)
+            stop_after_train = bool(stop_tensor.item())
+
+        if stop_after_train:
+            break
+
+        if is_main_process():
+            epoch_train_start = epoch * len(train_dataloader)
+            epoch_train_dicts = train_history[epoch_train_start:]
+            epoch_summary = compute_dict_mean(epoch_train_dicts) if epoch_train_dicts else {}
+            train_summary_string = ""
+            for k, v in epoch_summary.items():
+                train_summary_string += f"{k}: {v.item():.3f} "
+        else:
+            epoch_summary = {}
+            train_summary_string = ""
+
+        with torch.inference_mode():
+            policy.eval()
+            epoch_loss_sums = None
+            epoch_count = 0
+            for batch_idx, data in enumerate(val_dataloader):
+                forward_dict = forward_pass(data, policy)
+                batch_size = int(data[2].shape[0])
+                batch_loss_sums = {
+                    key: value.detach().to(next(policy.parameters()).device, dtype=torch.float64) * batch_size
+                    for key, value in forward_dict.items()
+                }
+                if epoch_loss_sums is None:
+                    epoch_loss_sums = batch_loss_sums
+                else:
+                    for key in epoch_loss_sums:
+                        epoch_loss_sums[key] += batch_loss_sums[key]
+                epoch_count += batch_size
+
+            epoch_summary = reduce_weighted_loss_dict(epoch_loss_sums, epoch_count, next(policy.parameters()).device)
+            if is_main_process():
+                validation_history.append(epoch_summary)
+
+            epoch_val_loss = epoch_summary["loss"]
+            if is_main_process() and epoch_val_loss < min_val_loss:
+                min_val_loss = epoch_val_loss
+                best_ckpt_info = (epoch, min_val_loss, deepcopy(policy_state_dict_for_save(policy)))
+
+        eval_summary_string = ""
+        for k, v in epoch_summary.items():
+            eval_summary_string += f"{k}: {v.item():.3f} "
+
+        epoch += 1
+
+    if is_main_process():
+        ckpt_path = os.path.join(ckpt_dir, f"policy_last.ckpt")
+        torch.save(policy_state_dict_for_save(policy), ckpt_path)
+
+        if best_ckpt_info is None:
+            best_ckpt_info = (epoch, float("nan"), deepcopy(policy_state_dict_for_save(policy)))
+
+        best_epoch, min_val_loss, best_state_dict = best_ckpt_info
+        ckpt_path = os.path.join(ckpt_dir, f"policy_epoch_{best_epoch}_seed_{seed}.ckpt")
+        torch.save(best_state_dict, ckpt_path)
+        print(f"Training finished:\nSeed {seed}, val loss {min_val_loss:.6f} at epoch {best_epoch}")
+
+        # save training curves
+        plot_history(train_history, validation_history, epoch, ckpt_dir, seed)
+
+    return best_ckpt_info
+
+
+def plot_history(train_history, validation_history, num_epochs, ckpt_dir, seed):
+    # save training curves
+    for key in train_history[0]:
+        plot_path = os.path.join(ckpt_dir, f"train_val_{key}_seed_{seed}.png")
+        plt.figure()
+        train_values = [summary[key].item() for summary in train_history]
+        val_values = [summary[key].item() for summary in validation_history]
+        plt.plot(
+            np.linspace(0, num_epochs - 1, len(train_history)),
+            train_values,
+            label="train",
+        )
+        plt.plot(
+            np.linspace(0, num_epochs - 1, len(validation_history)),
+            val_values,
+            label="validation",
+        )
+        # plt.ylim([-0.1, 1])
+        plt.tight_layout()
+        plt.legend()
+        plt.title(key)
+        plt.savefig(plot_path)
+    print(f"Saved plots to {ckpt_dir}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--eval", action="store_true")
+    parser.add_argument("--onscreen_render", action="store_true")
+    parser.add_argument("--ckpt_dir", action="store", type=str, help="ckpt_dir", required=True)
+    parser.add_argument("--task_name", action="store", type=str, help="task_name", required=True)
+    parser.add_argument("--config_path", action="store", type=str, help="config_path", required=True)
+    parser.add_argument("--seed", action="store", type=int, help="seed", required=True)
+
+    args = parser.parse_args()
+    with open(args.config_path, 'r') as f:
+        config_args = yaml.load(f, Loader=yaml.FullLoader)
+    config_args.update(vars(args))
+    main(config_args)

experiments/h100/real150_insert_tube_weighted_policy_20260729/configs/train_config_vitacdreamer_real150_stage2_depthdelta_insert_tube_kl10_lr3e-5_s12000_gw8_late3.yml

@@ -0,0 +1,53 @@
+# Insert-tube focused retrain with weighted gripper and chunk-late action loss.
+state_dim: 8
+kl_weight: 10.0
+chunk_size: 15
+hidden_dim: 512
+dim_feedforward: 3200
+temporal_agg: true
+device: cuda:0
+ckpt_dir: null
+policy_class: ACT
+num_steps: 12000
+batch_size: 32
+num_workers: 4
+save_freq: 1000
+position_embedding: sine
+lr_vision_backbone: 1.0e-05
+weight_decay: 0.0001
+lr: 3.0e-05
+vitacdreamer_adapter_lr: 5.0e-05
+masks: false
+dilation: false
+backbone: resnet18
+nheads: 8
+enc_layers: 4
+dec_layers: 7
+pre_norm: false
+dropout: 0.025
+camera_names:
+- cam_high
+tactile_names:
+- tac_left
+- tac_right
+lr_tactile_backbone: 1.0e-05
+tactile_masks: false
+tactile_backbone: resnet18
+tactile_ckpt: null
+tactile_dilation: false
+use_vitacdreamer_feature: true
+vitacdreamer_history_len: 5
+vitacdreamer_sample_stride: 5
+vitacdreamer_feature_dim: 512
+vitacdreamer_fusion_mode: feature_query_policy_kv
+vitacdreamer_cross_attn_layers: none
+finetune_vitacdreamer_encoder: false
+vitacdreamer_checkpoint: /dev/shm/muse/checkpoints/real_insert_tube_wipe_board_150_h32_20260725/stage2_prior512_hlen5_depthdelta_120train30val_b192_from_stage1_prior512_hlen5_120train30val_b192/stage2_v2_encoder_only.pth
+vitacdreamer_feature_cache_dir: ./data/sim-{task_stem}/real-150/vitacdreamer_features_real150_stage2_depthdelta_20260727
+vitacdreamer_task_order:
+- insert_tube
+- wipe_board
+save_step_ckpts: true
+gripper_loss_weight: 8.0
+late_action_loss_weight: 3.0
+late_action_loss_start_ratio: 0.65

experiments/h100/real150_insert_tube_weighted_policy_20260729/configs/train_config_vitacdreamer_real150_stage2_depthdelta_insert_tube_kl2p5_lr3e-5_s12000_gw8_late3.yml

@@ -0,0 +1,53 @@
+# Insert-tube focused retrain with weighted gripper and chunk-late action loss.
+state_dim: 8
+kl_weight: 2.5
+chunk_size: 15
+hidden_dim: 512
+dim_feedforward: 3200
+temporal_agg: true
+device: cuda:0
+ckpt_dir: null
+policy_class: ACT
+num_steps: 12000
+batch_size: 32
+num_workers: 4
+save_freq: 1000
+position_embedding: sine
+lr_vision_backbone: 1.0e-05
+weight_decay: 0.0001
+lr: 3.0e-05
+vitacdreamer_adapter_lr: 5.0e-05
+masks: false
+dilation: false
+backbone: resnet18
+nheads: 8
+enc_layers: 4
+dec_layers: 7
+pre_norm: false
+dropout: 0.025
+camera_names:
+- cam_high
+tactile_names:
+- tac_left
+- tac_right
+lr_tactile_backbone: 1.0e-05
+tactile_masks: false
+tactile_backbone: resnet18
+tactile_ckpt: null
+tactile_dilation: false
+use_vitacdreamer_feature: true
+vitacdreamer_history_len: 5
+vitacdreamer_sample_stride: 5
+vitacdreamer_feature_dim: 512
+vitacdreamer_fusion_mode: feature_query_policy_kv
+vitacdreamer_cross_attn_layers: none
+finetune_vitacdreamer_encoder: false
+vitacdreamer_checkpoint: /dev/shm/muse/checkpoints/real_insert_tube_wipe_board_150_h32_20260725/stage2_prior512_hlen5_depthdelta_120train30val_b192_from_stage1_prior512_hlen5_120train30val_b192/stage2_v2_encoder_only.pth
+vitacdreamer_feature_cache_dir: ./data/sim-{task_stem}/real-150/vitacdreamer_features_real150_stage2_depthdelta_20260727
+vitacdreamer_task_order:
+- insert_tube
+- wipe_board
+save_step_ckpts: true
+gripper_loss_weight: 8.0
+late_action_loss_weight: 3.0
+late_action_loss_start_ratio: 0.65

experiments/h100/real150_insert_tube_weighted_policy_20260729/configs/train_config_vitacdreamer_real150_stage2_depthdelta_insert_tube_kl5_lr2e-5_s12000_gw8_late3.yml

@@ -0,0 +1,53 @@
+# Insert-tube focused retrain with weighted gripper and chunk-late action loss.
+state_dim: 8
+kl_weight: 5.0
+chunk_size: 15
+hidden_dim: 512
+dim_feedforward: 3200
+temporal_agg: true
+device: cuda:0
+ckpt_dir: null
+policy_class: ACT
+num_steps: 12000
+batch_size: 32
+num_workers: 4
+save_freq: 1000
+position_embedding: sine
+lr_vision_backbone: 1.0e-05
+weight_decay: 0.0001
+lr: 2.0e-05
+vitacdreamer_adapter_lr: 5.0e-05
+masks: false
+dilation: false
+backbone: resnet18
+nheads: 8
+enc_layers: 4
+dec_layers: 7
+pre_norm: false
+dropout: 0.025
+camera_names:
+- cam_high
+tactile_names:
+- tac_left
+- tac_right
+lr_tactile_backbone: 1.0e-05
+tactile_masks: false
+tactile_backbone: resnet18
+tactile_ckpt: null
+tactile_dilation: false
+use_vitacdreamer_feature: true
+vitacdreamer_history_len: 5
+vitacdreamer_sample_stride: 5
+vitacdreamer_feature_dim: 512
+vitacdreamer_fusion_mode: feature_query_policy_kv
+vitacdreamer_cross_attn_layers: none
+finetune_vitacdreamer_encoder: false
+vitacdreamer_checkpoint: /dev/shm/muse/checkpoints/real_insert_tube_wipe_board_150_h32_20260725/stage2_prior512_hlen5_depthdelta_120train30val_b192_from_stage1_prior512_hlen5_120train30val_b192/stage2_v2_encoder_only.pth
+vitacdreamer_feature_cache_dir: ./data/sim-{task_stem}/real-150/vitacdreamer_features_real150_stage2_depthdelta_20260727
+vitacdreamer_task_order:
+- insert_tube
+- wipe_board
+save_step_ckpts: true
+gripper_loss_weight: 8.0
+late_action_loss_weight: 3.0
+late_action_loss_start_ratio: 0.65

experiments/h100/real150_insert_tube_weighted_policy_20260729/configs/train_config_vitacdreamer_real150_stage2_depthdelta_insert_tube_kl5_lr3e-5_s12000_gw8_late3.yml

@@ -0,0 +1,53 @@
+# Insert-tube focused retrain with weighted gripper and chunk-late action loss.
+state_dim: 8
+kl_weight: 5.0
+chunk_size: 15
+hidden_dim: 512
+dim_feedforward: 3200
+temporal_agg: true
+device: cuda:0
+ckpt_dir: null
+policy_class: ACT
+num_steps: 12000
+batch_size: 32
+num_workers: 4
+save_freq: 1000
+position_embedding: sine
+lr_vision_backbone: 1.0e-05
+weight_decay: 0.0001
+lr: 3.0e-05
+vitacdreamer_adapter_lr: 5.0e-05
+masks: false
+dilation: false
+backbone: resnet18
+nheads: 8
+enc_layers: 4
+dec_layers: 7
+pre_norm: false
+dropout: 0.025
+camera_names:
+- cam_high
+tactile_names:
+- tac_left
+- tac_right
+lr_tactile_backbone: 1.0e-05
+tactile_masks: false
+tactile_backbone: resnet18
+tactile_ckpt: null
+tactile_dilation: false
+use_vitacdreamer_feature: true
+vitacdreamer_history_len: 5
+vitacdreamer_sample_stride: 5
+vitacdreamer_feature_dim: 512
+vitacdreamer_fusion_mode: feature_query_policy_kv
+vitacdreamer_cross_attn_layers: none
+finetune_vitacdreamer_encoder: false
+vitacdreamer_checkpoint: /dev/shm/muse/checkpoints/real_insert_tube_wipe_board_150_h32_20260725/stage2_prior512_hlen5_depthdelta_120train30val_b192_from_stage1_prior512_hlen5_120train30val_b192/stage2_v2_encoder_only.pth
+vitacdreamer_feature_cache_dir: ./data/sim-{task_stem}/real-150/vitacdreamer_features_real150_stage2_depthdelta_20260727
+vitacdreamer_task_order:
+- insert_tube
+- wipe_board
+save_step_ckpts: true
+gripper_loss_weight: 8.0
+late_action_loss_weight: 3.0
+late_action_loss_start_ratio: 0.65

experiments/h100/real150_insert_tube_weighted_policy_20260729/configs/train_config_vitacdreamer_real150_stage2_depthdelta_insert_tube_kl5_lr3e-5_s16000_gw8_late3.yml

@@ -0,0 +1,53 @@
+# Insert-tube focused retrain with weighted gripper and chunk-late action loss.
+state_dim: 8
+kl_weight: 5.0
+chunk_size: 15
+hidden_dim: 512
+dim_feedforward: 3200
+temporal_agg: true
+device: cuda:0
+ckpt_dir: null
+policy_class: ACT
+num_steps: 16000
+batch_size: 32
+num_workers: 4
+save_freq: 1000
+position_embedding: sine
+lr_vision_backbone: 1.0e-05
+weight_decay: 0.0001
+lr: 3.0e-05
+vitacdreamer_adapter_lr: 5.0e-05
+masks: false
+dilation: false
+backbone: resnet18
+nheads: 8
+enc_layers: 4
+dec_layers: 7
+pre_norm: false
+dropout: 0.025
+camera_names:
+- cam_high
+tactile_names:
+- tac_left
+- tac_right
+lr_tactile_backbone: 1.0e-05
+tactile_masks: false
+tactile_backbone: resnet18
+tactile_ckpt: null
+tactile_dilation: false
+use_vitacdreamer_feature: true
+vitacdreamer_history_len: 5
+vitacdreamer_sample_stride: 5
+vitacdreamer_feature_dim: 512
+vitacdreamer_fusion_mode: feature_query_policy_kv
+vitacdreamer_cross_attn_layers: none
+finetune_vitacdreamer_encoder: false
+vitacdreamer_checkpoint: /dev/shm/muse/checkpoints/real_insert_tube_wipe_board_150_h32_20260725/stage2_prior512_hlen5_depthdelta_120train30val_b192_from_stage1_prior512_hlen5_120train30val_b192/stage2_v2_encoder_only.pth
+vitacdreamer_feature_cache_dir: ./data/sim-{task_stem}/real-150/vitacdreamer_features_real150_stage2_depthdelta_20260727
+vitacdreamer_task_order:
+- insert_tube
+- wipe_board
+save_step_ckpts: true
+gripper_loss_weight: 8.0
+late_action_loss_weight: 3.0
+late_action_loss_start_ratio: 0.65

experiments/h100/real150_insert_tube_weighted_policy_20260729/configs/train_config_vitacdreamer_real150_stage2_depthdelta_insert_tube_kl5_lr3e-5_s8000_gw8_late3.yml

@@ -0,0 +1,53 @@
+# Insert-tube focused retrain with weighted gripper and chunk-late action loss.
+state_dim: 8
+kl_weight: 5.0
+chunk_size: 15
+hidden_dim: 512
+dim_feedforward: 3200
+temporal_agg: true
+device: cuda:0
+ckpt_dir: null
+policy_class: ACT
+num_steps: 8000
+batch_size: 32
+num_workers: 4
+save_freq: 1000
+position_embedding: sine
+lr_vision_backbone: 1.0e-05
+weight_decay: 0.0001
+lr: 3.0e-05
+vitacdreamer_adapter_lr: 5.0e-05
+masks: false
+dilation: false
+backbone: resnet18
+nheads: 8
+enc_layers: 4
+dec_layers: 7
+pre_norm: false
+dropout: 0.025
+camera_names:
+- cam_high
+tactile_names:
+- tac_left
+- tac_right
+lr_tactile_backbone: 1.0e-05
+tactile_masks: false
+tactile_backbone: resnet18
+tactile_ckpt: null
+tactile_dilation: false
+use_vitacdreamer_feature: true
+vitacdreamer_history_len: 5
+vitacdreamer_sample_stride: 5
+vitacdreamer_feature_dim: 512
+vitacdreamer_fusion_mode: feature_query_policy_kv
+vitacdreamer_cross_attn_layers: none
+finetune_vitacdreamer_encoder: false
+vitacdreamer_checkpoint: /dev/shm/muse/checkpoints/real_insert_tube_wipe_board_150_h32_20260725/stage2_prior512_hlen5_depthdelta_120train30val_b192_from_stage1_prior512_hlen5_120train30val_b192/stage2_v2_encoder_only.pth
+vitacdreamer_feature_cache_dir: ./data/sim-{task_stem}/real-150/vitacdreamer_features_real150_stage2_depthdelta_20260727
+vitacdreamer_task_order:
+- insert_tube
+- wipe_board
+save_step_ckpts: true
+gripper_loss_weight: 8.0
+late_action_loss_weight: 3.0
+late_action_loss_start_ratio: 0.65

experiments/h100/real150_insert_tube_weighted_policy_20260729/configs/train_config_vitacdreamer_real150_stage2_depthdelta_insert_tube_kl5_lr5e-5_s12000_gw8_late3.yml

@@ -0,0 +1,53 @@
+# Insert-tube focused retrain with weighted gripper and chunk-late action loss.
+state_dim: 8
+kl_weight: 5.0
+chunk_size: 15
+hidden_dim: 512
+dim_feedforward: 3200
+temporal_agg: true
+device: cuda:0
+ckpt_dir: null
+policy_class: ACT
+num_steps: 12000
+batch_size: 32
+num_workers: 4
+save_freq: 1000
+position_embedding: sine
+lr_vision_backbone: 1.0e-05
+weight_decay: 0.0001
+lr: 5.0e-05
+vitacdreamer_adapter_lr: 5.0e-05
+masks: false
+dilation: false
+backbone: resnet18
+nheads: 8
+enc_layers: 4
+dec_layers: 7
+pre_norm: false
+dropout: 0.025
+camera_names:
+- cam_high
+tactile_names:
+- tac_left
+- tac_right
+lr_tactile_backbone: 1.0e-05
+tactile_masks: false
+tactile_backbone: resnet18
+tactile_ckpt: null
+tactile_dilation: false
+use_vitacdreamer_feature: true
+vitacdreamer_history_len: 5
+vitacdreamer_sample_stride: 5
+vitacdreamer_feature_dim: 512
+vitacdreamer_fusion_mode: feature_query_policy_kv
+vitacdreamer_cross_attn_layers: none
+finetune_vitacdreamer_encoder: false
+vitacdreamer_checkpoint: /dev/shm/muse/checkpoints/real_insert_tube_wipe_board_150_h32_20260725/stage2_prior512_hlen5_depthdelta_120train30val_b192_from_stage1_prior512_hlen5_120train30val_b192/stage2_v2_encoder_only.pth
+vitacdreamer_feature_cache_dir: ./data/sim-{task_stem}/real-150/vitacdreamer_features_real150_stage2_depthdelta_20260727
+vitacdreamer_task_order:
+- insert_tube
+- wipe_board
+save_step_ckpts: true
+gripper_loss_weight: 8.0
+late_action_loss_weight: 3.0
+late_action_loss_start_ratio: 0.65

experiments/h100/real150_insert_tube_weighted_policy_20260729/configs/train_config_vitacdreamer_real150_stage2_depthdelta_insert_tube_kl7p5_lr3e-5_s12000_gw8_late3.yml

@@ -0,0 +1,53 @@
+# Insert-tube focused retrain with weighted gripper and chunk-late action loss.
+state_dim: 8
+kl_weight: 7.5
+chunk_size: 15
+hidden_dim: 512
+dim_feedforward: 3200
+temporal_agg: true
+device: cuda:0
+ckpt_dir: null
+policy_class: ACT
+num_steps: 12000
+batch_size: 32
+num_workers: 4
+save_freq: 1000
+position_embedding: sine
+lr_vision_backbone: 1.0e-05
+weight_decay: 0.0001
+lr: 3.0e-05
+vitacdreamer_adapter_lr: 5.0e-05
+masks: false
+dilation: false
+backbone: resnet18
+nheads: 8
+enc_layers: 4
+dec_layers: 7
+pre_norm: false
+dropout: 0.025
+camera_names:
+- cam_high
+tactile_names:
+- tac_left
+- tac_right
+lr_tactile_backbone: 1.0e-05
+tactile_masks: false
+tactile_backbone: resnet18
+tactile_ckpt: null
+tactile_dilation: false
+use_vitacdreamer_feature: true
+vitacdreamer_history_len: 5
+vitacdreamer_sample_stride: 5
+vitacdreamer_feature_dim: 512
+vitacdreamer_fusion_mode: feature_query_policy_kv
+vitacdreamer_cross_attn_layers: none
+finetune_vitacdreamer_encoder: false
+vitacdreamer_checkpoint: /dev/shm/muse/checkpoints/real_insert_tube_wipe_board_150_h32_20260725/stage2_prior512_hlen5_depthdelta_120train30val_b192_from_stage1_prior512_hlen5_120train30val_b192/stage2_v2_encoder_only.pth
+vitacdreamer_feature_cache_dir: ./data/sim-{task_stem}/real-150/vitacdreamer_features_real150_stage2_depthdelta_20260727
+vitacdreamer_task_order:
+- insert_tube
+- wipe_board
+save_step_ckpts: true
+gripper_loss_weight: 8.0
+late_action_loss_weight: 3.0
+late_action_loss_start_ratio: 0.65

experiments/h100/real150_insert_tube_weighted_policy_20260729/scripts/run_insert_tube_weighted_policy_8gpu_20260729.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT=/dev/shm/muse/src/ViTacDreamer_policy
+ACT=$ROOT/UniVTAC/policy/ACT
+ENV=/dev/shm/muse/envs/vitacdreamer_prior512
+RUN=real150_insert_tube_weighted_policy_20260729
+cd "$ACT"
+mkdir -p "logs/$RUN" "scripts/$RUN"
+cp "$0" "scripts/$RUN/launch_8gpu.sh" 2>/dev/null || true
+run_one() {
+  local tag="$1" gpu="$2"
+  local cfg="train_config_vitacdreamer_real150_stage2_depthdelta_insert_tube_${tag}"
+  local log="logs/$RUN/insert_tube_${tag}_gpu${gpu}.log"
+  echo "START $(date '+%F %T') tag=$tag gpu=$gpu cfg=$cfg" | tee -a "$log"
+  CUDA_VISIBLE_DEVICES="$gpu" PATH="$ENV/bin:$PATH" TORCH_HOME="$ROOT/.torch_cache"     bash train.sh insert_tube real 150 0 0 "$cfg" 2>&1 | tee -a "$log"
+  echo "END $(date '+%F %T') tag=$tag gpu=$gpu cfg=$cfg" | tee -a "$log"
+}
+run_one kl2p5_lr3e-5_s12000_gw8_late3 0 &
+run_one kl5_lr2e-5_s12000_gw8_late3 1 &
+run_one kl5_lr3e-5_s8000_gw8_late3 2 &
+run_one kl5_lr3e-5_s12000_gw8_late3 3 &
+run_one kl5_lr3e-5_s16000_gw8_late3 4 &
+run_one kl7p5_lr3e-5_s12000_gw8_late3 5 &
+run_one kl10_lr3e-5_s12000_gw8_late3 6 &
+run_one kl5_lr5e-5_s12000_gw8_late3 7 &
+wait
+echo DONE_ALL