标签: backpropagation

哪些库/插件最适合(快速/充分记录/等)用于设计和创建具有反向传播的神经网络？谷歌搜索 Ai4r Ai-Appp

我已按照此视频中的说明实施了反向传播. https://class.coursera.org/ml-005/lecture/51

这似乎成功,通过梯度检查,并允许我训练MNIST数字.

但是,我注意到反向传播的大多数其他解释都将输出增量计算为

d =(a - y)*f'(z) http://ufldl.stanford.edu/wiki/index.php/Backpropagation_Algorithm

而视频使用.

d =(a - y).

当我将delta乘以激活导数(S形导数)时,我不再以梯度检查的相同梯度结束(差异至少为一个数量级).

什么允许Andrew Ng(视频)省略输出增量的激活衍生物？为什么它有效？然而,当添加导数时,会计算出不正确的梯度？

编辑

我现在已经在输出上测试了线性和sigmoid激活函数,只有在我使用Ng的delta方程(没有sigmoid导数)时才进行梯度检查.

有人能否清楚解释LSTM RNN的反向传播？这是我正在使用的类型结构.我的问题不在于什么是反向传播,我理解它是一种计算用于调整神经网络权重的假设和输出误差的逆序方法.我的问题是LSTM反向传播与常规神经网络的不同之处.

我不确定如何找到每个门的初始误差.您是否使用每个门的第一个误差(由假设减去输出计算)？或者你通过一些计算调整每个门的误差？我不确定细胞状态如何在LSTM的反向支持中发挥作用.我已经彻底查看了LSTM的良好来源,但还没有找到任何.

如果我理解正确，要在 keras 中执行 TBPTT，我们必须将我们的序列分成 k 个时间步长的较小部分。根据 keras 的文档，要在序列的所有部分重用 LSTM 的状态，我们必须使用有状态参数：

您可以将 RNN 层设置为“有状态”，这意味着为一个批次中的样本计算的状态将被重新用作下一个批次中样本的初始状态。这假设不同连续批次中的样品之间存在一对一映射。

所以如果我理解正确，第一批的第一个样本是第一个序列的第一个部分，第二批的第一个样本是第一个序列的第二个部分，等等。我有 125973 个长度为 1000 的序列，我分成40 个 k=25 时间步长的序列。所以我的模型应该训练 40 个批次，包含 125973 个 25 个时间步长的序列。我的问题是我的 GPU（quadro K2200，我很穷）的内存，125973 的批量大小似乎太多了。我想知道是否可以将 LSTM 的状态保持在同一批次内并在批次之间重置它，因此我应该将批次大小设为 40 和 125973 批次。

这是我的模型：

model = Sequential()
model.add(Embedding(len(char_to_num), 200, mask_zero=True, batch_input_shape=(batch_size, k)))
model.add(Dropout(0.5))
model.add(LSTM(512, activation='relu', return_sequences=True, stateful=True))
model.add(Dropout(0.5))
model.add(TimeDistributed(Dense(len(char_to_num), activation='softmax')))

model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')
model.summary()

EDIT 2021
今年已经有了最近的答案，但这是一个老问题。与此同时，图书馆、DL 和 NLP 的状态发生了很大变化，我已经从 LSTM 转向了 Transformers。我已经很多年没有使用 LSTM 了，我没有计划也没有时间测试发布的答案。

我目前正在用普通的 numpy 实现一个 CNN，并且有一个关于最大池层反向传播的特殊情况的简短问题：

虽然很明显非最大值的梯度消失了，但我不确定切片的几个条目等于最大值的情况。严格来说，函数在这个“点”上不应该是可微的。但是，我认为可以从相应的次微分中选择一个次梯度（类似于在 x=0 处为 Relu 函数选择次梯度“0”）。

因此，我想知道简单地形成关于最大值之一的梯度并将剩余的最大值视为非最大值是否就足够了。

如果是这种情况，是否建议随机选择最大值以避免偏差，还是总是选择第一个最大值？

我用 Python 编写了一个小脚本来解决具有策略梯度的各种 Gym 环境。

import gym, os
import numpy as np
#create environment
env = gym.make('Cartpole-v0')
env.reset()
s_size = len(env.reset())
a_size = 2

#import my neural network code
os.chdir(r'C:\---\---\---\Python Code')
import RLPolicy
policy = RLPolicy.NeuralNetwork([s_size,a_size],learning_rate=0.000001,['softmax']) #a 3layer network might be ([s_size, 5, a_size],learning_rate=1,['tanh','softmax'])
#it supports the sigmoid activation function also
print(policy.weights)

DISCOUNT = 0.95 #parameter for discounting future rewards

#first step
action = policy.feedforward(env.reset)
state,reward,done,info = env.step(action)

for t in range(3000):
    done = False
    states = [] #lists for …

我正在Theano实施RNN,我很难训练它.它甚至没有记住训练语料库.我的错误很可能是由于我不能完全理解Theano如何应对随时间推移的反向传播.现在,我的代码非常简单:

grad_params = theano.tensor.grad(cost, params)

我的问题是:鉴于我的网络是经常性的,这会自动将架构展开为前馈吗？一方面,这个例子正是我正在做的事情.另一方面,这个帖子让我觉得我错了.

如果它确实为我做了展开,我怎么能截断呢？我可以看到,从文档中有一种方法,scan但我无法想出代码来做到这一点.

我正在用Python写一个神经网络,按照这里的例子.考虑到神经网络经过一万次训练后无法产生正确的值(在误差范围内),似乎反向传播算法不起作用.具体来说,我正在训练它来计算以下示例中的正弦函数:

import numpy as np

class Neuralnet:
    def __init__(self, neurons):
        self.weights = []
        self.inputs = []
        self.outputs = []
        self.errors = []
        self.rate = .1
        for layer in range(len(neurons)):
            self.inputs.append(np.empty(neurons[layer]))
            self.outputs.append(np.empty(neurons[layer]))
            self.errors.append(np.empty(neurons[layer]))
        for layer in range(len(neurons)-1):
            self.weights.append(
                np.random.normal(
                    scale=1/np.sqrt(neurons[layer]), 
                    size=[neurons[layer], neurons[layer + 1]]
                    )
                )

    def feedforward(self, inputs):
        self.inputs[0] = inputs
        for layer in range(len(self.weights)):
            self.outputs[layer] = np.tanh(self.inputs[layer])
            self.inputs[layer + 1] = np.dot(self.weights[layer].T, self.outputs[layer])
        self.outputs[-1] = np.tanh(self.inputs[-1])

    def backpropagate(self, targets):
        gradient = 1 - self.outputs[-1] * self.outputs[-1]
        self.errors[-1] …

在 pytorch 中，我通过启动反向传播（通过时间）来训练 RNN/GRU/LSTM 网络：

loss.backward()

当序列很长时，我想进行截断的时间反向传播，而不是使用整个序列的正常时间反向传播。

但我在 Pytorch API 中找不到任何参数或函数来设置截断的 BPTT。我错过了吗？我应该在 Pytorch 中自己编写代码吗？

我仍在努力理解 PyTorch autograd 系统。我正在努力解决的一件事是理解为什么.clamp(min=0)并且nn.functional.relu()似乎有不同的向后传球。

它特别令人困惑，因为它.clamp与reluPyTorch 教程中的等效用法相同，例如https://pytorch.org/tutorials/beginner/pytorch_with_examples.html#pytorch-nn。

我在分析具有一个隐藏层和 relu 激活（输出层中的线性）的简单全连接网络的梯度时发现了这一点。

据我了解，以下代码的输出应该只是零。我希望有人能告诉我我缺少什么。

import torch
dtype = torch.float

x = torch.tensor([[3,2,1],
                  [1,0,2],
                  [4,1,2],
                  [0,0,1]], dtype=dtype)

y = torch.ones(4,4)

w1_a = torch.tensor([[1,2],
                     [0,1],
                     [4,0]], dtype=dtype, requires_grad=True)
w1_b = w1_a.clone().detach()
w1_b.requires_grad = True



w2_a = torch.tensor([[-1, 1],
                     [-2, 3]], dtype=dtype, requires_grad=True)
w2_b = w2_a.clone().detach()
w2_b.requires_grad = True


y_hat_a = torch.nn.functional.relu(x.mm(w1_a)).mm(w2_a)
y_a = torch.ones_like(y_hat_a)
y_hat_b = x.mm(w1_b).clamp(min=0).mm(w2_b)
y_b = torch.ones_like(y_hat_b)

loss_a = (y_hat_a - y_a).pow(2).sum()
loss_b …