tensorflow聊天机器人python实现_Python+tensorflow聊天机器人,pythonTensorFlow

一、遇到的问题解决

1.jieba分词的cut()方法:是一个生成器，返回一个列表，可以遍历查看。

精准模式

全模式：lists= [word for word in jieba.cut(s,cut_all=True)]

['我', '是', '张', '三', '，', '今天', '今天天气', '天天', '天气', '真好']

2.运行报错

readlines():

UnicodeDecodeError: 'gbk' codec can't decode byte 0x86 in position 22: illegal multibyte sequence

解决：            with open(file, 'r') as file_object:改为            with open(file, 'r',

encoding='UTF-8')

as file_object:

二、流程

1.reset_default_graph清除当前线程默认图形堆栈，重置全局默认图形

2.训练模型

1)构造训练集

读取问题与回答的数据，进行结巴分词，为每个词形成id,词和对应id保存在两个集合中。

为答案的句子添加''用来指示decoder什么时候停止预测。

训练集为：问题向量，答案向量

2)构造模型

设置学习率、优化方法等参数

3)模型训练

训练让loss变小，

训练10000次结果：

4)保存模型

3.reset_default_graph清除当前线程默认图形堆栈，重置全局默认图形

4.模型预测

1)加载模型

2)输入问题，对数据进行处理

3)输出结果

三、代码

def get_model(feed_previous=False):

"""构造模型

"""

learning_rate = tf.Variable(float(init_learning_rate), trainable=False, dtype=tf.float32)

learning_rate_decay_op = learning_rate.assign(learning_rate * 0.9)

encoder_inputs = []

decoder_inputs = []

target_weights = []

for i in range(input_seq_len):

encoder_inputs.append(tf.placeholder(tf.int32, shape=[None], name="encoder{0}".format(i)))

for i in range(output_seq_len + 1):

decoder_inputs.append(tf.placeholder(tf.int32, shape=[None], name="decoder{0}".format(i)))

for i in range(output_seq_len):

target_weights.append(tf.placeholder(tf.float32, shape=[None], name="weight{0}".format(i)))

# decoder_inputs左移一个时序作为targets

targets = [decoder_inputs[i + 1] for i in range(output_seq_len)]

cell = tf.contrib.rnn.BasicLSTMCell(size)

# 这里输出的状态我们不需要

outputs, _ = seq2seq.embedding_attention_seq2seq(

encoder_inputs,

decoder_inputs[:output_seq_len],

cell,

num_encoder_symbols=num_encoder_symbols,

num_decoder_symbols=num_decoder_symbols,

embedding_size=size,

output_projection=None,

feed_previous=feed_previous,

dtype=tf.float32)

# 计算加权交叉熵损失

loss = seq2seq.sequence_loss(outputs, targets, target_weights)

# 使用自适应优化器

opt = tf.train.AdamOptimizer(learning_rate=learning_rate)

# 优化目标：让loss最小化

update = opt.apply_gradients(opt.compute_gradients(loss))

# 模型持久化

saver = tf.train.Saver(tf.global_variables())

return encoder_inputs, decoder_inputs, target_weights, outputs, loss, update, saver, learning_rate_decay_op, learning_rate

def train():

"""

训练过程

"""

train_set = get_train_set()

with tf.Session() as sess:

encoder_inputs, decoder_inputs, target_weights, outputs, loss, update, saver, learning_rate_decay_op, learning_rate = get_model()

# 全部变量初始化

sess.run(tf.global_variables_initializer())

# 训练很多次迭代，每隔100次打印一次loss，可以看情况直接ctrl+c停止

previous_losses = []

for step in range(10000):

sample_encoder_inputs, sample_decoder_inputs, sample_target_weights = get_samples(train_set, 1000)

input_feed = {}

for l in range(input_seq_len):

input_feed[encoder_inputs[l].name] = sample_encoder_inputs[l]

for l in range(output_seq_len):

input_feed[decoder_inputs[l].name] = sample_decoder_inputs[l]

input_feed[target_weights[l].name] = sample_target_weights[l]

input_feed[decoder_inputs[output_seq_len].name] = np.zeros([len(sample_decoder_inputs[0])], dtype=np.int32)

[loss_ret, _] = sess.run([loss, update], input_feed)

if step % 100 == 0:

print( 'step=', step, 'loss=', loss_ret, 'learning_rate=', learning_rate.eval())

if len(previous_losses) > 5 and loss_ret > max(previous_losses[-5:]):

sess.run(learning_rate_decay_op)

previous_losses.append(loss_ret)

# 模型持久化

saver.save(sess, output_dir)

def predict():

"""

预测过程

"""

with tf.Session() as sess:

encoder_inputs, decoder_inputs, target_weights, outputs, loss, update, saver, learning_rate_decay_op, learning_rate = get_model(feed_previous=True)

saver.restore(sess, output_dir)

sys.stdout.write("> ")

sys.stdout.flush()

input_seq=input()

while input_seq:

input_seq = input_seq.strip()

input_id_list = get_id_list_from(input_seq)

if (len(input_id_list)):

sample_encoder_inputs, sample_decoder_inputs, sample_target_weights = seq_to_encoder(' '.join([str(v) for v in input_id_list]))

input_feed = {}

for l in range(input_seq_len):

input_feed[encoder_inputs[l].name] = sample_encoder_inputs[l]

for l in range(output_seq_len):

input_feed[decoder_inputs[l].name] = sample_decoder_inputs[l]

input_feed[target_weights[l].name] = sample_target_weights[l]

input_feed[decoder_inputs[output_seq_len].name] = np.zeros([2], dtype=np.int32)

# 预测输出

outputs_seq = sess.run(outputs, input_feed)

# 因为输出数据每一个是num_decoder_symbols维的，因此找到数值最大的那个就是预测的id，就是这里的argmax函数的功能

outputs_seq = [int(np.argmax(logit[0], axis=0)) for logit in outputs_seq]

# 如果是结尾符，那么后面的语句就不输出了

if EOS_ID in outputs_seq:

outputs_seq = outputs_seq[:outputs_seq.index(EOS_ID)]

outputs_seq = [wordToken.id2word(v) for v in outputs_seq]

print(" ".join(outputs_seq))

else:

print("WARN：词汇不在服务区")

sys.stdout.write("> ")

sys.stdout.flush()

input_seq = input()

if __name__ == "__main__":

tf.reset_default_graph()

train()

tf.reset_default_graph()

predict()

四、结果