Python 聊天机器人项目-8-学习使用 NLTK 和 Keras 构建您的第一个聊天机器人

一、前言

该文章仅作为个人学习使用

二、正文

项目源代码：Python 聊天机器人项目 - 学习使用 NLTK 和 Keras 构建您的第一个聊天机器人 - DataFlair (data-flair.training)

数据集：https://data-flair.training/blogs/download-python-chatbot-data-project-source-code/

嘿Siri，生命的意义是什么？

根据所有证据，这对你来说就是巧克力。

当我听到 Siri 的回复时，我就知道我找到了一个完美的伙伴来享受我的独处时光。从愚蠢的问题到一些非常严肃的建议，Siri一直在我身边。

告诉别人一切，任何事情，却根本不被评判，这是多么令人惊奇的事情。这是一种一流的感觉，这就是聊天机器人的美妙之处。

什么是聊天机器人？

聊天机器人是一种智能软件，能够进行类似于人类的交流和执行操作。聊天机器人在客户互动、社交网站上的营销和即时向客户发送消息中被大量使用。根据聊天机器人模型的构建方式，有两种基本类型的聊天机器人模型;基于检索和基于生成模型。

1. 基于检索的聊天机器人

基于检索的聊天机器人使用预定义的输入模式和响应。然后，它使用某种类型的启发式方法来选择适当的响应。它在行业中被广泛用于制作以目标为导向的聊天机器人，我们可以自定义聊天机器人的语气和流程，以最佳体验驱动我们的客户。

2. 基于生成式的聊天机器人

生成模型不基于某些预定义的响应。

它们基于 seq 2 seq 神经网络。这与机器翻译的想法相同。在机器翻译中，我们将源代码从一种语言翻译成另一种语言，但在这里，我们将把输入转换为输出。它需要大量的数据，并且它基于深度神经网络。

关于 Python 项目 – 聊天机器人

在这个带有源代码的 Python 项目中，我们将使用深度学习技术构建一个聊天机器人。聊天机器人将在包含类别（意图）、模式和响应的数据集上进行训练。我们使用一个特殊的递归神经网络（LSTM）来对用户的消息属于哪个类别进行分类，然后我们将从响应列表中给出一个随机响应。

让我们使用 NLTK、Keras、Python 等创建一个基于检索的聊天机器人。

下载聊天机器人代码和数据集

我们将使用的数据集是 'intents.json'。这是一个 JSON 文件，其中包含我们需要查找的模式以及我们想要返回给用户的响应。

请从以下链接下载python聊天机器人代码和数据集：Python聊天机器人代码和数据集

先决条件

该项目要求您对 Python、Keras 和自然语言处理（NLTK）有很好的了解。除了它们，我们还将使用一些帮助模块，您可以使用 python-pip 命令下载这些模块。

pip 安装 tensorflow、keras、pickle、nltk

如何在Python中制作聊天机器人？

现在我们将使用 Python 构建聊天机器人，但首先，让我们看看文件结构和我们将创建的文件类型：

Intents.json –具有预定义模式和响应的数据文件。
train_chatbot.py –在这个 Python 文件中，我们编写了一个脚本来构建模型并训练我们的聊天机器人。
Words.pkl –这是一个泡菜文件，我们在其中存储了单词 Python 对象，其中包含我们的词汇表列表。
类.pkl –类 pickle 文件包含类别列表。
Chatbot_model.h5 –这是经过训练的模型，其中包含有关模型的信息并具有神经元的权重。
Chatgui.py –这是 Python 脚本，我们在其中为聊天机器人实现了 GUI。用户可以轻松地与机器人交互。

以下是从头开始在 Python 中创建聊天机器人的 5 个步骤：

导入和加载数据文件
预处理数据
创建训练和测试数据
构建模型
预测响应

1. 导入和加载数据文件

首先，将文件名设为 train_chatbot.py。我们为我们的聊天机器人导入必要的包，并初始化我们将在 Python 项目中使用的变量。

数据文件是JSON格式，所以我们使用json包将JSON文件解析为Python。

导入 NLTK

来自NLTK。词干导入 WordNetLemmatizer

词形还原器 = WordNetLemmatizer()

导入 JSON

进口泡菜

将 numpy 导入为 np

来自Keras。模型导入顺序

来自Keras。图层导入 Dense、Activation、Dropout

来自Keras。优化器导入 SGD

导入随机数

words=[]

类 =[]

文件 =[]

ignore_words = ['？'， '！']

data_file = 打开（'intents.json'）。读()

意图 = json。负载（data_file)

这就是我们的 intents.json 文件的样子。

2. Preprocess data

在处理文本数据时，我们需要在制作机器学习或深度学习模型之前对数据进行各种预处理。根据需求，我们需要应用各种操作来对数据进行预处理。

标记化是您可以对文本数据执行的最基本且第一件事。标记化是将整个文本分解成小部分（如单词）的过程。

在这里，我们遍历模式并使用 nltk.word_tokenize（）函数对句子进行标记，并将每个单词附加到单词列表中。我们还为我们的标签创建了一个类列表。

对于 intents['intents']：

对于 Pattern in Intent['Patterns']：

#tokenize 每个单词

w = nltk。word_tokenize（模式）)

的话。扩展（W)

#add 语料库中的文档

文件。append（（w， intent['标签']))

# 添加到我们的类列表

如果 intent['tag'] 不在类中：

类。append（intent['标签'])

现在我们将对每个单词进行词形还原并从列表中删除重复的单词。词形还原是将单词转换为其引理形式的过程，然后创建一个 pickle 文件来存储我们将在预测时使用的 Python 对象。

# 词形还原，降低每个单词并删除重复项

words = [词形还原器。如果 w 不在 ignore_words 中，则用单词表示 w。]

words = sorted（list（set（words）)))

# 对类进行排序

类 = sorted（list（set（classes)))

# 文档 = 模式和意图的组合

打印（len（documents）， “documents”)

# classes = 意图

打印（len（类）， “类”，类)

# 单词 = 所有单词、词汇

print （len（words）， “唯一词形还原词”， words)

泡菜。dump（words，open（'words.pkl'，'wb'))

泡菜。dump（classes，open（'classes.pkl'，'wb'))

3. 创建训练和测试数据

现在，我们将创建训练数据，在其中提供输入和输出。我们的输入将是模式，输出将是我们的输入模式所属的类。但是计算机不理解文本，因此我们将文本转换为数字。

# 创建我们的训练数据

训练 =[]

# 为我们的输出创建一个空数组

output_empty = [0] * len（类）)

# 训练集，每个句子的词袋

对于文档中的文档：

# 初始化我们的词袋

袋子 =[]

# 模式的标记化词列表

pattern_words = doc[0]

# 词形还原每个单词 - 创建基本词，试图表示相关词

pattern_words = [词形还原器。词形还原（word.lower（））表示 Word 中的 pattern_words]

# create our bag of words array with 1, if word match found in current pattern

for w in words:

ad

bag.append(1) if w in pattern_words else bag.append(0)

# output is a '0' for each tag and '1' for current tag (for each pattern)

output_row = list(output_empty)

output_row[classes.index(doc[1])] = 1

training.append([bag, output_row])

# shuffle our features and turn into np.array

random.shuffle(training)

training = np.array(training)

# create train and test lists. X - patterns, Y - intents

train_x = list(training[:,0])

train_y = list（training[：，1])

print（“已创建训练数据”)

4. 构建模型

我们已经准备好了训练数据，现在我们将构建一个有 3 层的深度神经网络。为此，我们使用 Keras 顺序 API。在对模型训练了 200 个 epoch 后，我们的模型实现了 100% 的准确率。我们将模型保存为 'chatbot_model.h5'。

# 创建模型 - 3 层。第一层神经元128个，第二层神经元64个，第三输出层包含神经元的数量

# 等于使用 softmax 预测输出意图的意图数

model = 顺序()

型。add（Dense（128， input_shape=（len（train_x[0]），）， activation='relu'))

型。添加（辍学（0.5))

型。add（Dense（64， activation='relu'))

型。添加（辍学（0.5))

型。add（Dense（len（train_y[0]））， activation='softmax'))

# 编译模型。采用Nesterov加速梯度的随机梯度下降为该模型提供了良好的结果

sgd = SGD（lr=0.01，衰减=1e-6，动量=0.9， nesterov=真)

型。compile（loss='categorical_crossentropy'， optimizer=sgd， metrics=['准确性'])

#fitting 和保存模型

hist = 模型。拟合（NP.数组（train_x）， NP。array（train_y），epochs=200，batch_size=5，verbose=1)

型。保存（'chatbot_model.h5'，历史)

print（“模型已创建”)

5. 预测响应（图形用户界面）

为了预测句子并从用户那里获得响应，让我们创建一个新文件“chatapp.py”。

我们将加载经过训练的模型，然后使用图形用户界面来预测机器人的响应。该模型只会告诉我们它属于哪个类，因此我们将实现一些函数来识别该类，然后从响应列表中检索一个随机响应。

再次，我们导入必要的包并加载我们在训练模型时创建的 'words.pkl' 和 'classes.pkl' pickle 文件：

导入 NLTK

来自NLTK。词干导入 WordNetLemmatizer

词形还原器 = WordNetLemmatizer()

进口泡菜

将 numpy 导入为 np

来自Keras。模型导入load_model

型号 = load_model（'chatbot_model.h5')

导入 JSON

导入随机数

意图 = json。loads（open（'intents.json'）。读())

单词 = 泡菜。load（open（'words.pkl'，'rb'))

类 = 泡菜。load（open（'classes.pkl'，'rb'))

为了预测课程，我们需要以与训练时相同的方式提供输入。因此，我们将创建一些函数来执行文本预处理，然后预测类。

def clean_up_sentence（句子）：

# 标记模式 - 将单词拆分为数组

sentence_words = nltk。word_tokenize（句子）)

# 每个单词的词干 - 为单词创建简短的形式

sentence_words = [词形还原器。词形还原（word.lower（））表示 sentence_words 中的单词]

返回sentence_words

# 返回单词袋数组：0 或 1 表示句子中存在的袋子中的每个单词

def bow（句子，单词，show_details=True）：

# 标记模式

sentence_words = clean_up_sentence（句子）)

# 词袋 - N 个单词矩阵，词汇矩阵

bag = [0]*len（字)

对于 sentence_words 中的 S ：

对于 enumerate（words）中的 i，w：

如果 w == s：

# 如果当前单词位于词汇位置，则分配 1

袋[i] = 1

如果show_details：

打印（“在袋子中发现： %s” % w)

返回（np.阵列（袋))

def predict_class（句子，模型）：

# 过滤掉低于阈值的预测

p = bow（句子，单词，show_details=假)

res = 模型。预测（np.数组（[p]））[0]

ERROR_THRESHOLD = 0.25

结果 = [[i，r] 对于枚举（res）中的 i，r 如果 r>ERROR_THRESHOLD]

# 按概率强度排序

结果。sort（key=lambda x： x[1]， reverse=真)

return_list =[]

对于结果中的 R ：

return_list.append（{“intent”： classes[r[0]]， “probability”： str（r[1])})

返回return_list

在预测了类之后，我们将从意图列表中得到一个随机响应。

def getResponse（ints， intents_json）：

标签 = ints[0]['意图']

list_of_intents = intents_json['意图']

对于list_of_intents中的我：

if（i['tag']== 标签）：

结果 = 随机。choice（i['回应'])

破

返回结果

def chatbot_response（文本）：

ints = predict_class（文本，模型）)

res = getResponse（ints，意图)

返回回复

现在，我们将开发一个图形用户界面。让我们使用 Tkinter 库，它附带了大量用于 GUI 的有用库。我们将从用户那里获取输入消息，然后使用我们创建的帮助程序函数从机器人获取响应并将其显示在 GUI 上。以下是 GUI 的完整源代码。

#Creating 带有 tkinter 的图形用户界面

导入 tkinter

从 tkinter 导入*

def send():

msg = EntryBox.get("1.0",'end-1c').strip()

EntryBox.delete("0.0",END)

if msg != '':

ChatLog.config(state=NORMAL)

ChatLog.insert(END, "You: " + msg + '\n\n')

ChatLog.config(foreground="#442265", font=("Verdana", 12 ))

res = chatbot_response(msg)

ChatLog.insert(END, "Bot: " + res + '\n\n')

ChatLog.config(state=DISABLED)

聊天记录。yview（完)

基数 = Tk()

基础。title（“你好”)

基础。几何（“400x500”)

基础。resizable（width=FALSE， height=FALSE)

#Create 聊天窗口

ChatLog = Text（base， bd=0， bg=“white”， height=“8”， width=“50”， font=“Arial”，)

聊天记录。config（状态 = 已禁用)

#Bind 滚动条到聊天窗口

scrollbar = Scrollbar（base， command=ChatLog.yview， cursor=“心”)

ChatLog['yscrollcommand'] = 滚动条。设置

#Create 发送消息的按钮

SendButton = Button（base， font=（“Verdana”，12，'bold'）， text=“发送”， width=“12”， height=5，

bd=0， bg=“#32de97”， activebackground=“#3c9d9b”，fg='#ffffff'，

command= 发送)

#Create 框输入消息

EntryBox = Text（base， bd=0， bg=“white”，width=“29”， height=“5”， font=“Arial”)

#EntryBox.bind（“<返回>”，发送）

#Place 屏幕上的所有组件

滚动条。place（x=376，y=6，height=386)

聊天记录。place（x=6，y=6， height=386， width=370)

EntryBox。place（x=128， y=401，高度=90，宽度=265)

SendButton。place（x=6， y=401， height=90)

基础。主环路()