神经网络完成数据非线性切分实践

最新推荐文章于 2022-11-07 20:59:36 发布

myourdream2

最新推荐文章于 2022-11-07 20:59:36 发布

阅读量508

点赞数 2

分类专栏： Machine Learning

本文链接：https://blog.csdn.net/myourdream2/article/details/87557163

版权

Machine Learning 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

神经网络有着非常强的非线性表达能力，可以对复杂的问题进行学习和表达。

以分类问题为例，现实生活中的很多分类场景是不可线性切分的，那特征的处理就尤为重要了，有意思的是，手造特征这件事情靠人工来做是非常容易达到瓶颈的，而且每换一个场景都需要重新结合场景构建一次特征，而深度学习这种端到端的学习方式，非常擅长进行表示学习，在每一次的前向计算过程中，就在自动地做特征映射，而到达最后分类层(softmax层)的时候，其实构造出来的特征空间里，样本已经是能近似线性切分的了，于是可以非常好地完成样本的非线性切分。

下面我们来看一个例子，用最简单的多层感知器(单隐层)对样本点进行非线性切分。

关键词：前向传播、反向传播、梯度下降、权值更新

1. 参考教程实践代码

课程链接：https://mooc.study.163.com/smartSpec/detail/1001473001.htm?share=1&shareId=1015252963

# 神经网络完成数据非线性切分
# notebook作者：@寒小阳
#
# 神经网络有着非常强的非线性表达能力，可以对复杂的问题进行学习和表达。
#
# 以分类问题为例，现实生活中的很多分类场景是不可线性切分的，那特征的处理就尤为重要了，有意思的是，手造特征这件事情靠
# 人工来做是非常容易达到瓶颈的，而且每换一个场景都需要重新结合场景构建一次特征，而深度学习这种端到端的学习方式，非常
# 擅长进行表示学习，在每一次的前向计算过程中，就在自动地做特征映射，而到达最后分类层(softmax层)的时候，其实构造出来的
# 特征空间里，样本已经是能近似线性切分的了，于是可以非常好地完成样本的非线性切分。
#
# 下面我们来看一个例子，用最简单的多层感知器(单隐层)对样本点进行非线性切分。
#
# 这里为了给大家展示神经网络的训练细节，我们手写了神经网络的前向计算和反向传播，以及梯度下降优化调参。大家在后续的课程
# 里会学到使用AI生态工具库(tensorflow、pytorch、keras)构建神经网络更快捷地解决这个问题。
#
# 课程链接：https://mooc.study.163.com/smartSpec/detail/1001473001.htm?share=1&shareId=1015252963

import numpy as np
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt

# 手动生成一个随机的平面点分布，并画出来
np.random.seed(0)
X, y = make_moons(200, noise=0.20)
plt.scatter(X[:, 0], X[:, 1], s=40, c=y, cmap=plt.cm.Spectral)
plt.show()


# 咱们先定义一个函数来画决策边界
def plot_decision_boundary(pred_func):
    # 设定最大最小值，附加一点点边缘填充
    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
    h = 0.01

    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

    # 用预测函数预测一下
    Z = pred_func(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)

    # 然后画出图
    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)


# 我们先用传统的逻辑回归来做一下分类，并画出判定边界
from sklearn.linear_model import LogisticRegressionCV

# 咱们先来瞄一眼逻辑斯特回归对于它的分类效果
clf = LogisticRegressionCV()
clf.fit(X, y)

# 画一下决策边界
plot_decision_boundary(lambda x: clf.predict(x))
plt.title("Logistic Regression")
plt.show()

# 咱们来试一个简单的人工神经网络
num_examples = len(X)  # 样本数
nn_input_dim = 2  # 输入的维度
nn_output_dim = 2  # 输出的类别个数

# 梯度下降参数
epsilon = 0.01  # 学习率
reg_lambda = 0.01  # 正则化参数


# 定义损失函数
def calculate_loss(model):
    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)
    # 计算损失
    corect_logprobs = -np.log(probs[range(num_examples), y])
    data_loss = np.sum(corect_logprobs)
    # 也得加一下正则化项
    data_loss += reg_lambda / 2 * (np.sum(np.square(W1)) + np.sum(np.square(W2)))
    return 1. / num_examples * data_loss


# 完整的训练建模函数定义
def build_model(nn_hdim, num_passes=20000, print_loss=False):
    """
    参数：
    1) nn_hdim: 隐层节点个数
    2）num_passes: 梯度下降迭代次数
    3）print_loss: 设定为True的话，每1000次迭代输出一次loss的当前值
    """
    # 随机初始化一下权重呗
    np.random.seed(0)
    W1 = np.random.randn(nn_input_dim, nn_hdim) / np.sqrt(nn_input_dim)
    b1 = np.zeros((1, nn_hdim))
    W2 = np.random.randn(nn_hdim, nn_output_dim) / np.sqrt(nn_hdim)
    b2 = np.zeros((1, nn_output_dim))

    # 这是咱们最后学到的模型
    model = {}

    # 开始梯度下降...
    for i in range(0, num_passes):

        # 前向运算计算loss

        #####   Code here！   #####
        # 3行代码写出Z2的定义
        z1 = X.dot(W1) + b1
        a1 = np.tanh(z1)
        z2 = a1.dot(W2) + b2

        ####    Code end.     ####
        exp_scores = np.exp(z2)
        probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)

        # 反向传播
        delta3 = probs
        delta3[range(num_examples), y] -= 1
        dW2 = (a1.T).dot(delta3)
        db2 = np.sum(delta3, axis=0, keepdims=True)
        delta2 = delta3.dot(W2.T) * (1 - np.power(a1, 2))
        dW1 = np.dot(X.T, delta2)
        db1 = np.sum(delta2, axis=0)

        # 加上正则化项
        dW2 += reg_lambda * W2
        dW1 += reg_lambda * W1

        # 梯度下降更新参数
        W1 += -epsilon * dW1
        b1 += -epsilon * db1
        #####   Code here！   #####
        # 2行代码分别写出w2和b2的定义（别忘了现在在循环里哟~）
        W2 += -epsilon * dW2
        b2 += -epsilon * db2

        ####    Code end.     ####

        # 得到的模型实际上就是这些权重
        model = {'W1': W1, 'b1': b1, 'W2': W2, 'b2': b2}

        # 如果设定print_loss了，那我们汇报一下中间状况
        if print_loss and i % 1000 == 0:
            print("在迭代%i轮后的损失函数值为:%f" % (i, calculate_loss(model)))
            # print("在迭代%i轮后的损失函数值为: %f,W1:%f,b1:%f,W2:%f,b2:%f" % (i, calculate_loss(model), W1.ravel(),b1.ravel(),W2.ravel(),b2.ravel()))

    return model


# 判定结果的函数
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)


# 建立隐层有3个节点(神经元)的神经网络
model = build_model(3, print_loss=True)

# 然后再把决策/判定边界画出来
plot_decision_boundary(lambda x: predict(model, x))
plt.title("Decision Boundary for hidden layer size 3")
plt.show()

# 然后听闻你想知道不同的隐层神经元个数对结果的影响？
# 那咱们来一起看看吧
plt.figure(figsize=(16, 32))
# 设定不同的隐层节点(神经元)个数
hidden_layer_dimensions = [1, 2, 3, 4, 5, 20, 50]
for i, nn_hdim in enumerate(hidden_layer_dimensions):
    plt.subplot(5, 2, i + 1)
    plt.title('Hidden Layer size %d' % nn_hdim)
    model = build_model(nn_hdim)
    plot_decision_boundary(lambda x: predict(model, x))
plt.show()

2. 自己重写实践代码

import numpy as np
import matplotlib.pyplot as plt
import sklearn.datasets as skd

# 参数设置
n_samples = 200  # 设置训练样本点数
n_input_dim = 2  # 神经网络输入层数
n_hide_dim = 3  # 神经网络隐藏层数
n_output_dim = 2  # 神经网络输出层数
epsilon = 0.0005  # 学习率
reg_lambda = 0.01  # 正则化参数
n_iteration = 200000  # 样本训练迭代次数
target_gradient = 1e-6  # 梯度幅值之和目标值
print_switch = True  # 打印开关

# %% 神经网络模型训练
# 生成样本数据
np.random.seed(0)
X, y = skd.make_moons(n_samples, noise=0.2)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.show()


# 定义softmax函数
def softmax(x):
    x_exp = np.exp(x)
    sum_x_exp = np.sum(x_exp, axis=1, keepdims=True)
    return x_exp / sum_x_exp


def forward_propagation(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
    a2 = softmax(z2)
    return a2


def calc_loss(model, X, y):
    W1, b1, W2, b2 = model['W1'], model['b2'], model['W2'], model['b2']
    # z1 = X.dot(W1) + b1
    # a1 = np.tanh(z1)
    # z2 = a1.dot(W2) + b2
    # a2 = softmax(z2)
    a2 = forward_propagation(model, X)
    corect_logprobs = -np.log(a2[range(n_samples), y])
    data_loss = np.sum(corect_logprobs)
    data_loss += reg_lambda / 2 * ((np.sum(np.square(W1))) + (np.sum(np.square(W2))))
    return 1. / n_samples * data_loss


# 模型训练函数
def build_model(X, y):
    # 随机初始化权重
    np.random.seed(0)
    W1 = np.random.randn(n_input_dim, n_hide_dim) / np.sqrt(n_input_dim)
    b1 = np.zeros((1, n_hide_dim))
    W2 = np.random.randn(n_hide_dim, n_output_dim) / np.sqrt(n_hide_dim)
    b2 = np.zeros((1, n_output_dim))

    gradient_list = np.empty((n_iteration, 1))

    # 样本数据迭代训练
    for i in np.arange(n_iteration):
        # 前向传播
        z1 = X.dot(W1) + b1
        a1 = np.tanh(z1)
        z2 = a1.dot(W2) + b2
        a2 = softmax(z2)

        # 反向传播
        # 梯度函数参考网页：http://python.jobbole.com/82208/
        # https: // blog.csdn.net / haolexiao / article / details / 72757796
        y_ideal = np.zeros((n_samples, n_input_dim))
        y_ideal[range(n_samples), y] = 1

        delta3 = a2 - y_ideal
        dW2 = a1.T.dot(delta3)
        db2 = np.sum(delta3, axis=0, keepdims=True)
        delta2 = delta3.dot(W2.T) * (1 - np.power(a1, 2))
        dW1 = np.dot(X.T, delta2)
        db1 = np.sum(delta2, axis=0, keepdims=True)

        # 加上正则化
        dW2 += reg_lambda * W2
        dW1 += reg_lambda * W1

        # 梯度下降更新
        W1 -= epsilon * dW1
        b1 -= epsilon * db1
        W2 -= epsilon * dW2
        b2 -= epsilon * db2

        # 得到的神经网络模型权重
        model = {'W1': W1, 'b1': b1, 'W2': W2, 'b2': b2}

        # 梯度模值
        abs_gradient = np.sum([np.sqrt(np.sum(np.square(j))) for j in [dW1, db1, dW2, db2]])
        gradient_list[i, 0] = abs_gradient

        # 达到梯度模值目标，停止训练
        if abs_gradient < target_gradient:
            print("在迭代%i次时，损失函数值为%f,达到目标梯度模值%f" % (i, calc_loss(model, X, y), abs_gradient))
            break

        if print_switch and i % 1000 == 0:
            print("在迭代%i次后的损失函数值为%f,梯度模值为%f" % (i, calc_loss(model, X, y), abs_gradient))

        if print_switch and ((i + 1) % 20000 == 0):
            # 画出每次迭代的梯度模值变化曲线
            plt.plot(gradient_list[20000:, 0])
            plt.show()

    return model


# %% 测试数据预测

# 训练模型
model = build_model(X, y)

# 测试数据生成
x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
h = 0.01
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
XX = np.c_[xx.ravel(), yy.ravel()]

# 测试数据预测
a2 = forward_propagation(model, XX)
Z = np.argmax(a2, axis=1)
Z = Z.reshape(xx.shape)

# 画图,测试数据用颜色表示，样本数据用点表示
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.show()

myourdream2

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
神经网络完成数据非线性切分实践

神经网络有着非常强的非线性表达能力，可以对复杂的问题进行学习和表达。以分类问题为例，现实生活中的很多分类场景是不可线性切分的，那特征的处理就尤为重要了，有意思的是，手造特征这件事情靠人工来做是非常容易达到瓶颈的，而且每换一个场景都需要重新结合场景构建一次特征，而深度学习这种端到端的学习方式，非常擅长进行表示学习，在每一次的前向计算过程中，就在自动地做特征映射，而到达最后分类层(softmax层)...
复制链接

扫一扫

专栏目录