标签: backpropagation

对于我的高级算法和数据结构课程,我的教授要求我们挑选任何感兴趣的主题.他还告诉我们研究它并尝试在其中实施解决方案.我之所以选择神经网络,是因为这是我长期想学的东西.

我已经能够使用神经网络实现AND,OR和XOR,神经网络的神经元使用激活器的阶跃函数.之后,我尝试实现一个反向传播神经网络,学习识别XOR运算符(使用sigmoid函数作为激活器).通过使用3-3-1网络(输入和隐藏层的1个偏差,随机初始化权重),我能够在90%的时间内将其工作.在其他时候它似乎陷入我认为是当地的最小值,但我不确定(我之前已经问过这个问题,人们告诉我应该没有当地的最小值).

在它工作的90%的时间里,我一直按照这个顺序呈现我的输入:[0, 0], [0, 1], [1, 0], [1, 0]将预期的输出设置为[0, 1, 1, 0].当我以相同的顺序一致地呈现值时,网络最终会学习该模式.它实际上并不重要我发送它的顺序,只要它是每个纪元的完全相同的顺序.

然后我实现了训练集的随机化,因此这次输入的顺序足够随机化.我现在已经注意到我的神经网络卡住而且错误正在减少,但是速度很慢(每个时期都会变小).过了一会儿,错误开始在一个值周围振荡(所以错误停止减少).

我是这个主题的新手,到目前为止我所知道的一切都是自学成才(阅读教程,论文等).为什么输入的呈现顺序会改变我的网络行为？是因为从一个输入到下一个输入的错误变化是一致的(因为排序是一致的),这使得网络易于学习？

我该怎么做才能解决这个问题？我正在检查我的反向传播算法,以确保我已经正确实现了它; 目前它以学习率和动力实施.我正在考虑其他增强功能,如自适应学习率.但是,XOR网络通常被描绘成一个非常简单的网络,因此我认为我不需要使用复杂的反向传播算法.

我试图用反向传播实现一个双层感知器来解决奇偶校验问题.网络有4个二进制输入,第一层有4个隐藏单元,第二层有1个输出.我使用它作为参考,但遇到了收敛问题.

首先,我将注意到我使用sigmoid函数进行激活,因此衍生物(根据我的理解)sigmoid(v)*(1 - sigmoid(v)).因此,在计算delta值时使用.

所以,基本上我设置网络并运行几个时期(遍历每个可能的模式 - 在这种情况下,16种输入模式).在第一个纪元之后,重量略有变化.在第二次之后,无论我运行多少个时代,权重都不会改变并保持不变.我现在使用的学习率为0.1,偏差为+1.

训练网络的过程在伪代码下面(根据我检查的来源,我认为这是正确的):

前馈步骤:

v = SUM[weight connecting input to hidden * input value] + bias  
y = Sigmoid(v)  
set hidden.values to y  
v = SUM[weight connecting hidden to output * hidden value] + bias  
y = Sigmoid(v)  
set output value to y

输出层的反向传播:

error = desired - output.value  
outputDelta = error * output.value * (1 - output.value)

隐藏层的反向传播:

for each hidden neuron h:  
error = outputDelta * weight connecting h to output …

我有一个关于反向传播的快速问题.我在看以下内容:

http://www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf

在本文中,它说计算神经元的误差为

错误= 输出(i)*(1 - 输出(i))*(目标(i) - 输出(i))

我把方程的一部分用粗体来理解.在论文中,它说由于sigmoid函数需要输出(i)*(1 - 输出(i))项 - 但我仍然不明白为什么这将是nessecary.

使用会有什么问题

Error = abs(Output(i) - Target(i))

？

无论神经元激活/转移功能如何,错误功能都是？

我正在用单个输出单元(二进制分类)编写MLP的简单实现.我需要它用于教学目的,所以我不能使用现有的实现:(

我设法创建了一个工作虚拟模型并实现了训练功能,但MLP并没有收敛.实际上,输出单元的梯度在时期上保持很高,因此其权重接近无穷大.

我的实施:

import numpy as np
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report

X = np.loadtxt('synthetic.txt')
t = X[:, 2].astype(np.int)
X = X[:, 0:2]

# Sigmoid activation function for output unit
def logistic(x):
    return 1/(1 + np.exp(-x))

# derivative of the tanh activation function for hidden units
def tanh_deriv(x):
    return 1 - np.tanh(x)*np.tanh(x)

input_num = 2            # number of units in the input layer
hidden_num = 2           # number of units in the hidden layer

# initialize weights …

2014年6月6日更新:我已经更新了问题,以便我尝试解决非线性方程.正如你们许多人所指出的,我不需要额外的复杂性(隐藏层,sigmoid函数等)来解决非线性问题.

此外,我意识到除了神经网络之外,我甚至可以使用其他方法来解决这样的非线性问题.我不是要编写最有效的代码或最少量的代码.这纯粹是为了让我更好地学习神经网络.

我已经创建了自己的反向传播神经网络实现.

在训练解决简单的XOR操作时,它工作正常.

但是现在我想调整它并训练它来解决Y = X*X + B类型的公式,但是我没有得到预期的结果.训练后,网络无法计算出正确的答案.神经网络是否非常适合解决这样的代数方程？我意识到我的例子是微不足道的我只是想了解更多关于神经网络及其能力的知识.

我的隐藏层使用sigmoid激活函数,我的输出层使用身份函数.

如果你能分析我的代码并指出任何错误,我将不胜感激.

这是我的完整代码(C#.NET):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NeuralNetwork
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Training Network...");

            Random r = new Random();
            var network = new NeuralNetwork(1, 5, 1);
            for (int i = 0; i < 100000; i++)
            {
                int x = i % 15;
                int y = x * x + 10;
                network.Train(x);
                network.BackPropagate(y);
            }

            //Below should output 20, but instead outputs …

我创建了一个Octave脚本,用于使用反向传播训练具有1个隐藏层的神经网络,但它似乎不适合XOR函数.

• x 输入4x2矩阵 [0 0; 0 1; 1 0; 1 1]
• y 输出4x1矩阵 [0; 1; 1; 0]
• theta 隐藏/输出图层权重
• z 加权总和
• a 激活函数应用于加权和
• m样品数量(4这里)

我的权重初始化如下

epsilon_init = 0.12;
theta1 = rand(hiddenCount, inputCount + 1) * 2 * epsilon_init * epsilon_init;
theta2 = rand(outputCount, hiddenCount + 1) * 2 * epsilon_init * epsilon_init;

前馈

a1 = x;
a1_with_bias = [ones(m, 1) a1];
z2 = a1_with_bias * theta1';
a2 = sigmoid(z2);
a2_with_bias = [ones(size(a2, 1), 1) a2];
z3 = …

一段时间以来,我一直在反对这一点,无法弄清楚我在实施这些RNN时做错了什么(如果有的话).为了让你们处于前进阶段,我可以告诉你两个实现计算相同的输出,因此正向阶段是正确的.问题是在倒退阶段.

这是我的python反向代码.它遵循karpathy的神经传递的风格非常接近,但不完全:

def backward(self, cache, target,c=leastsquares_cost, dc=leastsquares_dcost):
        '''
        cache is from forward pass

        c is a cost function
        dc is a function used as dc(output, target) which gives the gradient dc/doutput 
        '''
        XdotW = cache['XdotW'] #num_time_steps x hidden_size
        Hin = cache['Hin'] # num_time_steps x hidden_size
        T = Hin.shape[0]
        Hout = cache['Hout']
        Xin = cache['Xin']
        Xout = cache['Xout']

        Oin = cache['Oin'] # num_time_steps x output_size
        Oout=cache['Oout']

        dcdOin = dc(Oout, target) # this will be num_time_steps x num_outputs. these are dc/dO_j


        dcdWho …

我试图用反向传播在Java中实现FFNN,并且不知道我做错了什么.当我在网络中只有一个神经元时,它工作,但我写了另一个类来处理更大的网络,没有任何收敛.这似乎是数学中的问题 - 或者更确切地说是我对数学的实现 - 但我已经多次检查它并且我找不到任何错误.这应该有效.
节点类:

package arr;

import util.ActivationFunction;
import util.Functions;

public class Node {
    public ActivationFunction f;
    public double output;
    public double error;

    private double sumInputs;
    private double sumErrors;
    public Node(){
        sumInputs = 0;
        sumErrors = 0;
        f = Functions.SIG;
        output = 0;
        error = 0;
    }
    public Node(ActivationFunction func){
        this();
        this.f = func;
    }

    public void addIW(double iw){
        sumInputs += iw;
    }
    public void addIW(double input, double weight){
        sumInputs += (input*weight);
    }
    public double calculateOut(){
        output = …

我正在使用我自己实现的神经网络:它是一个简单的前向网络,使用RPROP作为学习算法,作为与基本设计相比唯一的"加".

当我针对MNIST进行测试时或者当我尝试图像压缩时,网络得分得体,但是当我尝试模拟像XOR函数一样简单的东西时,有时在学习过程中它会陷入局部最小值,并输出以下真值表:

0 XOR 0 = 1.4598413968251171e-171
1 XOR 0 = 0.9999999999999998
0 XOR 1 = 0.9999999999999998
1 XOR 1 = 0.5

训练结果通常是正确的,但有时1 XOR 1输出0.5而不是1.它并不总是在XOR(1,1)中发生,但也与其他输入一起发生.作为反向传播文献中的"经典"的异或函数,我想知道这里发生了什么,特别是考虑到我的网络似乎学习更复杂(但可能更少非线性)的任务就好了.

我的猜测是偏见有问题.

任何提示？

注1:上面的网络布局是2 | 3 | 1,但是当我使用更多隐藏单元时,变化不大,某些学习尝试仍然出错.

注2:我将实现放入要点:https://gist.github.com/antirez/e45939b918868b91ec6fea1d1938db0d

我首先Tensorflow 2.0尝试实现Guided BackProp以显示Saliency Map。我开始计算的损失y_pred和y_true图像，然后找到所有层的梯度，由于这方面的损失。

with tf.GradientTape() as tape:
    logits = model(tf.cast(image_batch_val, dtype=tf.float32))
    print('`logits` has type {0}'.format(type(logits)))
    xentropy = tf.nn.softmax_cross_entropy_with_logits(labels=tf.cast(tf.one_hot(1-label_batch_val, depth=2), dtype=tf.int32), logits=logits)
    reduced = tf.reduce_mean(xentropy)
    grads = tape.gradient(reduced, model.trainable_variables)

但是，我不知道如何使用渐变来获得引导传播。

这是我的模型。我使用Keras图层创建了它：

image_input = Input((input_size, input_size, 3))

conv_0 = Conv2D(32, (3, 3), padding='SAME')(image_input)
conv_0_bn = BatchNormalization()(conv_0)
conv_0_act = Activation('relu')(conv_0_bn)
conv_0_pool = MaxPool2D((2, 2))(conv_0_act)

conv_1 = Conv2D(64, (3, 3), padding='SAME')(conv_0_pool)
conv_1_bn = BatchNormalization()(conv_1)
conv_1_act = Activation('relu')(conv_1_bn)
conv_1_pool = MaxPool2D((2, 2))(conv_1_act)

conv_2 = Conv2D(64, (3, 3), padding='SAME')(conv_1_pool) …