美文网首页
神经网络入门

神经网络入门

作者: 习习隹方方土 | 来源:发表于2019-06-11 11:43 被阅读0次

    1.神经网络前传——感知机

    感知机作为神经网络的起源，由Frank Rosenblatt（美国）在1957 年提出。感知机的构造与神经网络中的神经元类似，理解感知机的思想对后续了解神经网络有很重要的帮助。
    感知机的逻辑形状类似于生物的神经系统，由神经元与神经元之间连接构成。感知机的节点包含激活函数，用来处理节点收到的信息（激活函数详见附录），类似于神经系统的神经元；节点与节点之间由边连接，边包含权重等信息，类似于神经系统中神经细胞的突触。具体类比如下图：

    生物神经元.png
    感知机.png

    每个节点接收到连接他的相邻节点传来的信息作为输入，在上图中神经元B接受来自于A1、A2的输入x1、x2,在输入信号分别乘以对应边上的权重后求和，如果总和超过某个阈值，则该神经元被激活。这里将这个阈值用\theta表示。感知机的数学公式如下：
    f(x)= \begin{cases} 0& \text{w$_{1}$x$_{1}$+w$_{2}$x$_{2}\leqslant \theta$}\\ 1& \text{w$_{1}$x$_{1}$+w$_{2}$x$_{2}$ > $\theta$} \end{cases}
    NOTE:
    感知机的输入都有各自的权重，权重越大，意味着这个输入对该神经元的状态影响越大。而后面的神经网络的学习，就是在不断调优寻求最佳权重的过程。

    2.用感知机思想实现逻辑电路

    我们来回顾一下离散数学。这里用感知机的思想去实现与门、或门、与非门、异或门是为了更切实的体验感知机的思想，并形象地展现权重和偏置在神经网络中作用的作用，最后我们会引入激活函数的概念，并在下一章“神经网络”中进行详细介绍。

    2.1与门

    与门真值表
    x1 x2 y
    0 0 0
    0 1 0
    1 0 0
    1 1 1

    如果我们用代码实现逻辑电路与门、或门、与非门、异或门异常简单。但此处我们引入权重与偏置等概念，使用感知机的思想实现与门、或门、与非门、异或门。
    我们给x1、x2分别乘以各自边上的权重再求和，最后加上偏置量等于输出y。

    与门代码实现：
    import numpy as np

def AND(x1, x2):
    x = np.array([x1, x2])
    w = np.array([0.5, 0.5])
    b = -0.7
    tmp = np.sum(w*x) + b
    if tmp <= 0:
        return 0
    else:
        return 1

    2.2或门

    或门真值表
    x1 x2 y
    0 0 0
    0 1 1
    1 0 1
    1 1 1
    或门代码实现：
    import numpy as np

def OR(x1, x2):
    x = np.array([x1, x2])
    w = np.array([0.5, 0.5])
    b = -0.2
    tmp = np.sum(w*x) + b
    if tmp <= 0:
        return 0
    else:
        return 1

    2.3与非门

    与非门真值表
    x1 x2 y
    0 0 1
    0 1 1
    1 0 1
    1 1 0
    与非门代码实现：
    import numpy as np

def NAND(x1, x2):
    x = np.array([x1, x2])
    w = np.array([-0.5, -0.5])
    b = 0.7
    tmp = np.sum(w*x) + b
    if tmp <= 0:
        return 0
    else:
        return 1

    2.3异或门

    异或门真值表
    x1 x2 y
    0 0 0
    0 1 1
    1 0 1
    1 1 0

    异或门是比较特殊的逻辑门，因为观察异或门的真值表可以发现，他的true值分布是非线性的。在前面三个逻辑门中，如果以x1为横轴，以x2为纵轴，true值和false值可以用一条直线来区分开来，以或门为例：
    f(x)= \begin{cases} 0& (\text{x$_{1}$+x$_{2}$-0.5$\leqslant$0})\\ 1& (\text{x$_{1}$+x$_{2}$-0.5>0}) \end{cases}
    分割true值与false值的线性函数为：
    x_{2}= -x_1+0.5
    然而异或门的真值不是以上述这种方式分布，所以用单层感知机无法实现异或门。我们在离散数学中都学到过异或门可以通过与门、或门以及非与门组合实现，因此我们使用多层感知机来实现异或门。

    与门代码实现：
    def XOR(x1, x2):
    s1 = NAND(x1, x2)
    s2 = OR(x1, x2)
    y = AND(s1, s2)
    return y

    此处多层感知机就是神经网络的雏形，每个神经元的输入都有各自不同的权重，每个神经元都有自己的激活函数以及偏置量。最终的输出神经元就是所要的结果。

    2.神经网络

    我们已经了解了感知机的基本概念与结构，感知机既有优点又有缺点。优点是感知机理解起来简单容易，在遇到复杂问题上，感知机理论上是可以使用并解决问题的。但感知机最最致命的缺点就是所有的权重需要人工确认，例如我们实现逻辑门时，权重是由人为确定。在处理简单问题时，人工参与确认权重可行，一旦问题复杂，所用的感知机神经元数量庞大，结构复杂时，人工确认权重就变得困难。因此我们进一步探索神经网络，神经网络提供了一套机器自己确定权重的方法（但并非所有参数都可以自己自动决定，神经网络中一些超参数依旧需要人工确定。超参数将会在后续分享中提及）
    这一节将大致介绍神经网络。这里我们默认神经网络的权重已经获取到合适的值。我们仅仅使用神经网络进行分类。神经网络每个神经元的权重学习将在下一节分享中详述。

    2.1神经网络图解

    此处我们构建一个三层神经网络，用来说明神经网络的基本结构。三层神经网络结构如下图：


    神经网络结构图.png
    神经网络说明：

    层说明：上图展示的神经网络为一个三层的神经网络（实际上有4层，但是第一层是从0开始算起，因此称为三层神经网络）图中由x1,x2组成的神经网络层是第0层，称作输入层，由y1，y2组成的神经网络层是第3层，称作输出层。夹在中间两层的是隐藏层。
    参数说明：边上的w为权重，b为每层的偏置量。w是由参数组成的二维数组。b是由常数组成的数组，也就是说每一个神经元接收到的偏置量可以不一样。
    函数说明：h(x)为激活函数，激活函数详见 附录 零食一：激活函数。

    2.2神经网络的运算

    总体计算流程：输入层的神经元的输入值乘以每条边上的权重，然后传递给下一个神经元，在下一个神经元上将各个输入以及偏置量b求和，总和为a。z = h(a)，h()为激活函数。z作为本神经元的输出传递给下一个神经元。

    • 输入：输入层是一系列输入神经元，我们可以将输入作为一个一维数组来看待。后续批处理的时候输入是分批输入，输入可以抽象为二元数组。
    • 权重：权重可以抽象为二维数组，权重二维数组的第一维的形状必须和输入层（上一层的输出）的第二维的形状相同。
    • 中间结果：中间结果是由上一层的输入乘以权重加上偏置计算得出的。可以抽象为一个一维数组（在批量处理中是二维数组）具体计算参见 附录 零食二：矩阵乘法
    • 输出结果：输出结果由一系列输出层的神经元组成。根据不同目标会有不同个数的神经元。例如我们在手写数字分类的神经网络中，输出元有10个，分别代表0~9的概率。

    2.3三层神经网络的代码实现

    此处我们将权重的学习跳过，将权重信息写死在程序当中。权重的学习将放置在后续的分享当中。

    import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def identity_function(x):
    return x


def init_network():
    network = {}
    network['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
    network['b1'] = np.array([0.1, 0.2, 0.3])
    network['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
    network['b2'] = np.array([0.1, 0.2])
    network['W3'] = np.array([[0.1, 0.3], [0.2, 0.4]])
    network['b3'] = np.array([0.1, 0.2])
    return network



def forward(network, x):
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']

    a1 = np.dot(x, W1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, W2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, W3) + b3
    y = identity_function(a3)

    return y

network = init_network()
x = np.array([1.0, 0.5])
y = forward(network, x)
print(y)

    2.4输出层的设计

    在上面的代码实现中我们发现我们最后使用的identity_function是简单的只返回输入x，相当于什么也没做，这种函数叫做恒等函数。这一小节我们讨论下输出层的设计。
    神经网络可以用在分类问题与回归问题上，需要根据不同情况来使用不同的激活函数，一般而言，回归问题用恒等函数，分类问题用softmax函数。

    2.4.1softmax函数

    softmax函数的数学表示如下：
    y_{k}=\frac{exp(a_k)}{\sum_{i=1}^Nexp(a_i)}
    说明：假设输出层有N个神经元，在第k个神经元输出yk，因为分类问题需要的是每个分类的概率，softmax是一个大于0小于1的分数，softmax输出值的总和为1，所以使用softmax作为输出层的激活函数来处理分类问题。

    2.4.2softmax函数的实现

    import numpy as np
def softmax(x):
    exp_x = np.exp(x)
    sum_exp_x = np.sum(exp_x)
    y = exp_x / sum_exp_x

    return y

a = np.array([0.3, 2.9, 4.0])
print(softmax(a))

    2.4.3softmax中的陷阱

    我们来回忆一下y = e^{-x}的图像，当x趋于0时，y值趋于负无穷。这种情况下计算机会溢出。如果我们分类函数用如上的softmax作为输出层的激活函数，遇到一个概率判断很小的分类，就爆炸了。。。那如何避免这个数学上的陷阱呢？解决方案非常粗暴简单，给分子、分母加个不为0的常数。改进后的softmax的数学表示如下：
    y_{k}=\frac{exp(a_k)}{\sum_{i=1}^Nexp(a_i)}=\frac{Cexp(a_k)}{C\sum_{i=1}^Nexp(a_i)}
    =\frac{exp(a_k+logC)}{\sum_{i=1}^Nexp(a_i+logC)}
    =\frac{exp(a_k+C')}{\sum_{i=1}^Nexp(a_i+C')}
    说明：分子、分母同时乘以一个不为零的常数，运算结果不会改变。经过如上变换，只需要给输出加上一个不为零的常数即可。为了防止计算机溢出。我们减去输出层的神经元最大的输出项作为C'

    2.4.4改进后的softmax代码实现

    import numpy as np
def softmax(x):
    c = np.max(x)
    exp_x = np.exp(x - c)
    sum_exp_x = np.sum(exp_x)
    y = exp_x / sum_exp_x

    return y

a = np.array([0.3, 2.9, 4.0])
print(softmax(a))

    附录：

    附录附上一些在感知机中可能需要了解的数学知识。如果你的大学数学记忆犹新可以不看这部分附录。如果你和我一样大学数学全部还给老师的话，可以在此复习一下。别怕！所需要的高数知识非常简单。

    零食一：激活函数

    将输入信号（多于一个）进行一番运算转换为输出信号，这种函数统称为激活函数。我们来看几个常用激活函数的例子：

    1.阶跃函数

    f(x)= \begin{cases} 0& (\text{w$_{1}$x$_{1}$+w$_{2}$x$_{2}$+b$\leqslant$0})\\ 1& (\text{w$_{1}$x$_{1}$+w$_{2}$x$_{2}$+b>0}) \end{cases}
    NOTE：
    w:边上的权重
    b:偏置量

    说明：

    此神经元接受两个输入信号，x1,x2,两个输入信号分别乘以两条边上的权重w1,w1求和再加上偏置量b作为最终阶跃函数判断的依据。如果和小于0则阶跃函数输出0，如果和大于0则阶跃函数输出1。由于最终输出为0或1，在平面直角坐标系中的图像像台阶一样，因此称之为阶跃函数。

    阶跃函数的代码实现：
    import numpy as np
import matplotlib.pylab as plt


def step_function(x):
    return np.array(x > 0, dtype=np.int)

X = np.arange(-5.0, 5.0, 0.1)
Y = step_function(X)
plt.plot(X, Y)
plt.ylim(-0.1, 1.1) 
plt.show()
    阶跃函数图像：
    阶跃函数图形.png

    2.SIGMOD函数

    SIGMOD函数是神经网络中较为常用的一个激活函数，SIGMOD函数的数学表示如下：
    a=w_{1}x_{1}+w_{2}x_{2}+b
    h(a)=\frac{1}{1+exp(-a)}
    NOTE：
    w:边上的权重
    b:偏置量

    相对于阶跃函数，SIGMOD函数曲线更加平滑，而且范围也是在(0,1)之间，SIGMOD函数在神经网络之中有很特殊的意义。在某些场景下SIGMOD函数的输出更符合需求，例如我们需要求各个输出神经元对应的概率。在这种情况下，我们需要的是一个0到1之间的实数，而非0/1的二元输出。

    SIGMOD函数的代码实现：
    import numpy as np
import matplotlib.pylab as plt


def sigmoid(x):
    return 1 / (1 + np.exp(-x))    

X = np.arange(-5.0, 5.0, 0.1)
Y = sigmoid(X)
plt.plot(X, Y)
plt.ylim(-0.1, 1.1)
plt.show()
    SIGMOD函数的图像：
    SIGMOD函数图像.png

    3.ReLU函数

    在激活函数的发展史中SIGMOD函数很早就开始使用了。但是近期则主要使用ReLU函数。(Rectified Linear Unit)
    ReLU函数的数学表示如下：
    f(x)= \begin{cases} x& (\text{x>0})\\ 0& (\text{x$\leqslant$0}) \end{cases}

    ReLU函数的代码实现：
    import numpy as np
import matplotlib.pylab as plt


def relu(x):
    return np.maximum(0, x)

x = np.arange(-5.0, 5.0, 0.1)
y = relu(x)
plt.plot(x, y)
plt.ylim(-1.0, 5.5)
plt.show()
    ReLU函数的图像：
    ReLU函数图像.png

    零食二：矩阵乘法

    理论说的再好不如例子一个，我们举个来说明矩阵乘法怎么算。

    我们定义二维矩阵A, B
    A = {[2,4],[2,6],[5,6]}
    矩阵A的形状为3×2
    B = {[1,2,3],[4,5,6]}
    矩阵A的形状为2×3
    说明：矩阵的形状被乘数为第一维元素的个数，乘数为第二维元素的个数。如果两个二维矩阵相乘，必须保证第一个矩阵的第二维形状与第二个矩阵第一维的形状相等。在上述例子中为2 = 2，如果不相等则矩阵不可乘。
    矩阵A乘以B记做A·B，我们用矩阵S表示(S = A·B)。S的形状为第一个矩阵的第一维的形状×第二个矩阵的第二维的形状，即shape(S) = 3×3，具体运算规则如下：

    S[0][0] = A[0][0]×B[0][0] + A[0][1]×B[1][0] = 2×1 + 4×4 = 17
    S[0][1] = A[0][0]×B[0][1] + A[0][1]×B[1][1] = 2×2 + 4×5 = 24
    S[0][2] = A[0][0]×B[0][2] + A[0][1]×B[1][2] = 2×3 + 4×6 = 30
    S[1][0] = A[1][0]×B[0][0] + A[1][1]×B[1][0] = 2×1 + 6×4 = 26
    ……
    S[2][2] = A[2][0]×B[0][2] + A[2][1]×B[1][2] = 5×3 + 6×6 = 51

    最终结果为：

    S = {[17,24,30],[26,34,42],[29,40,51]}

    Reference：

    [1]斋藤康毅., 2016, Deep Learning from Scratch, Tokyo: O'Reilly Japan, Inc.
    [2]耿素云.,1998, 离散数学.第2分册,集合论与图论, 北京: 北京大学出版社.
    [3]李响初., 2012, 数字电路基础与应用, 北京: 机械工业出版社.

    相关文章

      网友评论

          本文标题：神经网络入门

          本文链接：https://www.haomeiwen.com/subject/kiljxctx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|神经网络入门|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！