def test(params): """测试不同参数在生成的假数据上的运行结果""" from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow from word_sequence import WordSequence # pylint: disable=unused-variable x_data, _ = pickle.load(open('chatbot.pkl', 'rb')) ws = pickle.load(open('ws.pkl', 'rb')) for x in x_data[:5]: print(' '.join(x)) config = tf.ConfigProto(device_count={ 'CPU': 1, 'GPU': 0 }, allow_soft_placement=True, log_device_placement=False) # save_path = '/tmp/s2ss_chatbot.ckpt' save_path = './s2ss_chatbot.ckpt' # 测试部分 tf.reset_default_graph() model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=0, **params) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) while True: user_text = input('Input Chat Sentence:') if user_text in ('exit', 'quit'): exit(0) x_test = [list(user_text.lower())] # x_test = [word_tokenize(user_text)] bar = batch_flow([x_test], ws, 1) x, xl = next(bar) x = np.flip(x, axis=1) # x = np.array([ # list(reversed(xx)) # for xx in x # ]) print(x, xl) pred = model_pred.predict(sess, np.array(x), np.array(xl)) print(pred) # prob = np.exp(prob.transpose()) print(ws.inverse_transform(x[0])) # print(ws.inverse_transform(pred[0])) # print(pred.shape, prob.shape) for p in pred: ans = ws.inverse_transform(p) print(ans)
def test(params, infos): from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow x_data, _ = pickle.load(open('chatbot.pkl', 'rb')) ws = pickle.load(open('ws.pkl', 'rb')) for x in x_data[:5]: print(' '.join(x)) config = tf.ConfigProto( device_count = {'CPU':1, 'GPU':0}, allow_soft_placement=True, log_device_placement=False ) save_path = './model/s2ss_chatbot_anti.ckpt' tf.reset_default_graph() model_pred = SequenceToSequence( input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=0, **params ) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) while True: # user_text = input('请输入您的句子:') # if user_text in ('exit', 'quit'): # exit(0) x_test = [list(infos.lower())] bar = batch_flow([x_test], ws, 1) x, xl = next(bar) x = np.flip(x, axis=1) print(x, xl) pred = model_pred.predict( sess, np.array(x), np.array(xl) ) print(pred) print(ws.inverse_transform(x[0])) for p in pred: ans = ws.inverse_transform(p) print(ans) return ans
def nlp(question): """测试不同参数在生成的假数据上的运行结果""" params = json.load(open(os.path.dirname(__file__) + '/params.json')) from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow x_data, _ = pickle.load( open(os.path.dirname(__file__) + '/data/chatbot.pkl', 'rb')) ws = pickle.load(open(os.path.dirname(__file__) + '/data/ws.pkl', 'rb')) # for x in x_data[:5]: # print(' '.join(x)) config = tf.ConfigProto(device_count={ 'CPU': 1, 'GPU': 0 }, allow_soft_placement=True, log_device_placement=False) # save_path = '/tmp/s2ss_chatbot.ckpt' save_path = os.path.dirname(__file__) + '/data/s2ss_chatbot.ckpt' # 测试部分 tf.reset_default_graph() model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=0, **params) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) while True: # user_text = input('Input Chat Sentence:') question = Converter('zh-hans').convert(question) # 繁體轉簡體 if question in ('exit', 'quit'): exit(0) x_test = [list(question.lower())] # x_test = [word_tokenize(user_text)] bar = batch_flow([x_test], ws, 1) x, xl = next(bar) x = np.flip(x, axis=1) pred = model_pred.predict(sess, np.array(x), np.array(xl)) # print(ws.inverse_transform(x[0])) -->['</s>', '饭', '吃', '去', '要', '我'] for p in pred: ans = ws.inverse_transform(p) str1 = ''.join(ans) # list轉str line = str1.strip("</s>") line = Converter('zh-hant').convert(line) # 簡體轉繁體 return line
def start(): from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow global input_list global response_dict global lock x_data, _ = pickle.load(open('chatbot.pkl', 'rb')) ws = pickle.load(open('ws.pkl', 'rb')) config = tf.ConfigProto(device_count={ 'CPU': 1, 'GPU': 0 }, allow_soft_placement=True, log_device_placement=False) save_path = './model/s2ss_chatbot_anti.ckpt' tf.reset_default_graph() model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=0, **params) init = tf.global_variables_initializer() print("线程-模型>>模型准备就绪") with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) while True: lock.acquire() if input_list: request = input_list.pop(0) ip = request.get('IP') infos = request.get('infos') print("线程-模型>>成功获取来自", ip, "的请求,内容:", infos) x_test = [list(infos.lower())] bar = batch_flow([x_test], ws, 1) x, xl = next(bar) x = np.flip(x, axis=1) pred = model_pred.predict(sess, np.array(x), np.array(xl)) for p in pred: ans = "".join(ws.inverse_transform(p)) response_dict[ip] = ans print("线程-模型>>完成处理来自", ip, "的请求,返回内容:", ans) break lock.release() time.sleep(0.1)
class chatbot_port(object): def __init__(self): self.cell_type = 'lstm' self.depth = 2 self.bidirectional = True self.attention_type = 'Bahdanau' self.use_residual = False self.use_dropout = False print("!!!!") self.time_major = False self.hidden_units = 512 random.seed(0) np.random.seed(0) tf.set_random_seed(0) self.x_data, self._, self.ws = pickle.load( open('chatbot_cut/chatbot.pkl', 'rb')) self.config = tf.ConfigProto(device_count={ 'CPU': 1, 'GPU': 0 }, allow_soft_placement=True, log_device_placement=False) self.save_path = 'chatbot_cut/s2ss_chatbot_anti.ckpt' tf.reset_default_graph() self.model_pred = SequenceToSequence( input_vocab_size=len(self.ws), target_vocab_size=len(self.ws), batch_size=1, mode='decode', beam_width=64, bidirectional=self.bidirectional, cell_type=self.cell_type, depth=self.depth, attention_type=self.attention_type, use_residual=self.use_residual, use_dropout=self.use_dropout, parallel_iterations=1, time_major=self.time_major, hidden_units=self.hidden_units, share_embedding=True, pretrained_embedding=True) self.init = tf.global_variables_initializer() #sess.run(self.init) print("!!!!") def chat(self, user_text): with tf.Session(config=self.config) as sess: self.model_pred.load(sess, self.save_path) x_test = [jieba.lcut(user_text.lower())] bar = batch_flow([x_test], self.ws, 1) x, xl = next(bar) x = np.flip(x, axis=1) pred = self.model_pred.predict(sess, np.array(x), np.array(xl)) return ''.join(self.ws.inverse_transform(pred))
def chatbot_port(user_text, bidirectional=True, num=0, cell_type='lstm', depth=2, attention_type='Bahdanau', use_residual=False, use_dropout=False, time_major=False, hidden_units=512): random.seed(0) np.random.seed(0) tf.set_random_seed(0) from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow x_data, _, ws = pickle.load(open('chatbot_cut/chatbot.pkl', 'rb')) config = tf.ConfigProto( device_count={'CPU': 1, 'GPU': 0}, allow_soft_placement=True, log_device_placement=False ) save_path = 'chatbot_cut/s2ss_chatbot_anti.ckpt' tf.reset_default_graph() model_pred = SequenceToSequence( input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=64, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, parallel_iterations=1, time_major=time_major, hidden_units=hidden_units, share_embedding=True, pretrained_embedding=True ) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) x_test = [jieba.lcut(user_text.lower())] print(user_text) bar = batch_flow([x_test], ws, 1) x, xl = next(bar) print(x,xl) x = np.flip(x, axis=1) pred = model_pred.predict( sess, np.array(x), np.array(xl) ) print(pred) return ''.join(ws.inverse_transform(pred))
def test(params): from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow_bucket as batch_flow from threadedgenerator import ThreadedGenerator x_data, y_data = pickle.load(open('chatbot.pkl', 'rb')) #extract_conv.py 生成 ws = pickle.load(open('ws.pkl', 'rb')) #训练 """ 1.n_epoch是训练的轮次数; 2.理论上来讲训练的轮次数越大,那么训练的精度越高; 3.如果训练的轮次数特别大,比如1000,那么有可能会发生过拟合的现象,但是是否过拟合也和训练的数据有关 4.n_epoch越大,训练的时间越长; 5.办公室电脑用P5000的GPU训练40轮,训练了大概3天,训练2轮,大概一个半小时, 如果使用CPU来训练的话,速度会特别特别的慢,可能一轮就要几个小时 """ n_epoch = 2 batch_size = 128 #每一轮的步数 steps = int(len(x_data) / batch_size) + 1 #日志 config = tf.ConfigProto( allow_soft_placement=True, #是不是由系统选择CPU还是GPU log_device_placement=False #是不是打印设备的日志 ) #训练完后的模型保存路径 save_path = './model/s2ss_chatbot.ckpt' #重置默认的图 tf.reset_default_graph() #定义图的信息 with tf.Graph().as_default(): random.seed(0) np.random.seed(0) tf.set_random_seed(0) #传入定义的配置 with tf.Session(config=config) as sess: # 定义模型 model = SequenceToSequence( input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=batch_size, **params #传入的参数 ) init = tf.global_variables_initializer() sess.run(init) #定义数据流 放在线程生成器里做 flow = ThreadedGenerator(batch_flow([x_data, y_data], ws, batch_size, add_end=[False, True]), queue_maxsize=30) for epoch in range(1, n_epoch + 1): costs = [] #进度条 bar = tqdm(range(steps), total=steps, desc='epoch {}, loss=0.000000'.format(epoch)) #变量没啥意义 或者 之后用不到的 使用下划线'_'来来表示 for _ in bar: x, xl, y, yl = next(flow) #[[1,2], [3,4]] #[[3,4], [1,2]] #对输出进行翻转 这个实际上是在训练时的一个技巧,这个技巧出自于encoder的论文 x = np.flip(x, axis=1) #得到损失和学习率 cost, lr = model.train(sess, x, xl, y, yl, return_lr=True) costs.append(cost) #进行信息的打印 bar.set_description( 'epoch {} loss={:.6f} lr={:.6f}'.format( epoch, np.mean(costs), lr)) #保存模型 model.save(sess, save_path) #测试 模型的正确性 tf.reset_default_graph() #默认的图reset model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=12, parallel_iterations=1, **params) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow([x_data, y_data], ws, 1, add_end=False) t = 0 for x, xl, y, yl in bar: x = np.flip(x, axis=1) pred = model_pred.predict(sess, np.array(x), np.array(xl)) #打印出预测的文字 print(ws.inverse_transform(x[0])) print(ws.inverse_transform(y[0])) print(ws.inverse_transform(pred[0])) t += 1 #仅测试三轮查看是否能正常对话 if t >= 3: break
def test(bidirectional, cell_type, depth, attention_type, use_residual, use_dropout, time_major, hidden_units): """测试不同参数在生成的假数据上的运行结果""" from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow from word_sequence import WordSequence # pylint: disable=unused-variable x_data, y_data, ws_input, ws_target = pickle.load( open('en-zh_cn.pkl', 'rb')) # 获取一些假数据 # x_data, y_data, ws_input, ws_target = generate(size=10000) # 训练部分 split = int(len(x_data) * 0.8) x_train, x_test, y_train, y_test = (x_data[:split], x_data[split:], y_data[:split], y_data[split:]) n_epoch = 2 batch_size = 256 steps = int(len(x_train) / batch_size) + 1 config = tf.ConfigProto( # device_count={'CPU': 1, 'GPU': 0}, allow_soft_placement=True, log_device_placement=False) save_path = './s2ss_en2zh.ckpt' tf.reset_default_graph() with tf.Graph().as_default(): random.seed(0) np.random.seed(0) tf.set_random_seed(0) with tf.Session(config=config) as sess: model = SequenceToSequence(input_vocab_size=len(ws_input), target_vocab_size=len(ws_target), batch_size=batch_size, learning_rate=0.001, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, parallel_iterations=64, hidden_units=hidden_units, optimizer='adam', time_major=time_major) init = tf.global_variables_initializer() sess.run(init) # print(sess.run(model.input_layer.kernel)) # exit(1) flow = batch_flow([x_train, y_train], [ws_input, ws_target], batch_size) for epoch in range(1, n_epoch + 1): costs = [] bar = tqdm(range(steps), total=steps, desc='epoch {}, loss=0.000000'.format(epoch)) for _ in bar: x, xl, y, yl = next(flow) cost = model.train(sess, x, xl, y, yl) costs.append(cost) bar.set_description('epoch {} loss={:.6f}'.format( epoch, np.mean(costs))) model.save(sess, save_path) # 测试部分 tf.reset_default_graph() model_pred = SequenceToSequence( input_vocab_size=len(ws_input), target_vocab_size=len(ws_target), batch_size=1, mode='decode', beam_width=12, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, hidden_units=hidden_units, time_major=time_major, parallel_iterations=1 # for test ) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow([x_test, y_test], [ws_input, ws_target], 1) t = 0 for x, xl, y, yl in bar: pred = model_pred.predict(sess, np.array(x), np.array(xl)) print(ws_input.inverse_transform(x[0])) print(ws_target.inverse_transform(y[0])) print(ws_target.inverse_transform(pred[0])) t += 1 if t >= 3: break tf.reset_default_graph() model_pred = SequenceToSequence( input_vocab_size=len(ws_input), target_vocab_size=len(ws_target), batch_size=1, mode='decode', beam_width=1, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, hidden_units=hidden_units, time_major=time_major, parallel_iterations=1 # for test ) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow([x_test, y_test], [ws_input, ws_target], 1) t = 0 for x, xl, y, yl in bar: pred = model_pred.predict(sess, np.array(x), np.array(xl)) print(ws_input.inverse_transform(x[0])) print(ws_target.inverse_transform(y[0])) print(ws_target.inverse_transform(pred[0])) t += 1 if t >= 3: break
def test(bidirectional, cell_type, depth, attention_type, use_residual, use_dropout, time_major, hidden_units): """测试不同参数在生成的假数据上的运行结果""" from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow from word_sequence import WordSequence # pylint: disable=unused-variable x_data, _, ws = pickle.load(open('chatbot.pkl', 'rb')) for x in x_data[:5]: print(' '.join(x)) config = tf.ConfigProto(device_count={ 'CPU': 1, 'GPU': 0 }, allow_soft_placement=True, log_device_placement=False) # save_path = '/tmp/s2ss_chatbot.ckpt' save_path = './s2ss_chatbot.ckpt' # 测试部分 tf.reset_default_graph() model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=0, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, parallel_iterations=1, time_major=time_major, hidden_units=hidden_units, share_embedding=True, pretrained_embedding=True) init = tf.global_variables_initializer() fp = open('meals.txt', 'r') meals = fp.readlines() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) while True: order = [] no_order_ans = ['咖啡', '紅茶', '綠茶'] user_text = input() if user_text in ('exit', 'quit'): exit(0) tw2s = OpenCC('tw2s') # user_text = tw2s.convert(user_text) # print(user_text) order_tmp, user_text = replace_meal_line(user_text, meals) print(user_text) for line in iter(order_tmp): order.append(line) x_test = [jieba.lcut(user_text.lower())] print(x_test) # x_test = [word_tokenize(user_text)] bar = batch_flow([x_test], ws, 1) x, xl = next(bar) x = np.flip(x, axis=1) # x = np.array([ # list(reversed(xx)) # for xx in x # ]) print(ws.inverse_transform(x[0])) pred = model_pred.predict(sess, np.array(x), np.array(xl)) s2tw = OpenCC('s2tw') out = filter(lambda ch: ch not in '</s><unk>', ws.inverse_transform(pred[0])) # print(ws.inverse_transform(pred[0])) ''' for i in range(len(out)): if out[i] == '甲': if len(order) == 0: out[i] = no_order_ans[0] del no_order_ans[0] else: out[i] = order[0] del order[0] ''' # print(type(out)) # print(list(out)) out = list(out) print(out[0]) print(out) for i, _ in enumerate(out): if out[i] == 'allkindofmeal': if not order: print('aaa') out[i] = no_order_ans[0] del no_order_ans[0] else: print('bbb') out[i] = order[0] del order[0] out = ''.join(list(out)) print(out)
def test(bidirectional, cell_type, depth, attention_type, use_residual, use_dropout, time_major, hidden_units): """测试不同参数在生成的假数据上的运行结果""" from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow from word_sequence import WordSequence # pylint: disable=unused-variable _, _, ws = pickle.load(open('chatbot.pkl', 'rb')) # for x in x_data[:5]: # print(' '.join(x)) config = tf.ConfigProto(device_count={ 'CPU': 1, 'GPU': 0 }, allow_soft_placement=True, log_device_placement=False) # save_path = '/tmp/s2ss_chatbot.ckpt' save_path = './s2ss_chatbot.ckpt' save_path_rl = './s2ss_chatbot_anti.ckpt' graph = tf.Graph() graph_rl = tf.Graph() with graph_rl.as_default(): model_rl = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=12, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, parallel_iterations=1, time_major=time_major, hidden_units=hidden_units, share_embedding=True, pretrained_embedding=True) init = tf.global_variables_initializer() sess_rl = tf.Session(config=config) sess_rl.run(init) model_rl.load(sess_rl, save_path_rl) # 测试部分 with graph.as_default(): model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=12, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, parallel_iterations=1, time_major=time_major, hidden_units=hidden_units, share_embedding=True, pretrained_embedding=True) init = tf.global_variables_initializer() sess = tf.Session(config=config) sess.run(init) model_pred.load(sess, save_path) while True: user_text = input('Input Chat Sentence:') if user_text in ('exit', 'quit'): exit(0) x_test = [jieba.lcut(user_text.lower())] bar = batch_flow([x_test], [ws], 1) x, xl = next(bar) x = np.flip(x, axis=1) print(x, xl) pred = model_pred.predict(sess, np.array(x), np.array(xl)) pred_rl = model_rl.predict(sess_rl, np.array(x), np.array(xl)) print(ws.inverse_transform(x[0])) print('no:', ws.inverse_transform(pred[0])) print('rl:', ws.inverse_transform(pred_rl[0])) p = [] for pp in ws.inverse_transform(pred_rl[0]): if pp == WordSequence.END_TAG: break if pp == WordSequence.PAD_TAG: break p.append(pp)
def test(params): from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow_bucket as batch_flow from threadedgenerator import ThreadedGenerator x_data, y_data = pickle.load(open('chatbot.pkl', 'rb')) ws = pickle.load(open('ws.pkl', 'rb')) #训练 """ 1.n_epoch是训练的轮次数; 2.理论上来讲训练的轮次数越大,那么训练的精度越高; 3.如果训练的轮次数特别大,比如1000,那么有可能会发生过拟合的现象,但是是否过拟合也和训练的数据有关 4.n_epoch越大,训练的时间越长; 5.办公室电脑用P5000的GPU训练40轮,训练了大概3天,训练2轮,大概一个半小时, 如果使用CPU来训练的话,速度会特别特别的慢,可能一轮就要几个小时 """ n_epoch = 2 batch_size = 128 steps = int(len(x_data) / batch_size) + 1 config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) save_path = './model/s2ss_chatbot.ckpt' tf.reset_default_graph() with tf.Graph().as_default(): random.seed(0) np.random.seed(0) tf.set_random_seed(0) with tf.Session(config=config) as sess: # 定义模型 model = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=batch_size, **params) init = tf.global_variables_initializer() sess.run(init) flow = ThreadedGenerator(batch_flow([x_data, y_data], ws, batch_size, add_end=[False, True]), queue_maxsize=30) for epoch in range(1, n_epoch + 1): costs = [] bar = tqdm(range(steps), total=steps, desc='epoch {}, loss=0.000000'.format(epoch)) for _ in bar: x, xl, y, yl = next(flow) #[[1,2], [3,4]] #[[3,4], [1,2]] x = np.flip(x, axis=1) cost, lr = model.train(sess, x, xl, y, yl, return_lr=True) costs.append(cost) bar.set_description( 'epoch {} loss={:.6f} lr={:.6f}'.format( epoch, np.mean(costs), lr)) model.save(sess, save_path) #测试 tf.reset_default_graph() model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=12, parallel_iterations=1, **params) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow([x_data, y_data], ws, 1, add_end=False) t = 0 for x, xl, y, yl in bar: x = np.flip(x, axis=1) pred = model_pred.predict(sess, np.array(x), np.array(xl)) print(ws.inverse_transform(x[0])) print(ws.inverse_transform(y[0])) print(ws.inverse_transform(pred[0])) t += 1 if t >= 3: break
def test(bidirectional, cell_type, depth, attention_type, use_residual, use_dropout, time_major, hidden_units, anti): """测试不同参数在生成的假数据上的运行结果""" from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow from word_sequence import WordSequence # pylint: disable=unused-variable x_data, _, ws = pickle.load(open('./pickle/chatbot.pkl', 'rb')) ''' for x in x_data[:5]: print(' '.join(x)) ''' config = tf.ConfigProto( device_count={'CPU': 1, 'GPU': 0}, allow_soft_placement=True, log_device_placement=False ) if anti is False: save_path = './pickle/s2ss_chatbot.ckpt' else: save_path = './pickle/s2ss_chatbot_anti.ckpt' # 测试部分 tf.reset_default_graph() model_pred = SequenceToSequence( input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=0, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, parallel_iterations=1, time_major=time_major, hidden_units=hidden_units, share_embedding=True, pretrained_embedding=True ) init = tf.global_variables_initializer() fp = open('meals.txt', 'r') meals = fp.readlines() order_table = defaultdict(list) # 紀錄所有點餐 with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) while True: order = [] # 紀錄當次點餐 no_order_ans = ['咖啡', '紅茶', '綠茶'] # 當使用者沒有輸入餐點回答的預設餐點 user_text = input() tmp = user_text.split() # 分開使用者id與問題 user_id = tmp[0] user_text = tmp[1] if user_text in ('exit', 'quit'): exit(0) elif user_text == '#menu': print(str(order_table[user_id]) + ' 零。') continue elif user_text == '#delete': del order_table[user_id] continue s2tw = OpenCC('s2tw') user_text = s2tw.convert(user_text) order_tmp, user_text = replace_meal_line(user_text, meals) for line in iter(order_tmp): order.append(line) x_test = [jieba.lcut(user_text.lower())] bar = batch_flow([x_test], ws, 1) x, xl = next(bar) x = np.flip(x, axis=1) pred = model_pred.predict( sess, np.array(x), np.array(xl) ) s2tw = OpenCC('s2tw') out = filter(lambda ch: ch not in '</s><unk>', ws.inverse_transform(pred[0])) out = list(out) for i, _ in enumerate(out): if out[i] == 'allkindofmeal': if not order: out[i] = no_order_ans[0] del no_order_ans[0] else: out[i] = order[0] order_table[user_id].append(order[0]) del order[0] order_table[user_id].extend(order) out = ''.join(list(out)) print(out)
def test(bidirectional, cell_type, depth, attention_type, use_residual, use_dropout, time_major, hidden_units): """测试不同参数在生成的假数据上的运行结果""" from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow from word_sequence import WordSequence # pylint: disable=unused-variable x_data, y_data, ws = pickle.load( open('chatbot.pkl', 'rb')) # 训练部分 n_epoch = 2 batch_size = 512 steps = int(len(x_data) / batch_size) + 1 config = tf.ConfigProto( # device_count={'CPU': 1, 'GPU': 0}, allow_soft_placement=True, log_device_placement=False ) save_path = './s2ss_chatbot_forward.ckpt' tf.reset_default_graph() with tf.Graph().as_default(): random.seed(0) np.random.seed(0) tf.set_random_seed(0) with tf.Session(config=config) as sess: model = SequenceToSequence( input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=batch_size, learning_rate=0.0001, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, hidden_units=hidden_units, optimizer='adadelta', dropout=0.4, time_major=time_major, share_embedding=True ) init = tf.global_variables_initializer() sess.run(init) flow = batch_flow([x_data, y_data], ws, batch_size) for epoch in range(1, n_epoch + 1): costs = [] bar = tqdm(range(steps), total=steps, desc='epoch {}, loss=0.000000'.format(epoch)) for _ in bar: x, xl, y, yl = next(flow) cost = model.train(sess, x, xl, y, yl) costs.append(cost) bar.set_description('epoch {} loss={:.6f}'.format( epoch, np.mean(costs) )) model.save(sess, save_path) # 测试部分 tf.reset_default_graph() model_pred = SequenceToSequence( input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=12, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, hidden_units=hidden_units, time_major=time_major, parallel_iterations=1, share_embedding=True ) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow( [x_data, y_data], ws, 1 ) t = 0 for x, xl, y, yl in bar: pred = model_pred.predict( sess, x, xl ) print(ws.inverse_transform(x[0])) print(ws.inverse_transform(y[0])) print(ws.inverse_transform(pred[0])) t += 1 if t >= 3: break
def test(params): from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow_bucket as batch_flow from word_sequence import WordSequence from threadedgenerator import ThreadedGenerator x_data, y_data = pickle.load(open('chatbot.pkl', 'rb')) ws = pickle.load(open('ws.pkl', 'rb')) n_epoch = 2 batch_size = 128 steps = int(len(x_data) / batch_size) + 1 config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) save_path = 'model/s2ss_chatbot_anti.ckpt' tf.reset_default_graph() with tf.Graph().as_default(): random.seed(0) np.random.seed(0) tf.set_random_seed(0) with tf.Session(config=config) as sess: model = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=batch_size, **params) init = tf.global_variables_initializer() sess.run(init) flow = ThreadedGenerator(batch_flow([x_data, y_data], ws, batch_size, add_end=[False, True]), queue_maxsize=30) dummy_encoder_inputs = np.array( [np.array([WordSequence.PAD]) for _ in range(batch_size)]) dummy_encoder_inputs_length = np.array([1] * batch_size) for epoch in range(1, n_epoch + 1): costs = [] bar = tqdm(range(steps), total=steps, desc='epoch {}, loss=0.000000'.format(epoch)) for _ in bar: x, xl, y, yl = next(flow) x = np.flip(x, axis=1) add_loss = model.train(sess, dummy_encoder_inputs, dummy_encoder_inputs_length, y, yl, loss_only=True) add_loss *= -0.5 cost, lr = model.train(sess, x, xl, y, yl, return_lr=True, add_loss=add_loss) costs.append(cost) bar.set_description( 'epoch {} loss={:.6f} lr={:.6f}'.format( epoch, np.mean(costs), lr)) model.save(sess, save_path) flow.close() tf.reset_default_graph() model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=12, **params) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow([x_data, y_data], ws, 1, add_end=False) t = 0 for x, xl, y, yl in bar: x = np.flip(x, axis=1) pred = model_pred.predict(sess, np.array(x), np.array(xl)) print(ws.inverse_transform(x[0])) print(ws.inverse_transform(y[0])) print(ws.inverse_transform(pred[0])) t += 1 if t >= 3: break tf.reset_default_graph() model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=1, **params) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow([x_data, y_data], ws, 1, add_end=False) t = 0 for x, xl, y, yl in bar: x = np.flip(x, axis=1) pred = model_pred.predict(sess, np.array(x), np.array(xl)) print(ws.inverse_transform(x[0])) print(ws.inverse_transform(y[0])) print(ws.inverse_transform(pred[0])) t += 1 if t >= 3: break
def test(bidirectional, cell_type, depth, attention_type, use_residual, use_dropout, time_major, hidden_units): """测试不同参数在生成的假数据上的运行结果""" from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow from word_sequence import WordSequence # pylint: disable=unused-variable x_data, _, ws = pickle.load(open('chatbot.pkl', 'rb')) for x in x_data[:5]: print(' '.join(x)) config = tf.ConfigProto(device_count={ 'CPU': 1, 'GPU': 0 }, allow_soft_placement=True, log_device_placement=False) # save_path = '/tmp/s2ss_chatbot.ckpt' save_path = './s2ss_chatbot_forward.ckpt' # 测试部分 tf.reset_default_graph() model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=12, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, hidden_units=hidden_units, time_major=time_major, parallel_iterations=1, share_embedding=True) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) while True: user_text = input('Input Chat Sentence:') if user_text in ('exit', 'quit'): exit(0) x_test = [list(user_text.lower())] bar = batch_flow([x_test], [ws], 1) x, xl = next(bar) # x = np.array([ # list(reversed(xx)) # for xx in x # ]) print(x, xl) pred = model_pred.predict(sess, np.array(x), np.array(xl)) print(pred) print(ws.inverse_transform(x[0])) print(ws.inverse_transform(pred[0]))
def test(bidirectional, cell_type, depth, attention_type, use_residual, use_dropout, time_major, hidden_units): """测试不同参数在生成的假数据上的运行结果""" from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow from word_sequence import WordSequence # pylint: disable=unused-variable x_data, _, ws = pickle.load(open('chatbot.pkl', 'rb')) for x in x_data[:5]: print(' '.join(x)) config = tf.ConfigProto( device_count={'CPU': 1, 'GPU': 0}, allow_soft_placement=True, log_device_placement=False ) # save_path = '/tmp/s2ss_chatbot.ckpt' save_path = './s2ss_chatbot_anti.ckpt' # 测试部分 tf.reset_default_graph() model_pred = SequenceToSequence( input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=64, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, parallel_iterations=1, time_major=time_major, hidden_units=hidden_units, share_embedding=True, pretrained_embedding=True ) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) with open('test_input.txt', 'r',encoding='utf-8',newline='') as f: with open('test_output.txt','w',encoding='utf-8') as g: for user_text in f: user_text=user_text.rstrip() print(user_text,file=g) x_test = [jieba.lcut(user_text.lower())] bar = batch_flow([x_test], ws, 1) x, xl = next(bar) print(x,xl,file=g) x = np.flip(x, axis=1) pred = model_pred.predict( sess, np.array(x), np.array(xl) ) ans = ws.inverse_transform(pred) print(ans,file=g) while True: user_text = input('Input Chat Sentence:') if user_text in ('exit', 'quit'): exit(0) x_test = [jieba.lcut(user_text.lower())] bar = batch_flow([x_test], ws, 1) x, xl = next(bar) x = np.flip(x, axis=1) print(x, xl) pred = model_pred.predict( sess, np.array(x), np.array(xl) ) print(pred) # prob = np.exp(prob.transpose()) print(ws.inverse_transform(x[0])) # print(ws.inverse_transform(pred[0])) # print(pred.shape, prob.shape) ans = ws.inverse_transform(pred) print(ans)
def test(bidirectional, cell_type, depth, attention_type): """测试并展示attention图 """ from tqdm import tqdm from fake_data import generate # 获取一些假数据 x_data, y_data, ws_input, ws_target = generate(size=10000) # 训练部分 split = int(len(x_data) * 0.9) x_train, x_test, y_train, y_test = (x_data[:split], x_data[split:], y_data[:split], y_data[split:]) n_epoch = 2 batch_size = 32 steps = int(len(x_train) / batch_size) + 1 config = tf.ConfigProto(device_count={ 'CPU': 1, 'GPU': 0 }, allow_soft_placement=True, log_device_placement=False) save_path = '/tmp/s2ss_atten.ckpt' with tf.Graph().as_default(): model = SequenceToSequence(input_vocab_size=len(ws_input), target_vocab_size=len(ws_target), batch_size=batch_size, learning_rate=0.001, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, parallel_iterations=1) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) for epoch in range(1, n_epoch + 1): costs = [] flow = batch_flow([x_train, y_train], [ws_input, ws_target], batch_size) bar = tqdm(range(steps), desc='epoch {}, loss=0.000000'.format(epoch)) for _ in bar: x, xl, y, yl = next(flow) cost = model.train(sess, x, xl, y, yl) costs.append(cost) bar.set_description('epoch {} loss={:.6f}'.format( epoch, np.mean(costs))) model.save(sess, save_path) # attention 展示 不能用 beam search 的 # 所以这里只是用 greedy with tf.Graph().as_default(): model_pred = SequenceToSequence(input_vocab_size=len(ws_input), target_vocab_size=len(ws_target), batch_size=1, mode='decode', beam_width=0, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, parallel_iterations=1) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) pbar = batch_flow([x_test, y_test], [ws_input, ws_target], 1) t = 0 for x, xl, y, yl in pbar: pred, atten = model_pred.predict(sess, np.array(x), np.array(xl), attention=True) ox = ws_input.inverse_transform(x[0]) oy = ws_target.inverse_transform(y[0]) op = ws_target.inverse_transform(pred[0]) print(ox) print(oy) print(op) fig, ax = plt.subplots() cax = ax.matshow(atten.reshape( [atten.shape[0], atten.shape[2]]), cmap=cm.coolwarm) ax.set_xticks(np.arange(len(ox))) ax.set_yticks(np.arange(len(op))) ax.set_xticklabels(ox) ax.set_yticklabels(op) fig.colorbar(cax) plt.show() print('-' * 30) t += 1 if t >= 10: break
def test(bidirectional, cell_type, depth, attention_type, use_residual, use_dropout, time_major, hidden_units): """测试不同参数在生成的假数据上的运行结果""" from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow_bucket as batch_flow from word_sequence import WordSequence # pylint: disable=unused-variable from threadedgenerator import ThreadedGenerator emb = pickle.load(open('emb.pkl', 'rb')) x_data, y_data, ws = pickle.load(open('chatbot.pkl', 'rb')) # 训练部分 n_epoch = 5 batch_size = 128 # x_data, y_data = shuffle(x_data, y_data, random_state=0) # x_data = x_data[:100000] # y_data = y_data[:100000] steps = int(len(x_data) / batch_size) + 1 config = tf.ConfigProto( # device_count={'CPU': 1, 'GPU': 0}, allow_soft_placement=True, log_device_placement=False) save_path = './s2ss_chatbot_anti.ckpt' tf.reset_default_graph() with tf.Graph().as_default(): random.seed(0) np.random.seed(0) tf.set_random_seed(0) with tf.Session(config=config) as sess: model = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=batch_size, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, hidden_units=hidden_units, time_major=time_major, learning_rate=0.001, optimizer='adam', share_embedding=True, dropout=0.2, pretrained_embedding=True) init = tf.global_variables_initializer() sess.run(init) # 加载训练好的embedding model.feed_embedding(sess, encoder=emb) # print(sess.run(model.input_layer.kernel)) # exit(1) flow = ThreadedGenerator(batch_flow([x_data, y_data], ws, batch_size), queue_maxsize=30) dummy_encoder_inputs = np.array( [np.array([WordSequence.PAD]) for _ in range(batch_size)]) dummy_encoder_inputs_lengths = np.array([1] * batch_size) for epoch in range(1, n_epoch + 1): costs = [] bar = tqdm(range(steps), total=steps, desc='epoch {}, loss=0.000000'.format(epoch)) for _ in bar: x, xl, y, yl = next(flow) x = np.flip(x, axis=1) add_loss = model.train(sess, dummy_encoder_inputs, dummy_encoder_inputs_lengths, y, yl, loss_only=True) add_loss *= -0.5 # print(x, y) cost, lr = model.train(sess, x, xl, y, yl, return_lr=True, add_loss=add_loss) costs.append(cost) bar.set_description( 'epoch {} loss={:.6f} lr={:.6f}'.format( epoch, np.mean(costs), lr)) model.save(sess, save_path) flow.close() # 测试部分 tf.reset_default_graph() model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=12, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, hidden_units=hidden_units, time_major=time_major, parallel_iterations=1, learning_rate=0.001, optimizer='adam', share_embedding=True, pretrained_embedding=True) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow([x_data, y_data], ws, 1) t = 0 for x, xl, y, yl in bar: x = np.flip(x, axis=1) pred = model_pred.predict(sess, np.array(x), np.array(xl)) print(ws.inverse_transform(x[0])) print(ws.inverse_transform(y[0])) print(ws.inverse_transform(pred[0])) t += 1 if t >= 3: break tf.reset_default_graph() model_pred = SequenceToSequence(input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=1, bidirectional=bidirectional, cell_type=cell_type, depth=depth, attention_type=attention_type, use_residual=use_residual, use_dropout=use_dropout, hidden_units=hidden_units, time_major=time_major, parallel_iterations=1, learning_rate=0.001, optimizer='adam', share_embedding=True, pretrained_embedding=True) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow([x_data, y_data], ws, 1) t = 0 for x, xl, y, yl in bar: pred = model_pred.predict(sess, np.array(x), np.array(xl)) print(ws.inverse_transform(x[0])) print(ws.inverse_transform(y[0])) print(ws.inverse_transform(pred[0])) t += 1 if t >= 3: break
def test(params): """测试不同参数在生成的假数据上的运行结果""" from sequence_to_sequence import SequenceToSequence from data_utils import batch_flow_bucket as batch_flow from word_sequence import WordSequence # pylint: disable=unused-variable from threadedgenerator import ThreadedGenerator x_data, y_data = pickle.load(open('chatbot.pkl', 'rb')) ws = pickle.load(open('ws.pkl', 'rb')) # 训练部分 n_epoch = 5 batch_size = 32 # x_data, y_data = shuffle(x_data, y_data, random_state=0) # x_data = x_data[:10000] # y_data = y_data[:10000] steps = int(len(x_data) / batch_size) + 1 config = tf.ConfigProto( # device_count={'CPU': 1, 'GPU': 0}, allow_soft_placement=True, log_device_placement=False ) save_path = './s2ss_chatbot.ckpt' tf.reset_default_graph() with tf.Graph().as_default(): random.seed(0) np.random.seed(0) tf.set_random_seed(0) with tf.Session(config=config) as sess: model = SequenceToSequence( input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=batch_size, **params ) init = tf.global_variables_initializer() sess.run(init) # print(sess.run(model.input_layer.kernel)) # exit(1) flow = ThreadedGenerator( batch_flow([x_data, y_data], ws, batch_size, add_end=[False, True]), queue_maxsize=30) for epoch in range(1, n_epoch + 1): costs = [] bar = tqdm(range(steps), total=steps, desc='epoch {}, loss=0.000000'.format(epoch)) for _ in bar: x, xl, y, yl = next(flow) x = np.flip(x, axis=1) # print(x, y) # print(xl, yl) # exit(1) cost, lr = model.train(sess, x, xl, y, yl, return_lr=True) costs.append(cost) bar.set_description('epoch {} loss={:.6f} lr={:.6f}'.format( epoch, np.mean(costs), lr )) model.save(sess, save_path) flow.close() # 测试部分 tf.reset_default_graph() model_pred = SequenceToSequence( input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=12, parallel_iterations=1, **params ) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow([x_data, y_data], ws, 1, add_end=False) t = 0 for x, xl, y, yl in bar: x = np.flip(x, axis=1) pred = model_pred.predict( sess, np.array(x), np.array(xl) ) print(ws.inverse_transform(x[0])) print(ws.inverse_transform(y[0])) print(ws.inverse_transform(pred[0])) t += 1 if t >= 3: break tf.reset_default_graph() model_pred = SequenceToSequence( input_vocab_size=len(ws), target_vocab_size=len(ws), batch_size=1, mode='decode', beam_width=1, parallel_iterations=1, **params ) init = tf.global_variables_initializer() with tf.Session(config=config) as sess: sess.run(init) model_pred.load(sess, save_path) bar = batch_flow([x_data, y_data], ws, 1, add_end=False) t = 0 for x, xl, y, yl in bar: pred = model_pred.predict( sess, np.array(x), np.array(xl) ) print(ws.inverse_transform(x[0])) print(ws.inverse_transform(y[0])) print(ws.inverse_transform(pred[0])) t += 1 if t >= 3: break