def filter_on_case_size(log, min_case_size=2, max_case_size=None):
"""
Get only traces in the log with a given size
Parameters
-----------
log
Log
min_case_size
Minimum desidered size of traces
max_case_size
Maximum desidered size of traces
Returns
-----------
filtered_log
Filtered log
"""
if max_case_size is not None:
filtered_log = EventLog([
trace for trace in log
if min_case_size <= len(trace) <= max_case_size
])
else:
filtered_log = EventLog(
[trace for trace in log if len(trace) >= min_case_size])
return filtered_log
def apply_variants_filter(log, admitted_variants, parameters=None):
"""
Filter log keeping/removing only provided variants
Parameters
-----------
log
Log object
admitted_variants
Admitted variants
parameters
Parameters of the algorithm, including:
activity_key -> Attribute identifying the activity in the log
positive -> Indicate if events should be kept/removed
"""
if parameters is None:
parameters = {}
positive = exec_utils.get_param_value(Parameters.POSITIVE, parameters,
True)
variants = variants_statistics.get_variants(log, parameters=parameters)
log = EventLog()
for variant in variants:
if (positive and variant in admitted_variants) or (
not positive and variant not in admitted_variants):
for trace in variants[variant]:
log.append(trace)
return log
def apply_tree_variants(variants, parameters=None):
"""
Apply the IM_F algorithm to a dictionary of variants obtaining a process tree
Parameters
----------
variants
Variants
parameters
Parameters of the algorithm, including:
Parameters.ACTIVITY_KEY -> attribute of the log to use as activity name
(default concept:name)
Returns
----------
process_tree
Process tree
"""
log = EventLog()
activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY,
parameters,
xes_constants.DEFAULT_NAME_KEY)
var_keys = list(variants.keys())
for var in var_keys:
val = variants[var]
if type(val) is list:
val = len(val)
for i in range(val):
trace = variants_util.variant_to_trace(var, parameters=parameters)
log.append(trace)
return apply_tree(log, parameters=parameters)
def filter_log_by_start_activities(start_activities,
variants,
vc,
threshold,
activity_key="concept:name"):
"""
Keep only variants of the log with a start activity which number of occurrences is above the threshold
Parameters
----------
start_activities
Dictionary of start attributes associated with their count
variants
(If specified) Dictionary with variant as the key and the list of traces as the value
vc
List of variant names along with their count
threshold
Cutting threshold (remove variants having start attributes which number of occurrences is below the threshold
activity_key
(If specified) Specify the activity key in the log (default concept:name)
Returns
----------
filtered_log
Filtered log
"""
filtered_log = EventLog()
fvsa = variants[vc[0][0]][0][0][activity_key]
for variant in variants:
vsa = variants[variant][0][0][activity_key]
if vsa in start_activities:
if vsa == fvsa or start_activities[vsa] >= threshold:
for trace in variants[variant]:
filtered_log.append(trace)
return filtered_log
def project(log, groups, activity_key):
'''
This method projects the log based on a presumed sequence cut and a list of activity groups
Parameters
----------
log
original log
groups
list of activity sets to be used in projection (activities can only appear in one group)
activity_key
key to use in the event to derive the activity name
Returns
-------
list of corresponding logs according to the sequence cut.
'''
# currently, not 'noise' proof
logs = list()
for group in groups:
proj = EventLog()
for t in log:
proj.append(
pm4py.filter_trace(lambda e: e[activity_key] in group, t))
logs.append(proj)
return logs
def apply(log, admitted_start_activities, parameters=None):
"""
Filter the log on the specified start activities
Parameters
-----------
log
log
admitted_start_activities
Admitted start activities
parameters
Algorithm parameters
Returns
-----------
filtered_log
Filtered log
"""
if parameters is None:
parameters = {}
attribute_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, DEFAULT_NAME_KEY)
positive = exec_utils.get_param_value(Parameters.POSITIVE, parameters, True)
if positive:
filtered_log = EventLog(
[trace for trace in log if trace and trace[0][attribute_key] in admitted_start_activities],
attributes=log.attributes, extensions=log.extensions, classifiers=log.classifiers,
omni_present=log.omni_present, properties=log.properties)
else:
filtered_log = EventLog(
[trace for trace in log if trace and trace[0][attribute_key] not in admitted_start_activities],
attributes=log.attributes, extensions=log.extensions, classifiers=log.classifiers,
omni_present=log.omni_present, properties=log.properties)
return filtered_log
def filter_on_case_size(log: EventLog, min_case_size: int = 2, max_case_size=None) -> EventLog:
"""
Get only traces in the log with a given size
Parameters
-----------
log
Log
min_case_size
Minimum desidered size of traces
max_case_size
Maximum desidered size of traces
Returns
-----------
filtered_log
Filtered log
"""
log = log_converter.apply(log, variant=log_converter.Variants.TO_EVENT_LOG)
if max_case_size is not None:
filtered_log = EventLog([trace for trace in log if min_case_size <= len(trace) <= max_case_size])
else:
filtered_log = EventLog([trace for trace in log if len(trace) >= min_case_size])
return filtered_log
def apply(log, admitted_variants, parameters=None):
"""
Filter log keeping/removing only provided variants
Parameters
-----------
log
Log object
admitted_variants
Admitted variants
parameters
Parameters of the algorithm, including:
Parameters.ACTIVITY_KEY -> Attribute identifying the activity in the log
Parameters.POSITIVE -> Indicate if events should be kept/removed
"""
if parameters is None:
parameters = {}
positive = exec_utils.get_param_value(Parameters.POSITIVE, parameters,
True)
variants = get_variants(log, parameters=parameters)
log = EventLog(list(),
attributes=log.attributes,
extensions=log.extensions,
classifiers=log.classifiers,
omni_present=log.omni_present,
properties=log.properties)
for variant in variants:
if (positive and variant in admitted_variants) or (
not positive and variant not in admitted_variants):
for trace in variants[variant]:
log.append(trace)
return log
def keep_one_trace_per_variant(log, parameters=None):
"""
Keeps only one trace per variant (does not matter for basic inductive miner)
Parameters
--------------
log
Log
parameters
Parameters of the algorithm
Returns
--------------
new_log
Log (with one trace per variant)
"""
if parameters is None:
parameters = {}
new_log = EventLog()
if log is not None:
variants = variants_module.get_variants(log, parameters=parameters)
for var in variants:
new_log.append(variants[var][0])
return new_log
def apply_from_variants_list(var_list, parameters=None):
"""
Discovers the log skeleton from the variants list
Parameters
---------------
var_list
Variants list
parameters
Parameters
Returns
---------------
model
Log skeleton model
"""
if parameters is None:
parameters = {}
log = EventLog()
for cv in var_list:
v = cv[0]
trace = variants_util.variant_to_trace(v, parameters=parameters)
log.append(trace)
return apply(log, parameters=parameters)
def detect(log: EventLog, alphabet: Dict[str, int], act_key: str, use_msd: bool) -> Optional[str]:
candidates = set(alphabet.keys())
for t in log:
candidates = candidates.intersection(set(map(lambda e: e[act_key], t)))
if len(candidates) == 0:
return None
for a in candidates:
proj = EventLog()
for t in log:
proj.append(pm4py.filter_trace(lambda e: e[act_key] != a, t))
if len(list(filter(lambda t: len(t) == 0, proj))) == 0:
dfg_proj = discover_dfg.apply(proj, parameters={
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: act_key})
alphabet_proj = pm4py.get_event_attribute_values(proj, act_key)
start_act_proj = get_starters.get_start_activities(proj, parameters={
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: act_key})
end_act_proj = get_ends.get_end_activities(log, parameters={
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: act_key})
pre_proj, post_proj = dfg_utils.get_transitive_relations(dfg_proj, alphabet_proj)
cut = sequence_cut.detect(alphabet_proj, pre_proj, post_proj)
if cut is not None:
return a
cut = xor_cut.detect(dfg_proj, alphabet_proj)
if cut is not None:
return a
cut = concurrent_cut.detect(dfg_proj, alphabet_proj, start_act_proj, end_act_proj,
msd= msdw_algo.derive_msd_witnesses(proj, msd_algo.apply(log, parameters={
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: act_key}), parameters={
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: act_key}) if use_msd else None)
if cut is not None:
return a
cut = loop_cut.detect(dfg_proj, alphabet_proj, start_act_proj, end_act_proj)
if cut is not None:
return a
return None
def apply(df, parameters=None):
"""
Convert a dataframe into a log containing 1 case per variant (only control-flow
perspective is considered)
Parameters
-------------
df
Dataframe
parameters
Parameters of the algorithm
Returns
-------------
log
Event log
"""
from pm4py.statistics.traces.pandas import case_statistics
if parameters is None:
parameters = {}
variant_stats = case_statistics.get_variant_statistics(df, parameters=parameters)
activity_key = parameters[
pm4_constants.PARAMETER_CONSTANT_ACTIVITY_KEY] if pm4_constants.PARAMETER_CONSTANT_ACTIVITY_KEY in parameters else xes.DEFAULT_NAME_KEY
log = EventLog()
for vd in variant_stats:
variant = vd['variant'].split(",")
trace = Trace()
for activity in variant:
event = Event()
event[activity_key] = activity
trace.append(event)
log.append(trace)
return log
def apply_from_variants_list(var_list, tree, parameters=None):
"""
Apply the alignments from the specification of a list of variants in the log
Parameters
-------------
var_list
List of variants (for each item, the first entry is the variant itself, the second entry may be the number of cases)
tree
Process tree
parameters
Parameters of the algorithm
Returns
--------------
dictio_alignments
Dictionary that assigns to each variant its alignment
"""
if parameters is None:
parameters = {}
dictio_alignments = {}
log = EventLog()
for index, varitem in enumerate(var_list):
trace = variants_util.variant_to_trace(varitem[0], parameters=parameters)
log.append(trace)
alignments = apply(log, tree, parameters=parameters)
for index, varitem in enumerate(var_list):
dictio_alignments[varitem[0]] = alignments[index]
return dictio_alignments
def __align(obj: Union[Trace, EventLog],
pt: ProcessTree,
max_trace_length: int = 1,
max_process_tree_height: int = 1,
parameters=None):
"""
this function approximates alignments for a given event log or trace and a process tree
:param obj: event log or single trace
:param pt: process tree
:param max_trace_length: specifies when the recursive splitting stops based on the trace's length
:param max_process_tree_height: specifies when the recursive splitting stops based on the tree's height
:return:
"""
assert isinstance(pt, ProcessTree)
if isinstance(obj, Trace):
e = EventLog()
e.append(obj)
obj = e
assert isinstance(obj, EventLog)
pt = process_tree_to_binary_process_tree(pt)
pt = EfficientTree(pt)
return __approximate_alignments_for_log(obj,
pt,
max_trace_length,
max_process_tree_height,
parameters=parameters)
def update_merge(loglist):
mergedlog = EventLog()
for i in range(len(loglist)):
for trace in loglist[i]:
mergedlog.append(trace)
return mergedlog
def apply_tree_variants(variants, parameters=None):
"""
Apply the IM algorithm to a dictionary of variants obtaining a process tree
Parameters
----------
variants
Variants
parameters
Parameters of the algorithm, including:
Parameters.ACTIVITY_KEY -> attribute of the log to use as activity name
(default concept:name)
Returns
----------
process_tree
Process tree
"""
log = EventLog()
activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY,
parameters,
xes_constants.DEFAULT_NAME_KEY)
var_keys = list(variants.keys())
for var in var_keys:
trace = Trace()
activities = variants_util.get_activities_from_variant(var)
for act in activities:
trace.append(Event({activity_key: act}))
log.append(trace)
return apply_tree(log, parameters=parameters)
def apply(tree: ProcessTree, parameters : Optional[Dict[Union[str, Parameters], Any]] = None) -> EventLog:
"""
Performs an extensive playout of the process tree
Parameters
-------------
tree
Process tree
parameters
Possible parameters, including:
- Parameters.MIN_TRACE_LENGTH => minimum length of a trace (default: 1)
- Parameters.MAX_TRACE_LENGTH => maximum length of a trace (default: min_allowed_trace_length)
- Parameters.MAX_LOOP_OCC => maximum number of occurrences for a loop (default: MAX_TRACE_LENGTH)
- Parameters.ACTIVITY_KEY => activity key
- Parameters.MAX_LIMIT_NUM_TRACES => maximum number to the limit of traces; the playout shall stop when the number is reached (default: 100000)
Returns
-------------
log
Event log
"""
if parameters is None:
parameters = {}
activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes_constants.DEFAULT_NAME_KEY)
# to save memory in the returned log, allocate each activity once. to know the list of activities of the
# process tree, use the footprints module
fp_tree = fp_discovery.apply(tree, parameters=parameters)
activities = fp_tree["activities"]
activities = {act: Event({activity_key: act}) for act in activities}
min_allowed_trace_length = bottomup_discovery.get_min_trace_length(tree, parameters=parameters)
min_trace_length = exec_utils.get_param_value(Parameters.MIN_TRACE_LENGTH, parameters, 1)
max_trace_length = exec_utils.get_param_value(Parameters.MAX_TRACE_LENGTH, parameters, min_allowed_trace_length)
max_loop_occ = exec_utils.get_param_value(Parameters.MAX_LOOP_OCC, parameters, int(max_trace_length / 2))
max_limit_num_traces = exec_utils.get_param_value(Parameters.MAX_LIMIT_NUM_TRACES, parameters, 100000)
return_set_strings = exec_utils.get_param_value(Parameters.RETURN_SET_STRINGS, parameters, False)
bottomup = bottomup_discovery.get_bottomup_nodes(tree, parameters=parameters)
min_rem_dict = bottomup_discovery.get_min_rem_dict(tree, parameters=parameters)
max_rem_dict = bottomup_discovery.get_max_rem_dict(tree, parameters=parameters)
playout_dictio = {}
for i in range(len(bottomup)):
get_playout(bottomup[i], playout_dictio, min_trace_length, max_trace_length, max_loop_occ, min_rem_dict,
max_rem_dict, max_limit_num_traces)
tree_playout_traces = playout_dictio[tree][TRACES]
if return_set_strings:
return tree_playout_traces
log = EventLog()
for tr0 in tree_playout_traces:
trace = Trace()
for act in tr0:
trace.append(activities[act])
log.append(trace)
return log
def project(log, groups, activity_key):
logs = list()
for group in groups:
proj = EventLog()
for t in log:
proj.append(
pm4py.filter_trace(lambda e: e[activity_key] in group, t))
logs.append(proj)
return logs
def interaction_two_resources(
log: EventLog,
t1: Union[datetime, str],
t2: Union[datetime, str],
r1: str,
r2: str,
parameters: Optional[Dict[Union[str, Parameters],
Any]] = None) -> float:
"""
The number of cases completed during a given time slot in which two given resources were involved.
Metric RBI 5.1 in Pika, Anastasiia, et al.
"Mining resource profiles from event logs." ACM Transactions on Management Information Systems (TMIS) 8.1 (2017): 1-30.
Parameters
-----------------
log
Event log
t1
Left interval
t2
Right interval
r1
Resource 1
r2
Resource 2
Returns
----------------
metric
Value of the metric
"""
if parameters is None:
parameters = {}
t1 = get_dt_from_string(t1)
t2 = get_dt_from_string(t2)
timestamp_key = exec_utils.get_param_value(
Parameters.TIMESTAMP_KEY, parameters,
xes_constants.DEFAULT_TIMESTAMP_KEY)
resource_key = exec_utils.get_param_value(
Parameters.RESOURCE_KEY, parameters,
xes_constants.DEFAULT_RESOURCE_KEY)
from pm4py.algo.filtering.log.attributes import attributes_filter
parameters_filter = {
attributes_filter.Parameters.ATTRIBUTE_KEY: resource_key
}
log = attributes_filter.apply(log, [r1], parameters=parameters_filter)
log = attributes_filter.apply(log, [r2], parameters=parameters_filter)
red_log = EventLog()
for trace in log:
if trace:
if t1 <= trace[-1][timestamp_key] < t2:
red_log.append(trace)
return len(red_log)
def apply(
log: EventLog,
value: Any,
parameters: Optional[Dict[Union[str, Parameters],
Any]] = None) -> EventLog:
"""
Filters the trace of the log where the given attribute value is repeated
(in a range of repetitions that is specified by the user)
Parameters
----------------
log
Event log
value
Value that is investigated
parameters
Parameters of the filter, including:
- Parameters.ATTRIBUTE_KEY => the attribute key
- Parameters.MIN_REP => minimum number of repetitions
- Parameters.MAX_REP => maximum number of repetitions
Returns
----------------
filtered_log
Filtered log
"""
if parameters is None:
parameters = {}
log = converter.apply(log,
variant=converter.Variants.TO_EVENT_LOG,
parameters=parameters)
attribute_key = exec_utils.get_param_value(Parameters.ATTRIBUTE_KEY,
parameters,
xes_constants.DEFAULT_NAME_KEY)
min_rep = exec_utils.get_param_value(Parameters.MIN_REP, parameters, 2)
max_rep = exec_utils.get_param_value(Parameters.MAX_REP, parameters,
sys.maxsize)
filtered_log = EventLog(list(),
attributes=log.attributes,
extensions=log.extensions,
classifiers=log.classifiers,
omni_present=log.omni_present,
properties=log.properties)
for trace in log:
rep = 0
for event in trace:
if attribute_key in event and event[attribute_key] == value:
rep += 1
if min_rep <= rep <= max_rep:
filtered_log.append(trace)
return filtered_log
def execute_script():
log = xes_importer.apply(os.path.join("..", "tests", "input_data", "receipt.xes"))
log = sorting.sort_timestamp(log)
net, im, fm = inductive_miner.apply(log)
log1 = EventLog(log[:500])
log2 = EventLog(log[len(log) - 500:])
statistics = element_usage_comparison.compare_element_usage_two_logs(net, im, fm, log1, log2)
gviz = pn_vis.apply(net, im, fm, variant=pn_vis.Variants.FREQUENCY, aggregated_statistics=statistics,
parameters={pn_vis.Variants.FREQUENCY.value.Parameters.FORMAT: "svg"})
pn_vis.view(gviz)
def apply(
log: EventLog,
admitted_start_activities: List[str],
parameters: Optional[Dict[Union[str, Parameters],
Any]] = None) -> EventLog:
"""
Filter the log on the specified start activities
Parameters
-----------
log
log
admitted_start_activities
Admitted start activities
parameters
Algorithm parameters
Returns
-----------
filtered_log
Filtered log
"""
if parameters is None:
parameters = {}
log = log_converter.apply(log,
variant=log_converter.Variants.TO_EVENT_LOG,
parameters=parameters)
attribute_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY,
parameters, DEFAULT_NAME_KEY)
positive = exec_utils.get_param_value(Parameters.POSITIVE, parameters,
True)
if positive:
filtered_log = EventLog([
trace for trace in log
if trace and trace[0][attribute_key] in admitted_start_activities
],
attributes=log.attributes,
extensions=log.extensions,
classifiers=log.classifiers,
omni_present=log.omni_present,
properties=log.properties)
else:
filtered_log = EventLog([
trace for trace in log if trace
and trace[0][attribute_key] not in admitted_start_activities
],
attributes=log.attributes,
extensions=log.extensions,
classifiers=log.classifiers,
omni_present=log.omni_present,
properties=log.properties)
return filtered_log
def apply(df, parameters=None):
"""
Convert a dataframe into a log containing N case per variant (only control-flow
perspective is considered)
Parameters
-------------
df
Dataframe
parameters
Parameters of the algorithm
Returns
-------------
log
Event log
"""
from pm4py.statistics.traces.pandas import case_statistics
if parameters is None:
parameters = {}
return_variants = parameters[
RETURN_VARIANTS] if RETURN_VARIANTS in parameters else False
case_glue = parameters[
pm4_constants.
PARAMETER_CONSTANT_CASEID_KEY] if pm4_constants.PARAMETER_CONSTANT_CASEID_KEY in parameters else pm4_constants.CASE_CONCEPT_NAME
activity_key = parameters[
pm4_constants.
PARAMETER_CONSTANT_ACTIVITY_KEY] if pm4_constants.PARAMETER_CONSTANT_ACTIVITY_KEY in parameters else xes.DEFAULT_NAME_KEY
variant_stats = case_statistics.get_variant_statistics(
df, parameters=parameters)
log = EventLog()
all_variants_log = {}
for vd in variant_stats:
variant = vd['variant'].split(",")
variant_count = vd[case_glue]
trace = Trace()
for activity in variant:
event = Event()
event[activity_key] = activity
trace.append(event)
all_variants_log[vd['variant']] = []
for i in range(variant_count):
log.append(trace)
all_variants_log[vd['variant']].append(len(log) - 1)
if return_variants:
return log, all_variants_log
return log
def apply(log: EventLog, act1: str, act2: str, parameters: Optional[Dict[Union[str, Parameters], Any]] = None) -> EventLog:
"""
Given an event log, filters all the subtraces going from an event with activity "act1" to an event with
activity "act2"
Parameters
----------------
log
Event log
act1
First activity
act2
Second activity
parameters
Parameters of the algorithm, including:
- Parameters.ACTIVITY_KEY => activity key
Returns
----------------
filtered_log
Log with all the subtraces going from "act1" to "act2"
"""
if parameters is None:
parameters = {}
log = log_converter.apply(log, variant=log_converter.Variants.TO_EVENT_LOG, parameters=parameters)
activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes_constants.DEFAULT_NAME_KEY)
filtered_log = EventLog(attributes=log.attributes, extensions=log.extensions, omni_present=log.omni_present,
classifiers=log.classifiers, properties=log.properties)
for trace in log:
act1_encountered = False
filt_trace = None
i = 0
while i < len(trace) - 1:
if not act1_encountered and trace[i][activity_key] == act1:
act1_encountered = True
filt_trace = Trace(attributes=trace.attributes)
filt_trace.append(trace[i])
elif act1_encountered and trace[i][activity_key] == act2:
filt_trace.append(trace[i])
filtered_log.append(filt_trace)
act1_encountered = False
filt_trace = None
elif filt_trace is not None:
filt_trace.append(trace[i])
i = i + 1
return filtered_log
def filter_log_by_attributes_threshold(log,
attributes,
variants,
vc,
threshold,
attribute_key=xes.DEFAULT_NAME_KEY):
"""
Keep only attributes which number of occurrences is above the threshold (or they belong to the first variant)
Parameters
----------
log
Log
attributes
Dictionary of attributes associated with their count
variants
(If specified) Dictionary with variant as the key and the list of traces as the value
vc
List of variant names along with their count
threshold
Cutting threshold (remove attributes which number of occurrences is below the threshold)
attribute_key
(If specified) Specify the activity key in the log (default concept:name)
Returns
----------
filtered_log
Filtered log
"""
filtered_log = EventLog(list(),
attributes=log.attributes,
extensions=log.extensions,
classifiers=log.classifiers,
omni_present=log.omni_present,
properties=log.properties)
fva = [
x[attribute_key] for x in variants[vc[0][0]][0] if attribute_key in x
]
for trace in log:
new_trace = Trace()
for j in range(len(trace)):
if attribute_key in trace[j]:
attribute_value = trace[j][attribute_key]
if attribute_value in attributes:
if (attribute_value in fva
and attribute_key == xes.DEFAULT_NAME_KEY
) or attributes[attribute_value] >= threshold:
new_trace.append(trace[j])
if len(new_trace) > 0:
for attr in trace.attributes:
new_trace.attributes[attr] = trace.attributes[attr]
filtered_log.append(new_trace)
return filtered_log
def apply(
log: EventLog,
paths: List[Tuple[str, str]],
parameters: Optional[Dict[Union[str, Parameters],
Any]] = None) -> EventLog:
"""
Apply a filter on traces containing / not containing a path
Parameters
-----------
log
Log
paths
Paths that we are looking for (expressed as tuple of 2 strings)
parameters
Parameters of the algorithm, including:
Parameters.ATTRIBUTE_KEY -> Attribute identifying the activity in the log
Parameters.POSITIVE -> Indicate if events should be kept/removed
Returns
-----------
filtered_log
Filtered log
"""
if parameters is None:
parameters = {}
log = log_converter.apply(log,
variant=log_converter.Variants.TO_EVENT_LOG,
parameters=parameters)
attribute_key = exec_utils.get_param_value(Parameters.ATTRIBUTE_KEY,
parameters,
xes.DEFAULT_NAME_KEY)
positive = exec_utils.get_param_value(Parameters.POSITIVE, parameters,
True)
filtered_log = EventLog(list(),
attributes=log.attributes,
extensions=log.extensions,
classifiers=log.classifiers,
omni_present=log.omni_present,
properties=log.properties)
for trace in log:
found = False
for i in range(len(trace) - 1):
path = (trace[i][attribute_key], trace[i + 1][attribute_key])
if path in paths:
found = True
break
if (found and positive) or (not found and not positive):
filtered_log.append(trace)
return filtered_log
def split(log: EventLog, train_percentage: float = 0.8) -> Tuple[EventLog, EventLog]:
"""
Split an event log in a training log and a test log (for machine learning purposes)
Parameters
--------------
log
Event log
train_percentage
Fraction of traces to be included in the training log (from 0.0 to 1.0)
Returns
--------------
training_log
Training event log
test_log
Test event log
"""
idxs = [i for i in range(len(log))]
random.shuffle(idxs)
stop_idx = math.floor(len(idxs) * train_percentage) + 1
idxs_train = idxs[:stop_idx]
idxs_test = idxs[stop_idx:]
train_log = EventLog(list(), attributes=log.attributes, extensions=log.extensions, classifiers=log.classifiers,
omni_present=log.omni_present, properties=log.properties)
test_log = EventLog(list(), attributes=log.attributes, extensions=log.extensions, classifiers=log.classifiers,
omni_present=log.omni_present, properties=log.properties)
for idx in idxs_train:
train_log.append(log[idx])
for idx in idxs_test:
test_log.append(log[idx])
return train_log, test_log
def project(log: EventLog, activity: str, activity_key: str) -> List[EventLog]:
proj = EventLog()
proj_act = EventLog()
for t in log:
proj.append(pm4py.filter_trace(lambda e: e[activity_key] != activity, t))
proj_act.append(pm4py.filter_trace(lambda e: e[activity_key] == activity, t))
return [proj_act, proj]
def filter_log_traces_attr(log, values, parameters=None):
"""
Filter log by keeping only traces that has/has not events with an attribute value that belongs to the provided
values list
Parameters
-----------
log
Trace log
values
Allowed attributes
parameters
Parameters of the algorithm, including:
activity_key -> Attribute identifying the activity in the log
positive -> Indicate if events should be kept/removed
Returns
-----------
filtered_log
Filtered log
"""
# CODE SAVING FROM FILTERS
if parameters is None:
parameters = {}
attribute_key = exec_utils.get_param_value(Parameters.ATTRIBUTE_KEY, parameters, DEFAULT_NAME_KEY)
positive = exec_utils.get_param_value(Parameters.POSITIVE, parameters, True)
filtered_log = EventLog()
for trace in log:
new_trace = Trace()
found = False
for j in range(len(trace)):
if attribute_key in trace[j]:
attribute_value = trace[j][attribute_key]
if attribute_value in values:
found = True
if (found and positive) or (not found and not positive):
new_trace = trace
else:
for attr in trace.attributes:
new_trace.attributes[attr] = trace.attributes[attr]
if len(new_trace) > 0:
filtered_log.append(new_trace)
return filtered_log
def apply_trace_attributes(log, list_of_values, parameters=None):
"""
Filter log by keeping only traces that has/has not certain case attribute value that belongs to the provided
values list
Parameters
-----------
log
Trace log
values
Allowed attribute values(if it's numerical value, [] is needed to make it a list)
parameters
Parameters of the algorithm, including:
activity_key -> Attribute identifying the case in the log
positive -> Indicate if events should be kept/removed
Returns
-----------
filtered_log
Filtered log
"""
if parameters is None:
parameters = {}
attribute_key = exec_utils.get_param_value(Parameters.ATTRIBUTE_KEY,
parameters, DEFAULT_NAME_KEY)
positive = exec_utils.get_param_value(Parameters.POSITIVE, parameters,
True)
filtered_log = EventLog()
for trace in log:
new_trace = Trace()
found = False
if attribute_key in trace.attributes:
attribute_value = trace.attributes[attribute_key]
if attribute_value in list_of_values:
found = True
if (found and positive) or (not found and not positive):
new_trace = trace
else:
for attr in trace.attributes:
new_trace.attributes[attr] = trace.attributes[attr]
if len(new_trace) > 0:
filtered_log.append(new_trace)
return filtered_log
