1 #!/usr/bin/env python
  2 # coding: utf-8
  3 
  4 # In[1]:
  5 
  6 
  7 # 如果没有安装pandas，则反注释下面一行
  8 # !pip install pandas
  9 
 10 get_ipython().run_line_magic(‘matplotlib‘, ‘inline‘)
 11 import d2lzh as d2l
 12 from mxnet import autograd, gluon, init, nd
 13 from mxnet.gluon import data as gdata, loss as gloss, nn
 14 import numpy as np
 15 import pandas as pd
 16 
 17 
 18 # In[2]:
 19 
 20 
 21 train_data = pd.read_csv(‘./data/kaggle_house_pred_train.csv‘)
 22 test_data = pd.read_csv(‘./data/kaggle_house_pred_test.csv‘)
 23 
 24 
 25 # In[3]:
 26 
 27 
 28 
 29 train_data.shape
 30 
 31 
 32 # In[4]:
 33 
 34 
 35 test_data.shape
 36 
 37 
 38 # In[5]:
 39 
 40 
 41 train_data.iloc[0:4, [0, 1, 2, 3, -3, -2, -1]]
 42 
 43 
 44 # In[6]:
 45 
 46 
 47 all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))
 48 
 49 
 50 # ### 预处理数据
 51 # 我们对连续数值的特征做标准化（standardization）：设该特征在整个数据集上的均值为μ，标准差为σ。那么，我们可以将该特征的每个值先减去μ再除以σ得到标准化后的每个特征值。对于缺失的特征值，我们将其替换成该特征的均值。
 52 
 53 # In[7]:
 54 
 55 
 56 numeric_features = all_features.dtypes[all_features.dtypes != ‘object‘].index
 57 all_features[numeric_features] = all_features[numeric_features].apply(
 58     lambda x: (x - x.mean()) / (x.std()))
 59 # 标准化后，每个特征的均值变为0，所以可以直接用0来替换缺失值
 60 all_features[numeric_features] = all_features[numeric_features].fillna(0)
 61 
 62 
 63 # 接下来将离散数值转成指示特征。举个例子，假设特征MSZoning里面有两个不同的离散值RL和RM，那么这一步转换将去掉MSZoning特征，并新加两个特征MSZoning_RL和MSZoning_RM，其值为0或1。如果一个样本原来在MSZoning里的值为RL，那么有MSZoning_RL=1且MSZoning_RM=0。
 64 
 65 # In[9]:
 66 
 67 
 68 # dummy_na=True将缺失值也当作合法的特征值并为其创建指示特征
 69 all_features = pd.get_dummies(all_features, dummy_na=True)
 70 all_features.shape
 71 
 72 
 73 # 可以看到这一步转换将特征数从79增加到了331。
 74 # 
 75 # 最后，通过values属性得到NumPy格式的数据，并转成NDArray方便后面的训练。
 76 
 77 # In[10]:
 78 
 79 
 80 n_train = train_data.shape[0]
 81 train_features = nd.array(all_features[:n_train].values)
 82 test_features = nd.array(all_features[n_train:].values)
 83 train_labels = nd.array(train_data.SalePrice.values).reshape((-1, 1))
 84 
 85 
 86 # In[11]:
 87 
 88 
 89 loss = gloss.L2Loss()
 90 
 91 def get_net():
 92     net = nn.Sequential()
 93     net.add(nn.Dense(1))
 94     net.initialize()
 95     return net
 96 
 97 
 98 # 下面定义比赛用来评价模型的对数均方根误差。给定预测值$\hat y_1, \ldots, \hat y_n$和对应的真实标签$y_1,\ldots, y_n$，它的定义为
 99 # 
100 # $$\sqrt{\frac{1}{n}\sum_{i=1}^n\left(\log(y_i)-\log(\hat y_i)\right)^2}.$$
101 #  
102 # 对数均方根误差的实现如下。
103 
104 # In[12]:
105 
106 
107 def log_rmse(net, features, labels):
108     # 将小于1的值设成1，使得取对数时数值更稳定
109     clipped_preds = nd.clip(net(features), 1, float(‘inf‘))
110     rmse = nd.sqrt(2 * loss(clipped_preds.log(), labels.log()).mean())
111     return rmse.asscalar()
112 
113 
114 # In[13]:
115 
116 
117 def train(net, train_features, train_labels, test_features, test_labels,
118           num_epochs, learning_rate, weight_decay, batch_size):
119     train_ls, test_ls = [], []
120     train_iter = gdata.DataLoader(gdata.ArrayDataset(
121         train_features, train_labels), batch_size, shuffle=True)
122     # 这里使用了Adam优化算法
123     trainer = gluon.Trainer(net.collect_params(), ‘adam‘, {
124         ‘learning_rate‘: learning_rate, ‘wd‘: weight_decay})
125     for epoch in range(num_epochs):
126         for X, y in train_iter:
127             with autograd.record():
128                 l = loss(net(X), y)
129             l.backward()
130             trainer.step(batch_size)
131         train_ls.append(log_rmse(net, train_features, train_labels))
132         if test_labels is not None:
133             test_ls.append(log_rmse(net, test_features, test_labels))
134     return train_ls, test_ls
135 
136 
137 # ### K 折交叉验证
138 # 我们在“模型选择、欠拟合和过拟合”中介绍了K折交叉验证。它将被用来选择模型设计并调节超参数。下面实现了一个函数，它返回第i折交叉验证时所需要的训练和验证数据。
139 
140 # In[14]:
141 
142 
143 def get_k_fold_data(k, i, X, y):
144     assert k > 1
145     fold_size = X.shape[0] // k
146     X_train, y_train = None, None
147     for j in range(k):
148         idx = slice(j * fold_size, (j + 1) * fold_size)
149         X_part, y_part = X[idx, :], y[idx]
150         if j == i:
151             X_valid, y_valid = X_part, y_part
152         elif X_train is None:
153             X_train, y_train = X_part, y_part
154         else:
155             X_train = nd.concat(X_train, X_part, dim=0)
156             y_train = nd.concat(y_train, y_part, dim=0)
157     return X_train, y_train, X_valid, y_valid
158 
159 
160 # In[15]:
161 
162 
163 #在 K 折交叉验证中我们训练 K 次并返回训练和验证的平均误差。
164 def k_fold(k, X_train, y_train, num_epochs,
165            learning_rate, weight_decay, batch_size):
166     train_l_sum, valid_l_sum = 0, 0
167     for i in range(k):
168         data = get_k_fold_data(k, i, X_train, y_train)
169         net = get_net()
170         train_ls, valid_ls = train(net, *data, num_epochs, learning_rate,
171                                    weight_decay, batch_size)
172         train_l_sum += train_ls[-1]
173         valid_l_sum += valid_ls[-1]
174         if i == 0:
175             d2l.semilogy(range(1, num_epochs + 1), train_ls, ‘epochs‘, ‘rmse‘,
176                          range(1, num_epochs + 1), valid_ls,
177                          [‘train‘, ‘valid‘])
178         print(‘fold %d, train rmse %f, valid rmse %f‘
179               % (i, train_ls[-1], valid_ls[-1]))
180     return train_l_sum / k, valid_l_sum / k
181 
182 
183 # In[16]:
184 
185 
186 #模型选择----我们使用一组未经调优的超参数并计算交叉验证误差。可以改动这些超参数来尽可能减小平均测试误差。
187 k, num_epochs, lr, weight_decay, batch_size = 5, 100, 5, 0, 64
188 train_l, valid_l = k_fold(k, train_features, train_labels, num_epochs, lr,
189                           weight_decay, batch_size)
190 print(‘%d-fold validation: avg train rmse %f, avg valid rmse %f‘
191       % (k, train_l, valid_l))
192 
193 
194 # In[17]:
195 
196 
197 #预测并在Kaggle提交结果
198 def train_and_pred(train_features, test_features, train_labels, test_data,
199                    num_epochs, lr, weight_decay, batch_size):
200     net = get_net()
201     train_ls, _ = train(net, train_features, train_labels, None, None,
202                         num_epochs, lr, weight_decay, batch_size)
203     d2l.semilogy(range(1, num_epochs + 1), train_ls, ‘epochs‘, ‘rmse‘)
204     print(‘train rmse %f‘ % train_ls[-1])
205     preds = net(test_features).asnumpy()
206     test_data[‘SalePrice‘] = pd.Series(preds.reshape(1, -1)[0])
207     submission = pd.concat([test_data[‘Id‘], test_data[‘SalePrice‘]], axis=1)
208     submission.to_csv(‘submission.csv‘, index=False)
209 
210 
211 # In[18]:
212 
213 
214 train_and_pred(train_features, test_features, train_labels, test_data,
215                num_epochs, lr, weight_decay, batch_size)