CN2 Rules: Add restriction to == for categorical variables

Author: janezd

Orange/classification/rules.py

@@ -435,10 +435,12 @@ class TopDownSearchStrategy(SearchStrategy):
     instances is developed. The hypothesis space of possible rules is
     then searched repeatedly by specialising candidate rules.
     """
-    def __init__(self, constrain_continuous=True, evaluate=True):
+    def __init__(self, constrain_continuous=True, evaluate=True,
+                        restrict_equality=False):
         self.constrain_continuous = constrain_continuous
         self.storage = None
         self.evaluate = evaluate
+        self.restrict_equality = restrict_equality
 
     def initialise_rule(self, X, Y, W, target_class, base_rules, domain,
                         initial_class_dist, prior_class_dist,
@@ -531,14 +533,15 @@ def find_new_selectors(self, X, Y, W, domain, existing_selectors):
 
         possible_selectors = []
         # examine covered examples, for each variable
+        disc_operators = ["=="] if self.restrict_equality else ["==", "!="]
         for i, attribute in enumerate(domain.attributes):
             # if discrete variable
             if attribute.is_discrete:
                 # for each unique value, generate all possible selectors
                 for val in np.unique(X[:, i]):
-                    s1 = Selector(column=i, op="==", value=val)
-                    s2 = Selector(column=i, op="!=", value=val)
-                    possible_selectors.extend([s1, s2])
+                    possible_selectors += (
+                        Selector(column=i, op=op, value=val)
+                        for op in disc_operators)
             # if continuous variable
             elif attribute.is_continuous:
                 if X.shape[0] == 1:
@@ -914,7 +917,8 @@ class _RuleLearner(Learner):
     """
     preprocessors = [RemoveNaNColumns(), HasClass(), Impute()]
 
-    def __init__(self, preprocessors=None, base_rules=None):
+    def __init__(self, preprocessors=None, base_rules=None,
+                 *, restrict_equality=False):
         """
         Constrain the search algorithm with a list of base rules.
 
@@ -940,6 +944,7 @@ def __init__(self, preprocessors=None, base_rules=None):
         super().__init__(preprocessors=preprocessors)
         self.base_rules = base_rules if base_rules is not None else []
         self.rule_finder = RuleHunter()
+        self.rule_finder.search_strategy.restrict_equality = restrict_equality
 
         self.data_stopping = self.positive_remaining_data_stopping
         self.cover_and_remove = self.exclusive_cover_and_remove
@@ -1247,8 +1252,10 @@ class _BaseCN2Learner(_RuleLearner):
     """
     def __init__(self, preprocessors=None, base_rules=None, beam_width=5,
                  constrain_continuous=True, min_covered_examples=1,
-                 max_rule_length=5, default_alpha=1.0, parent_alpha=1.0):
-        super().__init__(preprocessors, base_rules)
+                 max_rule_length=5, default_alpha=1.0, parent_alpha=1.0, *,
+                 restrict_equality=False):
+        super().__init__(preprocessors, base_rules,
+                         restrict_equality=restrict_equality)
         rf = self.rule_finder
         rf.search_algorithm.beam_width = beam_width
         rf.search_strategy.constrain_continuous = constrain_continuous
@@ -1272,8 +1279,10 @@ class CN2Learner(_RuleLearner):
     "The CN2 Induction Algorithm", Peter Clark and Tim Niblett, Machine
     Learning Journal, 3 (4), pp261-283, (1989)
     """
-    def __init__(self, preprocessors=None, base_rules=None):
-        super().__init__(preprocessors, base_rules)
+    def __init__(self, preprocessors=None, base_rules=None,
+                 *, restrict_equality=False):
+        super().__init__(preprocessors, base_rules,
+                         restrict_equality=restrict_equality)
         self.rule_finder.quality_evaluator = EntropyEvaluator()
 
     def fit_storage(self, data):
@@ -1326,8 +1335,10 @@ class CN2UnorderedLearner(_RuleLearner):
     """
     name = 'CN2 unordered inducer'
 
-    def __init__(self, preprocessors=None, base_rules=None):
-        super().__init__(preprocessors, base_rules)
+    def __init__(self, preprocessors=None, base_rules=None,
+                 *, restrict_equality=False):
+        super().__init__(preprocessors, base_rules,
+                         restrict_equality=restrict_equality)
         self.rule_finder.quality_evaluator = LaplaceAccuracyEvaluator()
 
     def fit_storage(self, data):
@@ -1392,8 +1403,10 @@ class CN2SDLearner(_RuleLearner):
     """
     name = 'CN2-SD inducer'
 
-    def __init__(self, preprocessors=None, base_rules=None):
-        super().__init__(preprocessors, base_rules)
+    def __init__(self, preprocessors=None, base_rules=None,
+                 *, restrict_equality=False):
+        super().__init__(preprocessors, base_rules,
+                         restrict_equality=restrict_equality)
         self.rule_finder.quality_evaluator = WeightedRelativeAccuracyEvaluator()
         self.cover_and_remove = self.weighted_cover_and_remove
         self.gamma = 0.7
@@ -1461,8 +1474,10 @@ class CN2SDUnorderedLearner(_RuleLearner):
     """
     name = 'CN2-SD unordered inducer'
 
-    def __init__(self, preprocessors=None, base_rules=None):
-        super().__init__(preprocessors, base_rules)
+    def __init__(self, preprocessors=None, base_rules=None,
+                 *, restrict_equality=False):
+        super().__init__(preprocessors, base_rules,
+                         restrict_equality=restrict_equality)
         self.rule_finder.quality_evaluator = WeightedRelativeAccuracyEvaluator()
         self.cover_and_remove = self.weighted_cover_and_remove
         self.gamma = 0.7

Orange/widgets/model/owrules.py

@@ -73,6 +73,7 @@ def __init__(self, preprocessors, base_rules, params):
 
         # bottom-level search procedure (search strategy)
         self.rule_finder.search_strategy.constrain_continuous = True
+        self.rule_finder.search_strategy.restrict_equality = params["Restrict to equality"]
 
         # bottom-level search procedure (search heuristics)
         evaluation_measure = params["Evaluation measure"]
@@ -229,6 +230,7 @@ class OWRuleLearner(OWBaseLearner):
     covering_algorithm = Setting(0)
     gamma = Setting(0.7)
     evaluation_measure = Setting(0)
+    restrict_equality = Setting(False)
     beam_width = Setting(5)
     min_covered_examples = Setting(1)
     max_rule_length = Setting(5)
@@ -312,6 +314,12 @@ def add_main_layout(self):
             alignment=Qt.AlignRight, controlWidth=80,
             checked="checked_parent_alpha")
 
+        gui.checkBox(
+            widget=bottom_box, master=self, value="restrict_equality",
+            label="Restrict operator for categorical values to equality",
+            callback=self.settings_changed,
+        )
+
     def settings_changed(self, *args, **kwargs):
         self.gamma_spin.setDisabled(self.covering_algorithm == 0)
         super().settings_changed(*args, **kwargs)
@@ -349,6 +357,7 @@ def get_learner_parameters(self):
             ("Covering algorithm", self.storage_covers[self.covering_algorithm]),
             ("Gamma", self.gamma),
             ("Evaluation measure", self.storage_measures[self.evaluation_measure]),
+            ("Restrict to equality", self.restrict_equality),
             ("Beam width", self.beam_width),
             ("Minimum rule coverage", self.min_covered_examples),
             ("Maximum rule length", self.max_rule_length),

i18n/si/msgs.jaml

@@ -10372,6 +10372,7 @@ widgets/model/owrules.py:
             weighted: utežena
             Gamma: Gama
             Beam width: Širina snopa
+            Restrict to equality: Omejitev na enakost
             Evaluation measure: Ocena kvalitete pravila
             entropy: entropija
             laplace: Laplacova natančnost
@@ -10427,11 +10428,14 @@ widgets/model/owrules.py:
             parent_alpha: false
             Relative significance (parent α):: Relativna značilnost (predniko α):
             checked_parent_alpha: false
+            restrict_equality: false
+            Restrict operator for categorical values to equality: Omeji operator za kategorične vrednosti na enakost
         def `get_learner_parameters`:
             Rule ordering: Urejenost pravil
             Covering algorithm: Način prekrivanja
             Gamma: Gama
             Evaluation measure: Ocena kvalitete pravila
+            Restrict to equality: Omejitev na enakost
             Beam width: Širina snopa
             Minimum rule coverage: Najmanjše število pokritih primerov
             Maximum rule length: Največja dolžina pravila