精华内容
下载资源
问答
  • 数据挖掘方法的人工神经网络是一种新的数学建模方式.传统方法对非线性数据的预测不易找到简单而有效的模型,神经网络的提出为处理非线性问题提供了比较好的方法.针对BP算法的局限性提出了改进的BP网络模型,通过对...
  • BP神经网络R实现 ##设置工作空间 #先用setwd设置工作空间,如D盘,并将相关数据拷贝到该目录下 setwd("D:/BP") #读入数据 Data=read.csv("D:/BP/data") #数据命名 library(nnet) colnames(Data) ###最终...

    BP神经网络R实现

    ##设置工作空间

    #先用setwd设置工作空间,如D盘,并将相关数据拷贝到该目录下
    setwd("D:/BP")
    #读入数据
    Data=read.csv("D:/BP/data")
    #数据命名
    library(nnet)
    colnames(Data)<-c("x1","x2","x3","y")
    ###最终模型
    model1=nnet(y~.,data=Data,size=6,decay=5e-4,maxit=1000)  


    pred=predict(model1,Data[,1:3],type="class")
    (P=sum(as.numeric(pred==Data$y))/nrow(Data))
    table(Data$y,pred)
    prop.table(table(Data$y,pred),1)
    展开全文
  • 介绍了数据挖掘的定义和常用方法,研究了基于遗传BP神经网络数据挖掘算法,并对其交叉算子进行了改进,提高算法训练速度。实验结果表明,将该方法应用于油气识别中,效果良好,具有一定的实际应用价值。
  • public class Test { public static void main(String args[]) throws Exception { ArrayList<ArrayList<Double>... // 存放所有数据 ArrayList<String> outlist = new ArrayLis..

    在这里插入图片描述

    
    public class Test {
        public static void main(String args[]) throws Exception {
    
            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("src/bp/train.txt");
    
            dataUtil.SetTypeNum(3); // 设置输出类型的数量
            dataUtil.ReadFile("src/bp/train.txt", ",", 0);
    
            in_num = dataUtil.GetInNum(); // 获得输入数据的个数
            out_num = dataUtil.GetOutNum(); // 获得输出数据的个数(个数代表类型个数)
            alllist = dataUtil.GetList(); // 获得初始化后的数据
    
            outlist = dataUtil.GetOutList();
            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("src/bp/test.txt");
    
            testUtil.SetTypeNum(3); // 设置输出类型的数量
            testUtil.ReadFile("src/bp/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>(); // 存放测试集计算后的输出字符串
    
            double right = 0; // 分类正确的数量
            int type_num = 0; // 类型的数量
            double all_num = 0; //测试集的数量
            type_num = outlist.size();
    
            testList = testUtil.GetList(); // 获取测试数据
            normallist = testUtil.GetCheckList();
    
            int errorcount=0; // 分类错误的数量
            resultList = bpnn.ForeCast(testList); // 测试
            all_num=resultList.size();
            for (int i = 0; i < resultList.size(); i++) {
                String checkString = "unknow";
                for (int j = 0; j < type_num; j++) {
                    if(resultList.get(i).get(j)==1.0){
                        checkString = outlist.get(j);
                        resultlist.add(checkString);
                    }
                    /*else{
                        resultlist.add(checkString);
                    }*/
                }
                /*
                if(checkString.equals("unknow"))
                    errorcount++;
                */
                if(checkString.equals(normallist.get(i)))
                    right++;
            }
    
    
            System.out.println("测试集的数量:"+ (new Double(all_num)).intValue());
            System.out.println("分类正确的数量:"+(new Double(right)).intValue());
            System.out.println("算法的分类正确率为:"+right/all_num);
    
            System.out.println("分类结果存储在:E:\\BP_data\\result.txt");
        }
    }
    
    
    package bp;
    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";
            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) {
                                if (!outlist.contains(splits[i]))
                                    outlist.add(splits[i]); // 存放字符串形式的输出数据
                                for (int k = 0; k < type_num; k++) {
                                    everylist.add(0.0);
                                }
    
                                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);
                System.out.println(resultlist.size());
                for(int i=0;i<resultlist.size()-1;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 = 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;
        }
    }
    
    
    
    
    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; // 每次迭代允许的误差
        private double ETA_W = 0.5; // 权值学习效率0.5
        private double ETA_T = 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(); // 比较创建存储每一层输出数据的数组
            out = new double[3][createsize];
    
            for (int iter = 0; iter < MaxTrain; iter++) {
                for (int cnd = 0; cnd < datanum; cnd++) {
                    // 第一层输入节点赋值
    
                    for (int i = 0; i < in_num; 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;
                    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++)
                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++)
                    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() {
            // 计算隐层节点的输出值
            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);
            }
            // 计算输出层节点的输出值
            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);
            }
        }
    
        // 误差反向传播
        public void Backward(int cnd) {
            CalcDelta(cnd); // 计算权值调整量
            UpdateNetWork(); // 更新BP神经网络的权值和阈值
        }
    
        // 计算delta调整量
        public void CalcDelta(int cnd) {
    
            int createsize = GetMaxNum(); // 比较创建数组
            delta = new double[3][createsize];
            // 计算输出层的delta值
            for (int i = 0; i < out_num; i++) {
                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]);
                }
                alloutlist.add(outlist);
                outlist = new ArrayList<Double>();
                outlist.clear();
            }
            return alloutlist;
        }
    
    }
    
    
    展开全文
  • nnet包提供了最常见的前馈反向传播神经网络算法,构建单隐层神经网络; AMORE包则进一步提供了更为丰富的控制参数,并可以增加多个隐层; neuralnet包的改进在于提供了弹性反向传播算法和更多的激活函数形式。 一、...

    R中关于神经网络的包:nnet、AMORE、neuralnet以及RSNNS
    nnet包提供了最常见的前馈反向传播神经网络算法,构建单隐层神经网络;
    AMORE包则进一步提供了更为丰富的控制参数,并可以增加多个隐层
    neuralnet包的改进在于提供了弹性反向传播算法和更多的激活函数形式。

    一、构建训练集与检验集

    data(iris)
    ind <- sample(2,nrow(iris),replace=T,prob=c(0.7,0.3)) 
    trainSet <- iris[ind==1,]
    testSet <- iris[ind==2,]
    

    二、nnet包的nnet函数

    nnet(traindata,trainlable,size,rang=0.1,decay=5e-4,maxit=300)
    #traindata:训练数据,注意这里的训练数据要去掉类标签
    #trainlable:类别
    #size:隐层神经元数目
    #rang:初始化权值会在-rang和rang之间选择
    #decay:权值衰减参数
    #maxit:最大迭代次数
    
    #生成类别的示性函数,把类别数值化才能计算误差(安装nnet包才有效)
    library(nnet)
    trainlable <- class.ind(trainSet$Species)
    testlable <- class.ind(testSet$Species)
    
    bpnet <- nnet(trainSet[,- 5],trainlable,size=3,rang=0.1,decay=5e-4,maxit=300)
    

    在这里插入图片描述

    输入层4个神经元(4个属性),隐层3个神经元,输出层3个神经元(3个类)

    在这里插入图片描述

    b:偏移(每个隐层结点有一个b,每个输出层结点有一个b)
    输入层:i1,i2,i3,i4
    隐层:h1,h2,h3
    输出层:o1,o2,o3
    权值

    #给出训练集分类结果
    trainpre<-predict(bpnet,trainSet[,-5])
    #给出检验集的分类结果
    testpre<-predict(bpnet,newdata=testSet[,-5])
    table(testSet$Species,apply(testpre,1,function(x){names(x)[which.max(x)]}))
    #左边的是行(真实类标签),右边是列(预测列标签)
    

    在这里插入图片描述
    在这里插入图片描述

    三、AMORE包

    应用AMORE包中的三个函数实现ANN构建:
    newff函数:实现构建ANN网络框架
    train函数:实现网络学习过程,即权值训练过程;
    sim函数:实现网络预测,对未知样本类别的推断。

    trainattri <- trainSet[,-5] #训练样本特征信息
    trainlabel <- trainSet[,5]  #训练样本类别信息
    T <- class.ind(trainlabel)  #示性函数
    
    netframe <- newff(n.neurons=c(dim(trainattri)[2],3,dim(T)[2]),# n.neurons:输入-隐层-输出层的神经元数目
    					learning.rate.global=1e-4, #学习速率
    					momentum.global=0.001, #动量因子
    					error.criterium="LMS",  #误差预测方法
    					Stao=NA,  #误差参数
    					hidden.layer="sigmoid", #隐层神经元激活函数 
    					output.layer="sigmoid",  #输出层神经元激活函数
    					method="ADAPTgdwm") #训练方法
    
    bpnet <- train(netframe, #由netff构建的网络(框架)
    				trainattri, #训练样本的特征信息
    				T, #训练样本的类别信息
    				error.criterium="LMS", 
    				report=T,n.shows=20,show.step=500)
    				#是否提供结果的图形信息或文字信息
    				#report=T的前提下,report的次数为20,每迭代500次报告一次(步长)
    				#训练总次数:n.shows*show.step
    
    testattri <- testSet[,-5]
    testlabel <- testSet[,5]
    
    testPre <- sim(bpnet$net,testattri)
                    #由train函数生成的训练好权值的ANN模型,bpnet不是sim的操作对象,而是bpnet中的元素net
    				#bpnet是一个list,bpnet$net即bpnet[[1]]
    				#待检测的样本(行为样本,列为特征信息)		
    
    展开全文
  • 神经网络进行数据分类,数据集是210条数据,每条数据包含8项内容:前7项是七个特征值,第8项是类别标号(取值:1、2、3)。该数据集中的每类数据各占三分之一。
  • 理解BP神经网络的前馈和反馈过程,并利用python实现一个AutoEncoder的神经网络(即输入等于输出的网络)【建议用矩阵的形式写】。 并利用sklearn包中的iris数据集来验证算法的准确性。 获取数据的方式为: from ...

    在这里插入图片描述

    实训题目:

    理解BP神经网络的前馈和反馈过程,并利用python实现一个AutoEncoder的神经网络(即输入等于输出的网络)【建议用矩阵的形式写】。

    并利用sklearn包中的iris数据集来验证算法的准确性。
    获取数据的方式为:
    from sklearn import datasets
    iris = datasets.load_iris()
    data = iris[‘data’]
    建议:算法参数包括隐藏层个数及每层的神经元的个数,学习率和迭代次数。
    激活函数用Tanh,数据要进行归一化处理,隐藏层数不宜过多。

    import numpy as np
    from sklearn import datasets
    from sklearn.preprocessing import MinMaxScaler
    
    #使用的数学函数
    def tanh(x):    
        return np.tanh(x)
    # tanh导函数
    def tanh_prime(x):      
        return 1.0 - tanh(x)**2
    
    #自编码器类
    class AE:
        def __init__(self, layers):
            self.activation = tanh
            self.activation_prime = tanh_prime
            self.weights = []
            # 初始化输入层和隐含层之间的权值
            for i in range(1, len(layers) - 1):
                r = 2*np.random.random((layers[i-1] + 1, layers[i] + 1)) -1
                self.weights.append(r)    
            # 初始化输出层权值
            r = 2*np.random.random( (layers[i] + 1, layers[i+1])) - 1         
            self.weights.append(r)
    
        def fit(self, X, Y, learning_rate=0.2, iterations=10000):
            X = np.hstack([np.ones((X.shape[0],1)),X])
            for k in range(iterations):
                i = np.random.randint(X.shape[0],high=None) 
                a = [X[i]]
                for l in range(len(self.weights)): 
                        dot_value = np.dot(a[l], self.weights[l])
                        activation = self.activation(dot_value)
                        a.append(activation)
                error = Y[i] - a[-1]
                deltas = [error * self.activation_prime(a[-1])]
                for l in range(len(a) - 2, 0, -1): 
                    deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_prime(a[l]))
                deltas.reverse()
                for i in range(len(self.weights)):
                    layer = np.atleast_2d(a[i])
                    delta = np.atleast_2d(deltas[i])
                    self.weights[i] += learning_rate * np.dot(layer.T, delta)
    
        def predict(self, x): 
            a = np.concatenate((np.ones(1), np.array(x)))
            for l in range(0, len(self.weights)):
                a = self.activation(np.dot(a, self.weights[l]))
            return a
    

    并利用sklearn包中的iris数据集来验证算法的准确性。

    #读取数据
    iris = datasets.load_iris()
    data = iris['data']
    min_max_scaler = MinMaxScaler()
    newdata = min_max_scaler.fit_transform(data)
    
    print("————————————————1个中间层————————————————")
    nn = AE([4,4,4])     # 4输入4输出,1个中间层(4个结点)
    nn.fit(newdata, newdata, 0.01, 50000) #学习率 0.01 , 迭代次数 50000
    for x in newdata:
        print("初始数据",x,"自编码后数据",nn.predict(x))
    
    ————————————————1个中间层————————————————
    初始数据 [0.22222222 0.625      0.06779661 0.04166667] 自编码后数据 [0.22735156 0.64396524 0.07139401 0.03898217]
    初始数据 [0.16666667 0.41666667 0.06779661 0.04166667] 自编码后数据 [0.12542281 0.45237477 0.07822221 0.02059593]
    初始数据 [0.11111111 0.5        0.05084746 0.04166667] 自编码后数据 [0.10063445 0.50684371 0.04776061 0.0339433 ]
    初始数据 [0.08333333 0.45833333 0.08474576 0.04166667] 自编码后数据 [0.08470202 0.46478568 0.05283872 0.03502866]
    初始数据 [0.19444444 0.66666667 0.06779661 0.04166667] 自编码后数据 [0.21885274 0.66505868 0.05755657 0.04598089]
    初始数据 [0.30555556 0.79166667 0.11864407 0.125     ] 自编码后数据 [0.31826637 0.74672126 0.11530296 0.12937576]
    初始数据 [0.08333333 0.58333333 0.06779661 0.08333333] 自编码后数据 [0.10354818 0.55888568 0.05442063 0.0883282 ]
    初始数据 [0.19444444 0.58333333 0.08474576 0.04166667] 自编码后数据 [0.20569673 0.60908458 0.07432611 0.03999921]
    初始数据 [0.02777778 0.375      0.06779661 0.04166667] 自编码后数据 [0.00259515 0.35176618 0.0334704  0.02208879]
    初始数据 [0.16666667 0.45833333 0.08474576 0.        ] 自编码后数据 [ 0.16442688  0.50861892  0.06705695 -0.0073099 ]
    初始数据 [0.30555556 0.70833333 0.08474576 0.04166667] 自编码后数据 [0.31161724 0.71420647 0.08536842 0.03594275]
    初始数据 [0.13888889 0.58333333 0.10169492 0.04166667] 自编码后数据 [0.17484955 0.59583311 0.06314123 0.04790602]
    初始数据 [0.13888889 0.41666667 0.06779661 0.        ] 自编码后数据 [ 0.11941281  0.4562334   0.05588101 -0.01251043]
    初始数据 [0.         0.41666667 0.01694915 0.        ] 自编码后数据 [-0.01555454  0.38332856 -0.00483548 -0.01286941]
    初始数据 [0.41666667 0.83333333 0.03389831 0.04166667] 自编码后数据 [0.37654393 0.7846429  0.07126538 0.02129237]
    初始数据 [0.38888889 1.         0.08474576 0.125     ] 自编码后数据 [0.38095406 0.83443355 0.07634159 0.12398266]
    初始数据 [0.30555556 0.79166667 0.05084746 0.125     ] 自编码后数据 [0.28611517 0.74106656 0.09675044 0.12277695]
    初始数据 [0.22222222 0.625      0.06779661 0.08333333] 自编码后数据 [0.21327098 0.63399658 0.08768652 0.07852549]
    初始数据 [0.38888889 0.75       0.11864407 0.08333333] 自编码后数据 [0.37754493 0.74232671 0.12865566 0.06953794]
    初始数据 [0.22222222 0.75       0.08474576 0.08333333] 自编码后数据 [0.2528033  0.714602   0.073887   0.09173684]
    初始数据 [0.30555556 0.58333333 0.11864407 0.04166667] 自编码后数据 [0.30577179 0.63813729 0.12158587 0.03001748]
    初始数据 [0.22222222 0.70833333 0.08474576 0.125     ] 自编码后数据 [0.22990482 0.68209936 0.09892936 0.13079891]
    初始数据 [0.08333333 0.66666667 0.         0.04166667] 自编码后数据 [0.11174209 0.62049109 0.01416072 0.05033305]
    初始数据 [0.22222222 0.54166667 0.11864407 0.16666667] 自编码后数据 [0.18941321 0.55714306 0.14670444 0.15906668]
    初始数据 [0.13888889 0.58333333 0.15254237 0.04166667] 自编码后数据 [0.20233244 0.60379218 0.0785444  0.05368182]
    初始数据 [0.19444444 0.41666667 0.10169492 0.04166667] 自编码后数据 [0.16833375 0.46791674 0.10061331 0.02295726]
    初始数据 [0.19444444 0.58333333 0.10169492 0.125     ] 自编码后数据 [0.18594346 0.5903608  0.11166992 0.12250704]
    初始数据 [0.25       0.625      0.08474576 0.04166667] 自编码后数据 [0.25597449 0.65246533 0.08474049 0.03730126]
    初始数据 [0.25       0.58333333 0.06779661 0.04166667] 自编码后数据 [0.23676663 0.62109505 0.08613262 0.03195143]
    初始数据 [0.11111111 0.5        0.10169492 0.04166667] 自编码后数据 [0.12902391 0.51736976 0.06361074 0.04083186]
    初始数据 [0.13888889 0.45833333 0.10169492 0.04166667] 自编码后数据 [0.13699883 0.48902928 0.07651709 0.03306009]
    初始数据 [0.30555556 0.58333333 0.08474576 0.125     ] 自编码后数据 [0.25774307 0.61656734 0.14092005 0.1071723 ]
    初始数据 [0.25       0.875      0.08474576 0.        ] 自编码后数据 [0.31821814 0.79174094 0.01614263 0.0123694 ]
    初始数据 [0.33333333 0.91666667 0.06779661 0.04166667] 自编码后数据 [0.3536472  0.81012533 0.03899854 0.04016876]
    初始数据 [0.16666667 0.45833333 0.08474576 0.04166667] 自编码后数据 [0.14863222 0.49545823 0.0801962  0.0284862 ]
    初始数据 [0.19444444 0.5        0.03389831 0.04166667] 自编码后数据 [0.15331727 0.53314312 0.06822591 0.02479639]
    初始数据 [0.33333333 0.625      0.05084746 0.04166667] 自编码后数据 [0.29692724 0.66587908 0.10002741 0.02363812]
    初始数据 [0.16666667 0.66666667 0.06779661 0.        ] 自编码后数据 [0.21372497 0.66810006 0.03380809 0.01107956]
    初始数据 [0.02777778 0.41666667 0.05084746 0.04166667] 自编码后数据 [0.00886332 0.39075951 0.02693966 0.02648738]
    初始数据 [0.22222222 0.58333333 0.08474576 0.04166667] 自编码后数据 [0.22584673 0.6163718  0.08281796 0.03688657]
    初始数据 [0.19444444 0.625      0.05084746 0.08333333] 自编码后数据 [0.18498848 0.62394212 0.07501294 0.07974003]
    初始数据 [0.05555556 0.125      0.05084746 0.08333333] 自编码后数据 [-0.09859155  0.05636961  0.04873416 -0.00160692]
    初始数据 [0.02777778 0.5        0.05084746 0.04166667] 自编码后数据 [0.04032116 0.47268388 0.02409017 0.03994104]
    初始数据 [0.19444444 0.625      0.10169492 0.20833333] 自编码后数据 [0.1699757  0.60242199 0.142987   0.21554021]
    初始数据 [0.22222222 0.75       0.15254237 0.125     ] 自编码后数据 [0.27302956 0.71428773 0.11151212 0.14218377]
    初始数据 [0.13888889 0.41666667 0.06779661 0.08333333] 自编码后数据 [0.08777932 0.42822682 0.08174191 0.05960583]
    初始数据 [0.22222222 0.75       0.10169492 0.04166667] 自编码后数据 [0.2736346  0.72423394 0.05977259 0.05189   ]
    初始数据 [0.08333333 0.5        0.06779661 0.04166667] 自编码后数据 [0.08957523 0.49987851 0.04472054 0.03847804]
    初始数据 [0.27777778 0.70833333 0.08474576 0.04166667] 自编码后数据 [0.29307578 0.70959891 0.07755298 0.03986917]
    初始数据 [0.19444444 0.54166667 0.06779661 0.04166667] 自编码后数据 [0.18478141 0.57394963 0.07441597 0.03373359]
    初始数据 [0.75       0.5        0.62711864 0.54166667] 自编码后数据 [0.71592323 0.51717729 0.68526008 0.56465637]
    初始数据 [0.58333333 0.5        0.59322034 0.58333333] 自编码后数据 [0.59260749 0.52857129 0.63247371 0.62694233]
    初始数据 [0.72222222 0.45833333 0.66101695 0.58333333] 自编码后数据 [0.70557007 0.47714633 0.70485678 0.6113184 ]
    初始数据 [0.33333333 0.125      0.50847458 0.5       ] 自编码后数据 [0.31583199 0.10190303 0.51209822 0.50791703]
    初始数据 [0.61111111 0.33333333 0.61016949 0.58333333] 自编码后数据 [0.60871358 0.35700014 0.66834519 0.60660601]
    初始数据 [0.38888889 0.33333333 0.59322034 0.5       ] 自编码后数据 [0.45713007 0.35749003 0.55429581 0.54724606]
    初始数据 [0.55555556 0.54166667 0.62711864 0.625     ] 自编码后数据 [0.58258737 0.56207849 0.64246095 0.67626941]
    初始数据 [0.16666667 0.16666667 0.38983051 0.375     ] 自编码后数据 [0.13255021 0.13698589 0.33791625 0.37278063]
    初始数据 [0.63888889 0.375      0.61016949 0.5       ] 自编码后数据 [0.65246159 0.40519572 0.65062525 0.52056241]
    初始数据 [0.25       0.29166667 0.49152542 0.54166667] 自编码后数据 [0.24383351 0.28940863 0.47152506 0.58428389]
    初始数据 [0.19444444 0.         0.42372881 0.375     ] 自编码后数据 [ 0.14259317 -0.05987761  0.37557557  0.34042074]
    初始数据 [0.44444444 0.41666667 0.54237288 0.58333333] 自编码后数据 [0.45163507 0.44741276 0.5728115  0.62830383]
    初始数据 [0.47222222 0.08333333 0.50847458 0.375     ] 自编码后数据 [0.48566331 0.06675926 0.5480308  0.34590183]
    初始数据 [0.5        0.375      0.62711864 0.54166667] 自编码后数据 [0.55543613 0.40338765 0.61880086 0.58602942]
    初始数据 [0.36111111 0.375      0.44067797 0.5       ] 自编码后数据 [0.33989178 0.40175294 0.47380721 0.53511047]
    初始数据 [0.66666667 0.45833333 0.57627119 0.54166667] 自编码后数据 [0.64654026 0.48995818 0.64820041 0.56713984]
    初始数据 [0.36111111 0.41666667 0.59322034 0.58333333] 自编码后数据 [0.41559245 0.43980089 0.56164246 0.64353351]
    初始数据 [0.41666667 0.29166667 0.52542373 0.375     ] 自编码后数据 [0.47684083 0.32621538 0.50401604 0.38891206]
    初始数据 [0.52777778 0.08333333 0.59322034 0.58333333] 自编码后数据 [0.51099641 0.04669354 0.65520729 0.58011229]
    初始数据 [0.36111111 0.20833333 0.49152542 0.41666667] 自编码后数据 [0.37774293 0.21711219 0.48560239 0.4252587 ]
    初始数据 [0.44444444 0.5        0.6440678  0.70833333] 自编码后数据 [0.48162999 0.51956772 0.64118672 0.75042317]
    初始数据 [0.5        0.33333333 0.50847458 0.5       ] 自编码后数据 [0.49407402 0.36778487 0.56403345 0.52161534]
    初始数据 [0.55555556 0.20833333 0.66101695 0.58333333] 自编码后数据 [0.58691258 0.20201064 0.67977847 0.60385246]
    初始数据 [0.5        0.33333333 0.62711864 0.45833333] 自编码后数据 [0.57815802 0.36207603 0.60025835 0.4915619 ]
    初始数据 [0.58333333 0.375      0.55932203 0.5       ] 自编码后数据 [0.59019073 0.41130834 0.61183696 0.52241976]
    初始数据 [0.63888889 0.41666667 0.57627119 0.54166667] 自编码后数据 [0.62699279 0.45025484 0.64446993 0.56636598]
    初始数据 [0.69444444 0.33333333 0.6440678  0.54166667] 自编码后数据 [0.68788247 0.35284712 0.69625925 0.55679697]
    初始数据 [0.66666667 0.41666667 0.6779661  0.66666667] 自编码后数据 [0.66064425 0.43659031 0.71983858 0.69236967]
    初始数据 [0.47222222 0.375      0.59322034 0.58333333] 自编码后数据 [0.50029357 0.40291006 0.60752865 0.62620109]
    初始数据 [0.38888889 0.25       0.42372881 0.375     ] 自编码后数据 [0.3790841  0.27765099 0.45003111 0.37091442]
    初始数据 [0.33333333 0.16666667 0.47457627 0.41666667] 自编码后数据 [0.33282533 0.16230093 0.46881165 0.41839899]
    初始数据 [0.33333333 0.16666667 0.45762712 0.375     ] 自编码后数据 [0.33771584 0.16744381 0.44882322 0.36867016]
    初始数据 [0.41666667 0.29166667 0.49152542 0.45833333] 自编码后数据 [0.42362537 0.31879166 0.51390835 0.47827925]
    初始数据 [0.47222222 0.29166667 0.69491525 0.625     ] 自编码后数据 [0.53890892 0.29907958 0.66527992 0.66612442]
    初始数据 [0.30555556 0.41666667 0.59322034 0.58333333] 自编码后数据 [0.36913177 0.43393158 0.54089435 0.64933848]
    初始数据 [0.47222222 0.58333333 0.59322034 0.625     ] 自编码后数据 [0.5087773  0.59722079 0.5972756  0.68628335]
    初始数据 [0.66666667 0.45833333 0.62711864 0.58333333] 自编码后数据 [0.65993279 0.48398713 0.67734024 0.61531229]
    初始数据 [0.55555556 0.125      0.57627119 0.5       ] 自编码后数据 [0.55642075 0.10721063 0.63670291 0.49343506]
    初始数据 [0.36111111 0.41666667 0.52542373 0.5       ] 自编码后数据 [0.40231431 0.44648264 0.50550101 0.55292611]
    初始数据 [0.33333333 0.20833333 0.50847458 0.5       ] 自编码后数据 [0.33104672 0.20608697 0.50581115 0.52231593]
    初始数据 [0.33333333 0.25       0.57627119 0.45833333] 自编码后数据 [0.40200904 0.25911518 0.51977829 0.49474989]
    初始数据 [0.5        0.41666667 0.61016949 0.54166667] 自编码后数据 [0.54946744 0.44858202 0.60718213 0.58902679]
    初始数据 [0.41666667 0.25       0.50847458 0.45833333] 自编码后数据 [0.42883694 0.2684601  0.52596522 0.47436122]
    初始数据 [0.19444444 0.125      0.38983051 0.375     ] 自编码后数据 [0.14754409 0.09217998 0.35261678 0.36158739]
    初始数据 [0.36111111 0.29166667 0.54237288 0.5       ] 自编码后数据 [0.39378533 0.30873483 0.52542593 0.53749124]
    初始数据 [0.38888889 0.41666667 0.54237288 0.45833333] 自编码后数据 [0.45078784 0.45251424 0.50934112 0.50699146]
    初始数据 [0.38888889 0.375      0.54237288 0.5       ] 自编码后数据 [0.43010184 0.40518981 0.52829424 0.54610297]
    初始数据 [0.52777778 0.375      0.55932203 0.5       ] 自编码后数据 [0.55030098 0.41108595 0.59063298 0.5301845 ]
    初始数据 [0.22222222 0.20833333 0.33898305 0.41666667] 自编码后数据 [0.14142564 0.18913556 0.35144779 0.41288468]
    初始数据 [0.38888889 0.33333333 0.52542373 0.5       ] 自编码后数据 [0.41290525 0.35959512 0.52553965 0.53788986]
    初始数据 [0.55555556 0.54166667 0.84745763 1.        ] 自编码后数据 [0.58890132 0.53625763 0.78964837 0.89334551]
    初始数据 [0.41666667 0.29166667 0.69491525 0.75      ] 自编码后数据 [0.44986454 0.29422535 0.67681714 0.76628103]
    初始数据 [0.77777778 0.41666667 0.83050847 0.83333333] 自编码后数据 [0.74507898 0.41402998 0.81816122 0.80883967]
    初始数据 [0.55555556 0.375      0.77966102 0.70833333] 自编码后数据 [0.62700084 0.38451784 0.73190454 0.74142179]
    初始数据 [0.61111111 0.41666667 0.81355932 0.875     ] 自编码后数据 [0.63626758 0.42176195 0.78464839 0.83933948]
    初始数据 [0.91666667 0.41666667 0.94915254 0.83333333] 自编码后数据 [0.82930019 0.39917673 0.85933006 0.80533689]
    初始数据 [0.16666667 0.20833333 0.59322034 0.66666667] 自编码后数据 [0.17388238 0.17786989 0.52824748 0.70431223]
    初始数据 [0.83333333 0.375      0.89830508 0.70833333] 自编码后数据 [0.80655131 0.36494422 0.82189408 0.72367089]
    初始数据 [0.66666667 0.20833333 0.81355932 0.70833333] 自编码后数据 [0.69864383 0.18282276 0.78357684 0.71876898]
    初始数据 [0.80555556 0.66666667 0.86440678 1.        ] 自编码后数据 [0.74403575 0.6222157  0.83514164 0.88772196]
    初始数据 [0.61111111 0.5        0.69491525 0.79166667] 自编码后数据 [0.6050297  0.51663638 0.72984918 0.79434734]
    初始数据 [0.58333333 0.29166667 0.72881356 0.75      ] 自编码后数据 [0.60029321 0.29336489 0.74036201 0.75642839]
    初始数据 [0.69444444 0.41666667 0.76271186 0.83333333] 自编码后数据 [0.67417044 0.42531814 0.78507863 0.81060608]
    初始数据 [0.38888889 0.20833333 0.6779661  0.79166667] 自编码后数据 [0.38684158 0.19429583 0.67608984 0.78476731]
    初始数据 [0.41666667 0.33333333 0.69491525 0.95833333] 自编码后数据 [0.37750453 0.33584627 0.71823105 0.870754  ]
    初始数据 [0.58333333 0.5        0.72881356 0.91666667] 自编码后数据 [0.56657541 0.51152081 0.7568154  0.85835599]
    初始数据 [0.61111111 0.41666667 0.76271186 0.70833333] 自编码后数据 [0.65639805 0.42928902 0.73876281 0.73837229]
    初始数据 [0.94444444 0.75       0.96610169 0.875     ] 自编码后数据 [0.83805782 0.64899001 0.8462097  0.83909628]
    初始数据 [0.94444444 0.25       1.         0.91666667] 自编码后数据 [0.8325667  0.22436288 0.8868384  0.83961   ]
    初始数据 [0.47222222 0.08333333 0.6779661  0.58333333] 自编码后数据 [0.51974742 0.03766218 0.66668257 0.59797999]
    初始数据 [0.72222222 0.5        0.79661017 0.91666667] 自编码后数据 [0.68873545 0.50098364 0.80662838 0.85430234]
    初始数据 [0.36111111 0.33333333 0.66101695 0.79166667] 自编码后数据 [0.37003063 0.33881394 0.65409501 0.79613397]
    初始数据 [0.94444444 0.33333333 0.96610169 0.79166667] 自编码后数据 [0.84229867 0.31935376 0.86296297 0.77425446]
    初始数据 [0.55555556 0.29166667 0.66101695 0.70833333] 自编码后数据 [0.5548236  0.30082256 0.70151963 0.72260098]
    初始数据 [0.66666667 0.54166667 0.79661017 0.83333333] 自编码后数据 [0.6793877  0.54162877 0.7763934  0.82190248]
    初始数据 [0.80555556 0.5        0.84745763 0.70833333] 自编码后数据 [0.78569194 0.48914977 0.79667351 0.7317955 ]
    初始数据 [0.52777778 0.33333333 0.6440678  0.70833333] 自编码后数据 [0.52774417 0.3503419  0.68329719 0.72762428]
    初始数据 [0.5        0.41666667 0.66101695 0.70833333] 自编码后数据 [0.52525168 0.43917572 0.67280178 0.73966617]
    初始数据 [0.58333333 0.33333333 0.77966102 0.83333333] 自编码后数据 [0.60608743 0.33535131 0.76755611 0.81359782]
    初始数据 [0.80555556 0.41666667 0.81355932 0.625     ] 自编码后数据 [0.78675521 0.41526261 0.77966679 0.65155992]
    初始数据 [0.86111111 0.33333333 0.86440678 0.75      ] 自编码后数据 [0.79990404 0.32317796 0.83086458 0.74613047]
    初始数据 [1.         0.75       0.91525424 0.79166667] 自编码后数据 [0.84918326 0.64564515 0.8300086  0.78729307]
    初始数据 [0.58333333 0.33333333 0.77966102 0.875     ] 自编码后数据 [0.59335608 0.33462042 0.77461192 0.83415932]
    初始数据 [0.55555556 0.33333333 0.69491525 0.58333333] 自编码后数据 [0.6158385  0.34931781 0.67906768 0.62326711]
    初始数据 [0.5        0.25       0.77966102 0.54166667] 自编码后数据 [0.62852368 0.24385417 0.68808798 0.58913372]
    初始数据 [0.94444444 0.41666667 0.86440678 0.91666667] 自编码后数据 [0.80704848 0.40354956 0.8628586  0.84076964]
    初始数据 [0.55555556 0.58333333 0.77966102 0.95833333] 自编码后数据 [0.56873067 0.57903283 0.76393505 0.88009114]
    初始数据 [0.58333333 0.45833333 0.76271186 0.70833333] 自编码后数据 [0.64165811 0.47225262 0.72690182 0.74445792]
    初始数据 [0.47222222 0.41666667 0.6440678  0.70833333] 自编码后数据 [0.49352713 0.43929723 0.65775075 0.74052675]
    初始数据 [0.72222222 0.45833333 0.74576271 0.83333333] 自编码后数据 [0.68463921 0.46777003 0.78422492 0.81021537]
    初始数据 [0.66666667 0.45833333 0.77966102 0.95833333] 自编码后数据 [0.63439061 0.46447708 0.79950569 0.87022084]
    初始数据 [0.72222222 0.45833333 0.69491525 0.91666667] 自编码后数据 [0.63947928 0.47280762 0.78608154 0.84744611]
    初始数据 [0.41666667 0.29166667 0.69491525 0.75      ] 自编码后数据 [0.44986454 0.29422535 0.67681714 0.76628103]
    初始数据 [0.69444444 0.5        0.83050847 0.91666667] 自编码后数据 [0.68798011 0.49846541 0.80808806 0.85729118]
    初始数据 [0.66666667 0.54166667 0.79661017 1.        ] 自编码后数据 [0.6362761  0.53909849 0.80338856 0.88752216]
    初始数据 [0.66666667 0.41666667 0.71186441 0.91666667] 自编码后数据 [0.60879257 0.43059989 0.77958639 0.84907329]
    初始数据 [0.55555556 0.20833333 0.6779661  0.75      ] 自编码后数据 [0.54251709 0.1969185  0.72208687 0.7461386 ]
    初始数据 [0.61111111 0.41666667 0.71186441 0.79166667] 自编码后数据 [0.60795141 0.43350605 0.74199456 0.7896098 ]
    初始数据 [0.52777778 0.58333333 0.74576271 0.91666667] 自编码后数据 [0.54354745 0.58256551 0.74054767 0.86563689]
    初始数据 [0.44444444 0.41666667 0.69491525 0.70833333] 自编码后数据 [0.50265632 0.43551742 0.66616813 0.7474928 ]
    
    print("————————————————2个中间层————————————————")
    nn = AE([4,4,4,4])     # 4输入4输出,2个中间层(每层4个结点)
    nn.fit(newdata, newdata, 0.01, 50000) #学习率 0.01 , 迭代次数 50000
    for x in newdata:
        print("初始数据",x,"自编码后数据",nn.predict(x))
    
    ————————————————2个中间层————————————————
    初始数据 [0.22222222 0.625      0.06779661 0.04166667] 自编码后数据 [0.21726453 0.65233743 0.05798185 0.03995504]
    初始数据 [0.16666667 0.41666667 0.06779661 0.04166667] 自编码后数据 [0.15668245 0.47636593 0.0876436  0.027529  ]
    初始数据 [0.11111111 0.5        0.05084746 0.04166667] 自编码后数据 [0.09411234 0.54685261 0.06167697 0.0395439 ]
    初始数据 [0.08333333 0.45833333 0.08474576 0.04166667] 自编码后数据 [0.07560961 0.50080474 0.08762399 0.05605771]
    初始数据 [0.19444444 0.66666667 0.06779661 0.04166667] 自编码后数据 [0.19118632 0.67672158 0.04964947 0.0479709 ]
    初始数据 [0.30555556 0.79166667 0.11864407 0.125     ] 自编码后数据 [0.30758742 0.73177535 0.11207204 0.09878124]
    初始数据 [0.08333333 0.58333333 0.06779661 0.08333333] 自编码后数据 [0.07087588 0.58949046 0.07520098 0.07478647]
    初始数据 [0.19444444 0.58333333 0.08474576 0.04166667] 自编码后数据 [0.19861173 0.61466807 0.07283511 0.04624075]
    初始数据 [0.02777778 0.375      0.06779661 0.04166667] 自编码后数据 [-0.00452989  0.42288972  0.08687381  0.0527269 ]
    初始数据 [0.16666667 0.45833333 0.08474576 0.        ] 自编码后数据 [0.17360694 0.52419745 0.07078833 0.01894753]
    初始数据 [0.30555556 0.70833333 0.08474576 0.04166667] 自编码后数据 [0.29757846 0.71279081 0.06440832 0.04696504]
    初始数据 [0.13888889 0.58333333 0.10169492 0.04166667] 自编码后数据 [0.15116549 0.60315882 0.07904136 0.06102048]
    初始数据 [0.13888889 0.41666667 0.06779661 0.        ] 自编码后数据 [0.13482076 0.48779579 0.06545715 0.01195864]
    初始数据 [0.         0.41666667 0.01694915 0.        ] 自编码后数据 [-0.04122487  0.48268759  0.02921795  0.01807603]
    初始数据 [0.41666667 0.83333333 0.03389831 0.04166667] 自编码后数据 [0.35171947 0.80058639 0.05156757 0.05595504]
    初始数据 [0.38888889 1.         0.08474576 0.125     ] 自编码后数据 [0.34538471 0.83825646 0.10418032 0.1269381 ]
    初始数据 [0.30555556 0.79166667 0.05084746 0.125     ] 自编码后数据 [0.27284547 0.74702231 0.07587525 0.07938771]
    初始数据 [0.22222222 0.625      0.06779661 0.08333333] 自编码后数据 [0.2125481  0.63969517 0.07850213 0.05784795]
    初始数据 [0.38888889 0.75       0.11864407 0.08333333] 自编码后数据 [0.37593921 0.72839131 0.10571117 0.0705682 ]
    初始数据 [0.22222222 0.75       0.08474576 0.08333333] 自编码后数据 [0.22157633 0.7156269  0.06976792 0.0750168 ]
    初始数据 [0.30555556 0.58333333 0.11864407 0.04166667] 自编码后数据 [0.31741856 0.61921363 0.10035278 0.0420408 ]
    初始数据 [0.22222222 0.70833333 0.08474576 0.125     ] 自编码后数据 [0.2176891  0.67905201 0.09564579 0.08820892]
    初始数据 [0.08333333 0.66666667 0.         0.04166667] 自编码后数据 [4.80397273e-02 6.77085839e-01 2.65824930e-05 3.67485196e-02]
    初始数据 [0.22222222 0.54166667 0.11864407 0.16666667] 自编码后数据 [0.22377763 0.5402956  0.16914268 0.11836079]
    初始数据 [0.13888889 0.58333333 0.15254237 0.04166667] 自编码后数据 [0.17400565 0.59120621 0.10894837 0.0807518 ]
    初始数据 [0.19444444 0.41666667 0.10169492 0.04166667] 自编码后数据 [0.20049953 0.47199424 0.10864686 0.03635611]
    初始数据 [0.19444444 0.58333333 0.10169492 0.125     ] 自编码后数据 [0.19573217 0.58488754 0.12643114 0.09349218]
    初始数据 [0.25       0.625      0.08474576 0.04166667] 自编码后数据 [0.25123609 0.65162423 0.07012736 0.04235863]
    初始数据 [0.25       0.58333333 0.06779661 0.04166667] 自编码后数据 [0.24371593 0.62549428 0.06619109 0.03105309]
    初始数据 [0.11111111 0.5        0.10169492 0.04166667] 自编码后数据 [0.116879   0.53528691 0.09222275 0.06085164]
    初始数据 [0.13888889 0.45833333 0.10169492 0.04166667] 自编码后数据 [0.14365994 0.5038995  0.1005479  0.05264831]
    初始数据 [0.30555556 0.58333333 0.08474576 0.125     ] 自编码后数据 [0.29466801 0.60254442 0.12443228 0.06928308]
    初始数据 [0.25       0.875      0.08474576 0.        ] 自编码后数据 [0.25031415 0.80061347 0.04024526 0.07477363]
    初始数据 [0.33333333 0.91666667 0.06779661 0.04166667] 自编码后数据 [0.3024392  0.82051933 0.06047425 0.0889978 ]
    初始数据 [0.16666667 0.45833333 0.08474576 0.04166667] 自编码后数据 [0.16621676 0.51046009 0.09192513 0.03986343]
    初始数据 [0.19444444 0.5        0.03389831 0.04166667] 自编码后数据 [0.17326654 0.56081856 0.05536698 0.01696653]
    初始数据 [0.33333333 0.625      0.05084746 0.04166667] 自编码后数据 [0.30863579 0.66921133 0.05578289 0.01806727]
    初始数据 [0.16666667 0.66666667 0.06779661 0.        ] 自编码后数据 [0.17000617 0.68533886 0.0290628  0.03612333]
    初始数据 [0.02777778 0.41666667 0.05084746 0.04166667] 自编码后数据 [-0.00561205  0.46430393  0.07146704  0.04904893]
    初始数据 [0.22222222 0.58333333 0.08474576 0.04166667] 自编码后数据 [0.22547737 0.61811064 0.07470186 0.04200522]
    初始数据 [0.19444444 0.625      0.05084746 0.08333333] 自编码后数据 [0.17720172 0.6400374  0.06595015 0.05507019]
    初始数据 [0.05555556 0.125      0.05084746 0.08333333] 自编码后数据 [-0.03711396  0.13786725  0.09652923  0.00726155]
    初始数据 [0.02777778 0.5        0.05084746 0.04166667] 自编码后数据 [0.00366667 0.53493119 0.05666029 0.05365065]
    初始数据 [0.19444444 0.625      0.10169492 0.20833333] 自编码后数据 [0.18740818 0.59039727 0.16467693 0.13936794]
    初始数据 [0.22222222 0.75       0.15254237 0.125     ] 自编码后数据 [0.25248447 0.68848069 0.12782615 0.11355167]
    初始数据 [0.13888889 0.41666667 0.06779661 0.08333333] 自编码后数据 [0.11769023 0.46000849 0.1081876  0.0566429 ]
    初始数据 [0.22222222 0.75       0.10169492 0.04166667] 自编码后数据 [0.2335394  0.72276159 0.06100449 0.06569475]
    初始数据 [0.08333333 0.5        0.06779661 0.04166667] 自编码后数据 [0.07191371 0.53918177 0.07034642 0.05151371]
    初始数据 [0.27777778 0.70833333 0.08474576 0.04166667] 自编码后数据 [0.27408263 0.70950642 0.06184292 0.04987302]
    初始数据 [0.19444444 0.54166667 0.06779661 0.04166667] 自编码后数据 [0.18993917 0.58685821 0.06955197 0.03566855]
    初始数据 [0.75       0.5        0.62711864 0.54166667] 自编码后数据 [0.71948843 0.47592405 0.64839476 0.56215552]
    初始数据 [0.58333333 0.5        0.59322034 0.58333333] 自编码后数据 [0.62502168 0.46145985 0.6368782  0.58785821]
    初始数据 [0.72222222 0.45833333 0.66101695 0.58333333] 自编码后数据 [0.70462416 0.45063204 0.671522   0.61215094]
    初始数据 [0.33333333 0.125      0.50847458 0.5       ] 自编码后数据 [0.2736934  0.10527914 0.48353816 0.49588982]
    初始数据 [0.61111111 0.33333333 0.61016949 0.58333333] 自编码后数据 [0.61258881 0.33816155 0.63152124 0.60017374]
    初始数据 [0.38888889 0.33333333 0.59322034 0.5       ] 自编码后数据 [0.43238625 0.32378112 0.55019762 0.52853986]
    初始数据 [0.55555556 0.54166667 0.62711864 0.625     ] 自编码后数据 [0.61747196 0.48799812 0.66404693 0.63049441]
    初始数据 [0.16666667 0.16666667 0.38983051 0.375     ] 自编码后数据 [0.0906137  0.13874464 0.37119407 0.36399229]
    初始数据 [0.63888889 0.375      0.61016949 0.5       ] 自编码后数据 [0.64600991 0.37425512 0.59549578 0.5195453 ]
    初始数据 [0.25       0.29166667 0.49152542 0.54166667] 自编码后数据 [0.22177741 0.2532313  0.51908019 0.54926519]
    初始数据 [0.19444444 0.         0.42372881 0.375     ] 自编码后数据 [ 0.05715311 -0.04866673  0.33461618  0.3281274 ]
    初始数据 [0.44444444 0.41666667 0.54237288 0.58333333] 自编码后数据 [0.48789828 0.38079867 0.59668811 0.5818023 ]
    初始数据 [0.47222222 0.08333333 0.50847458 0.375     ] 自编码后数据 [0.45249252 0.06162193 0.41475745 0.32652834]
    初始数据 [0.5        0.375      0.62711864 0.54166667] 自编码后数据 [0.54672801 0.36980787 0.60230276 0.5696909 ]
    初始数据 [0.36111111 0.375      0.44067797 0.5       ] 自编码后数据 [0.38554652 0.33529324 0.50692614 0.48024433]
    初始数据 [0.66666667 0.45833333 0.57627119 0.54166667] 自编码后数据 [0.66741962 0.4361337  0.6202736  0.54604911]
    初始数据 [0.36111111 0.41666667 0.59322034 0.58333333] 自编码后数据 [0.41538291 0.37682304 0.59673289 0.60110835]
    初始数据 [0.41666667 0.29166667 0.52542373 0.375     ] 自编码后数据 [0.45912842 0.28968239 0.46386951 0.3852091 ]
    初始数据 [0.52777778 0.08333333 0.59322034 0.58333333] 自编码后数据 [0.46976322 0.07453916 0.56925359 0.58393217]
    初始数据 [0.36111111 0.20833333 0.49152542 0.41666667] 自编码后数据 [0.36148937 0.19978627 0.45448448 0.4114701 ]
    初始数据 [0.44444444 0.5        0.6440678  0.70833333] 自编码后数据 [0.51343064 0.44454766 0.68997517 0.70784347]
    初始数据 [0.5        0.33333333 0.50847458 0.5       ] 自编码后数据 [0.52194533 0.31825012 0.54254016 0.49102325]
    初始数据 [0.55555556 0.20833333 0.66101695 0.58333333] 自编码后数据 [0.54578644 0.23299708 0.6192812  0.61672625]
    初始数据 [0.5        0.33333333 0.62711864 0.45833333] 自编码后数据 [0.54667149 0.33893511 0.55370355 0.49252821]
    初始数据 [0.58333333 0.375      0.55932203 0.5       ] 自编码后数据 [0.60328021 0.36497183 0.57363899 0.50402549]
    初始数据 [0.63888889 0.41666667 0.57627119 0.54166667] 自编码后数据 [0.64517896 0.40260596 0.61283641 0.54748406]
    初始数据 [0.69444444 0.33333333 0.6440678  0.54166667] 自编码后数据 [0.67171447 0.34583397 0.62928104 0.56952153]
    初始数据 [0.66666667 0.41666667 0.6779661  0.66666667] 自编码后数据 [0.66574526 0.42218415 0.70587844 0.69056244]
    初始数据 [0.47222222 0.375      0.59322034 0.58333333] 自编码后数据 [0.51109935 0.35982824 0.61115569 0.59846178]
    初始数据 [0.38888889 0.25       0.42372881 0.375     ] 自编码后数据 [0.40230662 0.2366857  0.42263224 0.34668823]
    初始数据 [0.33333333 0.16666667 0.47457627 0.41666667] 自编码后数据 [0.31094296 0.15290739 0.43733727 0.4039913 ]
    初始数据 [0.33333333 0.16666667 0.45762712 0.375     ] 自编码后数据 [0.32013002 0.15472031 0.40995744 0.35603445]
    初始数据 [0.41666667 0.29166667 0.49152542 0.45833333] 自编码后数据 [0.43786075 0.27794524 0.49807637 0.45156663]
    初始数据 [0.47222222 0.29166667 0.69491525 0.625     ] 自编码后数据 [0.49464343 0.31192885 0.64993113 0.66824717]
    初始数据 [0.30555556 0.41666667 0.59322034 0.58333333] 自编码后数据 [0.35344065 0.36788874 0.58754801 0.60427314]
    初始数据 [0.47222222 0.58333333 0.59322034 0.625     ] 自编码后数据 [0.56007377 0.49810666 0.64323744 0.61658114]
    初始数据 [0.66666667 0.45833333 0.62711864 0.58333333] 自编码后数据 [0.67229514 0.44295249 0.65538056 0.60097073]
    初始数据 [0.55555556 0.125      0.57627119 0.5       ] 自编码后数据 [0.52479011 0.11906841 0.52955606 0.49136502]
    初始数据 [0.36111111 0.41666667 0.52542373 0.5       ] 自编码后数据 [0.41720054 0.3763479  0.53467579 0.5064222 ]
    初始数据 [0.33333333 0.20833333 0.50847458 0.5       ] 自编码后数据 [0.30869043 0.1927966  0.50109661 0.5039786 ]
    初始数据 [0.33333333 0.25       0.57627119 0.45833333] 自编码后数据 [0.34772824 0.24826297 0.50422595 0.4883171 ]
    初始数据 [0.5        0.41666667 0.61016949 0.54166667] 自编码后数据 [0.55433117 0.39854283 0.60144952 0.56267386]
    初始数据 [0.41666667 0.25       0.50847458 0.45833333] 自编码后数据 [0.42847693 0.24147409 0.49660712 0.45502175]
    初始数据 [0.19444444 0.125      0.38983051 0.375     ] 自编码后数据 [0.11086933 0.09538691 0.36472504 0.35089469]
    初始数据 [0.36111111 0.29166667 0.54237288 0.5       ] 自编码后数据 [0.37919347 0.27830778 0.52723044 0.51480766]
    初始数据 [0.38888889 0.41666667 0.54237288 0.45833333] 自编码后数据 [0.45518016 0.384981   0.52197533 0.47272053]
    初始数据 [0.38888889 0.375      0.54237288 0.5       ] 自编码后数据 [0.43630148 0.34972094 0.54046359 0.51130939]
    初始数据 [0.52777778 0.375      0.55932203 0.5       ] 自编码后数据 [0.56294492 0.36266643 0.56580679 0.50712162]
    初始数据 [0.22222222 0.20833333 0.33898305 0.41666667] 自编码后数据 [0.15882586 0.17269375 0.39249382 0.38058972]
    初始数据 [0.38888889 0.33333333 0.52542373 0.5       ] 自编码后数据 [0.42007559 0.31374312 0.53157849 0.50655738]
    初始数据 [0.55555556 0.54166667 0.84745763 1.        ] 自编码后数据 [0.60817303 0.51647374 0.84988419 0.89677189]
    初始数据 [0.41666667 0.29166667 0.69491525 0.75      ] 自编码后数据 [0.40966796 0.30076426 0.70351849 0.76705514]
    初始数据 [0.77777778 0.41666667 0.83050847 0.83333333] 自编码后数据 [0.72604039 0.46945032 0.81556913 0.83639185]
    初始数据 [0.55555556 0.375      0.77966102 0.70833333] 自编码后数据 [0.59181736 0.40464932 0.72889275 0.74949288]
    初始数据 [0.61111111 0.41666667 0.81355932 0.875     ] 自编码后数据 [0.62634993 0.45008901 0.81003888 0.85172467]
    初始数据 [0.91666667 0.41666667 0.94915254 0.83333333] 自编码后数据 [0.78618263 0.50142209 0.84322465 0.85674718]
    初始数据 [0.16666667 0.20833333 0.59322034 0.66666667] 自编码后数据 [0.03701683 0.16595625 0.5878081  0.6949052 ]
    初始数据 [0.83333333 0.375      0.89830508 0.70833333] 自编码后数据 [0.7553903  0.45024226 0.78429117 0.77998951]
    初始数据 [0.66666667 0.20833333 0.81355932 0.70833333] 自编码后数据 [0.63080398 0.2876045  0.73361417 0.76217381]
    初始数据 [0.80555556 0.66666667 0.86440678 1.        ] 自编码后数据 [0.7651637  0.60666041 0.87236969 0.89284089]
    初始数据 [0.61111111 0.5        0.69491525 0.79166667] 自编码后数据 [0.63936505 0.47584219 0.76213515 0.7795337 ]
    初始数据 [0.58333333 0.29166667 0.72881356 0.75      ] 自编码后数据 [0.57588916 0.33161954 0.7338462  0.77182444]
    初始数据 [0.69444444 0.41666667 0.76271186 0.83333333] 自编码后数据 [0.67625928 0.44662273 0.79645797 0.82415861]
    初始数据 [0.38888889 0.20833333 0.6779661  0.79166667] 自编码后数据 [0.32411649 0.21873558 0.70597035 0.79390829]
    初始数据 [0.41666667 0.33333333 0.69491525 0.95833333] 自编码后数据 [0.37525691 0.32705311 0.79231913 0.87614053]
    初始数据 [0.58333333 0.5        0.72881356 0.91666667] 自编码后数据 [0.60889194 0.47609086 0.81121996 0.8543606 ]
    初始数据 [0.61111111 0.41666667 0.76271186 0.70833333] 自编码后数据 [0.63940495 0.43569742 0.73564301 0.74302389]
    初始数据 [0.94444444 0.75       0.96610169 0.875     ] 自编码后数据 [0.82504874 0.65722616 0.86202231 0.85422052]
    初始数据 [0.94444444 0.25       1.         0.91666667] 自编码后数据 [0.7717543  0.41151929 0.86285931 0.89626783]
    初始数据 [0.47222222 0.08333333 0.6779661  0.58333333] 自编码后数据 [0.42388512 0.10215338 0.58644572 0.6174759 ]
    初始数据 [0.72222222 0.5        0.79661017 0.91666667] 自编码后数据 [0.70334396 0.509268   0.83481513 0.86447394]
    初始数据 [0.36111111 0.33333333 0.66101695 0.79166667] 自编码后数据 [0.34492799 0.31270048 0.71095816 0.78703878]
    初始数据 [0.94444444 0.33333333 0.96610169 0.79166667] 自编码后数据 [0.78662709 0.44615154 0.83073288 0.84387975]
    初始数据 [0.55555556 0.29166667 0.66101695 0.70833333] 自编码后数据 [0.54917769 0.31008235 0.69570737 0.72605217]
    初始数据 [0.66666667 0.54166667 0.79661017 0.83333333] 自编码后数据 [0.69130936 0.52509688 0.8033847  0.81995106]
    初始数据 [0.80555556 0.5        0.84745763 0.70833333] 自编码后数据 [0.75849665 0.51845333 0.7792639  0.76065072]
    初始数据 [0.52777778 0.33333333 0.6440678  0.70833333] 自编码后数据 [0.53526923 0.33795439 0.69210537 0.72059835]
    初始数据 [0.5        0.41666667 0.66101695 0.70833333] 自编码后数据 [0.53991277 0.40118838 0.69823516 0.71934308]
    初始数据 [0.58333333 0.33333333 0.77966102 0.83333333] 自编码后数据 [0.58305321 0.38025192 0.78165836 0.83007496]
    初始数据 [0.80555556 0.41666667 0.81355932 0.625     ] 自编码后数据 [0.74751816 0.45257732 0.73300816 0.69608993]
    初始数据 [0.86111111 0.33333333 0.86440678 0.75      ] 自编码后数据 [0.75471524 0.41543978 0.79417537 0.80180054]
    初始数据 [1.         0.75       0.91525424 0.79166667] 自编码后数据 [0.83451154 0.65409591 0.83863036 0.81063355]
    初始数据 [0.58333333 0.33333333 0.77966102 0.875     ] 自编码后数据 [0.57625353 0.38115734 0.79690275 0.85081961]
    初始数据 [0.55555556 0.33333333 0.69491525 0.58333333] 自编码后数据 [0.58470806 0.35338257 0.64523841 0.62779266]
    初始数据 [0.5        0.25       0.77966102 0.54166667] 自编码后数据 [0.53122021 0.29893213 0.62606039 0.61844661]
    初始数据 [0.94444444 0.41666667 0.86440678 0.91666667] 自编码后数据 [0.78336559 0.4878053  0.85742505 0.88052945]
    初始数据 [0.55555556 0.58333333 0.77966102 0.95833333] 自编码后数据 [0.61458859 0.52423615 0.83056028 0.87236713]
    初始数据 [0.58333333 0.45833333 0.76271186 0.70833333] 自编码后数据 [0.6309127  0.45960166 0.73411408 0.73944921]
    初始数据 [0.47222222 0.41666667 0.6440678  0.70833333] 自编码后数据 [0.51210452 0.39385153 0.69024659 0.7156428 ]
    初始数据 [0.72222222 0.45833333 0.74576271 0.83333333] 自编码后数据 [0.69718755 0.47247583 0.79870953 0.81937881]
    初始数据 [0.66666667 0.45833333 0.77966102 0.95833333] 自编码后数据 [0.65622665 0.47531875 0.83812615 0.88066169]
    初始数据 [0.72222222 0.45833333 0.69491525 0.91666667] 自编码后数据 [0.6801838  0.46140386 0.81920664 0.85427631]
    初始数据 [0.41666667 0.29166667 0.69491525 0.75      ] 自编码后数据 [0.40966796 0.30076426 0.70351849 0.76705514]
    初始数据 [0.69444444 0.5        0.83050847 0.91666667] 自编码后数据 [0.69358857 0.51323934 0.83665579 0.86803118]
    初始数据 [0.66666667 0.54166667 0.79661017 1.        ] 自编码后数据 [0.67222654 0.524001   0.85363956 0.89267428]
    初始数据 [0.66666667 0.41666667 0.71186441 0.91666667] 自编码后数据 [0.64095061 0.43191022 0.81414061 0.85778283]
    初始数据 [0.55555556 0.20833333 0.6779661  0.75      ] 自编码后数据 [0.51703721 0.23897789 0.70925286 0.76237597]
    初始数据 [0.61111111 0.41666667 0.71186441 0.79166667] 自编码后数据 [0.62195982 0.42514808 0.76145847 0.78943673]
    初始数据 [0.52777778 0.58333333 0.74576271 0.91666667] 自编码后数据 [0.59453475 0.5144429  0.80946535 0.84983339]
    初始数据 [0.44444444 0.41666667 0.69491525 0.70833333] 自编码后数据 [0.49569876 0.39945599 0.69738501 0.72799964]
    
    
    
    
    
    展开全文
  • 本文介绍基本的反向传输神经网络(Backpropagation 简称BP),主要讲述算法的基本流程和自己在训练BP神经网络的一些经验。 BP神经网络的结构  神经网络就是模拟人的大脑的神经单元的工作方式,但进行了很大的...
  • 原文出处: fengfenggirl(@也爱数据挖掘) 欢迎分享原创到伯乐头条 ...神经网络曾经很火,有过一段低迷期,现在因为深度学习的原因...本文介绍基本的反向传输神经网络(Backpropagation 简称BP),主要讲述算法
  • BP神经网络

    万次阅读 多人点赞 2015-03-26 22:28:25
    今天来讲BP神经网络,神经网络在机器学习中应用比较广泛,比如函数逼近,模式识别,分类,数据压缩,数据 挖掘等领域。接下来介绍BP神经网络的原理及实现。   Contents    1. BP神经网络的认识  2. 隐含层的选取...
  • 声明:文中内容基于山东某高校数据挖掘课程的课件,本系列文章为课程内容的个人总结以及笔记内容。 神经网络 感知机(M-P神经元模型) 感知机激活函数 BP神经网络 异或问题 多层神经网络下的异或问题 p、q为...
  • 神经网络 数绝挖掘课程设计,本系统包括很多的架构和具体代码,可是直接使用
  • 1.演示使用的数据集为iris数据集 df<-iris ...4.对输入的X矩阵数据进行归一化(神经网络 对于数据的输入值的区间有要求的,一般使用标准正太分布归一化) for(i in 1:4){ df[,i]<-scale(df
  • /*人工神经网络BP算法思想: 神经网络一般分为3层(也可以多层),包括输入层,隐含层和输出层。通过有监督的学习拟合非线性函数。假如输入层有3个神经元,隐含层有5个神经元,输出层有1个神经元。有监督的学习是指既...
  • BP神经网络背景:  BP(Back propagation)神经网络是一种多层前馈神经网络,该神经网络主要特点就是信号前向传递,误差反向反馈。具体来说,就是输入信号先前向传播到中间层节点,经过中间层节点激励函数转化后传播到...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 190
精华内容 76
关键字:

数据挖掘bp神经网络