diff --git a/exercise-session-2.ipynb b/exercise-session-2.ipynb index 21d984cc5aac9b45db247be752a0f4371acd27dc..e9dea076c0e8d5f6435c469b0b4d39c50a23abce 100644 --- a/exercise-session-2.ipynb +++ b/exercise-session-2.ipynb @@ -13,11 +13,9 @@ }, { "cell_type": "code", - "execution_count": 1, - "id": "9e44486f", - "metadata": { - "tags": [] - }, + "execution_count": null, + "id": "3e6fa80c-07ba-4112-a0d3-2b3aec744e1d", + "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", @@ -25,131 +23,65 @@ "import seaborn as sns\n", "sns.set()\n", "rng = np.random.default_rng(13)\n", - "import jax\n", - "import jax.numpy as jnp\n", - "import tqdm\n", - "import scipy.stats as stats\n", - "import scipy\n", "from src.sim import generate_data\n", "from src.trajectories import get_ex2_trajectories\n", - "trajectories = get_ex2_trajectories()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e5ead4d2-2d44-4ef4-8961-ab8af73f2ba0", - "metadata": {}, - "outputs": [], - "source": [ - "def generate_data(trajectories, sensor_model, clutter_model, rng=None):\n", - " \"\"\"Simulates measurements along a state trajectory according to a sensor and clutter model.\n", - "\n", - " The function assumes Gaussian white noise affecting the measurements.\n", - "\n", - " Parameters\n", - " ----------\n", - " trajectories : dict of numpy.ndarrays\n", - " A dict with entries with nx by N arrays where nx is the state dimension and N is the number of time steps. Sample time T=1 is assumed.\n", - " sensor_model : dict\n", - " A dictionary with the following entries:\n", - " h : callable\n", - " measurement function\n", - " R : numpy.ndarray\n", - " measurement covariance\n", - " PD : float\n", - " probability of detection\n", - " clutter_model : dict\n", - " A dictionary with the following entries:\n", - " volume : dict\n", - " A dictionary with xmin, xmax, ymin, ymax (completely rectangular tracking volume)\n", - " lam : float\n", - " Clutter rate of Poisson distributed clutter. (lambda to coincide with numpy/wiki notation)\n", - " rng : Generator\n", - " A numpy random number generator. Can be constructed by e.g. np.random.default_rng()\n", - "\n", - " Returns\n", - " -------\n", - " list of numpy.ndarray\n", - " Each list item is a numpy.ndarray with zero or more measurements (ny by x)\n", - "\n", - " \"\"\"\n", - " N = max([T.shape[1] for key, T in trajectories.items()]) # Maximum length of a trajectory interesting for this purpose\n", - " if rng is None:\n", - " rng = np.random.default_rng()\n", - " measurements = []\n", - " \n", - " ny = sensor_model['h'](trajectories[next(iter(trajectories))][:, 0]).size # Get the dimensionality of the measurements\n", - " \n", - " for n in range(N):\n", - " # Determine amount of clutter this time\n", - " nclutter = rng.poisson(lam=clutter_model['lam'])\n", - " \n", - " trajs = [T for key, T in trajectories.items() if n<T.shape[1]] # Figure out what trajectories are active right now \n", - " Ntrajs = len(trajs) # Calc. number of trajectories present in the current time step\n", - " # Initialize an array w/ the number of measurements this time step\n", - " cur_measurements = np.empty((ny, nclutter+Ntrajs))\n", - " cur_measurements[:, :] = np.NaN\n", - " \n", - " if nclutter != 0:\n", - " # Calc. clutter states\n", - " clutter_states = np.concatenate([\n", - " rng.uniform(low=clutter_model['volume']['xmin'],\n", - " high=clutter_model['volume']['xmax'], size=(nclutter,)),\n", - " rng.uniform(low=clutter_model['volume']['ymin'],\n", - " high=clutter_model['volume']['ymax'], size=(nclutter,))\n", - " ]).reshape(-1, nclutter)\n", - "\n", - " cur_measurements[:, :nclutter] = (sensor_model['h'](clutter_states)+\\\n", - " rng.multivariate_normal(mean=np.zeros((ny,)), cov=sensor_model['R'], size=(nclutter)).squeeze().T).reshape(-1, nclutter)\n", - "\n", - " # Generate measurement of target(s) (possibly)\n", - " for nt, traj in enumerate(trajs):\n", - " if rng.uniform() <= sensor_model['PD']:\n", - " y = sensor_model['h'](traj[:, n])+\\\n", - " rng.multivariate_normal(mean=np.zeros((ny,)), cov=sensor_model['R'])\n", - " cur_measurements[:, nclutter+nt] = y.flatten() # Add actual observation to array\n", - " \n", - " cur_measurements = cur_measurements[~np.isnan(cur_measurements)].reshape(ny, -1) # Remove nan measurements (i.e. targets that did not generate a measurement)\n", - " measurements.append(cur_measurements)\n", - " return measurements\n" + "import src.gaters as gaters\n", + "import src.filters as filters\n", + "import src.associators as associators\n", + "import src.trackers as trackers\n", + "import src.plotters as plotters\n", + "import src.models as models\n", + "import src.logic as logic\n", + "# Get the necessary trajectories\n", + "trajectories = get_ex2_trajectories()\n", + "trajs = ['T1', 'T3', 'T5', 'T6'] # Select the trajectories to use\n", + "filtered_trajs = {key: T for key, T in trajectories.items() if key in trajs}" ] }, { - "cell_type": "code", - "execution_count": 3, - "id": "746fda2d-1e68-4715-9deb-b2afdd324537", + "cell_type": "markdown", + "id": "1f7e085f-ebe1-4f9c-a38b-79917e802d32", "metadata": {}, - "outputs": [], "source": [ - "T = []\n", - "trajs = ['T1', 'T3', 'T5', 'T6']\n", - "filtered_trajs = {key: T for key, T in trajectories.items() if key in trajs}" + "### Task 2.2 - 2.3 - GNN and JPDA\n", + "\n", + "A GNN tracker and a JPDA tracker were implemented, see src.trackers. The model setup is as follows\n", + "\n", + "##### **Sensor Model**\n", + "The sensor model is the standard distance and bearing radar with $\\mathbf{R}=\\mathrm{diag}[10, 0.001]^2$. The probability of detection is set to $P_D=0.9$.\n", + "\n", + "##### **Gating**\n", + "Mahalanobis gating is used with $\\gamma=9.2$.\n", + "\n", + "##### **Clutter Model**\n", + "The volume is rectangular with $0\\leq x\\leq 2500$ and $0\\leq y\\leq2000$. Further, $\\beta_{FA}V=2$.\n", + "\n", + "##### **Track Logic**\n", + "A score-based track logic was used with an exponential forgetting factor to avoid integrator wind-up. The forgetting factor was tuned to $\\lambda=0.6$. The new target rate $\\beta_{NT}=\\beta_{FA}$. Further, the probability of confirming false tracks $P_{FC}0.1\\%$ and the probability of rejecting true tracks is $P_{TM}=1\\%$.\n", + "\n", + "##### **Motion Model**\n", + "The motion model is chosen as a CV model with $\\mathbf{Q}=10\\mathbf{I}$ which yielded good tracking performance for both GNN and JPDA.\n", + "\n", + "##### **Filter**\n", + "The filter was chosen as an EKF for simplicity (and it seemed to work fine).\n", + "\n", + "##### **Initialization**\n", + "The tracks were initialized at the measurement (converted to the positional domain) with a $0$ velocity. The initial uncertainty was set to $\\mathbf{P}_0=\\mathsc{diag}[10, 10, 100, 100]$ to account for the unknown initial velocity. The track score is initially set to $L_t=0$." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "ad8aeebb", "metadata": {}, "outputs": [], "source": [ - "import src.gaters as gaters\n", - "import src.filters as filters\n", - "import src.associators as associators\n", - "import src.trackers as trackers\n", - "import src.plotters as plotters\n", - "import src.models as models\n", - "import src.logic as logic\n", - "\n", "R = np.diag([10, 0.001])**2\n", - "# R = np.diag([0, 0]) # No noise\n", - "PD = 0.9 # Perfect detections\n", - "lam = 2 # No clutter\n", + "PD = 0.9 \n", + "lam = 2 \n", "volume = dict(xmin=0, xmax=2500, ymin=0, ymax=2000)\n", "V = (volume['xmax']-volume['xmin'])*(volume['ymax']-volume['ymin'])\n", "Bfa = lam/V\n", - "# Bfa = 4e-7\n", "sensor_model = models.radar_model(R=R, PD=PD)\n", "clutter_model = dict(volume=volume, lam=lam, Bfa=Bfa)\n", "Bnt = Bfa\n", @@ -158,14 +90,14 @@ "motion_model = models.cv_model(Q=q*np.identity(2), D=2, T=1)\n", "\n", "# Setup Gater\n", - "gamma = 4.7\n", + "gamma = 9.2\n", "gater = gaters.MahalanobisGater(sensor_model, gamma)\n", "\n", - "P0 = np.diag([10, 10, 1000, 1000])\n", + "P0 = np.diag([10, 10, 100, 100])\n", "Ptm = 0.01\n", "Pfc = 0.001\n", - "lam = 0.7\n", - "logic_params = dict(PD=sensor_model['PD'], PG=1, lam=lam, Ptm=Ptm, Pfc=Pfc, Bfa=Bfa, Ldel=0.1*np.log(Ptm/(1-Pfc)), Bnt=Bnt)\n", + "lam = 0.6\n", + "logic_params = dict(PD=sensor_model['PD'], PG=1, lam=lam, Ptm=Ptm, Pfc=Pfc, Bfa=Bfa, Ldel=1*np.log(Ptm/(1-Pfc)), Bnt=Bnt)\n", "\n", "def init_track(y, k, identity, filt):\n", " track = dict(stage='tentative', Lt=0, x=[], P=[], t=[k], identity=identity, associations=[k], filt=filt)\n", @@ -179,129 +111,13 @@ ] }, { - "cell_type": "code", - "execution_count": 49, - "id": "1ff81504-d524-4106-ba87-4d0242930ea0", + "cell_type": "markdown", + "id": "30f60524-b6cb-48c6-bbee-c69d8f72bdf2", "metadata": {}, - "outputs": [], "source": [ - "import pdb\n", - "class JPDA():\n", - " def __init__(self, logic, logic_params, init_track, filt, gater, clutter_model):\n", - " self.logic = logic\n", - " self.logic_params = logic_params\n", - " self.init_track = init_track\n", - " self.filt = filt\n", - " self.gater = gater\n", - " self.clutter_model = clutter_model\n", - "\n", - " def _update_track(self, meas, track):\n", - " if meas.size == 0:\n", - " track = self.logic(np.array([]), track['filt'], track, self.logic_params) # If no meas associated, still update logic of track\n", - " return\n", - " # Calculate prediction error of each measurement\n", - " yhat = track['filt'].sensor_model['h'](track['x'][-1])\n", - "\n", - " eps = meas-yhat\n", - " track = self.logic(meas, track['filt'], track, self.logic_params)\n", - "\n", - " # Update\n", - " track['x'][-1], track['P'][-1] = track['filt'].update(track['x'][-1], track['P'][-1], eps)\n", - "\n", - " def evaluate(self, Y):\n", - " tracks = [] # Store all tracks\n", - " confirmed_tracks = [] # Store the confirmed tracks (for plotting purposes only)\n", - " ids = 0\n", - " for k, meas_k in tqdm.tqdm(enumerate(Y), desc=\"Evaluating observations: \"):\n", - " ny = meas_k.shape[1]\n", - " unused_meas = np.ones((ny), dtype=bool)\n", - "\n", - " live_tracks = [track for track in confirmed_tracks if track['stage']=='confirmed']\n", - "\n", - "# if live_tracks:\n", - "# association_matrix, _ = get_association_matrix(meas_k, live_tracks, self.logic_params, self.gater)\n", - " \n", - "# # Solve association problem\n", - "# row_ind, col_ind = scipy.optimize.linear_sum_assignment(-association_matrix)\n", - "\n", - "# for row, col in zip(row_ind, col_ind):\n", - "# if col >= len(live_tracks): # No target to associate the measurement to\n", - "# continue\n", - "# else:\n", - "# unused_meas[row] = 0 # Remove this measurement from further consideration\n", - "# # Update confirmed tracks\n", - "# self._update_track(meas_k[:, row], live_tracks[col])\n", - "# live_tracks[col]['associations'].append(k) # If we've associated something, add the time here (for plotting purposes)\n", - "# for i in range(len(live_tracks)):\n", - "# if i not in col_ind:\n", - "# self._update_track(np.array([]), live_tracks[i])\n", - "\n", - "\n", - " tentative_tracks = [track for track in tracks if track['stage'] == 'tentative']\n", - "\n", - " if tentative_tracks:\n", - " association_matrix, validation_matrix = trackers.get_association_matrix(meas_k[:, unused_meas], tentative_tracks, self.logic_params, self.gater)\n", - " Nc = len(tentative_tracks)\n", - " rec = compute_prob(association_matrix[:, :ny+Nc], validation_matrix, self.logic_params)\n", - " pdb.set_trace()\n", - " \n", - " # Solve association problem\n", - " row_ind, col_ind = scipy.optimize.linear_sum_assignment(-association_matrix)\n", - " meas = meas_k[:, unused_meas]\n", - " for row, col in zip(row_ind, col_ind):\n", - " if col >= len(tentative_tracks): # No target to associate the measurement to\n", - " continue\n", - " else:\n", - " unused_meas[(meas_k == meas[:,[row]]).all(axis=0)] = 0 # Remove this measurement from consideration\n", - " # Update confirmed tracks\n", - " self._update_track(meas[:, row], tentative_tracks[col])\n", - " tentative_tracks[col]['associations'].append(k) # If we've associated something, add the time here (for plotting purposes)\n", - " if tentative_tracks[col]['stage'] == 'confirmed':\n", - " confirmed_tracks.append(tentative_tracks[col]) # If a track has been confirmed, add it to confirmed tracks\n", - " for i in range(len(tentative_tracks)):\n", - " if i not in col_ind:\n", - " self._update_track(np.array([]), tentative_tracks[i])\n", - "\n", - " # Use the unused measurements to initiate new tracks\n", - " for meas in meas_k[:, unused_meas].T:\n", - " tracks.append(self.init_track(meas, k, ids, self.filt))\n", - " ids += 1\n", - "\n", - " for track in tracks:\n", - " if track['stage'] != 'deleted':\n", - " x, P = track['filt'].propagate(track['x'][-1], track['P'][-1])\n", - " track['x'].append(x)\n", - " track['P'].append(P)\n", - " track['t'].append(k+1)\n", - " return tracks, confirmed_tracks\n", - " \n", - "def compute_prob(association_matrix, validation_matrix, logic_params):\n", - " # Association matrix is assumed to consist of tracks and FA, no NT.\n", - " ny = association_matrix.shape[0]\n", - " ntracks = association_matrix.shape[1]-ny\n", - " P = np.zeros((ny, ntracks))\n", - " \n", - " def rec_find_associations(association_matrix, assoc_done, logic_params):\n", - " inds = np.where(association_matrix[0, :] != -np.inf)[0] # These are the nodes necessary to look at\n", - " this_assoc = []\n", - " for k, i in enumerate(inds):\n", - " if i not in assoc_done:\n", - " if association_matrix.shape[0] != 1:\n", - " assoc = rec_compute_prob(association_matrix[1:, :], [[i]], logic_params)\n", - " this_assoc.extend(assoc)\n", - " else:\n", - " this_assoc.append([i])\n", - " result = []\n", - " for assoc in assoc_done:\n", - " for th_assoc in this_assoc:\n", - " result.append(assoc + th_assoc)\n", - " return result\n", - " \n", - " possible_associations = rec_find_associations(association_matrix, [[]], logic_params) # Recursively finds possible measurement hypothesis\n", - " pdb.set_trace()\n", - " return res\n", - " \n", - " " + "#### Apply GNN and JPDA\n", + "\n", + "Generates measurements from the true tracks and evaluates those measurements with the JPDA and GNN tracker." ] }, { @@ -311,169 +127,215 @@ "metadata": {}, "outputs": [], "source": [ - "jpda = JPDA(logic.score_logic, logic_params, init_track, filt, gater, clutter_model)\n", + "jpda = trackers.JPDA(logic.score_logic, logic_params, init_track, filt, gater, clutter_model)\n", + "gnn = trackers.GNN(logic.score_logic, logic_params, init_track, filt, gater, clutter_model)\n", "Y = generate_data(filtered_trajs, sensor_model, clutter_model, rng)\n", - "tracks, confirmed_tracks = jpda.evaluate(Y)" + "jpda_tracks, jpda_confirmed_tracks = jpda.evaluate(Y)\n", + "gnn_tracks, gnn_confirmed_tracks = gnn.evaluate(Y)" + ] + }, + { + "cell_type": "markdown", + "id": "16eb8a37-895f-40a6-aefd-3d523e035d64", + "metadata": {}, + "source": [ + "#### Match the tracks to ground truth\n", + "\n", + "The tracks are matched according to the following criteria:\n", + "\n", + "- The initial point of each track is matched to the closest point of each true trajectory.\n", + "- The RMSE to each track is then calculated and the lowest RMSE is chosen as the true trajectory for this track.\n", + "\n", + "Limitations: several tracks can match a specific true trajectory. (Hopefully not an issue, at least not here)." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "0c29b3fb-55ac-4c19-9acb-b493e536bd8d", "metadata": {}, "outputs": [], "source": [ "from src.utility import match_tracks_to_ground_truth\n", - "matches = match_tracks_to_ground_truth(confirmed_tracks, filtered_trajs)" + "jpda_matches = match_tracks_to_ground_truth(jpda_confirmed_tracks, filtered_trajs)\n", + "gnn_matches = match_tracks_to_ground_truth(gnn_confirmed_tracks, filtered_trajs)\n", + "jpdaresult = dict(matches=jpda_matches, \n", + " tracks=jpda_tracks, \n", + " confirmed_tracks=jpda_confirmed_tracks,\n", + " Y=Y)\n", + "gnnresult = dict(matches=gnn_matches, \n", + " tracks=gnn_tracks, \n", + " confirmed_tracks=gnn_confirmed_tracks,\n", + " Y=Y)" + ] + }, + { + "cell_type": "markdown", + "id": "3be8ea4b-7d23-42a3-a4b2-bff1ab331767", + "metadata": {}, + "source": [ + "#### Plots\n", + "\n", + "Produces three plots for each tracker.\n", + "\n", + "- Plot 1: All the confirmed tracks over time with their birth and death.\n", + "- Plot 2: RMSE of each confirmed track to its matched true trajectory. Plotted over the normalized trajectory length.\n", + "- Plot 3: The tracks and all of the measurements together with the ground truths." ] }, { "cell_type": "code", - "execution_count": 10, - "id": "5dc32f5b-53c4-40e8-8c4b-9c50274cf2f0", + "execution_count": null, + "id": "41a6fabc-4074-4c6e-8e44-80693c4409a9", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 1152x1080 with 3 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "fig, ax = plt.subplots(3, 1, figsize=(16, 15))\n", - "Yt = np.hstack(Y)\n", - "yx, yy = plotters.radar_to_pos(Yt)\n", - "\n", - "for key, T in filtered_trajs.items():\n", - " ax[1].plot(T[0, :], T[1, :], color='k', lw=3)\n", - " \n", - "for track in tracks:\n", - " x = np.vstack(track['x'])\n", - " t = np.hstack(track['t']).flatten()\n", - " assoc = np.hstack(track['associations']).flatten()\n", - " if track in confirmed_tracks:\n", - " ls = '-'\n", - " l = ax[0].plot(t, track['identity']*np.ones(t.shape), ls=ls, markersize=3)[0]\n", - " ax[0].plot(assoc, track['identity']*np.ones(assoc.shape), ls='', color=l.get_color(), marker='x', markersize=6)\n", - " ax[1].plot(x[:, 0], x[:, 1], ls=ls, color=l.get_color(), lw=2)\n", - " else:\n", - " ls = '--'\n", - " ax[1].plot(x[:, 0], x[:, 1], ls=ls, lw=2)\n", - "\n", - "ax[0].set_ylabel('Track identity')\n", - "ax[0].set_title('Confirmed tracks over time')\n", - "ax[0].set_xlabel('Time index, k')\n", - "ax[1].plot(yx, yy, '.', color='k')\n", - "ax[1].set_xlabel(r'$p_x$')\n", - "ax[1].set_ylabel(r'$p_y$')\n", - "ax[1].set_title('Measurements and measurement predictions + tracks')\n", - "\n", - "# Plot the RMSE for the matched trajectories\n", - "for track_id, key in matches.items():\n", - " T = filtered_trajs[key]\n", - " track = [track for track in confirmed_tracks if track['identity'] == track_id][0]\n", - " x = np.vstack(track['x']).T\n", - " tf = np.hstack(track['t']).flatten()[-1]\n", - " gtf = T.shape[1]\n", - " if T.shape[1] > x.shape[1]:\n", - " N = x.shape[1]\n", - " else:\n", - " N = T.shape[1]\n", - " xrmse = np.sum((T[:, :N]-x[:2, :N])**2, axis=0)/N\n", - " terr = np.abs(gtf-tf)\n", - " T = np.linspace(0, x.shape[1]/N, N)\n", - " ax[2].plot(T, xrmse, label='{} -- Time error: {} timesteps'.format(key, terr))\n", - "\n", - "ax[2].set_xlabel('Trajectory index')\n", - "ax[2].set_ylabel('Positional RMSE')\n", - "ax[2].legend()\n", - "plt.tight_layout()\n", + "gnnfig = plotters.plot_result_ex2_2(gnnresult, filtered_trajs)\n", + "plt.suptitle('GNN', fontsize=20)\n", + "jpdafig = plotters.plot_result_ex2_2(jpdaresult, filtered_trajs)\n", + "plt.suptitle('JPDA', fontsize=20)\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "id": "2681a406-0615-49f7-8043-b306887d5fe0", + "metadata": {}, + "source": [ + "#### Comments\n", + "Both the GNN and JPDA capture all four tracks good. The GNN has a slightly lower RMSE overall which seems reasonable given the \"low\" clutter rate and only a few track cross-overs." + ] + }, + { + "cell_type": "markdown", + "id": "8058636f-682b-493c-aad5-374fb6f845df", + "metadata": {}, + "source": [ + "### Task 2.4 - Mysterious Data\n", + "\n", + "A GNN and a JPDA tracker were applied to the mysterious data set. The design choices are listed below.\n", + "\n", + "##### **Sensor Model**\n", + "The sensor model is the standard distance and bearing radar as before with the same noise parameters. The probability of detection was set to $P_D=0.9$.\n", + "\n", + "##### **Gating**\n", + "Mahalanobis gating was used with $\\gamma=9.2$.\n", + "\n", + "##### **Clutter Model**\n", + "The tracking volume was established by inspecting the measurement data in the positional domain. The volume is rectangular with $-2000\\leq x\\leq 2000$ and $-21000\\leq y\\leq-17000$. As before $\\beta_{FA}V=2$.\n", + "\n", + "##### **Track Logic**\n", + "A score-based track logic was used with an exponential forgetting factor to avoid integrator wind-up. The forgetting factor was tuned to $\\lambda=0.95$. The new target rate $\\beta_{NT}=\\beta_{FA}$. Further, the probability of confirming false tracks $P_{FC}0.1\\%$ and the probability of rejecting true tracks is $P_{TM}=1\\%$.\n", + "\n", + "##### **Motion Model**\n", + "After inspection of the measurement data in the positional domain, a CV model was chosen as the motion model. The process noise was tuned to $\\mathbf{Q}=5e4\\mathbf{I}$ which yielded good tracking performance for both GNN and JPDA.\n", + "\n", + "##### **Filter**\n", + "The filter was chosen as an EKF for simplicity (and it seemed to work fine).\n", + "\n", + "##### **Initialization**\n", + "The tracks were initialized at the measurement (converted to the positional domain) with a $0$ velocity. The initial uncertainty was set to $\\mathbf{P}_0=\\mathsc{diag}[100, 100, 1000, 1000]$ to account for the unknown initial velocity. The track score is initially set to $L_t=0$.\n" + ] + }, + { + "cell_type": "markdown", + "id": "dd9637ca-ccc3-46fe-bdfe-4f32faddd2a8", + "metadata": {}, + "source": [ + "##### **Model setup**\n", + "\n", + "Makes the necessary changes to the model setup." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8add90a-bb80-446d-9380-74d26ee43661", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.io import loadmat\n", + "dat = loadmat('data/ex2data.mat')\n", + "dat['Y'] = [yk.reshape(2, -1) for yk in dat['Y'].flatten()]\n", + "T = 0.26\n", + "volume = dict(xmin=-2000, xmax=2000, ymin=-21000, ymax=-17000)\n", + "\n", + "q = 5e4\n", + "motion_model = models.cv_model(Q=q*np.identity(2), D=2, T=T)\n", + "\n", + "V = (volume['xmax']-volume['xmin'])*(volume['ymax']-volume['ymin'])\n", + "Bfa = lam/V\n", + "clutter_model = dict(volume=volume, lam=lam, Bfa=Bfa)\n", + "\n", + "P0 = np.diag([100, 100, 1000, 1000])\n", + "logic_params['lam'] = 0.95\n", + "logic_params['Bnt'] = Bfa\n", + "\n", + "filt = filters.EKF(motion_model, sensor_model)" + ] + }, + { + "cell_type": "markdown", + "id": "62d5a1a0-fd3d-4419-87bb-b989d2c1b1d4", + "metadata": {}, + "source": [ + "#### Apply the JPDA and GNN trackers\n", + "\n", + "Applies the JPDA and GNN to the provided data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d955d2bc-9ee6-4ca2-bd0f-4ddf9c88ff68", + "metadata": {}, + "outputs": [], + "source": [ + "jpda = trackers.JPDA(logic.score_logic, logic_params, init_track, filt, gater, clutter_model)\n", + "gnn = trackers.GNN(logic.score_logic, logic_params, init_track, filt, gater, clutter_model)\n", + "jpda_tracks, jpda_confirmed_tracks = jpda.evaluate(dat['Y'])\n", + "gnn_tracks, gnn_confirmed_tracks = gnn.evaluate(dat['Y'])" + ] + }, + { + "cell_type": "markdown", + "id": "c1038ba5-c8e7-46d0-a91a-7be7cd9ef4bc", + "metadata": {}, + "source": [ + "#### Plots\n", + "\n", + "Produces two plots per tracker.\n", + "- Plot 1: Confirmed tracks over time with birth and possible death of tracks.\n", + "- Plot 2: The tracks and all of the measurements." + ] + }, { "cell_type": "code", - "execution_count": 42, - "id": "c6ab09ff-ae92-4df2-bda4-2f81535ef319", + "execution_count": null, + "id": "059a5880-31fe-40ba-acf7-755e1b002ec5", + "metadata": {}, + "outputs": [], + "source": [ + "jpda_result = dict(Y=dat['Y'], \n", + " tracks=jpda_tracks, \n", + " confirmed_tracks=jpda_confirmed_tracks)\n", + "gnn_result = dict(Y=dat['Y'],\n", + " tracks=gnn_tracks, \n", + " confirmed_tracks=gnn_confirmed_tracks)\n", + "plotters.plot_result_ex2_24(gnn_result)\n", + "plt.suptitle('GNN', fontsize=20)\n", + "plotters.plot_result_ex2_24(jpda_result)\n", + "plt.suptitle('JPDA', fontsize=20)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "50563376-26b3-40f8-98bc-6ded016a0eb3", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Evaluating observations: : 102it [00:33, 3.04it/s]\n" - ] - } - ], "source": [ - "import pdb\n", - "confirmed_tracks = [] # Store the confirmed tracks (for plotting purposes only)\n", - "tracks = [] # Store all tracks\n", - "\n", - "\n", - "ids = 0\n", - "\n", - "for k, meas_k in tqdm.tqdm(enumerate(Y), desc=\"Evaluating observations: \"):\n", - " ny = meas_k.shape[1]\n", - " unused_meas = np.ones((ny), dtype=bool)\n", - " \n", - " live_tracks = [track for track in confirmed_tracks if track['stage']=='confirmed']\n", - " \n", - " if live_tracks:\n", - " association_matrix = get_association_matrix(meas_k, live_tracks, gater)\n", - " # Solve association problem\n", - " row_ind, col_ind = scipy.optimize.linear_sum_assignment(-association_matrix)\n", - "\n", - " for row, col in zip(row_ind, col_ind):\n", - " if col >= len(live_tracks): # No target to associate the measurement to\n", - " continue\n", - " else:\n", - " unused_meas[row] = 0 # Remove this measurement from further consideration\n", - " # Update confirmed tracks\n", - " update_track(meas_k[:, row], live_tracks[col], logic.score_logic, logic_params)\n", - " live_tracks[col]['associations'].append(k) # If we've associated something, add the time here (for plotting purposes)\n", - " for i in range(len(live_tracks)):\n", - " if i not in col_ind:\n", - " live_tracks[i] = logic.score_logic(np.array([]), live_tracks[i]['filt'], live_tracks[i], logic_params) # If no meas associated, still update logic of track\n", - " \n", - " \n", - " tentative_tracks = [track for track in tracks if track['stage'] == 'tentative']\n", - " \n", - " if tentative_tracks:\n", - " association_matrix = get_association_matrix(meas_k[:, unused_meas], tentative_tracks, gater)\n", - " # Solve association problem\n", - " row_ind, col_ind = scipy.optimize.linear_sum_assignment(-association_matrix)\n", - " meas = meas_k[:, unused_meas]\n", - " for row, col in zip(row_ind, col_ind):\n", - " if col >= len(tentative_tracks): # No target to associate the measurement to\n", - " continue\n", - " else:\n", - " unused_meas[(meas_k == meas[:,[row]]).all(axis=0)] = 0 # Remove this measurement from consideration\n", - " # Update confirmed tracks\n", - " update_track(meas[:, row], tentative_tracks[col], logic.score_logic, logic_params)\n", - " tentative_tracks[col]['associations'].append(k) # If we've associated something, add the time here (for plotting purposes)\n", - " if tentative_tracks[col]['stage'] == 'confirmed':\n", - " confirmed_tracks.append(tentative_tracks[col]) # If a track has been confirmed, add it to confirmed tracks\n", - " for i in range(len(tentative_tracks)):\n", - " if i not in col_ind:\n", - " tentative_tracks[i] = logic.score_logic(np.array([]), tentative_tracks[i]['filt'], tentative_tracks[i], logic_params) # If no meas associated, still update logic of track\n", - " \n", - " # Use the unused measurements to initiate new tracks\n", - " for meas in meas_k[:, unused_meas].T:\n", - " tracks.append(init_track(meas, k, ids, filt))\n", - " ids += 1\n", - " \n", - " for track in tracks:\n", - " if track['stage'] != 'deleted':\n", - " x, P = track['filt'].propagate(track['x'][-1], track['P'][-1])\n", - " track['x'].append(x)\n", - " track['P'].append(P)\n", - " track['t'].append(k+1)\n" + "#### Comments\n", + "Both the GNN and JPDA manage to keep both tracks the entire time. The GNN results in two \"U\"-shaped tracks whereas the JPDA results in \"S\"-shaped tracks. Without more information, it is impossible to say which is correct. However, the JPDA tracker results in a smoother trajectory, probably because of the soft measurement assignments." ] } ],