def execute_script():
log = xes_importer.apply(
os.path.join("..", "tests", "input_data", "running-example.xes"))
frequency_dfg = dfg_miner.apply(log, variant=dfg_miner.Variants.FREQUENCY)
net, im, fm = dfg_conv.apply(frequency_dfg)
# perform the Montecarlo simulation with the arrival rate inferred by the log (the simulation lasts 5 secs)
parameters = {}
parameters[montecarlo_simulation.Variants.PETRI_SEMAPH_FIFO.value.
Parameters.TOKEN_REPLAY_VARIANT] = Variants.BACKWARDS
parameters[montecarlo_simulation.Variants.PETRI_SEMAPH_FIFO.value.
Parameters.PARAM_ENABLE_DIAGNOSTICS] = False
parameters[montecarlo_simulation.Variants.PETRI_SEMAPH_FIFO.value.
Parameters.PARAM_MAX_THREAD_EXECUTION_TIME] = 5
log, res = montecarlo_simulation.apply(log,
net,
im,
fm,
parameters=parameters)
print(
"\n(Montecarlo - Petri net) case arrival ratio inferred from the log")
print(res["median_cases_ex_time"])
print(res["total_cases_time"])
# perform the Montecarlo simulation with the arrival rate specified (the simulation lasts 5 secs)
parameters[montecarlo_simulation.Variants.PETRI_SEMAPH_FIFO.value.
Parameters.PARAM_CASE_ARRIVAL_RATIO] = 60
log, res = montecarlo_simulation.apply(log,
net,
im,
fm,
parameters=parameters)
print(
"\n(Montecarlo - Petri net) case arrival ratio specified by the user")
print(res["median_cases_ex_time"])
print(res["total_cases_time"])
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "interval_event_log.xes")
#log_path = os.path.join("..", "tests", "input_data", "reviewing.xes")
log = xes_importer.apply(log_path)
parameters = {}
parameters[constants.PARAMETER_CONSTANT_START_TIMESTAMP_KEY] = "start_timestamp"
parameters[constants.PARAMETER_CONSTANT_TIMESTAMP_KEY] = "time:timestamp"
parameters[constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = "concept:name"
parameters["strict"] = False
parameters["format"] = "svg"
start_activities = sa_get.get_start_activities(log, parameters=parameters)
end_activities = ea_get.get_end_activities(log, parameters=parameters)
parameters["start_activities"] = start_activities
parameters["end_activities"] = end_activities
soj_time = soj_time_get.apply(log, parameters=parameters)
print("soj_time")
print(soj_time)
conc_act = conc_act_get.apply(log, parameters=parameters)
print("conc_act")
print(conc_act)
efg = efg_get.apply(log, parameters=parameters)
print("efg")
print(efg)
dfg_freq = dfg_algorithm.apply(log, parameters=parameters, variant=dfg_algorithm.Variants.FREQUENCY)
dfg_perf = dfg_algorithm.apply(log, parameters=parameters, variant=dfg_algorithm.Variants.PERFORMANCE)
dfg_gv_freq = dfg_vis_fact.apply(dfg_freq, log=log, variant=dfg_vis_fact.Variants.FREQUENCY,
parameters=parameters)
dfg_vis_fact.view(dfg_gv_freq)
dfg_gv_perf = dfg_vis_fact.apply(dfg_perf, log=log, variant=dfg_vis_fact.Variants.PERFORMANCE,
parameters=parameters)
dfg_vis_fact.view(dfg_gv_perf)
net, im, fm = dfg_conv.apply(dfg_freq)
gviz = pn_vis.apply(net, im, fm, parameters=parameters)
pn_vis.view(gviz)
def test_46(self):
from pm4py.objects.log.importer.xes import importer as xes_importer
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.dfg import algorithm as dfg_discovery
dfg = dfg_discovery.apply(log)
from pm4py.objects.conversion.dfg import converter as dfg_mining
net, im, fm = dfg_mining.apply(dfg)
def get_tangible_reachability_and_q_matrix_from_dfg_performance(
dfg_performance, invisible_firing_rate=1000.0, parameters=None):
"""
Get the tangible reachability graph and the Q matrix from the performance DFG
Parameters
-------------
dfg_performance
Performance DFG
invisible_firing_rate
Firing rate for invisible transitions
parameters
Parameters
Returns
-------------
reachab_graph
Reachability graph
tangible_reach_graph
Tangible reachability graph
stochastic_info
Stochastic information
q_matrix
Q-matrix from the tangible reachability graph
"""
if parameters is None:
parameters = {}
net, im, fm = dfg_converter.apply(dfg_performance, parameters=parameters)
stochastic_map = {}
for tr in net.transitions:
if tr.label is None:
rv = random_variable.RandomVariable()
exp = exponential.Exponential()
exp.scale = 1 / invisible_firing_rate
rv.random_variable = exp
stochastic_map[tr] = rv
else:
input_arc = list(tr.in_arcs)[0]
output_arc = list(tr.out_arcs)[0]
rv = random_variable.RandomVariable()
el = (input_arc.source.name, output_arc.target.name)
scale = 0
if el in dfg_performance:
scale = dfg_performance[el]
if scale == 0:
scale = 1 / invisible_firing_rate
exp = exponential.Exponential()
exp.scale = scale
rv.random_variable = exp
stochastic_map[tr] = rv
tang_reach_graph = construct_reachability_graph(net,
im,
use_trans_name=True)
q_matrix = get_q_matrix_from_tangible_exponential(tang_reach_graph,
stochastic_map)
return tang_reach_graph, tang_reach_graph, stochastic_map, q_matrix
def discover_dfg_miner(log):
dfg = dfg_discovery.apply(log)
sa = sa_get.get_start_activities(log)
ea = ea_get.get_end_activities(log)
net, im, fm = dfg_converter.apply(dfg,
parameters={
"start_activities": sa,
"end_activities": ea
})
return net, im, fm
def execute_script():
log_path = os.path.join("..", "tests", "input_data",
"interval_event_log.csv")
dataframe = pm4py.read_csv(log_path)
log_path = os.path.join("..", "tests", "input_data", "reviewing.xes")
log = pm4py.read_xes(log_path)
dataframe = pm4py.convert_to_dataframe(log)
parameters = {}
#parameters[constants.PARAMETER_CONSTANT_START_TIMESTAMP_KEY] = "start_timestamp"
parameters[constants.PARAMETER_CONSTANT_TIMESTAMP_KEY] = "time:timestamp"
parameters[constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = "concept:name"
parameters[constants.PARAMETER_CONSTANT_CASEID_KEY] = "case:concept:name"
parameters["strict"] = True
parameters["format"] = "svg"
start_activities = sa_get.get_start_activities(dataframe,
parameters=parameters)
end_activities = ea_get.get_end_activities(dataframe,
parameters=parameters)
att_count = att_get.get_attribute_values(dataframe,
"concept:name",
parameters=parameters)
parameters["start_activities"] = start_activities
parameters["end_activities"] = end_activities
soj_time = soj_time_get.apply(dataframe, parameters=parameters)
print("soj_time")
print(soj_time)
conc_act = conc_act_get.apply(dataframe, parameters=parameters)
print("conc_act")
print(conc_act)
efg = efg_get.apply(dataframe, parameters=parameters)
print("efg")
print(efg)
dfg_freq, dfg_perf = df_statistics.get_dfg_graph(
dataframe, measure="both", start_timestamp_key="start_timestamp")
dfg_gv_freq = dfg_vis_fact.apply(dfg_freq,
activities_count=att_count,
variant=dfg_vis_fact.Variants.FREQUENCY,
soj_time=soj_time,
parameters=parameters)
dfg_vis_fact.view(dfg_gv_freq)
dfg_gv_perf = dfg_vis_fact.apply(dfg_perf,
activities_count=att_count,
variant=dfg_vis_fact.Variants.PERFORMANCE,
soj_time=soj_time,
parameters=parameters)
dfg_vis_fact.view(dfg_gv_perf)
net, im, fm = dfg_conv.apply(dfg_freq)
gviz = pn_vis.apply(net, im, fm, parameters=parameters)
pn_vis.view(gviz)
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_importer.apply(log_path)
dfg = dfg_algorithm.apply(log)
dfg_gv = dfg_vis_fact.apply(
dfg,
log,
parameters={
dfg_vis_fact.Variants.FREQUENCY.value.Parameters.FORMAT: "svg"
})
dfg_vis_fact.view(dfg_gv)
net, im, fm = dfg_conv.apply(dfg)
gviz = pn_vis.apply(
net,
im,
fm,
parameters={
pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"
})
pn_vis.view(gviz)
def dfg_miner_petri(log):
dfg = dfg_discovery.apply(log, variant=dfg_discovery.Variants.PERFORMANCE)
net, im, fm = dfg_mining.apply(dfg)
find_fitness('dfg', log, net, im, fm)
gviz = pn_visualizer.apply(net, im, fm)
return gviz, None
gviz = dfg_visualization.apply(dfg, log=log, variant=dfg_visualization.Variants.PERFORMANCE, parameters=parameters)
dfg_visualization.save(gviz, "dfg.svg")
#Conver DF graph to a workflow net
from pm4py.objects.log.importer.xes import importer as xes_importer
import os
filepath = os.path.join('E:/data/pm/running-example.xes')
log = xes_importer.apply(filepath)
from pm4py.algo.discovery.dfg import algorithm as dfg_discovery
dfg = dfg_discovery.apply(log)
from pm4py.objects.conversion.dfg import converter as dfg_mining
net, im, fm = dfg_mining.apply(dfg)
net
im
fm
#Adding info about freq/ performance
from pm4py.visualization.petrinet import visualizer as pn_visualizer
parameters = {pn_visualizer.Variants.FREQUENCY.value.Parameters.FORMAT: "png"}
gviz = pn_visualizer.apply(net, initial_marking, final_marking, parameters=parameters, variant=pn_visualizer.Variants.FREQUENCY, log=log)
pn_visualizer.save(gviz, "inductive_frequency.png")
#classifier
import os
from pm4py.objects.log.importer.xes import importer as xes_importer
