def execute_script(variant="frequency"):
# read the log using the nonstandard importer (faster)
log_path = os.path.join("..", "tests", "input_data", "receipt.xes")
log = xes_importer.import_log(log_path, variant="nonstandard")
# applies Inductive Miner on the log
net, initial_marking, final_marking = inductive_miner.apply(log)
# find shortest paths in the net
spaths = get_shortest_paths(net)
# then we start to decorate the net
# we decide if we should decorate it with frequency or performance
# we decide the aggregation measure (sum, min, max, mean, median, stdev)
aggregation_measure = "mean"
if variant == "frequency":
aggregation_measure = "sum"
# we find the DFG
dfg = dfg_factory.apply(log, variant=variant)
# we find the number of activities occurrences in the log
activities_count = attributes_filter.get_attribute_values(log, "concept:name")
# we calculate the statistics on the Petri net applying the greedy algorithm
aggregated_statistics = get_decorations_from_dfg_spaths_acticount(net, dfg, spaths,
activities_count,
variant=variant,
aggregation_measure=aggregation_measure)
# we find the gviz
gviz = pn_vis_factory.apply(net, initial_marking, final_marking, variant=variant,
aggregated_statistics=aggregated_statistics, parameters={"format": "svg"})
# we show the viz on screen
pn_vis_factory.view(gviz)
def calculate_process_schema_from_df(dataframe, path_frequency,
path_performance):
activities_count = attributes_filter.get_attribute_values(
dataframe, attribute_key=ACTIVITY_KEY)
[dfg_frequency, dfg_performance
] = df_statistics.get_dfg_graph(dataframe,
measure="both",
perf_aggregation_key="median",
case_id_glue=CASEID_GLUE,
activity_key=ACTIVITY_KEY,
timestamp_key=TIMEST_KEY,
sort_caseid_required=False)
net, initial_marking, final_marking = inductive_factory.apply_dfg(
dfg_frequency)
spaths = vis_trans_shortest_paths.get_shortest_paths(net)
aggregated_statistics = vis_trans_shortest_paths.get_decorations_from_dfg_spaths_acticount(
net, dfg_frequency, spaths, activities_count, variant="frequency")
parameters_viz = {"format": "svg"}
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
variant="frequency",
aggregated_statistics=aggregated_statistics,
parameters=parameters_viz)
pn_vis_factory.save(gviz, path_frequency)
aggregated_statistics = vis_trans_shortest_paths.get_decorations_from_dfg_spaths_acticount(
net, dfg_performance, spaths, activities_count, variant="performance")
parameters_viz = {"format": "svg"}
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
variant="performance",
aggregated_statistics=aggregated_statistics,
parameters=parameters_viz)
pn_vis_factory.save(gviz, path_performance)
def transient_analysis_from_dataframe(df, delay, parameters=None):
"""
Gets the transient analysis from a dataframe and a delay
Parameters
-------------
df
Pandas dataframe
delay
Time delay
parameters
Parameters of the algorithm
Returns
-------------
transient_result
Transient analysis result
"""
if parameters is None:
parameters = {}
activity_key = parameters[
constants.
PARAMETER_CONSTANT_ACTIVITY_KEY] if constants.PARAMETER_CONSTANT_ACTIVITY_KEY in parameters else xes.DEFAULT_NAME_KEY
case_id_glue = parameters[
constants.
PARAMETER_CONSTANT_CASEID_KEY] if constants.PARAMETER_CONSTANT_CASEID_KEY in parameters else CASE_CONCEPT_NAME
timestamp_key = parameters[
constants.
PARAMETER_CONSTANT_TIMESTAMP_KEY] if constants.PARAMETER_CONSTANT_TIMESTAMP_KEY in parameters else xes.DEFAULT_TIMESTAMP_KEY
log = log_conv_factory.apply(df,
variant=log_conv_factory.DF_TO_EVENT_LOG_1V,
parameters=parameters)
# gets the simple Petri net through simple miner
net, im, fm = simple_factory.apply(log,
parameters=parameters,
classic_output=True)
activities_count = dict(df.groupby(activity_key).size())
dfg_performance = df_statistics.get_dfg_graph(df,
measure="performance",
perf_aggregation_key="mean",
case_id_glue=case_id_glue,
activity_key=activity_key,
timestamp_key=timestamp_key)
spaths = get_shortest_paths(net)
aggregated_statistics = get_decorations_from_dfg_spaths_acticount(
net, dfg_performance, spaths, activities_count, variant="performance")
# gets the stochastic map out of the dataframe and the Petri net
s_map = smap_builder.get_map_exponential_from_aggstatistics(
aggregated_statistics, parameters=parameters)
return transient_analysis_from_petri_net_and_smap(net,
im,
s_map,
delay,
parameters=parameters)
def apply_through_conv_greedy(bpmn_graph,
dfg,
activities_count,
log=None,
aggregated_statistics=None,
parameters=None):
"""
Decorate BPMN graph through conversion to Petri net, using shortest paths in the Petri net
Parameters
-------------
bpmn_graph
BPMN graph
dfg
Directly-Follows graph
activities_count
Count of occurrences of the activities
log
Log object
aggregated_statistics
Aggregated statistics object
parameters
Possible parameters of the algorithm
Returns
-------------
file_name
Path of the figure in which the rendered BPMN has been saved
"""
if parameters is None:
parameters = {}
del log
del aggregated_statistics
image_format = parameters["format"] if "format" in parameters else "png"
net, initial_marking, final_marking, elements_correspondence, inv_elements_correspondence, el_corr_keys_map = \
bpmn_to_petri.apply(bpmn_graph)
spaths = vis_trans_shortest_paths.get_shortest_paths(net,
enable_extension=True)
aggregated_statistics = vis_trans_shortest_paths.get_decorations_from_dfg_spaths_acticount(
net, dfg, spaths, activities_count, variant="performance")
bpmn_aggreg_statistics = convert_performance_map.convert_performance_map_to_bpmn(
aggregated_statistics, inv_elements_correspondence)
file_name = bpmn_diagram_to_figure(
bpmn_graph,
image_format,
bpmn_aggreg_statistics=bpmn_aggreg_statistics)
return file_name
def get_decorated_net(net, initial_marking, final_marking, log, parameters=None, variant="frequency"):
"""
Get a decorated net according to the specified variant (decorate Petri net based on DFG)
Parameters
------------
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
log
Log to use to decorate the Petri net
parameters
Algorithm parameters
variant
Specify if the decoration should take into account the frequency or the performance
Returns
------------
gviz
GraphViz object
"""
if parameters is None:
parameters = {}
aggregation_measure = exec_utils.get_param_value(Parameters.AGGREGATION_MEASURE, parameters,
"sum" if "frequency" in variant else "mean")
activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes.DEFAULT_NAME_KEY)
stat_locale = exec_utils.get_param_value(Parameters.STAT_LOCALE, parameters, {})
# we find the DFG
if variant == "performance":
dfg = performance.performance(log, parameters=parameters)
else:
dfg = native.native(log, parameters=parameters)
# we find shortest paths
spaths = get_shortest_paths(net)
# we find the number of activities occurrences in the log
activities_count = attr_get.get_attribute_values(log, activity_key, parameters=parameters)
aggregated_statistics = get_decorations_from_dfg_spaths_acticount(net, dfg, spaths,
activities_count,
variant=variant,
aggregation_measure=aggregation_measure,
stat_locale=stat_locale)
return visualize.apply(net, initial_marking, final_marking, parameters=parameters,
decorations=aggregated_statistics)
def apply_embedding_greedy(bpmn_graph,
dfg,
activities_count,
log=None,
aggregated_statistics=None,
parameters=None):
"""
Embed decoration information inside the BPMN graph
Parameters
-----------
bpmn_graph
BPMN graph
dfg
Directly-Follows graph
activities_count
Count of occurrences of the activities
log
Log object
aggregated_statistics
Aggregated statistics object
parameters
Possible parameters of the algorithm
Returns
-----------
bpmn_graph
Annotated BPMN graph
"""
del parameters
del log
del aggregated_statistics
net, initial_marking, final_marking, elements_correspondence, inv_elements_correspondence, el_corr_keys_map = \
bpmn_to_petri.apply(bpmn_graph)
spaths = vis_trans_shortest_paths.get_shortest_paths(net,
enable_extension=True)
aggregated_statistics = vis_trans_shortest_paths.get_decorations_from_dfg_spaths_acticount(
net, dfg, spaths, activities_count, variant="performance")
bpmn_aggreg_statistics = convert_performance_map.convert_performance_map_to_bpmn(
aggregated_statistics, inv_elements_correspondence)
bpmn_graph = bpmn_embedding.embed_info_into_bpmn(bpmn_graph,
bpmn_aggreg_statistics,
"performance")
return bpmn_graph
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "running-example.csv")
dataframe = pandas_df_imp.import_dataframe_from_path(log_path)
activities_count = dict(dataframe.groupby("concept:name").size())
[dfg_frequency, dfg_performance] = df_statistics.get_dfg_graph(dataframe, measure="both",
perf_aggregation_key="mean")
net, initial_marking, final_marking = alpha_miner.apply_dfg(dfg_frequency)
spaths = get_shortest_paths(net)
aggregated_statistics = get_decorations_from_dfg_spaths_acticount(net, dfg_performance,
spaths,
activities_count,
variant="performance")
# obtain stochastic information for transitions in the model
s_map = stochastic_map.get_map_exponential_from_aggstatistics(aggregated_statistics)
# gets the reachability graph from the Petri net
reachab_graph = construct_reachability_graph(net, initial_marking)
# get the tangible reachability graph from the reachability graph and the stochastic map
tang_reach_graph = tangible_reachability.get_tangible_reachability_from_reachability(reachab_graph, s_map)
# visualize the tangible reachability graph on the screen
viz = ts_vis_factory.apply(tang_reach_graph, parameters={"format": "svg", "show_labels": True, "show_names": True})
ts_vis_factory.view(viz)
# gets the Q matrix assuming exponential distributions
q_matrix = ctmc.get_q_matrix_from_tangible_exponential(tang_reach_graph, s_map)
# pick a state to start from
states = sorted(list(tang_reach_graph.states), key=lambda x: x.name)
state = states[0]
print("\n\nstarting from state = ", state.name)
# do transient analysis after 1 day
transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state(tang_reach_graph, q_matrix,
state, 86400)
print("\nprobability for each state after 1 day = ", transient_result)
# do transient analysis after 10 days
transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state(tang_reach_graph, q_matrix,
state, 864000)
print("\nprobability for each state after 10 days = ", transient_result)
# do transient analysis after 100 days
transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state(tang_reach_graph, q_matrix,
state, 8640000)
print("\nprobability for each state after 100 days = ", transient_result)
steady_state = ctmc.steadystate_analysis_from_tangible_q_matrix(tang_reach_graph, q_matrix)
print("\nsteady state = ", steady_state)
def apply(dataframe, parameters=None):
"""
Gets the Petri net through Inductive Miner, decorated by performance metric
Parameters
------------
dataframe
Dataframe
parameters
Parameters of the algorithm
Returns
------------
base64
Base64 of an SVG representing the model
model
Text representation of the model
format
Format of the model
"""
if parameters is None:
parameters = {}
decreasingFactor = parameters[
"decreasingFactor"] if "decreasingFactor" in parameters else constants.DEFAULT_DEC_FACTOR
activity_key = parameters[
pm4_constants.
PARAMETER_CONSTANT_ACTIVITY_KEY] if pm4_constants.PARAMETER_CONSTANT_ACTIVITY_KEY in parameters else xes.DEFAULT_NAME_KEY
timestamp_key = parameters[
pm4_constants.
PARAMETER_CONSTANT_TIMESTAMP_KEY] if pm4_constants.PARAMETER_CONSTANT_TIMESTAMP_KEY in parameters else xes.DEFAULT_TIMESTAMP_KEY
case_id_glue = parameters[
pm4_constants.
PARAMETER_CONSTANT_CASEID_KEY] if pm4_constants.PARAMETER_CONSTANT_CASEID_KEY in parameters else CASE_CONCEPT_NAME
parameters[pm4_constants.RETURN_EA_COUNT_DICT_AUTOFILTER] = True
dataframe = attributes_filter.filter_df_keeping_spno_activities(
dataframe,
activity_key=activity_key,
max_no_activities=constants.MAX_NO_ACTIVITIES)
dataframe, end_activities = auto_filter.apply_auto_filter(
dataframe, parameters=parameters)
end_activities = list(end_activities.keys())
activities_count = attributes_filter.get_attribute_values(
dataframe, activity_key, parameters=parameters)
activities = list(activities_count.keys())
start_activities = list(
start_activities_filter.get_start_activities(
dataframe, parameters=parameters).keys())
[dfg, dfg_perf
] = df_statistics.get_dfg_graph(dataframe,
activity_key=activity_key,
timestamp_key=timestamp_key,
case_id_glue=case_id_glue,
sort_caseid_required=False,
sort_timestamp_along_case_id=False,
measure="both")
dfg = clean_dfg_based_on_noise_thresh(
dfg,
activities,
decreasingFactor * constants.DEFAULT_DFG_CLEAN_MULTIPLIER,
parameters=parameters)
dfg_perf = {x: y for x, y in dfg_perf.items() if x in dfg}
net, im, fm = inductive_miner.apply_dfg(dfg,
parameters,
activities=activities,
start_activities=start_activities,
end_activities=end_activities)
spaths = get_shortest_paths(net)
bpmn_graph, el_corr, inv_el_corr, el_corr_keys_map = petri_to_bpmn.apply(
net, im, fm)
aggregated_statistics = get_decorations_from_dfg_spaths_acticount(
net, dfg_perf, spaths, activities_count, variant="performance")
bpmn_aggreg_statistics = convert_performance_map.convert_performance_map_to_bpmn(
aggregated_statistics, inv_el_corr)
#bpmn_graph = bpmn_embedding.embed_info_into_bpmn(bpmn_graph, bpmn_aggreg_statistics, "performance")
bpmn_graph = bpmn_diagram_layouter.apply(bpmn_graph)
bpmn_string = bpmn_exporter.get_string_from_bpmn(bpmn_graph)
gviz = bpmn_vis_factory.apply_petri(
net,
im,
fm,
aggregated_statistics=aggregated_statistics,
variant="performance",
parameters={"format": "svg"})
gviz2 = bpmn_vis_factory.apply_petri(
net,
im,
fm,
aggregated_statistics=aggregated_statistics,
variant="performance",
parameters={"format": "dot"})
gviz_base64 = get_base64_from_file(gviz2.name)
ret_graph = get_graph.get_graph_from_petri(net, im, fm)
return get_base64_from_file(gviz.name), export_petri_as_string(
net, im, fm
), ".pnml", "parquet", activities, start_activities, end_activities, gviz_base64, ret_graph, "indbpmn", "perf", bpmn_string, ".bpmn", activity_key
def apply(dataframe, parameters=None):
"""
Gets the Petri net through Inductive Miner, decorated by frequency metric
Parameters
------------
dataframe
Dataframe
parameters
Parameters of the algorithm
Returns
------------
base64
Base64 of an SVG representing the model
model
Text representation of the model
format
Format of the model
"""
if parameters is None:
parameters = {}
decreasingFactor = parameters[
"decreasingFactor"] if "decreasingFactor" in parameters else constants.DEFAULT_DEC_FACTOR
activity_key = parameters[
pm4_constants.
PARAMETER_CONSTANT_ACTIVITY_KEY] if pm4_constants.PARAMETER_CONSTANT_ACTIVITY_KEY in parameters else xes.DEFAULT_NAME_KEY
timestamp_key = parameters[
pm4_constants.
PARAMETER_CONSTANT_TIMESTAMP_KEY] if pm4_constants.PARAMETER_CONSTANT_TIMESTAMP_KEY in parameters else xes.DEFAULT_TIMESTAMP_KEY
case_id_glue = parameters[
pm4_constants.
PARAMETER_CONSTANT_CASEID_KEY] if pm4_constants.PARAMETER_CONSTANT_CASEID_KEY in parameters else CASE_CONCEPT_NAME
parameters[pm4_constants.RETURN_EA_COUNT_DICT_AUTOFILTER] = True
dataframe = attributes_filter.filter_df_keeping_spno_activities(
dataframe,
activity_key=activity_key,
max_no_activities=constants.MAX_NO_ACTIVITIES)
dataframe, end_activities = auto_filter.apply_auto_filter(
dataframe, parameters=parameters)
end_activities = list(end_activities.keys())
activities_count = attributes_filter.get_attribute_values(
dataframe, activity_key, parameters=parameters)
activities = list(activities_count.keys())
start_activities = list(
start_activities_filter.get_start_activities(
dataframe, parameters=parameters).keys())
dfg = df_statistics.get_dfg_graph(dataframe,
activity_key=activity_key,
timestamp_key=timestamp_key,
case_id_glue=case_id_glue,
sort_caseid_required=False,
sort_timestamp_along_case_id=False)
dfg = clean_dfg_based_on_noise_thresh(
dfg,
activities,
decreasingFactor * constants.DEFAULT_DFG_CLEAN_MULTIPLIER,
parameters=parameters)
net, im, fm = inductive_miner.apply_dfg(dfg,
parameters,
activities=activities,
start_activities=start_activities,
end_activities=end_activities)
spaths = get_shortest_paths(net)
aggregated_statistics = get_decorations_from_dfg_spaths_acticount(
net, dfg, spaths, activities_count, variant="frequency")
gviz = pn_vis_factory.apply(net,
im,
fm,
parameters={"format": "svg"},
variant="frequency",
aggregated_statistics=aggregated_statistics)
gviz_base64 = base64.b64encode(str(gviz).encode('utf-8'))
ret_graph = get_graph.get_graph_from_petri(net, im, fm)
return get_base64_from_gviz(gviz), export_petri_as_string(
net, im, fm
), ".pnml", "parquet", activities, start_activities, end_activities, gviz_base64, ret_graph, "inductive", "freq", None, "", activity_key
def get_decorated_net(net,
initial_marking,
final_marking,
log,
parameters=None,
variant="frequency"):
"""
Get a decorated net according to the specified variant (decorate Petri net based on DFG)
Parameters
------------
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
log
Log to use to decorate the Petri net
parameters
Algorithm parameters
variant
Specify if the decoration should take into account the frequency or the performance
Returns
------------
gviz
GraphViz object
"""
if parameters is None:
parameters = {}
aggregation_measure = "mean"
if "frequency" in variant:
aggregation_measure = "sum"
elif "performance" in variant:
aggregation_measure = "mean"
if "aggregationMeasure" in parameters:
aggregation_measure = parameters["aggregationMeasure"]
activity_key = parameters[
PARAMETER_CONSTANT_ACTIVITY_KEY] if PARAMETER_CONSTANT_ACTIVITY_KEY in parameters else xes.DEFAULT_NAME_KEY
# we find the DFG
dfg = dfg_factory.apply(log, variant=variant, parameters=parameters)
# we find shortest paths
spaths = get_shortest_paths(net)
# we find the number of activities occurrences in the trace log
activities_count = attributes_filter.get_attribute_values(
log, activity_key, parameters=parameters)
aggregated_statistics = get_decorations_from_dfg_spaths_acticount(
net,
dfg,
spaths,
activities_count,
variant=variant,
aggregation_measure=aggregation_measure)
return visualize.apply(net,
initial_marking,
final_marking,
parameters=parameters,
decorations=aggregated_statistics)
def apply_petri_greedy(net,
initial_marking,
final_marking,
log=None,
aggr_stat=None,
parameters=None):
"""
Visualize a BPMN graph from a Petri net, decorated with performance, using the given parameters (greedy algorithm)
Parameters
-----------
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
log
(Optional) log where the replay technique should be applied
aggr_stat
(Optional) element-wise statistics calculated on the Petri net
parameters
Possible parameters of the algorithm, including:
format -> Format of the image to render (pdf, png, svg)
aggregationMeasure -> Measure to use to aggregate statistics
pm4py.util.constants.PARAMETER_CONSTANT_ACTIVITY_KEY -> Specification of the activity key
(if not concept:name)
pm4py.util.constants.PARAMETER_CONSTANT_TIMESTAMP_KEY -> Specification of the timestamp key
(if not time:timestamp)
Returns
-----------
file_name
Path of the figure in which the rendered BPMN has been saved
"""
if parameters is None:
parameters = {}
image_format = parameters["format"] if "format" in parameters else "png"
bpmn_graph, el_corr, inv_el_corr, el_corr_keys_map = bpmn_converter.apply(
net, initial_marking, final_marking)
activity_key = parameters[
PARAMETER_CONSTANT_ACTIVITY_KEY] if PARAMETER_CONSTANT_ACTIVITY_KEY in parameters else DEFAULT_NAME_KEY
if aggr_stat is None and log is not None:
dfg = dfg_factory.apply(log, variant="performance")
activities_count = attributes_filter.get_attribute_values(
log, activity_key)
spaths = vis_trans_shortest_paths.get_shortest_paths(net)
aggr_stat = vis_trans_shortest_paths.get_decorations_from_dfg_spaths_acticount(
net, dfg, spaths, activities_count, variant="performance")
bpmn_aggreg_statistics = None
if aggr_stat is not None:
bpmn_aggreg_statistics = convert_performance_map.convert_performance_map_to_bpmn(
aggr_stat, inv_el_corr)
file_name = bpmn_diagram_to_figure(
bpmn_graph,
image_format,
bpmn_aggreg_statistics=bpmn_aggreg_statistics)
return file_name
net, initial_marking, final_marking = model_factory.apply(df,
classic_output=True)
# visualize the output Petri net
gviz = pn_vis_factory.apply(net, initial_marking, final_marking)
pn_vis_factory.view(gviz)
# gets the average time between cases starts
avg_time_starts = get_case_arrival_avg(df)
print("avg_time_starts=", avg_time_starts)
# gets the aggregated statistics calculated on the DFG graph and the Petri net
activities_count = attributes_filter.get_attribute_values(
df, attribute_key=ACTIVITY_KEY)
[dfg_frequency,
dfg_performance] = df_statistics.get_dfg_graph(df,
measure="both",
perf_aggregation_key="median",
case_id_glue=CASEID_GLUE,
activity_key=ACTIVITY_KEY,
timestamp_key=TIMEST_KEY)
spaths = get_shortest_paths(net)
aggregated_statistics = get_decorations_from_dfg_spaths_acticount(
net, dfg_performance, spaths, activities_count, variant="performance")
# gets the stochastic distribution associated to the Petri net and the dataframe
smap = stochastic_map.get_map_exponential_from_aggstatistics(
aggregated_statistics)
print("smap=", smap)
perf_bound_obj = LpPerfBounds(net, initial_marking, final_marking, smap,
avg_time_starts)
net1, imarking1, fmarking1 = perf_bound_obj.get_net()
gviz = pn_vis_factory.apply(net1, imarking1, fmarking1)
pn_vis_factory.view(gviz)
def execute_script():
time1 = time.time()
dataframe = csv_import_adapter.import_dataframe_from_path_wo_timeconversion(
inputLog, sep=SEP, quotechar=QUOTECHAR)
time2 = time.time()
print("time2 - time1: " + str(time2 - time1))
parameters_filtering = {
constants.PARAMETER_CONSTANT_CASEID_KEY: CASEID_GLUE,
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: ACTIVITY_KEY
}
if enable_auto_filter:
dataframe = auto_filter.apply_auto_filter(
dataframe, parameters=parameters_filtering)
else:
dataframe = attributes_filter.apply_auto_filter(
dataframe, parameters=parameters_filtering)
time3 = time.time()
print("time3 - time2: " + str(time3 - time2))
if enable_filtering_on_cases:
dataframe = case_filter.filter_on_ncases(dataframe,
case_id_glue=CASEID_GLUE,
max_no_cases=max_no_cases)
time4 = time.time()
dataframe = csv_import_adapter.convert_caseid_column_to_str(
dataframe, case_id_glue=CASEID_GLUE)
dataframe = csv_import_adapter.convert_timestamp_columns_in_df(
dataframe, timest_columns=TIMEST_COLUMNS, timest_format=TIMEST_FORMAT)
time6 = time.time()
print("time6 - time4: " + str(time6 - time4))
# dataframe = dataframe.sort_values('time:timestamp')
time7 = time.time()
print("time7 - time6: " + str(time7 - time6))
# show the filtered dataframe on the screen
activities_count = attributes_filter.get_attribute_values(
dataframe, attribute_key=ACTIVITY_KEY)
[dfg_frequency, dfg_performance
] = df_statistics.get_dfg_graph(dataframe,
measure="both",
perf_aggregation_key="median",
case_id_glue=CASEID_GLUE,
activity_key=ACTIVITY_KEY,
timestamp_key=TIMEST_KEY)
if enable_filtering_df:
print("len dfg_frequency 0=", len(dfg_frequency))
dfg_frequency = dfg_filtering.apply(
dfg_frequency, {"noiseThreshold": filtering_df_noise})
print("len dfg_frequency 1=", len(dfg_frequency))
time8 = time.time()
print("time8 - time7: " + str(time8 - time7))
gviz = dfg_vis_factory.apply(dfg_frequency,
activities_count=activities_count,
parameters={"format": "svg"})
dfg_vis_factory.view(gviz)
net, initial_marking, final_marking = inductive_factory.apply_dfg(
dfg_frequency)
# net, initial_marking, final_marking = alpha_factory.apply_dfg(dfg_frequency)
spaths = get_shortest_paths(net)
time9 = time.time()
print("time9 - time8: " + str(time9 - time8))
aggregated_statistics = get_decorations_from_dfg_spaths_acticount(
net, dfg_performance, spaths, activities_count, variant="performance")
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
variant="performance",
aggregated_statistics=aggregated_statistics,
parameters={"format": "svg"})
time10 = time.time()
print("time10 - time9: " + str(time10 - time9))
print("time10 - time1: " + str(time10 - time1))
pn_vis_factory.view(gviz)
