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 apply_from_variants_list(var_list, model, parameters=None):
"""
Performs conformance checking using the log skeleton,
applying it from a list of variants
Parameters
--------------
var_list
List of variants
model
Log skeleton model
parameters
Parameters
Returns
--------------
conformance_dictio
Dictionary containing, for each variant, the result
of log skeleton checking
"""
if parameters is None:
parameters = {}
conformance_output = {}
for cv in var_list:
v = cv[0]
trace = variants_util.variant_to_trace(v, parameters=parameters)
conformance_output[v] = apply_trace(trace,
model,
parameters=parameters)
return conformance_output
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 apply_from_variant(variant,
petri_net,
initial_marking,
final_marking,
parameters=None):
"""
Apply the alignments from the specification of a single variant
Parameters
-------------
variant
Variant (as string delimited by the "variant_delimiter" parameter)
petri_net
Petri net
initial_marking
Initial marking
final_marking
Final marking
parameters
Parameters of the algorithm (same as 'apply' method, plus 'variant_delimiter' that is , by default)
Returns
------------
dictionary: `dict` with keys **alignment**, **cost**, **visited_states**, **queued_states**
"""
if parameters is None:
parameters = {}
trace = variants_util.variant_to_trace(variant, parameters=parameters)
return apply(trace,
petri_net,
initial_marking,
final_marking,
parameters=parameters)
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 apply_from_variants_list(var_list,
petri_net,
initial_marking,
final_marking,
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)
petri_net
Petri net
initial_marking
Initial marking
final_marking
Final marking
parameters
Parameters of the algorithm (same as 'apply' method, plus 'variant_delimiter' that is , by default)
Returns
--------------
dictio_alignments
Dictionary that assigns to each variant its alignment
"""
if parameters is None:
parameters = {}
log = log_implementation.EventLog()
dictio_alignments = {}
for varitem in var_list:
variant = varitem[0]
trace = variants_util.variant_to_trace(variant, parameters=parameters)
log.append(trace)
alignment = apply(log, petri_net, initial_marking, final_marking)
for index, varitem in enumerate(var_list):
variant = varitem[0]
dictio_alignments[variant] = alignment[index]
return dictio_alignments
def apply_tree_variants(variants, parameters=None):
if parameters is None:
parameters = {}
log = EventLog()
threshold = exec_utils.get_param_value(Parameters.NOISE_THRESHOLD,
parameters, 0.0)
var_keys = list(variants.keys())
for var in var_keys:
val = variants[var]
if type(val) is list:
val = len(val)
if threshold == 0.0:
# the inductive miner without noise needs only 1 trace per variant
val = 1
for i in range(val):
trace = variants_util.variant_to_trace(var, parameters=parameters)
log.append(trace)
return apply_tree(log, parameters=parameters)
def apply_from_variant(variant, dfg, sa, ea, parameters=None):
if parameters is None:
parameters = {}
trace = variants_util.variant_to_trace(variant, parameters=parameters)
return apply_trace(trace, dfg, sa, ea, parameters=parameters)
