def execute_script():
log_input_directory = "xesinput"
all_logs_names = os.listdir(log_input_directory)
all_logs_names = [log for log in all_logs_names if ".xe" in log]
for logName in all_logs_names:
# logPath = os.path.join("..", "tests", "inputData", logName)
log_path = log_input_directory + "\\" + logName
log = xes_importer.import_log(log_path)
print("\n\n")
print("log loaded")
print("Number of traces - ", len(log))
event_log = log_conv_fact.apply(log,
variant=log_conv_fact.TO_EVENT_STREAM)
print("Number of events - ", len(event_log))
print("Classifiers ", log.classifiers)
exp_log_name = "xescert_exportlogs" + "\\" + "exp_" + logName
print("exporting log", exp_log_name)
xes_exporter.export_log(log, exp_log_name)
print("exported log", exp_log_name)
log, classifier_attr_key = insert_classifier.search_act_class_attr(log)
classifiers = list(log.classifiers.keys())
if classifier_attr_key is None and classifiers:
try:
print(classifiers)
log, classifier_attr_key = insert_classifier.insert_activity_classifier_attribute(
log, classifiers[0])
print(classifier_attr_key)
except:
print("exception in handling classifier")
if classifier_attr_key is None:
classifier_attr_key = "concept:name"
if len(event_log) > 0 and classifier_attr_key in event_log[0]:
parameters = {
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: classifier_attr_key
}
dfg = dfg_factory.apply(log, parameters=parameters)
gviz = dfg_vis_factory.apply(dfg,
log=log,
variant="frequency",
parameters=parameters)
# dfg_vis_factory.view(gviz)
dfg_vis_factory.save(
gviz, "xescert_images\\" + logName.replace("xes", "png"))
print("Reimporting log file just exported - ", exp_log_name)
log = xes_importer.import_log(exp_log_name)
print("log loaded", exp_log_name)
print("Number of traces - ", len(log))
event_log = log_conv_fact.apply(log,
variant=log_conv_fact.TO_EVENT_STREAM)
print("Number of events - ", len(event_log))
print("Classifiers ", log.classifiers)
def build_from_path(self, path, parameters=None):
"""
Builds the handler from the specified path to XES file
Parameters
-------------
path
Path to the log file
parameters
Parameters of the algorithm
"""
if parameters is None:
parameters = {}
try:
# try faster non standard importer
self.log = xes_importer.apply(path, variant="nonstandard")
if len(self.log) == 0:
# non standard imported failed
self.log = xes_importer.apply(path)
except:
# revert to classic importer
self.log = xes_importer.apply(path)
self.log, classifier_key = insert_classifier.search_act_class_attr(
self.log, force_activity_transition_insertion=True)
self.activity_key = xes.DEFAULT_NAME_KEY
if classifier_key is not None:
self.activity_key = classifier_key
self.build_variants()
self.calculate_variants_number()
self.calculate_cases_number()
self.calculate_events_number()
def build_from_path(self, path, parameters=None):
"""
Builds the handler from the specified path to XES file
Parameters
-------------
path
Path to the log file
parameters
Parameters of the algorithm
"""
if parameters is None:
parameters = {}
self.log = xes_importer.apply(path)
self.log, classifier_key = insert_classifier.search_act_class_attr(self.log,
force_activity_transition_insertion=True)
self.activity_key = xes.DEFAULT_NAME_KEY
if classifier_key is not None:
self.activity_key = classifier_key
# sorts the traces and the events in the log
#self.log = sorting.sort_timestamp_log(self.log)
self.build_variants()
self.calculate_variants_number()
self.calculate_cases_number()
self.calculate_events_number()
# inserts the event and the case index attributes
self.insert_event_index()
f.write("\t")
f.write(get_elonged_float(simplicity_imdf[this_logname]))
f.write("\n")
f.write("\n")
f.close()
for logName in os.listdir(logFolder):
if "." in logName:
logNamePrefix = logName.split(".")[0]
print("\nelaborating " + logName)
logPath = os.path.join(logFolder, logName)
log = xes_factory.import_log(logPath, variant="iterparse")
log, classifier_key = insert_classifier.search_act_class_attr(log)
print("loaded log")
activity_key = "concept:name"
if classifier_key is not None:
activity_key = classifier_key
parameters_discovery = {
pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY: activity_key,
pmutil.constants.PARAMETER_CONSTANT_ATTRIBUTE_KEY: activity_key
}
t1 = time.time()
alpha_model, alpha_initial_marking, alpha_final_marking = alpha.apply(
log, parameters=parameters_discovery)
pnml_exporter.export_net(alpha_model,
def apply(log, parameters=None, classic_output=False):
"""
Gets a simple model out of a log
Parameters
-------------
log
Trace log
parameters
Parameters of the algorithm, including:
maximum_number_activities -> Maximum number of activities to keep
discovery_algorithm -> Discovery algorithm to use (alpha, inductive)
desidered_output -> Desidered output of the algorithm (default: Petri)
include_filtered_log -> Include the filtered log in the output
include_dfg_frequency -> Include the DFG of frequencies in the output
include_dfg_performance -> Include the DFG of performance in the output
include_filtered_dfg_frequency -> Include the filtered DFG of frequencies in the output
include_filtered_dfg_performance -> Include the filtered DFG of performance in the output
classic_output
Determine if the output shall contains directly the objects (e.g. net, initial_marking, final_marking)
or can return a more detailed dictionary
"""
if parameters is None:
parameters = {}
returned_dictionary = {}
net = None
initial_marking = None
final_marking = None
bpmn_graph = None
dfg_frequency = None
dfg_performance = None
filtered_dfg_frequency = None
filtered_dfg_performance = None
maximum_number_activities = parameters[
"maximum_number_activities"] if "maximum_number_activities" in parameters else 20
discovery_algorithm = parameters["discovery_algorithm"] if "discovery_algorithm" in parameters else "alpha"
desidered_output = parameters["desidered_output"] if "desidered_output" in parameters else "petri"
include_filtered_log = parameters["include_filtered_log"] if "include_filtered_log" in parameters else True
include_dfg_frequency = parameters["include_dfg_frequency"] if "include_dfg_frequency" in parameters else True
include_dfg_performance = parameters[
"include_dfg_performance"] if "include_dfg_performance" in parameters else False
include_filtered_dfg_frequency = parameters[
"include_filtered_dfg_frequency"] if "include_filtered_dfg_frequency" in parameters else True
include_filtered_dfg_performance = parameters[
"include_filtered_dfg_performance"] if "include_filtered_dfg_performance" in parameters else False
if PARAMETER_CONSTANT_ATTRIBUTE_KEY in parameters:
activity_key = parameters[
PARAMETER_CONSTANT_ATTRIBUTE_KEY] if PARAMETER_CONSTANT_ATTRIBUTE_KEY in parameters else DEFAULT_NAME_KEY
parameters[PARAMETER_CONSTANT_ATTRIBUTE_KEY] = activity_key
else:
log, activity_key = insert_classifier.search_act_class_attr(log)
if activity_key is None:
activity_key = DEFAULT_NAME_KEY
parameters[PARAMETER_CONSTANT_ATTRIBUTE_KEY] = activity_key
if PARAMETER_CONSTANT_ACTIVITY_KEY not in parameters:
parameters[PARAMETER_CONSTANT_ACTIVITY_KEY] = parameters[PARAMETER_CONSTANT_ATTRIBUTE_KEY]
activities_count_dictio = attributes_filter.get_attribute_values(log, activity_key)
activities_count_list = []
for activity in activities_count_dictio:
activities_count_list.append([activity, activities_count_dictio[activity]])
activities_count_list = sorted(activities_count_list, key=lambda x: x[1], reverse=True)
activities_count_list = activities_count_list[:min(len(activities_count_list), maximum_number_activities)]
activities_keep_list = [x[0] for x in activities_count_list]
log = attributes_filter.apply(log, activities_keep_list, parameters=parameters)
filtered_log = None
if "alpha" in discovery_algorithm:
# parameters_sa = deepcopy(parameters)
# parameters_sa["decreasingFactor"] = 1.0
filtered_log = start_activities_filter.apply_auto_filter(log, parameters=parameters)
filtered_log = end_activities_filter.apply_auto_filter(filtered_log, parameters=parameters)
filtered_log = filter_topvariants_soundmodel.apply(filtered_log, parameters=parameters)
elif "dfg_mining" in discovery_algorithm:
filtered_log = start_activities_filter.apply_auto_filter(log, parameters=parameters)
filtered_log = end_activities_filter.apply_auto_filter(filtered_log, parameters=parameters)
filtered_log = auto_filter.apply_auto_filter(filtered_log, parameters=parameters)
if include_dfg_frequency or "dfg_mining" in discovery_algorithm:
dfg_frequency = dfg_factory.apply(log, parameters=parameters, variant="frequency")
if include_dfg_performance:
dfg_performance = dfg_factory.apply(log, parameters=parameters, variant="performance")
if include_filtered_dfg_frequency:
filtered_dfg_frequency = dfg_factory.apply(filtered_log, parameters=parameters, variant="frequency")
if include_filtered_dfg_performance:
filtered_dfg_performance = dfg_factory.apply(filtered_log, parameters=parameters, variant="performance")
if "alpha" in discovery_algorithm:
net, initial_marking, final_marking = alpha_miner.apply(filtered_log, parameters=parameters)
elif "dfg_mining" in discovery_algorithm:
start_activities = start_activities_filter.get_start_activities(filtered_log, parameters=parameters)
end_activities = end_activities_filter.get_end_activities(filtered_log, parameters=parameters)
parameters_conv = {}
parameters_conv["start_activities"] = start_activities
parameters_conv["end_activities"] = end_activities
net, initial_marking, final_marking = dfg_conv_factory.apply(dfg_frequency, parameters=parameters_conv)
if filtered_log is not None and include_filtered_log:
returned_dictionary["filtered_log"] = filtered_log
if net is not None and desidered_output == "petri":
returned_dictionary["net"] = net
if initial_marking is not None and desidered_output == "petri":
returned_dictionary["initial_marking"] = initial_marking
if final_marking is not None and desidered_output == "petri":
returned_dictionary["final_marking"] = final_marking
if bpmn_graph is not None and desidered_output == "bpmn":
returned_dictionary["bpmn_graph"] = bpmn_graph
if dfg_frequency is not None and include_dfg_frequency:
returned_dictionary["dfg_frequency"] = dfg_frequency
if dfg_performance is not None and include_dfg_performance:
returned_dictionary["dfg_performance"] = dfg_performance
if filtered_dfg_frequency is not None and include_filtered_dfg_frequency:
returned_dictionary["filtered_dfg_frequency"] = filtered_dfg_frequency
if filtered_dfg_performance is not None and include_filtered_dfg_performance:
returned_dictionary["filtered_dfg_performance"] = filtered_dfg_performance
if classic_output:
if net is not None and desidered_output == "petri":
return net, initial_marking, final_marking
return returned_dictionary
f.write("\n")
f.close()
for logName in os.listdir(logFolder):
if "." in logName:
logNamePrefix = logName.split(".")[0]
logExtension = logName[len(logNamePrefix) + 1:]
print("\nelaborating " + logName)
logPath = os.path.join(logFolder, logName)
if "xes" in logExtension:
log = xes_importer.apply(logPath, variant=xes_importer.Variants.ITERPARSE)
log, classifier_key = insert_classifier.search_act_class_attr(log, force_activity_transition_insertion=True)
print("loaded log")
activity_key = "concept:name"
if classifier_key is not None:
activity_key = classifier_key
parameters_discovery = {pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY: activity_key,
pmutil.constants.PARAMETER_CONSTANT_ATTRIBUTE_KEY: activity_key}
t1 = time.time()
alpha_model, alpha_initial_marking, alpha_final_marking = alpha.apply(log, parameters=parameters_discovery)
if ENABLE_PETRI_EXPORTING:
pnml_exporter.export_net(alpha_model, alpha_initial_marking,
os.path.join(pnmlFolder, logNamePrefix + "_alpha.pnml"),
final_marking=alpha_final_marking)
