支援終止通知：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 函數新增為程式碼掛勾，以滿足意圖。測試端對端的體驗。

以下各節說明藍圖的作用。

## Amazon Lex Bot：藍圖概觀
<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 將在 \$1PickupDate\$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 管理主控台 ，並在 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)：// 開啟 Amazon Lex 主控台。

1. 如果這是您第一個機器人，請選擇 **Get Started (開始)**，否則在**機器人**頁面，選擇**建立**。

1. 在**建立您的機器人**頁面上提供以下資訊，然後選擇**建立**。
   + 選擇 **OrderFlowers** 藍圖。
   + 保留預設機器人名稱 (OrderFlowers)。
   + 對於 **COPPA (COPPA)**，選擇**No**。
   + 對於**使用者表達用語儲存**，請選擇適當的回應。

1. 選擇**建立**。主控台向 Amazon Lex 提出儲存組態所需的請求。而後，主控台將顯示機器人編輯器視窗。

1. 等待機器人已建置的確認。

1. 測試機器人。
**注意**  
透過在測試視窗中輸入文字即可測試機器人，或者對於相容的瀏覽器，可由測試視窗中選擇麥克風按鈕並說話。

   使用以下範例文字與機器人進行對話來訂花：  
![\[\]](http://docs.aws.amazon.com/zh_tw/lex/latest/dg/images/OrderFlowers-NoLambda.png)

   機器人憑藉輸入的內容推斷 `OrderFlowers` 意圖並提示提供槽資料。在您提供所有必要的槽資料後，機器人會將所有資訊傳回用戶端應用程式 (本例中即主控台) 以實現意圖 (`OrderFlowers`)。主控台在測試視窗中顯示這類資訊。

   具體而言：
   + 陳述式「What day do you want the roses to be picked up?」中出現了「roses」一詞，是因為 `pickupDate` 槽的提示已使用替換項 `{FlowerType}` 進行設定。從主控台可確認此項。
   + 陳述式「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 管理主控台 ，並在 [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)：// 開啟 Amazon 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. 用戶端 (主控台) 傳送以下 [PostContent](API_runtime_PostContent.md) 請求給 Amazon Lex：

      ```
      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` – base64 編碼版本的工作階段屬性 (\$1\$1)

      用戶端播放回應內文中的音訊。

1. 使用者說：玫瑰

   1. 用戶端 (主控台) 傳送以下 [PostContent](API_runtime_PostContent.md) 請求給 Amazon Lex：

      ```
      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`) 以及該槽的其中一則提示訊息 (您想要在什麼時間拿取玫瑰？)，並傳回具有以下標頭的回應：

      ```
      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` – base64 編碼版本的工作階段屬性 (\$1\$1)

      用戶端播放回應內文中的音訊。

1. 使用者說：明天

   1. 用戶端 (主控台) 傳送以下 [PostContent](API_runtime_PostContent.md) 請求給 Amazon Lex：

      ```
      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` – base64 編碼版本的工作階段屬性 (\$1\$1)

      用戶端播放回應內文中的音訊。

1. 使用者說：下午 6 點

   1. 用戶端 (主控台) 傳送以下 [PostContent](API_runtime_PostContent.md) 請求給 Amazon Lex：

      ```
      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` – base64 編碼版本的工作階段屬性 (\$1\$1)

      用戶端播放回應內文中的音訊。

1. 使用者說：好

   1. 用戶端 (主控台) 傳送以下 [PostContent](API_runtime_PostContent.md) 請求給 Amazon Lex：

      ```
      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. 用戶端 (主控台) 傳送以下 [PostText](API_runtime_PostText.md) 請求給 Amazon Lex：

      ```
      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_tw/lex/latest/dg/images/gs-1-details-10.png)

      用戶端顯示回應中的訊息。

1. 使用者輸入：玫瑰

   1. 用戶端 (主控台) 傳送以下 [PostText](API_runtime_PostText.md) 請求給 Amazon Lex：

      ```
      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_tw/lex/latest/dg/images/gs-1-details-20.png)

      用戶端顯示回應中的訊息。

1. 使用者輸入：明天

   1. 用戶端 (主控台) 傳送以下 [PostText](API_runtime_PostText.md) 請求給 Amazon Lex：

      ```
      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-01-05 的什麼時間交付玫瑰？ - ``給用戶端。

      然後，Amazon Lex 會傳回下列回應：  
![\[\]](http://docs.aws.amazon.com/zh_tw/lex/latest/dg/images/gs-1-details-30.png)

      用戶端顯示回應中的訊息。

1. 使用者輸入：下午 6 點

   1. 用戶端 (主控台) 傳送以下 [PostText](API_runtime_PostText.md) 請求給 Amazon Lex：

      ```
      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_tw/lex/latest/dg/images/gs-1-details-40.png)

      用戶端顯示回應中的訊息。

1. 使用者輸入：好

   1. 用戶端 (主控台) 傳送以下 [PostText](API_runtime_PostText.md) 請求給 Amazon Lex：

      ```
      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_tw/lex/latest/dg/images/gs-1-details-50.png)

      Amazon Lex 將 `dialogState` 設定為 `ReadyForFulfillment`。隨後用戶端即可實現意圖。

1. 現在，再次測試機器人。為此，您必須由主控台選擇 **Clear (清除)** 連結以建立新的 (使用者) 內容。接著為訂花意圖提供資料，請嘗試提供無效的資料。例如：
   + 花種為「茉莉」(此花種不受支援)，
   + 想要取花的日期為「昨天」。

   請注意，機器人會接受這些值，因為您沒有任何程式碼來初始化/驗證使用者資料。在下一節中，您可以新增 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 函數新增為程式碼掛勾，以滿足`OrderFlowersBot`您在上一節建立的 中的`OrderFlowers`意圖。

**建立 Lambda 函數 (主控台)**

1. 登入 AWS 管理主控台 並在 https：//[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 開啟 AWS Lambda 主控台。

1. 選擇**建立函數**。

1. 在 **Create function (建立函數)** 頁面上，選擇 **Use a blueprint (使用藍圖)**。在篩選條件的文字方塊中輸入 **lex-** 然後按 `Enter` 以尋找藍圖，然後選擇 `lex-order-flowers-python` 藍圖。

   Lambda 函數藍圖在 Node.js 和 Python 中提供。本練習將使用 Python 提供的藍圖。

1. 在 **Basic information (基本資訊)** 頁面上，執行以下作業。
   + 輸入 Lambda 函數名稱 (`OrderFlowersCodeHook`)。
   + 針對執行角色，選擇**使用基本 Lambda 許可建立新角色**。
   + 保留其他預設值。

1. 選擇**建立函數**。

1. 如果您使用的地區設定不是英文 (US) (en-US)，請更新意圖名稱，如中所述[更新特定地區設定的藍圖](lex-lambda-blueprints.md#blueprint-update-locale)。

1. 測試 Lambda 函數。

   1. 選擇 **Select a test event (選取測試事件)**、**Configure test events (設定測試事件)**。

   1. 從 **Event template (事件範本)** 清單中選擇 **Amazon Lex Order Flowers**。此範例事件符合 Amazon Lex 請求/回應模型 （請參閱 [使用 Lambda 函數](using-lambda.md))。為測試事件命名 (`LexOrderFlowersTest`)。

   1. 選擇**建立**。

   1. 選擇 **Test (測試)** 來測試程式碼掛勾。

   1. 確認 Lambda 函數已成功執行。在此情況下，回應符合 Amazon Lex 回應模型。

**後續步驟**  
[步驟 4：將 Lambda 函數新增為 Code Hook （主控台）](gs-bp-create-integrate.md)

# 步驟 4：將 Lambda 函數新增為 Code Hook （主控台）
<a name="gs-bp-create-integrate"></a>

在本節中，您將更新 OrderFlowers 意圖使用 Lambda 函數的組態，如下所示：
+ 首先，使用 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. 選擇 **Build** (建置)。

   1. 使用之前的對話測試機器人。

   最後一個陳述式 "Thanks， your order for roses....." 是來自您設定為程式碼掛勾之 Lambda 函數的回應。在上一節中，沒有 Lambda 函數。現在您使用 Lambda 函數來實際實現`OrderFlowers`意圖。

1. 新增 Lambda 函數做為初始化和驗證程式碼掛鉤，並測試。

   您使用的範例 Lambda 函數程式碼可以執行使用者輸入驗證和履行。Lambda 函數接收的輸入事件具有欄位 (`invocationSource`)，程式碼會使用此欄位來決定要執行的程式碼部分。如需詳細資訊，請參閱[Lambda 函數輸入事件和回應格式](lambda-input-response-format.md)。

   1. 選取 \$1LATEST 版本的 `OrderFlowers` 意圖。這是唯一能夠更新的版本。

   1. 從編輯器的 **Options (選項)**中選擇 **Initialization and validation (初始化和驗證)**。

   1. 同樣地，選取相同的 Lambda 函數。

   1. 選擇 **Build** (建置)。

   1. 測試機器人。

      您現在可以與 Amazon Lex 交談，如下圖所示。若要測試驗證部分，請選擇時間下午 6 點，您的 Lambda 函數會傳回回應 (「我們的營業時間是上午 10 點到下午 5 點」)，並再次提示您。在您提供所有有效的槽資料後，Lambda 函數會履行順序。  
![\[\]](http://docs.aws.amazon.com/zh_tw/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，並相應地顯示請求和回應詳細資訊。如需用戶端與用戶端使用 `PostContent` API 的 Amazon Lex 之間資訊流程的範例，請參閱 [步驟 2a (選用)：檢閱口語化資訊流程的詳細資訊 (主控台)](gs-bp-details-postcontent-flow.md)。

如需 `PostText` 執行時間 API 的詳細資訊及關於以下步驟所示的請求與回應的更多細節，請參閱 [PostText](API_runtime_PostText.md)。

1. 使用者：我想要訂花。

   1. 用戶端 (主控台) 傳送以下 [PostText](API_runtime_PostText.md) 請求給 Amazon Lex：

      ```
      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` 資訊 – 所有槽值均設定為 null。

   1. 此時，所有槽值都是 null。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_tw/lex/latest/dg/images/gs-1-details-10.png)

      用戶端顯示回應中的訊息。

1. 使用者：玫瑰

   1. 用戶端會將下列[PostText](API_runtime_PostText.md)請求傳送至 Amazon Lex：

      ```
      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. 根據 `invocationSource`的值`DialogCodeHook`，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_tw/lex/latest/dg/images/gs-1-details-20.png)

      用戶端將顯示回應中的訊息 –「您想要在哪一天拿取玫瑰？」

1. 使用者：明天

   1. 用戶端會將下列[PostText](API_runtime_PostText.md)請求傳送至 Amazon Lex：

      ```
      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. 根據 `invocationSource`的值`DialogCodeHook`，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-01-05 的什麼時間交付玫瑰？」)，並將下列回應傳回給用戶端：  
![\[\]](http://docs.aws.amazon.com/zh_tw/lex/latest/dg/images/gs-1-details-30.png)

      用戶端會在回應中顯示訊息 –「在 2017-01-05 的什麼時間交付玫瑰？」

1. 使用者：下午 4 點

   1. 用戶端會將下列[PostText](API_runtime_PostText.md)請求傳送至 Amazon Lex：

      ```
      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. 根據 `invocationSource`的值`DialogCodeHook`，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_tw/lex/latest/dg/images/gs-1-details-45.png)

      用戶端將顯示回應中的訊息並等待使用者回應。

1. 使用者：好

   1. 用戶端會將下列[PostText](API_runtime_PostText.md)請求傳送至 Amazon Lex：

      ```
      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` – 設定為 Fulfilled 且附上相應的 `message` 以傳達給使用者。

   1. Amazon Lex 會檢閱 `fulfillmentState`，並將下列回應傳回給用戶端。

      然後，Amazon Lex 會將下列項目傳回給用戶端：  
![\[\]](http://docs.aws.amazon.com/zh_tw/lex/latest/dg/images/gs-1-details-48.png)

      請注意：
      + `dialogState` – Amazon Lex 將此值設定為 `fulfilled`。
      + `message` – 是 Lambda 函數提供的相同訊息。

      用戶端將顯示該訊息。

1. 現在，再次測試機器人。要建立新的 (使用者) 內容，請由測試視窗選擇 **Clear (清除)** 連結。接著為 `OrderFlowers` 意圖提供無效的槽資料。這次 Lambda 函數會執行資料驗證、將無效的槽資料值重設為 null，並要求 Amazon Lex 提示使用者提供有效的資料。例如，嘗試以下操作：
   + 花種為「茉莉」(此花種不受支援)，
   + 想要取花的日期為「昨天」。
   + 下單後再輸入其他花種，而不要回覆「好」確認下單。為了回應，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_tw/lex/latest/dg/images/gs1-120.png)


您新增的每個表達用語都會為 Amazon Lex 提供有關如何回應使用者的詳細資訊。您不需要新增確切的表達用語，Amazon Lex 會從您提供的範例進行一般化，以辨識完全相符和類似的輸入。

**加入表達用語 (主控台)**

1. 將表達用語「我想要花朵」新增至意圖編輯器的範例**表達用語**區段，如下圖所示，然後按一下新表達用語旁的加號圖示。  
![\[意圖編輯器中加入了新表達用語。\]](http://docs.aws.amazon.com/zh_tw/lex/latest/dg/images/gs1-130.png)

1.  建置您的機器人使其接受變更。選擇 **Build (建置)**，然後再次選擇 **Build (建置)**。

1. 測試您的機器人以確認其能夠判別新表達用語。在測試視窗中，如下圖所示，輸入「我想要訂購花朵」。Amazon Lex 會辨識片語，並以「您想要訂購哪種類型的花？」回應。  
![\[意圖編輯器已能夠判別新表達用語。\]](http://docs.aws.amazon.com/zh_tw/lex/latest/dg/images/gs1-140.png)

**後續步驟**  
[步驟 7 (選用)：清理 (主控台)](gs-bp-cleaning-up.md)

# 步驟 7 (選用)：清理 (主控台)
<a name="gs-bp-cleaning-up"></a>

現在，刪除您所建立的資源並清理您的帳戶。

您只能刪除未使用的資源。一般而言，您應該按照以下順序刪除資源：
+ 刪除機器人以釋放意圖資源。
+ 刪除意圖以釋放槽類型資源。
+ 最後刪除槽類型。

**清理您的帳戶 (主控台)**

1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/) 開啟 Amazon Lex 主控台。

1. 從機器人清單中，選擇 **OrderFlowers** 旁的核取方塊。

1. 要刪除機器人，選擇 **Delete (刪除)**，然後從確認對話方塊選擇 **Continue (繼續)。**

1. 從左側窗格選擇 **意圖**。

1. 從意圖清單中選擇 **OrderFlowersIntent**。

1. 要刪除意圖，選擇 **Delete (刪除)**，然後從確認對話方塊選擇 **Continue (繼續)**。

1. 從左側窗格選擇 **Slot types (槽類型)**。

1. 從槽類型清單中選擇 **Flowers**。

1. 要刪除槽類型，選擇 **Delete (刪除)**，然後從確認對話方塊選擇 **Continue (繼續)**。

您已移除您建立並清除帳戶的所有 Amazon Lex 資源。如果需要，您可以使用 [Lambda 主控台](https://console.aws.amazon.com/lambda)來刪除本練習中使用的 Lambda 函數。