我们如何在 Keras 中定义一对一、一对多、多对一和多对多 LSTM 神经网络？

Question

我正在阅读这篇文章（The Unreasonable Effectiveness of Recurrent Neural Networks），想了解如何在 Keras 中表达一对一、一对多、多对一和多对多 LSTM 神经网络. 我已经阅读了很多关于 RNN 并了解 LSTM NN 的工作原理，特别是消失梯度、LSTM 单元、它们的输出和状态、序列输出等。但是，我无法在 Keras 中表达所有这些概念。

首先，我使用 LSTM 层创建了以下玩具神经网络

from keras.models import Model
from keras.layers import Input, LSTM
import numpy as np

t1 = Input(shape=(2, 3))
t2 = LSTM(1)(t1)
model = Model(inputs=t1, outputs=t2)

inp = np.array([[[1,2,3],[4,5,6]]])
model.predict(inp)

输出：

array([[ 0.0264638]], dtype=float32)

在我的示例中，我的输入形状为 2 x 3。据我所知，这意味着输入是 2 个向量的序列，每个向量具有 3 个特征，因此我的输入必须是 shape 的 3D 张量(n_examples, 2, 3)。在'sequences'方面，输入是一个长度为2的序列，该序列中的每个元素用3个特征表示（如有错误请指正）。当我打电话predict它时，它会返回一个带有单个标量的 2 维张量。所以，

Q1：是一对一的还是其他类型的LSTM网络？

当我们说“一个/多个输入和一个/多个输出”时

Q2：我们所说的“一个/多个输入/输出”是什么意思？“一个/多个”标量、向量、序列……，一个/多个什么？

Q3：有人可以在 Keras 中为每种类型的网络提供一个简单的工作示例：1-1、1-M、M-1 和 MM？

PS：我在一个线程中提出多个问题，因为它们非常接近并且彼此相关。

Answer 1

的区别一个到一，一到多，多到一个，多到许多仅在RNN / LSTM的情况下或网络存在的，关于工作顺序（时间）的数据上，细胞神经网络工作空间数据那里不存在这种区别。这么多总是涉及多个时间步长/一个序列

不同的物种描述了输入和输出的形状及其分类。对于输入而言，one表示单个输入量被归类为封闭量，而many表示一系列量（即图像序列、单词序列）被归类为封闭量。对于输出，one表示输出是一个标量（二元分类，即是一只鸟还是不是一只鸟 ），0或者1，many表示输出是一个单热编码向量，每个类都有一个维度（多类分类，即是一只麻雀，是a robin , ... ), 即三个类001, 010, 100：

在下面的示例中，图像和图像序列用作应分类的数量，或者您可以使用单词或...和单词序列（句子）或...：

一对一：单个图像（或单词，...）被分类为单一类别（二元分类），即这是否是一只鸟

一对多：单个图像（或单词，...）分为多个类别

多对一：图像序列（或单词，...）被分类为单个类（序列的二元分类）

多对多：图像序列（或单词，...）被分为多个类别

参见https://www.quora.com/How-can-I-choose-between-one-to-one-one-to-many-many-to-one-many-to-one-and-many-to -many-in-long-short-term-memory-LSTM

一对一 （activation=sigmoid（默认）loss=mean_squared_error）

from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
# prepare sequence
length = 5
seq = array([i/float(length) for i in range(length)])
X = seq.reshape(len(seq), 1, 1)
y = seq.reshape(len(seq), 1)
# define LSTM configuration
n_neurons = length
n_batch = length
n_epoch = 1000
# create LSTM
model = Sequential()
model.add(LSTM(n_neurons, input_shape=(1, 1)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
print(model.summary())
# train LSTM
model.fit(X, y, epochs=n_epoch, batch_size=n_batch, verbose=2)
# evaluate
result = model.predict(X, batch_size=n_batch, verbose=0)
for value in result:
    print('%.1f' % value)

来源：https : //machinelearningmastery.com/timedistributed-layer-for-long-short-term-memory-networks-in-python/

一对多用途RepeatVector()将单个数量转换为多类分类所需的序列

def test_one_to_many(self):
        params = dict(
            input_dims=[1, 10], activation='tanh',
            return_sequences=False, output_dim=3
        ),
        number_of_times = 4
        model = Sequential()
        model.add(RepeatVector(number_of_times, input_shape=(10,)))

        model.add(LSTM(output_dim=params[0]['output_dim'],
                       activation=params[0]['activation'],
                       inner_activation='sigmoid',
                       return_sequences=True,
                       ))
        relative_error, keras_preds, coreml_preds = simple_model_eval(params, model)
        # print relative_error, '\n', keras_preds, '\n', coreml_preds, '\n'
        for i in range(len(relative_error)):
            self.assertLessEqual(relative_error[i], 0.01) 

来源：https : //www.programcreek.com/python/example/89689/keras.layers.RepeatVector

替代一对多

model.add(RepeatVector(number_of_times, input_shape=input_shape))
model.add(LSTM(output_size, return_sequences=True))

来源：Keras 中的多对一和多对多 LSTM 示例

多对一，二元分类( loss=binary_crossentropy, activation=sigmoid, 全连接输出层的维数为 1 ( Dense(1)), 输出一个标量,0或1)

model = Sequential()
model.add(Embedding(5000, 32, input_length=500))
model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])        
print(model.summary())
model.fit(X_train, y_train, epochs=3, batch_size=64)
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)

多对多，多类分类( loss=sparse_categorial_crossentropy, activation=softmax, 需要对目标、ground truth 数据进行单热编码，全连接输出层的维数为 7 ( Dense71)) 输出一个 7 维向量，因为 7 个类是单热编码的)

from keras.models import Sequential
from keras.layers import *

model = Sequential()
model.add(Embedding(5000, 32, input_length=500))
model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(7, activation='softmax'))
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

model.summary()

参见Keras LSTM 多类分类

替代多对多使用TimeDistributed层 cf https://machinelearningmastery.com/timedistributed-layer-for-long-short-term-memory-networks-in-python/进行描述

from keras.models import Sequential
from keras.layers import Dense
from keras.layers import TimeDistributed
from keras.layers import LSTM
# prepare sequence
length = 5
seq = array([i/float(length) for i in range(length)])
X = seq.reshape(1, length, 1)
y = seq.reshape(1, length, 1)
# define LSTM configuration
n_neurons = length
n_batch = 1
n_epoch = 1000
# create LSTM
model = Sequential()
model.add(LSTM(n_neurons, input_shape=(length, 1), return_sequences=True))
model.add(TimeDistributed(Dense(1)))
model.compile(loss='mean_squared_error', optimizer='adam')
print(model.summary())
# train LSTM
model.fit(X, y, epochs=n_epoch, batch_size=n_batch, verbose=2)
# evaluate
result = model.predict(X, batch_size=n_batch, verbose=0)
for value in result[0,:,0]:
    print('%.1f' % value)

来源：https : //machinelearningmastery.com/timedistributed-layer-for-long-short-term-memory-networks-in-python/