msb-public
/
IoT-For-Beginners
mirror of https://github.com/microsoft/IoT-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
IoT-For-Beginners/translations/ml/6-consumer/lessons/2-language-understanding/README.md

60 KiB
Raw Permalink Blame History Escape

ഭാഷ മനസ്സിലാക്കുക

ഈ പാഠത്തിന്റെ സ്കെച്ച്നോട്ട് അവലോകനം

സ്കെച്ച്നോട്ട് Nitya Narasimhan രചിച്ചത്. വലിയ പതിപ്പിന് ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക.

പ്രീ-ലെക്ചർ ക്വിസ്

പ്രീ-ലെക്ചർ ക്വിസ്

പരിചയം

മുൻ പാഠത്തിൽ നിങ്ങൾ സംസാരത്തോട് പദത്തിൽ മാറ്റിയിരിക്കുന്നു. ഇതിനെ സ്മാർട്ട് ടൈമർ പ്രോഗ്രാം ചെയ്യാൻ ഉപയോഗിക്കാൻ, сказанотоൺ എത്രയും മനസിലാക്കേണ്ടതുണ്ട്. ഉപയോക്താവ് ഒരു സ്ഥിരമായ വാക്യം സംസാരിക്കും എന്ന് നിങ്ങൾ കരുതിക്കൊണ്ട്, ഉദാഹരണത്തിന് "Set a 3 minute timer" എന്നുവെന്നു പറഞ്ഞ്, ടൈമർ എത്രകാലം ആകണമെന്നു ഗ്രഹിക്കാൻ ആ വാക്യം വിശകലനം ചെയ്യാം, എന്നാൽ ഇത് ഉപയോക്തൃ സൗഹൃദമല്ല. ഉപയോക്താവ് "Set a timer for 3 minutes" എന്ന് പറഞ്ഞാൽ, നിങ്ങളോ ഞാൻ പോലും എന്താണെന്ന് മനസിലാക്കും, എന്നാൽ നിങ്ങളുടെ കോഡ് ആ ഇനിയും മനസ്സിലാക്കില്ല, അത് സ്ഥിരമായ വാക്യം പ്രത്യാശിക്കുന്നു.

ഇതെന്നിടത്താണ് ഭാഷ മനസ്സിലാക്കലിന്റെ പ്രാധാന്യം. എഐ മോഡലുകൾ ഉപയോഗിച്ച് പദംദോഷണം ചെയ്ത് ആവശ്യമായ വിവരങ്ങൾ തിരിച്ചറിയുന്നു, ഉദാഹരണത്തിന് "Set a 3 minute timer" എന്നും "Set a timer for 3 minutes" എന്നും രണ്ട് വാക്യങ്ങളെയും എടുത്ത് ടൈമർ 3 മിനിറ്റിന് വേണം എന്ന് മനസിലാക്കാൻ കഴിയും.

ഈ പാഠത്തിൽ നിങ്ങൾക്ക് ഭാഷ മനസ്സിലാക്കൽ മോഡലുകൾ, അവ സൃഷ്ടിക്കുക, പരിശീലിപ്പിക്കുക, നിങ്ങളുടെ കോഡ് വഴി ഉപയോഗിക്കുക എന്നിവയെ കുറിച്ച് പഠിക്കാം.

ഈ പാഠത്തിൽ നമ്മൾ ചെയ്യുന്നത്:

ഭാഷ മനസ്സിലാക്കൽ

അനവധി വർഷങ്ങളായി മനുഷ്യർ ഭാഷ ഉപയോഗിച്ച് ആശയവിനിമയം നടത്തിവരുന്നു. നാം പദങ്ങൾ, ശബ്ദങ്ങൾ, പ്രവർത്തനങ്ങൾ എന്നിവ ഉപയോഗിച്ച് ആശയവിനിമയം നടത്തുകയും വഴക്കുകൾ കേൾക്കുകയും ചെയ്യുന്നു, അവയുടെ അർത്ഥവും പശ്ചാത്തലവും മനസ്സിലാക്കുന്നു. എങ്ങനെ ആശയങ്ങൾ പ്രാമാണികമായും വ്യംഗ്യമായും സ്വീകരിക്കാമെന്ന് നമ്മൾ മനസ്സിലാക്കുന്നു, അതുകൊണ്ട് ഒരേ വാക്കുകൾ വിവിധ അർത്ഥങ്ങളിൽ വ്യത്യാസപ്പെടുന്നു നമ്മുടെ ശബ്‌ദത്തിന്റെ താളം അനുസരിച്ച്.

✅ ഏറ്റവും അടുത്ത കാലത്തുണ്ടായ ചില സംഭാഷണങ്ങളെപ്പറ്റി ചിന്തിക്കുക. കമ്പ്യൂട്ടറിന് ഇവയിൽ എത്രത്തോളം വൈകാരികവും പശ്ചാത്തലവുമില്ലാതെ മനസ്സിലാക്കാൻ ബുദ്ധിമുട്ടാണ്?

ഭാഷ മനസ്സിലാക്കൽ അല്ലെങ്കിൽ നാചുരൽ-ലാംഗ്വേജ് അണ്ടറസ്റ്റാൻഡിംഗ്, നാചുറൽ-ലാംഗ്വേജ് പ്രോസസ്സിംഗ് (NLP) എന്ന കൃത്രിമ ബുദ്ധിമുട്ടിന്റെൊരു ആക്കം ആണ്, പദങ്ങൾ അല്ലെങ്കിൽ വാക്യങ്ങളുടെ വിശദാംശങ്ങൾ മനസ്സിലാക്കാൻ ശ്രമിക്കുന്നു. നിങ്ങൾ അലക്‌സാ അല്ലെങ്കിൽ സിരി പോലുള്ള വോയ്സ് അസിസ്റ്റന്റുകൾ ഉപയോഗിച്ചാൽ, നിങ്ങൾ ഭാഷ മനസ്സിലാക്കൽ സേവനങ്ങൾ ഉപയോഗിച്ചിട്ടുണ്ട്. അവ ആ പുറകിലുള്ള എഐ സേവനങ്ങളാണ്, "Alexa, play the latest album by Taylor Swift" എന്ന ശബ്ദം എന്റെ മകൾ താമസമുറിയിൽ അവരുടെ ഇഷ്ട ഗാനങ്ങൾ കേൾക്കുവാൻ നൃത്തം ചെയ്യുന്നു എന്നാക്കുന്നത്.

💁 കമ്പ്യൂട്ടറുകൾ, അവരുടെ മികവുകൾക്കുപുറമെ, എഴുത്ത് സത്യത്തിൽ മനസ്സിലാക്കാൻ ഇന്നും ദൂരം തള്ളിയിരിക്കുന്നു. കമ്പ്യൂട്ടറുകളുടെ ഭാഷ മനസ്സിലാക്കൽ എന്നപ്പോൾ മനുഷ്യ ആശയവിനിമയത്തിന് ചേർച്ചയായവയിൽ നിന്ന് വളരെക്കുറച്ച് മാത്രം അർത്ഥമാക്കുന്നു, പദങ്ങളിൽ നിന്ന് പ്രധാന വിവരങ്ങൾ പുറത്തെടുക്കൽ മാത്രമേ വരൂ.

നാം മനുഷ്യന്മാരായി ചികിത്സിക്കാതെ തന്നെ ഭാഷ മനസ്സിലാക്കുന്നു. ഞാൻ ഏതൊരു മനുഷ്യനോടും "play the latest album by Taylor Swift" എന്ന് പറഞ്ഞാൽ, അവർ സ്വാഭാവികമായി എന്താണു ഞാൻ അർത്ഥമാക്കുന്നത് അറിയും. however, a computer finds this challenging. It has to take words, converted from speech to text, and identify the following details:

  • സംഗീതം പ്ലേ ചെയ്യണമെന്നും
  • ഈ സംഗീതം Taylor Swift എന്ന കലാകാരിയുടെ ആണ്
  • ഈ സാഹിത്യം നിരവധി പാട്ടുകൾ അടങ്ങിയ ഒരു ആൽബമാണ്
  • Taylor Swift ന്റെ പല ആൽബങ്ങളും ഉണ്ട്, അവ കാലക്രമത്തിലാകും ക്രമീകരിക്കേണ്ടത്, ഏറ്റവും പുതിയതേ ആവശ്യമുള്ളത്

✅ നിങ്ങൾ ഇതുവരെ പറഞ്ഞുപോയ മറ്റ് ചില വാക്യങ്ങൾ ചിന്തിച്ച് നോക്കൂ, ഉദാഹരണത്തിന് കാപ്പി ഓർഡർ ചെയ്യുമ്പോൾ അല്ലെങ്കിൽ കുടുംബാംഗം ഒരിടത്തേക്ക് എന്തെങ്കിലും കൈമാറാൻ പറയുമ്പോൾ. ഗണിത അർത്ഥം കണ്ടെത്തുന്നതിന് കമ്പ്യൂട്ടർ ഏതൊക്കെ വിവരങ്ങൾ വേണം എന്നു അവ മനസ്സിലാക്കാൻ ശ്രമിക്കുക.

ഭാഷ മനസ്സിലാക്കൽ മോഡലുകൾ വികസിപ്പിക്കാൻ AI മോഡലുകൾ ആണ് ഇവ കൃത്യമായ ചില വൃത്താന്തങ്ങൾ പടിയ്ക്കുമെങ്കിലും, പിന്നീട് കസ്റ്റം വിസൻ മോഡലുകളെ പോലെ ടെക്സ്റ്റ് ഉപയോഗിച്ച് പരിശീലിപ്പിക്കുന്നു. ഒരു മോഡൽ എടുത്ത് അത് നിങ്ങൾക്ക് മനസ്സിലാക്കേണ്ട വാചകം ഉപയോഗിച്ച് പരിശീലിപ്പിക്കാം.

ഭാഷ മനസ്സിലാക്കൽ മോഡൽ സൃഷ്ടിക്കൽ

LUIS ലോഗോ

LUIS ബാഷാ മനസ്സിലാക്കൽ സേവനമാണ്, മൈക്രോസോഫ്റ്റിന്റെ Cognitive Services-യുടെ ഭാഗമാണ്. LUIS ഉപയോഗിച്ച് ഭാഷ മനസ്സിലാക്കൽ മോഡലുകൾ സൃഷ്ടിക്കാം.

ജോലിയ് - ഒരു ഓതറിംഗ് റിസോഴ്‌സ് സൃഷ്ടിക്കൽ

LUIS ഉപയോഗിക്കാൻ ഒരു ഓതറിംഗ് റിസോഴ്‌സ് സൃഷ്ടിക്കണം.

  1. നിങ്ങളുടെ smart-timer റിസോഴ്‌സ് ഗ്രൂപ്പിൽ ഒരു ഓതറിംഗ് റിസോഴ്‌സ് സൃഷ്ടിക്കാൻ താഴെ കൊടുത്ത കമാൻഡ് ഉപയോഗിക്കുക:

    az cognitiveservices account create --name smart-timer-luis-authoring \
                                    --resource-group smart-timer \
                                    --kind LUIS.Authoring \
                                    --sku F0 \
                                    --yes \
                                    --location <location>

    Resource Group സൃഷ്ടിക്കുമ്പോൾ ഉപയോഗിച്ച <location> വാക്ക് മാറ്റുക.

    ⚠️ LUIS എല്ലാ പ്രദേശങ്ങളിലും ലഭ്യമായിട്ടില്ല, അതിനാൽ താഴെക്കൊടുത്ത പിശക് വന്നാൽ:

    InvalidApiSetId: The account type 'LUIS.Authoring' is either invalid or unavailable in given region.

    വേറെ പ്രദേശം തിരഞ്ഞെടുക്കുക.

    ഇതിലൂടെ ഒരു ഫ്രീ-ടയർ LUIS ഓതറിംഗ് റിസോഴ്‌സ് ഉണ്ടാക്കും.

ജോലിയ് - ഒരു ഭാഷ മനസ്സിലാക്കൽ ആപ്പ് സൃഷ്ടിക്കുക

  1. നിങ്ങളുടെ ബ്രൗസറിൽ luis.ai തുറന്ന്, കഴിഞ്ഞ ക്രമീകരണത്തിനുപയോഗിച്ച അതേ അക്കൗണ്ട് ഉപയോഗിച്ച് സൈൻ ഇൻ ചെയ്യുക.

  2. സംവാദത്തിൽ നൽകിയ നിർദ്ദേശങ്ങൾ പിന്തുടർന്ന് നിങ്ങളുടെ Azure സുരക്ഷിത ക്രമീകരിച്ച smart-timer-luis-authoring റിസോഴ്‌സ് തിരഞ്ഞെടുക്കുക.

  3. Conversation apps പട്ടികയിൽ, New app ബട്ടൺ തിരഞ്ഞെടുക്കിച്ച് ഒരു പുതിയ ആപ്പ് സൃഷ്ടിക്കുക. ആപ്പിന്റെ പേര് smart-timer എന്ന് നാമകരണംചെയ്യുക, Culture നിങ്ങളുടെ ഭാഷയായി തെരഞ്ഞെടുക്കുക.

    💁 പ്രവചനം ആവശ്യമായ റിപ്പോർട്ട് ഫീൽഡ് ഉണ്ട്. ഒരു വേറ EmmanuelmusകരResource Prediction എത്തിയാലും, ‍ഉപകരണമായി പഠിപ്പിക, ഉദാഹരണത്തിനു പരീക്ഷണത്തിനു 1,000 പ്രവചനങ്ങൾ അനുവദിക്കുന്ന ഈ സൗജന്യ ഓതറിംഗ് റിസോഴ്‌സ് മതിയാകും, അതിനാൽ ഇത് ഒഴിഞ്ഞിരിക്കാം.

  4. ആപ്പ് സൃഷ്ടിച്ചതിന് പുറമേ കാണുന്ന മാർഗ്ഗനിർദ്ദേശം വായിച്ച് LUIS മോഡൽ എങ്ങനെ പഠിപ്പിക്കാമെന്ന് മനസ്സിലാക്കുക. കഴിഞ്ഞാൽ മാർഗ്ഗനിർദ്ദേശം അടയ്ക്കുക.

ഉദ്ദേശ്യങ്ങളും ഘടകങ്ങളും

ഭാഷ മനസ്സിലാക്കൽ ഉദ്ദേശ്യങ്ങളിലും (intents) ഘടകങ്ങളിലും (entities) ആധാരമാക്കിയാണ് നടക്കുന്നത്. Intent എന്നത് വാക്കുകളുടെയും വാക്യങ്ങളുടെയും ഉദ്ദേശ്യമാണെന്ന് സൂചിപ്പിക്കുന്നു, ഉദാഹരണത്തിന് സംഗീതം പ്ലേചെയ്യൽ, ടൈമർ സെറ്റ് ചെയ്യൽ, ഭക്ഷ്യ ഓർഡർ ചെയ്തത്. Entity ഉദ്ദേശ്യത്തിൽ ഉൾപ്പെട്ട ഘടകമാണ്, ഉദാഹരണത്തിന് ആൽബം, ടൈമറിന്റെ ദൈർഘ്യം, ഭക്ഷണത്തിന്റെ തരം. മോഡൽ വ്യാഖ്യാനിക്കുന്ന ഓരോ വാക്യത്തിനും കുറഞ്ഞത് ഒരു intent ഉണ്ടാകണം, കൂടാതെ ഒരു അല്ലെങ്കിൽ കൂടുതൽ entities ഉം ഉണ്ടാകാം.

കുറച്ച് ഉദാഹരണങ്ങൾ:

വാക്യം ഉദ്ദേശ്യം ഘടകങ്ങൾ
"Play the latest album by Taylor Swift" play music the latest album by Taylor Swift
"Set a 3 minute timer" set a timer 3 minutes
"Cancel my timer" cancel a timer ഒന്നുമില്ല
"Order 3 large pineapple pizzas and a caesar salad" order food 3 large pineapple pizzas, caesar salad

✅ നിങ്ങൾ മുമ്പ് ചിന്തിച്ച വാക്യങ്ങളിൽ, അതിൽ ഉദ്ദേശ്യം എന്താകും? എന്തെന്ത് ഘടകങ്ങളായിരിക്കും?

LUIS പരിശീലിപ്പിക്കാൻ ആദ്യം entities സജ്ജമാക്കണം. അവ സ്ഥിരമായ വാക്കുകളുടെ പട്ടികയാകാം, അല്ലെങ്കിൽ വാക്കുകളിൽ നിന്നു പഠിച്ചിട്ടുണ്ടാകാം. ഉദാഹരണത്തിന്, നിങ്ങളുടെ മെനുവിൽ ഉള്ള ഭക്ഷണങ്ങളുടെ ഒരു ലിസ്റ്റ് നൽകാം, അതിൽ ഓരോ വാക്കിനും വ്യത്യാസങ്ങൾ (അതായത് സമാനാര്ഥ വാക്കുകൾ, വൈവിധ്യങ്ങൾ) ഉൾപ്പെടുത്താം, ഉദാഹരണത്തിന് egg plant എന്നതിന് സ്ഥാനാർത്ഥിയായ aubergine. LUISക്ക് മുമ്പ് സജ്ജമായ entities ഉണ്ട്, ഉദാഹരണത്തിന് സംഖ്യകൾ, സ്ഥലങ്ങൾ.

ടൈമർ സെറ്റ് ചെയ്യുമ്പോൾ, prebuilt number entity ഉപയോഗിച്ചുകൊണ്ട് ഒരു entity വേണം സമയത്തിന്, മറ്റൊരു entity വേണം സമയ യൂണിറ്റിന്, ഉദാഹരണത്തിന് മിനിറ്റ്, സെക്കന്റ് തുടങ്ങിയവ. ഓരോ യൂണിറ്റിനും ഏകവചനവും ബഹുവചനവും ഉൾപ്പെടുത്തുന്ന വ്യത്യാസങ്ങൾ എടുക്കണം - ഉദാഹരണത്തിന് minute, minutes.

Entity സൂചനകൾ നിശ്ചയിച്ചതിനു ശേഷം intents സൃഷ്ടിക്കുക. ഇതെല്ലാം ഉദാഹരണ വാക്യങ്ങൾ നൽകിയതിന് (utterances) അടിസ്ഥാനത്തിലാണ് മോഡൽ പഠിക്കുന്നത്. ഉദാഹരണത്തിന് set timer intent ന് നിങ്ങൾ താഴെ പറയുന്ന വാക്യങ്ങൾ നൽകാം:

  • set a 1 second timer
  • set a timer for 1 minute and 12 seconds
  • set a timer for 3 minutes
  • set a 9 minute 30 second timer

LUIS-ന് നിങ്ങൾക്ക് entities യെ വാക്യങ്ങളിൽ നിന്നു തിരിച്ചറിയാൻ അറിയിക്കും:

set a timer for 1 minute and 12 seconds എന്ന വാക്യം entityകളായി വിഭജിച്ചത്

set a timer for 1 minute and 12 seconds വാക്യത്തിന്റെ intent set timer ആണെന്നും, ഇരട്ട entity ഉണ്ട്, ഓരോന്നിലും രണ്ട് മൂല്യങ്ങളുള്ളത്:

സമയം യൂണിറ്റ്
1 minute 1 minute
12 seconds 12 second

മികച്ച മോഡൽ ട്രെയിൻ ചെയ്യാനായി വാക്കുകൾ വ്യത്യസ്ത രീതിയിൽ വരുന്ന വ്യത്യസ്ത ഉദാഹരണങ്ങൾ നൽകണം, അതായത് ഒരേ കാര്യം പരിശോധിക്കാൻ ചില വ്യത്യസ്ത മാർഗങ്ങൾ നൽകുക.

💁 ഏതൊരു AI മോഡലും പോലേ, കൂടുതൽ ഡാറ്റയും, കൂടുതൽ ശരിയായ ഡാറ്റയും ഉപയോഗിച്ചാണ് മോഡൽ മെച്ചപ്പെടുത്തുന്നത്.

✅ ഒരേ കാര്യം മനുഷ്യൻ ഓർമ്മിക്കാൻ ഏവ വിധങ്ങളുള്ള അഭ്യർത്ഥനകൾ ഉണ്ടാകാമെന്ന് ചിന്തിക്കൂ.

ജോലിയ് - ഭാഷ മനസ്സിലാക്കൽ മോഡലുകളിലേക്ക് entityകൾ ചേർക്കുക

ടൈമറിന്റെ ഭാഗമായ entityകളായി 2 benodhyam - സമയം യൂണിറ്റ് (മിനിറ്റ്, സെക്കന്റ്) ഒന്ന്, മറ്റൊന്നായി അളവ് (സമയം) എന്ന entity വേണം.

LUIS പോർട്ടലിലെ Quickstart: Build your app in LUIS portal documentation on Microsoft docs വായിച്ച് നിർദ്ദേശങ്ങൾ കാണാം.

  1. LUIS പോർട്ടലിൽ നിന്നും Entities ടാബ് തെരഞ്ഞെടുത്ത് Add prebuilt entity ബട്ടൺ അമർത്തി number entity തിരഞ്ഞെടുക്കുക.

  2. Create ബട്ടൺ ഉപയോഗിച്ച് പുതിയ entity സൃഷ്ടിക്കുക. entity നാമം time unit എന്നു നൽകുക, തരം List ആയി നിർദ്ദേശിക്കുക. Normalized values പട്ടികയിൽ minute , second ചേർക്കുക, synonyms ലിസ്റ്റിൽ ഏകവചനം, ബഹുവചനം തിരിച്ചു ചേർക്കുക. ഓരോ synonym ചേർക്കുമ്പോഴും return അമർത്തുക.

    Normalized value Synonyms
    minute minute, minutes
    second second, seconds

ജോലിയ് - ഭാഷ മനസ്സിലാക്കൽ മോഡലുകളിലേക്ക് intents ചേർക്കുക

  1. Intents ടാബിൽ Create ബട്ടൺ അമർത്തി പുതിയ intent സൃഷ്ടിക്കുക. intent നാമം set timer എന്നു നൽകുക.

  2. ഉദാഹരണങ്ങളിൽ മിനിട്ടും സെക്കന്റും യോജിപ്പിച്ച് ടൈമർ സജ്ജമാക്കാനുള്ള വിവിധ രീതികൾ നൽകുക, ഉദാഹരണങ്ങൾ:

    • set a 1 second timer
    • set a 4 minute timer
    • set a four minute six second timer
    • set a 9 minute 30 second timer
    • set a timer for 1 minute and 12 seconds
    • set a timer for 3 minutes
    • set a timer for 3 minutes and 1 second
    • set a timer for three minutes and one second
    • set a timer for 1 minute and 1 second
    • set a timer for 30 seconds
    • set a timer for 1 second

    അക്കങ്ങളും വാക്കുകളായി ചേർത്തുകൊണ്ട് മോഡലിന് ഇരിക്കയും പഠിപ്പിക്കുക.

  3. ഓരോ ഉദാഹരണവും നൽകുമ്പോൾ LUIS entityകൾ വ്യക്തമായി കണ്ടെത്താൻ തുടങ്ങും, അവയെ താഴെ രേഖപ്പെടുത്തും.

    LUIS കണ്ട കണക്കുകൾ കൊണ്ട് അക്കങ്ങളും സമയം യൂണിറ്റുകളും അടിവരയായി കാണിക്കുന്നു

ജോലിയ് - മോഡൽ പരിശീലിപ്പിക്കുകയും പരീക്ഷിക്കുകയും ചെയ്യുക

  1. entityകളും intentകളും ക്രമീകരിച്ചതിനു ശേഷം മുകളിൽ Train ബട്ടൺ അമർത്തി മോഡൽ പരിശീലിപ്പിക്കുക. അമർത്തിയാൽ കുറച്ച് സെക്കൻഡുകളിൽ പരിശീലനം നടക്കും. പരിശീലനത്തിനിടെ ബട്ടൺ മങ്ങിയിരിക്കും, കഴിഞ്ഞ് വീണ്ടും സജീവമാകും.

  2. മുകളിൽ Test ബട്ടൺ അമർത്തി ഭാഷ മനസ്സിലാക്കൽ മോഡൽ പരീക്ഷിക്കുക. ടെക്സ്റ്റ് ബോക്സിൽ set a timer for 5 minutes and 4 seconds എഴുതിയും return അമർത്തുക. നിങ്ങൾ ടൈപ്പ് ചെയ്ത വാക്യം ബോക്സിന്റെ കീഴിൽ കാണിക്കും, അതിനടിയിൽ top intent എന്നുള്ള സവിശേഷ intent കാണിക്കും, സാധാരണയായി set timer ആണ്. intent നാമത്തിന് ശേഷമുള്ള സംഭാവ്യതാ ശതമാനവും കാണിക്കും.

  3. Inspect ഓപ്ഷൻ തെരഞ്ഞെടുത്തു ഫലം വിഭജനം കാണുക. ഏറ്റവും ഉയർന്ന സ്കോർ ഉള്ള intent, അതിന്റെ ശതമാനം, entityകളുടെ പട്ടിക കാണാം.

  4. പരീക്ഷണം കഴിഞ്ഞാൽ Test പടി അടയ്ക്കുക.

ജോലിയ് - മോഡൽ പ്രസിദ്ധീകരിക്കുക

കോഡിൽ നിന്നും ഈ മോഡൽ ഉപയോഗിക്കാൻ, ആദ്യമെടുത്ത് പ്രസിദ്ധീകരിക്കണം. LUIS-ൽ നിന്നും പ്രസിദ്ധീകരിക്കുമ്പോൾ, പരീക്ഷണത്തിനായുള്ള സ്റ്റേജിംഗ് പരിസ്ഥിതിയിലോ, പൂർണ്ണ റിലീസിനായി പ്രൊഡക്ഷൻ പരിസ്ഥിതിയിലോ പ്രസിദ്ധീകരിക്കാം. ഈ പാഠത്തിൽ സ്റ്റേജിംഗ് പരിസ്ഥിതി മതിയാകും.

  1. LUIS പോർട്ടലിൽ മുകളിൽ നിന്നുള്ള Publish ബട്ടൺ അമർത്തുക.

  2. Staging slot തിരഞ്ഞെടുക്കിയിരിക്കണം ഉറപ്പ് വരുത്തുക, പിന്നീട് Done അമർത്തുക. ആപ്പ് പ്രസിദ്ധീകരിക്കുന്ന വിവരം അറിയിപ്പ് കാണിക്കും.

  3. നിങ്ങൾ ഇത് curl ഉപയോഗിച്ച് പരീക്ഷിക്കാം. curl കമാൻഡ് നിർമ്മിക്കാൻ, നിങ്ങളെ മൂന്ന് മൂല്യങ്ങൾ ആവശ്യമുണ്ട് - എണ്ട്പോയിന്റ്, അപ്‌ളിക്കേഷനു ID (App ID) ഒപ്പം API കീ. ഇവ പുറമേ മെനുവിൽ നിന്നുള്ള MANAGE ടാബിൽ നിന്ന് ലഭ്യമാണ്.

    1. Settings വിഭാഗത്തിൽ നിന്നു App ID കോപ്പി ചെയ്യുക

    2. Azure Resources വിഭാഗത്തിൽ നിന്നു Authoring Resource തിരഞ്ഞെടുത്ത്, Primary Keyയും Endpoint URLയും കോപ്പി ചെയ്യുക

  4. താഴെ കൊടുത്തിരിക്കുന്ന 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> ന് പകരം നിങ്ങൾ പരീക്ഷിക്കാനുള്ള വാചകം നൽകുക.

  5. ഈ കോൾയുടെ ഔട്ട്പുട്ട് ഒരു 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%) ആയ ടോപ്പ് Intent ആയിരുന്നു.
    • രണ്ട് number എന്റിറ്റികൾ കണ്ടെത്തി, 45 ഉം 12ഉം.
    • രണ്ട് time-unit എന്റിറ്റികൾ കണ്ടെത്തി, minute ഉം secondഉം.

ഭാഷാ മനസ്സിലാക്കൽ മോഡൽ ഉപയോഗിക്കുക

പ്രഖ്യാപിച്ചതിന് ശേഷം, LUIS മോഡൽ കോഡിൽ നിന്ന് വിളിക്കാം. മുൻപത്തെ പാഠങ്ങളിൽ, നിങ്ങൾ IoT ഹബ്ബ് ഉപയോഗിച്ച് ക്ലൗഡ് സേവനങ്ങളുമായി സംവാദം കൈകാര്യം ചെയ്തിട്ടുണ്ട്, ടെലിമെട്രി അയച്ച് കമാൻഡുകൾ കേട്ടത്. ഇത് വളരെ അസിങ്ക്രോൺസ് ആണ് - ടെലിമെട്രി അയച്ചു കഴിഞ്ഞാൽ നിങ്ങളുടെ കോഡ് പ്രതികരണത്തിനായി കാത്തിരിക്കുകയില്ല, ക്ലൗഡ് സേവനം shuts down ആണെങ്കിൽ നിങ്ങൾക്ക് അറിയാനായില്ല.

ഒരു സ്മാർട്ട് ടൈമറിന്, നമുക്ക് ഉടൻപ്രതികരണം വേണം, അതിനാൽ ടൈമർ സജ്ജമാക്കിയതായി ഉപയോക്താവിനു അറിയിക്കാം, അല്ലെങ്കിൽ ക്ലൗഡ് സേവനങ്ങൾ ലഭ്യമല്ല എന്ന് അറിയിക്കാം. അതിനായി, ഞങ്ങളുടെ IoT ഉപകരണം നേരിട്ട് ഒരു വെബ് എണ്ട്പോയിന്റ് വിളിക്കും, IoT ഹബ് ആശ്രയിക്കാതെ.

IoT ഉപകരണത്തിൽ നിന്ന് നേരിട്ട് LUIS വിളിക്കുന്നതിനുപകരം, HTTP ട്രിഗർ പോലുള്ള വേറെ തരത്തിലുള്ള ട്രിഗർ ഉപയോഗിച്ച് സെർവറ്ലെസ് കോഡ് ഉപയോഗിക്കാം. ഇതിലൂടെ നിങ്ങളുടെ ഫംഗ്ഷൻ ആപ് REST അഭ്യർത്ഥനകൾ കേൾക്കുകയും അവയ്ക്ക് പ്രതികരിക്കുകയും ചെയ്യും. ഈ ഫംഗ്ഷൻ നിങ്ങളുടെ ഉപകരണം വിളിക്കാൻ കഴിയുന്ന REST എണ്ട്പോയിണ்ட் ആയിരിക്കും.

💁 നിങ്ങൾക്ക് IoT ഉപകരണത്തിൽ നിന്ന് നേരിട്ട് LUIS വിളിക്കാമെങ്കിലും, സെർവറ്ലെസ് കോഡ് പോലുള്ള മറ്റൊന്ന് ഉപയോഗിക്കുന്നതാണ് നല്ലത്. ഉദാഹരണത്തിന് നിങ്ങൾ മികച്ച മോഡൽ ട്രെയിൻ ചെയ്യുമ്പോഴും, വ്യത്യസ്ത ഭാഷയിൽ മോഡൽ ട്രെയിൻ ചെയ്യുമ്പോഴും, ക്ലൗഡ് കോഡ് അപ്ഡേറ്റ് ചെയ്താൽ മതി, നിന്ന് ആയിരക്കണക്കിന് അല്ലെങ്കിൽ ലക്ഷക്കണക്കിന് IoT ഉപകരണങ്ങളിൽ വീണ്ടും കോഡ് ഡിപ്ലോയ്ചെയ്യേണ്ടതില്ല.

ടാസ്‌ക് - ഒരു സെർവറ്ലെസ് ഫംഗ്ഷൻസ് ആപ് സൃഷ്ടിക്കുക

  1. smart-timer-trigger എന്ന് പേരിട്ടു ഒരു Azure Functions ആപ് സൃഷ്ടിച്ച്, ഇത് VS Code-ൽ തുറക്കുക

  2. ഈ ആപ്പിൽ speech-trigger എന്ന HTTP ട്രിഗർ ചേർക്കുക, താഴെയുള്ള കമാൻഡ് VS Code ടെർമിനലിൽ നിന്ന് നടത്തുക:

    func new --name text-to-timer --template "HTTP trigger"

    ഇതിലൂടെ text-to-timer എന്ന HTTP ട്രിഗർ ഉണ്ടാകും.

  3. ഫംഗ്ഷൻസ് ആപ് ഓടിച്ച് 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.

ടാസ്ക് - ഭാഷാ മനസ്സിലാക്കൽ മോഡൽ ഉപയോഗിക്കുക

  1. LUIS-നുള്ള SDK ഒരു Pip പാക്കേജ് ആയി ലഭ്യമാണ്. ഈ പാക്കേജ് ഡിപ്പൻഡൻസി ചേർക്കാൻ requirements.txt ഫയലിലേക്കു താഴെ കൊടുത്ത വരി ചേർക്കുക:

    azure-cognitiveservices-language-luis

  2. VS Code ടെർമിനലിൽ വെർച്ച്വൽ എൻവയോണമെന്റ് സജീവമാക്കിയതായി ഉറപ്പാക്കി താഴെയുള്ള കമാൻഡ് ഉപയോഗിച്ച് പാക്കേജുകൾ പ്രവേശിപ്പിക്കുക:

    pip install -r requirements.txt

    💁 പിഴവുകൾ ഉണ്ടെങ്കിൽ, താഴെ കാണുന്ന കമാൻഡിൽ pip അപ്ഗ്രേഡ് ചെയ്യേണ്ടതായി വരാം:

    pip install --upgrade pip

  3. LUIS പോർട്ടലിലെ MANAGE ടാബിൽ നിന്നുള്ള LUIS API കീ, 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 നൽകുക.

  4. __init__.py ഫയലിൽ താഴെ കാണുന്ന ഇമ്പോർട്ടുകൾ ചേർക്കുക:

    import json
import os
from azure.cognitiveservices.language.luis.runtime import LUISRuntimeClient
from msrest.authentication import CognitiveServicesCredentials

    ഇത് സിസ്റ്റം ലൈബ്രറികളും LUIS-നോടുള്ള ഇടപാട് ലൈബ്രറികളും ഇറക്കുമതി ചെയ്യുന്നു.

  5. 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-ൽ ചേർത്ത മൂല്യങ്ങൾ തൂക്കുന്നു, API കീയോടുകൂടിയ ക്രെഡൻഷ്യൽസ് സൃഷ്ടിക്കുന്നു, തുടർന്ന് LUIS ക്ലയന്റ് സൃഷ്ടിക്കുന്നു.

  6. ഈ HTTP ട്രിഗർ JSON ആയി ടെക്സ്റ്റ് സ്വീകരിക്കും, വസ്തുവിൽ text എന്ന പ്രോപ്പർട്ടി ഉപയോഗിച്ച്. HTTP അഭ്യർത്ഥനയുടെ ബോഡിയിൽ നിന്ന് വാല്യൂ എടുക്കുകയും കോൺസോളിൽ ലോഗ് ചെയ്യുകയും ചെയ്യുന്ന കോഡ് main ഫംഗ്ഷനിൽ ചേർക്കുക:

    req_body = req.get_json()
text = req_body['text']
logging.info(f'Request - {text}')

  7. പ്രവചനങ്ങൾ ആവശ്യപ്പെടുന്നതിന്, പ്രവചിക്കേണ്ട ടെക്‌സ്റ്റ് അടങ്ങിയ JSON ഡോക്യൂമെന്റ് പടുത്തു സൃഷ്ടിക്കുക:

    prediction_request = { 'query' : text }

  8. ഈ അഭ്യർത്ഥന LUIS-യ്ക്ക് അയയ്ക്കുക, നിങ്ങൾ പ്രസിദ്ധനാക്കിയ സ്റ്റേജിംഗ് സ്ലോട്ട് ഉപയോഗിച്ച്:

    prediction_response = client.prediction.get_slot_prediction(app_id, 'Staging', prediction_request)

  9. പ്രവചന പ്രതികരണം ടോപ്പ് Intent (ഊന്നൽ നിരക്കു കൂടിയ Intent) ഉം എന്റിറ്റികളുമാണ് കാണിക്കുന്നത്. ടോപ്പ് Intent 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 അറേയിൽ 4നും 17നും രണ്ട് ഇന്റേജറുകൾ ഉണ്ടാകും.

    time unit എന്റിറ്റികൾ ഇടയിൽ നിന്ന് ഒരേ സമയം ഒരു സ്റ്റ്രിംഗുകളുടെ അറേ ഉണ്ടാകും. അതായത്, ഓരോ ടൈം യൂണിറ്റും ഉള്ള അറേയിൽ ഉൾപ്പെടും. ഉദാഹരണത്തിന്, "Set a four minute 17 second timer." എന്ന വാചകത്തിന് time unit അറേയിൽ രണ്ട് അറേകൾ ഉണ്ടായിരിക്കും - ['minute'] ഉം ['second'] ഉം.

    "Set a four minute 17 second timer." എന്ന വാചകത്തിന്‍റെ JSON പതിപ്പ് ഇങ്ങനെ ആണ്:

    {
    "number": [4, 17],
    "time unit": [
        ["minute"],
        ["second"]
    ]
}

    ഈ കോഡ് ടോട്ടൽ ടൈം സെക്കൻഡിൽ കണക്കാക്കാൻ ഒരു കൗണ്ട് നിർവ്വചിക്കുന്നു. ഇത് എന്റിറ്റികളിൽ നിന്നുള്ള മൂല്യങ്ങൾ ഉപയോഗിച്ച് പൂരിപ്പിക്കും.

  10. എന്റിറ്റികൾ ബന്ധിപ്പിച്ചിട്ടില്ലെങ്കിലും, അവയുടെ നിലയിൽ ചില സിദ്ധാന്തങ്ങൾ രൂപപ്പെടുത്താം. പ്രസംഗിച്ച ക്രമത്തിലാണ് അവ ഉണ്ടാകുന്നത്, അതുകൊണ്ട് അറേയിൽ സ്ഥിതിബോധം ഉപയോഗിച്ച് ഏത് നമ്പർ ഏത് ടൈം യൂണിറ്റിനോട് ചേർന്നിരിക്കുന്നുവെന്ന് നിർണയിക്കാം. ഉദാഹരണങ്ങൾ:

    • "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

  11. ഈ ലൂപ്പിനുള്ളിൽ, നമ്പറും ടൈം യൂണിറ്റും ഉപയോഗിച്ച് ടൈമറിന്റെ മൊത്തം സമയം കണക്കാക്കുക, ഓരോ മിനിറ്റിനും 60 സെക്കൻഡ് ചേർത്ത്, സെക്കൻഡുകൾ ഒട്ടുക:

    if time_unit == 'minute':
    total_seconds += number * 60
else:
    total_seconds += number

  12. ഈ എന്റിറ്റികളുടെ ലൂപ്പിനപ്പുറം, ടൈമറിന്റെ മൊത്തം സമയം ലോഗ് ചെയ്യുക:

    logging.info(f'Timer required for {total_seconds} seconds')

  13. ഈ സെക്കൻഡ് നിക്ഷേപം HTTP പ്രതികരണമായി ഫംഗ്ഷനിൽ തിരികെ നൽകണം. if ബ്ലോക്കിന്റെ അവസാനം താഴെ കൊടുത്തിരിക്കുന്ന കോഡ് ചേർക്കുക:

    payload = {
    'seconds': total_seconds
}
return func.HttpResponse(json.dumps(payload), status_code=200)

    ഈ കോഡ് മൊത്തം സെക്കൻഡുകളുടെ ഒരു പേലോഡ് നിർവ്വചിക്കുകയും JSON സ്ട്രിങിൽ പരിവർത്തിച്ച് 200 സ്റ്റാറ്റസ് കോഡോടുകൂടി വിജയകരമായ HTTP ഫലമായി തിരികെ നൽകുന്നു.

  14. അവസാനമായി, if ബ്ലോക്കിന്റെ പുറത്തായി, Intent രാഷ്ട്രീയമായില്ലെങ്കിൽ പിഴവ് കോഡ് തിരികെ നൽകുക:

    return func.HttpResponse(status_code=404)

    404 എന്നത് not found സ്റ്റാറ്റസ് കോഡ് ആണ്.

  15. ഫംഗ്ഷൻസ് ആപ് ഓടിച്ച് 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 ഉപകരണത്തിന് ലഭ്യമാക്കുക

  1. നിങ്ങളുടെ 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 trigger ഡോക്യുമെന്റേഷൻയിലെ കൺഫിഗറേഷൻ വിഭാഗം വായിക്കുക.

    • ഫംഗ്ഷൻസ് ആപ് പ്രാദേശികമായി ഓടിക്കുക, IP വിലാസം ഉപയോഗിച്ച് ആക്സസ് ചെയ്യുക - നിങ്ങളുടെ പ്രാദേശിക നെറ്റ്വർക്കിലെ കമ്പ്യൂട്ടറിന്റെ IP വിലാസം കണ്ടെത്തുക, പിന്നീട് അതുപയോഗിച്ച് URL നിർമ്മിക്കുക.

      നിങ്ങളുടെ IP വിലാസം കണ്ടെത്തുക:

      IP വിലാസം ലഭിച്ചശേഷം, ഫംഗ്ഷൻ ഈ URL-ൽ ലഭ്യമാണ്: http://<IP_ADDRESS>: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 ആപ്പിൽ ഉദാഹരണങ്ങളായി ഉപയോഗിക്കുക. വിവിധ verzoek ന്റെ വഴി പരീക്ഷിച്ച് നിങ്ങളുടെ മോഡൽ മൾട്ടിപ്പിൾ രീതി അഭ്യർത്ഥനകൾ എത്രത്തോളം കൈകാര്യം ചെയ്യുന്നു എന്ന് നോക്കുക.

പOs്റ്റ്-ലെക്ചർ ക്വിസ്

Post-lecture quiz

അവലോകനവും സ്വയം പഠനവും

അസൈൻമെന്റ്

Cancel the timer

പ്രത്യാഖ്യാനം: ഈ രേഖ AI പരിഭാഷാ സേവനമായ Co-op Translator ഉപയോഗിച്ച് വിവർത്തനം ചെയ്യപ്പെട്ടതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയമേവയായ പരിഭാഷകള്‍ പിശകുകൂടിയിരിക്കാമെന്നും തെറ്റായ വിവരങ്ങല്‍ക്കും സാധ്യതയുണ്ടെന്നും ദയവായി ശ്രദ്ധിക്കുക. എപ്പോഴും അതിന്റെ അതിഥിഭാഷ ആയ ആകാശ രേഖയെ പ്രാമാണികമായ ഉറവിടമായി കാണണം. അത്യാവശ്യം ഉള്ള വിവരങ്ങള്‍ക്ക് വിദഗ്ധ മാനവ പരിഭാഷ ശുപാര്‍ശ ചെയ്യുന്നു. ഈ പരിഭാഷ ഉപയോഗിച്ചതിനെ തുടര്‍ന്ന് ഉണ്ടായതിനാല്‍ സംഭവിക്കുന്ന തെറ്റിദ്ധാരണകള്‍ക്കും വ്യത്യാഖ്യാനങ്ങള്‍ക്കും നാം ഉത്തരവാദികളല്ല.