Kaggle competition: Lyft Motion Prediction for Autonomous Vehicles
<SOS> metric: PostProcessorKernel Kaggle data source: lyft-motion-prediction-autonomous-vehicles<choose_model_class>
warnings.filterwarnings("ignore" )
class LyftModel(tf.keras.Model):
def __init__(self ,num_modes = 3,future_pred_frames = 50 ,):
super(LyftModel , self ).__init__()
self.conv1 = tf.keras.layers.Conv2D(3,kernel_size=1,use_bias=False,padding="same" ,)
 self.bn1 = tf.keras.layers.BatchNormalization()
self.relu = tf.keras.layers.ReLU()
self.model = tf.keras.applications.ResNet50(include_top=False, weights='imagenet',)
 self.gap = tf.keras.layers.GlobalAveragePooling2D()
self.dropout = tf.keras.layers.Dropout(0.2)
 self.future_len = num_modes * future_pred_frames * 2
self.future_pred_frames = future_pred_frames
self.num_modes = num_modes
self.dense1 = tf.keras.layers.Dense(self.future_len + self.num_modes ,)
 def call(self, inputs):
x = self.conv1(inputs)
 x = self.bn1(x)
 x = self.relu(x)
 x = self.model(x)
 x = self.gap(x)
 x = self.dropout(x)
 x = self.dense1(x)
 batch_size, _ = x.shape
pred , confidence = tf.split(x , num_or_size_splits = [self.future_len, self.num_modes], axis = 1)
 assert confidence.shape ==(batch_size , self.num_modes), f'confidence shape got {confidence.shape}'
pred = tf.reshape(pred , shape =(batch_size ,self.num_modes, self.future_pred_frames , 2))
confidence = tf.nn.softmax(confidence , axis = 1)
 return pred , confidence 
<load_pretrained>
l5kit.__version__
def get_model() :
with strategy.scope() :
model = LyftModel()
model.build(( GLOBAL_BATCH_SIZE , None, None, CHANNEL_DIM))
model.summary()
model.load_weights('.. /input/lyft-resnet-model/epoch 45 and val_loss 23.7635 model.h5')
 transf_points = lambda pred , world_from_agent : transform_points(pred, world_from_agent)
 return model , transf_points<train_model>
def set_seed(seed):
random.seed(seed)
 np.random.seed(seed)
 os.environ["PYTHONHASHSEED"] = str(seed)
 torch.manual_seed(seed)
 torch.cuda.manual_seed(seed)
 set_seed(42 )
@tf.function
def test_step(image , world_from_agent):
pred , confidence = model(image , training = False)
 pred = transf_points(pred , world_from_agent)
 return pred , confidence<predict_on_test>
cfg = {
'format_version': 4,
'data_path': "/kaggle/input/lyft-motion-prediction-autonomous-vehicles",
'model_params': {
'model_architecture': 'resnet50',
'history_num_frames': 10,
'history_step_size': 1,
'history_delta_time': 0.1,
'future_num_frames': 50,
'future_step_size': 1,
'future_delta_time': 0.1,
'model_name': "model_resnet50_output",
'lr': 1e-3,
'weight_path': False,
'train': True,
'predict': True
},
'raster_params': {
'raster_size': [224, 224],
'pixel_size': [0.5, 0.5],
'ego_center': [0.25, 0.5],
'map_type': 'py_semantic',
'satellite_map_key': 'aerial_map/aerial_map.png',
'semantic_map_key': 'semantic_map/semantic_map.pb',
'dataset_meta_key': 'meta.json',
'filter_agents_threshold': 0.5
},
'train_data_loader': {
'key': 'scenes/train.zarr',
'batch_size': 16,
'shuffle': True,
'num_workers': 4
},
'test_data_loader': {
'key': 'scenes/test.zarr',
'batch_size': 32,
'shuffle': False,
'num_workers': 4
},
'train_params': {
'max_num_steps': 101,
'checkpoint_every_n_steps': 20,
}
}
def model_predict(test_dataset):
start_time = epoch_start_time = time.time()
future_coord_offset = []
timestamps = []
track_ids = []
confs = []
print(f'predicting {TOTAL_STEPS} steps')
 for step,(images, timestamp, track_id , world_from_agent , target , avail),in enumerate(test_dataset):
pred , confidence = strategy.run(test_step, args=(images, world_from_agent))
global_batch_pred = np.concatenate([pred.values[i].numpy() for i in range(strategy.num_replicas_in_sync)], axis = 0)
 global_batch_confs = np.concatenate([confidence.values[i].numpy() for i in range(strategy.num_replicas_in_sync)], axis = 0)
 global_batch_timestamps = np.concatenate([timestamp.values[i].numpy() for i in range(strategy.num_replicas_in_sync)], axis = 0)
 global_batch_track_ids = np.concatenate([track_id.values[i].numpy() for i in range(strategy.num_replicas_in_sync)], axis = 0)
 future_coord_offset.append(global_batch_pred)
 confs.append(global_batch_confs)
 timestamps.append(global_batch_timestamps)
 track_ids.append(global_batch_track_ids)
 print('=' , end = ' ' , flush = True)
 epoch_time = time.time() - epoch_start_time
print('time: {:0.1f}s'.format(epoch_time))
return future_coord_offset, timestamps , track_ids, confs<predict_on_test>
DIR_INPUT = cfg["data_path"]
os.environ["L5KIT_DATA_FOLDER"] = DIR_INPUT
dm = LocalDataManager(None )
test_dataset = get_dataset(test_files)
 model , transf_points = get_model()
future_coord_offset, timestamps , track_ids , confs = model_predict(test_dataset )<save_to_csv>
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"])
 print("==================================TRAIN DATA==================================")
 print(train_dataset )
pred_path = 'submission.csv'
test_length = len(sub)
 write_pred_csv(pred_path,
timestamps = np.concatenate(timestamps, axis = 0)[0:test_length],
track_ids = np.concatenate(track_ids , axis = 0)[0:test_length],
coords = np.concatenate(future_coord_offset , axis = 0)[0:test_length],
confs = np.concatenate(confs , axis = 0)[0:test_length],
)<import_modules>
test_cfg = cfg["test_data_loader"]
rasterizer = build_rasterizer(cfg, dm)
 test_zarr = ChunkedDataset(dm.require(test_cfg["key"])).open()
test_mask = np.load(f"{DIR_INPUT}/scenes/mask.npz")["arr_0"]
test_dataset = AgentDataset(cfg, test_zarr, rasterizer, agents_mask=test_mask)
 test_dataloader = DataLoader(test_dataset,shuffle=test_cfg["shuffle"],batch_size=test_cfg["batch_size"],
num_workers=test_cfg["num_workers"])
 print("==================================TEST DATA==================================")
 print(test_dataset )
import pandas as pd<import_modules>
class LyftMultiModel(nn.Module):
def __init__(self, cfg: Dict, num_modes=3):
super().__init__()
architecture = cfg["model_params"]["model_architecture"]
backbone = eval(architecture )(pretrained=True, progress=True)
 self.backbone = backbone
num_history_channels =(cfg["model_params"]["history_num_frames"] + 1)* 2
num_in_channels = 3 + num_history_channels
self.backbone.conv1 = nn.Conv2d(
 num_in_channels,
self.backbone.conv1.out_channels,
kernel_size=self.backbone.conv1.kernel_size,
stride=self.backbone.conv1.stride,
padding=self.backbone.conv1.padding,
bias=False, 
)
 if architecture == "resnet50":
backbone_out_features = 2048
else:
backbone_out_features = 512
self.future_len = cfg["model_params"]["future_num_frames"]
num_targets = 2 * self.future_len
self.head = nn.Sequential(
 nn.Linear(in_features=backbone_out_features, out_features=4096), 
)
 self.num_preds = num_targets * num_modes
self.num_modes = num_modes
self.logit = nn.Linear(4096, out_features=self.num_preds + num_modes)
 def forward(self, x):
x = self.backbone.conv1(x)
 x = self.backbone.bn1(x)
 x = self.backbone.relu(x)
 x = self.backbone.maxpool(x)
 x = self.backbone.layer1(x)
 x = self.backbone.layer2(x)
 x = self.backbone.layer3(x)
 x = self.backbone.layer4(x)
 x = self.backbone.avgpool(x)
 x = torch.flatten(x, 1)
 x = self.head(x)
 x = self.logit(x)
 bs, _ = x.shape
pred, confidences = torch.split(x, self.num_preds, dim=1)
 pred = pred.view(bs, self.num_modes, self.future_len, 2)
 assert confidences.shape ==(bs, self.num_modes)
 confidences = torch.softmax(confidences, dim=1)
 return pred, confidences
import pandas as pd<save_to_csv>
def forward(data, model, device, criterion = pytorch_neg_multi_log_likelihood_batch):
inputs = data["image"].to(device)
 target_availabilities = data["target_availabilities"].to(device)
 targets = data["target_positions"].to(device)
 preds, confidences = model(inputs)
 loss = criterion(targets, preds, confidences, target_availabilities)
 return loss, preds, confidences
sub = pd.read_csv(".. /input/lyft-complete-train-and-prediction-pipeline/submission.csv")
 sub = sub.sample(frac=1.0 ).reset_index(drop=True)
 sub.to_csv("submission.csv", index=False, float_format='%.6g' )<install_modules>
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 model = LyftMultiModel(cfg)
 weight_path = cfg["model_params"]["weight_path"]
if weight_path:
model.load_state_dict(torch.load(weight_path))
model.to(device)
 optimizer = optim.Adam(model.parameters() , lr=cfg["model_params"]["lr"])
 print(f'device {device}' )
!pip install -U torch==1.7.0<import_modules>
print(model )
warnings.filterwarnings("ignore")
 print(l5kit.__version__ )<set_options>
if cfg["model_params"]["train"]:
tr_it = iter(train_dataloader)
 progress_bar = tqdm(range(cfg["train_params"]["max_num_steps"]))
num_iter = cfg["train_params"]["max_num_steps"]
losses_train = []
iterations = []
metrics = []
times = []
model_name = cfg["model_params"]["model_name"]
start = time.time()
for i in progress_bar:
try:
data = next(tr_it)
 except StopIteration:
tr_it = iter(train_dataloader)
 data = next(tr_it)
 model.train()
torch.set_grad_enabled(True)
 loss, _, _ = forward(data, model, device)
 optimizer.zero_grad()
loss.backward()
optimizer.step()
losses_train.append(loss.item())
 progress_bar.set_description(f"loss: {loss.item() } loss(avg): {np.mean(losses_train)}")
 if i % cfg['train_params']['checkpoint_every_n_steps'] == 0:
torch.save(model.state_dict() , f'{model_name}_{i}.pth')
 iterations.append(i)
 metrics.append(np.mean(losses_train))
times.append(( time.time() -start)/60)
 results = pd.DataFrame({'iterations': iterations, 'metrics(avg)': metrics, 'elapsed_time(mins)': times})
 results.to_csv(f"train_metrics_{model_name}_{num_iter}.csv", index = False)
 print(f"Total training time is {(time.time() -start)/60} mins")
 print(results.head() )
<set_options><EOS> 
pred_path = 'submission.csv'
write_pred_csv(pred_path,
timestamps=np.concatenate(timestamps),
track_ids=np.concatenate(agent_ids),
coords=np.concatenate(future_coords_offsets_pd),
confs = np.concatenate(confidences_list)
 )