History

co-op-translator[bot] 2f4dff5e89 🌐 Update translations via Co-op Translator (#546 ) Co-authored-by: leestott <leestott@users.noreply.github.com>		4 weeks ago
..
README.md	🌐 Update translations via Co-op Translator (#546 )	4 weeks ago
assignment.md	🌐 Update translations via Co-op Translator (#546 )	4 weeks ago

README.md

เข้าใจภาษา

Sketchnote โดย Nitya Narasimhan คลิกที่ภาพเพื่อดูเวอร์ชันขนาดใหญ่ขึ้น

แบบทดสอบก่อนเรียน

บทนำ

ในบทเรียนที่แล้ว คุณได้แปลงคำพูดเป็นข้อความ สำหรับการนำไปใช้ในโปรแกรมจับเวลาอัจฉริยะ โค้ดของคุณจำเป็นต้องเข้าใจสิ่งที่พูดออกมา คุณอาจสมมติว่าผู้ใช้จะพูดประโยคที่กำหนดไว้ เช่น "ตั้งเวลาสามนาที" และแยกวิเคราะห์ประโยคนั้นเพื่อหาว่าควรตั้งเวลานานแค่ไหน แต่สิ่งนี้ไม่ค่อยเป็นมิตรกับผู้ใช้ หากผู้ใช้พูดว่า "ตั้งเวลาสำหรับสามนาที" คุณหรือฉันอาจเข้าใจความหมาย แต่โค้ดของคุณจะไม่เข้าใจ เพราะมันคาดหวังเพียงประโยคที่กำหนดไว้

นี่คือจุดที่การเข้าใจภาษามีบทบาท โดยใช้โมเดล AI เพื่อแปลความหมายของข้อความและดึงรายละเอียดที่จำเป็นออกมา เช่น การเข้าใจทั้ง "ตั้งเวลาสามนาที" และ "ตั้งเวลาสำหรับสามนาที" ว่าหมายถึงการตั้งเวลาสามนาที

ในบทเรียนนี้ คุณจะได้เรียนรู้เกี่ยวกับโมเดลการเข้าใจภาษา วิธีสร้างโมเดล ฝึกฝน และใช้งานจากโค้ดของคุณ

ในบทเรียนนี้เราจะครอบคลุม:

การเข้าใจภาษา

มนุษย์ใช้ภาษาในการสื่อสารมาหลายแสนปี เราสื่อสารด้วยคำพูด เสียง หรือการกระทำ และเข้าใจสิ่งที่พูดออกมา ทั้งความหมายของคำ เสียง หรือการกระทำ รวมถึงบริบทของมัน เราเข้าใจความจริงใจและการเสียดสี ทำให้คำเดียวกันสามารถมีความหมายต่างกันได้ขึ้นอยู่กับน้ำเสียงของเรา

✅ ลองคิดถึงบทสนทนาที่คุณเพิ่งมีเมื่อเร็วๆ นี้ มีส่วนใดของบทสนทนาที่คอมพิวเตอร์จะเข้าใจยากเพราะต้องการบริบทหรือไม่?

การเข้าใจภาษา หรือที่เรียกว่าการเข้าใจภาษาธรรมชาติ เป็นส่วนหนึ่งของสาขาปัญญาประดิษฐ์ที่เรียกว่าการประมวลผลภาษาธรรมชาติ (Natural Language Processing หรือ NLP) และเกี่ยวข้องกับการทำความเข้าใจข้อความ เช่น การอ่านจับใจความ หากคุณเคยใช้ผู้ช่วยเสียง เช่น Alexa หรือ Siri คุณก็เคยใช้บริการการเข้าใจภาษาแล้ว บริการเหล่านี้คือ AI ที่ทำงานเบื้องหลังเพื่อแปลงคำพูด เช่น "Alexa เล่นอัลบั้มล่าสุดของ Taylor Swift" ให้กลายเป็นลูกสาวของฉันที่เต้นในห้องนั่งเล่นกับเพลงโปรดของเธอ

💁 แม้คอมพิวเตอร์จะก้าวหน้ามาก แต่ก็ยังมีหนทางอีกยาวไกลกว่าจะเข้าใจข้อความได้อย่างแท้จริง เมื่อเราพูดถึงการเข้าใจภาษาด้วยคอมพิวเตอร์ เราไม่ได้หมายถึงการสื่อสารที่ซับซ้อนเหมือนมนุษย์ แต่หมายถึงการดึงรายละเอียดสำคัญจากคำพูด

ในฐานะมนุษย์ เราเข้าใจภาษาโดยไม่ต้องคิดมาก หากฉันขอให้มนุษย์อีกคน "เล่นอัลบั้มล่าสุดของ Taylor Swift" พวกเขาจะเข้าใจทันทีว่าฉันหมายถึงอะไร แต่สำหรับคอมพิวเตอร์ นี่เป็นเรื่องยาก มันต้องแปลงคำพูดเป็นข้อความ และแยกวิเคราะห์ข้อมูลดังนี้:

ต้องเล่นเพลง
เพลงนั้นเป็นของศิลปิน Taylor Swift
เพลงที่ต้องการคืออัลบั้มที่มีหลายเพลงเรียงตามลำดับ
Taylor Swift มีหลายอัลบั้ม ดังนั้นต้องเรียงตามลำดับเวลา และเลือกอัลบั้มที่เผยแพร่ล่าสุด

✅ ลองคิดถึงประโยคอื่นๆ ที่คุณพูดเมื่อทำการร้องขอ เช่น การสั่งกาแฟหรือขอให้สมาชิกในครอบครัวส่งของบางอย่างให้คุณ ลองแยกประโยคเหล่านั้นออกเป็นข้อมูลที่คอมพิวเตอร์ต้องดึงออกมาเพื่อเข้าใจประโยค

โมเดลการเข้าใจภาษาเป็นโมเดล AI ที่ถูกฝึกให้ดึงรายละเอียดบางอย่างจากภาษา และถูกฝึกสำหรับงานเฉพาะโดยใช้การเรียนรู้แบบถ่ายโอน (Transfer Learning) เช่นเดียวกับที่คุณฝึกโมเดล Custom Vision ด้วยชุดภาพขนาดเล็ก คุณสามารถนำโมเดลมาแล้วฝึกด้วยข้อความที่คุณต้องการให้เข้าใจ

สร้างโมเดลการเข้าใจภาษา

คุณสามารถสร้างโมเดลการเข้าใจภาษาโดยใช้ LUIS ซึ่งเป็นบริการการเข้าใจภาษาจาก Microsoft ที่เป็นส่วนหนึ่งของ Cognitive Services

งาน - สร้างทรัพยากรการเขียน

ในการใช้ LUIS คุณต้องสร้างทรัพยากรการเขียน

ใช้คำสั่งต่อไปนี้เพื่อสร้างทรัพยากรการเขียนในกลุ่มทรัพยากร smart-timer ของคุณ:
```
az cognitiveservices account create --name smart-timer-luis-authoring \
                                    --resource-group smart-timer \
                                    --kind LUIS.Authoring \
                                    --sku F0 \
                                    --yes \
                                    --location <location>
```
แทนที่ <location> ด้วยตำแหน่งที่คุณใช้เมื่อสร้างกลุ่มทรัพยากร
⚠️ LUIS ไม่สามารถใช้งานได้ในทุกภูมิภาค หากคุณได้รับข้อผิดพลาดดังนี้:
```
InvalidApiSetId: The account type 'LUIS.Authoring' is either invalid or unavailable in given region.
```
ให้เลือกภูมิภาคอื่น
คำสั่งนี้จะสร้างทรัพยากรการเขียน LUIS แบบฟรี

งาน - สร้างแอปการเข้าใจภาษา

เปิดพอร์ทัล LUIS ที่ luis.ai ในเบราว์เซอร์ของคุณ และลงชื่อเข้าใช้ด้วยบัญชีเดียวกับที่คุณใช้สำหรับ Azure
ทำตามคำแนะนำในหน้าต่างเพื่อเลือกการสมัครสมาชิก Azure ของคุณ จากนั้นเลือกทรัพยากร smart-timer-luis-authoring ที่คุณเพิ่งสร้าง
จากรายการ Conversation apps ให้เลือกปุ่ม New app เพื่อสร้างแอปพลิเคชันใหม่ ตั้งชื่อแอปใหม่ว่า smart-timer และตั้งค่า Culture เป็นภาษาของคุณ

💁 มีช่องสำหรับทรัพยากรการพยากรณ์ คุณสามารถสร้างทรัพยากรที่สองสำหรับการพยากรณ์ได้ แต่ทรัพยากรการเขียนแบบฟรีอนุญาตให้ทำการพยากรณ์ได้ 1,000 ครั้งต่อเดือน ซึ่งเพียงพอสำหรับการพัฒนา ดังนั้นคุณสามารถปล่อยช่องนี้ว่างไว้
อ่านคู่มือที่ปรากฏขึ้นเมื่อคุณสร้างแอปเพื่อทำความเข้าใจขั้นตอนที่คุณต้องทำเพื่อฝึกโมเดลการเข้าใจภาษา ปิดคู่มือเมื่อคุณอ่านเสร็จ

เจตนาและเอนทิตี

การเข้าใจภาษาขึ้นอยู่กับ เจตนา และ เอนทิตี เจตนาคือความตั้งใจของคำพูด เช่น การเล่นเพลง การตั้งเวลา หรือการสั่งอาหาร ส่วนเอนทิตีคือสิ่งที่เจตนาอ้างถึง เช่น อัลบั้ม ความยาวของเวลา หรือประเภทของอาหาร ประโยคแต่ละประโยคที่โมเดลแปลความหมายควรมีเจตนาอย่างน้อยหนึ่งอย่าง และอาจมีเอนทิตีหนึ่งหรือมากกว่านั้น

ตัวอย่าง:

ประโยค	เจตนา	เอนทิตี
"เล่นอัลบั้มล่าสุดของ Taylor Swift"	เล่นเพลง	อัลบั้มล่าสุดของ Taylor Swift
"ตั้งเวลาสามนาที"	ตั้งเวลา	สามนาที
"ยกเลิกตัวจับเวลา"	ยกเลิกตัวจับเวลา	ไม่มี
"สั่งพิซซ่าหน้าสับปะรดขนาดใหญ่สามถาดและสลัดซีซาร์"	สั่งอาหาร	พิซซ่าหน้าสับปะรดขนาดใหญ่สามถาด, สลัดซีซาร์

✅ สำหรับประโยคที่คุณคิดไว้ก่อนหน้านี้ เจตนาและเอนทิตีในประโยคนั้นคืออะไร?

ในการฝึก LUIS ขั้นแรกคุณต้องตั้งค่าเอนทิตี เอนทิตีเหล่านี้อาจเป็นรายการคำศัพท์ที่กำหนดไว้ล่วงหน้า หรือเรียนรู้จากข้อความ ตัวอย่างเช่น คุณสามารถให้รายการคำศัพท์ของอาหารในเมนูของคุณ พร้อมคำที่มีความหมายเหมือนกัน (หรือคำพ้องความหมาย) ของแต่ละคำ เช่น มะเขือยาว และ มะเขือม่วง เป็นคำพ้องความหมายของ มะเขือม่วง LUIS ยังมีเอนทิตีที่สร้างไว้ล่วงหน้าที่สามารถใช้งานได้ เช่น ตัวเลขและสถานที่

สำหรับการตั้งเวลา คุณสามารถมีเอนทิตีหนึ่งที่ใช้เอนทิตีตัวเลขที่สร้างไว้ล่วงหน้าสำหรับเวลา และอีกเอนทิตีสำหรับหน่วย เช่น นาทีและวินาที แต่ละหน่วยจะมีหลายรูปแบบเพื่อครอบคลุมรูปแบบเอกพจน์และพหูพจน์ เช่น นาทีและนาทียาว

เมื่อกำหนดเอนทิตีแล้ว คุณจะสร้างเจตนา เจตนาเหล่านี้จะถูกเรียนรู้โดยโมเดลจากประโยคตัวอย่างที่คุณให้ (เรียกว่าการพูด) ตัวอย่างเช่น สำหรับเจตนา ตั้งเวลา คุณอาจให้ประโยคตัวอย่างดังนี้:

ตั้งเวลาหนึ่งวินาที
ตั้งเวลาหนึ่งนาทีสิบสองวินาที
ตั้งเวลาสามนาที
ตั้งเวลาเก้านาทีสามสิบวินาที

จากนั้นคุณจะบอก LUIS ว่าส่วนใดของประโยคเหล่านี้ที่ตรงกับเอนทิตี:

ประโยค ตั้งเวลาหนึ่งนาทีสิบสองวินาที มีเจตนาเป็น ตั้งเวลา และมีเอนทิตี 2 ตัวพร้อมค่าของแต่ละตัว:

	เวลา	หน่วย
1 นาที	1	นาที
12 วินาที	12	วินาที

ในการฝึกโมเดลที่ดี คุณต้องมีประโยคตัวอย่างที่หลากหลายเพื่อครอบคลุมวิธีการต่างๆ ที่ผู้ใช้อาจพูดในสิ่งเดียวกัน

💁 เช่นเดียวกับโมเดล AI ใดๆ ยิ่งคุณใช้ข้อมูลที่มากและแม่นยำในการฝึกฝน โมเดลก็จะยิ่งดีขึ้น

✅ ลองคิดถึงวิธีการต่างๆ ที่คุณอาจพูดในสิ่งเดียวกันและคาดหวังให้มนุษย์เข้าใจ

งาน - เพิ่มเอนทิตีในโมเดลการเข้าใจภาษา

สำหรับตัวจับเวลา คุณต้องเพิ่มเอนทิตี 2 ตัว - หนึ่งสำหรับหน่วยเวลา (นาทีหรือวินาที) และอีกหนึ่งสำหรับจำนวนของนาทีหรือวินาที

คุณสามารถดูคำแนะนำในการใช้พอร์ทัล LUIS ได้ใน Quickstart: Build your app in LUIS portal documentation on Microsoft docs.

จากพอร์ทัล LUIS ให้เลือกแท็บ Entities และเพิ่มเอนทิตีที่สร้างไว้ล่วงหน้าชื่อ number โดยเลือกปุ่ม Add prebuilt entity จากนั้นเลือก number จากรายการ
สร้างเอนทิตีใหม่สำหรับหน่วยเวลาโดยใช้ปุ่ม Create ตั้งชื่อเอนทิตีว่า time unit และตั้งค่าประเภทเป็น List เพิ่มค่า minute และ second ในรายการ Normalized values โดยเพิ่มรูปแบบเอกพจน์และพหูพจน์ในรายการ synonyms กด return หลังจากเพิ่มคำพ้องความหมายแต่ละคำเพื่อเพิ่มลงในรายการ

Normalized value Synonyms

minute minute, minutes

second second, seconds

Normalized value	Synonyms
minute	minute, minutes
second	second, seconds

งาน - เพิ่มเจตนาในโมเดลการเข้าใจภาษา

จากแท็บ Intents ให้เลือกปุ่ม Create เพื่อสร้างเจตนาใหม่ ตั้งชื่อเจตนานี้ว่า set timer
ในตัวอย่าง ให้ป้อนวิธีการต่างๆ ในการตั้งเวลาที่ใช้ทั้งนาที วินาที และการรวมกันของนาทีและวินาที ตัวอย่างอาจเป็น:
- ตั้งเวลาหนึ่งวินาที
- ตั้งเวลาสี่นาที
- ตั้งเวลาสี่นาทีหกวินาที
- ตั้งเวลาเก้านาทีสามสิบวินาที
- ตั้งเวลาหนึ่งนาทีสิบสองวินาที
- ตั้งเวลาสามนาที
- ตั้งเวลาสามนาทีหนึ่งวินาที
- ตั้งเวลาสามนาทีหนึ่งวินาที
- ตั้งเวลาหนึ่งนาทีหนึ่งวินาที
- ตั้งเวลาสามสิบวินาที
- ตั้งเวลาหนึ่งวินาที
ผสมตัวเลขในรูปแบบคำและตัวเลขเพื่อให้โมเดลเรียนรู้การจัดการทั้งสองแบบ
เมื่อคุณป้อนตัวอย่างแต่ละตัวอย่าง LUIS จะเริ่มตรวจจับเอนทิตี และจะขีดเส้นใต้และติดป้ายกำกับที่พบ

งาน - ฝึกฝนและทดสอบโมเดล

เมื่อกำหนดเอนทิตีและเจตนาแล้ว คุณสามารถฝึกโมเดลโดยใช้ปุ่ม Train บนเมนูด้านบน เลือกปุ่มนี้ และโมเดลควรฝึกเสร็จในไม่กี่วินาที ปุ่มจะเป็นสีเทาระหว่างการฝึก และจะกลับมาใช้งานได้เมื่อเสร็จสิ้น
เลือกปุ่ม Test จากเมนูด้านบนเพื่อทดสอบโมเดลการเข้าใจภาษา ป้อนข้อความ เช่น ตั้งเวลาห้านาทีสี่วินาที แล้วกด return ข้อความจะปรากฏในกล่องใต้ช่องข้อความที่คุณพิมพ์ และด้านล่างจะเป็น เจตนาสูงสุด หรือเจตนาที่ตรวจพบด้วยความน่าจะเป็นสูงสุด ซึ่งควรเป็น set timer ชื่อเจตนาจะตามด้วยความน่าจะเป็นที่เจตนาที่ตรวจพบถูกต้อง
เลือกตัวเลือก Inspect เพื่อดูรายละเอียดของผลลัพธ์ คุณจะเห็นเจตนาที่มีคะแนนสูงสุดพร้อมความน่าจะเป็นเป็นเปอร์เซ็นต์ รวมถึงรายการเอนทิตีที่ตรวจพบ
ปิดหน้าต่าง Test เมื่อคุณทดสอบเสร็จ

งาน - เผยแพร่โมเดล

ในการใช้โมเดลนี้จากโค้ด คุณต้องเผยแพร่ เมื่อเผยแพร่จาก LUIS คุณสามารถเผยแพร่ไปยังสภาพแวดล้อมการทดสอบหรือสภาพแวดล้อมการผลิตได้ ในบทเรียนนี้ สภาพแวดล้อมการทดสอบก็เพียงพอแล้ว

จากพอร์ทัล LUIS ให้เลือกปุ่ม Publish จากเมนูด้านบน
ตรวจสอบให้แน่ใจว่าเลือก Staging slot แล้วเลือก Done คุณจะเห็นการแจ้งเตือนเมื่อแอปพลิเคชันถูกเผยแพร่
คุณสามารถทดสอบสิ่งนี้โดยใช้ curl ในการสร้างคำสั่ง curl คุณต้องใช้ค่าทั้งสาม - endpoint, application ID (App ID) และ API key ซึ่งสามารถเข้าถึงได้จากแท็บ MANAGE ที่สามารถเลือกได้จากเมนูด้านบน
1. จากส่วน Settings คัดลอก App ID
จากส่วน Azure Resources ให้เลือก Authoring Resource และคัดลอก Primary Key และ Endpoint URL
รันคำสั่ง curl ต่อไปนี้ใน command prompt หรือ terminal ของคุณ:
```
curl "<endpoint url>/luis/prediction/v3.0/apps/<app id>/slots/staging/predict" \
      --request GET \
      --get \
      --data "subscription-key=<primary key>" \
      --data "verbose=false" \
      --data "show-all-intents=true" \
      --data-urlencode "query=<sentence>"
```
แทนที่ <endpoint url> ด้วย Endpoint URL จากส่วน Azure Resources

แทนที่ <app id> ด้วย App ID จากส่วน Settings

แทนที่ <primary key> ด้วย Primary Key จากส่วน Azure Resources

แทนที่ <sentence> ด้วยประโยคที่คุณต้องการทดสอบ

ผลลัพธ์ของการเรียกนี้จะเป็นเอกสาร JSON ที่แสดงรายละเอียดของการ query, intent ที่มีคะแนนสูงสุด และรายการ entities ที่ถูกแยกตามประเภท

{
    "query": "set a timer for 45 minutes and 12 seconds",
    "prediction": {
        "topIntent": "set timer",
        "intents": {
            "set timer": {
                "score": 0.97031575
            },
            "None": {
                "score": 0.02205793
            }
        },
        "entities": {
            "number": [
                45,
                12
            ],
            "time-unit": [
                [
                    "minute"
                ],
                [
                    "second"
                ]
            ]
        }
    }
}

JSON ด้านบนมาจากการ query ด้วย set a timer for 45 minutes and 12 seconds:

set timer เป็น intent ที่มีคะแนนสูงสุดที่ 97%
มีการตรวจพบ number entities สองตัวคือ 45 และ 12
มีการตรวจพบ time-unit entities สองตัวคือ minute และ second

ใช้โมเดลการเข้าใจภาษา

เมื่อเผยแพร่แล้ว โมเดล LUIS สามารถถูกเรียกใช้งานจากโค้ดได้ ในบทเรียนก่อนหน้านี้ คุณได้ใช้ IoT Hub เพื่อจัดการการสื่อสารกับบริการคลาวด์ โดยการส่ง telemetry และฟังคำสั่ง ซึ่งเป็นแบบ asynchronous - เมื่อ telemetry ถูกส่ง โค้ดของคุณจะไม่รอการตอบกลับ และหากบริการคลาวด์ล่ม คุณจะไม่ทราบ

สำหรับ smart timer เราต้องการการตอบกลับทันที เพื่อที่เราจะสามารถบอกผู้ใช้ว่า timer ถูกตั้งค่าแล้ว หรือแจ้งเตือนว่าบริการคลาวด์ไม่พร้อมใช้งาน ในการทำเช่นนี้ อุปกรณ์ IoT ของเราจะเรียก web endpoint โดยตรง แทนที่จะพึ่งพา IoT Hub

แทนที่จะเรียก LUIS จากอุปกรณ์ IoT คุณสามารถใช้โค้ดแบบ serverless ที่มี trigger ประเภทอื่น - HTTP trigger สิ่งนี้จะช่วยให้แอปฟังก์ชันของคุณสามารถฟังคำขอ REST และตอบกลับได้ ฟังก์ชันนี้จะเป็น REST endpoint ที่อุปกรณ์ของคุณสามารถเรียกได้

💁 แม้ว่าคุณสามารถเรียก LUIS โดยตรงจากอุปกรณ์ IoT ของคุณ แต่การใช้โค้ดแบบ serverless จะดีกว่า ด้วยวิธีนี้เมื่อคุณต้องการเปลี่ยนแอป LUIS ที่คุณเรียก เช่น เมื่อคุณฝึกโมเดลที่ดีกว่าหรือฝึกโมเดลในภาษาอื่น คุณจะต้องอัปเดตโค้ดคลาวด์ของคุณเท่านั้น ไม่ต้องปรับใช้โค้ดใหม่ไปยังอุปกรณ์ IoT หลายพันหรือหลายล้านเครื่อง

งาน - สร้างแอปฟังก์ชันแบบ serverless

สร้าง Azure Functions app ชื่อ smart-timer-trigger และเปิดใน VS Code
เพิ่ม HTTP trigger ให้กับแอปนี้ชื่อ speech-trigger โดยใช้คำสั่งต่อไปนี้จากภายใน terminal ของ VS Code:
```
func new --name text-to-timer --template "HTTP trigger"
```
สิ่งนี้จะสร้าง HTTP trigger ชื่อ text-to-timer
ทดสอบ HTTP trigger โดยรันแอปฟังก์ชัน เมื่อรันคุณจะเห็น endpoint แสดงใน output:
```
Functions:

        text-to-timer: [GET,POST] http://localhost:7071/api/text-to-timer
```
ทดสอบโดยโหลด URL http://localhost:7071/api/text-to-timer ในเบราว์เซอร์ของคุณ
```
This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.
```

งาน - ใช้โมเดลการเข้าใจภาษา

SDK สำหรับ LUIS มีให้ใช้งานผ่าน Pip package เพิ่มบรรทัดต่อไปนี้ในไฟล์ requirements.txt เพื่อเพิ่ม dependency บนแพ็กเกจนี้:
```
azure-cognitiveservices-language-luis
```
ตรวจสอบให้แน่ใจว่า terminal ของ VS Code มี virtual environment เปิดใช้งานอยู่ และรันคำสั่งต่อไปนี้เพื่อติดตั้ง Pip packages:
```
pip install -r requirements.txt
```
💁 หากคุณพบข้อผิดพลาด คุณอาจต้องอัปเกรด pip ด้วยคำสั่งต่อไปนี้:
```
pip install --upgrade pip
```
เพิ่มรายการใหม่ในไฟล์ local.settings.json สำหรับ LUIS API Key, Endpoint URL และ App ID จากแท็บ MANAGE ในพอร์ทัล LUIS:
```
"LUIS_KEY": "<primary key>",
"LUIS_ENDPOINT_URL": "<endpoint url>",
"LUIS_APP_ID": "<app id>"
```
แทนที่ <endpoint url> ด้วย Endpoint URL จากส่วน Azure Resources ในแท็บ MANAGE ซึ่งจะเป็น https://<location>.api.cognitive.microsoft.com/

แทนที่ <app id> ด้วย App ID จากส่วน Settings ในแท็บ MANAGE

แทนที่ <primary key> ด้วย Primary Key จากส่วน Azure Resources ในแท็บ MANAGE
เพิ่ม imports ต่อไปนี้ในไฟล์ __init__.py:
```
import json
import os
from azure.cognitiveservices.language.luis.runtime import LUISRuntimeClient
from msrest.authentication import CognitiveServicesCredentials
```
สิ่งนี้จะ import ไลบรารีระบบบางตัว รวมถึงไลบรารีสำหรับการโต้ตอบกับ LUIS
ลบเนื้อหาในเมธอด main และเพิ่มโค้ดต่อไปนี้:
```
luis_key = os.environ['LUIS_KEY']
endpoint_url = os.environ['LUIS_ENDPOINT_URL']
app_id = os.environ['LUIS_APP_ID']

credentials = CognitiveServicesCredentials(luis_key)
client = LUISRuntimeClient(endpoint=endpoint_url, credentials=credentials)
```
โค้ดนี้โหลดค่าที่คุณเพิ่มในไฟล์ local.settings.json สำหรับแอป LUIS ของคุณ สร้าง credentials object ด้วย API key ของคุณ จากนั้นสร้าง LUIS client object เพื่อโต้ตอบกับแอป LUIS ของคุณ
HTTP trigger นี้จะถูกเรียกโดยส่งข้อความที่ต้องการเข้าใจเป็น JSON โดยมีข้อความอยู่ใน property ชื่อ text โค้ดต่อไปนี้จะดึงค่าจาก body ของคำขอ HTTP และบันทึกลงใน console เพิ่มโค้ดนี้ในฟังก์ชัน main:
```
req_body = req.get_json()
text = req_body['text']
logging.info(f'Request - {text}')
```
การทำนายจะถูกขอจาก LUIS โดยการส่งคำขอทำนาย - เอกสาร JSON ที่มีข้อความที่ต้องการทำนาย สร้างคำขอนี้ด้วยโค้ดต่อไปนี้:
```
prediction_request = { 'query' : text }
```
คำขอนี้สามารถถูกส่งไปยัง LUIS โดยใช้ staging slot ที่แอปของคุณถูกเผยแพร่ไป:
```
prediction_response = client.prediction.get_slot_prediction(app_id, 'Staging', prediction_request)
```
การตอบกลับการทำนายจะมี intent ที่มีคะแนนสูงสุด พร้อมกับ entities หาก intent ที่มีคะแนนสูงสุดคือ set timer entities สามารถถูกอ่านเพื่อรับเวลาที่ต้องการสำหรับ timer:
```
if prediction_response.prediction.top_intent == 'set timer':
    numbers = prediction_response.prediction.entities['number']
    time_units = prediction_response.prediction.entities['time unit']
    total_seconds = 0
```
- number entities จะเป็น array ของตัวเลข เช่น หากคุณพูดว่า "Set a four minute 17 second timer." number array จะมี 2 ตัวเลข - 4 และ 17
- time unit entities จะเป็น array ของ arrays ของ strings โดยแต่ละ time unit จะเป็น array ของ strings ภายใน array เช่น หากคุณพูดว่า "Set a four minute 17 second timer." time unit array จะมี 2 arrays โดยแต่ละ array มีค่าเดียว - ['minute'] และ ['second']
JSON ของ entities สำหรับ "Set a four minute 17 second timer." คือ:
```
{
    "number": [4, 17],
    "time unit": [
        ["minute"],
        ["second"]
    ]
}
```
โค้ดนี้ยังนิยาม count สำหรับเวลารวมของ timer ในวินาที ซึ่งจะถูกเติมค่าจาก entities
entities ไม่ได้ถูกเชื่อมโยง แต่เราสามารถทำสมมติฐานเกี่ยวกับพวกมันได้ พวกมันจะอยู่ในลำดับที่พูด ดังนั้นตำแหน่งใน array สามารถใช้เพื่อกำหนดว่าตัวเลขใดตรงกับ time unit ใด เช่น:
- "Set a 30 second timer" - จะมีตัวเลขเดียว 30 และ time unit เดียว second ดังนั้นตัวเลขเดียวจะตรงกับ time unit เดียว
- "Set a 2 minute and 30 second timer" - จะมีตัวเลขสองตัว 2 และ 30 และ time unit สองตัว minute และ second ดังนั้นตัวเลขแรกจะตรงกับ time unit แรก (2 นาที) และตัวเลขที่สองจะตรงกับ time unit ที่สอง (30 วินาที)
โค้ดต่อไปนี้จะนับจำนวน items ใน number entities และใช้สิ่งนี้เพื่อดึง item แรกจากแต่ละ array จากนั้น item ที่สอง และอื่นๆ เพิ่มโค้ดนี้ภายใน if block:
```
for i in range(0, len(numbers)):
    number = numbers[i]
    time_unit = time_units[i][0]
```
สำหรับ "Set a four minute 17 second timer." สิ่งนี้จะวนลูปสองครั้ง โดยให้ค่าดังนี้:

loop count number time_unit

0 4 minute

1 17 second
ภายในลูปนี้ ใช้ตัวเลขและ time unit เพื่อคำนวณเวลารวมสำหรับ timer โดยเพิ่ม 60 วินาทีสำหรับแต่ละนาที และจำนวนวินาทีสำหรับ seconds ใดๆ
```
if time_unit == 'minute':
    total_seconds += number * 60
else:
    total_seconds += number
```
นอกลูปนี้ผ่าน entities บันทึกเวลารวมสำหรับ timer:
```
logging.info(f'Timer required for {total_seconds} seconds')
```
จำนวนวินาทีต้องถูกส่งกลับจากฟังก์ชันเป็นการตอบกลับ HTTP ที่ท้าย if block เพิ่มสิ่งต่อไปนี้:
```
payload = {
    'seconds': total_seconds
}
return func.HttpResponse(json.dumps(payload), status_code=200)
```
โค้ดนี้สร้าง payload ที่มีจำนวนวินาทีรวมสำหรับ timer แปลงเป็น JSON string และส่งกลับเป็นผลลัพธ์ HTTP พร้อมสถานะ 200 ซึ่งหมายถึงการเรียกสำเร็จ
สุดท้าย นอก if block จัดการกรณีที่ intent ไม่ถูกจดจำโดยการส่งกลับ error code:
```
return func.HttpResponse(status_code=404)
```
404 เป็นสถานะสำหรับ not found

loop count	`number`	`time_unit`
0	4	minute
1	17	second

รันแอปฟังก์ชันและทดสอบโดยใช้ curl

curl --request POST 'http://localhost:7071/api/text-to-timer' \
     --header 'Content-Type: application/json' \
     --include \
     --data '{"text":"<text>"}'

แทนที่ <text> ด้วยข้อความของคำขอ เช่น set a 2 minutes 27 second timer

คุณจะเห็น output ต่อไปนี้จากแอปฟังก์ชัน:

Functions:

        text-to-timer: [GET,POST] http://localhost:7071/api/text-to-timer

For detailed output, run func with --verbose flag.
[2021-06-26T19:45:14.502Z] Worker process started and initialized.
[2021-06-26T19:45:19.338Z] Host lock lease acquired by instance ID '000000000000000000000000951CAE4E'.
[2021-06-26T19:45:52.059Z] Executing 'Functions.text-to-timer' (Reason='This function was programmatically called via the host APIs.', Id=f68bfb90-30e4-47a5-99da-126b66218e81)
[2021-06-26T19:45:53.577Z] Timer required for 147 seconds
[2021-06-26T19:45:53.746Z] Executed 'Functions.text-to-timer' (Succeeded, Id=f68bfb90-30e4-47a5-99da-126b66218e81, Duration=1750ms)

การเรียก curl จะส่งกลับดังนี้:

HTTP/1.1 200 OK
Date: Tue, 29 Jun 2021 01:14:11 GMT
Content-Type: text/plain; charset=utf-8
Server: Kestrel
Transfer-Encoding: chunked

{"seconds": 147}

จำนวนวินาทีสำหรับ timer อยู่ในค่า "seconds"

💁 คุณสามารถค้นหาโค้ดนี้ในโฟลเดอร์ code/functions

งาน - ทำให้ฟังก์ชันของคุณพร้อมใช้งานสำหรับอุปกรณ์ IoT ของคุณ

สำหรับอุปกรณ์ IoT ของคุณที่จะเรียก REST endpoint ของคุณ มันจะต้องทราบ URL เมื่อคุณเข้าถึงก่อนหน้านี้ คุณใช้ localhost ซึ่งเป็นทางลัดเพื่อเข้าถึง REST endpoints บนเครื่องของคุณเอง เพื่อให้อุปกรณ์ IoT ของคุณเข้าถึงได้ คุณต้องเผยแพร่ไปยังคลาวด์ หรือรับ IP address เพื่อเข้าถึงในเครื่อง

⚠️ หากคุณใช้ Wio Terminal จะง่ายกว่าที่จะรันแอปฟังก์ชันในเครื่อง เนื่องจากจะมี dependency บนไลบรารีที่หมายความว่าคุณไม่สามารถปรับใช้แอปฟังก์ชันในแบบเดียวกับที่คุณเคยทำมาก่อน รันแอปฟังก์ชันในเครื่องและเข้าถึงผ่าน IP address ของคอมพิวเตอร์ของคุณ หากคุณต้องการปรับใช้ในคลาวด์ ข้อมูลจะถูกให้ในบทเรียนถัดไปเกี่ยวกับวิธีการทำเช่นนี้
- เผยแพร่ Functions app - ทำตามคำแนะนำในบทเรียนก่อนหน้าเพื่อเผยแพร่แอปฟังก์ชันของคุณไปยังคลาวด์ เมื่อเผยแพร่แล้ว URL จะเป็น https://<APP_NAME>.azurewebsites.net/api/text-to-timer โดยที่ <APP_NAME> จะเป็นชื่อของแอปฟังก์ชันของคุณ ตรวจสอบให้แน่ใจว่าได้เผยแพร่ local settings ของคุณด้วย
  
  เมื่อทำงานกับ HTTP triggers พวกมันจะถูกป้องกันโดยค่าเริ่มต้นด้วย function app key เพื่อรับ key นี้ รันคำสั่งต่อไปนี้:
```
az functionapp keys list --resource-group smart-timer \
                         --name <APP_NAME>                               
```
  คัดลอกค่าของ entry default จากส่วน functionKeys
```
{
  "functionKeys": {
    "default": "sQO1LQaeK9N1qYD6SXeb/TctCmwQEkToLJU6Dw8TthNeUH8VA45hlA=="
  },
  "masterKey": "RSKOAIlyvvQEQt9dfpabJT018scaLpQu9p1poHIMCxx5LYrIQZyQ/g==",
  "systemKeys": {}
}
```
  key นี้จะต้องถูกเพิ่มเป็น query parameter ใน URL ดังนั้น URL สุดท้ายจะเป็น https://<APP_NAME>.azurewebsites.net/api/text-to-timer?code=<FUNCTION_KEY> โดยที่ <APP_NAME> จะเป็นชื่อของแอปฟังก์ชันของคุณ และ <FUNCTION_KEY> จะเป็น default function key ของคุณ
  
  💁 คุณสามารถเปลี่ยนประเภทการอนุญาตของ HTTP trigger โดยใช้การตั้งค่า authlevel ในไฟล์ function.json คุณสามารถอ่านเพิ่มเติมเกี่ยวกับสิ่งนี้ใน ส่วนการตั้งค่าของเอกสาร Azure Functions HTTP trigger บน Microsoft docs
- รันแอปฟังก์ชันในเครื่อง และเข้าถึงโดยใช้ IP address - คุณสามารถรับ IP address ของคอมพิวเตอร์ของคุณบนเครือข่ายในเครื่อง และใช้สิ่งนั้นเพื่อสร้าง URL
  
  ค้นหา IP address ของคุณ:
  - บน Windows 10 ทำตาม คู่มือการค้นหา IP address
  - บน macOS ทำตาม วิธีการค้นหา IP address บน Mac guide
  - บน linux ทำตามส่วนการค้นหา private IP address ใน วิธีการค้นหา IP address ใน Linux guide
  เมื่อคุณมี IP address ของคุณแล้ว คุณจะสามารถเข้าถึงฟังก์ชันที่ http://

:7071/api/text-to-timerโดยที่<IP_ADDRESS>จะเป็นที่อยู่ IP ของคุณ เช่นhttp://192.168.1.10:7071/api/text-to-timer`

  > 💁 โปรดทราบว่านี่ใช้พอร์ต 7071 ดังนั้นหลังจากที่อยู่ IP คุณจะต้องใส่ `:7071`

  > 💁 สิ่งนี้จะทำงานได้ก็ต่อเมื่ออุปกรณ์ IoT ของคุณอยู่ในเครือข่ายเดียวกันกับคอมพิวเตอร์ของคุณ

ทดสอบ endpoint โดยการเข้าถึงผ่าน curl

🚀 ความท้าทาย

มีหลายวิธีในการร้องขอสิ่งเดียวกัน เช่น การตั้งเวลา ลองคิดถึงวิธีต่าง ๆ ในการทำสิ่งนี้ และใช้วิธีเหล่านั้นเป็นตัวอย่างในแอป LUIS ของคุณ ทดสอบวิธีเหล่านี้เพื่อดูว่าโมเดลของคุณสามารถจัดการกับวิธีการร้องขอการตั้งเวลาในรูปแบบต่าง ๆ ได้ดีเพียงใด

แบบทดสอบหลังการบรรยาย

ทบทวนและศึกษาด้วยตนเอง

อ่านเพิ่มเติมเกี่ยวกับ LUIS และความสามารถของมันได้ที่ หน้าคู่มือ Language Understanding (LUIS) บน Microsoft docs
อ่านเพิ่มเติมเกี่ยวกับการทำความเข้าใจภาษาธรรมชาติได้ที่ หน้าการทำความเข้าใจภาษาธรรมชาติบน Wikipedia
อ่านเพิ่มเติมเกี่ยวกับ HTTP triggers ได้ที่ หน้าคู่มือ Azure Functions HTTP trigger บน Microsoft docs

งานที่ได้รับมอบหมาย

ยกเลิกการตั้งเวลา

ข้อจำกัดความรับผิดชอบ:
เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI Co-op Translator แม้ว่าเราจะพยายามให้การแปลมีความถูกต้องมากที่สุด แต่โปรดทราบว่าการแปลอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาดั้งเดิมควรถือเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ ขอแนะนำให้ใช้บริการแปลภาษามืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความผิดที่เกิดจากการใช้การแปลนี้