segmentae 1.5.20__py3-none-any.whl

segmentae/processing/preprocessing.py

@@ -0,0 +1,263 @@
+import warnings
+from typing import Any, List, Optional, Union
+
+import pandas as pd
+from pydantic import BaseModel, ConfigDict, field_validator
+
+from segmentae.core.constants import EncoderType, ImputerType, ScalerType
+from segmentae.core.exceptions import ModelNotFittedError, ValidationError
+from segmentae.processing.simplifier import ComponentFactory
+
+warnings.filterwarnings("ignore", category=Warning)
+
+class PreprocessingConfig(BaseModel):
+    """
+    Configuration for preprocessing pipeline.
+    """
+
+    encoder: Optional[Union[EncoderType, str]] = None           # Default: No encoding || Options: "IFrequencyEncoder", "LabelEncoder", "OneHotEncoder"
+    scaler: Optional[Union[ScalerType, str]] = "MinMaxScaler"   # Default: MinMaxScaler || Options: "MinMaxScaler", "StandardScaler", "RobustScaler"
+    imputer: Optional[Union[ImputerType, str]] = "Simple"       # Default: Simple Imputer || Options: "Simple"
+    
+    @field_validator('encoder', mode='before')
+    def convert_encoder_to_enum(cls, v):
+        """Convert string encoder to enum."""
+        if v is None or isinstance(v, EncoderType):
+            return v
+        try:
+            return EncoderType(v)
+        except ValueError:
+            valid_options = [e.value for e in EncoderType]
+            raise ValueError(
+                f"Invalid encoder type: '{v}'. "
+                f"Valid options: {valid_options}"
+            )
+    
+    @field_validator('scaler', mode='before')
+    def convert_scaler_to_enum(cls, v):
+        """Convert string scaler to enum."""
+        if v is None or isinstance(v, ScalerType):
+            return v
+        try:
+            return ScalerType(v)
+        except ValueError:
+            valid_options = [s.value for s in ScalerType]
+            raise ValueError(
+                f"Invalid scaler type: '{v}'. "
+                f"Valid options: {valid_options}"
+            )
+    
+    @field_validator('imputer', mode='before')
+    def convert_imputer_to_enum(cls, v):
+        """Convert string imputer to enum."""
+        if v is None or isinstance(v, ImputerType):
+            return v
+        try:
+            return ImputerType(v)
+        except ValueError:
+            valid_options = [i.value for i in ImputerType]
+            raise ValueError(
+                f"Invalid imputer type: '{v}'. "
+                f"Valid options: {valid_options}"
+            )
+    
+    model_config = ConfigDict(use_enum_values=False)
+
+class Preprocessing:
+    """
+    Main preprocessing class for data transformation.
+    
+    This class orchestrates the preprocessing pipeline including categorical encoding, numerical scaling, and missing value imputation.
+    It follows the scikit-learn fit/transform pattern.
+    """
+    
+    def __init__(self,
+                 encoder: Optional[Union[EncoderType, str]] = None,
+                 scaler: Optional[Union[ScalerType, str]] = "MinMaxScaler",
+                 imputer: Optional[Union[ImputerType, str]] = "Simple"):
+        """
+        Initialize preprocessing pipeline.
+        """
+        # Validate and store configuration
+        self.config = PreprocessingConfig(
+            encoder=encoder,
+            scaler=scaler,
+            imputer=imputer
+        )
+        
+        # Internal component storage
+        self._encoder: Optional[Any] = None
+        self._scaler: Optional[Any] = None
+        self._imputer: Optional[Any] = None
+        
+        # State tracking
+        self._X: Optional[pd.DataFrame] = None
+        self._cat_cols: List[str] = []
+        self._num_cols: List[str] = []
+        self._is_fitted: bool = False
+    
+    def fit(self, X: pd.DataFrame) -> 'Preprocessing':
+        """
+        Fit preprocessing components to data.
+        """
+        self._validate_input(X, "Input for fitting")
+        
+        # Setup components in order
+        self._setup_encoder(X)
+        self._setup_scaler()
+        self._setup_imputer()
+        
+        self._is_fitted = True
+        return self
+    
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """
+        Transform data using fitted preprocessing components.
+        """
+        self._validate_fitted()
+        self._validate_input(X, "Input for transformation")
+        
+        return self._apply_transformations(X)
+    
+    def fit_transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """
+        Fit and transform data in one step.
+        """
+        return self.fit(X).transform(X)
+    
+    def _setup_encoder(self, X: pd.DataFrame) -> None:
+        """
+        Setup encoder based on categorical columns.
+        """
+        self._cat_cols = X.select_dtypes(include=['object', 'category']).columns.tolist()
+        
+        if self.config.encoder is not None and self._cat_cols:
+            self._encoder = ComponentFactory.create_encoder(self.config.encoder)
+            self._encoder.fit(X[self._cat_cols])
+            self._X = self._encoder.transform(X).copy()
+        else:
+            self._X = X.copy()
+    
+    def _setup_scaler(self) -> None:
+        """
+        Setup scaler based on numerical columns.
+        """
+        self._num_cols = self._X.select_dtypes(include=['int', 'float']).columns.tolist()
+        
+        if self.config.scaler is not None and self._num_cols:
+            self._scaler = ComponentFactory.create_scaler(self.config.scaler)
+            self._scaler.fit(self._X[self._num_cols])
+    
+    def _setup_imputer(self) -> None:
+        """
+        Setup imputer if missing values exist.
+        """
+        if self.config.imputer is None or self._X.isnull().sum().sum() == 0:
+            return
+        
+        self._imputer = ComponentFactory.create_imputer(self.config.imputer)
+        
+        # Prepare data for imputer
+        X_for_imputer = self._X.copy()
+        
+        # Scale numerical columns before imputation
+        if self._scaler is not None and self._num_cols:
+            X_for_imputer[self._num_cols] = self._scaler.transform(
+                X_for_imputer[self._num_cols].copy()
+            )
+        
+        # Fit imputer
+        self._imputer.fit(X=X_for_imputer)
+    
+    def _apply_transformations(self, X: pd.DataFrame) -> pd.DataFrame:
+        """
+        Apply all fitted transformations in correct order.
+        """
+        X_ = X.copy()
+        
+        # Apply encoder
+        if self._encoder is not None:
+            X_ = self._encoder.transform(X_)
+        
+        # Apply scaler
+        if self._scaler is not None and self._num_cols:
+            X_[self._num_cols] = self._scaler.transform(X_[self._num_cols].copy())
+        
+        # Apply imputer
+        if self._imputer is not None:
+            X_[self._num_cols] = self._imputer.transform(X=X_[self._num_cols].copy())
+        
+        return X_
+
+    def _validate_input(self, X: pd.DataFrame, context: str = "Input") -> None:
+        """
+        Validate input DataFrame.
+        """
+        if not isinstance(X, pd.DataFrame):
+            raise ValidationError(
+                f"{context} must be a pandas DataFrame, got {type(X).__name__}",
+                suggestion="Convert your data to DataFrame using pd.DataFrame()"
+            )
+        
+        if X.empty:
+            raise ValidationError(
+                f"{context} DataFrame is empty",
+                suggestion="Ensure your dataset contains data"
+            )
+    
+    def _validate_fitted(self) -> None:
+        """
+        Check if preprocessing is fitted.
+        """
+        if not self._is_fitted:
+            raise ModelNotFittedError(
+                component="Preprocessing",
+                message="Preprocessing must be fitted before transform. "
+                        "Call fit(X) method first."
+            )
+
+    @property
+    def encoder(self) -> Optional[Any]:
+        """Get fitted encoder component."""
+        return self._encoder
+    
+    @property
+    def scaler(self) -> Optional[Any]:
+        """Get fitted scaler component."""
+        return self._scaler
+    
+    @property
+    def imputer(self) -> Optional[Any]:
+        """Get fitted imputer component."""
+        return self._imputer
+    
+    @property
+    def cat_cols(self) -> List[str]:
+        """Get list of categorical columns."""
+        return self._cat_cols
+    
+    @property
+    def num_cols(self) -> List[str]:
+        """Get list of numerical columns."""
+        return self._num_cols
+    
+    def __repr__(self) -> str:
+        """String representation of Preprocessing."""
+        return (
+            f"Preprocessing("
+            f"encoder={self.config.encoder.value if self.config.encoder else None}, "
+            f"scaler={self.config.scaler.value if self.config.scaler else None}, "
+            f"imputer={self.config.imputer.value if self.config.imputer else None})"
+        )
+    
+
+
+
+
+
+
+
+
+
+
+

segmentae/processing/simplifier.py

@@ -0,0 +1,74 @@
+from typing import Any, Optional, Union
+
+from atlantic.imputers.imputation import (
+    AutoSimpleImputer,  # || #AutoKNNImputer, AutoIterativeImputer
+)
+from atlantic.processing.encoders import AutoIFrequencyEncoder, AutoLabelEncoder, AutoOneHotEncoder
+from atlantic.processing.scalers import AutoMinMaxScaler, AutoRobustScaler, AutoStandardScaler
+from segmentae.core.constants import EncoderType, ImputerType, ScalerType
+from segmentae.core.exceptions import ConfigurationError
+
+
+class ComponentFactory:
+    """Factory class for creating preprocessing components."""
+    
+    @staticmethod
+    def create_imputer(imputer_type: Optional[Union[ImputerType, str]]) -> Optional[Any]:
+        """Create an imputer instance based on type."""
+        if imputer_type is None:
+            return None
+        
+        if isinstance(imputer_type, str):
+            imputer_type = ImputerType(imputer_type)
+        
+        if imputer_type == ImputerType.SIMPLE:
+            return AutoSimpleImputer(strategy="mean")
+        
+        raise ConfigurationError(
+            f"Unknown imputer type: {imputer_type}",
+            valid_options=list(ImputerType)
+        )
+    
+    @staticmethod
+    def create_encoder(encoder_type: Optional[Union[EncoderType, str]]) -> Optional[Any]:
+        """Create an encoder instance based on type."""
+        if encoder_type is None:
+            return None
+        
+        if isinstance(encoder_type, str):
+            encoder_type = EncoderType(encoder_type)
+        
+        match encoder_type:
+            case EncoderType.IFREQUENCY:
+                return AutoIFrequencyEncoder()
+            case EncoderType.LABEL:
+                return AutoLabelEncoder()
+            case EncoderType.ONEHOT:
+                return AutoOneHotEncoder()
+            case _:
+                raise ConfigurationError(
+                    f"Unknown encoder type: {encoder_type}",
+                    valid_options=list(EncoderType)
+                )
+    
+    @staticmethod
+    def create_scaler(scaler_type: Optional[Union[ScalerType, str]]) -> Optional[Any]:
+        """Create a scaler instance based on type."""
+        if scaler_type is None:
+            return None
+        
+        if isinstance(scaler_type, str):
+            scaler_type = ScalerType(scaler_type)
+        
+        match scaler_type:
+            case ScalerType.MINMAX:
+                return AutoMinMaxScaler()
+            case ScalerType.STANDARD:
+                return AutoStandardScaler()
+            case ScalerType.ROBUST:
+                return AutoRobustScaler()
+            case _:
+                raise ConfigurationError(
+                    f"Unknown scaler type: {scaler_type}",
+                    valid_options=list(ScalerType)
+                )

segmentae/utils/__init__.py

@@ -0,0 +1,17 @@
+from segmentae.utils.validation import (
+    validate_dataframe,
+    validate_fitted,
+    validate_lengths_match,
+    validate_positive_integer,
+    validate_series,
+    validate_threshold_ratio,
+)
+
+__all__ = [
+    'validate_dataframe',
+    'validate_series',
+    'validate_fitted',
+    'validate_threshold_ratio',
+    'validate_lengths_match',
+    'validate_positive_integer'
+]

segmentae/utils/validation.py

@@ -0,0 +1,94 @@
+from typing import Any
+
+import pandas as pd
+
+from segmentae.core.exceptions import ModelNotFittedError, ValidationError
+
+
+def validate_dataframe(df: Any, name: str = "DataFrame") -> None:
+    """
+    Validate that input is a non-empty DataFrame.
+    """
+    if not isinstance(df, pd.DataFrame):
+        raise ValidationError(
+            f"{name} must be a pandas DataFrame, got {type(df).__name__}",
+            suggestion="Convert to DataFrame using pd.DataFrame()"
+        )
+    
+    if df.empty:
+        raise ValidationError(
+            f"{name} cannot be empty",
+            suggestion="Ensure your dataset contains data"
+        )
+
+
+def validate_series(series: Any, name: str = "Series") -> None:
+    """
+    Validate that input is a non-empty Series.
+    """
+    if not isinstance(series, pd.Series):
+        raise ValidationError(
+            f"{name} must be a pandas Series, got {type(series).__name__}",
+            suggestion="Convert to Series using pd.Series() or extract DataFrame column"
+        )
+    
+    if len(series) == 0:
+        raise ValidationError(
+            f"{name} cannot be empty",
+            suggestion="Ensure your data contains values"
+        )
+
+
+def validate_fitted(is_fitted: bool, component: str = "Model") -> None:
+    """
+    Check if component is fitted.
+    """
+    if not is_fitted:
+        raise ModelNotFittedError(
+            component=component,
+            message=f"{component} must be fitted before use. Call fit() method first."
+        )
+
+
+def validate_threshold_ratio(ratio: float) -> None:
+    """
+    Validate threshold ratio is positive.
+    """
+    if ratio <= 0:
+        raise ValidationError(
+            f"threshold_ratio must be positive, got {ratio}",
+            suggestion="Use a positive value like 1.0, 2.0, etc."
+        )
+
+
+def validate_lengths_match(
+    a: Any,
+    b: Any,
+    name_a: str = "First array",
+    name_b: str = "Second array"
+) -> None:
+    """
+    Validate two objects have matching lengths.
+    """
+    if len(a) != len(b):
+        raise ValidationError(
+            f"{name_a} and {name_b} must have same length. "
+            f"Got {len(a)} and {len(b)}",
+            suggestion="Ensure both arrays/dataframes have the same number of samples"
+        )
+
+
+def validate_positive_integer(value: int, name: str = "Value") -> None:
+    """
+    Validate that a value is a positive integer.
+    """
+    if not isinstance(value, int):
+        raise ValidationError(
+            f"{name} must be an integer, got {type(value).__name__}"
+        )
+    
+    if value < 1:
+        raise ValidationError(
+            f"{name} must be positive, got {value}",
+            suggestion="Use a value >= 1"
+        )