-
前提说明
数据详情:
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200524203904743.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hcnV0b2R6eA==,size_16,color_FFFFFF,t_70)
构建波士顿房价预测任务的神经网络模型步骤:
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200524204137427.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hcnV0b2R6eA==,size_16,color_FFFFFF,t_70)
-
数据处理
数据处理包含五个部分:数据导入、数据形状变换、数据集划分、数据归一化处理和封装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)
data = firstdata.reshape([firstdata.shape[0] // feature_num, feature_num])
ratio = 0.8
offset = int(data.shape[0] * ratio)
training_data = data[:offset]
maximums, minimums, avgs = training_data.max(axis=0), training_data.min(axis=0), training_data.sum(axis=0) / \
training_data.shape[0]
for i in range(feature_num):
data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])
training_data = data[:offset]
test_data = data[offset:]
return training_data, test_data
-
模型设计
模型设计是深度学习模型关键要素之一,也称为网络结构设计,相当于模型的假设空间,即实现模型“前向计算”(从输入到输出)的过程。
类成员变量有参数w和b。通过写一个forward函数(代表“前向计算”)完成上述从特征和参数到输出预测值的计算过程,代码如下所示。
class Network(object):
def __init__(self, num_of_weights):
np.random.seed(0)
self.w = np.random.randn(num_of_weights, 1)
self.b = 0.
def forward(self, x):
z = np.dot(x, self.w) + self.b
return z
-
训练配置
模型设计完成后,需要通过训练配置寻找模型的最优值,即通过损失函数来衡量模型的好坏。训练配置也是深度学习模型关键要素之一。
在Network类下面添加损失函数,代码如下:
def loss(self, z, y):
error = z - y
num_samples = error.shape[0]
cost = error * error
cost = np.sum(cost) / num_samples
return cost
-
训练过程
训练过程是深度学习模型的关键要素之一,其目标是让定义的损失函数Loss尽可能的小,也就是说找到一个参数解w和b使得损失函数取得极小值。
使用梯度下降法,并用numpy进行梯度计算,在Network类下面添加gradient函数,代码如下:
def gradient(self, x, y):
z = self.forward(x)
gradient_w = (z - y) * x
gradient_w = np.mean(gradient_w, axis=0)
gradient_w = gradient_w[:, np.newaxis]
gradient_b = (z - y)
gradient_b = np.mean(gradient_b)
return gradient_w, gradient_b
确定损失函数更小的点,封装在train和update函数中,并在Network中添加,代码如下:
def update(self, gradient_w, gradient_b, eta=0.01):
self.w = self.w - eta * gradient_w
self.b = self.b - eta * gradient_b
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)
if (i + 1) % 10 == 0:
print('iter {}, loss{}'.format(i, L))
return losses
开始训练以及作图,代码如下:
training_data, test_data = load_data()
x = training_data[:, :-1]
y = training_data[:, -1:]
net = Network(13)
num_iterations = 1000
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()
输出结果:
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200525105423528.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hcnV0b2R6eA==,size_16,color_FFFFFF,t_70)
-
使用随机梯度下降法提高效率
在上述程序中,每次损失函数和梯度计算都是基于数据集中的全量数据。但在实际问题中,数据集往往非常大,如果每次都使用全量数据进行计算,效率非常低。
一个合理的解决方案是每次从总的数据集中随机抽取出小部分数据来代表整体,基于这部分数据计算梯度和损失来更新参数,这种方法被称作随机梯度下降法(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]
gradient_w = 1. / N * np.sum((z-y) * x, axis=0)
gradient_w = gradient_w[:, np.newaxis]
gradient_b = 1. / N * np.sum(z-y)
return gradient_w, gradient_b
训练数据导入后,越接近模型训练结束,最后几个批次数据对模型参数的影响越大。为了避免模型记忆影响训练效果,需要进行样本乱序操作。
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)
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):
x = mini_batche[:, :-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)
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()
输出结果:
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200525114632315.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hcnV0b2R6eA==,size_16,color_FFFFFF,t_70)
-
总结
在两层循环的内部中经典的四步训练流程:前向计算->计算损失->计算梯度->更新参数