TensorFlow mit LSTMs für das generieren von text

Habe ich die Arbeit in Richtung der exakt gleichen Ziel, und habe es an die Arbeit. Sie haben viele richtige änderungen hier, aber ich denke, dass Sie ' ve verpasst ein paar Schritte.

Ersten, zur Erzeugung von text, den Sie brauchen zu erstellen eine andere version des Modells, das stellt nur einen einzelnen Zeitschritt. Der Grund dafür ist, dass wir brauchen, um Probe jeden Ausgang y, bevor wir füttern es in den nächsten Schritt des Modells. Ich Tat dies, indem Sie eine neue config setzt num_steps und batch_size beide gleich 1.

class SmallGenConfig(object):
  """Small config. for generation"""
  init_scale = 0.1
  learning_rate = 1.0
  max_grad_norm = 5
  num_layers = 2
  num_steps = 1 # this is the main difference
  hidden_size = 200
  max_epoch = 4
  max_max_epoch = 13
  keep_prob = 1.0
  lr_decay = 0.5
  batch_size = 1
  vocab_size = 10000

Ich mir zusätzlich die Wahrscheinlichkeiten für das Modell mit diesen Zeilen:

self._output_probs = tf.nn.softmax(logits)

und

@property
def output_probs(self):
  return self._output_probs

Dann gibt es ein paar Unterschiede in meinem generate_text() Funktion. Die erste ist, dass ich das laden von gespeicherten Modell-Parameter von der Festplatte mit der tf.train.Saver() Objekt. Beachten Sie, dass wir diese nach der Instanziierung des PTBModel mit der neuen config von oben.

def generate_text(train_path, model_path, num_sentences):
  gen_config = SmallGenConfig()

  with tf.Graph().as_default(), tf.Session() as session:
    initializer = tf.random_uniform_initializer(-gen_config.init_scale,
                                                gen_config.init_scale)    
    with tf.variable_scope("model", reuse=None, initializer=initializer):
      m = PTBModel(is_training=False, config=gen_config)

    # Restore variables from disk.
    saver = tf.train.Saver() 
    saver.restore(session, model_path)
    print("Model restored from file " + model_path)

Der zweite Unterschied ist, dass ich den lookup-Tabelle von ids zu Wort-strings (die ich zu schreiben hatte diese Funktion, siehe code unten).

    words = reader.get_vocab(train_path)

Richte ich den ursprünglichen Zustand auf die gleiche Weise tun, aber dann setze ich das erste token in einer anderen Art und Weise. Ich möchte das "Ende der Satz" token so, dass ich beginne meinen Satz mit den passenden Wörtern. Ich schaute durch das Wort index und festgestellt, dass <eos> geschieht, index 2 (deterministisch), so dass ich nur hart codiert, dass in. Schließlich habe ich wickeln Sie es in eine 1x1-Numpy Matrix so, dass es der richtige Typ für den Modell-Eingänge.

    state = m.initial_state.eval()
    x = 2 # the id for '<eos>' from the training set
    input = np.matrix([[x]])  # a 2D numpy matrix 

Schließlich, hier ist der Teil, wo wir generieren Sätzen. Beachten Sie, dass wir sagen session.run() zur Berechnung der output_probs und die final_state. Und geben wir es der Eingabe-und der Staat. In der ersten iteration wird die Eingabe <eos> und der Staat ist der initial_state, aber auf den nachfolgenden Iterationen geben wir als input unserer letzten Stichprobe Ausgabe, und wir geben den Zustand entlang der letzten iteration. Beachten Sie auch, dass wir die Nutzung der words Liste zum nachschlagen der Wort-string aus der output-index.

    text = ""
    count = 0
    while count < num_sentences:
      output_probs, state = session.run([m.output_probs, m.final_state],
                                   {m.input_data: input,
                                    m.initial_state: state})
      x = sample(output_probs[0], 0.9)
      if words[x]=="<eos>":
        text += ".\n\n"
        count += 1
      else:
        text += " " + words[x]
      # now feed this new word as input into the next iteration
      input = np.matrix([[x]]) 

Dann alles, was wir tun müssen ist, drucken Sie den text, den wir angesammelt haben.

    print(text)
  return

Dass es für das generate_text() Funktion.

Schließlich, lassen Sie mich Ihnen zeigen, die definition der Funktion für get_vocab(), das ich in reader.py.

def get_vocab(filename):
  data = _read_words(filename)

  counter = collections.Counter(data)
  count_pairs = sorted(counter.items(), key=lambda x: (-x[1], x[0]))

  words, _ = list(zip(*count_pairs))

  return words

Das Letzte, was Sie tun müssen, ist, um in der Lage sein, das Modell zu retten, nach der Ausbildung, die aussieht wie

save_path = saver.save(session, "/tmp/model.ckpt")

... Und das ist das Modell, das Sie laden von der Festplatte später beim generieren von text.

Gab es noch ein problem: ich fand, dass manchmal die Wahrscheinlichkeitsverteilung produziert von der Tensorflow softmax-Funktion nicht Summe genau 1.0. Wenn die Summe größer als 1.0 ist, np.random.multinomial() wirft einen Fehler. Also ich hatte zu schreiben, meine eigene sampling-Funktion, die wie folgt aussieht

def sample(a, temperature=1.0):
  a = np.log(a) / temperature
  a = np.exp(a) / np.sum(np.exp(a))
  r = random.random() # range: [0,1)
  total = 0.0
  for i in range(len(a)):
    total += a[i]
    if total>r:
      return i
  return len(a)-1 

Wenn Sie all dies zusammen, das kleine Modell war in der Lage zu generieren, die mir ein paar Coole Sätze. Viel Glück.