Add files using upload-large-folder tool

maniskill3_environment_assets/.gitignore

@@ -0,0 +1 @@
+*.zip

maniskill3_environment_assets/racks/bin.gltf

@@ -0,0 +1,207 @@
+{
+	"asset":{
+		"generator":"Khronos glTF Blender I/O v4.3.47",
+		"version":"2.0"
+	},
+	"scene":0,
+	"scenes":[
+		{
+			"name":"Scene",
+			"nodes":[
+				0,
+				1
+			]
+		}
+	],
+	"nodes":[
+		{
+			"mesh":0,
+			"name":"Model"
+		},
+		{
+			"mesh":1,
+			"name":"Mesh_0",
+			"rotation":[
+				0.7071068286895752,
+				0,
+				0,
+				0.7071068286895752
+			]
+		}
+	],
+	"materials":[
+		{
+			"name":"Material.001"
+		},
+		{
+			"doubleSided":true,
+			"name":"Material_0.006",
+			"pbrMetallicRoughness":{
+				"baseColorFactor":[
+					0.800000011920929,
+					0.800000011920929,
+					0.800000011920929,
+					1
+				],
+				"metallicFactor":0,
+				"roughnessFactor":0.5
+			}
+		}
+	],
+	"meshes":[
+		{
+			"name":"Model.002",
+			"primitives":[
+				{
+					"attributes":{
+						"POSITION":0,
+						"NORMAL":1,
+						"TEXCOORD_0":2
+					},
+					"indices":3,
+					"material":0
+				}
+			]
+		},
+		{
+			"name":"Mesh_0.005",
+			"primitives":[
+				{
+					"attributes":{
+						"POSITION":4,
+						"NORMAL":5,
+						"TEXCOORD_0":6
+					},
+					"indices":7,
+					"material":1
+				}
+			]
+		}
+	],
+	"accessors":[
+		{
+			"bufferView":0,
+			"componentType":5126,
+			"count":96746,
+			"max":[
+				366.4075012207031,
+				1.4419732093811035,
+				192.4498291015625
+			],
+			"min":[
+				352.80267333984375,
+				-9.999999974752427e-07,
+				174.88624572753906
+			],
+			"type":"VEC3"
+		},
+		{
+			"bufferView":1,
+			"componentType":5126,
+			"count":96746,
+			"type":"VEC3"
+		},
+		{
+			"bufferView":2,
+			"componentType":5126,
+			"count":96746,
+			"type":"VEC2"
+		},
+		{
+			"bufferView":3,
+			"componentType":5125,
+			"count":398523,
+			"type":"SCALAR"
+		},
+		{
+			"bufferView":4,
+			"componentType":5126,
+			"count":18533,
+			"max":[
+				0.12296000123023987,
+				0.11509200185537338,
+				0.08574099838733673
+			],
+			"min":[
+				-0.12296000123023987,
+				9.999999974752427e-07,
+				-0.08569499850273132
+			],
+			"type":"VEC3"
+		},
+		{
+			"bufferView":5,
+			"componentType":5126,
+			"count":18533,
+			"type":"VEC3"
+		},
+		{
+			"bufferView":6,
+			"componentType":5126,
+			"count":18533,
+			"type":"VEC2"
+		},
+		{
+			"bufferView":7,
+			"componentType":5123,
+			"count":89001,
+			"type":"SCALAR"
+		}
+	],
+	"bufferViews":[
+		{
+			"buffer":0,
+			"byteLength":1160952,
+			"byteOffset":0,
+			"target":34962
+		},
+		{
+			"buffer":0,
+			"byteLength":1160952,
+			"byteOffset":1160952,
+			"target":34962
+		},
+		{
+			"buffer":0,
+			"byteLength":773968,
+			"byteOffset":2321904,
+			"target":34962
+		},
+		{
+			"buffer":0,
+			"byteLength":1594092,
+			"byteOffset":3095872,
+			"target":34963
+		},
+		{
+			"buffer":0,
+			"byteLength":222396,
+			"byteOffset":4689964,
+			"target":34962
+		},
+		{
+			"buffer":0,
+			"byteLength":222396,
+			"byteOffset":4912360,
+			"target":34962
+		},
+		{
+			"buffer":0,
+			"byteLength":148264,
+			"byteOffset":5134756,
+			"target":34962
+		},
+		{
+			"buffer":0,
+			"byteLength":178002,
+			"byteOffset":5283020,
+			"target":34963
+		}
+	],
+	"buffers":[
+		{
+			"byteLength":5461024,
+			"uri":"bin.bin"
+		}
+	]
+}

maniskill3_environment_assets/racks/dish_rack.mtl

@@ -0,0 +1,2 @@
+# Blender 4.3.2 MTL File: 'None'
+# www.blender.org

maniskill3_environment_assets/racks/sockerbit_box.mtl

@@ -0,0 +1,12 @@
+# Blender 4.3.2 MTL File: 'None'
+# www.blender.org
+
+newmtl SimplygonCastMaterial.004
+Ns 250.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.500000
+d 1.000000
+illum 2

maniskill3_environment_assets/racks/uppsnofsad_box.mtl

@@ -0,0 +1,12 @@
+# Blender 4.3.2 MTL File: 'None'
+# www.blender.org
+
+newmtl Material_0.004
+Ns 250.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.500000
+d 1.000000
+illum 2

project/ManiSkill3/src/maniskill3_environment/examples/baselines/README.md

@@ -0,0 +1,9 @@
+# ManiSkill Baselines
+
+This folder contains code for all implemented ManiSkill baselines which currently include online Reinforcement Learning and Imitation Learning. All baseline results are published to our [public wandb page](https://wandb.ai/stonet2000/ManiSkill).
+
+For more details on baselines (e.g. how to setup maniskill for RL, run baselines etc.) follow the links below in our documentation:
+
+- Online Reinforcement Learning: https://maniskill.readthedocs.io/en/latest/user_guide/reinforcement_learning/index.html
+- Learning From Demonstrations / Imitation Learning: https://maniskill.readthedocs.io/en/latest/user_guide/learning_from_demos/index.html
+

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/.gitignore

@@ -0,0 +1,2 @@
+runs/
+wandb/

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/README.md

@@ -0,0 +1,61 @@
+# Action Chunking with Transformers (ACT)
+
+Code for running the ACT algorithm based on ["Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware"](https://arxiv.org/pdf/2304.13705). It is adapted from the [original code](https://github.com/tonyzhaozh/act).
+
+## Installation
+
+To get started, we recommend using conda/mamba to create a new environment and install the dependencies
+
+```bash
+conda create -n act-ms python=3.9
+conda activate act-ms
+pip install -e .
+```
+
+## Setup
+
+Read through the [imitation learning setup documentation](https://maniskill.readthedocs.io/en/latest/user_guide/learning_from_demos/setup.html) which details everything you need to know regarding running imitation learning baselines in ManiSkill. It includes details on how to download demonstration datasets, preprocess them, evaluate policies fairly for comparison, as well as suggestions to improve performance and avoid bugs.
+
+## Training
+
+We provide scripts to train ACT on demonstrations.
+
+Note that some demonstrations are slow (e.g. motion planning or human teleoperated) and can exceed the default max episode steps which can be an issue as imitation learning algorithms learn to solve the task at the same speed the demonstrations solve it. In this case, you can use the `--max-episode-steps` flag to set a higher value so that the policy can solve the task in time. General recommendation is to set `--max-episode-steps` to about 2x the length of the mean demonstrations length you are using for training. We have tuned baselines in the `baselines.sh` script that set a recommended `--max-episode-steps` for each task.
+
+Example state-based training, learning from 100 demonstrations generated via motionplanning in the PickCube-v1 task.
+
+```bash
+seed=1
+demos=100
+python train.py --env-id PickCube-v1 \
+  --demo-path ~/.maniskill/demos/PickCube-v1/motionplanning/trajectory.state.pd_ee_delta_pos.physx_cpu.h5 \
+  --control-mode "pd_ee_delta_pos" --sim-backend "physx_cpu" --num_demos $demos --max_episode_steps 100 \
+  --total_iters 30000 --log_freq 100 --eval_freq 5000 \
+  --exp-name=act-PickCube-v1-state-${demos}_motionplanning_demos-$seed \
+  --track # track training on wandb
+```
+
+## Citation
+
+If you use this baseline please cite the following
+```
+@inproceedings{DBLP:conf/rss/ZhaoKLF23,
+  author       = {Tony Z. Zhao and
+                  Vikash Kumar and
+                  Sergey Levine and
+                  Chelsea Finn},
+  editor       = {Kostas E. Bekris and
+                  Kris Hauser and
+                  Sylvia L. Herbert and
+                  Jingjin Yu},
+  title        = {Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware},
+  booktitle    = {Robotics: Science and Systems XIX, Daegu, Republic of Korea, July
+                  10-14, 2023},
+  year         = {2023},
+  url          = {https://doi.org/10.15607/RSS.2023.XIX.016},
+  doi          = {10.15607/RSS.2023.XIX.016},
+  timestamp    = {Thu, 20 Jul 2023 15:37:49 +0200},
+  biburl       = {https://dblp.org/rec/conf/rss/ZhaoKLF23.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}
+```

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/act/detr/backbone.py

@@ -0,0 +1,129 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+Backbone modules.
+"""
+from collections import OrderedDict
+
+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
+
+from act.utils import NestedTensor, is_main_process
+from act.detr.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,
+                 include_depth: 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??
+
+        # for rgbd data 
+        if include_depth:
+            w = backbone.conv1.weight
+            w = torch.cat([w, torch.full((64, 1, 7, 7), 0)], dim=1)
+            backbone.conv1.weight = nn.Parameter(w)
+            
+        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, args.include_depth)
+    model = Joiner(backbone, position_embedding)
+    model.num_channels = backbone.num_channels
+    return model

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/act/detr/detr_vae.py

@@ -0,0 +1,141 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+"""
+DETR model and criterion classes.
+"""
+import torch
+from torch import nn
+from torch.autograd import Variable
+from act.detr.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):
+    """ This is the DETR module that performs object detection """
+    def __init__(self, backbones, transformer, encoder, state_dim, action_dim, num_queries):
+        super().__init__()
+        self.num_queries = num_queries
+        self.transformer = transformer
+        self.encoder = encoder
+        hidden_dim = transformer.d_model
+        self.action_head = nn.Linear(hidden_dim, action_dim)
+        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.backbones = None
+
+        # encoder extra parameters
+        self.latent_dim = 32 # size of latent z
+        self.cls_embed = nn.Embedding(1, hidden_dim) # extra cls token embedding
+        self.encoder_state_proj = nn.Linear(state_dim, hidden_dim)  # project state to embedding
+        self.encoder_action_proj = nn.Linear(action_dim, hidden_dim) # project action to embedding
+        self.latent_proj = nn.Linear(hidden_dim, self.latent_dim*2) # project hidden state to latent std, var
+        self.register_buffer('pos_table', get_sinusoid_encoding_table(1+1+num_queries, hidden_dim)) # [CLS], state, actions
+
+        # decoder extra parameters
+        self.latent_out_proj = nn.Linear(self.latent_dim, hidden_dim) # project latent sample to embedding
+        self.additional_pos_embed = nn.Embedding(2, hidden_dim) # learned position embedding for state and proprio
+
+    def forward(self, obs, actions=None):
+        is_training = actions is not None
+        state = obs['state'] if self.backbones is not None else obs
+        bs = state.shape[0]
+
+        if is_training:
+            # project CLS token, state sequence, and action sequence to embedding dim
+            cls_embed = self.cls_embed.weight  # (1, hidden_dim)
+            cls_embed = torch.unsqueeze(cls_embed, axis=0).repeat(bs, 1, 1)  # (bs, 1, hidden_dim)
+            state_embed = self.encoder_state_proj(state) # (bs, hidden_dim)
+            state_embed = torch.unsqueeze(state_embed, axis=1)  # (bs, 1, hidden_dim)
+            action_embed = self.encoder_action_proj(actions)  # (bs, seq, hidden_dim)
+            # concat them together to form an input to the CVAE encoder
+            encoder_input = torch.cat([cls_embed, state_embed, action_embed], axis=1) # (bs, seq+2, hidden_dim)
+            encoder_input = encoder_input.permute(1, 0, 2) # (seq+2, bs, hidden_dim)
+            # no masking is applied to all parts of the CVAE encoder input
+            is_pad = torch.full((bs, encoder_input.shape[0]), False).to(state.device) # False: not a padding
+            # obtain position embedding
+            pos_embed = self.pos_table.clone().detach()
+            pos_embed = pos_embed.permute(1, 0, 2)  # (seq+2, 1, hidden_dim)
+            # query CVAE encoder
+            encoder_output = self.encoder(encoder_input, pos=pos_embed, src_key_padding_mask=is_pad)
+            encoder_output = encoder_output[0] # take cls output only
+            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(state.device)
+            latent_input = self.latent_out_proj(latent_sample)
+
+        # CVAE decoder
+        if self.backbones is not None:
+            vis_data = obs['rgb']
+            if "depth" in obs:
+                vis_data = torch.cat([vis_data, obs['depth']], dim=2)
+            num_cams = vis_data.shape[1]
+
+            # Image observation features and position embeddings
+            all_cam_features = []
+            all_cam_pos = []
+            for cam_id in range(num_cams):
+                features, pos = self.backbones[0](vis_data[:, cam_id]) # HARDCODED
+                features = features[0] # take the last layer feature # (batch, hidden_dim, H, W)
+                pos = pos[0] # (1, hidden_dim, H, W)
+                all_cam_features.append(self.input_proj(features))
+                all_cam_pos.append(pos)
+
+            # proprioception features (state)
+            proprio_input = self.input_proj_robot_state(state)
+            # fold camera dimension into width dimension
+            src = torch.cat(all_cam_features, axis=3) # (batch, hidden_dim, 4, 8)
+            pos = torch.cat(all_cam_pos, axis=3) # (batch, hidden_dim, 4, 8)
+            hs = self.transformer(src, None, self.query_embed.weight, pos, latent_input, proprio_input, self.additional_pos_embed.weight)[0] # (batch, num_queries, hidden_dim)
+        else:
+            state = self.input_proj_robot_state(state)
+            hs = self.transformer(None, None, self.query_embed.weight, None, latent_input, state, self.additional_pos_embed.weight)[0]
+
+        a_hat = self.action_head(hs)
+        return a_hat, [mu, logvar]
+
+
+def build_encoder(args):
+    d_model = args.hidden_dim # 256
+    dropout = args.dropout # 0.1
+    nhead = args.nheads # 8
+    dim_feedforward = args.dim_feedforward # 2048
+    num_encoder_layers = args.enc_layers # 4 # TODO shared with VAE decoder
+    normalize_before = args.pre_norm # False
+    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

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/act/detr/position_encoding.py

@@ -0,0 +1,93 @@
+# 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 act.utils 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):
+    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

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/act/detr/transformer.py

@@ -0,0 +1,313 @@
+# 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):
+        if src is None:
+            bs = proprio_input.shape[0]
+            query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
+            pos_embed = additional_pos_embed.unsqueeze(1).repeat(1, bs, 1) # seq, bs, dim
+            src = torch.stack([latent_input, proprio_input], axis=0)
+        # TODO flatten only when input has H and W
+        elif 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)
+
+            additional_pos_embed = additional_pos_embed.unsqueeze(1).repeat(1, bs, 1) # seq, bs, dim
+            pos_embed = torch.cat([additional_pos_embed, pos_embed], axis=0)
+
+            addition_input = torch.stack([latent_input, proprio_input], axis=0)
+            src = torch.cat([addition_input, src], axis=0)
+
+        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}.")

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/act/evaluate.py

@@ -0,0 +1,98 @@
+from collections import defaultdict
+import gymnasium
+import numpy as np
+import torch
+
+from mani_skill.utils import common
+
+def evaluate(n: int, agent, eval_envs, eval_kwargs):
+    stats, num_queries, temporal_agg, max_timesteps, device, sim_backend = eval_kwargs.values()
+
+    use_visual_obs = isinstance(eval_envs.single_observation_space.sample(), dict)
+    delta_control = not stats
+    if not delta_control:
+        if sim_backend == "physx_cpu":
+            pre_process = lambda s_obs: (s_obs - stats['state_mean'].cpu().numpy()) / stats['state_std'].cpu().numpy()
+        else:
+            pre_process = lambda s_obs: (s_obs - stats['state_mean']) / stats['state_std']
+        post_process = lambda a: a * stats['action_std'] + stats['action_mean']
+
+    # create action table for temporal ensembling
+    action_dim = eval_envs.action_space.shape[-1]
+    num_envs = eval_envs.num_envs
+    if temporal_agg:
+        query_frequency = 1
+        all_time_actions = torch.zeros([num_envs, max_timesteps, max_timesteps+num_queries, action_dim], device=device)
+    else:
+        query_frequency = num_queries
+        actions_to_take = torch.zeros([num_envs, num_queries, action_dim], device=device)
+
+    agent.eval()
+    with torch.no_grad():
+        eval_metrics = defaultdict(list)
+        obs, info = eval_envs.reset()
+        ts, eps_count = 0, 0
+        while eps_count < n:
+            # pre-process obs
+            if use_visual_obs:
+                obs['state'] = pre_process(obs['state']) if not delta_control else obs['state']  # (num_envs, obs_dim)
+                obs = {k: common.to_tensor(v, device) for k, v in obs.items()}
+            else:
+                obs = pre_process(obs) if not delta_control else obs  # (num_envs, obs_dim)
+                obs = common.to_tensor(obs, device)
+
+            # query policy
+            if ts % query_frequency == 0:
+                action_seq = agent.get_action(obs)  # (num_envs, num_queries, action_dim)
+
+            # we assume ignore_terminations=True. Otherwise, some envs could be done
+            # earlier, so we would need to temporally ensemble at corresponding timestep
+            # for each env.
+            if temporal_agg:
+                assert query_frequency == 1, "query_frequency != 1 has not been implemented for temporal_agg==1."
+                all_time_actions[:, ts, ts:ts+num_queries] = action_seq # (num_envs, num_queries, act_dim)
+                actions_for_curr_step = all_time_actions[:, :, ts] # (num_envs, max_timesteps, act_dim)
+                # since we pad the action with 0 in 'delta_pos' control mode, this causes error.
+                #actions_populated = torch.all(actions_for_curr_step[0] != 0, axis=1) # (max_timesteps,)
+                actions_populated = torch.zeros(max_timesteps, dtype=torch.bool, device=device) # (max_timesteps,)
+                actions_populated[max(0, ts + 1 - num_queries):ts+1] = True
+                actions_for_curr_step = actions_for_curr_step[:, actions_populated] # (num_envs, num_populated, act_dim)
+                k = 0.01
+                if ts < num_queries:
+                    exp_weights = torch.exp(-k * torch.arange(len(actions_for_curr_step[0]), device=device)) # (num_populated,)
+                    exp_weights = exp_weights / exp_weights.sum() # (num_populated,)
+                    exp_weights = torch.tile(exp_weights, (num_envs, 1)) # (num_envs, num_populated)
+                    exp_weights = torch.unsqueeze(exp_weights, -1) # (num_envs, num_populated, 1)
+                raw_action = (actions_for_curr_step * exp_weights).sum(dim=1)  # (num_envs, act_dim)
+            else:
+                if ts % query_frequency == 0:
+                    actions_to_take = action_seq
+                raw_action = actions_to_take[:, ts % query_frequency]
+
+            action = post_process(raw_action) if not delta_control else raw_action  # (num_envs, act_dim)
+            if sim_backend == "physx_cpu":
+                action = action.cpu().numpy()
+
+            # step the environment
+            obs, rew, terminated, truncated, info = eval_envs.step(action)
+            ts += 1
+
+            # collect episode info
+            if truncated.any():
+                assert truncated.all() == truncated.any(), "all episodes should truncate at the same time for fair evaluation with other algorithms"
+                if isinstance(info["final_info"], dict):
+                    for k, v in info["final_info"]["episode"].items():
+                        eval_metrics[k].append(v.float().cpu().numpy())
+                else:
+                    for final_info in info["final_info"]:
+                        for k, v in final_info["episode"].items():
+                            eval_metrics[k].append(v)
+                # new episodes begin
+                eps_count += num_envs
+                ts = 0
+                all_time_actions = torch.zeros([num_envs, max_timesteps, max_timesteps+num_queries, action_dim], device=device)
+
+    agent.train()
+    for k in eval_metrics.keys():
+        eval_metrics[k] = np.stack(eval_metrics[k])
+    return eval_metrics

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/act/make_env.py

@@ -0,0 +1,46 @@
+from typing import Optional
+import gymnasium as gym
+import mani_skill.envs
+from mani_skill.utils import gym_utils
+from mani_skill.vector.wrappers.gymnasium import ManiSkillVectorEnv
+from mani_skill.utils.wrappers import RecordEpisode, CPUGymWrapper
+
+
+def make_eval_envs(env_id, num_envs: int, sim_backend: str, env_kwargs: dict, other_kwargs: dict, video_dir: Optional[str] = None, wrappers: list[gym.Wrapper] = []):
+    """Create vectorized environment for evaluation and/or recording videos.
+    For CPU vectorized environments only the first parallel environment is used to record videos.
+    For GPU vectorized environments all parallel environments are used to record videos.
+
+    Args:
+        env_id: the environment id
+        num_envs: the number of parallel environments
+        sim_backend: the simulation backend to use. can be "cpu" or "gpu
+        env_kwargs: the environment kwargs. You can also pass in max_episode_steps in env_kwargs to override the default max episode steps for the environment.
+        video_dir: the directory to save the videos. If None no videos are recorded.
+        wrappers: the list of wrappers to apply to the environment.
+    """
+    if sim_backend == "physx_cpu":
+        def cpu_make_env(env_id, seed, video_dir=None, env_kwargs = dict(), other_kwargs = dict()):
+            def thunk():
+                env = gym.make(env_id, reconfiguration_freq=1, **env_kwargs)
+                for wrapper in wrappers:
+                    env = wrapper(env)
+                env = CPUGymWrapper(env, ignore_terminations=True, record_metrics=True)
+                if video_dir:
+                    env = RecordEpisode(env, output_dir=video_dir, save_trajectory=False, info_on_video=True, source_type="act", source_desc="act evaluation rollout")
+                env.action_space.seed(seed)
+                env.observation_space.seed(seed)
+                return env
+
+            return thunk
+        vector_cls = gym.vector.SyncVectorEnv if num_envs == 1 else lambda x : gym.vector.AsyncVectorEnv(x, context="forkserver")
+        env = vector_cls([cpu_make_env(env_id, seed, video_dir if seed == 0 else None, env_kwargs, other_kwargs) for seed in range(num_envs)])
+    else:
+        env = gym.make(env_id, num_envs=num_envs, sim_backend=sim_backend, reconfiguration_freq=1, **env_kwargs)
+        max_episode_steps = gym_utils.find_max_episode_steps_value(env)
+        for wrapper in wrappers:
+            env = wrapper(env)
+        if video_dir:
+            env = RecordEpisode(env, output_dir=video_dir, save_trajectory=False, save_video=True, source_type="act", source_desc="act evaluation rollout", max_steps_per_video=max_episode_steps)
+        env = ManiSkillVectorEnv(env, ignore_terminations=True, record_metrics=True)
+    return env

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/act/utils.py

@@ -0,0 +1,161 @@
+from torch.utils.data.sampler import Sampler
+import numpy as np
+import torch
+import torch.distributed as dist
+from torch import Tensor
+from h5py import File, Group, Dataset
+from typing import Optional
+
+
+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 is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+def get_rank():
+    if not is_dist_avail_and_initialized():
+        return 0
+    return dist.get_rank()
+
+def is_main_process():
+    return get_rank() == 0
+    
+
+class IterationBasedBatchSampler(Sampler):
+    """Wraps a BatchSampler.
+    Resampling from it until a specified number of iterations have been sampled
+    References:
+        https://github.com/facebookresearch/maskrcnn-benchmark/blob/master/maskrcnn_benchmark/data/samplers/iteration_based_batch_sampler.py
+    """
+
+    def __init__(self, batch_sampler, num_iterations, start_iter=0):
+        self.batch_sampler = batch_sampler
+        self.num_iterations = num_iterations
+        self.start_iter = start_iter
+
+    def __iter__(self):
+        iteration = self.start_iter
+        while iteration < self.num_iterations:
+            # if the underlying sampler has a set_epoch method, like
+            # DistributedSampler, used for making each process see
+            # a different split of the dataset, then set it
+            if hasattr(self.batch_sampler.sampler, "set_epoch"):
+                self.batch_sampler.sampler.set_epoch(iteration)
+            for batch in self.batch_sampler:
+                yield batch
+                iteration += 1
+                if iteration >= self.num_iterations:
+                    break
+
+    def __len__(self):
+        return self.num_iterations - self.start_iter
+
+
+def worker_init_fn(worker_id, base_seed=None):
+    """The function is designed for pytorch multi-process dataloader.
+    Note that we use the pytorch random generator to generate a base_seed.
+    Please try to be consistent.
+    References:
+        https://pytorch.org/docs/stable/notes/faq.html#dataloader-workers-random-seed
+    """
+    if base_seed is None:
+        base_seed = torch.IntTensor(1).random_().item()
+    # print(worker_id, base_seed)
+    np.random.seed(base_seed + worker_id)
+
+TARGET_KEY_TO_SOURCE_KEY = {
+    'states': 'env_states',
+    'observations': 'obs',
+    'success': 'success',
+    'next_observations': 'obs',
+    # 'dones': 'dones',
+    # 'rewards': 'rewards',
+    'actions': 'actions',
+}
+def load_content_from_h5_file(file):
+    if isinstance(file, (File, Group)):
+        return {key: load_content_from_h5_file(file[key]) for key in list(file.keys())}
+    elif isinstance(file, Dataset):
+        return file[()]
+    else:
+        raise NotImplementedError(f"Unspported h5 file type: {type(file)}")
+
+def load_hdf5(path, ):
+    print('Loading HDF5 file', path)
+    file = File(path, 'r')
+    ret = load_content_from_h5_file(file)
+    file.close()
+    print('Loaded')
+    return ret
+
+def load_traj_hdf5(path, num_traj=None):
+    print('Loading HDF5 file', path)
+    file = File(path, 'r')
+    keys = list(file.keys())
+    if num_traj is not None:
+        assert num_traj <= len(keys), f"num_traj: {num_traj} > len(keys): {len(keys)}"
+        keys = sorted(keys, key=lambda x: int(x.split('_')[-1]))
+        keys = keys[:num_traj]
+    ret = {
+        key: load_content_from_h5_file(file[key]) for key in keys
+    }
+    file.close()
+    print('Loaded')
+    return ret
+def load_demo_dataset(path, keys=['observations', 'actions'], num_traj=None, concat=True):
+    # assert num_traj is None
+    raw_data = load_traj_hdf5(path, num_traj)
+    # raw_data has keys like: ['traj_0', 'traj_1', ...]
+    # raw_data['traj_0'] has keys like: ['actions', 'dones', 'env_states', 'infos', ...]
+    _traj = raw_data['traj_0']
+    for key in keys:
+        source_key = TARGET_KEY_TO_SOURCE_KEY[key]
+        assert source_key in _traj, f"key: {source_key} not in traj_0: {_traj.keys()}"
+    dataset = {}
+    for target_key in keys:
+        # if 'next' in target_key:
+        #     raise NotImplementedError('Please carefully deal with the length of trajectory')
+        source_key = TARGET_KEY_TO_SOURCE_KEY[target_key]
+        dataset[target_key] = [ raw_data[idx][source_key] for idx in raw_data ]
+        if isinstance(dataset[target_key][0], np.ndarray) and concat:
+            if target_key in ['observations', 'states'] and \
+                    len(dataset[target_key][0]) > len(raw_data['traj_0']['actions']):
+                dataset[target_key] = np.concatenate([
+                    t[:-1] for t in dataset[target_key]
+                ], axis=0)
+            elif target_key in ['next_observations', 'next_states'] and \
+                    len(dataset[target_key][0]) > len(raw_data['traj_0']['actions']):
+                dataset[target_key] = np.concatenate([
+                    t[1:] for t in dataset[target_key]
+                ], axis=0)
+            else:
+                dataset[target_key] = np.concatenate(dataset[target_key], axis=0)
+
+            print('Load', target_key, dataset[target_key].shape)
+        else:
+            print('Load', target_key, len(dataset[target_key]), type(dataset[target_key][0]))
+    return dataset

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/baselines.sh

@@ -0,0 +1,77 @@
+seed=1
+# State based
+for demos in 100; do
+  python train.py --env-id PickCube-v1 \
+    --demo-path ~/.maniskill/demos/PickCube-v1/motionplanning/trajectory.state.pd_ee_delta_pos.physx_cpu.h5 \
+    --control-mode "pd_ee_delta_pos" --sim-backend "physx_cpu" --num_demos $demos --max_episode_steps 100 \
+    --total_iters 30000 --log_freq 100 --eval_freq 5000 \
+    --exp-name=act-PickCube-v1-state-${demos}_motionplanning_demos-$seed \
+    --demo_type motionplanning --track
+
+  python train.py --env-id PushCube-v1 \
+    --demo-path ~/.maniskill/demos/PushCube-v1/motionplanning/trajectory.state.pd_ee_delta_pos.physx_cpu.h5 \
+    --control-mode "pd_ee_delta_pos" --sim-backend "physx_cpu" --num_demos $demos --max_episode_steps 100 \
+    --total_iters 30000 --log_freq 100 --eval_freq 5000 \
+    --exp-name=act-PushCube-v1-state-${demos}_motionplanning_demos-$seed \
+    --demo_type motionplanning --track
+
+  python train.py --env-id StackCube-v1 \
+    --demo-path ~/.maniskill/demos/StackCube-v1/motionplanning/trajectory.state.pd_ee_delta_pos.physx_cpu.h5 \
+    --control-mode "pd_ee_delta_pos" --sim-backend "physx_cpu" --num_demos $demos --max_episode_steps 200 \
+    --total_iters 30000 --log_freq 100 --eval_freq 5000 \
+    --exp-name=act-StackCube-v1-state-${demos}_motionplanning_demos-$seed \
+    --demo_type motionplanning --track
+
+  python train.py --env-id PegInsertionSide-v1 \
+    --demo-path ~/.maniskill/demos/PegInsertionSide-v1/motionplanning/trajectory.state.pd_ee_delta_pose.physx_cpu.h5 \
+    --control-mode "pd_ee_delta_pose" --sim-backend "physx_cpu" --num_demos $demos --max_episode_steps 300 \
+    --total_iters 100000 --log_freq 100 --eval_freq 5000 \
+    --exp-name=act-PegInsertionSide-v1-state-${demos}_motionplanning_demos-$seed \
+    --demo_type motionplanning --track
+
+  python train.py --env-id PushT-v1 \
+    --demo-path ~/.maniskill/demos/PushT-v1/rl/trajectory.state.pd_ee_delta_pose.physx_cuda.h5 \
+    --control-mode "pd_ee_delta_pose" --sim-backend "physx_cuda" --num_demos $demos --max_episode_steps 150 \
+    --total_iters 100000 --log_freq 100 --eval_freq 5000 \
+    --exp-name=act-PushT-v1-state-${demos}_rl_demos-$seed \
+    --demo_type rl --track
+done
+
+# RGB based
+
+for demos in 100; do
+  python train_rgbd.py --env-id PickCube-v1 --no_include_depth \
+    --demo-path ~/.maniskill/demos/PickCube-v1/motionplanning/trajectory.rgb.pd_ee_delta_pos.physx_cpu.h5 \
+    --control-mode "pd_ee_delta_pos" --sim-backend "physx_cuda" --num_demos $demos --max_episode_steps 100 --num_eval_envs 100 --no-capture-video \
+    --total_iters 30000 --log_freq 100 --eval_freq 5000 \
+    --exp-name=act-PickCube-v1-state-${demos}_motionplanning_demos-$seed \
+    --demo_type motionplanning --track
+
+  python train_rgbd.py --env-id PushCube-v1 --no_include_depth \
+    --demo-path ~/.maniskill/demos/PushCube-v1/motionplanning/trajectory.rgb.pd_ee_delta_pos.physx_cpu.h5 \
+    --control-mode "pd_ee_delta_pos" --sim-backend "physx_cuda" --num_demos $demos --max_episode_steps 100 --num_eval_envs 100 --no-capture-video \
+    --total_iters 30000 --log_freq 100 --eval_freq 5000 \
+    --exp-name=act-PushCube-v1-state-${demos}_motionplanning_demos-$seed \
+    --demo_type motionplanning --track
+
+  python train_rgbd.py --env-id StackCube-v1 --no_include_depth \
+    --demo-path ~/.maniskill/demos/StackCube-v1/motionplanning/trajectory.rgb.pd_ee_delta_pos.physx_cpu.h5 \
+    --control-mode "pd_ee_delta_pos" --sim-backend "physx_cuda" --num_demos $demos --max_episode_steps 200 --num_eval_envs 100 --no-capture-video \
+    --total_iters 30000 --log_freq 100 --eval_freq 5000 \
+    --exp-name=act-StackCube-v1-state-${demos}_motionplanning_demos-$seed \
+    --demo_type motionplanning --track
+
+  python train_rgbd.py --env-id PegInsertionSide-v1 --no_include_depth \
+    --demo-path ~/.maniskill/demos/PegInsertionSide-v1/motionplanning/trajectory.rgb.pd_ee_delta_pose.physx_cpu.h5 \
+    --control-mode "pd_ee_delta_pose" --sim-backend "physx_cpu" --num_demos $demos --max_episode_steps 300 \
+    --total_iters 100000 --log_freq 100 --eval_freq 5000 \
+    --exp-name=act-PegInsertionSide-v1-state-${demos}_motionplanning_demos-$seed \
+    --demo_type motionplanning --track
+
+  python train_rgbd.py --env-id PushT-v1 --no_include_depth \
+    --demo-path ~/.maniskill/demos/PushT-v1/rl/trajectory.rgb.pd_ee_delta_pose.physx_cuda.h5 \
+    --control-mode "pd_ee_delta_pose" --sim-backend "physx_cuda" --num_demos $demos --max_episode_steps 150 \
+    --total_iters 100000 --log_freq 100 --eval_freq 5000 \
+    --exp-name=act-PushT-v1-rgb-${demos}_rl_demos-$seed \
+    --demo_type rl --track
+done

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="act",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "torchvision",
+        "diffusers",
+        "tensorboard",
+        "wandb",
+        "mani_skill"
+    ],
+    description="A minimal setup for ACT for ManiSkill",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+)

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/train.py

@@ -0,0 +1,456 @@
+ALGO_NAME = 'BC_ACT_state'
+
+import argparse
+import os
+import random
+from distutils.util import strtobool
+import time
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+import torchvision.transforms as T
+from torch.utils.tensorboard import SummaryWriter
+from act.evaluate import evaluate
+from mani_skill.utils import common, gym_utils
+from mani_skill.utils.registration import REGISTERED_ENVS
+
+from collections import defaultdict
+
+from torch.utils.data.dataset import Dataset
+from torch.utils.data.sampler import RandomSampler, BatchSampler
+from torch.utils.data.dataloader import DataLoader
+from act.utils import IterationBasedBatchSampler, worker_init_fn
+from act.make_env import make_eval_envs
+from diffusers.training_utils import EMAModel
+from act.detr.transformer import build_transformer
+from act.detr.detr_vae import build_encoder, DETRVAE
+from dataclasses import dataclass, field
+from typing import Optional, List
+import tyro
+
+@dataclass
+class Args:
+    exp_name: Optional[str] = None
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "ManiSkill"
+    """the wandb's project name"""
+    wandb_entity: Optional[str] = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = True
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    env_id: str = "PickCube-v1"
+    """the id of the environment"""
+    demo_path: str = 'pickcube.trajectory.state.pd_joint_delta_pos.cpu.h5'
+    """the path of demo dataset (pkl or h5)"""
+    num_demos: Optional[int] = None
+    """number of trajectories to load from the demo dataset"""
+    total_iters: int = 1_000_000
+    """total timesteps of the experiment"""
+    batch_size: int = 1024
+    """the batch size of sample from the replay memory"""
+
+    # ACT specific arguments
+    lr: float = 1e-4
+    """the learning rate of the Action Chunking with Transformers"""
+    kl_weight: float = 10
+    """weight for the kl loss term"""
+    temporal_agg: bool = True
+    """if toggled, temporal ensembling will be performed"""
+
+    # Backbone
+    position_embedding: str = 'sine'
+    backbone: str = 'resnet18'
+    lr_backbone: float = 1e-5
+    masks: bool = False
+    dilation: bool = False
+
+    # Transformer
+    enc_layers: int = 2
+    dec_layers: int = 4
+    dim_feedforward: int = 512
+    hidden_dim: int = 256
+    dropout: float = 0.1
+    nheads: int = 4
+    num_queries: int = 30
+    pre_norm: bool = False
+
+    # Environment/experiment specific arguments
+    max_episode_steps: Optional[int] = None
+    """Change the environments' max_episode_steps to this value. Sometimes necessary if the demonstrations being imitated are too short. Typically the default
+    max episode steps of environments in ManiSkill are tuned lower so reinforcement learning agents can learn faster."""
+    log_freq: int = 1000
+    """the frequency of logging the training metrics"""
+    eval_freq: int = 5000
+    """the frequency of evaluating the agent on the evaluation environments"""
+    save_freq: Optional[int] = None
+    """the frequency of saving the model checkpoints. By default this is None and will only save checkpoints based on the best evaluation metrics."""
+    num_eval_episodes: int = 100
+    """the number of episodes to evaluate the agent on"""
+    num_eval_envs: int = 10
+    """the number of parallel environments to evaluate the agent on"""
+    sim_backend: str = "physx_cpu"
+    """the simulation backend to use for evaluation environments. can be "physx_cpu" or "physx_cuda" """
+    num_dataload_workers: int = 0
+    """the number of workers to use for loading the training data in the torch dataloader"""
+    control_mode: str = 'pd_joint_delta_pos'
+    """the control mode to use for the evaluation environments. Must match the control mode of the demonstration dataset."""
+
+    # additional tags/configs for logging purposes to wandb and shared comparisons with other algorithms
+    demo_type: Optional[str] = None
+
+
+class SmallDemoDataset_ACTPolicy(Dataset): # Load everything into GPU memory
+    def __init__(self, data_path, num_queries, device, num_traj):
+        if data_path[-4:] == '.pkl':
+            raise NotImplementedError()
+        else:
+            from act.utils import load_demo_dataset
+            trajectories = load_demo_dataset(data_path, num_traj=num_traj, concat=False)
+            # trajectories['observations'] is a list of np.ndarray (L+1, obs_dim)
+            # trajectories['actions'] is a list of np.ndarray (L, act_dim)
+
+        for k, v in trajectories.items():
+            for i in range(len(v)):
+                trajectories[k][i] = torch.Tensor(v[i]).to(device)
+
+        # When the robot reaches the goal state, its joints and gripper fingers need to remain stationary
+        if 'delta_pos' in args.control_mode or args.control_mode == 'base_pd_joint_vel_arm_pd_joint_vel':
+            self.pad_action_arm = torch.zeros((trajectories['actions'][0].shape[1]-1,), device=device)
+            # to make the arm stay still, we pad the action with 0 in 'delta_pos' control mode
+            # gripper action needs to be copied from the last action
+        # else:
+        #     raise NotImplementedError(f'Control Mode {args.control_mode} not supported')
+
+        self.slices = []
+        self.num_traj = len(trajectories['actions'])
+        for traj_idx in range(self.num_traj):
+            episode_len = trajectories['actions'][traj_idx].shape[0]
+            self.slices += [
+                (traj_idx, ts) for ts in range(episode_len)
+            ]
+
+        print(f"Length of Dataset: {len(self.slices)}")
+
+        self.num_queries = num_queries
+        self.trajectories = trajectories
+        self.delta_control = 'delta' in args.control_mode
+        self.norm_stats = self.get_norm_stats() if not self.delta_control else None
+
+    def __getitem__(self, index):
+        traj_idx, ts = self.slices[index]
+
+        # get observation at ts only
+        obs = self.trajectories['observations'][traj_idx][ts]
+        # get num_queries actions
+        act_seq = self.trajectories['actions'][traj_idx][ts:ts+self.num_queries]
+        action_len = act_seq.shape[0]
+
+        # Pad after the trajectory, so all the observations are utilized in training
+        if action_len < self.num_queries:
+            if 'delta_pos' in args.control_mode or args.control_mode == 'base_pd_joint_vel_arm_pd_joint_vel':
+                gripper_action = act_seq[-1, -1]
+                pad_action = torch.cat((self.pad_action_arm, gripper_action[None]), dim=0)
+                act_seq = torch.cat([act_seq, pad_action.repeat(self.num_queries-action_len, 1)], dim=0)
+                # making the robot (arm and gripper) stay still
+            elif not self.delta_control:
+                target = act_seq[-1]
+                act_seq = torch.cat([act_seq, target.repeat(self.num_queries-action_len, 1)], dim=0)
+
+        # normalize obs and act_seq
+        if not self.delta_control:
+            obs = (obs - self.norm_stats["state_mean"][0]) / self.norm_stats["state_std"][0]
+            act_seq = (act_seq - self.norm_stats["action_mean"]) / self.norm_stats["action_std"]
+
+        return {
+            'observations': obs,
+            'actions': act_seq,
+        }
+
+    def __len__(self):
+        return len(self.slices)
+
+    def get_norm_stats(self):
+        traj_idx, ts = self.slices[index]
+
+        # get observation at start_ts only
+        obs = self.trajectories['observations'][traj_idx][ts]
+        # get num_queries actions
+        act_seq = self.trajectories['actions'][traj_idx][ts:ts+self.num_queries]
+        action_len = act_seq.shape[0]
+
+        # Pad after the trajectory, so all the observations are utilized in training
+        if action_len < self.num_queries:
+            if 'delta_pos' in args.control_mode or args.control_mode == 'base_pd_joint_vel_arm_pd_joint_vel':
+                gripper_action = act_seq[-1, -1]
+                pad_action = torch.cat((self.pad_action_arm, gripper_action[None]), dim=0)
+                act_seq = torch.cat([act_seq, pad_action.repeat(self.num_queries-action_len, 1)], dim=0)
+                # making the robot (arm and gripper) stay still
+            elif not self.delta_control:
+                target = act_seq[-1]
+                act_seq = torch.cat([act_seq, target.repeat(self.num_queries-action_len, 1)], dim=0)
+
+        # normalize obs and act_seq
+        if not self.delta_control:
+            obs = (obs - self.norm_stats["state_mean"][0]) / self.norm_stats["state_std"][0]
+            act_seq = (act_seq - self.norm_stats["action_mean"]) / self.norm_stats["action_std"]
+
+        return {
+            'observations': obs,
+            'actions': act_seq,
+        }
+
+
+class Agent(nn.Module):
+    def __init__(self, env, args):
+        super().__init__()
+        assert len(env.single_observation_space.shape) == 1 # (obs_dim,)
+        assert len(env.single_action_space.shape) == 1 # (act_dim,)
+        #assert (env.single_action_space.high == 1).all() and (env.single_action_space.low == -1).all()
+
+        self.kl_weight = args.kl_weight
+        self.state_dim = env.single_observation_space.shape[0]
+        self.act_dim = env.single_action_space.shape[0]
+
+        # CNN backbone
+        backbones = None
+
+        # CVAE decoder
+        transformer = build_transformer(args)
+
+        # CVAE encoder
+        encoder = build_encoder(args)
+
+        # ACT ( CVAE encoder + (CNN backbones + CVAE decoder) )
+        self.model = DETRVAE(
+            backbones,
+            transformer,
+            encoder,
+            state_dim=self.state_dim,
+            action_dim=self.act_dim,
+            num_queries=args.num_queries,
+        )
+
+    def compute_loss(self, obs, action_seq):
+        # forward pass
+        a_hat, (mu, logvar) = self.model(obs, action_seq)
+
+        # compute l1 loss and kl loss
+        total_kld, dim_wise_kld, mean_kld = kl_divergence(mu, logvar)
+        all_l1 = F.l1_loss(action_seq, a_hat, reduction='none')
+        l1 = all_l1.mean()
+
+        # store all loss
+        loss_dict = dict()
+        loss_dict['l1'] = l1
+        loss_dict['kl'] = total_kld[0]
+        loss_dict['loss'] = loss_dict['l1'] + loss_dict['kl'] * self.kl_weight
+        return loss_dict
+
+    def get_action(self, obs):
+        # forward pass
+        a_hat, (_, _) = self.model(obs) # no action, sample from prior
+        return a_hat
+
+
+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
+
+def save_ckpt(run_name, tag):
+    os.makedirs(f'runs/{run_name}/checkpoints', exist_ok=True)
+    ema.copy_to(ema_agent.parameters())
+    torch.save({
+        'norm_stats': dataset.norm_stats,
+        'agent': agent.state_dict(),
+        'ema_agent': ema_agent.state_dict(),
+    }, f'runs/{run_name}/checkpoints/{tag}.pt')
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    if args.exp_name is None:
+        args.exp_name = os.path.basename(__file__)[: -len(".py")]
+        run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    else:
+        run_name = args.exp_name
+
+    if args.demo_path.endswith('.h5'):
+        import json
+        json_file = args.demo_path[:-2] + 'json'
+        with open(json_file, 'r') as f:
+            demo_info = json.load(f)
+            if 'control_mode' in demo_info['env_info']['env_kwargs']:
+                control_mode = demo_info['env_info']['env_kwargs']['control_mode']
+            elif 'control_mode' in demo_info['episodes'][0]:
+                control_mode = demo_info['episodes'][0]['control_mode']
+            else:
+                raise Exception('Control mode not found in json')
+            assert control_mode == args.control_mode, f"Control mode mismatched. Dataset has control mode {control_mode}, but args has control mode {args.control_mode}"
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    env_kwargs = dict(control_mode=args.control_mode, reward_mode="sparse", obs_mode="state", render_mode="rgb_array")
+    if args.max_episode_steps is not None:
+        env_kwargs["max_episode_steps"] = args.max_episode_steps
+    other_kwargs = None
+    envs = make_eval_envs(args.env_id, args.num_eval_envs, args.sim_backend, env_kwargs, other_kwargs, video_dir=f'runs/{run_name}/videos' if args.capture_video else None)
+
+    # dataloader setup
+    dataset = SmallDemoDataset_ACTPolicy(args.demo_path, args.num_queries, device, num_traj=args.num_demos)
+    sampler = RandomSampler(dataset, replacement=False)
+    batch_sampler = BatchSampler(sampler, batch_size=args.batch_size, drop_last=True)
+    batch_sampler = IterationBasedBatchSampler(batch_sampler, args.total_iters)
+    train_dataloader = DataLoader(
+        dataset,
+        batch_sampler=batch_sampler,
+        num_workers=args.num_dataload_workers,
+        worker_init_fn=lambda worker_id: worker_init_fn(worker_id, base_seed=args.seed),
+    )
+    if args.num_demos is None:
+        args.num_demos = dataset.num_traj
+
+    if args.track:
+        import wandb
+        config = vars(args)
+        config["eval_env_cfg"] = dict(**env_kwargs, num_envs=args.num_eval_envs, env_id=args.env_id, env_horizon=args.max_episode_steps)
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=config,
+            name=run_name,
+            save_code=True,
+            group="ACT",
+            tags=["act"]
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # agent setup
+    agent = Agent(envs, args).to(device)
+
+    # optimizer setup
+    param_dicts = [
+        {"params": [p for n, p in agent.named_parameters() if "backbone" not in n and p.requires_grad]},
+        {
+            "params": [p for n, p in agent.named_parameters() if "backbone" in n and p.requires_grad],
+            "lr": args.lr_backbone,
+        },
+    ]
+    optimizer = optim.AdamW(param_dicts, lr=args.lr, weight_decay=1e-4)
+
+    # LR drop by a factor of 10 after lr_drop iters
+    lr_drop = int((2/3)*args.total_iters)
+    lr_scheduler = optim.lr_scheduler.StepLR(optimizer, lr_drop)
+
+    # Exponential Moving Average
+    # accelerates training and improves stability
+    # holds a copy of the model weights
+    ema = EMAModel(parameters=agent.parameters(), power=0.75)
+    ema_agent = Agent(envs, args).to(device)
+
+    # Evaluation
+    #eval_kwargs = dict(
+    #    stats=dataset.norm_stats, num_queries=args.num_queries, temporal_agg=args.temporal_agg,
+    #    max_timesteps=gym_utils.find_max_episode_steps_value(envs), device=device, sim_backend=args.sim_backend
+    #)
+    eval_kwargs = dict(
+        stats=dataset.norm_stats, num_queries=args.num_queries, temporal_agg=args.temporal_agg,
+        max_timesteps=args.max_episode_steps, device=device, sim_backend=args.sim_backend
+    )
+
+    # ---------------------------------------------------------------------------- #
+    # Training begins.
+    # ---------------------------------------------------------------------------- #
+    print("Training begins...")
+    agent.train()
+
+    best_eval_metrics = defaultdict(float)
+    timings = defaultdict(float)
+
+    for cur_iter, data_batch in enumerate(train_dataloader):
+        last_tick = time.time()
+        # forward and compute loss
+        loss_dict = agent.compute_loss(
+            obs=data_batch['observations'],  # (B, obs_dim)
+            action_seq=data_batch['actions'],  # (B, num_queries, act_dim)
+        )
+        total_loss = loss_dict['loss']  # total_loss = l1 + kl * self.kl_weight
+
+        # backward
+        optimizer.zero_grad()
+        total_loss.backward()
+        optimizer.step()
+        lr_scheduler.step() # step lr scheduler every batch, this is different from standard pytorch behavior
+
+        # update Exponential Moving Average of the model weights
+        ema.step(agent.parameters())
+        timings["update"] += time.time() - last_tick
+
+        # Evaluation
+        if cur_iter % args.eval_freq == 0:
+            last_tick = time.time()
+
+            ema.copy_to(ema_agent.parameters())
+
+            eval_metrics = evaluate(args.num_eval_episodes, ema_agent, envs, eval_kwargs)
+            timings["eval"] += time.time() - last_tick
+
+
+            print(f"Evaluated {len(eval_metrics['success_at_end'])} episodes")
+            for k in eval_metrics.keys():
+                eval_metrics[k] = np.mean(eval_metrics[k])
+                writer.add_scalar(f"eval/{k}", eval_metrics[k], cur_iter)
+                print(f"{k}: {eval_metrics[k]:.4f}")
+
+            save_on_best_metrics = ["success_once", "success_at_end"]
+            for k in save_on_best_metrics:
+                if k in eval_metrics and eval_metrics[k] > best_eval_metrics[k]:
+                    best_eval_metrics[k] = eval_metrics[k]
+                    save_ckpt(run_name, f"best_eval_{k}")
+                    print(f'New best {k}_rate: {eval_metrics[k]:.4f}. Saving checkpoint.')
+
+        if cur_iter % args.log_freq == 0:
+            print(f"Iteration {cur_iter}, loss: {total_loss.item()}")
+            writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], cur_iter)
+            writer.add_scalar("losses/total_loss", total_loss.item(), cur_iter)
+            for k, v in timings.items():
+                writer.add_scalar(f"time/{k}", v, cur_iter)
+        # Checkpoint
+        if args.save_freq is not None and cur_iter % args.save_freq == 0:
+            save_ckpt(run_name, str(cur_iter))
+
+    envs.close()
+    writer.close()

project/ManiSkill3/src/maniskill3_environment/examples/baselines/act/train_rgbd.py

@@ -0,0 +1,612 @@
+ALGO_NAME = 'BC_ACT_rgbd'
+
+import argparse
+import os
+import random
+from distutils.util import strtobool
+from functools import partial
+import time
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+import torchvision.transforms as T
+from torch.utils.tensorboard import SummaryWriter
+from act.evaluate import evaluate
+from mani_skill.envs.sapien_env import BaseEnv
+from mani_skill.utils import common, gym_utils
+from mani_skill.utils.registration import REGISTERED_ENVS
+
+from collections import defaultdict
+
+from torch.utils.data.dataset import Dataset
+from torch.utils.data.sampler import RandomSampler, BatchSampler
+from torch.utils.data.dataloader import DataLoader
+from act.utils import IterationBasedBatchSampler, worker_init_fn
+from act.make_env import make_eval_envs
+from diffusers.training_utils import EMAModel
+from act.detr.backbone import build_backbone
+from act.detr.transformer import build_transformer
+from act.detr.detr_vae import build_encoder, DETRVAE
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict
+import tyro
+
+@dataclass
+class Args:
+    exp_name: Optional[str] = None
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "ManiSkill"
+    """the wandb's project name"""
+    wandb_entity: Optional[str] = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = True
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    env_id: str = "PickCube-v1"
+    """the id of the environment"""
+    demo_path: str = 'pickcube.trajectory.rgbd.pd_joint_delta_pos.cpu.h5'
+    """the path of demo dataset (pkl or h5)"""
+    num_demos: Optional[int] = None
+    """number of trajectories to load from the demo dataset"""
+    total_iters: int = 1_000_000
+    """total timesteps of the experiment"""
+    batch_size: int = 256
+    """the batch size of sample from the replay memory"""
+
+    # ACT specific arguments
+    lr: float = 1e-4
+    """the learning rate of the Action Chunking with Transformers"""
+    kl_weight: float = 10
+    """weight for the kl loss term"""
+    temporal_agg: bool = True
+    """if toggled, temporal ensembling will be performed"""
+
+    # Backbone
+    position_embedding: str = 'sine'
+    backbone: str = 'resnet18'
+    lr_backbone: float = 1e-5
+    masks: bool = False
+    dilation: bool = False
+    include_depth: bool = True
+
+    # Transformer
+    enc_layers: int = 2
+    dec_layers: int = 4
+    dim_feedforward: int = 512
+    hidden_dim: int = 256
+    dropout: float = 0.1
+    nheads: int = 8
+    num_queries: int = 30
+    pre_norm: bool = False
+
+    # Environment/experiment specific arguments
+    max_episode_steps: Optional[int] = None
+    """Change the environments' max_episode_steps to this value. Sometimes necessary if the demonstrations being imitated are too short. Typically the default
+    max episode steps of environments in ManiSkill are tuned lower so reinforcement learning agents can learn faster."""
+    log_freq: int = 1000
+    """the frequency of logging the training metrics"""
+    eval_freq: int = 5000
+    """the frequency of evaluating the agent on the evaluation environments"""
+    save_freq: Optional[int] = None
+    """the frequency of saving the model checkpoints. By default this is None and will only save checkpoints based on the best evaluation metrics."""
+    num_eval_episodes: int = 100
+    """the number of episodes to evaluate the agent on"""
+    num_eval_envs: int = 10
+    """the number of parallel environments to evaluate the agent on"""
+    sim_backend: str = "cpu"
+    """the simulation backend to use for evaluation environments. can be "cpu" or "gpu"""
+    num_dataload_workers: int = 0
+    """the number of workers to use for loading the training data in the torch dataloader"""
+    control_mode: str = 'pd_joint_delta_pos'
+    """the control mode to use for the evaluation environments. Must match the control mode of the demonstration dataset."""
+
+    # additional tags/configs for logging purposes to wandb and shared comparisons with other algorithms
+    demo_type: Optional[str] = None
+
+
+class FlattenRGBDObservationWrapper(gym.ObservationWrapper):
+    """
+    Flattens the rgbd mode observations into a dictionary with two keys, "rgbd" and "state"
+
+    Args:
+        rgb (bool): Whether to include rgb images in the observation
+        depth (bool): Whether to include depth images in the observation
+        state (bool): Whether to include state data in the observation
+
+    Note that the returned observations will have a "rgbd" or "rgb" or "depth" key depending on the rgb/depth bool flags.
+    """
+
+    def __init__(self, env, rgb=True, depth=True, state=True) -> None:
+        self.base_env: BaseEnv = env.unwrapped
+        super().__init__(env)
+        self.include_rgb = rgb
+        self.include_depth = depth
+        self.include_state = state
+        self.transforms = T.Compose(
+            [
+                T.Resize((224, 224), antialias=True),
+            ]
+        )  # resize the input image to be at least 224x224
+        new_obs = self.observation(self.base_env._init_raw_obs)
+        self.base_env.update_obs_space(new_obs)
+
+    def observation(self, observation: Dict):
+        sensor_data = observation.pop("sensor_data")
+        del observation["sensor_param"]
+        images_rgb = []
+        images_depth = []
+        for cam_data in sensor_data.values():
+            if self.include_rgb:
+                resized_rgb = self.transforms(
+                    cam_data["rgb"].permute(0, 3, 1, 2)
+                )  # (1, 3, 224, 224)
+                images_rgb.append(resized_rgb)
+            if self.include_depth:
+                depth = (cam_data["depth"].to(torch.float32) / 1024).to(torch.float16)
+                resized_depth = self.transforms(
+                    depth.permute(0, 3, 1, 2)
+                )  # (1, 1, 224, 224)
+                images_depth.append(resized_depth)
+
+        rgb = torch.stack(images_rgb, dim=1) # (1, num_cams, C, 224, 224), uint8
+        if self.include_depth:
+            depth = torch.stack(images_depth, dim=1) # (1, num_cams, C, 224, 224), float16
+
+        # flatten the rest of the data which should just be state data
+        observation = common.flatten_state_dict(observation, use_torch=True)
+        ret = dict()
+        if self.include_state:
+            ret["state"] = observation
+        if self.include_rgb and not self.include_depth:
+            ret["rgb"] = rgb
+        elif self.include_rgb and self.include_depth:
+            ret["rgb"] = rgb
+            ret["depth"] = depth
+        elif self.include_depth and not self.include_rgb:
+            ret["depth"] = depth
+        return ret
+
+
+class SmallDemoDataset_ACTPolicy(Dataset): # Load everything into memory
+    def __init__(self, data_path, num_queries, num_traj, include_depth=True):
+        if data_path[-4:] == '.pkl':
+            raise NotImplementedError()
+        else:
+            from act.utils import load_demo_dataset
+            trajectories = load_demo_dataset(data_path, num_traj=num_traj, concat=False)
+            # trajectories['observations'] is a list of np.ndarray (L+1, obs_dim)
+            # trajectories['actions'] is a list of np.ndarray (L, act_dim)
+        print('Raw trajectory loaded, start to pre-process the observations...')
+
+        self.include_depth = include_depth
+        self.transforms = T.Compose(
+            [
+                T.Resize((224, 224), antialias=True),
+            ]
+        )  # pre-trained models from torchvision.models expect input image to be at least 224x224
+
+        # Pre-process the observations, make them align with the obs returned by the FlattenRGBDObservationWrapper
+        obs_traj_dict_list = []
+        for obs_traj_dict in trajectories['observations']:
+            obs_traj_dict = self.process_obs(obs_traj_dict)
+            obs_traj_dict_list.append(obs_traj_dict)
+        trajectories['observations'] = obs_traj_dict_list
+        self.obs_keys = list(obs_traj_dict.keys())
+
+        # Pre-process the actions
+        for i in range(len(trajectories['actions'])):
+            trajectories['actions'][i] = torch.Tensor(trajectories['actions'][i])
+        print('Obs/action pre-processing is done.')
+
+        # When the robot reaches the goal state, its joints and gripper fingers need to remain stationary
+        if 'delta_pos' in args.control_mode or args.control_mode == 'base_pd_joint_vel_arm_pd_joint_vel':
+            self.pad_action_arm = torch.zeros((trajectories['actions'][0].shape[1]-1,))
+            # to make the arm stay still, we pad the action with 0 in 'delta_pos' control mode
+            # gripper action needs to be copied from the last action
+        # else:
+        #     raise NotImplementedError(f'Control Mode {args.control_mode} not supported')
+
+        self.slices = []
+        self.num_traj = len(trajectories['actions'])
+        for traj_idx in range(self.num_traj):
+            episode_len = trajectories['actions'][traj_idx].shape[0]
+            self.slices += [
+                (traj_idx, ts) for ts in range(episode_len)
+            ]
+
+        print(f"Length of Dataset: {len(self.slices)}")
+
+        self.num_queries = num_queries
+        self.trajectories = trajectories
+        self.delta_control = 'delta' in args.control_mode
+        self.norm_stats = self.get_norm_stats() if not self.delta_control else None
+
+    def __getitem__(self, index):
+        traj_idx, ts = self.slices[index]
+
+        # get state at start_ts only
+        state = self.trajectories['observations'][traj_idx]['state'][ts]
+        # get num_queries actions
+        act_seq = self.trajectories['actions'][traj_idx][ts:ts+self.num_queries]
+        action_len = act_seq.shape[0]
+
+        # Pad after the trajectory, so all the observations are utilized in training
+        if action_len < self.num_queries:
+            if 'delta_pos' in args.control_mode or args.control_mode == 'base_pd_joint_vel_arm_pd_joint_vel':
+                gripper_action = act_seq[-1, -1]
+                pad_action = torch.cat((self.pad_action_arm, gripper_action[None]), dim=0)
+                act_seq = torch.cat([act_seq, pad_action.repeat(self.num_queries-action_len, 1)], dim=0)
+                # making the robot (arm and gripper) stay still
+            elif not self.delta_control:
+                target = act_seq[-1]
+                act_seq = torch.cat([act_seq, target.repeat(self.num_queries-action_len, 1)], dim=0)
+
+        # normalize state and act_seq
+        if not self.delta_control:
+            state = (state - self.norm_stats["state_mean"][0]) / self.norm_stats["state_std"][0]
+            act_seq = (act_seq - self.norm_stats["action_mean"]) / self.norm_stats["action_std"]
+
+        # get rgb or rgbd data at start_ts and combine with state to form obs
+        if self.include_depth:
+            rgb = self.trajectories['observations'][traj_idx]['rgb'][ts]
+            depth = self.trajectories['observations'][traj_idx]['depth'][ts]
+            obs = dict(state=state, rgb=rgb, depth=depth)
+        else:
+            rgb = self.trajectories['observations'][traj_idx]['rgb'][ts]
+            obs = dict(state=state, rgb=rgb)
+
+        return {
+            'observations': obs,
+            'actions': act_seq,
+        }
+
+    def __len__(self):
+        return len(self.slices)
+
+    def process_obs(self, obs_dict):
+        # get rgbd data
+        sensor_data = obs_dict.pop("sensor_data")
+        del obs_dict["sensor_param"]
+        images_rgb = []
+        images_depth = []
+        for cam_data in sensor_data.values():
+            rgb = torch.from_numpy(cam_data["rgb"]) # (ep_len, H, W, 3)
+            resized_rgb = self.transforms(
+                rgb.permute(0, 3, 1, 2)
+            )  # (ep_len, 3, 224, 224); pre-trained models from torchvision.models expect input image to be at least 224x224
+            images_rgb.append(resized_rgb)
+            if self.include_depth:
+                depth = torch.Tensor(cam_data["depth"].astype(np.float32) / 1024).to(torch.float16) # (ep_len, H, W, 1)
+                resized_depth = self.transforms(
+                    depth.permute(0, 3, 1, 2)
+                )  # (ep_len, 1, 224, 224); pre-trained models from torchvision.models expect input image to be at least 224x224
+                images_depth.append(resized_depth)
+        rgb = torch.stack(images_rgb, dim=1) # (ep_len, num_cams, 3, 224, 224) # still uint8
+        if self.include_depth:
+            depth = torch.stack(images_depth, dim=1) # (ep_len, num_cams, 1, 224, 224) # float16
+
+        # flatten the rest of the data which should just be state data
+        obs_dict['extra'] = {k: v[:, None] if len(v.shape) == 1 else v for k, v in obs_dict['extra'].items()} # dirty fix for data that has one dimension (e.g. is_grasped)
+        obs_dict = common.flatten_state_dict(obs_dict, use_torch=True)
+
+        processed_obs = dict(state=obs_dict, rgb=rgb, depth=depth) if self.include_depth else dict(state=obs_dict, rgb=rgb)
+
+        return processed_obs
+
+    def get_norm_stats(self):
+        all_state_data = []
+        all_action_data = []
+        for traj_idx, ts in self.slices:
+            state = self.trajectories['observations'][traj_idx]['state'][ts]
+            act_seq = self.trajectories['actions'][traj_idx][ts:ts+self.num_queries]
+            action_len = act_seq.shape[0]
+            if action_len < self.num_queries:
+                target_pos = act_seq[-1]
+                act_seq = torch.cat([act_seq, target_pos.repeat(self.num_queries-action_len, 1)], dim=0)
+            all_state_data.append(state)
+            all_action_data.append(act_seq)
+
+        all_state_data = torch.stack(all_state_data)
+        all_action_data = torch.concatenate(all_action_data)
+
+        # normalize obs (state) data
+        state_mean = all_state_data.mean(dim=0, keepdim=True)
+        state_std = all_state_data.std(dim=0, keepdim=True)
+        state_std = torch.clip(state_std, 1e-2, np.inf) # clipping
+
+        # normalize action data
+        action_mean = all_action_data.mean(dim=0, keepdim=True)
+        action_std = all_action_data.std(dim=0, keepdim=True)
+        action_std = torch.clip(action_std, 1e-2, np.inf) # clipping
+
+        stats = {"action_mean": action_mean, "action_std": action_std,
+                 "state_mean": state_mean, "state_std": state_std,
+                 "example_state": state}
+
+        return stats
+
+
+class Agent(nn.Module):
+    def __init__(self, env, args):
+        super().__init__()
+        assert len(env.single_observation_space['state'].shape) == 1 # (obs_dim,)
+        assert len(env.single_observation_space['rgb'].shape) == 4 # (num_cams, C, H, W)
+        assert len(env.single_action_space.shape) == 1 # (act_dim,)
+        #assert (env.single_action_space.high == 1).all() and (env.single_action_space.low == -1).all()
+
+        self.state_dim = env.single_observation_space['state'].shape[0]
+        self.act_dim = env.single_action_space.shape[0]
+        self.kl_weight = args.kl_weight
+        self.normalize = T.Normalize(mean=[0.485, 0.456, 0.406],
+                                     std=[0.229, 0.224, 0.225])
+
+        # CNN backbone
+        backbones = []
+        backbone = build_backbone(args)
+        backbones.append(backbone)
+
+        # CVAE decoder
+        transformer = build_transformer(args)
+
+        # CVAE encoder
+        encoder = build_encoder(args)
+
+        # ACT ( CVAE encoder + (CNN backbones + CVAE decoder) )
+        self.model = DETRVAE(
+            backbones,
+            transformer,
+            encoder,
+            state_dim=self.state_dim,
+            action_dim=self.act_dim,
+            num_queries=args.num_queries,
+        )
+
+    def compute_loss(self, obs, action_seq):
+        # normalize rgb data
+        obs['rgb'] = obs['rgb'].float() / 255.0
+        obs['rgb'] = self.normalize(obs['rgb'])
+
+        # depth data
+        if args.include_depth:
+            obs['depth'] = obs['depth'].float()
+
+        # forward pass
+        a_hat, (mu, logvar) = self.model(obs, action_seq)
+
+        # compute l1 loss and kl loss
+        total_kld, dim_wise_kld, mean_kld = kl_divergence(mu, logvar)
+        all_l1 = F.l1_loss(action_seq, a_hat, reduction='none')
+        l1 = all_l1.mean()
+
+        # store all loss
+        loss_dict = dict()
+        loss_dict['l1'] = l1
+        loss_dict['kl'] = total_kld[0]
+        loss_dict['loss'] = loss_dict['l1'] + loss_dict['kl'] * self.kl_weight
+        return loss_dict
+
+    def get_action(self, obs):
+        # normalize rgb data
+        obs['rgb'] = obs['rgb'].float() / 255.0
+        obs['rgb'] = self.normalize(obs['rgb'])
+
+        # depth data
+        if args.include_depth:
+            obs['depth'] = obs['depth'].float()
+
+        # forward pass
+        a_hat, (_, _) = self.model(obs) # no action, sample from prior
+
+        return a_hat
+
+
+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
+
+def save_ckpt(run_name, tag):
+    os.makedirs(f'runs/{run_name}/checkpoints', exist_ok=True)
+    ema.copy_to(ema_agent.parameters())
+    torch.save({
+        'norm_stats': dataset.norm_stats,
+        'agent': agent.state_dict(),
+        'ema_agent': ema_agent.state_dict(),
+    }, f'runs/{run_name}/checkpoints/{tag}.pt')
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+
+    if args.exp_name is None:
+        args.exp_name = os.path.basename(__file__)[: -len(".py")]
+        run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    else:
+        run_name = args.exp_name
+
+    if args.demo_path.endswith('.h5'):
+        import json
+        json_file = args.demo_path[:-2] + 'json'
+        with open(json_file, 'r') as f:
+            demo_info = json.load(f)
+            if 'control_mode' in demo_info['env_info']['env_kwargs']:
+                control_mode = demo_info['env_info']['env_kwargs']['control_mode']
+            elif 'control_mode' in demo_info['episodes'][0]:
+                control_mode = demo_info['episodes'][0]['control_mode']
+            else:
+                raise Exception('Control mode not found in json')
+            assert control_mode == args.control_mode, f"Control mode mismatched. Dataset has control mode {control_mode}, but args has control mode {args.control_mode}"
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    env_kwargs = dict(control_mode=args.control_mode, reward_mode="sparse", obs_mode="rgbd" if args.include_depth else "rgb", render_mode="rgb_array")
+    if args.max_episode_steps is not None:
+        env_kwargs["max_episode_steps"] = args.max_episode_steps
+    other_kwargs = None
+    wrappers = [partial(FlattenRGBDObservationWrapper, depth=args.include_depth)]
+    envs = make_eval_envs(args.env_id, args.num_eval_envs, args.sim_backend, env_kwargs, other_kwargs, video_dir=f'runs/{run_name}/videos' if args.capture_video else None, wrappers=wrappers)
+
+    # dataloader setup
+    dataset = SmallDemoDataset_ACTPolicy(args.demo_path, args.num_queries, num_traj=args.num_demos, include_depth=args.include_depth)
+    sampler = RandomSampler(dataset, replacement=False)
+    batch_sampler = BatchSampler(sampler, batch_size=args.batch_size, drop_last=True)
+    batch_sampler = IterationBasedBatchSampler(batch_sampler, args.total_iters)
+    train_dataloader = DataLoader(
+        dataset,
+        batch_sampler=batch_sampler,
+        num_workers=args.num_dataload_workers,
+        worker_init_fn=lambda worker_id: worker_init_fn(worker_id, base_seed=args.seed),
+    )
+    if args.num_demos is None:
+        args.num_demos = dataset.num_traj
+
+    obs_mode = "rgb+depth" if args.include_depth else "rgb"
+
+    if args.track:
+        import wandb
+        config = vars(args)
+        config["eval_env_cfg"] = dict(**env_kwargs, num_envs=args.num_eval_envs, env_id=args.env_id, env_horizon=args.max_episode_steps)
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=config,
+            name=run_name,
+            save_code=True,
+            group="ACT",
+            tags=["act"]
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # agent setup
+    agent = Agent(envs, args).to(device)
+
+    # optimizer setup
+    param_dicts = [
+        {"params": [p for n, p in agent.named_parameters() if "backbone" not in n and p.requires_grad]},
+        {
+            "params": [p for n, p in agent.named_parameters() if "backbone" in n and p.requires_grad],
+            "lr": args.lr_backbone,
+        },
+    ]
+    optimizer = optim.AdamW(param_dicts, lr=args.lr, weight_decay=1e-4)
+
+    # LR drop by a factor of 10 after lr_drop iters
+    lr_drop = int((2/3)*args.total_iters)
+    lr_scheduler = optim.lr_scheduler.StepLR(optimizer, lr_drop)
+
+    # Exponential Moving Average
+    # accelerates training and improves stability
+    # holds a copy of the model weights
+    ema = EMAModel(parameters=agent.parameters(), power=0.75)
+    ema_agent = Agent(envs, args).to(device)
+
+    # Evaluation
+    #eval_kwargs = dict(
+    #    stats=dataset.norm_stats, num_queries=args.num_queries, temporal_agg=args.temporal_agg,
+    #    max_timesteps=gym_utils.find_max_episode_steps_value(envs), device=device, sim_backend=args.sim_backend
+    #)
+    eval_kwargs = dict(
+        stats=dataset.norm_stats, num_queries=args.num_queries, temporal_agg=args.temporal_agg,
+        max_timesteps=args.max_episode_steps, device=device, sim_backend=args.sim_backend
+    )
+
+    # ---------------------------------------------------------------------------- #
+    # Training begins.
+    # ---------------------------------------------------------------------------- #
+    agent.train()
+
+    best_eval_metrics = defaultdict(float)
+    timings = defaultdict(float)
+
+    for cur_iter, data_batch in enumerate(train_dataloader):
+        last_tick = time.time()
+        # copy data from cpu to gpu
+        obs_batch_dict = data_batch['observations']
+        obs_batch_dict = {k: v.cuda(non_blocking=True) for k, v in obs_batch_dict.items()}
+        act_batch = data_batch['actions'].cuda(non_blocking=True)
+
+        # forward and compute loss
+        loss_dict = agent.compute_loss(
+            obs=obs_batch_dict, # obs_batch_dict['state'] is (B, obs_dim)
+            action_seq=act_batch, # (B, num_queries, act_dim)
+        )
+        total_loss = loss_dict['loss']  # total_loss = l1 + kl * self.kl_weight
+
+        # backward
+        optimizer.zero_grad()
+        total_loss.backward()
+        optimizer.step()
+        lr_scheduler.step() # step lr scheduler every batch, this is different from standard pytorch behavior
+
+        # update Exponential Moving Average of the model weights
+        ema.step(agent.parameters())
+        timings["update"] += time.time() - last_tick
+
+        # Evaluation
+        if cur_iter % args.eval_freq == 0:
+            last_tick = time.time()
+
+            ema.copy_to(ema_agent.parameters())
+
+            eval_metrics = evaluate(args.num_eval_episodes, ema_agent, envs, eval_kwargs)
+            timings["eval"] += time.time() - last_tick
+
+            print(f"Evaluated {len(eval_metrics['success_at_end'])} episodes")
+            for k in eval_metrics.keys():
+                eval_metrics[k] = np.mean(eval_metrics[k])
+                writer.add_scalar(f"eval/{k}", eval_metrics[k], cur_iter)
+                print(f"{k}: {eval_metrics[k]:.4f}")
+
+            save_on_best_metrics = ["success_once", "success_at_end"]
+            for k in save_on_best_metrics:
+                if k in eval_metrics and eval_metrics[k] > best_eval_metrics[k]:
+                    best_eval_metrics[k] = eval_metrics[k]
+                    save_ckpt(run_name, f"best_eval_{k}")
+                    print(f'New best {k}_rate: {eval_metrics[k]:.4f}. Saving checkpoint.')
+
+        if cur_iter % args.log_freq == 0:
+            print(f"Iteration {cur_iter}, loss: {total_loss.item()}")
+            writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], cur_iter)
+            writer.add_scalar("charts/backbone_learning_rate", optimizer.param_groups[1]["lr"], cur_iter)
+            writer.add_scalar("losses/total_loss", total_loss.item(), cur_iter)
+            for k, v in timings.items():
+                writer.add_scalar(f"time/{k}", v, cur_iter)
+
+        # Checkpoint
+        if args.save_freq is not None and cur_iter % args.save_freq == 0:
+            save_ckpt(run_name, str(cur_iter))
+
+    envs.close()
+    writer.close()

project/ManiSkill3/src/maniskill3_environment/examples/baselines/bc/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+runs/
+wandb/
+*.egg-info/

project/ManiSkill3/src/maniskill3_environment/examples/baselines/diffusion_policy/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+runs/
+wandb/
+*.egg-info/

project/ManiSkill3/src/maniskill3_environment/examples/baselines/diffusion_policy/README.md

@@ -0,0 +1,64 @@
+# Diffusion Policy
+
+Code for running the Diffusion Policy algorithm based on ["Diffusion Policy: Visuomotor Policy Learning via Action Diffusion"](https://arxiv.org/abs/2303.04137v4). It is adapted from the [original code](https://github.com/real-stanford/diffusion_policy).
+
+## Installation
+
+To get started, we recommend using conda/mamba to create a new environment and install the dependencies
+
+```bash
+conda create -n diffusion-policy-ms python=3.9
+conda activate diffusion-policy-ms
+pip install -e .
+```
+
+## Setup
+
+Read through the [imitation learning setup documentation](https://maniskill.readthedocs.io/en/latest/user_guide/learning_from_demos/setup.html) which details everything you need to know regarding running imitation learning baselines in ManiSkill. It includes details on how to download demonstration datasets, preprocess them, evaluate policies fairly for comparison, as well as suggestions to improve performance and avoid bugs.
+
+## Training
+
+We provide scripts to train Diffusion Policy on demonstrations.
+
+Note that some demonstrations are slow (e.g. motion planning or human teleoperated) and can exceed the default max episode steps which can be an issue as imitation learning algorithms learn to solve the task at the same speed the demonstrations solve it. In this case, you can use the `--max-episode-steps` flag to set a higher value so that the policy can solve the task in time. General recommendation is to set `--max-episode-steps` to about 2x the length of the mean demonstrations length you are using for training. We have tuned baselines in the `baselines.sh` script that set a recommended `--max-episode-steps` for each task.
+
+Example state based training, learning from 100 demonstrations generated via motionplanning in the PickCube-v1 task
+
+```bash
+seed=1
+demos=100
+python train.py --env-id PickCube-v1 \
+  --demo-path ~/.maniskill/demos/PickCube-v1/motionplanning/trajectory.state.pd_ee_delta_pos.physx_cpu.h5 \
+  --control-mode "pd_ee_delta_pos" --sim-backend "physx_cpu" --num-demos ${demos} --max_episode_steps 100 \
+  --total_iters 30000 \
+  --exp-name diffusion_policy-PickCube-v1-state-${demos}_motionplanning_demos-${seed} \
+  --track # track training on wandb
+```
+
+## Citation
+
+If you use this baseline please cite the following
+```
+@inproceedings{DBLP:conf/rss/ChiFDXCBS23,
+  author       = {Cheng Chi and
+                  Siyuan Feng and
+                  Yilun Du and
+                  Zhenjia Xu and
+                  Eric Cousineau and
+                  Benjamin Burchfiel and
+                  Shuran Song},
+  editor       = {Kostas E. Bekris and
+                  Kris Hauser and
+                  Sylvia L. Herbert and
+                  Jingjin Yu},
+  title        = {Diffusion Policy: Visuomotor Policy Learning via Action Diffusion},
+  booktitle    = {Robotics: Science and Systems XIX, Daegu, Republic of Korea, July
+                  10-14, 2023},
+  year         = {2023},
+  url          = {https://doi.org/10.15607/RSS.2023.XIX.026},
+  doi          = {10.15607/RSS.2023.XIX.026},
+  timestamp    = {Mon, 29 Apr 2024 21:28:50 +0200},
+  biburl       = {https://dblp.org/rec/conf/rss/ChiFDXCBS23.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}
+```

project/ManiSkill3/src/maniskill3_environment/examples/baselines/diffusion_policy/baselines.sh

@@ -0,0 +1,78 @@
+# Baseline scripts
+
+# state based baselines
+seed=1
+demos=100
+for demo_type in "motionplanning" "rl"
+do
+  demo_path=~/.maniskill/demos/PickCube-v1/${demo_type}/trajectory.state.pd_ee_delta_pos.physx_cpu.h5
+  if [ -f "$demo_path" ]; then
+    python train.py --env-id PickCube-v1 \
+      --demo-path $demo_path \
+      --control-mode "pd_ee_delta_pos" --sim-backend "physx_cpu" --num-demos ${demos} --max_episode_steps 100 \
+      --total_iters 30000 \
+      --exp-name diffusion_policy-PickCube-v1-state-${demos}_motionplanning_demos-${seed} \
+      --demo_type=${demo_type} --track # additional tag for logging purposes on wandb
+  else
+    echo "Demo path $demo_path does not exist. Skipping PickCube-v1 for ${demo_type}."
+  fi
+
+  demo_path=~/.maniskill/demos/PushCube-v1/${demo_type}/trajectory.state.pd_ee_delta_pos.physx_cpu.h5
+  if [ -f "$demo_path" ]; then
+    python train.py --env-id PushCube-v1 \
+      --demo-path $demo_path \
+      --control-mode "pd_ee_delta_pos" --sim-backend "physx_cpu" --num-demos ${demos} --max_episode_steps 100 \
+      --total_iters 30000 \
+      --exp-name diffusion_policy-PushCube-v1-state-${demos}_motionplanning_demos-${seed} \
+      --demo_type=${demo_type} --track # additional tag for logging purposes on wandb
+  else
+    echo "Demo path $demo_path does not exist. Skipping PushCube-v1 for ${demo_type}."
+  fi
+  demo_path=~/.maniskill/demos/AnymalCReach-v1/${demo_type}/trajectory.state.pd_joint_delta_pos.physx_cuda.h5
+  if [ -f "$demo_path" ]; then
+    python train.py --env-id AnymalCReach-v1 \
+      --demo-path $demo_path \
+      --control-mode "pd_joint_delta_pos" --sim-backend "physx_cuda" --num-demos ${demos} --max_episode_steps 200 --num_eval_envs 100 \
+      --total_iters 30000 --act_horizon 1 \
+      --exp-name diffusion_policy-AnymalCReach-v1-state-${demos}_${demo_type}_demos-${seed} --no_capture_video \
+      --demo_type=${demo_type} --track # additional tag for logging purposes on wandb
+  else
+    echo "Demo path $demo_path does not exist. Skipping AnymalCReach-v1 for ${demo_type}."
+  fi
+
+  demo_path=~/.maniskill/demos/PushT-v1/${demo_type}/trajectory.state.pd_ee_delta_pose.physx_cuda.h5
+  if [ -f "$demo_path" ]; then
+    python train.py --env-id PushT-v1 \
+      --demo-path $demo_path \
+      --control-mode "pd_ee_delta_pose" --sim-backend "physx_cuda" --num-demos ${demos} --max_episode_steps 150 --num_eval_envs 100 \
+      --total_iters 50000 --act_horizon 1 \
+      --exp-name diffusion_policy-PushT-v1-state-${demos}_${demo_type}_demos-${seed} --no_capture_video \
+      --demo_type=${demo_type} --track # additional tag for logging purposes on wandb
+  else
+    echo "Demo path $demo_path does not exist. Skipping PushT-v1 for ${demo_type}."
+  fi
+
+  demo_path=~/.maniskill/demos/StackCube-v1/${demo_type}/trajectory.state.pd_ee_delta_pos.physx_cpu.h5
+  if [ -f "$demo_path" ]; then
+    python train.py --env-id StackCube-v1 \
+      --demo-path $demo_path \
+      --control-mode "pd_ee_delta_pos" --sim-backend "physx_cpu" --num-demos ${demos} --max_episode_steps 200 \
+      --total_iters 30000 \
+      --exp-name diffusion_policy-StackCube-v1-state-${demos}_${demo_type}_demos-${seed} \
+      --demo_type=${demo_type} --track # additional tag for logging purposes on wandb
+  else
+    echo "Demo path $demo_path does not exist. Skipping StackCube-v1 for ${demo_type}."
+  fi
+
+  demo_path=~/.maniskill/demos/PegInsertionSide-v1/${demo_type}/trajectory.state.pd_ee_delta_pose.physx_cpu.h5
+  if [ -f "$demo_path" ]; then
+    python train.py --env-id PegInsertionSide-v1 \
+      --demo-path $demo_path \
+      --control-mode "pd_ee_delta_pose" --sim-backend "physx_cpu" --num-demos ${demos} --max_episode_steps 300 \
+      --total_iters 100000 \
+      --exp-name diffusion_policy-PegInsertionSide-v1-state-${demos}_motionplanning_demos-${seed} \
+      --demo_type=${demo_type} --track # additional tag for logging purposes on wandb
+  else
+    echo "Demo path $demo_path does not exist. Skipping PegInsertionSide-v1 for ${demo_type}."
+  fi
+done

project/ManiSkill3/src/maniskill3_environment/examples/baselines/diffusion_policy/diffusion_policy/evaluate.py

@@ -0,0 +1,52 @@
+from collections import defaultdict
+import gymnasium
+import numpy as np
+import torch
+
+from mani_skill.utils import common
+
+def collect_episode_info(infos, result):
+    if "final_info" in infos: # infos is a dict
+
+        indices = np.where(infos["_final_info"])[0] # not all envs are done at the same time
+        for i in indices:
+            info = infos["final_info"][i] # info is also a dict
+            ep = info['episode']
+            result['return'].append(ep['r'][0])
+            result['episode_len'].append(ep["l"][0])
+            if "success" in info:
+                result['success'].append(info['success'])
+            if "fail" in info:
+                result['fail'].append(info['fail'])
+    return result
+
+def evaluate(n: int, agent, eval_envs, device, sim_backend: str):
+    agent.eval()
+    with torch.no_grad():
+        eval_metrics = defaultdict(list)
+        obs, info = eval_envs.reset()
+        eps_count = 0
+        while eps_count < n:
+            obs = common.to_tensor(obs, device)
+            action_seq = agent.get_action(obs)
+            if sim_backend == "cpu":
+                action_seq = action_seq.cpu().numpy()
+            for i in range(action_seq.shape[1]):
+                obs, rew, terminated, truncated, info = eval_envs.step(action_seq[:, i])
+                if truncated.any():
+                    break
+
+            if truncated.any():
+                assert truncated.all() == truncated.any(), "all episodes should truncate at the same time for fair evaluation with other algorithms"
+                if isinstance(info["final_info"], dict):
+                    for k, v in info["final_info"]["episode"].items():
+                        eval_metrics[k].append(v.float().cpu().numpy())
+                else:
+                    for final_info in info["final_info"]:
+                        for k, v in final_info["episode"].items():
+                            eval_metrics[k].append(v)
+                eps_count += eval_envs.num_envs
+    agent.train()
+    for k in eval_metrics.keys():
+        eval_metrics[k] = np.stack(eval_metrics[k])
+    return eval_metrics

project/ManiSkill3/src/maniskill3_environment/examples/baselines/diffusion_policy/diffusion_policy/make_env.py

@@ -0,0 +1,48 @@
+from typing import Optional
+import gymnasium as gym
+import mani_skill.envs
+from mani_skill.utils import gym_utils
+from mani_skill.vector.wrappers.gymnasium import ManiSkillVectorEnv
+from mani_skill.utils.wrappers import RecordEpisode, FrameStack, CPUGymWrapper
+
+
+def make_eval_envs(env_id, num_envs: int, sim_backend: str, env_kwargs: dict, other_kwargs: dict, video_dir: Optional[str] = None, wrappers: list[gym.Wrapper] = []):
+    """Create vectorized environment for evaluation and/or recording videos.
+    For CPU vectorized environments only the first parallel environment is used to record videos.
+    For GPU vectorized environments all parallel environments are used to record videos.
+
+    Args:
+        env_id: the environment id
+        num_envs: the number of parallel environments
+        sim_backend: the simulation backend to use. can be "cpu" or "gpu
+        env_kwargs: the environment kwargs. You can also pass in max_episode_steps in env_kwargs to override the default max episode steps for the environment.
+        video_dir: the directory to save the videos. If None no videos are recorded.
+        wrappers: the list of wrappers to apply to the environment.
+    """
+    if sim_backend == "cpu":
+        def cpu_make_env(env_id, seed, video_dir=None, env_kwargs = dict(), other_kwargs = dict()):
+            def thunk():
+                env = gym.make(env_id, reconfiguration_freq=1, **env_kwargs)
+                for wrapper in wrappers:
+                    env = wrapper(env)
+                env = CPUGymWrapper(env, ignore_terminations=True, record_metrics=True)
+                if video_dir:
+                    env = RecordEpisode(env, output_dir=video_dir, save_trajectory=False, info_on_video=True, source_type="diffusion_policy", source_desc="diffusion_policy evaluation rollout")
+                env = gym.wrappers.FrameStack(env, other_kwargs['obs_horizon'])
+                env.action_space.seed(seed)
+                env.observation_space.seed(seed)
+                return env
+
+            return thunk
+        vector_cls = gym.vector.SyncVectorEnv if num_envs == 1 else lambda x : gym.vector.AsyncVectorEnv(x, context="forkserver")
+        env = vector_cls([cpu_make_env(env_id, seed, video_dir if seed == 0 else None, env_kwargs, other_kwargs) for seed in range(num_envs)])
+    else:
+        env = gym.make(env_id, num_envs=num_envs, sim_backend=sim_backend, reconfiguration_freq=1, **env_kwargs)
+        max_episode_steps = gym_utils.find_max_episode_steps_value(env)
+        for wrapper in wrappers:
+            env = wrapper(env)
+        env = FrameStack(env, num_stack=other_kwargs['obs_horizon'])
+        if video_dir:
+            env = RecordEpisode(env, output_dir=video_dir, save_trajectory=False, save_video=True, source_type="diffusion_policy", source_desc="diffusion_policy evaluation rollout", max_steps_per_video=max_episode_steps)
+        env = ManiSkillVectorEnv(env, ignore_terminations=True, record_metrics=True)
+    return env

project/ManiSkill3/src/maniskill3_environment/examples/baselines/diffusion_policy/diffusion_policy/utils.py

@@ -0,0 +1,119 @@
+from torch.utils.data.sampler import Sampler
+import numpy as np
+import torch
+from h5py import File, Group, Dataset
+
+class IterationBasedBatchSampler(Sampler):
+    """Wraps a BatchSampler.
+    Resampling from it until a specified number of iterations have been sampled
+    References:
+        https://github.com/facebookresearch/maskrcnn-benchmark/blob/master/maskrcnn_benchmark/data/samplers/iteration_based_batch_sampler.py
+    """
+
+    def __init__(self, batch_sampler, num_iterations, start_iter=0):
+        self.batch_sampler = batch_sampler
+        self.num_iterations = num_iterations
+        self.start_iter = start_iter
+
+    def __iter__(self):
+        iteration = self.start_iter
+        while iteration < self.num_iterations:
+            # if the underlying sampler has a set_epoch method, like
+            # DistributedSampler, used for making each process see
+            # a different split of the dataset, then set it
+            if hasattr(self.batch_sampler.sampler, "set_epoch"):
+                self.batch_sampler.sampler.set_epoch(iteration)
+            for batch in self.batch_sampler:
+                yield batch
+                iteration += 1
+                if iteration >= self.num_iterations:
+                    break
+
+    def __len__(self):
+        return self.num_iterations - self.start_iter
+
+
+def worker_init_fn(worker_id, base_seed=None):
+    """The function is designed for pytorch multi-process dataloader.
+    Note that we use the pytorch random generator to generate a base_seed.
+    Please try to be consistent.
+    References:
+        https://pytorch.org/docs/stable/notes/faq.html#dataloader-workers-random-seed
+    """
+    if base_seed is None:
+        base_seed = torch.IntTensor(1).random_().item()
+    # print(worker_id, base_seed)
+    np.random.seed(base_seed + worker_id)
+
+TARGET_KEY_TO_SOURCE_KEY = {
+    'states': 'env_states',
+    'observations': 'obs',
+    'success': 'success',
+    'next_observations': 'obs',
+    # 'dones': 'dones',
+    # 'rewards': 'rewards',
+    'actions': 'actions',
+}
+def load_content_from_h5_file(file):
+    if isinstance(file, (File, Group)):
+        return {key: load_content_from_h5_file(file[key]) for key in list(file.keys())}
+    elif isinstance(file, Dataset):
+        return file[()]
+    else:
+        raise NotImplementedError(f"Unspported h5 file type: {type(file)}")
+
+def load_hdf5(path, ):
+    print('Loading HDF5 file', path)
+    file = File(path, 'r')
+    ret = load_content_from_h5_file(file)
+    file.close()
+    print('Loaded')
+    return ret
+
+def load_traj_hdf5(path, num_traj=None):
+    print('Loading HDF5 file', path)
+    file = File(path, 'r')
+    keys = list(file.keys())
+    if num_traj is not None:
+        assert num_traj <= len(keys), f"num_traj: {num_traj} > len(keys): {len(keys)}"
+        keys = sorted(keys, key=lambda x: int(x.split('_')[-1]))
+        keys = keys[:num_traj]
+    ret = {
+        key: load_content_from_h5_file(file[key]) for key in keys
+    }
+    file.close()
+    print('Loaded')
+    return ret
+def load_demo_dataset(path, keys=['observations', 'actions'], num_traj=None, concat=True):
+    # assert num_traj is None
+    raw_data = load_traj_hdf5(path, num_traj)
+    # raw_data has keys like: ['traj_0', 'traj_1', ...]
+    # raw_data['traj_0'] has keys like: ['actions', 'dones', 'env_states', 'infos', ...]
+    _traj = raw_data['traj_0']
+    for key in keys:
+        source_key = TARGET_KEY_TO_SOURCE_KEY[key]
+        assert source_key in _traj, f"key: {source_key} not in traj_0: {_traj.keys()}"
+    dataset = {}
+    for target_key in keys:
+        # if 'next' in target_key:
+        #     raise NotImplementedError('Please carefully deal with the length of trajectory')
+        source_key = TARGET_KEY_TO_SOURCE_KEY[target_key]
+        dataset[target_key] = [ raw_data[idx][source_key] for idx in raw_data ]
+        if isinstance(dataset[target_key][0], np.ndarray) and concat:
+            if target_key in ['observations', 'states'] and \
+                    len(dataset[target_key][0]) > len(raw_data['traj_0']['actions']):
+                dataset[target_key] = np.concatenate([
+                    t[:-1] for t in dataset[target_key]
+                ], axis=0)
+            elif target_key in ['next_observations', 'next_states'] and \
+                    len(dataset[target_key][0]) > len(raw_data['traj_0']['actions']):
+                dataset[target_key] = np.concatenate([
+                    t[1:] for t in dataset[target_key]
+                ], axis=0)
+            else:
+                dataset[target_key] = np.concatenate(dataset[target_key], axis=0)
+
+            print('Load', target_key, dataset[target_key].shape)
+        else:
+            print('Load', target_key, len(dataset[target_key]), type(dataset[target_key][0]))
+    return dataset

project/ManiSkill3/src/maniskill3_environment/examples/baselines/diffusion_policy/train.py

@@ -0,0 +1,418 @@
+ALGO_NAME = 'BC_Diffusion_state_UNet'
+
+import argparse
+import os
+import random
+from distutils.util import strtobool
+import time
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+from torch.utils.tensorboard import SummaryWriter
+from diffusion_policy.evaluate import evaluate
+from mani_skill.utils import gym_utils
+from mani_skill.utils.registration import REGISTERED_ENVS
+
+from collections import defaultdict
+
+from torch.utils.data.dataset import Dataset
+from torch.utils.data.sampler import RandomSampler, BatchSampler
+from torch.utils.data.dataloader import DataLoader
+from diffusion_policy.utils import IterationBasedBatchSampler, worker_init_fn
+from diffusion_policy.make_env import make_eval_envs
+from diffusers.schedulers.scheduling_ddpm import DDPMScheduler
+from diffusers.training_utils import EMAModel
+from diffusers.optimization import get_scheduler
+from diffusion_policy.conditional_unet1d import ConditionalUnet1D
+from dataclasses import dataclass, field
+from typing import Optional, List
+import tyro
+
+@dataclass
+class Args:
+    exp_name: Optional[str] = None
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "ManiSkill"
+    """the wandb's project name"""
+    wandb_entity: Optional[str] = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = True
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    env_id: str = "PegInsertionSide-v0"
+    """the id of the environment"""
+    demo_path: str = 'data/ms2_official_demos/rigid_body/PegInsertionSide-v0/trajectory.state.pd_ee_delta_pose.h5'
+    """the path of demo dataset (pkl or h5)"""
+    num_demos: Optional[int] = None
+    """number of trajectories to load from the demo dataset"""
+    total_iters: int = 1_000_000
+    """total timesteps of the experiment"""
+    batch_size: int = 1024
+    """the batch size of sample from the replay memory"""
+
+    # Diffusion Policy specific arguments
+    lr: float = 1e-4
+    """the learning rate of the diffusion policy"""
+    obs_horizon: int = 2 # Seems not very important in ManiSkill, 1, 2, 4 work well
+    act_horizon: int = 8 # Seems not very important in ManiSkill, 4, 8, 15 work well
+    pred_horizon: int = 16 # 16->8 leads to worse performance, maybe it is like generate a half image; 16->32, improvement is very marginal
+    diffusion_step_embed_dim: int = 64 # not very important
+    unet_dims: List[int] = field(default_factory=lambda: [64, 128, 256]) # default setting is about ~4.5M params
+    n_groups: int = 8 # jigu says it is better to let each group have at least 8 channels; it seems 4 and 8 are simila
+
+    # Environment/experiment specific arguments
+    max_episode_steps: Optional[int] = None
+    """Change the environments' max_episode_steps to this value. Sometimes necessary if the demonstrations being imitated are too short. Typically the default
+    max episode steps of environments in ManiSkill are tuned lower so reinforcement learning agents can learn faster."""
+    log_freq: int = 1000
+    """the frequency of logging the training metrics"""
+    eval_freq: int = 5000
+    """the frequency of evaluating the agent on the evaluation environments"""
+    save_freq: Optional[int] = None
+    """the frequency of saving the model checkpoints. By default this is None and will only save checkpoints based on the best evaluation metrics."""
+    num_eval_episodes: int = 100
+    """the number of episodes to evaluate the agent on"""
+    num_eval_envs: int = 10
+    """the number of parallel environments to evaluate the agent on"""
+    sim_backend: str = "cpu"
+    """the simulation backend to use for evaluation environments. can be "cpu" or "gpu"""
+    num_dataload_workers: int = 0
+    """the number of workers to use for loading the training data in the torch dataloader"""
+    control_mode: str = 'pd_joint_delta_pos'
+    """the control mode to use for the evaluation environments. Must match the control mode of the demonstration dataset."""
+
+    # additional tags/configs for logging purposes to wandb and shared comparisons with other algorithms
+    demo_type: Optional[str] = None
+
+
+class SmallDemoDataset_DiffusionPolicy(Dataset): # Load everything into GPU memory
+    def __init__(self, data_path, device, num_traj):
+        if data_path[-4:] == '.pkl':
+            raise NotImplementedError()
+        else:
+            from diffusion_policy.utils import load_demo_dataset
+            trajectories = load_demo_dataset(data_path, num_traj=num_traj, concat=False)
+            # trajectories['observations'] is a list of np.ndarray (L+1, obs_dim)
+            # trajectories['actions'] is a list of np.ndarray (L, act_dim)
+
+        for k, v in trajectories.items():
+            for i in range(len(v)):
+                trajectories[k][i] = torch.Tensor(v[i]).to(device)
+
+        # Pre-compute all possible (traj_idx, start, end) tuples, this is very specific to Diffusion Policy
+        if 'delta_pos' in args.control_mode or args.control_mode == 'base_pd_joint_vel_arm_pd_joint_vel':
+            self.pad_action_arm = torch.zeros((trajectories['actions'][0].shape[1]-1,), device=device)
+            # to make the arm stay still, we pad the action with 0 in 'delta_pos' control mode
+            # gripper action needs to be copied from the last action
+        # else:
+        #     raise NotImplementedError(f'Control Mode {args.control_mode} not supported')
+        self.obs_horizon, self.pred_horizon = obs_horizon, pred_horizon = args.obs_horizon, args.pred_horizon
+        self.slices = []
+        num_traj = len(trajectories['actions'])
+        total_transitions = 0
+        for traj_idx in range(num_traj):
+            L = trajectories['actions'][traj_idx].shape[0]
+            assert trajectories['observations'][traj_idx].shape[0] == L + 1
+            total_transitions += L
+
+            # |o|o|                             observations: 2
+            # | |a|a|a|a|a|a|a|a|               actions executed: 8
+            # |p|p|p|p|p|p|p|p|p|p|p|p|p|p|p|p| actions predicted: 16
+            pad_before = obs_horizon - 1
+            # Pad before the trajectory, so the first action of an episode is in "actions executed"
+            # obs_horizon - 1 is the number of "not used actions"
+            pad_after = pred_horizon - obs_horizon
+            # Pad after the trajectory, so all the observations are utilized in training
+            # Note that in the original code, pad_after = act_horizon - 1, but I think this is not the best choice
+            self.slices += [
+                (traj_idx, start, start + pred_horizon) for start in range(-pad_before, L - pred_horizon + pad_after)
+            ]  # slice indices follow convention [start, end)
+
+        print(f"Total transitions: {total_transitions}, Total obs sequences: {len(self.slices)}")
+
+        self.trajectories = trajectories
+
+    def __getitem__(self, index):
+        traj_idx, start, end = self.slices[index]
+        L, act_dim = self.trajectories['actions'][traj_idx].shape
+
+        obs_seq = self.trajectories['observations'][traj_idx][max(0, start):start+self.obs_horizon]
+        # start+self.obs_horizon is at least 1
+        act_seq = self.trajectories['actions'][traj_idx][max(0, start):end]
+        if start < 0: # pad before the trajectory
+            obs_seq = torch.cat([obs_seq[0].repeat(-start, 1), obs_seq], dim=0)
+            act_seq = torch.cat([act_seq[0].repeat(-start, 1), act_seq], dim=0)
+        if end > L: # pad after the trajectory
+            gripper_action = act_seq[-1, -1]
+            pad_action = torch.cat((self.pad_action_arm, gripper_action[None]), dim=0)
+            act_seq = torch.cat([act_seq, pad_action.repeat(end-L, 1)], dim=0)
+            # making the robot (arm and gripper) stay still
+        assert obs_seq.shape[0] == self.obs_horizon and act_seq.shape[0] == self.pred_horizon
+        return {
+            'observations': obs_seq,
+            'actions': act_seq,
+        }
+
+    def __len__(self):
+        return len(self.slices)
+
+
+class Agent(nn.Module):
+    def __init__(self, env, args):
+        super().__init__()
+        self.obs_horizon = args.obs_horizon
+        self.act_horizon = args.act_horizon
+        self.pred_horizon = args.pred_horizon
+        assert len(env.single_observation_space.shape) == 2 # (obs_horizon, obs_dim)
+        assert len(env.single_action_space.shape) == 1 # (act_dim, )
+        assert (env.single_action_space.high == 1).all() and (env.single_action_space.low == -1).all()
+        # denoising results will be clipped to [-1,1], so the action should be in [-1,1] as well
+        self.act_dim = env.single_action_space.shape[0]
+
+        self.noise_pred_net = ConditionalUnet1D(
+            input_dim=self.act_dim, # act_horizon is not used (U-Net doesn't care)
+            global_cond_dim=np.prod(env.single_observation_space.shape), # obs_horizon * obs_dim
+            diffusion_step_embed_dim=args.diffusion_step_embed_dim,
+            down_dims=args.unet_dims,
+            n_groups=args.n_groups,
+        )
+        self.num_diffusion_iters = 100
+        self.noise_scheduler = DDPMScheduler(
+            num_train_timesteps=self.num_diffusion_iters,
+            beta_schedule='squaredcos_cap_v2', # has big impact on performance, try not to change
+            clip_sample=True, # clip output to [-1,1] to improve stability
+            prediction_type='epsilon' # predict noise (instead of denoised action)
+        )
+
+    def compute_loss(self, obs_seq, action_seq):
+        B = obs_seq.shape[0]
+
+        # observation as FiLM conditioning
+        obs_cond = obs_seq.flatten(start_dim=1) # (B, obs_horizon * obs_dim)
+
+        # sample noise to add to actions
+        noise = torch.randn((B, self.pred_horizon, self.act_dim), device=device)
+
+        # sample a diffusion iteration for each data point
+        timesteps = torch.randint(
+            0, self.noise_scheduler.config.num_train_timesteps,
+            (B,), device=device
+        ).long()
+
+        # add noise to the clean images(actions) according to the noise magnitude at each diffusion iteration
+        # (this is the forward diffusion process)
+        noisy_action_seq = self.noise_scheduler.add_noise(
+            action_seq, noise, timesteps)
+
+        # predict the noise residual
+        noise_pred = self.noise_pred_net(
+            noisy_action_seq, timesteps, global_cond=obs_cond)
+
+        return F.mse_loss(noise_pred, noise)
+
+    def get_action(self, obs_seq):
+        # init scheduler
+        # self.noise_scheduler.set_timesteps(self.num_diffusion_iters)
+        # set_timesteps will change noise_scheduler.timesteps is only used in noise_scheduler.step()
+        # noise_scheduler.step() is only called during inference
+        # if we use DDPM, and inference_diffusion_steps == train_diffusion_steps, then we can skip this
+
+        # obs_seq: (B, obs_horizon, obs_dim)
+        B = obs_seq.shape[0]
+        with torch.no_grad():
+            obs_cond = obs_seq.flatten(start_dim=1) # (B, obs_horizon * obs_dim)
+
+            # initialize action from Guassian noise
+            noisy_action_seq = torch.randn((B, self.pred_horizon, self.act_dim), device=obs_seq.device)
+
+            for k in self.noise_scheduler.timesteps:
+                # predict noise
+                noise_pred = self.noise_pred_net(
+                    sample=noisy_action_seq,
+                    timestep=k,
+                    global_cond=obs_cond,
+                )
+
+                # inverse diffusion step (remove noise)
+                noisy_action_seq = self.noise_scheduler.step(
+                    model_output=noise_pred,
+                    timestep=k,
+                    sample=noisy_action_seq,
+                ).prev_sample
+
+        # only take act_horizon number of actions
+        start = self.obs_horizon - 1
+        end = start + self.act_horizon
+        return noisy_action_seq[:, start:end] # (B, act_horizon, act_dim)
+
+def save_ckpt(run_name, tag):
+    os.makedirs(f'runs/{run_name}/checkpoints', exist_ok=True)
+    ema.copy_to(ema_agent.parameters())
+    torch.save({
+        'agent': agent.state_dict(),
+        'ema_agent': ema_agent.state_dict(),
+    }, f'runs/{run_name}/checkpoints/{tag}.pt')
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    if args.exp_name is None:
+        args.exp_name = os.path.basename(__file__)[: -len(".py")]
+        run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    else:
+        run_name = args.exp_name
+
+    if args.demo_path.endswith('.h5'):
+        import json
+        json_file = args.demo_path[:-2] + 'json'
+        with open(json_file, 'r') as f:
+            demo_info = json.load(f)
+            if 'control_mode' in demo_info['env_info']['env_kwargs']:
+                control_mode = demo_info['env_info']['env_kwargs']['control_mode']
+            elif 'control_mode' in demo_info['episodes'][0]:
+                control_mode = demo_info['episodes'][0]['control_mode']
+            else:
+                raise Exception('Control mode not found in json')
+            assert control_mode == args.control_mode, f"Control mode mismatched. Dataset has control mode {control_mode}, but args has control mode {args.control_mode}"
+    assert args.obs_horizon + args.act_horizon - 1 <= args.pred_horizon
+    assert args.obs_horizon >= 1 and args.act_horizon >= 1 and args.pred_horizon >= 1
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    env_kwargs = dict(control_mode=args.control_mode, reward_mode="sparse", obs_mode="state", render_mode="rgb_array")
+    if args.max_episode_steps is not None:
+        env_kwargs["max_episode_steps"] = args.max_episode_steps
+    other_kwargs = dict(obs_horizon=args.obs_horizon)
+    envs = make_eval_envs(args.env_id, args.num_eval_envs, args.sim_backend, env_kwargs, other_kwargs, video_dir=f'runs/{run_name}/videos' if args.capture_video else None)
+
+    if args.track:
+        import wandb
+        config = vars(args)
+        config["eval_env_cfg"] = dict(**env_kwargs, num_envs=args.num_eval_envs, env_id=args.env_id, env_horizon=args.max_episode_steps or gym_utils.find_max_episode_steps_value(envs))
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=config,
+            name=run_name,
+            save_code=True,
+            group="DiffusionPolicy",
+            tags=["diffusion_policy"]
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # dataloader setup
+    dataset = SmallDemoDataset_DiffusionPolicy(args.demo_path, device, num_traj=args.num_demos)
+    sampler = RandomSampler(dataset, replacement=False)
+    batch_sampler = BatchSampler(sampler, batch_size=args.batch_size, drop_last=True)
+    batch_sampler = IterationBasedBatchSampler(batch_sampler, args.total_iters)
+    train_dataloader = DataLoader(
+        dataset,
+        batch_sampler=batch_sampler,
+        num_workers=args.num_dataload_workers,
+        worker_init_fn=lambda worker_id: worker_init_fn(worker_id, base_seed=args.seed),
+    )
+    if args.num_demos is None:
+        args.num_demos = len(dataset)
+
+    # agent setup
+    agent = Agent(envs, args).to(device)
+    optimizer = optim.AdamW(params=agent.parameters(),
+        lr=args.lr, betas=(0.95, 0.999), weight_decay=1e-6)
+
+    # Cosine LR schedule with linear warmup
+    lr_scheduler = get_scheduler(
+        name='cosine',
+        optimizer=optimizer,
+        num_warmup_steps=500,
+        num_training_steps=args.total_iters,
+    )
+
+    # Exponential Moving Average
+    # accelerates training and improves stability
+    # holds a copy of the model weights
+    ema = EMAModel(parameters=agent.parameters(), power=0.75)
+    ema_agent = Agent(envs, args).to(device)
+
+    # ---------------------------------------------------------------------------- #
+    # Training begins.
+    # ---------------------------------------------------------------------------- #
+    agent.train()
+
+    best_eval_metrics = defaultdict(float)
+    timings = defaultdict(float)
+
+    for iteration, data_batch in enumerate(train_dataloader):
+        # # copy data from cpu to gpu
+        # data_batch = {k: v.cuda(non_blocking=True) for k, v in data_batch.items()}
+
+        # forward and compute loss
+        total_loss = agent.compute_loss(
+            obs_seq=data_batch['observations'], # (B, L, obs_dim)
+            action_seq=data_batch['actions'], # (B, L, act_dim)
+        )
+
+        # backward
+        optimizer.zero_grad()
+        total_loss.backward()
+        optimizer.step()
+        lr_scheduler.step() # step lr scheduler every batch, this is different from standard pytorch behavior
+        last_tick = time.time()
+
+        # update Exponential Moving Average of the model weights
+        ema.step(agent.parameters())
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        if iteration % args.log_freq == 0:
+            print(f"Iteration {iteration}, loss: {total_loss.item()}")
+            writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], iteration)
+            writer.add_scalar("losses/total_loss", total_loss.item(), iteration)
+            for k, v in timings.items():
+                writer.add_scalar(f"time/{k}", v, iteration)
+        # Evaluation
+        if iteration % args.eval_freq == 0:
+            last_tick = time.time()
+
+            ema.copy_to(ema_agent.parameters())
+            # def sample_fn(obs):
+
+            eval_metrics = evaluate(args.num_eval_episodes, ema_agent, envs, device, args.sim_backend)
+            timings["eval"] += time.time() - last_tick
+
+            print(f"Evaluated {len(eval_metrics['success_at_end'])} episodes")
+            for k in eval_metrics.keys():
+                eval_metrics[k] = np.mean(eval_metrics[k])
+                writer.add_scalar(f"eval/{k}", eval_metrics[k], iteration)
+                print(f"{k}: {eval_metrics[k]:.4f}")
+
+            save_on_best_metrics = ["success_once", "success_at_end"]
+            for k in save_on_best_metrics:
+                if k in eval_metrics and eval_metrics[k] > best_eval_metrics[k]:
+                    best_eval_metrics[k] = eval_metrics[k]
+                    save_ckpt(run_name, f"best_eval_{k}")
+                    print(f'New best {k}_rate: {eval_metrics[k]:.4f}. Saving checkpoint.')
+        # Checkpoint
+        if args.save_freq is not None and iteration % args.save_freq == 0:
+            save_ckpt(run_name, str(iteration))
+    envs.close()
+    writer.close()

project/ManiSkill3/src/maniskill3_environment/examples/baselines/ppo/.gitignore

@@ -0,0 +1,4 @@
+/runs
+/videos
+/pretrained
+/wandb

project/ManiSkill3/src/maniskill3_environment/examples/baselines/ppo/README.md

@@ -0,0 +1,119 @@
+# Proximal Policy Optimization (PPO)
+
+Code for running the PPO RL algorithm is adapted from [CleanRL](https://github.com/vwxyzjn/cleanrl/) and [LeanRL](https://github.com/pytorch-labs/LeanRL/). It is written to be single-file and easy to follow/read, and supports state-based RL and visual-based RL code.
+
+Note that ManiSkill is still in beta, so we have not finalized training scripts for every pre-built task (some of which are simply too hard to solve with RL anyway).
+
+Official baseline results can be run by using the scripts in the baselines.sh file. Results are organized and published to our [wandb report](https://api.wandb.ai/links/stonet2000/k6lz966q)
+
+There is also now experimental support for PPO compiled and with CUDA Graphs enabled based on LeanRL. The code is in ppo_fast.py and you need to install [torchrl](https://github.com/pytorch/rl) and [tensordict](https://github.com/pytorch/tensordict/):
+
+```bash
+pip install torchrl tensordict
+```
+
+## State Based RL
+
+Below is a sample of various commands you can run to train a state-based policy to solve various tasks with PPO that are lightly tuned already. The fastest one is the PushCube-v1 task which can take less than a minute to train on the GPU and the PickCube-v1 task which can take 2-5 minutes on the GPU.
+
+The PPO baseline is not guaranteed to work for all tasks as some tasks do not have dense rewards yet or well tuned ones, or simply are too hard with standard PPO.
+
+
+```bash
+python ppo.py --env_id="PushCube-v1" \
+  --num_envs=2048 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=2_000_000 --eval_freq=10 --num-steps=20
+```
+
+To evaluate, you can run
+```bash
+python ppo.py --env_id="PushCube-v1" \
+   --evaluate --checkpoint=path/to/model.pt \
+   --num_eval_envs=1 --num-eval-steps=1000
+```
+
+Note that with `--evaluate`, trajectories are saved from a GPU simulation. In order to support replaying these trajectories correctly with the `maniskill.trajectory.replay_trajectory` tool for some task, the number of evaluation environments must be fixed to `1`. This is necessary in order to ensure reproducibility for tasks that have randomizations on geometry (e.g. PickSingleYCB). Other tasks without geometrical randomization like PushCube are fine and you can increase the number of evaluation environments. 
+
+The examples.sh file has a full list of tested commands for running state based PPO successfully on many tasks.
+
+The results of running the baseline scripts for state based PPO are here: https://api.wandb.ai/links/stonet2000/k6lz966q.
+
+## Visual (RGB) Based RL
+
+Below is a sample of various commands for training a image-based policy with PPO that are lightly tuned. The fastest again is also PushCube-v1 which can take about 1-5 minutes and PickCube-v1 which takes 15-45 minutes. You will need to tune the `--num_envs` argument according to how much GPU memory you have as rendering visual observations uses a lot of memory. The settings below should all take less than 15GB of GPU memory. The examples.sh file has a full list of tested commands for running visual based PPO successfully on many tasks.
+
+
+```bash
+python ppo_rgb.py --env_id="PushCube-v1" \
+  --num_envs=256 --update_epochs=8 --num_minibatches=8 \
+  --total_timesteps=1_000_000 --eval_freq=10 --num-steps=20
+python ppo_rgb.py --env_id="PickCube-v1" \
+  --num_envs=256 --update_epochs=8 --num_minibatches=8 \
+  --total_timesteps=10_000_000
+python ppo_rgb.py --env_id="AnymalC-Reach-v1" \
+  --num_envs=256 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=10_000_000 --num-steps=200 --num-eval-steps=200 \
+  --gamma=0.99 --gae_lambda=0.95
+```
+
+To evaluate a trained policy you can run
+
+```bash
+python ppo_rgb.py --env_id="PickCube-v1" \
+  --evaluate --checkpoint=path/to/model.pt \
+  --num_eval_envs=1 --num-eval-steps=1000
+```
+
+and it will save videos to the `path/to/test_videos`.
+
+The examples.sh file has a full list of tested commands for running RGB based PPO successfully on many tasks.
+
+The results of running the baseline scripts for RGB based PPO are here: https://api.wandb.ai/links/stonet2000/k6lz966q
+
+## Visual (RGB+Depth) Based RL
+
+WIP
+
+## Visual (Pointcloud) Based RL
+
+WIP
+
+## Replaying Evaluation Trajectories
+
+It might be useful to get some nicer looking videos. A simple way to do that is to first use the evaluation scripts provided above. It will then save a .h5 and .json file with a name equal to the date and time that you can then replay with different settings as so
+
+```bash
+python -m mani_skill.trajectory.replay_trajectory \
+  --traj-path=path/to/trajectory.h5 --use-env-states --shader="rt-fast" \
+  --save-video --allow-failure -o "none"
+```
+
+This will use environment states to replay trajectories, turn on the ray-tracer (There is also "rt" which is higher quality but slower), and save all videos including failed trajectories.
+
+## Some Notes
+
+- Evaluation with GPU simulation (especially with randomized objects) is a bit tricky. We recommend reading through [our docs](https://maniskill.readthedocs.io/en/latest/user_guide/reinforcement_learning/baselines.html#evaluation) on online RL evaluation in order to understand how to fairly evaluate policies with GPU simulation.
+- Many tasks support visual observations, however we have not carefully verified yet if the camera poses for the tasks are setup in a way that makes it possible to solve some tasks from visual observations.
+
+## Citation
+
+If you use this baseline please cite the following
+```
+@article{DBLP:journals/corr/SchulmanWDRK17,
+  author       = {John Schulman and
+                  Filip Wolski and
+                  Prafulla Dhariwal and
+                  Alec Radford and
+                  Oleg Klimov},
+  title        = {Proximal Policy Optimization Algorithms},
+  journal      = {CoRR},
+  volume       = {abs/1707.06347},
+  year         = {2017},
+  url          = {http://arxiv.org/abs/1707.06347},
+  eprinttype    = {arXiv},
+  eprint       = {1707.06347},
+  timestamp    = {Mon, 13 Aug 2018 16:47:34 +0200},
+  biburl       = {https://dblp.org/rec/journals/corr/SchulmanWDRK17.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}
+```

project/ManiSkill3/src/maniskill3_environment/examples/baselines/ppo/baselines.sh

@@ -0,0 +1,185 @@
+# Baseline results for PPO
+
+seeds=(9351 4796 1788)
+
+### State Based PPO Baselines ###
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="PushCube-v1" --seed=${seed} \
+    --num_envs=4096 --num-steps=4 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-PushCube-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="PickCube-v1" --seed=${seed} \
+    --num_envs=4096 --num-steps=4 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-PickCube-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="PushT-v1" --seed=${seed} \
+    --num_envs=4096 --num-steps=16 --update_epochs=8 --num_minibatches=32 --gamma=0.99 \
+    --total_timesteps=50_000_000 --num_eval_steps=100 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-PushT-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="StackCube-v1" --seed=${seed} \
+    --num_envs=4096 --num-steps=16 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-StackCube-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="RollBall-v1" --seed=${seed} \
+    --num_envs=4096 --num-steps=16 --update_epochs=8 --num_minibatches=32 --gamma=0.95 \
+    --total_timesteps=50_000_000 --num-eval-steps=80 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-RollBall-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="PullCube-v1" --seed=${seed} \
+    --num_envs=4096 --num-steps=4 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-PullCube-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="PokeCube-v1" --seed=${seed} \
+    --num_envs=4096 --num-steps=4 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-PokeCube-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="LiftPegUpright-v1" --seed=${seed} \
+    --num_envs=4096 --num-steps=4 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-LiftPegUpright-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="AnymalC-Reach-v1" --seed=${seed} \
+    --num_envs=4096 --update_epochs=8 --num_minibatches=32 --gamma=0.99 --gae_lambda=0.95 \
+    --total_timesteps=50_000_000 --num-steps=16 --num-eval-steps=200 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-AnymalC-Reach-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="PegInsertionSide-v1" --seed=${seed} \
+    --num_envs=2048 --update_epochs=8 --num_minibatches=32 --gamma=0.97 --gae_lambda=0.95 \
+    --total_timesteps=75_000_000 --num-steps=16 --num-eval-steps=100 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-PegInsertionSide-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="TwoRobotPickCube-v1" --seed=${seed} \
+    --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 --num-steps=100 --num-eval-steps=100 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-TwoRobotPickCube-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="UnitreeG1PlaceAppleInBowl-v1" --seed=${seed} \
+    --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 --num-steps=32 --num-eval-steps=100 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-UnitreeG1PlaceAppleInBowl-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_fast.py --env_id="UnitreeG1TransportBox-v1" --seed=${seed} \
+    --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=100_000_000 --num-steps=32 --num-eval-steps=100 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-UnitreeG1TransportBox-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do 
+  python ppo_fast.py --env_id="OpenCabinetDrawer-v1" --seed=${seed} \
+    --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 --num-steps=16 --num-eval-steps=100 \
+    --num_eval_envs=16 \
+    --save-model --cudagraphs --exp-name="ppo-OpenCabinetDrawer-v1-state-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+### RGB Based PPO Baselines ###
+for seed in ${seeds[@]}
+do
+  python ppo_rgb.py --env_id="PushCube-v1" --seed=${seed} \
+    --num_envs=256 --update_epochs=8 --num_minibatches=8 \
+    --total_timesteps=50_000_000 \
+    --num_eval_envs=16 \
+    --exp-name="ppo-PushCube-v1-rgb-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_rgb.py --env_id="PickCube-v1" --seed=${seed} \
+    --num_envs=1024 --num-steps=16 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 \
+    --num_eval_envs=16 \
+    --exp-name="ppo-PickCube-v1-rgb-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do
+  python ppo_rgb.py --env_id="PushT-v1" --seed=${seed} \
+    --num_envs=1024 --num-steps=16 --update_epochs=8 --num_minibatches=32 \
+    --total_timesteps=50_000_000 --num_eval_steps=100 --gamma=0.99 \
+    --num_eval_envs=16 \
+    --exp-name="ppo-PushT-v1-rgb-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done
+
+for seed in ${seeds[@]}
+do 
+  python ppo_rgb.py --env_id="AnymalC-Reach-v1" --seed=${seed} \
+    --num_envs=1024 --update_epochs=8 --num_minibatches=32 --gamma=0.99 --gae_lambda=0.95 \
+    --total_timesteps=50_000_000 --num-steps=16 --num-eval-steps=200 \
+    --num_eval_envs=16 --eval-reconfiguration-freq=0 \
+    --exp-name="ppo-AnymalC-Reach-v1-rgb-${seed}-walltime_efficient" \
+    --wandb_entity="stonet2000" --track
+done

project/ManiSkill3/src/maniskill3_environment/examples/baselines/ppo/examples.sh

@@ -0,0 +1,133 @@
+# This file is a giant collection of tested example commands for PPO
+# Note these are tuned for wall time speed. For official baseline results which run
+# more fair comparisons of RL algorithms see the baselines.sh file
+
+### State Based PPO ###
+python ppo.py --env_id="PickCube-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=10_000_000
+python ppo.py --env_id="StackCube-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=25_000_000
+python ppo.py --env_id="PushT-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=25_000_000 --num-steps=100 --num_eval_steps=100 --gamma=0.99
+python ppo.py --env_id="PickSingleYCB-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=25_000_000
+python ppo.py --env_id="PegInsertionSide-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=250_000_000 --num-steps=100 --num-eval-steps=100
+python ppo.py --env_id="TwoRobotPickCube-v1" \
+   --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+   --total_timesteps=20_000_000 --num-steps=100 --num-eval-steps=100
+python ppo.py --env_id="TwoRobotStackCube-v1" \
+   --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+   --total_timesteps=40_000_000 --num-steps=100 --num-eval-steps=100
+python ppo.py --env_id="TriFingerRotateCubeLevel0-v1" \
+   --num_envs=128 --update_epochs=8 --num_minibatches=32 \
+   --total_timesteps=50_000_000 --num-steps=250 --num-eval-steps=250
+python ppo.py --env_id="TriFingerRotateCubeLevel1-v1" \
+   --num_envs=128 --update_epochs=8 --num_minibatches=32 \
+   --total_timesteps=50_000_000 --num-steps=250 --num-eval-steps=250
+python ppo.py --env_id="TriFingerRotateCubeLevel2-v1" \
+   --num_envs=128 --update_epochs=8 --num_minibatches=32 \
+   --total_timesteps=50_000_000 --num-steps=250 --num-eval-steps=250
+python ppo.py --env_id="TriFingerRotateCubeLevel3-v1" \
+   --num_envs=128 --update_epochs=8 --num_minibatches=32 \
+   --total_timesteps=50_000_000 --num-steps=250 --num-eval-steps=250
+python ppo.py --env_id="TriFingerRotateCubeLevel4-v1" \
+   --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+   --total_timesteps=500_000_000 --num-steps=250 --num-eval-steps=250
+python ppo.py --env_id="PokeCube-v1" --update_epochs=8 --num_minibatches=32 \
+  --num_envs=1024 --total_timesteps=5_000_000 --eval_freq=10 --num-steps=20
+python ppo.py --env_id="MS-CartpoleBalance-v1" \
+   --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+   --total_timesteps=4_000_000 --num-steps=250 --num-eval-steps=1000 \
+   --gamma=0.99 --gae_lambda=0.95 \
+   --eval_freq=5
+
+python ppo.py --env_id="MS-CartpoleSwingUp-v1" \
+   --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+   --total_timesteps=10_000_000 --num-steps=250 --num-eval-steps=1000 \
+   --gamma=0.99 --gae_lambda=0.95 \
+   --eval_freq=5
+python ppo.py --env_id="MS-AntWalk-v1" --num_envs=2048 --eval_freq=10 \
+  --update_epochs=8 --num_minibatches=32 --total_timesteps=20_000_000 \
+  --num_eval_steps=1000 --num_steps=200 --gamma=0.97 --ent_coef=1e-3
+python ppo.py --env_id="MS-AntRun-v1" --num_envs=2048 --eval_freq=10 \
+  --update_epochs=8 --num_minibatches=32 --total_timesteps=20_000_000 \
+  --num_eval_steps=1000 --num_steps=200 --gamma=0.97 --ent_coef=1e-3
+python ppo.py --env_id="MS-HumanoidStand-v1" --num_envs=2048 --eval_freq=10 \
+  --update_epochs=8 --num_minibatches=32 --total_timesteps=40_000_000 \
+  --num_eval_steps=1000 --num_steps=200 --gamma=0.95
+python ppo.py --env_id="MS-HumanoidWalk-v1" --num_envs=2048 --eval_freq=10 \
+  --update_epochs=8 --num_minibatches=32 --total_timesteps=80_000_000 \
+  --num_eval_steps=1000 --num_steps=200 --gamma=0.97 --ent_coef=1e-3
+python ppo.py --env_id="MS-HumanoidRun-v1" --num_envs=2048 --eval_freq=10 \
+  --update_epochs=8 --num_minibatches=32 --total_timesteps=60_000_000 \
+  --num_eval_steps=1000 --num_steps=200 --gamma=0.97 --ent_coef=1e-3
+python ppo.py --env_id="UnitreeG1PlaceAppleInBowl-v1" \
+  --num_envs=512 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=50_000_000 --num-steps=100 --num-eval-steps=100
+python ppo.py --env_id="AnymalC-Reach-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=25_000_000 --num-steps=200 --num-eval-steps=200 \
+  --gamma=0.99 --gae_lambda=0.95
+python ppo.py --env_id="AnymalC-Spin-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=50_000_000 --num-steps=200 --num-eval-steps=200 \
+  --gamma=0.99 --gae_lambda=0.95
+python ppo.py --env_id="UnitreeGo2-Reach-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=50_000_000 --num-steps=200 --num-eval-steps=200 \
+  --gamma=0.99 --gae_lambda=0.95
+python ppo.py --env_id="UnitreeH1Stand-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=100_000_000 --num-steps=100 --num-eval-steps=1000 \
+  --gamma=0.99 --gae_lambda=0.95
+python ppo.py --env_id="UnitreeG1Stand-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=100_000_000 --num-steps=100 --num-eval-steps=1000 \
+  --gamma=0.99 --gae_lambda=0.95
+
+python ppo.py --env_id="OpenCabinetDrawer-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=10_000_000 --num-steps=100 --num-eval-steps=100   
+
+python ppo.py --env_id="RollBall-v1" \
+  --num_envs=1024 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=20_000_000 --num-steps=80 --num_eval_steps=80 --gamma=0.95
+
+### RGB Based PPO ###
+python ppo_rgb.py --env_id="PushCube-v1" \
+  --num_envs=256 --update_epochs=8 --num_minibatches=8 \
+  --total_timesteps=1_000_000 --eval_freq=10 --num-steps=20
+python ppo_rgb.py --env_id="PickCube-v1" \
+  --num_envs=256 --update_epochs=8 --num_minibatches=8 \
+  --total_timesteps=10_000_000
+python ppo_rgb.py --env_id="AnymalC-Reach-v1" \
+  --num_envs=256 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=10_000_000 --num-steps=200 --num-eval-steps=200 \
+  --gamma=0.99 --gae_lambda=0.95
+python ppo_rgb.py --env_id="PickSingleYCB-v1" \
+  --num_envs=256 --update_epochs=8 --num_minibatches=8 \
+  --total_timesteps=10_000_000
+python ppo_rgb.py --env_id="PushT-v1" \
+  --num_envs=256 --update_epochs=8 --num_minibatches=8 \
+  --total_timesteps=25_000_000 --num-steps=100 --num_eval_steps=100 --gamma=0.99
+python ppo_rgb.py --env_id="MS-AntWalk-v1" \
+ --num_envs=256 --update_epochs=8 --num_minibatches=32 \
+ --total_timesteps=5_000_000 --eval_freq=15 --num_eval_steps=1000 \
+ --num_steps=200 --gamma=0.97 --no-include-state --render_mode="rgb_array" \
+ --ent_coef=1e-3
+python ppo_rgb.py --env_id="MS-AntRun-v1" \
+ --num_envs=256 --update_epochs=8 --num_minibatches=32 \
+ --total_timesteps=15_000_000 --eval_freq=15 --num_eval_steps=1000 \
+ --num_steps=200 --gamma=0.97 --no-include-state --render_mode="rgb_array" \
+ --ent_coef=1e-3
+python ppo_rgb.py --env_id="MS-HumanoidRun-v1" \
+  --num_envs=256 --update_epochs=8 --num_minibatches=32 \
+  --total_timesteps=80_000_000 --eval_freq=15 --num_eval_steps=1000 \
+  --num_steps=200 --gamma=0.98 --no-include-state --render_mode="rgb_array" \
+  --ent_coef=1e-3

project/ManiSkill3/src/maniskill3_environment/examples/baselines/ppo/ppo.py

@@ -0,0 +1,470 @@
+from collections import defaultdict
+import os
+import random
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.normal import Normal
+from torch.utils.tensorboard import SummaryWriter
+
+# ManiSkill specific imports
+import mani_skill.envs
+from mani_skill.utils import gym_utils
+from mani_skill.utils.wrappers.flatten import FlattenActionSpaceWrapper
+from mani_skill.utils.wrappers.record import RecordEpisode
+from mani_skill.vector.wrappers.gymnasium import ManiSkillVectorEnv
+
+@dataclass
+class Args:
+    exp_name: Optional[str] = None
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=True`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "ManiSkill"
+    """the wandb's project name"""
+    wandb_entity: Optional[str] = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = True
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_model: bool = True
+    """whether to save model into the `runs/{run_name}` folder"""
+    evaluate: bool = False
+    """if toggled, only runs evaluation with the given model checkpoint and saves the evaluation trajectories"""
+    checkpoint: Optional[str] = None
+    """path to a pretrained checkpoint file to start evaluation/training from"""
+
+    # Algorithm specific arguments
+    env_id: str = "PickCube-v1"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 3e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 512
+    """the number of parallel environments"""
+    num_eval_envs: int = 8
+    """the number of parallel evaluation environments"""
+    partial_reset: bool = True
+    """whether to let parallel environments reset upon termination instead of truncation"""
+    eval_partial_reset: bool = False
+    """whether to let parallel evaluation environments reset upon termination instead of truncation"""
+    num_steps: int = 50
+    """the number of steps to run in each environment per policy rollout"""
+    num_eval_steps: int = 50
+    """the number of steps to run in each evaluation environment during evaluation"""
+    reconfiguration_freq: Optional[int] = None
+    """how often to reconfigure the environment during training"""
+    eval_reconfiguration_freq: Optional[int] = 1
+    """for benchmarking purposes we want to reconfigure the eval environment each reset to ensure objects are randomized in some tasks"""
+    control_mode: Optional[str] = "pd_joint_delta_pos"
+    """the control mode to use for the environment"""
+    anneal_lr: bool = False
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.8
+    """the discount factor gamma"""
+    gae_lambda: float = 0.9
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 32
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = False
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.0
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = 0.1
+    """the target KL divergence threshold"""
+    reward_scale: float = 1.0
+    """Scale the reward by this factor"""
+    eval_freq: int = 25
+    """evaluation frequency in terms of iterations"""
+    save_train_video_freq: Optional[int] = None
+    """frequency to save training videos in terms of iterations"""
+    finite_horizon_gae: bool = False
+
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 1)),
+        )
+        self.actor_mean = nn.Sequential(
+            layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, np.prod(envs.single_action_space.shape)), std=0.01*np.sqrt(2)),
+        )
+        self.actor_logstd = nn.Parameter(torch.ones(1, np.prod(envs.single_action_space.shape)) * -0.5)
+
+    def get_value(self, x):
+        return self.critic(x)
+    def get_action(self, x, deterministic=False):
+        action_mean = self.actor_mean(x)
+        if deterministic:
+            return action_mean
+        action_logstd = self.actor_logstd.expand_as(action_mean)
+        action_std = torch.exp(action_logstd)
+        probs = Normal(action_mean, action_std)
+        return probs.sample()
+    def get_action_and_value(self, x, action=None):
+        action_mean = self.actor_mean(x)
+        action_logstd = self.actor_logstd.expand_as(action_mean)
+        action_std = torch.exp(action_logstd)
+        probs = Normal(action_mean, action_std)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action).sum(1), probs.entropy().sum(1), self.critic(x)
+
+class Logger:
+    def __init__(self, log_wandb=False, tensorboard: SummaryWriter = None) -> None:
+        self.writer = tensorboard
+        self.log_wandb = log_wandb
+    def add_scalar(self, tag, scalar_value, step):
+        if self.log_wandb:
+            wandb.log({tag: scalar_value}, step=step)
+        self.writer.add_scalar(tag, scalar_value, step)
+    def close(self):
+        self.writer.close()
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    if args.exp_name is None:
+        args.exp_name = os.path.basename(__file__)[: -len(".py")]
+        run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    else:
+        run_name = args.exp_name
+
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    env_kwargs = dict(obs_mode="state", render_mode="rgb_array", sim_backend="physx_cuda")
+    if args.control_mode is not None:
+        env_kwargs["control_mode"] = args.control_mode
+    envs = gym.make(args.env_id, num_envs=args.num_envs if not args.evaluate else 1, reconfiguration_freq=args.reconfiguration_freq, **env_kwargs)
+    eval_envs = gym.make(args.env_id, num_envs=args.num_eval_envs, reconfiguration_freq=args.eval_reconfiguration_freq, **env_kwargs)
+    if isinstance(envs.action_space, gym.spaces.Dict):
+        envs = FlattenActionSpaceWrapper(envs)
+        eval_envs = FlattenActionSpaceWrapper(eval_envs)
+    if args.capture_video:
+        eval_output_dir = f"runs/{run_name}/videos"
+        if args.evaluate:
+            eval_output_dir = f"{os.path.dirname(args.checkpoint)}/test_videos"
+        print(f"Saving eval videos to {eval_output_dir}")
+        if args.save_train_video_freq is not None:
+            save_video_trigger = lambda x : (x // args.num_steps) % args.save_train_video_freq == 0
+            envs = RecordEpisode(envs, output_dir=f"runs/{run_name}/train_videos", save_trajectory=False, save_video_trigger=save_video_trigger, max_steps_per_video=args.num_steps, video_fps=30)
+        eval_envs = RecordEpisode(eval_envs, output_dir=eval_output_dir, save_trajectory=args.evaluate, trajectory_name="trajectory", max_steps_per_video=args.num_eval_steps, video_fps=30)
+    envs = ManiSkillVectorEnv(envs, args.num_envs, ignore_terminations=not args.partial_reset, record_metrics=True)
+    eval_envs = ManiSkillVectorEnv(eval_envs, args.num_eval_envs, ignore_terminations=not args.eval_partial_reset, record_metrics=True)
+    assert isinstance(envs.single_action_space, gym.spaces.Box), "only continuous action space is supported"
+
+    max_episode_steps = gym_utils.find_max_episode_steps_value(envs._env)
+    logger = None
+    if not args.evaluate:
+        print("Running training")
+        if args.track:
+            import wandb
+            config = vars(args)
+            config["env_cfg"] = dict(**env_kwargs, num_envs=args.num_envs, env_id=args.env_id, reward_mode="normalized_dense", env_horizon=max_episode_steps, partial_reset=args.partial_reset)
+            config["eval_env_cfg"] = dict(**env_kwargs, num_envs=args.num_eval_envs, env_id=args.env_id, reward_mode="normalized_dense", env_horizon=max_episode_steps, partial_reset=False)
+            wandb.init(
+                project=args.wandb_project_name,
+                entity=args.wandb_entity,
+                sync_tensorboard=False,
+                config=config,
+                name=run_name,
+                save_code=True,
+                group="PPO",
+                tags=["ppo", "walltime_efficient"]
+            )
+        writer = SummaryWriter(f"runs/{run_name}")
+        writer.add_text(
+            "hyperparameters",
+            "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+        )
+        logger = Logger(log_wandb=args.track, tensorboard=writer)
+    else:
+        print("Running evaluation")
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    eval_obs, _ = eval_envs.reset(seed=args.seed)
+    next_done = torch.zeros(args.num_envs, device=device)
+    print(f"####")
+    print(f"args.num_iterations={args.num_iterations} args.num_envs={args.num_envs} args.num_eval_envs={args.num_eval_envs}")
+    print(f"args.minibatch_size={args.minibatch_size} args.batch_size={args.batch_size} args.update_epochs={args.update_epochs}")
+    print(f"####")
+    action_space_low, action_space_high = torch.from_numpy(envs.single_action_space.low).to(device), torch.from_numpy(envs.single_action_space.high).to(device)
+    def clip_action(action: torch.Tensor):
+        return torch.clamp(action.detach(), action_space_low, action_space_high)
+
+    if args.checkpoint:
+        agent.load_state_dict(torch.load(args.checkpoint))
+
+    for iteration in range(1, args.num_iterations + 1):
+        print(f"Epoch: {iteration}, global_step={global_step}")
+        final_values = torch.zeros((args.num_steps, args.num_envs), device=device)
+        agent.eval()
+        if iteration % args.eval_freq == 1:
+            print("Evaluating")
+            eval_obs, _ = eval_envs.reset()
+            eval_metrics = defaultdict(list)
+            num_episodes = 0
+            for _ in range(args.num_eval_steps):
+                with torch.no_grad():
+                    eval_obs, eval_rew, eval_terminations, eval_truncations, eval_infos = eval_envs.step(agent.get_action(eval_obs, deterministic=True))
+                    if "final_info" in eval_infos:
+                        mask = eval_infos["_final_info"]
+                        num_episodes += mask.sum()
+                        for k, v in eval_infos["final_info"]["episode"].items():
+                            eval_metrics[k].append(v)
+            print(f"Evaluated {args.num_eval_steps * args.num_eval_envs} steps resulting in {num_episodes} episodes")
+            for k, v in eval_metrics.items():
+                mean = torch.stack(v).float().mean()
+                if logger is not None:
+                    logger.add_scalar(f"eval/{k}", mean, global_step)
+                print(f"eval_{k}_mean={mean}")
+            if args.evaluate:
+                break
+        if args.save_model and iteration % args.eval_freq == 1:
+            model_path = f"runs/{run_name}/ckpt_{iteration}.pt"
+            torch.save(agent.state_dict(), model_path)
+            print(f"model saved to {model_path}")
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        rollout_time = time.time()
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(clip_action(action))
+            next_done = torch.logical_or(terminations, truncations).to(torch.float32)
+            rewards[step] = reward.view(-1) * args.reward_scale
+
+            if "final_info" in infos:
+                final_info = infos["final_info"]
+                done_mask = infos["_final_info"]
+                for k, v in final_info["episode"].items():
+                    logger.add_scalar(f"train/{k}", v[done_mask].float().mean(), global_step)
+                with torch.no_grad():
+                    final_values[step, torch.arange(args.num_envs, device=device)[done_mask]] = agent.get_value(infos["final_observation"][done_mask]).view(-1)
+        rollout_time = time.time() - rollout_time
+        # bootstrap value according to termination and truncation
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    next_not_done = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    next_not_done = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                real_next_values = next_not_done * nextvalues + final_values[t] # t instead of t+1
+                # next_not_done means nextvalues is computed from the correct next_obs
+                # if next_not_done is 1, final_values is always 0
+                # if next_not_done is 0, then use final_values, which is computed according to bootstrap_at_done
+                if args.finite_horizon_gae:
+                    """
+                    See GAE paper equation(16) line 1, we will compute the GAE based on this line only
+                    1             *(  -V(s_t)  + r_t                                                               + gamma * V(s_{t+1})   )
+                    lambda        *(  -V(s_t)  + r_t + gamma * r_{t+1}                                             + gamma^2 * V(s_{t+2}) )
+                    lambda^2      *(  -V(s_t)  + r_t + gamma * r_{t+1} + gamma^2 * r_{t+2}                         + ...                  )
+                    lambda^3      *(  -V(s_t)  + r_t + gamma * r_{t+1} + gamma^2 * r_{t+2} + gamma^3 * r_{t+3}
+                    We then normalize it by the sum of the lambda^i (instead of 1-lambda)
+                    """
+                    if t == args.num_steps - 1: # initialize
+                        lam_coef_sum = 0.
+                        reward_term_sum = 0. # the sum of the second term
+                        value_term_sum = 0. # the sum of the third term
+                    lam_coef_sum = lam_coef_sum * next_not_done
+                    reward_term_sum = reward_term_sum * next_not_done
+                    value_term_sum = value_term_sum * next_not_done
+
+                    lam_coef_sum = 1 + args.gae_lambda * lam_coef_sum
+                    reward_term_sum = args.gae_lambda * args.gamma * reward_term_sum + lam_coef_sum * rewards[t]
+                    value_term_sum = args.gae_lambda * args.gamma * value_term_sum + args.gamma * real_next_values
+
+                    advantages[t] = (reward_term_sum + value_term_sum) / lam_coef_sum - values[t]
+                else:
+                    delta = rewards[t] + args.gamma * real_next_values - values[t]
+                    advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * next_not_done * lastgaelam # Here actually we should use next_not_terminated, but we don't have lastgamlam if terminated
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        agent.train()
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        update_time = time.time()
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                if args.target_kl is not None and approx_kl > args.target_kl:
+                    break
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        update_time = time.time() - update_time
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        logger.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        logger.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        logger.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        logger.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        logger.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        logger.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        logger.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        logger.add_scalar("losses/explained_variance", explained_var, global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        logger.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+        logger.add_scalar("time/step", global_step, global_step)
+        logger.add_scalar("time/update_time", update_time, global_step)
+        logger.add_scalar("time/rollout_time", rollout_time, global_step)
+        logger.add_scalar("time/rollout_fps", args.num_envs * args.num_steps / rollout_time, global_step)
+    if not args.evaluate:
+        if args.save_model:
+            model_path = f"runs/{run_name}/final_ckpt.pt"
+            torch.save(agent.state_dict(), model_path)
+            print(f"model saved to {model_path}")
+        logger.close()
+    envs.close()
+    eval_envs.close()

project/ManiSkill3/src/maniskill3_environment/examples/baselines/ppo/ppo_fast.py

@@ -0,0 +1,522 @@
+import os
+
+from mani_skill.utils import gym_utils
+from mani_skill.utils.wrappers.flatten import FlattenActionSpaceWrapper
+from mani_skill.utils.wrappers.record import RecordEpisode
+from mani_skill.vector.wrappers.gymnasium import ManiSkillVectorEnv
+
+os.environ["TORCHDYNAMO_INLINE_INBUILT_NN_MODULES"] = "1"
+
+import math
+import os
+import random
+import time
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+import gymnasium as gym
+import numpy as np
+import tensordict
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tqdm
+import tyro
+from torch.utils.tensorboard import SummaryWriter
+import wandb
+from tensordict import from_module
+from tensordict.nn import CudaGraphModule
+from torch.distributions.normal import Normal
+
+
+@dataclass
+class Args:
+    exp_name: Optional[str] = None
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "ManiSkill"
+    """the wandb's project name"""
+    wandb_entity: Optional[str] = None
+    """the entity (team) of wandb's project"""
+    wandb_group: str = "PPO"
+    """the group of the run for wandb"""
+    capture_video: bool = True
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_trajectory: bool = False
+    """whether to save trajectory data into the `videos` folder"""
+    save_model: bool = False
+    """whether to save model into the `runs/{run_name}` folder"""
+    evaluate: bool = False
+    """if toggled, only runs evaluation with the given model checkpoint and saves the evaluation trajectories"""
+    checkpoint: Optional[str] = None
+    """path to a pretrained checkpoint file to start evaluation/training from"""
+
+    # Environment specific arguments
+    env_id: str = "PickCube-v1"
+    """the id of the environment"""
+    env_vectorization: str = "gpu"
+    """the type of environment vectorization to use"""
+    num_envs: int = 512
+    """the number of parallel environments"""
+    num_eval_envs: int = 16
+    """the number of parallel evaluation environments"""
+    partial_reset: bool = True
+    """whether to let parallel environments reset upon termination instead of truncation"""
+    eval_partial_reset: bool = False
+    """whether to let parallel evaluation environments reset upon termination instead of truncation"""
+    num_steps: int = 50
+    """the number of steps to run in each environment per policy rollout"""
+    num_eval_steps: int = 50
+    """the number of steps to run in each evaluation environment during evaluation"""
+    reconfiguration_freq: Optional[int] = None
+    """how often to reconfigure the environment during training"""
+    eval_reconfiguration_freq: Optional[int] = 1
+    """for benchmarking purposes we want to reconfigure the eval environment each reset to ensure objects are randomized in some tasks"""
+    eval_freq: int = 25
+    """evaluation frequency in terms of iterations"""
+    save_train_video_freq: Optional[int] = None
+    """frequency to save training videos in terms of iterations"""
+    control_mode: Optional[str] = "pd_joint_delta_pos"
+    """the control mode to use for the environment"""
+
+    # Algorithm specific arguments
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 3e-4
+    """the learning rate of the optimizer"""
+    anneal_lr: bool = False
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.8
+    """the discount factor gamma"""
+    gae_lambda: float = 0.9
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 32
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = False
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.0
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = 0.1
+    """the target KL divergence threshold"""
+    reward_scale: float = 1.0
+    """Scale the reward by this factor"""
+    finite_horizon_gae: bool = False
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+    # Torch optimizations
+    compile: bool = False
+    """whether to use torch.compile."""
+    cudagraphs: bool = False
+    """whether to use cudagraphs on top of compile."""
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, n_obs, n_act, device=None):
+        super().__init__()
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(n_obs, 256, device=device)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256, device=device)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256, device=device)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 1, device=device)),
+        )
+        self.actor_mean = nn.Sequential(
+            layer_init(nn.Linear(n_obs, 256, device=device)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256, device=device)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256, device=device)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, n_act, device=device), std=0.01*np.sqrt(2)),
+        )
+        self.actor_logstd = nn.Parameter(torch.zeros(1, n_act, device=device))
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, obs, action=None):
+        action_mean = self.actor_mean(obs)
+        action_logstd = self.actor_logstd.expand_as(action_mean)
+        action_std = torch.exp(action_logstd)
+        probs = Normal(action_mean, action_std)
+        if action is None:
+            action = action_mean + action_std * torch.randn_like(action_mean)
+        return action, probs.log_prob(action).sum(1), probs.entropy().sum(1), self.critic(obs)
+
+class Logger:
+    def __init__(self, log_wandb=False, tensorboard: SummaryWriter = None) -> None:
+        self.writer = tensorboard
+        self.log_wandb = log_wandb
+    def add_scalar(self, tag, scalar_value, step):
+        if self.log_wandb:
+            wandb.log({tag: scalar_value}, step=step)
+        self.writer.add_scalar(tag, scalar_value, step)
+    def close(self):
+        self.writer.close()
+
+def gae(next_obs, next_done, container, final_values):
+    # bootstrap value if not done
+    next_value = get_value(next_obs).reshape(-1)
+    lastgaelam = 0
+    nextnonterminals = (~container["dones"]).float().unbind(0)
+    vals = container["vals"]
+    vals_unbind = vals.unbind(0)
+    rewards = container["rewards"].unbind(0)
+
+    advantages = []
+    nextnonterminal = (~next_done).float()
+    nextvalues = next_value
+    for t in range(args.num_steps - 1, -1, -1):
+        cur_val = vals_unbind[t]
+        # real_next_values = nextvalues * nextnonterminal
+        real_next_values = nextnonterminal * nextvalues + final_values[t] # t instead of t+1
+        delta = rewards[t] + args.gamma * real_next_values - cur_val
+        advantages.append(delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam)
+        lastgaelam = advantages[-1]
+
+        nextnonterminal = nextnonterminals[t]
+        nextvalues = cur_val
+
+    advantages = container["advantages"] = torch.stack(list(reversed(advantages)))
+    container["returns"] = advantages + vals
+    return container
+
+
+def rollout(obs, done):
+    ts = []
+    final_values = torch.zeros((args.num_steps, args.num_envs), device=device)
+    for step in range(args.num_steps):
+        # ALGO LOGIC: action logic
+        action, logprob, _, value = policy(obs=obs)
+
+        # TRY NOT TO MODIFY: execute the game and log data.
+        next_obs, reward, next_done, infos = step_func(action)
+
+        if "final_info" in infos:
+            final_info = infos["final_info"]
+            done_mask = infos["_final_info"]
+            for k, v in final_info["episode"].items():
+                logger.add_scalar(f"train/{k}", v[done_mask].float().mean(), global_step)
+            with torch.no_grad():
+                final_values[step, torch.arange(args.num_envs, device=device)[done_mask]] = agent.get_value(infos["final_observation"][done_mask]).view(-1)
+
+        ts.append(
+            tensordict.TensorDict._new_unsafe(
+                obs=obs,
+                # cleanrl ppo examples associate the done with the previous obs (not the done resulting from action)
+                dones=done,
+                vals=value.flatten(),
+                actions=action,
+                logprobs=logprob,
+                rewards=reward,
+                batch_size=(args.num_envs,),
+            )
+        )
+        # NOTE (stao): change here for gpu env
+        obs = next_obs = next_obs
+        done = next_done
+    # NOTE (stao): need to do .to(device) i think? otherwise container.device is None, not sure if this affects anything
+    container = torch.stack(ts, 0).to(device)
+    return next_obs, done, container, final_values
+
+
+def update(obs, actions, logprobs, advantages, returns, vals):
+    optimizer.zero_grad()
+    _, newlogprob, entropy, newvalue = agent.get_action_and_value(obs, actions)
+    logratio = newlogprob - logprobs
+    ratio = logratio.exp()
+
+    with torch.no_grad():
+        # calculate approx_kl http://joschu.net/blog/kl-approx.html
+        old_approx_kl = (-logratio).mean()
+        approx_kl = ((ratio - 1) - logratio).mean()
+        clipfrac = ((ratio - 1.0).abs() > args.clip_coef).float().mean()
+
+    if args.norm_adv:
+        advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)
+
+    # Policy loss
+    pg_loss1 = -advantages * ratio
+    pg_loss2 = -advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+    pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+    # Value loss
+    newvalue = newvalue.view(-1)
+    if args.clip_vloss:
+        v_loss_unclipped = (newvalue - returns) ** 2
+        v_clipped = vals + torch.clamp(
+            newvalue - vals,
+            -args.clip_coef,
+            args.clip_coef,
+        )
+        v_loss_clipped = (v_clipped - returns) ** 2
+        v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+        v_loss = 0.5 * v_loss_max.mean()
+    else:
+        v_loss = 0.5 * ((newvalue - returns) ** 2).mean()
+
+    entropy_loss = entropy.mean()
+    loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+    loss.backward()
+    gn = nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+    optimizer.step()
+
+    return approx_kl, v_loss.detach(), pg_loss.detach(), entropy_loss.detach(), old_approx_kl, clipfrac, gn
+
+
+update = tensordict.nn.TensorDictModule(
+    update,
+    in_keys=["obs", "actions", "logprobs", "advantages", "returns", "vals"],
+    out_keys=["approx_kl", "v_loss", "pg_loss", "entropy_loss", "old_approx_kl", "clipfrac", "gn"],
+)
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    # if not args.evaluate: exit()
+
+    batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = batch_size // args.num_minibatches
+    args.batch_size = args.num_minibatches * args.minibatch_size
+    args.num_iterations = args.total_timesteps // args.batch_size
+    if args.exp_name is None:
+        args.exp_name = os.path.basename(__file__)[: -len(".py")]
+        run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    else:
+        run_name = args.exp_name
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    ####### Environment setup #######
+    env_kwargs = dict(obs_mode="state", render_mode="rgb_array", sim_backend="physx_cuda")
+    if args.control_mode is not None:
+        env_kwargs["control_mode"] = args.control_mode
+    envs = gym.make(args.env_id, num_envs=args.num_envs if not args.evaluate else 1, reconfiguration_freq=args.reconfiguration_freq, **env_kwargs)
+    eval_envs = gym.make(args.env_id, num_envs=args.num_eval_envs, reconfiguration_freq=args.eval_reconfiguration_freq, human_render_camera_configs=dict(shader_pack="default"), **env_kwargs)
+    if isinstance(envs.action_space, gym.spaces.Dict):
+        envs = FlattenActionSpaceWrapper(envs)
+        eval_envs = FlattenActionSpaceWrapper(eval_envs)
+    if args.capture_video or args.save_trajectory:
+        eval_output_dir = f"runs/{run_name}/videos"
+        if args.evaluate:
+            eval_output_dir = f"{os.path.dirname(args.checkpoint)}/test_videos"
+        print(f"Saving eval trajectories/videos to {eval_output_dir}")
+        if args.save_train_video_freq is not None:
+            save_video_trigger = lambda x : (x // args.num_steps) % args.save_train_video_freq == 0
+            envs = RecordEpisode(envs, output_dir=f"runs/{run_name}/train_videos", save_trajectory=False, save_video_trigger=save_video_trigger, max_steps_per_video=args.num_steps, video_fps=30)
+        eval_envs = RecordEpisode(eval_envs, output_dir=eval_output_dir, save_trajectory=args.save_trajectory, save_video=args.capture_video, trajectory_name="trajectory", max_steps_per_video=args.num_eval_steps, video_fps=30)
+    envs = ManiSkillVectorEnv(envs, args.num_envs, ignore_terminations=not args.partial_reset, record_metrics=True)
+    eval_envs = ManiSkillVectorEnv(eval_envs, args.num_eval_envs, ignore_terminations=not args.eval_partial_reset, record_metrics=True)
+    assert isinstance(envs.single_action_space, gym.spaces.Box), "only continuous action space is supported"
+
+    max_episode_steps = gym_utils.find_max_episode_steps_value(envs._env)
+    logger = None
+    if not args.evaluate:
+        print("Running training")
+        if args.track:
+            import wandb
+            config = vars(args)
+            config["env_cfg"] = dict(**env_kwargs, num_envs=args.num_envs, env_id=args.env_id, reward_mode="normalized_dense", env_horizon=max_episode_steps, partial_reset=args.partial_reset)
+            config["eval_env_cfg"] = dict(**env_kwargs, num_envs=args.num_eval_envs, env_id=args.env_id, reward_mode="normalized_dense", env_horizon=max_episode_steps, partial_reset=False)
+            wandb.init(
+                project=args.wandb_project_name,
+                entity=args.wandb_entity,
+                sync_tensorboard=False,
+                config=config,
+                name=run_name,
+                save_code=True,
+                group=args.wandb_group,
+                tags=["ppo", "walltime_efficient", f"GPU:{torch.cuda.get_device_name()}"]
+            )
+        writer = SummaryWriter(f"runs/{run_name}")
+        writer.add_text(
+            "hyperparameters",
+            "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+        )
+        logger = Logger(log_wandb=args.track, tensorboard=writer)
+    else:
+        print("Running evaluation")
+    n_act = math.prod(envs.single_action_space.shape)
+    n_obs = math.prod(envs.single_observation_space.shape)
+    assert isinstance(envs.single_action_space, gym.spaces.Box), "only continuous action space is supported"
+
+    # Register step as a special op not to graph break
+    # @torch.library.custom_op("mylib::step", mutates_args=())
+    def step_func(action: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        # NOTE (stao): change here for gpu env
+        next_obs, reward, terminations, truncations, info = envs.step(action)
+        next_done = torch.logical_or(terminations, truncations)
+        return next_obs, reward, next_done, info
+
+    ####### Agent #######
+    agent = Agent(n_obs, n_act, device=device)
+    if args.checkpoint:
+        agent.load_state_dict(torch.load(args.checkpoint))
+    # Make a version of agent with detached params
+    agent_inference = Agent(n_obs, n_act, device=device)
+    agent_inference_p = from_module(agent).data
+    agent_inference_p.to_module(agent_inference)
+
+    ####### Optimizer #######
+    optimizer = optim.Adam(
+        agent.parameters(),
+        lr=torch.tensor(args.learning_rate, device=device),
+        eps=1e-5,
+        capturable=args.cudagraphs and not args.compile,
+    )
+
+    ####### Executables #######
+    # Define networks: wrapping the policy in a TensorDictModule allows us to use CudaGraphModule
+    policy = agent_inference.get_action_and_value
+    get_value = agent_inference.get_value
+
+    # Compile policy
+    if args.compile:
+        policy = torch.compile(policy)
+        gae = torch.compile(gae, fullgraph=True)
+        update = torch.compile(update)
+
+    if args.cudagraphs:
+        policy = CudaGraphModule(policy)
+        gae = CudaGraphModule(gae)
+        update = CudaGraphModule(update)
+
+    global_step = 0
+    start_time = time.time()
+    container_local = None
+    next_obs = envs.reset()[0]
+    next_done = torch.zeros(args.num_envs, device=device, dtype=torch.bool)
+    pbar = tqdm.tqdm(range(1, args.num_iterations + 1))
+
+    cumulative_times = defaultdict(float)
+
+    for iteration in pbar:
+        agent.eval()
+        if iteration % args.eval_freq == 1:
+            stime = time.perf_counter()
+            eval_obs, _ = eval_envs.reset()
+            eval_metrics = defaultdict(list)
+            num_episodes = 0
+            for _ in range(args.num_eval_steps):
+                with torch.no_grad():
+                    eval_obs, eval_rew, eval_terminations, eval_truncations, eval_infos = eval_envs.step(agent.actor_mean(eval_obs))
+                    if "final_info" in eval_infos:
+                        mask = eval_infos["_final_info"]
+                        num_episodes += mask.sum()
+                        for k, v in eval_infos["final_info"]["episode"].items():
+                            eval_metrics[k].append(v)
+            eval_metrics_mean = {}
+            for k, v in eval_metrics.items():
+                mean = torch.stack(v).float().mean()
+                eval_metrics_mean[k] = mean
+                if logger is not None:
+                    logger.add_scalar(f"eval/{k}", mean, global_step)
+            pbar.set_description(
+                f"success_once: {eval_metrics_mean['success_once']:.2f}, "
+                f"return: {eval_metrics_mean['return']:.2f}"
+            )
+            if logger is not None:
+                eval_time = time.perf_counter() - stime
+                cumulative_times["eval_time"] += eval_time
+                logger.add_scalar("time/eval_time", eval_time, global_step)
+            if args.evaluate:
+                break
+        if args.save_model and iteration % args.eval_freq == 1:
+            model_path = f"runs/{run_name}/ckpt_{iteration}.pt"
+            torch.save(agent.state_dict(), model_path)
+            print(f"model saved to {model_path}")
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"].copy_(lrnow)
+
+        torch.compiler.cudagraph_mark_step_begin()
+        rollout_time = time.perf_counter()
+        next_obs, next_done, container, final_values = rollout(next_obs, next_done)
+        rollout_time = time.perf_counter() - rollout_time
+        cumulative_times["rollout_time"] += rollout_time
+        global_step += container.numel()
+
+        update_time = time.perf_counter()
+        container = gae(next_obs, next_done, container, final_values)
+        container_flat = container.view(-1)
+
+        # Optimizing the policy and value network
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            b_inds = torch.randperm(container_flat.shape[0], device=device).split(args.minibatch_size)
+            for b in b_inds:
+                container_local = container_flat[b]
+
+                out = update(container_local, tensordict_out=tensordict.TensorDict())
+                clipfracs.append(out["clipfrac"])
+                if args.target_kl is not None and out["approx_kl"] > args.target_kl:
+                    break
+            else:
+                continue
+            break
+        update_time = time.perf_counter() - update_time
+        cumulative_times["update_time"] += update_time
+
+        logger.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        logger.add_scalar("losses/value_loss", out["v_loss"].item(), global_step)
+        logger.add_scalar("losses/policy_loss", out["pg_loss"].item(), global_step)
+        logger.add_scalar("losses/entropy", out["entropy_loss"].item(), global_step)
+        logger.add_scalar("losses/old_approx_kl", out["old_approx_kl"].item(), global_step)
+        logger.add_scalar("losses/approx_kl", out["approx_kl"].item(), global_step)
+        logger.add_scalar("losses/clipfrac", torch.stack(clipfracs).mean().cpu().item(), global_step)
+        logger.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+        logger.add_scalar("time/step", global_step, global_step)
+        logger.add_scalar("time/update_time", update_time, global_step)
+        logger.add_scalar("time/rollout_time", rollout_time, global_step)
+        logger.add_scalar("time/rollout_fps", args.num_envs * args.num_steps / rollout_time, global_step)
+        for k, v in cumulative_times.items():
+            logger.add_scalar(f"time/total_{k}", v, global_step)
+        logger.add_scalar("time/total_rollout+update_time", cumulative_times["rollout_time"] + cumulative_times["update_time"], global_step)
+    if not args.evaluate:
+        if args.save_model:
+            model_path = f"runs/{run_name}/final_ckpt.pt"
+            torch.save(agent.state_dict(), model_path)
+            print(f"model saved to {model_path}")
+        logger.close()
+    envs.close()
+    eval_envs.close()

project/ManiSkill3/src/maniskill3_environment/examples/baselines/ppo/ppo_rgb.py

@@ -0,0 +1,594 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_continuous_actionpy
+from collections import defaultdict
+import os
+import random
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.normal import Normal
+from torch.utils.tensorboard import SummaryWriter
+
+# ManiSkill specific imports
+import mani_skill.envs
+from mani_skill.utils import gym_utils
+from mani_skill.utils.wrappers.flatten import FlattenActionSpaceWrapper, FlattenRGBDObservationWrapper
+from mani_skill.utils.wrappers.record import RecordEpisode
+from mani_skill.vector.wrappers.gymnasium import ManiSkillVectorEnv
+
+@dataclass
+class Args:
+    exp_name: Optional[str] = None
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "ManiSkill"
+    """the wandb's project name"""
+    wandb_entity: Optional[str] = None
+    """the entity (team) of wandb's project"""
+    wandb_group: str = "PPO"
+    """the group of the run for wandb"""
+    capture_video: bool = True
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_model: bool = True
+    """whether to save model into the `runs/{run_name}` folder"""
+    evaluate: bool = False
+    """if toggled, only runs evaluation with the given model checkpoint and saves the evaluation trajectories"""
+    checkpoint: Optional[str] = None
+    """path to a pretrained checkpoint file to start evaluation/training from"""
+    render_mode: str = "all"
+    """the environment rendering mode"""
+
+    # Algorithm specific arguments
+    env_id: str = "PickCube-v1"
+    """the id of the environment"""
+    include_state: bool = True
+    """whether to include state information in observations"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 3e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 512
+    """the number of parallel environments"""
+    num_eval_envs: int = 8
+    """the number of parallel evaluation environments"""
+    partial_reset: bool = True
+    """whether to let parallel environments reset upon termination instead of truncation"""
+    eval_partial_reset: bool = False
+    """whether to let parallel evaluation environments reset upon termination instead of truncation"""
+    num_steps: int = 50
+    """the number of steps to run in each environment per policy rollout"""
+    num_eval_steps: int = 50
+    """the number of steps to run in each evaluation environment during evaluation"""
+    reconfiguration_freq: Optional[int] = None
+    """how often to reconfigure the environment during training"""
+    eval_reconfiguration_freq: Optional[int] = 1
+    """for benchmarking purposes we want to reconfigure the eval environment each reset to ensure objects are randomized in some tasks"""
+    control_mode: Optional[str] = "pd_joint_delta_pos"
+    """the control mode to use for the environment"""
+    anneal_lr: bool = False
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.8
+    """the discount factor gamma"""
+    gae_lambda: float = 0.9
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 32
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = False
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.0
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = 0.2
+    """the target KL divergence threshold"""
+    reward_scale: float = 1.0
+    """Scale the reward by this factor"""
+    eval_freq: int = 25
+    """evaluation frequency in terms of iterations"""
+    save_train_video_freq: Optional[int] = None
+    """frequency to save training videos in terms of iterations"""
+    finite_horizon_gae: bool = False
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+class DictArray(object):
+    def __init__(self, buffer_shape, element_space, data_dict=None, device=None):
+        self.buffer_shape = buffer_shape
+        if data_dict:
+            self.data = data_dict
+        else:
+            assert isinstance(element_space, gym.spaces.dict.Dict)
+            self.data = {}
+            for k, v in element_space.items():
+                if isinstance(v, gym.spaces.dict.Dict):
+                    self.data[k] = DictArray(buffer_shape, v, device=device)
+                else:
+                    dtype = (torch.float32 if v.dtype in (np.float32, np.float64) else
+                            torch.uint8 if v.dtype == np.uint8 else
+                            torch.int16 if v.dtype == np.int16 else
+                            torch.int32 if v.dtype == np.int32 else
+                            v.dtype)
+                    self.data[k] = torch.zeros(buffer_shape + v.shape, dtype=dtype, device=device)
+
+    def keys(self):
+        return self.data.keys()
+
+    def __getitem__(self, index):
+        if isinstance(index, str):
+            return self.data[index]
+        return {
+            k: v[index] for k, v in self.data.items()
+        }
+
+    def __setitem__(self, index, value):
+        if isinstance(index, str):
+            self.data[index] = value
+        for k, v in value.items():
+            self.data[k][index] = v
+
+    @property
+    def shape(self):
+        return self.buffer_shape
+
+    def reshape(self, shape):
+        t = len(self.buffer_shape)
+        new_dict = {}
+        for k,v in self.data.items():
+            if isinstance(v, DictArray):
+                new_dict[k] = v.reshape(shape)
+            else:
+                new_dict[k] = v.reshape(shape + v.shape[t:])
+        new_buffer_shape = next(iter(new_dict.values())).shape[:len(shape)]
+        return DictArray(new_buffer_shape, None, data_dict=new_dict)
+
+class NatureCNN(nn.Module):
+    def __init__(self, sample_obs):
+        super().__init__()
+
+        extractors = {}
+
+        self.out_features = 0
+        feature_size = 256
+        in_channels=sample_obs["rgb"].shape[-1]
+        image_size=(sample_obs["rgb"].shape[1], sample_obs["rgb"].shape[2])
+
+
+        # here we use a NatureCNN architecture to process images, but any architecture is permissble here
+        cnn = nn.Sequential(
+            nn.Conv2d(
+                in_channels=in_channels,
+                out_channels=32,
+                kernel_size=8,
+                stride=4,
+                padding=0,
+            ),
+            nn.ReLU(),
+            nn.Conv2d(
+                in_channels=32, out_channels=64, kernel_size=4, stride=2, padding=0
+            ),
+            nn.ReLU(),
+            nn.Conv2d(
+                in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=0
+            ),
+            nn.ReLU(),
+            nn.Flatten(),
+        )
+
+        # to easily figure out the dimensions after flattening, we pass a test tensor
+        with torch.no_grad():
+            n_flatten = cnn(sample_obs["rgb"].float().permute(0,3,1,2).cpu()).shape[1]
+            fc = nn.Sequential(nn.Linear(n_flatten, feature_size), nn.ReLU())
+        extractors["rgb"] = nn.Sequential(cnn, fc)
+        self.out_features += feature_size
+
+        if "state" in sample_obs:
+            # for state data we simply pass it through a single linear layer
+            state_size = sample_obs["state"].shape[-1]
+            extractors["state"] = nn.Linear(state_size, 256)
+            self.out_features += 256
+
+        self.extractors = nn.ModuleDict(extractors)
+
+    def forward(self, observations) -> torch.Tensor:
+        encoded_tensor_list = []
+        # self.extractors contain nn.Modules that do all the processing.
+        for key, extractor in self.extractors.items():
+            obs = observations[key]
+            if key == "rgb":
+                obs = obs.float().permute(0,3,1,2)
+                obs = obs / 255
+            encoded_tensor_list.append(extractor(obs))
+        return torch.cat(encoded_tensor_list, dim=1)
+
+class Agent(nn.Module):
+    def __init__(self, envs, sample_obs):
+        super().__init__()
+        self.feature_net = NatureCNN(sample_obs=sample_obs)
+        # latent_size = np.array(envs.unwrapped.single_observation_space.shape).prod()
+        latent_size = self.feature_net.out_features
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(latent_size, 512)),
+            nn.ReLU(inplace=True),
+            layer_init(nn.Linear(512, 1)),
+        )
+        self.actor_mean = nn.Sequential(
+            layer_init(nn.Linear(latent_size, 512)),
+            nn.ReLU(inplace=True),
+            layer_init(nn.Linear(512, np.prod(envs.unwrapped.single_action_space.shape)), std=0.01*np.sqrt(2)),
+        )
+        self.actor_logstd = nn.Parameter(torch.ones(1, np.prod(envs.unwrapped.single_action_space.shape)) * -0.5)
+    def get_features(self, x):
+        return self.feature_net(x)
+    def get_value(self, x):
+        x = self.feature_net(x)
+        return self.critic(x)
+    def get_action(self, x, deterministic=False):
+        x = self.feature_net(x)
+        action_mean = self.actor_mean(x)
+        if deterministic:
+            return action_mean
+        action_logstd = self.actor_logstd.expand_as(action_mean)
+        action_std = torch.exp(action_logstd)
+        probs = Normal(action_mean, action_std)
+        return probs.sample()
+    def get_action_and_value(self, x, action=None):
+        x = self.feature_net(x)
+        action_mean = self.actor_mean(x)
+        action_logstd = self.actor_logstd.expand_as(action_mean)
+        action_std = torch.exp(action_logstd)
+        probs = Normal(action_mean, action_std)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action).sum(1), probs.entropy().sum(1), self.critic(x)
+
+class Logger:
+    def __init__(self, log_wandb=False, tensorboard: SummaryWriter = None) -> None:
+        self.writer = tensorboard
+        self.log_wandb = log_wandb
+    def add_scalar(self, tag, scalar_value, step):
+        if self.log_wandb:
+            wandb.log({tag: scalar_value}, step=step)
+        self.writer.add_scalar(tag, scalar_value, step)
+    def close(self):
+        self.writer.close()
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    if args.exp_name is None:
+        args.exp_name = os.path.basename(__file__)[: -len(".py")]
+        run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    else:
+        run_name = args.exp_name
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    env_kwargs = dict(obs_mode="rgb", render_mode=args.render_mode, sim_backend="physx_cuda")
+    if args.control_mode is not None:
+        env_kwargs["control_mode"] = args.control_mode
+    eval_envs = gym.make(args.env_id, num_envs=args.num_eval_envs, reconfiguration_freq=args.eval_reconfiguration_freq, **env_kwargs)
+    envs = gym.make(args.env_id, num_envs=args.num_envs if not args.evaluate else 1, reconfiguration_freq=args.reconfiguration_freq, **env_kwargs)
+
+    # rgbd obs mode returns a dict of data, we flatten it so there is just a rgbd key and state key
+    envs = FlattenRGBDObservationWrapper(envs, rgb=True, depth=False, state=args.include_state)
+    eval_envs = FlattenRGBDObservationWrapper(eval_envs, rgb=True, depth=False, state=args.include_state)
+
+    if isinstance(envs.action_space, gym.spaces.Dict):
+        envs = FlattenActionSpaceWrapper(envs)
+        eval_envs = FlattenActionSpaceWrapper(eval_envs)
+    if args.capture_video:
+        eval_output_dir = f"runs/{run_name}/videos"
+        if args.evaluate:
+            eval_output_dir = f"{os.path.dirname(args.checkpoint)}/test_videos"
+        print(f"Saving eval videos to {eval_output_dir}")
+        if args.save_train_video_freq is not None:
+            save_video_trigger = lambda x : (x // args.num_steps) % args.save_train_video_freq == 0
+            envs = RecordEpisode(envs, output_dir=f"runs/{run_name}/train_videos", save_trajectory=False, save_video_trigger=save_video_trigger, max_steps_per_video=args.num_steps, video_fps=30)
+        eval_envs = RecordEpisode(eval_envs, output_dir=eval_output_dir, save_trajectory=args.evaluate, trajectory_name="trajectory", max_steps_per_video=args.num_eval_steps, video_fps=30)
+    envs = ManiSkillVectorEnv(envs, args.num_envs, ignore_terminations=not args.partial_reset, record_metrics=True)
+    eval_envs = ManiSkillVectorEnv(eval_envs, args.num_eval_envs, ignore_terminations=not args.eval_partial_reset, record_metrics=True)
+    assert isinstance(envs.single_action_space, gym.spaces.Box), "only continuous action space is supported"
+
+    max_episode_steps = gym_utils.find_max_episode_steps_value(envs._env)
+    logger = None
+    if not args.evaluate:
+        print("Running training")
+        if args.track:
+            import wandb
+            config = vars(args)
+            config["env_cfg"] = dict(**env_kwargs, num_envs=args.num_envs, env_id=args.env_id, reward_mode="normalized_dense", env_horizon=max_episode_steps, partial_reset=args.partial_reset)
+            config["eval_env_cfg"] = dict(**env_kwargs, num_envs=args.num_eval_envs, env_id=args.env_id, reward_mode="normalized_dense", env_horizon=max_episode_steps, partial_reset=args.partial_reset)
+            wandb.init(
+                project=args.wandb_project_name,
+                entity=args.wandb_entity,
+                sync_tensorboard=False,
+                config=config,
+                name=run_name,
+                save_code=True,
+                group=args.wandb_group,
+                tags=["ppo", "walltime_efficient"]
+            )
+        writer = SummaryWriter(f"runs/{run_name}")
+        writer.add_text(
+            "hyperparameters",
+            "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+        )
+        logger = Logger(log_wandb=args.track, tensorboard=writer)
+    else:
+        print("Running evaluation")
+
+    # ALGO Logic: Storage setup
+    obs = DictArray((args.num_steps, args.num_envs), envs.single_observation_space, device=device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    eval_obs, _ = eval_envs.reset(seed=args.seed)
+    next_done = torch.zeros(args.num_envs, device=device)
+    print(f"####")
+    print(f"args.num_iterations={args.num_iterations} args.num_envs={args.num_envs} args.num_eval_envs={args.num_eval_envs}")
+    print(f"args.minibatch_size={args.minibatch_size} args.batch_size={args.batch_size} args.update_epochs={args.update_epochs}")
+    print(f"####")
+    agent = Agent(envs, sample_obs=next_obs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    if args.checkpoint:
+        agent.load_state_dict(torch.load(args.checkpoint))
+
+    cumulative_times = defaultdict(float)
+
+    for iteration in range(1, args.num_iterations + 1):
+        print(f"Epoch: {iteration}, global_step={global_step}")
+        final_values = torch.zeros((args.num_steps, args.num_envs), device=device)
+        agent.eval()
+        if iteration % args.eval_freq == 1:
+            print("Evaluating")
+            stime = time.perf_counter()
+            eval_obs, _ = eval_envs.reset()
+            eval_metrics = defaultdict(list)
+            num_episodes = 0
+            for _ in range(args.num_eval_steps):
+                with torch.no_grad():
+                    eval_obs, eval_rew, eval_terminations, eval_truncations, eval_infos = eval_envs.step(agent.get_action(eval_obs, deterministic=True))
+                    if "final_info" in eval_infos:
+                        mask = eval_infos["_final_info"]
+                        num_episodes += mask.sum()
+                        for k, v in eval_infos["final_info"]["episode"].items():
+                            eval_metrics[k].append(v)
+            print(f"Evaluated {args.num_eval_steps * args.num_eval_envs} steps resulting in {num_episodes} episodes")
+            for k, v in eval_metrics.items():
+                mean = torch.stack(v).float().mean()
+                if logger is not None:
+                    logger.add_scalar(f"eval/{k}", mean, global_step)
+                print(f"eval_{k}_mean={mean}")
+            if logger is not None:
+                eval_time = time.perf_counter() - stime
+                cumulative_times["eval_time"] += eval_time
+                logger.add_scalar("time/eval_time", eval_time, global_step)
+            if args.evaluate:
+                break
+        if args.save_model and iteration % args.eval_freq == 1:
+            model_path = f"runs/{run_name}/ckpt_{iteration}.pt"
+            torch.save(agent.state_dict(), model_path)
+            print(f"model saved to {model_path}")
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+        rollout_time = time.perf_counter()
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action)
+            next_done = torch.logical_or(terminations, truncations).to(torch.float32)
+            rewards[step] = reward.view(-1) * args.reward_scale
+
+            if "final_info" in infos:
+                final_info = infos["final_info"]
+                done_mask = infos["_final_info"]
+                for k, v in final_info["episode"].items():
+                    logger.add_scalar(f"train/{k}", v[done_mask].float().mean(), global_step)
+
+                for k in infos["final_observation"]:
+                    infos["final_observation"][k] = infos["final_observation"][k][done_mask]
+                with torch.no_grad():
+                    final_values[step, torch.arange(args.num_envs, device=device)[done_mask]] = agent.get_value(infos["final_observation"]).view(-1)
+        rollout_time = time.perf_counter() - rollout_time
+        cumulative_times["rollout_time"] += rollout_time
+        # bootstrap value according to termination and truncation
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    next_not_done = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    next_not_done = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                real_next_values = next_not_done * nextvalues + final_values[t] # t instead of t+1
+                # next_not_done means nextvalues is computed from the correct next_obs
+                # if next_not_done is 1, final_values is always 0
+                # if next_not_done is 0, then use final_values, which is computed according to bootstrap_at_done
+                if args.finite_horizon_gae:
+                    """
+                    See GAE paper equation(16) line 1, we will compute the GAE based on this line only
+                    1             *(  -V(s_t)  + r_t                                                               + gamma * V(s_{t+1})   )
+                    lambda        *(  -V(s_t)  + r_t + gamma * r_{t+1}                                             + gamma^2 * V(s_{t+2}) )
+                    lambda^2      *(  -V(s_t)  + r_t + gamma * r_{t+1} + gamma^2 * r_{t+2}                         + ...                  )
+                    lambda^3      *(  -V(s_t)  + r_t + gamma * r_{t+1} + gamma^2 * r_{t+2} + gamma^3 * r_{t+3}
+                    We then normalize it by the sum of the lambda^i (instead of 1-lambda)
+                    """
+                    if t == args.num_steps - 1: # initialize
+                        lam_coef_sum = 0.
+                        reward_term_sum = 0. # the sum of the second term
+                        value_term_sum = 0. # the sum of the third term
+                    lam_coef_sum = lam_coef_sum * next_not_done
+                    reward_term_sum = reward_term_sum * next_not_done
+                    value_term_sum = value_term_sum * next_not_done
+
+                    lam_coef_sum = 1 + args.gae_lambda * lam_coef_sum
+                    reward_term_sum = args.gae_lambda * args.gamma * reward_term_sum + lam_coef_sum * rewards[t]
+                    value_term_sum = args.gae_lambda * args.gamma * value_term_sum + args.gamma * real_next_values
+
+                    advantages[t] = (reward_term_sum + value_term_sum) / lam_coef_sum - values[t]
+                else:
+                    delta = rewards[t] + args.gamma * real_next_values - values[t]
+                    advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * next_not_done * lastgaelam # Here actually we should use next_not_terminated, but we don't have lastgamlam if terminated
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,))
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        agent.train()
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        update_time = time.perf_counter()
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                if args.target_kl is not None and approx_kl > args.target_kl:
+                    break
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+        update_time = time.perf_counter() - update_time
+        cumulative_times["update_time"] += update_time
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        logger.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        logger.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        logger.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        logger.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        logger.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        logger.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        logger.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        logger.add_scalar("losses/explained_variance", explained_var, global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        logger.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+        logger.add_scalar("time/step", global_step, global_step)
+        logger.add_scalar("time/update_time", update_time, global_step)
+        logger.add_scalar("time/rollout_time", rollout_time, global_step)
+        logger.add_scalar("time/rollout_fps", args.num_envs * args.num_steps / rollout_time, global_step)
+        for k, v in cumulative_times.items():
+            logger.add_scalar(f"time/total_{k}", v, global_step)
+        logger.add_scalar("time/total_rollout+update_time", cumulative_times["rollout_time"] + cumulative_times["update_time"], global_step)
+    if args.save_model and not args.evaluate:
+        model_path = f"runs/{run_name}/final_ckpt.pt"
+        torch.save(agent.state_dict(), model_path)
+        print(f"model saved to {model_path}")
+
+    envs.close()
+    if logger is not None: logger.close()

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/README.md

@@ -0,0 +1,77 @@
+# Temporal Difference Learning for Model Predictive Control 2 (TD-MPC2)
+
+Scalable, robust model-based RL algorithm based on ["TD-MPC2: Scalable, Robust World Models for Continuous Control"](https://arxiv.org/abs/2310.16828). Code adapted from https://github.com/nicklashansen/tdmpc2. It is written to work with the new Maniskill update, and supports vectorized state-based and visual-based RL environment.
+
+## Installation
+We recommend using conda/mamba and you can install the dependencies as so :
+
+```bash
+conda env create -f environment.yaml
+conda activate tdmpc2-ms
+```
+
+or follow the [original repo](https://github.com/nicklashansen/tdmpc2)'s guide to build the docker image.
+
+
+## State Based RL
+
+Simple command to run the algorithm with default configs (5M params, 1M steps, default control mode, 32 envs, state obs mode) :
+```bash
+python train.py env_id=PushCube-v1
+```
+
+More advanced command with optional configs : (More can be found in config.yaml)
+```bash
+python train.py model_size=5 steps=1_000_000 seed=1 exp_name=default \
+  env_id=PushCube-v1 env_type=gpu num_envs=32 control_mode=pd_ee_delta_pose obs=state \
+  save_video_local=false wandb=true wandb_entity=??? wandb_project=??? wandb_group=??? wandb_name=??? setting_tag=??? 
+```
+(*) The optional *setting_tag* is for adding a specific tag in the wandb log (e.g. sample_efficient, walltime_efficient, etc.)
+
+## Visual (RGB) Based RL
+
+The visual based RL expects model_size = 5. Also, make sure you have sufficient CPU memory, otherwise lower the buffer_size and use gpu env.
+```bash
+python train.py buffer_size=500_000 steps=5_000_000 seed=1 exp_name=default \
+  env_id=PushCube-v1 env_type=gpu num_envs=32 control_mode=pd_ee_delta_pose obs=rgb \
+  save_video_local=false wandb=true wandb_entity=??? wandb_project=??? wandb_group=??? wandb_name=??? setting_tag=???
+```
+
+## Replaying Evaluation Trajectories
+
+To create videos of a checkpoint model, use the following command.
+
+```bash
+python evaluate.py model_size=5 seed=1 exp_name=default \ 
+  env_id=PushCube-v1 control_mode=pd_ee_delta_pose obs=state \
+  save_video_local=true checkpoint=/absolute/path/to/checkpoint.pt
+```
+
+* Make sure you specify the same control_mode the model was trained on if it's not default.
+* The video are saved under ```logs/{env_id}/{seed}/{exp_name}/videos```
+* The number of video saved is determined by ```num_envs * eval_episodes_per_env```
+
+## Some Notes
+
+- Multi-task TD-MPC2 isn't supported for Maniskill at the moment.
+
+## Citation
+
+If you use this baseline please cite the following
+```
+@inproceedings{hansen2024tdmpc2,
+  title={TD-MPC2: Scalable, Robust World Models for Continuous Control}, 
+  author={Nicklas Hansen and Hao Su and Xiaolong Wang},
+  booktitle={International Conference on Learning Representations (ICLR)},
+  year={2024}
+}
+```
+as well as the original TD-MPC paper:
+```
+@inproceedings{hansen2022tdmpc,
+  title={Temporal Difference Learning for Model Predictive Control},
+  author={Nicklas Hansen and Xiaolong Wang and Hao Su},
+  booktitle={International Conference on Machine Learning (ICML)},
+  year={2022}
+}
+```

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/common/buffer.py

@@ -0,0 +1,101 @@
+import torch
+from tensordict.tensordict import TensorDict
+from torchrl.data.replay_buffers import ReplayBuffer, LazyTensorStorage
+from torchrl.data.replay_buffers.samplers import SliceSampler
+
+
+class Buffer():
+	"""
+	Replay buffer for TD-MPC2 training. Based on torchrl.
+	Uses CUDA memory if available, and CPU memory otherwise.
+	"""
+
+	def __init__(self, cfg):
+		self.cfg = cfg
+		self._device = torch.device('cuda')
+		self._capacity = min(cfg.buffer_size, cfg.steps)
+		self._sampler = SliceSampler(
+			num_slices=self.cfg.batch_size,
+			end_key=None,
+			traj_key='episode',
+			truncated_key=None,
+			strict_length=True,
+		)
+		self._batch_size = cfg.batch_size * (cfg.horizon+1)
+		self._num_eps = 0
+
+	@property
+	def capacity(self):
+		"""Return the capacity of the buffer."""
+		return self._capacity
+	
+	@property
+	def num_eps(self):
+		"""Return the number of episodes in the buffer."""
+		return self._num_eps
+
+	def _reserve_buffer(self, storage):
+		"""
+		Reserve a buffer with the given storage.
+		"""
+		return ReplayBuffer(
+			storage=storage,
+			sampler=self._sampler,
+			pin_memory=True,
+			prefetch=int(self.cfg.num_envs / self.cfg.steps_per_update),
+			batch_size=self._batch_size,
+		)
+
+	def _init(self, tds):
+		"""Initialize the replay buffer. Use the first episode to estimate storage requirements."""
+		print(f'Buffer capacity: {self._capacity:,}')
+		mem_free, _ = torch.cuda.mem_get_info()
+		bytes_per_step = sum([
+				(v.numel()*v.element_size() if not isinstance(v, TensorDict) \
+				else sum([x.numel()*x.element_size() for x in v.values()])) \
+			for v in tds.values()
+		]) / len(tds)
+		total_bytes = bytes_per_step*self._capacity
+		print(f'Storage required: {total_bytes/1e9:.2f} GB')
+		# Heuristic: decide whether to use CUDA or CPU memory
+		storage_device = 'cuda' if 2.5*total_bytes < mem_free else 'cpu'
+		print(f'Using {storage_device.upper()} memory for storage.')
+		return self._reserve_buffer(
+			LazyTensorStorage(self._capacity, device=torch.device(storage_device))
+		)
+
+	def _to_device(self, *args, device=None):
+		if device is None:
+			device = self._device
+		return (arg.to(device, non_blocking=True) \
+			if arg is not None else None for arg in args)
+
+	def _prepare_batch(self, td):
+		"""
+		Prepare a sampled batch for training (post-processing).
+		Expects `td` to be a TensorDict with batch size TxB.
+		"""
+		obs = td['obs']
+		action = td['action'][1:]
+		reward = td['reward'][1:].unsqueeze(-1)
+		task = td['task'][0] if 'task' in td.keys() else None
+		return self._to_device(obs, action, reward, task)
+
+	def add(self, td):
+		"""Add an episode to the buffer. 
+		Before vec: td[episode_len+1, ..] ..=act_dim, obs_dim, None
+		After: add num_env to the batch dimension
+		Note: for official vec code @51d6b8d, it seems to have batch dimension [episode_len+1, num_env]"""
+
+		for _td in td:
+			_td['episode'] = torch.ones_like(_td['reward'], dtype=torch.int64) * self._num_eps
+			if self._num_eps == 0:
+				self._buffer = self._init(_td)
+			self._buffer.extend(_td)
+			self._num_eps += 1
+		return self._num_eps
+
+	def sample(self):
+		"""Sample a batch of subsequences from the buffer."""
+		td = self._buffer.sample().view(-1, self.cfg.horizon+1).permute(1, 0)
+		return self._prepare_batch(td)

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/common/init.py

@@ -0,0 +1,22 @@
+import torch.nn as nn
+
+
+def weight_init(m):
+	"""Custom weight initialization for TD-MPC2."""
+	if isinstance(m, nn.Linear):
+		nn.init.trunc_normal_(m.weight, std=0.02)
+		if m.bias is not None:
+			nn.init.constant_(m.bias, 0)
+	elif isinstance(m, nn.Embedding):
+		nn.init.uniform_(m.weight, -0.02, 0.02)
+	elif isinstance(m, nn.ParameterList):
+		for i,p in enumerate(m):
+			if p.dim() == 3: # Linear
+				nn.init.trunc_normal_(p, std=0.02) # Weight
+				nn.init.constant_(m[i+1], 0) # Bias
+
+
+def zero_(params):
+	"""Initialize parameters to zero."""
+	for p in params:
+		p.data.fill_(0)

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/common/logger.py

@@ -0,0 +1,208 @@
+import os
+import datetime
+import re
+import numpy as np
+import pandas as pd
+from termcolor import colored
+from omegaconf import OmegaConf
+from mani_skill.utils.visualization.misc import tile_images
+import wandb
+from common import TASK_SET
+
+
+CONSOLE_FORMAT = [
+	("iteration", "I", "int"),
+	("episode", "E", "int"),
+	("step", "I", "int"),
+	("return", "R", "float"),
+	("success_once", "S", "float"),
+	("fail_once", "F", "float"),
+	("total_time", "T", "time"),
+	# Added for maniskill rl baselines matrics
+	# ("reward", "RET", "float"), 
+	# ("episode_len", "L", "int"), 
+	# ("rollout_time", "RT", "float"), 
+	# ("rollout_fps", "RF", "float"), 
+	# ("update_time", "U", "float"), 
+
+]
+
+CAT_TO_COLOR = {
+	"pretrain": "yellow",
+	"train": "blue",
+	"eval": "green",
+	# Added for maniskill rl baselines matrics
+	"time" : "magenta", 
+}
+
+
+def make_dir(dir_path):
+	"""Create directory if it does not already exist."""
+	try:
+		os.makedirs(dir_path)
+	except OSError:
+		pass
+	return dir_path
+
+
+def print_run(cfg): # this function has to be called after make_env
+	"""
+	Pretty-printing of current run information.
+	Logger calls this method at initialization.
+	"""
+	prefix, color, attrs = "  ", "green", ["bold"]
+
+	def _limstr(s, maxlen=36):
+		return str(s[:maxlen]) + "..." if len(str(s)) > maxlen else s
+
+	def _pprint(k, v):
+		print(
+			prefix + colored(f'{k.capitalize()+":":<15}', color, attrs=attrs), _limstr(v)
+		)
+
+	observations  = ", ".join([str(v) for v in cfg.obs_shape.values()])
+	kvs = [
+		("task", cfg.env_id),
+		("sim backend", cfg.env_type),
+		("steps", f"{int(cfg.steps):,}"),
+		("observations", observations),
+		("actions", cfg.action_dim),
+		("experiment", cfg.exp_name),
+	]
+	w = np.max([len(_limstr(str(kv[1]))) for kv in kvs]) + 25
+	div = "-" * w
+	print(div)
+	for k, v in kvs:
+		_pprint(k, v)
+	print(div)
+
+
+def cfg_to_group(cfg, return_list=False):
+	"""
+	Return a wandb-safe group name for logging.
+	Optionally returns group name as list.
+	"""
+	lst = [cfg.env_id, re.sub("[^0-9a-zA-Z]+", "-", cfg.exp_name)]
+	return lst if return_list else "-".join(lst)
+class Logger:
+	"""Primary logging object. Logs either locally or using wandb."""
+
+	def __init__(self, cfg, manager = None):
+		self.cfg = cfg
+		self._log_dir = make_dir(cfg.work_dir)
+		self._model_dir = make_dir(self._log_dir / "models")
+		self._save_csv = cfg.save_csv
+		self._save_agent = cfg.save_agent
+		self._group = cfg_to_group(cfg)
+		self._seed = cfg.seed
+		self._eval = []
+		self.save_video_local = cfg.save_video_local
+		# Set up wandb
+		self.project = cfg.get("wandb_project", "none")
+		self.entity = cfg.get("wandb_entity", "none")
+		self.name = cfg.get("wandb_name", "none")
+		self.group = cfg.get("wandb_group", "none")
+		if not cfg.wandb or self.project == "none" or self.entity == "none":
+			print(colored("Wandb disabled.", "blue", attrs=["bold"]))
+			self._wandb = None
+		else:
+			print(colored("Logs will be synced with wandb.", "blue", attrs=["bold"]))
+			os.environ["WANDB_SILENT"] = "true" if cfg.wandb_silent else "false"
+			# Modified for Maniskill RL Baseline Logging Convention
+			wandb_tags = cfg_to_group(cfg, return_list=True) + [f"seed:{cfg.seed}"] + ["tdmpc2"]
+			if cfg.setting_tag != 'none':
+				wandb_tags += [cfg.setting_tag]
+			self._wandb = wandb.init(
+				project=self.project,
+				entity=self.entity,
+				name=self.name,
+				group=self.group,
+				tags=wandb_tags,
+				dir=self._log_dir,
+				config=OmegaConf.to_container(cfg, resolve=True),
+			)
+		
+		self.wandb_videos = manager.list()
+		self.lock = manager.Lock()
+
+	@property
+	def model_dir(self):
+		return self._model_dir
+
+	def save_agent(self, agent=None, identifier='final'):
+		if self._save_agent and agent:
+			fp = self._model_dir / f'{str(identifier)}.pt'
+			agent.save(fp)
+			if self._wandb:
+				artifact = wandb.Artifact(
+					self.group + '-' + str(self._seed) + '-' + str(identifier),
+					type='model',
+				)
+				artifact.add_file(fp)
+				self._wandb.log_artifact(artifact)
+
+	def finish(self, agent=None):
+		try:
+			self.save_agent(agent)
+		except Exception as e:
+			print(colored(f"Failed to save model: {e}", "red"))
+		if self._wandb:
+			self._wandb.finish()
+
+	def _format(self, key, value, ty):
+		if ty == "int":
+			return f'{colored(key+":", "blue")} {int(value):,}'
+		elif ty == "float":
+			return f'{colored(key+":", "blue")} {value:.02f}'
+		elif ty == "time":
+			value = str(datetime.timedelta(seconds=int(value)))
+			return f'{colored(key+":", "blue")} {value}'
+		else:
+			raise f"invalid log format type: {ty}"
+
+	def _print(self, d, category):
+		category = colored(category, CAT_TO_COLOR[category])
+		pieces = [f" {category:<14}"]
+		for k, disp_k, ty in CONSOLE_FORMAT:
+			if k in d:
+				pieces.append(f"{self._format(disp_k, d[k], ty):<22}")
+		print("   ".join(pieces))
+
+	def add_wandb_video(self, frames: np.ndarray): # (num_envs, num_frames, h, w, 3)
+		with self.lock:
+			if self.cfg.wandb and len(frames) > 0:
+				self.wandb_videos.extend(frames)
+            
+
+	def log_wandb_video(self, step, fps=15, key='videos/eval_video'):
+		with self.lock:
+			if self.cfg.wandb and len(self.wandb_videos) > 0 :
+				nrows = int(np.sqrt(len(self.wandb_videos)))
+				wandb_video = np.stack(self.wandb_videos)
+				wandb_video = wandb_video.transpose(1, 0, 2, 3, 4)
+				wandb_video = [tile_images(rgbs, nrows=nrows) for rgbs in wandb_video]
+				wandb_video = np.stack(wandb_video)
+				self.wandb_videos[:] = []
+				return self._wandb.log(
+					{key: wandb.Video(wandb_video.transpose(0, 3, 1, 2), fps=fps, format='mp4')}, step=step
+				)
+
+	def log(self, d, category="train"):
+		assert category in CAT_TO_COLOR.keys(), f"invalid category: {category}"
+		if self._wandb:
+			if category in {"train", "eval", "time"}:
+				xkey = "step"
+			elif category == "pretrain":
+				xkey = "iteration"
+			_d = dict()
+			for k, v in d.items():
+				_d[category + "/" + k] = v
+			self._wandb.log(_d, step=d[xkey])
+		if category == "eval" and self._save_csv:
+			keys = ["step", "return"]
+			self._eval.append(np.array([d[keys[0]], d[keys[1]]]))
+			pd.DataFrame(np.array(self._eval)).to_csv(
+				self._log_dir / "eval.csv", header=keys, index=None
+			)
+		if category != 'time':
+			self._print(d, category)

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/common/scale.py

@@ -0,0 +1,48 @@
+import torch
+
+
+class RunningScale:
+	"""Running trimmed scale estimator."""
+
+	def __init__(self, cfg):
+		self.cfg = cfg
+		self._value = torch.ones(1, dtype=torch.float32, device=torch.device('cuda'))
+		self._percentiles = torch.tensor([5, 95], dtype=torch.float32, device=torch.device('cuda'))
+
+	def state_dict(self):
+		return dict(value=self._value, percentiles=self._percentiles)
+
+	def load_state_dict(self, state_dict):
+		self._value.data.copy_(state_dict['value'])
+		self._percentiles.data.copy_(state_dict['percentiles'])
+
+	@property
+	def value(self):
+		return self._value.cpu().item()
+
+	def _percentile(self, x):
+		x_dtype, x_shape = x.dtype, x.shape
+		x = x.view(x.shape[0], -1)
+		in_sorted, _ = torch.sort(x, dim=0)
+		positions = self._percentiles * (x.shape[0]-1) / 100
+		floored = torch.floor(positions)
+		ceiled = floored + 1
+		ceiled[ceiled > x.shape[0] - 1] = x.shape[0] - 1
+		weight_ceiled = positions-floored
+		weight_floored = 1.0 - weight_ceiled
+		d0 = in_sorted[floored.long(), :] * weight_floored[:, None]
+		d1 = in_sorted[ceiled.long(), :] * weight_ceiled[:, None]
+		return (d0+d1).view(-1, *x_shape[1:]).type(x_dtype)
+
+	def update(self, x):
+		percentiles = self._percentile(x.detach())
+		value = torch.clamp(percentiles[1] - percentiles[0], min=1.)
+		self._value.data.lerp_(value, self.cfg.tau)
+
+	def __call__(self, x, update=False):
+		if update:
+			self.update(x)
+		return x * (1/self.value)
+
+	def __repr__(self):
+		return f'RunningScale(S: {self.value})'

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/common/seed.py

@@ -0,0 +1,12 @@
+import random
+
+import numpy as np
+import torch
+
+
+def set_seed(seed):
+	"""Set seed for reproducibility."""
+	random.seed(seed)
+	np.random.seed(seed)
+	torch.manual_seed(seed)
+	torch.cuda.manual_seed_all(seed)

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/common/world_model.py

@@ -0,0 +1,178 @@
+from copy import deepcopy
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+from common import layers, math, init
+
+
+class WorldModel(nn.Module):
+	"""
+	TD-MPC2 implicit world model architecture.
+	Can be used for both single-task and multi-task experiments.
+	"""
+
+	def __init__(self, cfg):
+		super().__init__()
+		self.cfg = cfg
+		if cfg.multitask:
+			self._task_emb = nn.Embedding(len(cfg.tasks), cfg.task_dim, max_norm=1)
+			self._action_masks = torch.zeros(len(cfg.tasks), cfg.action_dim)
+			for i in range(len(cfg.tasks)):
+				self._action_masks[i, :cfg.action_dims[i]] = 1.
+		self._encoder = layers.enc(cfg)
+		self._dynamics = layers.mlp(cfg.latent_dim + cfg.action_dim + cfg.task_dim, 2*[cfg.mlp_dim], cfg.latent_dim, act=layers.SimNorm(cfg))
+		self._reward = layers.mlp(cfg.latent_dim + cfg.action_dim + cfg.task_dim, 2*[cfg.mlp_dim], max(cfg.num_bins, 1))
+		self._pi = layers.mlp(cfg.latent_dim + cfg.task_dim, 2*[cfg.mlp_dim], 2*cfg.action_dim)
+		self._Qs = layers.Ensemble([layers.mlp(cfg.latent_dim + cfg.action_dim + cfg.task_dim, 2*[cfg.mlp_dim], 
+										 	   max(cfg.num_bins, 1), dropout=cfg.dropout) for _ in range(cfg.num_q)])
+		self.apply(init.weight_init)
+		init.zero_([self._reward[-1].weight, self._Qs.params[-2]])
+		self._target_Qs = deepcopy(self._Qs).requires_grad_(False)
+		self.log_std_min = torch.tensor(cfg.log_std_min)
+		self.log_std_dif = torch.tensor(cfg.log_std_max) - self.log_std_min
+
+	@property
+	def total_params(self):
+		return sum(p.numel() for p in self.parameters() if p.requires_grad)
+		
+	def to(self, *args, **kwargs):
+		"""
+		Overriding `to` method to also move additional tensors to device.
+		"""
+		super().to(*args, **kwargs)
+		if self.cfg.multitask:
+			self._action_masks = self._action_masks.to(*args, **kwargs)
+		self.log_std_min = self.log_std_min.to(*args, **kwargs)
+		self.log_std_dif = self.log_std_dif.to(*args, **kwargs)
+		return self
+	
+	def train(self, mode=True):
+		"""
+		Overriding `train` method to keep target Q-networks in eval mode.
+		"""
+		super().train(mode)
+		self._target_Qs.train(False)
+		return self
+
+	def track_q_grad(self, mode=True):
+		"""
+		Enables/disables gradient tracking of Q-networks.
+		Avoids unnecessary computation during policy optimization.
+		This method also enables/disables gradients for task embeddings.
+		"""
+		for p in self._Qs.parameters():
+			p.requires_grad_(mode)
+		if self.cfg.multitask:
+			for p in self._task_emb.parameters():
+				p.requires_grad_(mode)
+
+	def soft_update_target_Q(self):
+		"""
+		Soft-update target Q-networks using Polyak averaging.
+		"""
+		with torch.no_grad():
+			for p, p_target in zip(self._Qs.parameters(), self._target_Qs.parameters()):
+				p_target.data.lerp_(p.data, self.cfg.tau)
+	
+	def task_emb(self, x, task):
+		"""
+		Continuous task embedding for multi-task experiments.
+		Retrieves the task embedding for a given task ID `task`
+		and concatenates it to the input `x`.
+		"""
+		if isinstance(task, int):
+			task = torch.tensor([task], device=x.device)
+		emb = self._task_emb(task.long())
+		if x.ndim == 3:
+			emb = emb.unsqueeze(0).repeat(x.shape[0], 1, 1)
+		elif emb.shape[0] == 1:
+			emb = emb.repeat(x.shape[0], 1)
+		return torch.cat([x, emb], dim=-1)
+
+	def encode(self, obs, task):
+		"""
+		Encodes an observation into its latent representation. Online trainer obs is [1, obs_shape], task is None
+		This implementation assumes a single state-based observation. Should be already batched.
+		Should be ok.
+		"""
+		if self.cfg.multitask:
+			obs = self.task_emb(obs, task)
+		if self.cfg.obs == 'rgb' and obs.ndim == 5:
+			return torch.stack([self._encoder[self.cfg.obs](o) for o in obs])
+		return self._encoder[self.cfg.obs](obs)
+
+	def next(self, z, a, task):
+		"""
+		z[]
+		Predicts the next latent state given the current latent state and action.
+		"""
+		if self.cfg.multitask:
+			z = self.task_emb(z, task)
+		z = torch.cat([z, a], dim=-1)
+		return self._dynamics(z)
+	
+	def reward(self, z, a, task):
+		"""
+		Predicts instantaneous (single-step) reward.
+		"""
+		if self.cfg.multitask:
+			z = self.task_emb(z, task)
+		z = torch.cat([z, a], dim=-1)
+		return self._reward(z)
+
+	def pi(self, z, task):
+		"""
+		z[~, 1]
+		Return  mu[~, action_dim], pi[~, action_dim], log_pi[~, 1], log_std[~, action_dim]
+
+		Samples an action from the policy prior.
+		The policy prior is a Gaussian distribution with
+		mean and (log) std predicted by a neural network.
+		"""
+		if self.cfg.multitask:
+			z = self.task_emb(z, task)
+
+		# Gaussian policy prior
+		mu, log_std = self._pi(z).chunk(2, dim=-1)
+		log_std = math.log_std(log_std, self.log_std_min, self.log_std_dif)
+		eps = torch.randn_like(mu)
+
+		if self.cfg.multitask: # Mask out unused action dimensions
+			mu = mu * self._action_masks[task]
+			log_std = log_std * self._action_masks[task]
+			eps = eps * self._action_masks[task]
+			action_dims = self._action_masks.sum(-1)[task].unsqueeze(-1)
+		else: # No masking
+			action_dims = None
+
+		log_pi = math.gaussian_logprob(eps, log_std, size=action_dims)
+		pi = mu + eps * log_std.exp()
+		mu, pi, log_pi = math.squash(mu, pi, log_pi)
+
+		return mu, pi, log_pi, log_std
+
+	def Q(self, z, a, task, return_type='min', target=False):
+		"""
+		Predict state-action value. z[~, latent_dim], a[~, action_dim] -> [num_q, ~, num_bins] if all else [~, 1]
+		`return_type` can be one of [`min`, `avg`, `all`]:
+			- `min`: return the minimum of two randomly subsampled Q-values.
+			- `avg`: return the average of two randomly subsampled Q-values.
+			- `all`: return all Q-values.
+		`target` specifies whether to use the target Q-networks or not.
+		"""
+		assert return_type in {'min', 'avg', 'all'}
+
+		if self.cfg.multitask:
+			z = self.task_emb(z, task)
+			
+		z = torch.cat([z, a], dim=-1)
+		out = (self._target_Qs if target else self._Qs)(z)
+
+		if return_type == 'all':
+			return out
+
+		Q1, Q2 = out[np.random.choice(self.cfg.num_q, 2, replace=False)]
+		Q1, Q2 = math.two_hot_inv(Q1, self.cfg), math.two_hot_inv(Q2, self.cfg)
+		return torch.min(Q1, Q2) if return_type == 'min' else (Q1 + Q2) / 2

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/config.yaml

@@ -0,0 +1,120 @@
+defaults:
+    - override hydra/launcher: submitit_local
+
+# environment
+env_id: PushCube-v1
+obs: state # or rgb
+control_mode: default # or pd_joint_delta_pos or pd_ee_delta_pose
+num_envs: 32
+num_eval_envs: 4
+env_type: gpu # cpu
+render_mode: rgb_array # ['rgb_array' for quality, or 'sensors' for speed]
+render_size: 64
+setting_tag: none # ['none', 'walltime_efficient', 'sample_efficient', ...] for wandb tags
+
+# evaluation
+checkpoint: ???
+eval_episodes_per_env: 2 # total (eval_episodes_per_env * num_eval_envs number) of eval episodes
+eval_freq: 50000
+
+# training
+steps: 1_000_000
+batch_size: 256
+reward_coef: 0.1
+value_coef: 0.1
+consistency_coef: 20
+rho: 0.5
+lr: 3e-4
+enc_lr_scale: 0.3
+grad_clip_norm: 20
+tau: 0.01
+discount_denom: 5
+discount_min: 0.95
+discount_max: 0.995
+buffer_size: 1_000_000
+exp_name: default
+data_dir: ???
+steps_per_update: 1
+
+# planning
+mpc: true
+iterations: 6
+num_samples: 512
+num_elites: 64
+num_pi_trajs: 24
+horizon: 3
+min_std: 0.05
+max_std: 2
+temperature: 0.5
+
+# actor
+log_std_min: -10
+log_std_max: 2
+entropy_coef: 1e-4
+
+# critic
+num_bins: 101
+vmin: -10
+vmax: +10
+
+# architecture
+model_size: ???
+num_enc_layers: 2
+enc_dim: 256
+num_channels: 32
+mlp_dim: 512
+latent_dim: 512
+task_dim: 0
+num_q: 5
+dropout: 0.01
+simnorm_dim: 8
+
+# logging
+wandb_project:
+wandb_group: 
+wandb_name:
+wandb_entity: 
+wandb_silent: false
+wandb: false # enable wandb
+save_csv: true
+
+# misc
+save_video_local: false # save video in eval_video for evaluation during training
+save_agent: true
+seed: 1
+
+# convenience
+work_dir: ???
+task_title: ???
+multitask: ???
+tasks: ???
+obs_shape: ???
+action_dim: ???
+episode_length: ???
+obs_shapes: ???
+action_dims: ???
+episode_lengths: ???
+seed_steps: ???
+bin_size: ???
+
+# Added for Maniskill RL Baselines Config Convention (don't assign to them)
+env_cfg:
+    env_id: ???
+    control_mode: ??? # pd_joint_delta_pos or pd_ee_delta_pose
+    obs_mode: ???
+    reward_mode: ??? 
+    num_envs: ???
+    sim_backend: ??? # cpu or gpu
+    partial_reset: false
+    env_horizon: ???
+eval_env_cfg:
+    env_id: ???
+    control_mode: ???
+    obs_mode: ???
+    reward_mode: ???
+    num_envs: ???
+    sim_backend: ???
+    env_horizon: ???
+    partial_reset: false
+    num_eval_episodes: ???
+discount: ???

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/environment.yaml

@@ -0,0 +1,67 @@
+name: tdmpc2-ms
+channels:
+  - pytorch-nightly
+  - nvidia
+  - conda-forge
+  - defaults
+dependencies:
+  - cudatoolkit=11.7
+  - glew=2.1.0
+  - glib=2.68.4
+  - pip=21.0
+  - python=3.9.0
+  - pytorch>=2.2.2
+  - torchvision>=0.16.2
+  - pip:
+    - absl-py==2.0.0
+    - "cython<3"
+    - dm-control==1.0.8
+    - ffmpeg==1.4
+    - glfw==2.6.4
+    - hydra-core==1.3.2
+    - hydra-submitit-launcher==1.2.0
+    - imageio==2.33.1
+    - imageio-ffmpeg==0.4.9
+    - kornia==0.7.1
+    - moviepy==1.0.3
+    - mujoco==2.3.1
+    - mujoco-py==2.1.2.14
+    - numpy==1.23.5
+    - omegaconf==2.3.0
+    - open3d==0.18.0
+    - opencv-contrib-python==4.9.0.80
+    - opencv-python==4.9.0.80
+    - pandas==2.1.4
+    - sapien==3.0.0.b1
+    - submitit==1.5.1
+    - setuptools==65.5.0
+    - patchelf==0.17.2.1
+    - protobuf==4.25.2
+    - pillow==10.2.0
+    - pyquaternion==0.9.9
+    - tensordict-nightly==2024.3.26
+    - termcolor==2.4.0
+    - torchrl-nightly==2024.3.26
+    - transforms3d==0.4.1
+    - trimesh==4.0.9
+    - tqdm==4.66.1
+    - wandb==0.16.2
+    - wheel==0.38.0
+    - mani_skill>=3.0.0b12
+    ####################
+    # Gym:
+    # (unmaintained but required for maniskill2/meta-world/myosuite)
+    # - gym==0.21.0
+    ####################
+    # ManiSkill2:
+    # (requires gym==0.21.0 which occasionally breaks)
+    # - mani-skill2==0.4.1
+    ####################
+    # Meta-World:
+    # (requires gym==0.21.0 which occasionally breaks)
+    # - git+https://github.com/Farama-Foundation/Metaworld.git@04be337a12305e393c0caf0cbf5ec7755c7c8feb
+    ####################
+    # MyoSuite:
+    # (requires gym==0.13 which conflicts with meta-world / mani-skill2)
+    # - myosuite
+    ####################

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/evaluate.py

@@ -0,0 +1,124 @@
+import os
+os.environ['MUJOCO_GL'] = 'egl'
+import warnings
+warnings.filterwarnings('ignore')
+
+import hydra
+import imageio
+import numpy as np
+import torch
+from termcolor import colored
+
+from common.parser import parse_cfg
+from common.seed import set_seed
+from envs import make_envs
+from tdmpc2 import TDMPC2
+
+torch.backends.cudnn.benchmark = True
+
+
+@hydra.main(config_name='config', config_path='.')
+def evaluate(cfg: dict):
+	"""
+	Script for evaluating a single-task / multi-task TD-MPC2 checkpoint.
+
+	Most relevant args:
+		`env_id`: task name (eg. PickCube-v0)
+		`model_size`: model size, must be one of `[1, 5, 19, 48, 317]` (default: 5)
+		`checkpoint`: path to model checkpoint to load
+		`eval_episodes`: number of episodes to evaluate on per task (default: 10)
+		`save_video_local`: whether to save a video of the evaluation (default: True)
+		`seed`: random seed (default: 1)
+	
+	See config.yaml for a full list of args.
+
+	Example usage:
+	````
+		$ python evaluate.py task=mt80 model_size=48 checkpoint=/path/to/mt80-48M.pt
+		$ python evaluate.py task=mt30 model_size=317 checkpoint=/path/to/mt30-317M.pt
+		$ python evaluate.py task=dog-run checkpoint=/path/to/dog-1.pt save_video_local=true
+	```
+	"""
+	assert torch.cuda.is_available()
+	assert cfg.eval_episodes_per_env > 0, 'Must evaluate at least 1 episode.'
+	eval_episodes = cfg.eval_episodes_per_env * cfg.num_eval_envs
+	cfg.num_envs = 1 # to keep the code similar and logging video simpler
+	cfg = parse_cfg(cfg)
+	assert not cfg.multitask, colored('Warning: multi-task models is not currently supported for maniskill.', 'red', attrs=['bold'])
+	set_seed(cfg.seed)
+	print(colored(f'Task: {cfg.env_id}', 'blue', attrs=['bold']))
+	print(colored(f'Model size: {cfg.get("model_size", "default")}', 'blue', attrs=['bold']))
+	print(colored(f'Checkpoint: {cfg.checkpoint}', 'blue', attrs=['bold']))
+
+	# Make environment
+	env = make_envs(cfg, cfg.num_envs, is_eval=True)
+
+	# Load agent
+	agent = TDMPC2(cfg)
+	assert os.path.exists(cfg.checkpoint), f'Checkpoint {cfg.checkpoint} not found! Must be a valid filepath.'
+	agent.load(cfg.checkpoint)
+	
+	# Evaluate
+	if cfg.multitask:
+		print(colored(f'Evaluating agent on {len(cfg.tasks)} tasks:', 'yellow', attrs=['bold']))
+	else:
+		print(colored(f'Evaluating agent on {cfg.env_id}:', 'yellow', attrs=['bold']))
+	if cfg.save_video_local:
+		video_dir = os.path.join(cfg.work_dir, 'videos')
+		os.makedirs(video_dir, exist_ok=True)
+	scores = []
+	tasks = cfg.tasks if cfg.multitask else [cfg.env_id]
+	for task_idx, task in enumerate(tasks):
+		if not cfg.multitask:
+			task_idx = None
+		has_success, has_fail = False, False # if task has success or/and fail (added for maniskill)
+		ep_rewards, ep_successes, ep_fails = [], [], []
+		for i in range(eval_episodes):
+			obs, _ = env.reset()
+			done = False # ms3: done is truncated since the ms3 ignore_terminations.
+			ep_reward, t = 0, 0
+			if cfg.save_video_local:
+				frames = [env.render().squeeze()]
+			while not done: # done is truncated and should be the same
+				action = agent.act(obs, t0=t==0)
+				obs, reward, terminated, truncated, info = env.step(action)
+				done = terminated | truncated
+				ep_reward += reward
+				t += 1
+				if cfg.save_video_local:
+					frames.append(env.render().squeeze())
+			ep_rewards.append(ep_reward.mean().item())
+			if 'success' in info: 
+				has_success = True
+				ep_successes.append(info['success'].float().mean().item())
+			if 'fail' in info:
+				has_fail = True
+				ep_fails.append(info['fail'].float().mean().item())
+			if cfg.save_video_local:
+				imageio.mimsave(
+					os.path.join(video_dir, f'{task}-{i}.mp4'), frames, fps=15)
+		ep_rewards = np.nanmean(ep_rewards)
+		ep_successes = np.nanmean(ep_successes)
+		ep_fails = np.nanmean(ep_fails)
+		if cfg.multitask:
+			scores.append(ep_successes*100 if task.startswith('mw-') else ep_rewards/10)
+		if has_success and has_fail:
+			print(colored(f'  {task:<22}' \
+				f'\tR: {ep_rewards:.01f}  ' \
+				f'\tS: {ep_successes:.02f}' \
+				f'\tF: {ep_fails:.02f}', 'yellow'))
+		elif has_success:
+			print(colored(f'  {task:<22}' \
+				f'\tR: {ep_rewards:.01f}  ' \
+				f'\tS: {ep_successes:.02f}', 'yellow'))
+		elif has_fail:
+			print(colored(f'  {task:<22}' \
+				f'\tR: {ep_rewards:.01f}  ' \
+				f'\tF: {ep_fails:.02f}', 'yellow'))
+		
+	if cfg.multitask:
+		print(colored(f'Normalized score: {np.mean(scores):.02f}', 'yellow', attrs=['bold']))
+
+
+if __name__ == '__main__':
+	evaluate()

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/tdmpc2.py

@@ -0,0 +1,313 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from common import math
+from common.scale import RunningScale
+from common.world_model import WorldModel
+
+
+class TDMPC2:
+	"""
+	TD-MPC2 agent. Implements training + inference.
+	Can be used for both single-task and multi-task experiments,
+	and supports both state and pixel observations.
+	"""
+
+	def __init__(self, cfg):
+		self.cfg = cfg
+		self.device = torch.device('cuda')
+		self.model = WorldModel(cfg).to(self.device)
+		self.optim = torch.optim.Adam([
+			{'params': self.model._encoder.parameters(), 'lr': self.cfg.lr*self.cfg.enc_lr_scale},
+			{'params': self.model._dynamics.parameters()},
+			{'params': self.model._reward.parameters()},
+			{'params': self.model._Qs.parameters()},
+			{'params': self.model._task_emb.parameters() if self.cfg.multitask else []}
+		], lr=self.cfg.lr)
+		self.pi_optim = torch.optim.Adam(self.model._pi.parameters(), lr=self.cfg.lr, eps=1e-5)
+		self.model.eval()
+		self.scale = RunningScale(cfg)
+		self.cfg.iterations += 2*int(cfg.action_dim >= 20) # Heuristic for large action spaces
+		self.discount = torch.tensor(
+			[self._get_discount(ep_len) for ep_len in cfg.episode_lengths], device='cuda'
+		) if self.cfg.multitask else self._get_discount(cfg.episode_length)
+		
+		self.cfg.discount = self.discount
+
+	def _get_discount(self, episode_length):
+		"""
+		Returns discount factor for a given episode length.
+		Simple heuristic that scales discount linearly with episode length.
+		Default values should work well for most tasks, but can be changed as needed.
+
+		Args:
+			episode_length (int): Length of the episode. Assumes episodes are of fixed length.
+
+		Returns:
+			float: Discount factor for the task.
+		"""
+		frac = episode_length/self.cfg.discount_denom
+		return min(max((frac-1)/(frac), self.cfg.discount_min), self.cfg.discount_max)
+
+	def save(self, fp):
+		"""
+		Save state dict of the agent to filepath.
+		
+		Args:
+			fp (str): Filepath to save state dict to.
+		"""
+		torch.save({"model": self.model.state_dict()}, fp)
+
+	def load(self, fp):
+		"""
+		Load a saved state dict from filepath (or dictionary) into current agent.
+		
+		Args:
+			fp (str or dict): Filepath or state dict to load.
+		"""
+		state_dict = fp if isinstance(fp, dict) else torch.load(fp)
+		self.model.load_state_dict(state_dict["model"])
+
+	@torch.no_grad()
+	def act(self, obs, t0=False, eval_mode=False, task=None):
+		"""
+		Before: obs is 1d, return seems to be mu(1, action_dim)
+		After: obs is batched with num_env, return still 2d
+
+		Select an action by planning in the latent space of the world model.
+		
+		Args:
+			obs (torch.Tensor): Observation from the environment. 1d for online trainer
+			t0 (bool): Whether this is the first observation in the episode.
+			eval_mode (bool): Whether to use the mean of the action distribution.
+			task (int): Task index (only used for multi-task experiments).
+		
+		Returns:
+			torch.Tensor: Action to take in the environment.
+		"""
+		obs = obs.to(self.device, non_blocking=True)
+		if task is not None:
+			task = torch.tensor([task], device=self.device)
+		z = self.model.encode(obs, task) # [num_envs, latent_dim]
+		if self.cfg.mpc:
+			a = self.plan(z, t0=t0, eval_mode=eval_mode, task=task)
+		else:
+			a = self.model.pi(z, task)[int(not eval_mode)] # [int(not eval_mode)] selects mu or pi
+		return a.cpu()
+
+	@torch.no_grad()
+	def _estimate_value(self, z, actions, task):
+		"""z[num_samples, latent_dim], actions[horizon, num_samples, action_dim] -> [num_samples, 1]
+		Estimate value of a trajectory starting at latent state z and executing given actions."""
+		G, discount = 0, 1
+		for t in range(self.cfg.horizon):
+			reward = math.two_hot_inv(self.model.reward(z, actions[:, t], task), self.cfg)
+			z = self.model.next(z, actions[:, t], task)
+			G += discount * reward
+			discount *= self.discount[torch.tensor(task)] if self.cfg.multitask else self.discount
+		return G + discount * self.model.Q(z, self.model.pi(z, task)[1], task, return_type='avg')
+
+	@torch.no_grad()
+	def plan(self, z, t0=False, eval_mode=False, task=None):
+		"""
+		Before: For online, z[1, latent_dim]
+		After: For online z[num_envs, latent_dim]. Should be ok
+		Plan a sequence of actions using the learned world model.
+		
+		Args:
+			z (torch.Tensor): Latent state from which to plan.
+			t0 (bool): Whether this is the first observation in the episode.
+			eval_mode (bool): Whether to use the mean of the action distribution.
+			task (Torch.Tensor): Task index (only used for multi-task experiments).
+
+		Returns:
+			torch.Tensor: Action to take in the environment.
+		"""	
+		num_envs = self.cfg.num_eval_envs if eval_mode else self.cfg.num_envs
+		# Sample policy trajectories
+		if self.cfg.num_pi_trajs > 0:
+			pi_actions = torch.empty(num_envs, self.cfg.horizon, self.cfg.num_pi_trajs, self.cfg.action_dim, device=self.device)
+			_z = z.unsqueeze(1).repeat(1, self.cfg.num_pi_trajs, 1) # (num_envs, num_pi_trajs, latent_dim)
+			for t in range(self.cfg.horizon-1):
+				pi_actions[:, t] = self.model.pi(_z, task)[1]
+				_z = self.model.next(_z, pi_actions[:, t], task)
+			pi_actions[:, -1] = self.model.pi(_z, task)[1]
+
+		# Initialize state and parameters
+		z = z.unsqueeze(1).repeat(1, self.cfg.num_samples, 1) # (num_envs, num_samples, latent_dim)
+		mean = torch.zeros(num_envs, self.cfg.horizon, self.cfg.action_dim, device=self.device)
+		std = self.cfg.max_std*torch.ones(num_envs, self.cfg.horizon, self.cfg.action_dim, device=self.device)
+		if not t0 and hasattr(self, '_prev_mean'):
+			if eval_mode: # Added to avoid the problem with shape (num_envs) mismatch with train and eval env
+				mean[:, :-1] = self._prev_mean_eval[:, 1:]
+			else:
+				mean[:, :-1] = self._prev_mean[:, 1:]
+		actions = torch.empty(num_envs, self.cfg.horizon, self.cfg.num_samples, 
+						self.cfg.action_dim, device=self.device) # # (num_envs, horizon, num_samples, latent_dim)
+		if self.cfg.num_pi_trajs > 0:
+			actions[:, :, :self.cfg.num_pi_trajs] = pi_actions
+	
+		# Iterate MPPI
+		for _ in range(self.cfg.iterations):
+
+			# Sample actions
+			actions[:, :, self.cfg.num_pi_trajs:] = (mean.unsqueeze(2) + std.unsqueeze(2) * \
+				torch.randn(num_envs, self.cfg.horizon, self.cfg.num_samples-self.cfg.num_pi_trajs, self.cfg.action_dim, device=std.device)) \
+				.clamp(-1, 1)
+			if self.cfg.multitask:
+				actions = actions * self.model._action_masks[task]
+
+			# Compute elite actions
+			value = self._estimate_value(z, actions, task).nan_to_num_(0) # (num_envs, num_samples, 1)
+			elite_idxs = torch.topk(value.squeeze(2), self.cfg.num_elites, dim=1).indices # (num_envs, num_elites)
+			elite_value = value[torch.arange(num_envs).unsqueeze(1), elite_idxs] # (num_envs, num_elites, 1)
+			# elite_actions = torch.zeros(num_envs, self.cfg.horizon, self.cfg.num_elites, self.cfg.action_dim, dtype=actions.dtype, device=actions.device)
+			# for j, curr_elites in enumerate(elite_idxs):
+			# 	elite_actions[j] = actions[j, :, curr_elites]
+			elite_actions = torch.gather(actions, 2, elite_idxs.unsqueeze(1).unsqueeze(3).expand(-1, self.cfg.horizon, -1, self.cfg.action_dim))
+
+			# Update parameters
+			max_value = elite_value.max(1)[0] # (num_envs, 1)
+			score = torch.exp(self.cfg.temperature*(elite_value - max_value.unsqueeze(1)))
+			score /= score.sum(1, keepdim=True) # (num_envs, num_elites, 1)
+			mean = torch.sum(score.unsqueeze(1) * elite_actions, dim=2) / (score.sum(1, keepdim=True) + 1e-9)  # (num_envs, horizon, action_dim)
+			std = torch.sqrt(torch.sum(score.unsqueeze(1) * (elite_actions - mean.unsqueeze(2)) ** 2, dim=2) / (score.sum(1, keepdim=True) + 1e-9)) \
+				.clamp_(self.cfg.min_std, self.cfg.max_std) # (num_envs, horizon, action_dim)
+			if self.cfg.multitask:
+				mean = mean * self.model._action_masks[task]
+				std = std * self.model._action_masks[task]
+
+		# Select action
+		score = score.squeeze(2).cpu().numpy() # (num_envs, num_elites)
+		# (num_envs, horizon, num_elites, action_dim) for elite_actions
+		actions = torch.zeros(num_envs, self.cfg.horizon, self.cfg.action_dim, dtype=actions.dtype, device=actions.device)
+		for i in range(len(score)):
+			actions[i] = elite_actions[i, :, np.random.choice(np.arange(score.shape[1]), p=score[i])]
+		if eval_mode:
+			self._prev_mean_eval = mean # (num_eval_envs, horizon, action_dim)
+		else:
+			self._prev_mean = mean # (num_envs, horizon, action_dim)
+		a, std = actions[:, 0], std[:, 0]
+		if not eval_mode:
+			a += std * torch.randn(num_envs, self.cfg.action_dim, device=std.device)
+		return a.clamp_(-1, 1)
+		
+	def update_pi(self, zs, task):
+		"""
+		Update policy using a sequence of latent states.
+		
+		Args:
+			zs (torch.Tensor): Sequence of latent states.
+			task (torch.Tensor): Task index (only used for multi-task experiments).
+
+		Returns:
+			float: Loss of the policy update.
+		"""
+		self.pi_optim.zero_grad(set_to_none=True)
+		self.model.track_q_grad(False)
+		_, pis, log_pis, _ = self.model.pi(zs, task)
+		qs = self.model.Q(zs, pis, task, return_type='avg')
+		self.scale.update(qs[0])
+		qs = self.scale(qs)
+
+		# Loss is a weighted sum of Q-values
+		rho = torch.pow(self.cfg.rho, torch.arange(len(qs), device=self.device))
+		pi_loss = ((self.cfg.entropy_coef * log_pis - qs).mean(dim=(1,2)) * rho).mean()
+		pi_loss.backward()
+		torch.nn.utils.clip_grad_norm_(self.model._pi.parameters(), self.cfg.grad_clip_norm)
+		self.pi_optim.step()
+		self.model.track_q_grad(True)
+
+		return pi_loss.item()
+
+	@torch.no_grad()
+	def _td_target(self, next_z, reward, task):
+		"""
+		Compute the TD-target from a reward and the observation at the following time step.
+		
+		Args:
+			next_z (torch.Tensor): Latent state at the following time step.
+			reward (torch.Tensor): Reward at the current time step.
+			task (torch.Tensor): Task index (only used for multi-task experiments).
+		
+		Returns:
+			torch.Tensor: TD-target.
+		"""
+		pi = self.model.pi(next_z, task)[1]
+		discount = self.discount[task].unsqueeze(-1) if self.cfg.multitask else self.discount
+		return reward + discount * self.model.Q(next_z, pi, task, return_type='min', target=True)
+
+	def update(self, buffer):
+		"""
+		Main update function. Corresponds to one iteration of model learning.
+		
+		Args:
+			buffer (common.buffer.Buffer): Replay buffer.
+		
+		Returns:
+			dict: Dictionary of training statistics.
+		"""
+		obs, action, reward, task = buffer.sample()
+	
+		# Compute targets
+		with torch.no_grad():
+			next_z = self.model.encode(obs[1:], task)
+			td_targets = self._td_target(next_z, reward, task)
+
+		# Prepare for update
+		self.optim.zero_grad(set_to_none=True)
+		self.model.train()
+
+		# Latent rollout
+		zs = torch.empty(self.cfg.horizon+1, self.cfg.batch_size, self.cfg.latent_dim, device=self.device)
+		z = self.model.encode(obs[0], task)
+		zs[0] = z
+		consistency_loss = 0
+		for t in range(self.cfg.horizon):
+			z = self.model.next(z, action[t], task)
+			consistency_loss += F.mse_loss(z, next_z[t]) * self.cfg.rho**t
+			zs[t+1] = z
+
+		# Predictions
+		_zs = zs[:-1]
+		qs = self.model.Q(_zs, action, task, return_type='all')
+		reward_preds = self.model.reward(_zs, action, task)
+		
+		# Compute losses
+		reward_loss, value_loss = 0, 0
+		for t in range(self.cfg.horizon):
+			reward_loss += math.soft_ce(reward_preds[t], reward[t], self.cfg).mean() * self.cfg.rho**t
+			for q in range(self.cfg.num_q):
+				value_loss += math.soft_ce(qs[q][t], td_targets[t], self.cfg).mean() * self.cfg.rho**t
+		consistency_loss *= (1/self.cfg.horizon)
+		reward_loss *= (1/self.cfg.horizon)
+		value_loss *= (1/(self.cfg.horizon * self.cfg.num_q))
+		total_loss = (
+			self.cfg.consistency_coef * consistency_loss +
+			self.cfg.reward_coef * reward_loss +
+			self.cfg.value_coef * value_loss
+		)
+
+		# Update model
+		total_loss.backward()
+		grad_norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.cfg.grad_clip_norm)
+		self.optim.step()
+
+		# Update policy
+		pi_loss = self.update_pi(zs.detach(), task)
+
+		# Update target Q-functions
+		self.model.soft_update_target_Q()
+
+		# Return training statistics
+		self.model.eval()
+		return {
+			"consistency_loss": float(consistency_loss.mean().item()),
+			"reward_loss": float(reward_loss.mean().item()),
+			"value_loss": float(value_loss.mean().item()),
+			"pi_loss": pi_loss,
+			"total_loss": float(total_loss.mean().item()),
+			"grad_norm": float(grad_norm),
+			"pi_scale": float(self.scale.value),
+		}

project/ManiSkill3/src/maniskill3_environment/examples/baselines/tdmpc2/train.py

@@ -0,0 +1,86 @@
+import os
+os.environ['MUJOCO_GL'] = 'egl'
+os.environ['LAZY_LEGACY_OP'] = '0'
+import warnings
+warnings.filterwarnings('ignore')
+import torch
+
+import hydra
+from termcolor import colored
+from omegaconf import OmegaConf
+
+from common.parser import parse_cfg
+from common.seed import set_seed
+from common.buffer import Buffer
+from envs import make_envs
+from tdmpc2 import TDMPC2
+from trainer.offline_trainer import OfflineTrainer
+from trainer.online_trainer import OnlineTrainer
+from common.logger import Logger, print_run
+import multiprocessing
+
+import gymnasium as gym
+
+torch.backends.cudnn.benchmark = True
+
+
+@hydra.main(config_name='config', config_path='.')
+def train(cfg: dict):
+	"""
+	Script for training single-task / multi-task TD-MPC2 agents.
+
+	Most relevant args:
+		`task`: task name (or mt30/mt80 for multi-task training)
+		`model_size`: model size, must be one of `[1, 5, 19, 48, 317]` (default: 5)
+		`steps`: number of training/environment steps (default: 10M)
+		`seed`: random seed (default: 1)
+
+	See config.yaml for a full list of args.
+
+	Example usage:
+	```
+		$ python train.py task=mt80 model_size=48
+		$ python train.py task=mt30 model_size=317
+		$ python train.py task=dog-run steps=7000000
+	```
+	"""
+	assert torch.cuda.is_available()
+	assert cfg.steps > 0, 'Must train for at least 1 step.'
+	cfg = parse_cfg(cfg)
+	assert not cfg.multitask, colored('Warning: multi-task models is not currently supported for maniskill.', 'red', attrs=['bold'])
+	set_seed(cfg.seed)
+	print(colored('Work dir:', 'yellow', attrs=['bold']), cfg.work_dir)
+	
+	# Need to initiate logger before make env to wrap record episode wrapper into async vec cpu env
+	manager = multiprocessing.Manager()
+	video_path = cfg.work_dir / 'eval_video'
+	if cfg.save_video_local:
+		try:
+			os.makedirs(video_path)
+		except:
+			pass
+	logger = Logger(cfg, manager)
+	# Init env
+	env = make_envs(cfg, cfg.num_envs)
+	eval_env = make_envs(cfg, cfg.num_eval_envs, video_path=video_path, is_eval=True, logger=logger)
+	print_run(cfg)
+	# Init agent
+	agent = TDMPC2(cfg)
+	# Update wandb config, for control_mode, env_horizon, discount are set after logger init
+	if logger._wandb != None:
+		logger._wandb.config.update(OmegaConf.to_container(cfg, resolve=True), allow_val_change=True)
+	trainer_cls = OnlineTrainer # OfflineTrainer not available
+	trainer = trainer_cls(
+		cfg=cfg,
+		env=env,
+		eval_env=eval_env,
+		agent=agent,
+		buffer=Buffer(cfg),
+		logger=logger,
+	)
+	trainer.train()
+	print('\nTraining completed successfully')
+
+
+if __name__ == '__main__':
+	train()

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/tabletop/__init__.py

@@ -0,0 +1,46 @@
+from .assembling_kits import AssemblingKitsEnv
+from .lift_peg_upright import LiftPegUprightEnv
+from .peg_insertion_side import PegInsertionSideEnv
+from .pick_clutter_ycb import PickClutterYCBEnv
+from .pick_cube import PickCubeEnv
+from .pick_single_ycb import PickSingleYCBEnv
+from .plug_charger import PlugChargerEnv
+from .pull_cube import PullCubeEnv
+from .push_cube import PushCubeEnv
+from .stack_cube import StackCubeEnv
+from .turn_faucet import TurnFaucetEnv
+from .two_robot_pick_cube import TwoRobotPickCube
+from .two_robot_stack_cube import TwoRobotStackCube
+from .poke_cube import PokeCubeEnv
+from .place_sphere import PlaceSphereEnv
+from .roll_ball import RollBallEnv
+from .push_t import PushTEnv
+from .pull_cube_tool import PullCubeToolEnv
+from .mug_on_rack import PlaceMugOnRackEnv
+from .stack_mug_on_rack import StackMugOnRackEnv
+from .stack_bowl import StackBowlEnv
+from .fork_from_rack import PickForkFromRackEnv
+from .stack_plate_on_rack import StackPlateOnRackEnv
+from .mug_on_coffee_machine import PlaceMugOnCoffeeMachineEnv
+from .mug_from_coffee_machine import PickMugFromCoffeeMachineEnv
+from .spoon_on_rack import PlaceSpoonOnRackEnv
+from .bowl_on_rack import PlaceBowlOnRackEnv
+from .bowl_on_rack_v2 import PlaceBowlOnRackEnv
+from .bowl_on_rack_v3 import PlaceBowlOnRackEnv
+from .bowl_on_rack_v4 import PlaceBowlOnRackEnv
+from .plate_on_rack import PlacePlateOnRackEnv
+from .plate_on_rack_v2 import PlacePlateOnRackEnv
+from .plate_on_rack_v3 import PlacePlateOnRackEnv
+from .plate_on_rack_v4 import PlacePlateOnRackEnv
+from .fork_on_rack import PlaceForkOnRackEnv
+from .fork_on_rack_v2 import PlaceForkOnRackEnv
+from .fork_on_rack_v3 import PlaceForkOnRackEnv
+from .fork_on_rack_v4 import PlaceForkOnRackEnv
+from .knife_on_rack import PlaceKnifeOnRackEnv
+from .knife_on_rack_v2 import PlaceKnifeOnRackEnv
+from .knife_on_rack_v3 import PlaceKnifeOnRackEnv
+from .knife_on_rack_v4 import PlaceKnifeOnRackEnv
+from .grasp_fork_v0 import GraspForkEnv
+from .grasp_bowl_v0 import GraspBowlEnv
+from .grasp_plate_v0 import GraspPlateEnv
+from .grasp_cup_v0 import GraspCupEnv