skweights 0.1.0__py3-none-any.whl

skweights/__init__.py

@@ -0,0 +1,4 @@
+from .weighter import FeatureWeighter
+from .wrapper import RuleConstraintWrapper
+
+__all__ = ["FeatureWeighter", "RuleConstraintWrapper"]

skweights/weighter.py

@@ -0,0 +1,55 @@
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.utils.validation import check_is_fitted
+
+class FeatureWeighter(BaseEstimator, TransformerMixin):
+    """
+    A transformer that applies a priori scalar weights to specific features.
+    
+    Parameters
+    ----------
+    weights : dict, default=None
+        A dictionary mapping column names (for DataFrames) or 
+        column indices (for NumPy arrays) to their scalar weights.
+    """
+    def __init__(self, weights=None):
+        self.weights = weights
+
+    def fit(self, X, y=None):
+        """
+        Stateless fit method. Validates initialization and returns self.
+        """
+        # _is_fitted is a scikit-learn convention to prove the model 
+        # has passed through the fit step of a pipeline.
+        self._is_fitted_ = True
+        return self
+
+    def transform(self, X):
+        """
+        Applies the scalar weights to the defined features.
+        """
+        # 1. State Validation
+        check_is_fitted(self, '_is_fitted_')
+        
+        # 2. Bypass Logic
+        if self.weights is None or not self.weights:
+            return X
+            
+        # 3. Immutability Principle
+        X_transformed = X.copy()
+        
+        # 4. Type Routing & Matrix Operations
+        if isinstance(X_transformed, pd.DataFrame):
+            for col, weight in self.weights.items():
+                if col in X_transformed.columns:
+                    X_transformed[col] = X_transformed[col] * weight
+                    
+        elif isinstance(X_transformed, np.ndarray):
+            for col_idx, weight in self.weights.items():
+                if isinstance(col_idx, int) and 0 <= col_idx < X_transformed.shape[1]:
+                    X_transformed[:, col_idx] = X_transformed[:, col_idx] * weight
+        else:
+            raise TypeError("Input must be a Pandas DataFrame or a NumPy array.")
+            
+        return X_transformed

skweights/wrapper.py

@@ -0,0 +1,117 @@
+import operator
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, MetaEstimatorMixin, clone
+from sklearn.utils.validation import check_is_fitted
+
+# Safe mapping to avoid using eval() in production
+OPERATOR_MAP = {
+    '==': operator.eq,
+    '!=': operator.ne,
+    '>': operator.gt,
+    '<': operator.lt,
+    '>=': operator.ge,
+    '<=': operator.le
+}
+
+class RuleConstraintWrapper(BaseEstimator, MetaEstimatorMixin):
+    """
+    A meta-estimator that evaluates deterministic business rules before 
+    delegating predictions to an underlying supervised machine learning model.
+    
+    Parameters
+    ----------
+    estimator : estimator object
+        The base scikit-learn estimator (e.g., LogisticRegression).
+    rules : list of dict
+        A cascade of rules. Format: 
+        [{'column': 'age', 'operator': '<', 'value': 18, 'outcome': 0}]
+    """
+    def __init__(self, estimator, rules=None):
+        self.estimator = estimator
+        self.rules = rules if rules is not None else []
+
+    def _apply_rules(self, X):
+        """
+        Internal method to evaluate the rule cascade using vectorized masking.
+        Returns a boolean mask of handled rows and their hardcoded predictions.
+        """
+        n_samples = X.shape[0]
+        handled_mask = np.zeros(n_samples, dtype=bool)
+        rule_predictions = np.empty(n_samples, dtype=object)
+
+        if not self.rules:
+            return handled_mask, rule_predictions
+
+        for rule in self.rules:
+            col = rule['column']
+            op_func = OPERATOR_MAP[rule['operator']]
+            val = rule['value']
+            outcome = rule['outcome']
+
+            # Extract the column data safely
+            if isinstance(X, pd.DataFrame):
+                if col not in X.columns:
+                    continue
+                col_data = X[col].values
+            else:
+                # Assume col is an integer index if X is a NumPy array
+                if not isinstance(col, int) or col >= X.shape[1]:
+                    continue
+                col_data = X[:, col]
+
+            # Vectorized condition check (only on rows not yet handled)
+            condition_mask = op_func(col_data, val)
+            
+            # Find rows that meet the condition AND haven't been handled by previous rules
+            active_mask = condition_mask & ~handled_mask
+            
+            # Apply the outcome and update the handled mask
+            rule_predictions[active_mask] = outcome
+            handled_mask |= active_mask
+
+        return handled_mask, rule_predictions
+
+    def fit(self, X, y):
+        """
+        Filters out data that triggers deterministic rules, then fits the 
+        underlying estimator only on the remaining valid data.
+        """
+        self.estimator_ = clone(self.estimator)
+        
+        handled_mask, _ = self._apply_rules(X)
+        
+        # We only train the model on data that passes the rules
+        X_passed = X[~handled_mask]
+        y_passed = np.array(y)[~handled_mask]
+
+        if len(X_passed) == 0:
+            raise ValueError("All training samples were filtered out by the business rules.")
+
+        self.estimator_.fit(X_passed, y_passed)
+        self._is_fitted_ = True
+        
+        return self
+
+    def predict(self, X):
+        """
+        Predicts outcomes by first applying rules, then delegating the remainder.
+        """
+        check_is_fitted(self, '_is_fitted_')
+        
+        n_samples = X.shape[0]
+        final_predictions = np.empty(n_samples, dtype=object)
+        
+        # 1. Evaluate rules (The Gatekeeper)
+        handled_mask, rule_preds = self._apply_rules(X)
+        final_predictions[handled_mask] = rule_preds[handled_mask]
+        
+        # 2. Delegate remainder to the underlying model
+        unhandled_mask = ~handled_mask
+        if np.any(unhandled_mask):
+            # Pass only the unhandled rows to the trained estimator
+            X_unhandled = X[unhandled_mask] if isinstance(X, pd.DataFrame) else X[unhandled_mask, :]
+            model_preds = self.estimator_.predict(X_unhandled)
+            final_predictions[unhandled_mask] = model_preds
+            
+        return final_predictions

skweights-0.1.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: skweights
+Version: 0.1.0
+Summary: Scikit-learn compatible meta-estimators for heuristic business rules and feature weighting.
+Author-email: Aron Kipkurui <aronidengeno@gmail.com>
+Project-URL: Homepage, https://github.com/wizard-hash2/skweights
+Project-URL: Bug Tracker, https://github.com/wizard-hash2/skweights/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: numpy>=1.20.0

skweights-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+skweights/__init__.py,sha256=UYuQ4yLE_svvpdKXhogeMtFxqSixKleYYqR73wIaL5E,139
+skweights/weighter.py,sha256=-bhAYNhq7_cJCKv3nS_hefMXP-AmSrN8ypA7H8SLC2A,2021
+skweights/wrapper.py,sha256=EsRfy8hqpm3ZyojdEMJo-votEf1SJ7_Ni_wixOo5bzg,4302
+skweights-0.1.0.dist-info/METADATA,sha256=g3ZSPKxru2Rshk5H4qwV1HqitrsfctQ4tiL5bHMs39A,781
+skweights-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+skweights-0.1.0.dist-info/top_level.txt,sha256=8PGJQi3n3gM1dVIQYLFjPoKAAwh-1bIsoWIY_za4-xY,10
+skweights-0.1.0.dist-info/RECORD,,

skweights-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

skweights-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+skweights