Note

Go to the end to download the full example code or to run this example in your browser via Binder

# Disjoint Tracking and Classification

This example uses the implemented Hidden Markov model and composite tracking modules to categorise a target and track its kinematics.

All non-generic imports will be given in order of usage.

```
from datetime import datetime, timedelta
import matplotlib.pyplot as plt
import numpy as np
from stonesoup.models.transition.linear import ConstantVelocity, \
CombinedLinearGaussianTransitionModel
from stonesoup.types.groundtruth import GroundTruthState
```

## Ground Truth, Categorical, and Composite States

We will attempt to track and classify 3 targets.

### True Kinematics

They will move in random directions from defined starting points.

```
start = datetime.now()
kinematic_state1 = GroundTruthState([0, 1, 0, 1], timestamp=start) # x, vx, y, vy
kinematic_state2 = GroundTruthState([10, -1, 0, 1], timestamp=start)
kinematic_state3 = GroundTruthState([10, -1, 5, 1], timestamp=start)
kinematic_transition = CombinedLinearGaussianTransitionModel([ConstantVelocity(0.1),
ConstantVelocity(0.1)])
```

### True Classifications

A target may take one of three discrete hidden classes: ‘bike’, ‘car’ and ‘bus’.
It will be assumed that the targets cannot transition from one class to another, so an
identity transition matrix is given to the `MarkovianTransitionModel`

for all targets.

A `CategoricalState`

class is used to store information on the classification/’category’
of the targets. The state vector of each will define a categorical distribution over the 3
possible classes, whereby each component defines the probability that the target is of the
corresponding class. For example, the state vector (0.2, 0.3, 0.5), with category names
(‘bike’, ‘car’, ‘bus’) indicates that the target has a 20% probability of being class
‘bike’, a 30% probability of being class ‘car’ etc.
It does not make sense to have a true target being a distribution over the possible classes, and
therefore the true categorical states will have binary state vectors indicating a specific class
for each target (i.e. a ‘1’ at one state vector index, and ‘0’s elsewhere).
The `CategoricalGroundTruthState`

inherits directly from the base
`CategoricalState`

.

```
from stonesoup.types.groundtruth import CategoricalGroundTruthState
from stonesoup.models.transition.categorical import MarkovianTransitionModel
hidden_classes = ['bike', 'car', 'bus']
gt_kwargs = {'timestamp': start, 'categories': hidden_classes}
category_state1 = CategoricalGroundTruthState([0, 0, 1], **gt_kwargs)
category_state2 = CategoricalGroundTruthState([1, 0, 0], **gt_kwargs)
category_state3 = CategoricalGroundTruthState([0, 1, 0], **gt_kwargs)
category_transition = MarkovianTransitionModel(transition_matrix=np.eye(3))
```

### Composite States

Each target will have kinematics and a category to be inferred. These are contained within a
`CompositeState`

type (in this instance the child class
`CompositeGroundTruthState`

).

```
from stonesoup.types.groundtruth import CompositeGroundTruthState
initial_state1 = CompositeGroundTruthState([kinematic_state1, category_state1])
initial_state2 = CompositeGroundTruthState([kinematic_state2, category_state2])
initial_state3 = CompositeGroundTruthState([kinematic_state3, category_state3])
```

### Generating Ground Truth Paths

Both the physical and categorical states of the targets need to be transitioned. While the category will remain the same, a transition model is used here for the sake of demonstration.

```
from stonesoup.types.groundtruth import GroundTruthPath
GT1 = GroundTruthPath([initial_state1], id='GT1')
GT2 = GroundTruthPath([initial_state2], id='GT2')
GT3 = GroundTruthPath([initial_state3], id='GT3')
ground_truth_paths = [GT1, GT2, GT3]
for GT in ground_truth_paths:
for i in range(10):
kinematic_sv = kinematic_transition.function(GT[-1][0],
noise=True,
time_interval=timedelta(seconds=1))
kinematic = GroundTruthState(kinematic_sv,
timestamp=GT[-1].timestamp + timedelta(seconds=1))
category_sv = category_transition.function(GT[-1][1],
noise=True,
time_interval=timedelta(seconds=1))
category = CategoricalGroundTruthState(category_sv,
timestamp=GT[-1].timestamp + timedelta(seconds=1),
categories=hidden_classes)
GT.append(CompositeGroundTruthState([kinematic, category]))
# Printing GT1
for state in GT1:
vector = np.round(state[0].state_vector.flatten().astype(np.double), 2)
print("%25s" % vector, ' -- ', state[1].category, ' -- ', state.timestamp)
```

```
[0. 1. 0. 1.] -- bus -- 2024-02-22 13:49:33.736496
[0.67 0.59 0.76 0.8 ] -- bus -- 2024-02-22 13:49:34.736496
[1.7 1.52 1.81 1.38] -- bus -- 2024-02-22 13:49:35.736496
[3.25 1.43 3.37 1.59] -- bus -- 2024-02-22 13:49:36.736496
[4.64 1.45 5.03 2. ] -- bus -- 2024-02-22 13:49:37.736496
[5.98 1.36 7.05 2.06] -- bus -- 2024-02-22 13:49:38.736496
[7.82 2.01 9.41 2.4 ] -- bus -- 2024-02-22 13:49:39.736496
[ 9.71 1.85 11.95 3. ] -- bus -- 2024-02-22 13:49:40.736496
[11.42 1.39 14.92 2.93] -- bus -- 2024-02-22 13:49:41.736496
[12.68 1.73 17.88 2.91] -- bus -- 2024-02-22 13:49:42.736496
[14.2 1.53 20.83 2.82] -- bus -- 2024-02-22 13:49:43.736496
```

### Plotting Ground Truths

Colour will be used in plotting as an indicator to category: red == ‘bike’, green == ‘car’, and blue == ‘bus’.

```
fig, axes = plt.subplots(1, 3, figsize=(10, 5))
fig.set_figheight(15)
fig.set_figwidth(15)
fig.subplots_adjust(wspace=5)
fig.tight_layout()
for ax in axes:
ax.set_aspect('equal', 'box')
for GT in ground_truth_paths:
X = list()
Y = list()
col = list(GT[0][1].state_vector)
for state in GT:
pos = state[0].state_vector
X.append(pos[0])
Y.append(pos[2])
axes[0].plot(X, Y, color=col, label=GT[-1][1].category)
axes[0].legend(loc='upper left')
axes[0].set(title='GT', xlabel='X', ylabel='Y')
axes[1].set_visible(False)
axes[2].set_visible(False)
def set_axes_limits():
xmax = max(ax.get_xlim()[1] for ax in axes)
ymax = max(ax.get_ylim()[1] for ax in axes)
xmin = min(ax.get_xlim()[0] for ax in axes)
ymin = min(ax.get_ylim()[0] for ax in axes)
for ax in axes:
ax.set_xlim(xmin, xmax)
ax.set_ylim(ymin, ymax)
set_axes_limits()
```

## Measurement

A new sensor will be created that can provide the information needed to both track and classify the targets.

### Composite Detection

Detections relating to both the kinematics and classification of the targets will be needed.
Therefore, we will create a sensor that outputs `CompositeDetection`

types. The input
`sensors`

list will provide the contents of these compositions. For this example, we will
provide a `RadarBearingRange`

and a `HMMSensor`

for kinematics and
classification respectively. `CompositeDetection`

types have a mapping attribute
which defines which sub-state index each sub-detection was created from. For example, a
composite state of form (kinematic state, categorical state), and composite detection with
mapping (1, 0), would indicate that the 0th index sub-detection was attained from the
categorical state, and the 1st index sub-detection from the kinematic state.

```
from typing import Set, Union, Sequence
from stonesoup.base import Property
from stonesoup.sensor.sensor import Sensor
from stonesoup.types.detection import CompositeDetection
class CompositeSensor(Sensor):
sensors: Sequence[Sensor] = Property(doc="A list of sensors.")
mapping: Sequence = Property(default=None,
doc="Mapping of which component states in the composite truth "
"state is measured.")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if self.mapping is None:
self.mapping = list(np.arange(len(self.sensors)))
def measure(self, ground_truths: Set[CompositeGroundTruthState],
noise: Sequence[Union[np.ndarray, bool]] = True,
**kwargs) -> Set[CompositeDetection]:
if isinstance(noise, bool) or len(noise) == 1:
noise = len(self.sensors) * [noise]
detections = set()
for truth in ground_truths:
sub_detections = list()
states = [truth.sub_states[i] for i in self.mapping]
for state, sub_sensor, sub_noise in zip(states, self.sensors, noise):
sub_detection = sub_sensor.measure(
ground_truths={state},
noise=sub_noise
).pop() # sub-sensor returns a set
sub_detections.append(sub_detection)
detection = CompositeDetection(sub_states=sub_detections,
groundtruth_path=truth,
mapping=self.mapping)
detections.add(detection)
return detections
@property
def measurement_model(self):
raise NotImplementedError
```

### Kinematic Measurement

Measurements of the target’s kinematics will be attained via a `RadarBearingRange`

sensor model.

```
from stonesoup.sensor.radar.radar import RadarBearingRange
radar = RadarBearingRange(ndim_state=4,
position_mapping=[0, 2],
noise_covar=np.diag([np.radians(0.05), 0.1]))
```

### Categorical Measurement

Using the hidden Markov model, it is assumed that the hidden class of the target cannot be
directly observed, and instead indirect observations are taken. In this instance, observations of
the target’s size are taken (‘small’ or ‘large’), which have direct implications as to the
target’s hidden class. This relationship is modelled by the emission matrix of the
`MarkovianMeasurementModel`

, which is used by the `HMMSensor`

to
provide `CategoricalDetection`

types.

We will model this such that a ‘bike’ has a very small chance of being observed as a ‘big’ target. Similarly, a ‘bus’ will tend to appear as ‘large’. A ‘car’ has equal chance of being observed as either.

```
from stonesoup.models.measurement.categorical import MarkovianMeasurementModel
from stonesoup.sensor.categorical import HMMSensor
E = np.array([[0.99, 0.5, 0.01], # P(small | bike), P(small | car), P(small | bus)
[0.01, 0.5, 0.99]])
model = MarkovianMeasurementModel(emission_matrix=E,
measurement_categories=['small', 'large'])
eo = HMMSensor(measurement_model=model)
```

### Composite Sensor

Here, we create the composite sensor class.

```
sensor = CompositeSensor(sensors=[eo, radar], mapping=[1, 0])
```

### Generating Measurements

```
all_measurements = list()
for gts1, gts2, gts3 in zip(GT1, GT2, GT3):
measurements_at_time = sensor.measure({gts1, gts2, gts3})
timestamp = gts1.timestamp
all_measurements.append((timestamp, measurements_at_time))
# Printing some measurements
for i, (time, measurements_at_time) in enumerate(all_measurements):
if i > 2:
break
print(f"{time:%H:%M:%S}")
for measurement in measurements_at_time:
vector = np.round(measurement.state_vector.flatten().astype(np.double), 2)
print("%25s" % vector, ' -- ', measurement[0].category)
```

```
13:49:33
[ 0. 1. 0.02 -0.02] -- large
[1. 0. 0.01 9.92] -- small
[ 0. 1. 0.51 11.8 ] -- large
13:49:34
[0. 1. 0.85 0.44] -- large
[ 0. 1. 0.63 10.56] -- large
[1. 0. 0.14 8.78] -- small
13:49:35
[ 0. 1. 0.74 10.45] -- large
[1. 0. 0.22 8.55] -- small
[0. 1. 0.83 2.93] -- large
```

### Plotting Measurements

Colour will be used to indicate measurement category: orange == ‘small’ and light-blue == ‘large’. It is expected that the bus will have mostly light-blue (large) measurements coinciding with its route, the bike will have mostly orange (small), and the car a roughly even split of both.

```
for time, measurements in all_measurements:
for measurement in measurements:
loc = measurement[1].state_vector
obs = measurement[0].state_vector
col = list(measurement[0].measurement_model.emission_matrix.T @ obs)
phi = loc[0]
rho = loc[1]
x = rho * np.cos(phi)
y = rho * np.sin(phi)
axes[1].scatter(x, y, color=col, marker='x', s=100, label=measurement[0].category)
a = axes[1].get_legend_handles_labels()
b = {l: h for h, l in zip(*a)}
c = [*zip(*b.items())]
d = c[::-1]
axes[1].legend(*d, loc='upper left')
axes[1].set(title='Measurements', xlabel='X', ylabel='Y')
axes[1].set_visible(True)
set_axes_limits()
fig
```

## Tracking Components

### Predictor

Though not used by the tracking components here, a `CompositePredictor`

will predict
the component states of a composite state forward, according to a list of sub-predictors.

A `HMMPredictor`

specifically uses `MarkovianTransitionModel`

types to predict.

```
from stonesoup.predictor.kalman import KalmanPredictor
from stonesoup.predictor.categorical import HMMPredictor
from stonesoup.predictor.composite import CompositePredictor
kinematic_predictor = KalmanPredictor(kinematic_transition)
category_predictor = HMMPredictor(category_transition)
predictor = CompositePredictor([kinematic_predictor, category_predictor])
```

### Updater

The `CompositeUpdater`

will update each component sub-state according to a list of
corresponding sub-updaters. It has no method to create measurement predictions.
This is instead handled on instantiation of `CompositeHypothesis`

types: the expected
arguments to the updater’s update method.

```
from stonesoup.updater.kalman import ExtendedKalmanUpdater
from stonesoup.updater.categorical import HMMUpdater
from stonesoup.updater.composite import CompositeUpdater
kinematic_updater = ExtendedKalmanUpdater()
category_updater = HMMUpdater()
updater = CompositeUpdater(sub_updaters=[kinematic_updater, category_updater])
```

### Hypothesiser

The hypothesiser is a `CompositeHypothesiser`

type. It is in the data association step
that tracking and classification are combined: for each measurement, a hypothesis is created for
both a track’s kinematic and categorical components. A `CompositeHypothesis`

type is
created which contains these sub-hypotheses, whereby its weight is equal to the product of the
sub-hypotheses’ weights. These sub-hypotheses should be probabilistic.

The `CompositeHypothesiser`

uses a list of sub-hypothesisers to create these
sub-hypotheses, hence the sub-hypothesisers should also be probabilistic.
In this example, we will define a hypothesiser that simply changes kinematic distance weights into
probabilities for hypothesising the kinematic sub-state of the track.

```
from stonesoup.measures import Mahalanobis
from stonesoup.hypothesiser.distance import DistanceHypothesiser
from stonesoup.types.hypothesis import SingleProbabilityHypothesis
from stonesoup.types.multihypothesis import MultipleHypothesis
class ProbabilityHypothesiser(DistanceHypothesiser):
def hypothesise(self, track, detections, timestamp, **kwargs):
multi_hypothesis = super().hypothesise(track, detections, timestamp, **kwargs)
single_hypotheses = multi_hypothesis.single_hypotheses
prob_single_hypotheses = list()
for hypothesis in single_hypotheses:
prob_hypothesis = SingleProbabilityHypothesis(hypothesis.prediction,
hypothesis.measurement,
1 / hypothesis.distance,
hypothesis.measurement_prediction)
prob_single_hypotheses.append(prob_hypothesis)
return MultipleHypothesis(prob_single_hypotheses, normalise=False, total_weight=1)
kinematic_hypothesiser = ProbabilityHypothesiser(predictor=kinematic_predictor,
updater=kinematic_updater,
measure=Mahalanobis())
```

A `HMMHypothesiser`

is used for calculating categorical hypotheses. It utilises the
`ObservationAccuracy`

measure: a multidimensional extension of an ‘accuracy’ score,
essentially providing a measure of the similarity between two categorical distributions.

```
from stonesoup.hypothesiser.categorical import HMMHypothesiser
from stonesoup.hypothesiser.composite import CompositeHypothesiser
category_hypothesiser = HMMHypothesiser(predictor=category_predictor,
updater=category_updater)
hypothesiser = CompositeHypothesiser(
sub_hypothesisers=[kinematic_hypothesiser, category_hypothesiser]
)
```

### Data Associator

We will use a standard `GNNWith2DAssignment`

data associator.

```
from stonesoup.dataassociator.neighbour import GNNWith2DAssignment
data_associator = GNNWith2DAssignment(hypothesiser)
```

### Prior

As we are tracking in a composite state space, we should initiate tracks with a
`CompositeState`

type. The kinematic sub-state of the prior is a Gaussian state.
For the categorical sub-state of the prior, equal probability is given to all 3 of the possible
hidden classes that a target might take (the category names are also provided here).

```
from stonesoup.types.state import GaussianState, CategoricalState, CompositeState
kinematic_prior = GaussianState([0, 0, 0, 0], np.diag([10, 10, 10, 10]))
category_prior = CategoricalState([1 / 3, 1 / 3, 1 / 3], categories=hidden_classes)
prior = CompositeState([kinematic_prior, category_prior])
```

### Initiator

The initiator is composite. For each unassociated detection, a new track will be initiated. In
this instance, we use a `CompositeUpdateInitiator`

type. A detection has both kinematic
and categorical information to initiate the 2 state space sub-states from. However, in an
instance where a detection only provides one of these, the missing sub-state for the track will
be initiated as the given prior’s sub-state (eg. if a detection provides only kinematic
information of the target, the track will initiate its categorical sub-state as the
category_prior defined earlier).

```
from stonesoup.initiator.simple import SimpleMeasurementInitiator
from stonesoup.initiator.categorical import SimpleCategoricalMeasurementInitiator
from stonesoup.initiator.composite import CompositeUpdateInitiator
kinematic_initiator = SimpleMeasurementInitiator(prior_state=kinematic_prior,
measurement_model=None)
category_initiator = SimpleCategoricalMeasurementInitiator(prior_state=category_prior,
updater=category_updater)
initiator = CompositeUpdateInitiator(sub_initiators=[kinematic_initiator, category_initiator])
```

### Deleter

We can use a standard `UpdateTimeStepsDeleter`

.

```
from stonesoup.deleter.time import UpdateTimeStepsDeleter
deleter = UpdateTimeStepsDeleter(2)
```

### Tracker

We can use a standard `MultiTargetTracker`

.

```
from stonesoup.tracker.simple import MultiTargetTracker
tracker = MultiTargetTracker(initiator, deleter, all_measurements, data_associator, updater)
```

## Tracking

```
tracks = set()
for time, ctracks in tracker:
tracks.update(ctracks)
print(f'Number of tracks {len(tracks)}')
for track in tracks:
print(f'id: {track.id}')
for state in track:
vector = np.round(state[0].state_vector.flatten().astype(np.double), 2)
print("%25s" % vector, ' -- ', state[1].category, ' -- ', state.timestamp)
```

```
Number of tracks 3
id: f14198a5-50aa-40d4-bce2-eff4e85c03d2
[-0.02 0. -0. 0. ] -- bus -- 2024-02-22 13:49:33.736496
[-0.43 -0.41 0.05 0.05] -- bus -- 2024-02-22 13:49:34.736496
[-2.09 -1.28 2.09 2.56] -- bus -- 2024-02-22 13:49:35.736496
[3.68 3.61 6.65 5.46] -- bus -- 2024-02-22 13:49:36.736496
[6.63 2.57 6.7 1.4 ] -- bus -- 2024-02-22 13:49:37.736496
[6.32 0.74 7.58 0.99] -- bus -- 2024-02-22 13:49:38.736496
[7.29 0.89 8.89 1.2 ] -- bus -- 2024-02-22 13:49:39.736496
[ 9.87 1.99 11.35 2.02] -- bus -- 2024-02-22 13:49:40.736496
[11.89 2.03 14.59 2.8 ] -- bus -- 2024-02-22 13:49:41.736496
[13.78 1.95 17.43 2.81] -- bus -- 2024-02-22 13:49:42.736496
[14.96 1.54 20.38 2.83] -- bus -- 2024-02-22 13:49:43.736496
id: 558bba0d-d28d-4f54-9d56-5ed2da859c06
[10.31 0. 5.73 0. ] -- bus -- 2024-02-22 13:49:33.736496
[ 8.52 -1.77 6.42 0.68] -- bus -- 2024-02-22 13:49:34.736496
[ 7.57 -1.22 7.08 0.67] -- bus -- 2024-02-22 13:49:35.736496
[ 7. -0.8 8.03 0.84] -- bus -- 2024-02-22 13:49:36.736496
[ 5.83 -1.05 8.86 0.84] -- car -- 2024-02-22 13:49:37.736496
[ 5.18 -0.79 9.59 0.77] -- car -- 2024-02-22 13:49:38.736496
[ 3.71 -1.23 10.3 0.73] -- car -- 2024-02-22 13:49:39.736496
[ 2.78 -1.03 11.83 1.25] -- car -- 2024-02-22 13:49:40.736496
[ 2.06 -0.84 12.75 1.04] -- car -- 2024-02-22 13:49:41.736496
[ 0.88 -1.04 14.53 1.52] -- car -- 2024-02-22 13:49:42.736496
[ 0.22 -0.82 16.6 1.88] -- car -- 2024-02-22 13:49:43.736496
id: 2e78a779-bb2b-4aa2-bce1-a74c3fa74c2f
[9.92 0. 0.13 0. ] -- bike -- 2024-02-22 13:49:33.736496
[ 8.78 -1.13 1.39 1.25] -- bike -- 2024-02-22 13:49:34.736496
[ 8.29 -0.7 1.99 0.8 ] -- bike -- 2024-02-22 13:49:35.736496
[ 8.3 -0.25 3.11 1.01] -- bike -- 2024-02-22 13:49:36.736496
[ 8.14 -0.2 4.34 1.16] -- bike -- 2024-02-22 13:49:37.736496
[ 7.86 -0.26 5.87 1.42] -- bike -- 2024-02-22 13:49:38.736496
[ 7.41 -0.38 6.91 1.16] -- bike -- 2024-02-22 13:49:39.736496
[7.69 0.05 8.44 1.4 ] -- bike -- 2024-02-22 13:49:40.736496
[ 7.21 -0.29 9.61 1.25] -- bike -- 2024-02-22 13:49:41.736496
[ 7.15 -0.15 10.98 1.33] -- bike -- 2024-02-22 13:49:42.736496
[ 6.47 -0.47 12.61 1.51] -- bike -- 2024-02-22 13:49:43.736496
```

### Plotting Tracks

Colour will be used to indicate a track’s hidden category distribution. The rgb value is defined by the ‘bike’, ‘car’, and ‘bus’ probabilities. For example, a track with high probability of being a ‘bike’ will have a high ‘r’ value and will appear more red.

```
for track in tracks:
for i, state in enumerate(track[1:], 1):
loc0 = track[i - 1][0].state_vector.flatten()
loc1 = state[0].state_vector.flatten()
X = [loc0[0], loc1[0]]
Y = [loc0[2], loc1[2]]
axes[2].plot(X, Y, label='track', color=list(state[1].state_vector))
axes[2].set(title='Tracks', xlabel='X', ylabel='Y')
axes[2].set_visible(True)
set_axes_limits()
fig
```

**Total running time of the script:** (0 minutes 1.437 seconds)