终止支持通知：2025年9月15日， AWS 我们将停止对Amazon Lex V1的支持。2025 年 9 月 15 日之后，您将无法再访问 Amazon Lex V1 控制台或 Amazon Lex V1 资源。如果您使用的是 Amazon Lex V2，请改为参阅 [Amazon Lex V2 指南](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html)。

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 练习 1：使用蓝图创建 Amazon Lex 机器人（控制台）
<a name="gs-bp"></a>

在本练习中，您将执行以下操作：
+ 在 Amazon Lex 控制台中创建您的首个 Amazon Lex 机器人并进行测试。

  在本练习中，您将使用**OrderFlowers**蓝图。有关蓝图的信息，请参阅 [Amazon Lex 和 AWS Lambda 蓝图](lex-lambda-blueprints.md)。

   
+ 创建 AWS Lambda 函数并在 Lambda 控制台中对其进行测试。在处理请求时，机器人调用此 Lambda 函数。在本练习中，您将使用 AWS Lambda 控制台中提供的 Lambda 蓝图 (**lex-order-flowers-python**) 来创建您的 Lambda 函数。此蓝图代码说明如何使用该 Lambda 函数执行初始化和验证以及履行 `OrderFlowers` 意图。

   
+ 更新机器人以将 Lambda 函数添加为代码挂钩，从而履行此意图。测试 end-to-end体验。

下面几节介绍蓝图的作用。

## Amazon Lex 机器人：蓝图概览
<a name="gs-bp-summary-bot"></a>

您可以使用**OrderFlowers**蓝图创建 Amazon Lex 机器人。有关机器人结构的更多信息，请参阅。[Amazon Lex：工作原理](how-it-works.md)此自动程序将按如下方式进行预配置：
+ **意图** — OrderFlowers
+ **槽位类型**：一个称为 `FlowerTypes` 的自定义槽类型，具有枚举值：`roses`、`lilies` 和 `tulips`。
+ **槽位**：在机器人实现此意图之前，意图需要以下信息（即槽位）。
  + `PickupTime`（AMAZON.TIME 内置类型）
  + `FlowerType`（FlowerTypes 自定义类型）
  + `PickupDate`（AMAZON.DATE 内置类型）
+ **表达**：以下示例表达表示用户的意图：
  + “我想要取花。”
  + “我想要订些花。”
+ **提示**：在机器人确定此意图后，它会使用以下提示来填充槽：
  + 用于 `FlowerType` 槽的提示：“您想要订哪种类型的花？”
  + 提示进入时`PickupDate`段 — “你想在哪一天拿起 \$1FlowerType\$1？”
  + 提示输入插`PickupTime`槽 — “你想在什么时候拿起 \$1FlowerType\$1？”
  + 确认声明 — “好的，您的 \$1FlowerType\$1 将在 \$1\$1 上准备好在 \$1PickupTime\$1 上取货。PickupDate这样可以吗？” 



## AWS Lambda 功能：蓝图摘要
<a name="gs-bp-summary-lambda"></a>

此练习中的 Lambda 函数执行初始化和验证以及履行任务。因此，创建 Lambda 函数后，通过将该 Lambda 函数指定为代码挂钩，可以处理初始化和验证以及履行任务，从而更新意图配置。
+ 作为初始化和验证代码挂钩，Lambda 函数执行基本验证。例如，如果用户提供正常营业时间范围之外的某个提取时间，则 Lambda 函数会指示 Amazon Lex 重新提示用户指定时间。
+ 作为履行代码挂钩的一部分，Lambda 函数会返回一条摘要消息，指示鲜花订单已下单（即，意图已履行）。

**下一个步骤**  
[步骤 1：创建 Amazon Lex 机器人（控制台）](gs-bp-create-bot.md)

# 步骤 1：创建 Amazon Lex 机器人（控制台）
<a name="gs-bp-create-bot"></a>

在本练习中，创建一个用于订购鲜花的机器人，名为 OrderFlowersBot。

创建 Amazon Lex 机器人（控制台）

1. 登录 AWS 管理控制台 并打开 Amazon Lex 控制台，网址为[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)。

1. 如果这是您的第一个自动程序，请选择 **Get Started (开始)**；否则，在 **Bots (自动程序)** 页面上，选择 **Create (创建)**。

1. 在 **Create your Lex bot** 页面上，提供以下信息，然后选择 **Create**。
   + 选择 **OrderFlowers** 蓝图。
   + 保留默认的机器人名称 (OrderFlowers)。
   + 对于 **COPPA**，选择 **No**。
   + 对于**用户言语存储**，选择相应的响应。

1. 选择**创建**。控制台可向 Amazon Lex 提出必要的请求，以保存配置。然后，控制台显示自动程序编辑器窗口。

1. 等待自动程序的构建确认。

1. 测试自动程序。
**注意**  
通过在测试窗口中键入文本可以测试自动程序，或者对于兼容的浏览器，可通过选择测试窗口中的麦克风按钮并说话这种方法。

   使用以下示例文本与自动程序进行对话来订花：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/OrderFlowers-NoLambda.png)

   自动程序通过此输入推断槽数据的 `OrderFlowers` 目的和提示。在您提供所有必要的槽数据后，自动程序将所有这类信息返回到客户端应用程序 (这里指控制台) 即可实现目的 (`OrderFlowers`)。控制台在测试窗口中显示这类信息。

   具体来说：
   + 在语句“What day do you want the roses to be picked up?”中出现了词语“roses”，这是因为已使用替换项 `{FlowerType}` 来配置 `pickupDate` 槽的提示。在控制台中对此进行验证。
   + “Okay, your roses will be ready...”语句是您配置的确认提示。
   + 最后一个语句 (“`FlowerType:roses...`”) 是返回到客户端 (这里指测试窗口) 的槽数据。在下一个练习中，将使用 Lambda 函数履行此意图，在这种情况下，您将收到一条指示订单已履行的消息。

**下一个步骤**  
[步骤 2 (可选)：查看信息流的详细信息 (控制台)](gs-bp-details-two-runtime-apis.md)

# 步骤 2 (可选)：查看信息流的详细信息 (控制台)
<a name="gs-bp-details-two-runtime-apis"></a>

本节介绍示例对话中每个用户输入在客户端与 Amazon Lex 之间的信息流。

该示例使用控制台测试窗口与机器人进行对话。

**打开 Amazon Lex 测试窗口**

1. 登录 AWS 管理控制台 并打开 Amazon Lex 控制台，网址为[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)。

1. 选择要测试的机器人。

1. 在控制台的右侧，选择**测试聊天机器人**。

要查看语音或所键入内容的信息流，请选择相应的主题。

**Topics**
+ [步骤 2a (可选)：查看语音信息流的详细信息 (控制台)](gs-bp-details-postcontent-flow.md)
+ [步骤 2b (可选)：查看所键入信息流的详细信息 (控制台)](gs-bp-details-part1.md)

# 步骤 2a (可选)：查看语音信息流的详细信息 (控制台)
<a name="gs-bp-details-postcontent-flow"></a>

本节介绍在客户使用语音发送请求时客户端与 Amazon Lex 之间的信息流。有关更多信息，请参阅 [PostContent](API_runtime_PostContent.md)。

1. 用户说：我想要订些花。

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostContent](API_runtime_PostContent.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
      x-amz-lex-session-attributes: "e30=" 
      Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
      Accept: "audio/mpeg"
      
      
      Request body
      input stream
      ```

      请求 URI 和正文都将向 Amazon Lex 提供信息：
      + 请求 URI — 提供机器人名称 (`OrderFlowers`)、机器人别名 (`$LATEST`) 以及用户名称（用于识别用户的随机字符串）。`content` 指示这是 `PostContent` API 请求（而不是 `PostText` 请求）。
      + 请求标头
        + `x-amz-lex-session-attributes` — base64 编码值表示“\$1\$1”。在客户端发出第一个请求时，没有会话属性。
        + `Content-Type` – 反映音频格式。
      + 请求正文 – 用户输入音频流 (“我想要订些花。”)。
**注意**  
如果用户选择向 `PostContent` API 发送文本 (“我想要订些花”) 而非使用语音，则请求正文为用户输入。`Content-Type` 标头会相应地进行设置：  

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
      x-amz-lex-session-attributes: "e30="
      Content-Type: "text/plain; charset=utf-8"
      Accept: accept
      
      Request body
      input stream
      ```

   1. 从输入流中，Amazon Lex 可检测意图 (`OrderFlowers`)。随后，它会选择其中一个目的槽 (本例中为 `FlowerType`) 和其中一个值引出提示，然后发送具有以下标头的响应：

      ```
      x-amz-lex-dialog-state:ElicitSlot
      x-amz-lex-input-transcript:I would like to order some flowers.
      x-amz-lex-intent-name:OrderFlowers
      x-amz-lex-message:What type of flowers would you like to order?
      x-amz-lex-session-attributes:e30=
      x-amz-lex-slot-to-elicit:FlowerType
      x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjpudWxsLCJQaWNrdXBEYXRlIjpudWxsfQ==
      ```

      标头值提供以下信息：
      + `x-amz-lex-input-transcript` – 提供来自请求的音频脚本 (用户输入)
      + `x-amz-lex-message` — 提供在响应中返回的音频 Amazon Lex 的脚本
      + `x-amz-lex-slots` – 槽和值的 base64 编码版本：

        ```
        {"PickupTime":null,"FlowerType":null,"PickupDate":null}
        ```
      + `x-amz-lex-session-attributes` – 会话属性 (\$1\$1) 的 base64 编码版本

      客户端将播放响应正文中的音频。

1. 用户说：玫瑰

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostContent](API_runtime_PostContent.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
      x-amz-lex-session-attributes: "e30="
      Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1" 
      Accept: "audio/mpeg"
      
      
      Request body
      input stream ("roses")
      ```

      请求正文是用户输入音频流 (玫瑰)。`sessionAttributes` 将保留为空。

   1. Amazon Lex 将解释当前意图的上下文中的输入流（它会记住它已经向此用户询问了关于 `FlowerType` 插槽的信息）。Amazon Lex 将首先更新当前意图的插槽值。然后，它选择另一个槽 (`PickupDate`)，以及它的一个提示消息 (When do you want to pick up the roses?)，并返回包含以下标头的响应：

      ```
      x-amz-lex-dialog-state:ElicitSlot
      x-amz-lex-input-transcript:roses
      x-amz-lex-intent-name:OrderFlowers
      x-amz-lex-message:When do you want to pick up the roses?
      x-amz-lex-session-attributes:e30=
      x-amz-lex-slot-to-elicit:PickupDate
      x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6bnVsbH0=
      ```

      标头值提供以下信息：
      + `x-amz-lex-slots` – 槽和值的 base64 编码版本：

        ```
        {"PickupTime":null,"FlowerType":"roses","PickupDate":null}
        ```
      + `x-amz-lex-session-attributes` – 会话属性 (\$1\$1) 的 base64 编码版本

      客户端将播放响应正文中的音频。

1. 用户说：明天

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostContent](API_runtime_PostContent.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
      x-amz-lex-session-attributes: "e30="
      Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
      Accept: "audio/mpeg"
      
      
      Request body
      input stream ("tomorrow")
      ```

      请求正文是用户输入音频流 (“明天”)。`sessionAttributes` 将保留为空。

   1. Amazon Lex 将解释当前意图的上下文中的输入流（它会记住它已经向此用户询问了关于 `PickupDate` 插槽的信息）。Amazon Lex 将更新当前意图的插槽 (`PickupDate`) 值。然后，它将选择另一个槽来引出 (`PickupTime`) 的值，并选择其中一个值引出提示 (您想在 2017 年 3 月 18 日的什么时间取玫瑰？)，然后返回带有以下标头的响应：

      ```
      x-amz-lex-dialog-state:ElicitSlot
      x-amz-lex-input-transcript:tomorrow
      x-amz-lex-intent-name:OrderFlowers
      x-amz-lex-message:When do you want to pick up the roses on 2017-03-18?
      x-amz-lex-session-attributes:e30=
      x-amz-lex-slot-to-elicit:PickupTime
      x-amz-lex-slots:eyJQaWNrdXBUaW1lIjpudWxsLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
      x-amzn-RequestId:3a205b70-0b69-11e7-b447-eb69face3e6f
      ```

      标头值提供以下信息：
      + `x-amz-lex-slots` – 槽和值的 base64 编码版本：

        ```
        {"PickupTime":null,"FlowerType":"roses","PickupDate":"2017-03-18"}
        ```
      + `x-amz-lex-session-attributes` – 会话属性 (\$1\$1) 的 base64 编码版本

      客户端将播放响应正文中的音频。

1. 用户说：下午 6 点

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostContent](API_runtime_PostContent.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
      x-amz-lex-session-attributes: "e30="
      Content-Type: "text/plain; charset=utf-8"
      Accept: "audio/mpeg"
      
      
      Request body
      input stream ("6 pm")
      ```

      请求正文是用户输入音频流 (“下午 6 点”)。`sessionAttributes` 将保留为空。

   1. Amazon Lex 将解释当前意图的上下文中的输入流（它会记住它已经向此用户询问了关于 `PickupTime` 插槽的信息）。它将首先更新当前目的的槽值。

      现在，Amazon Lex 将检测到它拥有所有插槽的信息。但是，`OrderFlowers` 目的配置了确认消息。因此，Amazon Lex 需要先获得用户的显式确认，然后才能继续履行意图。在订花之前，它将发送具有以下请求确认的标头的响应：

      ```
      x-amz-lex-dialog-state:ConfirmIntent
      x-amz-lex-input-transcript:six p. m.
      x-amz-lex-intent-name:OrderFlowers
      x-amz-lex-message:Okay, your roses will be ready for pickup by 18:00 on 2017-03-18.  Does this sound okay?
      x-amz-lex-session-attributes:e30=
      x-amz-lex-slots:eyJQaWNrdXBUaW1lIjoiMTg6MDAiLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
      x-amzn-RequestId:083ca360-0b6a-11e7-b447-eb69face3e6f
      ```

      标头值提供以下信息：
      + `x-amz-lex-slots` – 槽和值的 base64 编码版本：

        ```
        {"PickupTime":"18:00","FlowerType":"roses","PickupDate":"2017-03-18"}
        ```
      + `x-amz-lex-session-attributes` – 会话属性 (\$1\$1) 的 base64 编码版本

      客户端将播放响应正文中的音频。

1. 用户回答“是”

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostContent](API_runtime_PostContent.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/content HTTP/1.1
      x-amz-lex-session-attributes: "e30="
      Content-Type: "audio/x-l16; sample-rate=16000; channel-count=1"
      Accept: "audio/mpeg"
      
      
      Request body
      input stream ("Yes")
      ```

      请求正文是用户输入音频流 (“是”)。`sessionAttributes` 将保留为空。

   1. Amazon Lex 将解释输入流，并了解用户希望继续完成订单。`OrderFlowers` 目的配置有 `ReturnIntent` 作为完成活动。这将指示 Amazon Lex 向客户端返回所有意图数据。Amazon Lex 将返回带有以下内容的响应: 

      

      ```
      x-amz-lex-dialog-state:ReadyForFulfillment
      x-amz-lex-input-transcript:yes
      x-amz-lex-intent-name:OrderFlowers
      x-amz-lex-session-attributes:e30=
      x-amz-lex-slots:eyJQaWNrdXBUaW1lIjoiMTg6MDAiLCJGbG93ZXJUeXBlIjoicm9zaSdzIiwiUGlja3VwRGF0ZSI6IjIwMTctMDMtMTgifQ==
      ```

      `x-amz-lex-dialog-state` 响应标头设置为 `ReadyForFulfillment`。然后，客户端可以完成目的。

1. 现在，重新测试自动程序。要建立新的 (用户) 上下文，请在控制台中选择 **Clear** 链接。为 `OrderFlowers` 目的提供数据，包括一些无效数据。例如：
   + “茉莉花”作为鲜花类型 (它不是一种受支持的鲜花类型)
   + “昨天”作为您想要取花的日期

   请注意，自动程序将接受这些值，因为您没有任何代码来初始化和验证用户数据。在下一节中，您将添加 Lambda 函数来完成此操作。请注意有关 Lambda 函数的以下内容：
   + 它将在每个用户输入后验证槽数据。它将在结束时完成目的。即自动程序将处理鲜花订单，然后向用户返回一条消息，而不是只向客户端返回槽数据。有关更多信息，请参阅 [使用 Lambda 函数](using-lambda.md)。
   + 此外，它还将设置会话属性。有关会话属性的更多信息，请参阅 [PostText](API_runtime_PostText.md)。

      完成“入门”部分后，您可以做其他练习 ([其他示例：创建 Amazon Lex 机器人](additional-exercises.md))。[预订旅程](ex-book-trip.md) 使用会话属性来共享各个目的的信息，以与用户进行动态对话。

**下一个步骤**  
[步骤 3：创建 Lambda 函数（控制台）](gs-bp-create-lambda-function.md)

# 步骤 2b (可选)：查看所键入信息流的详细信息 (控制台)
<a name="gs-bp-details-part1"></a>

本部分介绍了客户端和 Amazon Lex (客户端在其中使用 `PostText` API 来发送请求) 之间的信息流。有关更多信息，请参阅 [PostText](API_runtime_PostText.md)。

1. 用户类型：我想要订些花

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "I would like to order some flowers",
          "sessionAttributes": {}
      }
      ```

      请求 URI 和正文都将向 Amazon Lex 提供信息：
      + 请求 URI — 提供机器人名称 (`OrderFlowers`)、机器人别名 (`$LATEST`) 和用户名称（用于标识用户的随机字符串）。后面的 `text` 表示它是一个 `PostText` API 请求 (而不是 `PostContent`)。

         
      + 请求正文 – 包括用户输入 (`inputText`) 和空 `sessionAttributes`。在客户端发出第一个请求时，没有会话属性。稍后，Lambda 函数会启动这些属性。

   1. 在 `inputText` 中，Amazon Lex 可检测意图 (`OrderFlowers`)。此意图没有任何代码挂钩（即 Lambda 函数）用于初始化和验证用户输入或履行。

      Amazon Lex 将选择其中一个意图插槽 (`FlowerType`) 来引发值。此外，它还会选择槽的其中一个值引出提示 (目的配置的所有部分)，然后将以下响应发送回客户端。控制台向用户显示响应中的消息。  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-10.png)

      客户端将显示响应中的消息。

1. 用户类型：玫瑰

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "roses",
          "sessionAttributes": {}
      }
      ```

      请求正文中的 `inputText` 将提供用户输入。`sessionAttributes` 将保留为空。

   1. Amazon Lex 首先解读当前意图的上下文中的 `inputText`（服务记得它已经向特定用户询问了关于 `FlowerType` 插槽的信息）。Amazon Lex 首先更新当前意图的插槽值，然后选择另一个插槽 (`PickupDate`) 以及该插槽 `` 的其中一个提示消息（“您想在哪天取玫瑰？”）。

      然后，Amazon Lex 将返回以下响应：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-20.png)

      客户端将显示响应中的消息。

1. 用户类型：明天

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "tomorrow",
          "sessionAttributes": {}
      }
      ```

      请求正文中的 `inputText` 将提供用户输入。`sessionAttributes` 将保留为空。

   1. Amazon Lex 首先解读当前意图的上下文中的 `inputText`（服务记得它已经向特定用户询问了关于 `PickupDate` 插槽的信息）。Amazon Lex 将更新当前意图的插槽 (`PickupDate`) 值。它将选择另一个槽来引出 (`PickupTime`) 的值。它``向客户端返回其中一个值引发提示（在 2017 年 1 月 5 日的什么时间交付玫瑰？）。

      Amazon Lex 将返回以下响应：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-30.png)

      客户端将显示响应中的消息。

1. 用户类型：下午 6 点

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "6 pm",
          "sessionAttributes": {}
      }
      ```

      请求正文中的 `inputText` 将提供用户输入。`sessionAttributes` 将保留为空。

   1. Amazon Lex 首先解读当前意图的上下文中的 `inputText`（服务记得它已经向特定用户询问了关于 `PickupTime` 插槽的信息）。Amazon Lex 将首先更新当前意图的插槽值。现在，Amazon Lex 将检测到它拥有所有插槽的信息。

      `OrderFlowers` 目的配置了确认消息。因此，Amazon Lex 需要先获得用户的显式确认，然后才能继续履行意图。在订花之前，Amazon Lex 将向请求确认的客户端发送以下消息：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-40.png)

      客户端将显示响应中的消息。

1. 用户类型：是

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/4o9wwdhx6nlheferh6a73fujd3118f5w/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "Yes",
          "sessionAttributes": {}
      }
      ```

      请求正文中的 `inputText` 将提供用户输入。`sessionAttributes` 将保留为空。

   1. Amazon Lex 将解释确认当前意图的上下文中的 `inputText`。它将了解用户希望继续完成订单。`OrderFlowers` 意图配置有 `ReturnIntent` 作为履行活动（没有 Lambda 函数用来履行意图）。因此，Amazon Lex 向客户端返回插槽数据。  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-50.png)

      Amazon Lex 将 `dialogState` 设置为 `ReadyForFulfillment`。然后，客户端可以完成目的。

1. 现在，再次测试自动程序。为此，您必须在控制台中选择 **Clear** 链接以建立新的 (用户) 上下文。现在，在您提供订花目的的数据时，请尝试提供无效数据。例如：
   + “茉莉花”作为鲜花类型 (它不是一种受支持的鲜花类型)。
   + “昨天”作为您想要取花的日期。

   请注意，机器人之所以接受这些值，是因为您没有任何 initialize/validate 用户数据代码。在下一节中，您将添加 Lambda 函数来完成此操作。请注意有关 Lambda 函数的以下内容：
   + Lambda 函数将在每个用户输入后验证插槽数据。它将在结束时完成目的。即自动程序将处理鲜花订单，然后向用户返回一条消息，而不是只向客户端返回槽数据。有关更多信息，请参阅 [使用 Lambda 函数](using-lambda.md)。
   + Lambda 函数还将设置会话属性。有关会话属性的更多信息，请参阅 [PostText](API_runtime_PostText.md)。

      完成“入门”部分后，您可以做其他练习 ([其他示例：创建 Amazon Lex 机器人](additional-exercises.md))。[预订旅程](ex-book-trip.md) 使用会话属性来共享各个目的的信息，以与用户进行动态对话。

**下一个步骤**  
[步骤 3：创建 Lambda 函数（控制台）](gs-bp-create-lambda-function.md)

# 步骤 3：创建 Lambda 函数（控制台）
<a name="gs-bp-create-lambda-function"></a>

创建 Lambda 函数（使用**lex-order-flowers-python**蓝图），并使用控制台中的示例事件数据执行测试调用。 AWS Lambda 

您返回 Amazon Lex 控制台，然后添加 Lambda 函数作为代码挂钩以履行 `OrderFlowers` 意图（在上一节中创建的 `OrderFlowersBot` 中）。

**创建 Lambda 函数 (控制台)**

1. 登录 AWS 管理控制台 并打开 AWS Lambda 控制台，网址为[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)。

1. 选择**创建函数**。

1. 在 **Create function**（创建函数）页面中，选择 **Use a blueprint**（使用蓝图）。在筛选条件文本框中键入 **lex-** 然后按 `Enter` 查找蓝图，选择 `lex-order-flowers-python` 蓝图。

   Node.js 和 Python 中均提供 Lambda 函数蓝图。对于此练习，请使用基于 Python 的蓝图。

1. 在 **Basic information (基本信息)** 页面上，执行以下操作：
   + 键入 Lambda 函数名称 (`OrderFlowersCodeHook`)。
   + 对于执行角色，选择**创建具有基本 Lambda 权限的新角色**。
   + 保留其他默认值。

1. 选择**创建函数**。

1. 如果您使用的是英语 (美国) (en-US) 以外的区域设置，请按照[更新特定区域设置的蓝图](lex-lambda-blueprints.md#blueprint-update-locale)中所述更新意图名称。

1. 测试 Lambda 函数

   1. 选择 **Select a test events (选择测试事件)**、**Configure test event (配置测试事件)**。

   1. 从 **Event template (事件模板)** 列表中选择 **Amazon Lex Order Flowers**。此示例事件与 Amazon Lex request/response 模型相匹配（参见[使用 Lambda 函数](using-lambda.md)）。为测试事件提供一个名称 (`LexOrderFlowersTest`)。

   1. 选择**创建**。

   1. 选择 **Test (测试)** 以测试代码挂钩。

   1. 验证 Lambda 函数已成功执行。在此情况下，此响应与 Amazon Lex 响应模型相匹配。

**下一个步骤**  
[步骤 4：将 Lambda 函数添加为代码挂钩（控制台）](gs-bp-create-integrate.md)

# 步骤 4：将 Lambda 函数添加为代码挂钩（控制台）
<a name="gs-bp-create-integrate"></a>

在本节中，您将按如下方式更新使用 Lambda 函数的 OrderFlowers意图的配置：
+ 首先使用 Lambda 函数作为代码挂钩以履行 `OrderFlowers` 意图。您将测试机器人并验证您收到了来自 Lambda 函数的履行消息。Amazon Lex 仅在您提供订花所需的所有插槽的数据后才会调用 Lambda 函数。
+ 配置同一 Lambda 函数作为代码挂钩以执行初始化和验证。您将测试和验证 Lambda 函数是否会执行验证（当您提供插槽数据时）。

**将 Lambda 函数添加为代码挂钩（控制台）**

1. 在 Amazon Lex 控制台中，选择该**OrderFlowers**机器人。控制台显示**OrderFlowers**意图。确保目的版本设置为 `$LATEST`，因为这是我们可以修改的唯一版本。

1. 添加 Lambda 函数作为履行代码挂钩并对其进行测试。

   

   1. 在编辑器中，为**履行**选择 **AWS Lambda 函数**，然后选择上一步骤中创建的 Lambda 函数 (`OrderFlowersCodeHook`)。选择**确定**以授予 Amazon Lex 调用 Lambda 函数的权限。

      您正在配置此 Lambda 函数作为代码挂钩以履行意图。Amazon Lex 仅在具有用户提供的用于履行意图的所有必需的插槽数据后，才会调用此函数。

   1. 指定 **Goodbye message**。

   1. 选择**构建**。

   1. 使用之前的对话测试此自动程序。

   最后一个语句“谢谢，您订购的玫瑰.....”是配置为代码挂钩的 Lambda 函数的响应。在上一节，没有 Lambda 函数。现在，使用 Lambda 函数实际履行 `OrderFlowers` 意图。

1. 添加 Lambda 函数作为初始化和验证代码挂钩，然后进行测试。

   您使用的示例 Lambda 函数代码可同时执行用户输入验证和履行。Lambda 函数接收的输入事件有一个字段 (`invocationSource`)，代码使用该字段来确定要执行的代码的部分。有关更多信息，请参阅 [Lambda 函数输入事件和响应格式](lambda-input-response-format.md)。

   1. 选择 `OrderFlowers` 目的的 \$1LATEST 版本。这是您可更新的唯一版本。

   1. 在编辑器中，选择 **Options** 中的 **Initialization and validation**。

   1. 同样，选择同一 Lambda 函数。

   1. 选择**构建**。

   1. 测试自动程序。

      您现在已准备与 Amazon Lex 进行对话，如下图所示。要测试验证部分，请选择下午 6 点这个时间，然后您的 Lambda 函数会返回一个响应（“我们的营业时间是上午 10 点到下午 5 点。”），并再次向您发出提示。在您提供所有有效的插槽数据后，Lambda 函数会履行此订单。  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/OrderFlowers-FullLambda.png)

**下一个步骤**  
[步骤 5 (可选)：查看信息流的详细信息 (控制台)](gs-bp-details-after-lambda.md)

# 步骤 5 (可选)：查看信息流的详细信息 (控制台)
<a name="gs-bp-details-after-lambda"></a>

本节介绍每个用户输入的客户端与 Amazon Lex 之间的信息流，包括 Lambda 函数的集成。

**注意**  
本节假定客户端使用 `PostText` 运行时 API 向 Amazon Lex 发送请求，并显示相应的请求和响应详细信息。有关客户端和 Amazon Lex（客户端在其中使用 `PostContent` API）之间的信息流示例，请参阅[步骤 2a (可选)：查看语音信息流的详细信息 (控制台)](gs-bp-details-postcontent-flow.md)。

如需关于 `PostText` 运行时 API 的更多信息以及关于以下步骤中所示的请求和响应的更多详情，请参阅 [PostText](API_runtime_PostText.md)。

1. 用户：我想要订些花。

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "I would like to order some flowers",
          "sessionAttributes": {}
      }
      ```

      请求 URI 和正文都将向 Amazon Lex 提供信息：
      + 请求 URI — 提供机器人名称 (`OrderFlowers`)、机器人别名 (`$LATEST`) 和用户名称（用于标识用户的随机字符串）。后面的 `text` 表示它是一个 `PostText` API 请求 (而不是 `PostContent`)。
      + 请求正文 – 包括用户输入 (`inputText`) 和空 `sessionAttributes`。在客户端发出第一个请求时，没有会话属性。稍后，Lambda 函数会启动这些属性。

   1. 在 `inputText` 中，Amazon Lex 可检测意图 (`OrderFlowers`)。此意图配置有 Lambda 函数作为代码挂钩，以用于用户数据初始化和验证。因此，Amazon Lex 将通过传递以下信息作为事件数据来调用该 Lambda 函数：

      ```
      {
          "messageVersion": "1.0",
          "invocationSource": "DialogCodeHook",
          "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
          "sessionAttributes": {},
          "bot": {
              "name": "OrderFlowers",
              "alias": null,
              "version": "$LATEST"
          },
          "outputDialogMode": "Text",
          "currentIntent": {
              "name": "OrderFlowers",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": null,
                  "PickupDate": null
              },
              "confirmationStatus": "None"
          }
      }
      ```

      有关更多信息，请参阅 [输入事件格式](lambda-input-response-format.md#using-lambda-input-event-format)。

      除了客户端发送的信息以外，Amazon Lex 还包含以下额外数据：
      + `messageVersion` — Amazon Lex 当前只支持 1.0 版。
      + `invocationSource` — 表明 Lambda 函数调用的目的。在本例中，它将执行用户数据初始化和验证。此时，Amazon Lex 知道用户没有提供所有插槽数据以履行意图。
      + 将所有槽值设置为空值的 `currentIntent` 信息。

   1. 此时，所有槽值均为空值。Lambda 函数没有任何内容需要验证。Lambda 函数会向 Amazon Lex 返回以下响应：

      ```
      {
          "sessionAttributes": {},
          "dialogAction": {
              "type": "Delegate",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": null,
                  "PickupDate": null
              }
          }
      }
      ```

      有关响应格式的信息，请参阅 [响应格式](lambda-input-response-format.md#using-lambda-response-format)。

      注意以下几点：
      + `dialogAction.type` — 通过将此值设置为 `Delegate`，Lambda 函数会将决定下一个操作的责任委派给 Amazon Lex。
**注意**  
如果 Lambda 函数在用户数据验证中检测到任何内容，它会指示 Amazon Lex 下一步操作，如接下来的几个步骤所示。

   1. 根据 `dialogAction.type`，Amazon Lex 将决定下一步操作。由于没有一个槽得到填充，它将决定引出 `FlowerType` 槽的值。它将选择此槽的其中一个值引出提示（“您想要订哪种类型的花？”），并将以下响应发送回客户端：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-10.png)

      客户端将显示响应中的消息。

1. 用户：玫瑰

   1. 客户端将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "roses",
          "sessionAttributes": {}
      }
      ```

      在请求正文中，`inputText` 将提供用户输入。`sessionAttributes` 将保留为空。

   1. Amazon Lex 解读当前意图的上下文中的 `inputText`。服务会记住它已经向特定用户询问了关于 `FlowerType` 槽的信息。它将更新当前意图中的插槽值，并调用具有以下事件数据的 Lambda 函数：

      ```
      {
          "messageVersion": "1.0",
          "invocationSource": "DialogCodeHook",
          "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
          "sessionAttributes": {},
          "bot": {
              "name": "OrderFlowers",
              "alias": null,
              "version": "$LATEST"
          },
          "outputDialogMode": "Text",
          "currentIntent": {
              "name": "OrderFlowers",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": "roses",
                  "PickupDate": null
              },
              "confirmationStatus": "None"
          }
      }
      ```

      注意以下几点：
      + `invocationSource` – 继续为 `DialogCodeHook` (我们只验证用户数据)。
      + `currentIntent.slots` — Amazon Lex 已将 `FlowerType` 插槽更新为“玫瑰”。

   1. 根据 `DialogCodeHook` 的 `invocationSource` 值，Lambda 函数会执行用户数据验证。它会将 `roses` 识别为有效的插槽值（并将 `Price` 设置为会话属性），然后向 Amazon Lex 返回以下响应。

      ```
      {
          "sessionAttributes": {
              "Price": 25
          },
          "dialogAction": {
              "type": "Delegate",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": "roses",
                  "PickupDate": null
              }
          }
      }
      ```

      注意以下几点：
      + `sessionAttributes` — Lambda 函数已经将（玫瑰的）`Price` 添加为会话属性。
      + `dialogAction.type` – 设置为 `Delegate`。用户数据是有效的，因此 Lambda 函数会指示 Amazon Lex 选择下一步操作。

       

   1. 根据 `dialogAction.type`，Amazon Lex 选择下一步操作。Amazon Lex 知道它需要更多插槽数据，因此它将根据意图配置选择下一个具有最高优先级的未填充插槽 (`PickupDate`)。Amazon Lex 会根据意图配置，针对这个插槽选择一个值引发提示消息（“您想要在哪天收到玫瑰？”），然后向客户端发送回以下响应：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-20.png)

      客户端在响应中显示消息 –“What day do you want the roses to be picked up?”。

1. 用户：明天

   1. 客户端将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "tomorrow",
          "sessionAttributes": {
              "Price": "25"
          }
      }
      ```

      在请求正文中，`inputText` 将提供用户输入，然后客户端会将会话属性传递回服务。

   1. Amazon Lex 会记住上下文（它正引发 `PickupDate` 插槽的数据）。在这个上下文中，它知道 `inputText` 值用于 `PickupDate` 槽。然后，Amazon Lex 将通过发送以下事件调用 Lambda 函数：

      ```
      {
          "messageVersion": "1.0",
          "invocationSource": "DialogCodeHook",
          "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
          "sessionAttributes": {
              "Price": "25"
          },
          "bot": {
              "name": "OrderFlowersCustomWithRespCard",
              "alias": null,
              "version": "$LATEST"
          },
          "outputDialogMode": "Text",
          "currentIntent": {
              "name": "OrderFlowers",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": "roses",
                  "PickupDate": "2017-01-05"
              },
              "confirmationStatus": "None"
          }
      }
      ```

      Amazon Lex 已经通过设置 `PickupDate` 值更新了 `currentIntent.slots`。另请注意，该服务会将 `sessionAttributes` 传递到 Lambda 函数。

   1. 根据 `DialogCodeHook` 的 `invocationSource` 值，Lambda 函数将执行用户数据验证。它会将 `PickupDate` 插槽值识别为有效值，并向 Amazon Lex 返回以下响应：

      ```
      {
          "sessionAttributes": {
              "Price": 25
          },
          "dialogAction": {
              "type": "Delegate",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": "roses",
                  "PickupDate": "2017-01-05"
              }
          }
      }
      ```

      注意以下几点：
      + `sessionAttributes` – 无更改。
      + `dialogAction.type` – 设置为 `Delegate`。用户数据是有效的，因此 Lambda 函数会指示 Amazon Lex 选择下一步操作。

   1. 根据 `dialogAction.type`，Amazon Lex 选择下一步操作。Amazon Lex 知道它需要更多插槽数据，因此它将根据意图配置选择下一个具有最高优先级的未填充插槽 (`PickupTime`)。Amazon Lex 会根据意图配置，针对这个插槽选择一项提示消息（“在 2017 年 1 月 5 日的什么时间配送玫瑰？”），并将以下响应发送回客户端：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-30.png)

      客户端会显示响应中的消息（“在 2017 年 1 月 5 日的什么时间配送玫瑰？”）

1. 用户：下午 4 点

   1. 客户端将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "4 pm",
          "sessionAttributes": {
              "Price": "25"
          }
      }
      ```

      在请求正文中，`inputText` 将提供用户输入。客户端将在请求中传递 `sessionAttributes`。

   1. Amazon Lex 了解上下文。它了解它正在引出 `PickupTime` 槽的数据。在此上下文中，它知道 `inputText` 值用于 `PickupTime` 插槽。然后，Amazon Lex 将通过发送以下事件调用 Lambda 函数：

      ```
      {
          "messageVersion": "1.0",
          "invocationSource": "DialogCodeHook",
          "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
          "sessionAttributes": {
              "Price": "25"
          },
          "bot": {
              "name": "OrderFlowersCustomWithRespCard",
              "alias": null,
              "version": "$LATEST"
          },
          "outputDialogMode": "Text",
          "currentIntent": {
              "name": "OrderFlowers",
              "slots": {
                  "PickupTime": "16:00",
                  "FlowerType": "roses",
                  "PickupDate": "2017-01-05"
              },
              "confirmationStatus": "None"
          }
      }
      ```

      Amazon Lex 已经通过设置 `PickupTime` 值更新了 `currentIntent.slots`。

   1. 根据 `DialogCodeHook` 的 `invocationSource` 值，Lambda 函数会执行用户数据验证。它会将 `PickupDate` 插槽值识别为有效值，并向 Amazon Lex 返回以下响应。

      ```
      {
          "sessionAttributes": {
              "Price": 25
          },
          "dialogAction": {
              "type": "Delegate",
              "slots": {
                  "PickupTime": "16:00",
                  "FlowerType": "roses",
                  "PickupDate": "2017-01-05"
              }
          }
      }
      ```

      注意以下几点：
      + `sessionAttributes` – 会话属性无更改。
      + `dialogAction.type` – 设置为 `Delegate`。用户数据是有效的，因此 Lambda 函数会指示 Amazon Lex 选择下一步操作。

   1. 此时，Amazon Lex 知道它具有所有插槽数据。此目的配置有确认提示。因此，在履行意图之前，Amazon Lex 将向用户发送以下响应来请求确认：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-45.png)

      客户端只显示响应中的消息并等待用户响应。

1. 用户：是

   1. 客户端将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "yes",
          "sessionAttributes": {
              "Price": "25"
          }
      }
      ```

   1. Amazon Lex 将解释确认当前意图的上下文中的 `inputText`。Amazon Lex 了解用户希望继续完成订单。此时，Amazon Lex 将通过发送以下事件来调用 Lambda 函数以履行意图，这会在它发送给 Lambda 函数的事件中将 `invocationSource` 设置为 `FulfillmentCodeHook`。Amazon Lex 也将 `confirmationStatus` 设置为 `Confirmed`。

      ```
      {
          "messageVersion": "1.0",
          "invocationSource": "FulfillmentCodeHook",
          "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
          "sessionAttributes": {
              "Price": "25"
          },
          "bot": {
              "name": "OrderFlowersCustomWithRespCard",
              "alias": null,
              "version": "$LATEST"
          },
          "outputDialogMode": "Text",
          "currentIntent": {
              "name": "OrderFlowers",
              "slots": {
                  "PickupTime": "16:00",
                  "FlowerType": "roses",
                  "PickupDate": "2017-01-05"
              },
              "confirmationStatus": "Confirmed"
          }
      }
      ```

      注意以下几点：
      + `invocationSource` — 此时，Amazon Lex 将此值设置为 `FulfillmentCodeHook`，指示 Lambda 函数履行意图。
      + `confirmationStatus` – 设置为 `Confirmed`。

   1. 此时，Lambda 函数履行 `OrderFlowers` 意图，并返回以下响应：

      ```
      {
          "sessionAttributes": {
              "Price": "25"
          },
          "dialogAction": {
              "type": "Close",
              "fulfillmentState": "Fulfilled",
              "message": {
                  "contentType": "PlainText",
                  "content": "Thanks, your order for roses has been placed and will be ready for pickup by 16:00 on 2017-01-05"
              }
          }
      }
      ```

      注意以下几点：
      + `dialogAction.type` – Lambda 函数将该值设置为 `Close`，指示 Amazon Lex 不要期待用户响应。
      + `dialogAction.fulfillmentState` – 设置为“已完成”，并且包含要传达给用户的适当 `message`。

   1. Amazon Lex 将查看 `fulfillmentState`，并将以下响应发送回客户端。

      然后，Amazon Lex 将向客户端返回以下信息：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-48.png)

      请注意：
      + `dialogState` — Amazon Lex 将此值设置为 `fulfilled`。
      + `message` — 与 Lambda 函数提供的消息相同。

      客户端将显示消息。

1. 现在，再次测试自动程序。要建立新的 (用户) 上下文，请选择测试窗口中的 **Clear** 链接。现在提供 `OrderFlowers` 目的的无效槽数据。此时，Lambda 函数将执行数据验证，将无效的插槽数据值重置为空值，并要求 Amazon Lex 提示用户提供有效数据。例如，请尝试以下操作：
   + “茉莉花”作为鲜花类型 (它不是一种受支持的鲜花类型)。
   + “昨天”作为您想要取花的日期。
   + 下单后，输入另一种鲜花类型，而不是回复“yes”来确认订单。作为响应，Lambda 函数将更新会话属性中的 `Price`，以维护鲜花订单的滚动合计。

   Lambda 函数还将执行履行活动。

**下一个步骤**  
[步骤 6：更新目的配置以添加表达 (控制台)](gs-bp-utterance.md)

# 步骤 6：更新目的配置以添加表达 (控制台)
<a name="gs-bp-utterance"></a>

 `OrderFlowers` 自动程序只配置两个表达。这对 Amazon Lex 提供的信息有限，而它要依赖这些信息来构建能够识别并响应用户意图的机器学习模型。尝试键入“我想订购鲜花”，如下面的测试窗口中所示。Amazon Lex 无法识别该文本，并响应“我不明白，请问您想做什么呢？” 您可以通过添加更多表达来改进机器学习模型。

![\[测试窗口显示无法理解的言语。\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs1-120.png)


您添加的每句话都为 Amazon Lex 提供了更多信息来学习如何响应用户。您无需添加准确的表达，Amazon Lex 会基于您提供的示例形成相应的概念，以识别精确的匹配和类似的输入。

**添加表达 (控制台)**

1. 在意图编辑器的**示例言语**部分中键入言语“我想订购鲜花”，然后单击该新言语旁边的加号图标，将其添加到意图。  
![\[包含新表达的目的编辑器。\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs1-130.png)

1.  将自动程序构建为能够接受更改。选择 **Build**，然后再次选择 **Build**。

1. 测试自动程序，以确认它识别出了新表达。在测试窗口中，如下图所示，键入“我想订购鲜花”。Amazon Lex 会识别出该短语，并提供响应“您想要订购什么花？”。  
![\[目的编辑器识别出新表达。\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs1-140.png)

**下一个步骤**  
[步骤 7 (可选)：清除 (控制台)](gs-bp-cleaning-up.md)

# 步骤 7 (可选)：清除 (控制台)
<a name="gs-bp-cleaning-up"></a>

现在，删除您创建的资源并清除账户。

您只能删除未使用的资源。一般来说，您应该按照以下顺序删除资源：
+ 删除自动程序以释放目的资源。
+ 删除目的以释放槽类型资源。
+ 最后删除槽类型。

**清除账户 (控制台)**

1. 登录 AWS 管理控制台 并打开 Amazon Lex 控制台，网址为[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)。

1. 从机器人列表中，选中旁边的复选框**OrderFlowers**。

1. 要删除自动程序，请选择 **Delete**，然后在确认对话框中选择 **Continue**。

1. 在左侧窗格中，选择 **Intents**。

1. 在目的列表中，选择 **OrderFlowersIntent**。

1. 要删除目的，请选择 **Delete**，然后在确认对话框中选择 **Continue**。

1. 在左侧窗格中，选择 **Slot types**。

1. 在槽类型列表中，选择 **Flowers**。

1. 要删除槽类型，请选择 **Delete**，然后在确认对话框中选择 **Continue**。

您已经删除了创建的 Amazon Lex 所有资源并清理了账户。如果需要，您可以使用 [Lambda 控制台](https://console.aws.amazon.com/lambda)删除本练习中使用的 Lambda 函数。