Notebook is working (Flatland3)

04f78be1 · adrian_egli2 · a6701ab3 · 04f78be1
Commit 04f78be1 authored 2 years ago by adrian_egli2
--- a/notebooks/simple_example_3_manual_control.ipynb
+++ b/notebooks/simple_example_3_manual_control.ipynb
@@ -40,8 +40,10 @@
    "import random\n",
    "import numpy as np\n",
    "import time\n",
-    "from flatland.envs.rail_generators import random_rail_generator\n",
+    "from flatland.envs.rail_generators import sparse_rail_generator\n",
+    "from flatland.envs.line_generators import sparse_line_generator\n",
    "from flatland.envs.observations import TreeObsForRailEnv\n",
+    "from flatland.envs.predictions import ShortestPathPredictorForRailEnv\n",
    "from flatland.envs.rail_env import RailEnv\n",
    "from flatland.utils.rendertools import RenderTool"
   ]
@@ -53,15 +55,44 @@
   "outputs": [],
   "source": [
    "random.seed(1)\n",
-    "np.random.seed(1)\n",
-    "\n",
-    "env = RailEnv(width=7,\n",
-    "              height=7,\n",
-    "              rail_generator=random_rail_generator(),\n",
-    "              number_of_agents=2,\n",
-    "              obs_builder_object=TreeObsForRailEnv(max_depth=2))\n",
-    "env.reset()\n",
-    "\n",
+    "np.random.seed(1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "nAgents = 3\n",
+    "n_cities = 2\n",
+    "max_rails_between_cities = 2\n",
+    "max_rails_in_city = 4\n",
+    "seed = 0\n",
+    "env = RailEnv(\n",
+    "        width=20,\n",
+    "        height=30,\n",
+    "        rail_generator=sparse_rail_generator(\n",
+    "            max_num_cities=n_cities,\n",
+    "            seed=seed,\n",
+    "            grid_mode=True,\n",
+    "            max_rails_between_cities=max_rails_between_cities,\n",
+    "            max_rail_pairs_in_city=max_rails_in_city\n",
+    "        ),\n",
+    "        line_generator=sparse_line_generator(),\n",
+    "        number_of_agents=nAgents,\n",
+    "        obs_builder_object=TreeObsForRailEnv(max_depth=3, predictor=ShortestPathPredictorForRailEnv())\n",
+    "    )\n",
+    "\n",
+    "init_observation = env.reset()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
    "# Print the observation vector for agent 0\n",
    "obs, all_rewards, done, _ = env.step({0: 0})\n",
    "for i in range(env.get_num_agents()):\n",
@@ -116,6 +147,13 @@
    "    \n",
    "    time.sleep(0.3)"
   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
  }
 ],
 "metadata": {

 %% Cell type:markdown id: tags:

 ### Simple Example 3 - Manual Control

 By default this runs a few "move forward" actions for two agents, in a separate window.

 If you uncomment the "input" line below, it opens a text box in the Jupyter notebook, allowing basic manual control.

 eg Enter `"0 2 s<enter>"` to tell agent 0 to move forward, and step the environment.

 You should be able to see the red agent step forward, and get a reward from the env, looking like this:

 `Rewards:  {0: -1.0, 1: -1.0}   [done= {0: False, 1: False, '__all__': False} ]`

 Note that this example is set up to use the straightforward "PIL" renderer - without the special SBB artwork!
 The agent observations are displayed as squares of varying sizes, with a paler version of the agent colour.  The targets are half-size squares in the full agent colour.

 You can switch to the "PILSVG" renderer which is prettier but currently renders the agents one step behind, because it needs to know which way the agent is turning.  This can be confusing if you are debugging step-by-step.

 The image below is what the separate window should look like.

 %% Cell type:markdown id: tags:

 ![simple_example_3.png](simple_example_3.png)

 %% Cell type:code id: tags:

 ``` python
 import random
 import numpy as np
 import time
-from flatland.envs.rail_generators import random_rail_generator
+from flatland.envs.rail_generators import sparse_rail_generator
+from flatland.envs.line_generators import sparse_line_generator
 from flatland.envs.observations import TreeObsForRailEnv
+from flatland.envs.predictions import ShortestPathPredictorForRailEnv
 from flatland.envs.rail_env import RailEnv
 from flatland.utils.rendertools import RenderTool
 ```

 %% Cell type:code id: tags:

 ``` python
 random.seed(1)
 np.random.seed(1)
+```
+
+%% Cell type:code id: tags:
+
+``` python
+nAgents = 3
+n_cities = 2
+max_rails_between_cities = 2
+max_rails_in_city = 4
+seed = 0
+env = RailEnv(
+        width=20,
+        height=30,
+        rail_generator=sparse_rail_generator(
+            max_num_cities=n_cities,
+            seed=seed,
+            grid_mode=True,
+            max_rails_between_cities=max_rails_between_cities,
+            max_rail_pairs_in_city=max_rails_in_city
+        ),
+        line_generator=sparse_line_generator(),
+        number_of_agents=nAgents,
+        obs_builder_object=TreeObsForRailEnv(max_depth=3, predictor=ShortestPathPredictorForRailEnv())
+    )
+
+init_observation = env.reset()
+```

-env = RailEnv(width=7,
-              height=7,
-              rail_generator=random_rail_generator(),
-              number_of_agents=2,
-              obs_builder_object=TreeObsForRailEnv(max_depth=2))
-env.reset()
+%% Cell type:code id: tags:

+``` python
 # Print the observation vector for agent 0
 obs, all_rewards, done, _ = env.step({0: 0})
 for i in range(env.get_num_agents()):
    env.obs_builder.util_print_obs_subtree(tree=obs[i])

 env_renderer = RenderTool(env, gl="PIL")
 # env_renderer = RenderTool(env, gl="PILSVG")

 env_renderer.render_env(show=True, frames=True)

 print("Manual control: s=perform step, q=quit, [agent id] [1-2-3 action] \
       (turnleft+move, move to front, turnright+move)")
 ```

 %% Cell type:code id: tags:

 ``` python
 for step in range(10):

    # This is an example command, setting agent 0's action to 2 (move forward), and agent 1's action to 2,
    # then stepping the environment.
    cmd = "0 2 1 2 s"

    # uncomment this input statement if you want to try interactive manual commands
    # cmd = input(">> ")

    cmds = cmd.split(" ")

    action_dict = {}

    i = 0
    while i < len(cmds):
        if cmds[i] == 'q':
            import sys

            sys.exit()
        elif cmds[i] == 's':
            obs, all_rewards, done, _ = env.step(action_dict)
            action_dict = {}
            print("Rewards: ", all_rewards, "  [done=", done, "]")
        else:
            agent_id = int(cmds[i])
            action = int(cmds[i + 1])
            action_dict[agent_id] = action
            i = i + 1
        i += 1

    env_renderer.render_env(show=True, frames=True)

    time.sleep(0.3)
 ```
+
+%% Cell type:code id: tags:
+
+``` python
+```