tf.contrib.training.SequenceQueueingStateSaver

SequenceQueueingStateSaver предоставляет доступ к состоянию значений из входных данных.

tf.contrib.training.SequenceQueueingStateSaver(
    batch_size, num_unroll, input_length, input_key, input_sequences, input_context,
    initial_states, capacity=None, allow_small_batch=False, name=None
)

Этот класс предназначен для использования вместо, например, Queue, для разделения входных данных последовательностей переменной длины на сегменты последовательностей фиксированной длины и их объединения в мини-пакеты. Он сохраняет контексты и состояние для последовательности в сегментах. Его можно использовать совместно с QueueRunner (см. пример ниже).

SequenceQueueingStateSaver (SQSS) принимает по одному примеру за раз через входы input_length, input_key, input_sequences (словарь), input_context (словарь) и initial_states (словарь). Последовательности, значения в input_sequences, могут иметь переменную первую размерность (padded_length), хотя эта размерность всегда должна быть кратной num_unroll. Все остальные размерности должны быть фиксированными и доступными через вызовы get_shape. Длина до заполнения может быть записана в input_length. Значения контекста в input_context должны иметь фиксированные и хорошо определенные размерности. Начальные значения состояния должны иметь фиксированные и хорошо определенные размерности.

SQSS разбивает последовательности входного примера на сегменты длиной num_unroll. Между примерами формируются мини-пакеты размером batch_size. Эти мини-пакеты содержат сегмент последовательностей, копируют значения контекста и сохраняют информацию о состоянии, длине и ключе исходных входных примеров. В первом сегменте примера состояние всё ещё является начальным состоянием. Его можно обновить; обновленные значения состояния доступны в последующих сегментах того же примера. После каждого сегмента необходимо вызвать batch.save_state(), что выполняется state_saving_rnn. Без этого вызова операция декьюинга, связанная с SQSS, не будет выполнена. Внутренне SQSS имеет очередь для входных примеров. Её capacity настраивается. Если он меньше batch_size, операция декьюинга будет блокироваться неопределённо долго. Небольшое кратное значение batch_size - хороший ориентир для предотвращения превращения очереди в узкое место и замедления обучения. Если он слишком большой (по умолчанию он не ограничен), увеличивается потребление памяти. Кроме того, при многократном повторении одних и тех же входных примеров с использованием одного и того же key значение capacity должно быть меньше количества примеров.

Префечер, который считывает одну развернутую последовательность входных данных переменной длины за раз, доступен через prefetch_op. Базовый объект Barrier доступен через barrier. Обработанные мини-пакеты, а также возможности чтения и записи состояния доступны через next_batch. В частности, next_batch предоставляет доступ ко всем данным мини-пакетов, включая следующее, см. NextQueuedSequenceBatch для подробностей:

• total_length, length, insertion_index, key, next_key,
• sequence (индекс индекса сегмента времени каждого элемента мини-пакета),
• sequence_count (общее количество сегментов времени для каждого элемента мини-пакета),
• context (словарь скопированных значений контекста мини-пакета),
• sequences (словарь разделенных мини-пакетированных последовательностей переменной длины),
• state (для доступа к состояниям текущих сегментов этих элементов)
• save_state (для сохранения состояний следующих сегментов этих элементов)

Пример использования:

batch_size = 32
num_unroll = 20
lstm_size = 8
cell = tf.compat.v1.nn.rnn_cell.BasicLSTMCell(num_units=lstm_size)
initial_state_values = tf.zeros(cell.state_size, dtype=tf.float32)

raw_data = get_single_input_from_input_reader()
length, key, sequences, context = my_parser(raw_data)
assert "input" in sequences.keys()
assert "label" in context.keys()
initial_states = {"lstm_state": initial_state_value}

stateful_reader = tf.SequenceQueueingStateSaver(
    batch_size, num_unroll,
    length=length, input_key=key, input_sequences=sequences,
    input_context=context, initial_states=initial_states,
    capacity=batch_size*100)

batch = stateful_reader.next_batch
inputs = batch.sequences["input"]
context_label = batch.context["label"]

inputs_by_time = tf.split(value=inputs, num_or_size_splits=num_unroll, axis=1)
assert len(inputs_by_time) == num_unroll

lstm_output, _ = tf.contrib.rnn.static_state_saving_rnn(
  cell,
  inputs_by_time,
  state_saver=batch,
  state_name="lstm_state")

# Start a prefetcher in the background
sess = tf.compat.v1.Session()
num_threads = 3
queue_runner = tf.compat.v1.train.QueueRunner(
    stateful_reader, [stateful_reader.prefetch_op] * num_threads)
tf.compat.v1.train.add_queue_runner(queue_runner)
tf.compat.v1.train.start_queue_runners(sess=session)

while True:
  # Step through batches, perform training or inference...
  session.run([lstm_output])

Примечание: Обычно барьер предоставляется QueueRunner, как в примерах выше. QueueRunner закроет барьер, если префеч-операция получит ошибку OutOfRange от входных очередей выше по потоку (т.е., достигнет конца входных данных). Если барьер закрыт, новые примеры больше не добавляются в SQSS. Однако базовый барьер может всё ещё содержать дальнейшие шаги развертки примеров, которые не прошли все итерации. Для корректного завершения всех примеров флаг allow_small_batch должен быть установлен в true, что заставит SQSS выдавать постепенно уменьшающиеся мини-пакеты с оставшимися примерами.

Методы

close

Просмотреть исходный код

close(
    cancel_pending_enqueues=False, name=None
)

Закрывает барьер и FIFOQueue.

Эта операция сигнализирует о том, что больше сегменты новых последовательностей не будут помещены в очередь. Новые сегменты уже вставленных последовательностей всё ещё могут быть помещены в очередь и декьюированы, если есть достаточное количество для заполнения пакета или если allow_small_batch имеет значение true. В противном случае операции декьюинга завершатся немедленно.