classifier-toolkit 0.1.2__tar.gz → 0.1.4__tar.gz

{classifier_toolkit-0.1.2 → classifier_toolkit-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classifier-toolkit
-Version: 0.1.2
+Version: 0.1.4
 Summary: 
 Author: gauthier.marquand
 Author-email: gauthier.marquand@qonto.com

{classifier_toolkit-0.1.2 → classifier_toolkit-0.1.4}/classifier_toolkit/eda/eda_toolkit.py

@@ -4,8 +4,6 @@ from typing import Any, Dict, List, Literal, Optional, Union
 
 import pandas as pd
 
-from examples.constants import PATH_DATA_PROCESSED
-
 from .bivariate_analysis import BivariateAnalysis
 from .feature_engineering import FeatureEngineering
 from .first_glance import FirstGlance
@@ -44,6 +42,7 @@ class EDAToolkit:
         self,
         dataframe: pd.DataFrame,
         can_be_negative: List[str],
+        path_data_folder: Path,
         target_column: Optional[str] = None,
         exclusion: Optional[List[str]] = None,
         numerical_columns: Optional[List[str]] = None,
@@ -84,6 +83,7 @@ class EDAToolkit:
         self.categorical_columns = categorical_columns or []
         self.id_column = id_column or ""
         self.to_be_enc = to_be_enc or []
+        self.path_data_folder = path_data_folder
 
         # Initialize an empty list for transformations
         self.transformations: TransformationType = []
@@ -206,12 +206,20 @@ class EDAToolkit:
         self.first_glance.super_vision()
         self.first_glance.check_duplicates()
 
-    def plot_target_evolution(self):
+    def plot_target_evolution(self, time_column: str, evolving_numeric: str):
         """
         Plot the target balance and evolution over time.
+
+        Parameters
+        ----------
+        time_column : str
+            The name of the time column.
+        evolving_numeric : str
+            The name of the numerical column to plot that we want to see the evolution of
+            which helps us understanding the behavior of the target column.
         """
         self.visualizations.plot_target_balance()
-        self.visualizations.plot_target_evolution("scheduled_at", "min_balance_3m")
+        self.visualizations.plot_target_evolution(time_column, evolving_numeric)
 
     def plot_numerical_distributions(self, sub_plots: bool = False):
         """
@@ -232,7 +240,7 @@ class EDAToolkit:
         """
         self.visualizations.plot_categorical_value_counts()
         self.visualizations.visualize_high_cardinality(
-            excluded_vars=self.exclusion, id_column=self.id_column
+            excluded_columns=self.exclusion, id_column=self.id_column
         )
         self.visualizations.visualize_low_cardinality()
 
@@ -377,7 +385,7 @@ class EDAToolkit:
         """
         _, filtered_cramers = self.univariate_analysis.plot_cramers_v(
             self.numerical_columns,
-            excluded_vars=self.exclusion,
+            excluded_columns=self.exclusion,
             filter_threshold=threshold_c,
         )
 
@@ -406,7 +414,7 @@ class EDAToolkit:
         imputed = self.feature_engineering.handle_missing_values(imputation_method)
         transforms = self.get_transformations(unwanted_features=eliminated)
 
-        EDAToolkit.save_intermediary(PATH_DATA_PROCESSED, imputed, "imputed")
+        EDAToolkit.save_intermediary(self.path_data_folder, imputed, "imputed")
         print("Imputed dataframe saved in the processed directory.")
 
         self.feature_engineering = FeatureEngineering(
@@ -432,7 +440,7 @@ class EDAToolkit:
             to_transformed
         )
         transforms = self.get_transformations()
-        EDAToolkit.save_intermediary(PATH_DATA_PROCESSED, transformed, "transformed")
+        EDAToolkit.save_intermediary(self.path_data_folder, transformed, "transformed")
         print("Transformed dataframe saved in the processed directory.")
 
         self.feature_engineering = FeatureEngineering(
@@ -458,7 +466,7 @@ class EDAToolkit:
             Method to use for handling low cardinality columns.
         """
         binned = self.feature_engineering.binnings(methods=handling_method)
-        EDAToolkit.save_intermediary(PATH_DATA_PROCESSED, binned, "binned")
+        EDAToolkit.save_intermediary(self.path_data_folder, binned, "binned")
         print(
             "Variables with low cardinality are treated and saved in the processed directory."
         )
@@ -485,7 +493,7 @@ class EDAToolkit:
         )
         if high_card is not None:
             EDAToolkit.save_intermediary(
-                PATH_DATA_PROCESSED, high_card, "high_cardinality_treated"
+                self.path_data_folder, high_card, "high_cardinality_treated"
             )
             print(
                 "High cardinality variables are treated and dataframe saved in the processed directory."

{classifier_toolkit-0.1.2 → classifier_toolkit-0.1.4}/classifier_toolkit/eda/feature_engineering.py

@@ -364,9 +364,11 @@ class FeatureEngineering:
                 raise ValueError(f"Column {column} not found in transformed data")
 
         self.data = updated_data
-        self._log_transformation(
-            "apply_transformations", {"columns_to_keep": columns_to_keep}
-        )
+
+        for transform in self.transformations:
+            if transform["method"] == "normality_transform":
+                transform["selected_columns"] = columns_to_keep
+
         return self.data
 
     def handle_high_cardinality(
@@ -990,7 +992,10 @@ class FeatureEngineering:
 
         self.data = data
         self.data.info()
-        self._log_transformation("encoding_categorical", {"method": method})
+        self._log_transformation(
+            "encoding_categorical",
+            {"method": method, "selected_columns": self.encode_list},
+        )
         return self.data
 
     ####### FEATURE ENGINEERING: OPTIONAL FUNCTIONS #######
@@ -1264,47 +1269,3 @@ class FeatureEngineering:
         return self.data
 
     percentile_capping = apply_winsorization
-
-
-'''
-    def apply_winsorization(
-        self, selected_columns: List[str], percentile: float = 0.05
-    ) -> pd.DataFrame:
-        """
-        Apply winsorization to numerical columns to limit extreme values.
-
-        Parameters
-        ----------
-        selected_columns : List[str]
-            List of columns to apply winsorization to.
-        percentile : float, optional
-            The percentage of data to be considered as extreme values on each side, by default 0.05.
-
-        Returns
-        -------
-        pd.DataFrame
-            DataFrame with winsorized columns.
-        """
-        if len(selected_columns) == 0:
-            selected_columns = self.numerical_columns
-
-        for column in selected_columns:
-            if column == self.target_column:
-                print(f"{column} is the target column. Skipping winsorization.")
-                continue
-
-            lower_bound = np.percentile(self.data[column], percentile * 100)
-            upper_bound = np.percentile(self.data[column], (1 - percentile) * 100)
-            self.data[column] = np.clip(self.data[column], lower_bound, upper_bound)
-
-        print(f"\nWinsorization applied with {percentile * 100}% capping on each side.")
-        print(self.data[selected_columns].describe())
-
-        self._log_transformation(
-            "winsorization",
-            {"selected_columns": selected_columns, "percentile": percentile},
-        )
-        return self.data
-
-    percentile_capping = apply_winsorization
-'''

{classifier_toolkit-0.1.2 → classifier_toolkit-0.1.4}/classifier_toolkit/eda/first_glance.py

@@ -112,7 +112,7 @@ values in more detail, please call the see_duplicates method
         top_n : int, optional
             Number of top values to display, by default 10.
         """
-        for col in self.columns:
+        for col in self.categorical_columns:
             print(Fore.GREEN + f"\nColumn: {col}")
             value_counts = self.data[col].value_counts().head(top_n)
             for value, count in value_counts.items():

{classifier_toolkit-0.1.2 → classifier_toolkit-0.1.4}/classifier_toolkit/eda/univariate_analysis.py

@@ -31,13 +31,13 @@ class UnivariateAnalysis:
         self.numerical_features = numerical_features or []
 
     @staticmethod
-    def _get_cramers_v(data: pd.DataFrame, var1: str, var2: str) -> float:
+    def _get_cramers_v(df: pd.DataFrame, var1: str, var2: str) -> float:
         """
         Calculate Cramer's V statistic for two variables.
 
         Parameters
         ----------
-        data : pd.DataFrame
+        df : pd.DataFrame
             The data containing the variables.
         var1 : str
             The first variable.
@@ -49,15 +49,15 @@ class UnivariateAnalysis:
         float
             Cramer's V statistic.
         """
-        confusion_matrix = pd.crosstab(data[var1], data[var2])
+        confusion_matrix = pd.crosstab(df[var1], df[var2])
         chi2 = chi2_contingency(confusion_matrix)[0]
         n = confusion_matrix.sum().sum()
         min_dim = min(confusion_matrix.shape) - 1
 
         return np.sqrt(chi2 / (n * min_dim))
 
-    def _prepare_cramersV_features(
-        self, numerical_features: List[str], n_bins: int = 5
+    def _prepare_cramers_v_features(
+        self, numerical_features: List[str], num_bins: int = 5
     ) -> List[str]:
         """
         Prepare features for Cramer's V calculation by binning numerical features.
@@ -66,7 +66,7 @@ class UnivariateAnalysis:
         ----------
         numerical_features : List[str]
             List of numerical feature names.
-        n_bins : int, optional
+        num_bins : int, optional
             Number of bins for continuous variables, by default 5.
 
         Returns
@@ -74,13 +74,13 @@ class UnivariateAnalysis:
         List[str]
             List of features prepared for Cramer's V calculation.
         """
-        cramersV_var_list = self.data.select_dtypes(
+        cramers_v_var_list = self.data.select_dtypes(
             include=["object", "category"]
         ).columns.tolist()
 
         # Exclude the target column
-        cramersV_var_list = [
-            var for var in cramersV_var_list if var != self.target_column
+        cramers_v_var_list = [
+            var for var in cramers_v_var_list if var != self.target_column
         ]
 
         for num in numerical_features:
@@ -91,12 +91,12 @@ class UnivariateAnalysis:
             ):  # Ensure there are at least two unique values for binning
                 try:
                     self.data[f"{num}_bin"] = pd.qcut(
-                        self.data[num], q=n_bins, duplicates="drop"
+                        self.data[num], q=num_bins, duplicates="drop"
                     )
                     # Check if the resulting bins are more than 1
                     if self.data[f"{num}_bin"].nunique() <= 1:
                         raise ValueError(
-                            f"Only 1 bin created for {num} with q={n_bins}."
+                            f"Only 1 bin created for {num} with q={num_bins}."
                         )
 
                 except ValueError as e:
@@ -113,19 +113,19 @@ class UnivariateAnalysis:
                         self.data[f"{num}_bin"] = pd.qcut(
                             self.data[num], q=2, duplicates="drop"
                         )
-                cramersV_var_list.append(f"{num}_bin")
+                cramers_v_var_list.append(f"{num}_bin")
             else:
                 # Handle the case where there is only one unique value
                 print(f"Skipping {num} as it has only {unique_values} unique value(s).")
 
-        return cramersV_var_list
+        return cramers_v_var_list
 
     def plot_cramers_v(
         self,
         numerical_features: List[str],
-        excluded_vars: List[str],
+        excluded_columns: List[str],
         filter_threshold: float,
-        n_bins: int = 5,
+        num_bins: int = 5,
         fig_width: int = 800,
         fig_height: int = 800,
     ) -> Tuple[pd.DataFrame, List[str]]:
@@ -136,9 +136,9 @@ class UnivariateAnalysis:
         ----------
         numerical_features : List[str]
             List of numerical feature names.
-        excluded_vars : List[str]
+        excluded_columns : List[str]
             List of variables to exclude from the analysis.
-        n_bins : int, optional
+        num_bins : int, optional
             Number of bins for continuous variables, by default 5.
         fig_width : int, optional
             Width of the figure in pixels, by default 800.
@@ -150,22 +150,24 @@ class UnivariateAnalysis:
         pd.DataFrame
             DataFrame containing Cramer's V values.
         """
-        cramersV_var_list = self._prepare_cramersV_features(numerical_features, n_bins)
+        cramers_v_var_list = self._prepare_cramers_v_features(
+            numerical_features, num_bins
+        )
 
         # Exclude any specified variables
-        cramersV_var_list = [
-            var for var in cramersV_var_list if var not in excluded_vars
+        cramers_v_var_list = [
+            var for var in cramers_v_var_list if var not in excluded_columns
         ]
 
         rows = []
-        for cat in cramersV_var_list:
+        for cat in cramers_v_var_list:
             cramers = UnivariateAnalysis._get_cramers_v(
                 self.data, cat, self.target_column
             )
             rows.append(round(cramers, 2))
 
         cramers_results = pd.DataFrame(
-            rows, columns=[self.target_column], index=cramersV_var_list
+            rows, columns=[self.target_column], index=cramers_v_var_list
         )
 
         # Create a Plotly heatmap
@@ -194,18 +196,22 @@ class UnivariateAnalysis:
         return cramers_results, filtered_vars
 
     def _calculate_information_value(
-        self, feature_col: str, target_col: str, bins: int = 10, show_woe: bool = False
+        self,
+        feature_column: str,
+        target_column: str,
+        num_bins: int = 10,
+        show_woe: bool = False,
     ) -> Union[Tuple[float, pd.DataFrame], float]:
         """
         Calculate Information Value for a single feature.
 
         Parameters
         ----------
-        feature_col : str
+        feature_column : str
             Name of the feature column.
-        target_col : str
+        target_column : str
             Name of the target column.
-        bins : int, optional
+        num_bins : int, optional
             Number of bins for continuous variables, by default 10.
         show_woe : bool, optional
             Boolean to show WOE values, by default False.
@@ -217,21 +223,23 @@ class UnivariateAnalysis:
         """
         df = pd.DataFrame(
             {
-                feature_col: self.data[feature_col],
-                target_col: self.data[target_col].astype(float),
+                feature_column: self.data[feature_column],
+                target_column: self.data[target_column].astype(float),
             }
         )
 
-        if df[feature_col].dtype in ["int64", "float64"]:
-            df["bins"] = pd.qcut(df[feature_col], q=bins, duplicates="drop")
+        if df[feature_column].dtype in ["int64", "float64"]:
+            df["bins"] = pd.qcut(df[feature_column], q=num_bins, duplicates="drop")
         else:
-            df["bins"] = df[feature_col]
+            df["bins"] = df[feature_column]
 
-        total_good = df[target_col].sum()
-        total_bad = df[target_col].count() - total_good
+        total_good = df[target_column].sum()
+        total_bad = df[target_column].count() - total_good
 
         # Explicitly setting observed=False to retain current behavior
-        grouped = df.groupby("bins", observed=False)[target_col].agg(["sum", "count"])
+        grouped = df.groupby("bins", observed=False)[target_column].agg(
+            ["sum", "count"]
+        )
         grouped["good"] = grouped["sum"]
         grouped["bad"] = grouped["count"] - grouped["sum"]
 
@@ -255,7 +263,7 @@ class UnivariateAnalysis:
         numerical_features: List[str],
         filter_threshold: float,
         target_column: str,
-        bins: int = 10,
+        num_bins: int = 10,
         fig_width: int = 800,
         fig_height: int = 800,
     ) -> Tuple[pd.DataFrame, List[str]]:
@@ -268,7 +276,7 @@ class UnivariateAnalysis:
             List of numerical feature names.
         target_column : str
             Name of the target column.
-        bins : int, optional
+        num_bins : int, optional
             Number of bins for continuous variables, by default 10.
         fig_width : int, optional
             Width of the figure in pixels, by default 800.
@@ -282,7 +290,7 @@ class UnivariateAnalysis:
         """
         iv_values = []
         for feature in numerical_features:
-            iv = self._calculate_information_value(feature, target_column, bins)
+            iv = self._calculate_information_value(feature, target_column, num_bins)
             iv_values.append(iv)
 
         iv_df = pd.DataFrame(
@@ -412,7 +420,7 @@ class UnivariateAnalysis:
 
         fig.show()
 
-    def _make_partitions(self, number_of_partitions) -> pd.DataFrame:
+    def _make_partitions(self, num_partitions: int) -> pd.DataFrame:
         """
         Partition the numerical features into 4 bins.
 
@@ -425,21 +433,21 @@ class UnivariateAnalysis:
         for num in self.numerical_features:
             partitioned[num + "_bin"] = pd.qcut(
                 x=partitioned[num],
-                q=number_of_partitions,
+                q=num_partitions,
                 labels=False,
                 duplicates="drop",
             ).astype("category")
         return partitioned
 
     def get_num_feature_repartition(
-        self, time_col: str, number_of_partitions: int = 4, freq: str = "1ME"
+        self, time_column: str, num_partitions: int = 4, freq: str = "1ME"
     ) -> Optional[pd.DataFrame]:
         """
         Plot the risk class repartition through time and return a table of the risk class repartition through time.
 
         Parameters
         ----------
-        time_col : str
+        time_column : str
             Name of the column that contains the observation date.
         freq : str, optional
             The frequency at which the risk class is aggregated ('D', 'M', or 'Y'), by default '1ME'.
@@ -449,17 +457,17 @@ class UnivariateAnalysis:
         Optional[pd.DataFrame]
             DataFrame containing the risk class repartition through time.
         """
-        partitioned = self._make_partitions(number_of_partitions)
+        partitioned = self._make_partitions(num_partitions)
 
         # Drop rows where the time column is NaT
-        if partitioned[time_col].isnull().any():
+        if partitioned[time_column].isnull().any():
             print(
-                f"There are missing entries in the {time_col} column, dropping them for the functionality; however, try to mitigate the problem."
+                f"There are missing entries in the {time_column} column, dropping them for the functionality; however, try to mitigate the problem."
             )
-            partitioned = partitioned.dropna(subset=[time_col])
+            partitioned = partitioned.dropna(subset=[time_column])
 
         row_nb = math.ceil(len(self.numerical_features) / 2)
-        fig, ax = plt.subplots(row_nb, 2, figsize=(20, number_of_partitions * row_nb))
+        fig, ax = plt.subplots(row_nb, 2, figsize=(20, num_partitions * row_nb))
         i, j = 0, 0
 
         for num in self.numerical_features:
@@ -468,14 +476,15 @@ class UnivariateAnalysis:
             # Group by and count
             draw = (
                 partitioned.groupby(
-                    [num + "_bin", pd.Grouper(key=time_col, freq=freq)], observed=False
+                    [num + "_bin", pd.Grouper(key=time_column, freq=freq)],
+                    observed=False,
                 )[self.target_column]
                 .count()
                 .reset_index()
             )
 
             # Create 'freq' column with aligned indices
-            draw["freq"] = draw.groupby([time_col])[self.target_column].transform(
+            draw["freq"] = draw.groupby([time_column])[self.target_column].transform(
                 lambda x: x / x.sum()
             )
 
@@ -483,7 +492,7 @@ class UnivariateAnalysis:
             draw_pivot = pd.pivot_table(
                 draw,
                 values="freq",
-                index=time_col,
+                index=time_column,
                 columns=num + "_bin",
                 observed=False,
             )
@@ -501,8 +510,8 @@ class UnivariateAnalysis:
 
     def _prepare_data_for_psi(
         self,
-        number_of_partitions: int,
-        time_col: str,
+        num_partitions: int,
+        time_column: str,
         start_date: Union[str, datetime, date],
         end_date: Union[str, datetime, date],
     ):
@@ -511,14 +520,14 @@ class UnivariateAnalysis:
 
         Parameters
         ----------
-        time_col : str
+        time_column : str
             Name of the column that contains the observation date.
         start_date : Union[str, datetime, date]
             Start date for the PSI calculation.
         end_date : Union[str, datetime, date]
             End date for the PSI calculation.
         """
-        self.data = self._make_partitions(number_of_partitions)
+        self.data = self._make_partitions(num_partitions)
 
         # Convert string dates to datetime if necessary
         if isinstance(start_date, str):
@@ -526,21 +535,21 @@ class UnivariateAnalysis:
         if isinstance(end_date, str):
             end_date = pd.to_datetime(end_date)
 
-        # Ensure time_col is in datetime format
-        self.data[time_col] = pd.to_datetime(self.data[time_col])
+        # Ensure time_column is in datetime format
+        self.data[time_column] = pd.to_datetime(self.data[time_column])
 
-        _filter_date = (self.data[time_col] >= start_date) & (
-            self.data[time_col] < end_date
+        _filter_date = (self.data[time_column] >= start_date) & (
+            self.data[time_column] < end_date
         )
         self.data = self.data.loc[_filter_date]
         self.data.reset_index(drop=True, inplace=True)
 
     def _calculate_psi_single(
         self,
-        time_col: str,
+        time_column: str,
         time_expected: Union[str, datetime, date],
-        col: str,
-        buckets: int,
+        column: str,
+        num_buckets: int,
         bucket_type: Literal["quantile", "fixed_width"] = "quantile",
     ):
         """
@@ -548,13 +557,13 @@ class UnivariateAnalysis:
 
         Parameters
         ----------
-        time_col : str
+        time_column : str
             Name of the column that contains the observation date.
         time_expected : Union[str, datetime, date]
             The expected date for the PSI calculation.
-        col : str
+        column : str
             Name of the column to calculate the PSI.
-        buckets : int
+        num_buckets : int
             Number of buckets for binning.
         bucket_type : Literal["quantile", "fixed_width"]
             The type of binning to use.
@@ -567,11 +576,11 @@ class UnivariateAnalysis:
         if isinstance(time_expected, str):
             time_expected = pd.to_datetime(time_expected)
 
-        _filter_expected = self.data[time_col] < time_expected
-        expected = self.data.loc[_filter_expected, col]
-        observed = self.data.loc[~_filter_expected, col]
+        _filter_expected = self.data[time_column] < time_expected
+        expected = self.data.loc[_filter_expected, column]
+        observed = self.data.loc[~_filter_expected, column]
 
-        bins = self._create_bins(self.data[col], buckets, bucket_type)
+        bins = self._create_bins(self.data[column], num_buckets, bucket_type)
 
         expected_counts, _ = np.histogram(expected, bins=bins)
         observed_counts, _ = np.histogram(observed, bins=bins)
@@ -591,13 +600,13 @@ class UnivariateAnalysis:
     def _create_bins(
         self,
         series: pd.Series,
-        buckets: int,
+        num_buckets: int,
         bucket_type: Literal["quantile", "fixed_width"],
     ) -> np.ndarray:
         if bucket_type == "quantile":
-            return pd.qcut(series, q=buckets, duplicates="drop", retbins=True)[1]
+            return pd.qcut(series, q=num_buckets, duplicates="drop", retbins=True)[1]
         else:  # fixed_width
-            return pd.cut(series, bins=buckets, retbins=True)[1]
+            return pd.cut(series, bins=num_buckets, retbins=True)[1]
 
     def _create_buckets(self, series: pd.Series, bins: np.ndarray) -> pd.Series:
         return pd.cut(
@@ -633,25 +642,25 @@ class UnivariateAnalysis:
 
     def calculate_psi(
         self,
-        train: pd.DataFrame,
-        test: Optional[pd.DataFrame],
-        time_col: str,
+        train_df: pd.DataFrame,
+        test_df: Optional[pd.DataFrame],
+        time_column: str,
         time_expected: Union[str, datetime, date],
-        buckets: int = 10,
+        num_buckets: int = 10,
         bucket_type: Literal["quantile", "fixed_width"] = "quantile",
         epsilon: float = 1e-5,
     ) -> pd.DataFrame:
         psi_values = {}
         for feature in self.numerical_features:
-            if test is None:
-                expected = train[train[time_col] < time_expected][feature]
-                observed = train[train[time_col] >= time_expected][feature]
+            if test_df is None:
+                expected = train_df[train_df[time_column] < time_expected][feature]
+                observed = train_df[train_df[time_column] >= time_expected][feature]
             else:
-                expected = train[feature]
-                observed = test[feature]
+                expected = train_df[feature]
+                observed = test_df[feature]
 
             combined = pd.concat([expected, observed])
-            bins = self._create_bins(combined, buckets, bucket_type)
+            bins = self._create_bins(combined, num_buckets, bucket_type)
             psi = self._calculate_psi(expected, observed, bins, epsilon)
             psi_values[feature] = psi
 
@@ -698,12 +707,12 @@ class UnivariateAnalysis:
 
     def compute_psi(
         self,
-        time_col: str,
+        time_column: str,
         time_expected: Union[str, datetime, date],
         start_date: Union[str, datetime, date],
         end_date: Union[str, datetime, date],
         test_data: Optional[pd.DataFrame] = None,
-        buckets: int = 10,
+        num_buckets: int = 10,
         bucket_type: Literal["quantile", "fixed_width"] = "quantile",
         test_mode: bool = False,
     ) -> pd.DataFrame:
@@ -714,21 +723,27 @@ class UnivariateAnalysis:
         if isinstance(time_expected, str):
             time_expected = pd.to_datetime(time_expected)
 
-        self.data[time_col] = pd.to_datetime(self.data[time_col])
+        self.data[time_column] = pd.to_datetime(self.data[time_column])
         filtered_data = self.data[
-            (self.data[time_col] >= start_date) & (self.data[time_col] < end_date)
+            (self.data[time_column] >= start_date) & (self.data[time_column] < end_date)
         ]
 
         if test_data is not None:
-            test_data[time_col] = pd.to_datetime(test_data[time_col])
+            test_data[time_column] = pd.to_datetime(test_data[time_column])
             test_filtered = test_data[
-                (test_data[time_col] >= start_date) & (test_data[time_col] < end_date)
+                (test_data[time_column] >= start_date)
+                & (test_data[time_column] < end_date)
             ]
         else:
             test_filtered = None
 
         psi_df = self.calculate_psi(
-            filtered_data, test_filtered, time_col, time_expected, buckets, bucket_type
+            filtered_data,
+            test_filtered,
+            time_column,
+            time_expected,
+            num_buckets,
+            bucket_type,
         )
 
         fig = self.plot_psi(psi_df)
@@ -746,9 +761,9 @@ class UnivariateAnalysis:
 
     def _calculate_psi_all(
         self,
-        time_col: str,
+        time_column: str,
         time_expected: Union[str, datetime, date],
-        buckets: int,
+        num_buckets: int,
         bucket_type: Literal["quantile", "fixed_width"],
     ) -> pd.Series:
         """
@@ -756,11 +771,11 @@ class UnivariateAnalysis:
 
         Parameters
         ----------
-        time_col : str
+        time_column : str
             Name of the column that contains the observation date.
         time_expected : Union[str, datetime, date]
             The expected date for the PSI calculation.
-        buckets : int
+        num_buckets : int
             Number of buckets for binning.
         bucket_type : Literal["quantile", "fixed_width"]
             The type of binning to use.
@@ -773,6 +788,6 @@ class UnivariateAnalysis:
         dict_psi = {}
         for num in self.numerical_features:
             dict_psi[num] = self._calculate_psi_single(
-                time_col, time_expected, num, buckets, bucket_type
+                time_column, time_expected, num, num_buckets, bucket_type
             )
         return pd.Series(dict_psi)

{classifier_toolkit-0.1.2 → classifier_toolkit-0.1.4}/classifier_toolkit/eda/visualizations.py

@@ -21,7 +21,7 @@ class Visualizations:
 
     def __init__(
         self,
-        dataframe: pd.DataFrame,
+        df: pd.DataFrame,
         target_column: str,
         numerical_columns: List[str],
         categorical_columns: List[str],
@@ -31,7 +31,7 @@ class Visualizations:
 
         Parameters
         ----------
-        dataframe : pd.DataFrame
+        df : pd.DataFrame
             The data to be analyzed.
         target_column : str
             The target column for analysis.
@@ -40,7 +40,7 @@ class Visualizations:
         categorical_columns : List[str]
             List of categorical columns.
         """
-        self.data = dataframe
+        self.data = df
         self.target_column = target_column
         self.numerical_columns = numerical_columns
         self.categorical_columns = categorical_columns
@@ -292,7 +292,7 @@ class Visualizations:
 
     def visualize_high_cardinality(
         self,
-        excluded_vars: List[str],
+        excluded_columns: List[str],
         top_n: int = 10,
         id_column: Optional[str] = None,
     ) -> None:
@@ -301,7 +301,7 @@ class Visualizations:
 
         Parameters
         ----------
-        excluded_vars : List[str]
+        excluded_columns : List[str]
             List of columns to exclude.
         top_n : int, optional
             Number of top categories to display, by default 10.
@@ -311,10 +311,10 @@ class Visualizations:
         high_car, _ = self._check_cardinality()
 
         if id_column:
-            excluded_vars.append(id_column)
+            excluded_columns.append(id_column)
 
         # Exclude specified variables from the high cardinality list
-        high_car = [cat for cat in high_car if cat not in excluded_vars]
+        high_car = [cat for cat in high_car if cat not in excluded_columns]
 
         if not high_car:
             print("No high cardinality features found.")
@@ -543,7 +543,7 @@ class Visualizations:
         return vif_data
 
     def _bin_and_target_freq(
-        self, variable_name: str, n_bins: int = 10, scale: bool = False
+        self, variable_name: str, num_bins: int = 10, scale: bool = False
     ) -> pd.DataFrame:
         """
         Bin a numerical variable and calculate target frequency.
@@ -552,7 +552,7 @@ class Visualizations:
         ----------
         variable_name : str
             Name of the numerical variable.
-        n_bins : int, optional
+        num_bins : int, optional
             Number of bins to use, by default 10.
         scale : bool, optional
             Whether to scale the variable before binning, by default False.
@@ -562,15 +562,15 @@ class Visualizations:
         pd.DataFrame
             DataFrame with binned data and target frequency.
         """
-        data = self.data[[variable_name, self.target_column]].copy()
+        df = self.data[[variable_name, self.target_column]].copy()
 
         # Ensure target column is numeric (0 or 1)
-        data[self.target_column] = data[self.target_column].astype(int)
+        df[self.target_column] = df[self.target_column].astype(int)
 
         # Drop missing values and inform user
-        original_count = len(data)
-        data.dropna(subset=[variable_name], inplace=True)
-        dropped_count = original_count - len(data)
+        original_count = len(df)
+        df.dropna(subset=[variable_name], inplace=True)
+        dropped_count = original_count - len(df)
         if dropped_count > 0:
             print(
                 f"Dropped {dropped_count} rows with missing values for {variable_name}"
@@ -578,11 +578,11 @@ class Visualizations:
 
         if scale:
             # Scale the variable individually
-            min_val = data[variable_name].min()
-            max_val = data[variable_name].max()
-            if min_val != max_val:
-                data[variable_name] = (data[variable_name] - min_val) / (
-                    max_val - min_val
+            min_value = df[variable_name].min()
+            max_value = df[variable_name].max()
+            if min_value != max_value:
+                df[variable_name] = (df[variable_name] - min_value) / (
+                    max_value - min_value
                 )
             else:
                 print(
@@ -591,18 +591,18 @@ class Visualizations:
 
         # Use 'drop' option to handle duplicate bin edges
         try:
-            data["bin"] = pd.qcut(
-                data[variable_name], q=n_bins, labels=False, duplicates="drop"
+            df["bin"] = pd.qcut(
+                df[variable_name], q=num_bins, labels=False, duplicates="drop"
             )
         except ValueError as e:
             print(f"Warning: {e}")
             print(
-                f"Attempting to create {n_bins} bins for {variable_name}, but some may be merged due to duplicate values."
+                f"Attempting to create {num_bins} bins for {variable_name}, but some may be merged due to duplicate values."
             )
             # If qcut fails, fall back to cut with equal-width bins
-            data["bin"] = pd.cut(data[variable_name], bins=n_bins, labels=False)
+            df["bin"] = pd.cut(df[variable_name], bins=num_bins, labels=False)
 
-        grouped = data.groupby("bin").agg(
+        grouped = df.groupby("bin").agg(
             {variable_name: "mean", self.target_column: ["count", "sum"]}
         )
         grouped.columns = PandasIndex([variable_name, "total_count", "target_sum"])
@@ -610,7 +610,7 @@ class Visualizations:
         return grouped.reset_index()
 
     def plot_hexagon_target_vs_numerical(
-        self, var1: str, var2: str, n_bins: int = 20, scale: bool = False
+        self, var1: str, var2: str, num_bins: int = 20, scale: bool = False
     ) -> None:
         """
         Create a hexbin plot comparing two numerical variables and their relationship to the target variable.
@@ -621,7 +621,7 @@ class Visualizations:
             Name of the first numerical variable.
         var2 : str
             Name of the second numerical variable.
-        n_bins : int, optional
+        num_bins : int, optional
             Number of bins to use, by default 20.
         scale : bool, optional
             Whether to scale variables before binning, by default False.
@@ -644,7 +644,7 @@ class Visualizations:
             data[var1],
             data[var2],
             C=data[self.target_column],
-            gridsize=n_bins,
+            gridsize=num_bins,
             cmap="YlOrRd",
             reduce_C_function=np.mean,
         )
@@ -1203,46 +1203,3 @@ class Visualizations:
 
         if show_plot:
             fig.show()
-
-
-'''
-    def plot_categorical_value_counts(
-        self, plot_type: Literal["bar", "pie"] = "bar"
-    ) -> None:
-        """
-        Generate value counts for categorical features and visualize them.
-
-        Parameters
-        ----------
-        plot_type : {'bar', 'pie'}, optional
-            Type of plot to display, by default 'bar'.
-        """
-        value_counts = {
-            col: self.data[col].value_counts() for col in self.categorical_columns
-        }
-
-        for col in self.categorical_columns:
-            counts = value_counts[col].reset_index()
-            counts.columns = PandasIndex([col, "Frequency"])
-
-            if counts.empty:
-                print(f"No data to plot for column: {col}")
-                continue
-
-            if plot_type == "bar":
-                fig = px.bar(
-                    counts, x=col, y="Frequency", title=f"Distribution of {col}"
-                )
-            elif plot_type == "pie":
-                fig = px.pie(
-                    counts,
-                    names=col,
-                    values="Frequency",
-                    title=f"Distribution of {col}",
-                )
-            else:
-                raise ValueError("plot_type should be either 'bar' or 'pie'")
-
-            fig.update_layout(title={"x": 0.5})
-            fig.show()
-'''

{classifier_toolkit-0.1.2 → classifier_toolkit-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "classifier-toolkit"
-version = "0.1.2"
+version = "0.1.4"
 description = ""
 authors = [
     "gauthier.marquand <gauthier.marquand@qonto.com>",