robomimic

https://robomimic.github.io/docs
Admin
robomimic is a framework for robotic imitation learning, offering a comprehensive suite of...
Tokens:92,387
Snippets:1,035
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Robosuite from Source

Source: https://robomimic.github.io/docs/introduction/installation.html

Clones the robosuite repository, navigates into the directory, and installs its requirements. This is recommended for running most robomimic examples and released datasets.

```bash
# From source (recommended)
$ cd <PATH_TO_INSTALL_DIR>
$ git clone https://github.com/ARISE-Initiative/robosuite.git
$ cd robosuite
$ pip install -r requirements.txt

```

--------------------------------

### Install Robosuite from Source

Source: https://robomimic.github.io/docs/sources/introduction/installation.md.txt

Installs the robosuite simulator by cloning the repository and installing dependencies. This is recommended for full compatibility with robomimic examples and datasets.

```shell
# From source (recommended)
$ cd <PATH_TO_INSTALL_DIR>
$ git clone https://github.com/ARISE-Initiative/robosuite.git
$ cd robosuite
$ pip install -r requirements.txt
```

--------------------------------

### Install Robomimic from Source

Source: https://robomimic.github.io/docs/introduction/installation.html

Clones the robomimic repository, navigates into the directory, and installs it in editable mode using pip. This is the recommended installation method.

```bash
$ cd <PATH_TO_YOUR_INSTALL_DIRECTORY>
$ git clone https://github.com/ARISE-Initiative/robomimic.git
$ cd robomimic
$ pip install -e .

```

--------------------------------

### Install Robomimic from Source

Source: https://robomimic.github.io/docs/sources/introduction/installation.md.txt

Installs robomimic by cloning the repository and using pip for an editable install. This is the recommended method for development.

```shell
$ cd <PATH_TO_YOUR_INSTALL_DIRECTORY>
$ git clone https://github.com/ARISE-Initiative/robomimic.git
$ cd robomimic
$ pip install -e .
```

--------------------------------

### VisualCore Initialization Example

Source: https://robomimic.github.io/docs/sources/modules/models.md.txt

Example of initializing a VisualCore module with a ResNet18Conv backbone and SpatialSoftmax pooling. This demonstrates how to configure image input processing, backbone, pooling, and feature dimension.

```python
from robomimic.models.obs_core import VisualCore
from robomimic.models.base_nets import ResNet18Conv, SpatialSoftmax

vis_net = VisualCore(
  input_shape=(3, 224, 224),
  core_class="ResNet18Conv",  # use ResNet18 as the visualcore backbone
  core_kwargs={"pretrained": False, "input_coord_conv": False},  # kwargs for the ResNet18Conv class
  pool_class="SpatialSoftmax",  # use spatial softmax to regularize the model output
  pool_kwargs={"num_kp": 32},  # kwargs for the SpatialSoftmax --- use 32 keypoints
  flatten=True,  # flatten the output of the spatial softmax layer
  feature_dimension=64,  # project the flattened feature into a 64-dim vector through a linear layer 
)
```

--------------------------------

### Install Documentation Dependencies

Source: https://robomimic.github.io/docs/sources/introduction/installation.md.txt

Install the additional requirements for building the documentation locally. This is necessary if you plan to contribute to the repository.

```sh
pip install -r requirements-docs.txt
```

--------------------------------

### Base Config JSON Example

Source: https://robomimic.github.io/docs/sources/tutorials/hyperparam_scan.md.txt

An example of a base configuration JSON file. This file defines the initial settings for an experiment, including algorithm, experiment details, training parameters, and algorithm-specific options.

```json
{
    "algo_name": "bc",
    "experiment": {
        "name": "bc_rnn_hyper",
        "validate": true,
        "save": {
            "enabled": true,
            "every_n_seconds": null,
            "every_n_epochs": 50,
            "epochs": [],
            "on_best_validation": false,
            "on_best_rollout_return": false,
            "on_best_rollout_success_rate": true
        },
        "epoch_every_n_steps": 100,
        "validation_epoch_every_n_steps": 10,
        "rollout": {
            "enabled": true,
            "n": 50,
            "horizon": 400,
            "rate": 50,
            "warmstart": 0,
            "terminate_on_success": true
        }
    },
    "train": {
        "data": "/tmp/test_v15.hdf5",
        "output_dir": "../bc_trained_models",
        "num_data_workers": 0,
        "hdf5_cache_mode": "all",
        "hdf5_use_swmr": true,
        "hdf5_normalize_obs": false,
        "hdf5_filter_key": null,
        "seq_length": 1,
        "goal_mode": null,
        "cuda": true,
        "batch_size": 100,
        "num_epochs": 2000,
        "seed": 1
    },
    "algo": {
        "optim_params": {
            "policy": {
                "learning_rate": {
                    "initial": 0.0001,
                    "decay_factor": 0.1,
                    "epoch_schedule": []
                },
                "regularization": {
                    "L2": 0.0
                }
            }
        },
        "actor_layer_dims": [
            1024,
            1024
        ],
        "gmm": {
            "enabled": false,
            "num_modes": 5,
            "min_std": 0.0001,
            "std_activation": "softplus",
            "low_noise_eval": true
        },
        "rnn": {
            "enabled": false,
            "horizon": 10,
            "hidden_dim": 400,
            "rnn_type": "LSTM",
            "num_layers": 2
        }
    }
}
```

--------------------------------

### Run Training Command (Quick Example)

Source: https://robomimic.github.io/docs/datasets/robomimic_v0.1.html

Executes a training command using a specific configuration file. The training command can be found in the generated shell script.

```bash
# the training command can be found in robomimic/exps/paper/core.sh
# Training results can be viewed at /tmp/experiment_results (--output_dir when generating paper configs).
$ python train.py --config ../exps/paper/core/lift/ph/low_dim/bc_rnn.json
```

--------------------------------

### Install Robosuite via Pip

Source: https://robomimic.github.io/docs/sources/introduction/installation.md.txt

Installs the robosuite simulator directly from PyPI. This is a simpler installation method.

```shell
# Via pip
$ pip install robosuite
```

--------------------------------

### Example: Train BC on Two Datasets

Source: https://robomimic.github.io/docs/sources/tutorials/multi_dataset_training.md.txt

Complete configuration example for training a BC model on two datasets with different weights and normalized sampling.

```python
import robomimic
from robomimic.config import config_factory

# create BC config
config = config_factory(algo_name="bc")

# configure datasets
config.train.data = [
    {
        "path": "expert_demos.hdf5",
        "weight": 2.0,                    # sample expert demos more frequently
    },
    {
        "path": "suboptimal_demos.hdf5",
        "weight": 1.0,
    }
]

# normalize weights by dataset size for balanced sampling
config.train.normalize_weights_by_ds_size = True

# other training settings...
config.train.batch_size = 100
config.train.num_epochs = 1000
```

--------------------------------

### Example Multi-Dataset Training Configuration

Source: https://robomimic.github.io/docs/tutorials/multi_dataset_training.html

An example demonstrating how to configure BC model training on two datasets with different weights and enable weight normalization for balanced sampling. Ensure compatible observation and action spaces across datasets.

```python
import robomimic
from robomimic.config import config_factory

# create BC config
config = config_factory(algo_name="bc")

# configure datasets
config.train.data = [
    {
        "path": "expert_demos.hdf5",
        "weight": 2.0,                    # sample expert demos more frequently
    },
    {
        "path": "suboptimal_demos.hdf5",
        "weight": 1.0,
    }
]

# normalize weights by dataset size for balanced sampling
config.train.normalize_weights_by_ds_size = True

# other training settings...
config.train.batch_size = 100
config.train.num_epochs = 1000

```

--------------------------------

### RoboMimic Train Loop Example

Source: https://robomimic.github.io/docs/sources/modules/algorithms.md.txt

Demonstrates the typical training loop using RoboMimic's Algo class methods. Ensure the model is in train mode before starting.

```python
# @model should be instance of Algo class to use for training
# @data_loader should be instance of torch.utils.data.DataLoader for sampling batches

# train for 50 epochs and 100 gradient steps per epoch
num_epochs = 50
gradient_steps_per_epoch = 100

# ensure model is in train mode
model.set_train()

for epoch in range(1, num_epochs + 1): # epoch numbers start at 1
    # iterator for data_loader - it yields batches
    data_loader_iter = iter(data_loader)

    # record losses
    losses = []

    for _ in range(gradient_steps_per_epoch):

        # load next batch from data loader
        try:
            batch = next(data_loader_iter)
        except StopIteration:
            # data loader ran out of batches - reset and yield first batch
            data_loader_iter = iter(data_loader)
            batch = next(data_loader_iter)

        # process batch for training
        input_batch = model.process_batch_for_training(batch)

        # forward and backward pass
        info = model.train_on_batch(batch=input_batch, epoch=epoch, validate=False)

        # record loss
        step_log = model.log_info(info)
        losses.append(step_log["Loss"])

    # save model
    model_params = model.serialize()
    model_dict = dict(model=model.serialize())
    torch.save(model_dict, /path/to/ckpt.pth)
        
    # do anything model needs to after finishing epoch
    model.on_epoch_end(epoch)
```

--------------------------------

### Visualize Initial Demonstration Frames

Source: https://robomimic.github.io/docs/sources/tutorials/dataset_contents.md.txt

Render only the initial frames of the dataset's demonstrations to a video file. This helps in quickly reviewing the starting states of trajectories.

```bash
python playback_dataset.py --dataset ../../tests/assets/test_v15.hdf5 --first --render_image_names agentview --video_path /tmp/dataset_task_inits.mp4
```

--------------------------------

### Base Config JSON Example

Source: https://robomimic.github.io/docs/tutorials/hyperparam_scan.html

An example of a base configuration JSON file, including experiment name and dataset path. Relevant settings not involved in the scan can be omitted.

```json
{
    "algo_name": "bc",
    "experiment": {
        "name": "bc_rnn_hyper",
        "validate": true,
        "save": {
            "enabled": true,
            "every_n_seconds": null,
            "every_n_epochs": 50,
            "epochs": [],
            "on_best_validation": false,
            "on_best_rollout_return": false,
            "on_best_rollout_success_rate": true
        },
        "epoch_every_n_steps": 100,
        "validation_epoch_every_n_steps": 10,
        "rollout": {
            "enabled": true,
            "n": 50,
            "horizon": 400,
            "rate": 50,
            "warmstart": 0,
            "terminate_on_success": true
        }
    },
    "train": {
        "data": "/tmp/test_v15.hdf5",
        "output_dir": "../bc_trained_models",
        "num_data_workers": 0,
        "hdf5_cache_mode": "all",
        "hdf5_use_swmr": true,
        "hdf5_normalize_obs": false,
        "hdf5_filter_key": null,
        "seq_length": 1,
        "goal_mode": null,
        "cuda": true,
        "batch_size": 100,
        "num_epochs": 2000,
        "seed": 1
    },
    "algo": {
        "optim_params": {
            "policy": {
                "learning_rate": {
                    "initial": 0.0001,
                    "decay_factor": 0.1,
                    "epoch_schedule": []
                },
                "regularization": {
                    "L2": 0.0
                }
            }
        },
        "actor_layer_dims": [
            1024,
            1024
        ],
        "gmm": {
            "enabled": false,
            "num_modes": 5,
            "min_std": 0.0001,
            "std_activation": "softplus",
            "low_noise_eval": true
        },
        "rnn": {
            "enabled": false,
            "horizon": 10,
            "hidden_dim": 400,
            "rnn_type": "LSTM",
            "num_layers": 2
        }
    }
}

```

--------------------------------

### Install Documentation Dependencies

Source: https://robomimic.github.io/docs/introduction/installation.html

Installs additional Python packages required for building the documentation locally. This is necessary for contributing to the repository.

```bash
$ pip install -r requirements-docs.txt

```

--------------------------------

### Creating an ObservationEncoder with VisualCore

Source: https://robomimic.github.io/docs/modules/models.html

Example of manually creating an ObservationEncoder instance by registering an image modality with a VisualCore network and a CropRandomizer. This setup processes image inputs for the encoder.

```python
from robomimic.models.base_nets import MLP
from robomimic.models.obs_core import VisualCore, CropRandomizer
from robomimic.models.obs_nets import ObservationEncoder, ObservationDecoder

obs_encoder = ObservationEncoder(feature_activation=torch.nn.ReLU)

# There are two ways to construct the network for processing a input modality.
# Assume we are processing image input of shape (3, 224, 224).
camera1_shape = [3, 224, 224]

image_randomizer = CropRandomizer(input_shape=camera2_shape, crop_height=200, crop_width=200)

# We will use a reconfigurable image processing backbone VisualCore to process the input image modality
net_class = "VisualCore"  # this is defined in models/base_nets.py

# kwargs for VisualCore network
net_kwargs = {
    "input_shape": camera1_shape,
    "core_class": "ResNet18Conv",  # use ResNet18 as the visualcore backbone
    "core_kwargs": {"pretrained": False, "input_coord_conv": False},
    "pool_class": "SpatialSoftmax",  # use spatial softmax to regularize the model output
    "pool_kwargs": {"num_kp": 32}
}

# register the network for processing the modality
obs_encoder.register_obs_key(
    name="camera1",
    shape=camera1_shape,
    net_class=net_class,
    net_kwargs=net_kwargs,
    randomizers=image_randomizer
)


```

--------------------------------

### Generate Paper Configurations (Quick Example)

Source: https://robomimic.github.io/docs/datasets/robomimic_v0.1.html

Generates JSON configs for running all paper experiments. Training results are viewed at the specified output directory.

```bash
# generate json configs for running all experiments at robomimic/exps/paper
$ python generate_paper_configs.py --output_dir /tmp/experiment_results
```

--------------------------------

### Launch Training with Default Transformer Config

Source: https://robomimic.github.io/docs/sources/tutorials/training_transformers.md.txt

Use this command to start training with the default transformer configuration. Specify your dataset path using the `--dataset` argument.

```bash
python train.py --config ../config/default_templates/bc_transformer.json --dataset /path/to/dataset.hdf5
```

--------------------------------

### Test Robomimic Installation (Debug)

Source: https://robomimic.github.io/docs/sources/introduction/installation.md.txt

Runs a quick debugging training loop to verify that robomimic is installed correctly. Assumes robomimic was installed from source.

```shell
$ cd <PATH_TO_ROBOMIMIC_INSTALL_DIR>
$ python examples/train_bc_rnn.py --debug
```

--------------------------------

### Playback Dataset Trajectories with Rendering

Source: https://robomimic.github.io/docs/sources/tutorials/dataset_contents.md.txt

Visualize dataset trajectories by rendering agent and robot cameras to a video file. This example plays the first 5 trajectories.

```bash
python playback_dataset.py --dataset ../../tests/assets/test_v15.hdf5 --render_image_names agentview robot0_eye_in_hand --video_path /tmp/playback_dataset.mp4 --n 5
```

--------------------------------

### Gaussian Normalization Configuration

Source: https://robomimic.github.io/docs/sources/tutorials/action_configs.md.txt

Example configuration snippet for applying gaussian normalization to an action component.

```python
"normalization": "gaussian"
```

--------------------------------

### Download RoboMimic Datasets

Source: https://robomimic.github.io/docs/introduction/getting_started.html

Download specified datasets for RoboMimic experiments. This example downloads the 'Lift (PH)' dataset.

```bash
$ python robomimic/scripts/download_datasets.py --tasks lift --dataset_types ph
```

--------------------------------

### Reproduce BC and BC-RNN Training (Lift PH)

Source: https://robomimic.github.io/docs/datasets/robomimic_v0.1.html

Example commands to reproduce BC and BC-RNN training on the Lift PH dataset using generated configurations.

```bash
#  task: lift
#    dataset type: ph
#      hdf5 type: low_dim
python /path/to/robomimic/scripts/train.py --config /path/to/robomimic/exps/paper/core/lift/ph/low_dim/bc.json
python /path/to/robomimic/scripts/train.py --config /path/to/robomimic/exps/paper/core/lift/ph/low_dim/bc_rnn.json
```

--------------------------------

### Observation Encoder Setup with Image Randomizer

Source: https://robomimic.github.io/docs/sources/modules/models.md.txt

Manually create an ObservationEncoder and register an image modality with a CropRandomizer and a VisualCore network. This setup processes image inputs with random cropping augmentation.

```python
from robomimic.models.base_nets import MLP
from robomimic.models.obs_core import VisualCore, CropRandomizer
from robomimic.models.obs_nets import ObservationEncoder, ObservationDecoder

obs_encoder = ObservationEncoder(feature_activation=torch.nn.ReLU)

# There are two ways to construct the network for processing a input modality.
# Assume we are processing image input of shape (3, 224, 224).
camera1_shape = [3, 224, 224]

image_randomizer = CropRandomizer(input_shape=camera2_shape, crop_height=200, crop_width=200)

# We will use a reconfigurable image processing backbone VisualCore to process the input image modality
net_class = "VisualCore"  # this is defined in models/base_nets.py

# kwargs for VisualCore network
net_kwargs = {
    "input_shape": camera1_shape,
    "core_class": "ResNet18Conv",  # use ResNet18 as the visualcore backbone
    "core_kwargs": {"pretrained": False, "input_coord_conv": False},
    "pool_class": "SpatialSoftmax",  # use spatial softmax to regularize the model output
    "pool_kwargs": {"num_kp": 32}
}

# register the network for processing the modality
obs_encoder.register_obs_key(
    name="camera1",
    shape=camera1_shape,
    net_class=net_class,
    net_kwargs=net_kwargs,
    randomizers=image_randomizer
)

```

--------------------------------

### Min-Max Normalization Configuration

Source: https://robomimic.github.io/docs/sources/tutorials/action_configs.md.txt

Example configuration snippet for applying min-max normalization to an action component.

```python
"normalization": "min_max"
```

--------------------------------

### RoboMimic Training Loop Example

Source: https://robomimic.github.io/docs/modules/algorithms.html

Demonstrates the typical workflow for training a RoboMimic algorithm instance. It iterates through epochs, processes batches, performs training steps, logs information, and saves model checkpoints.

```python
# @model should be instance of Algo class to use for training
# @data_loader should be instance of torch.utils.data.DataLoader for sampling batches

# train for 50 epochs and 100 gradient steps per epoch
num_epochs = 50
gradient_steps_per_epoch = 100

# ensure model is in train mode
model.set_train()

for epoch in range(1, num_epochs + 1): # epoch numbers start at 1
    # iterator for data_loader - it yields batches
    data_loader_iter = iter(data_loader)

    # record losses
    losses = []

    for _ in range(gradient_steps_per_epoch):

        # load next batch from data loader
        try:
            batch = next(data_loader_iter)
        except StopIteration:
            # data loader ran out of batches - reset and yield first batch
            data_loader_iter = iter(data_loader)
            batch = next(data_loader_iter)

        # process batch for training
        input_batch = model.process_batch_for_training(batch)

        # forward and backward pass
        info = model.train_on_batch(batch=input_batch, epoch=epoch, validate=False)

        # record loss
        step_log = model.log_info(info)
        losses.append(step_log["Loss"])

    # save model
    model_params = model.serialize()
    model_dict = dict(model=model.serialize())
    torch.save(model_dict, /path/to/ckpt.pth)
        
    # do anything model needs to after finishing epoch
    model.on_epoch_end(epoch)

```

--------------------------------

### Visualize Initial Demonstration Frames

Source: https://robomimic.github.io/docs/tutorials/dataset_contents.html

Render only the initial frames of the dataset's demonstrations to a video file, showing the 'agentview' camera.

```bash
$ python playback_dataset.py --dataset ../../tests/assets/test_v15.hdf5 --first --render_image_names agentview --video_path /tmp/dataset_task_inits.mp4

```

--------------------------------

### Train a RoboMimic Experiment

Source: https://robomimic.github.io/docs/sources/introduction/getting_started.md.txt

Run a training experiment using the `train.py` script. This example configures behavior cloning (BC) for the downloaded Lift dataset and enables debug mode.

```shell
python robomimic/scripts/train.py --config robomimic/exps/templates/bc.json --dataset datasets/lift/ph/low_dim_v141.hdf5 --debug
```

--------------------------------

### Build VisualCore with ResNet18Conv and SpatialSoftmax

Source: https://robomimic.github.io/docs/modules/models.html

Example of constructing a VisualCore module using a ResNet18Conv backbone and a SpatialSoftmax pooling module. This demonstrates how to combine different network components for visual feature extraction.

```python
from robomimic.models.obs_core import VisualCore
from robomimic.models.base_nets import ResNet18Conv, SpatialSoftmax

vis_net = VisualCore(
  input_shape=(3, 224, 224),
  core_class="ResNet18Conv",  # use ResNet18 as the visualcore backbone
  core_kwargs={"pretrained": False, "input_coord_conv": False},  # kwargs for the ResNet18Conv class
  pool_class="SpatialSoftmax",  # use spatial softmax to regularize the model output
  pool_kwargs={"num_kp": 32},  # kwargs for the SpatialSoftmax --- use 32 keypoints
  flatten=True,  # flatten the output of the spatial softmax layer
  feature_dimension=64,  # project the flattened feature into a 64-dim vector through a linear layer 
)


```

--------------------------------

### Run Debug Training Loop

Source: https://robomimic.github.io/docs/introduction/installation.html

Executes a quick debugging training loop using the BC RNN example to verify robomimic installation. Assumes robomimic was installed from source.

```bash
$ cd <PATH_TO_ROBOMIMIC_INSTALL_DIR>
$ python examples/train_bc_rnn.py --debug

```

--------------------------------

### Launch Training with JSON Config

Source: https://robomimic.github.io/docs/tutorials/configs.html

This command launches a training run using a predefined BC algorithm configuration file and specifies the dataset. This is the recommended method for launching training.

```bash
$ python train.py --config ../exps/templates/bc.json --dataset ../../tests/assets/test_v15.hdf5

```

--------------------------------

### Install PyTorch on Mac

Source: https://robomimic.github.io/docs/introduction/installation.html

Installs PyTorch version 2.0.0 and Torchvision version 0.15.1 from the PyTorch conda channel. Does not install cudatoolkit as Mac does not have NVIDIA GPUs.

```bash
# Can change pytorch, torchvision versions
# We don't install cudatoolkit since Mac does not have NVIDIA GPU
$ conda install pytorch==2.0.0 torchvision==0.15.1 -c pytorch

```

--------------------------------

### Build and View Documentation Locally

Source: https://robomimic.github.io/docs/sources/introduction/installation.md.txt

Generate the documentation locally and view it in a web browser. Ensure you are in the correct directory before running these commands.

```sh
cd <PATH_TO_ROBOMIMIC_INSTALL_DIR>/docs
make clean
make apidoc
make html
make prep
cp -r images _build/html/
```

--------------------------------

### Install Robomimic via Pip

Source: https://robomimic.github.io/docs/introduction/installation.html

Installs the robomimic library directly using pip.

```bash
$ pip install robomimic

```

--------------------------------

### Run Comprehensive Installation Test

Source: https://robomimic.github.io/docs/introduction/installation.html

Executes a thorough test suite for several algorithms and scripts to ensure robomimic is installed correctly. This script may take several minutes to finish. Assumes robomimic was installed from source.

```bash
$ cd <PATH_TO_ROBOMIMIC_INSTALL_DIR>/tests
$ bash test.sh

```

--------------------------------

### Build and View Local Documentation

Source: https://robomimic.github.io/docs/introduction/installation.html

Commands to clean, generate API documentation, build HTML documentation, prepare it, and copy images. The documentation can then be viewed locally by opening '_build/html/index.html' in a web browser.

```bash
$ cd <PATH_TO_ROBOMIMIC_INSTALL_DIR>/docs
$ make clean
$ make apidoc
$ make html
$ make prep
$ cp -r images _build/html/

```

--------------------------------

### Install Robosuite via Pip

Source: https://robomimic.github.io/docs/introduction/installation.html

Installs the robosuite library directly using pip. Compatible with robosuite v1.2+.

```bash
# Via pip
$ pip install robosuite

```

--------------------------------

### Install PyTorch on Linux

Source: https://robomimic.github.io/docs/introduction/installation.html

Installs PyTorch version 2.0.0 and Torchvision version 0.15.1 from the PyTorch conda channel.

```bash
# Can change pytorch, torchvision versions
$ conda install pytorch==2.0.0 torchvision==0.15.1 -c pytorch

```

--------------------------------

### Install Robomimic via Pip

Source: https://robomimic.github.io/docs/sources/introduction/installation.md.txt

Installs the latest stable version of robomimic directly from the Python Package Index (PyPI).

```shell
$ pip install robomimic
```

--------------------------------

### Creating Configs using Config Factory

Source: https://robomimic.github.io/docs/sources/modules/configs.md.txt

Demonstrates the standard entry point for creating configuration objects in the codebase. It shows how to create a base config for an algorithm and then update it with values from a JSON file.

```python
import json
from robomimic.config import config_factory

# base config for algorithm with default values
config = config_factory("bc")

# update defaults with config json
with open("/path/to/config.json", "r") as f:
    ext_config_json = json.load(f)
config.update(ext_config_json)
```

--------------------------------

### Display All Command-Line Arguments

Source: https://robomimic.github.io/docs/sources/datasets/robosuite.md.txt

Displays a help message detailing all available command-line arguments for the dataset_states_to_obs.py script. Useful for exploring all options.

```bash
python dataset_states_to_obs.py --help
```

--------------------------------

### Install PyTorch on Linux

Source: https://robomimic.github.io/docs/sources/introduction/installation.md.txt

Installs PyTorch version 2.0.0 and torchvision version 0.15.1 using conda. This command is suitable for Linux systems.

```shell
# Can change pytorch, torchvision versions
$ conda install pytorch==2.0.0 torchvision==0.15.1 -c pytorch
```

--------------------------------

### Install PyTorch on Mac

Source: https://robomimic.github.io/docs/sources/introduction/installation.md.txt

Installs PyTorch version 2.0.0 and torchvision version 0.15.1 using conda. This command is for Mac users as it does not include cudatoolkit.

```shell
# Can change pytorch, torchvision versions
# We don't install cudatoolkit since Mac does not have NVIDIA GPU
$ conda install pytorch==2.0.0 torchvision==0.15.1 -c pytorch
```

--------------------------------

### Launch Transformer Training with Default Config

Source: https://robomimic.github.io/docs/tutorials/training_transformers.html

Use this command to launch training with a default transformer configuration. Specify your dataset path using the --dataset argument.

```bash
python train.py --config ../config/default_templates/bc_transformer.json --dataset /path/to/dataset.hdf5

```

--------------------------------

### Checkout Robosuite v1.5.1 Branch

Source: https://robomimic.github.io/docs/sources/introduction/installation.md.txt

Switches the robosuite installation to the v1.5.1 branch, which is required for using released datasets and reproducing experiments. This requires robosuite to be installed from source.

```shell
git checkout v1.5.1
```

--------------------------------

### Display Help for dataset_states_to_obs.py

Source: https://robomimic.github.io/docs/datasets/robosuite.html

Displays all available command-line arguments for the dataset_states_to_obs.py script, useful for understanding all processing options.

```bash
# For seeing descriptions of all the command-line args available
$ python dataset_states_to_obs.py --help
```

--------------------------------

### Launch Training with Default Configuration

Source: https://robomimic.github.io/docs/tutorials/training_diffusion_policy.html

Use this command to launch a training run with the default Diffusion Policy configuration. Specify your dataset path using the --dataset argument or within the config JSON.

```bash
python train.py --config ../exps/templates/diffusion_policy.json --dataset /path/to/dataset.hdf5

```

--------------------------------

### Construct and Launch Training with Python Config Object

Source: https://robomimic.github.io/docs/tutorials/configs.html

This Python script demonstrates how to create a default BC configuration, modify specific parameters in code, and then launch the training run. It shows how to set experiment name, dataset path, output directory, batch size, number of epochs, and algorithm-specific parameters like GMM.

```python
import robomimic
import robomimic.utils.torch_utils as TorchUtils
from robomimic.config import config_factory
from robomimic.scripts.train import train

# make default BC config
config = config_factory(algo_name="bc")

# set config attributes here that you would like to update
config.experiment.name = "bc_rnn_example"
config.train.data = [{"path": "/path/to/dataset.hdf5"}]
config.train.output_dir = "/path/to/desired/output_dir"
config.train.batch_size = 256
config.train.num_epochs = 500
config.algo.gmm.enabled = False

# get torch device
device = TorchUtils.get_torch_device(try_to_use_cuda=True)

# launch training run
train(config, device=device)

```

--------------------------------

### Get Target Values for TD-Loss

Source: https://robomimic.github.io/docs/sources/tutorials/custom_algorithms.md.txt

Helper function to compute target Q-values for TD-loss calculation. It uses the target actor network to get next actions and applies TD3's trick for ensemble Q-value targets.

```python
def _get_target_values(self, next_states, goal_states, rewards, dones):
        """
        Helper function to get target values for training Q-function with TD-loss.
        """

        with torch.no_grad():
            # get next actions via target actor and noise
            next_target_actions = self.nets["actor_target"](next_states, goal_states)
            noise = (
                torch.randn_like(next_target_actions) * self.algo_config.actor.noise_std
            ).clamp(-self.algo_config.actor.noise_clip, self.algo_config.actor.noise_clip)
            next_actions = (next_target_actions + noise).clamp(-1.0, 1.0)

            # TD3 trick to combine max and min over all Q-ensemble estimates into single target estimates
            all_value_targets = self.nets["critic_target"][0](next_states, next_actions, goal_states).reshape(-1, 1)
            max_value_targets = all_value_targets
            min_value_targets = all_value_targets
```

--------------------------------

### Initialize Env from Dataset Metadata

Source: https://robomimic.github.io/docs/modules/environments.html

Create an environment instance by loading metadata from a dataset file. Ensure the dataset path is correct and necessary utility modules are imported.

```python
import robomimic.utils.env_utils as EnvUtils
import robomimic.utils.file_utils as FileUtils

env_meta = FileUtils.get_env_metadata_from_dataset("path/to/the/dataset.hdf5")

env = EnvUtils.create_env_from_metadata(
    env_meta=env_meta,
    env_name=env_name, 
    render=False, 
    render_offscreen=False,
    use_image_obs=False, 
)

```

--------------------------------

### Launch RoboMimic Training Experiment

Source: https://robomimic.github.io/docs/introduction/getting_started.html

Run a training experiment using a specified configuration file and dataset. The `--debug` flag is recommended for initial sanity checks.

```bash
$ python robomimic/scripts/train.py --config robomimic/exps/templates/bc.json --dataset datasets/lift/ph/low_dim_v141.hdf5 --debug
```

--------------------------------

### Creating and Updating Config Objects with Config Factory

Source: https://robomimic.github.io/docs/modules/configs.html

Demonstrates the standard entry point for creating configuration objects. It first instantiates a base config for a given algorithm and then updates it with values from an external JSON configuration.

```python
import json
from robomimic.config import config_factory

# base config for algorithm with default values
config = config_factory("bc")

# update defaults with config json
with open("/path/to/config.json", "r") as f:
    ext_config_json = json.load(f)
config.update(ext_config_json)

```

--------------------------------

### Create Numpy Tensor Dictionary

Source: https://robomimic.github.io/docs/tutorials/tensor_collections.html

Example of creating a nested numpy dictionary representing observations.

```python
import numpy as np

x = {
    'image': np.random.randn(3, 224, 224),
    'proprio': {
        'eef_pos': np.random.randn(3),
        'eef_rot': np.random.randn(3)
    }
}

```

--------------------------------

### Initialize Environment from Dataset Metadata

Source: https://robomimic.github.io/docs/sources/modules/environments.md.txt

Use this snippet to create an environment instance by loading metadata from a dataset file. Ensure you have the necessary utility modules imported.

```python
import robomimic.utils.env_utils as EnvUtils
import robomimic.utils.file_utils as FileUtils

env_meta = FileUtils.get_env_metadata_from_dataset("path/to/the/dataset.hdf5")

env = EnvUtils.create_env_from_metadata(
    env_meta=env_meta,
    env_name=env_name, 
    render=False, 
    render_offscreen=False,
    use_image_obs=False, 
)
```

--------------------------------

### Initialize SequenceDataset

Source: https://robomimic.github.io/docs/modules/dataset.html

Instantiate SequenceDataset to load demonstration data. Specify observation and dataset keys, sequence length, frame stacking, padding options, and caching mode.

```python
dataset = SequenceDataset(
    hdf5_path=dataset_path,
    obs_keys=(
        "robot0_eef_pos", 
        "robot0_eef_quat", 
        "image", 
        "object",
    ),
    dataset_keys=(
        "actions", 
        "rewards", 
        "dones",
    ),
    seq_length=10,                  
    frame_stack=1,                  
    pad_seq_length=True,            
    pad_frame_stack=True,           
    hdf5_cache_mode="all",          
    hdf5_normalize_obs=False,
    filter_by_attribute=None,       
)

```

--------------------------------

### Download RoboMimic Datasets

Source: https://robomimic.github.io/docs/sources/introduction/getting_started.md.txt

Download specified datasets for RoboMimic. This example downloads the 'Lift (PH)' dataset.

```shell
python robomimic/scripts/download_datasets.py --tasks lift --dataset_types ph
```

--------------------------------

### Initialize Observation Modality Specs

Source: https://robomimic.github.io/docs/tutorials/tensor_collections.html

Example of defining observation modality specifications for initializing the observation utility registry.

```python
{
    "obs": {
        "low_dim": ["robot0_eef_pos", "robot0_eef_quat"],
        "rgb": ["agentview_image", "robot0_eye_in_hand"],
    }
    "goal": {
        "low_dim": ["robot0_eef_pos"],
        "rgb": ["agentview_image"]
    }
}

```

--------------------------------

### View TensorBoard Results

Source: https://robomimic.github.io/docs/tutorials/viewing_results.html

Launch TensorBoard to visualize training results. Use the `--logdir` flag to specify the experiment log directory.

```bash
$ tensorboard --logdir <experiment-log-dir> --bind_all

```

--------------------------------

### Get Action for Rollouts

Source: https://robomimic.github.io/docs/tutorials/custom_algorithms.html

Retrieves an action from the actor network for test-time rollouts. Assumes the network is not in training mode.

```python
def get_action(self, obs_dict, goal_dict=None):
        """
        Get policy action outputs.

        Args:
            obs_dict (dict): current observation
            goal_dict (dict): (optional) goal

        Returns:
            action (torch.Tensor): action tensor
        """
        assert not self.nets.training

        return self.nets["actor"](obs_dict=obs_dict, goal_dict=goal_dict)
```

--------------------------------

### initialize_obs_utils_with_config

Source: https://robomimic.github.io/docs/api/robomimic.utils.html

Utility function to parse config and initialize observation utilities.

```APIDOC
## initialize_obs_utils_with_config

### Description
Utility function to parse config and call @initialize_obs_utils_with_obs_specs and @initialize_default_obs_encoder_kwargs with the correct arguments.

### Parameters
**config** (_BaseConfig instance_) – config object
```

--------------------------------

### Launch Training by Constructing Config Object in Python

Source: https://robomimic.github.io/docs/sources/tutorials/configs.md.txt

This method involves creating a default config object using `config_factory`, modifying its attributes in Python code, and then calling the train function. Useful for dynamic configuration or when more granular control is needed.

```python
import robomimic
import robomimic.utils.torch_utils as TorchUtils
from robomimic.config import config_factory
from robomimic.scripts.train import train

# make default BC config
config = config_factory(algo_name="bc")

# set config attributes here that you would like to update
config.experiment.name = "bc_rnn_example"
config.train.data = [{"path": "/path/to/dataset.hdf5"}]
config.train.output_dir = "/path/to/desired/output_dir"
config.train.batch_size = 256
config.train.num_epochs = 500
config.algo.gmm.enabled = False

# get torch device
device = TorchUtils.get_torch_device(try_to_use_cuda=True)

# launch training run
train(config, device=device)
```

--------------------------------

### Get Action for Inference

Source: https://robomimic.github.io/docs/sources/tutorials/custom_algorithms.md.txt

Retrieves an action from the actor network for test-time rollouts. Assumes the network is not in training mode.

```python
    def get_action(self, obs_dict, goal_dict=None):
        """
        Get policy action outputs.

        Args:
            obs_dict (dict): current observation
            goal_dict (dict): (optional) goal

        Returns:
            action (torch.Tensor): action tensor
        """
        assert not self.nets.training

        return self.nets["actor"](obs_dict=obs_dict, goal_dict=goal_dict)
```

--------------------------------

### initialize_obs_utils_with_obs_specs

Source: https://robomimic.github.io/docs/api/robomimic.utils.html

Initializes observation utilities with observation specifications.

```APIDOC
## initialize_obs_utils_with_obs_specs

### Description
This function should be called before using any observation key-specific functions in this file, in order to make sure that all utility functions are aware of the observation modalities (e.g. which ones are low-dimensional, which ones are rgb, etc.). It constructs two dictionaries: (1) that map observation modality (e.g. low_dim, rgb) to a list of observation keys under that modality, and (2) that maps the inverse, specific observation keys to their corresponding observation modality.
Input should be a nested dictionary (or list of such dicts) with the following structure:
> obs_variant (str):
>     obs_modality (str): observation keys (list) …
>     …
> …
Example 
{
“obs”: {
“low_dim”: [“robot0_eef_pos”, “robot0_eef_quat”], “rgb”: [“agentview_image”, “robot0_eye_in_hand”]
}
“goal”: {
“low_dim”: [“robot0_eef_pos”], “rgb”: [“agentview_image”]
}
}

### Parameters
**obs_modality_specs** (_dict_) – Observation modality specifications.
```

--------------------------------

### Create Numpy Dictionary of Observations

Source: https://robomimic.github.io/docs/sources/tutorials/tensor_collections.md.txt

Example of creating a nested numpy dictionary to represent observations, including images and proprioceptive data.

```python
import numpy as np

x = {
    'image': np.random.randn(3, 224, 224),
    'proprio': {
        'eef_pos': np.random.randn(3),
        'eef_rot': np.random.randn(3)
    }
}
```

--------------------------------

### Configure Custom Encoder Core

Source: https://robomimic.github.io/docs/modules/models.html

Example of how to configure a custom EncoderCore-based class in a configuration file. This allows users to specify their own encoder implementations by name.

```python
config.observation.encoder.rgb.core_class = "MyCustomRGBEncoder"
config.observation.encoder.rgb.core_kwargs = ...


```

--------------------------------

### RolloutPolicy Wrapper Usage

Source: https://robomimic.github.io/docs/sources/modules/algorithms.md.txt

Demonstrates how to use the RolloutPolicy wrapper to deploy trained models in an environment. Ensure the policy is an instance of RolloutPolicy before starting the episode.

```python
model = RolloutPolicy(model)
```

```python
assert isinstance(policy, RolloutPolicy)

policy.start_episode()
obs = env.reset()

horizon = 400
total_return = 0
for step_i in range(horizon):
    act = policy(obs)
    next_obs, r, done = env.step(act)
    total_return += r
    success = env.is_success()["task"]
    if done or success:
        break
```

--------------------------------

### Dumping and Loading Configs to/from JSON

Source: https://robomimic.github.io/docs/sources/modules/configs.md.txt

Shows how to serialize a Config object to a JSON string or file, and how to load a Config object from a JSON string or dictionary.

```python
# dump config as a json string
json_string = c.dump()

# dump config to a json file
c.dump(filename="c.json")

# load config from json
import json
json_dic = json.loads(json_string)
c = Config(json_dic)
```

--------------------------------

### Specify Image Observation Modalities

Source: https://robomimic.github.io/docs/tutorials/pretrained_representations.html

Ensure that your configuration includes image observation modalities. The names 'agentview_image' and 'robot0_eye_in_hand_image' are examples and may vary based on your dataset.

```python
# Ensure that you are using image observation modalities, names may depend on your dataset naming convention
config.observation.modalities.obs.rgb = [
                    "agentview_image",
                    "robot0_eye_in_hand_image"
                ]
```
Tokens:
Raw