精华内容
下载资源
问答
  • 为了在保证图像质量的前提...实验结果表明,DR-BP算法相比仅适用于单站式成像的快速傅里叶变换算法,重建图像边缘干扰少,相比传统的反向传播算法,重建速度大幅提升,本文实验中获得的图像质量相同时,重建速度可提升60倍。
  • 三组模拟实验的经验和t检验结果,包括ORL人脸图像数据库上的人脸识别任务以及从机器学习数据库的UCI存储库中抽取的数据集上的四个基准分类任务,表明TP-ES-BP算法取得了显著成效与SBP和最新的情绪反向传播(EmBP)...
  • 误差反向传播学习算法 实现Iris数据分类 Denverg Secret Number 29,April 2018 实验目的 用C++实现BP神经网络 实验原理 人工神经网络模型 人们从40年代开始研究人脑神经元功能。1943年心理学家...

    误差反向传播学习算法

    实现Iris数据分类
    Denverg
    Secret Number
    29,April 2018

    实验目的

    用C++实现BP神经网络

    实验原理

    人工神经网络模型

    人们从40年代开始研究人脑神经元功能。1943年心理学家McCulloch 和 Pitts总结了神经元的一些基本特性,提出了形式神经元的数学描述和结构方法,即M-P神经元模型。
    Alt text
    输入信号通过带权重的连接进行传递,神经元将接收到的总输入值与神经元的阈值进行比较,然后通过”激活函数”(activation function)处理用来产生神经元的输出。
    理想中的激活函数是阶跃函数,但由于阶跃函数不连续不光滑,因此实际常用连续可导的 Sigmoid 函数。
    Alt text
    为将Iris数据集进行分类,需要学习一个具有多层神经元的神经网络。此网络可以是一个四个神经元的输入层,三个神经元的输出层,一层隐层(隐层的神经元本次定义为6)。
    Alt text
    误差反向传播算法
    误差反向传播(Error Backpropagation)学习算法通常被称为BP算法,其基本思想是:如果网络的输出有错,则将网络的权值进行调整,以使得今后网络的输出误差朝最小的方向发展,属于梯度下降算法。
    Alt text
    Alt text
    梯度下降算法
    Alt text
    误差反向传播
    Alt text

    实验内容

    Code Part

    #include "stdafx.h"
    
    #include <stdio.h>
    #include <cstdlib>
    #include <cmath>
    #include <math.h>
    #include <iostream>
    #include <time.h>
    #include <vector>
    #include <fstream>
    #include <string>
    #include <windows.h>
    
    using namespace std;
    
    #define INNODE 4 //input node number
    #define OUTNODE 3 //output kinds
    #define INF 9999999 
    #define MAXNODE 6 //Each layer maximum node number
    #define TRAINSAMPLE 75// half of the Iris sample
    
    //initial weight,bias and execute normalization operation
    void initialValue(vector<vector <double>> &weight1,vector<double> &bias1, vector<vector <double>> &weight2, vector<double> &bias2,int n1,int n2,int n3)
    {
        srand(time(NULL));
    
        for (int i = 0; i < n2; i++)
        {
            for (int j = 0; j < n1; j++)
            {
                weight1[i][j] = rand()/double(RAND_MAX);
            }
        }
        for (int i = 0; i < n3; i++)
        {
            for (int j = 0; j < n2; j++)
            {
                weight2[i][j] = rand() / double(RAND_MAX);
            }
        }
        for (int i = 0; i < n2; i++)
        {
            bias1[i] = rand() / double(RAND_MAX);
        }
        for (int i = 0; i < n3; i++)
        {
            bias2[i] = rand() / double(RAND_MAX);
        }
    }
    
    
    double sigmoid(double z)
    {
        return 1 / (1 + exp(-z));
    }
    
    //calculate the realoutputY
    void computeY(vector<vector <double>> &weight1, vector<double> &bias1, vector<vector <double>> &weight2, vector<double> &bias2, int n1, int n2, int n3, vector<double> &X, vector<double>  &realoutY,vector<double> &hideY)
    {
        //calculate the hidden layer out hideY first
        for (int i = 0; i < n2; i++)
        {   
            double sum = 0;
            for (int j = 0; j < n1; j++)
            {
                sum += weight1[i][j] * X[j];
            }
            sum = sigmoid(sum - bias1[i]);
            hideY[i] = sum;
        }
        //calculate the output layer out realoutY;
    
        for (int i = 0; i < n3; i++)
        {
            double sum = 0;
            for (int j = 0; j < n2; j++)
            {
                sum += weight2[i][j] * hideY[j];
            }
            sum = sigmoid(sum - bias2[i]);
            realoutY[i] = sum;
        }
    }
    
    //calculate the grade of the output layer
    void computeOutputDY(int n3, vector<double> &realoutY, vector<double> Y, vector<double> &outputDweight)
    {
        for (int i = 0; i < n3; i++)
        {
            outputDweight[i] = realoutY[i] * (1 - realoutY[i])*(Y[i] - realoutY[i]);
        }
    }
    
    
    //calculate the grade of the hidden layer
    void computerHideDY(vector<vector<double>> weight2, vector<double> outputDweight, vector<double> hideY,int n2, int n3, vector<double> &HideDweight)
    {
        for (int i = 0; i < n2; i++)
        {
            double sum = 0;
            for (int j = 0; j < n3; j++)
            {
                sum += weight2[j][i] * outputDweight[j];
            }
            HideDweight[i] = sum * hideY[i] * (1 - hideY[i]);
        }
    }
    
    //update weight1,2 and bias1,2
    void updateWeight(vector<vector <double>> &weight1, vector<double> &bias1, vector<vector <double>> &weight2, vector<double> &bias2, int n1, int n2, int n3, vector<double> X, vector<double> &hideY, vector<double> outputDweight, vector<double> hideDweight, double ratio)
    {
        for (int i = 0; i < n1; i++)
        {
            for (int j = 0; j < n2 ; j++)
            {
                weight1[j][i] += ratio * hideDweight[j] * X[i];
            }
        }
        for (int i = 0; i < n2; i++)
        {
            for (int j = 0; j < n3 ; j++)
            {
                weight2[j][i] += ratio * outputDweight[j] * hideY[i];
            }
        }
        for (int i = 0; i < n2; i++)
        {
            bias1[i] -= ratio * hideDweight[i];
        }
        for (int i = 0; i < n3; i++)
        {
            bias2[i] -= ratio * outputDweight[i];
        }
    }
    
    //calculate error of mean square
    double computerError(vector<double> realoutY, vector<double> Y, int n)
    {
        double error = 0.0;
        for (int i = 0; i < n; i++)
        {
            error += (realoutY[i] - Y[i])*(realoutY[i] - Y[i]);
        }
        return error;
    }
    
    //split funcion
    void SplitString(const string& s, vector<string>& v, const string& c)
    {
        string::size_type pos1, pos2;
        pos2 = s.find(c);
        pos1 = 0;
        while (string::npos != pos2)
        {
            v.push_back(s.substr(pos1, pos2 - pos1));
    
            pos1 = pos2 + c.size();
            pos2 = s.find(c, pos1);
        }
        if (pos1 != s.length())
            v.push_back(s.substr(pos1));
    }
    
    int main()
    {
        DWORD strat_time = GetTickCount();
        //the node number of each layer
        int n1 = 4, n2 = 6, n3 = 3;
    
        //weight1[n2][n1] and bias[n2]
        vector<vector<double>> weight1(n2, vector<double>(n1));
        vector<vector<double>> weight2(n3, vector<double>(n2));
        vector<double> bias1(n2);
        vector<double> bias2(n3);
    
        //grade of the layer
        vector<double> outputDweight(n3);
        vector<double> hideDweight(n2);
    
        //the outputY of hidden layer final layer
        vector<vector<double>> realoutY(TRAINSAMPLE, vector<double>(OUTNODE));
        vector<double> hideY(n2);
    
        //X and Y
        vector<vector<double>> X(TRAINSAMPLE, vector<double>(INNODE));
        vector<vector<double>> Y(TRAINSAMPLE, vector<double>(OUTNODE));
    
        //train data
        ifstream myfile("C:\\Users\\Administrator\\Desktop\\test.txt");
        for (int i = 0; i < TRAINSAMPLE; i++)
        {
            string temp;
            getline(myfile, temp);
            vector<string> a;
            SplitString(temp, a, ",");
            for (int j = 0; j <INNODE; j++)
            {
                double dd;
                sscanf_s(a[j].c_str(), "%lf", &dd);
                X[i][j] = dd ;
                if (a[j+1].compare("Iris-setosa")==0)
                {
                    Y[i] = {1,0,0} ;
    
                }
                if (a[j+1].compare("Iris-versicolor") == 0)
                {
                    Y[i] = {0,1,0} ;
    
                }
                if (a[j+1].compare("Iris-virginica") == 0)
                {
                    Y[i] = {0,0,1};
    
                }
            }
    
        }
        myfile.close();
    
        //initialvalue
        initialValue(weight1, bias1, weight2, bias2, n1, n2, n3);
    
        double err = INF;
    
        //stepsizes
        double ratio = 0.5;
    
        //train part
        int count = 0;
        while (err > 0.0005&&count<1000000)
        {
            err = 0.0;
            for (int i = 0; i < TRAINSAMPLE; i++)
            {
                computeY(weight1, bias1, weight2, bias2, n1, n2, n3, X[i], realoutY[i], hideY);
                computeOutputDY(n3, realoutY[i], Y[i], outputDweight);
                computerHideDY(weight2, outputDweight, hideY, n2, n3, hideDweight);
                updateWeight(weight1, bias1, weight2, bias2, n1, n2, n3, X[i], hideY, outputDweight, hideDweight, ratio);
                err += computerError(realoutY[i], Y[i], OUTNODE);
            }
            err = 0.5 * err;
            count++;
        }
    
        cout << "train data part:" << endl;
        //train out part
        for (int i = 0; i < TRAINSAMPLE; i++)
        {
            for (int j = 0; j < OUTNODE; j++)
            {
                cout << "realoutY["<<i<<"]["<<j<<"]::" << realoutY[i][j] << "----" << "Y["<<i<<"]["<<j<<"]::" << Y[i][j] << endl;
            }
            cout << endl;
        }
        cout << "test data part:" << endl;
    
        //test part
        vector<vector<double>> testX(TRAINSAMPLE, vector<double>(INNODE));
        vector<vector<double>> testY(TRAINSAMPLE, vector<double>(OUTNODE));
    
        ifstream myfile1("C:\\Users\\Administrator\\Desktop\\testy.txt");
        for (int i = 0; i < TRAINSAMPLE; i++)
        {
            string temp;
            getline(myfile1, temp);
            vector<string> a;
            SplitString(temp, a, ",");
            for (int j = 0; j <INNODE; j++)
            {
                double dd;
                sscanf_s(a[j].c_str(), "%lf", &dd);
                testX[i][j] = dd;
                if (a[j + 1].compare("Iris-setosa") == 0)
                {
                    Y[i] = { 1,0,0 };
    
                }
                if (a[j + 1].compare("Iris-versicolor") == 0)
                {
                    Y[i] = { 0,1,0 };
    
                }
                if (a[j + 1].compare("Iris-virginica") == 0)
                {
                    Y[j] = { 0,0,1 };
    
                }
            }
        }
        myfile1.close();
    
        for (int i = 0; i < TRAINSAMPLE; i++)
        {
          computeY(weight1, bias1, weight2, bias2, n1, n2, n3, testX[i], testY[i], hideY);
        }
    
        for (int i = 0; i < TRAINSAMPLE; i++)
        {
            double max = -1;
            int index = -1;
            for (int j = 0; j < OUTNODE; j++)
            {
                cout << "testY[" << i << "][" << j << "]::" << testY[i][j] << "---";
                if (max <= testY[i][j])
                {
                    max = testY[i][j];
                    index = j;
                }
            }
            switch (index)
            {
            case 0:
                cout << "Iris-setosa" << endl;
                break;
            case 1:
                cout << "Iris-versicolor" << endl;
                break;
            case 2:
                cout << "Iris-virginica" << endl;
                break;
            default:
                break;
            }
    
        }
        DWORD end_time = GetTickCount();
        cout << "The run time is:" << (end_time - strat_time) / 1000.0 << "s" << endl;
        cout << "compute count:" << count << endl;
        //delete space 
        return 0;
    }

    结果分析

    TEST 1
    使用15个数据集作为训练样本,每个Iris种类各5个,使用15个数据集作为测试。本次偏差设置为0.0005
    Alt text
    Alt text
    测试集与数据集中的分类一致,正确率为100%

    TEST 2
    使用75个数据集作为训练样本,每个Iris种类各25个,使用75个数据集作为测试。本次偏差设置为0.005
    Alt text
    正确率为98.68%

    TEST 3
    使用75个数据集作为训练样本,每个Iris种类各25个,使用75个数据集作为测试。本次偏差设置为0.0005
    Alt text
    Alt text
    正确率为97.37%

    数据图片未上传。

    实验总结

    误差反向传播的正确率的高低部分取决于随机生成的weight和bias,由于每次实验都会生成不同的随机数,固算法很难横向比较。
    但和预期结果相比,正确率能稳定在95%以上,已经是较好的预期结果。
    本次实验未单独写一个独立的矩阵运算类,而是用迭代的方法计算各种中间结果,这样可能可以更好的去理解算法。

    展开全文
  • Iris数据集(https://en.wikipedia.org/wiki/Iris_flower_data_set)是常用的分类实验数据集,由Fisher,1936收集整理。Iris也称鸢尾花卉数据集,是一类多重变量分析的数据集。数据集包含150个数据集,分为3类,每类...

    首先了解下Iris鸢尾花数据集:

    Iris数据集(https://en.wikipedia.org/wiki/Iris_flower_data_set)是常用的分类实验数据集,由Fisher,1936收集整理。Iris也称鸢尾花卉数据集,是一类多重变量分析的数据集。数据集包含150个数据集,分为3类,每类50个数据,每个数据包含4个属性。可通过花萼长度,花萼宽度,花瓣长度,花瓣宽度4个属性预测鸢尾花卉属于(Setosa,Versicolour,Virginica)三个种类中的哪一类。
    iris以鸢尾花的特征作为数据来源,常用在分类操作中。该数据集由3种不同类型的鸢尾花的50个样本数据构成。其中的一个种类与另外两个种类是线性可分离的,后两个种类是非线性可分离的。


    该数据集包含了4个属性:
    Sepal.Length(花萼长度),单位是cm;
    Sepal.Width(花萼宽度),单位是cm;
    Petal.Length(花瓣长度),单位是cm;
    Petal.Width(花瓣宽度),单位是cm;
    种类:Iris Setosa(1.山鸢尾)、Iris Versicolour(2.杂色鸢尾),以及Iris Virginica(3.维吉尼亚鸢尾)。

    Iris Setosa(1.山鸢尾)

    Iris Versicolour(2.杂色鸢尾)


    Iris Virginica(3.维吉尼亚鸢尾)


    百闻不如一见:



    贴一下使用最多的:

    5.1	3.5	1.4	0.2	1
    4.9	3	1.4	0.2	1
    4.7	3.2	1.3	0.2	1
    4.6	3.1	1.5	0.2	1
    5	3.6	1.4	0.2	1
    5.4	3.9	1.7	0.4	1
    4.6	3.4	1.4	0.3	1
    5	3.4	1.5	0.2	1
    4.4	2.9	1.4	0.2	1
    4.9	3.1	1.5	0.1	1
    5.4	3.7	1.5	0.2	1
    4.8	3.4	1.6	0.2	1
    4.8	3	1.4	0.1	1
    4.3	3	1.1	0.1	1
    5.8	4	1.2	0.2	1
    5.7	4.4	1.5	0.4	1
    5.4	3.9	1.3	0.4	1
    5.1	3.5	1.4	0.3	1
    5.7	3.8	1.7	0.3	1
    5.1	3.8	1.5	0.3	1
    5.4	3.4	1.7	0.2	1
    5.1	3.7	1.5	0.4	1
    4.6	3.6	1	0.2	1
    5.1	3.3	1.7	0.5	1
    4.8	3.4	1.9	0.2	1
    5	3	1.6	0.2	1
    5	3.4	1.6	0.4	1
    5.2	3.5	1.5	0.2	1
    5.2	3.4	1.4	0.2	1
    4.7	3.2	1.6	0.2	1
    4.8	3.1	1.6	0.2	1
    5.4	3.4	1.5	0.4	1
    5.2	4.1	1.5	0.1	1
    5.5	4.2	1.4	0.2	1
    4.9	3.1	1.5	0.2	1
    5	3.2	1.2	0.2	1
    5.5	3.5	1.3	0.2	1
    4.9	3.6	1.4	0.1	1
    4.4	3	1.3	0.2	1
    5.1	3.4	1.5	0.2	1
    5	3.5	1.3	0.3	1
    4.5	2.3	1.3	0.3	1
    4.4	3.2	1.3	0.2	1
    5	3.5	1.6	0.6	1
    5.1	3.8	1.9	0.4	1
    4.8	3	1.4	0.3	1
    5.1	3.8	1.6	0.2	1
    4.6	3.2	1.4	0.2	1
    5.3	3.7	1.5	0.2	1
    5	3.3	1.4	0.2	1
    7	3.2	4.7	1.4	2
    6.4	3.2	4.5	1.5	2
    6.9	3.1	4.9	1.5	2
    5.5	2.3	4	1.3	2
    6.5	2.8	4.6	1.5	2
    5.7	2.8	4.5	1.3	2
    6.3	3.3	4.7	1.6	2
    4.9	2.4	3.3	1	2
    6.6	2.9	4.6	1.3	2
    5.2	2.7	3.9	1.4	2
    5	2	3.5	1	2
    5.9	3	4.2	1.5	2
    6	2.2	4	1	2
    6.1	2.9	4.7	1.4	2
    5.6	2.9	3.6	1.3	2
    6.7	3.1	4.4	1.4	2
    5.6	3	4.5	1.5	2
    5.8	2.7	4.1	1	2
    6.2	2.2	4.5	1.5	2
    5.6	2.5	3.9	1.1	2
    5.9	3.2	4.8	1.8	2
    6.1	2.8	4	1.3	2
    6.3	2.5	4.9	1.5	2
    6.1	2.8	4.7	1.2	2
    6.4	2.9	4.3	1.3	2
    6.6	3	4.4	1.4	2
    6.8	2.8	4.8	1.4	2
    6.7	3	5	1.7	2
    6	2.9	4.5	1.5	2
    5.7	2.6	3.5	1	2
    5.5	2.4	3.8	1.1	2
    5.5	2.4	3.7	1	2
    5.8	2.7	3.9	1.2	2
    6	2.7	5.1	1.6	2
    5.4	3	4.5	1.5	2
    6	3.4	4.5	1.6	2
    6.7	3.1	4.7	1.5	2
    6.3	2.3	4.4	1.3	2
    5.6	3	4.1	1.3	2
    5.5	2.5	4	1.3	2
    5.5	2.6	4.4	1.2	2
    6.1	3	4.6	1.4	2
    5.8	2.6	4	1.2	2
    5	2.3	3.3	1	2
    5.6	2.7	4.2	1.3	2
    5.7	3	4.2	1.2	2
    5.7	2.9	4.2	1.3	2
    6.2	2.9	4.3	1.3	2
    5.1	2.5	3	1.1	2
    5.7	2.8	4.1	1.3	2
    6.3	3.3	6	2.5	3
    5.8	2.7	5.1	1.9	3
    7.1	3	5.9	2.1	3
    6.3	2.9	5.6	1.8	3
    6.5	3	5.8	2.2	3
    7.6	3	6.6	2.1	3
    4.9	2.5	4.5	1.7	3
    7.3	2.9	6.3	1.8	3
    6.7	2.5	5.8	1.8	3
    7.2	3.6	6.1	2.5	3
    6.5	3.2	5.1	2	3
    6.4	2.7	5.3	1.9	3
    6.8	3	5.5	2.1	3
    5.7	2.5	5	2	3
    5.8	2.8	5.1	2.4	3
    6.4	3.2	5.3	2.3	3
    6.5	3	5.5	1.8	3
    7.7	3.8	6.7	2.2	3
    7.7	2.6	6.9	2.3	3
    6	2.2	5	1.5	3
    6.9	3.2	5.7	2.3	3
    5.6	2.8	4.9	2	3
    7.7	2.8	6.7	2	3
    6.3	2.7	4.9	1.8	3
    6.7	3.3	5.7	2.1	3
    7.2	3.2	6	1.8	3
    6.2	2.8	4.8	1.8	3
    6.1	3	4.9	1.8	3
    6.4	2.8	5.6	2.1	3
    7.2	3	5.8	1.6	3
    7.4	2.8	6.1	1.9	3
    7.9	3.8	6.4	2	3
    6.4	2.8	5.6	2.2	3
    6.3	2.8	5.1	1.5	3
    6.1	2.6	5.6	1.4	3
    7.7	3	6.1	2.3	3
    6.3	3.4	5.6	2.4	3
    6.4	3.1	5.5	1.8	3
    6	3	4.8	1.8	3
    6.9	3.1	5.4	2.1	3
    6.7	3.1	5.6	2.4	3
    6.9	3.1	5.1	2.3	3
    5.8	2.7	5.1	1.9	3
    6.8	3.2	5.9	2.3	3
    6.7	3.3	5.7	2.5	3
    6.7	3	5.2	2.3	3
    6.3	2.5	5	1.9	3
    6.5	3	5.2	2	3
    6.2	3.4	5.4	2.3	3
    5.9	3	5.1	1.8	3
    

    使用AForge.Neuro中的BPAnn来进行训练和预测:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.IO;
    
    using AForge;
    using AForge.Neuro;
    using AForge.Neuro.Learning;
    using AForge.Controls;
    
    //BPann反向传播神经网络
    //进行鸢(yuan)尾花分类
    namespace bpannIris
    {
        class Program
        {
            private static double premnmx( double num , double min , double max  )//归一化1
            {
                if (num > max)
                    num = max;
                if (num < min)
                    num = min;
    
                return 2*(num - min) / (max - min) - 1;
            }
    
            private static double premnmx1(double num, double min, double max)//归一化2
            {
                if (num > max)
                    num = max;
                if (num < min)
                    num = min;
    
                return (num - min) / (max - min);
            }
            
            //主程序入口
            static void Main(string[] args)
            {
                int trainNum = 75 ; //训练数据个数
                int testNum = 75 ; //测试数据个数
                double[][] trainInput = new double[trainNum][];
                double[][] trainOutput = new double[trainNum][];
    
                double[] max = new double[4];
                double[] min = new double[4];
                for (int i = 0; i < 4; ++i)
                {
                    min[i] = double.MaxValue;//注意赋值,不能弄反了,目的找出每个属性的范围,做归一下用
                    max[i] = double.MinValue;
                }
    
                // 读取训练数据
                StreamReader reader = new StreamReader("trainData.txt");
    
                for (int i = 0; i < trainNum; ++i)
                {
                    string value = reader.ReadLine();//读取一行
                    string[] temp = value.Split('\t');//分割出字段
    
                    trainInput[i] = new double[4];//4个属性Sepal length, Sepal width, Petal length, Petal width
                    trainOutput[i] = new double[3];//分3种类别Iris setosa, Iris versicolor, Iris virginica
    
                    for (int j = 0; j < 4; ++j)//属性
                    {
                        trainInput[i][j] = double.Parse(temp[j]);
                        if (trainInput[i][j] > max[j])
                        {
                            max[j] = trainInput[i][j];
                        }
                        if (trainInput[i][j] < min[j])
                        {
                            min[j] = trainInput[i][j];
                        }
                    }
                    for (int j = 0; j < 3; ++j)
                    {
                        trainOutput[i][j] = 0;//初始化分类为0
                    }
                    trainOutput[i][int.Parse(temp[4])-1] = 1;
                }
    
                // 归一化
                for (int i = 0; i < trainNum; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        trainInput[i][j] = premnmx(trainInput[i][j], min[j], max[j]);
                    }
                }
                
                //训练网络
                // create multi-layer neural network
                ActivationNetwork network = new ActivationNetwork( new SigmoidFunction(3), 4, 5, 3 );
                
                // create teacher 反向传播算法
                BackPropagationLearning teacher = new BackPropagationLearning(network);
                
                // set learning rate and momentum
                teacher.LearningRate = 0.1;//学习率
                teacher.Momentum = 0;//动量参数
    
                int iteration = 1 ;//训练轮数
                while( iteration < 500 ) 
                {
                    teacher.RunEpoch( trainInput, trainOutput );
                    ++iteration;
                }
    
    
                // 读取测试数据
                double[][] testInput = new double[testNum][];
                double[] testOutput = new double[testNum];
                StreamReader reader1 = new StreamReader("testData.txt");
                for (int i = 0; i < testNum; ++i)
                {
                    string value = reader1.ReadLine();//读取行
                    string[] temp = value.Split('\t');//分割字段
    
                    testInput[i] = new double[4];
                    for (int j = 0; j < 4; ++j)//4个属性
                    {
                        testInput[i][j] = double.Parse(temp[j]);
                    }
                    testOutput[i] = int.Parse(temp[4]);//分类结果
                }
    
                // 对测试数据进行分类, 并统计正确率
                int hitNum = 0 ;
                for( int i = 0 ;  i < testNum ; ++i ) 
                {
    
                    double[] inp = new double[4]{ testInput[i][0], testInput[i][1], testInput[i][2], testInput[i][3] } ;
                    for (int j = 0; j < 4; ++j)
                    {
                        inp[j] = premnmx(inp[j], min[j], max[j]);//归一化
                    }
    
                    double[] t = { inp[0], inp[1], inp[2], inp[3] };
    
                    // 使用已训练的网络对测试样本计算输出
                    double[] result =  network.Compute(t) ;
    
                    int m = 0;
                    for (int j = 0; j < 3; ++j)
                    {
                        if (result[j] > result[m])//选出概率最大的分类
                        {
                            m = j;
                        }
                    }
    
                    if (m + 1 == testOutput[i])//转成测试集分类标签
                    {
                        ++hitNum;//统计命中个数
                    }
                }
    
                System.Console.WriteLine("分类正确率为 {0}% ", 100.0 * hitNum /  testNum );
                System.Console.Read();//读取输入,暂停
            }
        }
    }
    


    准确率基本在93.33333%---94.66666%

    展开全文
  • 针对LED光谱数学模型非线性的特点,提出利用一种经改进遗传算法(GA)优化的反向传播(BP)神经网络对LED光谱模型进行辨识。通过改进GA的算子,提高算法收敛效果和辨识精度,利用改进GA对BP神经网络初始和权值阈值进行...
  • 为了提高识别矿山水害水源(即,判定水的类型)的正确率,利用免疫算法设计并优化了反向传播神经元网络(BPNN)的结构并求得BPNN的各层权系数和阈值的初值,用该初值训练BPNN,获得最佳的BPNN各层的权系数(权重)和阈值,使其...
  • 1 发展历史1943年,Warren McCulloch和Walter Pitts发表题为《A Logical Calculus of the Ideas ...1958年,就职于Cornell航空实验室的Frank Rosenblatt发明了的一种称为感知器(Perceptron)的人工神经网络。它...

    1 发展历史

    1943年,Warren McCulloch和Walter Pitts发表题为《A Logical Calculus of the Ideas Immanent in Nervous Activity》的论文,首次提出神经元的M-P模型。

    1958年,就职于Cornell航空实验室的Frank Rosenblatt发明了的一种称为感知器(Perceptron)的人工神经网络。它可以被视为一种最简单形式的前馈神经网络。

    1969年,Marvin Minsky和 Seymour Papert发表《Perceptrons: an introduction to computational geometry》一书,从数学的角度证明了单层神经网络的局限性,指出神经网络甚至在面对简单的“异或”逻辑问题时也显得无能为力。因为这篇文章,神经网络的研究陷入了很长一段时间的低迷期,史称“Minsky造成的神经网络冰河事件”。

    1974 年,Paul Werbos在哈佛大学攻读博士学位期间,就在其博士论文中发明了影响深远的著名BP神经网络学习算法,但没有引起重视。

    1986年,David E. Rumelhart, Geoffrey E. Hinton和 Ronald J. Williams发表文章《Learning representations by back-propagating errors》,重新报道这一方法,BP神经网络学习算法才受到重视。

    自此,反向传播算法正式成型,历史的车轮开始缓缓转动,一场对神经网络和深度学习的轰轰烈烈的研究和应用正在徐徐拉开帷幕。

    (反向传播算法有多努力,有多牛逼,你们知道吗?)

    2 基本定义

    ef41218bf6f1a47167381d86ad3c6410.png

    图2.1 神经网络

    图2.1是一个2层神经网络的示例。

    第0层又被称为输入层,最后一层又被称为输出层,中间的若干层被称为隐藏层。

    神经网络的层数是从隐藏层开始计数的,输入层不计入总层数。

    z表示每个神经元的输入信号,上标(l)表示该神经元在神经网络的第l层,下标i表示该层的第i个神经元:

     637d7bf27088af565a4c39f9a2e1d285.png

    z向量化后为(假设第l层神经网络有k个神经元):

     942aa021e5bc82f4887e1d1fe367d222.png

    a表示每个神经元的输出信号,上标(l)表示该神经元在神经网络的第l层,下标i表示该层的第i个神经元:

     66b93384bafe66b9b7faaf8f55609424.png

    a向量化后为(假设第l层神经网络有k个神经元):

      65d7957fa7452640e669b3ec746f2cba.png

    w表示上一层神经元到下一层神经元的权重,上标(l)表示第l-1层神经元到第l层神经元的权重,下标i,j表示前一层的第i个神经元到后一层的第j个神经元的权重:

     d51214ddc87fd081cdffd05f97d30f50.png

    w向量化后为(假设第l-1层神经网络有k个神经元,第l层神经网络有q个神经元):

    57cb62c9aaceece998eac5f74554eda6.png

    b表示每个神经元输入信号的偏置值,有时又被称为偏置项或偏置单元,上标(l)和下标i表示该偏置属于神经网络的第l层第i个神经元:

     c04fe03a68294f5df7b7faa0f437e35b.png

    b向量化后为(假设第l层神经网络有k个神经元):

    c1b58e087f829d0c4e156316f8a1dd92.png

    注:第一次看本文的时候,可以先跳过“向量化”的内容不看。

    3 前向传播

    前向传播,就是将样本数据输入到神经网络模型,经由神经网络计算,最终输出预测值的过程。

    每个神经元的输入信号z,由参数w、b,和前一层的输出信号a 决定(假设第l层神经网络有k个神经元):

     0ca6a8ad5119f38664ea8a7469259b75.png

    向量化后为:

    01fc60bb3d61089e8e89c57fee65ecbc.png

    每个神经元的输出信号z,由激活函数σ和同一个神经元的输入信号a决定(为方便起见,本文中整个神经网络都采用同一种激活函数。但是,实际应用中,隐藏层和输出层的激活函数常常是不一样的):

    e05669ed906b0746c48bdfac4aa23b1e.png

    向量化后为:

    f1c1add27688b3ce5d143616183217df.png

    下面以图3.1为例进行说明。

    44815179aa4191e182ea686503014c26.png

    图3.1 前向传播模型

    样本数据为 (x,y)。其中:x=(x1,x2, x3),x的维度为3维;y=(y1,y2),y的维度为2维。

    神经网络的输入层的数据z0为:

    5e23e3a4e4aab96db41195e698be516b.png

    神经网络的输出层的预测值y^为:

    6e36a1f8de15da4048de84d03a937149.png

    某个神经元节点的输入信号:

    8e0281f0b6a665ab98c58b3232ae05e5.png

    某个神经元节点的输出信号:

    72d324f01dc981394fba7b14820c0acb.png

    神经网络的预测值的损失函数/代价函数为:

    aa9885b66a10dd85b6097fae4431549b.png

    注1:损失函数LossFunction、误差函数ErrorFunction、代价函数CostFunction,及其缩写L、E、C表达的是同一个函数。

    注2:损失函数里的系数1/2,仅仅是为了令函数求导后的系数为1,为了方便计算而设定的,没有实际意义。

    4 反向传播

    4.1 算法思路

    为了能够得到一个优质的神经网络模型,我们需要求模型的两类参数w和b的最优值,以达到令损失函数值最小的目标。

    显而易见的,对于这个L的最优化问题,我们可以考虑使用求偏导数的方法,并利用梯度下降法逐步逼近参数w和b的最优解。

    但是由于神经网络结构复杂、参数多,导致传统的偏导数和梯度下降法无法直接被使用。直至反向传播算法应运而生,它大大提高了求解神经网络模型的最优化参数的效率,使得神经网络实现了从理论到工业应用的跨越,也掀起了学习和使用神经网络的热潮。

    反向传播算法:首先利用损失函数求得模型的最终误差。接着再将误差自后向前层层传递,获取每个神经元的误差。最后将每层每个神经元的误差对w和b求偏导,迭代获取的w和b的最优解,从而构建损失函数最小的最优神经网络模型。当然,和梯度下降法类似,神经网络也需要经过多次迭代,才能够逼近并获得最优模型。

    注:反向传播算法能够提高计算效率的两个因素:一是运算过程的向量化,二是能够实现分布式计算。

    4.2 求误差δ

    我们对任意神经元上的误差δ作出如下定义:

    fedb5aa5a863cc583001765f007ed745.png

    注1:这个误差δ完全是一个人为的定义,求误差δ的目的,是以此为中介,求损失函数对参数w和b的偏导数。我们也可以定义误差为损失函数对神经元输出信号的偏导。

    注2:虽然这个误差是一个人为的定义,但是这个思路在机器学习领域一直都有可靠且广泛的应用,例如XGB和LGB的残差也是用了类似的将损失函数对超参数求偏导的方法。

    那么,对于神经网络的最后一层(第L层),可以求得整个神经网络的第一组误差:

    a56b4243c806e910b2d9ec0aeec77d7a.png

    进行向量化,并记为公式BP1

    d27834702fc6e1b15937a7c51461a9e0.png

    其中:右式用到了哈达玛积,表示将两个同样结构的矩阵的相同位置上的数值相乘。

    这样,我们就求得了最后一层神经网络的误差。

    接着,为了能够把误差层层向前传导,我们需要找到两个相邻层误差之间的关系,对于任意两层l层和l-1层的神经网络:

    7237c259764bff9ec22e544a9b822508.png

    进行向量化,并记为公式BP2

    727f018ea68c2a9882220d589b2e51ef.png

    其中:右式的第二项和第三项之间用到了哈达玛积,表示将两个同样结构的矩阵的相同位置上的数值相乘。

    现在,根据公式BP1我们能够获得网络最后一层的输出误差,接着根据公式BP2我们能够从后往前获得网络所有层的误差。

    4.3 求参数w和b的偏导数

    获取了各层各神经元的误差δ后,我们就能够利用误差δ作为中介,对模型参数w和b进行迭代求解。

    先求解w的偏导数:

    534ccc3adbaa11cf109fd1aa10430059.png

    进行向量化,并记为公式BP3

    1bf4c56a554e684aa48071ce8abfd1b6.png

    再求解b的偏导数:

    b009053b8f50786dae58edbf4f86c3fd.png

    进行向量化,并记为公式BP4

    48c221df0c0d893b278b860a350bf381.png

    4.4 迭代

    和梯度下降法类似,反向传播算法要进行多次迭代,以使得参数w和b趋向能够使损失函数最小的值。

    每轮迭代时,参数w和b的变化公式如下:

    204006d4e171281449c04e2544fffb2b.png

    这里的α是超参数:学习效率(LearningRate)。用于控制参数w和b变化的速度。

    注:本文的推导只涉及一个输入样本的数据,但是在实际应用中,一般会使用批量样本,这时只需要将各个样本求得的偏导数取均值,再进行迭代即可,具体内容这里就不作展开了。

    4.5 算法流程总结

    简要叙述下反向传播算法的流程:

    启动一个循环,事先定义好循环终止的条件,循环内容如下:

    步骤1:根据公式BP1,求得神经网络模型最后一层的误差δ(L)。

    步骤2:根据公式BP2,自后向前,求得神经网络模型所有层的误差δ(l)。

    步骤3:根据公式BP3和BP4,求得参数w和b的偏导数∂L/∂w和∂L/∂b。

    步骤4:利用偏导数∂L/∂w和∂L/∂b,更新参数w和b。

    步骤5:判断当前模型的损失函数L是否符合预期,如果“是”则跳出循环终止训练,否则继续训练。

    5 实操技巧

    只会推公式对解决问题没有任何帮助!!!

    推导数学公式的目的在于了解算法,以达到建立和优化模型的目的。所以谷歌最喜欢用的算法就是“博士生下降”(grad student descent)算法,也就是靠那些数学很好的博士去调参。。。。。。

    本节介绍几个和反向传播算法相关的实操技巧。

    5.1 梯度消失

    先回顾一下公式BP2:

    727f018ea68c2a9882220d589b2e51ef.png

    我们重点关注下激活函数的导数:

    ff4ca5cebdb4e0e74e31844b45ce2cff.png

    在模型刚开始学习的时候,激活函数σ的导数σ’变化得较快,这时候不会出现问题。但是,随着模型越来越逼近最优解,或者在训练的过程中不小心的一次扰动,σ’可能就等于0了。

    这样,无论后一层的误差δ(l)是多少,乘上一个接近0的数,那么前一层的误差δ(l-1)自然也会近似于0。δ(l-1)一旦等于0后,那么误差就不会继续向前传播了。后续的w和b也就都等于0了。

    所以,随着网络层数的增加,远离输出层(即接近输入层)的层不能够得到有效的学习,层数更深的神经网络有时反而会具有更大的训练误差。这就是梯度消失。

    有时候为了预防梯度消失,我们会采用梯度检验的方法,以确认反向传播算法是否工作在正常状态。

    5.2 激活函数的选择

    我们先看看传统的sigmoid函数:

    8d3355ae0e5ae6e0a058eabbec40e3ea.png

    图5.1 Sigmoid函数

    可以看出,Sigmoid函数只有一小段接近线性的区域,在输出趋近于0或1的区间,函数的值是保持不变或者变化很小的,反映到导数上,就是导数接近于0。

    所以,我们为了避免梯度消失,隐藏层不使用sigmoid函数作为激活函数

    为了保证激活函数不至于那么容易就饱和,导致导数等于0,我们考虑将ReLU函数作为激活函数:

    cee46082379a41cfefada2667c69cf65.png

    图5.2 ReLU函数和PReLU函数

    在ReLU中,在自变量大于0的区间,能保证梯度不会消失,在自变量小于0的区间,函数的值被截断。在PReLU中,当x<0时,它不输出0,而是具有一个较小的斜率。

    所以,卷积神经网络钟爱的激活函数是ReLU,它有利于反向传播阶段的计算,也能缓解过拟合。在ReLU函数效果不好时,建议尝试PReLU函数。此外,ReLu和PReLU一般只用于隐藏层

    既然提到了激活函数,那么顺便列举一下其它几个Tip,虽然它们和反向传播算法无关:

    激活函数最大的贡献就是将非线性引入神经网络模型,以使得算法能够学习更复杂的模型,否则即便增加网络的深度也依旧还是线性映射,起不到多层的效果。

    如果是分类问题,输出层的激活函数一般会选择sigmoid函数。

    在输入数据不是均值为0的正态分布时,Sigmoid函数输出的均值一般不为0,这是Sigmoid函数除了容易导致梯度消失外,另一个缺点。

    5.3 参数w和b的初始化

    5.3.1 参数w

    在神经网络中,将权重值w初始化为0是不合适的。考虑全连接的深度神经网络,同一层中的任意神经元都是同构的,它们拥有相同的输入和输出,如果再将参数全部初始化为同样的值,那么无论前向传播还是反向传播的各个神经元的取值都将是完全相同的。

    所以,我们采用打破对称性的方式,进行w初始值的随机化。

    在使用ReLu作为激活函数时,为了避免梯度爆炸,建议w采用接近单位矩阵的初始化值。资料表明(我没验证过),初始化w为单位矩阵并使用ReLU作为激活函数,在一些应用中取得了与长短期记忆模型LSTM相似的结果。

    两个比较流行的参数w的初始化方法:

    (1)HE初始化(He Initialization)。将w初始化为均值为0,方差为2/dim_input的正态分布随机数。其中dim_input为当前层输入数据的维度。

    (2)Xavier初始化。将w初始化为均值为0,方差为6/(dim_input+ dim_output)的正态分布随机数。其中dim_input为当前层输入数据的维度,dim_output为当前层输出数据的维度。

    5.3.2 参数b

    根据公式BP3:

    1bf4c56a554e684aa48071ce8abfd1b6.png

    在使用ReLU函数时,一个比较好的做法是用一个较小的正数来初始化参数b(参数b常常被初始化为1/0.1/0.01),以避免神经元节点输出为0的问题。

    6 参考资料

    [1]    Michael Nielsen Neural Networks and Deep Learning https://neuralnetworksanddeeplearning.com

    [2]    Andrew Ng(吴恩达) Machine Learning https://www.coursera.org/learn/machine-learning

    [3]    StoneNote 神经网络简史 https://www.jianshu.com/p/8aacc7f201f2


    本文转载自公众号:数论遗珠,作者:阮智

    1efc41a3a00f4bf6756f8b10fd8e8aad.png

    展开全文
  • 改进模型继承了概率神经网络模型的分类原理和结构特征,同时应用了多层感知器神经网络模型的反向传播算法进行函数和参数学习,由此解决了函数估计和空间复杂度高的问题. 通过三组数值实验的验证,结果表明该模型还有着...
  • 标签: 梯度下降 误差反向传播 一、梯度下降算法 基本思想:从某些初始解出发,迭代寻找最优参数值,每次迭代中在当前点计算梯度,根据函数值下降最快的方向确定搜索方向,梯度为0则达到局部极小。 J是代价函数,w...

    作者:中南大学可视化实验室可解释性机器学习项目组 18届 本科生研究员 WXY

    日期:2020-7-16

    标签: 梯度下降 误差反向传播

    一、梯度下降算法

    基本思想:从某些初始解出发,迭代寻找最优参数值,每次迭代中在当前点计算梯度,根据函数值下降最快的方向确定搜索方向,梯度为0则达到局部极小。
    在这里插入图片描述
    在这里插入图片描述
    J是代价函数,w是权重,b是一个常数类似于阈值,当我们从一个初始点出发,向梯度最大的方向一步一步前进,最终会到达最小值
    在这里插入图片描述
    全局最小与局部极小
    这张图是一个凸函数,但是如果在非凸最优化,类似于这张图
    在这里插入图片描述
    直接采取梯度下降或许就不能到达全局最小

    跳出局部极小的策略

    以多组不同参数值初始化多个神经网络,取其中误差最小的解作为最终参数。
    模拟退火simulated annealing:每一步都以一定的概率接受比当前解更差的结果。
    随机梯度下降:在计算梯度是加入了随机因素,即使到达极小点,它的梯度可能仍不为 0,会继续计算。

    技巧:

    1、学习率learning rate:
    在这里插入图片描述
    理想情况下代价函数关于迭代次数的曲线是这样的:
    在这里插入图片描述
    可以用来判断是否已经汇聚,比如一次迭代的下降在10^-3 范围内。但是如果曲线如下图:
    在这里插入图片描述
    在这里插入图片描述
    表示学习率过大,也就是说每一步的步长过大,虽然向着下降的方向前进,但是不能到达更小的值。
    在这里插入图片描述
    如果学习率过小,显然收敛速度是很慢的。
    2、保证输入特征的值在一个相似的范围内
    在这里插入图片描述
    假设一个特征在0-2000,另一个在1-5,那么把损失函数基于这两个特征的轮廓图画出来,就会变成这种细长的形状,那么在梯度下降的过程中轨迹将很复杂
    在这里插入图片描述
    但是当把两个缩放后,轨迹就变得简单,可以更快到达最优值。
    3、均值归一化
    使用xi-ui代替xi,使特征更加接近0
    在这里插入图片描述
    思考:在我们的应用中是否也可以进行这样的操作呢
    比如这张图像由三层像素值组成,当将每个值x用(x-均值)/255 代替或许也可以减少运行时间。
    在这里插入图片描述

    二、逆误差传播算法 BP算法

    在这里插入图片描述
    输入层有d个属性描述,q个隐层神经元,l个输出神经元,三层直接有权重,隐层和输出层神经元上有阈值。
    BP算法基于梯度下降算法,广义上每个参数的更新式都是这样的在这里插入图片描述
    ,比如对权重whj,在这里插入图片描述
    。这之中的每一个权重或阈值都可以由数学方法得到其基于特定输入的梯度。
    BP算法的基本思想:将输入数据提供给输入神经元,然后逐层将信号前传,直到产生输出层的结果,然后从输出层计算误差,再逆向地将误差传播到隐层,调整连接权和阈值,对此过程循环迭代,直到达到某些条件,例如最小化累积误差.
    这里可能产生一个问题:为什么要先向前传播再向后传播,为什么不直接一次向前传播就计算出所有的东西?
    这是由计算方式决定的,用一个计算图Computer Graph来解释
    J(a, b, c) = 3(a+bc)
    在这里插入图片描述
    我们在向前传播的过程中可以得到其中所有的输出值在这里插入图片描述
    但是当计算梯度时必须从后向前,比如v增加1,J增加3得到v与J的梯度,然后才能计算a与J的梯度,理论就是微积分里的链式法则。

    注:如何设置神经元的个数是个未决问题,应用中通常靠试错法来调整。

    技巧:
    BP有强大的表示能力,但是经常过拟合(训练误差降低,测试误差上升),有两种策略缓解过拟合:
    早停:将数据分为训练集和验证集,训练集用于计算梯度、更新连接权和阈值,当训练集的误差降低但是验证集的误差上升,就提前停止训练。
    正则化:在误差目标函数中增加一个用于描述网络复杂度的部分,比如连接权与阈值的平方和,将误差目标函数改变为:
    在这里插入图片描述
    对经验误差与网络复杂度这两项进行折中。
    我的理解是当过拟合发生网络的复杂度一定很高,那么控制复杂度可以帮助控制过拟合。

    注:本文发布已经得到原文作者WXY同意
    展开全文
  • 基于基于内部认知机制(KDTICM)理论的知识发现理论,我们构建了一种复合金字塔模型方法,该方法由四层智能接口组成,并以多种方式集成,例如混合反向传播方法(HBP),修改数据库中的知识发现(KDD *),混合SVM...
  • 深度学习(3): BP神经网络推导及实验

    千次阅读 多人点赞 2019-08-11 09:15:25
    文章目录1 BP神经网络简介2 BP神经网络结构与原理3 BP神经网络推导4 实验参考资料 1 BP神经网络简介 BP(back propagation)神经网络是1986年由Rumelhart和...BP算法(Back Propagation algorithm即反向传播算法)...
  • **任务简介:**前馈神经网络架构设计,反向传播算法 (视频:前向后向算法,前馈神经网络技巧) 详细说明: 6.4 架构设计 神经网络设计的一个关键点是确定它的架构:网络的深度,每一层的宽度。更深层的网络每层可...
  • BP 算法性能分析(1)实验条件:Matlab7.10.0(R2010a)分别实现了基本BP算法以及七种改进的BP算法(动量的梯度下降法、量化共轭梯度法、变学习率梯度下降算法、变学习率动量梯度下降法、弹性反向传播算法、L-M优化...
  • BP 算法性能分析(1)实验条件:Matlab7.10.0(R2010a)分别实现了基本BP算法以及七种改进的BP算法(动量的梯度下降法、量化共轭梯度法、变学习率梯度下降算法、变学习率动量梯度下降法、弹性反向传播算法、L-M优化...
  • 一种改进的BP神经网络算法及其应用-一种改进的BP神经网络算法及其应用.rar 一种改进的BP神经网络算法及其应用 一种改进的BP神经网络算法及其应用 褚辉,赖惠成 ...摘要:BP算法是目前应用最为...反向传播算法;模式识别
  • BP算法是由学习过程由信号的正向传播与误差的反向传播两个过程组成。由于多层前馈网络的训练经常采用误差反向传播算法,人们也常把将多层前馈网络直接称为BP网络。
  • BP算法(反向传播算法)以其良好的非线性逼近能力、泛化能力以及实用性成为了人工神经网络训练算法中应用最为广泛的算法。但同时使用BP算法又存在收敛速度较慢、易陷入局部极小值等问题。为了将BP算法用于大规模数据...
  • 首先设定抑制限寻找符合抑制条件的神经元,然后通过侧抑制函数对符合条件的神经元进行快速输出抑制,运用反向传播算法对模型进行优化,最终输出权重特征。实验结果表明,算法能够使隐藏层输出近似满足稀疏条件并学习得到...
  • 这本书讲述了一些深度学习的基本概念和基本算法像反向传播算法、梯度下降算法、Dropout等。 加上实验室学长对我们的培训,对这些算法也有了初步的了解。 在我目前学到的机器学习的中,降低损失函数的值是其中最重要...
  • 然后,利用反向传播(BP)算法对整个网络进行微调,从而使网络 权值达到最优;最后,将CS-DBN应用于肺部肿瘤图像的识别,实验从受限玻尔兹曼机(RBM)训练次数、训练批次大 小、DBN隐层层数和隐层节点数四个角度将CS-DBN...
  • 矿井中对粉尘浓度进行大范围内的检测,运用了无线传感器网络,针对网络耗能大、寿命有限及精度低等问题,对经典蚁群算法进行改进,使用其对反向传播(BP)神经网络进行优化,然后应用在无线传感器网络中进行数据融合。...
  • 利用该模型进行求解时,通过萤火虫算法按照目标函数进行全局搜索,得到反向传播(BP)神经网络的一组权阈值最优近似解,以该近似解作为BP模型初值,利用LM算法对这组权阈值进行二次优化训练,得到最终的图像压缩模型。实验...
  • 激活函数为Sigmoid,损失函数为MSE(均方误差),优化算法为GD(梯度下降),梯度计算算法为BP(反向传播算法),网络初始化方式为高斯分布中随机采样,无正则化处理等 network_v2.py 实现参数化FNN的设计与实现 ...
  • 利用两种数据集对RDAAA、基于交叉熵函数的深层自编码器学习算法(CDAA)与误差反向传播算法(BPA)进行模式识别能力分析,结果表明在确定限定误差与选取最佳学习速率的情况下,RDAAA相对于CDAA与BPA收敛速度最快,...
  • 在上一次的推送MLPMLPMLP算法推导小记中对反向传播进行了详细的推导, 本文将详细讲解该算法如何用numpynumpynumpy来实现。 本次实验中输入层为4个结点,隐藏层为20个结点,再加上偏置,激活函数为tanhtanhtanh,输出...
  • 算法可估计输入光场图像每个子视点的视差图,通过图像反向投影和重投影优化生成指定虚拟相机位置和姿态的光场图像,接着使用基于视差优先级的图像修复方法修复透视变换后的中心子视点图像,再通过中心子视点向水平和...
  • BP算法的基本思想是把学习过程分为两个阶段:第—阶段是信号的正向传播过程;输入信息通过输入层、隐层逐层处理并计算每个单元的实际输出值;第二阶段是误差的反向传递过程;若在输入层未能得到期望的输出值,则逐层递归...
  • 为了提高气化配煤煤灰流动温度预测的精度和稳定性,提出将遗传算法(GA)与误差反向传播神经网络(BP)相结合的预测方法,采用GA优化BP神经网路的权值和阈值,再用BP算法训练网络,结合仿真实验分析比较了GA-BP网络算法与...
  • 提出了一种基于误差反向传播前馈神经网络(BP)和主元分析法(PCA)实现色卡的表面光谱反射率重构的新算法。通过对三种色卡进行光谱重构实验研究了BP 神经网络的最优结构和主元数的最佳选择,验证了算法的精度。实验结果...
  • 在精确建立相机图像和投影仪图像对应关系的基础上,使用三层反向传播神经网络训练来建立图像坐标与被测物体三维坐标之间的映射关系。使用带有圆形标志点的平面标定板进行神经网络的样本采集与训练。为了验证本文算法...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 138
精华内容 55
关键字:

反向传播算法实验