Ist RNN ursprünglichen Zustand zurücksetzen für nachfolgende mini-batches?

Könnte jemand bitte klären, ob der anfängliche Zustand des RNN in TF-reset für nachfolgende mini-batches, oder der Letzte Zustand der früheren mini-batch verwendet wird, wie erwähnt, in Ilja Sutskever et al., ICLR 2015 ?

InformationsquelleAutor VM_AI | 2016-07-18

  1. 18

    Den tf.nn.dynamic_rnn() oder tf.nn.rnn() Vorgänge ermöglichen, geben Sie den ursprünglichen Zustand des RNN mit der initial_state parameter. Wenn Sie diesen parameter nicht angeben, wird die verborgene Staaten werden mit null initialisiert Vektoren am Anfang jeder batch-training.

    In TensorFlow, können Sie wrap-Tensoren in tf.Variable() zu halten, Ihre Werte in der Grafik zwischen mehreren Sitzung ausgeführt wird. So stellen Sie sicher, markieren Sie Sie als nicht trainierbar, weil die Optimierer optimieren alle trainierbar Variablen standardmäßig.

    data = tf.placeholder(tf.float32, (batch_size, max_length, frame_size))

cell = tf.nn.rnn_cell.GRUCell(256)
state = tf.Variable(cell.zero_states(batch_size, tf.float32), trainable=False)
output, new_state = tf.nn.dynamic_rnn(cell, data, initial_state=state)

with tf.control_dependencies([state.assign(new_state)]):
    output = tf.identity(output)

sess = tf.Session()
sess.run(tf.initialize_all_variables())
sess.run(output, {data: ...})

    Habe ich noch nicht getestet mit diesem code, aber es sollte Ihnen einen Hinweis in die richtige Richtung. Es gibt auch eine tf.nn.state_saving_rnn() , können Sie eine state-saver-Objekt, aber ich habe es nicht verwenden yet.

    was ist die batch_size war variable, in diesem Fall, die tf.Variable erstellt wird einen Fehler auslösen, denn wir müssen festlegen, die Größe der Variablen.

    InformationsquelleAutor danijar

  2. 8

    Zusätzlich zu danijar ' s Antwort, hier ist der code für eine LSTM, deren Zustand ist ein Tupel (state_is_tuple=True). Es unterstützt auch mehrere Schichten.

    Definieren wir zwei Funktionen - eine für das erhalten der Variablen mit einer anfänglichen Nullpunkt und eine Funktion für die Rückgabe einer operation, die wir weitergeben können, um session.run um ein update auf die state-Variablen mit dem LSTM letzten ausgeblendeten Zustand.

    def get_state_variables(batch_size, cell):
    # For each layer, get the initial state and make a variable out of it
    # to enable updating its value.
    state_variables = []
    for state_c, state_h in cell.zero_state(batch_size, tf.float32):
        state_variables.append(tf.contrib.rnn.LSTMStateTuple(
            tf.Variable(state_c, trainable=False),
            tf.Variable(state_h, trainable=False)))
    # Return as a tuple, so that it can be fed to dynamic_rnn as an initial state
    return tuple(state_variables)


def get_state_update_op(state_variables, new_states):
    # Add an operation to update the train states with the last state tensors
    update_ops = []
    for state_variable, new_state in zip(state_variables, new_states):
        # Assign the new state to the state variables on this layer
        update_ops.extend([state_variable[0].assign(new_state[0]),
                           state_variable[1].assign(new_state[1])])
    # Return a tuple in order to combine all update_ops into a single operation.
    # The tuple's actual value should not be used.
    return tf.tuple(update_ops)

    Ähnlich wie danijar Antwort, die wir verwenden können, die zur Aktualisierung der LSTM ist-Zustand nach jedem batch:

    data = tf.placeholder(tf.float32, (batch_size, max_length, frame_size))
cells = [tf.contrib.rnn.GRUCell(256) for _ in range(num_layers)]
cell = tf.contrib.rnn.MultiRNNCell(cells)

# For each layer, get the initial state. states will be a tuple of LSTMStateTuples.
states = get_state_variables(batch_size, cell)

# Unroll the LSTM
outputs, new_states = tf.nn.dynamic_rnn(cell, data, initial_state=states)

# Add an operation to update the train states with the last state tensors.
update_op = get_state_update_op(states, new_states)

sess = tf.Session()
sess.run(tf.global_variables_initializer())
sess.run([outputs, update_op], {data: ...})

    Der Hauptunterschied ist, dass state_is_tuple=True macht der LSTM ist-Zustand eine LSTMStateTuple mit zwei Variablen (Zelle Stand und versteckte Staat), anstatt nur eine einzelne variable. Mit mehreren Ebenen macht dann die LSTM Zustand ein Tupel von LSTMStateTuples - einer pro Schicht.

    Hinweis: wie Sie es machen, Sie schaffen num_layers identisch Zellen, die nicht ist, was Sie tun wollen wohl
    Was tun, wenn die batch_size ist bestimmt während der Laufzeit?
    danke für den Hinweis, ich aktualisierte den code.
    Sie können geben get_state_variables die maximale batch_size, die Sie erwarten, zu erstellen, die den Zustand von Variablen und ignorieren Sie die unbenutzte Variablen

    InformationsquelleAutor Kilian Batzner

Schreibe einen Kommentar