def execute_script():
log = pm4py.read_xes("../tests/input_data/running-example.xes")
dfg, sa, ea = pm4py.discover_dfg(log)
tree = pm4py.discover_process_tree_inductive(log)
heu_net = pm4py.discover_heuristics_net(log)
net, im, fm = pm4py.discover_petri_net_alpha(log)
bpmn = pm4py.convert_to_bpmn(tree)
ts = ts_discovery.apply(log)
x_cases, y_cases = case_statistics.get_kde_caseduration(log)
gviz1 = dfg_visualizer.apply(dfg)
gviz2 = tree_visualizer.apply(tree)
gviz3 = hn_visualizer.apply(heu_net)
gviz4 = pn_visualizer.apply(net, im, fm)
gviz5 = bpmn_visualizer.apply(bpmn)
gviz6 = ts_visualizer.apply(ts)
gviz7 = graphs_visualizer.apply(x_cases, y_cases, variant=graphs_visualizer.Variants.CASES,
parameters={graphs_visualizer.Variants.CASES.value.Parameters.FORMAT: "svg"})
print("1", len(dfg_visualizer.serialize_dot(gviz1)))
print("1", len(dfg_visualizer.serialize(gviz1)))
print("2", len(tree_visualizer.serialize_dot(gviz2)))
print("2", len(tree_visualizer.serialize(gviz2)))
print("3", len(hn_visualizer.serialize(gviz3)))
print("4", len(pn_visualizer.serialize_dot(gviz4)))
print("4", len(pn_visualizer.serialize(gviz4)))
print("5", len(bpmn_visualizer.serialize_dot(gviz5)))
print("5", len(bpmn_visualizer.serialize(gviz5)))
print("6", len(ts_visualizer.serialize_dot(gviz6)))
print("6", len(ts_visualizer.serialize(gviz6)))
print("7", len(graphs_visualizer.serialize(gviz7)))
def execute_script():
# log_path = "C:/Users/bas/Documents/tue/svn/private/logs/ilp_test_2_abcd_acbd.xes"
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_importer.apply(log_path)
ts = ts_discovery.apply(log)
viz = ts_vis.apply(
ts,
parameters={ts_vis.Variants.VIEW_BASED.value.Parameters.FORMAT: "svg"})
ts_vis.view(viz)
def execute_script():
log = pm4py.read_xes(
os.path.join("..", "tests", "input_data", "running-example.xes"))
ts = transition_system_discovery.apply(log,
parameters={
"include_data": True,
"direction": "forward"
})
gviz = trans_frequency.apply(ts, parameters={"format": "svg"})
transition_system_visualizer.view(gviz)
def test_transitionsystem1(self):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
input_log = os.path.join(INPUT_DATA_DIR, "running-example.xes")
log = xes_importer.apply(input_log)
ts = ts_alg.apply(log, parameters={
ts_alg.Variants.VIEW_BASED.value.Parameters.PARAM_KEY_VIEW: ts_alg.Variants.VIEW_BASED.value.Parameters.VIEW_SEQUENCE,
ts_alg.Variants.VIEW_BASED.value.Parameters.PARAM_KEY_WINDOW: 3,
ts_alg.Variants.VIEW_BASED.value.Parameters.PARAM_KEY_DIRECTION: ts_alg.Variants.VIEW_BASED.value.Parameters.DIRECTION_FORWARD})
viz = pm4py.visualization.transition_system.util.visualize_graphviz.visualize(ts)
del viz
def execute_script():
# log_path = "C:/Users/bas/Documents/tue/svn/private/logs/ilp_test_2_abcd_acbd.xes"
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_importer.apply(log_path)
ts = ts_discovery.apply(log, parameters={"include_data": True})
viz = ts_vis.apply(
ts,
parameters={ts_vis.Variants.VIEW_BASED.value.Parameters.FORMAT: "svg"})
ts_vis.view(viz)
for state in ts.states:
print(state.name, "ingoing=", len(state.data["ingoing_events"]),
"outgoing=", len(state.data["outgoing_events"]))
for trans in ts.transitions:
print(trans.name, trans.from_state.name, trans.to_state.name,
"frequency=", len(trans.data["events"]))
def test_tsystem(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.transition_system import algorithm as ts_system
tsystem = ts_system.apply(log, variant=ts_system.Variants.VIEW_BASED)
def apply(df0, classifier_function=None, parameters=None):
if parameters is None:
parameters = {}
if classifier_function is None:
classifier_function = lambda x: x["event_activity"]
min_acti_freq = parameters[
"min_acti_freq"] if "min_acti_freq" in parameters else 0
min_edge_freq = parameters[
"min_edge_freq"] if "min_edge_freq" in parameters else 0
df = df0.copy()
df = general.preprocess(df, parameters=parameters)
df = clean_frequency.apply(df, min_acti_freq=min_acti_freq)
df = clean_arc_frequency.apply(df, min_freq=min_edge_freq)
models = {}
obj_types = [x for x in df.columns if not x.startswith("event_")]
activities = set()
activities_repeated = Counter()
edges = Counter()
start_activities = dict()
end_activities = dict()
acti_spec = Counter()
for ot in obj_types:
start_activities[ot] = set()
end_activities[ot] = set()
new_df = df[["event_id", "event_activity", "event_timestamp",
ot]].dropna(subset=[ot])
new_df = new_df.rename(columns={
ot: "case:concept:name",
"event_timestamp": "time:timestamp"
})
log = new_df.to_dict("r")
for ev in log:
ev["event_objtype"] = ot
ev["concept:name"] = classifier_function(ev)
del ev["event_objtype"]
del ev["event_activity"]
activities.add((ev["event_id"], ev["concept:name"]))
log = EventStream(log)
this_activities = set(x["concept:name"] for x in log)
for act in this_activities:
activities_repeated[act] += 1
log = log_conv_factory.apply(log,
variant=log_conv_factory.TO_EVENT_LOG)
for trace in log:
if trace:
start_activities[ot].add(trace[0]["concept:name"])
end_activities[ot].add(trace[-1]["concept:name"])
for i in range(len(trace) - 1):
ev0 = trace[i]
ev1 = trace[i + 1]
edges[(ot, ev0["concept:name"], ev1["concept:name"],
ev0["event_id"], ev1["event_id"],
trace.attributes["concept:name"],
ev0["time:timestamp"], ev1["time:timestamp"])] += 1
acti_spec[(ot, trace[i]["concept:name"],
trace[i]["event_id"],
trace.attributes["concept:name"],
trace[i]["time:timestamp"])] += 1
if len(trace) > 0:
acti_spec[(ot, trace[-1]["concept:name"],
trace[-1]["event_id"],
trace.attributes["concept:name"],
trace[-1]["time:timestamp"])] += 1
models[ot] = tsystem.apply(log)
activities = dict(Counter(list(x[1] for x in activities)))
activities_repeated = set(x for x in activities_repeated
if activities_repeated[x] > 1)
return {
"type": "trans_system",
"models": models,
"activities": activities,
"activities_repeated": activities_repeated,
"edges": edges,
"acti_spec": acti_spec
}
def test_ts_df(self):
df = pd.read_csv(os.path.join("input_data", "running-example.csv"))
df = dataframe_utils.convert_timestamp_columns_in_df(df)
ts = ts_disc.apply(df)
def test_ts_stream(self):
df = pd.read_csv(os.path.join("input_data", "running-example.csv"))
df = dataframe_utils.convert_timestamp_columns_in_df(df)
stream = log_conversion.apply(df, variant=log_conversion.TO_EVENT_STREAM)
ts = ts_disc.apply(stream)
def test_ts_log(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
ts = ts_disc.apply(log)
