摩拜单车出行目的地分析---出行

背景简介

摩拜单车自推出以来，深受用户喜爱，在很多城市已经成为除公共交通以外的居民首选的 出行方式，大大减轻了城市路网压力和拥堵情况。随着绿色出行和环保观念的深入人心， 将会有更多的用户选择摩拜单车，进一步实现让自行车回归城市的目标。同时，摩拜致力于应用前沿科技的帮助人们更好地出行，利用机器学习去预测用户的出行目的地便是众多 应用场景中重要的一个。

目前，摩拜单车在北京的单车投放量已经超过40万。用户可以直接在人行道上找到停放的单车，用手机解锁，然后骑到目的地后再把单车停好并锁上。因此，为了更好地调配和管理这40万辆单车，需要准确地预测每个用户的骑行目的地。

比赛官网

任务描述

参赛者需要根据摩拜提供的数据，预测骑行的目的地所在区块。

比赛地训练集取北京某一区域的一段时间内的部分数据，测试集为同一区域未来一段时间的数据。训练集的将划分为public set和private set划分。比赛过程中，选手将只能看到public set的分数，但比赛的最终排名将由private set的分数决定。

标注数据中包含300万条出行记录数据，覆盖超过30万用户和40万摩拜单车。数据包括骑行起始时间和地点、车辆ID、车辆类型和用户ID等信息。参赛选手需要预测骑行目的地的区块位置。

认识数据

加载模块

import pandas as pd
import seaborn as sns
import geohash                            # 需要将脚本文件geohash.sh置于当前目录下
import matplotlib.pyplot as plt
from math import radians, cos, sin, asin, sqrt

初探数据

# parase_date是有作用的，将字符串类型转换成了Timestamp类型
train = pd.read_csv('train.csv', sep=',', parse_dates=['starttime'])
test = pd.read_csv('test.csv', sep=',', parse_dates=['starttime']) 
train.head()

test.head()

print(train.shape)      # (3214096, 7)
print(test.shape)       # (2002996, 6)

因为数据量太大（321万条数据），为了使模型更快的跑出结果，我们可以考虑减少一半的数据量，即进行随机抽样操作。（这个操作可以根据需要做或不做，我自己在实践的时候，取的是全部的数据。）

train = train.sample(frac=0.5)     # 随机50%

认识GeoHash

抛出问题

点外卖的时候软件是怎么返回最近的餐馆的？难道是每个餐馆和用户之间计算距离排序吗？（这样的计算量着实太大，毕竟用户太多，餐馆太多）

一个好的解决方案是分区块，想象一个三行三列的表格，只返回周边的8个块和自身的一个块内的餐馆数据。

那只返回一个区块内的餐馆行不行？我们考虑下面这种情况（红点表示用户的位置，黑点表示餐馆的位置），很明显，1，2，4区块内相较于区块5存在距离用户更近的餐馆，我们应该优先返回。

解决方案

1. GeoHash将二维的经纬度转换成字符串，比如下图展示了北京9个区域的GeoHash字符串，分别是WX4ER，WX4G2、WX4G3等等，每一个字符串代表了某一矩形区域。也就是说，这个矩形区域内所有的点（经纬度坐标）都共享相同的GeoHash字符串，这样既可以保护隐私（只表示大概区域位置而不是具体的点），又比较容易做缓存，比如左上角这个区域内的用户不断发送位置信息请求餐馆数据，由于这些用户的GeoHash字符串都是WX4ER，所以可以把WX4ER当作key，把该区域的餐馆信息当作value来进行缓存，而如果不使用GeoHash的话，由于区域内的用户传来的经纬度是各不相同的，很难做缓存。
2. 字符串越长，表示的范围越精确。如图所示，5位的编码能表示10平方千米范围的矩形区域，而6位编码能表示更精细的区域（约0.34平方千米）

3. 字符串相似的表示距离相近，这样可以利用字符串的前缀匹配来查询附近的POI信息

                                   ![](https://cdn.nlark.com/yuque/0/2020/png/706453/1580560866805-f877cd29-1a32-443a-8109-857cdcede222.png#align=left&display=inline&height=237&margin=%5Bobject%20Object%5D&originHeight=237&originWidth=234&size=0&status=done&style=none&width=234)

数据清洗

时间处理

我们想，根据正常的逻辑，用户出行肯定存在早晚高峰，工作日与非工作日的出行规律肯定也不一样。

# 0 Monday 6 Sunday
train['weekday'] = train['starttime'].apply(lambda t: t.weekday()) 
train['hour'] = train['starttime'].apply(lambda t: t.hour)
train['day'] = train['starttime'].apply(lambda t: str(t)[:10])
train.head()

通常情况下，我们并不直接修改原始数据，我们把数据copy给另一个变量。

kv = dict()
for a, b in zip(list(range(7)), ['周一','周二','周三','周四','周五','周六','周日']):
    kv[a] = b
df = train.loc[:,:'geohashed_end_loc']
df['date'] = train['day']
df['weekday'] = train['weekday'].apply(lambda d: kv.get(d))
df['hour'] = train['hour'].apply(lambda h: str(h) + '时')
df.head()

区块decode

数据集中只记录了用户起始和终止的区块位置信息，这样子我们是没有办法计算用户的出行距离的。要想计算出行距离，就得将区块转换成经纬度，这样子才好计算距离。

我们之前导入的脚本geohash.sh就是用来干这个事情的。

df['start_lat_lng'] = df['geohashed_start_loc'].apply(lambda s: geohash.decode(s))
df.head()

df['end_lat_lng'] = df['geohashed_end_loc'].apply(lambda s: geohash.decode(s))

对终点也作一个区块字符串的decode操作。

区块邻居

摩拜单车的定位是短途出行，用户有没有可能只是骑到了邻边的区块呢？（这一点不容易想到，可能需要一定的经验）

df['start_neighbors'] = df['geohashed_start_loc'].apply(lambda n: geohash.neighbors(n))

区块扩大(6)

上面我们已经知道，6位编码的区块距离大约在0.34平方千米，数据集中的区块编码是7位，如果用户骑车超过了7位编码的邻边区块，那有没有超过6位编码的邻边区块呢？（区块的范围更大了，编码越少范围越大）

df['geohashed_start_loc_6'] = df['geohashed_start_loc'].apply(lambda s: s[:6])
df['geohashed_end_loc_6'] = df['geohashed_end_loc'].apply(lambda s: s[:6])
df['start_neighbors_6'] = df['geohashed_start_loc_6'].apply(lambda s: geohash.neighbors(s))
df.head()

定义一个方法，判断是否在邻居区块（包括中心区块），append方法就是把中心区块添加进来。

def inGeohash(start_geohash, end_geohash, names):
    names.append(start_geohash)
    if end_geohash in names:
        return 1
    else:
        return 0
# 判断出行目的地是否在7位编码的周边区块（包括自身）
df['inside'] = df.apply(lambda s: inGeohash(s['geohashed_start_loc'], s['geohashed_end_loc'], s['start_neighbors']), axis=1)
# 判断出行目的地是否在6位编码的周边区块（包括自身）
df['inside_6'] = df.apply(lambda s: inGeohash(s['geohashed_start_loc_6'], s['geohashed_end_loc_6'], s['start_neighbors_6']), axis=1)

我们来看一下用户出行目的地在邻居区块的占比为多少？

# 7位编码
print(df[df['inside'] != 0].shape[0] / df.shape[0])      # 0.06702942289216003
# 6位编码
print(df[df['inside_6'] != 0].shape[0] / df.shape[0])    # 0.8145291864337593

打印输出，我们可以看到，目的地在7位编码邻居区块的占比约为6.8%，在6位编码邻居区块的占比约为81.5%。

计算距离

def distance(lon1, lat1, lon2, lat2):
     # lon1, lat1, lon2, lat2 = [radians(i) for i in  [lon1, lat1, lon2, lat2]]
    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
    c = 2 * asin(sqrt(a))
    r = 6371
    return c * r * 1000
df['start_end_distance'] = df.apply(lambda s: distance(s['start_lat_lng'][1], s['start_lat_lng'][0], s['end_lat_lng'][1], s['end_lat_lng'][0]), axis = 1)
df.head()

区块扩大(5)

df['geohashed_start_loc_5'] = df['geohashed_start_loc'].apply(lambda s: s[:5])
df['geohashed_end_loc_5'] = df['geohashed_end_loc'].apply(lambda s: s[:5])
df['start_neighbors_5'] = df['geohashed_start_loc_5'].apply(lambda s: geohash.neighbors(s))
df['inside_5'] = df.apply(lambda s: inGeohash(s['geohashed_start_loc_5'], s['geohashed_end_loc_5'], s['start_neighbors_5']), axis=1)
df.head()

5 rows × 23 columns

df[df['inside_5'] == 1].shape[0] / df.shape[0]        # 0.9976478611715394

将近是百分之百了，因为5位编码的区块范围已经是非常大了，大部分用户不会骑行那么远。

至此，我们的数据清洗步骤算是告一段落了

数据清洗是脏活累活，就看谁更加细心，能发掘到更多的信息。

数据分析

时间层面分析

问题一：一天之中不同小时内出发的订单数量有规律吗？

猜想：应该存在早高峰和晚高峰

g1 = df.groupby('hour')
# print(g1['orderid'].count().sort_values(ascending=False))
# 这两行代码的输出是等价的
g1.size().sort_values(ascending=False)

执行

hour
7时     316142
18时    290294
8时     285078
17时    273240
19时    209194
12时    199831
16时    179272
11时    172365
13时    163768
15时    155011
20时    151748
9时     148047
14时    136380
21时    127221
10时    126796
6时     121711
22时     69905
5时      29082
23时     28489
0时      13306
1时       6216
4时       4397
2时       3714
3时       2889
dtype: int64

我们可以清楚的观察到：早上七八点和晚上五六点，用户出行达到了一个顶峰。

下面通过图形化的方式来展现一下。

hour_group = df.groupby(['hour'])
hour_group = hour_group.size()
# 去掉汉字“时”
hour_group.index = hour_group.index.str[:-1]
hour_group = hour_group.reset_index()
# 转为int类型
hour_group['hour'] = hour_group['hour'].apply(lambda s: int(s))
hour_group = hour_group.sort_values(by = ['hour'], ascending=True)
sns.barplot(x='hour', y=0, data=hour_group)

执行

<matplotlib.axes._subplots.AxesSubplot at 0x1be7cbb208>

问题二：工作日与非工作日，用户出行的时间规律相同吗？

猜想：不同，工作日存在早晚高峰，非工作日可能就不存在了。

df['date'].unique()

执行

array(['2017-05-14', '2017-05-15', '2017-05-16', '2017-05-12',
       '2017-05-13', '2017-05-10', '2017-05-11', '2017-05-18',
       '2017-05-19', '2017-05-23', '2017-05-24', '2017-05-20',
       '2017-05-22', '2017-05-21'], dtype=object)

这里需要注意一点：数据集中工作日和非工作日的天数是不同的，我们不能简单的通过类似分析小时出行规律的思路来进行分析（也就是说不能简单的进行求和操作）。

Step 1: 添加一个字段，标志该天是否是周末

# 如果是周末，
df.loc[(df['weekday'] == '周六') | (df['weekday'] == '周日'), 'isWeekend'] = 1
df.loc[~((df['weekday'] == '周六') | (df['weekday'] == '周日')), 'isWeekend'] = 0

g1 = df.groupby(['isWeekend', 'hour'])

# g1['orderid'].count()
# 这两行代码输出的结果是等价的
g1.size()

执行

isWeekend  hour
0.0        0时        8512
           10时      69111
           11时     119007
           12时     148773
           13时     116841
           14时      90993
           15时     103856
           16时     126100
           17时     220159
           18时     230770
           19时     163303
           1时        3865
           20时     116924
           21时      91756
           22时      50128
           23时      20623
           2时        2420
           3时        1915
           4时        3089
           5时       21895
           6时      101157
           7时      273009
           8时      226845
           9时       97571
1.0        0时        4794
           10时      57685
           11时      53358
           12时      51058
           13时      46927
           14时      45387
           15时      51155
           16时      53172
           17时      53081
           18时      59524
           19时      45891
           1时        2351
           20时      34824
           21时      35465
           22时      19777
           23时       7866
           2时        1294
           3时         974
           4时        1308
           5时        7187
           6时       20554
           7时       43133
           8时       58233
           9时       50476
dtype: int64

这样的输出参考意义并不大，因为还是上面我们提到的一点，本身数据集中工作日与非工作日的天数就不同，这样简单的累加是非常不公平的，或许我们可以通过计算平均数来进行分析

Step 2: 计算数据集中工作日与非工作日的天数

g2 = df.groupby(['date', 'weekday'])

w = 0 # 周末天数
c = 0 # 工作日天数

for i, j in list(g2.groups.keys()):
    if j in ['周一','周二','周三','周四','周五']:
        c += 1
    else:
        w += 1

计算结果为工作日c为10天，非工作日w为4天。

Step 3: 计算平均值(给予相同的权重)

temp_df = pd.DataFrame(g1.size()).reset_index()

temp_df.head()

执行

# 举例，因为统计的是每个工作日0点的订单数，所以除以工作日的天数，就是平均每个工作日0点的订单数
temp_df.loc[temp_df['isWeekend'] == 0.0, 'orderid'] = temp_df[0] / c

temp_df.loc[temp_df['isWeekend'] == 1.0, 'orderid'] = temp_df[0] / w

temp_df.sort_values(['isWeekend', 'orderid'], ascending=False)

执行

单纯看这个输出的表格，我们可能一时看不出明显的规律，这个时候，就需要我们的可视化工具了。

pylab.rcParams['figure.figsize'] = (10, 7) # 两个参数对应行，列

temp_df['hour'] = temp_df['hour'].str[:-1]

temp_df['hour'] = temp_df['hour'].apply(lambda s: int(s))

temp_df = temp_df.sort_values(['isWeekend', 'hour'], ascending=True)

sns.barplot(x = 'hour', y = 'orderid', hue='isWeekend', data=temp_df)

执行

<matplotlib.axes._subplots.AxesSubplot at 0x1be76e5f28>

从这个图中我们可以明显看到，周末的出行规律基本上是持平的，不存在什么早晚高峰。只有工作日才存在早晚高峰。

我们得出结论：出行时间和是否是工作日这两个特征，对用户的出行有着重要影响。

距离自身分析

结合项目的目标：预测出行的目的地，那与目的地相关的特征有哪些呢？很重要的一个特征就是：距离

df['distance'] = df['start_end_distance'].apply(lambda s: int(s))
df.head()

执行

5 rows × 25 columns

我们查看一个距离这个特征的描述，比如大部分数据都在什么范围内，有没有很明显的异常值呀

即调用一下describe方法

df['distance'].describe()

执行

count    3.214096e+06
mean     8.142738e+02
std      6.864847e+02
min      1.160000e+02
25%      4.650000e+02
50%      6.600000e+02
75%      9.490000e+02
max      4.490000e+04
Name: distance, dtype: float64

我们可以看到，在当前的数据集下，有75%的用户出行距离在950米以内，平均的出行距离在814米。

sns.distplot(df['start_end_distance'])

执行

<matplotlib.axes._subplots.AxesSubplot at 0x1be7e00550>

# 通过对百分位数的观察 我们发现 75%的用户出行距离在950米以内 
# 因此我们剔除掉距离过大的异常值，只保留5公里以内的数据点

start_end_distance = df['start_end_distance']
start_end_distance = start_end_distance.loc[start_end_distance < 5000]
sns.distplot(start_end_distance)

执行

<matplotlib.axes._subplots.AxesSubplot at 0x1be7de96a0>

距离与小时

不同小时内，用户骑行的距离是否有区别呢?

hour_group = df.groupby(['hour'])
hour_group = hour_group.agg({"start_end_distance": 'mean'})

# 去掉汉字“时”
hour_group.index = hour_group.index.str[:-1]
hour_group = hour_group.reset_index()

# 转为int类型
hour_group['hour'] = hour_group['hour'].apply(lambda s: int(s))
hour_group.sort_values(['hour'], ascending=True)

hour_group

执行

sns.barplot(x='hour', y='start_end_distance', data=hour_group)

执行

<matplotlib.axes._subplots.AxesSubplot at 0x1be7d249e8>

从这个图中，我们可以观察到，距离这个目标特征与小时之间没什么明显的关系或者说规律。

即不同时间段对用户出行并没有什么影响。

距离与车类型

我们知道，初代的摩拜单车比较笨重，很难骑；第二代的摩拜单车比较轻便；

那有没有可能，用户会因为车子轻便，就多骑行一段距离呢？我们来验证一下：

df.groupby('biketype').agg({'start_end_distance': 'mean'})

根据输出的结果，第一代车的骑行平均距离约为807.6米，第二代车的骑行平均距离约为824.6米。

这并不能说明什么问题，算不上是显著的差异。

df.groupby('biketype').size() / df.shape[0]

根据输出的结果，第一代车的骑行占比约为60.56%，第二代车的骑行占比约为39.44%。

这与常规的猜测完全不同，我们认为第二代车轻便，所以第二代车的骑行占比会多，但数据推翻了它。

区块深入探索

以一个7位编码的区块为例，我们考虑一个问题？

每天有多少订单 / 多少不同的用户/ 多少不同的车辆从该区块出发或者到达该区块 ？

采取的思路是：（以出发点为例）

1. 按照天数，出发点进行group by
2. 每个组计算订单数，用户数(去重)，车辆数(去重)
3. 通过histogram直方图看数据的分布情况

g1 = df.groupby(['date', 'geohashed_start_loc'])

# unique方法返回不同的值，而nuique方法返回不同值的数量
group_data = g1.agg({'orderid': 'count', 'userid': 'nunique', 'bikeid':'nunique'}).reset_index()

group_data.head()

执行

group_data[group_data['orderid'] > 100].head()

执行

以上面表格中第一行数据为例，可理解为在区块 wx4dqqc 内，2017年5月10日，从该区块出发的有120个订单，有118个用户（肯定有用户是骑了两次或两次以上的），有120辆单车。

下面我们通过可视化的方式来展现一下。

sns.distplot(group_data['orderid'])

执行

<matplotlib.axes._subplots.AxesSubplot at 0x1c5922ba90>

sns.distplot(group_data['userid'])

执行

<matplotlib.axes._subplots.AxesSubplot at 0x1cbeb6f748>

sns.distplot(group_data['bikeid'])

执行

<matplotlib.axes._subplots.AxesSubplot at 0x1ccbfbb400>

其实从上面三个图中，只能是看出一个大概的分布信息。

具体的数值我们还需要通过 describe 方法来查看。

group_data.describe()

执行

我们得出结论：平均每天平均每个区块出发的也就是四到五单。同理我们可以计算出平均每天平均每个区块到达的大约在3.5单。毫无疑问这给我们目的地的预测增加了难度。

总和 / 总天数 / 总区块数 = 平均每天平均每个区块 = 总和 / (总天数 * 总区块数) = 总和 / group_data行数

起点终点组合分析

假设根据历史数据，从王府井到天安门的订单较多，那么我们是否可以找到块与块之间的对应，找出topN呢？这显然对于我们出行目的地的预测是有帮助的。

解决思路

1. 按照天数，开始区块，结束区块，进行分组
2. 每个组计算订单数，用户数，车辆数，进行排序

start_end = df.groupby(['date', 'geohashed_start_loc', 'geohashed_end_loc'])

# 计算每个出发点-停车点 的 订单数，用户数，车辆数，
start_end = start_end.agg({'orderid': 'count', 'userid': 'nunique', 'bikeid': 'nunique', 'start_end_distance': 'mean'}).reset_index().sort_values(by="orderid", ascending=False)

start_end.head()

执行

在现有的数据集中，哪个区块到哪个区块的订单数量最多呢？通过以下代码查看

# df.groupby(['geohashed_start_loc', 'geohashed_end_loc']).agg({'orderid': 'count'}).sort_values(by="orderid", ascending=False)[:10]

# 这两行代码输出的结果是等价的
start_end.groupby(['geohashed_start_loc', 'geohashed_end_loc']).agg({'orderid': 'sum'}).sort_values(by="orderid", ascending=False)[:10]

我们获取了Top10的关联，下图是输出的结果

考虑剔除数据

df['geohashed_start_loc_4'] = df['geohashed_start_loc_5'].apply(lambda s: s[:4])
df['geohashed_end_loc_4'] = df['geohashed_end_loc_5'].apply(lambda s: s[:4])

df['geohashed_start_loc_3'] = df['geohashed_start_loc_5'].apply(lambda s: s[:3])
df['geohashed_end_loc_3'] = df['geohashed_end_loc_5'].apply(lambda s: s[:3])

df.head()

执行

5 rows × 29 columns

# 出发点和目的地不在同一个g4区块内的
df.loc[df['geohashed_start_loc_4'] != df['geohashed_end_loc_4']].shape[0] / df.shape[0]        # 0.061495985185258936

# 出发点和目的地不在同一个g3区块内的
df.loc[df['geohashed_start_loc_3'] != df['geohashed_end_loc_3']].shape[0] / df.shape[0]        # 0.0006711062768504736

起点和终点不在同一个g4区块内的占比约为 6.15%，不在同一个g3区块内的占比约为 0.06%。

可以考虑直接剔除掉这部分数据了。

模型分析

模型要预测的是用户骑行的终点，为一个geohash的区域，我们可以计算一下整个区域大概有多少。

如果你具备一些基础的分类模型知识，你就会知道要模型分这么多类是不实际的甚至是无法完成的， 因此我们必须做一些规则上的判断。

1. 预测模型的GEOHASH4
2. 预测模型的GEOHASH5
3. 预测模型的GEOHASH6
4. 预测模型的GEOHASH7

如果是按照上面这种分层模型来预测，那存在一个很大的弊端，如果第一个geohash4预测错了，那后面的操作就完全无意义了。

做模型的预测时，一定要对数据有一个清晰的认识；如果数据处理不好，那么模型会学习的很糟糕