Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,23 @@
+# Use a lightweight Python image as the base image
+FROM python:3.12-slim
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install the dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the application code into the container
+COPY app.py .
+COPY superkart_regression_model_v1.0.joblib . 
+COPY superkart_gbr_model_v1.0.json . 
+
+
+# Expose the port the Flask app will run on
+EXPOSE 7860
+
+# Command to run the Flask application using Gunicorn
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "app:superkart_sales_predictor_api"]

app.py

@@ -0,0 +1,113 @@
+import numpy as np
+import joblib  # For loading the serialized model
+import pandas as pd  # For data manipulation
+from flask import Flask, request, jsonify  # For creating the Flask API
+import os # To check if the model file exists
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+logger.info("Starting SuperKart Sales Predictor API loading file...")
+# Initialize the Flask application
+superkart_sales_predictor_api = Flask("SuperKart Sales Predictor")
+
+# Define the path to the trained machine learning model
+model_path = "superkart_regression_model_v1.0.joblib"
+model = None
+
+def load_model():
+    """
+    This function loads the trained machine learning model.
+    It should be called when the Flask app starts to ensure the model is ready for predictions.
+    """
+    global model
+    if model is None:
+        try:
+            logger.info(f"Loading model from {model_path}...")
+            model = joblib.load(model_path)
+            logger.info("Model loaded successfully.")
+        except FileNotFoundError:
+            logger.info(f"Error: Model file not found at {model_path}")
+        except Exception as e:
+            logger.info(f"An error occurred while loading the model: {e}")
+
+
+# Define a route for the home page (GET request)
+@superkart_sales_predictor_api.route('/')
+def home():
+    """
+    This function handles GET requests to the root URL ('/') of the API.
+    It returns a simple welcome message and model loading status.
+    """
+    global model
+    if model is None:
+        load_model()
+    # Check if the model is loaded successfully
+    if model:
+        return "Welcome to the SuperKart Sales Prediction API! Model loaded successfullyX."
+    else:
+        return "Welcome to the SuperKart Sales Prediction API! Model loading failedX."
+
+# Define an endpoint for single sales prediction (POST request)
+@superkart_sales_predictor_api.route('/predict_sales', methods=['POST'])
+def predict_sales():
+    """
+    This function handles POST requests to the '/predict_sales' endpoint.
+    It expects a JSON payload containing product and store details and returns
+    the predicted sales as a JSON response.
+    """
+    global model
+    if model is None:
+        load_model()
+    if model is None:
+        return jsonify({'error': 'Model not loaded. Cannot make predictions.'}), 500
+
+    try:
+        # Get the JSON data from the request body
+        input_data = request.get_json()
+
+        # Convert the input data to a pandas DataFrame
+        # Ensure the column order matches the training data
+        input_df = pd.DataFrame([input_data])
+
+        # Preprocess the input data similar to how the training data was preprocessed
+        # This includes feature engineering, one-hot encoding, and scaling
+        # (Assuming the preprocessing steps from the notebook are applied here)
+
+        # Example of expected columns after preprocessing (adjust based on your actual preprocessing)
+        # This is a simplified example, you will need to replicate your exact preprocessing
+        # steps here, including any feature engineering and scaling.
+
+        # For demonstration, let's assume the input JSON keys directly map to the features
+        # used for training after one-hot encoding and scaling.
+        # You will need to replace this with your actual preprocessing logic.
+
+        # **IMPORTANT:** You need to add the exact preprocessing steps here that were used
+        # to train the model, including handling categorical variables (one-hot encoding)
+        # and scaling numerical features using the *same scaler* fitted on the training data.
+
+        # Placeholder for actual preprocessed input DataFrame
+        # Replace this with your actual preprocessing code
+        preprocessed_input = input_df # Replace with your actual preprocessed data
+
+        # Make prediction using the loaded model
+        # The model was trained on log-transformed sales, so the prediction will be log-transformed
+        predicted_sales_log = model.predict(preprocessed_input)[0]
+
+        # Inverse transform the prediction to get the actual sales value
+        predicted_sales = np.expm1(predicted_sales_log) # Use np.expm1 to reverse np.log1p
+
+        # Return the prediction as a JSON response
+        return jsonify({'predicted_sales': predicted_sales})
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 400
+
+# To run the Flask app (for local testing)
+if __name__ == '__main__':
+    # In a production environment, you would typically use a production-ready WSGI server
+    # such as Gunicorn or uWSGI.
+    logger.info("About to start the SuperKart Sales Predictor API...")
+    superkart_sales_predictor_api.run(debug=True, host='0.0.0.0', port=7860)

requirements.txt

@@ -0,0 +1,13 @@
+numpy==2.3.2
+pandas==2.3.1
+scikit-learn==1.6.1
+matplotlib
+seaborn==0.13.2
+joblib==1.5.1
+xgboost==3.0.4
+requests==2.32.3
+Werkzeug==2.2.2
+flask==2.2.2
+gunicorn==20.1.0
+uvicorn[standard]
+streamlit==1.43.2

superkart_regression_model_v1.0.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:82f53e00ea70bbecbf08c9b3dcccfe33c67736b73d5f6715b54d6ba9e5715f91
+size 424984