标签: sequence-to-sequence

我似乎无法找到如何将数据输入Keras的问题的具体答案.大多数示例似乎都可以处理图像/文本数据,并且具有明确定义的数据点.

我正在尝试将音乐输入LSTM神经网络.我希望网络能够播放约3秒钟的音乐并提名接下来的2秒钟.我将我的音乐准备好.wav文件并分成5秒间隔,我已经分解为我的X(前3秒)和Y(最后2秒).我已经在44,100赫兹对我的音乐进行了采样,所以我的X是132,300观察'长'而我的Y是'88,200'观察长.

但我无法弄清楚如何将Keras与我的数据结构联系起来.我正在使用Tensorflow后端.

为了概括问题和答案,我将使用A,B,C来表示维度.这个示例数据和我的实际数据之间的唯一区别是这些是从0到1分布的随机值,而我的数据是整数数组.

import numpy as np
#using variables to make it easy to generalize the answer

#a = the number of observations I have
a       = 411

#b = the duration of the sample, 44.1k observations per second of music
b_train = 132300
b_test  = 88200

#c = the number of channels in the music, this is 2 channel stereo
c       = 2

#now create sample data with the dimensionality given above:
X = np.random.rand(a,b_train,c)
y = np.random.rand(a,b_test …

我正在研究序列预测问题，并且在这方面没有太多经验，因此下面的一些问题可能很幼稚。

仅供参考：我在这里创建了一个重点关注 CRF 的后续问题

我有以下问题：

我想预测多个非独立变量的二元序列。

输入：

我有一个包含以下变量的数据集：

1. 时间戳
2. A组和B组
3. 与特定时间戳的每个组相对应的二进制信号

此外，假设以下情况：

1. 我们可以从时间戳（例如一天中的小时）中提取其他属性，这些属性可以用作外部预测器
2. 我们认为 A 组和 B 组不是独立的，因此联合建模他们的行为可能是最佳选择

binary_signal_group_A和binary_signal_group_B是我想使用（1）它们过去的行为和（2）从每个时间戳提取的附加信息来预测的 2 个非独立变量。

到目前为止我所做的：

# required libraries
import re
import numpy as np
import pandas as pd
from keras import Sequential
from keras.layers import LSTM

data_length = 18  # how long our data series will be
shift_length = 3  # how long of a sequence do we want

df = (pd.DataFrame  # create a sample dataframe
    .from_records(np.random.randint(2, …

从PyTorch Seq2Seq教程,http: //pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html#attention-decoder

我们看到注意机制严重依赖于MAX_LENGTH参数来确定输出维数attn -> attn_softmax -> attn_weights,即

class AttnDecoderRNN(nn.Module):
    def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):
        super(AttnDecoderRNN, self).__init__()
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.dropout_p = dropout_p
        self.max_length = max_length

        self.embedding = nn.Embedding(self.output_size, self.hidden_size)
        self.attn = nn.Linear(self.hidden_size * 2, self.max_length)
        self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)
        self.dropout = nn.Dropout(self.dropout_p)
        self.gru = nn.GRU(self.hidden_size, self.hidden_size)
        self.out = nn.Linear(self.hidden_size, self.output_size)

进一步来说

self.attn = nn.Linear(self.hidden_size * 2, self.max_length)

我理解MAX_LENGTH变量是减少no的机制.需要训练的参数AttentionDecoderRNN.

如果我们没有MAX_LENGTH预先决定.我们应该用什么值初始化attn图层？ …

我遇到的一些教程是使用随机初始化的嵌入矩阵进行描述的，然后使用该tf.nn.embedding_lookup函数获取整数序列的嵌入。我的印象是，由于embedding_matrix是通过获得的tf.get_variable，优化器将添加适当的操作来更新它。

我不明白的是，通过查找函数反向传播是如何发生的，查找函数似乎是硬的而不是软的。此操作的梯度是多少。输入ID之一？

为了处理不同长度的序列，我们使用分桶和填充。在分桶中，我们为某些 max_len 制作不同的桶，我们这样做是为了减少填充量，在制作不同的桶后，我们在不同的桶上训练不同的模型。

这是我目前发现的。但我不明白的是，这些不同的模型是如何训练的，以及它们如何用于翻译一个新句子？

我想创建一个使用注意机制的多层动态RNN解码器.为此,我首先创建一个注意机制:

attention_mechanism = BahdanauAttention(num_units=ATTENTION_UNITS,
                                        memory=encoder_outputs,
                                        normalize=True)

然后我用AttentionWrapper注意机制包装一个LSTM单元格:

attention_wrapper = AttentionWrapper(cell=self._create_lstm_cell(DECODER_SIZE),
                                             attention_mechanism=attention_mechanism,
                                             output_attention=False,
                                             alignment_history=True,
                                             attention_layer_size=ATTENTION_LAYER_SIZE)

其中self._create_lstm_cell定义如下:

@staticmethod
def _create_lstm_cell(cell_size):
    return BasicLSTMCell(cell_size)

然后我做一些簿记(例如创建我的MultiRNNCell,创建初始状态,创建一个TrainingHelper等)

        attention_zero = attention_wrapper.zero_state(batch_size=tf.flags.FLAGS.batch_size, dtype=tf.float32)

        # define initial state
        initial_state = attention_zero.clone(cell_state=encoder_final_states[0])

        training_helper = TrainingHelper(inputs=self.y,  # feed in ground truth
                                         sequence_length=self.y_lengths)  # feed in sequence lengths

        layered_cell = MultiRNNCell(
            [attention_wrapper] + [ResidualWrapper(self._create_lstm_cell(cell_size=DECODER_SIZE))
                                   for _ in range(NUMBER_OF_DECODER_LAYERS - 1)])

        decoder = BasicDecoder(cell=layered_cell,
                               helper=training_helper,
                               initial_state=initial_state)

        decoder_outputs, decoder_final_state, decoder_final_sequence_lengths = dynamic_decode(decoder=decoder,
                                                                                              maximum_iterations=tf.flags.FLAGS.max_number_of_scans // 12,
                                                                                              impute_finished=True) …

我最近尝试使用Google的seq2seq来建立一个小型的NMT系统.我设法让一切工作正常,但我仍然想知道时代数和模型训练步数之间的确切差异.

如果我没有弄错的话,一个时期包含多个训练步骤,并且一旦您的整个训练数据被处理一次就过去了.但是,当我查看Google自己的NMT教程中的文档时,我不明白两者之间的区别.请注意以下代码段的最后一行.

export DATA_PATH=

export VOCAB_SOURCE=${DATA_PATH}/vocab.bpe.32000
export VOCAB_TARGET=${DATA_PATH}/vocab.bpe.32000
export TRAIN_SOURCES=${DATA_PATH}/train.tok.clean.bpe.32000.en
export TRAIN_TARGETS=${DATA_PATH}/train.tok.clean.bpe.32000.de
export DEV_SOURCES=${DATA_PATH}/newstest2013.tok.bpe.32000.en
export DEV_TARGETS=${DATA_PATH}/newstest2013.tok.bpe.32000.de

export DEV_TARGETS_REF=${DATA_PATH}/newstest2013.tok.de
export TRAIN_STEPS=1000000

在我看来,似乎只有一种方法来定义训练步骤的数量,而不是模型的时代数量.是否有可能在术语上存在重叠,因此没有必要定义多个时期？

我遇到了一个大问题。对于我的学士论文，我必须使用 BERT 制作一个机器翻译模型。但我现在一事无成。你知道文档或可以帮助我的东西吗？我已经在这个方向上阅读了一些论文，但也许有文档或教程可以帮助我。

对于我的学士论文，我必须将文本摘要翻译成标题。我希望有一个人可以帮助我。