精华内容
下载资源
问答
  • 神经网络多输入多输出

    千次阅读 2020-08-19 20:42:24
    神经网络多输入多输出 单个神经元类 /** * 单个神经元 * * @author SXC 2020年8月13日 下午9:48:19 */ public class Neurons { ThreeNeurons tN; double input[]; double inputandoutput[]; double ...

    神经网络,多输入多输出
    反向传播使用到链式求导,公式如下:
    在这里插入图片描述

    单个神经元类

    /**
     * 单个神经元
     * 
     * @author SXC 2020年8月13日 下午9:48:19
     */
    public class Neurons {
    	ThreeNeurons tN;
    	double input[];
    	double inputandoutput[];
    	double weight[];// 包含一个偏置的权重,数量比输入大一个
    	private double nowoutput;
    	private double ez;// e误差对z中间输出的导数
    	private double ew[];// e误差对w权重的导数 同权重一起初始化
    	double expectation = 0;
    	double trainrate = 10;
    	double step = 0.00001;// 步进大小
    	double dw[];// 下次更新增量
    
    	// 输入信号数
    	Neurons(int inputcount) {
    		input = new double[inputcount];
    		weight = new double[inputcount + 1];
    		initweight();
    	}
    
    	public double[] getInput() {
    		return input;
    	}
    
    	public double[] getEw() {
    		return ew;
    	}
    
    	public void setEw(double[] ew) {
    		this.ew = ew;
    	}
    
    	public void setEz(double ez) {
    		this.ez = ez;
    	}
    
    	public double getEz() {
    		return ez;
    	}
    
    	public void settN(ThreeNeurons tN) {
    		this.tN = tN;
    	}
    
    	public double getNowoutput() {
    		return nowoutput;
    	}
    
    	// 设置期望值
    	public void setExpectation(double expectation) {
    		this.expectation = expectation;
    	}
    
    	// 计算误差值
    	public double errate() {
    		return Math.abs(calaOutput() - this.expectation);
    	}
    
    	// 计算模型误差值
    	public double merrate() {
    		return Math.abs(tN.calaOutput() - this.expectation);
    	}
    
    	// 设置权重值
    	public void setWeight(double[] weight) {
    		this.weight = weight;
    		if (ew == null) {
    			ew = new double[weight.length];
    		}
    	}
    
    	// 初始化权重
    	private void initweight() {
    		for (int i = 0; i < weight.length; i++) {
    			weight[i] = Math.random() * 2 - 1;
    		}
    		if (ew == null) {
    			ew = new double[weight.length];
    		}
    	}
    
    	// 获得权重
    	public double[] getWeight() {
    		return weight;
    	}
    
    	// --------------------输出打印---------------------------------------------
    	public void getEwtostring() {
    		String string = "当前ew为:[  ";
    		int i;
    		for (i = 0; i < ew.length; i++) {
    			string += ew[i] + "  ";
    		}
    		System.out.println("输入数:" + i + string + "] ");
    	}
    	public void getEztostring() {
    		System.out.println("当前ez为:[  " + ez + " ]");
    	}
    
    	public void getinputtostring() {
    		String string = "当前输入为:[  ";
    		int i;
    		for (i = 0; i < input.length; i++) {
    			string += input[i] + "  ";
    		}
    		System.out.println("输入数:" + i + string + "] ");
    	}
    
    	public void getoutnputtostring() {
    		System.out.println("该神经元输出:" + calaOutput());
    	}
    
    	public void getweighttostring() {
    		String string = "当前权重为:[  ";
    		int i;
    		for (i = 0; i < weight.length; i++) {
    			string += weight[i] + "  ";
    		}
    		System.out.println("权重数:" + i + string + "] ");
    	}
    	// --------------------输出打印---------------------------------------------
    
    	// 设置输入
    	public void setInput(double[] input) {
    		this.input = input;
    	}
    
    	// 设置输入输出
    	public void setInputandOutput(double[] inputandoutput) {
    		for (int i = 0; i < inputandoutput.length - 1; i++) {
    			this.input[i] = inputandoutput[i];
    		}
    		setExpectation(inputandoutput[inputandoutput.length - 1]);
    	}
    
    	// 神经元输出 0-1 sigmod(x1w1+x2w2+x3w3+bw4)
    	public double calaOutput() {
    		double output = 0;
    		for (int i = 0; i < input.length; i++) {
    			output = input[i] * weight[i] + output;
    		}
    		output = output + 1 * weight[weight.length - 1];
    		output = sigmoid(output);
    		nowoutput = output;
    		return output;
    	}
    
    	// 未经激励函数输出 x1w1+x2w2+x3w3+bw4
    	public double total() {
    		double output = 0;
    		for (int i = 0; i < input.length; i++) {
    			output = input[i] * weight[i] + output;
    		}
    		output = output + 1 * weight[weight.length - 1];
    		return output;
    
    	}
    
    //----------------------调整权重---------------------------------------	
    	// 调整权重1次
    	public void train() {
    		setDw();
    		updateweight();
    	}
    
    	// 计算权重增量
    	public void setDw() {
    		dw = new double[weight.length];
    		double errate = errate();
    		double newerrate = 0;
    		for (int i = 0; i < weight.length; i++) {
    			weight[i] += step;
    			newerrate = errate();
    			dw[i] = (newerrate - errate) / step;
    			weight[i] -= step;
    		}
    	}
    
    	public void msetDw() {
    		dw = new double[weight.length];
    		double errate = merrate();
    		double newerrate = 0;
    		for (int i = 0; i < weight.length; i++) {
    			weight[i] += step;
    			newerrate = merrate();
    			dw[i] = (newerrate - errate) / step;
    			weight[i] -= step;
    		}
    	}
    
    	// 更新权重
    	public void updateweight() {
    		for (int i = 0; i < dw.length; i++) {
    			weight[i] -= dw[i] * trainrate;
    		}
    
    	}
    
    	public double getTrainrate() {
    		return trainrate;
    	}
    
    	// 调整权重time次
    	public void train(int time) {
    		for (int i = 0; i < time; i++) {
    			train();
    		}
    	}
    
    	// 调整权重直到指定误差值
    	public void train(double d) {
    		while (errate() > d) {
    			train();
    		}
    	}
    //----------------------调整权重---------------------------------------	
    
    	// 激励函数
    	public double sigmoid(double input) {
    		return 1f / (1f + Math.pow(Math.E, -1 * input));
    	}
    }
    
    

    神经网络层类

    /**
     * 单个神经元
     * 
     * @author SXC 2020年8月14日 下午9:21:20
     */
    public class NetWork {
    	private int NeuronsC[];// 每个隐藏层神经元个数,new时初始化
    	private double nowoutput[];
    	Neurons AllNeurons[];
    	double input[];// 实时输入输出 input new时初始化
    	double expectation[];// 设定值
    	double trainrate = 1;// 学习率
    
    	NetWork(int m[], int in, int out) {// 隐藏层||...||隐藏层 共m层,每层m[i]个
    		input = new double[in];
    		NeuronsC = m;
    		int n = 0;
    		if (m[m.length-1]!=out) {
    			System.out.println("数据输入存在问题!!");
    		}
    		for (int i = 0; i < m.length; i++) {
    			n += m[i];
    		}
    		AllNeurons = new Neurons[n];
    		int index = 0;
    		for (int i = 0; i < m.length; i++) {
    			for (int j = 0; j < m[i]; j++) {
    				if (i == 0) {
    					AllNeurons[index] = new Neurons(in);//
    					index++;
    				} else {
    					AllNeurons[index] = new Neurons(m[i - 1]);
    					index++;
    				}
    			}
    		}
    		nowoutput = new double[out];
    		expectation = new double[out];
    		System.out.println("生成" + n + "个神经元");
    	}
    
    	public void setInput(double[] input) {
    		this.input = input;
    	}
    
    	public void setInputandLable(double[] inputandlable) {
    		for (int i = 0; i < input.length ; i++) {
    			input[i] = inputandlable[i];
    		}
    		for (int i = 0; i < expectation.length; i++) {
    			this.expectation[i] = inputandlable[i + input.length];
    		}
    
    	}
    
    	public void setExpectation(double expectation) {
    		this.expectation[0] = expectation;
    	}
    
    	public double err() {
    		double err=0;
    		for (int i = 0; i < expectation.length; i++) {
    			err+=(expectation[i] - forward_pass(i));
    		}
    		return err;
    
    	}
    
    	// 前向传播
    	public double forward_pass(int p) {
    		// 逐层传播
    		double newinput[] = null;// 除第一列外的输入数据
    		for (int i = 0; i < NeuronsC.length; i++) {// 一列一列来
    			for (int j = 0; j < NeuronsC[i]; j++) {
    				if (i == 0) {
    					getNeurons(1, j + 1).setInput(input);// 第一列用外部输入的输入数据
    				} else {
    					if (j == 0) {// 每列更新一次输入数据
    						newinput = new double[NeuronsC[i - 1]];
    						for (int k = 0; k < NeuronsC[i - 1]; k++) {
    							newinput[k] = getNeurons(i, k + 1).calaOutput();
    						}
    					}
    					getNeurons(i + 1, j + 1).setInput(newinput);// 除一列外输入的输入数据使用上一列的输出
    				}
    			}
    		}
    		for (int i = 0; i < nowoutput.length; i++) {
    			nowoutput[i] = getNeurons(NeuronsC.length, i + 1).calaOutput();
    		}
    
    		return nowoutput[p];// 输出最后一列第一个神经元的输出
    	}
    
    	// 反向传播 更新权重
    	public void update_weights() {
    		double[] nowoutput = getNowoutput();
    		// 从输出层开始 遍历各层
    		for (int i = NeuronsC.length; i > 0; i--) {
    			if (i == NeuronsC.length) {// 输出层特殊计算 暂时设定为一个神经元
    				for (int g = 0; g < NeuronsC[i - 1]; g++) {
    					Neurons Neurons = getNeurons(NeuronsC.length, g+1);
    					Neurons.setEz((nowoutput[g] - this.expectation[g]) * active_derivative(Neurons.getNowoutput()));
    					double ew[] = new double[Neurons.getWeight().length];
    					for (int j = 0; j < ew.length - 1; j++) {// 遍历各个权重
    						ew[j] = Neurons.getEz() * Neurons.getInput()[j];
    					}
    					ew[ew.length - 1] = Neurons.getEz();
    					Neurons.setEw(ew);
    				}
    
    			} else {// 计算除输出层外的ew
    				for (int j = 1; j < NeuronsC[i - 1] + 1; j++) {// 遍历各个该层各个神经元 i列j个神经元
    					Neurons Neurons = getNeurons(i, j);
    					// 计算ez=上一层ez*对应到上一层的权重w+....+上一层ez*对应到上一层的权重w
    					double ea = 0;// e对输出的导数
    					for (int k = 1; k < NeuronsC[i] + 1; k++) {
    						ea += getNeurons(i + 1, k).getEz() * getNeurons(i + 1, k).getWeight()[j - 1];
    					}
    					Neurons.setEz(ea * active_derivative(Neurons.getNowoutput()));
    					double ew[] = new double[Neurons.getWeight().length];
    					for (int l = 0; l < ew.length - 1; l++) {// 遍历各个权重
    						ew[l] = Neurons.getEz() * Neurons.getInput()[l];
    					}
    					ew[ew.length - 1] = Neurons.getEz();
    					Neurons.setEw(ew);
    				}
    			}
    		}
    		// 开始更新
    		for (Neurons neurons : AllNeurons) {
    			for (int i = 0; i < neurons.getWeight().length; i++) {
    				neurons.getWeight()[i] -= neurons.getEw()[i] * trainrate;
    			}
    		}
    	}
    
    	public double[] getNowoutput() {
    		forward_pass(0);
    		return nowoutput;
    	}
    
    	public double getNowoutput(int i) {
    		return nowoutput[i];
    	}
    	
    	// --------------------输出打印---------------------------------------------
    
    	public void getweighttostring() {
    		for (Neurons neurons : AllNeurons) {
    			neurons.getweighttostring();
    		}
    	}
    
    	public void getEwtostring() {
    		for (Neurons neurons : AllNeurons) {
    			neurons.getEwtostring();
    		}
    	}
    
    	public void getEztostring() {
    		for (Neurons neurons : AllNeurons) {
    			neurons.getEztostring();
    		}
    	}
    
    	public void getinputtostring() {
    		for (Neurons neurons : AllNeurons) {
    			neurons.getinputtostring();
    		}
    
    	}
    
    	public void getoutnputtostring() {
    		for (Neurons neurons : AllNeurons) {
    			neurons.getoutnputtostring();
    		}
    	}
    
    	// 激励函数
    	public double active(double input) {
    		return 1f / (1f + Math.pow(Math.E, -1 * input));
    	}
    
    	// 激励函数
    	public double active_derivative(double input) {
    		return input * (1 - input);
    	}
    
    	// --------------------输出打印---------------------------------------------
    
    	// 返回col列,cow行的神经元,都从1开始
    	public Neurons getNeurons(int col, int row) {
    		if (row > NeuronsC[col - 1]) {
    			System.out.println("该层没有这么多神经元!!请求" + col + "列" + row + "行神经元");
    		} else {
    			int n = 0;
    			for (int i = 0; i < col - 1; i++) {
    				n += NeuronsC[i];
    			}
    			n += row - 1;
    			// System.out.println("请求"+col+"列"+row+"行神经元");
    			return AllNeurons[n];
    		}
    
    		return null;
    
    	}
    }
    

    main类

    public class t {
    
    	public static void main(String[] args) {
    		int a[] = { 5, 5, 4, 7, 9, 2 };
    		double b[] = { 1, 1 };
    		double data0[] = { 1, 1, 1, 1 };
    		double data1[] = { 1, 0, 1, 0 };
    		double data2[] = { 0, 1, 1, 0 };
    		double data3[] = { 0, 0, 0, 1 };
    //		double data4[] = { 1, 0, 0, 0 };
    //		double data5[] = { 0, 1, 0, 0 };
    //		double data6[] = { 0, 0, 1, 0 };
    //		double data7[] = { 0, 0, 0, 0 };
    		NetWork NetWork = new NetWork(a, 2, 2);
    		double err = 1;
    		int i;
    		for (i = 0; err >= 0.08; i++) {
    			err = 0;
    			NetWork.setInputandLable(data0);
    			NetWork.update_weights();
    			err += Math.abs(NetWork.err());
    			NetWork.setInputandLable(data1);
    			NetWork.update_weights();
    			err += Math.abs(NetWork.err());
    			NetWork.setInputandLable(data2);
    			NetWork.update_weights();
    			err += Math.abs(NetWork.err());
    			NetWork.setInputandLable(data3);
    			NetWork.update_weights();
    			err += Math.abs(NetWork.err());
    //			NetWork.setInputandLable(data4);
    //			NetWork.update_weights();
    //
    //			NetWork.setInputandLable(data5);
    //			NetWork.update_weights();
    //
    //			NetWork.setInputandLable(data6);
    //			NetWork.update_weights();
    //
    //			NetWork.setInputandLable(data7);
    //			NetWork.update_weights();
    		}
    		System.out.println("误差:" + err);
    		System.out.println("运行次数:" + i);
    		NetWork.setInputandLable(data0);
    		err += Math.abs(NetWork.err());
    		System.out.println(NetWork.getNowoutput(0) + "   " + NetWork.getNowoutput(1));
    		NetWork.setInputandLable(data1);
    		err += Math.abs(NetWork.err());
    		System.out.println(NetWork.getNowoutput(0) + "   " + NetWork.getNowoutput(1));
    		NetWork.setInputandLable(data2);
    		err += Math.abs(NetWork.err());
    		System.out.println(NetWork.getNowoutput(0) + "   " + NetWork.getNowoutput(1));
    		NetWork.setInputandLable(data3);
    		err += Math.abs(NetWork.err());
    		System.out.println(NetWork.getNowoutput(0) + "   " + NetWork.getNowoutput(1));
    //		NetWork.setInputandLable(data4);
    //		err += Math.abs(NetWork.err());
    //		System.out.println(NetWork.getNowoutput()[0]);
    //		NetWork.setInputandLable(data5);
    //		err += Math.abs(NetWork.err());
    //		System.out.println(NetWork.getNowoutput()[0]);
    //		NetWork.setInputandLable(data6);
    //		err += Math.abs(NetWork.err());
    //		System.out.println(NetWork.getNowoutput()[0]);
    //		NetWork.setInputandLable(data7);
    //		err += Math.abs(NetWork.err());
    //		System.out.println(NetWork.getNowoutput()[0]);
    
    		System.out.println("误差:" + err);
    		// NetWork.getweighttostring();
    		drawnet(a);
    	}
    
    	private static void drawnet(int[] a) {
    		System.out.println("----------------------------------------------------------------------------------------------");
    		System.out.println("神经网络图:");
    		int max = 0;
    		for (int i = 0; i < a.length; i++) {
    			if (max < a[i]) {
    				max = a[i];
    			}
    		}
    		for (int i = 0; i < max; i++) {// 行
    			String string = "";
    			for (int j = 0; j < a.length; j++) {// 列
    				if (i>=(max-a[j])/2&&i<(max+a[j])/2) {
    					string += "     ●     ";
    				} else {
    					string += "           ";
    				}
    			}
    			System.out.println(string);
    		}
    		System.out.println("----------------------------------------------------------------------------------------------");
    	}
    }
    
    

    输出结果:

    生成32个神经元
    误差:0.079968261269626
    运行次数:31782
    0.9999784568902769   0.9746964043839443
    0.9915416453943027   0.026059584935733092
    0.9915361463055753   0.026071465598939452
    0.01106848775432035   0.9694260287169286
    误差:0.16000772575870634
    ----------------------------------------------------------------------------------------------
    神经网络图:
                                                     ●                
                                          ●          ●                
         ●          ●          ●          ●          ●                
         ●          ●          ●          ●          ●          ●     
         ●          ●          ●          ●          ●          ●     
         ●          ●          ●          ●          ●                
         ●          ●                     ●          ●                
                                          ●          ●                
                                                     ●                
    ----------------------------------------------------------------------------------------------
    
    展开全文
  • 之前说到的的输入输出都是二维数组(即只有两个维度:高、宽)。而真实数据实际上有很维度。比如,彩色图像除了高、宽,还有RGB三个颜色通道。所以,彩色图像在内存中表示为一个形状为3∗hx∗wx3*h_x*w_x3∗hx​∗...

    一、多输入通道

    之前说到的的输入输出都是二维数组(即只有两个维度:高、宽)。而真实数据实际上有很多维度。比如,彩色图像除了高、宽,还有RGB三个颜色通道。所以,彩色图像在内存中表示为一个形状为3hxwx3*h_x*w_x的三维数组大小为3的这一维称为通道(channel)

    当输入含有多个通道时,对应的卷积核也应该有相同的通道数。此时,输出为:每个通道分别做互相关运算,然后按通道相加。如下图:
    在这里插入图片描述

    二、多输出通道

    假设输入通道数为cinc_{in},输出通道数为coutc_{out},那么此时卷积核的形状为coutcinhkwkc_{out}*c_{in}*h_k*w_k,即对于最高维度来说,每个元素都是一个形状为cinhkwkc_{in}*h_k*w_k的元素。此时,输入和卷积核中每一个元素做互相关运算,得到输出中对应通道的结果。

    三、1×1卷积核

    对于111*1的卷积核,进行互相关操作,在高、宽维度上没有了识别相邻元素构成的模式的功能,而计算主要发生在了通道维度上。下图展示了输入通道数为3,输出通道数为2的111*1卷积核的互相关操作。
    在这里插入图片描述

    图中可以看出,每一个通道的输出的其中一个元素(比如输出中的浅蓝色方块),都是输入和卷积核在通道维度上的计算。

    此外,对于111*1的卷积核,输出的高、宽维度大小与输入相同。

    展开全文
  • 上图为本文所考虑的简单的 单层多输入输出BP神经网络输入变量个数:n 隐含层神经元个数:k 输出变量个数:1输入变量:x 输出变量:y 期望输出:t 样本数量:m 隐含层-输入层连接权值:ωjp\omega _{jp} ...

    参考文献:http://www.cnblogs.com/biaoyu/p/4591304.html

    单层多输入单输出BP神经网络

    上图为本文所考虑的简单的 单层多输入单输出BP神经网络。

    输入变量个数:n
    隐含层神经元个数:k
    输出变量个数:1

    输入变量:x
    输出变量:y
    期望输出:t
    样本数量:m

    隐含层-输入层连接权值:ωjp
    隐含层神经元偏置值: bj

    输出层-隐含层连接权值:ωoj
    输出层神经元偏置值: bo

    隐含层 激励函数采用sigmod函数:

    f(x)=11+ex,f(x)=f(x)(1f(x))


    公式推导部分

    对于第i个样本输入,
    隐含层第j个神经元输入为:

    netj=p=1nωjpxp+bj

    隐含层第j个神经元输出为:f(netj)

    BP模型输出为:

    y(i)=j=1kωojf(netj)+bo


    对于第i个样本,误差定义为:E(i)=12[t(i)y(i)]2
    根据误差反向传播算法有:

    输出-隐含层权值 修正 梯度:

    E(i)ωoj=ωoj12[(t(i)y(i))]2=[t(i)y(i)]y(i)ωoj=[t(i)y(i)]f(netj)

    输出层偏置值 修正 梯度:E(i)bo=[t(i)y(i)]

    隐含-输入层权值 修正 梯度:

    E(i)ωjp=[t(i)y(i)]y(i)ωjp=[t(i)y(i)]ωjpj=1kωojf(netj)+bo=[t(i)y(i)]ωjpj=1kωojfp=1nωjpxp+bj+bo=[t(i)y(i)]ωojf(netj)ωjp=[t(i)y(i)]ωojf(netj)netjnetjωjp=[t(i)y(i)]ωojf(netj)[1f(netj)]xp

    隐含层偏置值 修正梯度:

    E(i)bj=[t(i)y(i)]ωojf(netj)[1f(netj)]


    即:

    ΔωojΔboΔωjpΔbj=[t(i)y(i)]f(netj)=[t(i)y(i)]=[t(i)y(i)]ωojf(netj)[1f(netj)]xp=[t(i)y(i)]ωojf(netj)[1f(netj)]


    即 权值修正公式:

    ωojboωjpbj=ωojΔωoj=boΔbo=ωjpΔωjp=bjΔbj


    BP算法流程:

    1. 确定 样本、(输入层、输出层、隐含层 数目),对权值与偏置值初始化。
    2. 执行
      for i = 1 : 样本数目m
      计算BP输出;
      求 Err(i)=t(i)-y(i);
      end
      根据总误差Err 与上述权值修正公式,更新权值和偏置值。
      flag++;
      直到 总误差小于给定值 或 迭代次数达到上限

    C代码部分

    #include<stdio.h>
    #include<stdlib.h>
    #include <math.h>
    #include<time.h>
    
    #define n 3 //3输入
    #define k 5 //4神经元 
    #define o 1 //1输出 
    #define N 100   //100数据对 
    #define N1 90   //90个训练 
    #define N2 10   //10个测试 
    int i=0;
    int j=0;
    int m=0;
    
    
    
    int main()
    {
        srand(time(0));
    
        float x[3][N];
        float t[N]={0};
        float y[N]={0};
        float Wjp[k][n]={0};
        float dWjp[k][n][N1]={0};
        float Woj[k]={0};
        float sWoj={0};
        float dWoj[k][N1]={0};
        float bo={0};
        float dbo[N1]={0};
        float bj[k];
        float dbj[k][N1];
        float net[k]={0};
        float fnet[k]={0}; 
        float err[N1]={0};
        float Err=0;
        float sum1[k][n]={0};
        float sum2[k]={0};
        float sum3[k]={0};
        float sum4=0; 
        int flag=0;
    
    //权值初始化
        for(i=0;i<n;i++)
        {
            for(j=0;j<k;j++)
            {
                 Wjp[j][i]=((rand()%10)-5)/5.0;
                 Woj[j]=((rand()%10)-3)/5.0;
                 bj[j]  = ((rand()%10)-4)/5.0;
            }
    
        }
        bo = ((rand()%10)-5)/5.0;
    
    //输入输出对 
        for(i=0;i<N;i++)
        {
            x[0][i] = 1.0*i/N;
            x[1][i] = 1.0*i/N;
            x[2][i] = 1.0*i/N;
         t[i] = x[0][i]*2+2*x[1][i]+x[2][i];
        }
    
    
    do{
    
        Err=0;
        for(j=0;j<k;j++)
                {
                    for(m=0;m<n;m++)
                    {                       
                        sum1[j][m]=0;
    
                    }
                        sum2[j]=0;
                        sum3[j]=0;
    
                }
                        sum4=0;
    
        for(i=0;i<N1;i++)//训练样本 
        {
            y[i]=0;//增加 
    
        }
    
        for(i=0;i<N1;i++)//训练样本 
        {
    
            for(j=0;j<k;j++)
            {  
                net[j] = bj[j];
                for(m=0;m<n;m++)
                {
                    net[j] = net[j] + x[m][i]*Wjp[j][m];  //计算隐含层的输入        
                }
    
            }
    
            for(j=0;j<k;j++)
            {
                fnet[j] = 1.0/(1+exp(-net[j])); //计算 隐含层的输出 
                y[i] = y[i] + fnet[j]*Woj[j];   //计算模型输出 
            }
             err[i] = t[i] - y[i];      //模型输出与期望输出的差值
    
            for(j=0;j<k;j++)
            {
                dWoj[j][i]=-err[i]*fnet[j]; // 输出-隐含层 权值修正量 
                dbo[i] = -err[i];   
            }
    
            for(j=0;j<k;j++)
                {
                    for(m=0;m<n;m++)
                    {                   
                        dbj[j][i] = -err[i]*Woj[j]*fnet[j]*(1-fnet[j]);//隐含层-输入层权值修正量 
                        dWjp[j][m][i] = dbj[j][i] * x[m][i];
                    }
    
                }
    
    
        }
    
    //更新 权值和偏置 
    
             for(m=0;m<n;m++)
            {
                for(j=0;j<k;j++)
                {
                    for(i=0;i<N1;i++)
                    {    
                        sum1[j][m]+=dWjp[j][m][i];
                        sum2[j]+=dWoj[j][i];
                        sum3[j]+=dbj[j][i];
                        sum4+=dbo[i];
                    }
    
                }
    
            }
    
          for(i=0;i<N1;i++)
            {    
                Err=Err+abs(err[i]);
            }
    
    
            for(j=0;j<k;j++)
                {
    
                 for(m=0;m<n;m++)
                {
    
                     Wjp[j][m] = Wjp[j][m] -0.5*sum1[j][m]/N1;      
                }
                     Woj[j] = Woj[j] -0.5*sum2[j]/N1;
                     bj[j] = bj[j] - 0.5*sum3[j]/N1;
    
            }
                     bo = bo - sum4/N1;
    
    
          flag++;
    
    
          printf("%9f\n",Err);
    }while(Err>0.00001&&flag<10000);
    
    
    
    
    if(Err<=0.1)
    {
    
    
    for(i=N1;i<N;i++)//测试样本 
        {
    
            for(j=0;j<k;j++)
            {  
                net[j] = bj[j];
                for(m=0;m<n;m++)
                {
                    net[j] = net[j] + x[m][i]*Wjp[j][m];  //计算隐含层的输入        
                }
    
            }
    
            for(j=0;j<k;j++)
            {
                fnet[j] = 1.0/(1+exp(-net[j])); //计算 隐含层的输出 
                y[i] = y[i] + fnet[j]*Woj[j];   //计算模型输出 
    
            }
             err[i] = t[i] - y[i];      //模型输出与期望输出的差值
             printf("%f   %f\n",t[i],y[i]);
        }
    
    
    
    
    }
    
    return 0;
    }
    展开全文
  • 多输入通道:当输入数据含有个通道时,我们需要构造一个输入通道数与输入数据通道数相同的卷积核,从而能够与含有输入数据做...多输出通道:通过1乘1卷积核来调整网络层之间的通道数,并控制模型的复杂度。 ...

    多输入通道:当输入数据含有多个通道时,我们需要构造一个输入通道数与输入数据通道数相同的卷积核,从而能够与含有多个输入数据做互相关运算。
    例如:
    在这里插入图片描述
    阴影部分第一个元素及其计算所使用的输入和核数组元素:
    在这里插入图片描述
    多输出通道:通过1乘1卷积核来调整网络层之间的通道数,并控制模型的复杂度。
    在这里插入图片描述

    展开全文
  • 神经网络输出个神经元

    千次阅读 2019-05-02 22:15:38
    改版后需要输出层变成矩阵的形式,神经网络工具箱可以自动识别输出层有几个神经元。详细代码如何下: num=xlsread('data_shengzheng.xlsx','Sheet1','A2:I11'); input_train=num(1:9,1:8)'; outpu...
  • keras:构建多输入多输出模型、多输入输出模型

    万次阅读 多人点赞 2019-09-10 10:58:51
    一个具有两个输入和两个输出的模型: 我们试图预测 Twitter 上的一条新闻标题有多少转发和点赞数。模型的主要输入将是新闻标题本身,即一系列词语,但是为了增添趣味,我们的模型还添加了其他的辅助输入来接收额外的...
  • http://blog.csdn.net/xingchenbingbuyu/article/details/53698627微博:http://weibo.com/xingchenbing 在上一篇博客的结尾提到了神经网络的预测函数predict(),说道predict调用了forward函数并进行了输出的解析,...
  • https://zhidao.baidu.com/question/1882929579529248508.html
  • 前文中了解到,神经网络个神经单元组成,而本篇博客将会了解到深度学习由神经网络组成,并且分为 输入层、隐藏层和输出层,隐藏层涉及到的知识点最多,是本文的重点 正文 阶层型的神经网络主要...
  • 即使我们从理论上理解了卷积神经网络,在实际进行将数据拟合到网络时,很多人仍然对其网络的输入输出形状(shape)感到困惑。本文章将帮助你理解卷积神经网络输入输出形状。 让我们看看一个例子。CNN的输入数据...
  • 我们在理解RNN或者LSTM的时候,对它们的输入输出的维度都很迷惑,下面是我结合代码和网上的一些...有输入层、隐层和输出层,隐层中有神经元,图中每个参数都跟全部的神经元有链接。 接下来看下LSTM的拓扑图: ...
  • 深度学习——吴恩达(1)_binary_classification主要内容神经网络输入输出问题 主要内容 神经网络输入输出问题 输入一个5 ×\times× 5大小的rgb图像,将图像转换成一个5×\times× 5×\times× 3 = 75 大小的...
  • 快速理解卷积神经网络输入输出尺寸问题

    万次阅读 多人点赞 2018-04-15 21:19:24
    一般一个神经网络的一层包括一个卷积和一个池化,这里主要讲述对输入输出的尺寸的理解: 一、卷积 首先input输入矩阵,weight权值矩阵(滤波器)如下图429是由weight与input对应位置相乘再相加得到。 然后是...
  • 在本教程中,您将学习如何将Keras用于多输入和混合数据。 您将了解如何定义一个Keras体系结构,该体系结构能够接受多种输入,包括数字、分类和图像数据。然后,我们将在此混合数据上训练单个端到端网络。 今天是我们...
  • 神经网络学习 之 BP神经网络

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

    千次阅读 2019-01-04 16:48:24
    神经网络-反向传播算法 神经网络-激活函数 神经网络是将许多个神经元按一定的层次结构连接起来的网络结构。不同的层次结构会产出不同类型神经网络,比如前馈神经网络和递归神经网络。 神经元 神经元是神经网络最...
  • 神经网络入门-神经元多输出

    千次阅读 2018-11-25 10:51:01
    参考 https://www.jianshu.com/p/df146fa0a293 1.2 神经多输出 神经元-多输出 处理二分类的问题,用一个神经元可以解决,处理分类的问题,加神经元就可以了。这时候之前的w向量变成了矩阵 ...
  • 如果在Tensorflow中构建一个自己的神经网络,框架会自动进行后向传播,所以只需要搭建好前向传播的部分,这里面维度必须对应好,其他的调用函数就行,现在总结一下维度问题。 从最简单的说:如下图,X是一个全是...
  • 关于分类神经网络输出

    千次阅读 2019-03-21 21:45:50
    因此,神经网络解决类分类问题的本质是把原分类问题分解为一类对其他类(one-vs-all)的二类分类问题。 神经网络比直接使用Logistic回归的优势在于:如果给定基础特征的数量为100,那么在利用Logistic回归解决复杂...
  • 这几年,深度学习推动了人工智能领域快速的向前发展,神经网络架构也是演变的越来越复杂,经常会有多输入多输出的情况,然而,我们在使用训练后的模型进行预测的时候,有时并不需要进行和训练时一样的输入输出,...
  • 看到网上有很计算神经网络各种层的输入输出尺寸的公式,但是往往只是直接给出公式,并没有教给我们如何得到这种公式的,自己学习的时候,做一下记录以及图解 卷积层 首先给出公式,这里肯定假设输入图像是等宽高的...
  • 通过神经网络,怎么为输入输出建立映射关系公式?输入是三维的点云坐标,输出是二维的, 建立映射关系,怎么求出相应的表达式?
  • 卷积神经网络

    万次阅读 多人点赞 2014-11-29 16:20:41
    自今年七月份以来,一直在实验室负责卷积神经网络(Convolutional Neural Network,CNN),期间配置和使用过theano和cuda-convnet、cuda-convnet2。为了增进CNN的理解和使用,特写此博文,以其与人交流,互有增益。...
  • 博主对于神经网络输出神经元个数的问题,起源于“识别手写数字的神经网络为什么需要10个输出而不是四个?”. 实际上,这是两种不同的编码方式,两种的网络架构都是可行的,但是我们选择十个神经元而不是四个...
  • 本题节选自《BAT机器学习面试1000题》,1000题系列作为国内首个AI题库,囊括绝大部分机器学习和深度学习的笔试面试题、知识点,可以作为机器学习自测题,也可以当做查漏补缺的资料库。...LSTM神经网络输入输...
  • 隐含层节点数必须小于N-1(N是训练样本数),否则网络模型的系统误差与训练样本的特性无关而趋于0,即建立的网络模型没有泛化能力,也没有任何使用价值,同理,输入层的节点数也必须小于N-1;  训练样本数必须多余网络模型...
  • RNN、LSTM神经网络输入输出究竟是怎样的?

    千次阅读 多人点赞 2019-04-09 16:46:43
    原本以为自己懂的,可是看着看着论文,就越来越不知道Recurrent NNs(这里不区分LSTM,GRU)的输入输出到底是怎么样的。所以,查阅篇资料,整合如下,希望能帮到大家。 首先,用「动图」和「举例子」讲讲 RNN...
  • 经过大量的调研,现有的被广泛接受的输入层、隐藏层、输出层节点数的确定方法为: (1)输入层节点数n:取决于样本的属性个数 (2)输出层节点数l:取决于定义的标签编码规则,或者预测的节点数 (3)隐藏层节点数m...
  • logistics回归,逻辑回归问题。 图像在计算机中如何保存?要保存一张图像,要保存三个独立矩阵,对应三原色通道。...图片的特征向量x作为输入,预测输出的结果标签为y。 用一个单独的(x,y)作为一个单独的输入样本...
  • 建造一个完整的神经网络,包括添加神经层,计算误差,训练步骤,判断是否在学习。 ***代码如下:***(我把注释写的非常详细,不用怕看不懂) from __future__ import print_function #导入所需模块 import tensorflow ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 174,706
精华内容 69,882
关键字:

多输入多输出神经网络