devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

搭建简单的GPT聊天机器人_gpt搭建聊天机器人

作者：很楠不爱3 | 2024-03-17 17:58:59

赞

踩

gpt搭建聊天机器人

目录

第一步

进行语料库读取、文本预处理，完成data_utls.py

第二步

进行Seq2Seq模型的构建，完成Seq2Seq.py

第三步

进行模型参数设置、加载词典和数据、数据准备、GPU设置、构建优化器和损失函数，进行模型的训练和测试，完成execute.py。

第四步

通过给出的前端代码，调用flask前端进行测试，完成app.py文件，使用网页端聊天机器人聊天对话。

有问题后台私信

第一步

进行语料库读取、文本预处理，完成data_utls.py

data_utls.py

  1. '''
  2. 数据处理器
  3. '''
  4.  
  5. import os
  6. import jieba
  7. from tkinter import _flatten
  8. import json
  9.  
  10. # 读取语料库文件
  11. def read_corpus(corpus_path='../data/dialog/'):
  12.     '''
  13.     corpus_path:读取文件的路径
  14.     '''
  15.     corpus_files = os.listdir(corpus_path)  # 列出文件路径下所有文件 
  16.     corpus = []
  17.     for corpus_file in corpus_files:  # 循环读取各个文件内容
  18.         with open(os.path.join(corpus_path, corpus_file), 'r', encoding='utf-8') as f:
  19.             corpus.extend(f.readlines())
  20.     corpus = [i.replace('\n', '') for i in corpus]
  21.     return corpus  # 返回语料库的列表数据
  22.  
  23. print('语料库读取完成！'.center(30, '='))
  24. corpus = read_corpus(corpus_path='../data/dialog/')
  25. print('语料库展示: \n', corpus[:6])
  26.  
  27.  
  28. # 分词
  29. def word_cut(corpus, userdict='../data/ids/mydict.txt'):
  30.     '''
  31.     corpus：语料
  32.     userdict：自定义词典
  33.     '''
  34.     jieba.load_userdict(userdict)  # 加载自定义词典
  35.     corpus_cut = [jieba.lcut(i) for i in corpus]  # 分词
  36.  
  37.     print('分词完成'.center(30, '='))
  38.     return corpus_cut
  39.  
  40. # 构建词典
  41. def get_dict(corpus_cut):
  42.     '''
  43.     corpus_cut：分词后的语料文件
  44.     '''
  45.     tmp = _flatten(corpus_cut)  # 将分词结果列表拉直
  46.     all_dict = list(set(tmp))  # 去除重复词，保留所有出现的唯一的词
  47.     id2words = {i: j for i, j in enumerate(all_dict)}  
  48.     words2id = dict(zip(id2words.values(), id2words.keys()))  # 构建词典
  49.     print('词典构建完成'.center(30, '='))
  50.     return all_dict, id2words, words2id
  51.  
  52. # 执行分词
  53. corpus_cut = word_cut(corpus, userdict='../data/ids/mydict.txt')
  54. print('分词结果展示: \n', corpus_cut[:2])
  55. # 获取字典
  56. all_dict, id2words, words2id = get_dict(corpus_cut)
  57. print('词典展示: \n', all_dict[:6])
  58.  
  59.  
  60. # 文件保存
  61. def save(all_dict, corpus_cut, file_path='../tmp'):
  62.     '''
  63.     all_dict: 获取的词典
  64.     file_path: 文件保存路径
  65.     corpus_cut: 分词后的语料文件
  66.     '''
  67.     if not os.path.exists(file_path):
  68.         os.makedirs(file_path)  # 如果文件夹不存在则新建
  69.     source = corpus_cut[::2]  # 问
  70.     target = corpus_cut[1::2]  # 答
  71.     # 构建文件的对应字典
  72.     file = {'all_dict.txt': all_dict, 'source.txt': source, 'target.txt': target}
  73.     # 分别进行文件处理并保存
  74.     for i in file.keys():
  75.         if i in ['all_dict.txt']:
  76.             with open(os.path.join(file_path, i), 'w', encoding='utf-8') as f:
  77.                 f.writelines(['\n'.join(file[i])])
  78.         else:
  79.             with open(os.path.join(file_path, i), 'w', encoding='utf-8') as f:
  80.                 f.writelines([' '.join(i) + '\n' for i in file[i]])
  81. print('文件已保存'.center(30, '='))
  82.  
  83. # 执行保存
  84. save(all_dict, corpus_cut, file_path='../tmp')
  85.

第二步

进行Seq2Seq模型的构建，完成Seq2Seq.py

  1. import tensorflow as tf
  2. import typing
  3.  
  4. # 编码
  5. class Encoder(tf.keras.Model):
  6.     # 设置参数
  7.     def __init__(self, vocab_size: int, embedding_dim: int, enc_units: int) -> None:
  8.         '''
  9.         vocab_size: 词库大小
  10.         embedding_dim: 词向量维度
  11.         enc_units: LSTM层的神经元数量
  12.         '''
  13.         super(Encoder, self).__init__()
  14.         self.enc_units = enc_units
  15.         # 词嵌入层
  16.         self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim)
  17.         # LSTM层，GRU是简单的LSTM层
  18.         self.gru = tf.keras.layers.GRU(self.enc_units, return_sequences=True, return_state=True)
  19.     # 定义神经网络的传输顺序
  20.     def call(self, x: tf.Tensor, **kwargs) -> typing.Tuple[tf.Tensor, tf.Tensor]:
  21.         '''
  22.         x: 输入的文本
  23.         '''
  24.         x = self.embedding(x)
  25.         output, state = self.gru(x)
  26.         return output, state  # 输出预测结果和当前状态
  27.     
  28. # 注意力机制
  29. class BahdanauAttention(tf.keras.Model):
  30.     # 设置参数
  31.     def __init__(self, units: int) -> None:
  32.         '''
  33.         units: 神经元数据量
  34.         '''
  35.         super(BahdanauAttention, self).__init__()
  36.         self.W1 = tf.keras.layers.Dense(units)  # 全连接层
  37.         self.W2 = tf.keras.layers.Dense(units)  # 全连接层
  38.         self.V = tf.keras.layers.Dense(1)  # 输出层
  39.     # 设置注意力的计算方式
  40.     def call(self, query: tf.Tensor, values: tf.Tensor, **kwargs) -> typing.Tuple[tf.Tensor, tf.Tensor]:
  41.         '''
  42.         query: 上一层输出的特征值
  43.         values: 上一层输出的计算结果
  44.         '''
  45.         # 维度增加一维
  46.         hidden_with_time_axis = tf.expand_dims(query, 1)  
  47.         # 构造计算方法
  48.         score = self.V(tf.nn.tanh(self.W1(values) + self.W2(hidden_with_time_axis)))
  49.         # 计算权重
  50.         attention_weights = tf.nn.softmax(score, axis=1)
  51.         # 计算输出
  52.         context_vector = attention_weights * values
  53.         context_vector = tf.reduce_sum(context_vector, axis=1)
  54.  
  55.         return context_vector, attention_weights  # 输出特征向量和权重
  56.  
  57. # 解码
  58. class Decoder(tf.keras.Model):
  59.     # 设置参数
  60.     def __init__(self, vocab_size: int, embedding_dim: int, dec_units: int):
  61.         '''
  62.         vocab_size: 词库大小
  63.         embedding_dim: 词向量维度
  64.         dec_units: LSTM层的神经元数量
  65.         '''
  66.         super(Decoder, self).__init__()
  67.         self.dec_units = dec_units
  68.         # 词嵌入层
  69.         self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim)
  70.         # 添加LSTM层
  71.         self.gru = tf.keras.layers.GRU(self.dec_units, return_sequences=True, return_state=True)
  72.         # 全连接层
  73.         self.fc = tf.keras.layers.Dense(vocab_size)
  74.         # 添加注意力机制
  75.         self.attention = BahdanauAttention(self.dec_units)
  76.         
  77.     # 设置神经网络传输顺序
  78.     def call(self, x: tf.Tensor, hidden: tf.Tensor, enc_output: tf.Tensor) \
  79.             -> typing.Tuple[tf.Tensor, tf.Tensor, tf.Tensor]:
  80.         '''
  81.         x: 输入的文本
  82.         hidden: 上一层输出的特征值
  83.         enc_output: 上一层输出的计算结果
  84.         '''
  85.         # 计算注意力机制层的结果
  86.         context_vector, attention_weights = self.attention(hidden, enc_output)
  87.         # 次嵌入层
  88.         x = self.embedding(x)
  89.         # 词嵌入结果和注意力机制的结果合并
  90.         x = tf.concat([tf.expand_dims(context_vector, 1), x], axis=-1)
  91.         # 添加注意力机制
  92.         output, state = self.gru(x)
  93.  
  94.         # 输出结果更新维度
  95.         output = tf.reshape(output, (-1, output.shape[2]))
  96.         # 输出层
  97.         x = self.fc(output)
  98.  
  99.         return x, state, attention_weights  # 输出预测结果，当前状态和权重

第三步

进行模型参数设置、加载词典和数据、数据准备、GPU设置、构建优化器和损失函数，进行模型的训练和测试，完成execute.py。

  1.  
  2. import os
  3. import datetime
  4. from Seq2Seq import Encoder, Decoder
  5. import tensorflow as tf
  6.  
  7. # 设置参数
  8. data_path = '../data/ids'  # 文件路径
  9. epoch = 100  # 迭代训练次数
  10. batch_size = 15  # 每批次样本数
  11. embedding_dim = 256  # 词嵌入维度
  12. hidden_dim = 512  # 隐层神经元个数
  13. shuffle_buffer_size = 4  # 清洗数据集时将缓冲的实例数
  14. device = -1  # 使用的设备ID，-1即不使用GPU
  15. checkpoint_path = '../tmp/model'  # 模型参数保存的路径
  16. MAX_LENGTH = 50  # 句子的最大词长
  17. CONST = {'_BOS': 0, '_EOS': 1, '_PAD': 2, '_UNK': 3}# 最大输出句子的长度
  18.  
  19. # 加载词典
  20. print(f'[{datetime.datetime.now()}] 加载词典...')
  21. data_path = '../data/ids'
  22. CONST = {'_BOS': 0, '_EOS': 1, '_PAD': 2, '_UNK': 3}
  23. table = tf.lookup.StaticHashTable(  # 初始化后即不可变的通用哈希表。
  24.     initializer=tf.lookup.TextFileInitializer(
  25.         os.path.join(data_path, 'all_dict.txt'),
  26.         tf.string,
  27.         tf.lookup.TextFileIndex.WHOLE_LINE,
  28.         tf.int64,
  29.         tf.lookup.TextFileIndex.LINE_NUMBER
  30.     ),  # 要使用的表初始化程序。有关支持的键和值类型，请参见HashTable内核。
  31.     default_value=CONST['_UNK'] - len(CONST)  # 表中缺少键时使用的值。
  32. )
  33.  
  34. # 加载数据
  35. print(f'[{datetime.datetime.now()}] 加载预处理后的数据...')
  36.  
  37. # 构造序列化的键值对字典
  38. def to_tmp(text):
  39.     '''
  40.     text: 文本
  41.     '''
  42.     tokenized = tf.strings.split(tf.reshape(text, [1]), sep=' ')
  43.     tmp = table.lookup(tokenized.values) + len(CONST)
  44.     return tmp
  45.  
  46. # 增加开始和结束标记
  47. def add_start_end_tokens(tokens):
  48.     '''
  49.     tokens: 列化的键值对字典
  50.     '''
  51.     tmp = tf.concat([[CONST['_BOS']], tf.cast(tokens, tf.int32), [CONST['_EOS']]], axis=0)
  52.     return tmp
  53.  
  54. # 获取数据
  55. def get_dataset(src_path: str, table: tf.lookup.StaticHashTable) -> tf.data.Dataset:
  56.     '''
  57.     src_path: 文件路径
  58.     table:初始化后不可变的通用哈希表。
  59.     
  60.     '''
  61.     dataset = tf.data.TextLineDataset(src_path)
  62.     dataset = dataset.map(to_tmp)
  63.     dataset = dataset.map(add_start_end_tokens)
  64.     return dataset
  65.  
  66. # 获取数据
  67. src_train = get_dataset(os.path.join(data_path, 'source.txt'), table)
  68. tgt_train = get_dataset(os.path.join(data_path, 'target.txt'), table)
  69.  
  70. # 把数据和特征构造为tf数据集
  71. train_dataset = tf.data.Dataset.zip((src_train, tgt_train))
  72.  
  73. # 过滤数据实例数
  74. def filter_instance_by_max_length(src: tf.Tensor, tgt: tf.Tensor) -> tf.Tensor:
  75.     '''
  76.     src: 特征
  77.     tgt: 标签 
  78.     '''
  79.     return tf.logical_and(tf.size(src) <= MAX_LENGTH, tf.size(tgt) <= MAX_LENGTH)
  80.  
  81. train_dataset = train_dataset.filter(filter_instance_by_max_length)  # 过滤数据
  82. train_dataset = train_dataset.shuffle(shuffle_buffer_size)  # 打乱数据
  83. train_dataset = train_dataset.padded_batch(  # 将数据长度变为一致，长度不足用_PAD补齐
  84.     batch_size,
  85.     padded_shapes=([MAX_LENGTH + 2], [MAX_LENGTH + 2]),
  86.     padding_values=(CONST['_PAD'], CONST['_PAD']),
  87.     drop_remainder=True,
  88. )
  89. # 提升产生下一个批次数据的效率
  90. train_dataset = train_dataset.prefetch(tf.data.experimental.AUTOTUNE) 
  91.  
  92.  
  93. # 模型参数保存的路径如果不存在则新建
  94. if not os.path.exists(checkpoint_path):
  95.     os.makedirs(checkpoint_path)
  96.     
  97. # 获得当前主机上GPU运算设备的列表
  98. gpus = tf.config.experimental.list_physical_devices('GPU')
  99. if 0 <= device and 0 < len(gpus):
  100.     # 限制TensorFlow仅使用指定的GPU
  101.     tf.config.experimental.set_visible_devices(gpus[device], 'GPU')
  102.     logical_gpus = tf.config.experimental.list_logical_devices('GPU')
  103.  
  104. # 建模
  105. print(f'[{datetime.datetime.now()}] 创建一个seq2seq模型...')
  106. encoder = Encoder(table.size().numpy() + len(CONST), embedding_dim, hidden_dim)
  107. decoder = Decoder(table.size().numpy() + len(CONST), embedding_dim, hidden_dim)
  108.  
  109. # 设置优化器
  110. print(f'[{datetime.datetime.now()}] 准备优化器...')
  111. optimizer = tf.keras.optimizers.Adam()
  112.  
  113. # 设置损失函数
  114. print(f'[{datetime.datetime.now()}] 设置损失函数...')
  115. # 损失值计算方式
  116. loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True, reduction='none')
  117. # 损失函数
  118. def loss_function(loss_object, real: tf.Tensor, pred: tf.Tensor) -> tf.Tensor:
  119.     '''
  120.     loss_object: 损失值计算方式
  121.     real: 真实值
  122.     pred: 预测值
  123.     '''
  124.     # 计算真实值和预测值的误差
  125.     loss_ = loss_object(real, pred)
  126.     # 返回输出并不相等的值，并用_PAD填充
  127.     mask = tf.math.logical_not(tf.math.equal(real, CONST['_PAD']))
  128.     # 数据格式转换为跟损失值一致
  129.     mask = tf.cast(mask, dtype=loss_.dtype)
  130.     
  131.     return tf.reduce_mean(loss_ * mask)  # 返回平均误差
  132.     
  133.     
  134. # 设置模型保存
  135. checkpoint = tf.train.Checkpoint(optimizer=optimizer, encoder=encoder, decoder=decoder)
  136.  
  137. # 训练
  138. def train_step(src: tf.Tensor, tgt: tf.Tensor):
  139.     '''
  140.     src: 输入的文本
  141.     tgt: 标签
  142.     '''
  143.     # 获取标签维度
  144.     tgt_width, tgt_length = tgt.shape
  145.     loss = 0
  146.     # 创建梯度带，用于反向计算导数
  147.     with tf.GradientTape() as tape:
  148.         # 对输入的文本编码
  149.         enc_output, enc_hidden = encoder(src)
  150.         # 设置解码的神经元数目与编码的神经元数目相等
  151.         dec_hidden = enc_hidden
  152.         # 根据标签对数据解码
  153.         for t in range(tgt_length - 1):
  154.             # 更新维度，新增1维
  155.             dec_input = tf.expand_dims(tgt[:, t], 1)
  156.             # 解码
  157.             predictions, dec_hidden, dec_out = decoder(dec_input, dec_hidden, enc_output)
  158.             # 计算损失值
  159.             loss += loss_function(loss_object, tgt[:, t + 1], predictions)
  160.     # 计算一次训练的平均损失值
  161.     batch_loss = loss / tgt_length
  162.     # 更新预测值
  163.     variables = encoder.trainable_variables + decoder.trainable_variables
  164.     # 反向求导
  165.     gradients = tape.gradient(loss, variables)
  166.     # 利用优化器更新权重
  167.     optimizer.apply_gradients(zip(gradients, variables))
  168.  
  169.     return batch_loss  # 返回每次迭代训练的损失值
  170.  
  171. print(f'[{datetime.datetime.now()}] 开始训练模型...')
  172. # 根据设定的训练次数去训练模型
  173. for ep in range(epoch):
  174.     # 设置损失值
  175.     total_loss = 0
  176.     # 将每批次的数据取出，放入模型里
  177.     for batch, (src, tgt) in enumerate(train_dataset):
  178.         # 训练并计算损失值
  179.         batch_loss = train_step(src, tgt)
  180.         total_loss += batch_loss
  181.     if ep % 100 == 0:
  182.         # 每100训练次保存一次模型
  183.         checkpoint_prefix = os.path.join(checkpoint_path, 'ckpt')
  184.         checkpoint.save(file_prefix=checkpoint_prefix)
  185.  
  186.     print(f'[{datetime.datetime.now()}] 迭代次数: {ep+1} 损失值: {total_loss:.4f}')
  187.     
  188.  
  189.  
  190. # 模型预测
  191. def predict(sentence='你好'):
  192.     # 导入训练参数
  193.     checkpoint.restore(tf.train.latest_checkpoint(checkpoint_path))
  194.     # 给句子添加开始和结束标记
  195.     sentence = '_BOS' + sentence + '_EOS'
  196.     # 读取字段
  197.     with open(os.path.join(data_path, 'all_dict.txt'), 'r', encoding='utf-8') as f:
  198.         all_dict = f.read().split()
  199.     # 构建: 词-->id的映射字典
  200.     word2id = {j: i+len(CONST) for i, j in enumerate(all_dict)}
  201.     word2id.update(CONST)
  202.     # 构建: id-->词的映射字典
  203.     id2word = dict(zip(word2id.values(), word2id.keys()))
  204.     # 分词时保留_EOS 和 _BOS
  205.     from jieba import lcut, add_word
  206.     for i in ['_EOS', '_BOS']:
  207.         add_word(i)
  208.     # 添加识别不到的词，用_UNK表示
  209.     inputs = [word2id.get(i, CONST['_UNK']) for i in lcut(sentence)]
  210.     # 长度填充
  211.     inputs = tf.keras.preprocessing.sequence.pad_sequences(
  212.         [inputs], maxlen=MAX_LENGTH, padding='post', value=CONST['_PAD'])
  213.     # 将数据转为tensorflow的数据类型
  214.     inputs = tf.convert_to_tensor(inputs)
  215.     # 空字符串，用于保留预测结果
  216.     result = ''
  217.     
  218.     # 编码
  219.     enc_out, enc_hidden = encoder(inputs)
  220.     dec_hidden = enc_hidden
  221.     dec_input = tf.expand_dims([word2id['_BOS']], 0)
  222.  
  223.     for t in range(MAX_LENGTH):
  224.         # 解码
  225.         predictions, dec_hidden, attention_weights = decoder(dec_input, dec_hidden, enc_out)
  226.         # 预测出词语对应的id
  227.         predicted_id = tf.argmax(predictions[0]).numpy()
  228.         # 通过字典的映射，用id寻找词，遇到_EOS停止输出
  229.         if id2word.get(predicted_id, '_UNK') == '_EOS':
  230.             break
  231.         # 未预测出来的词用_UNK替代
  232.         result += id2word.get(predicted_id, '_UNK')
  233.         dec_input = tf.expand_dims([predicted_id], 0)
  234.  
  235.     return result # 返回预测结果
  236.  
  237. print('预测示例: \n', predict(sentence='你好，在吗'))

第四步

通过给出的前端代码，调用flask前端进行测试，完成app.py文件，使用网页端聊天机器人聊天对话。

app.py代码

  1. import tensorflow as tf
  2. import os
  3. from Seq2Seq import Encoder, Decoder
  4. from jieba import lcut, add_word
  5. from flask import Flask, render_template, request, jsonify
  6.  
  7. # 设置参数
  8. data_path = '../data/ids'  # 数据路径
  9. embedding_dim = 256  # 词嵌入维度
  10. hidden_dim = 512  # 隐层神经元个数
  11. checkpoint_path = '../tmp/model'  # 模型参数保存的路径
  12. MAX_LENGTH = 50  # 句子的最大词长
  13. CONST = {'_BOS': 0, '_EOS': 1, '_PAD': 2, '_UNK': 3}
  14.  
  15.  
  16. # 聊天预测
  17. def chat(sentence='你好'):
  18.     # 初始化所有词语的哈希表
  19.     table = tf.lookup.StaticHashTable(  # 初始化后即不可变的通用哈希表。
  20.         initializer=tf.lookup.TextFileInitializer(
  21.             os.path.join(data_path, 'all_dict.txt'),
  22.             tf.string,
  23.             tf.lookup.TextFileIndex.WHOLE_LINE,
  24.             tf.int64,
  25.             tf.lookup.TextFileIndex.LINE_NUMBER
  26.         ),  # 要使用的表初始化程序。有关支持的键和值类型，请参见HashTable内核。
  27.         default_value=CONST['_UNK'] - len(CONST)  # 表中缺少键时使用的值。
  28.     )
  29.  
  30.     # 实例化编码器和解码器
  31.     encoder = Encoder(table.size().numpy() + len(CONST), embedding_dim, hidden_dim)
  32.     decoder = Decoder(table.size().numpy() + len(CONST), embedding_dim, hidden_dim)
  33.     optimizer = tf.keras.optimizers.Adam()  # 优化器
  34.     # 模型保存路径
  35.     checkpoint = tf.train.Checkpoint(optimizer=optimizer, encoder=encoder, decoder=decoder)
  36.     # 导入训练参数
  37.     checkpoint.restore(tf.train.latest_checkpoint(checkpoint_path))
  38.     # 给句子添加开始和结束标记
  39.     sentence = '_BOS' + sentence + '_EOS'
  40.     # 读取字段
  41.     with open(os.path.join(data_path, 'all_dict.txt'), 'r', encoding='utf-8') as f:
  42.         all_dict = f.read().split()
  43.     # 构建: 词-->id的映射字典
  44.     word2id = {j: i + len(CONST) for i, j in enumerate(all_dict)}
  45.     word2id.update(CONST)
  46.     # 构建: id-->词的映射字典
  47.     id2word = dict(zip(word2id.values(), word2id.keys()))
  48.     # 分词时保留_EOS 和 _BOS
  49.     for i in ['_EOS', '_BOS']:
  50.         add_word(i)
  51.     # 添加识别不到的词，用_UNK表示
  52.     inputs = [word2id.get(i, CONST['_UNK']) for i in lcut(sentence)]
  53.     # 长度填充
  54.     inputs = tf.keras.preprocessing.sequence.pad_sequences(
  55.         [inputs], maxlen=MAX_LENGTH, padding='post', value=CONST['_PAD'])
  56.     # 将数据转为tensorflow的数据类型
  57.     inputs = tf.convert_to_tensor(inputs)
  58.     # 空字符串，用于保留预测结果
  59.     result = ''
  60.  
  61.     # 编码
  62.     enc_out, enc_hidden = encoder(inputs)
  63.     dec_hidden = enc_hidden
  64.     dec_input = tf.expand_dims([word2id['_BOS']], 0)
  65.  
  66.     for t in range(MAX_LENGTH):
  67.         # 解码
  68.         predictions, dec_hidden, attention_weights = decoder(dec_input, dec_hidden, enc_out)
  69.         # 预测出词语对应的id
  70.         predicted_id = tf.argmax(predictions[0]).numpy()
  71.         # 通过字典的映射，用id寻找词，遇到_EOS停止输出
  72.         if id2word.get(predicted_id, '_UNK') == '_EOS':
  73.             break
  74.         # 未预测出来的词用_UNK替代
  75.         result += id2word.get(predicted_id, '_UNK')
  76.         dec_input = tf.expand_dims([predicted_id], 0)
  77.     return result  # 返回预测结果
  78.  
  79.  
  80. # 实例化APP
  81. app = Flask(__name__, static_url_path='/static')
  82.  
  83.  
  84. @app.route('/message', methods=['POST'])
  85. # 定义应答函数，用于获取输入信息并返回相应的答案
  86. def reply():
  87.     # 从请求中获取参数信息
  88.     req_msg = request.form['msg']
  89.     # 将语句使用结巴分词进行分词
  90.     # req_msg = " ".join(jieba.cut(req_msg))
  91.     # 调用decode_line对生成回答信息
  92.     res_msg = chat(req_msg)
  93.     # 将unk值的词用微笑符号代替
  94.     res_msg = res_msg.replace('_UNK', '^_^')
  95.     res_msg = res_msg.strip()
  96.     # 如果接受到的内容为空，则给出相应的回复
  97.     if res_msg == ' ':
  98.         res_msg = '我们来聊聊天吧'
  99.     return jsonify({'text': res_msg})
  100.  
  101.  
  102. @app.route("/")
  103. # 在网页上展示对话
  104. def index():
  105.     return render_template('index.html')
  106.  
  107.  
  108. # 启动APP
  109. if (__name__ == '__main__'):
  110.     app.run(host='127.0.0.1', port=8808)

页面代码

  1. <!DOCTYPE html>
  2. <html >
  3. 	<head>
  4. 		<meta charset="UTF-8">
  5. 		<title>TIPDM</title>
  6.  
  7. 		<link rel="stylesheet" href="static/css/normalize.css">
  8.  
  9. 		<link rel='stylesheet prefetch' href='https://fonts.googleapis.com/css?family=Open+Sans'>
  10. 		<link rel='stylesheet prefetch' href='/static/js/jquery.mCustomScrollbar.min.css'>
  11. 		<link rel="stylesheet" href="static/css/style.css">
  12. 		<script src="/static/js/jquery-latest.js"></script>
  13. 	</head>
  14.  
  15. 	<body onload="init()" id="page_body">
  16.  
  17. <div class="chat">
  18. <div class="chat-title">
  19. 	<h1>中文聊天机器人</h1>
  20. 	<h2>咱们唠个五毛钱的天呗</h2>
  21. 	<figure class="avatar">
  22. 		<img src="static/res/7.png" /></figure>
  23. </div>
  24. <div class="messages">
  25. 	<div class="messages-content"></div>
  26. </div>
  27. <div class="message-box">
  28. 	<textarea type="text" class="message-input" placeholder="Type message..."></textarea>
  29. 	<button type="submit" class="message-submit">Send</button>
  30. </div>
  31.  
  32. </div>
  33. <div class="bg"></div>
  34. 		<script src='/static/js/jquery.min.js'></script>
  35. <script src='/static/js/jquery.mCustomScrollbar.concat.min.js'></script>
  36.  
  37. 				<script src="static/js/index.js"></script>
  38.  
  39. 	</body>
  40. </html>

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/257353?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号