Как рассчитать растерянность RNN в tensorflow

Question

Я бегу слово РНН implmentation тензора потока Word RNN

Как рассчитать растерянность RNN.

Ниже приведен код в обучении, который показывает потерю обучения и другие вещи, в каждой эпохе:

for e in range(model.epoch_pointer.eval(), args.num_epochs): 
     sess.run(tf.assign(model.lr, args.learning_rate * (args.decay_rate ** e))) 
     data_loader.reset_batch_pointer() 
     state = sess.run(model.initial_state) 
     speed = 0 
     if args.init_from is None: 
      assign_op = model.batch_pointer.assign(0) 
      sess.run(assign_op) 
      assign_op = model.epoch_pointer.assign(e) 
      sess.run(assign_op) 
     if args.init_from is not None: 
      data_loader.pointer = model.batch_pointer.eval() 
      args.init_from = None 
     for b in range(data_loader.pointer, data_loader.num_batches): 
      start = time.time() 
      x, y = data_loader.next_batch() 
      feed = {model.input_data: x, model.targets: y, model.initial_state: state, 
        model.batch_time: speed} 
      summary, train_loss, state, _, _ = sess.run([merged, model.cost, model.final_state, 
                 model.train_op, model.inc_batch_pointer_op], feed) 
      train_writer.add_summary(summary, e * data_loader.num_batches + b) 
      speed = time.time() - start 
      if (e * data_loader.num_batches + b) % args.batch_size == 0: 
       print("{}/{} (epoch {}), train_loss = {:.3f}, time/batch = {:.3f}" \ 
        .format(e * data_loader.num_batches + b, 
          args.num_epochs * data_loader.num_batches, 
          e, train_loss, speed)) 
      if (e * data_loader.num_batches + b) % args.save_every == 0 \ 
        or (e==args.num_epochs-1 and b == data_loader.num_batches-1): # save for the last result 
       checkpoint_path = os.path.join(args.save_dir, 'model.ckpt') 
       saver.save(sess, checkpoint_path, global_step = e * data_loader.num_batches + b) 
       print("model saved to {}".format(checkpoint_path)) 
    train_writer.close() 

Answer 1

Проект, который вы ссылаетесь использует sequence_to_sequence_loss_by_example, которая возвращает кросс-энтропии потери. Поэтому для расчета недоумения в подготовке вам просто нужно увеличить убыток, как описано here.

train_perplexity = tf.exp(train_loss) 

Мы должны использовать е вместо 2 в качестве основы, поскольку TensorFlow измеряет кросс-энтропии потери с натуральным логарифмом (TF Documentation). Спасибо, @Matthias Arro и @Colin Skow за подсказку.

Подробное пояснение

Поперечное энтропия двух распределений вероятностей P и Q говорит нам минимальное среднее число бит, мы должны кодировать события P, когда мы разрабатываем схему кодирования, основанную на Q. Таким образом, P это истинное распределение, которого мы обычно не знаем. Мы хотим найти Q как можно ближе к P, чтобы мы могли разработать красивую схему кодирования с максимально возможным количеством бит на событие.

Я не должен говорить биты, потому что мы можем использовать только биты в качестве меры, если мы используем базу 2 при вычислении кросс-энтропии. Но TensorFlow использует естественный логарифм, поэтому вместо этого давайте измерять кросс-энтропию в nats.

Итак, допустим, у нас плохая языковая модель, в которой каждый знак (символ/слово) в корпусе равновероятен, чтобы быть следующим. Для корпуса из 1000 токенов эта модель будет иметь кросс-энтропию log (1000) = 6,9 nats. При прогнозировании следующего токена он должен выбирать равномерно между 1000 токенами на каждом шаге.

Лучшая языковая модель будет определять распределение вероятности Q, которое ближе к P. Таким образом, кросс-энтропия ниже - мы можем получить кросс-энтропию 3,9 nats. Если теперь мы хотим измерить недоумения, мы просто экспоненциируются кросс-энтропии:

ехр (3,9) = 49,4

Так, на образцах, для которых мы рассчитали потери, хорошая модель была как будто он должен был выбирать равномерно и независимо между примерно 50 токенами.

Answer 2

Это зависит от того, дает ли ваша функция потерь вероятность регистрации данных в базе 2 или базе e. Эта модель использует legacy_seq2seq.sequence_loss_by_example, которая использует бинарную кроссентропию TensorFlow, которая appears to use logs of base e. Поэтому, несмотря на то, что мы имеем дело с дискретным распределением вероятности (текст), мы должны оценивать е, т. Е. Использовать tf.exp (train_loss), как предложил Колин Скоу.