IoT-For-Beginners/translations/kn/6-consumer/lessons/2-language-understanding/README.md

# ಭಾಷೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ

![ಈ ಪಾಠದ ಸ್ಕೆಚ್‌ನೋಟ್ ಅವಲೋಕನ](../../../../../translated_images/kn/lesson-22.6148ea28500d9e00.webp)

> ಸ್ಕೆಚ್‌ನೋಟ್ [ನಿತ್ಯ ನರಸಿಂಹನ್](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) ಎಂಬ ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯ ಕ್ಷೇತ್ರದಲ್ಲಿ ಭಾಗವಾಗಿದೆ, ಮತ್ತು ಪದಗಳು ಅಥವಾ ವಾಕ್ಯಗಳ ವಿವರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಓದುವಿಕೆ ಸಮಗ್ರತೆಯನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ. ನಿಮ್ಮಲ್ಲಿ ಅಲೆಕ್ಸಾ ಅಥವಾ ಸಿರಿ ಆವಿಯಾದ ಧ್ವನಿ ಸಹಾಯಕರಿದ್ದರೆ, ನೀವು ಭಾಷಾ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆಯನ್ನು ಬಳಸಿದ್ದೀರಿ. ಇವು "ಅಲೆಕ್ಸಾ, Taylor Swift ಅವರ ಇತ್ತೀಚಿನ ಆಲ್ಬಮ್ ಪ್ಲೇ ಮಾಡಿ" ಅನ್ನು ನನ್ನ ಮಗಳ ಮನೆಯಲ್ಲಿಯೇ ತನ್ನ ಪ್ರಿಯ ಗೀತಿಗಳೊಂದಿಗೆ ನೃತ್ಯ ಮಾಡುವುದಕ್ಕೆ ಪರಿವರ್ತಿಸುವ ಹಿನ್ನೆಲೆ AI ಸೇವೆಗಳು.

> 💁 ಕಂಪ್ಯೂಟರ್‌ಗಳು ಎಲ್ಲಾ ಅಭಿವೃದ್ಧಿಯ باوجود, ಪಠ್ಯವನ್ನು ನಿಜವಾದರೀತಿಯಲ್ಲಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಇನ್ನೂ ದಾರಿಯಿದೆ. ಕಂಪ್ಯೂಟರ್‌ಗಳೊಂದಿಗೆ ನಾವು ಭಾಷಾ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಬಗ್ಗೆ ಹೇಳುವುದರಲ್ಲಿ, ಮಾನವ ಸಂವಹನದ ಮಟ್ಟಿಗೆ ಬಲಿಷ್ಟ ಅರ್ಥವಲ್ಲ, ಆದರೆ ಕೆಲ ಪದಗಳನ್ನು ತೆಗೆದು ಅಗತ್ಯ ಮಾಹಿತಿಯನ್ನು ಹೊರತೆಗೆದುಕೊಳ್ಳುವುದು.

ಮಾನವರು ಭಾವನೆಗೂಡಿಸದೆ ಭಾಷೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತಾರೆ. ನಾನು ಮತ್ತೊಬ್ಬ ಮಾನವನಿಗೆ "Taylor Swift ಅವರ ಇತ್ತೀಚಿನ ಆಲ್ಬಮ್ ಪ್ಲೇ ಮಾಡಿ" ಎಂದರೆ ಅವರು ಸ್ವಭಾವಿಕವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತಾರೆ. ಆದರೆ ಕಂಪ್ಯೂಟರ್‌ಗೆ ಇದು ಕಷ್ಟ. ಇದು ಧ್ವನಿಯಿಂದ ಪಠ್ಯಕ್ಕೆ ಪರಿವರ್ತಿತ ಪದಗಳನ್ನು ತೆಗೆದು ಈ ಮಾಹಿತಿಗಳನ್ನು ತಯಾರಿಸಬೇಕಾಗುತ್ತದೆ:

* ಸಂಗೀತವನ್ನು ಪ್ಲೇ ಮಾಡಬೇಕಾಗಿದೆ
* ಸಂಗೀತ ಕಲಾವಿದ Taylor Swift ಅವರದು
* ವಿಶೇಷವಾಗಿ ಒಂದು ಸಂಪೂರ್ಣ ಆಲ್ಬಮ್ ಅನೇಕ ಟ್ರ್ಯಾಕ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ
* Taylor Swift ಅವರ ಹಲವಾರು ಆಲ್ಬಮ್‌ಗಳಿವೆ, ಅವುಗಳನ್ನು ಕಾಲಾನುಕ್ರಮದಲ್ಲಿ ಸಿಂಪಡಿಸಿ ಇತ್ತೀಚಿನ ಬಿಡುಗಡೆ ಮಾಡಲಾದ ಆಲ್ಬಮ್ ಬೇಕು

✅ ನೀವು ಕೇಳಿದ್ದ ಕೆಲವು ಇತರ ವಾಕ್ಯಗಳನ್ನು ಯೋಚಿಸಿ, ಉದಾಹರಣೆಗೆ ಕಾಫಿ ಆದೇಶಿಸುವಾಗ ಅಥವಾ ಕುಟುಂಬ ಸದಸ್ಯರಿಂದ ಏನಾದರೂ ಕೇಳುವಾಗ. ನಿಮ್ಮ ಕೋಂಪ್ಯೂಟರ್ ಅವುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಅಗತ್ಯ ಮಾಹಿತಿಯನ್ನು ತುಂಡಾಗಿ ಹೆಚ್ಚಿಸುವ ಪ್ರಯತ್ನ ಮಾಡಿ.

ಭಾಷಾ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಮಾದರಿಗಳು AI ಮಾದರಿಗಳು, ಅವುಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ವಿವರಗಳನ್ನು ಭಾಷೆಯಿಂದ ಹೊರತೆಗೆದುಕೊಳ್ಳಲು ತರಬೇತಿ ನೀಡಲಾಗಿದೆ, ನಂತರ ವರ್ಗೀಕರಣ ತರಬೇತಿಯನ್ನು ಬಳಸಿಕೊಂಡು ವಿವಿಧ ಕಾರ್ಯಗಳಿಗೆ ತರಬೇತು ಮಾಡಲಾಗುತ್ತದೆ, ನೀವು ಕಸ್ಟಮ್ ವಿಷನ್ ಮಾದರಿಯನ್ನು ಸಣ್ಣ ಚಿತ್ರಗಳ ಸಮೆಟ್ ಬಳಸಿಕೊಂಡು ತರಬೇತು ಮಾಡಿದಂತೆ. ನೀವು ಒಂದು ಮಾದರಿಯನ್ನು ಪಡೆದು, ಅದನ್ನು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕಾದ ಪಠ್ಯದಿಂದ ತರಬೇತು ಮಾಡಬಹುದು.

## ಭಾಷಾ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆಯ ಮಾದರಿಯನ್ನು ಸೃಷ್ಟಿಸುವುದು

![LUIS ಲೋಗೋ](../../../../../translated_images/kn/luis-logo.5cb4f3e88c020ee6.webp)

ನೀವು LUIS ಅನ್ನು ಬಳಸಿಕೊಂಡು ಭಾಷಾ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆಯ ಮಾದರಿಗಳನ್ನು ರಚಿಸಬಹುದು, ಇದು 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>
    ```

    ನೀವು 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) ನಲ್ಲಿ LUIS ಪೋರ್ಟಲ್ ತೆರೆಯಿರಿ ಮತ್ತು ಅದೇ ಖಾತೆಯನ್ನು ಬಳಸಿ Azure ಗೆ ಸೈನ್ ಇನ್ ಆಗಿ.

1. ಸಂವಾದದ ನಿರ್ದೇಶನಗಳನ್ನು ಅನುಸರಿಸಿ ನಿಮ್ಮ Azure ಸಬ್ಸ್ಕ್ರಿಪ್ಶನ್ ಆಯ್ಕೆ ಮಾಡಿ, ನಂತರ ನೀವು ರಚಿಸಿರುವ `smart-timer-luis-authoring` ಸಂಪನ್ಮೂಲವನ್ನು ಆಯ್ಕೆಮಾಡಿ.

1. *Conversation apps* ಪಟ್ಟಿಯಿಂದ **New app** ಬಟನ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ ಹೊಸ ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸಿ. ಹೊಸ ಅಪ್ಲಿಕೇಶನಿಗೆ `smart-timer` ಎಂದು ಹೆಸರು ನೀಡಿ ಮತ್ತು *Culture* ಅನ್ನು ನಿಮ್ಮ ಭಾಷೆಗೆ ಹೊಂದಿಸಿ.

    > 💁 ಪ್ರಿಡಿಕ್ಷನ್ ಸಂಪನ್ಮೂಲಕ್ಕಾಗಿ ಫೀಲ್ಡ್ ಇದೆ. ನೀವು ಪ್ರಿಡಿಕ್ಷನ್‌ಗೆ ದ್ವಿತೀಯ ಸಂಪನ್ಮೂಲವನ್ನು ಸೃಷ್ಟಿಸಬಹುದು, ಆದರೆ ಉಚಿತ ರಚನೆ ಸಂಪನ್ಮೂಲವು ತಿಂಗಳಿಗೆ 1,000 ಪ್ರಿಡಿಕ್ಷನ್ಗಳಿಗೆ ಬಿಡುತ್ತದೆ, ಇದು ಅಭಿವೃದ್ಧಿಗೆ ಸಾಕಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಇದನ್ನು ಬಿಡಬಹುದು.

1. ಅಪ್ಲಿಕೇಶನ್ ಸೃಷ್ಟಿಸಿದ ಮೇಲೆ ಕಾಣಿಸುವ ಮಾರ್ಗಸೂಚಿಯನ್ನು ಓದಿ, ಭಾಷಾ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಮಾದರಿಯನ್ನು ತರಬೇತು ಮಾಡಲು ನೀವು ತೆಗೆದುಕೊಳ್ಳಬೇಕಾದ ಹಂತಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ. ಮುಗಿಸಿದ ಮೇಲೆ ಮಾರ್ಗಸೂಚಿಯನ್ನು ಮುಚ್ಚಿ.

## ಉದ್ದೇಶಗಳು ಮತ್ತು ಘಟಕಗಳು

ಭಾಷಾ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆಯು *ಉದ್ದೇಶಗಳು* ಮತ್ತು *ಘಟಕಗಳ* ಸುತ್ತಲೂ ಇರುತ್ತದೆ. ಉದ್ದೇಶಗಳು ಎಂದರೆ ಪದಗಳ ಗುರಿ, ಉದಾಹರಣೆಗೆ ಸಂಗೀತ ಪ್ಲೇ ಮಾಡುವುದು, ಟೈಮರ್ ಸೆಟ್ ಮಾಡುವುದು, ಅಥವಾ ಆಹಾರವನ್ನು ಆದೇಶ ಮಾಡುವುದು. ಘಟಕಗಳು ಎಂದರೆ ಉದ್ದೇಶ ಯಾವ ವಿಷಯಗಳಿಗೆ ಸಂಬಂಢವಿರುವುದು, ಉದಾಹರಣೆಗೆ ಆಲ್ಬಮ್, ಟೈಮರ್ ಅವಧಿ, ಆದರೆ ಆಹಾರದ ವಿಧ. ಮಾದರಿ ವಿಶ್ಲೇಷಿಸುವ ಪ್ರತಿಯೊಂದು ವಾಕ್ಯಕ್ಕೂ ಕನಿಷ್ಠ ಒಂದು ಉದ್ದೇಶ ಮತ್ತು ಆಯ್ಕೆಮಾಡಬಹುದಾದ ಒಂದು ಅಥವಾ ಹೆಚ್ಚು ಘಟಕಗಳಿರಲಿ.

ಕೆಲವು ಉದಾಹರಣೆಗಳು:

| ವಾಕ್ಯ                                               | ಉದ್ದೇಶ            | ಘಟಕಗಳು                                     |
| -------------------------------------------------- | ----------------- | ------------------------------------------- |
| "Taylor Swift ಅವರ ಇತ್ತೀಚಿನ ಆಲ್ಬಮ್ ಪ್ಲೇ ಮಾಡಿ"       | *ಸಂಗೀತ ಪ್ಲೇ ಮಾಡಿ* | *Taylor Swift ಅವರ ಇತ್ತೀಚಿನ ಆಲ್ಬಮ್*           |
| "3 ನಿಮಿಷದ ಟೈಮರ್ ಸೆಟ್ ಮಾಡಿ"                        | *ಟೈಮರ್ ಸೆಟ್ ಮಾಡಿ* | *3 ನಿಮಿಷಗಳು*                                |
| "ನನ್ನ ಟೈಮರ್ ರದ್ದುಗೊಳಿಸಿ"                           | *ಟೈಮರ್ ರದ್ದುಗೊಳಿಸಿ* | ಇಲ್ಲವೆ                                     |
| "3 ದೊಡ್ಡ ಪೈನಾಪಲ್ ಪಿಜ್ಜಾಗಳನ್ನು ಮತ್ತು ಸೀಸರ್ ಸಲಾಡ್ ಆದೇಶಿಸು" | *ಆಹಾರ ಆದೇಶಿಸು* | *3 ದೊಡ್ಡ ಪೈನಾಪಲ್ ಪಿಜ್ಜಾಗಳು*, *ಸೀಸರ್ ಸಲಾಡ್* |

✅ ನೀವು ಮೊದಲು ಯೋಚಿಸಿದ ವಾಕ್ಯಗಳಲ್ಲಿ, ಯಾವುದಾದರೂ ಉದ್ದೇಶ ಮತ್ತು ಘಟಕಗಳೇನಿದೆ ಎಂದು ತಿಳಿಸಿ.

LUIS ತರಬೇತಿಗಾಗಿ, ಮೊದಲು ಘಟಕಗಳನ್ನು ಹೊಂದಿಸಬೇಕು. ಇವು ನಿರ್ದಿಷ್ಟ ಪದಗಳ ಸ್ಥಳಪಟ್ಟಿ ಆಗಿರಬಹುದು, ಅಥವಾ ಪಠ್ಯದಿಂದ ಕಲಿಯಬಹುದು. ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಮೆನುನಲ್ಲಿ ದೊరಕುವ ಆಹಾರಗಳ ನಿಯತಪಟ್ಟಿಯನ್ನು ನೀಡಬಹುದು, ಪ್ರತಿಯೊಂದು ಪದದ ಬದಲಾಗುವ ರೂಪಗಳೊಂದಿಗೆ (ಅಥವಾ ಪರ್ಯಾಯ ಪದಗಳು), ಉದಾಹರಣೆಗೆ *egg plant* ಮತ್ತು *aubergine* ಅನ್ನು *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 ಎಂಬ ವಾಕ್ಯವನ್ನು ಘಟಕಗಳಾಗಿ ವಿಭಜಿಸಲಾಗಿದೆ](../../../../../translated_images/kn/sentence-as-intent-entities.301401696f992259.webp)

`set a timer for 1 minute and 12 seconds` ಎಂಬ ವಾಕ್ಯದ ಉದ್ದೇಶ `set timer` ಆಗಿದೆ. ಇದರಲ್ಲಿ 2 ಘಟಕಗಳಿವೆ, ಪ್ರತಿಯೊಂದು 2 ಮೌಲ್ಯಗಳು ಗಿಟ್ಟಿದೆ:

|            | ಸಮಯ | ಘಟಕ    |
| ---------- | ---: | ------- |
| 1 ನಿಮಿಷ    | 1    | minute  |
| 12 ಸೆಕೆಂಡು | 12   | second  |

ಒಳ್ಳೆಯ ಮಾದರಿಯನ್ನು ತರಬೇತು ಮಾಡಲು, ನಾವು ವಿವಿಧ ಉದಾಹರಣಾ ವಾಕ್ಯಗಳನ್ನು ಹೊಂದಿರಬೇಕು, ಯಾರು ಒಂದೇ ವಿಷಯವನ್ನು ಕೇಳುವ ವಿವಿಧ ರೀತಿಗಳನ್ನು ಒಳಗೊಂಡಿರಲಿ.

> 💁 ಯಾವುದೇ 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* ಪೂರ್ವನಿರ್ಮಿತ ಘಟಕವನ್ನು ಸೇರಿಸಿ.

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. ಉದಾಹರಣೆಗಳಲ್ಲಿ, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡುಗಳು ಮತ್ತು ಅವುಗಳ ಸಂಯೋಜನೆಯೊಂದಿಗೆ ಟೈಮರ್ ಸೆಟ್ ಮಾಡುವ ವಿವಿಧ ಮಾರ್ಗಗಳನ್ನು ನಮೂದಿಸಿ. ಉದಾಹರಣೆಗಳು:

    * `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 ಘಟಕಗಳ ಕಂಡುಹಿಡಿವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಆದರೆ ಕಂಡುಕೊಂಡಿರುವ ಎಲ್ಲವನ್ನು ಅಡಿಕೆಮಾಡಿ ಮತ್ತು ಲೇಬಲ್ ಮಾಡುತ್ತದೆ.

    ![ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಸಮಯ ಘಟಕಗಳನ್ನು LUIS ಅಡಿಗೆಮಾಡಿರುವ ಉದಾಹರಣೆಗಳು](../../../../../translated_images/kn/luis-intent-examples.25716580b2d2723c.webp)

### ಕಾರ‍್ಯ - ಮಾದರಿಯನ್ನು ತರಬೇತುಮಾಡಿ ಮತ್ತು ಪರೀಕ್ಷಿಸಿ

1. ಘಟಕಗಳು ಮತ್ತು ಉದ್ದೇಶಗಳು ಹೊಂದಿಕೆಯಾಗಿದ್ದಾಗಿ, *Train* ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸಿ. ಈ ಬಟನ್‌ನಿಂದ ತರಬೇತು ಪ್ರಕ್ರಿಯೆ ಕೆಲವು ಸೆಕೆಂಡುಗಳಲ್ಲಿ ನಡೆಯುತ್ತದೆ. ತರಬೇತು ಪ್ರಾರಂಭವಾಗಿದ್ದಾಗ ಬಟನ್ ಬೂದು ಬಣ್ಣವಾಗುತ್ತದೆ ಮತ್ತು ಮುಗಿದುಳಿದರೆ ಮತ್ತೆ ಯೋಗ್ಯವಾಗುತ್ತದೆ.

1. *Test* ಬಟನ್ ಮೂಲಕ ಭಾಷಾ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆಯ ಮಾದರಿಯನ್ನು ಪರೀಕ್ಷಿಸಿ. ಉದಾಹರಣೆಗೆ `set a timer for 5 minutes and 4 seconds` ಎಂದು ನಮೂದಿಸಿ `return` ಒತ್ತಿರಿ. ನೀವು ಟೈಪಿಸಿದ ಪಠ್ಯದ ಕೆಳಗಿನ ಬಾಕ್ಸಿನಲ್ಲಿ ಪಠ್ಯ ಕಾಣಿಕೆ, ಮತ್ತು ಅದಕ್ಕೆ ಹೊಂದಿಕೊಂಡ *ಒಳಗಿನ ಉದ್ದೇಶ* (top intent) ಮೂಡಿ ಬರುವದು, ಹೆಚ್ಚಿನ ಸಾಧ್ಯತೆಯಿಂದ ಕಂಡುಬಂದ ಉದ್ದೇಶ. ಅದು `set timer` ಆಗಿರಬೇಕು. ಉದ್ದೇಶದ ಹೆಸರು ಬರುವ ನಂತರ ಆ ಉದ್ದೇಶವು ಸರಿಯಾದದ್ದು ಎಂಬ ಸಾಧ್ಯತೆಯು ನೀಡಲ್ಪಡುವುದು.

1. ಫಲಿತಾಂಶಗಳನ್ನು ಬಹಿರಂಗಗೊಳಿಸಲು *Inspect* ಆಯ್ಕೆಮಾಡಿ. ನೀವು ಶ್ರೇಯಸ್ಸು ಪ್ರಮಾಣದೊಂದಿಗೆ ಉನ್ನತ ಸ್ಕೋರಿಂಗ್ ಉದ್ದೇಶವನ್ನು ಮತ್ತು ಕಂಡುಹಿಡಿದ ಘಟಕಗಳ ಪಟ್ಟಿಗಳನ್ನು ನೋಡಬಹುದಾಗಿದೆ.

1. ಪರೀಕ್ಷೆ ಮುಗಿದ ಮೇಲೆ *Test* ಪೇನನ್ನು ಮುಚ್ಚಿ.

### ಕಾರ‍ಯ - ಮಾದರಿಯನ್ನು ಪ್ರಕಟಿಸಿ

ಈ ಮಾದರಿಯನ್ನು ಕೋಡ್ ನಿಂದ ಬಳಕೆಗೆ, ಅದನ್ನು ಪ್ರಕಟಿಸಬೇಕಾಗುತ್ತದೆ. LUIS ನಿಂದ ಪ್ರಕಟಿಸುವಾಗ, ಪರೀಕ್ಷೆಗಾಗಿ ಸ್ಟೇಜಿಂಗ್ ಪರಿಸರ ಅಥವಾ ಪೂರ್ಣ ಬಿಡುಗಡೆಗಾಗಿ ಉತ್ಪನ್ನ ಪರಿಸರಕ್ಕೆ ಪ್ರಕಟಿಸಬಹುದು. ಈ ಪಾಠದಲ್ಲಿ, ಸ್ಟೇಜಿಂಗ್ ಪರಿಸರ ನೀಡಲಾಗಿದೆ.

1. LUIS ಪೋರ್ಟಲ್‌ನಿಂದ ಮೇಲಿನ ಮೆನುನಲ್ಲಿ **Publish** ಬಟನ್ ಆಯ್ಕೆಮಾಡಿ.

1. *Staging slot* ಆಯ್ಕೆಮಾಡಿದಿರೋಣ ಎಂದು ಖಚಿತಪಡಿಸಿ, ನಂತರ **Done** ಕ್ಲಿಕ್ ಮಾಡಿ. ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಕಟಿತವಾದಾಗ ನೋಟಿಫಿಕೇಶನ್ ಕಾಣಸಿಗುತ್ತದೆ.
1. ನೀವು ಇದನ್ನು curl ಬಳಸಿ ಪರೀಕ್ಷಿಸಬಹುದು. curl ಕಮಾಂಡ್ ನಿರ್ಮಿಸಲು, ನಿಮಗೆ ಮೂರು ಮೌಲ್ಯಗಳ ಅಗತ್ಯವಿದೆ - ಎಂಡ್‌ಪಾಯಿಂಟ್, ಅಪ್ಲಿಕೇಶನ್ ಐಡಿ (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* ವಿಭಾಗದಿಂದ ಎಂಡ್‌ಪಾಯಿಂಟ್ URL ಆಗಿ ಬದಲಾಯಿಸಿ.

    `<app id>` ನ್ನು *Settings* ವಿಭಾಗದಿಂದ App ID ಆಗಿ ಬದಲಾಯಿಸಿ.

    `<primary key>` ನ್ನು *Azure Resources* ವಿಭಾಗದಿಂದ ಪ್ರಾಥಮಿಕ ಕೀ ಆಗಿ ಬದಲಾಯಿಸಿ.

    `<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% ಸಂಭವನೀಯತೆಯುಳ್ಳ ಪ್ರಮುಖ ಉದ್ದೇಶವಾಗಿತ್ತು.
    * ಎರಡು *ಸಂಖ್ಯೆ* ಘಟಕಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲಾಯಿತು, `45` ಮತ್ತು `12`.
    * ಎರಡು *ಸಮಯದ-ಘಟಕ*ಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲಾಯಿತು, `minute` ಮತ್ತು `second`.

## ಭಾಷಾ ಅರ್ಥಮಾಡಿಕೆ ಮಾದರಿಯನ್ನು ಉಪಯೋಗಿಸಿ

ಒಮ್ಮೆ ಪ್ರಕಟಿಸಿದ ಮೇಲೆ, LUIS ಮಾದರಿಯನ್ನು ಕೋಡ್‌ನಿಂದ ಕರೆ ಮಾಡಬಹುದು. ಹಿಂದಿನ ಪಾಠಗಳಲ್ಲಿ, ನೀವು IoT ಹಬ್ ಅನ್ನು ಬಳಸಿ ಕ್ಲೌಡ್ ಸೇವೆಗಳೊಂದಿಗೆ ಸಂವಹನ ಮಾಡಲು, ಟೆಲಿಮೆಟ್ರಿಯನ್ನು ಕಳುಹಿಸಲು ಮತ್ತು ಆಜ್ಞೆಗಳನ್ನು ಕೇಳಲು ಉಪಯೋಗಿಸಿದ್ದೀರಿ. ಇದು ಬಹಳ ಅಸಂಕ್ರಾಮಕವಾಗಿದೆ - ಟೆಲಿಮೆಟ್ರಿ ಕಳುಹಿಸಿದ ನಂತರ ನಿಮ್ಮ ಕೋಡ್ ಪ್ರತಿಕ್ರಿಯೆಗಾಗಿ ಕಾಯುವುದಿಲ್ಲ, ಮತ್ತು ಕ್ಲೌಡ್ ಸೇವೆ ನಿಂತಿದ್ದರೆ ನೀವು ಗೊತ್ತಾಗುವುದಿಲ್ಲ.

ಸ್ಮಾರ್ಟ್ ಟೈಮರಿಗೆ, ನಾವು ತೆರವು ಪ್ರಮಾಣವಾದ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಬಯಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ನಾವು ಬಳಕೆದಾರರಿಗೆ ಟೈಮರ್ ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಎಂದು ಹೇಳಬಹುದು ಅಥವಾ ಕ್ಲೌಡ್ ಸೇವೆಗಳು ಲಭ್ಯವಿಲ್ಲದಿರುವ ಬಗ್ಗೆ ಎಚ್ಚರಿಸಬಹುದು. ಇದಕ್ಕಾಗಿ, ನಮ್ಮ IoT ಸಾಧನವು ನೇರವಾಗಿ ವೆಬ್ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಕರೆ ಮಾಡುವುದಾಗಿದೆ, IoT ಹಬ್‌ನ ಮೇಲೆ ಅವಲಂಬಿಸದೆ.

IoT ಸಾಧನದಿಂದ ನೇರವಾಗಿ LUIS ಅನ್ನು ಕರೆಮಾಡುವ ಬದಲು, ನೀವು ವಿಭಿನ್ನ ರೀತಿಯ ಟ್ರಿಗರ್‌ ಅನ್ನು ಹೊಂದಿರುವ ಸರ್ವರ್‌ಲೆಸ್ ಕೋಡ್ ಬಳಸಬಹುದು - HTTP ಟ್ರಿಗರ್. ಇದು ನಿಮ್ಮ ಫಂಕ್ಷನ್ ಅಪ್‌ಗೆ REST ವಿನಂತಿಗಳನ್ನು ಕೇಳಲು ಮತ್ತು ಅವುಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುವಂತೆ ಮಾಡುತ್ತದೆ. ಈ ಫಂಕ್ಷನ್ ನಿಮ್ಮ ಸಾಧನವು ಕರೆಮಾಡಬಹುದಾದ REST ಎಂಡ್‌ಪಾಯಿಂಟ್ ಆಗಿರುವುದು.

> 💁 ನೀವು ನಿಮ್ಮ IoT ಸಾಧನದಿಂದ ನೇರವಾಗಿ LUIS ಅನ್ನು ಕರೆ ಮಾಡಬಹುದಾದರೂ, ಸರ್ವರ್‌ಲೆಸ್ ಕೋಡ್ ಬಳಸುವುದು ಉತ್ತಮ. ಉದಾಹರಣೆಗೆ ನೀವು ಉತ್ತಮ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸಲು ಬಯಸಿದಾಗ ಅಥವಾ ಬೇರೆ ಭಾಷೆಯಲ್ಲಿನ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸಿದಾಗ, ನೀವು ಕೇವಲ ನಿಮ್ಮ ಕ್ಲೌಡ್ ಕೋಡ್ನ್ನು ನವೀಕರಿಸಬೇಕು, ಸಾವಿರಾರು ಅಥವಾ ಲಕ್ಷಾಂತರ IoT ಸಾಧನಗಳಲ್ಲಿ ಕೋಡ್ ಪುನಃ ನಿಯೋಜಿಸಬೇಕಾಗುವುದಿಲ್ಲ.

### ಕಾರ್ಯ - ಸರ್ವರ್‌ಲೆಸ್ ಫಂಕ್ಷನ್ಸ್ ಅಪ್ ರಚಿಸಿ

1. `smart-timer-trigger` ಎಂಬ Azure Functions ಅಪ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು VS Code ನಲ್ಲಿ ಇದನ್ನು ತೆಗೆಯಿರಿ

1. VS Code ಟರ್ಮಿನಲ್‌ನಿಂದ ಕೆಳಗಿನ ಕಮಾಂಡ್ ಬಳಸಿ ಈ ಅಪ್‌ಗೆ `speech-trigger` ಎಂಬ HTTP ಟ್ರಿಗರ್ ಸೇರಿಸಿ:

    ```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 ಗಾಗಿ `local.settings.json` ಫೈಲ್‌ನಲ್ಲಿ ಹೊಸ ಇನ್ಟ್ರಿಗಳನ್ನು **MANAGE** ಟ್ಯಾಬ್ನಿಂದ ಸೇರಿಸಿ:

    ```JSON
    "LUIS_KEY": "<primary key>",
    "LUIS_ENDPOINT_URL": "<endpoint url>",
    "LUIS_APP_ID": "<app id>"
    ```

    `<endpoint url>` ನ್ನು **MANAGE** ಟ್ಯಾಬ್‌ನ *Azure Resources* ವಿಭಾಗದಿಂದ ಎಂಡ್‌ಪಾಯಿಂಟ್ URL ಆಗಿ ಬದಲಾಯಿಸಿ. ಇದು ಇರುತ್ತದೆ `https://<location>.api.cognitive.microsoft.com/`.

    `<app id>` ನ್ನು **MANAGE** ಟ್ಯಾಬ್‌ನ *Settings* ವಿಭಾಗದಿಂದ App ID ಆಗಿ ಬದಲಾಯಿಸಿ.

    `<primary key>` ನ್ನು **MANAGE** ಟ್ಯಾಬ್‌ನ *Azure Resources* ವಿಭಾಗದಿಂದ ಪ್ರಾಥಮಿಕ ಕೀ ಆಗಿ ಬದಲಾಯಿಸಿ.

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 ಟ್ರಿಗರ್ ಅನ್ನು `text` ಎಂಬ ಪ್ರಾಪರ್ಟಿಯಲ್ಲಿ ಒಳಗೊಂಡಿರುವ JSON ನಲ್ಲಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕಾದ ಪಠ್ಯವನ್ನು ಪಾಸ್ಸ್ ಮಾಡಿಕೊಂಡು ಕರೆಮಾಡಲಾಗುತ್ತದೆ. ಕೆಳಗಿನ ಕೋಡ್ HTTP ವಿನಂತಿಯ ದೇಹದಿಂದ ಮೌಲ್ಯವನ್ನು ಎಗ್ಜ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಕಾನ್ಸೋಲ್‌ಗೆ ಲಾಗ್ ಮಾಡುತ್ತದೆ. ಇದನ್ನು `main` ಫಂಕ್ಷನ್‌ಗೆ ಸೇರಿಸಿ:

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

1. LUIS ಗಾಗಿ ಭವಿಷ್ಯವಾಣಿ ಕೇಳಿಕೆಯು predictions ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುವ ಮೂಲಕ ಆಗುತ್ತದೆ - ಒಂದು JSON ಡಾಕ್ಯುಮೆಂಟ್ ಆಗಿದ್ದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕಾದ ಪಠ್ಯವನ್ನು ಒಳಗೊಂಡಿದೆ. ಕೆಳಗಿನ ಕೋಡ್‌ನೊಂದಿಗೆ ಇದನ್ನು ಸೃಷ್ಟಿಸಿ:

    ```python
    prediction_request = { 'query' : text }
    ```

1. ಈ ವಿನಂತಿಯನ್ನು ನಂತರ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಕಟಿತ ಸ್ಟೇಜಿಂಗ್ ಸ್ಲಾಟ್ ಗೆ ಕಳುಹಿಸಬಹುದು:

    ```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 ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ ಮತ್ತು 200 ಸ್ಥಿತಿ ಕೋಡ್ೊಂದಿಗೆ ಹಿಟಿಪಿ ಫಲಿತಾಂಶವಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು ಕರೆ ಯಶಸ್ವಿಯಾಗಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.

1. ಕೊನೆಗೆ, `if` ಬ್ಲಾಕ್ ಹೊರಗೆ, ಉದ್ದೇಶವನ್ನು ಗುರುತಿಸಲಾಗದಿದ್ದರೆ ದೋಷ ಕೋಡ್ ಹಿಂತಿರುಗಿಸಿ:

    ```python
    return func.HttpResponse(status_code=404)
    ```

    404 ಎಂದರೆ *ಕಾಣೆಯಾಗಿದೆ* ಎಂಬ ಸ್ಥಿತಿ ಕೋಡ್.

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 ಟರ್ಮಿನಲ್ ಬಳಸುತ್ತಿದ್ದರೆ, ಫಂಕ್ಷನ್ ಅಪ್ ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿಯೇ ಚಾಲನೆ ಮಾಡುವುದು ಸುಲಭ, ಏಕೆಂದರೆ ಕೆಲವು ಗ್ರಂಥಾಲಯಗಳ ಮೇಲೆ ಅವಲಂಬನೆ ಇದೆ ಎಂಬುದರಿಂದ ನೀವು ಫಂಕ್ಷನ್ ಅಪ್ ಅನ್ನು ನೀವು ಹಿಂದಿನಿಂದ ಮಾಡಿದ ರೀತಿಯಲ್ಲಿ ಡಿಪ್ಲಾಯ್ ಮಾಡಲಾಗದು. ಸ್ಥಳೀಯವಾಗಿ ಫಂಕ್ಷನ್ ಅಪ್ ಅನ್ನು ರನ್ ಮಾಡಿ ಮತ್ತು ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ 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` ಸೆಟ್ಟಿಂಗ್ ಬಳಸಿ ಬದಲಾಯಿಸಬಹುದು. Microsoft ಡಾಕ್ಸ್‌ನ 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 ನಲ್ಲಿ, [ಮ್ಯಾಕ್‌ನಲ್ಲಿ ನಿಮ್ಮ IP ವಿಳಾಸವನ್ನು ಹೇಗೆ ಕಂಡುಹಿಡಿಯಬಹುದು ಎಂಬ ಮಾರ್ಗದರ್ಶಿಯನ್ನು](https://www.hellotech.com/guide/for/how-to-find-ip-address-on-mac) ಅನುಸರಿಸಿ
      * ಲಿನಕ್ಸ್ನಲ್ಲಿ, [ಲಿನಕ್ಸ್ನಲ್ಲಿ ನಿಮ್ಮ ಖಾಸಗಿ IP ವಿಳಾಸವನ್ನು ಹೇಗೆ ಕಂಡುಕೊಳ್ಳುವುದು ಎಂಬ ಮಾರ್ಗದರ್ಶಿಯ](https://opensource.com/article/18/5/how-find-ip-address-linux) ವಿಭಾಗವನ್ನು ನೋಡಿ

      IP ವಿಳಾಸ ಪಡೆದುಕೊಂಡ ಮೇಲೆ, ನೀವು ಫಂಕ್ಷನ್ ಅನ್ನು `http://<IP_ADDRESS>:7071/api/text-to-timer` ನಲ್ಲಿ ಪ್ರವೇಶಿಸಬಹುದು, ಇಲ್ಲಿ `<IP_ADDRESS>` ನಿಮ್ಮ IP ವಿಳಾಸ ಆಗಿರುತ್ತದೆ, ಉದಾಹರಣೆಗಾಗಿ `http://192.168.1.10:7071/api/text-to-timer`.

      > 💁 ಗಮನಿಸಿ ಇದು 7071 ಪೋರ್ಟ್ ಅನ್ನು ಬಳಕೆಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ IP ವಿಳಾಸದ ನಂತರ `:7071` ಇರಬೇಕು.
      > 💁 ಇದು ನಿಮ್ಮ ಐಒಟಿ ಸಾಧನವು ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್‌ನ ಅದೇ ಜಾಲದಲ್ಲಿ ಇದ್ದಾಗ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

1. curl ಬಳಸಿ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಪ್ರವೇಶಿಸುವ ಮೂಲಕ ಪರೀಕ್ಷಿಸಿ.

---

## 🚀 ಸವಾಲು

ಒಂದು ಟೈಮರ್ ಸೆಟ್ ಮಾಡುವಂತೆ ಒಂದೇ ರಿಕ್ವೆಸ್ಟ್ ಮಾಡಲು ಹಲವು ಮಾರ್ಗಗಳಿವೆ. ಇದನ್ನು ಮಾಡುವ ವಿಭಿನ್ನ ಮಾರ್ಗಗಳನ್ನು ಯೋಚಿಸಿ, ಅವುಗಳನ್ನು ನಿಮ್ಮ LUIS ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಮಾದರಿಗಳಾಗಿ ಉಪಯೋಗಿಸಿ. ಈ ರೀತಿ ಪರೀಕ್ಷಿಸಿ, ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಟೈಮರ್‌ನ್ನು ಕೇಳಲು ವಿವಿಧ ಮಾರ್ಗಗಳನ್ನು ಹೇಗೆ ಒಪ್ಪಿಕೊಳ್ಳಬಹುದು ಎಂದು ನೋಡಿ.

## ಉಪನ್ಯಾಸದ ನಂತರದ ಪ್ರಶ್ನೋತ್ತರ

[ಉಪನ್ಯಾಸದ ನಂತರದ ಪ್ರಶ್ನೋತ್ತರ](https://black-meadow-040d15503.1.azurestaticapps.net/quiz/44)

## ವಿಮರ್ಶೆ & ಸ್ವಯಂ ಅಧ್ಯಯನ

* LUIS ಮತ್ತು ಅದರ ಸಾಮರ್ಥ್ಯಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ [Microsoft ಡಾಕ್ಯುಮೆಂಟೇಷನ್‌ನ ಭಾಷೆ ಅರ್ಥಮಾಡಿಕೊಡುವಿಕೆ (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)

---

<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಬयान**:
ಈ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ ಸಹ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸ್ವಲ್ಪತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ತಿಳಿದುಕೊಳ್ಳಿ. ಮೂಲ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಅದರ ಸ್ವದೇಶಿ ಭಾಷೆಯಲ್ಲಿ ಅಧಿಕಾರಪೂರ್ಣ ಮೂಲವಂತೆ ಪರಿಗಣಿಸುವುದು ಮುಖ್ಯ. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪುಬುಧ್ಧಿ ಅಥವಾ ತಪ್ಪುಅರ್ಥಗಳಿಗಾಗಿ ನಾವು ಜವಾಬ್ದಾರರಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->