def discretize_property(self, prop_df):
if prop_df.empty:
return DataframesGenerator.generate_empty_states(
), DataframesGenerator.generate_empty_symbolic_time_series()
prop_id = prop_df[DatasetColumns.TemporalPropertyID].values[0]
return self.__states[self.__states[StatesColumns.TemporalPropertyID] == prop_id], \
KnowledgeBased.knowledge_based(self.__states, prop_df)
def temporal_abstraction_per_property(self,
dataset,
entity_class_relations=None,
states=None):
if dataset.empty:
return DataframesGenerator.generate_empty_states(
), DataframesGenerator.generate_empty_symbolic_time_series()
symbolic_time_series = [
AbstractionPerProperty.__generate_abstraction_by_name(
row[1], entity_class_relations,
states).discretize_property(dataset[dataset[
DatasetColumns.TemporalPropertyID] == row[1][
TemporalAbstractionParamsColumns.TemporalPropertyID]])
for row in self.__temporal_abstraction_params_df.iterrows()
]
""" It counts the number of states and accumulates them to re-index the StateID column """
state_ids_ctr = reduce(
lambda acc, new: acc + [acc[-1] + new[0].shape[0]],
symbolic_time_series, [0])
""" For each given states df, it re-indexes the StateID to start from the last max StateID + 1
to avoid collisions between states ids """
def reindex_states(tmp_states, states_ctr):
return {
StatesColumns.StateID:
tmp_states[StatesColumns.StateID] + states_ctr -
(tmp_states[StatesColumns.StateID].min() - 1)
}
""" Just a map to update and re-assign the StateID column """
symbolic_time_series = [
(tmp_states.assign(**reindex_states(tmp_states, states_ctr)),
sts.assign(**reindex_states(sts, states_ctr)))
for ((tmp_states, sts),
states_ctr) in zip(symbolic_time_series, state_ids_ctr)
]
""" Concatenating the data-frames one after the other """
combined_symbolic_time_series = pd.concat(
[p[1] for p in symbolic_time_series], ignore_index=True)
combined_states = pd.concat([p[0] for p in symbolic_time_series],
ignore_index=True)
return combined_states, combined_symbolic_time_series
def discretize_property(self, prop_df):
"""
A template method in which the only change between algorithms is the _generate_cutpoints method
which is common to all child classes.
Each discretization method creates cutpoints in a different way
:param prop_df: Dataframe, A time-point series of a single property
:return: Tuple, (Dataframe , Dataframe) - states, , and the symbolic-point-series created from prop_df
"""
if prop_df.empty:
return DataframesGenerator.generate_empty_states(), DataframesGenerator.generate_empty_symbolic_time_series()
cutpoints = self._generate_cutpoints(prop_df)
# in case it is td4c or persist, they also return a list of bins scores
if len(cutpoints) == 2 and type(cutpoints[0]) is list:
cutpoints, scores = cutpoints
else:
scores = np.full(len(cutpoints), nan)
states = Discretization.create_prop_states(prop_df[DatasetColumns.TemporalPropertyID].values[0],
cutpoints, scores)
symbolic_point_series = TemporalAbstraction.create_symbolic_time_series(states, prop_df)
return states, symbolic_point_series