Последовательность Tensorflow Sequence для последовательности с использованием API seq2seq (версия 1.1 и выше)

Я использую TensorFlow v: 1.1, и я хотел бы реализовать модель для последовательности, используя tf.contrib.seq2seq api. Однако мне трудно понять, как использовать все функции (BasicDecoder, Dynamic_decode, Helper, Training Helper...) для создания моей модели.

Вот моя настройка: я хотел бы "перевести" последовательность вектор-функций: (batch_size, encoder_max_seq_len, feature_dim) в последовательность разной длины (batch_size, decoder_max_len, 1).

У меня уже есть encoder, который является RNN с ячейкой LSTM, и я получаю его конечное состояние, которое я хотел бы передать декодеру в качестве начального ввода. У меня уже есть ячейка для моего декодера MultiRNNCell LSM. Не могли бы вы помочь мне построить последнюю часть, используя функции tf.contrib.seq2seq2 и dynamic_decode (пример кода или объяснений будет очень оценен)?

Вот мой код:

import tensorflow as tf
from tensorflow.contrib import seq2seq
from tensorflow.contrib import rnn
import math

from data import gen_sum_2b2

class Seq2SeqModel:
def __init__(self,
             in_size,
             out_size,
             embed_size,
             n_symbols,
             cell_type,
             n_units,
             n_layers):
    self.in_size = in_size
    self.out_size = out_size
    self.embed_size = embed_size
    self.n_symbols = n_symbols
    self.cell_type = cell_type
    self.n_units = n_units
    self.n_layers = n_layers

    self.build_graph()

def build_graph(self):
    self.init_placeholders()
    self.init_cells()
    self.encoder()
    self.decoder_train()
    self.loss()
    self.training()

def init_placeholders(self):
    with tf.name_scope('Placeholders'):
        self.encoder_inputs = tf.placeholder(shape=(None, None, self.in_size), 
                                             dtype=tf.float32, name='encoder_inputs')
        self.decoder_targets = tf.placeholder(shape=(None, None),
                                              dtype=tf.int32, name='decoder_targets')
        self.seqs_len = tf.placeholder(dtype=tf.int32)
        self.batch_size = tf.placeholder(tf.int32, name='dynamic_batch_size')
        self.max_len = tf.placeholder(tf.int32, name='dynamic_seq_len')
        decoder_inputs = tf.reshape(self.decoder_targets, shape=(self.batch_size,
                                    self.max_len, self.out_size))
        self.decoder_inputs = tf.cast(decoder_inputs, tf.float32)
        self.eos_step = tf.ones([self.batch_size, 1], dtype=tf.float32, name='EOS')
        self.pad_step = tf.zeros([self.batch_size, 1], dtype=tf.float32, name='PAD')

def RNNCell(self):
    c = self.cell_type(self.n_units, reuse=None)
    c = rnn.MultiRNNCell([self.cell_type(self.n_units) for i in range(self.n_layers)])
    return c

def init_cells(self):
    with tf.variable_scope('RNN_enc_cell'):
        self.encoder_cell = self.RNNCell()  
    with tf.variable_scope('RNN_dec_cell'):
        self.decoder_cell = rnn.OutputProjectionWrapper(self.RNNCell(), self.n_symbols)

def encoder(self):
    with tf.variable_scope('Encoder'):
        self.init_state = self.encoder_cell.zero_state(self.batch_size, tf.float32) 
        _, self.encoder_final_state = tf.nn.dynamic_rnn(self.encoder_cell, self.encoder_inputs,
                                                        initial_state=self.init_state)

Ответы

Ответ 1

Уровень декодирования:

Декодирование состоит из двух частей из-за их различий во время training и inference:

Вход декодера на определенном временном шаге всегда поступает от выхода предыдущего временного шага. Но во время обучения выход фиксированныйк фактической цели (фактическая цель возвращается в качестве входного сигнала), и это показало, что она улучшает производительность.

Оба они обрабатываются с использованием методов из tf.contrib.seq2seq.

  • Основная функция для decoder: seq2seq.dynamic decoder(), которая выполняет динамическое декодирование:

    tf.contrib.seq2seq.dynamic_decode(decoder,maximum_iterations)

    В качестве входных данных используется экземпляр decoder и maximum_iterations=maximum seq length.

    1.1 Пример decoder:

    seq2seq.BasicDecoder(cell, helper, initial_state,output_layer)

    Входы: cell (экземпляр RNNCell), helper (вспомогательный экземпляр), initial_state (начальное состояние декодера, которое должно быть выходным состоянием кодировщика) и output_layer (необязательный плотный слой в качестве выходов для прогнозирования)

    1.2 Экземпляр RNNCell может быть rnn.MultiRNNCell().

    1.3 Экземпляр helper - это тот, который отличается в training и inference. Во время training мы хотим, чтобы входы были поданы в декодер, а во время inference мы хотим, чтобы выход декодера в time-step (t) передавался в качестве входа в декодер в time step (t+1).

    Для обучения: используется вспомогательная функция:                seq2seq.TrainingHelper(inputs, sequence_length), который просто считывает входы.

    Для вывода: мы вызываем вспомогательную функцию:                seq2seq.GreedyEmbeddingHelper() or seqseq.SampleEmbeddingHelper(), который отличается тем, следует ли использовать argmax() or sampling(from a distribution) выходов и передает результат через слой внедрения, чтобы получить следующий вход.

Объединение: модель Seq2Seq

  • Получить состояние кодировщика из encoder layer и передать его в качестве initial_state в декодер.
  • Получите выходные данные decoder train и decoder inference с помощью seq2seq.dynamic_decoder(). Когда вы вызываете оба метода, убедитесь, что весы разделены. (Используйте variable_scope для повторного использования веса)
  • Затем тренируйте сеть, используя функцию потерь seq2seq.sequence_loss.

Ниже приведен пример кода здесь и здесь.