Estou tentando usar o tensorflowModelo LSTM para fazer previsões da próxima palavra.

Conforme descrito nestepergunta relacionada (que não tem resposta aceita), o exemplo contém pseudocódigo para extrair as probabilidades da próxima palavra:

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)

Estou confuso sobre como interpretar o vetor de probabilidades. Eu modifiquei o__init__ função doPTBModel noptb_word_lm.py para armazenar as probabilidades e logits:

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 ...

Em seguida, imprimiu algumas informações sobre eles norun_epoch função:

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)

Isso produz uma saída como esta:

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

Eu estava esperando oprobs vetor para ser um conjunto de probabilidades, com um para cada palavra no vocabulário (por exemplo, com forma(1, vocab_size)), o que significa que eu poderia obter a palavra prevista usandonp.argmax(probs, 1) como sugerido na outra pergunta.

No entanto, a primeira dimensão do vetor é realmente igual ao número de etapas no LSTM desenrolado (20 se as pequenas configurações forem usadas), com as quais não tenho certeza do que fazer. Para acessar a palavra prevista, só preciso usar o último valor (porque é a saída da etapa final)? Ou há algo mais que estou perdendo?

Tentei entender como as previsões são feitas e avaliadas, observando a implementação deseq2seq.sequence_loss_by_example, que deve realizar essa avaliação, mas isso acaba chamandogen_nn_ops._sparse_softmax_cross_entropy_with_logits, que parece não estar incluído no repositório do github, então não tenho certeza de onde mais procurar.

Sou bastante novo no tensorflow e nos LSTMs, portanto qualquer ajuda é apreciada!