diff --git a/.gitignore b/.gitignore
index 875766b1..3c74cb3d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,6 +25,7 @@ share/python-wheels/
 .installed.cfg
 *.egg
 MANIFEST
+*.pyc
 
 # PyInstaller
 #  Usually these files are written by a python script from a template
diff --git a/src/av2/evaluation/detection/eval.py b/src/av2/evaluation/detection/eval.py
index 2a8357a1..5bd4221c 100644
--- a/src/av2/evaluation/detection/eval.py
+++ b/src/av2/evaluation/detection/eval.py
@@ -58,6 +58,7 @@
 
 import numpy as np
 import pandas as pd
+from tqdm import tqdm
 from av2.evaluation.detection.constants import (
     HIERARCHY,
     LCA,
@@ -442,14 +443,14 @@ def evaluate_hierarchy(
         gts_categories_list.append(sweep_gts_categories)
 
         num_dts = len(sweep_dts)
-        num_gts = len(sweep_dts)
+        num_gts = len(sweep_gts)
         dts_uuids_list.extend(num_dts * [uuid])
         gts_uuids_list.extend(num_gts * [uuid])
 
-    dts_npy = np.concatenate(dts).astype(np.float64)
-    gts_npy = np.concatenate(gts).astype(np.float64)
-    dts_categories_npy = np.concatenate(dts_categories).astype(np.object_)
-    gts_categories_npy = np.concatenate(gts_categories).astype(np.object_)
+    dts_npy = np.concatenate(dts_list).astype(np.float64)
+    gts_npy = np.concatenate(gts_list).astype(np.float64)
+    dts_categories_npy = np.concatenate(dts_categories_list).astype(np.object_)
+    gts_categories_npy = np.concatenate(gts_categories_list).astype(np.object_)
     dts_uuids_npy = np.array(dts_uuids_list)
     gts_uuids_npy = np.array(gts_uuids_list)
 
@@ -487,8 +488,9 @@ def evaluate_hierarchy(
             )
 
     logger.info("Starting evaluation ...")
-    with mp.get_context("spawn").Pool(processes=n_jobs) as p:
-        accumulate_outputs: Any = p.starmap(accumulate_hierarchy, accumulate_hierarchy_args_list)
+    accumulate_outputs = []
+    for accumulate_args in tqdm(accumulate_hierarchy_args_list):
+        accumulate_outputs.append(accumulate_hierarchy(*accumulate_args))
 
     super_categories = list(HIERARCHY.keys())
     metrics = np.zeros((len(cfg.categories), len(HIERARCHY.keys())))
diff --git a/src/av2/evaluation/detection/utils.py b/src/av2/evaluation/detection/utils.py
index 5922e603..f6e6a136 100644
--- a/src/av2/evaluation/detection/utils.py
+++ b/src/av2/evaluation/detection/utils.py
@@ -279,7 +279,7 @@ def accumulate_hierarchy(
     fp: Dict[int, Any] = {}
     gt_name: Dict[int, List[Any]] = {}
     pred_name: Dict[int, List[Any]] = {}
-    taken: Dict[int, Set[Tuple[Any, Any]]] = {}
+    taken: Dict[int, Set[Tuple[Any, Any, Any]]] = {}
     for i in range(len(cfg.affinity_thresholds_m)):
         tp[i] = []
         fp[i] = []
@@ -292,7 +292,11 @@ def accumulate_hierarchy(
         min_dist = len(cfg.affinity_thresholds_m) * [np.inf]
         match_gt_idx = len(cfg.affinity_thresholds_m) * [None]
 
-        keep_sweep = gts_uuids == np.array([gts.shape[0] * [pred_uuid]]).squeeze()
+        if len(gts_uuids) > 0:
+            keep_sweep = np.all(gts_uuids == np.array([gts.shape[0] * [pred_uuid]]).squeeze(), axis=1)
+        else:
+            keep_sweep = []
+
         gt_ind_sweep = np.arange(gts.shape[0])[keep_sweep]
         gts_sweep = gts[keep_sweep]
         gts_cats_sweep = gts_cats[keep_sweep]
@@ -303,7 +307,7 @@ def accumulate_hierarchy(
 
             # Find closest match among ground truth boxes
             for i in range(len(cfg.affinity_thresholds_m)):
-                if gt_cat == cat and not (pred_uuid, gt_idx) in taken[i]:
+                if gt_cat == cat and not (pred_uuid[0], pred_uuid[1], gt_idx) in taken[i]:
                     this_distance = dist_mat[pred_idx][gt_idx]
                     if this_distance < min_dist[i]:
                         min_dist[i] = this_distance
@@ -316,7 +320,7 @@ def accumulate_hierarchy(
             # Find closest match among ground truth boxes
 
             for i in range(len(cfg.affinity_thresholds_m)):
-                if not is_match[i] and not (pred_uuid, gt_idx) in taken[i]:
+                if not is_match[i] and not (pred_uuid[0], pred_uuid[1], gt_idx) in taken[i]:
                     this_distance = dist_mat[pred_idx][gt_idx]
                     if this_distance < min_dist[i]:
                         min_dist[i] = this_distance
@@ -330,7 +334,7 @@ def accumulate_hierarchy(
 
         for i in range(len(cfg.affinity_thresholds_m)):
             if is_match[i]:
-                taken[i].add((pred_uuid, gt_idx))
+                taken[i].add((pred_uuid[0], pred_uuid[1], gt_idx))
                 tp[i].append(1)
                 fp[i].append(0)
 
diff --git a/src/av2/evaluation/forecasting/SUBMISSION_FORMAT.md b/src/av2/evaluation/forecasting/SUBMISSION_FORMAT.md
deleted file mode 100644
index e4c56d27..00000000
--- a/src/av2/evaluation/forecasting/SUBMISSION_FORMAT.md
+++ /dev/null
@@ -1,94 +0,0 @@
-# Forecasting Submission Format
-
-The evaluation expects a dictionary of dictionaries of lists of dictionaries
-
-```python
-{
-  <log_id>: {
-    <timestamp_ns>: [
-      {
-         "prediction": <prediction>
-         "score": <score>
-         "detection_score": <detection_score>,
-         "instance_id": <instance_id>
-         "current_translation": <current_translation>,
-         "label": <label>,
-         "name": <name>,
-         "size": <size>,
-         "yaw" : <yaw>
-      }, ...
-    ], ...
-  }, ...
-}
-```
-
-- `log_id`: Log id associated with the forecast, also called `seq_id`.
-- `timestamp_ns`: Timestamp associated with the detections.
-- `prediction`: K translation forecasts 3 seconds into the future.
-- `score`: Forecast confidence.
-- `detection_score`: Detection confidence.
-- `instance_id`: Unique id assigned to each object.
-- `current_translation`: xyz-components of the object translation in the city reference frame at the current timestamp, in meters.
-- `label`: Integer index of the object class.
-- `name`: Object class name.
-- `size`: Object extent along the x,y,z axes in meters.
-- `yaw` : Object rotation in radians
-
-An example looks like this:
-
-```python
-# These forecasts are only for example purposes.
-
-print(forecasts)
-{
-  '02678d04-cc9f-3148-9f95-1ba66347dff9': {
-    315969904359876000: [
-      {'timestep_ns': 315969905359854000,
-      'current_translation': array([6759.4230302 , 1596.38016309]),
-      'detection_score': 0.54183,
-      'size': array([4.4779487, 1.7388916, 1.6963532], dtype=float32),
-      'yaw' : 0.832,
-      'label': 0,
-      'name': 'REGULAR_VEHICLE',
-      'prediction': array([[[6759.4230302 , 1596.38016309],
-              [6759.42134062, 1596.38361481],
-              [6759.41965104, 1596.38706653],
-              [6759.41796145, 1596.39051825],
-              [6759.41627187, 1596.39396997],
-              [6759.41458229, 1596.39742169]],
- 
-              [[6759.4230302 , 1596.38016309],
-              [6759.4210027 , 1596.38430516],
-              [6759.4189752 , 1596.38844722],
-              [6759.4169477 , 1596.39258928],
-              [6759.4149202 , 1596.39673134],
-              [6759.41289271, 1596.40087341]],
- 
-              [[6759.4230302 , 1596.38016309],
-              [6759.42066479, 1596.3849955 ],
-              [6759.41829937, 1596.38982791],
-              [6759.41593395, 1596.39466031],
-              [6759.41356854, 1596.39949272],
-      ...
-              [6759.41998895, 1596.38637619],
-              [6759.4189752 , 1596.38844722],
-              [6759.41796145, 1596.39051825]]]),
-      'score': [0.54183, 0.54183, 0.54183, 0.54183, 0.54183],
-      'instance_id': 0},
-      ...
-    ]
-    ...
-  }
-}
-```
-
-We need to export the above dictionary for submission. This can be done by:
-
-```python
-import pickle
-
-with open("forecast_predictions.pkl", "wb") as f:
-       pickle.dump(forecasts, f)
-```
-
-Lastly, submit this file to the competition leaderboard.
diff --git a/src/av2/evaluation/forecasting/eval.py b/src/av2/evaluation/forecasting/eval.py
index db8901fd..aee25928 100644
--- a/src/av2/evaluation/forecasting/eval.py
+++ b/src/av2/evaluation/forecasting/eval.py
@@ -52,7 +52,7 @@ def evaluate(
     ground_truth: ForecastSequences = convert_forecast_labels(raw_ground_truth)
     ground_truth = filter_max_dist(ground_truth, max_range_m)
 
-    utils.annotate_frame_metadata(predictions, ground_truth, ["ego_translation"])
+    utils.annotate_frame_metadata(predictions, ground_truth, ["ego_translation_m"])
     predictions = filter_max_dist(predictions, max_range_m)
 
     if dataset_dir is not None:
@@ -77,20 +77,20 @@ def evaluate(
                 pred = []
 
             for agent in gt:
-                if agent["future_translation"].shape[0] < 1:
+                if agent["future_translation_m"].shape[0] < 1:
                     continue
 
                 agent["seq_id"] = seq_id
-                agent["timestamp"] = timestamp_ns
-                agent["velocity"] = utils.agent_velocity(agent)
+                agent["timestamp_ns"] = timestamp_ns
+                agent["velocity_m_per_s"] = utils.agent_velocity_m_per_s(agent)
                 agent["trajectory_type"] = utils.trajectory_type(agent, CATEGORY_TO_VELOCITY_M_PER_S)
 
                 gt_agents.append(agent)
 
             for agent in pred:
                 agent["seq_id"] = seq_id
-                agent["timestamp"] = timestamp_ns
-                agent["velocity"] = utils.agent_velocity(agent)
+                agent["timestamp_ns"] = timestamp_ns
+                agent["velocity_m_per_s"] = utils.agent_velocity_m_per_s(agent)
                 agent["trajectory_type"] = utils.trajectory_type(agent, CATEGORY_TO_VELOCITY_M_PER_S)
 
                 pred_agents.append(agent)
@@ -138,8 +138,8 @@ def accumulate(
     """Perform matching between predicted and ground truth trajectories.
 
     Args:
-        pred_agents: List of predicted trajectories for a given log_id and timestamp.
-        gt_agents: List of ground truth trajectories for a given log_id and timestamp.
+        pred_agents: List of predicted trajectories for a given log_id and timestamp_ns.
+        gt_agents: List of ground truth trajectories for a given log_id and timestamp_ns.
         top_k: Number of future trajectories to consider when evaluating Forecastin AP, ADE and FDE (K=5 by default).
         class_name: Match class name (e.g. car, pedestrian, bicycle) to determine if a trajectory is included
             in evaluation.
@@ -165,7 +165,7 @@ def match(gt: str, pred: str, profile: str) -> bool:
     sortind = [i for (v, i) in sorted((v, i) for (i, v) in enumerate(conf))][::-1]
     gt_agents_by_frame = defaultdict(list)
     for agent in gt:
-        gt_agents_by_frame[(agent["seq_id"], agent["timestamp"])].append(agent)
+        gt_agents_by_frame[(agent["seq_id"], agent["timestamp_ns"])].append(agent)
 
     npos = len(gt)
     # ---------------------------------------------
@@ -179,12 +179,12 @@ def match(gt: str, pred: str, profile: str) -> bool:
         min_dist = np.inf
         match_gt_idx = None
 
-        gt_agents_in_frame = gt_agents_by_frame[(pred_agent["seq_id"], pred_agent["timestamp"])]
+        gt_agents_in_frame = gt_agents_by_frame[(pred_agent["seq_id"], pred_agent["timestamp_ns"])]
         for gt_idx, gt_agent in enumerate(gt_agents_in_frame):
-            if not (pred_agent["seq_id"], pred_agent["timestamp"], gt_idx) in taken:
+            if not (pred_agent["seq_id"], pred_agent["timestamp_ns"], gt_idx) in taken:
                 # Find closest match among ground truth boxes
                 this_distance = utils.center_distance(
-                    gt_agent["current_translation"], pred_agent["current_translation"]
+                    gt_agent["current_translation_m"], pred_agent["current_translation_m"]
                 )
                 if this_distance < min_dist:
                     min_dist = this_distance
@@ -194,18 +194,18 @@ def match(gt: str, pred: str, profile: str) -> bool:
         is_match = min_dist < threshold
 
         if is_match and match_gt_idx is not None:
-            taken.add((pred_agent["seq_id"], pred_agent["timestamp"], match_gt_idx))
+            taken.add((pred_agent["seq_id"], pred_agent["timestamp_ns"], match_gt_idx))
             gt_match_agent = gt_agents_in_frame[match_gt_idx]
 
-            gt_len = gt_match_agent["future_translation"].shape[0]
+            gt_len = gt_match_agent["future_translation_m"].shape[0]
             forecast_match_th = [threshold + constants.FORECAST_SCALAR[i] * velocity for i in range(gt_len + 1)]
 
             if top_k == 1:
                 ind = cast(int, np.argmax(pred_agent["score"]))
                 forecast_dist = [
                     utils.center_distance(
-                        gt_match_agent["future_translation"][i],
-                        pred_agent["prediction"][ind][i],
+                        gt_match_agent["future_translation_m"][i],
+                        pred_agent["prediction_m"][ind][i],
                     )
                     for i in range(gt_len)
                 ]
@@ -221,8 +221,8 @@ def match(gt: str, pred: str, profile: str) -> bool:
                 for ind in range(top_k):
                     curr_forecast_dist = [
                         utils.center_distance(
-                            gt_match_agent["future_translation"][i],
-                            pred_agent["prediction"][ind][i],
+                            gt_match_agent["future_translation_m"][i],
+                            pred_agent["prediction_m"][ind][i],
                         )
                         for i in range(gt_len)
                     ]
@@ -303,13 +303,13 @@ def convert_forecast_labels(labels: Any) -> Any:
         frame_dict = {}
         for frame_idx, frame in enumerate(frames):
             forecast_instances = []
-            for instance in utils.array_dict_iterator(frame, len(frame["translation"])):
+            for instance in utils.array_dict_iterator(frame, len(frame["translation_m"])):
                 future_translations: Any = []
                 for future_frame in frames[frame_idx + 1 : frame_idx + 1 + constants.NUM_TIMESTEPS]:
                     if instance["track_id"] not in future_frame["track_id"]:
                         break
                     future_translations.append(
-                        future_frame["translation"][future_frame["track_id"] == instance["track_id"]][0]
+                        future_frame["translation_m"][future_frame["track_id"] == instance["track_id"]][0]
                     )
 
                 if len(future_translations) == 0:
@@ -317,13 +317,13 @@ def convert_forecast_labels(labels: Any) -> Any:
 
                 forecast_instances.append(
                     {
-                        "current_translation": instance["translation"][:2],
-                        "ego_translation": instance["ego_translation"][:2],
-                        "future_translation": np.array(future_translations)[:, :2],
+                        "current_translation_m": instance["translation_m"][:2],
+                        "ego_translation_m": instance["ego_translation_m"][:2],
+                        "future_translation_m": np.array(future_translations)[:, :2],
                         "name": instance["name"],
                         "size": instance["size"],
                         "yaw": instance["yaw"],
-                        "velocity": instance["velocity"][:2],
+                        "velocity_m_per_s": instance["velocity_m_per_s"][:2],
                         "label": instance["label"],
                     }
                 )
@@ -346,14 +346,14 @@ def filter_max_dist(forecasts: ForecastSequences, max_range_m: int) -> ForecastS
         Dictionary of tracks.
     """
     for seq_id in forecasts.keys():
-        for timestamp in forecasts[seq_id].keys():
+        for timestamp_ns in forecasts[seq_id].keys():
             keep_forecasts = [
                 agent
-                for agent in forecasts[seq_id][timestamp]
-                if "ego_translation" in agent
-                and np.linalg.norm(agent["current_translation"] - agent["ego_translation"]) < max_range_m
+                for agent in forecasts[seq_id][timestamp_ns]
+                if "ego_translation_m" in agent
+                and np.linalg.norm(agent["current_translation_m"] - agent["ego_translation_m"]) < max_range_m
             ]
-            forecasts[seq_id][timestamp] = keep_forecasts
+            forecasts[seq_id][timestamp_ns] = keep_forecasts
 
     return forecasts
 
@@ -386,23 +386,23 @@ def filter_drivable_area(forecasts: ForecastSequences, dataset_dir: str) -> Fore
     for log_id in log_ids:
         avm = log_id_to_avm[log_id]
 
-        for timestamp in forecasts[log_id]:
-            city_SE3_ego = log_id_to_timestamped_poses[log_id][int(timestamp)]
+        for timestamp_ns in forecasts[log_id]:
+            city_SE3_ego = log_id_to_timestamped_poses[log_id][int(timestamp_ns)]
 
-            translation, size, quat = [], [], []
+            translation_m, size, quat = [], [], []
 
-            if len(forecasts[log_id][timestamp]) == 0:
+            if len(forecasts[log_id][timestamp_ns]) == 0:
                 continue
 
-            for box in forecasts[log_id][timestamp]:
-                translation.append(box["current_translation"] - box["ego_translation"])
+            for box in forecasts[log_id][timestamp_ns]:
+                translation_m.append(box["current_translation_m"] - box["ego_translation_m"])
                 size.append(box["size"])
                 quat.append(yaw_to_quaternion3d(box["yaw"]))
 
-            score = np.ones((len(translation), 1))
+            score = np.ones((len(translation_m), 1))
             boxes = np.concatenate(
                 [
-                    np.array(translation),
+                    np.array(translation_m),
                     np.array(size),
                     np.array(quat),
                     np.array(score),
@@ -411,7 +411,7 @@ def filter_drivable_area(forecasts: ForecastSequences, dataset_dir: str) -> Fore
             )
 
             is_evaluated = compute_objects_in_roi_mask(boxes, city_SE3_ego, avm)
-            forecasts[log_id][timestamp] = list(np.array(forecasts[log_id][timestamp])[is_evaluated])
+            forecasts[log_id][timestamp_ns] = list(np.array(forecasts[log_id][timestamp_ns])[is_evaluated])
 
     return forecasts
 
diff --git a/src/av2/evaluation/forecasting/utils.py b/src/av2/evaluation/forecasting/utils.py
index 4da6519f..db4ec114 100644
--- a/src/av2/evaluation/forecasting/utils.py
+++ b/src/av2/evaluation/forecasting/utils.py
@@ -8,56 +8,56 @@
 from ..typing import ForecastSequences, Frame
 
 
-def agent_velocity(agent: Dict[str, Any]) -> NDArrayFloat:
-    """Get the agent velocity.
+def agent_velocity_m_per_s(agent: Dict[str, Any]) -> NDArrayFloat:
+    """Get the agent velocity_m_per_s.
 
-    Velocity calculated as the delta between the current translation and the translation in the next timestep.
+    velocity_m_per_s calculated as the delta between the current translation_m and the translation_m in the next timestep.
 
     Args:
         agent: Dictionary containing the agent's translations
 
     Returns:
-        Ground truth velocity for label agents or
+        Ground truth velocity_m_per_s for label agents or
         List of velocities corresponding to each movement prediction for predicted agents
     """
-    if "future_translation" in agent:  # ground_truth
+    if "future_translation_m" in agent:  # ground_truth
         return cast(
             NDArrayFloat,
-            (agent["future_translation"][0][:2] - agent["current_translation"][:2]) / constants.TIME_DELTA_S,
+            (agent["future_translation_m"][0][:2] - agent["current_translation_m"][:2]) / constants.TIME_DELTA_S,
         )
 
     else:  # predictions
         res = []
-        for i in range(agent["prediction"].shape[0]):
-            res.append((agent["prediction"][i][0][:2] - agent["current_translation"][:2]) / constants.TIME_DELTA_S)
+        for i in range(agent["prediction_m"].shape[0]):
+            res.append((agent["prediction_m"][i][0][:2] - agent["current_translation_m"][:2]) / constants.TIME_DELTA_S)
 
         return np.stack(res)
 
 
-def trajectory_type(agent: Dict[str, Any], class_velocity: Dict[str, float]) -> Union[str, List[str]]:
+def trajectory_type(agent: Dict[str, Any], category_velocity_m_per_s: Dict[str, float]) -> Union[str, List[str]]:
     """Get the trajectory type, which is either static, linear or non-linear.
 
     Trajectory is static if the prediction error of a static forecast is below threshold.
     Trajectory is linear if the prediction error of the linear forecast is below threshold.
-    Linear forecast is created by linearly extrapolating the current velocity.
+    Linear forecast is created by linearly extrapolating the current velocity_m_per_s.
     Trajectory is non-linear if it is neither static or linear.
 
     Args:
-        agent: Dictionary containing the agent's translations and velocity
-        class_velocity: Average velocity of each class, used to determine the prediction error threshold for each class
+        agent: Dictionary containing the agent's translations and velocity_m_per_s.
+        category_velocity_m_per_s: Average velocity_m_per_s of each class, used to determine the prediction error threshold for each category.
 
     Returns:
         String corresponding to the trajectory type for agents in the ground-truth annotations or
         List of strings, one trajectory for each movement prediction for predicted agents
     """
-    if "future_translation" in agent:  # ground_truth
-        time = agent["future_translation"].shape[0] * constants.TIME_DELTA_S
-        static_target = agent["current_translation"][:2]
-        linear_target = agent["current_translation"][:2] + time * agent["velocity"][:2]
+    if "future_translation_m" in agent:  # ground_truth
+        time = agent["future_translation_m"].shape[0] * constants.TIME_DELTA_S
+        static_target = agent["current_translation_m"][:2]
+        linear_target = agent["current_translation_m"][:2] + time * agent["velocity_m_per_s"][:2]
 
-        final_position = agent["future_translation"][-1][:2]
+        final_position = agent["future_translation_m"][-1][:2]
 
-        threshold = 1 + constants.FORECAST_SCALAR[len(agent["future_translation"])] * class_velocity.get(
+        threshold = 1 + constants.FORECAST_SCALAR[len(agent["future_translation_m"])] * category_velocity_m_per_s.get(
             agent["name"], 0
         )
         if np.linalg.norm(final_position - static_target) < threshold:
@@ -69,14 +69,16 @@ def trajectory_type(agent: Dict[str, Any], class_velocity: Dict[str, float]) ->
 
     else:  # predictions
         res: List[str] = []
-        time = agent["prediction"].shape[1] * constants.TIME_DELTA_S
+        time = agent["prediction_m"].shape[1] * constants.TIME_DELTA_S
 
-        threshold = 1 + constants.FORECAST_SCALAR[len(agent["prediction"])] * class_velocity.get(agent["name"], 0)
-        for i in range(agent["prediction"].shape[0]):
-            static_target = agent["current_translation"][:2]
-            linear_target = agent["current_translation"][:2] + time * agent["velocity"][i][:2]
+        threshold = 1 + constants.FORECAST_SCALAR[len(agent["prediction_m"])] * category_velocity_m_per_s.get(
+            agent["name"], 0
+        )
+        for i in range(agent["prediction_m"].shape[0]):
+            static_target = agent["current_translation_m"][:2]
+            linear_target = agent["current_translation_m"][:2] + time * agent["velocity_m_per_s"][i][:2]
 
-            final_position = agent["prediction"][i][-1][:2]
+            final_position = agent["prediction_m"][i][-1][:2]
 
             if np.linalg.norm(final_position - static_target) < threshold:
                 res.append("static")
@@ -141,14 +143,14 @@ def annotate_frame_metadata(
         predictions: Forecast predictions with new metadat key
     """
     for seq_id in ground_truth.keys():
-        for timestamp in ground_truth[seq_id].keys():
+        for timestamp_ns in ground_truth[seq_id].keys():
             copy_keys = {}
 
             for key in metadata_keys:
-                copy_keys[key] = ground_truth[seq_id][timestamp][0][key]
+                copy_keys[key] = ground_truth[seq_id][timestamp_ns][0][key]
 
-            for i in range(len(predictions[seq_id][timestamp])):
+            for i in range(len(predictions[seq_id][timestamp_ns])):
                 for key in metadata_keys:
-                    predictions[seq_id][timestamp][i][key] = copy_keys[key]
+                    predictions[seq_id][timestamp_ns][i][key] = copy_keys[key]
 
     return predictions
diff --git a/src/av2/evaluation/scene_flow/make_annotation_files.py b/src/av2/evaluation/scene_flow/make_annotation_files.py
index 69717268..7a735ea6 100644
--- a/src/av2/evaluation/scene_flow/make_annotation_files.py
+++ b/src/av2/evaluation/scene_flow/make_annotation_files.py
@@ -31,7 +31,7 @@ def write_annotation(
         is_dynamic: Dynamic labels.
         is_valid: Valid flow labels.
         flow: Flow labels.
-        sweep_uuid: Log and timestamp of the sweep.
+        sweep_uuid: Log id and timestamp_ns of the sweep.
         output_dir: Top level directory to store the output in.
     """
     output = pd.DataFrame(
diff --git a/src/av2/evaluation/scene_flow/utils.py b/src/av2/evaluation/scene_flow/utils.py
index 5cd76e2b..f57ff78d 100644
--- a/src/av2/evaluation/scene_flow/utils.py
+++ b/src/av2/evaluation/scene_flow/utils.py
@@ -70,7 +70,7 @@ def write_output_file(
     Args:
         flow: (N,3) Flow predictions.
         is_dynamic: (N,) Dynamic segmentation prediction.
-        sweep_uuid: Identifier of the sweep being predicted (log_id, timestamp).
+        sweep_uuid: Identifier of the sweep being predicted (log_id, timestamp_ns).
         output_dir: Top level directory containing all predictions.
     """
     output_log_dir = output_dir / sweep_uuid[0]
diff --git a/src/av2/evaluation/tracking/SUBMISSION_FORMAT.md b/src/av2/evaluation/tracking/SUBMISSION_FORMAT.md
deleted file mode 100644
index 90922305..00000000
--- a/src/av2/evaluation/tracking/SUBMISSION_FORMAT.md
+++ /dev/null
@@ -1,86 +0,0 @@
-# Tracking Submission Format
-
-The evaluation expects a dictionary of lists of dictionaries
-
-```python
-{
-      <log_id>: [
-            {
-                  "timestamp_ns": <timestamp_ns>,
-                  "track_id": <track_id>
-                  "score": <score>,
-                  "label": <label>,
-                  "name": <name>,
-                  "translation": <translation>,
-                  "size": <size>,
-                  "yaw": <yaw>,
-                  "velocity": <velocity>,
-            }
-      ]
-}
-```
-
-- `log_id`: Log id associated with the track, also called `seq_id`.
-- `timestamp_ns`: Timestamp associated with the detections.
-- `track_id`: Unique id assigned to each track, this is produced by your tracker.
-- `score`: Track confidence.
-- `label`: Integer index of the object class.
-- `name`: Object class name.
-- `translation`: xyz-components of the object translation in the city reference frame, in meters.
-- `size`: Object extent along the x,y,z axes in meters.
-- `yaw`: Object heading rotation along the z axis.
-- `velocity`: Object veloicty along the x,y,z axes.
-
-An example looks like this:
-
-```python
-# These tracks are only for example purposes.
-
-print(tracks)
-{
-  '02678d04-cc9f-3148-9f95-1ba66347dff9': [
-    {
-       'timestamp_ns': 315969904359876000,
-       'translation': array([[6759.51786422, 1596.42662849,   57.90987307],
-             [6757.01580393, 1601.80434654,   58.06088218],
-             [6761.8232099 , 1591.6432147 ,   57.66341136],
-             ...,
-             [6735.5776378 , 1626.72694938,   59.12224152],
-             [6790.59603472, 1558.0159741 ,   55.68706682],
-             [6774.78130127, 1547.73853494,   56.55294184]]),
-       'size': array([[4.315736  , 1.7214599 , 1.4757565 ],
-             [4.3870926 , 1.7566483 , 1.4416479 ],
-             [4.4788623 , 1.7604711 , 1.4735452 ],
-             ...,
-             [1.6218852 , 0.82648355, 1.6104599 ],
-             [1.4323177 , 0.79862624, 1.5229694 ],
-             [0.7979312 , 0.6317313 , 1.4602867 ]], dtype=float32),
-      'yaw': array([-1.1205611 , ... , -1.1305285 , -1.1272993], dtype=float32),
-      'velocity': array([[ 2.82435445e-03, -8.80148250e-04, -1.52388044e-04],
-             [ 1.73744695e-01, -3.48345393e-01, -1.52417628e-02],
-             [ 7.38469649e-02, -1.16846527e-01, -5.85577238e-03],
-             ...,
-             [-1.38887463e+00,  3.96778419e+00,  1.45435923e-01],
-             [ 2.23189720e+00, -5.40360805e+00, -2.14317040e-01],
-             [ 9.81130002e-02, -2.00860636e-01, -8.68975817e-03]]),
-      'label': array([ 0, 0, ... 9,  0], dtype=int32),
-      'name': array(['REGULAR_VEHICLE', ..., 'STOP_SIGN', 'REGULAR_VEHICLE'], dtype='<U31'),
-      'score': array([0.54183, ..., 0.47720736, 0.4853499], dtype=float32),
-      'track_id': array([0, ... , 11, 12], dtype=int32),
-    },
-    ...
-  ],
-  ...
-}
-```
-
-We need to export the above dictionary for submission. This can be done by:
-
-```python
-import pickle
-
-with open("track_predictions.pkl", "wb") as f:
-       pickle.dump(tracks, f)
-```
-
-Lastly, submit this file to the competition leaderboard.
diff --git a/src/av2/evaluation/tracking/eval.py b/src/av2/evaluation/tracking/eval.py
index a45de7fc..2438a561 100644
--- a/src/av2/evaluation/tracking/eval.py
+++ b/src/av2/evaluation/tracking/eval.py
@@ -77,7 +77,7 @@ def _load_raw_file(self, tracker: str, seq_id: Union[str, int], is_gt: bool) ->
         raw_data = {
             f"{source}_ids": [frame["track_id"] for frame in tracks],
             f"{source}_classes": [frame["label"] for frame in tracks],
-            f"{source}_dets": [np.concatenate((frame["translation"], frame["size"]), axis=-1) for frame in tracks],
+            f"{source}_dets": [np.concatenate((frame["translation_m"], frame["size"]), axis=-1) for frame in tracks],
             "num_timesteps": len(tracks),
             "seq": seq_id,
         }
@@ -177,10 +177,10 @@ def evaluate_tracking(
                 {
                     "timestamp_ns": int, # nano seconds
                     "track_id": np.ndarray[I],
-                    "translation": np.ndarray[I, 3],
+                    "translation_m": np.ndarray[I, 3],
                     "size": np.ndarray[I, 3],
                     "yaw": np.ndarray[I],
-                    "velocity": np.ndarray[I, 3],
+                    "velocity_m_per_s": np.ndarray[I, 3],
                     "label": np.ndarray[I],
                     "score": np.ndarray[I],
                     "name": np.ndarray[I],
@@ -365,10 +365,10 @@ def _calculate_matched_scores(
     num_tp = 0
     for seq_id in labels:
         for label_frame, prediction_frame in zip(labels[seq_id], predictions[seq_id]):
-            sim = sim_func(label_frame["translation"], prediction_frame["translation"])
+            sim = sim_func(label_frame["translation_m"], prediction_frame["translation_m"])
             match_rows, match_cols = linear_sum_assignment(-sim)
             scores.append(prediction_frame["score"][match_cols])
-            n_gt += len(label_frame["translation"])
+            n_gt += len(label_frame["translation_m"])
             num_tp += len(match_cols)
 
     scores_array = np.concatenate(scores)
@@ -416,7 +416,7 @@ def filter_max_dist(tracks: Any, max_range_m: int) -> Any:
             utils.index_array_values(
                 frame,
                 np.linalg.norm(
-                    frame["translation"][:, :2] - np.array(frame["ego_translation"])[:2],
+                    frame["translation_m"][:, :2] - np.array(frame["ego_translation_m"])[:2],
                     axis=1,
                 )
                 <= max_range_m,
@@ -461,18 +461,18 @@ def filter_drivable_area(tracks: Sequences, dataset_dir: Optional[str]) -> Seque
         for frame in tracks[log_id]:
             timestamp_ns = frame["timestamp_ns"]
             city_SE3_ego = log_id_to_timestamped_poses[log_id][int(timestamp_ns)]
-            translation = frame["translation"] - frame["ego_translation"]
+            translation_m = frame["translation_m"] - frame["ego_translation_m"]
             size = frame["size"]
             quat = np.array([yaw_to_quaternion3d(yaw) for yaw in frame["yaw"]])
-            score = np.ones((translation.shape[0], 1))
-            boxes = np.concatenate([translation, size, quat, score], axis=1)
+            score = np.ones((translation_m.shape[0], 1))
+            boxes = np.concatenate([translation_m, size, quat, score], axis=1)
 
             is_evaluated = compute_objects_in_roi_mask(boxes, city_SE3_ego, avm)
 
-            frame["translation"] = frame["translation"][is_evaluated]
+            frame["translation_m"] = frame["translation_m"][is_evaluated]
             frame["size"] = frame["size"][is_evaluated]
             frame["yaw"] = frame["yaw"][is_evaluated]
-            frame["velocity"] = frame["velocity"][is_evaluated]
+            frame["velocity_m_per_s"] = frame["velocity_m_per_s"][is_evaluated]
             frame["label"] = frame["label"][is_evaluated]
             frame["name"] = frame["name"][is_evaluated]
             frame["track_id"] = frame["track_id"][is_evaluated]
@@ -525,7 +525,7 @@ def evaluate(
     utils.annotate_frame_metadata(
         utils.ungroup_frames(track_predictions),
         utils.ungroup_frames(labels),
-        ["ego_translation"],
+        ["ego_translation_m"],
     )
     track_predictions = filter_max_dist(track_predictions, max_range_m)
 
diff --git a/src/av2/evaluation/tracking/utils.py b/src/av2/evaluation/tracking/utils.py
index eea0af2f..18086ae2 100644
--- a/src/av2/evaluation/tracking/utils.py
+++ b/src/av2/evaluation/tracking/utils.py
@@ -62,7 +62,7 @@ def group_frames(frames_list: Frames) -> Sequences:
     """Group list of frames into dictionary by sequence id.
 
     Args:
-        frames_list: List of frames, each containing a detections snapshot for a timestamp.
+        frames_list: List of frames, each containing a detections snapshot at timestamp_ns.
 
     Returns:
         Dictionary of frames indexed by sequence id.