Tree-based Machine Learning Model¶

The New York City Taxi & Limousine Commission

In this project, we are the Data Analyst at the New York City Taxi & Limousine Commission (New York City TLC), and we have been requested to build a machine learning model to predict if a customer will not leave a tip. They want to use the model in an app that will alert taxi drivers to customers who are unlikely to tip, since drivers depend on tips.

Objective¶

We will employ the tree-based modeling techniques to predict on a binary target class.
The purpose of this model is to find ways to generate more revenue for taxi cab drivers.
The goal of this model is to predict whether or not a customer is a generous tipper.

Part 1: Ethical considerations

• Consider the ethical implications of the request

• Revisit the project objective

Part 2: Feature engineering

• Perform feature selection, extraction, and transformation to prepare the data for modeling

Part 3: Modeling

• Build the models, evaluate them, and advise on next steps

PACE stages: Plan, Analyze, Construct, and Execute¶

Plan¶

In this stage, let's consider the following questions:

1. What is the main purpose of the task?

2. What are the ethical implications of the model?

3. Do the benefits of such a model outweigh the potential problems?

4. Should we proceed with the request to build this model? Why or why not?

5. Can the objective be modified to make it less problematic?

Responses¶

• If our model focus whether a customer will tip or not, then it might end up making it difficult for customers, who can't afford to tip, to find a taxi, i.e. even if the model is correct, it will limit the accessibility of taxi service.
• If Drivers are told by the app that a customer will leave a tip but the customer doesn't, then the drivers will not trust or use the app.
• To make this prediction, ideally, we'd have behavourial history for each customer so we can predict if they will tip based on their previous rides.
• The target variable would be a binary variable (1 or 0) that indictates whether a customer is expected to tip or more than 20%.

Actions¶

• Instead of predicting whether people will or will not tip, we can predict if people are generous tipper.
• Those who tip 20% or more are considered generous.

Step 1. Imports and data loading¶

Import packages and libraries needed to build and evaluate random forest and XGBoost classification models.

Inspect the first few rows of df0.

Inspect the first few rows of nyc_preds_means.

Join the two dataframes¶

Join the two dataframes using a method of your choice.

Analyze¶

Step 2. Feature engineering¶

Upon completion of EDA, let's inspect the newly combined dataframe.

We know from our EDA that customers who pay cash generally have a tip amount of $0. To meet the modeling objective, we'll need to sample the data to select only the customers who pay with credit card.

Let's copy df0 and assign the result to a variable called df1. Then, use a Boolean mask to filter df1 so it contains only customers who paid with credit card.

Target¶

Let's add a tip_percent column to the dataframe by performing the following calculation:

Purpose: the customers who tip ≥ 20% are considered generous.

Now that we have a tip_percent column, we can add a binary indicator to identify if each customer is generous (tipped more than 20% will be 1= yes, otherwise, 0 = no).

Create day column¶

Let's convert the tpep_pickup_datetime and tpep_dropoff_datetime columns to datetime.

Now, create a day column that contains only the day of the week when each passenger was picked up. Then, convert the values to lowercase.

Create time of day columns¶

Next, engineer four new columns that represent time of day bins. Each column should contain binary values (0=no, 1=yes) that indicate whether a trip began (picked up) during the following times:

am_rush = [06:00–10:00)
daytime = [10:00–16:00)
pm_rush = [16:00–20:00)
nighttime = [20:00–06:00)

To do this, first create the four columns. For now, each new column should be identical and contain the same information: the hour (only) from the tpep_pickup_datetime column.

Create month column¶

Now, create a month column that contains only the abbreviated name of the month when each passenger was picked up, then convert the result to lowercase.

Examine the first five rows of your dataframe.

Drop columns¶

Drop redundant and irrelevant columns as well as those that would not be available when the model is deployed. This includes information like payment type, trip distance, tip amount, tip percentage, total amount, toll amount, etc. The target variable (generous) must remain in the data because it will get isolated as the y data for modeling.

Variable encoding¶

Many of the columns are categorical and will need to be dummied (converted to binary). Some of these columns are numeric, but they actually encode categorical information, such as RatecodeID and the pickup and dropoff locations. To make these columns recognizable to the get_dummies() function as categorical variables, we'll first need to convert them to type(str).

1. Define a variable called cols_to_str, which is a list of the numeric columns that contain categorical information and must be converted to string: RatecodeID, PULocationID, DOLocationID.
2. Write a for loop that converts each column in cols_to_str to string.

Now convert all the categorical columns to binary.

1. Call get_dummies() on the dataframe and assign the results back to a new dataframe called df2.

Evaluation metric¶

Before modeling, we must decide on an evaluation metric.

1. Examine the class balance of your target variable.

A little over half of the customers in this dataset were "generous" (tipped ≥ 20%). The dataset is very nearly balanced.

To determine a metric, consider the cost of both kinds of model error:

• False positives (the model predicts a tip ≥ 20%, but the customer does not give one)
• False negatives (the model predicts a tip < 20%, but the customer gives more)

False positives are worse for cab drivers, because they would pick up a customer expecting a good tip and then not receive one, frustrating the driver.

False negatives are worse for customers, because a cab driver would likely pick up a different customer who was predicted to tip more—even when the original customer would have tipped generously.

**The stakes are relatively even. We want to help taxi drivers make more money, but we don't want this to anger customers. Our metric should weigh both precision and recall equally.

Construct¶

Step 3. Modeling¶

Split the data¶

Now you're ready to model. The only remaining step is to split the data into features/target variable and training/testing data.

1. Define a variable y that isolates the target variable (generous).
2. Define a variable X that isolates the features.
3. Split the data into training and testing sets. Put 20% of the samples into the test set, stratify the data, and set the random state.

Random forest¶

Begin with using GridSearchCV to tune a random forest model.

1. Instantiate the random forest classifier rf and set the random state.

2. Create a dictionary cv_params of any of the following hyperparameters and their corresponding values to tune. The more you tune, the better your model will fit the data, but the longer it will take.

• max_depth
• max_features
• max_samples
• min_samples_leaf
• min_samples_split
• n_estimators

3. Define a set scoring of scoring metrics for GridSearch to capture (precision, recall, F1 score, and accuracy).

4. Instantiate the GridSearchCV object rf1. Pass to it as arguments:

• estimator=rf
• param_grid=cv_params
• scoring=scoring
• cv: define the number of you cross-validation folds you want (cv=_)
• refit: indicate which evaluation metric you want to use to select the model (refit=_)

Note: refit should be set to 'f1'.