Upload backend app files

Dockerfile

@@ -4,13 +4,17 @@ FROM python:3.9-slim
 # Set the working directory inside the container to /app
 WORKDIR /app
 
-# Copy all files from the current directory on the host to the container's /app directory
-COPY . .
+# Copy the requirements.txt file into the working directory
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Install Python dependencies listed in requirements.txt
-RUN pip3 install -r requirements.txt
+# Copy the rest of the application files into the working directory
+COPY . .
 
-# Define the command to run the Streamlit app on port 8501 and make it accessible externally
-CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Expose port 5000
+EXPOSE 5000
 
-# NOTE: Disable XSRF protection for easier external access in order to make batch predictions
+# Define the command to run the Flask application
+CMD ["flask", "run", "--host=0.0.0.0"]

app.py

@@ -1,51 +1,54 @@
-import streamlit as st
-import requests
-import json
+from flask import Flask, request, jsonify
+import joblib
 import pandas as pd
 
-# Define the backend API endpoint URL
-# Replace with the actual URL of your deployed backend API
-BACKEND_API_URL = "https://huggingface.co/spaces/Dattaluri/Great_Learning"
-
-st.title("SuperKart Sales Forecast")
-
-st.write("Enter the product and store details to get a sales forecast.")
-
-# Create input fields for features
-product_weight = st.number_input("Product Weight", min_value=0.0)
-product_sugar_content = st.selectbox("Product Sugar Content", ["Low Sugar", "Regular", "No Sugar", "reg"])
-product_allocated_area = st.number_input("Product Allocated Area", min_value=0.0)
-product_type = st.selectbox("Product Type", ["Frozen Foods", "Dairy", "Canned", "Baking Goods", "Health and Hygiene", "Meat", "Snack Foods", "Hard Drinks", "Breakfast", "Household", "Breads", "Starchy Foods", "Fruits and Vegetables", "Seafood", "Others", "Soft Drinks"])
-product_mrp = st.number_input("Product MRP", min_value=0.0)
-store_size = st.selectbox("Store Size", ["Medium", "High", "Small"])
-store_location_city_type = st.selectbox("Store Location City Type", ["Tier 2", "Tier 1", "Tier 3"])
-store_type = st.selectbox("Store Type", ["Supermarket Type2", "Departmental Store", "Supermarket Type1", "Food Mart"])
-store_establishment_year = st.number_input("Store Establishment Year", min_value=1985, max_value=2025, step=1)
-
-# Create a button to trigger the prediction
-if st.button("Get Sales Forecast"):
-    # Prepare the input data as a dictionary
-    input_data = {
-        "Product_Weight": product_weight,
-        "Product_Sugar_Content": product_sugar_content,
-        "Product_Allocated_Area": product_allocated_area,
-        "Product_Type": product_type,
-        "Product_MRP": product_mrp,
-        "Store_Size": store_size,
-        "Store_Location_City_Type": store_location_city_type,
-        "Store_Type": store_type,
-        "Store_Establishment_Year": store_establishment_year # Include original year for 'Store_Age' calculation in backend
-    }
-
-    # Send the input data to the backend API for prediction
+app = Flask(__name__)
+
+# Load the serialized full pipeline
+try:
+    full_pipeline = joblib.load('deployment_files/SuperKart_model_v1_0.joblib')
+    # Get the list of columns from the training data used by the pipeline
+    # Adjusting to correctly get column names after one-hot encoding and scaling
+    # This part might need refinement based on the exact structure of your pipeline's preprocessor
+    # A safer approach is to save the column names of X_train during preprocessing
+    # For now, let's assume the order is numerical followed by one-hot encoded categorical
+    # We need to get the feature names from the OneHotEncoder and combine with numerical names
+    categorical_feature_names = full_pipeline.named_steps['preprocessor'].transformers_[0][1].get_feature_names_out(
+        full_pipeline.named_steps['preprocessor'].transformers_[0][2]
+    )
+    numerical_feature_names = full_pipeline.named_steps['scaler'].feature_names_in_
+
+    # Combine numerical and categorical feature names in the correct order
+    pipeline_columns = list(numerical_feature_names) + list(categorical_feature_names)
+
+except Exception as e:
+    full_pipeline = None
+    print(f"Error loading pipeline: {e}")
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    if full_pipeline is None:
+        return jsonify({'error': 'Model not loaded'}), 500
+
     try:
-        response = requests.post(f"{https://huggingface.co/spaces/Dattaluri/Great_Learning/blob/main/app.py}/predict", json=input_data)
-        response.raise_for_status() # Raise an exception for bad status codes
+        data = request.get_json(force=True)
+
+        # Convert input data to DataFrame, ensuring column order matches training data
+        input_df = pd.DataFrame([data])
+
+        # Reorder columns to match the order expected by the pipeline
+        # This assumes all expected columns are present in the input data
+        input_df = input_df[pipeline_columns]
+
+
+        # Make prediction
+        prediction = full_pipeline.predict(input_df)
+
+        # Return prediction as JSON
+        return jsonify({'prediction': prediction.tolist()})
 
-        prediction = response.json()["prediction"][0]
-        st.success(f"The estimated sales total is: ${prediction:.2f}")
+    except Exception as e:
+        return jsonify({'error': str(e)}), 400
 
-    except requests.exceptions.RequestException as e:
-        st.error(f"Error communicating with the backend API: {e}")
-    except KeyError:
-        st.error("Invalid response from the backend API.")
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

requirements.txt

@@ -1,3 +1,5 @@
-streamlit==1.36.0
-requests==2.32.3
+Flask==3.0.3
+joblib==1.4.2
 pandas==2.2.2
+scikit-learn==1.6.1
+numpy==2.0.2