From 2f059a948dcceae76489aede3e25d01fad06a78a Mon Sep 17 00:00:00 2001 From: MarcusRostSAP <146723913+MarcusRostSAP@users.noreply.github.com> Date: Mon, 25 Mar 2024 10:20:55 +0100 Subject: [PATCH] Explainability (#7) * Initial commit explainer module * Some experimentation * Tried a new heurstic * Some code clean up * Slight change in logic * added activation feature * Made some changes to the activation and logic * Updated notebook * some small logic changes * Notebook compile * added shapley_values * Progress on shapely for traces * Added comments * Linting issues * Linting * Linting * more linting * More linting * Linting * Linting * linter * Linter * Linting --- .gitignore | 4 + bpmnconstraints/script.py | 1 + bpmnconstraints/utils/plot.py | 1 + explainer/README.md | 47 ++ explainer/explainer.py | 546 ++++++++++++++++++++ explainer/tutorial/explainer_tutorial.ipynb | 308 +++++++++++ setup.py | 1 + tests/explainer/explainer_test.py | 261 ++++++++++ tutorial/tutorial.ipynb | 4 +- 9 files changed, 1171 insertions(+), 2 deletions(-) create mode 100644 explainer/README.md create mode 100644 explainer/explainer.py create mode 100644 explainer/tutorial/explainer_tutorial.ipynb create mode 100644 tests/explainer/explainer_test.py diff --git a/.gitignore b/.gitignore index 3dc4d04..d34c252 100644 --- a/.gitignore +++ b/.gitignore @@ -135,3 +135,7 @@ dmypy.json .idea/ .vscode/ + +# explainer Stuff +explainer/test.py +explainer/old_code.py \ No newline at end of file diff --git a/bpmnconstraints/script.py b/bpmnconstraints/script.py index 6f7eb1e..060ca00 100644 --- a/bpmnconstraints/script.py +++ b/bpmnconstraints/script.py @@ -1,4 +1,5 @@ """Entry point for bpmnsignal command. Verifies argument and runs parser.""" + # pylint: disable=import-error import argparse import logging diff --git a/bpmnconstraints/utils/plot.py b/bpmnconstraints/utils/plot.py index 7a5990c..434b782 100644 --- a/bpmnconstraints/utils/plot.py +++ b/bpmnconstraints/utils/plot.py @@ -1,6 +1,7 @@ """ Module for plotting functions. """ + # pylint: disable=import-error import matplotlib.pyplot as plt diff --git a/explainer/README.md b/explainer/README.md new file mode 100644 index 0000000..e4052a2 --- /dev/null +++ b/explainer/README.md @@ -0,0 +1,47 @@ +# Symbolic Explanations of Process Conformance Violations +## Introduction + + +# Regex usage for the first iteration of the software + +## 1. Sequence Constraint +Pattern: `'A.*B.*C'` + +Explanation: This regex specifies that for a trace to be conformant, it must contain the nodes 'A', 'B', and 'C' in that order, though not necessarily consecutively. The .* allows for any number of intervening nodes between the specified nodes. + +> Example: A trace ['A', 'X', 'B', 'Y', 'C'] would be conformant, while ['A', 'C', 'B'] would not. + +## 2. Immediate Succession +Pattern: `'AB'` + +Explanation: This regex specifies that node 'A' must be immediately followed by node 'B' with no intervening nodes. + +> Example: A trace ['A', 'B', 'C'] would be conformant, while ['A', 'X', 'B'] would not. + +## 3. Optional Node +Pattern: `'A(B)?C'` + +Explanation: This regex specifies that the node 'B' is optional between 'A' and 'C'. The node 'C' must follow 'A', but 'B' can either be present or absent. + +> Example: Both traces ['A', 'B', 'C'] and ['A', 'C'] would be conformant. + +## 4. Excluding Specific Nodes +Pattern: `'A[^D]*B'` + +Explanation: This regex specifies that 'A' must be followed by 'B' without the occurrence of 'D' in between them. The [^D] part matches any character except 'D'. + +> Example: A trace ['A', 'C', 'B'] would be conformant, while ['A', 'D', 'B'] would not. + +## 5. Repetition of Nodes +Pattern: `'A(B{2,3})C'` + +Explanation: This regex specifies that 'A' must be followed by 'B' repeated 2 to 3 times and then followed by 'C'. + +> Example: Traces ['A', 'B', 'B', 'C'] and ['A', 'B', 'B', 'B', 'C'] would be conformant, while ['A', 'B', 'C'] or ['A', 'B', 'B', 'B', 'B', 'C'] would not. + +## 6. Alternative Paths +Pattern: `'A(B|D)C'` + +Explanation: This regex specifies that after 'A', there must be either a 'B' or a 'D', followed by a 'C'. + +> Example: Both traces ['A', 'B', 'C'] and ['A', 'D', 'C'] would be conformant. diff --git a/explainer/explainer.py b/explainer/explainer.py new file mode 100644 index 0000000..ffb2811 --- /dev/null +++ b/explainer/explainer.py @@ -0,0 +1,546 @@ +import math +import re +from itertools import combinations, product, chain + + +class Trace: + def __init__(self, nodes): + """ + Initializes a Trace instance. + + :param nodes: A list of nodes where each node is represented as a string label. + """ + self.nodes = nodes + + def __len__(self): + """ + Returns the number of nodes in the trace. + """ + return len(self.nodes) + + def __iter__(self): + """ + Initializes the iteration over the nodes in the trace. + """ + self.index = 0 + return self + + def __next__(self): + """ + Returns the next node in the trace during iteration. + """ + if self.index < len(self.nodes): + result = self.nodes[self.index] + self.index += 1 + return result + else: + raise StopIteration + + def __split__(self): + """ + Splits the nodes of the trace into a list. + + :return: A list containing the nodes of the trace. + """ + spl = [] + for node in self.nodes: + spl.append(node) + return spl + + +class EventLog: + def __init__(self, trace=None): + """ + Initializes an EventLog instance. + + :param traces: A list of Trace instances. + """ + self.log = {} + if trace: + self.add_trace(trace) + + def add_trace(self, trace, count=1): + """ + Adds a trace to the log or increments its count if it already exists. + + :param trace: A Trace instance to add. + """ + trace_tuple = tuple(trace.nodes) + if trace_tuple in self.log: + self.log[trace_tuple] += count + else: + self.log[trace_tuple] = count + + def remove_trace(self, trace, count=1): + """ + Removes a trace from the log or decrements its count if the count is greater than 1. + + :param trace: A Trace instance to remove. + """ + trace_tuple = tuple(trace.nodes) + if trace_tuple in self.log: + if self.log[trace_tuple] > count: + self.log[trace_tuple] -= count + else: + del self.log[trace_tuple] + + def __str__(self): + """ + Returns a string representation of the event log. + """ + return str(self.log) + + def __len__(self): + """ + Returns the total number of trace occurrences in the log. + """ + return sum(self.log.values()) + + def __iter__(self): + """ + Allows iteration over each trace occurrence in the log. + """ + for trace_tuple, count in self.log.items(): + for _ in range(count): + yield Trace(list(trace_tuple)) + + +class Explainer: + def __init__(self): + """ + Initializes an Explainer instance. + """ + self.constraints = [] # List to store constraints (regex patterns) + self.adherent_trace = None + + def add_constraint(self, regex): + """ + Adds a new constraint and updates the nodes list. + + :param regex: A regular expression representing the constraint. + """ + self.constraints.append(regex) + if self.contradiction(): + self.constraints.remove(regex) + print(f"Constraint {regex} contradicts the other constraints.") + + def remove_constraint(self, idx): + """ + Removes a constraint by index and updates the nodes list if necessary. + + :param idx: Index of the constraint to be removed. + """ + if 0 <= idx < len(self.constraints): + removed_regex = self.constraints.pop(idx) + removed_nodes = set(filter(str.isalpha, removed_regex)) + + # Re-evaluate nodes to keep based on remaining constraints + remaining_nodes = set(filter(str.isalpha, "".join(self.constraints))) + self.nodes = remaining_nodes + + # Optionally, remove nodes that are no longer in any constraint + for node in removed_nodes: + if node not in remaining_nodes: + self.nodes.discard(node) + + def activation(self, trace, constraints=None): + """ + Checks if any of the nodes in the trace activates any constraint. + + :param trace: A Trace instance. + :return: Boolean indicating if any constraint is activated. + """ + if not constraints: + constraints = self.constraints + con_activation = [0] * len(constraints) + activated = False + for idx, con in enumerate(constraints): + if activated: + activated = False + continue + target = self.identify_existance_constraints(con) + if target: + con_activation[idx] = 1 + continue + for event in trace: + if event in con: + con_activation[idx] = 1 + activated = True + break + return con_activation + + def identify_existance_constraints(self, pattern): + """ + Identifies existance constraints within a pattern. + + :param pattern: The constraint pattern as a string. + :return: A tuple indicating the type of existance constraint and the node involved. + """ + # Check for AtLeastOne constraint + for match in re.finditer(r"(? 100: + return f"{explanation}\n Maximum depth of {depth -1} reached" + score = self.evaluate_similarity(working_trace) + return self.operate_on_trace(working_trace, score, explanation, depth) + + def operate_on_trace(self, trace, score, explanation_path, depth=0): + """ + Finds and applies modifications to the trace to make it conformant. + + :param trace: The trace to be modified. + :param score: The similarity score of the trace. + :param explanation_path: The current explanation path. + :param depth: The current recursion depth. + :return: A string explaining why the best subtrace is non-conformant or a message indicating the maximum depth has been reached. + """ + explanation = None + counter_factuals = self.modify_subtrace(trace) + best_subtrace = None + best_score = -float("inf") + for subtrace in counter_factuals: + current_score = self.evaluate_similarity(subtrace[0]) + if current_score > best_score and current_score > score: + best_score = current_score + best_subtrace = subtrace[0] + explanation = subtrace[1] + if best_subtrace == None: + for subtrace in counter_factuals: + self.operate_on_trace(subtrace[0], score, explanation_path, depth + 1) + explanation_string = explanation_path + "\n" + str(explanation) + return self.counter_factual_helper(best_subtrace, explanation_string, depth + 1) + + def get_nodes_from_constraint(self, constraint=None): + """ + Extracts unique nodes from a constraint pattern. + + :param constraint: The constraint pattern as a string. + :return: A list of unique nodes found within the constraint. + """ + if constraint is None: + all_nodes = set() + for con in self.constraints: + all_nodes.update(re.findall(r"[A-Za-z]", con)) + return list(set(all_nodes)) + else: + return list(set(re.findall(r"[A-Za-z]", constraint))) + + def modify_subtrace(self, trace): + """ + Modifies the given trace to meet constraints by adding nodes where the pattern fails. + + Parameters: + - trace: A list of node identifiers + + Returns: + - A list of potential subtraces each modified to meet constraints. + """ + potential_subtraces = [] + possible_additions = self.get_nodes_from_constraint() + for i, s_trace in enumerate(get_iterative_subtrace(trace)): + for con in self.constraints: + new_trace_str = "".join(s_trace) + match = re.match(new_trace_str, con) + if not match: + for add in possible_additions: + potential_subtraces.append( + [ + Trace(s_trace + [add] + trace.nodes[i + 1 :]), + f"Addition (Added {add} at position {i+1}): " + + "->".join(s_trace + [add] + trace.nodes[i + 1 :]), + ] + ) + potential_subtraces.append( + [ + Trace(s_trace[:-1] + [add] + trace.nodes[i:]), + f"Addition (Added {add} at position {i}): " + + "->".join(s_trace[:-1] + [add] + trace.nodes[i:]), + ] + ) + + potential_subtraces.append( + [ + Trace(s_trace[:-1] + trace.nodes[i + 1 :]), + f"Subtraction (Removed {s_trace[i]} from position {i}): " + + "->".join(s_trace[:-1] + trace.nodes[i + 1 :]), + ] + ) + return potential_subtraces + + def determine_shapley_value(self, log, constraints, index): + """Determines the Shapley value-based contribution of a constraint to a the + overall conformance rate. + Args: + log (dictionary): The event log, where keys are strings and values are + ints + constraints (list): A list of constraints (regexp strings) + index (int): The + Returns: + float: The contribution of the constraint to the overall conformance + rate + """ + if len(constraints) < index: + raise Exception("Constraint not in constraint list.") + contributor = constraints[index] + sub_ctrbs = [] + reduced_constraints = [c for c in constraints if not c == contributor] + subsets = determine_powerset(reduced_constraints) + for subset in subsets: + lsubset = list(subset) + constraints_without = [c for c in constraints if c in lsubset] + constraints_with = [c for c in constraints if c in lsubset + [contributor]] + weight = ( + math.factorial(len(lsubset)) + * math.factorial(len(constraints) - 1 - len(lsubset)) + ) / math.factorial(len(constraints)) + sub_ctrb = weight * ( + self.determine_conformance_rate(log, constraints_without) + - self.determine_conformance_rate(log, constraints_with) + ) + sub_ctrbs.append(sub_ctrb) + return sum(sub_ctrbs) + + def evaluate_similarity(self, trace): + """ + Calculates the similarity between the adherent trace and the given trace using the Levenshtein distance. + + :param trace: The trace to compare with the adherent trace. + :return: A normalized score indicating the similarity between the adherent trace and the given trace. + """ + length = len(self.adherent_trace) + trace_len = len("".join(trace)) + lev_distance = levenshtein_distance(self.adherent_trace, "".join(trace)) + max_distance = max(length, trace_len) + normalized_score = 1 - lev_distance / max_distance + return normalized_score + + def determine_conformance_rate(self, event_log, constraints=None): + """ + Determines the conformance rate of the event log based on the given constraints. + + :param event_log: The event log to analyze. + :param constraints: The constraints to check against the event log. + :return: The conformance rate as a float between 0 and 1, or a message if no constraints are provided. + """ + if not self.constraints and not constraints: + return "The explainer have no constraints" + len_log = len(event_log) + if len_log == 0: + return 1 + non_conformant = 0 + if constraints == None: + constraints = self.constraints + for trace, count in event_log.log.items(): + for con in constraints: + if not re.search(con, "".join(trace)): + non_conformant += count + break + return (len_log - non_conformant) / len_log + + def trace_contribution_to_conformance_loss( + self, event_log, trace, constraints=None + ): + """ + Calculates the contribution of a specific trace to the conformance loss of the event log. + + :param event_log: The event log to analyze. + :param trace: The trace to calculate its contribution. + :param constraints: The constraints to check against the event log. + :return: The contribution of the trace to the conformance loss as a float between 0 and 1. + """ + if not constraints: + constraints = self.constraints + total_traces = len(event_log) + contribution_of_trace = 0 + for t, count in event_log.log.items(): + if not self.conformant(t, constraints): + if trace.nodes == list(t): + contribution_of_trace = count + + return contribution_of_trace / total_traces + + +def determine_powerset(elements): + """Determines the powerset of a list of elements + Args: + elements (set): Set of elements + Returns: + list: Powerset of elements + """ + lset = list(elements) + ps_elements = chain.from_iterable( + combinations(lset, option) for option in range(len(lset) + 1) + ) + return [set(ps_element) for ps_element in ps_elements] + + +def get_sublists(lst): + """ + Generates all possible non-empty sublists of a list. + + :param lst: The input list. + :return: A list of all non-empty sublists. + """ + sublists = [] + for r in range(2, len(lst) + 1): # Generate combinations of length 2 to n + sublists.extend(combinations(lst, r)) + return sublists + + +def get_iterative_subtrace(trace): + """ + Generates all possible non-empty contiguous sublists of a list, maintaining order. + + :param lst: The input list. + n: the minmum length of sublists + :return: A list of all non-empty contiguous sublists. + """ + sublists = [] + for i in range(0, len(trace)): + sublists.append(trace.nodes[0 : i + 1]) + + return sublists + + +def levenshtein_distance(seq1, seq2): + """ + Calculates the Levenshtein distance between two sequences. + + Args: + seq1 (str): The first sequence. + seq2 (str): The second sequence. + + Returns: + int: The Levenshtein distance between the two sequences. + """ + size_x = len(seq1) + 1 + size_y = len(seq2) + 1 + matrix = [[0] * size_y for _ in range(size_x)] + for x in range(size_x): + matrix[x][0] = x + for y in range(size_y): + matrix[0][y] = y + + for x in range(1, size_x): + for y in range(1, size_y): + if seq1[x - 1] == seq2[y - 1]: + matrix[x][y] = matrix[x - 1][y - 1] + else: + matrix[x][y] = min( + matrix[x - 1][y] + 1, matrix[x][y - 1] + 1, matrix[x - 1][y - 1] + 1 + ) + return matrix[size_x - 1][size_y - 1] diff --git a/explainer/tutorial/explainer_tutorial.ipynb b/explainer/tutorial/explainer_tutorial.ipynb new file mode 100644 index 0000000..c8c0504 --- /dev/null +++ b/explainer/tutorial/explainer_tutorial.ipynb @@ -0,0 +1,308 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Explainer utility in BPMN2CONSTRAINTS\n", + "\n", + "In this notebook, we explore the `Explainer` class, designed to analyze and explain the conformance of traces against predefined constraints. Trace analysis is crucial in domains such as process mining, where understanding the behavior of system executions against expected models can uncover inefficiencies, deviations, or compliance issues.\n", + "\n", + "The constraints currently consists of basic regex, this is because of it's similiarities and likeness to declarative constraints used in BPMN2CONSTRAINTS\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append('../')\n", + "from explainer import Explainer, Trace" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Basic Usage\n", + "Let's start by creating an instance of the `Explainer` and adding a simple constraint that a valid trace should contain the sequence \"A\" followed by \"B\" and then \"C\".\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "explainer = Explainer()\n", + "explainer.add_constraint('A.*B.*C')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Analyzing Trace Conformance\n", + "\n", + "Now, we'll create a trace and check if it conforms to the constraints we've defined." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Is the trace conformant? True\n" + ] + } + ], + "source": [ + "trace = Trace(['A', 'X', 'B', 'Y', 'C'])\n", + "is_conformant = explainer.conformant(trace)\n", + "print(f\"Is the trace conformant? {is_conformant}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Explaining Non-conformance\n", + "\n", + "If a trace is not conformant, we can use the `minimal_expl` and `counterfactual_expl` methods to understand why and how to adjust the trace.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Constraint: A.*B.*C\n", + "Trace:['A', 'C']\n", + "\n", + "Addition (Added B at position 1): A->B->C\n", + "Non-conformance due to: Constraint (A.*B.*C) is violated by subtrace: ('A', 'C')\n", + "-----------\n", + "Constraint: A.*B.*C\n", + "Trace:['C', 'B', 'A']\n", + "\n", + "Addition (Added A at position 1): C->A->B->A\n", + "Subtraction (Removed C from position 0): A->B->A\n", + "Addition (Added C at position 2): A->B->C->A\n", + "Non-conformance due to: Constraint (A.*B.*C) is violated by subtrace: ('C', 'B')\n", + "-----------\n", + "Constraint: A.*B.*C\n", + "Trace:['A', 'A', 'C']\n", + "\n", + "Addition (Added B at position 2): A->A->B->C\n", + "Non-conformance due to: Constraint (A.*B.*C) is violated by subtrace: ('A', 'A')\n", + "-----------\n", + "Constraint: A.*B.*C\n", + "Trace:['A', 'A', 'C', 'A', 'TEST', 'A', 'C', 'X', 'Y']\n", + "-----------\n", + "Constraint: AC\n", + "Trace:['A', 'X', 'C']\n", + "\n", + "Subtraction (Removed X from position 1): A->C\n", + "Non-conformance due to: Constraint (AC) is violated by subtrace: ('A', 'X')\n", + "-----------\n", + "constraint: AC\n", + "constraint: B.*A.*B.*C\n", + "constraint: A.*B.*C.*\n", + "constraint: A.*D.*B*\n", + "constraint: A[^D]*B\n", + "constraint: B.*[^X].*\n", + "Trace:['A', 'X', 'C']\n", + "\n", + "Subtraction (Removed X from position 1): A->C\n", + "Non-conformance due to: Constraint (AC) is violated by subtrace: ('A', 'X')\n" + ] + } + ], + "source": [ + "non_conformant_trace = Trace(['A', 'C'])\n", + "print('Constraint: A.*B.*C')\n", + "print('Trace:' + str(non_conformant_trace.nodes))\n", + "print(explainer.counterfactual_expl(non_conformant_trace))\n", + "print(explainer.minimal_expl(non_conformant_trace))\n", + "\n", + "non_conformant_trace = Trace(['C', 'B', 'A'])\n", + "print('-----------')\n", + "print('Constraint: A.*B.*C')\n", + "print('Trace:' + str(non_conformant_trace.nodes))\n", + "print(explainer.counterfactual_expl(non_conformant_trace))\n", + "print(explainer.minimal_expl(non_conformant_trace))\n", + "\n", + "non_conformant_trace = Trace(['A','A','C'])\n", + "print('-----------')\n", + "print('Constraint: A.*B.*C')\n", + "print('Trace:' + str(non_conformant_trace.nodes))\n", + "print(explainer.counterfactual_expl(non_conformant_trace))\n", + "print(explainer.minimal_expl(non_conformant_trace))\n", + "\n", + "\n", + "non_conformant_trace = Trace(['A','A','C','A','TEST','A','C', 'X', 'Y']) \n", + "print('-----------')\n", + "print('Constraint: A.*B.*C')\n", + "print('Trace:' + str(non_conformant_trace.nodes))\n", + "#print(explainer.counterfactual_expl(non_conformant_trace))\n", + "#print(explainer.minimal_expl(non_conformant_trace))\n", + "\n", + "\n", + "explainer.remove_constraint(0)\n", + "explainer.add_constraint('AC')\n", + "non_conformant_trace = Trace(['A', 'X', 'C']) #Substraction\n", + "print('-----------')\n", + "print('Constraint: AC')\n", + "print('Trace:' + str(non_conformant_trace.nodes))\n", + "print(explainer.counterfactual_expl(non_conformant_trace))\n", + "print(explainer.minimal_expl(non_conformant_trace))\n", + "print('-----------')\n", + "\n", + "explainer.add_constraint('B.*A.*B.*C')\n", + "explainer.add_constraint('A.*B.*C.*')\n", + "explainer.add_constraint('A.*D.*B*')\n", + "explainer.add_constraint('A[^D]*B')\n", + "explainer.add_constraint('B.*[^X].*')\n", + "non_conformant_trace = Trace(['A', 'X', 'C']) #Substraction\n", + "for con in explainer.constraints:\n", + " print(f'constraint: {con}')\n", + "print('Trace:' + str(non_conformant_trace.nodes))\n", + "print(explainer.counterfactual_expl(non_conformant_trace))\n", + "print(explainer.minimal_expl(non_conformant_trace))\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 5: Event Logs and Shapely values\n", + "\n", + "The event logs in this context is built with traces, here's how you set them up." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Conformance rate: 0.2\n", + "Contribution ^A: 0.5\n", + "Contribution C$: 0.30000000000000004\n" + ] + } + ], + "source": [ + "from explainer import EventLog\n", + "\n", + "event_log = EventLog()\n", + "trace1 = Trace(['A', 'B', 'C'])\n", + "trace2 = Trace(['B', 'C'])\n", + "trace3 = Trace(['A', 'B'])\n", + "trace4 = Trace(['B'])\n", + "\n", + "event_log.add_trace(trace1, 5) # The second is how many traces you'd like to add, leave blank for 1\n", + "event_log.add_trace(trace2, 10)\n", + "event_log.add_trace(trace3, 5)\n", + "event_log.add_trace(trace4, 5)\n", + "\n", + "\n", + "exp = Explainer()\n", + "exp.add_constraint(\"^A\")\n", + "exp.add_constraint(\"C$\")\n", + "print(\"Conformance rate: \"+ str(exp.determine_conformance_rate(event_log)))\n", + "print('Contribution ^A:', exp.determine_shapley_value(event_log, exp.constraints, 0))\n", + "print('Contribution C$:', exp.determine_shapley_value(event_log, exp.constraints, 1))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "conformant AC :True\n", + "Conformance rate: 0.14\n", + "Contribution C$: 0.21\n", + "Contribution ^A: 0.36\n", + "Contribution B+: 0.29\n" + ] + } + ], + "source": [ + "exp = Explainer()\n", + "event_log = EventLog()\n", + "trace1 = Trace(['A', 'B', 'C'])\n", + "trace2 = Trace(['B', 'C'])\n", + "trace3 = Trace(['A', 'B'])\n", + "trace4 = Trace(['B'])\n", + "trace5 = Trace(['A', 'C'])\n", + "\n", + "\n", + "event_log.add_trace(trace1, 5) # The second is how many traces you'd like to add, leave blank for 1\n", + "event_log.add_trace(trace2, 10)\n", + "event_log.add_trace(trace3, 5)\n", + "event_log.add_trace(trace4, 5)\n", + "event_log.add_trace(trace5, 10)\n", + "\n", + "\n", + "exp = Explainer()\n", + "exp.add_constraint(\"C$\")\n", + "exp.add_constraint(\"^A\")\n", + "exp.add_constraint(\"B+\")\n", + "print(\"conformant AC :\" + str(exp.conformant(trace5)))\n", + "print(\"Conformance rate: \"+ str(round(exp.determine_conformance_rate(event_log), 2)))\n", + "print('Contribution C$:', round(exp.determine_shapley_value(event_log, exp.constraints, 0), 2))\n", + "print('Contribution ^A:', round(exp.determine_shapley_value(event_log, exp.constraints, 1), 2))\n", + "print('Contribution B+:', round(exp.determine_shapley_value(event_log, exp.constraints, 2), 2))\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/setup.py b/setup.py index dffd6fe..2882653 100644 --- a/setup.py +++ b/setup.py @@ -1,4 +1,5 @@ """Setup for running the bpmnconstraints script.""" + import setuptools with open("README.md", encoding="utf-8") as file: diff --git a/tests/explainer/explainer_test.py b/tests/explainer/explainer_test.py new file mode 100644 index 0000000..e22fb32 --- /dev/null +++ b/tests/explainer/explainer_test.py @@ -0,0 +1,261 @@ +from explainer.explainer import * + + +# Test 1: Adding and checking constraints +def test_add_constraint(): + explainer = Explainer() + explainer.add_constraint("A.*B.*C") + assert "A.*B.*C" in explainer.constraints, "Constraint 'A.*B.*C' should be added." + + +# Test 2: Removing constraints +def test_remove_constraint(): + explainer = Explainer() + explainer.add_constraint("A.*B.*C") + explainer.add_constraint("B.*C") + explainer.remove_constraint(0) + assert ( + "A.*B.*C" not in explainer.constraints, + ), "Constraint 'A.*B.*C' should be removed." + + +# Test 3: Activation of constraints +def test_activation(): + trace = Trace(["A", "B", "C"]) + explainer = Explainer() + explainer.add_constraint("A.*B.*C") + assert explainer.activation(trace), "The trace should activate the constraint." + + +# Test 4: Checking conformance of traces +def test_conformance(): + trace = Trace(["A", "B", "C"]) + explainer = Explainer() + explainer.add_constraint("A.*B.*C") + assert explainer.conformant(trace), "The trace should be conformant." + + +# Test 5: Non-conformance explanation +def test_non_conformance_explanation(): + trace = Trace(["C", "A", "B"]) + explainer = Explainer() + explainer.add_constraint("A.*B.*C") + explanation = explainer.minimal_expl(trace) + assert "violated" in explanation, "The explanation should indicate a violation." + + +# Test 6: Overlapping constraints +def test_overlapping_constraints(): + trace = Trace(["A", "B", "A", "C"]) + explainer = Explainer() + explainer.add_constraint("A.*B.*C") + explainer.add_constraint("A.*A.*C") + assert explainer.conformant( + trace + ), "The trace should be conformant with overlapping constraints." + + +# Test 7: Partially meeting constraints +def test_partial_conformance(): + trace = Trace(["A", "C", "B"]) + explainer = Explainer() + explainer.add_constraint("A.*B.*C") + assert not explainer.conformant(trace), "The trace should not be fully conformant." + + +# Test 8: Constraints with repeated nodes +def test_constraints_with_repeated_nodes(): + trace = Trace(["A", "A", "B", "A"]) + explainer = Explainer() + explainer.add_constraint("A.*A.*B.*A") + assert explainer.conformant( + trace + ), "The trace should conform to the constraint with repeated nodes." + + +# Test 9: Removing constraints and checking nodes list +def test_remove_constraint_and_check_nodes(): + explainer = Explainer() + explainer.add_constraint("A.*B") + explainer.add_constraint("B.*C") + explainer.remove_constraint(0) + assert ( + "A" not in explainer.nodes and "B" in explainer.nodes and "C" in explainer.nodes + ), "Node 'A' should be removed, while 'B' and 'C' remain." + + +# Test 10: Complex regex constraint +def test_complex_regex_constraint(): + trace = Trace(["A", "X", "B", "Y", "C"]) + explainer = Explainer() + explainer.add_constraint( + "A.*X.*B.*Y.*C" + ) # Specifically expects certain nodes in order + assert explainer.conformant( + trace + ), "The trace should conform to the complex regex constraint." + + +# Test 11: Constraint not covered by any trace node +def test_constraint_not_covered(): + trace = Trace(["A", "B", "C"]) + explainer = Explainer() + explainer.add_constraint("D*") # This node "D" does not exist in the trace + assert explainer.activation(trace) == [ + 0 + ], "The constraint should not be activated by the trace." + + +# Test 12: Empty trace and constraints +def test_empty_trace_and_constraints(): + trace = Trace([]) + explainer = Explainer() + explainer.add_constraint("") # Adding an empty constraint + assert explainer.conformant( + trace + ), "An empty trace should be conformant with an empty constraint." + + +# Test 13: Removing non-existent constraint index +def test_remove_nonexistent_constraint(): + explainer = Explainer() + explainer.add_constraint("A.*B") + explainer.remove_constraint(10) # Non-existent index + assert ( + len(explainer.constraints) == 1 + ), "Removing a non-existent constraint should not change the constraints list." + + +# Test 14: Activation with no constraints +def test_activation_with_no_constraints(): + trace = Trace(["A", "B", "C"]) + explainer = Explainer() + assert not explainer.activation(trace), "No constraints should mean no activation." + + +# Test 15: Trace conformance against multiple constraints +def test_trace_conformance_against_multiple_constraints(): + trace1 = Trace( + ["A", "B", "D"] + ) # This trace should not be fully conformant as it only matches one constraint + trace2 = Trace( + ["A", "B", "C", "D"] + ) # This trace should be conformant as it matches both constraints + + explainer = Explainer() + explainer.add_constraint("A.*B.*C") # Both traces attempt to conform to this + explainer.add_constraint("B.*D") # And to this + + # Checking conformance + assert not explainer.conformant( + trace1 + ), "Trace1 should not be conformant as it does not satisfy all constraints." + assert explainer.conformant( + trace2 + ), "Trace2 should be conformant as it satisfies all constraints." + + +# Test 16: Conformant trace does not generate minimal explaination +def test_conformant_trace_handled_correctly(): + trace = Trace(["A", "B"]) + explainer = Explainer() + explainer.add_constraint("AB") + + assert ( + explainer.minimal_expl(trace) + == "The trace is already conformant, no changes needed." + ) + + +# Test 17: Conformant trace +def test_explainer_methods(): + trace = Trace(["A", "B", "C"]) + explainer = Explainer() + explainer.add_constraint("A.*B.*C") + explainer.add_constraint("B.*C") + + assert ( + explainer.conformant(trace) == True + ), "Test 1 Failed: Trace should be conformant." + assert ( + explainer.minimal_expl(trace) + == "The trace is already conformant, no changes needed." + ), "Test 1 Failed: Incorrect minimal explanation for a conformant trace." + assert ( + explainer.counterfactual_expl(trace) + == "The trace is already conformant, no changes needed." + ), "Test 1 Failed: Incorrect counterfactual explanation for a conformant trace." + + +# Test 18: Some explaination test +def test_explaination(): + explainer = Explainer() + + conformant_trace = Trace(["A", "B", "C"]) + non_conformant_trace = Trace(["A", "C"]) + + explainer.add_constraint("A.*B.*C") + + assert explainer.conformant(non_conformant_trace) == False + assert explainer.conformant(conformant_trace) == True + assert ( + explainer.minimal_expl(non_conformant_trace) + == "Non-conformance due to: Constraint (A.*B.*C) is violated by subtrace: ('A', 'C')" + ) + assert ( + explainer.counterfactual_expl(non_conformant_trace) + == "\nAddition (Added B at position 1): A->B->C" + ) + + +# Test 19: Complex explaination test. +""" +This part is not very complex as of now and is very much up for change, the complexity of counterfactuals +proved to be slightly larger than expected +""" + + +def test_complex_counterfactual_explanation(): + explainer = Explainer() + + explainer.add_constraint("ABB*C") + + non_conformant_trace = Trace(["A", "C", "E", "D"]) + + counterfactual_explanation = explainer.counterfactual_expl(non_conformant_trace) + + assert ( + counterfactual_explanation + == "\nAddition (Added B at position 1): A->B->C->E->D" + ) + + +# Test 20: Event logs +def test_event_log(): + event_log = EventLog() + assert event_log != None + trace = Trace(["A", "B", "C"]) + event_log.add_trace(trace) + assert event_log.log == { + ("A", "B", "C"): 1 + } # There should be one instance of the trace in the log + event_log.add_trace(trace, 5) + assert event_log.log == { + ("A", "B", "C"): 6 + } # There should be 6 instances of the trace in the log + event_log.remove_trace(trace) + assert event_log.log == { + ("A", "B", "C"): 5 + } # There should be 5 instances of the trace + event_log.remove_trace(trace, 5) + assert event_log.log == {} # The log should be emptied + event_log.add_trace(trace, 5) + event_log.remove_trace(trace, 10) + assert event_log.log == {} # The log should be emptied + trace2 = Trace(["X", "Y", "Z"]) + event_log.add_trace(trace, 5) + event_log.add_trace(trace2, 7) + assert event_log.log == { + ("A", "B", "C"): 5, + ("X", "Y", "Z"): 7, + } # There should be several traces in the log diff --git a/tutorial/tutorial.ipynb b/tutorial/tutorial.ipynb index 3755a8d..7e7d8a1 100644 --- a/tutorial/tutorial.ipynb +++ b/tutorial/tutorial.ipynb @@ -106,7 +106,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "" ] @@ -488,7 +488,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.2" + "version": "3.12.1" } }, "nbformat": 4,