为什么使用for循环在RNN中进行缓慢学习？

Question

问题设置

作为RNN的初学者，我目前正在为4个字母的单词建立 3比1 自动完成 RNN模型，其中输入为3字母不完整的单词，并且输出是一个完整的单词的单字母。例如，我希望具有以下模型预测：

• 输入：“ C”，“ A”，“ F”
• 输出：“ E”

---

代码-生成数据集

为了从RNN模型中获得所需的结果，我制作了一个（不平衡的）数据集，如下所示：

import string
import numpy as np       
import tensorflow as tf
import matplotlib.pyplot as plt

alphList  = list(string.ascii_uppercase) # Define a list of alphabets
alphToNum = {n: i for i, n in enumerate(alphList)} # dic of alphabet-numbers

# Make dataset
# define words of interest
fourList = ['CARE', 'CODE', 'COME', 'CANE', 'COPE', 'FISH', 'JAZZ', 'GAME', 'WALK', 'QUIZ']

# (len(Sequence), len(Batch), len(Observation)) following tensorflow-style
first3Data = np.zeros((3, len(fourList), len(alphList)), dtype=np.int32)
last1Data  = np.zeros((len(fourList), len(alphList)), dtype=np.int32)

for idxObs, word in enumerate(fourList):
    # Make an array of one-hot vectors consisting of first 3 letters
    first3 = [alphToNum[n] for n in word[:-1]]
    first3Data[:,idxObs,:] = np.eye(len(alphList))[first3]
    # Make an array of one-hot vectors consisting of last 1 letter
    last1  = alphToNum[word[3]]
    last1Data[idxObs,:]    = np.eye(len(alphList))[last1]

因此，fourList包含训练数据信息，first3Data包含训练数据的所有一个一键编码的前三个字母，last1Data包含所有的一个一键编码的最后1个字母训练数据的字母。

---

代码-构建模型

按照 3比1 RNN模型的标准设置，我编写了以下代码。

# Hyperparameters
n_data        = len(fourList)
n_input       = len(alphList)  # number of input units
n_hidden      = 128            # number of hidden units
n_output      = len(alphList)  # number of output units
learning_rate = 0.01
total_epoch   = 100000

# Variables (separate version)
W_in  = tf.Variable(tf.random_normal([n_input, n_hidden]))
W_rec = tf.Variable(tf.random_normal([n_hidden, n_hidden]))
b_rec = tf.Variable(tf.random_normal([n_hidden]))
W_out = tf.Variable(tf.random_normal([n_hidden, n_output]))
b_out = tf.Variable(tf.random_normal([n_output]))

# Manual calculation of RNN output
def RNNoutput(Xinput):
    h_state    = tf.random_normal([1,n_hidden]) # initial hidden state

    for iX in Xinput:
        h_state = tf.nn.tanh(iX @ W_in + (h_state @ W_rec + b_rec))

    rnn_output = h_state @ W_out + b_out
    return(rnn_output)

请注意，Manual calculation of RNN output部分基本上使用矩阵乘法和tanh激活函数将隐藏状态精确地滚动了4次，如下所示：

tf.nn.tanh(iX @ W_in + (h_state @ W_rec + b_rec))

在这里，每当传递全部数据时，一个时期就完成了。因此，每当我传递数据时，我都会初始化h_state。此外，请注意我没有使用占位符，这可能是学习不稳定的原因。

---

代码-火车

我已经使用以下代码来训练网络。

# Cost / optimizer definition
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=RNNoutput(first3Data),
                                                                 labels=last1Data))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)

# Train and keep track of the loss history
sess = tf.Session()
sess.run(tf.global_variables_initializer())

lossHistory = []
for epoch in range(total_epoch):
    _, loss = sess.run([optimizer, cost])
    lossHistory.append(loss)

---

问题

所得到的学习曲线如下所示。确实，它显示出指数衰减。

但是，对于我来说，对于这种简单的示例而言，它看起来太摇摆了，即使在学习后期也显示出一些不稳定。

plt.plot(range(total_epoch), lossHistory)
plt.show()

---

可能的解释吗？

我认为学习曲线应该显示出使用tensorflow内置函数（*）所期望的正方形稳定衰减模式。但是我认为这种不稳定性可以解释如下：

• 参数随机初始化的不稳定性
• 由于在定义RNNoutput时连续相加而导致的数值不稳定
• 不使用tensor for loop，而是直接在数据中使用for循环

但是我认为这些都不起关键作用。 还有其他解决方案可以帮助我吗？

---

（*）我已经看到使用tensorflow内置函数实现简单RNN的近似方阵损耗衰减。但是抱歉，由于时间用完，我没有包括要比较的结果...我想我可以很快进行编辑。

Answer 1

这种将初始状态设置为零的修改似乎可以解决该问题。

[6, 1, 3, 4, 6, 2]