psyke 0.8.9.dev93__py3-none-any.whl → 0.8.14__py3-none-any.whl

psyke/extraction/hypercubic/hypercube.py

@@ -472,11 +472,13 @@ class RegressionCube(HyperCube):
 
     def body(self, variables: dict[str, Var], ignore: list[str], unscale=None, normalization=None) -> Iterable[Struct]:
         intercept = self.output.intercept_ if normalization is None else unscale(sum(
-            [-self.output.coef_[i] * normalization[name][0] / normalization[name][1] for i, name in
+            [-self.output.coef_.flatten()[i] * normalization[name][0] / normalization[name][1] for i, name in
              enumerate(self.dimensions.keys())], self.output.intercept_), list(normalization.keys())[-1])
+        if isinstance(intercept, list):
+            intercept = intercept[0]
         coefs = self.output.coef_ if normalization is None else [
-            self.output.coef_[i] / normalization[name][1] * normalization[list(normalization.keys())[-1]][1] for
-            i, name in enumerate(self.dimensions.keys())
+            self.output.coef_.flatten()[i] / normalization[name][1] * normalization[list(normalization.keys())[-1]][1]
+            for i, name in enumerate(self.dimensions.keys())
         ]
         return list(super().body(variables, ignore, unscale, normalization)) + [linear_function_creator(
             list(variables.values()), [to_rounded_real(v) for v in coefs], to_rounded_real(intercept)

psyke/extraction/real/__init__.py

@@ -15,13 +15,11 @@ class REAL(PedagogicalExtractor):
     """
     Explanator implementing Rule Extraction As Learning (REAL) algorithm, doi:10.1016/B978-1-55860-335-6.50013-1.
     The algorithm is sensible to features' order in the provided dataset during extraction.
-    To make it reproducible the features are internally sorted (alphabetically).
     """
 
     def __init__(self, predictor, discretization: Iterable[DiscreteFeature]):
         super().__init__(predictor, discretization)
         self._ruleset: IndexedRuleSet = IndexedRuleSet()
-        self._output_mapping = {}
 
     @property
     def n_rules(self):
@@ -31,7 +29,7 @@ class REAL(PedagogicalExtractor):
         new_rule = self._rule_from_example(sample)
         return any([new_rule in rule for rule in rules])
 
-    def _create_body(self, variables: dict[str, Var], rule: Rule) -> list[Struct]:
+    def _body(self, variables: dict[str, Var], rule: Rule) -> list[Struct]:
         result = []
         for predicates, truth_value in zip(rule.to_lists(), [True, False]):
             for predicate in predicates:
@@ -40,27 +38,24 @@ class REAL(PedagogicalExtractor):
         return result
 
     def _create_clause(self, dataset: pd.DataFrame, variables: dict[str, Var], key: int, rule: Rule) -> Clause:
-        head = create_head(dataset.columns[-1],
-                           sorted(list(variables.values())),
-                           str(sorted(list(set(dataset.iloc[:, -1])))[key]))
-        return clause(head, self._create_body(variables, rule))
+        return clause(create_head(dataset.columns[-1], list(variables.values()), key), self._body(variables, rule))
 
     def _create_new_rule(self, sample: pd.Series) -> Rule:
         rule = self._rule_from_example(sample)
         return self._generalise(rule, sample)
 
     def _create_ruleset(self, dataset: pd.DataFrame) -> IndexedRuleSet:
-        ruleset = IndexedRuleSet.create_indexed_ruleset(dataset)
-        for index, sample in dataset.iloc[:, :-1].iterrows():
+        ruleset = IndexedRuleSet.create_indexed_ruleset(sorted(set(dataset.iloc[:, -1])))
+        for _, sample in dataset.iloc[:, :-1].iterrows():
             prediction = list(self.predictor.predict(sample.to_frame().transpose()))[0]
-            rules = ruleset.get(self._output_mapping[prediction])
+            rules = ruleset.get(prediction)
             if not self._covers(sample, rules):
                 rules.append(self._create_new_rule(sample))
         return ruleset.optimize()
 
-    def _create_theory(self, dataset: pd.DataFrame, ruleset: IndexedRuleSet) -> MutableTheory:
+    def _create_theory(self, dataset: pd.DataFrame) -> MutableTheory:
         theory = mutable_theory()
-        for key, rule in ruleset.flatten():
+        for key, rule in self._ruleset.flatten():
             variables = create_variable_list(self.discretization)
             theory.assertZ(self._create_clause(dataset, variables, key, rule))
         return theory
@@ -93,15 +88,14 @@ class REAL(PedagogicalExtractor):
 
     def _internal_predict(self, sample: pd.Series):
         x = [index for index, rule in self._ruleset.flatten() if REAL._rule_from_example(sample) in rule]
-        reverse_mapping = dict((v, k) for k, v in self._output_mapping.items())
-        return reverse_mapping[x[0]] if len(x) > 0 else None
+        return x[0] if x else None
 
     @staticmethod
     def _rule_from_example(sample: pd.Series) -> Rule:
         true_predicates, false_predicates = [], []
         for feature, value in sample.items():
             true_predicates.append(str(feature)) if value == 1 else false_predicates.append(str(feature))
-        return Rule(sorted(true_predicates), sorted(false_predicates))
+        return Rule(true_predicates, false_predicates)
 
     def _subset(self, samples: pd.DataFrame, predicate: str) -> (pd.DataFrame, bool):
         samples_0 = samples.copy()
@@ -112,11 +106,8 @@ class REAL(PedagogicalExtractor):
         return samples_all, len(set(self.predictor.predict(samples_all))) == 1
 
     def _extract(self, dataframe: pd.DataFrame) -> Theory:
-        # Order the dataset by column to preserve reproducibility.
-        dataframe = dataframe.sort_values(by=list(dataframe.columns.values), ascending=False)
-        self._output_mapping = {value: index for index, value in enumerate(sorted(set(dataframe.iloc[:, -1])))}
         self._ruleset = self._get_or_set(HashableDataFrame(dataframe))
-        return self._create_theory(dataframe, self._ruleset)
+        return self._create_theory(dataframe)
 
     def _predict(self, dataframe) -> Iterable:
         return np.array([self._internal_predict(data.transpose()) for _, data in dataframe.iterrows()])

psyke/extraction/real/utils.py

@@ -49,5 +49,5 @@ class IndexedRuleSet(dict[int, list[Rule]]):
         ]
 
     @staticmethod
-    def create_indexed_ruleset(dataset: pd.DataFrame) -> IndexedRuleSet:
-        return IndexedRuleSet({index: [] for index, _ in enumerate(set(dataset.iloc[:, -1]))})
+    def create_indexed_ruleset(indices: Iterable) -> IndexedRuleSet:
+        return IndexedRuleSet({i: [] for i in indices})

psyke/extraction/trepan/__init__.py

@@ -73,10 +73,10 @@ class Trepan(PedagogicalExtractor):
                     splits.add(split)
         return splits
 
-    def _create_theory(self, name: str, sort: bool = True) -> MutableTheory:
+    def _create_theory(self, name: str) -> MutableTheory:
         theory = mutable_theory()
         for node in self._root:
-            variables = create_variable_list(self.discretization, sort=sort)
+            variables = create_variable_list(self.discretization)
             theory.assertZ(
                 clause(
                     create_head(name, list(variables.values()), str(node.dominant)),

psyke/hypercubepredictor.py

@@ -45,9 +45,9 @@ class HyperCubePredictor(EvaluableModel):
         idx = tree.query([list(row.values())], k=1)[1][0][0]
         return HyperCubePredictor._get_cube_output(cubes[idx], row)
 
-    def _brute_predict_surface(self, row: dict[str, float]) -> GenericCube:
+    def _brute_predict_surface(self, row: pd.Series) -> GenericCube:
         return min([(
-            cube.surface_distance(Point(list(row.keys()), list(row.values()))), cube.volume(), cube
+            cube.surface_distance(Point(list(row.keys()), list(row.values))), cube.volume(), cube
         ) for cube in self._hypercubes])[-1]
 
     def _create_brute_tree(self, criterion: str = 'center', n: int = 2) -> (BallTree, list[GenericCube]):
@@ -76,6 +76,8 @@ class HyperCubePredictor(EvaluableModel):
             return round(HyperCubePredictor._get_cube_output(cube, data), get_int_precision())
 
     def _find_cube(self, data: dict[str, float]) -> GenericCube | None:
+        if not self._hypercubes:
+            return None
         data = data.copy()
         for dimension in self._dimensions_to_ignore:
             if dimension in data:

psyke/utils/logic.py

@@ -123,12 +123,8 @@ def to_var(name: str) -> Var:
     return var(name[0].upper() + name[1:])
 
 
-def create_variable_list(features: list[DiscreteFeature], dataset: pd.DataFrame = None, sort: bool = True) -> dict[str, Var]:
-    if sort:
-        features = sorted(features, key=lambda x: x.name)
-        dataset = sorted(dataset.columns[:-1]) if dataset is not None else None
-    else:
-        dataset = dataset.columns[:-1] if dataset is not None else None
+def create_variable_list(features: list[DiscreteFeature], dataset: pd.DataFrame = None) -> dict[str, Var]:
+    dataset = dataset.columns[:-1] if dataset is not None else None
     values = {feature.name: to_var(feature.name) for feature in features} \
         if len(features) > 0 else {name: to_var(name) for name in dataset}
     return values
@@ -325,4 +321,4 @@ def get_not_in_rule(min_included: bool = False, max_included: bool = True) -> Cl
     parser = DEFAULT_CLAUSES_PARSER
     theory = parser.parse_clauses(not_in_textual_rule(LE if min_included else L, GE if max_included else G),
                                   operators=None)
-    return theory[0]
+    return theory[0]

{psyke-0.8.9.dev93.dist-info → psyke-0.8.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psyke
-Version: 0.8.9.dev93
+Version: 0.8.14
 Summary: Python-based implementation of PSyKE, i.e. a Platform for Symbolic Knowledge Extraction
 Home-page: https://github.com/psykei/psyke-python
 Author: Matteo Magnini

{psyke-0.8.9.dev93.dist-info → psyke-0.8.14.dist-info}/RECORD

@@ -1,5 +1,5 @@
 psyke/__init__.py,sha256=V_sOXKt_5fYmNABwpveJd10u7Wy7A6wlLECBJY_ra_E,18634
-psyke/hypercubepredictor.py,sha256=MlSRLky6J1I07qKcH98c9WvEjFHGyBiz_LU9W_oDnqs,4572
+psyke/hypercubepredictor.py,sha256=Pg8F2R_NHrNgFHx92s32BorYHMVvaxpEh4GtCsoyB2U,4620
 psyke/clustering/__init__.py,sha256=36MokTVwwWR_-o0mesvXHaYEYVTK2pn2m0ZY4G3Y3qU,581
 psyke/clustering/utils.py,sha256=S0YwCKyHVYp9qUAQVzCMrTwcQFPJ5TD14Jwn10DE-Z4,1616
 psyke/clustering/cream/__init__.py,sha256=W6k7vdjuUdA_azYA4vb5JtpWrofhDJ0DbM2jsnRKzfw,2994
@@ -8,7 +8,7 @@ psyke/extraction/__init__.py,sha256=ziZ8T9eAOZjKipepE5_j1zfZgyFPONjW8MGERSk83nI,
 psyke/extraction/cart/__init__.py,sha256=r2mDULg7oTHrIMPw9lqD6MyXhkkymP4r9PoGUKjAWCM,4569
 psyke/extraction/cart/predictor.py,sha256=_YBedfyz4rGIBeNpN7OaL2BKWdF_5nuq8AlXkVfCtvk,3359
 psyke/extraction/hypercubic/__init__.py,sha256=w_NmfSjh8fCWLDXVXpRLiAApq697cvUSPTgju-jtZCA,10620
-psyke/extraction/hypercubic/hypercube.py,sha256=GKjplRl34BegrA3JclvlkrL7hXftdUUMXndmRFFoJic,25697
+psyke/extraction/hypercubic/hypercube.py,sha256=DlphGxbUHg4MePmpZm97PPw2GL8Ot2fypZBut-aTpwc,25794
 psyke/extraction/hypercubic/strategy.py,sha256=X-roIsfcpJyMdo2px5JtbhP7-XE-zUNkaEK7XGXoWA8,1636
 psyke/extraction/hypercubic/utils.py,sha256=D2FN5CCm_T3h23DmLFoTnIcFo7LvIq__ktl4hjUqkcA,1525
 psyke/extraction/hypercubic/cosmik/__init__.py,sha256=XQUvOtMFpR0vMHYtwIVl3G626HMqN8Clt6BqNm4nvFs,1880
@@ -18,9 +18,9 @@ psyke/extraction/hypercubic/gridex/__init__.py,sha256=o7tNU3JH8AqA2PRj839-rPb6zh
 psyke/extraction/hypercubic/gridrex/__init__.py,sha256=h9usK5tFqd6ngBmRydsgkfQ1jlcQKj2uG72Tr1puFHk,595
 psyke/extraction/hypercubic/hex/__init__.py,sha256=553AZjOT9thfqDGtVDI6WtgYNex2Y6dg53cEyuf7Q80,4805
 psyke/extraction/hypercubic/iter/__init__.py,sha256=9wE9pdEVNM9a9VfkNVKZjemFESyNJRoJPUF0AbitTsk,10054
-psyke/extraction/real/__init__.py,sha256=fFqiwgWTpu5Jx9lz5CdSfs1QyqWYFLQDG7tc5M6Q7UM,6065
-psyke/extraction/real/utils.py,sha256=eHGU-Y0inn_8jrk9lMcuRUKXpsTkI-s_myXSWz4bALQ,2190
-psyke/extraction/trepan/__init__.py,sha256=KpZpk0btCWV4bS-DOmpgpYscSQ5FEMyP54ekm7ZedME,6583
+psyke/extraction/real/__init__.py,sha256=t3wrY4dEmZK3PhGexxHh1bhlCr4vvZ1IS6vDZoHyZjw,5379
+psyke/extraction/real/utils.py,sha256=4NNL15Eu7cmkG9b29GBP6CKgMTV1cmiJVS0k1MbWpIs,2148
+psyke/extraction/trepan/__init__.py,sha256=1g9AXPgH6xrPUjFMFK7c7-DZ-AeGD7EUbF4U7WFSSsI,6553
 psyke/extraction/trepan/utils.py,sha256=iSUJ1ooNQT_VO1KfBZuIUeUsyUbGdQf_pSEE87vMeQg,2320
 psyke/schema/__init__.py,sha256=axv4ejZY0ItUwrC9IXb_yAhaQL5f1vwvXXmaIAHJmt0,26063
 psyke/tuning/__init__.py,sha256=yd_ForFmHeYbtRXltY1fOa-mPJvpE6ijzg50M_8Sdxw,3649
@@ -29,12 +29,12 @@ psyke/tuning/orchid/__init__.py,sha256=s64iABbteik27CrRPHSVHNZX25JKlDu7YYjhseOiz
 psyke/tuning/pedro/__init__.py,sha256=Q7Te3FWeLvJ7g2dkDraorUs6eRtxFgE9HEc3MshcATs,6648
 psyke/utils/__init__.py,sha256=F-fgBT9CkthIwW8dDCuF5OoQDVMBNvIsZyvNqkgZNUA,1767
 psyke/utils/dataframe.py,sha256=cPbCl_paACCtO0twCiHKUcEKIYiT89WDwQ-f5I9oKrg,6841
-psyke/utils/logic.py,sha256=7bbW6qcKof5PlqoQ0n5Kt3Obcot-KqGAvpE8rMXvEPE,12419
+psyke/utils/logic.py,sha256=P_hmhpRhpyCzWwOS1uOWGzvNAh6Eo10wbOBUQNZ_Rxo,12236
 psyke/utils/metrics.py,sha256=Oo5BOonOSfo0qYsXWT5dmypZ7jiStByFC2MKEU0uMHg,2250
 psyke/utils/plot.py,sha256=dE8JJ6tQ0Ezosid-r2jqAisREjFe5LqExRzsVi5Ns-c,7785
 psyke/utils/sorted.py,sha256=C3CPW2JisND30BRk5c1sAAHs3Lb_wsRB2qZrYFuRnfM,678
-psyke-0.8.9.dev93.dist-info/licenses/LICENSE,sha256=KP9K6Hgezf_xdMFW7ORyKz9uA8Y8k52YJn292wcP-_E,11354
-psyke-0.8.9.dev93.dist-info/METADATA,sha256=j5s2tda9j6R5nmDATTaqmjYCObNgGkaL7mUDOhFZqEM,8395
-psyke-0.8.9.dev93.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-psyke-0.8.9.dev93.dist-info/top_level.txt,sha256=q1HglxOqqoIRukFtyis_ZNHczZg4gANRUPWkD7HAUTU,6
-psyke-0.8.9.dev93.dist-info/RECORD,,
+psyke-0.8.14.dist-info/licenses/LICENSE,sha256=KP9K6Hgezf_xdMFW7ORyKz9uA8Y8k52YJn292wcP-_E,11354
+psyke-0.8.14.dist-info/METADATA,sha256=cwlsEje_1gui71I0iJ778f0RTM5Hf4sZA1Ztl6KXbDk,8390
+psyke-0.8.14.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+psyke-0.8.14.dist-info/top_level.txt,sha256=q1HglxOqqoIRukFtyis_ZNHczZg4gANRUPWkD7HAUTU,6
+psyke-0.8.14.dist-info/RECORD,,

{psyke-0.8.9.dev93.dist-info → psyke-0.8.14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (80.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any