精华内容
下载资源
问答
  • 多层感知器

    千次阅读 2019-08-08 22:57:26
    很简单的一个分布,但事实上就是无法用直线进行分类,后来就出现了多层感知器,主要改变的地方是把第一层的感知器的输出作为第二层感知器的输入,即使只是简单添加一层感知器,也足以解决xor问题,关键的原因是,多...

    在介绍单层感知器的时候,我们提到对于非线性可分问题,单层感知器是很难解决的,比如下面这个例子:

    很简单的一个分布,但事实上就是无法用直线进行分类,后来就出现了多层感知器,主要改变的地方是把第一层的感知器的输出作为第二层感知器的输入,即使只是简单添加一层感知器,也足以解决xor问题,关键的原因是,多了一层感知器,就像对原来的输入做了一个映射,第一层感知器的目的是对输入进行映射使得数据在新的空间能够线性可分,然后我们再利用第二层感知器对数据进行分类,我们通过训练模型,使得第一层感知器能更好地重新映射原输入,第二层感知器能更好地分类。

    接下来结合下图介绍一下多层感知器的一些术语和结构。

    多层感知器,又叫深度前馈网络、前馈神经网络。最左边的是输入层,就是我们的输入数据,最右边的是输出层,中间的就是隐藏层(因为训练数据并没有直接表明隐藏层的每一层的所需输出),实际上就是由感知器构成。从现在开始,感知器就开始称为神经元,而这整个包含了输入层、隐藏层和输出层的结构就是大名鼎鼎的神经网络。可以看到相邻层之间的神经元是全连接的。

    多层感知器的学习过程也是和感知器接近,主要都是计算训练数据的输出,根据预测输出和实际输出之间的差异去调整神经元的权值和阈值,不断迭代训练直到误差小于一定范围。同时也可能有一种情况,就是迭代次数已经很大可是模型依然无法得到很好的训练效果,这时我们就需要调整模型的超参数,比如神经元的数量、隐藏层的层数等等。基本上,这个过程和之前的线性回归等机器学习过程是一致的。

    想浏览更多关于数学、机器学习、深度学习的内容,可浏览本人博客

    展开全文
  • 多层感知器-源码

    2021-02-16 06:53:46
    多层感知器
  • 多层感知器神经网络 多层感知器神经网络的实现(多层感知器 - MLP) - 语言:C++ MLP(多层感知器)是一种前馈神经网络,可将输入数据集映射到适当的输出集。 MLP 由有向图中的几层节点(顶点)组成,每一层都完全...
  • python实现单层感知器(附赠多层感知器源码) 实验报告类型
  • python实现多层感知器

    2020-09-19 17:03:40
    主要为大家详细介绍了python实现多层感知器的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 多层感知器:Google Colab中的Python从零开始开发的多层感知器。 使用的库:numpy,matplotlib,sklearn
  • 用python写了个多层感知器,用bp梯度下降更新,拟合正弦曲线,效果凑合。

        写了个多层感知器,用bp梯度下降更新,拟合正弦曲线,效果凑合。


    # -*- coding: utf-8 -*-
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    def sigmod(z):
        return 1.0 / (1.0 + np.exp(-z))
    
    
    class mlp(object):
        def __init__(self, lr=0.1, lda=0.0, te=1e-5, epoch=100, size=None):
            self.learningRate = lr
            self.lambda_ = lda
            self.thresholdError = te
            self.maxEpoch = epoch
            self.size = size
            self.W = []
            self.b = []
            self.init()
    
        def init(self):
            for i in xrange(len(self.size)-1):
                self.W.append(np.mat(np.random.uniform(-0.5, 0.5, size=(self.size[i+1], self.size[i]))))
                self.b.append(np.mat(np.random.uniform(-0.5, 0.5, size=(self.size[i+1], 1))))
    
        def forwardPropagation(self, item=None):
            a = [item]
            for wIndex in xrange(len(self.W)):
                a.append(sigmod(self.W[wIndex]*a[-1]+self.b[wIndex]))
            """
            print "-----------------------------------------"
            for i in a:
                print i.shape,
            print
            for i in self.W:
                print i.shape,
            print
            for i in self.b:
                print i.shape,
            print
            print "-----------------------------------------"
            """
            return a
    
        def backPropagation(self, label=None, a=None):
            # print "backPropagation--------------------begin"
            delta = [(a[-1]-label)*a[-1]*(1.0-a[-1])]
            for i in xrange(len(self.W)-1):
                abc = np.multiply(a[-2-i], 1-a[-2-i])
                cba = np.multiply(self.W[-1-i].T*delta[-1], abc)
                delta.append(cba)
            """
            print "++++++++++++++delta++++++++++++++++++++"
            print "len(delta):", len(delta)
            for ii in delta:
                print ii.shape,
            print "\n======================================="
            """
            for j in xrange(len(delta)):
                ads = delta[j]*a[-2-j].T
                # print self.W[-1-j].shape, ads.shape, self.b[-1-j].shape, delta[j].shape
                self.W[-1-j] = self.W[-1-j]-self.learningRate*(ads+self.lambda_*self.W[-1-j])
                self.b[-1-j] = self.b[-1-j]-self.learningRate*delta[j]
                """print "=======================================1234"
                for ij in self.b:
                    print ij.shape,
                print
                """
            # print "backPropagation--------------------finish"
            error = 0.5*(a[-1]-label)**2
            return error
    
        def train(self, input_=None, target=None, show=10):
            for ep in xrange(self.maxEpoch):
                error = []
                for itemIndex in xrange(input_.shape[1]):
                    a = self.forwardPropagation(input_[:, itemIndex])
                    e = self.backPropagation(target[:, itemIndex], a)
                    error.append(e[0, 0])
                tt = sum(error)/len(error)
                if tt < self.thresholdError:
                    print "Finish {0}: ".format(ep), tt
                    return
                elif ep % show == 0:
                    print "epoch {0}: ".format(ep), tt
    
        def sim(self, inp=None):
            return self.forwardPropagation(item=inp)[-1]
    
    
    if __name__ == "__main__":
        tt = np.arange(0, 6.28, 0.01)
        labels = np.zeros_like(tt)
        print tt.shape
        """
        for po in xrange(tt.shape[0]):
            if tt[po] < 4:
                labels[po] = 0.0
            elif 8 > tt[po] >= 4:
                labels[po] = 0.25
            elif 12 > tt[po] >= 8:
                labels[po] = 0.5
            elif 16 > tt[po] >= 12:
                labels[po] = 0.75
            else:
                labels[po] = 1.0
        """
        tt = np.mat(tt)
        labels = np.sin(tt)*0.5+0.5
        labels = np.mat(labels)
        model = mlp(lr=0.2, lda=0.0, te=1e-5, epoch=500, size=[1, 6, 6, 6, 1])
        print tt.shape, labels.shape
        print len(model.W), len(model.b)
        print
        model.train(input_=tt, target=labels, show=10)
        sims = [model.sim(tt[:, idx])[0, 0] for idx in xrange(tt.shape[1])]
    
        xx = tt.tolist()[0]
        plt.figure()
        plt.plot(xx, labels.tolist()[0], xx, sims, 'r')
        plt.show()
    

    转载请注明出处。

    展开全文
  • 多层感知器速成

    千次阅读 2020-07-07 09:38:29
    转载自《深度学习–基于Keras的Python实践》第四章 ...人工神经网络领域通常被称为神经网络或多层感知器(MLP,MultilayerPerceptron),多层感知器也许是最有用的神经网络类型。多层感知器是一种前馈.

    转载自《深度学习–基于Keras的Python实践》第四章
    魏贞原 著
    电子工业出版社
    微信文章地址:https://mp.weixin.qq.com/s/WWuKIE4ZGD3KFjLnBojjhQ
    很不错的书,推荐购买实体书。
    转载目的是为了方便大家学习,如有侵权,请联系 root@smileyan.cn 。立即删除

    人工神经网络是一个引人入胜的学习领域,尽管在开始学习的时候非常复杂。本章将会快速的介绍一下在人工神经网络领域使用的多层感知器。

    4.1 多层感知器

    人工神经网络领域通常被称为神经网络或多层感知器(MLP,MultilayerPerceptron),多层感知器也许是最有用的神经网络类型。多层感知器是一种前馈人工神经网络模型,其将输入的多个数据维度映射到单一的输出的数据维度上。感知器是单个神经元模型,它是较大神经网络的基石。多层感知器是一个研究如何模拟生物电脑模型来解决困难的计算任务的方法,是具有良好的鲁棒性算法和数据结构的模型。

    神经网络依靠系统的复杂程度,通过调整内部大量节点之间相互连接的关系,从而达到处理信息的目的。神经网络的一个重要特性是它能够从环境中学习,并把学习的结果分布存储于网络的突触连接中。在数学上,神经网络能够学习任何映射函数,并且已被证明是一种通用近似算法。神经网络的学习是一个过程,在其所处环境的激励下,相继给网络输入一些样本模式,并按照一定的规则(学习算法)调整网络各层的权值矩阵,待网络各层权值都收敛到一定值,学习过程结束。然后就可以用生成的神经网络来对真实数据做预测。神经网络的预测能力来自网络的分层或多层结构。数据结构可以选择(学习代表)不同尺度或分辨率的特征,并将它们组合成高阶特征。例如从线,到线的集合到形状。

    4.2 神经元

    神经元是构成神经网络的基本模块。神经元模型是一个包含加权输入,并且使用激活功能产生输出信号的基础计算单元。输入可以类比为神经元的树突,而输出可以类比为神经元的轴突,计算则可以类比为细胞核。图4-1是一个简单的神经元示例,有3个输入和一个输出构成。

    图 4.1

    4.2.1 神经元权重

    线性回归中输入的权重与回归方程中使用的系数非常相似。与线性回归一样,每个神经元也有一个偏差,可以被认为是总是具有值1.0的输入,它也必须加权。例如,神经元可能有两个输入,在这种情况下,它需要三个权重。每个输入一个,偏置一个。

    尽管可以使用更复杂的初始化方案,权重通常被初始化为小的随机值,例如0到0.3范围内的值。像线性回归一样,较大的权重表示模型的复杂性和脆弱性的增加。小随机数初始化权重初始值要非常接近0又不能等于0,就是将权重初始化为很小的数值,以此来打破对称性。

    采用小随机数初始化权重,为什么不将权重初始化为0?因为如果网络中的每个神经元都计算出同样的输出,然后它们就会在反向传播中计算出同样的梯度,从而进行同样的参数更新。换句话说,如果权重被初始化为同样的值,神经元之间就失去了不对称性的源头。如果神经元刚开始的时候是随机且不相等的,那么它们将计算出不同的更新,并将自身变成整个网络的不同部分。

    4.2.2 激活函数

    激活函数是将加权输入与神经元输出的简单映射。它被称为激活函数,是因为它控制神经元激活的阈值和输出信号的强度。历史上最简单的激活函数时临界值判定,如总和输入高于阈值,例如0.5,则神经元将输出1.0的值,否则将输出0.0。

    激活函数通常有如下一些性质:

    • 非线性:当激活函数是线性的时候,一个两层的神经网络就可以逼近基本上所有的函数了。但是,如果激活函数是恒等激活函数的时候(即f(x)=x),就不满足这个性质了,而且如果MLP使用的是恒等激活函数,那么其实整个网络跟单层神经网络是等价的。
    • 可微性:当优化方法是基于梯度的时候,这个性质是必须的
    • 单调性:当激活函数是单调的时候,单层网络能够保证是凸函数。
    • f(x)≈x:当激活函数满足这个性质的时候,如果参数的初始化是random的很小的值,那么神经网络的训练将会很高效;如果不满足这个性质,那么就需要很用心的去设置初始值。
    • 输出值的范围:当激活函数输出值是有限的时候,基于梯度的优化方法会更加稳定,因为特征的表示受有限权值的影响更显著;当激活函数的输出是无限的时候,模型的训练会更加高效,不过在这种情况小,一般需要更小的学习率。

    既然激活函数具有这些特征,那么如何选择计划函数呢?传统上使用非线性激活函数。这允许网络以更复杂的方式组合输入,从而可以构建的功能中更丰富的模型。使用类似逻辑函数的非线性函数也称为sigmoid函数,它们以s形分布输出0和1之间的值。双曲正切函数也称为Tanh,它在-1到+1范围内输出相同的分布。最近,线性整流函数( ReLU)已被证明可以提供更好的结果,相比于 sigmoid和Tanh,ReLU只需要一个阈值就可以得到激活值,而不用去算一大堆复杂的运算。当然ReLU 也有缺点,就是训练的时候很”脆弱”,很容易就“死掉”。举个例子,一个非常大的梯度流过一个ReLU 神经元,更新过参数之后,这个神经元再也不会对任何数据有激活现象了。如果这个情况发生了,那么这个神经元的梯度就永远都会是0。

    4.3 神经网络

    神经元被布置成神经元网络。一排或者一列神经元称为一层,一个网络可以有多个层。网络中神经元的架构通常被称为网络拓扑。如图所示:
    图4-2
    在开始介绍神经网络之前,有一些知识可以先记在心里:

    • 设计一个神经网络时,输入层与输出层的节点数往往是固定的,中间层则可以自由指定;
    • 神经网络结构图中的拓扑与箭头代表着预测过程时数据的流向,跟训练时的数据流有一定的区别;
    • 结构图里的关键不是圆圈(代表“神经元”),而是连接线(代表“神经元”之间的连接)。每个连接线对应一个不同的权重(其值称为权值),这是需要训练得到的。

    4.3.1 输入层(可视层)

    从数据集中获取输入的层也称为可视层,因为它是网络的暴露在外的部分。通常,在数据集中每个输入值或列具有一个神经元,具有一个神经元的神经网络。输入层的神经元与上述神经元不同,仅是简单地将输入值传递到下一层。

    4.3.2 隐藏层

    输入层之后的层被称为隐藏层,因为它们不直接暴露给输入。最简单的网络结构是在隐层中具有直接输出值的单个神经元。考虑到计算能力和高效算法的增加,可以构建非常深的神经网络。深度学习可以指神经网络中有很多隐藏层。多层的神经网络,过去在训练上表现不佳,使用现代技术和硬件可能仅需要几秒钟或几分钟就能完成训练。理论证明,两层神经网络可以无限逼近任意连续函数。也就是说,面对复杂的非线性分类任务,两层(带一个隐藏层)神经网络可以分类的很好,关键就是从输入层到隐藏层时,数据发生了空间变换。也就是说,两层神经网络中,隐藏层对原始的数据进行了一个空间变换,使其可以被线性分类,然后输出层的决策分界划出了一个线性分类分界线,对其进行分类。两层神经网络通过两层的线性模型模拟了数据内真实的非线性函数。因此,多层的神经网络的本质就是复杂函数拟合。

    4.3.3 输出层

    最后的隐藏层称为输出层,它负责输出与项目问题所需格式相对应的值的值或向量。输出层中激活功能的选择受建模的问题类型的强烈约束。例如:

    • 回归问题可能有单个输出神经元,神经元可能没有激活功能。
    • 二进制分类问题可能具有单个输出神经元,并使用sigmoid激活函数输出0和1之间的值,以表示预测主类的值的概率。这可以通过使用阈值为0.5,捕捉值小于阈值为0而变为清晰的类值,否则为1。
    • 多分类分类问题可能在输出层中有多个神经元,每个类别有一个神经元(例如著名的鸢尾花分类问题中的三个类别的三个神经元)。在这种情况下,可以使用softmax激活功能来输出网络预测每个类值的概率。选择具有最高概率的输出可用于产生清晰的类分类值。

    在设计一个神经网络时,输入层的节点数需要与特征的维度匹配,输出层的节点数要与目标的维度匹配。而中间层的节点数,却是由设计者指定的。因此,“自由”把握在设计者的手中。但是,节点数设置的多少,却会影响到整个模型的效果。如何决定这个自由层的节点数呢?目前业界没有完善的理论来指导这个决策。一般是根据经验来设置。较好的方法就是预先设定几个可选值,通过切换这几个值来看整个模型的预测效果,选择效果最好的值作为最终选择。这种方法又叫做GridSearch(网格搜索)。

    4.4 训练神经网络

    当完成对神经网络的配置后,需要通过数据集来训练神经网络模型。

    4.4.1 准备数据

    训练神经网络模型首先必须准备数据,数据必须是数值。如果数据中存在类别数据,例如男性和女性的性别属性,可以将其转换为称为一个热编码的数值来表示分类。如:将男性设置为1,女性设置为0。

    对于多分类问题,输出变量可以使用相同的热编码。这将从单个列创建一个二进制向量,为每个类别输出一个值,并且很容易直接与网络输出层中神经元的输出进行比较。神经网络需要以相同的尺度对输入进行缩放,因此可以将其数据缩放到0和1之间的范围,称为归一化(Normalization)。另一种流行的技术是使其标准化(Standardize),使每列的分布具有零的平均值和标准偏差1。标度也适用于图像像素数据,单词的数据可以被转换为整数,例如数据集中的单词的频率等级和其他编码技术。

    4.4.2 随机梯度下降算法

    经典并且最为有效的神经网络训练算法称为随机梯度下降。随机梯度下降是随机和优化相结合的产物,属于梯度下降的一种,适用于大规模的问题。要想理解随机梯度下降,需要先明确梯度下降。众所周知,每个优化问题会有一个目标函数,梯度下降就是采用迭代的策略,从初始点开始,每次沿着目标函数在当前点的负梯度方向前进一定的步长,只要步长设置合理,可以得到一个单调递减的序列,直至最终不再下降,即可得到最优解。对于一般优化问题,梯度下降可以找到局部最优解,对于凸优化问题,梯度下降可以得到全局最优解。但是,当数据量非常大时,梯度下降的计算开销非常大,现在的DeepLearning中的数据量时非常巨大的,为了降低梯度下降的巨大计算开销,就出现了随机梯度下降算法。随机梯度下降的基本想法很简单,就是不直接计算梯度的精确值,而是用梯度的无偏估计来代替梯度,以便降低计算开销。从而让数据快速收敛。

    输入通过神经元的激活函数,一直传递到输出,这个过程叫做向前传导。将网络的输出与预期输出进行比较,并计算出错误。然后,该错误通过网络一次传播回来,并且根据它们对错误的贡献量更新权重。这个过程称为反向传播算法。在神经网络的模型训练中,会使用训练数据重复此过程。整个训练数据集的一轮更新网络被称为epochs。完成整个神经网络模型的训练需要数十,数百或数千个epochs。

    4.4.3 权重更新

    使用每个训练数据中错误计算更新网络中的权重,被称为在线学习。这可能会导致网络快速而混乱的变化。作为改进方法,在所有训练过程中保存结果误差,并在最后更新网络,这被称为批量学习,通常更稳定。

    通常数据集非常大,为了提高计算效率,批处理的大小,网络在更新之前显示的示例的数量通常减少到一个很小的数目,例如数十或数百个示例。权重更新由被称为学习率的配置参数控制,它也被称为步长,并控制给定结果误差对网络权重的更新。通常使用较小的学习率,例如0.1或0.01或更小。此外,更新方程还可以设置其他配置参数:

    • 动量(Momentum):不恰当的初始权值可能使得网络的损失函数在训练过程中陷入局部最小值,达不到全局最优的状态。因此,如何消除这种不确定性,是训练深度网络是必须解决的一个问题。动量(Momentum)能够在一定程度上解决这个问题,即使在计算过程中很少存在结果误差,也能确保持续更新权重。
    • 学习率衰减(Learning Rate Decay):平衡模型的训练速度和损失(loss)后选择了相对合适的学习率(learningrate),但是训练集的损失下降到一定的程度后就不在下降,遇到这种情况通常可以通过适当降低学习率(learningrate)来实现。但是,降低学习率又会延长训练所需的时间。学习率衰减(learningrate decay)就是一种可以平衡这两者之间矛盾的解决方案。学习率衰减的基本思想是:学习率随着训练的进行逐渐衰减。

    4.4.4 预测新数据

    一旦神经网络被训练,就可以用来做出预测。可以通过对评估数据进行预测,来评估模型对未知数据的准确度。训练完成的模型,可以部署到生产环境,并对新数据做出预测。网络拓扑和最终的权重集都是需要保存到模型的数据。通过向网络提供输入并执行向前传导,计算新数据通过模型后的输出,来完成对新数据的预测。

    在单层神经网络时,使用的激活函数是sgn函数。到了两层神经网络时,使用的最多的是sigmoid函数。而到了多层神经网络时,通过一系列的研究发现,ReLU函数在训练多层神经网络时,更容易收敛,并且预测性能更好。因此,目前在深度学习中,最流行的非线性函数是ReLU函数。ReLU函数不是传统的非线性函数,而是分段线性函数。其表达式非常简单,就是y=max(x,0)。简而言之,在x大于0,输出就是输入,而在x小于0时,输出就保持为0。这种函数的设计启发来自于生物神经元对于激励的线性响应,以及当低于某个阈值后就不再响应的模拟。

    在多层神经网络中,训练的主题仍然是优化和泛化。当使用足够强的计算芯片(例如GPU图形加速卡)时,梯度下降算法以及反向传播算法在多层神经网络中的训练中仍然工作的很好。目前学术界主要的研究既在于开发新的算法,也在于对这两个算法进行不断的优化,例如,增加了一种带动量因子(momentum)的梯度下降算法。

    在深度学习中,泛化技术变的比以往更加的重要。这主要是因为神经网络的层数增加了,参数也增加了,表示能力大幅度增强,很容易出现过拟合现象。因此正则化技术就显得十分重要。目前,Dropout技术,以及数据扩容(Data-Augmentation)技术是目前使用的最多的正则化技术。

    转载自《深度学习–基于Keras的Python实践》第四章
    魏贞原 著
    电子工业出版社
    微信文章地址:https://mp.weixin.qq.com/s/WWuKIE4ZGD3KFjLnBojjhQ
    很不错的书,推荐购买实体书。
    转载目的是为了方便大家学习,如有侵权,请联系 root@smileyan.cn 。立即删除

    展开全文
  • TensorFlow 多层感知器

    2019-12-02 09:50:44
    本文介绍如何使用TensorFlow对多层感知器进行编程。

    本文主要介绍使用TensorFlow对多层感知器(MLP)进行编程,其他内容参考:TensorFlow 学习目录

    目录

    一、多层感知器MLP


    一、多层感知器MLP

    多层感知器不同于CNN,CNN提取的是局部特征,而且CNN训练的并不是feature,而是feature的特征过滤器,也就是Filter(Kernel),多层感知器隐藏层中的每一个神经元是上一层的全部神经元的权重配比,并不具有局部性,而是更加注重整体,所以相比于CNN,MLP的参数量是非常庞大的。在多层感知器这种结构下,H-ELM、ML-ELM对其进行训练的效果是比Back Propagation算法进行不断地迭代训练好很多的,而且更快,只要调一次参数,而BP算法要调到收敛,并需要注意过拟合。

    import tensorflow as tf
    import numpy as np
    import get_Dataset
    
    x_train, y_train, x_test, y_test = get_Dataset.get_Dataset(name='mnist')
    
    inputs = tf.placeholder(dtype=tf.float32, shape=[None, 784], name='inputs')
    labels = tf.placeholder(dtype=tf.float32, shape=[None, 10], name='labels')
    pre_labels = tf.placeholder(dtype=tf.int64, shape=[None], name='pre_labels')
    
    def fully_connected(x, size):
        len_x = int(x.get_shape()[1])
        w = tf.Variable(tf.random_normal(shape=[len_x, size], stddev=0.1), dtype=tf.float32)
        b = tf.Variable(tf.constant(0.0, dtype=tf.float32, shape=[size]))
        z = tf.nn.relu(tf.nn.xw_plus_b(x, w, b))
        return z
    
    
    f1 = fully_connected(inputs, 520)
    f2 = fully_connected(f1, 200)
    logits = fully_connected(f2, 10)
    
    
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))
    optimizer = tf.train.AdamOptimizer(1e-4).minimize(loss)
    
    correct_pred = tf.equal(tf.argmax(logits, 1), pre_labels)
    acc = tf.reduce_mean(tf.cast(correct_pred, dtype=tf.float32))
    
    
    epochs = 50
    batch_size = 40
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
    
        for epoch in range(epochs):
            for batch in range(int(x_train.shape[0]/batch_size)):
                batchx = x_train[batch*batch_size: (batch+1)*batch_size]
                batchy = y_train[batch*batch_size: (batch+1)*batch_size]
    
                feed_dict={
                    inputs: batchx,
                    labels: batchy
                }
                _ = sess.run(optimizer, feed_dict=feed_dict)
    
            Acc = sess.run(acc, feed_dict={inputs: x_test, pre_labels: y_test})
            print ("Epoch ", epoch+1, "ACC = ", Acc)
    

    输出:

    Epoch  1 ACC =  0.9402
    Epoch  2 ACC =  0.9577
    Epoch  3 ACC =  0.9649
    Epoch  4 ACC =  0.9682
    Epoch  5 ACC =  0.9709
    Epoch  6 ACC =  0.972
    Epoch  7 ACC =  0.9738
    Epoch  8 ACC =  0.9756
    Epoch  9 ACC =  0.9757
    Epoch  10 ACC =  0.9762
    Epoch  11 ACC =  0.9766
    Epoch  12 ACC =  0.9759
    Epoch  13 ACC =  0.9768
    Epoch  14 ACC =  0.9765
    Epoch  15 ACC =  0.9772
    Epoch  16 ACC =  0.9773
    Epoch  17 ACC =  0.9782
    Epoch  18 ACC =  0.9773
    Epoch  19 ACC =  0.9798
    Epoch  20 ACC =  0.9781
    Epoch  21 ACC =  0.9795
    Epoch  22 ACC =  0.9745
    Epoch  23 ACC =  0.9813
    Epoch  24 ACC =  0.9806
    Epoch  25 ACC =  0.9804
    Epoch  26 ACC =  0.9804
    Epoch  27 ACC =  0.9786
    Epoch  28 ACC =  0.9811
    Epoch  29 ACC =  0.9811
    Epoch  30 ACC =  0.9808
    Epoch  31 ACC =  0.981
    Epoch  32 ACC =  0.9809
    Epoch  33 ACC =  0.9807
    Epoch  34 ACC =  0.9807
    Epoch  35 ACC =  0.982
    Epoch  36 ACC =  0.9819
    Epoch  37 ACC =  0.9816
    Epoch  38 ACC =  0.9817
    Epoch  39 ACC =  0.9809
    Epoch  40 ACC =  0.9749
    Epoch  41 ACC =  0.981
    Epoch  42 ACC =  0.981
    Epoch  43 ACC =  0.9811
    Epoch  44 ACC =  0.9815
    Epoch  45 ACC =  0.9813
    Epoch  46 ACC =  0.9808
    Epoch  47 ACC =  0.9811
    Epoch  48 ACC =  0.9817
    Epoch  49 ACC =  0.9819
    Epoch  50 ACC =  0.982

     

    展开全文
  • MLP:多层感知器-源码

    2021-03-21 18:43:07
    MLP:多层感知器
  • 多层感知器的极限学习机
  • keras 模型序列化 多层感知器进阶,代码有齐全的注释
  • 多层感知器神经网络

    2019-01-03 20:40:20
    理解多层感知器用于分类的原理和方法,特别是解决非线性多类别分类问题,利用实际数据进行分类处理。
  • 多层感知器重叠奇点的影响范围
  • 手写字识别_多层感知器(Keras')
  • 两层多层感知器 (MLP) 神经网络的 MLP 和反向传播算法的矩阵实现。 马塞洛·奥古斯托·科斯塔·费尔南德斯DCA - CT - UFRN mfernandes@dca.ufrn.br
  • 多层感知器

    2020-03-10 16:41:55
    文章目录多层感知器梯度下降法学习速率反向传播算法激活函数常见的优化函数 多层感知器 梯度下降法 学习速率 反向传播算法 激活函数 Relu tanh 3.sigmoid 4.Leak relu 常见的优化函数 SGD:随机...
  • TensorFlow多层感知器识别手写数字
  • keras人工智能构建多层感知器诊断印第安糖尿病,包含数据集和代码以及注释
  • 多层感知器原理分析出发, 提出一种自适应学习速率因子方法, 用于对多层感知器中BP 算 法的改进, 并将改进算法用于XOR 问题的学习及某分类器实例样本的学习。仿真结果表明, 改进的BP 算法可显著加速网络...
  • 多层感知器的分类和预测
  • TensorFlow实现多层感知器。单层感知器解决不了非线性的问题,此时需要引入多层感知器。其实质上是,一个含有一个或多个隐含层的神经网络。当出现神经网络层数较深时,我们要考虑过拟合、参数调试的困难、梯度弥散等...
  • MATLAB 中的人工神经网络练习 单层感知器 1- 可以线性分离 2- 不能线性分离 多层感知器 1- 分类 2- 鸢尾花 3-系统识别
  • 在本文中,我们将研究单隐藏层多层感知器(MLP)。
  • 多层感知器的基本特征

    千次阅读 2018-04-22 18:06:33
    多层感知器的基本特征 Rosenblatt 感知器本质上是一个单层神经网络,这一网络局限于线性可分模式的分类问题。自适应滤波采用了 Widrow 和 Hoff 的 LMS 算法。这一算法也是基于权值可调的单个线性神经元,这也限制...
  • 多层感知器是一种多层前馈神经网络 ,常用的快速训练算法有共轭梯度法、拟牛顿法。通 过模式分类实验对这两种算法和 BP算法进行比较 ,并由试验数据得出这几种算法的复杂性、可靠 性 ,以及由算法产生的多层感知器的...
  • 关于多层感知器隐节点的研究,王疏艳,高大启,本文分析了多层感知器的分类机理。提出在输入空间中隐节点的基本函数为0所决定的超平面并不起到超维分界面的作用。网络的学习过�

空空如也

空空如也

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

多层感知器