# Source code for stonesoup.types.hypothesis

```# -*- coding: utf-8 -*-

from abc import abstractmethod
from collections import UserDict
import numpy as np

from .base import Type
from ..base import Property
from .detection import Detection, MissedDetection
from .prediction import MeasurementPrediction, Prediction
from ..types.numeric import Probability

[docs]class Hypothesis(Type):
"""Hypothesis base type

A Hypothesis has sub-types:

'SingleHypothesis', which consists of a prediction for a single
Track and a single Measurement that *might* be associated with it

'MultipleHypothesis', which consists of a prediction for a
single Track and multiple Measurements of which one *might* be associated
with it
"""

[docs]class SingleHypothesis(Hypothesis):
"""A hypothesis based on a single measurement.

"""
prediction: Prediction = Property(doc="Predicted track state")
measurement: Detection = Property(doc="Detection used for hypothesis and updating")
measurement_prediction: MeasurementPrediction = Property(
default=None, doc="Optional track prediction in measurement space")

def __bool__(self):
return (not isinstance(self.measurement, MissedDetection)) and \
(self.measurement is not None)

[docs]class SingleDistanceHypothesis(SingleHypothesis):
"""Distance scored hypothesis subclass.

Notes
-----
As smaller distance is 'better', comparison logic is reversed
i.e. smaller distance is a greater likelihood.
"""

distance: float = Property(doc="Distance between detection and prediction")

def __lt__(self, other):
return self.distance > other.distance

def __le__(self, other):
return self.distance >= other.distance

def __eq__(self, other):
return self.distance == other.distance

def __gt__(self, other):
return self.distance < other.distance

def __ge__(self, other):
return self.distance <= other.distance

@property
def weight(self):
try:
return 1 / self.distance
except ZeroDivisionError:
return float('inf')

[docs]class SingleProbabilityHypothesis(SingleHypothesis):
"""Single Measurement Probability scored hypothesis subclass.

"""

probability: Probability = Property(
doc="Probability that detection is true location of prediction")

def __lt__(self, other):
return self.probability < other.probability

def __le__(self, other):
return self.probability <= other.probability

def __eq__(self, other):
return self.probability == other.probability

def __gt__(self, other):
return self.probability > other.probability

def __ge__(self, other):
return self.probability >= other.probability

@property
def weight(self):
return self.probability

[docs]class JointHypothesis(Type, UserDict):
"""Joint Hypothesis base type

A Joint Hypothesis consists of multiple Hypothesese, each with a single
Track and a single Prediction.  A Joint Hypothesis can be a
'ProbabilityJointHypothesis' or a 'DistanceJointHypothesis', with a
probability or distance that is a function of the Hypothesis
probabilities.  Multiple Joint Hypotheses can be compared to see which is
most likely to be the "correct" hypothesis.

Note: In reality, the property 'hypotheses' is a dictionary where the
entries have the form 'Track: Hypothesis'.  However, we cannot define
it this way because then Hypothesis imports Track, and Track imports
Update, and Update imports Hypothesis, which is a circular import.
"""

hypotheses: Hypothesis = Property(doc='Association hypotheses')

def __new__(cls, hypotheses):
if all(isinstance(hypothesis, SingleDistanceHypothesis)
for hypothesis in hypotheses.values()):
return super().__new__(DistanceJointHypothesis)
elif all(isinstance(hypothesis, SingleProbabilityHypothesis)
for hypothesis in hypotheses.values()):
return super().__new__(ProbabilityJointHypothesis)
else:
raise NotImplementedError

def __init__(self, hypotheses):
super().__init__(hypotheses)
self.data = self.hypotheses

@abstractmethod
def __lt__(self, other):
raise NotImplementedError

@abstractmethod
def __le__(self, other):
raise NotImplementedError

@abstractmethod
def __eq__(self, other):
raise NotImplementedError

@abstractmethod
def __gt__(self, other):
raise NotImplementedError

@abstractmethod
def __ge__(self, other):
raise NotImplementedError

[docs]class ProbabilityJointHypothesis(JointHypothesis):
"""Probability-scored Joint Hypothesis subclass.

"""

probability: Probability = Property(default=None, doc='Probability of the Joint Hypothesis')

def __init__(self, hypotheses, *args, **kwargs):
super().__init__(hypotheses, *args, **kwargs)
self.probability = Probability(np.prod(
[hypothesis.probability for hypothesis in hypotheses.values()]))

def normalise(self):
sum_probability = Probability.sum(
hypothesis.probability for hypothesis in self.hypotheses.values())
for hypothesis in self.hypotheses.values():
hypothesis.probability /= sum_probability

def __lt__(self, other):
return self.probability < other.probability

def __le__(self, other):
return self.probability <= other.probability

def __eq__(self, other):
return self.probability == other.probability

def __gt__(self, other):
return self.probability > other.probability

def __ge__(self, other):
return self.probability >= other.probability

[docs]class DistanceJointHypothesis(
JointHypothesis):
"""Distance scored Joint Hypothesis subclass.

Notes
-----
As smaller distance is 'better', comparison logic is reversed
i.e. smaller distance is a greater likelihood.
"""

def __init__(self, hypotheses):
super().__init__(hypotheses)

@property
def distance(self):
return sum(hypothesis.distance for hypothesis in self.data.values())

def __lt__(self, other):
return self.distance > other.distance

def __le__(self, other):
return self.distance >= other.distance

def __eq__(self, other):
return self.distance == other.distance

def __gt__(self, other):
return self.distance < other.distance

def __ge__(self, other):
return self.distance <= other.distance
```