精华内容
下载资源
问答
  • 多层感知机的基本知识 深度学习主要关注多层模型。在这里,我们将以多层感知机(multilayer perceptron,MLP)为例,介绍多层神经网络的概念。
  • 一、多层感知机简介 Softmax回归可以算是多分类问题logistic回归,它和神经网络的最大区别是没有隐含层。理论上只要隐含节点足够多,即时只有一个隐含层的神经网络也可以拟合任意函数,同时隐含层越多,越容易拟合...
  • 多层感知机matlab代码实现,分类是采用较难分类的半月形两类问题分类,可方便深度学习初学者了解深度学习反馈传播机制。
  • 多层感知机(MLP,Multilayer Perceptron)也叫人工神经网络(ANN,Artificial Neural Network),除了输入输出层,它中间可以有多个隐层,最简单的MLP只含一个隐层,即三层的结构,如下图最简单的MLP: 上图模型...
  • Machine-Learning:包含KNN,感知机,多层感知机,聚类分析等源代码
  • multilayer perceptron多层感知机 一、多层感知机的基本知识 隐藏层 下图展示了一个多层感知机的神经网络图,它含有一个隐藏层,该层中有5个隐藏单元。 含单层隐藏层的多层感知机公式: 从联立后的式子可以看出,...
  • 多层感知机python代码

    2018-04-26 12:41:55
    多层感知机python代码,属于深度网络学习中的内容,multilayer-perceptron,python代码
  • 多层感知机(MLP)(三层)(UCI乳腺癌数据库)(k折交叉验证)(反向传递)(机器学习,神经网络)
  • MLP-多层感知机的原理及Matlab实现-附件资源
  • 本实验旨在掌握Weka 多层感知机模型实践操作;了解多层感知机算法在各领域的应用;掌握Matlab 神经网络工具箱实践操作;了解Matlab 神经网络工具箱在各领域的应用。
  • 本代码是在TensorFlow实现softmax regression模型之后的优化,增加了一层隐含层来提高拟合度,并使用dropout减轻过拟合、自适应学习速率的Adagrad,以及可以解决梯度弥散的激活函数ReLU。 本代码按照《TensorFlow...
  • 多层感知机(multi-layer perceptron)实现手写体分类(TensorFlow)
  • 多层感知机

    2020-10-13 19:42:31
    多层感知机 深度学习主要关注多层模型,现在以多层感知机(multilayer perceptron,MLP)为例,介绍多层神经网络的概念。 隐藏层 多层感知机在单层神经网络的基础上引入了一到多个隐藏层(hidden layer)。隐藏层...

    多层感知机
    深度学习主要关注多层模型,现在以多层感知机(multilayer perceptron,MLP)为例,介绍多层神经网络的概念。

    隐藏层
    多层感知机在单层神经网络的基础上引入了一到多个隐藏层(hidden layer)。隐藏层位于输入层和输出层之间。图展示了一个多层感知机的神经网络图。
    在这里插入图片描述
    在这里插入图片描述

    模型图所示的多层感知机中,输入和输出个数分别为4和3,中间的隐藏层中包含了5个隐藏单元(hidden unit)。由于输入层不涉及计算,模型图中的多层感知机的层数为2。由模型图可见,隐藏层中的神经元和输入层中各个输入完全连接,输出层中的神经元和隐藏层中的各个神经元也完全连接。因此,多层感知机中的隐藏层和输出层都是全连接层。

    具体来说,给定一个小批量样本X∈ℝn×d,其批量大小为n,输入个数为d。假设多层感知机只有一个隐藏层,其中隐藏单元个数为h。记隐藏层的输出(也称为隐藏层变量或隐藏变量)为H,有H∈ℝn×h,因为隐藏层和输出层均是全连接层,可以设隐藏层的权重参数和偏差参数分别为Wh∈ℝd×h和bh∈ℝ1×h,输出层的权重和偏差参数分别W0∈ℝh×q和b0∈ℝ1×q

    我们先来看一种含单隐藏层的多层感知机的设计。其输出的计算为
    在这里插入图片描述

    也就是将隐藏层的输出直接作为输出层的输入。如果将以上两个式子联立起来,可以得到

    在这里插入图片描述

    从联立后的式子可以看出,虽然神经网络引入了隐藏层,却依然等价于一个单层神经网络:其中输出层权重参数为WhW0,偏差参数为bhW0+b。难发现,即便再添加更多的隐藏层,以上设计依然只能与仅含输出层的单层神经网络等价。

    激活函数
    上述问题的根源在于全连接层只是对数据做仿射变换(affine transformation),而多个仿射变换的叠加仍然是一个仿射变换。解决问题的一个方法是引入非线性变换,例如对隐藏变量使用按元素运算的非线性函数进行变换,然后再作为下一个全连接层的输入。这个非线性函数被称为激活函数(activation function)。下面我们介绍几个常用的激活函数。

    ReLU函数
    ReLU(rectified linear unit)函数提供了一个很简单的非线性变换。给定元素xx,该函数定义为

    在这里插入图片描述

    可以看出,ReLU函数只保留正数元素,并将负数元素清零。为了直观地观察这一非线性变换,我们先定义一个绘图函数xyplot。

    复制代码
    %matplotlib inline
    import d2lzh as d2l
    from mxnet import autograd, nd

    def xyplot(x_vals, y_vals, name):
    d2l.set_figsize(figsize=(5, 2.5))
    d2l.plt.plot(x_vals.asnumpy(), y_vals.asnumpy())
    d2l.plt.xlabel(‘x’)
    d2l.plt.ylabel(name + ‘(x)’)
    复制代码
    我们接下来通过NDArray提供的relu函数来绘制ReLU函数。可以看到,该激活函数是一个两段线性函数。

    x = nd.arange(-8.0, 8.0, 0.1)
    x.attach_grad()
    with autograd.record():
    y = x.relu()
    xyplot(x, y, ‘relu’)

    在这里插入图片描述

    显然,当输入为负数时,ReLU函数的导数为0;当输入为正数时,ReLU函数的导数为1。尽管输入为0时ReLU函数不可导,但是我们可以取此处的导数为0。下面绘制ReLU函数的导数。
    在这里插入图片描述

    y.backward()
    xyplot(x, x.grad, ‘grad of relu’)

    sigmoid函数
    sigmoid函数可以将元素的值变换到0和1之间:在这里插入图片描述

    sigmoid函数在早期的神经网络中较为普遍,但它目前逐渐被更简单的ReLU函数取代。在后面“循环神经网络”一章中我们会介绍如何利用它值域在0到1之间这一特性来控制信息在神经网络中的流动。下面绘制了sigmoid函数。当输入接近0时,sigmoid函数接近线性变换。

    with autograd.record():
    y = x.sigmoid()
    xyplot(x, y, ‘sigmoid’)

    在这里插入图片描述

    依据链式法则,sigmoid函数的导数

    在这里插入图片描述

    下面绘制了sigmoid函数的导数。当输入为0时,sigmoid函数的导数达到最大值0.25;当输入越偏离0时,sigmoid函数的导数越接近0。

    y.backward()
    xyplot(x, x.grad, ‘grad of sigmoid’)

    在这里插入图片描述

    tanh函数
    tanh(双曲正切)函数可以将元素的值变换到-1和1之间:

    在这里插入图片描述

    绘制tanh函数。当输入接近0时,tanh函数接近线性变换。虽然该函数的形状和sigmoid函数的形状很像,但tanh函数在坐标系的原点上对称。
    在这里插入图片描述

    with autograd.record():
    y = x.tanh()
    xyplot(x, y, ‘tanh’)

    依据链式法则,tanh函数的导数

    在这里插入图片描述

    绘制了tanh函数的导数。当输入为0时,tanh函数的导数达到最大值1;当输入越偏离0时,tanh函数的导数越接近0。
    在这里插入图片描述

    y.backward()
    xyplot(x, x.grad, ‘grad of tanh’)

    多层感知机
    多层感知机就是含有至少一个隐藏层的由全连接层组成的神经网络,且每个隐藏层的输出通过激活函数进行变换。多层感知机的层数和各隐藏层中隐藏单元个数都是超参数。以单隐藏层为例并沿用本节之前定义的符号,多层感知机按以下方式计算输出:

    在这里插入图片描述

    其中ϕ表示激活函数。在分类问题中,我们可以对输出O做softmax运算,并使用softmax回归中的交叉熵损失函数。 在回归问题中,我们将输出层的输出个数设为1,并将输出O直接提供给线性回归中使用的平方损失函数。

    代码实现
    复制代码
    #!/usr/bin/env python

    coding: utf-8

    In[1]:

    get_ipython().run_line_magic(‘matplotlib’, ‘inline’)
    import d2lzh as d2l
    from mxnet import nd
    from mxnet.gluon import loss as gloss

    In[2]:

    #读取数据
    batch_size = 256
    train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

    In[3]:

    #定义模型参数
    #Fashion-MNIST数据集中图像形状为28×28,类别数为10。我们使用长度为28×28=784的向量表示每一张图像。
    #因此,输入个数为784,输出个数为10。实验中,我们设超参数隐藏单元个数为256。
    num_inputs, num_outputs, num_hiddens = 784, 10, 256

    W1 = nd.random.normal(scale=0.01, shape=(num_inputs, num_hiddens))
    b1 = nd.zeros(num_hiddens)
    W2 = nd.random.normal(scale=0.01, shape=(num_hiddens, num_outputs))
    b2 = nd.zeros(num_outputs)
    params = [W1, b1, W2, b2]

    for param in params:
    param.attach_grad()

    In[4]:

    #定义激活函数
    def relu(X):
    return nd.maximum(X, 0)

    In[6]:

    #定义模型
    def net(X):
    X = X.reshape((-1, num_inputs))
    H = relu(nd.dot(X, W1) + b1)
    return nd.dot(H, W2) + b2

    In[8]:

    #定义损失函数
    loss = gloss.SoftmaxCrossEntropyLoss()

    In[9]:

    #训练模型
    num_epochs, lr = 5, 0.5
    d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size,
    params, lr)

    展开全文
  • Python语言,word2vec模型,词袋模型和TFIDF模型,使用MLP(多层感知机)进行情感分析,使用fasttext进行文档分类
  • 改进的多层感知机对拟稳点的选取,陶叶青,杨娟,本文运用多层感知机对监测网中的相对稳定点(拟稳点)进行选取,克服了传统的剔除粗差的局限性,为监测网的拟稳平差提供精确可靠
  • 多层感知机、常见激活函数

    千次阅读 2020-06-17 22:41:10
    3.8 多层感知机 xiaoyao 动手学深度学习 tensorflow2 前面学习了线性回归和softmax回归在内的单层神经网络。然而深度学习主要关注多层模型。在本节中,将学习多层感知机(multilayer perceptron,MLP)。 3.8.1 隐藏...

    3.8 多层感知机

    xiaoyao 动手学深度学习 tensorflow2

    前面学习了线性回归和softmax回归在内的单层神经网络。然而深度学习主要关注多层模型。在本节中,将学习多层感知机(multilayer perceptron,MLP)。

    3.8.1 隐藏层

    多层感知机在单层神经网络的基础上引入了一个或多个隐藏层(hidden layer).隐藏层位于输入层和输出层之间。

    如下图所示:

    在这里插入图片描述

    上图所示的多层感知机中,输入和输出个数分别为4和3,中间的隐藏层中包含了5个隐藏单元(hidden unit)。由于输入层不涉及计算,图中的多层感知机的层数为2。由图可见,隐藏层中的神经元和输入层中各个输入完全连接,输出层中的神经元和隐藏层中的各个神经元也完全连接。因此,多层感知机中的隐藏层和输出层都是全连接层。

    具体来说,给定一个小批量样本 X ∈ R n × d \boldsymbol{X} \in \mathbb{R}^{n \times d} XRn×d,其批量大小为 n n n,输入个数为 d d d。假设多层感知机只有一个隐藏层,其中隐藏单元个数为 h h h。记隐藏层的输出(也称为隐藏层变量或隐藏变量)为 H \boldsymbol{H} H,有 H ∈ R n × h \boldsymbol{H} \in \mathbb{R}^{n \times h} HRn×h。因为隐藏层和输出层均是全连接层,可以设隐藏层的权重参数和偏差参数分别为 W h ∈ R d × h \boldsymbol{W}_h \in \mathbb{R}^{d \times h} WhRd×h b h ∈ R 1 × h \boldsymbol{b}_h \in \mathbb{R}^{1 \times h} bhR1×h,输出层的权重和偏差参数分别为 W o ∈ R h × q \boldsymbol{W}_o \in \mathbb{R}^{h \times q} WoRh×q b o ∈ R 1 × q \boldsymbol{b}_o \in \mathbb{R}^{1 \times q} boR1×q

    先来看一种含单隐藏层的多层感知机的设计。其输出 O ∈ R n × q \boldsymbol{O} \in \mathbb{R}^{n \times q} ORn×q的计算为

    H = X W h + b h , O = H W o + b o , (式1) \begin{aligned} \boldsymbol{H} &= \boldsymbol{X} \boldsymbol{W}_h + \boldsymbol{b}_h,\\ \boldsymbol{O} &= \boldsymbol{H} \boldsymbol{W}_o + \boldsymbol{b}_o, \end{aligned}\tag{式1} HO=XWh+bh,=HWo+bo,(1)

    也就是将隐藏层的输出直接作为输出层的输入。如果将以上两个式子联立起来,可以得到

    O = ( X W h + b h ) W o + b o = X W h W o + b h W o + b o . (式2) \boldsymbol{O} = (\boldsymbol{X} \boldsymbol{W}_h + \boldsymbol{b}_h)\boldsymbol{W}_o + \boldsymbol{b}_o = \boldsymbol{X} \boldsymbol{W}_h\boldsymbol{W}_o + \boldsymbol{b}_h \boldsymbol{W}_o + \boldsymbol{b}_o.\tag{式2} O=(XWh+bh)Wo+bo=XWhWo+bhWo+bo.(2)

    从联立后的式子可以看出,虽然神经网络引入了隐藏层,却依然等价于一个单层神经网络:其中输出层权重参数为 W h W o \boldsymbol{W}_h\boldsymbol{W}_o WhWo,偏差参数为 b h W o + b o \boldsymbol{b}_h \boldsymbol{W}_o + \boldsymbol{b}_o bhWo+bo。不难发现,即便再添加更多的隐藏层,以上设计依然只能与仅含输出层的单层神经网络等价。

    3.8.2 激活函数

    上述问题的根源在于全连接层只是对数据做仿射变换(affine transformation),而多个仿射变换的叠加仍然是一个仿射变换。解决问题的一个方法是引入非线性变换,例如对隐藏变量使用按元素运算的非线性函数进行变换,然后再作为下一个全连接层的输入。这个非线性函数被称为激活函数(activation function)。下面介绍几个常用的激活函数。

    3.8.2.1 ReLU函数

    ReLU(rectified linear unit)函数提供了一个很简单的非线性变换。
    给定元素xx,该函数定义为
    R e L U ( x ) = m a x ( x , 0 ) . (式3) ReLU(x)=max(x,0).\tag{式3} ReLU(x)=max(x,0).(3)
    可以看出,ReLU函数只保留正数元素,并将负数元素清零。为了直观地观察这一非线性变换,我们先定义一个绘图函数xyplot。

    import tensorflow as tf
    from matplotlib import pyplot as plt
    import numpy as np
    import random
    %matplotlib inline
    
    def use_svg_display():
        # 用矢量图显示
        %config InlineBackend.figure_format = 'svg'
    
    def set_figsize(figsize=(3.5, 2.5)):
        use_svg_display()
        # 设置图的尺寸
        plt.rcParams['figure.figsize'] = figsize
    
    def xyplot(x_vals, y_vals, name):
        set_figsize(figsize=(5, 2.5))
        plt.plot(x_vals.numpy(), y_vals.numpy())
        plt.xlabel('x')
        plt.ylabel(name + '(x)')
    

    接下来通过Tensor提供的relu函数来绘制ReLU函数。可以看到,该激活函数是一个两段线性函数。

    x = tf.Variable(tf.range(-8,8,0.1),dtype=tf.float32)
    y = tf.nn.relu(x)
    xyplot(x, y, 'relu')
    

    在这里插入图片描述

    显然,当输入为负数时,ReLU函数的导数为0;当输入为正数时,ReLU函数的导数为1。尽管输入为0时ReLU函数不可导,但是我们可以取此处的导数为0。下面绘制ReLU函数的导数。

    with tf.GradientTape() as t:
        t.watch(x)
        y = tf.nn.relu(x)
    dy_dx = t.gradient(y, x)
    xyplot(x, dy_dx, 'grad of relu')
    

    在这里插入图片描述

    3.8.2.2 sigmoid函数

    sigmoid函数可以将元素的值变换到0和1之间:
    sigmoid ( x ) = 1 1 + exp ⁡ ( − x ) . (式4) \text{sigmoid}(x) = \frac{1}{1 + \exp(-x)}.\tag{式4} sigmoid(x)=1+exp(x)1.(4)

    sigmoid函数在早期的神经网络中较为普遍,但它目前逐渐被更简单的ReLU函数取代。在后面“循环神经网络”中会介绍如何利用它值域在0到1之间这一特性来控制信息在神经网络中的流动。下面绘制了sigmoid函数。当输入接近0时,sigmoid函数接近线性变换。

    # x
    
    y = tf.nn.sigmoid(x)
    xyplot(x, y, 'sigmoid')
    

    在这里插入图片描述

    据链式法则,sigmoid函数的导数

    s i g m o i d ′ ( x ) = s i g m o i d ( x ) ( 1 − s i g m o i d ( x ) ) (式5) sigmoid'(x)=sigmoid(x)(1−sigmoid(x))\tag{式5} sigmoid(x)=sigmoid(x)(1sigmoid(x))(5)
    下面绘制了sigmoid函数的导数。当输入为0时,sigmoid函数的导数达到最大值0.25;当输入越偏离0时,sigmoid函数的导数越接近0。

    with tf.GradientTape() as t:
        t.watch(x)
        y = tf.nn.sigmoid(x)
    dy_dx = t.gradient(y, x)
    xyplot(x, dy_dx, 'grad of sigmoid')
    

    在这里插入图片描述

    3.8.2.3 tanh函数

    tanh(双曲正切)函数可以将元素的值变换到-1和1之间:

    定义如下:

    tanh ( x ) = 1 − exp ⁡ ( − 2 x ) 1 + exp ⁡ ( − 2 x ) . (式6) \text{tanh}(x) = \frac{1 - \exp(-2x)}{1 + \exp(-2x)}.\tag{式6} tanh(x)=1+exp(2x)1exp(2x).(6)
    .
    绘制tanh函数。当输入接近0时,tanh函数接近线性变换。虽然该函数的形状和sigmoid函数的形状很像,但tanh函数在坐标系的原点上对称。

    y = tf.nn.tanh(x)
    xyplot(x, y, 'tanh')
    

    在这里插入图片描述

    依据链式法则,tanh函数的导数
    t a n h ′ ( x ) = 1 − t a n h 2 ( x ) . (式7) tanh′(x)=1−tanh^2 (x).\tag{式7} tanh(x)=1tanh2(x).(7)

    下面绘制了tanh函数的导数。当输入为0时,tanh函数的导数达到最大值1;当输入越偏离0时,tanh函数的导数越接近0。

    with tf.GradientTape() as t:
        t.watch(x)
        y = tf.nn.tanh(x)
    dy_dx = t.gradient(y, x)
    xyplot(x, dy_dx, 'grad of tanh')
    

    在这里插入图片描述

    3.8.3 多层感知机

    多层感知机就是含有至少一个隐藏层的由全连接层组成的神经网络,且每个隐藏层的输出通过激活函数进行变换。多层感知机的层数和各隐藏层中隐藏单元个数都是超参数。以单隐藏层为例并沿用本节之前定义的符号,多层感知机按以下方式计算输出:
    H = ϕ ( X W h + b h ) , O = H W o + b o , (式8) \begin{aligned} \boldsymbol{H} &= \phi(\boldsymbol{X} \boldsymbol{W}_h + \boldsymbol{b}_h),\\\boldsymbol{O} &= \boldsymbol{H} \boldsymbol{W}_o + \boldsymbol{b}_o, \end{aligned}\tag{式8} HO=ϕ(XWh+bh),=HWo+bo,(8)

    其中 ϕ \phi ϕ表示激活函数。在分类问题中,我们可以对输出O做softmax运算,并使用softmax回归中的交叉熵损失函数。 在回归问题中,我们将输出层的输出个数设为1,并将输出O直接提供给线性回归中使用的平方损失函数。

    • 小结
      多层感知机在输出层与输入层之间加入了一个或多个全连接隐藏层,并通过激活函数对隐藏层输出进行变换。
      常用的激活函数包括ReLU函数、sigmoid函数和tanh函数。
    
    
    展开全文
  • pytorch-多层感知机

    2020-02-12 20:29:18
    多层感知机 多层感知机的基本知识 使用多层感知机图像分类的从零开始的实现 使用pytorch的简洁实现 多层感知机的基本知识 深度学习主要关注多层模型。在这里,我们将以多层感知机(multilayer perceptron,MLP)为...

    多层感知机

    1. 多层感知机的基本知识
    2. 使用多层感知机图像分类的从零开始的实现
    3. 使用pytorch的简洁实现

    多层感知机的基本知识

    深度学习主要关注多层模型。在这里,我们将以多层感知机(multilayer perceptron,MLP)为例,介绍多层神经网络的概念。

    隐藏层

    下图展示了一个多层感知机的神经网络图,它含有一个隐藏层,该层中有5个隐藏单元。

    Image Name

    表达公式

    具体来说,给定一个小批量样本 X ∈ R n × d \boldsymbol{X} \in \mathbb{R}^{n \times d} XRn×d,其批量大小为 n n n,输入个数为 d d d。假设多层感知机只有一个隐藏层,其中隐藏单元个数为 h h h。记隐藏层的输出(也称为隐藏层变量或隐藏变量)为 H \boldsymbol{H} H,有 H ∈ R n × h \boldsymbol{H} \in \mathbb{R}^{n \times h} HRn×h。因为隐藏层和输出层均是全连接层,可以设隐藏层的权重参数和偏差参数分别为 W h ∈ R d × h \boldsymbol{W}_h \in \mathbb{R}^{d \times h} WhRd×h b h ∈ R 1 × h \boldsymbol{b}_h \in \mathbb{R}^{1 \times h} bhR1×h,输出层的权重和偏差参数分别为 W o ∈ R h × q \boldsymbol{W}_o \in \mathbb{R}^{h \times q} WoRh×q b o ∈ R 1 × q \boldsymbol{b}_o \in \mathbb{R}^{1 \times q} boR1×q

    我们先来看一种含单隐藏层的多层感知机的设计。其输出 O ∈ R n × q \boldsymbol{O} \in \mathbb{R}^{n \times q} ORn×q的计算为

    H = X W h + b h , O = H W o + b o , \begin{aligned} \boldsymbol{H} &= \boldsymbol{X} \boldsymbol{W}_h + \boldsymbol{b}_h,\\ \boldsymbol{O} &= \boldsymbol{H} \boldsymbol{W}_o + \boldsymbol{b}_o, \end{aligned} HO=XWh+bh,=HWo+bo,

    也就是将隐藏层的输出直接作为输出层的输入。如果将以上两个式子联立起来,可以得到

    O = ( X W h + b h ) W o + b o = X W h W o + b h W o + b o . \boldsymbol{O} = (\boldsymbol{X} \boldsymbol{W}_h + \boldsymbol{b}_h)\boldsymbol{W}_o + \boldsymbol{b}_o = \boldsymbol{X} \boldsymbol{W}_h\boldsymbol{W}_o + \boldsymbol{b}_h \boldsymbol{W}_o + \boldsymbol{b}_o. O=(XWh+bh)Wo+bo=XWhWo+bhWo+bo.

    从联立后的式子可以看出,虽然神经网络引入了隐藏层,却依然等价于一个单层神经网络:其中输出层权重参数为 W h W o \boldsymbol{W}_h\boldsymbol{W}_o WhWo,偏差参数为 b h W o + b o \boldsymbol{b}_h \boldsymbol{W}_o + \boldsymbol{b}_o bhWo+bo。不难发现,即便再添加更多的隐藏层,以上设计依然只能与仅含输出层的单层神经网络等价。

    激活函数

    上述问题的根源在于全连接层只是对数据做仿射变换(affine transformation),而多个仿射变换的叠加仍然是一个仿射变换。解决问题的一个方法是引入非线性变换,例如对隐藏变量使用按元素运算的非线性函数进行变换,然后再作为下一个全连接层的输入。这个非线性函数被称为激活函数(activation function)。

    下面我们介绍几个常用的激活函数:

    ReLU函数

    ReLU(rectified linear unit)函数提供了一个很简单的非线性变换。给定元素 x x x,该函数定义为

    ReLU ( x ) = max ⁡ ( x , 0 ) . \text{ReLU}(x) = \max(x, 0). ReLU(x)=max(x,0).

    可以看出,ReLU函数只保留正数元素,并将负数元素清零。为了直观地观察这一非线性变换,我们先定义一个绘图函数xyplot。

    %matplotlib inline
    import torch
    import numpy as np
    import matplotlib.pyplot as plt
    import sys
    sys.path.append("/home/kesci/input")
    import d2lzh1981 as d2l
    print(torch.__version__)
    
    1.3.0
    
    def xyplot(x_vals, y_vals, name):
        # d2l.set_figsize(figsize=(5, 2.5))
        plt.plot(x_vals.detach().numpy(), y_vals.detach().numpy())
        # detach,切断从这点开始的反向传播
        plt.xlabel('x')
        plt.ylabel(name + '(x)')
    
    x = torch.arange(-8.0, 8.0, 0.1, requires_grad=True)
    y = x.relu()
    xyplot(x, y, 'relu')
    
    y.sum().backward()
    xyplot(x, x.grad, 'grad of relu')
    # 从下面这幅图中可以知道,relu在x<0处的梯度为0,在x>0处的梯度为1,在x = 0处梯度
    

    Sigmoid函数

    sigmoid函数可以将元素的值变换到0和1之间:

    sigmoid ( x ) = 1 1 + exp ⁡ ( − x ) . \text{sigmoid}(x) = \frac{1}{1 + \exp(-x)}. sigmoid(x)=1+exp(x)1.

    y = x.sigmoid()
    xyplot(x, y, 'sigmoid')
    

    依据链式法则,sigmoid函数的导数

    sigmoid ′ ( x ) = sigmoid ( x ) ( 1 − sigmoid ( x ) ) . \text{sigmoid}'(x) = \text{sigmoid}(x)\left(1-\text{sigmoid}(x)\right). sigmoid(x)=sigmoid(x)(1sigmoid(x)).

    下面绘制了sigmoid函数的导数。当输入为0时,sigmoid函数的导数达到最大值0.25;当输入越偏离0时,sigmoid函数的导数越接近0。

    #x.grad.zero_()
    y.sum().backward()
    xyplot(x, x.grad, 'grad of sigmoid')
    

    tanh函数

    tanh(双曲正切)函数可以将元素的值变换到-1和1之间:

    tanh ( x ) = 1 − exp ⁡ ( − 2 x ) 1 + exp ⁡ ( − 2 x ) . \text{tanh}(x) = \frac{1 - \exp(-2x)}{1 + \exp(-2x)}. tanh(x)=1+exp(2x)1exp(2x).

    我们接着绘制tanh函数。当输入接近0时,tanh函数接近线性变换。虽然该函数的形状和sigmoid函数的形状很像,但tanh函数在坐标系的原点上对称。

    y = x.tanh()
    xyplot(x, y, 'tanh')
    

    依据链式法则,tanh函数的导数

    tanh ′ ( x ) = 1 − tanh 2 ( x ) . \text{tanh}'(x) = 1 - \text{tanh}^2(x). tanh(x)=1tanh2(x).

    下面绘制了tanh函数的导数。当输入为0时,tanh函数的导数达到最大值1;当输入越偏离0时,tanh函数的导数越接近0。

    x.grad.zero_()
    y.sum().backward()
    xyplot(x, x.grad, 'grad of tanh')
    

    关于激活函数的选择

    ReLu函数是一个通用的激活函数,目前在大多数情况下使用。但是,ReLU函数只能在隐藏层中使用。

    用于分类器时,sigmoid函数及其组合通常效果更好。由于梯度消失问题,有时要避免使用sigmoid和tanh函数。

    在神经网络层数较多的时候,最好使用ReLu函数,ReLu函数比较简单计算量少,而sigmoid和tanh函数计算量大很多。

    在选择激活函数的时候可以先选用ReLu函数如果效果不理想可以尝试其他激活函数。

    多层感知机

    多层感知机就是含有至少一个隐藏层的由全连接层组成的神经网络,且每个隐藏层的输出通过激活函数进行变换。多层感知机的层数和各隐藏层中隐藏单元个数都是超参数。以单隐藏层为例并沿用本节之前定义的符号,多层感知机按以下方式计算输出:

    H = ϕ ( X W h + b h ) , O = H W o + b o , \begin{aligned} \boldsymbol{H} &= \phi(\boldsymbol{X} \boldsymbol{W}_h + \boldsymbol{b}_h),\\ \boldsymbol{O} &= \boldsymbol{H} \boldsymbol{W}_o + \boldsymbol{b}_o, \end{aligned} HO=ϕ(XWh+bh),=HWo+bo,

    其中 ϕ \phi ϕ表示激活函数。

    多层感知机从零开始的实现

    import torch
    import numpy as np
    import sys
    sys.path.append("/home/kesci/input")
    import d2lzh1981 as d2l
    print(torch.__version__)
    
    1.3.0
    

    获取训练集

    # 上一节中图像识别得到的
    batch_size = 256
    train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size,root='/home/kesci/input/FashionMNIST2065')
    

    定义模型参数

    num_inputs, num_outputs, num_hiddens = 784, 10, 256
    
    W1 = torch.tensor(np.random.normal(0, 0.01, (num_inputs, num_hiddens)), dtype=torch.float)# 784*256
    b1 = torch.zeros(num_hiddens, dtype=torch.float)
    # 这里隐藏层为256*256,也就是可以这么理解有256个隐藏节点,每个节点的规模是1*256
    W2 = torch.tensor(np.random.normal(0, 0.01, (num_hiddens, num_outputs)), dtype=torch.float)
    b2 = torch.zeros(num_outputs, dtype=torch.float)
    
    params = [W1, b1, W2, b2]
    for param in params:
        param.requires_grad_(requires_grad=True)
    # 设置可以反向求导
    

    定义激活函数

    def relu(X):
        return torch.max(input=X, other=torch.tensor(0.0))
        #torch.max(input, other, out=None) → Tensor,input (Tensor) – 输入张量other (Tensor) – 输出张量
    

    定义网络

    def net(X):
        X = X.view((-1, num_inputs))
        H = relu(torch.matmul(X, W1) + b1)
        # matmul是高维度矩阵相乘的函数,mm是只是针对二维矩阵
        return torch.matmul(H, W2) + b2
    

    定义损失函数

    loss = torch.nn.CrossEntropyLoss()
    # 交叉熵损失函数
    

    训练

    num_epochs, lr = 5, 100.0
    # 内置的交叉熵是求均值,所以为了得到和上一节相似结果,需要提高batch_size倍
    # def train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size,
    #               params=None, lr=None, optimizer=None):
    #     for epoch in range(num_epochs):
    #         train_l_sum, train_acc_sum, n = 0.0, 0.0, 0
    #         for X, y in train_iter:
    #             y_hat = net(X)
    #             l = loss(y_hat, y).sum()
    #             
    #             # 梯度清零
    #             if optimizer is not None:
    #                 optimizer.zero_grad()
    #             elif params is not None and params[0].grad is not None:
    #                 for param in params:
    #                     param.grad.data.zero_()
    #            
    #             l.backward()
    #             if optimizer is None:
    #                 d2l.sgd(params, lr, batch_size)
    #             else:
    #                 optimizer.step()  # “softmax回归的简洁实现”一节将用到
    #             
    #             
    #             train_l_sum += l.item()
    #             train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
    #             n += y.shape[0]
    #         test_acc = evaluate_accuracy(test_iter, net)
    #         print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f'
    #               % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))
    
    d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, params, lr)
    
    epoch 1, loss 0.0031, train acc 0.712, test acc 0.791
    epoch 2, loss 0.0019, train acc 0.822, test acc 0.827
    epoch 3, loss 0.0017, train acc 0.846, test acc 0.823
    epoch 4, loss 0.0015, train acc 0.856, test acc 0.830
    epoch 5, loss 0.0014, train acc 0.865, test acc 0.849
    

    多层感知机pytorch实现

    import torch
    from torch import nn
    from torch.nn import init
    import numpy as np
    import sys
    sys.path.append("/home/kesci/input")
    import d2lzh1981 as d2l
    
    print(torch.__version__)
    

    初始化模型和各个参数

    num_inputs, num_outputs, num_hiddens = 784, 10, 256
        
    net = nn.Sequential(
            d2l.FlattenLayer(),
            # 在d2l中定义了把图片压成一行的数据
            nn.Linear(num_inputs, num_hiddens),
            nn.ReLU(),
            nn.Linear(num_hiddens, num_outputs), 
            )
        
    for params in net.parameters():
        init.normal_(params, mean=0, std=0.01)
    

    训练

    batch_size = 256
    train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size,root='/home/kesci/input/FashionMNIST2065')
    loss = torch.nn.CrossEntropyLoss()
    
    optimizer = torch.optim.SGD(net.parameters(), lr=0.5)
    
    num_epochs = 5
    d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)
    
    
    
    展开全文
  • 这是用matlab实现的一个多层感知机,由三个全连接层组成,压缩包中的脚本可直接运行。 运行顺序为: 1.data_gen.m (在工作空间生成数据集 data.mat ,因为压缩包本来已经有数据集了,这一步可以跳过, 画出数据集的...
  • 多层感知机理解

    2021-04-26 10:26:54
    好在我对神经网络的了解是从卷积神经网络开始的,对基本的原理和模型已经有了了解,所以学习起来相对容易,先看多层感知机的模型: 1.网络的连接及输出: 1.最左边就是我们的输入层了,算是网络的第0层,通常是一...

    一.网络的原理和结构

    多层感知器(Muti-Layer Percetron)和卷积网络(Convolutional Neural Network)。这两种网络都属于前馈型网络(Feedforward network),其中多层感知器(MLP)是最简单也是最常见的一种神经网络结构,它是所有其他神经网络结构的基础,

    好在我对神经网络的了解是从卷积神经网络开始的,对基本的原理和模型已经有了了解,所以学习起来相对容易,先看多层感知机的模型:
    在这里插入图片描述
    如何设计一个网络,输入代表像素的值,输出0-9之间的一个正确的数字
    在这里插入图片描述
    在这里插入图片描述
    先把神经元当做数字
    在这里插入图片描述
    在这里插入图片描述
    每个神经元里面是我们要提取的特征值,即像素的灰度值,0表示纯黑,1 表示纯白
    在这里插入图片描述

    这784个神经元组成了第一层,即神经网络的输入层

    网络的最后一层是输出层,输出的是可能的概率,哪个概率最大,就代表识别的结果是哪个数字
    在这里插入图片描述

    网络的中间是隐藏层,包含这一些算法
    在这里插入图片描述
    比如网络的第三层,我们已经提取到局部的特征,只需要考虑将局部特征组合起来有多少 可能组成某一个数字
    在这里插入图片描述

    在这里插入图片描述
    那再往前推,前面的一层网络就要能提取出更小的局部特征,把他们组合起来
    在这里插入图片描述
    通过权重值w,来提取我们关注的区域的值
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    这个加权和,再通过激活函数映射到[0,1]的区间

    在这里插入图片描述
    而通过偏置值,控制加权和不过早的激发

    在这里插入图片描述
    将加权和减去一个数,不让不必要的神经元激活,
    在这里插入图片描述
    权重代表我们关注什么样的图案,而偏置值代表加权和有多大激活神经元才有意义

    在网络的第二层,每一个神经元都和上一层的784个神经元保持全连接
    在这里插入图片描述

    每个神经元都带一个权重和偏置值
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    用向量表示
    在这里插入图片描述
    所以,网络中每一个神经元更像一个函数,接收输入,输出0-1的值
    在这里插入图片描述

    进而整个网络也可以看成一个函数,接收输入,输出一个结果
    在这里插入图片描述

    在这里插入图片描述

    二.网络如何学习

    在网络训练的时候,我们需要定义一个代价函数,来告诉网络与正确值的差距在这里插入图片描述
    定义正确值1,其他为0,将网络输出的结果与实际结果相减,再将他们差的平方加起来,得到一个损失值
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    代价函数输出单个数值,来评价整个网络中的权重和偏置值与正确结果的差距
    在这里插入图片描述
    网络需要知道如何调整这些输入参数使输出接近正确的结果

    以二维图像为例

    随便 选一个输入值,然后考虑向左还是向右
    在这里插入图片描述

    计算斜率,斜率为正,表示函数是上升,那么我们梯度的反方向即向左

    斜率为负,表示梯度是下降的,我们继续往右找到最低点
    在这里插入图片描述

    在每一点这样重复的计算斜率,直到找到局部最低点
    在这里插入图片描述
    在这里插入图片描述
    在三维空间如何计算
    在这里插入图片描述
    同样也是计算梯度,沿梯度的反方向下降一小步

    在这里插入图片描述

    梯度如何计算:

    梯度,就是封装了所有偏导的向量
    在这里插入图片描述

    在这里插入图片描述

    这样我们就有了一个权重向量和一个反向梯度向量

    在这里插入图片描述
    将两个向量的对应的每一项相加,得到新的权重,再更新权重,如此循环
    在这里插入图片描述
    同时,代价值的绝对值表示每个w和B的重要程度
    在这里插入图片描述
    假如有一个函数的在点[1,1]的梯度向量是 [ 3 1 ] \begin{bmatrix} 3\\1\\ \end{bmatrix} [31]
    在这里插入图片描述
    在这里插入图片描述
    也可以理解为改变x对函数影响更大

    在这里插入图片描述

    这样来看,网络的代价函数是把权重和偏置作为输入

    在这里插入图片描述

    三.反向传播法

    通过代价函数我们得到了误差值

    然后需要把所有样本的误差值平均值

    在这里插入图片描述

    我们求出的负梯度,同时反映了代价函数值的重要程度,
    在这里插入图片描述
    比如样本2,网络输出的值与正确的值差距较大,如何增大这个输出呢

    如何让这个结果变大

    我们知道这个结果是上一层的输出+权重+偏置再通过激活函数得到的

    那么有三个方法

    *增大上一层的输出

    *增加权重

    *增加偏置值

    在这里插入图片描述
    如何增加权重

    比较亮的神经元,对应的权重对结果影响相对更大,所以增加相对亮的神经元,训练的效率会更高
    在这里插入图片描述
    所以当反向传播的时候,不仅要看高边哪些权重,还要看改变那些权重性价比高
    在这里插入图片描述
    如何改变上一层的输出

    和更改权重一样,如果我们需要结果更大的时候,依据权重的大小,对上一层的结果做出呈比例的改变
    在这里插入图片描述
    结果2期待上一层的值如何改变,比如增大

    结果3期待上一层的值如何改变,比如减小

    我们把这些期待全部加起来,作为如何改变上一层的值的指示

    如此往复循环,达到训练的效果

    这就是反向传播的理念
    在这里插入图片描述

    展开全文
  • 多层感知机1、概述2、原理3、多层感知机(MLP)代码详细解读(基于python+PyTorch) 1、概述 \quad \quad多层感知机(MLP,Multilayer Perceptron)也叫人工神经网络(ANN,Artificial Neural Network),除了输入...
  • @(Aaron)[机器学习 | 多层感知机] 主要内容包括: 多层感知机的基本知识 使用多层感知机图像分类的从零开始的实现 使用pytorch的简洁实现 文章目录多层感知机的基本知识隐藏层表达公式激活函数关于激活函数的选择...
  • 文章目录问题概述公式推导Numpy实现 问题概述 公式推导 Numpy实现
  • 多层感知机预测两个值 学习深度学习 目前,我在Jason Brownlee的《 Python深度学习》一书的帮助下学习了深度学习基础知识。 它为构建各种类型的深度学习网络(如CNN,RNN等)提供了良好的实践覆盖。运行本书中的每...
  • 理解多层感知机

    2020-02-14 22:17:09
    多层感知机的基本知识 深度学习主要关注多层模型。在这里,我们将以多层感知机(multilayer perceptron,MLP)为例,介绍多层神经网络的概念。 隐藏层 下图展示了一个多层感知机的神经网络图,它含有一个隐藏层,该...
  • 深入理解多层感知机

    2021-04-16 15:36:34
    多层感知机在单层神经网络的基础上引入了一到多个隐藏层(hidden layer)。隐藏层位于输入层和输出层之间。下图展示了一个多层感知机的神经网络图,它含有一个隐藏层,该层中有5个隐藏单元。 图中所展示的多层感知机...
  • 多层感知机实现

    2021-05-16 15:52:46
    多层感知机(mutilayer preceptron)加入了隐藏层,将神经网络的层级加深,因为线性层的串联结果还是线性层,所以必须在每个隐藏层之后添加激活函数,即增加model的非线性能力,使得model的function set变大。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,674
精华内容 9,869
关键字:

多层感知机