Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • flatland/flatland
  • stefan_otte/flatland
  • jiaodaxiaozi/flatland
  • sfwatergit/flatland
  • utozx126/flatland
  • ChenKuanSun/flatland
  • ashivani/flatland
  • minhhoa/flatland
  • pranjal_dhole/flatland
  • darthgera123/flatland
  • rivesunder/flatland
  • thomaslecat/flatland
  • joel_joseph/flatland
  • kchour/flatland
  • alex_zharichenko/flatland
  • yoogottamk/flatland
  • troye_fang/flatland
  • elrichgro/flatland
  • jun_jin/flatland
  • nimishsantosh107/flatland
20 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 1964 additions and 352 deletions
notebooks/Simple_Rendering_Demo.ipynb → notebooks/simple_rendering_demo.ipynb
View file @ a6c4ae6a
%% Cell type:markdown id: tags:
# Plot the Env and some trees
%% Cell type:code id: tags:
``` python
%load_ext autoreload
%autoreload 2
```
%% Cell type:code id: tags:
``` python
import jpy_canvas
import random
import time
import sys
```
%% Cell type:code id: tags:
``` python
# in case you need to tweak your PYTHONPATH...
sys.path.append("../flatland")
```
%% Cell type:code id: tags:
``` python
import flatland.core.env
import flatland.utils.rendertools as rt
from flatland.envs.rail_env import RailEnv, random_rail_generator
from flatland.envs.rail_env import RailEnv
from flatland.envs.rail_generators import sparse_rail_generator
from flatland.envs.line_generators import sparse_line_generator
from flatland.envs.observations import TreeObsForRailEnv
```
%% Cell type:code id: tags:
``` python
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:90% !important; }</style>"))
from flatland.envs.predictions import ShortestPathPredictorForRailEnv
```
%% Cell type:markdown id: tags:
# Generate
%% Cell type:code id: tags:
``` python
nAgents = 3
fnMethod = random_rail_generator(cell_type_relative_proportion=[1] * 11)
env = RailEnv(width=20,
height=10,
rail_generator=fnMethod,
number_of_agents=nAgents,
obs_builder_object=TreeObsForRailEnv(max_depth=2))
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()
```
%% Cell type:markdown id: tags:
# Render
%% Cell type:code id: tags:
``` python
oRT = rt.RenderTool(env,gl="PILSVG")
oRT.renderEnv()
img = oRT.getImage()
oRT.render_env(show_observations=False,show_predictions=True)
img = oRT.get_image()
```
%% Cell type:code id: tags:
``` python
jpy_canvas.Canvas(img)
```
%% Cell type:code id: tags:
``` python
oRT = rt.RenderTool(env,gl="PIL")
oRT.render_env(show_observations=False,show_predictions=True)
img = oRT.get_image()
```
%% Cell type:code id: tags:
``` python
jpy_canvas.Canvas(img)
```
......
notebooks/test-service-timeouts.ipynb 0 → 100644
View file @ a6c4ae6a
%% Cell type:markdown id: tags:
# Test Service
Intended to test the service.py evaluator.
Runs the service.py and a simple client.
%% Cell type:markdown id: tags:
Setup
---
%% Cell type:code id: tags:
``` python
%load_ext autoreload
%autoreload 2
```
%% Cell type:code id: tags:
``` python
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:90% !important; }</style>"))
```
%% Cell type:code id: tags:
``` python
import os
import redis
import subprocess as sp
import shlex
import time
```
%% Cell type:code id: tags:
``` python
import numpy as np
```
%% Cell type:code id: tags:
``` python
from flatland.core.env_observation_builder import DummyObservationBuilder
from flatland.envs.persistence import RailEnvPersister
from flatland.evaluators.client import FlatlandRemoteClient
from flatland.evaluators.client import TimeoutException
```
%% Cell type:code id: tags:
``` python
sDirRoot = "/Users/flaurent/Sites/flatland/neurips2020-flatland-starter-kit/scratch/test-neurips2020-round2-v0"
```
%% Cell type:code id: tags:
``` python
!ps -ef | grep -i python | grep -i flatland.evaluators.service
```
%% Cell type:code id: tags:
``` python
def kill_evaluator():
# kill previous evaluator
!ps -ef | grep -i python | grep -i flatland.evaluators.service | awk '{print $2}' | xargs kill
```
%% Cell type:code id: tags:
``` python
def cleanup():
oRedis = redis.Redis()
lKeys = oRedis.keys("flatland*")
for sKey in lKeys:
print("Deleting:", sKey)
oRedis.delete(sKey)
!rm -f /tmp/output.csv
kill_evaluator()
```
%% Cell type:code id: tags:
``` python
def configure_env(overall=8*60*60, planning=5*60, step=10, successive=10, mean_percentage=0.25):
osEnv2 = os.environ.copy()
osEnv2["FLATLAND_OVERALL_TIMEOUT"]=str(overall)
osEnv2["FLATLAND_PER_STEP_TIMEOUT"] = str(step)
osEnv2["FLATLAND_INITIAL_PLANNING_TIMEOUT"] = str(planning)
osEnv2["FLATLAND_MAX_SUCCESSIVE_TIMEOUTS"] = str(successive)
osEnv2["TEST_MIN_PERCENTAGE_COMPLETE_MEAN"] = str(mean_percentage)
return osEnv2
```
%% Cell type:code id: tags:
``` python
def start_evaluator(env):
sCmd = f"python -m flatland.evaluators.service --test_folder {sDirRoot} --pickle" # --verbose"
lsCmd = shlex.split(sCmd)
print(sCmd)
oPipe = sp.Popen(lsCmd, env=env)
oPipe.poll()
```
%% Cell type:code id: tags:
``` python
def start_client():
oFRC = FlatlandRemoteClient(test_envs_root=sDirRoot, verbose=False, use_pickle=True)
env, env_dict = RailEnvPersister.load_new(f"{sDirRoot}/Test_0/Level_0.pkl")
return oFRC
```
%% Cell type:code id: tags:
``` python
def random_controller(obs, _env):
np.random.seed(0)
dAct = {}
for iAg in range(len(_env.agents)):
dAct[iAg] = np.random.randint(0, 5)
return dAct
```
%% Cell type:code id: tags:
``` python
def run_submission(oFRC, slow_ep=-1, debug=False):
def log(txt, end="\n"):
if debug: print(txt, end)
dummy_obs = DummyObservationBuilder()
episode = 0
obs = True
while obs:
obs, info = oFRC.env_create(obs_builder_object=dummy_obs)
log(oFRC.current_env_path)
log(f"Episode : {episode}")
if not obs:
log("None observation - all envs completed!")
break
while True:
action = random_controller(obs, oFRC.env)
if slow_ep != -1:
# make a specific episode artificially slow
if (episode == slow_ep) and (oFRC.env._elapsed_steps > 10):
time.sleep(2)
try:
observation, all_rewards, done, info = oFRC.env_step(action)
#log(".", end="")
if done['__all__']:
log("\nCompleted Episode : ", episode)
log("Reward : ", sum(list(all_rewards.values())))
break
except TimeoutException as err:
log("Timeout: ", err)
break
episode += 1
```
%% Cell type:markdown id: tags:
Tests
---
%% Cell type:code id: tags:
``` python
%%time
# Normal submission
cleanup()
config = configure_env(overall=8*60*60, planning=5*60, step=10, successive=10, mean_percentage=0.1)
start_evaluator(config)
client = start_client()
run_submission(client)
```
%% Cell type:code id: tags:
``` python
%%time
# Overall timeout
cleanup()
config = configure_env(overall=3, planning=5*60, step=10, successive=10, mean_percentage=0.0)
start_evaluator(config)
client = start_client()
run_submission(client, debug=False)
```
%% Cell type:markdown id: tags:
Cleanup
---
%% Cell type:code id: tags:
``` python
kill_evaluator()
```
notebooks/test_saved_envs.ipynb 0 → 100644
View file @ a6c4ae6a
%% Cell type:markdown id: tags:
## Load some (old) env files to check they work
This notebook just loads some old env files, renders them, and runs a few steps.
This is just a sanity check that these old envs will still load.
Many of them use deprecated data formats so it's just so that we can avoid deleting them for now, and so new participants are not confused by us shipping env files which don't work...
%% Cell type:code id: tags:
``` python
%load_ext autoreload
%autoreload 2
```
%% Cell type:code id: tags:
``` python
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:90% !important; }</style>"))
```
%% Cell type:code id: tags:
``` python
import importlib_resources as ir
```
%% Cell type:code id: tags:
``` python
from flatland.envs.persistence import RailEnvPersister
from flatland.utils import jupyter_utils as ju
```
%% Cell type:code id: tags:
``` python
lsPackages = [ "env_data.railway"]
```
%% Cell type:code id: tags:
``` python
ltPackRes = []
for sPack in lsPackages:
for sExt in ["mpk", "pkl"]:
ltPackRes += [ (sPack, sRes) for sRes in ir.contents(sPack) if sRes.endswith(sExt) ]
ltPackRes
```
%% Cell type:code id: tags:
``` python
for sPack, sRes in ltPackRes:
print("Loading: ", sPack, sRes)
env, env_dict = RailEnvPersister.load_new(sRes, load_from_package=sPack)
env.reset()
oCanvas = ju.EnvCanvas(env, ju.AlwaysForward(env))
oCanvas.show()
for iStep in range(10):
oCanvas.step()
oCanvas.render()
```
notebooks/test_service.ipynb 0 → 100644
View file @ a6c4ae6a
%% Cell type:markdown id: tags:
# Test Service
Intended to test the service.py evaluator.
Runs the service.py and a simple client.
%% Cell type:markdown id: tags:
# Setup
%% Cell type:code id: tags:
``` python
%load_ext autoreload
%autoreload 2
```
%% Cell type:code id: tags:
``` python
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:90% !important; }</style>"))
```
%% Cell type:code id: tags:
``` python
import sys
import os
import redis
import subprocess as sp
import shlex
import time
import importlib_resources as ir
```
%% Cell type:code id: tags:
``` python
import pandas as pd
import numpy as np
```
%% Cell type:code id: tags:
``` python
from flatland.core.env_observation_builder import DummyObservationBuilder
from flatland.envs.persistence import RailEnvPersister
from flatland.evaluators.client import FlatlandRemoteClient
from flatland.evaluators.client import TimeoutException
from flatland.envs.rail_env import RailEnvActions
```
%% Cell type:markdown id: tags:
### Find the real path of the `env_data` package (should be copied by tox)
%% Cell type:code id: tags:
``` python
with ir.path("env_data.tests", "test_001.pkl") as oPath:
sPath = oPath
print(type(sPath), sPath)
```
%% Cell type:code id: tags:
``` python
sDirRoot = "/" + "/".join(sPath.parts[1:-1] + ("service_test",""))
sDirRoot
```
%% Cell type:markdown id: tags:
### Clear any old redis keys
%% Cell type:code id: tags:
``` python
oRedis = redis.Redis()
```
%% Cell type:code id: tags:
``` python
lKeys = oRedis.keys("flatland*")
lKeys
```
%% Cell type:code id: tags:
``` python
for sKey in lKeys:
print("Deleting:", sKey)
oRedis.delete(sKey)
```
%% Cell type:markdown id: tags:
### Remove `/tmp/output.csv`
%% Cell type:code id: tags:
``` python
!rm -f /tmp/output.csv
```
%% Cell type:markdown id: tags:
### kill any old `service.py` process
%% Cell type:code id: tags:
``` python
!ps -ef | grep -i python | grep -i flatland.evaluators.service | awk '{print $2}' | xargs kill
```
%% Cell type:code id: tags:
``` python
osEnv2 = os.environ.copy()
```
%% Cell type:markdown id: tags:
### Set some short timeouts for testing
%% Cell type:code id: tags:
``` python
osEnv2["FLATLAND_OVERALL_TIMEOUT"]="10"
osEnv2["FLATLAND_PER_STEP_TIMEOUT"] = "2"
osEnv2["FLATLAND_MAX_SUCCESSIVE_TIMEOUTS"] = "2"
```
%% Cell type:markdown id: tags:
### Create the python command for `service.py`
%% Cell type:code id: tags:
``` python
#sCmd = "python -m flatland.evaluators.service --test_folder ../env_data/tests/service_test --mergeDir ./tmp/merge --actionDir ./tmp/actions --pickle --missingOnly"
#sCmd = "python -m flatland.evaluators.service --test_folder ../env_data/tests/service_test --pickle" # --verbose"
sCmd = f"python -m flatland.evaluators.service --test_folder {sDirRoot} --pickle" # --verbose"
lsCmd = shlex.split(sCmd)
print(sCmd)
print(lsCmd)
```
%% Cell type:markdown id: tags:
### Run the command with Popen (output goes to jupyter stdout not notebook)
%% Cell type:code id: tags:
``` python
oPipe = sp.Popen(lsCmd, env=osEnv2)
```
%% Cell type:code id: tags:
``` python
oPipe.poll()
```
%% Cell type:code id: tags:
``` python
oFRC = FlatlandRemoteClient(test_env_folder=sDirRoot, verbose=False, use_pickle=True)
```
%% Cell type:code id: tags:
``` python
env, env_dict = RailEnvPersister.load_new(f"{sDirRoot}/Test_0/Level_0.pkl")
```
%% Cell type:code id: tags:
``` python
def forward_only_controller(obs, _env):
dAct = {}
for iAg in range(len(_env.agents)):
dAct[iAg] = RailEnvActions.MOVE_FORWARD
return dAct
def random_controller(obs, _env):
dAct = {}
for iAg in range(len(_env.agents)):
dAct[iAg] = np.random.randint(0, 5)
return dAct
```
%% Cell type:code id: tags:
``` python
oObsB = DummyObservationBuilder()
```
%% Cell type:code id: tags:
``` python
oObsB.get()
```
%% Cell type:code id: tags:
``` python
def run_submission(slow_ep=1, delay=2):
episode = 0
obs = True
while obs:
obs, info = oFRC.env_create(obs_builder_object=oObsB)
if not obs:
print("null observation - all envs completed!")
break
print(f"Episode : {episode}")
print(oFRC.env.dones['__all__'])
while True:
if episode < 3:
action = forward_only_controller(obs, oFRC.env)
else:
action = random_controller(obs, oFRC.env)
time_start = time.time()
if (episode == slow_ep) and (oFRC.env._elapsed_steps > 10):
time.sleep(2)
try:
observation, all_rewards, done, info = oFRC.env_step(action)
time_diff = time.time() - time_start
print(".", end="")
if done['__all__']:
print("\nCompleted Episode : ", episode)
print("Reward : ", sum(list(all_rewards.values())))
break
except TimeoutException as err:
print("Timeout: ", err)
break
episode += 1
print(f"Evaluation Complete - episodes={episode} - send submit message...")
print(oFRC.submit())
print("All done.")
```
%% Cell type:code id: tags:
``` python
try:
run_submission()
except TimeoutException as timeoutException:
print("Timed out.")
print(timeoutException)
```
%% Cell type:markdown id: tags:
### Kill the evaluator process we started earlier
%% Cell type:code id: tags:
``` python
!ps -ef | grep -i python | grep -i flatland.evaluators.service | awk '{print $2}' | xargs kill
```
%% Cell type:code id: tags:
``` python
pd.read_csv("/tmp/output.csv").T
```
rendering/make_video_ffmpeg.txt
View file @ a6c4ae6a
ffmpeg -y -framerate 12 -i frame_%04d.bmp -hide_banner -c:v libx264 -pix_fmt yuv420p test.mp4
ffmpeg -i test.mp4 test.gif
pause
\ No newline at end of file
requirements_continuous_integration.txt
View file @ a6c4ae6a
# contains all additional requirements to run the ```tox .``` in addition to requirements_dev.txt for ```tox -e py36,py37```
bumpversion==0.5.3
wheel==0.32.1
watchdog==0.9.0
benchmarker==4.0.1
coverage==4.5.1
Sphinx==1.8.1
sphinx-rtd-theme==0.4.3
flake8==3.7.7
flake8-eradicate==0.2.0
twine==1.12.1
pydeps==1.7.2
jupyter==1.0.0
bumpversion>=0.5.3
wheel>=0.32.1
watchdog>=0.9.0
benchmarker>=4.0.1
coverage>=4.5.1
# pin sphinx to <2.0 because of https://github.com/readthedocs/sphinx_rtd_theme/issues/746
Sphinx>=1.8.1,<2.0
sphinx-rtd-theme>=0.4.3
numpydoc>=0.9.1
docutils>=0.15.2
flake8>=3.7.7
flake8-eradicate>=0.2.0
twine>=1.12.1
pydeps>=1.7.2
jupyter>=1.0.0
jupyter-core>=4.5.0
jupyter-contrib-nbextensions
notebook>=5.7.8
PyVirtualDisplay==1.3.2
pytest-xvfb==2.0.0
git+https://github.com/who8mylunch/Jupyter_Canvas_Widget.git@bd151ae1509c50b5809944dd3294f58b7b069c86
m2r>=0.2.1
requirements_dev.txt
View file @ a6c4ae6a
# contains all requirements to run the tests by running ```tox -e py36,py37```
tox==3.5.2
twine==1.12.1
pytest==3.8.2
pytest-runner==4.2
pytest-xvfb==1.2.0
numpy==1.16.4
recordtype==1.3
xarray==0.11.3
matplotlib==3.0.2
Pillow==5.4.1
# pycairo==1.18.1 is installed via setup.py since it needs special treatment under Windows
CairoSVG==2.3.1
msgpack==0.6.1
svgutils==0.3.1
screeninfo==0.3.1
pyarrow==0.13.0
importlib-metadata==0.17
importlib_resources==1.0.2
tox>=3.5.2
pytest>=3.8.2,<5
pytest-runner>=4.2
Click>=7.0
crowdai-api>=0.1.21
numpy>=1.16.2
recordtype>=1.3
matplotlib>=3.0.2
Pillow>=5.4.1
msgpack>=1.0.0,<2.0.0
msgpack-numpy>=0.4.4.0
svgutils>=0.3.1
pyarrow>=0.13.0
pandas>=0.25.1
importlib-metadata>=0.17
importlib-resources>=1.0.1,<2
six>=1.12.0
timeout-decorator>=0.4.1
attrs
gym==0.14.0
networkx
ipycanvas
graphviz
imageio
dataclasses
run_local_multispeed.py 0 → 100644
View file @ a6c4ae6a
from flatland.envs.agent_utils import TrainState
from flatland.envs.malfunction_generators import ParamMalfunctionGen
from flatland.envs.malfunction_generators import MalfunctionParameters
from flatland.envs.observations import GlobalObsForRailEnv
from flatland.envs.rail_env import RailEnv
from flatland.envs.rail_generators import sparse_rail_generator
from flatland.envs.line_generators import sparse_line_generator
import random
import r2_solver
import sys
import time
import matplotlib.pyplot as plt
import PIL
from flatland.utils.rendertools import RenderTool
from IPython.display import clear_output
from IPython.display import display
def GetTestParams(tid):
seed = tid * 19997 + 997
random.seed(seed)
width = 30 + random.randint(0, 11)
height = 30 + random.randint(0, 11)
nr_cities = 4 + random.randint(0, (width + height) // 10)
nr_trains = min(nr_cities * 4, 10 + random.randint(0, 10))
max_rails_between_cities = 2
max_rails_in_cities = 3 + random.randint(0, 5)
malfunction_rate = 0#1/100 + random.randint(0, 5)
malfunction_min_duration = 0#1 + random.randint(0, 5)
malfunction_max_duration = 0#6 + random.randint(0, 10)
return (seed, width, height, nr_trains, nr_cities, max_rails_between_cities, max_rails_in_cities, malfunction_rate,
malfunction_min_duration, malfunction_max_duration)
def render_env(env,wait=True,cnt=0):
env_renderer = RenderTool(env, gl="PILSVG")
env_renderer.render_env()
image = env_renderer.get_image()
pil_image = PIL.Image.fromarray(image)
# clear_output(wait=True)
pil_image.save("images/"+str(cnt)+".png")
def ShouldRunTest(tid):
# return tid == 5
# return tid >= 3
return True
DEFAULT_SPEED_RATIO_MAP = {1.: 0.25,
1. / 2.: 0.25,
1. / 3.: 0.25,
1. / 4.: 0.25}
NUM_TESTS = 200
d_base = {}
# f = open("scores.txt", "r")
# for line in f.readlines():
# lsplit = line.split(" ")
# if len(lsplit) >= 4:
# test_id = int(lsplit[0])
# num_done_agents = int(lsplit[1])
# percentage_num_done_agents = float(lsplit[2])
# score = float(lsplit[3])
# d_base[test_id] = (num_done_agents, score)
# f.close()
f = open("tmp-scores.txt", "w")
total_percentage_num_done_agents = 0.0
total_score = 0.0
total_base_percentage_num_done_agents = 0.0
total_base_score = 0.0
num_tests = 0
cnt = 0
for test_id in range(NUM_TESTS):
print(test_id)
seed, width, height, nr_trains, nr_cities, max_rails_between_cities, max_rails_in_cities, malfunction_rate, \
malfunction_min_duration, malfunction_max_duration = GetTestParams(test_id)
if not ShouldRunTest(test_id):
continue
rail_generator = sparse_rail_generator(max_num_cities=nr_cities,
seed=seed,
grid_mode=False,
max_rails_between_cities=max_rails_between_cities,
max_rail_pairs_in_city=max_rails_in_cities,
)
line_generator = sparse_line_generator(DEFAULT_SPEED_RATIO_MAP, seed=seed)
stochastic_data = MalfunctionParameters(malfunction_rate = malfunction_rate,
min_duration = malfunction_min_duration,
max_duration = malfunction_max_duration,
)
observation_builder = GlobalObsForRailEnv()
env = RailEnv(width=width,
height=height,
rail_generator=rail_generator,
line_generator=line_generator,
number_of_agents=nr_trains,
malfunction_generator=ParamMalfunctionGen(stochastic_data),
obs_builder_object=observation_builder,
remove_agents_at_target=True,
random_seed=seed
)
obs = env.reset()
render_env(env)
solver = r2_solver.Solver(test_id)
score = 0.0
num_steps = 15 * (width + height)
all_rewards = {}
print(
"test_id=%d seed=%d nr_trains=%d nr_cities=%d num_steps=%d" % (test_id, seed, nr_trains, nr_cities, num_steps))
for step in range(num_steps):
moves = solver.GetMoves(env.agents, obs[0], env.distance_map, env._max_episode_steps)
next_obs, all_rewards, done, _ = env.step(moves)
# render_env(env, True, cnt)
cnt += 1
# print("step",cnt)
for a in range(env.get_num_agents()):
score += float(all_rewards[a])
obs = next_obs.copy()
if done['__all__']:
break
# print(env._elapsed_steps)
# for a in range(env.get_num_agents()):
# print(a, float(all_rewards[a]))
print("--Reward : ", sum(list(all_rewards.values())))
num_done_agents = 0
for aid, agent in enumerate(env.agents):
if agent.state == TrainState.DONE:
num_done_agents += 1
percentage_num_done_agents = 100.0 * num_done_agents / len(env.agents)
total_percentage_num_done_agents += percentage_num_done_agents
total_score += score
num_tests += 1
base_num_done_agents = 0
base_score = -1e9
if test_id in d_base:
base_num_done_agents, base_score = d_base[test_id]
base_percentage_num_done_agents = 100.0 * base_num_done_agents / len(env.agents)
total_base_percentage_num_done_agents += base_percentage_num_done_agents
total_base_score += base_score
avg_nda = total_percentage_num_done_agents / num_tests
avg_nda_dif = (total_percentage_num_done_agents - total_base_percentage_num_done_agents) / num_tests
print(
"\n### test_id=%d nda=%d(dif=%d) pnda=%.6f(dif=%.6f) score=%.6f(dif=%.6f) avg_nda=%.6f(dif=%.6f) avg_sc=%.6f(dif=%.6f)\n" % (
test_id, num_done_agents, num_done_agents - base_num_done_agents, percentage_num_done_agents,
percentage_num_done_agents - base_percentage_num_done_agents, score, score - base_score, avg_nda, avg_nda_dif,
total_score / num_tests, (total_score - total_base_score) / num_tests))
f.write("%d %d% .10f %.10f %d %.10f %.10f\n" % (
test_id, num_done_agents, percentage_num_done_agents, score, num_done_agents - base_num_done_agents,
percentage_num_done_agents - base_percentage_num_done_agents, avg_nda_dif))
f.flush()
# f.close()
run_local_readytodepart_check.py 0 → 100644
View file @ a6c4ae6a
from flatland.envs.agent_utils import TrainState
from flatland.envs.malfunction_generators import ParamMalfunctionGen
from flatland.envs.malfunction_generators import MalfunctionParameters
from flatland.envs.observations import GlobalObsForRailEnv
from flatland.envs.rail_env import RailEnv
from flatland.envs.rail_generators import sparse_rail_generator
from flatland.envs.line_generators import sparse_line_generator
from flatland.envs.rail_env_action import RailEnvActions
import random
# import r2_solver
import sys
import time
import matplotlib.pyplot as plt
import PIL
from flatland.utils.rendertools import RenderTool
from IPython.display import clear_output
from IPython.display import display
def GetTestParams(tid):
seed = tid * 19997 + 997
random.seed(seed)
width = 30 + random.randint(0, 11)
height = 30 + random.randint(0, 11)
nr_cities = 4 + random.randint(0, (width + height) // 10)
nr_trains = min(nr_cities * 4, 10 + random.randint(0, 10))
max_rails_between_cities = 2
max_rails_in_cities = 3 + random.randint(0, 5)
malfunction_rate = 0#1/100 + random.randint(0, 5)
malfunction_min_duration = 0#1 + random.randint(0, 5)
malfunction_max_duration = 0#6 + random.randint(0, 10)
return (seed, width, height, nr_trains, nr_cities, max_rails_between_cities, max_rails_in_cities, malfunction_rate,
malfunction_min_duration, malfunction_max_duration)
def render_env(env,wait=True,cnt=0):
return
env_renderer = RenderTool(env, gl="PILSVG")
env_renderer.render_env()
image = env_renderer.get_image()
pil_image = PIL.Image.fromarray(image)
# clear_output(wait=True)
pil_image.save("images/"+str(cnt)+".png")
def ShouldRunTest(tid):
return tid >= 7
# return tid >= 3
return True
def getactions(step):
with open('/Users/dipam/Downloads/actions_ms.txt', 'r') as f:
line = f.readline()
while line.strip() != f'time= {step}':
line = f.readline()
_ = f.readline()
actions = {}
line = f.readline()
while line.strip().split(' ')[0] != 'time=':
lsplit = line.strip().split(' ')
act = int(lsplit[-1])
i_agent = int(lsplit[0])
actions[i_agent] = act
line = f.readline()
return actions
DEFAULT_SPEED_RATIO_MAP = {1.: 0.25,
1. / 2.: 0.25,
1. / 3.: 0.25,
1. / 4.: 0.25}
NUM_TESTS = 1
d_base = {}
# f = open("scores.txt", "r")
# for line in f.readlines():
# lsplit = line.split(" ")
# if len(lsplit) >= 4:
# test_id = int(lsplit[0])
# num_done_agents = int(lsplit[1])
# percentage_num_done_agents = float(lsplit[2])
# score = float(lsplit[3])
# d_base[test_id] = (num_done_agents, score)
# f.close()
# f = open("tmp-scores.txt", "w")
total_percentage_num_done_agents = 0.0
total_score = 0.0
total_base_percentage_num_done_agents = 0.0
total_base_score = 0.0
num_tests = 0
cnt = 0
for test_id in range(NUM_TESTS):
seed, width, height, nr_trains, nr_cities, max_rails_between_cities, max_rails_in_cities, malfunction_rate, \
malfunction_min_duration, malfunction_max_duration = GetTestParams(test_id)
# if not ShouldRunTest(test_id):
# continue
rail_generator = sparse_rail_generator(max_num_cities=nr_cities,
seed=seed,
grid_mode=False,
max_rails_between_cities=max_rails_between_cities,
max_rail_pairs_in_city=max_rails_in_cities,
)
line_generator = sparse_line_generator(DEFAULT_SPEED_RATIO_MAP, seed=seed)
stochastic_data = MalfunctionParameters(malfunction_rate = malfunction_rate,
min_duration = malfunction_min_duration,
max_duration = malfunction_max_duration,
)
# stochastic_data = MalfunctionParameters(
# malfunction_rate=1/10000, # Rate of malfunction occurence
# min_duration=15, # Minimal duration of malfunction
# max_duration=50 # Max duration of malfunction
# )
observation_builder = GlobalObsForRailEnv()
env = RailEnv(width=width,
height=height,
rail_generator=rail_generator,
line_generator=line_generator,
number_of_agents=nr_trains,
malfunction_generator=ParamMalfunctionGen(stochastic_data),
obs_builder_object=observation_builder,
remove_agents_at_target=True,
random_seed=seed
)
obs = env.reset()
render_env(env)
# solver = r2_solver.Solver(test_id)
score = 0.0
num_steps = 80 * (width + height + 20)
print(
"test_id=%d seed=%d nr_trains=%d nr_cities=%d num_steps=%d" % (test_id, seed, nr_trains, nr_cities, num_steps))
for step in range(num_steps):
# moves = solver.GetMoves(env.agents, obs[0])
moves = getactions(step)
if env.agents[1].speed_counter.is_cell_exit:
moves[1] = 4
if env._elapsed_steps > 25 and env._elapsed_steps < 41:
a1 = env.agents[1]
a5 = env.agents[5]
print("Step", env._elapsed_steps, "Agent 1", a1.position, a1.state, a1.speed_counter.counter, moves[1],
env.agents[1].speed_counter.is_cell_exit, env.agents[1].speed_counter.counter)
next_obs, all_rewards, done, _ = env.step(moves)
old_agent_positions = env.agent_positions.copy()
# for ag in self.agents:
# if ag.state == TrainState.STOPPED and ag.state_machine.previous_state == TrainState.MALFUNCTION_OFF_MAP and \
# action_dict_.get(ag.handle, 4) == RailEnvActions.DO_NOTHING:
# import pdb; pdb.set_trace()
positions = {}
for ag in env.agents:
if ag.position in positions:
import pdb; pdb.set_trace()
if ag.position is not None:
positions[ag.position] = ag.handle, ag.speed_counter.speed
# if env._elapsed_steps > 30:
# import pdb; pdb.set_trace()
render_env(env, True, cnt)
cnt += 1
for a in range(env.get_num_agents()):
score += float(all_rewards[a])
obs = next_obs.copy()
if done['__all__']:
break
num_done_agents = 0
for aid, agent in enumerate(env.agents):
if agent.state == TrainState.DONE:
num_done_agents += 1
percentage_num_done_agents = 100.0 * num_done_agents / len(env.agents)
total_percentage_num_done_agents += percentage_num_done_agents
total_score += score
num_tests += 1
base_num_done_agents = 0
base_score = -1e9
if test_id in d_base:
base_num_done_agents, base_score = d_base[test_id]
base_percentage_num_done_agents = 100.0 * base_num_done_agents / len(env.agents)
total_base_percentage_num_done_agents += base_percentage_num_done_agents
total_base_score += base_score
avg_nda = total_percentage_num_done_agents / num_tests
avg_nda_dif = (total_percentage_num_done_agents - total_base_percentage_num_done_agents) / num_tests
# print(
# "\n### test_id=%d nda=%d(dif=%d) pnda=%.6f(dif=%.6f) score=%.6f(dif=%.6f) avg_nda=%.6f(dif=%.6f) avg_sc=%.6f(dif=%.6f)\n" % (
# test_id, num_done_agents, num_done_agents - base_num_done_agents, percentage_num_done_agents,
# percentage_num_done_agents - base_percentage_num_done_agents, score, score - base_score, avg_nda, avg_nda_dif,
# total_score / num_tests, (total_score - total_base_score) / num_tests))
# f.write("%d %d% .10f %.10f %d %.10f %.10f\n" % (
# test_id, num_done_agents, percentage_num_done_agents, score, num_done_agents - base_num_done_agents,
# percentage_num_done_agents - base_percentage_num_done_agents, avg_nda_dif))
# f.flush()
# f.close()
scripts/convert_svg_2_png.py 0 → 100755
View file @ a6c4ae6a
#!/usr/bin/env python
import glob
from cairosvg import svg2png
import os
import shutil
import tqdm
import io
from PIL import Image
########################################################
########################################################
#
# Converts SVG assets into PNG assets
#
# We use this approach to drop the CairoSVG dependency
# from the flatland requirements.
#
# Usage Requires :
#
# conda install cairo
#
########################################################
########################################################
TARGET_PNG_WIDTH=300
TARGET_PNG_HEIGHT=300
SVG_FOLDER="../flatland/svg"
TARGET_FOLDER="../flatland/png"
# Delete target PNG files, if they exist
for _png_file in glob.glob(os.path.join(TARGET_FOLDER, "*.png")):
os.remove(_png_file)
# Convert all SVG files into PNG files
for _source_svg_path in tqdm.tqdm(glob.glob(os.path.join(SVG_FOLDER, "*.svg"))):
base_filename = os.path.basename(_source_svg_path)
target_filename = base_filename.replace(".svg", ".png")
target_filepath = os.path.join(
TARGET_FOLDER,
target_filename
)
bytesPNG = svg2png(
file_obj=open(_source_svg_path, "rb"),
output_height=TARGET_PNG_WIDTH,
output_width=TARGET_PNG_HEIGHT
)
with io.BytesIO(bytesPNG) as fIn:
im = Image.open(fIn)
im.load()
assert im.size == (TARGET_PNG_WIDTH, TARGET_PNG_HEIGHT)
im.save(target_filepath)
setup.cfg
View file @ a6c4ae6a
[bumpversion]
current_version = 0.1.1
current_version = 3.0.15
commit = True
tag = True
......@@ -22,4 +22,3 @@ test = pytest
[tool:pytest]
collect_ignore = ['setup.py']
setup.py
View file @ a6c4ae6a
......@@ -3,68 +3,36 @@
"""The setup script."""
import os
import platform
import sys
from setuptools import setup, find_packages
with open('README.rst') as readme_file:
assert sys.version_info >= (3, 6)
with open('README.md', 'r', encoding='utf8') as readme_file:
readme = readme_file.read()
with open('HISTORY.rst') as history_file:
history = history_file.read()
# install pycairo on Windows
if os.name == 'nt':
p = platform.architecture()
is64bit = p[0] == '64bit'
if sys.version[0:3] == '3.5':
if is64bit:
url = 'https://download.lfd.uci.edu/pythonlibs/t4jqbe6o/pycairo-1.18.0-cp35-cp35m-win_amd64.whl'
else:
url = 'https://download.lfd.uci.edu/pythonlibs/t4jqbe6o/pycairo-1.18.0-cp35-cp35m-win32.whl'
if sys.version[0:3] == '3.6':
if is64bit:
url = 'https://download.lfd.uci.edu/pythonlibs/t4jqbe6o/pycairo-1.18.0-cp36-cp36m-win_amd64.whl'
else:
url = 'https://download.lfd.uci.edu/pythonlibs/t4jqbe6o/pycairo-1.18.0-cp36-cp36m-win32.whl'
if sys.version[0:3] == '3.7':
if is64bit:
url = 'https://download.lfd.uci.edu/pythonlibs/t4jqbe6o/pycairo-1.18.0-cp37-cp37m-win_amd64.whl'
else:
url = 'https://download.lfd.uci.edu/pythonlibs/t4jqbe6o/pycairo-1.18.0-cp37-cp37m-win32.whl'
try:
import pycairo
except:
call_cmd = "pip install " + url
os.system(call_cmd)
def get_all_svg_files(directory='./svg/'):
ret = []
for dirpath, subdirs, files in os.walk(directory):
for f in files:
ret.append(os.path.join(dirpath, f))
return ret
import site
import ctypes.util
default_os_path = os.environ['PATH']
os.environ['PATH'] = ''
for s in site.getsitepackages():
os.environ['PATH'] = os.environ['PATH'] + ';' + s + '\\cairo'
os.environ['PATH'] = os.environ['PATH'] + ';' + default_os_path
print(os.environ['PATH'])
if ctypes.util.find_library('cairo') is not None:
print("cairo installed: OK")
else:
try:
import pycairo
except:
os.system("pip install pycairo==1.18.1")
def get_all_images_files(directory='./images/'):
ret = []
for dirpath, subdirs, files in os.walk(directory):
for f in files:
ret.append(os.path.join(dirpath, f))
return ret
def get_all_svg_files(directory='./svg/'):
def get_all_notebook_files(directory='./notebooks/'):
ret = []
for f in os.listdir(directory):
if os.path.isfile(os.path.join(directory, f)):
ret.append(directory + f)
for dirpath, subdirs, files in os.walk(directory):
for f in files:
ret.append(os.path.join(dirpath, f))
return ret
......@@ -85,7 +53,7 @@ setup(
author="S.P. Mohanty",
author_email='mohanty@aicrowd.com',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'Natural Language :: English',
'Programming Language :: Python :: 3.6',
......@@ -94,20 +62,24 @@ setup(
description="Multi Agent Reinforcement Learning on Trains",
entry_points={
'console_scripts': [
'flatland=flatland.cli:main',
'flatland-demo=flatland.cli:demo',
'flatland-evaluator=flatland.cli:evaluator'
],
},
install_requires=requirements,
long_description=readme + '\n\n' + history,
long_description=readme,
long_description_content_type="text/markdown",
include_package_data=True,
keywords='flatland',
name='flatland-rl',
packages=find_packages('.'),
data_files=[('svg', get_all_svg_files())],
data_files=[('svg', get_all_svg_files()),
('images', get_all_images_files()),
('notebooks', get_all_notebook_files())],
setup_requires=setup_requirements,
test_suite='tests',
tests_require=test_requirements,
url='https://gitlab.aicrowd.com/flatland/flatland',
version='0.1.1',
version='3.0.15',
zip_safe=False,
)
simple_env_creation.ipynb 0 → 100644
View file @ a6c4ae6a
source diff could not be displayed: it is too large. Options to address this: view the blob.
tests/manual_test_eval_timeout.sh 0 → 100755
View file @ a6c4ae6a
#!/bin/bash
export FLATLAND_DEFAULT_COMMAND_TIMEOUT=5
export FLATLAND_DEFAULT_COMMAND_TIMEOUT=60
export FLATLAND_INITIAL_PLANNING_TIMEOUT=8
export AICROWD_TESTS_FOLDER=../submission-scoring/Envs/neurips2020_round1_v0
redis-cli KEYS "*" | grep -i flatland | xargs redis-cli DEL
# you need to create the envs in the folder
# best to delete all but 10 small ones
#gnome-terminal --title Service --window -- python -m flatland.evaluators.service --test_folder ../submission-scoring/Envs/neurips2020_round1_v0/
xterm -title Service -hold -e "python -m flatland.evaluators.service --test_folder ../submission-scoring/Envs/neurips2020_round1_v0/ " &
#gnome-terminal --title test_eval_timeout --window -- python tests/test_eval_timeout.py
xterm -title test_eval_timeout -hold -e "python tests/test_eval_timeout.py" &
tests/test_action_plan.py 0 → 100644
View file @ a6c4ae6a
from flatland.action_plan.action_plan import TrainrunWaypoint, ActionPlanElement, \
ControllerFromTrainruns
from flatland.action_plan.action_plan_player import ControllerFromTrainrunsReplayer
from flatland.core.grid.grid4 import Grid4TransitionsEnum
from flatland.envs.observations import GlobalObsForRailEnv
from flatland.envs.rail_env import RailEnv, RailEnvActions
from flatland.envs.rail_generators import rail_from_grid_transition_map
from flatland.envs.rail_trainrun_data_structures import Waypoint
from flatland.envs.line_generators import sparse_line_generator
from flatland.utils.rendertools import RenderTool, AgentRenderVariant
from flatland.utils.simple_rail import make_simple_rail
from flatland.envs.step_utils.speed_counter import SpeedCounter
def test_action_plan(rendering: bool = False):
"""Tests ActionPlanReplayer: does action plan generation and replay work as expected."""
rail, rail_map, optionals = make_simple_rail()
env = RailEnv(width=rail_map.shape[1],
height=rail_map.shape[0],
rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(seed=77),
number_of_agents=2,
obs_builder_object=GlobalObsForRailEnv(),
remove_agents_at_target=True,
random_seed=1,
)
env.reset()
env.agents[0].initial_position = (3, 0)
env.agents[0].target = (3, 8)
env.agents[0].initial_direction = Grid4TransitionsEnum.WEST
env.agents[1].initial_position = (3, 8)
env.agents[1].initial_direction = Grid4TransitionsEnum.WEST
env.agents[1].target = (0, 3)
env.agents[1].speed_counter = SpeedCounter(speed=0.5)
env.reset(False, False)
for handle, agent in enumerate(env.agents):
print("[{}] {} -> {}".format(handle, agent.initial_position, agent.target))
# Perform DO_NOTHING actions until all trains get to READY_TO_DEPART
for _ in range(max([agent.earliest_departure for agent in env.agents]) + 1):
env.step({}) # DO_NOTHING for all agents
chosen_path_dict = {0: [TrainrunWaypoint(scheduled_at=0, waypoint=Waypoint(position=(3, 0), direction=3)),
TrainrunWaypoint(scheduled_at=2, waypoint=Waypoint(position=(3, 1), direction=1)),
TrainrunWaypoint(scheduled_at=3, waypoint=Waypoint(position=(3, 2), direction=1)),
TrainrunWaypoint(scheduled_at=14, waypoint=Waypoint(position=(3, 3), direction=1)),
TrainrunWaypoint(scheduled_at=15, waypoint=Waypoint(position=(3, 4), direction=1)),
TrainrunWaypoint(scheduled_at=16, waypoint=Waypoint(position=(3, 5), direction=1)),
TrainrunWaypoint(scheduled_at=17, waypoint=Waypoint(position=(3, 6), direction=1)),
TrainrunWaypoint(scheduled_at=18, waypoint=Waypoint(position=(3, 7), direction=1)),
TrainrunWaypoint(scheduled_at=19, waypoint=Waypoint(position=(3, 8), direction=1)),
TrainrunWaypoint(scheduled_at=20, waypoint=Waypoint(position=(3, 8), direction=5))],
1: [TrainrunWaypoint(scheduled_at=0, waypoint=Waypoint(position=(3, 8), direction=3)),
TrainrunWaypoint(scheduled_at=3, waypoint=Waypoint(position=(3, 7), direction=3)),
TrainrunWaypoint(scheduled_at=5, waypoint=Waypoint(position=(3, 6), direction=3)),
TrainrunWaypoint(scheduled_at=7, waypoint=Waypoint(position=(3, 5), direction=3)),
TrainrunWaypoint(scheduled_at=9, waypoint=Waypoint(position=(3, 4), direction=3)),
TrainrunWaypoint(scheduled_at=11, waypoint=Waypoint(position=(3, 3), direction=3)),
TrainrunWaypoint(scheduled_at=13, waypoint=Waypoint(position=(2, 3), direction=0)),
TrainrunWaypoint(scheduled_at=15, waypoint=Waypoint(position=(1, 3), direction=0)),
TrainrunWaypoint(scheduled_at=17, waypoint=Waypoint(position=(0, 3), direction=0))]}
expected_action_plan = [[
# take action to enter the grid
ActionPlanElement(0, RailEnvActions.MOVE_FORWARD),
# take action to enter the cell properly
ActionPlanElement(1, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(2, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(3, RailEnvActions.STOP_MOVING),
ActionPlanElement(13, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(14, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(15, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(16, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(17, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(18, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(19, RailEnvActions.STOP_MOVING)
], [
ActionPlanElement(0, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(1, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(3, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(5, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(7, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(9, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(11, RailEnvActions.MOVE_RIGHT),
ActionPlanElement(13, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(15, RailEnvActions.MOVE_FORWARD),
ActionPlanElement(17, RailEnvActions.STOP_MOVING),
]]
deterministic_controller = ControllerFromTrainruns(env, chosen_path_dict)
deterministic_controller.print_action_plan()
ControllerFromTrainruns.assert_actions_plans_equal(expected_action_plan, deterministic_controller.action_plan)
if rendering:
renderer = RenderTool(env, gl="PILSVG",
agent_render_variant=AgentRenderVariant.AGENT_SHOWS_OPTIONS_AND_BOX,
show_debug=True,
clear_debug_text=True,
screen_height=1000,
screen_width=1000)
def render(*argv):
if rendering:
renderer.render_env(show=True, show_observations=False, show_predictions=False)
ControllerFromTrainrunsReplayer.replay_verify(deterministic_controller, env, call_back=render)
tests/test_distance_map.py 0 → 100644
View file @ a6c4ae6a
import numpy as np
from flatland.core.grid.rail_env_grid import RailEnvTransitions
from flatland.core.transition_map import GridTransitionMap
from flatland.envs.observations import TreeObsForRailEnv
from flatland.envs.predictions import ShortestPathPredictorForRailEnv
from flatland.envs.rail_env import RailEnv
from flatland.envs.rail_generators import rail_from_grid_transition_map
from flatland.envs.line_generators import sparse_line_generator
def test_walker():
# _ _ _
transitions = RailEnvTransitions()
cells = transitions.transition_list
dead_end_from_south = cells[7]
dead_end_from_west = transitions.rotate_transition(dead_end_from_south, 90)
dead_end_from_east = transitions.rotate_transition(dead_end_from_south, 270)
vertical_straight = cells[1]
horizontal_straight = transitions.rotate_transition(vertical_straight, 90)
rail_map = np.array(
[[dead_end_from_east] + [horizontal_straight] + [dead_end_from_west]], dtype=np.uint16)
rail = GridTransitionMap(width=rail_map.shape[1],
height=rail_map.shape[0], transitions=transitions)
rail.grid = rail_map
city_positions = [(0,2), (0, 1)]
train_stations = [
[( (0, 1), 0 ) ],
[( (0, 2), 0 ) ],
]
city_orientations = [1, 0]
agents_hints = {'num_agents': 1,
'city_positions': city_positions,
'train_stations': train_stations,
'city_orientations': city_orientations
}
optionals = {'agents_hints': agents_hints}
env = RailEnv(width=rail_map.shape[1],
height=rail_map.shape[0],
rail_generator=rail_from_grid_transition_map(rail, optionals),
line_generator=sparse_line_generator(),
number_of_agents=1,
obs_builder_object=TreeObsForRailEnv(max_depth=2,
predictor=ShortestPathPredictorForRailEnv(max_depth=10)),
)
env.reset()
# set initial position and direction for testing...
env.agents[0].position = (0, 1)
env.agents[0].direction = 1
env.agents[0].target = (0, 0)
# reset to set agents from agents_static
# env.reset(False, False)
env.distance_map._compute(env.agents, env.rail)
print(env.distance_map.get()[(0, *[0, 1], 1)])
assert env.distance_map.get()[(0, *[0, 1], 1)] == 3
print(env.distance_map.get()[(0, *[0, 2], 3)])
assert env.distance_map.get()[(0, *[0, 2], 1)] == 2
tests/test_env_edit.py deleted 100644 → 0
View file @ 9890abf5
from flatland.envs.agent_utils import EnvAgentStatic
from flatland.envs.rail_env import RailEnv
def test_load_env():
env = RailEnv(10, 10)
env.load_resource('env_data.tests', 'test-10x10.mpk')
agent_static = EnvAgentStatic((0, 0), 2, (5, 5), False)
env.add_agent_static(agent_static)
assert env.get_num_agents() == 1
tests/test_env_observation_builder.py deleted 100644 → 0
View file @ 9890abf5
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
from flatland.core.transition_map import GridTransitionMap, Grid4Transitions
from flatland.envs.generators import rail_from_GridTransitionMap_generator
from flatland.envs.observations import GlobalObsForRailEnv
from flatland.envs.rail_env import RailEnv
"""Tests for `flatland` package."""
def test_global_obs():
# We instantiate a very simple rail network on a 7x10 grid:
# |
# |
# |
# _ _ _ /_\ _ _ _ _ _ _
# \ /
# |
# |
# |
cells = [int('0000000000000000', 2), # empty cell - Case 0
int('1000000000100000', 2), # Case 1 - straight
int('1001001000100000', 2), # Case 2 - simple switch
int('1000010000100001', 2), # Case 3 - diamond drossing
int('1001011000100001', 2), # Case 4 - single slip switch
int('1100110000110011', 2), # Case 5 - double slip switch
int('0101001000000010', 2), # Case 6 - symmetrical switch
int('0010000000000000', 2)] # Case 7 - dead end
transitions = Grid4Transitions([])
empty = cells[0]
dead_end_from_south = cells[7]
dead_end_from_west = transitions.rotate_transition(dead_end_from_south, 90)
dead_end_from_north = transitions.rotate_transition(dead_end_from_south, 180)
dead_end_from_east = transitions.rotate_transition(dead_end_from_south, 270)
vertical_straight = cells[1]
horizontal_straight = transitions.rotate_transition(vertical_straight, 90)
double_switch_south_horizontal_straight = horizontal_straight + cells[6]
double_switch_north_horizontal_straight = transitions.rotate_transition(
double_switch_south_horizontal_straight, 180)
rail_map = np.array(
[[empty] * 3 + [dead_end_from_south] + [empty] * 6] +
[[empty] * 3 + [vertical_straight] + [empty] * 6] * 2 +
[[dead_end_from_east] + [horizontal_straight] * 2 +
[double_switch_north_horizontal_straight] +
[horizontal_straight] * 2 + [double_switch_south_horizontal_straight] +
[horizontal_straight] * 2 + [dead_end_from_west]] +
[[empty] * 6 + [vertical_straight] + [empty] * 3] * 2 +
[[empty] * 6 + [dead_end_from_north] + [empty] * 3], dtype=np.uint16)
rail = GridTransitionMap(width=rail_map.shape[1],
height=rail_map.shape[0], transitions=transitions)
rail.grid = rail_map
env = RailEnv(width=rail_map.shape[1],
height=rail_map.shape[0],
rail_generator=rail_from_GridTransitionMap_generator(rail),
number_of_agents=1,
obs_builder_object=GlobalObsForRailEnv())
global_obs = env.reset()
assert (global_obs[0][0].shape == rail_map.shape + (16,))
rail_map_recons = np.zeros_like(rail_map)
for i in range(global_obs[0][0].shape[0]):
for j in range(global_obs[0][0].shape[1]):
rail_map_recons[i, j] = int(
''.join(global_obs[0][0][i, j].astype(int).astype(str)), 2)
assert (rail_map_recons.all() == rail_map.all())
# If this assertion is wrong, it means that the observation returned
# places the agent on an empty cell
assert (np.sum(rail_map * global_obs[0][1][:, :, :4].sum(2)) > 0)
def main():
test_global_obs()
if __name__ == "__main__":
main()
tests/test_env_prediction_builder.py deleted 100644 → 0
View file @ 9890abf5
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
from flatland.core.transition_map import GridTransitionMap, Grid4Transitions
from flatland.envs.generators import rail_from_GridTransitionMap_generator
from flatland.envs.observations import TreeObsForRailEnv
from flatland.envs.predictions import DummyPredictorForRailEnv
from flatland.envs.rail_env import RailEnv
"""Test predictions for `flatland` package."""
def test_predictions():
# We instantiate a very simple rail network on a 7x10 grid:
# |
# |
# |
# _ _ _ /_\ _ _ _ _ _ _
# \ /
# |
# |
# |
cells = [int('0000000000000000', 2), # empty cell - Case 0
int('1000000000100000', 2), # Case 1 - straight
int('1001001000100000', 2), # Case 2 - simple switch
int('1000010000100001', 2), # Case 3 - diamond drossing
int('1001011000100001', 2), # Case 4 - single slip switch
int('1100110000110011', 2), # Case 5 - double slip switch
int('0101001000000010', 2), # Case 6 - symmetrical switch
int('0010000000000000', 2)] # Case 7 - dead end
transitions = Grid4Transitions([])
empty = cells[0]
dead_end_from_south = cells[7]
dead_end_from_west = transitions.rotate_transition(dead_end_from_south, 90)
dead_end_from_north = transitions.rotate_transition(dead_end_from_south, 180)
dead_end_from_east = transitions.rotate_transition(dead_end_from_south, 270)
vertical_straight = cells[1]
horizontal_straight = transitions.rotate_transition(vertical_straight, 90)
double_switch_south_horizontal_straight = horizontal_straight + cells[6]
double_switch_north_horizontal_straight = transitions.rotate_transition(
double_switch_south_horizontal_straight, 180)
rail_map = np.array(
[[empty] * 3 + [dead_end_from_south] + [empty] * 6] +
[[empty] * 3 + [vertical_straight] + [empty] * 6] * 2 +
[[dead_end_from_east] + [horizontal_straight] * 2 +
[double_switch_north_horizontal_straight] +
[horizontal_straight] * 2 + [double_switch_south_horizontal_straight] +
[horizontal_straight] * 2 + [dead_end_from_west]] +
[[empty] * 6 + [vertical_straight] + [empty] * 3] * 2 +
[[empty] * 6 + [dead_end_from_north] + [empty] * 3], dtype=np.uint16)
rail = GridTransitionMap(width=rail_map.shape[1],
height=rail_map.shape[0], transitions=transitions)
rail.grid = rail_map
env = RailEnv(width=rail_map.shape[1],
height=rail_map.shape[0],
rail_generator=rail_from_GridTransitionMap_generator(rail),
number_of_agents=1,
obs_builder_object=TreeObsForRailEnv(max_depth=2, predictor=DummyPredictorForRailEnv(max_depth=10)),
)
env.reset()
# set initial position and direction for testing...
env.agents[0].position = (5, 6)
env.agents[0].direction = 0
env.agents[0].target = (3., 0.)
predictions = env.obs_builder.predictor.get(None)
positions = np.array(list(map(lambda prediction: [prediction[1], prediction[2]], predictions[0])))
directions = np.array(list(map(lambda prediction: [prediction[3]], predictions[0])))
time_offsets = np.array(list(map(lambda prediction: [prediction[0]], predictions[0])))
actions = np.array(list(map(lambda prediction: [prediction[4]], predictions[0])))
# compare against expected values
expected_positions = np.array([[5., 6.],
[4., 6.],
[3., 6.],
[3., 5.],
[3., 4.],
[3., 3.],
[3., 2.],
[3., 1.],
# at target (3,0): stay in this position from here on
[3., 0.],
[3., 0.],
[3., 0.],
])
expected_directions = np.array([[0.],
[0.],
[0.],
[3.],
[3.],
[3.],
[3.],
[3.],
# at target (3,0): stay in this position from here on
[3.],
[3.],
[3.]
])
expected_time_offsets = np.array([[0.],
[1.],
[2.],
[3.],
[4.],
[5.],
[6.],
[7.],
[8.],
[9.],
[10.],
])
expected_actions = np.array([[0.],
[2.],
[2.],
[1.],
[2.],
[2.],
[2.],
[2.],
# reaching target by straight
[2.],
# at target: stopped moving
[4.],
[4.],
])
assert np.array_equal(positions, expected_positions)
assert np.array_equal(directions, expected_directions)
assert np.array_equal(time_offsets, expected_time_offsets)
assert np.array_equal(actions, expected_actions)
def main():
test_predictions()
if __name__ == "__main__":
main()
tests/test_env_step_utils.py 0 → 100644
View file @ a6c4ae6a
import numpy as np
import numpy as np
import os
from flatland.envs.malfunction_generators import malfunction_from_params, MalfunctionParameters, ParamMalfunctionGen
from flatland.envs.observations import GlobalObsForRailEnv
# First of all we import the Flatland rail environment
from flatland.envs.rail_env import RailEnv
from flatland.envs.rail_env import RailEnvActions
from flatland.envs.rail_generators import sparse_rail_generator
#from flatland.envs.sparse_rail_gen import SparseRailGen
from flatland.envs.line_generators import sparse_line_generator
def get_small_two_agent_env():
"""Generates a simple 2 city 2 train env returns it after reset"""
width = 30 # With of map
height = 15 # Height of map
nr_trains = 2 # Number of trains that have an assigned task in the env
cities_in_map = 2 # Number of cities where agents can start or end
seed = 42 # Random seed
grid_distribution_of_cities = False # Type of city distribution, if False cities are randomly placed
max_rails_between_cities = 2 # Max number of tracks allowed between cities. This is number of entry point to a city
max_rail_in_cities = 6 # Max number of parallel tracks within a city, representing a realistic trainstation
rail_generator = sparse_rail_generator(max_num_cities=cities_in_map,
seed=seed,
grid_mode=grid_distribution_of_cities,
max_rails_between_cities=max_rails_between_cities,
max_rail_pairs_in_city=max_rail_in_cities//2,
)
speed_ration_map = {1.: 0.25, # Fast passenger train
1. / 2.: 0.25, # Fast freight train
1. / 3.: 0.25, # Slow commuter train
1. / 4.: 0.25} # Slow freight train
line_generator = sparse_line_generator(speed_ration_map)
stochastic_data = MalfunctionParameters(malfunction_rate=1/10000, # Rate of malfunction occurence
min_duration=15, # Minimal duration of malfunction
max_duration=50 # Max duration of malfunction
)
observation_builder = GlobalObsForRailEnv()
env = RailEnv(width=width,
height=height,
rail_generator=rail_generator,
line_generator=line_generator,
number_of_agents=nr_trains,
obs_builder_object=observation_builder,
#malfunction_generator_and_process_data=malfunction_from_params(stochastic_data),
malfunction_generator=ParamMalfunctionGen(stochastic_data),
remove_agents_at_target=True,
random_seed=seed)
env.reset()
return env
\ No newline at end of file