scikit-extensions 0.2.0__tar.gz → 0.2.2__tar.gz

{scikit_extensions-0.2.0 → scikit_extensions-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-extensions
-Version: 0.2.0
+Version: 0.2.2
 Summary: A collection of Scikit-learn-compatible transformers for feature engineering, preprocessing, and pipeline utilities.
 Keywords: scikit-learn,transformers,preprocessing,pipeline
 Author: sh99

{scikit_extensions-0.2.0 → scikit_extensions-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scikit-extensions"
-version = "0.2.0"
+version = "0.2.2"
 description = "A collection of Scikit-learn-compatible transformers for feature engineering, preprocessing, and pipeline utilities."
 readme = "README.md"
 license = "MIT"

{scikit_extensions-0.2.0 → scikit_extensions-0.2.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "scikit-extensions"
-version = "0.2.0"
+version = "0.2.2"
 description = "A collection of Scikit-learn-compatible transformers for feature engineering, preprocessing, and pipeline utilities."
 authors = [{ name = "sh99", email = "shriramh99@gmail.com" }]
 readme = "README.md"

{scikit_extensions-0.2.0 → scikit_extensions-0.2.2}/skext/linear_model.py

@@ -39,12 +39,15 @@ class OLSRegressor(BaseEstimator, RegressorMixin):
         self : object
             Returns self.
         """
+        input_feature_names = X.columns.tolist() if isinstance(X, pd.DataFrame) else None
+
         # Check input data
         X, y = check_X_y(X, y, y_numeric=True)
         
         # Convert to DataFrame to preserve feature names
-        if isinstance(X, pd.DataFrame):
-            self.feature_names_ = X.columns.tolist()
+        if input_feature_names is not None:
+            self.feature_names_ = input_feature_names
+            X = pd.DataFrame(X, columns=self.feature_names_)
         else:
             self.feature_names_ = [f'x{i}' for i in range(X.shape[1])]
             X = pd.DataFrame(X, columns=self.feature_names_)
@@ -98,14 +101,15 @@ class OLSRegressor(BaseEstimator, RegressorMixin):
         """Return model coefficients (excluding intercept)."""
         if self.results_ is None:
             raise ValueError("Model not fitted. Call 'fit' first.")
-        return self.results_.params[1:] if self.fit_intercept else self.results_.params
+        params = np.asarray(self.results_.params)
+        return params[1:] if self.fit_intercept else params
     
     @property
     def intercept_(self):
         """Return intercept value."""
         if self.results_ is None:
             raise ValueError("Model not fitted. Call 'fit' first.")
-        return self.results_.params[0] if self.fit_intercept else 0.0
+        return np.asarray(self.results_.params)[0] if self.fit_intercept else 0.0
     
     def summary(self):
         """Return statsmodels summary object."""

{scikit_extensions-0.2.0 → scikit_extensions-0.2.2}/skext/multicolinerity.py

@@ -31,8 +31,6 @@ class MultiCollinearityReducer(BaseEstimator, TransformerMixin):
         self.correlation_threshold = correlation_threshold
         self.strategy = strategy
         self.random_state = random_state
-        self.selected_features_ = None
-        self.feature_correlations_ = None
     
     def _select_by_variance(self, X, features):
         """Select feature with highest variance from group"""
@@ -74,6 +72,18 @@ class MultiCollinearityReducer(BaseEstimator, TransformerMixin):
         """
         # Convert to DataFrame if needed
         X_ = X.copy() if isinstance(X, pd.DataFrame) else pd.DataFrame(X)
+        self.n_features_in_ = X_.shape[1]
+        if isinstance(X, pd.DataFrame):
+            self.input_columns_ = list(X.columns)
+            if all(isinstance(column, str) for column in X.columns):
+                self.feature_names_in_ = np.asarray(X.columns, dtype=object)
+            elif hasattr(self, "feature_names_in_"):
+                del self.feature_names_in_
+        else:
+            self.input_columns_ = [f"x{i}" for i in range(X_.shape[1])]
+            X_.columns = self.input_columns_
+            if hasattr(self, "feature_names_in_"):
+                del self.feature_names_in_
         
         # Calculate correlation matrix
         corr_matrix = X_.corr().abs()
@@ -129,12 +139,24 @@ class MultiCollinearityReducer(BaseEstimator, TransformerMixin):
         pandas.DataFrame
             Transformed data with selected features only
         """
-        if self.selected_features_ is None:
+        if not hasattr(self, "selected_features_"):
             raise ValueError("Transformer has not been fitted yet.")
-            
-        X_ = X.copy() if isinstance(X, pd.DataFrame) else pd.DataFrame(X)
+
+        X_ = X.copy() if isinstance(X, pd.DataFrame) else pd.DataFrame(X, columns=self.input_columns_)
+        if X_.shape[1] != self.n_features_in_:
+            raise ValueError("X has a different number of features than during fit.")
+        if isinstance(X, pd.DataFrame) and list(X.columns) != self.input_columns_:
+            raise ValueError("Input columns must match the columns seen during fit.")
         return X_[self.selected_features_]
     
     def get_feature_names_out(self, input_features=None):
         """Return feature names for output features."""
-        return np.array(self.selected_features_)
+        if not hasattr(self, "selected_features_"):
+            raise ValueError("Transformer has not been fitted yet.")
+        if input_features is not None and hasattr(self, "feature_names_in_"):
+            if not np.array_equal(input_features, self.feature_names_in_):
+                raise ValueError("input_features must match feature_names_in_ when feature names are available.")
+        return np.asarray(self.selected_features_, dtype=object)
+
+
+MulticollinearityRemover = MultiCollinearityReducer

{scikit_extensions-0.2.0 → scikit_extensions-0.2.2}/skext/multilabels.py

@@ -35,8 +35,6 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
             If True, the output will be a sparse matrix in Compressed Sparse Row (CSR) format. Otherwise, a dense NumPy array is returned.
         """
         self.sparse_output = sparse_output
-        self.mlbs = {}
-        self.feature_names_in_ = None
 
     def fit(self, X, y=None):
         """
@@ -57,10 +55,15 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
         """
         if not isinstance(X, pd.DataFrame):
             raise ValueError("Input must be a pandas DataFrame")
-        self.feature_names_in_ = X.columns.tolist()
-        self.mlbs = {
+        self.input_columns_ = list(X.columns)
+        self.n_features_in_ = X.shape[1]
+        if all(isinstance(column, str) for column in X.columns):
+            self.feature_names_in_ = np.asarray(X.columns, dtype=object)
+        elif hasattr(self, "feature_names_in_"):
+            del self.feature_names_in_
+        self.mlbs_ = {
             col: MultiLabelBinarizer(sparse_output=self.sparse_output).fit(X[col])
-            for col in self.feature_names_in_
+            for col in self.input_columns_
         }
         return self
 
@@ -80,9 +83,13 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
         """
         if not isinstance(X, pd.DataFrame):
             raise ValueError("Input must be a pandas DataFrame")
+        if not hasattr(self, "mlbs_"):
+            raise ValueError("Transformer has not been fitted yet.")
+        if list(X.columns) != self.input_columns_:
+            raise ValueError("Input columns must match the columns seen during fit.")
         transformed_parts = []
-        for col in self.feature_names_in_:
-            mlb = self.mlbs[col]
+        for col in self.input_columns_:
+            mlb = self.mlbs_[col]
             part = mlb.transform(X[col])
             if not self.sparse_output:
                 part = pd.DataFrame(
@@ -91,7 +98,7 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
                     index=X.index
                 )
             transformed_parts.append(part)
-        return hstack(transformed_parts) if self.sparse_output else pd.concat(transformed_parts, axis=1)
+        return hstack(transformed_parts, format="csr") if self.sparse_output else pd.concat(transformed_parts, axis=1)
 
     def inverse_transform(self, X):
         """
@@ -107,24 +114,31 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
         inverse_transformed : pandas DataFrame of shape (n_samples, n_features)
             A DataFrame where each column contains the original label sets for each sample.
         """
+        if not hasattr(self, "mlbs_"):
+            raise ValueError("Transformer has not been fitted yet.")
         if self.sparse_output and not issparse(X):
             raise ValueError("Expected sparse input for inverse_transform but got dense.")
-        if not self.sparse_output and isinstance(X, np.ndarray):
-            X = pd.DataFrame(X, columns=self.get_feature_names_out())
+        if not self.sparse_output:
+            X = np.asarray(X)
         result = {}
         if self.sparse_output:
             current_col = 0
-            for col in self.feature_names_in_:
-                mlb = self.mlbs[col]
+            for col in self.input_columns_:
+                mlb = self.mlbs_[col]
                 n_classes = len(mlb.classes_)
                 col_slice = X[:, current_col:current_col + n_classes]
-                result[col] = mlb.inverse_transform(col_slice)
+                result[col] = [list(labels) for labels in mlb.inverse_transform(col_slice)]
                 current_col += n_classes
         else:
-            for col in self.feature_names_in_:
-                mlb = self.mlbs[col]
-                col_data = X[[f"{col}__{cls}" for cls in mlb.classes_]]
-                result[col] = mlb.inverse_transform(col_data.values)
+            current_col = 0
+            for col in self.input_columns_:
+                mlb = self.mlbs_[col]
+                n_classes = len(mlb.classes_)
+                result[col] = [
+                    list(labels)
+                    for labels in mlb.inverse_transform(X[:, current_col:current_col + n_classes])
+                ]
+                current_col += n_classes
         return pd.DataFrame(result)
 
     def get_feature_names_out(self, input_features=None):
@@ -141,11 +155,20 @@ class MultiLabelBinarizerTransformer(BaseEstimator, TransformerMixin):
         feature_names_out : list of str
             The output feature names.
         """
+        if not hasattr(self, "mlbs_"):
+            raise ValueError("Transformer has not been fitted yet.")
         if input_features is None:
-            input_features = self.feature_names_in_
+            input_features = getattr(
+                self,
+                "feature_names_in_",
+                np.asarray([f"x{i}" for i in range(self.n_features_in_)], dtype=object),
+            )
+        elif hasattr(self, "feature_names_in_") and not np.array_equal(
+            input_features, self.feature_names_in_
+        ):
+            raise ValueError("input_features must match feature_names_in_ when feature names are available.")
         out = []
-        for col in input_features:
-            mlb = self.mlbs.get(col)
-            if mlb:
-                out.extend([f"{col}__{cls}" for cls in mlb.classes_])
-        return out
+        for col, fitted_col in zip(input_features, self.input_columns_):
+            mlb = self.mlbs_[fitted_col]
+            out.extend([f"{col}__{cls}" for cls in mlb.classes_])
+        return np.asarray(out, dtype=object)