python实现简单对话机器人_聊天机器人连续对话用Python怎么实现？

我这里有一个用Python&深度学习创建聊天机器人的教程，是非常粗糙的聊天机器人，不知道对题主适不适用，下面是详细的教程。

这是成品的样子。简单的界面显然，此聊天机器人的响应极为有限

本教程包括以下七大部分：库与数据

初始化聊天机器人

建立深度学习模型

构建聊天机器人用户界面

运行聊天机器人

结论

改进领域

一.库与数据

运行该项目的所有必需组件都在GitHub存储库上。随意派生存储库并将其克隆到本地计算机。以下是这些组件的快速分解：train_chatbot.py —用于将自然语言数据读入训练集中并使用Keras顺序神经网络创建模型的代码

chatgui.py —用于基于模型的预测清理响应并创建用于与聊天机器人进行交互的图形界面的代码

classes.pkl —不同类型的响应类别的列表

words.pkl —可以用于模式识别的不同单词的列表

intents.json — JavaScript对象的组合，列出了与不同类型的单词模式相对应的不同标签

chatbot_model.h5-由train_chatbot.py创建并由chatgui.py使用的实际模型

完整的代码位于GitHub存储库上，但是为了透明和更好地理解，我将遍历代码的详细信息。

现在让我们开始导入必要的库。（当您在终端上运行python文件时，请确保已正确安装它们。我使用pip3来安装软件包。）

import nltk

nltk.download('punkt')

nltk.download('wordnet')

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()

import json

import pickle

​

import numpy as np

from keras.models import Sequential

from keras.layers import Dense, Activation, Dropout

from keras.optimizers import SGD

import random

我们有一堆库，例如nltk（自然语言工具包），其中包含一整套用于清理文本并为深度学习算法做准备的工具，json，将json文件直接加载到Python中，pickle，加载pickle文件，numpy（可以非常有效地执行线性代数运算）和keras（这是我们将要使用的深度学习框架）。

二.初始化聊天机器人

words=[]

classes = []

documents = []

ignore_words = ['?', '!']

data_file = open('intents.json').read()

intents = json.loads(data_file)

现在是时候初始化所有要存储自然语言数据的列表了。我们有我们前面提到的json文件，其中包含“意图”。这是json文件实际外观的一小段。典型的json格式

我们使用json模块加载文件并将其另存为变量intent。

for intent in intents['intents']:

for pattern in intent['patterns']:

​

# take each word and tokenize it

w = nltk.word_tokenize(pattern)

words.extend(w)

# adding documents

documents.append((w, intent['tag']))

​

# adding classes to our class list

if intent['tag'] not in classes:

classes.append(intent['tag'])

如果仔细查看json文件，可以看到对象中有子对象。例如，“模式”是“意图”内的属性。因此，我们将使用嵌套的for循环来提取“模式”中的所有单词并将其添加到单词列表中。然后，将对应标签中的每对模式添加到文档列表中。我们还将标记添加到类列表中，并使用简单的条件语句来防止重复。

words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_words]

words = sorted(list(set(words)))

​

classes = sorted(list(set(classes)))

​

print (len(documents), "documents")

​

print (len(classes), "classes", classes)

​

print (len(words), "unique lemmatized words", words)

​

​

pickle.dump(words,open('words.pkl','wb'))

pickle.dump(classes,open('classes.pkl','wb'))

接下来，我们将使用单词 list并将其中的所有单词进行词母化和小写。如果您还不知道，则lemmatize意味着将单词变成其基本含义或引理。例如，单词“ walking”，“ walked”，“ walks”都具有相同的引理，即“ walk”。限制我们的言语的目的是将所有内容缩小到最简单的程度。当我们为机器学习实际处理这些单词时，它将为我们节省大量时间和不必要的错误。这与词干法非常相似，词干法是将变体单词减少到其基数或词根形式。

接下来，我们对列表进行排序并打印出结果。好吧，看来我们已经准备好建立深度学习模型！

三.建立深度学习模型

# initializing training data

training = []

output_empty = [0] * len(classes)

for doc in documents:

# initializing bag of words

bag = []

# list of tokenized words for the pattern

pattern_words = doc[0]

# lemmatize each word - create base word, in attempt to represent related words

pattern_words = [lemmatizer.lemmatize(word.lower()) for word in pattern_words]

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

for w in words:

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("Training data created")

让我们使用变量training初始化训练数据。我们正在创建一个巨大的嵌套列表，其中包含每个文档的单词袋。我们有一个称为output_row的功能，它只是充当列表的键。然后，我们将训练集改组并进行训练-测试拆分，其中模式是X变量，意图是Y变量。

# Create model - 3 layers. First layer 128 neurons, second layer 64 neurons and 3rd output layer contains number of neurons

# equal to number of intents to predict output intent with softmax

model = Sequential()

model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))

model.add(Dropout(0.5))

model.add(Dense(64, activation='relu'))

model.add(Dropout(0.5))

model.add(Dense(len(train_y[0]), activation='softmax'))

​

# Compile model. Stochastic gradient descent with Nesterov accelerated gradient gives good results for this model

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)

model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

​

#fitting and saving the model

hist = model.fit(np.array(train_x), np.array(train_y), epochs=200, batch_size=5, verbose=1)

model.save('chatbot_model.h5', hist)

​

print("model created")

现在我们已经准备好训练和测试数据，我们现在将使用来自keras的深度学习模型Sequential。我不想让您沉迷于深度学习模型的工作原理的所有细节，但是如果您感到好奇，请查看本文底部的资源。

keras中的顺序模型实际上是最简单的神经网络之一，即多层感知器。如果您不知道那是什么，我也不会怪您。这是keras中的文档。

这个特定的网络具有3层，第一层具有128个神经元，第二层具有64个神经元，第三层具有意图数量作为神经元数量。请记住，该网络的目的是能够预测给定一些数据时选择哪种意图。

将使用随机梯度下降训练模型，这也是一个非常复杂的主题。随机梯度下降比普通梯度下降更有效，这就是您需要了解的全部。

训练模型后，整个对象将变成一个numpy数组，并保存为chatbot_model.h5。

我们将使用此模型来构成我们的聊天机器人界面！

四.构建聊天机器人界面

from keras.models import load_model

model = load_model('chatbot_model.h5')

import json

import random

intents = json.loads(open('intents.json').read())

words = pickle.load(open('words.pkl','rb'))

classes = pickle.load(open('classes.pkl','rb'))

我们需要从文件中提取信息。

def clean_up_sentence(sentence):

sentence_words = nltk.word_tokenize(sentence)

sentence_words = [lemmatizer.lemmatize(word.lower()) for word in sentence_words]

return sentence_words

​

# return bag of words array: 0 or 1 for each word in the bag that exists in the sentence

​

def bow(sentence, words, show_details=True):

# tokenize the pattern

sentence_words = clean_up_sentence(sentence)

# bag of words - matrix of N words, vocabulary matrix

bag = [0]*len(words)

for s in sentence_words:

for i,w in enumerate(words):

if w == s:

# assign 1 if current word is in the vocabulary position

bag[i] = 1

if show_details:

print ("found in bag: %s" % w)

return(np.array(bag))

​

def predict_class(sentence, model):

# filter out predictions below a threshold

p = bow(sentence, words,show_details=False)

res = model.predict(np.array([p]))[0]

ERROR_THRESHOLD = 0.25

results = [[i,r] for i,r in enumerate(res) if r>ERROR_THRESHOLD]

# sort by strength of probability

results.sort(key=lambda x: x[1], reverse=True)

return_list = []

for r in results:

return_list.append({"intent": classes[r[0]], "probability": str(r[1])})

return return_list

​

def getResponse(ints, intents_json):

tag = ints[0]['intent']

list_of_intents = intents_json['intents']

for i in list_of_intents:

if(i['tag']== tag):

result = random.choice(i['responses'])

break

return result

​

def chatbot_response(msg):

ints = predict_class(msg, model)

res = getResponse(ints, intents)

return res

以下是一些功能，其中包含运行GUI所需的所有必要过程，并将其封装为单元。我们具有clean_up_sentence（）函数，该函数可以清理输入的所有句子。该函数用在bow（）函数中，该函数接收要清理的句子并创建一袋用于预测类的单词（这是基于我们先前训练模型所得到的结果）。

在predict_class（）函数中，我们使用0.25的错误阈值来避免过度拟合。此函数将输出意图和概率的列表，它们与正确的意图匹配的可能性。函数getResponse（）获取输出的列表并检查json文件，并以最高的概率输出最多的响应。

最后，我们的chatbot_response（）接收一条消息（该消息将通过我们的聊天机器人GUI输入），使用我们的prepare_class（）函数预测该类，将输出列表放入getResponse（）中，然后输出响应。我们得到的是聊天机器人的基础。现在，我们可以告诉bot，然后它将进行响应。

#Creating GUI with tkinter

import tkinter

from tkinter import *

​

​

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)

ChatLog.yview(END)

​

​

base = Tk()

base.title("Hello")

base.geometry("400x500")

base.resizable(width=FALSE, height=FALSE)

​

#Create Chat window

ChatLog = Text(base, bd=0, bg="white", height="8", width="50", font="Arial",)

​

ChatLog.config(state=DISABLED)

​

#Bind scrollbar to Chat window

scrollbar = Scrollbar(base, command=ChatLog.yview, cursor="heart")

ChatLog['yscrollcommand'] = scrollbar.set

​

#Create Button to send message

SendButton = Button(base, font=("Verdana",12,'bold'), text="Send", width="12", height=5,

bd=0, bg="#32de97", activebackground="#3c9d9b",fg='#ffffff',

command= send )

​

#Create the box to enter message

EntryBox = Text(base, bd=0, bg="white",width="29", height="5", font="Arial")

#EntryBox.bind("", send)

​

​

#Place all components on the screen

scrollbar.place(x=376,y=6, height=386)

ChatLog.place(x=6,y=6, height=386, width=370)

EntryBox.place(x=128, y=401, height=90, width=265)

SendButton.place(x=6, y=401, height=90)

​

base.mainloop()

这里是有趣的部分（如果其他部分还不好玩）。我们可以使用tkinter（一个允许我们创建自定义界面的Python库）来创建GUI。

我们创建一个名为send（）的函数，该函数设置了聊天机器人的基本功能。如果我们输入到聊天机器人中的消息不是空字符串，则机器人将基于我们的chatbot_response（）函数输出响应。

此后，我们将建立聊天窗口，滚动条，用于发送消息的按钮以及用于创建消息的文本框。我们使用简单的坐标和高度将所有组件放置在屏幕上。

五.运行聊天机器人

终于可以运行我们的聊天机器人了！

因为我在Windows 10计算机上运行程序，所以必须下载名为Xming的服务器。如果您运行程序，并且给您一些有关程序失败的奇怪错误，则可以下载Xming。

在运行程序之前，需要确保使用pip（或pip3）安装python或python3。如果您不熟悉命令行命令，请查看下面的资源。

一旦运行程序，就应该得到这个。

六.结论

恭喜您完成了该项目！构建一个简单的聊天机器人可以使您掌握各种有用的数据科学和通用编程技能。我觉得学习任何东西的最好方法（至少对我而言）是建立和修补。如果您想变得擅长某事，则需要进行大量练习，而最好的练习方法就是动手并坚持练习！

七.可以改进的地方

这只是一套简单且让你在短时间内即可构建聊天机器人构建的教程，还有许多改进的空间，欢迎各位大牛进行修改更正。

1.尝试不同的神经网络

我们使用了最简单的keras神经网络，因此还有很多改进的余地。随时为您的项目尝试卷积网络或循环网络。

2.使用更多数据

就各种可能的意图和响应而言，我们的json文件非常小。人类语言比这复杂数十亿倍，因此从头开始创建JARVIS会需要更多。

3.使用不同的框架

有很多深度学习框架，而不仅仅是keras。有tensorflow，Apache Spark，PyTorch，Sonnet等。不要只局限于一种工具！

本文由未艾信息(www.weainfo.net)翻译，想看更多译文，大家可以到我们的网站上观看~

也可以关注我们的微信公众号：为AI呐喊（ID：weainahan）