Add files using upload-large-folder tool

.gitattributes

@@ -2022,3 +2022,23 @@ objects/012_plant-pot/collision/base4.glb filter=lfs diff=lfs merge=lfs -text
 objects/012_plant-pot/collision/base3.glb filter=lfs diff=lfs merge=lfs -text
 objects/074_displaystand/collision/base0.glb filter=lfs diff=lfs merge=lfs -text
 objects/074_displaystand/collision/base2.glb filter=lfs diff=lfs merge=lfs -text
+tactile_data/videos/peg_insertion/episode_00.hdf5 filter=lfs diff=lfs merge=lfs -text
+tactile_data/videos/peg_insertion/episode_02.hdf5 filter=lfs diff=lfs merge=lfs -text
+tactile_data/videos/peg_insertion/episode_07.hdf5 filter=lfs diff=lfs merge=lfs -text
+tactile_data/videos/peg_insertion/episode_06.hdf5 filter=lfs diff=lfs merge=lfs -text
+tactile_data/videos/peg_insertion/episode_01.hdf5 filter=lfs diff=lfs merge=lfs -text
+tactile_data/videos/peg_insertion/episode_05.hdf5 filter=lfs diff=lfs merge=lfs -text
+tactile_data/videos/peg_insertion/episode_03.hdf5 filter=lfs diff=lfs merge=lfs -text
+tactile_data/videos/peg_insertion/episode_04.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_36.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_39.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_33.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_10.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_48.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_13.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_5.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_20.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_18.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_35.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_37.hdf5 filter=lfs diff=lfs merge=lfs -text
+policy/EVA/processed_data/sim-peg_insertion/default-50/episode_41.hdf5 filter=lfs diff=lfs merge=lfs -text

policy/EVA/SIM_TASK_CONFIGS.json

@@ -0,0 +1,11 @@
+{
+    "sim-peg_insertion-default-50": {
+        "dataset_dir": "./processed_data/sim-peg_insertion/default-50",
+        "num_episodes": 50,
+        "episode_len": 495,
+        "camera_names": [
+            "agentview",
+            "eye_in_hand"
+        ]
+    }
+}

policy/EVA/__init__.py

@@ -0,0 +1,2 @@
+from .eva_policy import EVAPolicy
+from .tactile_event import TactileEventDetector, label_tactile_events, tactile_event_loss

policy/EVA/constants.py

@@ -0,0 +1,15 @@
+import os
+import json
+
+current_dir = os.path.dirname(__file__)
+
+### Task parameters
+SIM_TASK_CONFIGS_PATH = os.path.join(current_dir, "SIM_TASK_CONFIGS.json")
+try:
+    with open(SIM_TASK_CONFIGS_PATH, "r") as f:
+        SIM_TASK_CONFIGS = json.load(f)
+except (FileNotFoundError, json.JSONDecodeError):
+    SIM_TASK_CONFIGS = {}
+
+### Simulation fixed constants
+DT = 0.05  # 20Hz control

policy/EVA/detr/main.py

@@ -0,0 +1,103 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+import argparse
+from pathlib import Path
+
+import numpy as np
+import torch
+from .models import build_EVA_model, build_CNNMLP_model
+
+import IPython
+
+e = IPython.embed
+
+
+def get_args_parser():
+    parser = argparse.ArgumentParser("Set transformer detector", add_help=False)
+    parser.add_argument("--lr", default=1e-4, type=float)
+    parser.add_argument("--lr_backbone", default=1e-5, type=float)
+    parser.add_argument("--batch_size", default=2, type=int)
+    parser.add_argument("--weight_decay", default=1e-4, type=float)
+    parser.add_argument("--epochs", default=300, type=int)
+    parser.add_argument("--lr_drop", default=200, type=int)
+    parser.add_argument("--clip_max_norm", default=0.1, type=float, help="gradient clipping max norm")
+
+    # Model parameters
+    parser.add_argument("--backbone", default="resnet18", type=str, help="Name of the convolutional backbone to use")
+    parser.add_argument("--dilation", action="store_true",
+                        help="If true, we replace stride with dilation in the last convolutional block (DC5)")
+    parser.add_argument("--position_embedding", default="sine", type=str, choices=("sine", "learned"),
+                        help="Type of positional embedding to use on top of the image features")
+    parser.add_argument("--camera_names", default=[], type=list, help="A list of camera names")
+
+    # Transformer
+    parser.add_argument("--enc_layers", default=4, type=int, help="Number of encoding layers in the transformer")
+    parser.add_argument("--dec_layers", default=6, type=int, help="Number of decoding layers in the transformer")
+    parser.add_argument("--dim_feedforward", default=2048, type=int,
+                        help="Intermediate size of the feedforward layers in the transformer blocks")
+    parser.add_argument("--hidden_dim", default=256, type=int, help="Size of the embeddings (dimension of the transformer)")
+    parser.add_argument("--dropout", default=0.1, type=float, help="Dropout applied in the transformer")
+    parser.add_argument("--nheads", default=8, type=int, help="Number of attention heads inside the transformer's attentions")
+    parser.add_argument("--pre_norm", action="store_true")
+
+    # Segmentation
+    parser.add_argument("--masks", action="store_true", help="Train segmentation head if the flag is provided")
+
+    # repeat args in imitate_episodes just to avoid error
+    parser.add_argument("--eval", action="store_true")
+    parser.add_argument("--onscreen_render", action="store_true")
+    parser.add_argument("--ckpt_dir", type=str, default=None)
+    parser.add_argument("--policy_class", type=str, default=None)
+    parser.add_argument("--task_name", type=str, default=None)
+    parser.add_argument("--seed", type=int, default=None)
+    parser.add_argument("--num_epochs", type=int, default=None)
+    parser.add_argument("--kl_weight", type=int, default=None)
+    parser.add_argument("--chunk_size", type=int, default=None)
+    parser.add_argument("--temporal_agg", action="store_true")
+    parser.add_argument("--state_dim", type=int, default=None)
+    parser.add_argument("--save_freq", type=int, default=6000)
+
+    return parser
+
+
+def build_EVA_model_and_optimizer(args_override, RoboTwin_Config=None):
+    if RoboTwin_Config is None:
+        parser = argparse.ArgumentParser("DETR training and evaluation script", parents=[get_args_parser()])
+        args, _ = parser.parse_known_args()
+        for k, v in args_override.items():
+            setattr(args, k, v)
+    else:
+        args = RoboTwin_Config
+
+    print("build_EVA_model_and_optimizer", args)
+
+    model = build_EVA_model(args)
+    model.cuda()
+
+    param_dicts = [
+        {"params": [p for n, p in model.named_parameters() if "backbone" not in n and p.requires_grad]},
+        {"params": [p for n, p in model.named_parameters() if "backbone" in n and p.requires_grad],
+         "lr": args.lr_backbone},
+    ]
+    optimizer = torch.optim.AdamW(param_dicts, lr=args.lr, weight_decay=args.weight_decay)
+
+    return model, optimizer
+
+
+def build_CNNMLP_model_and_optimizer(args_override):
+    parser = argparse.ArgumentParser("DETR training and evaluation script", parents=[get_args_parser()])
+    args = parser.parse_args()
+
+    for k, v in args_override.items():
+        setattr(args, k, v)
+
+    model = build_CNNMLP_model(args)
+    model.cuda()
+
+    param_dicts = [
+        {"params": [p for n, p in model.named_parameters() if "backbone" not in n and p.requires_grad]},
+        {"params": [p for n, p in model.named_parameters() if "backbone" in n and p.requires_grad],
+         "lr": args.lr_backbone},
+    ]
+    optimizer = torch.optim.AdamW(param_dicts, lr=args.lr, weight_decay=args.weight_decay)
+
+    return model, optimizer

policy/EVA/detr/models/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+from .detr_vae import build as build_vae
+from .detr_vae import build_cnnmlp as build_cnnmlp
+
+
+def build_EVA_model(args):
+    return build_vae(args)
+
+
+def build_CNNMLP_model(args):
+    return build_cnnmlp(args)

policy/EVA/detr/models/backbone.py

@@ -0,0 +1,128 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Backbone modules.
+"""
+from collections import OrderedDict
+import os
+import torch
+import torch.nn.functional as F
+import torchvision
+from torch import nn
+from torchvision.models._utils import IntermediateLayerGetter
+from typing import Dict, List
+import sys
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.abspath(os.path.join(current_dir, '..'))
+sys.path.append(project_root)
+
+from util.misc import NestedTensor, is_main_process
+
+from .position_encoding import build_position_encoding
+
+import IPython
+
+e = IPython.embed
+
+
+class FrozenBatchNorm2d(torch.nn.Module):
+    """
+    BatchNorm2d where the batch statistics and the affine parameters are fixed.
+
+    Copy-paste from torchvision.misc.ops with added eps before rqsrt,
+    without which any other policy_models than torchvision.policy_models.resnet[18,34,50,101]
+    produce nans.
+    """
+
+    def __init__(self, n):
+        super(FrozenBatchNorm2d, self).__init__()
+        self.register_buffer("weight", torch.ones(n))
+        self.register_buffer("bias", torch.zeros(n))
+        self.register_buffer("running_mean", torch.zeros(n))
+        self.register_buffer("running_var", torch.ones(n))
+
+    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys,
+                              error_msgs):
+        num_batches_tracked_key = prefix + 'num_batches_tracked'
+        if num_batches_tracked_key in state_dict:
+            del state_dict[num_batches_tracked_key]
+
+        super(FrozenBatchNorm2d, self)._load_from_state_dict(state_dict, prefix, local_metadata, strict, missing_keys,
+                                                             unexpected_keys, error_msgs)
+
+    def forward(self, x):
+        # move reshapes to the beginning
+        # to make it fuser-friendly
+        w = self.weight.reshape(1, -1, 1, 1)
+        b = self.bias.reshape(1, -1, 1, 1)
+        rv = self.running_var.reshape(1, -1, 1, 1)
+        rm = self.running_mean.reshape(1, -1, 1, 1)
+        eps = 1e-5
+        scale = w * (rv + eps).rsqrt()
+        bias = b - rm * scale
+        return x * scale + bias
+
+
+class BackboneBase(nn.Module):
+
+    def __init__(self, backbone: nn.Module, train_backbone: bool, num_channels: int, return_interm_layers: bool):
+        super().__init__()
+        # for name, parameter in backbone.named_parameters(): # only train later layers # TODO do we want this?
+        #     if not train_backbone or 'layer2' not in name and 'layer3' not in name and 'layer4' not in name:
+        #         parameter.requires_grad_(False)
+        if return_interm_layers:
+            return_layers = {"layer1": "0", "layer2": "1", "layer3": "2", "layer4": "3"}
+        else:
+            return_layers = {'layer4': "0"}
+        self.body = IntermediateLayerGetter(backbone, return_layers=return_layers)
+        self.num_channels = num_channels
+
+    def forward(self, tensor):
+        xs = self.body(tensor)
+        return xs
+        # out: Dict[str, NestedTensor] = {}
+        # for name, x in xs.items():
+        #     m = tensor_list.mask
+        #     assert m is not None
+        #     mask = F.interpolate(m[None].float(), size=x.shape[-2:]).to(torch.bool)[0]
+        #     out[name] = NestedTensor(x, mask)
+        # return out
+
+
+class Backbone(BackboneBase):
+    """ResNet backbone with frozen BatchNorm."""
+
+    def __init__(self, name: str, train_backbone: bool, return_interm_layers: bool, dilation: bool):
+        backbone = getattr(torchvision.models,
+                           name)(replace_stride_with_dilation=[False, False, dilation],
+                                 pretrained=is_main_process(),
+                                 norm_layer=FrozenBatchNorm2d)  # pretrained # TODO do we want frozen batch_norm??
+        num_channels = 512 if name in ('resnet18', 'resnet34') else 2048
+        super().__init__(backbone, train_backbone, num_channels, return_interm_layers)
+
+
+class Joiner(nn.Sequential):
+
+    def __init__(self, backbone, position_embedding):
+        super().__init__(backbone, position_embedding)
+
+    def forward(self, tensor_list: NestedTensor):
+        xs = self[0](tensor_list)
+        out: List[NestedTensor] = []
+        pos = []
+        for name, x in xs.items():
+            out.append(x)
+            # position encoding
+            pos.append(self[1](x).to(x.dtype))
+
+        return out, pos
+
+
+def build_backbone(args):
+    position_embedding = build_position_encoding(args)
+    train_backbone = args.lr_backbone > 0
+    return_interm_layers = args.masks
+    backbone = Backbone(args.backbone, train_backbone, return_interm_layers, args.dilation)
+    model = Joiner(backbone, position_embedding)
+    model.num_channels = backbone.num_channels
+    return model

policy/EVA/detr/models/detr_vae.py

@@ -0,0 +1,253 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+# Modified for EVA: adds event_token injection into transformer encoder input.
+"""
+DETR-VAE model for EVA (Event-driven Visual-tactile ACT).
+
+Only change vs original ACT:
+  - DETRVAE.forward() accepts optional event_token [B, hidden_dim]
+  - event_token is prepended to the decoder transformer input alongside latent & proprio
+  - additional_pos_embed grows from 2 → 3 when event_token is used
+"""
+import torch
+from torch import nn
+from torch.autograd import Variable
+from .backbone import build_backbone
+from .transformer import build_transformer, TransformerEncoder, TransformerEncoderLayer
+
+import numpy as np
+
+import IPython
+
+e = IPython.embed
+
+
+def reparametrize(mu, logvar):
+    std = logvar.div(2).exp()
+    eps = Variable(std.data.new(std.size()).normal_())
+    return mu + std * eps
+
+
+def get_sinusoid_encoding_table(n_position, d_hid):
+
+    def get_position_angle_vec(position):
+        return [position / np.power(10000, 2 * (hid_j // 2) / d_hid) for hid_j in range(d_hid)]
+
+    sinusoid_table = np.array([get_position_angle_vec(pos_i) for pos_i in range(n_position)])
+    sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2])  # dim 2i
+    sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2])  # dim 2i+1
+
+    return torch.FloatTensor(sinusoid_table).unsqueeze(0)
+
+
+class DETRVAE(nn.Module):
+    """DETR-VAE with optional tactile event token injection."""
+
+    def __init__(self, backbones, transformer, encoder, state_dim, num_queries, camera_names):
+        super().__init__()
+        self.num_queries = num_queries
+        self.camera_names = camera_names
+        self.transformer = transformer
+        self.encoder = encoder
+        hidden_dim = transformer.d_model
+        self.action_head = nn.Linear(hidden_dim, state_dim)
+        self.is_pad_head = nn.Linear(hidden_dim, 1)
+        self.query_embed = nn.Embedding(num_queries, hidden_dim)
+        if backbones is not None:
+            self.input_proj = nn.Conv2d(backbones[0].num_channels, hidden_dim, kernel_size=1)
+            self.backbones = nn.ModuleList(backbones)
+            self.input_proj_robot_state = nn.Linear(state_dim, hidden_dim)
+        else:
+            self.input_proj_robot_state = nn.Linear(state_dim, hidden_dim)
+            self.input_proj_env_state = nn.Linear(7, hidden_dim)
+            self.pos = torch.nn.Embedding(2, hidden_dim)
+            self.backbones = None
+
+        # encoder extra parameters (CVAE)
+        self.latent_dim = 32
+        self.cls_embed = nn.Embedding(1, hidden_dim)
+        self.encoder_action_proj = nn.Linear(state_dim, hidden_dim)
+        self.encoder_joint_proj = nn.Linear(state_dim, hidden_dim)
+        self.latent_proj = nn.Linear(hidden_dim, self.latent_dim * 2)
+        self.register_buffer('pos_table', get_sinusoid_encoding_table(1 + 1 + num_queries, hidden_dim))
+
+        # decoder extra parameters
+        self.latent_out_proj = nn.Linear(self.latent_dim, hidden_dim)
+        # 3 slots: [latent, proprio, event_token]
+        self.additional_pos_embed = nn.Embedding(3, hidden_dim)
+
+    def forward(self, qpos, image, env_state, actions=None, is_pad=None, event_token=None):
+        """
+        Args:
+            qpos: [B, state_dim]
+            image: [B, num_cam, C, H, W]
+            env_state: None
+            actions: [B, seq, action_dim] or None
+            is_pad: [B, seq] or None
+            event_token: [B, hidden_dim] or None — from TactileEventDetector
+        """
+        is_training = actions is not None
+        bs, _ = qpos.shape
+
+        ### Obtain latent z from action sequence (CVAE encoder — unchanged)
+        if is_training:
+            action_embed = self.encoder_action_proj(actions)
+            qpos_embed = self.encoder_joint_proj(qpos)
+            qpos_embed = torch.unsqueeze(qpos_embed, axis=1)
+            cls_embed = self.cls_embed.weight
+            cls_embed = torch.unsqueeze(cls_embed, axis=0).repeat(bs, 1, 1)
+            encoder_input = torch.cat([cls_embed, qpos_embed, action_embed], axis=1)
+            encoder_input = encoder_input.permute(1, 0, 2)
+            cls_joint_is_pad = torch.full((bs, 2), False).to(qpos.device)
+            is_pad = torch.cat([cls_joint_is_pad, is_pad], axis=1)
+            pos_embed = self.pos_table.clone().detach()
+            pos_embed = pos_embed.permute(1, 0, 2)
+            encoder_output = self.encoder(encoder_input, pos=pos_embed, src_key_padding_mask=is_pad)
+            encoder_output = encoder_output[0]
+            latent_info = self.latent_proj(encoder_output)
+            mu = latent_info[:, :self.latent_dim]
+            logvar = latent_info[:, self.latent_dim:]
+            latent_sample = reparametrize(mu, logvar)
+            latent_input = self.latent_out_proj(latent_sample)
+        else:
+            mu = logvar = None
+            latent_sample = torch.zeros([bs, self.latent_dim], dtype=torch.float32).to(qpos.device)
+            latent_input = self.latent_out_proj(latent_sample)
+
+        ### Decoder transformer — inject event_token here
+        if self.backbones is not None:
+            all_cam_features = []
+            all_cam_pos = []
+            for cam_id, cam_name in enumerate(self.camera_names):
+                features, pos = self.backbones[0](image[:, cam_id])
+                features = features[0]
+                pos = pos[0]
+                all_cam_features.append(self.input_proj(features))
+                all_cam_pos.append(pos)
+            proprio_input = self.input_proj_robot_state(qpos)
+            src = torch.cat(all_cam_features, axis=3)
+            pos = torch.cat(all_cam_pos, axis=3)
+            hs = self.transformer(
+                src, None, self.query_embed.weight, pos,
+                latent_input, proprio_input,
+                self.additional_pos_embed.weight,
+                event_input=event_token,
+            )[0]
+        else:
+            qpos = self.input_proj_robot_state(qpos)
+            env_state = self.input_proj_env_state(env_state)
+            transformer_input = torch.cat([qpos, env_state], axis=1)
+            hs = self.transformer(transformer_input, None, self.query_embed.weight, self.pos.weight)[0]
+
+        a_hat = self.action_head(hs)
+        is_pad_hat = self.is_pad_head(hs)
+        return a_hat, is_pad_hat, [mu, logvar]
+
+
+class CNNMLP(nn.Module):
+
+    def __init__(self, backbones, state_dim, camera_names):
+        super().__init__()
+        self.camera_names = camera_names
+        self.action_head = nn.Linear(1000, state_dim)
+        if backbones is not None:
+            self.backbones = nn.ModuleList(backbones)
+            backbone_down_projs = []
+            for backbone in backbones:
+                down_proj = nn.Sequential(nn.Conv2d(backbone.num_channels, 128, kernel_size=5),
+                                          nn.Conv2d(128, 64, kernel_size=5), nn.Conv2d(64, 32, kernel_size=5))
+                backbone_down_projs.append(down_proj)
+            self.backbone_down_projs = nn.ModuleList(backbone_down_projs)
+            mlp_in_dim = 768 * len(backbones) + 14
+            self.mlp = mlp(input_dim=mlp_in_dim, hidden_dim=1024, output_dim=state_dim, hidden_depth=2)
+        else:
+            raise NotImplementedError
+
+    def forward(self, qpos, image, env_state, actions=None):
+        is_training = actions is not None
+        bs, _ = qpos.shape
+        all_cam_features = []
+        for cam_id, cam_name in enumerate(self.camera_names):
+            features, pos = self.backbones[cam_id](image[:, cam_id])
+            features = features[0]
+            pos = pos[0]
+            all_cam_features.append(self.backbone_down_projs[cam_id](features))
+        flattened_features = []
+        for cam_feature in all_cam_features:
+            flattened_features.append(cam_feature.reshape([bs, -1]))
+        flattened_features = torch.cat(flattened_features, axis=1)
+        features = torch.cat([flattened_features, qpos], axis=1)
+        a_hat = self.mlp(features)
+        return a_hat
+
+
+def mlp(input_dim, hidden_dim, output_dim, hidden_depth):
+    if hidden_depth == 0:
+        mods = [nn.Linear(input_dim, output_dim)]
+    else:
+        mods = [nn.Linear(input_dim, hidden_dim), nn.ReLU(inplace=True)]
+        for i in range(hidden_depth - 1):
+            mods += [nn.Linear(hidden_dim, hidden_dim), nn.ReLU(inplace=True)]
+        mods.append(nn.Linear(hidden_dim, output_dim))
+    trunk = nn.Sequential(*mods)
+    return trunk
+
+
+def build_encoder(args):
+    d_model = args.hidden_dim
+    dropout = args.dropout
+    nhead = args.nheads
+    dim_feedforward = args.dim_feedforward
+    num_encoder_layers = args.enc_layers
+    normalize_before = args.pre_norm
+    activation = "relu"
+
+    encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout, activation, normalize_before)
+    encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
+    encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
+
+    return encoder
+
+
+def build(args):
+    state_dim = getattr(args, 'state_dim', 14)
+
+    backbones = []
+    backbone = build_backbone(args)
+    backbones.append(backbone)
+
+    transformer = build_transformer(args)
+    encoder = build_encoder(args)
+
+    model = DETRVAE(
+        backbones,
+        transformer,
+        encoder,
+        state_dim=state_dim,
+        num_queries=args.chunk_size,
+        camera_names=args.camera_names,
+    )
+
+    n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print("number of parameters: %.2fM" % (n_parameters / 1e6,))
+
+    return model
+
+
+def build_cnnmlp(args):
+    state_dim = getattr(args, 'state_dim', 16)
+
+    backbones = []
+    for _ in args.camera_names:
+        backbone = build_backbone(args)
+        backbones.append(backbone)
+
+    model = CNNMLP(
+        backbones,
+        state_dim=state_dim,
+        camera_names=args.camera_names,
+    )
+
+    n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print("number of parameters: %.2fM" % (n_parameters / 1e6,))
+
+    return model

policy/EVA/detr/models/position_encoding.py

@@ -0,0 +1,98 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Various positional encodings for the transformer.
+"""
+import math
+import torch
+from torch import nn
+
+from util.misc import NestedTensor
+
+import IPython
+
+e = IPython.embed
+
+
+class PositionEmbeddingSine(nn.Module):
+    """
+    This is a more standard version of the position embedding, very similar to the one
+    used by the Attention is all you need paper, generalized to work on images.
+    """
+
+    def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):
+        super().__init__()
+        self.num_pos_feats = num_pos_feats
+        self.temperature = temperature
+        self.normalize = normalize
+        if scale is not None and normalize is False:
+            raise ValueError("normalize should be True if scale is passed")
+        if scale is None:
+            scale = 2 * math.pi
+        self.scale = scale
+
+    def forward(self, tensor):
+        x = tensor
+        # mask = tensor_list.mask
+        # assert mask is not None
+        # not_mask = ~mask
+
+        not_mask = torch.ones_like(x[0, [0]])
+        y_embed = not_mask.cumsum(1, dtype=torch.float32)
+        x_embed = not_mask.cumsum(2, dtype=torch.float32)
+        if self.normalize:
+            eps = 1e-6
+            y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
+            x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
+
+        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
+        dim_t = self.temperature**(2 * (dim_t // 2) / self.num_pos_feats)
+
+        pos_x = x_embed[:, :, :, None] / dim_t
+        pos_y = y_embed[:, :, :, None] / dim_t
+        pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3)
+        pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3)
+        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
+        return pos
+
+
+class PositionEmbeddingLearned(nn.Module):
+    """
+    Absolute pos embedding, learned.
+    """
+
+    def __init__(self, num_pos_feats=256):
+        super().__init__()
+        self.row_embed = nn.Embedding(50, num_pos_feats)
+        self.col_embed = nn.Embedding(50, num_pos_feats)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        nn.init.uniform_(self.row_embed.weight)
+        nn.init.uniform_(self.col_embed.weight)
+
+    def forward(self, tensor_list: NestedTensor):
+        x = tensor_list.tensors
+        h, w = x.shape[-2:]
+        i = torch.arange(w, device=x.device)
+        j = torch.arange(h, device=x.device)
+        x_emb = self.col_embed(i)
+        y_emb = self.row_embed(j)
+        pos = torch.cat([
+            x_emb.unsqueeze(0).repeat(h, 1, 1),
+            y_emb.unsqueeze(1).repeat(1, w, 1),
+        ], dim=-1).permute(2, 0, 1).unsqueeze(0).repeat(x.shape[0], 1, 1, 1)
+        return pos
+
+
+def build_position_encoding(args):
+    # print(args.keys())
+    N_steps = args.hidden_dim // 2
+    if args.position_embedding in ('v2', 'sine'):
+        # TODO find a better way of exposing other arguments
+        position_embedding = PositionEmbeddingSine(N_steps, normalize=True)
+    elif args.position_embedding in ('v3', 'learned'):
+        position_embedding = PositionEmbeddingLearned(N_steps)
+    else:
+        raise ValueError(f"not supported {args.position_embedding}")
+
+    return position_embedding

policy/EVA/detr/models/transformer.py

@@ -0,0 +1,347 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+DETR Transformer class.
+
+Copy-paste from torch.nn.Transformer with modifications:
+    * positional encodings are passed in MHattention
+    * extra LN at the end of encoder is removed
+    * decoder returns a stack of activations from all decoding layers
+"""
+import copy
+from typing import Optional, List
+
+import torch
+import torch.nn.functional as F
+from torch import nn, Tensor
+
+import IPython
+
+e = IPython.embed
+
+
+class Transformer(nn.Module):
+
+    def __init__(self,
+                 d_model=512,
+                 nhead=8,
+                 num_encoder_layers=6,
+                 num_decoder_layers=6,
+                 dim_feedforward=2048,
+                 dropout=0.1,
+                 activation="relu",
+                 normalize_before=False,
+                 return_intermediate_dec=False):
+        super().__init__()
+
+        encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout, activation, normalize_before)
+        encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
+        self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
+
+        decoder_layer = TransformerDecoderLayer(d_model, nhead, dim_feedforward, dropout, activation, normalize_before)
+        decoder_norm = nn.LayerNorm(d_model)
+        self.decoder = TransformerDecoder(decoder_layer,
+                                          num_decoder_layers,
+                                          decoder_norm,
+                                          return_intermediate=return_intermediate_dec)
+
+        self._reset_parameters()
+
+        self.d_model = d_model
+        self.nhead = nhead
+
+    def _reset_parameters(self):
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+
+    def forward(self,
+                src,
+                mask,
+                query_embed,
+                pos_embed,
+                latent_input=None,
+                proprio_input=None,
+                additional_pos_embed=None,
+                event_input=None):
+        # TODO flatten only when input has H and W
+        if len(src.shape) == 4:  # has H and W
+            # flatten NxCxHxW to HWxNxC
+            bs, c, h, w = src.shape
+            src = src.flatten(2).permute(2, 0, 1)
+            pos_embed = pos_embed.flatten(2).permute(2, 0, 1).repeat(1, bs, 1)
+            query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
+            # mask = mask.flatten(1)
+
+            # Build prefix tokens: [latent, proprio] or [latent, proprio, event]
+            prefix_tokens = [latent_input, proprio_input]
+            if event_input is not None:
+                prefix_tokens.append(event_input)
+            n_prefix = len(prefix_tokens)
+
+            # Slice pos embed to match prefix count
+            add_pos = additional_pos_embed[:n_prefix]
+            add_pos = add_pos.unsqueeze(1).repeat(1, bs, 1)  # [n_prefix, bs, dim]
+            pos_embed = torch.cat([add_pos, pos_embed], axis=0)
+
+            addition_input = torch.stack(prefix_tokens, axis=0)
+            src = torch.cat([addition_input, src], axis=0)
+        else:
+            assert len(src.shape) == 3
+            # flatten NxHWxC to HWxNxC
+            bs, hw, c = src.shape
+            src = src.permute(1, 0, 2)
+            pos_embed = pos_embed.unsqueeze(1).repeat(1, bs, 1)
+            query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
+
+        tgt = torch.zeros_like(query_embed)
+        memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)
+        hs = self.decoder(tgt, memory, memory_key_padding_mask=mask, pos=pos_embed, query_pos=query_embed)
+        hs = hs.transpose(1, 2)
+        return hs
+
+
+class TransformerEncoder(nn.Module):
+
+    def __init__(self, encoder_layer, num_layers, norm=None):
+        super().__init__()
+        self.layers = _get_clones(encoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+
+    def forward(self,
+                src,
+                mask: Optional[Tensor] = None,
+                src_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None):
+        output = src
+
+        for layer in self.layers:
+            output = layer(output, src_mask=mask, src_key_padding_mask=src_key_padding_mask, pos=pos)
+
+        if self.norm is not None:
+            output = self.norm(output)
+
+        return output
+
+
+class TransformerDecoder(nn.Module):
+
+    def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
+        super().__init__()
+        self.layers = _get_clones(decoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+        self.return_intermediate = return_intermediate
+
+    def forward(self,
+                tgt,
+                memory,
+                tgt_mask: Optional[Tensor] = None,
+                memory_mask: Optional[Tensor] = None,
+                tgt_key_padding_mask: Optional[Tensor] = None,
+                memory_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None):
+        output = tgt
+
+        intermediate = []
+
+        for layer in self.layers:
+            output = layer(output,
+                           memory,
+                           tgt_mask=tgt_mask,
+                           memory_mask=memory_mask,
+                           tgt_key_padding_mask=tgt_key_padding_mask,
+                           memory_key_padding_mask=memory_key_padding_mask,
+                           pos=pos,
+                           query_pos=query_pos)
+            if self.return_intermediate:
+                intermediate.append(self.norm(output))
+
+        if self.norm is not None:
+            output = self.norm(output)
+            if self.return_intermediate:
+                intermediate.pop()
+                intermediate.append(output)
+
+        if self.return_intermediate:
+            return torch.stack(intermediate)
+
+        return output.unsqueeze(0)
+
+
+class TransformerEncoderLayer(nn.Module):
+
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation="relu", normalize_before=False):
+        super().__init__()
+        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(self,
+                     src,
+                     src_mask: Optional[Tensor] = None,
+                     src_key_padding_mask: Optional[Tensor] = None,
+                     pos: Optional[Tensor] = None):
+        q = k = self.with_pos_embed(src, pos)
+        src2 = self.self_attn(q, k, value=src, attn_mask=src_mask, key_padding_mask=src_key_padding_mask)[0]
+        src = src + self.dropout1(src2)
+        src = self.norm1(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
+        src = src + self.dropout2(src2)
+        src = self.norm2(src)
+        return src
+
+    def forward_pre(self,
+                    src,
+                    src_mask: Optional[Tensor] = None,
+                    src_key_padding_mask: Optional[Tensor] = None,
+                    pos: Optional[Tensor] = None):
+        src2 = self.norm1(src)
+        q = k = self.with_pos_embed(src2, pos)
+        src2 = self.self_attn(q, k, value=src2, attn_mask=src_mask, key_padding_mask=src_key_padding_mask)[0]
+        src = src + self.dropout1(src2)
+        src2 = self.norm2(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))
+        src = src + self.dropout2(src2)
+        return src
+
+    def forward(self,
+                src,
+                src_mask: Optional[Tensor] = None,
+                src_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None):
+        if self.normalize_before:
+            return self.forward_pre(src, src_mask, src_key_padding_mask, pos)
+        return self.forward_post(src, src_mask, src_key_padding_mask, pos)
+
+
+class TransformerDecoderLayer(nn.Module):
+
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation="relu", normalize_before=False):
+        super().__init__()
+        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.norm3 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+        self.dropout3 = nn.Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(self,
+                     tgt,
+                     memory,
+                     tgt_mask: Optional[Tensor] = None,
+                     memory_mask: Optional[Tensor] = None,
+                     tgt_key_padding_mask: Optional[Tensor] = None,
+                     memory_key_padding_mask: Optional[Tensor] = None,
+                     pos: Optional[Tensor] = None,
+                     query_pos: Optional[Tensor] = None):
+        q = k = self.with_pos_embed(tgt, query_pos)
+        tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout1(tgt2)
+        tgt = self.norm1(tgt)
+        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos),
+                                   key=self.with_pos_embed(memory, pos),
+                                   value=memory,
+                                   attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask)[0]
+        tgt = tgt + self.dropout2(tgt2)
+        tgt = self.norm2(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
+        tgt = tgt + self.dropout3(tgt2)
+        tgt = self.norm3(tgt)
+        return tgt
+
+    def forward_pre(self,
+                    tgt,
+                    memory,
+                    tgt_mask: Optional[Tensor] = None,
+                    memory_mask: Optional[Tensor] = None,
+                    tgt_key_padding_mask: Optional[Tensor] = None,
+                    memory_key_padding_mask: Optional[Tensor] = None,
+                    pos: Optional[Tensor] = None,
+                    query_pos: Optional[Tensor] = None):
+        tgt2 = self.norm1(tgt)
+        q = k = self.with_pos_embed(tgt2, query_pos)
+        tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout1(tgt2)
+        tgt2 = self.norm2(tgt)
+        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos),
+                                   key=self.with_pos_embed(memory, pos),
+                                   value=memory,
+                                   attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask)[0]
+        tgt = tgt + self.dropout2(tgt2)
+        tgt2 = self.norm3(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
+        tgt = tgt + self.dropout3(tgt2)
+        return tgt
+
+    def forward(self,
+                tgt,
+                memory,
+                tgt_mask: Optional[Tensor] = None,
+                memory_mask: Optional[Tensor] = None,
+                tgt_key_padding_mask: Optional[Tensor] = None,
+                memory_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None):
+        if self.normalize_before:
+            return self.forward_pre(tgt, memory, tgt_mask, memory_mask, tgt_key_padding_mask, memory_key_padding_mask,
+                                    pos, query_pos)
+        return self.forward_post(tgt, memory, tgt_mask, memory_mask, tgt_key_padding_mask, memory_key_padding_mask, pos,
+                                 query_pos)
+
+
+def _get_clones(module, N):
+    return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
+
+
+def build_transformer(args):
+    return Transformer(
+        d_model=args.hidden_dim,
+        dropout=args.dropout,
+        nhead=args.nheads,
+        dim_feedforward=args.dim_feedforward,
+        num_encoder_layers=args.enc_layers,
+        num_decoder_layers=args.dec_layers,
+        normalize_before=args.pre_norm,
+        return_intermediate_dec=True,
+    )
+
+
+def _get_activation_fn(activation):
+    """Return an activation function given a string"""
+    if activation == "relu":
+        return F.relu
+    if activation == "gelu":
+        return F.gelu
+    if activation == "glu":
+        return F.glu
+    raise RuntimeError(F"activation should be relu/gelu, not {activation}.")

policy/EVA/detr/setup.py

@@ -0,0 +1,10 @@
+from distutils.core import setup
+from setuptools import find_packages
+
+setup(
+    name="detr",
+    version="0.0.0",
+    packages=find_packages(),
+    license="MIT License",
+    long_description=open("README.md").read(),
+)

policy/EVA/detr/util/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved

policy/EVA/detr/util/box_ops.py

@@ -0,0 +1,86 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Utilities for bounding box manipulation and GIoU.
+"""
+import torch
+from torchvision.ops.boxes import box_area
+
+
+def box_cxcywh_to_xyxy(x):
+    x_c, y_c, w, h = x.unbind(-1)
+    b = [(x_c - 0.5 * w), (y_c - 0.5 * h), (x_c + 0.5 * w), (y_c + 0.5 * h)]
+    return torch.stack(b, dim=-1)
+
+
+def box_xyxy_to_cxcywh(x):
+    x0, y0, x1, y1 = x.unbind(-1)
+    b = [(x0 + x1) / 2, (y0 + y1) / 2, (x1 - x0), (y1 - y0)]
+    return torch.stack(b, dim=-1)
+
+
+# modified from torchvision to also return the union
+def box_iou(boxes1, boxes2):
+    area1 = box_area(boxes1)
+    area2 = box_area(boxes2)
+
+    lt = torch.max(boxes1[:, None, :2], boxes2[:, :2])  # [N,M,2]
+    rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:])  # [N,M,2]
+
+    wh = (rb - lt).clamp(min=0)  # [N,M,2]
+    inter = wh[:, :, 0] * wh[:, :, 1]  # [N,M]
+
+    union = area1[:, None] + area2 - inter
+
+    iou = inter / union
+    return iou, union
+
+
+def generalized_box_iou(boxes1, boxes2):
+    """
+    Generalized IoU from https://giou.stanford.edu/
+
+    The boxes should be in [x0, y0, x1, y1] format
+
+    Returns a [N, M] pairwise matrix, where N = len(boxes1)
+    and M = len(boxes2)
+    """
+    # degenerate boxes gives inf / nan results
+    # so do an early check
+    assert (boxes1[:, 2:] >= boxes1[:, :2]).all()
+    assert (boxes2[:, 2:] >= boxes2[:, :2]).all()
+    iou, union = box_iou(boxes1, boxes2)
+
+    lt = torch.min(boxes1[:, None, :2], boxes2[:, :2])
+    rb = torch.max(boxes1[:, None, 2:], boxes2[:, 2:])
+
+    wh = (rb - lt).clamp(min=0)  # [N,M,2]
+    area = wh[:, :, 0] * wh[:, :, 1]
+
+    return iou - (area - union) / area
+
+
+def masks_to_boxes(masks):
+    """Compute the bounding boxes around the provided masks
+
+    The masks should be in format [N, H, W] where N is the number of masks, (H, W) are the spatial dimensions.
+
+    Returns a [N, 4] tensors, with the boxes in xyxy format
+    """
+    if masks.numel() == 0:
+        return torch.zeros((0, 4), device=masks.device)
+
+    h, w = masks.shape[-2:]
+
+    y = torch.arange(0, h, dtype=torch.float)
+    x = torch.arange(0, w, dtype=torch.float)
+    y, x = torch.meshgrid(y, x)
+
+    x_mask = masks * x.unsqueeze(0)
+    x_max = x_mask.flatten(1).max(-1)[0]
+    x_min = x_mask.masked_fill(~(masks.bool()), 1e8).flatten(1).min(-1)[0]
+
+    y_mask = masks * y.unsqueeze(0)
+    y_max = y_mask.flatten(1).max(-1)[0]
+    y_min = y_mask.masked_fill(~(masks.bool()), 1e8).flatten(1).min(-1)[0]
+
+    return torch.stack([x_min, y_min, x_max, y_max], 1)

policy/EVA/detr/util/misc.py

@@ -0,0 +1,481 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Misc functions, including distributed helpers.
+
+Mostly copy-paste from torchvision references.
+"""
+import os
+import subprocess
+import time
+from collections import defaultdict, deque
+import datetime
+import pickle
+from packaging import version
+from typing import Optional, List
+
+import torch
+import torch.distributed as dist
+from torch import Tensor
+
+# needed due to empty tensor bug in pytorch and torchvision 0.5
+import torchvision
+
+if version.parse(torchvision.__version__) < version.parse("0.7"):
+    from torchvision.ops import _new_empty_tensor
+    from torchvision.ops.misc import _output_size
+
+
+class SmoothedValue(object):
+    """Track a series of values and provide access to smoothed values over a
+    window or the global series average.
+    """
+
+    def __init__(self, window_size=20, fmt=None):
+        if fmt is None:
+            fmt = "{median:.4f} ({global_avg:.4f})"
+        self.deque = deque(maxlen=window_size)
+        self.total = 0.0
+        self.count = 0
+        self.fmt = fmt
+
+    def update(self, value, n=1):
+        self.deque.append(value)
+        self.count += n
+        self.total += value * n
+
+    def synchronize_between_processes(self):
+        """
+        Warning: does not synchronize the deque!
+        """
+        if not is_dist_avail_and_initialized():
+            return
+        t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda")
+        dist.barrier()
+        dist.all_reduce(t)
+        t = t.tolist()
+        self.count = int(t[0])
+        self.total = t[1]
+
+    @property
+    def median(self):
+        d = torch.tensor(list(self.deque))
+        return d.median().item()
+
+    @property
+    def avg(self):
+        d = torch.tensor(list(self.deque), dtype=torch.float32)
+        return d.mean().item()
+
+    @property
+    def global_avg(self):
+        return self.total / self.count
+
+    @property
+    def max(self):
+        return max(self.deque)
+
+    @property
+    def value(self):
+        return self.deque[-1]
+
+    def __str__(self):
+        return self.fmt.format(
+            median=self.median,
+            avg=self.avg,
+            global_avg=self.global_avg,
+            max=self.max,
+            value=self.value,
+        )
+
+
+def all_gather(data):
+    """
+    Run all_gather on arbitrary picklable data (not necessarily tensors)
+    Args:
+        data: any picklable object
+    Returns:
+        list[data]: list of data gathered from each rank
+    """
+    world_size = get_world_size()
+    if world_size == 1:
+        return [data]
+
+    # serialized to a Tensor
+    buffer = pickle.dumps(data)
+    storage = torch.ByteStorage.from_buffer(buffer)
+    tensor = torch.ByteTensor(storage).to("cuda")
+
+    # obtain Tensor size of each rank
+    local_size = torch.tensor([tensor.numel()], device="cuda")
+    size_list = [torch.tensor([0], device="cuda") for _ in range(world_size)]
+    dist.all_gather(size_list, local_size)
+    size_list = [int(size.item()) for size in size_list]
+    max_size = max(size_list)
+
+    # receiving Tensor from all ranks
+    # we pad the tensor because torch all_gather does not support
+    # gathering tensors of different shapes
+    tensor_list = []
+    for _ in size_list:
+        tensor_list.append(torch.empty((max_size, ), dtype=torch.uint8, device="cuda"))
+    if local_size != max_size:
+        padding = torch.empty(size=(max_size - local_size, ), dtype=torch.uint8, device="cuda")
+        tensor = torch.cat((tensor, padding), dim=0)
+    dist.all_gather(tensor_list, tensor)
+
+    data_list = []
+    for size, tensor in zip(size_list, tensor_list):
+        buffer = tensor.cpu().numpy().tobytes()[:size]
+        data_list.append(pickle.loads(buffer))
+
+    return data_list
+
+
+def reduce_dict(input_dict, average=True):
+    """
+    Args:
+        input_dict (dict): all the values will be reduced
+        average (bool): whether to do average or sum
+    Reduce the values in the dictionary from all processes so that all processes
+    have the averaged results. Returns a dict with the same fields as
+    input_dict, after reduction.
+    """
+    world_size = get_world_size()
+    if world_size < 2:
+        return input_dict
+    with torch.no_grad():
+        names = []
+        values = []
+        # sort the keys so that they are consistent across processes
+        for k in sorted(input_dict.keys()):
+            names.append(k)
+            values.append(input_dict[k])
+        values = torch.stack(values, dim=0)
+        dist.all_reduce(values)
+        if average:
+            values /= world_size
+        reduced_dict = {k: v for k, v in zip(names, values)}
+    return reduced_dict
+
+
+class MetricLogger(object):
+
+    def __init__(self, delimiter="\t"):
+        self.meters = defaultdict(SmoothedValue)
+        self.delimiter = delimiter
+
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if isinstance(v, torch.Tensor):
+                v = v.item()
+            assert isinstance(v, (float, int))
+            self.meters[k].update(v)
+
+    def __getattr__(self, attr):
+        if attr in self.meters:
+            return self.meters[attr]
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        raise AttributeError("'{}' object has no attribute '{}'".format(type(self).__name__, attr))
+
+    def __str__(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append("{}: {}".format(name, str(meter)))
+        return self.delimiter.join(loss_str)
+
+    def synchronize_between_processes(self):
+        for meter in self.meters.values():
+            meter.synchronize_between_processes()
+
+    def add_meter(self, name, meter):
+        self.meters[name] = meter
+
+    def log_every(self, iterable, print_freq, header=None):
+        i = 0
+        if not header:
+            header = ""
+        start_time = time.time()
+        end = time.time()
+        iter_time = SmoothedValue(fmt="{avg:.4f}")
+        data_time = SmoothedValue(fmt="{avg:.4f}")
+        space_fmt = ":" + str(len(str(len(iterable)))) + "d"
+        if torch.cuda.is_available():
+            log_msg = self.delimiter.join([
+                header,
+                "[{0" + space_fmt + "}/{1}]",
+                "eta: {eta}",
+                "{meters}",
+                "time: {time}",
+                "data: {data}",
+                "max mem: {memory:.0f}",
+            ])
+        else:
+            log_msg = self.delimiter.join([
+                header,
+                "[{0" + space_fmt + "}/{1}]",
+                "eta: {eta}",
+                "{meters}",
+                "time: {time}",
+                "data: {data}",
+            ])
+        MB = 1024.0 * 1024.0
+        for obj in iterable:
+            data_time.update(time.time() - end)
+            yield obj
+            iter_time.update(time.time() - end)
+            if i % print_freq == 0 or i == len(iterable) - 1:
+                eta_seconds = iter_time.global_avg * (len(iterable) - i)
+                eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
+                if torch.cuda.is_available():
+                    print(
+                        log_msg.format(
+                            i,
+                            len(iterable),
+                            eta=eta_string,
+                            meters=str(self),
+                            time=str(iter_time),
+                            data=str(data_time),
+                            memory=torch.cuda.max_memory_allocated() / MB,
+                        ))
+                else:
+                    print(
+                        log_msg.format(
+                            i,
+                            len(iterable),
+                            eta=eta_string,
+                            meters=str(self),
+                            time=str(iter_time),
+                            data=str(data_time),
+                        ))
+            i += 1
+            end = time.time()
+        total_time = time.time() - start_time
+        total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+        print("{} Total time: {} ({:.4f} s / it)".format(header, total_time_str, total_time / len(iterable)))
+
+
+def get_sha():
+    cwd = os.path.dirname(os.path.abspath(__file__))
+
+    def _run(command):
+        return subprocess.check_output(command, cwd=cwd).decode("ascii").strip()
+
+    sha = "N/A"
+    diff = "clean"
+    branch = "N/A"
+    try:
+        sha = _run(["git", "rev-parse", "HEAD"])
+        subprocess.check_output(["git", "diff"], cwd=cwd)
+        diff = _run(["git", "diff-index", "HEAD"])
+        diff = "has uncommited changes" if diff else "clean"
+        branch = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+    except Exception:
+        pass
+    message = f"sha: {sha}, status: {diff}, branch: {branch}"
+    return message
+
+
+def collate_fn(batch):
+    batch = list(zip(*batch))
+    batch[0] = nested_tensor_from_tensor_list(batch[0])
+    return tuple(batch)
+
+
+def _max_by_axis(the_list):
+    # type: (List[List[int]]) -> List[int]
+    maxes = the_list[0]
+    for sublist in the_list[1:]:
+        for index, item in enumerate(sublist):
+            maxes[index] = max(maxes[index], item)
+    return maxes
+
+
+class NestedTensor(object):
+
+    def __init__(self, tensors, mask: Optional[Tensor]):
+        self.tensors = tensors
+        self.mask = mask
+
+    def to(self, device):
+        # type: (Device) -> NestedTensor # noqa
+        cast_tensor = self.tensors.to(device)
+        mask = self.mask
+        if mask is not None:
+            assert mask is not None
+            cast_mask = mask.to(device)
+        else:
+            cast_mask = None
+        return NestedTensor(cast_tensor, cast_mask)
+
+    def decompose(self):
+        return self.tensors, self.mask
+
+    def __repr__(self):
+        return str(self.tensors)
+
+
+def nested_tensor_from_tensor_list(tensor_list: List[Tensor]):
+    # TODO make this more general
+    if tensor_list[0].ndim == 3:
+        if torchvision._is_tracing():
+            # nested_tensor_from_tensor_list() does not export well to ONNX
+            # call _onnx_nested_tensor_from_tensor_list() instead
+            return _onnx_nested_tensor_from_tensor_list(tensor_list)
+
+        # TODO make it support different-sized images
+        max_size = _max_by_axis([list(img.shape) for img in tensor_list])
+        # min_size = tuple(min(s) for s in zip(*[img.shape for img in tensor_list]))
+        batch_shape = [len(tensor_list)] + max_size
+        b, c, h, w = batch_shape
+        dtype = tensor_list[0].dtype
+        device = tensor_list[0].device
+        tensor = torch.zeros(batch_shape, dtype=dtype, device=device)
+        mask = torch.ones((b, h, w), dtype=torch.bool, device=device)
+        for img, pad_img, m in zip(tensor_list, tensor, mask):
+            pad_img[:img.shape[0], :img.shape[1], :img.shape[2]].copy_(img)
+            m[:img.shape[1], :img.shape[2]] = False
+    else:
+        raise ValueError("not supported")
+    return NestedTensor(tensor, mask)
+
+
+# _onnx_nested_tensor_from_tensor_list() is an implementation of
+# nested_tensor_from_tensor_list() that is supported by ONNX tracing.
+@torch.jit.unused
+def _onnx_nested_tensor_from_tensor_list(tensor_list: List[Tensor]) -> NestedTensor:
+    max_size = []
+    for i in range(tensor_list[0].dim()):
+        max_size_i = torch.max(torch.stack([img.shape[i] for img in tensor_list]).to(torch.float32)).to(torch.int64)
+        max_size.append(max_size_i)
+    max_size = tuple(max_size)
+
+    # work around for
+    # pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img)
+    # m[: img.shape[1], :img.shape[2]] = False
+    # which is not yet supported in onnx
+    padded_imgs = []
+    padded_masks = []
+    for img in tensor_list:
+        padding = [(s1 - s2) for s1, s2 in zip(max_size, tuple(img.shape))]
+        padded_img = torch.nn.functional.pad(img, (0, padding[2], 0, padding[1], 0, padding[0]))
+        padded_imgs.append(padded_img)
+
+        m = torch.zeros_like(img[0], dtype=torch.int, device=img.device)
+        padded_mask = torch.nn.functional.pad(m, (0, padding[2], 0, padding[1]), "constant", 1)
+        padded_masks.append(padded_mask.to(torch.bool))
+
+    tensor = torch.stack(padded_imgs)
+    mask = torch.stack(padded_masks)
+
+    return NestedTensor(tensor, mask=mask)
+
+
+def setup_for_distributed(is_master):
+    """
+    This function disables printing when not in master process
+    """
+    import builtins as __builtin__
+
+    builtin_print = __builtin__.print
+
+    def print(*args, **kwargs):
+        force = kwargs.pop("force", False)
+        if is_master or force:
+            builtin_print(*args, **kwargs)
+
+    __builtin__.print = print
+
+
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+
+def get_world_size():
+    if not is_dist_avail_and_initialized():
+        return 1
+    return dist.get_world_size()
+
+
+def get_rank():
+    if not is_dist_avail_and_initialized():
+        return 0
+    return dist.get_rank()
+
+
+def is_main_process():
+    return get_rank() == 0
+
+
+def save_on_master(*args, **kwargs):
+    if is_main_process():
+        torch.save(*args, **kwargs)
+
+
+def init_distributed_mode(args):
+    if "RANK" in os.environ and "WORLD_SIZE" in os.environ:
+        args.rank = int(os.environ["RANK"])
+        args.world_size = int(os.environ["WORLD_SIZE"])
+        args.gpu = int(os.environ["LOCAL_RANK"])
+    elif "SLURM_PROCID" in os.environ:
+        args.rank = int(os.environ["SLURM_PROCID"])
+        args.gpu = args.rank % torch.cuda.device_count()
+    else:
+        print("Not using distributed mode")
+        args.distributed = False
+        return
+
+    args.distributed = True
+
+    torch.cuda.set_device(args.gpu)
+    args.dist_backend = "nccl"
+    print("| distributed init (rank {}): {}".format(args.rank, args.dist_url), flush=True)
+    torch.distributed.init_process_group(
+        backend=args.dist_backend,
+        init_method=args.dist_url,
+        world_size=args.world_size,
+        rank=args.rank,
+    )
+    torch.distributed.barrier()
+    setup_for_distributed(args.rank == 0)
+
+
+@torch.no_grad()
+def accuracy(output, target, topk=(1, )):
+    """Computes the precision@k for the specified values of k"""
+    if target.numel() == 0:
+        return [torch.zeros([], device=output.device)]
+    maxk = max(topk)
+    batch_size = target.size(0)
+
+    _, pred = output.topk(maxk, 1, True, True)
+    pred = pred.t()
+    correct = pred.eq(target.view(1, -1).expand_as(pred))
+
+    res = []
+    for k in topk:
+        correct_k = correct[:k].view(-1).float().sum(0)
+        res.append(correct_k.mul_(100.0 / batch_size))
+    return res
+
+
+def interpolate(input, size=None, scale_factor=None, mode="nearest", align_corners=None):
+    # type: (Tensor, Optional[List[int]], Optional[float], str, Optional[bool]) -> Tensor
+    """
+    Equivalent to nn.functional.interpolate, but with support for empty batch sizes.
+    This will eventually be supported natively by PyTorch, and this
+    class can go away.
+    """
+    if version.parse(torchvision.__version__) < version.parse("0.7"):
+        if input.numel() > 0:
+            return torch.nn.functional.interpolate(input, size, scale_factor, mode, align_corners)
+
+        output_shape = _output_size(2, input, size, scale_factor)
+        output_shape = list(input.shape[:-2]) + list(output_shape)
+        return _new_empty_tensor(input, output_shape)
+    else:
+        return torchvision.ops.misc.interpolate(input, size, scale_factor, mode, align_corners)

policy/EVA/detr/util/plot_utils.py

@@ -0,0 +1,110 @@
+"""
+Plotting utilities to visualize training logs.
+"""
+
+import torch
+import pandas as pd
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+from pathlib import Path, PurePath
+
+
+def plot_logs(
+        logs,
+        fields=("class_error", "loss_bbox_unscaled", "mAP"),
+        ewm_col=0,
+        log_name="log.txt",
+):
+    """
+    Function to plot specific fields from training log(s). Plots both training and test results.
+
+    :: Inputs - logs = list containing Path objects, each pointing to individual dir with a log file
+              - fields = which results to plot from each log file - plots both training and test for each field.
+              - ewm_col = optional, which column to use as the exponential weighted smoothing of the plots
+              - log_name = optional, name of log file if different than default 'log.txt'.
+
+    :: Outputs - matplotlib plots of results in fields, color coded for each log file.
+               - solid lines are training results, dashed lines are test results.
+
+    """
+    func_name = "plot_utils.py::plot_logs"
+
+    # verify logs is a list of Paths (list[Paths]) or single Pathlib object Path,
+    # convert single Path to list to avoid 'not iterable' error
+
+    if not isinstance(logs, list):
+        if isinstance(logs, PurePath):
+            logs = [logs]
+            print(f"{func_name} info: logs param expects a list argument, converted to list[Path].")
+        else:
+            raise ValueError(f"{func_name} - invalid argument for logs parameter.\n \
+            Expect list[Path] or single Path obj, received {type(logs)}")
+
+    # Quality checks - verify valid dir(s), that every item in list is Path object, and that log_name exists in each dir
+    for i, dir in enumerate(logs):
+        if not isinstance(dir, PurePath):
+            raise ValueError(f"{func_name} - non-Path object in logs argument of {type(dir)}: \n{dir}")
+        if not dir.exists():
+            raise ValueError(f"{func_name} - invalid directory in logs argument:\n{dir}")
+        # verify log_name exists
+        fn = Path(dir / log_name)
+        if not fn.exists():
+            print(f"-> missing {log_name}.  Have you gotten to Epoch 1 in training?")
+            print(f"--> full path of missing log file: {fn}")
+            return
+
+    # load log file(s) and plot
+    dfs = [pd.read_json(Path(p) / log_name, lines=True) for p in logs]
+
+    fig, axs = plt.subplots(ncols=len(fields), figsize=(16, 5))
+
+    for df, color in zip(dfs, sns.color_palette(n_colors=len(logs))):
+        for j, field in enumerate(fields):
+            if field == "mAP":
+                coco_eval = (pd.DataFrame(np.stack(df.test_coco_eval_bbox.dropna().values)[:,
+                                                                                           1]).ewm(com=ewm_col).mean())
+                axs[j].plot(coco_eval, c=color)
+            else:
+                df.interpolate().ewm(com=ewm_col).mean().plot(
+                    y=[f"train_{field}", f"test_{field}"],
+                    ax=axs[j],
+                    color=[color] * 2,
+                    style=["-", "--"],
+                )
+    for ax, field in zip(axs, fields):
+        ax.legend([Path(p).name for p in logs])
+        ax.set_title(field)
+
+
+def plot_precision_recall(files, naming_scheme="iter"):
+    if naming_scheme == "exp_id":
+        # name becomes exp_id
+        names = [f.parts[-3] for f in files]
+    elif naming_scheme == "iter":
+        names = [f.stem for f in files]
+    else:
+        raise ValueError(f"not supported {naming_scheme}")
+    fig, axs = plt.subplots(ncols=2, figsize=(16, 5))
+    for f, color, name in zip(files, sns.color_palette("Blues", n_colors=len(files)), names):
+        data = torch.load(f)
+        # precision is n_iou, n_points, n_cat, n_area, max_det
+        precision = data["precision"]
+        recall = data["params"].recThrs
+        scores = data["scores"]
+        # take precision for all classes, all areas and 100 detections
+        precision = precision[0, :, :, 0, -1].mean(1)
+        scores = scores[0, :, :, 0, -1].mean(1)
+        prec = precision.mean()
+        rec = data["recall"][0, :, 0, -1].mean()
+        print(f"{naming_scheme} {name}: mAP@50={prec * 100: 05.1f}, " + f"score={scores.mean():0.3f}, " +
+              f"f1={2 * prec * rec / (prec + rec + 1e-8):0.3f}")
+        axs[0].plot(recall, precision, c=color)
+        axs[1].plot(recall, scores, c=color)
+
+    axs[0].set_title("Precision / Recall")
+    axs[0].legend(names)
+    axs[1].set_title("Scores / Recall")
+    axs[1].legend(names)
+    return fig, axs

policy/EVA/eva_policy.py

@@ -0,0 +1,127 @@
+"""
+EVA Policy: Event-driven Visual-tactile ACT.
+
+Differences from ACTPolicy:
+  - Owns a TactileEventDetector that encodes [B, 2, 5, 4, 4, 3] → event_token
+  - Passes event_token into DETRVAE as an extra encoder input token
+  - Adds auxiliary cross-entropy loss (event classification vs rule-based labels)
+"""
+
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+import torchvision.transforms as transforms
+
+try:
+    from detr.main import build_EVA_model_and_optimizer
+except ImportError:
+    from .detr.main import build_EVA_model_and_optimizer
+
+from .tactile_event import TactileEventDetector, tactile_event_loss
+
+
+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 EVAPolicy(nn.Module):
+    """
+    EVA = ACT + TactileEventDetector.
+
+    Forward signature:
+        Training:  policy(qpos, image, tactile, actions, is_pad, event_labels)
+        Inference: policy(qpos, image, tactile)
+    """
+
+    def __init__(self, args_override, RoboTwin_Config=None):
+        super().__init__()
+        model, optimizer = build_EVA_model_and_optimizer(args_override, RoboTwin_Config)
+        self.model = model  # CVAE decoder (DETRVAE)
+        self.optimizer = optimizer
+        self.kl_weight = args_override["kl_weight"]
+        self.event_weight = args_override.get("event_weight", 0.1)
+
+        hidden_dim = args_override.get("hidden_dim", 256)
+        self.tactile_detector = TactileEventDetector(hidden_dim=hidden_dim)
+        self.tactile_detector.cuda()
+
+        # Add tactile detector params to optimizer
+        self.optimizer.add_param_group({
+            "params": self.tactile_detector.parameters(),
+            "lr": args_override.get("lr", 1e-4),
+        })
+
+        print(f"EVA Policy | KL weight: {self.kl_weight}, Event weight: {self.event_weight}")
+        n_tactile = sum(p.numel() for p in self.tactile_detector.parameters())
+        print(f"TactileEventDetector parameters: {n_tactile / 1e3:.1f}K")
+
+    def __call__(self, qpos, image, tactile, actions=None, is_pad=None, event_labels=None):
+        """
+        Args:
+            qpos:         [B, state_dim]
+            image:        [B, num_cam, C, H, W]
+            tactile:      [B, 2, 5, 4, 4, 3]
+            actions:      [B, seq, action_dim] or None (inference)
+            is_pad:       [B, seq] or None
+            event_labels: [B] int64 or None (rule-based labels for aux loss)
+
+        Returns:
+            Training: loss_dict with keys {l1, kl, event, loss}
+            Inference: a_hat [B, num_queries, action_dim]
+        """
+        env_state = None
+        normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        image = normalize(image)
+
+        # Encode tactile → event token
+        event_token, event_logits = self.tactile_detector(tactile)
+
+        if actions is not None:  # training
+            actions = actions[:, :self.model.num_queries]
+            is_pad = is_pad[:, :self.model.num_queries]
+
+            a_hat, is_pad_hat, (mu, logvar) = self.model(
+                qpos, image, env_state, actions, is_pad, event_token=event_token
+            )
+
+            total_kld, dim_wise_kld, mean_kld = kl_divergence(mu, logvar)
+
+            loss_dict = dict()
+            all_l1 = F.l1_loss(actions, a_hat, reduction="none")
+            l1 = (all_l1 * ~is_pad.unsqueeze(-1)).mean()
+            loss_dict["l1"] = l1
+            loss_dict["kl"] = total_kld[0]
+
+            # Auxiliary event classification loss
+            if event_labels is not None:
+                event_loss = tactile_event_loss(event_logits, event_labels)
+            else:
+                event_loss = torch.tensor(0.0, device=qpos.device)
+            loss_dict["event"] = event_loss
+
+            loss_dict["loss"] = (
+                loss_dict["l1"]
+                + loss_dict["kl"] * self.kl_weight
+                + loss_dict["event"] * self.event_weight
+            )
+            return loss_dict
+        else:  # inference
+            a_hat, _, (_, _) = self.model(
+                qpos, image, env_state, event_token=event_token
+            )
+            return a_hat
+
+    def configure_optimizers(self):
+        return self.optimizer

policy/EVA/imitate_episodes.py

@@ -0,0 +1,240 @@
+"""
+EVA training script. Based on ACT's imitate_episodes.py.
+
+Usage:
+    python imitate_episodes.py                         # use train_config.yaml defaults
+    python imitate_episodes.py --task peg_insertion     # shorthand
+    python imitate_episodes.py --eval                   # evaluate best checkpoint
+"""
+
+import os
+
+os.environ["MUJOCO_GL"] = "egl"
+
+import torch
+import numpy as np
+import pickle
+import argparse
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from copy import deepcopy
+from tqdm import tqdm
+
+from constants import DT, SIM_TASK_CONFIGS
+from utils import load_data, compute_dict_mean, set_seed, detach_dict
+from eva_policy import EVAPolicy
+
+
+def main(args):
+    set_seed(1)
+
+    is_eval = args["eval"]
+    ckpt_dir = args["ckpt_dir"]
+    task_name = args["task_name"]
+    batch_size_train = args["batch_size"]
+    batch_size_val = args["batch_size"]
+    num_epochs = args["num_epochs"]
+
+    # Task config
+    task_config = SIM_TASK_CONFIGS[task_name]
+    dataset_dir = task_config["dataset_dir"]
+    num_episodes = task_config["num_episodes"]
+    episode_len = task_config["episode_len"]
+    camera_names = task_config["camera_names"]
+
+    # Model config
+    state_dim = args["state_dim"]
+    policy_config = {
+        "lr": args["lr"],
+        "num_queries": args["chunk_size"],
+        "kl_weight": args["kl_weight"],
+        "event_weight": args.get("event_weight", 0.1),
+        "hidden_dim": args["hidden_dim"],
+        "dim_feedforward": args["dim_feedforward"],
+        "lr_backbone": 1e-5,
+        "backbone": "resnet18",
+        "enc_layers": 4,
+        "dec_layers": 7,
+        "nheads": 8,
+        "camera_names": camera_names,
+        "state_dim": state_dim,
+        "chunk_size": args["chunk_size"],
+    }
+
+    config = {
+        "num_epochs": num_epochs,
+        "ckpt_dir": ckpt_dir,
+        "episode_len": episode_len,
+        "state_dim": state_dim,
+        "lr": args["lr"],
+        "policy_config": policy_config,
+        "task_name": task_name,
+        "seed": args["seed"],
+        "temporal_agg": args.get("temporal_agg", False),
+        "camera_names": camera_names,
+        "save_freq": args["save_freq"],
+    }
+
+    if is_eval:
+        ckpt_name = "policy_best.ckpt"
+        print(f"Evaluating {ckpt_name}...")
+        # TODO: implement eval loop for EVA
+        print("EVA eval not yet implemented — use ACT eval with tactile wrapper")
+        return
+
+    train_dataloader, val_dataloader, stats, _ = load_data(
+        dataset_dir, num_episodes, camera_names, batch_size_train, batch_size_val
+    )
+
+    # Save dataset stats
+    os.makedirs(ckpt_dir, exist_ok=True)
+    stats_path = os.path.join(ckpt_dir, "dataset_stats.pkl")
+    with open(stats_path, "wb") as f:
+        pickle.dump(stats, f)
+
+    best_ckpt_info = train_bc(train_dataloader, val_dataloader, config)
+    best_epoch, min_val_loss, best_state_dict = best_ckpt_info
+
+    ckpt_path = os.path.join(ckpt_dir, "policy_best.ckpt")
+    torch.save(best_state_dict, ckpt_path)
+    print(f"Best ckpt, val loss {min_val_loss:.6f} @ epoch {best_epoch}")
+
+
+def forward_pass(data, policy):
+    """EVA forward pass: unpack 6-tuple (includes tactile + event_labels)."""
+    image_data, qpos_data, action_data, is_pad, tactile_data, event_labels = data
+    image_data = image_data.cuda()
+    qpos_data = qpos_data.cuda()
+    action_data = action_data.cuda()
+    is_pad = is_pad.cuda()
+    tactile_data = tactile_data.cuda()
+    event_labels = event_labels.cuda()
+    return policy(qpos_data, image_data, tactile_data, action_data, is_pad, event_labels)
+
+
+def train_bc(train_dataloader, val_dataloader, config):
+    num_epochs = config["num_epochs"]
+    ckpt_dir = config["ckpt_dir"]
+    seed = config["seed"]
+    policy_config = config["policy_config"]
+
+    set_seed(seed)
+
+    policy = EVAPolicy(policy_config)
+    policy.cuda()
+    optimizer = policy.configure_optimizers()
+
+    train_history = []
+    validation_history = []
+    min_val_loss = np.inf
+    best_ckpt_info = None
+
+    for epoch in tqdm(range(num_epochs)):
+        print(f"\nEpoch {epoch}")
+
+        # Validation
+        with torch.inference_mode():
+            policy.eval()
+            epoch_dicts = []
+            for batch_idx, data in enumerate(val_dataloader):
+                forward_dict = forward_pass(data, policy)
+                epoch_dicts.append(forward_dict)
+            epoch_summary = compute_dict_mean(epoch_dicts)
+            validation_history.append(epoch_summary)
+
+            epoch_val_loss = epoch_summary["loss"]
+            if epoch_val_loss < min_val_loss:
+                min_val_loss = epoch_val_loss
+                best_ckpt_info = (epoch, min_val_loss, deepcopy(policy.state_dict()))
+
+        summary_str = " | ".join(f"{k}: {v.item():.4f}" for k, v in epoch_summary.items())
+        print(f"Val: {summary_str}")
+
+        # Training
+        policy.train()
+        optimizer.zero_grad()
+        for batch_idx, data in enumerate(train_dataloader):
+            forward_dict = forward_pass(data, policy)
+            loss = forward_dict["loss"]
+            loss.backward()
+            optimizer.step()
+            optimizer.zero_grad()
+            train_history.append(detach_dict(forward_dict))
+
+        epoch_summary = compute_dict_mean(
+            train_history[(batch_idx + 1) * epoch:(batch_idx + 1) * (epoch + 1)]
+        )
+        epoch_train_loss = epoch_summary["loss"]
+        summary_str = " | ".join(f"{k}: {v.item():.4f}" for k, v in epoch_summary.items())
+        print(f"Train: {summary_str}")
+
+        if (epoch + 1) % config["save_freq"] == 0:
+            ckpt_path = os.path.join(ckpt_dir, f"policy_epoch_{epoch + 1}_seed_{seed}.ckpt")
+            torch.save(policy.state_dict(), ckpt_path)
+            plot_history(train_history, validation_history, epoch, ckpt_dir, seed)
+
+    ckpt_path = os.path.join(ckpt_dir, "policy_last.ckpt")
+    torch.save(policy.state_dict(), ckpt_path)
+
+    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: seed {seed}, val loss {min_val_loss:.6f} at epoch {best_epoch}")
+
+    plot_history(train_history, validation_history, num_epochs, ckpt_dir, seed)
+    return best_ckpt_info
+
+
+def plot_history(train_history, validation_history, num_epochs, ckpt_dir, seed):
+    for key in train_history[0]:
+        plot_path = os.path.join(ckpt_dir, f"train_val_{key}_seed_{seed}.png")
+        plt.figure()
+        train_values = [s[key].item() for s in train_history]
+        val_values = [s[key].item() for s 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.tight_layout()
+        plt.legend()
+        plt.title(key)
+        plt.savefig(plot_path)
+        plt.close()
+    print(f"Saved plots to {ckpt_dir}")
+
+
+if __name__ == "__main__":
+    import yaml
+
+    config_path = os.path.join(os.path.dirname(__file__), "train_config.yaml")
+    with open(config_path, "r") as f:
+        args = yaml.safe_load(f)
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task", type=str, default=None)
+    parser.add_argument("--eval", action="store_true")
+    parser.add_argument("--ckpt_dir", type=str, default=None)
+    parser.add_argument("--task_name", type=str, default=None)
+    parser.add_argument("--batch_size", type=int, default=None)
+    parser.add_argument("--seed", type=int, default=None)
+    parser.add_argument("--num_epochs", type=int, default=None)
+    parser.add_argument("--lr", type=float, default=None)
+    parser.add_argument("--kl_weight", type=float, default=None)
+    parser.add_argument("--event_weight", type=float, default=None)
+    parser.add_argument("--chunk_size", type=int, default=None)
+    parser.add_argument("--hidden_dim", type=int, default=None)
+    parser.add_argument("--state_dim", type=int, default=None)
+    parser.add_argument("--save_freq", type=int, default=None)
+    parser.add_argument("--dim_feedforward", type=int, default=None)
+    parser.add_argument("--temporal_agg", action="store_true")
+
+    for k, v in vars(parser.parse_args()).items():
+        if v is not None and v is not False:
+            args[k] = v
+
+    if args.get("task"):
+        task = args.pop("task")
+        args["task_name"] = f"sim-{task}-default-50"
+        args["ckpt_dir"] = f"./checkpoints/{task}_eva"
+
+    main(args)

policy/EVA/process_data.py

@@ -0,0 +1,148 @@
+"""
+Process raw tactile_data/ HDF5 into EVA-compatible format.
+
+Raw format (from collect_data.py):
+    actions:           [T, 7]    float64   (OSC_POSE delta commands)
+    agentview_image:   [T, 256, 256, 3] uint8
+    eye_in_hand_image: [T, 256, 256, 3] uint8
+    joint_pos:         [T, 7]    float64
+    gripper_qpos:      [T, 6]    float64
+    eef_pos:           [T, 3]    float64
+    eef_quat:          [T, 4]    float64
+    tactile_left:      [T*5, 4, 4, 3] float64  (100Hz)
+    tactile_right:     [T*5, 4, 4, 3] float64
+    rewards:           [T]
+    success:           [T]
+
+EVA processed format (ACT-compatible + tactile):
+    action:                        [T, 8]  float32   (7 joint + 1 gripper)
+    observations/qpos:             [T, 8]  float32
+    observations/images/agentview: [T, 256, 256, 3] uint8
+    observations/images/eye_in_hand: [T, 256, 256, 3] uint8
+    observations/tactile:          [T, 2, 5, 4, 4, 3] float32  (per-step tactile window)
+    observations/event_labels:     [T] int64  (rule-based event class)
+    attrs: sim=True
+"""
+
+import os
+import sys
+import h5py
+import json
+import numpy as np
+import argparse
+from glob import glob
+
+sys.path.insert(0, os.path.dirname(__file__))
+from tactile_event import label_tactile_events
+
+
+def process_episode(raw_path, save_path):
+    """Convert one raw episode to EVA format."""
+    with h5py.File(raw_path, 'r') as raw:
+        T = raw['actions'].shape[0]
+        actions_raw = raw['actions'][:]             # [T, 7]
+        joint_pos = raw['joint_pos'][:]             # [T, 7]
+        gripper_qpos = raw['gripper_qpos'][:]       # [T, 6]
+        agentview = raw['agentview_image'][:]       # [T, 256, 256, 3]
+        eye_in_hand = raw['eye_in_hand_image'][:]   # [T, 256, 256, 3]
+        tl = raw['tactile_left'][:]                 # [T*5, 4, 4, 3]
+        tr = raw['tactile_right'][:]
+
+    # qpos: 7 joint angles + 1 gripper (first joint of gripper_qpos)
+    gripper_state = gripper_qpos[:, 0:1]  # [T, 1]
+    qpos = np.concatenate([joint_pos, gripper_state], axis=1).astype(np.float32)  # [T, 8]
+
+    # action: same as qpos (next-step joint target), following ACT convention
+    # Use qpos[1:] as action for qpos[:-1], pad last with repeat
+    action = np.zeros_like(qpos)
+    action[:-1] = qpos[1:]
+    action[-1] = qpos[-1]
+
+    # Tactile window: for each control step t, take 5 tactile frames [t*5 : t*5+5]
+    T_tac = len(tl)
+    window = 5
+    assert T_tac == T * window, f"Tactile length {T_tac} != {T}*{window}"
+
+    tactile = np.zeros((T, 2, window, 4, 4, 3), dtype=np.float32)
+    for t in range(T):
+        s = t * window
+        tactile[t, 0] = tl[s:s+window]
+        tactile[t, 1] = tr[s:s+window]
+
+    # Event labels (rule-based)
+    event_labels = label_tactile_events(tl, tr, window=window)
+    assert len(event_labels) == T
+
+    # Save in ACT-compatible format
+    with h5py.File(save_path, 'w') as f:
+        f.attrs['sim'] = True
+        f.create_dataset('action', data=action)
+        obs = f.create_group('observations')
+        obs.create_dataset('qpos', data=qpos)
+        imgs = obs.create_group('images')
+        imgs.create_dataset('agentview', data=agentview)
+        imgs.create_dataset('eye_in_hand', data=eye_in_hand)
+        obs.create_dataset('tactile', data=tactile)
+        obs.create_dataset('event_labels', data=event_labels)
+
+    return T
+
+
+def process_task(task_name, max_episodes=None):
+    """Process all episodes for a task."""
+    raw_dir = os.path.join(os.path.dirname(__file__), '..', '..', 'tactile_data', task_name)
+    raw_dir = os.path.abspath(raw_dir)
+    raw_files = sorted(glob(os.path.join(raw_dir, 'episode_*.hdf5')))
+
+    if not raw_files:
+        print(f"No episodes found in {raw_dir}")
+        return
+
+    if max_episodes:
+        raw_files = raw_files[:max_episodes]
+
+    n_episodes = len(raw_files)
+    save_dir = os.path.join(os.path.dirname(__file__), 'processed_data', f'sim-{task_name}', f'default-{n_episodes}')
+    os.makedirs(save_dir, exist_ok=True)
+
+    episode_lens = []
+    for i, raw_path in enumerate(raw_files):
+        save_path = os.path.join(save_dir, f'episode_{i}.hdf5')
+        T = process_episode(raw_path, save_path)
+        episode_lens.append(T)
+        print(f"  [{i+1}/{n_episodes}] {os.path.basename(raw_path)} → {T} steps")
+
+    max_len = max(episode_lens)
+    median_len = sorted(episode_lens)[len(episode_lens) // 2]
+
+    # Update SIM_TASK_CONFIGS.json
+    config_path = os.path.join(os.path.dirname(__file__), 'SIM_TASK_CONFIGS.json')
+    try:
+        with open(config_path, 'r') as f:
+            configs = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        configs = {}
+
+    config_key = f"sim-{task_name}-default-{n_episodes}"
+    configs[config_key] = {
+        "dataset_dir": f"./processed_data/sim-{task_name}/default-{n_episodes}",
+        "num_episodes": n_episodes,
+        "episode_len": max_len,
+        "camera_names": ["agentview", "eye_in_hand"],
+    }
+
+    with open(config_path, 'w') as f:
+        json.dump(configs, f, indent=4)
+
+    print(f"\nProcessed {n_episodes} episodes → {save_dir}")
+    print(f"Episode lengths: {min(episode_lens)}-{max_len} (median {median_len})")
+    print(f"Config key: {config_key}")
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Process tactile data for EVA training')
+    parser.add_argument('task_name', type=str, help='Task name (e.g., peg_insertion)')
+    parser.add_argument('--max_episodes', type=int, default=None, help='Max episodes to process')
+    args = parser.parse_args()
+
+    process_task(args.task_name, args.max_episodes)

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_10.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:754f35d7f400e34c7cff6f07ad68e2a7283f479c7b145c4e4940abf40e3e4111
+size 183777864

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_13.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d75e048c50c79229c63d49f161d7abe91431e88509b30d56f5e3677a0fb3a07
+size 192472440

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_18.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:08f3b651840b910dd1d7f0d0ff9cf2e4ecf99bc64f163e49a42ee01d426024c9
+size 192867648

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_20.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a80b7498f4cb7bd496bc851095f0bf05b276d39406074866aaa5918b7183a33e
+size 187334736

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_33.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c52e8a0f7c79ea527049f871a3d43669b1c4446c062b30c36064e8b76008a982
+size 192867648

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_35.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a0a78369d6db3696b0b78ad7895896d69af3c4b479523a8fa7e4a47d97be86c
+size 185358696

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_36.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c5b3f1d73f894c5466594d711925fc16d5284c9a06483a895ad2372f1f0a421
+size 186939528

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_37.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b64437d7df940a370ea6abed257c8293318b62c9118b3a3e108ff23b5214b258
+size 191286816

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_39.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:349634a5f2aea7f8718d037259e708115a315d5d28fcb4f6ca8610a5fe0e6d3a
+size 188520360

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_41.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5b2b03a8960d1da28f136bcd591b09e4eb7b62dc08603f12722ad241f7fc6a5
+size 186149112

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_48.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fcdd231af21c9a0510d3e4bcad923eb083a4d7366fe1177dcbd472a9e2d8978a
+size 189310776

policy/EVA/processed_data/sim-peg_insertion/default-50/episode_5.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc39566a0181b9d309f15b52c51f1d95c181371ba25e1715f96fba6f9a33b448
+size 195634104

policy/EVA/tactile_event.py

@@ -0,0 +1,178 @@
+"""
+Tactile Event Detection for EVA (Event-driven Visual-tactile ACT).
+
+Two components:
+1. Auto event labeling (rule-based, no grad) — produces training labels
+2. TactileEventDetector (learned) — produces soft event embeddings for the transformer
+
+Event classes:
+  0 = no_contact    : both fingers below force threshold
+  1 = initial_contact: force crosses threshold (rising edge within window)
+  2 = stuck          : sustained high force + high asymmetry, low jerk
+  3 = slip           : tangential jerk spike (sudden lateral force change)
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+
+# ---------------------------------------------------------------------------
+# 1. Rule-based auto labeling (numpy, offline)
+# ---------------------------------------------------------------------------
+
+def label_tactile_events(
+    tactile_left: np.ndarray,
+    tactile_right: np.ndarray,
+    contact_thresh: float = 0.3,
+    stuck_force_thresh: float = 1.0,
+    stuck_asym_thresh: float = 0.3,
+    slip_jerk_thresh: float = 0.8,
+    window: int = 5,
+) -> np.ndarray:
+    """
+    Label each control-rate timestep with a contact event class.
+
+    Args:
+        tactile_left:  [T_tactile, 4, 4, 3]  (100Hz)
+        tactile_right: [T_tactile, 4, 4, 3]
+        window: number of tactile frames per control step (5 for 100Hz/20Hz)
+
+    Returns:
+        labels: [T_control] int array, values in {0,1,2,3}
+    """
+    T = len(tactile_left)
+    n_steps = T // window
+
+    # Per-frame scalar features
+    normal_l = np.abs(tactile_left[..., 2]).mean(axis=(-1, -2))   # [T]
+    normal_r = np.abs(tactile_right[..., 2]).mean(axis=(-1, -2))
+    normal_mean = (normal_l + normal_r) / 2
+    asymmetry = np.abs(normal_l - normal_r)
+
+    tangent_l = tactile_left[..., :2].reshape(T, -1)
+    tangent_r = tactile_right[..., :2].reshape(T, -1)
+    tangent = np.concatenate([tangent_l, tangent_r], axis=-1)
+    jerk = np.linalg.norm(np.diff(tangent, axis=0, prepend=tangent[:1]), axis=-1)
+
+    labels = np.zeros(n_steps, dtype=np.int64)
+
+    for i in range(n_steps):
+        s, e = i * window, (i + 1) * window
+        win_force = normal_mean[s:e]
+        win_asym = asymmetry[s:e]
+        win_jerk = jerk[s:e]
+
+        max_force = win_force.max()
+        max_jerk = win_jerk.max()
+        mean_asym = win_asym.mean()
+
+        # Check previous window for rising-edge detection
+        if i > 0:
+            prev_s = (i - 1) * window
+            prev_force = normal_mean[prev_s:s].max()
+        else:
+            prev_force = 0.0
+
+        if max_force < contact_thresh:
+            labels[i] = 0  # no_contact
+        elif prev_force < contact_thresh and max_force >= contact_thresh:
+            labels[i] = 1  # initial_contact (rising edge)
+        elif max_jerk > slip_jerk_thresh:
+            labels[i] = 3  # slip
+        elif max_force > stuck_force_thresh and mean_asym > stuck_asym_thresh:
+            labels[i] = 2  # stuck
+        else:
+            # In contact but no special event — default to no_contact
+            # (could also be a "stable grasp" class, but we keep 4 classes)
+            labels[i] = 0
+
+    return labels
+
+
+# ---------------------------------------------------------------------------
+# 2. TactileEventDetector (learned, differentiable)
+# ---------------------------------------------------------------------------
+
+class TactileEventDetector(nn.Module):
+    """
+    Encodes a tactile window into a single event embedding vector.
+
+    Input:  [B, 2, 5, 4, 4, 3]  (batch, fingers, frames, rows, cols, xyz)
+    Output:
+        event_embedding: [B, hidden_dim]   — injected into ACT transformer
+        event_logits:    [B, 4]            — supervised by rule-based labels
+    """
+
+    NUM_CLASSES = 4
+
+    def __init__(self, hidden_dim: int = 256, num_frames: int = 5):
+        super().__init__()
+        self.hidden_dim = hidden_dim
+
+        # Per-finger spatial encoder: 4x4 grid x 3 channels → feature vector
+        # Flatten grid: 4*4*3 = 48 per frame per finger
+        input_per_frame = 2 * 48  # both fingers concatenated
+
+        # Temporal 1D conv over frames
+        self.temporal_encoder = nn.Sequential(
+            nn.Conv1d(input_per_frame, 128, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv1d(128, hidden_dim, kernel_size=3, padding=1),
+            nn.ReLU(),
+        )
+
+        # Pool over time → single vector
+        self.pool = nn.AdaptiveAvgPool1d(1)
+
+        # Project to event embedding + classification head
+        self.event_proj = nn.Linear(hidden_dim, hidden_dim)
+        self.event_classifier = nn.Linear(hidden_dim, self.NUM_CLASSES)
+
+        self._init_weights()
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, (nn.Linear, nn.Conv1d)):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+
+    def forward(self, tactile):
+        """
+        Args:
+            tactile: [B, 2, 5, 4, 4, 3]
+
+        Returns:
+            event_embedding: [B, hidden_dim]
+            event_logits:    [B, NUM_CLASSES]
+        """
+        B, F, T, H, W, C = tactile.shape  # F=2 fingers, T=5 frames
+        # Flatten spatial dims per finger per frame: [B, T, 2*48]
+        x = tactile.reshape(B, F, T, H * W * C)       # [B, 2, 5, 48]
+        x = x.permute(0, 2, 1, 3).reshape(B, T, -1)   # [B, 5, 96]
+
+        # Conv1d expects [B, C, T]
+        x = x.permute(0, 2, 1)                         # [B, 96, 5]
+        x = self.temporal_encoder(x)                    # [B, hidden_dim, 5]
+        x = self.pool(x).squeeze(-1)                   # [B, hidden_dim]
+
+        event_embedding = self.event_proj(x)            # [B, hidden_dim]
+        event_logits = self.event_classifier(x)         # [B, 4]
+
+        return event_embedding, event_logits
+
+
+def tactile_event_loss(event_logits, event_labels):
+    """
+    Auxiliary cross-entropy loss for event classification.
+
+    Args:
+        event_logits: [B, 4] from TactileEventDetector
+        event_labels: [B] int64 from rule-based labeling
+
+    Returns:
+        scalar loss
+    """
+    return F.cross_entropy(event_logits, event_labels)

policy/EVA/train_all.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+set -e
+cd "$(dirname "$0")"
+
+# Step 1: Process data for all tasks
+echo "========== Processing data =========="
+for task in peg_insertion gentle_stack precision_grasp; do
+    echo "--- $task ---"
+    python process_data.py $task
+done
+
+# Step 2: Train EVA on each task
+echo ""
+echo "========== Training EVA =========="
+for task in peg_insertion gentle_stack precision_grasp; do
+    echo ""
+    echo "====== Training $task ======"
+    python imitate_episodes.py --task $task
+done
+
+echo ""
+echo "========== All done =========="

policy/EVA/train_config.yaml

@@ -0,0 +1,25 @@
+# EVA Training Config
+# Usage: cd policy/EVA && python imitate_episodes.py [--task peg_insertion]
+
+# Task (override with --task)
+task_name: sim-peg_insertion-default-50
+ckpt_dir: ./checkpoints/peg_insertion_eva
+
+# Model
+state_dim: 8
+hidden_dim: 256
+dim_feedforward: 2048
+chunk_size: 20
+kl_weight: 10
+event_weight: 0.1
+
+# Training
+batch_size: 128
+lr: 1.0e-4
+num_epochs: 3000
+seed: 1
+save_freq: 500
+temporal_agg: false
+
+# Eval
+eval: false

policy/EVA/utils.py

@@ -0,0 +1,185 @@
+"""
+Data loading utilities for EVA.
+Extends ACT's EpisodicDataset with tactile data and event labels.
+"""
+
+import numpy as np
+import torch
+import os
+import h5py
+from torch.utils.data import DataLoader
+
+
+class EVAEpisodicDataset(torch.utils.data.Dataset):
+    """
+    Dataset that returns (image, qpos, action, is_pad, tactile, event_label) tuples.
+    Tactile: [2, 5, 4, 4, 3] per timestep.
+    Event label: int64 scalar per timestep.
+    """
+
+    def __init__(self, episode_ids, dataset_dir, camera_names, norm_stats, max_action_len):
+        super().__init__()
+        self.episode_ids = episode_ids
+        self.dataset_dir = dataset_dir
+        self.camera_names = camera_names
+        self.norm_stats = norm_stats
+        self.max_action_len = max_action_len
+        self.is_sim = None
+        self.__getitem__(0)  # initialize self.is_sim
+
+    def __len__(self):
+        return len(self.episode_ids)
+
+    def __getitem__(self, index):
+        episode_id = self.episode_ids[index]
+        dataset_path = os.path.join(self.dataset_dir, f"episode_{episode_id}.hdf5")
+
+        with h5py.File(dataset_path, "r") as root:
+            is_sim = root.attrs.get("sim", True)
+            episode_len = root["/action"].shape[0]
+            start_ts = np.random.choice(episode_len)
+
+            # Observation at start_ts
+            qpos = root["/observations/qpos"][start_ts]
+            image_dict = {}
+            for cam_name in self.camera_names:
+                image_dict[cam_name] = root[f"/observations/images/{cam_name}"][start_ts]
+
+            # Tactile at start_ts: [2, 5, 4, 4, 3]
+            tactile = root["/observations/tactile"][start_ts]
+
+            # Event label at start_ts
+            event_label = root["/observations/event_labels"][start_ts]
+
+            # Actions from start_ts onward
+            action = root["/action"][start_ts:]
+            action_len = episode_len - start_ts
+
+        self.is_sim = is_sim
+
+        # Pad actions
+        padded_action = np.zeros((self.max_action_len, action.shape[1]), dtype=np.float32)
+        padded_action[:action_len] = action
+        is_pad = np.ones(self.max_action_len, dtype=bool)
+        is_pad[:action_len] = False
+
+        # Stack camera images
+        all_cam_images = np.stack([image_dict[c] for c in self.camera_names], axis=0)
+
+        # To tensors
+        image_data = torch.from_numpy(all_cam_images)
+        qpos_data = torch.from_numpy(qpos).float()
+        action_data = torch.from_numpy(padded_action).float()
+        is_pad = torch.from_numpy(is_pad).bool()
+        tactile_data = torch.from_numpy(tactile).float()
+        event_label = torch.tensor(event_label, dtype=torch.long)
+
+        # NCHW for images
+        image_data = torch.einsum("k h w c -> k c h w", image_data)
+        image_data = image_data / 255.0
+
+        # Normalize
+        action_data = (action_data - self.norm_stats["action_mean"]) / self.norm_stats["action_std"]
+        qpos_data = (qpos_data - self.norm_stats["qpos_mean"]) / self.norm_stats["qpos_std"]
+
+        return image_data, qpos_data, action_data, is_pad, tactile_data, event_label
+
+
+def get_norm_stats(dataset_dir, num_episodes):
+    """Compute normalization statistics for qpos and action."""
+    all_qpos_data = []
+    all_action_data = []
+
+    for episode_idx in range(num_episodes):
+        dataset_path = os.path.join(dataset_dir, f"episode_{episode_idx}.hdf5")
+        with h5py.File(dataset_path, "r") as root:
+            qpos = root["/observations/qpos"][()]
+            action = root["/action"][()]
+        all_qpos_data.append(torch.from_numpy(qpos))
+        all_action_data.append(torch.from_numpy(action))
+
+    max_qpos_len = max(q.size(0) for q in all_qpos_data)
+    max_action_len = max(a.size(0) for a in all_action_data)
+
+    # Pad to max length
+    padded_qpos = []
+    for qpos in all_qpos_data:
+        if qpos.size(0) < max_qpos_len:
+            pad = qpos[-1:].repeat(max_qpos_len - qpos.size(0), 1)
+            qpos = torch.cat([qpos, pad], dim=0)
+        padded_qpos.append(qpos)
+
+    padded_action = []
+    for action in all_action_data:
+        if action.size(0) < max_action_len:
+            pad = action[-1:].repeat(max_action_len - action.size(0), 1)
+            action = torch.cat([action, pad], dim=0)
+        padded_action.append(action)
+
+    all_qpos_data = torch.stack(padded_qpos)
+    all_action_data = torch.stack(padded_action)
+
+    action_mean = all_action_data.mean(dim=[0, 1], keepdim=True)
+    action_std = all_action_data.std(dim=[0, 1], keepdim=True)
+    action_std = torch.clip(action_std, 1e-2, np.inf)
+
+    qpos_mean = all_qpos_data.mean(dim=[0, 1], keepdim=True)
+    qpos_std = all_qpos_data.std(dim=[0, 1], keepdim=True)
+    qpos_std = torch.clip(qpos_std, 1e-2, np.inf)
+
+    stats = {
+        "action_mean": action_mean.numpy().squeeze(),
+        "action_std": action_std.numpy().squeeze(),
+        "qpos_mean": qpos_mean.numpy().squeeze(),
+        "qpos_std": qpos_std.numpy().squeeze(),
+    }
+
+    return stats, max_action_len
+
+
+def load_data(dataset_dir, num_episodes, camera_names, batch_size_train, batch_size_val):
+    """Load EVA dataset with tactile data."""
+    print(f"\nData from: {dataset_dir}\n")
+
+    train_ratio = 0.8
+    shuffled_indices = np.random.permutation(num_episodes)
+    train_indices = shuffled_indices[:int(train_ratio * num_episodes)]
+    val_indices = shuffled_indices[int(train_ratio * num_episodes):]
+
+    norm_stats, max_action_len = get_norm_stats(dataset_dir, num_episodes)
+
+    train_dataset = EVAEpisodicDataset(train_indices, dataset_dir, camera_names, norm_stats, max_action_len)
+    val_dataset = EVAEpisodicDataset(val_indices, dataset_dir, camera_names, norm_stats, max_action_len)
+
+    train_dataloader = DataLoader(
+        train_dataset, batch_size=batch_size_train, shuffle=True,
+        pin_memory=True, num_workers=1, prefetch_factor=1,
+    )
+    val_dataloader = DataLoader(
+        val_dataset, batch_size=batch_size_val, shuffle=True,
+        pin_memory=True, num_workers=1, prefetch_factor=1,
+    )
+
+    return train_dataloader, val_dataloader, norm_stats, train_dataset.is_sim
+
+
+# Helper functions (same as ACT)
+
+def compute_dict_mean(epoch_dicts):
+    result = {k: None for k in epoch_dicts[0]}
+    num_items = len(epoch_dicts)
+    for k in result:
+        value_sum = 0
+        for epoch_dict in epoch_dicts:
+            value_sum += epoch_dict[k]
+        result[k] = value_sum / num_items
+    return result
+
+
+def detach_dict(d):
+    return {k: v.detach() for k, v in d.items()}
+
+
+def set_seed(seed):
+    torch.manual_seed(seed)
+    np.random.seed(seed)

robosuite/models/assets/grippers/robotiq_gripper_85.xml

@@ -62,7 +62,7 @@
                     <geom type="mesh" group="0" rgba="0.1 0.1 0.1 1" mesh="robotiq_arg2f_85_inner_finger" name="left_inner_finger_collision" solref="0.01 0.25" />
                     <geom size="0.011 0.003175 0.01875" pos="0 -0.0220203 0.03242" type="box" contype="0" conaffinity="0" group="1" rgba="0.9 0.9 0.9 1" name="left_fingertip_visual" />
                     <geom size="0.011 0.003175 0.01875" pos="0 -0.0220203 0.03242" type="box" group="0" rgba="0.9 0.9 0.9 1" name="left_fingertip_collision" solref="0.01 0.25" />
-                    <geom size="0.010 0.001 0.01675" pos="0 -0.0245203 0.03242" type="box" group="0" name="left_fingerpad_collision" />
+                    <geom size="0.010 0.001 0.01675" pos="0 -0.0245203 0.03242" type="box" group="0" name="left_fingerpad_collision" friction="2.0 0.5 0.01" condim="4" />
                     <!-- 4x4 taxel grid on left fingerpad (uSkin-like) -->
                     <site name="taxel_l_r0c0" type="sphere" size="0.002" pos="-0.0075 -0.0255 0.01986" rgba="0 1 0 0.3" group="4"/>
                     <site name="taxel_l_r0c1" type="sphere" size="0.002" pos="-0.0025 -0.0255 0.01986" rgba="0 1 0 0.3" group="4"/>
@@ -102,7 +102,7 @@
                     <geom type="mesh" group="0" rgba="0.1 0.1 0.1 1" mesh="robotiq_arg2f_85_inner_finger" name="right_inner_finger_collision" solref="0.01 0.25" />
                     <geom size="0.011 0.003175 0.01875" pos="0 -0.0220203 0.03242" type="box" contype="0" conaffinity="0" group="1" rgba="0.9 0.9 0.9 1" name="right_fingertip_visual" />
                     <geom size="0.011 0.003175 0.01875" pos="0 -0.0220203 0.03242" type="box" group="0" rgba="0.9 0.9 0.9 1" name="right_fingertip_collision" solref="0.01 0.25" />
-                    <geom size="0.010 0.001 0.01675" pos="0 -0.0245203 0.03242" type="box" group="0" name="right_fingerpad_collision" />
+                    <geom size="0.010 0.001 0.01675" pos="0 -0.0245203 0.03242" type="box" group="0" name="right_fingerpad_collision" friction="2.0 0.5 0.01" condim="4" />
                     <!-- 4x4 taxel grid on right fingerpad (uSkin-like) -->
                     <site name="taxel_r_r0c0" type="sphere" size="0.002" pos="-0.0075 -0.0255 0.01986" rgba="0 0.5 1 0.3" group="4"/>
                     <site name="taxel_r_r0c1" type="sphere" size="0.002" pos="-0.0025 -0.0255 0.01986" rgba="0 0.5 1 0.3" group="4"/>

tactile_data/videos/peg_insertion/episode_00.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf73e0db1834b78ca661a313cbdd105b64a7a4f0209383bb834ad6ddc6adf727
+size 132782352

tactile_data/videos/peg_insertion/episode_01.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cb4e78fa52e70927d38a3a56c6931c2d1207fca024c011fafb743c34180b428
+size 177724829

tactile_data/videos/peg_insertion/episode_02.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:747aaab888aa488f3b8becf1b31ea6cca53eb1083cf145bad1f6a9bdcdf7775a
+size 181730076

tactile_data/videos/peg_insertion/episode_03.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8e46266901d816cdfa838418e4e02e5f2ee604aed222f233b8ba688a9d06cdc
+size 177563752

tactile_data/videos/peg_insertion/episode_04.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6365ce9231745f24285fd4faf2a2ed434b323094ef8fe3ba6e1ca577fba219d1
+size 131992471

tactile_data/videos/peg_insertion/episode_05.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff7af7a443c2a8701a92a3716cee5fba84435e14735fc0219c41c8d6f89450c1
+size 179919535

tactile_data/videos/peg_insertion/episode_06.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13ee0e0dc21187609f98a6db4f03e13ebc2c7536cd25ef7970209d95fe3f8fe7
+size 178115959

tactile_data/videos/peg_insertion/episode_07.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5345e8d1041633e862644ca962f6ccece0ce695f496a17623773f6e42cd4fea
+size 180681465

tactile_data/videos/peg_insertion/peg_insertion_ep00.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7e7b9e65b38e27a044e55ffcd7ac6c546263cd85824d6a06449eb425ef60e8ad
-size 801077
+oid sha256:c3492f2a6a81fb8f93ce90e1bec6962d072ad6c52c3747876b6fb4d3eea34f04
+size 1204351