def test_graph_rasterizer_no_error():
# contain traffic light
index = 150
cfg = load_config_data(config_file)
cfg["raster_params"]["map_type"] = "semantic_graph"
data_loader_conf = cfg.get(f"val_data_loader")
dm = LocalDataManager()
dataset_path = dm.require(data_loader_conf.get("key"))
zarr_dataset = ChunkedDataset(dataset_path)
zarr_dataset.open()
rasterizer = build_rasterizer(cfg=cfg, data_manager=dm)
dataset = AgentGraphDataset(cfg=cfg,
zarr_dataset=zarr_dataset,
rasterizer=rasterizer)
data_point = dataset[index]
assert "graph" in data_point
assert "lanes" in data_point["graph"]
assert isinstance(data_point["graph"]["lanes"], List)
print()
print(data_point.keys())
element_types = SemGraphRasterizer.keys
for e in element_types:
print(f"---- {e} ----")
if len(data_point["graph"][e]) > 0:
print(data_point["graph"][e][0])
def cfg() -> dict:
"""Get a config file from artefacts.
Note: the scope of this fixture is "function"-> one per test function
:return: the config python dict
"""
return load_config_data("./l5kit/tests/artefacts/config.yaml")
def __init__(self,
data_root: str,
config_path: str,
split: str,
show_progress=True,
turn_thresh=3.,
speed_thresh=0.5,
static_thresh=1.,
output_folder='preprocess',
autosave=True,
cache_size=1e9):
self.autosave = autosave
self.show_progress = show_progress
self.turn_thresh = turn_thresh
self.speed_thresh = speed_thresh
self.static_thresh = static_thresh
self.split = split
self.config = load_config_data(config_path)
self.output_folder = output_folder
self.data_manager = LocalDataManager(data_root)
self.rasterizer = build_rasterizer(self.config, self.data_manager)
self.data_zarr = ChunkedDataset(self.data_manager.require(split)).open(
cache_size_bytes=int(cache_size))
self.dataset = AgentDataset(self.config, self.data_zarr,
self.rasterizer)
self.data = defaultdict(list)
self.junk = defaultdict(list)
self.progress = None
def test_rasterizer_created_from_config(map_type: str,
dataset: ChunkedStateDataset) -> None:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
cfg["raster_params"]["map_type"] = map_type
dm = LocalDataManager("./l5kit/tests/artefacts/")
rasterizer = build_rasterizer(cfg, dm)
check_rasterizer(cfg, rasterizer, dataset)
def test_build_dataloader(scene_indices: tuple, dataset_cls: Callable) -> None:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
cfg["train_data_loader"]["datasets"][0]["scene_indices"] = scene_indices
dm = LocalDataManager("./l5kit/tests/artefacts/")
rasterizer = build_rasterizer(cfg, dm)
dl = build_dataloader(cfg, "train", dm, dataset_cls, rasterizer)
next(iter(dl))
def test_rasterizer_created_from_config(map_type: str,
dataset: ChunkedStateDataset) -> None:
cfg = load_config_data("./l5kit/configs/default.yaml")
cfg["raster_params"]["map_type"] = map_type
with tempfile.TemporaryDirectory("", "rasterizer-test") as tmpdir:
setup_rasterizer_artifacts_and_config(tmpdir, cfg)
dm = LocalDataManager(tmpdir)
rasterizer = build_rasterizer(cfg, dm)
check_rasterizer(cfg, rasterizer, dataset)
def test_ego_layer_out_center_configs(ego_center: tuple,
hist_data: tuple) -> None:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
cfg["raster_params"]["map_type"] = "box_debug"
cfg["raster_params"]["ego_center"] = np.asarray(ego_center)
dm = LocalDataManager("./l5kit/tests/artefacts/")
rasterizer = build_rasterizer(cfg, dm)
out = rasterizer.rasterize(hist_data[0][:1], hist_data[1][:1])
assert out[..., -1].sum() > 0
def test_scene_index_interval(dataset_cls: Callable, scene_idx: int,
zarr_dataset: ChunkedStateDataset) -> None:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
rasterizer = StubRasterizer((100, 100), np.asarray((0.25, 0.25)),
np.asarray((0.5, 0.5)), 0)
dataset = dataset_cls(cfg, zarr_dataset, rasterizer, None)
indices = dataset.get_scene_indices(scene_idx)
subdata = Subset(dataset, indices)
for _ in subdata: # type: ignore
pass
def test_dataset_rasterizer(rast_name: str, dataset_cls: Callable,
zarr_dataset: ChunkedStateDataset) -> None:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
dm = LocalDataManager("./l5kit/tests/artefacts/")
rasterizer = build_rasterizer(cfg, dm)
dataset = dataset_cls(cfg=cfg,
zarr_dataset=zarr_dataset,
rasterizer=rasterizer,
perturbation=None)
check_sample(cfg, dataset)
check_torch_loading(dataset)
def test_agent_as_ego(hist_data: tuple) -> None:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
cfg["raster_params"]["map_type"] = "box_debug"
cfg["raster_params"]["filter_agents_threshold"] = -1 # take everything
dm = LocalDataManager("./l5kit/tests/artefacts/")
rasterizer = build_rasterizer(cfg, dm)
agents = hist_data[1][0]
for ag in agents:
out = rasterizer.rasterize(hist_data[0][:1], hist_data[1][:1], ag)
assert out[..., -1].sum() > 0
def test_scene_index_interval(dataset_cls: Callable, scene_idx: int,
zarr_dataset: ChunkedStateDataset) -> None:
cfg = load_config_data("./l5kit/configs/default.yaml")
# replace th for agents for AgentDataset test
cfg["raster_params"]["filter_agents_threshold"] = 0.5
rasterizer = StubRasterizer((100, 100), np.asarray((0.25, 0.25)),
np.asarray((0.5, 0.5)), 0)
dataset = dataset_cls(cfg, zarr_dataset, rasterizer, None)
indices = dataset.get_scene_indices(scene_idx)
subdata = Subset(dataset, indices)
for _ in subdata: # type: ignore
pass
def test_dataset_rasterizer(rast_name: str, dataset_cls: Callable,
zarr_dataset: ChunkedStateDataset) -> None:
cfg = load_config_data("./l5kit/configs/default.yaml")
# replace th for agents for AgentDataset test
cfg["raster_params"]["filter_agents_threshold"] = 0.5
rasterizer = get_rasterizer(rast_name, cfg)
dataset = dataset_cls(cfg=cfg,
zarr_dataset=zarr_dataset,
rasterizer=rasterizer,
perturbation=None)
check_sample(cfg, dataset)
check_torch_loading(dataset)
def test_out_shape(hist_data: tuple) -> None:
hist_length = 5
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
cfg["raster_params"]["map_type"] = "box_debug"
cfg["model_params"]["history_num_frames"] = hist_length
dm = LocalDataManager("./l5kit/tests/artefacts/")
rasterizer = build_rasterizer(cfg, dm)
out = rasterizer.rasterize(hist_data[0][:hist_length + 1],
hist_data[1][:hist_length + 1])
assert out.shape == (224, 224, (hist_length + 1) * 2)
def train():
os.environ["L5KIT_DATA_FOLDER"] = "../"
dm = LocalDataManager(None)
cfg = load_config_data("../agent_motion_config.yaml")
train_cfg = cfg['train_data_loader']
rasterizer = build_rasterizer(cfg, dm)
train_zarr = ChunkedDataset(dm.require(train_cfg['key'])).open()
train_dataset = AgentDataset(cfg, train_zarr, rasterizer)
train_dataloader = DataLoader(train_dataset,
shuffle=train_cfg['shuffle'],
batch_size=train_cfg['batch_size'],
num_workers=train_cfg['num_workers'])
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SusNetv2(cfg['history_num_frames'], cfg['future_num_frames'])
optimizer = optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.MSELoss(reduction='none')
train_it = iter(train_dataloader)
losses = []
progress_bar = tqdm(range(cfg['train_params']['max_num_steps']))
for step in progress_bar:
try:
data = next(train_it)
except StopIteration:
train_it = iter(train_dataloader)
data = next(train_it)
model.train()
torch.set_grad_enabled(True)
inputs = data['image'].to(device)
target_availabilities = data['target_availabilities'].unsqueeze(-1).to(
device)
targets = data['target_positions'].to(device)
outputs = model(inputs).reshape(targets.shape)
loss = criterion(outputs, targets)
loss = loss * target_availabilities
loss = loss.mean()
optimizer.zero_grad()
loss.backward()
optimizer.step()
losses.append(loss.item())
progress_bar.set_description(
f'Loss: {loss.item()}, loss(avg): {np.mean(losses_train)}')
plt.plot(np.arange(len(losses)), losses, label='Train loss')
plt.legend()
plt.show()
torch.save(model.state_dict(), 'lyft_model.pth')
def test_build_dataloader(scene_indices: tuple, dataset_cls: Callable) -> None:
cfg = load_config_data("./l5kit/configs/default.yaml")
# replace in cfg to point to the test dataset and seqs
cfg["train_data_loader"]["datasets"] = [{
"key": "./l5kit/tests/data/single_scene.zarr",
"scene_indices": scene_indices
}]
cfg["train_data_loader"]["num_workers"] = 0
# replace th for agents for AgentDataset test
cfg["raster_params"]["filter_agents_threshold"] = 0.5
dl = build_dataloader(cfg, "train", LocalDataManager("."), dataset_cls,
get_rasterizer("box", cfg), None)
next(iter(dl))
def __init__(self, data_path, config_path):
super().__init__()
self.data_path = data_path
self.config_path = config_path
os.environ["L5KIT_DATA_FOLDER"] = data_path
self.dm = LocalDataManager(None)
self.cfg = load_config_data(config_path)
self.train_cfg = self.cfg["train_data_loader"]
self.val_cfg = self.cfg["val_data_loader"]
self.rasterizer = build_rasterizer(self.cfg, self.dm)
def __init__(self, config=None, num_modes=1, checkpoint_path=None):
super().__init__()
if config is None:
# Load in the config
self.cfg = load_config_data("./models/resnet152/config.yaml")
else:
self.cfg = config
model = resnet152(pretrained=True)
# change input channels number to match the rasterizer's output
num_history_channels = (
self.cfg["model_params"]["history_num_frames"] + 1) * 2
num_in_channels = 3 + num_history_channels
object_methods = [
method_name for method_name in dir(model.conv1)
if callable(getattr(model.conv1, method_name))
]
print(num_in_channels)
print(model.conv1.out_channels)
print(model.conv1.kernel_size)
print(model.conv1.stride)
print(model.conv1.padding)
model.conv1 = nn.Conv2d(
in_channels=num_in_channels,
out_channels=model.conv1.out_channels,
kernel_size=model.conv1.kernel_size,
stride=model.conv1.stride,
padding=model.conv1.padding,
bias=False,
)
self.head = nn.Sequential(
# nn.Dropout(0.2),
nn.Linear(in_features=2048, out_features=4096), )
# change output size to (X, Y) * number of future states
num_targets = 2 * self.cfg["model_params"]["future_num_frames"]
self.future_len = self.cfg["model_params"]["future_num_frames"]
self.num_targets = num_targets
self.num_preds = num_targets * num_modes
self.num_modes = num_modes
model.fc = nn.Linear(in_features=2048,
out_features=self.num_preds + num_modes)
self.model = model
def __init__(self):
print("Visualization Class initialized.")
# get config
self.cfg = load_config_data("/mnt/extra/kaggle/competitions/2020lyft/ProjectLyft/Modules/visualisation_config.yaml")
print(self.cfg)
dm = LocalDataManager()
self.dataset_path = dm.require(self.cfg["val_data_loader"]["key"])
self.zarr_dataset = ChunkedDataset(self.dataset_path)
self.zarr_dataset.open()
# Dataset package
self.rast = build_rasterizer(self.cfg, dm)
self.dataset = EgoDataset(self.cfg, self.zarr_dataset, self.rast)
def test_shape(dataset: ChunkedStateDataset) -> None:
hist_length = 10
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
cfg["raster_params"]["map_type"] = "py_satellite"
cfg["raster_params"]["filter_agents_threshold"] = 1.0
cfg["model_params"]["history_num_frames"] = hist_length
dm = LocalDataManager("./l5kit/tests/artefacts/")
rasterizer = build_rasterizer(cfg, dm)
frames = dataset.frames[:hist_length + 1][::-1]
agents = filter_agents_by_frames(frames, dataset.agents)
out = rasterizer.rasterize(frames, agents)
assert out.shape == (224, 224, (hist_length + 1) * 2 + 3)
def test_agents_layer_out(hist_data: tuple) -> None:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
cfg["raster_params"]["map_type"] = "box_debug"
cfg["raster_params"]["filter_agents_threshold"] = 1.0
dm = LocalDataManager("./l5kit/tests/artefacts/")
rasterizer = build_rasterizer(cfg, dm)
out = rasterizer.rasterize(hist_data[0][:1], hist_data[1][:1])
assert out[..., 0].sum() == 0
cfg["raster_params"]["filter_agents_threshold"] = 0.0
rasterizer = build_rasterizer(cfg, dm)
out = rasterizer.rasterize(hist_data[0][:1], hist_data[1][:1])
assert out[..., 0].sum() > 0
def test_env_reset(dmg: LocalDataManager, env_cfg_path: str) -> None:
env = L5Env(env_cfg_path, dmg)
# env config
cfg = load_config_data(env_cfg_path)
# rasterisation
rasterizer = build_rasterizer(cfg, dmg)
raster_size = cfg["raster_params"]["raster_size"][0]
n_channels = rasterizer.num_channels()
# check first observation
obs = env.reset()
assert isinstance(obs, dict)
assert len(obs) == 1
assert 'image' in obs.keys()
assert obs['image'].shape == (n_channels, raster_size, raster_size)
def test_non_zero_history(history_num_frames: int, dataset_cls: Callable,
zarr_dataset: ChunkedStateDataset) -> None:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
cfg["model_params"]["history_num_frames"] = history_num_frames
rast_params = cfg["raster_params"]
rast_params["map_type"] = "box_debug"
dm = LocalDataManager("./l5kit/tests/artefacts/")
rasterizer = build_rasterizer(cfg, dm)
dataset = dataset_cls(cfg, zarr_dataset, rasterizer, None)
indexes = [
0, 1, 10, -1
] # because we pad, even the first index should have an (entire black) history
for idx in indexes:
data = dataset[idx]
assert data["image"].shape == (2 * (history_num_frames + 1),
*rast_params["raster_size"])
def base_displacement(zarr_dataset: ChunkedStateDataset) -> np.ndarray:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
cfg["raster_params"]["raster_size"] = (100, 100)
cfg["raster_params"]["ego_center"] = np.asarray((0.5, 0.5))
cfg["raster_params"]["pixel_size"] = np.asarray((0.25, 0.25))
dataset = EgoDataset(
cfg,
zarr_dataset,
StubRasterizer(
cfg["raster_params"]["raster_size"],
cfg["raster_params"]["pixel_size"],
cfg["raster_params"]["ego_center"],
0.5,
),
)
data = dataset[0]
return data["target_positions"]
def test_perturbation_is_applied(perturb_prob: float) -> None:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
zarr_dataset = ChunkedDataset(path="./l5kit/tests/artefacts/single_scene.zarr")
zarr_dataset.open()
dm = LocalDataManager("./l5kit/tests/artefacts/")
rasterizer = build_rasterizer(cfg, dm)
dataset = EgoDataset(cfg, zarr_dataset, rasterizer, None) # no perturb
data_no_perturb = dataset[0]
# note we cannot change the object we already have as a partial is built at init time
perturb = AckermanPerturbation(ReplayRandomGenerator(np.asarray([[4.0, 0.33]])), perturb_prob=perturb_prob)
dataset = EgoDataset(cfg, zarr_dataset, rasterizer, perturb) # perturb
data_perturb = dataset[0]
assert np.linalg.norm(data_no_perturb["target_positions"] - data_perturb["target_positions"]) > 0
assert np.linalg.norm(data_no_perturb["target_yaws"] - data_perturb["target_yaws"]) > 0
def loadDataset(TYPE):
# Load config file
cfg = load_config_data("../cfg/agent_motion_config.yaml")
print("Configuration for {} : \n".format(TYPE))
for key,val in cfg.items():
print(key,val )
'''
set env variable for data (PATH to the main DATASET folder)
../lyft-motion-prediction-autonomous-vehicles/
+-arial_map
--scenes
--sample.zarr
--test.zarr
--train.zarr
--validate.zarr
+-semantic_map
--meta.json
'''
os.environ["L5KIT_DATA_FOLDER"] = "/media/kartik/62A60BCB35EBD08A/lyft-motion-prediction-autonomous-vehicles"
dm = LocalDataManager(None)
'''
Load the dataset for training and validation.
For training:
TYPE: "train_data_loader"
For validation:
TYPE: "val_data_loader"
'''
dt_cfg = cfg[TYPE]
rasterizer = build_rasterizer(cfg, dm)
dt_zarr = ChunkedDataset(dm.require(dt_cfg["key"])).open()
dt_dataset = AgentDataset(cfg, dt_zarr, rasterizer)
dt_dataloader = DataLoader(dt_dataset, shuffle=dt_cfg["shuffle"],
batch_size=dt_cfg["batch_size"],
num_workers=dt_cfg["num_workers"])
return dt_zarr, dt_dataset, dt_dataloader
def test_non_zero_history(history_num_frames: int, dataset_cls: Callable,
zarr_dataset: ChunkedStateDataset) -> None:
cfg = load_config_data("./l5kit/configs/default.yaml")
cfg["model_params"]["history_num_frames"] = history_num_frames
rast_params = cfg["raster_params"]
rast_params["filter_agents_threshold"] = 0.5
rasterizer = BoxRasterizer(
rast_params["raster_size"],
np.asarray(rast_params["pixel_size"]),
np.asarray(rast_params["ego_center"]),
rast_params["filter_agents_threshold"],
history_num_frames=history_num_frames,
)
dataset = dataset_cls(cfg, zarr_dataset, rasterizer, None)
indexes = [
0, 1, 10, -1
] # because we pad, even the first index should have an (entire black) history
for idx in indexes:
data = dataset[idx]
assert data["image"].shape == (2 * (history_num_frames + 1),
*rast_params["raster_size"])
def __init__(self,
data_dir: str,
config_file: str,
split: str = "val",
transform=None,
pre_transform=None):
self.split = split
self.cfg = load_config_data(config_file)
dm = LocalDataManager()
data_loader_conf = self.cfg.get(f"{self.split}_data_loader")
dataset_path = dm.require(data_loader_conf.get("key"))
print("dataset path", dataset_path)
zarr_dataset = ChunkedDataset(dataset_path)
zarr_dataset.open()
rasterizer = build_rasterizer(cfg=self.cfg, data_manager=dm)
self.dataset = AgentGraphDataset(cfg=self.cfg,
zarr_dataset=zarr_dataset,
rasterizer=rasterizer)
self.graph_builder = SceneGraphBuilder(raster_size=self.cfg["raster_params"]["raster_size"])
super(LyftGraphDataset, self).__init__(data_dir, transform, pre_transform)
def test_same_displacement(
zarr_dataset: ChunkedStateDataset,
base_displacement: np.ndarray,
raster_size: tuple,
ego_center: tuple,
pixel_size: tuple,
) -> None:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
cfg["raster_params"]["raster_size"] = raster_size
cfg["raster_params"]["ego_center"] = np.asarray(ego_center)
cfg["raster_params"]["pixel_size"] = np.asarray(pixel_size)
dataset = EgoDataset(
cfg,
zarr_dataset,
StubRasterizer(
cfg["raster_params"]["raster_size"],
cfg["raster_params"]["pixel_size"],
cfg["raster_params"]["ego_center"],
0.5,
),
)
data = dataset[0]
assert np.allclose(data["target_positions"], base_displacement)
def cfg() -> dict:
cfg = load_config_data("./l5kit/tests/artefacts/config.yaml")
return cfg
# import plotly.figure_factory as ff
# import plotly.io as pio
# pio.templates.default = "plotly_dark"
# # --- models ---
# from sklearn import preprocessing
# from sklearn.model_selection import KFold
# import lightgbm as lgb
# import xgboost as xgb
# import catboost as cb
# pd.set_option('max_columns', 50)
os.environ["L5KIT_DATA_FOLDER"] = "data"
cfg = load_config_data("examples/visualisation/visualisation_config.yaml")
print(cfg)
# Loading sample data for EDA
# set env variable for data
dm = LocalDataManager()
dataset_path = dm.require('scenes/sample.zarr')
zarr_dataset = ChunkedDataset(dataset_path)
zarr_dataset.open()
print(zarr_dataset)
cfg2 = omegaconf.DictConfig(cfg2)
frames = zarr_dataset.frames
agents = zarr_dataset.agents
