ripple-down-rules 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

ripple_down_rules/datastructures/table.py

@@ -4,7 +4,7 @@ import os
 import time
 from abc import ABC
 from collections import UserDict
-from copy import deepcopy
+from copy import deepcopy, copy
 from dataclasses import dataclass
 from enum import Enum
 
@@ -78,7 +78,7 @@ class SubClassFactory:
         parent_class_alias = cls.__name__ + "_"
         imports = f"from {cls.__module__} import {cls.__name__} as {parent_class_alias}\n"
         class_code = f"class {name}({parent_class_alias}):\n"
-        class_attributes = deepcopy(class_attributes) if class_attributes else {}
+        class_attributes = copy(class_attributes) if class_attributes else {}
         class_attributes.update({"_value_range": range_})
         for key, value in class_attributes.items():
             if value is not None:

ripple_down_rules/experts.py

@@ -97,14 +97,23 @@ class Human(Expert):
         self.use_loaded_answers = use_loaded_answers
         self.session = session
 
-    def save_answers(self, path: str):
+    def save_answers(self, path: str, append: bool = False):
         """
         Save the expert answers to a file.
 
         :param path: The path to save the answers to.
+        :param append: A flag to indicate if the answers should be appended to the file or not.
         """
-        with open(path + '.json', "w") as f:
-            json.dump(self.all_expert_answers, f)
+        if append:
+            # read the file and append the new answers
+            with open(path + '.json', "r") as f:
+                all_answers = json.load(f)
+                all_answers.extend(self.all_expert_answers)
+            with open(path + '.json', "w") as f:
+                json.dump(all_answers, f)
+        else:
+            with open(path + '.json', "w") as f:
+                json.dump(self.all_expert_answers, f)
 
     def load_answers(self, path: str):
         """

ripple_down_rules/rdr.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from copy import copy
+from copy import copy, deepcopy
 
 from matplotlib import pyplot as plt
 from ordered_set import OrderedSet
 from sqlalchemy.orm import DeclarativeBase as SQLTable, Session
-from typing_extensions import List, Optional, Dict, Type, Union, Any, Self
+from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple
 
 from .datastructures import Case, MCRDRMode, CallableExpression, Column, CaseQuery
 from .experts import Expert, Human
@@ -51,7 +51,7 @@ class RippleDownRules(ABC):
         pass
 
     @abstractmethod
-    def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs)\
+    def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Union[Column, CallableExpression]:
         """
         Fit the RDR on a case, and ask the expert for refinements or alternatives if the classification is incorrect by
@@ -86,8 +86,6 @@ class RippleDownRules(ABC):
         num_rules: int = 0
         while not stop_iterating:
             all_pred = 0
-            all_recall = []
-            all_precision = []
             if not targets:
                 targets = [None] * len(cases)
             for case_query in case_queries:
@@ -97,14 +95,7 @@ class RippleDownRules(ABC):
                     conclusions = self.classify(case) if self.start_rule and self.start_rule.conditions else []
                     target = expert.ask_for_conclusion(case_query, conclusions)
                 pred_cat = self.fit_case(case_query, expert=expert, **kwargs_for_fit_case)
-                pred_cat = pred_cat if isinstance(pred_cat, list) else [pred_cat]
-                target = target if isinstance(target, list) else [target]
-                recall = [not yi or (yi in pred_cat) for yi in target]
-                y_type = [type(yi) for yi in target]
-                precision = [(pred in target) or (type(pred) not in y_type) for pred in pred_cat]
-                match = all(recall) and all(precision)
-                all_recall.extend(recall)
-                all_precision.extend(precision)
+                match = self.is_matching(pred_cat, target)
                 if not match:
                     print(f"Predicted: {pred_cat} but expected: {target}")
                 all_pred += int(match)
@@ -112,21 +103,43 @@ class RippleDownRules(ABC):
                     num_rules = self.start_rule.size
                     self.update_figures()
             i += 1
-            all_pred = [1 if p == t else 0
-                        for case, target in zip(cases, targets) for p, t in zip(self.classify(case), target)]
-            all_predicted = targets and sum(all_pred) == len(targets)
+            all_predictions = [1 if self.is_matching(self.classify(case), target) else 0
+                               for case, target in zip(cases, targets)]
+            all_pred = sum(all_predictions)
+            print(f"Accuracy: {all_pred}/{len(targets)}")
+            all_predicted = targets and all_pred == len(targets)
             num_iter_reached = n_iter and i >= n_iter
             stop_iterating = all_predicted or num_iter_reached
             if stop_iterating:
                 break
-            print(f"Recall: {sum(all_recall) / len(all_recall)}")
-            print(f"Precision: {sum(all_precision) / len(all_precision)}")
-            print(f"Accuracy: {all_pred}/{len(targets)}")
         print(f"Finished training in {i} iterations")
         if animate_tree:
             plt.ioff()
             plt.show()
 
+    @staticmethod
+    def calculate_precision_and_recall(pred_cat: List[Column], target: List[Column]) -> Tuple[List[bool], List[bool]]:
+        """
+        :param pred_cat: The predicted category.
+        :param target: The target category.
+        :return: The precision and recall of the classifier.
+        """
+        pred_cat = pred_cat if isinstance(pred_cat, list) else [pred_cat]
+        target = target if isinstance(target, list) else [target]
+        recall = [not yi or (yi in pred_cat) for yi in target]
+        target_types = [type(yi) for yi in target]
+        precision = [(pred in target) or (type(pred) not in target_types) for pred in pred_cat]
+        return precision, recall
+
+    def is_matching(self, pred_cat: List[Column], target: List[Column]) -> bool:
+        """
+        :param pred_cat: The predicted category.
+        :param target: The target category.
+        :return: Whether the classifier is matching or not.
+        """
+        precision, recall = self.calculate_precision_and_recall(pred_cat, target)
+        return all(recall) and all(precision)
+
     def update_figures(self):
         """
         Update the figures of the classifier.
@@ -501,6 +514,7 @@ class MultiClassRDR(RippleDownRules):
             same_type_conclusions = [c for c in self.conclusions if type(c) == type(evaluated_rule.conclusion)]
             combined_conclusion = evaluated_rule.conclusion if isinstance(evaluated_rule.conclusion, set) \
                 else {evaluated_rule.conclusion}
+            combined_conclusion = deepcopy(combined_conclusion)
             for c in same_type_conclusions:
                 combined_conclusion.update(c if isinstance(c, set) else make_set(c))
                 self.conclusions.remove(c)
@@ -582,7 +596,7 @@ class GeneralRDR(RippleDownRules):
                 break
         return conclusions
 
-    def fit_case(self, case_queries: List[CaseQuery], expert: Optional[Expert] = None, **kwargs)\
+    def fit_case(self, case_queries: List[CaseQuery], expert: Optional[Expert] = None, **kwargs) \
             -> List[Union[Column, CallableExpression]]:
         """
         Fit the GRDR on a case, if the target is a new type of category, a new RDR is created for it,

{ripple_down_rules-0.0.4.dist-info → ripple_down_rules-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.4
+Version: 0.0.5
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 License:                     GNU GENERAL PUBLIC LICENSE

{ripple_down_rules-0.0.4.dist-info → ripple_down_rules-0.0.5.dist-info}/RECORD

@@ -1,21 +1,21 @@
 ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/datasets.py,sha256=QRB-1BdFTcUNuhgYEuXYx6qQOYlDu03_iLKDBqrcVrQ,4511
-ripple_down_rules/experts.py,sha256=wss-rMjmVRNoNpPNo_EygNsh57iebNi-g2j7_SkgWIU,11636
+ripple_down_rules/experts.py,sha256=DMTC-E2g1Fs43oyr30MGeGi5-VKBb3RojzzPa8DvCSA,12093
 ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
 ripple_down_rules/prompt.py,sha256=lmREZRyleBTHrVtcf2j_48oc0v3VlxXYGhl6w1mk8qI,4208
-ripple_down_rules/rdr.py,sha256=i-SFrnrkii_ARc-hLnSJHCwfOim09ynrqCnnOw_y-BI,33199
+ripple_down_rules/rdr.py,sha256=nRhrHdQYmvXgfTFLyO_xxwe7GDYuUhaOqZlQtqSUrnE,33751
 ripple_down_rules/rules.py,sha256=TLptqvA6I3QlQaVBTYchbgvXm17XWwFJoTmoN0diHm8,10348
 ripple_down_rules/utils.py,sha256=WlUXTf-B45SPEKpDBVb9QPQWS54250MGAY5xl9MIhR4,16944
 ripple_down_rules/datastructures/__init__.py,sha256=wY9WqXavuE3wQ1YP65cs_SZyr7CEMB9tol-4oxgK9CM,104
 ripple_down_rules/datastructures/callable_expression.py,sha256=yEZ6OWzSiWsRtEz_5UquA0inmodFTOWqXWV_a2gg1cg,9110
 ripple_down_rules/datastructures/dataclasses.py,sha256=z_9B7Nj_MIf2Iyrs5VeUhXhYxwaqnuKVjgwxhZZTygY,2525
 ripple_down_rules/datastructures/enums.py,sha256=6Mh55_8QRuXyYZXtonWr01VBgLP-jYp91K_8hIgh8u8,4244
-ripple_down_rules/datastructures/table.py,sha256=q3RIZ5BiqaFNTKcVRc28xQSvso0X_eGf1l_kVCw4mbA,23159
+ripple_down_rules/datastructures/table.py,sha256=Tq7savAaFoB7n7x6-u2Vz6NfvjLBzPxsqblR4cHujzM,23161
 ripple_down_rules/datastructures/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/datastructures/generated/column/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/datastructures/generated/row/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules-0.0.4.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.0.4.dist-info/METADATA,sha256=MUirOiWljZwLdaaEqnIjhk39fbeILkxFZcoYQI_Zw5g,42518
-ripple_down_rules-0.0.4.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ripple_down_rules-0.0.4.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.0.4.dist-info/RECORD,,
+ripple_down_rules-0.0.5.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.0.5.dist-info/METADATA,sha256=qwUDSDi3YlBsg1RlYOEtFn5YQ3x7yNizCAKm72_8YPU,42518
+ripple_down_rules-0.0.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ripple_down_rules-0.0.5.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.0.5.dist-info/RECORD,,