ChatBot 예제 최신 텐서플로에 맞게 수정

Author: golbin

10 - RNN/ChatBot/chat.py

@@ -26,14 +26,14 @@ def run(self):
         line = sys.stdin.readline()
 
         while line:
-            print(self.get_replay(line.strip()))
+            print(self._get_replay(line.strip()))
 
             sys.stdout.write("\n> ")
             sys.stdout.flush()
 
             line = sys.stdin.readline()
 
-    def decode(self, enc_input, dec_input):
+    def _decode(self, enc_input, dec_input):
         if type(dec_input) is np.ndarray:
             dec_input = dec_input.tolist()
 
@@ -46,7 +46,7 @@ def decode(self, enc_input, dec_input):
 
         return self.model.predict(self.sess, [enc_input], [dec_input])
 
-    def get_replay(self, msg):
+    def _get_replay(self, msg):
         enc_input = self.dialog.tokenizer(msg)
         enc_input = self.dialog.tokens_to_ids(enc_input)
         dec_input = []
@@ -57,7 +57,7 @@ def get_replay(self, msg):
         #       다만 상황에 따라서는 이런 방식이 더 유연할 수도 있을 듯
         curr_seq = 0
         for i in range(FLAGS.max_decode_len):
-            outputs = self.decode(enc_input, dec_input)
+            outputs = self._decode(enc_input, dec_input)
             if self.dialog.is_eos(outputs[0][curr_seq]):
                 break
             elif self.dialog.is_defined(outputs[0][curr_seq]) is not True:
@@ -75,5 +75,6 @@ def main(_):
     chatbot = ChatBot(FLAGS.voc_path, FLAGS.train_dir)
     chatbot.run()
 
+
 if __name__ == "__main__":
     tf.app.run()

10 - RNN/ChatBot/dialog.py

@@ -2,7 +2,6 @@
 import tensorflow as tf
 import numpy as np
 import re
-import codecs
 
 from config import FLAGS
 
@@ -32,11 +31,11 @@ def decode(self, indices, string=False):
         tokens = [[self.vocab_list[i] for i in dec] for dec in indices]
 
         if string:
-            return self.decode_to_string(tokens[0])
+            return self._decode_to_string(tokens[0])
         else:
             return tokens
 
-    def decode_to_string(self, tokens):
+    def _decode_to_string(self, tokens):
         text = ' '.join(tokens)
         return text.strip()
 
@@ -50,7 +49,7 @@ def is_eos(self, voc_id):
     def is_defined(self, voc_id):
         return voc_id in self._PRE_DEFINED_
 
-    def max_len(self, batch_set):
+    def _max_len(self, batch_set):
         max_len_input = 0
         max_len_output = 0
 
@@ -64,7 +63,7 @@ def max_len(self, batch_set):
 
         return max_len_input, max_len_output + 1
 
-    def pad(self, seq, max_len, start=None, eos=None):
+    def _pad(self, seq, max_len, start=None, eos=None):
         if start:
             padded_seq = [self._STA_ID_] + seq
         elif eos:
@@ -77,16 +76,16 @@ def pad(self, seq, max_len, start=None, eos=None):
         else:
             return padded_seq
 
-    def pad_left(self, seq, max_len):
+    def _pad_left(self, seq, max_len):
         if len(seq) < max_len:
             return ([self._PAD_ID_] * (max_len - len(seq))) + seq
         else:
             return seq
 
     def transform(self, input, output, input_max, output_max):
-        enc_input = self.pad(input, input_max)
-        dec_input = self.pad(output, output_max, start=True)
-        target = self.pad(output, output_max, eos=True)
+        enc_input = self._pad(input, input_max)
+        dec_input = self._pad(output, output_max, start=True)
+        target = self._pad(output, output_max, eos=True)
 
         # 구글 방식으로 입력을 인코더에 역순으로 입력한다.
         enc_input.reverse()
@@ -117,7 +116,7 @@ def next_batch(self, batch_size):
 
         # TODO: 구글처럼 버킷을 이용한 방식으로 변경
         # 간단하게 만들기 위해 구글처럼 버킷을 쓰지 않고 같은 배치는 같은 사이즈를 사용하도록 만듬
-        max_len_input, max_len_output = self.max_len(batch_set)
+        max_len_input, max_len_output = self._max_len(batch_set)
 
         for i in range(0, len(batch_set) - 1, 2):
             enc, dec, tar = self.transform(batch_set[i], batch_set[i+1],

10 - RNN/ChatBot/logs/events.out.tfevents.1484699399.mpr

@@ -25,15 +25,15 @@ def __init__(self, vocab_size, n_hidden=128, n_layers=3):
         self.bias = tf.Variable(tf.zeros([self.vocab_size]), name="bias")
         self.global_step = tf.Variable(0, trainable=False, name="global_step")
 
-        self.build_model()
+        self._build_model()
 
         self.saver = tf.train.Saver(tf.global_variables())
 
-    def build_model(self):
-        self.enc_input = tf.transpose(self.enc_input, [1, 0, 2])
-        self.dec_input = tf.transpose(self.dec_input, [1, 0, 2])
+    def _build_model(self):
+        # self.enc_input = tf.transpose(self.enc_input, [1, 0, 2])
+        # self.dec_input = tf.transpose(self.dec_input, [1, 0, 2])
 
-        enc_cell, dec_cell = self.build_cells()
+        enc_cell, dec_cell = self._build_cells()
 
         with tf.variable_scope('encode'):
             outputs, enc_states = tf.nn.dynamic_rnn(enc_cell, self.enc_input, dtype=tf.float32)
@@ -42,24 +42,24 @@ def build_model(self):
             outputs, dec_states = tf.nn.dynamic_rnn(dec_cell, self.dec_input, dtype=tf.float32,
                                                     initial_state=enc_states)
 
-        self.logits, self.cost, self.train_op = self.build_ops(outputs, self.targets)
+        self.logits, self.cost, self.train_op = self._build_ops(outputs, self.targets)
 
         self.outputs = tf.argmax(self.logits, 2)
 
-    def cell(self, n_hidden, output_keep_prob):
-        rnn_cell = tf.contrib.rnn.BasicRNNCell(self.n_hidden)
-        rnn_cell = tf.contrib.rnn.DropoutWrapper(rnn_cell, output_keep_prob=output_keep_prob)
+    def _cell(self, output_keep_prob):
+        rnn_cell = tf.nn.rnn_cell.BasicLSTMCell(self.n_hidden)
+        rnn_cell = tf.nn.rnn_cell.DropoutWrapper(rnn_cell, output_keep_prob=output_keep_prob)
         return rnn_cell
 
-    def build_cells(self, output_keep_prob=0.5):
-        enc_cell = tf.contrib.rnn.MultiRNNCell([self.cell(self.n_hidden, output_keep_prob)
+    def _build_cells(self, output_keep_prob=0.5):
+        enc_cell = tf.nn.rnn_cell.MultiRNNCell([self._cell(output_keep_prob)
                                                 for _ in range(self.n_layers)])
-        dec_cell = tf.contrib.rnn.MultiRNNCell([self.cell(self.n_hidden, output_keep_prob)
+        dec_cell = tf.nn.rnn_cell.MultiRNNCell([self._cell(output_keep_prob)
                                                 for _ in range(self.n_layers)])
 
         return enc_cell, dec_cell
 
-    def build_ops(self, outputs, targets):
+    def _build_ops(self, outputs, targets):
         time_steps = tf.shape(outputs)[1]
         outputs = tf.reshape(outputs, [-1, self.n_hidden])
 

10 - RNN/ChatBot/logs/events.out.tfevents.1512710234.AL01286619.local

@@ -1,2 +1,2 @@
-model_checkpoint_path: "conversation.ckpt-5000"
-all_model_checkpoint_paths: "conversation.ckpt-5000"
+model_checkpoint_path: "conversation.ckpt-10000"
+all_model_checkpoint_paths: "conversation.ckpt-10000"