从零开始搭建神经网络（三）含隐藏层的神经网络

最新推荐文章于 2024-06-21 18:22:19 发布
最新推荐文章于 2024-06-21 18:22:19 发布
阅读量1.1w 收藏 73
点赞数 13
分类专栏： 从零开始搭建神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_35821976/article/details/81046080
版权

 单层感知机的学习能力有限，对于非线性可分的情况下分类效果不好，因此为了让网络拥有更强大的学习能力，需要在输入和输出层之间添加隐藏层。

                                 

下面实现一个简单含隐藏层的神经网络结构，是一个二分问题，输入为两维，输出为两类。

 

1.激活函数

  由于添加了隐藏层，因此激活函数分为隐藏层的激活函数和输出层的激活函数，这里隐藏层的激活函数使用tanh()激活函数，输出层还是使用sigmoid()激活函数，这里使用上一篇的代码，至于tanh()激活函数到时候使用np.tanh()就行了

def sigmoid(z):
    """
    sigmoid激活函数
    :param z: 输入
    :return: sigmoid(z)
    """
    return 1/(1 + np.exp(-z))

2.初始化参数

  初始化参数和不含隐藏层的升级网络没有多大区别，只是要初始化的参数多了一些而已，权重采用随机初始化，偏置零值初始化。这里需要讲一下各变量初始化的维度。以我们的图为例， 当处于在隐藏层这一层时，输入维度为（2，1），输出维度为（3，1），根据矩阵乘法公式和激活函数输出，可以得到权重矩阵W的维度为（3，2），如下图所示。偏置的维度同理。

                                                       

def initialize_parameters(in_n, h_n, out_n):
    """
    初始化权重和偏置
    in_n -- 输入层节点数
    h_n -- 隐藏层节点数
    out_n -- 输出层结点数

    returns:
    params --
              W1 --  权重矩阵，维度为(h_n, in_n)
              b1 -- 偏置向量，维度为(h_n, 1)
              W2 -- 权重矩阵，维度为 (out_n, h_n)
              b2 -- 偏置向量，维度为 (out_n, 1)
    """
    W1 = np.random.randn(h_n, in_n) * 0.01
    b1 = np.zeros((h_n, 1))
    W2 = np.random.randn(out_n, h_n) * 0.01
    b2 = np.zeros((out_n, 1))

    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}

    return parameters

3.BP算法

    含隐藏层的神经网络的BP算法要复杂一些因为要一层一层的正向传播，然后再反向传播回来。下面讲一下含隐藏层的BP算法。前向传播和不含隐藏层的神经网络一样，从输入层开始依次计算每一层的输入，上一次的输出当做当前层的输入；反向传播则是从输出层开始依次进行梯度下降，公式就不进行具体的推导了，在下面直接给出，可以参考：从零开始搭建神经网络（二）数学公式及代码实现。因为含隐藏层的BP算法比较复杂，所以前向传播和反向传播分开来写，

                                                                            

def forward_propagation(X, parameters):
    """
    前向传播
    X -- 输入数据
    parameters -- 参数（包含W1,b1,W2,b2）

    returns:
    A2 -- 网络输出
    temp -- 包含 Z1, A1, Z2，A2的字典，用于BP算法
    """

    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]

    Z1 = np.dot(W1, X) + b1
    A1 = np.tanh(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = sigmoid(Z2)

    temp = {"Z1": Z1,
             "A1": A1,
             "Z2": Z2,
             "A2": A2}
    return A2,temp
def backward_propagation(parameters, temp, X, Y):
    """
    反向传播
    parameters -- 参数（包含W1,b1,W2,b2）
    temp -- 包含 Z1, A1, Z2，A2的字典，用于BP算法
    X -- 输入数据
    Y -- 输入数据标签

    returns:
    grads -- 返回不同参数的梯度
    cost -- 损失函数
    """
    # 取回参数
    W1 = parameters["W1"]
    W2 = parameters["W2"]

    A1 = temp["A1"]
    A2 = temp["A2"]

    # 样本数目
    num = Y.shape[0]
    # 交叉熵损失函数
    cost = -1 / num * np.sum(Y * np.log(A2) + (1 - Y) * np.log(1 - A2))

    # 反向传播
    dZ2 = A2 - Y
    dW2 = 1 / num * np.dot(dZ2, A1.T)
    db2 = 1 / num * np.sum(dZ2, axis=1, keepdims=True)
    dZ1 = np.dot(W2.T, dZ2) * (1 - np.power(A1, 2))
    dW1 = 1 / num * np.dot(dZ1, X.T)
    db1 = 1 / num * np.sum(dZ1, axis=1, keepdims=True)


    gradients = {"dW1": dW1,
             "db1": db1,
             "dW2": dW2,
             "db2": db2}

    return cost,gradients

4.参数更新

    参数更新和其他的完全一样，不懂的参考我上一篇博客。

def update_parameters(parameters, gradients, learning_rate):
    """
    梯度下降法更新参数

    parameters -- 参数（包含W1,b1,W2,b2）
    grads -- 不同参数的梯度

    returns:
    parameters -- 更新后的参数
    """
    #取回参数
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]

    dW1 = gradients["dW1"]
    db1 = gradients["db1"]
    dW2 = gradients["dW2"]
    db2 = gradients["db2"]

    # 更新参数
    W1 -= learning_rate * dW1
    b1 -= learning_rate * db1
    W2 -= learning_rate * dW2
    b2 -= learning_rate * db2

    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}

    return parameters

5.预测

    根据神经网络的输出值来进行预测，公式如下：

                                                                               

def predict(parameters, X):
    """
    使用学习好的参数来预测

    parameters -- 学习好的参数
    X -- 输入数据

    Returns
    predictions -- 预测结果0/1
    """
    A2, temp = forward_propagation(X, parameters)
    predictions = np.round(A2)

    return predictions

 

6. 完整实例

 

    下图是中的两类点是线性不可分的，利用这些数据测试下含隐藏层的神经网络的学习能力

                        

 

if __name__ == "__main__":
    # X为横坐标，Y为纵坐标
    X = [0, 0, 1, 1]
    Y = [0, 1, 0, 1]
    label = [1, 0, 0, 1]
    # 第一类为蓝色，第二类为红色
    label_color = ['blue', 'red']
    color = []
    for i in label:
        if i == 1:
            color.append(label_color[0])
        else:
            color.append(label_color[1])

    # 数据归一化
    X = np.array(X)
    Y = np.array(Y)
    X = (X - np.average(X))
    Y = (Y - np.average(Y))
    X = X / X.max()
    Y = Y / Y.max()
    for i in range(len(X)):
        plt.scatter(X[i], Y[i], c=color[i])
    plt.title('Normalization Data')
    plt.show()

    data_X = np.vstack((X, Y))
    data_label = np.array([label])

    # 参数设置
    in_n = 2
    h_n = 3
    out_n = 1
    costs = []
    Y_prediction = []
    iters = 2000
    learning_rate = 2
    parameters = initialize_parameters(in_n, h_n, out_n)

    #开始训练
    for i in range(iters):
        # 前向传播
        A2, temp = forward_propagation(data_X, parameters)
        # 反向传播
        costTemp, gradients = backward_propagation(parameters, temp, data_X, data_label)
        costs.append(costTemp)
        # 参数更新
        parameters = update_parameters(parameters, gradients, learning_rate)

    # 预测
    Y_prediction = predict(parameters, data_X)

    plot_decision_boundary(lambda x: predict(parameters, x.T), data_X, data_label)
    plt.show()

    # #画图
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('iterations')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()

    分类结果如下图所示，可以发现含隐藏层的神经网络可以对线性不可分的数据进行分类

 

 

P.S. 完整代码

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(z):
    """
    sigmoid激活函数
    :param z: 输入
    :return: sigmoid(z)
    """
    return 1/(1 + np.exp(-z))


def initialize_parameters(in_n, h_n, out_n):
    """
    初始化权重和偏置
    in_n -- 输入层节点数
    h_n -- 隐藏层节点数
    out_n -- 输出层结点数
    returns:
    params --
              W1 --  权重矩阵，维度为(h_n, in_n)
              b1 -- 偏置向量，维度为(h_n, 1)
              W2 -- 权重矩阵，维度为 (out_n, h_n)
              b2 -- 偏置向量，维度为 (out_n, 1)
    """
    W1 = np.random.randn(h_n, in_n) * 0.01
    b1 = np.zeros((h_n, 1))
    W2 = np.random.randn(out_n, h_n) * 0.01
    b2 = np.zeros((out_n, 1))

    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}

    return parameters


def forward_propagation(X, parameters):
    """
    前向传播
    X -- 输入数据
    parameters -- 参数（包含W1,b1,W2,b2）
    returns:
    A2 -- 网络输出
    temp -- 包含 Z1, A1, Z2，A2的字典，用于BP算法
    """

    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]

    Z1 = np.dot(W1, X) + b1
    A1 = np.tanh(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = sigmoid(Z2)

    temp = {"Z1": Z1,
            "A1": A1,
            "Z2": Z2,
            "A2": A2}
    return A2, temp


def backward_propagation(parameters, temp, X, Y):
    """
    反向传播
    parameters -- 参数（包含W1,b1,W2,b2）
    temp -- 包含 Z1, A1, Z2，A2的字典，用于BP算法
    X -- 输入数据
    Y -- 输入数据标签
    returns:
    grads -- 返回不同参数的梯度
    cost -- 损失函数
    """
    # 取回参数
    W1 = parameters["W1"]
    W2 = parameters["W2"]

    A1 = temp["A1"]
    A2 = temp["A2"]

    # 样本数目
    num = Y.shape[0]
    # 交叉熵损失函数
    cost = -1 / num * np.sum(Y * np.log(A2) + (1 - Y) * np.log(1 - A2))

    # 反向传播
    dZ2 = A2 - Y
    dW2 = 1 / num * np.dot(dZ2, A1.T)
    db2 = 1 / num * np.sum(dZ2, axis=1, keepdims=True)
    dZ1 = np.dot(W2.T, dZ2) * (1 - np.power(A1, 2))
    dW1 = 1 / num * np.dot(dZ1, X.T)
    db1 = 1 / num * np.sum(dZ1, axis=1, keepdims=True)

    gradients = {"dW1": dW1,
                 "db1": db1,
                 "dW2": dW2,
                 "db2": db2}

    return cost, gradients


def update_parameters(parameters, gradients, learning_rate):
    """
    梯度下降法更新参数
    parameters -- 参数（包含W1,b1,W2,b2）
    grads -- 不同参数的梯度
    returns:
    parameters -- 更新后的参数
    """
    # 取回参数
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]

    dW1 = gradients["dW1"]
    db1 = gradients["db1"]
    dW2 = gradients["dW2"]
    db2 = gradients["db2"]

    # 更新参数
    W1 -= learning_rate * dW1
    b1 -= learning_rate * db1
    W2 -= learning_rate * dW2
    b2 -= learning_rate * db2

    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}

    return parameters


def predict(parameters, X):
    """
    使用学习好的参数来预测
    parameters -- 学习好的参数
    X -- 输入数据
    Returns
    predictions -- 预测结果0/1
    """
    A2, temp = forward_propagation(X, parameters)
    predictions = np.round(A2)

    return predictions


def plot_decision_boundary(model, X, y):
    # 设置边界
    x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1
    y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1
    h = 0.01

    # 生成边界
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    # 预测结构
    Z = model(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)

    # 画出边界
    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
    plt.ylabel('y')  # 标记y轴名称
    plt.xlabel('x')  # 标记x轴名称
    plt.scatter(X[0, :], X[1, :], c=np.squeeze(y), cmap=plt.cm.Spectral)


if __name__ == "__main__":
    # X为横坐标，Y为纵坐标
    X = [0, 0, 1, 1]
    Y = [0, 1, 0, 1]
    label = [1, 0, 0, 1]
    # 第一类为蓝色，第二类为红色
    label_color = ['blue', 'red']
    color = []
    for i in label:
        if i == 1:
            color.append(label_color[0])
        else:
            color.append(label_color[1])

    # 数据归一化
    X = np.array(X)
    Y = np.array(Y)
    X = (X - np.average(X))
    Y = (Y - np.average(Y))
    X = X / X.max()
    Y = Y / Y.max()
    for i in range(len(X)):
        plt.scatter(X[i], Y[i], c=color[i])
    plt.title('Normalization Data')
    plt.show()

    data_X = np.vstack((X, Y))
    data_label = np.array([label])

    # 参数设置
    in_n = 2
    h_n = 3
    out_n = 1
    costs = []
    Y_prediction = []
    iters = 2000
    learning_rate = 2
    parameters = initialize_parameters(in_n, h_n, out_n)

    # 开始训练
    for i in range(iters):
        # 前向传播
        A2, temp = forward_propagation(data_X, parameters)
        # 反向传播
        costTemp, gradients = backward_propagation(parameters, temp, data_X, data_label)
        costs.append(costTemp)
        # 参数更新
        parameters = update_parameters(parameters, gradients, learning_rate)

    # 预测
    Y_prediction = predict(parameters, data_X)

    plot_decision_boundary(lambda x: predict(parameters, x.T), data_X, data_label)
    plt.show()

    # #画图
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('iterations')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()

 

非典型废言
关注
专栏目录
Python实现一个简单三层神经网络的搭建并测试
10-07 3075
废话不多说了，直接步入正题，一个完整的神经网络一般由三层构成：输入层，隐藏层（可以有多层）和输出层。本文所构建的神经网络隐藏层只有一层。一个神经网络主要由三部分构成（代码结构上）：初始化，训练，和预测。首先我们先来初始化这个神经网络吧！
神经网络 深度神经网络,从零开始搭建神经网络
wenangou的博客
10-19 366
搭建由一个输入层，一个隐藏层，一个输出层组成的三层神经网络。相应的，输出层的节点数则是由类的数量来决定，也是2个。（因为我们只有一个预测0和1的输出节点，所以我们只有两类输出，实际中，两个输出节点将更易于在后期进行扩展从而获得更多类别的输出）。以x，y坐标作为输入，输出的则是两种概率，一种是0（代表女），另一种是1（代表男）。其次至少需要具备一些适用于研究的编程语言的技能，例如python，matlab，（C++也可行）等，哪怕不自己实现最简单的神经网络而是用API，也是需要一定计算机能力才能应用之。
吴恩达编程作业——搭建含一个隐藏层的神经网络进行数据分析
weixin_38293304的博客
07-26 719
搭建含有一个隐藏层的神经网络 首先声明本文参考https://blog.csdn.net/u013733326/article/details/79702148，通过学习自己动手实现了前文中的所有功能，在此基础上实现了对于最后的“blobs”数据集的6分类，采用softmax进行多分类，希望交流学习 testCases：提供了一些测试示例来评估函数的正确性，参见下载的资料或者在底部查看它的代码。 planar_utils ：提供了在这个任务中使用的各种有用的功能，参见下载的资料或者在底部查看它的代码。
深度神经网络一
最新发布
橘猫的博客
06-21 1369
深度神经网络（Deep Neural Network, DNN）是人工神经网络的一种，拥有多个隐藏层。这些隐藏层之间的连接使得DNN能够学习和表示复杂的函数和模式。深度神经网络是人工智能领域的核心技术，具有强大的学习和表达能力。理解其基本概念、结构、训练过程和应用领域，对于深入学习和应用深度学习技术至关重要。通过不断的学习和实践，可以更好地掌握和应用DNN，解决各种复杂的问题。
神经网络和深度学习（9）--浅层神经网络(一个隐藏层)
ShaneHolmes
08-14 3374
神经网络和深度学习 上一篇 主目录 下一篇 文章结构1. 神经网络的表示2. 关于各个参数3. 计算一个神经网络的输出4. 多个样本神经网络的输出 【前言】 介绍神经网络的基本组成，表...
搭建简易神经网络（~）
HeLoZhaoFei的博客
03-10 349
参考：《深度学习之Pytorch实战计算机视觉》 该模型只考虑一个隐藏层； 定义四个整型变量； import torch batch_n=100 #一个批次输入的数量 hidden_layer=100 #隐藏层后保留的数据特征个数 input_data=1000 #每个数据包含的数据特征个数 output_data=10 #输出的数据，值为10，代表，我们最后要10个分类结果值 先输入100个具有1000个特征的..
标准3层神经网络搭建Demo
weixin_30682127的博客
06-30 245
上面我们说了神经网络的基础知识，根据上章的基础尝试搭建一个标准的3层神经网络，参考https://www.cnblogs.com/bestExpert/p/9128645.html 1.框架代码 1.>初始化函数 — 设定输入层节点、隐藏层节点、输出层节点的数量，设置学习率和各层的权重 2.>训练 — 学习给定训练集样本后，优化权重 3.>查询— 给定输入，从输出节点给...
从零开始搭建神经网络-卷积神经网络(CNN)
02-24
卷积神经网络的基础内容可以参考：机器学习算法之卷积神经网络卷积神经网络一般包括卷积层，池化层和全连接层，下面分别介绍一下2.1卷积层卷积神经网络里面的这个卷积和信号里面的卷积是有些差别的，信号中的卷积...
神经网络的搭建过程描述,从零开始搭建神经网络
wenangou的博客
10-05 2019
基本上，神经网络是由一层一层的不同的计算单位连接起来的。我们把计算单位称为神经元，这些网络可以把数据处理分类，就是我们要的输出。
搭建一个多层神经网络
Yinger_2000的博客
02-12 927
这是吴恩达-神经网络和深度学习第四周的课后作业，在这里整理一下思路。 最后的模型是用来判断“是否是猫脸”的任意指定层数的神经网络，其中最后一层的激活函数是sigmoid，中间的隐藏层都用relu。 步骤如下： 初始化 ...
3层全连接神经网络
qq_41832757的博客
10-05 1548
输入层是28x28=784个节点 隐层500个结点 输出层10个结点 采用了L2正则化，指数衰减学习率，滑动平均优化后的结果正确率 98.3%左右 from tensorflow.examples.tutorials.mnist import input_data import tensorflow as tf import os import warnings warnings.filterwa...
搭建一个简单的神经网络
w_1106的博客
12-04 357
搭建一个简单的神经网络 搭建一个简单二分类神经网络。 一个简单的三层网络，包括输入层，隐层，输出层。反向传播迭代更新。 软件：PyCharm Python version：3.7 代码： import numpy as np class NeuralNetwork: def __init__(self): pass ##实现sigmode函数，同时通过True/False 来分别返回sigmode函数的导数和函数 def sigmode(self, x, deri
TensorFlow 实现的最简单的两层神经网络
BLOG OF PETERMAOSX.
08-12 780
这里搭建的是一个这种的两层神经网络 中间设置了一层隐藏层 import tensorflow as tf #定义输入和参数 x = tf.constant([[0.7,0.5]]) w1 = tf.Variable(tf.random_uniform([2,3],seed=1,stddev=1)) w2 = tf.Variable(tf.random_uniform([3,1],seed=1,s...
bp神经网络隐含层神经元个数_CNN,残差网络，BP网络
weixin_39633455的博客
11-20 1702
（以下实验均在MNIST中实现）一、CNN与CNN改进的对比 众所周知，对于CNN卷积神经网络而言，随着卷积层数的增加，其模型的准确度也会增加。那模型层数和准确度是无限地成正比例关系吗？显然不是的，众多实验已经证实，随着网络卷积层增加，准确度增加将逐渐趋缓。当模型卷积层增加到一定程度时，准确度几乎停滞甚至还会降低。为什么会产生这种原因？我们回想CNN的全称：卷积神经网络，他最初是在解决...
计算机视觉（七）：构建两层的神经网络来分类Cifar-10数据集
HHH_ANS的博客
01-11 2169
1 - 引言 之前我们学习了神经网络的理论知识，现在我们要自己搭建一个结构为如下图所示的神经网络，对Cifar-10数据集进行分类 前向传播比较简单，就不在赘述 反向传播需要注意的是，softmax的反向传播与之前写的softmax代码一样。神经网络内部的反向传播权重偏导就是前面的系数，偏置的导为1，所以就是传播输入的累加和，ReLU函数在反向传播时，小于零的均为0，大于零的不变 根据求导过程可...
大脑神经网络图高清,图神经网络 图像
shirley67269的博客
08-29 1350
1、全连接神经网络解析：对n-1层和n层而言，n-1层的任意一个节点，都和第n层所有节点有连接。即第n层的每个节点在进行计算的时候，激活函数的输入是n-1层所有节点的加权。2、全连接的神经网络示意图：3、“全连接”是一种不错的模式，但是网络很大的时候，训练速度回很慢。部分连接就是认为的切断某两个节点直接的连接，这样训练时计算量大大减小。...
深度学习 两层隐藏层网络实现猫狗分类
DoKiDoK的博客
11-12 298
中国传媒大学深度学习
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值