深度学习系统学习系列【3】之血液检测项目

• 通过构建一个3 层的人工神经网络ANN模型对收集到的数据进行训练，得到该医疗数据的分类模型，最后利用新的医疗数据，预测其所属病理分类。

血液检测项目

• 本次血液检测项目只有链球菌$x_1$和葡萄球菌$x_2$两种，身体血液中对于不同的球菌组合会呈现不同的病原体（不同的病症）。 现在假设有两个分类，分别是病原体I和病原体 II，分别用蓝色和灰色表达： x轴表示链球菌的值， y轴表示葡萄球菌的值。

项目实现步骤

项目导包和自定义分类边界函数

import matplotlib.pyplot as plt
import numpy as np
from mpmath.libmp.backend import xrange
from sklearn import datasets
from sklearn import linear_model

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

def plot_decision_boundary(pred_func, data, labels):
    # 绘制分类边界函数
    x_min, x_max = data[:, 0].min() - 0.5, data[:, 0].max() + 0.5
    y_min, y_max = data[:, 1].min() - 0.5, data[:, 1].max() + 0.5
    
    # 生成一个点阵网格，点阵间距为h
    h = 0.01  # 点阵间距
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    # 计算分类结果z
    z = pred_func(np.c_[xx.ravel(), yy.ravel()])
    z = z.reshape(xx.shape)
    # 绘制轮廓和训练样本，轮廓颜色使用Blues透明度0.2
    plt.contourf(xx, yy, z, cmap=plt.cm.Blues, alpha=0.2)
    plt.scatter(data[:, 0], data[:, 1], s=40, c=labels, cmap=plt.cm.tab20c, edgecolors="Black")

准备数据

• 本例中产生的医疗数据是通过skiearn 的 datasets 产生的，并不是真实的医疗数据。

# 医疗数据是通过sklearn的datasets产生的，并不是真实的医疗数据
np.random.seed(0)
X, y = datasets.make_moons(300, noise=0.25)  # 300个数据点，噪声设定0.25

# 显示产生的医疗数据 深色 病原体Ⅰ 浅色 病原体Ⅱ
plt.scatter(X[:, 0], X[:, 1], s=50, c=y, cmap=plt.cm.tab20c, edgecolors="Black")

plt.title('Medical Data Analysis')
plt.xlabel("链球菌值")
plt.ylabel("葡萄球菌值")
plt.show()

线性分类

• 对数据进行二分类最直接有效的方法就是采用线性回归分类器，下面使用 skleam的 LogisticRegressionCV 函数对数据进行二分类。

# 使用scikit-learn的线性回归分类器
logistic_fun = linear_model.LogisticRegressionCV()
logistic_fun.fit(X, y)
# 示线性分类结果
plot_decision_boundary(lambda x: logistic_fun.predict(x), X, y)
plt.title("Logistic Regression Result")
plt.xlabel("链球菌值")
plt.ylabel("葡萄球菌值")
plt.show()

• 逻辑回归算法直接用直线将数据分隔为两类。从图中可以清晰地看到该分类结果远远不能满足真实
  目的。

人工神经网络模型

• 在现实生活当中，数据大多是线性不可分的，因此我们不能简单地使用直线将数据划分为两份。为减少误差， 提升分类的结果和质量，可以采用人工神经网络对数据进行预测分类。

设计人工神经网络模型

1. 建立一个3 层神经网络模型，包括输入层、隐层、输出层。
2. 输入层中的神经节点数目由输入数据的维数决定，本例中有链球菌$x_1$和葡萄球菌$x_2$，因此输入数据维度是$2$，输入由2个神经元节点组成。同理，输出层中的节点数目由输出的分类维度决定， 本例中为病原体 I(O）和病原体 II(1），因此输出层由 2个神经元组成。
3. 人工神经网络的定义图
   
4. 激活函数使用Tanh函数，输出层函数使用Softmax函数

• 在神经网络中Softmax 函数常作用于输出层，将神经网络的输出向量转换成同分布的概率分布。

5. 损失函数采用交叉熵损失函数（负对数似然函数），假设$N$个训练样本，对应C个分类，预测值$\hat{y}$与真实值$y$的损失函数为：
   $$L(y,\hat{y})=-\frac{1}{N}\sum _{n\in N}\sum _{i\in C}{y}_{n,i}log{\hat{y}}_{n,i}$$
6. 梯度下降算法使用固定学习率$\eta$的批量梯度下降算法$$x\leftarrow x-\eta \Delta x$$对本例中人工智能模型中用到的参数$W_1,b_1,W_2,b_2$求导，对权重和偏置参数进行求导则是利用 BP反向传播算法，可以得到网络中各个参数的偏导
   $$\begin{array}{rl}{\mathbf{\delta }}_3& =\hat{\mathbf{y}}-\mathbf{y}\\ {\mathbf{\delta }}_2& =\left(1-{\tanh }^2({\mathbf{z}}_1)\right)\times {\mathbf{\delta }}_3{\mathbf{W}}_2^T\\ \frac{\partial L}{\partial {\mathbf{W}}_2}& ={\mathbf{a}}_1^T{\mathbf{\delta }}_3\\ \frac{\partial L}{\partial {\mathbf{b}}_2}& ={\mathbf{\delta }}_3\\ \frac{\partial L}{\partial {\mathbf{W}}_1}& ={\mathbf{x}}^T{\mathbf{\delta }}_2\\ \frac{\partial L}{\partial {\mathbf{b}}_1}& ={\mathbf{\delta }}_2\end{array}$$

实现损失函数和预测函数

1. model 字典中存储着网络中的权重参数和偏置参数，通过model 获取网络中的参数$w_1,b_1,w_2,b_2$，使用神经网络的前馈公式进行前馈计算。 前馈计算后得到预测的输出值 probs,再用 probs与真实的输出值y来计算损失值。

# 人工神经网络实现
# 1 定义参数 input_dim 输入维度 output_dim 输出维度
input_dim, output_dim = 2, 2
epsilon = 0.01  # 梯度下降的学习率
reg_lambda = 0.01  # 正则化强度


# 损失函数
def calculate_loss(model):
    num_examples = len(X)  # 训练集大小
    w1, b1, w2, b2 = model['W1'], model['b1'], model['W2'], model['b2']

    # 使用正向传播计算预测值
    z1 = X.dot(w1) + b1
    a1 = np.tanh(z1)
    z2 = a1.dot(w2) + b2
    exp_scores = np.exp(z2)
    probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)

    # 计算损失
    data_loss = np.sum(-np.log(probs[range(num_examples), y]))
    # 正则化
    data_loss += reg_lambda / 2 * (np.sum(np.square(w1)) + np.sum(np.square(w2)))
    return 1. / num_examples * data_loss


# 预测函数
def predict(model, x):
    w1, b1, w2, b2 = model['W1'], model['b1'], model['W2'], model['b2']
    # 正向传播
    z1 = x.dot(w1) + b1
    a1 = np.tanh(z1)
    z2 = a1.dot(w2) + b2
    exp_scores = np.exp(z2)
    probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
    return np.argmax(probs, axis=1)

人工神经网络模型整体函数

• ann_model()函数实现反向传播算法来计算梯度下降。
• 迭代次数为20000次，使用批量梯度下降算法

# 人工神经网络模型整体函数
def ann_model(x, y, nn_hdim):
    """
    人工神经网络模型函数
    :param x:
    :param y:
    :param nn_hdim: 隐层的神经元节点（隐层的数目）
    :return:
    """
    num_indim = len(x)  # 输入维度
    model = {}  # 模型参数
    # 随机初始化网络中的权重参数w1、w2和偏置b1、b2
    np.random.seed(0)
    w1 = np.random.randn(input_dim, nn_hdim) / np.sqrt(input_dim)
    b1 = np.zeros((1, nn_hdim))
    w2 = np.random.randn(nn_hdim, output_dim) / np.sqrt(nn_hdim)
    b2 = np.zeros((1, output_dim))

    # 批量梯度下降算法 BSGD
    num_passes = 20000  # 迭代次数
    for i in xrange(0, num_passes):
        z1 = x.dot(w1) + b1
        a1 = np.tanh(z1)
        z2 = a1.dot(w2) + b2
        exp_scores = np.exp(z2)
        probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)

        # 向后传播算法
        delta3 = probs  # 获取预测值
        delta3[range(len(x)), y] -= 1  # 预测值减去真实值
        delta2 = delta3.dot(w2.T) * (1 - np.power(a1, 2))
        dW2 = a1.T.dot(delta3)  # w2的倒数
        db2 = np.sum(delta3, axis=0, keepdims=True)  # b2的倒数
        dW1 = np.dot(x.T, delta2)  # w1的倒数
        db1 = np.sum(delta2, axis=0)  # b1的倒数

        # 添加正则项
        dW1 += reg_lambda * w1
        dW2 += reg_lambda * w2

        # 根据梯度下降算法更新权重
        w1 += -epsilon * dW1 # epsilon 
        w2 += -epsilon * dW2
        b1 += -epsilon * db1
        b2 += -epsilon * db2

        # 把新的参数写入model 字典中进行记录
        model = {'W1': w1, 'b1': b1, 'W2': w2, 'b2': b2}

        if i % 1000 == 0:
            print("迭代次数：{}，损失函数：{}".format(i, calculate_loss(model)))
    return model

隐层节点数效果对比

• 研究不同的隐层节点数（隐层中神经元的数量）对ANN模型的影响。使用$list$来记录被测试的不同隐层节点数，分别是$[1,2,3,4,5,15,30,50]$，然后使用$for$来迭代$Python$的$enumerate$对象

# 定义输出图像的大小
plt.figure(figsize=(32, 16))

# 待输入的隐层节点数list
hidden_layer_dimensions = [1, 2, 3, 4, 30, 50]

for i, nn_hdim in enumerate(hidden_layer_dimensions):
    plt.subplot(2, 3, i + 1)
    plt.title('Hidden Layer size %d' % nn_hdim)
    model = ann_model(X, y, nn_hdim)  # 建立 nn_hdim 个神经元的隐层
    plot_decision_boundary(lambda x: predict(model, x), X, y)  # 输出 ANN 模型分类结果
plt.show()

• 结果：隐层数在低维（3, 4,5）时能够很好地表达数据的分类属性。随着隐层中节点数的增加，过度拟合的可能性越高（如隐层数为 50）。

结论

• 神经网络并不非隐层数越多或者隐层节点越多效果越好。因此在实际工程中，要重视训练结果和效果可视化。