""" A simple example showing how to add custom observation modalities, and custom observation networks (EncoderCore, ObservationRandomizer, etc.) as well. We also show how to use your custom classes directly in a config, and link them to your environment's observations """ import numpy as np import torch import robomimic from robomimic.models import EncoderCore, Randomizer from robomimic.utils.obs_utils import Modality, ScanModality from robomimic.config.bc_config import BCConfig import robomimic.utils.tensor_utils as TensorUtils # Let's create a new modality to handle observation modalities, which will be interpreted as # single frame images, with raw shape (H, W) in range [0, 255] class CustomImageModality(Modality): # We must define the class string name to reference this modality with the @name attribute name = "custom_image" # We must define two class methods: a processor and an unprocessor method. The processor # method should map the raw observations (a numpy array OR torch tensor) into a form / shape suitable for learning, # and the unprocess method should do the inverse operation @classmethod def _default_obs_processor(cls, obs): # We add a channel dimension and normalize them to be in range [-1, 1] return (obs / 255.0 - 0.5) * 2 @classmethod def _default_obs_unprocessor(cls, obs): # We do the reverse return ((obs / 2) + 0.5) * 255.0 # You can also modify pre-existing modalities as well. Let's say you have scan data that pads the ends with a 0, so we # want to pre-process those scans in a different way. We can specify a custom processor / unprocessor # method that will override the default one (assumes obs are a flat 1D array): def custom_scan_processor(obs): # Trim the padded ends return obs[1:-1] def custom_scan_unprocessor(obs): # Re-add the padding # Note: need to check type return np.concatenate([np.zeros(1), obs, np.zeros(1)]) if isinstance(obs, np.ndarray) else \ torch.concat([torch.zeros(1), obs, torch.zeros(1)]) # Override the default functions for ScanModality ScanModality.set_obs_processor(processor=custom_scan_processor) ScanModality.set_obs_unprocessor(unprocessor=custom_scan_unprocessor) # Let's now create a custom encoding class for the custom image modality class CustomImageEncoderCore(EncoderCore): # For simplicity, this will be a pass-through with some simple kwargs def __init__( self, input_shape, # Required, will be inferred automatically at runtime # Any args below here you can specify arbitrarily welcome_str, ): # Always need to run super init first and pass in input_shape super().__init__(input_shape=input_shape) # Anything else should can be custom to your class # Let's print out the welcome string print(f"Welcome! {welcome_str}") # We need to always specify the output shape from this model, based on a given input_shape def output_shape(self, input_shape=None): # this is just a pass-through, so we return input_shape return input_shape # we also need to specify the forward pass for this network def forward(self, inputs): # just a pass through again return inputs # Let's also create a custom randomizer class for randomizing our observations class CustomImageRandomizer(Randomizer): """ A simple example of a randomizer - we make @num_rand copies of each image in the batch, and add some small uniform noise to each. All randomized images will then get passed through the network, resulting in outputs corresponding to each copy - we will pool these outputs across the copies with a simple average. """ def __init__( self, input_shape, num_rand=1, noise_scale=0.01, ): """ Args: input_shape (tuple, list): shape of input (not including batch dimension) num_rand (int): number of random images to create on each forward pass noise_scale (float): magnitude of uniform noise to apply """ super(CustomImageRandomizer, self).__init__() assert len(input_shape) == 3 # (C, H, W) self.input_shape = input_shape self.num_rand = num_rand self.noise_scale = noise_scale def output_shape_in(self, input_shape=None): """ Function to compute output shape from inputs to this module. Corresponds to the @forward_in operation, where raw inputs (usually observation modalities) are passed in. Args: input_shape (iterable of int): shape of input. Does not include batch dimension. Some modules may not need this argument, if their output does not depend on the size of the input, or if they assume fixed size input. Returns: out_shape ([int]): list of integers corresponding to output shape """ # @forward_in takes (B, C, H, W) -> (B, N, C, H, W) -> (B * N, C, H, W). # since only the batch dimension changes, and @input_shape does not include batch # dimension, we indicate that the non-batch dimensions don't change return list(input_shape) def output_shape_out(self, input_shape=None): """ Function to compute output shape from inputs to this module. Corresponds to the @forward_out operation, where processed inputs (usually encoded observation modalities) are passed in. Args: input_shape (iterable of int): shape of input. Does not include batch dimension. Some modules may not need this argument, if their output does not depend on the size of the input, or if they assume fixed size input. Returns: out_shape ([int]): list of integers corresponding to output shape """ # since the @forward_out operation splits [B * N, ...] -> [B, N, ...] # and then pools to result in [B, ...], only the batch dimension changes, # and so the other dimensions retain their shape. return list(input_shape) def forward_in(self, inputs): """ Make N copies of each image, add random noise to each, and move copies into batch dimension to ensure compatibility with rest of network. """ # note the use of @self.training to ensure no randomization at test-time if self.training: # make N copies of the images [B, C, H, W] -> [B, N, C, H, W] out = TensorUtils.unsqueeze_expand_at(inputs, size=self.num_rand, dim=1) # add random noise to each copy out = out + self.noise_scale * (2. * torch.rand_like(out) - 1.) # reshape [B, N, C, H, W] -> [B * N, C, H, W] to ensure network forward pass is unchanged return TensorUtils.join_dimensions(out, 0, 1) return inputs def forward_out(self, inputs): """ Pools outputs across the copies by averaging them. It does this by splitting the outputs from shape [B * N, ...] -> [B, N, ...] and then averaging across N to result in shape [B, ...] to make sure the network output is consistent with what would have happened if there were no randomization. """ # note the use of @self.training to ensure no randomization at test-time if self.training: batch_size = (inputs.shape[0] // self.num_rand) out = TensorUtils.reshape_dimensions(inputs, begin_axis=0, end_axis=0, target_dims=(batch_size, self.num_rand)) return out.mean(dim=1) return inputs def __repr__(self): """Pretty print network.""" header = '{}'.format(str(self.__class__.__name__)) msg = header + "(input_shape={}, num_rand={}, noise_scale={})".format( self.input_shape, self.num_rand, self.noise_scale) return msg if __name__ == "__main__": # Now, we can directly reference the classes in our config! config = BCConfig() config.observation.encoder.custom_image.core_class = "CustomImageEncoderCore" # Custom class, in string form config.observation.encoder.custom_image.core_kwargs.welcome_str = "hi there!" # Any custom arguments, of any primitive type that is json-able config.observation.encoder.custom_image.obs_randomizer_class = "CustomImageRandomizer" config.observation.encoder.custom_image.obs_randomizer_kwargs.num_rand = 3 config.observation.encoder.custom_image.obs_randomizer_kwargs.noise_scale = 0.05 # We can also directly use this new modality and associate dataset / observation keys with it! config.observation.modalities.obs.custom_image = ["my_image1", "my_image2"] config.observation.modalities.goal.custom_image = ["my_image2", "my_image3"] # Let's view our config print(config) # That's it! Now we can pass this config into our training script, and robomimic will directly use our # custom modality + encoder network