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)