实现一个用来执行加法的序列到序列学习模型

输入: "535+61"

输出: "596"

使用重复的标记字符（空格）处理填充。

输入可以选择性地反转，它被认为可以提高许多任务的性能，例如：Learning to Execute以及Sequence to Sequence Learning with Neural Networks。

从理论上讲，它引入了源和目标之间的短期依赖关系。

两个反转的数字 + 一个 LSTM 层（128个隐藏单元），在 55 个 epochs 后，5k 的训练样本取得了 99% 的训练/测试准确率。

三个反转的数字 + 一个 LSTM 层（128个隐藏单元），在 100 个 epochs 后，50k 的训练样本取得了 99% 的训练/测试准确率。

四个反转的数字 + 一个 LSTM 层（128个隐藏单元），在 20 个 epochs 后，400k 的训练样本取得了 99% 的训练/测试准确率。

五个反转的数字 + 一个 LSTM 层（128个隐藏单元），在 30 个 epochs 后，550k 的训练样本取得了 99% 的训练/测试准确率。

  1. from __future__ import print_function
  2. from keras.models import Sequential
  3. from keras import layers
  4. import numpy as np
  5. from six.moves import range
  8. class CharacterTable(object):
  9.     """给定一组字符：
  10.     + 将它们编码为 one-hot 整数表示
  11.     + 将 one-hot 或整数表示解码为字符输出
  12.     + 将一个概率向量解码为字符输出
  13.     """
  14.     def __init__(self, chars):
  15.         """初始化字符表。
  17.         # 参数：
  18.             chars: 可以出现在输入中的字符。
  19.         """
  20.         self.chars = sorted(set(chars))
  21.         self.char_indices = dict((c, i) for i, c in enumerate(self.chars))
  22.         self.indices_char = dict((i, c) for i, c in enumerate(self.chars))
  24.     def encode(self, C, num_rows):
  25.         """给定字符串 C 的 one-hot 编码。
  27.         # 参数
  28.             C: 需要编码的字符串。
  29.             num_rows: 返回的 one-hot 编码的行数。
  30.                       这用来保证每个数据的行数相同。
  31.         """
  32.         x = np.zeros((num_rows, len(self.chars)))
  33.         for i, c in enumerate(C):
  34.             x[i, self.char_indices[c]] = 1
  35.         return x
  37.     def decode(self, x, calc_argmax=True):
  38.         """将给定的向量或 2D array 解码为它们的字符输出。
  40.         # 参数
  41.             x: 一个向量或 2D 概率数组或 one-hot 表示，
  42.                或 字符索引的向量（如果 `calc_argmax=False`）。
  43.             calc_argmax: 是否根据最大概率来找到字符，默认为 `True`。
  44.         """
  45.         if calc_argmax:
  46.             x = x.argmax(axis=-1)
  47.         return ''.join(self.indices_char[x] for x in x)
  50. class colors:
  51.     ok = '\033[92m'
  52.     fail = '\033[91m'
  53.     close = '\033[0m'
  55. # 模型和数据的参数
  56. TRAINING_SIZE = 50000
  57. DIGITS = 3
  58. REVERSE = True
  60. # 输入的最大长度是 'int+int' (例如, '345+678'). int 的最大长度为 DIGITS。
  61. MAXLEN = DIGITS + 1 + DIGITS
  63. # 所有的数字，加上符号，以及用于填充的空格。
  64. chars = '0123456789+ '
  65. ctable = CharacterTable(chars)
  67. questions = []
  68. expected = []
  69. seen = set()
  70. print('Generating data...')
  71. while len(questions) < TRAINING_SIZE:
  72.     f = lambda: int(''.join(np.random.choice(list('0123456789'))
  73.                     for i in range(np.random.randint(1, DIGITS + 1))))
  74.     a, b = f(), f()
  75.     # 跳过任何已有的加法问题
  76.     # 同事跳过任何 x+Y == Y+x 的情况(即排序)。
  77.     key = tuple(sorted((a, b)))
  78.     if key in seen:
  79.         continue
  80.     seen.add(key)
  81.     # 利用空格填充，是的长度始终为 MAXLEN。
  82.     q = '{}+{}'.format(a, b)
  83.     query = q + ' ' * (MAXLEN - len(q))
  84.     ans = str(a + b)
  85.     # 答案可能的最长长度为 DIGITS + 1。
  86.     ans += ' ' * (DIGITS + 1 - len(ans))
  87.     if REVERSE:
  88.         # 反转查询，例如，'12+345  ' 变成 '  543+21'. 
  89.         # (注意用于填充的空格)
  90.         query = query[::-1]
  91.     questions.append(query)
  92.     expected.append(ans)
  93. print('Total addition questions:', len(questions))
  95. print('Vectorization...')
  96. x = np.zeros((len(questions), MAXLEN, len(chars)), dtype=np.bool)
  97. y = np.zeros((len(questions), DIGITS + 1, len(chars)), dtype=np.bool)
  98. for i, sentence in enumerate(questions):
  99.     x[i] = ctable.encode(sentence, MAXLEN)
  100. for i, sentence in enumerate(expected):
  101.     y[i] = ctable.encode(sentence, DIGITS + 1)
  103. # 混洗 (x, y)，因为 x 的后半段几乎都是比较大的数字。
  104. indices = np.arange(len(y))
  105. np.random.shuffle(indices)
  106. x = x[indices]
  107. y = y[indices]
  109. # 显式地分离出 10% 的训练数据作为验证集。
  110. split_at = len(x) - len(x) // 10
  111. (x_train, x_val) = x[:split_at], x[split_at:]
  112. (y_train, y_val) = y[:split_at], y[split_at:]
  114. print('Training Data:')
  115. print(x_train.shape)
  116. print(y_train.shape)
  118. print('Validation Data:')
  119. print(x_val.shape)
  120. print(y_val.shape)
  122. # 可以尝试更改为 GRU, 或 SimpleRNN。
  123. RNN = layers.LSTM
  124. HIDDEN_SIZE = 128
  125. BATCH_SIZE = 128
  126. LAYERS = 1
  128. print('Build model...')
  129. model = Sequential()
  130. # 利用 RNN 将输入序列「编码」为一个 HIDDEN_SIZE 长度的输出向量。
  131. # 注意：在输入序列具有可变长度的情况下,
  132. # 使用 input_shape=(None, num_feature).
  133. model.add(RNN(HIDDEN_SIZE, input_shape=(MAXLEN, len(chars))))
  134. # 作为解码器 RNN 的输入，为每个时间步重复地提供 RNN 的最后输出。
  135. # 重复 'DIGITS + 1' 次，因为它是最大输出长度。
  136. # 例如，当 DIGITS=3, 最大输出为 999+999=1998。
  137. model.add(layers.RepeatVector(DIGITS + 1))
  138. # 解码器 RNN 可以是多个堆叠的层，或一个单独的层。
  139. for _ in range(LAYERS):
  140.     # 通过设置 return_sequences 为 True, 将不仅返回最后一个输出，而是返回目前的所有输出，形式为(num_samples, timesteps, output_dim)。
  141.     # 这是必须的，因为后面的 TimeDistributed 需要第一个维度是时间步。
  142.     model.add(RNN(HIDDEN_SIZE, return_sequences=True))
  144. # 将全连接层应用于输入的每个时间片。
  145. # 对于输出序列的每一步，决定应选哪个字符。
  146. model.add(layers.TimeDistributed(layers.Dense(len(chars), activation='softmax')))
  147. model.compile(loss='categorical_crossentropy',
  148.               optimizer='adam',
  149.               metrics=['accuracy'])
  150. model.summary()
  152. # 训练模型，并在每一代显示验证数据的预测。
  153. for iteration in range(1, 200):
  154.     print()
  155.     print('-' * 50)
  156.     print('Iteration', iteration)
  157.     model.fit(x_train, y_train,
  158.               batch_size=BATCH_SIZE,
  159.               epochs=1,
  160.               validation_data=(x_val, y_val))
  161.     # 从随机验证集中选择 10 个样本，以便我们可以看到错误。
  162.     for i in range(10):
  163.         ind = np.random.randint(0, len(x_val))
  164.         rowx, rowy = x_val[np.array([ind])], y_val[np.array([ind])]
  165.         preds = model.predict_classes(rowx, verbose=0)
  166.         q = ctable.decode(rowx[0])
  167.         correct = ctable.decode(rowy[0])
  168.         guess = ctable.decode(preds[0], calc_argmax=False)
  169.         print('Q', q[::-1] if REVERSE else q, end=' ')
  170.         print('T', correct, end=' ')
  171.         if correct == guess:
  172.             print(colors.ok + '☑' + colors.close, end=' ')
  173.         else:
  174.             print(colors.fail + '☒' + colors.close, end=' ')
  175.         print(guess)