psyke 0.8.9.dev94__tar.gz → 0.8.14__tar.gz

{psyke-0.8.9.dev94/psyke.egg-info → psyke-0.8.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psyke
-Version: 0.8.9.dev94
+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.14/VERSION

@@ -0,0 +1 @@
+0.8.14

{psyke-0.8.9.dev94 → psyke-0.8.14}/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-0.8.9.dev94 → psyke-0.8.14}/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-0.8.9.dev94 → psyke-0.8.14}/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-0.8.9.dev94 → psyke-0.8.14}/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-0.8.9.dev94 → psyke-0.8.14}/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-0.8.9.dev94 → psyke-0.8.14}/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.dev94 → psyke-0.8.14/psyke.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psyke
-Version: 0.8.9.dev94
+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.dev94 → psyke-0.8.14}/setup.py

@@ -70,58 +70,58 @@ class GetVersionCommand(distutils.cmd.Command):
         print(version)
 
 
-class CreateTestPredictors(distutils.cmd.Command):
-    description = 'gets the project version from git describe'
-    user_options = []
-
-    def initialize_options(self):
-        pass
-
-    def finalize_options(self):
-        pass
-
-    def run(self):
-        from psyke.utils import get_default_random_seed
-        from psyke.utils.dataframe import get_discrete_dataset
-        from sklearn.model_selection import train_test_split
-        from test import REQUIRED_PREDICTORS, get_dataset, get_model, get_schema
-        from test.resources.predictors import get_predictor_path, PATH, create_predictor_name
-        import ast
-        import pandas as pd
-        from tensorflow.keras import Model
-        from test import Predictor
+#class CreateTestPredictors(distutils.cmd.Command):
+#    description = 'gets the project version from git describe'
+#    user_options = []
+
+#    def initialize_options(self):
+#        pass
+
+#    def finalize_options(self):
+#        pass
+
+#    def run(self):
+#        from psyke.utils import get_default_random_seed
+#        from psyke.utils.dataframe import get_discrete_dataset
+#        from sklearn.model_selection import train_test_split
+#        from test import REQUIRED_PREDICTORS, get_dataset, get_model, get_schema
+#        from test.resources.predictors import get_predictor_path, PATH, create_predictor_name
+#        import ast
+#        import pandas as pd
+#        from tensorflow.keras import Model
+#        from test import Predictor
 
         # Read the required predictors to run the tests:
         #   model | model_options | dataset
-        required_predictors = pd.read_csv(REQUIRED_PREDICTORS, sep=';')
+#        required_predictors = pd.read_csv(REQUIRED_PREDICTORS, sep=';')
 
         # Create missing predictors.
         #     model | model_options | dataset
-        for index, row in required_predictors.iterrows():
-            options = ast.literal_eval(row['model_options'])
-            file_name = create_predictor_name(row['dataset'], row['model'], options)
-            if not get_predictor_path(file_name).is_file():
-                dataset = get_dataset(row['dataset'])
-                if row['bins'] > 0:
-                    schema = get_schema(dataset)  # int(row['bins'])
-                    dataset = get_discrete_dataset(dataset.iloc[:, :-1], schema).join(dataset.iloc[:, -1])
-                model, _ = get_model(row['model'], options)
-                training_set, test_set = train_test_split(dataset, test_size=0.5,
-                                                          random_state=get_default_random_seed())
-                if isinstance(model, Model):
-                    keys = set(training_set.iloc[:, -1])
-                    mapping = {key: i for i, key in enumerate(keys)}
-                    training_set.iloc[:, -1] = training_set.iloc[:, -1].apply(lambda x: mapping[x])
-                    test_set.iloc[:, -1] = test_set.iloc[:, -1].apply(lambda x: mapping[x])
-                    model.fit(training_set.iloc[:, :-1], training_set.iloc[:, -1], epochs=EPOCHS, batch_size=BATCH_SIZE)
-                else:
-                    model.fit(training_set.iloc[:, :-1], training_set.iloc[:, -1])
-                predictor = Predictor(model)
-                predictor.save_to_onnx(PATH / file_name, Predictor.get_initial_types(training_set.iloc[:, :-1]))
-
-        required_predictors.to_csv(REQUIRED_PREDICTORS, sep=';', index=False)
-
-        print("Done")
+#        for index, row in required_predictors.iterrows():
+#            options = ast.literal_eval(row['model_options'])
+#            file_name = create_predictor_name(row['dataset'], row['model'], options)
+#            if not get_predictor_path(file_name).is_file():
+#                dataset = get_dataset(row['dataset'])
+#                if row['bins'] > 0:
+#                    schema = get_schema(dataset)  # int(row['bins'])
+#                    dataset = get_discrete_dataset(dataset.iloc[:, :-1], schema).join(dataset.iloc[:, -1])
+#                model, _ = get_model(row['model'], options)
+#                training_set, test_set = train_test_split(dataset, test_size=0.5,
+#                                                          random_state=get_default_random_seed())
+#                if isinstance(model, Model):
+#                    keys = set(training_set.iloc[:, -1])
+#                    mapping = {key: i for i, key in enumerate(keys)}
+#                    training_set.iloc[:, -1] = training_set.iloc[:, -1].apply(lambda x: mapping[x])
+#                    test_set.iloc[:, -1] = test_set.iloc[:, -1].apply(lambda x: mapping[x])
+#                    model.fit(training_set.iloc[:, :-1], training_set.iloc[:, -1], epochs=EPOCHS, batch_size=BATCH_SIZE)
+#                else:
+#                    model.fit(training_set.iloc[:, :-1], training_set.iloc[:, -1])
+#                predictor = Predictor(model)
+#                predictor.save_to_onnx(PATH / file_name, Predictor.get_initial_types(training_set.iloc[:, :-1]))
+
+#        required_predictors.to_csv(REQUIRED_PREDICTORS, sep=';', index=False)
+
+#        print("Done")
 
 
 class CreateTheoryPlot(distutils.cmd.Command):
@@ -205,8 +205,8 @@ setup(
     include_package_data=True,
     python_requires='>=3.9.0, <3.10',
     install_requires=REQUIREMENTS,  # Optional
-    zip_safe = False,
-    platforms = "Independant",
+    zip_safe=False,
+    platforms="Independant",
     project_urls={  # Optional
         'Bug Reports': 'https://github.com/psykei/psyke-python/issues',
         # 'Funding': 'https://donate.pypi.org',
@@ -215,7 +215,7 @@ setup(
     },
     cmdclass={
         'get_project_version': GetVersionCommand,
-        'create_test_predictors': CreateTestPredictors,
+        # 'create_test_predictors': CreateTestPredictors,
         'create_theory_plot': CreateTheoryPlot
     },
 )

{psyke-0.8.9.dev94 → psyke-0.8.14}/test/psyke/__init__.py

@@ -20,10 +20,6 @@ def initialize(file: str) -> list[dict[str:Theory]]:
         params = dict() if row['extractor_params'] == '' else ast.literal_eval(row['extractor_params'])
         dataset = get_dataset(row['dataset'])
 
-        # Dataset's columns are sorted due to alphabetically sorted extracted rules.
-        # columns = sorted(dataset.columns[:-1]) + [dataset.columns[-1]]
-        # dataset = dataset.reindex(columns, axis=1)
-
         training_set, test_set = train_test_split(dataset, test_size=0.05 if row['dataset'].lower() == 'house' else 0.5,
                                                   random_state=get_default_random_seed())
 
@@ -63,10 +59,8 @@ def initialize(file: str) -> list[dict[str:Theory]]:
 
         # Compute predictions from rules
         index = test_set.shape[1] - 1
-        ordered_test_set = test_set.copy()
-        ordered_test_set.iloc[:, :-1] = ordered_test_set.iloc[:, :-1].reindex(sorted(ordered_test_set.columns[:-1]),
-                                                                              axis=1)
-        cast, substitutions = get_substitutions(test_set, ordered_test_set, theory)
+
+        cast, substitutions = get_substitutions(test_set, theory)
         expected = [cast(query.solved_query.get_arg_at(index)) for query in substitutions if query.is_yes]
         predictions = [prediction for prediction in extractor.predict(test_set_for_predictor.iloc[:, :-1])
                        if prediction is not None]
@@ -82,8 +76,8 @@ def initialize(file: str) -> list[dict[str:Theory]]:
         }
 
 
-def get_substitutions(test_set, ordered_test_set, theory):
+def get_substitutions(test_set, theory):
     cast: Callable = lambda x: (str(x) if isinstance(test_set.iloc[0, -1], str) else float(x.value))
     solver = prolog_solver(static_kb=mutable_theory(theory).assertZ(get_in_rule()).assertZ(get_not_in_rule()))
-    substitutions = [solver.solveOnce(data_to_struct(data)) for _, data in ordered_test_set.iterrows()]
+    substitutions = [solver.solveOnce(data_to_struct(data)) for _, data in test_set.iterrows()]
     return cast, substitutions

{psyke-0.8.9.dev94 → psyke-0.8.14}/test/psyke/extraction/cart/test_simplified_cart.py

@@ -33,10 +33,10 @@ class TestSimplifiedCart(unittest.TestCase):
         simplified_theory = simplified_extractor.extract(train)
 
         index = test.shape[1] - 1
-        cast, substitutions = get_substitutions(test, test, theory)
+        cast, substitutions = get_substitutions(test, theory)
         expected = [cast(query.solved_query.get_arg_at(index)) for query in substitutions]
 
-        cast, simplified_substitutions = get_substitutions(test, test, simplified_theory)
+        cast, simplified_substitutions = get_substitutions(test, simplified_theory)
         simplified_expected = [cast(query.solved_query.get_arg_at(index)) for query in simplified_substitutions]
 
         if isinstance(test.iloc[0, -1], str):

psyke-0.8.9.dev94/VERSION

@@ -1 +0,0 @@
-0.8.9.dev94