train_die_reorient.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training notebook for Die reorient task\n",
    "\n",
    "We build upon the evotorch baseline which uses PGPE and the ClipUp optimizer on a 3 layer RNN. Our primary approach to solving this hard exploration challenge is by using potential function based reward shaping [refer to RUDDER, Arjona-Medina et al. for a detailed overview] and task subdivision using adapting curricula [Similar to POET, Wang et al.]. We have a population of environments (256), each of which starts of at \"easy\" difficulty and adapts its difficulty based on the success achieved by the agent in the recent past (20 episodes). The environment difficulty is controlled using the goal_rot value. Hence, the difficulty distribution is shaped by the agent's current performance.\n",
    "\n",
    "Our recently published work(At the DRL workshop in NeurIPS 2022) shows that minimizing task-irrlevant exploration speeds up learning and improves generalization. This is because visiting task-irrelevant states forces the policy/value networks to fit irrelevant targets that affect their capacity and generalization capabilities. This was also our primary motivation for entering the challenge, to verify some of our ideas on the challenging continuous control tasks posed here.\n",
    "\n",
    "Essentially, using a reward function based on the differences of a potential function avoids spurious optima (E.g. committing suicide) and also provides a much easier to optimize reward. (Since, it's always possible to obtain a positive reward at every state). Further, the curriculum minimizes task-irrelevant exploration speeding up learning and allowing the trained policy to generalize much better to downstream tasks in the curriculum."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports\n",
    "To begin with, we import all necessary tools from EvoTorch, and also PyTorch so that we can jit save the learned policy for submission."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from evotorch import Problem\n",
    "from evotorch.algorithms import PGPE\n",
    "from evotorch.neuroevolution import GymNE\n",
    "from evotorch.logging import StdOutLogger, PandasLogger\n",
    "import torch\n",
    "import sys\n",
    "import pathlib\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Configuration\n",
    "Now we configure for the specific environment we want to solve. We've figured this configuration out for the weighted reward keys through some trial and error, but we imagine that they can be modified further. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "conda_env_path = pathlib.Path(sys.executable).parent.parent\n",
    "env_name = \"myosuite:myoChallengeDieReorientP2-v10\"\n",
    "policy_path = 'agent/policies/learned_policy_reorient2_v10.pkl'\n",
    "env_config = {\n",
    "    'weighted_reward_keys' : {\n",
    "        # 'pos_dist': 3, # We discard the provided distance based rewards.\n",
    "        # 'rot_dist': 1,\n",
    "        'solved': 40,\n",
    "        # 'survival': 2, # We also implemented a survival reward, but we didn't need it.\n",
    "        'dist_diff': -100, # We implemented the reward as a difference of a potential function\n",
    "        #(In this case the sum of the pos and rot errors)\n",
    "        'act_reg': 0.05,\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We configure the optimizer similar to the evotorch baseline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "CLIPUP_MAX_SPEED = 0.15\n",
    "CLIPUP_ALPHA = CLIPUP_MAX_SPEED * 0.75\n",
    "RADIUS = CLIPUP_MAX_SPEED * 15\n",
    "\n",
    "STDEV_LR = 0.1\n",
    "STDEV_MAX_CHANGE = 0.2\n",
    "\n",
    "POPSIZE = 20000\n",
    "POPSIZE_MAX = POPSIZE * 8\n",
    "NUM_INTERACTIONS = int(POPSIZE * 200 * 0.75)\n",
    "NUM_GENERATIONS = 4000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MODIFICATION: Dynamic curricula\n",
    "We made a few changes to the environments to support dynamic curricula along with the potential function based reward function. However, we note that once the env reaches the maximum difficulty it is same as the original test env.\n",
    "\n",
    "Please observe python file `reorient2_v10.py` provided along this notebook for implementation details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sanity check to test that environment is importing and works correctly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from gym.envs.registration import register\n",
    "\n",
    "model_path = os.path.join(\n",
    "    conda_env_path, \n",
    "    *'lib/python3.8/site-packages/myosuite/envs/myo/assets/hand/myo_hand_die.mjb'.split('/')\n",
    "    )\n",
    "register(id='myoChallengeDieReorientP2-v10',\n",
    "        entry_point='reorient2_v10:ReorientEnv2V10',\n",
    "        max_episode_steps=150,\n",
    "        kwargs={\n",
    "            'model_path': model_path,\n",
    "            'normalize_act': True,\n",
    "            'frame_skip': 5,\n",
    "            # Randomization in goals\n",
    "            'goal_pos': (-.020, .020),  # +- 2 cm\n",
    "            'goal_rot': (-0.20, 0.20),   # +-0.2 radians We start with the easiest difficulty.\n",
    "            'drop_th' : 0.05, # We also reduced the drop threshold, so bad episodes are terminated early \n",
    "            # which avoids visiting task-irrelevant states and saving on sample complexity.\n",
    "            #It's possible the optimal policy involves tossing the cube up, \n",
    "            # but we assume that is not the intended technique!\n",
    "            'trigger_num': 20, # The number of past episodes to consider when evaluating agent performance.\n",
    "            'trigger_thresh': 0.85, # The success percentage required to trigger the environment difficulty increase.\n",
    "            'trigger_decay': 0.99, # We decay the success percentage as difficult environments take more timesteps to solve.\n",
    "            'kappa': 0.8, # not used\n",
    "            # Randomization in physical properties of the die\n",
    "            'obj_size_change': 0.007, # +-7mm delta change in object size\n",
    "            'obj_friction_change': (0.2, 0.001, 0.00002) # nominal: 1.0, 0.005, 0.0001\n",
    "        }\n",
    "    )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RS:> Registering Myo Envs\n",
      "Compiling /scratch/luis.ferro/conda-envs/myochallenge-iarai-jku/lib/python3.8/site-packages/mujoco_py/cymj.pyx because it changed.\n",
      "[1/1] Cythonizing /scratch/luis.ferro/conda-envs/myochallenge-iarai-jku/lib/python3.8/site-packages/mujoco_py/cymj.pyx\n"
     ]
    }
   ],
   "source": [
    "import gym\n",
    "env = gym.make(\"myoChallengeDieReorientP2-v10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "changing goal  (-1.5, 1.5) 0.98 15\n"
     ]
    }
   ],
   "source": [
    "env.set_difficulty(1.5, 0.98, 15)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup\n",
    "Now we're ready to create the problem class. You should note that we're using the `Policy` class from the included `policy.py` file. In our experiments we use the same baseline 2 layer RNN policy. The recurrent layer helps because the task involves partial observability (State of tendons, randomness in objects). The use of leaky relus helps avoid capacity loss during training to an extent. Our motivation was to test our ideas on minimizing task-irrelevant exploration and hence we did not modify the policy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/scratch/luis.ferro/conda-envs/myochallenge-iarai-jku/lib/python3.8/site-packages/numpy/core/fromnumeric.py:86: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "2023-02-24 11:29:02,913\tINFO worker.py:1553 -- Started a local Ray instance.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solution length is 21543\n"
     ]
    }
   ],
   "source": [
    "from policy import Policy # Needs to be explicitly defined here.\n",
    "\n",
    "problem = GymNE(\n",
    "    env_name=env_name,\n",
    "    env_config = env_config,\n",
    "    network=Policy,\n",
    "    network_args = {\n",
    "        'hidden_dim': 64, # We use the same architecture used by the evotorch baseline.\n",
    "    },\n",
    "    observation_normalization=True,\n",
    "    num_actors='max',\n",
    ")\n",
    "print('Solution length is', problem.solution_length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment Registration Routine as a hook \n",
    "Here we pass the gym registration function to all environments in the population via a remote_hook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def register_env(problem):\n",
    "    from gym.envs.registration import register\n",
    "    \n",
    "    print(\"Registering env\")\n",
    "    register(id='myoChallengeDieReorientP2-v10',\n",
    "        entry_point='reorient2_v10:ReorientEnv2V10',\n",
    "        max_episode_steps=150,\n",
    "        kwargs={\n",
    "            'model_path': model_path,\n",
    "            'normalize_act': True,\n",
    "            'frame_skip': 5,\n",
    "            # Randomization in goals\n",
    "            'goal_pos': (-.020, .020),  # +- 2 cm\n",
    "            'goal_rot': (-0.20, 0.20),   # +-180 degrees\n",
    "            'drop_th' : 0.05,\n",
    "            'trigger_num': 20,\n",
    "            'trigger_thresh': 0.85,\n",
    "            'trigger_decay': 0.99,\n",
    "            'kappa': 0.8, # not used\n",
    "            # Randomization in physical properties of the die\n",
    "            'obj_size_change': 0.007, # +-7mm delta change in object size\n",
    "            'obj_friction_change': (0.2, 0.001, 0.00002) # nominal: 1.0, 0.005, 0.0001\n",
    "        }\n",
    "    )\n",
    "\n",
    "problem.remote_hook.append(register_env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `problem` instantiated, we can create the searcher:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "searcher = PGPE(\n",
    "    problem,\n",
    "    center_learning_rate=CLIPUP_ALPHA,\n",
    "    optimizer=\"clipup\",\n",
    "    optimizer_config={\"max_speed\": CLIPUP_MAX_SPEED},\n",
    "    radius_init=RADIUS,\n",
    "    stdev_learning_rate=STDEV_LR,\n",
    "    stdev_max_change=STDEV_MAX_CHANGE,\n",
    "    popsize=POPSIZE,\n",
    "    popsize_max=POPSIZE_MAX,\n",
    "    num_interactions=NUM_INTERACTIONS,\n",
    "    distributed = True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We add an additional `after_step_hook` which will save the policy after every generation. This means that you can asynchonously evaluate and submit agents, even as the evolutionary run continues!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "def save_policy():\n",
    "    global problem, searcher, policy_path\n",
    "    folder = pathlib.Path(policy_path).parent\n",
    "    os.makedirs(folder, exist_ok=True)\n",
    "    policy = problem.to_policy(searcher.status['center'])\n",
    "    scripted_module = torch.jit.script(policy)\n",
    "    torch.jit.save(scripted_module, policy_path)\n",
    "\n",
    "searcher.after_step_hook.append(save_policy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For sanity, we're adding a StdOutLogger instance and a PandasLogger instance so that we can track what's going on:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = StdOutLogger(searcher)\n",
    "pandas_logger = PandasLogger(searcher)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train\n",
    "And that's all there is to it! We're ready to train. As we go, we'll be creating `learned_policy_boading.pkl` in the local directory. Check out `README.md` to see how you can submit these learned agents. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[2m\u001b[36m(EvaluationActor pid=22220)\u001b[0m Registering env\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22223)\u001b[0m Registering env\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22221)\u001b[0m Registering env\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22220)\u001b[0m RS:> Registering Myo Envs\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22223)\u001b[0m RS:> Registering Myo Envs\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22221)\u001b[0m RS:> Registering Myo Envs\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22222)\u001b[0m Registering env\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22222)\u001b[0m RS:> Registering Myo Envs\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[2m\u001b[36m(EvaluationActor pid=22222)\u001b[0m /scratch/luis.ferro/myo/conda-env/lib/python3.8/site-packages/numpy/core/fromnumeric.py:86: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22222)\u001b[0m   return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22220)\u001b[0m /scratch/luis.ferro/myo/conda-env/lib/python3.8/site-packages/numpy/core/fromnumeric.py:86: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22220)\u001b[0m   return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22221)\u001b[0m /scratch/luis.ferro/myo/conda-env/lib/python3.8/site-packages/numpy/core/fromnumeric.py:86: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22221)\u001b[0m   return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22223)\u001b[0m /scratch/luis.ferro/myo/conda-env/lib/python3.8/site-packages/numpy/core/fromnumeric.py:86: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "\u001b[2m\u001b[36m(EvaluationActor pid=22223)\u001b[0m   return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     iter : 1\n",
      "mean_eval : 202.79705047607422\n",
      "\n",
      "     iter : 2\n",
      "mean_eval : 215.78834533691406\n",
      "\n"
     ]
    }
   ],
   "source": [
    "searcher.run(NUM_GENERATIONS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, it's nice to see the mean evaluation of the training as time passes. You can interrupt the above cell at any time, generate the plot below, and restart the above cell to continue training!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot: xlabel='iter'>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pandas_logger.to_dataframe().mean_eval.plot()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}