ripple-down-rules 0.1.5__tar.gz → 0.1.6__tar.gz

{ripple_down_rules-0.1.5 → ripple_down_rules-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.5
+Version: 0.1.6
 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.1.5 → ripple_down_rules-0.1.6}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.5"
+version = "0.1.6"
 description = "Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning."
 readme = "README.md"
 authors = [{ name = "Abdelrhman Bassiouny", email = "abassiou@uni-bremen.de" }]

{ripple_down_rules-0.1.5 → ripple_down_rules-0.1.6}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -8,7 +8,7 @@ from typing_extensions import Any, Optional, Dict, Type, Tuple, Union
 
 from .callable_expression import CallableExpression
 from .case import create_case, Case
-from ..utils import copy_case
+from ..utils import copy_case, make_list
 
 
 @dataclass
@@ -88,6 +88,7 @@ class CaseQuery:
         """
         :return: The type of the attribute.
         """
+        self._attribute_types = tuple(make_list(self._attribute_types))
         if not self.mutually_exclusive and (set not in self._attribute_types):
             self._attribute_types = tuple(list(self._attribute_types) + [set])
         return self._attribute_types
@@ -97,9 +98,7 @@ class CaseQuery:
         """
         Set the type of the attribute.
         """
-        if not isinstance(value, tuple):
-            value = (value,)
-        self._attribute_types = value
+        self._attribute_types = tuple(make_list(value))
 
     @property
     def name(self):

{ripple_down_rules-0.1.5 → ripple_down_rules-0.1.6}/src/ripple_down_rules/rdr.py

@@ -22,7 +22,7 @@ from .experts import Expert, Human
 from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
 from .utils import draw_tree, make_set, copy_case, \
     get_hint_for_attribute, SubclassJSONSerializer, is_iterable, make_list, get_type_from_string, \
-    get_case_attribute_type, ask_llm
+    get_case_attribute_type, ask_llm, is_matching
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -103,14 +103,14 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                 target = {case_query.attribute_name: case_query.target(case_query.case)}
                 if len(targets) < len(case_queries):
                     targets.append(target)
-                match = self.is_matching(case_query, pred_cat)
+                match = is_matching(self.classify, case_query, pred_cat)
                 if not match:
                     print(f"Predicted: {pred_cat} but expected: {target}")
                 if animate_tree and self.start_rule.size > num_rules:
                     num_rules = self.start_rule.size
                     self.update_figures()
             i += 1
-            all_predictions = [1 if self.is_matching(case_query) else 0 for case_query in case_queries
+            all_predictions = [1 if is_matching(self.classify, case_query) else 0 for case_query in case_queries
                                if case_query.target is not None]
             all_pred = sum(all_predictions)
             print(f"Accuracy: {all_pred}/{len(targets)}")
@@ -124,43 +124,6 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             plt.ioff()
             plt.show()
 
-    def is_matching(self, case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
-        """
-        :param case_query: The case query to check.
-        :param pred_cat: The predicted category.
-        :return: Whether the classifier prediction is matching case_query target or not.
-        """
-        if case_query.target is None:
-            return False
-        if pred_cat is None:
-            pred_cat = self.classify(case_query.case)
-        if not isinstance(pred_cat, dict):
-            pred_cat = {case_query.attribute_name: pred_cat}
-        target = {case_query.attribute_name: case_query.target_value}
-        precision, recall = self.calculate_precision_and_recall(pred_cat, target)
-        return all(recall) and all(precision)
-
-    @staticmethod
-    def calculate_precision_and_recall(pred_cat: Dict[str, Any], target: Dict[str, Any]) -> Tuple[
-        List[bool], List[bool]]:
-        """
-        :param pred_cat: The predicted category.
-        :param target: The target category.
-        :return: The precision and recall of the classifier.
-        """
-        recall = []
-        precision = []
-        for pred_key, pred_value in pred_cat.items():
-            if pred_key not in target:
-                continue
-            precision.extend([v in make_set(target[pred_key]) for v in make_set(pred_value)])
-        for target_key, target_value in target.items():
-            if target_key not in pred_cat:
-                recall.append(False)
-                continue
-            recall.extend([v in make_set(pred_cat[target_key]) for v in make_set(target_value)])
-        return precision, recall
-
     def update_figures(self):
         """
         Update the figures of the classifier.
@@ -399,6 +362,12 @@ class SingleClassRDR(RDRWithCodeWriter):
         matched_rule = self.start_rule(case)
         return matched_rule if matched_rule else self.start_rule
 
+    def write_to_python_file(self, file_path: str, postfix: str = ""):
+        super().write_to_python_file(file_path, postfix)
+        if self.default_conclusion is not None:
+            with open(file_path + f"/{self.generated_python_file_name}.py", "a") as f:
+                f.write(f"{' '*4}else:\n{' '*8}return {self.default_conclusion}\n")
+
     def write_rules_as_source_code_to_file(self, rule: SingleClassRule, file: TextIOWrapper, parent_indent: str = "",
                                            defs_file: Optional[str] = None):
         """

{ripple_down_rules-0.1.5 → ripple_down_rules-0.1.6}/src/ripple_down_rules/utils.py

@@ -33,6 +33,45 @@ import ast
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def is_matching(rdr_classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
+    """
+    :param rdr_classifier: The RDR classifier to check the prediction of.
+    :param case_query: The case query to check.
+    :param pred_cat: The predicted category.
+    :return: Whether the classifier prediction is matching case_query target or not.
+    """
+    if case_query.target is None:
+        return False
+    if pred_cat is None:
+        pred_cat = rdr_classifier(case_query.case)
+    if not isinstance(pred_cat, dict):
+        pred_cat = {case_query.attribute_name: pred_cat}
+    target = {case_query.attribute_name: case_query.target_value}
+    precision, recall = calculate_precision_and_recall(pred_cat, target)
+    return all(recall) and all(precision)
+
+
+def calculate_precision_and_recall(pred_cat: Dict[str, Any], target: Dict[str, Any]) -> Tuple[
+    List[bool], List[bool]]:
+    """
+    :param pred_cat: The predicted category.
+    :param target: The target category.
+    :return: The precision and recall of the classifier.
+    """
+    recall = []
+    precision = []
+    for pred_key, pred_value in pred_cat.items():
+        if pred_key not in target:
+            continue
+        precision.extend([v in make_set(target[pred_key]) for v in make_set(pred_value)])
+    for target_key, target_value in target.items():
+        if target_key not in pred_cat:
+            recall.append(False)
+            continue
+        recall.extend([v in make_set(pred_cat[target_key]) for v in make_set(target_value)])
+    return precision, recall
+
+
 def get_rule_conclusion_as_source_code(rule: Rule, conclusion: str, parent_indent: str = "") -> str:
     """
     Convert the conclusion of a rule to source code.

{ripple_down_rules-0.1.5 → ripple_down_rules-0.1.6}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.5
+Version: 0.1.6
 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.1.5 → ripple_down_rules-0.1.6}/test/test_rdr_world.py

@@ -8,6 +8,7 @@ from unittest import TestCase
 from ripple_down_rules.datastructures.dataclasses import CaseQuery
 from ripple_down_rules.experts import Human
 from ripple_down_rules.rdr import SingleClassRDR, GeneralRDR
+from ripple_down_rules.utils import is_matching
 
 
 @dataclass
@@ -93,17 +94,26 @@ class TestRDRWorld(TestCase):
         print(all_views)
         cls.drawer_case_queries = [CaseQuery(view, "correct", bool, True, default_value=False) for view in all_views]
 
-    def test_drawer_scrdr(self):
-        use_loaded_answers = True
-        save_answers = False
+    def test_drawer_rdr(self):
+        self.get_drawer_rdr(use_loaded_answers=True, save_answers=False)
+
+    def test_write_drawer_rdr_to_python_file(self):
+        rdrs_dir = "./test_generated_rdrs"
+        drawer_rdr = self.get_drawer_rdr()
+        drawer_rdr.write_to_python_file(rdrs_dir)
+        loaded_rdr_classifier = drawer_rdr.get_rdr_classifier_from_python_file(rdrs_dir)
+        for case_query in self.drawer_case_queries:
+            self.assertTrue(is_matching(loaded_rdr_classifier, case_query))
+
+    def get_drawer_rdr(self, use_loaded_answers: bool = True, save_answers: bool = False):
         expert = Human(use_loaded_answers=use_loaded_answers)
-        filename = os.path.join(os.getcwd(), "test_expert_answers/scrdr_world_expert_answers_fit")
+        filename = os.path.join(os.getcwd(), "test_expert_answers/correct_drawer_rdr_expert_answers_fit")
         if use_loaded_answers:
             expert.load_answers(filename)
-        rdr = SingleClassRDR()
+        rdr = GeneralRDR()
         rdr.fit(self.drawer_case_queries, expert=expert, animate_tree=False)
         if save_answers:
             expert.save_answers(filename)
         for case_query in self.drawer_case_queries:
-            self.assertEqual(rdr.classify(case_query.case), case_query.target_value)
-            # print(f"Case: {case_query}, Classification: {rdr.classify(case_query.case)}")
+            self.assertTrue(is_matching(rdr.classify, case_query))
+        return rdr