深度学习——入门经典案例《波士顿房价预测》深度解析

一、深度学习

机器学习算法理论在上个世纪90年代发展成熟，在许多领域都取得了成功应用。但平静的日子只延续到2010年左右，随着大数据的涌现和计算机算力提升，深度学习模型异军突起，极大改变了机器学习的应用格局。今天，多数机器学习任务都可以使用深度学习模型解决，尤其在在语音、计算机视觉和自然语言处理等领域，深度学习模型的效果比传统机器学习算法有显著提升。

有关机器学习、深度学习的详细介绍及其之间的联系可查看下方链接
https://www.paddlepaddle.org.cn/tutorials/projectdetail/328689

二、《波士顿房价预测》案例详解

项目完整代码和数据集已经上传，点击链接查看
https://github.com/Narutoooooooo/boston-house-price-forecast

1. 前提说明

   数据详情：
   
   构建波士顿房价预测任务的神经网络模型步骤：
   

2. 数据处理
   数据处理包含五个部分：数据导入、数据形状变换、数据集划分、数据归一化处理和封装load data函数。
   数据预处理后，才能被模型调用。

   数据归一化参考https://blog.csdn.net/program_developer/article/details/78637711

   实现代码如下：

   import numpy as np
   import matplotlib.pyplot as plt
   
   def load_data():
       # 读取以空格分开的文件，变成一个连续的数组
       firstdata = np.fromfile('housing.data', sep=' ')
       # 添加属性
       feature_names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT',
                        'MEDV']
       # 列的长度
       feature_num = len(feature_names)
       # print(firstdata.shape)  输出结果:(7084, )
       # print(firstdata.shape[0] // feature_nums)  输出结果:506
       # 构造506*14的二维数组
       data = firstdata.reshape([firstdata.shape[0] // feature_num, feature_num])
   	
   	# 将数据集划分成训练集和测试集，其中训练集用于确定模型的参数，测试集用于评判模型的效果。
       # 训练集设置为总数据的80%
       ratio = 0.8
       offset = int(data.shape[0] * ratio)
       training_data = data[:offset]
       # print(training_data.shape)
   
       # axis=0表示列
       # axis=1表示行
       # \表示换行，无需输入
       maximums, minimums, avgs = training_data.max(axis=0), training_data.min(axis=0), training_data.sum(axis=0) / \
                                  training_data.shape[0]
       # 查看训练集每列的最大值、最小值、平均值
       # print(maximums, minimums, avgs)
   
       # 对所有数据进行归一化处理
       for i in range(feature_num):
           # print(maximums[i], minimums[i], avgs[i])
           # 归一化，减去平均值是为了移除共同部分，凸显个体差异
           data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])
   
       # 覆盖上面的训练集
       training_data = data[:offset]
       # 剩下的20%为测试集
       test_data = data[offset:]
       return training_data, test_data
   

3. 模型设计
   模型设计是深度学习模型关键要素之一，也称为网络结构设计，相当于模型的假设空间，即实现模型“前向计算”（从输入到输出）的过程。

   类成员变量有参数w和b。通过写一个forward函数（代表“前向计算”）完成上述从特征和参数到输出预测值的计算过程，代码如下所示。

   class Network(object):
       def __init__(self, num_of_weights):
           # 随即产生w的初始值
           # seed(0)表示设置了随机种子，保证程序每次运行结果的一致性
           np.random.seed(0)
           # self.w的结构为num_of_weights行，1列
           self.w = np.random.randn(num_of_weights, 1)
           # b初始化为0
           self.b = 0.
   
       def forward(self, x):
           # dot()功能：向量点积和矩阵乘法
           # 根据下面x的取值可以确定x和z的结构
           z = np.dot(x, self.w) + self.b
           return z
   

4. 训练配置
   模型设计完成后，需要通过训练配置寻找模型的最优值，即通过损失函数来衡量模型的好坏。训练配置也是深度学习模型关键要素之一。
   在Network类下面添加损失函数，代码如下：

       def loss(self, z, y):
           # 根据下面y的取值可以确定y的结构
           error = z - y
           # num_samples为总行数404
           num_samples = error.shape[0]
           # cost为均方误差，用来评价模型的好坏
           cost = error * error
           # 计算损失时需要把每个样本的损失都考虑到
           # 对单个样本的损失函数进行求和，并除以样本总数
           cost = np.sum(cost) / num_samples
           return cost
   

5. 训练过程
   训练过程是深度学习模型的关键要素之一，其目标是让定义的损失函数Loss尽可能的小，也就是说找到一个参数解w和b使得损失函数取得极小值。
   使用梯度下降法，并用numpy进行梯度计算，在Network类下面添加gradient函数，代码如下：

       def gradient(self, x, y):
           # 调用forward函数，得到z
           z = self.forward(x)
           # 计算w梯度，得到一个13维向量，每个分量分别代表该维度的梯度
           gradient_w = (z - y) * x
           # 均值函数mean：求均值
           # axis 不设置值，对 m*n 个数求均值，返回一个实数
           # axis = 0：压缩行，对各列求均值，返回 1* n 矩阵
           # axis =1 ：压缩列，对各行求均值，返回 m *1 矩阵
           gradient_w = np.mean(gradient_w, axis=0)
           # 增加维度，变成 n * 1 的矩阵
           gradient_w = gradient_w[:, np.newaxis]
           # 计算b的梯度
           gradient_b = (z - y)
           # b为一个数值，不需要再增加维度
           gradient_b = np.mean(gradient_b)
           return gradient_w, gradient_b
   

   确定损失函数更小的点，封装在train和update函数中，并在Network中添加，代码如下：

   # 确定损失函数更小的点
       # 更新梯度
       def update(self, gradient_w, gradient_b, eta=0.01):
           # 更新参数
           # 相减：参数需要向梯度的反方向移动。
           # eta：控制每次参数值沿着梯度反方向变动的大小，即每次移动的步长，又称为学习率。
           self.w = self.w - eta * gradient_w
           self.b = self.b - eta * gradient_b
   
       # 迭代100次，每次移动0.01
       def train(self, x, y, iterations=100, eta=0.01):
           losses = []
           for i in range(iterations):
               z = self.forward(x)
               L = self.loss(z, y)
               gradient_w, gradient_b = self.gradient(x, y)
               self.update(gradient_w, gradient_b, eta)
               losses.append(L)
               # 循环输出i末尾为9，间隔为10的数据
               if (i + 1) % 10 == 0:
                   print('iter {}, loss{}'.format(i, L))
           return losses
   

   开始训练以及作图，代码如下：

   # 获取数据
   training_data, test_data = load_data()
   # 取训练集全部行的前13列
   x = training_data[:, :-1]
   # 取训练集全部行的最后一列
   y = training_data[:, -1:]
   # 创建网络
   net = Network(13)
   num_iterations = 1000
   # 启动训练，迭代次数为1000，步长为0.01
   losses = net.train(x, y, iterations=num_iterations, eta=0.01)
   
   # 画出损失函数的变化趋势
   plot_x = np.arange(num_iterations)
   plot_y = np.array(losses)
   plt.plot(plot_x, plot_y)
   plt.show()
   
   

   输出结果：
   

6. 使用随机梯度下降法提高效率
   在上述程序中，每次损失函数和梯度计算都是基于数据集中的全量数据。但在实际问题中，数据集往往非常大，如果每次都使用全量数据进行计算，效率非常低。
   一个合理的解决方案是每次从总的数据集中随机抽取出小部分数据来代表整体，基于这部分数据计算梯度和损失来更新参数，这种方法被称作随机梯度下降法（Stochastic Gradient Descent，SGD），核心概念如下：

   min-batch：每次迭代时抽取出来的一批数据被称为一个min-batch。
   batch_size：一个mini-batch所包含的样本数目称为batch_size。
   epoch：当程序迭代的时候，按mini-batch逐渐抽取出样本，当把整个数据集都遍历到了的时候，则完成了一轮的训练，也叫一个epoch。启动训练时，可以将训练的轮数num_epochs和batch_size作为参数传入。

   需要修改数据处理和训练过程的代码
   代码修改：

   	# 计算梯度的另一种方法，可以不修改
       def gradient(self, x, y):
           z = self.forward(x)
           # 取数据的行数
           N = x.shape[0]
           # 计算w的梯度，总数相加再除以N
           gradient_w = 1. / N * np.sum((z-y) * x, axis=0)
           # 增加维度
           gradient_w = gradient_w[:, np.newaxis]
           # 计算b的梯度，同上
           gradient_b = 1. / N * np.sum(z-y)
           return gradient_w, gradient_b
   

   训练数据导入后，越接近模型训练结束，最后几个批次数据对模型参数的影响越大。为了避免模型记忆影响训练效果，需要进行样本乱序操作。

   # num_epoches为训练的轮数，eta为步长
       def train(self, training_data, num_epoches, batch_size=10, eta=0.01):
           n = len(training_data)
           losses = []
           for epoch_id in range(num_epoches):
               # 打乱样本顺序
               np.random.shuffle(training_data)
               # 将train_data分成多个mini_batch
               # 循环取值，每次取出batch_size条数据
               mini_batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)]
               for iter_id, mini_batche in enumerate(mini_batches):
                   # 取mini_batch的前13列
                   x = mini_batche[:, :-1]
                   # 取mini_batch的最后1列
                   y = mini_batche[:, -1:]
                   # 前向计算
                   a = self.forward(x)
                   # 计算损失
                   loss = self.loss(a, y)
                   # 计算梯度
                   gradient_w, gradient_b = self.gradient(x, y)
                   # 更新参数
                   self.update(gradient_w, gradient_b, eta)
                   losses.append(loss)
                   print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.format(epoch_id, iter_id, loss))
           return losses
   

   开始训练以及作图，代码如下：

   # 获取数据
   training_data, test_data = load_data()
   # 创建网络
   net = Network(13)
   # 启动训练，训练50轮，每轮样本数目为100，步长为0.1
   losses = net.train(training_data, num_epoches=50, batch_size=100, eta=0.1)
   
   # 画出损失函数的变化趋势
   plot_x = np.arange(len(losses))
   plot_y = np.array(losses)
   plt.plot(plot_x, plot_y)
   plt.show()
   
   

   输出结果：
   

7. 总结
   在两层循环的内部中经典的四步训练流程：前向计算->计算损失->计算梯度->更新参数

参考：

【1】https://www.paddlepaddle.org.cn/tutorials/projectdetail/342081
【2】https://blog.csdn.net/qq_34732729/article/details/104015433
【3】https://blog.csdn.net/program_developer/article/details/78637711