精华内容
下载资源
问答
  • 用pytorch导入MNIST数据集,然后手写BP神经网络实现对数据集的识别预测。

    BP神经网络原理可以参考:反向传播算法(Backpropagation)----Gradient Descent的推导过程
    主要步骤:

    1. input layer有784(28X28)个节点;3层hidden layer,每一层20个节点;output layer有10个节点,分别表示输出为0-9的概率
    2. 初始化所有w为(-1, 1)的随机值
    3. 前向传播,计算每一层输入输出的关系
    4. 反向传播计算损失函数的导数
    5. 更新权值

    代码:

    """
    @Time : 2020/8/15 10:19
    @Author :KI 
    @File :bp_mnist.py
    @Motto:Hungry And Humble
    
    """
    import numpy as np
    import torch
    import torchvision
    import torchvision.transforms as transforms
    from torch.utils.data import DataLoader
    import cv2
    
    #input layer:784 nodes; hidden layer:three hidden layers with 20 nodes in each layer
    #output layer:10 nodes
    class BP:
        def __init__(self):
            self.input = np.zeros((100, 784))   #100 samples per round
            self.hidden_layer_1 = np.zeros((100, 20))
            self.hidden_layer_2 = np.zeros((100, 20))
            self.hidden_layer_3 = np.zeros((100, 20))
            self.output_layer = np.zeros((100, 10))
            self.w1 = 2 * np.random.random((784, 20)) - 1   #limit to (-1, 1)
            self.w2 = 2 * np.random.random((20, 20)) - 1
            self.w3 = 2 * np.random.random((20, 20)) - 1
            self.w4 = 2 * np.random.random((20, 10)) - 1
            self.error = np.zeros(10)
            self.learning_rate = 0.1
    
        def sigmoid(self, x):
            return 1 / (1 + np.exp(-x))
    
        def sigmoid_deri(self, x):
            return x * (1 - x)
    
        def forward_prop(self, data, label):   #label:100 X 10,data: 100 X 784
            self.input = data
            self.hidden_layer_1 = self.sigmoid(np.dot(self.input, self.w1))
            self.hidden_layer_2 = self.sigmoid(np.dot(self.hidden_layer_1, self.w2))
            self.hidden_layer_3 = self.sigmoid(np.dot(self.hidden_layer_2, self.w3))
            self.output_layer = self.sigmoid(np.dot(self.hidden_layer_3, self.w4))
            #error
            self.error = label - self.output_layer
            return self.output_layer
    
        def backward_prop(self):
            output_diff = self.error * self.sigmoid_deri(self.output_layer)
            hidden_diff_3 = np.dot(output_diff, self.w4.T) * self.sigmoid_deri(self.hidden_layer_3)
            hidden_diff_2 = np.dot(hidden_diff_3, self.w3.T) * self.sigmoid_deri(self.hidden_layer_2)
            hidden_diff_1 = np.dot(hidden_diff_2, self.w2.T) * self.sigmoid_deri(self.hidden_layer_1)
            #update
            self.w4 += self.learning_rate * np.dot(self.hidden_layer_3.T, output_diff)
            self.w3 += self.learning_rate * np.dot(self.hidden_layer_2.T, hidden_diff_3)
            self.w2 += self.learning_rate * np.dot(self.hidden_layer_1.T, hidden_diff_2)
            self.w1 += self.learning_rate * np.dot(self.input.T, hidden_diff_1)
    
    #from torchvision load data
    def load_data():
        datasets_train = torchvision.datasets.MNIST(root='./data/', train=True, transform=transforms.ToTensor())
        datasets_test = torchvision.datasets.MNIST(root='./data/', train=False, transform=transforms.ToTensor())
        data_train = datasets_train.data
        X_train = data_train.numpy()
        X_test = datasets_test.data.numpy()
        X_train = np.reshape(X_train, (60000, 784))
        X_test = np.reshape(X_test, (10000, 784))
        Y_train = datasets_train.targets.numpy()
        Y_test = datasets_test.targets.numpy()
    
        real_train_y = np.zeros((60000, 10))
        real_test_y = np.zeros((10000, 10))
        #each y has ten dimensions
        for i in range(60000):
            real_train_y[i, Y_train[i]] = 1
        for i in range(10000):
            real_test_y[i, Y_test[i]] = 1
        index = np.arange(60000)
        np.random.shuffle(index)
        #shuffle train_data
        X_train = X_train[index]
        real_train_y = real_train_y[index]
    
        X_train = np.int64(X_train > 0)
        X_test = np.int64(X_test > 0)
    
    
        return X_train, real_train_y, X_test, real_test_y
    
    
    
    def bp_network():
        nn = BP()
        X_train, Y_train, X_test, Y_test = load_data()
        batch_size = 100
        epochs = 6000
        for epoch in range(epochs):
            start = (epoch % 600) * batch_size
            end = start + batch_size
            print(start, end)
            nn.forward_prop(X_train[start: end], Y_train[start: end])
            nn.backward_prop()
    
        return nn
    
    
    def bp_test():
        nn = bp_network()
        sum = 0
        X_train, Y_train, X_test, Y_test = load_data()
        #test:
        for i in range(len(X_test)):
            res = nn.forward_prop(X_test[i], Y_test[i])
            res = res.tolist()
            index = res.index(max(res))
            if Y_test[i, index] == 1:
                sum += 1
    
        print('accuracy:', sum / len(Y_test))
    
    
    if __name__ == '__main__':
        bp_test()
    

    结果:
    在这里插入图片描述
    注意第一次运行时,导入数据的第一条语句:

    datasets_train = torchvision.datasets.MNIST(root='./data/', train=True, transform=transforms.ToTensor())
    

    应该在后面加上

    download = True
    
    展开全文
  • 神经网络学习 之 BP神经网络

    万次阅读 多人点赞 2015-11-30 21:17:56
    上一次我们讲了M-P模型,...BP网络就是一种简单的人工神经网络。 本文具体来介绍一下一种非常常见的神经网络模型——反向传播(Back Propagation)神经网络。概述BP(Back Propagation)神经网络是1986年由Rumelhart和Mc

    上一次我们讲了M-P模型,它实际上就是对单个神经元的一种建模,还不足以模拟人脑神经系统的功能。由这些人工神经元构建出来的网络,才能够具有学习、联想、记忆和模式识别的能力。BP网络就是一种简单的人工神经网络。
    本文具体来介绍一下一种非常常见的神经网络模型——反向传播(Back Propagation)神经网络。

    概述

    BP(Back Propagation)神经网络是1986年由Rumelhart和McCelland为首的科研小组提出,参见他们发表在Nature上的论文 Learning representations by back-propagating errors

    BP神经网络是一种按误差逆传播算法训练的多层前馈网络,是目前应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的 输入-输出模式映射关系,而无需事前揭示描述这种映射关系的数学方程。它的学习规则是使用最速下降法,通过反向传播来不断 调整网络的权值和阈值,使网络的误差平方和最小。

    BP算法的基本思想

    上一次我们说到,多层感知器在如何获取隐层的权值的问题上遇到了瓶颈。既然我们无法直接得到隐层的权值,能否先通过输出层得到输出结果和期望输出的误差来间接调整隐层的权值呢?BP算法就是采用这样的思想设计出来的算法,它的基本思想是,学习过程由信号的正向传播与误差的反向传播两个过程组成。

    • 正向传播时,输入样本从输入层传入,经各隐层逐层处理后,传向输出层。若输出层的实际输出与期望的输出(教师信号)不符,则转入误差的反向传播阶段。
    • 反向传播时,将输出以某种形式通过隐层向输入层逐层反传,并将误差分摊给各层的所有单元,从而获得各层单元的误差信号,此误差信号即作为修正各单元权值的依据。

    这两个过程的具体流程会在后文介绍。

    BP算法的信号流向图如下图所示
    在这里插入图片描述
    BP网络特性分析——BP三要素

    我们分析一个ANN时,通常都是从它的三要素入手,即
    1)网络拓扑结构;
    2)传递函数;
    3)学习算法。

    在这里插入图片描述

    每一个要素的特性加起来就决定了这个ANN的功能特性。所以,我们也从这三要素入手对BP网络的研究。

    3.1 BP网络的拓扑结构

    上一次已经说了,BP网络实际上就是多层感知器,因此它的拓扑结构和多层感知器的拓扑结构相同。由于单隐层(三层)感知器已经能够解决简单的非线性问题,因此应用最为普遍。三层感知器的拓扑结构如下图所示。
    一个最简单的三层BP:
    这里写图片描述
    ###3.2 BP网络的传递函数
    BP网络采用的传递函数是非线性变换函数——Sigmoid函数(又称S函数)。其特点是函数本身及其导数都是连续的,因而在处理上十分方便。为什么要选择这个函数,等下在介绍BP网络的学习算法的时候会进行进一步的介绍。
    单极性S型函数曲线如下图所示。
    f ( x ) = 1 1 + e − x f(x)={1\over 1+e^{-x}} f(x)=1+ex1
    这里写图片描述
    双极性S型函数曲线如下图所示。
    f ( x ) = 1 − e − x 1 + e − x f(x)={1-e^{-x}\over 1+e^{-x}} f(x)=1+ex1ex

    这里写图片描述

    3.3 BP网络的学习算法

    BP网络的学习算法就是BP算法,又叫 δ 算法(在ANN的学习过程中我们会发现不少具有多个名称的术语), 以三层感知器为例,当网络输出与期望输出不等时,存在输出误差 E ,定义如下

    E = 1 2 ( d − O ) 2 = 1 2 ∑ κ = 1 ℓ ( d k − o k ) 2 E={1\over 2}(d−O)^2={1\over 2}∑_{κ=1}^ℓ(d_k−o_k)^2 E=21(dO)2=21κ=1(dkok)2

    将以上误差定义式展开至隐层,有
    E = 1 2 ∑ κ = 1 ℓ [ d κ − f ( n e t κ ) ] 2 = 1 2 ∑ κ = 1 ℓ [ d κ − f ( ∑ j = 0 m ω j κ y j ) ] 2 E={1\over 2}∑_{κ=1}^ℓ[d_κ−f(net_κ)]^2={1\over 2}∑_{κ=1}^ℓ[d_κ−f(∑_{j=0}^mω_{jκ}y_j)]^2 E=21κ=1[dκf(netκ)]2=21κ=1[dκf(j=0mωjκyj)]2

    进一步展开至输入层,有
    E = 1 2 ∑ κ = 1 ℓ d κ − f [ ∑ j = 0 m ω j κ f ( n e t j ) ] 2 = 1 2 ∑ κ = 1 ℓ d κ − f [ ∑ j = 0 m ω j κ f ( ∑ j = 0 n υ i j χ i ) ] 2 E={1\over 2}∑_{κ=1}^ℓ{d_κ−f[∑_{j=0}^mω_{jκ}f(net_j)]}^2={1\over 2}∑_{κ=1}^ℓ{d_κ−f[∑_{j=0}^mω_{jκ}f(∑_{j=0}^nυ_{ij}χ_i)]}^2 E=21κ=1dκf[j=0mωjκf(netj)]2=21κ=1dκf[j=0mωjκf(j=0nυijχi)]2

    由上式可以看出,网络输入误差是各层权值 ω j κ ω_{jκ} ωjκ υ i j υ_{ij} υij的函数,因此调整权值可改变误差 E E E。 显然,调整权值的原则是使误差不断减小,因此应使权值与误差的梯度下降成正比,即
    Δ ω j κ = − η ∂ E ∂ ω j κ j = 0 , 1 , 2 , … , m ; κ = 1 , 2 , … , ℓ Δω_{jκ}=−η{∂E\over ∂ω_{jκ}}j=0,1,2,…,m;κ=1,2,…,ℓ Δωjκ=ηωjκEj=0,1,2,,m;κ=1,2,,

    Δ υ i j = − η ∂ E ∂ υ i j i = 0 , 1 , 2 , … , n ; j = 1 , 2 , … , m Δυ_{ij}=−η{∂E∂\over υ_{ij}}i=0,1,2,…,n;j=1,2,…,m Δυij=ηυijEi=0,1,2,,n;j=1,2,,m

    对于一般多层感知器,设共有 h h h 个隐层,按前向顺序各隐层节点数分别记为 m 1 , m 2 , … , m h m_1,m_2,…,m_h m1,m2,,mh,各隐层输出分别记为 y 1 , y 2 , … , y h y_1,y_2,…,y_h y1,y2,,yh,各层权值矩阵分别记为 W 1 , W 2 , … , W h , W h + 1 W_1,W_2,…,W_h,W_{h+1} W1,W2,,Wh,Wh+1,则各层权值调整公式为

    输出层

    Δ ω j κ h + 1 = η δ h + 1 κ y j h = η ( d κ − o κ ) o κ ( 1 − o κ ) y j κ ( j=0,1,2, … ,mh;κ=1,2, … ,ℓ ) Δω^{h+1}_{jκ}=ηδ_{h+1}^κy^h_j=η(d_κ−o_κ)o_κ(1−o_κ)y^κ_j\tag{j=0,1,2,…,mh;κ=1,2,…,ℓ} Δωjκh+1=ηδh+1κyjh=η(dκoκ)oκ(1oκ)yjκ(j=0,1,2,,mh;κ=1,2,,)

    h h h 隐层

    Δ ω i j h = η δ j h y i h − 1 = η ( ∑ κ = 1 l δ κ o ω j κ h + 1 y j κ ( 1 − y j k a p p a ) y i h − 1 ( i=0,1,2, … ,m(h−1);j=1,2, … , m h ) Δω^h_{ij}=ηδ^h_jy^h_i−1=η(∑^l_{κ=1}δ^o_κω^{h+1}_{jκ}y^κ_j(1−y^k_jappa)y^h_i−1\tag{i=0,1,2,…,m(h−1);j=1,2,…,$m_h$} Δωijh=ηδjhyih1=η(κ=1lδκoωjκh+1yjκ(1yjkappa)yih1(i=0,1,2,,m(h1);j=1,2,,mh)

    按以上规律逐层类推,则第一隐层权值调整公式

    Δ ω p q 1 = η δ q 1 χ p = η ( ∑ r = 1 m 2 δ r 2 ω q r 2 ) y q 1 ( 1 − y q 1 ) χ p ( p=0,1,2, … ,n;j=1,2, … , m 1 ) Δω^1_{pq}=ηδ^1_qχ_p=η(∑^{m_2}_{r=1}δ^2_rω^2_{qr})y^1_q(1−y^1_q)χ_p\tag{p=0,1,2,…,n;j=1,2,…,$m_1$} Δωpq1=ηδq1χp=η(r=1m2δr2ωqr2)yq1(1yq1)χp(p=0,1,2,,n;j=1,2,,m1)

    容易看出,BP学习算法中,各层权值调整公式形式上都是一样的,均由3个因素决定,即:

    1. 学习率 η η η
    2. 本层输出的误差信号 δ δ δ
    3. 本层输入信号 Y Y Y(或 X X X

    其中输入层误差信号与网络的期望输出与实际输出之差有关,直接反应了输出误差,而各隐层的误差信号与前面各层的误差信号有关,是从输出层开始逐层反传过来的。

    可以看出BP算法属于δ学习规则类,这类算法常被称为误差的梯度下降算法。δ学习规则可以看成是Widrow-Hoff(LMS)学习规则的一般化(generalize)情况。LMS学习规则与神经元采用的变换函数无关,因而不需要对变换函数求导,δ学习规则则没有这个性质,要求变换函数可导。这就是为什么我们前面采用Sigmoid函数的原因。

    综上所述,BP三要素如下图所示。

    在这里插入图片描述

    下面我们会介绍BP网络的学习训练的具体过程。

    BP网络的训练分解

    训练一个BP神经网络,实际上就是调整网络的权重和偏置这两个参数,BP神经网络的训练过程分两部分:

    • 前向传输,逐层波浪式的传递输出值;
    • 逆向反馈,反向逐层调整权重和偏置;
      我们先来看前向传输。

    前向传输(Feed-Forward前向反馈)

    在训练网络之前,我们需要随机初始化权重和偏置,对每一个权重取 [ − 1 , 1 ] [-1,1] [1,1]的一个随机实数,每一个偏置取 [ 0 , 1 ] [0,1] [0,1]的一个随机实数,之后就开始进行前向传输。

    神经网络的训练是由多趟迭代完成的,每一趟迭代都使用训练集的所有记录,而每一次训练网络只使用一条记录,抽象的描述如下:

    while 终止条件未满足:
        for record:dataset:
            trainModel(record)
    

    首先设置输入层的输出值,假设属性的个数为100,那我们就设置输入层的神经单元个数为100,输入层的结点 N i N_i Ni为记录第 i i i维上的属性值 x i x_i xi。对输入层的操作就这么简单,之后的每层就要复杂一些了,除输入层外,其他各层的输入值是上一层输入值按权重累加的结果值加上偏置,每个结点的输出值等该结点的输入值作变换
    这里写图片描述
    前向传输的输出层的计算过程公式如下:
    I j = ∑ i = 1 ω i j o i + θ j I_j=\sum_{i=1}\omega_{ij}o_i+\theta_j Ij=i=1ωijoi+θj
    o j = f ( I j ) = 1 1 + e I j o_j=f(I_j)={1\over 1+e^{I_j}} oj=f(Ij)=1+eIj1
    对隐藏层和输出层的每一个结点都按照如上图的方式计算输出值,就完成前向传播的过程,紧接着是进行逆向反馈。

    逆向反馈(Backpropagation)

    逆向反馈从最后一层即输出层开始,我们训练神经网络作分类的目的往往是希望最后一层的输出能够描述数据记录的类别,比如对于一个二分类的问题,我们常常用两个神经单元作为输出层,如果输出层的第一个神经单元的输出值比第二个神经单元大,我们认为这个数据记录属于第一类,否则属于第二类。

    还记得我们第一次前向反馈时,整个网络的权重和偏置都是我们随机取,因此网络的输出肯定还不能描述记录的类别,因此需要调整网络的参数,即权重值和偏置值,而调整的依据就是网络的输出层的输出值与类别之间的差异,通过调整参数来缩小这个差异,这就是神经网络的优化目标。对于输出层:
    E j = O j ( 1 − O j ) ( T j − O j ) E_j=O_j(1-O_j)(T_j-O_j) Ej=Oj(1Oj)(TjOj)
    其中 E j E_j Ej表示第 j j j个结点的误差值, O j O_j Oj表示第 j j j个结点的输出值, T j T_j Tj记录输出值,比如对于2分类问题,我们用01表示类标1,10表示类别2,如果一个记录属于类别1,那么其 T 1 = 0 T_1=0 T1=0 T 2 = 1 T_2=1 T2=1

    中间的隐藏层并不直接与数据记录的类别打交道,而是通过下一层的所有结点误差按权重累加,计算公式如下:
    E j = O j ( 1 − O j ) ∑ k E k W j k E_j=O_j(1-O_j)\sum_kE_kW_{jk} Ej=Oj(1Oj)kEkWjk
    其中 W j k W_{jk} Wjk表示当前层的结点 j j j到下一层的结点 k k k的权重值, E k E_k Ek下一层的结点 k k k的误差率。

    计算完误差率后,就可以利用误差率对权重和偏置进行更新,首先看权重的更新:
    这里写图片描述
    其中 λ λ λ表示表示学习速率,取值为0到1,学习速率设置得大,训练收敛更快,但容易陷入局部最优解,学习速率设置得比较小的话,收敛速度较慢,但能一步步逼近全局最优解。

    更新完权重后,还有最后一项参数需要更新,即偏置:
    这里写图片描述

    至此,我们完成了一次神经网络的训练过程,通过不断的使用所有数据记录进行训练,从而得到一个分类模型。不断地迭代,不可能无休止的下去,总归有个终止条件。

    训练终止条件

    每一轮训练都使用数据集的所有记录,但什么时候停止,停止条件有下面两种:

    1. 设置最大迭代次数,比如使用数据集迭代100次后停止训练
    2. 计算训练集在网络上的预测准确率,达到一定门限值后停止训练

    BP网络运行的具体流程

    网络结构

    输入层有 n n n个神经元,隐含层有 p p p个神经元,输出层有 q q q个神经元。

    变量定义

    输入变量: x = ( x 1 , x 2 , … , x n ) x=(x_1,x_2,\dots,x_n) x=(x1,x2,,xn)
    隐含层输入变量: h i = ( h i 1 , h i 2 , … , h i p ) hi=(hi_1,hi_2,\dots,hi_p) hi=(hi1,hi2,,hip)
    隐含层输出变量: h o = ( h o 1 , h o 2 , … , h o p ) ho=(ho_1,ho_2,\dots,ho_p) ho=(ho1,ho2,,hop)
    输出层输入变量: y i = ( y i 1 , y i 2 , … , y i q ) yi=(yi_1,yi_2,\dots,yi_q) yi=(yi1,yi2,,yiq)
    输出层输出变量: y o = ( y o 1 , y o 2 , … , y o q ) yo=(yo_1,yo_2,\dots,yo_q) yo=(yo1,yo2,,yoq)
    期望输出向量: d o = ( d 1 , d 2 , … , d q ) d_o=(d_1,d_2,\dots,d_q) do=(d1,d2,,dq)
    输入层与中间层的连接权值: w i h w_{ih} wih
    隐含层与输出层的连接权值: w h o w_{ho} who
    隐含层各神经元的阈值: b h b_h bh
    输出层各神经元的阈值: b o b_o bo
    样本数据个数: k = 1 , 2 , … , m k=1,2,\dots,m k=1,2,,m
    激活函数: f ( ⋅ ) f(\cdot) f()
    误差函数: e = 1 2 ∑ o = 1 q ( d o ( k ) − y o o ( k ) ) 2 e={1\over 2}\sum_{o=1}^{q}(d_o(k)-yo_o(k))^2 e=21o=1q(do(k)yoo(k))2
    ###第一步:网络初始化
    给各连接权值分别赋一个区间 ( − 1 , 1 ) (-1,1) (1,1)内的随机数,设定误差函数 e e e,给定计算精度值 ε \varepsilon ε和最大学习次数 M M M
    ###第二步:随机选取
    随机选取第 k k k个输入样本以及对应的期望输出
    x ( k ) = ( x 1 ( k ) , x 2 ( k ) , … , x n ( k ) ) d o ( k ) = ( d 1 ( k ) , d 2 ( k ) , … , d q ( k ) ) x(k)=(x_1(k),x_2(k),\dots,x_n(k))\\ d_o(k)=(d_1(k),d_2(k),\dots,d_q(k)) x(k)=(x1(k),x2(k),,xn(k))do(k)=(d1(k),d2(k),,dq(k))
    ###第三部:隐含层计算
    计算隐含层各神经元的输入和输出
    h i h ( k ) = ∑ i = 1 n w i h x i ( k ) − b h ( h = 1 , 2 , … , p ) hi_h(k)=\sum_{i=1}^nw_{ih}x_i(k)-b_h \tag{$h=1,2,\dots,p$} hih(k)=i=1nwihxi(k)bh(h=1,2,,p)
    h i h ( k ) = f ( h i h ( k ) ) ( h = 1 , 2 , … , p ) hi_h(k)=f(hi_h(k)) \tag{$h=1,2,\dots,p$} hih(k)=f(hih(k))(h=1,2,,p)
    y i o ( k ) = ∑ h = 1 p w h o h o h ( k ) − b o ( o=1,2, …   ,q ) yi_o(k)=\sum_{h=1}^pw_{ho}ho_h(k)-b_o \tag{o=1,2,$\dots$,q} yio(k)=h=1pwhohoh(k)bo(o=1,2,,q)
    y o o ( k ) = f ( y i o ( k ) ) ( o=1,2, …   ,q ) yo_o(k)=f(yi_o(k))\tag{o=1,2,$\dots$,q} yoo(k)=f(yio(k))(o=1,2,,q)

    第四步:求偏导数

    利用网络期望输出和实际输出,计算误差函数对输出层的各神经元的偏导数 δ o ( k ) \delta_o(k) δo(k)
    这里写图片描述这里写图片描述

    第六步:修正权值

    利用输出层各神经元的 δ o ( k ) \delta_o(k) δo(k)和隐含层各神经元的输出来修正连接权值 w h o ( k ) w_{ho}(k) who(k)
    这里写图片描述

    第七部:修正权值

    利用隐含层各神经元的 δ h ( k ) \delta_h(k) δh(k)和输入层各神经元的输入修正连接权值。
    这里写图片描述

    第八步:计算全局误差

    E = 1 2 m ∑ k = 1 m ∑ o = 1 q ( d o ( k ) − y o ( k ) ) 2 E={1\over 2m}\sum_{k=1}^m\sum_{o=1}^q(d_o(k)-y_o(k))^2 E=2m1k=1mo=1q(do(k)yo(k))2

    第九步:判断模型合理性

    判断网络误差是否满足要求。
    当误差达到预设精度或者学习次数大于设计的最大次数,则结束算法。
    否则,选取下一个学习样本以及对应的输出期望,返回第三部,进入下一轮学习。

    BP网络的设计

    在进行BP网络的设计是,一般应从网络的层数、每层中的神经元个数和激活函数、初始值以及学习速率等几个方面来进行考虑,下面是一些选取的原则。

    1.网络的层数

    理论已经证明,具有偏差和至少一个S型隐层加上一个线性输出层的网络,能够逼近任何有理函数,增加层数可以进一步降低误差,提高精度,但同时也是网络 复杂化。另外不能用仅具有非线性激活函数的单层网络来解决问题,因为能用单层网络解决的问题,用自适应线性网络也一定能解决,而且自适应线性网络的 运算速度更快,而对于只能用非线性函数解决的问题,单层精度又不够高,也只有增加层数才能达到期望的结果。

    2.隐层神经元的个数

    网络训练精度的提高,可以通过采用一个隐含层,而增加其神经元个数的方法来获得,这在结构实现上要比增加网络层数简单得多。一般而言,我们用精度和 训练网络的时间来恒量一个神经网络设计的好坏:
    (1)神经元数太少时,网络不能很好的学习,训练迭代的次数也比较多,训练精度也不高。
    (2)神经元数太多时,网络的功能越强大,精确度也更高,训练迭代的次数也大,可能会出现过拟合(over fitting)现象。
    由此,我们得到神经网络隐层神经元个数的选取原则是:在能够解决问题的前提下,再加上一两个神经元,以加快误差下降速度即可。

    3.初始权值的选取

    一般初始权值是取值在(−1,1)之间的随机数。另外威得罗等人在分析了两层网络是如何对一个函数进行训练后,提出选择初始权值量级为s√r的策略, 其中r为输入个数,s为第一层神经元个数。

    4.学习速率

    学习速率一般选取为0.01−0.8,大的学习速率可能导致系统的不稳定,但小的学习速率导致收敛太慢,需要较长的训练时间。对于较复杂的网络, 在误差曲面的不同位置可能需要不同的学习速率,为了减少寻找学习速率的训练次数及时间,比较合适的方法是采用变化的自适应学习速率,使网络在 不同的阶段设置不同大小的学习速率。

    5.期望误差的选取

    在设计网络的过程中,期望误差值也应当通过对比训练后确定一个合适的值,这个合适的值是相对于所需要的隐层节点数来确定的。一般情况下,可以同时对两个不同 的期望误差值的网络进行训练,最后通过综合因素来确定其中一个网络。

    BP网络的局限性

    BP网络具有以下的几个问题:

    • (1)需要较长的训练时间:这主要是由于学习速率太小所造成的,可采用变化的或自适应的学习速率来加以改进。
    • (2)完全不能训练:这主要表现在网络的麻痹上,通常为了避免这种情况的产生,一是选取较小的初始权值,而是采用较小的学习速率。
    • (3)局部最小值:这里采用的梯度下降法可能收敛到局部最小值,采用多层网络或较多的神经元,有可能得到更好的结果。
      BP网络的改进

    P算法改进的主要目标是加快训练速度,避免陷入局部极小值等,常见的改进方法有带动量因子算法、自适应学习速率、变化的学习速率以及作用函数后缩法等。 动量因子法的基本思想是在反向传播的基础上,在每一个权值的变化上加上一项正比于前次权值变化的值,并根据反向传播法来产生新的权值变化。而自适应学习 速率的方法则是针对一些特定的问题的。改变学习速率的方法的原则是,若连续几次迭代中,若目标函数对某个权倒数的符号相同,则这个权的学习速率增加, 反之若符号相反则减小它的学习速率。而作用函数后缩法则是将作用函数进行平移,即加上一个常数。

    BP网络实现

    由于BP网络具有出色的非线性映射能力、泛化能力和容错能力,因此BP网络成了至今为止应用最广泛的人工神经网络。下图是Matlab下用BP网络做线性拟合的结果,效果很好。
    这里写图片描述

    % BP网络函数逼近实例
    % 1.首先定义正弦函数,采样率为20Hz,频率为1Hz
    k = 1; % 设定正弦信号频率
    p = [0:0.05:4];
    t = cos(k*pi*p) + 3*sin(pi*p);
    plot(p, t, '-'), xlabel('时间'); ylabel('输入信号');
    % 2.生成BP网络。用newff函数生成前向型BP网络,设定隐层中神经元数目为10
    % 分别选择隐层的传递函数为 tansig,输出层的传递函数为 purelin,
    % 学习算法为trainlm。
    net =
    newff(minmax(p),[10,10,1],{'tansig','tansig','purelin'},'trainlm');
    % 3.对生成的网络进行仿真并做图显示。
    y1 = sim(net,p); plot(p, t, '-', p, y1, '--')
    % 4.训练。对网络进行训练,设定训练误差目标为 1e-5,最大迭代次数为300,
    % 学习速率为0.05。
    net.trainParam.lr=0.05;
    net.trainParam.epochs=1000;
    net.trainParam.goal=1e-5;
    [net,tr]=train(net,p,t);
    %5.再次对生成的网络进行仿真并做图显示。
    y2 = sim(net,p);
    plot(p, t, '-', p, y2, '--')
    

    这是用C语言写的:用BP神经网络拟合函数: Y = s i n ( X ) Y=sin(X) Y=sin(X)

    #include "math.h"
    #include "time.h"
    #include "stdio.h"
    #include "stdlib.h"
    #include "ctype.h"
    #define Ni 1
    #define Nm 4
    #define No 1
    #define L 100
    #define Enom 0.02
    #define loopmax 100000
    #define e 2.71828
    double E;
    double a,u,n;
    double W1[Ni][Nm],D1[Ni][Nm],W2[Nm][No],D2[Nm][No];
    double D22[Nm][No],D11[Ni][No];
    double a1[Ni][Nm],a2[Nm][No];
    double Pi[L][Ni],Pm[L][Nm],Po[L][No],T[L][No];
    double Xm[L][Nm],Xo[L][No];
    double Qm[L][Nm],Qo[L][No];
    void proceed();
    void proceedR();
    void forQ();
    void amend();
    void initiate();
    double newa(double a,double D);
    double cal(double d);
    double vcal(double d);
    main()
    {
        long int i;
    	int flag;
    	char choice;
        for(;;)
    	{
    		flag=0;
    		initiate();
    		for(i=0;;i++)
    		{
    			proceed();
    			if( E < Enom )
    			{ 
    				flag=1;
    				break;
    			}
    			if( i >= loopmax)
    			{
    				flag = -1;
    				break;
    			}
    			if(i%2500==0)
    				printf("第%10d轮误差:%20f,学习速率:%10f\n",i,E,a1[0][0]);
    			forQ();
    			amend();
    		}
    		if(flag>0)proceedR();
    		else printf("训练失败!\n");
    		for(;;)
    		{
    			choice=getchar();
    			printf("是否继续?(Y/N)\n");
    			choice=getchar();
    			choice=toupper(choice);
    			if(choice=='Y')break;
    			if(choice=='N')exit(0);
    		}
    	}
    }
    void initiate()
    {
    	int i,j;
    	int random;
    	double x;
    	double step;
    	int stime;	
    	long ltime;
    	ltime=time(NULL);
    	stime=(unsigned)ltime/2;
    	srand(stime);
    	a=0.02;
    	u=1;
        n=1;
    	printf("本程序将用BP神经网络拟合函数:Y=sin(X)\n\n");
    	for( i=0; i<Nm; i++)
    	{
    		for( j=0; j<Ni; j++)
    		{
    			random=rand()%100-50;
    			x=random;
    			x=x/100;
    			W1[j][i]=x;
    			D11[j][i]=0;
    			D1[j][i]=0;
    			a1[j][i]=0.01;
    		}
    		for( j=0; j<No; j++)
    		{
    			random=rand()%100-50;
    			x=random;
    			x=x/100;
    			W2[i][j]=x;
    			D22[i][j]=0;
    			D2[i][j]=0;
    			a2[i][j]=0.01;
    		}
    	}
        step=1.0/L;
    	for(i=0;i<L;i++)
    	{
    		x=i;
    		Pi[i][0]=x*step;
    		T[i][0]=sin(Pi[i][0]);
    	}
    	printf("初始化成功!\n\n下面将对神经网络进行训练请稍候。\n");
    }
    void proceed()
    {
    	int i, j, k;
    	E=0 ;
    	for( i=0; i<L; i++ )
    	{
    		for( j=0; j<Nm; j++ )
    		{
    			Pm[i][j] = 0;
    			for( k=0; k<Ni; k++ )
    			{
    				Pm[i][j] = Pi[i][k] * W1[k][j] + Pm[i][j];
    			}
    			Xm[i][j] = cal( Pm[i][j] );
    		}
    		for( j=0; j<No; j++)
    		{
    			Po[i][j] = 0;
    			for( k=0; k<Nm; k++)
    			{
    				Po[i][j] = Xm[i][k] * W2[k][j] + Po[i][j];
    			}
    			Xo[i][j] = cal( Po[i][j] );
    		    E = E + ( Xo[i][j] - T[i][j] ) * ( Xo[i][j] - T[i][j] ) / 2;
    		}
    	}
    }
    void forQ()
    {
    	int i,j,k;
    	for( i=0; i<L; i++ )
    	{
    		for( j=0; j<No; j++)
    		{
    			Qo[i][j] = ( T[i][j] - Xo[i][j] )* vcal( Xo[i][j] );
    		}
    		for(j=0; j<Nm; j++)
    		{
    			Qm[i][j]=0;
    			for( k=0; k<No; k++)
    			{
    				Qm[i][j] = Qo[i][k] * W2[j][k] + Qm[i][j];
    			}
    			Qm[i][j] = Qm[i][j] * vcal( Xm[i][j] );
    		}
    	}
    }
    void amend()
    {
    	int i,j,k;
    	double D;
    	for( i=0; i<Nm; i++)
    	{
    		for( j=0; j<Ni; j++)
    		{
    			D1[j][i]=0;
    		}
    		for( j=0; j<No; j++)
    		{
    			D2[i][j]=0;
    		}
    	}
    	for( i=0; i<Ni; i++)
    	{
    		for( j=0; j<Nm; j++)
    		{
    			for( k=0; k<L; k++)
    			{
    				D1[i][j] = Qm[k][j] * Pi[k][i] + D1[i][j];
    			}
                 D = D1[i][j] * D11[i][j]  ;//为D11付初值
    			 a1[i][j] = newa( a1[i][j] , D );  // a 付初值
    			 W1[i][j] = W1[i][j] + a1[i][j] * ( n * D1[i][j] + ( 1 - n ) * D11[i][j] );
    			 D11[i][j] = D1[i][j];
    		}
    	}
        for( i=0; i<Nm; i++)
    	{
    		for( j=0; j<No; j++)
    		{
    			for( k=0; k<L; k++)
    			{
    				D2[i][j] = Qo[k][j] * Xm[k][i] + D2[i][j];
    			}
    			D = D2[i][j] * D22[i][j]  ;//为D11付初值
                a2[i][j] = newa( a2[i][j] , D ); 
    			W2[i][j] = W2[i][j] + a2[i][j] * ( n * D2[i][j] + ( 1 - n ) * D22[i][j] );
    			D22[i][j] = D2[i][j];
    		}
    	}
    }
     void proceedR()
    {
    	int i, j;
    	float x;
    	double input,output;
    	char choice;
    	for(;;)
    	{
    		for(;;)
    		{
    			printf("在此输入需要计算的值(0,1):\n");
    			scanf("%f",&x);
    			input=(double)x;
    			if((input>=0)&(input<=1))break;			
    			printf("注意输入值应介于0、1之间!\n");
    			for(;;)
    			{
    				choice=getchar();
    				printf("是否继续?(Y/N)\n");
    				choice=getchar();
    				choice=toupper(choice);
    				if(choice=='Y')break;
    				if(choice=='N')exit(0);			
    			}
    		}
    		for(i=0;i<Nm;i++)
    		{
    			Pm[0][i]=0;
    			for( j=0; j<Ni; j++ )
    			{
    				Pm[0][i] =  input* W1[j][i]+Pm[0][i] ;
    			}
    			Xm[0][i] = cal( Pm[0][i] );
    		}
    		for( i=0; i<No; i++)
    		{
    			Po[0][i] = 0;
    			for( j=0; j<Nm; j++)
    			{
    				Po[0][i] = Xm[0][j] * W2[j][i]+Po[0][i];
    			}
    		}
    		output=cal( Po[0][0] );
    		printf("输入值为%20f对应的结果为%f\n",input,output);
    		printf("输入值为%20f对应的正常结果为%f\n",input,sin(input));
    		for(;;)
    		{
    			choice=getchar();
    			printf("是否继续?(Y/N)\n");
    			choice=getchar();
    			choice=toupper(choice);
    			if(choice=='Y')break;
    			if(choice=='N')exit(0);			
    		}
    	}
    }
    
    double newa(double a, double D)
    {
    	if( D > 0 )
    	{
    		{
    			if(a<=0.04)
    				a = a * 2;
    			else a=0.08;
    		}
    	}
    	else
    		if ( D < 0)
    		{
    			if(a>=0.02)
    			{
    				a = a / 2;
    			}
    			else a=0.01;
    		}
    	return a;
    }
    double cal(double d)
    {
    	d =  - (d * u);                                //              chushihua 
    	d = exp( d );
    	d = 1 / ( 1 + d );
    	return d;
    }
    double vcal(double d)
    {
    	return u * d * ( 1 - d );
    }
    
    
    
    展开全文
  • 【Matlab学习手记】BP神经网络数据预测

    万次阅读 多人点赞 2018-08-11 09:50:55
    目的:利用BP神经网络进行数据预测。 原理 代码 clear; clc; TestSamNum = 20; % 学习样本数量 ForcastSamNum = 2; % 预测样本数量 HiddenUnitNum=8; % 隐含层 InDim = 3; % 输入层 OutDi...

    2021-6-25 新增 github 源码链接

    https://github.com/AFei19911012/MatlabSamples/tree/master/MachineLearning/BP

    目的:利用BP神经网络进行数据预测。

    数据滚动预测(用之前数据预测未来数据)参考:

    https://blog.csdn.net/u012366767/article/details/90021289

    • 原理

    • 代码
    clear; clc;
    TestSamNum = 20;             % 学习样本数量
    ForcastSamNum = 2;           % 预测样本数量
    HiddenUnitNum=8;             % 隐含层
    InDim = 3;                   % 输入层
    OutDim = 2;                  % 输出层
    % 原始数据 
    % 人数(单位:万人)
    sqrs = [20.55 22.44 25.37 27.13 29.45 30.10 30.96 34.06 36.42 38.09 39.13 39.99 ...
           41.93 44.59 47.30 52.89 55.73 56.76 59.17 60.63];
    % 机动车数(单位:万辆)
    sqjdcs = [0.6 0.75 0.85 0.9 1.05 1.35 1.45 1.6 1.7 1.85 2.15 2.2 2.25 2.35 2.5 2.6...
            2.7 2.85 2.95 3.1];
    % 公路面积(单位:万平方公里)
    sqglmj = [0.09 0.11 0.11 0.14 0.20 0.23 0.23 0.32 0.32 0.34 0.36 0.36 0.38 0.49 ... 
             0.56 0.59 0.59 0.67 0.69 0.79];
    % 公路客运量(单位:万人)
    glkyl = [5126 6217 7730 9145 10460 11387 12353 15750 18304 19836 21024 19490 20433 ...
            22598 25107 33442 36836 40548 42927 43462];
    % 公路货运量(单位:万吨)
    glhyl = [1237 1379 1385 1399 1663 1714 1834 4322 8132 8936 11099 11203 10524 11115 ...
            13320 16762 18673 20724 20803 21804];
    p = [sqrs; sqjdcs; sqglmj];  % 输入数据矩阵
    t = [glkyl; glhyl];          % 目标数据矩阵
    [SamIn, minp, maxp, tn, mint, maxt] = premnmx(p, t);   % 原始样本对(输入和输出)初始化
    SamOut = tn;         % 输出样本
    MaxEpochs = 50000;   % 最大训练次数
    lr = 0.05;           % 学习率
    E0 = 1e-3;           % 目标误差
    rng('default');
    W1 = rand(HiddenUnitNum, InDim);      % 初始化输入层与隐含层之间的权值
    B1 = rand(HiddenUnitNum, 1);          % 初始化输入层与隐含层之间的阈值
    W2 = rand(OutDim, HiddenUnitNum);     % 初始化输出层与隐含层之间的权值              
    B2 = rand(OutDim, 1);                 % 初始化输出层与隐含层之间的阈值
    ErrHistory = zeros(MaxEpochs, 1);     
    for i = 1 : MaxEpochs   
        HiddenOut = logsig(W1*SamIn + repmat(B1, 1, TestSamNum));   % 隐含层网络输出
        NetworkOut = W2*HiddenOut + repmat(B2, 1, TestSamNum);      % 输出层网络输出
        Error = SamOut - NetworkOut;       % 实际输出与网络输出之差
        SSE = sumsqr(Error);               % 能量函数(误差平方和)
        ErrHistory(i) = SSE;
        if SSE < E0
            break;
        end
        % 以下六行是BP网络最核心的程序
        % 权值(阈值)依据能量函数负梯度下降原理所作的每一步动态调整量
        Delta2 = Error;
        Delta1 = W2' * Delta2 .* HiddenOut .* (1 - HiddenOut);    
        dW2 = Delta2 * HiddenOut';
        dB2 = Delta2 * ones(TestSamNum, 1); 
        dW1 = Delta1 * SamIn';
        dB1 = Delta1 * ones(TestSamNum, 1);
        % 对输出层与隐含层之间的权值和阈值进行修正
        W2 = W2 + lr*dW2;
        B2 = B2 + lr*dB2;
        % 对输入层与隐含层之间的权值和阈值进行修正
        W1 = W1 + lr*dW1;
        B1 = B1 + lr*dB1;
    end
    HiddenOut = logsig(W1*SamIn + repmat(B1, 1, TestSamNum));   % 隐含层输出最终结果
    NetworkOut = W2*HiddenOut + repmat(B2, 1, TestSamNum);      % 输出层输出最终结果
    a = postmnmx(NetworkOut, mint, maxt);    % 还原网络输出层的结果
    x = 1990 : 2009;      % 时间轴刻度
    newk = a(1, :);       % 网络输出客运量
    newh = a(2, :);       % 网络输出货运量
    subplot(2, 1, 1);
    plot(x, newk, 'r-o', x, glkyl, 'b--+');
    legend('网络输出客运量', '实际客运量');
    xlabel('年份');
    ylabel('客运量/万人');
    subplot(2, 1, 2);
    plot(x, newh, 'r-o', x, glhyl, 'b--+');
    legend('网络输出货运量', '实际货运量');
    xlabel('年份');
    ylabel('货运量/万吨');
    % 利用训练好的网络进行预测
    pnew=[73.39 75.55
          3.9635 4.0975
          0.9880 1.0268];  % 2010年和2011年的相关数据;
    pnewn = tramnmx(pnew, minp, maxp); 
    HiddenOut = logsig(W1*pnewn + repmat(B1, 1, ForcastSamNum));  % 隐含层输出预测结果
    anewn = W2*HiddenOut + repmat(B2, 1, ForcastSamNum);          % 输出层输出预测结果
    anew = postmnmx(anewn, mint, maxt);
    disp('预测值d:');
    disp(anew);
    

    展开全文
  • python3_实现BP神经网络 + BP神经网络应用实例

    万次阅读 多人点赞 2018-07-29 22:10:28
    1.BP神经网络简介 BP神经网络是1986年由Rumelhart和McClelland为首的科学家提出的概念,是一种按照逆向传播...从结构上讲,BP神经网络具有输入层、隐含层和输出层;从本质上讲,BP算法就是以网络误差平方目标函数...

    0.目录

    1.BP神经网络简介

    2.前期理论准备

    2.算法数学原理

    (一)符号说明

    (二)公式推导

    3.python实现(python3编程实现)

    (一)sigmoid函数

    (二)BP主函数实现

    4.数据格式

    1.BP神经网络简介

    BP神经网络是1986年由Rumelhart和McClelland为首的科学家提出的概念,是一种按照逆向传播算法训练的多层前馈神经网络,是目前应用最广泛的神经网络。

    目录

    0.目录

    1.BP神经网络简介

    2.前期理论准备

    2.算法数学原理

    (一)符号说明

    (二)公式推导

    3.python实现(python3编程实现)

    (一)sigmoid函数

    (二)BP主函数实现

    4.数据格式


    优点

    • 1.具有任意复杂的模式分类能力和优良的多维函数映射能力,解决了简单感知器不能解决的异或问题的问题(参考博客:https://www.jianshu.com/p/a25788130897 或 https://www.cnblogs.com/xym4869/p/11282469.html
    • 2.从结构上讲,BP神经网络具有输入层、隐含层和输出层
    • 3.从本质上讲,BP算法就是以网络误差平方目标函数、采用梯度下降法来计算目标函数的最小值。基本BP算法包括信号的前向传播误差的反向传播两个过程。

    缺点

    • 1.学习速度慢,即使是一个简单的过程,也需要几百次甚至上千次的学习才能收敛。
    • 2.容易陷入局部极小值
    • 3.网络层数、神经元个数的选择没有相应的理论指导
    • 4.网络推广能力有限。

    应用

    • 1.函数逼近
    • 2.模式识别
    • 3.分类
    • 4.数据压缩

    2.前期理论准备

    网络训练的目标:找到合适的权值和阈值,使得误差E最小。

    sigmoid函数:在信息科学当中,由于其单增以及其反函数单增等性质,sigmoid函数常被用作神经网络的阈值函数,将变量映射当0和1之间。(该函数的对x的求导也应该理解)

    2.算法数学原理

    (一)符号说明

    Xi: 输入信号。

    Xd: 隐层的阈值(是从求和函数中-θ中分离出的-1)。

    Vih: 第h个隐层神经元所对应输入信号Xi的权值。

    αh: 第h个隐层神经元的输入。

    -γh=--1*γh:隐层神经元的阈值。

    bh: 第h个隐层神经元的输入。

    ωhj: 第j个输出层神经元所对应的隐层神经元输出bh的权值。

    -θj=-1*θj:  输出层神经元的阈值(bq)

    :第j个输出层神经元的输出(预测输出值,yj为真实值)

    (二)公式推导

    通过公式变换可得输出层权值与阈值的变化量:

    同理可得隐层权值和阈值的变化量:

    3.python实现(python3编程实现)

    (一)sigmoid函数

    def sigmoid(x):
        """
        隐含层和输出层对应的函数法则
        """
        return 1/(1+np.exp(-x))
    

    (二)BP主函数实现

    def BP(data_tr, data_te, maxiter=600):
    
        # --pandas是基于numpy设计的,效率略低
        # 为提高处理效率,转换为数组
        data_tr, data_te = np.array(data_tr), np.array(data_te)
    
        # --隐层输入
        # -1: 代表的是隐层的阈值
        net_in = np.array([0.0, 0, -1])
        w_mid = np.random.rand(3, 4)          # 隐层权值阈值(-1x其中一个值:阈值)
    
        # 输出层输入
        # -1:代表输出层阈值
        out_in = np.array([0.0, 0, 0, 0, -1])
        w_out = np.random.rand(5)             # 输出层权值阈值(-1x其中一个值:阈值)
        delta_w_out = np.zeros([5])           # 存放输出层权值阈值的逆向计算误差
        delta_w_mid = np.zeros([3, 4])        # 存放因此能权值阈值的逆向计算误差
        yita = 1.75                           # η: 学习速率
        Err = np.zeros([maxiter])             # 记录总体样本每迭代一次的错误率
    
        # 1.样本总体训练的次数
        for it in range(maxiter):
    
            # 衡量每一个样本的误差
            err = np.zeros([len(data_tr)])
    
            # 2.训练集训练一遍
            for j in range(len(data_tr)):
                net_in[:2] = data_tr[j, :2]                       # 存储当前对象前两个属性值
                real = data_tr[j, 2]
    
                # 3.当前对象进行训练
                for i in range(4):
                    out_in[i] = sigmoid(sum(net_in*w_mid[:, i]))  # 计算输出层输入
                res = sigmoid(sum(out_in * w_out))                # 获得训练结果
    
                err[j] = abs(real - res)
    
                # --先调节输出层的权值与阈值
                delta_w_out = yita*res*(1-res)*(real-res)*out_in  # 权值调整
                delta_w_out[4] = -yita*res*(1-res)*(real-res)     # 阈值调整
                w_out = w_out + delta_w_out
    
                # --隐层权值和阈值的调节
                for i in range(4):
                    # 权值调整
                    delta_w_mid[:, i] = yita * out_in[i] * (1 - out_in[i]) * w_out[i] * res * (1 - res) * (real - res) * net_in
                    # 阈值调整
                    delta_w_mid[2, i] = -yita * out_in[i] * (1 - out_in[i]) * w_out[i] * res * (1 - res) * (real - res)
                w_mid = w_mid + delta_w_mid
            Err[it] = err.mean()
        plt.plot(Err)
        plt.show()
    
        # 存储预测误差
        err_te = np.zeros([100])
    
        # 预测样本100个
        for j in range(100):
            net_in[:2] = data_te[j, :2]                         # 存储数据
            real = data_te[j, 2]                                # 真实结果
    
            # net_in和w_mid的相乘过程
            for i in range(4):
                # 输入层到隐层的传输过程
                out_in[i] = sigmoid(sum(net_in*w_mid[:, i]))
            res = sigmoid(sum(out_in*w_out))                    # 网络预测结果输出
            err_te[j] = abs(real-res)                           # 预测误差
            print('res:', res, ' real:', real)
        
        plt.plot(err_te)
        plt.show()
    
    
    
    
    if "__main__" == __name__:
    
        # 1.读取样本
        data_tr = pd.read_csv("5.2 data_tr.txt")
        data_te = pd.read_csv("5.2 data_te.txt")
        BP(data_tr, data_te, maxiter=600)

    4.数据格式

    训练集、测试集下载链接见置顶评论:

    https://download.csdn.net/download/admin_maxin/19844122

    展开全文
  • 详解BP神经网络

    万次阅读 多人点赞 2018-05-06 11:30:41
      BP神经网络学习算法可以说是目前最成功的神经网络学习算法。显示任务中使用神经网络时,大多数是使用BP算法进行训练.   在我看来BP神经网络就是一个”万能的模型+误差修正函数“,每次根据训练得到的结果与...
  • BP神经网络matlab代码讲解与实现步骤

    万次阅读 多人点赞 2020-04-02 01:39:51
    BP神经网络的简介和结构参数1.1 BP神经网络的结构组成1.2 BP神经网络训练界面的参数解读2. 实现BP网络的步骤3. matlab代码编写4. BP代码运行结果4.1 预测值和真实值的误差计算(MAE、MSE、MRSE)4.2 BP网络训练的...
  • BP神经网络数据分类

    万次阅读 2018-11-06 22:17:38
    一、BP神经网络概述 BP神经网络是一种多层前馈神经网络,该网络的主要特点是信号前向传递,误差反向传播。在前向传播的过程中,输入信号从输入层经隐含层处理,直至输出层。每一层的神经元状态只影响下一层神经元...
  • 研究了BP网络输入数据的归一化方法 ,提出了一...在此基础上 , 建立了用于机械故障诊断的三层 BP神经网 络模型 ,编写了基于 BP神经网络的故障诊断软件 , 并在实际的齿轮箱状态监测与故障诊断研究 中得到 了 工程应用 。
  • BP神经网络用于数据分类,基于语音特征信号分类的示例。语音识别的运算过程为:首先,待识别语音转化为电信号后输入识别系统,经过预处理后 用数学方法提取语音特征信号,提取出的语音特征信号可以看成该段语音的...
  • 基于Matlab平台的BP神经网络进行数据拟合 ...本次所采用的神经网络为BP神经网络,是一个误差反向传播训练(Error Back Propagation Training)的多层前馈网络,主要包含输入层、隐含层和输出层。数
  • BP神经网络Matlab实例BP神经网络Matlab实例BP神经网络Matlab实例BP神经网络Matlab实例BP神经网络Matlab实例BP神经网络Matlab实例BP神经网络Matlab实例
  • BP神经网络是一种多层前馈神经网络,该网络的主要特点是信号前向传递,误差反向传播。在前向传递中,输入信号从输入层经隐含层逐层处理,直至输出层. 每一层的神经元状态只影响下一层神经元状态。如果输出层得不到...
  • Matlab搭建BP神经网络实现数据预测

    千次阅读 2020-05-27 22:26:32
    Matlab搭建bp神经网络实现数据预测写自定义目录标题BP神经网络介绍matlab程序实现运行结果总结 BP神经网络介绍 BP(back propagation)神经网络是1986年由Rumelhart和McClelland为首的科学家提出的概念,是一种按照...
  • C++版本的Bp神经网络,工程代码双击直接运行。可用于数据拟合、数据预测,N维输入,1输出。
  • 基于BP神经网络数据分类

    万次阅读 2016-10-27 20:19:37
    转自:基于BP神经网络数据分类,保存在此以学习。  BP(Back Propagation)网络是1986年由Rumelhart和McCelland为首的科学家小组提出,是一种按误差逆传播算法训练的多层前馈网络,是目前应用最广泛的神经网络...
  • BP神经网络拟合数据及调优

    万次阅读 2015-12-03 00:36:34
    BP神经网络数据拟合,逐步调优,得到期望输出,并分析如何过渡到深度学习
  • matlab中我们如何讲n*36 的MFCC系数做为BP神经网络输入数据,因为单个数据应该以一行36个特征做为输入数据,那我在进行mfcc运算时得到的是n乘36的矩阵。求解如何解决这样的问题
  • 基于蝙蝠算法优化BP神经网络数据分类算法及其MATLAB实现-附代码 文章目录基于蝙蝠算法优化BP神经网络数据分类算法及其MATLAB实现-附...BP神经网络通过自身的训练,在训练过程中调整参数,来学习输入数据和输出数
  • BP神经网络预测的算法,内含代码和数据输入7维,输出1维,前面的35组数据进行训练,最后1组数据进行预测,曲线为神经网络的拟合效果。
  • BP神经网络的Matlab实现——人工智能算法

    万次阅读 多人点赞 2018-01-27 23:07:23
    这几天在各大媒体上接触到了人工智能机器学习,觉得很有意思,于是开始入门最简单的机器算法——神经网络训练算法(Neural Network Training);以前一直觉得机器学习很高深,到处是超高等数学、线性代数、数理统计。...
  • BP神经网络概述 BP神经网络是一种按误差逆传播算法训练的多层前馈网络,是目前应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的 输入-输出模式映射关系,而无需事前揭示描述这种映射关系的数学方程。它的...
  • BP神经网络的计算过程由正向计算过程和反向计算过程组成。正向传播过程,输入模式从输入层经隐单元层逐层处理,并转向输出层,每层神经元的状态只影响下一层神经元的状态。如果在输出层不能得到期望的输出,则转入...
  • 最近一段时间在研究如何利用...发现神经网络模型可以来预测,并且有很多是结合时间序列或者SVM(支持向量机)等组合模型来进行预测,本文结合实际数据,选取了常用的BP神经网络算法,其算法原理,因网上一大堆,所以...
  • BP神经网络实现图像识别(BP神经网络实现图像识别,批量输入图像得到识别结果。)
  • matlab建立简单BP神经网络数据分类

    万次阅读 2018-07-27 16:32:09
    BP神经网络是一种多层前馈神经网络,网络信号向前传递,误差反向传播。在已知的神经网络基础上,通过北航出版社开源MATLAB神经网络开源训练和代码库来学习在MATLAB上建立和学习BP神经网络。 %% 该代码为基于BP网络...
  • 多层前馈神经网络bp(back propagation)代码附带数据集,matlab版本
  • 一、最简单的神经网络--Bp神经网络

    万次阅读 多人点赞 2018-09-04 20:44:38
    在之前的文章中,有提到过,所谓的 AI 技术,本质上是一种数据处理处理技术,它的强大来自于两方面:1.互联网的发展带来的海量数据信息 2.计算机深度学习算法的快速发展。 所以说 AI 其实并没有什么神秘,只是在算法...
  • BP神经网络数据预测

    千次阅读 2019-12-01 09:37:28
    BP神经网络是一种多层前馈网络,可以进行学习和存储输入输出映射关系,不需要建立数学方程式。能通过对输入的样本数据的学习训练,获得隐藏在数据内部的规律,并利用学习到的规律来预测未来的数据。 p=[20.55 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,700
精华内容 8,280
关键字:

bp神经网络的输入数据