计算智能 -- BP神经网络（2）

最新推荐文章于 2024-08-24 21:58:27 发布
最新推荐文章于 2024-08-24 21:58:27 发布
阅读量869 收藏 1
点赞数 1
分类专栏： 计算机智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjf_1997/article/details/78234560
版权

本文是对懒惰的gler–Java实现BP神经网络完成 Iris 数据分类:http://blog.csdn.net/u010858605/article/details/72898178 这篇博客的理解和对一些小问题的改进。原文的相关描述请点击上面的链接即可。

（1）数据选取

由于采用Iris 鸢尾花数据集，该数据集一共有150条记录，选取 Iris 数据集中的120条数据作为训练集（train.txt），剩余的30条数据作为测试集（test.txt）。
数据采取编号

（2）java-code的理解

一共包含三个类： BPNN.java 、DataUtil.java 、Test.java
这里写图片描述

（3）代码的问题

3.1 在数据写入reslt.txt中的时候，判定的花型全是”Iris-setosa”，与事实不符合。
3.2 如果训练次数超过MaxTrain则没有给出判断的条件

（4）改进

4.1 – BPNN.java

import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

class BPNN {
    // private static int LAYER = 3; // 三层神经网络
    private static int NodeNum = 10; // 每层的最多节点数
    private static final int ADJUST = 5; // 隐层节点数调节常数
    private static final int MaxTrain = 2000; // 最大训练次数
    private static final double ACCU = 0.015; // 每次迭代允许的误差 iris:0.015
    private double ETA_W = 0.5; // 权值学习效率0.5
    private double ETA_T = 0.5; // 阈值学习效率0.5
    private double accu;

    // 附加动量项
    //private static final double ETA_A = 0.3; // 动量常数0.1
    //private double[][] in_hd_last; // 上一次的权值调整量
    //private double[][] hd_out_last;

    private int in_num;     // 输入层节点数
    private int hd_num;     // 隐层节点数
    private int out_num;    // 输入出节点数

    private ArrayList<ArrayList<Double>> list = new ArrayList<>(); // 输入输出数据

    private double[][] in_hd_weight;    // BP网络in-hidden突触权值
    private double[][] hd_out_weight;   // BP网络hidden_out突触权值
    private double[] in_hd_th;          // BP网络in-hidden阈值
    private double[] hd_out_th;         // BP网络hidden-out阈值

    private double[][] out;     // 每个神经元的值经S型函数转化后的输出值，输入层就为原值
    private double[][] delta;       // delta学习规则中的值

    // 获得网络三层中神经元最多的数量
    public int GetMaxNum() {
        return Math.max(Math.max(in_num, hd_num), out_num);
    }

    // 设置权值学习率
    public void SetEtaW() {
        ETA_W = 0.5;
    }

    // 设置阈值学习率
    public void SetEtaT() {
        ETA_T = 0.5;
    }

    // BPNN训练
    public void Train(int in_number, int out_number, ArrayList<ArrayList<Double>> arraylist) throws IOException {

        list = arraylist;
        in_num = in_number;
        out_num = out_number;

        GetNums(in_num, out_num); // 获取输入层、隐层、输出层的节点数
        // SetEtaW(); // 设置学习率
        // SetEtaT();

        InitNetWork(); // 初始化网络的权值和阈值

        int datanum = list.size();        // 训练数据的组数
        int createsize = GetMaxNum();     // 比较每一层的节点数，取max
        out = new double[3][createsize];  // 创建输出数组 out[3][7]

        //训练次数为MaxTrain以内，如果训练次数超过MaxTrain则没有给出判断的条件
        for (int iter = 0; iter < MaxTrain; iter++) {

            for (int cnd = 0; cnd < datanum; cnd++) {
                // 第一层输入节点赋值  out[0][4]
                for (int i = 0; i < in_num; i++) {
                    //list.get(cnd).get(i) 取样本数据的第cnd组中第i个数据放入到out[0][i]中
                    out[0][i] = list.get(cnd).get(i); // 为输入层节点赋值，其输入与输出相同
                }
                Forward(); // 前向传播
                Backward(cnd); // 误差反向传播

            }
            System.out.println("This is the " + (iter + 1) + " th trainning NetWork !");
            accu = GetAccu();
            System.out.println("All Samples Accuracy is " + accu);
            if (accu < ACCU)
                break;

        }

    }

    // 获取输入层、隐层、输出层的节点数，in_number、out_number分别为输入层节点数和输出层节点数
    public void GetNums(int in_number, int out_number) {
        in_num = in_number;
        out_num = out_number;
        hd_num = (int) Math.sqrt(in_num + out_num) + ADJUST;
        if (hd_num > NodeNum)
            hd_num = NodeNum; // 隐层节点数不能大于最大节点数
    }

    // 初始化网络的权值和阈值
    public void InitNetWork() {
        // 初始化上一次权值量,范围为-0.5-0.5之间
        //in_hd_last = new double[in_num][hd_num];
        //hd_out_last = new double[hd_num][out_num];

        in_hd_weight = new double[in_num][hd_num];
        for (int i = 0; i < in_num; i++)
            for (int j = 0; j < hd_num; j++) {
                int flag = 1; // 符号标志位(-1或者1)
                if ((new Random().nextInt(2)) == 1)
                    flag = 1;
                else
                    flag = -1;
                // New Random.nextDouble()的取值范围: [0,1.0)
                in_hd_weight[i][j] = ( new Random().nextDouble() / 2 ) * flag; // 初始化in-hidden的权值
                //in_hd_last[i][j] = 0;
            }

        hd_out_weight = new double[hd_num][out_num];
        for (int i = 0; i < hd_num; i++)
            for (int j = 0; j < out_num; j++) {
                int flag = 1; // 符号标志位(-1或者1)
                if ((new Random().nextInt(2)) == 1)
                    flag = 1;
                else
                    flag = -1;
                hd_out_weight[i][j] = (new Random().nextDouble() / 2) * flag; // 初始化hidden-out的权值
                //hd_out_last[i][j] = 0;
            }

        // 阈值均初始化为0
        // 输入层不处理数据，只接收数据，所以不设置阈值
        in_hd_th = new double[hd_num];
        for (int k = 0; k < hd_num; k++)
            in_hd_th[k] = 0;

        hd_out_th = new double[out_num];
        for (int k = 0; k < out_num; k++)
            hd_out_th[k] = 0;
    }

   /* // 计算单个样本的误差
    public double GetError(int cnd) {
        double ans = 0;
        for (int i = 0; i < out_num; i++)
        {
            System.out.println(out[2][i]);
            ans += 0.5 * (out[2][i] - list.get(cnd).get(in_num + i)) * (out[2][i] - list.get(cnd).get(in_num + i));
        }

        return ans;
    }*/

    // 计算所有样本的平均精度
    public double GetAccu() {
        double ans = 0;
        int num = list.size();
        for (int i = 0; i < num; i++) {
            int m = in_num;
            for (int j = 0; j < m; j++)
                out[0][j] = list.get(i).get(j);
            Forward();
            int n = out_num;
            for (int k = 0; k < n; k++){
                //定义了输入与输出之间的平方误差
                //System.out.println(list.get(i).get(in_num + k));
                //System.out.println(out[2][k]);
                ans += 0.5 * (list.get(i).get(in_num + k) - out[2][k]) * (list.get(i).get(in_num + k) - out[2][k]);
            }
        }

        return ans / num;
    }

    // 前向传播
    public void Forward() {
        /**
         * 计算隐层节点的输出值 
         * v = 求和( 每个输入层数据 * 每个隐层的权重 ) + 对应  隐层 的阈值 
         * in_hd_weight[4][7]   out[0][4]   in_hd_th[7]
         */
        for (int j = 0; j < hd_num; j++) {
            double v = 0;
            for (int i = 0; i < in_num; i++)
                v += in_hd_weight[i][j] * out[0][i];
            v += in_hd_th[j];
            out[1][j] = Sigmoid(v);
        }

        /**
         * 计算输出层节点的输出值
         * v = 求和( 每个隐层输出数据 * 每个输出层的权重 ) + 对应 输出层 的阈值 
         * hd_out_weight[7][3]  out[1][3]   hd_out_th[3]
         */
        for (int j = 0; j < out_num; j++) {
            double v = 0;
            for (int i = 0; i < hd_num; i++)
                v += hd_out_weight[i][j] * out[1][i];
            v += hd_out_th[j];
            out[2][j] = Sigmoid(v);
        }
    }

    // 误差反向传播 = 计算权值调整量 + 更新BP神经网络的权值和阈值
    public void Backward(int cnd) {
        CalcDelta(cnd); // 计算权值调整量
        UpdateNetWork(); // 更新BP神经网络的权值和阈值
    }

    // 计算delta调整量
    public void CalcDelta(int cnd) {

        int createsize = GetMaxNum(); // 比较创建数组
        delta = new double[3][createsize];

        // 计算输出层的delta值  cnd ( 0 - 119 )
        for (int i = 0; i < out_num; i++) {
            //System.out.println(list.size());
            delta[2][i] = (list.get(cnd).get(in_num + i) - out[2][i]) * SigmoidDerivative(out[2][i]);
        }

        // 计算隐层的delta值
        for (int i = 0; i < hd_num; i++) {
            double t = 0;
            for (int j = 0; j < out_num; j++)
                t += hd_out_weight[i][j] * delta[2][j];
            delta[1][i] = t * SigmoidDerivative(out[1][i]);
        }
    }

    // 更新BP神经网络的权值和阈值
    public void UpdateNetWork() {

        // 隐含层和输出层之间权值和阀值调整
        for (int i = 0; i < hd_num; i++) {
            for (int j = 0; j < out_num; j++) {
                hd_out_weight[i][j] += ETA_W * delta[2][j] * out[1][i]; // 未加权值动量项
                /* 动量项
                 * hd_out_weight[i][j] += (ETA_A * hd_out_last[i][j] + ETA_W
                 * delta[2][j] * out[1][i]); hd_out_last[i][j] = ETA_A *
                 * hd_out_last[i][j] + ETA_W delta[2][j] * out[1][i];
                 */
            }

        }
        for (int i = 0; i < out_num; i++)
            hd_out_th[i] += ETA_T * delta[2][i];

        // 输入层和隐含层之间权值和阀值调整
        for (int i = 0; i < in_num; i++) {
            for (int j = 0; j < hd_num; j++) {
                in_hd_weight[i][j] += ETA_W * delta[1][j] * out[0][i]; // 未加权值动量项
                /* 动量项
                 * in_hd_weight[i][j] += (ETA_A * in_hd_last[i][j] + ETA_W
                 * delta[1][j] * out[0][i]); in_hd_last[i][j] = ETA_A *
                 * in_hd_last[i][j] + ETA_W delta[1][j] * out[0][i];
                 */
            }
        }
        for (int i = 0; i < hd_num; i++)
            in_hd_th[i] += ETA_T * delta[1][i];
    }

    // 符号函数sign
    public int Sign(double x) {
        if (x > 0)
            return 1;
        else if (x < 0)
            return -1;
        else
            return 0;
    }

    // 返回最大值
    public double Maximum(double x, double y) {
        if (x >= y)
            return x;
        else
            return y;
    }

    // 返回最小值
    public double Minimum(double x, double y) {
        if (x <= y)
            return x;
        else
            return y;
    }

    // log-sigmoid函数
    public double Sigmoid(double x) {
        return (double) (1 / (1 + Math.exp(-x)));
    }

    // log-sigmoid函数的倒数
    public double SigmoidDerivative(double y) {
        return (double) (y * (1 - y));
    }

 /*   // tan-sigmoid函数
    public double TSigmoid(double x) {
        return (double) ((1 - Math.exp(-x)) / (1 + Math.exp(-x)));
    }

    // tan-sigmoid函数的倒数
    public double TSigmoidDerivative(double y) {
        return (double) (1 - (y * y));
    }*/

    // 分类预测函数
    public ArrayList<ArrayList<Double>> ForeCast(
            ArrayList<ArrayList<Double>> arraylist) {

        ArrayList<ArrayList<Double>> alloutlist = new ArrayList<>();
        ArrayList<Double> outlist = new ArrayList<Double>();
        int datanum = arraylist.size();
        for (int cnd = 0; cnd < datanum; cnd++) {
            for (int i = 0; i < in_num; i++)
                out[0][i] = arraylist.get(cnd).get(i); // 为输入节点赋值
            Forward();
            for (int i = 0; i < out_num; i++) {
                if (out[2][i] > 0 && out[2][i] < 0.5)
                    out[2][i] = 0;
                else if (out[2][i] > 0.5 && out[2][i] < 1) {
                    out[2][i] = 1;
                }
                outlist.add(out[2][i]);
                //System.out.println( out[2][i] );
            }
            alloutlist.add(outlist);
            outlist = new ArrayList<Double>();
            outlist.clear();
        }
        return alloutlist;
    }

}

4.2 – DataUtil.java

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

class DataUtil {

    private ArrayList<ArrayList<Double>> alllist = new ArrayList<ArrayList<Double>>(); // 存放所有数据
    private ArrayList<String> outlist = new ArrayList<String>(); // 存放输出数据，索引对应每个everylist的输出
    private ArrayList<String> checklist = new ArrayList<String>();  //存放测试集的真实输出字符串
    private int in_num = 0;
    private int out_num = 0; // 输入输出数据的个数
    private int type_num = 0; // 输出的类型数量
    private double[][] nom_data; //归一化输入数据中的最大值和最小值
    private int in_data_num = 0; //提前获得输入数据的个数

    // 获取输出类型的个数
    public int GetTypeNum() {
        return type_num;
    }

    // 设置输出类型的个数
    public void SetTypeNum(int type_num) {
        this.type_num = type_num;
    }

    // 获取输入数据的个数
    public int GetInNum() {
        return in_num;
    }

    // 获取输出数据的个数
    public int GetOutNum() {
        return out_num;
    }

    // 获取所有数据的数组
    public ArrayList<ArrayList<Double>> GetList() {
        return alllist;
    }

    // 获取输出为字符串形式的数据
    public ArrayList<String> GetOutList() {
        return outlist;
    }

    // 获取输出为字符串形式的数据
    public ArrayList<String> GetCheckList() {
        return checklist;
    }

    //返回归一化数据所需最大最小值
    public double[][] GetMaxMin(){

        return nom_data;
    }

    // 读取文件初始化数据
    public void ReadFile( String filepath, String sep, int flag ) throws Exception {

        ArrayList<Double> everylist = new ArrayList<Double>(); // 存放每一组输入输出数据
        int readflag = flag; // flag=0,train;flag=1,test

        String encoding = "GBK"; //编码格式"GBK"
        File file = new File(filepath);

        if (file.isFile() && file.exists()) { // 判断文件是否存在
            InputStreamReader read = new InputStreamReader(new FileInputStream( file ), encoding);// 考虑到编码格式
            BufferedReader bufferedReader = new BufferedReader(read);
            String lineTxt = null;

            while ((lineTxt = bufferedReader.readLine()) != null) {
                int in_number = 0;
                //将每一行的数据按','截取字符串
                String splits[] = lineTxt.split(sep); 
                if (readflag == 0) {
                    for (int i = 0; i < splits.length; i++)
                        try {
                            //对数据进行归一化处理
                            everylist.add(Normalize(Double.valueOf(splits[i]),nom_data[i][0],nom_data[i][1]));
                            in_number++;
                        } catch (Exception e) {
                            //outlist:存放输出数据的类型
                            if (!outlist.contains(splits[i]))
                                outlist.add(splits[i]); // 存放字符串形式的输出数据
                            //初始化[-,-,-,-,0.0,0.0,0.0]
                            for (int k = 0; k < type_num; k++) {
                                everylist.add(0.0);
                            }
                            // 0-3:四个属性   4-6:输出节点处理,进行one-hot编程 
                            // outlist.indexOf(splits[i]):获取第几位的不为空
                            // everylist 存放着[ 0 - 6 ] 位
                            everylist.set(in_number + outlist.indexOf(splits[i]),1.0);
                        }
                } else if (readflag == 1) {
                    for (int i = 0; i < splits.length; i++)
                        try {
                            everylist.add(Normalize(Double.valueOf(splits[i]),nom_data[i][0],nom_data[i][1]));
                            in_number++;
                        } catch (Exception e) {
                            checklist.add(splits[i]); // 存放字符串形式的输出数据
                        }
                }
                alllist.add(everylist); // 存放所有数据
                in_num = in_number;
                out_num = type_num;
                everylist = new ArrayList<Double>();
                everylist.clear();
            }
            bufferedReader.close();
        }
    }

    //向文件写入分类结果
    public void WriteFile(String filepath, ArrayList<ArrayList<Double>> list, int in_number,  ArrayList<String> resultlist) throws IOException{
        File file = new File(filepath);
        FileWriter fw = null;
        BufferedWriter writer = null;
        try {
            fw = new FileWriter(file);
            writer = new BufferedWriter(fw);
            for(int i=0;i<list.size();i++){
                for(int j=0;j<in_number;j++){
                    writer.write(list.get(i).get(j)+",");
                }
                writer.write(resultlist.get(i));
                writer.newLine();
            }
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            writer.close();
            fw.close();
        }
    }


    //学习样本归一化,找到输入样本数据的最大值和最小值
    public void NormalizeData(String filepath) throws IOException{
        //提前获得输入数据的个数   
        GetBeforIn(filepath);
        int flag=1;
        //nom_data存放输入节点的max和min   in_data_num:4
        nom_data = new double[in_data_num][2];
        String encoding = "GBK";
        File file = new File(filepath);
        if ( file.isFile() && file.exists() ) { // 判断文件是否存在
            InputStreamReader read = new InputStreamReader( new FileInputStream(file), encoding );// 考虑到编码格式
            BufferedReader bufferedReader = new BufferedReader(read);
            String lineTxt = null;
            while ((lineTxt = bufferedReader.readLine()) != null) {
                String splits[] = lineTxt.split(",");   // 按','截取字符串
                for (int i = 0; i < splits.length-1; i++){
                    if(flag==1){
                        nom_data[i][0]=Double.valueOf(splits[i]);
                        nom_data[i][1]=Double.valueOf(splits[i]);
                    }
                    else{
                        if(Double.valueOf(splits[i])>nom_data[i][0])
                            nom_data[i][0]=Double.valueOf(splits[i]);
                        if(Double.valueOf(splits[i])<nom_data[i][1])
                            nom_data[i][1]=Double.valueOf(splits[i]);
                    }
                }
                flag=0;
            }
            bufferedReader.close();
        }
    }

    //归一化前获得输入数据的个数
    public void GetBeforIn(String filepath) throws IOException{
        String encoding = "GBK";
        File file = new File(filepath);
        if (file.isFile() && file.exists()) { // 判断文件是否存在
            InputStreamReader read = new InputStreamReader(new FileInputStream(
                    file), encoding);// 考虑到编码格式
            //提前获得输入数据的个数
            BufferedReader beforeReader = new BufferedReader(read);
            String beforetext = beforeReader.readLine();
            String splits[] = beforetext.split(",");
            in_data_num = splits.length-1;
            beforeReader.close();
        }
    }

    //归一化公式 -- 用于读取文件中
    public double Normalize(double x, double max, double min){
        double y = 0.1+0.8*(x-min)/(max-min);
        return y;
    }
}

4.3 – Test.java 

import java.util.ArrayList;

public class Test {
    public static void main(String args[]) throws Exception {

        //alllist = 4 + 3 即输入和输出
        ArrayList<ArrayList<Double>> alllist = new ArrayList<ArrayList<Double>>(); // 存放所有数据
        ArrayList<String> outlist = new ArrayList<String>();  // 存放分类的字符串
        int in_num = 0, out_num = 0; // 输入输出数据的个数

        DataUtil dataUtil = new DataUtil(); // 初始化数据

        dataUtil.NormalizeData("F:\\实训\\code\\BPNN_three\\data\\train.txt");  //对数据进行归一化处理

        dataUtil.SetTypeNum(3); // 设置输出类型的数量
        dataUtil.ReadFile("F:\\实训\\code\\BPNN_three\\data\\train.txt", ",", 0);

        in_num = dataUtil.GetInNum();   // 获得输入数据的个数
        out_num = dataUtil.GetOutNum(); // 获得输出数据的个数(个数代表类型个数)
        alllist = dataUtil.GetList();   // 获得初始化后的数据

        outlist = dataUtil.GetOutList();
        //System.out.println(outlist);
        System.out.print("分类的类型：");
        for(int i =0 ;i<outlist.size();i++)
            System.out.print(outlist.get(i)+"  ");
        System.out.println();
        System.out.println("训练集的数量："+alllist.size());

        BPNN bpnn = new BPNN();
        // 训练
        System.out.println("Train Start!");
        System.out.println(".............");
        bpnn.Train(in_num, out_num, alllist);
        System.out.println("Train End!");

        // 测试
        DataUtil testUtil = new DataUtil();

        testUtil.NormalizeData("F:\\实训\\code\\BPNN_three\\data\\test.txt");

        testUtil.SetTypeNum(3); // 设置输出类型的数量
        testUtil.ReadFile("F:\\实训\\code\\BPNN_three\\data\\test.txt", ",", 1);

        ArrayList<ArrayList<Double>> testList = new ArrayList<ArrayList<Double>>();
        ArrayList<ArrayList<Double>> resultList = new ArrayList<ArrayList<Double>>();
        ArrayList<String> normallist = new ArrayList<String>(); // 存放测试集标准的输出字符串
        ArrayList<String> resultlist = new ArrayList<String>(); // 存放测试集计算后的输出字符串

        int right = 0;          // 分类正确的数量
        int type_num = 0;       // 类型的数量
        int all_num = 0;        //测试集的数量
        type_num = outlist.size();

        testList = testUtil.GetList();          // 获取测试数据
        normallist = testUtil.GetCheckList(); 

        //int errorcount = 0; // 分类错误的数量
        resultList = bpnn.ForeCast(testList);   // 测试
        all_num  = resultList.size();

        //resultList:[-,-,-] normallist:[-] outlist:[-,-,-]
        //System.out.println(resultList);
        //System.out.println(normallist);
        //System.out.println(outlist);

        //临时存放结果
        ArrayList<String> Temp = new ArrayList<String>();
        //resultList=[30][3] 这里的输出有问题？？？解决方式：增加一个临时存放结果的数组
        for (int i = 0; i < resultList.size(); i++) {
            String checkString = "unknow";
            for (int j = 0; j < type_num; j++) {
                //System.out.println(resultList.get(i).get(j));
                if( resultList.get(i).get(j) == 1.0 ){
                    //System.out.println(outlist.get(j));
                    checkString = outlist.get(j);
                    Temp.add(checkString);
                }
                else{
                    resultlist.add(checkString);
                }
            }

           /* if(checkString.equals("unknow"))
                errorcount++;*/

            //normallist.get(i)为实际的判定值
            if(checkString.equals(normallist.get(i)))
                right++;
        }
        //System.out.println(Temp);

        testUtil.WriteFile("F:\\实训\\code\\BPNN_three\\data\\result.txt",testList,in_num,Temp);

        System.out.println("测试集的数量："+ all_num );
        System.out.println("分类正确的数量："+ right );
        //System.out.println("分类正确的数量："+(new Double(right)).intValue());
        System.out.println("算法的分类正确率为："+  (new Double( (double) right/all_num )));
        System.out.println("分类结果存储在：F:\\实训\\code\\BPNN_three\\data\\result.txt");     

        //bpnn.GetError(1);

    }
}

（5）运行截图

1

2
…………………………………………….一共30组

（6）参考资料

1.原作者博客:http://blog.csdn.net/u010858605/article/details/72898178
2.数据集下载：http://archive.ics.uci.edu/ml/index.php
3.归一化处理：http://www.cnblogs.com/chaosimple/p/3227271.html
4.one-hot编程：http://www.cnblogs.com/daguankele/p/6595470.html
5.delta学习:http://blog.csdn.net/u012562273/article/details/56297648
6.机器学习之BP神经网络(三) : https://zhuanlan.zhihu.com/p/28993795

王嘉凡
关注
专栏目录
计算智能——BP神经网络和感知器的简单应用
zjn1174962912的博客
10-04 1155
文章目录BP神经网络神经网络基本原理1.人工神经元模型2.神经网络模型：前馈式3.神经网络训练过程4.神经网络算法 BP神经网络 神经网络基本原理 人工神经网络无需事先确定输入输出之间映射关系的数学方程，仅通过自身的训练，学习某种规则，在给定输入值时得到最接近期望输出值的结果。作为一种智能信息处理系统，人工神经网络实现其功能的核心是算法。BP神经网络是一种按误差反向传播(简称误差反传)训练的多层前...
利用Python写BP神经网络（一）：无偏置的BPNN
巴壁虎的专栏
05-22 1928
第一个最简单的BPNN：包括3个输入层节点，3个隐含层节点，1个输出层节点。学习样本为5个，每次都把5个学习样本都学习一遍，直到学习次数达到预设的次数。每次学习都记录下误差（或者叫损失）。为了简单，隐含层和输出层暂时不考虑偏置，等下一次再考虑。训练了1000次，误差在0.05多些，然后损失就下降得很慢了，估计增加偏置后会好些。import numpy as np # --------------...
计算智能 -- BP神经网络（1）
wjf_1997的博客
10-11 805
本文实现的是对张军等编写的《计算智能》第二章中的2.4.3引用举例的code实现。图一 图二 import java.util.Scanner;public class Bp { private int InputLayer = 3; //输入层 private int HiddenLayer = 2; //隐含层 private int Ou
python运行出现“ takes no arguments”错误原因
最新发布
li758568825的专栏
08-24 474
1.写成了。
takes no arguments 报错原因及解决
qq_45441438的博客
10-23 1万+
在_init_左右两边分别加一个“_”直接改成__init__，即可解决。_init_是错误的，__init__才是正确的，具体可参考下图。init前后都应该有2个如图的字符，而不是只有一个。原文：takes no arguments。
实验4 Bp算法实现
仙王狂虐战神
04-13 2259
参考代码在最低部 一、实验目的 通过分析Bp算法的原理，利用JAVA编程工具(或者其他编程工具)实现Bp算法，并通过对样本数据的监督学习过程，加深对反馈型神经网络算法的理解与应用过程。 二、实验内容 按照下面的要求操作，然后分析不同操作后网络输出结果。 可修改学习因子 可任意指定隐单元层数 可任意指定输入层、隐含层、输出层的单元数 可指定最大允许误差ε 可输入学习样本（增加样本） 可存储训练后的网络各神经元之间的连接权值矩阵； 修改训练后的BP神经网络部分连接权值，分析连接权值修改前和修改后对相同测试样本
计算智能-智能信息处理-实验一-基于BP神经网络的手写体数字识别设计
01-21
实验一“基于BP神经网络的手写体数字识别设计”旨在让学生深入理解并实践BP神经网络在解决实际问题中的应用，特别是手写数字的识别。BP神经网络，全称为反向传播神经网络，是由Rumelhart和McClelland等人提出的，它...
人工智能、优化算法、GA优化BP神经网络对比BP神经网络、回归预测
08-30
首先，BP神经网络是一种广泛使用的前馈神经网络，它通过反向传播误差来更新权重和阈值，从而学习输入和输出之间的复杂关系。然而，BP算法在训练过程中存在一个问题，即它可能会陷入局部最小值，导致模型性能受限。...
人工智能-基于BP神经网络实现曲面数据修补的方法研究.pdf
06-26
### 人工智能-基于BP神经网络实现曲面数据修补的方法研究 #### 一、研究背景与意义 随着数字化技术的发展，曲面数据修补成为了实现曲面模型重构的关键环节。尤其是在复杂曲面的逆向工程中，如何高效准确地修复缺失...
03-GA-BP神经网络-拟合_GA-BP_gabp_matlab_BPGA_
10-01
【标题】"03-GA-BP神经网络-拟合_GA-BP_gabp_matlab_BPGA_" 涉及的核心技术是遗传算法优化的反向传播（GA-BP）神经网络，这是一种结合了遗传算法（Genetic Algorithm, GA）与反向传播（Backpropagation, BP）算法的...
基于PSO-GA-BP神经网络的视觉伺服控制系统.pdf
09-25
本文提出了一种基于PSO-GA-BP神经网络的视觉伺服控制系统，旨在解决传统基于图像视觉伺服控制的缺陷，如计算雅可比矩阵和解雅克比矩阵的逆，结构复杂、计算量大且系统的实时性不够理想。 PSO-GA-BP神经网络是一种...
iris_classification_BPNeuralNetwork:Python 基于BP神经网络实现鸢尾花的分类
05-10
iris_classification_BPNeuralNetwork 本文用Python实现了BP神经网络分类算法，根据鸢尾花的4个特征，实现3种鸢尾花的分类。 算法参考文章： iris_data_classification_bpnn_V1.py 需使用 bpnn_V1数据集 文件夹中的数据 iris_data_classification_bpnn_V2.py 需使用 bpnn_V2数据集 文件夹中的数据 iris_data_classification_knn.py 需使用 原始数据集 文件夹中的数据 iris_data_cluster_sklearn.py 需使用 sklearn数据集 文件夹中的数据 不同数据集里数据都是一样的，只是为了程序使用方便而做了一些格式的变动。 2020.07.21更新： 增加了分类结果可视化result_visualiza
BP神经网络用于分类iris数据集
06-15
BP神经网络用于分类iris数据集，编程的思路不错，值得初学者学习。
多层神经网络BP算法 原理及推导
07-12 1133
　　首先什么是人工神经网络？简单来说就是将单个感知器作为一个神经网络节点，然后用此类节点组成一个层次网络结构，我们称此网络即为人工神经网络（本人自己的理解）。当网络的层次大于等于3层（输入层+隐藏层（大于等于1）+输出层）时，我们称之为多层人工神经网络。 1、神经单元的选择 　　那么我们应该使用什么样的感知器来作为神经网络节点呢？在上一篇文章我们介绍过感知器算法，但是直接使用的话会存...
Python 基于BP神经网络的鸢尾花分类
Michael的博客
12-27 4万+
本文用Python实现了BP神经网络分类算法，根据鸢尾花的4个特征，实现3种鸢尾花的分类。
计算智能——BP神经网络
qq_42678341的博客
09-30 1190
BP神经网络 BP神经网络是一种按照误差逆向传播算法训练的多层前馈神经网络，是目前应用最广泛的神经网络。BP网络是前向神经网络的核心部分，也是整个人工神经网络体系中的精华，广泛用于分类识别、逼近、回归、压缩等领域。在实际应用中，大约80%的神经网络模型采用了BP网络或BP网络的变化形式。 基本原理 BP神经网络是一种按误差反向传播(简称误差反传)训练的多层前馈网络，其算法称为BP算法，它的基...
BP神经网络（BPNN）
热门推荐
Cufewxy的博客
05-28 9万+
本文简要介绍BP神经网络（BPNN, Back Propagation Neural Network）的思想。BP神经网络是最基础的神经网络，结果采用前向传播，误差反向（Back Propagation）传播方式进行。BP神经网络是有监督学习，不妨想象这么一个应用场景：输入数据是很多银行用户的年龄、职业、收入等，输出数据是该用户借钱后是否还贷。作为银行风控部门的负责人，你希望建立一个神经网络模型，...
机器学习中的Logistic回归算法(LR)
More
07-15 6243
Logistic回归算法（LR）算法简介LR名为回归，实际是一种分类算法。其针对输入样本集xx，假设的输出结果 y=hθ(x)y=h_{\theta}(x) 的取值范围为 y=[0,1]y=[0,1] 。在线性回归中，hθ(x)=θTXh_{\theta}(x)=\theta^{T} X，在此引入Logistic函数，也被称为Sigmoid函数g(z)=11+e−zg(z)=\dfrac{1}{1+
Matlab源码：MPA-BP优化BP神经网络回归预测
2. **BP神经网络（反向传播神经网络）**：这是一种使用反向传播算法进行训练的多层前馈神经网络，能够实现从输入到输出的非线性映射。在本项目中，BP神经网络被用于多变量回归预测任务。 3. **MPA-BP海洋捕食者算法...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值