Главный вопрос

Загрузка слов

Загрузите пользовательские данные вместо использования набора тестов:

reader.py@ptb_raw_data

test_path = os.path.join(data_path, "ptb.test.txt")
test_data = _file_to_word_ids(test_path, word_to_id)  # change this line

test_data должен содержать идентификаторы слов (распечатайте word_to_id для сопоставления). Например, это должно выглядеть так: [1, 52, 562, 246] ...

Отображение прогнозов

Нам нужно вернуть вывод уровня FC (logits) в вызове sess.run

ptb_word_lm.py@PTBModel.__init__

    logits = tf.reshape(logits, [self.batch_size, self.num_steps, vocab_size])
    self.top_word_id = tf.argmax(logits, axis=2)  # add this line

ptb_word_lm.py@run_epoch

  fetches = {
      "cost": model.cost,
      "final_state": model.final_state,
      "top_word_id": model.top_word_id # add this line
  }

Позже в функции vals['top_word_id'] будет массив целых чисел с идентификатором верхнего слова. Посмотрите это в word_to_id, чтобы определить предсказанное слово. Я проделал это некоторое время назад с маленькой моделью, и максимальная точность 1 была довольно низкой (20-30% iirc), даже несмотря на то, что недоумение было тем, что было предсказано в заголовке.

Подвопросы

Зачем использовать случайное (неинициализированное, неподготовленное) встраивание слов?

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

Зачем использовать softmax?

Окончательный прогноз не определяется косинусным сходством с выводом скрытого слоя. После LSTM есть уровень FC, который преобразует встроенное состояние в быстрое кодирование последнего слова.

Вот набросок операций и измерений в нейронной сети:

word -> one hot code (1 x vocab_size) -> embedding (1 x hidden_size) -> LSTM -> FC layer (1 x vocab_size) -> softmax (1 x vocab_size)

Должен ли скрытый слой соответствовать размеру ввода (т.е. размеру вложений word2vec)

Технически нет. Если вы посмотрите на уравнения LSTM, вы заметите, что x (вход) может иметь любой размер, если матрица весов настроена соответствующим образом.

Как / Могу ли я использовать предварительно обученную модель word2vec вместо неинициализированной?

Не знаю, извини.

Мой самый большой вопрос: как использовать созданную модель, чтобы на самом деле создать предложение следующего слова, учитывая первые несколько слов предложения?

Т.е. Пытаюсь написать функцию с подписью: getNextWord (модель, предложениеPrefix)

Прежде чем я объясню свой ответ, сначала сделайте замечание о вашем предложении # Call static_rnn(cell) once for each word in prefix to initialize state: имейте в виду, что static_rnn не возвращает значение, подобное массиву numpy, а возвращает тензор. Вы можете оценить тензор до значения, когда он запускается (1) в сеансе (сеанс сохраняет состояние вашего вычислительного графика, включая значения параметров вашей модели) и (2) с входными данными, которые необходимы для расчета значение тензора. Входные данные могут быть предоставлены с помощью считывателей ввода (подход, описанный в руководстве) или с помощью заполнителей (что я буду использовать ниже).

Теперь следует собственно ответ: модель в учебнике была разработана для чтения входных данных из файла. Ответ @ user3080953 уже показал, как работать с вашим собственным текстовым файлом, но, насколько я понимаю, вам нужно больше контроля над тем, как данные передаются в модель. Для этого вам нужно будет определить свои собственные заполнители и передать данные в эти заполнители при вызове session.run().

В приведенном ниже коде я разделил PTBModel на подклассы и сделал его ответственным за явную подачу данных в модель. Я представил специальный PTBInteractiveInput, интерфейс которого похож на PTBInput, поэтому вы можете повторно использовать функциональность PTBModel. Для обучения модели вам еще понадобится PTBModel.

class PTBInteractiveInput(object):
  def __init__(self, config):
    self.batch_size = 1
    self.num_steps = config.num_steps
    self.input_data = tf.placeholder(dtype=tf.int32, shape=[self.batch_size, self.num_steps])
    self.sequence_len = tf.placeholder(dtype=tf.int32, shape=[])
    self.targets = tf.placeholder(dtype=tf.int32, shape=[self.batch_size, self.num_steps])

class InteractivePTBModel(PTBModel):

  def __init__(self, config):
    input = PTBInteractiveInput(config)
    PTBModel.__init__(self, is_training=False, config=config, input_=input)
    output = self.logits[:, self._input.sequence_len - 1, :]
    self.top_word_id = tf.argmax(output, axis=2)

  def get_next(self, session, prefix):
    prefix_array, sequence_len = self._preprocess(prefix)
    feeds = {
      self._input.sequence_len: sequence_len,
      self._input.input_data: prefix_array,
    }
    fetches = [self.top_word_id]
    result = session.run(fetches, feeds)
    self._postprocess(result)

  def _preprocess(self, prefix):
    num_steps = self._input.num_steps
    seq_len = len(prefix)
    if seq_len > num_steps:
      raise ValueError("Prefix to large for model.")
    prefix_ids = self._prefix_to_ids(prefix)
    num_items_to_pad = num_steps - seq_len
    prefix_ids.extend([0] * num_items_to_pad)
    prefix_array = np.array([prefix_ids], dtype=np.float32)
    return prefix_array, seq_len

  def _prefix_to_ids(self, prefix):
    # should convert your prefix to a list of ids
    pass

  def _postprocess(self, result):
    # convert ids back to strings
    pass

В __init__ функции PTBModel вам нужно добавить эту строку:

self.logits = logits

Зачем использовать случайное (неинициализированное, неподготовленное) встраивание слов?

Во-первых, обратите внимание, что, хотя вначале вложения случайны, они будут обучаться вместе с остальной частью сети. Вложения, которые вы получаете после обучения, будут иметь те же свойства, что и вложения, которые вы получаете с моделями word2vec, например, способность отвечать на вопросы аналогии с векторными операциями (король - мужчина + женщина = королева и т. Д.). обучающих данных, таких как языковое моделирование (которое не требует аннотированных обучающих данных) или нейронный машинный перевод, чаще всего обучают вложениям с нуля.

Зачем использовать softmax?

Softmax - это функция, которая нормализует вектор оценок сходства (логитов) к распределению вероятностей. Распределение вероятностей необходимо для обучения модели с кросс-энтропийными потерями и возможности выборки из модели. Обратите внимание: если вас интересуют только наиболее вероятные слова обученной модели, softmax вам не нужен, и вы можете использовать логиты напрямую.

Должен ли скрытый слой соответствовать размеру ввода (т.е. размеру вложений word2vec)

Нет, в принципе это может быть любое значение. Однако использование скрытого состояния с более низкой размерностью, чем ваше измерение встраивания, не имеет особого смысла.

Как / Могу ли я использовать предварительно обученную модель word2vec вместо неинициализированной?

Вот автономный пример инициализации вложения с заданным массивом numpy. Если вы хотите, чтобы встраивание оставалось фиксированным / постоянным во время обучения, установите trainable на False.

import tensorflow as tf
import numpy as np
vocab_size = 10000
size = 200
trainable=True
embedding_matrix = np.zeros([vocab_size, size]) # replace this with code to load your pretrained embedding
embedding = tf.get_variable("embedding",
                            initializer=tf.constant_initializer(embedding_matrix),
                            shape=[vocab_size, size],
                            dtype=tf.float32,
                            trainable=trainable)

Вопросов много, я бы постарался прояснить некоторые из них.

как мне использовать созданную модель, чтобы на самом деле создать предложение следующего слова, учитывая первые несколько слов предложения?

Ключевым моментом здесь является то, что следующее поколение слов на самом деле является классификацией слов в словаре. Итак, вам нужен классификатор, поэтому на выходе есть softmax.

Принцип заключается в том, что на каждом временном шаге модель будет выводить следующее слово на основе встраивания последнего слова и внутренней памяти предыдущих слов. tf.contrib.rnn.static_rnn автоматически объединяет ввод в память, но нам нужно обеспечить встраивание последнего слова и классифицировать следующее слово.

Мы можем использовать предварительно обученную модель word2vec, просто инициализируйте embedding матрицу с предварительно обученной. Я думаю, что в учебнике для простоты используется случайная матрица. Размер памяти не связан с размером встраивания, вы можете использовать больший размер памяти, чтобы сохранить больше информации.

Эти уроки являются высокоуровневыми. Если вы хотите глубоко разобраться в деталях, я бы посоветовал взглянуть на исходный код в виде простого python / numpy.

Вы можете найти весь код в конце ответа.

Я полагаю, что на большинство ваших вопросов (почему Softmax, как использовать предварительно обученный слой встраивания и т. Д.) Были даны ответы. Однако, поскольку вы все еще ждали краткого кода для создания сгенерированного текста из семени, здесь я пытаюсь рассказать, как я в итоге сделал это сам.

Я изо всех сил пытался, начиная с официального руководства по Tensorflow, добраться до точки, где я мог легко генерировать слова из созданной модели. К счастью, после того, как я получил некоторые ответы практически на все ответы, которые вы упомянули в своем вопросе, я получил лучшее представление о проблеме (и решениях). Это может содержать ошибки, но, по крайней мере, он запускается и генерирует некоторый текст ...

как мне использовать созданную модель, чтобы на самом деле создать предложение следующего слова, учитывая первые несколько слов предложения?

Я заключу предложение следующего слова в цикл, чтобы создать целое предложение, но вы легко сократите его до одного слова.

Допустим, вы следовали текущему руководству, предоставленному tenorflow (v1.4 на момент написания), здесь , который сохранит модель после ее обучения.

Затем нам остается загрузить его с диска и написать функцию, которая принимает эту модель и некоторый начальный ввод и возвращает сгенерированный текст.

Сгенерировать текст из сохраненной модели

Я предполагаю, что мы напишем весь этот код в новом скрипте Python. Весь сценарий внизу в качестве резюме, здесь я объясняю основные шаги.

Первые необходимые шаги

FLAGS = tf.flags.FLAGS
FLAGS.model = "medium" # or whatever size you used

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

word_to_id = reader._build_vocab('../data/ptb.train.txt') # here we load the word -> id dictionnary ()
id_to_word = dict(zip(word_to_id.values(), word_to_id.keys())) # and transform it into id -> word dictionnary
_, _, test_data, _ = reader.ptb_raw_data('../data')

Затем мы загружаем класс конфигурации, также устанавливая для num_steps и batch_size значение 1, поскольку мы хотим отбирать по одному слову за раз, в то время как LSTM будет обрабатывать также по одному слову за раз. Также создание экземпляра ввода на лету:

eval_config = get_config()
eval_config.num_steps = 1
eval_config.batch_size = 1
model_input = PTBInput(eval_config, test_data)

Строительный график

Чтобы загрузить сохраненную модель (сохраненную модулем Supervisor.saver в руководстве), нам нужно сначала перестроить график (легко с классом PTBModel), который должен использовать ту же конфигурацию как при обучении:

sess = tf.Session()
initializer = tf.random_uniform_initializer(-eval_config.init_scale, eval_config.init_scale)
# not sure but seems to need the same name for variable scope as when saved ....!!
with tf.variable_scope("Model", reuse=None, initializer=initializer):
    tf.global_variables_initializer()
    mtest = PTBModel(is_training=False, config=eval_config, input=model_input)

sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint('../Whatever_folder_you_saved_in')) # the path must point to the hierarchy where your 'checkpoint' file is

# the line goes somewhere below the reshaping "logits = tf.reshape(logits, [self.batch_size, ..."
self.probas = tf.nn.softmax(logits, name="probas")

def sample_from_pmf(probas):
    t = np.cumsum(probas)
    s = np.sum(probas)
    return int(np.searchsorted(t, np.random.rand(1) * s))

def generate_text(session, model, word_to_index, index_to_word, 
                  seed='</s>', n_sentences=10):
    sentence_cnt = 0
    input_seeds_id = [word_to_index[w] for w in seed.split()]
    state = session.run(model.initial_state)

    # Initiate network with seeds up to the before last word:
    for x in input_seeds_id[:-1]:
        feed_dict = {model.initial_state: state,
                     model.input.input_data: [[x]]}
        state = session.run([model.final_state], feed_dict)

    text = seed
    # Generate a new sample from previous, starting at last word in seed
    input_id = [[input_seeds_id[-1]]]
    while sentence_cnt < n_sentences:
        feed_dict = {model.input.input_data: input_id,
                     model.initial_state: state}
        probas, state = session.run([model.probas, model.final_state],
                                 feed_dict=feed_dict)
        sampled_word = sample_from_pmf(probas[0])
        if sampled_word == word_to_index['</s>']:
            text += '.\n'
            sentence_cnt += 1
        else:
            text += ' ' + index_to_word[sampled_word]
        input_wordid = [[sampled_word]]

    return text

self.probas = tf.nn.softmax(logits, name='probas')

import reader
import numpy as np
import tensorflow as tf
from ptb_lstm import PTBModel, get_config, PTBInput

FLAGS = tf.flags.FLAGS
FLAGS.model = "medium"

def sample_from_pmf(probas):
    t = np.cumsum(probas)
    s = np.sum(probas)
    return int(np.searchsorted(t, np.random.rand(1) * s))

def generate_text(session, model, word_to_index, index_to_word, 
                  seed='</s>', n_sentences=10):
    sentence_cnt = 0
    input_seeds_id = [word_to_index[w] for w in seed.split()]
    state = session.run(model.initial_state)

    # Initiate network with seeds up to the before last word:
    for x in input_seeds_id[:-1]:
        feed_dict = {model.initial_state: state,
                     model.input.input_data: [[x]]}
        state = session.run([model.final_state], feed_dict)

    text = seed
    # Generate a new sample from previous, starting at last word in seed
    input_id = [[input_seeds_id[-1]]]
    while sentence_cnt < n_sentences:
        feed_dict = {model.input.input_data: input_id,
                     model.initial_state: state}
        probas, state = sess.run([model.probas, model.final_state],
                                 feed_dict=feed_dict)
        sampled_word = sample_from_pmf(probas[0])
        if sampled_word == word_to_index['</s>']:
            text += '.\n'
            sentence_cnt += 1
        else:
            text += ' ' + index_to_word[sampled_word]
        input_wordid = [[sampled_word]]

    print(text)

if __name__ == '__main__':

    word_to_id = reader._build_vocab('../data/ptb.train.txt') # here we load the word -> id dictionnary ()
    id_to_word = dict(zip(word_to_id.values(), word_to_id.keys())) # and transform it into id -> word dictionnary
    _, _, test_data, _ = reader.ptb_raw_data('../data')

    eval_config = get_config()
    eval_config.batch_size = 1
    eval_config.num_steps = 1
    model_input = PTBInput(eval_config, test_data, name=None)

    sess = tf.Session()
    initializer = tf.random_uniform_initializer(-eval_config.init_scale,
                                            eval_config.init_scale)
    with tf.variable_scope("Model", reuse=None, initializer=initializer):
        tf.global_variables_initializer()
        mtest = PTBModel(is_training=False, config=eval_config, 
                         input_=model_input)

    sess.run(tf.global_variables_initializer())

    saver = tf.train.Saver()
    saver.restore(sess, tf.train.latest_checkpoint('../models'))

    while True:
        print(generate_text(sess, mtest, word_to_id, id_to_word, seed="this sentence is"))
        try:
            raw_input('press Enter to continue ...\n')
        except KeyboardInterrupt:
            print('\b\bQuiting now...')
            break

reader = tf.train.NewCheckpointReader(CKPT_FILE)
reader.get_variable_to_shape_map()