Spaces:
Running
Running
File size: 11,055 Bytes
e60e568 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 |
'''
This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).
PM4Py is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
PM4Py is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with PM4Py. If not, see <https://www.gnu.org/licenses/>.
'''
import importlib.util
import random
import warnings
from enum import Enum
from typing import Optional, Dict, Any
import numpy as np
from pm4py.algo.anonymization.trace_variant_query.util import behavioralAppropriateness as ba
from pm4py.algo.anonymization.trace_variant_query.util import exp_mech as exp
from pm4py.algo.anonymization.trace_variant_query.util.util import generate_pm4py_log
from pm4py.objects.log.obj import EventLog
from pm4py.util import exec_utils
TRACE_START = "TRACE_START"
TRACE_END = "TRACE_END"
EVENT_DELIMETER = ">>>"
activityKey = 'Activity'
class Parameters(Enum):
EPSILON = "epsilon"
K = "k"
P = "p"
SHOW_PROGRESS_BAR = "show_progress_bar"
def apply(log: EventLog, parameters: Optional[Dict[Any, Any]] = None) -> EventLog:
"""
Variant SaCoFa is described in:
S. A. Fahrenkog-Petersen, M. Kabierski, F. Rösel, H. van der Aa and M. Weidlich, "SaCoFa: Semantics-aware
Control-flow Anonymization for Process Mining," 2021 3rd International Conference on Process Mining (ICPM), 2021,
pp. 72-79, doi: 10.1109/ICPM53251.2021.9576857.
Parameters
-------------
log
Event log
parameters
Parameters of the algorithm:
-Parameters.EPSILON -> Strength of the differential privacy guarantee
-Parameters.K -> Maximum prefix length of considered traces for the trace-variant-query
-Parameters.P -> Pruning parameter of the trace-variant-query. Of a noisy trace variant, at least P traces
must appear. Otherwise, the trace variant and its traces won't be part of the result of the
trace variant query.
-Parameters.SHOW_PROGRESS_BAR -> Enables/disables the progress bar (default: True)
Returns
------------
anonymized_trace_variant_distribution
An anonymized trace variant distribution as an EventLog
"""
if parameters is None:
parameters = {}
epsilon = exec_utils.get_param_value(Parameters.EPSILON, parameters, 1)
k = exec_utils.get_param_value(Parameters.K, parameters, 0)
p = exec_utils.get_param_value(Parameters.P, parameters, 1)
if k == 0:
warnings.warn(
"k, the maximum prefix length of considered traces for the trace-variant-query, is set to 0, "
"the trace-varaint-query will be empty.")
if p == 1:
warnings.warn("p, the pruning parameter, is set to 1, the trace-varaint-query might be very large.",
RuntimeWarning)
show_progress_bar = exec_utils.get_param_value(Parameters.SHOW_PROGRESS_BAR, parameters, True)
progress = None
if importlib.util.find_spec("tqdm") and show_progress_bar:
from tqdm.auto import tqdm
progress = tqdm(total=k, desc="prefix tree construction, completed prefixes of length :: ")
return privatize_tracevariants(log, epsilon, p, k, progress)
def privatize_tracevariants(log, epsilon, P, N, progress, smart_pruning=False, P_smart=0, sensitivity=1):
epsilon = epsilon / sensitivity
if not smart_pruning:
P_smart = P
# print("Retrieving behavioral appropriateness relations")
traces = get_traces_from_log(log=log)
events = get_events_from_traces(traces)
followsRelations, precedesRelations = ba.getBARelations(traces=traces, events=events)
events.append(
TRACE_END) # TRACE_END is not relevant for follows/precedes relations, but is later used to generate new prefix variants
# print("Retrieving true prefix frequencies")
known_prefix_frequencies = get_prefix_frequencies_from_log(log=log)
# print("Sanitizing...")
final_frequencies = {}
trace_frequencies = {"": 0}
for n in range(1, N + 1):
# get prefix_frequencies, using either known frequency, or frequency of parent, or 0
trace_frequencies = get_prefix_frequencies_length_n(trace_frequencies, events, n, known_prefix_frequencies)
# exp_mech
trace_frequencies, conformASet = privatize_trace_variants(trace_frequencies=trace_frequencies, epsilon=epsilon,
followRelations=followsRelations,
precedesRelations=precedesRelations, allEvents=events,
allTraces=traces, sensitivity=sensitivity)
# prune
if n < N:
trace_frequencies = prune_trace_frequencies(trace_frequencies, P, P_smart, conformASet)
# add finished traces to output, remove from list, sanity checks
new_frequencies = {}
for entry in trace_frequencies.items():
if TRACE_END in entry[0]:
final_frequencies[entry[0]] = entry[1]
elif n == N:
final_frequencies[entry[0][:-3]] = entry[1]
else:
new_frequencies[entry[0]] = entry[1]
trace_frequencies = new_frequencies
if progress is not None:
progress.update()
if progress is not None:
progress.close()
del progress
return generate_pm4py_log(trace_frequencies=final_frequencies)
def get_prefix_frequencies_from_log(log):
prefix_frequencies = {}
for trace in log:
current_prefix = ""
for event in trace._list:
current_prefix = current_prefix + event._dict.get('concept:name') + EVENT_DELIMETER
if current_prefix in prefix_frequencies:
prefix_frequencies[current_prefix] += 1
else:
prefix_frequencies[current_prefix] = 1
current_prefix = current_prefix + TRACE_END
if current_prefix in prefix_frequencies:
prefix_frequencies[current_prefix] += 1
else:
prefix_frequencies[current_prefix] = 1
return prefix_frequencies
def get_prefix_frequencies_length_n(trace_frequencies, events, n, known_prefix_frequencies):
prefixes_length_n = {}
for prefix, frequency in trace_frequencies.items():
for new_prefix in pref(prefix, events, n):
if new_prefix in known_prefix_frequencies:
new_frequency = known_prefix_frequencies[new_prefix]
prefixes_length_n[new_prefix] = new_frequency
else:
prefixes_length_n[new_prefix] = 0
return prefixes_length_n
def privatize_trace_variants(trace_frequencies, epsilon, followRelations, precedesRelations, allEvents, allTraces,
sensitivity):
conformsToBASet = []
violatesBASet = dict()
firstEvents = get_first_events(
traceSet=allTraces) # all events which appear as the first event in a trace in the original log
for trace_frequency in trace_frequencies.items():
working_trace_frequency = list(filter(None, trace_frequency[0].split(EVENT_DELIMETER)))
if len(working_trace_frequency) == 1: # len(prefix) == 1 -> does a trace which begins with this prefix/event exist in the original log?
if working_trace_frequency[0] in firstEvents: # if so, this prefix conforms to BA, if not BA is violated
conformsToBASet.append(trace_frequency[0])
else:
violatesBASet[trace_frequency[0]] = 1
continue
baViolations = ba.getBAViolations(allEvents=allEvents, followsRelations=followRelations,
precedesRelations=precedesRelations, prefix=working_trace_frequency,
TRACE_END=TRACE_END)
if baViolations == 0:
conformsToBASet.append(trace_frequency[0])
else:
violatesBASet[trace_frequency[0]] = baViolations
not_to_prune_prefix = conformsToBASet.copy()
output_universes = np.linspace(0, len(violatesBASet), num=len(violatesBASet) + 1, dtype=int)
chosen_universe = exp.exp_mech(output_universes, epsilon)
# print("conformsToBASet: ", len(conformsToBASet), "| violatesBASet: ", len(violatesBASet), "| chosen universe: ",
# chosen_universe)
while chosen_universe > 0:
for x in random.sample(list(violatesBASet.keys()), 1):
chosen_universe = chosen_universe - min(violatesBASet[x], sensitivity)
conformsToBASet.append(x)
violatesBASet.pop(x)
return apply_laplace_noise_tf(trace_frequencies, conformsToBASet, epsilon), not_to_prune_prefix
def get_first_events(traceSet):
firstEvents = list()
for trace in traceSet:
if trace[0] not in firstEvents:
firstEvents.append(trace[0])
return firstEvents
def get_traces_from_log(log):
logStringList = list()
i = 0
for trace in log:
logStringList.append(list())
for event in trace._list:
logStringList[i].append(event._dict.get('concept:name'))
i += 1
return logStringList
def get_events_from_traces(traceSet):
events = list()
for t in traceSet:
for e in t:
if e not in events:
events.append(e)
return events
def prune_trace_frequencies(trace_frequencies, P, P_smart, conformSet):
pruned_frequencies = {}
for entry in trace_frequencies.items():
if entry[0] in conformSet:
if entry[1] >= P_smart or TRACE_END in entry[0]:
pruned_frequencies[entry[0]] = entry[1]
else:
if entry[1] >= P or TRACE_END in entry[0]:
pruned_frequencies[entry[0]] = entry[1]
return pruned_frequencies
def pref(prefix, events, n):
prefixes_length_n = []
if not TRACE_END in prefix:
for event in events:
if event == TRACE_END:
current_prefix = prefix + event
else:
current_prefix = prefix + event + EVENT_DELIMETER
prefixes_length_n.append(current_prefix)
return prefixes_length_n
def apply_laplace_noise_tf(trace_frequencies, conformsToBASet, epsilon):
scale = 1 / epsilon
for trace_frequency in conformsToBASet:
noise = int(np.random.laplace(0, scale))
trace_frequencies[trace_frequency] = trace_frequencies[trace_frequency] + noise
if trace_frequencies[trace_frequency] < 0:
trace_frequencies[trace_frequency] = 0
return trace_frequencies
|