def __init__(self, distribution_beginning, distribution_ending,
bins=50, relation_formula=None):
if not isinstance(distribution_beginning, rv_frozen):
raise TypeError("'distribution_beginning' should be a scipy frozen distribution")
if not isinstance(distribution_ending, rv_frozen):
raise TypeError("'distribution_ending' should be a scipy frozen distribution")
self._distribution_beginning = distribution_beginning
self._distribution_ending = distribution_ending
a, beginning = calculate_bounds_of_probability_distribution(distribution_beginning)
ending, b = calculate_bounds_of_probability_distribution(distribution_ending)
self._beginning = UnixTime(beginning)
self._ending = UnixTime(ending)
self.membership_function = MembershipFunction(self)
bins_beginning = bins / 2
bins_ending = bins - bins_beginning
self.interval_beginning = TimeInterval(a, beginning, bins_beginning)
self.interval_ending = TimeInterval(ending, b, bins_ending)
list.__init__(self, self.interval_beginning + self.interval_ending)
TimeInterval.__init__(self, a, b, bins)
if relation_formula is None:
relation_formula = RelationFormulaGeometricMean()
elif not isinstance(relation_formula, BaseRelationFormula):
raise TypeError("'relation_formula' should be of type 'BaseRelationFormula'")
relation_formula.bounds[distribution_beginning] = self.a, self.beginning
relation_formula.bounds[distribution_ending] = self.ending, self.b
self._formula_creator = FormulaCreator(relation_formula)
class TemporalEvent(list, TimeInterval):
_distribution_beginning = None
_distribution_ending = None
_beginning = None
_ending = None
_dict = None
def __init__(self,
distribution_beginning,
distribution_ending,
bins=50,
relation_formula=None):
if not isinstance(distribution_beginning, rv_frozen):
raise TypeError(
"'distribution_beginning' should be a scipy frozen distribution"
)
if not isinstance(distribution_ending, rv_frozen):
raise TypeError(
"'distribution_ending' should be a scipy frozen distribution")
self._distribution_beginning = distribution_beginning
self._distribution_ending = distribution_ending
a, beginning = calculate_bounds_of_probability_distribution(
distribution_beginning)
ending, b = calculate_bounds_of_probability_distribution(
distribution_ending)
self._beginning = UnixTime(beginning)
self._ending = UnixTime(ending)
self.membership_function = MembershipFunction(self)
bins_beginning = bins / 2
bins_ending = bins - bins_beginning
self.interval_beginning = TimeInterval(a, beginning, bins_beginning)
self.interval_ending = TimeInterval(ending, b, bins_ending)
list.__init__(self, self.interval_beginning + self.interval_ending)
TimeInterval.__init__(self, a, b, bins)
# if relation_formula is None:
# relation_formula = RelationFormulaGeometricMean()
# elif not isinstance(relation_formula, BaseRelationFormula):
# raise TypeError("'relation_formula' should be of type 'BaseRelationFormula'")
relation_formula = RelationFormulaGeometricMean()
relation_formula.bounds[
distribution_beginning] = self.a, self.beginning
relation_formula.bounds[distribution_ending] = self.ending, self.b
self._formula_creator = FormulaCreator(relation_formula)
def degree(self, time_step=None, a=None, b=None, interval=None):
"""
usage: provide 'time_step' or 'a' and 'b' or 'interval'
"""
if time_step is not None:
return self.membership_function(time_step)
if interval is None:
if (a, b) == (None, None):
interval = self
else:
interval = TimeInterval(a, b)
else:
check_is_time_interval(interval)
return integral(self.membership_function, interval.a, interval.b)
def temporal_relations_with(self, other):
return self._formula_creator.temporal_relations_between(self, other)
def instance(self):
return TemporalInstance(self.distribution_beginning.rvs(),
self.distribution_ending.rvs())
def to_dict(self):
if self._dict is None:
self._dict = {}
for time_step in self.to_list():
self._dict[time_step] = self.membership_function(time_step)
return self._dict
# def plot(self, show_distributions=False):
# import matplotlib.pyplot as plt
# plt.plot(self.to_datetime_list(), self.membership_function())
# if show_distributions:
# if hasattr(self.distribution_beginning, 'plot'):
# self.distribution_beginning.plot()
# else:
# plt.plot(self.interval_beginning.to_datetime_list(),
# self.distribution_beginning.pdf(self.interval_beginning))
# if hasattr(self.distribution_ending, 'plot'):
# self.distribution_ending.plot()
# else:
# plt.plot(self.interval_ending.to_datetime_list(),
# self.distribution_ending.pdf(self.interval_ending))
# return plt
def plot(self, plt=None, show_distributions=False):
if plt is None:
import matplotlib.pyplot as plt
plt.plot(self.to_float_list(), self.membership_function())
if show_distributions:
if hasattr(self.distribution_beginning, 'plot'):
self.distribution_beginning.plot()
else:
plt.plot(
self.interval_beginning.to_float_list(),
self.distribution_beginning.pdf(self.interval_beginning))
if hasattr(self.distribution_ending, 'plot'):
self.distribution_ending.plot()
else:
plt.plot(self.interval_ending.to_float_list(),
self.distribution_ending.pdf(self.interval_ending))
return plt
@property
def distribution_beginning(self):
return self._distribution_beginning
@property
def distribution_ending(self):
return self._distribution_ending
@property
def beginning(self):
return self._beginning
@property
def ending(self):
return self._ending
def __mul__(self, other):
return self.temporal_relations_with(other)
def __str__(self):
return repr(self)
from spatiotemporal.temporal_events.trapezium import TemporalEventTrapezium
from spatiotemporal.temporal_events.relation_formulas import FormulaCreator
from spatiotemporal.temporal_events.composition.non_linear_least_squares import DecompositionFitter
import matplotlib.pyplot as plt
all_relations = "pmoFDseSdfOMP"
a = TemporalEventTrapezium(1, 12, 4, 8)
b = TemporalEventTrapezium(9, 17, 13, 15)
# compute relations between events
temporal_relations = a * b
print("Relations: {0}".format(temporal_relations.to_list()))
# print degree for every relation
for relation in all_relations:
print(relation, temporal_relations[relation])
# plot events
a.plot(show_distributions=True).ylim(ymin=-0.1, ymax=1.1)
b.plot(show_distributions=True).figure()
plt.show()
# from the 13 relations, learns parameters for all combinations of the
# before, same, and after relationships between the beginning and
# ending distributions of the two intervals
formula = FormulaCreator(DecompositionFitter(temporal_relations))
# from these relationships, computes the 13 relations again
relations_estimate = formula.calculate_relations()
print("Estimated relations: {0}".format(relations_estimate.to_list()))
class TemporalEvent(list, TimeInterval):
_distribution_beginning = None
_distribution_ending = None
_beginning = None
_ending = None
_dict = None
def __init__(self, distribution_beginning, distribution_ending,
bins=50, relation_formula=None):
if not isinstance(distribution_beginning, rv_frozen):
raise TypeError("'distribution_beginning' should be a scipy frozen distribution")
if not isinstance(distribution_ending, rv_frozen):
raise TypeError("'distribution_ending' should be a scipy frozen distribution")
self._distribution_beginning = distribution_beginning
self._distribution_ending = distribution_ending
a, beginning = calculate_bounds_of_probability_distribution(distribution_beginning)
ending, b = calculate_bounds_of_probability_distribution(distribution_ending)
self._beginning = UnixTime(beginning)
self._ending = UnixTime(ending)
self.membership_function = MembershipFunction(self)
bins_beginning = bins / 2
bins_ending = bins - bins_beginning
self.interval_beginning = TimeInterval(a, beginning, bins_beginning)
self.interval_ending = TimeInterval(ending, b, bins_ending)
list.__init__(self, self.interval_beginning + self.interval_ending)
TimeInterval.__init__(self, a, b, bins)
if relation_formula is None:
relation_formula = RelationFormulaGeometricMean()
elif not isinstance(relation_formula, BaseRelationFormula):
raise TypeError("'relation_formula' should be of type 'BaseRelationFormula'")
relation_formula.bounds[distribution_beginning] = self.a, self.beginning
relation_formula.bounds[distribution_ending] = self.ending, self.b
self._formula_creator = FormulaCreator(relation_formula)
def degree(self, time_step=None, a=None, b=None, interval=None):
"""
usage: provide 'time_step' or 'a' and 'b' or 'interval'
"""
if time_step is not None:
return self.membership_function(time_step)
if interval is None:
if (a, b) == (None, None):
interval = self
else:
interval = TimeInterval(a, b)
else:
check_is_time_interval(interval)
return integral(self.membership_function, interval.a, interval.b)
def temporal_relations_with(self, other):
return self._formula_creator.temporal_relations_between(self, other)
def instance(self):
return TemporalInstance(self.distribution_beginning.rvs(), self.distribution_ending.rvs())
def to_dict(self):
if self._dict is None:
self._dict = {}
for time_step in self.to_list():
self._dict[time_step] = self.membership_function(time_step)
return self._dict
def plot(self, show_distributions=False):
import matplotlib.pyplot as plt
plt.plot(self.to_datetime_list(), self.membership_function())
if show_distributions:
if hasattr(self.distribution_beginning, 'plot'):
self.distribution_beginning.plot()
else:
plt.plot(self.interval_beginning.to_datetime_list(),
self.distribution_beginning.pdf(self.interval_beginning))
if hasattr(self.distribution_ending, 'plot'):
self.distribution_ending.plot()
else:
plt.plot(self.interval_ending.to_datetime_list(),
self.distribution_ending.pdf(self.interval_ending))
return plt
@property
def distribution_beginning(self):
return self._distribution_beginning
@property
def distribution_ending(self):
return self._distribution_ending
@property
def beginning(self):
return self._beginning
@property
def ending(self):
return self._ending
def __mul__(self, other):
return self.temporal_relations_with(other)
def __str__(self):
return repr(self)
from spatiotemporal.temporal_events.trapezium import TemporalEventTrapezium
from spatiotemporal.temporal_events.relation_formulas import FormulaCreator
from spatiotemporal.temporal_events.composition.non_linear_least_squares import DecompositionFitter
import matplotlib.pyplot as plt
all_relations = "pmoFDseSdfOMP"
a = TemporalEventTrapezium(1, 12, 4, 8)
b = TemporalEventTrapezium(9, 17, 13, 15)
# compute relations between events
temporal_relations = a * b
print("Relations: {0}".format(temporal_relations.to_list()))
# print degree for every relation
for relation in all_relations:
print(relation, temporal_relations[relation])
# plot events
a.plot(show_distributions=True).ylim(ymin=-0.1, ymax=1.1)
b.plot(show_distributions=True).figure()
plt.show()
# from the 13 relations, learns parameters for all combinations of the
# before, same, and after relationships between the beginning and
# ending distributions of the two intervals
formula = FormulaCreator(DecompositionFitter(temporal_relations))
# from these relationships, computes the 13 relations again
relations_estimate = formula.calculate_relations()
print("Estimated relations: {0}".format(relations_estimate.to_list()))
