Python 有没有办法减少RMSProp的代码量

我有一些简单的递归神经网络的代码，我想知道是否有办法减少更新阶段所需的代码量。我的守则是：

class RNN(object):
    def__init___(self, data, hidden_size, eps=0.0001):
        self.data = data
        self.hidden_size = hidden_size
        self.weights_hidden = np.random.rand(hidden_size, hidden_size) * 0.1 # W
        self.weights_input = np.random.rand(hidden_size, len(data[0])) * 0.1 # U
        self.weights_output = np.random.rand(len(data[0]), hidden_size) * 0.1 # V 
        self.bias_hidden = np.array([np.random.rand(hidden_size)]).T  # b
        self.bias_output = np.array([np.random.rand(len(data[0]))]).T # c

        self.cache_w_hid, self.cache_w_in, self.cache_w_out = 0, 0, 0
        self.cache_b_hid, self.cache_b_out = 0, 0
        self.eps = eps

    def train(self, seq_length, epochs, eta, decay_rate=0.9, learning_decay=0.0):
         # Other stuff
         self.update(seq, epoch, eta, decay_rate, learning_decay)
         # Other Stuff

    def update(self, seq, epoch, eta, decay_rate, learning_decay):
        """Updates the network's weights and biases by applying gradient
        descent using backpropagation through time and RMSPROP. 
        """
        delta_nabla_c, delta_nabla_b,\
        delta_nabla_V, delta_nabla_W, delta_nabla_U = self.backward_pass(seq)

        eta = eta*np.exp(-epoch*learning_decay)

        self.cache_w_hid += decay_rate * self.cache_w_hid \
                           + (1 - decay_rate) * delta_nabla_W**2
        self.weights_hidden -= eta * delta_nabla_W / (np.sqrt(self.cache_w_hid) + self.eps)

        self.cache_w_in += decay_rate * self.cache_w_in \
                          + (1 - decay_rate) * delta_nabla_U**2         
        self.weights_input -= eta * delta_nabla_U / (np.sqrt(self.cache_w_in) + self.eps)

        self.cache_w_out += decay_rate * self.cache_w_out \
                           + (1 - decay_rate) * delta_nabla_V**2
        self.weights_output -= eta * delta_nabla_V / (np.sqrt(self.cache_w_out) + self.eps)

        self.cache_b_hid += decay_rate * self.cache_b_hid \
                          + (1 - decay_rate) * delta_nabla_b**2
        self.bias_hidden -= eta * delta_nabla_b / (np.sqrt(self.cache_b_hid) + self.eps)

        self.cache_b_out += decay_rate * self.cache_b_out \
                          + (1 - decay_rate) * delta_nabla_c**2
        self.bias_output -= eta * delta_nabla_c / (np.sqrt(self.cache_b_out) + self.eps)

对于

#RMSProp

下的每个变量，都遵循更新规则，即：

cache = decay_rate * cache + (1 - decay_rate) * dx**2
x += - learning_rate * dx / (np.sqrt(cache) + eps)

---

我已经声明了

cache\u

所有，然后是

self.weight\u

或

self.bias\u

，我想把它写得更简洁一些。我正在考虑使用

zip（）

，但我不知道该怎么做

从您的问题判断，我猜您正在努力提高可读性/优雅性，而不是其他类型的优化

您可以引入一个函数来实现更新规则，然后为每个变量调用一次。这里的诀窍是Python允许您按名称访问属性，因此您可以传入缓存的名称和权重属性，而不是值。这将允许您更新未来过程的值：

def update_rule(self, cache_attr, x_attr, decay_rate, learning_rate, dx):
    cache = getattr(self, cache_attr)
    cache = decay_rate * cache + (1 - decay_rate) * dx**2
    setattr(self, cache_attr, cache)

    x = getattr(self, x_attr)
    x += - learning_rate * dx / (np.sqrt(cache) + self.eps)
    setattr(self, x_attr, x)

def update(self, seq, epoch, eta, decay_rate, learning_decay):
    """Updates the network's weights and biases by applying gradient
    descent using backpropagation through time and RMSPROP. 
    """
    delta_nabla_c, delta_nabla_b,\
    delta_nabla_V, delta_nabla_W, delta_nabla_U = self.backward_pass(seq)

    eta = eta*np.exp(-epoch*learning_decay)

    self.update_rule('cache_w_hid', 'weights_hidden', decay_rate, eta, delta_nabla_W)
    self.update_rule('cache_w_in', 'weights_input', decay_rate, eta, delta_nabla_U)
    self.update_rule('cache_w_out', 'weights_output', decay_rate, eta, delta_nabla_V)
    self.update_rule('cache_b_hid', 'bias_hidden', decay_rate, eta, delta_nabla_b)
    self.update_rule('cache_b_out', 'bias_output', decay_rate, eta, delta_nabla_c)

事实上，通过将

update\u rule

放入

update

中，您可以保存其他参数并避免暴露基本上是私有的方法。这将在调用时将

update

的命名空间公开给

update\u rule

，因此您不必传入

decation\u rate

和

learning\u rate

：

def update(self, seq, epoch, eta, decay_rate, learning_decay):
    """Updates the network's weights and biases by applying gradient
    descent using backpropagation through time and RMSPROP. 
    """

    def update_rule(cache_attr, x_attr, dx):
        cache = getattr(self, cache_attr)
        cache = decay_rate * cache + (1 - decay_rate) * dx**2
        setattr(self, cache_attr, cache)

        x = getattr(self, x_attr)
        x += - eta * dx / (np.sqrt(cache) + self.eps)
        setattr(self, x_attr, x)

    delta_nabla_c, delta_nabla_b,\
    delta_nabla_V, delta_nabla_W, delta_nabla_U = self.backward_pass(seq)

    eta = eta*np.exp(-epoch*learning_decay)

    update_rule('cache_w_hid', 'weights_hidden', delta_nabla_W)
    update_rule('cache_w_in', 'weights_input', delta_nabla_U)
    update_rule('cache_w_out', 'weights_output', delta_nabla_V)
    update_rule('cache_b_hid', 'bias_hidden', delta_nabla_b)
    update_rule('cache_b_out', 'bias_output', delta_nabla_c)

最后，如果确实需要，可以使用

zip

将对

update\u rule

的调用放入循环中。请注意，对于这个版本，调用的顺序已更改为与self.backward\u pass返回的值的顺序相匹配。就我个人而言，除非你真的有很多更新要做，否则我不会使用最后一个版本，因为除了它对

向后传递的结果非常敏感这一事实之外，它开始看起来很模糊

def update(self, seq, epoch, eta, decay_rate, learning_decay):
    """Updates the network's weights and biases by applying gradient
    descent using backpropagation through time and RMSPROP. 
    """

    def update_rule(cache_attr, x_attr, dx):
        cache = getattr(self, cache_attr)
        cache = decay_rate * cache + (1 - decay_rate) * dx**2
        setattr(self, cache_attr, cache)

        x = getattr(self, x_attr)
        x += - eta * dx / (np.sqrt(cache) + self.eps)
        setattr(self, x_attr, x)

    dx = self.backward_pass(seq)

    eta = eta*np.exp(-epoch*learning_decay)

    cache_attrs = ('cache_b_out', 'cache_b_hid', 'cache_w_out', 'cache_w_hid', 'cache_w_in')
    x_attrs = ('bias_output', 'bias_hidden', 'weights_output', 'weights_hidden', 'weights_input')

    for args in zip(cache_attrs, x_attrs, dx):
        update_rule(*args)

代码在哪里？在脚本/模块中，是类还是函数？使用
self
表示一种方法，但是使用像
cache\u w\u hid
这样的全局变量指向一个模块或类。这完美地回答了我的问题。谢谢正在处理应答。等等，您每次都故意将缓存设置为零？那么缓存变量也必须是在
\uuuuu init\uuuu
中设置的实例属性。这就是为什么我被你发布的第一段代码弄糊涂了。希望你不介意我的编辑。此外，请解决缓存更新中的差异。在您的代码中，它是
缓存*+=…
。在您的规则中，它是
缓存\*=…
。