Upload folder using huggingface_hub

code/policy_models/VPP_policy.py

@@ -0,0 +1,688 @@
+import logging
+from typing import Dict, Optional, Tuple
+from functools import partial
+from torch import einsum, nn
+from einops import rearrange, repeat
+from omegaconf import DictConfig, OmegaConf
+import pytorch_lightning as pl
+from pytorch_lightning.utilities import rank_zero_only
+import einops
+from policy_models.edm_diffusion.score_wrappers import GCDenoiser
+
+from policy_models.module.clip_lang_encoder import LangClip
+from policy_models.edm_diffusion.gc_sampling import *
+from policy_models.utils.lr_schedulers.tri_stage_scheduler import TriStageLRScheduler
+from policy_models.module.Video_Former import Video_Former_2D,Video_Former_3D
+from diffusers import StableVideoDiffusionPipeline
+from policy_models.module.diffusion_extract import Diffusion_feature_extractor
+from transformers import AutoTokenizer, CLIPTextModelWithProjection
+
+
+logger = logging.getLogger(__name__)
+
+def load_primary_models(pretrained_model_path, eval=False):
+    if eval:
+        pipeline = StableVideoDiffusionPipeline.from_pretrained(pretrained_model_path, torch_dtype=torch.float16)
+    else:
+        pipeline = StableVideoDiffusionPipeline.from_pretrained(pretrained_model_path)
+    return pipeline, None, pipeline.feature_extractor, pipeline.scheduler, pipeline.video_processor, \
+        pipeline.image_encoder, pipeline.vae, pipeline.unet
+
+
+class VPP_Policy(pl.LightningModule):
+    """
+    The lightning module used for training.
+    """
+
+    def __init__(
+            self,
+            optimizer: DictConfig,
+            lr_scheduler: DictConfig,
+            latent_dim: int = 512,
+            multistep: int = 10,
+            sampler_type: str = 'ddim',
+            num_sampling_steps: int = 10,
+            sigma_data: float = 0.5,
+            sigma_min: float = 0.001,
+            sigma_max: float = 80,
+            noise_scheduler: str = 'exponential',
+            sigma_sample_density_type: str = 'loglogistic',
+            use_lr_scheduler: bool = True,
+            act_window_size: int = 10,
+            use_text_not_embedding: bool = False,
+            seed: int = 42,
+            pretrained_model_path: str = '/cephfs/shared/gyj/ckpt/svd_pre/checkpoint-100000',
+            text_encoder_path: str = '/home/disk2/gyj/hyc_ckpt/llm/clip-vit-base-patch32',
+            use_position_encoding: bool = True,
+            Former_depth: int = 3,
+            Former_heads: int = 8,
+            Former_dim_head: int = 64,
+            Former_num_time_embeds: int = 1,
+            num_latents: int = 3,
+            use_Former: str = '3d',
+            timestep: int = 20,
+            max_length: int = 20,
+            extract_layer_idx: int = 1,
+            use_all_layer: bool = False,
+            obs_seq_len: int = 1,
+            action_dim: int = 7,
+            action_seq_len: int = 10,
+    ):
+        super(VPP_Policy, self).__init__()
+        self.latent_dim = latent_dim
+        self.use_all_layer = use_all_layer
+        self.use_position_encoding = use_position_encoding
+
+        self.act_window_size = act_window_size
+        self.action_dim = action_dim
+
+        self.timestep = timestep
+        self.extract_layer_idx = extract_layer_idx
+        self.use_Former = use_Former
+        self.Former_num_time_embeds = Former_num_time_embeds
+        self.max_length = max_length
+
+        condition_dim_list = [1280,1280,1280,640]
+        sum_dim = 0
+        for i in range(extract_layer_idx+1):
+            sum_dim = sum_dim + condition_dim_list[i+1]
+        condition_dim = condition_dim_list[extract_layer_idx+1] if not self.use_all_layer else sum_dim
+
+        if use_Former=='3d':
+            self.Video_Former = Video_Former_3D(
+                dim=latent_dim,
+                depth=Former_depth,
+                dim_head=Former_dim_head,
+                heads=Former_heads,
+                num_time_embeds=Former_num_time_embeds,
+                num_latents=num_latents,
+                condition_dim=condition_dim,
+                use_temporal=True,
+             )
+        elif use_Former == '2d':
+            self.Video_Former = Video_Former_2D(
+                    dim=latent_dim,
+                    depth=Former_depth,
+                    dim_head=Former_dim_head,
+                    heads=Former_heads,
+                    num_time_embeds=Former_num_time_embeds,
+                    num_latents=num_latents,
+                    condition_dim=condition_dim,
+                 )
+        else:
+            self.Video_Former = nn.Linear(condition_dim,latent_dim)
+
+        print('use_Former:', self.use_Former)
+        print('use_all_layer',self.use_all_layer)
+
+        self.seed = seed
+        self.use_lr_scheduler = use_lr_scheduler
+        # goal encoders
+        self.language_goal = LangClip(model_name='ViT-B/32').to(self.device)
+
+        pipeline, tokenizer, feature_extractor, train_scheduler, vae_processor, text_encoder, vae, unet = load_primary_models(
+            pretrained_model_path , eval = True)
+
+        #text_encoder = CLIPTextModelWithProjection.from_pretrained("/cephfs/shared/llm/clip-vit-base-patch32")
+        #tokenizer = AutoTokenizer.from_pretrained("/cephfs/shared/llm/clip-vit-base-patch32", use_fast=False)
+        text_encoder = CLIPTextModelWithProjection.from_pretrained(text_encoder_path)
+        tokenizer = AutoTokenizer.from_pretrained(text_encoder_path, use_fast=False)
+
+        text_encoder = text_encoder.to(self.device).eval()
+
+        for param in pipeline.image_encoder.parameters():
+            param.requires_grad = False
+        for param in text_encoder.parameters():
+            param.requires_grad = False
+
+        for param in pipeline.vae.parameters():
+            param.requires_grad = False
+        for param in pipeline.unet.parameters():
+            param.requires_grad = False
+
+        pipeline = pipeline.to(self.device)
+        pipeline.unet.eval()
+
+        self.TVP_encoder = Diffusion_feature_extractor(pipeline=pipeline,
+                                                        tokenizer=tokenizer,
+                                                        text_encoder=text_encoder,
+                                                        position_encoding = self.use_position_encoding)
+        self.TVP_encoder = self.TVP_encoder.to(self.device)
+        # policy network
+        self.model = GCDenoiser(action_dim = action_dim,
+                                obs_dim=latent_dim,
+                                goal_dim=512,
+                                num_tokens=num_latents,
+                                goal_window_size = 1,
+                                obs_seq_len = obs_seq_len,
+                                act_seq_len = action_seq_len,
+                                device=self.device,
+                                sigma_data=0.5).to(self.device)
+
+        self.optimizer_config = optimizer
+        self.lr_scheduler = lr_scheduler
+        self.save_hyperparameters()
+        # diffusion stuff
+        self.sampler_type = sampler_type
+        self.num_sampling_steps = num_sampling_steps
+        self.noise_scheduler = noise_scheduler
+        self.sigma_data = sigma_data
+        self.sigma_min = sigma_min
+        self.sigma_max = sigma_max
+        self.sigma_sample_density_type = sigma_sample_density_type
+        # for inference
+        self.rollout_step_counter = 0
+        self.multistep = multistep
+        self.latent_goal = None
+        self.plan = None
+        self.use_text_not_embedding = use_text_not_embedding
+        # print_model_parameters(self.perceptual_encoder.perceiver_resampler)
+        # for clip loss ground truth plot
+        self.ema_callback_idx = None
+
+        for param in self.model.inner_model.proprio_emb.parameters():
+            param.requires_grad = False
+        for param in self.model.inner_model.goal_emb.parameters():
+            param.requires_grad = False
+        self.model.inner_model.pos_emb.requires_grad = False
+
+    def process_device(self):
+        self.TVP_encoder.pipeline = self.TVP_encoder.pipeline.to(self.device)
+        self.TVP_encoder.text_encoder = self.TVP_encoder.text_encoder.to(self.device)
+
+    def configure_optimizers(self):
+        """
+        Initialize optimizers and learning rate schedulers based on model configuration.
+        """
+        # Configuration for models using transformer weight decay
+        '''optim_groups = self.action_decoder.model.inner_model.get_optim_groups(
+            weight_decay=self.optimizer_config.transformer_weight_decay
+        )'''
+        optim_groups = [
+            {"params": self.model.inner_model.parameters(),
+             "weight_decay": self.optimizer_config.transformer_weight_decay},
+            {"params": self.Video_Former.parameters(), "weight_decay": self.optimizer_config.transformer_weight_decay},
+        ]
+
+
+        optimizer = torch.optim.AdamW(optim_groups, lr=self.optimizer_config.learning_rate,
+                                      betas=self.optimizer_config.betas)
+
+        # Optionally initialize the scheduler
+        if self.use_lr_scheduler:
+            lr_configs = OmegaConf.create(self.lr_scheduler)
+            scheduler = TriStageLRScheduler(optimizer, lr_configs)
+            lr_scheduler = {
+                "scheduler": scheduler,
+                "interval": 'step',
+                "frequency": 1,
+            }
+            return {"optimizer": optimizer, "lr_scheduler": lr_scheduler}
+        else:
+            return optimizer
+
+    def on_before_zero_grad(self, optimizer=None):
+        total_grad_norm = 0.0
+        total_param_norm = 0.0
+        for p in self.model.parameters():
+            if p.grad is not None:
+                total_grad_norm += p.grad.norm().item() ** 2
+            total_param_norm += p.norm().item() ** 2
+        total_grad_norm = total_grad_norm ** 0.5
+        total_param_norm = total_param_norm ** 0.5
+
+        self.log("train/grad_norm", total_grad_norm, on_step=True, on_epoch=False, sync_dist=True)
+        self.log("train/param_norm", total_param_norm, on_step=True, on_epoch=False, sync_dist=True)
+
+
+    def training_step(self, dataset_batch: Dict[str, Dict],) -> torch.Tensor:  # type: ignore
+        """
+        Compute and return the training loss for the MDT Agent.
+        The training loss consists of the score matching loss of the diffusion model
+        and the contrastive loss of the CLIP model for the multimodal encoder.
+
+        Args:
+            batch: Dictionary containing the batch data for each modality.
+            batch_idx: Index of the batch. used for compatibility with pytorch lightning.
+            dataloader_idx: Index of the dataloader. used for compatibility with pytorch lightning.
+
+        Returns:
+            loss tensor
+        """
+        total_loss, action_loss = (
+            torch.tensor(0.0).to(self.device),
+            torch.tensor(0.0).to(self.device),
+        )
+
+        predictive_feature, latent_goal= self.extract_predictive_feature(dataset_batch)
+
+        act_loss, sigmas, noise = self.diffusion_loss(
+            predictive_feature,
+            latent_goal,
+            dataset_batch["actions"],
+        )
+
+        action_loss += act_loss
+        total_loss += act_loss
+
+        total_bs = dataset_batch["actions"].shape[0]
+
+        self._log_training_metrics(action_loss, total_loss, total_bs)
+        return total_loss
+
+    @torch.no_grad()
+    def validation_step(self, dataset_batch: Dict[str, Dict]) -> Dict[
+        str, torch.Tensor]:  # type: ignore
+        """
+        Compute and log the validation losses and additional metrics.
+        During the validation step, the diffusion model predicts the next action sequence given the current state
+
+        Args:
+            batch: Dictionary containing the batch data for each modality.
+            batch_idx: Index of the batch. used for compatibility with pytorch lightning.
+            dataloader_idx: Index of the dataloader. used for compatibility with pytorch lightning.
+
+        Returns:
+            Dictionary containing the sampled plans of plan recognition and plan proposal module, as well as the
+            episode indices.
+        """
+        output = {}
+        val_total_act_loss_pp = torch.tensor(0.0).to(self.device)
+            # Compute the required embeddings
+        predictive_feature, latent_goal= self.extract_predictive_feature(dataset_batch)
+
+        # predict the next action sequence
+        action_pred = self.denoise_actions(
+            torch.zeros_like(latent_goal).to(latent_goal.device),
+            predictive_feature,
+            latent_goal,
+            inference=True,
+        )
+        dataset_batch["actions"] = dataset_batch["actions"].to(action_pred.device)
+        # compute the mse action loss
+        pred_loss = torch.nn.functional.mse_loss(action_pred, dataset_batch["actions"])
+        val_total_act_loss_pp += pred_loss
+
+        output[f"idx:"] = dataset_batch["idx"]
+        output["validation_loss"] = val_total_act_loss_pp
+        return output
+
+    def extract_predictive_feature(self, dataset_batch):
+        """
+        Compute the required embeddings for the visual ones and the latent goal.
+        """
+        # 1. extract the revelant visual observations
+        rgb_static = dataset_batch["rgb_obs"]['rgb_static'].to(self.device)
+        rgb_gripper = dataset_batch["rgb_obs"]['rgb_gripper'].to(self.device)
+        # 3. we compute the language goal if the language modality is in the scope
+        modality = "lang"
+        if self.use_text_not_embedding:
+            latent_goal = self.language_goal(dataset_batch["lang_text"]).to(rgb_static.dtype)
+        else:
+            latent_goal = self.language_goal(dataset_batch["lang"]).to(rgb_static.dtype)
+
+        language = dataset_batch["lang_text"]
+
+        num_frames = self.Former_num_time_embeds
+        rgb_static = rgb_static.to(self.device)
+        rgb_gripper = rgb_gripper.to(self.device)
+        batch = rgb_static.shape[0]
+
+        with torch.no_grad():
+            input_rgb = torch.cat([rgb_static, rgb_gripper], dim=0)
+            language = language + language
+            perceptual_features = self.TVP_encoder(input_rgb, language, self.timestep,
+                                                           self.extract_layer_idx, all_layer=self.use_all_layer,
+                                                           step_time=1, max_length=self.max_length)
+
+        perceptual_features = einops.rearrange(perceptual_features, 'b f c h w-> b f c (h w)')
+        perceptual_features = einops.rearrange(perceptual_features, 'b f c l-> b f l c')
+        perceptual_features = perceptual_features[:, :num_frames, :, :]
+        #print('perceptual_features_shape:', perceptual_features.shape)
+
+        perceptual_features, gripper_feature = torch.split(perceptual_features, [batch, batch], dim=0)
+        perceptual_features = torch.cat([perceptual_features, gripper_feature], dim=2)
+
+        perceptual_features = perceptual_features.to(torch.float32)
+        perceptual_features = self.Video_Former(perceptual_features)
+        if self.use_Former=='linear':
+            perceptual_features = rearrange(perceptual_features, 'b T q d -> b (T q) d')
+        predictive_feature = {'state_images': perceptual_features}
+        predictive_feature['modality'] = modality
+        return predictive_feature, latent_goal
+
+
+    def _log_training_metrics(self, action_loss, total_loss, total_bs):
+        """
+        Log the training metrics.
+        """
+        self.log("train/action_loss", action_loss, on_step=False, on_epoch=True, sync_dist=True, batch_size=total_bs)
+        self.log("train/total_loss", total_loss, on_step=False, on_epoch=True, sync_dist=True, batch_size=total_bs)
+
+    def _log_validation_metrics(self, pred_loss, img_gen_loss, val_total_act_loss_pp):
+        """
+        Log the validation metrics.
+        """
+        self.log(
+            "val_act/action_loss",
+            val_total_act_loss_pp / len(self.trainer.datamodule.modalities),  # type:ignore
+            sync_dist=True,
+        )
+        self.log(f"val_act/img_gen_loss_pp", img_gen_loss, sync_dist=True)
+
+    def diffusion_loss(
+            self,
+            perceptual_emb: torch.Tensor,
+            latent_goal: torch.Tensor,
+            actions: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Computes the score matching loss given the perceptual embedding, latent goal, and desired actions.
+        """
+        self.model.train()
+        sigmas = self.make_sample_density()(shape=(len(actions),), device=self.device).to(self.device)
+        noise = torch.randn_like(actions).to(self.device)
+        loss, _ = self.model.loss(perceptual_emb, actions, latent_goal, noise, sigmas)
+        return loss, sigmas, noise
+
+    def denoise_actions(  # type: ignore
+            self,
+            latent_plan: torch.Tensor,
+            perceptual_emb: torch.Tensor,
+            latent_goal: torch.Tensor,
+            inference: Optional[bool] = False,
+            extra_args={}
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Denoise the next sequence of actions
+        """
+        if inference:
+            sampling_steps = self.num_sampling_steps
+        else:
+            sampling_steps = 10
+        self.model.eval()
+        if len(latent_goal.shape) < len(
+                perceptual_emb['state_images'].shape if isinstance(perceptual_emb, dict) else perceptual_emb.shape):
+            latent_goal = latent_goal.unsqueeze(1)  # .expand(-1, seq_len, -1)
+        input_state = perceptual_emb
+        sigmas = self.get_noise_schedule(sampling_steps, self.noise_scheduler)
+
+        x = torch.randn((len(latent_goal), self.act_window_size, self.action_dim), device=self.device) * self.sigma_max
+
+        actions = self.sample_loop(sigmas, x, input_state, latent_goal, latent_plan, self.sampler_type, extra_args)
+
+        return actions
+
+    def make_sample_density(self):
+        """
+        Generate a sample density function based on the desired type for training the model
+        We mostly use log-logistic as it has no additional hyperparameters to tune.
+        """
+        sd_config = []
+        if self.sigma_sample_density_type == 'lognormal':
+            loc = self.sigma_sample_density_mean  # if 'mean' in sd_config else sd_config['loc']
+            scale = self.sigma_sample_density_std  # if 'std' in sd_config else sd_config['scale']
+            return partial(utils.rand_log_normal, loc=loc, scale=scale)
+
+        if self.sigma_sample_density_type == 'loglogistic':
+            loc = sd_config['loc'] if 'loc' in sd_config else math.log(self.sigma_data)
+            scale = sd_config['scale'] if 'scale' in sd_config else 0.5
+            min_value = sd_config['min_value'] if 'min_value' in sd_config else self.sigma_min
+            max_value = sd_config['max_value'] if 'max_value' in sd_config else self.sigma_max
+            return partial(utils.rand_log_logistic, loc=loc, scale=scale, min_value=min_value, max_value=max_value)
+
+        if self.sigma_sample_density_type == 'loguniform':
+            min_value = sd_config['min_value'] if 'min_value' in sd_config else self.sigma_min
+            max_value = sd_config['max_value'] if 'max_value' in sd_config else self.sigma_max
+            return partial(utils.rand_log_uniform, min_value=min_value, max_value=max_value)
+
+        if self.sigma_sample_density_type == 'uniform':
+            return partial(utils.rand_uniform, min_value=self.sigma_min, max_value=self.sigma_max)
+
+        if self.sigma_sample_density_type == 'v-diffusion':
+            min_value = self.min_value if 'min_value' in sd_config else self.sigma_min
+            max_value = sd_config['max_value'] if 'max_value' in sd_config else self.sigma_max
+            return partial(utils.rand_v_diffusion, sigma_data=self.sigma_data, min_value=min_value, max_value=max_value)
+        if self.sigma_sample_density_type == 'discrete':
+            sigmas = self.get_noise_schedule(self.num_sampling_steps * 1e5, 'exponential')
+            return partial(utils.rand_discrete, values=sigmas)
+        if self.sigma_sample_density_type == 'split-lognormal':
+            loc = sd_config['mean'] if 'mean' in sd_config else sd_config['loc']
+            scale_1 = sd_config['std_1'] if 'std_1' in sd_config else sd_config['scale_1']
+            scale_2 = sd_config['std_2'] if 'std_2' in sd_config else sd_config['scale_2']
+            return partial(utils.rand_split_log_normal, loc=loc, scale_1=scale_1, scale_2=scale_2)
+        else:
+            raise ValueError('Unknown sample density type')
+
+    def sample_loop(
+            self,
+            sigmas,
+            x_t: torch.Tensor,
+            state: torch.Tensor,
+            goal: torch.Tensor,
+            latent_plan: torch.Tensor,
+            sampler_type: str,
+            extra_args={},
+    ):
+        """
+        Main method to generate samples depending on the chosen sampler type. DDIM is the default as it works well in all settings.
+        """
+        s_churn = extra_args['s_churn'] if 's_churn' in extra_args else 0
+        s_min = extra_args['s_min'] if 's_min' in extra_args else 0
+        use_scaler = extra_args['use_scaler'] if 'use_scaler' in extra_args else False
+        keys = ['s_churn', 'keep_last_actions']
+        if bool(extra_args):
+            reduced_args = {x: extra_args[x] for x in keys}
+        else:
+            reduced_args = {}
+        if use_scaler:
+            scaler = self.scaler
+        else:
+            scaler = None
+        # ODE deterministic
+        if sampler_type == 'lms':
+            x_0 = sample_lms(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True, extra_args=reduced_args)
+        # ODE deterministic can be made stochastic by S_churn != 0
+        elif sampler_type == 'heun':
+            x_0 = sample_heun(self.model, state, x_t, goal, sigmas, scaler=scaler, s_churn=s_churn, s_tmin=s_min,
+                              disable=True)
+        # ODE deterministic
+        elif sampler_type == 'euler':
+            x_0 = sample_euler(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        # SDE stochastic
+        elif sampler_type == 'ancestral':
+            x_0 = sample_dpm_2_ancestral(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+            # SDE stochastic: combines an ODE euler step with an stochastic noise correcting step
+        elif sampler_type == 'euler_ancestral':
+            x_0 = sample_euler_ancestral(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        # ODE deterministic
+        elif sampler_type == 'dpm':
+            x_0 = sample_dpm_2(self.model, state, x_t, goal, sigmas, disable=True)
+        # ODE deterministic
+        elif sampler_type == 'dpm_adaptive':
+            x_0 = sample_dpm_adaptive(self.model, state, x_t, goal, sigmas[-2].item(), sigmas[0].item(), disable=True)
+        # ODE deterministic
+        elif sampler_type == 'dpm_fast':
+            x_0 = sample_dpm_fast(self.model, state, x_t, goal, sigmas[-2].item(), sigmas[0].item(), len(sigmas),
+                                  disable=True)
+        # 2nd order solver
+        elif sampler_type == 'dpmpp_2s_ancestral':
+            x_0 = sample_dpmpp_2s_ancestral(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        # 2nd order solver
+        elif sampler_type == 'dpmpp_2m':
+            x_0 = sample_dpmpp_2m(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        elif sampler_type == 'dpmpp_2m_sde':
+            x_0 = sample_dpmpp_sde(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        elif sampler_type == 'ddim':
+            x_0 = sample_ddim(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        elif sampler_type == 'dpmpp_2s':
+            x_0 = sample_dpmpp_2s(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        elif sampler_type == 'dpmpp_2_with_lms':
+            x_0 = sample_dpmpp_2_with_lms(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        else:
+            raise ValueError('desired sampler type not found!')
+        return x_0
+
+    def get_noise_schedule(self, n_sampling_steps, noise_schedule_type):
+        """
+        Get the noise schedule for the sampling steps. Describes the distribution over the noise levels from sigma_min to sigma_max.
+        """
+        if noise_schedule_type == 'karras':
+            return get_sigmas_karras(n_sampling_steps, self.sigma_min, self.sigma_max, 7,
+                                     self.device)  # rho=7 is the default from EDM karras
+        elif noise_schedule_type == 'exponential':
+            return get_sigmas_exponential(n_sampling_steps, self.sigma_min, self.sigma_max, self.device)
+        elif noise_schedule_type == 'vp':
+            return get_sigmas_vp(n_sampling_steps, device=self.device)
+        elif noise_schedule_type == 'linear':
+            return get_sigmas_linear(n_sampling_steps, self.sigma_min, self.sigma_max, device=self.device)
+        elif noise_schedule_type == 'cosine_beta':
+            return cosine_beta_schedule(n_sampling_steps, device=self.device)
+        elif noise_schedule_type == 've':
+            return get_sigmas_ve(n_sampling_steps, self.sigma_min, self.sigma_max, device=self.device)
+        elif noise_schedule_type == 'iddpm':
+            return get_iddpm_sigmas(n_sampling_steps, self.sigma_min, self.sigma_max, device=self.device)
+        raise ValueError('Unknown noise schedule type')
+
+    def reset(self):
+        """
+        Call this at the beginning of a new rollout when doing inference.
+        """
+        self.plan = None
+        self.latent_goal = None
+        self.rollout_step_counter = 0
+
+    def forward(self,batch):
+        return self.training_step(batch)
+        #def training_step(self, batch: Dict[str, Dict], batch_idx: int,
+        #                  dataloader_idx: int = 0) -> torch.Tensor
+
+    def eval_forward(self, obs, goal):
+        """
+        Method for doing inference with the model.
+        """
+        if 'lang_text' in goal:
+            if self.use_text_not_embedding:
+                # print(goal.keys())
+                latent_goal = self.language_goal(goal["lang_text"])
+                latent_goal = latent_goal.to(torch.float32)
+            else:
+                latent_goal = self.language_goal(goal["lang"]).unsqueeze(0).to(torch.float32).to(
+                    obs["rgb_obs"]['rgb_static'].device)
+
+        rgb_static = obs["rgb_obs"]['rgb_static']
+        # rgb_gripper = dataset_batch["rgb_obs"]['rgb_gripper'][:, :-1]
+        rgb_gripper = obs["rgb_obs"]['rgb_gripper']
+
+        language = goal["lang_text"]
+
+        num_frames = self.Former_num_time_embeds
+        rgb_static = rgb_static.to(self.device)
+        rgb_gripper = rgb_gripper.to(self.device)
+        batch = rgb_static.shape[0]
+
+        with torch.no_grad():
+            input_rgb = torch.cat([rgb_static, rgb_gripper], dim=0)
+            language = [language] + [language]
+            perceptual_features = self.TVP_encoder(input_rgb, language, self.timestep,
+                                                           self.extract_layer_idx, all_layer=self.use_all_layer,
+                                                           step_time=1, max_length=self.max_length)
+
+        perceptual_features = einops.rearrange(perceptual_features, 'b f c h w-> b f c (h w)')
+        perceptual_features = einops.rearrange(perceptual_features, 'b f c l-> b f l c')
+        perceptual_features = perceptual_features[:, :num_frames, :, :]
+
+        perceptual_features, gripper_feature = torch.split(perceptual_features, [batch, batch], dim=0)
+        perceptual_features = torch.cat([perceptual_features, gripper_feature], dim=2)
+
+        perceptual_features = perceptual_features.to(torch.float32)
+        perceptual_features = self.Video_Former(perceptual_features)
+        if self.use_Former == 'linear':
+            perceptual_features = rearrange(perceptual_features, 'b T q d -> b (T q) d')
+
+        perceptual_emb = {'state_images': perceptual_features}
+
+        perceptual_emb['modality'] = "lang"
+        #print('latent_goal_shape:',latent_goal.shape)
+        #print('perceptual_features_shape:', perceptual_features.shape)
+
+        act_seq = self.denoise_actions(
+            torch.zeros_like(latent_goal).to(latent_goal.device),
+            perceptual_emb,
+            latent_goal,
+            inference=True,
+        )
+        return act_seq
+
+    def step(self, obs, goal):
+        """
+        Do one step of inference with the model. THis method handles the action chunking case.
+        Our model is trained to predict a sequence of actions.
+        We only compute the sequence once every self.multistep steps.
+
+        Args:
+            obs (dict): Observation from environment.
+            goal (dict): Goal as visual observation or embedded language instruction.
+
+        Returns:
+            Predicted action.
+        """
+        if self.rollout_step_counter % self.multistep == 0:
+            pred_action_seq = self.eval_forward(obs, goal)
+
+            self.pred_action_seq = pred_action_seq
+
+        current_action = self.pred_action_seq[0, self.rollout_step_counter]
+        if len(current_action.shape) == 2:
+            current_action = einops.rearrange(current_action, 'b d -> b 1 d')
+        self.rollout_step_counter += 1
+        if self.rollout_step_counter == self.multistep:
+            self.rollout_step_counter = 0
+
+        return current_action
+
+    def on_train_start(self) -> None:
+
+        self.model.to(dtype=self.dtype)
+
+        self.Video_Former.to(dtype=self.dtype)
+        self.language_goal.to(dtype=self.dtype)
+        #self.vae.to(dtype=self.dtype)
+        self.TVP_encoder.to(dtype=self.dtype)
+
+    @rank_zero_only
+    def on_train_epoch_start(self) -> None:
+        logger.info(f"Start training epoch {self.current_epoch}")
+
+    @rank_zero_only
+    def on_train_epoch_end(self, unused: Optional = None) -> None:  # type: ignore
+        logger.info(f"Finished training epoch {self.current_epoch}")
+
+    @rank_zero_only
+    def on_validation_epoch_end(self) -> None:
+        logger.info(f"Finished validation epoch {self.current_epoch}")
+
+
+    def on_validation_epoch_start(self) -> None:
+        log_rank_0(f"Start validation epoch {self.current_epoch}")
+
+    @rank_zero_only
+    def on_train_epoch_start(self) -> None:
+        logger.info(f"Start training epoch {self.current_epoch}")
+
+    @rank_zero_only
+    def on_train_epoch_end(self, unused: Optional = None) -> None:  # type: ignore
+        logger.info(f"Finished training epoch {self.current_epoch}")
+
+    @rank_zero_only
+    def on_validation_epoch_end(self) -> None:
+        logger.info(f"Finished validation epoch {self.current_epoch}")
+
+    def on_validation_epoch_start(self) -> None:
+        log_rank_0(f"Start validation epoch {self.current_epoch}")
+
+
+@rank_zero_only
+def log_rank_0(*args, **kwargs):
+    # when using ddp, only log with rank 0 process
+    logger.info(*args, **kwargs)

code/policy_models/VPP_policy_xbot.py

@@ -0,0 +1,941 @@
+import logging
+from typing import Dict, Optional, Tuple
+from functools import partial
+
+from omegaconf import DictConfig, OmegaConf
+import pytorch_lightning as pl
+from pytorch_lightning.utilities import rank_zero_only
+import einops
+from policy_models.edm_diffusion.score_wrappers import GCDenoiser
+
+from policy_models.module.clip_lang_encoder import LangClip
+from policy_models.edm_diffusion.gc_sampling import *
+from policy_models.utils.lr_schedulers.tri_stage_scheduler import TriStageLRScheduler
+from policy_models.module.Video_Former import Video_Former_2D,Video_Former_3D
+from diffusers import StableVideoDiffusionPipeline
+from policy_models.module.diffusion_extract import Diffusion_feature_extractor
+from transformers import AutoTokenizer, CLIPTextModelWithProjection
+
+
+logger = logging.getLogger(__name__)
+
+def load_primary_models(pretrained_model_path, eval=False):
+    print('load primary models from:', pretrained_model_path)
+    if eval:
+        pipeline = StableVideoDiffusionPipeline.from_pretrained(pretrained_model_path, torch_dtype=torch.float16)
+    else:
+        pipeline = StableVideoDiffusionPipeline.from_pretrained(pretrained_model_path)
+    return pipeline
+
+
+class VPP_Policy(nn.Module):#pl.LightningModule):
+    """
+    The lightning module used for training.
+    """
+
+    def __init__(
+            self,
+            optimizer: DictConfig,
+            lr_scheduler: DictConfig,
+            latent_dim: int = 512,
+            multistep: int = 10,
+            sampler_type: str = 'ddim',
+            num_sampling_steps: int = 10,
+            sigma_data: float = 0.5,
+            sigma_min: float = 0.001,
+            sigma_max: float = 80,
+            noise_scheduler: str = 'exponential',
+            sigma_sample_density_type: str = 'loglogistic',
+            use_lr_scheduler: bool = True,
+            act_window_size: int = 10,
+            use_text_not_embedding: bool = False,
+            seed: int = 42,
+            pretrained_model_path: str = '/cephfs/shared/gyj/ckpt/svd_pre/checkpoint-100000',
+            text_encoder_path: str = '/cephfs/shared/llm/clip-vit-base-patch32',
+            Former_depth: int = 3,
+            Former_heads: int = 8,
+            Former_dim_head: int = 64,
+            Former_num_time_embeds: int = 1,
+            num_latents: int = 3,
+            use_3d_Former: bool = False,
+            timestep: int = 20,
+            extract_layer_idx: int = 1,
+            use_all_layer: bool = False,
+            obs_seq_len: int = 1,
+            action_dim: int = 18,
+            action_seq_len: int = 10,
+            proprio_dim: int = 19,
+            device: str = 'cuda',
+    ):
+        super(VPP_Policy, self).__init__()
+        self.device = device
+        self.dtype = torch.float32
+        self.latent_dim = latent_dim
+        self.use_all_layer = use_all_layer
+
+        self.act_window_size = act_window_size
+        self.action_dim = action_dim
+
+        self.timestep = timestep
+        self.extract_layer_idx = extract_layer_idx
+        self.use_3d_Former = use_3d_Former
+
+        condition_dim_list = [1280,1280,640]
+        condition_dim = condition_dim_list[extract_layer_idx]
+
+        if use_3d_Former:
+            self.Video_Former = Video_Former_3D(
+                dim=latent_dim,
+                depth=Former_depth,
+                dim_head=Former_dim_head,
+                heads=Former_heads,
+                num_time_embeds=Former_num_time_embeds,
+                num_latents=num_latents,
+                condition_dim=condition_dim,
+                use_temporal=True,
+             )
+        else:
+            self.Video_Former = Video_Former_2D(
+                    dim=latent_dim,
+                    depth=Former_depth,
+                    dim_head=Former_dim_head,
+                    heads=Former_heads,
+                    num_time_embeds=Former_num_time_embeds,
+                    num_latents=num_latents,
+                    condition_dim=condition_dim,
+                 )
+
+        print('use_3d_Former:', self.use_3d_Former)
+        print('use_all_layer',self.use_all_layer)
+
+        self.seed = seed
+        self.use_lr_scheduler = use_lr_scheduler
+        # goal encoders
+        # self.language_goal = LangClip(model_name='ViT-B/32').to(self.device)
+
+
+        pipeline = load_primary_models(
+            pretrained_model_path , eval = True)
+
+        #text_encoder = CLIPTextModelWithProjection.from_pretrained("/cephfs/shared/llm/clip-vit-base-patch32")
+        #tokenizer = AutoTokenizer.from_pretrained("/cephfs/shared/llm/clip-vit-base-patch32", use_fast=False)
+        text_encoder = CLIPTextModelWithProjection.from_pretrained(text_encoder_path)
+        tokenizer = AutoTokenizer.from_pretrained(text_encoder_path, use_fast=False)
+
+        self.tokenizer = tokenizer
+        self.text_encoder = text_encoder
+
+        text_encoder = text_encoder.to(self.device).eval()
+
+        for param in pipeline.image_encoder.parameters():
+            param.requires_grad = False
+        for param in text_encoder.parameters():
+            param.requires_grad = False
+
+        for param in pipeline.vae.parameters():
+            param.requires_grad = False
+        for param in pipeline.unet.parameters():
+            param.requires_grad = False
+
+        pipeline = pipeline.to(self.device)
+        pipeline.unet.eval()
+
+        self.TVP_encoder = Diffusion_feature_extractor(pipeline=pipeline,
+                                                        tokenizer=tokenizer,
+                                                        text_encoder=text_encoder, )
+        self.TVP_encoder = self.TVP_encoder.to(self.device)
+        # policy network
+        self.model = GCDenoiser(action_dim = action_dim,
+                                obs_dim=latent_dim,
+                                proprio_dim=proprio_dim,
+                                goal_dim=512,
+                                num_tokens=num_latents,
+                                goal_window_size = 1,
+                                obs_seq_len = obs_seq_len,
+                                act_seq_len = action_seq_len,
+                                device=self.device,
+                                sigma_data=0.5).to(self.device)
+
+        self.optimizer_config = optimizer
+        self.lr_scheduler = lr_scheduler
+        # self.save_hyperparameters()
+        # diffusion stuff
+        self.sampler_type = sampler_type
+        self.num_sampling_steps = num_sampling_steps
+        self.noise_scheduler = noise_scheduler
+        self.sigma_data = sigma_data
+        self.sigma_min = sigma_min
+        self.sigma_max = sigma_max
+        self.sigma_sample_density_type = sigma_sample_density_type
+        # for inference
+        self.rollout_step_counter = 0
+        self.multistep = multistep
+        self.latent_goal = None
+        self.plan = None
+        self.use_text_not_embedding = use_text_not_embedding
+        # print_model_parameters(self.perceptual_encoder.perceiver_resampler)
+        # for clip loss ground truth plot
+        self.ema_callback_idx = None
+
+        for param in self.model.inner_model.proprio_emb.parameters():
+            param.requires_grad = False
+        for param in self.model.inner_model.goal_emb.parameters():
+            param.requires_grad = False
+        self.model.inner_model.pos_emb.requires_grad = False
+
+    def process_device(self):
+        self.TVP_encoder.pipeline = self.TVP_encoder.pipeline.to(self.device)
+        self.TVP_encoder.text_encoder = self.TVP_encoder.text_encoder.to(self.device)
+
+    def configure_optimizers(self):
+        """
+        Initialize optimizers and learning rate schedulers based on model configuration.
+        """
+        # Configuration for models using transformer weight decay
+        '''optim_groups = self.action_decoder.model.inner_model.get_optim_groups(
+            weight_decay=self.optimizer_config.transformer_weight_decay
+        )'''
+        optim_groups = [
+            {"params": self.model.inner_model.parameters(),
+             "weight_decay": self.optimizer_config.transformer_weight_decay},
+            {"params": self.Video_Former.parameters(), "weight_decay": self.optimizer_config.transformer_weight_decay},
+        ]
+
+
+        optimizer = torch.optim.AdamW(optim_groups, lr=self.optimizer_config.learning_rate,
+                                      betas=self.optimizer_config.betas)
+
+        # Optionally initialize the scheduler
+        if self.use_lr_scheduler:
+            lr_configs = OmegaConf.create(self.lr_scheduler)
+            scheduler = TriStageLRScheduler(optimizer, lr_configs)
+            lr_scheduler = {
+                "scheduler": scheduler,
+                "interval": 'step',
+                "frequency": 1,
+            }
+            return {"optimizer": optimizer, "lr_scheduler": lr_scheduler}
+        else:
+            return optimizer
+
+    def on_before_zero_grad(self, optimizer=None):
+        total_grad_norm = 0.0
+        total_param_norm = 0.0
+        for p in self.model.parameters():
+            if p.grad is not None:
+                total_grad_norm += p.grad.norm().item() ** 2
+            total_param_norm += p.norm().item() ** 2
+        total_grad_norm = total_grad_norm ** 0.5
+        total_param_norm = total_param_norm ** 0.5
+
+        self.log("train/grad_norm", total_grad_norm, on_step=True, on_epoch=False, sync_dist=True)
+        self.log("train/param_norm", total_param_norm, on_step=True, on_epoch=False, sync_dist=True)
+
+
+    def training_step(self, dataset_batch: Dict[str, Dict],) -> torch.Tensor:  # type: ignore
+        """
+        Compute and return the training loss for the MDT Agent.
+        The training loss consists of the score matching loss of the diffusion model
+        and the contrastive loss of the CLIP model for the multimodal encoder.
+
+        Args:
+            batch: Dictionary containing the batch data for each modality.
+            batch_idx: Index of the batch. used for compatibility with pytorch lightning.
+            dataloader_idx: Index of the dataloader. used for compatibility with pytorch lightning.
+
+        Returns:
+            loss tensor
+        """
+        total_loss, action_loss = (
+            torch.tensor(0.0).to(self.device),
+            torch.tensor(0.0).to(self.device),
+        )
+
+        predictive_feature, latent_goal= self.extract_predictive_feature(dataset_batch)
+
+        target, model_output = self.diffusion_loss(
+            predictive_feature,
+            latent_goal,
+            dataset_batch["actions"],
+        )
+        act_loss = (model_output - target).pow(2).flatten(1).mean(),
+
+        action_loss += act_loss
+        total_loss += act_loss
+
+        total_bs = dataset_batch["actions"].shape[0]
+
+        self._log_training_metrics(action_loss, total_loss, total_bs)
+        return total_loss
+
+
+    @torch.no_grad()
+    def validation_step(self, dataset_batch: Dict[str, Dict]) -> Dict[
+        str, torch.Tensor]:  # type: ignore
+        """
+        Compute and log the validation losses and additional metrics.
+        During the validation step, the diffusion model predicts the next action sequence given the current state
+
+        Args:
+            batch: Dictionary containing the batch data for each modality.
+            batch_idx: Index of the batch. used for compatibility with pytorch lightning.
+            dataloader_idx: Index of the dataloader. used for compatibility with pytorch lightning.
+
+        Returns:
+            Dictionary containing the sampled plans of plan recognition and plan proposal module, as well as the
+            episode indices.
+        """
+        output = {}
+        val_total_act_loss_pp = torch.tensor(0.0).to(self.device)
+            # Compute the required embeddings
+        predictive_feature, latent_goal= self.extract_predictive_feature(dataset_batch)
+
+        # predict the next action sequence
+        action_pred = self.denoise_actions(
+            torch.zeros_like(latent_goal).to(latent_goal.device),
+            predictive_feature,
+            latent_goal,
+            inference=True,
+        )
+        dataset_batch["actions"] = dataset_batch["actions"].to(action_pred.device)
+        # compute the mse action loss
+        pred_loss = torch.nn.functional.mse_loss(action_pred, dataset_batch["actions"])
+        val_total_act_loss_pp += pred_loss
+
+        output[f"idx:"] = dataset_batch["idx"]
+        output["validation_loss"] = val_total_act_loss_pp
+        return output
+
+    def training_step_xbot(self, dataset_batch: Dict[str, Dict],):
+        total_loss, action_loss, loss_xyz, loss_rot, loss_hand = (
+            torch.tensor(0.0).to(self.device),
+            torch.tensor(0.0).to(self.device),
+            torch.tensor(0.0).to(self.device),
+            torch.tensor(0.0).to(self.device),
+            torch.tensor(0.0).to(self.device),
+        )
+        predictive_feature, latent_goal= self.extract_predictive_feature(dataset_batch)
+
+        target, model_output = self.diffusion_loss(
+            predictive_feature,
+            latent_goal,
+            dataset_batch["actions"],
+        )
+        loss_dict = {}
+        loss_dict['loss_xyz'] = (model_output[:,:,:3] - target[:,:,:3]).pow(2).mean()*3/38+(model_output[:,:,19:22] - target[:,:,19:22]).pow(2).mean()*3/38
+        loss_dict['loss_rot'] = (model_output[:,:,3:7] - target[:,:,3:7]).pow(2).mean()*4/38+(model_output[:,:,22:26] - target[:,:,22:26]).pow(2).mean()*4/38
+        loss_dict['loss_hand'] = (model_output[:,:,7:19] - target[:,:,7:19]).pow(2).mean()*12/38+(model_output[:,:,26:38] - target[:,:,26:38]).pow(2).mean()*12/38
+
+        act_loss = loss_dict['loss_xyz']+loss_dict['loss_rot']+loss_dict['loss_hand']
+        loss_dict['loss'] = act_loss
+
+        action_loss += act_loss
+        loss_xyz += loss_dict['loss_xyz']
+        loss_rot += loss_dict['loss_rot']
+        loss_hand += loss_dict['loss_hand']
+
+        total_loss += act_loss
+
+        return total_loss, loss_xyz, loss_rot, loss_hand
+
+    @torch.no_grad()
+    def validation_step_xbot(self, dataset_batch: Dict[str, Dict], print_it=False) -> Dict[
+        str, torch.Tensor]:  # type: ignore
+        output = {}
+        val_total_act_loss_pp = torch.tensor(0.0).to(self.device)
+            # Compute the required embeddings
+        # perceptual_emb, latent_goal, image_latent_goal = self.compute_input_embeddings(dataset_batch)
+        predictive_feature, latent_goal= self.extract_predictive_feature(dataset_batch)
+
+        # predict the next action sequence
+        action_pred = self.denoise_actions(
+            torch.zeros_like(latent_goal).to(latent_goal.device),
+            predictive_feature,
+            latent_goal,
+            inference=True,
+        )
+        dataset_batch["actions"] = dataset_batch["actions"].to(action_pred.device) #(batch, time, dim)
+        # loss_xyz  = torch.nn.functional.mse_loss(action_pred[:, :, :3], dataset_batch["actions"][:, :, :3])*3/18
+        # loss_rot = torch.nn.functional.mse_loss(action_pred[:, :, 3:-12], dataset_batch["actions"][:, :, 3:-12])*3/18
+        # loss_hand = torch.nn.functional.mse_loss(action_pred[:, :, -12:], dataset_batch["actions"][:, :, -12:])*12/18
+        model_output = action_pred
+        target  = dataset_batch["actions"]
+        loss_xyz = (model_output[:,:,:3] - target[:,:,:3]).pow(2).mean()*3/38+(model_output[:,:,19:22] - target[:,:,19:22]).pow(2).mean()*3/38
+        loss_rot = (model_output[:,:,3:7] - target[:,:,3:7]).pow(2).mean()*4/38+(model_output[:,:,22:26] - target[:,:,22:26]).pow(2).mean()*4/38
+        loss_hand = (model_output[:,:,7:19] - target[:,:,7:19]).pow(2).mean()*12/38+(model_output[:,:,26:38] - target[:,:,26:38]).pow(2).mean()*12/38
+        pred_loss = loss_xyz + loss_rot + loss_hand
+
+        # pred_loss = torch.nn.functional.mse_loss(action_pred, dataset_batch["actions"])
+        # loss_xyz, loss_rot, loss_hand = 0, 0, 0
+
+        latent_encoder_emb = self.model.inner_model.latent_encoder_emb
+        val_total_act_loss_pp += pred_loss
+
+
+        # output[f"idx_{self.modality_scope}"] = dataset_batch["idx"]
+        output["validation_loss"] = val_total_act_loss_pp
+        output["loss_xyz"] = loss_xyz
+        output["loss_rot"] = loss_rot
+        output["loss_hand"] = loss_hand
+
+        if print_it:
+            # print(dataset_batch['frame_ids'])
+            # print(dataset_batch['ann_file'])
+            # print("action_pred_shape:", action_pred.shape)
+            frame_ids = [idx.cpu().numpy() for idx in dataset_batch['frame_ids']]
+            frame_ids = np.array(frame_ids)
+            # print("frame_ids:", frame_ids)
+            for i in range(action_pred.shape[0]):
+                print('data info', dataset_batch['ann_file'][i], frame_ids[:,i])
+                # print("true_action:", dataset_batch["actions"][i].flatten()[:19])
+                # print("pred_action:", action_pred[i].flatten()[:19])
+                print("true_action:", dataset_batch["actions"][i][:4, :7].flatten())
+                print("pred_action:", action_pred[i][:4, :7].flatten())
+
+                print("true_hand:", dataset_batch["actions"][i][:1, -12:].flatten())
+                print("pred_hand:", action_pred[i][:1, -12:].flatten())
+                print('-----------------------------------------------')
+        return output
+
+    def training_step_xhand(self, dataset_batch: Dict[str, Dict],):
+        total_loss, action_loss, loss_xyz, loss_rot, loss_hand = (
+            torch.tensor(0.0).to(self.device),
+            torch.tensor(0.0).to(self.device),
+            torch.tensor(0.0).to(self.device),
+            torch.tensor(0.0).to(self.device),
+            torch.tensor(0.0).to(self.device),
+        )
+        predictive_feature, latent_goal= self.extract_predictive_feature(dataset_batch)
+
+        target, model_output = self.diffusion_loss(
+            predictive_feature,
+            latent_goal,
+            dataset_batch["actions"],
+        )
+        loss_dict = {}
+        loss_dict['loss_xyz'] = (model_output[:,:,:3] - target[:,:,:3]).pow(2).mean()*3/18
+        loss_dict['loss_rot'] = (model_output[:,:,3:-12] - target[:,:,3:-12]).pow(2).mean()*3/18
+        loss_dict['loss_hand'] = (model_output[:,:,-12:] - target[:,:,-12:]).pow(2).mean()*12/18
+        act_loss = loss_dict['loss_xyz']+loss_dict['loss_rot']+loss_dict['loss_hand']
+        loss_dict['loss'] = act_loss
+
+        action_loss += act_loss
+        loss_xyz += loss_dict['loss_xyz']
+        loss_rot += loss_dict['loss_rot']
+        loss_hand += loss_dict['loss_hand']
+
+        total_loss += act_loss
+
+        return total_loss, loss_xyz, loss_rot, loss_hand
+
+    @torch.no_grad()
+    def validation_step_xhand(self, dataset_batch: Dict[str, Dict], print_it=False) -> Dict[
+        str, torch.Tensor]:  # type: ignore
+        """
+        Compute and log the validation losses and additional metrics.
+        During the validation step, the diffusion model predicts the next action sequence given the current state
+
+        Args:
+            batch: Dictionary containing the batch data for each modality.
+            batch_idx: Index of the batch. used for compatibility with pytorch lightning.
+            dataloader_idx: Index of the dataloader. used for compatibility with pytorch lightning.
+
+        Returns:
+            Dictionary containing the sampled plans of plan recognition and plan proposal networks, as well as the
+            episode indices.
+        """
+        output = {}
+        val_total_act_loss_pp = torch.tensor(0.0).to(self.device)
+            # Compute the required embeddings
+        # perceptual_emb, latent_goal, image_latent_goal = self.compute_input_embeddings(dataset_batch)
+        predictive_feature, latent_goal= self.extract_predictive_feature(dataset_batch)
+
+        # predict the next action sequence
+        action_pred = self.denoise_actions(
+            torch.zeros_like(latent_goal).to(latent_goal.device),
+            predictive_feature,
+            latent_goal,
+            inference=True,
+        )
+        dataset_batch["actions"] = dataset_batch["actions"].to(action_pred.device) #(batch, time, dim)
+        # print("action_pred_shape:", action_pred.shape)
+        # print("action_truth_shape:", dataset_batch["actions"].shape)
+        
+        # compute the mse action loss
+        loss_xyz  = torch.nn.functional.mse_loss(action_pred[:, :, :3], dataset_batch["actions"][:, :, :3])*3/18
+        loss_rot = torch.nn.functional.mse_loss(action_pred[:, :, 3:-12], dataset_batch["actions"][:, :, 3:-12])*3/18
+        loss_hand = torch.nn.functional.mse_loss(action_pred[:, :, -12:], dataset_batch["actions"][:, :, -12:])*12/18
+        pred_loss = loss_xyz + loss_rot + loss_hand
+
+        # pred_loss = torch.nn.functional.mse_loss(action_pred, dataset_batch["actions"])
+        # loss_xyz, loss_rot, loss_hand = 0, 0, 0
+
+        latent_encoder_emb = self.model.inner_model.latent_encoder_emb
+        val_total_act_loss_pp += pred_loss
+
+
+        # output[f"idx_{self.modality_scope}"] = dataset_batch["idx"]
+        output["validation_loss"] = val_total_act_loss_pp
+        output["loss_xyz"] = loss_xyz
+        output["loss_rot"] = loss_rot
+        output["loss_hand"] = loss_hand
+
+        if print_it:
+            # print(dataset_batch['frame_ids'])
+            # print(dataset_batch['ann_file'])
+            # print("action_pred_shape:", action_pred.shape)
+            frame_ids = [idx.cpu().numpy() for idx in dataset_batch['frame_ids']]
+            frame_ids = np.array(frame_ids)
+            # print("frame_ids:", frame_ids)
+            for i in range(action_pred.shape[0]):
+                print('data info', dataset_batch['ann_file'][i], frame_ids[:,i])
+                # print("true_action:", dataset_batch["actions"][i].flatten()[:19])
+                # print("pred_action:", action_pred[i].flatten()[:19])
+                print("true_action:", dataset_batch["actions"][i][:4, :-12].flatten())
+                print("pred_action:", action_pred[i][:4, :-12].flatten())
+
+                print("true_hand:", dataset_batch["actions"][i][:1, -12:].flatten())
+                print("pred_hand:", action_pred[i][:1, -12:].flatten())
+                print('-----------------------------------------------')
+        return output
+
+    def extract_predictive_feature(self, dataset_batch):
+        """
+        Compute the required embeddings for the visual ones and the latent goal.
+        """
+        # 1. extract the revelant visual observations
+        rgb_static = dataset_batch["rgb_obs"]['rgb_static'].to(self.device)
+        rgb_gripper = dataset_batch["rgb_obs"]['rgb_gripper'].to(self.device)
+        if 'rgb_gripper2' in dataset_batch["rgb_obs"]:
+            rgb_gripper2 = dataset_batch["rgb_obs"]['rgb_gripper2'].to(self.device)
+        # 3. we compute the language goal if the language modality is in the scope
+        modality = "lang"
+
+        assert self.use_text_not_embedding == True
+        if self.use_text_not_embedding:
+            inputs = self.tokenizer(text=dataset_batch["lang_text"], padding='max_length', return_tensors="pt",truncation=True).to(self.text_encoder.device)
+            outputs = self.text_encoder(**inputs)
+            latent_goal = outputs.text_embeds
+
+        language = dataset_batch["lang_text"]
+
+        batch = rgb_static.shape[0]
+
+        if 'rgb_gripper2' not in dataset_batch["rgb_obs"]:
+            with torch.no_grad():
+                input_rgb = torch.cat([rgb_static, rgb_gripper], dim=0)
+                language = language + language
+                # print("input_rgb_shape:", input_rgb.shape)
+                # print("language_shape:", len(language))
+                perceptual_features = self.TVP_encoder(input_rgb, language, self.timestep,
+                                                            self.extract_layer_idx)
+                # perceptual_features = self.TVP_encoder(input_rgb, language, self.timestep,
+                #                                                self.extract_layer_idx, all_layer=self.use_all_layer,
+                #                                                step_time=1)
+
+            perceptual_features = einops.rearrange(perceptual_features, 'b f c h w-> b f c (h w)')
+            perceptual_features = einops.rearrange(perceptual_features, 'b f c l-> b f l c')
+
+            perceptual_features, gripper_feature = torch.split(perceptual_features, [batch, batch], dim=0)
+            perceptual_features = torch.cat([perceptual_features, gripper_feature], dim=2)
+        
+        else:
+            with torch.no_grad():
+                input_rgb = torch.cat([rgb_static, rgb_gripper, rgb_gripper2], dim=0)
+                language = language + language + language
+                perceptual_features = self.TVP_encoder(input_rgb, language, self.timestep,
+                                                            self.extract_layer_idx)
+
+            perceptual_features = einops.rearrange(perceptual_features, 'b f c h w-> b f c (h w)')
+            perceptual_features = einops.rearrange(perceptual_features, 'b f c l-> b f l c')
+
+            perceptual_features, gripper_feature1, gripper_feature2 = torch.split(perceptual_features, [batch, batch, batch], dim=0)
+            perceptual_features = torch.cat([perceptual_features, gripper_feature1, gripper_feature2], dim=2)
+
+
+        perceptual_features = perceptual_features.to(torch.float32)
+        perceptual_features = self.Video_Former(perceptual_features)
+
+        predictive_feature = {'state_images': perceptual_features}
+        predictive_feature['modality'] = modality
+        if 'state_obs' in dataset_batch.keys():
+            predictive_feature['state_obs'] = dataset_batch['state_obs'].to(self.device)
+
+        return predictive_feature, latent_goal
+
+
+    def _log_training_metrics(self, action_loss, total_loss, total_bs):
+        """
+        Log the training metrics.
+        """
+        self.log("train/action_loss", action_loss, on_step=False, on_epoch=True, sync_dist=True, batch_size=total_bs)
+        self.log("train/total_loss", total_loss, on_step=False, on_epoch=True, sync_dist=True, batch_size=total_bs)
+
+    def _log_validation_metrics(self, pred_loss, img_gen_loss, val_total_act_loss_pp):
+        """
+        Log the validation metrics.
+        """
+        self.log(
+            "val_act/action_loss",
+            val_total_act_loss_pp / len(self.trainer.datamodule.modalities),  # type:ignore
+            sync_dist=True,
+        )
+        self.log(f"val_act/img_gen_loss_pp", img_gen_loss, sync_dist=True)
+
+    def diffusion_loss(
+            self,
+            perceptual_emb: torch.Tensor,
+            latent_goal: torch.Tensor,
+            actions: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Computes the score matching loss given the perceptual embedding, latent goal, and desired actions.
+        """
+        self.model.train()
+        sigmas = self.make_sample_density()(shape=(len(actions),), device=self.device).to(self.device)
+        noise = torch.randn_like(actions).to(self.device)
+        target, model_output = self.model.loss(perceptual_emb, actions, latent_goal, noise, sigmas)
+        return target, model_output
+
+    def denoise_actions(  # type: ignore
+            self,
+            latent_plan: torch.Tensor,
+            perceptual_emb: torch.Tensor,
+            latent_goal: torch.Tensor,
+            inference: Optional[bool] = False,
+            extra_args={}
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Denoise the next sequence of actions
+        """
+        if inference:
+            sampling_steps = self.num_sampling_steps
+        else:
+            sampling_steps = 10
+        self.model.eval()
+        if len(latent_goal.shape) < len(
+                perceptual_emb['state_images'].shape if isinstance(perceptual_emb, dict) else perceptual_emb.shape):
+            latent_goal = latent_goal.unsqueeze(1)  # .expand(-1, seq_len, -1)
+        input_state = perceptual_emb
+        sigmas = self.get_noise_schedule(sampling_steps, self.noise_scheduler)
+
+        x = torch.randn((len(latent_goal), self.act_window_size, self.action_dim), device=self.device) * self.sigma_max
+
+        actions = self.sample_loop(sigmas, x, input_state, latent_goal, latent_plan, self.sampler_type, extra_args)
+
+        return actions
+
+    def make_sample_density(self):
+        """
+        Generate a sample density function based on the desired type for training the model
+        We mostly use log-logistic as it has no additional hyperparameters to tune.
+        """
+        sd_config = []
+        if self.sigma_sample_density_type == 'lognormal':
+            loc = self.sigma_sample_density_mean  # if 'mean' in sd_config else sd_config['loc']
+            scale = self.sigma_sample_density_std  # if 'std' in sd_config else sd_config['scale']
+            return partial(utils.rand_log_normal, loc=loc, scale=scale)
+
+        if self.sigma_sample_density_type == 'loglogistic':
+            loc = sd_config['loc'] if 'loc' in sd_config else math.log(self.sigma_data)
+            scale = sd_config['scale'] if 'scale' in sd_config else 0.5
+            min_value = sd_config['min_value'] if 'min_value' in sd_config else self.sigma_min
+            max_value = sd_config['max_value'] if 'max_value' in sd_config else self.sigma_max
+            return partial(utils.rand_log_logistic, loc=loc, scale=scale, min_value=min_value, max_value=max_value)
+
+        if self.sigma_sample_density_type == 'loguniform':
+            min_value = sd_config['min_value'] if 'min_value' in sd_config else self.sigma_min
+            max_value = sd_config['max_value'] if 'max_value' in sd_config else self.sigma_max
+            return partial(utils.rand_log_uniform, min_value=min_value, max_value=max_value)
+
+        if self.sigma_sample_density_type == 'uniform':
+            return partial(utils.rand_uniform, min_value=self.sigma_min, max_value=self.sigma_max)
+
+        if self.sigma_sample_density_type == 'v-diffusion':
+            min_value = self.min_value if 'min_value' in sd_config else self.sigma_min
+            max_value = sd_config['max_value'] if 'max_value' in sd_config else self.sigma_max
+            return partial(utils.rand_v_diffusion, sigma_data=self.sigma_data, min_value=min_value, max_value=max_value)
+        if self.sigma_sample_density_type == 'discrete':
+            sigmas = self.get_noise_schedule(self.num_sampling_steps * 1e5, 'exponential')
+            return partial(utils.rand_discrete, values=sigmas)
+        if self.sigma_sample_density_type == 'split-lognormal':
+            loc = sd_config['mean'] if 'mean' in sd_config else sd_config['loc']
+            scale_1 = sd_config['std_1'] if 'std_1' in sd_config else sd_config['scale_1']
+            scale_2 = sd_config['std_2'] if 'std_2' in sd_config else sd_config['scale_2']
+            return partial(utils.rand_split_log_normal, loc=loc, scale_1=scale_1, scale_2=scale_2)
+        else:
+            raise ValueError('Unknown sample density type')
+
+    def sample_loop(
+            self,
+            sigmas,
+            x_t: torch.Tensor,
+            state: torch.Tensor,
+            goal: torch.Tensor,
+            latent_plan: torch.Tensor,
+            sampler_type: str,
+            extra_args={},
+    ):
+        """
+        Main method to generate samples depending on the chosen sampler type. DDIM is the default as it works well in all settings.
+        """
+        s_churn = extra_args['s_churn'] if 's_churn' in extra_args else 0
+        s_min = extra_args['s_min'] if 's_min' in extra_args else 0
+        use_scaler = extra_args['use_scaler'] if 'use_scaler' in extra_args else False
+        keys = ['s_churn', 'keep_last_actions']
+        if bool(extra_args):
+            reduced_args = {x: extra_args[x] for x in keys}
+        else:
+            reduced_args = {}
+        if use_scaler:
+            scaler = self.scaler
+        else:
+            scaler = None
+        # ODE deterministic
+        if sampler_type == 'lms':
+            x_0 = sample_lms(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True, extra_args=reduced_args)
+        # ODE deterministic can be made stochastic by S_churn != 0
+        elif sampler_type == 'heun':
+            x_0 = sample_heun(self.model, state, x_t, goal, sigmas, scaler=scaler, s_churn=s_churn, s_tmin=s_min,
+                              disable=True)
+        # ODE deterministic
+        elif sampler_type == 'euler':
+            x_0 = sample_euler(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        # SDE stochastic
+        elif sampler_type == 'ancestral':
+            x_0 = sample_dpm_2_ancestral(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+            # SDE stochastic: combines an ODE euler step with an stochastic noise correcting step
+        elif sampler_type == 'euler_ancestral':
+            x_0 = sample_euler_ancestral(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        # ODE deterministic
+        elif sampler_type == 'dpm':
+            x_0 = sample_dpm_2(self.model, state, x_t, goal, sigmas, disable=True)
+        # ODE deterministic
+        elif sampler_type == 'dpm_adaptive':
+            x_0 = sample_dpm_adaptive(self.model, state, x_t, goal, sigmas[-2].item(), sigmas[0].item(), disable=True)
+        # ODE deterministic
+        elif sampler_type == 'dpm_fast':
+            x_0 = sample_dpm_fast(self.model, state, x_t, goal, sigmas[-2].item(), sigmas[0].item(), len(sigmas),
+                                  disable=True)
+        # 2nd order solver
+        elif sampler_type == 'dpmpp_2s_ancestral':
+            x_0 = sample_dpmpp_2s_ancestral(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        # 2nd order solver
+        elif sampler_type == 'dpmpp_2m':
+            x_0 = sample_dpmpp_2m(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        elif sampler_type == 'dpmpp_2m_sde':
+            x_0 = sample_dpmpp_sde(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        elif sampler_type == 'ddim':
+            x_0 = sample_ddim(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        elif sampler_type == 'dpmpp_2s':
+            x_0 = sample_dpmpp_2s(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        elif sampler_type == 'dpmpp_2_with_lms':
+            x_0 = sample_dpmpp_2_with_lms(self.model, state, x_t, goal, sigmas, scaler=scaler, disable=True)
+        else:
+            raise ValueError('desired sampler type not found!')
+        return x_0
+
+    def get_noise_schedule(self, n_sampling_steps, noise_schedule_type):
+        """
+        Get the noise schedule for the sampling steps. Describes the distribution over the noise levels from sigma_min to sigma_max.
+        """
+        if noise_schedule_type == 'karras':
+            return get_sigmas_karras(n_sampling_steps, self.sigma_min, self.sigma_max, 7,
+                                     self.device)  # rho=7 is the default from EDM karras
+        elif noise_schedule_type == 'exponential':
+            return get_sigmas_exponential(n_sampling_steps, self.sigma_min, self.sigma_max, self.device)
+        elif noise_schedule_type == 'vp':
+            return get_sigmas_vp(n_sampling_steps, device=self.device)
+        elif noise_schedule_type == 'linear':
+            return get_sigmas_linear(n_sampling_steps, self.sigma_min, self.sigma_max, device=self.device)
+        elif noise_schedule_type == 'cosine_beta':
+            return cosine_beta_schedule(n_sampling_steps, device=self.device)
+        elif noise_schedule_type == 've':
+            return get_sigmas_ve(n_sampling_steps, self.sigma_min, self.sigma_max, device=self.device)
+        elif noise_schedule_type == 'iddpm':
+            return get_iddpm_sigmas(n_sampling_steps, self.sigma_min, self.sigma_max, device=self.device)
+        raise ValueError('Unknown noise schedule type')
+
+    def reset(self):
+        """
+        Call this at the beginning of a new rollout when doing inference.
+        """
+        self.plan = None
+        self.latent_goal = None
+        self.rollout_step_counter = 0
+
+    def forward(self,batch, xhand=False, xbot=False):
+        if xhand:
+            return self.training_step_xhand(batch)
+        elif xbot:
+            return self.training_step_xbot(batch)
+        else:
+            return self.training_step(batch)
+    
+
+    def eval_forward(self, obs, goal, xhand=False, xbot=False):
+        """
+        Method for doing inference with the model.
+        """
+        if 'lang_text' in goal:
+            assert self.use_text_not_embedding == True
+            if self.use_text_not_embedding:
+                inputs = self.tokenizer(text=goal["lang_text"], padding='max_length', return_tensors="pt",truncation=True).to(self.text_encoder.device)
+                outputs = self.text_encoder(**inputs)
+                latent_goal = outputs.text_embeds
+            
+            # if self.use_text_not_embedding:
+            #     # print(goal.keys())
+            #     latent_goal = self.language_goal(goal["lang_text"])
+            #     latent_goal = latent_goal.to(torch.float32)
+            # else:
+            #     latent_goal = self.language_goal(goal["lang"]).unsqueeze(0).to(torch.float32).to(
+            #         obs["rgb_obs"]['rgb_static'].device)
+
+        rgb_static = obs["rgb_obs"]['rgb_static'].to(self.device)
+        rgb_gripper = obs["rgb_obs"]['rgb_gripper'].to(self.device)
+        if 'rgb_gripper2' in obs["rgb_obs"]:
+            rgb_gripper2 = obs["rgb_obs"]['rgb_gripper2'].to(self.device)
+
+        language = goal["lang_text"]
+        batch = rgb_static.shape[0]
+
+        if 'rgb_gripper2' not in obs["rgb_obs"]:
+            with torch.no_grad():
+                input_rgb = torch.cat([rgb_static, rgb_gripper], dim=0)
+                language = [language] + [language]
+                print("input_rgb_shape:", input_rgb.shape)
+                print("language_shape:", len(language))
+                perceptual_features = self.TVP_encoder(input_rgb, language, self.timestep,
+                                                            self.extract_layer_idx)
+                # perceptual_features = self.TVP_encoder(input_rgb, language, self.timestep,
+                #                                                self.extract_layer_idx, all_layer=self.use_all_layer,
+                #                                                step_time=1)
+            print("perceptual_features_shape:", perceptual_features.shape)
+            perceptual_features = einops.rearrange(perceptual_features, 'b f c h w-> b f c (h w)')
+            perceptual_features = einops.rearrange(perceptual_features, 'b f c l-> b f l c')
+
+            perceptual_features, gripper_feature = torch.split(perceptual_features, [batch, batch], dim=0)
+            perceptual_features = torch.cat([perceptual_features, gripper_feature], dim=2)
+        else:
+            with torch.no_grad():
+                input_rgb = torch.cat([rgb_static, rgb_gripper, rgb_gripper2], dim=0)
+                language = [language] + [language] + [language]
+                perceptual_features = self.TVP_encoder(input_rgb, language, self.timestep,
+                                                            self.extract_layer_idx)
+
+            perceptual_features = einops.rearrange(perceptual_features, 'b f c h w-> b f c (h w)')
+            perceptual_features = einops.rearrange(perceptual_features, 'b f c l-> b f l c')
+
+            perceptual_features, gripper_feature1, gripper_feature2 = torch.split(perceptual_features, [batch, batch, batch], dim=0)
+            perceptual_features = torch.cat([perceptual_features, gripper_feature1, gripper_feature2], dim=2)
+
+        perceptual_features = perceptual_features.to(torch.float32)
+        perceptual_features = self.Video_Former(perceptual_features)
+
+        perceptual_emb = {'state_images': perceptual_features}
+
+        perceptual_emb['modality'] = "lang"
+
+        if 'state_obs' in obs.keys():
+            perceptual_emb['state_obs'] = obs['state_obs'].to(self.device)
+
+        act_seq = self.denoise_actions(
+            torch.zeros_like(latent_goal).to(latent_goal.device),
+            perceptual_emb,
+            latent_goal,
+            inference=True,
+        )
+        return act_seq
+
+    def step(self, obs, goal):
+        """
+        Do one step of inference with the model. THis method handles the action chunking case.
+        Our model is trained to predict a sequence of actions.
+        We only compute the sequence once every self.multistep steps.
+
+        Args:
+            obs (dict): Observation from environment.
+            goal (dict): Goal as visual observation or embedded language instruction.
+
+        Returns:
+            Predicted action.
+        """
+        if self.rollout_step_counter % self.multistep == 0:
+            pred_action_seq = self.eval_forward(obs, goal)
+
+            self.pred_action_seq = pred_action_seq
+
+        current_action = self.pred_action_seq[0, self.rollout_step_counter]
+        if len(current_action.shape) == 2:
+            current_action = einops.rearrange(current_action, 'b d -> b 1 d')
+        self.rollout_step_counter += 1
+        if self.rollout_step_counter == self.multistep:
+            self.rollout_step_counter = 0
+
+        return current_action
+
+    def step_real(self, obs, goal):
+        """
+        Do one step of inference with the model. THis method handles the action chunking case.
+        Our model is trained to predict a sequence of actions.
+        We only compute the sequence once every self.multistep steps.
+
+        Args:
+            obs (dict): Observation from environment.
+            goal (dict): Goal as visual observation or embedded language instruction.
+
+        Returns:
+            Predicted action.
+        """
+
+        pred_action_seq = self.eval_forward(obs, goal)
+        self.pred_action_seq = pred_action_seq
+
+        return pred_action_seq
+
+    def on_train_start(self) -> None:
+
+        self.model.to(dtype=self.dtype)
+
+        self.Video_Former.to(dtype=self.dtype)
+        self.text_encoder.to(dtype=self.dtype)
+        #self.vae.to(dtype=self.dtype)
+        self.TVP_encoder.to(dtype=self.dtype)
+
+    @rank_zero_only
+    def on_train_epoch_start(self) -> None:
+        logger.info(f"Start training epoch {self.current_epoch}")
+
+    @rank_zero_only
+    def on_train_epoch_end(self, unused: Optional = None) -> None:  # type: ignore
+        logger.info(f"Finished training epoch {self.current_epoch}")
+
+    @rank_zero_only
+    def on_validation_epoch_end(self) -> None:
+        logger.info(f"Finished validation epoch {self.current_epoch}")
+
+
+    def on_validation_epoch_start(self) -> None:
+        log_rank_0(f"Start validation epoch {self.current_epoch}")
+
+    @rank_zero_only
+    def on_train_epoch_start(self) -> None:
+        logger.info(f"Start training epoch {self.current_epoch}")
+
+    @rank_zero_only
+    def on_train_epoch_end(self, unused: Optional = None) -> None:  # type: ignore
+        logger.info(f"Finished training epoch {self.current_epoch}")
+
+    @rank_zero_only
+    def on_validation_epoch_end(self) -> None:
+        logger.info(f"Finished validation epoch {self.current_epoch}")
+
+    def on_validation_epoch_start(self) -> None:
+        log_rank_0(f"Start validation epoch {self.current_epoch}")
+
+
+@rank_zero_only
+def log_rank_0(*args, **kwargs):
+    # when using ddp, only log with rank 0 process
+    logger.info(*args, **kwargs)

code/policy_models/callbacks/ema.py

@@ -0,0 +1,211 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os.path
+import warnings
+from typing import Any, Dict, List, Optional
+import logging
+
+import pytorch_lightning as pl
+import torch
+from pytorch_lightning import Callback
+from pytorch_lightning.utilities import rank_zero_warn
+from pytorch_lightning.utilities.exceptions import MisconfigurationException
+from pytorch_lightning.utilities.types import STEP_OUTPUT
+
+logger = logging.getLogger(__name__)
+
+try:
+    import amp_C
+
+    apex_available = True
+except Exception:
+    apex_available = False
+
+
+class EMA(Callback):
+    """
+    Implements Exponential Moving Averaging (EMA).
+    When training a model, this callback will maintain moving averages of the trained parameters.
+    When evaluating, we use the moving averages copy of the trained parameters.
+    When saving, we save an additional set of parameters with the prefix `ema`.
+    Args:
+        decay: The exponential decay used when calculating the moving average. Has to be between 0-1.
+        apply_ema_every_n_steps: Apply EMA every n global steps.
+        start_step: Start applying EMA from ``start_step`` global step onwards.
+        evaluate_ema_weights_instead: Validate the EMA weights instead of the original weights.
+            Note this means that when saving the model, the validation metrics are calculated with the EMA weights.
+        save_ema_weights_in_callback_state: Enable saving ema weights in callback state.
+            This is not required when using NeMo as the experiment manager handles saving weights.
+    """
+
+    def __init__(
+        self,
+        decay: float,
+        apply_ema_every_n_steps: int = 1,
+        start_step: int = 0,
+        save_ema_weights_in_callback_state: bool = False,
+        evaluate_ema_weights_instead: bool = False,
+        inv_gamma: float = 1.0,
+        power: float = 2 / 3,
+        min_value: float = 0.0,
+        max_value: float = 0.9999,
+    ):
+        if not apex_available:
+            rank_zero_warn(
+                "EMA has better performance when Apex is installed: https://github.com/NVIDIA/apex#installation."
+            )
+        if not (0 <= decay <= 1):
+            raise MisconfigurationException("EMA decay value must be between 0 and 1")
+        self._ema_model_weights: Optional[List[torch.Tensor]] = None
+        self._overflow_buf: Optional[torch.Tensor] = None
+        self._cur_step: Optional[int] = None
+        self._weights_buffer: Optional[List[torch.Tensor]] = None
+        self.apply_ema_every_n_steps = apply_ema_every_n_steps
+        self.start_step = start_step
+        self.save_ema_weights_in_callback_state = save_ema_weights_in_callback_state
+        self.evaluate_ema_weights_instead = evaluate_ema_weights_instead
+        self.decay = decay
+        self.inv_gamma = inv_gamma
+        self.power = power
+        self.min_value = min_value
+        self.max_value = max_value
+    
+    def get_decay(self, optimization_step):
+        step = max(0, optimization_step - self.start_step - 1)
+        value = 1 - (1 + step / self.inv_gamma) ** -self.power
+
+        # clamp the value between min_value and max_value
+        value = max(min(value, self.max_value), self.min_value)
+
+        return value
+
+    def on_train_start(self, trainer: "pl.Trainer", pl_module: "pl.LightningModule") -> None:
+        logging.info('Creating EMA weights copy.')
+        if self._ema_model_weights is None:
+            self._ema_model_weights = [p.detach().clone() for p in pl_module.state_dict().values()]
+        # ensure that all the weights are on the correct device
+        self._ema_model_weights = [p.to(pl_module.device) for p in self._ema_model_weights]
+        self._overflow_buf = torch.IntTensor([0]).to(pl_module.device)
+
+    def ema(self, pl_module: "pl.LightningModule") -> None:
+        if apex_available and pl_module.device.type == "cuda":
+            return self.apply_multi_tensor_ema(pl_module)
+        return self.apply_ema(pl_module)
+
+    def apply_multi_tensor_ema(self, pl_module: "pl.LightningModule") -> None:
+        model_weights = list(pl_module.state_dict().values())
+        amp_C.multi_tensor_axpby(
+            65536,  # todo (sean): chunk size, should we expose?
+            self._overflow_buf,
+            [self._ema_model_weights, model_weights, self._ema_model_weights],
+            self.decay,
+            1 - self.decay,
+            -1,
+        )
+
+    def apply_ema(self, pl_module: "pl.LightningModule") -> None:
+        decay = self.get_decay(self._cur_step)
+        for orig_weight, ema_weight in zip(list(pl_module.state_dict().values()), self._ema_model_weights):
+            if orig_weight.dtype == torch.uint8 or orig_weight.dtype == torch.int64:
+                ema_weight.data = orig_weight.data.clone()
+            else:
+                diff = ema_weight.data - orig_weight.data
+                diff.mul_(1.0 - decay)
+                ema_weight.sub_(diff)
+        self.log("train/ema_rate", decay, on_step=True, on_epoch=False, prog_bar=True)
+
+    def should_apply_ema(self, step: int) -> bool:
+        return step != self._cur_step and step >= self.start_step and step % self.apply_ema_every_n_steps == 0
+
+    def on_train_batch_end(
+        self, 
+        trainer: "pl.Trainer", 
+        pl_module: "pl.LightningModule", 
+        outputs: STEP_OUTPUT, 
+        batch: Any, 
+        batch_idx: int,
+        # dataloader_idx: int,
+    ) -> None:
+        if self.should_apply_ema(trainer.global_step):
+            self._cur_step = trainer.global_step
+            self.ema(pl_module)
+
+    def state_dict(self) -> Dict[str, Any]:
+        if self.save_ema_weights_in_callback_state:
+            return dict(cur_step=self._cur_step, ema_weights=self._ema_model_weights)
+        return dict(cur_step=self._cur_step)
+
+    def load_state_dict(self, state_dict: Dict[str, Any]) -> None:
+        self._cur_step = state_dict['cur_step']
+        # when loading using NeMo, ema weights will be loaded by the experiment manager separately.
+        if self._ema_model_weights is None:
+            self._ema_model_weights = state_dict.get('ema_weights')
+
+    def on_load_checkpoint(
+        self, trainer: "pl.Trainer", pl_module: "pl.LightningModule", checkpoint: Dict[str, Any]
+    ) -> None:
+        checkpoint_callback = trainer.checkpoint_callback
+
+        if trainer.ckpt_path and checkpoint_callback is not None and 'NeMo' in type(checkpoint_callback).__name__:
+            ext = checkpoint_callback.FILE_EXTENSION
+            if trainer.ckpt_path.endswith(f'-EMA{ext}'):
+                logging.info(
+                    "loading EMA based weights. "
+                    "The callback will treat the loaded EMA weights as the main weights"
+                    " and create a new EMA copy when training."
+                )
+                return
+            ema_path = trainer.ckpt_path.replace(ext, f'-EMA{ext}')
+            if os.path.exists(ema_path):
+                ema_state_dict = torch.load(ema_path, map_location=torch.device('cpu'))
+                self._ema_model_weights = ema_state_dict['state_dict'].values()
+                del ema_state_dict
+                logging.info("EMA weights have been loaded successfully. Continuing training with saved EMA weights.")
+            else:
+                warnings.warn(
+                    "we were unable to find the associated EMA weights when re-loading, "
+                    "training will start with new EMA weights.",
+                    UserWarning,
+                )
+
+    def replace_model_weights(self, pl_module: "pl.LightningModule") -> None:
+        self._weights_buffer = [p.detach().clone().to('cpu') for p in pl_module.state_dict().values()]
+        new_state_dict = {k: v for k, v in zip(pl_module.state_dict().keys(), self._ema_model_weights)}
+        pl_module.load_state_dict(new_state_dict)
+
+    def restore_original_weights(self, pl_module: "pl.LightningModule") -> None:
+        state_dict = pl_module.state_dict()
+        new_state_dict = {k: v for k, v in zip(state_dict.keys(), self._weights_buffer)}
+        pl_module.load_state_dict(new_state_dict)
+        del self._weights_buffer
+
+    @property
+    def ema_initialized(self) -> bool:
+        return self._ema_model_weights is not None
+
+    def on_validation_start(self, trainer: "pl.Trainer", pl_module: "pl.LightningModule") -> None:
+        if self.ema_initialized and self.evaluate_ema_weights_instead:
+            self.replace_model_weights(pl_module)
+
+    def on_validation_end(self, trainer: "pl.Trainer", pl_module: "pl.LightningModule") -> None:
+        if self.ema_initialized and self.evaluate_ema_weights_instead:
+            self.restore_original_weights(pl_module)
+
+    def on_test_start(self, trainer: "pl.Trainer", pl_module: "pl.LightningModule") -> None:
+        if self.ema_initialized and self.evaluate_ema_weights_instead:
+            self.replace_model_weights(pl_module)
+
+    def on_test_end(self, trainer: "pl.Trainer", pl_module: "pl.LightningModule") -> None:
+        if self.ema_initialized and self.evaluate_ema_weights_instead:
+            self.restore_original_weights(pl_module)

code/policy_models/datasets/base_dataset.py

@@ -0,0 +1,296 @@
+import logging
+from pathlib import Path
+from typing import Dict, Tuple, Union
+
+import numpy as np
+from omegaconf import DictConfig
+import pyhash
+import torch
+from torch.utils.data import Dataset
+
+from policy_models.datasets.utils.episode_utils import (
+    get_state_info_dict,
+    process_actions,
+    process_depth,
+    process_language,
+    process_rgb,
+    process_state,
+)
+
+hasher = pyhash.fnv1_32()
+logger = logging.getLogger(__name__)
+
+
+def get_validation_window_size(idx: int, min_window_size: int, max_window_size: int) -> int:
+    """
+    In validation step, use hash function instead of random sampling for consistent window sizes across epochs.
+
+    Args:
+        idx: Sequence index.
+        min_window_size: Minimum window size.
+        max_window_size: Maximum window size.
+
+    Returns:
+        Window size computed with hash function.
+    """
+    window_range = max_window_size - min_window_size + 1
+    return min_window_size + hasher(str(idx)) % window_range
+
+
+class BaseDataset(Dataset):
+    """
+    Abstract dataset base class.
+
+    Args:
+        datasets_dir: Path of folder containing episode files (string must contain 'validation' or 'training').
+        obs_space: DictConfig of observation space.
+        proprio_state: DictConfig with shape of prioprioceptive state.
+        key: 'vis' or 'lang'.
+        lang_folder: Name of the subdirectory of the dataset containing the language annotations.
+        num_workers: Number of dataloading workers for this dataset.
+        transforms: Dict with pytorch data transforms.
+        batch_size: Batch size.
+        min_window_size: Minimum window length of loaded sequences.
+        max_window_size: Maximum window length of loaded sequences.
+        pad: If True, repeat last frame such that all sequences have length 'max_window_size'.
+        aux_lang_loss_window: How many sliding windows to consider for auxiliary language losses, counted from the end
+            of an annotated language episode.
+    """
+
+    def __init__(
+        self,
+        datasets_dir: Path,
+        obs_space: DictConfig,
+        proprio_state: DictConfig,
+        key: str,
+        lang_folder: str,
+        num_workers: int,
+        transforms: Dict = {},
+        batch_size: int = 32,
+        min_window_size: int = 16,
+        max_window_size: int = 32,
+        pad: bool = True,
+        aux_lang_loss_window: int = 1,
+        window_sampling_strategy: str = 'random',
+        geometric_p_value: float = 0.1,
+    ):
+        self.observation_space = obs_space
+        self.proprio_state = proprio_state
+        self.transforms = transforms
+        self.with_lang = key == "lang"
+        self.relative_actions = "rel_actions" in self.observation_space["actions"]
+        assert window_sampling_strategy in ('random', 'geometric')
+        self.window_sampling_strategy = window_sampling_strategy
+        self.geometric_p_value = geometric_p_value # only needed for geomtric sampling
+        self.pad = pad
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+        self.min_window_size = min_window_size
+        self.max_window_size = max_window_size
+        self.abs_datasets_dir = datasets_dir
+        self.lang_folder = lang_folder  # if self.with_lang else None
+        self.aux_lang_loss_window = aux_lang_loss_window
+        assert "validation" in self.abs_datasets_dir.as_posix() or "training" in self.abs_datasets_dir.as_posix()
+        self.validation = "validation" in self.abs_datasets_dir.as_posix()
+        assert self.abs_datasets_dir.is_dir()
+        logger.info(f"loading dataset at {self.abs_datasets_dir}")
+        logger.info("finished loading dataset")
+
+    def __getitem__(self, idx: Union[int, Tuple[int, int]]) -> Dict:
+        """
+        Get sequence of dataset.
+
+        Args:
+            idx: Index of the sequence.
+
+        Returns:
+            Loaded sequence.
+        """
+        if isinstance(idx, int):
+            # When max_ws_size and min_ws_size are equal, avoid unnecessary padding
+            # acts like Constant dataset. Currently, used for language data
+            if self.min_window_size == self.max_window_size:
+                window_size = self.max_window_size
+            elif self.min_window_size < self.max_window_size:
+                window_size = self._get_window_size(idx)
+            else:
+                logger.error(f"min_window_size {self.min_window_size} > max_window_size {self.max_window_size}")
+                raise ValueError
+        else:
+            idx, window_size = idx
+        sequence = self._get_sequences(idx, window_size)
+        if self.pad:
+            pad_size = self._get_pad_size(sequence)
+            sequence = self._pad_sequence(sequence, pad_size)
+        return sequence
+
+    def _get_sequences(self, idx: int, window_size: int) -> Dict:
+        """
+        Load sequence of length window_size.
+
+        Args:
+            idx: Index of starting frame.
+            window_size: Length of sampled episode.
+
+        Returns:
+            dict: Dictionary of tensors of loaded sequence with different input modalities and actions.
+        """
+
+        episode = self._load_episode(idx, window_size)
+
+        seq_state_obs = process_state(episode, self.observation_space, self.transforms, self.proprio_state)
+        seq_rgb_obs = process_rgb(episode, self.observation_space, self.transforms)
+        #seq_depth_obs = process_depth(episode, self.observation_space, self.transforms)
+        seq_acts = process_actions(episode, self.observation_space, self.transforms)
+        info = get_state_info_dict(episode)
+        seq_lang = process_language(episode, self.transforms, self.with_lang)
+        info = self._add_language_info(info, idx)
+        seq_dict = {**seq_state_obs, **seq_rgb_obs, **seq_acts, **info, **seq_lang}  # type:ignore
+        seq_dict["idx"] = idx  # type:ignore
+        return seq_dict
+
+    def _load_episode(self, idx: int, window_size: int) -> Dict[str, np.ndarray]:
+        raise NotImplementedError
+
+    def _get_window_size(self, idx: int) -> int:
+        """
+        Sample a window size taking into account the episode limits.
+
+        Args:
+            idx: Index of the sequence to load.
+
+        Returns:
+            Window size.
+        """
+        window_diff = self.max_window_size - self.min_window_size
+        if len(self.episode_lookup) <= idx + window_diff:
+            # last episode
+            max_window = self.min_window_size + len(self.episode_lookup) - idx - 1
+        elif self.episode_lookup[idx + window_diff] != self.episode_lookup[idx] + window_diff:
+            # less than max_episode steps until next episode
+            steps_to_next_episode = int(
+                np.nonzero(
+                    self.episode_lookup[idx : idx + window_diff + 1]
+                    - (self.episode_lookup[idx] + np.arange(window_diff + 1))
+                )[0][0]
+            )
+            max_window = min(self.max_window_size, (self.min_window_size + steps_to_next_episode - 1))
+        else:
+            max_window = self.max_window_size
+
+        if self.validation:
+            # in validation step, repeat the window sizes for each epoch.
+            return get_validation_window_size(idx, self.min_window_size, max_window)
+        else:
+            if self.window_sampling_strategy == 'geometric':
+                p = self.geometric_p_value # Choose a suitable value for p
+                while True:
+                    sampled_window_size = 1 + np.random.geometric(p)
+                    if self.min_window_size <= sampled_window_size <= max_window:
+                        return sampled_window_size
+            else:
+                return np.random.randint(self.min_window_size, max_window + 1)
+
+    def __len__(self) -> int:
+        """
+        Returns:
+            Size of the dataset.
+        """
+        return len(self.episode_lookup)
+
+    def _get_pad_size(self, sequence: Dict) -> int:
+        """
+        Determine how many frames to append to end of the sequence
+
+        Args:
+            sequence: Loaded sequence.
+
+        Returns:
+            Number of frames to pad.
+        """
+        return self.max_window_size - len(sequence["actions"])
+
+    def _pad_sequence(self, seq: Dict, pad_size: int) -> Dict:
+        """
+        Pad a sequence by repeating the last frame.
+
+        Args:
+            seq: Sequence to pad.
+            pad_size: Number of frames to pad.
+
+        Returns:
+            Padded sequence.
+        """
+        seq.update({"robot_obs": self._pad_with_repetition(seq["robot_obs"], pad_size)})
+        seq.update({"rgb_obs": {k: self._pad_with_repetition(v, pad_size) for k, v in seq["rgb_obs"].items()}})
+        seq.update({"depth_obs": {k: self._pad_with_repetition(v, pad_size) for k, v in seq["depth_obs"].items()}})
+        #  todo: find better way of distinguishing rk and play action spaces
+        if not self.relative_actions:
+            # repeat action for world coordinates action space
+            seq.update({"actions": self._pad_with_repetition(seq["actions"], pad_size)})
+        else:
+            # for relative actions zero pad all but the last action dims and repeat last action dim (gripper action)
+            seq_acts = torch.cat(
+                [
+                    self._pad_with_zeros(seq["actions"][..., :-1], pad_size),
+                    self._pad_with_repetition(seq["actions"][..., -1:], pad_size),
+                ],
+                dim=-1,
+            )
+            seq.update({"actions": seq_acts})
+        seq.update({"state_info": {k: self._pad_with_repetition(v, pad_size) for k, v in seq["state_info"].items()}})
+        return seq
+
+    @staticmethod
+    def _pad_with_repetition(input_tensor: torch.Tensor, pad_size: int) -> torch.Tensor:
+        """
+        Pad a sequence Tensor by repeating last element pad_size times.
+
+        Args:
+            input_tensor: Sequence to pad.
+            pad_size: Number of frames to pad.
+
+        Returns:
+            Padded Tensor.
+        """
+        last_repeated = torch.repeat_interleave(torch.unsqueeze(input_tensor[-1], dim=0), repeats=pad_size, dim=0)
+        padded = torch.vstack((input_tensor, last_repeated))
+        return padded
+
+    @staticmethod
+    def _pad_with_zeros(input_tensor: torch.Tensor, pad_size: int) -> torch.Tensor:
+        """
+        Pad a Tensor with zeros.
+
+        Args:
+            input_tensor: Sequence to pad.
+            pad_size: Number of frames to pad.
+
+        Returns:
+            Padded Tensor.
+        """
+        zeros_repeated = torch.repeat_interleave(
+            torch.unsqueeze(torch.zeros(input_tensor.shape[-1]), dim=0), repeats=pad_size, dim=0
+        )
+        padded = torch.vstack((input_tensor, zeros_repeated))
+        return padded
+
+    def _add_language_info(self, info: Dict, idx: int) -> Dict:
+        """
+        If dataset contains language, add info to determine if this sequence will be used for the auxiliary losses.
+
+        Args:
+            info: Info dictionary.
+            idx: Sequence index.
+
+        Returns:
+            Info dictionary with updated information.
+        """
+        if not self.with_lang:
+            return info
+        use_for_aux_lang_loss = (
+            idx + self.aux_lang_loss_window >= len(self.lang_lookup)
+            or self.lang_lookup[idx] < self.lang_lookup[idx + self.aux_lang_loss_window]
+        )
+        info["use_for_aux_lang_loss"] = use_for_aux_lang_loss
+        return info

code/policy_models/datasets/disk_dataset.py

@@ -0,0 +1,280 @@
+import os.path
+from itertools import chain
+import logging
+from pathlib import Path
+import pickle
+from typing import Any, Dict, List, Tuple
+import random
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import concurrent.futures
+import numpy as np
+
+from policy_models.datasets.base_dataset import BaseDataset
+from policy_models.datasets.utils.episode_utils import lookup_naming_pattern
+
+logger = logging.getLogger(__name__)
+
+
+def load_pkl(filename: Path) -> Dict[str, np.ndarray]:
+    with open(filename, "rb") as f:
+        return pickle.load(f)
+
+
+def load_npz(filename: Path) -> Dict[str, np.ndarray]:
+    return np.load(filename.as_posix())
+
+
+class DiskDataset(BaseDataset):
+    """
+    Dataset that loads episodes as individual files from disk.
+
+    Args:
+        skip_frames: Skip this amount of windows for language dataset.
+        save_format: File format in datasets_dir (pkl or npz).
+        pretrain: Set to True when pretraining.
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        skip_frames: int = 1,
+        save_format: str = "npz",
+        pretrain: bool = False,
+        **kwargs: Any,
+    ):
+        super().__init__(*args, **kwargs)
+        self.save_format = save_format
+        if self.save_format == "pkl":
+            self.load_file = load_pkl
+        elif self.save_format == "npz":
+            self.load_file = load_npz
+        else:
+            raise NotImplementedError
+        self.pretrain = pretrain
+        self.skip_frames = skip_frames
+
+        if self.with_lang:
+            self.episode_lookup, self.lang_lookup, self.lang_ann, self.lang_text = self._build_file_indices_lang(self.abs_datasets_dir)
+        else:
+            self.episode_lookup = self._build_file_indices(self.abs_datasets_dir)
+
+        self.naming_pattern, self.n_digits = lookup_naming_pattern(self.abs_datasets_dir, self.save_format)
+
+    def _get_episode_name(self, file_idx: int) -> Path:
+        """
+        Convert file idx to file path.
+
+        Args:
+            file_idx: index of starting frame.
+
+        Returns:
+            Path to file.
+        """
+        return Path(f"{self.naming_pattern[0]}{file_idx:0{self.n_digits}d}{self.naming_pattern[1]}")
+
+    def _load_episode(self, idx: int, window_size: int) -> Dict[str, np.ndarray]:
+        """
+        Load consecutive frames saved as individual files on disk and combine to episode dict.
+
+        Args:
+            idx: Index of first frame.
+            window_size: Length of sampled episode.
+
+        Returns:
+            episode: Dict of numpy arrays containing the episode where keys are the names of modalities.
+        """
+        start_idx = self.episode_lookup[idx]
+        end_idx = start_idx + window_size
+        keys = list(chain(*self.observation_space.values()))
+        keys.remove("language")
+        keys.append("scene_obs")
+        episodes = [self.load_file(self._get_episode_name(file_idx)) for file_idx in range(start_idx, end_idx)]
+        episode = {key: np.stack([ep[key] for ep in episodes]) for key in keys}
+        if self.with_lang:
+            episode["language"] = self.lang_ann[self.lang_lookup[idx]][0]  # TODO check  [0]
+        return episode
+
+    def _build_file_indices_lang(self, abs_datasets_dir: Path) -> Tuple[np.ndarray, List, np.ndarray]:
+        """
+        This method builds the mapping from index to file_name used for loading the episodes of the language dataset.
+
+        Args:
+            abs_datasets_dir: Absolute path of the directory containing the dataset.
+
+        Returns:
+            episode_lookup: Mapping from training example index to episode (file) index.
+            lang_lookup: Mapping from training example to index of language instruction.
+            lang_ann: Language embeddings.
+        """
+        assert abs_datasets_dir.is_dir()
+
+        episode_lookup = []
+
+        try:
+            print("trying to load lang data from: ", abs_datasets_dir / self.lang_folder / "auto_lang_ann.npy")
+            lang_data = np.load(abs_datasets_dir / self.lang_folder / "auto_lang_ann.npy", allow_pickle=True).item()
+        except Exception:
+            print("Exception, trying to load lang data from: ", abs_datasets_dir / "auto_lang_ann.npy")
+            lang_data = np.load(abs_datasets_dir / "auto_lang_ann.npy", allow_pickle=True).item()
+
+        ep_start_end_ids = lang_data["info"]["indx"]  # each of them are 64
+        lang_ann = lang_data["language"]["emb"]  # length total number of annotations
+        lang_text = lang_data["language"]["ann"]  # length total number of annotations
+        lang_lookup = []
+        for i, (start_idx, end_idx) in enumerate(ep_start_end_ids):
+            if self.pretrain:
+                start_idx = max(start_idx, end_idx + 1 - self.min_window_size - self.aux_lang_loss_window)
+            assert end_idx >= self.max_window_size
+            cnt = 0
+            for idx in range(start_idx, end_idx + 1 - self.min_window_size):
+                if cnt % self.skip_frames == 0:
+                    lang_lookup.append(i)
+                    episode_lookup.append(idx)
+                cnt += 1
+
+        return np.array(episode_lookup), lang_lookup, lang_ann, lang_text
+
+    def _build_file_indices(self, abs_datasets_dir: Path) -> np.ndarray:
+        """
+        This method builds the mapping from index to file_name used for loading the episodes of the non language
+        dataset.
+
+        Args:
+            abs_datasets_dir: Absolute path of the directory containing the dataset.
+
+        Returns:
+            episode_lookup: Mapping from training example index to episode (file) index.
+        """
+        assert abs_datasets_dir.is_dir()
+
+        episode_lookup = []
+        ep_start_end_ids = np.load(abs_datasets_dir / "ep_start_end_ids.npy")
+        logger.info(f'Found "ep_start_end_ids.npy" with {len(ep_start_end_ids)} episodes.')
+        for start_idx, end_idx in ep_start_end_ids:
+            assert end_idx > self.max_window_size
+            for idx in range(start_idx, end_idx + 1 - self.min_window_size):
+                episode_lookup.append(idx)
+        return np.array(episode_lookup)
+
+
+class ExtendedDiskDataset(DiskDataset):
+    def __init__(
+        self,
+        *args: Any,
+        obs_seq_len: int,
+        action_seq_len: int,
+        future_range: int,
+        img_gen_frame_diff: int = 3,
+        **kwargs: Any,
+    ):
+        super().__init__(*args, **kwargs)
+        self.obs_seq_len = obs_seq_len
+        self.action_seq_len = action_seq_len
+        self.future_range = future_range  # Number of steps into the future to sample goals
+        self.ep_start_end_ids = np.load(self.abs_datasets_dir / "ep_start_end_ids.npy")  # Load sequence boundaries
+        self.img_gen_frame_diff = img_gen_frame_diff
+        self.random_frame_diff = False if img_gen_frame_diff > -1 else True 
+        # self.min_window_size = self.action_seq_len
+        # self.max_window_size = self.action_seq_len + self.future_range
+        
+    def find_sequence_boundaries(self, idx: int) -> Tuple[int, int]:
+        for start_idx, end_idx in self.ep_start_end_ids:
+            if start_idx <= idx < end_idx:
+                return start_idx, end_idx
+        raise ValueError(f"Index {idx} does not belong to any sequence.")
+
+    def _load_episode(self, idx: int, window_size: int) -> Dict[str, np.ndarray]:
+        """
+        Load consecutive frames saved as individual files on disk and combine to episode dict.
+
+        Args:
+            idx: Index of first frame.
+            window_size: Length of sampled episode.
+
+        Returns:
+            episode: Dict of numpy arrays containing the episode where keys are the names of modalities.
+        """
+        start_idx = self.episode_lookup[idx]
+        end_idx = start_idx + self.action_seq_len + self.obs_seq_len-1
+        keys = list(chain(*self.observation_space.values()))
+        keys.remove("language")
+        keys.append("scene_obs")
+        episodes = [self.load_file(self._get_episode_name(file_idx)) for file_idx in range(start_idx, end_idx)]
+
+        episode = {}
+        for key in keys:
+            if 'gen' in key:
+                continue
+            stacked_data = np.stack([ep[key] for ep in episodes])
+            if key == "rel_actions" or key == 'actions':
+                episode[key] = stacked_data[(self.obs_seq_len-1):((self.obs_seq_len-1) + self.action_seq_len), :]
+            else:
+                episode[key] = stacked_data[:self.obs_seq_len, :]
+
+        if self.with_lang:
+            episode["language"] = self.lang_ann[self.lang_lookup[idx]][0]  # TODO check  [0]
+            episode["language_text"] = self.lang_text[self.lang_lookup[idx]] #[0]  # TODO check  [0]
+        
+        # get the random future state as goal
+        # goal_idx = end_idx + window_size
+        # # print(start_idx, end_idx, goal_idx)
+        # eps_start_idx, eps_end_idx = self.find_sequence_boundaries(end_idx)
+        #
+        # # Check if future goal can be sampled
+        #
+        # if eps_end_idx < goal_idx:
+        #     goal_idx = eps_end_idx
+        
+        # goal_episodes = self.load_file(self._get_episode_name(goal_idx))
+        # goal_episode = {}
+        # for key in keys:
+        #     if 'gen' in key:
+        #         continue
+        #     goal_stacked_data = np.stack([goal_episodes[key]])
+        #     if key == "rel_actions" or key == 'actions':
+        #         pass
+        #     else:
+        #         goal_episode[key] = goal_stacked_data[:self.obs_seq_len, :]
+        # # store for merging
+        #
+        # episode = self.merge_episodes(episode, goal_episode)
+        return episode
+       
+    
+    def merge_episodes(self, episode1: Dict[str, np.ndarray], episode2: Dict[str, np.ndarray]) -> Dict[str, np.ndarray]:
+        merged_episode = {}
+        all_keys = set(episode1.keys()).union(set(episode2.keys()))
+        for key in all_keys:
+            if key in episode1 and key in episode2:
+                # Merge logic here, for example:
+                merged_episode[key] = np.concatenate([episode1[key], episode2[key]], axis=0)
+            elif key in episode1:
+                merged_episode[key] = episode1[key]
+            else:
+                merged_episode[key] = episode2[key]
+        return merged_episode
+    
+    def _build_file_indices(self, abs_datasets_dir: Path) -> np.ndarray:
+        """
+        This method builds the mapping from index to file_name used for loading the episodes of the non language
+        dataset.
+
+        Args:
+            abs_datasets_dir: Absolute path of the directory containing the dataset.
+
+        Returns:
+            episode_lookup: Mapping from training example index to episode (file) index.
+        """
+        assert abs_datasets_dir.is_dir()
+
+        episode_lookup = []
+
+        ep_start_end_ids = np.load(abs_datasets_dir / "ep_start_end_ids.npy")
+        logger.info(f'Found "ep_start_end_ids.npy" with {len(ep_start_end_ids)} episodes.')
+        for start_idx, end_idx in ep_start_end_ids:
+            assert end_idx > self.max_window_size
+            for idx in range(start_idx, end_idx + 1 - self.min_window_size):
+                episode_lookup.append(idx)
+        return np.array(episode_lookup)
+

code/policy_models/datasets/hulc_data_module.py

@@ -0,0 +1,160 @@
+import logging
+import os
+from pathlib import Path
+from typing import Dict, List
+
+import hydra
+import numpy as np
+from omegaconf import DictConfig, OmegaConf
+
+from torch.utils.data import DataLoader
+import torchvision
+import pytorch_lightning as pl
+
+import policy_models
+from policy_models.datasets.utils.episode_utils import load_dataset_statistics
+from policy_models.datasets.utils.shared_memory_utils import load_shm_lookup, save_shm_lookup, SharedMemoryLoader
+
+logger = logging.getLogger(__name__)
+DEFAULT_TRANSFORM = OmegaConf.create({"train": None, "val": None})
+ONE_EP_DATASET_URL = "http://www.informatik.uni-freiburg.de/~meeso/50steps.tar.xz"
+
+
+class HulcDataModule(pl.LightningDataModule):
+    def __init__(
+        self,
+        datasets: DictConfig,
+        root_data_dir: str = "data",
+        num_workers: int = 8,
+        transforms: DictConfig = DEFAULT_TRANSFORM,
+        shuffle_val: bool = False,
+        **kwargs: Dict,
+    ):
+        super().__init__()
+        self.datasets_cfg = datasets
+        self.train_datasets = None
+        self.val_datasets = None
+        self.train_sampler = None
+        self.val_sampler = None
+        self.num_workers = num_workers
+        root_data_path = Path(root_data_dir)
+        if not root_data_path.is_absolute():
+            root_data_path = Path(policy_models.__file__).parent / root_data_path
+        self.training_dir = root_data_path / "training"
+        self.val_dir = root_data_path / "validation"
+        self.shuffle_val = shuffle_val
+        self.modalities: List[str] = []
+        self.transforms = transforms
+        self.use_shm = False
+
+        #if 'lang_dataset' in self.datasets_cfg:
+        #    if "shm_dataset" in self.datasets_cfg.lang_dataset._target_:
+        #        self.use_shm = "shm_dataset" in self.datasets_cfg.lang_dataset._target_
+        #    else:
+        #        self.use_shm = False
+        #elif 'shm_dataset' in self.datasets_cfg.vision_dataset._target_:
+        #    self.use_shm = True
+        #else:
+        #    self.use_shm = False
+
+    def prepare_data(self, *args, **kwargs):
+        # check if files already exist
+        dataset_exist = np.any([len(list(self.training_dir.glob(extension))) for extension in ["*.npz", "*.pkl"]])
+
+        # download and unpack images
+        if not dataset_exist:
+            if "CI" not in os.environ:
+                print(f"No dataset found in {self.training_dir}.")
+                print("For information how to download to full CALVIN dataset, please visit")
+                print("https://github.com/mees/calvin/tree/main/dataset")
+                print("Do you wish to download small debug dataset to continue training?")
+                s = input("YES / no")
+                if s == "no":
+                    exit()
+            logger.info(f"downloading dataset to {self.training_dir} and {self.val_dir}")
+            torchvision.datasets.utils.download_and_extract_archive(ONE_EP_DATASET_URL, self.training_dir)
+            torchvision.datasets.utils.download_and_extract_archive(ONE_EP_DATASET_URL, self.val_dir)
+
+        # if self.use_shm:
+        #     # When using shared memory dataset, initialize lookups
+        #     train_shmem_loader = SharedMemoryLoader(self.datasets_cfg, self.training_dir)
+        #     train_shm_lookup = train_shmem_loader.load_data_in_shared_memory()
+        #
+        #     val_shmem_loader = SharedMemoryLoader(self.datasets_cfg, self.val_dir)
+        #     val_shm_lookup = val_shmem_loader.load_data_in_shared_memory()
+        #
+        #     save_shm_lookup(train_shm_lookup, val_shm_lookup)
+
+    def setup(self, stage=None):
+        transforms = load_dataset_statistics(self.training_dir, self.val_dir, self.transforms)
+
+        # self.train_transforms = {
+        #    cam: [hydra.utils.instantiate(transform) for transform in transforms.train[cam]] for cam in transforms.train
+        #}
+        self.train_transforms = {}
+        for cam in transforms.train:
+            # print("Processing camera:", cam)
+            cam_transforms = []
+            for transform in transforms.train[cam]:
+                # print("Instantiating transform for camera", cam, ":", transform)
+                if transform._target_ == "torchvision.transforms.ColorJitter":
+                    instantiated_transform = torchvision.transforms.ColorJitter(
+                        brightness=transform.brightness,
+                        contrast=tuple(transform.contrast),
+                        saturation=tuple(transform.saturation),
+                    )
+                else:
+                    instantiated_transform = hydra.utils.instantiate(transform)
+                cam_transforms.append(instantiated_transform)
+            self.train_transforms[cam] = cam_transforms
+
+        self.val_transforms = {
+            cam: [hydra.utils.instantiate(transform) for transform in transforms.val[cam]] for cam in transforms.val
+        }
+        self.train_transforms = {key: torchvision.transforms.Compose(val) for key, val in self.train_transforms.items()}
+        self.val_transforms = {key: torchvision.transforms.Compose(val) for key, val in self.val_transforms.items()}
+        self.train_datasets, self.train_sampler, self.val_datasets, self.val_sampler = {}, {}, {}, {}
+
+        # if self.use_shm:
+        #     train_shm_lookup, val_shm_lookup = load_shm_lookup()
+
+        for _, dataset in self.datasets_cfg.items():
+            if dataset == 'lang_paraphrase-MiniLM-L3-v2':
+                continue
+            else:
+                train_dataset = hydra.utils.instantiate(
+                    dataset, datasets_dir=self.training_dir, transforms=self.train_transforms
+                )
+                val_dataset = hydra.utils.instantiate(dataset, datasets_dir=self.val_dir, transforms=self.val_transforms)
+                # if self.use_shm:
+                #     train_dataset.setup_shm_lookup(train_shm_lookup)
+                #     val_dataset.setup_shm_lookup(val_shm_lookup)
+                key = dataset.key
+                self.train_datasets[key] = train_dataset
+                self.val_datasets[key] = val_dataset
+                self.modalities.append(key)
+
+    def train_dataloader(self):
+        return {
+            key: DataLoader(
+                dataset,
+                batch_size=dataset.batch_size,
+                num_workers=dataset.num_workers,
+                pin_memory=True,
+                shuffle=True,
+                prefetch_factor=2,
+            )
+            for key, dataset in self.train_datasets.items()
+        }
+
+    def val_dataloader(self):
+        return {
+            key: DataLoader(
+                dataset,
+                batch_size=dataset.batch_size,
+                num_workers=dataset.num_workers,
+                pin_memory=True,
+            )
+            for key, dataset in self.val_datasets.items()
+        }
+

code/policy_models/datasets/mvlibero_dataset.py

@@ -0,0 +1,230 @@
+# Copyright (2024) Bytedance Ltd. and/or its affiliates
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import random
+import warnings
+import traceback
+import argparse
+from omegaconf import OmegaConf
+from tqdm import tqdm
+from torchvision import transforms as T
+import torch
+from torch.utils.data import Dataset,DataLoader
+import numpy as np
+import imageio
+from decord import VideoReader, cpu
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from einops import rearrange
+
+# from mdt.datasets.utils.dataset_util import euler2rotm, rotm2euler
+# from mdt.datasets.utils.video_transforms import Resize_Preprocess, ToTensorVideo
+# from mdt.datasets.utils.util import update_paths
+from scipy.spatial.transform import Rotation as R  
+import decord
+
+class Dataset_mvlibero(Dataset):
+    def __init__(
+            self,
+            args,
+            mode = 'val',
+    ):
+        """Constructor."""
+        super().__init__()
+        self.args = args
+        self.mode = mode
+        data_json_path = args.data_json_path
+        data_root_path = args.data_root_path
+
+        # dataset stucture
+        # dataset_dir/dataset_name/annotation_name/mode/traj
+        # dataset_dir/dataset_name/video/mode/traj
+        # dataset_dir/dataset_name/latent_video/mode/traj
+
+        # samles:{'ann_file':xxx, 'frame_idx':xxx, 'dataset_name':xxx}
+
+        # prepare all datasets path
+        self.video_path = []
+        data_json_path = f'{data_json_path}/{mode}_all.json'
+        with open(data_json_path, "r") as f:
+            self.samples = json.load(f)
+        self.video_path = [os.path.join(data_root_path, sample['dataset_name']) for sample in self.samples]
+        
+        print(f"ALL dataset, {len(self.samples)} samples in total")
+
+        # with open(f'{self.args.action_json}', "r") as f:
+        # self.stat = json.load(f)
+        self.a_min = np.array(args.action_01)[None,:]
+        self.a_max = np.array(args.action_99)[None,:]
+        self.s_min = np.array(args.state_01)[None,:]
+        self.s_max = np.array(args.state_99)[None,:]
+        print(f"action min: {self.a_min.shape}, action max: {self.a_max.shape}")
+
+    def __len__(self):
+        return len(self.samples)
+
+    def _load_latent_video(self, video_path, frame_ids):
+        # video_path = video_path.split('/')[:-1]
+        # video_path = '/'.join(video_path)+'/0.pt'
+        
+        # print(video_path)
+        with open(video_path,'rb') as file:
+            video_tensor = torch.load(file)
+            video_tensor.requires_grad = False
+        # vr = VideoReader(video_path, ctx=cpu(0), num_threads=2)
+        # print(video_tensor.size(),np.array(frame_ids))
+        try:
+            assert (np.array(frame_ids) < video_tensor.size()[0]).all()
+            assert (np.array(frame_ids) >= 0).all()
+        except:
+            assert False
+        frame_data = video_tensor[frame_ids]
+        return frame_data
+
+    def _get_frames(self, label, frame_ids, cam_id, pre_encode, video_dir, use_img_cond=False):
+        # directly load videos latent after svd-vae encoder
+        assert cam_id is not None
+        assert pre_encode == True
+        if pre_encode: 
+            video_path = label['latent_videos'][cam_id]['latent_video_path']
+            try:
+                video_path = os.path.join(video_dir,video_path)
+                frames = self._load_latent_video(video_path, frame_ids)
+            except:
+                video_path = video_path.replace("latent_videos", "latent_videos_svd")
+                frames = self._load_latent_video(video_path, frame_ids)
+        # load original videos
+        else: 
+            if use_img_cond:
+                frame_ids = frame_ids[0]
+            video_path = label['videos'][cam_id]['video_path']
+            video_path = os.path.join(video_dir,video_path)
+            # frames = self._load_video(video_path, frame_ids)
+            # frames = mediapy.read_video(video_path)
+            vr = decord.VideoReader(video_path)
+            frames = vr[frame_ids].asnumpy()
+            frames = torch.from_numpy(frames).permute(2,0,1).unsqueeze(0) # (frame, h, w, c) -> (frame, c, h, w)
+            # resize the video to self.args.video_size
+            frames = self.preprocess(frames)
+        return frames
+
+    def _get_obs(self, label, frame_ids, cam_id, pre_encode, video_dir):
+        if cam_id is None:
+            temp_cam_id = random.choice(self.cam_ids)
+        else:
+            temp_cam_id = cam_id
+        frames = self._get_frames(label, frame_ids, cam_id = temp_cam_id, pre_encode = pre_encode, video_dir=video_dir)
+        return frames, temp_cam_id
+
+    def normalize_bound(
+        self,
+        data: np.ndarray,
+        data_min: np.ndarray,
+        data_max: np.ndarray,
+        clip_min: float = -1,
+        clip_max: float = 1,
+        eps: float = 1e-8,
+    ) -> np.ndarray:
+        ndata = 2 * (data - data_min) / (data_max - data_min + eps) - 1
+        return np.clip(ndata, clip_min, clip_max)
+
+    def denormalize_bound(
+        self,
+        data: np.ndarray,
+        data_min: np.ndarray,
+        data_max: np.ndarray,
+        clip_min: float = -1,
+        clip_max: float = 1,
+        eps=1e-8,
+    ) -> np.ndarray:
+        clip_range = clip_max - clip_min
+        rdata = (data - clip_min) / clip_range * (data_max - data_min) + data_min
+        return rdata
+
+    def process_action_xhand(self, label,frame_ids, rel = False):
+        num_frames = len(frame_ids)
+        frame_ids = frame_ids[:int(self.args.num_frames)] # (f)
+        states = np.array(label['states'])[frame_ids] #(f, 38)
+        command = np.array(label['actions'])[frame_ids]
+
+        # print(f'states: {states.shape}, actions: {command.shape}')
+
+        state = states[0:1] # current state
+
+        a_dim = command.shape[-1]
+        action_base = state[:,:a_dim] #(1,38)
+        actions = command - action_base #(self.args.num_frames,38)
+
+        # normalize
+        action_scaled = self.normalize_bound(actions, self.a_min, self.a_max)
+        state_scaled = self.normalize_bound(state, self.s_min, self.s_max)
+        return torch.from_numpy(action_scaled).float(), torch.from_numpy(state_scaled).float()
+
+    def __getitem__(self, index, cam_id = None, return_video = False):
+
+        sample = self.samples[index]
+        sampled_video_dir = self.video_path[index]
+
+        ann_file = sample['ann_file']
+        # dataset_name = sample['dataset_name']
+        ann_file = f'{sampled_video_dir}/{ann_file}'
+        frame_ids = sample['frame_ids']
+        with open(ann_file, "r") as f:
+            label = json.load(f)
+
+        data = dict()
+        # action
+        data['actions'], data['state_obs'] = self.process_action_xhand(label,frame_ids,rel=self.args.relative)
+        # instructions
+        data['lang_text'] = label['texts'][0]
+        # observation
+        static_latent, cam_id = self._get_obs(label, frame_ids[0], cam_id=0, pre_encode=self.args.pre_encode,video_dir=sampled_video_dir)
+        gripper_latent, cam_id = self._get_obs(label, frame_ids[0], cam_id=1, pre_encode=self.args.pre_encode,video_dir=sampled_video_dir)
+        gripper_latent2, cam_id = self._get_obs(label, frame_ids[0], cam_id=2, pre_encode=self.args.pre_encode,video_dir=sampled_video_dir)
+        static_latent = static_latent.unsqueeze(0)
+        gripper_latent = gripper_latent.unsqueeze(0) # (1,4,32,32)
+        gripper_latent2 = gripper_latent2.unsqueeze(0)
+
+        # one sample
+        rgb_obs = {'rgb_static': static_latent, 'rgb_gripper': gripper_latent, 'rgb_gripper2': gripper_latent2}
+        data['rgb_obs'] = rgb_obs
+        data['ann_file'] = ann_file
+        data['frame_ids'] = frame_ids
+
+        return data
+        
+
+if __name__ == "__main__":
+    from hydra import compose, initialize
+    from omegaconf import OmegaConf
+    with initialize(config_path="../../conf", job_name="VPP_xbot_train.yaml"):
+        cfg = compose(config_name="VPP_xbot_train")
+    
+    # import sys
+    # sys.path.append('/cephfs/cjyyj/code/video_robot_svd-main/mdt')
+    # from utils.util import get_args
+    # train_args = get_args(cfg.datamodule.args)
+    # print(train_args)
+    train_dataset = Dataset_xbot(cfg.dataset_args,mode="val")
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=cfg.dataset_args.batch_size,
+        shuffle=cfg.dataset_args.shuffle,
+    )
+    for data in tqdm(train_loader,total=len(train_loader)):
+        print(data['ann_file'])
+        print(len(data['rgb_obs']))
+
+    

code/policy_models/datasets/real_dataset.py

@@ -0,0 +1,287 @@
+# Copyright (2024) Bytedance Ltd. and/or its affiliates
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import random
+import warnings
+import traceback
+import argparse
+from omegaconf import OmegaConf
+from tqdm import tqdm
+from torchvision import transforms as T
+import torch
+from torch.utils.data import Dataset,DataLoader
+import numpy as np
+import imageio
+from decord import VideoReader, cpu
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from einops import rearrange
+
+# from mdt.datasets.utils.dataset_util import euler2rotm, rotm2euler
+# from mdt.datasets.utils.video_transforms import Resize_Preprocess, ToTensorVideo
+# from mdt.datasets.utils.util import update_paths
+from scipy.spatial.transform import Rotation as R  
+import decord
+
+class Dataset_policy(Dataset):
+    def __init__(
+            self,
+            args,
+            mode = 'val',
+            data_json_path = '/localssd/gyj/opensource_robotdata/annotation_all/0407',
+            data_root_path = '/localssd/gyj/opensource_robotdata/',
+    ):
+        """Constructor."""
+        super().__init__()
+        self.args = args
+        self.mode = mode
+
+        # dataset stucture
+        # dataset_dir/dataset_name/annotation_name/mode/traj
+        # dataset_dir/dataset_name/video/mode/traj
+        # dataset_dir/dataset_name/latent_video/mode/traj
+
+        # samles:{'ann_file':xxx, 'frame_idx':xxx, 'dataset_name':xxx}
+
+        # prepare all datasets path
+        self.video_path = []
+        data_json_path = f'{data_json_path}/{mode}_all.json'
+        with open(data_json_path, "r") as f:
+            self.samples = json.load(f)
+        self.video_path = [os.path.join(data_root_path, sample['dataset_name']) for sample in self.samples]
+        
+        print(f"ALL dataset, {len(self.samples)} samples in total")
+
+        self.a_min = np.array(args.action_01)[None,:]
+        self.a_max = np.array(args.action_99)[None,:]
+        self.s_min = np.array(args.state_01)[None,:]
+        self.s_max = np.array(args.state_99)[None,:]
+
+    def __len__(self):
+        return len(self.samples)
+
+    def _load_latent_video(self, video_path, frame_ids):
+        # video_path = video_path.split('/')[:-1]
+        # video_path = '/'.join(video_path)+'/0.pt'
+        
+        # print(video_path)
+        with open(video_path,'rb') as file:
+            video_tensor = torch.load(file)
+            video_tensor.requires_grad = False
+        # vr = VideoReader(video_path, ctx=cpu(0), num_threads=2)
+        # print(video_tensor.size(),np.array(frame_ids))
+        try:
+            assert (np.array(frame_ids) < video_tensor.size()[0]).all()
+            assert (np.array(frame_ids) >= 0).all()
+        except:
+            assert False
+        frame_data = video_tensor[frame_ids]
+        return frame_data
+
+    def _get_frames(self, label, frame_ids, cam_id, pre_encode, video_dir, use_img_cond=False):
+        # directly load videos latent after svd-vae encoder
+        assert cam_id is not None
+        assert pre_encode == True
+        if pre_encode: 
+            video_path = label['latent_videos'][cam_id]['latent_video_path']
+            try:
+                video_path = os.path.join(video_dir,video_path)
+                frames = self._load_latent_video(video_path, frame_ids)
+            except:
+                video_path = video_path.replace("latent_videos", "latent_videos_svd")
+                frames = self._load_latent_video(video_path, frame_ids)
+        # load original videos
+        else: 
+            if use_img_cond:
+                frame_ids = frame_ids[0]
+            video_path = label['videos'][cam_id]['video_path']
+            video_path = os.path.join(video_dir,video_path)
+            # frames = self._load_video(video_path, frame_ids)
+            # frames = mediapy.read_video(video_path)
+            vr = decord.VideoReader(video_path)
+            frames = vr[frame_ids].asnumpy()
+            frames = torch.from_numpy(frames).permute(2,0,1).unsqueeze(0) # (frame, h, w, c) -> (frame, c, h, w)
+            # resize the video to self.args.video_size
+            frames = self.preprocess(frames)
+        return frames
+
+    def _get_obs(self, label, frame_ids, cam_id, pre_encode, video_dir):
+        if cam_id is None:
+            temp_cam_id = random.choice(self.cam_ids)
+        else:
+            temp_cam_id = cam_id
+        frames = self._get_frames(label, frame_ids, cam_id = temp_cam_id, pre_encode = pre_encode, video_dir=video_dir)
+        return frames, temp_cam_id
+
+    def process_action_xhand(self, label,frame_ids, rel = False):
+        num_frames = len(frame_ids)
+        frame_ids = frame_ids[:int(self.args.num_frames+1)] # (10,)
+        states = np.array(label['states'])[frame_ids]
+        command = np.array(label['actions'])[frame_ids]
+
+        state_input = states[0:1] #(1,19)
+        # always use the set the first item of quat >0
+        if state_input[0,3] <0:
+            state_input[0,3:7] *= -1 
+
+        states_raw = states if not self.args.learn_command else command
+
+        if not rel:
+            state_next = states_raw[:-1] # command
+            mu = np.array(self.args.mu)
+            std = np.array(self.args.std)
+
+            state_input = (state_input-mu)/std
+            action_sclaed = (state_next-mu)/std
+
+        else: # relative ro fiest frame
+            xyz, rot, hand = states_raw[:,:3], states_raw[:,3:7], states_raw[:,7:]
+            # xyz
+            current_xyz = state_input[:,:3]
+            delta_xyz = (xyz[:-1]-current_xyz)*self.args.rel_xyz_scale
+            # rot
+            current_quat = state_input[:,3:7]
+            rotm = [R.from_quat(rot[i]).as_matrix() for i in range(len(rot-1))]
+            current_rotm = R.from_quat(current_quat[0]).as_matrix()
+            rel_rotm = [current_rotm.T @ next_rotm for next_rotm in rotm[:-1]]
+            rel_rpy = [R.from_matrix(rot).as_euler('xyz', degrees=False) for rot in rel_rotm]
+
+            rel_rpy = np.array(rel_rpy)*self.args.rel_rot_scale
+            # hand
+            hand = hand[:-1]*self.args.rel_hand_scale
+
+            action_sclaed = np.concatenate([delta_xyz,rel_rpy,hand],axis=1) # (10,18)
+
+            if self.args.norm_input:
+                mu = np.array(self.args.mu)
+                std = np.array(self.args.std)
+                state_input = (state_input-mu)/std
+
+        return torch.from_numpy(action_sclaed).float(), torch.from_numpy(state_input).float()
+
+    def normalize_bound(
+        self,
+        data: np.ndarray,
+        data_min: np.ndarray,
+        data_max: np.ndarray,
+        clip_min: float = -1,
+        clip_max: float = 1,
+        eps: float = 1e-8,
+    ) -> np.ndarray:
+        ndata = 2 * (data - data_min) / (data_max - data_min + eps) - 1
+        return np.clip(ndata, clip_min, clip_max)
+
+    def denormalize_bound(
+        self,
+        data: np.ndarray,
+        data_min: np.ndarray,
+        data_max: np.ndarray,
+        clip_min: float = -1,
+        clip_max: float = 1,
+        eps=1e-8,
+    ) -> np.ndarray:
+        clip_range = clip_max - clip_min
+        rdata = (data - clip_min) / clip_range * (data_max - data_min) + data_min
+        return rdata
+
+    def process_action_xhand_v2(self, label,frame_ids, rel = False):
+        frame_ids = frame_ids[:int(self.args.num_frames)]
+        states = np.array(label['states'])[frame_ids]
+        command = np.array(label['actions'])[frame_ids]
+
+        state_input = states[0:1] #(1,19)
+        # always use the set the first item of quat >0
+        if state_input[0,3] <0:
+            state_input[0,3:7] *= -1 
+
+        states_raw = states if not self.args.learn_command else command
+
+        xyz, rot, hand = states_raw[:,:3], states_raw[:,3:7], states_raw[:,7:]
+        # xyz
+        current_xyz = state_input[:,:3]
+        delta_xyz = (xyz-current_xyz)
+        # rot
+        current_quat = state_input[:,3:7]
+        rotm = [R.from_quat(rot[i]).as_matrix() for i in range(len(rot))]
+        current_rotm = R.from_quat(current_quat[0]).as_matrix()
+        rel_rotm = [current_rotm.T @ next_rotm for next_rotm in rotm]
+        rel_rpy = [R.from_matrix(rot).as_euler('xyz', degrees=False) for rot in rel_rotm]
+        # hand
+        hand = hand
+
+        action = np.concatenate([delta_xyz,rel_rpy,hand],axis=1) # (10,18)
+        state = state_input
+
+        action_scaled = self.normalize_bound(action, self.a_min, self.a_max)
+        state_scaled = self.normalize_bound(state, self.s_min, self.s_max)
+
+        return torch.from_numpy(action_scaled).float(), torch.from_numpy(state_scaled).float() 
+
+    def __getitem__(self, index, cam_id = None, return_video = False):
+
+        sample = self.samples[index]
+        sampled_video_dir = self.video_path[index]
+
+        ann_file = sample['ann_file']
+        # dataset_name = sample['dataset_name']
+        ann_file = f'{sampled_video_dir}/{ann_file}'
+        frame_ids = sample['frame_ids']
+        with open(ann_file, "r") as f:
+            label = json.load(f)
+
+        data = dict()
+        # action
+        if self.args.action_v2:
+            data['actions'], data['state_obs'] = self.process_action_xhand_v2(label,frame_ids,rel=self.args.relative)
+        else:
+            data['actions'], data['state_obs'] = self.process_action_xhand(label,frame_ids,rel=self.args.relative)
+        # instructions
+        data['lang_text'] = label['texts'][0]
+        # observation
+        static_latent, cam_id = self._get_obs(label, frame_ids[0], cam_id=0, pre_encode=self.args.pre_encode,video_dir=sampled_video_dir)
+        gripper_latent, cam_id = self._get_obs(label, frame_ids[0], cam_id=1, pre_encode=self.args.pre_encode,video_dir=sampled_video_dir)
+        static_latent = static_latent.unsqueeze(0)
+        gripper_latent = gripper_latent.unsqueeze(0) # (1,4,32,32)
+
+        # one sample
+        rgb_obs = {'rgb_static': static_latent, 'rgb_gripper': gripper_latent}
+        data['rgb_obs'] = rgb_obs
+        data['ann_file'] = ann_file
+        data['frame_ids'] = frame_ids
+
+        return data
+        
+
+if __name__ == "__main__":
+    from hydra import compose, initialize
+    from omegaconf import OmegaConf
+    with initialize(config_path="../../conf", job_name="VPP_xhand_train.yaml"):
+        cfg = compose(config_name="VPP_xhand_train")
+    
+    # import sys
+    # sys.path.append('/cephfs/cjyyj/code/video_robot_svd-main/mdt')
+    # from utils.util import get_args
+    # train_args = get_args(cfg.datamodule.args)
+    # print(train_args)
+    train_dataset = Dataset_policy(cfg.dataset_args,mode="val")
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=cfg.dataset_args.batch_size,
+        shuffle=cfg.dataset_args.shuffle,
+    )
+    for data in tqdm(train_loader,total=len(train_loader)):
+        print(data['ann_file'])
+
+    

code/policy_models/datasets/shm_dataset.py

@@ -0,0 +1,176 @@
+import logging
+from multiprocessing.shared_memory import SharedMemory
+from typing import Dict, List, Optional
+
+import numpy as np
+
+from policy_models.datasets.base_dataset import BaseDataset
+
+logger = logging.getLogger(__name__)
+
+
+class ShmDataset(BaseDataset):
+    """
+    Dataset that loads episodes from shared memory.
+    """
+
+    def __init__(self, *args, **kwargs):  # type: ignore
+        super().__init__(*args, **kwargs)
+        self.episode_lookup_dict: Dict[str, List] = {}
+        self.episode_lookup: Optional[np.ndarray] = None
+        self.lang_lookup = None
+        self.lang_ann = None
+        self.shapes = None
+        self.sizes = None
+        self.dtypes = None
+        self.dataset_type = None
+        self.shared_memories = None
+
+    def setup_shm_lookup(self, shm_lookup: Dict) -> None:
+        """
+        Initialize episode lookups.
+
+        Args:
+            shm_lookup: Dictionary containing precomputed lookups.
+        """
+        if self.with_lang:
+            self.episode_lookup_dict = shm_lookup["episode_lookup_lang"]
+            self.lang_lookup = shm_lookup["lang_lookup"]
+            self.lang_ann = shm_lookup["lang_ann"]
+        else:
+            self.episode_lookup_dict = shm_lookup["episode_lookup_vision"]
+        key = list(self.episode_lookup_dict.keys())[0]
+        self.episode_lookup = np.array(self.episode_lookup_dict[key])[:, 1]
+        self.shapes = shm_lookup["shapes"]
+        self.sizes = shm_lookup["sizes"]
+        self.dtypes = shm_lookup["dtypes"]
+        self.dataset_type = "train" if "training" in self.abs_datasets_dir.as_posix() else "val"
+        # attach to shared memories
+        self.shared_memories = {
+            key: SharedMemory(name=f"{self.dataset_type}_{key}") for key in self.episode_lookup_dict
+        }
+
+    def _load_episode(self, idx: int, window_size: int) -> Dict[str, np.ndarray]:
+        """
+        Load consecutive frames from shared memory and combine to episode dict.
+
+        Args:
+            idx: Index of first frame.
+            window_size: Length of sampled episode.
+
+        Returns:
+            episode: Dict of numpy arrays containing the episode where keys are the names of modalities.
+        """
+        episode = {}
+        for key, lookup in self.episode_lookup_dict.items():
+            offset, j = lookup[idx]
+            shape = (window_size + j,) + self.shapes[key]
+            array = np.ndarray(shape, dtype=self.dtypes[key], buffer=self.shared_memories[key].buf, offset=offset)[j:]  # type: ignore
+            episode[key] = array
+        if self.with_lang:
+            episode["language"] = self.lang_ann[self.lang_lookup[idx]][0]  # TODO check  [0]
+        return episode
+
+
+
+class BesoSHmDataset(BaseDataset):
+    
+    def __init__(
+        self, 
+        obs_seq_len: int,
+        action_seq_len: int,
+        future_range: int,
+        *args, 
+        **kwargs):  # type: ignore
+        super().__init__(*args, **kwargs)
+        self.episode_lookup_dict: Dict[str, List] = {}
+        self.episode_lookup: Optional[np.ndarray] = None
+        self.lang_lookup = None
+        self.lang_ann = None
+        self.shapes = None
+        self.sizes = None
+        self.dtypes = None
+        self.dataset_type = None
+        self.shared_memories = None
+        
+        # new stuff for our dataset
+        self.obs_seq_len = obs_seq_len
+        self.action_seq_len = action_seq_len
+        self.future_range = future_range
+
+    def setup_shm_lookup(self, shm_lookup: Dict) -> None:
+        """
+        Initialize episode lookups.
+
+        Args:
+            shm_lookup: Dictionary containing precomputed lookups.
+        """
+        if self.with_lang:
+            self.episode_lookup_dict = shm_lookup["episode_lookup_lang"]
+            self.lang_lookup = shm_lookup["lang_lookup"]
+            self.lang_ann = shm_lookup["lang_ann"]
+        else:
+            self.episode_lookup_dict = shm_lookup["episode_lookup_vision"]
+        key = list(self.episode_lookup_dict.keys())[0]
+        self.episode_lookup = np.array(self.episode_lookup_dict[key])[:, 1]
+        self.shapes = shm_lookup["shapes"]
+        self.sizes = shm_lookup["sizes"]
+        self.dtypes = shm_lookup["dtypes"]
+        self.dataset_type = "train" if "training" in self.abs_datasets_dir.as_posix() else "val"
+        # attach to shared memories
+        self.shared_memories = {
+            key: SharedMemory(name=f"{self.dataset_type}_{key}") for key in self.episode_lookup_dict
+        }
+
+    def _load_episode(self, idx: int, window_size: int) -> Dict[str, np.ndarray]:
+        episode = {}
+        keys = list(chain(*self.observation_space.values()))
+        keys.remove("language")
+        keys.append("scene_obs")
+        
+        # Load main episode data from shared memory
+        for key, lookup in self.episode_lookup_dict.items():
+            offset, j = lookup[idx]
+            shape = (window_size + j,) + self.shapes[key]
+            array = np.ndarray(shape, dtype=self.dtypes[key], buffer=self.shared_memories[key].buf, offset=offset)[j:]
+            
+            # Slice the data to match action_seq_len and obs_seq_len
+            if key == "rel_actions" or key == 'actions':
+                episode[key] = array[:self.action_seq_len, :]
+            else:
+                episode[key] = array[:self.obs_seq_len, :]
+
+        if self.with_lang:
+            episode["language"] = self.lang_ann[self.lang_lookup[idx]][0]  # TODO check  [0]
+        
+        # Logic for future goal
+        delta = np.random.randint(self.future_range)
+        goal_idx = self.episode_lookup[idx] + self.action_seq_len + delta
+        eps_start_idx, eps_end_idx = self.find_sequence_boundaries(goal_idx)
+        if eps_end_idx < goal_idx:
+            goal_idx = eps_end_idx
+        
+        # Load future goal from shared memory
+        offset, j = self.episode_lookup_dict['scene_obs'][goal_idx]  # Assuming 'scene_obs' is the key for goals
+        shape = (1,) + self.shapes['scene_obs']
+        goal_array = np.ndarray(shape, dtype=self.dtypes['scene_obs'], buffer=self.shared_memories['scene_obs'].buf, offset=offset)[j:]
+        
+        goal_episode = {'scene_obs': goal_array[:self.obs_seq_len, :]}
+        
+        # Merge episodes
+        episode = self.merge_episodes(episode, goal_episode)
+        
+        return episode
+
+    def merge_episodes(self, episode1: Dict[str, np.ndarray], episode2: Dict[str, np.ndarray]) -> Dict[str, np.ndarray]:
+        merged_episode = {}
+        all_keys = set(episode1.keys()).union(set(episode2.keys()))
+        for key in all_keys:
+            if key in episode1 and key in episode2:
+                # Merge logic here, for example:
+                merged_episode[key] = np.concatenate([episode1[key], episode2[key]], axis=0)
+            elif key in episode1:
+                merged_episode[key] = episode1[key]
+            else:
+                merged_episode[key] = episode2[key]
+        return merged_episode

code/policy_models/datasets/utils/episode_utils.py

@@ -0,0 +1,237 @@
+import logging
+import os
+from pathlib import Path
+import re
+from typing import Dict, Tuple
+
+import numpy as np
+from omegaconf import DictConfig, ListConfig, OmegaConf
+import torch
+
+logger = logging.getLogger(__name__)
+
+
+def process_state(
+    episode: Dict[str, np.ndarray],
+    observation_space: DictConfig,
+    transforms: Dict,
+    proprio_state: DictConfig,
+    seq_idx: int = 0,
+    window_size: int = 0,
+) -> Dict[str, torch.Tensor]:
+    state_obs_keys = observation_space["state_obs"]
+    state_obs_list_normalized = []
+    state_obs_list_unnormalized = []
+    for state_ob in state_obs_keys:
+        if window_size == 0 and seq_idx == 0:  # single file loader
+            state_tensor = torch.from_numpy(episode[state_ob]).float()
+        else:  # episode loader
+            state_tensor = torch.from_numpy(episode[state_ob][seq_idx : seq_idx + window_size]).float()
+        # expand dims for single environment obs
+        if len(state_tensor.shape) != 2:
+            state_tensor = state_tensor.unsqueeze(0)
+        # shape: (BxN_state_obs)
+        assert len(state_tensor.shape) == 2
+        if state_ob in transforms:
+            state_tensor_normalized = transforms[state_ob](state_tensor)
+            state_obs_list_normalized.append(state_tensor_normalized)
+        else:
+            state_obs_list_normalized.append(state_tensor)
+        state_obs_list_unnormalized.append(state_tensor)
+    seq_state_obs = torch.cat(state_obs_list_normalized, dim=1)
+    seq_state_obs_unnormalized = torch.cat(state_obs_list_unnormalized, dim=1)
+
+    if not proprio_state.normalize_robot_orientation and "robot_orientation_idx" in proprio_state:
+        seq_state_obs[:, slice(*proprio_state.robot_orientation_idx)] = seq_state_obs_unnormalized[
+            :, slice(*proprio_state.robot_orientation_idx)
+        ]
+
+    if not proprio_state.normalize:
+        seq_state_obs = seq_state_obs_unnormalized
+
+    # slice the specified parts of the proprioception state
+    state_obs_sliced = []
+    for slice_ids in proprio_state.keep_indices:
+        seq_state_obs_ = seq_state_obs[:, slice(*slice_ids)]
+        state_obs_sliced.append(seq_state_obs_)
+    seq_state_obs = torch.cat(state_obs_sliced, dim=1)
+
+    return {"robot_obs": seq_state_obs}
+
+
+def process_rgb(
+    episode: Dict[str, np.ndarray],
+    observation_space: DictConfig,
+    transforms: Dict,
+    seq_idx: int = 0,
+    window_size: int = 0,
+) -> Dict[str, Dict[str, torch.Tensor]]:
+    rgb_obs_keys = observation_space["rgb_obs"]
+    seq_rgb_obs_dict = {}
+    for _, rgb_obs_key in enumerate(rgb_obs_keys):
+        if rgb_obs_key not in episode:
+            # If the key is not found, skip to the next iteration
+            continue
+        rgb_obs = episode[rgb_obs_key]
+        # expand dims for single environment obs
+        if len(rgb_obs.shape) != 4:
+            rgb_obs = np.expand_dims(rgb_obs, axis=0)
+        assert len(rgb_obs.shape) == 4
+        if window_size == 0 and seq_idx == 0:  # single file loader
+            # To Square image
+            seq_rgb_obs_ = torch.from_numpy(rgb_obs).byte().permute(0, 3, 1, 2)
+        else:  # episode loader
+            seq_rgb_obs_ = torch.from_numpy(rgb_obs[seq_idx : seq_idx + window_size]).byte().permute(0, 3, 1, 2)
+        # we might have different transformations for the different cameras
+        if rgb_obs_key in transforms:
+            seq_rgb_obs_ = transforms[rgb_obs_key](seq_rgb_obs_)
+        seq_rgb_obs_dict[rgb_obs_key] = seq_rgb_obs_
+    # shape: N_rgb_obs x (BxCxHxW)
+    return {"rgb_obs": seq_rgb_obs_dict}
+
+
+
+def process_depth(
+    episode: Dict[str, np.ndarray],
+    observation_space: DictConfig,
+    transforms: Dict,
+    seq_idx: int = 0,
+    window_size: int = 0,
+) -> Dict[str, Dict[str, torch.Tensor]]:
+    # expand dims for single environment obs
+    def exp_dim(depth_img):
+        if len(depth_img.shape) != 3:
+            depth_img = np.expand_dims(depth_img, axis=0)
+        return depth_img
+
+    depth_obs_keys = observation_space["depth_obs"]
+    seq_depth_obs_dict = {}
+    for _, depth_obs_key in enumerate(depth_obs_keys):
+        depth_ob = exp_dim(episode[depth_obs_key])
+        assert len(depth_ob.shape) == 3
+        if window_size == 0 and seq_idx == 0:  # single file loader
+            depth_ob_ = torch.from_numpy(depth_ob).float()
+        else:  # episode loader
+            depth_ob_ = torch.from_numpy(depth_ob[seq_idx : seq_idx + window_size]).float()
+        # we might have different transformations for the different cameras
+        if depth_obs_key in transforms:
+            depth_ob_ = transforms[depth_obs_key](depth_ob_)
+        seq_depth_obs_dict[depth_obs_key] = depth_ob_
+    # shape: N_depth_obs x(BxHxW)
+    return {"depth_obs": seq_depth_obs_dict}
+
+
+def process_actions(
+    episode: Dict[str, np.ndarray],
+    observation_space: DictConfig,
+    transforms: Dict,
+    seq_idx: int = 0,
+    window_size: int = 0,
+) -> Dict[str, torch.Tensor]:
+    # shape: (N_actions)
+    action_keys = observation_space["actions"]
+    if len(action_keys) != 1:
+        raise NotImplementedError
+    action_key = action_keys[0]
+    if window_size == 0 and seq_idx == 0:  # single file loader
+        action = episode[action_key]
+        if "actions" in transforms:
+            action = transforms["actions"]((action, episode["robot_obs"]))
+        seq_acts = torch.from_numpy(action).float()
+    else:  # episode loader
+        seq_acts = torch.from_numpy(episode[action_key][seq_idx : seq_idx + window_size]).float()
+    return {"actions": seq_acts}
+
+
+def process_language(episode: Dict[str, np.ndarray], transforms: Dict, with_lang: bool) -> Dict[str, torch.Tensor]:
+    seq_lang = {"lang": torch.empty(0)}
+    if with_lang:
+        lang = torch.from_numpy(episode["language"]).float()
+        if "language" in transforms:
+            lang = transforms["language"](lang)
+        seq_lang["lang"] = lang
+        seq_lang['lang_text']  = episode['language_text']
+    return seq_lang
+
+
+def get_state_info_dict(episode: Dict[str, np.ndarray]) -> Dict[str, Dict[str, torch.Tensor]]:
+    """
+    Create a dictionary with raw state observations for environment resets.
+
+    Args:
+        episode: Sequence dictionary.
+
+    Returns:
+         Info dict of full robot and scene state (for env resets).
+    """
+    return {
+        "state_info": {
+            "robot_obs": torch.from_numpy(episode["robot_obs"]),
+            "scene_obs": torch.from_numpy(episode["scene_obs"]),
+        }
+    }
+
+
+def load_dataset_statistics(train_dataset_dir, val_dataset_dir, transforms):
+    """
+    Tries to load statistics.yaml in every dataset folder in order to update the transforms hardcoded in the
+    hydra config file. If no statistics.yaml exists, nothing is changed
+
+    Args:
+        train_dataset_dir: path of the training folder
+        val_dataset_dir: path of the validation folder
+        transforms: transforms loaded from hydra conf
+
+    Returns:
+        transforms: potentially updated transforms
+    """
+    paths = {"train": train_dataset_dir, "val": val_dataset_dir}
+    for dataset_type in ["train", "val"]:
+        try:
+            statistics = OmegaConf.load(Path(paths[dataset_type]) / "statistics.yaml")
+            # Hack for maintaining two repositories with transforms
+            statistics = OmegaConf.create(OmegaConf.to_yaml(statistics).replace("calvin_agent", "policy_models"))
+            # this ugly piece of code only exists because OmegaConf actually can't merge ListConfigs.
+            # we do not want to override everything, but just the transforms that are specified in both
+            # see https://stackoverflow.com/questions/61315623/omegaconf-can-i-influence-how-lists-are-merged
+            for modality in transforms[dataset_type]:
+                if modality in statistics:
+                    conf_transforms = transforms[dataset_type][modality]
+                    dataset_transforms = statistics[modality]
+                    for dataset_trans in dataset_transforms:
+                        exists = False
+                        for i, conf_trans in enumerate(conf_transforms):
+                            if dataset_trans["_target_"] == conf_trans["_target_"]:
+                                exists = True
+                                transforms[dataset_type][modality][i] = dataset_trans
+                                break
+                        if not exists:
+                            transforms[dataset_type][modality] = ListConfig([*conf_transforms, dataset_trans])
+        except FileNotFoundError:
+            logger.warning("Could not load statistics.yaml")
+    return transforms
+
+
+def lookup_naming_pattern(dataset_dir: Path, save_format: str) -> Tuple[Tuple[Path, str], int]:
+    """
+    Check naming pattern of dataset files.
+
+    Args:
+        dataset_dir: Path to dataset.
+        save_format: File format (CALVIN default is npz).
+
+    Returns:
+        naming_pattern: 'file_0000001.npz' -> ('file_', '.npz')
+        n_digits: Zero padding of file enumeration.
+    """
+    it = os.scandir(dataset_dir)
+    while True:
+        filename = Path(next(it))
+        if save_format in filename.suffix:
+            break
+    aux_naming_pattern = re.split(r"\d+", filename.stem)
+    naming_pattern = (filename.parent / aux_naming_pattern[0], filename.suffix)
+    n_digits = len(re.findall(r"\d+", filename.stem)[0])
+    assert len(naming_pattern) == 2
+    assert n_digits > 0
+    return naming_pattern, n_digits

code/policy_models/datasets/utils/shared_memory_utils.py

@@ -0,0 +1,336 @@
+from collections import defaultdict
+from functools import partial
+from itertools import chain
+import logging
+import multiprocessing
+from multiprocessing.shared_memory import SharedMemory
+import os
+from pathlib import Path
+import signal
+from typing import Dict, Optional, Tuple
+
+import numpy as np
+from omegaconf import DictConfig
+from pytorch_lightning import Callback, LightningModule, Trainer
+from tqdm import tqdm
+
+from policy_models.datasets.shm_dataset import ShmDataset
+from policy_models.datasets.utils.episode_utils import lookup_naming_pattern
+
+log = logging.getLogger(__name__)
+
+
+def gather_results(return_dict: Dict) -> Tuple[Dict, Dict]:
+    """
+    Combine results of worker processes.
+
+    Args:
+        return_dict: Dictionary with results of worker processes.
+
+    Returns:
+        episode_lookup_vision: Combined results of vision lookup.
+        lang_episode_dict: Combined results of lanugage lookup.
+    """
+    episode_lookup_vision: Dict = defaultdict(list)
+    lang_episode_dict: Dict = defaultdict(dict)
+    for proc in sorted(return_dict):
+        for key in return_dict[proc][0]:
+            episode_lookup_vision[key] += return_dict[proc][0][key]
+            lang_episode_dict[key].update(return_dict[proc][1][key])
+    return episode_lookup_vision, lang_episode_dict
+
+
+def check_shm_lookup_exists(dataset_type: str) -> Optional[Dict]:
+    """
+    Check if there is already a shared memory lookup file saved on the disk.
+
+    Args:
+        dataset_type: 'train' or 'val'.
+
+    Returns:
+        Lookup file if exists, None otherwise.
+    """
+    load_path = Path("/tmp/") if "TMPDIR" not in os.environ else Path(os.environ["TMPDIR"])
+    try:
+        data: Dict = np.load(load_path / f"{dataset_type}_shm_lookup.npy", allow_pickle=True).item()
+        return data
+    except FileNotFoundError:
+        return None
+
+
+def save_shm_lookup(train_shm_lookup: Dict, val_shm_lookup: Dict) -> None:
+    """
+    Save shared memory lookups to disk, such that they can be reused by ddp subprocesses.
+
+    Args:
+        train_shm_lookup: Shared memory lookup for training data.
+        val_shm_lookup: Shared memory lookup for validation data.
+    """
+    save_path = Path("/tmp/") if "TMPDIR" not in os.environ else Path(os.environ["TMPDIR"])
+    np.save(save_path / "train_shm_lookup.npy", train_shm_lookup)  # type: ignore
+    np.save(save_path / "val_shm_lookup.npy", val_shm_lookup)  # type: ignore
+
+
+def load_shm_lookup() -> Tuple[Dict, Dict]:
+    """
+    Load shared memory lookup.
+
+    Returns:
+        train_shm_lookup: Shared memory lookup for training data.
+        val_shm_lookup: Shared memory lookup for validation data.
+    """
+    load_path = Path("/tmp/") if "TMPDIR" not in os.environ else Path(os.environ["TMPDIR"])
+    train_shm_lookup: Dict = np.load(load_path / "train_shm_lookup.npy", allow_pickle=True).item()
+    val_shm_lookup: Dict = np.load(load_path / "val_shm_lookup.npy", allow_pickle=True).item()
+    return train_shm_lookup, val_shm_lookup
+
+
+class SharedMemoryLoader:
+    """
+    Helper class for loading dataset into shared memory.
+
+    Args:
+         datasets_cfg: Hydra config of datasets.
+         dataset_dir: Path to dataset.
+    """
+
+    def __init__(self, datasets_cfg: DictConfig, dataset_dir: Path):
+        self.obs_space = datasets_cfg.lang_dataset.obs_space if "lang" in datasets_cfg else datasets_cfg.vision_dataset.obs_space
+        self.dataset_dir = dataset_dir
+        self.dataset_type = "train" if "training" in dataset_dir.as_posix() else "val"
+        self.lang_folder = datasets_cfg.lang_dataset.lang_folder if "lang" in datasets_cfg else datasets_cfg.vision_dataset.lang_folder # lang_folder: "lang_paraphrase-MiniLM-L3-v2"
+        self.naming_pattern, self.n_digits = lookup_naming_pattern(self.dataset_dir, "npz")
+        self.min_window_size_vision = datasets_cfg.vision_dataset.min_window_size
+        self.min_window_size_lang = datasets_cfg.lang_dataset.min_window_size if "lang" in datasets_cfg else datasets_cfg.vision_dataset.min_window_size
+        self.n_proc = 8
+
+    def _worker_process(self, proc_num, ep_start_end_ids, offsets, shmem, lang_ep_start_end_ids, return_dict):
+        """
+        Multiprocessing worker to speed up the loading of the data into shared memory.
+
+        Args:
+            proc_num: Process number.
+            ep_start_end_ids: Episode start and end indices for this worker.
+            offsets: Offset for addressing right portion of shared array.
+            shmem: Shared memory handles.
+            lang_ep_start_end_ids: Episode start and end indices of language data for this worker.
+            return_dict: Dictionary for saving the results.
+        """
+        episode_lookup_vision = defaultdict(list)
+        lang_episode_dict = defaultdict(dict)
+        if proc_num == 0:
+            pbar = tqdm(total=np.sum(np.diff(ep_start_end_ids)), leave=False)
+        else:
+            pbar = None
+        for i, (start_idx, end_idx) in enumerate(ep_start_end_ids):
+            seq = self._zip_sequence(start_idx, end_idx, pbar)
+            for key, array in seq.items():
+                shared_array = np.ndarray(array.shape, dtype=array.dtype, buffer=shmem[key].buf, offset=offsets[key])
+                shared_array[:] = array[:]
+
+                for j, idx in enumerate(range(start_idx, end_idx + 1 - self.min_window_size_vision)):
+                    episode_lookup_vision[key].append((offsets[key], j))
+                    if idx in lang_ep_start_end_ids[:, 0]:
+                        lang_episode_dict[key][idx] = (offsets[key], j)
+                offsets[key] += array.nbytes
+        return_dict[proc_num] = episode_lookup_vision, lang_episode_dict
+        if pbar is not None:
+            pbar.close()
+
+    def load_data_in_shared_memory(self):
+        """
+        Load the dataset from disk into shared memory once at the beginning of the training to speed up data loading.
+
+        Returns:
+            Shared memory lookup dict.
+        """
+        lang_data = np.load(self.dataset_dir / self.lang_folder / "auto_lang_ann.npy", allow_pickle=True).item() if self.lang_folder is not None else None
+        ep_start_end_ids = np.load(self.dataset_dir / "ep_start_end_ids.npy")
+        lang_ep_start_end_ids = np.array(lang_data["info"]["indx"]) if self.lang_folder is not None else None #np.array(vision_data["info"]["indx"])
+        lang_ann = lang_data["language"]["emb"] if self.lang_folder is not None else None
+        shmem, shapes, sizes, dtypes, shmem_lookup = self._init_shmem(ep_start_end_ids)
+
+        if shmem_lookup is not None:
+            pass
+            # using existing shared memory
+            # log.info("Using existing shared memory without reloading it.")
+            # return shmem_lookup
+
+        lang_lookup = []
+
+        episode_lookup_lang = defaultdict(list)
+        log.info(
+            f"Loading {self.dataset_type} language episodes into shared memory. "
+            f"(progress bar shows only worker process 0)."
+        )
+
+        if self.n_proc > len(ep_start_end_ids):
+            self.n_proc = len(ep_start_end_ids)
+        split_indices = np.array_split(ep_start_end_ids, self.n_proc, axis=0)
+        split_lens = [np.sum(np.diff(split_indices[i])) for i in range(len(split_indices))]
+        obs_size = {key: dtypes[key].itemsize * np.prod(shapes[key]) for key in dtypes}
+        offsets = [{key: n * obs_size[key] for key in dtypes} for n in np.cumsum([0] + split_lens[:-1])]
+
+        manager = multiprocessing.Manager()
+        return_dict = manager.dict()
+        processes = []
+        # load vision data with multiple processes
+        for i in range(self.n_proc):
+            p = multiprocessing.Process(
+                target=self._worker_process,
+                args=(i, split_indices[i], offsets[i], shmem, lang_ep_start_end_ids, return_dict),
+            )
+            processes.append(p)
+            p.start()
+        for proc in processes:
+            proc.join()
+
+        episode_lookup_vision, lang_episode_dict = gather_results(return_dict)
+
+        # lang data
+        if lang_ep_start_end_ids is not None:
+            for i, (start_idx, end_idx) in enumerate(tqdm(lang_ep_start_end_ids)):
+                for key in lang_episode_dict:
+                    offset, step = lang_episode_dict[key][start_idx]
+                    for j, idx in enumerate(range(start_idx, end_idx + 1 - self.min_window_size_lang)):
+                        episode_lookup_lang[key].append((offset, step + j))
+                for idx in range(start_idx, end_idx + 1 - self.min_window_size_lang):
+                    lang_lookup.append(i)
+        result = {
+            "episode_lookup_vision": episode_lookup_vision,
+            "episode_lookup_lang": episode_lookup_lang,
+            "lang_lookup": lang_lookup,
+            "lang_ann": lang_ann,
+            "shapes": shapes,
+            "sizes": sizes,
+            "dtypes": dtypes,
+        }
+        return result
+
+    def _init_shmem(self, ep_start_end_ids: np.ndarray) -> Tuple[Dict, Dict, Dict, Dict, Optional[Dict]]:
+        """
+        Initialize shared memory.
+
+        Args:
+            ep_start_end_ids: Episode start and end indices of dataset.
+
+        Returns:
+            shmem: Dictionary with shared memory handles for each dataset key (rgb_static, etc ...).
+            shapes: Dictionary with the shape of one datapoint for each dataset key.
+            sizes: Dictionary with the memory size of one datapoint for each dataset key.
+            dtypes: Dictionary with the dtype of data for each dataset key.
+            shm_lookup: If shared memory lookup dict already exists, return it here.
+        """
+        # load first episode to determine memory usage
+        seq = self._zip_sequence(ep_start_end_ids[0][0], ep_start_end_ids[0][0] + 1)
+        total_size = np.sum(ep_start_end_ids[:, 1] - ep_start_end_ids[:, 0])
+        shmem: Dict[str, SharedMemory] = {}
+        shapes: Dict[str, Tuple] = {}
+        sizes: Dict[str, int] = {}
+        dtypes: Dict[str, str] = {}
+
+        shm_lookup = check_shm_lookup_exists(self.dataset_type)
+        # check if all necessary shared memories are already loaded
+        if shm_lookup is not None:
+            print("shm_lookup exists")
+            try:
+                if np.all(
+                    [
+                        SharedMemory(name=f"{self.dataset_type}_{key}").size == size * total_size
+                        for key, size in shm_lookup["sizes"].items()
+                    ]
+                ):
+                    return shmem, shapes, sizes, dtypes, shm_lookup
+            except FileNotFoundError as e:
+                pass
+        for key, array in seq.items():
+            try:
+                # see if exists
+                s = SharedMemory(name=f"{self.dataset_type}_{key}")
+                s.close()
+                s.unlink()
+                log.warning(
+                    f"Found existing shared memory {self.dataset_type}_{key}, freeing up memory."
+                    "In case of multiple training runs on the same node, this will lead to problems."
+                )
+            except FileNotFoundError:
+                pass
+            shmem[key] = SharedMemory(create=True, size=array.nbytes * total_size, name=f"{self.dataset_type}_{key}")
+            shapes[key] = array.shape[1:]
+            sizes[key] = array.nbytes
+            dtypes[key] = array.dtype
+
+        # register signal handler for the case that shm data loading process gets interrupted.
+        signal.signal(signal.SIGTERM, partial(delete_shm, shmem.keys()))
+
+        return shmem, shapes, sizes, dtypes, None
+
+    def _zip_sequence(self, start_idx, end_idx, pbar=None):
+        """
+        Load consecutive frames saved as individual files on disk and combine to episode dict.
+
+        Args:
+            start_idx: Start index of file.
+            end_idx: End index of file.
+            pbar: Tqdm progress bar.
+
+        Returns:
+            Episode dict.
+        """
+        keys = list(chain(*self.obs_space.values()))
+        keys.remove("language")
+        keys.append("scene_obs")
+        n_items = end_idx - start_idx
+        episode = {}
+        data = np.load(self._get_episode_name(start_idx))
+        for key in keys:
+            shape = (n_items,) + data[key].shape
+            dtype = data[key].dtype
+            episode[key] = np.empty(shape=shape, dtype=dtype)
+        for i, file_idx in enumerate(range(start_idx, end_idx)):
+            with np.load(self._get_episode_name(file_idx)) as data:
+                for key in keys:
+                    episode[key][i] = data[key]
+            if pbar is not None:
+                pbar.update(1)
+        return episode
+
+    def _get_episode_name(self, file_idx):
+        """
+        Convert file idx to file path.
+
+        Args:
+            file_idx: index of starting frame.
+
+        Returns:
+            Path to file.
+        """
+        return Path(f"{self.naming_pattern[0]}{file_idx:0{self.n_digits}d}{self.naming_pattern[1]}")
+
+
+def delete_shm(shm_keys, signal, frame):
+    """
+    Close and unlink the shared memories.
+    """
+    for dataset_type in ["train", "val"]:
+        for shm_key in shm_keys:
+            try:
+                s = SharedMemory(name=f"{dataset_type}_{shm_key}")
+                s.close()
+                s.unlink()
+                print(f"successfully unlinked {shm_key}")
+            except Exception as e:
+                print(e)
+    exit()
+
+
+class SignalCallback(Callback):
+    """
+    Register a signal handler for closing and unlinking the shared memory that get's activated with a SIGTERM signal.
+    """
+
+    def on_fit_start(self, trainer: Trainer, pl_module: LightningModule) -> None:
+        if isinstance(trainer.datamodule.train_dataloader()["vis"].dataset, ShmDataset):  # type: ignore
+            shm_keys = trainer.datamodule.train_dataloader()["vis"].dataset.episode_lookup_dict.keys()  # type: ignore
+            signal.signal(signal.SIGTERM, partial(delete_shm, shm_keys))
+            print("Registered shared memory signal handler.")

code/policy_models/datasets/xbot_dataset.py

@@ -0,0 +1,230 @@
+# Copyright (2024) Bytedance Ltd. and/or its affiliates
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import random
+import warnings
+import traceback
+import argparse
+from omegaconf import OmegaConf
+from tqdm import tqdm
+from torchvision import transforms as T
+import torch
+from torch.utils.data import Dataset,DataLoader
+import numpy as np
+import imageio
+from decord import VideoReader, cpu
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from einops import rearrange
+
+# from mdt.datasets.utils.dataset_util import euler2rotm, rotm2euler
+# from mdt.datasets.utils.video_transforms import Resize_Preprocess, ToTensorVideo
+# from mdt.datasets.utils.util import update_paths
+from scipy.spatial.transform import Rotation as R  
+import decord
+
+class Dataset_xbot(Dataset):
+    def __init__(
+            self,
+            args,
+            mode = 'val',
+    ):
+        """Constructor."""
+        super().__init__()
+        self.args = args
+        self.mode = mode
+        data_json_path = args.data_json_path
+        data_root_path = args.data_root_path
+
+        # dataset stucture
+        # dataset_dir/dataset_name/annotation_name/mode/traj
+        # dataset_dir/dataset_name/video/mode/traj
+        # dataset_dir/dataset_name/latent_video/mode/traj
+
+        # samles:{'ann_file':xxx, 'frame_idx':xxx, 'dataset_name':xxx}
+
+        # prepare all datasets path
+        self.video_path = []
+        data_json_path = f'{data_json_path}/{mode}_all.json'
+        with open(data_json_path, "r") as f:
+            self.samples = json.load(f)
+        self.video_path = [os.path.join(data_root_path, sample['dataset_name']) for sample in self.samples]
+        
+        print(f"ALL dataset, {len(self.samples)} samples in total")
+
+        # with open(f'{self.args.action_json}', "r") as f:
+        # self.stat = json.load(f)
+        self.a_min = np.array(args.action_01)[None,:]
+        self.a_max = np.array(args.action_99)[None,:]
+        self.s_min = np.array(args.state_01)[None,:]
+        self.s_max = np.array(args.state_99)[None,:]
+        print(f"action min: {self.a_min.shape}, action max: {self.a_max.shape}")
+
+    def __len__(self):
+        return len(self.samples)
+
+    def _load_latent_video(self, video_path, frame_ids):
+        # video_path = video_path.split('/')[:-1]
+        # video_path = '/'.join(video_path)+'/0.pt'
+        
+        # print(video_path)
+        with open(video_path,'rb') as file:
+            video_tensor = torch.load(file)
+            video_tensor.requires_grad = False
+        # vr = VideoReader(video_path, ctx=cpu(0), num_threads=2)
+        # print(video_tensor.size(),np.array(frame_ids))
+        try:
+            assert (np.array(frame_ids) < video_tensor.size()[0]).all()
+            assert (np.array(frame_ids) >= 0).all()
+        except:
+            assert False
+        frame_data = video_tensor[frame_ids]
+        return frame_data
+
+    def _get_frames(self, label, frame_ids, cam_id, pre_encode, video_dir, use_img_cond=False):
+        # directly load videos latent after svd-vae encoder
+        assert cam_id is not None
+        assert pre_encode == True
+        if pre_encode: 
+            video_path = label['latent_videos'][cam_id]['latent_video_path']
+            try:
+                video_path = os.path.join(video_dir,video_path)
+                frames = self._load_latent_video(video_path, frame_ids)
+            except:
+                video_path = video_path.replace("latent_videos", "latent_videos_svd")
+                frames = self._load_latent_video(video_path, frame_ids)
+        # load original videos
+        else: 
+            if use_img_cond:
+                frame_ids = frame_ids[0]
+            video_path = label['videos'][cam_id]['video_path']
+            video_path = os.path.join(video_dir,video_path)
+            # frames = self._load_video(video_path, frame_ids)
+            # frames = mediapy.read_video(video_path)
+            vr = decord.VideoReader(video_path)
+            frames = vr[frame_ids].asnumpy()
+            frames = torch.from_numpy(frames).permute(2,0,1).unsqueeze(0) # (frame, h, w, c) -> (frame, c, h, w)
+            # resize the video to self.args.video_size
+            frames = self.preprocess(frames)
+        return frames
+
+    def _get_obs(self, label, frame_ids, cam_id, pre_encode, video_dir):
+        if cam_id is None:
+            temp_cam_id = random.choice(self.cam_ids)
+        else:
+            temp_cam_id = cam_id
+        frames = self._get_frames(label, frame_ids, cam_id = temp_cam_id, pre_encode = pre_encode, video_dir=video_dir)
+        return frames, temp_cam_id
+
+    def normalize_bound(
+        self,
+        data: np.ndarray,
+        data_min: np.ndarray,
+        data_max: np.ndarray,
+        clip_min: float = -1,
+        clip_max: float = 1,
+        eps: float = 1e-8,
+    ) -> np.ndarray:
+        ndata = 2 * (data - data_min) / (data_max - data_min + eps) - 1
+        return np.clip(ndata, clip_min, clip_max)
+
+    def denormalize_bound(
+        self,
+        data: np.ndarray,
+        data_min: np.ndarray,
+        data_max: np.ndarray,
+        clip_min: float = -1,
+        clip_max: float = 1,
+        eps=1e-8,
+    ) -> np.ndarray:
+        clip_range = clip_max - clip_min
+        rdata = (data - clip_min) / clip_range * (data_max - data_min) + data_min
+        return rdata
+
+    def process_action_xhand(self, label,frame_ids, rel = False):
+        num_frames = len(frame_ids)
+        frame_ids = frame_ids[:int(self.args.num_frames)] # (f)
+        states = np.array(label['states'])[frame_ids] #(f, 38)
+        command = np.array(label['actions'])[frame_ids]
+
+        # print(f'states: {states.shape}, actions: {command.shape}')
+
+        state = states[0:1] # current state
+
+        a_dim = command.shape[-1]
+        action_base = state[:,:a_dim] #(1,38)
+        actions = command - action_base #(self.args.num_frames,38)
+
+        # normalize
+        action_scaled = self.normalize_bound(actions, self.a_min, self.a_max)
+        state_scaled = self.normalize_bound(state, self.s_min, self.s_max)
+        return torch.from_numpy(action_scaled).float(), torch.from_numpy(state_scaled).float()
+
+    def __getitem__(self, index, cam_id = None, return_video = False):
+
+        sample = self.samples[index]
+        sampled_video_dir = self.video_path[index]
+
+        ann_file = sample['ann_file']
+        # dataset_name = sample['dataset_name']
+        ann_file = f'{sampled_video_dir}/{ann_file}'
+        frame_ids = sample['frame_ids']
+        with open(ann_file, "r") as f:
+            label = json.load(f)
+
+        data = dict()
+        # action
+        data['actions'], data['state_obs'] = self.process_action_xhand(label,frame_ids,rel=self.args.relative)
+        # instructions
+        data['lang_text'] = label['texts'][0]
+        # observation
+        static_latent, cam_id = self._get_obs(label, frame_ids[0], cam_id=0, pre_encode=self.args.pre_encode,video_dir=sampled_video_dir)
+        gripper_latent, cam_id = self._get_obs(label, frame_ids[0], cam_id=1, pre_encode=self.args.pre_encode,video_dir=sampled_video_dir)
+        gripper_latent2, cam_id = self._get_obs(label, frame_ids[0], cam_id=2, pre_encode=self.args.pre_encode,video_dir=sampled_video_dir)
+        static_latent = static_latent.unsqueeze(0)
+        gripper_latent = gripper_latent.unsqueeze(0) # (1,4,32,32)
+        gripper_latent2 = gripper_latent2.unsqueeze(0)
+
+        # one sample
+        rgb_obs = {'rgb_static': static_latent, 'rgb_gripper': gripper_latent, 'rgb_gripper2': gripper_latent2}
+        data['rgb_obs'] = rgb_obs
+        data['ann_file'] = ann_file
+        data['frame_ids'] = frame_ids
+
+        return data
+        
+
+if __name__ == "__main__":
+    from hydra import compose, initialize
+    from omegaconf import OmegaConf
+    with initialize(config_path="../../conf", job_name="VPP_xbot_train.yaml"):
+        cfg = compose(config_name="VPP_xbot_train")
+    
+    # import sys
+    # sys.path.append('/cephfs/cjyyj/code/video_robot_svd-main/mdt')
+    # from utils.util import get_args
+    # train_args = get_args(cfg.datamodule.args)
+    # print(train_args)
+    train_dataset = Dataset_xbot(cfg.dataset_args,mode="val")
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=cfg.dataset_args.batch_size,
+        shuffle=cfg.dataset_args.shuffle,
+    )
+    for data in tqdm(train_loader,total=len(train_loader)):
+        print(data['ann_file'])
+        print(len(data['rgb_obs']))
+
+    

code/policy_models/edm_diffusion/gc_sampling.py

@@ -0,0 +1,1007 @@
+import math
+import os 
+
+from scipy import integrate
+import torch
+from torch import nn
+import torchsde
+from torchdiffeq import odeint
+from tqdm.auto import trange, tqdm
+from matplotlib import pyplot as plt
+import numpy as np
+
+from . import utils
+
+
+'''
+Code adapted for state-action based sampling with/without goal-conditioning:
+
+https://github.com/crowsonkb/k-diffusion/blob/master/k_diffusion/sampling.py
+'''
+
+def append_zero(action):
+    return torch.cat([action, action.new_zeros([1])])
+
+
+def get_sigmas_karras(n, sigma_min, sigma_max, rho=7., device='cpu'):
+    """Constructs the noise schedule of Karras et al. (2022)."""
+    ramp = torch.linspace(0, 1, n)
+    min_inv_rho = sigma_min ** (1 / rho)
+    max_inv_rho = sigma_max ** (1 / rho)
+    sigmas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
+    return append_zero(sigmas).to(device)
+
+
+def get_sigmas_exponential(n, sigma_min, sigma_max, device='cpu'):
+    """Constructs an exponential noise schedule."""
+    sigmas = torch.linspace(math.log(sigma_max), math.log(sigma_min), n, device=device).exp()
+    return append_zero(sigmas)
+
+
+def get_sigmas_linear(n, sigma_min, sigma_max, device='cpu'):
+    """Constructs an linear noise schedule."""
+    sigmas = torch.linspace(sigma_max, sigma_min, n, device=device)
+    return append_zero(sigmas)
+
+
+def cosine_beta_schedule(n, s=0.008, device='cpu'):
+    """
+    cosine schedule
+    as proposed in https://openreview.net/forum?id=-NEXDKk8gZ
+    """
+    steps = n + 1
+    x = np.linspace(0, steps, steps)
+    alphas_cumprod = np.cos(((x / steps) + s) / (1 + s) * np.pi * 0.5) ** 2
+    alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
+    betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
+    betas_clipped = np.clip(betas, a_min=0, a_max=0.999)
+    return append_zero(torch.tensor(np.flip(betas_clipped).copy(), device=device, dtype=torch.float32))
+
+
+def get_sigmas_ve(n, sigma_min=0.02, sigma_max=100, device='cpu'):
+    """Constructs a continuous VP noise schedule."""
+    # (sigma_max ** 2) * ((sigma_min ** 2 / sigma_max ** 2) ** (step_indices / (num_steps - 1)))
+    steps = n + 1
+    t = torch.linspace(0, steps, n, device=device)
+    t = (sigma_max ** 2) * ((sigma_min ** 2 / sigma_max ** 2) ** (t / (n - 1)))
+    sigmas = torch.sqrt(t)
+    return append_zero(sigmas)
+
+
+def get_iddpm_sigmas(n, sigma_min=0.02, sigma_max=100, M=1000, j_0=0, C_1=0.001, C_2=0.008, device='cpu'):
+    """Constructs a continuous VP noise schedule."""
+    # (sigma_max ** 2) * ((sigma_min ** 2 / sigma_max ** 2) ** (step_indices / (num_steps - 1)))
+    step_indices = torch.arange(n, dtype=torch.float64, device=device)
+    u = torch.zeros(M + 1, dtype=torch.float64, device=device)
+    alpha_bar = lambda j: (0.5 * np.pi * j / M / (C_2 + 1)).sin() ** 2
+    for j in torch.arange(M, j_0, -1, device=device): # M, ..., 1
+        u[j - 1] = ((u[j] ** 2 + 1) / (alpha_bar(j - 1) / alpha_bar(j)).clip(min=C_1) - 1).sqrt()
+    u_filtered = u[torch.logical_and(u >= sigma_min, u <= sigma_max)]
+    sigmas = u_filtered[((len(u_filtered) - 1) / (n - 1) * step_indices).round().to(torch.int64)]
+    return append_zero(sigmas).to(torch.float32)
+
+
+def get_sigmas_vp(n, beta_d=19.9, beta_min=0.1, eps_s=1e-3, device='cpu'):
+    """Constructs a continuous VP noise schedule."""
+    t = torch.linspace(1, eps_s, n, device=device)
+    sigmas = torch.sqrt(torch.exp(beta_d * t ** 2 / 2 + beta_min * t) - 1)
+    return append_zero(sigmas)
+
+
+def to_d(action, sigma, denoised):
+    """Converts a denoiser output to a Karras ODE derivative."""
+    return (action- denoised) / utils.append_dims(sigma, action.ndim)
+
+
+
+def default_noise_sampler(x):
+    return lambda sigma, sigma_next: torch.randn_like(x)
+
+
+
+def get_ancestral_step(sigma_from, sigma_to, eta=1.):
+    """Calculates the noise level (sigma_down) to step down to and the amount
+    of noise to add (sigma_up) when doing an ancestral sampling step."""
+    if not eta:
+        return sigma_to, 0.
+    sigma_up = min(sigma_to, eta * (sigma_to ** 2 * (sigma_from ** 2 - sigma_to ** 2) / sigma_from ** 2) ** 0.5)
+    sigma_down = (sigma_to ** 2 - sigma_up ** 2) ** 0.5
+    return sigma_down, sigma_up
+
+
+class BatchedBrownianTree:
+    """A wrapper around torchsde.BrownianTree that enables batches of entropy."""
+
+    def __init__(self, x, t0, t1, seed=None, **kwargs):
+        t0, t1, self.sign = self.sort(t0, t1)
+        w0 = kwargs.get('w0', torch.zeros_like(x))
+        if seed is None:
+            seed = torch.randint(0, 2 ** 63 - 1, []).item()
+        self.batched = True
+        try:
+            assert len(seed) == x.shape[0]
+            w0 = w0[0]
+        except TypeError:
+            seed = [seed]
+            self.batched = False
+        self.trees = [torchsde.BrownianTree(t0, w0, t1, entropy=s, **kwargs) for s in seed]
+
+    @staticmethod
+    def sort(a, b):
+        return (a, b, 1) if a < b else (b, a, -1)
+
+    def __call__(self, t0, t1):
+        t0, t1, sign = self.sort(t0, t1)
+        w = torch.stack([tree(t0, t1) for tree in self.trees]) * (self.sign * sign)
+        return w if self.batched else w[0]
+
+
+class BrownianTreeNoiseSampler:
+    """A noise sampler backed by a torchsde.BrownianTree.
+    Args:
+        x (Tensor): The tensor whose shape, device and dtype to use to generate
+            random samples.
+        sigma_min (float): The low end of the valid interval.
+        sigma_max (float): The high end of the valid interval.
+        seed (int or List[int]): The random seed. If a list of seeds is
+            supplied instead of a single integer, then the noise sampler will
+            use one BrownianTree per batch item, each with its own seed.
+        transform (callable): A function that maps sigma to the sampler's
+            internal timestep.
+    """
+
+    def __init__(self, x, sigma_min, sigma_max, seed=None, transform=lambda x: x):
+        self.transform = transform
+        t0, t1 = self.transform(torch.as_tensor(sigma_min)), self.transform(torch.as_tensor(sigma_max))
+        self.tree = BatchedBrownianTree(x, t0, t1, seed)
+
+    def __call__(self, sigma, sigma_next):
+        t0, t1 = self.transform(torch.as_tensor(sigma)), self.transform(torch.as_tensor(sigma_next))
+        return self.tree(t0, t1) / (t1 - t0).abs().sqrt()
+
+
+
+@torch.no_grad()
+def sample_euler(
+    model, 
+    state: torch.Tensor, 
+    action: torch.Tensor,  
+    goal: torch.Tensor, 
+    sigmas, 
+    scaler=None,
+    extra_args=None, 
+    callback=None, 
+    disable=None, 
+    s_churn=0., 
+    s_tmin=0., 
+    s_tmax=float('inf'), 
+    s_noise=1.
+):
+    """
+    Implements a variant of Algorithm 2 (Euler steps) from Karras et al. (2022).
+    Stochastic sampler, which combines a first order ODE solver with explicit Langevin-like "churn"
+    of adding and removing noise. 
+    Every update consists of these substeps:
+    1. Addition of noise given the factor eps
+    2. Solving the ODE dx/dt at timestep t using the score model 
+    3. Take Euler step from t -> t+1 to get x_{i+1}
+    
+    In contrast to the Heun variant, this variant does not compute a 2nd order correction step
+    For S_churn=0 the solver is an ODE solver
+    """
+    extra_args = {} if extra_args is None else extra_args
+    s_in = action.new_ones([action.shape[0]])
+    for i in trange(len(sigmas) - 1, disable=disable):
+        gamma = min(s_churn / (len(sigmas) - 1), 2 ** 0.5 - 1) if s_tmin <= sigmas[i] <= s_tmax else 0. 
+        eps = torch.randn_like(action) * s_noise    # sample current noise depnding on S_noise 
+        sigma_hat = sigmas[i] * (gamma + 1)         # add noise to sigma
+        # print(action[:, -1, :])
+        if gamma > 0: # if gamma > 0, use additional noise level for computation
+            action = action + eps * (sigma_hat ** 2 - sigmas[i] ** 2) ** 0.5 
+        denoised = model(state, action, goal, sigma_hat * s_in, **extra_args) # compute denoised action
+        d = to_d(action, sigma_hat, denoised) # compute derivative
+        if callback is not None: 
+            callback({'x': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigma_hat, 'denoised': denoised})
+        dt = sigmas[i + 1] - sigma_hat # compute timestep
+        # Euler method
+        action = action + d * dt # take Euler step
+        if scaler is not None:
+            action = scaler.clip_output(action)
+    return action
+
+
+@torch.no_grad()
+def sample_euler_ancestral(
+    model, 
+    state, 
+    action, 
+    goal, 
+    sigmas, 
+    scaler=None, 
+    extra_args=None, 
+    callback=None,
+    disable=None, 
+    eta=1.
+):
+    """
+    Ancestral sampling with Euler method steps.
+    
+    1. compute dx_{i}/dt at the current timestep 
+    2. get \sigma_{up} and \sigma_{down} from ancestral method 
+    3. compute x_{t-1} = x_{t} + dx_{t}/dt * \sigma_{down}
+    4. Add additional noise after the update step x_{t-1} =x_{t-1} + z * \sigma_{up}
+    """
+    extra_args = {} if extra_args is None else extra_args
+    s_in = action.new_ones([action.shape[0]])
+    for i in trange(len(sigmas) - 1, disable=disable):
+        # compute x_{t-1}
+        denoised = model(state, action, goal,  sigmas[i] * s_in, **extra_args)
+        # get ancestral steps
+        sigma_down, sigma_up = get_ancestral_step(sigmas[i], sigmas[i + 1], eta=eta)
+        if callback is not None:
+            callback({'x': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
+        # compute dx/dt 
+        d = to_d(action, sigmas[i], denoised)
+        # compute dt based on sigma_down value 
+        dt = sigma_down - sigmas[i]
+        # update current action 
+        action = action + d * dt
+        if sigma_down > 0:
+            action = action + torch.randn_like(action) * sigma_up
+        if scaler is not None:
+            action = scaler.clip_output(action)
+    return action
+
+
+@torch.no_grad()
+def sample_heun(
+    model, 
+    state, 
+    action, 
+    goal, 
+    sigmas, 
+    scaler=None,
+    extra_args=None, 
+    callback=None, 
+    disable=None, 
+    s_churn=0., 
+    s_tmin=0., 
+    s_tmax=float('inf'), 
+    s_noise=1.
+):
+    """
+    Implements Algorithm 2 (Heun steps) from Karras et al. (2022).
+    For S_churn =0 this is an ODE solver otherwise SDE
+    Every update consists of these substeps:
+    1. Addition of noise given the factor eps
+    2. Solving the ODE dx/dt at timestep t using the score model 
+    3. Take Euler step from t -> t+1 to get x_{i+1}
+    4. 2nd order correction step to get x_{i+1}^{(2)}
+    
+    In contrast to the Euler variant, this variant computes a 2nd order correction step. 
+    """
+    extra_args = {} if extra_args is None else extra_args
+    s_in = action.new_ones([action.shape[0]])
+    for i in trange(len(sigmas) - 1, disable=disable):
+        gamma = min(s_churn / (len(sigmas) - 1), 2 ** 0.5 - 1) if s_tmin <= sigmas[i] <= s_tmax else 0.
+        eps = torch.randn_like(action) * s_noise
+        sigma_hat = sigmas[i] * (gamma + 1)
+        # if gamma > 0, use additional noise level for computation ODE-> SDE Solver
+        if gamma > 0:
+            action= action+ eps * (sigma_hat ** 2 - sigmas[i] ** 2) ** 0.5
+        denoised = model(state, action, goal,  sigma_hat * s_in, **extra_args)
+        d = to_d(action, sigma_hat, denoised)
+        if callback is not None:
+            callback({'x': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigma_hat, 'denoised': denoised})
+        dt = sigmas[i + 1] - sigma_hat
+        # if we only are at the last step we use an Euler step for our update otherwise the heun one 
+        if sigmas[i + 1] == 0:
+            # Euler method
+            action= action+ d * dt
+        else:
+            # Heun's method
+            action_2 = action+ d * dt
+            denoised_2 = model(state, action_2,  goal, sigmas[i + 1] * s_in,**extra_args)
+            d_2 = to_d( action_2, sigmas[i + 1], denoised_2)
+            d_prime = (d + d_2) / 2
+            action= action+ d_prime * dt
+        # scale if wanted
+        if scaler is not None:
+            action = scaler.clip_output(action)
+    return action
+
+
+@torch.no_grad()
+def sample_dpm_2(
+    model, 
+    state, 
+    action, 
+    goal, 
+    sigmas, 
+    scaler=None,
+    extra_args=None, 
+    callback=None, 
+    disable=None, 
+    s_churn=0., 
+    s_tmin=0., 
+    s_tmax=float('inf'), 
+    s_noise=1.
+):
+    """
+    A sampler inspired by DPM-Solver-2 and Algorithm 2 from Karras et al. (2022).
+    SDE for S_churn!=0 and ODE otherwise
+
+    1.
+    
+    Last denoising step is an Euler step  
+    """
+    extra_args = {} if extra_args is None else extra_args
+    s_in = action.new_ones([action.shape[0]])
+    for i in trange(len(sigmas) - 1, disable=disable):
+        # compute stochastic gamma if s_churn > 0: 
+        gamma = min(s_churn / (len(sigmas) - 1), 2 ** 0.5 - 1) if s_tmin <= sigmas[i] <= s_tmax else 0.
+        
+        eps = torch.randn_like(action) * s_noise
+        sigma_hat = sigmas[i] * (gamma + 1)
+        # add noise to our current action sample in SDE case
+        if gamma > 0:
+            action = action + eps * (sigma_hat ** 2 - sigmas[i] ** 2) ** 0.5
+        # compute the derivative dx/dt at timestep t
+        denoised = model(state, action, goal, sigma_hat * s_in, **extra_args)
+        d = to_d(action, sigma_hat, denoised)
+
+        if callback is not None:
+            callback({'action': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigma_hat, 'denoised': denoised})
+        
+        # if we are at the last timestep: use Euler method
+        if sigmas[i + 1] == 0:
+            # Euler method
+            dt = sigmas[i + 1] - sigma_hat
+            action = action + d * dt
+        else:
+            # use Heun 2nd order update step 
+            sigma_mid = sigma_hat.log().lerp(sigmas[i + 1].log(), 0.5).exp()
+            dt_1 = sigma_mid - sigma_hat
+            dt_2 = sigmas[i + 1] - sigma_hat
+            action_2 = action + d * dt_1
+            denoised_2 = model(state, action_2, goal, sigma_mid * s_in, **extra_args)
+            d_2 = to_d( action_2, sigma_mid, denoised_2)
+            action = action + d_2 * dt_2
+        if scaler is not None:
+            action = scaler.clip_output(action)
+    return action
+
+
+@torch.no_grad()
+def sample_dpm_2_ancestral(model, state, action, goal,  sigmas, scaler=None, extra_args=None, callback=None, disable=None, eta=1.):
+    """
+    Ancestral sampling with DPM-Solver inspired second-order steps.
+
+    Ancestral sampling is based on the DDPM paper (https://arxiv.org/abs/2006.11239) generation process.
+    Song et al. (2021) show that ancestral sampling can be used to improve the performance of DDPM for its SDE formulation.
+    
+    1. Compute dx_{i}/dt at the current timestep 
+    
+    """
+    extra_args = {} if extra_args is None else extra_args
+    s_in = action.new_ones([action.shape[0]])
+    for i in trange(len(sigmas) - 1, disable=disable):
+        denoised = model(state, action, goal,  sigmas[i] * s_in, **extra_args)
+        sigma_down, sigma_up = get_ancestral_step(sigmas[i], sigmas[i + 1], eta=eta)
+        if callback is not None:
+            callback({'x': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
+        d = to_d(action, sigmas[i], denoised)
+        if sigma_down == 0:
+            # Euler method
+            dt = sigma_down - sigmas[i]
+            action= action+ d * dt
+        else:
+            # DPM-Solver-2
+            sigma_mid = sigmas[i].log().lerp(sigma_down.log(), 0.5).exp()
+            dt_1 = sigma_mid - sigmas[i]
+            dt_2 = sigma_down - sigmas[i]
+            action_2 = action+ d * dt_1
+            denoised_2 = model(state, action_2, goal, sigma_mid * s_in, **extra_args)
+            d_2 = to_d( action_2, sigma_mid, denoised_2)
+            action= action+ d_2 * dt_2
+            action= action+ torch.randn_like(action) * sigma_up
+        if scaler is not None:
+            action = scaler.clip_output(action)
+    return action
+
+
+def linear_multistep_coeff(order, t, i, j):
+    '''
+    Returns the coefficient of the j-th derivative of the i-th step of a linear multistep method.
+    '''
+    if order - 1 > i:
+        raise ValueError(f'Order {order} too high for step {i}')
+    def fn(tau):
+        prod = 1.
+        for k in range(order):
+            if j == k:
+                continue
+            prod *= (tau - t[i - k]) / (t[i - j] - t[i - k])
+        return prod
+    return integrate.quad(fn, t[i], t[i + 1], epsrel=1e-4)[0]
+
+
+@torch.no_grad()
+def sample_lms(
+    model, 
+    state, 
+    action, 
+    goal,  
+    sigmas, 
+    scaler=None,
+    extra_args=None, 
+    callback=None, 
+    disable=None, 
+    order=4
+):
+    '''
+    A linear multistep sampler.
+
+    1. compute x_{t-1} using the current noise level 
+    2. compute dx/dt at x_{t-1} using the current noise level
+    '''
+    extra_args = {} if extra_args is None else extra_args
+    s_in = action.new_ones([action.shape[0]])
+    sigmas_cpu = sigmas.detach().cpu().numpy()
+    ds = []
+    for i in trange(len(sigmas) - 1, disable=disable):
+        denoised = model(state, action, goal,  sigmas[i] * s_in, **extra_args)
+        d = to_d(action, sigmas[i], denoised)
+        ds.append(d)
+        if len(ds) > order:
+            ds.pop(0)
+        if callback is not None:
+            callback({'x': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
+        cur_order = min(i + 1, order)
+        coeffs = [linear_multistep_coeff(cur_order, sigmas_cpu, i, j) for j in range(cur_order)]
+        action = action + sum(coeff * d for coeff, d in zip(coeffs, reversed(ds)))
+        if scaler is not None:
+            action = scaler.clip_output(action)
+    return action
+
+
+@torch.no_grad()
+def log_likelihood(model, state, action, goal,  sigma_min, sigma_max, extra_args=None, atol=1e-4, rtol=1e-4):
+    '''
+    Computes the log-likelihood of actions 
+    '''
+    extra_args = {} if extra_args is None else extra_args
+    s_in = action.new_ones([action.shape[0]])
+    v = torch.randint_like(action, 2) * 2 - 1
+    fevals = 0
+    def ode_fn(sigma, action):
+        nonlocal fevals
+        with torch.enable_grad():
+            action= action[0].detach().requires_grad_()
+            denoised = model(state, action, goal,  sigma * s_in, **extra_args)
+            d = to_d(action, sigma, denoised)
+            fevals += 1
+            grad = torch.autograd.grad((d * v).sum(), action)[0]
+            d_ll = (v * grad).flatten(1).sum(1)
+        return d.detach(), d_ll
+    action_min = action, action.new_zeros([action.shape[0]])
+    t = action.new_tensor([sigma_min, sigma_max])
+    sol = odeint(ode_fn, action_min, t, atol=atol, rtol=rtol, method='dopri5')
+    latent, delta_ll = sol[0][-1], sol[1][-1]
+    ll_prior = torch.distributions.Normal(0, sigma_max).log_prob(latent).flatten(1).sum(1)
+    return ll_prior + delta_ll, {'fevals': fevals}
+
+
+class PIDStepSizeController:
+    """A PID controller for ODE adaptive step size control."""
+    def __init__(self, h, pcoeff, icoeff, dcoeff, order=1, accept_safety=0.81, eps=1e-8):
+        self.h = h
+        self.b1 = (pcoeff + icoeff + dcoeff) / order
+        self.b2 = -(pcoeff + 2 * dcoeff) / order
+        self.b3 = dcoeff / order
+        self.accept_safety = accept_safety
+        self.eps = eps
+        self.errs = []
+
+    def limiter(self, action):
+        return 1 + math.atan(action- 1)
+
+    def propose_step(self, error):
+        inv_error = 1 / (float(error) + self.eps)
+        if not self.errs:
+            self.errs = [inv_error, inv_error, inv_error]
+        self.errs[0] = inv_error
+        factor = self.errs[0] ** self.b1 * self.errs[1] ** self.b2 * self.errs[2] ** self.b3
+        factor = self.limiter(factor)
+        accept = factor >= self.accept_safety
+        if accept:
+            self.errs[2] = self.errs[1]
+            self.errs[1] = self.errs[0]
+        self.h *= factor
+        return accept
+
+
+class DPMSolver(nn.Module):
+    """DPM-Solver. See https://arxiv.org/abs/2206.00927."""
+
+    def __init__(self, model, extra_args=None, eps_callback=None, info_callback=None):
+        super().__init__()
+        self.model = model
+        self.extra_args = {} if extra_args is None else extra_args
+        self.eps_callback = eps_callback
+        self.info_callback = info_callback
+
+    def t(self, sigma):
+        return -sigma.log()
+
+    def sigma(self, t):
+        return t.neg().exp()
+
+    def eps(self, eps_cache, key, state, action, goal,  t, *args, **kwargs):
+        if key in eps_cache:
+            return eps_cache[key], eps_cache
+        sigma = self.sigma(t) * action.new_ones([action.shape[0]])
+        eps = (action - self.model(state, action, goal,  sigma, *args, **self.extra_args, **kwargs)) / self.sigma(t)
+        if self.eps_callback is not None:
+            self.eps_callback()
+        return eps, {key: eps, **eps_cache}
+
+    def dpm_solver_1_step(self, state, action, goal,  t, t_next, eps_cache=None):
+        eps_cache = {} if eps_cache is None else eps_cache
+        h = t_next - t
+        eps, eps_cache = self.eps(eps_cache, 'eps', state, action, goal,  t)
+        action_1 = action- self.sigma(t_next) * h.expm1() * eps
+        return action_1, eps_cache
+
+    def dpm_solver_2_step(self, state, action, goal,  t, t_next, r1=1 / 2, eps_cache=None):
+        eps_cache = {} if eps_cache is None else eps_cache
+        h = t_next - t
+        eps, eps_cache = self.eps(eps_cache, 'eps', state, action, goal,  t)
+        s1 = t + r1 * h
+        u1 = action - self.sigma(s1) * (r1 * h).expm1() * eps
+        eps_r1, eps_cache = self.eps(eps_cache, 'eps_r1', state, u1, goal, s1)
+        action_2 = action - self.sigma(t_next) * h.expm1() * eps - self.sigma(t_next) / (2 * r1) * h.expm1() * (eps_r1 - eps)
+        return action_2, eps_cache
+
+    def dpm_solver_3_step(self, state, action, goal,  t, t_next, r1=1 / 3, r2=2 / 3, eps_cache=None):
+        eps_cache = {} if eps_cache is None else eps_cache
+        h = t_next - t
+        eps, eps_cache = self.eps(eps_cache, 'eps', state, action, goal,  t)
+        s1 = t + r1 * h
+        s2 = t + r2 * h
+        u1 = action - self.sigma(s1) * (r1 * h).expm1() * eps
+        eps_r1, eps_cache = self.eps(eps_cache, 'eps_r1', state, u1, goal, s1)
+        u2 = action - self.sigma(s2) * (r2 * h).expm1() * eps - self.sigma(s2) * (r2 / r1) * ((r2 * h).expm1() / (r2 * h) - 1) * (eps_r1 - eps)
+        eps_r2, eps_cache = self.eps(eps_cache, 'eps_r2', state, u2, goal, s2)
+        action_3 = action - self.sigma(t_next) * h.expm1() * eps - self.sigma(t_next) / r2 * (h.expm1() / h - 1) * (eps_r2 - eps)
+        return action_3, eps_cache
+
+    def dpm_solver_fast(self, state, action, goal,  t_start, t_end, nfe, eta=0., s_noise=1., noise_sampler=None):
+        noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler
+        if not t_end > t_start and eta:
+            raise ValueError('eta must be 0 for reverse sampling')
+
+        m = math.floor(nfe / 3) + 1
+        ts = torch.linspace(t_start, t_end, m + 1, device=action.device)
+
+        if nfe % 3 == 0:
+            orders = [3] * (m - 2) + [2, 1]
+        else:
+            orders = [3] * (m - 1) + [nfe % 3]
+
+        for i in range(len(orders)):
+            eps_cache = {}
+            t, t_next = ts[i], ts[i + 1]
+            if eta:
+                sd, su = get_ancestral_step(self.sigma(t), self.sigma(t_next), eta)
+                t_next_ = torch.minimum(t_end, self.t(sd))
+                su = (self.sigma(t_next) ** 2 - self.sigma(t_next_) ** 2) ** 0.5
+            else:
+                t_next_, su = t_next, 0.
+
+            eps, eps_cache = self.eps(eps_cache, 'eps', state, action, goal,  t)
+            denoised = action- self.sigma(t) * eps
+            if self.info_callback is not None:
+                self.info_callback({'x': action, 'i': i, 't': ts[i], 't_up': t, 'denoised': denoised})
+
+            if orders[i] == 1:
+                action, eps_cache = self.dpm_solver_1_step(state, action, goal,  t, t_next_, eps_cache=eps_cache)
+            elif orders[i] == 2:
+                action, eps_cache = self.dpm_solver_2_step(state, action, goal,  t, t_next_, eps_cache=eps_cache)
+            else:
+                action, eps_cache = self.dpm_solver_3_step(state, action, goal,  t, t_next_, eps_cache=eps_cache)
+
+            action= action+ su * s_noise * noise_sampler(self.sigma(t), self.sigma(t_next))
+
+        return action
+
+    def dpm_solver_adaptive(self, state, action, goal,  t_start, t_end, order=3, rtol=0.05, atol=0.0078, h_init=0.05, pcoeff=0., icoeff=1., dcoeff=0., accept_safety=0.81, eta=0., s_noise=1.):
+        noise_sampler = default_noise_sampler(action) if noise_sampler is None else noise_sampler
+        if order not in {2, 3}:
+            raise ValueError('order should be 2 or 3')
+        forward = t_end > t_start
+        if not forward and eta:
+            raise ValueError('eta must be 0 for reverse sampling')
+        h_init = abs(h_init) * (1 if forward else -1)
+        atol = torch.tensor(atol)
+        rtol = torch.tensor(rtol)
+        s = t_start
+        action_prev = action
+        accept = True
+        pid = PIDStepSizeController(h_init, pcoeff, icoeff, dcoeff, 1.5 if eta else order, accept_safety)
+        info = {'steps': 0, 'nfe': 0, 'n_accept': 0, 'n_reject': 0}
+
+        while s < t_end - 1e-5 if forward else s > t_end + 1e-5:
+            eps_cache = {}
+            t = torch.minimum(t_end, s + pid.h) if forward else torch.maximum(t_end, s + pid.h)
+            if eta:
+                sd, su = get_ancestral_step(self.sigma(s), self.sigma(t), eta)
+                t_ = torch.minimum(t_end, self.t(sd))
+                su = (self.sigma(t) ** 2 - self.sigma(t_) ** 2) ** 0.5
+            else:
+                t_, su = t, 0.
+
+            eps, eps_cache = self.eps(eps_cache, 'eps', state, action, goal,  s)
+            denoised = action - self.sigma(s) * eps
+
+            if order == 2:
+                action_low, eps_cache = self.dpm_solver_1_step(state, action, goal,  s, t_, eps_cache=eps_cache)
+                action_high, eps_cache = self.dpm_solver_2_step(state, action, goal,  s, t_, eps_cache=eps_cache)
+            else:
+                action_low, eps_cache = self.dpm_solver_2_step(state, action, goal,  s, t_, r1=1 / 3, eps_cache=eps_cache)
+                action_high, eps_cache = self.dpm_solver_3_step(state, action, goal,  s, t_, eps_cache=eps_cache)
+            delta = torch.maximum(atol, rtol * torch.maximum( action_low.abs(), action_prev.abs()))
+            error = torch.linalg.norm(( action_low - action_high) / delta) / action.numel() ** 0.5
+            accept = pid.propose_step(error)
+            if accept:
+                action_prev = action_low
+                action = action_high + su * s_noise * noise_sampler(self.sigma(s), self.sigma(t))
+                s = t
+                info['n_accept'] += 1
+            else:
+                info['n_reject'] += 1
+            info['nfe'] += order
+            info['steps'] += 1
+
+            if self.info_callback is not None:
+                self.info_callback({'x': action, 'i': info['steps'] - 1, 't': s, 't_up': s, 'denoised': denoised, 'error': error, 'h': pid.h, **info})
+
+        return action, info
+
+
+@torch.no_grad()
+def sample_dpm_fast(
+    model, 
+    state, 
+    action, 
+    goal,  
+    sigma_min, 
+    sigma_max, 
+    n, 
+    scaler=None,
+    extra_args=None, 
+    callback=None, 
+    disable=None, 
+    eta=0., 
+    s_noise=1.,
+    noise_sampler=None
+):
+    """DPM-Solver-Fast (fixed step size). See https://arxiv.org/abs/2206.00927."""
+    if sigma_min <= 0 or sigma_max <= 0:
+        raise ValueError('sigma_min and sigma_maactionmust not be 0')
+    with tqdm(total=n, disable=disable) as pbar:
+        dpm_solver = DPMSolver(model, extra_args, eps_callback=pbar.update)
+        if callback is not None:
+            dpm_solver.info_callback = lambda info: callback({'sigma': dpm_solver.sigma(info['t']), 'sigma_hat': dpm_solver.sigma(info['t_up']), **info})
+        return dpm_solver.dpm_solver_fast(state, action, goal,  dpm_solver.t(torch.tensor(sigma_max)), dpm_solver.t(torch.tensor(sigma_min)), n, eta, s_noise, noise_sampler)
+
+
+@torch.no_grad()
+def sample_dpmpp_2m(
+    model, 
+    state, 
+    action, 
+    goal, 
+    sigmas, 
+    scaler=None,
+    extra_args=None, 
+    callback=None, 
+    disable=None
+):
+    """DPM-Solver++(2M)."""
+    extra_args = {} if extra_args is None else extra_args
+    s_in = action.new_ones([action.shape[0]])
+    sigma_fn = lambda t: t.neg().exp()
+    t_fn = lambda sigma: sigma.log().neg()
+    old_denoised = None
+
+    for i in trange(len(sigmas) - 1, disable=disable):
+        # predict the next action
+        denoised = model(state, action, goal, sigmas[i] * s_in, **extra_args)
+        if callback is not None:
+            callback({'action': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
+        t, t_next = t_fn(sigmas[i]), t_fn(sigmas[i + 1])
+        h = t_next - t
+        if old_denoised is None or sigmas[i + 1] == 0:
+            action = (sigma_fn(t_next) / sigma_fn(t)) * action - (-h).expm1() * denoised
+        else:
+            h_last = t - t_fn(sigmas[i - 1])
+            r = h_last / h
+            denoised_d = (1 + 1 / (2 * r)) * denoised - (1 / (2 * r)) * old_denoised
+            action = (sigma_fn(t_next) / sigma_fn(t)) * action - (-h).expm1() * denoised_d
+        old_denoised = denoised
+    return action
+
+
+@torch.no_grad()
+def sample_dpmpp_sde(
+    model, 
+    state, 
+    action, 
+    goal, 
+    sigmas, 
+    extra_args=None, 
+    callback=None, 
+    disable=None, 
+    eta=1., 
+    s_noise=1., 
+    scaler=None,
+    noise_sampler=None, 
+    r=1 / 2
+):
+    """DPM-Solver++ (stochastic)."""
+    x = action
+    sigma_min, sigma_max = sigmas[sigmas > 0].min(), sigmas.max()
+    noise_sampler = BrownianTreeNoiseSampler(x, sigma_min, sigma_max) if noise_sampler is None else noise_sampler
+    extra_args = {} if extra_args is None else extra_args
+    s_in = x.new_ones([x.shape[0]])
+    sigma_fn = lambda t: t.neg().exp()
+    t_fn = lambda sigma: sigma.log().neg()
+
+    for i in trange(len(sigmas) - 1, disable=disable):
+        denoised =  model(state, x, goal, sigmas[i] * s_in, **extra_args)
+        if callback is not None:
+            callback({'x': x, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
+        if sigmas[i + 1] == 0:
+            # Euler method
+            d = to_d(x, sigmas[i], denoised)
+            dt = sigmas[i + 1] - sigmas[i]
+            x = x + d * dt
+        else:
+            # DPM-Solver++
+            t, t_next = t_fn(sigmas[i]), t_fn(sigmas[i + 1])
+            h = t_next - t
+            s = t + h * r
+            fac = 1 / (2 * r)
+
+            # Step 1
+            sd, su = get_ancestral_step(sigma_fn(t), sigma_fn(s), eta)
+            s_ = t_fn(sd)
+            x_2 = (sigma_fn(s_) / sigma_fn(t)) * x - (t - s_).expm1() * denoised
+            x_2 = x_2 + noise_sampler(sigma_fn(t), sigma_fn(s)) * s_noise * su
+            denoised_2 =  model(state, x_2, goal,  sigma_fn(s) * s_in, **extra_args)
+
+            # Step 2
+            sd, su = get_ancestral_step(sigma_fn(t), sigma_fn(t_next), eta)
+            t_next_ = t_fn(sd)
+            denoised_d = (1 - fac) * denoised + fac * denoised_2
+            x = (sigma_fn(t_next_) / sigma_fn(t)) * x - (t - t_next_).expm1() * denoised_d
+            x = x + noise_sampler(sigma_fn(t), sigma_fn(t_next)) * s_noise * su
+            if scaler is not None:
+                x = scaler.clip_output(x)
+    return x
+
+
+
+@torch.no_grad()
+def sample_dpmpp_2_with_lms(
+    model, 
+    state, 
+    action, 
+    goal, 
+    sigmas, 
+    scaler=None,
+    extra_args=None, 
+    callback=None, 
+    disable=None
+):
+    """DPM-Solver++(2M)."""
+    extra_args = {} if extra_args is None else extra_args
+    s_in = action.new_ones([action.shape[0]])
+    sigma_fn = lambda t: t.neg().exp()
+    t_fn = lambda sigma: sigma.log().neg()
+    old_denoised = None
+
+    for i in trange(len(sigmas) - 1, disable=disable):
+        # predict the next action
+        denoised = model(state, action, goal,  sigmas[i] * s_in, **extra_args)
+        if callback is not None:
+            callback({'action': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
+        t, t_next = t_fn(sigmas[i]), t_fn(sigmas[i + 1])
+        h = t_next - t
+        if old_denoised is None or sigmas[i + 1] == 0:
+            action = (sigma_fn(t_next) / sigma_fn(t)) * action - (-h).expm1() * denoised
+        else:
+            h_last = t - t_fn(sigmas[i - 1])
+            r = h_last / h
+            denoised_d = (1 + 1 / (2 * r)) * denoised - (1 / (2 * r)) * old_denoised
+            action = (sigma_fn(t_next) / sigma_fn(t)) * action - (-h).expm1() * denoised_d
+        old_denoised = denoised
+    return action
+
+
+@torch.no_grad()
+def sample_dpm_adaptive(
+    model, 
+    state, 
+    action, 
+    goal,  
+    sigma_min, 
+    sigma_max, 
+    extra_args=None, 
+    callback=None, 
+    disable=None, 
+    order=3, 
+    rtol=0.05, 
+    atol=0.0078, 
+    h_init=0.05, 
+    pcoeff=0., 
+    icoeff=1., 
+    dcoeff=0., 
+    accept_safety=0.81, 
+    eta=0., 
+    s_noise=1., 
+    return_info=False
+):
+    """
+    DPM-Solver-12 and 23 (adaptive step size). 
+    
+    See https://arxiv.org/abs/2206.00927.
+    """
+    if sigma_min <= 0 or sigma_max <= 0:
+        raise ValueError('sigma_min and sigma_max action nmust not be 0')
+    with tqdm(disable=disable) as pbar:
+        dpm_solver = DPMSolver(model, extra_args, eps_callback=pbar.update)
+        if callback is not None:
+            dpm_solver.info_callback = lambda info: callback({'sigma': dpm_solver.sigma(info['t']), 'sigma_hat': dpm_solver.sigma(info['t_up']), **info})
+        action, info = dpm_solver.dpm_solver_adaptive(state, action, goal,  dpm_solver.t(torch.tensor(sigma_max)), dpm_solver.t(torch.tensor(sigma_min)), order, rtol, atol, h_init, pcoeff, icoeff, dcoeff, accept_safety, eta, s_noise)
+    if return_info:
+        return action, info
+    return action
+
+
+@torch.no_grad()
+def sample_dpmpp_2s_ancestral(
+    model, 
+    state, 
+    action, 
+    goal, 
+    sigmas, 
+    scaler=None,
+    extra_args=None, 
+    callback=None, 
+    disable=None, 
+    eta=1., 
+    s_noise=1.,
+    noise_sampler=None
+):
+    """
+    Ancestral sampling combined with DPM-Solver++(2S) second-order steps."""
+    extra_args = {} if extra_args is None else extra_args
+    noise_sampler = default_noise_sampler(action) if noise_sampler is None else noise_sampler
+    s_in = action.new_ones([action.shape[0]])
+    sigma_fn = lambda t: t.neg().exp()
+    t_fn = lambda sigma: sigma.log().neg()
+
+    for i in trange(len(sigmas) - 1, disable=disable):
+        denoised = model(state, action, goal, sigmas[i] * s_in, **extra_args)
+        sigma_down, sigma_up = get_ancestral_step(sigmas[i], sigmas[i + 1], eta=eta)
+        if callback is not None:
+            callback({'action': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
+        if sigma_down == 0:
+            # Euler method
+            d = to_d(action, sigmas[i], denoised)
+            dt = sigma_down - sigmas[i]
+            action = action + d * dt
+        else:
+            # DPM-Solver-2++(2S)
+            t, t_next = t_fn(sigmas[i]), t_fn(sigma_down)
+            r = 1 / 2
+            h = t_next - t
+            s = t + r * h
+            x_2 = (sigma_fn(s) / sigma_fn(t)) * action - (-h * r).expm1() * denoised
+            denoised_2 = model(state, x_2, goal, sigma_fn(s) * s_in, **extra_args)
+            action = (sigma_fn(t_next) / sigma_fn(t)) * action - (-h).expm1() * denoised_2
+        # Noise addition
+        action = action + noise_sampler(sigmas[i], sigmas[i + 1]) * s_noise * sigma_up
+        if scaler is not None:
+            action = scaler.clip_output(action)
+    return action
+
+
+@torch.no_grad()
+def sample_ddim(
+    model, 
+    state, 
+    action, 
+    goal, 
+    sigmas, 
+    scaler=None,
+    extra_args=None, 
+    callback=None, 
+    disable=None, 
+    eta=1., 
+):
+    """
+    DPM-Solver 1( or DDIM sampler"""
+    extra_args = {} if extra_args is None else extra_args
+    s_in = action.new_ones([action.shape[0]])
+    sigma_fn = lambda t: t.neg().exp()
+    t_fn = lambda sigma: sigma.log().neg()
+    old_denoised = None
+
+    for i in trange(len(sigmas) - 1, disable=disable):
+        # predict the next action
+        denoised = model(state, action, goal, sigmas[i] * s_in, **extra_args)
+        if callback is not None:
+            callback({'action': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
+        t, t_next = t_fn(sigmas[i]), t_fn(sigmas[i + 1])
+        h = t_next - t
+        action = (sigma_fn(t_next) / sigma_fn(t)) * action - (-h).expm1() * denoised
+    return action
+
+
+
+@torch.no_grad()
+def sample_dpmpp_2s(
+    model, 
+    state, 
+    action, 
+    goal, 
+    sigmas, 
+    scaler=None,
+    extra_args=None, 
+    callback=None, 
+    disable=None, 
+    eta=1., 
+):
+    """
+    DPM-Solver++(2S) second-order steps."""
+    extra_args = {} if extra_args is None else extra_args
+    sigma_fn = lambda t: t.neg().exp()
+    t_fn = lambda sigma: sigma.log().neg()
+    s_in = action.new_ones([action.shape[0]])
+    for i in trange(len(sigmas) - 1, disable=disable):
+        denoised = model(state, action, goal, sigmas[i] * s_in, **extra_args)
+        if callback is not None:
+            callback({'action': action, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
+        if sigmas[i + 1] == 0:
+            # Euler method
+            d = to_d(action, sigmas[i], denoised)
+            dt = sigmas[i + 1] - sigmas[i]
+            action = action + d * dt
+        else:
+            # DPM-Solver-2++(2S)
+            t, t_next = t_fn(sigmas[i]), t_fn(sigmas[i + 1])
+            r = 1 / 2
+            h = t_next - t
+            s = t + r * h
+            x_2 = (sigma_fn(s) / sigma_fn(t)) * action - (-h * r).expm1() * denoised
+            denoised_2 = model(state, x_2, goal, sigma_fn(s) * s_in, **extra_args)
+            action = (sigma_fn(t_next) / sigma_fn(t)) * action - (-h).expm1() * denoised_2
+        if scaler is not None:
+            action = scaler.clip_output(action)
+    return action
+
+
+def make_sample_contour_plot(actions, n_steps, file_store_path):
+    
+    store_path = os.path.join(file_store_path, 'action_visualization.png')
+    rows = n_steps % 2
+    for idx, step in range(n_steps):
+        fig, axs = plt.subplots()
+        actions
+        store_path = os.path.join(file_store_path, f'action_visualization_step_{idx}.png')
+        
+        
+    

code/policy_models/edm_diffusion/score_wrappers.py

@@ -0,0 +1,119 @@
+from torch import nn
+from .utils import append_dims
+from policy_models.module.diffusion_decoder import DiffusionTransformer
+
+'''
+Wrappers for the score-based models based on Karras et al. 2022
+They are used to get improved scaling of different noise levels, which
+improves training stability and model performance 
+
+Code is adapted from:
+
+https://github.com/crowsonkb/k-diffusion/blob/master/k_diffusion/layers.py
+'''
+
+
+class GCDenoiser(nn.Module):
+    """
+    A Karras et al. preconditioner for denoising diffusion models.
+
+    Args:
+        inner_model: The inner model used for denoising.
+        sigma_data: The data sigma for scalings (default: 1.0).
+    """
+    def __init__(self, action_dim, obs_dim, goal_dim, num_tokens, goal_window_size, obs_seq_len, act_seq_len, device, sigma_data=1., proprio_dim=8):
+        super().__init__()
+        self.inner_model = DiffusionTransformer(
+            action_dim = action_dim,
+            obs_dim = obs_dim,
+            goal_dim = goal_dim,
+            proprio_dim= proprio_dim,
+            goal_conditioned = True,
+            embed_dim = 384,
+            n_dec_layers = 4,
+            n_enc_layers = 4,
+            n_obs_token = num_tokens,
+            goal_seq_len = goal_window_size,
+            obs_seq_len = obs_seq_len,
+            action_seq_len =act_seq_len,
+            embed_pdrob = 0,
+            goal_drop = 0,
+            attn_pdrop = 0.3,
+            resid_pdrop = 0.1,
+            mlp_pdrop = 0.05,
+            n_heads= 8,
+            device = device,
+            use_mlp_goal = True,
+        )
+        self.sigma_data = sigma_data
+
+    def get_scalings(self, sigma):
+        """
+        Compute the scalings for the denoising process.
+
+        Args:
+            sigma: The input sigma.
+        Returns:
+            The computed scalings for skip connections, output, and input.
+        """
+        c_skip = self.sigma_data ** 2 / (sigma ** 2 + self.sigma_data ** 2)
+        c_out = sigma * self.sigma_data / (sigma ** 2 + self.sigma_data ** 2) ** 0.5
+        c_in = 1 / (sigma ** 2 + self.sigma_data ** 2) ** 0.5
+        return c_skip, c_out, c_in
+
+    def loss(self, state, action, goal, noise, sigma, **kwargs):
+        """
+        Compute the loss for the denoising process.
+
+        Args:
+            state: The input state.
+            action: The input action.
+            goal: The input goal.
+            noise: The input noise.
+            sigma: The input sigma.
+            **kwargs: Additional keyword arguments.
+        Returns:
+            The computed loss.
+        """
+        c_skip, c_out, c_in = [append_dims(x, action.ndim) for x in self.get_scalings(sigma)]
+        noised_input = action + noise * append_dims(sigma, action.ndim)
+        model_output = self.inner_model(state, noised_input * c_in, goal, sigma, **kwargs)
+        target = (action - c_skip * noised_input) / c_out
+        return (model_output - target).pow(2).flatten(1).mean(), model_output
+
+    def forward(self, state, action, goal, sigma, **kwargs):
+        """
+        Perform the forward pass of the denoising process.
+
+        Args:
+            state: The input state.
+            action: The input action.
+            goal: The input goal.
+            sigma: The input sigma.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The output of the forward pass.
+        """
+        c_skip, c_out, c_in = [append_dims(x, action.ndim) for x in self.get_scalings(sigma)]
+        return self.inner_model(state, action * c_in, goal, sigma, **kwargs) * c_out + action * c_skip
+    
+    def forward_context_only(self, state, action, goal, sigma, **kwargs):
+        """
+        Perform the forward pass of the denoising process.
+
+        Args:
+            state: The input state.
+            action: The input action.
+            goal: The input goal.
+            sigma: The input sigma.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The output of the forward pass.
+        """
+        c_skip, c_out, c_in = [append_dims(x, action.ndim) for x in self.get_scalings(sigma)]
+        return self.inner_model.forward_enc_only(state, action * c_in, goal, sigma, **kwargs)
+
+    def get_params(self):
+        return self.inner_model.parameters()

code/policy_models/edm_diffusion/utils.py

@@ -0,0 +1,203 @@
+import torch
+import math
+import torch.nn as nn
+import numpy as np
+import einops
+
+
+def return_time_sigma_embedding_model(embedding_type, time_embed_dim, device):
+    '''
+    Method returns an embedding model given the chosen type
+    '''
+    if embedding_type == 'GaussianFourier':
+        return GaussianFourierEmbedding(time_embed_dim, device)
+    elif embedding_type == 'Sinusoidal':
+        return SinusoidalPosEmbedding(time_embed_dim, device)
+    elif embedding_type == 'FourierFeatures':
+        return FourierFeatures(time_embed_dim, device)
+    else:
+        raise ValueError('Embedding not avaiable, please chose an existing one!')
+
+
+class GaussianFourierProjection(nn.Module):
+    """Gaussian random features for encoding time steps."""
+    def __init__(self, embed_dim, scale=30.):
+        super().__init__()
+        # Randomly sample weights during initialization. These weights are fixed
+        # during optimization and are not trainable.
+        self.W = nn.Parameter(torch.randn(embed_dim // 2) * scale, requires_grad=False)
+
+    def forward(self, x):
+        x_proj = x[:, None] * self.W[None, :] * 2 * np.pi
+        return torch.cat([torch.sin(x_proj), torch.cos(x_proj)], dim=-1)
+    
+
+class FourierFeatures(nn.Module):
+    def __init__(self, time_embed_dim, device, in_features=1,  std=1.):
+        super().__init__()
+        self.device = device
+        assert time_embed_dim % 2 == 0
+        self.register_buffer('weight', torch.randn([time_embed_dim // 2, in_features]) * std
+                             )
+
+    def forward(self, input):
+        if len(input.shape) == 1:
+            input = einops.rearrange(input, 'b -> b 1')
+        f = 2 * math.pi * input @ self.weight.T
+        return torch.cat([f.cos(), f.sin()], dim=-1).to(self.device)
+
+
+class GaussianFourierEmbedding(nn.Module):
+    
+    def __init__(self, time_embed_dim, device):
+        super().__init__()
+        self.t_dim = time_embed_dim 
+        self.embed = nn.Sequential(
+            GaussianFourierProjection(embed_dim=time_embed_dim),
+            nn.Linear(time_embed_dim, 2*time_embed_dim),
+            nn.Mish(),
+            nn.Linear(2*time_embed_dim, time_embed_dim)
+        ).to(device)
+    
+    def forward(self, t):
+        return self.embed(t)
+
+
+class SinusoidalPosEmbedding(nn.Module):
+    
+    def __init__(self, time_embed_dim, device):
+        super().__init__()
+        self.device = device
+        self.embed = nn.Sequential(
+            SinusoidalPosEmb(time_embed_dim),
+            nn.Linear(time_embed_dim, time_embed_dim * 2),
+            nn.Mish(),
+            nn.Linear(time_embed_dim * 2, time_embed_dim),
+        ).to(self.device)
+    
+    def forward(self, t):
+        return self.embed(t)
+    
+    
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-np.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0).transpose(0, 1)
+
+        self.register_buffer('pe', pe)
+
+    def forward(self, x):
+        # not used in the final model
+        x = x + self.pe[:x.shape[0], :]
+        return self.dropout(x)
+    
+
+class SinusoidalPosEmb(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.dim = dim
+
+    def forward(self, x):
+        device = x.device
+        half_dim = self.dim // 2
+        emb = math.log(10000) / (half_dim - 1)
+        emb = torch.exp(torch.arange(half_dim, device=device) * -emb)
+        emb = x[:, None] * emb[None, :]
+        emb = torch.cat((emb.sin(), emb.cos()), dim=-1)
+        return emb
+
+
+class InputEncoder(nn.Module):
+    
+    def __init__(self, input_dim, latent_dim):
+        super().__init__()
+        
+        self.input_dim = input_dim
+        self.latent_dim = latent_dim
+        
+        self.emb = nn.Linear(self.input_dim, self.latent_dim)
+        
+    def forward(self, x):
+        return self.emb(x)
+
+
+class TEncoder(nn.Module):
+    
+    def __init__(self, input_dim, latent_dim):
+        super().__init__()
+        
+        self.input_dim = input_dim
+        self.latent_dim = latent_dim
+        
+        self.emb = nn.Linear(self.input_dim, self.latent_dim)
+        
+    def forward(self, x):
+        return self.emb(x)
+    
+
+def append_dims(x, target_dims):
+    """Appends dimensions to the end of a tensor until it has target_dims dimensions."""
+    dims_to_append = target_dims - x.ndim
+    if dims_to_append < 0:
+        raise ValueError(f'input has {x.ndim} dims but target_dims is {target_dims}, which is less')
+    return x[(...,) + (None,) * dims_to_append]
+
+
+def rand_log_normal(shape, loc=0., scale=1., device='cpu', dtype=torch.float32):
+    """Draws samples from a lognormal distribution."""
+    return (torch.randn(shape, device=device, dtype=dtype) * scale + loc).exp()
+
+
+def rand_log_logistic(shape, loc=0., scale=1., min_value=0., max_value=float('inf'), device='cpu', dtype=torch.float32):
+    """Draws samples from an optionally truncated log-logistic distribution."""
+    min_value = torch.as_tensor(min_value, device=device, dtype=torch.float64)
+    max_value = torch.as_tensor(max_value, device=device, dtype=torch.float64)
+    min_cdf = min_value.log().sub(loc).div(scale).sigmoid()
+    max_cdf = max_value.log().sub(loc).div(scale).sigmoid()
+    u = torch.rand(shape, device=device, dtype=torch.float64) * (max_cdf - min_cdf) + min_cdf
+    return u.logit().mul(scale).add(loc).exp().to(dtype)
+
+
+def rand_log_uniform(shape, min_value, max_value, device='cpu', dtype=torch.float32):
+    """Draws samples from an log-uniform distribution."""
+    min_value = math.log(min_value)
+    max_value = math.log(max_value)
+    return (torch.rand(shape, device=device, dtype=dtype) * (max_value - min_value) + min_value).exp()
+
+
+def rand_v_diffusion(shape, sigma_data=1., min_value=0., max_value=float('inf'), device='cpu', dtype=torch.float32):
+    """Draws samples from a truncated v-diffusion training timestep distribution."""
+    min_cdf = math.atan(min_value / sigma_data) * 2 / math.pi
+    max_cdf = math.atan(max_value / sigma_data) * 2 / math.pi
+    u = torch.rand(shape, device=device, dtype=dtype) * (max_cdf - min_cdf) + min_cdf
+    return torch.tan(u * math.pi / 2) * sigma_data
+
+
+def rand_split_log_normal(shape, loc, scale_1, scale_2, device='cpu', dtype=torch.float32):
+    """Draws samples from a split lognormal distribution."""
+    n = torch.randn(shape, device=device, dtype=dtype).abs()
+    u = torch.rand(shape, device=device, dtype=dtype)
+    n_left = n * -scale_1 + loc
+    n_right = n * scale_2 + loc
+    ratio = scale_1 / (scale_1 + scale_2)
+    return torch.where(u < ratio, n_left, n_right).exp()
+
+# Function to sample from discrete values
+def rand_discrete(shape, values, device='cpu', dtype=torch.float32):
+    """Draws samples from the given discrete values."""
+    indices = torch.randint(0, len(values), shape, device=device)
+    samples = torch.index_select(values, 0, indices).to(dtype)
+    return samples
+
+
+def rand_uniform(shape, min_value, max_value, device='cpu', dtype=torch.float32):
+    """Draws samples from a uniform distribution."""
+    return torch.rand(shape, device=device, dtype=dtype) * (max_value - min_value) + min_value

code/policy_models/losses/step_unet_mse.py

@@ -0,0 +1,373 @@
+import torch
+import torch.nn.functional as F
+from einops import rearrange, repeat
+import numpy as np
+import random
+
+def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
+    """
+    embed_dim: output dimension for each position
+    pos: a list of positions to be encoded: size (M,)
+    out: (M, D)
+    """
+    assert embed_dim % 2 == 0
+    omega = np.arange(embed_dim // 2, dtype=np.float64)
+    omega /= embed_dim / 2.
+    omega = 1. / 10000**omega  # (D/2,)
+
+    pos = pos.reshape(-1)  # (M,)
+    out = np.einsum('m,d->md', pos, omega)  # (M, D/2), outer product
+
+    emb_sin = np.sin(out) # (M, D/2)
+    emb_cos = np.cos(out) # (M, D/2)
+
+    emb = np.concatenate([emb_sin, emb_cos], axis=1)  # (M, D)
+    return emb
+
+
+def encode_text(texts, tokenizer, text_encoder, img_cond=None, img_cond_mask=None, img_encoder=None, position_encode=True, use_clip=False, max_length=20):
+    """Encode text with optional image conditioning."""
+    with torch.no_grad():
+        if use_clip:
+            inputs = tokenizer(texts, padding='max_length', return_tensors="pt",truncation=True, max_length=max_length).to(text_encoder.device)
+            outputs = text_encoder(**inputs)
+            encoder_hidden_states = outputs.last_hidden_state # (batch, 30, 512)
+            if position_encode:
+                embed_dim, pos_num = encoder_hidden_states.shape[-1], encoder_hidden_states.shape[1]
+                pos = np.arange(pos_num,dtype=np.float64)
+
+                position_encode = get_1d_sincos_pos_embed_from_grid(embed_dim, pos)
+                position_encode = torch.tensor(position_encode, device=encoder_hidden_states.device, dtype=encoder_hidden_states.dtype, requires_grad=False)
+
+                encoder_hidden_states += position_encode
+            assert encoder_hidden_states.shape[-1] == 512
+
+            if img_encoder is not None:
+                assert img_cond is not None
+                assert img_cond_mask is not None
+                img_cond = img_cond.to(img_encoder.device)
+                if len(img_cond.shape) == 5:
+                    img_cond = img_cond.squeeze(1)
+                
+                img_hidden_states = img_encoder(img_cond).image_embeds
+                img_hidden_states[img_cond_mask] = 0.0
+                img_hidden_states = img_hidden_states.unsqueeze(1).expand(-1,encoder_hidden_states.shape[1],-1)
+                assert img_hidden_states.shape[-1] == 512
+                encoder_hidden_states = torch.cat([encoder_hidden_states, img_hidden_states], dim=-1)
+                assert encoder_hidden_states.shape[-1] == 1024
+            else:
+                encoder_hidden_states = torch.cat([encoder_hidden_states, encoder_hidden_states], dim=-1)
+        
+        else:
+            inputs = tokenizer(texts, padding='max_length', return_tensors="pt",truncation=True, max_length=32).to(text_encoder.device)
+            outputs = text_encoder(**inputs)
+            encoder_hidden_states = outputs.last_hidden_state # (batch, 30, 512)
+            assert encoder_hidden_states.shape[1:] == (32,1024)
+
+    return encoder_hidden_states
+
+
+def unwrap_unet(unet):
+    if hasattr(unet, "module"):
+        unet = unet.module
+    return unet
+
+def _step_unet(unet, sample, timestep, encoder_hidden_states, added_time_ids, use_layer_idx=5, all_layer=False, complete=False):
+    """Direct UNet forward pass with early stopping at specified layer."""
+    unet = unwrap_unet(unet)
+    # 1. time
+    timesteps = timestep
+    if not torch.is_tensor(timesteps):
+        is_mps = sample.device.type == "mps"
+        if isinstance(timestep, float):
+            dtype = torch.float32 if is_mps else torch.float64
+        else:
+            dtype = torch.int32 if is_mps else torch.int64
+        timesteps = torch.tensor([timesteps], dtype=dtype, device=sample.device)
+    elif len(timesteps.shape) == 0:
+        timesteps = timesteps[None].to(sample.device)
+
+    # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
+    batch_size, num_frames = sample.shape[:2]
+    timesteps = timesteps.expand(batch_size)
+
+    t_emb = unet.time_proj(timesteps)
+    t_emb = t_emb.to(dtype=sample.dtype)
+    emb = unet.time_embedding(t_emb)
+
+    time_embeds = unet.add_time_proj(added_time_ids.flatten())
+    time_embeds = time_embeds.reshape((batch_size, -1))
+    time_embeds = time_embeds.to(emb.dtype)
+    aug_emb = unet.add_embedding(time_embeds)
+    emb = emb + aug_emb
+
+    # Flatten the batch and frames dimensions
+    sample = sample.flatten(0, 1)
+    emb = emb.repeat_interleave(num_frames, dim=0)
+    encoder_hidden_states = encoder_hidden_states.repeat_interleave(num_frames, dim=0)
+
+    # 2. pre-process
+    sample = unet.conv_in(sample)
+
+    image_only_indicator = torch.zeros(batch_size, num_frames, dtype=sample.dtype, device=sample.device)
+
+    down_block_res_samples = (sample,)
+    for downsample_block in unet.down_blocks:
+        if hasattr(downsample_block, "has_cross_attention") and downsample_block.has_cross_attention:
+            sample, res_samples = downsample_block(
+                hidden_states=sample,
+                temb=emb,
+                encoder_hidden_states=encoder_hidden_states,
+                image_only_indicator=image_only_indicator,
+            )
+        else:
+            sample, res_samples = downsample_block(
+                hidden_states=sample,
+                temb=emb,
+                image_only_indicator=image_only_indicator,
+            )
+
+        down_block_res_samples += res_samples
+
+    # 4. mid
+    sample = unet.mid_block(
+        hidden_states=sample,
+        temb=emb,
+        encoder_hidden_states=encoder_hidden_states,
+        image_only_indicator=image_only_indicator,
+    )
+
+    feature_list = []
+
+    # 5. up
+    for i, upsample_block in enumerate(unet.up_blocks):
+        res_samples = down_block_res_samples[-len(upsample_block.resnets) :]
+        down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)]
+
+        if hasattr(upsample_block, "has_cross_attention") and upsample_block.has_cross_attention:
+            sample = upsample_block(
+                hidden_states=sample,
+                temb=emb,
+                res_hidden_states_tuple=res_samples,
+                encoder_hidden_states=encoder_hidden_states,
+                image_only_indicator=image_only_indicator,
+            )
+        else:
+            sample = upsample_block(
+                hidden_states=sample,
+                temb=emb,
+                res_hidden_states_tuple=res_samples,
+                image_only_indicator=image_only_indicator,
+            )
+        
+        if i < use_layer_idx:
+            factor = 2**(use_layer_idx - i)
+            feature_list.append(torch.nn.functional.interpolate(sample, scale_factor=factor))
+        
+        if i == use_layer_idx and not complete:
+            feature_list.append(sample)
+            break
+
+    if not complete:
+        if all_layer:
+            sample = torch.cat(feature_list, dim=1)
+            sample = sample.reshape(batch_size, num_frames, *sample.shape[1:])
+        else:
+            sample = sample.reshape(batch_size, num_frames, *sample.shape[1:])
+        return sample
+    else:
+        sample = unet.conv_norm_out(sample)
+        sample = unet.conv_act(sample)
+        sample = unet.conv_out(sample)
+        sample = sample.reshape(batch_size, num_frames, *sample.shape[1:])
+        return sample
+
+
+def _compute_step_unet_feature(videos, images, texts, unet, pipeline, tokenizer, text_encoder, image_encoder, args, timestep=20, extract_layer_idx=1, step_time=1, max_length=20, seed=None):
+    """Compute intermediate UNet feature with gradients enabled via direct UNet forward."""
+    height = unet.module.config.sample_size * pipeline.vae_scale_factor // 3
+    width = unet.module.config.sample_size * pipeline.vae_scale_factor // 3
+    pipeline.vae.eval()
+    pipeline.image_encoder.eval()
+    device = images.device
+    dtype = pipeline.vae.dtype
+    #print('dtype:',dtype)
+    vae = pipeline.vae
+
+    num_videos_per_prompt = 1
+
+    frames = rearrange(videos, 'b f c h w-> (b f) c h w').to(dtype)
+    with torch.no_grad():
+        latents = vae.encode(frames).latent_dist.mode() * vae.config.scaling_factor    
+    latents = rearrange(latents, '(b f) c h w-> b f c h w', b=images.shape[0])
+
+
+
+
+
+    pixel_values = images
+    batch_size = pixel_values.shape[0]
+
+    pixel_values = rearrange(pixel_values, 'b f c h w-> (b f) c h w').to(dtype)
+
+    with torch.no_grad():
+        # texts, tokenizer, text_encoder, img_cond=None, img_cond_mask=None, img_encoder=None, position_encode=True, use_clip=False, max_length=20
+        encoder_hidden_states = encode_text(texts, tokenizer, text_encoder, position_encode=args.position_encode, use_clip=True, max_length=max_length)
+    encoder_hidden_states = encoder_hidden_states.to(dtype)
+    image_embeddings = encoder_hidden_states
+
+    needs_upcasting = pipeline.vae.dtype == torch.float16 and pipeline.vae.config.force_upcast
+    #if needs_upcasting:
+    #    pipeline.vae.to(dtype=torch.float32)
+    #    pixel_values.to(dtype=torch.float32)
+    if pixel_values.shape[-3] == 4:
+        image_latents = pixel_values/vae.config.scaling_factor
+    else:
+        image_latents = pipeline._encode_vae_image(pixel_values, device, num_videos_per_prompt, False)
+    image_latents = image_latents.to(image_embeddings.dtype)
+
+    #print('dtype:', image_latents.dtype)
+
+    #if needs_upcasting:
+    #    pipeline.vae.to(dtype=torch.float16)
+
+    #num_frames = unet.config.num_frames
+    num_frames = args.num_frames
+    image_latents = image_latents.unsqueeze(1).repeat(1, num_frames, 1, 1, 1)
+
+
+    # num_channels_latents = unet.module.config.in_channels
+    
+    gen = None
+    if seed is not None:
+        gen = torch.Generator(device=device)
+        gen.manual_seed(int(seed))
+    
+    # latents = pipeline.prepare_latents(
+    #     batch_size * num_videos_per_prompt,
+    #     num_frames,
+    #     num_channels_latents,
+    #     height,
+    #     width,
+    #     image_embeddings.dtype,
+    #     device,
+    #     gen,
+    #     None,
+    # )
+    rnd_normal = torch.randn([batch_size//2, 1, 1, 1, 1], device=device)
+    sigma = (rnd_normal * 1.6 + 0.7).exp()
+    c_in = 1 / (sigma**2 + 1) ** 0.5
+    c_noise = (sigma.log() / 4).reshape([batch_size//2])
+    loss_weight = (sigma ** 2 + 1) / sigma ** 2
+
+    # repreat items twice
+    sigma = torch.cat([sigma, sigma], dim=0)
+    c_noise = torch.cat([c_noise, c_noise], dim=0)
+    c_in = torch.cat([c_in, c_in], dim=0)
+    loss_weight = torch.cat([loss_weight, loss_weight], dim=0)
+    tmp_noise = torch.randn_like(latents.chunk(2, dim=0)[0])
+
+    latents = latents + torch.cat([tmp_noise, tmp_noise], dim=0) * sigma
+
+    fps = 4
+    motion_bucket_id = 127
+    added_time_ids = pipeline._get_add_time_ids(
+        fps,
+        motion_bucket_id,
+        0,
+        image_embeddings.dtype,
+        batch_size,
+        num_videos_per_prompt,
+        False,
+    )
+    added_time_ids = added_time_ids.to(device)
+
+    pipeline.scheduler.set_timesteps(timestep, device=device)
+    timesteps = pipeline.scheduler.timesteps
+
+
+    for i, t in enumerate(timesteps):
+        #print('step:',i)
+        if i == step_time - 1:
+            complete = False
+        else:
+            complete = True
+        # complete = True
+        #print('complete:',complete)
+
+        latent_model_input = latents * c_in
+        # latent_model_input = pipeline.scheduler.scale_model_input(latent_model_input, t)
+
+        # Concatenate image_latents over channels dimention
+        # latent_model_input = torch.cat([mask, latent_model_input, image_latents], dim=2)
+        latent_model_input = torch.cat([latent_model_input, image_latents], dim=2)
+        #print('latent_model_input_shape:',latent_model_input.shape)
+        #print('image_embeddings_shape:',image_embeddings.shape)
+
+        # predict the noise residual
+        # print('extract_layer_idx:',extract_layer_idx)
+        # print('latent_model_input_shape:',latent_model_input.shape)
+        # print('encoder_hidden_states:',image_embeddings.shape)
+        feature_pred = _step_unet(
+            unet,
+            latent_model_input,
+            c_noise,
+            encoder_hidden_states=image_embeddings,
+            added_time_ids=added_time_ids,
+            use_layer_idx=extract_layer_idx,
+            all_layer=True,
+            complete=complete,
+        )
+        # feature_pred = unet(latent_model_input,t,encoder_hidden_states=image_embeddings,added_time_ids=added_time_ids,return_dict=False,)[0]
+
+        # print('feature_pred_shape:',feature_pred.shape)
+
+        if not complete:
+            break
+
+        latents = pipeline.scheduler.step(feature_pred, t, latents).prev_sample
+
+        # latents = outputs.prev_sample
+        # pred_x0 = outputs.pred_original_sample
+        # frames = pipeline.decode_latents(pred_x0, num_frames)
+        # frames = pipeline.video_processor.postprocess_video(video=frames, output_type="np")
+        # import imageio
+        # breakpoint()
+        # imageio.mimsave("output.mp4", frames[0], fps=8)
+    return feature_pred
+
+
+def step_unet_pairwise_mse_loss(batch, unet, pipeline, tokenizer, text_encoder, image_encoder, args, timestep=20, extract_layer_idx=1, step_time=1, max_length=20):
+    """
+    Compute MSE between two step_unet feature passes derived from the same batch but with different noise seeds.
+    This keeps gradients w.r.t. UNet parameters.
+    """
+    batchsize = batch['video'].shape[0]
+    # text = batch['text'][:batchsize//2]
+    # video = batch['video'][:batchsize//2]
+    text = batch['text']
+    video = batch['video']
+    # random select a batch of two numbers as index not the same
+    pairs = [random.sample(range(video.shape[1]), 2) for _ in range(video.shape[0])]
+    pairs = torch.tensor(pairs, device=video.device, dtype=torch.long)
+    
+    image1 = video[torch.arange(video.shape[0], device=video.device), pairs[:, 0]].unsqueeze(1)
+    image2 = video[torch.arange(video.shape[0], device=video.device), pairs[:, 1]].unsqueeze(1)
+
+    # use the same seed for both images
+    # seed = torch.seed()
+    feats = _compute_step_unet_feature(torch.cat([video, video], dim=0), torch.cat([image1, image2], dim=0), text+text, unet, pipeline, tokenizer, text_encoder, image_encoder, args, timestep, extract_layer_idx, step_time, max_length)
+    # feat2 = _compute_step_unet_feature(image2, text, unet, pipeline, tokenizer, text_encoder, image_encoder, args, timestep, extract_layer_idx, step_time, max_length, seed=seed)
+    feat1, feat2 = feats.chunk(2, dim=0)
+    # use cosine similarity
+    # return F.mse_loss(feat1, feat2)
+    feat1 = feat1.permute(0,1,3,4,2)
+    feat1 = feat1.reshape(-1, feat1.shape[-1])
+    feat2 = feat2.permute(0,1,3,4,2)
+    feat2 = feat2.reshape(-1, feat2.shape[-1])
+    assert feat1.shape[-1] == 2560
+    feat1 = F.normalize(feat1, dim=1)
+    feat2 = F.normalize(feat2, dim=1)
+    return 1 - (feat1 * feat2).sum(dim=1).mean()
+
+

code/policy_models/module/Video_Former copy 2.py

@@ -0,0 +1,538 @@
+# This code is referenced from https://github.com/dhansmair/flamingo-mini
+
+import torch
+from einops import rearrange, repeat
+from einops_exts import rearrange_many
+from torch import einsum, nn
+import torch.nn.functional as F
+
+from policy_models.module.transformers.utils import feed_forward_layer
+
+class Attention(nn.Module):
+    def __init__(
+            self,
+            dim: int,
+            num_heads: int = 8,
+            use_cross_attn=False,
+            y_dim=512,
+            qkv_bias: bool = False,
+            qk_norm: bool = False,
+            attn_drop: float = 0.,
+            proj_drop: float = 0.,
+            norm_layer: nn.Module = nn.LayerNorm,
+            attn_mask = None,
+    ) -> None:
+        super().__init__()
+        assert dim % num_heads == 0, 'dim should be divisible by num_heads'
+        self.num_heads = num_heads
+        self.head_dim = dim // num_heads
+        self.scale = self.head_dim ** -0.5
+        self.fused_attn = True
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.q_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+        self.k_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+        self.attn_mask = attn_mask
+        self.use_cross_attn=use_cross_attn
+        if self.use_cross_attn:
+            #print('use_cross_attn')
+            self.y_kv = nn.Linear(y_dim, dim * 2, bias=qkv_bias)
+            self.y_k_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+            self.gate = nn.Parameter(torch.zeros([self.num_heads]))
+
+    def forward(self, x: torch.Tensor, y=None, attn_mask=None) -> torch.Tensor:
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv.unbind(0)
+        q, k = self.q_norm(q), self.k_norm(k)
+
+
+        if self.fused_attn:
+            if self.attn_mask is not None:
+                self.attn_mask = self.attn_mask.to(x.device)
+            x = F.scaled_dot_product_attention(
+                q, k, v,
+                dropout_p=self.attn_drop.p if self.training else 0.,
+                attn_mask=self.attn_mask
+            )
+        else:
+            q = q * self.scale
+            attn = q @ k.transpose(-2, -1)
+            attn = attn.softmax(dim=-1)
+            attn = self.attn_drop(attn)
+            x = attn @ v
+
+        if self.use_cross_attn:
+            #print('y_shape:',y.shape)
+            N_y = y.shape[1]
+            y_kv = self.y_kv(y).reshape(B, N_y, 2, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+            y_k, y_v = y_kv.unbind(0)
+            y_k = self.y_k_norm(y_k)
+            y_out = F.scaled_dot_product_attention(
+                q, y_k, y_v,
+                dropout_p=self.attn_drop.p if self.training else 0.,
+            )
+            #print('y_out_shape:', y_out.shape)
+            y_out = y_out*self.gate.tanh().view(1, -1, 1, 1)
+            x = x + y_out
+
+        x = x.transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+class PerceiverAttentionLayer(nn.Module):
+    """Perceiver Attention Layer"""
+
+    def __init__(self, dim: int, dim_head: int = 64, heads: int = 8):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        self.dim_head = dim_head
+        inner_dim = dim_head * heads
+
+        # trainable components of PerceiverAttentionLayer
+        self.norm_media = nn.LayerNorm(dim)
+        self.norm_latents = nn.LayerNorm(dim)
+
+        self.to_q = nn.Linear(dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(dim, inner_dim, bias=False)
+        self.to_out = nn.Linear(inner_dim, dim, bias=False)
+
+    def forward(self, features, latents):
+        """Latent vectors are cross-attending to the visual features x
+
+        Args:
+            features: Batch of visual features with shape (batch_size, n_features, dim)
+            latents: Latent learnt vectors which are used to compute queries with shape (batch_size, n_latents, dim)
+
+        Returns:
+            Attention score with shape (batch_size, n_latents, dim)
+        """
+        assert features.ndim == 3
+        assert latents.ndim == 3
+        assert features.shape[0] == latents.shape[0]
+        assert features.shape[2] == latents.shape[2]
+
+        n_heads = self.heads
+        n_batch, n_features, dim = features.shape
+        n_queries = latents.shape[1]
+
+        # Layer normalization
+        x = self.norm_media(features)
+        latents = self.norm_latents(latents)
+
+        # Compute the queries from the latents, for all attention heads simultaneously
+        q = self.to_q(latents)
+        q = rearrange(q, 'b q (h d) -> b h q d', h=n_heads)
+        assert q.shape == torch.Size([n_batch, n_heads, n_queries, self.dim_head])
+
+        # Keys and values for all attention heads
+        kv_input = torch.cat((x, latents), dim=-2)
+        n_features_latents = n_features + n_queries
+        k = self.to_k(kv_input)
+        v = self.to_v(kv_input)
+
+        k, v = rearrange_many((k, v), 'b f (h d) -> b h f d', h=n_heads)
+        assert v.shape == torch.Size([n_batch, n_heads, n_features_latents, self.dim_head])
+
+        q = q * self.scale
+
+        # Attention scores
+        sim = einsum('b h q d, b h f d -> b h q f', q, k)
+        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
+        alphas = sim.softmax(dim=-1)
+
+        out = einsum('b h q f, b h f v -> b h q v', alphas, v)
+        out = rearrange(out, 'b h q v -> b q (h v)')
+
+        return self.to_out(out)
+
+class TempAttentionLayer(nn.Module):
+    """Perceiver Attention Layer"""
+
+    def __init__(self, dim: int, dim_head: int = 64, heads: int = 8):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        self.dim_head = dim_head
+        inner_dim = dim_head * heads
+
+        # trainable components of PerceiverAttentionLayer
+        self.norm_media = nn.LayerNorm(dim)
+
+        self.to_q = nn.Linear(dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(dim, inner_dim, bias=False)
+        self.to_out = nn.Linear(inner_dim, dim, bias=False)
+
+    def forward(self, features):
+        """Latent vectors are cross-attending to the visual features x
+
+        Args:
+            features: Batch of visual features with shape (batch_size, n_features, dim)
+            latents: Latent learnt vectors which are used to compute queries with shape (batch_size, n_latents, dim)
+
+        Returns:
+            Attention score with shape (batch_size, n_latents, dim)
+        """
+        assert features.ndim == 3
+
+        n_heads = self.heads
+        n_batch, n_features, dim = features.shape
+        n_queries = features.shape[1]
+
+        # Layer normalization
+        x = self.norm_media(features)
+
+        # Compute the queries from the latents, for all attention heads simultaneously
+        q = self.to_q(x)
+        q = rearrange(q, 'b q (h d) -> b h q d', h=n_heads)
+        assert q.shape == torch.Size([n_batch, n_heads, n_queries, self.dim_head])
+
+        # Keys and values for all attention heads
+        n_features_latents = n_features
+        k = self.to_k(x)
+        v = self.to_v(x)
+
+        k, v = rearrange_many((k, v), 'b f (h d) -> b h f d', h=n_heads)
+        assert v.shape == torch.Size([n_batch, n_heads, n_features_latents, self.dim_head])
+
+        q = q * self.scale
+
+        # Attention scores
+        sim = einsum('b h q d, b h f d -> b h q f', q, k)
+        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
+        alphas = sim.softmax(dim=-1)
+
+        out = einsum('b h q f, b h f v -> b h q v', alphas, v)
+        out = rearrange(out, 'b h q v -> b q (h v)')
+
+        return self.to_out(out)
+
+
+class Video_Former_3D(nn.Module):
+    """Perceiver Resampler with multi-head attention layer"""
+
+    def __init__(
+            self,
+            dim: int,
+            depth: int,
+            condition_dim: int = 1280,
+            dim_head: int = 64,
+            heads: int = 8,
+            num_latents: int = 64,
+            num_frame: int = 14,
+            num_time_embeds: int = 4,
+            ff_mult: int = 4,
+            activation: str = 'gelu',
+            trainable: bool = True,
+            use_temporal: bool = False,
+    ):
+        super().__init__()
+
+        self.dim = dim
+        self.num_queries = num_latents
+        self.num_frame = num_frame
+        self.condition_dim = condition_dim
+        self.use_temporal = use_temporal
+        self.input_mask_mode = 'zero' # 'none' | 'zero' | 'gaussian' | 'learnable'
+
+        self.goal_emb = nn.Sequential(
+            nn.Linear(condition_dim, dim * 2),
+            nn.GELU(),
+            nn.Linear(dim * 2, dim)
+        )
+        frame_seq_len = num_latents // num_frame
+        self.latents = nn.Parameter(torch.randn(self.num_frame, frame_seq_len, dim))  # type: ignore[reportPrivateUsage]
+        self.time_pos_emb = nn.Parameter(torch.randn(num_time_embeds, 1, dim))  # type: ignore[reportPrivateUsage]
+        attn_mask = torch.ones((num_frame, num_frame))
+        #attn_mask = torch.tril(attn_mask).bool()
+
+        self.layers = nn.ModuleList([])
+
+        if self.use_temporal:
+            for _ in range(depth):
+                self.layers.append(
+                    nn.ModuleList(
+                        [
+                            PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            #TempAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            Attention(dim, num_heads=heads, qkv_bias=True, use_cross_attn=False,
+                                      y_dim=512, attn_mask=attn_mask),
+                            feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                        ]
+                    )
+                )
+        else:
+            for _ in range(depth):
+                self.layers.append(
+                    nn.ModuleList(
+                        [
+                            PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                        ]
+                    )
+                )
+
+        # Layer normalization takes as input the query vector length
+        self.norm = nn.LayerNorm(dim)
+
+        self._update_trainable_state(trainable)
+
+        # learnable frame token (used when input_mask_mode == 'learnable')
+        if self.input_mask_mode == 'learnable':
+            # shape: (1, 1, n_features, dim) after goal_emb
+            self.learnable_mask_token = nn.Parameter(torch.zeros(1, 1, 1, dim))
+
+    def _update_trainable_state(self, trainable: bool = True):
+        for param in self.parameters():
+            param.requires_grad = trainable
+
+    def forward(self, x_f: torch.Tensor, mask: torch.BoolTensor = None, extra : torch.Tensor = None, frame_mask_prob: float = 0.0, language: torch.Tensor = None):
+        """Run perceiver resampler on the input visual embeddings
+
+        Args:
+            x_f: Input visual embeddings of shape (batch_size, n_frames, n_features, d_visual)
+            mask: Mask for the input visual embeddings of shape (batch_size, n_frames)
+            extra: Extra tensor for concatenation
+            frame_mask_prob: Probability of masking each frame during training (0.0 = no masking)
+            language: Language embeddings of shape (batch_size, 1, lang_dim)
+
+        Returns:
+            Resampler features of shape (batch_size, num_queries, d_visual)
+        """
+        assert x_f.ndim == 4
+
+        batch_size, max_length, _, dim = x_f.shape
+
+        # Generate per-batch frame mask (True=keep, False=mask) with non-uniform probability centered at index 6
+        frame_mask = None
+        if frame_mask_prob > 0.0 and self.training:
+            # per-frame mask probabilities p_i: highest at center_idx=6, decays with distance
+            center_idx = 6 if max_length > 6 else (max_length // 2)
+            frame_indices = torch.arange(max_length, device=x_f.device).float()
+            distances = (frame_indices - float(center_idx)).abs()
+            sigma = 2.0
+            # Gaussian decay: p_i = frame_mask_prob * exp(-0.5 * (d/sigma)^2)
+            per_frame_p = frame_mask_prob * torch.exp(-0.5 * (distances / sigma) ** 2)
+            # broadcast to batch and sample Bernoulli per (b, t)
+            rand_vals = torch.rand(batch_size, max_length, device=x_f.device)
+            # True=keep, False=mask
+            frame_mask = rand_vals > per_frame_p.unsqueeze(0)
+            # ensure at least one frame kept per sample
+            needs_fix = frame_mask.sum(dim=1) == 0
+            if needs_fix.any():
+                idx = torch.nonzero(needs_fix, as_tuple=False).squeeze(-1)
+                rand_cols = torch.randint(0, max_length, (idx.numel(),), device=x_f.device)
+                frame_mask[idx, rand_cols] = True
+
+        # Mask the position embeddings for the padded frames
+        time_pos_emb = (
+            self.time_pos_emb[:max_length].unsqueeze(0).expand(batch_size, -1, -1, -1)
+        )  # [batch_size, max_length, 1, dim]
+        if mask is not None:
+            time_pos_emb = time_pos_emb * mask.unsqueeze(-1).unsqueeze(-1)
+
+        # Apply the position embeddings
+        x_f = self.goal_emb(x_f)
+        # Frame-level input masking before adding positional encoding
+        if frame_mask is not None:
+            bsz = batch_size
+            T = max_length
+            n_features = x_f.shape[2]
+            d = x_f.shape[3]
+            mask_expand = frame_mask.unsqueeze(-1).unsqueeze(-1).expand(bsz, T, n_features, d)
+            if self.input_mask_mode == 'zero':
+                x_f = torch.where(mask_expand, x_f, torch.zeros_like(x_f))
+            elif self.input_mask_mode == 'gaussian':
+                noise = torch.randn_like(x_f)
+                x_f = torch.where(mask_expand, x_f, noise)
+            elif self.input_mask_mode == 'learnable':
+                token = self.learnable_mask_token
+                token = token.expand(bsz, T, n_features, d)
+                x_f = torch.where(mask_expand, x_f, token)
+            # 'none' -> do nothing
+        # 融合语言：将 language (b,1,512) 投影到dim，并按帧复制后拼接为额外特征
+        # if language is not None:
+        #     lang = self.lang_emb(language.squeeze(1))  # (b, dim)
+        #     lang = lang.unsqueeze(1)  # (b,1,dim)
+        #     lang = repeat(lang, 'b q d -> b T q d', T=max_length)  # (b,T,1,dim)
+        #     x_f = torch.cat([x_f, lang], dim=2)
+        if extra is not None:
+            extra = repeat(extra, 'b q d -> b T q d', T=max_length)
+            x_f = torch.cat([x_f, extra],dim = 2)
+        x_f = x_f + time_pos_emb
+
+        # Select temporal keep mask for spatial attention only (do not change latent length)
+        keep_mask_time = None
+        if frame_mask_prob > 1.0 and self.training:
+            b, T, n, d = x_f.shape
+            # center-weighted dropping: closer to center has higher drop prob
+            center_idx = 6 if T > 6 else (T // 2)
+            frame_indices = torch.arange(T, device=x_f.device).float()
+            distances = (frame_indices - float(center_idx)).abs()
+            sigma = 2.0
+            # unnormalized weights (max at center, decay with distance)
+            weights = torch.exp(-0.5 * (distances / sigma) ** 2)
+            weights = weights / (weights.sum() + 1e-8)
+            # sample p ~ Uniform(0, frame_mask_prob) then fixed count per batch
+            p = (torch.rand((), device=x_f.device) * frame_mask_prob).item()
+            num_to_remove = int(T * p)
+            if num_to_remove >= T:
+                num_to_remove = T - 1
+            if num_to_remove > 0:
+                drop_idx = torch.multinomial(weights, num_samples=num_to_remove, replacement=False)
+                keep_mask_time = torch.ones(T, dtype=torch.bool, device=x_f.device)
+                keep_mask_time[drop_idx] = False
+
+        # Copy the latents for every element in the batch (full timeline, no dropping)
+        x_full = repeat(self.latents, 'T q d -> b T q d', b=batch_size)  # (b, T, q, d)
+
+        # Apply attention and feed forward layer
+        if self.use_temporal:
+            for attn, Temp_attn, ffw in self.layers:
+                # spatial attention only on kept frames in b T q d layout
+                if keep_mask_time is not None:
+                    # select kept time steps
+                    x_kept = x_full[:, keep_mask_time, :, :]  # (b, T_kept, q, d)
+                    x_f_kept = x_f[:, keep_mask_time, :, :]   # (b, T_kept, n, d)
+                    # flatten kept slices for attention
+                    x_kept_flat = rearrange(x_kept, 'b T q d -> (b T) q d')
+                    x_f_kept_flat = rearrange(x_f_kept, 'b T n d -> (b T) n d')
+                    # update kept positions
+                    x_kept_flat = x_kept_flat + attn(x_f_kept_flat, x_kept_flat)
+                    x_kept = rearrange(x_kept_flat, '(b T) q d -> b T q d', b=batch_size)
+                    # create new tensor combining kept and unmasked parts
+                    x_full_new = torch.zeros_like(x_full)
+                    x_full_new[:, keep_mask_time, :, :] = x_kept
+                    x_full_new[:, ~keep_mask_time, :, :] = x_full[:, ~keep_mask_time, :, :]
+                    x_full = x_full_new
+                else:
+                    # no dropping, full spatial attention
+                    x_full_flat = rearrange(x_full, 'b T q d -> (b T) q d')
+                    x_f_flat = rearrange(x_f, 'b T n d -> (b T) n d')
+                    x_full_flat = x_full_flat + attn(x_f_flat, x_full_flat)
+                    x_full = rearrange(x_full_flat, '(b T) q d -> b T q d', b=batch_size)
+
+                # temporal attention on full timeline (no additional mask)
+                x_full_flat = rearrange(x_full, 'b T q d -> (b q) T d')
+                x_full_flat = x_full_flat + Temp_attn(x_full_flat, attn_mask=None)
+                x_full_flat = rearrange(x_full_flat, '(b q) T d -> (b T) q d', b=batch_size)
+                x_full_flat = x_full_flat + ffw(x_full_flat)
+                x_full = rearrange(x_full_flat, '(b T) q d -> b T q d', b=batch_size)
+        else:
+            for attn, ffw in self.layers:
+                x = x + attn(x_f, x)
+                x = x + ffw(x)
+
+        #x = rearrange(x, 'l q d -> b T q d', b=batch_size)
+        x = rearrange(x_full, 'b T q d -> b (T q) d')
+        assert x.shape == torch.Size([batch_size, self.num_queries, self.dim])
+        norm = self.norm(x)
+
+        return norm
+
+class Video_Former_2D(nn.Module):
+    """Perceiver Resampler with multi-head attention layer"""
+
+    def __init__(
+            self,
+            dim: int,
+            depth: int,
+            condition_dim: int = 1280,
+            dim_head: int = 64,
+            heads: int = 8,
+            num_latents: int = 64,
+            num_frame: int = 16,
+            num_time_embeds: int = 4,
+            ff_mult: int = 4,
+            activation: str = 'gelu',
+            trainable: bool = True,
+    ):
+        super().__init__()
+
+        self.dim = dim
+        self.num_queries = num_latents
+        self.num_frame = num_frame
+        self.condition_dim = condition_dim
+
+        self.goal_emb = nn.Sequential(
+            nn.Linear(condition_dim, dim * 2),
+            nn.GELU(),
+            nn.Linear(dim * 2, dim)
+        )
+        seq_len = num_latents // num_frame
+        self.latents = nn.Parameter(torch.randn(num_frame, seq_len, dim))  # type: ignore[reportPrivateUsage]
+        self.time_pos_emb = nn.Parameter(torch.randn(num_time_embeds, 1, dim))  # type: ignore[reportPrivateUsage]
+
+        self.layers = nn.ModuleList([])
+        for _ in range(depth):
+            self.layers.append(
+                nn.ModuleList(
+                    [
+                        PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                        feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                    ]
+                )
+            )
+
+        # Layer normalization takes as input the query vector length
+        self.norm = nn.LayerNorm(dim)
+
+        self._update_trainable_state(trainable)
+
+    def _update_trainable_state(self, trainable: bool = True):
+        for param in self.parameters():
+            param.requires_grad = trainable
+
+    def forward(self, x_f: torch.Tensor, mask: torch.BoolTensor = None):
+        """Run perceiver resampler on the input visual embeddings
+
+        Args:
+            x_f: Input visual embeddings of shape (batch_size, n_frames, n_features, d_visual)
+            mask: Mask for the input visual embeddings of shape (batch_size, n_frames)
+
+        Returns:
+            Resampler features of shape (batch_size, num_queries, d_visual)
+        """
+        assert x_f.ndim == 4
+
+        batch_size, max_length, _, dim = x_f.shape
+
+        assert dim == self.condition_dim
+
+        # Mask the position embeddings for the padded frames
+        time_pos_emb = (
+            self.time_pos_emb[:max_length].unsqueeze(0).expand(batch_size, -1, -1, -1)
+        )  # [batch_size, max_length, 1, dim]
+        if mask is not None:
+            time_pos_emb = time_pos_emb * mask.unsqueeze(-1).unsqueeze(-1)
+
+        # Apply the position embeddings
+        x_f = self.goal_emb(x_f)
+        x_f = x_f + time_pos_emb
+
+        # Flatten the frames
+        x_f = rearrange(x_f, 'b T n d -> (b T) n d')
+
+        # Copy the latents for every element in the batch
+        x = repeat(self.latents, 'T q d -> b T q d', b=batch_size)
+        x = rearrange(x, 'b T q d -> (b T) q d')
+
+        # Apply attention and feed forward layer
+        for attn, ffw in self.layers:
+            x = x + attn(x_f, x)
+            x = x + ffw(x)
+
+        #x = rearrange(x, 'l q d -> b T q d', b=batch_size)
+        x = x.reshape(batch_size, -1 ,x.shape[1],x.shape[2])
+        x = rearrange(x, 'b T q d -> b (T q) d')
+        assert x.shape == torch.Size([batch_size, self.num_queries, self.dim])
+        norm = self.norm(x)
+
+        return norm

code/policy_models/module/Video_Former copy.py

@@ -0,0 +1,554 @@
+# This code is referenced from https://github.com/dhansmair/flamingo-mini
+
+import torch
+from einops import rearrange, repeat
+from einops_exts import rearrange_many
+from torch import einsum, nn
+import torch.nn.functional as F
+
+from policy_models.module.transformers.utils import feed_forward_layer
+
+class Attention(nn.Module):
+    def __init__(
+            self,
+            dim: int,
+            num_heads: int = 8,
+            use_cross_attn=False,
+            y_dim=512,
+            qkv_bias: bool = False,
+            qk_norm: bool = False,
+            attn_drop: float = 0.,
+            proj_drop: float = 0.,
+            norm_layer: nn.Module = nn.LayerNorm,
+            attn_mask = None,
+    ) -> None:
+        super().__init__()
+        assert dim % num_heads == 0, 'dim should be divisible by num_heads'
+        self.num_heads = num_heads
+        self.head_dim = dim // num_heads
+        self.scale = self.head_dim ** -0.5
+        self.fused_attn = True
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.q_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+        self.k_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+        self.attn_mask = attn_mask
+        self.use_cross_attn=use_cross_attn
+        if self.use_cross_attn:
+            #print('use_cross_attn')
+            self.y_kv = nn.Linear(y_dim, dim * 2, bias=qkv_bias)
+            self.y_k_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+            self.gate = nn.Parameter(torch.zeros([self.num_heads]))
+
+    def forward(self, x: torch.Tensor, y=None, attn_mask=None) -> torch.Tensor:
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv.unbind(0)
+        q, k = self.q_norm(q), self.k_norm(k)
+
+
+        if self.fused_attn:
+            runtime_mask = None
+            if attn_mask is not None:
+                runtime_mask = attn_mask.to(x.device)
+            elif self.attn_mask is not None:
+                runtime_mask = self.attn_mask.to(x.device)[:q.shape[2],:k.shape[2]]
+            x = F.scaled_dot_product_attention(
+                q, k, v,
+                dropout_p=self.attn_drop.p if self.training else 0.,
+                attn_mask=runtime_mask
+            )
+        else:
+            q = q * self.scale
+            attn = q @ k.transpose(-2, -1)
+            attn = attn.softmax(dim=-1)
+            attn = self.attn_drop(attn)
+            x = attn @ v
+
+        if self.use_cross_attn:
+            #print('y_shape:',y.shape)
+            N_y = y.shape[1]
+            y_kv = self.y_kv(y).reshape(B, N_y, 2, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+            y_k, y_v = y_kv.unbind(0)
+            y_k = self.y_k_norm(y_k)
+            y_out = F.scaled_dot_product_attention(
+                q, y_k, y_v,
+                dropout_p=self.attn_drop.p if self.training else 0.,
+            )
+            #print('y_out_shape:', y_out.shape)
+            y_out = y_out*self.gate.tanh().view(1, -1, 1, 1)
+            x = x + y_out
+
+        x = x.transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+class PerceiverAttentionLayer(nn.Module):
+    """Perceiver Attention Layer"""
+
+    def __init__(self, dim: int, dim_head: int = 64, heads: int = 8):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        self.dim_head = dim_head
+        inner_dim = dim_head * heads
+
+        # trainable components of PerceiverAttentionLayer
+        self.norm_media = nn.LayerNorm(dim)
+        self.norm_latents = nn.LayerNorm(dim)
+
+        self.to_q = nn.Linear(dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(dim, inner_dim, bias=False)
+        self.to_out = nn.Linear(inner_dim, dim, bias=False)
+
+    def forward(self, features, latents):
+        """Latent vectors are cross-attending to the visual features x
+
+        Args:
+            features: Batch of visual features with shape (batch_size, n_features, dim)
+            latents: Latent learnt vectors which are used to compute queries with shape (batch_size, n_latents, dim)
+
+        Returns:
+            Attention score with shape (batch_size, n_latents, dim)
+        """
+        assert features.ndim == 3
+        assert latents.ndim == 3
+        assert features.shape[0] == latents.shape[0]
+        assert features.shape[2] == latents.shape[2]
+
+        n_heads = self.heads
+        n_batch, n_features, dim = features.shape
+        n_queries = latents.shape[1]
+
+        # Layer normalization
+        x = self.norm_media(features)
+        latents = self.norm_latents(latents)
+
+        # Compute the queries from the latents, for all attention heads simultaneously
+        q = self.to_q(latents)
+        q = rearrange(q, 'b q (h d) -> b h q d', h=n_heads)
+        assert q.shape == torch.Size([n_batch, n_heads, n_queries, self.dim_head])
+
+        # Keys and values for all attention heads
+        kv_input = torch.cat((x, latents), dim=-2)
+        n_features_latents = n_features + n_queries
+        k = self.to_k(kv_input)
+        v = self.to_v(kv_input)
+
+        k, v = rearrange_many((k, v), 'b f (h d) -> b h f d', h=n_heads)
+        assert v.shape == torch.Size([n_batch, n_heads, n_features_latents, self.dim_head])
+
+        q = q * self.scale
+
+        # Attention scores
+        sim = einsum('b h q d, b h f d -> b h q f', q, k)
+        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
+        alphas = sim.softmax(dim=-1)
+
+        out = einsum('b h q f, b h f v -> b h q v', alphas, v)
+        out = rearrange(out, 'b h q v -> b q (h v)')
+
+        return self.to_out(out)
+
+class TempAttentionLayer(nn.Module):
+    """Perceiver Attention Layer"""
+
+    def __init__(self, dim: int, dim_head: int = 64, heads: int = 8):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        self.dim_head = dim_head
+        inner_dim = dim_head * heads
+
+        # trainable components of PerceiverAttentionLayer
+        self.norm_media = nn.LayerNorm(dim)
+
+        self.to_q = nn.Linear(dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(dim, inner_dim, bias=False)
+        self.to_out = nn.Linear(inner_dim, dim, bias=False)
+
+    def forward(self, features):
+        """Latent vectors are cross-attending to the visual features x
+
+        Args:
+            features: Batch of visual features with shape (batch_size, n_features, dim)
+            latents: Latent learnt vectors which are used to compute queries with shape (batch_size, n_latents, dim)
+
+        Returns:
+            Attention score with shape (batch_size, n_latents, dim)
+        """
+        assert features.ndim == 3
+
+        n_heads = self.heads
+        n_batch, n_features, dim = features.shape
+        n_queries = features.shape[1]
+
+        # Layer normalization
+        x = self.norm_media(features)
+
+        # Compute the queries from the latents, for all attention heads simultaneously
+        q = self.to_q(x)
+        q = rearrange(q, 'b q (h d) -> b h q d', h=n_heads)
+        assert q.shape == torch.Size([n_batch, n_heads, n_queries, self.dim_head])
+
+        # Keys and values for all attention heads
+        n_features_latents = n_features
+        k = self.to_k(x)
+        v = self.to_v(x)
+
+        k, v = rearrange_many((k, v), 'b f (h d) -> b h f d', h=n_heads)
+        assert v.shape == torch.Size([n_batch, n_heads, n_features_latents, self.dim_head])
+
+        q = q * self.scale
+
+        # Attention scores
+        sim = einsum('b h q d, b h f d -> b h q f', q, k)
+        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
+        alphas = sim.softmax(dim=-1)
+
+        out = einsum('b h q f, b h f v -> b h q v', alphas, v)
+        out = rearrange(out, 'b h q v -> b q (h v)')
+
+        return self.to_out(out)
+
+
+class Video_Former_3D(nn.Module):
+    """Perceiver Resampler with multi-head attention layer"""
+
+    def __init__(
+            self,
+            dim: int,
+            depth: int,
+            condition_dim: int = 1280,
+            dim_head: int = 64,
+            heads: int = 8,
+            num_latents: int = 64,
+            num_frame: int = 14,
+            num_time_embeds: int = 4,
+            ff_mult: int = 4,
+            activation: str = 'gelu',
+            trainable: bool = True,
+            use_temporal: bool = False,
+    ):
+        super().__init__()
+
+        self.dim = dim
+        self.num_queries = num_latents
+        self.num_frame = num_frame
+        self.condition_dim = condition_dim
+        self.use_temporal = use_temporal
+        self.input_mask_mode = 'zero' # 'none' | 'zero' | 'gaussian' | 'learnable'
+
+        self.goal_emb = nn.Sequential(
+            nn.Linear(condition_dim, dim * 2),
+            nn.GELU(),
+            nn.Linear(dim * 2, dim)
+        )
+        
+        # 语言嵌入层（将512维语言向量映射到与视觉相同的dim）
+        # self.lang_emb = nn.Linear(512, dim)
+        
+        frame_seq_len = num_latents // num_frame
+        self.latents = nn.Parameter(torch.randn(self.num_frame, frame_seq_len, dim))  # type: ignore[reportPrivateUsage]
+        self.time_pos_emb = nn.Parameter(torch.randn(num_time_embeds, 1, dim))  # type: ignore[reportPrivateUsage]
+        attn_mask = torch.ones((num_frame, num_frame))
+        #attn_mask = torch.tril(attn_mask).bool()
+
+        self.layers = nn.ModuleList([])
+
+        if self.use_temporal:
+            for _ in range(depth):
+                self.layers.append(
+                    nn.ModuleList(
+                        [
+                            PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            #TempAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            Attention(dim, num_heads=heads, qkv_bias=True, use_cross_attn=False,
+                                      y_dim=512, attn_mask=attn_mask),
+                            feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                        ]
+                    )
+                )
+        else:
+            for _ in range(depth):
+                self.layers.append(
+                    nn.ModuleList(
+                        [
+                            PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                        ]
+                    )
+                )
+
+        # Layer normalization takes as input the query vector length
+        self.norm = nn.LayerNorm(dim)
+
+        self._update_trainable_state(trainable)
+
+        # learnable frame token (used when input_mask_mode == 'learnable')
+        if self.input_mask_mode == 'learnable':
+            # shape: (1, 1, n_features, dim) after goal_emb
+            self.learnable_mask_token = nn.Parameter(torch.zeros(1, 1, 1, dim))
+
+    def _update_trainable_state(self, trainable: bool = True):
+        for param in self.parameters():
+            param.requires_grad = trainable
+
+    def forward(self, x_f: torch.Tensor, mask: torch.BoolTensor = None, extra : torch.Tensor = None, frame_mask_prob: float = 0.0, language: torch.Tensor = None):
+        """Run perceiver resampler on the input visual embeddings
+
+        Args:
+            x_f: Input visual embeddings of shape (batch_size, n_frames, n_features, d_visual)
+            mask: Mask for the input visual embeddings of shape (batch_size, n_frames)
+            extra: Extra tensor for concatenation
+            frame_mask_prob: Probability of masking each frame during training (0.0 = no masking)
+            language: Language embeddings of shape (batch_size, 1, lang_dim)
+
+        Returns:
+            Resampler features of shape (batch_size, num_queries, d_visual)
+        """
+        assert x_f.ndim == 4
+        batch_size, max_length, _, dim = x_f.shape
+
+        # Generate per-batch frame mask (True=keep, False=mask) with non-uniform probability centered at index 6
+        frame_mask = None
+        if frame_mask_prob > 1.0 and self.training:
+            # per-frame mask probabilities p_i: highest at center_idx=6, decays with distance
+            center_idx = 6 if max_length > 6 else (max_length // 2)
+            frame_indices = torch.arange(max_length, device=x_f.device).float()
+            distances = (frame_indices - float(center_idx)).abs()
+            sigma = 2.0
+            # Gaussian decay: p_i = frame_mask_prob * exp(-0.5 * (d/sigma)^2)
+            per_frame_p = frame_mask_prob * torch.exp(-0.5 * (distances / sigma) ** 2)
+            # broadcast to batch and sample Bernoulli per (b, t)
+            rand_vals = torch.rand(batch_size, max_length, device=x_f.device)
+            # True=keep, False=mask
+            frame_mask = rand_vals > per_frame_p.unsqueeze(0)
+            # ensure at least one frame kept per sample
+            needs_fix = frame_mask.sum(dim=1) == 0
+            if needs_fix.any():
+                idx = torch.nonzero(needs_fix, as_tuple=False).squeeze(-1)
+                rand_cols = torch.randint(0, max_length, (idx.numel(),), device=x_f.device)
+                frame_mask[idx, rand_cols] = True
+
+        # Mask the position embeddings for the padded frames
+        time_pos_emb = (
+            self.time_pos_emb[:max_length].unsqueeze(0).expand(batch_size, -1, -1, -1)
+        )  # [batch_size, max_length, 1, dim]
+        if mask is not None:
+            time_pos_emb = time_pos_emb * mask.unsqueeze(-1).unsqueeze(-1)
+
+        # Apply the position embeddings
+        x_f = self.goal_emb(x_f)
+        # Frame-level input masking before adding positional encoding
+        if frame_mask is not None:
+            bsz = batch_size
+            T = max_length
+            n_features = x_f.shape[2]
+            d = x_f.shape[3]
+            mask_expand = frame_mask.unsqueeze(-1).unsqueeze(-1).expand(bsz, T, n_features, d)
+            if self.input_mask_mode == 'zero':
+                x_f = torch.where(mask_expand, x_f, torch.zeros_like(x_f))
+            elif self.input_mask_mode == 'gaussian':
+                noise = torch.randn_like(x_f)
+                x_f = torch.where(mask_expand, x_f, noise)
+            elif self.input_mask_mode == 'learnable':
+                token = self.learnable_mask_token
+                token = token.expand(bsz, T, n_features, d)
+                x_f = torch.where(mask_expand, x_f, token)
+            # 'none' -> do nothing
+        # 融合语言：将 language (b,1,512) 投影到dim，并按帧复制后拼接为额外特征
+        # if language is not None:
+        #     lang = self.lang_emb(language.squeeze(1))  # (b, dim)
+        #     lang = lang.unsqueeze(1)  # (b,1,dim)
+        #     lang = repeat(lang, 'b q d -> b T q d', T=max_length)  # (b,T,1,dim)
+        #     x_f = torch.cat([x_f, lang], dim=2)
+        if extra is not None:
+            extra = repeat(extra, 'b q d -> b T q d', T=max_length)
+            x_f = torch.cat([x_f, extra],dim = 2)
+        x_f = x_f + time_pos_emb
+
+        # Apply Token Masking Augmentation (TMAug) - frame dropping on temporal dimension
+        dropped_indices = None
+        if frame_mask_prob > 0.0 and self.training:
+            b, T, n, d = x_f.shape
+            
+            # Randomly select frames to drop
+            num_to_remove = int(T * frame_mask_prob)
+            if num_to_remove > 0 and num_to_remove < T:
+                # Randomly select frame indices to remove
+                indices_to_remove = torch.randperm(T, device=x_f.device)[:num_to_remove]
+                keep_mask = torch.ones(T, dtype=torch.bool, device=x_f.device)
+                keep_mask[indices_to_remove] = False
+                dropped_indices = indices_to_remove
+                
+                # Apply frame dropping
+                x_f = x_f[:, keep_mask, :, :]  # (b, T_new, n, d)
+
+
+        # Flatten the frames
+        x_f = rearrange(x_f, 'b T n d -> (b T) n d')
+
+        # Get actual time dimension after dropping
+        actual_T = x_f.shape[0] // batch_size  # (b*T_new) // b = T_new
+
+        # Copy the latents for every element in the batch
+        # x = repeat(self.latents, 'T q d -> b T q d', b=batch_size)
+        # Copy the latents for every element in the batch, matching the actual time dimension
+        if dropped_indices is not None:
+            # Apply the same dropping to latents
+            latents_keep_mask = torch.ones(self.num_frame, dtype=torch.bool, device=x_f.device)
+            latents_keep_mask[dropped_indices] = False
+            latents_after_drop = self.latents[latents_keep_mask]  # (T_new, q, d)
+            x = repeat(latents_after_drop, 'T q d -> b T q d', b=batch_size)
+        else:
+            # No dropping, use original latents
+            x = repeat(self.latents, 'T q d -> b T q d', b=batch_size)
+
+        x = rearrange(x, 'b T q d -> (b T) q d')
+
+        # Apply attention and feed forward layer
+        if self.use_temporal:
+            for attn, Temp_attn, ffw in self.layers:
+                x = x + attn(x_f, x)
+                x = rearrange(x, '(b T) q d -> (b q) T d', b = batch_size)
+                # build per-batch temporal attention mask if frame_mask is provided
+                runtime_temporal_mask = None
+                if frame_mask is not None:
+                    # frame_mask: (b, T) True=keep, False=mask
+                    keep = frame_mask  # (b, T)
+                    # expand along batch for each latent query: current batch for attention is (b * q)
+                    q_per_frame = x.shape[0] // batch_size
+                    # construct (b, 1, 1, T) -> (b*q, 1, 1, T)
+                    mask_bt = keep.unsqueeze(1).unsqueeze(2)  # (b,1,1,T)
+                    runtime_temporal_mask = mask_bt.repeat_interleave(q_per_frame, dim=0)  # (b*q,1,1,T)
+                    # convert to additive mask with 0 for keep and -inf for masked
+                    runtime_temporal_mask = runtime_temporal_mask.to(x.dtype)
+                    runtime_temporal_mask = torch.where(
+                        runtime_temporal_mask > 0,
+                        torch.zeros_like(runtime_temporal_mask),
+                        torch.full_like(runtime_temporal_mask, -1e9)
+                    )
+                x = x + Temp_attn(x, attn_mask=runtime_temporal_mask)
+                x = rearrange(x, '(b q) T d -> (b T) q d', b = batch_size)
+                x = x + ffw(x)
+        else:
+            for attn, ffw in self.layers:
+                x = x + attn(x_f, x)
+                x = x + ffw(x)
+
+        #x = rearrange(x, 'l q d -> b T q d', b=batch_size)
+        x = x.reshape(batch_size, actual_T, x.shape[1],x.shape[2])
+        x = rearrange(x, 'b T q d -> b (T q) d')
+        # assert x.shape == torch.Size([batch_size, self.num_queries, self.dim])
+        expected_queries = actual_T * (self.num_queries // self.num_frame)
+        assert x.shape == torch.Size([batch_size, expected_queries, self.dim])
+        norm = self.norm(x)
+
+        return norm
+
+class Video_Former_2D(nn.Module):
+    """Perceiver Resampler with multi-head attention layer"""
+
+    def __init__(
+            self,
+            dim: int,
+            depth: int,
+            condition_dim: int = 1280,
+            dim_head: int = 64,
+            heads: int = 8,
+            num_latents: int = 64,
+            num_frame: int = 16,
+            num_time_embeds: int = 4,
+            ff_mult: int = 4,
+            activation: str = 'gelu',
+            trainable: bool = True,
+    ):
+        super().__init__()
+
+        self.dim = dim
+        self.num_queries = num_latents
+        self.num_frame = num_frame
+        self.condition_dim = condition_dim
+
+        self.goal_emb = nn.Sequential(
+            nn.Linear(condition_dim, dim * 2),
+            nn.GELU(),
+            nn.Linear(dim * 2, dim)
+        )
+        seq_len = num_latents // num_frame
+        self.latents = nn.Parameter(torch.randn(num_frame, seq_len, dim))  # type: ignore[reportPrivateUsage]
+        self.time_pos_emb = nn.Parameter(torch.randn(num_time_embeds, 1, dim))  # type: ignore[reportPrivateUsage]
+
+        self.layers = nn.ModuleList([])
+        for _ in range(depth):
+            self.layers.append(
+                nn.ModuleList(
+                    [
+                        PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                        feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                    ]
+                )
+            )
+
+        # Layer normalization takes as input the query vector length
+        self.norm = nn.LayerNorm(dim)
+
+        self._update_trainable_state(trainable)
+
+    def _update_trainable_state(self, trainable: bool = True):
+        for param in self.parameters():
+            param.requires_grad = trainable
+
+    def forward(self, x_f: torch.Tensor, mask: torch.BoolTensor = None):
+        """Run perceiver resampler on the input visual embeddings
+
+        Args:
+            x_f: Input visual embeddings of shape (batch_size, n_frames, n_features, d_visual)
+            mask: Mask for the input visual embeddings of shape (batch_size, n_frames)
+
+        Returns:
+            Resampler features of shape (batch_size, num_queries, d_visual)
+        """
+        assert x_f.ndim == 4
+
+        batch_size, max_length, _, dim = x_f.shape
+
+        assert dim == self.condition_dim
+
+        # Mask the position embeddings for the padded frames
+        time_pos_emb = (
+            self.time_pos_emb[:max_length].unsqueeze(0).expand(batch_size, -1, -1, -1)
+        )  # [batch_size, max_length, 1, dim]
+        if mask is not None:
+            time_pos_emb = time_pos_emb * mask.unsqueeze(-1).unsqueeze(-1)
+
+        # Apply the position embeddings
+        x_f = self.goal_emb(x_f)
+        x_f = x_f + time_pos_emb
+
+        # Flatten the frames
+        x_f = rearrange(x_f, 'b T n d -> (b T) n d')
+
+        # Copy the latents for every element in the batch
+        x = repeat(self.latents, 'T q d -> b T q d', b=batch_size)
+        x = rearrange(x, 'b T q d -> (b T) q d')
+
+        # Apply attention and feed forward layer
+        for attn, ffw in self.layers:
+            x = x + attn(x_f, x)
+            x = x + ffw(x)
+
+        #x = rearrange(x, 'l q d -> b T q d', b=batch_size)
+        x = x.reshape(batch_size, -1 ,x.shape[1],x.shape[2])
+        x = rearrange(x, 'b T q d -> b (T q) d')
+        assert x.shape == torch.Size([batch_size, self.num_queries, self.dim])
+        norm = self.norm(x)
+
+        return norm

code/policy_models/module/Video_Former.py

@@ -0,0 +1,670 @@
+# This code is referenced from https://github.com/dhansmair/flamingo-mini
+
+import torch
+from einops import rearrange, repeat
+from einops_exts import rearrange_many
+from torch import einsum, nn
+import torch.nn.functional as F
+
+from policy_models.module.transformers.utils import feed_forward_layer
+
+class Attention(nn.Module):
+    def __init__(
+            self,
+            dim: int,
+            num_heads: int = 8,
+            use_cross_attn=False,
+            y_dim=512,
+            qkv_bias: bool = False,
+            qk_norm: bool = False,
+            attn_drop: float = 0.,
+            proj_drop: float = 0.,
+            norm_layer: nn.Module = nn.LayerNorm,
+            attn_mask = None,
+    ) -> None:
+        super().__init__()
+        assert dim % num_heads == 0, 'dim should be divisible by num_heads'
+        self.num_heads = num_heads
+        self.head_dim = dim // num_heads
+        self.scale = self.head_dim ** -0.5
+        self.fused_attn = True
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.q_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+        self.k_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+        self.attn_mask = attn_mask
+        self.use_cross_attn=use_cross_attn
+        if self.use_cross_attn:
+            #print('use_cross_attn')
+            self.y_kv = nn.Linear(y_dim, dim * 2, bias=qkv_bias)
+            self.y_k_norm = norm_layer(self.head_dim) if qk_norm else nn.Identity()
+            self.gate = nn.Parameter(torch.zeros([self.num_heads]))
+
+    def forward(self, x: torch.Tensor, y=None, attn_mask=None) -> torch.Tensor:
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv.unbind(0)
+        q, k = self.q_norm(q), self.k_norm(k)
+
+        # TODO: whether to use attn_mask
+        if self.fused_attn:
+            runtime_mask = None
+            if attn_mask is not None:
+                runtime_mask = attn_mask.to(x.device)
+            elif self.attn_mask is not None:
+                runtime_mask = self.attn_mask.to(x.device)[:q.shape[2],:k.shape[2]]
+            x = F.scaled_dot_product_attention(
+                q, k, v,
+                dropout_p=self.attn_drop.p if self.training else 0.,
+                attn_mask=runtime_mask
+            )
+        else:
+            q = q * self.scale
+            attn = q @ k.transpose(-2, -1)
+            attn = attn.softmax(dim=-1)
+            attn = self.attn_drop(attn)
+            x = attn @ v
+
+        if self.use_cross_attn:
+            #print('y_shape:',y.shape)
+            N_y = y.shape[1]
+            y_kv = self.y_kv(y).reshape(B, N_y, 2, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
+            y_k, y_v = y_kv.unbind(0)
+            y_k = self.y_k_norm(y_k)
+            y_out = F.scaled_dot_product_attention(
+                q, y_k, y_v,
+                dropout_p=self.attn_drop.p if self.training else 0.,
+            )
+            #print('y_out_shape:', y_out.shape)
+            y_out = y_out*self.gate.tanh().view(1, -1, 1, 1)
+            x = x + y_out
+
+        x = x.transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+class PerceiverAttentionLayer(nn.Module):
+    """Perceiver Attention Layer"""
+
+    def __init__(self, dim: int, dim_head: int = 64, heads: int = 8):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        self.dim_head = dim_head
+        inner_dim = dim_head * heads
+
+        # trainable components of PerceiverAttentionLayer
+        self.norm_media = nn.LayerNorm(dim)
+        self.norm_latents = nn.LayerNorm(dim)
+
+        self.to_q = nn.Linear(dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(dim, inner_dim, bias=False)
+        self.to_out = nn.Linear(inner_dim, dim, bias=False)
+
+    def forward(self, features, latents):
+        """Latent vectors are cross-attending to the visual features x
+
+        Args:
+            features: Batch of visual features with shape (batch_size, n_features, dim)
+            latents: Latent learnt vectors which are used to compute queries with shape (batch_size, n_latents, dim)
+
+        Returns:
+            Attention score with shape (batch_size, n_latents, dim)
+        """
+        assert features.ndim == 3
+        assert latents.ndim == 3
+        assert features.shape[0] == latents.shape[0]
+        assert features.shape[2] == latents.shape[2]
+
+        n_heads = self.heads
+        n_batch, n_features, dim = features.shape
+        n_queries = latents.shape[1]
+
+        # Layer normalization
+        x = self.norm_media(features)
+        latents = self.norm_latents(latents)
+
+        # Compute the queries from the latents, for all attention heads simultaneously
+        q = self.to_q(latents)
+        q = rearrange(q, 'b q (h d) -> b h q d', h=n_heads)
+        assert q.shape == torch.Size([n_batch, n_heads, n_queries, self.dim_head])
+
+        # Keys and values for all attention heads
+        kv_input = torch.cat((x, latents), dim=-2)
+        n_features_latents = n_features + n_queries
+        k = self.to_k(kv_input)
+        v = self.to_v(kv_input)
+
+        k, v = rearrange_many((k, v), 'b f (h d) -> b h f d', h=n_heads)
+        assert v.shape == torch.Size([n_batch, n_heads, n_features_latents, self.dim_head])
+
+        q = q * self.scale
+
+        # Attention scores
+        sim = einsum('b h q d, b h f d -> b h q f', q, k)
+        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
+        alphas = sim.softmax(dim=-1)
+
+        out = einsum('b h q f, b h f v -> b h q v', alphas, v)
+        out = rearrange(out, 'b h q v -> b q (h v)')
+
+        return self.to_out(out)
+
+class TempAttentionLayer(nn.Module):
+    """Perceiver Attention Layer"""
+
+    def __init__(self, dim: int, dim_head: int = 64, heads: int = 8):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        self.dim_head = dim_head
+        inner_dim = dim_head * heads
+
+        # trainable components of PerceiverAttentionLayer
+        self.norm_media = nn.LayerNorm(dim)
+
+        self.to_q = nn.Linear(dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(dim, inner_dim, bias=False)
+        self.to_out = nn.Linear(inner_dim, dim, bias=False)
+
+    def forward(self, features):
+        """Latent vectors are cross-attending to the visual features x
+
+        Args:
+            features: Batch of visual features with shape (batch_size, n_features, dim)
+            latents: Latent learnt vectors which are used to compute queries with shape (batch_size, n_latents, dim)
+
+        Returns:
+            Attention score with shape (batch_size, n_latents, dim)
+        """
+        assert features.ndim == 3
+
+        n_heads = self.heads
+        n_batch, n_features, dim = features.shape
+        n_queries = features.shape[1]
+
+        # Layer normalization
+        x = self.norm_media(features)
+
+        # Compute the queries from the latents, for all attention heads simultaneously
+        q = self.to_q(x)
+        q = rearrange(q, 'b q (h d) -> b h q d', h=n_heads)
+        assert q.shape == torch.Size([n_batch, n_heads, n_queries, self.dim_head])
+
+        # Keys and values for all attention heads
+        n_features_latents = n_features
+        k = self.to_k(x)
+        v = self.to_v(x)
+
+        k, v = rearrange_many((k, v), 'b f (h d) -> b h f d', h=n_heads)
+        assert v.shape == torch.Size([n_batch, n_heads, n_features_latents, self.dim_head])
+
+        q = q * self.scale
+
+        # Attention scores
+        sim = einsum('b h q d, b h f d -> b h q f', q, k)
+        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
+        alphas = sim.softmax(dim=-1)
+
+        out = einsum('b h q f, b h f v -> b h q v', alphas, v)
+        out = rearrange(out, 'b h q v -> b q (h v)')
+
+        return self.to_out(out)
+
+
+class Video_Former_3D(nn.Module):
+    """Perceiver Resampler with multi-head attention layer"""
+
+    def __init__(
+            self,
+            dim: int,
+            depth: int,
+            condition_dim: int = 1280,
+            dim_head: int = 64,
+            heads: int = 8,
+            num_latents: int = 64,
+            num_frame: int = 14,
+            num_time_embeds: int = 4,
+            ff_mult: int = 4,
+            activation: str = 'gelu',
+            trainable: bool = True,
+            use_temporal: bool = False,
+    ):
+        super().__init__()
+
+        self.dim = dim
+        self.num_queries = num_latents
+        self.num_frame = num_frame
+        self.condition_dim = condition_dim
+        self.use_temporal = use_temporal
+        self.input_mask_mode = 'zero' # 'none' | 'zero' | 'gaussian' | 'learnable'
+
+        self.goal_emb = nn.Sequential(
+            nn.Linear(condition_dim, dim * 2),
+            nn.GELU(),
+            nn.Linear(dim * 2, dim)
+        )
+        # self.goal_emb = nn.Sequential(
+        #     nn.Linear(condition_dim, dim),
+        #     nn.LayerNorm(dim),
+        # )
+        frame_seq_len = num_latents // num_frame
+        self.latents = nn.Parameter(torch.randn(self.num_frame, frame_seq_len, dim))  # type: ignore[reportPrivateUsage]
+        self.time_pos_emb = nn.Parameter(torch.randn(num_time_embeds, 1, dim))  # type: ignore[reportPrivateUsage]
+        attn_mask = torch.ones((num_frame, num_frame))
+        #attn_mask = torch.tril(attn_mask).bool()
+
+        self.layers = nn.ModuleList([])
+
+        if self.use_temporal:
+            for _ in range(depth):
+                self.layers.append(
+                    nn.ModuleList(
+                        [
+                            PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            #TempAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            Attention(dim, num_heads=heads, qkv_bias=True, use_cross_attn=False,
+                                      y_dim=512, attn_mask=attn_mask),
+                            feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                        ]
+                    )
+                )
+        else:
+            for _ in range(depth):
+                self.layers.append(
+                    nn.ModuleList(
+                        [
+                            PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                        ]
+                    )
+                )
+
+        # Layer normalization takes as input the query vector length
+        self.norm = nn.LayerNorm(dim)
+
+        self._update_trainable_state(trainable)
+
+        # learnable frame token (used when input_mask_mode == 'learnable')
+        if self.input_mask_mode == 'learnable':
+            # shape: (1, 1, n_features, dim) after goal_emb
+            self.learnable_mask_token = nn.Parameter(torch.zeros(1, 1, 1, dim))
+
+    def _update_trainable_state(self, trainable: bool = True):
+        for param in self.parameters():
+            param.requires_grad = trainable
+
+    def forward(self, x_f: torch.Tensor, mask: torch.BoolTensor = None, extra : torch.Tensor = None, frame_mask_prob: float = 0.0, language: torch.Tensor = None):
+        """Run perceiver resampler on the input visual embeddings
+
+        Args:
+            x_f: Input visual embeddings of shape (batch_size, n_frames, n_features, d_visual)
+            mask: Mask for the input visual embeddings of shape (batch_size, n_frames)
+            extra: Extra tensor for concatenation
+            frame_mask_prob: Probability of masking each frame during training (0.0 = no masking)
+            language: Language embeddings of shape (batch_size, 1, lang_dim)
+
+        Returns:
+            Resampler features of shape (batch_size, num_queries, d_visual)
+        """
+        assert x_f.ndim == 4
+
+        batch_size, max_length, _, dim = x_f.shape
+
+        # Generate per-batch frame mask (True=keep, False=mask) with non-uniform probability centered at index 6
+        frame_mask = None
+        if frame_mask_prob > 0.0 and self.training:
+            # per-frame mask probabilities p_i: highest at center_idx=6, decays with distance
+            center_idx = 6 if max_length == 14 else (max_length // 2)
+            frame_indices = torch.arange(max_length, device=x_f.device).float()
+            distances = (frame_indices - float(center_idx)).abs()
+            sigma = 2.0
+            # Gaussian decay: p_i = frame_mask_prob * exp(-0.5 * (d/sigma)^2)
+            per_frame_p = frame_mask_prob * torch.exp(-0.5 * (distances / sigma) ** 2)
+            # broadcast to batch and sample Bernoulli per (b, t)
+            rand_vals = torch.rand(batch_size, max_length, device=x_f.device)
+            # True=keep, False=mask
+            frame_mask = rand_vals > per_frame_p.unsqueeze(0)
+            # ensure at least one frame kept per sample
+            needs_fix = frame_mask.sum(dim=1) == 0
+            if needs_fix.any():
+                idx = torch.nonzero(needs_fix, as_tuple=False).squeeze(-1)
+                rand_cols = torch.randint(0, max_length, (idx.numel(),), device=x_f.device)
+                frame_mask[idx, rand_cols] = True
+
+        # Mask the position embeddings for the padded frames
+        time_pos_emb = (
+            self.time_pos_emb[:max_length].unsqueeze(0).expand(batch_size, -1, -1, -1)
+        )  # [batch_size, max_length, 1, dim]
+        if mask is not None:
+            time_pos_emb = time_pos_emb * mask.unsqueeze(-1).unsqueeze(-1)
+
+        # Apply the position embeddings
+        x_f = self.goal_emb(x_f)
+        # Frame-level input masking before adding positional encoding
+        if frame_mask is not None:
+            bsz = batch_size
+            T = max_length
+            n_features = x_f.shape[2]
+            d = x_f.shape[3]
+            mask_expand = frame_mask.unsqueeze(-1).unsqueeze(-1).expand(bsz, T, n_features, d)
+            if self.input_mask_mode == 'zero':
+                x_f = torch.where(mask_expand, x_f, torch.zeros_like(x_f))
+            elif self.input_mask_mode == 'gaussian':
+                noise = torch.randn_like(x_f)
+                x_f = torch.where(mask_expand, x_f, noise)
+            elif self.input_mask_mode == 'learnable':
+                token = self.learnable_mask_token
+                token = token.expand(bsz, T, n_features, d)
+                x_f = torch.where(mask_expand, x_f, token)
+            # 'none' -> do nothing
+        if extra is not None:
+            extra = repeat(extra, 'b q d -> b T q d', T=max_length)
+            x_f = torch.cat([x_f, extra],dim = 2)
+        x_f = x_f + time_pos_emb
+
+        # Flatten the frames
+        x_f = rearrange(x_f, 'b T n d -> (b T) n d')
+
+        # Copy the latents for every element in the batch
+        x = repeat(self.latents, 'T q d -> b T q d', b=batch_size)
+        x = rearrange(x, 'b T q d -> (b T) q d')
+
+        # Apply attention and feed forward layer
+        if self.use_temporal:
+            for attn, Temp_attn, ffw in self.layers:
+                x = x + attn(x_f, x)
+                x = rearrange(x, '(b T) q d -> (b q) T d', b = batch_size)
+                # build per-batch temporal attention mask if frame_mask is provided
+                runtime_temporal_mask = None
+                if frame_mask is not None:
+                    # frame_mask: (b, T) True=keep, False=mask
+                    keep = frame_mask  # (b, T)
+                    # expand along batch for each latent query: current batch for attention is (b * q)
+                    q_per_frame = x.shape[0] // batch_size
+                    # construct (b, 1, 1, T) -> (b*q, 1, 1, T)
+                    mask_bt = keep.unsqueeze(1).unsqueeze(2)  # (b,1,1,T)
+                    runtime_temporal_mask = mask_bt.repeat_interleave(q_per_frame, dim=0)  # (b*q,1,1,T)
+                    # convert to additive mask with 0 for keep and -inf for masked
+                    runtime_temporal_mask = runtime_temporal_mask.to(x.dtype)
+                    runtime_temporal_mask = torch.where(
+                        runtime_temporal_mask > 0,
+                        torch.zeros_like(runtime_temporal_mask),
+                        torch.full_like(runtime_temporal_mask, -1e9)
+                    )
+                x = x + Temp_attn(x, attn_mask=runtime_temporal_mask)
+                x = rearrange(x, '(b q) T d -> (b T) q d', b = batch_size)
+                x = x + ffw(x)
+        else:
+            for attn, ffw in self.layers:
+                x = x + attn(x_f, x)
+                x = x + ffw(x)
+
+        #x = rearrange(x, 'l q d -> b T q d', b=batch_size)
+        x = x.reshape(batch_size, -1 ,x.shape[1],x.shape[2])
+        x = rearrange(x, 'b T q d -> b (T q) d')
+        assert x.shape == torch.Size([batch_size, self.num_queries, self.dim])
+        norm = self.norm(x)
+
+        return norm
+
+class Video_Former_2D(nn.Module):
+    """Perceiver Resampler with multi-head attention layer"""
+
+    def __init__(
+            self,
+            dim: int,
+            depth: int,
+            condition_dim: int = 1280,
+            dim_head: int = 64,
+            heads: int = 8,
+            num_latents: int = 64,
+            num_frame: int = 16,
+            num_time_embeds: int = 4,
+            ff_mult: int = 4,
+            activation: str = 'gelu',
+            trainable: bool = True,
+    ):
+        super().__init__()
+
+        self.dim = dim
+        self.num_queries = num_latents
+        self.num_frame = num_frame
+        self.condition_dim = condition_dim
+
+        self.goal_emb = nn.Sequential(
+            nn.Linear(condition_dim, dim * 2),
+            nn.GELU(),
+            nn.Linear(dim * 2, dim)
+        )
+        seq_len = num_latents // num_frame
+        self.latents = nn.Parameter(torch.randn(num_frame, seq_len, dim))  # type: ignore[reportPrivateUsage]
+        self.time_pos_emb = nn.Parameter(torch.randn(num_time_embeds, 1, dim))  # type: ignore[reportPrivateUsage]
+
+        self.layers = nn.ModuleList([])
+        for _ in range(depth):
+            self.layers.append(
+                nn.ModuleList(
+                    [
+                        PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                        feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                    ]
+                )
+            )
+
+        # Layer normalization takes as input the query vector length
+        self.norm = nn.LayerNorm(dim)
+
+        self._update_trainable_state(trainable)
+
+    def _update_trainable_state(self, trainable: bool = True):
+        for param in self.parameters():
+            param.requires_grad = trainable
+
+    def forward(self, x_f: torch.Tensor, mask: torch.BoolTensor = None):
+        """Run perceiver resampler on the input visual embeddings
+
+        Args:
+            x_f: Input visual embeddings of shape (batch_size, n_frames, n_features, d_visual)
+            mask: Mask for the input visual embeddings of shape (batch_size, n_frames)
+
+        Returns:
+            Resampler features of shape (batch_size, num_queries, d_visual)
+        """
+        assert x_f.ndim == 4
+
+        batch_size, max_length, _, dim = x_f.shape
+
+        assert dim == self.condition_dim
+
+        # Mask the position embeddings for the padded frames
+        time_pos_emb = (
+            self.time_pos_emb[:max_length].unsqueeze(0).expand(batch_size, -1, -1, -1)
+        )  # [batch_size, max_length, 1, dim]
+        if mask is not None:
+            time_pos_emb = time_pos_emb * mask.unsqueeze(-1).unsqueeze(-1)
+
+        # Apply the position embeddings
+        x_f = self.goal_emb(x_f)
+        x_f = x_f + time_pos_emb
+
+        # Flatten the frames
+        x_f = rearrange(x_f, 'b T n d -> (b T) n d')
+
+        # Copy the latents for every element in the batch
+        x = repeat(self.latents, 'T q d -> b T q d', b=batch_size)
+        x = rearrange(x, 'b T q d -> (b T) q d')
+
+        # Apply attention and feed forward layer
+        for attn, ffw in self.layers:
+            x = x + attn(x_f, x)
+            x = x + ffw(x)
+
+        #x = rearrange(x, 'l q d -> b T q d', b=batch_size)
+        x = x.reshape(batch_size, -1 ,x.shape[1],x.shape[2])
+        x = rearrange(x, 'b T q d -> b (T q) d')
+        assert x.shape == torch.Size([batch_size, self.num_queries, self.dim])
+        norm = self.norm(x)
+
+        return norm
+
+
+
+class Video_Former_3D_vggt(nn.Module):
+    """Perceiver Resampler with multi-head attention layer"""
+
+    def __init__(
+            self,
+            dim: int,
+            depth: int,
+            condition_dim: int = 1280,
+            dim_head: int = 64,
+            heads: int = 8,
+            num_latents: int = 64,
+            num_frame: int = 14,
+            num_time_embeds: int = 4,
+            ff_mult: int = 4,
+            activation: str = 'gelu',
+            trainable: bool = True,
+            use_temporal: bool = False,
+    ):
+        super().__init__()
+
+        self.dim = dim
+        self.num_queries = num_latents
+        self.num_frame = num_frame
+        self.condition_dim = condition_dim
+        self.use_temporal = use_temporal
+        self.input_mask_mode = 'zero' # 'none' | 'zero' | 'gaussian' | 'learnable'
+
+        self.goal_emb = nn.Sequential(
+            nn.Linear(condition_dim, dim * 2),
+            nn.GELU(),
+            nn.Linear(dim * 2, dim)
+        )
+        frame_seq_len = num_latents // num_frame
+        self.latents = nn.Parameter(torch.randn(self.num_frame, frame_seq_len, dim))  # type: ignore[reportPrivateUsage]
+        self.time_pos_emb = nn.Parameter(torch.randn(num_time_embeds, 1, dim))  # type: ignore[reportPrivateUsage]
+        attn_mask = torch.ones((num_frame, num_frame))
+        attn_mask2 = torch.ones((256, 256))
+        #attn_mask = torch.tril(attn_mask).bool()
+
+        self.layers = nn.ModuleList([])
+
+        self.vggt_emb = nn.Sequential(
+            nn.Linear(dim, 2048),
+            nn.GELU(),
+            nn.Linear(2048, 2048)
+        )
+
+
+        self.spatial_attn = Attention(dim, num_heads=heads, qkv_bias=True, use_cross_attn=False,
+                                y_dim=512, attn_mask=attn_mask2)
+        self.temporal_attn = Attention(dim, num_heads=heads, qkv_bias=True, use_cross_attn=False,
+                                y_dim=512, attn_mask=attn_mask)
+        self.feature_ffw = feed_forward_layer(dim=dim, mult=ff_mult, activation=activation)
+
+        if self.use_temporal:
+            for _ in range(depth):
+                self.layers.append(
+                    nn.ModuleList(
+                        [
+                            PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            Attention(dim, num_heads=heads, qkv_bias=True, use_cross_attn=False,
+                                      y_dim=512, attn_mask=attn_mask),
+                            feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                        ]
+                    )
+                )
+        else:
+            for _ in range(depth):
+                self.layers.append(
+                    nn.ModuleList(
+                        [
+                            PerceiverAttentionLayer(dim=dim, dim_head=dim_head, heads=heads),
+                            feed_forward_layer(dim=dim, mult=ff_mult, activation=activation),
+                        ]
+                    )
+                )
+
+        # Layer normalization takes as input the query vector length
+        self.norm = nn.LayerNorm(dim)
+        self.norm_g = nn.LayerNorm(dim)
+
+        self._update_trainable_state(trainable)
+
+        # learnable frame token (used when input_mask_mode == 'learnable')
+        if self.input_mask_mode == 'learnable':
+            # shape: (1, 1, n_features, dim) after goal_emb
+            self.learnable_mask_token = nn.Parameter(torch.zeros(1, 1, 1, dim))
+
+    def _update_trainable_state(self, trainable: bool = True):
+        for param in self.parameters():
+            param.requires_grad = trainable
+
+    def forward(self, x_f: torch.Tensor, mask: torch.BoolTensor = None, extra : torch.Tensor = None, frame_mask_prob: float = 0.0, language: torch.Tensor = None):
+        """Run perceiver resampler on the input visual embeddings
+        Args:
+            x_f: Input visual embeddings of shape (batch_size, n_frames, n_features, d_visual)
+            mask: Mask for the input visual embeddings of shape (batch_size, n_frames)
+            extra: Extra tensor for concatenation
+        Returns:
+            Resampler features of shape (batch_size, num_queries, d_visual)
+        """
+        assert x_f.ndim == 4
+
+        batch_size, max_length, _, dim = x_f.shape
+
+        # Mask the position embeddings for the padded frames
+        time_pos_emb = (
+            self.time_pos_emb[:max_length].unsqueeze(0).expand(batch_size, -1, -1, -1)
+        )  # [batch_size, max_length, 1, dim]
+        if mask is not None:
+            time_pos_emb = time_pos_emb * mask.unsqueeze(-1).unsqueeze(-1)
+
+        # Apply the position embeddings
+        x_f = self.goal_emb(x_f)
+        
+        if extra is not None:
+            extra = repeat(extra, 'b q d -> b T q d', T=max_length)
+            x_f = torch.cat([x_f, extra],dim = 2)
+        x_f = x_f + time_pos_emb
+
+        # Flatten the frames
+        x_f = rearrange(x_f, 'b T n d -> (b T) n d')
+
+        # Copy the latents for every element in the batch
+        x = repeat(self.latents, 'T q d -> b T q d', b=batch_size)
+        x = rearrange(x, 'b T q d -> (b T) q d')
+
+        x_g = x_f + self.spatial_attn(x_f)
+        x_g = rearrange(x_g, '(b T) q d -> (b q) T d', b = batch_size)
+        x_g = x_g + self.temporal_attn(x_g)
+        x_g = rearrange(x_g, '(b q) T d -> (b T) q d', b = batch_size)
+        x_g = x_g + self.feature_ffw(x_g)
+
+        # x_f = torch.cat([x_f, x_g], dim = 1)
+        x_f = x_g
+
+        # Apply attention and feed forward layer
+        for attn, Temp_attn, ffw in self.layers:
+            x = x + attn(x_f, x)
+            x = rearrange(x, '(b T) q d -> (b q) T d', b = batch_size)
+            x = x + Temp_attn(x)
+            x = rearrange(x, '(b q) T d -> (b T) q d', b = batch_size)
+            x = x + ffw(x)
+
+        #x = rearrange(x, 'l q d -> b T q d', b=batch_size)
+        x = x.reshape(batch_size, -1 ,x.shape[1],x.shape[2])
+        x = rearrange(x, 'b T q d -> b (T q) d')
+        assert x.shape == torch.Size([batch_size, self.num_queries, self.dim])
+        norm = self.norm(x)
+        x_g = rearrange(x_g, '(b T) q d -> b T q d', b = batch_size)
+
+        return norm, self.vggt_emb(self.norm_g(x_g))