58 KiB

Raw Permalink Blame History

भाषा को समझें

स्केच नोट नित्या नरसिम्हन द्वारा। बड़े संस्करण के लिए छवि पर क्लिक करें।

व्याख्यान से पहले का क्विज़

परिचय

पिछले पाठ में आपने आवाज़ को टेक्स्ट में बदला। इसे एक स्मार्ट टाइमर प्रोग्राम करने के लिए उपयोग करने के लिए, आपके कोड को यह समझने की आवश्यकता होगी कि क्या कहा गया। आप मान सकते हैं कि उपयोगकर्ता एक निश्चित वाक्यांश बोलेगा, जैसे "3 मिनट का टाइमर सेट करें", और उस वाक्यांश को पार्स करके यह पता लगाएंगे कि टाइमर कितने समय के लिए होना चाहिए, लेकिन यह बहुत उपयोगकर्ता-अनुकूल नहीं है। यदि कोई उपयोगकर्ता कहे "3 मिनट के लिए टाइमर सेट करें", तो आप या मैं समझ जाएंगे कि उनका क्या मतलब है, लेकिन आपका कोड नहीं समझेगा, क्योंकि वह एक निश्चित वाक्यांश की अपेक्षा कर रहा होगा।

यहीं पर भाषा समझने की तकनीक काम आती है, जो AI मॉडल का उपयोग करके टेक्स्ट की व्याख्या करती है और आवश्यक विवरण लौटाती है। उदाहरण के लिए, "3 मिनट का टाइमर सेट करें" और "3 मिनट के लिए टाइमर सेट करें" दोनों को समझना कि 3 मिनट के लिए एक टाइमर की आवश्यकता है।

इस पाठ में आप भाषा समझने वाले मॉडल के बारे में जानेंगे, उन्हें कैसे बनाना, प्रशिक्षित करना और अपने कोड में उपयोग करना।

इस पाठ में हम कवर करेंगे:

भाषा समझना

मनुष्य हजारों वर्षों से संवाद करने के लिए भाषा का उपयोग कर रहे हैं। हम शब्दों, ध्वनियों, या क्रियाओं के माध्यम से संवाद करते हैं और यह समझते हैं कि क्या कहा गया, न केवल शब्दों, ध्वनियों या क्रियाओं का अर्थ, बल्कि उनका संदर्भ भी। हम ईमानदारी और व्यंग्य को समझते हैं, जिससे एक ही शब्द अलग-अलग स्वर के आधार पर अलग-अलग अर्थ रख सकते हैं।

✅ हाल ही में हुई कुछ बातचीतों के बारे में सोचें। कितनी बातचीत कंप्यूटर के लिए समझना मुश्किल होगी क्योंकि उसे संदर्भ की आवश्यकता है?

भाषा समझना, जिसे प्राकृतिक भाषा समझना भी कहा जाता है, कृत्रिम बुद्धिमत्ता के एक क्षेत्र का हिस्सा है जिसे प्राकृतिक भाषा प्रसंस्करण (NLP) कहा जाता है। यह पढ़ने और समझने की क्षमता से संबंधित है, जिसमें शब्दों या वाक्यों के विवरण को समझने की कोशिश की जाती है। यदि आप एलेक्सा या सिरी जैसे वॉयस असिस्टेंट का उपयोग करते हैं, तो आपने भाषा समझने वाली सेवाओं का उपयोग किया है। ये वे AI सेवाएँ हैं जो "एलेक्सा, टेलर स्विफ्ट का नवीनतम एल्बम चलाओ" को मेरी बेटी के लिविंग रूम में अपने पसंदीदा गानों पर नाचने में बदल देती हैं।

💁 कंप्यूटर, अपनी सभी प्रगति के बावजूद, टेक्स्ट को वास्तव में समझने में अभी भी बहुत पीछे हैं। जब हम कंप्यूटर के साथ भाषा समझने की बात करते हैं, तो हमारा मतलब मानव संचार जितना उन्नत कुछ भी नहीं होता, बल्कि हमारा मतलब कुछ शब्दों को लेकर मुख्य विवरण निकालने से होता है।

मनुष्य के रूप में, हम बिना सोचे-समझे भाषा को समझते हैं। यदि मैं किसी अन्य व्यक्ति से "टेलर स्विफ्ट का नवीनतम एल्बम चलाओ" कहूं, तो वे स्वाभाविक रूप से समझ जाएंगे कि मेरा क्या मतलब है। कंप्यूटर के लिए, यह कठिन है। उसे शब्दों को लेना होगा, जो आवाज़ से टेक्स्ट में बदले गए हैं, और निम्नलिखित जानकारी के टुकड़ों को समझना होगा:

संगीत चलाना है
संगीत कलाकार टेलर स्विफ्ट का है
विशेष संगीत एक पूरे एल्बम का है जिसमें कई ट्रैक क्रम में हैं
टेलर स्विफ्ट के कई एल्बम हैं, इसलिए उन्हें कालानुक्रमिक क्रम में व्यवस्थित करना होगा और सबसे हाल ही में प्रकाशित एल्बम की आवश्यकता है

✅ उन अन्य वाक्यों के बारे में सोचें जो आपने अनुरोध करते समय बोले हैं, जैसे कॉफी ऑर्डर करना या किसी परिवार के सदस्य से कुछ पास करने के लिए कहना। उन्हें उन जानकारी के टुकड़ों में तोड़ने की कोशिश करें जिन्हें कंप्यूटर को वाक्य को समझने के लिए निकालने की आवश्यकता होगी।

भाषा समझने वाले मॉडल AI मॉडल हैं जिन्हें भाषा से कुछ विवरण निकालने के लिए प्रशिक्षित किया जाता है, और फिर उन्हें स्थानांतरित शिक्षण (transfer learning) का उपयोग करके विशिष्ट कार्यों के लिए प्रशिक्षित किया जाता है, जैसे आपने कस्टम विज़न मॉडल को छवियों के एक छोटे सेट का उपयोग करके प्रशिक्षित किया था। आप एक मॉडल ले सकते हैं, फिर उसे उस टेक्स्ट का उपयोग करके प्रशिक्षित कर सकते हैं जिसे आप समझना चाहते हैं।

भाषा समझने का मॉडल बनाएं

आप LUIS (Language Understanding Intelligent Service) का उपयोग करके भाषा समझने वाले मॉडल बना सकते हैं, जो 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.ai पोर्टल खोलें और उसी खाते से साइन इन करें जिसे आप Azure के लिए उपयोग कर रहे हैं।
डायलॉग पर दिए गए निर्देशों का पालन करें, अपनी Azure सदस्यता का चयन करें, फिर उस smart-timer-luis-authoring संसाधन का चयन करें जिसे आपने अभी बनाया है।
Conversation apps सूची से, New app बटन का चयन करें और एक नया ऐप बनाएं। नए ऐप का नाम smart-timer रखें और Culture को अपनी भाषा पर सेट करें।

💁 भविष्यवाणी संसाधन के लिए एक फ़ील्ड है। आप केवल भविष्यवाणी के लिए एक दूसरा संसाधन बना सकते हैं, लेकिन मुफ्त ऑथरिंग संसाधन प्रति माह 1,000 भविष्यवाणियाँ प्रदान करता है, जो विकास के लिए पर्याप्त होना चाहिए, इसलिए आप इसे खाली छोड़ सकते हैं।
ऐप बनाने के बाद जो गाइड दिखाई देता है, उसे पढ़ें ताकि आप भाषा समझने वाले मॉडल को प्रशिक्षित करने के चरणों को समझ सकें। जब आप गाइड पढ़ लें, तो इसे बंद कर दें।

इरादे और इकाइयाँ

भाषा समझना इरादों और इकाइयों पर आधारित है। इरादे शब्दों के उद्देश्य को दर्शाते हैं, जैसे संगीत चलाना, टाइमर सेट करना, या खाना ऑर्डर करना। इकाइयाँ वह होती हैं जिनका इरादा संदर्भित करता है, जैसे एल्बम, टाइमर की अवधि, या भोजन का प्रकार। मॉडल द्वारा व्याख्या किए गए प्रत्येक वाक्य में कम से कम एक इरादा और वैकल्पिक रूप से एक या अधिक इकाइयाँ होनी चाहिए।

कुछ उदाहरण:

वाक्य	इरादा	इकाइयाँ
"टेलर स्विफ्ट का नवीनतम एल्बम चलाओ"	संगीत चलाना	टेलर स्विफ्ट का नवीनतम एल्बम
"3 मिनट का टाइमर सेट करें"	टाइमर सेट करें	3 मिनट
"मेरा टाइमर रद्द करें"	टाइमर रद्द करें	कोई नहीं
"3 बड़े पाइनएप्पल पिज्जा और एक सीज़र सलाद ऑर्डर करें"	खाना ऑर्डर करें	3 बड़े पाइनएप्पल पिज्जा, सीज़र सलाद

✅ उन वाक्यों के बारे में सोचें जो आपने पहले सोचे थे। उस वाक्य में इरादा और कोई इकाइयाँ क्या होंगी?

LUIS को प्रशिक्षित करने के लिए, पहले आप इकाइयाँ सेट करते हैं। ये निश्चित शब्दों की सूची हो सकती हैं, या टेक्स्ट से सीखी जा सकती हैं। उदाहरण के लिए, आप अपने मेनू से उपलब्ध भोजन की एक निश्चित सूची प्रदान कर सकते हैं, जिसमें प्रत्येक शब्द के भिन्न रूप (या पर्यायवाची) शामिल हैं, जैसे बैंगन और एबर्जीन।

टाइमर सेट करने के लिए, आप समय के लिए एक इकाई बना सकते हैं (जैसे मिनट और सेकंड) और एक अन्य इकाई समय की संख्या के लिए। प्रत्येक इकाई में एकाधिक भिन्न रूप हो सकते हैं, जैसे मिनट और मिनट्स।

इरादे बनाने के बाद, आप उदाहरण वाक्य प्रदान करते हैं (जिन्हें utterances कहा जाता है)। उदाहरण के लिए, टाइमर सेट करें इरादे के लिए, आप निम्नलिखित वाक्य प्रदान कर सकते हैं:

1 सेकंड का टाइमर सेट करें
1 मिनट और 12 सेकंड के लिए टाइमर सेट करें
3 मिनट के लिए टाइमर सेट करें
9 मिनट 30 सेकंड का टाइमर सेट करें

फिर आप LUIS को बताते हैं कि इन वाक्यों के कौन से हिस्से इकाइयों से मेल खाते हैं:

वाक्य 1 मिनट और 12 सेकंड के लिए टाइमर सेट करें का इरादा टाइमर सेट करें है। इसमें 2 इकाइयाँ हैं, जिनमें 2 मान हैं:

	समय	इकाई
1 मिनट	1	मिनट
12 सेकंड	12	सेकंड

एक अच्छा मॉडल प्रशिक्षित करने के लिए, आपको विभिन्न प्रकार के उदाहरण वाक्य चाहिए ताकि यह विभिन्न तरीकों को कवर कर सके जिनसे कोई व्यक्ति एक ही चीज़ माँग सकता है।

💁 किसी भी AI मॉडल की तरह, जितना अधिक डेटा और जितना सटीक डेटा आप प्रशिक्षण के लिए उपयोग करेंगे, मॉडल उतना ही बेहतर होगा।

✅ उन विभिन्न तरीकों के बारे में सोचें जिनसे आप एक ही चीज़ माँग सकते हैं और उम्मीद कर सकते हैं कि एक इंसान समझ जाएगा।

कार्य - भाषा समझने वाले मॉडल में इकाइयाँ जोड़ें

टाइमर के लिए, आपको 2 इकाइयाँ जोड़नी होंगी - एक समय की इकाई (मिनट या सेकंड) के लिए और एक मिनट या सेकंड की संख्या के लिए।

LUIS पोर्टल का उपयोग करने के निर्देश Microsoft Docs पर Quickstart: Build your app in LUIS portal में पाए जा सकते हैं।

LUIS पोर्टल से, Entities टैब का चयन करें और Add prebuilt entity बटन का उपयोग करके number प्रीबिल्ट इकाई जोड़ें। सूची से number का चयन करें।
समय इकाई के लिए एक नई इकाई बनाएं। Create बटन का उपयोग करें। इकाई का नाम time unit रखें और प्रकार List पर सेट करें। Normalized values सूची में minute और second के लिए मान जोड़ें, और synonyms सूची में उनके एकवचन और बहुवचन रूप जोड़ें। प्रत्येक पर्याय जोड़ने के बाद return दबाएँ।

Normalized value Synonyms

minute minute, minutes

second second, seconds

Normalized value	Synonyms
minute	minute, minutes
second	second, seconds

कार्य - भाषा समझने वाले मॉडल में इरादे जोड़ें

Intents टैब से, Create बटन का चयन करें और एक नया इरादा बनाएं। इस इरादे का नाम set timer रखें।
उदाहरणों में, टाइमर सेट करने के विभिन्न तरीकों को दर्ज करें, जिनमें मिनट, सेकंड और मिनट और सेकंड का संयोजन शामिल हो। उदाहरण हो सकते हैं:
- 1 सेकंड का टाइमर सेट करें
- 4 मिनट का टाइमर सेट करें
- चार मिनट छह सेकंड का टाइमर सेट करें
- 9 मिनट 30 सेकंड का टाइमर सेट करें
- 1 मिनट और 12 सेकंड के लिए टाइमर सेट करें
- 3 मिनट के लिए टाइमर सेट करें
- 3 मिनट और 1 सेकंड के लिए टाइमर सेट करें
- तीन मिनट और एक सेकंड के लिए टाइमर सेट करें
- 1 मिनट और 1 सेकंड के लिए टाइमर सेट करें
- 30 सेकंड के लिए टाइमर सेट करें
- 1 सेकंड के लिए टाइमर सेट करें
मॉडल को दोनों शब्दों और अंकों को संभालने के लिए प्रशिक्षित करने के लिए शब्दों और अंकों को मिलाएँ।
प्रत्येक उदाहरण दर्ज करते समय, LUIS इकाइयों का पता लगाना शुरू कर देगा और किसी भी पाए गए इकाई को रेखांकित और लेबल करेगा।

कार्य - मॉडल को प्रशिक्षित और परीक्षण करें

इकाइयों और इरादों को कॉन्फ़िगर करने के बाद, आप शीर्ष मेनू में Train बटन का उपयोग करके मॉडल को प्रशिक्षित कर सकते हैं। इस बटन का चयन करें, और मॉडल कुछ सेकंड में प्रशिक्षित हो जाएगा। प्रशिक्षण के दौरान बटन ग्रे हो जाएगा और प्रशिक्षण पूरा होने के बाद फिर से सक्रिय हो जाएगा।
शीर्ष मेनू से Test बटन का चयन करें और भाषा समझने वाले मॉडल का परीक्षण करें। 5 मिनट और 4 सेकंड के लिए टाइमर सेट करें जैसे टेक्स्ट दर्ज करें और रिटर्न दबाएँ। वाक्य उस टेक्स्ट बॉक्स के नीचे दिखाई देगा जिसमें आपने इसे टाइप किया था, और उसके नीचे top intent होगा, या वह इरादा जिसे सबसे अधिक संभावना के साथ पहचाना गया। यह set timer होना चाहिए। इरादे का नाम उसके सही होने की संभावना के प्रतिशत के साथ होगा।
परिणामों का ब्रेकडाउन देखने के लिए Inspect विकल्प का चयन करें। आप शीर्ष स्कोरिंग इरादे को उसकी प्रतिशत संभावना के साथ देखेंगे, साथ ही पहचानी गई इकाइयों की सूची भी।
परीक्षण समाप्त करने के बाद Test पैन को बंद करें।

कार्य - मॉडल को प्रकाशित करें

इस मॉडल का कोड से उपयोग करने के लिए, आपको इसे प्रकाशित करना होगा। LUIS से प्रकाशित करते समय, आप इसे परीक्षण के लिए एक स्टेजिंग वातावरण या पूर्ण रिलीज़ के लिए एक प्रोडक्ट वातावरण में प्रकाशित कर सकते हैं। इस पाठ में, स्टेजिंग वातावरण पर्याप्त है।

LUIS पोर्टल से, शीर्ष मेनू से Publish बटन का चयन करें।
सुनिश्चित करें कि Staging slot चयनित है, फिर Done का चयन करें। ऐप प्रकाशित होने पर आपको एक सूचना दिखाई देगी।
आप इसे curl का उपयोग करके परीक्षण कर सकते हैं। curl कमांड बनाने के लिए, आपको तीन मानों की आवश्यकता होगी - एंडपॉइंट, एप्लिकेशन ID (App ID) और एक API कुंजी। ये शीर्ष मेनू से चयनित MANAGE टैब के Settings अनुभाग से एक्सेस किए जा सकते हैं।
1. Settings अनुभाग से App ID कॉपी करें।
Azure Resources सेक्शन से Authoring Resource चुनें, और Primary Key और Endpoint URL कॉपी करें।
अपने कमांड प्रॉम्प्ट या टर्मिनल में निम्नलिखित curl कमांड चलाएं:
```
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> को Azure Resources सेक्शन से प्राप्त Endpoint URL से बदलें।

<app id> को Settings सेक्शन से प्राप्त App ID से बदलें।

<primary key> को Azure Resources सेक्शन से प्राप्त Primary Key से बदलें।

<sentence> को उस वाक्य से बदलें जिसे आप टेस्ट करना चाहते हैं।

इस कॉल का आउटपुट एक JSON डॉक्यूमेंट होगा, जिसमें क्वेरी, टॉप इंटेंट, और विभिन्न प्रकार के एंटिटी की सूची होगी।

{
    "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 set a timer for 45 minutes and 12 seconds क्वेरी से प्राप्त हुआ है:

set timer टॉप इंटेंट था, जिसकी संभावना 97% थी।
दो number एंटिटी डिटेक्ट हुईं, 45 और 12।
दो time-unit एंटिटी डिटेक्ट हुईं, minute और second।

भाषा समझने वाले मॉडल का उपयोग करें

एक बार प्रकाशित होने के बाद, LUIS मॉडल को कोड से कॉल किया जा सकता है। पिछले पाठों में, आपने IoT Hub का उपयोग क्लाउड सेवाओं के साथ संचार के लिए किया था, टेलीमेट्री भेजने और कमांड सुनने के लिए। यह बहुत असिंक्रोनस है - एक बार टेलीमेट्री भेजने के बाद आपका कोड प्रतिक्रिया का इंतजार नहीं करता, और यदि क्लाउड सेवा डाउन है, तो आपको पता नहीं चलेगा।

एक स्मार्ट टाइमर के लिए, हमें तुरंत प्रतिक्रिया चाहिए, ताकि हम उपयोगकर्ता को बता सकें कि टाइमर सेट हो गया है, या उन्हें सूचित कर सकें कि क्लाउड सेवाएं उपलब्ध नहीं हैं। ऐसा करने के लिए, हमारा IoT डिवाइस सीधे एक वेब एंडपॉइंट को कॉल करेगा, IoT Hub पर निर्भर रहने के बजाय।

LUIS को IoT डिवाइस से कॉल करने के बजाय, आप एक अलग प्रकार के ट्रिगर के साथ सर्वरलेस कोड का उपयोग कर सकते हैं - एक HTTP ट्रिगर। यह आपके फंक्शन ऐप को REST अनुरोधों को सुनने और उनका जवाब देने की अनुमति देता है। यह फंक्शन एक REST एंडपॉइंट होगा जिसे आपका डिवाइस कॉल कर सकता है।

💁 हालांकि आप LUIS को सीधे अपने IoT डिवाइस से कॉल कर सकते हैं, सर्वरलेस कोड जैसी चीज़ का उपयोग करना बेहतर है। इस तरह, जब आप बेहतर मॉडल ट्रेन करते हैं या किसी अन्य भाषा में मॉडल ट्रेन करते हैं, तो आपको केवल अपने क्लाउड कोड को अपडेट करना होगा, न कि हजारों या लाखों IoT डिवाइसों पर कोड को फिर से डिप्लॉय करना।

कार्य - एक सर्वरलेस फंक्शन ऐप बनाएं

smart-timer-trigger नामक एक Azure Functions ऐप बनाएं, और इसे VS Code में खोलें।
इस ऐप में speech-trigger नामक एक HTTP ट्रिगर जोड़ें, निम्नलिखित कमांड का उपयोग करके, जो आप VS Code टर्मिनल के अंदर चलाएंगे:
```
func new --name text-to-timer --template "HTTP trigger"
```
यह text-to-timer नामक एक HTTP ट्रिगर बनाएगा।
फंक्शन ऐप चलाकर HTTP ट्रिगर का परीक्षण करें। जब यह चलेगा, तो आउटपुट में एंडपॉइंट सूचीबद्ध होगा:
```
Functions:

        text-to-timer: [GET,POST] http://localhost:7071/api/text-to-timer
```
इसे अपने ब्राउज़र में http://localhost:7071/api/text-to-timer URL लोड करके टेस्ट करें।
```
This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.
```

कार्य - भाषा समझने वाले मॉडल का उपयोग करें

LUIS के लिए SDK एक Pip पैकेज के माध्यम से उपलब्ध है। इस पैकेज पर निर्भरता जोड़ने के लिए requirements.txt फाइल में निम्नलिखित लाइन जोड़ें:
```
azure-cognitiveservices-language-luis
```
सुनिश्चित करें कि VS Code टर्मिनल में वर्चुअल एनवायरनमेंट सक्रिय है, और Pip पैकेज इंस्टॉल करने के लिए निम्नलिखित कमांड चलाएं:
```
pip install -r requirements.txt
```
💁 यदि आपको त्रुटियां मिलती हैं, तो आपको निम्नलिखित कमांड का उपयोग करके pip को अपग्रेड करने की आवश्यकता हो सकती है:
```
pip install --upgrade pip
```
LUIS पोर्टल के MANAGE टैब से अपने LUIS API Key, Endpoint URL, और App ID के लिए local.settings.json फाइल में नए एंट्री जोड़ें:
```
"LUIS_KEY": "<primary key>",
"LUIS_ENDPOINT_URL": "<endpoint url>",
"LUIS_APP_ID": "<app id>"
```
<endpoint url> को MANAGE टैब के Azure Resources सेक्शन से प्राप्त Endpoint URL से बदलें। यह https://<location>.api.cognitive.microsoft.com/ होगा।

<app id> को MANAGE टैब के Settings सेक्शन से प्राप्त App ID से बदलें।

<primary key> को MANAGE टैब के Azure Resources सेक्शन से प्राप्त Primary Key से बदलें।
__init__.py फाइल में निम्नलिखित इंपोर्ट जोड़ें:
```
import json
import os
from azure.cognitiveservices.language.luis.runtime import LUISRuntimeClient
from msrest.authentication import CognitiveServicesCredentials
```
यह कुछ सिस्टम लाइब्रेरी और 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)
```
यह आपके LUIS ऐप के लिए local.settings.json फाइल में जोड़े गए मानों को लोड करता है, आपके API Key के साथ एक क्रेडेंशियल ऑब्जेक्ट बनाता है, और आपके LUIS ऐप के साथ इंटरैक्ट करने के लिए एक LUIS क्लाइंट ऑब्जेक्ट बनाता है।
यह HTTP ट्रिगर JSON के रूप में समझने के लिए टेक्स्ट पास करते हुए कॉल किया जाएगा, जिसमें टेक्स्ट text नामक प्रॉपर्टी में होगा। HTTP अनुरोध के बॉडी से मान निकालने और इसे कंसोल में लॉग करने के लिए निम्नलिखित कोड main फंक्शन में जोड़ें:
```
req_body = req.get_json()
text = req_body['text']
logging.info(f'Request - {text}')
```
भविष्यवाणियां LUIS से एक प्रेडिक्शन अनुरोध भेजकर मांगी जाती हैं - एक JSON डॉक्यूमेंट जिसमें भविष्यवाणी के लिए टेक्स्ट होता है। इसे निम्नलिखित कोड के साथ बनाएं:
```
prediction_request = { 'query' : text }
```
इस अनुरोध को LUIS पर भेजा जा सकता है, उस स्टेजिंग स्लॉट का उपयोग करते हुए जिसमें आपका ऐप प्रकाशित किया गया था:
```
prediction_response = client.prediction.get_slot_prediction(app_id, 'Staging', prediction_request)
```
प्रेडिक्शन प्रतिक्रिया में टॉप इंटेंट होता है - सबसे अधिक प्रेडिक्शन स्कोर वाला इंटेंट, साथ ही एंटिटी। यदि टॉप इंटेंट set 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 एंटिटी एक नंबरों की सूची होगी। उदाहरण के लिए, यदि आपने कहा "Set a four minute 17 second timer.", तो number सूची में 2 पूर्णांक होंगे - 4 और 17।

time unit एंटिटी स्ट्रिंग्स की सूची की सूची होगी, जिसमें प्रत्येक समय इकाई एक सूची के अंदर होगी। उदाहरण के लिए, यदि आपने कहा "Set a four minute 17 second timer.", तो time unit सूची में 2 सूचियां होंगी, जिनमें प्रत्येक में एक मान होगा - ['minute'] और ['second']।

"Set a four minute 17 second timer." के लिए इन एंटिटी का JSON संस्करण है:
```
{
    "number": [4, 17],
    "time unit": [
        ["minute"],
        ["second"]
    ]
}
```
यह कोड टाइमर के लिए कुल समय को सेकंड में परिभाषित करता है। इसे एंटिटी से प्राप्त मानों द्वारा भरा जाएगा।
एंटिटी लिंक नहीं होती हैं, लेकिन हम उनके बारे में कुछ धारणाएं कर सकते हैं। वे बोले गए क्रम में होंगी, इसलिए सूची में स्थिति का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि कौन सा नंबर किस समय इकाई से मेल खाता है। उदाहरण के लिए:
- "Set a 30 second timer" - इसमें एक नंबर, 30, और एक समय इकाई, second होगी, इसलिए एकल नंबर एकल समय इकाई से मेल खाएगा।
- "Set a 2 minute and 30 second timer" - इसमें दो नंबर, 2 और 30, और दो समय इकाइयां, minute और second होंगी, इसलिए पहला नंबर पहली समय इकाई के लिए होगा (2 मिनट), और दूसरा नंबर दूसरी समय इकाई के लिए (30 सेकंड)।
निम्नलिखित कोड if ब्लॉक के अंदर जोड़ें:
```
for i in range(0, len(numbers)):
    number = numbers[i]
    time_unit = time_units[i][0]
```
"Set a four minute 17 second timer." के लिए, यह दो बार लूप करेगा, निम्नलिखित मान देगा:

लूप काउंट number time_unit

0 4 minute

1 17 second
इस लूप के अंदर, नंबर और समय इकाई का उपयोग करके टाइमर के लिए कुल समय की गणना करें, प्रत्येक मिनट के लिए 60 सेकंड जोड़ें, और किसी भी सेकंड के लिए सेकंड की संख्या जोड़ें:
```
if time_unit == 'minute':
    total_seconds += number * 60
else:
    total_seconds += number
```
एंटिटी के माध्यम से लूप के बाहर, टाइमर के लिए कुल समय को लॉग करें:
```
logging.info(f'Timer required for {total_seconds} seconds')
```
सेकंड की संख्या को HTTP प्रतिक्रिया के रूप में फंक्शन से वापस करना होगा। if ब्लॉक के अंत में निम्नलिखित जोड़ें:
```
payload = {
    'seconds': total_seconds
}
return func.HttpResponse(json.dumps(payload), status_code=200)
```
यह कोड टाइमर के लिए कुल सेकंड की संख्या वाली पेलोड बनाता है, इसे JSON स्ट्रिंग में बदलता है, और इसे HTTP परिणाम के रूप में 200 की स्थिति कोड के साथ वापस करता है, जिसका अर्थ है कि कॉल सफल रहा।
अंत में, if ब्लॉक के बाहर, यदि इंटेंट पहचाना नहीं गया तो त्रुटि कोड लौटाएं:
```
return func.HttpResponse(status_code=404)
```
404 not found के लिए स्थिति कोड है।

लूप काउंट	`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।

आपको फंक्शन ऐप से निम्नलिखित आउटपुट दिखाई देगा:

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}

टाइमर के लिए सेकंड की संख्या "seconds" मान में होगी।

💁 आप इस कोड को code/functions फोल्डर में पा सकते हैं।

कार्य - अपने IoT डिवाइस के लिए अपना फंक्शन उपलब्ध कराएं

आपके IoT डिवाइस को आपके REST एंडपॉइंट को कॉल करने के लिए URL जानने की आवश्यकता होगी। जब आपने इसे पहले एक्सेस किया था, तो आपने localhost का उपयोग किया था, जो आपके लोकल मशीन पर REST एंडपॉइंट्स तक पहुंचने के लिए एक शॉर्टकट है। आपके IoT डिवाइस को एक्सेस देने के लिए, आपको या तो इसे क्लाउड पर प्रकाशित करना होगा, या इसे लोकल रूप से एक्सेस करने के लिए अपना IP पता प्राप्त करना होगा।

⚠️ यदि आप Wio Terminal का उपयोग कर रहे हैं, तो फंक्शन ऐप को लोकल रूप से चलाना आसान है, क्योंकि इसमें ऐसी लाइब्रेरी पर निर्भरता होगी, जिसका अर्थ है कि आप फंक्शन ऐप को पहले की तरह डिप्लॉय नहीं कर सकते। फंक्शन ऐप को लोकल रूप से चलाएं और अपने कंप्यूटर के IP पते के माध्यम से इसे एक्सेस करें। यदि आप इसे क्लाउड पर डिप्लॉय करना चाहते हैं, तो बाद के पाठ में इसे करने का तरीका प्रदान किया जाएगा।
- फंक्शन ऐप को प्रकाशित करें - अपने फंक्शन ऐप को क्लाउड पर प्रकाशित करने के लिए पहले के पाठों में दिए गए निर्देशों का पालन करें। एक बार प्रकाशित होने के बाद, URL https://<APP_NAME>.azurewebsites.net/api/text-to-timer होगा, जहां <APP_NAME> आपके फंक्शन ऐप का नाम होगा। सुनिश्चित करें कि आपने अपनी लोकल सेटिंग्स भी प्रकाशित की हैं।
  
  HTTP ट्रिगर्स के साथ काम करते समय, वे डिफ़ॉल्ट रूप से एक फंक्शन ऐप कुंजी के साथ सुरक्षित होते हैं। इस कुंजी को प्राप्त करने के लिए निम्नलिखित कमांड चलाएं:
```
az functionapp keys list --resource-group smart-timer \
                         --name <APP_NAME>                               
```
  functionKeys सेक्शन से default एंट्री का मान कॉपी करें।
```
{
  "functionKeys": {
    "default": "sQO1LQaeK9N1qYD6SXeb/TctCmwQEkToLJU6Dw8TthNeUH8VA45hlA=="
  },
  "masterKey": "RSKOAIlyvvQEQt9dfpabJT018scaLpQu9p1poHIMCxx5LYrIQZyQ/g==",
  "systemKeys": {}
}
```
  इस कुंजी को URL में एक क्वेरी पैरामीटर के रूप में जोड़ने की आवश्यकता होगी, इसलिए अंतिम URL https://<APP_NAME>.azurewebsites.net/api/text-to-timer?code=<FUNCTION_KEY> होगा, जहां <APP_NAME> आपके फंक्शन ऐप का नाम होगा, और <FUNCTION_KEY> आपकी डिफ़ॉल्ट फंक्शन कुंजी होगी।
  
  💁 आप HTTP ट्रिगर के प्राधिकरण के प्रकार को function.json फाइल में authlevel सेटिंग का उपयोग करके बदल सकते हैं। आप इसके बारे में अधिक पढ़ सकते हैं Azure Functions HTTP ट्रिगर डाक्यूमेंटेशन के कॉन्फ़िगरेशन सेक्शन में।
- फंक्शन ऐप को लोकल रूप से चलाएं, और IP पते का उपयोग करके एक्सेस करें - आप अपने कंप्यूटर के लोकल नेटवर्क पर IP पता प्राप्त कर सकते हैं, और इसका उपयोग करके URL बना सकते हैं।
  
  अपना IP पता खोजें:
  - Windows 10 पर, अपना IP पता खोजने के लिए गाइड का पालन करें।
  - macOS पर, Mac पर अपना IP पता कैसे खोजें गाइड का पालन करें।
  - Linux पर, Linux में अपना IP पता कैसे खोजें गाइड में अपने प्राइवेट IP पते को खोजने वाले सेक्शन का पालन करें।
  एक बार जब आपको अपना IP पता मिल जाए, तो आप फंक्शन को http://

:7071/api/text-to-timer, जहां <IP_ADDRESS>आपका IP पता होगा, उदाहरण के लिएhttp://192.168.1.10:7071/api/text-to-timer`।

  > 💁 ध्यान दें कि यह पोर्ट 7071 का उपयोग करता है, इसलिए IP पते के बाद आपको `:7071` जोड़ना होगा।

  > 💁 यह केवल तभी काम करेगा जब आपका IoT डिवाइस आपके कंप्यूटर के समान नेटवर्क पर हो।

इस एंडपॉइंट को curl का उपयोग करके एक्सेस करके टेस्ट करें।

🚀 चुनौती

एक ही चीज़ का अनुरोध करने के कई तरीके हो सकते हैं, जैसे कि टाइमर सेट करना। इसके अलग-अलग तरीकों के बारे में सोचें और उन्हें अपने LUIS ऐप में उदाहरण के रूप में उपयोग करें। इन्हें टेस्ट करें, यह देखने के लिए कि आपका मॉडल टाइमर सेट करने के विभिन्न तरीकों को कितनी अच्छी तरह संभाल सकता है।

पोस्ट-लेक्चर क्विज़

समीक्षा और स्व-अध्ययन

LUIS और इसकी क्षमताओं के बारे में अधिक पढ़ें Microsoft डॉक्स पर Language Understanding (LUIS) दस्तावेज़ पेज पर।
भाषा समझने के बारे में अधिक पढ़ें विकिपीडिया पर प्राकृतिक भाषा समझने के पेज पर।
HTTP ट्रिगर्स के बारे में अधिक पढ़ें Microsoft डॉक्स पर Azure Functions HTTP ट्रिगर दस्तावेज़ पर।

असाइनमेंट

टाइमर रद्द करें

अस्वीकरण:
यह दस्तावेज़ AI अनुवाद सेवा Co-op Translator का उपयोग करके अनुवादित किया गया है। जबकि हम सटीकता सुनिश्चित करने का प्रयास करते हैं, कृपया ध्यान दें कि स्वचालित अनुवाद में त्रुटियां या अशुद्धियां हो सकती हैं। मूल भाषा में उपलब्ध मूल दस्तावेज़ को प्रामाणिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम उत्तरदायी नहीं हैं।

58 KiB Raw Permalink Blame History