Repository: facebookresearch/habitat-challenge (language: python)

Issue:
Updated Challenge Configs



Discussion / hints:

Fix patch:
diff --git a/.circleci/config.yml b/.circleci/config.yml
index 1f13a52..81d7319 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -85,19 +85,11 @@ jobs:
               # Set EvalAI account token
               evalai set_token $EVALAI_TOKEN
 
-              # DDPPO baseline ObjectNav
-              wget https://dl.fbaipublicfiles.com/habitat/data/baselines/v1/ddppo_objectnav_habitat2022_challenge_baseline_v1.pth
-              docker build . --file Objectnav_DDPPO_baseline.Dockerfile -t ddppo_objectnav_submission
+              docker build . --file docker/hab2.Dockerfile  -t rearrange_submission
 
               # Push docker image to EvalAI docker registry
-              evalai push ddppo_objectnav_submission:latest --phase habitat-objectnav-minival-2022-1615 --private
-
-              # Random agent baseline
-              docker build . --file Objectnav.Dockerfile -t objectnav_submission
-
-              # Push docker image to EvalAI docker registry
-              evalai push objectnav_submission:latest --phase habitat-objectnav-minival-2022-1615 --private
-
+              evalai push rearrange_submission:latest --phase habitat-rearrange-minival-2022-1820 --private
+              evalai push rearrange_submission:latest --phase habitat-rearrange-easy-minival-2022-1820 --private
 
 workflows:
   version: 2
diff --git a/.gitignore b/.gitignore
index e43b0f9..3e5a4ef 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,1 +1,2 @@
 .DS_Store
+data
diff --git a/Objectnav.Dockerfile b/Objectnav.Dockerfile
deleted file mode 100644
index f763e55..0000000
--- a/Objectnav.Dockerfile
+++ /dev/null
@@ -1,10 +0,0 @@
-FROM fairembodied/habitat-challenge:testing_2022_habitat_base_docker
-
-ADD agent.py agent.py
-ADD submission.sh submission.sh
-ADD configs/challenge_objectnav2022.local.rgbd.yaml /challenge_objectnav2022.local.rgbd.yaml
-ENV AGENT_EVALUATION_TYPE remote
-
-ENV TRACK_CONFIG_FILE "/challenge_objectnav2022.local.rgbd.yaml"
-
-CMD ["/bin/bash", "-c", "source activate habitat && export PYTHONPATH=/evalai-remote-evaluation:$PYTHONPATH && export CHALLENGE_CONFIG_FILE=$TRACK_CONFIG_FILE && bash submission.sh"]
diff --git a/Objectnav_DDPPO_baseline.Dockerfile b/Objectnav_DDPPO_baseline.Dockerfile
deleted file mode 100644
index aecc22b..0000000
--- a/Objectnav_DDPPO_baseline.Dockerfile
+++ /dev/null
@@ -1,12 +0,0 @@
-FROM fairembodied/habitat-challenge:testing_2022_habitat_base_docker
-
-ADD ddppo_agents.py agent.py
-ADD submission.sh submission.sh
-ADD configs/challenge_objectnav2022.local.rgbd.yaml /challenge_objectnav2022.local.rgbd.yaml
-ADD configs/ configs/
-ADD ddppo_objectnav_habitat2022_challenge_baseline_v1.pth demo.ckpt.pth
-ENV AGENT_EVALUATION_TYPE remote
-
-ENV TRACK_CONFIG_FILE "/challenge_objectnav2022.local.rgbd.yaml"
-
-CMD ["/bin/bash", "-c", "source activate habitat && export PYTHONPATH=/evalai-remote-evaluation:$PYTHONPATH && export CHALLENGE_CONFIG_FILE=$TRACK_CONFIG_FILE && bash submission.sh --model-path demo.ckpt.pth --input-type rgbd"]
diff --git a/README.md b/README.md
index c31647d..3db7083 100644
--- a/README.md
+++ b/README.md
@@ -4,244 +4,163 @@
 
 --------------------------------------------------------------------------------
 
-# Habitat Challenge 2022
+# Habitat Rearrangement Challenge 2022
 
-This repository contains the starter code for the 2022 challenge, and training and evaluation setups. For an overview of habitat-challenge, visit [aihabitat.org/challenge](https://aihabitat.org/challenge/).
+This repository contains the starter code for the Habitat 2022 rearrangement challenge, and training and evaluation setups. For an overview of habitat-challenge, visit [aihabitat.org/challenge/2022_rearrange](https://aihabitat.org/challenge/2022_rearrange).
 
-If you are looking for our 2021/2020/2019 starter code, it’s available in the [`challenge-YEAR branch`](https://github.com/facebookresearch/habitat-challenge/tree/challenge-2021).
+## Task: Object Rearrangement
 
-This year, we are hosting a challenges on the ObjectNav embodied navigation task. ObjectNav focuses on egocentric object/scene recognition and a commonsense understanding of object semantics (where is a fireplace typically located in a house?).
+In the object rearrangement task, a Fetch robot is randomly spawned in an unknown environment and asked to rearrange 1 object from an initial to desired position – picking/placing it from receptacles (counter, sink, sofa, table), opening/closing containers (drawers, fridges) as necessary. A map of the environment is not provided and the agent must only use its sensory input to navigate and rearrange.
 
-### Changes in 2022 (over 2021)
-- We are instantiating ObjectNav on a new dataset called [HM3D-Semantics v0.1](https://aihabitat.org/datasets/hm3d-semantics/).
-- We are retiring the PointNav challenge, although the evaluation servers will continue to be open and researchers are welcome to submit to them.
+The Fetch robot is equipped with an egocentric 256x256 90-degree FoV RGBD camera on the robot head. 
+The agent also has access to idealized base-egomotion giving the relative displacement and angle of the base since the start of the episode. 
+Additionally, the robot has proprioceptive joint sensing providing access to the current robot joint angles.
 
-## Task: ObjectNav
+For details about the agent, dataset, and evaluation, see the challenge website: [aihabitat.org/challenge/2022_rearrange](https://aihabitat.org/challenge/2022_rearrange/).
 
-In ObjectNav, an agent is initialized at a random starting position and orientation in an unseen environment and asked to find an instance of an object category (*‘find a chair’*) by navigating to it. A map of the environment is not provided and the agent must only use its sensory input to navigate.
-
-The agent is equipped with an RGB-D camera and a (noiseless) GPS+Compass sensor. GPS+Compass sensor provides the agent’s current location and orientation information relative to the start of the episode. We attempt to match the camera specification (field of view, resolution) in simulation to the Azure Kinect camera, but this task does not involve any injected sensing noise.
-
-### Dataset
-The 2022 ObjectNav challenge uses 120 scenes from the [Habitat-Matterport3D (HM3D) Semantics v0.1](https://aihabitat.org/datasets/hm3d/)[2] dataset with train/val/test splits on 80/20/20. Following Chaplot et al.[3], we use 6 object goal categories: chair, couch, potted plant, bed, toilet and tv.
-
-### Evaluation
-Similar to 2021 Habitat Challenge, we measure performance along the same two axes as specified by Anderson et al.[4]:
-- **Success**: Did the agent navigate to an instance of the goal object? (Notice: *any* instance, regardless of distance from starting location.)
-
-Concretely, an episode is deemed successful if on calling the STOP action, the agent is within 1.0m Euclidean distance from any instance of the target object category AND the object *can be viewed by an oracle* from that stopping position by turning the agent or looking up/down. Notice: we do NOT require the agent to be actually viewing the object at the stopping location, simply that such oracle-visibility is possible without moving. Why? Because we want participants to focus on *navigation*, not object framing. In Embodied AI’s larger goal, the agent is navigating to an object instance to interact with it (say point at or manipulate an object). Oracle-visibility is our proxy for *‘the agent is close enough to interact with the object’*.
-
-- **SPL**: How efficient was the agent’s path compared to an optimal path? (Notice: optimal path = shortest path from the agent’s starting position to the *closest* instance of the target object category.)
-
-After calling the STOP action, the agent is evaluated using the ‘Success weighted by Path Length’ (SPL) metric [4].
-
-<p align="center">
-  <img src='res/img/spl.png' />
-</p>
-
-ObjectNav-SPL is defined analogous to PointNav-SPL. The only key difference is that the shortest path is computed to the object instance closest to the agent start location. Thus, if an agent spawns very close to *‘chair1’* but stops at a distant *‘chair2’*, it will achieve 100% success (because it found a *‘chair’*) but a fairly low SPL (because the agent path is much longer compared to the oracle path).
-
-We reserve the right to use additional metrics to choose winners in case of statistically insignificant SPL differences.
+If you have any issues, open a GitHub issue on this repository.
 
 ## Participation Guidelines
 
-Participate in the contest by registering on the [EvalAI challenge page](https://eval.ai/web/challenges/challenge-page/1615/overview) and creating a team. Participants will upload docker containers with their agents that are evaluated on an AWS GPU-enabled instance. Before pushing the submissions for remote evaluation, participants should test the submission docker locally to ensure it is working. Instructions for training, local evaluation, and online submission are provided below.
+Participate in the contest by registering on the in the soon to be released EvalAI page and creating a team. Participants will upload docker containers with their agents that are evaluated on an AWS GPU-enabled instance. Before pushing the submissions for remote evaluation, participants should test the submission docker locally to ensure it is working. Instructions for training, local evaluation, and online submission are provided below.
 
-For your convenience, please check our [Habitat Challenge video tutorial](https://youtu.be/V7PXttmJ8EE?list=PLGywud_-HlCORC0c4uj97oppQrGiB6JNy) and [Colab step-by-step tutorial from previous year](https://colab.research.google.com/gist/mathfac/8c9b97d7afef36e377f17d587c903ede).
+### Installing Habitat-Sim and Downloading data
+First setup Habitat Sim in a new conda environment so you can download the datasets to evaluate your models locally.
 
-### Local Evaluation
+1. Prepare your [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/) env:
+    ```bash
+    # We require python>=3.7 and cmake>=3.10
+    conda create -n habitat python=3.7 cmake=3.14.0
+    conda activate habitat
+    ```
+
+1. Install Habitat-Sim using our custom Conda package for habitat challenge 2022 with: 
+    ```
+    conda install -y habitat-sim-rearrange-challenge-2022  withbullet  headless -c conda-forge -c aihabitat
+    ```
+    **On MacOS, omit the `headless` argument**.    
+    Note: If you face any issues related to the `GLIBCXX` version after conda installation, please uninstall this conda package and install the habitat-sim repository from source (more information [here](https://github.com/facebookresearch/habitat-sim/blob/main/BUILD_FROM_SOURCE.md#build-from-source)). Make sure that you are using the `hab2_challenge_2022` tag and not the `stable` branch for your installation. 
 
 1. Clone the challenge repository:
 
     ```bash
-    git clone https://github.com/facebookresearch/habitat-challenge.git
+    git clone -b rearrangement-challenge-2022 https://github.com/facebookresearch/habitat-challenge.git
     cd habitat-challenge
     ```
 
-1. Implement your own agent or try one of ours. We provide an agent in `agent.py` that takes random actions:
-    ```python
-    import numpy
+1. Download the episode datasets, scenes, and all other assets with 
+    ```
+    python -m habitat_sim.utils.datasets_download --uids rearrange_task_assets --data-path <path to download folder>
+    ```
+    If this step was successful, you should see the train, val and minival splits in the `<path to download folder>/datasets/replica_cad/rearrange/v1/{train, val, minival}` folders respectively. 
 
-    import habitat
+1. Now, create a symlink to the downloaded data in your habitat-challenge repository:
+    ```
+    ln -s <absolute path to download folder> data
+    ```
 
-    class RandomAgent(habitat.Agent):
-        def reset(self):
-            pass
 
-        def act(self, observations):
-            return {"action": numpy.random.choice(task_config.TASK.POSSIBLE_ACTIONS)}
 
-    def main():
-        config_paths = "/path/to/challenge/config/file"
-        config = habitat.get_config(config_paths)
-        agent = RandomAgent(task_config=config)
-        challenge = habitat.Challenge()
-        challenge.submit(agent)
-    ```
-    [Optional] Modify submission.sh file if your agent needs any custom modifications (e.g. command-line arguments). Otherwise, nothing to do. Default submission.sh is simply a call to `RandomAgent` agent in `agent.py`.
+### Local Docker Evaluation
+In these steps, we will evaluate a sample agent in Docker. We evaluate in Docker because EvalAI requires submitting a Docker image to run your agent on the leaderboard. **Since these steps depend on [nvidia-docker v2](https://github.com/NVIDIA/nvidia-docker), they will only run on Linux**; no Windows or MacOS.
 
+1. Implement your own agent or try one of ours. We provide an agent in `agents/random_agent.py` that takes random actions.
 
 1. Install [nvidia-docker v2](https://github.com/NVIDIA/nvidia-docker) following instructions here: [https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#docker).
 Note: only supports Linux; no Windows or MacOS.
 
-1. Modify the provided Dockerfile if you need custom modifications. Let’s say your code needs `pytorch==1.9.0`, these dependencies should be pip installed inside a conda environment called `habitat` that is shipped with our habitat-challenge docker, as shown below:
+1. Modify the [provided Dockerfile](https://github.com/facebookresearch/habitat-challenge/blob/rearrangement-challenge-2022/docker/hab2.Dockerfile) if you need custom modifications. Let’s say your code needs `pytorch==1.9.0`, these dependencies should be pip installed inside the Docker conda environment called `habitat`. Below is an example Dockerfile with pip installing custom dependencies. 
 
     ```dockerfile
-    FROM fairembodied/habitat-challenge:testing_2022_habitat_base_docker
+    FROM fairembodied/habitat-challenge:habitat_rearrangement_2022_base_docker
 
     # install dependencies in the habitat conda environment
     RUN /bin/bash -c ". activate habitat; pip install torch==1.9.0"
 
     ADD agent.py /agent.py
-    ADD submission.sh /submission.sh
     ```
     Build your docker container using: 
     ```bash
-    docker build . --file Objectnav.Dockerfile  -t objectnav_submission
-    ```
-    
-    Note #1: you may need `sudo` priviliges to run this command.
-
-    Note #2: Please make sure that you keep your local version of `fairembodied/habitat-challenge:testing_2022_habitat_base_docker` image up to date with the image we have hosted on [dockerhub](https://hub.docker.com/r/fairembodied/habitat-challenge/tags). This can be done by pruning all cached images, using:
+    docker build . --file docker/hab2.Dockerfile  -t rearrange_submission
     ```
-    docker system prune -a
-    ```
-
-1. Dataset: First, get access to the Habitat-Matterport3D Dataset scenes by visiting [this link](https://matterport.com/habitat-matterport-3d-research-dataset) and following the given instructions. After getting access to the dataset, carry out the following steps to download the dataset:
-    
-    a) First, you will need to generate a matterport API Token:
-
-    1. Navigate to https://my.matterport.com/settings/account/devtools
-        
-    1. Generate an API token
-        
-    1. Your API token ID then functions as your username, passed to the download script with --username, and your API token secret functions as your password, passed to the download script with --password. Note: Make sure to write your API token secret down, you can't reveal it again!
-
-    b)  Install [Habitat-Sim](https://github.com/facebookresearch/habitat-sim/) to get access to our dataset downloader:
 
-    1. Prepare your [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/) env:
-        ```bash
-        # We require python>=3.7 and cmake>=3.10
-        conda create -n habitat python=3.7 cmake=3.14.0
-        conda activate habitat
-        ```
-
-    1. Install Habitat-Sim using our custom Conda package for habitat challenge 2022 with: 
-        ```
-        conda install habitat-sim-challenge-2022 -c conda-forge -c aihabitat
-        ```
-        In case you face any issues related to the `GLIBCXX` version after conda installation, please uninstall this conda package and install the habitat-sim repository from source (more information [here](https://github.com/facebookresearch/habitat-sim/blob/main/BUILD_FROM_SOURCE.md#build-from-source)). Make sure that you are using the `challenge-2022` tag and not the `stable` branch for your installation.
+    Note #1: you may need `sudo` privileges to run this command.
 
-    c) Now, you are ready to download. Start by downloading the val split, which we will use in the following steps:
-
-      ```bash
-      python -m habitat_sim.utils.datasets_download --username <api-token-id> --password <api-token-secret> --uids hm3d_val --data-path <path to download folder>
-      ```
-    Replace `val` by `train` or `example` to download the different splits. By default, downloading the data for `train/val/example` scenes also pulls in the semantic annotations and configs for [HM3D-Semantics v0.1](https://aihabitat.org/datasets/hm3d-semantics/). To download only the semantic files for these splits, use the uid `hm3d_semantics`.
-
-    **Note**: We do not support loading of semantic annotations inside the challenge docker and the usage of semantic annotations is not allowed during evaluation on EvalAI. This is to prevent the navigating agent from accessing ground truth information during testing. To load the semantic annotations outside of the docker, take a look at the instructions posted [here](https://github.com/facebookresearch/habitat-sim/blob/main/DATASETS.md#loading-semantics-for-hm3d).
-
-    d) Create a symlink to the downloaded data in your habitat-challenge repository: 
+    Note #2: Please make sure that you keep your local version of `fairembodied/habitat-challenge:habitat_rearrangement_2022_base_docker` image up to date with the image we have hosted on [dockerhub](https://hub.docker.com/r/fairembodied/habitat-challenge/tags). This can be done by pruning all cached images, using:
     ```
-    mkdir -p habitat-challenge-data/data/scene_datasets/
-    ln -s <absolute path to download folder>/scene_datasets/hm3d habitat-challenge-data/data/scene_datasets/hm3d
+    docker system prune -a
     ```
 
 1. Evaluate your docker container locally:
     ```bash
-    ./test_locally_objectnav_rgbd.sh --docker-name objectnav_submission
+    bash ./scripts/test_local.sh --docker-name rearrange_submission
     ```
     If the above command runs successfully you will get an output similar to:
     ```
-    2022-02-14 01:23:51,798 initializing sim Sim-v0
-    2022-02-14 01:23:52,820 initializing task Nav-v0
-    2022-02-14 01:23:56,339 distance_to_goal: 5.205519378185272
-    2022-02-14 01:23:56,339 spl: 0.0
+    2022-07-14 22:03:05,811 Initializing dataset RearrangeDataset-v0
+    2022-07-14 22:03:05,811 Rearrange task assets are not downloaded locally, downloading and extracting now...
+    2022-07-14 22:03:05,812 Downloaded and extracted the data.
+    2022-07-14 22:03:05,818 initializing sim RearrangeSim-v0
+    2022-07-14 22:03:06,214 Initializing task RearrangeCompositeTask-v0
+    2022-07-14 22:03:08,822 object_to_goal_distance/30: 4.302241203188896
+    2022-07-14 22:03:08,822 robot_force/accum: 657186.0750969499
+    2022-07-14 22:03:08,823 robot_force/instant: 657193.0133517366
+    2022-07-14 22:03:08,823 force_terminate: 0.05
+    2022-07-14 22:03:08,823 robot_collisions/total_collisions: 0.0
+    2022-07-14 22:03:08,823 robot_collisions/robot_obj_colls: 0.0
+    2022-07-14 22:03:08,823 robot_collisions/robot_scene_colls: 0.0
+    2022-07-14 22:03:08,823 robot_collisions/obj_scene_colls: 0.0
+    2022-07-14 22:03:08,823 ee_to_object_distance/30: 4.221194922924042
+    2022-07-14 22:03:08,823 does_want_terminate: 1.0
+    2022-07-14 22:03:08,823 composite_success: 0.0
+    2022-07-14 22:03:08,823 composite_bad_called_terminate: 1.0
+    2022-07-14 22:03:08,823 num_steps: 1.0
+    2022-07-14 22:03:08,823 did_violate_hold_constraint: 0.0
+    2022-07-14 22:03:08,823 move_obj_reward: -0.5103676795959473
     ```
     Note: this same command will be run to evaluate your agent for the leaderboard. **Please submit your docker for remote evaluation (below) only if it runs successfully on your local setup.**
 
-### Online submission
+### Online submission 
+Follow instructions in the [submit tab of the EvalAI challenge page](https://eval.ai/web/challenges/challenge-page/1820/submission) to submit your docker image. Note that you will need a version of EvalAI >= 1.2.3. The challenge consists of the following phases:
 
-Follow instructions in the `submit` tab of the [EvalAI challenge page](https://eval.ai/web/challenges/challenge-page/1615/submission) to submit your docker image. Note that you will need a version of EvalAI `>= 1.3.13`. Pasting those instructions here for convenience:
+1. *Minival phase*: This split is used in the local evaluation scripts in this repository. The purpose of this phase/split is sanity checking -- to confirm that our remote evaluation reports the same result as the one you’re seeing locally.
 
-```bash
-# Installing EvalAI Command Line Interface
-pip install "evalai>=1.3.13"
+1. *Test Standard phase*: The purpose of this phase/split is to serve as the public leaderboard establishing the state of the art; this is what should be used to report results in papers. Each team is allowed maximum of 10 submissions per day for this phase, but again, please use them judiciously. Don’t overfit to the test set.
 
-# Set EvalAI account token
-evalai set_token <your EvalAI participant token>
+1. *Test Challenge phase*: This phase/split will be used to decide challenge winners. Each team is allowed a total of 5 submissions until the end of challenge submission phase. The highest performing of these 5 will be automatically chosen. Results on this split will not be made public until the announcement of final results at NeurIPS 2022.
 
-# Push docker image to EvalAI docker registry
-evalai push objectnav_submission:latest --phase <phase-name>
-```
+Note: Your agent will be evaluated on 1000 episodes and will have a total available time of 48 hours to finish. Your submissions will be evaluated on AWS EC2 p2.xlarge instance which has a Tesla K80 GPU (12 GB Memory), 4 CPU cores, and 61 GB RAM. If you need more time/resources for evaluation of your submission please get in touch. If you face any issues or have questions you can ask them by opening an issue on this repository.
 
-Valid phase names are `habitat-objectnav-{minival, test-standard, test-challenge}-2022-1615`. The challenge consists of the following phases:
+### DD-PPO Training Starter Code
+In this example, we will train and evaluate an end-to-end policy trained with DD-PPO. You will run all the subsequent steps from the `habitat` conda environment.
 
-1. **Minival phase**: This split is same as the one used in `./test_locally_objectnav_rgbd.sh`. The purpose of this phase/split is sanity checking -- to confirm that our remote evaluation reports the same result as the one you’re seeing locally. Each team is allowed maximum of 100 submissions per day for this phase, but please use them judiciously. We will block and disqualify teams that spam our servers.
-1. **Test Standard phase**: The purpose of this phase/split is to serve as the public leaderboard establishing the state of the art; this is what should be used to report results in papers. Each team is allowed maximum of 10 submissions per day for this phase, but again, please use them judiciously. Don’t overfit to the test set.
-1. **Test Challenge phase**: This phase/split will be used to decide challenge winners. Each team is allowed a total of 5 submissions until the end of challenge submission phase. The highest performing of these 5 will be automatically chosen. Results on this split will not be made public until the announcement of final results at the [Embodied AI workshop at CVPR](https://embodied-ai.org/).
-
-Note: Your agent will be evaluated on 1000 episodes and will have a total available time of 48 hours to finish. Your submissions will be evaluated on AWS EC2 p3.2xlarge instance which has a V100 GPU (16 GB Memory), 8 vCPU cores, and 61 GB RAM. If you need more time/resources for evaluation of your submission please get in touch. If you face any issues or have questions you can ask them by opening an issue on this repository.
-
-### ObjectNav Baselines and DD-PPO Training Starter Code
-We have added a config in `configs/ddppo_objectnav.yaml` that includes a baseline using DD-PPO from Habitat-Lab. Follow these next steps to get the DD-PPO baseline running (skip to step 3 if you have completed step 5.b from the local evaluation section):
-
-1. Prepare your [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/) env:
-    ```bash
-    # We require python>=3.7 and cmake>=3.10
-    conda create -n habitat python=3.7 cmake=3.14.0
-    conda activate habitat
-    ```
-
-1. Install [Habitat-Sim](https://github.com/facebookresearch/habitat-sim/) - Use our custom Conda package for habitat challenge 2022: 
+1. Install [Habitat-Lab](https://github.com/facebookresearch/habitat-lab/) - Use the `rearrange_challenge_2022` branch in our Github repo, which can be cloned using: 
     ```
-    conda install habitat-sim-challenge-2022 -c conda-forge -c aihabitat
-    ```
-    In case you face any issues related to the `GLIBCXX` version after conda installation, please uninstall this conda package and install the habitat-sim repository from source (more information [here](https://github.com/facebookresearch/habitat-sim/blob/main/BUILD_FROM_SOURCE.md#build-from-source)). Make sure that you are using the `challenge-2022` tag and not the `stable` branch for your installation.
-
-1. Install [Habitat-Lab](https://github.com/facebookresearch/habitat-lab/) - We have created the `habitat-challenge-2022` tag in our Github repo, which can be cloned using: 
-    ```
-    git clone --branch challenge-2022 https://github.com/facebookresearch/habitat-lab.git
+    git clone --branch rearrange_challenge_2022 https://github.com/facebookresearch/habitat-lab.git
     ``` 
-    Also ensure that habitat-baselines is installed when installing Habitat-Lab by using ```python setup.py develop --all``` . You will find further information for installation in the Github repositories. 
-
-1. Download the episode dataset for HM3D ObjectNav from [link](https://dl.fbaipublicfiles.com/habitat/data/datasets/objectnav/hm3d/v1/objectnav_hm3d_v1.zip) and place it in the folder `habitat-challenge/habitat-challenge-data/data/datasets/objectnav/hm3d`.
-    ```bash
-    wget https://dl.fbaipublicfiles.com/habitat/data/datasets/objectnav/hm3d/v1/objectnav_hm3d_v1.zip -P habitat-challenge-data/objectgoal_hm3d
+    Install Habitat Lab along with the included RL trainer code by first entering the `habitat-lab` directory, activating the `habitat` conda environment from step 1, and then running `pip install -r requirements.txt && python setup.py develop --all`. 
 
-    unzip habitat-challenge-data/objectgoal_hm3d/objectnav_hm3d_v1.zip -d habitat-challenge-data/objectgoal_hm3d
-    mv habitat-challenge-data/objectgoal_hm3d/objectnav_hm3d_v1/* habitat-challenge-data/objectgoal_hm3d
-    rm -r habitat-challenge-data/objectgoal_hm3d/objectnav_hm3d_v1*
-    ```
-
-    If placed correctly, you should see the train, val and val mini splits in the `habitat-challenge-data/objectgoal_hm3d/{train, val, val_mini}` folders respectively. 
-
-1. An example on how to train DD-PPO model can be found in [habitat-lab/habitat_baselines/rl/ddppo](https://github.com/facebookresearch/habitat-lab/tree/main/habitat_baselines/rl/ddppo). See the corresponding README in habitat-lab for how to adjust the various hyperparameters, save locations, visual encoders and other features.
+1. Follow this documentation for how to run DD-PPO in a single or multi-machine setup. See [habitat_baselines/ddppo](https://github.com/facebookresearch/habitat-lab/tree/main/habitat_baselines/rl/ddppo) for more information. These commands assume `habitat-lab` and `habitat-challenge` are in the same directory. Modify the paths in the arguments if your `habitat-challenge` directory is located somewhere else.
 
     1. To run on a single machine use the following script from `habitat-lab` directory:
         ```bash
         #/bin/bash
 
-        export GLOG_minloglevel=2
         export MAGNUM_LOG=quiet
         export HABITAT_SIM_LOG=quiet
 
         set -x
-        python -u -m torch.distributed.launch \
-            --use_env \
-            --nproc_per_node 1 \
-            habitat_baselines/run.py \
-            --exp-config ../habitat-challenge/configs/ddppo_objectnav.yaml \
+        python habitat_baselines/run.py \
+            --exp-config ../habitat-challenge/configs/methods/ddppo_monolithic.yaml \
             --run-type train \
-            BASE_TASK_CONFIG_PATH ../habitat-challenge/configs/challenge_objectnav2022.local.rgbd.yaml \
-            TASK_CONFIG.DATASET.DATA_PATH ../habitat-challenge/habitat-challenge-data/objectgoal_hm3d/{split}/{split}.json.gz \
-            TASK_CONFIG.DATASET.SCENES_DIR ../habitat-challenge/habitat-challenge-data/data/scene_datasets/ \
+            BASE_TASK_CONFIG_PATH ../habitat-challenge/configs/tasks/rearrange.local.rgbd.yaml \
             TASK_CONFIG.DATASET.SPLIT 'train' \
+            TASK_CONFIG.TASK.TASK_SPEC_BASE_PATH ../habitat-challenge/configs/pddl/ \
             TENSORBOARD_DIR ./tb \
             CHECKPOINT_FOLDER ./checkpoints \
             LOG_FILE ./train.log
         ```
-    1. There is also an example of running the code distributed on a cluster with SLURM. While this is not necessary, if you have access to a cluster, it can significantly speed up training. To run on multiple machines in a SLURM cluster run the following script: change ```#SBATCH --nodes $NUM_OF_MACHINES``` to the number of machines and ```#SBATCH --ntasks-per-node $NUM_OF_GPUS``` and ```$SBATCH --gres $NUM_OF_GPUS``` to specify the number of GPUS to use per requested machine.
+    1. To run on a cluster with SLURM using distributed training run the following script. While this is not necessary, if you have access to a cluster, it can significantly speed up training. To run on multiple machines in a SLURM cluster run the following script: change `#SBATCH --nodes $NUM_OF_MACHINES` to the number of machines and `#SBATCH --ntasks-per-node $NUM_OF_GPUS` and `$SBATCH --gres $NUM_OF_GPUS` to specify the number of GPUS to use per requested machine.
         ```bash
         #!/bin/bash
         #SBATCH --job-name=ddppo
@@ -256,86 +175,112 @@ We have added a config in `configs/ddppo_objectnav.yaml` that includes a baselin
         #SBATCH --signal=USR1@600
         #SBATCH --partition=dev
 
-        export GLOG_minloglevel=2
         export MAGNUM_LOG=quiet
+        export HABITAT_SIM_LOG=quiet
 
         export MAIN_ADDR=$(srun --ntasks=1 hostname 2>&1 | tail -n1)
 
         set -x
         srun python -u -m habitat_baselines.run \
-            --exp-config ../habitat-challenge/configs/ddppo_objectnav.yaml \
+            habitat_baselines/run.py \
+            --exp-config ../habitat-challenge/configs/methods/ddppo_monolithic.yaml \
             --run-type train \
-            BASE_TASK_CONFIG_PATH ../habitat-challenge/configs/challenge_objectnav2022.local.rgbd.yaml \
-            TASK_CONFIG.DATASET.DATA_PATH ../habitat-challenge/habitat-challenge-data/objectgoal_hm3d/{split}/{split}.json.gz \
-            TASK_CONFIG.DATASET.SCENES_DIR ../habitat-challenge/habitat-challenge-data/data/scene_datasets/ \
+            BASE_TASK_CONFIG_PATH ../habitat-challenge/configs/tasks/rearrange.local.rgbd.yaml \
+            TASK_CONFIG.DATASET.DATA_PATH ../habitat-challenge/data/datasets/replica_cad/rearrange/v1/{split}/rearrange.json.gz \
+            TASK_CONFIG.DATASET.SCENES_DIR ../habitat-challenge/data/replica_cad/ \
             TASK_CONFIG.DATASET.SPLIT 'train' \
+            TASK_CONFIG.TASK.TASK_SPEC_BASE_PATH ../habitat-challenge/configs/pddl/ \
             TENSORBOARD_DIR ./tb \
             CHECKPOINT_FOLDER ./checkpoints \
             LOG_FILE ./train.log
         ```
 
-    1. The preceding two scripts are based off ones found in the [habitat_baselines/ddppo](https://github.com/facebookresearch/habitat-lab/tree/main/habitat_baselines/rl/ddppo).
-
-1. The checkpoint specified by ```$PATH_TO_CHECKPOINT``` can evaluated using SPL and other measurements by running the following command:
+1. More instructions on how to train the DD-PPO model can be found in [habitat-lab/habitat_baselines/rl/ddppo](https://github.com/facebookresearch/habitat-lab/tree/main/habitat_baselines/rl/ddppo). See the corresponding README in habitat-lab for how to adjust the various hyperparameters, save locations, visual encoders and other features.
 
+1. Evaluate on the minival dataset for the `rearrange_easy` task from the command line via. First enter the `habitat-challenge` directory. Ensure, you have the datasets installed in this directory as well. If not, run `python -m habitat_sim.utils.datasets_download --uids rearrange_task_assets`.
     ```bash
-    python -u -m habitat_baselines.run \
-        --exp-config ../habitat-challenge/configs/ddppo_objectnav.yaml \
-        --run-type eval \
-        BASE_TASK_CONFIG_PATH ../habitat-challenge/configs/challenge_objectnav2022.local.rgbd.yaml \
-        TASK_CONFIG.DATASET.DATA_PATH ../habitat-challenge/habitat-challenge-data/objectgoal_hm3d/{split}/{split}.json.gz \
-        TASK_CONFIG.DATASET.SCENES_DIR ../habitat-challenge/habitat-challenge-data/data/scene_datasets/ \
-        EVAL_CKPT_PATH_DIR $PATH_TO_CHECKPOINT \
-        TASK_CONFIG.DATASET.SPLIT val
-    ```
-    The weights used for our DD-PPO Objectnav baseline for the Habitat-2022 challenge can be downloaded with the following command:
-    ```bash
-    wget https://dl.fbaipublicfiles.com/habitat/data/baselines/v1/ddppo_objectnav_habitat2022_challenge_baseline_v1.pth
+    CHALLENGE_CONFIG_FILE=configs/tasks/rearrange_easy.local.rgbd.yaml python agents/habitat_baselines_agent.py --evaluation local --input-type depth --cfg-path configs/methods/ddppo_monolithic.yaml --model-path data/models/rearrange_easy.pth
     ```
 
-1. We provide Dockerfiles ready to use with the DD-PPO baselines in `Objectnav_DDPPO_baseline.Dockerfile`. For the sake of completeness, we describe how you can make your own Dockerfile below. If you just want to test the baseline code, feel free to skip this bullet because  ```Objectnav_DDPPO_baseline.Dockerfile``` is ready to use.
-    1. You may want to modify the `Objectnav_DDPPO_baseline.Dockerfile` to include torchvision or other libraries. To install torchvision, ifcfg and tensorboard, add the following command to the Docker file:
+1. We provide Dockerfiles ready to use with the DD-PPO baselines in `docker/hab2_monolithic.Dockerfile`. For the sake of completeness, we describe how you can make your own Dockerfile below. If you just want to test the baseline code, feel free to skip this bullet because  `hab2_DDPPO_baseline.Dockerfile` is ready to use.
+    1. You may want to modify the `hab2_DDPPO_baseline.Dockerfile` to include torchvision or other libraries. To install torchvision, ifcfg and tensorboard, add the following command to the Docker file:
         ```dockerfile
         RUN /bin/bash -c ". activate habitat; pip install ifcfg torchvision tensorboard"
         ```
-    1. You change which ```agent.py``` and which ``submission.sh`` script is used in the Docker, modify the following lines and replace the first agent.py or submission.sh with your new files.:
+    1. You change which `agent.py` is used in the Docker, modify the following lines and replace the agent.py file with your new file:
         ```dockerfile
         ADD agent.py agent.py
-        ADD submission.sh submission.sh
         ```
-    1. Do not forget to add any other files you may need in the Docker, for example, we add the ```demo.ckpt.pth``` file which is the saved weights from the DD-PPO example code.
+    1. Do not forget to add any other files you may need in the Docker, for example, we add the `data/models/rearrange_easy.pth` file which is the saved weights from the DD-PPO example code.
 
-    1. Finally, modify the submission.sh script to run the appropriate command to test your agents. The scaffold for this code can be found ```agent.py``` and the DD-PPO specific agent can be found in ```ddppo_agents.py```. In this example, we only modify the final command of the ObjectNav docker: by adding the following args to submission.sh ```--model-path demo.ckpt.pth --input-type rgbd```. The default submission.sh script will pass these args to the python script. You may also replace the submission.sh.
-        1. Please note that at this time, that habitat_baselines uses a slightly different config system, and the configs nodes for habitat are defined under TASK_CONFIG which is loaded at runtime from BASE_TASK_CONFIG_PATH. We manually overwrite this config using the opts args in our agent.py file.
+    1. The scaffold for this code can be found `agents/random_agent.py` and the code for policies trained with Habitat Baselines can be found in `agents/habitat_baselines_agent.py`. 
 
 1. Once your Dockerfile and other code is modified to your satisfaction, build it with the following command.
     ```bash
-    docker build . --file Objectnav_DDPPO_baseline.Dockerfile -t objectnav_submission
+    docker build . --file docker/hab2_monolithic.Dockerfile -t rearrange_submission
+    ```
+1. To test locally simply run the `bash scripts/test_local.sh --docker-name rearrange_submission` script. If the docker runs your code without errors, it should work on Eval-AI. The instructions for submitting the Docker to EvalAI are listed above.
+
+### Hierarchical RL Starter Code
+First, you will need to train individual skill policies with RL. In this example we will approach the `rearrange_easy` task by training a Pick, Place, and Navigation policy and then plug them into a hard-coded high-level controller.
+1. Follow step 1 of [the DD-PPO section](https://github.com/facebookresearch/habitat-challenge/tree/rearrangement-challenge-2022#dd-ppo-training-starter-code) to install install Habitat-Lab, and download the datasets.
+
+1. Steps to train the skills from scratch:
+
+    1. Train the Pick skill. From the Habitat Lab directory, run 
+    ```bash
+    python habitat_baselines/run.py \
+        --exp-config habitat_baselines/config/rearrange/ddppo_pick.yaml \
+        --run-type train \
+        TENSORBOARD_DIR ./pick_tb/ \
+        CHECKPOINT_FOLDER ./pick_checkpoints/ \
+        LOG_FILE ./pick_train.log
+    ```
+    1. Train the Place skill. Use the exact same command as the above, but replace every instance of "pick" with "place".
+    1. Train the Navigation skill. Use the exact same command as the above, but replace every instance of "pick" with "nav_to_obj".
+    1. Copy the checkpoints for the different skills to the `data/models` directory in the Habitat Challenge directory. There should now be three files `data/models/[nav,pick,place].pth`.
+
+1. Instead of training the skills, you can also use the provided pre-trained skills. Download the skills via `wget https://dl.fbaipublicfiles.com/habitat/data/baselines/v1/rearrange_habitat2022_challenge_baseline_v1.zip && unzip rearrange_habitat2022_challenge_baseline_v1.zip`.
+
+1. Finally, evaluate the combined policies on the minival dataset for the `rearrange_easy` task from the command line. First enter the `habitat-challenge` directory. Ensure, you have the datasets installed in this directory as well. If not, run `python -m habitat_sim.utils.datasets_download --uids rearrange_task_assets`.
+    ```bash
+    CHALLENGE_CONFIG_FILE=configs/tasks/rearrange_easy.local.rgbd.yaml python agents/habitat_baselines_agent.py --evaluation local --input-type depth --cfg-path configs/methods/tp_srl.yaml
     ```
-1. To test locally simple run the ```test_locally_objectnav_rgbd.sh``` script. If the docker runs your code without errors, it should work on Eval-AI. The instructions for submitting the Docker to EvalAI are listed above.
-1. Happy hacking!
+    Using the pre-trained skills from the Google Drive, you should see around a `30%` success rate.
+
+1. Just like with the DD-PPO baseline, we provide a Dockerfile ready to use in `docker/tpsrl_monolithic.Dockerfile`. See the instructions in the [DD-PPO section](https://github.com/facebookresearch/habitat-challenge/tree/rearrangement-challenge-2022#dd-ppo-training-starter-code) for how to modify Dockerfile, build it, and test it.
+
+## Change Log
+* Sept 7, 2022: Fixed problem with collision threshold and concurrent rendering in the configuration files.
 
-## Citing Habitat Challenge 2022
-Please cite [the following paper](https://arxiv.org/abs/2006.13171) for details about the 2022 ObjectNav challenge:
+## Citing Habitat Rearrangement Challenge 2022
+Please cite the challenge and [the following paper](https://arxiv.org/abs/2106.14405) for details about the 2022 Rearrangement challenge:
 ```
-@misc{habitatchallenge2022,
-  title         =     Habitat Challenge 2022,
-  author        =     {Karmesh Yadav and Santhosh Kumar Ramakrishnan and Aaron Gokaslan and Oleksandr Maksymets and Rishabh Jain and Ram Ramrakhya and Angel X Chang and Alexander Clegg and Manolis Savva and Eric Undersander and Devendra Singh Chaplot and Dhruv Batra},
-  howpublished  =     {\url{https://aihabitat.org/challenge/2022/}},
+@misc{habitatrearrangechallenge2022,
+  title         =     Habitat Rearrangement Challenge 2022,
+  author        =     {Andrew Szot, Karmesh Yadav, Alex Clegg, Vincent-Pierre Berges, Aaron Gokaslan, Angel Chang, Manolis Savva, Zsolt Kira, Dhruv Batra},
+  howpublished  =     {\url{https://aihabitat.org/challenge/2022_rearrange}},
   year          =     {2022}
 }
 ```
 
+```
+@article{szot2021habitat,
+  title={Habitat 2.0: Training home assistants to rearrange their habitat},
+  author={Szot, Andrew and Clegg, Alexander and Undersander, Eric and Wijmans, Erik and Zhao, Yili and Turner, John and Maestre, Noah and Mukadam, Mustafa and Chaplot, Devendra Singh and Maksymets, Oleksandr and others},
+  journal={Advances in Neural Information Processing Systems},
+  volume={34},
+  pages={251--266},
+  year={2021}
+}
+```
+
 ## Acknowledgments
 
-The Habitat challenge would not have been possible without the infrastructure and support of [EvalAI](https://evalai.cloudcv.org/) team. We also thank the team behind [Habitat-Matterport3D](https://aihabitat.org/datasets/hm3d/) datasets.
+The Habitat challenge would not have been possible without the infrastructure and support of [EvalAI](https://evalai.cloudcv.org/) team.
 
 ## References
 
 [1] [Habitat: A Platform for Embodied AI Research](https://arxiv.org/abs/1904.01201). Manolis Savva\*, Abhishek Kadian\*, Oleksandr Maksymets\*, Yili Zhao, Erik Wijmans, Bhavana Jain, Julian Straub, Jia Liu, Vladlen Koltun, Jitendra Malik, Devi Parikh, Dhruv Batra. IEEE/CVF International Conference on Computer Vision (ICCV), 2019.
 
-[2] [Habitat-Matterport 3D Dataset (HM3D): 1000 Large-scale 3D Environments for Embodied AI](https://arxiv.org/abs/2109.08238) Santhosh K. Ramakrishnan, Aaron Gokaslan, Erik Wijmans, Oleksandr Maksymets, Alex Clegg, John Turner, Eric Undersander, Wojciech Galuba, Andrew Westbury, Angel X. Chang, Manolis Savva, Yili Zhao, Dhruv Batra. arXiv:2109.08238, 2021.
-
-[3] [Object Goal Navigation using Goal-Oriented Semantic Exploration](https://arxiv.org/abs/2007.00643) Devendra Singh Chaplot, Dhiraj Gandhi, Abhinav Gupta, Ruslan Salakhutdinov. NeurIPS, 2020.
 
-[4] [On evaluation of embodied navigation agents](https://arxiv.org/abs/1807.06757). Peter Anderson, Angel Chang, Devendra Singh Chaplot, Alexey Dosovitskiy, Saurabh Gupta, Vladlen Koltun, Jana Kosecka, Jitendra Malik, Roozbeh Mottaghi, Manolis Savva, Amir R. Zamir. arXiv:1807.06757, 2018.
diff --git a/agents/__init__.py b/agents/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/ddppo_agents.py b/agents/habitat_baselines_agent.py
similarity index 52%
rename from ddppo_agents.py
rename to agents/habitat_baselines_agent.py
index 8ff3417..1aa97a9 100644
--- a/ddppo_agents.py
+++ b/agents/habitat_baselines_agent.py
@@ -10,17 +10,17 @@
 import random
 from typing import Dict, Optional
 
+import gym.spaces as spaces
 import numba
 import numpy as np
 import torch
-from gym.spaces import Box
-from gym.spaces import Dict as SpaceDict
-from gym.spaces import Discrete
 
 import habitat
 from habitat.config import Config
 from habitat.core.agent import Agent
 from habitat.core.simulator import Observations
+from habitat.core.spaces import ActionSpace, EmptySpace
+from habitat.utils.gym_adapter import continuous_vector_action_to_hab_dict
 from habitat_baselines.common.baseline_registry import baseline_registry
 from habitat_baselines.common.obs_transformers import (
     apply_obs_transforms_batch,
@@ -29,10 +29,13 @@
 )
 from habitat_baselines.config.default import get_config
 from habitat_baselines.rl.ddppo.policy import PointNavResNetPolicy
-from habitat_baselines.utils.common import batch_obs
+from habitat_baselines.utils.common import batch_obs, get_num_actions
 
 random_generator = np.random.RandomState()
 
+CAMERA_HEIGHT = 256
+CAMERA_WIDTH = 256
+
 
 @numba.njit
 def _seed_numba(seed: int):
@@ -53,54 +56,97 @@ def sample_random_seed():
 
 class PPOAgent(Agent):
     def __init__(self, config: Config) -> None:
-        image_size = config.RL.POLICY.OBS_TRANSFORMS.CENTER_CROPPER
-        if "ObjectNav" in config.TASK_CONFIG.TASK.TYPE:
-            OBJECT_CATEGORIES_NUM = 5
-            spaces = {
-                "objectgoal": Box(
-                    low=0, high=OBJECT_CATEGORIES_NUM, shape=(1,), dtype=np.int64
+        obs_space = spaces.Dict(
+            {
+                "robot_head_depth": spaces.Box(
+                    low=0,
+                    high=1,
+                    shape=(CAMERA_HEIGHT, CAMERA_WIDTH, 1),
+                    dtype=np.float32,
+                ),
+                "robot_head_rgb": spaces.Box(
+                    low=0,
+                    high=255,
+                    shape=(CAMERA_HEIGHT, CAMERA_WIDTH, 1),
+                    dtype=np.float32,
+                ),
+                "obj_start_sensor": spaces.Box(
+                    low=np.finfo(np.float32).min,
+                    high=np.finfo(np.float32).max,
+                    shape=(3,),
+                    dtype=np.float32,
+                ),
+                "obj_goal_sensor": spaces.Box(
+                    low=np.finfo(np.float32).min,
+                    high=np.finfo(np.float32).max,
+                    shape=(3,),
+                    dtype=np.float32,
                 ),
-                "compass": Box(low=-np.pi, high=np.pi, shape=(1,), dtype=np.float32),
-                "gps": Box(
+                "obj_start_gps_compass": spaces.Box(
                     low=np.finfo(np.float32).min,
                     high=np.finfo(np.float32).max,
                     shape=(2,),
                     dtype=np.float32,
                 ),
-            }
-        else:
-            spaces = {
-                "pointgoal": Box(
+                "obj_goal_gps_compass": spaces.Box(
                     low=np.finfo(np.float32).min,
                     high=np.finfo(np.float32).max,
                     shape=(2,),
                     dtype=np.float32,
-                )
+                ),
+                "joint": spaces.Box(
+                    low=np.finfo(np.float32).min,
+                    high=np.finfo(np.float32).max,
+                    shape=(7,),
+                    dtype=np.float32,
+                ),
+                "is_holding": spaces.Box(
+                    low=np.finfo(np.float32).min,
+                    high=np.finfo(np.float32).max,
+                    shape=(1,),
+                    dtype=np.float32,
+                ),
+                "relative_resting_position": spaces.Box(
+                    low=np.finfo(np.float32).min,
+                    high=np.finfo(np.float32).max,
+                    shape=(3,),
+                    dtype=np.float32,
+                ),
+            }
+        )
+        self.action_space = ActionSpace(
+            {
+                "ARM_ACTION": spaces.Dict(
+                    {
+                        "arm_action": spaces.Box(
+                            low=-1.0, high=1.0, shape=(7,), dtype=np.float32
+                        ),
+                        "grip_action": spaces.Box(
+                            low=-1.0, high=1.0, shape=(1,), dtype=np.float32
+                        ),
+                    }
+                ),
+                "BASE_VELOCITY": spaces.Dict(
+                    {
+                        "base_vel": spaces.Box(
+                            low=-20.0, high=20.0, shape=(2,), dtype=np.float32
+                        )
+                    }
+                ),
+                "REARRANGE_STOP": EmptySpace(),
             }
+        )
 
-        if config.INPUT_TYPE in ["depth", "rgbd"]:
-            spaces["depth"] = Box(
-                low=0,
-                high=1,
-                shape=(image_size.HEIGHT, image_size.WIDTH, 1),
-                dtype=np.float32,
-            )
+        if config.INPUT_TYPE == "blind":
+            del obs_space.spaces["robot_head_depth"]
+            del obs_space.spaces["robot_head_rgb"]
+        elif config.INPUT_TYPE == "depth":
+            del obs_space.spaces["robot_head_rgb"]
+        elif config.INPUT_TYPE == "rgb":
+            del obs_space.spaces["robot_head_depth"]
 
-        if config.INPUT_TYPE in ["rgb", "rgbd"]:
-            spaces["rgb"] = Box(
-                low=0,
-                high=255,
-                shape=(image_size.HEIGHT, image_size.WIDTH, 3),
-                dtype=np.uint8,
-            )
-        observation_spaces = SpaceDict(spaces)
-        action_spaces = (
-            Discrete(6) if "ObjectNav" in config.TASK_CONFIG.TASK.TYPE else Discrete(4)
-        )
         self.obs_transforms = get_active_obs_transforms(config)
-        observation_spaces = apply_obs_transforms_obs_space(
-            observation_spaces, self.obs_transforms
-        )
+        obs_space = apply_obs_transforms_obs_space(obs_space, self.obs_transforms)
 
         self.device = (
             torch.device("cuda:{}".format(config.PTH_GPU_ID))
@@ -115,7 +161,15 @@ def __init__(self, config: Config) -> None:
 
         policy = baseline_registry.get_policy(config.RL.POLICY.name)
         self.actor_critic = policy.from_config(
-            config, observation_spaces, action_spaces
+            config,
+            obs_space,
+            spaces.Box(
+                shape=(get_num_actions(self.action_space),),
+                low=-1,
+                high=1,
+                dtype=np.float32,
+            ),
+            orig_action_space=self.action_space,
         )
 
         self.actor_critic.to(self.device)
@@ -133,7 +187,7 @@ def __init__(self, config: Config) -> None:
 
         else:
             habitat.logger.error(
-                "Model checkpoint wasn't loaded, evaluating " "a random model."
+                "Model checkpoint wasn't loaded, evaluating a random model."
             )
 
         self.test_recurrent_hidden_states: Optional[torch.Tensor] = None
@@ -143,19 +197,24 @@ def __init__(self, config: Config) -> None:
     def reset(self) -> None:
         self.test_recurrent_hidden_states = torch.zeros(
             1,
-            self.actor_critic.net.num_recurrent_layers,
+            self.actor_critic.num_recurrent_layers,
             self.hidden_size,
             device=self.device,
         )
         self.not_done_masks = torch.zeros(1, 1, device=self.device, dtype=torch.bool)
-        self.prev_actions = torch.zeros(1, 1, dtype=torch.long, device=self.device)
+        self.prev_actions = torch.zeros(
+            1,
+            get_num_actions(self.action_space),
+            dtype=torch.float32,
+            device=self.device,
+        )
 
     def act(self, observations: Observations) -> Dict[str, int]:
         sample_random_seed()
         batch = batch_obs([observations], device=self.device)
         batch = apply_obs_transforms_batch(batch, self.obs_transforms)
         with torch.no_grad():
-            (_, actions, _, self.test_recurrent_hidden_states) = self.actor_critic.act(
+            (_, actions, _, self.test_recurrent_hidden_states,) = self.actor_critic.act(
                 batch,
                 self.test_recurrent_hidden_states,
                 self.prev_actions,
@@ -166,24 +225,30 @@ def act(self, observations: Observations) -> Dict[str, int]:
             self.not_done_masks.fill_(True)
             self.prev_actions.copy_(actions)  # type: ignore
 
-        return {"action": actions[0][0].item()}
+        step_action = continuous_vector_action_to_hab_dict(
+            self.action_space, None, actions[0].cpu().numpy()
+        )
+
+        return step_action
 
 
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument(
-        "--input-type", default="blind", choices=["blind", "rgb", "depth", "rgbd"]
+        "--input-type",
+        default="blind",
+        choices=["blind", "rgb", "depth", "rgbd"],
     )
     parser.add_argument(
         "--evaluation", type=str, required=True, choices=["local", "remote"]
     )
+    parser.add_argument("--cfg-path", type=str, required=True)
+
     config_paths = os.environ["CHALLENGE_CONFIG_FILE"]
     parser.add_argument("--model-path", default="", type=str)
     args = parser.parse_args()
 
-    config = get_config(
-        "configs/ddppo_objectnav.yaml", ["BASE_TASK_CONFIG_PATH", config_paths]
-    ).clone()
+    config = get_config(args.cfg_path, ["BASE_TASK_CONFIG_PATH", config_paths]).clone()
     config.defrost()
     config.PTH_GPU_ID = 0
     config.INPUT_TYPE = args.input_type
diff --git a/agent.py b/agents/random_agent.py
similarity index 70%
rename from agent.py
rename to agents/random_agent.py
index 5bd0737..00b2dab 100644
--- a/agent.py
+++ b/agents/random_agent.py
@@ -1,8 +1,8 @@
 import argparse
 import os
-import random
 
 import numpy
+import numpy as np
 
 import habitat
 
@@ -15,7 +15,15 @@ def reset(self):
         pass
 
     def act(self, observations):
-        return {"action": numpy.random.choice(self._POSSIBLE_ACTIONS)}
+        return {
+            "action": ("ARM_ACTION", "BASE_VELOCITY", "REARRANGE_STOP"),
+            "action_args": {
+                "arm_action": np.random.rand(7),
+                "grip_action": np.random.rand(1),
+                "base_vel": np.random.rand(2),
+                "REARRANGE_STOP": np.random.rand(1),
+            },
+        }
 
 
 def main():
diff --git a/configs/challenge_objectnav2022.local.rgbd.yaml b/configs/challenge_objectnav2022.local.rgbd.yaml
deleted file mode 100644
index a2dc6a6..0000000
--- a/configs/challenge_objectnav2022.local.rgbd.yaml
+++ /dev/null
@@ -1,50 +0,0 @@
-ENVIRONMENT:
-  MAX_EPISODE_STEPS: 500
-
-SIMULATOR:
-  TURN_ANGLE: 30
-  TILT_ANGLE: 30
-  ACTION_SPACE_CONFIG: "v1"
-  AGENT_0:
-    SENSORS: ['RGB_SENSOR', 'DEPTH_SENSOR']
-    HEIGHT: 0.88
-    RADIUS: 0.18
-  HABITAT_SIM_V0:
-    GPU_DEVICE_ID: 0
-    ALLOW_SLIDING: False
-  SEMANTIC_SENSOR:
-    WIDTH: 640
-    HEIGHT: 480
-    HFOV: 79
-    POSITION: [0, 0.88, 0]
-  RGB_SENSOR:
-    WIDTH: 640
-    HEIGHT: 480
-    HFOV: 79
-    POSITION: [0, 0.88, 0]
-  DEPTH_SENSOR:
-    WIDTH: 640
-    HEIGHT: 480
-    HFOV: 79
-    MIN_DEPTH: 0.5
-    MAX_DEPTH: 5.0
-    POSITION: [0, 0.88, 0]
-TASK:
-  TYPE: ObjectNav-v1
-  POSSIBLE_ACTIONS: ["STOP", "MOVE_FORWARD", "TURN_LEFT", "TURN_RIGHT", "LOOK_UP", "LOOK_DOWN"]
-
-  SENSORS: ['OBJECTGOAL_SENSOR', 'COMPASS_SENSOR', 'GPS_SENSOR']
-  GOAL_SENSOR_UUID: objectgoal
-
-  MEASUREMENTS: ['DISTANCE_TO_GOAL', 'SUCCESS', 'SPL', 'SOFT_SPL']
-
-  DISTANCE_TO_GOAL:
-    DISTANCE_TO: VIEW_POINTS
-  SUCCESS:
-    SUCCESS_DISTANCE: 0.1
-
-DATASET:
-  TYPE: ObjectNav-v1
-  SPLIT: val_mini
-  DATA_PATH: "habitat-challenge-data/objectgoal_hm3d/{split}/{split}.json.gz"
-  SCENES_DIR: "habitat-challenge-data/data/scene_datasets/"
diff --git a/configs/ddppo_objectnav.yaml b/configs/methods/ddppo_monolithic.yaml
similarity index 56%
rename from configs/ddppo_objectnav.yaml
rename to configs/methods/ddppo_monolithic.yaml
index 2aab215..efd1b55 100644
--- a/configs/ddppo_objectnav.yaml
+++ b/configs/methods/ddppo_monolithic.yaml
@@ -1,57 +1,66 @@
-BASE_TASK_CONFIG_PATH: "configs/challenge_objectnav2022.local.rgbd.yaml"
-CMD_TRAILING_OPTS: ["TASK_CONFIG.ENVIRONMENT.ITERATOR_OPTIONS.MAX_SCENE_REPEAT_STEPS", "50000"]
+VERBOSE: False
+BASE_TASK_CONFIG_PATH: configs/tasks/rearrange.local.rgbd.yaml
 TRAINER_NAME: "ddppo"
-ENV_NAME: "NavRLEnv"
+ENV_NAME: "RearrangeRLEnv"
 SIMULATOR_GPU_ID: 0
 TORCH_GPU_ID: 0
-VIDEO_OPTION: []
+VIDEO_OPTION: ["disk"]
 TENSORBOARD_DIR: "tb"
 VIDEO_DIR: "video_dir"
+VIDEO_FPS: 30
+VIDEO_RENDER_TOP_DOWN: False
+VIDEO_RENDER_ALL_INFO: True
 TEST_EPISODE_COUNT: -1
-EVAL_CKPT_PATH_DIR: "habitat-challenge-data"
-NUM_ENVIRONMENTS: 4
-SENSORS: ["DEPTH_SENSOR", "RGB_SENSOR"]
-CHECKPOINT_FOLDER: "habitat-challenge-data"
-NUM_UPDATES: 270000
+EVAL_CKPT_PATH_DIR: "data/new_checkpoints"
+NUM_ENVIRONMENTS: 32
+WRITER_TYPE: 'tb'
+# Visual sensors to include
+SENSORS: ["HEAD_DEPTH_SENSOR"]
+CHECKPOINT_FOLDER: "data/new_checkpoints"
+NUM_UPDATES: -1
+TOTAL_NUM_STEPS: 1.0e8
 LOG_INTERVAL: 10
-NUM_CHECKPOINTS: 100
+NUM_CHECKPOINTS: 20
 # Force PyTorch to be single threaded as
 # this improves performance considerably
 FORCE_TORCH_SINGLE_THREADED: True
-
+EVAL_KEYS_TO_INCLUDE_IN_NAME: ['reward', 'force', 'success']
 EVAL:
-  SPLIT: "val"
+  SPLIT: 'minival'
 
 RL:
-  SUCCESS_REWARD: 2.5
-  SLACK_REWARD: -1e-3
-
   POLICY:
-    name: "PointNavResNetPolicy"
-    OBS_TRANSFORMS:
-      ENABLED_TRANSFORMS: ("ResizeShortestEdge", "CenterCropper")
-
+      name: "PointNavResNetPolicy"
+      action_distribution_type: "gaussian"
+      ACTION_DIST:
+         use_log_std: True
   PPO:
     # ppo params
     clip_param: 0.2
-    ppo_epoch: 4
+    ppo_epoch: 2
     num_mini_batch: 2
     value_loss_coef: 0.5
-    entropy_coef: 0.01
+    entropy_coef: 0.0001
     lr: 2.5e-4
     eps: 1e-5
     max_grad_norm: 0.2
-    num_steps: 64
+    num_steps: 128
     use_gae: True
     gamma: 0.99
     tau: 0.95
     use_linear_clip_decay: False
     use_linear_lr_decay: False
     reward_window_size: 50
+
     use_normalized_advantage: False
 
     hidden_size: 512
 
+    # Use double buffered sampling, typically helps
+    # when environment time is similar or large than
+    # policy inference time during rollout generation
+    use_double_buffered_sampler: False
+
   DDPPO:
     sync_frac: 0.6
     # The PyTorch distributed backend to use
@@ -68,6 +77,6 @@ RL:
     reset_critic: True
 
     # Model parameters
-    backbone: resnet50
+    backbone: resnet18
     rnn_type: LSTM
     num_recurrent_layers: 2
diff --git a/configs/methods/tp_srl.yaml b/configs/methods/tp_srl.yaml
new file mode 100644
index 0000000..c0ab7cb
--- /dev/null
+++ b/configs/methods/tp_srl.yaml
@@ -0,0 +1,156 @@
+VERBOSE: False
+BASE_TASK_CONFIG_PATH: configs/tasks/rearrange.local.rgbd.yaml
+TRAINER_NAME: "ddppo"
+ENV_NAME: "RearrangeRLEnv"
+SIMULATOR_GPU_ID: 0
+TORCH_GPU_ID: 0
+VIDEO_OPTION: ["disk"]
+TENSORBOARD_DIR: "tb"
+VIDEO_DIR: "video_dir"
+VIDEO_FPS: 30
+VIDEO_RENDER_TOP_DOWN: False
+VIDEO_RENDER_ALL_INFO: True
+TEST_EPISODE_COUNT: -1
+EVAL_CKPT_PATH_DIR: "data/new_checkpoints"
+NUM_ENVIRONMENTS: 1
+WRITER_TYPE: 'tb'
+CHECKPOINT_FOLDER: "data/new_checkpoints"
+NUM_UPDATES: -1
+TOTAL_NUM_STEPS: 1.0e8
+LOG_INTERVAL: 10
+NUM_CHECKPOINTS: 20
+FORCE_TORCH_SINGLE_THREADED: True
+EVAL_KEYS_TO_INCLUDE_IN_NAME: ['reward', 'force', 'composite_success']
+EVAL:
+  USE_CKPT_CONFIG: False
+  SHOULD_LOAD_CKPT: False
+  SPLIT: 'minival'
+
+RL:
+  POLICY:
+      name: "HierarchicalPolicy"
+      high_level_policy:
+        name: "GtHighLevelPolicy"
+      OBS_TRANSFORMS:
+        ENABLED_TRANSFORMS: ['AddVirtualKeys']
+        ADD_VIRTUAL_KEYS:
+          "nav_to_skill": 8
+          "object_to_agent_gps_compass": 2
+      DEFINED_SKILLS:
+        NN_OPEN_CAB:
+          skill_name: "ArtObjSkillPolicy"
+          name: "PointNavResNetPolicy"
+          action_distribution_type: "gaussian"
+          AT_RESTING_THRESHOLD: 0.15
+          OBS_SKILL_INPUTS: []
+          LOAD_CKPT_FILE: "data/models/open_cab.pth"
+          MAX_SKILL_STEPS: 200
+          START_ZONE_RADIUS: 0.3
+          FORCE_END_ON_TIMEOUT: True
+
+        NN_OPEN_FRIDGE:
+          skill_name: "ArtObjSkillPolicy"
+          name: "PointNavResNetPolicy"
+          action_distribution_type: "gaussian"
+          AT_RESTING_THRESHOLD: 0.15
+          OBS_SKILL_INPUTS: []
+          LOAD_CKPT_FILE: "data/models/open_fridge.pth"
+          MAX_SKILL_STEPS: 200
+          START_ZONE_RADIUS: 0.3
+          FORCE_END_ON_TIMEOUT: True
+
+        NN_PICK:
+          skill_name: "PickSkillPolicy"
+          name: "PointNavResNetPolicy"
+          action_distribution_type: "gaussian"
+          AT_RESTING_THRESHOLD: 0.15
+          OBS_SKILL_INPUTS: ["obj_start_sensor"]
+          LOAD_CKPT_FILE: "data/models/pick.pth"
+          MAX_SKILL_STEPS: 200
+          FORCE_END_ON_TIMEOUT: True
+
+        NN_PLACE:
+          skill_name: "PlaceSkillPolicy"
+          name: "PointNavResNetPolicy"
+          action_distribution_type: "gaussian"
+          AT_RESTING_THRESHOLD: 0.15
+          OBS_SKILL_INPUTS: ["obj_goal_sensor"]
+          LOAD_CKPT_FILE: "data/models/place.pth"
+          MAX_SKILL_STEPS: 200
+          FORCE_END_ON_TIMEOUT: True
+
+        NN_NAV:
+          skill_name: "NavSkillPolicy"
+          name: "PointNavResNetPolicy"
+          action_distribution_type: "gaussian"
+          OBS_SKILL_INPUTS: ["object_to_agent_gps_compass"]
+          OBS_SKILL_INPUT_DIM: 2
+          LIN_SPEED_STOP: 0.067
+          ANG_SPEED_STOP: 0.067
+          LOAD_CKPT_FILE: "data/models/nav.pth"
+          MAX_SKILL_STEPS: 300
+          FORCE_END_ON_TIMEOUT: False
+
+        WAIT_SKILL:
+          skill_name: "WaitSkillPolicy"
+          MAX_SKILL_STEPS: -1.0
+          FORCE_END_ON_TIMEOUT: False
+
+        RESET_ARM_SKILL:
+          skill_name: "ResetArmSkill"
+          MAX_SKILL_STEPS: 50
+          RESET_JOINT_STATE: [-4.5003259e-01, -1.0799699e00, 9.9526465e-02, 9.3869519e-01, -7.8854430e-04, 1.5702540e00, 4.6168058e-03]
+          FORCE_END_ON_TIMEOUT: False
+
+      USE_SKILLS:
+        # Uncomment if you are also using these skills
+        # open_cab: "NN_OPEN_CAB"
+        # open_fridge: "NN_OPEN_FRIDGE"
+        pick: "NN_PICK"
+        place: "NN_PLACE"
+        nav: "NN_NAV"
+        nav_to_receptacle: "NN_NAV"
+        wait: "WAIT_SKILL"
+        reset_arm: "RESET_ARM_SKILL"
+
+  PPO:
+    # ppo params
+    clip_param: 0.2
+    ppo_epoch: 2
+    num_mini_batch: 2
+    value_loss_coef: 0.5
+    entropy_coef: 0.0001
+    lr: 2.5e-4
+    eps: 1e-5
+    max_grad_norm: 0.2
+    num_steps: 128
+    use_gae: True
+    gamma: 0.99
+    tau: 0.95
+    use_linear_clip_decay: False
+    use_linear_lr_decay: False
+    reward_window_size: 50
+
+    use_normalized_advantage: False
+
+    hidden_size: 512
+
+  DDPPO:
+    sync_frac: 0.6
+    # The PyTorch distributed backend to use
+    distrib_backend: NCCL
+    # Visual encoder backbone
+    pretrained_weights: data/ddppo-models/gibson-2plus-resnet50.pth
+    # Initialize with pretrained weights
+    pretrained: False
+    # Initialize just the visual encoder backbone with pretrained weights
+    pretrained_encoder: False
+    # Whether or not the visual encoder backbone will be trained.
+    train_encoder: True
+    # Whether or not to reset the critic linear layer
+    reset_critic: False
+
+    # Model parameters
+    backbone: resnet18
+    rnn_type: LSTM
+    num_recurrent_layers: 2
diff --git a/configs/pddl/rearrange.yaml b/configs/pddl/rearrange.yaml
new file mode 100644
index 0000000..8c04c39
--- /dev/null
+++ b/configs/pddl/rearrange.yaml
@@ -0,0 +1,24 @@
+objects:
+  - name: goal0|0
+    expr_type: rigid_obj_type
+  - name: TARGET_goal0|0
+    expr_type: goal_type
+  - name: ROBOT_0
+    expr_type: robot_type
+
+goal:
+  expr_type: AND
+  sub_exprs:
+    - at(goal0|0,TARGET_goal0|0)
+    - not_holding(ROBOT_0)
+
+stage_goals:
+  stage_0_5:
+    expr_type: AND
+    sub_exprs:
+      - holding(goal0|0, ROBOT_0)
+  stage_1:
+    expr_type: AND
+    sub_exprs:
+      - at(goal0|0,TARGET_goal0|0)
+
diff --git a/configs/pddl/rearrange_easy.yaml b/configs/pddl/rearrange_easy.yaml
new file mode 100644
index 0000000..88f350b
--- /dev/null
+++ b/configs/pddl/rearrange_easy.yaml
@@ -0,0 +1,29 @@
+objects:
+  - name: goal0|0
+    expr_type: rigid_obj_type
+  - name: TARGET_goal0|0
+    expr_type: goal_type
+  - name: ROBOT_0
+    expr_type: robot_type
+
+goal:
+  expr_type: AND
+  sub_exprs:
+    - at(goal0|0,TARGET_goal0|0)
+    - not_holding(ROBOT_0)
+
+stage_goals:
+  stage_0_5:
+    expr_type: AND
+    sub_exprs:
+      - holding(goal0|0, ROBOT_0)
+  stage_1:
+    expr_type: AND
+    sub_exprs:
+      - at(goal0|0,TARGET_goal0|0)
+
+solution:
+  - nav(goal0|0, ROBOT_0)
+  - pick(goal0|0, ROBOT_0)
+  - nav(TARGET_goal0|0, ROBOT_0)
+  - place(goal0|0, TARGET_goal0|0, ROBOT_0)
diff --git a/configs/tasks/rearrange.local.rgbd.yaml b/configs/tasks/rearrange.local.rgbd.yaml
new file mode 100644
index 0000000..615c9fc
--- /dev/null
+++ b/configs/tasks/rearrange.local.rgbd.yaml
@@ -0,0 +1,140 @@
+GYM:
+    CLASS_NAME: RearrangeRLEnv
+    AUTO_NAME: RearrangeChallenge
+    OBS_KEYS:
+    - robot_head_depth
+    - obj_start_sensor
+    - obj_goal_sensor
+    - obj_start_gps_compass
+    - obj_goal_gps_compass
+    - joint
+    - is_holding
+    - relative_resting_position
+ENVIRONMENT:
+    MAX_EPISODE_STEPS: 3000
+DATASET:
+    TYPE: RearrangeDataset-v0
+    SPLIT: minival
+    DATA_PATH: data/datasets/replica_cad/rearrange/v1/{split}/rearrange.json.gz
+    SCENES_DIR: data/replica_cad/
+TASK:
+    TYPE: RearrangeCompositeTask-v0
+    REWARD_MEASURE: move_obj_reward
+    SUCCESS_MEASURE: composite_success
+    SUCCESS_REWARD: 100.0
+    SLACK_REWARD: -0.01
+    END_ON_SUCCESS: true
+    COUNT_OBJ_COLLISIONS: true
+    COUNT_ROBOT_OBJ_COLLS: false
+    CONSTRAINT_VIOLATION_ENDS_EPISODE: false
+    CONSTRAINT_VIOLATION_DROPS_OBJECT: True
+    BASE_ANGLE_NOISE: 0.15
+    BASE_NOISE: 0.05
+    EASY_INIT: false
+    TASK_SPEC_BASE_PATH: configs/pddl/
+    TASK_SPEC: rearrange
+    PDDL_DOMAIN_DEF: replica_cad
+    OBJ_SUCC_THRESH: 0.3
+    ART_SUCC_THRESH: 0.15
+    SENSORS:
+    - RELATIVE_RESTING_POS_SENSOR
+    - TARGET_START_SENSOR
+    - GOAL_SENSOR
+    - JOINT_SENSOR
+    - IS_HOLDING_SENSOR
+    - END_EFFECTOR_SENSOR
+    - TARGET_START_GPS_COMPASS_SENSOR
+    - TARGET_GOAL_GPS_COMPASS_SENSOR
+    FORCE_TERMINATE:
+        TYPE: ForceTerminate
+        MAX_ACCUM_FORCE: 100_000.0
+        MAX_INSTANT_FORCE: 10_000.0
+    MEASUREMENTS:
+    - OBJECT_TO_GOAL_DISTANCE
+    - ROBOT_FORCE
+    - FORCE_TERMINATE
+    - ROBOT_COLLS
+    - END_EFFECTOR_TO_OBJECT_DISTANCE
+    - DOES_WANT_TERMINATE
+    - COMPOSITE_SUCCESS
+    - COMPOSITE_BAD_CALLED_TERMINATE
+    - NUM_STEPS
+    - DID_VIOLATE_HOLD_CONSTRAINT
+    - MOVE_OBJECTS_REWARD
+    ACTIONS:
+        ARM_ACTION:
+            TYPE: ArmAction
+            ARM_CONTROLLER: ArmRelPosAction
+            GRIP_CONTROLLER: SuctionGraspAction
+            ARM_JOINT_DIMENSIONALITY: 7
+            GRASP_THRESH_DIST: 0.15
+            DISABLE_GRIP: false
+            DELTA_POS_LIMIT: 0.0125
+            EE_CTRL_LIM: 0.015
+        BASE_VELOCITY:
+            TYPE: BaseVelAction
+            LIN_SPEED: 10.0
+            ANG_SPEED: 10.0
+            ALLOW_DYN_SLIDE: true
+            END_ON_STOP: false
+            ALLOW_BACK: true
+            MIN_ABS_LIN_SPEED: 1.0
+            MIN_ABS_ANG_SPEED: 1.0
+        REARRANGE_STOP:
+            TYPE: RearrangeStopAction
+    POSSIBLE_ACTIONS:
+    - ARM_ACTION
+    - BASE_VELOCITY
+    - REARRANGE_STOP
+    MOVE_OBJECTS_REWARD:
+        TYPE: MoveObjectsReward
+        PICK_REWARD: 1.0
+        SUCCESS_DIST: 0.15
+        SINGLE_REARRANGE_REWARD: 1.0
+        DIST_REWARD: 1.0
+        CONSTRAINT_VIOLATE_PEN: 10.0
+        FORCE_PEN: 0.0
+        MAX_FORCE_PEN: 1.0
+        FORCE_END_PEN: 10.0
+SIMULATOR:
+    ADDITIONAL_OBJECT_PATHS:
+        - "data/objects/ycb/configs/"
+    ACTION_SPACE_CONFIG: v0
+    GRASP_IMPULSE: 10000.0
+    HOLD_THRESH: 0.2
+    AC_FREQ_RATIO: 4
+    DEBUG_RENDER: false
+    DEBUG_RENDER_GOAL: true
+    AGENTS:
+    - AGENT_0
+    CONCUR_RENDER: true
+    AUTO_SLEEP: true
+    AGENT_0:
+        HEIGHT: 1.5
+        RADIUS: 0.3
+        SENSORS:
+        - HEAD_RGB_SENSOR
+        - HEAD_DEPTH_SENSOR
+        ROBOT_URDF: ./data/robots/hab_fetch/robots/hab_suction.urdf
+        ROBOT_TYPE: FetchSuctionRobot
+        IK_ARM_URDF: ./data/robots/hab_fetch/robots/fetch_onlyarm.urdf
+    HEAD_RGB_SENSOR:
+        WIDTH: 256
+        HEIGHT: 256
+    HEAD_DEPTH_SENSOR:
+        WIDTH: 256
+        HEIGHT: 256
+        MIN_DEPTH: 0.0
+        MAX_DEPTH: 10.0
+        NORMALIZE_DEPTH: true
+    CTRL_FREQ: 120.0
+    DEFAULT_AGENT_ID: 0
+    FORWARD_STEP_SIZE: 0.25
+    HABITAT_SIM_V0:
+        ALLOW_SLIDING: false
+        ENABLE_PHYSICS: true
+        GPU_DEVICE_ID: 0
+        GPU_GPU: false
+        PHYSICS_CONFIG_FILE: ./data/default.physics_config.json
+    SEED: 100
+    TYPE: RearrangeSim-v0
diff --git a/configs/tasks/rearrange_easy.local.rgbd.yaml b/configs/tasks/rearrange_easy.local.rgbd.yaml
new file mode 100644
index 0000000..ce21ddf
--- /dev/null
+++ b/configs/tasks/rearrange_easy.local.rgbd.yaml
@@ -0,0 +1,140 @@
+GYM:
+    CLASS_NAME: RearrangeRLEnv
+    AUTO_NAME: RearrangeEasy
+    OBS_KEYS:
+    - robot_head_depth
+    - obj_start_sensor
+    - obj_goal_sensor
+    - obj_start_gps_compass
+    - obj_goal_gps_compass
+    - joint
+    - is_holding
+    - relative_resting_position
+ENVIRONMENT:
+    MAX_EPISODE_STEPS: 1500
+DATASET:
+    TYPE: RearrangeDataset-v0
+    SPLIT: minival
+    DATA_PATH: data/datasets/replica_cad/rearrange/v1/{split}/rearrange_easy.json.gz
+    SCENES_DIR: data/replica_cad/
+TASK:
+    TYPE: RearrangeCompositeTask-v0
+    REWARD_MEASURE: move_obj_reward
+    SUCCESS_MEASURE: composite_success
+    SUCCESS_REWARD: 100.0
+    SLACK_REWARD: -0.01
+    END_ON_SUCCESS: true
+    COUNT_OBJ_COLLISIONS: true
+    COUNT_ROBOT_OBJ_COLLS: false
+    CONSTRAINT_VIOLATION_ENDS_EPISODE: false
+    CONSTRAINT_VIOLATION_DROPS_OBJECT: True
+    BASE_ANGLE_NOISE: 0.15
+    BASE_NOISE: 0.05
+    EASY_INIT: false
+    TASK_SPEC_BASE_PATH: configs/pddl/
+    TASK_SPEC: rearrange_easy
+    PDDL_DOMAIN_DEF: replica_cad
+    OBJ_SUCC_THRESH: 0.3
+    ART_SUCC_THRESH: 0.15
+    SENSORS:
+    - RELATIVE_RESTING_POS_SENSOR
+    - TARGET_START_SENSOR
+    - GOAL_SENSOR
+    - JOINT_SENSOR
+    - IS_HOLDING_SENSOR
+    - END_EFFECTOR_SENSOR
+    - TARGET_START_GPS_COMPASS_SENSOR
+    - TARGET_GOAL_GPS_COMPASS_SENSOR
+    FORCE_TERMINATE:
+        TYPE: ForceTerminate
+        MAX_ACCUM_FORCE: 100_000.0
+        MAX_INSTANT_FORCE: 10_000.0
+    MEASUREMENTS:
+    - OBJECT_TO_GOAL_DISTANCE
+    - ROBOT_FORCE
+    - FORCE_TERMINATE
+    - ROBOT_COLLS
+    - END_EFFECTOR_TO_OBJECT_DISTANCE
+    - DOES_WANT_TERMINATE
+    - COMPOSITE_SUCCESS
+    - COMPOSITE_BAD_CALLED_TERMINATE
+    - NUM_STEPS
+    - DID_VIOLATE_HOLD_CONSTRAINT
+    - MOVE_OBJECTS_REWARD
+    ACTIONS:
+        ARM_ACTION:
+            TYPE: ArmAction
+            ARM_CONTROLLER: ArmRelPosAction
+            GRIP_CONTROLLER: SuctionGraspAction
+            ARM_JOINT_DIMENSIONALITY: 7
+            GRASP_THRESH_DIST: 0.15
+            DISABLE_GRIP: false
+            DELTA_POS_LIMIT: 0.0125
+            EE_CTRL_LIM: 0.015
+        BASE_VELOCITY:
+            TYPE: BaseVelAction
+            LIN_SPEED: 10.0
+            ANG_SPEED: 10.0
+            ALLOW_DYN_SLIDE: true
+            END_ON_STOP: false
+            ALLOW_BACK: true
+            MIN_ABS_LIN_SPEED: 1.0
+            MIN_ABS_ANG_SPEED: 1.0
+        REARRANGE_STOP:
+            TYPE: RearrangeStopAction
+    POSSIBLE_ACTIONS:
+    - ARM_ACTION
+    - BASE_VELOCITY
+    - REARRANGE_STOP
+    MOVE_OBJECTS_REWARD:
+        TYPE: MoveObjectsReward
+        PICK_REWARD: 1.0
+        SUCCESS_DIST: 0.15
+        SINGLE_REARRANGE_REWARD: 1.0
+        DIST_REWARD: 1.0
+        CONSTRAINT_VIOLATE_PEN: 10.0
+        FORCE_PEN: 0.0
+        MAX_FORCE_PEN: 1.0
+        FORCE_END_PEN: 10.0
+SIMULATOR:
+    ADDITIONAL_OBJECT_PATHS:
+        - "data/objects/ycb/configs/"
+    ACTION_SPACE_CONFIG: v0
+    GRASP_IMPULSE: 10000.0
+    HOLD_THRESH: 0.2
+    AC_FREQ_RATIO: 4
+    DEBUG_RENDER: false
+    DEBUG_RENDER_GOAL: true
+    AGENTS:
+    - AGENT_0
+    CONCUR_RENDER: true
+    AUTO_SLEEP: true
+    AGENT_0:
+        HEIGHT: 1.5
+        RADIUS: 0.3
+        SENSORS:
+        - HEAD_RGB_SENSOR
+        - HEAD_DEPTH_SENSOR
+        ROBOT_URDF: ./data/robots/hab_fetch/robots/hab_suction.urdf
+        ROBOT_TYPE: FetchSuctionRobot
+        IK_ARM_URDF: ./data/robots/hab_fetch/robots/fetch_onlyarm.urdf
+    HEAD_RGB_SENSOR:
+        WIDTH: 256
+        HEIGHT: 256
+    HEAD_DEPTH_SENSOR:
+        WIDTH: 256
+        HEIGHT: 256
+        MIN_DEPTH: 0.0
+        MAX_DEPTH: 10.0
+        NORMALIZE_DEPTH: true
+    CTRL_FREQ: 120.0
+    DEFAULT_AGENT_ID: 0
+    FORWARD_STEP_SIZE: 0.25
+    HABITAT_SIM_V0:
+        ALLOW_SLIDING: false
+        ENABLE_PHYSICS: true
+        GPU_DEVICE_ID: 0
+        GPU_GPU: false
+        PHYSICS_CONFIG_FILE: ./data/default.physics_config.json
+    SEED: 100
+    TYPE: RearrangeSim-v0
diff --git a/docker/hab2.Dockerfile b/docker/hab2.Dockerfile
new file mode 100644
index 0000000..6c42d8b
--- /dev/null
+++ b/docker/hab2.Dockerfile
@@ -0,0 +1,8 @@
+FROM fairembodied/habitat-challenge:habitat_rearrangement_2022_base_docker
+ADD agents/random_agent.py agent.py
+ADD configs/ /configs/
+ENV AGENT_EVALUATION_TYPE remote
+
+ENV TRACK_CONFIG_FILE "/configs/tasks/rearrange.local.rgbd.yaml"
+
+CMD ["/bin/bash", "-c", "source activate habitat && export PYTHONPATH=/evalai-remote-evaluation:$PYTHONPATH && export CHALLENGE_CONFIG_FILE=$TRACK_CONFIG_FILE && python agent.py --evaluation $AGENT_EVALUATION_TYPE"]
diff --git a/docker/hab2_monolithic.Dockerfile b/docker/hab2_monolithic.Dockerfile
new file mode 100644
index 0000000..4d963d5
--- /dev/null
+++ b/docker/hab2_monolithic.Dockerfile
@@ -0,0 +1,12 @@
+FROM fairembodied/habitat-challenge:habitat_rearrangement_2022_base_docker
+ADD agents/habitat_baselines_agent.py agent.py
+ADD configs/ /configs/
+ADD data/models/rearrange_easy.pth demo.ckpt.pth
+ENV AGENT_EVALUATION_TYPE remote
+
+ENV TRACK_CONFIG_FILE "/configs/tasks/rearrange.local.rgbd.yaml"
+
+RUN /bin/bash -c ". activate habitat; pip install ifcfg torchvision tensorboard"
+CMD ["/bin/bash", "-c", "source activate habitat && export PYTHONPATH=/evalai-remote-evaluation:$PYTHONPATH && export CHALLENGE_CONFIG_FILE=$TRACK_CONFIG_FILE && python agent.py --evaluation $AGENT_EVALUATION_TYPE --model-path demo.ckpt.pth --input-type rgbd --cfg-path configs/methods/ddppo_monolithic.yaml"]
+
+
diff --git a/docker/hab2_tpsrl.Dockerfile b/docker/hab2_tpsrl.Dockerfile
new file mode 100644
index 0000000..745aa30
--- /dev/null
+++ b/docker/hab2_tpsrl.Dockerfile
@@ -0,0 +1,13 @@
+FROM fairembodied/habitat-challenge:habitat_rearrangement_2022_base_docker
+ADD agents/habitat_baselines_agent.py agent.py
+ADD configs/ /configs/
+RUN /bin/bash -c "mkdir -p data/models"
+ADD data/models/ data/models/
+ENV AGENT_EVALUATION_TYPE remote
+
+ENV TRACK_CONFIG_FILE "/configs/tasks/rearrange_easy.local.rgbd.yaml"
+
+RUN /bin/bash -c ". activate habitat; pip install ifcfg torchvision tensorboard"
+CMD ["/bin/bash", "-c", "source activate habitat && export PYTHONPATH=/evalai-remote-evaluation:$PYTHONPATH && export CHALLENGE_CONFIG_FILE=$TRACK_CONFIG_FILE && python agent.py --evaluation $AGENT_EVALUATION_TYPE --input-type depth --cfg-path configs/methods/tp_srl.yaml"]
+
+
diff --git a/habitat-challenge-data/objectgoal_hm3d/val_mini/content/TEEsavR23oF.json.gz b/habitat-challenge-data/objectgoal_hm3d/val_mini/content/TEEsavR23oF.json.gz
deleted file mode 100644
index 1e34083..0000000
Binary files a/habitat-challenge-data/objectgoal_hm3d/val_mini/content/TEEsavR23oF.json.gz and /dev/null differ
diff --git a/habitat-challenge-data/objectgoal_hm3d/val_mini/content/wcojb4TFT35.json.gz b/habitat-challenge-data/objectgoal_hm3d/val_mini/content/wcojb4TFT35.json.gz
deleted file mode 100644
index d66097b..0000000
Binary files a/habitat-challenge-data/objectgoal_hm3d/val_mini/content/wcojb4TFT35.json.gz and /dev/null differ
diff --git a/habitat-challenge-data/objectgoal_hm3d/val_mini/val_mini.json.gz b/habitat-challenge-data/objectgoal_hm3d/val_mini/val_mini.json.gz
deleted file mode 100644
index c6de50d..0000000
Binary files a/habitat-challenge-data/objectgoal_hm3d/val_mini/val_mini.json.gz and /dev/null differ
diff --git a/submission.sh b/submission.sh
deleted file mode 100644
index 85e1c3d..0000000
--- a/submission.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-
-python agent.py --evaluation $AGENT_EVALUATION_TYPE $@
-


Test patch:
diff --git a/test_locally_objectnav_rgbd.sh b/scripts/test_local.sh
old mode 100755
new mode 100644
similarity index 51%
rename from test_locally_objectnav_rgbd.sh
rename to scripts/test_local.sh
index f3c7abb..9a4618d
--- a/test_locally_objectnav_rgbd.sh
+++ b/scripts/test_local.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-DOCKER_NAME="objectnav_submission"
+DOCKER_NAME="rearrange_submission"
 
 while [[ $# -gt 0 ]]
 do
@@ -19,10 +19,10 @@ case $key in
 esac
 done
 
-docker run -v $(pwd)/habitat-challenge-data:/habitat-challenge-data \
-    -v $(realpath habitat-challenge-data/data/scene_datasets/hm3d):/habitat-challenge-data/data/scene_datasets/hm3d \
+docker run \
+    -v $(realpath data/versioned_data):/data/versioned_data \
     --runtime=nvidia \
     -e "AGENT_EVALUATION_TYPE=local" \
-    -e "TRACK_CONFIG_FILE=/challenge_objectnav2022.local.rgbd.yaml" \
+    -e "TRACK_CONFIG_FILE=/configs/tasks/rearrange_easy.local.rgbd.yaml" \
     ${DOCKER_NAME}\