support float and boolean targets in KhiopsClassifier

Author: nairbenrekia

khiops/samples/samples_sklearn.py

@@ -88,45 +88,6 @@ def khiops_classifier():
     # khc.export_report_file("report.khj")
     # kh.visualize_report("report.khj")
 
-def khiops_classifier_float_target():
-    """Trains a `.KhiopsClassifier` on a monotable dataframe"""
-    # Imports
-    import os
-    import pandas as pd
-    from khiops import core as kh
-    from khiops.sklearn import KhiopsClassifier
-    from sklearn import metrics
-    from sklearn.model_selection import train_test_split
-
-    # Load the dataset into a pandas dataframe
-    adult_path = os.path.join(kh.get_samples_dir(), "Adult", "Adult.txt")
-    adult_df = pd.read_csv(adult_path, sep="\t")
-
-    # Split the whole dataframe into train and test (70%-30%)
-    adult_train_df, adult_test_df = train_test_split(
-        adult_df, test_size=0.3, random_state=1
-    )
-
-    X_train = adult_train_df.drop("class", axis=1)
-    X_test = adult_test_df.drop("class", axis=1)
-    #y_train = adult_train_df["class"].replace({"less": 0.0, "more": 1.0})
-    y_train = adult_train_df["class"].replace({"less": True, "more": False})
-
-    print(y_train.dtype)
-    #y_train.replace()
-
-    # Create the classifier object
-    khc = KhiopsClassifier()
-
-    # Train the classifier
-    khc.fit(X_train, y_train)
-
-    # Predict the classes on the test dataset
-    y_test_pred = khc.predict(X_test)
-    print("Predicted classes (first 10):")
-    print(y_test_pred[0:10])
-    print("---")
-
 
 def khiops_classifier_multiclass():
     """Trains a multiclass `.KhiopsClassifier` on a monotable dataframe"""
@@ -1063,7 +1024,23 @@ def khiops_classifier_multitable_star_file():
 
 
 exported_samples = [
-    khiops_classifier_float_target
+    khiops_classifier,
+    khiops_classifier_multiclass,
+    khiops_classifier_multitable_star,
+    khiops_classifier_multitable_snowflake,
+    khiops_classifier_sparse,
+    khiops_classifier_pickle,
+    khiops_classifier_with_hyperparameters,
+    khiops_regressor,
+    khiops_encoder,
+    khiops_encoder_multitable_star,
+    khiops_encoder_multitable_snowflake,
+    khiops_encoder_pipeline_with_hgbc,
+    khiops_encoder_with_hyperparameters,
+    khiops_coclustering,
+    khiops_coclustering_simplify,
+    khiops_classifier_multitable_list,
+    khiops_classifier_multitable_star_file,
 ]
 
 

khiops/sklearn/dataset.py

@@ -14,7 +14,6 @@
 
 import numpy as np
 import pandas as pd
-from Demos.win32cred_demo import target
 from scipy import sparse as sp
 from sklearn.utils import check_array
 from sklearn.utils.validation import column_or_1d
@@ -739,8 +738,15 @@ def _init_target_column(self, y):
         if isinstance(y, str):
             y_checked = y
         else:
-            y_checked = column_or_1d(y, warn=True)
-
+            if hasattr(y, "dtype"):
+                if isinstance(y.dtype, pd.CategoricalDtype):
+                    y_checked = column_or_1d(
+                        y, warn=True, dtype=y.dtype.categories.dtype
+                    )
+                else:
+                    y_checked = column_or_1d(y, warn=True, dtype=y.dtype)
+            else:
+                y_checked = column_or_1d(y, warn=True)
         # Check the target type coherence with those of X's tables
         if isinstance(
             self.main_table, (PandasTable, SparseTable, NumpyTable)
@@ -1259,8 +1265,6 @@ def create_table_file_for_khiops(
             get_khiops_variable_name(column_id) for column_id in self.column_ids
         ]
         if target_column is not None:
-            print(target_column)
-            print(target_column.dtype)
             output_dataframe[get_khiops_variable_name(target_column_id)] = (
                 target_column.copy()
             )

khiops/sklearn/estimators.py

@@ -2126,20 +2126,20 @@ def _is_real_target_dtype_integer(self):
 
     def _is_real_target_dtype_float(self):
         return self._original_target_dtype is not None and (
-                pd.api.types.is_float_dtype(self._original_target_dtype)
-                or (
-                        isinstance(self._original_target_dtype, pd.CategoricalDtype)
-                        and pd.api.types.is_float_dtype(self._original_target_dtype.categories)
-                )
+            pd.api.types.is_float_dtype(self._original_target_dtype)
+            or (
+                isinstance(self._original_target_dtype, pd.CategoricalDtype)
+                and pd.api.types.is_float_dtype(self._original_target_dtype.categories)
+            )
         )
 
     def _is_real_target_dtype_bool(self):
         return self._original_target_dtype is not None and (
-                pd.api.types.is_bool_dtype(self._original_target_dtype)
-                or (
-                        isinstance(self._original_target_dtype, pd.CategoricalDtype)
-                        and pd.api.types.is_bool_dtype(self._original_target_dtype.categories)
-                )
+            pd.api.types.is_bool_dtype(self._original_target_dtype)
+            or (
+                isinstance(self._original_target_dtype, pd.CategoricalDtype)
+                and pd.api.types.is_bool_dtype(self._original_target_dtype.categories)
+            )
         )
 
     def _sorted_prob_variable_names(self):
@@ -2246,12 +2246,10 @@ def _fit_training_post_process(self, ds):
             for key in variable.meta_data.keys:
                 if key.startswith("TargetProb"):
                     self.classes_.append(variable.meta_data.get_value(key))
-        print(self._get_main_dictionary())
         if ds.is_in_memory:
             if self._is_real_target_dtype_integer():
                 self.classes_ = [int(class_value) for class_value in self.classes_]
             elif self._is_real_target_dtype_float():
-                print(self.classes_)
                 self.classes_ = [float(class_value) for class_value in self.classes_]
             elif self._is_real_target_dtype_bool():
                 self.classes_ = [class_value == "True" for class_value in self.classes_]

tests/test_sklearn_output_types.py

@@ -83,19 +83,19 @@ def test_classifier_output_types(self):
         # Create the fixtures
         fixtures = {
             "ys": {
-                #"int": y,
-                #"int binary": y_bin,
-                #"float": y.astype(float),
-                #"bool": y.replace({0: True, 1: True, 2: False}),
-                #"string": self._replace(y, {0: "se", 1: "vi", 2: "ve"}),
-                #"string binary": self._replace(y_bin, {0: "vi_or_se", 1: "ve"}),
-                #"int as string": self._replace(y, {0: "8", 1: "9", 2: "10"}),
-                #"int as string binary": self._replace(y_bin, {0: "89", 1: "10"}),
-                #"cat int": pd.Series(y).astype("category"),
-                #"cat string": pd.Series(
-           #self._replace(y, {0: "se", 1: "vi", 2: "ve"})
-                #).astype("category"),
-                #"cat float": y.astype(float).astype("category"),
+                "int": y,
+                "int binary": y_bin,
+                "float": y.astype(float),
+                "bool": y.replace({0: True, 1: True, 2: False}),
+                "string": self._replace(y, {0: "se", 1: "vi", 2: "ve"}),
+                "string binary": self._replace(y_bin, {0: "vi_or_se", 1: "ve"}),
+                "int as string": self._replace(y, {0: "8", 1: "9", 2: "10"}),
+                "int as string binary": self._replace(y_bin, {0: "89", 1: "10"}),
+                "cat int": pd.Series(y).astype("category"),
+                "cat string": pd.Series(
+                    self._replace(y, {0: "se", 1: "vi", 2: "ve"})
+                ).astype("category"),
+                "cat float": y.astype(float).astype("category"),
                 "cat bool": y.replace({0: True, 1: True, 2: False}).astype("category"),
             },
             "y_type_check": {
@@ -144,7 +144,6 @@ def test_classifier_output_types(self):
                     "cat string": self._replace(y_pred, {0: "se", 1: "vi", 2: "ve"}),
                     "cat float": self._replace(y_pred, {0: 0.0, 1: 1.0, 2: 2.0}),
                     "cat bool": self._replace(y_bin_pred, {0: True, 1: False}),
-
                 },
                 "multi": {
                     "int": y_mt_pred,
@@ -165,7 +164,6 @@ def test_classifier_output_types(self):
                     "cat string": self._replace(y_mt_pred, {0: "se", 1: "vi", 2: "ve"}),
                     "cat float": self._replace(y_mt_pred, {0: 0.0, 1: 1.0, 2: 2.0}),
                     "cat bool": self._replace(y_mt_bin_pred, {0: True, 1: False}),
-
                 },
             },
             "Xs": {
@@ -176,8 +174,6 @@ def test_classifier_output_types(self):
 
         # Test for each fixture configuration
         for y_type, y in fixtures["ys"].items():
-            print()
-            print(y_type)
             y_type_check = fixtures["y_type_check"][y_type]
             expected_classes = fixtures["expected_classes"][y_type]
             for dataset_type, X in fixtures["Xs"].items():
@@ -189,12 +185,8 @@ def test_classifier_output_types(self):
                     # Train the classifier
                     khc = KhiopsClassifier(n_trees=0)
                     khc.fit(X, y)
-                    print('unique y values:', np.unique(y))
 
                     # Check the expected classes
-                    print()
-                    print('model classes:', khc.classes_)
-                    print('expected_classes:', expected_classes)
                     assert_array_equal(khc.classes_, expected_classes)
 
                     # Check the return type of predict
@@ -207,14 +199,7 @@ def test_classifier_output_types(self):
                     )
 
                     # Check the predictions match
-                    print(dataset_type, y_type)
                     expected_y_pred = fixtures["expected_y_preds"][dataset_type][y_type]
-                    diff_indices = np.where(y_pred != expected_y_pred)
-                    print("Indices où les valeurs diffèrent :", diff_indices)
-
-                    for idx in zip(*diff_indices):
-                        print(f"À l'indice {idx}, y_pred={y_pred[idx]}, expected_y_pred={expected_y_pred[idx]}")
-
                     assert_array_equal(y_pred, expected_y_pred)
 
                     # Check the dimensions of predict_proba