action-rules 0.0.1__py3-none-any.whl

action_rules/action_rules.py

@@ -0,0 +1,357 @@
+import copy
+import itertools
+from collections import defaultdict
+
+import pandas as pd
+
+
+# Reduce candidates to required minimum number of stable or flexible attributes.
+def reduce_candidates_min_attributes(K, actionable_attributes, stable_items_binding, min_stable_attributes,
+                                     flexible_items_binding, min_flexible_attributes):
+    # Reduce by min stable and flexible
+    number_of_stable_attributes = len(stable_items_binding) - (min_stable_attributes - K)
+    if K > min_stable_attributes:
+        number_of_flexible_attributes = len(flexible_items_binding) - (
+                min_flexible_attributes - actionable_attributes - 1)
+    else:
+        number_of_flexible_attributes = 0
+    reduced_stable_items_binding = {k: stable_items_binding[k] for k in
+                                    list(stable_items_binding.keys())[:number_of_stable_attributes]}
+    reduced_flexible_items_binding = {k: flexible_items_binding[k] for k in
+                                      list(flexible_items_binding.keys())[:number_of_flexible_attributes]}
+    return reduced_stable_items_binding, reduced_flexible_items_binding
+
+
+# Check if itemset is in the stop list.
+def in_stop_list(ar_prefix, stop_list):
+    if ar_prefix[-2:] in stop_list:
+        return True
+    if ar_prefix[1:] in stop_list:
+        stop_list.append(ar_prefix)
+        return True
+    return False
+
+
+# Generate candidates and count their support
+# Node derived from stable attribute must simultaneously have sufficient support for the desired and undesired classes in the consequent.
+# Group of nodes representing flexible attributes must simultaneously have required min. support for the desired and undesired classes.
+def generate_candidates(ar_prefix, itemset_prefix, stable_items_binding, flexible_items_binding, undesired_mask,
+                        desired_mask, actionable_attributes=0, item=0, stop_list=[], frames=None, undesired_state=0,
+                        desired_state=1, stop_list_itemset=[], classification_rules=[], verbose=False):
+    K = len(itemset_prefix) + 1
+    reduced_stable_items_binding, reduced_flexible_items_binding = reduce_candidates_min_attributes(K,
+                                                                                                    actionable_attributes,
+                                                                                                    stable_items_binding,
+                                                                                                    min_stable_attributes,
+                                                                                                    flexible_items_binding,
+                                                                                                    min_flexible_attributes)
+
+    if undesired_mask is None:
+        undesired_frame = frames[undesired_state]
+        desired_frame = frames[desired_state]
+    else:
+        undesired_frame = frames[undesired_state].multiply(undesired_mask, axis="index")
+        desired_frame = frames[desired_state].multiply(desired_mask, axis="index")
+
+    stable_candidates = copy.deepcopy(stable_items_binding)
+    flexible_candidates = copy.deepcopy(flexible_items_binding)
+
+    new_branches = []
+
+    for attribute, items in reduced_stable_items_binding.items():
+        for item in items:
+
+            new_ar_prefix = ar_prefix + (item,)
+            if in_stop_list(new_ar_prefix, stop_list):
+                continue
+
+            undesired_support = undesired_frame[item].sum()
+            desired_support = desired_frame[item].sum()
+
+            if verbose:
+                print('SUPPORT')
+                print(itemset_prefix + (item,))
+                print((undesired_support, desired_support))
+
+            if undesired_support < min_undesired_support or desired_support < min_desired_support:
+                stable_candidates[attribute].remove(item)
+                stop_list.append(new_ar_prefix)
+            else:
+                new_branches.append({'ar_prefix': new_ar_prefix,
+                                     'itemset_prefix': new_ar_prefix,
+                                     'item': item,
+                                     'undesired_mask': undesired_frame[item],
+                                     'desired_mask': desired_frame[item],
+                                     'actionable_attributes': 0,
+                                     })
+
+    for attribute, items in reduced_flexible_items_binding.items():
+
+        new_ar_prefix = ar_prefix + (attribute,)
+        if in_stop_list(new_ar_prefix, stop_list):
+            continue
+
+        undesired_states = []
+        desired_states = []
+        undesired_count = 0
+        desired_count = 0
+        for item in items:
+
+            if in_stop_list(itemset_prefix + (item,), stop_list_itemset):
+                continue
+
+            undesired_support = undesired_frame[item].sum()
+            desired_support = desired_frame[item].sum()
+
+            if verbose:
+                print('SUPPORT')
+                print(itemset_prefix + (item,))
+                print((undesired_support, desired_support))
+
+            # is undesired
+            if desired_support + undesired_support == 0:
+                undesired_conf = 0
+            else:
+                undesired_conf = undesired_support / (desired_support + undesired_support)
+            if undesired_support >= min_undesired_support:
+                undesired_count += 1
+                if undesired_conf >= min_undesired_confidence:
+                    undesired_states.append({'item': item, 'support': undesired_support, 'confidence': undesired_conf})
+            # is desired
+            if desired_support + undesired_support == 0:
+                desired_conf = 0
+            else:
+                desired_conf = desired_support / (desired_support + undesired_support)
+            if desired_support >= min_desired_support:
+                desired_count += 1
+                if desired_conf >= min_desired_confidence:
+                    desired_states.append({'item': item, 'support': desired_support, 'confidence': desired_conf})
+            if desired_support < min_desired_support and undesired_support < min_undesired_support:
+                flexible_candidates[attribute].remove(item)
+                stop_list_itemset.append(itemset_prefix + (item,))
+
+        if actionable_attributes == 0 and (undesired_count == 0 or desired_count == 0):  # just for first flexible level
+            del flexible_candidates[attribute]
+            stop_list.append(ar_prefix + (attribute,))
+        else:
+            for item in items:
+                new_branches.append({'ar_prefix': new_ar_prefix,
+                                     'itemset_prefix': itemset_prefix + (item,),
+                                     'item': item,
+                                     'undesired_mask': undesired_frame[item],
+                                     'desired_mask': desired_frame[item],
+                                     'actionable_attributes': actionable_attributes + 1,
+                                     })
+
+            if actionable_attributes + 1 >= min_flexible_attributes:
+                for undesired_item in undesired_states:
+                    new_itemset_prefix = itemset_prefix + (undesired_item['item'],)
+                    classification_rules[new_ar_prefix]['undesired'].append({
+                        'itemset': new_itemset_prefix,
+                        'support': undesired_item['support'],
+                        'confidence': undesired_item['confidence'],
+                        'target': desired_change_in_target[0]
+                    })
+                for desired_item in desired_states:
+                    new_itemset_prefix = itemset_prefix + (desired_item['item'],)
+                    classification_rules[new_ar_prefix]['desired'].append({
+                        'itemset': new_itemset_prefix,
+                        'support': desired_item['support'],
+                        'confidence': desired_item['confidence'],
+                        'target': desired_change_in_target[1]
+                    })
+
+    for new_branch in new_branches:
+        adding = False
+        new_stable = {}
+        new_flexible = {}
+
+        for attribute, items in stable_candidates.items():
+            for item in items:
+                if adding:
+                    if attribute not in new_stable:
+                        new_stable[attribute] = []
+                    new_stable[attribute].append(item)
+                if item == new_branch['item']:
+                    adding = True
+
+        for attribute, items in flexible_candidates.items():
+            for item in items:
+                if adding:
+                    if attribute not in new_flexible:
+                        new_flexible[attribute] = []
+                    new_flexible[attribute].append(item)
+                if item == new_branch['item']:
+                    adding = True
+
+        new_branch['stable_items_binding'] = new_stable
+        new_branch['flexible_items_binding'] = new_flexible
+
+    return new_branches
+
+
+# Generate action rules from classification rules
+def generate_action_rules(classification_rules, action_rules):
+    for attribute_prefix, rules in classification_rules.items():
+        for desired_rule in rules['desired']:
+            for undesired_rule in rules['undesired']:
+                action_rules.append({'undesired': undesired_rule, 'desired': desired_rule})
+
+
+# Prune tree
+def prune_tree(K, classification_rules, stop_list):
+    for attribute_prefix, rules in classification_rules.items():
+        if K == len(attribute_prefix):
+            if len(rules['desired']) < 0 or len(rules['undesired']) < 0:
+                stop_list.append(attribute_prefix)
+                del classification_rules[attribute_prefix]
+
+
+# Get the dictionaries of attributes and their values
+def get_bindings(data, stable_attributes, flexible_attributes, target):
+    stable_items_binding = defaultdict(lambda: [])
+    flexible_items_binding = defaultdict(lambda: [])
+    target_items_binding = defaultdict(lambda: [])
+
+    for col in data.columns:
+        is_continue = False
+        # stable
+        for attribute in stable_attributes:
+            if col.startswith(attribute + '_<item>_'):
+                stable_items_binding[attribute].append(col)
+                is_continue = True
+                break
+        if is_continue is True:
+            continue
+        # flexible
+        for attribute in flexible_attributes:
+            if col.startswith(attribute + '_<item>_'):
+                flexible_items_binding[attribute].append(col)
+                is_continue = True
+                break
+        if is_continue is True:
+            continue
+        # target
+        if col.startswith(target + '_<item>_'):
+            target_items_binding[target].append(col)
+    return stable_items_binding, flexible_items_binding, target_items_binding
+
+
+# Create default stop list
+def get_stop_list(stable_items_binding, flexible_items_binding):
+    stop_list = []
+    for items in stable_items_binding.values():
+        for stop_couple in itertools.product(items, repeat=2):
+            stop_list.append(tuple(stop_couple))
+    for item in flexible_items_binding.keys():
+        stop_list.append(tuple([item, item]))
+    return stop_list
+
+
+# Split data to desired and undesired
+def get_split_tables(data, target_items_binding, target):
+    frames = {}
+    for item in target_items_binding[target]:
+        mask = data[item] == 1
+        frames[item] = data[mask]
+    return frames
+
+
+# Action-Apriori main function
+def action_apriori(data, stable_attributes, flexible_attributes, target, desired_change_in_target_l,
+                   min_stable_attributes_l, min_flexible_attributes_l, min_undesired_support_l,
+                   min_undesired_confidence_l, min_desired_support_l, min_desired_confidence_l, verbose=False):
+    # Global variables
+    global min_stable_attributes
+    global min_flexible_attributes
+    global min_undesired_support
+    global min_desired_support
+    global min_undesired_confidence
+    global min_desired_confidence
+    global desired_change_in_target
+    min_stable_attributes = min_stable_attributes_l
+    min_flexible_attributes = min_flexible_attributes_l
+    min_undesired_support = min_undesired_support_l
+    min_desired_support = min_desired_support_l
+    min_undesired_confidence = min_undesired_confidence_l
+    min_desired_confidence = min_desired_confidence_l
+    desired_change_in_target = desired_change_in_target_l
+
+    data = pd.get_dummies(data, sparse=False, columns=data.columns, prefix_sep='_<item>_')
+    stable_items_binding, flexible_items_binding, target_items_binding = get_bindings(data, stable_attributes,
+                                                                                      flexible_attributes, target)
+    stop_list = get_stop_list(stable_items_binding, flexible_items_binding)
+    frames = get_split_tables(data, target_items_binding, target)
+    undesired_state = target + '_<item>_' + str(desired_change_in_target[0])
+    desired_state = target + '_<item>_' + str(desired_change_in_target[1])
+    action_rules = []
+    classification_rules = defaultdict(lambda: {'desired': [], 'undesired': []})
+    stop_list_itemset = []
+
+    candidates_queue = [{
+        'ar_prefix': tuple(),
+        'itemset_prefix': tuple(),
+        'stable_items_binding': stable_items_binding,
+        'flexible_items_binding': flexible_items_binding,
+        'undesired_mask': None,
+        'desired_mask': None,
+        'actionable_attributes': 0
+    }]
+    K = 0
+    while len(candidates_queue) > 0:
+        candidate = candidates_queue.pop(0)
+        if len(candidate['ar_prefix']) > K:
+            K += 1
+            prune_tree(K, classification_rules, stop_list)
+        new_candidates = generate_candidates(**candidate, stop_list=stop_list, frames=frames,
+                                             undesired_state=undesired_state, desired_state=desired_state,
+                                             stop_list_itemset=stop_list_itemset,
+                                             classification_rules=classification_rules, verbose=verbose)
+        candidates_queue += new_candidates
+    generate_action_rules(classification_rules, action_rules)
+    return action_rules
+
+
+def get_ar_notation(ar_dict, target):
+    rule = '['
+    for i, item in enumerate(ar_dict['undesired']['itemset']):
+        if i > 0:
+            rule += ' ∧ '
+        rule += '('
+        if item == ar_dict['desired']['itemset'][i]:
+            val = item.split('_<item>_')
+            rule += str(val[0]) + ': ' + str(val[1])
+        else:
+            val = item.split('_<item>_')
+            val_desired = ar_dict['desired']['itemset'][i].split('_<item>_')
+            rule += str(val[0]) + ': ' + str(val[1]) + ' → ' + str(val_desired[1])
+        rule += ')'
+    rule += '] ⇒ [' + str(target) + ': ' + str(ar_dict['undesired']['target']) + ' → ' + str(
+        ar_dict['desired']['target']) + ']'
+    rule += ', support of undesired part: ' + str(
+        ar_dict['undesired']['support']) + ', confidence of undesired part: ' + str(ar_dict['undesired']['confidence'])
+    rule += ', support of desired part: ' + str(ar_dict['desired']['support']) + ', confidence of desired part: ' + str(
+        ar_dict['desired']['confidence'])
+    return rule
+
+
+def get_export_notation(action_rules, target):
+    rules = []
+    for ar_dict in action_rules:
+        rule = {'stable': [], 'flexible': []}
+        for i, item in enumerate(ar_dict['undesired']['itemset']):
+            if item == ar_dict['desired']['itemset'][i]:
+                val = item.split('_<item>_')
+                rule['stable'].append({'attribute': val[0], 'value': val[1]})
+            else:
+                val = item.split('_<item>_')
+                val_desired = ar_dict['desired']['itemset'][i].split('_<item>_')
+                rule['flexible'].append({'attribute': val[0], 'undesired': val[1], 'desired': val_desired[1]})
+        rule['target'] = {'attribute': target, 'undesired': ar_dict['undesired']['target'],
+                          'desired': ar_dict['desired']['target']}
+        rule['support of undesired part'] = ar_dict['undesired']['support']
+        rule['confidence of undesired part'] = ar_dict['undesired']['confidence']
+        rule['support of desired part'] = ar_dict['desired']['support']
+        rule['confidence of desired part'] = ar_dict['desired']['confidence']
+        rules.append(rule)
+    return rules

action_rules-0.0.1.dist-info/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Lukas Sykora
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

action_rules-0.0.1.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.1
+Name: action-rules
+Version: 0.0.1
+Summary: Action Rules Mining Tool.
+Home-page: https://github.com/lukassykora/actionrules
+Author: Lukas Sykora
+Author-email: lukas.sykora@vse.cz
+License: UNKNOWN
+Platform: UNKNOWN
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: pandas (~=2.2.2)
+
+# Action-Apriori (Apriori Modified for Action Rules Mining)
+
+ [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+ ## Installation
+The Action-Apriori script needs the following libraries:
+- itertools (built-in module in python)
+- copy (built-in module in python)
+- collections (built-in module in python)
+- pandas (1.3.4)
+
+The tested Python version is: 3.9.7
+
+The action_apriori function can be called:
+
+```python
+import action_rules as ar
+import pandas as pd
+# Data
+transactions = {'Sex': ['M', 'F', 'M', 'M', 'F', 'M', 'F'], 
+                'Age': ['Y', 'Y', 'O', 'Y', 'Y', 'O', 'Y'],
+                'Class': [1, 1, 2, 2, 1, 1, 2],
+                'Embarked': ['S', 'C', 'S', 'C', 'S', 'C', 'C'],
+                'Survived': [1, 1, 0, 0, 1, 1, 0],
+               }
+data = pd.DataFrame.from_dict(transactions)
+# Parameters
+stable_attributes = ['Sex','Age']
+flexible_attributes = ['Class','Embarked']
+target = 'Survived'
+wanted_change_in_target = [0, 1]
+min_stable_attributes = 2
+min_flexible_attributes = 1 #min 1
+min_unwanted_support = 1
+min_unwanted_confidence = 0.5 #min 0.5
+min_wanted_support = 2
+min_wanted_confidence = 0.5 #min 0.5
+# Action Rules Mining
+action_rules = ar.action_apriori(
+    data, 
+    stable_attributes, 
+    flexible_attributes, 
+    target, 
+    wanted_change_in_target,
+    min_stable_attributes , 
+    min_flexible_attributes, 
+    min_unwanted_support, 
+    min_unwanted_confidence, 
+    min_wanted_support, 
+    min_wanted_confidence, 
+    True) #verbose
+# Print rules
+for action_rule in action_rules:
+    print(action_rule)
+# Print rules with action rules notation
+for action_rule in action_rules:
+    print(ar.get_ar_notation(action_rule, target))
+# Print rules with export notation
+print(ar.get_export_notation(action_rules, target))
+```
+
+The output: ation rule with notation:
+
+```python
+[(Sex: F) ∧ (Age: Y) ∧ (Class: 2 → 1)] ⇒ [Survived: 0 → 1], support of undesired part: 1, confidence of undesired part: 1.0, support of desired part: 2, confidence of desired part: 1.0
+```
+
+
+
+

action_rules-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+action_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+action_rules/action_rules.py,sha256=BSVQ5CiQp3TimnqGLp_lQTskX9kmafG9gCwxJkHyyqw,16926
+action_rules-0.0.1.dist-info/LICENSE.txt,sha256=gEr-nYwCX9aGVHiZSsOVYQb4TFlbKfQVmmd0-Gun2t4,1088
+action_rules-0.0.1.dist-info/METADATA,sha256=9vL4OiGIp9pp6geT2ErXVI3wmTGg_WypwXT0zNkFiK0,2419
+action_rules-0.0.1.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+action_rules-0.0.1.dist-info/top_level.txt,sha256=4uSeKPOWLOUAFeSknZThyYBY1Ra9pQb_wNWm8GRCxcE,13
+action_rules-0.0.1.dist-info/RECORD,,

action_rules-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

action_rules-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+action_rules