def test_docmeasures11(self):
from pm4py.log.importer import xes as xes_importer
log = xes_importer.import_from_file_xes('inputData\\receipt.xes')
from pm4py.algo.alpha import factory as alpha_miner
from pm4py.algo.inductive import factory as inductive_miner
alpha_petri, alpha_initial_marking, alpha_final_marking = alpha_miner.apply(log)
inductive_petri, inductive_initial_marking, inductive_final_marking = inductive_miner.apply(log)
from pm4py.evaluation.replay_fitness import factory as replay_factory
fitness_alpha = replay_factory.apply(log, alpha_petri, alpha_initial_marking, alpha_final_marking)
fitness_inductive = replay_factory.apply(log, inductive_petri, inductive_initial_marking, inductive_final_marking)
# print("fitness_alpha=",fitness_alpha)
# print("fitness_inductive=",fitness_inductive)
from pm4py.evaluation.precision import factory as precision_factory
precision_alpha = precision_factory.apply(log, alpha_petri, alpha_initial_marking, alpha_final_marking)
precision_inductive = precision_factory.apply(log, inductive_petri, inductive_initial_marking, inductive_final_marking)
# print("precision_alpha=",precision_alpha)
# print("precision_inductive=",precision_inductive)
from pm4py.evaluation.generalization import factory as generalization_factory
generalization_alpha = generalization_factory.apply(log, alpha_petri, alpha_initial_marking, alpha_final_marking)
generalization_inductive = generalization_factory.apply(log, inductive_petri, inductive_initial_marking,
inductive_final_marking)
# print("generalization_alpha=",generalization_alpha)
# print("generalization_inductive=",generalization_inductive)
from pm4py.evaluation.simplicity import factory as simplicity_factory
simplicity_alpha = simplicity_factory.apply(alpha_petri)
simplicity_inductive = simplicity_factory.apply(inductive_petri)
# print("simplicity_alpha=",simplicity_alpha)
# print("simplicity_inductive=",simplicity_inductive)
from pm4py.evaluation import factory as evaluation_factory
alpha_evaluation_result = evaluation_factory.apply(log, alpha_petri, alpha_initial_marking, alpha_final_marking)
# print("alpha_evaluation_result=",alpha_evaluation_result)
inductive_evaluation_result = evaluation_factory.apply(log, inductive_petri, inductive_initial_marking,
inductive_final_marking)
def test_docmeasures11(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"
from pm4py.objects.log.importer.xes import factory as xes_importer
log = xes_importer.import_log(os.path.join("input_data",
"receipt.xes"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
from pm4py.algo.discovery.inductive import factory as inductive_miner
alpha_petri, alpha_initial_marking, alpha_final_marking = alpha_miner.apply(
log)
inductive_petri, inductive_initial_marking, inductive_final_marking = inductive_miner.apply(
log)
from pm4py.evaluation.replay_fitness import factory as replay_factory
fitness_alpha = replay_factory.apply(log, alpha_petri,
alpha_initial_marking,
alpha_final_marking)
fitness_inductive = replay_factory.apply(log, inductive_petri,
inductive_initial_marking,
inductive_final_marking)
del fitness_alpha
del fitness_inductive
from pm4py.evaluation.precision import factory as precision_factory
precision_alpha = precision_factory.apply(log, alpha_petri,
alpha_initial_marking,
alpha_final_marking)
precision_inductive = precision_factory.apply(
log, inductive_petri, inductive_initial_marking,
inductive_final_marking)
del precision_alpha
del precision_inductive
from pm4py.evaluation.generalization import factory as generalization_factory
generalization_alpha = generalization_factory.apply(
log, alpha_petri, alpha_initial_marking, alpha_final_marking)
generalization_inductive = generalization_factory.apply(
log, inductive_petri, inductive_initial_marking,
inductive_final_marking)
del generalization_alpha
del generalization_inductive
from pm4py.evaluation.simplicity import factory as simplicity_factory
simplicity_alpha = simplicity_factory.apply(alpha_petri)
simplicity_inductive = simplicity_factory.apply(inductive_petri)
del simplicity_alpha
del simplicity_inductive
from pm4py.evaluation import factory as evaluation_factory
alpha_evaluation_result = evaluation_factory.apply(
log, alpha_petri, alpha_initial_marking, alpha_final_marking)
inductive_evaluation_result = evaluation_factory.apply(
log, inductive_petri, inductive_initial_marking,
inductive_final_marking)
del alpha_evaluation_result
del inductive_evaluation_result
def test_tokenreplay(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.conformance.tokenreplay import factory as token_replay
replayed_traces = token_replay.apply(log,
net,
im,
fm,
variant="token_replay")
replayed_traces = token_replay.apply(log,
net,
im,
fm,
variant="backwards")
from pm4py.evaluation.replay_fitness import factory as rp_fitness_evaluator
fitness = rp_fitness_evaluator.apply(
log, net, im, fm, variant=rp_fitness_evaluator.TOKEN_BASED)
evaluation = rp_fitness_evaluator.evaluate(
replayed_traces, variant=rp_fitness_evaluator.TOKEN_BASED)
from pm4py.evaluation.precision import factory as precision_evaluator
precision = precision_evaluator.apply(
log, net, im, fm, variant=precision_evaluator.ETCONFORMANCE_TOKEN)
from pm4py.evaluation.generalization import factory as generalization_evaluation
generalization = generalization_evaluation.apply(
log,
net,
im,
fm,
variant=generalization_evaluation.GENERALIZATION_TOKEN)
def test_etc1(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.import_log(
os.path.join(INPUT_DATA_DIR, "running-example.xes"))
net, marking, final_marking = dfg_only.apply(log, None)
precision = etc_factory.apply(log, net, marking, final_marking)
del precision
def test_evaluation_pm1(self):
log = xes_importer.import_from_file_xes(
os.path.join(INPUT_DATA_DIR, "running-example.xes"))
net, marking, final_marking = dfg_only.apply(log, None)
fitness = fitness_factory.apply(log, net, marking, final_marking)
precision = precision_factory.apply(log, net, marking, final_marking)
generalization = generalization_factory.apply(log, net, marking,
final_marking)
simplicity = simplicity_factory.apply(net)
def test_heu_log(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
net, im, fm = heuristics_miner.apply(log)
aligned_traces_tr = tr_factory.apply(log, net, im, fm)
aligned_traces_alignments = align_factory.apply(log, net, im, fm)
evaluation = eval_factory.apply(log, net, im, fm)
fitness = rp_fit_factory.apply(log, net, im, fm)
precision = precision_factory.apply(log, net, im, fm)
generalization = generalization_factory.apply(log, net, im, fm)
simplicity = simplicity_factory.apply(net)
def test_inductiveminer_df(self):
log = csv_import_adapter.import_dataframe_from_path(
os.path.join("input_data", "running-example.csv"))
net, im, fm = inductive_miner.apply(log)
aligned_traces_tr = tr_factory.apply(log, net, im, fm)
aligned_traces_alignments = align_factory.apply(log, net, im, fm)
evaluation = eval_factory.apply(log, net, im, fm)
fitness = rp_fit_factory.apply(log, net, im, fm)
precision = precision_factory.apply(log, net, im, fm)
generalization = generalization_factory.apply(log, net, im, fm)
simplicity = simplicity_factory.apply(net)
def test_inductiveminer_stream(self):
stream = csv_importer.apply(
os.path.join("input_data", "running-example.csv"))
net, im, fm = inductive_miner.apply(stream)
aligned_traces_tr = tr_factory.apply(stream, net, im, fm)
aligned_traces_alignments = align_factory.apply(stream, net, im, fm)
evaluation = eval_factory.apply(stream, net, im, fm)
fitness = rp_fit_factory.apply(stream, net, im, fm)
precision = precision_factory.apply(stream, net, im, fm)
generalization = generalization_factory.apply(stream, net, im, fm)
simplicity = simplicity_factory.apply(net)
def test_evaluation_pm1(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.import_log(
os.path.join(INPUT_DATA_DIR, "running-example.xes"))
net, marking, final_marking = inductive_miner.apply(log)
fitness = fitness_factory.apply(log, net, marking, final_marking)
precision = precision_factory.apply(log, net, marking, final_marking)
generalization = generalization_factory.apply(log, net, marking,
final_marking)
simplicity = simplicity_factory.apply(net)
del fitness
del precision
del generalization
del simplicity
def test_alignment(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.conformance.alignments import factory as alignments
aligned_traces = alignments.apply(
log, net, im, fm, version=alignments.VERSION_STATE_EQUATION_A_STAR)
aligned_traces = alignments.apply(
log,
net,
im,
fm,
version=alignments.VERSION_DIJKSTRA_NO_HEURISTICS)
from pm4py.evaluation.replay_fitness import factory as rp_fitness_evaluator
fitness = rp_fitness_evaluator.apply(
log, net, im, fm, variant=rp_fitness_evaluator.ALIGNMENT_BASED)
evaluation = rp_fitness_evaluator.evaluate(
aligned_traces, variant=rp_fitness_evaluator.ALIGNMENT_BASED)
from pm4py.evaluation.precision import factory as precision_evaluator
precision = precision_evaluator.apply(
log, net, im, fm, variant=precision_evaluator.ALIGN_ETCONFORMANCE)
variant="token_replay")[
'perc_fit_traces']
t2 = time.time()
times_tokenreplay_imdf[logName] = t2 - t1
if ENABLE_ALIGNMENTS:
t1 = time.time()
fitness_align_imdf[logName] = \
fitness_factory.apply(log, inductive_model, inductive_im, inductive_fm,
variant="alignments", parameters=parameters)['percFitTraces']
t2 = time.time()
times_alignments_imdf[logName] = t2 - t1
precision_alpha[logName] = precision_factory.apply(
log,
alpha_model,
alpha_initial_marking,
alpha_final_marking,
parameters=parameters)
generalization_alpha[logName] = generalization_factory.apply(
log,
alpha_model,
alpha_initial_marking,
alpha_final_marking,
parameters=parameters)
simplicity_alpha[logName] = simplicity_factory.apply(
alpha_model, parameters=parameters)
precision_imdf[logName] = precision_factory.apply(
log,
inductive_model,
inductive_im,
#---------------------------
from pm4py.objects.log.importer.xes import factory as xes_import_factory
log = xes_import_factory.apply("running-example.xes")
from pm4py.algo.discovery.alpha import factory as alpha_miner
from pm4py.algo.discovery.inductive import factory as inductive_miner
from pm4py.evaluation.precision import factory as precision_factory
alpha_petri, alpha_initial_marking, alpha_final_marking = alpha_miner.apply(
log)
inductive_petri, inductive_initial_marking, inductive_final_marking = inductive_miner.apply(
log)
precision_alpha = precision_factory.apply(log, alpha_petri,
alpha_initial_marking,
alpha_final_marking)
precision_inductive = precision_factory.apply(log, inductive_petri,
inductive_initial_marking,
inductive_final_marking)
print("precision_alpha=", precision_alpha)
print("precision_inductive=", precision_inductive)
from pm4py.algo.discovery.dfg import factory as dfg_factory
dfg = dfg_factory.apply(log)
#-----------------------------
from collections import Counter
dfg1 = Counter({
('scroll', 'blur'): 1,
('selection', 'blur'): 1,
def test_etc1(self):
log = xes_importer.import_from_file_xes(os.path.join(INPUT_DATA_DIR, "running-example.xes"))
net, marking, final_marking = dfg_only.apply(log, None)
precision = etc_factory.apply(log, net, marking, final_marking)
def main(system, miner):
if DATA_PATH is None:
log = xes_importer.import_log(
os.path.join(WORK_PATH, "data", "variants",
str(system) + "_train.xes"))
else:
log = xes_importer.import_log(
os.path.join(DATA_PATH, "variants",
str(system) + "_train.xes"))
bestmodel = None
bestfit = None
bestPrec = None
bestGen = 0
bestfittraces = 0
gen_bestmodel = None
gen_bestfit = None
gen_bestPrec = None
gen_bestGen = 0
if DATA_PATH is None:
dir = os.listdir(os.path.join(WORK_PATH, "data", "pns", str(system)))
else:
dir = os.listdir(os.path.join(DATA_PATH, "pns", str(system)))
for file in dir:
if system in file and miner in file:
if DATA_PATH is None:
path = os.path.join(WORK_PATH, "data", "pns", str(system),
file)
else:
path = os.path.join(DATA_PATH, "pns", str(system), file)
print("Checking conformance of file:", path)
net, initial_marking, final_marking = pnml_importer.import_net(
path)
fitness = replay_factory.apply(log, net, initial_marking,
final_marking)
precision = precision_factory.apply(log, net, initial_marking,
final_marking)
generalization = generalization_factory.apply(
log, net, initial_marking, final_marking)
if fitness['perc_fit_traces'] > bestfittraces:
bestfittraces = fitness['perc_fit_traces']
bestmodel = path
bestfit = fitness
bestPrec = precision
bestGen = generalization
elif generalization > bestGen and fitness[
'perc_fit_traces'] == bestfittraces:
bestmodel = path
bestfit = fitness
bestPrec = precision
bestGen = generalization
if generalization > gen_bestGen:
gen_bestmodel = path
gen_bestfit = fitness
gen_bestPrec = precision
gen_bestGen = generalization
net, initial_marking, final_marking = pnml_importer.import_net(
gen_bestmodel)
try:
align_fitness = replay_factory.apply(log,
net,
initial_marking,
final_marking,
variant="alignments")
except:
align_fitness = {"averageFitness": "N/A"}
try:
align_precision = precision_factory.apply(
log,
net,
initial_marking,
final_marking,
variant="align_etconformance")
except:
align_precision = "N/A"
print("")
print("")
print(
"*********** Petri net w/ highest ratio of fitting traces and high generalization *************** "
)
print("Petri net file:", gen_bestmodel)
print("Token-based Fitness=", gen_bestfit['average_trace_fitness'])
print("Token-based Precision=", gen_bestPrec)
print("Alignment-based Fitness=", align_fitness['averageFitness'])
print("Alignment-based Precision=", align_precision)
print("Generalization=", gen_bestGen)
net, initial_marking, final_marking = pnml_importer.import_net(bestmodel)
try:
align_fitness = replay_factory.apply(log,
net,
initial_marking,
final_marking,
variant="alignments")
except:
align_fitness = {"averageFitness": "N/A"}
try:
align_precision = precision_factory.apply(
log,
net,
initial_marking,
final_marking,
variant="align_etconformance")
except:
align_precision = "N/A"
print("")
print(
"*********** Petri net w/ highest ratio of fitting traces and high generalization *************** "
)
print("Petri net file:", bestmodel)
print("Token-based Fitness=", bestfit['average_trace_fitness'])
print("Token-based Precision=", bestPrec)
print("Alignment-based Fitness=", align_fitness['averageFitness'])
print("Alignment-based Precision=", align_precision)
print("Generalization=", bestGen)
