%pip install xgboost
%pip install ipython-autotime
%load_ext autotime

from math import radians, sin, cos, asin, sqrt
# This line imports specific functions from the math library that are used for calculating the haversine distance between two points on a globe.

import pandas as pd
# This line imports the Pandas library, which is a popular library for data manipulation and analysis.

from sklearn.preprocessing import LabelEncoder, StandardScaler
# This line imports the LabelEncoder and StandardScaler classes from the scikit-learn library, which are used for preprocessing data for machine learning models.

import time
# This line imports the time module, which is used for timing the execution of code

import numpy as np
# This line imports the NumPy library, which provides support for numerical computing with Python.

from sklearn.metrics import accuracy_score
# This line imports the accuracy_score function from the scikit-learn library, which is used for evaluating the performance of classification models.

from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
# These lines import the train_test_split and GridSearchCV classes from the scikit-learn library, which are used for splitting data into training and testing sets and tuning hyperparameters, respectively.

from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import VotingRegressor
from sklearn.svm import SVR
# These lines import the RandomForestRegressor, VotingRegressor, and SVR classes from the scikit-learn library, which are used for building machine learning models.

import xgboost as xgb
# This line imports the xgboost library, which is a popular library for gradient boosting.

import pickle
# This line imports the pickle module, which is used for serializing and deserializing Python objects.

orders = pd.read_csv("./data/olist_orders_dataset.csv")
# This line reads the CSV file "olist_orders_dataset.csv" located in the "./data/" directory and stores its contents as a Pandas DataFrame named "orders".

items = pd.read_csv("./data/olist_order_items_dataset.csv")
# This line reads the CSV file "olist_order_items_dataset.csv" located in the "./data/" directory and stores its contents as a Pandas DataFrame named "items".

customers = pd.read_csv("./data/olist_customers_dataset.csv")
# This line reads the CSV file "olist_customers_dataset.csv" located in the "./data/" directory and stores its contents as a Pandas DataFrame named "customers".

sellers = pd.read_csv("./data/olist_sellers_dataset.csv")
# This line reads the CSV file "olist_sellers_dataset.csv" located in the "./data/" directory and stores its contents as a Pandas DataFrame named "sellers".

geo = pd.read_csv("./data/olist_geolocation_dataset.csv")
# This line reads the CSV file "olist_geolocation_dataset.csv" located in the "./data/" directory and stores its contents as a Pandas DataFrame named "geo".

products = pd.read_csv("./data/olist_products_dataset.csv")
# This line reads the CSV file "olist_products_dataset.csv" located in the "./data/" directory and stores its contents as a Pandas DataFrame named "products".

orders.head()

# The code above assumes that a Pandas DataFrame named orders has been previously defined, and calls the head() method on that DataFrame.

# The head() method is used to display the first few rows of a DataFrame, by default the first five rows. This can be useful for quickly checking the structure and content of a DataFrame.

# So, this line of code will output the first five rows of the orders DataFrame, assuming it has been previously defined.

products.head()

customers.head()

sellers.head()

# info() helps summarize the dataset- It gives basic information like number of non-null values, datatypes and memory usage
# It is a good practise to start by this information
products.info() 

customers.info()

sellers.info()

orders.info()

# Get the seller zip code of each order

middle = items[['order_id', 'seller_id']]
# This line creates a new dataframe middle that contains only the order_id and seller_id columns from the items dataframe.

middle_2 = middle.merge(sellers[['seller_id', 'seller_zip_code_prefix']], on="seller_id", how="outer")
# This line merges the middle dataframe with the seller_id and seller_zip_code_prefix columns from the sellers dataframe, creating a new dataframe middle_2. The outer join type is used, which means that all rows from both dataframes are included in the merged dataframe, and missing values are filled with NaN.

orders = orders.merge(middle_2, on="order_id", how="left")
# This line merges the orders dataframe with the middle_2 dataframe on the order_id column, creating a new orders dataframe. The left join type is used, which means that all rows from the orders dataframe are included in the merged dataframe, and missing values from the middle_2 dataframe are filled with NaN.

orders.head()

# Get customer zip code of each order
orders = orders.merge(customers[['customer_id', 'customer_zip_code_prefix']],
                  on='customer_id', how="left")
# The code above performs a left merge operation between two Pandas dataframes named "orders" and "customers" using the "customer_id" column as the joining key. It then selects the "customer_id" and "customer_zip_code_prefix" columns from the "customers" dataframe and merges them with the "orders" dataframe based on the matching "customer_id" column.


orders.head()

# Clean geo df
geo = geo[~geo['geolocation_zip_code_prefix'].duplicated()]
'''
This line first selects the 'geolocation_zip_code_prefix' column from the 'geo' DataFrame using the indexing operator []. The duplicated() method is then called on this column to create a boolean mask of rows that have duplicate values in this column.

The tilde operator (~) is used to invert this boolean mask, so that the mask contains True for rows that do not have duplicate values in this column.
'''

geo.head()

# add seller coordinates to the orders
orders = orders.merge(geo, left_on="seller_zip_code_prefix",
                      right_on="geolocation_zip_code_prefix", how="left")
'''
The code above performs a left join of two dataframes - "orders" and "geo" - using the "seller_zip_code_prefix" column of the "orders" dataframe and the "geolocation_zip_code_prefix" column of the "geo" dataframe as the join keys.
'''
                      
orders.head()

# add customer coordinates to the orders
orders = orders.merge(geo, left_on="customer_zip_code_prefix",
                      right_on="geolocation_zip_code_prefix", how="left",
                      suffixes=("_seller", "_customer"))
# This code merges two Pandas DataFrames, orders and geo, on a common column, customer_zip_code_prefix in orders and geolocation_zip_code_prefix in geo. The resulting merged DataFrame contains all the columns from both DataFrames.

# Clean orders
# 1-Filter out orders with multiple sellers Because each order only has one delivery date
df = orders.groupby(by="order_id").nunique()
# Groups the orders by order_id and calculates the number of unique values in each group using the nunique() method.

mono_orders = pd.Series(df[df['seller_id'] == 1].index)
# Selects the indices of the resulting DataFrame where the seller_id column equals 1 and stores them in a Pandas Series called mono_orders.

filtered_orders = orders.merge(mono_orders, how='inner')
# Merges the original orders DataFrame with mono_orders based on the order_id column using an inner join and stores the resulting DataFrame in a variable called filtered_orders.

# 2-drop rows with missing values
filtered_orders = filtered_orders.drop(columns=["order_approved_at"])
# This line drops the "order_approved_at" column from the filtered_orders DataFrame. This column is not necessary for the analysis being performed.

filtered_orders = filtered_orders.dropna()
# This line drops any rows in the filtered_orders DataFrame that contain missing values. This is a common data preprocessing step to ensure that the dataset is clean and complete.


filtered_orders.head()

# Define Function to calculate distance
def haversine_distance(lon1, lat1, lon2, lat2):
    """
    Compute distance between two pairs of (lat, lng)
    """
    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = sin(dlat / 2) ** 2 + cos(lat1) * cos(lat2) * sin(dlon / 2) ** 2
    return 2 * 6371 * asin(sqrt(a))

# This line defines a function called haversine_distance that takes four arguments: lon1, lat1, lon2, and lat2. These arguments represent the longitude and latitude coordinates of two points on the globe.

def get_package_size(items, products):
    # Get Package Size
    df_tmp = items[['order_id', 'product_id']].merge(products[['product_id', 'product_length_cm', 'product_height_cm',
                                                               'product_width_cm', 'product_weight_g']],
                                                     on="product_id",
                                                     how="outer")
    df_tmp.loc[:, "product_size_cm3"] = \
        df_tmp['product_length_cm']*df_tmp['product_width_cm'] * df_tmp['product_height_cm']
    orders_size_weight = df_tmp.groupby("order_id", as_index=False).sum()[['order_id', 'product_size_cm3',
                                                                           'product_weight_g']]
    return orders_size_weight

# The code above defines a function called get_package_size that takes two arguments: items and products, which are Pandas DataFrames containing information about products and the items ordered.

def object_to_int(dataframe_series):

    if dataframe_series.dtype == 'object':
        # This line checks if the data type of the input dataframe_series is "object", which typically represents string or categorical data.

        dataframe_series = LabelEncoder().fit_transform(dataframe_series)
        # This line uses the LabelEncoder() method from the scikit-learn library to encode the string or categorical data as integers. This is a common preprocessing step in machine learning to convert non-numeric data into a format that can be used by algorithms. The fit_transform() method fits the encoder to the data and transforms it.
        
    return dataframe_series

#It gives the numerical statistical information of the dataframe
'''
Your Code Here
'''


# The code above applies the describe() method to a Pandas DataFrame called orders, which provides summary statistics of the data in the DataFrame. Here's a brief explanation of what each statistic means:

# count: the number of non-missing values in each column
# mean: the average value of each column
# std: the standard deviation of each column
# min: the minimum value of each column
# 25%: the first quartile of each column (25th percentile)
# 50%: the second quartile of each column (50th percentile, equivalent to the median)
# 75%: the third quartile of each column (75th percentile)
# max: the maximum value of each column
# The describe() method is useful for quickly getting an overview of the data in a DataFrame, including identifying potential outliers or unusual patterns in the data.

# It returns the number of null values in the dataframe for every column feature
# Using info() we can view the number of non-null values whereas isnull() gives the number of null values
orders.isnull().sum()

def scaling(X_train, X_test):
    '''
    The code above defines a function called scaling that performs feature scaling using the StandardScaler class from scikit-learn.
    '''
    sc_X = StandardScaler()
    X_train_scaled = sc_X.fit_transform(X_train)
    X_test_scaled = sc_X.fit_transform(X_test)
    return X_train_scaled, X_test_scaled

def split_data(final_df, columns_for_train, columns_for_pred, i_flag):
    '''
    This function is a convenient way to split a DataFrame into training and testing sets for machine learning purposes. The i_flag parameter is used to avoid a warning message related to the NumPy library, and the columns_for_train and columns_for_pred parameters allow for flexible selection of features and target variables.
    '''

    if i_flag:
        from sklearnex import patch_sklearn  # pylint: disable=C0415, E0401
        patch_sklearn()
    from sklearn.model_selection import train_test_split  # pylint: disable=C0415

    x_train, x_test, y_train, y_test = train_test_split(final_df[columns_for_train], final_df[columns_for_pred],
                                                        test_size=0.3, random_state=42)
    return x_train, x_test, y_train, y_test

filtered_orders['distance'] = filtered_orders.apply(lambda row: haversine_distance(row["geolocation_lng_seller"],
                                                                                   row["geolocation_lat_seller"],
                                                                                   row["geolocation_lng_customer"],
                                                                                   row["geolocation_lat_customer"],),
                                                    axis=1,)
# This line creates a new column in the filtered_orders DataFrame called "distance" by applying the haversine_distance function to calculate the distance between the seller and the customer for each row in the DataFrame.


orders_size_weight = get_package_size(items, products)
filtered_orders = filtered_orders.merge(orders_size_weight, on='order_id', how='left')
# These lines merge information about the package size and weight for each order from the items and products DataFrames into the filtered_orders DataFrame.


# process time columns
time_columns = ['order_purchase_timestamp', 'order_delivered_customer_date', 'order_estimated_delivery_date']
for column in time_columns:
    filtered_orders[column] = pd.to_datetime(filtered_orders[column])
# These lines convert several time-related columns in the filtered_orders DataFrame from string format to datetime format using the pd.to_datetime function.


filtered_orders["wait_time"] = (filtered_orders['order_delivered_customer_date'] -
                                       filtered_orders['order_purchase_timestamp']).dt.days
filtered_orders["est_wait_time"] = (filtered_orders['order_estimated_delivery_date'] -
                                           filtered_orders['order_purchase_timestamp']).dt.days
# These lines calculate the wait time and estimated wait time for each order in days, based on the difference between the purchase time and the delivered/estimated delivery time.


filtered_orders["purchase_dow"] = filtered_orders.order_purchase_timestamp.dt.dayofweek
filtered_orders["year"] = filtered_orders.order_purchase_timestamp.dt.year
filtered_orders["purchase_month"] = filtered_orders.order_purchase_timestamp.dt.month
# These lines extract the day of the week, year, and month from the order_purchase_timestamp column in the filtered_orders DataFrame.


final_df = filtered_orders[['purchase_dow', 'purchase_month', 'year', 'product_size_cm3', 'product_weight_g',
                            'geolocation_state_customer', 'geolocation_state_seller', 'distance',
                            'wait_time', 'est_wait_time']]
# This line creates a new DataFrame called final_df by selecting certain columns from the filtered_orders DataFrame.

final_df['delay'] = final_df['wait_time'] - final_df['est_wait_time']
final_df['delay'] = final_df['delay'] > 0
final_df['delay'] = final_df['delay'].astype(int)
# These lines calculate the delay time for each order and encode it as a binary variable indicating whether there was a delay or not.

'''
Your Code Here
'''
# This line applies the object_to_int function to each column in the final_df DataFrame to convert categorical variables into integer format. The object_to_int function is not shown in the code provided, but it likely uses the LabelEncoder class from the scikit-learn library to perform the conversion.

# split data
columns_for_regression_train = ['purchase_dow', 'purchase_month', 'year', 'product_size_cm3', 'product_weight_g',
                                'geolocation_state_customer', 'geolocation_state_seller',
                                'distance']
columns_for_regression_pred = ['wait_time']
# These two lines define lists of column names to be used as predictors and targets, respectively.

X_train_reg_0, X_test_reg_0, y_train_reg_0, y_test_reg_0 = train_test_split(final_df_enc[columns_for_regression_train],
                                                                            final_df_enc[columns_for_regression_pred],
                                                                            random_state=42)

# This line splits the final_df_enc DataFrame into training and testing sets for regression modeling. Specifically, the predictors defined in columns_for_regression_train are assigned to X_train_reg_0 and X_test_reg_0, while the target variable defined in columns_for_regression_pred is assigned to y_train_reg_0 and y_test_reg_0. The train_test_split function is used to randomly split the data into training and testing sets, with 75% of the data assigned to training and 25% assigned to testing. The random_state parameter is set to 42 to ensure reproducibility of the results.

# len(dataframe): returns the no of rows in the dataframe
len(X_train_reg_0)

len(X_test_reg_0)

# Prints the first five entry of the dataframe

X_train_reg_0.head()

# Prints the first five entry of the dataframe

X_test_reg_0.head()

# Prints the first five entry of the dataframe

y_train_reg_0.head()

'''
This code block defines several utility functions for making predictions with different regression models and evaluating their performance.
'''

def xgb_predict_reg(xgb_model, x_test_reg, y_test_reg):
    '''
    This function takes an XGBoost regression model, test input data (x_test_reg), and test output data (y_test_reg) as inputs. It uses the model to make predictions on the test data, calculates the mean squared error (MSE) of the predictions compared to the actual test output data, and returns the MSE and the time it took to make the predictions.
    '''
    xgb_pred_start = time.time()
    y_pred = xgb_model.predict(x_test_reg)
    xgb_pred_time = time.time() - xgb_pred_start
    xgb_mse = np.square(np.subtract(y_test_reg.values.reshape(-1), y_pred)).mean()
    return xgb_mse, xgb_pred_time
        
def rf_predict_reg(rf_model, x_test_reg, y_test_reg):
    '''
    This function is similar to the previous one but takes a random forest regression model instead of an XGBoost model.
    '''
    rf_pred_start = time.time()
    y_pred = rf_model.predict(x_test_reg)
    rf_pred_time = time.time() - rf_pred_start
    rf_mse = np.square(np.subtract(y_test_reg.values.reshape(-1), y_pred)).mean()
    return rf_mse, rf_pred_time

def SV_predict_reg(svr_model, x_test_reg, y_test_reg):
    '''
    This function is similar to the previous two but takes a support vector regression (SVR) model instead.
    '''
    svr_pred_start = time.time()
    y_pred = svr_model.predict(x_test_reg)
    svr_pred_time = time.time() - svr_pred_start
    svr_mse = np.square(np.subtract(y_test_reg.values.reshape(-1), y_pred)).mean()
    return svr_mse, svr_pred_time

def ensemble_predict_reg(ensemble_model, x_test_reg, y_test_reg):
    '''
    This function takes an ensemble model (e.g. a voting regressor) instead of a single regression model and performs the same evaluation as the previous functions.
    '''
    ensemble_pred_start = time.time()
    y_pred = ensemble_model.predict(x_test_reg)
    ensemble_pred_time = time.time() - ensemble_pred_start
    ensemble_mse = np.square(np.subtract(y_test_reg.values.reshape(-1), y_pred)).mean()
    return ensemble_mse, ensemble_pred_time

hyper_train = pd.DataFrame(X_train_reg_0, columns=columns_for_regression_train)
hyper_train['wait_time'] = y_train_reg_0['wait_time'].values
# These lines create a new Pandas DataFrame called hyper_train from the training set (X_train_reg_0 and y_train_reg_0) and add a new column called "wait_time" to it. The columns_for_regression_train variable specifies which columns from X_train_reg_0 to include in the new DataFrame. The "wait_time" column is added to hyper_train by taking the values from the "wait_time" column of y_train_reg_0.

hyper_train_section = hyper_train.sample(8192, random_state=42)
# This line randomly samples a subset of 8192 rows from hyper_train and creates a new DataFrame called hyper_train_section. The random_state=42 parameter ensures that the random sampling is reproducible.

X_train_reg = hyper_train_section[columns_for_regression_train]
y_train_reg = hyper_train_section[columns_for_regression_pred]
# These lines split the hyper_train_section DataFrame into the training set (X_train_reg) and the target variable (y_train_reg) based on the columns_for_regression_train and columns_for_regression_pred variables, respectively. columns_for_regression_train specifies which columns from hyper_train_section to include in X_train_reg, while columns_for_regression_pred specifies which column(s) to use as the target variable.

# Set parameters for xgb and random forests and SV for hyper parameter tuning
xgb_params = {'n_estimators': [500, 1000], 'max_depth': [10, 20], 'tree_method': ['hist']}
# This dictionary contains hyperparameters for the XGBoost model, including the number of estimators (500 or 1000), the maximum depth of each tree (10 or 20), and the tree construction method ('hist').

rf_params = {'n_estimators': [500, 1000], 'max_depth': [10, 20]}
# This dictionary contains hyperparameters for the Random Forest model, including the number of estimators (500 or 1000) and the maximum depth of each tree (10 or 20).

SV_params = {'C': [10, 20], 'epsilon': [0.1, 0.05], 'kernel': ['rbf'], 'gamma': ['auto']}
# This dictionary contains hyperparameters for the Support Vector Regression model, including the penalty parameter C (10 or 20), the epsilon parameter (0.1 or 0.05), the kernel function ('rbf'), and the kernel coefficient ('auto').

ensemble_params = {'weights': [(1, 1, 1), (1, 2, 1), (2, 1, 1), (1, 1, 2)]}
# This dictionary contains hyperparameters for the VotingRegressor model, including the weights assigned to each model in the ensemble. The weights are represented as tuples, with each element representing the weight of a different model. For example, the tuple (1, 2, 1) represents an ensemble where the second model has twice the weight of the first and third models.

print('Running Hyperparameter Tuning for XGB')
xgb_model = xgb.XGBRegressor()
# This line creates a new instance of the XGBRegressor class from the XGBoost library. This will be the base model that will be tuned using GridSearchCV.

xgb_grid = GridSearchCV(xgb_model, xgb_params, cv=4, n_jobs=-1, verbose=True)

# This line creates a new instance of the GridSearchCV class from the scikit-learn library. The GridSearchCV class performs an exhaustive search over a specified parameter grid to find the combination of hyperparameters that yields the best performance. In this case, the GridSearchCV object is created with the following arguments:

# xgb_model: The XGBoost model instance that will be tuned.
# xgb_params: A dictionary of hyperparameters and their possible values.
# cv=4: The number of cross-validation folds to use in the search. In this case, 4-fold cross-validation will be used.
# n_jobs=-1: The number of CPU cores to use in parallel for training the models. In this case, -1 is specified to use all available CPU cores.
# verbose=True: Whether to print progress messages during the search.

# record time
xgb_start = time.time()
# This line records the current time using the time.time() function and saves it to the variable xgb_start. This is used to calculate the time it takes to train the XGBoost model.

xgb_grid.fit(X_train_reg, y_train_reg)
# This line fits a grid search on the XGBoost model with the training data X_train_reg and y_train_reg. The grid search involves searching through a range of hyperparameters to find the best combination of hyperparameters for the XGBoost model.

xgb_hyper_time = time.time()-xgb_start
# This line calculates the time it took to train the XGBoost model by subtracting xgb_start from the current time using the time.time() function. The result is saved to the variable xgb_hyper_time.

# extract best grid
xgb_best_grid = xgb_grid.best_estimator_
# This line takes the best estimator found by the GridSearchCV object xgb_grid and assigns it to the variable xgb_best_grid. The best_estimator_ attribute of the GridSearchCV object is the model that performed the best according to the chosen evaluation metric and hyperparameter search space.

print('Hyperparameter tuning time for for: XGB: ', str(xgb_hyper_time))
print('\n')

print('Running Hyperparameter Tuning for RF')
rf_model = RandomForestRegressor()
rf_grid = GridSearchCV(rf_model, rf_params, cv=4, n_jobs=-1, verbose=True)

# record time
rf_start = time.time()
rf_grid.fit(X_train_reg, y_train_reg.values.ravel())
rf_hyper_time = time.time()-rf_start

# extract best grid
rf_best_grid = rf_grid.best_estimator_

print('Hyperparameter tuning time for for: RF: ', str(rf_hyper_time))
print('\n')

print('Running Hyperparameter Tuning for SV')
'''
Your Code Here
'''

# record time
'''
Your Code Here
'''
SV_grid.fit(X_train_reg, y_train_reg.values.ravel())
'''
Your Code Here
'''

# extract best grid and params
SV_best_grid = SV_grid.best_estimator_

print('Hyperparameter tuning time for for: SV: ', str(SV_hyper_time))
print('\n')

# Hyperparameter Tuning for ensemble model using the "Best Grid for SGB, RF, SV"

print('Running Hyperparameter Tuning for ensemble')
voting_model = VotingRegressor(estimators=[('xgb', xgb_best_grid), ('rf', rf_best_grid), ('SV', SV_best_grid)])
# This line defines a voting regressor model (voting_model) that combines three base models: XGBoost (xgb_best_grid), Random Forest (rf_best_grid), and Support Vector Regression (SV_best_grid). The estimators parameter takes a list of tuples, where each tuple contains the name of the model and the model object.

ensemble_grid = GridSearchCV(voting_model, ensemble_params, cv=4, n_jobs=-1, verbose=True)

# record time
ensemble_start = time.time()
ensemble_grid.fit(X_train_reg, y_train_reg.values.ravel())
ensemble_hyper_time = time.time()-ensemble_start

# extract best params
ensemble_best_params = ensemble_grid.best_params_

print('Hyperparameter tuning time for for: ensemble model: ', str(ensemble_hyper_time))
print('\n')

ti_train = pd.DataFrame(X_train_reg_0, columns=columns_for_regression_train)
ti_train['wait_time'] = y_train_reg_0['wait_time'].values
# These lines create a new Pandas DataFrame called ti_train by combining the training data (X_train_reg_0) and the corresponding target variable (y_train_reg_0['wait_time']).

for data_size in [8192, 32768]:
# This line sets up a loop to train the ensemble model on two different data sizes.

    ti_train_section = ti_train.sample(data_size, random_state=42)
    # This line randomly samples data_size rows from the ti_train DataFrame and creates a new DataFrame called ti_train_section.

    X_train_reg = ti_train_section[columns_for_regression_train]
    y_train_reg = ti_train_section[columns_for_regression_pred]
    # These lines create the feature matrix X_train_reg and the target vector y_train_reg for the current ti_train_section DataFrame.

    print('Running Training for ensemble model with data length ', str(data_size))

    voting_model = VotingRegressor(estimators=[('xgb', xgb_best_grid), ('rf', rf_best_grid), ('SV', SV_best_grid)],
                                   n_jobs=-1, weights=ensemble_best_params['weights'])
    # This line creates a new ensemble model using the VotingRegressor class from scikit-learn, and specifying the three models to be used as inputs.

    ensemble_model_train_start = time.time()
    # This line calculates the training time for the ensemble model on the current ti_train_section.

    voting_model.fit(X_train_reg, y_train_reg.values.ravel())
    # This line fits the ensemble model to the current ti_train_section DataFrame. 

    ensemble_model_train_time = time.time() - ensemble_model_train_start
    # This line calculates the training time for the ensemble model on the current ti_train_section.

    print('Training time for for: ensemble model: ', str(ensemble_model_train_time))
    print('\n')

ti_test_base = pd.DataFrame(X_test_reg_0, columns=columns_for_regression_train)
ti_test_base['wait_time'] = y_test_reg_0['wait_time'].values
# These lines create a Pandas DataFrame ti_test_base from the test features X_test_reg_0 and labels y_test_reg_0 for a regression problem. The column names are specified by columns_for_regression_train. The label column "wait_time" is added to the DataFrame.

ti_test = pd.concat([ti_test_base, ti_test_base, ti_test_base, ti_test_base])
# This line concatenates the ti_test_base DataFrame with itself four times to create a larger test dataset ti_test with four times as many rows as the original ti_test_base. This is a common technique for increasing the size of a small test dataset to improve the reliability of model performance estimates.

print(list(ti_test.iloc[1:]))
# This line prints a list of the values in the ti_test DataFrame starting from the second row. This is useful for inspecting the content of the DataFrame.

print(list(ti_test.iloc[9]))
# This line prints a list of the values in the 10th row of the ti_test DataFrame. This is useful for inspecting the content of a specific row in the DataFrame.

modelfile = "voting_model.pkl"
pickle.dump(voting_model, open(modelfile, 'wb'))  # nosec
# These lines save the trained voting_model to a file called "voting_model.pkl" using the pickle module.

voting_model = pickle.load(open(modelfile, 'rb'))  # nosec
# This line loads the trained voting_model from the "voting_model.pkl" file.

ti_test_section = ti_test.sample(1000, random_state=42)
# This line creates a smaller sample dataset of ti_test called ti_test_section by randomly selecting 1000 rows from the original dataset using a random seed of 42.

lst_of_stream_times = []
for _counter in range(1000):
    sample_df = ti_test_section.sample(n=1)
    X_test_reg = sample_df[columns_for_regression_train]
    y_test_reg = sample_df[columns_for_regression_pred]
    ensemble_mse, ensemble_pred_time = ensemble_predict_reg(voting_model, X_test_reg, y_test_reg)  # pylint: disable=W0612
    lst_of_stream_times.append(ensemble_pred_time)
    # These lines loop through the ti_test_section dataset 1000 times, randomly selecting one row each time and using it to evaluate the voting regressor model's inference time. The results are stored in a list called lst_of_stream_times.

avg_stream_time = sum(lst_of_stream_times)/len(lst_of_stream_times)
print("Average Streaming Inference Time for Voting Regressor model: ", str(avg_stream_time))
# This line calculates the average inference time for the voting regressor model over the 1000 iterations and prints the result to the console.

for data_size in [10000, 30000, 50000, 70000]:
# This line sets up a loop that iterates over a list of data sizes.

    ti_test_section = ti_test.sample(data_size, random_state=42)
    # This line creates a random subset of the test data, with the number of rows specified by data_size.

    X_test_reg = ti_test_section[columns_for_regression_train]
    y_test_reg = ti_test_section[columns_for_regression_pred]
    # These lines define the input features (X_test_reg) and output target (y_test_reg) for the regression models. The feature and target columns are specified by columns_for_regression_train and columns_for_regression_pred, respectively.

    # Perform prediction - refer to ensemble train function in utils
    xgb_mse, xgb_pred_time = xgb_predict_reg(xgb_best_grid, X_test_reg, y_test_reg)
    rf_mse, rf_pred_time = rf_predict_reg(rf_best_grid, X_test_reg, y_test_reg)
    '''
    Your Code Here
    '''
    # These lines perform predictions using four machine learning models (xgb_best_grid, rf_best_grid, SV_best_grid, and voting_model) on the subset of test data (X_test_reg and y_test_reg). The functions xgb_predict_reg, rf_predict_reg, SV_predict_reg, and ensemble_predict_reg are used to make the predictions and return the mean squared error (*_mse) and prediction time (*_pred_time) for each model.

    print('Running Inference with data length ', str(data_size))
    print("Inference time and MSE for for XGB: ", ' '.join(map(str, list((xgb_pred_time, xgb_mse)))))
    print("Inference time and MSE for for RF: ", ' '.join(map(str, list((rf_pred_time, rf_mse)))))
    print("Inference time and MSE for for SV: ", ' '.join(map(str, list((SV_pred_time, SV_mse)))))
    print("Inference time and MSE for for Voting model: ", ' '.join(map(str, list((ensemble_pred_time, ensemble_mse)))))
    print('\n')
    # These lines print out the results of the predictions for each model, including the data size, inference time, and mean squared error. The results are printed in a formatted way using print statements and join and list functions.