You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
572 lines
58 KiB
572 lines
58 KiB
<!--
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
{
|
|
"original_hash": "6f4ba69d77f16c4a5110623a96a215c3",
|
|
"translation_date": "2025-08-25T17:40:34+00:00",
|
|
"source_file": "6-consumer/lessons/2-language-understanding/README.md",
|
|
"language_code": "hi"
|
|
}
|
|
-->
|
|
# भाषा को समझें
|
|
|
|
|
|
|
|
> स्केच नोट [नित्या नरसिम्हन](https://github.com/nitya) द्वारा। बड़े संस्करण के लिए छवि पर क्लिक करें।
|
|
|
|
## व्याख्यान से पहले का क्विज़
|
|
|
|
[व्याख्यान से पहले का क्विज़](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/43)
|
|
|
|
## परिचय
|
|
|
|
पिछले पाठ में आपने आवाज़ को टेक्स्ट में बदला। इसे एक स्मार्ट टाइमर प्रोग्राम करने के लिए उपयोग करने के लिए, आपके कोड को यह समझने की आवश्यकता होगी कि क्या कहा गया। आप मान सकते हैं कि उपयोगकर्ता एक निश्चित वाक्यांश बोलेगा, जैसे "3 मिनट का टाइमर सेट करें", और उस वाक्यांश को पार्स करके यह पता लगाएंगे कि टाइमर कितने समय के लिए होना चाहिए, लेकिन यह बहुत उपयोगकर्ता-अनुकूल नहीं है। यदि कोई उपयोगकर्ता कहे "3 मिनट के लिए टाइमर सेट करें", तो आप या मैं समझ जाएंगे कि उनका क्या मतलब है, लेकिन आपका कोड नहीं समझेगा, क्योंकि वह एक निश्चित वाक्यांश की अपेक्षा कर रहा होगा।
|
|
|
|
यहीं पर भाषा समझने की तकनीक काम आती है, जो AI मॉडल का उपयोग करके टेक्स्ट की व्याख्या करती है और आवश्यक विवरण लौटाती है। उदाहरण के लिए, "3 मिनट का टाइमर सेट करें" और "3 मिनट के लिए टाइमर सेट करें" दोनों को समझना कि 3 मिनट के लिए एक टाइमर की आवश्यकता है।
|
|
|
|
इस पाठ में आप भाषा समझने वाले मॉडल के बारे में जानेंगे, उन्हें कैसे बनाना, प्रशिक्षित करना और अपने कोड में उपयोग करना।
|
|
|
|
इस पाठ में हम कवर करेंगे:
|
|
|
|
* [भाषा समझना](../../../../../6-consumer/lessons/2-language-understanding)
|
|
* [भाषा समझने का मॉडल बनाएं](../../../../../6-consumer/lessons/2-language-understanding)
|
|
* [इरादे और इकाइयाँ](../../../../../6-consumer/lessons/2-language-understanding)
|
|
* [भाषा समझने के मॉडल का उपयोग करें](../../../../../6-consumer/lessons/2-language-understanding)
|
|
|
|
## भाषा समझना
|
|
|
|
मनुष्य हजारों वर्षों से संवाद करने के लिए भाषा का उपयोग कर रहे हैं। हम शब्दों, ध्वनियों, या क्रियाओं के माध्यम से संवाद करते हैं और यह समझते हैं कि क्या कहा गया, न केवल शब्दों, ध्वनियों या क्रियाओं का अर्थ, बल्कि उनका संदर्भ भी। हम ईमानदारी और व्यंग्य को समझते हैं, जिससे एक ही शब्द अलग-अलग स्वर के आधार पर अलग-अलग अर्थ रख सकते हैं।
|
|
|
|
✅ हाल ही में हुई कुछ बातचीतों के बारे में सोचें। कितनी बातचीत कंप्यूटर के लिए समझना मुश्किल होगी क्योंकि उसे संदर्भ की आवश्यकता है?
|
|
|
|
भाषा समझना, जिसे प्राकृतिक भाषा समझना भी कहा जाता है, कृत्रिम बुद्धिमत्ता के एक क्षेत्र का हिस्सा है जिसे प्राकृतिक भाषा प्रसंस्करण (NLP) कहा जाता है। यह पढ़ने और समझने की क्षमता से संबंधित है, जिसमें शब्दों या वाक्यों के विवरण को समझने की कोशिश की जाती है। यदि आप एलेक्सा या सिरी जैसे वॉयस असिस्टेंट का उपयोग करते हैं, तो आपने भाषा समझने वाली सेवाओं का उपयोग किया है। ये वे AI सेवाएँ हैं जो "एलेक्सा, टेलर स्विफ्ट का नवीनतम एल्बम चलाओ" को मेरी बेटी के लिविंग रूम में अपने पसंदीदा गानों पर नाचने में बदल देती हैं।
|
|
|
|
> 💁 कंप्यूटर, अपनी सभी प्रगति के बावजूद, टेक्स्ट को वास्तव में समझने में अभी भी बहुत पीछे हैं। जब हम कंप्यूटर के साथ भाषा समझने की बात करते हैं, तो हमारा मतलब मानव संचार जितना उन्नत कुछ भी नहीं होता, बल्कि हमारा मतलब कुछ शब्दों को लेकर मुख्य विवरण निकालने से होता है।
|
|
|
|
मनुष्य के रूप में, हम बिना सोचे-समझे भाषा को समझते हैं। यदि मैं किसी अन्य व्यक्ति से "टेलर स्विफ्ट का नवीनतम एल्बम चलाओ" कहूं, तो वे स्वाभाविक रूप से समझ जाएंगे कि मेरा क्या मतलब है। कंप्यूटर के लिए, यह कठिन है। उसे शब्दों को लेना होगा, जो आवाज़ से टेक्स्ट में बदले गए हैं, और निम्नलिखित जानकारी के टुकड़ों को समझना होगा:
|
|
|
|
* संगीत चलाना है
|
|
* संगीत कलाकार टेलर स्विफ्ट का है
|
|
* विशेष संगीत एक पूरे एल्बम का है जिसमें कई ट्रैक क्रम में हैं
|
|
* टेलर स्विफ्ट के कई एल्बम हैं, इसलिए उन्हें कालानुक्रमिक क्रम में व्यवस्थित करना होगा और सबसे हाल ही में प्रकाशित एल्बम की आवश्यकता है
|
|
|
|
✅ उन अन्य वाक्यों के बारे में सोचें जो आपने अनुरोध करते समय बोले हैं, जैसे कॉफी ऑर्डर करना या किसी परिवार के सदस्य से कुछ पास करने के लिए कहना। उन्हें उन जानकारी के टुकड़ों में तोड़ने की कोशिश करें जिन्हें कंप्यूटर को वाक्य को समझने के लिए निकालने की आवश्यकता होगी।
|
|
|
|
भाषा समझने वाले मॉडल AI मॉडल हैं जिन्हें भाषा से कुछ विवरण निकालने के लिए प्रशिक्षित किया जाता है, और फिर उन्हें स्थानांतरित शिक्षण (transfer learning) का उपयोग करके विशिष्ट कार्यों के लिए प्रशिक्षित किया जाता है, जैसे आपने कस्टम विज़न मॉडल को छवियों के एक छोटे सेट का उपयोग करके प्रशिक्षित किया था। आप एक मॉडल ले सकते हैं, फिर उसे उस टेक्स्ट का उपयोग करके प्रशिक्षित कर सकते हैं जिसे आप समझना चाहते हैं।
|
|
|
|
## भाषा समझने का मॉडल बनाएं
|
|
|
|
|
|
|
|
आप LUIS (Language Understanding Intelligent Service) का उपयोग करके भाषा समझने वाले मॉडल बना सकते हैं, जो Microsoft की एक सेवा है और Cognitive Services का हिस्सा है।
|
|
|
|
### कार्य - एक ऑथरिंग संसाधन बनाएं
|
|
|
|
LUIS का उपयोग करने के लिए, आपको एक ऑथरिंग संसाधन बनाना होगा।
|
|
|
|
1. अपने `smart-timer` संसाधन समूह में एक ऑथरिंग संसाधन बनाने के लिए निम्नलिखित कमांड का उपयोग करें:
|
|
|
|
```python
|
|
az cognitiveservices account create --name smart-timer-luis-authoring \
|
|
--resource-group smart-timer \
|
|
--kind LUIS.Authoring \
|
|
--sku F0 \
|
|
--yes \
|
|
--location <location>
|
|
```
|
|
|
|
`<location>` को उस स्थान से बदलें जिसे आपने संसाधन समूह बनाते समय उपयोग किया था।
|
|
|
|
> ⚠️ LUIS सभी क्षेत्रों में उपलब्ध नहीं है, इसलिए यदि आपको निम्नलिखित त्रुटि मिलती है:
|
|
>
|
|
> ```output
|
|
> InvalidApiSetId: The account type 'LUIS.Authoring' is either invalid or unavailable in given region.
|
|
> ```
|
|
>
|
|
> तो एक अलग क्षेत्र चुनें।
|
|
|
|
यह एक मुफ्त-स्तरीय LUIS ऑथरिंग संसाधन बनाएगा।
|
|
|
|
### कार्य - एक भाषा समझने वाला ऐप बनाएं
|
|
|
|
1. अपने ब्राउज़र में [luis.ai](https://luis.ai?WT.mc_id=academic-17441-jabenn) पोर्टल खोलें और उसी खाते से साइन इन करें जिसे आप Azure के लिए उपयोग कर रहे हैं।
|
|
|
|
1. डायलॉग पर दिए गए निर्देशों का पालन करें, अपनी Azure सदस्यता का चयन करें, फिर उस `smart-timer-luis-authoring` संसाधन का चयन करें जिसे आपने अभी बनाया है।
|
|
|
|
1. *Conversation apps* सूची से, **New app** बटन का चयन करें और एक नया ऐप बनाएं। नए ऐप का नाम `smart-timer` रखें और *Culture* को अपनी भाषा पर सेट करें।
|
|
|
|
> 💁 भविष्यवाणी संसाधन के लिए एक फ़ील्ड है। आप केवल भविष्यवाणी के लिए एक दूसरा संसाधन बना सकते हैं, लेकिन मुफ्त ऑथरिंग संसाधन प्रति माह 1,000 भविष्यवाणियाँ प्रदान करता है, जो विकास के लिए पर्याप्त होना चाहिए, इसलिए आप इसे खाली छोड़ सकते हैं।
|
|
|
|
1. ऐप बनाने के बाद जो गाइड दिखाई देता है, उसे पढ़ें ताकि आप भाषा समझने वाले मॉडल को प्रशिक्षित करने के चरणों को समझ सकें। जब आप गाइड पढ़ लें, तो इसे बंद कर दें।
|
|
|
|
## इरादे और इकाइयाँ
|
|
|
|
भाषा समझना *इरादों* और *इकाइयों* पर आधारित है। इरादे शब्दों के उद्देश्य को दर्शाते हैं, जैसे संगीत चलाना, टाइमर सेट करना, या खाना ऑर्डर करना। इकाइयाँ वह होती हैं जिनका इरादा संदर्भित करता है, जैसे एल्बम, टाइमर की अवधि, या भोजन का प्रकार। मॉडल द्वारा व्याख्या किए गए प्रत्येक वाक्य में कम से कम एक इरादा और वैकल्पिक रूप से एक या अधिक इकाइयाँ होनी चाहिए।
|
|
|
|
कुछ उदाहरण:
|
|
|
|
| वाक्य | इरादा | इकाइयाँ |
|
|
| --------------------------------------------------- | ----------------- | ------------------------------------------ |
|
|
| "टेलर स्विफ्ट का नवीनतम एल्बम चलाओ" | *संगीत चलाना* | *टेलर स्विफ्ट का नवीनतम एल्बम* |
|
|
| "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](https://docs.microsoft.com/azure/cognitive-services/luis/luis-get-started-create-app?WT.mc_id=academic-17441-jabenn) में पाए जा सकते हैं।
|
|
|
|
1. LUIS पोर्टल से, *Entities* टैब का चयन करें और **Add prebuilt entity** बटन का उपयोग करके *number* प्रीबिल्ट इकाई जोड़ें। सूची से *number* का चयन करें।
|
|
|
|
1. समय इकाई के लिए एक नई इकाई बनाएं। **Create** बटन का उपयोग करें। इकाई का नाम `time unit` रखें और प्रकार *List* पर सेट करें। *Normalized values* सूची में `minute` और `second` के लिए मान जोड़ें, और *synonyms* सूची में उनके एकवचन और बहुवचन रूप जोड़ें। प्रत्येक पर्याय जोड़ने के बाद `return` दबाएँ।
|
|
|
|
| Normalized value | Synonyms |
|
|
| ---------------- | --------------- |
|
|
| minute | minute, minutes |
|
|
| second | second, seconds |
|
|
|
|
### कार्य - भाषा समझने वाले मॉडल में इरादे जोड़ें
|
|
|
|
1. *Intents* टैब से, **Create** बटन का चयन करें और एक नया इरादा बनाएं। इस इरादे का नाम `set timer` रखें।
|
|
|
|
1. उदाहरणों में, टाइमर सेट करने के विभिन्न तरीकों को दर्ज करें, जिनमें मिनट, सेकंड और मिनट और सेकंड का संयोजन शामिल हो। उदाहरण हो सकते हैं:
|
|
|
|
* `1 सेकंड का टाइमर सेट करें`
|
|
* `4 मिनट का टाइमर सेट करें`
|
|
* `चार मिनट छह सेकंड का टाइमर सेट करें`
|
|
* `9 मिनट 30 सेकंड का टाइमर सेट करें`
|
|
* `1 मिनट और 12 सेकंड के लिए टाइमर सेट करें`
|
|
* `3 मिनट के लिए टाइमर सेट करें`
|
|
* `3 मिनट और 1 सेकंड के लिए टाइमर सेट करें`
|
|
* `तीन मिनट और एक सेकंड के लिए टाइमर सेट करें`
|
|
* `1 मिनट और 1 सेकंड के लिए टाइमर सेट करें`
|
|
* `30 सेकंड के लिए टाइमर सेट करें`
|
|
* `1 सेकंड के लिए टाइमर सेट करें`
|
|
|
|
मॉडल को दोनों शब्दों और अंकों को संभालने के लिए प्रशिक्षित करने के लिए शब्दों और अंकों को मिलाएँ।
|
|
|
|
1. प्रत्येक उदाहरण दर्ज करते समय, LUIS इकाइयों का पता लगाना शुरू कर देगा और किसी भी पाए गए इकाई को रेखांकित और लेबल करेगा।
|
|
|
|
|
|
|
|
### कार्य - मॉडल को प्रशिक्षित और परीक्षण करें
|
|
|
|
1. इकाइयों और इरादों को कॉन्फ़िगर करने के बाद, आप शीर्ष मेनू में **Train** बटन का उपयोग करके मॉडल को प्रशिक्षित कर सकते हैं। इस बटन का चयन करें, और मॉडल कुछ सेकंड में प्रशिक्षित हो जाएगा। प्रशिक्षण के दौरान बटन ग्रे हो जाएगा और प्रशिक्षण पूरा होने के बाद फिर से सक्रिय हो जाएगा।
|
|
|
|
1. शीर्ष मेनू से **Test** बटन का चयन करें और भाषा समझने वाले मॉडल का परीक्षण करें। `5 मिनट और 4 सेकंड के लिए टाइमर सेट करें` जैसे टेक्स्ट दर्ज करें और रिटर्न दबाएँ। वाक्य उस टेक्स्ट बॉक्स के नीचे दिखाई देगा जिसमें आपने इसे टाइप किया था, और उसके नीचे *top intent* होगा, या वह इरादा जिसे सबसे अधिक संभावना के साथ पहचाना गया। यह `set timer` होना चाहिए। इरादे का नाम उसके सही होने की संभावना के प्रतिशत के साथ होगा।
|
|
|
|
1. परिणामों का ब्रेकडाउन देखने के लिए **Inspect** विकल्प का चयन करें। आप शीर्ष स्कोरिंग इरादे को उसकी प्रतिशत संभावना के साथ देखेंगे, साथ ही पहचानी गई इकाइयों की सूची भी।
|
|
|
|
1. परीक्षण समाप्त करने के बाद *Test* पैन को बंद करें।
|
|
|
|
### कार्य - मॉडल को प्रकाशित करें
|
|
|
|
इस मॉडल का कोड से उपयोग करने के लिए, आपको इसे प्रकाशित करना होगा। LUIS से प्रकाशित करते समय, आप इसे परीक्षण के लिए एक स्टेजिंग वातावरण या पूर्ण रिलीज़ के लिए एक प्रोडक्ट वातावरण में प्रकाशित कर सकते हैं। इस पाठ में, स्टेजिंग वातावरण पर्याप्त है।
|
|
|
|
1. LUIS पोर्टल से, शीर्ष मेनू से **Publish** बटन का चयन करें।
|
|
|
|
1. सुनिश्चित करें कि *Staging slot* चयनित है, फिर **Done** का चयन करें। ऐप प्रकाशित होने पर आपको एक सूचना दिखाई देगी।
|
|
|
|
1. आप इसे curl का उपयोग करके परीक्षण कर सकते हैं। curl कमांड बनाने के लिए, आपको तीन मानों की आवश्यकता होगी - एंडपॉइंट, एप्लिकेशन ID (App ID) और एक API कुंजी। ये शीर्ष मेनू से चयनित **MANAGE** टैब के *Settings* अनुभाग से एक्सेस किए जा सकते हैं।
|
|
|
|
1. *Settings* अनुभाग से App ID कॉपी करें।
|
|
1. *Azure Resources* सेक्शन से *Authoring Resource* चुनें, और *Primary Key* और *Endpoint URL* कॉपी करें।
|
|
|
|
1. अपने कमांड प्रॉम्प्ट या टर्मिनल में निम्नलिखित curl कमांड चलाएं:
|
|
|
|
```sh
|
|
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>` को उस वाक्य से बदलें जिसे आप टेस्ट करना चाहते हैं।
|
|
|
|
1. इस कॉल का आउटपुट एक JSON डॉक्यूमेंट होगा, जिसमें क्वेरी, टॉप इंटेंट, और विभिन्न प्रकार के एंटिटी की सूची होगी।
|
|
|
|
```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 डिवाइसों पर कोड को फिर से डिप्लॉय करना।
|
|
|
|
### कार्य - एक सर्वरलेस फंक्शन ऐप बनाएं
|
|
|
|
1. `smart-timer-trigger` नामक एक Azure Functions ऐप बनाएं, और इसे VS Code में खोलें।
|
|
|
|
1. इस ऐप में `speech-trigger` नामक एक HTTP ट्रिगर जोड़ें, निम्नलिखित कमांड का उपयोग करके, जो आप VS Code टर्मिनल के अंदर चलाएंगे:
|
|
|
|
```sh
|
|
func new --name text-to-timer --template "HTTP trigger"
|
|
```
|
|
|
|
यह `text-to-timer` नामक एक HTTP ट्रिगर बनाएगा।
|
|
|
|
1. फंक्शन ऐप चलाकर HTTP ट्रिगर का परीक्षण करें। जब यह चलेगा, तो आउटपुट में एंडपॉइंट सूचीबद्ध होगा:
|
|
|
|
```output
|
|
Functions:
|
|
|
|
text-to-timer: [GET,POST] http://localhost:7071/api/text-to-timer
|
|
```
|
|
|
|
इसे अपने ब्राउज़र में [http://localhost:7071/api/text-to-timer](http://localhost:7071/api/text-to-timer) URL लोड करके टेस्ट करें।
|
|
|
|
```output
|
|
This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.
|
|
```
|
|
|
|
### कार्य - भाषा समझने वाले मॉडल का उपयोग करें
|
|
|
|
1. LUIS के लिए SDK एक Pip पैकेज के माध्यम से उपलब्ध है। इस पैकेज पर निर्भरता जोड़ने के लिए `requirements.txt` फाइल में निम्नलिखित लाइन जोड़ें:
|
|
|
|
```sh
|
|
azure-cognitiveservices-language-luis
|
|
```
|
|
|
|
1. सुनिश्चित करें कि VS Code टर्मिनल में वर्चुअल एनवायरनमेंट सक्रिय है, और Pip पैकेज इंस्टॉल करने के लिए निम्नलिखित कमांड चलाएं:
|
|
|
|
```sh
|
|
pip install -r requirements.txt
|
|
```
|
|
|
|
> 💁 यदि आपको त्रुटियां मिलती हैं, तो आपको निम्नलिखित कमांड का उपयोग करके pip को अपग्रेड करने की आवश्यकता हो सकती है:
|
|
>
|
|
> ```sh
|
|
> pip install --upgrade pip
|
|
> ```
|
|
|
|
1. LUIS पोर्टल के **MANAGE** टैब से अपने LUIS API Key, Endpoint URL, और App ID के लिए `local.settings.json` फाइल में नए एंट्री जोड़ें:
|
|
|
|
```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 से बदलें।
|
|
|
|
1. `__init__.py` फाइल में निम्नलिखित इंपोर्ट जोड़ें:
|
|
|
|
```python
|
|
import json
|
|
import os
|
|
from azure.cognitiveservices.language.luis.runtime import LUISRuntimeClient
|
|
from msrest.authentication import CognitiveServicesCredentials
|
|
```
|
|
|
|
यह कुछ सिस्टम लाइब्रेरी और LUIS के साथ इंटरैक्ट करने के लिए लाइब्रेरी इंपोर्ट करता है।
|
|
|
|
1. `main` मेथड की सामग्री को डिलीट करें, और निम्नलिखित कोड जोड़ें:
|
|
|
|
```python
|
|
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 क्लाइंट ऑब्जेक्ट बनाता है।
|
|
|
|
1. यह HTTP ट्रिगर JSON के रूप में समझने के लिए टेक्स्ट पास करते हुए कॉल किया जाएगा, जिसमें टेक्स्ट `text` नामक प्रॉपर्टी में होगा। HTTP अनुरोध के बॉडी से मान निकालने और इसे कंसोल में लॉग करने के लिए निम्नलिखित कोड `main` फंक्शन में जोड़ें:
|
|
|
|
```python
|
|
req_body = req.get_json()
|
|
text = req_body['text']
|
|
logging.info(f'Request - {text}')
|
|
```
|
|
|
|
1. भविष्यवाणियां LUIS से एक प्रेडिक्शन अनुरोध भेजकर मांगी जाती हैं - एक JSON डॉक्यूमेंट जिसमें भविष्यवाणी के लिए टेक्स्ट होता है। इसे निम्नलिखित कोड के साथ बनाएं:
|
|
|
|
```python
|
|
prediction_request = { 'query' : text }
|
|
```
|
|
|
|
1. इस अनुरोध को LUIS पर भेजा जा सकता है, उस स्टेजिंग स्लॉट का उपयोग करते हुए जिसमें आपका ऐप प्रकाशित किया गया था:
|
|
|
|
```python
|
|
prediction_response = client.prediction.get_slot_prediction(app_id, 'Staging', prediction_request)
|
|
```
|
|
|
|
1. प्रेडिक्शन प्रतिक्रिया में टॉप इंटेंट होता है - सबसे अधिक प्रेडिक्शन स्कोर वाला इंटेंट, साथ ही एंटिटी। यदि टॉप इंटेंट `set timer` है, तो एंटिटी को पढ़कर टाइमर के लिए आवश्यक समय प्राप्त किया जा सकता है:
|
|
|
|
```python
|
|
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 संस्करण है:
|
|
|
|
```json
|
|
{
|
|
"number": [4, 17],
|
|
"time unit": [
|
|
["minute"],
|
|
["second"]
|
|
]
|
|
}
|
|
```
|
|
|
|
यह कोड टाइमर के लिए कुल समय को सेकंड में परिभाषित करता है। इसे एंटिटी से प्राप्त मानों द्वारा भरा जाएगा।
|
|
|
|
1. एंटिटी लिंक नहीं होती हैं, लेकिन हम उनके बारे में कुछ धारणाएं कर सकते हैं। वे बोले गए क्रम में होंगी, इसलिए सूची में स्थिति का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि कौन सा नंबर किस समय इकाई से मेल खाता है। उदाहरण के लिए:
|
|
|
|
* *"Set a 30 second timer"* - इसमें एक नंबर, `30`, और एक समय इकाई, `second` होगी, इसलिए एकल नंबर एकल समय इकाई से मेल खाएगा।
|
|
* *"Set a 2 minute and 30 second timer"* - इसमें दो नंबर, `2` और `30`, और दो समय इकाइयां, `minute` और `second` होंगी, इसलिए पहला नंबर पहली समय इकाई के लिए होगा (2 मिनट), और दूसरा नंबर दूसरी समय इकाई के लिए (30 सेकंड)।
|
|
|
|
निम्नलिखित कोड `if` ब्लॉक के अंदर जोड़ें:
|
|
|
|
```python
|
|
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 |
|
|
|
|
1. इस लूप के अंदर, नंबर और समय इकाई का उपयोग करके टाइमर के लिए कुल समय की गणना करें, प्रत्येक मिनट के लिए 60 सेकंड जोड़ें, और किसी भी सेकंड के लिए सेकंड की संख्या जोड़ें:
|
|
|
|
```python
|
|
if time_unit == 'minute':
|
|
total_seconds += number * 60
|
|
else:
|
|
total_seconds += number
|
|
```
|
|
|
|
1. एंटिटी के माध्यम से लूप के बाहर, टाइमर के लिए कुल समय को लॉग करें:
|
|
|
|
```python
|
|
logging.info(f'Timer required for {total_seconds} seconds')
|
|
```
|
|
|
|
1. सेकंड की संख्या को HTTP प्रतिक्रिया के रूप में फंक्शन से वापस करना होगा। `if` ब्लॉक के अंत में निम्नलिखित जोड़ें:
|
|
|
|
```python
|
|
payload = {
|
|
'seconds': total_seconds
|
|
}
|
|
return func.HttpResponse(json.dumps(payload), status_code=200)
|
|
```
|
|
|
|
यह कोड टाइमर के लिए कुल सेकंड की संख्या वाली पेलोड बनाता है, इसे JSON स्ट्रिंग में बदलता है, और इसे HTTP परिणाम के रूप में 200 की स्थिति कोड के साथ वापस करता है, जिसका अर्थ है कि कॉल सफल रहा।
|
|
|
|
1. अंत में, `if` ब्लॉक के बाहर, यदि इंटेंट पहचाना नहीं गया तो त्रुटि कोड लौटाएं:
|
|
|
|
```python
|
|
return func.HttpResponse(status_code=404)
|
|
```
|
|
|
|
404 *not found* के लिए स्थिति कोड है।
|
|
|
|
1. फंक्शन ऐप चलाएं और इसे curl का उपयोग करके टेस्ट करें।
|
|
|
|
```sh
|
|
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 का कॉल निम्नलिखित लौटाएगा:
|
|
|
|
```output
|
|
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](../../../../../6-consumer/lessons/2-language-understanding/code/functions) फोल्डर में पा सकते हैं।
|
|
|
|
### कार्य - अपने IoT डिवाइस के लिए अपना फंक्शन उपलब्ध कराएं
|
|
|
|
1. आपके IoT डिवाइस को आपके REST एंडपॉइंट को कॉल करने के लिए URL जानने की आवश्यकता होगी। जब आपने इसे पहले एक्सेस किया था, तो आपने `localhost` का उपयोग किया था, जो आपके लोकल मशीन पर REST एंडपॉइंट्स तक पहुंचने के लिए एक शॉर्टकट है। आपके IoT डिवाइस को एक्सेस देने के लिए, आपको या तो इसे क्लाउड पर प्रकाशित करना होगा, या इसे लोकल रूप से एक्सेस करने के लिए अपना IP पता प्राप्त करना होगा।
|
|
|
|
> ⚠️ यदि आप Wio Terminal का उपयोग कर रहे हैं, तो फंक्शन ऐप को लोकल रूप से चलाना आसान है, क्योंकि इसमें ऐसी लाइब्रेरी पर निर्भरता होगी, जिसका अर्थ है कि आप फंक्शन ऐप को पहले की तरह डिप्लॉय नहीं कर सकते। फंक्शन ऐप को लोकल रूप से चलाएं और अपने कंप्यूटर के IP पते के माध्यम से इसे एक्सेस करें। यदि आप इसे क्लाउड पर डिप्लॉय करना चाहते हैं, तो बाद के पाठ में इसे करने का तरीका प्रदान किया जाएगा।
|
|
|
|
* फंक्शन ऐप को प्रकाशित करें - अपने फंक्शन ऐप को क्लाउड पर प्रकाशित करने के लिए पहले के पाठों में दिए गए निर्देशों का पालन करें। एक बार प्रकाशित होने के बाद, URL `https://<APP_NAME>.azurewebsites.net/api/text-to-timer` होगा, जहां `<APP_NAME>` आपके फंक्शन ऐप का नाम होगा। सुनिश्चित करें कि आपने अपनी लोकल सेटिंग्स भी प्रकाशित की हैं।
|
|
|
|
HTTP ट्रिगर्स के साथ काम करते समय, वे डिफ़ॉल्ट रूप से एक फंक्शन ऐप कुंजी के साथ सुरक्षित होते हैं। इस कुंजी को प्राप्त करने के लिए निम्नलिखित कमांड चलाएं:
|
|
|
|
```sh
|
|
az functionapp keys list --resource-group smart-timer \
|
|
--name <APP_NAME>
|
|
```
|
|
|
|
`functionKeys` सेक्शन से `default` एंट्री का मान कॉपी करें।
|
|
|
|
```output
|
|
{
|
|
"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 ट्रिगर डाक्यूमेंटेशन के कॉन्फ़िगरेशन सेक्शन में](https://docs.microsoft.com/azure/azure-functions/functions-bindings-http-webhook-trigger?WT.mc_id=academic-17441-jabenn&tabs=python#configuration)।
|
|
|
|
* फंक्शन ऐप को लोकल रूप से चलाएं, और IP पते का उपयोग करके एक्सेस करें - आप अपने कंप्यूटर के लोकल नेटवर्क पर IP पता प्राप्त कर सकते हैं, और इसका उपयोग करके URL बना सकते हैं।
|
|
|
|
अपना IP पता खोजें:
|
|
|
|
* Windows 10 पर, [अपना IP पता खोजने के लिए गाइड](https://support.microsoft.com/windows/find-your-ip-address-f21a9bbc-c582-55cd-35e0-73431160a1b9?WT.mc_id=academic-17441-jabenn) का पालन करें।
|
|
* macOS पर, [Mac पर अपना IP पता कैसे खोजें गाइड](https://www.hellotech.com/guide/for/how-to-find-ip-address-on-mac) का पालन करें।
|
|
* Linux पर, [Linux में अपना IP पता कैसे खोजें गाइड](https://opensource.com/article/18/5/how-find-ip-address-linux) में अपने प्राइवेट 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 डिवाइस आपके कंप्यूटर के समान नेटवर्क पर हो।
|
|
|
|
1. इस एंडपॉइंट को curl का उपयोग करके एक्सेस करके टेस्ट करें।
|
|
|
|
---
|
|
|
|
## 🚀 चुनौती
|
|
|
|
एक ही चीज़ का अनुरोध करने के कई तरीके हो सकते हैं, जैसे कि टाइमर सेट करना। इसके अलग-अलग तरीकों के बारे में सोचें और उन्हें अपने LUIS ऐप में उदाहरण के रूप में उपयोग करें। इन्हें टेस्ट करें, यह देखने के लिए कि आपका मॉडल टाइमर सेट करने के विभिन्न तरीकों को कितनी अच्छी तरह संभाल सकता है।
|
|
|
|
## पोस्ट-लेक्चर क्विज़
|
|
|
|
[पोस्ट-लेक्चर क्विज़](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/44)
|
|
|
|
## समीक्षा और स्व-अध्ययन
|
|
|
|
* LUIS और इसकी क्षमताओं के बारे में अधिक पढ़ें [Microsoft डॉक्स पर Language Understanding (LUIS) दस्तावेज़ पेज](https://docs.microsoft.com/azure/cognitive-services/luis/?WT.mc_id=academic-17441-jabenn) पर।
|
|
* भाषा समझने के बारे में अधिक पढ़ें [विकिपीडिया पर प्राकृतिक भाषा समझने के पेज](https://wikipedia.org/wiki/Natural-language_understanding) पर।
|
|
* HTTP ट्रिगर्स के बारे में अधिक पढ़ें [Microsoft डॉक्स पर Azure Functions HTTP ट्रिगर दस्तावेज़](https://docs.microsoft.com/azure/azure-functions/functions-bindings-http-webhook-trigger?WT.mc_id=academic-17441-jabenn&tabs=python) पर।
|
|
|
|
## असाइनमेंट
|
|
|
|
[टाइमर रद्द करें](assignment.md)
|
|
|
|
**अस्वीकरण**:
|
|
यह दस्तावेज़ AI अनुवाद सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) का उपयोग करके अनुवादित किया गया है। जबकि हम सटीकता सुनिश्चित करने का प्रयास करते हैं, कृपया ध्यान दें कि स्वचालित अनुवाद में त्रुटियां या अशुद्धियां हो सकती हैं। मूल भाषा में उपलब्ध मूल दस्तावेज़ को प्रामाणिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम उत्तरदायी नहीं हैं। |