Ich versuche den Tensorflow zu benutzenLSTM model, um Vorhersagen für das nächste Wort zu treffen.

Wie in diesem @ beschrieb Verwandte Frage (das hat keine akzeptierte Antwort) das Beispiel enthält Pseudocode, um Wahrscheinlichkeiten für das nächste Wort zu extrahieren:

lstm = rnn_cell.BasicLSTMCell(lstm_size)
# Initial state of the LSTM memory.
state = tf.zeros([batch_size, lstm.state_size])

loss = 0.0
for current_batch_of_words in words_in_dataset:
  # The value of state is updated after processing each batch of words.
  output, state = lstm(current_batch_of_words, state)

  # The LSTM output can be used to make next word predictions
  logits = tf.matmul(output, softmax_w) + softmax_b
  probabilities = tf.nn.softmax(logits)
  loss += loss_function(probabilities, target_words)

Ich bin verwirrt darüber, wie der Wahrscheinlichkeitsvektor zu interpretieren ist. Ich habe das @ geände__init__ Funktion desPTBModel im ptb_word_lm.py um die Wahrscheinlichkeiten und Logs zu speichern:

class PTBModel(object):
  """The PTB model."""

  def __init__(self, is_training, config):
    # General definition of LSTM (unrolled)
    # identical to tensorflow example ...     
    # omitted for brevity ...


    # computing the logits (also from example code)
    logits = tf.nn.xw_plus_b(output,
                             tf.get_variable("softmax_w", [size, vocab_size]),
                             tf.get_variable("softmax_b", [vocab_size]))
    loss = seq2seq.sequence_loss_by_example([logits],
                                            [tf.reshape(self._targets, [-1])],
                                            [tf.ones([batch_size * num_steps])],
                                            vocab_size)
    self._cost = cost = tf.reduce_sum(loss) / batch_size
    self._final_state = states[-1]

    # my addition: storing the probabilities and logits
    self.probabilities = tf.nn.softmax(logits)
    self.logits = logits

    # more model definition ...

Dann druckte einige Informationen über sie in derrun_epoch Funktion:

def run_epoch(session, m, data, eval_op, verbose=True):
  """Runs the model on the given data."""
  # first part of function unchanged from example

  for step, (x, y) in enumerate(reader.ptb_iterator(data, m.batch_size,
                                                    m.num_steps)):
    # evaluate proobability and logit tensors too:
    cost, state, probs, logits, _ = session.run([m.cost, m.final_state, m.probabilities, m.logits, eval_op],
                                 {m.input_data: x,
                                  m.targets: y,
                                  m.initial_state: state})
    costs += cost
    iters += m.num_steps

    if verbose and step % (epoch_size // 10) == 10:
      print("%.3f perplexity: %.3f speed: %.0f wps, n_iters: %s" %
            (step * 1.0 / epoch_size, np.exp(costs / iters),
             iters * m.batch_size / (time.time() - start_time), iters))
      chosen_word = np.argmax(probs, 1)
      print("Probabilities shape: %s, Logits shape: %s" % 
            (probs.shape, logits.shape) )
      print(chosen_word)
      print("Batch size: %s, Num steps: %s" % (m.batch_size, m.num_steps))

  return np.exp(costs / iters)

Dies erzeugt eine Ausgabe wie diese:

0.000 perplexity: 741.577 speed: 230 wps, n_iters: 220
(20, 10000) (20, 10000)
[ 14   1   6 589   1   5   0  87   6   5   3   5   2   2   2   2   6   2  6   1]
Batch size: 1, Num steps: 20

Ich habe das @ erwartprobs vector ist ein Array von Wahrscheinlichkeiten mit einer für jedes Wort im Vokabular (z. B. mit shape(1, vocab_size)), was bedeutet, dass ich das vorhergesagte Wort mit @ erhalten könnnp.argmax(probs, 1) wie in der anderen Frage vorgeschlagen.

Die erste Dimension des Vektors entspricht jedoch der Anzahl der Schritte im entrollten LSTM (20, wenn die kleinen Konfigurationseinstellungen verwendet werden), mit denen ich nicht sicher bin, was ich tun soll. Muss ich nur den letzten Wert verwenden, um auf das vorhergesagte Wort zuzugreifen (da dies die Ausgabe des letzten Schritts ist)? Oder fehlt mir noch etwas?

Ich habe versucht zu verstehen, wie die Vorhersagen getroffen und bewertet werden, indem ich mir die Implementierung von @ anschau seq2seq.sequence_loss_by_example, das diese Auswertung durchführen muss, aber dies führt zum Aufruf vongen_nn_ops._sparse_softmax_cross_entropy_with_logits, das nicht im Github-Repo enthalten zu sein scheint, daher bin ich mir nicht sicher, wo ich es sonst suchen soll.

Ich bin sowohl für Tensorflow als auch für LSTMs ziemlich neu, daher ist jede Hilfe willkommen!