robomimic: A Modular Framework for Robot Learning from Demonstration

Overview

robomimic

[Homepage][Documentation][Study Paper][Study Website][ARISE Initiative]


Latest Updates

[08/09/2021] v0.1.0: Initial code and paper release


robomimic is a framework for robot learning from demonstration. It offers a broad set of demonstration datasets collected on robot manipulation domains, and learning algorithms to learn from these datasets. This project is part of the broader Advancing Robot Intelligence through Simulated Environments (ARISE) Initiative, with the aim of lowering the barriers of entry for cutting-edge research at the intersection of AI and Robotics.

Imitating human demonstrations is a promising approach to endow robots with various manipulation capabilities. While recent advances have been made in imitation learning and batch (offline) reinforcement learning, a lack of open-source human datasets and reproducible learning methods make assessing the state of the field difficult. The overarching goal of robomimic is to provide researchers and practitioners with:

  • a standardized set of large demonstration datasets across several benchmarking tasks to facilitate fair comparisons, with a focus on learning from human-provided demonstrations
  • high-quality implementations of several learning algorithms for training closed-loop policies from offline datasets to make reproducing results easy and lower the barrier to entry
  • a modular design that offers great flexibility in extending algorithms and designing new algorithms

This release of robomimic contains seven offline learning algorithms and standardized datasets collected across five simulated and three real-world multi-stage manipulation tasks of varying complexity. We highlight some features below:

  • standardized datasets: a set of datasets collected from different sources (single proficient human, multiple humans, and machine-generated) across several simulated and real-world tasks, along with a plug-and-play Dataset class to easily use the datasets outside of this project
  • algorithm implementations: several high-quality implementations of offline learning algorithms, including BC, BC-RNN, HBC, IRIS, BCQ, CQL, and TD3-BC
  • multiple observation spaces: support for learning both low-dimensional and visuomotor policies, with support for observation tensor dictionaries throughout the codebase, making it easy to specify different subsets of observations to train a policy. This includes a set of useful tensor utilities to work with nested dictionaries of torch Tensors and numpy arrays.
  • visualization utilities: utilities for visualizing demonstration data, playing back actions, visualizing trained policies, and collecting new datasets using trained policies
  • train launching utilities: utilities for easily running hyperparameter sweeps, enabled by a flexible Config management system

Contributing to robomimic

This framework originally began development in late 2018. Researchers in the Stanford Vision and Learning Lab (SVL) used it as an internal tool for training policies from offline human demonstration datasets. Now it is actively maintained and used for robotics research projects across multiple labs. We welcome community contributions to this project. For details please check our contributing guidelines.

Troubleshooting

Please see the troubleshooting section for common fixes, or submit an issue on our github page.

Reproducing study results

The robomimic framework also makes reproducing the results from this study easy. See the results documentation for more information.

Citations

Please cite this paper if you use this framework in your work:

@inproceedings{robomimic2021,
  title={What Matters in Learning from Offline Human Demonstrations for Robot Manipulation},
  author={Ajay Mandlekar and Danfei Xu and Josiah Wong and Soroush Nasiriany and Chen Wang and Rohun Kulkarni and Li Fei-Fei and Silvio Savarese and Yuke Zhu and Roberto Mart\'{i}n-Mart\'{i}n},
  booktitle={arXiv preprint arXiv:2108.03298},
  year={2021}
}
Comments
  • Demo collection script

    Demo collection script

    Hi, is the demonstration collection script available somewhere? The one in robosuite repo does not seem to output demos with the right format.

    Thanks!

    opened by yuchen93 11
  • Segfault of some algorithms on cluster

    Segfault of some algorithms on cluster

    Hi,

    I am trying to run all the algorithms on the TwoArmTransport environment, and I ran into Segmentation issue when trying td3_bc, bcq and cql on our school's cluster (with GeForce GTX 1080 with 8120 MB memory). Here is an example of the segmentation fault when running the td3_bc algorithm on the low_dim dataset. I tried to investigate a little bit, but it's not clear to me what is causing this segfault issue (I've attached the error message below from the terminal). There is no such issue if I run these algorithms on my own laptop. It would be great if there are solutions to the segfault so that I can run my experiments on the cluster. Thanks a lot in advance.

    SequenceDataset (
    	path=robomimic_data/low_dim.hdf5
    	obs_keys=('object', 'robot0_eef_pos', 'robot0_eef_quat', 'robot0_gripper_qpos')
    	seq_length=1
    	filter_key=none
    	frame_stack=1
    	pad_seq_length=True
    	pad_frame_stack=True
    	goal_mode=none
    	cache_mode=all
    	num_demos=200
    	num_sequences=93752
    )
    
     10%|#         | 519/5000 [00:28<04:03, 18.43it/s]Segmentation fault (core dumped)
    
    opened by vivianchen98 9
  • robosuite env.reset_to

    robosuite env.reset_to "hack" present in run_trained_agent.py but not in train_utils.py

    I'm trying to use code from run_trained_agent.py to collect some rollout statistics and it seems like this particular script uses a .reset_to() call that resets an environment to its current state. To my knowledge, this trick isn't present in other robomimic evaluation scripts, like run_rollout() in train_utils.py.

    When collecting human demonstrations on the robosuite task, was the .reset_to() trick used? I'm seeing some performance differences between the two versions of eval scripts, and I'm trying to pinpoint the issue.

    https://github.com/ARISE-Initiative/robomimic/blob/b5d2aa9902825c6c652e3b08b19446d199b49590/robomimic/scripts/run_trained_agent.py#L103

    opened by MaxDu17 5
  • Goal-conditioned observations

    Goal-conditioned observations

    Hello,

    I noticed that there is a functionality to use goal-conditioned images in robomimic. I was interested to figure out how this worked and found out that we can use the get_goal() function in the env_robosuite.py file. However, this function was used only in the rollout runs and I couldn't find its use during the training. Is it possible to train using goal-conditioned observations in robomimic? I was thinking of instances such as goal-conditioned imitation learning where the image from the last time-step in the demonstration is used as the goal observation in the policy.

    There was also a documentation comment in the get_goal() function noting that not all environments support this. I went to check all the environments in robosuite and saw that none of them had a _get_goal() function. If I were to write my own get_goal() function in a robosuite environment, is it possible to return an agentview image in the function as a goal observation once the task has succeeded? Would appreciate any help on this, thank you!

    opened by PraveenElango 5
  • How to use transport environment ?

    How to use transport environment ?

    I get the following error when I pass in the path to transport data Environment TwoArmTransport not found. Make sure it is a registered environment among: Lift, Stack, NutAssembly, .....

    Does this error arise due to robosuite not having the TwoArmTransport environment ? Is yes, how do I reproduce the paper results on transport. Any suggestions will be helpful.

    opened by prajjwal1 3
  • ImportError: cannot import name 'postprocess_model_xml' from 'robosuite.utils.mjcf_utils'

    ImportError: cannot import name 'postprocess_model_xml' from 'robosuite.utils.mjcf_utils'

    I get this error when I run a coupe of scripts such as : python examples/train_bc_rnn.py --debug or even the playback_dataset.py script:

    from robosuite.utils.mjcf_utils import postprocess_model_xml ImportError: cannot import name 'postprocess_model_xml' from 'robosuite.utils.mjcf_utils' (/home/xyz/anaconda3/envs/robomimic_venv/lib/python3.7/site-packages/robosuite/utils/mjcf_utils.py)

    Is 'postprocess_model_xml' removed/moved or renamed?

    opened by supriyasathya 3
  • Project Roadmap

    Project Roadmap

    Hi there, amazing project.

    I'm considering building on top of this framework, but I would like to understand what are your plans for the future. I see that many libraries are outdated (mujoco-py not active, pytorch 1.6, python 3.7).

    Which one of the below would you say is more accurate? -Project will be maintaned with basic fixes and small updates. -Project will be updated and will keep following the state of the art. -The project will be not be maintained anymore. -Other

    opened by lorepieri8 3
  • ERROR: GLEW initalization error: Missing GL version

    ERROR: GLEW initalization error: Missing GL version

    Hi, I followed tutorials accoding to this documentation, I have exported lines in my: .bashrc, .zshrc (i am using .zsh):

    export LD_LIBRARY_PATH=/home/dato/.mujoco/mujoco210/bin
    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/nvidia
    export PATH="$LD_LIBRARY_PATH:$PATH"
    export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libGLEW.so
    

    when i run: python examples/train_bc_rnn.py --debug to test my installation it gives me an error: ERROR: GLEW initalization error: Missing GL version when i check my environmental variables in .zsh/bash terminal, LD_PRELOAD env variable is present, I don't know how to proceed forward

    opened by datonefaridze 3
  • run_policy.ipynb error

    run_policy.ipynb error

    When trying to play the trajectory:

    Playing back demo key: demo_0
    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-14-b0a68c6d2406> in <module>
          2 for ep in demos[:5]:
          3     print("Playing back demo key: {}".format(ep))
    ----> 4     playback_trajectory(ep)
          5 
          6 # done writing video
    
    <ipython-input-13-455a7b8775a3> in playback_trajectory(demo_key)
         13 
         14     # reset to initial state
    ---> 15     env.reset_to(initial_state_dict)
         16 
         17     # playback actions one by one, and render frames
    
    ~/.local/lib/python3.8/site-packages/robomimic/envs/env_robosuite.py in reset_to(self, state)
        133             self.reset()
        134             xml = postprocess_model_xml(state["model"])
    --> 135             self.env.reset_from_xml_string(xml)
        136             self.env.sim.reset()
        137             if not self._is_v1:
    
    ~/.local/lib/python3.8/site-packages/robosuite/environments/base.py in reset_from_xml_string(self, xml_string)
        537 
        538         # Now reset as normal
    --> 539         self.reset()
        540 
        541         # Turn off deterministic reset
    
    ~/.local/lib/python3.8/site-packages/robosuite/environments/base.py in reset(self)
        263 
        264         # Reset necessary robosuite-centric variables
    --> 265         self._reset_internal()
        266         self.sim.forward()
        267         # Setup observables, reloading if
    
    ~/.local/lib/python3.8/site-packages/robosuite/environments/manipulation/lift.py in _reset_internal(self)
        387         Resets simulation internal configurations.
        388         """
    --> 389         super()._reset_internal()
        390 
        391         # Reset all object positions using initializer sampler if we're not directly loading from an xml
    
    ~/.local/lib/python3.8/site-packages/robosuite/environments/robot_env.py in _reset_internal(self)
        508         """
        509         # Run superclass reset functionality
    --> 510         super()._reset_internal()
        511 
        512         # Reset controllers
    
    ~/.local/lib/python3.8/site-packages/robosuite/environments/base.py in _reset_internal(self)
        316         # additional housekeeping
        317         self.sim_state_initial = self.sim.get_state()
    --> 318         self._setup_references()
        319         self.cur_time = 0
        320         self.timestep = 0
    
    ~/.local/lib/python3.8/site-packages/robosuite/environments/manipulation/lift.py in _setup_references(self)
        333         in a flatten array, which is how MuJoCo stores physical simulation data.
        334         """
    --> 335         super()._setup_references()
        336 
        337         # Additional object references from this env
    
    ~/.local/lib/python3.8/site-packages/robosuite/environments/robot_env.py in _setup_references(self)
        311         in a flatten array, which is how MuJoCo stores physical simulation data.
        312         """
    --> 313         super()._setup_references()
        314 
        315         # Setup robot-specific references as well (note: requires resetting of sim for robot first)
    
    ~/.local/lib/python3.8/site-packages/robosuite/environments/base.py in _setup_references(self)
        216         """
        217         # Setup mappings from model to IDs
    --> 218         self.model.generate_id_mappings(sim=self.sim)
        219 
        220     def _setup_observables(self):
    
    ~/.local/lib/python3.8/site-packages/robosuite/models/tasks/task.py in generate_id_mappings(self, sim)
        114             id_groups = [
        115                 get_ids(sim=sim, elements=model.visual_geoms + model.contact_geoms, element_type="geom"),
    --> 116                 get_ids(sim=sim, elements=model.sites, element_type="site"),
        117             ]
        118             group_types = ("geom", "site")
    
    ~/.local/lib/python3.8/site-packages/robosuite/utils/mjcf_utils.py in get_ids(sim, elements, element_type, inplace)
        887     else:  # We assume this is an iterable array
        888         assert isinstance(elements, Iterable), "Elements must be iterable for get_id!"
    --> 889         elements = [get_ids(sim=sim, elements=ele, element_type=element_type, inplace=True) for ele in elements]
        890 
        891     return elements
    
    ~/.local/lib/python3.8/site-packages/robosuite/utils/mjcf_utils.py in <listcomp>(.0)
        887     else:  # We assume this is an iterable array
        888         assert isinstance(elements, Iterable), "Elements must be iterable for get_id!"
    --> 889         elements = [get_ids(sim=sim, elements=ele, element_type=element_type, inplace=True) for ele in elements]
        890 
        891     return elements
    
    ~/.local/lib/python3.8/site-packages/robosuite/utils/mjcf_utils.py in get_ids(sim, elements, element_type, inplace)
        880             elements = sim.model.body_name2id(elements)
        881         else:  # site
    --> 882             elements = sim.model.site_name2id(elements)
        883     elif isinstance(elements, dict):
        884         # Iterate over each element in dict and recursively repeat
    
    wrappers.pxi in mujoco_py.cymj.PyMjModel.site_name2id()
    
    ValueError: No "site" with name gripper0_ee_x exists. Available "site" names = ('table_top', 'robot0_ee', 'robot0_ee_x', 'robot0_ee_z', 'robot0_ee_y', 'gripper0_ft_frame', 'gripper0_grip_site', 'gripper0_grip_site_cylinder', 'cube_default_site').
    
    
    opened by seann999 2
  • Using image datasets from demonstrations for  - memory issues

    Using image datasets from demonstrations for - memory issues

    Hello,

    I read the study paper for robomimic and saw that around 200-300 demonstrations were collected for various tasks. I collected 200 demonstrations for the Wipe task in robosuite and converted them and extracted image observations from the MuJoCo states as described here and created a new hdf5 file.

    I then used this new converted and extracted hdf5 file to conduct training in robomimic using the train_bc_rnn.py script while including agentview_image and robot0_eye_in_hand_image in the config.observation.modalities.obs.rgb. When I commenced training, the process keeps getting killed when dataset was being loaded into memory. I ran htop on my terminal and noticed that the Mem bar was full (125G/126G) right before the process was killed. The size of my hdf5 file is around 7 GB.

    When I reduced batch_size all the way to 1 and tried again, after about 50 epochs, the process gets killed again due to memory. Does this mean that I have to reduce the size of my demonstration dataset, or is there something that I may have missed here? Would appreciate any help, thank you!

    opened by PraveenElango 2
  • using SequenceDataset as standalone module

    using SequenceDataset as standalone module

    Hi! I want to use SequenceDataset in my project so I don't have to write it myself, but all other modules are not relevant for me.

    When I try to create a dataset, I get an error:

    AssertionError: error: must call ObsUtils.initialize_obs_utils_with_obs_config first
    

    Can I somehow use a dataset without creating (or using minimal only relevant args) configs? For example, as in https://arise-initiative.github.io/robomimic-web/docs/introduction/examples.html, but without model creation and training loop.

    Thanks!

    opened by Howuhh 2
  • ObsUtils.unprocess_obs_dict() modifies obs dict in-place

    ObsUtils.unprocess_obs_dict() modifies obs dict in-place

    The ObsUtils.unprocess_obs_dict() seems to modify the observation dictionary that is passed in, in addition to returning it. For example, I observed that in the lines referenced below, next_obs images are between 0 and 1, while after line 147, next_obs images are between 0 and 255. This leads to a problem, as obs is derived from next_obs, which means that in the next loop around, we will pass already unprocessed images into unprocess_obs_dict(). This has led to some significant issues, as the saved images are corrupted from what is observed. As a simple fix, I wrapped the next_obs in deepcopy(next_obs) on line 147.

    https://github.com/ARISE-Initiative/robomimic/blob/b5d2aa9902825c6c652e3b08b19446d199b49590/robomimic/scripts/run_trained_agent.py#L142-L147

    opened by MaxDu17 4
  • wrong rendering

    wrong rendering

    Hi! I want to visualize my agent's rollouts. However, the resulting videos turns out to be strange, I see some color artifacts. Should it be like this?

    What I do:

    # on each step
    render_frames.append(env.render(mode="rgb_array", width=256, height=256))
    
    # at the end
    imageio.mimsave(render_path, render_frames, fps=32)
    

    Result: Screenshot-from-2022-02-21-16-11-13

    opened by Howuhh 4
  • basic support for logging warnings

    basic support for logging warnings

    • adding functions log_warning and flush_warnings to utils/log_utils.py, allowing us to log warnings (in yellow text by default) at the start of training, and cache them so that they are displayed once again right before training starts, so that they appear all together in a convenient location that's easy to check while debugging
    • to leverage, call log_warning with the warning message, and optionally specify the text color (default is "yellow"), and whether you want to print the warning immediately (in addition to printing later when flush_warnings is called)
    opened by amandlek 0
  • Problem with train_bc_rnn.py in python 3.8

    Problem with train_bc_rnn.py in python 3.8

    When running examples/train_bc_rnn.py on python 3.8, if you set config.train.hdf5_cache_mode = "low_dim" and config.train.num_data_workers = 2, the training fails. It appears to be related to an issue with global variables in utils/obs_utils.py and the torch dataloader workers not having those set properly.

    opened by amandlek 0
  • Switch from urllib to requests

    Switch from urllib to requests

    Fixes issues where urllib would return "503: Service Temporary Unavailable", despite the following url being valid: http://downloads.cs.stanford.edu/downloads/rt_benchmark/lift/ph/low_dim.hdf5

    For more information, see: https://stackoverflow.com/a/25936312

    And for the progress bar implementation: https://stackoverflow.com/a/37573701

    opened by ellislm 0
Releases(v0.2.0)
  • v0.2.0(Dec 17, 2021)

    robomimic 0.2.0 Release Notes

    Highlights

    This release of robomimic brings integrated support for mobile manipulation datasets from the recent MOMART paper, and adds modular features for easily modifying and adding custom observation modalities and corresponding encoding networks.

    MOMART Datasets

    We have added integrated support for MOMART datasets, a large-scale set of multi-stage, long-horizon mobile manipulation task demonstrations in a simulated kitchen environment collected in iGibson.

    Using MOMART Datasets

    Datasets can be easily downloaded using download_momart_datasets.py.

    For step-by-step instructions for setting up your machine environment to visualize and train with the MOMART datasets, please visit the Getting Started page.

    Modular Observation Modalities

    We also introduce modular features for easily modifying and adding custom observation modalities and corresponding encoding networks. A modality corresponds to a group of specific observations that should be encoded the same way.

    Default Modalities

    robomimic natively supports the following modalities (expected size from a raw dataset shown, excluding the optional leading batch dimension):

    • rgb (H, W, 3): Standard 3-channel color frames with values in range [0, 255]
    • depth (H, W, 1): 1-channel frame with normalized values in range [0, 1]
    • low_dim (N): low dimensional observations, e.g.: proprioception or object states
    • scan (1, N): 1-channel, single-dimension data from a laser range scanner

    We have default encoder networks which can be configured / modified by setting relevant parameters in your config, e.g.:

    # These keys should exist in your dataset
    config.observation.modalities.obs.rgb = ["cam1", "cam2", "cam3"]    # Add camera observations to the RGB modality
    config.observation.modalities.obs.low_dim = ["proprio", "object"]   # Add proprioception and object states to low dim modality
    ...
    
    # Now let's modify the default RGB encoder network and set the feature dimension size
    config.observation.encoder.rgb.core_kwargs.feature_dimension = 128
    ...
    

    To see the structure of the observation modalities and encoder parameters, please see the base config module.

    Custom Modalities

    You can also easily add your own modality and corresponding custom encoding network! Please see our example add_new_modality.py.

    Refactored Config Structure

    With the introduction of modular modalities, our Config class structure has been modified slightly, and will likely cause breaking changes to any configs you have created using version 0.1.0. Below, we describe the exact changes in the config that need to be updated to match the current structure:

    Observation Modalities

    The image modality have been renamed to rgb. Thus, you would need to change your config in any places referencing image modality, e.g.:

    # Old format
    config.observation.modalities.image.<etc>
    
    # New format
    config.observation.modalities.rgb.<etc>
    

    The low_dim modality remains unchanged. Note, however, that we have additionally added integrated support for both depth and scan modalities, and can be referenced in the same way, e.g.:

    config.observation.modalities.depth.<etc>
    config.observation.modalities.scan.<etc>
    

    Observation Encoders / Randomizer Networks

    We have modularized the encoder / randomizer arguments so that they are general, and are unique to each type of observation modality. All of the original arguments in v0.1.0 have been preserved, but are now re-formatted as follows:

    ############# OLD ##############
    
    # Previously, a single set of arguments were specified, and was hardcoded to process image (rgb) observations
    
    # Assumes that you're using the VisualCore class, not general!
    config.observation.encoder.visual_feature_dimension = 64
    config.observation.encoder.visual_core = 'ResNet18Conv'
    config.observation.encoder.visual_core_kwargs.pretrained = False
    config.observation.encoder.visual_core_kwargs.input_coord_conv = False
    
    # For pooling, is hardcoded to use spatial softmax or not, not general!
    config.observation.encoder.use_spatial_softmax = True
    # kwargs for spatial softmax layer
    config.observation.encoder.spatial_softmax_kwargs.num_kp = 32
    config.observation.encoder.spatial_softmax_kwargs.learnable_temperature = False
    config.observation.encoder.spatial_softmax_kwargs.temperature = 1.0
    config.observation.encoder.spatial_softmax_kwargs.noise_std = 0.0
    
    
    ############# NEW ##############
    
    # Now, argument names are general (network-agnostic), and are specified per modality!
    
    # Example for RGB, to reproduce the above configuration
    
    # The core encoder network can be arbitrarily specified!
    config.observation.encoder.rgb.core_class = "VisualCore"
    
    # Corresponding kwargs that should be passed to the core class are specified below
    config.observation.encoder.rgb.core_kwargs.feature_dimension = 64
    config.observation.encoder.rgb.core_kwargs.backbone_class = "ResNet18Conv"
    config.observation.encoder.rgb.core_kwargs.backbone_kwargs.pretrained = False
    config.observation.encoder.rgb.core_kwargs.backbone_kwargs.input_coord_conv = False
    
    # The pooling class can also arbitrarily be specified!
    config.observation.encoder.rgb.core_kwargs.pool_class = "SpatialSoftmax"
    
    # Corresponding kwargs that should be passed to the pooling class are specified below
    config.observation.encoder.rgb.core_kwargs.pool_kwargs.num_kp = 32
    config.observation.encoder.rgb.core_kwargs.pool_kwargs.learnable_temperature = False
    config.observation.encoder.rgb.core_kwargs.pool_kwargs.temperature = 1.0
    config.observation.encoder.rgb.core_kwargs.pool_kwargs.noise_std = 0.0
    

    Thankfully, the observation randomization network specifications were already modularized, but were hardcoded to process image (rgb) modality only. Thus, the only change we made is to allow the randomization kwargs to be specified per modality:

    ############# OLD ##############
    # Previously, observation randomization was hardcoded for image / rgb modality
    config.observation.encoder.obs_randomizer_class = None
    config.observation.encoder.obs_randomizer_kwargs.crop_height = 76
    config.observation.encoder.obs_randomizer_kwargs.crop_width = 76
    config.observation.encoder.obs_randomizer_kwargs.num_crops = 1
    config.observation.encoder.obs_randomizer_kwargs.pos_enc = False
    
    ############# NEW ##############
    
    # Now, the randomization arguments are specified per modality. An example for RGB is shown below
    config.observation.encoder.rgb.obs_randomizer_class = None
    config.observation.encoder.rgb.obs_randomizer_kwargs.crop_height = 76
    config.observation.encoder.rgb.obs_randomizer_kwargs.crop_width = 76
    config.observation.encoder.rgb.obs_randomizer_kwargs.num_crops = 1
    config.observation.encoder.rgb.obs_randomizer_kwargs.pos_enc = False
    

    You can also view the default configs and compare your config to these templates to view exact diffs in structure.

    Source code(tar.gz)
    Source code(zip)
    robomimic-0.2.0-py2.py3-none-any.whl(218.02 KB)
    robomimic-0.2.0.tar.gz(188.39 KB)
  • v0.1.0(Nov 16, 2021)

Owner
ARISE Initiative
Advancing Robot Intelligence through Simulated Environments (ARISE)
ARISE Initiative
BMW TechOffice MUNICH 148 Dec 21, 2022
Neurons Dataset API - The official dataloader and visualization tools for Neurons Datasets.

Neurons Dataset API - The official dataloader and visualization tools for Neurons Datasets. Introduction We propose our dataloader API for loading and

1 Nov 19, 2021
This repository contains the implementation of the paper: "Towards Frequency-Based Explanation for Robust CNN"

RobustFreqCNN About This repository contains the implementation of the paper "Towards Frequency-Based Explanation for Robust CNN" arxiv. It primarly d

Sarosij Bose 2 Jan 23, 2022
Solving Zero-Shot Learning in Named Entity Recognition with Common Sense Knowledge

Zero-Shot Learning in Named Entity Recognition with Common Sense Knowledge Associated code for the paper Zero-Shot Learning in Named Entity Recognitio

Søren Hougaard Mulvad 13 Dec 25, 2022
PyTorch implementation of neural style randomization for data augmentation

README Augment training images for deep neural networks by randomizing their visual style, as described in our paper: https://arxiv.org/abs/1809.05375

84 Nov 23, 2022
Development of IP code based on VIPs and AADM

Sparse Implicit Processes In this repository we include the two different versions of the SIP code developed for the article Sparse Implicit Processes

1 Aug 22, 2022
PyTorch implementation of adversarial patch

adversarial-patch PyTorch implementation of adversarial patch This is an implementation of the Adversarial Patch paper. Not official and likely to hav

Jamie Hayes 172 Nov 29, 2022
A novel framework to automatically learn high-quality scanning of non-planar, complex anisotropic appearance.

appearance-scanner About This repository is an implementation of the neural network proposed in Free-form Scanning of Non-planar Appearance with Neura

Xiaohe Ma 14 Oct 18, 2022
Pytorch implementation of the paper "Class-Balanced Loss Based on Effective Number of Samples"

Class-balanced-loss-pytorch Pytorch implementation of the paper Class-Balanced Loss Based on Effective Number of Samples presented at CVPR'19. Yin Cui

Vandit Jain 697 Dec 29, 2022
Speech Recognition using DeepSpeech2.

deepspeech.pytorch Implementation of DeepSpeech2 for PyTorch using PyTorch Lightning. The repo supports training/testing and inference using the DeepS

Sean Naren 2k Jan 04, 2023
BankNote-Net: Open dataset and encoder model for assistive currency recognition

BankNote-Net: Open Dataset for Assistive Currency Recognition Millions of people around the world have low or no vision. Assistive software applicatio

Microsoft 13 Oct 28, 2022
3D Pose Estimation for Vehicles

3D Pose Estimation for Vehicles Introduction This work generates 4 key-points and 2 key-edges from vertices and edges of vehicles as ground truth. The

Jingyi Wang 1 Nov 01, 2021
A semismooth Newton method for elliptic PDE-constrained optimization

sNewton4PDEOpt The Python module implements a semismooth Newton method for solving finite-element discretizations of the strongly convex, linear ellip

2 Dec 08, 2022
Group Fisher Pruning for Practical Network Compression(ICML2021)

Group Fisher Pruning for Practical Network Compression (ICML2021) By Liyang Liu*, Shilong Zhang*, Zhanghui Kuang, Jing-Hao Xue, Aojun Zhou, Xinjiang W

Shilong Zhang 129 Dec 13, 2022
This project is for a Twitter bot that monitors a bird feeder in my backyard. Any detected birds are identified and posted to Twitter.

Backyard Birdbot Introduction This is a silly hobby project to use existing ML models to: Detect any birds sighted by a webcam Identify whic

Chi Young Moon 71 Dec 25, 2022
This repository contains the code for the paper Neural RGB-D Surface Reconstruction

Neural RGB-D Surface Reconstruction Paper | Project Page | Video Neural RGB-D Surface Reconstruction Dejan Azinović, Ricardo Martin-Brualla, Dan B Gol

Dejan 406 Jan 04, 2023
Certis - Certis, A High-Quality Backtesting Engine

Certis - Backtesting For y'all Certis is a powerful, lightweight, simple backtes

Yeachan-Heo 46 Oct 30, 2022
[CVPR 2020] 3D Photography using Context-aware Layered Depth Inpainting

[CVPR 2020] 3D Photography using Context-aware Layered Depth Inpainting [Paper] [Project Website] [Google Colab] We propose a method for converting a

Virginia Tech Vision and Learning Lab 6.2k Jan 01, 2023
Code for Parameter Prediction for Unseen Deep Architectures (NeurIPS 2021)

Parameter Prediction for Unseen Deep Architectures (NeurIPS 2021) authors: Boris Knyazev, Michal Drozdzal, Graham Taylor, Adriana Romero-Soriano Overv

Facebook Research 462 Jan 03, 2023
Open-source implementation of Google Vizier for hyper parameters tuning

Advisor Introduction Advisor is the hyper parameters tuning system for black box optimization. It is the open-source implementation of Google Vizier w

tobe 1.5k Jan 04, 2023