def test_alpha_miner_log(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net1, im1, fm1 = alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_CLASSIC)
net2, im2, fm2 = alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_PLUS)
from pm4py.algo.discovery.dfg import algorithm as dfg_discovery
dfg = dfg_discovery.apply(log)
net3, im3, fm3 = alpha_miner.apply_dfg(dfg, variant=alpha_miner.Variants.ALPHA_VERSION_CLASSIC)
def test_alignment(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.conformance.alignments import algorithm as alignments
aligned_traces = alignments.apply(
log,
net,
im,
fm,
variant=alignments.Variants.VERSION_STATE_EQUATION_A_STAR)
aligned_traces = alignments.apply(
log,
net,
im,
fm,
variant=alignments.Variants.VERSION_DIJKSTRA_NO_HEURISTICS)
from pm4py.evaluation.replay_fitness import evaluator as rp_fitness_evaluator
fitness = rp_fitness_evaluator.apply(
log,
net,
im,
fm,
variant=rp_fitness_evaluator.Variants.ALIGNMENT_BASED)
evaluation = rp_fitness_evaluator.evaluate(
aligned_traces,
variant=rp_fitness_evaluator.Variants.ALIGNMENT_BASED)
from pm4py.evaluation.precision import evaluator as precision_evaluator
precision = precision_evaluator.apply(
log,
net,
im,
fm,
variant=rp_fitness_evaluator.Variants.ALIGNMENT_BASED)
def test_playout(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.simulation.playout import simulator
log2 = simulator.apply(net, im, fm)
def test_tokenreplay(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.conformance.tokenreplay import algorithm as token_replay
replayed_traces = token_replay.apply(
log, net, im, fm, variant=token_replay.Variants.TOKEN_REPLAY)
replayed_traces = token_replay.apply(
log, net, im, fm, variant=token_replay.Variants.BACKWARDS)
from pm4py.evaluation.replay_fitness import evaluator as rp_fitness_evaluator
fitness = rp_fitness_evaluator.apply(
log,
net,
im,
fm,
variant=rp_fitness_evaluator.Variants.TOKEN_BASED)
evaluation = rp_fitness_evaluator.evaluate(
replayed_traces, variant=rp_fitness_evaluator.Variants.TOKEN_BASED)
from pm4py.evaluation.precision import evaluator as precision_evaluator
precision = precision_evaluator.apply(
log,
net,
im,
fm,
variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN)
from pm4py.evaluation.generalization import evaluator as generalization_evaluation
generalization = generalization_evaluation.apply(
log,
net,
im,
fm,
variant=generalization_evaluation.Variants.GENERALIZATION_TOKEN)
def test_alignment(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.conformance.alignments import algorithm as alignments
aligned_traces = alignments.apply(log, net, im, fm, variant=alignments.Variants.VERSION_STATE_EQUATION_A_STAR)
aligned_traces = alignments.apply(log, net, im, fm, variant=alignments.Variants.VERSION_DIJKSTRA_NO_HEURISTICS)
def test_alpha_miner_dataframe(self):
from pm4py.objects.log.adapters.pandas import csv_import_adapter
df = csv_import_adapter.import_dataframe_from_path(
os.path.join("input_data", "running-example.csv"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(
df, variant=alpha_miner.Variants.ALPHA_VERSION_CLASSIC)
def test_48(self):
import os
from pm4py.objects.log.importer.xes import importer as xes_importer
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
parameters = {alpha_miner.Variants.ALPHA_VERSION_CLASSIC.value.Parameters.ACTIVITY_KEY: "concept:name"}
net, initial_marking, final_marking = alpha_miner.apply(log, parameters=parameters)
def test_conversion_pn_to_pt(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.objects.conversion.wf_net import converter as wf_net_converter
tree = wf_net_converter.apply(
net, im, fm, variant=wf_net_converter.Variants.TO_PROCESS_TREE)
def test_decomp_alignment(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.conformance.decomp_alignments import algorithm as decomp_align
aligned_traces = decomp_align.apply(
log, net, im, fm, variant=decomp_align.Variants.RECOMPOS_MAXIMAL)
def test_evaluation(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.evaluation.simplicity import algorithm as simplicity
simp = simplicity.apply(net)
from pm4py.algo.evaluation import algorithm as evaluation_method
eval = evaluation_method.apply(log, net, im, fm)
def test_running_example_alpha(self):
path = os.path.join("input_data", "running-example.xes")
log = xes_import.apply(path)
net, i_m, f_m = alpha_miner.apply(log)
self.assertTrue(
woflan.apply(net,
i_m,
f_m,
parameters={"print_diagnostics": False}))
def test_footprints_net(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.discovery.footprints import algorithm as footprints_discovery
fp_log = footprints_discovery.apply(log)
fp_net = footprints_discovery.apply(net, im)
from pm4py.algo.conformance.footprints import algorithm as footprints_conformance
conf = footprints_conformance.apply(fp_log, fp_net)
def gerar_orgaosjulgadores_modelfit_from_params(ramo_justica,
codtribunal,
atuacao,
cluster,
grau,
codorgaoj,
codnatureza,
codclasse,
dtinicio,
dtfim,
baixado=None,
sensibility='60'):
eventLog = gerar_log_eventos(ramo_justica, codtribunal, atuacao, cluster,
grau, codorgaoj, codnatureza, codclasse,
dtinicio, dtfim, baixado, sensibility)
net, initial_marking, final_marking = alpha_miner.apply(eventLog)
orgaos_model_fit = []
df = consultar_orgaosjulgadores_por_tribunal_e_atuacaovara(
codtribunal, atuacao)
with ThreadPoolExecutor(max_workers=15) as executor:
future_to_row = {
executor.submit(get_token_replayed_traces_from_params, net,
initial_marking, final_marking,
ramo_justica, codtribunal, atuacao, cluster, grau,
str(row["cod"]), codnatureza, codclasse, dtinicio,
dtfim, baixado, sensibility): row
for index, row in df.iterrows()
}
for future in concurrent.futures.as_completed(future_to_row):
row = future_to_row[future]
try:
replayed_traces = future.result()
orgao_model_fit = {
"cod":
row["cod"],
"descricao":
row["descricao"],
"traceFitness":
str(replayed_traces[0]['trace_fitness'] * 100) + ' %',
"traceIsFit":
replayed_traces[0]['trace_is_fit']
}
orgaos_model_fit.append(orgao_model_fit)
except Exception as exc:
print('%r generated an exception: %s' % (row, exc))
sorted_orgaos_model_fit = sorted(orgaos_model_fit,
key=lambda i: i['traceFitness'],
reverse=True)
return sorted_orgaos_model_fit
def test_alphaminer_log(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
net, im, fm = alpha_miner.apply(log)
aligned_traces_tr = tr_alg.apply(log, net, im, fm)
aligned_traces_alignments = align_alg.apply(log, net, im, fm)
evaluation = eval_alg.apply(log, net, im, fm)
fitness = rp_fit.apply(log, net, im, fm)
precision = precision_evaluator.apply(log, net, im, fm)
gen = generalization.apply(log, net, im, fm)
sim = simplicity.apply(net)
def test_alphaminer_df(self):
log = pd.read_csv(os.path.join("input_data", "running-example.csv"))
log = dataframe_utils.convert_timestamp_columns_in_df(log)
net, im, fm = alpha_miner.apply(log)
aligned_traces_tr = tr_alg.apply(log, net, im, fm)
aligned_traces_alignments = align_alg.apply(log, net, im, fm)
evaluation = eval_alg.apply(log, net, im, fm)
fitness = rp_fit.apply(log, net, im, fm)
precision = precision_evaluator.apply(log, net, im, fm)
gen = generalization.apply(log, net, im, fm)
sim = simplicity.apply(net)
def test_alphaminer_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)
net, im, fm = alpha_miner.apply(stream)
aligned_traces_tr = tr_alg.apply(stream, net, im, fm)
aligned_traces_alignments = align_alg.apply(stream, net, im, fm)
evaluation = eval_alg.apply(stream, net, im, fm)
fitness = rp_fit.apply(stream, net, im, fm)
precision = precision_evaluator.apply(stream, net, im, fm)
gen = generalization.apply(stream, net, im, fm)
sim = simplicity.apply(net)
def test_50(self):
import os
from pm4py.objects.log.importer.xes import importer as xes_importer
log = xes_importer.apply(os.path.join("input_data", "receipt.xes"))
for trace in log:
for event in trace:
event["customClassifier"] = event["concept:name"] + event["lifecycle:transition"]
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
parameters = {alpha_miner.Variants.ALPHA_VERSION_CLASSIC.value.Parameters.ACTIVITY_KEY: "customClassifier"}
net, initial_marking, final_marking = alpha_miner.apply(log, parameters=parameters)
def test_49(self):
import os
from pm4py.objects.log.importer.xes import importer as xes_importer
log = xes_importer.apply(os.path.join("input_data", "receipt.xes"))
classifiers = log.classifiers
from pm4py.objects.log.util import insert_classifier
log, activity_key = insert_classifier.insert_activity_classifier_attribute(log, "Activity classifier")
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
parameters = {alpha_miner.Variants.ALPHA_VERSION_CLASSIC.value.Parameters.ACTIVITY_KEY: activity_key}
net, initial_marking, final_marking = alpha_miner.apply(log, parameters=parameters)
def execute_script():
log = xes_importer.apply(
os.path.join("..", "tests", "input_data", "running-example.xes"))
net, im, fm = alpha_miner.apply(log)
is_sound, diagn = woflan.apply(net,
im,
fm,
parameters={
"print_diagnostics": True,
"return_diagnostics": True
})
print("is_sound", is_sound)
print(diagn)
def obtainPetriNetThroughAlphaMiner(self, log_name):
# 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"
if ".xes" in log_name:
log = xes_importer.apply(log_name)
else:
df = pd.read_csv(log_name)
df = dataframe_utils.convert_timestamp_columns_in_df(df)
log = log_conversion.apply(df)
net, marking, fmarking = alpha_alg.apply(log)
return log, net, marking, fmarking
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_import.apply(log_path)
net, i_m, f_m = alpha_miner.apply(log)
gviz = pn_vis.apply(
net,
i_m,
f_m,
parameters={
pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg",
pn_vis.Variants.WO_DECORATION.value.Parameters.DEBUG: False
})
pn_vis.view(gviz)
def test_footprints_net(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.discovery.footprints import algorithm as footprints_discovery
fp_entire_log = footprints_discovery.apply(log, variant=footprints_discovery.Variants.ENTIRE_EVENT_LOG)
fp_trace_trace = footprints_discovery.apply(log)
fp_net = footprints_discovery.apply(net, im)
from pm4py.algo.conformance.footprints import algorithm as footprints_conformance
conf1 = footprints_conformance.apply(fp_entire_log, fp_net)
conf2 = footprints_conformance.apply(fp_trace_trace, fp_net)
conf3 = footprints_conformance.apply(fp_entire_log, fp_net,
variant=footprints_conformance.Variants.LOG_EXTENSIVE)
conf4 = footprints_conformance.apply(fp_trace_trace, fp_net,
variant=footprints_conformance.Variants.TRACE_EXTENSIVE)
def test_rep_log_petri_fitness(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"
log = xes_importer.apply(
os.path.join(INPUT_DATA_DIR, "running-example.xes"))
pref_mat, var_mat, activities = prefix_matrix.get_prefix_variants_matrix(
log)
net, im, fm = alpha_miner.apply(log)
net_matrix = project_net_on_matrix(net, activities)
product_matrix = np.matmul(pref_mat, net_matrix)
max_product_matrix = np.max(product_matrix)
self.assertGreaterEqual(max_product_matrix, 0)
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_importer.apply(log_path)
net, marking, final_marking = alpha_miner.apply(log)
for place in marking:
print("initial marking " + place.name)
for place in final_marking:
print("final marking " + place.name)
gviz = pn_vis.apply(net, marking, final_marking,
parameters={pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"})
pn_vis.view(gviz)
print("started token replay")
aligned_traces = token_replay.apply(log, net, marking, final_marking)
fit_traces = [x for x in aligned_traces if x['trace_is_fit']]
perc_fitness = 0.00
if len(aligned_traces) > 0:
perc_fitness = len(fit_traces) / len(aligned_traces)
print("perc_fitness=", perc_fitness)
def execute_script():
log = xes_importer.apply(
os.path.join("..", "tests", "input_data", "running-example.xes"))
net, im, fm = alpha_miner.apply(log)
# the alpha miner in this case returns a sound workflow net!
# get the tangible reachability graph and the Q-matrix
reach_graph, tang_reach_graph, stochastic_map, q_matrix = ctmc.get_tangible_reachability_and_q_matrix_from_log_net(
log, net, im, fm)
print(reach_graph.states)
# pick the source state
state = [
x for x in tang_reach_graph.states
if x.name.startswith("registerrequest")
or x.name.startswith("reinitiaterequest")
][0]
# analyse the distribution over the states of the system starting from the source after 86400.0 seconds (1 day)
transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state(
tang_reach_graph, q_matrix, state, 86400.0)
print(transient_result)
def discover_petri_net_alpha(log: EventLog) -> Tuple[PetriNet, Marking, Marking]:
"""
Discovers a Petri net using the Alpha Miner
Parameters
--------------
log
Event log
Returns
--------------
petri_net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
return alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_CLASSIC)
def discover_petri_net_alpha_plus(log):
"""
Discovers a Petri net using the Alpha+ algorithm
Parameters
--------------
log
Event log_skeleton
Returns
--------------
petri_net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
return alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_PLUS)
def discover_petri_net_alpha_plus(log: Union[EventLog, pd.DataFrame]) -> Tuple[PetriNet, Marking, Marking]:
"""
Discovers a Petri net using the Alpha+ algorithm
Parameters
--------------
log
Event log
Returns
--------------
petri_net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
return alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_PLUS)
def test_alignment_alpha(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"
log = xes_importer.apply(
os.path.join(INPUT_DATA_DIR, "running-example.xes"))
net, marking, fmarking = alpha_alg.apply(log)
final_marking = petri_net.obj.Marking()
for p in net.places:
if not p.out_arcs:
final_marking[p] = 1
for trace in log:
cf_result = \
align_alg.apply(trace, net, marking, final_marking, variant=align_alg.VERSION_DIJKSTRA_NO_HEURISTICS)[
'alignment']
is_fit = True
for couple in cf_result:
if not (couple[0] == couple[1]
or couple[0] == ">>" and couple[1] is None):
is_fit = False
if not is_fit:
raise Exception("should be fit")
def discover_petri_net_alpha_plus(log: Union[EventLog, pd.DataFrame]) -> Tuple[PetriNet, Marking, Marking]:
"""
Discovers a Petri net using the Alpha+ algorithm
Parameters
--------------
log
Event log
Returns
--------------
petri_net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
if type(log) not in [pd.DataFrame, EventLog, EventStream]: raise Exception("the method can be applied only to a traditional event log!")
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
return alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_PLUS, parameters=get_properties(log))
