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_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 __imd_internal(dfg_sa_ea_actcount, threshold, root, remove_noise=False):
alphabet = dfg_sa_ea_actcount.act_count.keys()
if len(dfg_sa_ea_actcount.act_count) > 0 and len(
dfg_sa_ea_actcount.dfg) == 0:
return __base_case(dfg_sa_ea_actcount, root)
if threshold > 0 and remove_noise:
dfg = __filter_dfg_on_threshold(dfg_sa_ea_actcount.dfg,
dfg_sa_ea_actcount.end_activities,
threshold)
dfg_sa_ea_actcount = DfgSaEaActCount(
dfg, dfg_sa_ea_actcount.start_activities,
dfg_sa_ea_actcount.end_activities, dfg_sa_ea_actcount.act_count)
alphabet = dfg_sa_ea_actcount.act_count.keys()
pre, post = dfg_utils.get_transitive_relations(dfg_sa_ea_actcount.dfg,
alphabet)
cut = sequence_cut.detect(alphabet, pre, post)
if cut is not None:
dfgs, skippable = sequence_cut.project_dfg(dfg_sa_ea_actcount, cut)
return __add_subdfgs(dfgs, skippable, threshold, root,
pt.Operator.SEQUENCE)
cut = xor_cut.detect(dfg_sa_ea_actcount.dfg, alphabet)
if cut is not None:
dfgs, skippable = xor_cut.project_dfg(dfg_sa_ea_actcount, cut)
return __add_subdfgs(dfgs, skippable, threshold, root, pt.Operator.XOR)
cut = concurrent_cut.detect(dfg_sa_ea_actcount.dfg, alphabet,
dfg_sa_ea_actcount.start_activities,
dfg_sa_ea_actcount.end_activities)
if cut is not None:
dfgs, skippable = concurrent_cut.project_dfg(dfg_sa_ea_actcount, cut)
return __add_subdfgs(dfgs, skippable, threshold, root,
pt.Operator.PARALLEL)
cut = loop_cut.detect(dfg_sa_ea_actcount.dfg, alphabet,
dfg_sa_ea_actcount.start_activities,
dfg_sa_ea_actcount.end_activities)
if cut is not None:
dfgs, skippable = loop_cut.project_dfg(dfg_sa_ea_actcount, cut)
return __add_subdfgs(dfgs, skippable, threshold, root,
pt.Operator.LOOP)
if threshold > 0 and not remove_noise:
return __imd(dfg_sa_ea_actcount, threshold, root, remove_noise=True)
return __flower(alphabet, root)
def __inductive_miner_internal(log,
dfg,
threshold,
root,
act_key,
use_msd,
remove_noise=False):
alphabet = pm4py.get_event_attribute_values(log, act_key)
if threshold > 0 and remove_noise:
end_activities = get_ends.get_end_activities(
log,
parameters={constants.PARAMETER_CONSTANT_ACTIVITY_KEY: act_key})
dfg = __filter_dfg_on_threshold(dfg, end_activities, threshold)
original_length = len(log)
log = pm4py.filter_log(lambda t: len(t) > 0, log)
# revised EMPTYSTRACES
if original_length - len(log) > original_length * threshold:
return __add_operator_recursive_logs(
pt.ProcessTree(pt.Operator.XOR, root), threshold, act_key,
[EventLog(), log], use_msd)
start_activities = get_starters.get_start_activities(
log, parameters={constants.PARAMETER_CONSTANT_ACTIVITY_KEY: act_key})
end_activities = get_ends.get_end_activities(
log, parameters={constants.PARAMETER_CONSTANT_ACTIVITY_KEY: act_key})
if __is_base_case_act(log, act_key) or __is_base_case_silent(log):
return __apply_base_case(log, root, act_key)
pre, post = dfg_utils.get_transitive_relations(dfg, alphabet)
cut = sequence_cut.detect(alphabet, pre, post)
if cut is not None:
return __add_operator_recursive_logs(
pt.ProcessTree(pt.Operator.SEQUENCE, root), threshold, act_key,
sequence_cut.project(log, cut, act_key), use_msd)
cut = xor_cut.detect(dfg, alphabet)
if cut is not None:
return __add_operator_recursive_logs(
pt.ProcessTree(pt.Operator.XOR, root), threshold, act_key,
xor_cut.project(log, cut, act_key), use_msd)
cut = concurrent_cut.detect(
dfg,
alphabet,
start_activities,
end_activities,
msd=msdw_algo.derive_msd_witnesses(
log,
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 __add_operator_recursive_logs(
pt.ProcessTree(pt.Operator.PARALLEL, root), threshold, act_key,
concurrent_cut.project(log, cut, act_key), use_msd)
cut = loop_cut.detect(dfg, alphabet, start_activities, end_activities)
if cut is not None:
return __add_operator_recursive_logs(
pt.ProcessTree(pt.Operator.LOOP, root), threshold, act_key,
loop_cut.project(log, cut, act_key), use_msd)
aopt = activity_once_per_trace.detect(log, alphabet, act_key)
if aopt is not None:
operator = pt.ProcessTree(operator=pt.Operator.PARALLEL, parent=root)
operator.children.append(
pt.ProcessTree(operator=None, parent=operator, label=aopt))
return __add_operator_recursive_logs(
operator, threshold, act_key,
activity_once_per_trace.project(log, aopt, act_key), use_msd)
act_conc = activity_concurrent.detect(log, alphabet, act_key, use_msd)
if act_conc is not None:
return __add_operator_recursive_logs(
pt.ProcessTree(pt.Operator.PARALLEL, root), threshold, act_key,
activity_concurrent.project(log, act_conc, act_key), use_msd)
stl = strict_tau_loop.detect(log, start_activities, end_activities,
act_key)
if stl is not None:
return __add_operator_recursive_logs(
pt.ProcessTree(pt.Operator.LOOP, root), threshold, act_key,
[stl, EventLog()], use_msd)
tl = tau_loop.detect(log, start_activities, act_key)
if tl is not None:
return __add_operator_recursive_logs(
pt.ProcessTree(pt.Operator.LOOP, root), threshold, act_key,
[tl, EventLog()], use_msd)
if threshold > 0 and not remove_noise:
return __inductive_miner(log,
dfg,
threshold,
root,
act_key,
use_msd,
remove_noise=True)
return __flower(alphabet, root)
def inductive_miner(log, dfg, threshold, root, act_key, use_msd):
alphabet = pm4py.get_attribute_values(log, act_key)
start_activities = get_starters.get_start_activities(
log, parameters={constants.PARAMETER_CONSTANT_ACTIVITY_KEY: act_key})
end_activities = get_ends.get_end_activities(
log, parameters={constants.PARAMETER_CONSTANT_ACTIVITY_KEY: act_key})
empty_traces = pm4py.filter_log(lambda trace: len(trace) == 0, log)
if len(empty_traces) == 0:
if _is_base_case_act(log, act_key) or _is_base_case_silent(log):
return _apply_base_case(log, root, act_key)
pre, post = dfg_utils.get_transitive_relations(dfg, alphabet)
cut = sequence_cut.detect(alphabet, pre, post)
if cut is not None:
return _add_operator_recursive(
pt.ProcessTree(pt.Operator.SEQUENCE, root), threshold, act_key,
sequence_cut.project(log, cut, act_key), use_msd)
cut = xor_cut.detect(dfg, alphabet)
if cut is not None:
return _add_operator_recursive(
pt.ProcessTree(pt.Operator.XOR, root), threshold, act_key,
xor_cut.project(log, cut, act_key), use_msd)
cut = concurrent_cut.detect(
dfg,
alphabet,
start_activities,
end_activities,
msd=msdw_algo.derive_msd_witnesses(
log,
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 _add_operator_recursive(
pt.ProcessTree(pt.Operator.PARALLEL, root), threshold, act_key,
concurrent_cut.project(log, cut, act_key), use_msd)
cut = loop_cut.detect(dfg, alphabet, start_activities, end_activities)
if cut is not None:
return _add_operator_recursive(
pt.ProcessTree(pt.Operator.LOOP, root), threshold, act_key,
loop_cut.project(log, cut, act_key), use_msd)
if len(empty_traces) > 0:
nempty = pm4py.filter_log(lambda t: len(t) > 0, log)
return _add_operator_recursive(pt.ProcessTree(pt.Operator.XOR,
root), threshold,
act_key, [EventLog(), nempty], use_msd)
aopt = activity_once_per_trace.detect(log, alphabet, act_key)
if aopt is not None:
operator = pt.ProcessTree(operator=pt.Operator.PARALLEL, parent=root)
operator.children.append(
pt.ProcessTree(operator=None, parent=operator, label=aopt))
return _add_operator_recursive(
operator, threshold, act_key,
activity_once_per_trace.project(log, aopt, act_key), use_msd)
act_conc = activity_concurrent.detect(log, alphabet, act_key, use_msd)
if act_conc is not None:
return _add_operator_recursive(
pt.ProcessTree(pt.Operator.PARALLEL, root), threshold, act_key,
activity_concurrent.project(log, act_conc, act_key), use_msd)
stl = strict_tau_loop.detect(log, start_activities, end_activities,
act_key)
if stl is not None:
return _add_operator_recursive(pt.ProcessTree(pt.Operator.LOOP,
root), threshold,
act_key, [stl, EventLog()], use_msd)
tl = tau_loop.detect(log, start_activities, act_key)
if tl is not None:
return _add_operator_recursive(pt.ProcessTree(pt.Operator.LOOP,
root), threshold,
act_key, [tl, EventLog()], use_msd)
return _flower(alphabet, root)