机器学习做自动聊天机器人

by Vanco Stojkov

通过Vanco Stojkov

建立聊天机器人需要什么？让我们找出答案。 (What does it take to build a chatbot? Let’s find out.)

Without any delay, the image below shows what we are building:

没有任何延迟，下图显示了我们正在构建的图像：

To answer the question in the title, “What does it take to build a chatbot?” the answer is not much.

要回答标题“构建聊天机器人需要什么？”中的问题。答案不多。

I’m a web developer. It has been my desire to dig into this thrilling field for a long time. Unfortunately, I can’t say I have the knowledge in Natural Language Understanding (NLU) required to build a chatbot without help. The good news is that such help is available today.

我是网络开发人员。长期以来，我一直渴望进入这个激动人心的领域。不幸的是，我不能说我不具备构建聊天机器人所需的自然语言理解(NLU)知识。好消息是，今天有这样的帮助。

Google’s Cloud Natural Language API, Microsoft’s Cognitive Services APIs, and IBM’s Watson Conversation provide commercial NLU services, with generous free tiers. There are also completely free ones, at least for the moment. This includes API.AI, which has recently been acquired by Google, and Wit.ai, which Facebook owns.

Google的Cloud Natural Language API ，Microsoft的Cognitive Services API和IBM的Watson Conversation提供了具有大量免费套餐的商业NLU服务。也有完全免费的，至少目前是这样。这包括API.AI ，最近被谷歌收购， Wit.ai ，其中Facebook的拥有。

From a web developer’s point of view, that’s all the help we need — an API which will remove the complexity for us.

从Web开发人员的角度来看，这就是我们需要的所有帮助-API将为我们消除复杂性。

让我们从有趣的部分开始 (Let’s start with the fun part)

If you are eager to see the example live, here is the demo available on Heroku. The entire code for this example is available on GitHub.

如果您希望现场观看此示例，请参见Heroku上的演示。该示例的完整代码可在GitHub上找到。

For the purpose of this article, we’ll create a chatbot called TiBot to answer our questions about the date and time. We’ll use API.AI’s API to process these questions. I believe API.AP is more intuitive and easier to work with than Wit.ai.

出于本文的目的，我们将创建一个名为TiBot的聊天机器人，以回答有关日期和时间的问题。我们将使用API.A我的API来处理这些问题。我相信API.AP比Wit.ai更直观，更易于使用。

At the back end, a simple Node.js server will handle requests sent from the front-end app via WebSockets. We’ll then fetch a response from the language processing API. Finally, we’ll send the answer back via WebSockets.

在后端，一个简单的Node.js服务器将处理通过WebSockets从前端应用程序发送的请求。然后，我们将从语言处理API中获取响应。最后，我们将通过WebSockets将答案发送回去。

At the front end, we have a messenger-like app built on a single Angular component. Angular is built-in TypeScript (a typed superset of JavaScript). If you are not familiar with either of them, you still should be able to understand the code.

在前端，我们有一个基于单个Angular组件的类似于Messenger的应用程序。 Angular是内置的TypeScript (JavaScript的类型化超集)。如果您不熟悉它们中的任何一个，那么您仍然应该能够理解代码。

I chose Angular because it inherently uses RxJS (the ReactiveX library for JavaScript). RxJS handles asynchronous data streams in an amazingly powerful yet simple manner.

我选择Angular是因为它固有地使用RxJS (JavaScript的ReactiveX库)。 RxJS以惊人的强大而简单的方式处理异步数据流。

API.AI设置 (API.AI setup)

API.AI has a neat Docs section. First, we need to become familiar with some of the basic terms and concepts related to the APIs, and to know NLU in general.

API.AI有一个简洁的Docs部分。首先，我们需要熟悉与API相关的一些基本术语和概念，并全面了解NLU。

Once we create an account at API.AI, we need to create an agent to start our project. With each agent, we get API keys — client and developer access tokens. We use the client access token to access the API.

在API.AI中创建帐户后，我们需要创建一个代理以启动我们的项目。对于每个代理，我们都获得API密钥-客户端和开发人员访问令牌。我们使用客户端访问令牌来访问API。

Agents are like projects or NLU modules. The important parts of an agent are intents, entities, and actions and parameters.

代理就像项目或NLU模块一样。代理的重要部分是意图，实体以及动作和参数。

Intents are the responses the API returns or, according to API.AI, “a mapping between what a user says and what action should be taken by your software.” For example, if a user says, “I want to book a flight,” the result we receive should look like the following:

意图是API返回的响应，或者根据API.AI，“用户所说的内容与您的软件应采取的措施之间的映射。” 例如，如果用户说“我要预订航班”，我们收到的结果应如下所示：

{ ... "action": "book_flight" ... }

Entities help extract data from what the user says. If a user says, “I want to book a flight to Paris,” we want to get the information about Paris in. We need that data passed to our logic so that we can book a flight to Paris for our user. The result should look like this:

实体有助于从用户所说的内容中提取数据。如果用户说“我想预订飞往巴黎的航班”，我们希望获得有关巴黎的信息。我们需要将数据传递到逻辑中，以便我们可以为用户预订飞往巴黎的航班。结果应如下所示：

{  ...  "action": "book_flight",   "parameters": {    "destination": "Paris"  }  ...}

Entities are parameters values, like data types. There are system-defined entities by the API.AI platform. Examples of these include @sys.date, @sys.color, @sys.number. More complicated ones include @sys.phone-number, @sys.date-period, @sys.unit-length-name.

实体是参数值，例如数据类型。 API.AI平台有系统定义的实体。这些示例包括@sys.date ， @sys.color ， @sys.number 。更复杂的参数包括@sys.phone-number ， @sys.date-period ， @sys.unit-length-name 。

We can also define our own entities, or pass them on the fly with each request. A good example of passing entities on the fly is that of users listening to their playlists. Users have a playlist entity in their request or a user session with all of the songs in the playlist. We would be able to respond to “Play Daydreaming” if the user is currently listening to Radiohead’s A Moon Shaped Pool playlist.

我们还可以定义自己的实体，或随每个请求即时传递它们。动态传递实体的一个很好的例子是用户收听其播放列表。用户在其请求中具有播放列表实体，或者与播放列表中的所有歌曲进行用户会话。如果用户当前正在收听Radiohead的A Moon Shaped Pool播放列表，我们将能够响应“ Play Daydreaming”。

Actions and parameters send requests to the API so that they result in an action. But they may also result in something our chatbot doesn’t understand. We may choose to fall back to a default response in that case.

动作和参数将请求发送到API，以便它们导致动作。但它们也可能导致我们的聊天机器人无法理解。在这种情况下，我们可以选择退回默认响应。

Parameters are the companion of actions. They complement and complete the action. In some cases, we don’t need parameters. But there are cases where actions only make sense with parameters. An example is booking a flight without knowing the destination. That is something we need to think about before we even start creating the intents.

参数是动作的伴侣。他们补充并完成了动作。在某些情况下，我们不需要参数。但是在某些情况下，操作仅对参数有意义。例如，在不知道目的地的情况下预订航班。在开始创建意图之前，我们需要考虑这一点。

Finally, the following code is how the API’s response should appear for a resolved intent:

最后，以下代码是API响应如何显示以解决问题的意图：

The most important part of the JSON is the “result” object with the “action” and “parameters” properties discussed above. The confidence for the resolved query (in the range of 0 to 1) is indicated with “score”. If “score” is zero, our query hasn’t been understood.

JSON最重要的部分是具有上述“action”和“parameters”属性的“result”对象。已解决查询的置信度(介于0到1之间)用“score”表示。如果“score”为零，则说明我们的查询不正确。

It’s worth noting that the “context” array contains information about unresolved intents that may need a follow-up response. For example, if a user says, “I want to book a flight,” we’d process the book_flight” action (the context). But to get the required “destination” , we may respond with, “Ok, where would you like to go?” and process the “destination” within the following request.

值得注意的是， “context”数组包含有关未解决的意图的信息，这些信息可能需要后续响应。例如，如果用户说“我想预订航班”，我们将处理book_flight”动作(上下文)。但是要获得所需的“destination” ，我们可能会回答：“好，您想去哪里？” 并在以下请求中处理“destination” 。

后端 (The back end)

We are building a chat app. The communication between the client and the server will go through WebSockets. For that purpose, we’ll use a Node.js WebSocket library on the server. Our WebSockets module looks like this:

我们正在构建一个聊天应用程序。客户端和服务器之间的通信将通过WebSockets进行。为此，我们将在服务器上使用Node.js WebSocket库。我们的WebSockets模块如下所示：

The format of the WebSockets messages is a string encoded JSON with “type” and “msg” properties.

WebSockets消息的格式是具有“type”和“msg”属性的字符串编码的JSON。

The string “type” refers to one of the following:

字符串“type”是指以下之一：

“bot”, which answers to the user.

“bot” ，它回答用户。

“user”, which the user asks the bot.

“user” ，用户向机器人询问。

“sessionId”, which issues a unique session ID.

“sessionId” ，发出唯一的会话ID。

Our chatbot’s answer is contained in “msg”. It is sent back to the user, the question of the user, or the sessionId.

我们的聊天机器人的答案包含在“msg” 。它被发送回用户，用户问题或sessionId。

The processRequest(msg) represents the core of our server’s functionality. It first makes a request to the API:

processRequest(msg)代表我们服务器功能的核心。它首先向API发出请求：

Then, it executes withdoIntent() — the specific action for the user’s intent, based on the response from the API:

然后，它根据API的响应，使用doIntent() (针对用户意图的特定操作doIntent()执行：

doIntent() checks to see if there is a function to handle the action in the response. It then calls that function with the parameters of the response. If there is no function for the action, or the response is not resolved, it checks for a fallback from the API. Or it calls handleUnknownAnswer().

doIntent()检查是否有函数来处理响应中的动作。然后，它使用响应的参数调用该函数。如果该操作没有功能，或者响应没有解决，它将检查API的后备状态。或调用handleUnknownAnswer() 。

The action handlers are in our intents module:

动作处理程序在我们的意图模块中：

To each handler function, we pass the parameters from the API response. We also pass the user’s time zone that we receive from the client side. Because we are dealing with the date and time, it turns out that the time zone plays an important role in our logic. It has nothing to do with the API, or NLU in general, but only with our specific business logic.

对于每个处理程序函数，我们将从API响应中传递参数。我们还会传递从客户端收到的用户时区。因为我们正在处理日期和时间，所以事实证明时区在我们的逻辑中起着重要作用。它与API或通常与NLU无关，而仅与我们特定的业务逻辑有关。

For example, if a user in London on Friday at 8:50 pm asks our bot, “What day is it today?” the answer should be, “It’s Friday.”

例如，如果星期五晚上8:50在伦敦的用户问我们的机器人，“今天是星期几？” 答案应该是“今天是星期五”。

But if that same user asks, “What day is it in Sydney?” the answer should be, “It’s Saturday in Sydney.”

但是，如果那个用户问：“悉尼今天是星期几？” 答案应该是“今天是悉尼的星期六”。

Location is important to our business logic too. We want to detect where the question is coming from (in the case of Sydney), so that we can get the time zone for its location. We would combine Google Maps Geocoding API and Time Zone API for that.

位置对我们的业务逻辑也很重要。我们想要检测问题的来源(例如悉尼)，以便我们可以获取问题所在的时区。为此，我们将结合使用Google Maps Geocoding API和时区API 。

前端 (The front end)

Our app is a single Angular component. The most important functionality is within the ngOnInit() method of the component:

我们的应用程序是单个Angular组件。最重要的功能是在组件的ngOnInit()方法中：

We first create the WebSocket (WS) connection to our server with a WS Observable. We then subscribe a couple of observers to it.

我们首先使用WS Observable创建到服务器的WebSocket(WS)连接。然后，我们订阅几个观察者。

The first observer gets the sessionId when it connects to the WebSocket server. Immediately, the take(1) operator is unsubscribed:

第一个观察者在连接到WebSocket服务器时获得sessionId 。立即取消take(1)运算符：

The second subscription is the fun one:

第二个订阅很有趣：

this.ws$.takeUntil(this.ngUnsubscribe$)  .filter(r => r.type === 'bot')  .retryWhen(err$ =>    Observable.zip(err$, Observable.range(1, 3), (e, n) => n)      .mergeMap(retryCount => Observable.timer(1000 * retryCount))  )  .delayWhen(inp => Observable.interval(100 + inp.msg.length * 10))  .subscribe(    (msg) => this.pushMsg(msg)  );

Here we want to take out the messages only from the bot, hence the filter(r => r.type === ‘bot’) operator. The retryWhen(err$ =&gt; …) operator automatically re-connects to the WebSocket after it has been disconnected.

在这里，我们只想从漫游器中取出消息，因此filter(r => r.type === 'bo t')运算符。 he retryWhen(err$ =& gt;…)运算符在断开连接后会自动重新连接到WebSocket。

The purpose of the delayWhen() operator is to achieve “the bot is typing” effect that the messengers use. To do this, we delay the data for 100 + MSG_CHARACTERS_LENGTH * 10 milliseconds.

delayWhen()运算符的目的是实现Messenger使用的“机器人正在键入”效果。为此，我们将数据延迟100 + MSG_CHARACTERS_LENGTH * 10毫秒。

When the message gets through all the operators, we push it into our array of messages (msg) => this.pushMsg(msg).

当消息通过所有运算符时，我们将其推入消息数组(msg) => this.pushMsg(m sg)。

We use the component’s private pushMsg() method to add a message and to show it in the chat:

我们使用组件的私有pushMsg()方法添加消息并将其显示在聊天中：

If the message is from the user (the clearUserMsg flag), we clear the input box. We use this.botIsTyping to control “the bot is typing” effect. So here we set it to false.

如果消息是来自用户的( clearUserMsg标志)，则清除输入框。我们使用this.botIsTyping来控制“机器人正在键入”效果。因此，这里我们将其设置为false 。

We handle the user input with the onSubmit() method when the user hits Enter:

当用户按下Enter键时，我们使用onSubmit()方法处理用户输入：

Along with the user’s message, we send the user’s sessionId and time zone. These are indicated in this.ws$.next(JSON.stringify(input)). To show the bot is typing effect, we also set this.botIsTyping to true.

连同用户的消息，我们发送用户的sessionId和时区。这些在this.ws$.next(JSON.stringify(input))中指示。为了显示机器人正在键入效果，我们还将this.botIsTyping设置为true 。

The Angular’s component template we use as the UI of our app, consists of the following code:

我们用作应用程序UI的Angular组件模板由以下代码组成：

This is all we need for our app on the front end.

这就是我们前端应用程序所需要的。

It’s amazing to see how elegant and clean this code turned out. Thanks to RxJS. When using WebSockets, things tend to get complicated. Here we’ve done it with a single line of code.

看到这段代码多么优雅和简洁，真是太神奇了。感谢RxJS。使用WebSockets时，事情往往会变得复杂。在这里，我们用一行代码完成了它。

And having features like auto re-connecting — well, that’s a story on its own. But with RxJS, we handled that in a simple manner.

并且具有自动重新连接等功能-嗯，这本身就是一个故事。但是，使用RxJS，我们可以以一种简单的方式来处理它。

To conclude, I hope you understandable why I said, “It doesn’t take much” to answer the question, “What does it take to build a chatbot?”

总而言之，我希望您能理解为什么我说“不需要很多”来回答“构建聊天机器人需要什么？”这一问题。

This doesn’t mean that building a chatbot is an easy task. These NLU services, as intelligent as they are, won’t solve all our problems. We still need to take care of our own business logic.

这并不意味着构建聊天机器人是一件容易的事。这些NLU服务虽然非常智能，但是并不能解决我们所有的问题。我们仍然需要照顾自己的业务逻辑。

A couple of years ago, it was impossible for me to build something similar to this. But services like API.AI now makes that power available to everyone.

几年前，我不可能建立类似的东西。但是，API.AI之类的服务现在使所有人都可以使用该功能。

API.AI also provides integrations with Facebook Messenger, Twitter, Viber, and Slack. But for this article, I thought it would be best to use their API to better understand how everything works.

API.AI还提供与Facebook Messenger，Twitter，Viber和Slack的集成。但是对于本文，我认为最好使用他们的API更好地了解一切。

I hope you’ve enjoyed this article and find it helpful to build your own chatbot.

我希望您喜欢这篇文章，并发现对构建自己的聊天机器人有帮助。