├── betaencoder.py
├── README.md
├── other.py
└── main.py


/betaencoder.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | # @Author: zhushuai
 3 | # @Date:   2019-04-02 12:02:01
 4 | # @Last Modified by:   zhushuai
 5 | # @Last Modified time: 2019-04-02 12:03:41
 6 | # 定义目标编码函数
 7 | 
 8 | class BetaEncoder(object):
 9 | 
10 |     def __init__(self, group):
11 | 
12 |         self.group = group
13 |         self.stats = None
14 | 
15 |     # get counts from df
16 |     def fit(self, df, target_col):
17 |         self.prior_mean = np.mean(df[target_col])
18 |         stats = df[[target_col, self.group]].groupby(self.group)
19 |         stats = stats.agg(['sum', 'count'])[target_col]
20 |         stats.rename(columns={'sum': 'n', 'count': 'N'}, inplace=True)
21 |         stats.reset_index(level=0, inplace=True)
22 |         self.stats = stats
23 | 
24 |     # extract posterior statistics
25 |     def transform(self, df, stat_type, N_min=1):
26 | 
27 |         df_stats = pd.merge(df[[self.group]], self.stats, how='left')
28 |         n = df_stats['n'].copy()
29 |         N = df_stats['N'].copy()
30 | 
31 |         # fill in missing
32 |         nan_indexs = np.isnan(n)
33 |         n[nan_indexs] = self.prior_mean
34 |         N[nan_indexs] = 1.0
35 | 
36 |         # prior parameters
37 |         N_prior = np.maximum(N_min - N, 0)
38 |         alpha_prior = self.prior_mean * N_prior
39 |         beta_prior = (1 - self.prior_mean) * N_prior
40 | 
41 |         # posterior parameters
42 |         alpha = alpha_prior + n
43 |         beta = beta_prior + N - n
44 | 
45 |         # calculate statistics
46 |         if stat_type == 'mean':
47 |             num = alpha
48 |             dem = alpha + beta
49 | 
50 |         elif stat_type == 'mode':
51 |             num = alpha - 1
52 |             dem = alpha + beta - 2
53 | 
54 |         elif stat_type == 'median':
55 |             num = alpha - 1 / 3
56 |             dem = alpha + beta - 2 / 3
57 | 
58 |         elif stat_type == 'var':
59 |             num = alpha * beta
60 |             dem = (alpha + beta) ** 2 * (alpha + beta + 1)
61 | 
62 |         elif stat_type == 'skewness':
63 |             num = 2 * (beta - alpha) * np.sqrt(alpha + beta + 1)
64 |             dem = (alpha + beta + 2) * np.sqrt(alpha * beta)
65 | 
66 |         elif stat_type == 'kurtosis':
67 |             num = 6 * (alpha - beta) ** 2 * (alpha + beta + 1) - alpha * beta * (alpha + beta + 2)
68 |             dem = alpha * beta * (alpha + beta + 2) * (alpha + beta + 3)
69 | 
70 |         else:
71 |             num = self.prior_mean
72 |             dem = np.ones_like(N_prior)
73 | 
74 |         # replace missing
75 |         value = num / dem
76 |         value[np.isnan(value)] = np.nanmedian(value)
77 |         return value


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # <center><span id="title">地铁乘客流量预测</span></center>
  2 | 
  3 | 
  4 | Table of Contents
  5 | =================
  6 | 
  7 |    * [地铁乘客流量预测](#title)
  8 |    * [1. 赛题分析和前期思路](#1)
  9 |       * [1.1 数据清洗](#1.1)
 10 |       * [1.2 特征工程](#1.2)
 11 |       * [1.3 划分训练集和测试集](#1.3)
 12 |       * [1.4 搭建模型预测](#1.4)
 13 |    * [2. 其他的一些想法](#2)
 14 |    * [3. 总结与思考](#3)
 15 | 
 16 | 
 17 | >  <font size=3>**竞赛题目**</font>
 18 | 
 19 | &emsp;通过分析地铁站的历史刷卡数据，预测站点未来的客流量变化。开放了20190101至20190125共25天的刷卡记录，共涉及3条线路81个地铁站约7000万条数据作为训练数据`Metro_train.zip`，供选手搭建地铁站点乘客流量预测模型。同时大赛提供了路网地图，即各个地铁站之间的连接关系表，存储在文件`Metro_roadMap.csv`文件中。
 20 | 
 21 | &emsp;测试阶段，提供某天所有线路所有站点的刷卡记录数据，预测未来一天00时至24时以10分钟为单位的各时段各站点的进站和出站人次。
 22 | 
 23 | &emsp;测试集A集上，提供2019年1月28日的刷卡数据`testA_record_2019-01-28.csv`，选手需对2019年1月29日全天各地铁站以10分钟为单位的人流量进行预测。
 24 | 
 25 | &emsp;评估指标采用**平均绝对误差`Mean Absolute Error, MAE`**，分别对入站人数和出站人数预测结果进行评估，然后在对两者取平均，得到最终评分。
 26 | 
 27 | &emsp;关于数据的具体描述以及说明[详见天池官网](<https://tianchi.aliyun.com/competition/entrance/231708/information>)。
 28 | 
 29 | 
 30 | 
 31 | # <font size=4><span id="1">1. 赛题分析和前期思路</span></font>
 32 | 
 33 | &emsp;比赛提供了1号到25号共25天的刷卡记录数据，所以第一步就是对每一天的文件进行处理。原始数据集中包含了`time`, `lineID`, `stationID`, `deviceID`, `status`, `userID`, `payType`这几个列，根据题目要求要预测进站和出站的人流量，所以要先统计出每一天的进站和出站流量。
 34 | 
 35 | ## <font size=3><span id="1.1">1.1 数据清洗</span></font>
 36 | 
 37 | >  **提取基础信息**
 38 | 
 39 | &emsp;首先对时间信息进行处理，提取出日、周、时、分、秒的信息，由于是按照10分钟为间隔统计，所以在提取分钟信息的时候只需要取整十。接着总计80个站点(除去缺失数据的54站)，每个站点从0点到24点，以10分钟为一次单位，总计144段时间间隔。根据站点、日、时、分进行分组统计，得到每个时段的进站人数和出站人数。
 40 | 
 41 | &emsp;经过第一轮处理之后，得到了每一天的文件包含的`columns`有：`stationID`,  `weekday`, `is_holiday`, `day`,  `hour`,  `minute`,  `time_cut`,  `inNums`以及`outNums`这几列。
 42 | 
 43 | &emsp;增加了一些和刷卡设备相关的特征，包括`nuni_deveiceID_of_stationID`, `nuni_deviceID_of_stationID_hour`, `nuni_deviceID_of_stationID_hour_minute`。
 44 | 
 45 | 
 46 | 
 47 | ## <font size=3><span id="1.2">1.2 特征工程</span></font>
 48 | 
 49 | > **增加同一站点相邻时间段的进出站流量信息**
 50 | 
 51 | &emsp;考虑到当前时刻的流量信息与前后时刻的流量信息存在一定的关系，所以将当前时间段的前两个时段以及后两个时段流量信息作为特征。
 52 | 
 53 | &emsp;增加的特征包括`inNums_before1`, `inNums_before2`, `inNums_after1`, `inNums_after2`, `outNums_before1`, `outNums_before2`, `outNums_after1`, `outNums_after2`。
 54 | 
 55 | 
 56 | 
 57 | > **增加乘车高峰时段相关的特征**
 58 | 
 59 | &emsp;根据杭州地铁的运营时段信息，将高峰时段分为四类，0表示非运营时间段，1表示非高峰时间段，2表示高峰时间段，3表示特殊高峰时间段。由于周末和非周末的高峰时间存在一定的差异，所以需要分别计算。
 60 | 
 61 | &emsp;增加了特征`peak_type`。
 62 | 
 63 | 
 64 | 
 65 | > **增加同周次的进出站流量信息**
 66 | 
 67 | &emsp;均值、最大值以及最小值在一定程度上反映了数据的分布信息，所以增加同周次进站流量和出站流量的均值、最大值以及最小值作为特征。
 68 | 
 69 | &emsp;增加的特征包括`inNums_whm_max`, `inNums_whm_min`, `inNums_whm_mean`, `outNums_whm_max`, `outNums_whm_min`, `outNums_whm_mean`, `inNums_wh_max`, `inNums_wh_min`, `inNums_wh_mean`, `outNums_wh_mean`。
 70 | 
 71 | 
 72 | 
 73 | > **增加线路信息**
 74 | 
 75 | &emsp;根据某一天的刷卡记录表统计每条线路和站点的对应信息，并计算各条线路的站点数，用站点数量代表该站的线路信息。
 76 | 
 77 | &emsp;增加特征`line`。
 78 | 
 79 | 
 80 | 
 81 | > **增加站点的类型信息**
 82 | 
 83 | &emsp;不同的站点属于不同的类型，比如起点站、终点站、换乘站、普通站等，而这些站点的类别信息可以通过邻站点的数量表示，所以根据路网图对邻站点的数量进行统计，表示各个站点的类别。
 84 | 
 85 | &emsp;增加特征`station_type`。
 86 | 
 87 | 
 88 | 
 89 | > **增加特殊站点的标记**
 90 | 
 91 | &emsp;对站点流量的分析过程中，发现第15站的流量与其他站点存在明显的区别，全天都处于高峰状态，因此给15站添加特别的标记。
 92 | 
 93 | &emsp;增加特征`is_special`。
 94 | 
 95 | 
 96 | 
 97 | > **连接训练特征和目标值**
 98 | 
 99 | &emsp;本次建模的思想使用前一天的流量特征和时间特征，以及预测当天的时间特征，来预测进站流量和出站流量。所以要对之前处理好的数据集进行拼接。
100 | 
101 | &emsp;增加新的特征`yesterday_is_holiday`以及`today_is_holiday`，增加目标值列`inNums`和`outNums`。
102 | 
103 | 
104 | 
105 | > **对时间间隔进行目标编码**
106 | 
107 | &emsp;考虑时间间隔信息与进站、出站流量的相关性，对时间间隔信息针对`inNums`和`outNums`进行目标编码。(这一步并非必须的，一定程度上可能会导致过拟合，所以可以考虑加入和不加入的情况都测试一下)
108 | 
109 | &emsp;目标编码后得到了`in_time_cut`和`out_time_cut`。
110 | 
111 | 
112 | 
113 | ## <font size=3><span id="1.3">1.3 划分训练集和测试集</span></font>
114 | 
115 | &emsp;根据上面数据清洗以及特征工程得到的结果对数据集进行划分。
116 | 
117 | 
118 | 
119 | ## <font size=3><span id="1.4">1.4 搭建模型预测</span></font>
120 | 
121 | &emsp;我们使用了LightGBM和CatBoost两个模型预测并取其均值，其实也可以尝试加入XGBoost，然后取3个模型的加权平均，但是我们当时训练时发现XGBoost得到的结果不是很好，所以直接丢掉了。其实，通过加权平均，给XGBoost的结果一个比较好的权重，也有可能会得到比较不错的结果。最后，<font color=blue>**对模型结果平均**</font>。
122 | 
123 | 
124 | 
125 | # <font size=4><span id="2">2. 其他的一些想法</span></font>
126 | 
127 | (1) 由于官方给了路网图，所以我们尝试将路网图拼接在特征后面，表示各个站点之间的连接关系，但是这样反而降低了模型最终的性能。
128 | 
129 | <br/>
130 | 
131 | (2) 过程中我们一直想充分利用邻站点的信息，想在邻站点上提取尽可能多的特征，包括邻站点相同时刻以及相邻时刻的流量信息，但是这样都会降低模型的性能，也在这上面浪费了不少的时间。
132 | 
133 | <br/>
134 | 
135 | (3) 除了从以后的数据中提取特征之外，我们还对提出出来的特征做了一些特征工程，包括计算一些可能有一定关联的特征**计算加减以及比率信息**，但是这些工作都没有能够提升模型的性能。
136 | 
137 | <br/>
138 | 
139 | (4) 根据官方交流群的讨论，我们在A榜的时候尝试去掉周末的信息，只讲工作日的信息进行提取和拼接，这在一定程度上提升了模型的效果，后来我们在[鱼的代码](<https://zhuanlan.zhihu.com/p/59998657>)基础上加入了我们之前找到的一些特征。之后，仔细推敲了一下鱼的代码，发现在进行特征`feature`和目标值`target`拼接的时候，和`deviceID`相关的特征使用的是预测当天的，这样一方面会导致leak，另一方面就是最后的测试集这些特征都是`nan`值，也就是说在最终的预测中没有起到作用。于是，我们改变了拼接的方法，再次加入了自己提取的特征，最终在A榜跑出的成绩是`12.99`。注意，**这里使用的数据并不是全部的数据，而只是使用了工作日的数据拼接**。
140 | 
141 | <br/>
142 | 
143 | &emsp;在B榜的时候，我们还是希望能够训练一个通用的模型，所以这次把所有的数据放在一起训练，并没有将周末的数据单独提取出来，但是在滑窗的时候使用了`13`和`20`两天的数据作为验证，最终跑出了`12.57`的成绩，说明这种想法是可行的。为了验证一下只提取周末信息的效果，我们也尝试把周末的信息单独提取出来，最后得分一直在`14`以上，可能也是因为我们提的特征不太适用于这种场景。
144 | 
145 | <br/>
146 | 
147 | &emsp;最终，我们使用了全部的数据通过Stacking的方法进行了训练，将三个梯度提升树模型进行了堆叠，最后得到的结果也是`14`多一点。
148 | 
149 | 
150 | 
151 | # <font size=4><span id="3">3. 总结与思考</span></font>
152 | 
153 | (1) 首先是对数据的EDA做的不够，包括对各个站点的分析，各个时间段综合分析，对特征重要性的分析等等。主要还是因为经验不够，不知道该怎么做，甚至15站点的特殊性也是从交流群里得到的信息。另外，就是调参做的有问题，反而把模型的性能调低了，说明对参数的理解不够。
154 | 
155 | <br/>
156 | 
157 | (2) 第一次团队作战，不知道该怎么协作，分工不是很明确，所以效率不是很高，没能有机会尝试更多的模型。代码写的不规范，导致后面修改的时候浪费了比较多的时间，包括整理也花了不少的时间。
158 | 
159 | <br/>
160 | 
161 | (3) 知道的模型太少，只使用了梯度提升树模型，其实还有很多可能有效的模型可以尝试，包括图神经网络，时空模型以及LSTM，但是都因为不够熟悉而无从入手。
162 | 
163 | <br/>
164 | 
165 | (4) 总结：
166 | 
167 | - 了解自己能做的事情，明确分工；
168 | - 做好EDA，做到对数据的充分理解；
169 | - 代码书写规范，每一个功能模块应该定义为一个函数；
170 | - 熟悉不同模型的功能以及试用场景。
171 | 
172 | 


--------------------------------------------------------------------------------
/other.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # @Author: zhushuai
  3 | # @Date:   2019-04-02 13:08:20
  4 | # @Last Modified by:   zhushuai
  5 | # @Last Modified time: 2019-04-02 13:11:13
  6 | 
  7 | import xgboost as xgb 
  8 | from sklearn.metrics import mean_absolute_error
  9 | from sklearn.base import BaseEstimator, TransformerMixin, RegressorMixin, clone
 10 | 
 11 | # 定义XGB模型
 12 | 
 13 | # 设置模型参数
 14 | xgb_params = {
 15 |     'booster': 'gbtree',
 16 |     'objective': 'reg:linear',
 17 |     
 18 |     'eval_metric': 'mae',
 19 |     
 20 |     'learning_rate': 0.0894,
 21 |     'max_depth': 9,
 22 |     'max_leaves': 20,
 23 |     
 24 |     'lambda': 2,
 25 |     'alpha': 1,
 26 |     'subsample': 0.8,
 27 |     'colsample_bytree': 0.8,
 28 |     'silent': 1,
 29 |     
 30 |     'gpu_id': 0,
 31 |     'tree_method': 'gpu_hist'
 32 | }
 33 | 
 34 | ## 预测进站流量
 35 | in_xgb_pred = np.zeros(len(X_test))
 36 | X_data = train_data[features].values
 37 | y_data = train_data['inNums'].values
 38 | 
 39 | 
 40 | for i, date in enumerate(slip):
 41 |     train = train_data[train_data.day<date]
 42 |     valid = train_data[train_data.day==date]
 43 |     X_train = train[features].values
 44 |     X_eval =  valid[features].values
 45 |     y_train = train['inNums'].values
 46 |     y_eval = valid['inNums'].values
 47 |     
 48 |     print("\n Fold ", i)
 49 |     xgb_train = xgb.DMatrix(X_train, y_train)
 50 |     xgb_eval = xgb.DMatrix(X_eval,y_eval)
 51 |     
 52 |     xgb_model = xgb.train(
 53 |         xgb_params,
 54 |         xgb_train,
 55 |         num_boost_round=10000,
 56 |         evals=[(xgb_eval, 'evals')],
 57 |         early_stopping_rounds=200,
 58 |         verbose_eval=1000
 59 |     )
 60 |     
 61 |     temp_eval = xgb.DMatrix(X_eval)
 62 |     eval_pred = xgb_model.predict(temp_eval)
 63 |     print("MAE = ", mean_absolute_error(y_eval, eval_pred))
 64 |     
 65 |     ## all_data
 66 |     all_train = xgb.DMatrix(X_data, y_data)
 67 |     xgb_model = xgb.train(
 68 |         xgb_params,
 69 |         all_train,
 70 |         num_boost_round=xgb_model.best_iteration,
 71 |         evals=[(all_train, 'train')],
 72 |         verbose_eval=1000
 73 |     )
 74 |     
 75 |     xgb_test = xgb.DMatrix(X_test)
 76 |     in_xgb_pred += xgb_model.predict(xgb_test) / n
 77 |     print("第%d轮完成"%(i+1))
 78 | print("全部结束！")
 79 | 
 80 | ## 预测出站流量
 81 | out_xgb_pred = np.zeros(len(X_test))
 82 | X_data = train_data[features].values
 83 | y_data = train_data['outNums'].values
 84 | 
 85 | 
 86 | for i, date in enumerate(slip):
 87 |     train = train_data[train_data.day<date]
 88 |     valid = train_data[train_data.day==date]
 89 |     X_train = train[features].values
 90 |     X_eval =  valid[features].values
 91 |     y_train = train['outNums'].values
 92 |     y_eval = valid['outNums'].values
 93 |     
 94 |     print("\n Fold ", i)
 95 |     xgb_train = xgb.DMatrix(X_train, y_train)
 96 |     xgb_eval = xgb.DMatrix(X_eval,y_eval)
 97 |     
 98 |     out_xgb_model = xgb.train(
 99 |         xgb_params,
100 |         xgb_train,
101 |         num_boost_round=10000,
102 |         evals=[(xgb_eval, 'evals')],
103 |         early_stopping_rounds=200,
104 |         verbose_eval=1000
105 |     )
106 |     
107 |     temp_eval = xgb.DMatrix(X_eval)
108 |     eval_pred = out_xgb_model.predict(temp_eval)
109 |     print("MAE = ", mean_absolute_error(y_eval, eval_pred))
110 |     
111 |     ## all_data
112 |     all_train = xgb.DMatrix(X_data, y_data)
113 |     out_xgb_model = xgb.train(
114 |         xgb_params,
115 |         all_train,
116 |         num_boost_round = out_xgb_model.best_iteration,
117 |         evals=[(all_train, 'train')],
118 |         verbose_eval=1000
119 |     )
120 |     
121 |     xgb_test = xgb.DMatrix(X_test)
122 |     out_xgb_pred += out_xgb_model.predict(xgb_test) / n
123 |     print("第%d轮完成"%(i+1))
124 | print("全部结束！")
125 | 
126 | 
127 | # 定义Stacking模型
128 | class MyStacking(BaseEstimator, RegressorMixin, TransformerMixin):
129 |     # base_models表示基准模型，meta_model表示元模型
130 |     # slip表示滑窗的预测值
131 |     # time_fe表示时间对应的特征
132 |     def __init__(self, base_models, 
133 |                  meta_model, slip, time_fe, features, target):
134 |         self.base_models = base_models
135 |         self._slip = slip
136 |         self.fe_ = time_fe
137 |         self.features = features
138 |         self.target_ = target
139 |         
140 |         self.meta_model = meta_model
141 |         
142 |     
143 |     # 定义拟合函数
144 |     # 这里的X和y是DataFrame形式的
145 |     def fit(self, train_data):
146 |         # 定义基本模型
147 |         self.base_models_ = [list() for x in self.base_models]
148 |         # 定义元模型
149 |         self.meta_model_ = clone(self.meta_model)
150 |         
151 |         
152 |         shape_ = [train_data[train_data[self.fe_] == d].shape[0] for d in self._slip]
153 |         y_true = np.array([])
154 |         for d in self._slip:
155 |             y_true = np.hstack((y_true, train_data.loc[train_data.day == d, self.target_].values))
156 |         
157 |         index = []
158 |         for k, sh in enumerate(shape_):
159 |             if k == 0:
160 |                 index.append(list(range(sh)))
161 |             else:
162 |                 index.append(list(range(index[-1][-1], index[-1][-1]+shape_[k])))
163 |         
164 |         # 设置用于元模型的特征大小
165 |         oof_pred = np.zeros((sum(shape_), 
166 |                              len(self.base_models)))
167 |         # 训练基础模型
168 |         for i, model_name in enumerate(self.base_models):
169 |             for j, date in enumerate(self._slip):
170 |                 # 设置训练集和验证集
171 |                 train = train_data[train_data[self.fe_]<date]
172 |                 valid = train_data[train_data[self.fe_]==date]
173 |                 
174 |                 X_train = train[self.features].values
175 |                 X_eval = valid[self.features].values
176 |                 y_train = train[self.target_].values
177 |                 y_eval = valid[self.target_].values
178 |                 
179 |                 if model_name =='lgb':
180 |                     lgb_train = lgb.Dataset(X_train, y_train)
181 |                     lgb_eval = lgb.Dataset(X_eval, y_eval, reference=lgb_train)
182 |                     print("开始训练{}_{}".format(i, j))
183 |                     model = lgb.train(lgb_params, 
184 |                                          lgb_train,
185 |                                          num_boost_round=10000,
186 |                                          valid_sets=[lgb_train, lgb_eval],
187 |                                          valid_names=['train', 'valid'],
188 |                                          early_stopping_rounds=200,
189 |                                          verbose_eval=1000,)
190 |                     y_pred = model.predict(X_eval)
191 |                     print("结束本次训练！")
192 |                 if model_name == 'cat':
193 |                     cat_train = Pool(X_train, y_train)
194 |                     cat_eval = Pool(X_eval, y_eval)
195 |                     print("开始训练{}_{}".format(i, j))
196 |                     model = catboost.train(
197 |                                 pool = cat_train, params=cat_params,
198 |                                 eval_set=cat_eval, num_boost_round=50000,
199 |                                 verbose_eval=5000, early_stopping_rounds=200,)
200 |                     y_pred = model.predict(X_eval)
201 |                     print("结束本次训练！")
202 |                     
203 |                 if model_name == 'xgb':
204 |                     
205 |                     print("开始训练{}_{}".format(i, j))
206 |                     model = xgb.XGBRegressor(**xgb_params)
207 |                     #print(X_train.shape)
208 |                     model.fit(X_train, y_train, eval_set=[(X_eval, y_eval)], early_stopping_rounds=400, verbose=1000)
209 |                     y_pred = model.predict(X_eval)
210 |                     print("结束本次训练！")
211 |                     
212 |                 self.base_models_[i].append(model)
213 |                 oof_pred[index[j], i] = y_pred
214 |         
215 |         self.meta_model_.fit(oof_pred, y_true)
216 |         return self
217 | 
218 |     # 预测结果
219 |     def predict(self, X):
220 |         meta_features = np.column_stack([
221 |             np.column_stack([model.predict(X) for model in base_models]).mean(axis=1)
222 |         for base_models in self.base_models_])
223 |         return self.meta_model_.predict(meta_features)


--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # @Author: zhushuai
  3 | # @Date:   2019-04-02 11:53:48
  4 | # @Last Modified by:   zhushuai
  5 | # @Last Modified time: 2019-04-02 13:11:40
  6 | import os
  7 | import numpy as np 
  8 | import pandas as pd 
  9 | import xgboost as xgb 
 10 | import lightgbm as lgb 
 11 | import catboost 
 12 | from catboost import CatBoostRegressor, Pool
 13 | from collections import Counter
 14 | from sklearn.metrics import mean_absolute_error
 15 | 
 16 | from betaencoder import BetaEncoder
 17 | 
 18 | 
 19 | # 设置一些文件的路径
 20 | train_path = "../origin/Metro_train"
 21 | test_path = "../origin/Metro_testA"
 22 | 
 23 | test_file = "testA_record_2019-01-28.csv"
 24 | sub_file = "testA_submit_2019-01-29.csv"
 25 | roadfile = "../origin/Metro_roadMap.csv"
 26 | 
 27 | 
 28 | 
 29 | # 数据清洗
 30 | # 表示2019年本应该是工作日，却是节假日的情况
 31 | w2h = ["1-1", "2-4", "2-5", "2-6", "2-7", "2-8", "2-9", "2-10", "4-5", "5-1", "6-7", "9-13",
 32 |   "10-1", "10-2", "10-3", "10-4", "10-5", "10-6", "10-7"]
 33 | # 表示本应该是节假日，调休为工作日的情况
 34 | h2w = ["2-2", "2-3", "9-29", "10-12"]
 35 | 
 36 | def get_base_features(df_):
 37 |     train_df = df_.copy()
 38 |     
 39 |     # 加入日期的信息
 40 |     train_df['day'] = train_df['time'].apply(lambda x: int(x[8:10]))
 41 |     train_df['minute'] = train_df['time'].apply(lambda  x: int(x[14:15] + '0'))
 42 | 
 43 |     # 将时间对应的列转换为pandas可以处理的类型
 44 |     train_df['time'] = pd.to_datetime(train_df['time'])
 45 |     # 得到月的信息
 46 |     train_df['month'] = train_df['time'].dt.month
 47 |     # 得到对应的周次、小时和分钟
 48 |     train_df['weekday'] = train_df['time'].dt.weekday + 1
 49 |     #train_df['weekend'] = (train_df.weekday >=6 ).astype(int)
 50 |     train_df['hour'] = train_df['time'].dt.hour
 51 |     date = str(train_df.month.values[0])+'-'+str(train_df.day.values[0])
 52 |     if date in w2h or (date not in h2w and train_df.weekday.values[0] in [6,7]):
 53 |         train_df['is_holiday'] = 1
 54 |     else:
 55 |         train_df['is_holiday'] = 0
 56 |     
 57 |     train_final = train_df.groupby(['stationID', 'weekday', 'is_holiday', 'day', 'hour', 'minute']).status.agg(['count', 'sum']).reset_index()
 58 |     # 这一段参考yu的代码
 59 |     # 考虑和刷卡设备相关的特征
 60 |     # 每个站点的刷卡设备数量与该站点的人流量存在一定的关系
 61 |     # 每个时段的刷卡设备数与流量也存在一定的关系
 62 |     tmp = train_df.groupby(['stationID'])['deviceID'].nunique().reset_index(name='nuni_deviceID_of_stationID')
 63 |     train_final = train_final.merge(tmp, on=['stationID'], how='left')
 64 |     tmp = train_df.groupby(['stationID','hour'])['deviceID'].nunique().reset_index(name='nuni_deviceID_of_stationID_hour')
 65 |     train_final = train_final.merge(tmp, on=['stationID', 'hour'], how='left')
 66 |     tmp = train_df.groupby(['stationID','hour','minute'])['deviceID'].nunique().\
 67 |                                            reset_index(name='nuni_deviceID_of_stationID_hour_minute')
 68 |     train_final  = train_final.merge(tmp, on=['stationID','hour','minute'], how='left')
 69 |     
 70 |     train_final['time_cut'] = train_final['hour'] * 6 + train_final['minute'] // 10
 71 |     train_final['inNums'] = train_final['sum']
 72 |     train_final['outNums'] = train_final['count'] - train_final['sum']
 73 |     del train_final['sum'], train_final['count']
 74 |     
 75 |     return train_final
 76 | 
 77 | # 特征工程
 78 | 
 79 | ## 增加同站点相邻时间段的信息
 80 | def add_neighbor_time(df_):
 81 |     train_df = df_.copy()  
 82 |     # 生成一个用于中间转换的DataFrame
 83 |     train_now = train_df[['stationID', 'day', 'time_cut', 'inNums', 'outNums']]
 84 |     
 85 |     train_df.rename(columns={'inNums': 'inNums_now', 'outNums': 'outNums_now'}, inplace=True)
 86 |     
 87 |     # 考虑前多少个时间段，默认考虑前两个时间段
 88 |     for i in range(2, 0, -1):
 89 |         train_before = train_now.copy()
 90 |         train_before['time_cut'] = train_before['time_cut'] + i
 91 |         train_df = train_df.merge(train_before, how='left', on = ["stationID","day", "time_cut"])
 92 |         train_df.rename(columns = {'inNums': f'inNums_before{i}', 'outNums': f'outNums_before{i}'}, inplace=True)
 93 |         train_df.fillna(0, inplace=True)
 94 |     
 95 | 		# 考虑后多少个时间段，默认考虑前两个时间段
 96 |     for j in range(2, 0, -1):
 97 |         train_after = train_now.copy()
 98 |         train_after['time_cut'] = train_after['time_cut'] - j
 99 |         train_df = train_df.merge(train_after, how='left', on = ["stationID", "day", "time_cut"])
100 |         train_df.rename(columns = {'inNums': f'inNums_after{j}', 'outNums': f'outNums_after{j}'}, inplace=True)
101 |         train_df.fillna(0, inplace=True)
102 |     
103 |     return train_df
104 | 
105 | ## 增加乘车高峰时段相关的特征
106 | 
107 | def add_peak_type(df_):
108 |     
109 |     train_df = df_.copy()
110 |     
111 |     ### 7:00-9:00、17:00-19:00为高峰时段，7:30-8:30、17:30-18:30为特殊高峰
112 |     w_time = ['6:00', '7:00', '7:30', '8:30', '9:00', '17:00', '17:30', '18:30', '19:00', '0:00']
113 | 
114 |     w_time_cut = [10*pd.to_datetime(ti).hour+pd.to_datetime(ti).minute//10 for ti in w_time]
115 | 
116 |     # 节假日的高峰时间段
117 |     h_time = ['6:00','7:00', '9:00', '12:00', '15:00', '18:00', '20:00', '0:00']
118 | 
119 |     h_time_cut = [10*pd.to_datetime(ti).hour+pd.to_datetime(ti).minute//10 for ti in h_time]
120 | 
121 |     # 每个时间点对应的time_cut
122 |     temp_array = {'temp': [i*10+j for i in range(24) for j in range(6)], 'time_cut': list(range(0, 144))}
123 | 
124 |     # 工作日
125 |     ## 早高峰的开始和结束时间
126 |     ### 运营开始时间
127 |     w_start = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[0])]
128 | 
129 |     mp_start_1 = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[1])]
130 |     mp_end_1 = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[2])]
131 | 
132 |     mp_start_2 = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[3])]
133 |     mp_end_2 = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[4])]
134 | 
135 |     ## 早特殊高峰开始结束时间
136 |     msp_start = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[2])]
137 |     msp_end = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[3])]
138 | 
139 |     ## 晚高峰开始和结束时间
140 |     ap_start_1 = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[5])]
141 |     ap_end_1 = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[6])]
142 | 
143 |     ap_start_2 = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[7])]
144 |     ap_end_2 = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[8])]
145 | 
146 |     ## 晚特殊高峰开始结束时间
147 |     asp_start = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[6])]
148 |     asp_end = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[7])]
149 | 
150 |     w_end = temp_array['time_cut'][temp_array['temp'].index(w_time_cut[9])]
151 | 
152 |     ## 工作日peak类型映射表
153 |     ### 0表示停运期间，1表示运行开始到高峰前和高峰后到运营结束，2表示高峰时间，3表示特殊高峰时间
154 | 
155 |     w_peak = {0: list(range(w_end, w_start)),
156 |             2: list(range(mp_start_1, mp_end_1))
157 |               + list(range(mp_start_2, mp_end_2))
158 |               + list(range(ap_start_1, ap_end_1))
159 |               + list(range(ap_start_2, ap_end_2)),
160 |               3: list(range(msp_start, msp_end))
161 |               + list(range(asp_start, asp_end))}
162 | 
163 |     peak_workday = {}
164 | 
165 |     for key, value in w_peak.items():
166 |         for t in value:
167 |             peak_workday[t] = key
168 | 
169 | 
170 |     # 节假日
171 | 
172 |     ## 早高峰的开始和结束时间
173 | 
174 |     h_start = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[0])]
175 |     h_end = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[7])]
176 | 
177 |     h_mp_start_1 = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[1])]
178 |     h_mp_end_1 = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[2])]
179 | 
180 |     h_mp_start_2 = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[3])]
181 |     h_mp_end_2 = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[4])]
182 | 
183 |     ## 早特殊高峰开始结束时间
184 |     h_msp_start = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[2])]
185 |     h_msp_end = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[3])]
186 | 
187 |     ## 晚高峰开始和结束时间
188 |     h_ap_start_1 = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[5])]
189 |     h_ap_end_1 = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[6])]
190 | 
191 |     ## 晚特殊高峰开始结束时间
192 |     h_asp_start = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[4])]
193 |     h_asp_end = temp_array['time_cut'][temp_array['temp'].index(h_time_cut[5])]
194 | 
195 |     ## 节假日日peak类型映射表
196 | 
197 |     h_peak = {0: list(range(h_end, h_start)),
198 |             2: list(range(h_mp_start_1, h_mp_end_1))
199 |               + list(range(h_mp_start_2, h_mp_end_2))
200 |               + list(range(h_ap_start_1, h_ap_end_1)) ,
201 |               3: list(range(h_msp_start, h_msp_end))
202 |               + list(range(h_asp_start, h_asp_end))}
203 | 
204 |     peak_holiday = {}
205 | 
206 |     for key, value in h_peak.items():
207 |         for t in value:
208 |             peak_holiday[t] = key
209 | 		
210 |     # 转换成用于连接的DataFrame
211 |     wo_peak = pd.DataFrame({'time_cut':list(peak_workday.keys()) , 'peak_type': list(peak_workday.values()) })
212 |     wo_peak['is_holiday'] = 0
213 | 
214 |     ho_peak = pd.DataFrame({'time_cut': list(peak_holiday.keys()), 'peak_type': list(peak_holiday.values())})
215 |     ho_peak['is_holiday'] = 1
216 | 
217 |     to_peak = pd.concat([wo_peak, ho_peak], axis=0, sort=False)
218 | 
219 | 
220 |     
221 |     train_df = train_df.merge(to_peak, on=['is_holiday', 'time_cut'], how='left')
222 |     train_df['peak_type'].fillna(1, inplace=True)
223 |     
224 |     return train_df
225 | 
226 | ## 增加同周次进出站流量的信息
227 | def add_week_flow(df_):
228 |     
229 |     train_df = df_.copy()
230 |     
231 |     tmp = train_df.groupby(['stationID','weekday','hour','minute'], as_index=False)['inNums_now'].agg({
232 |                                                                         'inNums_whm_max'    : 'max',
233 |                                                                         'inNums_whm_min'    : 'min',
234 |                                                                         'inNums_whm_mean'   : 'mean'
235 |                                                                             })
236 |     train_df = train_df.merge(tmp, on=['stationID','weekday','hour','minute'], how='left')
237 | 
238 |     tmp = train_df.groupby(['stationID','weekday','hour','minute'], as_index=False)['outNums_now'].agg({
239 |                                                                             'outNums_whm_max'    : 'max',
240 |                                                                             'outNums_whm_min'    : 'min',
241 |                                                                             'outNums_whm_mean'   : 'mean'
242 |                                                                             })
243 |     train_df = train_df.merge(tmp, on=['stationID','weekday','hour','minute'], how='left')
244 | 
245 |     tmp = train_df.groupby(['stationID','weekday','hour'], as_index=False)['inNums_now'].agg({
246 |                                                                             'inNums_wh_max'    : 'max',
247 |                                                                             'inNums_wh_min'    : 'min',
248 |                                                                             'inNums_wh_mean'   : 'mean'
249 |                                                                             })
250 |     train_df = train_df.merge(tmp, on=['stationID','weekday','hour'], how='left')
251 | 
252 |     tmp = train_df.groupby(['stationID','weekday','hour'], as_index=False)['outNums_now'].agg({
253 |                                                                             #'outNums_wh_max'    : 'max',
254 |                                                                             #'outNums_wh_min'    : 'min',
255 |                                                                             'outNums_wh_mean'   : 'mean'
256 |                                                                             })
257 |     train_df = train_df.merge(tmp, on=['stationID','weekday','hour'], how='left')
258 |     
259 |     return train_df
260 | 
261 | ## 增加线路信息
262 | def add_line(df_):
263 |     def station_line(record):
264 |         station_line = record[['lineID', 'stationID']]
265 |         station_line = station_line.drop_duplicates().reset_index(drop=True)
266 |         station_line = station_line.sort_values(by='stationID').reset_index(drop=True)
267 |         return station_line
268 | 
269 |     train_df = df_.copy()
270 | 
271 |     # 这里的file表示原始文件
272 |     train_files = [f for f in sorted(os.listdir(train_path)) if f.endswith("csv")]
273 |     record = pd.read_csv(os.path.join(train_path, train_files[0]))
274 |     line = station_line(record)
275 |     line_pad = pd.DataFrame(Counter(line['lineID']), index=line.lineID.unique())
276 |     line_ID = (line_pad.T)['B'].reset_index().rename(columns={'index': 'lineID', 'B': 'line'})
277 |     line = line.merge(line_ID, on='lineID', how='left')
278 |     line.drop('lineID', axis=1, inplace=True)
279 |     train_df = train_df.merge(line, on=['stationID'], how='left')
280 |     return train_df
281 | 
282 | ## 增加车站类型信息
283 | def add_station_type(df_):
284 |     
285 |     def get_map(roadmap):
286 |         roadmap.rename(columns={"Unnamed: 0": 'stationID'}, inplace=True)
287 |         tmp = roadmap.drop(['stationID'], axis=1)
288 |         roadmap['station_type'] = tmp.sum(axis=1)
289 |         return roadmap[['stationID', 'station_type']]
290 |     
291 |     
292 |     roadmap = pd.read_csv(roadfile)
293 |     map_pad = get_map(roadmap)
294 |     
295 |     train_df = df_.copy()
296 |     train_df = train_df.merge(map_pad, on=['stationID'], how='left')
297 |     return train_df
298 | 
299 | ## 增加特征站点标记
300 | 
301 | def add_special_station(df_):
302 |     train_df = df_.copy()
303 |     
304 |     train_df['is_special'] = np.nan
305 |     train_df.loc[train_df['stationID']==15, 'is_special'] = 1 
306 |     train_df['is_special'].fillna(0, inplace=True)
307 |     return train_df
308 | 
309 | 
310 | ## 连接训练特征和目标值
311 | # 定义增加周末信息的函数
312 | def add_is_holiday(test):
313 |     date = str(test.month.values[0])+'-'+str(test.day.values[0])
314 |     if date in w2h or (date not in h2w and test.weekday.values[0] in [6,7]):
315 |         test['is_holiday'] = 1
316 |     else:
317 |         test['is_holiday'] = 0
318 |     return test
319 | 
320 | 
321 | # 获取最终的测试日期数据
322 | def read_test(test):
323 |     test['weekday']    = pd.to_datetime(test['startTime']).dt.dayofweek + 1
324 |     #test['weekend'] = (pd.to_datetime(test.startTime).dt.weekday >=5).astype(int)
325 |     test['month'] = pd.to_datetime(test['startTime']).dt.month
326 |     test['day']     = test['startTime'].apply(lambda x: int(x[8:10]))
327 |     test['hour']    = test['startTime'].apply(lambda x: int(x[11:13]))
328 |     test['minute']  = test['startTime'].apply(lambda x: int(x[14:15]+'0'))
329 |     test = test.drop(['startTime', 'endTime'], axis=1)
330 | 
331 |     test = add_is_holiday(test)
332 |     test['time_cut'] = test['hour'] * 6 + test['minute'] // 10
333 |     test.drop(['inNums', 'outNums', 'month'], axis=1, inplace=True)
334 |     return test
335 | 
336 | # 用于对weekday的信息进行修正
337 | def fix_weekday(w):
338 |     if w == 7:
339 |         return 1 
340 |     else:
341 |         return w+1
342 | 
343 | # 合并得到训练集和测试集的数据
344 | def merge_train_test(df_):
345 |     train_df = df_.copy()
346 |     
347 |     # 读取最后要提交的数据
348 |     test = pd.read_csv(os.path.join(test_path, sub_file))
349 |     test_df = read_test(test)
350 |     all_data = pd.concat([train_df, test_df], axis=0, sort=False)
351 | 
352 |     # 将当天对应的节假日信息取出备用
353 |     th = all_data[['day', 'is_holiday']].drop_duplicates().sort_values(by=['day']).reset_index(drop=True).rename(columns={'is_holiday': 'today_is_holiday'})
354 |     # 提取用于合并为target的部分
355 |     train_target = all_data[['stationID','day', 'hour','minute', 'time_cut', 'inNums_now', 'outNums_now']]
356 | 
357 |     train_target.rename(columns={'inNums_now': 'inNums', 'outNums_now': 'outNums'}, inplace=True)
358 |     # 将所有数据的节假日信息名称改为前一天的节假日信息
359 |     all_data.rename(columns={'is_holiday': 'yesterday_is_holiday'}, inplace=True)
360 |     # 为了之后合并，将day的特征加1
361 |     all_data['day'] += 1
362 |     # 对周的信息进行修正
363 |     all_data['weekday'] = all_data['weekday'].apply(fix_weekday)
364 |     
365 |     # 需要将训练集和测试集单独合并
366 | 
367 |     train_df = all_data[(all_data.day != 29) & (all_data.day != 26) & (all_data.day != 30)]
368 | 
369 |     test_df = all_data[all_data.day == 29]
370 |     
371 |     # 首先对生成训练集数据
372 |     train_df = train_df.merge(train_target, on=['stationID', 'day', 'hour', 'minute', 'time_cut'], how='left')
373 |     ## 对预测目标值的缺失值补0
374 |     train_df['inNums'].fillna(0, inplace=True)
375 |     train_df['outNums'].fillna(0, inplace=True)
376 |     
377 |     ## 补充当天是否周末的信息
378 |     train_df = train_df.merge(th, on='day', how='left')
379 |     
380 |     # 生成测试集的数据
381 |     test_target = train_target[train_target.day == 29]
382 |     # 对测试值进行连接
383 |     test_df = test_df.merge(test_target, on=['stationID', 'day', 'hour', 'minute', 'time_cut'], how='outer')
384 |     test_df = test_df.sort_values(by=['stationID', 'hour', 'minute']).reset_index(drop=True)
385 |     use_fe = ['stationID', 'weekday', 'yesterday_is_holiday', 'nuni_deviceID_of_stationID', 'line', 'station_type', 'is_special']
386 |     test_merge = test_df[use_fe].drop_duplicates().dropna()
387 |     test_df = test_df.drop(use_fe[1:], axis=1)
388 |     test_df = test_df.merge(test_merge, on=['stationID'], how='left')
389 |     
390 |     test_df = test_df.merge(th, on='day', how='left')
391 |     test_df.fillna(0, inplace=True)
392 |     all_data = pd.concat([train_df, test_df], axis=0, sort=False)
393 |     return all_data, train_df
394 | 
395 | # 考虑进出站流量和时间段密切相关
396 | # 针对time_cut进行目标编码
397 | def target_encoding(all_data, train_df):
398 |     # 设置参数
399 |     N_min = 300
400 |     fe = 'time_cut'
401 |     
402 |     # 针对进站流量的目标编码
403 |     te_in = BetaEncoder(fe)
404 |     te_in.fit(train_df, 'inNums')
405 |     all_data['in_time_cut'] = te_in.transform(all_data, 'mean', N_min=N_min)
406 |     
407 |     # 针对出站流量的目标编码
408 |     te_out = BetaEncoder(fe)
409 |     te_out.fit(train_df, 'outNums')
410 |     all_data['out_time_cut'] = te_out.transform(all_data, 'mean', N_min = N_min)
411 |     
412 |     return all_data
413 | 
414 | 
415 | def train(all_data):
416 |     # 设置需要使用的特征
417 |     features = [f for f in all_data.columns if f not in ['inNums', 'outNums', 'time_cut']]
418 | 
419 |     # 提取训练集和测试集
420 | 
421 |     # 所有数据
422 |     # 由于1号是元旦节，情况相对特殊，所以去掉了该极端值
423 |     # 也可以使用一下看看效果
424 |     train_data = all_data[(all_data.day != 29) & (all_data.day != 2)]
425 | 
426 |     # 用于训练的数据
427 |     test = all_data[all_data.day == 29]
428 |     X_test = test[features].values
429 | 
430 |     # 设置滑动窗口
431 |     # 这里A榜要预测的是29号的信息，所以设置同是周二的日期作为滑动窗口的末尾
432 |     # 而B榜要预测的是27号的信息，所以设置周末的日期作为滑窗末尾，即13，20
433 |     slip = [15, 22]
434 | 
435 |     n = len(slip)
436 | 
437 | 
438 |     ## 搭建LGB模型
439 |     # 设置模型参数
440 |     lgb_params = {
441 |         'boosting_type': 'gbdt',
442 |         'objective': 'regression_l1',
443 |         'metric': 'mae',
444 |         'num_leaves': 63,
445 |         'learning_rate': 0.01,
446 |         'feature_fraction': 0.9,
447 |         'bagging_fraction': 0.9,
448 |         'bagging_seed':0,
449 |         'bagging_freq': 1,
450 |         'verbose': 1,
451 |         'reg_alpha':1,
452 |         'reg_lambda':2,
453 |         
454 |         # 设置GPU 
455 |         'device' : 'gpu',
456 |         'gpu_platform_id':1,  
457 |         'gpu_device_id':0 
458 |     }
459 | 
460 |     ## 预测进站流量
461 |     in_lgb_pred = np.zeros(len(X_test))
462 |     X_data = train_data[features].values
463 |     y_data = train_data['inNums'].values
464 |     for i, date in enumerate(slip):
465 |         train = train_data[train_data.day<date]
466 |         valid = train_data[train_data.day==date]
467 |         X_train = train[features].values
468 |         X_eval =  valid[features].values
469 |         y_train = train['inNums'].values
470 |         y_eval = valid['inNums'].values
471 |         
472 |         print("\n Fold ", i)    
473 |         lgb_train = lgb.Dataset(X_train, y_train)
474 |         lgb_eval = lgb.Dataset(X_eval, y_eval, reference=lgb_train)
475 |         
476 |         lgb_model = lgb.train(lgb_params, 
477 |                              lgb_train,
478 |                              num_boost_round=10000,
479 |                              valid_sets=[lgb_train, lgb_eval],
480 |                              valid_names=['train', 'valid'],
481 |                              early_stopping_rounds=200,
482 |                              verbose_eval=1000,)
483 |         
484 |         # 用所有的数据训练再预测
485 |         all_train = lgb.Dataset(X_data, y_data)
486 |         lgb_model = lgb.train(lgb_params, 
487 |                              all_train,
488 |                              num_boost_round=lgb_model.best_iteration,
489 |                              valid_sets=[all_train],
490 |                              valid_names=['train'],
491 |                              verbose_eval=1000
492 |                              )
493 |         
494 |         in_lgb_pred += lgb_model.predict(X_test) / n
495 |         print("第%d轮训练结束"%(i+1))
496 |     print("完成！")
497 | 
498 | 
499 |     ## 预测出站流量
500 |     out_lgb_pred = np.zeros(len(X_test))
501 |     X_data = train_data[features].values
502 |     y_data = train_data['outNums'].values
503 |     for i, date in enumerate(slip):
504 |         train = train_data[train_data.day<date]
505 |         valid = train_data[train_data.day==date]
506 |         X_train = train[features].values
507 |         X_eval =  valid[features].values
508 |         y_train = train['outNums'].values
509 |         y_eval = valid['outNums'].values
510 |         
511 |         print("\n Fold ", i)
512 |         lgb_train = lgb.Dataset(X_train, y_train)
513 |         lgb_eval = lgb.Dataset(X_eval, y_eval, reference=lgb_train)
514 |         
515 |         lgb_model = lgb.train(lgb_params, 
516 |                              lgb_train,
517 |                              num_boost_round=10000,
518 |                              valid_sets=[lgb_train, lgb_eval],
519 |                              valid_names=['train', 'valid'],
520 |                              early_stopping_rounds=200,
521 |                              verbose_eval=1000,)
522 |         
523 |         # 用所有的数据训练再预测
524 |         all_train = lgb.Dataset(X_data, y_data)
525 |         lgb_model_out = lgb.train(lgb_params, 
526 |                              all_train,
527 |                              num_boost_round=lgb_model.best_iteration,
528 |                              valid_sets=[all_train],
529 |                              valid_names=['train'],
530 |                              verbose_eval=1000
531 |                              )
532 |         
533 |         out_lgb_pred += lgb_model_out.predict(X_test) / n
534 |         print("第%d轮训练结束"%(i+1))
535 |     print("完成！")
536 | 
537 |         ## 搭建CatBoost模型
538 |         # 设置模型参数
539 |     cat_params = {
540 |         'loss_function': 'MAE',
541 |         'eval_metric': 'MAE',
542 |         
543 |         'learning_rate': 0.08,
544 |         
545 |         'max_depth': 5,
546 |         'max_leaves_count': 60, 
547 | 
548 |         'reg_lambda': 2,
549 |         
550 |         'verbose': 1,
551 |         
552 |         'od_type': 'Iter',
553 |         'task_type': 'GPU'
554 |     }
555 | 
556 |     ## 预测进站流量
557 |     in_cat_pred = np.zeros(len(X_test))
558 |     X_data = train_data[features].values
559 |     y_data = train_data['inNums'].values
560 | 
561 | 
562 |     for i, date in enumerate(slip):
563 |         train = train_data[train_data.day<date]
564 |         valid = train_data[train_data.day==date]
565 |         X_train = train[features].values
566 |         X_eval =  valid[features].values
567 |         y_train = train['inNums'].values
568 |         y_eval = valid['inNums'].values
569 |         
570 |         print("\n Fold ", i)
571 |         cat_train = Pool(X_train, y_train)
572 |         cat_eval = Pool(X_eval, y_eval)
573 |         
574 |         cat_model = catboost.train(
575 |             pool = cat_train, params=cat_params,
576 |             eval_set=cat_eval, num_boost_round=50000,
577 |             verbose_eval=5000, early_stopping_rounds=200,)
578 |         
579 |         eval_pred = cat_model.predict(X_eval)
580 |         print("MAE = ", mean_absolute_error(y_eval, eval_pred))
581 |         
582 |         # all data
583 |         all_train = Pool(X_data, y_data)
584 |         cat_model = catboost.train(
585 |             pool = all_train, params=cat_params,
586 |             eval_set= all_train, num_boost_round=cat_model.best_iteration_,
587 |             verbose_eval=5000, early_stopping_rounds=200,)
588 |         in_cat_pred += cat_model.predict(X_test) / n
589 |         print("第%d轮完成"%(i+1))
590 |     print("全部结束！")
591 | 
592 |     ## 预测出站流量
593 |     out_cat_pred = np.zeros(len(X_test))
594 |     X_data = train_data[features].values
595 |     y_data = train_data['outNums'].values
596 | 
597 | 
598 |     for i, date in enumerate(slip):
599 |         train = train_data[train_data.day<date]
600 |         valid = train_data[train_data.day==date]
601 |         X_train = train[features].values
602 |         X_eval =  valid[features].values
603 |         y_train = train['outNums'].values
604 |         y_eval = valid['outNums'].values
605 |         
606 |         print("\n Fold ", i)
607 |         cat_train = Pool(X_train, y_train)
608 |         cat_eval = Pool(X_eval, y_eval)
609 |         
610 |         out_cat_model = catboost.train(
611 |             pool = cat_train, params=cat_params,
612 |             eval_set=cat_eval, num_boost_round=50000,
613 |             verbose_eval=5000, early_stopping_rounds=200,)
614 |         
615 |         eval_pred = out_cat_model.predict(X_eval)
616 |         print("MAE = ", mean_absolute_error(y_eval, eval_pred))
617 |         
618 |         # all data
619 |         all_train = Pool(X_data, y_data)
620 |         out_cat_model = catboost.train(
621 |             pool = all_train, params=cat_params,
622 |             eval_set= all_train, num_boost_round=out_cat_model.best_iteration_,
623 |             verbose_eval=5000, early_stopping_rounds=200,)
624 |         out_cat_pred += out_cat_model.predict(X_test) / n
625 |         print("第%d轮完成"%(i+1))
626 |     print("全部结束！")
627 | 
628 | 
629 |     ## 对模型结果进行平均
630 |     inNums = (in_cat_pred + in_lgb_pred) / 2
631 |     outNums = (out_cat_pred + out_lgb_pred) / 2
632 |     return inNums, outNums
633 | 
634 | 
635 | # 定义运行的主函数
636 | def main():
637 | 
638 |     test_28 = pd.read_csv(os.path.join(test_path, test_file))
639 | 
640 |     data = get_base_features(test_28)
641 | 
642 |     train_files = [f for f in sorted(os.listdir(train_path)) if f.endswith("csv")]
643 | 
644 |     for file in train_files:
645 |         print("正在处理...", file)
646 |         tmp = pd.read_csv(os.path.join(train_path, file))
647 | 
648 |         tmp = get_base_features(tmp)
649 |         data = pd.concat([data, tmp], axis=0, sort=False)
650 |     print("数据清洗完成！")
651 | 
652 |     # 加入相邻时间的流量信息
653 |     data = add_neighbor_time(data)
654 |     # 增加高峰时间信息
655 |     data = add_peak_type(data)
656 |     # 增加同周次的流量信息
657 |     data = add_week_flow(data)
658 |     # 增加线路信息
659 |     data = add_line(data)
660 |     # 增加站点类型信息
661 |     data = add_station_type(data)
662 |     # 增加特殊站点的标记
663 |     data = add_special_station(data)
664 |     # 连接训练特征和目标值
665 |     all_data, train_df = merge_train_test(data)
666 |     # 进行目标编码
667 |     all_data = target_encoding(all_data, train_df)
668 |     # 训练模型
669 |     inNums, outNums = train(all_data)
670 | 
671 |     # 添加进要提交的文件中
672 |     submission = pd.read_csv(os.path.join(test_path, sub_file))
673 |     submission['inNums'] = inNums
674 |     submission['outNums'] = outNums
675 |     submission.to_csv("submission.csv", index=False)
676 | 
677 | if __name__ == "__main__":
678 |     main()


--------------------------------------------------------------------------------