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.
564 lines
58 KiB
564 lines
58 KiB
# భాషను అర్థం చేసుకోండి
|
|
|
|
|
|
|
|
> స్కెచ్నోట్ [నిత్య నరసింహన్](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)
|
|
|
|
## భాష అర్థం చేసుకోవడం
|
|
|
|
మనుషులు సంభాషించడానికి వందల వేల సంవత్సరాలుగా భాషను ఉపయోగిస్తున్నారు. మనం మాటలు, ధ్వనులు లేదా చర్యలతో సంభాషిస్తాము మరియు చెప్పబడిన వాటిని అర్థం చేసుకుంటాము, అర్థం మాత్రమే కాదు, వాటి సందర్భం కూడా. మనం సిద్ధహస్తత్వం మరియు వ్యంగ్యాన్ని అర్థం చేసుకుంటాము, ఒకే మాటలు వాణి టోన్ ప్రకారం విభిన్న అర్థాలు కలిగివుంటాయి.
|
|
|
|
✅ మీరు ఇటీవల మాట్లాడిన సంభాషణలలో కొన్ని గురించి ఆలోచించండి. అది కంప్యూటర్ అర్థం చేసుకోవడానికి ఎంత భాగం కష్టం ఉంటుంది, ఎందుకంటే అది సందర్భం అవసరం?
|
|
|
|
భాష అర్థం చేసుకోవడం, సహజ భాష అర్థం చేసుకోవడం అని కూడా పిలవబడుతుంది, ఇది సహజ భాష ప్రాసెసింగ్ అనే ఆర్టిఫిషియల్ ఇంటెలిజెన్స్ రంగంలో భాగంగా ఉంటుంది, మరియు పాఠాన్ని చదవడం, మాటలు లేదా వాక్యాల వివరాలను అర్థం చేసుకోవడం పై పనిచేస్తుంది. మీరు అలెక్సా లేదా సిరీ వంటి వాయిస్ అసిస్టెంట్ ఉపయోగిస్తే, మీరు భాష అర్థం చేసుకునే సేవలను ఉపయోగించారు. ఇవి ఆ వెనుక పనిచేసే AI సేవలు, "అలెక్సా, టేలర్ స్విఫ్ట్ యొక్క తాజా ఆల్బమ్ ప్లే చేయి" అని చెప్పగానే నా కూతురు ఇంట్లో తన ఇష్టమైన పాటలపై నర్తిస్తోంది.
|
|
|
|
> 💁 కంప్యూటర్లు, అన్ని అభివృద్ధులకుప్పటికీ, నిజమయిన అర్థం చేసుకోవడానికి ఇంకా చాలా దూరం ఉంది. మనం కంప్యూటర్లతో భాష అర్థం చేసుకోవడం అనగా, మనుషుల సంభాషణ లానే ఏమీ కాదు, మంచి మాటల నుండి కీలక వివరాలను ఎక్స్ట్రాక్ట్ చేయడం.
|
|
|
|
మనుషులుగా, మనం భాషను ఆలోచించకుండా అర్థం చేసుకుంటాము. మీరు మరో మనిషిని "టేలర్ స్విఫ్ట్ యొక్క తాజా ఆల్బమ్ ప్లే చేయి" అని అడిగితే, వారు స్వయంచాలకంగా మీ అర్థం తెలుసుకుంటారు. ఇది కంప్యూటర్ కొరకు కష్టం. అది మాటలను, స్పీచ్ నుండి టెక్స్ట్ మార్చబడిన వాటిని తీసుకుని, క్రింది సమాచారాన్ని తెలుసుకోవాలి:
|
|
|
|
* సంగీతం ప్లే చేయాలి
|
|
* సంగీతం ఆర్టిస్ట్ టేలర్ స్విఫ్ట్ ద్వారా పట్టింది
|
|
* ప్రత్యేకంగా ఆ సంగీతం ఒక ఆల్బమ్, అనేక ట్రాక్స్ కలిగి అర్డర్లో ఉండాలి
|
|
* టేలర్ స్విఫ్ట్ కి అనేక ఆల్బములు ఉన్నాయి, కాబట్టి అవి కాలానుక్రమంలో వర్గీకరించాలి, మరియు తాజా విడుదలైనది కావాలి
|
|
|
|
✅ మీరు అడిగిన అభ్యర్థనల్లో, ఉదాహరణకు కాఫీ ఆర్డర్ చేయడం లేదా కుటుంబ సభ్యుని ఏదైనా ఇవ్వమని అడిగిన వాక్యాలలో, వాటిని విభజించి కంప్యూటర్ అర్థం చేసుకోవడానికి అవసరమైన సమాచారాన్ని గుర్తించండి.
|
|
|
|
భాష అర్థం చేసుకునే మోడల్స్ AI మోడల్స్, ఇవి భాష నుండి নির্দিষ্ট వివరాలను ఎక్స్ట్రాక్ట్ చేయడానికి శిక్షణ పొందుతాయి, మరియు తరఫర్ లెర్నింగ్తో ప్రత్యేక పనులకు శిక్షణ ఇవ్వబడతాయి, మీరు చిన్న చిత్రాల సెట్తో కస్టమ్ విజన్ మోడల్ శిక్షణ ఇచ్చిన విధంగా. మీరు ఒక మోడల్ తీసుకుని అచ్ఛి సమాచారంతో శిక్షణ ఇవ్వవచ్చు.
|
|
|
|
## భాష అర్థం చేసుకునే మోడల్ సృష్టించండి
|
|
|
|
|
|
|
|
మీరు LUIS ఉపయోగించి భాష అర్థం చేసుకునే మోడల్స్ సృష్టించవచ్చు, Microsoft యొక్క LUIS అనేది కాగ్నిటివ్ సర్వీసుల భాగమయ్యే భాష అర్థం చేసుకునే సేవ.
|
|
|
|
### టాస్క్ - ఒక ఆథరింగ్ రిసోర్స్ సృష్టించండి
|
|
|
|
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>
|
|
```
|
|
|
|
Resource Group సృష్టించినప్పుడు ఉపయోగించిన `<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*ని మీ భాషకు సెట్ చేయండి.
|
|
|
|
> 💁 prediction resource కి ఒక ఫీల్డ్ ఉంది. మీరు ఉభయ కారికాలకి prediction కోసం రెండవ రిసోర్స్ సృష్టించవచ్చు, కానీ ఉచిత ఆథరింగ్ రిసోర్స్ నెలకు 1,000 predictionలను అనుమతిస్తుంది, ఇది అభివృద్ధికి తగినట్టుగా ఉంటుంది, కనుక ఇది వదిలేయవచ్చు.
|
|
|
|
1. అప్లికేషన్ సృష్టించిన తర్వాత కనిపించే మార్గసూచిని చదవండి, భాష అర్థం చేసుకునే మోడల్ ను శిక్షణ ఇవ్వడానికి ఎటువంటి దశలు అవసరమో అర్థం చేసుకోండి. ఈ గైడ్ పూర్తి అయిన తర్వాత మూసివేయండి.
|
|
|
|
## అభిరుచులు మరియు ఎంటిటీల
|
|
|
|
భాష అర్థం చేసుకోవడం *అభిరుచులు* మరియు *ఎంటిటీల* చుట్టూ ఉంటుంది. అభిరుచులు అనగా మాటల ఉద్దేశం, ఉదాహరణకి సంగీతం ప్లే చేయడం, టైమర్ సెట్ చేయడం, లేదా ఆహారం ఆర్డర్ చేయడం. ఎంటిటీల అనగా అభిరుచికి సంబంధించిన ప్రధాన విషయం, ఉదాహరణకు ఆల్బమ్, టైమర్ వ్యవధి, లేదా ఆహారం రకం. మోడల్ వివరించే ప్రతి వాక్యంలో కనీసం ఒక అభిరుచి మరియు కావాలంటే ఒకటి లేదా అంతకు పైగా ఎంటిటీల ఉండాలి.
|
|
|
|
కొన్ని ఉదాహరణలు:
|
|
|
|
| వాక్యం | అభిరుచి | ఎంటిటీల |
|
|
| --------------------------------------------------- | ---------------- | ------------------------------------------ |
|
|
| "టేలర్ స్విఫ్ట్ యొక్క తాజా ఆల్బమ్ ప్లే చేయి" | *సంగీతం ప్లే చేయి* | *టేలర్ స్విఫ్ట్ యొక్క తాజా ఆల్బమ్* |
|
|
| "3 నిమిషాల టైమర్ సెట్ చేయు" | *టైమర్ సెట్ చేయి* | *3 నిమిషాలు* |
|
|
| "నా టైమర్ రద్దు చేయు" | *టైమర్ రద్దు చేయి* | ఎటువంటి లేవు |
|
|
| "3 పెద్ద అనాస పిజ్జాలు మరియు సీజర్ సలాడ్ ఆర్డర్ చేయి" | *ఆహారం ఆర్డర్ చేయి* | *3 పెద్ద అనాస పిజ్జాలు*, *సీజర్ సలాడ్* |
|
|
|
|
✅ మీరు ముందుగా ఆలోచించిన వాక్యాల్లో, అబిరుచి మరియు ఎంటిటీలు ఏవి ఉండవచ్చు?
|
|
|
|
LUIS లో శిక్షణ ఇవ్వడానికి, మీరు మొదట ఎంటిటీలను సెట్ చేయాలి. ఇవి స్థిరమైన పదాల జాబితా కావచ్చు, లేదా టెక్స్ట్ నుండి నేర్చుకోవచ్చు. ఉదాహరణకు, మీ మెనూలో అందుబాటులో ఉన్న ఆహారం యొక్క స్థిర జాబిత, మరియు వాటి వేరియేషన్లు (సినోనీమ్స్) ఇస్తే, ఉదాహరణకు *egg plant* మరియు *aubergine* అనేవి ఒకే వాటి వేరియేషన్లు. LUIS లోనూ కొన్ని ముందే నిర్మించిన ఎంటిటీలుంటాయి, ఉదాహరణకు సంఖ్యలు, ప్రదేశాలు.
|
|
|
|
టైమర్ సెట్ చేయడానికి, ఒక ఎంటిటీ సమయం కొరకు ప్రీబిల్ట్ సంఖ్య ఎంటిటీగా ఉండవచ్చు, మరొకటి యూనిట్ కోసం, నిమిషాలు, సెకన్లు వంటి. ప్రతి యూనిట్ కు ఏకవచన మరియు బహువచన రూపాలైన వివిధ వేరియేషన్లు ఉండాలి—ఉదాహరణకి minute, minutes.
|
|
|
|
ఎంటిటీల నిర్వచన తర్వాత, అభిరుచులను సృష్టించాలి. మోడల్ మీరు ఇచ్చే ఉదాహరణ వాక్యాల (utterances) ఆధారంగా అభిరుచులను నేర్చుకుంటుంది. ఉదాహరణకి *set timer* అభిరుచికి, క్రింది వాక్యాలు ఇవ్వవచ్చు:
|
|
|
|
* `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కి మీరు ఈ వాక్యాల్లో ఎంటిటీలకు సంబంధించిన భాగాలను గుర్తించి తెలియజేయాలి:
|
|
|
|
|
|
|
|
`set a timer for 1 minute and 12 seconds` వాక్యానికి `set timer` అభిరుచి ఉంది. ఇది రెండు ఎంటిటీలతో మరియు రెండు విలువలతో ఉంది:
|
|
|
|
| | సమయం | యూనిట్ |
|
|
| ---------- | ---: | ------ |
|
|
| 1 నిమిషం | 1 | minute |
|
|
| 12 సెకన్లు | 12 | second |
|
|
|
|
క్లిష్టమైన మోడల్ శిక్షణ కోసం, వివిధ రకాల ఉదాహరణ వాక్యాలు ఉండాలి, ఎందుకంటే ఒకటే అభిరుచికి వేరే వేరే చెప్పే మార్గాలు ఉంటాయి.
|
|
|
|
> 💁 ఏదైనా AI మోడల్ లాగా, ఎంత ఎక్కువ డేటా మరియు అంతకన్నా ఖచ్చితమైన డేటా ఉపయోగిస్తే, మోడల్ అంత మంచిగా పని చేస్తుంది.
|
|
|
|
✅ మీరు ఒకే విషయాన్ని వివిధ రకాలుగా అడిగే ఇతర మార్గాలను ఆలోచించండి మరియు మనిషి దాన్ని అర్థం చేసుకుంటాడు.
|
|
|
|
### టాస్క్ - భాష అర్థం చేసుకునే మోడల్స్ కు ఎంటిటీలను జోడించండి
|
|
|
|
టైమర్ కొరకు, రెండు ఎంటిటీలను జోడించాలి — ఒకటి సమయ యూనిట్ (నిమిషాలు లేదా సెకన్లు), ఒకటి నంబర్ (నిమిషాల లేదా సెకన్ల సంఖ్య).
|
|
|
|
LUIS పోర్టల్ ఉపయోగించే సూచనలు కొరకు [Quickstart: Build your app in LUIS portal - Microsoft Docs](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* ఎంటిటీ జోడించండి.
|
|
|
|
1. **Create** బటన్ ఉపయోగించి సమయ యూనిట్ కోసం కొత్త ఎంటిటీ సృష్టించండి. ఎంటిటీకి `time unit` అని పేరు పెట్టి టైప్ ని *List*గా సెట్ చేయండి. *Normalized values* జాబితాలో `minute` మరియు `second` విలువలు జోడించండి, అలాగే వాటి ఏకవచనం మరియు బహువచనలు *synonyms* జాబితాలో జోడించండి. ప్రతి సున్నితమైన పదం జోడించిన తర్వాత `return` నొక్కి జాబితాలో చేర్చండి.
|
|
|
|
| సాధారణీకరించిన విలువు | సమానార్థకాలు |
|
|
| ---------------- | --------------- |
|
|
| minute | minute, minutes |
|
|
| second | second, seconds |
|
|
|
|
### టాస్క్ - భాష అర్థం చేసుకునే మోడల్స్ కు అభిరుచులను జోడించండి
|
|
|
|
1. *Intents* ట్యాబ్ నుండి **Create** బటన్ నొక్కి కొత్త అభిరుచి సృష్టించండి. దీనికి పేరు `set timer` అని పెట్టండి.
|
|
|
|
1. ఉదాహరణల్లో, నిమిషాలు, సెకన్లు మరియు రెండు కలిపి టైమర్ సెట్ చేసే విభిన్న మార్గాలు ఇవ్వండి. ఉదాహరణలు:
|
|
|
|
* `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`
|
|
|
|
సంఖ్యలను పదాలుగా మరియు సంఖ్యలుగా మిళితం చేయండి, మోడల్ రెండింటినీ గుర్తించలేకుండా ఉండకూడదు.
|
|
|
|
1. ప్రతి ఉదాహరణ ఇవ్వగానే, LUIS ఎంటిటీలను గుర్తించడం ప్రారంభిస్తుంది మరియు లేబులు మరియు అండర్లైనింగ్ చేస్తుంది.
|
|
|
|
|
|
|
|
### టాస్క్ - మోడల్ శిక్షణ మరియు పరీక్ష
|
|
|
|
1. ఎంటిటీలు మరియు అభిరుచులు సెట్ చేసిన తర్వాత, టాప్ మెనూ లో **Train** బటన్ నొక్కి మోడల్ శిక్షణ ఇవ్వండి. కొద్ది సెకన్లలో శిక్షణ పూర్తి అవుతుంది. శిక్షణ సమయంలో బటన్ గ్రేవ్ అవుతుంది, తర్వాత తిరిగి ఎనేబుల్ అవుతుంది.
|
|
|
|
1. టాప్ మెనూ నుండి **Test** బటన్ నొక్కి భాష అర్థం చేసుకునే మోడల్ పరీక్షించండి. `set a timer for 5 minutes and 4 seconds` వంటిది టైప్ చేసి ఎంటర్ నొక్కండి. మీరు టైప్ చేసిన టెక్స్ట్ పైన బాక్స్లో చూపిస్తుంది, క్రింద *top intent* లేదా అత్యధిక ప్రాబబిలిటీతో కనుగొన్న అభిరుచి చూపిస్తుంది. ఇది `set timer` అయి ఉండాలి. అభిరుచి పేరు తర్వాత ప్రాబబిలిటి కూడా చూపిస్తుంది.
|
|
|
|
1. ఫలితాల విభజన చూడటానికి **Inspect** ఎంపిక ఎంచుకోండి. మీరు టాప్ స్కోరింగ్ అభిరుచి మరియు శాతం ప్రాబబిలిటీ, మరియు కనుగొన్న ఎంటిటీల జాబితా చూస్తారు.
|
|
|
|
1. పరీక్ష పూర్తయిన తర్వాత *Test* ప్యానెల్ మూసివేయండి.
|
|
|
|
### టాస్క్ - మోడల్ ప్రచురించండి
|
|
|
|
కోడ్ నుండి ఈ మోడల్ ఉపయోగించడానికి, మీరు దీన్ని ప్రచురించాలి. LUIS నుండి ప్రచురించేటప్పుడు, మీరు పరీక్షకి స్టేజింగ్ ఎన్విరాన్మెంట్ లేదా పూర్తి విడుదలకోసం ప్రొడక్ట్ ఎన్విరాన్మెంట్ ఎంచుకోవచ్చు. ఈ పాఠంలో, స్టేజింగ్ ఎన్విరాన్మెంట్ సరిపోతుంది.
|
|
|
|
1. LUIS పోర్టల్ నుండి టాప్ మెనూ లో **Publish** బటన్ నొక్కండి.
|
|
|
|
1. *Staging slot* ఎంచుకుని, తరువాత **Done** ఎంచుకోండి. అప్లికేషన్ ప్రచురించిన తరువాత నోటిఫికేషన్ వస్తుంది.
|
|
1. మీరు దీన్ని curl ఉపయోగించి పరీక్షించవచ్చు. curl ఆజ్ఞను రూపొందించడానికి, మీరు మూడు విలువలు అవసరం - endpoint, అప్లికేషన్ ID (App ID) మరియు API కీ. ఇవి టాప్ మెను నుండి ఎంచుకోవగల **MANAGE** టాబ్ నుండి యాక్సెస్ చేయవచ్చు.
|
|
|
|
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 హబ్ ఉపయోగించి క్లౌడ్ సేవలతో కమ్యూనికేషన్ నిర్వహించేందుకు, టెలిమేట్రీ పంపించటానికి మరియు ఆజ్ఞల కోసం వినేలా ఉపయోగించారు. ఇది చాలా అసంక్రామ్యంగా ఉంటుంది - టెల్మేట్రీ పంపిన వెంటనే మీ కోడ్ స్పందన కోసం వేచి ఉండదు, మరియు క్లౌడ్ సేవ డౌన్ అయితే, మీరు తెలియదు.
|
|
|
|
స్మార్ట్ టైమర్ కోసం, మేము వెంటనే స్పందన కావాలి, కాబట్టి యూజర్ కి టైమర్ సెట్ అయ్యింది అని చెప్పగలుగుతాము, లేదా క్లౌడ్ సేవలు అందుబాటులో లేవని హెచ్చరించవచ్చు. దీని కోసం, మా IoT డివైస్ ఒక వెబ్ ఎండ్పాయింట్ ని నేరుగా పిలుస్తుంది, IoT హబ్ పై ఆధారపడకుండా.
|
|
|
|
LUIS ని IoT డివైస్ నుండి నేరుగా పిలవడం కన్నా, మీరు వేరే రకమైన ట్రిగ్గర్ తో సర్వర్లెస్ కోడ్ ఉపయోగించవచ్చు - HTTP ట్రిగ్గర్. ఇది మీ ఫంక్షన్ అప్లికేషన్ REST అభ్యర్థనలకు వేచిచూస్తుంది మరియు వాటికి స్పందిస్తుంది. ఈ ఫంక్షన్ మీ డివైస్ పిలవగల REST ఎండ్పాయింట్ అవుతుంది.
|
|
|
|
> 💁 మీరు మీ IoT డివైస్ నుండి నేరుగా LUIS పిలవవచ్చు అయినా, సర్వర్లెస్ కోడ్ వంటిది ఉపయోగించడం బెటర్. దీని ద్వారా మీరు పిలవబోయే LUIS అప్లికేషన్ మార్చాలనుకున్నప్పుడు, ఉదాహరణకు బెటర్ మోడల్ ట్రైన్ చేసినప్పుడు లేదా ఇతర భాషలో మోడల్ ట్రైన్ చేసినప్పుడు, మీరు మీ క్లౌడ్ కోడ్ మాత్రమే అప్డేట్ చేస్తారు, వేల లేదా లక్షల 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 API కీ, ఎండ్పాయింట్ URL, మరియు App ID కోసం **MANAGE** టాబ్ యొక్క LUIS పోర్టల్ నుండి ఈ విలువలను మీ `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)
|
|
```
|
|
|
|
ఇది `local.settings.json` ఫైల్ లో జత చేసిన విలువలను లోడింగ్ చేస్తుంది, API కీతో క్రెడెంజియల్స్ ఆబ్జెక్ట్ సృష్టిస్తుంది, ఆపై 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 నుండి అభిప్రాయాలు (predictions) అభ్యర్థించడానికి, JSON డాక్యుమెంట్ - అర్ధం చేసుకోవలసిన వాక్యం తో prediction రిక్వెస్ట్ సృష్టించండి:
|
|
|
|
```python
|
|
prediction_request = { 'query' : text }
|
|
```
|
|
|
|
1. ఈ అభ్యర్థనను LUIS కు పంపండి, తద్వారా మీరు ప్రచురించిన స్టేజింగ్ స్లాట్ ఉపయోగించబడుతుంది:
|
|
|
|
```python
|
|
prediction_response = client.prediction.get_slot_prediction(app_id, 'Staging', prediction_request)
|
|
```
|
|
|
|
1. prediction ప్రతిస్పందనలో టాప్ ఇంటెంట్ ఉంటుంది - అత్యధిక పూర్వానుమాన స్కోరు ఉన్న ఇంటెంట్, అలాగే ఎంటిటీలను కూడా చూపిస్తుంది. టాప్ ఇంటెంట్ `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)
|
|
```
|
|
|
|
ఈ కోడ్ టైమర్ కొరకు మొత్తం సెకన్లతో కూడిన పayload సృష్టించి, దాన్ని JSON స్ట్రింగ్ గా మార్చి 200 స్టేటస్ కోడ్ తో HTTP ఫలితంగా తిరిగి ఇస్తుంది, దీని అర్థం కాల్ విజయవంతమయింది.
|
|
|
|
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 Trigger డాక్యుమెంటేషన్ లోని కాన్ఫిగరేషన్ విభాగం](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 పై, [మ్యాక్ లో 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 చిరునామా తెలుసుకున్న తరువాత, మీరు ఫంక్షన్ ని ఈ 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 యాప్లో ఉదాహరణలుగా ఉపయోగించండి. భేదభిన్నమైన రీతుల్లో టైమర్ని కోరగలగడం మీ మోడల్ ఎంత బాగా సహాయపడుతుందో పరీక్షించండి.
|
|
|
|
## ఉపన్యాసం తరువాత క్విజ్
|
|
|
|
[ఉపన్యాసం తరువాత క్విజ్](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/44)
|
|
|
|
## సమీక్ష & స్వీయ అధ్యయనం
|
|
|
|
* LUIS మరియు దాని సామర్థ్యాల గురించి మరింత చదవండి [Language Understanding (LUIS) డాక్యుమెంటేషన్ పేజీ Microsoft డాక్స్లో](https://docs.microsoft.com/azure/cognitive-services/luis/?WT.mc_id=academic-17441-jabenn)
|
|
* భాషా అవగాహన గురించి మరింత తెలుసుకోండి [ప్రाकृतिक-భాషా అవగాహన Wikipedia పేజీ](https://wikipedia.org/wiki/Natural-language_understanding)
|
|
* HTTP ట్రిగ్గర్ల గురించి మరింత చదవండి [Azure Functions HTTP ట్రిగ్గర్ డాక్యుమెంటేషన్ Microsoft డాక్స్లో](https://docs.microsoft.com/azure/azure-functions/functions-bindings-http-webhook-trigger?WT.mc_id=academic-17441-jabenn&tabs=python)
|
|
|
|
## అసైన్మెంట్
|
|
|
|
[టైమర్ రద్దు చేయండి](assignment.md)
|
|
|
|
---
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
**వెయ్యింపు**:
|
|
ఈ దస్త్రం AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఆధారంగా అనువదించబడింది. ఖచ్చితత్వం కోసం మేము యత్నిస్తున్నప్పటికీ, ఆప్టోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా అపవృత్తులు ఉండవచ్చు. అసలు దస్త్రం తన స్వదేశీ భాషలోనే అధికారిక ఆధారంగా పరిగణించబడాలి. ముఖ్యమైన సమాచారం కోసం, ప్రామాణిక మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం ఉపయోగం వల్ల కలిగే ఏమైనా తప్పుదోషాలు లేదా తప్పుబాట్లకు మేము బాధ్యులు కాదు.
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |