class PaperExample(unittest.TestCase):
# Constructing the Petri Net from
log = xes_importer.import_log(os.path.join("paper_log.xes"))
net1, im1, fm1 = petri_importer.apply("fig1.pnml")
#x=generalization.apply(log, net1, im1, fm1)
net2, im2, fm2 = petri_importer.apply("fig2.pnml")
net3, im3, fm3 = petri_importer.apply("fig3.pnml")
net4, im4, fm4 = petri_importer.apply("fig4.pnml")
net5, im5, fm5 = petri_importer.apply("fig5.pnml")
net6, im6, fm6 = petri_importer.apply("fig6.pnml")
net7, im7, fm7 = petri_importer.apply("fig7.pnml")
net8, im8, fm8 = petri_importer.apply("fig8.pnml")
#3std
## precision tests
def test_precision_figure1(self):
fac = Quality_dimension_factory(self.log, self.net1, self.im1,
self.fm1)
fac.compute_alignments_of_length()
self.assertAlmostEqual(fac.apply(alpha_generalization=None),
0.871,
places=3)
#
def test_precision_figure2(self):
fac = Quality_dimension_factory(self.log, self.net2, self.im2,
self.fm2)
fac.compute_alignments_of_length()
self.assertAlmostEqual(fac.apply(alpha_generalization=None),
1.000,
places=3)
# def test_precision_figure5(self): #AssertionError: 0.8714285714285714 != 0.8 within 3 places (0.0714285714285714 difference)
# self.assertAlmostEqual(Quality_dimension_factory(self.log, self.net5, self.im5, self.fm5).apply(alpha_generalization=None), 0.800, places=3)
# def test_precision_figure6(self): #AssertionError: 0.6184981684981685 != 0.588 within 3 places
# fac=Quality_dimension_factory(self.log, self.net6, self.im6, self.fm6)
# fac.compute_alignments_of_length()
# self.assertAlmostEqual(fac.apply(alpha_generalization=None), 0.588, places=3)
##
# def test_precision_figure8(self): #Problem: State space of Reachbility graph
# fac=Quality_dimension_factory(self.log, self.net8, self.im8, self.fm8)
# fac.compute_alignments_of_length()
# self.assertAlmostEqual(fac.apply(alpha_generalization=None), 0.033, places=3)
#
# #generalisation_tests
def test_generalization_figure1(self):
fac = Quality_dimension_factory(self.log, self.net1, self.im1,
self.fm1)
fac.compute_alignments_of_length()
self.assertAlmostEqual(fac.apply(alpha_precision=None),
0.206,
places=3)
#
def test_generalization_figure2(self):
fac = Quality_dimension_factory(self.log, self.net2, self.im2,
self.fm2)
fac.compute_alignments_of_length()
self.assertAlmostEqual(fac.apply(alpha_precision=None),
0.000,
places=3)
import warnings
import warnings
warnings.filterwarnings("ignore")
sys.path.insert(
1,
'C:\\Users\\USER\\Documents\\Vorlesungen\\Conformance Checking\\lab-anti-alignment'
) # path where the project is when no IDE is used
from anti_alignment.quality_dimensions.quality_dimension_factory import Quality_dimension_factory
import numpy as np
log = xes_importer.import_log(os.path.join("../test/test_one/paper_log.xes"))
net, im, fm = petri_importer.apply("../test/test_one/fig1.pnml")
start = 0.1
end = 1
intervall = 0.1
calc = True
if calc:
#factories=[]*((end-start)/intervall)
factories = {}
precision = {}
generalisation = {}
k_vals = np.arange(start, end, intervall)
for k in k_vals:
fac = Quality_dimension_factory(log, net, im, fm)
fac.compute_alignments_of_length(15)
factories[15] = fac
def biased_playout_b2(
pn,
f_pop,
f_train,
f_test,
xes_train,
csv_train,
):
print("*** PLAYOUT " + str(pn) + " ***")
f_pn = os.path.join(pn)
net, initial_marking, final_marking = pnml_importer.apply(f_pn)
print("Initial Marking:", initial_marking)
print("Final Marking:", final_marking)
player = Player(net,
initial_marking,
final_marking,
maxTraceLength=200,
rep_inv_thresh=100,
max_loop=3)
gen_traces = player.play()
print("Total Number of Variants:", len(gen_traces))
writeVariantToFile(f_pop, gen_traces)
print("Unique Variant Log stored in:", str(f_pop))
max_len = 0
for trace in gen_traces:
if len(trace) > max_len:
max_len = len(trace)
test = list()
train = list()
gen_traces = list(gen_traces)
gen_traces.sort(key=lambda s: -len(s))
threshold = 0.7 * len(gen_traces)
cnt = 0
for trace in gen_traces:
if cnt < threshold:
train.append(trace)
else:
test.append(trace)
cnt += 1
print()
print("Mean variant length size train:", np.mean([len(s) for s in train]))
print("Mean variant length size test:", np.mean([len(s) for s in test]))
print()
print("Max variant length size train:", np.max([len(s) for s in train]))
print("Max variant length size test:", np.max([len(s) for s in test]))
print()
writeVariantToFile(f_train, train)
print("b2 Biased Unique Variant Log (Train, 70%) stored in:", str(f_train))
writeVariantToFile(f_test, test)
print("b2 Biased Unique Variant Log (Test, 30%) stored in:", str(f_test))
prepare_xes_csv(f_train, xes_train, csv_train)
printStatistics(f_pop, f_train, f_test)
def biased_playout_b4(
pn,
f_pop,
f_train,
f_test,
xes_train,
csv_train,
):
print("*** PLAYOUT " + str(pn) + " ***")
f_pn = os.path.join(pn)
net, initial_marking, final_marking = pnml_importer.apply(f_pn)
print("Initial Marking:", initial_marking)
print("Final Marking:", final_marking)
player = Player(net,
initial_marking,
final_marking,
maxTraceLength=200,
rep_inv_thresh=100,
max_loop=3)
gen_traces = player.play()
print("Total Number of Variants:", len(gen_traces))
writeVariantToFile(f_pop, gen_traces)
print("Unique Variant Log stored in:", str(f_pop))
max_len = 0
for trace in gen_traces:
if len(trace) > max_len:
max_len = len(trace)
test = list()
train = list()
gen_traces = list(gen_traces)
gen_traces.sort(key=lambda s: -len(s))
threshold = 0.7 * len(gen_traces)
cnt = 0
for trace in gen_traces:
if cnt < threshold:
train.append(trace)
else:
test.append(trace)
cnt += 1
r_train = []
r_test = []
p_thresh = 0.75
for t in test:
p = np.random.uniform(0, 1, 1)[0]
if p < p_thresh:
r_test.append(t)
else:
r_train.append(t)
required_transfers = len(r_train)
train_transfer = random.sample(train, required_transfers)
while np.max([len(s) for s in train_transfer]) == max_len:
train_transfer = random.sample(train, required_transfers)
print("resample")
for t in train:
if t in train_transfer:
r_test.append(t)
else:
r_train.append(t)
print()
print("Transfer", len(train_transfer), "variants from train to test.")
print("Mean variant length size train (before randomization):",
np.mean([len(s) for s in train]))
print("Mean variant length size test (before randomization):",
np.mean([len(s) for s in test]))
print("Mean variant length size train (after randomization):",
np.mean([len(s) for s in r_train]))
print("Mean variant length size test (after randomization):",
np.mean([len(s) for s in r_test]))
print("Size before and after randomization (train):", len(train),
len(r_train))
print("Size before and after randomization (test):", len(test),
len(r_test))
print()
print("Max variant length size train (after randomization):",
np.max([len(s) for s in r_train]))
print("Max variant length size test (after randomization):",
np.max([len(s) for s in r_test]))
print()
writeVariantToFile(f_train, r_train)
print("b4 Biased Unique Variant Log (Train, 70%) stored in:", str(f_train))
writeVariantToFile(f_test, r_test)
print("b4 Biased Unique Variant Log (Test, 30%) stored in:", str(f_test))
prepare_xes_csv(f_train, xes_train, csv_train)
printStatistics(f_pop, f_train, f_test)
def standard_playout(pn,
f_pop,
f_train,
f_test,
xes_train,
csv_train,
train_size=0.7):
print("*** PLAYOUT " + str(pn) + " ***")
f_pn = os.path.join(pn)
net, initial_marking, final_marking = pnml_importer.apply(f_pn)
print("Initial Marking:", initial_marking)
print("Final Marking:", final_marking)
player = Player(net,
initial_marking,
final_marking,
maxTraceLength=200,
rep_inv_thresh=100,
max_loop=3)
gen_traces = player.play()
print("Total Number of Variants:", len(gen_traces))
writeVariantToFile(f_pop, gen_traces)
print("Unique Variant Log stored in:", str(f_pop))
max_len = 0
for trace in gen_traces:
if len(trace) > max_len:
max_len = len(trace)
test = list()
train = list()
for trace in gen_traces:
if len(trace) == max_len:
train.append(trace)
gen_traces.remove(trace)
break
indices = [i for i in range(0, len(gen_traces))]
train_indices, test_indices = train_test_split(indices,
train_size=train_size)
for index, trace in enumerate(gen_traces):
if index in train_indices:
train.append(trace)
else:
test.append(trace)
print()
print("Mean variant length size train:", np.mean([len(s) for s in train]))
print("Mean variant length size test:", np.mean([len(s) for s in test]))
print()
print("Max variant length size train:", np.max([len(s) for s in train]))
print("Max variant length size test:", np.max([len(s) for s in test]))
print()
writeVariantToFile(f_train, train)
print(
"Unique Variant Log (Train, " + str(int(train_size * 100)) +
"%) stored in:", str(f_train))
writeVariantToFile(f_test, test)
print(
"Unique Variant Log (Test, " + str(int(
(1 - train_size) * 100)) + "%) stored in:", str(f_test))
prepare_xes_csv(f_train, xes_train, csv_train)
printStatistics(f_pop, f_train, f_test)
'C:\\Users\\USER\\Documents\\Vorlesungen\\Conformance Checking\\lab-anti-alignment'
)
import time
from anti_alignment.quality_dimensions.quality_dimension_factory import Quality_dimension_factory
from pm4py.objects.petri.importer import factory as petri_importer
from pm4py.objects.log.importer.xes import factory as xes_importer
import os
from pm4py.evaluation.precision import factory as precision_factory
from pm4py.evaluation.generalization import factory as generalization_factory
path = "3-way match - invoice after GR - service - without SRM"
log_file = os.path.join(path, "BPI_Challenge_2019.xes")
log = xes_importer.import_log(log_file)
for model in ["02.pnml"]:
net, im, fm = petri_importer.apply(os.path.join(path, model))
print("Current Model: " + model)
print("Number of places: " + str(len(list(net.places))))
print("Number of transitions: " + str(len(list(net.transitions))))
results = []
fac = Quality_dimension_factory(log, net, im, fm)
while len(results) < 1:
start = time.time()
fac.compute_alignments_of_length()
(pre, gen) = fac.apply()
end = time.time()
results.append(end - start)
print()
print("Results of our approach")
print("Precision: " + str(pre))
work_buffer = logstateprob.T
for i in prange(n_states):
work_buffer[i, :] += prev_logfwd
# work_buffer = logstateprob.T + prev_logfwd
cur_logfwd_est = logsumexp2d(work_buffer, axis=1)
return cur_logfwd_est
if __name__ == '__main__':
start_all = time.time()
configs_df = experiment_configs2df(EXPERIMENT_CONFIGS)
info_msg = 'Experiment configuration: \n{}'.format(configs_df)
logger.info(info_msg)
net_orig, init_marking_orig, final_marking_orig = pnml_importer.apply(
NET_FP)
net, init_marking, final_marking = pnml_importer.apply(NET_FP)
store = pd.HDFStore(STORE_FP, mode='r')
case_prefix_df = store['case_prefix_df']
activity_list = sorted(case_prefix_df['activity'].unique())
activity_cat_type = CategoricalDtype(categories=activity_list)
logger.info('Mapping activity to integer labels')
obs2int = dict(enumerate(activity_cat_type.categories))
obs2int = {v: k for k, v in obs2int.items()}
int2obs = {v: k for k, v in obs2int.items()}
obs2int_df = pd.DataFrame(list(obs2int.items()),
columns=['activity', 'activity_int'])
info_msg = 'Activity 2 int dataframe: \n{}'.format(obs2int_df)
logger.info(info_msg)
map_net_activity(net, obs2int)
def py_data_2019_demo_script():
event_data = xes_log_importer.apply('<path_to_data>')
model, marking_i, marking_f = pn_importer.apply('<path_to_model>')
alignments = alignment_algorithm.apply(event_data, model, marking_i, marking_f)
print(alignments)
def read_pnml():
log = Log.objects.first()
# for some reason it just works by passing the file object...
net, init_marking, final_marking = pnml_importer.apply(log.file_pnml)
return net, init_marking, final_marking
