classifier-toolkit 0.1.0__py3-none-any.whl

classifier_toolkit/eda/warnings/__init__.py

@@ -0,0 +1,4 @@
+from .automated_warnings import WarningSystem
+from .default_warnings import EDAWarning, get_default_warnings
+
+__all__ = ["WarningSystem", "EDAWarning", "get_default_warnings"]

classifier_toolkit/eda/warnings/automated_warnings.py

@@ -0,0 +1,20 @@
+from typing import Dict, List
+
+from .default_warnings import EDAWarning
+
+
+class WarningSystem:
+    def __init__(self, warnings: Dict[str, EDAWarning]):
+        self.warnings = warnings
+
+    def register_warning(self, name: str, warning_obj: EDAWarning):
+        """Register a new warning object."""
+        self.warnings[name] = warning_obj
+        print(f"Registered warning '{name}'")
+
+    def run_warnings(self) -> Dict[str, List[Dict[str, str]]]:
+        """Run all registered warning objects and return the results."""
+        results = {}
+        for name, warning_obj in self.warnings.items():
+            results[name] = warning_obj.run()
+        return results

classifier_toolkit/eda/warnings/default_warnings.py

@@ -0,0 +1,286 @@
+from typing import Dict, List, Optional, Protocol
+
+import numpy as np
+import pandas as pd
+from scipy import stats
+
+
+class EDAWarning(Protocol):
+    df: pd.DataFrame
+
+    def run(self) -> List[Dict[str, str]]: ...
+
+
+class NegativeValuesWarning:
+    def __init__(
+        self,
+        df: pd.DataFrame,
+        numerical_columns: Optional[List[str]] = None,
+        can_be_negative: Optional[List[str]] = None,
+    ):
+        self.df = df
+        self.numerical_columns = numerical_columns
+        self.can_be_negative = can_be_negative
+
+    def run(self) -> List[Dict[str, str]]:
+        warnings = []
+        if self.numerical_columns:
+            for col in self.numerical_columns:
+                if (
+                    self.can_be_negative is None or col not in self.can_be_negative
+                ) and (self.df[col] < 0).any():
+                    neg_count = (self.df[col] < 0).sum()
+                    warnings.append(
+                        {
+                            "warning_type": "Negative",
+                            "message": f"Negative values found in column '{col}' ({neg_count} negative values)",
+                        }
+                    )
+        return warnings
+
+
+class OutliersWarning:
+    def __init__(
+        self, df: pd.DataFrame, numerical_columns: List[str], distance: float = 1.5
+    ):
+        self.df = df
+        self.numerical_columns = numerical_columns
+        self.distance = distance
+
+    def run(self) -> List[Dict[str, str]]:
+        warnings = []
+        for col in self.numerical_columns:
+            Q1 = self.df[col].quantile(0.25)
+            Q3 = self.df[col].quantile(0.75)
+            IQR = Q3 - Q1
+            lower_bound = Q1 - self.distance * IQR
+            upper_bound = Q3 + self.distance * IQR
+            outliers = self.df[
+                (self.df[col] < lower_bound) | (self.df[col] > upper_bound)
+            ]
+            if not outliers.empty:
+                warnings.append(
+                    {
+                        "warning_type": "Outlier",
+                        "message": f"Outliers detected in column '{col}' ({len(outliers)} outliers)",
+                    }
+                )
+        return warnings
+
+
+class MissingValuesWarning:
+    def __init__(self, df: pd.DataFrame):
+        self.df = df
+
+    def run(self) -> List[Dict[str, str]]:
+        missing = self.df.isnull().sum()
+        if missing.sum() > 0:
+            return [
+                {
+                    "warning_type": "data_quality",
+                    "message": f"Missing values detected in columns: {missing[missing > 0].index.tolist()}",
+                }
+            ]
+        return []
+
+
+class CardinalityWarning:
+    def __init__(
+        self,
+        df: pd.DataFrame,
+        numerical_columns: List[str],
+        exclusion: List[str],
+        low_threshold: int = 10,
+    ):
+        self.df = df
+        self.numerical_columns = numerical_columns
+        self.exclusion = exclusion
+        self.low_threshold = low_threshold
+
+    def run(self) -> List[Dict[str, str]]:
+        warnings = []
+        for col in self.df.columns:
+            if col not in self.numerical_columns and col not in self.exclusion:
+                value_counts = len(self.df[col].value_counts())
+                if value_counts == 1:
+                    warnings.append(
+                        {
+                            "warning_type": "Cardinality",
+                            "message": f"Column '{col}' has only one unique value",
+                        }
+                    )
+                elif value_counts <= self.low_threshold:
+                    warnings.append(
+                        {
+                            "warning_type": "Cardinality",
+                            "message": f"Low cardinality in column '{col}' ({value_counts} unique values)",
+                        }
+                    )
+                else:
+                    warnings.append(
+                        {
+                            "warning_type": "Cardinality",
+                            "message": f"High cardinality in column '{col}' ({value_counts} unique values)",
+                        }
+                    )
+        return warnings
+
+
+class DuplicatesWarning:
+    def __init__(self, df: pd.DataFrame, id_column: Optional[str] = None):
+        self.df = df
+        self.id_column = id_column
+
+    def run(self) -> List[Dict[str, str]]:
+        warnings = []
+        if self.id_column:
+            duplicates = self.df[
+                self.df.duplicated(subset=[self.id_column], keep=False)
+            ]
+            if not duplicates.empty:
+                warnings.append(
+                    {
+                        "warning_type": "Duplicate",
+                        "message": f"{len(duplicates)} duplicate entries found based on '{self.id_column}'",
+                    }
+                )
+        else:
+            duplicates = self.df[self.df.duplicated(keep=False)]
+            if not duplicates.empty:
+                warnings.append(
+                    {
+                        "warning_type": "Duplicate",
+                        "message": f"{len(duplicates)} duplicate rows found",
+                    }
+                )
+        return warnings
+
+
+class NormalityWarning:
+    def __init__(
+        self,
+        df: pd.DataFrame,
+        numerical_columns: List[str],
+        significance_level: float = 0.05,
+    ):
+        self.df = df
+        self.numerical_columns = numerical_columns
+        self.significance_level = significance_level
+
+    def run(self) -> List[Dict[str, str]]:
+        warnings = []
+        for col in self.numerical_columns:
+            _, p_value = stats.normaltest(self.df[col].dropna())
+            if p_value < self.significance_level:
+                warnings.append(
+                    {
+                        "warning_type": "Normality",
+                        "message": f"Column '{col}' may not be normally distributed (p-value: {p_value:.4f})",
+                    }
+                )
+        return warnings
+
+
+class ImbalanceWarning:
+    def __init__(self, df: pd.DataFrame, target_column: str, threshold: float = 0.75):
+        self.df = df
+        self.target_column = target_column
+        self.threshold = threshold
+
+    def run(self) -> List[Dict[str, str]]:
+        warnings = []
+        if self.target_column in self.df.columns:
+            value_counts = self.df[self.target_column].value_counts(normalize=True)
+            if (value_counts > self.threshold).any():  # type: ignore
+                majority_class = value_counts.index[0]
+                majority_percentage = value_counts.iloc[0] * 100
+                warnings.append(
+                    {
+                        "warning_type": "Imbalance",
+                        "message": f"Target variable '{self.target_column}' is imbalanced. "
+                        f"Majority class '{majority_class}' represents {majority_percentage:.2f}% of the data",
+                    }
+                )
+        return warnings
+
+
+class CorrelationsWarning:
+    def __init__(
+        self, df: pd.DataFrame, numerical_columns: List[str], threshold: float = 0.8
+    ):
+        self.df = df
+        self.numerical_columns = numerical_columns
+        self.threshold = threshold
+
+    def run(self) -> List[Dict[str, str]]:
+        warnings = []
+        if len(self.numerical_columns) > 1:
+            corr_matrix = self.df[self.numerical_columns].corr()
+            high_corr = np.where(np.abs(corr_matrix) > self.threshold)
+            high_corr_pairs = [
+                (corr_matrix.index[x], corr_matrix.columns[y])
+                for x, y in zip(*high_corr)
+                if x != y and x < y
+            ]
+            for pair in high_corr_pairs:
+                warnings.append(
+                    {
+                        "warning_type": "Correlation",
+                        "message": f"High correlation ({corr_matrix.loc[pair[0], pair[1]]:.2f}) "
+                        f"between '{pair[0]}' and '{pair[1]}'",
+                    }
+                )
+        return warnings
+
+
+def get_default_warnings(
+    df: pd.DataFrame,
+    target_column: str,
+    can_be_negative: List[str],
+    numerical_columns: List[str],
+    cardinality_exclusion: List[str],
+    correlation_threshold: float = 0.8,
+    outlier_distance: float = 1.5,
+    imbalance_threshold: float = 0.75,
+    normality_significance_level: float = 0.05,
+    cardinality_low_threshold: int = 10,
+    id_column: Optional[str] = None,
+) -> Dict[str, EDAWarning]:
+    return {
+        "negative_values": NegativeValuesWarning(
+            df,
+            numerical_columns=numerical_columns,
+            can_be_negative=can_be_negative,
+        ),
+        "outliers": OutliersWarning(
+            df,
+            numerical_columns=numerical_columns,
+            distance=outlier_distance,
+        ),
+        "missing_values": MissingValuesWarning(df),
+        "cardinality": CardinalityWarning(
+            df,
+            numerical_columns=numerical_columns,
+            exclusion=cardinality_exclusion,
+            low_threshold=cardinality_low_threshold,
+        ),
+        "duplicates": DuplicatesWarning(
+            df,
+            id_column=id_column,
+        ),
+        "normality": NormalityWarning(
+            df,
+            numerical_columns=numerical_columns,
+            significance_level=normality_significance_level,
+        ),
+        "imbalance": ImbalanceWarning(
+            df,
+            target_column=target_column,
+            threshold=imbalance_threshold,
+        ),
+        "correlations": CorrelationsWarning(
+            df,
+            numerical_columns=numerical_columns,
+            threshold=correlation_threshold,
+        ),
+    }

classifier_toolkit/feature_selection/__init__.py

@@ -0,0 +1,33 @@
+from classifier_toolkit.feature_selection.base import BaseFeatureSelector
+from classifier_toolkit.feature_selection.embedded_methods.elastic_net import (
+    ElasticNetSelector,
+)
+from classifier_toolkit.feature_selection.meta_selector import MetaSelector
+from classifier_toolkit.feature_selection.utils.plottings import (
+    plot_feature_importances,
+    plot_rfecv_results,
+)
+from classifier_toolkit.feature_selection.utils.scoring import (
+    false_positive_rate,
+    get_scorer,
+    true_positive_rate,
+)
+from classifier_toolkit.feature_selection.wrapper_methods.rfe import (
+    EnsembleFeatureSelector,
+)
+from classifier_toolkit.feature_selection.wrapper_methods.sequential_selection import (
+    SequentialSelector,
+)
+
+__all__ = [
+    "BaseFeatureSelector",
+    "MetaSelector",
+    "ElasticNetSelector",
+    "plot_feature_importances",
+    "plot_rfecv_results",
+    "get_scorer",
+    "false_positive_rate",
+    "true_positive_rate",
+    "EnsembleFeatureSelector",
+    "SequentialSelector",
+]

classifier_toolkit/feature_selection/base.py

@@ -0,0 +1,182 @@
+from abc import ABC, abstractmethod
+from typing import List, Literal, Optional, Union
+
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.feature_selection import RFECV
+from sklearn.model_selection import BaseCrossValidator, cross_val_score
+from sklearn.utils import check_X_y
+
+
+class BaseFeatureSelector(BaseEstimator, TransformerMixin, ABC):
+    @abstractmethod
+    def __init__(
+        self,
+        estimator: Optional[BaseEstimator],
+        n_features_to_select: int = 1,
+        scoring: Literal[
+            "accuracy", "f1", "precision", "recall", "roc_auc"
+        ] = "accuracy",
+        cv: Union[int, BaseCrossValidator] = 5,
+        verbose: int = 0,
+    ) -> None:
+        self.estimator: Optional[BaseEstimator] = estimator
+        self.n_features_to_select = n_features_to_select
+        self.scoring = scoring
+        from .utils.scoring import get_scorer
+
+        self.scorer = get_scorer(scoring)
+        self.cv = cv
+        self.verbose = verbose
+        self.selected_features_: Optional[List[str]] = None
+        self.feature_importances_: Optional[pd.Series] = None
+        self.rfecv: Optional[RFECV] = None
+        self.rfecv_step: int = 1
+
+    @abstractmethod
+    def fit(self, X: pd.DataFrame, y: pd.Series) -> "BaseFeatureSelector":
+        """
+        Fit the feature selector to the data.
+        """
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """
+        Transform the data to include only selected features.
+        """
+        if self.selected_features_ is None:
+            raise FeatureSelectionError(
+                "Selector has not been fitted yet. Call 'fit' first."
+            )
+        if isinstance(self.selected_features_[0], str):
+            return X[self.selected_features_]
+        else:
+            return X.loc[:, self.selected_features_]
+
+    def fit_transform(self, X: pd.DataFrame, y: pd.Series) -> pd.DataFrame:
+        """
+        Fit the selector and transform the data.
+        """
+        return self.fit(X, y).transform(X)
+
+    @abstractmethod
+    def _get_score(self, X: pd.DataFrame, y: pd.Series, features: List[int]) -> float:
+        """
+        Evaluate the score for a subset of features.
+
+        Args:
+            X (pd.DataFrame): The input features.
+            y (pd.Series): The target variable.
+            features (List[int]): The indices of features to evaluate.
+
+        Returns:
+            float: The score for the given features.
+        """
+
+    @abstractmethod
+    def get_feature_importances(self) -> pd.Series:
+        """
+        Get the importance scores for each feature.
+        """
+
+    def get_support(self, indices: bool = False) -> Union[List[bool], List[int]]:
+        """
+        Get a mask, or integer index, of the features selected.
+        """
+        if self.selected_features_ is None:
+            raise FeatureSelectionError(
+                "Selector has not been fitted yet. Call 'fit' first."
+            )
+        assert self.feature_importances_ is not None, ValueError(
+            'Feature importances are not available. Call "fit" first.'
+        )
+        mask = [
+            feature in self.selected_features_
+            for feature in self.feature_importances_.index
+        ]
+        if indices:
+            return [i for i, m in enumerate(mask) if m]
+        return mask
+
+    def _evaluate_features(
+        self, X: Union[pd.DataFrame, np.ndarray], y: pd.Series
+    ) -> pd.Series:
+        """
+        Evaluate the features using cross-validation.
+
+        Args:
+            X (Union[pd.DataFrame, np.ndarray]): The input features.
+            y (pd.Series): The target variable.
+
+        Returns:
+            pd.Series: A series containing the mean cross-validation score for each feature.
+        """
+        if self.estimator is None:
+            raise ValueError("Estimator is not set. Please provide an estimator.")
+
+        X, y = check_X_y(X, y, ensure_min_features=0, force_all_finite=False)
+
+        if isinstance(X, np.ndarray):
+            X = pd.DataFrame(X, columns=[f"feature_{i}" for i in range(X.shape[1])])
+
+        scores = []
+        feature_names = X.columns
+
+        for feature in feature_names:
+            X_feature = X[[feature]]
+            try:
+                feature_scores = cross_val_score(
+                    self.estimator,
+                    X_feature,
+                    y,
+                    scoring=self.scorer,
+                    cv=self.cv,
+                    n_jobs=-1,
+                    error_score="raise",
+                )
+                mean_score = np.mean(feature_scores)
+            except Exception as e:
+                if self.verbose > 0:
+                    print(f"Error evaluating feature {feature}: {e!s}")
+                mean_score = np.nan
+
+            scores.append(mean_score)
+
+        return pd.Series(scores, index=feature_names, name="Feature Scores")
+
+    def fit_rfecv(
+        self, X: pd.DataFrame, y: pd.Series, **rfecv_params
+    ) -> "BaseFeatureSelector":
+        """
+        Fit the selector using RFECV.
+
+        Args:
+            X (pd.DataFrame): The input features.
+            y (pd.Series): The target variable.
+            **rfecv_params: Additional parameters to  to RFECV.
+
+        Returns:
+            self: The fitted selector.
+        """
+        if self.estimator is None:
+            raise ValueError("Estimator is not set. Please provide an estimator.")
+
+        self.rfecv = RFECV(
+            estimator=self.estimator,
+            step=self.rfecv_step,
+            cv=self.cv,
+            scoring=self.scoring,
+            n_jobs=-1,
+            verbose=self.verbose,
+            **rfecv_params,
+        )
+
+        self.rfecv.fit(X, y)
+        self.selected_features_ = X.columns[self.rfecv.support_].tolist()
+        self.feature_importances_ = pd.Series(self.rfecv.ranking_, index=X.columns)
+
+        return self
+
+
+class FeatureSelectionError(Exception):
+    """Base exception for feature selection errors."""

classifier_toolkit/feature_selection/embedded_methods/__init__.py

@@ -0,0 +1,7 @@
+from classifier_toolkit.feature_selection.embedded_methods.elastic_net import (
+    ElasticNetSelector,
+)
+
+__all__ = [
+    "ElasticNetSelector",
+]