Upload 5 files

food_app.py

@@ -0,0 +1,123 @@
+from pathlib import Path
+import datetime
+
+import pandas as pd
+import streamlit as st
+
+import main
+import predict
+
+
+def get_user_input(df_train):
+    st.sidebar.write(f"**Order Related Information**")
+    date = st.sidebar.date_input("what is the Order Date?")
+    order_time = st.sidebar.time_input("What is the Order Time?", step=60)
+    order_datetime = datetime.datetime.combine(date, order_time)
+    pickup_time = st.sidebar.time_input("What is the Order Pickup Time?",
+                                        order_datetime + datetime.timedelta(minutes=15), step=60)
+    order_type = st.sidebar.selectbox('What is the type of order?',
+                                      df_train['Type_of_order'].unique())
+    multiple_deliveries = st.sidebar.selectbox('How many deliveries are combined?',
+                                               sorted(df_train['multiple_deliveries'].unique().astype('int')))
+    st.sidebar.write(f"**Location Related Information**")
+    restaurant_latitude = st.sidebar.text_input("What is the restaurant latitude?", "14.829222")
+    restaurant_longitude = st.sidebar.text_input("What is the restaurant longitude?", "67.920922")
+    delivery_location_latitude = st.sidebar.text_input("What is the delivery location latitude?", "14.929222")
+    delivery_location_longitude = st.sidebar.text_input("What is the delivery location longitude?", "68.860922")
+    st.sidebar.write(f"**Delivery Person Related Information**")
+    delivery_person_age = st.sidebar.slider("How old is the delivery person?",
+                                            int(df_train['Delivery_person_Age'].min()),
+                                            int(df_train['Delivery_person_Age'].max()),
+                                            int(df_train['Delivery_person_Age'].mean()))
+    delivery_person_rating = st.sidebar.slider("What is delivery person rating?",
+                                               float(df_train['Delivery_person_Ratings'].min()),
+                                               float(df_train['Delivery_person_Ratings'].max()),
+                                               float(df_train['Delivery_person_Ratings'].mean()))
+    vehicle = st.sidebar.selectbox('What type of vehicle delivery person has?',
+                                   df_train['Type_of_vehicle'].unique())
+    vehicle_condition = st.sidebar.selectbox('What is the Vehicle condition of delivery person?',
+                                             sorted(df_train['Vehicle_condition'].unique()))
+    st.sidebar.write(f"**City Related Information**")
+    city_code = st.sidebar.selectbox('What is the city name of delivery?',
+                                     df_train['City_code'].unique())
+    city = st.sidebar.selectbox('Which type of city it is?',
+                                df_train['City'].unique())
+    st.sidebar.write(f"**Weather Conditions/Event Related Information**")
+    road_density = st.sidebar.selectbox('What is road traffic density?',
+                                        df_train['Road_traffic_density'].unique())
+    weather_conditions = st.sidebar.selectbox('How is the weather?',
+                                              df_train['Weather_conditions'].unique())
+    festival = st.sidebar.selectbox('Is there a festival?',
+                                    df_train['Festival'].unique())
+
+    X = pd.DataFrame({
+        'ID': '123456',
+        'Delivery_person_ID': city_code + 'RES13DEL02',
+        'Delivery_person_Age': delivery_person_age,
+        'Delivery_person_Ratings': delivery_person_rating,
+        'Restaurant_latitude': format(float(restaurant_latitude), ".6f"),
+        'Restaurant_longitude': format(float(restaurant_longitude), ".6f"),
+        'Delivery_location_latitude': format(float(delivery_location_latitude), ".6f"),
+        'Delivery_location_longitude': format(float(delivery_location_longitude), ".6f"),
+        'Order_Date': date.strftime('%d-%m-%Y'),
+        'Time_Orderd': order_time.strftime('%H:%M:%S'),
+        'Time_Order_picked': pickup_time.strftime('%H:%M:%S'),
+        'Weatherconditions': 'conditions ' + weather_conditions,
+        'Road_traffic_density': road_density,
+        'Vehicle_condition': vehicle_condition,
+        'Type_of_order': order_type,
+        'Type_of_vehicle': vehicle,
+        'multiple_deliveries': multiple_deliveries,
+        'Festival': festival,
+        'City': city
+    }, index=[0])
+    return X
+
+
+if __name__ == "__main__":
+    st.set_page_config(page_title="Food Delivery Time Prediction", page_icon=None, layout="centered",
+                       initial_sidebar_state="auto")
+
+    # Read in training data
+    df_train = pd.read_csv(str(Path(__file__).parents[1] / 'data/train.csv'))
+    main.cleaning_steps(df_train)
+
+    # Displaying text
+    st.title("Food Delivery Time Prediction")
+    # Displaying an image
+    st.image(str(Path(__file__).parents[1] / 'img/food-delivery.png'), width=700)
+
+    st.write("""  
+            The food delivery time prediction model is vital in ensuring prompt and accurate delivery in the food delivery industry. Leveraging advanced data cleaning techniques and feature engineering, a robust food delivery time prediction model is developed.
+            
+            This model predicts food delivery time based on a range of factors, including order details, location, city, delivery person information, and weather conditions.  
+             """)
+
+    ##create the sidebar
+    st.sidebar.header("User Input Parameters")
+
+    ##create function for User input
+
+    input_df = get_user_input(df_train)  # get user input from sidebar
+
+    order_date = input_df['Order_Date'][0]
+    order_time = input_df['Time_Orderd'][0]
+    order_date_time = datetime.datetime.strptime(f'{order_date} {order_time}', '%d-%m-%Y %H:%M:%S')
+    order_pickup_time = input_df['Time_Order_picked'][0]
+    order_pickup_date_time = datetime.datetime.strptime(f'{order_date} {order_pickup_time}', '%d-%m-%Y %H:%M:%S')
+
+    total_delivery_minutes = round(predict.predict(input_df)[0], 2)  # get predicitions
+    minutes = int(total_delivery_minutes)
+    seconds = int((total_delivery_minutes - minutes) * 60)
+    X = order_pickup_date_time + datetime.timedelta(minutes=minutes, seconds=seconds)
+
+    # display predictions
+    st.subheader("Order Details")
+    st.write(f"**Order was Placed on :** {order_date_time}")
+    st.write(f"**Order was Picked up at :** {order_pickup_date_time}")
+    st.subheader("Prediction")
+    formatted_X = "{:.2f}".format(total_delivery_minutes)
+    st.write(f"**Total Delivery Time is :** {formatted_X} mins")
+    st.write(f"**Order will be delivered by :** {X}")
+
+

main.py

@@ -0,0 +1,186 @@
+from pathlib import Path
+import numpy as np
+import pandas as pd
+from geopy.distance import geodesic
+import pickle
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+import xgboost as xgb
+from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
+
+
+def update_column_name(df):
+    df.rename(columns={'Weatherconditions': 'Weather_conditions'}, inplace=True)
+
+
+def extract_feature_value(df):
+    # Extract Weather conditions
+    df['Weather_conditions'] = df['Weather_conditions'].apply(lambda x: x.split(' ')[1].strip())
+    # Extract city code from Delivery person ID
+    df['City_code'] = df['Delivery_person_ID'].str.split("RES", expand=True)[0]
+
+    #Remove Whitespaces on categorical value
+    categorical_columns = df.select_dtypes(include='object').columns
+    for column in categorical_columns:
+        df[column] = df[column].str.strip()
+
+
+def extract_label_value(df):
+    # Extract time and convert to int
+    df['Time_taken(min)'] = df['Time_taken(min)'].apply(lambda x: int(x.split(' ')[1].strip()))
+
+
+def drop_columns(df):
+    df.drop(['ID', 'Delivery_person_ID'], axis=1, inplace=True)
+
+
+def update_datatype(df):
+    df['Delivery_person_Age'] = df['Delivery_person_Age'].astype('float64')
+    df['Delivery_person_Ratings'] = df['Delivery_person_Ratings'].astype('float64')
+    df['multiple_deliveries'] = df['multiple_deliveries'].astype('float64')
+    df['Order_Date'] = pd.to_datetime(df['Order_Date'], format="%d-%m-%Y")
+
+
+def convert_nan(df):
+    df.replace('NaN', float(np.nan), regex=True, inplace=True)
+
+
+def handle_null_values(df):
+    df['Delivery_person_Age'].fillna(np.random.choice(df['Delivery_person_Age']), inplace=True)
+    df['Weather_conditions'].fillna(np.random.choice(df['Weather_conditions']), inplace=True)
+    df['City'].fillna(df['City'].mode()[0], inplace=True)
+    df['Festival'].fillna(df['Festival'].mode()[0], inplace=True)
+    df['multiple_deliveries'].fillna(df['multiple_deliveries'].mode()[0], inplace=True)
+    df['Road_traffic_density'].fillna(df['Road_traffic_density'].mode()[0], inplace=True)
+    df['Delivery_person_Ratings'].fillna(df['Delivery_person_Ratings'].median(), inplace=True)
+
+
+def extract_date_features(data):
+    data["day"] = data.Order_Date.dt.day
+    data["month"] = data.Order_Date.dt.month
+    data["quarter"] = data.Order_Date.dt.quarter
+    data["year"] = data.Order_Date.dt.year
+    data['day_of_week'] = data.Order_Date.dt.day_of_week.astype(int)
+    data["is_month_start"] = data.Order_Date.dt.is_month_start.astype(int)
+    data["is_month_end"] = data.Order_Date.dt.is_month_end.astype(int)
+    data["is_quarter_start"] = data.Order_Date.dt.is_quarter_start.astype(int)
+    data["is_quarter_end"] = data.Order_Date.dt.is_quarter_end.astype(int)
+    data["is_year_start"] = data.Order_Date.dt.is_year_start.astype(int)
+    data["is_year_end"] = data.Order_Date.dt.is_year_end.astype(int)
+    data['is_weekend'] = np.where(data['day_of_week'].isin([5, 6]), 1, 0)
+
+
+def calculate_time_diff(df):
+    # Find the difference between ordered time & picked time
+    df['Time_Orderd'] = pd.to_timedelta(df['Time_Orderd'])
+    df['Time_Order_picked'] = pd.to_timedelta(df['Time_Order_picked'])
+
+    df['Time_Order_picked_formatted'] = df['Order_Date'] + np.where(df['Time_Order_picked'] < df['Time_Orderd'],
+                                                                    pd.DateOffset(days=1), pd.DateOffset(days=0)) + df[
+                                            'Time_Order_picked']
+    df['Time_Ordered_formatted'] = df['Order_Date'] + df['Time_Orderd']
+
+    df['order_prepare_time'] = (df['Time_Order_picked_formatted'] - df[
+        'Time_Ordered_formatted']).dt.total_seconds() / 60
+
+    # Handle null values by filling with the median
+    df['order_prepare_time'].fillna(df['order_prepare_time'].median(), inplace=True)
+
+    # Drop all the time & date related columns
+    df.drop(['Time_Orderd', 'Time_Order_picked', 'Time_Ordered_formatted', 'Time_Order_picked_formatted', 'Order_Date'],
+            axis=1, inplace=True)
+
+
+def calculate_distance(df):
+    df['distance'] = np.zeros(len(df))
+    restaurant_coordinates = df[['Restaurant_latitude', 'Restaurant_longitude']].to_numpy()
+    delivery_location_coordinates = df[['Delivery_location_latitude', 'Delivery_location_longitude']].to_numpy()
+    df['distance'] = np.array([geodesic(restaurant, delivery) for restaurant, delivery in
+                               zip(restaurant_coordinates, delivery_location_coordinates)])
+    df['distance'] = df['distance'].astype("str").str.extract('(\d+)').astype("int64")
+
+
+def label_encoding(df):
+    categorical_columns = df.select_dtypes(include='object').columns
+    label_encoders = {}
+
+    # Iterate over each categorical column and fit a label encoder
+    for column in categorical_columns:
+        df[column] = df[column].str.strip()  # Remove whitespaces
+        label_encoder = LabelEncoder()
+        label_encoder.fit(df[column])
+        df[column] = label_encoder.transform(df[column])
+        label_encoders[column] = label_encoder
+    return label_encoders
+
+
+def data_split(X, y):
+    # Split the data into train and test sets
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    return X_train, X_test, y_train, y_test
+
+
+def standardize(X_train, X_test):
+    scaler = StandardScaler()
+
+    # Fit the scaler on the training data
+    scaler.fit(X_train)
+
+    # Perform standardization
+    X_train = scaler.transform(X_train)
+    X_test = scaler.transform(X_test)
+    return X_train, X_test, scaler
+
+
+def cleaning_steps(df):
+    update_column_name(df)
+    extract_feature_value(df)
+    drop_columns(df)
+    update_datatype(df)
+    convert_nan(df)
+    handle_null_values(df)
+
+def perform_feature_engineering(df):
+    extract_date_features(df)
+    calculate_time_diff(df)
+    calculate_distance(df)
+
+
+def evaluate_model(y_test, y_pred):
+    mae = mean_absolute_error(y_test, y_pred)
+    mse = mean_squared_error(y_test, y_pred)
+    rmse = np.sqrt(mse)
+    r2 = r2_score(y_test, y_pred)
+
+    print("Mean Absolute Error (MAE):", round(mae, 2))
+    print("Mean Squared Error (MSE):", round(mse, 2))
+    print("Root Mean Squared Error (RMSE):", round(rmse, 2))
+    print("R-squared (R2) Score:", round(r2, 2))
+
+
+if __name__ == "__main__":
+    df_train = pd.read_csv(str(Path(__file__).parents[1] / 'data/train.csv'))  # Load Data
+    cleaning_steps(df_train)  # Perform Cleaning
+    extract_label_value(df_train) #Extract Label Value
+    perform_feature_engineering(df_train)  # Perform feature engineering
+
+    # Split features & label
+    X = df_train.drop('Time_taken(min)', axis=1)  # Features
+    y = df_train['Time_taken(min)']  # Target variable
+
+    label_encoders = label_encoding(X)  # Label Encoding
+    X_train, X_test, y_train, y_test = data_split(X, y)  # Test Train Split
+    X_train, X_test, scaler = standardize(X_train, X_test)  # Standardization
+
+    # Build Model
+    model = xgb.XGBRegressor(n_estimators=20, max_depth=9)
+    model.fit(X_train, y_train)
+
+    # Evaluate Model
+    y_pred = model.predict(X_test)
+    evaluate_model(y_test, y_pred)
+
+    # Save Model
+    with open(str(Path(__file__).parents[1] / 'code/model.pickle'), 'wb') as f:
+        pickle.dump((model, label_encoders, scaler), f)

model.pickle

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

predict.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+import main
+import pickle
+
+
+def predict(X):
+    # Load the model and scaler from the saved file
+    with open(str(Path(__file__).parents[1] / 'code/model.pickle'), 'rb') as f:
+        model, label_encoders, scaler = pickle.load(f)
+
+    main.cleaning_steps(X)  # Perform Cleaning
+    main.perform_feature_engineering(X)  # Perform Feature Engineering
+    # Label Encoding
+    for column, label_encoder in label_encoders.items():
+        X[column] = label_encoder.transform(X[column])
+    X = scaler.transform(X)  # Standardize
+    pred = model.predict(X)
+    return pred

requirements.txt

@@ -0,0 +1,3 @@
+geopy==2.3.0
+xgboost==1.6.2
+scikit-learn==1.2.1