Bike Share Demand Prediction in San Francisco

Introduction

I am going to predict the number of borrowed bikes in a given day and station by using 4 available data set below.

• station.csv - Contains data that represents a station where users can pick up or return bikes.
• status.csv - Data about the number of bikes and docks available for a given station and minute.
• trips.csv - Data about individual bike trips.
• weather.csv - Data about the weather on a specific day for specific station id.

Hypothesis Generation

What could effect people to rent a bike?

• Number of bikes
• Condition of the bikes
• Availablity of the bike roads around the station
• Daily Trend: weekdays as compared to weekend or holiday
• Hourly trend: office timings. Early morning and late evening
• Rain: The demand of bikes will be lower on a rainy day as compared to a sunny day
• Temperature: I presume it may have positive correlation
• Pollution: government / company policies
• Traffic: Higher traffic may force people to use bike as compared to others

Understanding the Data Set and EDA

I’ve already performed EDA on the data sets, you can access it via this link.

Install Necessary Packages

import pandas as pd
import numpy as np
from scipy.stats.stats import pearsonr  
from pandas.tseries.holiday import USFederalHolidayCalendar
from pandas.tseries.offsets import CustomBusinessDay
from datetime import datetime
from sklearn.model_selection import train_test_split
import math
import matplotlib.pyplot as plt
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import Pipeline
from sklearn.decomposition import PCA
from sklearn.pipeline import FeatureUnion
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, AdaBoostRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.metrics import mean_squared_error, median_absolute_error
from pandas.tseries.holiday import USFederalHolidayCalendar as calendar
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import StandardScaler

Loading Data Sets

df_trip = pd.read_csv("trip.csv")
df_station = pd.read_csv("station.csv")
df_weather = pd.read_csv("weather.csv")

Station Data Set

df_station

len(df_station.id.unique())

70

There are 70 different stations.

Trip Data Set

# Have a look at first 5 instance
df_trip.head()

# Number of instance and variables
df_trip.shape

(669959, 11)

# Checking for Missing Values
df_trip.isnull().sum()

id                       0
duration                 0
start_date               0
start_station_name       0
start_station_id         0
end_date                 0
end_station_name         0
end_station_id           0
bike_id                  0
subscription_type        0
zip_code              6619
dtype: int64

#Check dtypes
df_trip.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 669959 entries, 0 to 669958
Data columns (total 11 columns):
 #   Column              Non-Null Count   Dtype 
---  ------              --------------   ----- 
 0   id                  669959 non-null  int64 
 1   duration            669959 non-null  int64 
 2   start_date          669959 non-null  object
 3   start_station_name  669959 non-null  object
 4   start_station_id    669959 non-null  int64 
 5   end_date            669959 non-null  object
 6   end_station_name    669959 non-null  object
 7   end_station_id      669959 non-null  int64 
 8   bike_id             669959 non-null  int64 
 9   subscription_type   669959 non-null  object
 10  zip_code            663340 non-null  object
dtypes: int64(5), object(6)
memory usage: 56.2+ MB

#Create a new variable date from start_date
df_trip['date'] = df_trip.start_date
df_trip.date = pd.to_datetime(df_trip.start_date, format='%m/%d/%Y %H:%M')
df_trip['date'] = pd.to_datetime(df_trip['date'])

# Summary statistics
df_trip.describe()

Weather

df_weather

df_weather.events.unique()

array([nan, 'Fog', 'Rain', 'Fog-Rain', 'rain', 'Rain-Thunderstorm'],
      dtype=object)

df_weather.loc[df_weather.events == 'rain', 'events'] = "Rain"
df_weather.loc[df_weather.events.isnull(), 'events'] = "Normal"

df_weather.isnull().sum()

date                       0
start_station_id           0
zip_code                   0
mean_temperature_f         0
min_temperature_f          5
mean_humidity              0
max_humidity             105
mean_visibility_miles      0
min_visibility_miles      26
max_wind_Speed_mph         0
max_gust_speed_mph         2
precipitation_inches     252
events                     0
dtype: int64

#Fill null cells with lambda
df_weather = df_weather.apply(lambda x:x.fillna(x.value_counts().index[0]))

df_weather.isnull().sum()

date                     0
start_station_id         0
zip_code                 0
mean_temperature_f       0
min_temperature_f        0
mean_humidity            0
max_humidity             0
mean_visibility_miles    0
min_visibility_miles     0
max_wind_Speed_mph       0
max_gust_speed_mph       0
precipitation_inches     0
events                   0
dtype: int64

Data Preparation

• Prepare data set for prediction based on df_trip dataframe
• Drop unnecessary variables
• Data set should countain date and total number of daily trips from each stations
• Day,Mount,Year,Weekday,Holiday,Season variables need to be added
• Station data should be merged
• Weather data should be merged

#Drop unnecessary variables
df= df_trip.drop(['id','duration','start_date','start_station_name','end_date', 'end_station_name','end_station_id','bike_id','subscription_type', 'zip_code'], 1)

#Number of trips variable
df['date'] = df.date.dt.date
df = df.value_counts().to_frame('no_of_trips').reset_index()

#Sort by date
df = df.sort_values(by=['date'])
df.reset_index(drop=True, inplace=True)

df.head()

# We will make daily predictions, hours is not important
df['year'] = df_trip['date'].dt.year
df['month'] = df_trip['date'].dt.month
df['day'] = df_trip['date'].dt.day

# Variables added
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 43270 entries, 0 to 43269
Data columns (total 6 columns):
 #   Column            Non-Null Count  Dtype 
---  ------            --------------  ----- 
 0   start_station_id  43270 non-null  int64 
 1   date              43270 non-null  object
 2   no_of_trips       43270 non-null  int64 
 3   year              43270 non-null  int64 
 4   month             43270 non-null  int64 
 5   day               43270 non-null  int64 
dtypes: int64(5), object(1)
memory usage: 2.0+ MB

#Day name of the week
df['date'] = pd.to_datetime(df['date'])
df['day_name'] = df['date'].dt.day_name()

#Weekend
df['weekend'] = df['weekend'] = df['date'].dt.dayofweek > 4
df['weekend'] = df['weekend'].astype(object)

#Season variable
df['season'] = (df['date'].dt.month%12 + 3)//3

seasons = {
             1: 'Winter',
             2: 'Spring',
             3: 'Summer',
             4: 'Autumn'
}

df['season'] = df['season'].map(seasons)

#Find holidays
cal = calendar()
dr = pd.date_range(start='2013-07-01', end='2016-07-31')
holidays = cal.holidays(start=dr.min(), end=dr.max())

#Holiday variable
df['holiday'] = df['date'].dt.date.astype('datetime64').isin(holidays)
df['holiday'] = df['holiday'].astype(object)

# allign dtypes before merge
df['date'] = pd.to_datetime(df['date'])
df_station['installation_date'] = pd.to_datetime(df_station['installation_date'])
df_weather['date'] = pd.to_datetime(df_weather['date'])

#merge trips and station data
no_of_docks = []
for day in df.date:
    no_of_docks.append(sum(df_station[df_station.installation_date <= day].dock_count))
    
df['no_of_docks'] = no_of_docks

#merge trips and weather data
df = pd.merge(df, df_weather, on=['start_station_id','date'], how='left')

df.head()

df.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 43270 entries, 0 to 43269
Data columns (total 22 columns):
 #   Column                 Non-Null Count  Dtype         
---  ------                 --------------  -----         
 0   start_station_id       43270 non-null  int64         
 1   date                   43270 non-null  datetime64[ns]
 2   no_of_trips            43270 non-null  int64         
 3   year                   43270 non-null  int64         
 4   month                  43270 non-null  int64         
 5   day                    43270 non-null  int64         
 6   day_name               43270 non-null  object        
 7   weekend                43270 non-null  object        
 8   season                 43270 non-null  object        
 9   holiday                43270 non-null  object        
 10  no_of_docks            43270 non-null  int64         
 11  zip_code               43270 non-null  int64         
 12  mean_temperature_f     43270 non-null  float64       
 13  min_temperature_f      43270 non-null  float64       
 14  mean_humidity          43270 non-null  float64       
 15  max_humidity           43270 non-null  float64       
 16  mean_visibility_miles  43270 non-null  float64       
 17  min_visibility_miles   43270 non-null  float64       
 18  max_wind_Speed_mph     43270 non-null  float64       
 19  max_gust_speed_mph     43270 non-null  float64       
 20  precipitation_inches   43270 non-null  float64       
 21  events                 43270 non-null  object        
dtypes: datetime64[ns](1), float64(9), int64(7), object(5)
memory usage: 7.6+ MB

Feature Engineering

Standard Scaler for continous variables

scaler = StandardScaler()
df[['no_of_docks','mean_temperature_f', 'min_temperature_f', 'mean_humidity', 'max_humidity','mean_visibility_miles', 'min_visibility_miles', 'max_wind_Speed_mph', 'max_gust_speed_mph','max_gust_speed_mph']]=scaler.fit_transform(df[['no_of_docks','mean_temperature_f', 'min_temperature_f', 'mean_humidity', 'max_humidity','mean_visibility_miles', 'min_visibility_miles', 'max_wind_Speed_mph', 'max_gust_speed_mph','max_gust_speed_mph']].to_numpy())
df

One hot encoding for categorical variables

# Making dummy variables for categorical data with more inputs.  
data_dummy = pd.get_dummies(df[['day_name','weekend','season', 'holiday', 'events']])

# Output the first five rows.
data_dummy.head()

# Merging (concatenate) original data frame with 'dummy' dataframe.
df = pd.concat([df,data_dummy], axis=1)

# Dropping attributes for which we made dummy variables and zip_code
df = df.drop(['day_name','weekend','season', 'holiday', 'events','zip_code'], axis=1)
df.head()

df.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 43270 entries, 0 to 43269
Data columns (total 36 columns):
 #   Column                    Non-Null Count  Dtype         
---  ------                    --------------  -----         
 0   start_station_id          43270 non-null  int64         
 1   date                      43270 non-null  datetime64[ns]
 2   no_of_trips               43270 non-null  int64         
 3   year                      43270 non-null  int64         
 4   month                     43270 non-null  int64         
 5   day                       43270 non-null  int64         
 6   no_of_docks               43270 non-null  float64       
 7   mean_temperature_f        43270 non-null  float64       
 8   min_temperature_f         43270 non-null  float64       
 9   mean_humidity             43270 non-null  float64       
 10  max_humidity              43270 non-null  float64       
 11  mean_visibility_miles     43270 non-null  float64       
 12  min_visibility_miles      43270 non-null  float64       
 13  max_wind_Speed_mph        43270 non-null  float64       
 14  max_gust_speed_mph        43270 non-null  float64       
 15  precipitation_inches      43270 non-null  float64       
 16  day_name_Friday           43270 non-null  uint8         
 17  day_name_Monday           43270 non-null  uint8         
 18  day_name_Saturday         43270 non-null  uint8         
 19  day_name_Sunday           43270 non-null  uint8         
 20  day_name_Thursday         43270 non-null  uint8         
 21  day_name_Tuesday          43270 non-null  uint8         
 22  day_name_Wednesday        43270 non-null  uint8         
 23  weekend_False             43270 non-null  uint8         
 24  weekend_True              43270 non-null  uint8         
 25  season_Autumn             43270 non-null  uint8         
 26  season_Spring             43270 non-null  uint8         
 27  season_Summer             43270 non-null  uint8         
 28  season_Winter             43270 non-null  uint8         
 29  holiday_False             43270 non-null  uint8         
 30  holiday_True              43270 non-null  uint8         
 31  events_Fog                43270 non-null  uint8         
 32  events_Fog-Rain           43270 non-null  uint8         
 33  events_Normal             43270 non-null  uint8         
 34  events_Rain               43270 non-null  uint8         
 35  events_Rain-Thunderstorm  43270 non-null  uint8         
dtypes: datetime64[ns](1), float64(10), int64(5), uint8(20)
memory usage: 6.4 MB

Model Building

labels = df.no_of_trips
train = df.drop(['no_of_trips', 'date'], 1)

X_train, X_test, y_train, y_test = train_test_split(train, labels, test_size=0.2, random_state = 2)

Random Forest Regressor

rfr = RandomForestRegressor(n_estimators = 55,
                            min_samples_leaf = 3,
                            random_state = 2)
rfr = rfr.fit(X_train, y_train)

Ada Boost Regressor

abr = AdaBoostRegressor(n_estimators = 100,
                        learning_rate = 0.1,
                        loss = 'linear',
                        random_state = 2)

GradientBoostingRegressor

gbr = GradientBoostingRegressor(learning_rate = 0.12,
                                n_estimators = 55,
                                max_depth = 5,
                                min_samples_leaf = 1,
                                random_state = 2)

Scoring the Models

scoring = ['r2','neg_mean_squared_error','neg_mean_absolute_error']
models = [rfr,abr,gbr]

for model in models:
    for i in scoring:
        scores = cross_val_score( model, X_train, y_train, cv=5, scoring = i)
    #    print(scores)
        if i == 'r2':
            print(model, i, ': ', scores.mean())
        elif i == 'neg_mean_squared_error':    
            x = -1*scores.mean()
            y = math.sqrt(x) 
            print(model, 'RMSE: ', "%0.2f" % y)
        elif i == 'neg_mean_absolute_error':
            x = -1*scores.mean()
            print(model,i, ": %0.2f (+/- %0.2f)" % (x, scores.std() * 2))   

RandomForestRegressor(min_samples_leaf=3, n_estimators=55, random_state=2) r2 :  0.9059889252171234
RandomForestRegressor(min_samples_leaf=3, n_estimators=55, random_state=2) RMSE:  5.43
RandomForestRegressor(min_samples_leaf=3, n_estimators=55, random_state=2) neg_mean_absolute_error : 3.39 (+/- 0.11)
AdaBoostRegressor(learning_rate=0.1, n_estimators=100, random_state=2) r2 :  0.6193340252543343
AdaBoostRegressor(learning_rate=0.1, n_estimators=100, random_state=2) RMSE:  10.93
AdaBoostRegressor(learning_rate=0.1, n_estimators=100, random_state=2) neg_mean_absolute_error : 7.74 (+/- 0.23)
GradientBoostingRegressor(learning_rate=0.12, max_depth=5, n_estimators=55,
                          random_state=2) r2 :  0.8729724087591497
GradientBoostingRegressor(learning_rate=0.12, max_depth=5, n_estimators=55,
                          random_state=2) RMSE:  6.32
GradientBoostingRegressor(learning_rate=0.12, max_depth=5, n_estimators=55,
                          random_state=2) neg_mean_absolute_error : 4.12 (+/- 0.08)

#Fit and predict with the best model
rfr = rfr.fit(X_train, y_train)
rfr_preds = rfr.predict(X_test)

#Visualize
y_test.reset_index(drop = True, inplace = True)
fs = 30
plt.figure(figsize=(50,20))
plt.plot(rfr_preds)
plt.plot(y_test)
plt.legend(['Prediction', 'Acutal'])
plt.ylabel("Number of Trips", fontsize = fs)
plt.xlabel("Predicted Date", fontsize = fs)
plt.title("Predicted Values vs Actual Values", fontsize = fs)
plt.show()

#Features by importance
def plot_importances(model, model_name):
    importances = model.feature_importances_
    std = np.std([model.feature_importances_ for feature in model.estimators_],
                 axis=0)
    indices = np.argsort(importances)[::-1]    

    # Plot the feature importances of the forest
    plt.figure(figsize = (12,5))
    plt.title("Feature importances of " + model_name)
    plt.bar(range(X_train.shape[1]), importances[indices], color="r", align="center")
    plt.xticks(range(X_train.shape[1]), indices)
    plt.xlim([-1, X_train.shape[1]])
    plt.show()

print("Feature ranking:")

i = 0
for feature in X_train:
    print (i, feature)
    i += 1
    
plot_importances(rfr, "RandomForestRegressor")

Feature ranking:
0 start_station_id
1 year
2 month
3 day
4 no_of_docks
5 mean_temperature_f
6 min_temperature_f
7 mean_humidity
8 max_humidity
9 mean_visibility_miles
10 min_visibility_miles
11 max_wind_Speed_mph
12 max_gust_speed_mph
13 precipitation_inches
14 day_name_Friday
15 day_name_Monday
16 day_name_Saturday
17 day_name_Sunday
18 day_name_Thursday
19 day_name_Tuesday
20 day_name_Wednesday
21 weekend_False
22 weekend_True
23 season_Autumn
24 season_Spring
25 season_Summer
26 season_Winter
27 holiday_False
28 holiday_True
29 events_Fog
30 events_Fog-Rain
31 events_Normal
32 events_Rain
33 events_Rain-Thunderstorm

Question: Can you predict the demand for bikes in a given station day in advance?

If yes, what arethe main factors contributing to the predictions? Would this model be actionable to business? The model should be basic, the only requirement is that it should be interpretable.

Answer: Yes

Station, weekday/weekend info, number of docks, mean_temperature, day. If this model is improved, it can be actionable to business. Bike and docks number can be increased for the station which the prediction model interprets the demand will be higher. Or, for the stations with low number predicted demand may be considered to close down.

Question: What are 3 additional pieces of information you would recommend to add to these datasets to gain more insight into the business and usage of this product?

Answer:

• Condition of the bikes
• Population in the region of the station
• Traffic data
• Availablity of the bike roads in the region of the station
• Polution
• Average bike prices in the region