Upload folder using huggingface_hub

app.py

@@ -6,6 +6,194 @@ from sklearn.compose import ColumnTransformer
 import traceback
 import numpy as np
 import os
+from typing import Iterable, Optional, Any
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.pipeline import Pipeline
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import OneHotEncoder
+
+
+class ManualProductTypeMapper(BaseEstimator, TransformerMixin):
+    """
+    Transformer that maps values of a Product-Type column to a controlled set of
+    allowed categories, mapping all other (unwanted / rare / unknown) values to 'Others'.
+
+    Key design choices (sklearn-compatible):
+    - Constructor arguments are stored exactly as provided in __init__ (no conversion).
+      This is required so sklearn.clone can recreate the estimator for CV/hyperparameter search.
+    - Any conversion/validation of constructor args is done in fit() and stored in attributes
+      that end with an underscore (e.g., `keep_set_`) following sklearn conventions.
+    - fit_transform() appends a single synthetic row with Product_Type='Others' when necessary,
+      so that downstream OneHotEncoder will always learn an 'Others' category during fit.
+
+    Parameters
+    ----------
+    product_col : str, default='Product_Type'
+        Name of the column in the incoming DataFrame that contains product type labels.
+
+    keep_set : Iterable[str] or None, default=None
+        Iterable (list / set / tuple) of product type values that should be preserved as-is.
+        All other values will be mapped to the literal string 'Others'.
+        Must be provided (non-empty) before calling fit().
+
+    Notes
+    -----
+    - This transformer does not use the target `y` — it only needs X (pandas DataFrame).
+    - After fit(), an internal attribute `keep_set_` (a set) contains the validated keep values.
+    - transform() requires the transformer to be fit first (i.e., keep_set_ must exist).
+    """
+
+    def __init__(self, product_col: str = 'Product_Type', keep_set: Optional[Iterable[str]] = None):
+        # Store constructor arguments exactly as provided. Do NOT mutate or coerce them here.
+        # sklearn.clone relies on the instance attributes matching constructor args.
+        self.product_col = product_col
+        self.keep_set = keep_set
+
+    def fit(self, X: pd.DataFrame, y: Optional[Any] = None):
+        """
+        Validate inputs and prepare internal state.
+
+        This method:
+        - Validates X is a pandas DataFrame and contains the product_col.
+        - Validates that keep_set is provided and converts it into an internal set
+          stored as `keep_set_` (sklearn-style learned attribute).
+
+        Parameters
+        ----------
+        X : pd.DataFrame
+            Input training DataFrame. Must contain the `product_col`.
+        y : ignored
+            Present for sklearn compatibility with fit(X, y) API.
+
+        Returns
+        -------
+        self : ManualProductTypeMapper
+            Returns self.
+        """
+        # Basic input validation
+        if not isinstance(X, pd.DataFrame):
+            raise ValueError("fit expects X to be a pandas DataFrame")
+        if self.product_col not in X.columns:
+            raise ValueError(f"product_col '{self.product_col}' not found in X during fit")
+
+        # keep_set must be provided by user; convert into an internal set for fast membership tests
+        if self.keep_set is None:
+            raise ValueError("ManualProductTypeMapper requires a non-empty keep_set (pass an iterable of values)")
+        # Create a defensive copy and ensure type is set
+        self.keep_set_ = set(self.keep_set)
+
+        # No statistical learning required, return the fitted instance
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        """
+        Map values not in keep_set_ to 'Others'.
+
+        Parameters
+        ----------
+        X : pd.DataFrame
+            Input DataFrame to transform. Must contain the `product_col`.
+            transform assumes fit() was called previously to create `keep_set_`.
+
+        Returns
+        -------
+        X_transformed : pd.DataFrame
+            A copy of X with values in `product_col` replaced with 'Others' when not in keep_set_.
+        """
+        # Ensure fit has been called
+        if not hasattr(self, 'keep_set_'):
+            raise ValueError("transform called before fit(). Call fit(X) first.")
+
+        if not isinstance(X, pd.DataFrame):
+            raise ValueError("transform expects a pandas DataFrame")
+        if self.product_col not in X.columns:
+            raise ValueError(f"product_col '{self.product_col}' not found in X during transform")
+
+        # Work on a shallow copy to avoid mutating the user's DataFrame
+        X2 = X.copy()
+        # Replace values not in keep_set_ with 'Others'
+        X2[self.product_col] = X2[self.product_col].apply(lambda v: v if v in self.keep_set_ else 'Others')
+        return X2
+
+    def fit_transform(self, X: pd.DataFrame, y: Optional[Any] = None, **fit_params) -> pd.DataFrame:
+        """
+        Fit the transformer and transform X in one step.
+
+        Additionally ensures that the transformed training data contains at least one
+        row with Product_Type == 'Others'. If no training row mapped to 'Others',
+        a synthetic row is appended so downstream OneHotEncoder will create the
+        'Others' category at fit time.
+
+        Parameters
+        ----------
+        X : pd.DataFrame
+            Training DataFrame (must contain product_col).
+        y : ignored
+            For sklearn-compatible API.
+
+        Returns
+        -------
+        X_with_dummy : pd.DataFrame
+            Transformed DataFrame (may contain one extra synthetic row if needed).
+        """
+        # Fit to create keep_set_
+        self.fit(X, y)
+        # Apply mapping to the data
+        X_trans = self.transform(X)
+
+        # If 'Others' already present, return transformed data as-is
+        if 'Others' in X_trans[self.product_col].unique():
+            return X_trans
+
+        # Build a synthetic row with Product_Type='Others' and safe defaults for other columns
+        synthetic: dict = {}
+        for col in X_trans.columns:
+            if col == self.product_col:
+                synthetic[col] = 'Others'  # ensure 'Others' exists in transformed data
+            else:
+                # Choose a safe default: mode for categorical-like columns, median for numeric
+                ser = X_trans[col].dropna()
+                if ser.empty:
+                    synthetic[col] = np.nan
+                else:
+                    if pd.api.types.is_object_dtype(ser) or pd.api.types.is_categorical_dtype(ser):
+                        synthetic[col] = ser.mode().iloc[0]
+                    else:
+                        # numeric fallback
+                        synthetic[col] = float(ser.median())
+
+        synthetic_df = pd.DataFrame([synthetic], columns=X_trans.columns)
+        # Append the synthetic row and return the augmented DataFrame
+        X_with_dummy = pd.concat([X_trans, synthetic_df], ignore_index=True)
+        return X_with_dummy
+
+
+# ------------------ Hard-coded keep list (edit as needed) ------------------
+KEEP_PRODUCT_TYPES = {
+    'Fruits and Vegetables', 'Snack Foods', 'Dairy', 'Frozen Foods', 'Household',
+    'Baking Goods', 'Canned', 'Health and Hygiene', 'Meat', 'Soft Drinks'
+}
+
+# ------------------ ColumnTransformer ------------------
+
+# Step 2: Define how categorical columns should be encoded
+col_transformer = ColumnTransformer(
+    transformers=[
+        # 'ohe_cat' = name of the transformer (for reference)
+        # OneHotEncoder is applied to all columns listed in cat_cols
+        # handle_unknown='ignore' prevents errors on unseen categories at inference
+        # sparse_output=False → return dense numpy array (easier for pandas conversion later)
+        ('ohe_cat', OneHotEncoder(handle_unknown='ignore', sparse_output=False, drop='first'), cat_cols),
+    ],
+    # All columns NOT listed in cat_cols will be passed through unchanged
+    remainder='passthrough'
+)
+
+# Step 1: Custom transformer that groups rare Product_Type values into 'Others'
+mapper = ManualProductTypeMapper(
+    product_col='Product_Type',
+    keep_set=KEEP_PRODUCT_TYPES   # your manually defined keep list
+)
 
 
 # Initialize the Flask application
@@ -14,6 +202,7 @@ superKart_sales_predictor_api = Flask("SuperKart Sales Predictor")
 # # Load the trained machine learning model
 model = joblib.load("final_xgboost_pipeline.joblib")
 
+
 # Define a route for the home page
 @superKart_sales_predictor_api.get('/')
 def home():