def __init__(self, dictionary_input_output): cdf_input_list, cdf_output_list = convert_dict_to_sorted_lists(dictionary_input_output) list.__init__(self, cdf_input_list) TimeInterval.__init__(self, self[0], self[-1], 2) self.cdf = FunctionPiecewiseLinear(dictionary_input_output, function_undefined=FUNCTION_ZERO) self.cdf.dictionary_bounds_function[(self.b, POSITIVE_INFINITY)] = FUNCTION_ONE pdf_output_list = [] dictionary_bounds_function = {} for bounds in sorted(self.cdf.dictionary_bounds_function): a, b = bounds if a in [NEGATIVE_INFINITY, POSITIVE_INFINITY] or b in [NEGATIVE_INFINITY, POSITIVE_INFINITY]: continue pdf_y_intercept = fabs(self.cdf.derivative((a + b) / 2.0)) pdf_output_list.append(pdf_y_intercept) dictionary_bounds_function[bounds] = FunctionHorizontalLinear(pdf_y_intercept) self.pdf = FunctionComposite(dictionary_bounds_function, function_undefined=FUNCTION_ZERO, domain=self, is_normalised=True) self.roulette_wheel = [] self._mean = 0 for bounds in sorted(self.pdf.dictionary_bounds_function): (a, b) = bounds if a in [NEGATIVE_INFINITY, POSITIVE_INFINITY] and b in [NEGATIVE_INFINITY, POSITIVE_INFINITY]: continue cdf = self.cdf.dictionary_bounds_function[bounds] pdf = self.pdf.dictionary_bounds_function[bounds] share = cdf(b) self.roulette_wheel.append((a, b, share)) self._mean += (a + b) / 2.0 * pdf(a) * (b - a)
def compare(self, dist_1, dist_2): dist_1_interval = TimeInterval(*self.bounds_of(dist_1)) dist_2_interval = TimeInterval(*self.bounds_of(dist_2)) dictionary_input_output = {} for time_step in dist_1_interval + dist_2_interval: dictionary_input_output[time_step] = sqrt( dist_1.pdf(time_step) * dist_2.pdf(time_step)) geometric_mean = FunctionPiecewiseLinear( dictionary_input_output, function_undefined=FUNCTION_ZERO) same = integral(geometric_mean, NEGATIVE_INFINITY, POSITIVE_INFINITY) dist_1_mean, dist_1_skewness, dist_1_kurtosis = dist_1.stats( moments='msk') dist_1_standard_deviation = dist_1.std() dist_2_mean, dist_2_skewness, dist_2_kurtosis = dist_2.stats( moments='msk') dist_2_standard_deviation = dist_2.std() distance = fabs(dist_1_standard_deviation - dist_2_standard_deviation) + fabs(dist_1_skewness - dist_2_skewness) distance += fabs(dist_1_kurtosis - dist_2_kurtosis) delta = dist_1_mean - dist_2_mean non_same_portion = 1.0 - same portion_after, portion_before = 1.0, 0.0 if almost_equals(distance, 0): if delta < 0: portion_after, portion_before = 0.0, 1.0 else: dist_1_standardized_pdf = lambda x: dist_1.pdf( dist_1_standard_deviation * x + dist_1_mean) dist_2_standardized_pdf = lambda x: dist_2.pdf( dist_2_standard_deviation * x + dist_2_mean) geometric_mean = lambda t: sqrt( dist_1_standardized_pdf(t) * dist_2_standardized_pdf(t)) geometric_mean_scaled = lambda p: geometric_mean(p / distance) geometric_mean_scaled_length = max(self.duration_of(dist_1), self.duration_of(dist_2)) dictionary_input_output = {} for time_step in TimeInterval(-geometric_mean_scaled_length / 2.0, geometric_mean_scaled_length / 2.0): dictionary_input_output[time_step] = geometric_mean_scaled( time_step) geometric_mean_scaled = FunctionPiecewiseLinear( dictionary_input_output, function_undefined=FUNCTION_ZERO) portion_after = integral(geometric_mean_scaled, NEGATIVE_INFINITY, delta) portion_before = integral(geometric_mean_scaled, delta, POSITIVE_INFINITY) after = portion_after / (portion_after + portion_before) * non_same_portion return 1.0 - same - after, same, after
def __init__(self, dictionary_input_output): cdf_input_list, cdf_output_list = convert_dict_to_sorted_lists( dictionary_input_output) list.__init__(self, cdf_input_list) TimeInterval.__init__(self, self[0], self[-1], 2) self.cdf = FunctionPiecewiseLinear(dictionary_input_output, function_undefined=FUNCTION_ZERO) self.cdf.dictionary_bounds_function[(self.b, POSITIVE_INFINITY)] = FUNCTION_ONE pdf_output_list = [] dictionary_bounds_function = {} for bounds in sorted(self.cdf.dictionary_bounds_function): a, b = bounds if a in [NEGATIVE_INFINITY, POSITIVE_INFINITY ] or b in [NEGATIVE_INFINITY, POSITIVE_INFINITY]: continue pdf_y_intercept = fabs(self.cdf.derivative((a + b) / 2.0)) pdf_output_list.append(pdf_y_intercept) dictionary_bounds_function[bounds] = FunctionHorizontalLinear( pdf_y_intercept) #dictionary_bounds_function[bounds] = FunctionLinear( # x_0=a, y_0=pdf_y_intercept - pdf_y_intercept / 2.0, # x_1=b, y_1=pdf_y_intercept + pdf_y_intercept / 2.0) self.pdf = FunctionComposite(dictionary_bounds_function, function_undefined=FUNCTION_ZERO, domain=self, is_normalised=True) self.roulette_wheel = [] #center_of_mass_lower_bound = 0 #center_of_mass_set = False self._mean = 0 for bounds in sorted(self.pdf.dictionary_bounds_function): (a, b) = bounds if a in [NEGATIVE_INFINITY, POSITIVE_INFINITY ] and b in [NEGATIVE_INFINITY, POSITIVE_INFINITY]: continue cdf = self.cdf.dictionary_bounds_function[bounds] pdf = self.pdf.dictionary_bounds_function[bounds] share = cdf(b) self.roulette_wheel.append((a, b, share)) #if not center_of_mass_set and share > 0.5: # self._center_of_mass = UnixTime(self._calculate_center_of_mass(center_of_mass_lower_bound, b)) # center_of_mass_set = True #center_of_mass_lower_bound = b self._mean += (a + b) / 2.0 * pdf(a) * (b - a)
def generate_random_events(size=20): from datetime import datetime from spatiotemporal.time_intervals import TimeInterval events = [] year_2010 = TimeInterval(datetime(2010, 1, 1), datetime(2011, 1, 1)) for i in xrange(size): start = year_2010.random_time() end = year_2010.random_time(start) event = TemporalEventTrapezium(start, end) events.append(event) return events
def __init__(self, event_a, event_b, event_c, plt=plt): self.event_a = event_a self.event_c = event_c self.event_b_length_beginning = event_b.beginning - event_b.a self.event_b_length_middle = self.event_b_length_beginning + event_b.ending - event_b.beginning self.event_b_length_total = event_b.b - event_b.ending self.plt = plt self.fig = plt.figure(1) self.ax_a_b = self.fig.add_subplot(4, 1, 1) self.ax_b_c = self.fig.add_subplot(4, 1, 2) self.ax_a_c = self.fig.add_subplot(4, 1, 3) self.ax_relations = self.fig.add_subplot(4, 1, 4) self.ax_a_b.set_xlim(0, 13) self.ax_a_b.set_ylim(0, 1) self.ax_b_c.set_xlim(0, 13) self.ax_b_c.set_ylim(0, 1) self.ax_a_c.set_xlim(0, 13) self.ax_a_c.set_ylim(0, 1) self.rects_a_b = self.ax_a_b.bar(x_axis, zeros_13) self.rects_b_c = self.ax_b_c.bar(x_axis, zeros_13) self.rects_a_c = self.ax_a_c.bar(x_axis, zeros_13) self.line_a = Line2D([], []) self.line_b = Line2D([], []) self.line_c = Line2D([], []) self.ax_relations.add_line(self.line_a) self.ax_relations.add_line(self.line_b) self.ax_relations.add_line(self.line_c) a = min(event_a.a, event_c.a) - self.event_b_length_total b = max(event_a.b, event_c.b) self.ax_relations.set_xlim(a, b + self.event_b_length_total) self.ax_relations.set_ylim(0, 1.1) # self.interval = TimeInterval(a, b, 150) self.interval = TimeInterval(a, b, 2) self.ax_a_b.xaxis.set_minor_formatter( self.ax_a_b.xaxis.get_major_formatter()) self.ax_a_b.xaxis.set_minor_locator(AutoMinorLocator(2)) self.ax_a_b.xaxis.set_ticklabels('poDedOP') self.ax_a_b.xaxis.set_ticklabels('mFsSfM', minor=True) self.ax_b_c.xaxis.set_minor_formatter( self.ax_b_c.xaxis.get_major_formatter()) self.ax_b_c.xaxis.set_minor_locator(AutoMinorLocator(2)) self.ax_b_c.xaxis.set_ticklabels('poDedOP') self.ax_b_c.xaxis.set_ticklabels('mFsSfM', minor=True) self.ax_a_c.xaxis.set_minor_formatter( self.ax_a_c.xaxis.get_major_formatter()) self.ax_a_c.xaxis.set_minor_locator(AutoMinorLocator(2)) self.ax_a_c.xaxis.set_ticklabels('poDedOP') self.ax_a_c.xaxis.set_ticklabels('mFsSfM', minor=True)
def function_convolution(self, dist_1, dist_2, bins=50): a_1, b_1, a_2, b_2 = 0, 0, 0, 0 if dist_1 in self.bounds: a_1, b_1 = self.bounds[dist_1] else: a_1, b_1 = calculate_bounds_of_probability_distribution(dist_1) self.bounds[dist_1] = a_1, b_1 if dist_2 in self.bounds: a_2, b_2 = self.bounds[dist_2] else: a_2, b_2 = calculate_bounds_of_probability_distribution(dist_2) self.bounds[dist_2] = a_2, b_2 if (type(dist_1.dist), type(dist_2.dist)) == (uniform_gen, uniform_gen): return self.function_convolution_uniform((a_1, b_1), (a_2, b_2)) convolution_bounds_a, convolution_bounds_b = min(a_1, a_2), max(b_1, b_2) delta = fabs(convolution_bounds_a - convolution_bounds_b) / bins convolution_interval = TimeInterval(convolution_bounds_a, convolution_bounds_b, bins) x = [dist_1.pdf(t) for t in convolution_interval] y = [dist_2.pdf(t) for t in reversed(convolution_interval)] c = convolve(x, y) dictionary_convolution = {} for t in xrange(len(c)): dictionary_convolution[delta * t] = c[t] bias = calculateCenterMass(dictionary_convolution)[0] + dist_2.mean() - dist_1.mean() dictionary_convolution_biased = {} for t in dictionary_convolution: dictionary_convolution_biased[t - bias] = dictionary_convolution[t] convolution_function = FunctionPiecewiseLinear(dictionary_convolution_biased, FunctionHorizontalLinear(0)) return convolution_function.normalised()
def _interval_from_self_if_none(self, a, b, interval): if interval is None: if (a, b) == (None, None): interval = self else: interval = TimeInterval(a, b) else: assert_is_time_interval(interval) return interval
def __init__(self, dictionary_input_output): cdf_input_list, cdf_output_list = convert_dict_to_sorted_lists(dictionary_input_output) list.__init__(self, cdf_input_list) TimeInterval.__init__(self, self[0], self[-1], 2) self.cdf = FunctionPiecewiseLinear(dictionary_input_output, function_undefined=FUNCTION_ZERO) self.cdf.dictionary_bounds_function[(self.b, POSITIVE_INFINITY)] = FUNCTION_ONE pdf_output_list = [] dictionary_bounds_function = {} for bounds in sorted(self.cdf.dictionary_bounds_function): a, b = bounds if a in [NEGATIVE_INFINITY, POSITIVE_INFINITY] or b in [NEGATIVE_INFINITY, POSITIVE_INFINITY]: continue pdf_y_intercept = fabs(self.cdf.derivative((a + b) / 2.0)) pdf_output_list.append(pdf_y_intercept) dictionary_bounds_function[bounds] = FunctionHorizontalLinear(pdf_y_intercept) #dictionary_bounds_function[bounds] = FunctionLinear( # x_0=a, y_0=pdf_y_intercept - pdf_y_intercept / 2.0, # x_1=b, y_1=pdf_y_intercept + pdf_y_intercept / 2.0) self.pdf = FunctionComposite(dictionary_bounds_function, function_undefined=FUNCTION_ZERO, domain=self, is_normalised=True) self.roulette_wheel = [] #center_of_mass_lower_bound = 0 #center_of_mass_set = False self._mean = 0 for bounds in sorted(self.pdf.dictionary_bounds_function): (a, b) = bounds if a in [NEGATIVE_INFINITY, POSITIVE_INFINITY] and b in [NEGATIVE_INFINITY, POSITIVE_INFINITY]: continue cdf = self.cdf.dictionary_bounds_function[bounds] pdf = self.pdf.dictionary_bounds_function[bounds] share = cdf(b) self.roulette_wheel.append((a, b, share)) #if not center_of_mass_set and share > 0.5: # self._center_of_mass = UnixTime(self._calculate_center_of_mass(center_of_mass_lower_bound, b)) # center_of_mass_set = True #center_of_mass_lower_bound = b self._mean += (a + b) / 2.0 * pdf(a) * (b - a)
def same(self, dist_1, dist_2): dist_1_a, dist_1_b = self.bounds_of(dist_1) dist_2_a, dist_2_b = self.bounds_of(dist_2) a, b = max(dist_1_a, dist_2_a), min(dist_1_b, dist_2_b) interval = TimeInterval(a, b) dictionary_input_output = {} for time_step in interval: dictionary_input_output[time_step] = dist_1.pdf( time_step) * dist_2.pdf(time_step) function = FunctionPiecewiseLinear(dictionary_input_output, FUNCTION_ZERO) return integral(function, a, b)
def __init__(self, distribution_beginning, distribution_ending, bins=50, distribution_integral_limit=DISTRIBUTION_INTEGRAL_LIMIT): 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") if not 0 < distribution_integral_limit <= 1: raise TypeError( "'distribution_integral_limit' should be within (0, 1]") self._distribution_beginning = distribution_beginning self._distribution_ending = distribution_ending a, beginning = calculate_bounds_of_probability_distribution( distribution_beginning, distribution_integral_limit) ending, b = calculate_bounds_of_probability_distribution( distribution_ending, distribution_integral_limit) 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)
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 generate_random_relations_file(size=20): from datetime import datetime from spatiotemporal.time_intervals import TimeInterval csv_writer = csv.writer(open('relations.csv~', 'w')) year_2010 = TimeInterval(datetime(2010, 1, 1), datetime(2011, 1, 1)) i = size specifications = [None, None] while i >= 0: for j in xrange(2): a = year_2010.random_time() beg = year_2010.random_time(start=a) end = year_2010.random_time(start=beg) #(start=a) b = year_2010.random_time(start=end) #(start=max(end, beg)) specifications[j] = (a, b, beg, end) a_beg, a_end = (specifications[0][0], specifications[0][2]), (specifications[0][3], specifications[0][1]) b_beg, b_end = (specifications[1][0], specifications[1][2]), (specifications[1][3], specifications[1][1]) valid = False for bounds_1, bounds_2 in [ (a_beg, b_beg), (a_beg, b_end), (a_end, b_beg), (a_end, b_end) ]: if overlaps(bounds_1, bounds_2): valid = True break if not valid: continue event_1, event_2 = TemporalEventTrapezium(*specifications[0]), TemporalEventTrapezium(*specifications[1]) csv_writer.writerow((event_1 * event_2).to_list()) percentage = (size - i + 1) / float(size) * 100 if (size - i + 1) % 10**3 == 0: print '%' + str(int(percentage)) i -= 1
def __init__(self, dictionary_input_output): cdf_input_list, cdf_output_list = convert_dict_to_sorted_lists( dictionary_input_output) list.__init__(self, cdf_input_list) TimeInterval.__init__(self, self[0], self[-1], 2) self.cdf = FunctionPiecewiseLinear(dictionary_input_output, function_undefined=FUNCTION_ZERO) self.cdf.dictionary_bounds_function[(self.b, POSITIVE_INFINITY)] = FUNCTION_ONE pdf_output_list = [] dictionary_bounds_function = {} for bounds in sorted(self.cdf.dictionary_bounds_function): a, b = bounds if a in [NEGATIVE_INFINITY, POSITIVE_INFINITY ] or b in [NEGATIVE_INFINITY, POSITIVE_INFINITY]: continue pdf_y_intercept = fabs(self.cdf.derivative((a + b) / 2.0)) pdf_output_list.append(pdf_y_intercept) dictionary_bounds_function[bounds] = FunctionHorizontalLinear( pdf_y_intercept) self.pdf = FunctionComposite(dictionary_bounds_function, function_undefined=FUNCTION_ZERO, domain=self, is_normalised=True) self.roulette_wheel = [] self._mean = 0 for bounds in sorted(self.pdf.dictionary_bounds_function): (a, b) = bounds if a in [NEGATIVE_INFINITY, POSITIVE_INFINITY ] and b in [NEGATIVE_INFINITY, POSITIVE_INFINITY]: continue cdf = self.cdf.dictionary_bounds_function[bounds] pdf = self.pdf.dictionary_bounds_function[bounds] share = cdf(b) self.roulette_wheel.append((a, b, share)) self._mean += (a + b) / 2.0 * pdf(a) * (b - a)
def before(self, dist_1, dist_2): a, b = self.bounds_of(dist_1) # Cancel pdf's error a += EPSILON b -= EPSILON interval = TimeInterval(a, b) dictionary_input_output = {} for time_step in interval: dictionary_input_output[time_step] = dist_1.pdf(time_step) * ( 1 - dist_2.cdf(time_step)) function = FunctionPiecewiseLinear(dictionary_input_output, FUNCTION_ZERO) return integral(function, a, b)
def __init__(self, distribution_beginning, distribution_ending, bins=50, distribution_integral_limit=DISTRIBUTION_INTEGRAL_LIMIT): 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") if not 0 < distribution_integral_limit <= 1: raise TypeError("'distribution_integral_limit' should be within (0, 1]") self._distribution_beginning = distribution_beginning self._distribution_ending = distribution_ending a, beginning = calculate_bounds_of_probability_distribution(distribution_beginning, distribution_integral_limit) ending, b = calculate_bounds_of_probability_distribution(distribution_ending, distribution_integral_limit) 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)
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 function_cosine(self, dist_1, dist_2, bins=50): a1, b1, a2, b2 = 0, 0, 0, 0 if dist_1 in self.bounds: a1, b1 = self.bounds[dist_1] else: a1, b1 = calculate_bounds_of_probability_distribution(dist_1) self.bounds[dist_1] = a1, b1 if dist_2 in self.bounds: a2, b2 = self.bounds[dist_2] else: a2, b2 = calculate_bounds_of_probability_distribution(dist_2) self.bounds[dist_2] = a2, b2 cosine_bounds_a, cosine_bounds_b = min(a1, a2), max(b1, b2) delta = fabs(cosine_bounds_a - cosine_bounds_b) / bins convolution_interval = TimeInterval(cosine_bounds_a, cosine_bounds_b, bins) #convolution_interval = linspace(cosine_bounds_a, cosine_bounds_b, bins) x = [dist_1.pdf(t) for t in convolution_interval] y = [dist_2.pdf(t) for t in convolution_interval] return cosine(x, y)
def __repr__(self): return TimeInterval.__repr__(self)
def __init__(self, a, b): TimeInterval.__init__(self, a, b, 1)
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)
class TemporalEvent(list, TimeInterval): _distribution_beginning = None _distribution_ending = None _beginning = None _ending = None _dict = None _formula_creator = FormulaCreator(TemporalFormulaConvolution()) def __init__(self, distribution_beginning, distribution_ending, bins=50, distribution_integral_limit=DISTRIBUTION_INTEGRAL_LIMIT): 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") if not 0 < distribution_integral_limit <= 1: raise TypeError("'distribution_integral_limit' should be within (0, 1]") self._distribution_beginning = distribution_beginning self._distribution_ending = distribution_ending a, beginning = calculate_bounds_of_probability_distribution(distribution_beginning, distribution_integral_limit) ending, b = calculate_bounds_of_probability_distribution(distribution_ending, distribution_integral_limit) 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) 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)
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)