本文以经典的
波士顿房价预测任务为例，介绍使用Python语言和Numpy库来构建神经网络模型的过程和代码实现。
波士顿房价预测是一个经典的机器学习任务，波士顿地区的房价是由诸多因素影响的。该数据集统计了13种可能影响房价的因素和该类型房屋的均价，期望构建一个基于13个因素进行房价预测的模型。
波士顿放假影响因素示意图：
预测问题分为两类，该问题属于回归任务。
- 回归任务(输出连续的实数值) √
- 分类任务(输出离散的标签)
线性回归模型
假设房价和各影响因素之间能够用线性关系来描述：
模型的求解即是通过数据拟合出每个 (模型的权重)和b(模型的偏置)，一维情况下，两者分别是直线的斜率和截距。
均方差作为损失函数(Loss)，以衡量预测房价和真实房价的差异，公式如下：
采用均方差作为损失函数，即将模型在每个训练样本上的预测误差加和，以此来衡量整体样本的准确性。
线性回归模型的神经网络结构
线性回归模型可以认为是神经网络模型的一种极简特例，是一个只有加权和、没有非线性变换的神经元(无需形成网络)。
构建波士顿房价预测任务的神经网络模型
一、数据处理
数据处理包含五个部分，①数据导入②数据形状变换③数据集划分④数据归一化处理⑤封装load data函数。只有数据预处理后，才能被模型调用。训练数据housing.data附在文末。
数据导入
通过如下代码读入数据，了解下波士顿房价的数据集结构：
# 导入需要用到的package
import numpy as np
import json
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
# 读入训练数据
datafile = 'housing.data'
data = np.fromfile(datafile, sep=' ')
print(data)
--------------------------------------------------------
输出结果：
[6.320e-03 1.800e+01 2.310e+00 ... 3.969e+02 7.880e+00 1.190e+01]
数据形状变换
由于读入的原始数据是1维的，因此需要将数据的形状进行变换，形成一个2维的矩阵。
每行为一个数据样本(14个值)，每个数据样本包含13个X(影响房价的特征)和一个Y(该类型房屋的均价)。
# 读入之后的数据被转化成1维array，其中array的第0-13项是第一条数据，第14-27项是第二条数据，以此类推....
# 这里对原始数据做reshape，变成N x 14的形式
feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE','DIS',
'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]
feature_num = len(feature_names)
data = data.reshape([data.shape[0] // feature_num, feature_num])
# 查看数据
x = data[0]
print(x.shape)
print(x)
--------------------------------------------------------
输出结果：
[6.320e-03 1.800e+01 2.310e+00 0.000e+00 5.380e-01 6.575e+00 6.520e+01
4.090e+00 1.000e+00 2.960e+02 1.530e+01 3.969e+02 4.980e+00 2.400e+01]
数据集划分
将数据集划分成训练集和测试集，其中训练集用于确定模型的参数，测试集用于评判模型的效果。在本案例中，将80%的数据用作训练集，20%用作测试集，实现代码如下。
ratio = 0.8
offset = int(data.shape[0] * ratio)
training_data = data[:offset]
print(training_data.shape)
--------------------------------------------------------
输出结果：
(404, 14)
通过打印结果可知：共有404个样本，每个样本含有13个特征和1个预测值。
数据归一化处理
对每个特征进行归一化处理，使得每个特征的取值缩放到0~1之间。这样的好处是：
①模型训练更高效。
②特征前的权重大小可以代表该变量对预测结果的贡献度(因为每个特征值本身的范围相同)。
# 计算train数据集的最大值，最小值，平均值
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):
#print(maximums[i], minimums[i], avgs[i])
data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])
注意：若训练时做了归一化，预测时也需要进行归一化，需以训练样本的均值和极值计算。
封装成load data函数
将上述几个数据处理操作封装成load data函数，以便下一步模型的调用，代码如下。
# 导入需要用到的package
import numpy as np
import json
def load_data():
# 从文件导入数据
datafile = 'housing.data'
data = np.fromfile(datafile, sep=' ')
# 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数
feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', \
'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]
feature_num = len(feature_names)
# 将原始数据进行Reshape，变成[N, 14]这样的形状
data = data.reshape([data.shape[0] // feature_num, feature_num])
# 将原数据集拆分成训练集和测试集
# 这里使用80%的数据做训练，20%的数据做测试
# 测试集和训练集必须是没有交集的
ratio = 0.8
offset = int(data.shape[0] * ratio)
training_data = data[:offset]
# 计算train数据集的最大值，最小值，平均值
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):
#print(maximums[i], minimums[i], avgs[i])
data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])
# 训练集和测试集的划分比例
training_data = data[:offset]
test_data = data[offset:]
return training_data, test_data
# 获取数据
training_data, test_data = load_data()
x = training_data[:, :-1]
y = training_data[:, -1:]
# 查看数据
print('第一个样本的特征:',x[0])
print('第一个样本的预测值',y[0])
--------------------------------------------------------
输出结果：
第一个样本的特征: [-0.02146321 0.03767327 -0.28552309 -0.08663366 0.01289726 0.04634817
0.00795597 -0.00765794 -0.25172191 -0.11881188 -0.29002528 0.0519112
-0.17590923]
第一个样本的预测值 [-0.00390539]
二、模型设计
模型设计也称为网络结构设计，相当于模型的假设空间，即实现模型的前向计算(从输入到输出)的过程。如果将输入特征x和输出预测值z均以向量表示，输入特征有13个分量，输出预测值有1个分量，那么参数权重的形状(shape)是13×1。
以类的方式来做前向计算，生成类的实例，调用其方法来完成前向计算的代码如下：
1.使用时可以生成多个模型实例。
2.类成员变量有w和b，在类初始化函数中初始化变量。(w随机初始化,b=0)
3.函数成员forward完成从输入特征x到输出z的计算过程。
class Network(object):
def __init__(self, num_of_weights):
# 随机产生w的初始值
# 为了保持程序每次运行结果的一致性，
# 此处设置固定的随机数种子
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
net = Network(13)
x1 = x[0]
y1 = y[0]
z = net.forward(x1)
print('z的值为:',z)
--------------------------------------------------------
输出结果：
z的值为: [-0.63182506]
三、训练配置
模型设计完成后，需要通过训练配置寻找模型的最优值，即通过损失函数来衡量模型的好坏。对于回归问题，最常采用的是使用均方误差作为评价模型好坏的指标，具体定义如下：
代码实现如下:
Loss = (y1 - z)*(y1 - z)
又因为计算损失时需要把每个样本的损失都考虑到，所以需要对单个样本的损失函数进行求和，并除以样本总数N。
在Network类下面添加损失函数的计算过程如下：
class Network(object):
def __init__(self, num_of_weights):
# 随机产生w的初始值
# 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
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
def loss(self, z, y):
error = z - y
cost = error * error
cost = np.mean(cost)
return cost
net = Network(13)
# 此处可以一次性计算多个样本的预测值和损失函数
x1 = x[0:3]
y1 = y[0:3]
z = net.forward(x1)
print('predict: ', z)
loss = net.loss(z, y1)
print('loss:', loss)
--------------------------------------------------------
输出结果：
predict: [[-0.63182506]
[-0.55793096]
[-1.00062009]]
loss: 0.7229825055441156
四、训练过程
前文介绍了如何构建神经网络，通过神经网络完成预测值和损失函数的计算。接下来介绍如何求解参数w和b的数值，这个过程也称为模型训练过程。训练过程的目标是：让定义的损失函数Loss尽可能的小，也就是说找到一个参数解w和b使得损失函数取得极小值。
使用梯度下降法：
具体推导不再给出，直接将计算梯度下降与更新封装进Network函数中。
class Network(object):
def __init__(self, num_of_weights):
# 随机产生w的初始值
# 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子
#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
def loss(self, z, y):
error = z - y
num_samples = error.shape[0]
cost = error * error
cost = np.sum(cost) / num_samples
return cost
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 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, training_data, num_epoches, batch_size=10, eta=0.01):
n = len(training_data)
losses = []
for epoch_id in range(num_epoches):
# 在每轮迭代开始之前，将训练数据的顺序随机的打乱，
# 然后再按每次取batch_size条数据的方式取出
np.random.shuffle(training_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_batch in enumerate(mini_batches):
#print(self.w.shape)
#print(self.b)
x = mini_batch[:, :-1]
y = mini_batch[:, -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
# 获取数据
train_data, test_data = load_data()
# 创建网络
net = Network(13)
# 启动训练
losses = net.train(train_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()
--------------------------------------------------------
输出结果：
Epoch 0 / iter 0, loss = 0.2177
Epoch 0 / iter 1, loss = 0.2258
Epoch 0 / iter 2, loss = 0.2461
Epoch 0 / iter 3, loss = 0.2737
Epoch 0 / iter 4, loss = 0.0419
Epoch 1 / iter 0, loss = 0.2344
Epoch 1 / iter 1, loss = 0.1875
Epoch 1 / iter 2, loss = 0.2694
Epoch 1 / iter 3, loss = 0.2042
Epoch 1 / iter 4, loss = 0.4452
Epoch 2 / iter 0, loss = 0.1191
....
Epoch 47 / iter 4, loss = 0.0488
Epoch 48 / iter 0, loss = 0.0388
Epoch 48 / iter 1, loss = 0.0413
Epoch 48 / iter 2, loss = 0.0610
Epoch 48 / iter 3, loss = 0.0563
Epoch 48 / iter 4, loss = 0.0092
Epoch 49 / iter 0, loss = 0.0556
Epoch 49 / iter 1, loss = 0.0588
Epoch 49 / iter 2, loss = 0.0334
Epoch 49 / iter 3, loss = 0.0442
Epoch 49 / iter 4, loss = 0.0682
画出的图像如下：
观察Loss的变化，随机梯度下降加快了训练过程，但由于每次仅基于少量样本更新参数和计算损失，所以损失下降曲线会出现震荡。
由于房价预测的数据量过少，所以难以感受到随机梯度下降带来的性能提升。不过整体还是可以看到Loss是在不断下降的。
转载：https://blog.csdn.net/weixin_43691058/article/details/106041635