我们如何在Keras中定义一对一，一对多，多对一和多对多的LSTM神经网络？ [重复]

问题描述 投票：1回答：1

这个问题在这里已有答案：

我正在阅读this文章（回归神经网络的不合理有效性），并希望了解如何在Keras中表达一对一，一对多，多对一和多对多的LSTM神经网络。我已经阅读了很多关于RNN的知识，并了解LSTM NN是如何工作的，特别是消失梯度，LSTM单元，它们的输出和状态，序列输出等。但是，我在Keras中难以表达所有这些概念。

首先，我使用LSTM层创建了以下玩具NN

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×3。据我所知，这意味着输入是2个向量的序列，每个向量有3个特征，因此我的输入必须是形状(n_examples, 2, 3)的3D张量。就“序列”而言，输入是长度为2的序列，序列中的每个元素由3个特征表示（如果我错了，请纠正我）。当我调用predict时，它返回一个带有单个标量的2-dim张量。所以，

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

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

Q2：“一个/多个输入/输出”是什么意思？一个/多个标量，矢量（s），序列......，一个/多个什么？

问题3：有人可以在Keras为每种类型的网络提供一个简单的工作示例：1-1,1-M，M-1和M-M？

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

python neural-network keras lstm recurrent-neural-network
1个回答
3
投票

区分一对一，一对多，多对一，多对多仅在RNN / LSTM或处理顺序（时间）数据的网络中存在，CNN处理空间数据这种区别不存在。这么多人总是涉及多个时间步/一个序列

不同的物种描述了输入和输出的形状及其分类。对于输入，一个意味着单个输入量被分类为封闭量，并且许多意味着一系列量（即图像序列，单词序列）被分类为封闭量。对于输出，一个意味着输出是标量（二进制分类，即鸟或不是鸟）0或1，许多意味着输出是一个单热编码的矢量，每个类一维（多类分类即麻雀） ，是一个知更鸟，...），为三类001, 010, 100：

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

一对一：单个图像（或单词，......）被分类为单个类别（二进制分类），即这是一只鸟还是没有

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

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

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

cf 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))

来源：Many to one and many to many LSTM examples in Keras

多对一，二进制分类（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，需要目标的单热编码，地面实况数据，完全连接的输出层的维数为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()

cf Keras LSTM multiclass classification

使用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/

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.