msb-public
/
ML-For-Beginners
mirror of https://github.com/microsoft/ML-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity

chore(i18n): sync translations with latest source changes (chunk 1/1, 21 changes)

Browse Source
pull/935/head
localizeflow[bot] 7 months ago
parent 7cb481c5ce
commit 2197534167
21 changed files with 1139 additions and 1010 deletions
Show Stats Download Patch File Download Diff File

28
translations/kn/.co-op-translator.json
Unescape View File

@ -30,8 +30,8 @@
"language_code": "kn" "language_code": "kn"
}, },
"1-Introduction/3-fairness/assignment.md": { "1-Introduction/3-fairness/assignment.md": {
"original_hash": "dbda60e7b1fe5f18974e7858eff0004e", "original_hash": "c81d9affadb89d017d610eadeb6c84f9",
"translation_date": "2025-12-19T13:43:57+00:00", "translation_date": "2026-02-28T11:00:19+00:00",
"source_file": "1-Introduction/3-fairness/assignment.md", "source_file": "1-Introduction/3-fairness/assignment.md",
"language_code": "kn" "language_code": "kn"
}, },
@ -90,8 +90,8 @@
"language_code": "kn" "language_code": "kn"
}, },
"2-Regression/3-Linear/README.md": { "2-Regression/3-Linear/README.md": {
"original_hash": "40e64f004f3cb50aa1d8661672d3cd92", "original_hash": "9a8359f1945bd3beccccb2b46592580e",
"translation_date": "2025-12-19T13:51:46+00:00", "translation_date": "2026-02-28T11:01:40+00:00",
"source_file": "2-Regression/3-Linear/README.md", "source_file": "2-Regression/3-Linear/README.md",
"language_code": "kn" "language_code": "kn"
}, },
@ -186,8 +186,8 @@
"language_code": "kn" "language_code": "kn"
}, },
"4-Classification/3-Classifiers-2/README.md": { "4-Classification/3-Classifiers-2/README.md": {
"original_hash": "49047911108adc49d605cddfb455749c", "original_hash": "d94438d71164b0ff68002812aed1a8b4",
"translation_date": "2025-12-19T15:24:07+00:00", "translation_date": "2026-02-28T11:06:30+00:00",
"source_file": "4-Classification/3-Classifiers-2/README.md", "source_file": "4-Classification/3-Classifiers-2/README.md",
"language_code": "kn" "language_code": "kn"
}, },
@ -197,12 +197,24 @@
"source_file": "4-Classification/3-Classifiers-2/assignment.md", "source_file": "4-Classification/3-Classifiers-2/assignment.md",
"language_code": "kn" "language_code": "kn"
}, },
"4-Classification/3-Classifiers-2/notebook.ipynb": {
"original_hash": "624ca6cf73d3548ff1b3059e413fa4cd",
"translation_date": "2026-02-28T10:51:31+00:00",
"source_file": "4-Classification/3-Classifiers-2/notebook.ipynb",
"language_code": "kn"
},
"4-Classification/3-Classifiers-2/solution/Julia/README.md": { "4-Classification/3-Classifiers-2/solution/Julia/README.md": {
"original_hash": "a39c15d63f3b2795ee2284a82b986b93", "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T15:37:42+00:00", "translation_date": "2025-12-19T15:37:42+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md", "source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md",
"language_code": "kn" "language_code": "kn"
}, },
"4-Classification/3-Classifiers-2/solution/notebook.ipynb": {
"original_hash": "70f41fe4fd4253adb44cd9d291406e4f",
"translation_date": "2026-02-28T10:51:37+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/notebook.ipynb",
"language_code": "kn"
},
"4-Classification/4-Applied/README.md": { "4-Classification/4-Applied/README.md": {
"original_hash": "61bdec27ed2da8b098cd9065405d9bb0", "original_hash": "61bdec27ed2da8b098cd9065405d9bb0",
"translation_date": "2025-12-19T15:28:29+00:00", "translation_date": "2025-12-19T15:28:29+00:00",
@ -540,8 +552,8 @@
"language_code": "kn" "language_code": "kn"
}, },
"README.md": { "README.md": {
"original_hash": "2f594ee136e3127a47f56d80055227bc", "original_hash": "3a0286e1c4858e79ff54f080dadc1426",
"translation_date": "2026-02-06T09:37:26+00:00", "translation_date": "2026-02-28T11:00:12+00:00",
"source_file": "README.md", "source_file": "README.md",
"language_code": "kn" "language_code": "kn"
}, },

14
translations/kn/1-Introduction/3-fairness/assignment.md
Unescape View File

@ -1,18 +1,18 @@
# ಜವಾಬ್ದಾರಿಯುತ AI ಟೂಲ್‌ಬಾಕ್ಸ್ ಅನ್ನು ಅನ್ವೇಷಿಸಿ # ಜವಾಬ್ದಾರಿಯುತ AI ಟೂಲ್ಬಾಕ್ಸ್ ಅನ್ವೇಷಿಸಿ
## ಸೂಚನೆಗಳು ## ಸೂಚನೆಗಳು
ಈ ಪಾಠದಲ್ಲಿ ನೀವು ಜವಾಬ್ದಾರಿಯುತ AI ಟೂಲ್‌ಬಾಕ್ಸ್ ಬಗ್ಗೆ ತಿಳಿದುಕೊಂಡಿದ್ದೀರಿ, ಇದು "ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳಿಗೆ AI ವ್ಯವಸ್ಥೆಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಮತ್ತು ಸುಧಾರಿಸಲು ಸಹಾಯ ಮಾಡುವ ಓಪನ್-ಸೋರ್ಸ್, ಸಮುದಾಯ ಚಾಲಿತ ಯೋಜನೆ." ಈ ಕಾರ್ಯಕ್ಕಾಗಿ, RAI ಟೂಲ್‌ಬಾಕ್ಸ್‌ನ [ನೋಟ್ಬುಕ್‌ಗಳ](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) ಒಂದನ್ನು ಅನ್ವೇಷಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಕಂಡುಹಿಡಿತಗಳನ್ನು ಒಂದು ಪೇಪರ್ ಅಥವಾ ಪ್ರಸ್ತುತಿಯಲ್ಲಿ ವರದಿ ಮಾಡಿ. ಈ ಪಾಠದಲ್ಲಿ ನೀವು ಜವಾಬ್ದಾರಿಯುತ AI ಟೂಲ್ಬಾಕ್ಸ್ ಕುರಿತು ಕಲಿತಿದ್ದೀರಿ, ಇದು "ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳನ್ನು AI ವ್ಯವಸ್ಥೆಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಮತ್ತು ಸುಧಾರಿಸಲು ಸಹಾಯ ಮಾಡುವ ಓಪನ್-ಸೋರ್ಸ್, ಸಮುದಾಯ ಚಾಲಿತ ಯೋಜನೆ" ಆಗಿದೆ. ಈ ನಿಯೋಜನೆಯಲ್ಲಿ, RAI ಟೂಲ್ಬಾಕ್ಸ್‌ನ [ನೋಟ್‌ಬುಕ್‌ಗಳ](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/tabular/getting-started.ipynb) ಒಂದನ್ನು ಅನ್ವೇಷಿಸಿ ಮತ್ತು ನೀವು ಕಂಡುಕೊಂಡುದನ್ನು ಪತ್ರ ಅಥವಾ ಪ್ರಸ್ತುತಿಯಲ್ಲಿ ವರದಿ ಮಾಡಿ.
## ಮೌಲ್ಯಮಾಪನ ## ಮೌಲ್ಯಮಾಪನಮಾನ
| ಮಾನದಂಡ | ಉದಾಹರಣೀಯ | ತೃಪ್ತಿಕರ | ಸುಧಾರಣೆ ಅಗತ್ಯವಿದೆ | | ಮಾನದಂಡ | ಉದಾತ್ತ | ತಕ್ಕಮಟ್ಟಿನಲ್ಲಿ | ಸುಧಾರಣೆ ಅಗತ್ಯವಿದೆ |
| -------- | --------- | -------- | ----------------- | | -------- | --------- | -------- | ----------------- |
| | ಫೇರ್‌ಲರ್ನ್‌ನ ವ್ಯವಸ್ಥೆಗಳ ಬಗ್ಗೆ ಚರ್ಚಿಸುವ ಪೇಪರ್ ಅಥವಾ ಪವರ್‌ಪಾಯಿಂಟ್ ಪ್ರಸ್ತುತಿ, ಚಾಲನೆ ಮಾಡಿದ ನೋಟ್ಬುಕ್ ಮತ್ತು ಅದನ್ನು ಚಾಲನೆ ಮಾಡುವ ಮೂಲಕ ಪಡೆದ ನಿರ್ಣಯಗಳನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ | ನಿರ್ಣಯಗಳಿಲ್ಲದೆ ಪೇಪರ್ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ | ಯಾವುದೇ ಪೇಪರ್ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿಲ್ಲ | | | Fairlearn ನ ವ್ಯವಸ್ಥೆಗಳ, ಚಾಲನೆ ಮಾಡಿದ ನೋಟ್ಬುಕ್ ಮತ್ತು ಅದನ್ನು ಚಾಲನೆ ಮಾಡುವ ಮೂಲಕ ಪಡೆದ ತೀರ್ಮಾನಗಳನ್ನು ಚರ್ಚಿಸುವ ಪತ್ರ ಅಥವಾ ಪವರ್‌ಪಾಯಿಂಟ್ ಪ್ರಸ್ತುತಿಯನ್ನು ಸಲ್ಲಿಸಲಾಗಿದೆ | ತೀರ್ಮಾನವಿಲ್ಲದೆ ಒಂದು ಪತ್ರವನ್ನು ಸಲ್ಲಿಸಲಾಗಿದೆ | ಯಾವುದೇ ಪತ್ರವನ್ನು ಸಲ್ಲಿಸಲಾಗಿಲ್ಲ |
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**: **ಅಪಸ್ಥಾಪನೆ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪುಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ. ಈ ದಾಖಲೆ AI ಭಾಷಾಂತರ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯತ್ತ ಪ್ರಯತ್ನಿಸಿದರೂ, ಸ್ವಯಂಚಾಲಿತ ಭಾಷಾಂತರಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸಂಗತತೆಗಳಿರಬಹುದು ಎಂದು ಗಮನದಲ್ಲಿರಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿನ ಮೂಲ ದಾಖಲೆ ಇದಕ್ಕಾಗಿ ಪ್ರಾಮಾಣಿಕ ಮೂಲವಾಗಿರಬೇಕು. ಮಹತ್ವಪೂರ್ಣ ಮಾಹಿತಿಗಾಗಿ ವೃತ್ತಿಪರ ಮಾನವ ಭಾಷಾಂತರೆಯನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ವಿಮರ್ಶೆಗಳು ಅಥವಾ ತಪ್ಪು ಅರ್ಥاغ್ರಹಣಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗಿದ್ದೇವೆಂಬುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

297
translations/kn/2-Regression/3-Linear/README.md
Unescape View File

@ -1,124 +1,137 @@
# Scikit-learn ಬಳಸಿ ರೆಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ: ರೆಗ್ರೆಶನ್ ನಾಲ್ಕು ರೀತಿಗಳು # ಸ್ಕೈಕಿಟ್-ಲರ್ನ್ ಬಳಸಿ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ: ನಾಲ್ಕೆರೆಗಳ ರೆಗ್ರೆಷನ್
![ರೇಖೀಯ ಮತ್ತು ಬಹುಪದ ರೆಗ್ರೆಶನ್ ಇನ್ಫೋಗ್ರಾಫಿಕ್](../../../../translated_images/kn/linear-polynomial.5523c7cb6576ccab.webp) ## ಆರಂಭಿಕ ಟಿಪ್ಪಣಿ
> ಇನ್ಫೋಗ್ರಾಫಿಕ್ [ದಾಸನಿ ಮಡಿಪಳ್ಳಿ](https://twitter.com/dasani_decoded) ಅವರಿಂದ
## [ಪೂರ್ವ-ಪಾಠ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
> ### [ಈ ಪಾಠ R ನಲ್ಲಿ ಲಭ್ಯವಿದೆ!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html) ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ಅನ್ನು ನಾವು **ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯ** (ಉದಾಹರಣೆಗೆ, ಮನೆಯ ಬೆಲೆ, ತಾಪಮಾನ, ಅಥವಾ ಮಾರಾಟ) ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಬಳಸುತ್ತೇವೆ.
ಇದು ಇನ್ಪುಟ್ ವೈಶಿಷ್ಟ್ಯಗಳ ಮತ್ತು ಔಟ್‌ಪುಟ್ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿ ಪ್ರತಿನಿಧಿಸುವ ನೇರ ರೇಖೆಯನ್ನು ಕಂಡುಹಿಡಿಯುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಈ ಪಾಠದಲ್ಲಿ, ನಾವು ಆಧುನಿಕ ರೆಗ್ರೆಷನ್ ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸಲು ಮೊದಲು ಆ ಕಲ್ಪನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದರ ಮೇಲೆ ಗಮನ ಹರಿಸುತ್ತೇವೆ.
![Linear vs polynomial regression infographic](../../../../translated_images/kn/linear-polynomial.5523c7cb6576ccab.webp)
> ಇನ್ಫೋಗ್ರಾಫಿಕ್ [ದಾಸನಿ ಮಡಿಪಳ್ಳಿ](https://twitter.com/dasani_decoded) ರವರಿಂದ
## [ಪ್ರೀ-ಲೆಕ್ಚರ್ ಕುಜ್](https://ff-quizzes.netlify.app/en/ml/)
> ### [ಈ ಪಾಠವು R ನಲ್ಲಿ ಲಭ್ಯವಿದೆ!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### ಪರಿಚಯ ### ಪರಿಚಯ
ಈವರೆಗೆ ನೀವು ರೆಗ್ರೆಶನ್ ಎಂದರೇನು ಎಂಬುದನ್ನು ಪಂಪ್ಕಿನ್ ಬೆಲೆ ಡೇಟಾಸೆಟ್‌ನಿಂದ ಸಂಗ್ರಹಿಸಿದ ಮಾದರಿ ಡೇಟಾ ಮೂಲಕ ಅನ್ವೇಷಿಸಿದ್ದೀರಿ. ನೀವು ಅದನ್ನು Matplotlib ಬಳಸಿ ದೃಶ್ಯೀಕರಿಸಿದ್ದೀರಿ. ಇದುವರೆಗೆ ನೀವು ಪೊಲೀಸಿ ಏನು ಎಂದು ತೆಗೆಯಲಾಯಿತು, ಪಂಪ್ಕಿನ್ ಬೆಲೆ ಫಲಿತಾಂಶಗಳ ಡೇಟಾಸೆಟ್ ನಿಂದ ಸೆಂಪಲ್ ಡೇಟಾ ಬಳಸಿಕೊಂಡು. ಜೊತೆಗೆ ನೀವು ಅದನ್ನು ಮ್ಯಾಟ್‌ಪ್ಲಾಟ್‌ಲಿಬ್ ಬಳಸಿ ದೃಶ್ಯೀಕರಣ ಮಾಡಿದ್ದೀರಾ.
ಈಗ ನೀವು ML ಗಾಗಿ ರೆಗ್ರೆಶನ್‌ನಲ್ಲಿ ಇನ್ನಷ್ಟು ಆಳವಾಗಿ ಹೋಗಲು ಸಿದ್ಧರಾಗಿದ್ದೀರಿ. ದೃಶ್ಯೀಕರಣವು ಡೇಟಾವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಆದರೆ ಯಂತ್ರ ಅಧ್ಯಯನದ ನಿಜವಾದ ಶಕ್ತಿ _ಮಾದರಿಗಳನ್ನು ತರಬೇತುಗೊಳಿಸುವುದರಿಂದ_ ಬರುತ್ತದೆ. ಮಾದರಿಗಳನ್ನು ಇತಿಹಾಸದ ಡೇಟಾದ ಮೇಲೆ ತರಬೇತುಗೊಳಿಸಲಾಗುತ್ತದೆ, ಇದು ಡೇಟಾ ಅವಲಂಬನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಮತ್ತು ಹೊಸ ಡೇಟಾದ ಫಲಿತಾಂಶಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ, ಇದು ಮಾದರಿ ಮೊದಲು ನೋಡಿರಲಿಲ್ಲ. ಈಗ ನೀವು ಮಷೀನ್ ಲರ್ನಿಂಗ್‌ನಲ್ಲಿ ರೆಗ್ರೆಷನ್ ಅನ್ನು ಆಳವಾಗಿ ಪರಿಚಯಿಸಲು ಸಿದ್ಧರಾಗಿದ್ದೀರಿ. ದೃಶ್ಯೀಕರಣದ ಮೂಲಕ ನೀವು ಡೇಟಾವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು, ಆದರೆ ಮೆಷೀನ್ ಲರ್ನಿಂಗ್ ನ ನಿಜವಾದ ಶಕ್ತಿ _ಮಾದರಿಗಳನ್ನು ತರಬೇತುಗೊಳಿಸುವಿಕೆಯಿಂದ_ ಇರುತ್ತದೆ. ಮಾದರಿಗಳನ್ನು ಇತಿಹಾಸ ಡೇಟಾದ ಮೇಲೆ ತರಬೇತುಗೊಳಿಸಿ ಡೇಟಾ ಅವಲಂಬನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹಿಡಿದುಕೊಳ್ಳುತ್ತಾರೆ ಮತ್ತು ಹೊಸ ಡೇಟಾ ಮೇಲೆ ಫಲಿತಾಂಶಗಳ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಅನುಮತಿಸುತ್ತವೆ, ಆ ಮಾದರಿಯು ಅದನ್ನು ಮೊದಲು ಕಂಡಿಲ್ಲ.
ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ಎರಡು ರೀತಿಯ ರೆಗ್ರೆಶನ್ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿಯುತ್ತೀರಿ: _ಮೂಲಭೂತ ರೇಖೀಯ ರೆಗ್ರೆಶನ್_ ಮತ್ತು _ಬಹುಪದ ರೆಗ್ರೆಶನ್_, ಜೊತೆಗೆ ಈ ತಂತ್ರಜ್ಞಾನಗಳ ಹಿಂದೆ ಇರುವ ಕೆಲವು ಗಣಿತ. ಆ ಮಾದರಿಗಳು ನಮಗೆ ವಿವಿಧ ಇನ್ಪುಟ್ ಡೇಟಾದ ಆಧಾರದ ಮೇಲೆ ಪಂಪ್ಕಿನ್ ಬೆಲೆಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ. ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ಎರಡು ರೆಗ್ರೆಷನ್ ಪ್ರಕಾರಗಳನ್ನು ಕಲಿಯುತ್ತೀರಿ: _ಮೂಲ ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್_ ಮತ್ತು _ಪೋಲಿನೊಮಿಯಲ್ ರೆಗ್ರೆಷನ್_, ಮತ್ತು ಈ ತಂತ್ರಾಂಶಗಳ ಹಿಂದಿರುವ ಗಣಿತವನ್ನು ಕೂಡ ತಿಳಿದುಕೊಳ್ಳುವಿರಿ. ಅವುಗಳಲ್ಲಿ ಈ ಮಾದರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪಂಪ್ಕಿನ್ ಬೆಲೆಗಳನ್ನು ವಿವಿಧ ಇನ್ಪುಟ್ ಡೇಟಾ ಪ್ರಕಾರ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬಹುದು.
[![ML for beginners - Understanding Linear Regression](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression") [![ML for beginners - Understanding Linear Regression](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
> 🎥 ರೇಖೀಯ ರೆಗ್ರೆಶನ್ ಕುರಿತು ಸಂಕ್ಷಿಪ್ತ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕಾಗಿ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ. > 🎥 ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ಕುರಿತ ಚಿಕ್ಕ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕೆ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ.
> ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ, ನಾವು ಗಣಿತದ ಕನಿಷ್ಠ ಜ್ಞಾನವನ್ನು ಊಹಿಸುತ್ತೇವೆ ಮತ್ತು ಇತರ ಕ್ಷೇತ್ರಗಳಿಂದ ಬರುವ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಇದನ್ನು ಸುಲಭಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ಟಿಪ್ಪಣಿಗಳು, 🧮 ಕರೆಗಳು, ಚಿತ್ರಗಳು ಮತ್ತು ಇತರ ಕಲಿಕಾ ಸಾಧನಗಳನ್ನು ಗಮನಿಸಿ. > ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ, ಗಣಿತದ ಕಡಿಮೆ ಜ್ಞಾನ ಇರುವವರಿಗೂ ಕೆಲವೆಲ್ಲ ಬೇರೆ ಕ್ಷೇತ್ರಗಳಿಂದ ಬರುವ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೂ ಸುಲಭವಾಗುವಂತೆ ಮಾಡಲು ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದೇವೆ; ಆದ್ದರಿಂದ ಟಿಪ್ಪಣಿಗಳು, 🧮 ಕರೆಗಳು, ಚಿತ್ರಗಳು ಮತ್ತು ಇತರೆ ಅಧ್ಯಯನ ಸಾಧನಗಳನ್ನು ಗಮನಿಸಿ.
### ಪೂರ್ವಾಪೇಕ್ಷಿತ ### ಪೂರ್ವಾಪೇಕ್ಷಿತ
ನೀವು ಈಗಾಗಲೇ ನಾವು ಪರಿಶೀಲಿಸುತ್ತಿರುವ ಪಂಪ್ಕಿನ್ ಡೇಟಾದ ರಚನೆಗೆ ಪರಿಚಿತರಾಗಿರಬೇಕು. ನೀವು ಈ ಪಾಠದ _notebook.ipynb_ ಫೈಲ್‌ನಲ್ಲಿ ಪೂರ್ವಲೋಡ್ ಮತ್ತು ಪೂರ್ವಶುದ್ಧೀಕರಿಸಿದ ಡೇಟಾವನ್ನು ಕಾಣಬಹುದು. ಫೈಲ್‌ನಲ್ಲಿ, ಪಂಪ್ಕಿನ್ ಬೆಲೆ ಪ್ರತಿ ಬಷೆಲ್‌ಗೆ ಹೊಸ ಡೇಟಾ ಫ್ರೇಮ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗಿದೆ. ನೀವು Visual Studio Code ನಲ್ಲಿ ಈ ನೋಟ್ಬುಕ್‌ಗಳನ್ನು ಕರ್ಣೆಲ್‌ಗಳಲ್ಲಿ ಚಾಲನೆ ಮಾಡಬಹುದಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಈವರೆಗೆ ನೀವು ಪರಿಶೀಲಿಸುತ್ತಿರುವ ಪಂಪ್ಕಿನ್ ಡೇಟಾ ರಚನೆಯನ್ನು ಪರಿಚಿತವಾಗಿಸಿಕೊಳ್ಳಬೇಕಾಗಿದೆ. ಈ ಪಾಠದ _notebook.ipynb_ ಫೈಲ್‌ನಲ್ಲಿ ಅದು ಪೂರ್ವಭಾಗಿಯಾಗಿ ಲೋಡ್ ಮತ್ತು ಪೂರ್ವಸ್ವಚ್ಛಗೊಳಿಸಲಾಗಿದೆ. ಫೈಲ್‌ನಲ್ಲಿ, ಪಂಪ್ಕಿನ್ ಬೆಲೆನ್ನು ಹಾಕಿ ಪ್ರತಿ ಬಷೆಲ್ ಪ್ರಕಾರ ಹೊಸ ಡೇಟಾ ಫ್ರೇಮ್‌ನಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ. ನೀವು ವಿದ್ಯುತ್ ಸ್ಟುಡಿಯೋ ಕೋಡ್‌ನ ಕರ್ಣೆಲ್‌ಗಳಲ್ಲಿ ಈ ನೋಟ್ಬುಕ್‌ಗಳನ್ನು ಚಲಾಯಿಸಲು ಸಿದ್ಧರಾಗಿರಬೇಕು.
### ತಯಾರಿ ### ತಯಾರಿ
ಒಂದು ಸ್ಮರಣಿಕೆಗಾಗಿ, ನೀವು ಈ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡುತ್ತಿದ್ದೀರಿ ಇದರಿಂದ ಅದಕ್ಕೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಲು. ಸ್ವಲ್ಪ ನೆನಪಿಗೆ, ನೀವು ಈ ಡೇಟಾವನ್ನು ಕೇಳಬೇಕು ಎಂಬ ಪ್ರಶ್ನೆಗಳಿಗಾಗಿ ಲೋಡ್ ಮಾಡುತ್ತಿದ್ದೀರಿ.
- ಯಾವ ಸಮಯದಲ್ಲಿ ಪಂಪ್ಕಿನ್ ಖರೀದಿಸುವುದು ಉತ್ತಮ?
- ಮಿನಿಯ್ಚರ್ ಪಂಪ್ಕಿನ್ ಗಳ ಒಂದು ಪ್ರಕರಣದ ಬೆಲೆ ಏನು ಆಗಬಹುದು?
- ಅವುಗಳನ್ನು ಅರ್ಧ-ಬಷೆಲ್ ಟೋಪ್‌ಗಳಲ್ಲಿ ಖರೀದಿಸಬೇಕೇ ಅಥವಾ 1 1/9 ಬಷೆಲ್ ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಖರೀದಿಸಬೇಕೇ?
ನಾವು ಈ ಡೇಟಾದ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಅನ್ವೇಷಣೆಯನ್ನು ಮುಂದುವರೆಸೋಣ.
ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ, ನೀವು ಪ್ಯಾಂಡಾಸ್ ಡೇಟಾ ಫ್ರೇಮ್ ಸೃಷ್ಟಿಸಿ ಮೂಲ ಡೇಟಾಸೆಟ್‌ನ ಭಾಗದಿಂದ ಡೇಟಾ ತುಂಬಿಸಿದ್ದೀರಿ, ಬೆಲೆಯ ಮೂಲಕ ಬಷೆಲ್ ಸರಳೀಕರಣ ಮಾಡುತ್ತಿದ್ದೀರಿ. ಇದರಿಂದ ಸುಮಾರು 400 ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳು ಮಾತ್ರ ಮತ್ತು ಶರದ್ರುಚಿ ತಿಂಗಳಲ್ಲಿ ಮಾತ್ರ ದೊರಕಿತು.
- ಪಂಪ್ಕಿನ್‌ಗಳನ್ನು ಖರೀದಿಸಲು ಅತ್ಯುತ್ತಮ ಸಮಯ ಯಾವುದು? ಈ ಪಾಠದ ಜೊತೆಯ ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಪೂರ್ವಭಾಗವಾಗಿ ಲೋಡ್ ಮಾಡಲಾದ ಡೇಟಾವನ್ನು ನೋಡಿ. ಡೇಟಾ ಲೋಡ್ ಆಗಿದ್ದು ಮೊದಲ ಸ್ಕ್ಯಾಟರ್ಪ್ಲಾಟ್ ಚಾರ್ಟ್ ಆಗಿದ್ದು ತಿಂಗಳ ಡೇಟಾವನ್ನು ತೋರಿಸುತ್ತದೆ. ಡೇಟಾ ಸ್ವಚ್ಛಗೊಳಿಸಿ ಇನ್ನಷ್ಟು ವಿವರಗಳನ್ನು ಪಡೆಯಬಹುದೇ ಎಂದು ನೋಡೋಣ.
- ಸಣ್ಣ ಪಂಪ್ಕಿನ್‌ಗಳ ಒಂದು ಕೇಸ್‌ನ ಬೆಲೆ ಎಷ್ಟು ನಿರೀಕ್ಷಿಸಬಹುದು?
- ಅವುಗಳನ್ನು ಅರ್ಧ-ಬಷೆಲ್ ಬಾಸ್ಕೆಟ್‌ಗಳಲ್ಲಿ ಖರೀದಿಸಬೇಕೇ ಅಥವಾ 1 1/9 ಬಷೆಲ್ ಬಾಕ್ಸ್ ಮೂಲಕವೇ?
ನಾವು ಈ ಡೇಟಾದಲ್ಲಿ ಇನ್ನಷ್ಟು ತವಕದಿಂದ ತೊಡಗಿಸೋಣ.
ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ, ನೀವು ಪಾಂಡಾಸ್ ಡೇಟಾ ಫ್ರೇಮ್ ರಚಿಸಿ ಮೂಲ ಡೇಟಾಸೆಟ್‌ನ ಭಾಗವನ್ನು ತುಂಬಿದ್ದೀರಿ, ಬೆಲೆಯನ್ನು ಬಷೆಲ್ ಮೂಲಕ ಮಾನಕೀಕರಿಸಿದ್ದೀರಿ. ಆದಾಗ್ಯೂ, ನೀವು ಸುಮಾರು 400 ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳನ್ನು ಮಾತ್ರ ಸಂಗ್ರಹಿಸಿದ್ದೀರಿ ಮತ್ತು ಅವು ಕೇವಲ ಶರತ್ಕಾಲದ ತಿಂಗಳುಗಳಿಗೆ ಮಾತ್ರ. ## ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ರೇಖೆ
ಈ ಪಾಠದ ಜೊತೆಗೆ ಲಭ್ಯವಿರುವ ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಪೂರ್ವಲೋಡ್ ಮಾಡಲಾದ ಡೇಟಾವನ್ನು ನೋಡಿ. ಡೇಟಾ ಪೂರ್ವಲೋಡ್ ಆಗಿದ್ದು, ಪ್ರಾಥಮಿಕ ಸ್ಕ್ಯಾಟರ್‌ಪ್ಲಾಟ್ ತಿಂಗಳ ಡೇಟಾವನ್ನು ತೋರಿಸಲು ಚಾರ್ಟ್ ಮಾಡಲಾಗಿದೆ. ಡೇಟಾದ ಸ್ವಭಾವವನ್ನು ಇನ್ನಷ್ಟು ವಿವರವಾಗಿ ತಿಳಿದುಕೊಳ್ಳಲು ಅದನ್ನು ಹೆಚ್ಚು ಶುದ್ಧೀಕರಿಸಬಹುದು. ಪಾಠ 1 ರಲ್ಲಿ ಕಲಿತುಕೊಂಡಂತೆ, ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ವ್ಯಾಯಾಮದ ಗುರಿ ಒಂದು ರೇಖೆಯನ್ನು আঁಕುವುದು:
## ರೇಖೀಯ ರೆಗ್ರೆಶನ್ ರೇಖೆ - **ಚರ ವ್ಯತ್ಯಯಗಳ ಸಂಬಂಧ ತೋರಿಸುವುದು**. ಚರಗಳ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ತೋರಿಸಲು
- **ಭವಿಷ್ಯವಾಣಿ ಮಾಡುವುದು**. ಹೊಸ ಡೇಟಾಪಾಯಿಂಟ್ ಅಲ್ಲಿ ಎಲ್ಲಿ ಬಿದ್ದೀತೆಂದು ಅಮೆರಿಕವಾಗಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡುವುದು
ಪಾಠ 1 ರಲ್ಲಿ ನೀವು ಕಲಿತಂತೆ, ರೇಖೀಯ ರೆಗ್ರೆಶನ್ ವ್ಯಾಯಾಮದ ಗುರಿ ಒಂದು ರೇಖೆಯನ್ನು ರೇಖಾಚಿತ್ರ ಮಾಡಲು ಆಗಿದೆ: **ಲೀಸ್ಟ್-ಸ್ಕ್ವೇರ್ಸ್ ರೆಗ್ರೆಷನ್** ಗೆ ಈ ರೀತಿ ರೇಖೆಯನ್ನು ಡ್ರಾ ಮಾಡುವುದು ಸಾಮಾನ್ಯ. “ಲೀಸ್ಟ್-ಸ್ಕ್ವೇರ್ಸ್” ಶಬ್ದವೆಂದರೆ ನಮ್ಮ ಮಾದರಿಯಲ್ಲಿ ಕುಲ ಒಂದು ತಪ್ಪನ್ನು ಕನಿಷ್ಠಗೊಳಿಸುವ ಪ್ರಕ್ರಿಯೆ. ಪ್ರತಿ ಡೇಟಾ ಪಾಯಿಂಟ್ ಗಾಗಿ, ನಿಜವಾದ ಪಾಯಿಂಟ್ ಮತ್ತು ನಮ್ಮ ರೆಗ್ರೆಷನ್ ರೇಖೆಯ ನಡುವೆ ಲಂಬದೂರವನ್ನು (ಇದುವನ್ನು ಉಳಿದಂತೆ residual ಎಂದು ಕರೆಯುತ್ತಾರೆ) ಅಳತೆ ಮಾಡುತ್ತೇವೆ.
- **ಚರಗಳ ಸಂಬಂಧಗಳನ್ನು ತೋರಿಸುವುದು**. ಚರಗಳ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ತೋರಿಸುವುದು ಈ ಅಂತರಗಳನ್ನು ಚದುರಿಸುತ್ತೇವೆ ಎರಡು ಮುಖ್ಯ ಕಾರಣಗಳಿಗಾಗಿ:
- **ಭವಿಷ್ಯವಾಣಿ ಮಾಡುವುದು**. ಹೊಸ ಡೇಟಾಪಾಯಿಂಟ್ ಆ ರೇಖೆಯ ಸಂಬಂಧದಲ್ಲಿ ಎಲ್ಲಿ ಬಿದ್ದೀತು ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡುವುದು.
**ಕನಿಷ್ಠ ಚದರ ರೆಗ್ರೆಶನ್** ಸಾಮಾನ್ಯವಾಗಿ ಈ ರೀತಿಯ ರೇಖೆಯನ್ನು ಬಿಡುತ್ತದೆ. 'ಕನಿಷ್ಠ ಚದರ' ಎಂಬ ಪದವು ಅಂದರೆ ರೆಗ್ರೆಶನ್ ರೇಖೆಯ ಸುತ್ತಲೂ ಇರುವ ಎಲ್ಲಾ ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳ ಚದರಗಳನ್ನು ತೆಗೆದು ಸೇರಿಸಲಾಗುತ್ತದೆ. ಆದರ್ಶವಾಗಿ, ಅಂತಿಮ ಮೊತ್ತ ಸಾಧ್ಯವಾದಷ್ಟು ಕಡಿಮೆ ಇರಬೇಕು, ಏಕೆಂದರೆ ನಾವು ತಪ್ಪುಗಳ ಸಂಖ್ಯೆ ಕಡಿಮೆ ಇರಬೇಕೆಂದು ಬಯಸುತ್ತೇವೆ, ಅಂದರೆ `ಕನಿಷ್ಠ ಚದರ`. 1. **ವರಮಾನಕ್ಕೆ ಬದಲು ಮೌಲ್ಯ**: -5 ಎಂಬ ತಪ್ಪನ್ನು +5 ಎಂಬ ತಪ್ಪು ಹಾಗೆಯೇ ಗಣನೆ ಮಾಡಲು, ಚದುರಿಸುವುದರಿಂದ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳು ಸಕಾರಾತ್ಮಕವಾಗಿವೆ.
ನಾವು ಈ ರೇಖೆಯನ್ನು ಮಾದರಿಮಾಡಲು ಬಯಸುತ್ತೇವೆ ಏಕೆಂದರೆ ಅದು ನಮ್ಮ ಎಲ್ಲಾ ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳಿಂದ ಕನಿಷ್ಠ ಒಟ್ಟು ದೂರವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ನಾವು ಮೊದಲು ಚದರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ ಏಕೆಂದರೆ ನಾವು ಅದರ ದಿಕ್ಕಿನ ಬದಲು ಅದರ ಪ್ರಮಾಣದ ಬಗ್ಗೆ ಚಿಂತಿಸುತ್ತೇವೆ. 2. **ಅಸಾಧಾರಣ ಮೌಲ್ಯಗಳಿಗೆ ಶಿಕ್ಷೆ ವಿಧಿಸುವುದು**: ಚದುರಿಸುವುದು ದೊಡ್ಡ ತಪ್ಪುಗಳಿಗೆ ಹೆಚ್ಚುವರಿ ತೂಕ ನೀಡುತ್ತದೆ, ತಕ್ಷಣ ದೂರದಿರುವ ಪಾಯಿಂಟ್‌ಗಳಿಗೆ ರೇಖೆಯನ್ನು ಹತ್ತಿರವಾಗಿರಿಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ.
> **🧮 ಗಣಿತವನ್ನು ತೋರಿಸಿ** ನಂತರ ಆ ಎಲ್ಲಾ ಚದುರಿಸಿದ ಮೌಲ್ಯಗಳನ್ನು ಸೇರುತ್ತೇವೆ. ಗುರಿ ಆ ಯಾವ ವಿಶಿಷ್ಟ ರೇಖೆಯನ್ನು ಕಂಡುಹಿಡಿಯುವುದು, ಅಲ್ಲಿ ಆ ಅಂತಿಮ ಮೊತ್ತ ಕನಿಷ್ಠವಾಗಿರುತ್ತದೆ (ಸರ್ವನಿಮ್ನ ಮೌಲ್ಯ) — ಹಾಗಾಗಿ ಇದಕ್ಕೆ "ಲೀಸ್ಟ್-ಸ್ಕ್ವೇರ್ಸ್" ಎಂದು ಹೆಸರಿದೆ.
>
> ಈ ರೇಖೆಯನ್ನು, _ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಯ ರೇಖೆ_ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಅದನ್ನು [ಸಮೀಕರಣ](https://en.wikipedia.org/wiki/Simple_linear_regression) ಮೂಲಕ ವ್ಯಕ್ತಪಡಿಸಬಹುದು: > **🧮 ನನಗೆ ಗಣಿತ ತೋರಿಸು**
> >
> ಈ ರೇಖೆ, _ಅತ್ಯುತ್ತಮ ಹೊಂದಾಣಿಕೆಯ ರೇಖೆ_ ಎಂದೂ ಕರೆಯಲ್ಪಡುವುದು, [ಒಂದು ಸಮೀಕರಣದಿಂದ](https://en.wikipedia.org/wiki/Simple_linear_regression) ವ್ಯಕ್ತಪಡಿಸಬಹುದು:
>
> ``` > ```
> Y = a + bX > Y = a + bX
> ``` > ```
> >
> `X` ಅನ್ನು 'ವಿವರಣೆ ಚರ' ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. `Y` ಅನ್ನು 'ಆಧಾರಿತ ಚರ' ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ರೇಖೆಯ ಸ್ಲೋಪ್ `b` ಆಗಿದ್ದು, `a` ಯು y-ಅಂತರವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಇದು `X = 0` ಆಗಿರುವಾಗ `Y` ಯ ಮೌಲ್ಯ. > `X` 'ವಿವರಣೆ ಚರ' ಆಗಿದ್ದು, `Y` 'ಆಧಾರಿತ ಚರ'. ರೇಖೆಯ ತರಳು `b`, ಮತ್ತು y-ಅಂಕ (y-intercept) `a` ಆಗಿದ್ದು, `X = 0` ಇದ್ದಾಗ 'Y'ಯ ಮೌಲ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ.
> >
>![ಸ್ಲೋಪ್ ಲೆಕ್ಕಹಾಕಿ](../../../../translated_images/kn/slope.f3c9d5910ddbfcf9.webp) >![calculate the slope](../../../../translated_images/kn/slope.f3c9d5910ddbfcf9.webp)
> >
> ಮೊದಲು, ಸ್ಲೋಪ್ `b` ಅನ್ನು ಲೆಕ್ಕಹಾಕಿ. ಇನ್ಫೋಗ್ರಾಫಿಕ್ [ಜೆನ್ ಲೂಪರ್](https://twitter.com/jenlooper) ಅವರಿಂದ > ಮೊದಲು, ತರಳು `b` ಅನ್ನು ಲೆಕ್ಕಿಸು. ಇನ್ಫೋಗ್ರಾಫಿಕ್ [ಜೆನ್ ಲೂಪರ್](https://twitter.com/jenlooper) ರವರಿಂದ
> >
> ಬೇರೆ ಪದಗಳಲ್ಲಿ, ಮತ್ತು ನಮ್ಮ ಪಂಪ್ಕಿನ್ ಡೇಟಾದ ಮೂಲ ಪ್ರಶ್ನೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ: "ತಿಂಗಳ ಪ್ರಕಾರ ಪ್ರತಿ ಬಷೆಲ್ ಪಂಪ್ಕಿನ್ ಬೆಲೆಯನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿ", `X` ಬೆಲೆಗೆ ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು `Y` ಮಾರಾಟದ ತಿಂಗಳಿಗೆ ಸೂಚಿಸುತ್ತದೆ. > ಇನ್ನೊಂದು ಪದಗಳಲ್ಲಿ, ನಮ್ಮ ಪಂಪ್ಕಿನ್ ಮೂಲ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರವಾಗಿ: "ಪ್ರತಿ ಬಷೆಲ್‌ಗೆ ಪಂಪ್ಕಿನ್ ಬೆಲೆ ಭವಿಷ್ಯವಾಣಿ ಮಾಡು", `X` ಬೆಲೆಗೆ ಮತ್ತು `Y` ಮಾರಾಟ ತಿಂಗಳಿಗೆ ಸೂಚಿಸುತ್ತದೆ.
> >
>![ಸಮೀಕರಣ ಪೂರ್ಣಗೊಳಿಸಿ](../../../../translated_images/kn/calculation.a209813050a1ddb1.webp) >![complete the equation](../../../../translated_images/kn/calculation.a209813050a1ddb1.webp)
> >
> Y ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕಹಾಕಿ. ನೀವು ಸುಮಾರು $4 ಪಾವತಿಸುತ್ತಿದ್ದರೆ, ಅದು ಏಪ್ರಿಲ್ ಆಗಿರಬೇಕು! ಇನ್ಫೋಗ್ರಾಫಿಕ್ [ಜೆನ್ ಲೂಪರ್](https://twitter.com/jenlooper) ಅವರಿಂದ > Y ಯ ಮೌಲ್ಯ ಲೆಕ್ಕಿಸು. ನೀವು ಸುಮಾರು $4 ಕೊಡುವಾಗ, ಅದು ಏಪ್ರಿಲ್ ಆಗಿರಲೇಬೇಕು! ಇನ್ಫೋಗ್ರಾಫಿಕ್ [ಜೆನ್ ಲೂಪರ್](https://twitter.com/jenlooper) ರವರಿಂದ
> >
> ರೇಖೆಯ ಗಣಿತವು ಸ್ಲೋಪ್ ಅನ್ನು ತೋರಿಸಬೇಕು, ಇದು ಅಂತರದ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದ್ದು, ಅಂದರೆ `X = 0` ಆಗಿರುವಾಗ `Y` ಎಲ್ಲಿ ಇರುತ್ತದೆ. > ರೇಖೆಯನ್ನು ಲೆಕ್ಕಿಸುವ ಗಣಿತವು ರೇಖೆಯ ತರಳನ್ನು ಮತ್ತು Yಅಂಕವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ, ಇವು `X = 0` ಆಗಿರುವಾಗ Yಯ ಸನ್ನಿವೇಶವನ್ನು ವಿವರಿಸುತ್ತದೆ.
> >
> ನೀವು ಈ ಮೌಲ್ಯಗಳ ಲೆಕ್ಕಾಚಾರದ ವಿಧಾನವನ್ನು [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ನೋಡಬಹುದು. ಜೊತೆಗೆ [ಈ ಕನಿಷ್ಠ ಚದರ ಕ್ಯಾಲ್ಕ್ಯುಲೇಟರ್](https://www.mathsisfun.com/data/least-squares-calculator.html) ಗೆ ಭೇಟಿ ನೀಡಿ ಸಂಖ್ಯೆಗಳ ಮೌಲ್ಯಗಳು ರೇಖೆಯನ್ನು ಹೇಗೆ ಪ್ರಭಾವಿಸುತ್ತವೆ ಎಂದು ನೋಡಿ. > ನೀವು ಈ ಮೌಲ್ಯಗಳ ಲೆಕ್ಕಿಸುವ ವಿಧಾನವನ್ನು [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ನೋಡಬಹುದು. ಜೊತೆಗೆ [ಈ ಲೀಸ್ಟ್-ಸ್ಕ್ವೇರ್ಸ್ ಕ್ಯಾಲ್ಕ್ಯುಲೇಟರ್](https://www.mathsisfun.com/data/least-squares-calculator.html) ಕಡೆಗೆ ಭೇಟಿ ನೀಡಿ ಸಂಖ್ಯೆಮೌಲ್ಯಗಳು ರೇಖೆಯನ್ನು ಹೇಗೆ ಪರಿಣಾಮಗೊಳಿಸುತ್ತವೆ ಅಂತ ನೋಡಬಹುದು.
## ಸಹಸಂಬಂಧ ## ಸಂಬಂಧ
ಮತ್ತೊಂದು ಪದವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕಿದೆ ಅದು **ಸಹಸಂಬಂಧ ಗುಣಾಂಕ** ಆಗಿದ್ದು, ನೀಡಲಾದ X ಮತ್ತು Y ಚರಗಳ ನಡುವೆ. ಸ್ಕ್ಯಾಟರ್‌ಪ್ಲಾಟ್ ಬಳಸಿ ನೀವು ಈ ಗುಣಾಂಕವನ್ನು ತ್ವರಿತವಾಗಿ ದೃಶ್ಯೀಕರಿಸಬಹುದು. ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳು ಸರಳ ರೇಖೆಯಲ್ಲಿ ಸುತ್ತಲೂ ಹಂಚಿಕೊಂಡಿದ್ದರೆ ಸಹಸಂಬಂಧ ಹೆಚ್ಚು ಇರುತ್ತದೆ, ಆದರೆ ಡೇಟಾಪಾಯಿಂಟ್‌ಗಳು X ಮತ್ತು Y ನಡುವೆ ಎಲ್ಲೆಡೆ ಹಂಚಿಕೊಂಡಿದ್ದರೆ ಸಹಸಂಬಂಧ ಕಡಿಮೆ ಇರುತ್ತದೆ. ಇನ್ನೊಂದು ಪರಿಕಲ್ಪನೆ ತಿಳಿಯಬೇಕಾದುದು **X ಮತ್ತು Y ಚರಗಳ ನಡುವಿನ ಸಂಬಂಧ ಸೂಚಕಾಂಕ** ಆಗಿದ್ದುದು. ಸ್ಕ್ಯಾಟರ್ಪ್ಲಾಟ್ ಮೂಲಕ ನೀವು ಈ ಸೂಚಕಾಂಕವನ್ನು ತ್ವರಿತವಾಗಿ ದೃಶ್ಯೀಕರಿಸಬಹುದು.
ಒಂದೊಂದು ನೇರ ರೇಖೆಯಲ್ಲಿ ಸರಿಯಾಗಿ ಹರಡಿದ ಡೇಟಾಪಾಯಿಂಟ್ ಗಳಿರುವ ಪ್ಲಾಟ್‌ಗೆ ಹೆಚ್ಚು ಸಂಬಂಧವಿದೆ. ಆದರೆ X ಮತ್ತು Y ನಡುವಣ ಎಲ್ಲಾ ಕಡೆ ಇಡಲಾಗಿರುವ ಡೇಟಾಪಾಯಿಂಟ್ ಗಳಿರುವ ಪ್ಲಾಟ್‌ಗೆ ಕಡಿಮೆ ಸಂಬಂಧವಿದೆ.
ಒಳ್ಳೆಯ ರೇಖೀಯ ರೆಗ್ರೆಶನ್ ಮಾದರಿ ಕನಿಷ್ಠ ಚದರ ರೆಗ್ರೆಶನ್ ವಿಧಾನವನ್ನು ಬಳಸಿ ರೇಖೆಯೊಂದಿಗೆ ಸಹಸಂಬಂಧ ಗುಣಾಂಕವು ಹೆಚ್ಚು (0 ಕ್ಕಿಂತ 1 ಗೆ ಹತ್ತಿರ) ಇರುವುದಾಗಿರುತ್ತದೆ.
ಒಳ್ಳೆಯ ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿ ಅಂದರೆ, ಲೀಸ್ಟ್-ಸ್ಕ್ವೇರ್ಸ್ ರೆಗ್ರೆಷನ್ ಕ್ರಮದೊಂದಿಗೆ, 1ಕ್ಕೆ ಹತ್ತಿರವಾಗಿರುವ (0 ಬೆಲೆಗೆ ಹತ್ತಿರವಲ್ಲ) ಸಂಬಂಧ ಸೂಚಕಾಂಕ ಹೊಂದಿರುವುದು.
✅ ಈ ಪಾಠದ ಜೊತೆಗೆ ಲಭ್ಯವಿರುವ ನೋಟ್ಬುಕ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ ಮತ್ತು ತಿಂಗಳು ಮತ್ತು ಬೆಲೆ ಸ್ಕ್ಯಾಟರ್‌ಪ್ಲಾಟ್ ನೋಡಿ. ಪಂಪ್ಕಿನ್ ಮಾರಾಟದ ತಿಂಗಳು ಮತ್ತು ಬೆಲೆ ನಡುವಿನ ಡೇಟಾ ನಿಮ್ಮ ದೃಶ್ಯಾತ್ಮಕ ವಿಶ್ಲೇಷಣೆಯ ಪ್ರಕಾರ ಹೆಚ್ಚು ಅಥವಾ ಕಡಿಮೆ ಸಹಸಂಬಂಧ ಹೊಂದಿದೆಯೇ? ನೀವು `ತಿಂಗಳು` ಬದಲು ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮ ಮಾಪನವನ್ನು ಬಳಸಿದರೆ, ಉದಾ. *ವರ್ಷದ ದಿನ* (ಅಂದರೆ ವರ್ಷದ ಆರಂಭದಿಂದ ದಿನಗಳ ಸಂಖ್ಯೆ) ಇದರಿಂದ ಬದಲಾವಣೆ ಆಗುತ್ತದೆಯೇ?
✅ ಈ ಪಾಠದ ಜೊತೆಯ ನೋಟ್ಬುಕ್ ಚಾಲನೆ ಮಾಡಿ, ತಿಂಗಳುಮೂಲ್ಯ ಮತ್ತು ಬೆಲೆಯ ಸ್ಕ್ಯಾಟರ್ಪ್ಲಾಟ್ ನೋಡಿ. ಪಂಪ್ಕಿನ್ ಮಾರಾಟಗಳ ತಿಂಗಳು ಮತ್ತು ಬೆಲೆಯ ಡೇಟಾ ನಿಮ್ಮ ದೃಶ್ಯಾತ್ಮಕ ಅರ್ಥಮಾಡಿಕೊಳುವಿಕೆಗೆ ತಕ್ಕಂತೆ ಹೆಚ್ಚು ಅಥವಾ ಕಡಿಮೆ ಸಂಬಂಧವಿದೆಯೇ? `Month` ಬದಲಿಗೆ ಹೆಚ್ಚು ಸಣ್ಣ ಪ್ರಮಾಣದ ಅಳತೆ (*ವರ್ಷದ ದಿನಾಂಕ*) ಬಳಿದ್ರೆ ಅದು ಬದಲಾಯಿತ್ತಾ?
ಕೆಳಗಿನ ಕೋಡ್‌ನಲ್ಲಿ, ನಾವು ಡೇಟಾವನ್ನು ಶುದ್ಧೀಕರಿಸಿದ್ದೇವೆ ಎಂದು ಊಹಿಸೋಣ ಮತ್ತು `new_pumpkins` ಎಂಬ ಡೇಟಾ ಫ್ರೇಮ್ ಅನ್ನು ಪಡೆದಿದ್ದೇವೆ, ಹೀಗಿದೆ:
ಕೆಳಗಿನ ಕೋಡ್‌ನಲ್ಲಿ, ನಾವು ಡೇಟಾ ಸ್ವಚ್ಛಗೊಳಿಸಲಾಗಿದೆ ಅಂತ ನಿವೇದಿಸುತ್ತೇವೆ, ಹಾಗೂ `new_pumpkins` ಎಂಬ ಡೇಟಾಫ್ರೇಮ್ ಪಡೆದಿದ್ದೇವೆ, ಹಾಗೆಯೇ ಕೆಳಗಿನಂತಿದೆ:
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
---|-------|-----------|---------|------|---------|-----------|------------|------- ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364 ---|-------|-----------|---------|------|---------|-----------|------------|-------
71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636 70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636 71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545 72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364 73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545
74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
> ಡೇಟಾ ಶುದ್ಧೀಕರಣದ ಕೋಡ್ [`notebook.ipynb`](notebook.ipynb) ನಲ್ಲಿ ಲಭ್ಯವಿದೆ. ನಾವು ಹಿಂದಿನ ಪಾಠದಂತೆ ಅದೇ ಶುದ್ಧೀಕರಣ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿದ್ದೇವೆ ಮತ್ತು ಕೆಳಗಿನ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಬಳಸಿ `DayOfYear` ಕಾಲಮ್ ಲೆಕ್ಕಹಾಕಿದ್ದೇವೆ:
> ಡೇಟಾ ಸ್ವಚ್ಛಗೊಳಿಸುವ ಕೋಡ್ [`notebook.ipynb`](notebook.ipynb) ನಲ್ಲಿ ಲಭ್ಯವಿದೆ. ನಾವು ಹಿಂದಿನ ಪಾಠದಲ್ಲಿರುವಂತೆ ಸ್ವಚ್ಛಗೊಳಿಸುವ ಹಂತಗಳನ್ನು ನಿರ್ವಹಿಸಿದ್ದೇವೆ, ಮತ್ತು ಕೆಳಗಿನ ಸೂತ್ರದಿಂದ `DayOfYear` ಕಾಲಮ್ ಲೆಕ್ಕಿಸಿಕೊಂಡಿದ್ದೇವೆ:
```python ```python
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days) day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
``` ```
ಈಗ ನೀವು ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ಹಿಂದಿನ ಗಣಿತವನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ, ಪಂಪ್ಕಿನ್ ಪ್ಯಾಕೇಜ್‌ಗಳ ಬೆಲೆಗಳಾದ್ದರ ಮೇಲೆ ಯಾವ ಪ್ಯಾಕೇಜ್ ಉತ್ತಮ ಬೆಲೆ ಹೊಂದಬಹುದು ಎಂದು ಭವಿಷ್ಯವಾಣಿಗಾಗಿ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ರಚಿಸೋಣ. ಹಬ್ಬದ ಪಂಪ್ಕಿನ್ ಪ್ಯಾಚ್‌ಗಾಗಿ ಪಂಪ್ಕಿನ್‌ನ ಖರೀದಿದಾರರಿಗೆ ಈ ಮಾಹಿತಿ ಖರೀದಿಗಳನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲು ಸಹಾಯಕವಾಗಬಹುದು.
ಈಗ ನೀವು ರೇಖೀಯ ರೆಗ್ರೆಶನ್ ಹಿಂದಿನ ಗಣಿತವನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ, ಬನ್ನಿ ಒಂದು ರೆಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ರಚಿಸಿ ಯಾವ ಪಂಪ್ಕಿನ್ ಪ್ಯಾಕೇಜ್ ಉತ್ತಮ ಬೆಲೆ ಹೊಂದಿರಬಹುದು ಎಂದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡೋಣ. ಹಬ್ಬದ ಪಂಪ್ಕಿನ್ ಪ್ಯಾಚ್‌ಗಾಗಿ ಪಂಪ್ಕಿನ್ ಖರೀದಿಸುವವರು ಈ ಮಾಹಿತಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ಯಾಚ್‌ಗಾಗಿ ಪಂಪ್ಕಿನ್ ಪ್ಯಾಕೇಜ್‌ಗಳ ಖರೀದಿಯನ್ನು ಗರಿಷ್ಠಗೊಳಿಸಬಹುದು. ## ಸಂಬಂಧವನ್ನು ಹುಡುಕುವುದು
## ಸಹಸಂಬಂಧ ಹುಡುಕುವುದು
[![ML for beginners - Looking for Correlation: The Key to Linear Regression](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression") [![ML for beginners - Looking for Correlation: The Key to Linear Regression](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression")
> 🎥 ಸಹಸಂಬಂಧದ ಸಂಕ್ಷಿಪ್ತ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕಾಗಿ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ. > 🎥 ಸಂಬಂಧ ಕುರಿತ ಚಿಕ್ಕ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕೆ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ.
ಹಿಂದಿನ ಪಾಠದಿಂದ ನೀವು ನೋಡಿರಬಹುದು ವಿಭಿನ್ನ ತಿಂಗಳುಗಳಿಗೆ ಸರಾಸರಿ ಬೆಲೆ ಹೀಗಿದೆ: ಹಿಂದಿನ ಪಾಠದಿಂದ ನೀವು ಕಂಡಿದ್ದೀರಿ, ವಿವಿಧ ತಿಂಗಳ ಸರಾಸರಿ ಬೆಲೆ ಈ ರೀತಿಯಾಗಿದೆ:
<img alt="ತಿಂಗಳ ಪ್ರಕಾರ ಸರಾಸರಿ ಬೆಲೆ" src="../../../../translated_images/kn/barchart.a833ea9194346d76.webp" width="50%"/> <img alt="Average price by month" src="../../../../translated_images/kn/barchart.a833ea9194346d76.webp" width="50%"/>
ಇದು ಕೆಲವು ಸಹಸಂಬಂಧ ಇರಬೇಕೆಂದು ಸೂಚಿಸುತ್ತದೆ, ಮತ್ತು ನಾವು `ತಿಂಗಳು` ಮತ್ತು `ಬೆಲೆ` ಅಥವಾ `DayOfYear` ಮತ್ತು `ಬೆಲೆ` ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ರೇಖೀಯ ರೆಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು. ಕೆಳಗಿನ ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್ ನಂತರದ ಸಂಬಂಧವನ್ನು ತೋರಿಸುತ್ತದೆ: ಈಗ ನಾವು ಕೆಲ ಸಂಬಂಧಗಳಿರಬೇಕು ಎನ್ನುತ್ತದೆ, ಮತ್ತು ನಾವು ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸಿ `Month` ಮತ್ತು `Price` ನಡುವಣ ಸಂಬಂಧ ಅಥವಾ `DayOfYear` ಮತ್ತು `Price` ನಡುವಣ ಸಂಬಂಧ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬಹುದು. ಕೆಳಗಿನ ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್ ನಂತರದ ಸಂಬಂಧವನ್ನು ತೋರಿಸುತ್ತದೆ:
<img alt="ಬೆಲೆ ಮತ್ತು ವರ್ಷದ ದಿನದ ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್" src="../../../../translated_images/kn/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" /> <img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/kn/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
`corr` ಫಂಕ್ಷನ್ ಬಳಸಿ ಸಹಸಂಬಂಧವನ್ನು ನೋಡೋಣ: `corr` ಫಂಗ್ಷನ್ ಬಳಸಿ ಪರೀಕ್ಷೆ ಮಾಡೋಣ:
```python ```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price'])) print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price'])) print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
``` ```
ಸಹಸಂಬಂಧವು ಬಹಳ ಕಡಿಮೆ ಇದೆ ಎಂದು ತೋರುತ್ತದೆ, `ತಿಂಗಳು` ಮೂಲಕ -0.15 ಮತ್ತು `DayOfMonth` ಮೂಲಕ -0.17, ಆದರೆ ಇನ್ನೊಂದು ಪ್ರಮುಖ ಸಂಬಂಧ ಇರಬಹುದು. ವಿಭಿನ್ನ ಪಂಪ್ಕಿನ್ ಪ್ರಭೇದಗಳಿಗೆ ಹೊಂದಿಕೊಂಡ ಬೆಲೆಗಳ ವಿಭಿನ್ನ ಗುಂಪುಗಳಿವೆ ಎಂದು ತೋರುತ್ತದೆ. ಈ ಊಹೆಯನ್ನು ದೃಢೀಕರಿಸಲು, ಪ್ರತಿ ಪಂಪ್ಕಿನ್ ವರ್ಗವನ್ನು ವಿಭಿನ್ನ ಬಣ್ಣದಲ್ಲಿ ಚಿತ್ರಿಸೋಣ. `scatter` ಪ್ಲಾಟ್ ಫಂಕ್ಷನ್‌ಗೆ `ax` ಪರಾಮಿತಿ ನೀಡುವ ಮೂಲಕ ನಾವು ಎಲ್ಲಾ ಬಿಂದುಗಳನ್ನು ಒಂದೇ ಗ್ರಾಫ್‌ನಲ್ಲಿ ಚಿತ್ರಿಸಬಹುದು: ಸಂಬಂಧ ಚಿಕ್ಕದು ಎನ್ನುತ್ತಿದೆ, -0.15 `Month` ಮೂಲಕ ಮತ್ತು -0.17 `DayOfMonth` ಮೂಲಕ, ಆದರೆ ಇನ್ನೂ ಒಂದು ಮಹತ್ವದ ಸಂಬಂಧ ಇರಬಹುದು. ವಿಭಿನ್ನ ಪಂಪ್ಕಿನ್ ವೈವಿಧ್ಯಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಬೆಲೆಯ ವಿಭಿನ್ನ ಗುಂಪುಗಳಿವೆ. ಈ ಊಹೆಯನ್ನು ದೃಢಪಡಿಸಲು, ಪ್ರತಿ ಪಂಪ್ಕಿನ್ ವರ್ಗವನ್ನು ವಿಭಿನ್ನ ಬಣ್ಣದಲ್ಲಿ ಪ್ಲಾಟ್ ಮಾಡೋಣ. `scatter` ಫಂಕ್ಷನ್‌ಗೆ `ax` ಪ್ಯಾರಾಮೀಟರ್ ನೀಡಿ ನಾವು ಎಲ್ಲಾ ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಒಂದೇ ಗ್ರಾಫ್ ಮೇಲೆ ಪ್ಲಾಟ್ ಮಾಡಬಹುದು:
```python ```python
ax=None ax=None
@ -127,74 +140,76 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
df = new_pumpkins[new_pumpkins['Variety']==var] df = new_pumpkins[new_pumpkins['Variety']==var]
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var) ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
``` ```
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/kn/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
<img alt="ಬೆಲೆ ಮತ್ತು ವರ್ಷದ ದಿನದ ಬಣ್ಣದ ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್" src="../../../../translated_images/kn/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" /> ನಮ್ಮ ಅನ್ವೇಷಣೆ ಸೂಚಿಸುತ್ತದೆ, ವೈವಿಧ್ಯಕ್ಕೆ ಮಾರಾಟ ದಿನಾಂಕಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಪರಿಣಾಮವಿದೆ. ಇದನ್ನು ಬಾರ್ ಗ್ರಾಫ್ ಮೂಲಕ ನೋಡಬಹುದು:
ನಮ್ಮ ತನಿಖೆ ಸೂಚಿಸುತ್ತದೆ, ಪ್ರಭೇದವು ಮಾರಾಟದ ದಿನಾಂಕಕ್ಕಿಂತ ಒಟ್ಟು ಬೆಲೆಯ ಮೇಲೆ ಹೆಚ್ಚು ಪ್ರಭಾವ ಬೀರುತ್ತದೆ. ನಾವು ಇದನ್ನು ಬಾರ್ ಗ್ರಾಫ್ ಮೂಲಕ ನೋಡಬಹುದು:
```python ```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar') new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
``` ```
<img alt="Bar graph of price vs variety" src="../../../../translated_images/kn/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
<img alt="ಬೆಲೆ ಮತ್ತು ಪ್ರಭೇದದ ಬಾರ್ ಗ್ರಾಫ್" src="../../../../translated_images/kn/price-by-variety.744a2f9925d9bcb4.webp" width="50%" /> ಈಗ ನಾವು ಒಂದು ಪಂಪ್ಕಿನ್ ವೈವಿಧ್ಯ 'ಪೈ ಪ್ರಕಾರ' ಮೇಲೆ ಮಾತ್ರ ಗಮನಹರಿಸೋಣ ಮತ್ತು ದಿನಾಂಕ ಬೆಲೆಗೆ ಎಂತಹ ಪರಿಣಾಮ ಬೀರುತ್ತಿದೆ ನೋಡೋಣ:
ಈಗ ನಾವು ಒಂದು ಪಂಪ್ಕಿನ್ ಪ್ರಭೇದ, 'ಪೈ ಟೈಪ್' ಮೇಲೆ ಮಾತ್ರ ಗಮನಹರಿಸೋಣ ಮತ್ತು ದಿನಾಂಕವು ಬೆಲೆಗೆ ಏನು ಪ್ರಭಾವ ಬೀರುತ್ತದೆ ನೋಡೋಣ:
```python ```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE'] pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price') pie_pumpkins.plot.scatter('DayOfYear','Price')
``` ```
<img alt="ಬೆಲೆ ಮತ್ತು ವರ್ಷದ ದಿನದ ಸ್ಕ್ಯಾಟರ್ ಪ್ಲಾಟ್" src="../../../../translated_images/kn/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/kn/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
ಈಗ ನಾವು `corr` ಫಂಕ್ಷನ್ ಬಳಸಿ `ಬೆಲೆ` ಮತ್ತು `DayOfYear` ನಡುವಿನ ಸಹಸಂಬಂಧವನ್ನು ಲೆಕ್ಕಹಾಕಿದರೆ, ಅದು `-0.27` ಆಗಿರುತ್ತದೆ - ಇದು ಭವಿಷ್ಯವಾಣಿ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸುವುದು ಅರ್ಥಪೂರ್ಣ ಎಂದು ಸೂಚಿಸುತ್ತದೆ. ಈಗ ನಾವು `corr` ಫಂಕ್ಷನ್ ಬಳಸಿ `Price` ಮತ್ತು `DayOfYear` ನಡುವಣ ಸಂಬಂಧ ಲೆಕ್ಕಿಸಿದರೆ, ಸರಿಸುಣಿಗೆ `-0.27` ಸಿಗುತ್ತದೆ - ಇದರಿಂದ ಮಾದರಿ ತರಬೇತುಗೊಳಿಸುವುದು ಯುಕ್ತಿ.
> ರೇಖೀಯ ರೆಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸುವ ಮೊದಲು, ನಮ್ಮ ಡೇಟಾ ಶುದ್ಧವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಮುಖ್ಯ. ರೇಖೀಯ ರೆಗ್ರೆಶನ್ ಕಳೆದುಹೋಗಿರುವ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಚೆನ್ನಾಗಿ ಕೆಲಸ ಮಾಡದು, ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಖಾಲಿ ಸೆಲ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು ಸೂಕ್ತ. > ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯ ತರಬೇತಿಗೆ ಮೊದಲು, ಡೇಟಾ ಸರಿ ಇದ್ದುದು ಸಂಶೋಧನೆಗೆ ಮುಖ್ಯ. ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ಕೊರತೆಗೊಳ್ಳುವ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಚೆನ್ನಾಗಿರುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಖಾಲಿ ಕಣಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು ಯುಕ್ತಿ:
```python ```python
pie_pumpkins.dropna(inplace=True) pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info() pie_pumpkins.info()
``` ```
ಮತ್ತೊಂದು ವಿಧಾನ ಎನ್ನುವುದು ಅವುಗಳನ್ನು ಸಂಬಂಧಿತ ಕಾಲಮ್‌ನ ಸರಾಸರಿ ಮೌಲ್ಯಗಳಿಂದ ಭರ್ತಿ ಮಾಡುವುದು.
ಮತ್ತೊಂದು ವಿಧಾನವೆಂದರೆ ಆ ಖಾಲಿ ಮೌಲ್ಯಗಳನ್ನು ಸಂಬಂಧಿಸಿದ ಕಾಲಮ್‌ನ ಸರಾಸರಿ ಮೌಲ್ಯಗಳಿಂದ ತುಂಬಿಸುವುದು. ## ಸರಳ ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್
## ಸರಳ ರೇಖೀಯ ರೆಗ್ರೆಶನ್
[![ML for beginners - Linear and Polynomial Regression using Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn") [![ML for beginners - Linear and Polynomial Regression using Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
> 🎥 ರೇಖೀಯ ಮತ್ತು ಬಹುಪದ ರೆಗ್ರೆಶನ್ ಕುರಿತು ಸಂಕ್ಷಿಪ್ತ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕಾಗಿ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ. > 🎥 ಲಿನಿಯರ್ ಮತ್ತು ಪೋಲಿನೊಮಿಯಲ್ ರೆಗ್ರೆಷನ್ ಕುರಿತ ಚಿಕ್ಕ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕೆ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ.
ನಮ್ಮ ರೇಖೀಯ ರೆಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸಲು, ನಾವು **Scikit-learn** ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸುತ್ತೇವೆ. ನಮ್ಮ ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸಲು ನಾವು **ಸ್ಕೈಕಿಟ್-ಲರ್ನ್** ಗ್ರಂಥಾಲಯ ಬಳಸುತ್ತೇವೆ.
```python ```python
from sklearn.linear_model import LinearRegression from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split from sklearn.model_selection import train_test_split
``` ```
ನಾವು ಮೊದಲಿಗೆ ಇನ್ಪುಟ್ ಮೌಲ್ಯಗಳು (ಲಕ್ಷಣಗಳು) ಮತ್ತು ನಿರೀಕ್ಷಿತ ಔಟ್‌ಪುಟ್ (ಲೇಬಲ್) ಅನ್ನು ಪ್ರತ್ಯೇಕ numpy ಅರೆಗಳಾಗಿ ವಿಭಜಿಸುತ್ತೇವೆ: ಮೊದಲು, ಇನ್ಪುಟ್ ಮೌಲ್ಯಗಳು (ವೈಶಿಷ್ಟ್ಯಗಳು) ಮತ್ತು ನಿರೀಕ್ಷಿತ ಔಟ್‌ಪುಟ್ (ಲೇಬಲ್) ಎರಡು ವಿಭಿನ್ನ ನಂಪೈ ಅರೆಗಳನ್ನು ಭೇದಿಸುವುದರಿಂದ ಪ್ರಾರಂಭಿಸೋಣ:
```python ```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1) X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price'] y = pie_pumpkins['Price']
``` ```
> ಗಮನಿಸಿ, ನಾವು ಇನ್ಪುಟ್ ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ತಜ್ಞರಿತಿಸಲು `reshape` ಮಾಡಬೇಕಾಯಿತು. ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ 2D ಅರೆ ಇನ್ಪುಟ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಸಾಲು ವೈಶಿಷ್ಟ್ಯಗಳ ಒಂದು ವಿಕ್ಟರ್ ಆಗಿರುತ್ತದೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ ಒಂದೇ ಇನ್ಪುಟ್ ಇದ್ದು, N×1 ಅರೆ ಬೇಕಾಗಿದೆ, ಇಲ್ಲಿ N ಡೇಟಾಸೆಟ್ ಗಾತ್ರ.
> ಗಮನಿಸಿ, Linear Regression ಪ್ಯಾಕೇಜ್ ಸರಿಯಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಾವು ಇನ್ಪುಟ್ ಡೇಟಾದ ಮೇಲೆ `reshape` ಮಾಡಬೇಕಾಯಿತು. Linear Regression 2D ಅರೆ ಇನ್ಪುಟ್ ಆಗಿರಬೇಕೆಂದು ನಿರೀಕ್ಷಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಸಾಲು ಒಂದು ಲಕ್ಷಣಗಳ ವೆಕ್ಟರ್ ಆಗಿರುತ್ತದೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ನಮಗೆ ಒಂದೇ ಇನ್ಪುಟ್ ಇದ್ದು, ಆದ್ದರಿಂದ N×1 ಆಕಾರದ ಅರೆ ಬೇಕಾಗುತ್ತದೆ, ಇಲ್ಲಿ N ಡೇಟಾಸೆಟ್ ಗಾತ್ರ. ನಂತರ, ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷೆ ಡೇಟಾಸೆಟ್‌ಗಳಾಗಿ ಡೇಟಾವನ್ನು ವಿಭಜಿಸುವ ಅಗತ್ಯವಿದೆ, ಬಳಿಕ ತರಬೇತಿಗಿಂತ ಮುಂದೆ ನಮ್ಮ ಮಾದರಿಯನ್ನು ದೃಢೀಕರಿಸಬಹುದು:
ನಂತರ, ನಾವು ಡೇಟಾವನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾಸೆಟ್‌ಗಳಾಗಿ ವಿಭಜಿಸಬೇಕು, ಇದರಿಂದ ನಾವು ತರಬೇತಿಯ ನಂತರ ನಮ್ಮ ಮಾದರಿಯನ್ನು ಮಾನ್ಯತೆ ಮಾಡಬಹುದು:
```python ```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
``` ```
ಕೊನೆಗೆ, ನಿಜವಾದ ರೇಖೀಯ ರೆಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸುವುದು ಕೇವಲ ಎರಡು ಸಾಲು ಕೋಡ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನಾವು `LinearRegression` ವಸ್ತುವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ, `fit` ವಿಧಾನ ಬಳಸಿ ಅದನ್ನು ನಮ್ಮ ಡೇಟಾಗೆ ಹೊಂದಿಸುತ್ತೇವೆ: ಕೊನೆಗೆ, ನಿಜವಾದ ಲಿನಿಯರ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯ ತರಬೇತಿ ಕೇವಲ ಎರಡು ಸಾಲುಗಳಲ್ಲಿ ಸಾದ್ಯ. ನಾವು `LinearRegression` ಆಬ್ಜೆಕ್ಟ್ ವ್ಯಾಖ್ಯಾನಿಸಿ, `fit` ವಿಧಾನ ಬಳಸಿ ಡೇಟಾ ಗೆ ಫಿಟ್ ಮಾಡುತ್ತೇವೆ:
```python ```python
lin_reg = LinearRegression() lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train) lin_reg.fit(X_train,y_train)
``` ```
`fit` ಮಾಡುವ ನಂತರದ `LinearRegression` ವಸ್ತುವು regression ನ ಎಲ್ಲಾ coefficients ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಇದಕ್ಕೆ `.coef_` ಎಂಬ property ಉಪಯೋಗಿಸಿ ಪ್ರವೇಶಿಸಬಹುದು. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಕೇವಲ ಒಂದು coefficient ಇದೆ, ಅದು ಸుమಾರಿಗೆ `-0.017` ಆಗಿರಬಹುದು. ಇದರ ಅರ್ಥ ಬೆಲೆಗಳು ಕಾಲದೊಂದಿಗೆ ಸ್ವಲ್ಪ ಇಳಿಕೆಯಾಗುತ್ತಿವೆ, ಆದರೆ ಬಹಳಷ್ಟು ಅಲ್ಲ, ದಿನಕ್ಕೆ ಸುಮಾರು 2 ಸೆಂಟುಗಳು ಇಳಿಯುತ್ತವೆ. regression ನ Y-ಅಕ್ಷದ ನಡುವೆ ಇರುವ intersection point ಅನ್ನು ನಾವು `lin_reg.intercept_` ಉಪಯೋಗಿಸಿ ಪ್ರವೇಶಿಸಬಹುದು - ಇದು ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ ಸుమಾರಿಗೆ `21` ಇರಬಹುದು, ಇದು ವರ್ಷದ ಪ್ರಾರಂಭದಲ್ಲಿ ಬೆಲೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.
`fit` ಮಾಡಿದ ನಂತರ `LinearRegression` ವಸ್ತುವಿನಲ್ಲಿ ಎಲ್ಲಾ ರೆಗ್ರೆಶನ್ ಗುಣಾಂಕಗಳು ಇರುತ್ತವೆ, ಅವುಗಳನ್ನು `.coef_` ಗುಣಲಕ್ಷಣದಿಂದ ಪ್ರವೇಶಿಸಬಹುದು. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಒಂದೇ ಗುಣಾಂಕ ಇದೆ, ಅದು ಸುಮಾರು `-0.017` ಆಗಿರಬೇಕು. ಇದರ ಅರ್ಥ ಬೆಲೆಗಳು ಸಮಯದೊಂದಿಗೆ ಸ್ವಲ್ಪ ಇಳಿಯುತ್ತಿವೆ, ಆದರೆ ಹೆಚ್ಚು ಅಲ್ಲ, ದಿನಕ್ಕೆ ಸುಮಾರು 2 ಸೆಂಟುಗಳಷ್ಟು. ನಾವು ರೇಖೆಯ Y-ಅಕ್ಷದ ಅಂತರ ಬಿಂದುವನ್ನು `lin_reg.intercept_` ಬಳಸಿ ಪ್ರವೇಶಿಸಬಹುದು - ಇದು ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ ಸುಮಾರು `21` ಆಗಿರುತ್ತದೆ, ವರ್ಷ ಆರಂಭದ ಬೆಲೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ನಮ್ಮ ಮಾದರಿ ಎಷ್ಟು ಖಚಿತವಾಗಿದೆ ಎಂದು ನೋಡಲು, ನಾವು ಪರೀಕ್ಷಾ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಬೆಲೆಯನ್ನು predict ಮಾಡಬಹುದು, ನಂತರ ನಮ್ಮ ಭವಿಷ್ಯವಾಣಿ ನಿರೀಕ್ಷಿತ ಮೌಲ್ಯಗಳಿಗೆ ಎಷ್ಟು ಹತ್ತಿರವಾಗಿದೆ ಎಂದು ಅಳೆಯಬಹುದು. ಇದು mean square error (MSE) ಮೆಟ್ರಿಕ್ಸ್ ಬಳಸಿ ಮಾಡಬಹುದು, ಇದು ನಿರೀಕ್ಷಿತ ಮತ್ತು ಭವಿಷ್ಯವಾಣಿ ಮೌಲ್ಯದ ನಡುವಿನ ಎಲ್ಲಾ ವರ್ಗೀಕರಿಸಿದ ವ್ಯತ್ಯಾಸಗಳ ಸರಾಸರಿ.
ನಮ್ಮ ಮಾದರಿ ಎಷ್ಟು ನಿಖರವಾಗಿದೆ ಎಂದು ನೋಡಲು, ನಾವು ಪರೀಕ್ಷಾ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಬೆಲೆಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬಹುದು, ಮತ್ತು ನಂತರ ನಮ್ಮ ಭವಿಷ್ಯವಾಣಿಗಳು ನಿರೀಕ್ಷಿತ ಮೌಲ್ಯಗಳಿಗೆ ಎಷ್ಟು ಹತ್ತಿರವಿದೆ ಎಂದು ಅಳೆಯಬಹುದು. ಇದು ಸರಾಸರಿ ಚದರ ದೋಷ (MSE) ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮಾಡಬಹುದು, ಇದು ನಿರೀಕ್ಷಿತ ಮತ್ತು ಭವಿಷ್ಯವಾಣಿ ಮೌಲ್ಯಗಳ ನಡುವಿನ ಎಲ್ಲಾ ಚದರ ವ್ಯತ್ಯಾಸಗಳ ಸರಾಸರಿ.
```python ```python
pred = lin_reg.predict(X_test) pred = lin_reg.predict(X_test)
@ -203,16 +218,16 @@ mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)') print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
``` ```
ನಮ್ಮ ದೋಷವು ಸುಮಾರು 2 ಅಂಕಿಗಳ ಸುತ್ತಲೂ ಇದೆ, ಇದು ~17% ಆಗಿದೆ. ತುಂಬಾ ಚೆನ್ನಾಗಿಲ್ಲ. ಮಾದರಿ ಗುಣಮಟ್ಟದ ಮತ್ತೊಂದು ಸೂಚಕವು **ನಿರ್ಧಾರ ಸಹಗುಣಕ** ಆಗಿದ್ದು, ಇದನ್ನು ಹೀಗೆ ಪಡೆಯಬಹುದು: ನಮ್ಮ ದೋಷವು ಸುತ್ತಮುತ್ತ 2 ಅಂಕಿಗಳು ಎಂಬಂತೆ ತೋರುತ್ತದೆ, ಇದು ಸುಮಾರು 17%. ತುಂಬಾ ಚೆನ್ನಾಗಿಲ್ಲ. ಮಾದರಿ ಗುಣಮಟ್ಟದ ಮತ್ತೊಂದು ಸೂಚಕವು **ನಿರ್ಣಾಯಕ коэффициент (coefficient of determination)** ಆಗಿದ್ದು, ಈ ಕೆಳಗಿನಂತೆ ಪಡೆಯಬಹುದು:
```python ```python
score = lin_reg.score(X_train,y_train) score = lin_reg.score(X_train,y_train)
print('Model determination: ', score) print('Model determination: ', score)
``` ```
ಮೌಲ್ಯವು 0 ಆಗಿದ್ದರೆ, ಅದು ಮಾದರಿ ಇನ್‌ಪುಟ್ ಡೇಟಾವನ್ನು ಪರಿಗಣಿಸುವುದಿಲ್ಲ ಮತ್ತು *ಅತ್ಯಂತ ಕೆಟ್ಟ ರೇಖೀಯ ಭವಿಷ್ಯವಾಣಿ* ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಇದು ಫಲಿತಾಂಶದ ಸರಾಸರಿ ಮೌಲ್ಯವೇ ಆಗಿದೆ. 1 ಮೌಲ್ಯವು ನಾವು ಎಲ್ಲಾ ನಿರೀಕ್ಷಿತ ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬಹುದು ಎಂದು ಅರ್ಥ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಸಹಗುಣಕವು ಸುಮಾರು 0.06 ಆಗಿದ್ದು, ಇದು ತುಂಬಾ ಕಡಿಮೆ. ಎರಡು ಅಂತಿಮ ಮೌಲ್ಯವಾದ 0 ಅಂದರೆ, ಮಾದರಿ ಇನ್ಪುಟ್ ಡೇಟಾವನ್ನು ಪರಿಗಣಿಸುತ್ತಿಲ್ಲ ಮತ್ತು *ಅತೀಕೆಡಾದ ರೇಖೀಯ ಭವಿಷ್ಯದಾತ* ಆಗಿ ವರ್ತಿಸುತ್ತದೆ, ಅದು ಒಟ್ಟು ಫಲಿತಾಂಶದ ಸರಾಸರಿ ಮೌಲ್ಯದಂತೆ ಇರುತ್ತದೆ. ಮೌಲ್ಯವು 1 ಎಂದರೆ ನಾವು ಎಲ್ಲಾ ನಿರೀಕ್ಷಿತ ಹೊರಗಿನ ಮೌಲ್ಯಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತಕ್ಕಂತೆ ಭವಿಷ್ಯವಾಣಿ ಮಾಡಬಹುದು. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, коэффициент ಸುತ್ತಮುತ್ತ 0.06 ಆಗಿದ್ದು, ಇದು ತುಂಬಾ ಕಡಿಮೆ.
ನಾವು ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಮತ್ತು ರಿಗ್ರೆಷನ್ ರೇಖೆಯನ್ನು ಒಟ್ಟಿಗೆ ಚಿತ್ರಿಸಿ, ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ ರಿಗ್ರೆಷನ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಉತ್ತಮವಾಗಿ ನೋಡಬಹುದು: ನಾವು regression ರೇಖೆಯೊಂದಿಗೆ ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಒಟ್ಟಾಗಿ ಚಿತ್ರಿಸುವುದರಿಂದ regression ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂದು ಉತ್ತಮವಾಗಿ ನೋಡಬಹುದು:
```python ```python
plt.scatter(X_test,y_test) plt.scatter(X_test,y_test)
@ -221,19 +236,19 @@ plt.plot(X_test,pred)
<img alt="Linear regression" src="../../../../translated_images/kn/linear-results.f7c3552c85b0ed1c.webp" width="50%" /> <img alt="Linear regression" src="../../../../translated_images/kn/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
## ಬಹುಪದ ರಿಗ್ರೆಷನ್ ## ಬಹುಪದ ರೇಖೀಯ ವಿಶ್ಲೇಷಣೆ (Polynomial Regression)
ಮತ್ತೊಂದು ರೇಖೀಯ ರಿಗ್ರೆಷನ್ ಪ್ರಕಾರ ಬಹುಪದ ರಿಗ್ರೆಷನ್ ಆಗಿದೆ. ಕೆಲವೊಮ್ಮೆ ಚರಗಳ ನಡುವೆ ರೇಖೀಯ ಸಂಬಂಧವಿರಬಹುದು - ಗಾತ್ರದಲ್ಲಿ ದೊಡ್ಡ ಕಂಬಳಿಯು ಬೆಲೆಯೂ ಹೆಚ್ಚು - ಆದರೆ ಕೆಲವೊಮ್ಮೆ ಈ ಸಂಬಂಧಗಳನ್ನು ಸಮತಲ ಅಥವಾ ಸರಳ ರೇಖೆಯಾಗಿ ಚಿತ್ರಿಸಲಾಗುವುದಿಲ್ಲ. ಹೆಚ್ಚುಕಾಲ linear regression ಒಂದು ವಿಧವಾಗಿದೆ. ಕೆಲವೊಮ್ಮೆ, ಎರಡು ಚರಗಳ ನಡುವೆ ರೇಖೀಯ ಸಂಬಂಧವಿರಬಹುದು - ಕೀಮಿಗೆ ಇರುವ ಪಂಪ್ಕಿನ್ ವಾಲ್ಯೂಮ್ ದೊಡ್ಡದಾಗಿದ್ದಂತೆ ಬೆಲೆಯೂ ಹೆಚ್ಚಾಗುತ್ತದೆ - ಆದರೆ ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಈ ಸಂಪರ್ಕಗಳನ್ನು ಸಮತಲ ಅಥವಾ ನೇರ ರೇಖೆಯಾಗಿ ಚಿತ್ರಿಸಲಾಗುವುದಿಲ್ಲ.
✅ ಇಲ್ಲಿ [ಇನ್ನಷ್ಟು ಉದಾಹರಣೆಗಳು](https://online.stat.psu.edu/stat501/lesson/9/9.8) ಇವೆ, ಅವು ಬಹುಪದ ರಿಗ್ರೆಷನ್ ಬಳಸಬಹುದು ✅ ಈ ಕೆಳಗಿನಗಿನ [ಇನ್ನಷ್ಟು ಉದಾಹರಣೆಗಳಿವೆ](https://online.stat.psu.edu/stat501/lesson/9/9.8) Polynomial Regression ಉಪಯೋಗಿಸಲಾದ ಡೇಟಾಗಳಿಗೆ
ದಿನಾಂಕ ಮತ್ತು ಬೆಲೆಯ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಮತ್ತೊಮ್ಮೆ ನೋಡಿ. ಈ ಸ್ಕ್ಯಾಟರ್‌ಪ್ಲಾಟ್ ಅನ್ನು ಅವಶ್ಯಕವಾಗಿ ಸರಳ ರೇಖೆಯಿಂದ ವಿಶ್ಲೇಷಿಸಬೇಕೆಂದು ತೋರುತ್ತದೆಯೇ? ಬೆಲೆಗಳು ಬದಲಾಯಿಸಬಹುದೇ? ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಬಹುಪದ ರಿಗ್ರೆಷನ್ ಪ್ರಯತ್ನಿಸಬಹುದು. Date ಮತ್ತು Price ನಡುವೆ ಇರುವ ಸಂಬಂಧವನ್ನು ಮತ್ತೆ ನೋಡಿ. ಈ scatterplot ನೇರ ರೇಖೆಯ ಮೂಲಕ ವಿಶ್ಲೇಷಿಸುವುದು ಅತಿ ಅವಶ್ಯಕವೆಂದು ಭಾವಿಸುತ್ತೀರಾ? ಬೆಲೆಗಳು ಎತ್ತಕೆ ಮೇಲೆ ತಗ್ಗಬಹುದು ಅಲ್ಲವೇ? ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು polynomial regression ಪ್ರಯತ್ನಿಸಬಹುದು.
✅ ಬಹುಪದಗಳು ಗಣಿತೀಯ ಅಭಿವ್ಯಕ್ತಿಗಳು, ಅವು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಚರಗಳು ಮತ್ತು ಸಹಗುಣಕಗಳನ್ನು ಹೊಂದಿರಬಹುದು ✅ ಬಹುಪದಗಳು ಗಣಿತೀಯ ಸಮೀಕರಣಗಳು ಆಗಿದ್ದು, ಅವು ಒಂದಿನಿಂದ ಹೆಚ್ಚು ಚರಗಳು ಮತ್ತು coefficients ಗಳಿಂದ ಅಳವಡಿಸಬಹುದು
ಬಹುಪದ ರಿಗ್ರೆಷನ್ ಅರೇಖೀಯವಲ್ಲದ ಡೇಟಾವನ್ನು ಉತ್ತಮವಾಗಿ ಹೊಂದಿಸಲು ವಕ್ರ ರೇಖೆಯನ್ನು ರಚಿಸುತ್ತದೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ನಾವು ಇನ್‌ಪುಟ್ ಡೇಟಾದಲ್ಲಿ ಚದರ `DayOfYear` ಚರವನ್ನು ಸೇರಿಸಿದರೆ, ನಾವು ಡೇಟಾವನ್ನು ಪ್ಯಾರಾಬೋಲಿಕ್ ವಕ್ರದಿಂದ ಹೊಂದಿಸಬಹುದು, ಅದು ವರ್ಷದಲ್ಲಿ ಒಂದು ನಿರ್ದಿಷ್ಟ ಬಿಂದುವಿನಲ್ಲಿ ಕನಿಷ್ಠ ಮೌಲ್ಯ ಹೊಂದಿರುತ್ತದೆ. Polynomial regression nonlinear ಡೇಟೆಗೆ ಮತ್ತೆ ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಗೆ ಒಂದು ವಕ್ರರೇಖೆಯನ್ನು ರಚಿಸುತ್ತದೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ನಾವು `DayOfYear` ಚರವನ್ನು ವರ್ಗ (squared) ರೂಪದಲ್ಲಿ ಸೇರಿಸಿದರೆ, ನಮ್ಮ ಡೇಟಾಗಳನ್ನು ಸರಿ ಹೊಂದಿಸಲು ಪರಾಬೋಲಿಕ್ ವಕ್ರವನ್ನು ಹೊಂದಬಹುದು, ಅದು ವರ್ಷದ ಯಾವುದೇ ಒಂದು ಮಿನಿಮಮ್ ಅಂಶದಲ್ಲಿ ಇರುತ್ತದೆ.
ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಸಹಾಯಕ [ಪೈಪ್‌ಲೈನ್ API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) ಅನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದು ಡೇಟಾ ಪ್ರಕ್ರಿಯೆಯ ವಿವಿಧ ಹಂತಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸಂಯೋಜಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. **ಪೈಪ್‌ಲೈನ್** ಎಂದರೆ **ಅಂದಾಜುಕಾರರ** ಸರಪಳಿ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ನಾವು ಮೊದಲು ಬಹುಪದ ಲಕ್ಷಣಗಳನ್ನು ನಮ್ಮ ಮಾದರಿಯಲ್ಲಿ ಸೇರಿಸುವ, ನಂತರ ರಿಗ್ರೆಷನ್ ತರಬೇತಿ ನೀಡುವ ಪೈಪ್‌ಲೈನ್ ರಚಿಸುವೆವು: Scikit-learn ಗೆ ಒಂದು ಸಹಾಯಕ [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) ಇದೆ, ಇದು ಡೇಟಾ ಪ್ರಾಸೆಸಿಂಗ್ ನ ವಿವಿಧ ಹಂತಗಳನ್ನು ಒಟ್ಟಿಗೆ ಜೋಡುತ್ತದೆ. **pipeline** ಎಂದರೆ **estimators** ಗಳ ಸರಪಳಿ. ನಾವು ಮೊದಲಿಗೆ polynomial features ಮೌಲ್ಯವನ್ನು ನಮ್ಮ ಮಾದರಿಗೆ ಸೇರಿಸುವ pipeline ರಚಿಸಿ, ನಂತರ regression ನನ್ನು ತರಬೇತಿಮಾಡುತ್ತೇವೆ:
```python ```python
from sklearn.preprocessing import PolynomialFeatures from sklearn.preprocessing import PolynomialFeatures
@ -244,36 +259,36 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train) pipeline.fit(X_train,y_train)
``` ```
`PolynomialFeatures(2)` ಬಳಸುವುದು ಎಂದರೆ ನಾವು ಇನ್‌ಪುಟ್ ಡೇಟಾದಿಂದ ಎಲ್ಲಾ ದ್ವಿತೀಯ ದರ್ಜೆಯ ಬಹುಪದಗಳನ್ನು ಸೇರಿಸುವೆವು. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ ಇದು ಕೇವಲ `DayOfYear`<sup>2</sup> ಅರ್ಥವಾಗುತ್ತದೆ, ಆದರೆ ಎರಡು ಇನ್‌ಪುಟ್ ಚರಗಳು X ಮತ್ತು Y ಇದ್ದರೆ, ಇದು X<sup>2</sup>, XY ಮತ್ತು Y<sup>2</sup> ಸೇರಿಸುತ್ತದೆ. ನಾವು ಹೆಚ್ಚಿನ ದರ್ಜೆಯ ಬಹುಪದಗಳನ್ನು ಕೂಡ ಬಳಸಬಹುದು. `PolynomialFeatures(2)` ಬಳಕೆ ಅಂದರೆಲ ಸಂಪೂರ್ಣ ದ್ವಿತೀಯ ದರ್ಜೆಯ ಬಹುಪದಗಳನ್ನು ಇನ್ಪುಟ್ ಡೇಟಾದಿಂದ ಸೇರಿಸುವುದು. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಅದು ಕೇವಲ `DayOfYear`<sup>2</sup>, ಆದರೆ ಎರಡು ಇನ್ಪುಟ್ ಚರಗಳು X ಮತ್ತು Y ಇದ್ದರೆ, X<sup>2</sup>, XY ಮತ್ತು Y<sup>2</sup> ಸೇರಿಸಲಾಗುತ್ತದೆ. ನಾವು ಹೆಚ್ಚಿನ ದರ್ಜೆಯ ಬಹುಪದಗಳನ್ನು ಬಳಸಬಹುದು.
ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ಮೂಲ `LinearRegression` ವಸ್ತುವಿನಂತೆ ಬಳಸಬಹುದು, ಅಂದರೆ ನಾವು ಪೈಪ್‌ಲೈನ್ ಅನ್ನು `fit` ಮಾಡಬಹುದು, ನಂತರ `predict` ಬಳಸಿ ಭವಿಷ್ಯವಾಣಿ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯಬಹುದು. ಇಲ್ಲಿ ಪರೀಕ್ಷಾ ಡೇಟಾ ಮತ್ತು ಅಂದಾಜು ವಕ್ರವನ್ನು ತೋರಿಸುವ ಗ್ರಾಫ್ ಇದೆ: Pipelines ನ್ನು ಮೂಲ `LinearRegression` ವಸ್ತುವಿನಂತೆ ಉಪಯೋಗಿಸಬಹುದು, ಅಂದರೆ ನಾವು pipeline ನ್ನು `fit` ಮಾಡಬಹುದು ಮತ್ತು ನಂತರ `predict` ಬಳಸಿ ಭವಿಷ್ಯವಾಣಿ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯಬಹುದು. ಇದೇ ಚಿತ್ರವು ಪರೀಕ್ಷಾ ಡೇಟಾ ಮತ್ತು ಅಂದಾಜು ವಕ್ರರೇಖೆಯನ್ನು ತೋರಿಸುತ್ತದೆ:
<img alt="Polynomial regression" src="../../../../translated_images/kn/poly-results.ee587348f0f1f60b.webp" width="50%" /> <img alt="Polynomial regression" src="../../../../translated_images/kn/poly-results.ee587348f0f1f60b.webp" width="50%" />
ಬಹುಪದ ರಿಗ್ರೆಷನ್ ಬಳಸಿ, ನಾವು ಸ್ವಲ್ಪ ಕಡಿಮೆ MSE ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ಧಾರ ಸಹಗುಣಕವನ್ನು ಪಡೆಯಬಹುದು, ಆದರೆ ಬಹಳಷ್ಟು ಅಲ್ಲ. ನಾವು ಇತರ ಲಕ್ಷಣಗಳನ್ನು ಪರಿಗಣಿಸಬೇಕಾಗಿದೆ! Polynomial Regression ಬಳಸಿ ನಾವು ಸ್ವಲ್ಪ ಕಡಿಮೆ MSE ಮತ್ತು ಹೆಚ್ಚಾದ ನಿರ್ಣಾಯಕ коэффициент ಪಡೆಯಬಹುದು, ಆದರೆ ಬಹಳ ಹೆಚ್ಚಿನ ಪ್ರಭಾವವಿಲ್ಲ. ಇನ್ನಷ್ಟು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಪರಿಗಣಿಸುವ ಅಗತ್ಯವಿದೆ!
> ನೀವು ನೋಡಬಹುದು, ಕನಿಷ್ಠ ಕಂಬಳಿ ಬೆಲೆಗಳು ಹ್ಯಾಲೋವೀನ್ ಸುತ್ತಲೂ ಕಂಡುಬರುತ್ತವೆ. ಇದನ್ನು ನೀವು ಹೇಗೆ ವಿವರಿಸಬಹುದು? > ನೀವು ನೋಡಬಹುದು, ಕನಿಷ್ಠ ಪಂಪ್ಕಿನ್ ಬೆಲೆಗಳು ಹಲೋವೀನ್ ಬಾಡಿಯಲ್ಲಿ ಕೆಲವು ಸ್ಥಳಗಳಲ್ಲಿ ಕಂಡು ಬರುತ್ತವೆ. ಇದನ್ನು ನೀವು ಹೇಗೆ ವಿವರಿಸುತ್ತೀರಿ?
🎃 ಅಭಿನಂದನೆಗಳು, ನೀವು ಈಗ ಪೈ ಕಂಬಳಿಗಳ ಬೆಲೆಯನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಸಹಾಯ ಮಾಡುವ ಮಾದರಿಯನ್ನು ರಚಿಸಿದ್ದೀರಿ. ನೀವು ಬಹುಶಃ ಎಲ್ಲಾ ಕಂಬಳಿ ಪ್ರಕಾರಗಳಿಗೆ ಇದೇ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸಬಹುದು, ಆದರೆ ಅದು ಕಷ್ಟಕರವಾಗಬಹುದು. ಈಗ ನಾವು ನಮ್ಮ ಮಾದರಿಯಲ್ಲಿ ಕಂಬಳಿ ಪ್ರಭೇದವನ್ನು ಹೇಗೆ ಪರಿಗಣಿಸಬೇಕೆಂದು ಕಲಿಯೋಣ! 🎃 ಅಭಿನಂದನೆಗಳು, ನೀವು ಹತ್ತೊಂಬತ್ತು ಪಂಪ್ಕಿನ್ ಬೆಲೆಯ ಭವಿಷ್ಯವಾಣಿಗೆ ಸಹಾಯ ಮಾಡುವ ಮಾದರಿಯನ್ನು ಸೃಷ್ಟಿಸಿದ್ದಾರೆ. ನಾವೇ ಎಲ್ಲಾ ಪಂಪ್ಕಿನ್ ಪ್ರಕಾರಗಳಿಗೂ ಇದೇ ಕ್ರಮವನ್ನು ಪುನರಾವರ್ತಿಸಬಹುದು, ಆದರೆ ಅದು ಕಷ್ಟಕರವಾಗುತ್ತದೆ. ಈಗ ನಾವು ಹೇಗೆ ನಮ್ಮ ಮಾದರಿಯಲ್ಲಿ ಪಂಪ್ಕಿನ್ ವೈವಿಧ್ಯತೆಯನ್ನು ಪರಿಗಣಿಸುವುದನ್ನು ಕಲಿಯೋಣ!
## ವರ್ಗೀಕೃತ ಲಕ್ಷಣಗಳು ## ವರ್ಗೀಯ ಲಕ್ಷಣಗಳು (Categorical Features)
ಆದರ್ಶ ಜಗತ್ತಿನಲ್ಲಿ, ನಾವು ಒಂದೇ ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ವಿಭಿನ್ನ ಕಂಬಳಿ ಪ್ರಭೇದಗಳ ಬೆಲೆಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ. ಆದರೆ, `Variety` ಕಾಲಮ್ `Month` ಮುಂತಾದ ಕಾಲಮ್‌ಗಳಿಗಿಂತ ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿದೆ, ಏಕೆಂದರೆ ಅದು ಅಂಕಿ-ಅಂಶಗಳಲ್ಲದ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದೆ. ಇಂತಹ ಕಾಲಮ್‌ಗಳನ್ನು **ವರ್ಗೀಕೃತ** ಎಂದು ಕರೆಯುತ್ತಾರೆ. ಐಡಿಯಲ್ ಪ್ರಪಂಚದಲ್ಲಿ, ನಾವು ಒಂದೇ ಮಾದರಿಯಿಂದ ವಿಭಿನ್ನ ಪಂಪ್ಕಿನ್ ಪ್ರಕಾರಗಳ ಬೆಲೆಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ. ಆದರೆ `Variety` ಕಾಲಮ್ `Month` ಲాంటి ಕಾಲಮ್ ಗಳಿಗಿಂತ ಸ್ವಲ್ಪ ವಿಭಿನ್ನ, ಏಕೆಂದರೆ ಅದರಲ್ಲಿ ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯಗಳಿಲ್ಲ. ಇಂಥ ಕಾಲಮ್ ಗಳನ್ನು **category** ಎಂದರೆ ವರ್ಗೀಯ ಕಾಲಮ್ ಗಳಂತೆ ಆಹ್ವಾನಿಸಲಾಗುತ್ತದೆ.
[![ML for beginners - Categorical Feature Predictions with Linear Regression](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression") [![ML for beginners - Categorical Feature Predictions with Linear Regression](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
> 🎥 ವರ್ಗೀಕೃತ ಲಕ್ಷಣಗಳನ್ನು ಬಳಸುವ ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತ ವೀಡಿಯೋ ಅವಲೋಕನಕ್ಕಾಗಿ ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ. > 🎥 ಕೆಳಗಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿರಿ, ವರ್ಗೀಯ ಲಕ್ಷಣಗಳನ್ನು ಉಪಯೋಗಿಸುವ ಶೀಘ್ರ ವಿಡಿಯೋ ಅವಲೋಕನಕ್ಕೆ.
ಇಲ್ಲಿ ನೀವು ಪ್ರಭೇದದ ಮೇಲೆ ಸರಾಸರಿ ಬೆಲೆ ಹೇಗೆ ಅವಲಂಬಿತವಾಗಿದೆ ಎಂದು ನೋಡಬಹುದು: ಇಲ್ಲಿ ನೀವು ವೈವಿಧ್ಯತೆಯ ಪ್ರಕಾರ ಸರಾಸರಿ ಬೆಲೆ ಹೇಗೆ ಅವಲಂಬಿತವಾಗಿದೆ ಎಂದು ನೋಡಬಹುದು:
<img alt="Average price by variety" src="../../../../translated_images/kn/price-by-variety.744a2f9925d9bcb4.webp" width="50%" /> <img alt="Average price by variety" src="../../../../translated_images/kn/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
ಪ್ರಭೇದವನ್ನು ಪರಿಗಣಿಸಲು, ಮೊದಲು ಅದನ್ನು ಅಂಕಿ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಬೇಕಾಗುತ್ತದೆ, ಅಥವಾ **ಎನ್‌ಕೋಡ್** ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು ಹಲವಾರು ವಿಧಾನಗಳಿವೆ: ವೈವಿಧ್ಯತೆಯನ್ನು ಪರಿಗಣಿಸಲು, ಮೊದಲು ಅದನ್ನು ಸಂಖ್ಯಾತ್ಮಕ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಬೇಕಾಗುತ್ತದೆ, ಅಂದರೆ **encode** ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇದಕ್ಕಾಗಿ ಕೆಲವೊಂದು ವಿಧಾನಗಳಿವೆ:
* ಸರಳ **ಅಂಕಿ ಎನ್‌ಕೋಡಿಂಗ್** ವಿಭಿನ್ನ ಪ್ರಭೇದಗಳ ಟೇಬಲ್ ರಚಿಸಿ, ನಂತರ ಆ ಟೇಬಲ್‌ನಲ್ಲಿನ ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರಭೇದದ ಹೆಸರನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ. ಇದು ರೇಖೀಯ ರಿಗ್ರೆಷನ್‌ಗೆ ಉತ್ತಮ ಐಡಿಯಾ ಅಲ್ಲ, ಏಕೆಂದರೆ ರೇಖೀಯ ರಿಗ್ರೆಷನ್ ಸೂಚ್ಯಂಕದ ನಿಜವಾದ ಅಂಕಿ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಂಡು, ಅದನ್ನು ಫಲಿತಾಂಶಕ್ಕೆ ಸೇರಿಸಿ, ಕೆಲವು ಸಹಗುಣಕದಿಂದ ಗುಣಿಸುತ್ತದೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಸೂಚ್ಯಂಕ ಸಂಖ್ಯೆ ಮತ್ತು ಬೆಲೆಯ ನಡುವಿನ ಸಂಬಂಧ ಸ್ಪಷ್ಟವಾಗಿ ಅರೇಖೀಯವಲ್ಲ, ಸೂಚ್ಯಂಕಗಳು ನಿರ್ದಿಷ್ಟ ಕ್ರಮದಲ್ಲಿ ಇರಿಸಿದರೂ ಸಹ. * ಸರಳ **ಸಂಖ್ಯಾತ್ಮಕ ಎನ್ಕೋಡಿಂಗ್** ವಿಭಿನ್ನ ವೈವಿಧ್ಯತೆಯ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಿ, ನಂತರ ವೈವಿಧ್ಯತೆಯ ಹೆಸರನ್ನು ಆ ಪಟ್ಟಿಯಲ್ಲಿ ನಿಬಂಧಿತ ಸೂಚ್ಯಂಕಕ್ಕೆ ಬದಲಿಸಿ. ಇದು ರೇಖೀಯ regression ಗೆ ಹೆಚ್ಚಿನ ಒಳ್ಳೆಯ ಆಯ್ಕೆ ಅಲ್ಲ, ಏಕೆಂದರೆ ರೇಖೀಯ regression ಸೂಚ್ಯಂಕದ ಅವರನ್ನು ನೇರ ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯವಾಗಿ ಪರಿಗಣಿಸಿ ಫಲಿತಾಂಶದಲ್ಲಿ ಕೆಲ coefficient ಗಳೊಂದಿಗೆ ಗುಣಿಸುತ್ತದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಸೂಚ್ಯಂಕಗಳು ಮತ್ತು ಬೆಲೆಯ ನಡುವೆ ಸಂಬಂಧ ಸ್ಪಷ್ಟವಾಗಿ ರೇಖೀಯವಲ್ಲ, ಮತ್ತು ಸೂಚ್ಯಂಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ಕ್ರಮದಲ್ಲಿ ಅಳವಡಿಸಿದರೂ ಸಹ.
* **ಒನ್-ಹಾಟ್ ಎನ್‌ಕೋಡಿಂಗ್** `Variety` ಕಾಲಮ್ ಅನ್ನು 4 ವಿಭಿನ್ನ ಕಾಲಮ್‌ಗಳಾಗಿ ಬದಲಾಯಿಸುತ್ತದೆ, ಪ್ರತಿ ಪ್ರಭೇದಕ್ಕೆ ಒಂದು ಕಾಲಮ್. ಪ್ರತಿ ಕಾಲಮ್‌ನಲ್ಲಿ, ಸಂಬಂಧಿಸಿದ ಸಾಲು ಆ ಪ್ರಭೇದಕ್ಕೆ ಸೇರಿದರೆ `1` ಇರುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ `0`. ಇದರರ್ಥ, ರೇಖೀಯ ರಿಗ್ರೆಷನ್‌ನಲ್ಲಿ ನಾಲ್ಕು ಸಹಗುಣಕಗಳು ಇರುತ್ತವೆ, ಪ್ರತಿ ಕಂಬಳಿ ಪ್ರಭೇದಕ್ಕೆ ಒಂದು, ಅದು ಆ ಪ್ರಭೇದಕ್ಕೆ "ಆರಂಭಿಕ ಬೆಲೆ" (ಅಥವಾ "ಹೆಚ್ಚುವರಿ ಬೆಲೆ") ಗೆ ಹೊಣೆಗಾರ. * **ಒನ್-ಹಾಟ್ ಎನ್ಕೋಡಿಂಗ್** `Variety` ಕಾಲಮ್ ನ್ನು 4 ವಿಭಿನ್ನ ಕಾಲಮ್ ಗಳಾಗಿಸುವುದು, ಪ್ರತಿ ವೈವಿಧ್ಯತೆಯರಿಗೆ ಒಂದು ಕಾಲಮ್. ಪ್ರತಿಯೊಂದು ಕಾಲಮ್ ನಲ್ಲಿ `1` ಇರುತ್ತದೆ, ಅಂದರೆ ಆ ಸಾಲಿನ ವೈವಿಧ್ಯತಾ ನೀಡಲ್ಪಟ್ಟಿರುವುದು ಮತ್ತು ಬೇರೆಯಲ್ಲಿ `0`. ಇದರ ಅರ್ಥ regression ನಲ್ಲಿ ನಾಲ್ಕು coefficients ಇರುವಂತೆ, ಪ್ರತಿ ಪಂಪ್ಕಿನ್ ವೈವಿಧ್ಯತೆಯ "ಆರಂಭಿಕ ಬೆಲೆ" (ಅಥವಾ "ಹೆಚ್ಚುವರಿ ಬೆಲೆ") ನ್ನು ನಿರ್ಧರಿಸುವಂತೆ.
ಕೆಳಗಿನ ಕೋಡ್ ಒನ್-ಹಾಟ್ ಎನ್‌ಕೋಡಿಂಗ್ ಹೇಗೆ ಮಾಡಬಹುದು ಎಂದು ತೋರಿಸುತ್ತದೆ: ಕೆಳಗಿನ ಕೋಡ್ ಒನ್-ಹಾಟ್ ಎನ್ಕೋಡಿಂಗ್ ಸಂಬಂಧಿಸಿ ತೋರಿಸುತ್ತದೆ:
```python ```python
pd.get_dummies(new_pumpkins['Variety']) pd.get_dummies(new_pumpkins['Variety'])
@ -290,14 +305,14 @@ pd.get_dummies(new_pumpkins['Variety'])
1741 | 0 | 1 | 0 | 0 1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0 1742 | 0 | 1 | 0 | 0
ಒನ್-ಹಾಟ್ ಎನ್‌ಕೋಡ್ ಮಾಡಿದ ಪ್ರಭೇದವನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ಬಳಸಿಕೊಂಡು ರೇಖೀಯ ರಿಗ್ರೆಷನ್ ತರಬೇತಿ ನೀಡಲು, ನಾವು ಸರಿಯಾಗಿ `X` ಮತ್ತು `y` ಡೇಟಾವನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕಾಗುತ್ತದೆ: ಒನ್-ಹಾಟ್ ಎನ್ಕೋಡಿಂಗ್ ಮಾಡಿದ variety ನ್ನು ಇನ್ಪುಟ್ ಆಗಿ ಪಡೆದು linear regression ತರಬೇತಿ ಮಾಡಲು, ನಾವು ಸರಿಯಾಗಿ `X` ಮತ್ತು `y` ಡೇಟಾಗಳನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕಾಗುತ್ತದೆ:
```python ```python
X = pd.get_dummies(new_pumpkins['Variety']) X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price'] y = new_pumpkins['Price']
``` ```
ಮತ್ತೆ ಉಳಿದ ಕೋಡ್ ಮೇಲಿನ ರೇಖೀಯ ರಿಗ್ರೆಷನ್ ತರಬೇತಿಗೆ ಬಳಸಿದಂತೆಯೇ ಇದೆ. ನೀವು ಪ್ರಯತ್ನಿಸಿದರೆ, ಸರಾಸರಿ ಚದರ ದೋಷವು ಸುಮಾರು ಅದೇ ಆಗಿದ್ದು, ಆದರೆ ನಿರ್ಧಾರ ಸಹಗುಣಕವು ಬಹಳ ಹೆಚ್ಚು (~77%) ಆಗಿದೆ ಎಂದು ಕಾಣುತ್ತೀರಿ. ಇನ್ನೂ ನಿಖರವಾದ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಪಡೆಯಲು, ನಾವು ಇನ್ನಷ್ಟು ವರ್ಗೀಕೃತ ಲಕ್ಷಣಗಳನ್ನು ಮತ್ತು ಅಂಕಿ ಲಕ್ಷಣಗಳನ್ನು, ಉದಾಹರಣೆಗೆ `Month` ಅಥವಾ `DayOfYear` ಅನ್ನು ಪರಿಗಣಿಸಬಹುದು. ಒಂದು ದೊಡ್ಡ ಲಕ್ಷಣಗಳ ಸರಣಿಯನ್ನು ಪಡೆಯಲು, ನಾವು `join` ಬಳಸಬಹುದು: ಮತ್ತಷ್ಟು ಕೋಡ್ linear regression ತರಬೇತಿಗೆ ಮೇಲಿನಂತೆಯೇ ಇದೆ. ನೀವು ಪ್ರಯತ್ನಿಸಿದರೆ, mean squared error ಹೋಲಿಕೆಯಲ್ಲಿ ಅದೇ ಮಟ್ಟದಲ್ಲಿದ್ದು, ಆದರೆ coefficient of determination (~77%) ಹೆಚ್ಚು ಇದೆ. ಮತ್ತಷ್ಟು ಖಚಿತ ಭವಿಷ್ಯವಾಣಿಗಾಗಿ, ನಮಗೆ ಇನ್ನಷ್ಟು ವರ್ಗೀಯ ಮತ್ತು ಸಂಖ್ಯಾತ್ಮಕ ಲಕ್ಷಣಗಳನ್ನು ಪರಿಗಣಿಸಬೇಕಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ `Month` ಅಥವಾ `DayOfYear`. ಒಂದೇ ದೊಡ್ಡ array(features) ಪಡೆಯಲು, ನಾವು `join` ಬಳಸಿ:
```python ```python
X = pd.get_dummies(new_pumpkins['Variety']) \ X = pd.get_dummies(new_pumpkins['Variety']) \
@ -307,31 +322,31 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price'] y = new_pumpkins['Price']
``` ```
ಇಲ್ಲಿ ನಾವು `City` ಮತ್ತು `Package` ಪ್ರಕಾರವನ್ನು ಕೂಡ ಪರಿಗಣಿಸುತ್ತೇವೆ, ಇದು ನಮಗೆ MSE 2.84 (10%) ಮತ್ತು ನಿರ್ಧಾರ 0.94 ನೀಡುತ್ತದೆ! ಇಲ್ಲಿ ನಾವು `City` ಮತ್ತು `Package` ಪ್ರಕಾರಗಳನ್ನು ಕೂಡ ಪರಿಗಣಿಸಿ, ಇದರಿಂದ MSE 2.84 (10%) ಮತ್ತು ನಿರ್ಣಾಯಕ коэффициент 0.94 ಸಿಗುತ್ತದೆ!
## ಎಲ್ಲವನ್ನೂ ಒಟ್ಟಿಗೆ ಸೇರಿಸುವುದು ## ಎಲ್ಲವನ್ನೂ ಒಟ್ಟುಗೂಡಿಸುವುದು
ಉತ್ತಮ ಮಾದರಿಯನ್ನು ಮಾಡಲು, ನಾವು ಮೇಲಿನ ಉದಾಹರಣೆಯಿಂದ ಸಂಯೋಜಿತ (ಒನ್-ಹಾಟ್ ಎನ್‌ಕೋಡ್ ಮಾಡಿದ ವರ್ಗೀಕೃತ + ಅಂಕಿ) ಡೇಟಾವನ್ನು ಬಹುಪದ ರಿಗ್ರೆಷನ್ ಜೊತೆಗೆ ಬಳಸಬಹುದು. ನಿಮ್ಮ ಅನುಕೂಲಕ್ಕಾಗಿ ಸಂಪೂರ್ಣ ಕೋಡ್ ಇಲ್ಲಿದೆ: ಉತ್ತಮ ಮಾದರಿಯನ್ನು ರಚಿಸಲು, ನಾವು ಮೇಲಿನ ಉದಾಹರಣೆಯಿಂದ ಸಂಯುಕ್ತ (ಒನ್-ಹಾಟ್ ಎನ್ಕೋಡಿಂಗ್ + ಸಂಖ್ಯಾತ್ಮಕ) ಡೇಟಾವನ್ನು Polynomial Regression ಜೊತೆಗೆ ಬಳಸಬಹುದು. ನಿಮ್ಮ ಅನುಕೂಲಕ್ಕೆ ಸಂಪೂರ್ಣ ಕೋಡ್ ಇಲ್ಲಿ:
```python ```python
# ತರಬೇತಿ ಡೇಟಾವನ್ನು ಸಜ್ಜುಗೊಳಿಸಿ # ತರಬೇತಿ ಡೇಟಾವನ್ನು ಹೊಂದಿಸು
X = pd.get_dummies(new_pumpkins['Variety']) \ X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \ .join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \ .join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package'])) .join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price'] y = new_pumpkins['Price']
# ತರಬೇತಿ-ಪರೀಕ್ಷೆ ವಿಭಜನೆ ಮಾಡಿ # ತರಬೇತಿ-ಪರೀಕ್ಷೆ ಹೋಲಿಕೆಯನ್ನು ಮಾಡು
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
# ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಸಜ್ಜುಗೊಳಿಸಿ ಮತ್ತು ತರಬೇತಿ ನೀಡಿ # ಪೈಪ್ಲೈನ್ ಅನ್ನು ಹೊಂದಿಸಿ ಮತ್ತು ತರಬೇತಿಯನ್ನು ನೀಡಿ
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression()) pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train) pipeline.fit(X_train,y_train)
# ಪರೀಕ್ಷಾ ಡೇಟಾದ ಫಲಿತಾಂಶಗಳನ್ನು ಭವಿಷ್ಯವಾಣಿ ಮಾಡಿ # ಪರೀಕ್ಷಾ ಡೇಟಾದ ಫಲಿತಾಂಶಗಳನ್ನು ಊಹಿಸು
pred = pipeline.predict(X_test) pred = pipeline.predict(X_test)
# MSE ಮತ್ತು ನಿರ್ಧಾರವನ್ನು ಲೆಕ್ಕಹಾಕಿ # MSE ಮತ್ತು ನಿರ್ಧಾರವನ್ನು ಲೆಕ್ಕಿಸಿ
mse = np.sqrt(mean_squared_error(y_test,pred)) mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)') print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
@ -339,36 +354,36 @@ score = pipeline.score(X_train,y_train)
print('Model determination: ', score) print('Model determination: ', score)
``` ```
ಇದು ನಮಗೆ ಸುಮಾರು 97% ನಿರ್ಧಾರ ಸಹಗುಣಕ ಮತ್ತು MSE=2.23 (~8% ಭವಿಷ್ಯವಾಣಿ ದೋಷ) ನೀಡಬೇಕು. ಇದು ಸುತ್ತಮುತ್ತ 97% ಅಷ್ಟಷ್ಟೇ ಉತ್ತಮ ನಿರ್ಣಾಯಕ коэффициент ಮತ್ತು MSE=2.23 (~8% ಭವಿಷ್ಯ ತಪ್ಪು) ನೀಡುತ್ತದೆ.
| ಮಾದರಿ | MSE | ನಿರ್ಧಾರ | | ಮಾದರಿ | MSE | ನಿರ್ಣಾಯಕ коэффициент |
|-------|-----|---------| |-------|-----|------------------|
| `DayOfYear` ರೇಖೀಯ | 2.77 (17.2%) | 0.07 | | `DayOfYear` ರೇಖೀಯ | 2.77 (17.2%) | 0.07 |
| `DayOfYear` ಬಹುಪದ | 2.73 (17.0%) | 0.08 | | `DayOfYear` ಬಹುಪದ | 2.73 (17.0%) | 0.08 |
| `Variety` ರೇಖೀಯ | 5.24 (19.7%) | 0.77 | | `Variety` ರೇಖೀಯ | 5.24 (19.7%) | 0.77 |
| ಎಲ್ಲಾ ಲಕ್ಷಣಗಳು ರೇಖೀಯ | 2.84 (10.5%) | 0.94 | | ಎಲ್ಲಾ ಲಕ್ಷಣಗಳು ರೇಖೀಯ | 2.84 (10.5%) | 0.94 |
| ಎಲ್ಲಾ ಲಕ್ಷಣಗಳು ಬಹುಪದ | 2.23 (8.25%) | 0.97 | | ಎಲ್ಲಾ ಲಕ್ಷಣಗಳು ಬಹುಪದ | 2.23 (8.25%) | 0.97 |
🏆 ಚೆನ್ನಾಗಿದೆ! ನೀವು ಒಂದೇ ಪಾಠದಲ್ಲಿ ನಾಲ್ಕು ರಿಗ್ರೆಷನ್ ಮಾದರಿಗಳನ್ನು ರಚಿಸಿ, ಮಾದರಿ ಗುಣಮಟ್ಟವನ್ನು 97% ಗೆ ಸುಧಾರಿಸಿದ್ದೀರಿ. ರಿಗ್ರೆಷನ್‌ನ ಅಂತಿಮ ವಿಭಾಗದಲ್ಲಿ, ನೀವು ವರ್ಗಗಳನ್ನು ನಿರ್ಧರಿಸಲು ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಷನ್ ಬಗ್ಗೆ ಕಲಿಯುತ್ತೀರಿ. 🏆 ಚೆನ್ನಾಗಿದೆ! ನೀವು ಒಂದೇ ಪಾಠದಲ್ಲಿ ನಾಲ್ಕು Regression ಮಾದರಿಗಳನ್ನು ರಚಿಸಿ, ಮಾದರಿಯ ಗುಣಮಟ್ಟವನ್ನು 97%ಕ್ಕೆ ಸುಧಾರಿಸಿದ್ದಾರೆ. Regression ಹಂತದ ಕೊನೆಯಲ್ಲಿ, ನೀವು Logistic Regression ಕುರಿತು ಕಲಿತೀರಿ, ಅದು ವರ್ಗಗಳನ್ನು ನಿರ್ಧರಿಸುವಲ್ಲಿ ಉಪಯೋಗವಾಗುತ್ತದೆ.
--- ---
## 🚀ಸವಾಲು ## 🚀ಸವಾಲು
ಈ ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ವಿವಿಧ ಚರಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ, ಸಹಸಂಬಂಧವು ಮಾದರಿ ನಿಖರತೆಗೆ ಹೇಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ನೋಡಿ. ಈ ನೋಟ್ಬುಕ್‌ನಲ್ಲಿ ಹಲವು ಬದಲಾವಣೆಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ, ಸವಾಲು ಹಾಗೂ ಮಾದರಿಯ ನಿಖರತೆಗೆ ಸಂಬಂಧವಿದೆ ಎಂದು ತಿಳಿದುಕೊಳ್ಳಿ.
## [ಪಾಠೋತ್ತರ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/) ## [ಪಾಠದ ನಂತರದ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ ## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ
ಈ ಪಾಠದಲ್ಲಿ ನಾವು ರೇಖೀಯ ರಿಗ್ರೆಷನ್ ಬಗ್ಗೆ ಕಲಿತೆವು. ಇನ್ನೂ ಕೆಲವು ಪ್ರಮುಖ ರಿಗ್ರೆಷನ್ ಪ್ರಕಾರಗಳಿವೆ. ಸ್ಟೆಪ್ವೈಸ್, ರಿಡ್ಜ್, ಲಾಸ್ಸೋ ಮತ್ತು ಎಲಾಸ್ಟಿಕ್‌ನೆಟ್ ತಂತ್ರಗಳನ್ನು ಓದಿ ತಿಳಿಯಿರಿ. ಇನ್ನಷ್ಟು ಕಲಿಯಲು ಉತ್ತಮ ಕೋರ್ಸ್ [ಸ್ಟ್ಯಾನ್‌ಫೋರ್ಡ್ ಸ್ಟಾಟಿಸ್ಟಿಕಲ್ ಲರ್ನಿಂಗ್ ಕೋರ್ಸ್](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning) ಆಗಿದೆ. ಈ ಪಾಠದಲ್ಲಿ ನಾವು Linear Regression ಬಗ್ಗೆ ಕಲಿತೆವು. ಇನ್ನಷ್ಟು ಪ್ರಮುಖ Regression ವಿಧಗಳಿವೆ. Stepwise, Ridge, Lasso ಮತ್ತು Elasticnet ತಂತ್ರಗಳನ್ನು ಓದಿ ತಿಳಿದುಕೊಳ್ಳಿ. ಉತ್ತಮ ಅಧ್ಯಯನ ಕೋರ್ಸ್ ಆಗಿದ್ದು [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning).
## ಹುದ್ದೆ ## ನಿಯೋಜನೆ
[ಮಾದರಿ ರಚಿಸಿ](assignment.md) [ಮಾದರಿ ರಚಿಸಿ](assignment.md)
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕಾರ**: **ತ್ಯಾಗಪತ್ರ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ. ಈ ದಸ್ತಾವೇಜನ್ನು AI ಅನುವಾದ ಸೇವೆ [ಕೋ-ಓಪ್ ಟ್ರಾನ್ಸ್‌ಲೇಟರ್](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಗೆ ಪ್ರಯತ್ನಿಸುವಾಗಲೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪುಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪುಭಾಷ್ಯಗಳು ಅಥವಾ ಅರ್ಥಕೊಳಕೊಳ್ಳಿಕೆಗಳಿಗಾಗಿ ನಾವು ಜವಾಬ್ದಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

108
translations/kn/4-Classification/3-Classifiers-2/README.md
Unescape View File

@ -1,44 +1,44 @@
# ಆಹಾರ ವರ್ಗೀಕರಣಗಳು 2 # ಆಹಾರ ವರ್ಗೀಕರಣಕಾರರು 2
ಈ ಎರಡನೇ ವರ್ಗೀಕರಣ ಪಾಠದಲ್ಲಿ, ನೀವು ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುವ ಇನ್ನಷ್ಟು ವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸುವಿರಿ. ನೀವು ಒಂದು ವರ್ಗೀಕರಣಕಾರಿಯನ್ನು ಇನ್ನೊಂದರಿಗಿಂತ ಆಯ್ಕೆಮಾಡುವ ಪರಿಣಾಮಗಳ ಬಗ್ಗೆ ಸಹ ತಿಳಿಯುವಿರಿ. ಈ ಎರಡನೇ ವರ್ಗೀಕರಣ ಪಾಠದಲ್ಲಿ, ನೀವು ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುವ ಇನ್ನೂ ಹೆಚ್ಚಿನ ರೀತಿಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೀರಿ. ನೀವು ಒಂದು ವರ್ಗೀಕರಣಕಾರಿಯನ್ನು ಮತ್ತೊಂದರ ಮೇಲೆ ಆರಿಸುವುದರ ಪರಿಣಾಮಗಳ ಬಗ್ಗೆ ಕೂಡ ತಿಳಿದುಕೊಳ್ಳುತ್ತೀರಿ.
## [ಪೂರ್ವ-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/) ## [ಪೂರ್ವ-ಪಾಠ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
### ಪೂರ್ವಾಪೇಕ್ಷೆ ### ಪೂರ್ವಾಪಶ್ಚಾತ್
ನೀವು ಹಿಂದಿನ ಪಾಠಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ್ದೀರಿ ಮತ್ತು ನಿಮ್ಮ `data` ಫೋಲ್ಡರ್‌ನಲ್ಲಿ _cleaned_cuisines.csv_ ಎಂಬ ಸ್ವಚ್ಛಗೊಳಿಸಿದ ಡೇಟಾಸೆಟ್ ಇದೆ ಎಂದು ನಾವು ಊಹಿಸುತ್ತೇವೆ, ಇದು ಈ 4-ಪಾಠ ಫೋಲ್ಡರ್‌ನ ರೂಟ್‌ನಲ್ಲಿ ಇದೆ. ನೀವು ಹಿಂದಿನ ಪಾಠಗಳನ್ನು ಮುಗಿಸಿಕೊಂಡಿದ್ದೀರೆಂದು ಮತ್ತು ಈ 4-ಪಾಠಗಳ ಫೋಲ್ಡರ್ ರೂಟ್‌ನಲ್ಲಿ `data` ಫೋಲ್ಡರ್‌ನಲ್ಲಿ _cleaned_cuisines.csv_ ಎಂಬ ಶುಧ್ಧೀಕರಿಸಲಾದ ಡೇಟಾಸೆಟ್ ಹೊಂದಿದ್ದೀರಿ ಎಂದು ನಾವು ನಿರ್ಧರಿಸುತ್ತೇವೆ.
### ತಯಾರಿ ### ತಯಾರಿ
ನಾವು ನಿಮ್ಮ _notebook.ipynb_ ಫೈಲ್ ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿದ ಡೇಟಾಸೆಟ್‌ನೊಂದಿಗೆ ಲೋಡ್ ಮಾಡಿದ್ದೇವೆ ಮತ್ತು ಅದನ್ನು X ಮತ್ತು y ಡೇಟಾಫ್ರೇಮ್‌ಗಳಾಗಿ ವಿಭಜಿಸಿದ್ದೇವೆ, ಮಾದರಿ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಗೆ ಸಿದ್ಧವಾಗಿದೆ. ನಾವು ನಿಮ್ಮ _notebook.ipynb_ ಫೈಲ್‌ನ್ನು ಶುಧ್ಧೀಕರಿಸಲಾದ ಡೇಟಾಸೆಟ್‌ನೊಂದಿಗೆ ಲೋಡ್ ಮಾಡಿದ್ದೇವೆ ಮತ್ತು ಇದನ್ನು X ಮತ್ತು y ಡೇಟಾಫ್ರೇಮ್ಗಳಾಗಿ ವಿಭಜಿಸಿ ಮೋಡಲ್ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಗೆ ಸಿದ್ಧಪಡಿಸಿದ್ದೇವೆ.
## ವರ್ಗೀಕರಣ ನಕ್ಷೆ ## ವರ್ಗೀಕರಣ ನಕ್ಷೆ
ಹಿಂದೆ, ನೀವು ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುವಾಗ Microsoft ನ ಚೀಟ್ ಶೀಟ್ ಬಳಸಿ ವಿವಿಧ ಆಯ್ಕೆಗಳ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೀರಿ. Scikit-learn ಒಂದು ಸಮಾನವಾದ, ಆದರೆ ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮ ಚೀಟ್ ಶೀಟ್ ಅನ್ನು ನೀಡುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಅಂದಾಜುಕಾರರನ್ನು (ಮತ್ತೊಂದು ಪದದಲ್ಲಿ ವರ್ಗೀಕರಣಕಾರರು) ಇನ್ನಷ್ಟು ನಿಖರಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ: ಹಿಂದೆ, ನೀವು ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುವಾಗ ನಿಮಗೆ ಇರುವ ವಿಭಿನ್ನ ಆಯ್ಕೆಗಳ ಬಗ್ಗೆ Microsoft's ಚೀಟ್ ಶೀಟ್ ಮೂಲಕ ತಿಳಿದುಕೊಂಡಿದ್ದಿರಿ. Scikit-learn ಸಹ ಹೋಲುವ, ಆದರೆ ಇನ್ನಷ್ಟು ಸೂಕ್ಷ್ಮವಾಗಿರುವ ಚೀಟ್ ಶೀಟ್ ಅನ್ನು ನೀಡುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಅಂದಾಜುಕರರನ್ನು (ವರ್ಗೀಕರಣಕಾರರು ಎಂದು ಬೇರೆ ಹೆಸರು) ಇನ್ನಷ್ಟು ಸಂಕೋಚಿತಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ:
![ML Map from Scikit-learn](../../../../translated_images/kn/map.e963a6a51349425a.webp) ![ML Map from Scikit-learn](../../../../translated_images/kn/map.e963a6a51349425a.webp)
> ಟಿಪ್: [ಈ ನಕ್ಷೆಯನ್ನು ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ಭೇಟಿ ನೀಡಿ](https://scikit-learn.org/stable/tutorial/machine_learning_map/) ಮತ್ತು ದಾರಿಯಲ್ಲಿ ಕ್ಲಿಕ್ ಮಾಡಿ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಓದಿ. > ಟಿಪ್: [ಈ ನಕ್ಷೆಯನ್ನು ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ಸಂದರ್ಶಿಸಿ](https://scikit-learn.org/stable/tutorial/machine_learning_map/) ಮತ್ತು ದಾರಿಯಲ್ಲಿ ಕ್ಲಿಕ್ ಮಾಡಿ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಓದಿರಿ.
### ಯೋಜನೆ ### ಯೋಜನೆ
ನಿಮ್ಮ ಡೇಟಾ ಸ್ಪಷ್ಟವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಂಡ ನಂತರ ಈ ನಕ್ಷೆ ಬಹಳ ಸಹಾಯಕವಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ನೀವು ಅದರ ದಾರಿಗಳಲ್ಲಿ 'ನಡೆದು' ನಿರ್ಧಾರಕ್ಕೆ ಬರಬಹುದು: ನಿಮ್ಮ ಡೇಟಾದ ಸ್ಪಷ್ಟ ಗ್ರಹಿಕೆಯಿದ್ದಾಗ ಈ ನಕ್ಷೆ ತುಂಬ ಸಹಾಯಕವಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ನೀವು ನಿರ್ಧಾರಕ್ಕೆ ಈ ದಾರಿಗಳನ್ನು 'ನಡೆದು' ಹೋಗಬಹುದು:
- ನಮಗೆ >50 ಮಾದರಿಗಳು ಇವೆ - ನಮ್ಮ ಬಳಿ >50 ಮಾದರಿಗಳು ಇವೆ
- ನಾವು ಒಂದು ವರ್ಗವನ್ನು ಊಹಿಸಲು ಬಯಸುತ್ತೇವೆ - ನಾವು ಶ್ರೇಣಿಯನ್ನು ಊಹಿಸಲು ಬಯಸುತ್ತೇವೆ
- ನಮಗೆ ಲೇಬಲ್ ಮಾಡಲಾದ ಡೇಟಾ ಇದೆ - ನಮಗೆ ಲೇಬಲ್ ಮಾಡಲಾದ ಡೇಟಾ ಇದೆ
- ನಮಗೆ 100K ಕ್ಕಿಂತ ಕಡಿಮೆ ಮಾದರಿಗಳು ಇವೆ - ನಮಗಿರುವ ಮಾದರಿಗಳು 100K ಕ್ಕಿಂತ ಕಡಿಮೆ
- ✨ ನಾವು ಲೀನಿಯರ್ SVC ಆಯ್ಕೆಮಾಡಬಹುದು - ✨ ನಾವು ಲಿನಿಯರ್ SVC ಅನ್ನು ಆರಿಸಬಹುದು
- ಅದು ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ಏಕೆಂದರೆ ನಮಗೆ ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾ ಇದೆ - ಅದು ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ಏಕೆಂದರೆ ನಮಗೆ ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾ ಇದೆ
- ನಾವು ✨ KNeighbors ವರ್ಗೀಕರಣಕಾರಿಯನ್ನು ಪ್ರಯತ್ನಿಸಬಹುದು - ನಾವು ✨ KNeighbors ವರ್ಗೀಕರಣಕಾರಿಯನ್ನು ಪ್ರಯತ್ನಿಸಬಹುದು
- ಅದು ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ✨ SVC ಮತ್ತು ✨ Ensemble ವರ್ಗೀಕರಣಕಾರಿಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ - ಅದು ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ✨ SVC ಮತ್ತು ✨ Ensemble ವರ್ಗೀಕರಿಸುಕರುಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ
ಇದು ಅನುಸರಿಸಲು ಬಹಳ ಸಹಾಯಕ ದಾರಿಯಾಗಿದೆ. ಇದು ಅನುಸರಿಸಲು ತುಂಬಾ ಸಹಾಯಕವಾದ ಮಾರ್ಗವಾಗಿದೆ.
## ಅಭ್ಯಾಸ - ಡೇಟಾವನ್ನು ವಿಭಜಿಸಿ ## ವ್ಯಾಯಾಮ - ಡೇಟಾವನ್ನು ವಿಭಜಿಸಿ
ಈ ದಾರಿಯನ್ನು ಅನುಸರಿಸಿ, ನಾವು ಕೆಲವು ಲೈಬ್ರರಿಗಳನ್ನು ಆಮದುಮಾಡುವುದರಿಂದ ಪ್ರಾರಂಭಿಸಬೇಕು. ಈ ದಾರಿಯನ್ನು ಅನುಸರಿಸಿ, ನಾವು ಕೆಲವು ಗ್ರಂಥಾಲಯಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವುದರಿಂದ ಆರಂಭಿಸೋಣ.
1. ಅಗತ್ಯವಿರುವ ಲೈಬ್ರರಿಗಳನ್ನು ಆಮದುಮಾಡಿ: 1. ಅಗತ್ಯವಿರುವ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ:
```python ```python
from sklearn.neighbors import KNeighborsClassifier from sklearn.neighbors import KNeighborsClassifier
@ -50,31 +50,31 @@
import numpy as np import numpy as np
``` ```
1. ನಿಮ್ಮ ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ವಿಭಜಿಸಿ: 2. ನಿಮ್ಮ ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ವಿಭಜಿಸಿ:
```python ```python
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3) X_train, X_test, y_train, y_test = train_test_split(cuisines_features_df, cuisines_label_df, test_size=0.3)
``` ```
## ಲೀನಿಯರ್ SVC ವರ್ಗೀಕರಣಕಾರ ## ಲಿನಿಯರ್ SVC ವರ್ಗೀಕರಣಕಾರ
ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ಕ್ಲಸ್ಟರಿಂಗ್ (SVC) ಎಂಬುದು ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ಯಂತ್ರಗಳ ಕುಟುಂಬದ ಒಂದು ಭಾಗವಾಗಿದೆ (ಈ ಬಗ್ಗೆ ಕೆಳಗೆ ಇನ್ನಷ್ಟು ತಿಳಿಯಿರಿ). ಈ ವಿಧಾನದಲ್ಲಿ, ನೀವು ಲೇಬಲ್‌ಗಳನ್ನು ಹೇಗೆ ಕ್ಲಸ್ಟರ್ ಮಾಡಬೇಕೆಂದು ನಿರ್ಧರಿಸಲು 'ಕರ್ಣಲ್' ಆಯ್ಕೆಮಾಡಬಹುದು. 'C' ಪರಿಮಾಣವು 'ನಿಯಮಿತತೆ'ಗೆ ಸಂಬಂಧಿಸಿದೆ, ಇದು ಪರಿಮಾಣಗಳ ಪ್ರಭಾವವನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ. ಕರ್ಣಲ್ [ಬಹುಮಾನ](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC)ಗಳಲ್ಲೊಂದು ಆಗಿರಬಹುದು; ಇಲ್ಲಿ ನಾವು ಲೀನಿಯರ್ SVC ಬಳಸಲು 'linear' ಎಂದು ಹೊಂದಿಸಿದ್ದೇವೆ. Probability ಡೀಫಾಲ್ಟ್ 'false' ಆಗಿದೆ; ಇಲ್ಲಿ ನಾವು 'true' ಎಂದು ಹೊಂದಿಸಿದ್ದೇವೆ ಪ್ರಾಬಬಿಲಿಟಿ ಅಂದಾಜುಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು. ಡೇಟಾವನ್ನು ಶಫಲ್ ಮಾಡಲು random state ಅನ್ನು '0' ಎಂದು ಹೊಂದಿಸಿದ್ದೇವೆ. ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ಕ್ಲಸ್ಟರಿಂಗ್ (SVC) ಯು Support-Vector ಮೆಷೀನುಗಳ ಕುಟುಂಬದ ಒಂದು ಭಾಗವಾಗಿದೆ (ನಿಮಗೆ ಈ ಕೆಳಗೆ ಇದರ ಬಗ್ಗೆ ಹೆಚ್ಚು ತಿಳಿಯಬಹುದು). ಈ ವಿಧಾನದಲ್ಲಿ, ಟ್ಯಾಗ್‌ಗಳನ್ನು ಕ್ಲಸ್ಟರ್ ಮಾಡಲು ನೀವು 'ಕರ್ಣಲ್' ಅನ್ನು ಆಯ್ಕೆಮಾಡಬಹುದು. ‘C’ ಪರಿಮಾಣ 'ರೆಗ್ಯುಲರೈಸೇಶನ್' ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಇದು ಪರಿಮಾಣಗಳ ಪ್ರಭಾವವನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ. ಕರ್ಣಲ್ ಒಂದೇ ಒಂದು [ಹಣ] (https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); ಇಲ್ಲಿ ನಾವು ಲಿನಿಯರ್ ಎಂದು ಸೆಟ್ಟಾಗಿ ನೇರ SVC ನ ಉಪಯೋಗವನ್ನು ಖಚಿತಪಡಿಸುತ್ತೇವೆ. ಪ್ರಾಬಬಿಲಿಟಿ ಡೀಫಾಲ್ಟ್ 'false'; ಇಲ್ಲಿ ನಾವು ಪ್ರಾಬಬಿಲಿಟಿ ಅಂದಾಜುಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು 'true' ಗೆ ಸೆಟ್ ಮಾಡಿದ್ದೇವೆ. ನಾವು ಡೇಟಾವನ್ನು ಮಿಶ್ರಣಗೊಳಿಸಲು ಮತ್ತು ಪ್ರಮಾಣವನ್ನು ಪಡೆಯಲು random state ಅನ್ನು '0' ಗೆ ಸೆಟ್ ಮಾಡಿದ್ದೇವೆ.
### ಅಭ್ಯಾಸ - ಲೀನಿಯರ್ SVC ಅನ್ವಯಿಸಿ ### ವ್ಯಾಯಾಮ - ಲಿನಿಯರ್ SVC ಅನ್ನು ಅನ್ವಯಿಸಿ
ವರ್ಗೀಕರಣಕಾರರ ಅರೆ ಅನ್ನು ರಚಿಸುವುದರಿಂದ ಪ್ರಾರಂಭಿಸಿ. ನಾವು ಪರೀಕ್ಷಿಸುವಂತೆ ಈ ಅರೆಗೆ ಕ್ರಮೇಣ ಸೇರಿಸುತ್ತೇವೆ. ವರ್ಗೀಕರಣಕಾರರ ಸಾಲನ್ನು ರಚಿಸಿ ಪ್ರಾರಂಭಿಸಿ. ಪರೀಕ್ಷಿಸುವಂತೆ ನೀವು ಈ ಸಾಲಿನಲ್ಲಿ ಹಂತ ಹಂತವಾಗಿ ಸೇರಿಸುತ್ತೀರಿ.
1. ಲೀನಿಯರ್ SVC ನಿಂದ ಪ್ರಾರಂಭಿಸಿ: 1. ಲಿನಿಯರ್ SVC ನಿಂದ ಪ್ರಾರಂಭಿಸಿ:
```python ```python
C = 10 C = 10
# ವಿಭಿನ್ನ ವರ್ಗೀಕರಿಸುವವರನ್ನು ರಚಿಸಿ. # ವಿಭಿನ್ನ ವರ್ಗೀಕರಣೆಗಳನ್ನು ರಚಿಸಿ.
classifiers = { classifiers = {
'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0) 'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
} }
``` ```
2. ಲೀನಿಯರ್ SVC ಬಳಸಿ ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ತರಬೇತಿಮಾಡಿ ಮತ್ತು ವರದಿಯನ್ನು ಮುದ್ರಿಸಿ: 2. ಲಿನಿಯರ್ SVC ಬಳಸಿ ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡಿ ಮತ್ತು ವರದಿ ಮುದ್ರಿಸಿ:
```python ```python
n_classifiers = len(classifiers) n_classifiers = len(classifiers)
@ -88,7 +88,7 @@
print(classification_report(y_test,y_pred)) print(classification_report(y_test,y_pred))
``` ```
ಫಲಿತಾಂಶ ಚೆನ್ನಾಗಿದೆ: ಫಲಿತಾಂಶ ತುಂಬ ಚೆನ್ನಾಗಿದೆ:
```output ```output
Accuracy (train) for Linear SVC: 78.6% Accuracy (train) for Linear SVC: 78.6%
@ -105,15 +105,15 @@
weighted avg 0.79 0.79 0.79 1199 weighted avg 0.79 0.79 0.79 1199
``` ```
## K-ನೆರೆಹೊರೆಯವರ ವರ್ಗೀಕರಣಕಾರ ## K-ನೈಬರ್ಸ್ ವರ್ಗೀಕರಣಕಾರ
K-ನೆರೆಹೊರೆಯವರು "ನೆರೆಹೊರೆಯವರು" ಕುಟುಂಬದ ML ವಿಧಾನಗಳ ಭಾಗವಾಗಿದ್ದು, ಮೇಲ್ವಿಚಾರಣೆಯುಳ್ಳ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆಯಿಲ್ಲದ ಕಲಿಕೆಗೆ ಬಳಸಬಹುದು. ಈ ವಿಧಾನದಲ್ಲಿ, ಪೂರ್ವನಿರ್ಧರಿತ ಸಂಖ್ಯೆಯ ಬಿಂದುಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಡೇಟಾ ಈ ಬಿಂದುಗಳ ಸುತ್ತ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಇದರಿಂದ ಸಾಮಾನ್ಯ ಲೇಬಲ್‌ಗಳನ್ನು ಊಹಿಸಬಹುದು. K-ನೈಬರ್ಸ್ "ನೈಬರ್ಸ್" ಕುಟುಂಬದ ML ವಿಧಾನಗಳ ಭಾಗವಾಗಿದ್ದು, ಇದು ಮೇಲ್ವಿಚಾರಿತ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆಯಿಲ್ಲದ ಕಲಿಕೆಗೆ ಬಳಸಬಹುದು. ಈ ವಿಧಾನದಲ್ಲಿ, ನಿಗದಿತ ಸಂಖ್ಯೆಯ ಬಿಂದುಗಳನ್ನು ನಿರ್ಮಿಸಿ, ಆ ಬಿಂದುಗಳ ಸುತ್ತಲೂ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಹೀಗಾಗಿ ಸಾಮಾನ್ಯೀಕೃತ ಲೇಬಲ್‌ಗಳನ್ನು ಊಹಿಸಬಹುದು.
### ಅಭ್ಯಾಸ - K-ನೆರೆಹೊರೆಯವರ ವರ್ಗೀಕರಣಕಾರ ಅನ್ವಯಿಸಿ ### ವ್ಯಾಯಾಮ - K-ನೈಬರ್ಸ್ ವರ್ಗೀಕರಣಕಾರವನ್ನು ಅನ್ವಯಿಸಿ
ಹಿಂದಿನ ವರ್ಗೀಕರಣಕಾರ ಚೆನ್ನಾಗಿತ್ತು ಮತ್ತು ಡೇಟಾದೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕೆಲಸ ಮಾಡಿತು, ಆದರೆ ನಾವು ಉತ್ತಮ ನಿಖರತೆಯನ್ನು ಪಡೆಯಬಹುದು. K-ನೆರೆಹೊರೆಯವರ ವರ್ಗೀಕರಣಕಾರವನ್ನು ಪ್ರಯತ್ನಿಸಿ. ಹಿಂದಿನ ವರ್ಗೀಕರಣಕಾರ ಉತ್ತಮವಾಗಿತ್ತು ಮತ್ತು ಡೇಟಾಡಿಗೆ ಚೆನ್ನಾಗಿ ಕೆಲಸ ಮಾಡಿತು, ಆದರೆ ಉತ್ತಮ ನಿಖರತೆಯನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಿದೆ. K-ನೈಬರ್ಸ್ ವರ್ಗೀಕರಣಕಾರವನ್ನು ಪ್ರಯತ್ನಿಸಿ.
1. ನಿಮ್ಮ ವರ್ಗೀಕರಣಕಾರ ಅರೆಗೆ ಒಂದು ಸಾಲು ಸೇರಿಸಿ (ಲೀನಿಯರ್ SVC ಐಟಂನ ನಂತರ ಕಾಮಾ ಸೇರಿಸಿ): 1. ನಿಮ್ಮ ವರ್ಗೀಕರಣಕಾರರ ಸಾಲಿಗೆ ಒಂದು ಲೈನ್ ಸೇರಿಸಿ (ಲಿನಿಯರ್ SVC ಐಟಂನ ನಂತರ ಕಮಾ ಸೇರಿಸಿ):
```python ```python
'KNN classifier': KNeighborsClassifier(C), 'KNN classifier': KNeighborsClassifier(C),
@ -136,23 +136,23 @@ K-ನೆರೆಹೊರೆಯವರು "ನೆರೆಹೊರೆಯವರು"
weighted avg 0.76 0.74 0.74 1199 weighted avg 0.76 0.74 0.74 1199
``` ```
✅ [K-ನೆರೆಹೊರೆಯವರು](https://scikit-learn.org/stable/modules/neighbors.html#neighbors) ಬಗ್ಗೆ ತಿಳಿಯಿರಿ ✅ [K-ನೈಬರ್ಸ್](https://scikit-learn.org/stable/modules/neighbors.html#neighbors) ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳಿ
## ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರ ## ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರ
ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರಗಳು [ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ಯಂತ್ರ](https://wikipedia.org/wiki/Support-vector_machine) ಕುಟುಂಬದ ಭಾಗವಾಗಿದ್ದು, ವರ್ಗೀಕರಣ ಮತ್ತು ರಿಗ್ರೆಷನ್ ಕಾರ್ಯಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತವೆ. SVM ಗಳು "ತರಬೇತಿ ಉದಾಹರಣೆಗಳನ್ನು ಸ್ಥಳದಲ್ಲಿ ಬಿಂದುಗಳಾಗಿ ನಕ್ಷೆ ಮಾಡುತ್ತವೆ" ಎರಡು ವರ್ಗಗಳ ನಡುವಿನ ದೂರವನ್ನು ಗರಿಷ್ಠಗೊಳಿಸಲು. ನಂತರದ ಡೇಟಾವನ್ನು ಈ ಸ್ಥಳದಲ್ಲಿ ನಕ್ಷೆ ಮಾಡಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಅವುಗಳ ವರ್ಗವನ್ನು ಊಹಿಸಬಹುದು. ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರಗಳು [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine) ಕುಟುಂಬದ ಭಾಗವಾಗಿದ್ದು ವರ್ಗೀಕರಣ ಮತ್ತು ರೆಗ್ರೆಷನ್ ಕಾರ್ಯಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತವೆ. SVM ಗಳು "ತರಬೇತಿ ಮಾದರಿಗಳನ್ನು ಸ್ಥಳದಲ್ಲಿ ಬಿಂದುಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡಿ" ಎರಡು ವರ್ಗಗಳ ನಡುವಿನ ದೂರವನ್ನು ಗರಿಷ್ಠಗೊಳಿಸುತ್ತವೆ. ನಂತರದ ಡೇಟಾವನ್ನು ಈ ಸ್ಥಳಕ್ಕೆ ಮ್ಯಾಪ್ ಮಾಡಿ ಅವುಗಳ ವರ್ಗವನ್ನು ಊಹಿಸಲಾಗುತ್ತದೆ.
### ಅಭ್ಯಾಸ - ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರ ಅನ್ವಯಿಸಿ ### ವ್ಯಾಯಾಮ - ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರವನ್ನು ಅನ್ವಯಿಸಿ
ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರದೊಂದಿಗೆ ಸ್ವಲ್ಪ ಉತ್ತಮ ನಿಖರತೆಯನ್ನು ಪ್ರಯತ್ನಿಸೋಣ. ಸದೃಢ ನಿಖರತೆಗೆ ಪ್ರಯತ್ನಿಸಲು ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರ ಬಳಸಿ ನೋಡೋಣ.
1. K-ನೆರೆಹೊರೆಯವರ ಐಟಂನ ನಂತರ ಕಾಮಾ ಸೇರಿಸಿ, ನಂತರ ಈ ಸಾಲನ್ನು ಸೇರಿಸಿ: 1. K-ನೈಬರ್ಸ್ ಐಟಂನ ನಂತರ ಒಂದು ಕಮಾ ಸೇರಿಸಿ, ನಂತರ ಈ ಸಾಲನ್ನು ಸೇರಿಸಿ:
```python ```python
'SVC': SVC(), 'SVC': SVC(),
``` ```
ಫಲಿತಾಂಶ ಬಹಳ ಚೆನ್ನಾಗಿದೆ! ಫಲಿತಾಂಶ ತುಂಬಾ ಚೆನ್ನಾಗಿದೆ!
```output ```output
Accuracy (train) for SVC: 83.2% Accuracy (train) for SVC: 83.2%
@ -169,18 +169,18 @@ K-ನೆರೆಹೊರೆಯವರು "ನೆರೆಹೊರೆಯವರು"
weighted avg 0.84 0.83 0.83 1199 weighted avg 0.84 0.83 0.83 1199
``` ```
✅ [ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್‌ಗಳ](https://scikit-learn.org/stable/modules/svm.html#svm) ಬಗ್ಗೆ ತಿಳಿಯಿರಿ ✅ [ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್‌ಗಳು](https://scikit-learn.org/stable/modules/svm.html#svm) ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳಿ
## ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರಗಳು ## ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರರು
ಹಿಂದಿನ ಪರೀಕ್ಷೆ ಚೆನ್ನಾಗಿದ್ದರೂ, ನಾವು ದಾರಿಯ ಕೊನೆಯಲ್ಲಿ ಇರುವ ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರಗಳನ್ನು ಪ್ರಯತ್ನಿಸೋಣ, ವಿಶೇಷವಾಗಿ ರ್ಯಾಂಡಮ್ ಫಾರೆಸ್ಟ್ ಮತ್ತು ಅಡಾಬೂಸ್ಟ್: ಹಿಂದಿನ ಪರೀಕ್ಷೆ ತುಂಬಾ ಉತ್ತಮವಾಗಿದ್ದರೂ, ನಾವು ದಾರಿಯನ್ನು ಕೊನೆವರೆಗೆ ಅನುಸರಿಸೋಣ. ನಾವು ಕೆಲವು 'ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರರನ್ನು' ಪ್ರಯತ್ನಿಸೋಣ, ವಿಶೇಷವಾಗಿ Random Forest ಮತ್ತು AdaBoost:
```python ```python
'RFST': RandomForestClassifier(n_estimators=100), 'RFST': RandomForestClassifier(n_estimators=100),
'ADA': AdaBoostClassifier(n_estimators=100) 'ADA': AdaBoostClassifier(n_estimators=100)
``` ```
ಫಲಿತಾಂಶ ಬಹಳ ಚೆನ್ನಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ರ್ಯಾಂಡಮ್ ಫಾರೆಸ್ಟ್‌ಗೆ: ಫಲಿತಾಂಶ ತುಂಬಾ ಚೆನ್ನಾಗಿದೆ, ವಿಶೇಷವಾಗಿ Random Forest ಗೆ:
```output ```output
Accuracy (train) for RFST: 84.5% Accuracy (train) for RFST: 84.5%
@ -210,33 +210,33 @@ Accuracy (train) for ADA: 72.4%
weighted avg 0.73 0.72 0.72 1199 weighted avg 0.73 0.72 0.72 1199
``` ```
✅ [ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರಗಳು](https://scikit-learn.org/stable/modules/ensemble.html) ಬಗ್ಗೆ ತಿಳಿಯಿರಿ ✅ [ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರರ](https://scikit-learn.org/stable/modules/ensemble.html) ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳಿ
ಈ ಯಂತ್ರ ಕಲಿಕೆಯ ವಿಧಾನವು "ಕೆಲವು ಮೂಲ ಅಂದಾಜುಕಾರರ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ" ಮಾದರಿಯ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸಲು. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ರ್ಯಾಂಡಮ್ ಟ್ರೀಸ್ ಮತ್ತು ಅಡಾಬೂಸ್ಟ್ ಬಳಸಿದ್ದೇವೆ. ಈ ಮೆಷಿನ್ ಲರ್ನಿಂಗ್ ವಿಧಾನವು "ಕೆಲವು ಮೂಲ ಅಂದಾಜುಕರರ ಭವಿಷ್ಯಾಣಗಳನ್ನು ಏಕರೂಪಗೊಳಿಸುತ್ತದೆ" ಮತ್ತು ಮಾದರಿಯ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು Random Trees ಮತ್ತು AdaBoost ಅನ್ನು ಬಳಸಿದ್ದೇವೆ.
- [ರ್ಯಾಂಡಮ್ ಫಾರೆಸ್ಟ್](https://scikit-learn.org/stable/modules/ensemble.html#forest), ಸರಾಸರಿ ವಿಧಾನ, 'ನಿರ್ಣಯ ಮರಗಳ' ಒಂದು 'ಕಾಡನ್ನು' ರಚಿಸುತ್ತದೆ, ಇದು ಅತಿಯಾದ ಹೊಂದಾಣಿಕೆಯನ್ನು ತಪ್ಪಿಸಲು ಯಾದೃಚ್ಛಿಕತೆಯನ್ನು ಒಳಗೊಂಡಿದೆ. n_estimators ಪರಿಮಾಣವನ್ನು ಮರಗಳ ಸಂಖ್ಯೆಗೆ ಹೊಂದಿಸಲಾಗಿದೆ. - [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), ಸರಾಸರಿ ಮಾಡುವ ವಿಧಾನ, ಯಾದೃಚ್ಛಿಕತೆಯಿಂದ ತುಂಬಿದ 'ನಿರ್ಣಯ ಮರಗಳ' 'ಕಾಡನ್ನು' ನಿರ್ಮಿಸಿ ಓವರ್‌ಫಿಟಿಂಗ್‌ನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. n_estimators ಪರಿಮಾಣವು ಮರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.
- [ಅಡಾಬೂಸ್ಟ್](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ಒಂದು ವರ್ಗೀಕರಣಕಾರವನ್ನು ಡೇಟಾಸೆಟ್‌ಗೆ ಹೊಂದಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಆ ವರ್ಗೀಕರಣಕಾರದ ನಕಲುಗಳನ್ನು ಅದೇ ಡೇಟಾಸೆಟ್‌ಗೆ ಹೊಂದಿಸುತ್ತದೆ. ಇದು ತಪ್ಪಾಗಿ ವರ್ಗೀಕರಿಸಿದ ಐಟಂಗಳ ತೂಕಗಳ ಮೇಲೆ ಗಮನಹರಿಸಿ, ಮುಂದಿನ ವರ್ಗೀಕರಣಕಾರದ ಹೊಂದಾಣಿಕೆಯನ್ನು ಸರಿಪಡಿಸುತ್ತದೆ. - [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ಒಂದು ವರ್ಗೀಕರಣಕಾರಿಯನ್ನು ಡೇಟಾಸೆಟ್‌ಗೆ ಹೊಂದಿಸಿ ನಂತರ ಅದೇ ಡೇಟಾಸೆಟ್‌ಗೆ ಆ ವರ್ಗೀಕರಣಕಾರಿಯ ನಕಲುಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ. ಇದು ತಪ್ಪಾಗಿ ವರ್ಗೀಕರಿಸಿದ ಐಟಂಗಳ ತೂಕಗಳಿಗೆ ಎಚ್ಚರಿಕೆ ನೀಡುತ್ತದೆ ಮತ್ತು ಮುಂದಿನ ವರ್ಗೀಕರಣಕಾರಿಗೆ ಸರಿಯಾದ ಹೊಂದಾಣಿಕೆಯನ್ನು ಮಾಡುತ್ತದೆ.
--- ---
## 🚀ಸವಾಲು ## 🚀ಸವಾಲು
ಈ ತಂತ್ರಗಳ ಪ್ರತಿಯೊಂದಕ್ಕೂ ನೀವು ತಿದ್ದುಪಡಿ ಮಾಡಬಹುದಾದ ಅನೇಕ ಪರಿಮಾಣಗಳಿವೆ. ಪ್ರತಿಯೊಂದರ ಡೀಫಾಲ್ಟ್ ಪರಿಮಾಣಗಳನ್ನು ಸಂಶೋಧಿಸಿ ಮತ್ತು ಈ ಪರಿಮಾಣಗಳನ್ನು ತಿದ್ದುಪಡಿ ಮಾಡುವುದು ಮಾದರಿಯ ಗುಣಮಟ್ಟಕ್ಕೆ ಏನು ಅರ್ಥವಾಗುತ್ತದೆ ಎಂದು ಯೋಚಿಸಿ. ಈ ಎಲ್ಲ ತಂತ್ರಜ್ಞಾನಗಳಿಗೂ ನೀವು ಅಳವಡಿಸಬಹುದಾದ ಅನೇಕ ಪರಿಮಾಣಗಳಿವೆ. ಪ್ರತಿಯೊಂದರ ಡೀಫಾಲ್ಟ್ ಪರಿಮಾಣಗಳನ್ನು ಸಂಶೋಧಿಸಿ ಮತ್ತು ಈ ಪರಿವರ್ತನೆಗಳು ಮಾದರಿಯ ಗುಣಮಟ್ಟಕ್ಕೆ ಏನು ಅರ್ಥ ಮಾಡಿಕೊಳ್ಳುತ್ತದೆ ಎಂದು ಯೋಚಿಸಿ.
## [ಪೋಸ್ಟ್-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/) ## [ಪೋಸ್ಟ್-ಪಾಠ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
## ವಿಮರ್ಶೆ & ಸ್ವಯಂ ಅಧ್ಯಯನ ## ವಿಮರ್ಶೆ ಮತ್ತು ಸ್ವಯಂ ಅಧ್ಯಯನ
ಈ ಪಾಠಗಳಲ್ಲಿ ಬಹಳಷ್ಟು ತಾಂತ್ರಿಕ ಪದಗಳಿವೆ, ಆದ್ದರಿಂದ [ಈ ಪಟ್ಟಿ](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) ಯನ್ನು ಪರಿಶೀಲಿಸಲು ಒಂದು ನಿಮಿಷ ತೆಗೆದುಕೊಳ್ಳಿ! ಈ ಪಾಠಗಳಲ್ಲಿ ಬಹಳಷ್ಟು ಜಾರ್ಗನ್ ಇದೆ, ಹೀಗಾಗಿ ಪ್ರಯುತ್ತವೂ [ಈ ಪಟ್ಟಿಯನ್ನು](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) ಪರಿಶೀಲಿಸಿ!
## ನಿಯೋಜನೆ ## ಕಾರ್ಯನಿರ್ವಹಣೆ
[ಪರಿಮಾಣ ಆಟ](assignment.md) [ಪರಿಮಾಣ ಆಟ](assignment.md)
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**: **ವಿಆರೋಪಣೆ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪುಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ. ಈ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಗೆ ಪ್ರಯತ್ನಿಸಿದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷ ಅಥವಾ ಅಸತ್ಯತೆಗಳಿರಬಹುದು ಎಂದು ಜ್ಞಾಪಕವಿಡಿ. ಮೂಲ ಭಾಷೆಯ ಮೂಲ ಡಾಕ್ಯುಮೆಂಟ್ ನ್ನು ಅಧಿಕಾರಿಯಾದ ಮೂಲ ಎಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರಿತಿಕೆಗಳು ಅಥವಾ ತಪ್ಪು ಅನುವಾದಗಳಿಗೆ ನಾವು ಜವಾಬ್ದಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

12
translations/kn/4-Classification/3-Classifiers-2/notebook.ipynb
Unescape View File

@ -116,15 +116,15 @@
} }
], ],
"source": [ "source": [
"cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n", "cuisines_features_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n",
"cuisines_feature_df.head()" "cuisines_features_df.head()"
] ]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**ಅಸ್ವೀಕರಣ**: \nಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n" "---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**ವಿಚಾರಣೆ**: \nಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯ ಮೇಲೆ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳು ದೋಷಗಳು ಅಥವಾ ಅಸಮತೋಲನಗಳನ್ನು ಹೊಂದಿರಬಹುದೆಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ದಸ್ತಾವೇಜಿನ ಸ್ವಭಾವಭಾಷೆಯ ಪ್ರತಿಯನ್ನು ಪ್ರಾಮಾಣಿಕ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಲಾಗಬೇಕಾಗಿದೆ. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದವನ್ನು ಬಳಸಿ ಉಂಟಾಗುವ ಯಾವುದೇ ಭ್ರಮಗಳು ಅಥವಾ ತಪ್ಪು ಅರ್ಥಾಂಶಗಳಿಗಾಗಿ ನಾವು ಹೊಣೆಗಾರರಾಗಲಾರೆವು.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
] ]
} }
], ],
@ -152,12 +152,6 @@
"interpreter": { "interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d" "hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
} }
},
"coopTranslator": {
"original_hash": "15a83277036572e0773229b5f21c1e12",
"translation_date": "2025-12-19T17:02:55+00:00",
"source_file": "4-Classification/3-Classifiers-2/notebook.ipynb",
"language_code": "kn"
} }
}, },
"nbformat": 4, "nbformat": 4,

18
translations/kn/4-Classification/3-Classifiers-2/solution/notebook.ipynb
Unescape View File

@ -2,7 +2,7 @@
"cells": [ "cells": [
{ {
"source": [ "source": [
"# ಇನ್ನಷ್ಟು ವರ್ಗೀಕರಣ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಿ\n" "# ಇನ್ನಷ್ಟು ವರ್ಗೀಕರಣ ಮಾದರಿಗಳನ್ನು ರಚಿಸಿ\n"
], ],
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {} "metadata": {}
@ -116,15 +116,15 @@
} }
], ],
"source": [ "source": [
"cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n", "cuisines_features_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n",
"cuisines_feature_df.head()" "cuisines_features_df.head()"
] ]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"# ವಿಭಿನ್ನ ವರ್ಗೀಕರಿಸುವವರನ್ನು ಪ್ರಯತ್ನಿಸಿ\n" "# ವಿಭಿನ್ನ ವರ್ಗೀಕರಣಕಾರಿಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ\n"
] ]
}, },
{ {
@ -148,7 +148,7 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)" "X_train, X_test, y_train, y_test = train_test_split(cuisines_features_df, cuisines_label_df, test_size=0.3)"
] ]
}, },
{ {
@ -263,7 +263,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**ಅಸ್ವೀಕರಣ**: \nಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n" "---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**ತಪ್ಪು ನಿರಾಕರಣೆ**: \nಈ ದಸ್ತಾವೇಜನ್ನು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ದತೆಯ ಮೇಲೆ ಪ್ರಯತ್ನಿಸುವರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸ್ಪಷ್ಟತೆಗಳು ಇರುವ ಸಾಧ್ಯತೆ ಇದೆ ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿ ಇರುವ ಮೂಲ ದಸ್ತಾವೇಜೇ ಅಧಿಕೃತ ಮೂಲ ಎಂದು ಪರಿಗಣಿಸಿ. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ಅವಘಡಗಳು ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಲ್ಲ.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
] ]
} }
], ],
@ -291,12 +291,6 @@
"interpreter": { "interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d" "hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
} }
},
"coopTranslator": {
"original_hash": "7ea2b714669c823a596d986ba2d5739f",
"translation_date": "2025-12-19T17:09:17+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/notebook.ipynb",
"language_code": "kn"
} }
}, },
"nbformat": 4, "nbformat": 4,

269
translations/kn/README.md
Unescape View File

@ -1,182 +1,237 @@
[![GitHub license](https://img.shields.io/github/license/microsoft/ML-For-Beginners.svg)](https://github.com/microsoft/ML-For-Beginners/blob/master/LICENSE)
[![GitHub contributors](https://img.shields.io/github/contributors/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/graphs/contributors/)
[![GitHub issues](https://img.shields.io/github/issues/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/issues/)
[![GitHub pull-requests](https://img.shields.io/github/issues-pr/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/pulls/)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
[![GitHub watchers](https://img.shields.io/github/watchers/microsoft/ML-For-Beginners.svg?style=social&label=Watch)](https://GitHub.com/microsoft/ML-For-Beginners/watchers/)
[![GitHub forks](https://img.shields.io/github/forks/microsoft/ML-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/ML-For-Beginners/network/)
[![GitHub stars](https://img.shields.io/github/stars/microsoft/ML-For-Beginners.svg?style=social&label=Star)](https://GitHub.com/microsoft/ML-For-Beginners/stargazers/)
### 🌐 ಬಹುಭಾಷಾ ಬೆಂಬಲ ### 🌐 ಬಹುಭಾಷಾ ಬೆಂಬಲ
#### GitHub ಕ್ರಿಯೆಯಿಂದ ಬೆಂಬಲಿಸಲಾಗಿದೆ (ಸ್ವಯಂಚಾಲಿತ & ಸದಾ ನವೀಕರಿಸಲಾಗಿದೆ) #### GitHub ಕ್ರಿಯೆ ಮೂಲಕ ನೆರವು (ಸ್ವಯಂಚಾಲಿತ ಮತ್ತು ಯಾವಾಗಲೂ ನವೀಕರಿಸಲಾಗುತ್ತದೆ)
> **ಸ್ಥಳೀಯವಾಗಿ ಕ್ಲೋನ್ ಮಾಡುವುದಾಗಿ ಇಚ್ಛಿಸುತ್ತೀರಾ?** <!-- CO-OP TRANSLATOR LANGUAGES TABLE START -->
[Arabic](../ar/README.md) | [Bengali](../bn/README.md) | [Bulgarian](../bg/README.md) | [Burmese (Myanmar)](../my/README.md) | [Chinese (Simplified)](../zh-CN/README.md) | [Chinese (Traditional, Hong Kong)](../zh-HK/README.md) | [Chinese (Traditional, Macau)](../zh-MO/README.md) | [Chinese (Traditional, Taiwan)](../zh-TW/README.md) | [Croatian](../hr/README.md) | [Czech](../cs/README.md) | [Danish](../da/README.md) | [Dutch](../nl/README.md) | [Estonian](../et/README.md) | [Finnish](../fi/README.md) | [French](../fr/README.md) | [German](../de/README.md) | [Greek](../el/README.md) | [Hebrew](../he/README.md) | [Hindi](../hi/README.md) | [Hungarian](../hu/README.md) | [Indonesian](../id/README.md) | [Italian](../it/README.md) | [Japanese](../ja/README.md) | [Kannada](./README.md) | [Korean](../ko/README.md) | [Lithuanian](../lt/README.md) | [Malay](../ms/README.md) | [Malayalam](../ml/README.md) | [Marathi](../mr/README.md) | [Nepali](../ne/README.md) | [Nigerian Pidgin](../pcm/README.md) | [Norwegian](../no/README.md) | [Persian (Farsi)](../fa/README.md) | [Polish](../pl/README.md) | [Portuguese (Brazil)](../pt-BR/README.md) | [Portuguese (Portugal)](../pt-PT/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Romanian](../ro/README.md) | [Russian](../ru/README.md) | [Serbian (Cyrillic)](../sr/README.md) | [Slovak](../sk/README.md) | [Slovenian](../sl/README.md) | [Spanish](../es/README.md) | [Swahili](../sw/README.md) | [Swedish](../sv/README.md) | [Tagalog (Filipino)](../tl/README.md) | [Tamil](../ta/README.md) | [Telugu](../te/README.md) | [Thai](../th/README.md) | [Turkish](../tr/README.md) | [Ukrainian](../uk/README.md) | [Urdu](../ur/README.md) | [Vietnamese](../vi/README.md)
> ಈ ಸಂಗ್ರಹವು 50+ ಭಾಷಾ ಅನುವಾದಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದರಿಂದ ಡೌನ್ಲೋಡ್ ಗಾತ್ರವು ಬಹುಮಾನವಾಗುತ್ತದೆ. ಅನುವಾದಗಳಿಲ್ಲದೆ ಕ್ಲೋನ್ ಮಾಡಲು, ಸ್ಪಾರ್ಸ್ ಚೇಕ್ಔಟ್ ಬಳಸಿ: > **ಸ್ಥಳೀಯವಾಗಿ ಕ್ಲೋನ್ ಮಾಡಲು ಇಚ್ಛಿಸುವಿರಾ?**
>
> ಈ ಸಂಗ್ರಹವು 50+ ಭಾಷಾ ಭಾಷಾಂತರಗಳನ್ನು ಒಳಗೊಂಡಿದ್ದು, ಇದು ಡೌನ್‌ಲೋಡ್ ಗಾತ್ರವನ್ನು ಬಹುಮಟ್ಟಿಗೆ ಹೆಚ್ಚಿಸುತ್ತದೆ. ಭಾಷಾಂತರಗಳಿಲ್ಲದೆ ಕ್ಲೋನ್ ಮಾಡಲು, ಸ್ಪಾರ್ಸ್ ಚೆಕ್‌ಔಟ್ ಬಳಸಿ:
>
> **Bash / macOS / Linux:**
> ```bash > ```bash
> git clone --filter=blob:none --sparse https://github.com/microsoft/ML-For-Beginners.git > git clone --filter=blob:none --sparse https://github.com/microsoft/ML-For-Beginners.git
> cd ML-For-Beginners > cd ML-For-Beginners
> git sparse-checkout set --no-cone '/*' '!translations' '!translated_images' > git sparse-checkout set --no-cone '/*' '!translations' '!translated_images'
> ``` > ```
> ಇದು ನಿಮಗೆ ಕೋರ್ಸ್ ಅನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲವನ್ನೂ ಹೆಚ್ಚು ವೇಗದ ಡೌನ್ಲೋಡ್ ಮೂಲಕ ಒದಗಿಸುತ್ತದೆ. >
> **CMD (Windows):**
> ```cmd
> git clone --filter=blob:none --sparse https://github.com/microsoft/ML-For-Beginners.git
> cd ML-For-Beginners
> git sparse-checkout set --no-cone "/*" "!translations" "!translated_images"
> ```
>
> ಇದರಿಂದ ನೀವು ಕೋರ್ಸನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ತ್ವರಿತ ಡೌನ್‌ಲೋಡ್ೊಂದಿಗೆ ಪಡೆಯಬಹುದು.
<!-- CO-OP TRANSLATOR LANGUAGES TABLE END -->
#### ನಮ್ಮ ಸಮುದಾಯದಲ್ಲಿ ಸೇರಿ #### ನಮ್ಮ ಸಮುದಾಯದಲ್ಲಿ ಸೇರಿ
ನಾವು ಡಿಸ್ಕೋರ್ಡ್ "ಲರ್ನ್ ವಿಥ ಎಐ" ಸರಣಿಯನ್ನು ನಡೆಸುತ್ತಿದ್ದು, ಹೆಚ್ಚಾಗಿ ತಿಳಿದುಕೊಳ್ಳಲು ಮತ್ತು ಭಾಗವಹಿಸಲು [Learn with AI Series](https://aka.ms/learnwithai/discord) ಗೆ ಬಂದಿರಿ. ಸೆಪ್ಟೆಂಬರ್ 18 ರಿಂದ 30, 2025 ರವರೆಗೆ GitHub Copilot ನ ಉಪಯೋಗ ಮೂಲಕ data science ಗೆ ಸಲಹೆಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಪಡೆಯಿರಿ. [![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG)
ನಾವು ಡಿಸ್ಕಾರ್ಡ್ ನಲ್ಲಿ AI ಸರಣಿಯನ್ನು ನಡೆಸುತ್ತಿದ್ದೇವೆ, ಹೆಚ್ಚಾಗಿ ತಿಳಿದುಕೊಳ್ಳಲು ಮತ್ತು ಸೇರ್ಪಡೆಗಾಗಿ [Learn with AI Series](https://aka.ms/learnwithai/discord) ನಲ್ಲಿ 18 - 30 ಸೆಪ್ಟೆಂಬರ್, 2025 ರಂದು ಸೇರಿ. ನೀವು GitHub Copilot ಉಪಯೋಗಿಸುವ ಉಲುಕುಗಳ ಮತ್ತು ಸಲಹೆಗಳನ್ನೂ ಪಡೆಯುವಿರಿ.
![Learn with AI series](../../translated_images/kn/3.9b58fd8d6c373c20.webp)
# ಯಾಂತ್ರಿಕ ಅಧ್ಯಯನ ಆರಂಭಿಕರಿಗಾಗಿ - ಒಂದು ಪಠ್ಯಕ್ರಮ
> 🌍 ಜಗತ್ತಿನ ಸಂಸ್ಕೃತಿಗಳನ್ನು ಅನ್ವೇಷಿಸುವ ಮೂಲಕ ಯಾಂತ್ರಿಕ ಅಧ್ಯಯನವನ್ನು ಪರ್ವತಾರೋಹಣ ಮಾಡಿ 🌍
ಮೈಕ್ರೋಸಾಫ್ಟ್‌ನ ಕ್ಲೌಡ್ ಅಭಿಕಾರಕರು 12-ವಾರ, 26-ಪಾಠಗಳ ಪಠ್ಯಕ್ರಮವನ್ನು ನೀಡಲು ಸಂತೋಷಪಡುತ್ತಾರೆ, ಇದು **ಯಾಂತ್ರಿಕ ಅಧ್ಯಯನ** ಬಗ್ಗೆ ಸಂಪೂರ್ಣವಾಗಿ. ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ ನೀವು ಕೆಲವೊಮ್ಮೆ **ಸಾಂಪ್ರದಾಯಿಕ ಯಾಂತ್ರಿಕ ಅಧ್ಯಯನ** ಎಂದು ಕರೆಯಲ್ಪಡುವ ತಂತ್ರಗಳನ್ನು ಕಲಿಯೋಿರಿ, ಮುಖ್ಯವಾಗಿ Scikit-learn लाईಬ್ರೆರಿಯನ್ನು ಬಳಸುತ್ತೀರಾ ಮತ್ತು ನಮ್ಮ [AI for Beginners' ಪಠ್ಯಕ್ರಮ](https://aka.ms/ai4beginners) ನಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ಡೀಪ್ ಲರ್ನಿಂಗ್‌ನಿಂದ ದೂರವಿರುತ್ತೀರಿ. ಈ ಪಾಠಗಳನ್ನು ನಮ್ಮ ['ಡೇಟಾ ಸೈನ್ಸ್ ಫಾರ್ ಬಿಗಿನರ್ಸ್' ಪಠ್ಯಕ್ರಮ](https://aka.ms/ds4beginners) ಜೊತೆಗೆ ಜೋಡಿಸಬಹುದು.
ನಮ್ಮೊಂದಿಗೆ ಜಗತ್ತಿನ ಸುತ್ತು ಪ್ರಯಾಣ ಮಾಡಿ, ಈ ಸಾಂಪ್ರದಾಯಿಕ ತಂತ್ರಗಳನ್ನು ಜಗತ್ತಿನ ಹಲವು ಭಾಗಗಳ ಡೇಟಾದ ಮೇಲೆ ಅನ್ವಯಿಸುವ ಸಮಯ. ಪ್ರತಿಯೊಂದು ಪಾಠದಲ್ಲಿ ಪೂರ್ವಪಾಠ ಮತ್ತು ಪರಪಾಠ ಟೆಸ್ಟ್‌ಗಳು, ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಬರೆದ ಸೂಚನೆಗಳು, ಪರಿಹಾರ,ೊಂದು ಕಾರ್ಯ ಮತ್ತು ಇನ್ನಷ್ಟು ಅಂಶಗಳಿವೆ. ನಮ್ಮ ಯೋಜನೆ ಆಧಾರಿತ ಪಠಣಶೈಲಿಯು ನಿಮ್ಮನ್ನು ಕಲಿಕೆಗೆ ಪ್ರೇರೇಪಿಸಿ, ಹೊಸ ಕೌಶಲ್ಯಗಳು ಅಳವಡಿಕೊಳ್ಳಲ್ಪಡುವ ಪರಿಣಾಮಕಾರಿ ವಿಧಾನವಾಗಿದೆ.
**✍️ ನಮಗೆ ಬರಹಗಾರರಿಗೆ ಹೃತ್ಪೂರ್ವಕ ಧನ್ಯವಾದಗಳು**: ಜೆನ್ ಲೂಪರ್, ಸ್ಟೀಫನ್ ಹೌವೆಲ್, ಫ್ರಾನ್ಸೆಸ್ಕಾ ಲಾಜ್ಜೇರಿ, ಟೊಮೊಮಿ ಇಮುರಾ, ಕ್ಯাস್ಸಿ ಬ್ರೇವಿಯು, ಡಿಮಿಟ್ರಿ ಸೋಶ್ನಿಕೊವ್, ಕ್ರಿಸ್ ನೋರಿಂಗ್, ಅನಿರ್ಬಾನ್ ಮುಖರ್ಜೀ, ಒರ್ನೆಲ್ಲಾ ಅಲ್ಟುನ್ಯಾನ್, ರೂತ್ ಯಾಕುಬು ಮತ್ತು ಎಂಬಿ ಬಾಯ್ಡ್
# ಶುರುಮಾಡೋಣ **🎨 ಚಿತ್ರಿಗರಿಗೆ ಧನ್ಯವಾದಗಳು**: ಟೊಮೊಮಿ ಇಮುರಾ, ದಸಾಣಿ ಮाडಿಪಳ್ಳಿ ಮತ್ತು ಜೆನ್ ಲೂಪರ್
**🙏 ವಿಶೇಷ ಧನ್ಯವಾದಗಳು 🙏 ಮೈಕ್ರೋಸಾಫ್ಟ್ ವಿದ್ಯಾರ್ಥಿ ರಾಯಭಾರಿ ಬರಹಗಾರರು, ವಿಮರ್ಶಕರು ಮತ್ತು ವಿಷಯದ ಕೊಡುಗೆದಾರರಿಗೆ**, ವಿಶೇಷವಾಗಿ ರಿಷಿತ್дагಲಿ, ಮುಹಮ್ಮದ್ ಸಕೀಬ್ ಖಾನ್ ಇನಾನ್, ರೋಹನ್ ರಾಜ್, ಅಲೆಕ್ಸಾಂಡು್ರು ಪೆಟ್ರೆಸ್ಕು, અભિષೇಕ್ ಜೈಸ್ವಾಲ್, ನವ್ರಿನ್ ತಬಸ್ಸುಮ್, ಯೋನ್ ಸಮೈಲಾ ಮತ್ತು ಸ್ನಿಗ್ಧಾಗ ಅಗರ್‌వಾಲ್
**🤩 Microsoft ವಿದ್ಯಾರ್ಥಿ ರಾಯಭಾರ್ ಎರಿಗೆ ವಾಂಜೌ, ಜಸ್‌ಲೀನ್ ಸೋಂಧಿ ಮತ್ತು ವಿದುವಿ ಗುಪ್ತರಿಗೆ ನಮ್ಮ R ಪಾಠಗಳಿಗಾಗಿ ಹೆಚ್ಚಿನ ಧನ್ಯವಾದಗಳು!**
# ಪ್ರಾರಂಭಿಸುವುದು
ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ: ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ:
1. **ರೆಪೊ ಫೋರ್ಕ್ ಮಾಡಿ**: ಈ ಪುಟದ ಮೇಲ್ಭಾಗದ ಬಲಭಾಗದಲ್ಲಿರುವ "Fork" ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ. 1. **ರಿಪೋಜಿಟರಿಯನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ**: ಈ ಪುಟದ ಮೇಲ್ಭಾಗದಲ್ಲಿ "Fork" ಬಟನ್ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ.
2. **ರೆಪೊ ಕ್ಲೋನ್ ಮಾಡಿ**: `git clone https://github.com/microsoft/ML-For-Beginners.git` 2. **ರಿಪೋಜಿಟರಿಯನ್ನು ಕ್ಲೋನ್ ಮಾಡಿ**: `git clone https://github.com/microsoft/ML-For-Beginners.git`
> [ಈ ಕೋರ್ಸ್‌ಗೆ ಎಲ್ಲಾ ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಮ್ಮ ಮೈಕ್ರೋಸಾಫ್ಟ್ ಲರ್ನ್ ಸಂಗ್ರಹದಲ್ಲಿ ಕಂಡುಹಿಡಿಯಿರಿ](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> [ಈ ಕೋರ್ಸ್‌ನಲ್ಲಿ ಎಲ್ಲ ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಮ್ಮ Microsoft Learn ಸಂಗ್ರಹದಲ್ಲಿ ಕಂಡುಹಿಡಿಯಿರಿ](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum) > 🔧 **ಸಹಾಯ ಬೇಕೆ?**Our [ತೊಂದರೆ ಪರಿಹಾರ ಮಾರ್ಗದರ್ಶನ](TROUBLESHOOTING.md) ಅನ್ನು ಸ್ಥಾಪನೆ, ಸೆಟಪ್ ಮತ್ತು ಪಾಠಗಳ ರನ್ನಿಂಗ್ ಸಮಸ্‌ಯೆಗಳ ಪರಿಹಾರಕ್ಕಾಗಿ ಪರಿಶೀಲಿಸಿ.
> 🔧 **ಸಹಾಯ ಬೇಕೆ?** ಸ್ಥಾಪನೆ, ಸೆಟಪ್ ಮತ್ತು ಪಾಠಗಳನ್ನು ರನ್ ಮಾಡುವ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳ ಪರಿಹಾರಗಳಿಗಾಗಿ ನಮ್ಮ [Troubleshooting Guide](TROUBLESHOOTING.md) ನೋಡಿ.
**[ವಿದ್ಯಾರ್ಥಿಗಳು](https://aka.ms/student-page)**, ಈ ಪಾಠಕ್ರಮವನ್ನು ಬಳಸಲು, ಸಂಪೂರ್ಣ ರೆಪೊ ನಿಮ್ಮ GitHub ಖಾತೆಗೆ ಫೋರ್ಕ್ ಮಾಡಿ ಮತ್ತು ವ್ಯಾಯಾಮಗಳನ್ನು ಸ್ವತಂತ್ರವಾಗಿ ಅಥವಾ ಗುಂಪಿನೊಂದಿಗೆ ಪೂರ್ಣಗೊಳಿಸಿ: **[ವಿದ್ಯಾರ್ಥಿಗಳು](https://aka.ms/student-page)**, ಈ ಪಠ್ಯಕ್ರಮವನ್ನು ಬಳಸಲು, ನಿಮ್ಮ ಸ್ವಂತ GitHub ಖಾತೆಗೆ ಸಂಪೂರ್ಣ ರಿಪೊವನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ ಮತ್ತು ಕ್ರಿಯಾಕಲಾಪಗಳನ್ನು ಸ್ವತಃ ಅಥವಾ ಗುಂಪಿನಲ್ಲಿ ಪೂರ್ಣಗೊಳಿಸಿ:
- ಪ್ರಾಧ್ಯಾಪನ ಚಿಂತನೆಯ ಪ್ರಶ್ನಾವಳಿಯಿಂದ ಆರಂಭಿಸಿ. - ಪ್ರಾರಂಭದಲ್ಲಿ ಪೂರ್ವ-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ ಆಯ್ಕೆಮಾಡಿ.
- ಉಪನ್ಯಾಸವನ್ನು ಓದಿ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ, ಪ್ರತಿ ಜ್ಞಾನ ಪರಿಶೀಲನೆಯಲ್ಲಿ ನಿಧಾನಿಸಿ ಮತ್ತು ಪರಿಗಣಿಸಿ. - ಪಾಠವನ್ನು ಓದಿ, ಪ್ರತಿ ಜ್ಞಾನ-ಪರಿಶೀಲನೆಯಲ್ಲಿ ವಿರಾಮ ತೆಗೆದು ಆಲೋಚಿಸಿ.
- ಪರಿಹಾರ ಕೋಡ್ ನಡಿಸುವುದಕ್ಕಿಂತ ಪಾಠಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡು ಪ್ರಾಜೆಕ್ಟ್‌ಗಳನ್ನು ಸೃಷ್ಟಿಸುವ ಪ್ರಯತ್ನ ಮಾಡಿ; ಆದರೆ ಆ ಕೋಡ್ ಪ್ರತಿ ಪ್ರಾಜೆಕ್ಟ್-ಆಧರಿತ ಪಾಠದಲ್ಲಿನ `/solution` ಫೋಲ್ಡರ್ ಗಳಲ್ಲಿ ಲಭ್ಯವಿದೆ. - ಪಾಠಗಳನ್ನು ಅರಿತು ಯೋಜನೆಗಳನ್ನು ಸೃಷ್ಟಿಸುವ ಪ್ರಯತ್ನ ಮಾಡಿ; ಬದಲಾಗಿ ಪರಿಹಾರ ಕೋಡ್ `/solution` ಫೋಲ್ಡರ್‌ಗಳಲ್ಲಿ ಲಭ್ಯವಿದೆ.
- ಉಪನ್ಯಾಸ ಬಳಿಕದ ಪ್ರಶ್ನಾವಳಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ. - ಪಾಠದ ನಂತರದ ಪ್ರಶ್ನೋತ್ತರ ಆಯ್ಕೆಮಾಡಿ.
- ಸವಾಲು ಪೂರ್ಣಗೊಳಿಸಿ. - ಸವಾಲು ಪೂರ್ಣಗೊಳಿಸಿ.
- ನಿಯುಕ್ತಿಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ. - ಕಾರ್ಯವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ.
- ಪಾಠ ಗುಂಪನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, [ಚರ್ಚಾ ಮಂಡಳಿ](https://github.com/microsoft/ML-For-Beginners/discussions) ಗೆ ಭೇಟಿ ನೀಡಿರಿ ಮತ್ತು ಸೂಕ್ತವಾದ PAT ರೂಬ್ರಿಕ್ ಅನ್ನು ತುಂಬಿ 'ಬುದ್ದಿಮತ್ತೆ ಹಂಚಿಕೊಳ್ಳಿ'. 'PAT' ಎಂದರೆ ಪ್ರಗತಿ ಮೌಲ್ಯಮಾಪನ ಸಾಧನ, ಇದು ನಿಮ್ಮ ಕಲಿಕೆಯನ್ನು ಮತ್ತಷ್ಟು ಗಟ್ಟಿಗೊಳಿಸಲು ನೀವು ತುಂಬುವ ರೂಬ್ರಿಕ್ ಆಗುತ್ತದೆ. ನೀವು ಇನ್ನಿತರ PAT ಗಳಿಗೂ ಪ್ರತಿಕ್ರಿಯಿಸಬಹುದು, ಇದರಿಂದ ನಾವು ಒಟ್ಟಿಗೆ ಕಲಿಯಬಹುದು. - ಪಾಠಗಳ ಗುರೂಪನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, [ಚರ್ಚಾ ಫಲಕ](https://github.com/microsoft/ML-For-Beginners/discussions) ಗೆ ಭೇಟಿ ನೀಡಿ ಮತ್ತು ಸೂಕ್ತ PAT ರೂಬ್ರಿಕ್ ಭರ್ತಿ ಮಾಡಿ 'ಮೆಚ್ಚುಗೆಯೊಂದಿಗೆ ಕಲಿದುಕೊಳ್ಳಿ.' ‘PAT’ ಎಂದರೆ ಪ್ರಗತಿ ಮೌಲ್ಯಮಾಪನ ಸಾಧನ. ನೀವು ಇನ್ನಿತರ PAT ಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಲು ಸಹ ಸಾದ್ಯ.
> ಮುಂದಿನ ಅಧ್ಯಯನಕ್ಕಾಗಿ, ಈ [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) ಮೋಡ್ಯೂಲ್‌ಗಳು ಮತ್ತು ಲರ್ನಿಂಗ್ ಪಾತ್‌ಗಳನ್ನು ಅನುಸರಿಸುವುದು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. > ಮುಂದಿನ ಅಧ್ಯಯನಕ್ಕಾಗಿ, ಈ [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) ಮೋಡ್ಯೂಲುಗಳು ಮತ್ತು ಕಲಿಕೆ ಮಾರ್ಗಗಳನ್ನು ಅನುಸರಿಸುವುದು ಶಿಫಾರಸುಮಾಡಲ್ಪಟ್ಟಿದೆ.
**ಶಿಕ್ಷಕರು**, ಈ ಪಾಠಕ್ರಮ ಉಪಯೋಗಿಸುವ ಬಗ್ಗೆ ಕೆಲವು [ಶಿಫಾರಸುಗಳನ್ನು](for-teachers.md) ನಾವು ಸೇರಿಸಿದ್ದೇವೆ. **ಶಿಕ್ಷಕರಿಗೆ**, ನಾವು ಈ ಪಠ್ಯಕ್ರಮವನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬ ಕೆಲವು ಶಿಫಾರಸುಗಳನ್ನು [ಸೇರಿಸಿದ್ದೇವೆ](for-teachers.md).
--- ---
## ವೀಡಿಯೋ ವಾಕ್ತ್ರೂಸ್ ## ವಿಡಿಯೋ ನಡೆಯಿ
ಕೆಲವು ಪಾಠಗಳು ಚಿಕ್ಕವೀಡಿಯೋ ರೂಪದಲ್ಲಿಯೂ ಲಭ್ಯವಾಗಿವೆ. ಎಲ್ಲಾ ವೀಡಿಯೋಗಳನ್ನು ಪಾಠಗಳಲ್ಲಿ ಇನ್‌ಲೈನ್‌ನಲ್ಲಿ ಅಥವಾ [Microsoft Developer ಯೂಟ್ಯೂಬ್ ಚಾನೆಲ್‌ನ ML for Beginners ಪ್ಲೇಲಿಸ್ಟ್‌ನಲ್ಲಿ](https://aka.ms/ml-beginners-videos) ಚಿತ್ರ ಕ್ಲಿಕ್ ಮಾಡಿ ನೋಡಬಹುದು. ಕೆಲವು ಪಾಠಗಳು ಚಿಕ್ಕ ವೀಡಿಯೊ ರೂಪದಲ್ಲಿ ಲಭ್ಯವಿವೆ. ನೀವು ಈ ಎಲ್ಲವನ್ನೂ ಪಾಠಗಳಲ್ಲಿ ಆನ್‌ಲೈನ್ ನೋಡಬಹುದು ಅಥವಾ [Microsoft Developer YouTube ಚಾನೆಲ್‌ನ ML for Beginners ಪ್ಲೇಲಿಸ್ಟ್](https://aka.ms/ml-beginners-videos) ನಲ್ಲಿ ಈ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ.
[![ML for beginners banner](../../translated_images/kn/ml-for-beginners-video-banner.63f694a100034bc6.webp)](https://aka.ms/ml-beginners-videos)
--- ---
## ತಂಡವನ್ನು ಪರಿಚಯಿಸಿ ## ತಂಡವನ್ನು ಭೇಟಿ ಮಾಡಿ
[![ಪ್ರಮೋ ವೀಡಿಯೊ](../../images/ml.gif)](https://youtu.be/Tj1XWrDSYJU)
**ಗಿಫ್ ಇಬ್ಬರು** [ಮೋಹಿತ್ ಜೈಸಾಲ್](https://linkedin.com/in/mohitjaisal)
> 🎥 ಯೋಜನೆ ಮತ್ತು ಅದನ್ನು ರಚಿಸಿದವರ ಬಗ್ಗೆ ವೀಡಿಯೋ ನೋಡಿ! > 🎥 ಮೇಲಿನ ಚಿತ್ರವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ಯೋಜನೆ ಮತ್ತು ಅದನ್ನು ರಚಿಸಿದವರ ಬಗ್ಗೆ ವೀಡಿಯೊ ನೋಡಿ!
--- ---
## ಪಠ್ಯಶಾಸ್ತ್ರ ## ಪಠಣಶೈಲಿ
ಈ ಪಾಠಕ್ರಮವನ್ನು ನಿರ್ಮಿಸುವಾಗ ನಾವು ಎರಡು ಪಠ್ಯಶಾಸ್ತ್ರೀಯ ತತ್ವಗಳನ್ನು ಆರಿಸಿಕೊಂಡಿದ್ದೇವೆ: ಕಾರ್ಯಗಾರ ಸಹಿತ **ಪ್ರಾಜೆಕ್ಟ್-ಆಧಾರಿತ** ಮತ್ತು **ನಿತ್ಯ ಪ್ರಶ್ನನಗಳಿಗೆ** ಒತ್ತು ನೀಡುವುದು. ಜೊತೆಗೆ, ಈ ಪಾಠಕ್ರಮವು ಒಕ್ಕೂಟಕ್ಕಾಗಿ ಸಾಮಾನ್ಯ **ಥೀಮ್** ಅನ್ನು ಒಳಗೊಂಡಿದೆ. ನಾವು ಈ ಪಠ್ಯಕ್ರಮವನ್ನು ತಯಾರಿಸುವಾಗ ಎರಡು ಪಠಣಶೈಲಿ ತತ್ವಗಳನ್ನು ಆಯ್ಕೆಮಾಡಿದ್ದೇವೆ: ಕಾರ್ಯಾಧಾರಿತ ಕಾರ್ಯಕ್ರಮ (**project-based**) ಮತ್ತು ನಿಯಮಿತ ಪ್ರಶ್ನೋತ್ತರಗಳ ಒಳಗೊಂಡಿರುವುದು. கூடಲೇ, ಈ ಪಠ್ಯಕ್ರಮಕ್ಕೆ ಒಂದೇ ಇಕೈ ಹೊಂದಿರುವ **ಥೀಮ್** ಇದೆ.
ಕಾರ್ಯಕ್ರಮವು ಪ್ರಾಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಹೊಂದಿಕೊಳಿಸುವುದರಿಂದ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಇದನ್ನು ಆಕರ್ಷಕವಾಗಿಸುತ್ತದೆ ಮತ್ತು ಅರ್ಥಹೀನತೆಯು ಹೆಚ್ಚಾಗುತ್ತದೆ. ಜೊತೆಗೆ ತರಗತಿಯ ಮುಂಚಿತವಾಗಿ ಹಗಟು ಪ್ರಶ್ನೆಯಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿಯ ಹಂಬಲವನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತದೆ, ತರಗತಿಯ ನಂತರದ ಪ್ರಶ್ನೆಯಲ್ಲಿ ಮತ್ತಷ್ಟು ಜ್ಞಾನದ ನಿಕಾಷಿ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ. ಈ ಪಠ್ಯಕ್ರಮವನ್ನು ಬಿಣಿಕೆಯಕ್ಷಮ ಮತ್ತು ಮೋಜುಗಾರಿಯೊಂದಿಗೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಸಂಪೂರ್ಣ ಅಥವಾ ಭಾಗವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಪ್ರಾಜೆಕ್ಟ್ಸ್ ಸಣ್ಣದಾಗಿ ಆರಂಭಿಸಿ, 12-ವಾರಗಳ ಅವಧಿಯಲ್ಲಿಂದೆ ಜಟಿಲವಾಗುತ್ತವೆ. ಈ ಪಠ್ಯಕ್ರಮವು ಎಂಎಲ್ ನ ನೈಜ ಲೋಕ ಅನ್ವಯಗಳ ಬಗ್ಗೆ ಒಂದು ಪೋಷಕೋದ್ಧೇಶನವನ್ನು ಕೂಡ ಹೊಂದಿದ್ದು, ಹೆಚ್ಚುವರಿ ಕ್ರೆಡಿಟ್ ಗಾಗಿ ಅಥವಾ ಚರ್ಚೆಗೆ ಆಧಾರವಾಗಿ ಬಳಸಬಹುದು. ವಿಷಯವು ಯೋಜನೆಗಳಿಗೆ ಹೊಂದಾಣಿಕೆ ಆಗುವ ಮೂಲಕ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಹೆಚ್ಚು ಆಕರ್ಷಕವಾಗುತ್ತದೆ ಮತ್ತು ತತ್ವಾರ್ಹತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ತರಗತಿಯ ಮುಂಚೆಯೂ ವ್ಯಾಪಿತ ಪ್ರಶ್ನೋತ್ತರವು ವಿದ್ಯಾರ್ಥಿಯನ್ನು ಕಲಿಕೆ ನಿಟ್ಟಿನಲ್ಲಿ ಸಿದ್ಧಪಡಿಸುತ್ತದೆ, ಮತ್ತು ತರಗತಿಯ ನಂತರದ ಪ್ರಶ್ನೋತ್ತರವು ಸ್ಮರಣವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಈ ಪಠ್ಯಕ್ರಮವು ಆರಾಮದಾಯಕ, ನಿರ್ವಿಕಲ್ಪವಾಗಿ ಸಾರ್ವಜನಿಕವಾಗಿ ಅಥವಾ ಹಂತವಾಗಿ ಇಳಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಯೋಜನೆಗಳು ಸಣ್ಣದಾಗಿ ಪ್ರಾರಂಭಿಸಿ 12 ವಾರಗಳ ಕೊನೆಯಲ್ಲಿ ಜಟಿಲವಾಗುತ್ತವೆ. ಈ ಪಠ್ಯಕ್ರಮದಲ್ಲಿ ಯಾಂತ್ರಿಕ ಅಧ್ಯಯನದ ನೈಜ ಜಗತ್ತಿನ ಅನ್ವಯಿಕೆಗಳ ಮೇಲಿನ ಒಂದು ನಂತರದ ಟಿಪ್ಪಣಿಯೂ ಇದೆ, ಇದನ್ನು ಹೆಚ್ಚುವರಿ ಕ್ರೆಡಿಟ್ ಅಥವಾ ಚರ್ಚೆಗೆ ನೆಲೆಮಿಡಿಸಲು ಬಳಸಬಹುದು.
> ನಮ್ಮ [ನಡವಳಿಕೆ ನಿಯಮಾವಳಿ](CODE_OF_CONDUCT.md), [ಕೊಡುಗೆ](CONTRIBUTING.md), [ಅನುವಾದ](TRANSLATIONS.md), ಮತ್ತು [ಸಮಸ್ಯಾ ಪರಿಹಾರ](TROUBLESHOOTING.md) ಮಾರ್ಗದರ್ಶಿಗಳನ್ನು ನೋಡಿ. ನಿಮ್ಮ ಆಪಾದನೆ ಬೆಂಬಲಕ್ಕೆ ಸ್ವಾಗತ! > ನಮ್ಮ [ನಡವಳಿಕೆ ನಿಯಮಾವಳಿ](CODE_OF_CONDUCT.md), [ನಿಯೋಗ](CONTRIBUTING.md), [ಭಾಷಾಂತರ](TRANSLATIONS.md), ಮತ್ತು [ತೊಂದರೆ ಪರಿಹಾರ](TROUBLESHOOTING.md) ಮಾರ್ಗಸೂಚಿಗಳನ್ನು ನೋಡಿ. ನಿಮ್ಮ ರಚನೆಾತ್ಮಕ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನಾವು ಸ್ವಾಗತಿಸುತ್ತೇವೆ!
## ಪ್ರತಿಯೊಂದು ಪಾಠದಲ್ಲಿ ಈ ಕೆಳಗಿನವುಗಳಿವೆ ## ಪ್ರತಿ ಪಾಠದಲ್ಲಿ ಒಳಗೊಂಡಿದೆ
- ಐಚ್ಛಿಕ ಸ್ಕೆಚ್‌ನೋಟು - ಐಚ್ಛಿಕ ಸ್ಕೆಚ್ನೋಟ್
- ಐಚ್ಛಿಕ ಪರಿಪೂರಕ ವೀಡಿಯೋ - ಐಚ್ಛಿಕ ಪೂರಕ ವೀಡಿಯೊ
- ವೀಡಿಯೋ ವಾಕ್ತ್ರೂ (ಕೆಲವು ಪಾಠಗಳು ಮಾತ್ರ) - ವಿಡಿಯೋ ನಡೆಯು (ಕೆಲವು ಪಾಠಗಳಿಗೆ ಮಾತ್ರ)
- [ಪ್ರಾಥಮಿಕ ಉಪನ್ಯಾಸ ತಡೆ ಪ್ರಶ್ನೆ](https://ff-quizzes.netlify.app/en/ml/) - [ಪೂರ್ವ ಪಾಠ ತಯಾರಿಕಾ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
- ಲಿಖಿತ ಪಾಠ - ಬರೆದ ಪಾಠ
- ಪ್ರಾಜೆಕ್ಟ್-ಆಧಾರಿತ ಪಾಠಗಳಿಗೆ, ಪ್ರಾಜೆಕ್ಟ್ ಹೇಗೆ ನಿರ್ಮಿಸಬೇಕು ಎಂಬ ಹಂತ ಹಂತದ ಮಾರ್ಗದರ್ಶಿಗಳು - ಯೋಜನೆ ಆಧಾರಿತ ಪಾಠಗಳಿಗೆ, ಯೋಜನೆಯನ್ನು ನಿರ್ಮಿಸುವ ಹಂತ ಹಂತದ ಮಾರ್ಗದರ್ಶಿ
- ಜ್ಞಾನ ಪರಿಶೀಲನೆಗಳು - ಜ್ಞಾನ ಪರೀಕ್ಷೆಗಳು
- ಸವಾಲು - ಸವಾಲು
- ಪರಿಪೂರಕ ಓದು - ಪೂರಕ ಓದು
- ನಿಯಮಿತಿ - ಕಾರ್ಯ
- [ಉಪನ್ಯಾಸ ನಂತರದ ಪ್ರಶ್ನೆ](https://ff-quizzes.netlify.app/en/ml/) - [ಪೋಸ್ಟ್ ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
> **ಭಾಷೆಗಳ ಬಗ್ಗೆ ಒಂದು ಟಿಪ್ಪಣಿ**: ಈ ಪಾಠಗಳು ಪ್ರಾಮುಖ್ಯವಾಗಿ ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯಲ್ಪಟ್ಟಿವೆ, ಆದರೆ ಹಲವಾರು R ದಲ್ಲೂ ಲಭ್ಯವಿವೆ. R ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು, `/solution` ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗಿ R ಪಾಠಗಳನ್ನು ಹುಡುಕಿ. ಇವುಗಳಲ್ಲಿಗೆ ಒಂದು .rmd ವಿಸ್ತರಣೆಒದಗಿಸಲಾಗಿದೆ, ಇದು **R ಮಾರ್ಕ್‌ಡೌನ್** ಫೈಲ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಇದು `code chunks` (R ಅಥವಾ ಇತರ ಭಾಷೆಗಳ) ಮತ್ತು ಒಂದು `YAML header` (PDF ಮುಂತಾದ output ಗಳನ್ನು ಹೇಗೆ ಫಾರ್ಮಾಟ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ಸೂಚಿಸುವ) ಅನ್ನು `Markdown ಡಾಕ್ಯುಮೆಂಟ್`ರಲ್ಲಿ ಎम्बೆಡ್ ಮಾಡುವುದಾಗಿ ಸರಳವಾಗಿ ವಿವರಿಸಬಹುದು. ಹೀಗಾಗಿ, ಇದು ಡೇಟಾ ಸೈನ್ಸ್ ಕ್ಕೆ ಒಂದು ಉದಾಹರಣಾದ ಲೇಖನ ಚಟುವಟಿಕೆ ವ್ಯವಸ್ಥೆ ಆಗಿದ್ದು, ನೀವು ನಿಮ್ಮ ಕೋಡ್, ಅದರಿಂದ ಬರುವ output ಮತ್ತು ನಿಮ್ಮ ಆಲೋಚನೆಗಳನ್ನು ಮಾರ್ಕ್‌ಡೌನ್‌ನಲ್ಲಿ ಬರೆದು ಒಟ್ಟುಗೂಡಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಮತ್ತೊಮ್ಮೆ, R ಮಾರ್ಕ್‌ಡೌನ್ ಡಾಕ್ಯುಮೆಂಟ್ಗಳನ್ನು PDF, HTML, ಅಥವಾ ವರ್ಡ್ ಮುಂತಾದ_OUTPUT_ ಸ್ವರೂಪಗಳಿಗೆ ರೆಂಡರ್ ಮಾಡಬಹುದು.
> **ಭಾಷೆಗಳ ಕುರಿತು ಟಿಪ್**: ಈ ಪಾಠಗಳು ಮುಖ್ಯವಾಗಿ Python ನಲ್ಲಿ ಬರೆಯಲ್ಪಟ್ಟಿದೆ, ಆದರೆ ಹಲವರು R ಲಲ್ಲಿಯೂ ಲಭ್ಯವಿದೆ. R ಪಾಠವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು, `/solution` ಫೋಲ್ಡರ್ ಗೆ ಹೋಗಿ R ಪಾಠಗಳನ್ನು ಹುಡುಕಿ. ಅವು .rmd ವಿಸ್ತಾರವನ್ನು ಹೊಂದಿವೆ, ಇದು **R ಮಾರ್ಕ್‌ಡೌನ್** ಫೈಲ್ ಆಗಿದ್ದು, ಇದರಲ್ಲಿ `ಕೋಡ್ ತುಂಡುಗಳು` (R ಅಥವಾ ಇತರ ಭಾಷೆಗಳ) ಮತ್ತು `YAML ಶೀರ್ಷಿಕೆ` (ಪಿಡಿಎಫ್, ಇತ್ಯಾದಿ ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುತ್ತದೆ) ಒಟ್ಟಿಗೆ ಇರೋದು. ಇದರಿಂದ ನೀವು ಕೋಡ್, ಅದರ ಔಟ್‌ಪುಟ್ ಮತ್ತು ನಿಮ್ಮ ಚಿಂತನೆಗಳನ್ನು ಮಾರ್ಕ್‌ಡೌನ್‌ನಲ್ಲಿ ಬರೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಇದಲ್ಲದೆ, R ಮಾರ್ಕ್‌ಡೌನ್ ದಾಖಲೆಗಳನ್ನು ಪಿಡಿಎಫ್, HTML, ಅಥವಾ ವರ್ಡ್ ಔಟ್‌ಪುಟ್‌ಗಳಿಗೆ ರೂಪಾಂತರಿಸಬಹುದು.
> **ಕ್ವಿಜ್‌ಗಳ ಬಗ್ಗೆ ಟಿಪ್ಪಣಿ**: ಎಲ್ಲಾ ಕ್ವಿಜ್‌ಗಳು [ಕ್ವಿಜ್ ಆಪ್ ಫೋಲ್ಡರ್](../../quiz-app) ನಲ್ಲಿ ಒಳಗೊಂಡಿವೆ, ಮೂರು ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿರುವ ಒತ್ತಡಿ 52 ಕ್ವಿಜ್‌ಗಳ ಸಂಖ್ಯೆ. ಅವು ಪಾಠಗಳಲ್ಲಿ ಕೊಂಡಿಯಾಗಿವೆ ಆದರೆ ಕ್ವಿಜ್ ಆಪ್ ಸ್ಥಳೀಯವಾಗಿ ಚಾಲನೆ ಮಾಡಬಹುದು; `quiz-app` ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ಹೋಸ್ಟ್ ಮಾಡುವುದು ಅಥವಾ ಅಜೂರ್‌ಗೆ ನಿಯೋಜಿಸಲು ಸೂಚನೆವನ್ನು ಅನುಸರಿಸಿ. > **ಪ್ರಶ್ನೋತ್ತರಗಳ ಬಗ್ಗೆ ಒಂದು ಟಿಪ್ಪಣಿ**: ಎಲ್ಲಾ ಪ್ರಶ್ನೋತ್ತರಗಳು [Quiz App ಫೋಲ್ಡರ್](../../quiz-app) ನಲ್ಲಿ ಸೇರಿವೆ, ಒಟ್ಟು 52 ಪ್ರಶ್ನೋತ್ತರಗಳು, ಪ್ರತಿ ಮೂರು ಪ್ರಶ್ನೆಗಳನ್ನು ಒಳಗೊಂಡಿವೆ. ಅವು ಪಾಠಗಳಲ್ಲಿ ಲಿಂಕ್ ಆಗಿದ್ದು, Quiz App ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿ ರನ್ ಮಾಡಬಹುದು; ಸ್ಥಳೀಯವಾಗಿ ಹೋಸ್ಟ್ ಮಾಡಲು ಅಥವಾ Azure ಗೆ ಡಿಪ್ಲಾಯ್ ಮಾಡಲು `quiz-app` ಫೋಲ್ಡರ್‌ನಲ್ಲಿನ ಸೂಚನೆಗಳನ್ನು ಅನುಸರಿಸಿ.
| ಪಾಠ ಸಂಖ್ಯೆ | ವಿಷಯ | ಪಾಠ ಗುಂಪು | ಕಲಿಕೆಯ ಉದ್ದೇಶಗಳು | ಸಂಪರ್ಕಿಸಿದ ಪಾಠ | ಲೇಖಕ | | ಪಾಠ ಸಂಖ್ಯೆ | ವಿಷಯ | ಪಾಠ ಗುಂಪು | ಕಲಿಕೆ ಗುರಿಗಳು | ಲಿಂಕ್ ಪಾಠ | ಲೇಖಕ |
| :-------: | :------------------------------------------------------------: | :---------------------------------------------: | ---------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------: | :------------------------------------------------: | | :-------: | :--------------------------------------------------------------: | :--------------------------------------------: | ---------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------: |
| 01 | ಯಂತ್ರ ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ | [ಪರಿಚಯ](1-Introduction/README.md) | ಯಂತ್ರ ಅಧ್ಯಯನದ ಹಿಂದೆ ಇರುವ ಮೂಲಭೂತ ಸಂಕಲ್ಪಗಳನ್ನು ಕಲಿಯೋಣ | [ಪಾಠ](1-Introduction/1-intro-to-ML/README.md) | ಮುಹಮ್ಮದ್ | | 01 | ಯಂತ್ರ ಕಲಿಕೆಗೆ ಪರಿಚಯ | [ಪರಿಚಯ](1-Introduction/README.md) | ಯಂತ್ರ ಕಲಿಕೆಯ ಮೂಲಭೂತ ಸಂಸ್ಥಾನಗಳನ್ನು ಕಲಿಯಿರಿ | [ಪಾಠ](1-Introduction/1-intro-to-ML/README.md) | ಮೂಹಮ್ಮದ್ |
| 02 | ಯಂತ್ರ ಅಧ್ಯಯನದ ಇತಿಹಾಸ | [ಪರಿಚಯ](1-Introduction/README.md) | ಈ ಕ್ಷೇತ್ರದ ಇತಿಹಾಸವನ್ನು ತಿಳಿಯೋಣ | [ಪಾಠ](1-Introduction/2-history-of-ML/README.md) | ಜೆನ್ ಮತ್ತು ಏಮಿ | | 02 | ಯಂತ್ರ ಕಲಿಕೆಯ ಇತಿಹಾಸ | [ಪರಿಚಯ](1-Introduction/README.md) | ಈ ಕ್ಷೇತ್ರದ ಇತಿಹಾಸವನ್ನು ತಿಳಿದುಕೊಳ್ಳಿ | [ಪಾಠ](1-Introduction/2-history-of-ML/README.md) | ಜೆನ್ ಮತ್ತು ಎಮಿ |
| 03 | ನ್ಯಾಯಾಸಂಗತತೆ ಮತ್ತು ಯಂತ್ರ ಅಧ್ಯಯನ | [ಪರಿಚಯ](1-Introduction/README.md) | ನ್ಯಾಯಾಸಂಗತೆಯ ಸುತ್ತಲೂ ಮುಖ್ಯ ತತ್ವಜ್ಞಾನ ಸಮಸ್ಯೆಗಳು ಏನು ಹಾಗೂ ML ಮಾದರಿಗಳನ್ನು ರಚಿಸುವಾಗ ಮತ್ತು ಜಾರಿಗೊಳಿಸುವಾಗ ವಿದ್ಯಾರ್ಥಿಗಳು ಪರಿಗಣಿಸಬೇಕಾಗಿರುವುದು? | [ಪಾಠ](1-Introduction/3-fairness/README.md) | ತೊಮೊಮಿ | | 03 | ನ್ಯಾಯ ಮತ್ತು ಯಂತ್ರ ಕಲಿಕೆ | [ಪರಿಚಯ](1-Introduction/README.md) | ಯಂತ್ರ ಕಲಿಕೆ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ ವಾದಸರಣೀಯ ನ್ಯಾಯದ ಪ್ರಮುಖ ತತ್ತ್ವಾಂಶಗಳೇನು ಎಂದು ವಿದ್ಯಾರ್ಥಿಗಳು ಪರಿಗಣಿಸುವುದೇನು? | [ಪಾಠ](1-Introduction/3-fairness/README.md) | ಟೊಮೊಮಿ |
| 04 | ಯಂತ್ರ ಅಧ್ಯಯನದ ತಂತ್ರಗಳು | [ಪರಿಚಯ](1-Introduction/README.md) | ಯಂತ್ರ ಅಧ್ಯಯನ ಸಂಶೋಧಕರು ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಲು ಯಾವ ತಂತ್ರಗಳನ್ನು ಬಳಸುತ್ತಾರೆ? | [ಪಾಠ](1-Introduction/4-techniques-of-ML/README.md) | ಕ್ರಿಸ್ ಮತ್ತು ಜೆನ್ | | 04 | ಯಂತ್ರ ಕಲಿಕೆಯ ತಂತ್ರಗಳು | [ಪರಿಚಯ](1-Introduction/README.md) | ಯಂತ್ರ ಕಲಿಕೆ ಸಂಶೋಧಕರು ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಲು ಯಾವ ತಂತ್ರಗಳನ್ನು ಬಳಕೆ ಮಾಡುತ್ತಾರೆ? | [ಪಾಠ](1-Introduction/4-techniques-of-ML/README.md) | ಕ್ರಿಸ್ ಮತ್ತು ಜೆನ್ |
| 05 | ರೆಗ್ರೆಷನ್‌ಗೆ ಪರಿಚಯ | [ರೆಗ್ರೆಷನ್](2-Regression/README.md) | ರೆಗ್ರೆಷನ್ ಮಾದರಿಗಳಿಗಾಗಿ ಪೈಥಾನ್ ಮತ್ತು ಸ್ಕಿಕ್-ಲರ್ನ್ ಉಪಯೋಗಿಸುವ ಪ್ರಾಥಮಿಕ ಅನುಭವ | [ಪೈಥಾನ್](2-Regression/1-Tools/README.md) • [ಆರ್](../../2-Regression/1-Tools/solution/R/lesson_1.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜಾ | | 05 | ರಿಗ್ರೆಶನ್‌ಗೆ ಪರಿಚಯ | [ರಿಗ್ರೆಶನ್](2-Regression/README.md) | ರಿಗ್ರೆಶನ್ ಮಾದರಿಗಳಿಗಾಗಿ ಪೈಥಾನ್ ಮತ್ತು ಸೈಕಿಟ್-ಲರ್ನ್ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿ | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜ್ಜಿ |
| 06 | ಉತ್ತರ ಅಮೆರಿಕದ ಪಂಪ್ಕಿನ್ ಬೆಲೆಗಳು 🎃 | [ರೆಗ್ರೆಷನ್](2-Regression/README.md) | ಯಂತ್ರ ಅಧ್ಯಯನದ ಪೂರ್ವಸಿದ್ಧಿಗಾಗಿ ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಿ ಮತ್ತು ಶುದ್ಧೀಕರಿಸಿ | [ಪೈಥಾನ್](2-Regression/2-Data/README.md) • [ಆರ್](../../2-Regression/2-Data/solution/R/lesson_2.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜಾ | | 06 | ನಾರ್ತ್ ಅಮೆರಿಕದ ಹುಳಿಗೆ ದರಗಳು 🎃 | [ರಿಗ್ರೆಶನ್](2-Regression/README.md) | ಯಂತ್ರ ಕಲಿಕೆಯ ತಯಾರಿಗಾಗಿ ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಣ ಮತ್ತು ಸ್ವಚ್ಛತೆ ಮಾಡಿರಿ | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜ್ಜಿ |
| 07 | ಉತ್ತರ ಅಮೆರಿಕದ ಪಂಪ್ಕಿನ್ ಬೆಲೆಗಳು 🎃 | [ರೆಗ್ರೆಷನ್](2-Regression/README.md) | ರೇಖೀಯ ಮತ್ತು ಬಹುಪದ್ಯ ರೆಗ್ರೆಷನ್ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಿ | [ಪೈಥಾನ್](2-Regression/3-Linear/README.md) • [ಆರ್](../../2-Regression/3-Linear/solution/R/lesson_3.html) | ಜೆನ್ ಮತ್ತು Dmitry • ಎರಿಕ್ ವಾಂಜಾ | | 07 | ನಾರ್ತ್ ಅಮೆರಿಕದ ಹುಳಿಗೆ ದರಗಳು 🎃 | [ರಿಗ್ರೆಶನ್](2-Regression/README.md) | ರೇಖೀಯ ಮತ್ತು ಬಹುಪದ ರಿಗ್ರೆಶನ್ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಿ | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | ಜೆನ್ ಮತ್ತು ಡ್ಮಿಟ್ರಿ • ಎರಿಕ್ ವಾಂಜ್ಜೌ |
| 08 | ಉತ್ತರ ಅಮೆರಿಕದ ಪಂಪ್ಕಿನ್ ಬೆಲೆಗಳು 🎃 | [ರೆಗ್ರೆಷನ್](2-Regression/README.md) | ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಷನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ | [ಪೈಥಾನ್](2-Regression/4-Logistic/README.md) • [ಆರ್](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜಾ | | 08 | ನಾರ್ತ್ ಅಮೆರಿಕದ ಹುಳಿಗೆ ದರಗಳು 🎃 | [ರಿಗ್ರೆಶನ್](2-Regression/README.md) | ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಶನ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿ | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜ್ಜೌ |
| 09 | ವೆಬ್ ಆಪ್ 🔌 | [ವೆಬ್ ಆಪ್](3-Web-App/README.md) | ತರಬೇತಿಗೊಂಡ ಮಾದರಿ ಉಪಯೋಗಿಸಲು ವೆಬ್ ಆಪ್ ನಿರ್ಮಿಸಿ | [ಪೈಥಾನ್](3-Web-App/1-Web-App/README.md) | ಜೆನ್ | | 09 | ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ 🔌 | [ವೆಬ್ ಅಪ್](3-Web-App/README.md) | ನಿಮ್ಮ ತರಬೇತುಗೊಳ್ಳಿಸಿದ ಮಾದರಿಯನ್ನು ಬಳಸಲು ಒಂದು ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಿಸಿ | [Python](3-Web-App/1-Web-App/README.md) | ಜೆನ್ |
| 10 | ವರ್ಗೀಕರಣಕ್ಕೆ ಪರಿಚಯ | [ವರ್ಗೀಕರಣ](4-Classification/README.md) | ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಶುದ್ಧ ಮಾಡಿ, ಪೂರ್ವಸಿದ್ಧ ಮಾಡಿ ಮತ್ತು ದೃಶ್ಯೀಕರಿಸಿ; ವರ್ಗೀಕರಣಗೆ ಪರಿಚి | [ಪೈಥಾನ್](4-Classification/1-Introduction/README.md) • [ಆರ್](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | ಜೆನ್ ಮತ್ತು ಕ್ಯಾಸಿ • ಎರಿಕ್ ವಾಂಜಾ | | 10 | ವರ್ಗೀಕರಣಕ್ಕೆ ಪರಿಚಯ | [ವರ್ಗೀಕರಣ](4-Classification/README.md) | ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಸ್ವಚ್ಛ, ತಯಾರಿಸಿ, ಮತ್ತು ದೃಶ್ಯೀಕರಿಸಿ; ವರ್ಗೀಕರಣಕ್ಕೆ ಪರಿಚಯ | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | ಜೆನ್ ಮತ್ತು ಕ್ಯಾಸಿ • ಎರಿಕ್ ವಾಂಜ್ಜೌ |
| 11 | ರುಚಿಕರ ಏಷ್ಯನ್ ಮತ್ತು ಭಾರತೀಯ ವಿನ್ಯಾಸಗಳು 🍜 | [ವರ್ಗೀಕರಣ](4-Classification/README.md) | ವರ್ಗೀಕರಿಸುವವರ ಪರಿಚಯ | [ಪೈಥಾನ್](4-Classification/2-Classifiers-1/README.md) • [ಆರ್](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | ಜೆನ್ ಮತ್ತು ಕ್ಯಾಸಿ • ಎರಿಕ್ ವಾಂಜಾ | | 11 | ಆಸೀಯ ಮತ್ತು ಭಾರತೀಯ ರುಚಿಗಳು 🍜 | [ವರ್ಗೀಕರಣ](4-Classification/README.md) | ವರ್ಗೀಕರಣಕಾರರ ಪರಿಚಯ | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | ಜೆನ್ ಮತ್ತು ಕ್ಯಾಸಿ • ಎರಿಕ್ ವಾಂಜ್ಜೌ |
| 12 | ರುಚಿಕರ ಏಷ್ಯನ್ ಮತ್ತು ಭಾರತೀಯ ವಿನ್ಯಾಸಗಳು 🍜 | [ವರ್ಗೀಕರಣ](4-Classification/README.md) | ಇನ್ನಷ್ಟು ವರ್ಗೀಕರಿಸುವವರು | [ಪೈಥಾನ್](4-Classification/3-Classifiers-2/README.md) • [ಆರ್](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | ಜೆನ್ ಮತ್ತು ಕ್ಯಾಸಿ • ಎರಿಕ್ ವಾಂಜಾ | | 12 | ಆಸೀಯ ಮತ್ತು ಭಾರತೀಯ ರುಚಿಗಳು 🍜 | [ವರ್ಗೀಕರಣ](4-Classification/README.md) | ಹೆಚ್ಚಿನ ವರ್ಗೀಕರಣಕಾರರು | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | ಜೆನ್ ಮತ್ತು ಕ್ಯಾಸಿ • ಎರಿಕ್ ವಾಂಜ್ಜೌ |
| 13 | ರುಚಿಕರ ಏಷ್ಯನ್ ಮತ್ತು ಭಾರತೀಯ ವಿನ್ಯಾಸಗಳು 🍜 | [ವರ್ಗೀಕರಣ](4-Classification/README.md) | ನಿಮ್ಮ ಮಾದರಿ ಉಪಯೋಗಿಸಿ ಶಿಫಾರಸು ವೆಬ್ ಆಪ್ ನಿರ್ಮಿಸಿ | [ಪೈಥಾನ್](4-Classification/4-Applied/README.md) | ಜೆನ್ | | 13 | ಆಸೀಯ ಮತ್ತು ಭಾರತೀಯ ರುಚಿಗಳು 🍜 | [ವರ್ಗೀಕರಣ](4-Classification/README.md) | ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ಉಪಯೋಗಿಸಿ ಶಿಫಾರಸು ಮಾಡುವ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಿಸಿ | [Python](4-Classification/4-Applied/README.md) | ಜೆನ್ |
| 14 | ಗುಂಪುಗಟ್ಟಿಗೆ ಪರಿಚಯ | [ಗುಂಪುಗಟ್ಟಿ](5-Clustering/README.md) | ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಶುದ್ಧ ಮಾಡಿ, ಪೂರ್ವಸಿದ್ಧ ಮಾಡಿ ಮತ್ತು ದೃಶ್ಯೀಕರಿಸಿ; ಗುಂಪುಗಟ್ಟಿಗೆಗೆ ಪರಿಚಯ | [ಪೈಥಾನ್](5-Clustering/1-Visualize/README.md) • [ಆರ್](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜಾ | | 14 | ಕ್ಲಸ್ಟರಿಂಗ್‌ಗೆ ಪರಿಚಯ | [ಕ್ಲಸ್ಟರಿಂಗ್](5-Clustering/README.md) | ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಸ್ವಚ್ಛ, ತಯಾರಿಸಿ, ಮತ್ತು ದೃಶ್ಯೀಕರಿಸಿ; ಕ್ಲಸ್ಟರಿಂಗ್‌ಗೆ ಪರಿಚಯ | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜ್ಜೌ |
| 15 | ನೈಜೀರಿಯಾ ಸಂಗೀತ ರುಚಿಗಳನ್ನು ಅನ್ವೇಷಣೆ 🎧 | [ಗುಂಪುಗಟ್ಟಿ](5-Clustering/README.md) | K-ಮೀನ್ಸ್ ಗುಂಪುಗಟ್ಟಿ ವಿಧಾನವನ್ನು ಅನ್ವೇಷಿಸಿ | [ಪೈಥಾನ್](5-Clustering/2-K-Means/README.md) • [ಆರ್](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜಾ | | 15 | ನೈಜೀರಿಯನ್ ಸಂಗೀತ ರುಚಿಗಳ ಅನ್ವೇಷಣೆ 🎧 | [ಕ್ಲಸ್ಟರಿಂಗ್](5-Clustering/README.md) | ಕೆ-ಮೀನ್ಸ್ ಕ್ಲಸ್ಟರಿಂಗ್ ವಿಧಾನವನ್ನು ಅನ್ವೇಷಿಸಿ | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | ಜೆನ್ • ಎರಿಕ್ ವಾಂಜ್ಜೌ |
| 16 | ನೈಸರ್ಗಿಕ ಭಾಷೆ ಸಂಸ್ಕರಣೆಗೆ ಪರಿಚಯ ☕️ | [ನೈಸರ್ಗಿಕ ಭಾಷೆ ಸಂಸ್ಕರಣೆ](6-NLP/README.md) | ಸರಳ ಬಾಟ್ ನಿರ್ಮಿಸುವ ಮೂಲಕ NLP ಆಧಾರಭೂತ ವಿಷಯಗಳನ್ನು ಕಲಿಯೋಣ | [ಪೈಥಾನ್](6-NLP/1-Introduction-to-NLP/README.md) | ಸ್ಟೀಫನ್ | | 16 | ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆಗೆ ಪರಿಚಯ ☕️ | [ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ](6-NLP/README.md) | ಸರಳ ಬಾಟ್ ಅನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಕ NLP ಮೂಲಗಳನ್ನು ಕಲಿಯಿರಿ | [Python](6-NLP/1-Introduction-to-NLP/README.md) | ಸ್ಟೀಫನ್ |
| 17 | ಸಾಮಾನ್ಯ NLP ಕಾರ್ಯಗಳು ☕️ | [ನೈಸರ್ಗಿಕ ಭಾಷೆ ಸಂಸ್ಕರಣೆ](6-NLP/README.md) | ಭಾಷಾ ರಚನೆಗಳ ಸಂಬಂದಿಸಿದ ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದರಿಂದ ನಿಮ್ಮ NLP ಜ್ಞಾನವನ್ನು ಗಾಢಗೊಳಿಸಿ | [ಪೈಥಾನ್](6-NLP/2-Tasks/README.md) | ಸ್ಟೀಫನ್ | | 17 | ಸಾಮಾನ್ಯ NLP ಕೆಲಸಗಳು ☕️ | [ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ](6-NLP/README.md) | ಭಾಷಾ ರಚನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಬೇಕಾದ ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದರಿಂದ ನಿಮ್ಮ NLP ಜ್ಞಾನವನ್ನು ಆಳಗೊಳಿಸಿ | [Python](6-NLP/2-Tasks/README.md) | ಸ್ಟೀಫನ್ |
| 18 | ಭಾಷಾಂತರ ಮತ್ತು ಭಾವ ವಿಶ್ಲೇಷಣೆ ♥️ | [ನೈಸರ್ಗಿಕ ಭಾಷೆ ಸಂಸ್ಕರಣೆ](6-NLP/README.md) | ಜಯನ್ ಆಸ್ಟೆನ್ ಅವರೊಂದಿಗೆ ಭಾಷಾಂತರ ಮತ್ತು ಭಾವ ವಿಶ್ಲೇಷಣೆ | [ಪೈಥಾನ್](6-NLP/3-Translation-Sentiment/README.md) | ಸ್ಟೀಫನ್ | | 18 | ಅನುವಾದ ಮತ್ತು ಭಾವ ವಿಶ್ಲೇಷಣೆ ♥️ | [ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ](6-NLP/README.md) | ಜೆನ್ ಆಷ್ಟಿನ್ ಮೂಲಕ ಅನುವಾದ ಮತ್ತು ಭಾವ ವಿಶ್ಲೇಷಣೆ | [Python](6-NLP/3-Translation-Sentiment/README.md) | ಸ್ಟೀಫನ್ |
| 19 | ಯುರೋಪಿನ ರೊಮ್ಯಾಂಟಿಕ್ ಹೋಟೆಲ್ಸ್ ♥️ | [ನೈಸರ್ಗಿಕ ಭಾಷೆ ಸಂಸ್ಕರಣೆ](6-NLP/README.md) | ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳೊಂದಿಗೆ ಭಾವ ವಿಶ್ಲೇಷಣೆ 1 | [ಪೈಥಾನ್](6-NLP/4-Hotel-Reviews-1/README.md) | ಸ್ಟೀಫನ್ | | 19 | ಯುರೋಪಿಯನ್ ಪ್ರೇಮ ಆಸ್ಪತ್ರೆಗಳು ♥️ | [ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ](6-NLP/README.md) | ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳಿಂದ ಭಾವ ವಿಶ್ಲೇಷಣೆ 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | ಸ್ಟೀಫನ್ |
| 20 | ಯುರೋಪಿನ ರೊಮ್ಯಾಂಟಿಕ್ ಹೋಟೆಲ್ಸ್ ♥️ | [ನೈಸರ್ಗಿಕ ಭಾಷೆ ಸಂಸ್ಕರಣೆ](6-NLP/README.md) | ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳೊಂದಿಗೆ ಭಾವ ವಿಶ್ಲೇಷಣೆ 2 | [ಪೈಥಾನ್](6-NLP/5-Hotel-Reviews-2/README.md) | ಸ್ಟೀಫನ್ | | 20 | ಯುರೋಪಿಯನ್ ಪ್ರೇಮ ಆಸ್ಪತ್ರೆಗಳು ♥️ | [ನೈಸರ್ಗಿಕ ಭಾಷಾ ಸಂಸ್ಕರಣೆ](6-NLP/README.md) | ಹೋಟೆಲ್ ವಿಮರ್ಶೆಗಳಿಂದ ಭಾವ ವಿಶ್ಲೇಷಣೆ 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | ಸ್ಟೀಫನ್ |
| 21 | ಕಾಲಶ್ರೇಣಿ ಪೂರ್ವನಿರ್ದೇಶನಕ್ಕೆ ಪರಿಚಯ | [ಕಾಲಶ್ರೇಣಿ](7-TimeSeries/README.md) | ಕಾಲಶ್ರೇಣಿ ಪೂರ್ವನಿರ್ದೇಶನಕ್ಕೆ ಪರಿಚಯ | [ಪೈಥಾನ್](7-TimeSeries/1-Introduction/README.md) | ಫ್ರಾನ್ಸೆಸ್ಕಾ | | 21 | ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯಕ್ತಿಸುವಿಕೆಗೆ ಪರಿಚಯ | [ಕಾಲ ಸರಣಿ](7-TimeSeries/README.md) | ಕಾಲ ಸರಣಿಗಳ ಭವಿಷ್ಯಕ್ಟಿಸುವಿಕೆಗೆ ಪರಿಚಯ | [Python](7-TimeSeries/1-Introduction/README.md) | ഫ്രಾನ್ಸೆಸ್ಕ |
| 22 | ⚡️ ವಿಶ್ವ ವಿದ್ಯುತ್ ಬಳಕೆ ⚡️ - ARIMA ಜೊತೆಗೆ ಕಾಲಶ್ರೇಣಿ ಪೂರ್ವನಿರ್ದೇಶನ | [ಕಾಲಶ್ರೇಣಿ](7-TimeSeries/README.md) | ARIMA ಬಳಸಿ ಕಾಲಶ್ರೇಣಿ ಪೂರ್ವನಿರ್ದೇಶನ | [ಪೈಥಾನ್](7-TimeSeries/2-ARIMA/README.md) | ಫ್ರಾನ್ಸೆಸ್ಕಾ | | 22 | ⚡️ ವಿಶ್ವ ವಿದ್ಯुत ಬಳಕೆ ⚡️ - ARIMA ಸಹಿತ ಕಾಲ ಸರಣಿ forecasting | [ಕಾಲ ಸರಣಿ](7-TimeSeries/README.md) | ARIMA ನೊಂದಿಗೆ ಕಾಲ ಸರಣಿ forecasting | [Python](7-TimeSeries/2-ARIMA/README.md) | ഫ്രಾನ್ಸೆಸ್ಕ |
| 23 | ⚡️ ವಿಶ್ವ ವಿದ್ಯುತ್ ಬಳಕೆ ⚡️ - SVR ಜೊತೆಗೆ ಕಾಲಶ್ರೇಣಿ ಪೂರ್ವನಿರ್ದೇಶನ | [ಕಾಲಶ್ರೇಣಿ](7-TimeSeries/README.md) | ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ರೆಗ್ರೆಸರ್ ಬಳಸಿ ಕಾಲಶ್ರೇಣಿ ಪೂರ್ವನಿರ್ದೇಶನ | [ಪೈಥಾನ್](7-TimeSeries/3-SVR/README.md) | ಅನಿರ್ಬಾನ್ | | 23 | ⚡️ ವಿಶ್ವ ವಿದ್ಯುತ್ ಬಳಕೆ ⚡️ - SVR ಸಹಿತ ಕಾಲ ಸರಣಿ forecasting | [ಕಾಲ ಸರಣಿ](7-TimeSeries/README.md) | ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ರಿಗ್ರೆಶನ್ (SVR) ಸಹಿತ ಕಾಲ ಸರಣಿ forecasting | [Python](7-TimeSeries/3-SVR/README.md) | ಅನಿರ್ಬಾನ್ |
| 24 | ಬಲವರ್ಧಿತ ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ | [ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ](8-Reinforcement/README.md) | Q-ಅಧ್ಯಯನದೊಂದಿಗೆ ಬಲವರ್ಧಿತ ಅಧ್ಯಯನಕ್ಕೆ ಪರಿಚಯ | [ಪೈಥಾನ್](8-Reinforcement/1-QLearning/README.md) | Dmitry | | 24 | ಪುನರಾವೃತ್ತ ಕಲಿಕೆಯ ಪರಿಚಯ | [ಪುನರಾವೃತ್ತ ಕಲಿಕೆ](8-Reinforcement/README.md) | Q-ಲರ್ನಿಂಗ್ ಬಳಸಿ ಪುನರಾವೃತ್ತ ಕಲಿಕೆಯ ಪರಿಚಯ | [Python](8-Reinforcement/1-QLearning/README.md) | ಡ್ಮಿಟ್ರಿ |
| 25 | ಪೀಟರ್ ನೆಗೆ ದಾಳಿಯನ್ನ ತಪ್ಪಿಸುವಲ್ಲಿ ನೆರವು! 🐺 | [ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ](8-Reinforcement/README.md) | ಬಲವರ್ಧಿತ ಅಧ್ಯಯನ ಜಿಮ್ | [ಪೈಥಾನ್](8-Reinforcement/2-Gym/README.md) | Dmitry | | 25 | ಪೀಟರ್ ಪ್ರಾಣಿಗಳಿಂದ ತಪ್ಪಿಸಿರಿ! 🐺 | [ಪುನರಾವೃತ್ತ ಕಲಿಕೆ](8-Reinforcement/README.md) | ಪುನರಾವೃತ್ತ ಕಲಿಕೆಯ ಜಿಮ್ | [Python](8-Reinforcement/2-Gym/README.md) | ಡ್ಮಿಟ್ರಿ |
| ಸಾಂಧರ್ಭಿಕ | ನಿಜಜೀವನದ ML ಸನ್ನಿವೇಶಗಳು ಮತ್ತು ಅನ್ವಯಿಕೆಗಳು | [ML in the Wild](9-Real-World/README.md) | ಶ್ರೇಷ್ಟ ಮತ್ತು ಬಹಿರಂಗ ನಿಜಜೀವನದ ಅನ್ವಯಿಕೆಗಳು | [ಪಾಠ](9-Real-World/1-Applications/README.md) | ತಂಡ | | ಅನುಬಂಧ | ನಿಜಜೀವ ML ಘಟನಾಕ್ರಮಗಳು ಮತ್ತು ಅನ್ವಯಿಕೆಗಳು | [ಜೀವರಹಿತದ ML](9-Real-World/README.md) | ಕ್ಲಾಸಿಕಲ್ ML ನ ಆಸಕ್ತಿದಾಯಕ ಮತ್ತು ಪ್ರಕಟಣೆಮಾಡುವ ನಿಜಜೀವ ಅನ್ವಯಿಕೆಗಳು | [ಪಾಠ](9-Real-World/1-Applications/README.md) | ತಂಡ |
| ಸಾಂಧರ್ಭಿಕ | RAI ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಬಳಸಿ ML ಮಾದರಿಗಳ ಡಿಬಗ್ ಮಾಡುವುದು | [ML in the Wild](9-Real-World/README.md) | ಜವಾಬ್ದಾರಿ AI ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಘಟಕಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಯಂತ್ರ ಅಧ್ಯಯನದಲ್ಲಿ ಮಾದರಿ ಡಿಬಗ್ ಮಾಡುವುದು | [ಪಾಠ](9-Real-World/2-Debugging-ML-Models/README.md) | ರುತ್ ಯಾಕುಬು | | ಅನುಬಂಧ | RAI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಬಳಸಿ ML ಮಾದರಿ ಡಿಬಗಿಂಗ್ | [ಜೀವರಹಿತದ ML](9-Real-World/README.md) | ಜವಾಬ್ದಾರಿ AI ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಘಟಕಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಯಂತ್ರ ಕಲಿಕೆ ಮಾದರಿ ಡಿಬಗಿಂಗ್ | [ಪಾಠ](9-Real-World/2-Debugging-ML-Models/README.md) | ರೂತ್ ಯಾಕುಬು |
> [ಈ ಕೋರ್ಸ್‌ನ ಎಲ್ಲಾ ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಮ್ಮ Microsoft Learn ಸಂಗ್ರಹದಲ್ಲಿ ಕಂಡುಹಿಡಿಯಿರಿ](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum) > [ಈ ಕೋರ್ಸ್‌ನ ಎಲ್ಲಾ ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಮ್ಮ Microsoft Learn ಸಂಗ್ರಹದಲ್ಲಿ ಪತ್ತೆಮಾಡಿ](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
## ಆಫ್‌ಲೈನ್ ಪ್ರವೇಶ ## ಆಫ್‌ಲೈನ್ ಪ್ರವೇಶ
ನೀವು ಈ ದಾಖಲೆಗಳನ್ನು [Docsify](https://docsify.js.org/#/) ಉಪಯೋಗಿಸಿ ಆಫ್‌ಲೈನ್‌ನಲ್ಲಿ ಓಡಿಸಬಹುದು. ಈ ರೆಪೋವನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ, ನಿಮ್ಮ ಸ್ಥಳೀಯ ಯಂತ್ರಕ್ಕೆ [Docsify ಅನ್ನು ಸ್ಥಾಪಿಸಿ](https://docsify.js.org/#/quickstart), ನಂತರ ಈ ರೆಪೋಯ ರುಟ್ ಫೋಲ್ಡರ್ನಲ್ಲಿ `docsify serve` ಅನ್ನು ಟೈಪ್ ಮಾಡಿ. ವೆಬ್‌ಸೈಟ್ ನಿಮ್ಮ ಲೋಕಲ್‌ಹೋಸ್ಟ್‌ನ 3000 ಪೋರ್ಟ್‌ನಲ್ಲಿ ಸರ್ವ್ ಆಗುತ್ತದೆ: `localhost:3000`. ನೀವು ಈ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನ್ನು ಆಫ್‌ಲೈನಲ್ಲಿಯೇ [Docsify](https://docsify.js.org/#/) ಬಳಸಿ রান್ ಮಾಡಬಹುದು. ಈ ರೆಪೊವನ್ನು ಫೋರ್ಕ್ ಮಾಡಿ, ನಿಮ್ಮ ಸ್ಥಳೀಯ ಯಂತ್ರದಲ್ಲಿ [Docsify ಹೊಂದಿಸಿ](https://docsify.js.org/#/quickstart), ನಂತರ ಈ ರೆಪೊ ರూట್ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ `docsify serve` ಎಂಬ ಲಿಖನ ನೀಡಿ. ವೆಬ್‌ಸೈಟ್ ನಿಮ್ಮ ಸ್ಥಳೀಯ ಯಂತ್ರದಲ್ಲಿ ಪೋರ್ಟ್ 3000 ಮೇಲೆ ಸರ್ವ್ ಆಗುತ್ತದೆ: `localhost:3000`.
## ಪಿಡಿಎಫ್ಗಳು ## PDF‌ಗಳು
ಲಿಂಕ್‌ಗಳೊಂದಿಗೆ ಪಠ್ಯಕ್ರಮದ ಪಿಡಿಎಫ್ [ಇಲ್ಲಿ](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf) ಕಂಡುಹಿಡಿಯಿರಿ. ಪಠ್ಯಕ್ರಮದ ಪಿಡಿಎಫ್ ಅನ್ನು [ಇಲ್ಲಿ](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf) ಹುಡುಕಿ.
## 🎒 ಇತರ ಕೋರ್ಸಸ್
## 🎒 ಇತರೆ ಕೋರ್ಸ್‌ಗಳು ನಮ್ಮ ತಂಡ ಇತರ ಕೋರ್ಸಸ್ ಅನ್ನು ತಯಾರಿಸುತ್ತದೆ! ನೋಡಿ:
ನಮ್ಮ ತಂಡ ಇನ್ನಿತರ ಕೋರ್ಸ್‌ಗಳನ್ನು ಸೃಷ್ಟಿಸಿದೆ! ಪರಿಶೀಲಿಸಿ:
<!-- CO-OP TRANSLATOR OTHER COURSES START --> <!-- CO-OP TRANSLATOR OTHER COURSES START -->
### LangChain ### LangChain
[![LangChain4j for Beginners](https://img.shields.io/badge/LangChain4j%20for%20Beginners-22C55E?style=for-the-badge&&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchain4j-for-beginners) [![ಬಿಗಿನರ್ಸ್‌ಗಾಗಿ LangChain4j](https://img.shields.io/badge/LangChain4j%20for%20Beginners-22C55E?style=for-the-badge&&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchain4j-for-beginners)
[![LangChain.js for Beginners](https://img.shields.io/badge/LangChain.js%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin) [![ಬಿಗಿನರ್ಸ್‌ಗಾಗಿ LangChain.js](https://img.shields.io/badge/LangChain.js%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
[![LangChain for Beginners](https://img.shields.io/badge/LangChain%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin) [![ಬಿಗಿನರ್ಸ್‌ಗಾಗಿ LangChain](https://img.shields.io/badge/LangChain%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
--- ---
### ಅಜೂರ್ / ಎಡ್ಜ್ / MCP / ಏಜೆಂಟ್ಸ್ ### ಅಜೂರ್ / ಎಡ್ಜ್ / MCP / ಏಜೆಂಟ್‌ಗಳು
[![AZD for Beginners](https://img.shields.io/badge/AZD%20for%20Beginners-0078D4?style=for-the-badge&labelColor=E5E7EB&color=0078D4)](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst) [![ಬಿಗಿನರ್ಸ್‌ಗಾಗಿ AZD](https://img.shields.io/badge/AZD%20for%20Beginners-0078D4?style=for-the-badge&labelColor=E5E7EB&color=0078D4)](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[![Edge AI for Beginners](https://img.shields.io/badge/Edge%20AI%20for%20Beginners-00B8E4?style=for-the-badge&labelColor=E5E7EB&color=00B8E4)](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst) [![ಬಿಗಿನರ್ಸ್‌ಗಾಗಿ Edge AI](https://img.shields.io/badge/Edge%20AI%20for%20Beginners-00B8E4?style=for-the-badge&labelColor=E5E7EB&color=00B8E4)](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[![MCP for Beginners](https://img.shields.io/badge/MCP%20for%20Beginners-009688?style=for-the-badge&labelColor=E5E7EB&color=009688)](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst) [![ಆರಂಭಿಕ ಯಜಮಾನರಿಗೆ MCP](https://img.shields.io/badge/MCP%20for%20Beginners-009688?style=for-the-badge&labelColor=E5E7EB&color=009688)](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[![AI Agents for Beginners](https://img.shields.io/badge/AI%20Agents%20for%20Beginners-00C49A?style=for-the-badge&labelColor=E5E7EB&color=00C49A)](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst) [![ಆರಂಭಿಕ ಯಜಮಾನರಿಗೆ AI ಏಜೆಂಟ್‌ಗಳು](https://img.shields.io/badge/AI%20Agents%20for%20Beginners-00C49A?style=for-the-badge&labelColor=E5E7EB&color=00C49A)](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
--- ---
### ಜನರೇಟಿವ್ AI ಸರಣಿ ### ಜನರೇಟಿವ್ AI ಸರಣಿ
[![ಪ್ರಾರಂಭಿಕರಿಗೆ ಜನರೇಟಿವ್ AI](https://img.shields.io/badge/Generative%20AI%20for%20Beginners-8B5CF6?style=for-the-badge&labelColor=E5E7EB&color=8B5CF6)](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst) [![ಆರಂಭಿಕ ಯಜಮಾನರಿಗೆ ಜನರೇಟಿವ್ AI](https://img.shields.io/badge/Generative%20AI%20for%20Beginners-8B5CF6?style=for-the-badge&labelColor=E5E7EB&color=8B5CF6)](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
[![ಜನರೇಟಿವ್ AI (.NET)](https://img.shields.io/badge/Generative%20AI%20(.NET)-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst) [![ಜನರೇಟಿವ್ AI (.NET)](https://img.shields.io/badge/Generative%20AI%20(.NET)-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst)
[![ಜನರೇಟಿವ್ AI (ಜಾವಾ)](https://img.shields.io/badge/Generative%20AI%20(Java)-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst) [![ಜನರೇಟಿವ್ AI (ಜಾವಾ)](https://img.shields.io/badge/Generative%20AI%20(Java)-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst)
[![ಜನರೇಟಿವ್ AI (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್)](https://img.shields.io/badge/Generative%20AI%20(JavaScript)-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst) [![ಜನರೇಟಿವ್ AI (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್)](https://img.shields.io/badge/Generative%20AI%20(JavaScript)-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst)
--- ---
### ಮೂಲ ಕಲಿಕೆ ### ಕೋರ್ ಲರ್ನಿಂಗ್
[![ಪ್ರಾರಂಭಿಕರಿಗೆ ಎಂಎಲ್](https://img.shields.io/badge/ML%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=22C55E)](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst) [![ಆರಂಭಿಕ ಯಜಮಾನರಿಗೆ ML](https://img.shields.io/badge/ML%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=22C55E)](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst)
[![ಪ್ರಾರಂಭಿಕರಿಗೆ ಡೇಟಾ ಸೈನ್ಸ್](https://img.shields.io/badge/Data%20Science%20for%20Beginners-84CC16?style=for-the-badge&labelColor=E5E7EB&color=84CC16)](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst) [![ಆರಂಭಿಕ ಯಜಮಾನರಿಗೆ ಡೇಟಾ ವಿಜ್ಞಾನ](https://img.shields.io/badge/Data%20Science%20for%20Beginners-84CC16?style=for-the-badge&labelColor=E5E7EB&color=84CC16)](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst)
[![ಪ್ರಾರಂಭಿಕರಿಗೆ AI](https://img.shields.io/badge/AI%20for%20Beginners-A3E635?style=for-the-badge&labelColor=E5E7EB&color=A3E635)](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst) [![ಆರಂಭಿಕ ಯಜಮಾನರಿಗೆ AI](https://img.shields.io/badge/AI%20for%20Beginners-A3E635?style=for-the-badge&labelColor=E5E7EB&color=A3E635)](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst)
[![ಪ್ರಾರಂಭಿಕರಿಗೆ ಸೈಬರ್ ಭದ್ರತೆ](https://img.shields.io/badge/Cybersecurity%20for%20Beginners-F97316?style=for-the-badge&labelColor=E5E7EB&color=F97316)](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung) [![ಆರಂಭಿಕ ಯಜಮಾನರಿಗೆ ಸೈಬರ್‌ಸುರಕ್ಷತೆ](https://img.shields.io/badge/Cybersecurity%20for%20Beginners-F97316?style=for-the-badge&labelColor=E5E7EB&color=F97316)](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung)
[![ಪ್ರಾರಂಭಿಕರಿಗೆ ವೆಬ್ ಡೆವ್](https://img.shields.io/badge/Web%20Dev%20for%20Beginners-EC4899?style=for-the-badge&labelColor=E5E7EB&color=EC4899)](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst) [![ಆರಂಭಿಕ ಯಜಮಾನರಿಗೆ ವೆಬ್ ಡೆವ್](https://img.shields.io/badge/Web%20Dev%20for%20Beginners-EC4899?style=for-the-badge&labelColor=E5E7EB&color=EC4899)](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst)
[![ಪ್ರಾರಂಭಿಕರಿಗೆ ಐಒಟಿ](https://img.shields.io/badge/IoT%20for%20Beginners-14B8A6?style=for-the-badge&labelColor=E5E7EB&color=14B8A6)](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst) [![ಆರಂಭಿಕ ಯಜಮಾನರಿಗೆ ಐಒಟಿ](https://img.shields.io/badge/IoT%20for%20Beginners-14B8A6?style=for-the-badge&labelColor=E5E7EB&color=14B8A6)](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst)
[![ಪ್ರಾರಂಭಿಕರಿಗೆ XR ಅಭಿವೃದ್ಧಿ](https://img.shields.io/badge/XR%20Development%20for%20Beginners-38BDF8?style=for-the-badge&labelColor=E5E7EB&color=38BDF8)](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst) [![ಆರಂಭಿಕ ಯಜಮಾನರಿಗೆ XR ಅಭಿವೃದ್ಧಿ](https://img.shields.io/badge/XR%20Development%20for%20Beginners-38BDF8?style=for-the-badge&labelColor=E5E7EB&color=38BDF8)](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst)
--- ---
### ಕೊಪೈಲಟ್ ಸರಣಿ ### ಕೋಪಿಲಾಟ್ ಸರಣಿ
[![AI ಜೋಡಣೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಗೆ ಕೊಪೈಲಟ್](https://img.shields.io/badge/Copilot%20for%20AI%20Paired%20Programming-FACC15?style=for-the-badge&labelColor=E5E7EB&color=FACC15)](https://aka.ms/GitHubCopilotAI?WT.mc_id=academic-105485-koreyst) [![AI ಜೋಡಣೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗಾಗಿ ಕೋಪಿಲಾಟ್](https://img.shields.io/badge/Copilot%20for%20AI%20Paired%20Programming-FACC15?style=for-the-badge&labelColor=E5E7EB&color=FACC15)](https://aka.ms/GitHubCopilotAI?WT.mc_id=academic-105485-koreyst)
[![C#/.NET ಗೆ ಕೊಡ್‌ಪೈಲಟ್](https://img.shields.io/badge/Copilot%20for%20C%23/.NET-FBBF24?style=for-the-badge&labelColor=E5E7EB&color=FBBF24)](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers?WT.mc_id=academic-105485-koreyst) [![C#/.NET ಗಾಗಿ ಕೋಪಿಲಾಟ್](https://img.shields.io/badge/Copilot%20for%20C%23/.NET-FBBF24?style=for-the-badge&labelColor=E5E7EB&color=FBBF24)](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers?WT.mc_id=academic-105485-koreyst)
[![ಕೊಪೈಲಟ್ ಸಾಹಸ](https://img.shields.io/badge/Copilot%20Adventure-FDE68A?style=for-the-badge&labelColor=E5E7EB&color=FDE68A)](https://github.com/microsoft/CopilotAdventures?WT.mc_id=academic-105485-koreyst) [![ಕೋಪಿಲಾಟ್ ಸಾಹಸ](https://img.shields.io/badge/Copilot%20Adventure-FDE68A?style=for-the-badge&labelColor=E5E7EB&color=FDE68A)](https://github.com/microsoft/CopilotAdventures?WT.mc_id=academic-105485-koreyst)
<!-- CO-OP TRANSLATOR OTHER COURSES END --> <!-- CO-OP TRANSLATOR OTHER COURSES END -->
## ಸಹಾಯ ಪಡೆಯುವುದು ## ಸಹಾಯ ಪಡೆಯುವುದು
ನೀವು ಅడ్డುಕೊಳ್ಳುತ್ತಿದ್ದೀರಾ ಅಥವಾ AI ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳಿದ್ದರೆ. MCP ಬಗ್ಗೆ fellow ಕಲಿಯುವವರು ಮತ್ತು ಅನುಭವ ಹೊಂದಿದ ಡೆವಲಪರ್ಸ್ ನಡುವೆ ಸಂವಾದಗಳಲ್ಲಿ ಸೇರಿ. ಇದು ಪ್ರಶ್ನೆಗಳಿಗೆ ಸ್ವಾಗತಿಸುವ ಮತ್ತು ಜ್ಞಾನವನ್ನು ಮುಕ್ತವಾಗಿ ಹಂಚಿಕೊಳ್ಳುವ ಬೆಂಬಲಾತ್ಮಕ ಸಮುದಾಯವಾಗಿದೆ. ನೀವು ಅಡ್ಡಬಿದ್ದರೆ ಅಥವಾ AI ಆ್ಯಪ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳಿದ್ದರೆ, MCP ಬಗ್ಗೆ ಚರ್ಚೆಗಳಲ್ಲಿ ಇತರ ಕಲಿಯುತ್ತಿರುವವರ ಮತ್ತು ಅನುಭವೀ ಡೆವಲಪರ್‌ಗಳೊಂದಿಗೆ ಸೇರಿ. ಇದು ಪ್ರಶ್ನೆಗಳಿಗೆ ಸ್ವಾಗತ ನೀಡುವ ಮತ್ತು ಜ್ಞಾನದ ವಿನಿಮಯದ ಸಹಾಯಕ ಸಮುದಾಯವಾಗಿದೆ.
[![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG) [![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG)
ನೀವು ಉತ್ಪನ್ನ ಪ್ರತಿಕ್ರಿಯೆ ಅಥವಾ ನಿರ್ಮಾಣದ ಸಮಯದಲ್ಲಿ ದೋಷಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಭೇಟಿ ನೀಡಿರಿ: ನೀವು ಉತ್ಪನ್ನ ಪ್ರತಿಕ್ರಿಯೆ ಅಥವಾ ನಿರ್ಮಾಣದ ವೇಳೆ ದೋಷಗಳನ್ನು ಕಂಡುಹಿಡಿದಿದ್ದರೆ ಭೇಟಿ ನೀಡಿ:
[![Microsoft Foundry Developer Forum](https://img.shields.io/badge/GitHub-Microsoft_Foundry_Developer_Forum-blue?style=for-the-badge&logo=github&color=000000&logoColor=fff)](https://aka.ms/foundry/forum) [![Microsoft Foundry Developer Forum](https://img.shields.io/badge/GitHub-Microsoft_Foundry_Developer_Forum-blue?style=for-the-badge&logo=github&color=000000&logoColor=fff)](https://aka.ms/foundry/forum)
## ಹೆಚ್ಚುವರಿ ಕಲಿಕೆಯ ಸಲಹೆಗಳು
- ಪ್ರತಿ ಪಾಠದ ನಂತರ ಟಿಪ್ಪಣಿಗಳನ್ನು ಪರಿಶೀಲಿಸಿ ಉತ್ತಮ ಅರ್ಥವಾಗಲು.
- ಸ್ವತಃ ಅಲ್ಗಾರಿತಮ್‌ಗಳನ್ನು ಅನುಸರಿಸಿ ಅಭ್ಯಾಸ ಮಾಡಿ.
- ಕಲಿತ ತತ್ವಗಳನ್ನು ಬಳಸಿ ವಾಸ್ತವಿಕ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಅನ್ವೇಷಿಸಿ.
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ತಡೆ ಸೂಚನೆ**: **ತಳ್ಳುವಿಕೆ**:
ಈ ದಾಖಲೆ AI ಭಾಷಾಂತರ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವದಿಸಲಾಗಿದೆ. ನಾವ್ ಸಂಪೂರ್ಣ ಶುದ್ಧತೆಯ ಕಡೆಗೆ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಭಾಷಾಂತರಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಲ್ಲವು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನದಲ್ಲಿರಿಸಿ. ಮೂಲ ದಾಖಲೆ ಅದರ ಸ್ವದೇಶಿ ಭಾಷೆಯಲ್ಲಿ ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವಪೂರ್ಣ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಭಾಷಾಂತರ ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ. ಈ ಭಾಷಾಂತರ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಗ್ರಹಿಕೆ ಅಥವಾ ತಪ್ಪಾದ ವಿವರಣೆಗೆ ನಾವು ಹೊಣೆಗಾರರಲ್ಲ. ಈ ದಸ್ತಾವೇಜುವನ್ನು AI ಭಾಷಾಂತರ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಭಾಷಾಂತರಿಸಲಾಗಿದೆ. ನಾವು ಸತ್ಯತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುವುದಾದರೂ, ಸ್ವಯಂಚಾಲಿತ ಭಾಷಾಂತರಗಳು ದೋಷಗಳು ಅಥವಾ ಅಸತ್ಯತೆಯನ್ನು ಹೊಂದಿರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿನ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕಾರಪೂರ್ಣ ಮೂಲ ಎಂದು ಪರಿಗಣಿಸಬೇಕಾಗಿದೆ. ಸಂವೇದನಶೀಲ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಭಾಷಾಂತರವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಭಾಷಾಂತರದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪುಅರ್ಥಗಳನ್ನು ಅಥವಾ ತಪ್ಪು ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ನಾವು ಹೊಣೆಗಾರರಾಗಿರುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

28
translations/ml/.co-op-translator.json
Unescape View File

@ -30,8 +30,8 @@
"language_code": "ml" "language_code": "ml"
}, },
"1-Introduction/3-fairness/assignment.md": { "1-Introduction/3-fairness/assignment.md": {
"original_hash": "dbda60e7b1fe5f18974e7858eff0004e", "original_hash": "c81d9affadb89d017d610eadeb6c84f9",
"translation_date": "2025-12-19T13:43:38+00:00", "translation_date": "2026-02-28T10:56:43+00:00",
"source_file": "1-Introduction/3-fairness/assignment.md", "source_file": "1-Introduction/3-fairness/assignment.md",
"language_code": "ml" "language_code": "ml"
}, },
@ -90,8 +90,8 @@
"language_code": "ml" "language_code": "ml"
}, },
"2-Regression/3-Linear/README.md": { "2-Regression/3-Linear/README.md": {
"original_hash": "40e64f004f3cb50aa1d8661672d3cd92", "original_hash": "9a8359f1945bd3beccccb2b46592580e",
"translation_date": "2025-12-19T13:48:41+00:00", "translation_date": "2026-02-28T10:58:05+00:00",
"source_file": "2-Regression/3-Linear/README.md", "source_file": "2-Regression/3-Linear/README.md",
"language_code": "ml" "language_code": "ml"
}, },
@ -186,8 +186,8 @@
"language_code": "ml" "language_code": "ml"
}, },
"4-Classification/3-Classifiers-2/README.md": { "4-Classification/3-Classifiers-2/README.md": {
"original_hash": "49047911108adc49d605cddfb455749c", "original_hash": "d94438d71164b0ff68002812aed1a8b4",
"translation_date": "2025-12-19T15:23:04+00:00", "translation_date": "2026-02-28T10:58:32+00:00",
"source_file": "4-Classification/3-Classifiers-2/README.md", "source_file": "4-Classification/3-Classifiers-2/README.md",
"language_code": "ml" "language_code": "ml"
}, },
@ -197,12 +197,24 @@
"source_file": "4-Classification/3-Classifiers-2/assignment.md", "source_file": "4-Classification/3-Classifiers-2/assignment.md",
"language_code": "ml" "language_code": "ml"
}, },
"4-Classification/3-Classifiers-2/notebook.ipynb": {
"original_hash": "624ca6cf73d3548ff1b3059e413fa4cd",
"translation_date": "2026-02-28T10:51:21+00:00",
"source_file": "4-Classification/3-Classifiers-2/notebook.ipynb",
"language_code": "ml"
},
"4-Classification/3-Classifiers-2/solution/Julia/README.md": { "4-Classification/3-Classifiers-2/solution/Julia/README.md": {
"original_hash": "a39c15d63f3b2795ee2284a82b986b93", "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T15:37:32+00:00", "translation_date": "2025-12-19T15:37:32+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md", "source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md",
"language_code": "ml" "language_code": "ml"
}, },
"4-Classification/3-Classifiers-2/solution/notebook.ipynb": {
"original_hash": "70f41fe4fd4253adb44cd9d291406e4f",
"translation_date": "2026-02-28T10:51:27+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/notebook.ipynb",
"language_code": "ml"
},
"4-Classification/4-Applied/README.md": { "4-Classification/4-Applied/README.md": {
"original_hash": "61bdec27ed2da8b098cd9065405d9bb0", "original_hash": "61bdec27ed2da8b098cd9065405d9bb0",
"translation_date": "2025-12-19T15:27:17+00:00", "translation_date": "2025-12-19T15:27:17+00:00",
@ -540,8 +552,8 @@
"language_code": "ml" "language_code": "ml"
}, },
"README.md": { "README.md": {
"original_hash": "2f594ee136e3127a47f56d80055227bc", "original_hash": "3a0286e1c4858e79ff54f080dadc1426",
"translation_date": "2026-02-06T09:33:39+00:00", "translation_date": "2026-02-28T10:56:36+00:00",
"source_file": "README.md", "source_file": "README.md",
"language_code": "ml" "language_code": "ml"
}, },

12
translations/ml/1-Introduction/3-fairness/assignment.md
Unescape View File

@ -1,18 +1,18 @@
# ഉത്തരവാദിത്വമുള്ള AI ടൂൾബോക്സ് അന്വേഷിക്കുക # ഉത്തരവാദിത്വമുള്ള AI ടൂള്ബോക്സ് എക്സ്പോൾർ ചെയ്യുക
## നിർദ്ദേശങ്ങൾ ## നിർദ്ദേശങ്ങൾ
ഈ പാഠത്തിൽ നിങ്ങൾ ഉത്തരവാദിത്വമുള്ള AI ടൂൾബോക്സ് എന്നതിനെക്കുറിച്ച് പഠിച്ചു, ഇത് "ഡാറ്റാ സയന്റിസ്റ്റുകൾക്ക് AI സിസ്റ്റങ്ങൾ വിശകലനം ചെയ്ത് മെച്ചപ്പെടുത്താൻ സഹായിക്കുന്ന ഒരു ഓപ്പൺ-സോഴ്‌സ്, കമ്മ്യൂണിറ്റി-നയിച്ച പ്രോജക്ട്" ആണ്. ഈ അസൈൻമെന്റിനായി, RAI Toolbox-ന്റെ [നോട്ട്ബുക്കുകളിൽ](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) ഒന്നിനെ അന്വേഷിച്ച്, അതിൽ നിന്നുള്ള കണ്ടെത്തലുകൾ ഒരു പേപ്പറിൽ അല്ലെങ്കിൽ പ്രეზന്റേഷനിൽ റിപ്പോർട്ട് ചെയ്യുക. ഈ பாடത്തിൽ നിങ്ങൾ ഉത്തരവാദിത്വമുള്ള AI ടൂള്ബോക്സ് എന്നതിനെക്കുറിച്ച് പഠിച്ചു, ഇത് "ഡാറ്റാ സൈന്റിസ്റ്റുകൾക്ക് AI സിസ്റ്റങ്ങൾ വിശകലനം ചെയ്യാനും മെച്ചപ്പെടുത്താനുമുള്ള സഹായത്തിനായി തുറന്നസ്രോതസ്സായ, സമൂഹം നല്കുന്ന ഒരു പ്രോജക്ട്" ആണെന്ന്. ഈ അസൈന്മെന്റിനായി, RAI ടൂള്ബോക്സിന്റെ [നോട്ട്‌ബുക്കുകളിൽ](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/tabular/getting-started.ipynb) ഒന്ന് എക്സ്പ്ലോർ ചെയ്ത്, റിപോർട്ട് അല്ലെങ്കിൽ പ്രезЕНТേഷനിൽ നിങ്ങൾ കണ്ടെത്തിയ കാര്യങ്ങൾ രേഖപ്പെടുത്തുക.
## റൂബ്രിക് ## റൂബ്രിക്
| മാനദണ്ഡം | ഉദാഹരണമായത് | മതിയായത് | മെച്ചപ്പെടുത്തേണ്ടത് | | ക്രൈറ്റീരിയ | ഉദാത്തം | യുക്തമായത് | മെച്ചപ്പെടുത്താൻ ആവശ്യമുണ്ട് |
| -------- | --------- | -------- | ----------------- | | -------- | --------- | -------- | ----------------- |
| | Fairlearn-ന്റെ സിസ്റ്റങ്ങൾ, പ്രവർത്തിപ്പിച്ച നോട്ട്ബുക്ക്, പ്രവർത്തിപ്പിച്ചതിൽ നിന്നുള്ള നിഗമനങ്ങൾ ചർച്ച ചെയ്യുന്ന ഒരു പേപ്പർ അല്ലെങ്കിൽ പവർപോയിന്റ് പ്രეზന്റേഷൻ അവതരിപ്പിക്കുന്നു | നിഗമനങ്ങളില്ലാതെ ഒരു പേപ്പർ അവതരിപ്പിക്കുന്നു | ഒരു പേപ്പർ അവതരിപ്പിക്കുന്നില്ല | | | Fairlearn ന്റെ സിസ്റ്റങ്ങൾ, നടപ്പിലാക്കിയ നോട്ട്‌ബുക്ക്, അത് നടത്തുന്നതിലൂടെ രൂപപ്പെട്ട നിഗമനങ്ങൾ എന്നിവ വിവരിക്കുന്ന പേപ്പർ അല്ലെങ്കിൽ പവർപോയിന്റ് പ്രезЕНТേഷൻ അവതരിപ്പിക്കുന്നു | നിഗമനങ്ങൾ കൂടാതെ ഒരു പേപ്പർ അവതരിപ്പിക്കുന്നു | ഒരു പേപ്പർ അവതരിപ്പിക്കുന്നില്ല |
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**: **അവകാശവാദം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല. ഈ രേഖ [Co-op Translator](https://github.com/Azure/co-op-translator) എന്ന AI പരിഭാഷാ സേവനം ഉപയോഗിച്ച് പരിഭാഷപ്പെടുത്തിയതാണ്. ഞങ്ങൾ ശരിയായതിനു ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പരിഭാഷകൾ പിഴവുകളോ തെറ്റുകളോ ഉള്ളതാകാനിടയുള്ളതു ശ്രദ്ധിക്കുക. നാടൻ ഭാഷയിലുള്ള元സ്ട്രുകശാസഹിയായ രജതവായനാ ഏർപ്പെടുക. നിർണായകമായ വിവരങ്ങൾക്കായി, പ്രൊഫഷണൽ മാനവ പരിഭാഷ ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ പരിഭാഷ ഉപയോഗിച്ചതിൽ നിന്നുള്ള ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ബാധ്യസ്ഥരല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

315
translations/ml/2-Regression/3-Linear/README.md
Unescape View File

@ -1,85 +1,100 @@
# Scikit-learn ഉപയോഗിച്ച് ഒരു റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക: റെഗ്രഷൻ നാല് രീതികൾ # Scikit-learn ഉപയോഗിച്ച് റഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക: റഗ്രഷൻ നാല് വിധങ്ങൾ
![Linear vs polynomial regression infographic](../../../../translated_images/ml/linear-polynomial.5523c7cb6576ccab.webp) ## തുടക്കക്കാരുടെ കുറിപ്പ്
> ഇൻഫോഗ്രാഫിക് [ദസാനി മടിപള്ളി](https://twitter.com/dasani_decoded) tarafından
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
> ### [ഈ പാഠം R-ൽ ലഭ്യമാണ്!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html) ലീനിയർ റഗ്രഷൻ ഉപയോഗിക്കുന്നത് നമ്മൾ ഒരു **സംഖ്യാമാന മൂല്യം** (ഉദാഹരണത്തിന്, വീട് വില, താപനില, അല്ലെങ്കിൽ വിൽപ്പന) പ്രവചിക്കണമെന്ന് ആഗ്രഹിക്കുന്നപ്പോഴാണ്.
### പരിചയം ഇത് ഇൻപുട്ട് ഫീച്ചറുകളും ഔട്ട്‌പുട്ട് തമ്മിലുള്ള ബന്ധത്തെ മികച്ച വിധത്തിൽ പ്രതിനിധാനം ചെയ്യുന്ന ഒരു നേരിയ റേഖ കണ്ടെത്തി പ്രവർത്തിക്കുന്നു.
ഇതുവരെ നിങ്ങൾ റെഗ്രഷൻ എന്താണെന്ന് പംപ്കിൻ വില നിർണ്ണയ ഡാറ്റാസെറ്റിൽ നിന്നുള്ള സാമ്പിൾ ഡാറ്റ ഉപയോഗിച്ച് പരിശോധിച്ചിട്ടുണ്ട്, ഇത് ഈ പാഠത്തിൽ മുഴുവൻ ഉപയോഗിക്കും. നിങ്ങൾ Matplotlib ഉപയോഗിച്ച് അതിനെ ദൃശ്യവൽക്കരിക്കുകയും ചെയ്തു. ഈ പാഠത്തിൽ, കൂടുതൽ പുരോഗമന റഗ്രഷൻ സാങ്കേതികവിദ്യകൾ ഏറെയുള്ളതിന് മുമ്പ് ആശയം മനസിലാക്കുന്നതിൽ ശ്രദ്ധ നൽകുന്നു.
![Linear vs polynomial regression infographic](../../../../translated_images/ml/linear-polynomial.5523c7cb6576ccab.webp)
> ഇൻഫോഗ്രാഫിക്: [ദാസാനി മാടിപള്ളി](https://twitter.com/dasani_decoded)
ഇപ്പോൾ നിങ്ങൾ ML-നുള്ള റെഗ്രഷനിൽ കൂടുതൽ ആഴത്തിൽ പ്രവേശിക്കാൻ തയ്യാറാണ്. ദൃശ്യവൽക്കരണം ഡാറ്റയെ മനസ്സിലാക്കാൻ സഹായിക്കുന്നതിനാൽ, യഥാർത്ഥ മെഷീൻ ലേണിങ്ങിന്റെ ശക്തി _മോഡലുകൾ പരിശീലിപ്പിക്കുന്നതിൽ_ ആണ്. മോഡലുകൾ ചരിത്ര ഡാറ്റയിൽ പരിശീലിപ്പിച്ച് ഡാറ്റ ആശ്രിതത്വങ്ങൾ സ്വയം പിടിച്ചെടുക്കുന്നു, കൂടാതെ മോഡൽ മുമ്പ് കാണാത്ത പുതിയ ഡാറ്റയ്ക്ക് ഫലം പ്രവചിക്കാൻ അനുവദിക്കുന്നു. ## [പഠനത്തിനുമുമ്പ് ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
ഈ പാഠത്തിൽ, നിങ്ങൾ രണ്ട് തരത്തിലുള്ള റെഗ്രഷനുകൾക്കുറിച്ച് കൂടുതൽ പഠിക്കും: _അടിസ്ഥാന ലീനിയർ റെഗ്രഷൻ_യും _പോളിനോമിയൽ റെഗ്രഷൻ_യും, കൂടാതെ ഈ സാങ്കേതികവിദ്യകളുടെ പിന്നിലെ ചില ഗണിതശാസ്ത്രവും. ആ മോഡലുകൾ വിവിധ ഇൻപുട്ട് ഡാറ്റയുടെ അടിസ്ഥാനത്തിൽ പംപ്കിൻ വില പ്രവചിക്കാൻ സഹായിക്കും. > ### [ഈ പാഠം R ൽ ലഭ്യമാണ്!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### ആമുഖം
ഇത്ര വരെ നിങ്ങൾ റഗ്രഷൻ എന്താണെന്ന് പംപ്കിൻ വില dataset ൽ നിന്നുള്ള സാമ്പിൾ ഡാറ്റ ഉപയോഗിച്ച് അന്വേഷിച്ച് കഴിഞ്ഞു. Matplotlib ഉപയോഗിച്ച് അതിനെ ദൃശ്യമാക്കിയിട്ടുണ്ട്.
ഇപ്പോഴിതുവരെ നിങ്ങൾ മെഷീൻ ലേണിംഗിനായി റഗ്രഷനിൽ കൂടുതൽ ആഴത്തിൽ പ്രവേശിക്കാനുള്ള ഒരുക്കത്തിലാണ്. ദൃശ്യമാക്കൽ ഡാറ്റ മനസ്സിലാക്കാനുള്ള ഒരു മാർഗമാണ്, പക്ഷേ യഥാർത്ഥ മെഷീൻ ലേണിംഗ് ശക്തി _മോഡലുകൾ പരിശീലിപ്പിക്കുന്നതിൽ_ ആണ്. മോഡലുകൾ പഴയ ഡാറ്റയിൽ പരിശീലിപ്പിച്ച് സ്വയം ഡാറ്റയുടെ ആശ്രിതത്വങ്ങൾ സുഖാത്മകമായി പിടിച്ച് പൂട്ടുന്നു, പുതിയ ഡാറ്റയ്ക്ക് ഫലങ്ങൾ പ്രവചിക്കാൻ അനുമതിയുണ്ട്, മോഡൽ മുമ്പ് കണ്ടിട്ടില്ലാത്തതുകൊണ്ട്.
ഈ പാഠത്തിൽ, നിങ്ങൾ റഗ്രഷന്റെ രണ്ട് തരങ്ങളുടെ പറ്റി കൂടുതൽ പഠിക്കും: _അടിഭാഗം ലീനിയർ റഗ്രഷൻ_ ഒപ്പം _പോളിനോമിയൽ റഗ്രഷൻ_, ഈ സാങ്കേതികവിദ്യകൾ പിന്തുണയ്ക്കുന്ന ചില ഗണിതവും. ഈ മോഡലുകൾ വഴി വ്യത്യസ്ത ഇൻപുട്ട് ഡാറ്റ അടിസ്ഥാനമാക്കി പംപ്കിൻ വിലകൾ പ്രവചിക്കാം.
[![ML for beginners - Understanding Linear Regression](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression") [![ML for beginners - Understanding Linear Regression](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression")
> 🎥 ലീനിയർ റെഗ്രഷന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിനായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക. > 🎥 ലീനിയർ റഗ്രഷന്റെ സംക്ഷിപ്ത വീഡിയോ അവലോകം കാണാൻ മുകളിലുള്ള ചിത്രം ക്ലിക്ക് ചെയ്യുക.
> ഈ പാഠ്യപദ്ധതിയിൽ, ഗണിതത്തിൽ കുറഞ്ഞ പരിജ്ഞാനം ഉള്ളവർക്കും മറ്റ് മേഖലകളിൽ നിന്നുള്ള വിദ്യാർത്ഥികൾക്കും ഇത് സുലഭമാക്കാൻ ശ്രമിക്കുന്നു, അതിനാൽ കുറിപ്പുകൾ, 🧮 വിളിപ്പുകൾ, ചിത്രങ്ങൾ, മറ്റ് പഠന ഉപകരണങ്ങൾ ശ്രദ്ധിക്കുക. > ഈ പാഠ ക്രമത്തിൽ, ഗണിതത്തിന്റെ അടിസ്ഥാന അറിയിപ്പ് ഉപരിതല രീതിയിൽ കരുതുന്നു, മറ്റ് മേഖലയിലെ വിദ്യാർത്ഥികൾക്ക് പാഠം എളുപ്പത്തിൽ പകർന്നു നൽകാനായി കുറിപ്പുകളും, 🧮 ഗണിത ചൂണ്ടിക്കാണലുകളും, ചിത്രീകരണങ്ങളും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.
### മുൻപരിചയം ### മുൻഅനുഭവം
നിങ്ങൾ ഇപ്പോൾ പരിശോധിക്കുന്ന പംപ്കിൻ ഡാറ്റയുടെ ഘടനയിൽ പരിചിതനാകണം. ഈ പാഠത്തിലെ _notebook.ipynb_ ഫയലിൽ ഇത് മുൻകൂട്ടി ലോഡ് ചെയ്ത് ശുദ്ധീകരിച്ചിരിക്കുന്നു. ഫയലിൽ, പംപ്കിൻ വില ബുഷെൽപ്രതി പുതിയ ഡാറ്റാ ഫ്രെയിമിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നു. Visual Studio Code-ൽ കർണലുകളിൽ ഈ നോട്ട്‌ബുക്കുകൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക. നിങ്ങൾ ഇപ്പോൾ പരിശോദിക്കുന്ന പംപ്കിൻ ഡാറ്റയുടെ ഘടനയെ പരിചിതമാണ്. ഈ പാഠത്തിന്റെ _notebook.ipynb_ ഫയലിൽ ഇത് മുൻകൂട്ടി ലോഡ് ചെയ്തും ശുദ്ധീകരിച്ചും ലഭ്യമാണ്. ഈ ഫയലിൽ പൊതു ബുശെലിനുള്ള പംപ്കിൻ വില പുതിയ ഡാറ്റാഫ്രെയിമിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നു. Visual Studio Code എന്ന കോഡിംഗ് പരിസ്ഥിതിയിൽ നിങ്ങൾക്ക് ഈ നോട്ട്‌ബുക്കുകൾ റൺ ചെയ്യാൻ കഴിയണമെന്ന് ഉറപ്പാക്കുക.
### തയ്യാറെടുപ്പ് ### തയ്യാറെടുപ്പ്
ഓർമ്മപ്പെടുത്തലായി, നിങ്ങൾ ഈ ഡാറ്റ ലോഡ് ചെയ്യുന്നത് അതിൽ നിന്ന് ചോദ്യങ്ങൾ ചോദിക്കാൻ ആണ്. ഓർമപ്പെടുത്തലായി, നിങ്ങൾ ഈ ഡാറ്റ ലോഡ് ചെയ്യുന്നത് അതിൽ നിന്നുള്ള ചോദ്യങ്ങൾ ചോദിക്കാൻ ആണ്.
- പംപ്കിനുകൾ വാങ്ങാൻ ഏറ്റവും നല്ല സമയം എപ്പോൾ?
- ഒരു കേസ് മിനിയേച്ചർ പംപ്കിനുകളുടെ വില എത്ര പ്രതീക്ഷിക്കാം?
- അവയെ അർദ്ധ ബുഷെൽ ബാസ്കറ്റുകളിൽ വാങ്ങണോ, 1 1/9 ബുഷെൽ ബോക്സിൽ വാങ്ങണോ?
നാം ഈ ഡാറ്റയിൽ കൂടുതൽ തിരയാം.
മുൻ പാഠത്തിൽ, നിങ്ങൾ ഒരു Pandas ഡാറ്റാ ഫ്രെയിം സൃഷ്ടിച്ച് അതിൽ യഥാർത്ഥ ഡാറ്റാസെറ്റിന്റെ ഭാഗം ഉൾപ്പെടുത്തി, വില ബുഷെൽപ്രതി സ്റ്റാൻഡേർഡൈസ് ചെയ്തു. എന്നാൽ, അങ്ങനെ ചെയ്തപ്പോൾ, ഏകദേശം 400 ഡാറ്റാപോയിന്റുകൾ മാത്രമേ ലഭിച്ചുള്ളൂ, അത് പോലും പകുതിമാസങ്ങളിൽ മാത്രം. - പംപ്കിനുകൾ വാങ്ങാൻ ഏറ്റവും അനുയോജ്യമായ സമയമ是哪ა?
- മിനിയേച്ചർ പംപ്കിനുകളുടെ ഒരു കേസ് വേണ്ടി എത്ര വില പ്രതീക്ഷിക്കാമെന്നു?
- അതെ, അവ പകുതി-ബുശെൽ ബാസ್ಕೆറ്റുകളിൽ വാങ്ങണോ എനിക്ക്, 1 1/9 ബുശെൽ ബോക്സിൽ വാങ്ങണോ?
ഈ പാഠത്തിലെ അനുബന്ധ നോട്ട്‌ബുക്കിൽ മുൻകൂട്ടി ലോഡ് ചെയ്ത ഡാറ്റ നോക്കുക. ഡാറ്റ മുൻകൂട്ടി ലോഡ് ചെയ്തിട്ടുണ്ട്, ഒരു പ്രാഥമിക സ്കാറ്റർപ്ലോട്ട് മാസത്തെ ഡാറ്റ കാണിക്കാൻ വരച്ചിട്ടുണ്ട്. ഡാറ്റയുടെ സ്വഭാവത്തെ കുറിച്ച് കൂടുതൽ വിശദാംശങ്ങൾ ലഭിക്കാൻ കൂടുതൽ ശുദ്ധീകരണം നടത്താമോ എന്ന് നോക്കാം. നാം ഈ ഡാറ്റയിൽ കൂടുതൽ അവലോകനം തുടരാം.
## ഒരു ലീനിയർ റെഗ്രഷൻ രേഖ മുമ്പത്തെ പാഠത്തിൽ, നിങ്ങൾ Pandas ഡാറ്റാഫ്രെയിം സൃഷ്ടിച്ച് ഭാഗികം യഥാർത്ഥ dataset യിൽ നിന്നുള്ള ഡാറ്റ ഉപയോഗിച്ച് പുഴക്കമില്ലാതെ വില ബുശെൽ അനുപാതത്തിൽ സ്റ്റാന്ററ്ഡൈസ് ചെയ്തു. അതിലൂടെ, ഏകദേശം 400 ഡാറ്റാപോയിന്റുകൾ മാത്രം ശേഖരിക്കാനായി സാധ്യമായി, തേനി മാസങ്ങൾക്കായി മാത്രം.
പാഠം 1-ൽ നിങ്ങൾ പഠിച്ച പോലെ, ഒരു ലീനിയർ റെഗ്രഷൻ അഭ്യാസത്തിന്റെ ലക്ഷ്യം ഒരു രേഖ വരയ്ക്കാനാകണം: ഈ പാഠത്തിനുള്ളൊപ്പം നൽകിയ നോട്ട്‌ബുക്കിൽ മുൻകൂട്ടി ലോഡ് ചെയ്ത ഡാറ്റയും, പ്രതിമാസം ചിത്രീകരിക്കുന്ന സ്കാറ്റർ പ്ലോട്ടും കാണുക. കൂടുതൽ വിശദാംശങ്ങൾ ലഭിക്കാനായി ഡാറ്റ കൂടുതൽ ശുദ്ധീകരിച്ച് പരിശോധിക്കാം.
- **വേരിയബിൾ ബന്ധങ്ങൾ കാണിക്കുക**. വേരിയബിൾകളുടെ ബന്ധം കാണിക്കുക ## ലീനിയർ റഗ്രഷൻ ലൈനുകൾ
- **പ്രവചനങ്ങൾ നടത്തുക**. ആ രേഖയുമായി ബന്ധപ്പെട്ട് പുതിയ ഡാറ്റാപോയിന്റ് എവിടെ വരും എന്ന് കൃത്യമായി പ്രവചിക്കുക.
**ലീസ്റ്റ്-സ്ക്വയർസ് റെഗ്രഷൻ** സാധാരണയായി ഇത്തരത്തിലുള്ള രേഖ വരയ്ക്കുന്നു. 'ലീസ്റ്റ്-സ്ക്വയർസ്' എന്ന പദം അർത്ഥമാക്കുന്നത്, റെഗ്രഷൻ രേഖ ചുറ്റിപ്പറ്റിയ എല്ലാ ഡാറ്റാപോയിന്റുകളും സ്ക്വയർ ചെയ്ത് കൂട്ടിച്ചേർക്കുന്നു എന്നതാണ്. ആകെ തുക όσο ചെറിയതായിരിക്കും, അത്ര നല്ലതാണ്, കാരണം ഞങ്ങൾ കുറവ് പിശകുകൾ (least-squares) ആഗ്രഹിക്കുന്നു. Lesson 1ൽ പഠിച്ചത് പോലെ, ലീനിയർ റഗ്രഷൻ ജനറായി പ്ലോട്ട് ചെയ്യാൻ ഒരു ലൈനാണ് തയ്യാർ ചെയ്യുക:
ഞങ്ങൾ ഒരു രേഖ മോഡൽ ചെയ്യാൻ ആഗ്രഹിക്കുന്നു, അത് എല്ലാ ഡാറ്റാപോയിന്റുകളുടെയും കൂറ്റൻ ദൂരം ഏറ്റവും കുറവായിരിക്കും. കൂടാതെ, ദിശയേക്കാൾ അതിന്റെ വലിപ്പം (മാഗ്നിറ്റ്യൂഡ്) പ്രധാനമാണെന്ന് കണക്കിലെടുത്ത് സ്ക്വയർ ചെയ്യുന്നു. - **വലിയ നിരീക്ഷണങ്ങൾ കാണിക്കുക**. മാറ്റ চলനങ്ങളുടേയും അന്തസുടേയും ബന്ധം വ്യക്തമാക്കുക
- **പ്രവചനങ്ങൾ നടത്തുക**. ആ ലൈനോട് ബന്ധം പുലർത്തുന്ന സ്ഥിതിയിൽ പുതിയ ഡേറ്റാ പോയിന്റ് എവിടെയുണ്ടാകുമെന്ന് ശരിയായി പ്രവചിക്കുക
> **🧮 ഗണിതം കാണിക്കുക** **Least-Squares Regression** പ്രകാരമാണ് ഇത്തരം ലൈനുകൾ വരയ്ക്കുന്നത് സാധാരണ. "Least-Squares" എന്ന പദം മോഡലിലെ മൊത്തം പിശകുകൾ കുറഞ്ഞതാക്കുന്നതിനുള്ള പ്രക്രിയയെ സൂചിപ്പിക്കുന്നു. ഓരോ ഡാറ്റാ പോയിൻറിനും, യഥാർത്ഥ പോയിന്റും റഗ്രഷൻ ലൈനും തമ്മിലുള്ളൻ നിലത്തുള്ള ദൂരം (residual) അളക്കുന്നു.
>
> ഈ രേഖ, _ബെസ്റ്റ് ഫിറ്റ് ലൈന_ എന്ന് വിളിക്കപ്പെടുന്നത്, [ഒരു സമവാക്യത്തിലൂടെ](https://en.wikipedia.org/wiki/Simple_linear_regression) പ്രകടിപ്പിക്കാം:
>
> ```
> Y = a + bX
> ```
>
> `X` 'വ്യാഖ്യാന വേരിയബിൾ' ആണ്. `Y` 'അനുഭവ വേരിയബിൾ' ആണ്. രേഖയുടെ സ്ലോപ്പ് `b` ആണ്, `a` y-ഇന്റർസെപ്റ്റ് ആണ്, അതായത് `X = 0` ആയപ്പോൾ `Y` യുടെ മൂല്യം.
>
>![സ്ലോപ്പ് കണക്കാക്കുക](../../../../translated_images/ml/slope.f3c9d5910ddbfcf9.webp)
>
> ആദ്യം സ്ലോപ്പ് `b` കണക്കാക്കുക. ഇൻഫോഗ്രാഫിക് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper) tarafından
>
> മറ്റൊരു വാക്കിൽ, പംപ്കിൻ ഡാറ്റയുടെ യഥാർത്ഥ ചോദ്യത്തെ ആശ്രയിച്ച്: "മാസംപ്രതി പംപ്കിൻ വില പ്രവചിക്കുക", `X` വിലയെ സൂചിപ്പിക്കും, `Y` വിൽപ്പന മാസത്തെ സൂചിപ്പിക്കും.
>
>![സമവാക്യം പൂർത്തിയാക്കുക](../../../../translated_images/ml/calculation.a209813050a1ddb1.webp)
>
> Y-യുടെ മൂല്യം കണക്കാക്കുക. നിങ്ങൾ ഏകദേശം $4 നൽകുകയാണെങ്കിൽ, അത് ഏപ്രിൽ ആയിരിക്കണം! ഇൻഫോഗ്രാഫിക് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper) tarafından
>
> രേഖയുടെ സ്ലോപ്പ് കണക്കാക്കുന്ന ഗണിതം, ഇന്റർസെപ്റ്റിനും ആശ്രയിച്ചിരിക്കുന്നു, അതായത് `X = 0` ആയപ്പോൾ `Y` എവിടെയാണ് എന്നതും.
>
> ഈ മൂല്യങ്ങൾ കണക്കാക്കുന്ന രീതി [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) വെബ്സൈറ്റിൽ കാണാം. കൂടാതെ [ഈ Least-squares കാൽക്കുലേറ്റർ](https://www.mathsisfun.com/data/least-squares-calculator.html) സന്ദർശിച്ച് സംഖ്യകളുടെ മൂല്യങ്ങൾ രേഖയെ എങ്ങനെ ബാധിക്കുന്നു എന്ന് കാണാം.
## സഹസംബന്ധം ഈ ദൂരങ്ങൾ സ്ക്വയർ ചെയ്യുന്ന രണ്ട് പ്രധാന കാരണങ്ങൾ:
മറ്റൊരു പദം മനസ്സിലാക്കേണ്ടത് **സഹസംബന്ധ കോഫിഷ്യന്റ്** ആണ്, നൽകിയ X, Y വേരിയബിൾക്കിടയിലെ. സ്കാറ്റർപ്ലോട്ട് ഉപയോഗിച്ച് ഈ കോഫിഷ്യന്റ് എളുപ്പത്തിൽ ദൃശ്യവൽക്കരിക്കാം. ഡാറ്റാപോയിന്റുകൾ ഒരു സുതാര്യമായ രേഖയിൽ പടർന്നാൽ ഉയർന്ന സഹസംബന്ധം ഉണ്ട്, എന്നാൽ ഡാറ്റാപോയിന്റുകൾ X, Y-യുടെ ഇടയിൽ എല്ലായിടത്തും പടർന്നാൽ കുറഞ്ഞ സഹസംബന്ധം ഉണ്ട്. 1. **ദിശക്ക് മുകളിലായിരുത്തുക:** -5 പിശകും +5 പിശകും സമാനമായി പരിഗണിക്കണമെന്ന് ആഗ്രഹിക്കുന്നു. സ്ക്വയർ ചെയ്താൽ എല്ലാ മൂല്യങ്ങളും പോസിറ്റീവായി മാറുന്നു.
ഒരു നല്ല ലീനിയർ റെഗ്രഷൻ മോഡൽ, ലീസ്റ്റ്-സ്ക്വയർസ് റെഗ്രഷൻ രീതിയിൽ ഒരു രേഖയുള്ള, ഉയർന്ന (0-നേക്കാൾ 1-നടുത്തുള്ള) സഹസംബന്ധ കോഫിഷ്യന്റ് ഉള്ളതാണ്. 2. **അപവാദങ്ങളോട് കരുതലോടെ ഉണ്ടായിരിക്കുക:** വലിയ പിശകുകൾക്ക് കൂടുതൽ ഭാരമാണ് സ്ക്വയർ ചെയ്തപ്പോൾ ലഭിക്കുക, അതിനാൽ അകലെയുള്ള പോയിന്റുകളെ líne അടുത്തുനിർത്താൻ ഉദ്ദേശിക്കുന്നു.
✅ ഈ പാഠത്തോടനുബന്ധിച്ച നോട്ട്‌ബുക്ക് പ്രവർത്തിപ്പിച്ച് മാസവും വിലയും തമ്മിലുള്ള സ്കാറ്റർപ്ലോട്ട് നോക്കുക. പംപ്കിൻ വിൽപ്പനയിൽ മാസവും വിലയും തമ്മിലുള്ള ഡാറ്റയ്ക്ക് നിങ്ങളുടെ ദൃശ്യവിവരണപ്രകാരം ഉയർന്നോ കുറഞ്ഞോ സഹസംബന്ധം ഉണ്ടോ? `Month` പകരം കൂടുതൽ സൂക്ഷ്മമായ അളവ് (ഉദാ: വർഷത്തിലെ ദിവസം) ഉപയോഗിച്ചാൽ അത് മാറുമോ? അങ്ങനെ ഈ സ്ക്വയർ ചെയ്ത മൂല്യങ്ങളെല്ലാം കൂടി കൂട്ടുന്നു. ഏറ്റവും കുറഞ്ഞ മൊത്തം പൂജ്യം നൽകുന്ന പ്രത്യേക ലൈനാണ് കണ്ടെത്തുന്നത്, അതുകൊണ്ടുതന്നെ "Least-Squares" എന്ന് പേര്.
താഴെ കൊടുത്തിരിക്കുന്ന കോഡിൽ, ഡാറ്റ ശുദ്ധീകരിച്ചുവെന്ന് കരുതി, `new_pumpkins` എന്ന ഡാറ്റാ ഫ്രെയിം ലഭിച്ചിരിക്കുന്നു, താഴെപറയുന്ന പോലെ: > **🧮 ഗണിതം കാണിക്കൂ**
>
> ഈ ലൈനിനെ _ഉത്തമമായ അനുയോജ്യമായ ലൈന_ എന്ന് കൂടി പറയുന്നു, ഇതിനെ [സൂത്രവാക്യം](https://en.wikipedia.org/wiki/Simple_linear_regression) വഴി പ്രകടിപ്പിക്കാം:
>
> ```
> Y = a + bX
> ```
>
> `X` എന്നത് 'വ്യാഖ്യാനചിഹ്നം' (explanatory variable) ആണ്. `Y` എന്നത് 'ആശ്രിത ചര' (dependent variable) ആണ്. ലൈന്റെ സ്ലോപ്പ് `b` ആണ്, `a` എന്നത് y-ഇന്റർസെപ്റ്റ് ആണ്, അതായത് `X = 0` ആയപ്പോൾ `Y` യുടെ മൂല്യം.
>
> ![calculate the slope](../../../../translated_images/ml/slope.f3c9d5910ddbfcf9.webp)
>
> ആദ്യം സ്ലോപ്പ് `b` കണക്കാക്കുക. ഇൻഫോഗ്രാഫിക്: [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper)
>
> മറ്റൊരു ഭാഷയിൽ പറഞ്ഞാൽ, നമ്മുടെ പംപ്കിൻ ഡാറ്റയുടെ അടിസ്ഥാന ചോദ്യത്തിന്: "മാസം അനുസരിച്ച് ബുശെലിന് പംപ്കിന്റെ വില പ്രവചിക്കുക", `X` വിലയെ സൂചിപ്പിക്കും, `Y` വിൽപ്പനയുള്ള മാസം.
>
> ![complete the equation](../../../../translated_images/ml/calculation.a209813050a1ddb1.webp)
>
> Y വാല്യൂ കണക്കാക്കുക. നിങ്ങൾക്ക് $4 ന് ചുറ്റും നൽകുന്നുവെങ്കിൽ അത് ഏപ്രിലായിരിക്കണം! ഇൻഫോഗ്രാഫിക്: [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper)
>
> ലൈൻ കണക്കാക്കുന്ന ഗണിതം തന്നെ സ്ലോപ്പ് മത്സ്യവും y-ഇന്റർസെപ്റ്റ് സൂചിപ്പിക്കുന്നതു്, ഇപ്പോൾ `X = 0` ആണെങ്കിൽ `Y` എവിടെയാണെന്ന്.
>
> ഈ മൂല്യങ്ങൾ കണക്കാക്കുന്ന രീതി നിങ്ങൾ [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) വെബ്സൈറ്റിൽ കാണാം. കൂടാതെ [Least-squares കാൽക്കുലേറ്റർ](https://www.mathsisfun.com/data/least-squares-calculator.html) സന്ദർശിച്ച് എങ്ങനെ മൂല്യങ്ങൾ ലൈനിനെ സ്വാധീനിക്കുന്നു എന്ന് കാണാം.
## കോറിലേഷൻ
ഒരു മത്സ്യ മനസ്സിലാക്കാനുള്ള മറ്റൊരു പദമാണ് **Correlation Coefficient** രണ്ട് 변수 X, Y നുള്ളത്.
സ്കാറ്റർപ്ലോട്ടിലൂടെ ഈ കോഫീഷ്യന്റ് ഉടനെ ദൃശ്യമായാക്കാം. ഒരു ലൈൻ പോലെ നന്നായി കൃത്യമായ പോയിന്റുകൾ ഉള്ള പ്ലോട്ട് ഉയർന്ന കോറിലേഷൻ കാണിക്കും, പക്ഷേ X, Y തമ്മിൽ പായൽപോയ എല്ലായിടത്തും പൊടിപോയ പോയിന്റുകൾ ഉള്ള പ്ലോട്ട് താഴ്ന്ന കോറിലേഷൻ കാണിക്കും.
ഒരു മികച്ച ലീനിയർ റഗ്രഷൻ മോഡൽ **ഉയർന്ന (0 നുള്ളിൽ 1-ന് അടുത്തുള്ള)** Correlation Coefficient ഉം ഒരേ റഗ്രഷൻ ലൈനും Least-Squares regression ഉപയോഗിച്ചുള്ളതും ആയിരിക്കും.
✅ ഈ പാഠം കൂടെ നൽകിയ നോട്ട്‌ബുക്ക് റൺ ചെയ്ത്, മാസംനും വിലയും ഉള്ള സ്കാറ്റർപ്ലോട്ടിനെ കാണുക. പംപ്കിൻ വിൽപ്പനയുടെ മാസം വിലക്കിടയിലുള്ള ഡാറ്റ ഉയർന്ന കോറിലേഷൻ കാണിക്കുന്നുണ്ടോ എങ്കിൽ താഴ്ന്നതാണോ എന്നറിയാമോ? ആ കോർലേഷൻ `മാസം` പകരം *വർഷത്തിലെ ദിവസം* (ആരംഭം മുതൽ ദിവസങ്ങളുടെ സംഖ്യ) ആയി finer measure ആയി എടുത്താൽ മാറ്റം ഉണ്ടാകുമോ?
താഴെയുള്ള കോഡിൽ നമുക്ക് ഡാറ്റ ശുദ്ധീകരിച്ചിരിക്കുന്നുവെന്ന് കരുതാം, ഈ പദ്സ്യൂപം ഡാറ്റാഫ്രെയിം ഞങ്ങൾ ലഭിച്ചു, `new_pumpkins` എന്ന പേരിൽ, താഴെപോലെ:
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
---|-------|-----------|---------|------|---------|-----------|------------|------- ---|-------|-----------|---------|------|---------|-----------|------------|-------
@ -89,36 +104,36 @@ ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Pri
73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545 73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545
74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364 74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
> ഡാറ്റ ശുദ്ധീകരിക്കുന്ന കോഡ് [`notebook.ipynb`](notebook.ipynb) ൽ ലഭ്യമാണ്. മുൻ പാഠത്തിലെ പോലെ തന്നെ ശുദ്ധീകരണ നടപടികൾ നടന്നു, കൂടാതെ `DayOfYear` കോളം താഴെപ്പറയുന്ന പ്രകടനത്തിലൂടെ കണക്കാക്കി: > ഡാറ്റ ശുദ്ധീകരിക്കുന്ന കോഡ് [`notebook.ipynb`](notebook.ipynb) ല് ലഭ്യമാണ്. കഴിഞ്ഞ പാഠത്തിലെ പോലെ തന്നെ ഡാറ്റ ശുദ്ധീകരണ നടപടികൾ ചെയ്തിരിക്കുന്നു, കൂടാതെ താഴെപറയുന്ന ഘടകം ഉപയോഗിച്ചും `DayOfYear` കോളം കണക്കാക്കി:
```python ```python
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days) day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
``` ```
ഇപ്പോൾ ലീനിയർ റഗ്രഷന്റെ പിന്നിലുള്ള ഗണിതം മനസ്സിലാക്കി, നാം ഒരു Regression മോഡൽ സൃഷ്ടിക്കാം, ഏത് പംപ്കിൻ പാക്കേജ് ഏറ്റവും നല്ല വില നൽകുമെന്ന് പ്രവചിക്കാൻ സഹായിക്കും. ഒരു ഉത്സവത്തിനായി പംപ്കിൻ വാങ്ങുന്നവർക്കു ഇത് അവരുടെ വാങ്ങേണ്ട പംപ്കിൻ പാക്കേജുകൾ പരമാവധി ഉപയോഗപ്പെടുത്താൻ സഹായിക്കും.
ലീനിയർ റെഗ്രഷന്റെ പിന്നിലെ ഗണിതം മനസ്സിലാക്കിയതിനു ശേഷം, പംപ്കിൻ പാക്കേജുകളുടെ വില ഏറ്റവും നല്ലത് ഏതാണ് എന്ന് പ്രവചിക്കാൻ ഒരു റെഗ്രഷൻ മോഡൽ സൃഷ്ടിക്കാം. അവധി പംപ്കിൻ പാച്ചിനായി പംപ്കിനുകൾ വാങ്ങുന്നവർക്ക് ഈ വിവരം അവരുടെ വാങ്ങലുകൾ മെച്ചപ്പെടുത്താൻ സഹായിക്കും. ## കോറിലേഷൻ തേടുക
## സഹസംബന്ധം അന്വേഷിക്കൽ
[![ML for beginners - Looking for Correlation: The Key to Linear Regression](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression") [![ML for beginners - Looking for Correlation: The Key to Linear Regression](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression")
> 🎥 സഹസംബന്ധത്തിന്റെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിനായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക. > 🎥 കോറിലേഷൻ പറ്റി ചെറിയ വീഡിയോ അവലോകം കാണാൻ മുകളിലുള്ള ചിത്രം ക്ലിക്ക് ചെയ്യുക.
മുൻ പാഠത്തിൽ നിങ്ങൾ കണ്ടതുപോലെ, വ്യത്യസ്ത മാസങ്ങളിലെ ശരാശരി വില ഇങ്ങനെ കാണപ്പെടുന്നു: മുമ്പത്തെ പാഠത്തിൽ, വേറിട്ട മാസങ്ങളിലെ ശരാശരി വില ഇങ്ങനെ കാണിച്ചിട്ടുണ്ട്:
<img alt="Average price by month" src="../../../../translated_images/ml/barchart.a833ea9194346d76.webp" width="50%"/> <img alt="Average price by month" src="../../../../translated_images/ml/barchart.a833ea9194346d76.webp" width="50%"/>
ഇത് ചില സഹസംബന്ധം ഉണ്ടാകുമെന്ന് സൂചിപ്പിക്കുന്നു, നാം ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിച്ച് `Month`-നും `Price`-നും ഇടയിലുള്ള ബന്ധം പ്രവചിക്കാം, അല്ലെങ്കിൽ `DayOfYear`-നും `Price`-നും ഇടയിലുള്ള ബന്ധം. താഴെ കാണുന്ന സ്കാറ്റർപ്ലോട്ട് രണ്ടാം ബന്ധം കാണിക്കുന്നു: ഇത് ഏതാനും കോറിലേഷൻ ഉണ്ടായിരിക്കാമെന്നു സൂചിപ്പിക്കുന്നു, നാം പാഠം റഗ്രഷൻ മോഡൽ പരിശീലിപ്പിച്ച് `Month`-നും `Price`-നും ഇടയിലുള്ള ബന്ധം പ്രവചിക്കാം, അല്ലെങ്കിൽ `DayOfYear`-നും `Price`-നും ഇടയിലുള്ള ബന്ധം. താഴെയുള്ള സ്കാറ്റർ പ്ലോട്ട് ഇരട്ട ബന്ധം കാണിക്കുന്നു:
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/ml/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" /> <img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/ml/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
`corr` ഫംഗ്ഷൻ ഉപയോഗിച്ച് സഹസംബന്ധം പരിശോധിക്കാം: `corr` ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഇതെന്ത് കോറലേഷൻ ആണെന്ന് നോക്കാം:
```python ```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price'])) print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price'])) print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
``` ```
സഹസംബന്ധം വളരെ ചെറിയതാണ്, `Month`-നായി -0.15, `DayOfMonth`-നായി -0.17, എന്നാൽ മറ്റൊരു പ്രധാന ബന്ധം ഉണ്ടാകാം. വ്യത്യസ്ത പംപ്കിൻ വർഗ്ഗങ്ങൾക്ക് വ്യത്യസ്ത വില ക്ലസ്റ്ററുകൾ ഉണ്ടെന്ന് തോന്നുന്നു. ഈ സിദ്ധാന്തം സ്ഥിരീകരിക്കാൻ, ഓരോ പംപ്കിൻ വിഭാഗവും വ്യത്യസ്ത നിറത്തിൽ സ്കാറ്റർ പ്ലോട്ട് ചെയ്യാം. `scatter` ഫംഗ്ഷനിൽ `ax` പാരാമീറ്റർ നൽകി എല്ലാ പോയിന്റുകളും ഒരേ ഗ്രാഫിൽ വരയ്ക്കാം: `Month`ൽ -0.15, `DayOfMonth`ൽ -0.17 എന്ന് വളരെ ഇളം കോറിലേഷൻ പോലെയാണ് കാണുന്നത്, എന്നാൽ മറ്റൊരു പ്രധാന ബന്ധം ഉണ്ടായിരിക്കും എങ്കിൽ. വില വ്യത്യാസപ്പെടുന്ന പല വർണ്ണങ്ങൾ ഉള്ള പരമ്പരകളാണെന്നു കാണാം. ഈ ആശയം സ്ഥിരീകരിക്കാൻ, ഓരോ പംപ്കിൻ വർഗ്ഗത്തെയും വേറിട്ട നിറത്തിൽ ചിത്രീകരിക്കാം. `ax` പാരാമീറ്റർ `scatter` ഫംഗ്ഷനിലേക്ക് കൊടുക്കുമ്പോൾ എല്ലാ പോയിന്റുകളും ഒരേ ഗ്രാഫിൽ വരയ്ക്കാം.
```python ```python
ax=None ax=None
@ -127,74 +142,76 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
df = new_pumpkins[new_pumpkins['Variety']==var] df = new_pumpkins[new_pumpkins['Variety']==var]
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var) ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
``` ```
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/ml/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" /> <img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/ml/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
നമ്മുടെ പരിശോധന പ്രകാരം, പംപ്കിൻ വർഗ്ഗം വിൽപ്പന തീയതിയേക്കാൾ വിലയിൽ കൂടുതൽ സ്വാധീനം ചെലുത്തുന്നു. ഇത് ഒരു ബാർ ഗ്രാഫിൽ കാണാം: നമ്മുടെ പരിശോധനാ വിവരമനുസരിച്ചു, വർഗ്ഗം വിലയിൽ തികച്ചും ഫലപ്രദമാണ്, ഉയർന്ന വിലയുടെ മറ്റു വകുപ്പുകളേക്കാൾ മാസത്തിൻ്റെ സ്വാധീനം കുറവാണ് എന്ന് കാണാം. ഇത് ഒരു ബാർ ഗ്രാഫിലും വ്യക്തമാക്കാം:
```python ```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar') new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
``` ```
<img alt="Bar graph of price vs variety" src="../../../../translated_images/ml/price-by-variety.744a2f9925d9bcb4.webp" width="50%" /> <img alt="Bar graph of price vs variety" src="../../../../translated_images/ml/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
ഇപ്പോൾ നാം 'പൈ ടൈപ്പ്' എന്ന ഒരു പംപ്കിൻ വർഗ്ഗത്തിൽ മാത്രം ശ്രദ്ധ കേന്ദ്രീകരിച്ച്, തീയതി വിലയിൽ എങ്ങനെ സ്വാധീനം ചെലുത്തുന്നു എന്ന് നോക്കാം: നാം ഒരു പ്രത്യേക പംപ്കിൻ വർഗ്ഗം മാത്രമേ ഇപ്പോൾ ശ്രദ്ധിക്കൂ, 'പൈ തരം' (pie type), കാണാം ദിവസത്തിന്റെ വിലയിൽ എന്ത് സ്വാധീനം ഉണ്ട്:
```python ```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE'] pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price') pie_pumpkins.plot.scatter('DayOfYear','Price')
``` ```
<img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/ml/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" /> <img alt="Scatter plot of Price vs. Day of Year" src="../../../../translated_images/ml/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
`Price`-നും `DayOfYear`-നും ഇടയിലെ സഹസംബന്ധം `corr` ഫംഗ്ഷൻ ഉപയോഗിച്ച് കണക്കാക്കുമ്പോൾ, ഏകദേശം `-0.27` കിട്ടും - ഇത് പ്രവചന മോഡൽ പരിശീലിപ്പിക്കുന്നത് യുക്തിയുള്ളതാണെന്ന് സൂചിപ്പിക്കുന്നു. ഇപ്പോൾ `Price`-നും `DayOfYear`-നും `corr` ഫംഗ്ഷൻ ഉപയോഗിച്ച് കോറലേഷനെ കണക്കാക്കി നോക്കിയാൽ `-0.27` പോലെയാകും, അതായത് പ്രവചന മോഡൽ പരിശീലിപ്പിക്കുന്നത് അർത്ഥവത്താണ്.
> ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കുന്നതിന് മുമ്പ്, ഡാറ്റ ശുദ്ധമാണെന്ന് ഉറപ്പാക്കുക. ലീനിയർ റെഗ്രഷൻ നഷ്ടപ്പെട്ട മൂല്യങ്ങളോടൊപ്പം നല്ല രീതിയിൽ പ്രവർത്തിക്കാറില്ല, അതിനാൽ എല്ലാ ശൂന്യ സെല്ലുകളും നീക്കം ചെയ്യുന്നത് ഉചിതമാണ്: > ലീനിയർ റഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കുന്നതിന് മുമ്പ്, ഡാറ്റ ശുദ്ധമാണെന്ന് സ്ഥിരീകരിക്കുക വളരെ പ്രധാനമാണ്. ലീനിയർ റഗ്രഷൻ പതിവായി നഷ്ടപ്പെട്ട മൂല്യങ്ങളുള്ള ഡാറ്റയിൽ മോശമായി പ്രവർത്തിക്കുന്നു, അതിനാൽ ശൂന്യമായ സെല്ലുകൾ നീക്കംചെയ്യേണ്ടതാണ്:
```python ```python
pie_pumpkins.dropna(inplace=True) pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info() pie_pumpkins.info()
``` ```
മറ്റ് സമീപനം, ആ ശൂന്യ മൂല്യങ്ങളെ ആ കോളത്തിലെ ശരാശരി മൂല്യത്തോടെ പകരം നല്കുക തന്നെയാണ്.
മറ്റൊരു സമീപനം, ആ ശൂന്യ മൂല്യങ്ങളെ അനുയോജ്യമായ കോളത്തിന്റെ ശരാശരി മൂല്യത്തോടെ പൂരിപ്പിക്കലായിരിക്കും. ## സിംപിൾ ലീനിയർ റഗ്രഷൻ
## ലളിത ലീനിയർ റെഗ്രഷൻ
[![ML for beginners - Linear and Polynomial Regression using Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn") [![ML for beginners - Linear and Polynomial Regression using Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn")
> 🎥 ലീനിയർ, പോളിനോമിയൽ റെഗ്രഷൻ എന്നിവയുടെ ഒരു ചുരുക്ക വീഡിയോ അവലോകനത്തിനായി മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക. > 🎥 ലീനിയർ, പോളിനോമിയൽ റഗ്രഷൻ സംക്ഷിപ്ത വീഡിയോ കാണാൻ മുകളിലുള്ള ചിത്രം ക്ലിക്ക് ചെയ്യുക.
നമ്മുടെ ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കാൻ, **Scikit-learn** ലൈബ്രറി ഉപയോഗിക്കും. ലീനിയർ റഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കാൻ നമ്മൾ **Scikit-learn** ലൈബ്രറി ഉപയോഗിക്കും.
```python ```python
from sklearn.linear_model import LinearRegression from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split from sklearn.model_selection import train_test_split
``` ```
ആദ്യമായി, ഇൻപുട്ട് മൂല്യങ്ങൾ (ഫീച്ചറുകൾ)യും പ്രതീക്ഷിക്കുന്ന ഔട്ട്പുട്ട് (ലേബൽ)യും വേർതിരിച്ച് numpy അറേകളായി മാറ്റുന്നു: നാം ആദ്യം ഇൻപുട്ട് മൂല്യങ്ങൾ (ഫീച്ചറുകൾ) അതേ സമയം പ്രതീക്ഷിക്കുന്ന ഔട്ട്‌പുട്ട് (ലേബൽ) numpy അരേയിലായി വേർതിരിക്കുന്നു:
```python ```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1) X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price'] y = pie_pumpkins['Price']
``` ```
> ഇൻപുട്ട് ഡാറ്റ പാക്കേജ് ശരിയായി മനസ്സിലാക്കാൻ `reshape` നടത്തേണ്ടതുണ്ടെന്ന് ശ്രദ്ധിക്കുക. ലീനിയർ റഗ്രഷൻ 2D അരേ കണ്ടു കേൾക്കാൻ ആഗ്രഹിക്കുന്നു, ഓരോ റോ ഡാറ്റാ സജ്ജീവങ്ങളുള്ള ഫീച്ചറുകളുടെ വെക്റ്ററാണ്. ഇന്നത്തെ അവസരത്തിൽ, നമ്മുടെ ഇൻപുട്ട് ഒറ്റ ഫീച്ചറിനെയാണ്, അതിനാൽ N×1 രൂപത്തിലുള്ള അരേയുണ്ടു, N dataset വലിപ്പം.
> ലീനിയർ റെഗ്രഷൻ പാക്കേജ് ശരിയായി മനസ്സിലാക്കാൻ ഇൻപുട്ട് ഡാറ്റയിൽ `reshape` നിർബന്ധമായിരുന്നു. ലീനിയർ റെഗ്രഷൻ 2D അറേയെ ഇൻപുട്ടായി പ്രതീക്ഷിക്കുന്നു, ഓരോ വരിയും ഇൻപുട്ട് ഫീച്ചറുകളുടെ വെക്ടറിനോട് അനുബന്ധിക്കുന്നു. നമ്മുടെ കേസിൽ, ഒരു ഇൻപുട്ട് മാത്രമുണ്ടെങ്കിൽ, N×1 ആകൃതിയിലുള്ള അറേ വേണം, ഇവിടെ N ഡാറ്റാസെറ്റിന്റെ വലുപ്പമാണ്. അതിനുശേഷം ഡാറ്റ പരിശീലനത്തിനും പരിശോധനയ്ക്കുമായി train-test സെറ്റുകളായി വേർതിരിക്കും:
അതിനുശേഷം, ഡാറ്റ ട്രെയിൻ, ടെസ്റ്റ് ഡാറ്റാസെറ്റുകളായി വിഭജിക്കണം, മോഡൽ പരിശീലിപ്പിച്ചതിനു ശേഷം അത് പരിശോധിക്കാൻ:
```python ```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
``` ```
അവസാനമായി, ലീനിയർ റെഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കുന്നത് രണ്ട് കോഡ് വരികളിൽ മാത്രമാണ്. `LinearRegression` ഒബ്ജക്റ്റ് നിർവചിച്ച്, `fit` മെത്തഡ് ഉപയോഗിച്ച് ഡാറ്റയിൽ ഫിറ്റ് ചെയ്യുന്നു: അവസാനത്തിൽ, യഥാർത്ഥ ലീനിയർ റഗ്രഷൻ മോഡൽ പരിശീലിപ്പിക്കുന്നത് രണ്ട് കോഡ് വരികളിൽ മാത്രമേ എടുക്കൂ. `LinearRegression` ഒബ്‌ജക്ട് നിർവ്വചിച്ച്, `fit` മെതഡിലൂടെ ഡാറ്റയിൽ ഇതിനെ നിന്നും ഫിറ്റ് ചെയ്യുക:
```python ```python
lin_reg = LinearRegression() lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train) lin_reg.fit(X_train,y_train)
``` ```
`fit` ചെയ്ത ശേഷം `LinearRegression` ഒബ്ജക്റ്റിൽ റെഗ്രഷന്റെ എല്ലാ കോഫിഷ്യന്റുകളും `.coef_` പ്രോപ്പർട്ടി വഴി ലഭ്യമാണ്. നമ്മുടെ കേസിൽ, ഏക കോഫിഷ്യന്റ് മാത്രമേ ഉണ്ടാകൂ, ഏകദേശം `-0.017`. ഇത് വിലകൾ സമയം കൂടുമ്പോൾ കുറയുന്നു എന്ന് സൂചിപ്പിക്കുന്നു, ഏകദേശം ദിവസത്തിൽ 2 സെന്റ്. Y-അക്ഷത്തോടുള്ള റെഗ്രഷൻ രേഖയുടെ ഇന്റർസെപ്റ്റ് `lin_reg.intercept_` ഉപയോഗിച്ച് ലഭിക്കും - ഇത് ഏകദേശം `21` ആയിരിക്കും, വർഷം ആരംഭത്തിലെ വില സൂചിപ്പിക്കുന്നു. `LinearRegression` ഓബ്രക്റ്റ് `fit`-ചെയ്‌തതിന് ശേഷം റെഗ്രഷന്റെ എല്ലാ കോഫിഷ്യന്റുകളും അടങ്ങിയിരിക്കും, അവ `.coef_` പ്രോപ്പർട്ടി വഴി ആക്സസ് ചെയ്യാവുന്നതാണ്. നമ്മുടെ കേസിൽ ഒരു കോഫിഷ്യന്റ് മാത്രമേ ഉണ്ടാകൂ, അത് ഏകദേശം `-0.017` ആയിരിക്കണം. ഇത് അതായത് വിലകൾ സമയത്തിന് അനുബന്ധിച്ച് കുറച്ചുകുറച്ച് കുറഞ്ഞേക്കാം, പക്ഷെ അത്രയും കൂടുതലല്ല, ദിവസം ഏകദേശം 2 സെന്റുകൾക്കു ചുറ്റും. Y-അക്സിസുമായുള്ള റെഗ്രഷന്റെ ഇന്റേഴ്‌സെക്ഷൻ പോയിന്റ് `lin_reg.intercept_` ഉപയോഗിച്ച് ആക്സസ് ചെയ്യാമെന്നാണ്, ഇത് നമ്മുടെ കേസിൽ ഏകദേശം `21` ആയിരിക്കും, വർഷത്തിന്റെ തുടക്കത്തിലെ വില സൂചിപ്പിക്കുന്നു.
നമ്മുടെ മോഡൽ എത്രത്തോളം കൃത്യമാണെന്ന് കാണാൻ, നാം ഒരു ടെസ്റ്റ് ഡാറ്റാസെറ്റിൽ വിലകൾ പ്രവചിച്ച്, പിന്നീട് നമ്മുടെ പ്രവചനങ്ങൾ പ്രതീക്ഷിച്ച മൂല്യങ്ങളോട് എത്രത്തോളം അടുത്തുവെന്ന് അളക്കാം. ഇത് ചെയ്യാൻ സാധിക്കുന്നത് മീൻ സ്ക്വയർ എറർ (MSE) മെട്രിക്‌സ് ഉപയോഗിച്ച് ആണ്, ഇത് പ്രതീക്ഷിച്ച മൂല്യവും പ്രവചിച്ച മൂല്യവും തമ്മിലുള്ള എല്ലാ സ്ക്വയർ ചെയ്ത വ്യത്യാസങ്ങളുടെ ശരാശരിയാണ്.
നമ്മുടെ മോഡൽ എത്രത്തോളം ആക്വറേറ്റ് ആണെന്ന് കാണാൻ, ടെസ്റ്റ് ഡാറ്റാസെറ്റിൽ വിലകൾ പ്രവചിച്ച്, പ്രതീക്ഷിച്ച മൂല്യങ്ങളോട് നമ്മുടെ പ്രവചനങ്ങൾ എത്രത്തോളം അടുത്താണ് എന്ന് അളക്കാം. ഇത് ഗണിക്കുവാൻ മീൻ സ്ക്വയർ എറർ (MSE) മെട്രിക് ഉപയോഗിക്കാം, ഇത് പ്രതീക്ഷിച്ചയും പ്രവചിച്ചതും തമ്മിലുള്ള എല്ലാ സ്ക്വയർ ചെയ്ത വ്യത്യാസങ്ങളുടെ ശരാശരിയാണ്.
```python ```python
pred = lin_reg.predict(X_test) pred = lin_reg.predict(X_test)
@ -202,38 +219,38 @@ pred = lin_reg.predict(X_test)
mse = np.sqrt(mean_squared_error(y_test,pred)) mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)') print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
``` ```
നമ്മുടെ പിശക് ഏകദേശം 2 പോയിന്റ് ചുറ്റും ആണ്, അത് ~17% ആണ്. വളരെ നല്ലതല്ല. മോഡൽ ഗുണനിലവാരത്തിന്റെ മറ്റൊരു സൂചികയാണ് **നിർണ്ണയ ഘടകം** (coefficient of determination), ഇത് ഇങ്ങനെ ലഭിക്കും: നമ്മുടെ തകരാറ് ഏകദേശം 2 പോയിന്റുകൾക്കു ചുറ്റും ആണ്, അത് ~17% ചെലവാണ്. അത്ര നല്ലതല്ല. മോഡലിന്റെ ഗുണനിലവാരത്തിന്റെ മറ്റൊരു സൂചികയാണ് **ദേറ്റർമിനേഷൻ കോഫിഷ്യന്റ്** (coefficient of determination), ഇത് ഇങ്ങനെ ലഭിക്കും:
```python ```python
score = lin_reg.score(X_train,y_train) score = lin_reg.score(X_train,y_train)
print('Model determination: ', score) print('Model determination: ', score)
``` ```
മൂല്യം 0 ആണെങ്കിൽ, അത് മോഡൽ ഇൻപുട്ട് ഡാറ്റ കണക്കിലെടുത്ത് പ്രവൃത്തി ചെയ്യാത്തതാണെന്ന് വ്യക്തമാക്കുന്നു, അതായത് *ഏറ്റവും മോശം ലീനിയർ പ്രവചകൻ* പോലെ പ്രവർത്തിക്കുന്നു, ഇത് ഫലം കണക്കാക്കുന്ന ശരാശരിയാണ്. മൂല്യം 1 ആണെങ്കിൽ, എല്ലാ പ്രതീക്ഷിച്ച ഔട്ട്പുട്ടുകളും പൂർണ്ണമായും കൃത്യമായി പ്രവചിക്കാം എന്നർത്ഥം. നമ്മുടെ കേസിൽ, കോഫിഷ്യന്റ് ഏകദേശം 0.06 ആയിട്ടാണ്, ഇത് വളരെ കുറഞ്ഞതാണെന്ന് 의미ം.
മൂല്യം 0 ആണെങ്കിൽ, മോഡൽ ഇൻപുട്ട് ഡാറ്റ പരിഗണിക്കാതെ *ഏറ്റവും മോശം ലീനിയർ പ്രവചകൻ* ആയി പ്രവർത്തിക്കുന്നു, അത് ഫലത്തിന്റെ ശരാശരിയാണ്. മൂല്യം 1 ആണെങ്കിൽ, നാം എല്ലാ പ്രതീക്ഷിച്ച ഔട്ട്പുട്ടുകളും പൂർണ്ണമായി പ്രവചിക്കാനാകും. നമ്മുടെ കേസിൽ, നിർണ്ണയ ഘടകം ഏകദേശം 0.06 ആണ്, ഇത് വളരെ കുറവാണ്. റെഗ്രഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് നന്നായി കാണാൻ ടെസ്റ്റ് ഡാറ്റയും റെഗ്രഷൻ വരും ചേർന്ന് പ്ലോട്ട് ചെയ്യാം:
റിഗ്രഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് നന്നായി കാണാൻ, ടെസ്റ്റ് ഡാറ്റയും റിഗ്രഷൻ ലൈനും ചേർന്ന് പ്ലോട്ട് ചെയ്യാം:
```python ```python
plt.scatter(X_test,y_test) plt.scatter(X_test,y_test)
plt.plot(X_test,pred) plt.plot(X_test,pred)
``` ```
<img alt="Linear regression" src="../../../../translated_images/ml/linear-results.f7c3552c85b0ed1c.webp" width="50%" /> <img alt="Linear regression" src="../../../../translated_images/ml/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
## പോളിനോമിയൽ റിഗ്രഷൻ ## പൊളിനോമിയൽ റെഗ്രഷൻ
ലീനിയർ റിഗ്രഷന്റെ മറ്റൊരു തരം പോളിനോമിയൽ റിഗ്രഷനാണ്. ചിലപ്പോൾ വേരിയബിളുകൾക്കിടയിൽ ലീനിയർ ബന്ധമുണ്ടാകാം - വോളിയം കൂടുതലായ പംപ്കിൻ വില കൂടുതലായിരിക്കും - എന്നാൽ ചിലപ്പോൾ ഈ ബന്ധങ്ങൾ ഒരു സമതലമോ നേരിയ ലൈനോ ആയി ചിത്രീകരിക്കാൻ കഴിയില്ല. ലീനിയർ റെഗ്രഷന്റെ മറ്റൊരു തരമാണ് പൊളിനോമിയൽ റെഗ്രഷൻ. ചിലസമയം വേരിയബിളുകൾ തമ്മിൽ ലീനിയർ ബന്ധം കാണാം - വോള്യത്തിൽ വലിയ ഗ്രാമ്മാതുള്ള പംപ്കിൻ കൂടുതൽ വിലവീഴും - എന്നാൽ ചിലപ്പോൾ ഈ ബന്ധങ്ങൾ സുതാര്യമായ വിമർശനയും അല്ലെങ്കിൽ നേരെയുള്ള রেখയായി കാഴ്ചവയ്ക്കാനാകാത്തതാണ്.
✅ ഇവിടെ [കൂടുതൽ ഉദാഹരണങ്ങൾ](https://online.stat.psu.edu/stat501/lesson/9/9.8) ഉണ്ട്, പോളിനോമിയൽ റിഗ്രഷൻ ഉപയോഗിക്കാവുന്ന ഡാറ്റയുടെ. ✅ ഇവിടെയാണ് [ഇനി ചില ഉദാഹരണങ്ങൾ](https://online.stat.psu.edu/stat501/lesson/9/9.8) പൊളിനോമിയൽ റെഗ്രഷൻ ഉപയോ​ഗിക്കാൻ കഴിയുന്നഡാറ്റ.
തീയതി (Date)യും വിലയും (Price)യും തമ്മിലുള്ള ബന്ധം വീണ്ടും നോക്കൂ. ഈ സ്കാറ്റർപ്ലോട്ട് ഒരു നേരിയ ലൈനിലൂടെ വിശകലനം ചെയ്യേണ്ടതുണ്ടോ? വിലകൾ മാറാറില്ലേ? ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ പോളിനോമിയൽ റിഗ്രഷൻ പരീക്ഷിക്കാം. തിയതി Dateയും വില Priceയും തമ്മിലുള്ള ബന്ധം വീണ്ടും നോക്കുക. ഈ സ്കാറ്റർപ്ലോട്ട് ഒരു സരളരേഖ ഉപയോഗിച്ച് അവലോകനം ചെയ്തിരിക്കണമെന്നു തോന്നുമോ? വിലകൾ ചലിക്കുന്നില്ലേ? ഇത്തരം അവസരങ്ങളിൽ, പൊളിനോമിയൽ റെഗ്രഷൻ ശ്രമിക്കാം.
✅ പോളിനോമിയലുകൾ ഒരു അല്ലെങ്കിൽ കൂടുതൽ വേരിയബിളുകളും കോഫിഷ്യന്റുകളും അടങ്ങിയ ഗണിതപരമായ പ്രകടനങ്ങളാണ്. ✅ പൊളിനോമിയൽ ആണെങ്കിൽ, അത് ഒരോ വൈറബിളുകളുടെയും കോഫിഷ്യന്റുകളുടെയും കൂട്ടമായ ഗണിതം പ്രകടനമാണ്.
പോളിനോമിയൽ റിഗ്രഷൻ nonlinear ഡാറ്റയ്ക്ക് മികച്ച അനുയോജ്യമായ വളഞ്ഞ ലൈനുണ്ടാക്കുന്നു. നമ്മുടെ കേസിൽ, `DayOfYear` എന്ന വേരിയബിളിന്റെ സ്ക്വയർഡ് വേരിയബിള് ഇൻപുട്ടിൽ ഉൾപ്പെടുത്തുകയാണെങ്കിൽ, വർഷത്തിനുള്ളിൽ ഒരു പ്രത്യേക പോയിന്റിൽ കുറഞ്ഞ മൂല്യമുള്ള പാരബോളിക് വളഞ്ഞ ലൈനിൽ ഡാറ്റ ഫിറ്റ് ചെയ്യാൻ കഴിയും. പൊളിനോമിയൽ റെഗ്രഷൻ, നെളിനിയർ ഡാറ്റയ്ക്ക് മികച്ച രൂപത്തിൽ ചട്ടം പിടിക്കാൻ വളഞ്ഞ വര വരയ്ക്കുന്നു. നമ്മുടെ കേസിൽ, സ്ക്വയർ ചെയ്ത `DayOfYear` വേരിയബിള്‍ ഇൻപ്പുട്ടിൽ ചേർത്താൽ, വർഷത്തിനുള്ളിൽ ഒരു നിശ്ചിത പോയിന്റിൽ കുറഞ്ഞത് ഉള്ള പാരബോളിക് വളവ് ഫിറ്റ് ചെയ്യാൻ കഴിയും.
Scikit-learn ല്‍ വിവിധ ഡാറ്റ പ്രോസസ്സിംഗ് ഘട്ടങ്ങൾ ചേർക്കാൻ സഹായിക്കുന്ന [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) ഉണ്ട്. **pipeline** എന്നത് **estimators** ന്റെ ഒരു ശൃംഖലയാണ്. നമ്മുടെ കേസിൽ, ആദ്യം മോഡലിൽ പോളിനോമിയൽ ഫീച്ചറുകൾ ചേർക്കുകയും പിന്നീട് റിഗ്രഷൻ ട്രെയിൻ ചെയ്യുകയും ചെയ്യുന്ന pipeline സൃഷ്ടിക്കും: Scikit-learn ഒരു ഉപകാരപ്രദമായ [പൈപ്പ്‌ലൈൻ API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) ഉൾപ്പെടുത്തി, ഇത് ഡാറ്റ പ്രോസസിങ്ങിന്റെ വിവിധ ഘട്ടങ്ങൾ കൂട്ടിച്ചേർക്കുന്നു. ഒരു **പൈപ്പ്‌ലൈൻ** എന്ന് പറയുന്നു **എസ്റ്റിമേറ്ററുകളുടെ** ഒരു ശൃംഖല. നമ്മുടെ കേസ്, ആദ്യം മോഡലിൽ പൊളിനോമിയൽ ഫീച്ചറുകൾ ചേർക്കുകയും പിന്നെ റെഗ്രഷൻ പരിശീലിപ്പിക്കുകയും ചെയ്യുന്ന പൈപ്പ്ലൈൻ സൃഷ്ടിക്കും:
```python ```python
from sklearn.preprocessing import PolynomialFeatures from sklearn.preprocessing import PolynomialFeatures
@ -243,61 +260,61 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train) pipeline.fit(X_train,y_train)
``` ```
`PolynomialFeatures(2)` ഉപയോഗിക്കുന്നത് ഇൻപുട്ട് ഡാറ്റയിലെ എല്ലാ രണ്ടാം-നിര പൊളിനോമിയൽ ഉൾപ്പെടുത്തുമെന്ന് അർത്ഥം. നമ്മുടെ കേസിൽ `DayOfYear`<sup>2</sup> മാത്രമായിരിക്കും, എന്നാൽ രണ്ട് ഇൻപുട്ട് വേരിയബിൾസ് X, Y ഉണ്ടെങ്കിൽ, ഇത് X<sup>2</sup>, XY, Y<sup>2</sup> എന്നിവ ചേർക്കും. ഉയർന്ന ഡിഗ്രി പൊളിനോമിയലുകൾ വേണമെങ്കിൽ അവ ഉപയോഗിക്കാം.
`PolynomialFeatures(2)` ഉപയോഗിക്കുന്നത്, ഇൻപുട്ട് ഡാറ്റയിലെ എല്ലാ രണ്ടാം-ഡിഗ്രി പോളിനോമിയലുകളും ഉൾപ്പെടുത്തുമെന്ന് അർത്ഥം. നമ്മുടെ കേസിൽ ഇത് `DayOfYear`<sup>2</sup> മാത്രമാണ്, പക്ഷേ രണ്ട് ഇൻപുട്ട് വേരിയബിളുകൾ X, Y ഉണ്ടെങ്കിൽ, ഇത് X<sup>2</sup>, XY, Y<sup>2</sup> എന്നിവ ചേർക്കും. കൂടുതൽ ഡിഗ്രി പോളിനോമിയലുകളും ഉപയോഗിക്കാം. പൈപ്പ്‌ലൈൻ `LinearRegression` ഓബ്രക്റ്റ് പോലെ തന്നെ ഉപയോഗിക്കാം, അതായത് പൈപ്പ് ലൈൻ `fit` ചെയ്ത്, തുടർന്ന് `predict` എന്ന ഫംഗ്ഷൻ ഉപയോഗിച്ച് പ്രവചന ഫലങ്ങൾ കിട്ടിക്കും. ഇവിടെ ടെസ്റ്റ് ഡാറ്റയും ആനുകൂല്യവർഗ്ഗം വളവും കാണിക്കുന്ന ഗ്രാഫ്:
Pipeline-കൾ ആദ്യം ഉപയോഗിച്ച `LinearRegression` ഒബ്ജക്റ്റ് പോലെ തന്നെ ഉപയോഗിക്കാം, അഥവാ pipeline-നെ `fit` ചെയ്ത്, പിന്നീട് `predict` ഉപയോഗിച്ച് പ്രവചന ഫലങ്ങൾ നേടാം. ടെസ്റ്റ് ഡാറ്റയും അനുമാന വളഞ്ഞ ലൈനും കാണിക്കുന്ന ഗ്രാഫ് ഇതാ:
<img alt="Polynomial regression" src="../../../../translated_images/ml/poly-results.ee587348f0f1f60b.webp" width="50%" /> <img alt="Polynomial regression" src="../../../../translated_images/ml/poly-results.ee587348f0f1f60b.webp" width="50%" />
പോളിനോമിയൽ റിഗ്രഷൻ ഉപയോഗിച്ച്, നാം കുറച്ച് താഴ്ന്ന MSEയും ഉയർന്ന നിർണ്ണയ ഘടകവും നേടാം, പക്ഷേ വലിയ വ്യത്യാസമില്ല. മറ്റ് ഫീച്ചറുകളും പരിഗണിക്കേണ്ടതാണ്! പൊളിനോമിയൽ റെഗ്രഷൻ ഉപയോഗിച്ച് ചെറിയ കുറവ് MSEയും കൂടുതൽ ദേറ്റർമിനേഷൻ കിട്ടാമെന്ന് കാണാം, പക്ഷെ സാരമായ മാറ്റം ഇല്ല. കൂടുതൽ ഫീച്ചറുകൾ പരിഗണിക്കേണ്ടതാണ്!
> നിങ്ങൾക്ക് കാണാം, ഏറ്റവും കുറഞ്ഞ പംപ്കിൻ വില ഹാലോവീൻ സമയത്ത് കാണപ്പെടുന്നു. ഇതെങ്ങനെ വിശദീകരിക്കാം? > ഹാലോവീന് ചുറ്റുമുള്ള സമയത്ത് പംപ്കിൻ വിലകൾ ഏറ്റവും താഴെയാണ് എന്ന് നിങ്ങൾ കാണും. നിങ്ങൾക്ക് ഇതെങ്ങനെ വിശദീകരിക്കാമെന്ന് തോന്നുന്നു?
🎃 അഭിനന്ദനങ്ങൾ, നിങ്ങൾ പൈ പംപ്കിൻ വില പ്രവചിക്കാൻ സഹായിക്കുന്ന മോഡൽ സൃഷ്ടിച്ചു. എല്ലാ പംപ്കിൻ തരംകൾക്കും ഇതേ പ്രക്രിയ ആവർത്തിക്കാം, പക്ഷേ അത് ബുദ്ധിമുട്ടുള്ളതാണ്. ഇനി നാം പഠിക്കാം, പംപ്കിൻ വൈവിധ്യം നമ്മുടെ മോഡലിൽ എങ്ങനെ പരിഗണിക്കാം! 🎃 അഭിനന്ദനങ്ങൾ, നിങ്ങൾ പൈ പംപ്കിൻ വില പ്രവചിക്കുന്ന ഒരു മോഡൽ സൃഷ്ടിച്ചു. നിങ്ങൾക്ക് സൂക്ഷ്മമായി എല്ലാം കായ്ക്കാം, എന്നാൽ അതൊരു കാരണം വൈകിയാകും. ഇനി പംപ്കിൻ വകഭേദം (variety) മോഡലിൽ ഉൾപ്പെടുത്തുന്നത് പഠിക്കാം!
## വർഗ്ഗീയ ഫീച്ചറുകൾ ## വിഭാഗീയ (Categorical) ഫീച്ചറുകൾ
ആദർശ ലോകത്ത്, നാം ഒരേ മോഡൽ ഉപയോഗിച്ച് വ്യത്യസ്ത പംപ്കിൻ വൈവിധ്യങ്ങളുടെ വില പ്രവചിക്കാൻ ആഗ്രഹിക്കുന്നു. എന്നാൽ, `Variety` കോളം `Month` പോലുള്ള കോളങ്ങളേക്കാൾ വ്യത്യസ്തമാണ്, കാരണം അതിൽ സംഖ്യാത്മകമല്ലാത്ത മൂല്യങ്ങൾ ഉണ്ട്. ഇത്തരം കോളങ്ങൾ **വർഗ്ഗീയ** (categorical) എന്ന് വിളിക്കുന്നു. സർവോപരി സ്ഥിതിയിൽ, ഒരേ മോഡലിൽ ഉപയോഗിച്ച് പംപ്കിൻ വകഭേദങ്ങൾക്കായുള്ള വില പ്രവചിക്കാൻ ആഗ്രഹിക്കും. പക്ഷെ `Variety` കോളം ഒരു പ്രത്യേകമാണ്, ലളിതവസ്തുക്കളായ `Month` പോലുള്ള കോളുകളേക്കാൾ വ്യത്യസ്തമാണ്, കാരണം ഇത് സംഖ്യാമല്ലാത്ത മൂല്യങ്ങൾ അടങ്ങിയതാണ്. ഇത്തരം കോളംഗൾ **വിഭാഗീയ** (categorical) എന്ന് പറയുന്നു.
[![ML for beginners - Categorical Feature Predictions with Linear Regression](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression") [![ML for beginners - Categorical Feature Predictions with Linear Regression](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
> 🎥 വർഗ്ഗീയ ഫീച്ചറുകൾ ഉപയോഗിക്കുന്നതിന്റെ ഒരു ചെറിയ വീഡിയോ അവലോകനത്തിന് മുകളിൽ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക. > 🎥 ഉപയോഗിക്കാനുമുള്ള ലഘുവായ വീഡിയോ അവലോകനത്തിന് മുകളിലുള്ള ചിത്രം ക്ലിക്ക് ചെയ്യുക.
ഇവിടെ നിങ്ങൾക്ക് കാണാം, ശരാശരി വില വൈവിധ്യത്തെ ആശ്രയിച്ചിരിക്കുന്നു: ഇവിടെ നിങ്ങൾക്ക് പക്ഷവിധിവഴി ശരാശരി വില എങ്ങനെ വ്യത്യസ്തമാണ് എന്ന് കാണാം:
<img alt="Average price by variety" src="../../../../translated_images/ml/price-by-variety.744a2f9925d9bcb4.webp" width="50%" /> <img alt="Average price by variety" src="../../../../translated_images/ml/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
വൈവിധ്യം പരിഗണിക്കാൻ, ആദ്യം അത് സംഖ്യാത്മക രൂപത്തിലേക്ക് മാറ്റണം, അല്ലെങ്കിൽ **എൻകോഡ്** ചെയ്യണം. ഇത് ചെയ്യാനുള്ള ചില മാർഗ്ഗങ്ങൾ: വകഭേദം പരിഗണിക്കാൻ, ആദ്യം അത് സംഖ്യാമായ രൂപത്തിൽ മാറ്റണം, അല്ലെങ്കിൽ **എൻകോഡ്** ചെയ്യണമെന്ന്. ഇതിന് കൂടുതലായ മാർഗ്ഗങ്ങൾ ഉണ്ട്:
* ലളിതമായ **സംഖ്യാത്മക എൻകോഡിംഗ്** വ്യത്യസ്ത വൈവിധ്യങ്ങളുടെ പട്ടിക സൃഷ്ടിച്ച്, ആ പട്ടികയിലെ ഇൻഡക്സ് ഉപയോഗിച്ച് വൈവിധ്യത്തിന്റെ പേര് മാറ്റും. ഇത് ലീനിയർ റിഗ്രഷനിൽ നല്ല ആശയമല്ല, കാരണം ലീനിയർ റിഗ്രഷൻ ഇൻഡക്സ് സംഖ്യയുടെ യഥാർത്ഥ മൂല്യം എടുത്ത് ഫലത്തിൽ കൂട്ടിച്ചേർക്കും, ചില കോഫിഷ്യന്റുകളാൽ ഗുണിച്ച്. നമ്മുടെ കേസിൽ, ഇൻഡക്സ് നമ്പറും വിലയും തമ്മിലുള്ള ബന്ധം വ്യക്തമായി nonlinear ആണ്, ഇൻഡക്സുകൾ പ്രത്യേക ക്രമത്തിൽ ക്രമീകരിച്ചാലും. * ലളിതമായ **സംഖ്യാനി ഏന്കോടിംഗ്** (numeric encoding) വിവിധ വകഭേദങ്ങളുടെ പട്ടിക സൃഷ്ടിച്ച്, ആ പട്ടികയിൽ ഉള്ള ഇനങ്ങളുടെ സൂചിക നൽകിയിട്ട് ഭാരതമാറ്റം നടത്തും. ഇത് ലീനിയർ റെഗ്രഷനിൽ നല്ല ഐഡിയയല്ല, കാരണം ലീനിയർ റെഗ്രഷൻ ഇൻഡക്സിന്റെ സംഖ്യാത്മക മൂല്യം കണക്കാക്കുന്നു, അത് അക്ക ഫലത്തിൽ ഒരു കോഫിഷ്യന്റ് ഉപയോഗിച്ച് കൂട്ടിച്ചേർക്കുന്നു. നമ്മുടെ കേസിൽ ഇൻഡക്സ് നമ്പറും വിലയും തമ്മിലുള്ള ബന്ധം ലീനിയർ അല്ലാത്തതായതിനാൽ ഇത് സാധ്യതയില്ല.
* **ഒന്ന്-ഹോട്ട് എൻകോഡിംഗ്** `Variety` കോളം 4 വ്യത്യസ്ത കോളങ്ങളായി മാറ്റും, ഓരോ വൈവിധ്യത്തിനും ഒരു കോളം. ഓരോ കോളവും ആ വരി ആ വൈവിധ്യത്തിനുള്ളതാണെങ്കിൽ `1` അടങ്ങിയിരിക്കും, അല്ലെങ്കിൽ `0`. ഇതിന്റെ അർത്ഥം, ലീനിയർ റിഗ്രഷനിൽ ഓരോ പംപ്കിൻ വൈവിധ്യത്തിനും നാല് കോഫിഷ്യന്റുകൾ ഉണ്ടാകും, ഓരോ വൈവിധ്യത്തിനും "ആരംഭ വില" (അഥവാ "കൂടുതൽ വില") നിർണ്ണയിക്കാൻ. * **ഒന്ന്-ഹോട്ട് എൻകോഡിംഗ്** (One-hot encoding) `Variety` കോളം 4 വ്യത്യസ്ത കോളങ്ങളായി മാറ്റും, ഓരോ വകഭേദത്തിനും പ്രത്യേകം ഒരു കോളം. ഓരോ കോളവും 1 അല്ലെങ്കിൽ 0 മൂല്യങ്ങളുള്ളതായി വരും, 1 ആണെങ്കിൽ ആ വരി ആ വിഭാഗത്തിൽപ്പെടുന്നു എന്നർത്ഥം. ഇത് ലീനിയർ റെഗ്രഷനിൽ ഓരോ പംപ്കിൻ വകഭേദത്തിനും 4 കോഫിഷ്യന്റുകൾ ഉണ്ടാകുമെന്ന് സൂചിപ്പിക്കുന്നു, ഓരോ വകഭേദത്തിനും പ്രത്യേക "ആരംഭ വില" (കൂടാതെ "കൂടുതൽ വില") പേരിൽ.
വൈവിധ്യം ഒന്ന്-ഹോട്ട് എൻകോഡ് ചെയ്യുന്നത് കാണിക്കുന്ന കോഡ് താഴെ: ഓന്ന്-ഹോട്ട് എൻകോഡിംഗ് Variety-യുമായി എങ്ങനെ ചെയ്യാമെന്നു കാണിക്കുന്നു ഈ കോഡ്:
```python ```python
pd.get_dummies(new_pumpkins['Variety']) pd.get_dummies(new_pumpkins['Variety'])
``` ```
ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
----|-----------|-----------|--------------------------|---------- ----|-----------|-----------|--------------------------|----------
70 | 0 | 0 | 0 | 1 70 | 0 | 0 | 0 | 1
71 | 0 | 0 | 0 | 1 71 | 0 | 0 | 0 | 1
... | ... | ... | ... | ... ... | ... | ... | ... | ...
1738 | 0 | 1 | 0 | 0 1738| 0 | 1 | 0 | 0
1739 | 0 | 1 | 0 | 0 1739| 0 | 1 | 0 | 0
1740 | 0 | 1 | 0 | 0 1740| 0 | 1 | 0 | 0
1741 | 0 | 1 | 0 | 0 1741| 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0 1742| 0 | 1 | 0 | 0
ഒന്ന്-ഹോട്ട് എൻകോഡ് ചെയ്ത വൈവിധ്യം ഇൻപുട്ടായി ഉപയോഗിച്ച് ലീനിയർ റിഗ്രഷൻ ട്രെയിൻ ചെയ്യാൻ, `X`യും `y`യും ശരിയായി ഇൻഷിയലൈസ് ചെയ്യണം: ഒന്ന്-ഹോട്ട് എൻകോഡിംഗ് ഉപയോഗിച്ച് Variety ഇൻപുട്ടായി Linear Regression പരിശീലിപ്പിക്കാൻ, `X`യും `y`യും ശരിയായി ഇൻഷ്യലൈസ് ചെയ്യണം:
```python ```python
X = pd.get_dummies(new_pumpkins['Variety']) X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price'] y = new_pumpkins['Price']
``` ```
മറ്റുള്ള കോഡ് മുകളിൽ ലീനിയർ റിഗ്രഷൻ ട്രെയിനിംഗിനായി ഉപയോഗിച്ച കോഡിനോട് സമാനമാണ്. പരീക്ഷിച്ചാൽ, മീൻ സ്ക്വയർ എറർ ഏകദേശം അതേപോലെയാണ്, പക്ഷേ നിർണ്ണയ ഘടകം വളരെ ഉയർന്ന (~77%) ആണ്. കൂടുതൽ കൃത്യമായ പ്രവചനങ്ങൾക്കായി, നാം കൂടുതൽ വർഗ്ഗീയ ഫീച്ചറുകളും സംഖ്യാത്മക ഫീച്ചറുകളും, ഉദാഹരണത്തിന് `Month` അല്ലെങ്കിൽ `DayOfYear` ഉൾപ്പെടുത്താം. വലിയ ഒരു ഫീച്ചർ അറേ ഉണ്ടാക്കാൻ `join` ഉപയോഗിക്കാം: മറ്റ് കോഡ് അതെതാണ്, മുമ്പ് ലീനിയർ റെഗ്രഷൻ പരിശീലിപ്പിക്കാൻ ഉപയോഗിച്ചത് പോലെ. നിങ്ങൾ പരീക്ഷിക്കുമ്പോൾ, MSE ഏകദേശം അതേ ഉണ്ടാകുമെന്ന് കാണും പകരം തന്നെ ദേറ്റർമിനേഷൻ കോഫിഷ്യന്റ് വളരെ ഉയർന്നീിരിക്കും (~77%). കൂടുതൽ കൃത്യമായ പ്രവചനങ്ങൾക്ക്, മറ്റു വിഭാഗീയ ഫീച്ചറുകളും കൂടാതെ സങ്ക്യാ ഫീച്ചറുകളും (ഉദാ: `Month` അല്ലെങ്കിൽ `DayOfYear`) പരിഗണിക്കാം. മുഴുവൻ ഫീച്ചറുകളും ഒരു വൻ അറായിയാക്കാൻ `join` ഉപയോഗിക്കാം:
```python ```python
X = pd.get_dummies(new_pumpkins['Variety']) \ X = pd.get_dummies(new_pumpkins['Variety']) \
@ -306,12 +323,12 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
.join(pd.get_dummies(new_pumpkins['Package'])) .join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price'] y = new_pumpkins['Price']
``` ```
ഇവിടെ `City` ഉം `Package` തരവും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, ഇത് MSE 2.84 (10%) ഉം ദേറ്റർമിനേഷൻ 0.94 ഉം നൽകുന്നു!
ഇവിടെ നാം `City`യും `Package` തരംയും പരിഗണിക്കുന്നു, ഇത് MSE 2.84 (10%)യും നിർണ്ണയ ഘടകം 0.94 ഉം നൽകുന്നു! ## എല്ലാം ചേർത്ത് ഉപയോഗിക്കൽ
## എല്ലാം ചേർത്ത്
മികച്ച മോഡൽ ഉണ്ടാക്കാൻ, മുകളിൽ നൽകിയ സംയുക്ത (ഒന്ന്-ഹോട്ട് എൻകോഡ് ചെയ്ത വർഗ്ഗീയ + സംഖ്യാത്മക) ഡാറ്റ പോളിനോമിയൽ റിഗ്രഷനോടൊപ്പം ഉപയോഗിക്കാം. നിങ്ങളുടെ സൗകര്യത്തിനായി പൂർണ്ണ കോഡ് ഇതാ: ശ്രേഷ്ഠ മോഡൽ ഉണ്ടാക്കാൻ, ഒരു കൂട്ടിച്ചേർന്ന (ഒന്ന്-ഹോട്ട് എൻകോഡഡ് വിഭാഗീയ + സഖ്യാ) ഡാറ്റയും പൊളിനോമിയൽ റെഗ്രഷനും ചേർത്ത് ഉപയോഗിക്കാം. നിങ്ങളുടെ സൗകര്യത്തിന് പൂർണ്ണ കോഡ് ഇവിടെ:
```python ```python
# പരിശീലന ഡാറ്റ സജ്ജമാക്കുക # പരിശീലന ഡാറ്റ സജ്ജമാക്കുക
@ -324,51 +341,51 @@ y = new_pumpkins['Price']
# ട്രെയിൻ-ടെസ്റ്റ് വിഭജനം നടത്തുക # ട്രെയിൻ-ടെസ്റ്റ് വിഭജനം നടത്തുക
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
# പൈപ്പ്‌ലൈൻ സജ്ജമാക്കി പരിശീലിപ്പിക്കുക # പൈപ്പ്ലൈൻ സജ്ജമാക്കി പരിശീലിപ്പിക്കുക
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression()) pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train) pipeline.fit(X_train,y_train)
# ടെസ്റ്റ് ഡാറ്റയ്ക്ക് ഫലം പ്രവചിക്കുക # ടെസ്റ്റ് ഡാറ്റയ്ക്ക് ഫലം പ്രവചനമാക്കുക
pred = pipeline.predict(X_test) pred = pipeline.predict(X_test)
# MSEയും നിർണ്ണയവും കണക്കാക്കുക # MSEയും നിർണയവും കണക്കാക്കുക
mse = np.sqrt(mean_squared_error(y_test,pred)) mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)') print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
score = pipeline.score(X_train,y_train) score = pipeline.score(X_train,y_train)
print('Model determination: ', score) print('Model determination: ', score)
``` ```
ഇത് ഏകദേശം 97% ദേറ്റർമിനേഷൻ കോഫിഷ്യന്റ്, MSE 2.23 (~8% പ്രവചന പിശകു) നൽകും.
ഇത് ഏകദേശം 97% നിർണ്ണയ ഘടകവും MSE=2.23 (~8% പ്രവചന പിശക്)യും നൽകും. | മോഡൽ | MSE | ദേറ്റർമിനേഷൻ |
|-------|-----|----------------|
| മോഡൽ | MSE | നിർണ്ണയം |
|-------|-----|---------|
| `DayOfYear` ലീനിയർ | 2.77 (17.2%) | 0.07 | | `DayOfYear` ലീനിയർ | 2.77 (17.2%) | 0.07 |
| `DayOfYear` പോളിനോമിയൽ | 2.73 (17.0%) | 0.08 | | `DayOfYear` പൊളിനോമിയൽ | 2.73 (17.0%) | 0.08 |
| `Variety` ലീനിയർ | 5.24 (19.7%) | 0.77 | | `Variety` ലീനിയർ | 5.24 (19.7%) | 0.77 |
| എല്ലാ ഫീച്ചറുകളും ലീനിയർ | 2.84 (10.5%) | 0.94 | | എല്ലാം ഫീച്ചറുകൾ ലീനിയർ | 2.84 (10.5%) | 0.94 |
| എല്ലാ ഫീച്ചറുകളും പോളിനോമിയൽ | 2.23 (8.25%) | 0.97 | | എല്ലാം ഫീച്ചറുകൾ പൊളിനോമിയൽ | 2.23 (8.25%) | 0.97 |
🏆 നന്നായി! നിങ്ങൾ ഒരു പാഠത്തിൽ നാല് റിഗ്രഷൻ മോഡലുകൾ സൃഷ്ടിച്ചു, മോഡൽ ഗുണനിലവാരം 97% വരെ മെച്ചപ്പെടുത്തി. റിഗ്രഷൻ അവസാന ഭാഗത്ത്, നിങ്ങൾക്ക് വിഭാഗങ്ങൾ നിർണ്ണയിക്കാൻ ലൊജിസ്റ്റിക് റിഗ്രഷൻ പഠിക്കാം. 🏆 മികച്ച പ്രവർത്തി! നിങ്ങള ഗുണനിലവാരമുള്ള നാല് റെഗ്രഷൻ മോഡലുകൾ ഈ അധ്യായത്തിൽ സൃഷ്ടിച്ചു, മോഡലിന്റെ വിശ്വാസ്യത 97% വരെ ഉയർത്തി. റെഗ്രഷനിലെ അവസാന അധ്യായത്തിൽ നിങ്ങൾ ലജിസ്റ്റിക് റെഗ്രഷൻ കുറിച്ച് പഠിക്കും, വിഭാഗങ്ങൾ നിർണയിക്കാൻ.
--- ---
## 🚀ചലഞ്ച് ## 🚀ചലഞ്ച്
ഈ നോട്ട്‌ബുക്കിൽ വിവിധ വേരിയബിളുകൾ പരീക്ഷിച്ച്, സഹസംബന്ധം മോഡൽ കൃത്യതയുമായി എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നു എന്ന് കാണുക. ഈ നോട്ട്ബുക്കിൽ പല വ്യത്യസ്ത വേരിയബിളുകളെ പരീക്ഷിച്ച് കോറിയലേഷൻ മോഡൽ ആകുറേറ്റിന് എങ്ങനെ ബാധിക്കുന്നു എന്ന് നോക്കുക.
## [പാഠം കഴിഞ്ഞുള്ള ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/) ## [പഠനാനന്തര ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## അവലോകനം & സ്വയം പഠനം ## അവലോകനം & സ്വയംപഠനം
ഈ പാഠത്തിൽ നാം ലീനിയർ റിഗ്രഷൻ പഠിച്ചു. മറ്റ് പ്രധാന റിഗ്രഷൻ തരംകളും ഉണ്ട്. Stepwise, Ridge, Lasso, Elasticnet സാങ്കേതികതകൾക്കുറിച്ച് വായിക്കുക. കൂടുതൽ പഠിക്കാൻ നല്ല കോഴ്സ് [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning) ആണ്. ഈ പാഠത്തിൽ നാം ലീനിയർ റെഗ്രഷൻ പഠിച്ചു. മറ്റ് പ്രധാന റെഗ്രഷൻ തരം들도 ഉണ്ട്. Stepwise, Ridge, Lasso, Elasticnet ടെക്നിക്കുകൾ വായിക്കുക. കൂടുതൽ പഠിക്കാനുള്ള നല്ല കോഴ്‌സ് [Stanford Statistical Learning course](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning) ആണ്.
## അസൈൻമെന്റ് ## അസൈൻമെന്റ്
[മോഡൽ നിർമ്മിക്കുക](assignment.md) [മോഡൽ തയാറാക്കുക](assignment.md)
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**: **പരിചിതക്കുറിപ്പ്**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനത്തിന്റെ ഉപയോഗത്തിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല. ഈ രേഖ AI പരിഭാഷാ സേവനമായ [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് പരിഭാഷ ചെയ്തതാണ്. ഞങ്ങൾ സർവസാധാരണത്വത്തിനായി ശ്രമിച്ചുവെങ്കിലും, യന്ത്രപരിഭാഷയിൽ പിശകുകളോ അസംഘടിതത്വങ്ങളോ ഉണ്ടായേക്കാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. യഥാര്‍ത്ഥ രേഖയുടെ മാതൃഭാഷയിലെ ഫയൽ പ്രാമാണികമായ ആദ്യസ്രോതസ്സായി കണക്കാക്കേണ്ടതാണ്. സുപ്രധാന വിവരങ്ങൾക്കായി, പ്രൊഫഷണൽ മനുഷ്യ പരിഭാഷ നിർദ്ദേശിക്കുന്നു. ഈ പരിഭാഷ ഉപയോഗിക്കുന്നതിൽ നിന്നു കാണാവുന്ന തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾക്ക് ഉത്തരവാദിത്വമില്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

108
translations/ml/4-Classification/3-Classifiers-2/README.md
Unescape View File

@ -1,42 +1,42 @@
# ഭക്ഷണശൈലി വർഗ്ഗീകരണങ്ങൾ 2 # ഭക്ഷണ ശൈലികളുടെ വര്‍ഗീകരണങ്ങള്‍ 2
ഈ രണ്ടാം വർഗ്ഗീകരണ പാഠത്തിൽ, നിങ്ങൾ സംഖ്യാത്മക ഡാറ്റ വർഗ്ഗീകരിക്കുന്ന കൂടുതൽ മാർഗങ്ങൾ അന്വേഷിക്കും. മറ്റൊരു വർഗ്ഗീകരണ ഉപാധി തിരഞ്ഞെടുക്കുന്നതിന്റെ ഫലങ്ങൾക്കുറിച്ചും നിങ്ങൾ പഠിക്കും. ഈ രണ്ടാം വര്‍ഗീകരണ പാഠത്തില്‍, നമുക്ക് അക്ക സംഖ്യാഗത ഡാറ്റ വര്‍ഗീകരിക്കാനുള്ള കൂടുതല്‍ വഴികള്‍ പരിശോധിക്കാം. ഓരോ ക്ലാസിഫയറും ഒന്നിനെതിരെയൊരു തിരഞ്ഞെടുപ്പിന് ഉള്ള സ്വാധീനം കുറിച്ചും അറിയാം.
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/) ## [മുൻ പാഠം പരീക്ഷ](https://ff-quizzes.netlify.app/en/ml/)
### മുൻകൂർ ആവശ്യകത ### മുൻകൂട്ടി ആവശ്യമായത്
നിങ്ങൾ മുമ്പത്തെ പാഠങ്ങൾ പൂർത്തിയാക്കിയിട്ടുണ്ട് എന്ന് ഞങ്ങൾ കരുതുന്നു, കൂടാതെ ഈ 4-പാഠ ഫോളഡറിന്റെ റൂട്ടിൽ ഉള്ള `data` ഫോൾഡറിൽ _cleaned_cuisines.csv_ എന്ന ശുദ്ധീകരിച്ച ഡാറ്റാസെറ്റ് ഉണ്ട്. മുൻപുള്ള പാഠങ്ങള്‍ കഴിഞ്ഞുകഴിഞ്ഞുവെന്ന് എടുത്ത് ഞങ്ങളുടെ `data` ഫോള്‍ഡറില്‍ _cleaned_cuisines.csv_ എന്ന ശുദ്ധപ്പെടുത്തിയ ഡാറ്റാസെറ്റ് ഉള്ളതായി കരുതുന്നു, ഈ 4-പാഠ ഫോള്‍ഡറിന്റെ റൂട്ട് ഫോട്ടില്‍.
### തയ്യാറെടുപ്പ് ### ഒരുക്കം
നിങ്ങളുടെ _notebook.ipynb_ ഫയലിൽ ശുദ്ധീകരിച്ച ഡാറ്റാസെറ്റ് ലോഡ് ചെയ്തിട്ടുണ്ട്, കൂടാതെ മോഡൽ നിർമ്മാണ പ്രക്രിയയ്ക്ക് തയ്യാറായി X, y ഡാറ്റാഫ്രെയിമുകളായി വിഭജിച്ചിട്ടുണ്ട്. ഞങ്ങള്‍ നിങ്ങളുടെ _notebook.ipynb_ ഫയലില്‍ ശുദ്ധപ്പെടുത്തിയ ഡാറ്റാസെറ്റ് ലോഡ് ചെയ്തിട്ടുണ്ട്, അത് X, y ഡാറ്റാഫ്രെയിമുകളായി വിഭജിച്ചെടുത്തിട്ടുണ്ട്, മോഡല്‍ നിർമ്മാണ പ്രക്രിയയ്ക്ക് തയ്യാറായി.
## ഒരു വർഗ്ഗീകരണ മാപ്പ് ## ഒരു വര്‍ജ്ശീകരണ ഭൂപടം
മുൻപ്, മൈക്രോസോഫ്റ്റിന്റെ ചീറ്റ്ഷീറ്റിന്റെ സഹായത്തോടെ ഡാറ്റ വർഗ്ഗീകരിക്കുന്നതിനുള്ള വിവിധ ഓപ്ഷനുകൾ നിങ്ങൾ പഠിച്ചിരുന്നു. Scikit-learn സമാനമായ, എന്നാൽ കൂടുതൽ സൂക്ഷ്മമായ ഒരു ചീറ്റ്ഷീറ്റ് നൽകുന്നു, ഇത് നിങ്ങളുടെ എസ്റ്റിമേറ്റർമാരെ (വർഗ്ഗീകരണ ഉപാധികൾക്ക് മറ്റൊരു പദം) കൂടുതൽ കുറയ്ക്കാൻ സഹായിക്കും: മുൻപ്, മൈക്രോസോഫ്റ്റ് ചീറ്റ്ഷീറ്റിലെ ഡാറ്റ വര്‍ഗീകരണത്തിനുള്ള വിവിധ ഓപ്ഷനുകള്‍ കുറിച്ച് പഠിച്ചു. Scikit-learn സമാനമായെങ്കിലും കൂടുതല്‍ സൂക്ഷ്മമായ ഒരു ചീറ്റ്ഷീറ്റ് നല്‍കുന്നു, ഇത് നിങ്ങളുടെ എസ്റ്റിമേറ്ററുകള്‍ (മറ്റൊരു പദം ക്ലാസിഫയര്‍) കുറച്ച് കുറയ്ക്കാനായി ഉപകരിക്കും:
![ML Map from Scikit-learn](../../../../translated_images/ml/map.e963a6a51349425a.webp) ![ML Map from Scikit-learn](../../../../translated_images/ml/map.e963a6a51349425a.webp)
> ടിപ്പ്: [ഈ മാപ്പ് ഓൺലൈനിൽ സന്ദർശിക്കുക](https://scikit-learn.org/stable/tutorial/machine_learning_map/) കൂടാതെ പാതയിലൂടെ ക്ലിക്ക് ചെയ്ത് ഡോക്യുമെന്റേഷൻ വായിക്കുക. > ടിപ്: [ഈ ഭൂപടം ഓൺലൈനിൽ സന്ദർശിക്കുക](https://scikit-learn.org/stable/tutorial/machine_learning_map/) നിന്ന് പാതയിൽ ക്ലിക്ക് ചെയ്ത് ഡോക്യുമെന്റേഷൻ വായിക്കുക.
### പദ്ധതി ### പദ്ധതി
നിങ്ങളുടെ ഡാറ്റയെക്കുറിച്ച് വ്യക്തമായ ധാരണയുണ്ടായാൽ ഈ മാപ്പ് വളരെ സഹായകരമാണ്, കാരണം നിങ്ങൾ അതിന്റെ പാതകളിലൂടെ 'നടക്കാം' ഒരു തീരുമാനം എടുക്കാൻ: നിങ്ങളുടെ ഡാറ്റയെക്കുറിച്ചും വ്യക്തമായ ധാരണ ഉണ്ടാകുമ്പോഴാണ് ഈ ഭൂപടം വളരെ ഉപകാരപ്രദം, കാരണം നിങ്ങൾ പാതകളിലൂടെ 'നടക്കാൻ' സാദ്ധ്യമാകുന്നു:
- ഞങ്ങൾക്ക് >50 സാമ്പിളുകൾ ഉണ്ട് - ഞങ്ങള്‍ക്ക് >50 സാമ്പിളുകൾ ഉണ്ട്
- ഒരു വിഭാഗം പ്രവചിക്കണം - ഒരു വിഭാഗം സാധ്യം പ്രവചിക്കണം
- ലേബൽ ചെയ്ത ഡാറ്റ ഉണ്ട് - ലേബൽ ചെയ്ത ഡാറ്റ ഉണ്ട്
- 100K സാമ്പിളുകൾക്കു താഴെയാണ് - 100K സാമ്പളിൽ കുറവാണ്
- ✨ നാം ഒരു ലീനിയർ SVC തിരഞ്ഞെടുക്കാം - ✨ Linear SVC തിരഞ്ഞെടുക്കാം
- അത് പ്രവർത്തിക്കാത്ത പക്ഷം, സംഖ്യാത്മക ഡാറ്റ ഉള്ളതിനാൽ - അത് പ്രവര്‍ത്തിക്കാത്ത പക്ഷം, അക്ക സംഖ്യാഗത ഡാറ്റ ഉള്ളതിനാല്‍
- നാം ✨ KNeighbors Classifier പരീക്ഷിക്കാം - ✨ KNeighbors Classifier പരീക്ഷിക്കാം
- അത് പ്രവർത്തിക്കാത്ത പക്ഷം, ✨ SVC, ✨ Ensemble Classifiers പരീക്ഷിക്കുക - അത് പരാജയപ്പെടുകയാണെങ്കില്‍ ✨ SVC, ✨ Ensemble Classifiers പരീക്ഷിക്കുക
ഇത് പിന്തുടരാൻ വളരെ സഹായകരമായ ഒരു പാതയാണ്. ഏറ്റവും സഹായകരമായ ഒരു പാതയാണ് ഇത്.
## അഭ്യാസം - ഡാറ്റ വിഭജിക്കുക ## അഭ്യാസം - ഡാറ്റ വിഭജിക്കുക
ഈ പാത പിന്തുടർന്ന്, നാം ഉപയോഗിക്കാൻ ചില ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുന്നതിൽ നിന്ന് തുടങ്ങാം. ഈ പാത പിന്തുടർന്ന്, ചില ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുകയായിരിക്കും.
1. ആവശ്യമായ ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുക: 1. ആവശ്യമായ ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യുക:
@ -50,31 +50,31 @@
import numpy as np import numpy as np
``` ```
1. നിങ്ങളുടെ പരിശീലനവും ടെസ്റ്റ് ഡാറ്റയും വിഭജിക്കുക: 1. നിങ്ങളുടെ പരിശീലനവും പരിശോധനാ ഡാറ്റയും വിഭജിക്കുക:
```python ```python
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3) X_train, X_test, y_train, y_test = train_test_split(cuisines_features_df, cuisines_label_df, test_size=0.3)
``` ```
## ലീനിയർ SVC വർഗ്ഗീകരകൻ ## ലിനിയർ SVC ക്ലാസിഫയര്‍
സപ്പോർട്ട്-വെക്ടർ ക്ലസ്റ്ററിംഗ് (SVC) ML സാങ്കേതികവിദ്യകളായ Support-Vector machines കുടുംബത്തിലെ ഒരു ശാഖയാണ് (താഴെ ഇതിനെക്കുറിച്ച് കൂടുതൽ പഠിക്കുക). ഈ രീതിയിൽ, ലേബലുകൾ എങ്ങനെ ക്ലസ്റ്റർ ചെയ്യാമെന്ന് തീരുമാനിക്കാൻ 'kernel' തിരഞ്ഞെടുക്കാം. 'C' പാരാമീറ്റർ 'regularization' നെ സൂചിപ്പിക്കുന്നു, ഇത് പാരാമീറ്ററുകളുടെ സ്വാധീനം നിയന്ത്രിക്കുന്നു. kernel [വിവിധങ്ങളിലൊന്നായിരിക്കാം](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); ഇവിടെ നാം 'linear' ആയി സജ്ജമാക്കി ലീനിയർ SVC പ്രയോജനപ്പെടുത്തുന്നു. Probability ഡിഫോൾട്ട് 'false' ആണ്; ഇവിടെ 'true' ആയി സജ്ജമാക്കി സാധ്യതാ അളവുകൾ ശേഖരിക്കുന്നു. ഡാറ്റ ഷഫിൾ ചെയ്യാൻ random state '0' ആയി സജ്ജമാക്കിയിട്ടുണ്ട്. Support-Vector clustering (SVC) Support-Vector machines കുടുംബത്തിലെ ഒരു ശാഖയാണ് (ഇവയെ കുറിച്ച് താഴെ പഠിക്കാം). ഈ രീതിയിൽ, ലേബലുകളെ എങ്ങനെ ക്ലസ്റ്റർ ചെയ്യാമെന്ന് തീരുമാനിക്കാനുള്ള ഒരു 'kernel' തിരഞ്ഞെടുക്കാം. 'C' ക്രമേങ്കം പാരാമീറ്ററിന്റെ സ്വാധീനം നിയന്ത്രിക്കുന്ന 'regularization' ഉം സൂചിപ്പിക്കുന്നു. kernel വിവിധ [തരം](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC) ഉള്ളതിൽ നിന്നാണ്; ഇവിടെ 'linear' ആയി വച്ച് linear SVC ഉപയോഗിക്കുന്നത് ഉറപ്പാക്കുന്നു. Probability നിന്റെ മുന്നറിയിപ്പ് 'false' ആണെങ്കിലും, ഇവിടെ 'true' ആയി ക്രമീകരിച്ചിരിക്കുന്നു സാധ്യതാനിരീക്ഷണങ്ങള്‍ ശേഖരിക്കാൻ. ഡാറ്റ ശഫിൾ ചെയ്യാൻ random state '0' ആയി നിശ്ചയിച്ചിട്ടുണ്ട്.
### അഭ്യാസം - ലീനിയർ SVC പ്രയോഗിക്കുക ### അഭ്യാസം - ലിനിയർ SVC പ്രയോജനം ചെയ്യുക
വർഗ്ഗീകരകങ്ങളുടെ ഒരു അറേ സൃഷ്ടിച്ച് തുടങ്ങുക. പരീക്ഷണങ്ങൾ നടത്തുമ്പോൾ ഈ അറേയിൽ ക്രമാനുസൃതമായി ചേർക്കും. ക്ലാസിഫയറുകളുടെ ഒരു നിര സംരചിക്കുക, ഞങ്ങൾ നിര്‍ണയം ചെയ്യുമ്പോൾ ഇതിലേക്ക് തുടരെകൂടി ചേർക്കുന്നു.
1. ലീനിയർ SVC ഉപയോഗിച്ച് തുടങ്ങുക: 1. Linear SVC ഉം തുടങ്ങുക:
```python ```python
C = 10 C = 10
# വ്യത്യസ്ത ക്ലാസിഫയർസുകൾ സൃഷ്ടിക്കുക. # വ്യത്യസ്ത ക്ലാസിഫയറുകൾ സൃഷ്ടിക്കുക.
classifiers = { classifiers = {
'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0) 'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
} }
``` ```
2. ലീനിയർ SVC ഉപയോഗിച്ച് മോഡൽ പരിശീലിപ്പിച്ച് റിപ്പോർട്ട് പ്രിന്റ് ചെയ്യുക: 2. Linear SVC ഉപയോഗിച്ച് നിങ്ങളുടെ മോഡല്‍ പരിശീലിപ്പിച്ച് റിപ്പോര്‍ട്ട് അച്ചടിക്കുക:
```python ```python
n_classifiers = len(classifiers) n_classifiers = len(classifiers)
@ -88,7 +88,7 @@
print(classification_report(y_test,y_pred)) print(classification_report(y_test,y_pred))
``` ```
ഫലം വളരെ നല്ലതാണ്: ഫലം വളരെ നല്ലതാണെന്ന് കാണാം:
```output ```output
Accuracy (train) for Linear SVC: 78.6% Accuracy (train) for Linear SVC: 78.6%
@ -105,21 +105,21 @@
weighted avg 0.79 0.79 0.79 1199 weighted avg 0.79 0.79 0.79 1199
``` ```
## K-Neighbors വർഗ്ഗീകരകൻ ## K-Neighbors ക്ലാസിഫയര്‍
K-Neighbors ML രീതികളായ "neighbors" കുടുംബത്തിലെ ഒരു ഭാഗമാണ്, ഇത് സൂപ്പർവൈസ്ഡ്, അൺസൂപ്പർവൈസ്ഡ് പഠനത്തിനും ഉപയോഗിക്കാം. ഈ രീതിയിൽ, മുൻകൂട്ടി നിർവ്വചിച്ച പോയിന്റുകളുടെ എണ്ണം സൃഷ്ടിച്ച്, ഡാറ്റ ഈ പോയിന്റുകളുടെ ചുറ്റും ശേഖരിച്ച് പൊതുവായ ലേബലുകൾ പ്രവചിക്കാനാകും. K-Neighbors മെനമ്പരും മഹത്തായ പരമ്പരാഗത ആയ ML രീതികളില്‍നിന്നാണ്, അവ സൂപ്പർവൈസ്ഡ് ഉം അൺസൂപ്പർവൈസ്ഡ് പഠനത്തിനും ഉപയോഗിക്കാൻ കഴിയും. ഈ രീതിയില്‍, നിശ്ചിത എണ്ണത്തിലുള്ള പോയിന്റുകള്‍ ഉണ്ടാക്കി ആ പോയിന്റുകളെ ചുറ്റി ഡാറ്റ ശേഖരിച്ച് ആ ഡാറ്റയ്ക്ക് പൊതുവായ ലേബലുകള്‍ പ്രവചിക്കാം.
### അഭ്യാസം - K-Neighbors വർഗ്ഗീകരകൻ പ്രയോഗിക്കുക ### അഭ്യാസം - K-Neighbors ക്ലാസിഫയറിനെ ബാധിക്കുക
മുൻ വർഗ്ഗീകരകൻ നല്ലതായിരുന്നു, ഡാറ്റയുമായി നന്നായി പ്രവർത്തിച്ചു, പക്ഷേ നാം കൂടുതൽ കൃത്യത നേടാമോ എന്ന് നോക്കാം. K-Neighbors വർഗ്ഗീകരകൻ പരീക്ഷിക്കുക. മുന്‌ത്തെ ക്ലാസിഫയര്‍ മികച്ചതു, ഡാറ്റയുമായി വളരെ നന്നായി പ്രവര്‍ത്തിച്ചു; പക്ഷേ കൃത്യത കുറേക്കൂടി മെച്ചമാകാമെന്ന് കാണാം. K-Neighbors ക്ലാസിഫയറിന് ശ്രമിക്കുക.
1. നിങ്ങളുടെ വർഗ്ഗീകരക അറേയിൽ ഒരു വരി ചേർക്കുക (ലീനിയർ SVC ഇനത്തിന് ശേഷം കോമ ചേർക്കുക): 1. ക്ലാസിഫയർ നിരയിലെ ഒരു വരി ചേർക്കുക (Linear SVC വിഷയം കഴിഞ്ഞ്, ഒരു കോമ ബാധിക്കുക):
```python ```python
'KNN classifier': KNeighborsClassifier(C), 'KNN classifier': KNeighborsClassifier(C),
``` ```
ഫലം കുറച്ച് മോശമാണ്: ഫലം കൊച്ചുകൂടി മോശമാണ്:
```output ```output
Accuracy (train) for KNN classifier: 73.8% Accuracy (train) for KNN classifier: 73.8%
@ -136,23 +136,23 @@ K-Neighbors ML രീതികളായ "neighbors" കുടുംബത്ത
weighted avg 0.76 0.74 0.74 1199 weighted avg 0.76 0.74 0.74 1199
``` ```
✅ [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors) കുറിച്ച് പഠിക്കുക ✅ [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors) കുറിച്ച് ഭേദഗതി നേടുക
## Support Vector Classifier ## Support Vector Classifier
Support-Vector വർഗ്ഗീകരകർ [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine) ML രീതികളുടെ കുടുംബത്തിലെ ഭാഗമാണ്, വർഗ്ഗീകരണവും റെഗ്രഷനും വേണ്ടി ഉപയോഗിക്കുന്നു. SVMകൾ "പരിശീലന ഉദാഹരണങ്ങളെ ബിന്ദുക്കളായി മാപ്പ് ചെയ്യുന്നു" രണ്ട് വിഭാഗങ്ങൾക്കിടയിലെ ദൂരം പരമാവധി ആക്കാൻ. പിന്നീട് വരുന്ന ഡാറ്റ ഈ സ്ഥലത്ത് മാപ്പ് ചെയ്ത് അവരുടെ വിഭാഗം പ്രവചിക്കാം. Support-Vector ക്ലാസിഫയർ [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine) കുടുംബത്തിലെ ML രീതികളിലാണ്, ക്ലാസിഫിക്കേഷൻ, റെഗ്രഷൻ നടപടികള്‍ക്ക് ഉപയോഗിക്കുന്നു. SVMs "പരിശീലന ഉദാഹരണങ്ങളെ സ്ഥിതികളായി മാപ്പ് ചെയ്യുന്നു" δύο വിഭാഗങ്ങളിലിടയിലെ ദൂരം പരമാവധി വരുത്തുന്നതിനായി. തുടര്‍ന്നുള്ള ഡാറ്റ ഈ സ്ഥലത്തു മാപ്പ്ചെച് അവരുടെ വിഭാഗം പ്രവചിക്കപ്പെടുന്നു.
### അഭ്യാസം - Support Vector Classifier പ്രയോഗിക്കുക ### അഭ്യാസം - Support Vector Classifier പ്രയോജനം ചെയ്യുക
കുറച്ച് കൂടുതൽ കൃത്യതക്കായി Support Vector Classifier പരീക്ഷിക്കാം. കുറച്ച് മെച്ചപ്പെട്ട കൃത്യതക്കായി Support Vector Classifier പരീക്ഷിക്കാം.
1. K-Neighbors ഇനത്തിന് ശേഷം കോമ ചേർക്കുക, പിന്നെ ഈ വരി ചേർക്കുക: 1. K-Neighbors വിഷയം കഴിഞ്ഞ് കോമ ചേർത്ത് ഈ വരി ചേർക്കുക:
```python ```python
'SVC': SVC(), 'SVC': SVC(),
``` ```
ഫലം വളരെ നല്ലതാണ്! ഫലം വളരെ നന്നായിരിക്കുന്നു!
```output ```output
Accuracy (train) for SVC: 83.2% Accuracy (train) for SVC: 83.2%
@ -173,14 +173,14 @@ Support-Vector വർഗ്ഗീകരകർ [Support-Vector Machine](https://w
## Ensemble Classifiers ## Ensemble Classifiers
മുൻ പരീക്ഷണം വളരെ നല്ലതായിരുന്നു എങ്കിലും, പാതയുടെ അവസാനത്തേക്ക് പോകാം. 'Ensemble Classifiers', പ്രത്യേകിച്ച് Random Forest, AdaBoost പരീക്ഷിക്കാം: മുൻ പരീക്ഷണം നല്ലതായിരുന്നു എന്നാൽ പാതയുടെ അവസാനം വരെ പോകാം, പ്രത്യേകിച്ച് Random Forest ആയും AdaBoost ആയും Ensemble Classifiers ഉപയോഗിക്കുക:
```python ```python
'RFST': RandomForestClassifier(n_estimators=100), 'RFST': RandomForestClassifier(n_estimators=100),
'ADA': AdaBoostClassifier(n_estimators=100) 'ADA': AdaBoostClassifier(n_estimators=100)
``` ```
ഫലം വളരെ നല്ലതാണ്, പ്രത്യേകിച്ച് Random Forest: ഫലം വളരെ നല്ലതാണു, പ്രത്യേകിച്ച് Random Forest ന്:
```output ```output
Accuracy (train) for RFST: 84.5% Accuracy (train) for RFST: 84.5%
@ -212,31 +212,31 @@ weighted avg 0.73 0.72 0.72 1199
✅ [Ensemble Classifiers](https://scikit-learn.org/stable/modules/ensemble.html) കുറിച്ച് പഠിക്കുക ✅ [Ensemble Classifiers](https://scikit-learn.org/stable/modules/ensemble.html) കുറിച്ച് പഠിക്കുക
ഈ മെഷീൻ ലേണിംഗ് രീതി "അനേകം അടിസ്ഥാന എസ്റ്റിമേറ്റർമാരുടെ പ്രവചനങ്ങൾ സംയോജിപ്പിക്കുന്നു" മോഡലിന്റെ ഗുണമേന്മ മെച്ചപ്പെടുത്താൻ. നമ്മുടെ ഉദാഹരണത്തിൽ, Random Trees, AdaBoost ഉപയോഗിച്ചു. ഈ മെഷീൻ ലേണിംഗിലെ രീതി "വിഭിന്ന ബേസ് എസ്റ്റിമേറ്ററുകളുടെ പ്രവചനങ്ങൾ സംയോജിപ്പിച്ച്" മോഡലിന്റെ ഗുണമേൻമ വർദ്ധിപ്പിക്കുന്നു. നമ്മുടെ ഉദാഹരണത്തിൽ, റാൻഡം ട്രീസുകളും AdaBoost ഉം ഉപയോഗിച്ചു.
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), ഒരു ശരാശരി രീതി, 'decision trees' ന്റെ 'കാടുകൾ' നിർമ്മിക്കുന്നു, ഓവർഫിറ്റിംഗ് ഒഴിവാക്കാൻ റാൻഡംനസ് ചേർക്കുന്നു. n_estimators പാരാമീറ്റർ മരങ്ങളുടെ എണ്ണം സജ്ജമാക്കുന്നു. - [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), ഒരു ശരാശരി രീതി, 'ഡെസിഷൻ ട്രീസിന്റെ' ' ഫോറസ്റ്റ്' നിർമ്മിക്കുന്നു, overfitting-നെ തടയാൻ യാദൃശ്ചികത ചേർത്തിരിക്കുന്നു. ന_estimators പാരാമീറ്റർ തൈകളുടെ എണ്ണം സ്വരൂപിക്കുന്നു.
- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ഒരു ക്ലാസിഫയർ ഡാറ്റാസെറ്റിൽ ഫിറ്റ് ചെയ്ത്, അതേ ക്ലാസിഫയറിന്റെ പകർപ്പുകൾ അതേ ഡാറ്റാസെറ്റിൽ ഫിറ്റ് ചെയ്യുന്നു. തെറ്റായി വർഗ്ഗീകരിച്ച വസ്തുക്കളുടെ ഭാരം ശ്രദ്ധിച്ച് അടുത്ത ക്ലാസിഫയറിന്റെ ഫിറ്റ് ശരിയാക്കുന്നു. - [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ഒരു ക്ലാസിഫയറെ ഡാറ്റാസെറ്റിൽ ഒപ്പം ഒത്ത പൊരുത്തപ്പെടുത്തുന്നു, പിന്നീട് അതേ ക്ലാസിഫയറിന്റെ പകർപ്പുകൾ സമാന ഡാറ്റയിൽ फिट് ചെയ്യുന്നു. തെറ്റായി ക്ലാസിഫൈ ചെയ്ത അംശങ്ങളുടെ ഭാരങ്ങളിൽ കേന്ദ്രീകരിക്കുന്നു, പിന്നിലെ ക്ലാസിഫയർക്ക് ശരിയാക്കി പരിഹരിക്കാനായി.
--- ---
## 🚀ചലഞ്ച് ## 🚀ചിലവിടുന്നൊരു വെല്ലുവിളി
ഈ സാങ്കേതികവിദ്യകളിൽ ഓരോതിലും നിങ്ങൾ ക്രമീകരിക്കാവുന്ന നിരവധി പാരാമീറ്ററുകൾ ഉണ്ട്. ഓരോതിന്റെ ഡിഫോൾട്ട് പാരാമീറ്ററുകൾ ഗവേഷണം ചെയ്ത്, ഈ പാരാമീറ്ററുകൾ ക്രമീകരിക്കുന്നത് മോഡലിന്റെ ഗുണമേന്മയ്ക്ക് എന്ത് അർത്ഥമാക്കുമെന്ന് ചിന്തിക്കുക. ഈ എല്ലാ സാങ്കേതിക രീതി പരമീറ്ററുകളുടെ ഒരു വലിയ എണ്ണം ഉണ്ട്, അതിനെ നിങ്ങൾ തിളക്കത്തിനായി ക്രമീകരിക്കാം. ഓരോവയുടെയും ഡീഫോൾട്ട് പാരാമീറ്ററുകൾ അന്വേഷിച്ച് എന്നാലും ഈ പാരാമീറ്ററുകൾ ക്രമീകരിക്കാൻ മോഡലിന്റെ ഗുണമേൻമയ്ക്ക് എന്തെല്ലാം പ്രഭാവമാകും എന്ന് ചിന്തിച്ചുകൊണ്ട് പഠിക്കുക.
## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/) ## [പോസ്റ്റ്-ലെക്ഷർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
## അവലോകനം & സ്വയം പഠനം ## അവലോകനം & സ്വയം പഠനം
ഈ പാഠങ്ങളിൽ ധാരാളം സാങ്കേതിക പദങ്ങൾ ഉണ്ട്, അതിനാൽ [ഈ പട്ടിക](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) ഉപയോഗിച്ച് ഒരു നിമിഷം അവലോകനം ചെയ്യുക! ഈ പാഠങ്ങളിൽ ജെർഗൺ വളരെ ഉണ്ടാകുന്നു, കൃത്യമായി സമീക്ഷിക്കാൻ [ഈ പട്ടിക](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) പരിശോധിക്കുക!
## അസൈൻമെന്റ് ## അസൈൻമെന്റ്
[പാരാമീറ്റർ കളി](assignment.md) [പാരാമീറ്റർ പ്ലേ](assignment.md)
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**: **പ്രതിഭാസവ്യവസ്ഥ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല. ഈ രേഖ AI വിവർത്തന സേവനമായ [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. ഞങ്ങൾ ശരിയായ വിവർത്തനം നൽകാൻ ശ്രമിച്ചുവെങ്കിലും, യാന്ത്രിക വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ സാധുവല്ലാത്ത വിശദാംശങ്ങൾ ഉണ്ടാകാമെന്നും ശ്രദ്ധിക്കണം. നാടൻ ഭാഷയിലുള്ള നിലവിലുള്ള രേഖയാണ് അധികാരപരമായ ഉറവിടം എന്നുള്ള കാര്യം മനസ്സിലാക്കുക. അത്യാവശ്യമുള്ള വിവരങ്ങൾക്കായി പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം നിർദ്ദേശിക്കപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിച്ചതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

12
translations/ml/4-Classification/3-Classifiers-2/notebook.ipynb
Unescape View File

@ -116,15 +116,15 @@
} }
], ],
"source": [ "source": [
"cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n", "cuisines_features_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n",
"cuisines_feature_df.head()" "cuisines_features_df.head()"
] ]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**അസൂയാ**: \nഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n" "---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**നിഷേധ പ്രശ്നം**: \nഈ രേഖ എഐ വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തിരിക്കുന്നു. നാം ശരിയായതിനു ശ്രമിക്കുന്നുവെങ്കിലും, യാന്ത്രിക വിവർത്തനങ്ങളിൽ പിഴവുകൾ അല്ലെങ്കിൽ അകൃത്യതകൾ ഉണ്ടായിരിക്കും എന്നതിനുള്ള സാധ്യത ഉണ്ട്. ഇവിടെയുള്ള പ്രാദേശികഭാഷയിലെ മൂലരേഖയെ മാത്രമേ കൃത്യമായ ഉറവിടമായി കണക്കാക്കേണ്ടതുള്ളൂ. നിർണ്ണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യുന്നു. ഈ വിവർത്തനം ഉപയോഗിച്ചതിന്റെ ഫലമായി ഉണ്ടായ സംശയങ്ങളും തെറ്റിദ്ധാരണകളും біз ബാധ്യസ്ഥരല്ല.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
] ]
} }
], ],
@ -152,12 +152,6 @@
"interpreter": { "interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d" "hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
} }
},
"coopTranslator": {
"original_hash": "15a83277036572e0773229b5f21c1e12",
"translation_date": "2025-12-19T17:02:50+00:00",
"source_file": "4-Classification/3-Classifiers-2/notebook.ipynb",
"language_code": "ml"
} }
}, },
"nbformat": 4, "nbformat": 4,

16
translations/ml/4-Classification/3-Classifiers-2/solution/notebook.ipynb
Unescape View File

@ -116,15 +116,15 @@
} }
], ],
"source": [ "source": [
"cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n", "cuisines_features_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n",
"cuisines_feature_df.head()" "cuisines_features_df.head()"
] ]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"# വ്യത്യസ്ത ക്ലാസിഫയറുകൾ പരീക്ഷിക്കുക\n" "# വ്യത്യസ്ത ക്ലാസിഫയർമാർ ശ്രമിക്കൂ\n"
] ]
}, },
{ {
@ -148,7 +148,7 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)" "X_train, X_test, y_train, y_test = train_test_split(cuisines_features_df, cuisines_label_df, test_size=0.3)"
] ]
}, },
{ {
@ -263,7 +263,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**അസൂയാ**: \nഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n" "---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**അസ خیل**: \nഈ രേഖ AI പരിഭാഷാ සේവയായ [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് പരിഭാഷ ചെയ്തിരിക്കുന്നു. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയംസംവൃത്തമായ പരിഭാഷകളിൽ പിഴവുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ട്. യഥാർത്ഥ രേഖ അത് രേഖപ്പെടുത്തിയ സസ്വഭാവ ഭാഷയിലാണ് ഔദ്യോഗിക ഉറവിടമെന്ന നിലയിൽ കണക്കാക്കപ്പെടേണ്ടത്. നിർണായക വിവരങ്ങൾക്ക് പ്രൊഫഷണൽ മനുഷ്യ പരിഭാഷ ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ പരിഭാഷ ഉപയോഗിച്ചതിൽ നിന്നുണ്ടാകുന്ന ഏതൊരു തെറ്റിദ്ധാരണകൾക്കും ഞങ്ങൾ ഉത്തരവാദിത്വം വഹിക്കുന്നില്ല.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
] ]
} }
], ],
@ -291,12 +291,6 @@
"interpreter": { "interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d" "hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
} }
},
"coopTranslator": {
"original_hash": "7ea2b714669c823a596d986ba2d5739f",
"translation_date": "2025-12-19T17:09:10+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/notebook.ipynb",
"language_code": "ml"
} }
}, },
"nbformat": 4, "nbformat": 4,

258
translations/ml/README.md
Unescape View File

@ -10,215 +10,229 @@
### 🌐 ബഹുഭാഷാ പിന്തുണ ### 🌐 ബഹുഭാഷാ പിന്തുണ
#### GitHub Action മുഖേന പിന്തുണ (സ്വയമാറ്റവും എപ്പോഴും പുതുക്കിയതും) #### GitHub Action മുഖേന (സ്വയമേവവും എല്ലായിപ്പോഴും പുതുക്കിയതുമായ)
<!-- CO-OP TRANSLATOR LANGUAGES TABLE START --> <!-- CO-OP TRANSLATOR LANGUAGES TABLE START -->
[Arabic](../ar/README.md) | [Bengali](../bn/README.md) | [Bulgarian](../bg/README.md) | [Burmese (Myanmar)](../my/README.md) | [Chinese (Simplified)](../zh-CN/README.md) | [Chinese (Traditional, Hong Kong)](../zh-HK/README.md) | [Chinese (Traditional, Macau)](../zh-MO/README.md) | [Chinese (Traditional, Taiwan)](../zh-TW/README.md) | [Croatian](../hr/README.md) | [Czech](../cs/README.md) | [Danish](../da/README.md) | [Dutch](../nl/README.md) | [Estonian](../et/README.md) | [Finnish](../fi/README.md) | [French](../fr/README.md) | [German](../de/README.md) | [Greek](../el/README.md) | [Hebrew](../he/README.md) | [Hindi](../hi/README.md) | [Hungarian](../hu/README.md) | [Indonesian](../id/README.md) | [Italian](../it/README.md) | [Japanese](../ja/README.md) | [Kannada](../kn/README.md) | [Korean](../ko/README.md) | [Lithuanian](../lt/README.md) | [Malay](../ms/README.md) | [Malayalam](./README.md) | [Marathi](../mr/README.md) | [Nepali](../ne/README.md) | [Nigerian Pidgin](../pcm/README.md) | [Norwegian](../no/README.md) | [Persian (Farsi)](../fa/README.md) | [Polish](../pl/README.md) | [Portuguese (Brazil)](../pt-BR/README.md) | [Portuguese (Portugal)](../pt-PT/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Romanian](../ro/README.md) | [Russian](../ru/README.md) | [Serbian (Cyrillic)](../sr/README.md) | [Slovak](../sk/README.md) | [Slovenian](../sl/README.md) | [Spanish](../es/README.md) | [Swahili](../sw/README.md) | [Swedish](../sv/README.md) | [Tagalog (Filipino)](../tl/README.md) | [Tamil](../ta/README.md) | [Telugu](../te/README.md) | [Thai](../th/README.md) | [Turkish](../tr/README.md) | [Ukrainian](../uk/README.md) | [Urdu](../ur/README.md) | [Vietnamese](../vi/README.md) [Arabic](../ar/README.md) | [Bengali](../bn/README.md) | [Bulgarian](../bg/README.md) | [Burmese (Myanmar)](../my/README.md) | [Chinese (Simplified)](../zh-CN/README.md) | [Chinese (Traditional, Hong Kong)](../zh-HK/README.md) | [Chinese (Traditional, Macau)](../zh-MO/README.md) | [Chinese (Traditional, Taiwan)](../zh-TW/README.md) | [Croatian](../hr/README.md) | [Czech](../cs/README.md) | [Danish](../da/README.md) | [Dutch](../nl/README.md) | [Estonian](../et/README.md) | [Finnish](../fi/README.md) | [French](../fr/README.md) | [German](../de/README.md) | [Greek](../el/README.md) | [Hebrew](../he/README.md) | [Hindi](../hi/README.md) | [Hungarian](../hu/README.md) | [Indonesian](../id/README.md) | [Italian](../it/README.md) | [Japanese](../ja/README.md) | [Kannada](../kn/README.md) | [Korean](../ko/README.md) | [Lithuanian](../lt/README.md) | [Malay](../ms/README.md) | [Malayalam](./README.md) | [Marathi](../mr/README.md) | [Nepali](../ne/README.md) | [Nigerian Pidgin](../pcm/README.md) | [Norwegian](../no/README.md) | [Persian (Farsi)](../fa/README.md) | [Polish](../pl/README.md) | [Portuguese (Brazil)](../pt-BR/README.md) | [Portuguese (Portugal)](../pt-PT/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Romanian](../ro/README.md) | [Russian](../ru/README.md) | [Serbian (Cyrillic)](../sr/README.md) | [Slovak](../sk/README.md) | [Slovenian](../sl/README.md) | [Spanish](../es/README.md) | [Swahili](../sw/README.md) | [Swedish](../sv/README.md) | [Tagalog (Filipino)](../tl/README.md) | [Tamil](../ta/README.md) | [Telugu](../te/README.md) | [Thai](../th/README.md) | [Turkish](../tr/README.md) | [Ukrainian](../uk/README.md) | [Urdu](../ur/README.md) | [Vietnamese](../vi/README.md)
> **സ്ഥലീയമായി കോഡ് കോപ്പിസുചെയ്യാൻ ഇഷ്ടമാണോ?** > **പ്രിയപ്പെട്ടവരെ, ലോക്കലായി ക്ലോണ്‍ ചെയ്യുക ആഗ്രഹിക്കുന്നോ?**
>
> ഈ സംഭരണം 50+ ഭാഷാ പരിഭാഷകൾ ഉൾക്കൊള്ളുന്നത് കാരണം ഡൗൺലോഡ് വലിപ്പം വൻമൂല്യം വർദ്ധിപ്പിക്കുന്നു. പരിഭാഷകൾ കൂടാതെ കോഡ് കോപ്പി ചെയ്യാൻ sparse checkout ഉപയോഗിക്കുക: > ഈ റിപ്പോസിറ്ററിയില്‍ 50+ ഭാഷാ വിവര്‍ത്തനങ്ങള്‍ ഉള്‍പ്പെടുന്നു, ഇത് ഡൗണ്‍ലോഡ് വലുപ്പം ഗണ്യമായി വര്‍ധിപ്പിക്കും. വിവര്‍ത്തനങ്ങള്‍ ഇല്ലാതെ ക്ലോണ്‍ ചെയ്യാന്‍, സ്പാര്‍സ് ചെക്ഔട്ട് ഉപയോഗിക്കുക:
>
> **Bash / macOS / Linux:**
> ```bash > ```bash
> git clone --filter=blob:none --sparse https://github.com/microsoft/ML-For-Beginners.git > git clone --filter=blob:none --sparse https://github.com/microsoft/ML-For-Beginners.git
> cd ML-For-Beginners > cd ML-For-Beginners
> git sparse-checkout set --no-cone '/*' '!translations' '!translated_images' > git sparse-checkout set --no-cone '/*' '!translations' '!translated_images'
> ``` > ```
> ഇതു കോഴ്‌സ് പൂർത്തിയാക്കാനുള്ള എല്ലാ ആവശ്യകതകളും വേഗത്തിൽ ലഭ്യമാക്കും. >
> **CMD (Windows):**
> ```cmd
> git clone --filter=blob:none --sparse https://github.com/microsoft/ML-For-Beginners.git
> cd ML-For-Beginners
> git sparse-checkout set --no-cone "/*" "!translations" "!translated_images"
> ```
>
> ഇതിലൂടെതാഴ്ന്ന ഡൗൺലോഡ് സമയത്തോട് കൂടെ നിങ്ങൾക്ക് പാഠ്യപദ്ധതി പൂർത്തിയാക്കാന്‍ ആവശ്യമായ എല്ലാം ലഭിക്കും.
<!-- CO-OP TRANSLATOR LANGUAGES TABLE END --> <!-- CO-OP TRANSLATOR LANGUAGES TABLE END -->
#### നമ്മുടെ കമ്മ്യൂണിറ്റിയുമായി ചേർക്കൂ #### ഞങ്ങളുടെ സമൂഹത്തിലേക്ക് شامل ٿيو
[![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG) [![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG)
നമുക്കൊരു Discord ലേർൺ വിത് AI പരമ്പരയുണ്ട്, കൂടുതൽ വിവരങ്ങൾക്കും ചേരാനും [Learn with AI Series](https://aka.ms/learnwithai/discord) സന്ദർശിക്കുക, 2025 സെപ്റ്റംബർ 18 - 30 വരെ. GitHub Copilot ഡേറ്റാ സയൻസിനായി ഉപയോഗിക്കുന്ന ടിപ്പ്‌സുകളും ട്രിക്കുകളും നിങ്ങൾക്ക് ലഭിക്കും. നാമൊരു ഡിസ്കോർഡ് 'learn with AI' സീരീസ് നടത്തുകയാണ്, 18 - 30 സെപ്റ്റംബർ, 2025 കാലയളവിൽ [Learn with AI Series](https://aka.ms/learnwithai/discord) ൽ കൂടി ഞങ്ങളോടൊപ്പം ചേക്കേറുക. ഡാറ്റ സയൻസിനായി GitHub Copilot ഉപയോഗിക്കുന്ന ടിപ്പുകളും ട്രിക്കുകളും നിങ്ങൾക്ക് ലഭിക്കും.
![Learn with AI series](../../translated_images/ml/3.9b58fd8d6c373c20.webp) ![Learn with AI series](../../translated_images/ml/3.9b58fd8d6c373c20.webp)
# തുടക്കക്കാർക്കുള്ള മെഷീൻ ലേണിംഗ് - ഒരു പഠനപദ്ധതി # തുടക്കക്കാർക്കുള്ള മെഷീൻ ലേണിംഗ് - ഒരു പാഠ്യപദ്ധതി
> 🌍 ലോക സംസ്കാരങ്ങളിലൂടെ മെഷീൻ ലേണിംഗ് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് ഞങ്ങളൊടു കൂടി അന്വഷിക്കാം 🌍 > 🌍 ലോക സംസ്കാരങ്ങളിലൂടെ മധ്യേയൂ ട്രാവൽ ചെയ്ത് മെഷീൻ ലേണിംഗ് പഠിക്കാം 🌍
മൈക്രോസോഫ്റ്റിലെ ക്ലൗഡ് അഡ്വക്കേറ്റ്സ് 12 ആഴ്ചകളിൽ 26 പാഠങ്ങൾ ഉള്ള **മെഷീൻ ലേണിംഗ്** പഠനപരിപാടി അവതരിപ്പിയ്ക്കാൻ സന്തോഷിക്കുന്നു. ഈ പഠനപദ്ധതിയിൽ നിങ്ങൾക്ക് ചിലപ്പോൾ **ക്ലാസിക് മെഷീൻ ലേണിംഗ്** എന്നും വിളിക്കുന്നതിന്റെ അടിസ്ഥാനങ്ങൾ പഠിക്കാം, പ്രധാനമായി Scikit-learn ലൈബ്രറി ഉപയോഗിച്ച്, ഡീപ്പ് ലേണിംഗ് ഒഴിവാക്കി, അത് ഞങ്ങളുടെ [AI for Beginners' curriculum](https://aka.ms/ai4beginners) ൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഈ പാഠങ്ങൾ ഞങ്ങളുടെ ['Data Science for Beginners' curriculum](https://aka.ms/ds4beginners) ഉപയോഗിച്ച് ചേർത്ത് പഠിക്കാം. Microsoft ലിലെ Cloud Advocates നിങ്ങളുടെ സേവനത്തിൽ ഒരു 12-ആഴ്ച, 26 പാഠങ്ങളുടെ പാഠ്യപദ്ധതി സമർപ്പിക്കുന്നതിൽ സന്തോഷം പറയുന്നു, ഇത് **Machine Learning**യെക്കുറിച്ചാണ്. ഈ പാഠ്യപദ്ധതിയിൽ, പലപ്പോഴും **ശാസ്ത്രീയ മെഷീൻ ലേണിംഗ്** എന്നറിയപ്പെടുന്നതു പഠിക്കും, പ്രാഥമികമായും Scikit-learn ലൈബ്രറിയെ ഉപയോഗിച്ച്, ഡീപ്പ് ലേണിംഗ് ഒഴിവാക്കി, അത് നമ്മുടെ [AI for Beginners' curriculum](https://aka.ms/ai4beginners) ൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഈ പാഠങ്ങൾ ഞങ്ങളുടെ ['Data Science for Beginners' curriculum](https://aka.ms/ds4beginners) നെ കൂടെ കൂട്ടിച്ചേർക്കൂ!
ലോകത്തിലെ വിവിധ ഭാഗങ്ങളിൽ നിന്നുള്ള ഡേറ്റയുമായി ഈ ക്ലാസിക് സാങ്കേതിക വിദ്യകൾ പ്രയോഗിക്കുമ്പോൾ ഞങ്ങളോടുകൂടെ യാത്ര നടത്തുന്നുണ്ടാകൂ. ഓരോ പാഠത്തിലും മുൻ-യും പിന്‍പും ക്വിസുകള്‍, എഴുത്ത് നിർദ്ദേശങ്ങൾ, പരിഹാരങ്ങൾ, ടാസ്കുകൾ എന്നിവയുണ്ട്. ഞങ്ങളുടെ പ്രോജെക്റ്റ് അടിസ്ഥാനത്തിലുള്ള പാഠശൈലി പുതിയ കഴിവുകൾ മനസിലാക്കുകയും മെച്ചപ്പെടുത്തുകയും ചെയ്യാൻ സഹായിക്കുന്നു. ലോകത്തിലെ വിവിധ ഭാഗങ്ങളിൽ നിന്നുള്ള ഡാറ്റയിൽ ഈ ശാസ്ത്രീയ സാങ്കേതികവിദ്യകൾ പ്രയോഗിച്ച് ലോകമയാത്ര ചെയ്യാം. ഓരോ പാഠവും മുൻപ്-പോസ്റ്റു-ക്വിസുകൾ, പാഠ مکملമാക്കുന്നതിനുള്ള എഴുത്തുരേഖകൾ, പരിഹാരം, അസൈൻമെന്റ് എന്നിവ ഉൾക്കൊള്ളുന്നു. ഞങ്ങളുടെ പ്രൊജക്ട്-ആധാരിത പദഗതി നിങ്ങളെ ഉത്തരവാദിത്വത്തോടെ പഠിപ്പിക്കും, പുതിയ കഴിവുകൾ ഉറപ്പായി തിരഞ്ഞെടുക്കാൻ സഹായിക്കും.
**✍️ ഞങ്ങളുടെ രചയിതാക്കൾക്ക് ഹൃദയം നിറഞ്ഞ നന്ദി** ജെൻ ലൂപ്പർ, സ്റ്റീഫൻ ഹൗവെൽ, ഫ്രാൻസെസ്ക്ക ലസ്ജേരി, തോമോമി ഇമുര, കാസ്സി ബ്രേവിയു, ദിമിത്രി സോഷ്നികോവ്, ക്രിസ് നോറിംഗ്, അനിർബാൻ മുഖർജ്ജി, ഓർണെല്ല എൽടുന്യൻ, റൂത്ത് യാകുബു, ആമി ബോയ്‌ഡ് **✍️ ഞങ്ങളുടെ എഴുത്തുകാർക്ക് ഹൃദയം നിറഞ്ഞ നന്ദി**: Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu, Amy Boyd
**🎨 നമ്മുടെ ചിത്രകാരന്മാർക്കു കൂടി നന്ദി** തോമോമി ഇമുര, ദാസാനി മഡിപള്ളി, ജെൻ ലൂപ്പർ **🎨 ഞങ്ങളുടെ ചിത്രകാരന്മാർക്കും നന്ദി**: Tomomi Imura, Dasani Madipalli, Jen Looper
**🙏 പ്രത്യേക നന്ദികൾ Microsoft Student Ambassador രചയിതാക്കളായും, നിരീക്ഷകരും, ഉള്ളടക്ക സംഭാവകരുമായ ട്ടുള്ളവർക്ക്**, പ്രത്യേകിച്ച് റിഷിത് ഡാഗ്ലി, മുഹമ്മദ് സാകിബ് ഖാൻ ഇനാൻ, ロഹാൻ രാജ്, അലക്സാന്‍ഡ്രു പെട്രെസ്കു, അഭിഷേക് ജയസ്വൽ, നൗറിൻ ടബസ്സും, ഇവാന സംയുല, സ്നിഗ്ധ അഗർവാൾ **🙏 പ്രത്യേക നന്ദി 🙏 Microsoft സ്റ്റുഡന്റ് അംബാസിഡർ എഴുത്തുകാരും റിവ്യൂവേഴ്സും കണ്ടന്റ് സംഭാവകരും**, പ്രത്യേകിച്ച് Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila, Snigdha Agarwal
**🤩 Microsoft Student Ambassadors എറിക് വൻജാവ്, ജസ്ലീൻ സോന്ധി, വിദ്യുഷി ഗുപ്തയ്ക്ക് R പാഠങ്ങൾക്കുള്ള നന്ദി!** **🤩 Microsoft സ്റ്റുഡന്റ് അംബാസിഡർമാരായ Eric Wanjau, Jasleen Sondhi, Vidushi Gupta എന്നിവർക്ക് R പാഠങ്ങളിലുള്ള പ്രത്യേക നന്ദി!**
# ആരംഭം # ആരംഭിക്കുന്ന വിധം
ഈ ചുവടുകൾ പാലിക്കുക: ഈ ചുവടുകൾ പിന്തുടരുക:
1. **സംഗ്രഹം ഫോർക്ക് ചെയുക**: ഈ പേജിന്റെ മുകളിൽ വലത്തുഭാഗത്ത് "Fork" ബട്ടൺ ക്ലിക്കുക. 1. **റിപ്പോസിറ്ററി ഫോർക്കുചെയ്യുക**: ഈ പേജ് വലതുഭാഗത്ത് "Fork" ബട്ടൺ ക്ലിക്ക് ചെയ്യുക.
2. **സംഗ്രഹം ക്ലോൺ ചെയ്യുക**: `git clone https://github.com/microsoft/ML-For-Beginners.git` 2. **റിപ്പോസിറ്ററി ക്ലോണ്‍ ചെയ്യുക**: `git clone https://github.com/microsoft/ML-For-Beginners.git`
> [ഈ കോഴ്‌സിനുള്ള എല്ലാ അധിക സ്രോതസ്സുകളും ഞങ്ങളുടെ Microsoft Learn ശേഖരത്തിൽ കണ്ടെത്തുക](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum) > [ഈ കോഴ്സിനുള്ള എല്ലാ അധിക വിഭവങ്ങളും Microsoft Learn കൂട്ടത്തിൽ കണ്ടെത്തുക](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> 🔧 **സഹായം വേണോ?** ഇൻസ്റ്റാളേഷൻ, ക്രമീകരണം, പാഠങ്ങൾ റൺ ചെയ്യുന്നതുമായി ബന്ധപ്പെട്ട സാധാരണ പ്രശ്നങ്ങൾക്ക് പരിഹാരങ്ങൾ കണ്ടെത്താൻ [Troubleshooting Guide](TROUBLESHOOTING.md) പരിശോധിക്കുക. > 🔧 **സഹായം വേണമോ?** ഇൻസ്റ്റാളേഷൻ, സെറ്റ്‌അപ്പ്, പാഠങ്ങൾ നടത്തുന്നതുമായി ബന്ധപ്പെട്ട സാധാരണ പ്രശ്‌നങ്ങൾക്ക് പരിഹാരം നൽകുന്ന [Troubleshooting Guide](TROUBLESHOOTING.md) പരിശോധിക്കൂ.
**[വിദ്യാർത്ഥികൾ](https://aka.ms/student-page)**, ഈ പഠനപദ്ധതി ഉപയോഗിക്കാൻ, മുഴുവൻ റീപ്പോ നിങ്ങളുടേതായി ഫോർക്ക് ചെയ്ത് വ്യത്യസ്ത ഗ്രൂപ്പുകളുമായി അല്ലെങ്കിൽ ഒറ്റയ്ക്ക് പരിശീലനങ്ങൾ പൂർത്തിയാക്കുക: **[വിദ്യാർത്ഥികൾ](https://aka.ms/student-page)**, ഈ പാഠ്യപദ്ധതിയുടെ ഉപയോഗത്തിനായി, മുഴുവൻ റീപ്പോ നിങ്ങളുടെ സ്വന്തം GitHub അക്കൗണ്ടിലേക്ക് ഫോർക്കുചെയ്യുകയും വ്യത്യസ്ത വ്യായാമങ്ങൾ സ്വയം അല്ലെങ്കിൽ ഗ്രൂപ്പിനൊപ്പം പൂർത്തിയാക്കുകയും ചെയ്യുക:
- പാഠം തുടങ്ങുന്നതിനു മുൻപ് ക്വിസ് നടത്തുക. - ഒരു പ്രീ-ലെക്ചർ ക്വിസ് ആരംഭിക്കുക.
- പാഠം വായിച്ച് പ്രവർത്തനങ്ങൾ പൂർത്തിയാക്കുക, ഓരോ വിജ്ഞാന പരിശോധനയിലും ചിന്തിക്കാൻ സമയം കൊടുക്കുക. - പ്രഭാഷണം വായിച്ച് പ്രവർത്തനങ്ങൾ പൂർത്തിയാക്കുക, ഓരോ നോമനുസരണ ചോദ്യത്തിലും നിർത്തി ആലോചിക്കുക.
- പാഠങ്ങൾ മനസ്സിലാക്കി പ്രോജക്ടുകൾ സ്വയം നിർമ്മിക്കാൻ ശ്രമിക്കുക, പരിഹാര കോഡ് `/solution` ഫോളഡറുകളിലുണ്ട്. - പാഠങ്ങൾ മനസ്സിലാക്കി പ്രോജക്ടുകൾ സൃഷ്ടിക്കാൻ ശ്രമിക്കുക, പരിഹാര കോഡ് റൺ ചെയ്യുന്നതിനു പകരം; അതുവഴി /solution ഫോൾഡറുകളിലെ കോഡ് ലഭ്യമാണ്.
- പാഠം കഴിഞ്ഞു ക്വിസ് എഴുതുക. - പോസ്റ്റ്-ലെക്ചർ ക്വിസ് എടുത്തുക.
- ചലഞ്ച് പൂർത്തിയാക്കുക. - ചലഞ്ച് പൂർത്തിയാക്കുക.
- അസൈൻമെന്റ് നടത്തുക. - അസൈൻമെന്റ് പൂർത്തിയാക്കുക.
- ഒരു പാഠ ഗ്രൂപ്പ് കഴിഞ്ഞു കഴിഞ്ഞാൽ, [Discussion Board](https://github.com/microsoft/ML-For-Beginners/discussions) സന്ദർശിച്ച് അനുയോജ്യമായ PAT റൂബ്രിക് പൂരിപ്പിച്ച് "learn out loud" ചെയ്യുക. 'PAT' progress assessment tool ആണ്, ഇത് നിങ്ങളുടേ പഠനം മുന്നോട്ട് പോകാൻ സഹായിക്കും. മറ്റുള്ള PAT കളിൽ പ്രതികരിക്കുകയും ഞങ്ങൾ ഒരുമിച്ചു പഠിക്കാനും കഴിയും. - ഒരു പാഠ ഗ്രൂപ്പ് പൂർത്തിയാക്കിയശേഷം, [Discussion Board](https://github.com/microsoft/ML-For-Beginners/discussions) സന്ദർശിച്ച് അനുയോജ്യമായ PAT റൂബ്രിക് പൂരിപ്പിച്ച് "learn out loud" ചെയ്യുക. 'PAT' progress assessment tool ആണ്, പഠനത്തിനു സഹായകരമായ ഒരു റൂബ്രിക്. ഇത്തരത്തിലുള്ള മറ്റ് PAT-കളിൽ പ്രതികരിച്ചോളാം, ഒപ്പം പഠിച്ചോളാം.
> കൂടുതൽ പഠനത്തിനായി, ഈ [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) മോദ്യുലുകളും പഠന പാതകളും പിന്തുടരാൻ ശിപാർശ ചെയ്യുന്നു. > കൂടുതൽ പഠനത്തിന്, ഈ [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) മോഡ്യൂളുകളും പഠന പാതകളും പിന്തുടരാൻ ശിപാര്‍ശ ചെയ്യുന്നു.
**അധ്യാപകർ**, ഈ പഠനപദ്ധതി ഉപയോഗിക്കുന്നതിന് [ചില നിർദ്ദേശങ്ങൾ](for-teachers.md) ഞങ്ങൾ നൽകിയിട്ടുണ്ട്. **അധ്യാപകർക്ക്** ഈ പാഠ്യപദ്ധതി ഉപയോഗിക്കുന്നതിനുള്ള ചില ശുപാർശകൾ ഞങ്ങൾ [ഇവിടെ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്](for-teachers.md).
--- ---
## വീഡിോ വിശദീകരണങ്ങൾ ## വീഡിയോ വഴിതടങ്ങൾ
കൊല്ലം മാറുന്ന വീഡിയോകൾ ചില പാഠങ്ങൾക്കുണ്ട്. എല്ലാം പാഠങ്ങൾക്കുള്ളിൽ തന്നെ ലഭിച്ചേക്കും അല്ലെങ്കിൽ [ML for Beginners യുട്യൂബ് പ്ലേലിസ്റ്റിൽ](https://aka.ms/ml-beginners-videos) താഴെ ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്ത് കാണാം. കുറച്ച് പാഠങ്ങൾ ചുരുക്കത്തിലുള്ള വീഡിയോ രൂപത്തിൽ ലഭ്യമാണ്. ഇവ പാഠങ്ങളുടെ വരിയിലെങ്കിലും, [Microsoft Developer YouTube ചാനലിലെ ML for Beginners പ്ലേലിസ്റ്റിൽ](https://aka.ms/ml-beginners-videos) താഴെ കാണുന്ന ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്‌തും കണ്ടെത്താം.
[![ML for beginners banner](../../translated_images/ml/ml-for-beginners-video-banner.63f694a100034bc6.webp)](https://aka.ms/ml-beginners-videos) [![ML for beginners banner](../../translated_images/ml/ml-for-beginners-video-banner.63f694a100034bc6.webp)](https://aka.ms/ml-beginners-videos)
--- ---
## ടീം പരിചയം ## ടീമാണ് അഭിമുഖം നടത്തുക
[![Promo video](../../images/ml.gif)](https://youtu.be/Tj1XWrDSYJU) [![Promo video](../../images/ml.gif)](https://youtu.be/Tj1XWrDSYJU)
**ഗിഫ്** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal) **ഗിഫ്** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)
> 🎥 മേൽചിത്രം ക്ലിക്ക് ചെയ്‌തു ഈ പ്രോജക്ടും അതത് സൃഷ്ടാക്കളും കുറിച്ച് വീഡിയൊ കാണുക! > 🎥 ഈ പ്രോജക്ടിന്റെയും സൃഷ്ടിച്ചവരുടെയും വീഡിയോ കാണാൻ മുകളിൽ കാണുന്ന ചിത്രം ക്ലിക്ക് ചെയ്യുക!
--- ---
## പഠനശൈലി ## പഠനരീതി
ഈ പഠനപദ്ധതി രൂപകൽപ്പന ചെയ്യുമ്പോൾ ഞങ്ങൾ തിരഞ്ഞെടുത്ത രണ്ട് പ്രധാന തത്വങ്ങൾ ഉണ്ട്: പ്രായോഗികമായും **പ്രോജെക്റ്റ്-അധിഷ്ഠിതമായ** രീതിയും, കൂടാതെ **തിയ്യതി കുറഞ്ഞ കൂടിയ ഒഴിവുകളുള്ള ക്വിസുകൾ** ഉൾപ്പെടുത്തലും. കൂടാതെ, ഈ പാഠ്യം ഏകോപനത്തിനായി സാധാരണമായ ഒരു **തെീം** ഉള്ളതും ആണ്. ഈ പാഠ്യപദ്ധതി നിർമ്മിക്കുമ്പോൾ കേരളത്തു രണ്ടിടത്തായി ശ്രദ്ധിച്ചു: ഹാൻഡ്‌സ്-ഓൺ **പ്രോജക്ട്-ബേസ്ഡ്** ആയിരിക്കണം, കൂടാതെ **സാധാരണ ക്വിസുകൾ** ഉണ്ടാകണം. കൂടാതെ, പാഠ്യപദ്ധതിക്ക് ഒരു സാധാരണ **തീം** ഉണ്ടായിരിക്കണം.
വിഷയങ്ങൾ പ്രോജക്റ്റുകളിലേക്കു നേരെയുള്‍‍‌പ്പെടുത്തുന്നത് വിദ്യാർത്ഥികൾക്കു പഠിക്കാൻ ഉത്സാഹകരവും സങ്കൽപങ്ങൾ കൂടുതൽ നല്ലമായി ഓർമ്മിക്കാനും സഹായിക്കും. കൂടാതെ ക്ലാസിന് മുന്നോടിയായി കുറഞ്ഞ സമ്മർദമുള്ള ഒരു ക്വിസ് വിദ്യാർത്ഥിയുടെ പഠന ഊർജ്ജമുണ്ടാക്കുകയും, ക്ലാസ് കഴിഞ്ഞ് മറ്റൊരു ക്വിസ് അടുക്കിയാൽ കൂടുതൽ ഓർമ്മ ശേഷി ഉറപ്പാക്കുകയും ചെയ്യും. ഈ പഠനപദ്ധതി കാര്യക്ഷമവും രസകരവുമുള്ളതാണ്. മുഴുവനും അല്ലെങ്കിൽ ഭാഗികമായി എടുക്കാനാകും. 12 ആഴ്ചകളിൽ പ്രോജക്റ്റുകൾ ചെറുതായി ആരംഭിച്ച് കൂടുതൽ സങ്കീർണമായിരിക്കും. ML യുടെ യഥാർത്ഥ ലോക പ്രയോഗങ്ങളുടെ ഒരു പ്രത്യേക വിഭാഗവും ഈ പഠനപദ്ധതിയിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, കൂടെ ആഡംബര ക്രെഡിറ്റ് അല്ലെങ്കിൽ ചർച്ചകൾക്കുള്ള അടിസ്ഥാനം ആയി ഉപയോഗിക്കാം. സന്ദർഭം പ്രോജക്ടുകളുമായി ഒത്തുചേരുന്നതിനാൽ വിദ്യാര്‍ത്ഥികൾക്ക് ഉൾക്കാഴ്ചയും പാഠങ്ങൾ എളുപ്പത്തോടെ മനസ്സിലാകുന്നതുമാണ് സംഭവിക്കുന്നത്; നിമിഷം കുറഞ്ഞ ക്വിസ് ഒരു ക്ലാസിന് മുൻപായി വിദ്യാർത്ഥിയുടെ പഠന ഉദ്ദേശ്യം സജ്ജീകരിക്കും, രണ്ടാമത്തേക്കു ക്വിസ് മെച്ചപ്പെട്ട മനസ്സിലാക്കലും ഉറപ്പാക്കും. ഈ പാഠ്യപദ്ധതി ഇളവുള്ളതും രസകരവുമാണ്, മുഴുവൻ പാഠ്യപദ്ധതിയോ അതിലുണ്ടായ ഭാഗങ്ങളോ പഠിക്കാവുന്നതാണ്. പ്രോജക്ടുകൾ ചെറിയതിങ്ങനെ ആരംഭിച്ച് 12 ആഴ്ചകളുടെ അവസാനം കൂടുതൽ സങ്കീർണ്ണമാകും. യഥാർത്ഥ ലോക പരിഗണനകൾ ഉൾപ്പെടുന്ന ഒരു പോസ്റ്റ്‌സ്‌ക്രിപ്റ്റും ഇതിലുണ്ട്, ഇത് അധിക ക്രെഡിറ്റിനോ സംവാദത്തിനോ ഉപയോഗിക്കാം.
> ഞങ്ങളുടെ [Code of Conduct](CODE_OF_CONDUCT.md), [Contributing](CONTRIBUTING.md), [Translation](TRANSLATIONS.md), [Troubleshooting](TROUBLESHOOTING.md) മാർഗ്ഗനിർദ്ദേശങ്ങൾ വായിക്കുക. നിങ്ങളുടെ പോസിറ്റീവ് അഭിപ്രായങ്ങൾ ഞങ്ങൾക്ക് സന്തോഷമാകുന്നു! > ഞങ്ങളുടെ [Code of Conduct](CODE_OF_CONDUCT.md), [Contributing](CONTRIBUTING.md), [Translation](TRANSLATIONS.md), [Troubleshooting](TROUBLESHOOTING.md) ഗൈഡ്ലൈനുകൾ കാണുക. നിങ്ങളുടെ നിർമാതൃകാത്മക கருத்தുകൾ സ്വാഗതം!
## ഓരോ പാഠത്തിലുമുള്ളവ ## ഓരോ പാഠത്തിലും ഉൾപ്പെടുന്നത്
- ഓപ്ഷണൽ സ്കെച്ച്നോട്ട് - ഐച്ഛിക സ്കെച്ച്നോട്ട്
- ഓപ്ഷണൽ സപ്ലിമെന്റൽ വീഡിയൊ - ഐച്ഛിക സപ്ലിമെന്ററി വീഡിയോ
- വീഡിയൊ വാക്ക് ത്രൂ (വരെ ചില പാഠങ്ങൾക്കു മാത്രം) - വീഡിയോ വഴി മാർഗ്‌ദർശനം (ചില പാഠങ്ങൾ മാത്രം)
- [പൂർവ പാഠ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/) - [പ്രീ-ലെക്ചർ വാർമപ്പ് ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
- എഴുതിയ പാഠം - എഴുത്തുപാഠം
- പ്രോജക്റ്റ് അടിസ്ഥാനപ്പെടുന്ന പാഠങ്ങൾക്ക്, പ്രോജക്റ്റ് നിർമ്മിക്കുന്നതിനുള്ള ഘട്ടം ഘട്ടമായുള്ള നിർദ്ദേശങ്ങൾ - പ്രോജക്ട്-ബേസ്ഡ് പാഠങ്ങൾക്ക്, പ്രവൃത്തി നിർദ്ദേശങ്ങൾ
- വിജ്ഞാന പരിശോധനകള - നോളേജ് ചെക്കുകൾ
- ഒരു ചലഞ്ച് - ഒരു മത്സരപരീക്ഷ
- കൂടെയുള്ള വായന - തീരുവത്തിൽ വായന
- അസൈൻമെന്റ് - അസൈൻമെന്റ്
- [പോസ്റ്റ്-പാഠ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/) - [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)
> **ഭാഷകളെക്കുറിച്ചുള്ള ഒരു കുറിപ്പ്**: ഈ പാഠങ്ങൾ പ്രധാനമായും Python-ൽ എഴുതപ്പെട്ടതാണ്, എന്നാൽ പലതും R-ലിലും ലഭ്യമാണ്. ഒരു R പാഠം പൂർത്തിയാക്കാൻ, `/solution` ഫോൾഡറിൽ പോയി R പാഠങ്ങൾ കാണുക. അവയ്ക്ക് .rmd എക്സ്റ്റൻഷൻ ഉണ്ട്, ഇത് **R Markdown** ഫയൽ ആണ്, ഇത് ഒരു `Markdown ഡോക്യുമെന്റിൽ` `code chunks` (R അല്ലെങ്കിൽ മറ്റു ഭാഷകളിലെ)യും `YAML ഹെഡർ` (PDF പോലുള്ള ഔട്ട്പുട്ടുകൾ എങ്ങനെ ഫോർമാറ്റ് ചെയ്യണമെന്ന് മാർഗനിർദേശിക്കുന്ന) എന്നടക്കമുളള ഒരു ഘടകവും ഉൾക്കൊണ്ടാണ്. അതിനാൽ, σας നിങ്ങളുടെ കോഡ്, അതിന്റെ ഔട്ട്പുട്ട്, നിങ്ങളുടെ ചിന്തകൾ എന്നിവയെ Markdown-ൽ എഴുതാൻ അനുവദിക്കുന്നതിനാൽ, ഇത് ഡാറ്റാ സയൻസിനായി ഉദാഹരണരൂപത്തിലുള്ള ഒരു റൈറ്റിംഗ് ഫ്രെയിംവർക്ക് ആയി സേവിക്കുന്നു. കൂടാതെ, R Markdown ഡോക്യുമെന്റുകൾ PDF, HTML, അല്ലെങ്കിൽ Word പോലുള്ള ഔട്ട്പുട്ട് ഫോർമാറ്റുകളിലേക്ക് രendere ചെയ്യാം.
> **ഭാഷ സംബന്ധിച്ച ഒരു കുറിപ്പ്**: ഈ പാഠങ്ങൾ പ്രധാനമായും Python ലിലാണ് എഴുതിയിട്ടുള്ളത്, എന്നാൽ പലത് R ലും ലഭ്യമാണ്. R പാഠം പൂർത്തിയാക്കാൻ `/solution` ഫോൾഡറിൽ പോയി R പാഠങ്ങൾ വയ്ക്കപ്പെട്ടിട്ടുള്ളവ അന്വേഷിക്കുക. അവയ്ക്ക് `.rmd` വിപുലീകരണം ഉണ്ട്, അതാണ് **R Markdown** ഫയൽ, കൂടാതെ കോഡ് ചങ്കുകൾ (R അല്ലെങ്കിൽ മറ്റ് ഭാഷകൾ), `YAML header` ഉപയോഗിച്ച് Markdown ഡോക്കുമെന്റുകളിൽ എഴുതിയിത്തളകൾ ചേർക്കാൻ സഹായിക്കുന്നു. ഇത് ഡാറ്റ സയൻസിന് മികച്ച ഒരു എഴുത്തുകൂടിയാണ്, നിങ്ങളുടെ കോഡ്, അതിന്റെ ഔട്ട്‌പുട്ട്, അഭിപ്രായങ്ങൾ എന്നിവയെല്ലാം Markdown ൽ എഴുതാം. കൂടാതെ R Markdown ഡോക്കുമെന്റുകൾ PDF, HTML, Word പോലുള്ള ഫോർമാറ്റുകളിൽ മാറ്റാനും കഴിയും.
> **ക്വിസുകളെ കുറിച്ചുള്ള ഒരു കുറിപ്പ്**: മൂന്നു ചോദ്യങ്ങളുള്ള 52 ക്വിസുകൾക്ക് സംരക്ഷിച്ചിരിക്കുന്ന [Quiz App ഫോൾഡർ](../../quiz-app)യിൽ എല്ലാ ക്വിസുകളും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. അവ പാഠങ്ങളിൽ നിന്ന് ലിങ്ക് ചെയ്തിട്ടുണ്ട്, എന്നാൽ ക്വിസ് ആപ്പ് ലോക്കലായി പ്രവർത്തിപ്പിക്കാൻ കഴിയും; ലോക്കലായി ഹോസ്റ്റ് ചെയ്യുന്നതിന് അല്ലെങ്കിൽ Azure-യിലേക്ക് ഡിപ്ലോയ്മെന്റ് നടത്താൻ `quiz-app` ഫോൾഡറിലുള്ള നിർദ്ദേശങ്ങൾ അനുസരിക്കുക. > **ക്വിസുകളെക്കുറിച്ചുള്ള ഒരു കുറിപ്പ്**: എല്ലാ ക്വിസുകളും [Quiz App folder](../../quiz-app) എന്നിടത്ത് ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, മൂന്ന് ചോദ്യങ്ങളുള്ള 52 മൊത്തം ക്വിസുകളാണ്. ഇവ പാഠങ്ങളിലൂടെയും ബന്ധിപ്പിച്ചിരിക്കുന്നു, പക്ഷേ ക്വിസ് ആപ്പ് പ്രാദേശികമായി പ്രവർത്തിപ്പിക്കാവുന്നതാണ്; പ്രാദേശികമായി ഹോസ്റ്റ് ചെയ്യാനോ Azure-ലേക്ക് ഡിപ്ലോയ് ചെയ്യാനോ `quiz-app` ഫോൾഡറിലെ നിർദ്ദേശങ്ങൾ പാലിക്കുക.
| പാഠസംഖ്യ | വിഷയം | പാഠ ഗ്രൂപ്പിംഗ് | പഠനലക്ഷ്യങ്ങൾ | ലിങ്ക് ചെയ്ത പാഠം | എഴുത്തുകാരൻ | | പാഠം നമ്പർ | വിഷയം | പാഠസംഘടനം | പഠന ലക്ഷ്യങ്ങൾ | ബന്ധിപ്പിച്ച പാഠം | രചയിതാവ് |
| :-------: | :--------------------------------------------------------------: | :----------------------------------------------------: | ----------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: | | :---------: | :------------------------------------------------------------: | :----------------------------------------------: | --------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------: |
| 01 | മെഷീൻ ലേണിങ്ങില്‍ പരിചയം | [Introduction](1-Introduction/README.md) | മെഷീൻ ലേണിങ്ങിന്റെ അടിസ്ഥാന ആശയങ്ങൾ പഠിക്കുക | [Lesson](1-Introduction/1-intro-to-ML/README.md) | മുഹമ്മദ് | | 01 | മെഷീൻ ലേണിങ്ങിലേക്കുള്ള அறிமுகം | [Introduction](1-Introduction/README.md) | മെഷീൻ ലേണിങ്ങിന് പിന്‍ബലമായ അടിസ്ഥാന ആശയങ്ങൾ പഠിക്കുക | [Lesson](1-Introduction/1-intro-to-ML/README.md) | മുഹമ്മദ് |
| 02 | മെഷീൻ ലേണിങ്ങിന്റെ ചരിത്രം | [Introduction](1-Introduction/README.md) | ഈ മേഖലയിലെ ചരിത്രം പഠിക്കുക | [Lesson](1-Introduction/2-history-of-ML/README.md) | ജെൻ ആൻഡ് എമി | | 02 | മെഷീൻ ലേണിങ്ങിന്റെ ചരിത്രം | [Introduction](1-Introduction/README.md) | ഈ മേഖലയ്ക്കുള്ള പശ്ചാത്തല ചരിത്രം പഠിക്കുക | [Lesson](1-Introduction/2-history-of-ML/README.md) | ജെൻ ആൻഡ് അമി |
| 03 | നീതിമാന്മാരായ മെഷീൻ ലേണിങ് | [Introduction](1-Introduction/README.md) | ML മോഡലുകൾ നിർമ്മിക്കുമ്പോൾ പരിഗണിക്കേണ്ട നീതിമാന്മായ തത്വശാസ്ത്ര പ്രശ്നങ്ങൾ എന്തെല്ലാമാണ് എന്നറിയുക | [Lesson](1-Introduction/3-fairness/README.md) | ടോമോമി | | 03 | നീതിയും മെഷീൻ ലേണിംഗും | [Introduction](1-Introduction/README.md) | ML മോഡലുകളുടെ നിർമ്മാണത്തിലും പ്രയോഗത്തിലും വിദ്യാർഥികൾ പരിഗണിക്കേണ്ട ന്യായപരമായ തത്ത്വചിന്തന വിഷയങ്ങൾ എന്തെല്ലാം ആണെന്നറിയുക | [Lesson](1-Introduction/3-fairness/README.md) | ടോമോമി |
| 04 | മെഷീൻ ലേണിങ്ങിന്‍റെ തന്ത്രങ്ങൾ | [Introduction](1-Introduction/README.md) | ML ഗവേഷകർ ML മോഡലുകൾ നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്ന തന്ത്രങ്ങൾ എന്തൊക്കെയാണെന്ന് അറിയുക | [Lesson](1-Introduction/4-techniques-of-ML/README.md) | ക്രിസ് ആൻഡ് ജെൻ | | 04 | മെഷീൻ ലേണിംഗിന്‍റെ സാങ്കേതിക വിദ്യകൾ | [Introduction](1-Introduction/README.md) | ML ഗവേഷകർ ML മോഡലുകൾ നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്ന സാങ്കേതിക വിദ്യകൾ എന്തെല്ലാമാണെന്ന് അറിയുക | [Lesson](1-Introduction/4-techniques-of-ML/README.md) | ക്രിസ് ആൻഡ് ജെൻ |
| 05 | റെഗ്രഷനിൽ പരിചയം | [Regression](2-Regression/README.md) | റെഗ്രഷൻ മോഡലുകൾക്കായി Python, Scikit-learn ഉപയോഗിച്ച് ആരംഭിക്കുക | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | ജെൻ • എറിക് വാണ്ട്‌ജു | | 05 | റെഗ്രഷൻলৈക്കുള്ള പരിചയം | [Regression](2-Regression/README.md) | റെഗ്രഷൻ മോഡലുകൾക്കായി Python ഉം Scikit-learn ഉം ഉപയോഗിച്ച് തുടങ്ങുക | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | ജെൻ • എറിക് വാൻജോ |
| 06 | നോര്ത്ത് അമേരിക്കന്‍ കുമ്പളം വിലകള്‍ 🎃 | [Regression](2-Regression/README.md) | ML-ന് വേണ്ടി ഡാറ്റ വൈറസ് ചെയ്ത് ശുചിയാക്കുക | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | ജെൻ • എറിക് വാണ്ട്‌ജു | | 06 | ഉത്തര അമേരിക്കയിലെ പംപ്കിൻ വിലകൾ 🎃 | [Regression](2-Regression/README.md) | ML-ന് മുൻകൂർ ഡേറ്റാ ദൃശ്യവത്കരിച്ച് ആഴ്ച്ചയാക്കി ശുദ്ധമാക്കുക | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | ജെൻ • എറിക് വാൻജോ |
| 07 | നോര്ത്ത് അമേരിക്കന്‍ കുമ്പളം വിലകള്‍ 🎃 | [Regression](2-Regression/README.md) | ലീനിയർ, പോളിനോമിയൽ റെഗ്രഷൻ മോഡലുകൾ നിർമ്മിക്കുക | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | ജെൻ ആൻഡ് ഡിമ്ട്രി • എറിക് വാണ്ട്‌ജു | | 07 | ഉത്തര അമേരിക്കയിലെ പംപ്കിൻ വിലകൾ 🎃 | [Regression](2-Regression/README.md) | രേഖാഖണ്ഡ പുനർവൈകല്യസാധ്യതയും പോളിനോമിയൽ റെഗ്രഷൻ മോഡലുകളും നിർമ്മിക്കുക | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | ജെൻ, ഡ്മിത്രി • എറിക് വാൻജോ |
| 08 | നോര്ത്ത് അമേരിക്കന്‍ കുമ്പളം വിലകള്‍ 🎃 | [Regression](2-Regression/README.md) | ലോജിസ്റ്റിക് റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | ജെൻ • എറിക് വാണ്ട്‌ജു | | 08 | ഉത്തര അമേരിക്കയിലെ പംപ്കിൻ വിലകൾ 🎃 | [Regression](2-Regression/README.md) | ലോഗിസ്റ്റിക് റെഗ്രഷൻ മോഡൽ നിർമ്മിക്കുക | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | ജെൻ • എറിക് വാൻജോ |
| 09 | ഒരു വെബ് ആപ്പ് 🔌 | [Web App](3-Web-App/README.md) | പരിശീലിപ്പിച്ച മോഡൽ ഉപയോഗിക്കാൻ ഒരു വെബ് ആപ്പ് നിർമ്മിക്കുക | [Python](3-Web-App/1-Web-App/README.md) | ജെൻ | | 09 | ഒരു വെബ് ആപ്പ് 🔌 | [Web App](3-Web-App/README.md) | പരിശീലിപ്പിച്ച മോഡൽ ഉപയോഗിച്ച് ഒരു വെബ് ആപ്പ് നിർമ്മിക്കുക | [Python](3-Web-App/1-Web-App/README.md) | ജെൻ |
| 10 | ക്ലാസ്സിഫിക്കേഷനിൽ പരിചയം | [Classification](4-Classification/README.md) | ഡാറ്റ ശുചിയാക്കുക, തയ്യാറാക്കുക, ദൃശ്യവത്കരിക്കുക; ക്ലാസ്സിഫിക്കേഷനിലേക്ക് പരിചയം | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | ജെൻ ആൻഡ് കാസ്സി • എറിക് വാണ്ട്‌ജു | | 10 | ക്ലാസിഫിക്കേഷനിലേക്കുള്ള പരിചയം | [Classification](4-Classification/README.md) | ഡാറ്റ ശുദ്ധമാക്കും, തയ്യാറാക്കും, ദൃശ്യവത്ക്കരിക്കും; ക്ലാസിഫിക്കേഷനിലെ പരിചയം | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | ജെൻ ആൻഡ് കാസ്സി • എറിക് വാൻജോ |
| 11 | രുചികരമായ ഏഷ്യൻ-ഇന്ത്യൻ ഭക്ഷണങ്ങള്‍ 🍜 | [Classification](4-Classification/README.md) | ക്ലാസ്സിഫയറുകളിലേക്ക് പരിചയം | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | ജെൻ ആൻഡ് കാസ്സി • എറിക് വാണ്ട്‌ജു | | 11 | രുചികരമായ ഏഷ്യൻ-ഇന്ത്യൻ പാചകകലകൾ 🍜 | [Classification](4-Classification/README.md) | ക്ലാസിഫയറുകളിലേക്ക് പരിചയം | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | ജെൻ ആൻഡ് കാസ്സി • എറിക് വാൻജോ |
| 12 | രുചികരമായ ഏഷ്യൻ-ഇന്ത്യൻ ഭക്ഷണങ്ങള്‍ 🍜 | [Classification](4-Classification/README.md) | കൂടുതൽ ക്ലാസ്സിഫയറുകൾ | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | ജെൻ ആൻഡ് കാസ്സി • എറിക് വാണ്ട്‌ജു | | 12 | രുചികരമായ ഏഷ്യൻ-ഇന്ത്യൻ പാചകകലകൾ 🍜 | [Classification](4-Classification/README.md) | കൂടുതൽ ക്ലാസിഫയറുകൾ | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | ജെൻ ആൻഡ് കാസ്സി • എറിക് വാൻജോ |
| 13 | രുചികരമായ ഏഷ്യൻ-ഇന്ത്യൻ ഭക്ഷണങ്ങള്‍ 🍜 | [Classification](4-Classification/README.md) | നിങ്ങളുടെ മോഡൽ ഉപയോഗിച്ച് ഒരു ശਿਫാർശ വെബ് ആപ്പ് നിർമ്മിക്കുക | [Python](4-Classification/4-Applied/README.md) | ജെൻ | | 13 | രുചികരമായ ഏഷ്യൻ-ഇന്ത്യൻ പാചകകലകൾ 🍜 | [Classification](4-Classification/README.md) | നിങ്ങളുടെ മോഡൽ ഉപയോഗിച്ച് ഒരു റികमेंഡർ വെബ് ആപ്പ് നിർമ്മിക്കുക | [Python](4-Classification/4-Applied/README.md) | ജെൻ |
| 14 | ക്ലസ്റ്ററിങ്ങിൽ പരിചയം | [Clustering](5-Clustering/README.md) | ഡാറ്റ ശുചിയാക്കുക, തയ്യാറാക്കുക, ദൃശ്യവത്കരിക്കുക; ക്ലസ്റ്ററിങ്ങിലേക്ക് പരിചയം | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | ജെൻ • എറിക് വാണ്ട്‌ജു | | 14 | ക്ലസ്റ്ററിങ്ങിലേക്കുള്ള പരിചയം | [Clustering](5-Clustering/README.md) | ഡാറ്റ ശുദ്ധമാക്കുക, തയ്യാറാക്കുക, ദൃശ്യവത്കരിക്കുക; ക്ലസ്റ്ററിങ്ങിലേക്കുള്ള പരിചയം | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | ജെൻ • എറിക് വാൻജോ |
| 15 | നൈജീരിയൻ സംഗീത രുചികള്‍ അന്വേഷിക്കല്‍ 🎧 | [Clustering](5-Clustering/README.md) | K-മീൻസ് ക്ലസ്റ്ററിംഗ് പદ્ધതി പരിശോധിക്കുക | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | ജെൻ • എറിക് വാണ്ട്‌ജു | | 15 | നൈജീരിയൻ സംഗീത രുചികൾ അന്വേഷിക്കൽ 🎧 | [Clustering](5-Clustering/README.md) | K-മീൻസ് ക്ലസ്റ്ററിങ് രീതി അന്വേഷിക്കുക | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | ജെൻ • എറിക് വാൻജോ |
| 16 | നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിങ്ങിൽ പരിചയം ☕️ | [Natural language processing](6-NLP/README.md) | ഒരു ലളിത ബോട്ട് നിർമ്മിച്ച് NLP അടിസ്ഥാനങ്ങൾ പഠിക്കുക | [Python](6-NLP/1-Introduction-to-NLP/README.md) | സ്റ്റീഫൻ | | 16 | പ്രകൃതിമാറ്റഭാഷാ പ്രോസസ്സിംഗിന്റെ പരിചയം ☕️ | [Natural language processing](6-NLP/README.md) | ഒരു ലളിതമായ ബോട്ട് നിർമ്മിച്ച് NLP-യുടെ അടിസ്ഥാന കാര്യങ്ങൾ പഠിക്കുക | [Python](6-NLP/1-Introduction-to-NLP/README.md) | സ്റ്റീഫൻ |
| 17 | പൊതു NLP ജോലി കൾ ☕️ | [Natural language processing](6-NLP/README.md) | ഭാഷാചട്ടങ്ങളോട് ഇടപഴകുമ്പോഴുള്ള സാധാരണ ജോലികൾ മനസിലാക്കിയാണ് നിങ്ങളുടെ NLP അറിവ് മെച്ചപ്പെടുത്തുക | [Python](6-NLP/2-Tasks/README.md) | സ്റ്റീഫൻ | | 17 | പൊതുവായ NLP പ്രവര്‍ത്തനങ്ങൾ ☕️ | [Natural language processing](6-NLP/README.md) | ഭാഷാസംരചനകളുമായി ഇടപെടുമ്പോൾ ആവശ്യമായ സാധാരണ പ്രവൃത്തികൾ മനസ്സിലാക്കി NLP അറിവ് വിപുലப்படുത്തുക | [Python](6-NLP/2-Tasks/README.md) | സ്റ്റീഫൻ |
| 18 | വിവർത്തനവും വികാരപരിശോധനയും ♥️ | [Natural language processing](6-NLP/README.md) | ജെയ്ന്‍ ഓസ്റ്റീനിനൊപ്പം വിവർത്തനവും വികാരപരിശോധനയും | [Python](6-NLP/3-Translation-Sentiment/README.md) | സ്റ്റീഫൻ | | 18 | വിവർത്തനം, വികാര വിശകലനം ♥️ | [Natural language processing](6-NLP/README.md) | ജെയിൻ ഓസ്റ്റീനുമായി വിവർത്തനവും വികാര വിശകലനവും | [Python](6-NLP/3-Translation-Sentiment/README.md) | സ്റ്റീഫൻ |
| 19 | യൂറോപ്പിലെ രോമാന്റിക് ഹോട്ടലുകള്‍ ♥️ | [Natural language processing](6-NLP/README.md) | ഹോട്ടല്‍ അവലോകനങ്ങളുടെ വികാരപരിശോധനയുമായി 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | സ്റ്റീഫൻ | | 19 | യൂറോപ്പിലെ റോമാന്റിക് ഹോട്ടലുകൾ ♥️ | [Natural language processing](6-NLP/README.md) | ഹോട്ടൽ അവലോകനങ്ങളുമായി വികാര വിശകലനം 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | സ്റ്റീഫൻ |
| 20 | യൂറോപ്പിലെ രോമാന്റിക് ഹോട്ടലുകള്‍ ♥️ | [Natural language processing](6-NLP/README.md) | ഹോട്ടല്‍ അവലോകനങ്ങളുടെ വികാരപരിശോധനയുമായി 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | സ്റ്റീഫൻ | | 20 | യൂറോപ്പിലെ റോമാന്റിക് ഹോട്ടലുകൾ ♥️ | [Natural language processing](6-NLP/README.md) | ഹോട്ടൽ അവലോകനങ്ങളുമായി വികാര വിശകലനം 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | സ്റ്റീഫൻ |
| 21 | ടൈം സീരീസ് ഫോറ്കാസ്റ്റിങ്ങിൽ പരിചയം | [Time series](7-TimeSeries/README.md) | ടൈം സീരീസ് ഫോറ്കാസ്റ്റിങിൽ പരിചയം | [Python](7-TimeSeries/1-Introduction/README.md) | ഫ്രാൻസെസ്ക | | 21 | ടൈം സീരിസിന്റെ പ്രവചനം പരിചയം | [Time series](7-TimeSeries/README.md) | ടൈം സീരിസ് പ്രവചനത്തിലേക്ക് പരിചയം | [Python](7-TimeSeries/1-Introduction/README.md) | ഫ്രാൻസെസ്ക |
| 22 | ⚡️ ലോക വൈദ്യുതിചെലവ് ⚡️ - ARIMA ഉപയോഗിച്ച് ടൈം സീരീസ് ഫോറ്കാസ്റ്റിംഗ് | [Time series](7-TimeSeries/README.md) | ARIMA ഉപയോഗിച്ച് ടൈം സീരീസ് ഫോറ്കാസ്റ്റിംഗ് | [Python](7-TimeSeries/2-ARIMA/README.md) | ഫ്രാൻസെസ്ക | | 22 | ⚡️ ലോക വൈദ്യുതി ഉപയോഗം ⚡️ - ARIMA ഉപയോഗിച്ചുള്ള ടൈം സീരിസ് പ്രവചന | [Time series](7-TimeSeries/README.md) | ARIMA ഉപയോഗിച്ച് ടൈം സീരിസ് പ്രവചന | [Python](7-TimeSeries/2-ARIMA/README.md) | ഫ്രാൻസെസ്ക |
| 23 | ⚡️ ലോക വൈദ്യുതിചെലവ് ⚡️ - SVR ഉപയോഗിച്ച് ടൈം സീരീസ് ഫോറ്കാസ്റ്റിംഗ് | [Time series](7-TimeSeries/README.md) | Support Vector Regressor ഉപയോഗിച്ച് ടൈം സീരീസ് ഫോറ്കാസ്റ്റിംഗ് | [Python](7-TimeSeries/3-SVR/README.md) | അനിർബാൻ | | 23 | ⚡️ ലോക വൈദ്യുതി ഉപയോഗം ⚡️ - SVR ഉപയോഗിച്ചുള്ള ടൈം സീരിസ് പ്രവചന | [Time series](7-TimeSeries/README.md) | Support Vector Regressor ഉപയോഗിച്ച് ടൈം സീരിസ് പ്രവചന | [Python](7-TimeSeries/3-SVR/README.md) | അനിർബാൻ |
| 24 | റീ ഇൻഫോഴ്‌സ്‌മെന്റ് ലേണിങ്ങിലേക്ക് പരിചയം | [Reinforcement learning](8-Reinforcement/README.md) | Q-ലേണിങ്ങ് ഉപയോഗിച്ചുള്ള റീ ഇൻഫോഴ്‌സ്‌മെന്റ് ലേണിങ്ങിന് പരിചയം | [Python](8-Reinforcement/1-QLearning/README.md) | ഡിമ്ട്രി | | 24 | റീൻഫോഴ്സ്മെന്റ് ലേണിങ്ങിലേക്ക് പരിചയം | [Reinforcement learning](8-Reinforcement/README.md) | Q-Learning ഉപയോഗിച്ചുള്ള റീൻഫോഴ്സ്മെന്റ് ലേണിങ്ങിലേക്ക് പരിചയം | [Python](8-Reinforcement/1-QLearning/README.md) | ഡ്മിത്രി |
| 25 | പീറ്ററിന് വെളുത്തയാനെ ഒഴിവാക്കാന്‍ സഹായിക്കുക! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | റീ ഇൻഫോഴ്‌സ്‌മെന്റ് ലേർണിങ് ജിം | [Python](8-Reinforcement/2-Gym/README.md) | ഡിമ്ട്രി | | 25 | പീറ്റർ നായകനെ ഒഴിവാക്കാൻ സഹായിക്കുക! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | റീൻഫോഴ്സ്മെന്റ് ലേണിങ്ങ് ജിം | [Python](8-Reinforcement/2-Gym/README.md) | ഡ്മിത്രി |
| Postscript | യഥാർത്ഥ ലോകത്തെ ML സാഹചര്യങ്ങളും ആപ്ലിക്കേഷനുകളും | [ML in the Wild](9-Real-World/README.md) | ക്ലാസ്സിക്കൽ ML-ന്റെ രസകരവും വെളിച്ചവും പകരുന്ന യഥാർത്ഥ ലോക ആപ്ലിക്കേഷനുകൾ | [Lesson](9-Real-World/1-Applications/README.md) | ടീം | | പോസ്‌ക്രിപ്റ്റ് | യാഥാർത്ഥ്യ ML സാഹചര്യങ്ങൾ, പ്രയോഗങ്ങൾ | [ML in the Wild](9-Real-World/README.md) | ക്ലാസിക്കൽ ML ന്റെ സാരവുമായ യാഥാർത്ഥ്യ ആപ്ലിക്കേഷനുകൾ | [Lesson](9-Real-World/1-Applications/README.md) | ടീം |
| Postscript | RAI ഡാഷ്ബോർഡ് ഉപയോഗിച്ച് ML മോഡൽ ഡീബഗ്ഗിങ് | [ML in the Wild](9-Real-World/README.md) | Responsible AI ഡാഷ്ബോർഡ് കോമ്പോണന്റുകൾ ഉപയോഗിച്ച് മെഷീൻ ലേണിങ്ങിൽ മോഡൽ ഡീബഗ്ഗിങ് | [Lesson](9-Real-World/2-Debugging-ML-Models/README.md) | രൂത് യാക്കുബു | | പോസ്‌ക്രിപ്റ്റ് | RAI ഡാഷ്ബോർഡ് ഉപയോഗിച്ച് ML മോഡൽ ഡീബഗിങ് | [ML in the Wild](9-Real-World/README.md) | വെറുപ്പ് AI ഡാഷ്ബോർഡ് ഘടകങ്ങൾ ഉപയോഗിച്ച് മെഷീൻ ലേണിങ്ങിലെ മോഡൽ ഡീബഗിങ് | [Lesson](9-Real-World/2-Debugging-ML-Models/README.md) | റുത് യകുബു |
> [ഈ കോഴ്‌സിനുള്ള എല്ലാ അധിക വിഭവങ്ങളും നമ്മുടെ Microsoft Learn ശേഖരത്തിൽ കാണുക](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum) > [ഈ കോഴ്സിന്റെ എല്ലാ അധിക വിഭവങ്ങളും ഞങ്ങളുടെ Microsoft Learn ശേഖരത്തിൽ കണ്ടെത്തുക](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
## ഓഫ്‌ലൈൻ ആക്‌സസ് ## ഓഫ്ലൈൻ ആക്‌സസ്
[Docsify](https://docsify.js.org/#/) ഉപയോഗിച്ച് ഈ ഡോക്യമെന്റേഷൻ ഓഫ്‌ലൈൻ റണ്ചെയ്യാം. ഈ റെപ്പോയെ ഫോർക്കുചെയ്യുക, നിങ്ങളുടെ ലോക്കൽ മെഷീനിൽ [Docsify ഇൻസ്റ്റാൾ ചെയ്യുക](https://docsify.js.org/#/quickstart), തുടർന്ന് ഈ റെപ്പോയുടെ റൂട്ട് ഫോൾഡറിൽ `docsify serve` ടൈപ്പ് ചെയ്യുക. വെബ്‌സൈറ്റ് പോർട്ട് 3000ൽ നിങ്ങളുടെ ലോക്കൽഹോസ്റ്റിൽ സേർവ് ചെയ്യും: `localhost:3000`. [Docsify](https://docsify.js.org/#/) ഉപയോഗിച്ച് നിങ്ങള്‍ക്ക് ഈ ഡോക്യുമെന്റაცია ഓഫ്ലൈൻ പ്രവർത്തിപ്പിക്കാം. ഈ റിപ്പൊ ഫോർക്ക് ചെയ്ത്, നിങ്ങളുടെ പ്രാദേശിക യന്ത്രത്തിൽ [Docsify ഇൻസ്റ്റാൾ](https://docsify.js.org/#/quickstart) ചെയ്തു, ശേഷം ഈ റിപ്പൊയുടെ റൂട്ട് ഫോൾഡറിൽ ടൈപ്പ് ചെയ്യുക `docsify serve`. വെബ്സൈറ്റ് പ്രാദേശികഹോസ്റ്റിൽ പോർട് 3000-ൽ പ്രവർത്തിക്കും: `localhost:3000`.
## PDF-കൾ ## PDFs
ഇന്ത്യയുടെ പാഠ്യപദ്ധതിയുടെ PDF-നെ ഈ ലിങ്കിൽ കാണുക [ഇവിടെ](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf). പാഠ്യപദ്ധതിയുടെ PDF ഇവിടെ കണ്ടെത്തുക [here](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
## 🎒 മറ്റു കോഴ്‌സുകൾ ## 🎒 മറ്റു കോഴ്സുകൾ
നമ്മുടെ ടീം മറ്റു കോഴ്്സുകളും ഒരുക്കുന്നു! കാണുക: നമ്മുടെ ടീം മറ്റു കോഴ്സുകളും നിർമ്മിക്കുന്നു! നോക്കൂ:
<!-- CO-OP TRANSLATOR OTHER COURSES START --> <!-- CO-OP TRANSLATOR OTHER COURSES START -->
### LangChain ### LangChain
[![Beginners-ക്കായി LangChain4j](https://img.shields.io/badge/LangChain4j%20for%20Beginners-22C55E?style=for-the-badge&&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchain4j-for-beginners) [![LangChain4j for Beginners](https://img.shields.io/badge/LangChain4j%20for%20Beginners-22C55E?style=for-the-badge&&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchain4j-for-beginners)
[![Beginners-ക്കായി LangChain.js](https://img.shields.io/badge/LangChain.js%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin) [![LangChain.js for Beginners](https://img.shields.io/badge/LangChain.js%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://aka.ms/langchainjs-for-beginners?WT.mc_id=m365-94501-dwahlin)
[![Beginners-ക്കായി LangChain](https://img.shields.io/badge/LangChain%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin) [![LangChain for Beginners](https://img.shields.io/badge/LangChain%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=0553D6)](https://github.com/microsoft/langchain-for-beginners?WT.mc_id=m365-94501-dwahlin)
--- ---
### Azure / Edge / MCP / ഏജന്റുമാർ ### Azure / Edge / MCP / Agents
[![Beginners-ക്കായി AZD](https://img.shields.io/badge/AZD%20for%20Beginners-0078D4?style=for-the-badge&labelColor=E5E7EB&color=0078D4)](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst) [![AZD for Beginners](https://img.shields.io/badge/AZD%20for%20Beginners-0078D4?style=for-the-badge&labelColor=E5E7EB&color=0078D4)](https://github.com/microsoft/AZD-for-beginners?WT.mc_id=academic-105485-koreyst)
[![Beginners-ക്കായി<Edge> AI](https://img.shields.io/badge/Edge%20AI%20for%20Beginners-00B8E4?style=for-the-badge&labelColor=E5E7EB&color=00B8E4)](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst) [![Edge AI for Beginners](https://img.shields.io/badge/Edge%20AI%20for%20Beginners-00B8E4?style=for-the-badge&labelColor=E5E7EB&color=00B8E4)](https://github.com/microsoft/edgeai-for-beginners?WT.mc_id=academic-105485-koreyst)
[![Beginners-ക്കായി MCP](https://img.shields.io/badge/MCP%20for%20Beginners-009688?style=for-the-badge&labelColor=E5E7EB&color=009688)](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst) [![MCP for Beginners](https://img.shields.io/badge/MCP%20for%20Beginners-009688?style=for-the-badge&labelColor=E5E7EB&color=009688)](https://github.com/microsoft/mcp-for-beginners?WT.mc_id=academic-105485-koreyst)
[![Beginners-ക്കായി AI ഏജൻ്റുമാർ](https://img.shields.io/badge/AI%20Agents%20for%20Beginners-00C49A?style=for-the-badge&labelColor=E5E7EB&color=00C49A)](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst) [![AI Agents for Beginners](https://img.shields.io/badge/AI%20Agents%20for%20Beginners-00C49A?style=for-the-badge&labelColor=E5E7EB&color=00C49A)](https://github.com/microsoft/ai-agents-for-beginners?WT.mc_id=academic-105485-koreyst)
--- ---
### ജനറേറ്റീവ് AI പരമ്പര ### ജനറേറ്റീവ് AI പരമ്പര
[![Generative AI for Beginners](https://img.shields.io/badge/Generative%20AI%20for%20Beginners-8B5CF6?style=for-the-badge&labelColor=E5E7EB&color=8B5CF6)](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
[![ആരംഭക്കാർക്കും മുൻഗണനാപ്രാപ്‌തമാർക്കും ഉപകാരമുള്ള സൃഷ്‌ടിപരമായ AI](https://img.shields.io/badge/Generative%20AI%20for%20Beginners-8B5CF6?style=for-the-badge&labelColor=E5E7EB&color=8B5CF6)](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
[![Generative AI (.NET)](https://img.shields.io/badge/Generative%20AI%20(.NET)-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst) [![Generative AI (.NET)](https://img.shields.io/badge/Generative%20AI%20(.NET)-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst)
[![Generative AI (Java)](https://img.shields.io/badge/Generative%20AI%20(Java)-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst) [![Generative AI (Java)](https://img.shields.io/badge/Generative%20AI%20(Java)-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst)
[![Generative AI (JavaScript)](https://img.shields.io/badge/Generative%20AI%20(JavaScript)-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst) [![Generative AI (JavaScript)](https://img.shields.io/badge/Generative%20AI%20(JavaScript)-E879F9?style=for-the-badge&labelColor=E5E7EB&color=E879F9)](https://github.com/microsoft/generative-ai-with-javascript?WT.mc_id=academic-105485-koreyst)
--- ---
### കോർ പഠനം ### മദ്ധ്യസ്ഥാന പഠനം
[![ML for Beginners](https://img.shields.io/badge/ML%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=22C55E)](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst) [![ML for Beginners](https://img.shields.io/badge/ML%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=22C55E)](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst)
[![ഡാറ്റാ സയൻസ് ആരംഭക്കാർക്കായി](https://img.shields.io/badge/Data%20Science%20for%20Beginners-84CC16?style=for-the-badge&labelColor=E5E7EB&color=84CC16)](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst) [![Data Science for Beginners](https://img.shields.io/badge/Data%20Science%20for%20Beginners-84CC16?style=for-the-badge&labelColor=E5E7EB&color=84CC16)](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst)
[![AI for Beginners](https://img.shields.io/badge/AI%20for%20Beginners-A3E635?style=for-the-badge&labelColor=E5E7EB&color=A3E635)](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst) [![AI for Beginners](https://img.shields.io/badge/AI%20for%20Beginners-A3E635?style=for-the-badge&labelColor=E5E7EB&color=A3E635)](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst)
[![സൈബർസെക്യൂരിറ്റി ആരംഭക്കാർക്കായി](https://img.shields.io/badge/Cybersecurity%20for%20Beginners-F97316?style=for-the-badge&labelColor=E5E7EB&color=F97316)](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung) [![Cybersecurity for Beginners](https://img.shields.io/badge/Cybersecurity%20for%20Beginners-F97316?style=for-the-badge&labelColor=E5E7EB&color=F97316)](https://github.com/microsoft/Security-101?WT.mc_id=academic-96948-sayoung)
[![വെബ് ഡെവ് ആരംഭക്കാർക്കായി](https://img.shields.io/badge/Web%20Dev%20for%20Beginners-EC4899?style=for-the-badge&labelColor=E5E7EB&color=EC4899)](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst) [![Web Dev for Beginners](https://img.shields.io/badge/Web%20Dev%20for%20Beginners-EC4899?style=for-the-badge&labelColor=E5E7EB&color=EC4899)](https://aka.ms/webdev-beginners?WT.mc_id=academic-105485-koreyst)
[![ഐ‌ഒ‌ടി ആരംഭക്കാർക്കായി](https://img.shields.io/badge/IoT%20for%20Beginners-14B8A6?style=for-the-badge&labelColor=E5E7EB&color=14B8A6)](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst) [![IoT for Beginners](https://img.shields.io/badge/IoT%20for%20Beginners-14B8A6?style=for-the-badge&labelColor=E5E7EB&color=14B8A6)](https://aka.ms/iot-beginners?WT.mc_id=academic-105485-koreyst)
[![എക്സ്‌ആർ ഡെവലപ്മെന്റ് ആരംഭക്കാർക്കായി](https://img.shields.io/badge/XR%20Development%20for%20Beginners-38BDF8?style=for-the-badge&labelColor=E5E7EB&color=38BDF8)](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst) [![XR Development for Beginners](https://img.shields.io/badge/XR%20Development%20for%20Beginners-38BDF8?style=for-the-badge&labelColor=E5E7EB&color=38BDF8)](https://github.com/microsoft/xr-development-for-beginners?WT.mc_id=academic-105485-koreyst)
--- ---
### കോപ്പിലോട്ട് സിരീസ് ### കോപൈലറ്റ് പരമ്പര
[![AI പൂജ്യം കൂടിയ കോപ്പിലോട്ട്](https://img.shields.io/badge/Copilot%20for%20AI%20Paired%20Programming-FACC15?style=for-the-badge&labelColor=E5E7EB&color=FACC15)](https://aka.ms/GitHubCopilotAI?WT.mc_id=academic-105485-koreyst) [![Copilot for AI Paired Programming](https://img.shields.io/badge/Copilot%20for%20AI%20Paired%20Programming-FACC15?style=for-the-badge&labelColor=E5E7EB&color=FACC15)](https://aka.ms/GitHubCopilotAI?WT.mc_id=academic-105485-koreyst)
[![C#/.NET കോപ്പിലോട്ട്](https://img.shields.io/badge/Copilot%20for%20C%23/.NET-FBBF24?style=for-the-badge&labelColor=E5E7EB&color=FBBF24)](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers?WT.mc_id=academic-105485-koreyst) [![Copilot for C#/.NET](https://img.shields.io/badge/Copilot%20for%20C%23/.NET-FBBF24?style=for-the-badge&labelColor=E5E7EB&color=FBBF24)](https://github.com/microsoft/mastering-github-copilot-for-dotnet-csharp-developers?WT.mc_id=academic-105485-koreyst)
[![കോപ്പിലോട്ട് സാഹസികം](https://img.shields.io/badge/Copilot%20Adventure-FDE68A?style=for-the-badge&labelColor=E5E7EB&color=FDE68A)](https://github.com/microsoft/CopilotAdventures?WT.mc_id=academic-105485-koreyst) [![Copilot Adventure](https://img.shields.io/badge/Copilot%20Adventure-FDE68A?style=for-the-badge&labelColor=E5E7EB&color=FDE68A)](https://github.com/microsoft/CopilotAdventures?WT.mc_id=academic-105485-koreyst)
<!-- CO-OP TRANSLATOR OTHER COURSES END --> <!-- CO-OP TRANSLATOR OTHER COURSES END -->
## സഹായം നേടുക ## സഹായം നേടുക
AI ആപ്പുകൾ നിർമ്മിക്കുമ്പോൾ നിങ്ങൾക്ക് തളർന്നുപോകുകയോ ഏതെങ്കിലും ചോദ്യങ്ങളുണ്ടായിരിക്കാൻ സാധ്യതയുണ്ടെങ്കിൽ. MCP-യിൽ അനുഭവസമ്പന്നരായ ഡെവലപർമാരോടും മറ്റ് പഠനസുഹൃത്തുക്കളോടും ചേർന്ന് സംവാദങ്ങളിൽ പങ്കാളിയാകുക. ചോദ്യങ്ങൾക്ക് സ്വാഗതം ഉള്ള ഒത്തുചേരുന്ന ഒരു സമൂഹമാണിത്, അറിവ് സ്വതന്ത്രമായി പങ്കുവെക്കുന്ന സ്ഥലമാണ്. AI അപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുമ്പോൾ നിങ്ങൾ കുടുങ്ങിയാൽ അല്ലെങ്കിൽ എന്തെങ്കിലും ചോദ്യങ്ങൾ ഉണ്ടെങ്കിലോ, MCP-യുമായി ബന്ധപ്പെട്ട ചര്‍ച്ചകളിൽ അനുഭവ സമ്പന്നരായ വികസകർ പൊതു പഠനക്കാരുമായി ചേരുക. ചോദ്യം ചോദിക്കാൻ സ്വാതന്ത്ര്യവും അറിയിപ്പ് സൗകര്യവും ഉള്ള ഒരു പിന്തുണയുള്ള സമൂഹമാണ് ഇത്.
[![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG) [![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG)
ഉൽപ്പന്ന പ്രതികരണം അല്ലെങ്കിൽ പിഴവുകൾ ഉണ്ടെങ്കിൽ: ഉത്പന്ന പ്രതികരണം നൽകാൻ അല്ലെങ്കിൽ പിഴവുകൾ ഉണ്ടെങ്കിൽ ഡിസ്ക്കസിൽ സന്ദർശിക്കുക:
[![Microsoft Foundry Developer Forum](https://img.shields.io/badge/GitHub-Microsoft_Foundry_Developer_Forum-blue?style=for-the-badge&logo=github&color=000000&logoColor=fff)](https://aka.ms/foundry/forum) [![Microsoft Foundry Developer Forum](https://img.shields.io/badge/GitHub-Microsoft_Foundry_Developer_Forum-blue?style=for-the-badge&logo=github&color=000000&logoColor=fff)](https://aka.ms/foundry/forum)
## അധിക പഠന ടിപ്സ്
- ഓരോ പാഠവും കഴിഞ്ഞ് നോട്ട്‌ബുക്കുകൾ അവലോകനം ചെയ്യുക മനസ്സിലാക്കാൻ സഹായിക്കും.
- ആല്ഗാരിതങ്ങൾ സ്വയം പ്രയോജനപ്പെടുത്താൻ പരിശീലനമെടുക്കുക.
- പഠിച്ച ആശയങ്ങൾ ഉപയോഗിച്ച് യഥാർത്ഥ ലോക ഡാറ്റാ സെറ്റുകൾ പരിശോധിക്കുക.
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**വിവരണ കുറിപ്പ്**: **അയക്കിപ്പ്**:
ഈ പ്രമാണം AI ഭാഷാന്തരണ സർവീസ് [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. ഞങ്ങൾ കൃത്യതയ്ക്ക് ശ്രമിച്ചിള്ളെങ്കിലും, യാന്ത്രിക വിവർത്തനങ്ങളിൽ പിഴവുകൾ അല്ലെങ്കിൽ അസാധുതകൾ ഉണ്ടായേക്കാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. ആ പ്രമാണത്തിന്റെ പ്രാഥമിക ഭാഷയിലെ أصل പകർപ്പ് ആണ് പ്രാമാണിക നിയന്ത്രണ ഉറവിടം. പ്രധാന വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മാനവ വിവർത്തനം നിർദ്ദേശിക്കുന്നു. ഈ വിവർത്തനത്തിന്റെ ഉപയോഗത്തിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾ അല്ലെങ്കിൽ അപ്രത്യക്ഷതകൾക്കായി ഞങ്ങൾ ഉത്തരവാദികളല്ല. ഈ രേഖ [Co-op Translator](https://github.com/Azure/co-op-translator) എന്ന AI വിവർത്തന സേവനം ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. ഞങ്ങൾ കൃത്യത ഉറപ്പാക്കാൻ ശ്രമിച്ചുവെങ്കിലും, യന്ത്രക്രമം അടങ്ങിയ വിവർത്തനങ്ങളിൽ പിഴവുകൾ അല്ലെങ്കിൽ അശുദ്ധികൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മൂലഭാഷയിലെ ആദ്യരൂപം മാത്രം അതിന്റേതായ സ്വതന്ത്ര സ്രോതസ്സായി പരിഗണിക്കേണ്ടതാണ്. പ്രധാനപ്പെട്ട വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മാനവ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

28
translations/te/.co-op-translator.json
Unescape View File

@ -30,8 +30,8 @@
"language_code": "te" "language_code": "te"
}, },
"1-Introduction/3-fairness/assignment.md": { "1-Introduction/3-fairness/assignment.md": {
"original_hash": "dbda60e7b1fe5f18974e7858eff0004e", "original_hash": "c81d9affadb89d017d610eadeb6c84f9",
"translation_date": "2025-12-19T13:43:21+00:00", "translation_date": "2026-02-28T10:53:18+00:00",
"source_file": "1-Introduction/3-fairness/assignment.md", "source_file": "1-Introduction/3-fairness/assignment.md",
"language_code": "te" "language_code": "te"
}, },
@ -90,8 +90,8 @@
"language_code": "te" "language_code": "te"
}, },
"2-Regression/3-Linear/README.md": { "2-Regression/3-Linear/README.md": {
"original_hash": "40e64f004f3cb50aa1d8661672d3cd92", "original_hash": "9a8359f1945bd3beccccb2b46592580e",
"translation_date": "2025-12-19T13:45:41+00:00", "translation_date": "2026-02-28T10:54:37+00:00",
"source_file": "2-Regression/3-Linear/README.md", "source_file": "2-Regression/3-Linear/README.md",
"language_code": "te" "language_code": "te"
}, },
@ -186,8 +186,8 @@
"language_code": "te" "language_code": "te"
}, },
"4-Classification/3-Classifiers-2/README.md": { "4-Classification/3-Classifiers-2/README.md": {
"original_hash": "49047911108adc49d605cddfb455749c", "original_hash": "d94438d71164b0ff68002812aed1a8b4",
"translation_date": "2025-12-19T15:22:00+00:00", "translation_date": "2026-02-28T10:55:02+00:00",
"source_file": "4-Classification/3-Classifiers-2/README.md", "source_file": "4-Classification/3-Classifiers-2/README.md",
"language_code": "te" "language_code": "te"
}, },
@ -197,12 +197,24 @@
"source_file": "4-Classification/3-Classifiers-2/assignment.md", "source_file": "4-Classification/3-Classifiers-2/assignment.md",
"language_code": "te" "language_code": "te"
}, },
"4-Classification/3-Classifiers-2/notebook.ipynb": {
"original_hash": "624ca6cf73d3548ff1b3059e413fa4cd",
"translation_date": "2026-02-28T10:51:11+00:00",
"source_file": "4-Classification/3-Classifiers-2/notebook.ipynb",
"language_code": "te"
},
"4-Classification/3-Classifiers-2/solution/Julia/README.md": { "4-Classification/3-Classifiers-2/solution/Julia/README.md": {
"original_hash": "a39c15d63f3b2795ee2284a82b986b93", "original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T15:37:22+00:00", "translation_date": "2025-12-19T15:37:22+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md", "source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md",
"language_code": "te" "language_code": "te"
}, },
"4-Classification/3-Classifiers-2/solution/notebook.ipynb": {
"original_hash": "70f41fe4fd4253adb44cd9d291406e4f",
"translation_date": "2026-02-28T10:51:17+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/notebook.ipynb",
"language_code": "te"
},
"4-Classification/4-Applied/README.md": { "4-Classification/4-Applied/README.md": {
"original_hash": "61bdec27ed2da8b098cd9065405d9bb0", "original_hash": "61bdec27ed2da8b098cd9065405d9bb0",
"translation_date": "2025-12-19T15:26:05+00:00", "translation_date": "2025-12-19T15:26:05+00:00",
@ -540,8 +552,8 @@
"language_code": "te" "language_code": "te"
}, },
"README.md": { "README.md": {
"original_hash": "2f594ee136e3127a47f56d80055227bc", "original_hash": "3a0286e1c4858e79ff54f080dadc1426",
"translation_date": "2026-02-06T09:31:22+00:00", "translation_date": "2026-02-28T10:53:10+00:00",
"source_file": "README.md", "source_file": "README.md",
"language_code": "te" "language_code": "te"
}, },

14
translations/te/1-Introduction/3-fairness/assignment.md
Unescape View File

@ -1,18 +1,18 @@
# బాధ్యతాయుత AI టూల్‌బాక్స్‌ను అన్వేషించండి # బాధ్యమైన AI టూల్‌బాక్స్‌ను అన్వేషించండి
## సూచనలు ## సూచనలు
ఈ పాఠంలో మీరు బాధ్యతాయుత AI టూల్‌బాక్స్ గురించి తెలుసుకున్నారు, ఇది "డేటా శాస్త్రవేత్తలకు AI వ్యవస్థలను విశ్లేషించడానికి మరియు మెరుగుపరచడానికి సహాయపడే ఓపెన్-సోర్స్, కమ్యూనిటీ-చాలిత ప్రాజెక్ట్." ఈ అసైన్‌మెంట్ కోసం, RAI టూల్‌బాక్స్ యొక్క [నోట్‌బుక్స్](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) లో ఒకదాన్ని అన్వేషించి, మీ కనుగొనిన విషయాలను ఒక పేపర్ లేదా ప్రెజెంటేషన్‌లో నివేదించండి. ఈ పాఠంలో మీరు బాధ్యమైన AI టూల్‌బాక్స్ గురించి నేర్చుకున్నారు, ఇది "డేటా శాస్త్రజ్ఞులు AI వ్యవస్థలను విశ్లేషించటం మరియు మెరుగుపర్చటానికి సహాయపడే ఓపెన్-సోర్స్, కమ్యూనిటీ-నడపబడే ప్రాజెక్టు." ఈ అసైన్‌మెంట్ కోసం, RAI టూల్‌బాక్స్ యొక్క ఒక [నోట్బుక్](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/tabular/getting-started.ipynb)ను అన్వేషించి, అందుకురాలిన నిష్కర్షలను పేపర్ లేదా ప్రეზెంటేషన్‌గా నివేదిక ఇవ్వండి.
## రూబ్రిక్ ## మూల్యాంకన పట్టిక
| ప్రమాణాలు | అద్భుతం | సరిపోతుంది | మెరుగుదల అవసరం | | ప్రమాణాలు | ఆదర్శం | సరిపోతుంది | మెరుగుదల అవసరం |
| -------- | --------- | -------- | ----------------- | | -------- | --------- | -------- | ----------------- |
| | Fairlearn యొక్క వ్యవస్థలు, నడిపించిన నోట్‌బుక్ మరియు దాన్ని నడిపిన తర్వాత తీసుకున్న తీరులను చర్చిస్తూ ఒక పేపర్ లేదా పవర్‌పాయింట్ ప్రెజెంటేషన్ అందించబడింది | తీరులు లేకుండా ఒక పేపర్ అందించబడింది | ఎలాంటి పేపర్ అందించబడలేదు | | | Fairlearn యొక్క వ్యవస్థలు, నడిపించిన నోట్బుక్ మరియు దానిని నడిపిన తర్వాత వచ్చిన నిష్కర్షలను చర్చించే పేపర్ లేదా పవర్‌పాయింట్ ప్రезెంటేషన్ అందించబడింది | నిష్కర్షలు లేకుండా ఒక పేపర్ అందించబడింది | ఏ పేపర్ అందబడలేదు |
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**: **అసంబద్ధత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం మంచిది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము. ఈ పత్రం [Co-op Translator](https://github.com/Azure/co-op-translator) AI అనువాద సేవ ద్వారా అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో లోపాలు లేదా తప్పులుండవచ్చు. ఇది రాబోయే పత్రంలోని మౌలిక భాషలో ఉన్న అసలు పత్రాన్ని అధికారిక మూలంగా భావించాలి. కీలక సమాచారానికి, నిపుణులైన మానవ అనువాదాన్ని ఉపయోగించటం సురక్షితంగా ఉంటుంది. ఈ అనువాదం వలన ఏర్పడిన ఏవైనా అర్థం పొరపాట్లు లేదా తప్పులు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

285
translations/te/2-Regression/3-Linear/README.md
Unescape View File

@ -1,115 +1,127 @@
# Scikit-learn ఉపయోగించి రిగ్రెషన్ మోడల్ నిర్మించండి: రిగ్రెషన్ నాలుగు విధానాలు # Scikit-learn ఉపయోగించి రిగ్రెషన్ మోడల్ ను నిర్మించండి: రిగ్రెషన్ నాలుగు విధాలుగా
![లీనియర్ vs పాలినోమియల్ రిగ్రెషన్ ఇన్ఫోగ్రాఫిక్](../../../../translated_images/te/linear-polynomial.5523c7cb6576ccab.webp) ## ప్రారంభిక గమనిక
> ఇన్ఫోగ్రాఫిక్ [దాసాని మడిపల్లి](https://twitter.com/dasani_decoded) ద్వారా
## [ప్రీ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
> ### [ఈ పాఠం R లో అందుబాటులో ఉంది!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html) లీనియర్ రిగ్రెషన్ అనేది మనం ఒక **న్యూమరిక్ విలువను** (ఉదాహరణకు, ఇంటి ధర, ఉష్ణోగ్రత, లేదా అమ్మకాలు) అంచనా వేసేటప్పుడు ఉపయోగిస్తాం.
ఇది ఇన్పుట్ ఫీచర్లు మరియు అవుట్‌పుట్ మధ్య సంబంధాన్ని ఉత్తమంగా ప్రతిబింబించే సరియైన రేఖ కనుగొనడం ద్వారా పనిచేస్తుంది.
ఈ పాఠంలో, మేము ఈ ఆలోచనను బాగా అర్థం చేసుకోవడంపై దృష్టి సారిస్తాము, తరువాత మరింత అభివృద్ధి చెందిన రిగ్రెషన్ సాంకేతికతలను పరిశీలిస్తాము.
![లీనియర్ vs పోలినోమియల్ రిగ్రెషన్ ఇన్ఫో గ్రాఫిక్](../../../../translated_images/te/linear-polynomial.5523c7cb6576ccab.webp)
> ఇన్ఫోగ్రాపిక్ రూపొందించిన [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [పూర్వ అధ్యయన క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
> ### [ఈ పాఠం R లో లభ్యం!](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### పరిచయం ### పరిచయం
ఇప్పటివరకు మీరు రిగ్రెషన్ అంటే ఏమిటి అనేది పంప్కిన్ ధరల డేటాసెట్ నుండి సేకరించిన నమూనా డేటాతో అన్వేషించారు, దీన్ని ఈ పాఠం మొత్తం ఉపయోగిస్తాము. మీరు Matplotlib ఉపయోగించి దాన్ని విజువలైజ్ కూడా చేసారు. ఇప్పటి వరకు మీరు రిగ్రెషన్ అంటే ఏమిటి అనేది పంప్కిన్ ధరల డేటా సెట్ నుండి సేకరించిన నమూనా డేటాను ఉపయోగించి తెలుసుకున్నారు. మీరు Matplotlib ఉపయోగించి దాన్ని విజువలైజ్ కూడా చేశారు.
ఇప్పుడు మీరు మెషిన్ లెర్నింగ్ లో రిగ్రెషన్ లో లోతైన అవగాహన కోసం సిద్ధంగా ఉన్నారు. విజువలైజేషన్ డేటాను అర్థం చేసుకోవడానికి సహాయపడుతుంది, కానీ మెషిన్ లెర్నింగ్ యొక్క నిజమైన శక్తి _మోడళ్లను ట్రైనింగ్_ చేయడంలో ఉంది. మోడళ్ళు చరిత్రాత్మక డేటాపై శిక్షణ పొందతాయి, డేటా డిపెండెన్సీలను ఆటోమేటిక్‌గా పట్టుకోవడానికి వీలు కల్పించి, ముందర చూడని కొత్త డేటాకు ఫలితాలను అంచనా వేయడానికి వీలు కల్పిస్తాయి.
ఈ పాఠంలో, మీరు రెండు రకాల రిగ్రెషన్ అనేవి తెలుసుకుంటారు: _బేసిక్ లీనియర్ రిగ్రెషన్_ మరియు _పోలినోమియల్ రిగ్రెషన్_, అలాగే ఈ సాంకేతికతలను అర్థం చేసుకోవడానికి కొంత గణిత శాస్త్రం. ఈ మోడల్స్ మాకు వివిధ ఇన్‌పుట్ డేటా ఆధారంగా పుంప్కిన్ ధరలను అంచనా వేసేందుకు సహాయపడతాయి.
ఇప్పుడు మీరు ML కోసం రిగ్రెషన్ లో మరింత లోతుగా ప్రవేశించడానికి సిద్ధంగా ఉన్నారు. విజువలైజేషన్ డేటాను అర్థం చేసుకోవడానికి సహాయపడుతుంది, కానీ మెషీన్ లెర్నింగ్ యొక్క నిజమైన శక్తి _మోడల్స్ శిక్షణ_ నుండి వస్తుంది. మోడల్స్ చరిత్రాత్మక డేటాపై శిక్షణ పొందుతాయి, డేటా ఆధారిత సంబంధాలను ఆటోమేటిక్‌గా పట్టుకోవడానికి, మరియు మోడల్ ఇప్పటివరకు చూడని కొత్త డేటాకు ఫలితాలను అంచనా వేయడానికి వీలు కల్పిస్తాయి. [![మెషిన్ లెర్నింగ్ ప్రారంభవారికి - లీనియర్ రిగ్రెషన్ అర్థం చేసుకోవడం](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "మెషిన్ లెర్నింగ్ ప్రారంభవారికి - లీనియర్ రిగ్రెషన్ అర్థం చేసుకోవడం")
ఈ పాఠంలో, మీరు రెండు రకాల రిగ్రెషన్ గురించి మరింత తెలుసుకుంటారు: _బేసిక్ లీనియర్ రిగ్రెషన్_ మరియు _పాలినోమియల్ రిగ్రెషన్_, మరియు ఈ సాంకేతికతల వెనుక ఉన్న కొన్ని గణిత శాస్త్రం. ఆ మోడల్స్ మాకు వివిధ ఇన్‌పుట్ డేటాపై ఆధారపడి పంప్కిన్ ధరలను అంచనా వేయడానికి సహాయపడతాయి. > 🎥 లీనియర్ రిగ్రెషన్ సంక్షిప్త వీడియో అవలోకనానికి పై చిత్రం పై క్లిక్ చేయండి.
[![ML for beginners - Understanding Linear Regression](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "ML for beginners - Understanding Linear Regression") > ఈ కోర్సు మొత్తం, మేము కనీస గణిత జ్ఞానంతో ఉన్నవారిని అనుకుంటూ, ఇతర రంగాల నుండి వచ్చిన మైత్రియులకు అనువుగా చేయాలని చూస్తున్నాం, కావున గమనికలు, 🧮 గణిత బొమ్మలు, డయాగ్రామ్‌లు మరియు ఇతర నేర్చుకోవడంలో సహాయక సాధనాల కోసం చూస్తూ ఉండండి.
> 🎥 లీనియర్ రిగ్రెషన్ యొక్క సంక్షిప్త వీడియో అవలోకనానికి పై చిత్రం క్లిక్ చేయండి. ### ముందు జ్ఞానం
> ఈ పాఠ్యాంశం మొత్తం, మేము గణితంపై కనీస జ్ఞానం ఉన్నట్లు భావించి, ఇతర రంగాల నుండి వచ్చిన విద్యార్థులకు సులభంగా అర్థమయ్యేలా చేయడానికి ప్రయత్నిస్తాము, కాబట్టి గమనికలు, 🧮 కాల్ అవుట్లు, చిత్రాలు మరియు ఇతర అభ్యాస సాధనాలను గమనించండి. మీకు ఇప్పటివరకు మనం పరిశీలిస్తున్న పుంప్కిన్ డేటా నిర్మాణం తెలుసు అనుకోవచ్చు. దీనిని ఈ పాఠం యొక్క _notebook.ipynb_ ఫైల్ లో ముందుగా లోడ్ చేసి, శుభ్రపరిచిన రూపంలో పొందవచ్చు. ఆ ఫైల్లో పుంప్కిన్ ధరను బషెల్ ప్రధానంగా కొత్త డేటా ఫ్రేమ్ లో ప్రదర్శించబడింది. Visual Studio Code లో kernel లను ఉపయోగించి ఈ నోట్‌బుక్స్ ను నడుపగలగడం నిర్ధారించుకోండి.
### ముందస్తు అవగాహన ### రెడీ కావడం
మీకు ఇప్పటివరకు పరిశీలిస్తున్న పంప్కిన్ డేటా నిర్మాణం గురించి పరిచయం కలిగి ఉండాలి. మీరు ఈ పాఠం యొక్క _notebook.ipynb_ ఫైల్‌లో ముందుగా లోడ్ చేసి శుభ్రపరిచిన డేటాను కనుగొనవచ్చు. ఆ ఫైల్‌లో, పంప్కిన్ ధర బషెల్‌కు ప్రదర్శించబడుతుంది. మీరు Visual Studio Code లో కర్నెల్స్‌లో ఈ నోట్‌బుక్స్ నడపగలగాలి. గమనికగా, మీరు ఈ డేటా లోడ్ చేస్తున్నారు తద్వారా దాని పట్ల ప్రశ్నలు అడగడానికి.
### సిద్ధం కావడం - పుంప్కిన్లు కొనుగోలు చేయడానికి ఉత్తమ సమయం ఎప్పుడు?
- మినీ పుంప్కిన్ల కేప్ ధర ఎంత ఊహించగలవు?
- వాటిని సగం బషెల్ బాస్కెట్లలో కొనాలి లేదా 1 1/9 బషెల్ బాక్స్‌లోనా?
దీనిపై మరింత లోతుగా పరిశోధిద్దాం.
మరలా గుర్తు చేసుకోవడానికి, మీరు ఈ డేటాను లోడ్ చేస్తున్నారంటే దానిపై ప్రశ్నలు అడగడానికి. మునుపటి పాఠంలో, మీరు ఒక Pandas డేటా ఫ్రేమ్ సృష్టించి, అసలు డేటా సెట్ లోని ఒక భాగంతోpopulate చేసి, ధరలను బషెల్‌ ఆధారంగా స్తాండర్డైజ్ చేశారు. అలా చేసినప్పుడు మీరు సుమారుగా 400 డేటాపాయింట్లు మాత్రమే సేకరించగలిగారు మరియు فقط వేసవి నెలల కోసం మాత్రమే.
- పంప్కిన్లను కొనుగోలు చేయడానికి ఉత్తమ సమయం ఎప్పుడు? ఈ పాఠంలోని సహాయక నోట్‌బుక్‌లో ముందుగానే లోడ్ చేసిన డేటాను చూడండి. డేటా ముందే లోడ్ చేయబడింది మరియు ప్రారంభ స్కాటర్ ప్లాట్ నెలల డేటాని చూపిస్తుంది. మరింత శుభ్రపరిచి డేటా స్వభావం గురించి కొంత స్పష్టత పొందవచ్చు.
- మినీ పంప్కిన్ల కేసు ధర ఎంత ఉండవచ్చు?
- వాటిని అర్ధ బషెల్ బాస్కెట్లలో కొనాలా లేదా 1 1/9 బషెల్ బాక్స్ ద్వారా కొనాలా?
మనం ఈ డేటాలో మరింత లోతుగా వెళ్దాం.
మునుపటి పాఠంలో, మీరు Pandas డేటా ఫ్రేమ్ సృష్టించి, అసలు డేటాసెట్‌లోని భాగాన్ని బషెల్ ద్వారా ధరను ప్రమాణీకరించి నింపారు. అయితే, మీరు సుమారు 400 డేటాపాయింట్లు మాత్రమే సేకరించగలిగారు మరియు అవి కేవలం శరదృతువు నెలల కోసం మాత్రమే. ## ఒక లీనియర్ రిగ్రెషన్ రేఖ
ఈ పాఠం యొక్క సహాయక నోట్‌బుక్‌లో ముందుగా లోడ్ చేసిన డేటాను చూడండి. డేటా ముందుగా లోడ్ చేయబడింది మరియు నెల డేటాను చూపించడానికి ప్రారంభ స్కాటర్‌ప్లాట్ రూపొందించబడింది. డేటా స్వభావం గురించి మరింత వివరాలు తెలుసుకోవడానికి మరింత శుభ్రపరచడం చేయవచ్చు. మీరు పాఠం 1 లో ఎక్క‌డ నేర్చుకున్నదానిని అనుసరించి, లీనియర్ రిగ్రెషన్ వ్యాయామం లక్ష్యం ఒక రేఖను గీసే అవకాశం:
## లీనియర్ రిగ్రెషన్ లైన్ - **చరాలను చూపండి**: చరాల మధ్య సంబంధాన్ని ప్రదర్శించండి
- **అంచనాలు చేయండి**: కొత్త డేటాపాయింట్ ఆ రేఖకు సంబంధించి ఎక్కడ పడుతుందో సరిగ్గా అంచనా వేయండి
పాఠం 1 లో మీరు నేర్చుకున్నట్లుగా, లీనియర్ రిగ్రెషన్ వ్యాయామం యొక్క లక్ష్యం ఒక లైన్‌ను ప్లాట్ చేయగలగడం: **లీస్ట్-స్క్వేర్ రిగ్రెషన్** ఈ రకమైన ఒక రేఖ గీసే మార్గం. "లీస్ట్-స్క్వేర్" అనే పదం మన మోడల్ లో తప్పిదాన్ని తగ్గించే ప్రక్రియను సూచిస్తుంది. ప్రతి డేటాపాయింట్ కోసం, మనం నిజమైన పాయింట్ మరియు రిగ్రెషన్ రేఖ మధ్య నిలువరేఖా దూరం (రెసిడ్యుయల్) కొలుస్తాము.
- **వేరియబుల్ సంబంధాలను చూపించండి**. వేరియబుల్స్ మధ్య సంబంధాన్ని చూపించండి ఈ దూరాలను రెండు ముఖ్య కారణాల వల్ల స్క్వేర్ చేస్తాము:
- **అంచనాలు చేయండి**. కొత్త డేటాపాయింట్ ఆ లైన్‌కు సంబంధించి ఎక్కడ పడుతుందో ఖచ్చితంగా అంచనా వేయండి.
**లీస్ట్-స్క్వేర్ రిగ్రెషన్**లో ఈ రకమైన లైన్ డ్రా చేయడం సాధారణం. 'లీస్ట్-స్క్వేర్' అనే పదం అంటే రిగ్రెషన్ లైన్ చుట్టూ ఉన్న అన్ని డేటాపాయింట్లు స్క్వేర్ చేసి, వాటిని జోడించడం. ఆ తుది మొత్తం సాధ్యమైనంత తక్కువగా ఉండాలి, ఎందుకంటే మేము తప్పుల సంఖ్యను తక్కువగా ఉంచాలనుకుంటున్నాము, అంటే `లీస్ట్-స్క్వేర్`. 1. **దిశ కంటే పరిమాణం**: మనం -5 లో తప్పిదాన్ని +5 లో తప్పిదం లాంటివిగా తలచాలి. స్క్వేరింగ్ అన్ని విలువలను ధనాత్మకంగా మార్చుతుంది.
మేము ఈ విధంగా చేస్తాము ఎందుకంటే మేము మా డేటా పాయింట్లన్నింటి నుండి కనీస సమ్మిళిత దూరం కలిగిన లైన్‌ను మోడల్ చేయాలనుకుంటున్నాము. దిశ కాకుండా పరిమాణం గురించి ఆందోళన కలిగినందున, జోడించే ముందు పదాలను స్క్వేర్ చేస్తాము. 2. **అతిరేక పాయింట్లకు కఠినంగా నిందించడం**: స్క్వేరు తప్పిదం పెద్దదైతే, ఆ రేఖ తప్పిదం ఎక్కువ ఉన్న పాయింట్లకు సమీపంగా ఉంటుందని చెబుతుంది.
> **🧮 గణితం చూపించండి** మేము ఆ స్క్వేర్డ్ విలువ‌లను కలుపుతాము. మన లక్ష్యం ఆ చివరి మొత్తం విలువ కనిష్టమయ్యే రేఖ కనుగొనడం.
>
> ఈ లైన్, _లైన్ ఆఫ్ బెస్ట్ ఫిట్_ అని పిలవబడుతుంది, [సమీకరణ](https://en.wikipedia.org/wiki/Simple_linear_regression) ద్వారా వ్యక్తం చేయవచ్చు: > **🧮 నాకు గణితం చూపించు**
> >
> ఈ రేఖ, _లైన్ ఆఫ్ బెస్ట్ ఫిట్_ అంటారు, [సమీకరణ](https://en.wikipedia.org/wiki/Simple_linear_regression) ద్వారా వ్యక్తమవుతుంది:
>
> ``` > ```
> Y = a + bX > Y = a + bX
> ``` > ```
>
> `X` అనేది 'వివరణాత్మక వేరియబుల్'. `Y` అనేది 'ఆధారిత వేరియబుల్'. లైన్ యొక్క స్లోప్ `b` మరియు `a` y-ఇంటర్సెప్ట్, అంటే `X = 0` ఉన్నప్పుడు `Y` విలువ. > `X` అనేది 'వివరణాత్మక చర'గా పిలవబడుతుంది. `Y` అనేది 'ఆధారపడి ఉన్న చర'. రేఖ యొక్క స్లోప్ `b` మరియు `a` అనేది y-ఇంటర్సెప్ట్, అంటే `X = 0` ఉన్నప్పుడు `Y` విలువ.
> >
>![స్లోప్ లెక్కించండి](../../../../translated_images/te/slope.f3c9d5910ddbfcf9.webp) >![స్లోప్ లెక్కింపు](../../../../translated_images/te/slope.f3c9d5910ddbfcf9.webp)
> >
> మొదట, స్లోప్ `b` లెక్కించండి. ఇన్ఫోగ్రాఫిక్ [జెన్ లూపర్](https://twitter.com/jenlooper) ద్వారా > మొదట స్లోప్ `b` లెక్కించండి. ఇన్ఫోగ్రాఫిక్ రూపొందించిన [Jen Looper](https://twitter.com/jenlooper)
> >
> మరొక మాటలో చెప్పాలంటే, మా పంప్కిన్ డేటా యొక్క అసలు ప్రశ్నకు సంబంధించి: "నెల వారీగా పంప్కిన్ ధర అంచనా వేయండి", `X` ధరకు సూచిస్తుంది మరియు `Y` అమ్మకాల నెలకు సూచిస్తుంది. > మరొక మాటలో చెప్పాలంటే, మన పుంప్కిన్ డేటా అసలు ప్రశ్న మేరకు: "నెలకు పుంప్కిన్ ధర అంచనా వేయాలి" అనుకుంటే, `X` ధరకి సంబంధించినది, మరియు `Y` అమ్మకాల నెలకు సంబంధించినది.
> >
>![సమీకరణ పూర్తి చేయండి](../../../../translated_images/te/calculation.a209813050a1ddb1.webp) >![సమీకరణ పూర్తి చేయండి](../../../../translated_images/te/calculation.a209813050a1ddb1.webp)
> >
> Y విలువ లెక్కించండి. మీరు సుమారు $4 చెల్లిస్తుంటే, అది ఏప్రిల్ కావాలి! ఇన్ఫోగ్రాఫిక్ [జెన్ లూపర్](https://twitter.com/jenlooper) ద్వారా > Y విలువను లెక్కించండి. మీరు సుమారుగా $4 చుట్టూ చెల్లిస్తుంటే అది తప్పకుండా ఏప్రిల్ కావాలి! ఇన్ఫోగ్రాఫిక్ డిజైన్ చేసిన [Jen Looper](https://twitter.com/jenlooper)
> >
> లైన్ లెక్కించే గణితం స్లోప్‌ను చూపించాలి, ఇది ఇంటర్సెప్ట్‌పై ఆధారపడి ఉంటుంది, అంటే `X = 0` ఉన్నప్పుడు `Y` ఎక్కడ ఉంటుంది. > ఈ సమీకరణ లెక్కింపు పద్ధతి slope ను ప్రదర్శించాలి, ఇది ఇంటర్సెప్ట్ మీద ఆధారపడి ఉంటుంది, అంటే `X = 0` ఉన్నప్పుడు `Y` ఎక్కడ ఉంటుంది అని.
> >
> ఈ విలువల లెక్కింపు పద్ధతిని మీరు [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) వెబ్‌సైట్‌లో చూడవచ్చు. అలాగే [ఈ లీస్ట్-స్క్వేర్ కాలిక్యులేటర్](https://www.mathsisfun.com/data/least-squares-calculator.html) ను సందర్శించి సంఖ్యల విలువలు లైన్‌పై ఎలా ప్రభావం చూపిస్తాయో చూడండి. > మీరు ఈ విలువల లెక్కింపు పద్ధతి చూడగలరు [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) వెబ్‌సైట్‌లో. ఇది కూడా చూడండి [Least-squares calculator](https://www.mathsisfun.com/data/least-squares-calculator.html) లెక్కల విలువలు రేఖపై ఎలా ప్రభావం చూపుతాయో చూడటానికి.
## సహసంబంధం ## సహసంబంధం
మరొక పదం అర్థం చేసుకోవాలి అంటే **సహసంబంధ గుణకం** X మరియు Y వేరియబుల్స్ మధ్య. స్కాటర్‌ప్లాట్ ఉపయోగించి మీరు ఈ గుణకాన్ని త్వరగా విజువలైజ్ చేయవచ్చు. డేటాపాయింట్లు ఒక సూటిగా పడ్డ స్కాటర్‌ప్లాట్‌కు ఉన్నత సహసంబంధం ఉంటుంది, కానీ డేటాపాయింట్లు X మరియు Y మధ్య ఎక్కడైనా పడ్డ స్కాటర్‌ప్లాట్‌కు తక్కువ సహసంబంధం ఉంటుంది. మరొక ముఖ్యమైన పధ్యం అంటే ఇవ్వబడిన X మరియు Y చరాల మధ్య ఉన్న **సహసంబంధ గుణకం (Correlation Coefficient)**. స్కాటర్ ప్లాట్ ఉపయోగించి ఈ గుణకం త్వరగా గమనించవచ్చు. ఒక రేఖలో పాయింట్లు సరిగా అమర్చబడి ఉంటే, అది అధిక సహసంబంధం అని, కానీ పాయింట్లు విస్తృతంగా చురుకుగా చల్లబడితే సహసంబంధం తక్కువ అని అర్థం.
మంచి లీనియర్ రిగ్రెషన్ మోడల్ అనేది లీస్ట్-స్క్వేర్ రిగ్రెషన్ పద్ధతితో రిగ్రెషన్ లైన్ ఉన్నప్పుడు 1 కి దగ్గరగా ఉన్న (0 కంటే ఎక్కువ) సహసంబంధ గుణకం కలిగి ఉంటుంది. ఒక మంచి లీనియర్ రిగ్రెషన్ మోడల్ అంటే లీస్ట్-స్క్వేర్ రిగ్రెషన్ పద్ధతిలో గల సహసంబంధ గుణకం 1కి దగ్గరగా ఉండటం.
✅ ఈ పాఠం సహాయక నోట్‌బుక్ నడపండి మరియు నెల నుండి ధర స్కాటర్‌ప్లాట్ చూడండి. పంప్కిన్ అమ్మకాల కోసం నెల మరియు ధర మధ్య డేటా మీ విజువల్ అర్థం ప్రకారం అధిక లేదా తక్కువ సహసంబంధం ఉందా? మీరు `నెల` బదులు మరింత సూక్ష్మమైన కొలత ఉపయోగిస్తే, ఉదాహరణకు *సంవత్సరంలో రోజు* (అంటే సంవత్సర ప్రారంభం నుండి గడిచిన రోజుల సంఖ్య), అది మారుతుందా? ✅ ఈ పాఠం యొక్క నోట్‌బుక్ నడబడించి, నెల మరియు ధర మధ్య స్కాటర్ ప్లాట్‌ని పరిశీలించండి. మీ విజువల్ అనుభవం ద్వారా పుంప్కిన్ అమ్మకాల నెల మరియు ధర మధ్య డేటా అధిక సహసంబంధం లేదా తక్కువ ఉందా? మీరు `Month`మే కాకుండా *సంవత్సరం లో రోజుల సంఖ్య* (DayOfYear) ని అంటే మరింత సూక్ష్మాతీస్థితిని ఉపయోగిస్తే ఇది మారుతుందా?
క్రింది కోడ్‌లో, మేము డేటాను శుభ్రపరిచినట్లు భావిస్తాము, మరియు `new_pumpkins` అనే డేటా ఫ్రేమ్ పొందాము, ఇది ఈ క్రింది విధంగా ఉంటుంది: కింది కోడ్‌లో, మేము డేటాను శుభ్రపరిచినట్లు భావిస్తాము, మరియు `new_pumpkins` అనే డేటా ఫ్రేమ్ పొందాము, ఇది ఈ క్రింది ప్రతిరూపం విధంగా ఉంటుంది:
ID | నెల | సంవత్సరం లో రోజు | రకం | నగరం | ప్యాకేజీ | తక్కువ ధర | ఎక్కువ ధర | ధర ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
---|-------|-----------|---------|------|---------|-----------|------------|------- ---|-------|-----------|---------|------|---------|-----------|------------|-------
70 | 9 | 267 | పై టైప్ | బాల్టిమోర్ | 1 1/9 బషెల్ కార్టన్లు | 15.0 | 15.0 | 13.636364 70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
71 | 9 | 267 | పై టైప్ | బాల్టిమోర్ | 1 1/9 బషెల్ కార్టన్లు | 18.0 | 18.0 | 16.363636 71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
72 | 10 | 274 | పై టైప్ | బాల్టిమోర్ | 1 1/9 బషెల్ కార్టన్లు | 18.0 | 18.0 | 16.363636 72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
73 | 10 | 274 | పై టైప్ | బాల్టిమోర్ | 1 1/9 బషెల్ కార్టన్లు | 17.0 | 17.0 | 15.454545 73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545
74 | 10 | 281 | పై టైప్ | బాల్టిమోర్ | 1 1/9 బషెల్ కార్టన్లు | 15.0 | 15.0 | 13.636364 74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
> డేటాను శుభ్రపరచడానికి కోడ్ [`notebook.ipynb`](notebook.ipynb) లో అందుబాటులో ఉంది. మేము మునుపటి పాఠంలో చేసిన శుభ్రపరిచే దశలను అమలు చేసాము, మరియు `DayOfYear` కాలమ్‌ను క్రింది వ్యక్తీకరణతో లెక్కించాము: > డేటా శుభ్రపరిచే కోడ్ [`notebook.ipynb`](notebook.ipynb) లో అందుబాటులో ఉంది. మేము మునుపటి పాఠంలో చేసిన శుభ్రతా దశలను అమలు చేశాము, మరియు క్రింది వ్యక్తీకరణ ద్వారా `DayOfYear` కాలమ్ లెక్కించాము:
```python ```python
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days) day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
``` ```
మీకు లీనియర్ రిగ్రెషన్ గణితం గురించి అవగాహన కలిగిన తర్వాత, ఇప్పుడు మనం ఒక రిగ్రెషన్ మోడల్ తయారు చేద్దాం చూసేద్దాం ఏ పుంప్కిన్ ప్యాకేజీకి ఉత్తమ ధర ఉంటుందో తెలుసుకోవడానికి. పండుగ పుంప్కిన్ ప్యాచ్ కొరకు పుంప్కిన్ కొనేవారు ఈ సమాచారం ఉపయోగించి కొనుగోళ్లను మెరుగుపరచుకుంటారు.
లీనియర్ రిగ్రెషన్ వెనుక గణితాన్ని మీరు అర్థం చేసుకున్న తర్వాత, పంప్కిన్ ప్యాకేజీలలో ఏది ఉత్తమ ధర కలిగి ఉంటుందో అంచనా వేయడానికి రిగ్రెషన్ మోడల్ సృష్టిద్దాం. సెలవుల పంప్కిన్ ప్యాచ్ కోసం పంప్కిన్లు కొనుగోలు చేసే వారు ఈ సమాచారాన్ని ఉపయోగించి తమ కొనుగోళ్లను ఆప్టిమైజ్ చేసుకోవచ్చు. ## సహసంబంధం కోసం వెతుకుదాం
## సహసంబంధం కోసం వెతుకుతున్నాం
[![ML for beginners - Looking for Correlation: The Key to Linear Regression](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML for beginners - Looking for Correlation: The Key to Linear Regression") [![ML ప్రారంభవారికి - సహసంబంధం కోసం వెతుకుతాం: లీనియర్ రిగ్రెషన్ యొక్క కీలకం](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "ML ప్రారంభవారికి - సహసంబంధం కోసం వెతుకుతాం: లీనియర్ రిగ్రెషన్ యొక్క కీలకం")
> 🎥 సహసంబంధం యొక్క సంక్షిప్త వీడియో అవలోకనానికి పై చిత్రం క్లిక్ చేయండి. > 🎥 సహసంబంధ సందర్శన సంక్షిప్త వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి.
మునుపటి పాఠం నుండి మీరు చూసినట్లయితే, వివిధ నెలల సగటు ధర ఇలా ఉంటుంది: మునుపటి పాఠం నుండి మీరు చూసినట్టు, వేర్వేరు నెలల సగటు ధర ఇలా ఉంటుంది:
<img alt="నెల వారీ సగటు ధర" src="../../../../translated_images/te/barchart.a833ea9194346d76.webp" width="50%"/> <img alt="నెల வாரీ సగటు ధర" src="../../../../translated_images/te/barchart.a833ea9194346d76.webp" width="50%"/>
ఇది కొంత సహసంబంధం ఉండాలని సూచిస్తుంది, మరియు మేము `నెల` మరియు `ధర` మధ్య లేదా `DayOfYear` మరియు `ధర` మధ్య సంబంధాన్ని అంచనా వేయడానికి లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణ ఇవ్వవచ్చు. క్రింది స్కాటర్ ప్లాట్ ఆ తర్వాత సంబంధాన్ని చూపిస్తుంది: ఇది కొంత సహసంబంధం ఉండే సూచన చేస్తుంది, మరియు మేము `Month` మరియు `Price` మధ్య, లేదా `DayOfYear` మరియు `Price` మధ్య సంబంధాన్ని అంచనా వేసే లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణ ఇస్తే ఎలా ఉంటుందో చూడవచ్చు. క్రింద స్కాటర్ ప్లాట్ ఆ తర్వాత సంబంధాన్ని చూపిస్తుంది:
<img alt="ధర vs. సంవత్సరం లో రోజు స్కాటర్ ప్లాట్" src="../../../../translated_images/te/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" /> <img alt="దినాంశం ప్రకారం ధర స్కాటర్ ప్లాట్" src="../../../../translated_images/te/scatter-dayofyear.bc171c189c9fd553.webp" width="50%" />
`corr` ఫంక్షన్ ఉపయోగించి సహసంబంధం ఉందా చూద్దాం: `corr` ఫంక్షన్ ఉపయోగించి సహసంబంధం ఉందా చూద్దాం:
@ -117,8 +129,8 @@ day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.
print(new_pumpkins['Month'].corr(new_pumpkins['Price'])) print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price'])) print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
``` ```
సహసంబంధం చాలా తక్కువగా ఉంది, `నెల` ద్వారా -0.15 మరియు `DayOfMonth` ద్వారా -0.17, కానీ మరో ముఖ్యమైన సంబంధం ఉండవచ్చు. వివిధ పంప్కిన్ రకాల ధరల వేర్వేరు క్లస్టర్లు ఉన్నట్లు కనిపిస్తోంది. ఈ హైపోథసిస్ నిర్ధారించడానికి, ప్రతి పంప్కిన్ వర్గాన్ని వేరే రంగుతో ప్లాట్ చేద్దాం. `scatter` ప్లాటింగ్ ఫంక్షన్‌కు `ax` పారామీటర్ ఇవ్వడం ద్వారా అన్ని పాయింట్లను ఒకే గ్రాఫ్‌లో ప్లాట్ చేయవచ్చు: సహసంబంధం తక్కువగా కనిపిస్తుంది, `Month` కు -0.15, మరియు `DayOfMonth` కు -0.17, కానీ మరో ముఖ్యమైన సంబంధం ఉండవచ్చు. వేర్వేరు పుంప్కిన్ రకాల ధరకెక్కలు వేరుగా గుళ్ళలా చూపుతాయి. ఈ సత్యాన్ని నిర్ధారించడానికి, ప్రతి పుంప్కిన్ వర్గాన్ని వేరే రంగులో గీయండి. `scatter` ఫంక్షన్‌కు `ax` పరామితిని పంపించి అన్ని పాయింట్లు ఒకే గ్రాఫ్ పై ప్లాట్ చేయవచ్చు:
```python ```python
ax=None ax=None
@ -127,74 +139,75 @@ for i,var in enumerate(new_pumpkins['Variety'].unique()):
df = new_pumpkins[new_pumpkins['Variety']==var] df = new_pumpkins[new_pumpkins['Variety']==var]
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var) ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
``` ```
<img alt="రంగులతో దినాంశం ప్రకారం ధర స్కాటర్ ప్లాట్" src="../../../../translated_images/te/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" />
<img alt="ధర vs. సంవత్సరం లో రోజు రంగు స్కాటర్ ప్లాట్" src="../../../../translated_images/te/scatter-dayofyear-color.65790faefbb9d54f.webp" width="50%" /> మన పరిశోధన ద్వారా కనిపించిందంటే రకం విక్రయ తేదీ కంటే ధర మీద ఎక్కువ ప్రభావం చూపుతుంది. దీన్ని బార్ గ్రాఫ్ ద్వారా చూడగలం:
మా పరిశీలన ప్రకారం, రకం అమ్మకాల తేదీ కంటే మొత్తం ధరపై ఎక్కువ ప్రభావం చూపుతుంది. దీన్ని బార్ గ్రాఫ్‌తో చూడవచ్చు:
```python ```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar') new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
``` ```
<img alt="రకం ప్రకారం ధర బార్ గ్రాఫ్" src="../../../../translated_images/te/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
<img alt="ధర vs రకం బార్ గ్రాఫ్" src="../../../../translated_images/te/price-by-variety.744a2f9925d9bcb4.webp" width="50%" /> ఇప్పుడు మనం ఒక్క పుంప్కిన్ రకం 'పై టైప్' పై మాత్రమే దృష్టి సారించి, తేదీ ధరపై ఎలాంటి ప్రభావం చూపుతుందో చూద్దాం:
ఇప్పుడు మనం కేవలం ఒక పంప్కిన్ రకం, 'పై టైప్' పై దృష్టి పెట్టి, తేదీ ధరపై ఎలాంటి ప్రభావం చూపుతుందో చూద్దాం:
```python ```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE'] pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price') pie_pumpkins.plot.scatter('DayOfYear','Price')
``` ```
<img alt="ధర vs. సంవత్సరం లో రోజు స్కాటర్ ప్లాట్" src="../../../../translated_images/te/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" /> <img alt="దినాంశం ప్రకారం ధర స్కాటర్ - పై రకం" src="../../../../translated_images/te/pie-pumpkins-scatter.d14f9804a53f927e.webp" width="50%" />
ఇప్పుడు `corr` ఫంక్షన్ ఉపయోగించి `ధర` మరియు `DayOfYear` మధ్య సహసంబంధం లెక్కిస్తే, సుమారు `-0.27` వస్తుంది - అంటే అంచనా వేయగల మోడల్ శిక్షణ ఇవ్వడం అర్థం. ఇప్పటి `Price` మరియు `DayOfYear` మధ్య సహసంబంధం `corr` ఫంక్షన్ ద్వారా లెక్కించితే సుమారు `-0.27` వస్తుంది, అంటే అంచనా మోడల్ శిక్షణ సరైనది.
> లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణకు ముందు, మా డేటా శుభ్రంగా ఉందని నిర్ధారించుకోవడం ముఖ్యం. లీనియర్ రిగ్రెషన్ లో మిస్సింగ్ విలువలతో పని చేయడం సరిగా ఉండదు, కాబట్టి అన్ని ఖాళీ సెల్స్ తొలగించడం మంచిది: > లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణ మొదలుపెట్టేముందు, డేటా శుభ్రంగా ఉందని నిర్ధారించుకోవాలి. లీనియర్ రిగ్రెషన్ లో లెక్కలు లేకపోవడం వల్ల సరిగ్గా పని చేయదు, అందుకే ఖాళీ செல్లను తీసివేయడం బాగా ఉంటుంది:
```python ```python
pie_pumpkins.dropna(inplace=True) pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info() pie_pumpkins.info()
``` ```
మరొక విధానం ఖాళీ విలువలను సంబంధిత కాలమ్ యొక్క సగటు విలువలతో భర్తీ చేయడం. ఇంకో పద్ధతి ఖాళీ విలువలను సంబంధిత కాలమ్ యొక్క సగటు విలువలతో భర్తీ చేయడం.
## సింపుల్ లీనియర్ రిగ్రెషన్ ## సింపుల్ లీనియర్ రిగ్రెషన్
[![ML for beginners - Linear and Polynomial Regression using Scikit-learn](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML for beginners - Linear and Polynomial Regression using Scikit-learn") [![ML ప్రారంభవారికి - Scikit-learn ఉపయోగించి లీనియర్ మరియు పోలినోమియల్ రిగ్రెషన్](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "ML ప్రారంభవారికి - Scikit-learn ఉపయోగించి లీనియర్ మరియు పోలినోమియల్ రిగ్రెషన్")
> 🎥 లీనియర్ మరియు పాలినోమియల్ రిగ్రెషన్ యొక్క సంక్షిప్త వీడియో అవలోకనానికి పై చిత్రం క్లిక్ చేయండి. > 🎥 లీనియర్ మరియు పోలినోమియల్ రిగ్రెషన్ సంక్షిప్త వీడియో అవలోకనానికి పై చిత్రం పై క్లిక్ చేయండి.
మా లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణకు, మేము **Scikit-learn** లైబ్రరీని ఉపయోగిస్తాము. లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణ కోసం, మేము **Scikit-learn** లైబ్రరీని ఉపయోగిస్తాము.
```python ```python
from sklearn.linear_model import LinearRegression from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split from sklearn.model_selection import train_test_split
``` ```
మేము మొదట ఇన్‌పుట్ విలువలు (ఫీచర్లు) మరియు అంచనా వేయాల్సిన అవుట్‌పుట్ (లేబుల్) ను వేర్వేరు numpy అర్రేలలో విడగొడతాము: మనం ఇన్‌పుట్ విలువలు (ఫీచర్లు) మరియు అంచనా వేయవలసిన అవుట్పుట్ (లేబుల్) ను వేర్వేరు numpy అర్రేస్ లో విడగొడతాము:
```python ```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1) X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price'] y = pie_pumpkins['Price']
``` ```
> గమనించండి, లీనియర్ రిగ్రెషన్ ప్యాకేజీకి సరియైన విధంగా ఉన్నట్టుగా వుండేందుకు ఇన్‌పుట్ డేటాను `reshape` చేయాల్సి వచ్చింది. లీనియర్ రిగ్రెషన్ 2D అర్రేని ఉపయోగిస్తుందని ఆశిస్తుంది, ఇందులో ప్రతి పంక్తి ఇన్‌పుట్ ఫీచర్ల యొక్క వెక్టార్. మనకి ఒక్క ఇన్‌పుట్ ఉన్నందున, N×1 రూపంలో ఒక అర్రే కావాలి, ఇక్కడ N అనేది డేటాసెట్ పరిమాణం.
> గమనించండి, లీనియర్ రిగ్రెషన్ ప్యాకేజీ సరిగ్గా అర్థం చేసుకోవడానికి ఇన్‌పుట్ డేటాపై `reshape` చేయాల్సి వచ్చింది. లీనియర్ రిగ్రెషన్ 2D-అర్రేను ఇన్‌పుట్‌గా ఆశిస్తుంది, ఇందులో ప్రతి వరుస ఒక ఫీచర్ వెక్టర్‌కు సరిపోతుంది. మన కేసులో, ఒక్క ఇన్‌పుట్ ఉన్నందున, N×1 ఆకారంలో అర్రే కావాలి, ఇక్కడ N డేటాసెట్ పరిమాణం. ఆపై, మనం డేటాను ట్రెయిన్ మరియు టెస్ట్ డేటాసెట్ లుగా విభజించాలి, తద్వారా శిక్షణ తర్వాత మనం మోడల్‌ను సరైనదని నిర్ధారించుకోగలను:
తర్వాత, మేము డేటాను శిక్షణ మరియు పరీక్ష డేటాసెట్‌లుగా విభజించాలి, తద్వారా శిక్షణ తర్వాత మోడల్‌ను ధృవీకరించవచ్చు:
```python ```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
``` ```
చివరగా, లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణ రెండు కోడ్ లైన్లలోనే జరుగుతుంది. మేము `LinearRegression` ఆబ్జెక్ట్‌ను నిర్వచించి, `fit` మెథడ్ ఉపయోగించి మా డేటాకు అనుగుణంగా చేస్తాము: చివరగా, లీనియర్ రిగ్రెషన్ మోడల్ ను శిక్షణ ఇవ్వడం రెండు కోడ్ లైన్లలోనే జరుగుతుంది. మేము `LinearRegression` ఆబ్జెక్ట్ ను నిర్వచించి, `fit` మెథడ్ ద్వారా మన డేటాకు అనుగుణంగా రూపొందిస్తాము:
```python ```python
lin_reg = LinearRegression() lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train) lin_reg.fit(X_train,y_train)
``` ```
`fit` చేసిన తర్వాత `LinearRegression` ఆబ్జెక్ట్‌లో రిగ్రెషన్ యొక్క అన్ని కోఎఫిషియెంట్లు ఉంటాయి, వాటిని `.coef_` ప్రాపర్టీ ద్వారా యాక్సెస్ చేయవచ్చు. మన కేసులో, ఒక్క కోఎఫిషియెంట్ ఉంటుంది, అది సుమారు `-0.017` ఉంటుంది. అంటే ధరలు కాలంతో కొంత తగ్గుతున్నట్లు కనిపిస్తుంది, రోజుకు సుమారు 2 సెంట్లు. మేము రిగ్రెషన్ యొక్క Y-అక్షంతో ఇంటర్సెక్షన్ పాయింట్‌ను `lin_reg.intercept_` ద్వారా కూడా పొందవచ్చు - ఇది మన కేసులో సుమారు `21` ఉంటుంది, సంవత్సర ప్రారంభంలో ధరను సూచిస్తుంది. `fit` చేసిన తరువాత `LinearRegression` ఆబ్జెక్ట్ రిగ్రెషన్ యొక్క అన్ని సహగుణాలను కలిగి ఉంటుంది, వాటిని `.coef_` ప్రాపర్టీ ఉపయోగించి యాక్సెస్ చేయవచ్చు. మన కేసులో, ఒకే ఒక్క సహగుణం ఉంది, అది సుమారు `-0.017` ఉండాలి. దీని అర్థం ఏమిటంటే, ధరలు కాలక్రమేణా కొంత క్షీణిస్తున్నట్లు కనిపిస్తోంది, రోజుకు సుమారు 2 సెంట్లు తగ్గుతుంటాయి. రిగ్రెషన్ యొక్క Y-అక్షతో కూడిన ఇంటర్‌సెక్షన్ పాయింట్ ను మనం `lin_reg.intercept_` ఉపయోగించి కూడా యాక్సెస్ చేయవచ్చు - మన కేసులో ఇది సుమారు `21` ఉంటుంది, ఇది సంవత్సరం ప్రారంభంలో ధరను సూచిస్తుంది.
మా మోడల్ ఎంత ఖచ్చితంగా ఉందో చూడటానికి, మేము టెస్ట్ డేటాసెట్‌పై ధరలను అంచనా వేయవచ్చు, ఆపై మా అంచనాలు ఆశించిన విలువలకు ఎంత దగ్గరగా ఉన్నాయో కొలవవచ్చు. ఇది మినీ స్క్వేర్ ఎర్రర్ (MSE) మెట్రిక్స్ ఉపయోగించి చేయవచ్చు, ఇది ఆశించిన మరియు అంచనా విలువల మధ్య అన్ని చదరపు తేడాల సగటు.
మన మోడల్ ఎంత ఖచ్చితమో చూసేందుకు, మనం టెస్ట్ డేటాసెట్ పై ధరలను అంచనా వేసి, అది ఆశించిన మూల్యాలకు ఎంత దగ్గరగా ఉన్నదో కొలవవచ్చు. ఇది mean square error (MSE) ప్రమాణం ఉపయోగించి చేయవచ్చు, ఇది ఆశించిన మరియు అంచనా విలువల మధ్య ఉన్న అన్ని వర్గ ఉన్నత వ్యత్యాసాల యొక్క సగటు.
```python ```python
pred = lin_reg.predict(X_test) pred = lin_reg.predict(X_test)
@ -203,16 +216,16 @@ mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)') print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
``` ```
మా పొరపాటు సుమారు 2 పాయింట్ల చుట్టూ ఉంది, ఇది సుమారు 17%. చాలా బాగాలేదు. మోడల్ నాణ్యతకు మరో సూచిక **నిర్ణయ సహగుణం** (coefficient of determination), ఇది ఇలా పొందవచ్చు: మన తప్పిదం సుమారు 2 పాయింట్ల చుట్టూ ఉంది, ఇది ~17%. చాలా మంచి కాదు. మోడల్ నాణ్యతకు మరొక సూచిక **coefficient of determination** అని పిలవబడుతుంది, దాన్ని ఇలా పొందవచ్చు:
```python ```python
score = lin_reg.score(X_train,y_train) score = lin_reg.score(X_train,y_train)
print('Model determination: ', score) print('Model determination: ', score)
``` ```
విలువ 0 అయితే, అంటే మోడల్ ఇన్‌పుట్ డేటాను పరిగణలోకి తీసుకోదు, మరియు *చెత్త లీనియర్ అంచనా వేయగలిగే* మోడల్‌గా పనిచేస్తుంది, ఇది ఫలితాల సగటు విలువ మాత్రమే. విలువ 1 అంటే మేము అన్ని ఆశించిన అవుట్‌పుట్‌లను పూర్తిగా అంచనా వేయగలమని అర్థం. మా సందర్భంలో, సహగుణం సుమారు 0.06, ఇది చాలా తక్కువ. ఈ విలువ 0 అయితే, మోడల్ ఇన్{}పుట్ డేటాను పరిగణనలోకి తీసుకోలేదు, మరియు *చాలా చెత్త లీనియర్ అంచనావాది* (worst linear predictor) లాగా పని చేస్తుంది, ఇది ఫలితపు సరాసరి విలువ మాత్రమే. విలువ 1 అంటే మనం అన్ని ఆశించిన అవుట్పుట్లను సరిగ్గా అంచనా వేయగలమని అర్థం. మన కేసులో, coefficient సుమారు 0.06, ఇది చాలా తక్కువ.
మేము టెస్ట్ డేటాను రిగ్రెషన్ లైన్‌తో కలిసి ప్లాట్ చేయవచ్చు, మా సందర్భంలో రిగ్రెషన్ ఎలా పనిచేస్తుందో మెరుగ్గా చూడటానికి: మనం టెస్ట్ డేటాను రిగ్రెషన్ రేఖతో కలిసి కూడా చిత్రీకరించవచ్చు, మన కేసులో రిగ్రెషన్ ఎలా పని చేస్తుందో మెరుగ్గా చూడటానికి:
```python ```python
plt.scatter(X_test,y_test) plt.scatter(X_test,y_test)
@ -221,19 +234,19 @@ plt.plot(X_test,pred)
<img alt="Linear regression" src="../../../../translated_images/te/linear-results.f7c3552c85b0ed1c.webp" width="50%" /> <img alt="Linear regression" src="../../../../translated_images/te/linear-results.f7c3552c85b0ed1c.webp" width="50%" />
## పాలినోమియల్ రిగ్రెషన్ ## పోలినోమియల్ రిగ్రెషన్
లీనియర్ రిగ్రెషన్ యొక్క మరో రకం పాలినోమియల్ రిగ్రెషన్. కొన్ని సార్లు వేరియబుల్స్ మధ్య లీనియర్ సంబంధం ఉంటుంది - వాల్యూమ్ లో పెద్ద పంక్‌కిన్ ఉంటే ధర ఎక్కువ - కానీ కొన్ని సార్లు ఈ సంబంధాలను ప్లేన్ లేదా సూటి రేఖగా చిత్రీకరించలేము. లెనియర్ రిగ్రెషన్ యొక్క మరో రకం పోలినోమియల్ రిగ్రెషన్. కొన్నిసార్లు వేరియబుల్స్ మధ్య లీనియర్ సంబంధం ఉంటుంది — వాల్యూమ్ లో మెగా తూర్పులో గుమ్మడికాయ పెరిగితే ధర కూడా పెరుగుతుంది — కానీ ఈ సంబంధాలు సాధారణంగా సమతలమైన లేదా సరాసరి లైన్ గా చూపించలేము.
✅ ఇక్కడ [మరిన్ని ఉదాహరణలు](https://online.stat.psu.edu/stat501/lesson/9/9.8) ఉన్నాయి, ఇవి పాలినోమియల్ రిగ్రెషన్ ఉపయోగించవచ్చు ✅ ఇక్కడ [ఇంకా కొన్ని ఉదాహరణలు](https://online.stat.psu.edu/stat501/lesson/9/9.8) ఉన్నాయి, ఇవి పోలినోమియల్ రిగ్రెషన్ అవసరం కావచ్చు
తేదీ మరియు ధర మధ్య సంబంధాన్ని మరోసారి చూడండి. ఈ స్కాటర్‌ప్లాట్ తప్పనిసరిగా సూటి రేఖతో విశ్లేషించాల్సినదిగా అనిపిస్తుందా? ధరలు మారవచ్చునా? ఈ సందర్భంలో, మీరు పాలినోమియల్ రిగ్రెషన్ ప్రయత్నించవచ్చు. Date మరియు Price మధ్య సంబంధం మరోసారి చూడండి. ఈ స్కాటర్‌ప్లాట్ సరాసరి లైన్తో తప్పనిసరిగా విశ్లేషించవలసినది అనిపిస్తుందా? ధరలు మార్పు చెందలేవా? ఈ సందర్భంలో, మీరు పోలినొమియల్ రిగ్రెషన్ ప్రయత్నించవచ్చు.
✅ పాలినోమియల్స్ అనేవి ఒకటి లేదా ఎక్కువ వేరియబుల్స్ మరియు సహగుణాలతో కూడిన గణితీయ వ్యక్తీకరణలు ✅ పోలినొమియల్స్ అనేవి ఒకదాని కంటే ఎక్కువ వేరియబుల్స్ మరియు సహగుణాల కలయికలు ఉండే గణిత అభివ్యక్తులు
పాలినోమియల్ రిగ్రెషన్ వక్రీకృత రేఖను సృష్టించి, నాన్‌లీనియర్ డేటాకు మెరుగైన సరిపోయేలా చేస్తుంది. మా సందర్భంలో, ఇన్‌పుట్ డేటాలో స్క్వేర్ చేసిన `DayOfYear` వేరియబుల్‌ను చేర్చితే, మేము మా డేటాను ఒక పారబాలిక్ వక్రీకరణతో సరిపోల్చగలము, ఇది సంవత్సరంలో ఒక నిర్దిష్ట బిందువులో కనిష్ఠం ఉంటుంది. పోలినోమియల్ రిగ్రెషన్ వక్రీభవించిన రేఖను సృష్టిస్తుంది, అంతర్జాతీయ డేటాను బాగా సరిపోల్చేందుకు. మన కేసులో, మనం `DayOfYear` ఛైక్రమంలో చదరపు వేరియబుల్ చేర్చితే, మనం మన డేటాను పారాబాలిక్ వక్రీభవంలో సరిపోల్చగలము, ఇది ఏడాది లో ఒక నిర్దిష్ట స్థానంలో కనిష్టం ఉంటుంది.
Scikit-learn ఒక సహాయక [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) కలిగి ఉంది, ఇది డేటా ప్రాసెసింగ్ యొక్క వివిధ దశలను కలిపేందుకు ఉపయోగపడుతుంది. ఒక **pipeline** అనేది **estimators** యొక్క గొలుసు. మా సందర్భంలో, మేము మొదట మా మోడల్‌కు పాలినోమియల్ ఫీచర్లను జోడించి, ఆపై రిగ్రెషన్‌ను ట్రెయిన్ చేసే pipeline సృష్టిస్తాము: స్కైకిట్-లెర్న్ లో డేటా ప్రాసెసింగ్ యొక్క వివిధ దశలను కలిపే వినియోగకరమైన [pipeline API](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline) ఉంది. ఒక **pipeline** అనేది **estimators** యొక్క గొలుసు. మన కేసులో, మేము మొదట పోలినోమియల్ ఫీచర్స్ ను మోడల్లో చేర్చిన తరువాత, రిగ్రెషన్ ను ట్రెయిన్ చేసే pipeline సృష్టిస్తాము:
```python ```python
from sklearn.preprocessing import PolynomialFeatures from sklearn.preprocessing import PolynomialFeatures
@ -244,36 +257,36 @@ pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train) pipeline.fit(X_train,y_train)
``` ```
`PolynomialFeatures(2)` ఉపయోగించడం అంటే మేము ఇన్‌పుట్ డేటా నుండి అన్ని రెండవ-డిగ్రీ పాలినోమియల్స్‌ను చేర్చుతాము. మా సందర్భంలో ఇది కేవలం `DayOfYear`<sup>2</sup> మాత్రమే, కానీ రెండు ఇన్‌పుట్ వేరియబుల్స్ X మరియు Y ఉంటే, ఇది X<sup>2</sup>, XY మరియు Y<sup>2</sup> ను జోడిస్తుంది. మేము కావాలంటే ఎక్కువ డిగ్రీ పాలినోమియల్స్ కూడా ఉపయోగించవచ్చు. `PolynomialFeatures(2)` ఉపయోగించడం అంటే ఇన్{}పుట్ డేటాలోని అన్ని రెండో డిగ్రీ పోలినోమియల్స్ చేర్చబడతాయి. మన కేసులో అది కేవలం `DayOfYear`<sup>2</sup> మాత్రమే అవుతుంది, కానీ ఇన్{}పుట్ వేరియబుల్స్ X మరియు Y ఉంటే, ఇది X<sup>2</sup>, XY మరియు Y<sup>2</sup> చేర్చుతుంది. మనం ఎక్కువ డిగ్రీ పోలినోమియల్స్ కూడా ఉపయోగించవచ్చు.
Pipelines ను అసలు `LinearRegression` ఆబ్జెక్ట్ లాగా ఉపయోగించవచ్చు, అంటే మేము pipeline ను `fit` చేసి, ఆపై `predict` ఉపయోగించి అంచనా ఫలితాలు పొందవచ్చు. ఇక్కడ టెస్ట్ డేటా మరియు సన్నిహిత వక్రీకరణ వక్రాన్ని చూపించే గ్రాఫ్ ఉంది: Pipeline లను ఆరంభ లీనియర్ రిగ్రెషన్ ఆబ్జెక్ట్ వలెనే ఉపయోగించవచ్చు, అంటే pipeline `fit` చేసి, తర్వాత `predict` ఉపయోగించి అంచనా ఫలితాలను తీసుకోవచ్చు. ఇది టెస్ట్ డేటా, మరియు సన్నిహిత వక్రీభవాన్ని చూపే గ్రాఫ్:
<img alt="Polynomial regression" src="../../../../translated_images/te/poly-results.ee587348f0f1f60b.webp" width="50%" /> <img alt="Polynomial regression" src="../../../../translated_images/te/poly-results.ee587348f0f1f60b.webp" width="50%" />
పాలినోమియల్ రిగ్రెషన్ ఉపయోగించి, మేము కొంచెం తక్కువ MSE మరియు ఎక్కువ నిర్ణయ సహగుణం పొందవచ్చు, కానీ గణనీయంగా కాదు. మేము ఇతర ఫీచర్లను కూడా పరిగణలోకి తీసుకోవాలి! పోలినోమియల్ రిగ్రెషన్ ఉపయోగించి, మనం కొంచెం తక్కువ MSE మరియు ఎక్కువ determination పొందవచ్చు, కానీ చాలా పెద్దగా కాదు. ఇతర ఫీచర్లను పరిగణనలోకి తీసుకోవాలి!
> మీరు గమనించవచ్చు, కనిష్ఠ పంక్‌కిన్ ధరలు హాలోవీన్ సమీపంలో ఉంటాయి. దీన్ని మీరు ఎలా వివరిస్తారు? > మీరు గమనించవచ్చు, కనిష్ట పండ్లు ధర్నం హాలోవీన్ దినచర్యలో ఉన్నట్లు కనిపిస్తోంది. దీన్ని ఎలా వివరించగలరు?
🎃 అభినందనలు, మీరు ఇప్పుడు పాయ్ పంక్‌కిన్ ధర అంచనా వేయగలిగే మోడల్ సృష్టించారు. మీరు అన్ని పంక్‌కిన్ రకాల కోసం ఇదే ప్రక్రియను పునరావృతం చేయవచ్చు, కానీ అది కష్టమైన పని. ఇప్పుడు మనం మా మోడల్‌లో పంక్‌కిన్ రకాన్ని ఎలా పరిగణలోకి తీసుకోవాలో నేర్చుకుందాం! 🎃 శుభాకాంక్షలు, మీరు ఇప్పుడు పి గుమ్మడికాయ ధర అంచనా వేయగలిగే మోడల్ సృష్టించారని. మిగిలిన అన్ని గుమ్మడికాయ రకాలకు ఇదే ప్రక్రియను పునరావృతం చేయవచ్చు, కానీ అది జీజ్ఞాస కలిగిన పని. మనం ఇప్పుడు మన మోడల్ లో గుమ్మడికాయ జాతిని పరిగణనలోకి ఎలా తీసుకోవచ్చో నేర్చుకుందాం!
## వర్గీకృత ఫీచర్లు ## వర్గీకరణ ఫీచర్లు
స идеల్ ప్రపంచంలో, మేము ఒకే మోడల్ ఉపయోగించి వివిధ పంక్‌కిన్ రకాల ధరలను అంచనా వేయగలగాలి. అయితే, `Variety` కాలమ్ `Month` లాంటి కాలమ్స్ నుండి కొంత భిన్నంగా ఉంటుంది, ఎందుకంటే ఇది సంఖ్యాత్మక విలువలు కాకుండా ఉంటుంది. ఇలాంటి కాలమ్స్‌ను **వర్గీకృత** (categorical) అంటారు. స ideaal లో, మనం ఒకే మోడల్ ఉపయోగించి వేర్వేరు గుమ్మడికాయ జాతుల ధరలను అంచనా వేయగలగాలి. కానీ, `Variety` కాలమ్ నిర్వహణలో `Month` లా కాదు, ఎందుకంటే దీని లోనివి సంఖ్యాత్మక (numeric) విలువలు కావు. ఇలాంటి కాలమ్స్ ను **categorical** అని పిలుస్తారు.
[![ML for beginners - Categorical Feature Predictions with Linear Regression](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression") [![ML for beginners - Categorical Feature Predictions with Linear Regression](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
> 🎥 పై చిత్రాన్ని క్లిక్ చేసి వర్గీకృత ఫీచర్ల ఉపయోగంపై చిన్న వీడియో అవలోకనం చూడండి. > 🎥 కేటగిరీ ఫీచర్లు ఎలా ఉపయోగించాలో ఒక చిన్న వీడియో సమీక్ష కోసం పై చిత్రాన్ని క్లిక్ చేయండి.
ఇక్కడ మీరు వేరియటీపై సగటు ధర ఎలా ఆధారపడి ఉందో చూడవచ్చు: ఇక్కడ మీరు గమనించవచ్చు సరాసరి ధర వేరియటీలపై ఆధారపడి ఉంటుందని:
<img alt="Average price by variety" src="../../../../translated_images/te/price-by-variety.744a2f9925d9bcb4.webp" width="50%" /> <img alt="Average price by variety" src="../../../../translated_images/te/price-by-variety.744a2f9925d9bcb4.webp" width="50%" />
వేరియటీని పరిగణలోకి తీసుకోవడానికి, ముందుగా దాన్ని సంఖ్యాత్మక రూపంలోకి మార్చాలి, లేదా **ఎంకోడ్** చేయాలి. దీని కోసం కొన్ని మార్గాలు ఉన్నాయి: వేరియిటీని పరిగణించాలంటే, ముందుగా దాన్ని సంఖ్యాత్మక రూపంలోకి మార్చాలి, లేదా **ఎంకోడ్** చేయాలి. మనం దీన్ని చేయగల వివిధ మార్గాలు ఉన్నాయి:
* సాదా **సంఖ్యాత్మక ఎంకోడింగ్** వేరియటీల పట్టికను సృష్టించి, ఆ పట్టికలోని సూచికతో వేరియటీ పేరును మార్చుతుంది. ఇది లీనియర్ రిగ్రెషన్‌కు ఉత్తమ ఆలోచన కాదు, ఎందుకంటే లీనియర్ రిగ్రెషన్ సూచిక యొక్క అసలు సంఖ్యాత్మక విలువను తీసుకుని, దానిని కొంత సహగుణంతో గుణించి ఫలితానికి జోడిస్తుంది. మా సందర్భంలో, సూచిక సంఖ్య మరియు ధర మధ్య సంబంధం స్పష్టంగా నాన్-లీనియర్, ఎప్పటికైనా సూచికలు నిర్దిష్ట రీతిలో క్రమబద్ధీకరించినా కూడా. * సులభమైన **న్యూమరిక్ ఎంకోడింగ్** వేరియటీల పట్టిక తయారు చేసి, అప్పుడు వేరియటీ పేరును ఆ పట్టికలో ఉన్న సూచికతో మార్చుతుంది. ఇది లీనియర్ రిగ్రెషన్ కొరకు సరైన విధానం కాదు, ఎందుకంటే లీనియర్ రిగ్రెషన్ సూచిక యొక్క అసలు సంఖ్యాపరమైన విలువను తీసుకుని కొన్ని సహగుణాలతో బహుగుణింపజేస్తుంది. మన కేసులో, సూచిక సంఖ్య మరియు ధర మధ్య సంబంధం స్పష్టంగా లీనియర్ కానిది, చిత్తడుగా సూచికలు యథావిధిగా అమర్చినా కూడా.
* **వన్-హాట్ ఎంకోడింగ్** `Variety` కాలమ్‌ను 4 వేర్వేరు కాలమ్స్‌గా మార్చుతుంది, ఒక్కో వేరియటీకి ఒకటి. ప్రతి కాలమ్‌లో ఆ వరుస ఆ వేరియటీకి చెందినదైతే `1`, లేకపోతే `0` ఉంటుంది. అంటే లీనియర్ రిగ్రెషన్‌లో నాలుగు సహగుణాలు ఉంటాయి, ఒక్కో పంక్‌కిన్ వేరియటీకి ఒకటి, ఆ ప్రత్యేక వేరియటీకి "ప్రారంభ ధర" (లేదా "అదనపు ధర") బాధ్యత వహిస్తుంది. * **వన్-హాట్ ఎంకోడింగ్** `Variety` కాలమ్ ను 4 వేరువేరు కాలమ్స్ గా మార్చుతుంది, ఒక్కో వేరియటీ కి ఒకటి. ప్రతి కాలమ్ ఆ వరుస వేరియటీకి సరిపోతే `1`, కాకపోతే `0` ఉంటుంది. దీని అర్థం ఒక్కో గుమ్మడికాయ వేరియటే కోసం నాలుగు సహగుణాలు ఉంటాయి, అవి ఆ వేరియటీకి "ప్రారంభ ధర" (లేదా "అతిరిగిన ధర") ని సూచిస్తాయి.
క్రింది కోడ్ వన్-హాట్ ఎంకోడింగ్ ఎలా చేయాలో చూపిస్తుంది: కోడ్ క్రింద చూపుతుంది ఏ విధంగా వేరియటీని వన్-హాట్ ఎంకోడ్ చేయవచ్చో:
```python ```python
pd.get_dummies(new_pumpkins['Variety']) pd.get_dummies(new_pumpkins['Variety'])
@ -290,14 +303,14 @@ pd.get_dummies(new_pumpkins['Variety'])
1741 | 0 | 1 | 0 | 0 1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0 1742 | 0 | 1 | 0 | 0
వన్-హాట్ ఎంకోడెడ్ వేరియటీని ఇన్‌పుట్‌గా ఉపయోగించి లీనియర్ రిగ్రెషన్ ట్రెయిన్ చేయడానికి, మేము కేవలం `X` మరియు `y` డేటాను సరిగ్గా ప్రారంభించాలి: వన్-హాట్ ఎంకోడ్ చేసిన వేరియటీ వాడి లీనియర్ రిగ్రెషన్ ట్రెయిన్ చేసేందుకు, మనం కేవలం `X` మరియు `y` డేటాను సరిగ్గా ఇనిషియలైజ్ చేయాలి:
```python ```python
X = pd.get_dummies(new_pumpkins['Variety']) X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price'] y = new_pumpkins['Price']
``` ```
మిగతా కోడ్ మేము పైగా లీనియర్ రిగ్రెషన్ ట్రెయిన్ చేయడానికి ఉపయోగించినదే. మీరు ప్రయత్నిస్తే, సగటు చదరపు పొరపాటు సుమారు అదే ఉంటుంది, కానీ నిర్ణయ సహగుణం చాలా ఎక్కువగా ఉంటుంది (~77%). మరింత ఖచ్చితమైన అంచనాల కోసం, మేము మరిన్ని వర్గీకృత ఫీచర్లు మరియు సంఖ్యాత్మక ఫీచర్లు, ఉదాహరణకు `Month` లేదా `DayOfYear` కూడా పరిగణలోకి తీసుకోవచ్చు. ఒక పెద్ద ఫీచర్ అర్రే పొందడానికి, మేము `join` ఉపయోగించవచ్చు: మిగిలిన కోడ్ కూడా మనం లీనియర్ రిగ్రెషన్ ట్రెయిన్ చేసిన విధంగా అదే. మీరు ప్రయత్నిస్తే, మీకు దే ధాసిన మాత్రం సగటు వర్గంలో కూడటపు తప్పిదం (MSE) సుమారు అదే ఉంటుంది, కానీ determination coefficient 77% వరకు పెరుగుతుంది. ఇంకా ఖచ్చితమైన అంచనాలు పొందటానికి, మేము మరింత categorical ఫీచర్లు, మరియు సంఖ్యాపరమైన ఫీచర్లు, ఉదాహరణకు `Month` లేదా `DayOfYear` ను పరిగణించవచ్చు. మొత్తం ఫీచర్లను ఒక పెద్ద అర్రే గా చేయడానికి `join` ఉపయోగించవచ్చు:
```python ```python
X = pd.get_dummies(new_pumpkins['Variety']) \ X = pd.get_dummies(new_pumpkins['Variety']) \
@ -307,11 +320,11 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
y = new_pumpkins['Price'] y = new_pumpkins['Price']
``` ```
ఇక్కడ మేము `City` మరియు `Package` రకాలను కూడా పరిగణలోకి తీసుకుంటున్నాము, ఇది మాకు MSE 2.84 (10%) మరియు నిర్ణయ సహగుణం 0.94 ఇస్తుంది! ఇక్కడ మనం `City` మరియు `Package` రకాలు కూడా పరిగణనలోకి తీసుకుంటున్నాము, దీనివల్ల MSE 2.84 (10%) మరియు determination 0.94 అవుతుంది!
## అన్నింటినీ కలిపి ## అన్నిటిని కలిపితే
ఉత్తమ మోడల్ తయారుచేయడానికి, మేము పై ఉదాహరణలోని కలిపిన (వన్-హాట్ ఎంకోడెడ్ వర్గీకృత + సంఖ్యాత్మక) డేటాను పాలినోమియల్ రిగ్రెషన్‌తో కలిపి ఉపయోగించవచ్చు. మీ సౌకర్యానికి పూర్తి కోడ్ ఇక్కడ ఉంది: మంచి మోడల్ ను సృష్టించడానికి, మనం కాంబిన్డ్ (వన్-హాట్ ఎంకోడ్ చేసిన categorical + సంఖ్యాపరమైన) డేటాను పై ఉదాహరణ నుండి పోలినోమియల్ రిగ్రెషన్ తో కలిపి వాడవచ్చు. మీ సౌలభ్యం కోసం పూర్తి కోడ్ ఇక్కడ ఉంది:
```python ```python
# శిక్షణ డేటాను సెట్ చేయండి # శిక్షణ డేటాను సెట్ చేయండి
@ -321,17 +334,17 @@ X = pd.get_dummies(new_pumpkins['Variety']) \
.join(pd.get_dummies(new_pumpkins['Package'])) .join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price'] y = new_pumpkins['Price']
# శిక్షణ-పరీక్ష విభజన చేయండి # శిక్షణ-పరీక్ష విడగొట్టు చేయండి
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
# పైప్‌లైన్‌ను సెట్ చేసి శిక్షణ ఇవ్వండి # పైప్‌లైన్‌ను సెటప్ చేసి శిక్షణ ఇవ్వండి
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression()) pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train) pipeline.fit(X_train,y_train)
# పరీక్ష డేటాకు ఫలితాలను అంచనా వేయండి # పరీక్ష డేటా కోసం ఫలితాలు భవిష్యత్తు చెప్పండి
pred = pipeline.predict(X_test) pred = pipeline.predict(X_test)
# MSE మరియు నిర్ణయాన్ని లెక్కించండి # MSE మరియు నిర్ణయం గణించండి
mse = np.sqrt(mean_squared_error(y_test,pred)) mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)') print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
@ -339,36 +352,36 @@ score = pipeline.score(X_train,y_train)
print('Model determination: ', score) print('Model determination: ', score)
``` ```
ఇది సుమారు 97% నిర్ణయ సహగుణం మరియు MSE=2.23 (~8% అంచనా పొరపాటు) ఇస్తుంది. ఇది అత్యుత్తమ determination coefficient సుమారు 97% మరియు MSE=2.23 (~8% అంచనా తప్పు) ఇస్తుంది.
| మోడల్ | MSE | నిర్ణయ సహగుణం | | మోడల్ | MSE | Determination |
|-------|-----|---------------| |-------|-----|---------------|
| `DayOfYear` లీనియర్ | 2.77 (17.2%) | 0.07 | | `DayOfYear` లీనియర్ | 2.77 (17.2%) | 0.07 |
| `DayOfYear` పాలినోమియల్ | 2.73 (17.0%) | 0.08 | | `DayOfYear` పోలినోమియల్ | 2.73 (17.0%) | 0.08 |
| `Variety` లీనియర్ | 5.24 (19.7%) | 0.77 | | `Variety` లీనియర్ | 5.24 (19.7%) | 0.77 |
| అన్ని ఫీచర్లు లీనియర్ | 2.84 (10.5%) | 0.94 | | అన్ని ఫీచర్లు లీనియర్ | 2.84 (10.5%) | 0.94 |
| అన్ని ఫీచర్లు పాలినోమియల్ | 2.23 (8.25%) | 0.97 | | అన్ని ఫీచర్లు పోలినోమియల్ | 2.23 (8.25%) | 0.97 |
🏆 బాగుంది! మీరు ఒక పాఠంలో నాలుగు రిగ్రెషన్ మోడల్స్ సృష్టించి, మోడల్ నాణ్యతను 97%కి పెంచారు. రిగ్రెషన్ చివరి భాగంలో, మీరు వర్గాలను నిర్ణయించడానికి లాజిస్టిక్ రిగ్రెషన్ గురించి నేర్చుకుంటారు. 🏆 బాగుంది! మీరు ఒక పాఠంలో నాలుగు రిగ్రెషన్ మోడల్స్ సృష్టించి, మోడల్ నాణ్యతను 97% కావరకు మెరుగుపర్చారు. రిగ్రెషన్ యొక్క తుది భాగంలో, మీరు కేటగిరీలను నిర్ధారించేందుకు లాజిస్టిక్ రిగ్రెషన్ గురించి నేర్చుకుంటారు.
--- ---
## 🚀సవాలు ## 🚀సవాలు
ఈ నోట్‌బుక్‌లో వివిధ వేరియబుల్స్‌ను పరీక్షించి, సహసంబంధం మోడల్ ఖచ్చితత్వానికి ఎలా అనుగుణంగా ఉందో చూడండి. ఈ నోట్‌బుక్ లో వేర్వేరు వేరియబుల్స్ ను పరీక్షించి చూడండి, వాటి సహ సంబంధం మోడల్ ఖచ్చితత్వానికి ఎలా సంబంధించినదో చూడండి.
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/) ## [పోస్ట్-లెక్షర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం ## సమీక్ష & స్వీయ అధ్యయనం
ఈ పాఠంలో మేము లీనియర్ రిగ్రెషన్ గురించి నేర్చుకున్నాము. ఇతర ముఖ్యమైన రిగ్రెషన్ రకాలు కూడా ఉన్నాయి. స్టెప్వైజ్, రిడ్జ్, లాస్సో మరియు ఎలాస్టిక్‌నెట్ సాంకేతికతల గురించి చదవండి. మరింత నేర్చుకోవడానికి మంచి కోర్సు [స్టాన్‌ఫర్డ్ స్టాటిస్టికల్ లెర్నింగ్ కోర్సు](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning) ఈ పాఠంలో మనం లినియర్ రిగ్రెషన్ గురించి నేర్చుకున్నాం. మరిన్ని ముఖ్యమైన రిగ్రెషన్ రకాలు ఉన్నాయి. స్టెప్వైజ్, రిడ్జి, లాస్సో మరియు ఎలాస్టిక్‌నెట్ సాంకేతికతలను చదవండి. మరింత తెలుసుకోడానికి మంచి కోర్సు [స్టాన్‌ఫోర్డ్ స్టాటిస్టికల్ లెర్నింగ్ కోర్సు](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## అసైన్‌మెంట్ ## అసైన్‌మెంట్
[మోడల్ నిర్మించండి](assignment.md) [మోడల్ సృష్టించండి](assignment.md)
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**: **జాప్యం**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం మంచిది. ఈ అనువాదం వలన కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల బాధ్యత మేము తీసుకోము. ఈ పత్రం AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నిస్తున్నప్పటికీ, ఆటోమేటెడ్ అనువాదాలలో లోపాలు లేదా తప్పిదాలు ఉండొచ్చు. మੂల పత్రం దాని స్వదేశి భాషలో అధికారిక మూలం గా పరిగణించాలి. ముఖ్య సమాచారం కోసం వృత్తిపరమైన మానవ అనువాదం సూచించబడుతుంది. ఈ అనువాదం ఉపయోగించే కారణంగా ఏర్పడే ఏదైనా తప్పుదోవ లేదా దుర్వినియోగం కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

94
translations/te/4-Classification/3-Classifiers-2/README.md
Unescape View File

@ -1,42 +1,42 @@
# వంటక వర్గీకరణలు 2 # వంటకాల వర్గీకరణ 2
ఈ రెండవ వర్గీకరణ పాఠంలో, మీరు సంఖ్యాత్మక డేటాను వర్గీకరించడానికి మరిన్ని మార్గాలను అన్వేషిస్తారు. మీరు ఒక వర్గీకర్తను మరొకదానితో పోల్చినప్పుడు కలిగే ప్రభావాల గురించి కూడా తెలుసుకుంటారు. ఈ రెండవ వర్గీకరణ పాఠంలో, మీరు సంఖ్యాత్మక డేటాను వర్గీకరించేందుకు మరిన్ని మార్గాలను అధ్యయనం చేస్తారు. మీరు ఒక వర్గీకర్తని మరొకదానికి భిన్నంగా ఎంచుకునే ఫలితాల గురించి కూడా తెలుసుకుంటారు.
## [పాఠం ముందు క్విజ్](https://ff-quizzes.netlify.app/en/ml/) ## [పాఠం ముందు క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
### ముందస్తు అర్హత ### ముందస్తు అర్హత
ముందటి పాఠాలు మీరు పూర్తి చేశారని మరియు మీ `data` ఫోల్డర్‌లో _cleaned_cuisines.csv_ అనే శుభ్రపరిచిన డేటాసెట్ ఉందని మేము అనుకుంటున్నాము, ఇది ఈ 4-పాఠాల ఫోల్డర్ యొక్క రూట్‌లో ఉంది. మీరు గత పాఠాలను పూర్తి చేసి, ఈ 4-పాఠాల ఫోల్డర్ రూట్‌లోని `data` ఫోల్డర్‌లో _cleaned_cuisines.csv_ అనే శుభ్రపరిచిన డేటాసెట్ ఉందని మేము భావిస్తాము.
### సిద్ధం ### సిద్ధత
మేము మీ _notebook.ipynb_ ఫైల్‌లో శుభ్రపరిచిన డేటాసెట్‌ను లోడ్ చేసి, మోడల్ నిర్మాణ ప్రక్రియ కోసం X మరియు y డేటాఫ్రేమ్‌లుగా విభజించాము. మేము మీ _notebook.ipynb_ ఫైల్‌లో శుభ్రపరిచిన డేటాను లోడ్ చేసి, మోడల్ నిర్మాణ ప్రక్రియకి సిద్ధంగా X మరియు y డేటాఫ్రేమ్‌లుగా విభజించాం.
## ఒక వర్గీకరణ మ్యాప్ ## ఒక వర్గీకరణ మ్యాప్
ముందుగా, మీరు మైక్రోసాఫ్ట్ యొక్క చీట్ షీట్ ఉపయోగించి డేటాను వర్గీకరించేటప్పుడు మీకు ఉన్న వివిధ ఎంపికల గురించి తెలుసుకున్నారు. Scikit-learn ఒక సమానమైన, కానీ మరింత సూక్ష్మమైన చీట్ షీట్ అందిస్తుంది, ఇది మీ అంచనాదారులను (ఇంకో పేరు వర్గీకర్తలు) మరింత సన్నిహితంగా తగ్గించడంలో సహాయపడుతుంది: మునుపటి పాఠంలో మీరు మైక్రోసాఫ్ట్ యొక్క చీట్ షీట్ ఉపయోగించి డేటాను వర్గీకరించేటప్పుడు అనేక ఎంపికలు తెలుసుకున్నారు. Scikit-learn మరింత సూటిగా మరియు విస్తృతంగా సహాయం చేసే చీట్ షీట్‌ను అందిస్తుంది, ఇది మీ అంచనాకర్తలను (ఇంకా వర్గీకర్తలు అని పిలవబడే) మరింత కుదించడంలో సహాయం చేస్తుంది:
![ML Map from Scikit-learn](../../../../translated_images/te/map.e963a6a51349425a.webp) ![ML Map from Scikit-learn](../../../../translated_images/te/map.e963a6a51349425a.webp)
> సూచన: [ఈ మ్యాప్‌ను ఆన్‌లైన్‌లో సందర్శించండి](https://scikit-learn.org/stable/tutorial/machine_learning_map/) మరియు దారిలో క్లిక్ చేసి డాక్యుమెంటేషన్ చదవండి. > సూచన: [ఈ మ్యాప్‌ను ఆన్లైన్‌లో సందర్శించండి](https://scikit-learn.org/stable/tutorial/machine_learning_map/) మరియు దారిని క్లిక్ చేసి డాక్యుమెంటేషన్ చదవండి.
### ప్రణాళిక ### ప్రణాళిక
మీ డేటాను స్పష్టంగా అర్థం చేసుకున్న తర్వాత ఈ మ్యాప్ చాలా సహాయకారి, ఎందుకంటే మీరు దాని మార్గాలను అనుసరించి నిర్ణయం తీసుకోవచ్చు: ఈ మ్యాప్ మీ డేటాను స్పష్టంగా అర్థం చేసుకున్న తర్వాత చాలా ఉపయోగకరం, ఎందుకంటే మీరు దాని దారులను 'నడవచ్చు' మరియు నిర్ణయం తీసుకోవచ్చు:
- మాకు >50 నమూనాలు ఉన్నాయి - మాకు 50కి పైగా నమూనాలు ఉన్నాయి
- మేము ఒక వర్గాన్ని అంచనా వేయాలనుకుంటున్నాము - మేము ఒక వర్గాన్ని అంచనా వేయాలి
- మాకు లేబుల్ చేయబడిన డేటా ఉంది - మాకు లేబుల్ చేయబడిన డేటా ఉంది
- మాకు 100K కన్నా తక్కువ నమూనాలు ఉన్నాయి - మాకు 100K కన్నా తక్కువ నమూనాలు ఉన్నాయి
- ✨ మేము లీనియర్ SVC ఎంచుకోవచ్చు - ✨ మేము లీనియర్ SVC ని ఎంచుకోవచ్చు
- అది పనిచేయకపోతే, ఎందుకంటే మాకు సంఖ్యాత్మక డేటా ఉంది - అది పనిచేయకపోతే, సంఖ్యాత్మక డేటా ఉందాకాక మరి
- మేము ✨ KNeighbors Classifier ప్రయత్నించవచ్చు - మేము ✨ KNeighbors వర్గీకర్త ప్రయత్నించవచ్చు
- అది పనిచేయకపోతే, ✨ SVC మరియు ✨ Ensemble Classifiers ప్రయత్నించండి - అది పనిచేయకపోతే, ✨ SVC మరియు ✨ ఎంసెంబుల్ వర్గీకర్తలను ప్రయత్నించండి
ఇది అనుసరించడానికి చాలా సహాయకారి మార్గం. ఇది అనుసరించడానికి చాలా ఉపయోగకరమైన ట్రైల్.
## వ్యాయామం - డేటాను విభజించండి ## వ్యాయామం - డేటాను విభజించండి
ఈ మార్గాన్ని అనుసరించి, మేము ఉపయోగించడానికి కొన్ని లైబ్రరీలను దిగుమతి చేసుకోవడం ప్రారంభించాలి. ఈ దారిని అనుసరించి, కొన్ని లైబ్రరీలను దిగుమతి చేయడం మొదలుపెట్టాలి.
1. అవసరమైన లైబ్రరీలను దిగుమతి చేసుకోండి: 1. అవసరమైన లైబ్రరీలను దిగుమతి చేసుకోండి:
@ -53,28 +53,28 @@
1. మీ శిక్షణ మరియు పరీక్ష డేటాను విభజించండి: 1. మీ శిక్షణ మరియు పరీక్ష డేటాను విభజించండి:
```python ```python
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3) X_train, X_test, y_train, y_test = train_test_split(cuisines_features_df, cuisines_label_df, test_size=0.3)
``` ```
## లీనియర్ SVC వర్గీకర్త ## లీనియర్ SVC వర్గీకర్త
సపోర్ట్-వెక్టర్ క్లస్టరింగ్ (SVC) అనేది సపోర్ట్-వెక్టర్ మెషీన్ల కుటుంబానికి చెందిన ML సాంకేతికత (ఇంకా తెలుసుకోండి). ఈ పద్ధతిలో, మీరు లేబుల్స్‌ను ఎలా క్లస్టర్ చేయాలో నిర్ణయించడానికి 'కర్నెల్'ను ఎంచుకోవచ్చు. 'C' పారామీటర్ 'రెగ్యులరైజేషన్'కి సంబంధించినది, ఇది పారామీటర్ల ప్రభావాన్ని నియంత్రిస్తుంది. కర్నెల్ అనేది [చాలా](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC) రకాలలో ఒకటి; ఇక్కడ మేము లీనియర్ SVC ఉపయోగించడానికి 'linear' గా సెట్ చేసాము. Probability డిఫాల్ట్‌గా 'false'; ఇక్కడ probability అంచనాలు సేకరించడానికి 'true' గా సెట్ చేసాము. డేటాను షఫుల్ చేయడానికి మరియు probability లను పొందడానికి రాండమ్ స్టేట్‌ను '0' గా సెట్ చేసాము. సపోర్ట్-వెక్టర్ క్లస్టరింగ్ (SVC) అనేది SVM పద్ధతుల కుటుంబానికి చెందినది (ఇవి గురించి దిగువ తెలుసుకోండి). ఈ పద్ధతిలో, మీరు లేబుళ్లను ఎలా క్లస్టర్ చేయాలో నిర్ణయించేందుకు 'కెర్నెల్'ను ఎంచుకోవచ్చు. 'C' పరామితి అనేది 'రెగ్యులరైజేషన్'కి సంబంధించినది, ఇది ప్రామాణాలను నియంత్రిస్తుంది. కెర్నెల్ [బహువిధాలుగా](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC) ఉండవచ్చు; ఇక్కడ లీనియర్ SVC కోసం 'linear' గా సెట్ చేసాం. ప్రాబబిలిటీ డిఫాల్ట్‌గా 'false'; ఇక్కడ probability estimates సేకరించేందుకు 'true' గా సెట్ చేసాం. రాండమ్ స్టేట్ 0 ప్లేస్ చేసి డేటాను షఫుల్ చేసి ప్రాబబిలిటీలను పొందుతాము.
### వ్యాయామం - లీనియర్ SVC వర్తించండి ### వ్యాయామం - లీనియర్ SVC ఉపయోగించండి
వర్గీకర్తల అర్రేను సృష్టించడం ప్రారంభించండి. పరీక్షల సమయంలో మీరు ఈ అర్రేకు క్రమంగా జోడిస్తారు. వర్గీకర్తాల సరసన ఒక అర్రే తయారు చేయడం మొదలుపెట్టండి. పరీక్షలతో క్రమంగా దీన్ని పెంచుతారు.
1. లీనియర్ SVC తో ప్రారంభించండి: 1. లీనియర్ SVC తో ప్రారంభించండి:
```python ```python
C = 10 C = 10
# వేర్వేరు వర్గీకరణలను సృష్టించండి. # వివిధ వర్గీకర్తలను సృష్టించండి.
classifiers = { classifiers = {
'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0) 'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
} }
``` ```
2. లీనియర్ SVC ఉపయోగించి మీ మోడల్‌ను శిక్షణ ఇవ్వండి మరియు నివేదికను ప్రింట్ చేయండి: 2. లీనియర్ SVC ఉపయోగించి మీ మోడల్‌ను శిక్షించండి మరియు రిపోర్ట్ ప్రింట్ చేయండి:
```python ```python
n_classifiers = len(classifiers) n_classifiers = len(classifiers)
@ -88,7 +88,7 @@
print(classification_report(y_test,y_pred)) print(classification_report(y_test,y_pred))
``` ```
ఫలితం చాలా బాగుంది: ఫలితం బాగుంది:
```output ```output
Accuracy (train) for Linear SVC: 78.6% Accuracy (train) for Linear SVC: 78.6%
@ -105,21 +105,21 @@
weighted avg 0.79 0.79 0.79 1199 weighted avg 0.79 0.79 0.79 1199
``` ```
## K-నెయిబర్స్ వర్గీకర్త ## K-Neighbors వర్గీకర్త
K-నెయిబర్స్ అనేది "నెయిబర్స్" కుటుంబానికి చెందిన ML పద్ధతి, ఇది పర్యవేక్షిత మరియు పర్యవేక్షణలేని రెండింటికీ ఉపయోగించవచ్చు. ఈ పద్ధతిలో, ముందుగా నిర్దేశించిన సంఖ్యలో పాయింట్లు సృష్టించబడతాయి మరియు డేటా ఈ పాయింట్ల చుట్టూ సేకరించబడుతుంది, తద్వారా సాధారణీకృత లేబుల్స్‌ను అంచనా వేయవచ్చు. K-Neighbors అనేది "నైబర్స్" కుటుంబంలోని ML పద్ధతికి చెందినది, ఇది పర్యవేక్షిత మరియు అపర్యవేక్షిత రెండింటి కోసం ఉపయోగించవచ్చు. ఈ పద్ధతిలో, ముందుగా నిర్దేశించిన కొంత పాయింట్లు సృష్టించి, ఆ పాయింట్ల చుట్టూ డేటా సేకరించి, సాధారణీకరించిన లేబుళ్లను అంచనా వేయడం జరుగుతుంది.
### వ్యాయామం - K-నెయిబర్స్ వర్గీకర్తను వర్తించండి ### వ్యాయామం - K-Neighbors వర్గీకర్త ఉపయోగించండి
ముందటి వర్గీకర్త బాగుంది మరియు డేటాతో బాగా పనిచేసింది, కానీ మేము మెరుగైన ఖచ్చితత్వం పొందవచ్చని అనుకుంటున్నాము. K-నెయిబర్స్ వర్గీకర్తను ప్రయత్నించండి. గత వర్గీకర్త బాగుంది, డేటాతో బాగా పని చేసింది, కానీ బెటర్ ఖచ్చితత్వం రావచ్చు. మీరు K-Neighbors వర్గీకర్తను ప్రయత్నించండి.
1. మీ వర్గీకర్త అర్రేలో ఒక లైన్ జోడించండి (లీనియర్ SVC అంశం తర్వాత కామా జోడించండి): 1. మీరు వర్గీకర్తల అర్రేలో ఒక లైన్ జోడించండి (లీనియర్ SVC తర్వాత కామా పెట్టండి):
```python ```python
'KNN classifier': KNeighborsClassifier(C), 'KNN classifier': KNeighborsClassifier(C),
``` ```
ఫలితం కొంచెం తక్కువగా ఉంది: ఫలితం కొంతే వరలుతుంది:
```output ```output
Accuracy (train) for KNN classifier: 73.8% Accuracy (train) for KNN classifier: 73.8%
@ -136,17 +136,17 @@ K-నెయిబర్స్ అనేది "నెయిబర్స్" క
weighted avg 0.76 0.74 0.74 1199 weighted avg 0.76 0.74 0.74 1199
``` ```
✅ [K-నెయిబర్స్ గురించి తెలుసుకోండి](https://scikit-learn.org/stable/modules/neighbors.html#neighbors) ✅ [K-Neighbors గురించి నేర్చుకోండి](https://scikit-learn.org/stable/modules/neighbors.html#neighbors)
## సపోర్ట్ వెక్టర్ వర్గీకర్త ## సపోర్ట్ వెక్టర్ వర్గీకర్త
సపోర్ట్-వెక్టర్ వర్గీకర్తలు [సపోర్ట్-వెక్టర్ మెషీన్](https://wikipedia.org/wiki/Support-vector_machine) కుటుంబానికి చెందిన ML పద్ధతులు, ఇవి వర్గీకరణ మరియు రిగ్రెషన్ పనుల కోసం ఉపయోగిస్తారు. SVMలు "శిక్షణ ఉదాహరణలను స్థలంలో పాయింట్లుగా మ్యాప్ చేస్తాయి" రెండు వర్గాల మధ్య దూరాన్ని గరిష్టం చేయడానికి. తరువాతి డేటాను ఈ స్థలంలో మ్యాప్ చేసి వారి వర్గాన్ని అంచనా వేస్తారు. సపోర్ట్-వెక్టర్ వర్గీకర్తలు [సపోర్ట్-వెక్టర్ మిషన్](https://wikipedia.org/wiki/Support-vector_machine) కుటుంబానికి చెందిన ML పద్ధతులు, ఇవి వర్గీకరణ మరియు రేగ్రెషన్ పనుల కోసం ఉపయోగిస్తారు. SVMలు "శిక్షణ ఉదాహరణలను స్థలాలలో పాయింట్లుగా మ్యాప్" చేసి రెండు వర్గాల మధ్య దూరాన్ని గరిష్టం చేస్తాయి. తదుపరి డేటాను ఈ స్థలంలో మ్యాప్ చేసి వారి వర్గం అంచనా వేయబడుతుంది.
### వ్యాయామం - సపోర్ట్ వెక్టర్ వర్గీకర్తను వర్తించండి ### వ్యాయామం - సపోర్ట్ వెక్టర్ వర్గీకర్త అన్వయించండి
కొంచెం మెరుగైన ఖచ్చితత్వం కోసం సపోర్ట్ వెక్టర్ వర్గీకర్తను ప్రయత్నిద్దాం. మంచి ఖచ్చితత్వానికి సపోర్ట్ వెక్టర్ వర్గీకర్త ప్రయత్నిద్దాం.
1. K-నెయిబర్స్ అంశం తర్వాత కామా జోడించి, ఈ లైన్ జోడించండి: 1. K-Neighbors తర్వాత కామా పెట్టి, ఈ లైన్ జోడించండి:
```python ```python
'SVC': SVC(), 'SVC': SVC(),
@ -169,11 +169,11 @@ K-నెయిబర్స్ అనేది "నెయిబర్స్" క
weighted avg 0.84 0.83 0.83 1199 weighted avg 0.84 0.83 0.83 1199
``` ```
✅ [సపోర్ట్-వెక్టర్స్ గురించి తెలుసుకోండి](https://scikit-learn.org/stable/modules/svm.html#svm) ✅ [సపోర్ట్-వెక్టర్లు గురించి తెలుసుకోండి](https://scikit-learn.org/stable/modules/svm.html#svm)
## ఎన్‌సెంబుల్ వర్గీకర్తలు ## ఎంసెంబుల్ వర్గీకర్తలు
ముందటి పరీక్ష చాలా బాగుండగా కూడా, చివరి వరకు ఈ మార్గాన్ని అనుసరించుకుందాం. కొన్ని 'ఎన్‌సెంబుల్ వర్గీకర్తలు', ముఖ్యంగా రాండమ్ ఫారెస్ట్ మరియు అడాబూస్ట్ ప్రయత్నిద్దాం: మునుపటి పరీక్ష బాగుంది కానీ చివరకు ప్రయోగం ముగించడానికి ‘ఎంసెంబుల్ వర్గీకర్తలు’, ముఖ్యంగా రాండమ్ ఫారెస్ట్ మరియు AdaBoost ప్రయత్నిద్దాం:
```python ```python
'RFST': RandomForestClassifier(n_estimators=100), 'RFST': RandomForestClassifier(n_estimators=100),
@ -210,33 +210,33 @@ Accuracy (train) for ADA: 72.4%
weighted avg 0.73 0.72 0.72 1199 weighted avg 0.73 0.72 0.72 1199
``` ```
✅ [ఎన్‌సెంబుల్ వర్గీకర్తల గురించి తెలుసుకోండి](https://scikit-learn.org/stable/modules/ensemble.html) ✅ [ఎంసెంబుల్ వర్గీకర్తల గురించి తెలుసుకోండి](https://scikit-learn.org/stable/modules/ensemble.html)
ఈ మెషీన్ లెర్నింగ్ పద్ధతి "చాలా బేస్ అంచనాదారుల అంచనాలను కలిపి" మోడల్ నాణ్యతను మెరుగుపరుస్తుంది. మా ఉదాహరణలో, మేము రాండమ్ ట్రీలు మరియు అడాబూస్ట్ ఉపయోగించాము. ఈ యంత్ర అభ్యాస పద్ధతి "చాలా బేస్ అంచనాలు కలిపి" మోడల్ నాణ్యతను మెరుగుపరుస్తుంది. ఉదాహరణకు, మనం రాండమ్ ట్రీ మరియు AdaBoost ఉపయోగించాము.
- [రాండమ్ ఫారెస్ట్](https://scikit-learn.org/stable/modules/ensemble.html#forest), ఒక సగటు పద్ధతి, 'డిసిషన్ ట్రీల' 'ఫారెస్ట్'ను నిర్మిస్తుంది, ఇది ఓవర్‌ఫిట్టింగ్ నివారించడానికి యాదృచ్ఛికతతో నింపబడింది. n_estimators పారామీటర్ ట్రీల సంఖ్యకు సెట్ చేయబడింది. - [రాండమ్ ఫారెస్ట్](https://scikit-learn.org/stable/modules/ensemble.html#forest), అవరేజ్ పద్ధతి, ఒవర్‌ఫిటింగ్ నివారించేందుకు యాదృచ్ఛికతతో 'దిశ trees' 'అరణ్యాన్ని' నిర్మిస్తుంది. n_estimators పరామితి ట్రీల సంఖ్యకు సెట్ చేయబడుతుంది.
- [అడాబూస్ట్](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ఒక వర్గీకర్తను డేటాసెట్‌కు సరిపోల్చి, ఆ వర్గీకర్త యొక్క కాపీలను అదే డేటాసెట్‌కు సరిపోల్చుతుంది. ఇది తప్పుగా వర్గీకరించిన అంశాల బరువులపై దృష్టి సారించి, తదుపరి వర్గీకర్త సరిపోల్చడాన్ని సరిచేస్తుంది. - [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ఒక వర్గీకర్తను డేటాసెట్‌కు పొందించి, ఆ వర్గీకర్త ప్రతులు అదే డేటాసెట్‌కు సరిపడతాయి. ఇది తప్పుగా వర్గీకరించిన అంశాల బరువులపై దృష్టిసారించి తదుపరి వర్గీకర్త కోసం సరిపడేలా సర్దుబాటు చేస్తుంది.
--- ---
## 🚀సవాలు ## 🚀సవాలు
ఈ ప్రతి సాంకేతికతకు మీరు సర్దుబాటు చేయగల పెద్ద సంఖ్యలో పారామీటర్లు ఉన్నాయి. ప్రతి ఒకటి యొక్క డిఫాల్ట్ పారామీటర్లను పరిశోధించి, ఈ పారామీటర్ల సర్దుబాటు మోడల్ నాణ్యతకు ఏమి అర్థం అవుతుందో ఆలోచించండి. ఈ ప్రతి పద్ధతికి అనేక పరామితులు ఉంటాయి వీటిని మీరు సవరించవచ్చు. ప్రతి ఒకటి యొక్క డిఫాల్ట్ పరామితుల్ని పరిశోధించి, ఆ పరామితులు సవరించడం మోడల్ నాణ్యతకి ఏమి ప్రభావం చూపుతుందో ఆలోచించండి.
## [పాఠం తర్వాత క్విజ్](https://ff-quizzes.netlify.app/en/ml/) ## [పాఠం తరువాత క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం ## సమీక్ష & స్వీయ అధ్యయనం
ఈ పాఠాలలో చాలా జార్గన్ ఉంది, కాబట్టి [ఈ జాబితా](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) ఉపయోగకరమైన పదజాలాన్ని సమీక్షించడానికి ఒక నిమిషం తీసుకోండి! ఈ పాఠాల్లో చాలా టెక్నికల్ పదాలు ఉన్నాయి, కాబట్టి ఉపయోగకరమైన టర్మినాలజీ [ఈ జాబితా](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) ను ఒక నిమిషం సమీక్షించండి!
## అసైన్‌మెంట్ ## అసైన్‌మెంట్
[పారామీటర్ ప్లే](assignment.md) [పరామితుల ఆట](assignment.md)
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**: **అస్పష్టం**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము. ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించాం. మేము సరిగా ఉన్నదానికి ప్రయత్నిస్తామైనప్పటికీ, స్వయంచాలక అనువాదాల్లో తప్పులు లేదా లోపాలు ఉండవచ్చు. మౌలిక పత్రం దాని స్థానిక భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, నిపుణుల చేతిలో మానవ అనువాదం అవసరం. ఈ అనువాదాన్ని ఉపయోగించి ఏర్పడిన ఏవైనా తప్పుగా అర్థం చేసుకోవడం లేదా పాక్షిక ఆవగాహనలకి మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->

14
translations/te/4-Classification/3-Classifiers-2/notebook.ipynb
Unescape View File

@ -4,7 +4,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"# వర్గీకరణ మోడల్ నిర్మించండి\n" "# వర్గీకరణ నమూనా నిర్మాణం\n"
] ]
}, },
{ {
@ -116,15 +116,15 @@
} }
], ],
"source": [ "source": [
"cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n", "cuisines_features_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n",
"cuisines_feature_df.head()" "cuisines_features_df.head()"
] ]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**అస్పష్టత**: \nఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n" "---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**అస్పష్టత**: \nఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించాం. సరైనత కొరకు ప్రయత్నిస్తున్నప్పటికీ, ఆపొమేటెడ్ అనువాదాలలో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు అని దయచేసి గమనించండి. మూల పత్రం ఆ స్థానిక భాషలో ప్రామాణిక మూలంగా పరిగణించబడాలి. కీలక సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదాన్ని సిఫారసు చేస్తాం. ఈ అనువాదం వాడకపు కారణంగా కలగగలిగే అవగాహన లోపాలు లేదా தவరోజులకి మేము బాధ్యులు కాదు.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
] ]
} }
], ],
@ -152,12 +152,6 @@
"interpreter": { "interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d" "hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
} }
},
"coopTranslator": {
"original_hash": "15a83277036572e0773229b5f21c1e12",
"translation_date": "2025-12-19T17:02:44+00:00",
"source_file": "4-Classification/3-Classifiers-2/notebook.ipynb",
"language_code": "te"
} }
}, },
"nbformat": 4, "nbformat": 4,

18
translations/te/4-Classification/3-Classifiers-2/solution/notebook.ipynb
Unescape View File

@ -2,7 +2,7 @@
"cells": [ "cells": [
{ {
"source": [ "source": [
"# మరిన్ని వర్గీకరణ మోడల్స్ నిర్మించండి\n" "# మరిన్ని వర్గీకరణ నమూనాలను నిర్మించండి\n"
], ],
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {} "metadata": {}
@ -116,15 +116,15 @@
} }
], ],
"source": [ "source": [
"cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n", "cuisines_features_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n",
"cuisines_feature_df.head()" "cuisines_features_df.head()"
] ]
}, },
{ {
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"# వేరే వేరే వర్గీకరణలను ప్రయత్నించండి\n" "# వేరువేరు వర్గీకరణకర్తలను ప్రయత్నించండి\n"
] ]
}, },
{ {
@ -148,7 +148,7 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)" "X_train, X_test, y_train, y_test = train_test_split(cuisines_features_df, cuisines_label_df, test_size=0.3)"
] ]
}, },
{ {
@ -263,7 +263,7 @@
"cell_type": "markdown", "cell_type": "markdown",
"metadata": {}, "metadata": {},
"source": [ "source": [
"---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**అస్పష్టత**: \nఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n" "---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**అసూయాపూర్వక మంజూరు**:\nఈ పత్రం AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడినది. మనం ఖచ్చితత్వానికి శ్రమించినప్పటికీ, స్వయంచాలక అనువాదాల్లో తప్పులు లేదా అసత్యతలు ఉండొచ్చు అని దయచేసి గమనించండి. ప్రముఖ భాషలో ఉన్న అసలు పత్రాన్ని అధికారిక మూలంగా పరిగణించాలి. కీలక సమాచారానికి, నిపుణుల చేతి అనువాదం సూచించబడుతుంది. ఈ అనువాదం వాడకంలో జరిగిన ఏవైనా అపవాచనలు లేదా దుష్ప్రతిపత్తుల కోసం మేము బాధ్యతారహితులు.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
] ]
} }
], ],
@ -291,12 +291,6 @@
"interpreter": { "interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d" "hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
} }
},
"coopTranslator": {
"original_hash": "7ea2b714669c823a596d986ba2d5739f",
"translation_date": "2025-12-19T17:09:02+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/notebook.ipynb",
"language_code": "te"
} }
}, },
"nbformat": 4, "nbformat": 4,

201
translations/te/README.md
Unescape View File

@ -10,160 +10,170 @@
### 🌐 బహుభాషా మద్దతు ### 🌐 బహుభాషా మద్దతు
#### GitHub చర్య ద్వారా మద్దతు (స్వయంచాలక మరియు ఎప్పుడూ తాజాకరణ) #### GitHub యాక్షన్ ద్వారా మద్దతు (ఆటోమేటెడ్ & ఎప్పుడూ తాజా)
<!-- CO-OP TRANSLATOR LANGUAGES TABLE START --> <!-- CO-OP TRANSLATOR LANGUAGES TABLE START -->
[Arabic](../ar/README.md) | [Bengali](../bn/README.md) | [Bulgarian](../bg/README.md) | [Burmese (Myanmar)](../my/README.md) | [Chinese (Simplified)](../zh-CN/README.md) | [Chinese (Traditional, Hong Kong)](../zh-HK/README.md) | [Chinese (Traditional, Macau)](../zh-MO/README.md) | [Chinese (Traditional, Taiwan)](../zh-TW/README.md) | [Croatian](../hr/README.md) | [Czech](../cs/README.md) | [Danish](../da/README.md) | [Dutch](../nl/README.md) | [Estonian](../et/README.md) | [Finnish](../fi/README.md) | [French](../fr/README.md) | [German](../de/README.md) | [Greek](../el/README.md) | [Hebrew](../he/README.md) | [Hindi](../hi/README.md) | [Hungarian](../hu/README.md) | [Indonesian](../id/README.md) | [Italian](../it/README.md) | [Japanese](../ja/README.md) | [Kannada](../kn/README.md) | [Korean](../ko/README.md) | [Lithuanian](../lt/README.md) | [Malay](../ms/README.md) | [Malayalam](../ml/README.md) | [Marathi](../mr/README.md) | [Nepali](../ne/README.md) | [Nigerian Pidgin](../pcm/README.md) | [Norwegian](../no/README.md) | [Persian (Farsi)](../fa/README.md) | [Polish](../pl/README.md) | [Portuguese (Brazil)](../pt-BR/README.md) | [Portuguese (Portugal)](../pt-PT/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Romanian](../ro/README.md) | [Russian](../ru/README.md) | [Serbian (Cyrillic)](../sr/README.md) | [Slovak](../sk/README.md) | [Slovenian](../sl/README.md) | [Spanish](../es/README.md) | [Swahili](../sw/README.md) | [Swedish](../sv/README.md) | [Tagalog (Filipino)](../tl/README.md) | [Tamil](../ta/README.md) | [Telugu](./README.md) | [Thai](../th/README.md) | [Turkish](../tr/README.md) | [Ukrainian](../uk/README.md) | [Urdu](../ur/README.md) | [Vietnamese](../vi/README.md) [Arabic](../ar/README.md) | [Bengali](../bn/README.md) | [Bulgarian](../bg/README.md) | [Burmese (Myanmar)](../my/README.md) | [Chinese (Simplified)](../zh-CN/README.md) | [Chinese (Traditional, Hong Kong)](../zh-HK/README.md) | [Chinese (Traditional, Macau)](../zh-MO/README.md) | [Chinese (Traditional, Taiwan)](../zh-TW/README.md) | [Croatian](../hr/README.md) | [Czech](../cs/README.md) | [Danish](../da/README.md) | [Dutch](../nl/README.md) | [Estonian](../et/README.md) | [Finnish](../fi/README.md) | [French](../fr/README.md) | [German](../de/README.md) | [Greek](../el/README.md) | [Hebrew](../he/README.md) | [Hindi](../hi/README.md) | [Hungarian](../hu/README.md) | [Indonesian](../id/README.md) | [Italian](../it/README.md) | [Japanese](../ja/README.md) | [Kannada](../kn/README.md) | [Korean](../ko/README.md) | [Lithuanian](../lt/README.md) | [Malay](../ms/README.md) | [Malayalam](../ml/README.md) | [Marathi](../mr/README.md) | [Nepali](../ne/README.md) | [Nigerian Pidgin](../pcm/README.md) | [Norwegian](../no/README.md) | [Persian (Farsi)](../fa/README.md) | [Polish](../pl/README.md) | [Portuguese (Brazil)](../pt-BR/README.md) | [Portuguese (Portugal)](../pt-PT/README.md) | [Punjabi (Gurmukhi)](../pa/README.md) | [Romanian](../ro/README.md) | [Russian](../ru/README.md) | [Serbian (Cyrillic)](../sr/README.md) | [Slovak](../sk/README.md) | [Slovenian](../sl/README.md) | [Spanish](../es/README.md) | [Swahili](../sw/README.md) | [Swedish](../sv/README.md) | [Tagalog (Filipino)](../tl/README.md) | [Tamil](../ta/README.md) | [Telugu](./README.md) | [Thai](../th/README.md) | [Turkish](../tr/README.md) | [Ukrainian](../uk/README.md) | [Urdu](../ur/README.md) | [Vietnamese](../vi/README.md)
> **స్థానికంగా క్లోన్ చేయడం ఇష్టం?** > **స్థానికంగా క్లోన్ చేయాలనుకుంటున్నారా?**
>
> ఈ రిపోజిటరీ 50+ భాషా అనువాదాలను కలిగి ఉంది, ఇది డౌన్లోడ్ పరిమాణాన్ని ప్రముఖంగా పెంచుతుంది. అనువాదాలు లేకుండా క్లోన్ చేయడానికి, స్పార్స్ చెక్అవుట్ ఉపయోగించండి: > ఈ రిపోసిటరీలో 50+ భాషా అనువాదాలు ఉన్నాయి, ఇవి డౌన్లోడ్ పరిమాణాన్ని గణనీయంగా పెంచుతాయి. అనువాదాలు లేకుండా క్లోన్ చేసుకోవడానికి, స్పార్స్ చెకౌట్ ఉపయోగించండి:
>
> **Bash / macOS / Linux:**
> ```bash > ```bash
> git clone --filter=blob:none --sparse https://github.com/microsoft/ML-For-Beginners.git > git clone --filter=blob:none --sparse https://github.com/microsoft/ML-For-Beginners.git
> cd ML-For-Beginners > cd ML-For-Beginners
> git sparse-checkout set --no-cone '/*' '!translations' '!translated_images' > git sparse-checkout set --no-cone '/*' '!translations' '!translated_images'
> ``` > ```
> ఇది కోర్సును పూర్తిచేయడానికి కావలసిన అన్ని వస్తువులను చాలా వేగంగా డౌన్లోడ్ చేసే అవకాశాన్ని ఇస్తుంది. >
> **CMD (Windows):**
> ```cmd
> git clone --filter=blob:none --sparse https://github.com/microsoft/ML-For-Beginners.git
> cd ML-For-Beginners
> git sparse-checkout set --no-cone "/*" "!translations" "!translated_images"
> ```
>
> ఈ విధంగా మీరు కోర్సును పూర్తి చేయడానికి అవసరమైన అన్నింటినీ తక్షణంగా పొందవచ్చు.
<!-- CO-OP TRANSLATOR LANGUAGES TABLE END --> <!-- CO-OP TRANSLATOR LANGUAGES TABLE END -->
#### మా సమూహంలో చేరండి #### మా కమ్యూనిటీతో చేరండి
[![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG) [![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG)
మేము ఒక Discordలో AI తో నేర్చుకునే సిరీస్ నిర్వహిస్తున్నాము, మరింత తెలుసుకోండి మరియు [Learn with AI Series](https://aka.ms/learnwithai/discord) వద్ద 2025 సెప్టెంబర్ 18 నుండి 30 వరకు చేరండి. మీరు డేటా సైన్స్ కోసం GitHub Copilot ఉపయోగించే చిట్కాలు మరియు సూత్రాలను గ్రహించవచ్చు. మనం ఒక Discord లో "learn with AI" సీరీస్ జరుగుతున్నది, మరింత తెలుసుకోండి మరియు 18 - 30 సెప్టెంబర్, 2025 వరకు [Learn with AI Series](https://aka.ms/learnwithai/discord) వద్ద మాతో చేరండి. మీరు GitHub Copilot ను Data Science కోసం ఉపయోగించే సూచనలు మరియు మాయాజాలాలను పొందగలుగుతారు.
![Learn with AI series](../../translated_images/te/3.9b58fd8d6c373c20.webp) ![Learn with AI series](../../translated_images/te/3.9b58fd8d6c373c20.webp)
# మొదటి సారిగా మెషిన్ లెర్నింగ్ - ఒక పాఠ్యపుస్తకం # కొత్తవారికి మెషీన్ లెర్నింగ్ - ఒక పాఠ్యક્રમం
> 🌍 ప్రపంచ సంవృత్తుల ద్వారా మెషిన్ లెర్నింగ్‌ను అన్వేషిస్తూ ప్రపంచం చుట్టూ ప్రయాణించండి 🌍 > 🌍 ప్రపంచ సంస్కృతుల ద్వారా మెషీన్ లెర్నింగ్‌ను అన్వేషించడమే మన ప్రయాణం 🌍
Microsoftలోని క్లౌడ్ అడ్వొకేట్లు మెషిన్ లెర్నింగ్ గురించి 12 వారాల, 26 పాఠాల ఒక సంపూర్ణ అధ్యయన పాఠ్యక్రమాన్ని అందించడానికి సంతోషిస్తున్నాము. ఈ పాఠ్యక్రమంలో, మీరు తరచుగా "క్లాసిక్ మెషిన్ లెర్నింగ్" అని పిలవబడే విషయాలను, ప్రధానంగా Scikit-learn లైబ్రరీగా ఉపయోగించి మరియు డీప్ లెర్నింగ్‌ను దాటిచూపకుండా (మా [AI for Beginners' curriculum](https://aka.ms/ai4beginners)లో అందించబడింది) నేర్చుకుంటారు. ఈ పాఠాలను మా ['Data Science for Beginners' curriculum](https://aka.ms/ds4beginners) తో కూడ కలిపి చూడండి. Microsoftలో క్లౌడ్ అడ్వొకేట్లు **మెషీన్ లెర్నింగ్** గురించి 12-వారం, 26-పాఠాలు కలిగిన పాఠ్యક્રમాన్ని అందిస్తున్నందుకు సంతోషిస్తున్నాము. ఈ పాఠ్యക്രമంలో, మీరు కొన్ని సందర్భాలలో **క్లాసిక్ మెషీన్ లెర్నింగ్** అనే పద్ధతులను నేర్చుకుంటారు, ప్రధానంగా Scikit-learn లైబ్రరీ ఉపయోగించి, డీప్ లెర్నింగ్‌ను తప్పించుకుంటూ, ఇది మన [AI for Beginners' curriculum](https://aka.ms/ai4beginners) లో ఉన్నది. ఈ పాఠ్యక్రమాన్ని మన ['Data Science for Beginners' curriculum](https://aka.ms/ds4beginners) తో జత చేస్తే బాగుంటుంది!
మనం ఈ క్లాసిక్ సాంకేతికతలను ప్రపంచంలోని వివిధ ప్రాంతాల డేటాపై అన్వయిస్తూ ప్రపంచం చుట్టూ ప్రయాణిద్దాం. ప్రతి పాఠం ముందు మరియు తర్వాత క్విజ్‌లు, పాఠాన్ని పూర్తి చేయడానికి వ్రాత సరళీకరణ, ఒక పరిష్కారం, ఒక అసైన్మెంట్ మరియు ఇంకా చాలా ఉంటాయి. మా ప్రాజెక్ట్-ఆధారిత పాఠ్య విధానం మీరు నిర్మిస్తూ నేర్చుకునే అవకాశాన్ని ఇస్తుంది, ఇది కొత్త నైపుణ్యాలు మట్టడంలో నిర్ధారిత మార్గం. ప్రపంచం మొత్తం నుండి డేటాను తీసుకుని ఈ క్లాసిక్ పద్ధతులను మనం అన్వయిస్తాం. ప్రతి పాఠంలో ప్రీ మరియు పోస్టు-పాఠం క్విజ్‌లు, పాఠం పూర్తి చేసేందుకు రచనాత్మక ఆదేశాలు, ఒక పరిష్కారం, ఒక అసైన్‌మెంట్ మరియు ఇతర వివరాలు ఉంటాయి. మన ప్రాజెక్ట్-ఆధారిత పద్ధతి వల్ల మీరు అభ్యాసం చేస్తూ నేర్చుకుంటారు, ఇది కొత్త నైపుణ్యాలను గ్రహించడానికి చాలా ఉపయోగకరం.
**✍️ మా రచయితలకు హృదయపూర్వక ధన్యవాదాలు** జెన్ లూపర్, స్టీఫన్ హావెల్, ఫ్రాన్సెస్‌కా లాజెరి, టోమోమీ ఇమురా, క్యాస్‌శీ బ్రేవియూ, ద్మిత్రి సోష్నీకొవ్, క్రిస్ నరింగ్, అనిర్బాన్ ముఖర్జీ, ఒర్నెల్లా అల్టున్యాన్, రూత్ యాకుబు మరియు ఎమీ బాయిడ్ **✍️ హృదయపూర్వక ధన్యవాదాలు మా రచయితలకు**: Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu మరియు Amy Boyd
**🎨 మా చిత్రం చిత్రకారులకు కూడా ధన్యవాదాలు** టోమోమీ ఇమురా, దాసాని మడిపల్లి, మరియు జెన్ లూపర్ **🎨 మాకు చిత్రాలు అందించిన**: Tomomi Imura, Dasani Madipalli, మరియు Jen Looper కు ధన్యవాదాలు
**🙏 Microsoft స్టూడెంట్ అంబాసిడర్ రచయితలు, సమీక్షకులు, మరియు కంటెంట్ సహకారులకు ప్రత్యేక ధన్యవాదాలు**, ముఖ్యంగా రిషిట్ దాగ్లీ, ముహమ్మద్ సకిబ్ ఖాన్ ఇనాన్, రోహన్ రాజ్, అలెగ్జాండ్రూ పెట్రేస్కు, అభిషేక్ జైస్వాల్, న‌వ్రీన్ టబాస్సుమ్, ఇోయాన్ సముయిల, మరియు స్నిగ్ధ అగర్వాల్ **🙏 ప్రత్యేక ధన్యవాదాలు 🙏 మా Microsoft Student Ambassador రచయితలు, సమీక్షకులు, మరియు కంటెంట్ సహకారిణులకు**, ముఖ్యంగా Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila, మరియు Snigdha Agarwal
**🤩 మైక్రోసాఫ్ట్ స్టూడెంట్ అంబాసిడర్స్ ఏరిక్ వాంజావ్, జస్లీన్ సోంధి మరియు విదుషి గుప్తా మా R పాఠాల కోసం అదనపు కృతజ్ఞతలు!** **🤩 R పాఠాల కొరకు Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi, మరియు Vidushi Gupta కు అదనపు కృతజ్ఞతలు!**
# ప్రారంభించడం # ప్రారంభించడం
ఈ దశలను అనుసరించండి: ఈ దశలను అనుసరించండి:
1. **రిపోజిటరీని ఫోర్క్ చేయండి**: ఈ పేజీ ఎడమ పక్కకు ఉన్న "Fork" బటన్ క్లిక్ చేయండి. 1. **రిపోజిటరీని Fork చేసుకోండి**: ఈ పేజీ పైకుడి కోనలో ఉన్న "Fork" బటన్ పై క్లిక్ చేయండి.
2. **రిపోజిటరీని క్లోన్ చేయండి**: `git clone https://github.com/microsoft/ML-For-Beginners.git` 2. **రిపోజిటరీని Clone చేసుకోండి**: `git clone https://github.com/microsoft/ML-For-Beginners.git`
> [ఈ కోర్సుకు సంబంధించిన అన్ని అదనపు వనరులను మా Microsoft Learn సేకరణలో కనుగొనండి](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum) > [ఈ కోర్సుకు సంబంధించిన అన్ని అదనపు వనరులను మా Microsoft Learn సేకరణలో చూడండి](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
> 🔧 **సహాయం కావాలా?** స్థాపన, వ్యవస్థీకరణ, మరియు పాఠాలు నడుపుట విషయంలో సాధారణ సమస్యలకు పరిష్కారాల కోసం మా [Troubleshooting Guide](TROUBLESHOOTING.md) ను చూస్తే మెరుగైనదే. > 🔧 **సహాయం కావాలా?** సాధారణ ఇన్స్టాలేషన్, సెటప్, మరియు పాఠాలు నడిపించడంలో సమస్యలకు మేము [Troubleshooting Guide](TROUBLESHOOTING.md) అందిస్తున్నాము.
**[విద్యార్థులు](https://aka.ms/student-page)**, ఈ పాఠ్యక్రమాన్ని ఉపయోగించడానికి, మొత్తం రిపోను మీ స్వంత GitHub ఖాతాకు ఫోర్క్ చేసి, వ్యక్తిగతంగానో గుంపుగా చర్యలని పూర్తి చేయండి: **[విద్యార్థులు](https://aka.ms/student-page)**, ఈ పాఠ్యక్రమం ఉపయోగించేందుకు, మీరు ఈ మొత్తం రెపోను మీ GitHub ఖాతాకు ఫోర్క్ చేసి, స్వయంగా లేదా జట్టుతో వ్యాయామాలు పూర్తి చేయండి:
- పాఠమునుపటి క్విజ్ తో ప్రారంభించండి. - ప్రీ-లెక్చర్ క్విజ్ తో ప్రారంభించండి.
- పాఠం చదివి, ప్రతి జ్ఞాన తనిఖీ వద్ద ఆగి ఆలోచిస్తూ చర్యలు పూర్తి చేయండి. - పాఠం చదవండి మరియు క్రియాకలాపాలను పూర్తి చేయండి, ప్రతి నోటిఫికేషన్ వద్ద ఆలోచింప జేయండి.
- పాఠాలను అర్థం చేసుకొని ప్రాజెక్టులు సృష్టించాలని ప్రాముఖ్యత ఇవ్వండి; అయినప్పటికీ, ఆ కోడ్ ప్రతి ప్రాజెక్ట్-కేంద్రీయ పాఠంలో `/solution` ఫోల్డర్‌లో అందుబాటులో ఉంటుంది. - ప్రాజెక్టులు సృష్టించే ప్రయత్నం చెయ్యండి, పరిష్కార కోడ్ నడపడం కాకుండా పాఠాలు అర్థం చేసుకుంటూ; ఆ కోడ్ /solution ఫోల్డర్లలో అందుబాటులో ఉంటుంది.
- పాఠానంతర క్విజ్ తీసుకోండి. - పోస్ట్-లెక్చర్ క్విజ్ చేయండి.
- చాలెంజిని పూర్తి చేయండి. - ఛాలెంజ్ పూర్తి చేయండి.
- అసైన్మెంట్ పూర్తి చేయండి. - అసైన్‌మెంట్ పూర్తి చేయండి.
- పాఠం సమూహం పూర్తయ్యాక, [Discussion Board](https://github.com/microsoft/ML-For-Beginners/discussions) ను సందర్శించి, మీ అభ్యసనాన్ని పటిష్టంగా చూపించేందుకు సంబంధిత PAT రుబ్రిక్ ని భర్తీ చేయండి. PAT అంటే ప్రోగ్రెస్ అసెస్‌మెంట్ టూల్, ఇది నేర్చుకోవడంలో మీ పురోగతిని సూచించే రుబ్రిక్. మీరు ఇతర PAT లపై స్పందించి మనం కలిసి నేర్చుకోవచ్చు. - పాఠాల గుంపు పూర్తయిన తర్వాత, [Discussion Board](https://github.com/microsoft/ML-For-Beginners/discussions) ను సందర్శించండి మరియు 'PAT రుబ్రిక్'ని సరిగ్గా పూరించి "స్పష్టంగా నేర్చుకోండి." PAT అంటే మీరు మీ అభ్యాసాన్ని ముందుకు తీసుకెళ్లేందుకు పూర్తి చేసే ప్రోగ్రెస్ అసెస్‌మెంట్ టూల్. మీరు ఇతర PATs కు కూడా స్పందించి మనం కలిసి నేర్చుకోవచ్చు.
> మరింత అభ్యసనానికి, ఈ [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) మాడ్యూల్‌లు మరియు అభ్యసన మార్గాలను అనుసరించాలని సలహా ఇస్తున్నాము. > మరింత అభ్యాసం కొరకు, ఈ [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) మాడ్యూల్స్ మరియు లెర్నింగ్ పాథ్స్ ను అనుసరించండి.
**గురువులు**, ఈ పాఠ్యక్రమాన్ని ఎలా ఉపయోగించాలో ఆలోచనలు కొన్ని [ఇక్కడ](for-teachers.md) ఉన్నాయి. **ఉపాధ్యాయులు**, ఈ పాఠ్యక్రమాన్ని ఎలా ఉపయోగించాలో కొంత సలహాలు మేము [కొత్తగా చేర్చాము](for-teachers.md).
--- ---
## వీడియో నడుపుటలు ## వీడియో వాక్‌థ్రూ
కొన్ని పాఠాలు సంక్షిప్త వీడియోలుగా అందుబాటులో ఉన్నాయి. మీరు ఈ వీడియోలను పాఠాల్లోనే లేదా [ML for Beginners ప్లేలిస్ట్ Microsoft Developer YouTube ఛానెల్](https://aka.ms/ml-beginners-videos) లో క్రింద ఇవ్వబడ్డ చిత్రం క్లిక్ చేయడం ద్వారా చూడవచ్చు. కొన్ని పాఠాలు చిన్నవీడియోలుగా అందుబాటులో ఉన్నాయి. మీరు ఇవన్నీ పాఠాలలో పక్కననే చూడవచ్చు, లేదా [ML for Beginners ప్లేలిస్ట్‌ ను Microsoft Developer YouTube ఛానెల్‌లో](https://aka.ms/ml-beginners-videos) క్రింది చిత్రం క్లిక్ చేసి చూడవచ్చు.
[![ML for beginners banner](../../translated_images/te/ml-for-beginners-video-banner.63f694a100034bc6.webp)](https://aka.ms/ml-beginners-videos) [![ML for beginners banner](../../translated_images/te/ml-for-beginners-video-banner.63f694a100034bc6.webp)](https://aka.ms/ml-beginners-videos)
--- ---
## బృందాన్ని పరిచయం ## జట్టును కలుసుకుందాం
[![Promo video](../../images/ml.gif)](https://youtu.be/Tj1XWrDSYJU) [![Promo video](../../images/ml.gif)](https://youtu.be/Tj1XWrDSYJU)
**Gif సృష్టికర్త** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal) **Gif రూపొందించిన** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)
> 🎥 ప్రాజెక్ట్ మరియు దాన్ని సృష్టించిన వారిని గురించి వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి! > 🎥 పై చిత్రాన్ని క్లిక్ చేసి ప్రాజెక్ట్ మరియు అంద darin వారు గురించి వీడియో చూడండి!
--- ---
## పాఠ్య విధానం ## పాఠ్య విధానం
మేము ఈ పాఠ్యక్రమంను రూపొందించేప్పుడు రెండు విద్యా సూత్రాలను ఎంచుకున్నాం: ఇది చేతులతో చేయగల **ప్రాజెక్ట్-ఆధారితం** కావాలి మరియు దీంట్లో **తనిఖీలు చాలాసార్లు** ఉండాలి. అదనంగా, ఈ పాఠ్యక్రమానికి ఒక సాధారణ **థీమ్** ఉందని నిర్ధారించాం. మేము ఈ పాఠ్యక్రమాన్ని నిర్మించడంలో రెండు ముఖ్యమైన పాఠ్య సిద్ధాంతాలను ఎంచుకున్నాము: ఇది **ప్రాక్టికల్ ప్రాజెక్ట్ ఆధారితం** కావాలి మరియు **తదుపరి తరచూ క్విజ్‌లు** ఉండాలి. అదనంగా, ఈ పాఠ్యక్రమానికి ఒక సాధారణ **విషయం** ఉంటుంది, ఇది పాఠ్యక్రమాన్ని సుస్పష్టంగా చేస్తుంది.
విషయాలను ప్రాజెక్టులకు అనుసంధానించడం వలన విద్యార్థులకు ఆసక్తి పెరుగుతుంది మరియు భావనల మరపక తగ్గుతుంది. తరగతి మొదట్లో తక్కువ ఒత్తిడి ఉన్న క్విజ్ విద్యార్థి యొక్క అభ్యసన లక్ష్యాన్ని పెంచుతుంది, తరగతి అనంతరం రెండవ క్విజ్ మరింత జ్ఞాపకం పెంచుతుంది. ఈ పాఠ్యక్రమం సులభంగా అనుసరించదగ్గదిగా, మజాలో ఉండే విధంగా రూపొందించబడింది. 12 వారాల చక్ర ముగింపు వరకు ప్రాజెక్టులు చిన్నవి నుండి పెద్దవి అవుతాయి. ఈ పాఠ్యక్రమంలో ఒక ML యొక్క వాస్తవ ప్రపంచ వినియోగాల మీద ఒక పోస్ట్‌స్క్రిప్ట్ కూడా ఉంది, ఇది అదనపు క్రెడిట్ లేదా చర్చ ఆధారం కావచ్చు. కంటెంట్ ప్రాజెక్ట్లతో సమన్వయంగా ఉన్నప్పుడు, విద్యార్థులు ఎక్కువ ఆసక్తితో నేర్చుకోవడం మరియు కాన్సెప్ట్ల మెమరేషన్ మెరుగుపడుతుంది. తరగతి మొదట ఒక తక్కువ-పనికి క్విజ్ విద్యార్థిని ఆ విషయాన్ని నేర్చుకునేందుకు ఉద్దేశం పెట్టిస్తుంది, తరువాతి క్విజ్ మరింత మెమరేషన్‌కు సహాయపడుతుంది. ఈ పాఠ్యక్రమం మెరుగైన అనుకూలతను కలిగి, పూర్తి లేదా భాగంగా తీసుకోవచ్చు. ప్రాజెక్టులు చిన్నగా మొదలై చివరికి క్లిష్టత పెరుగుతాయి. ఈ పాఠ్యక్రమంలో ML యొక్క వాస్తవ ప్రపంచ కార్యక్రమాల గురించి ఒక పుస్తకారం కూడా ఉంది, దీన్ని అదనపు క్రెడిట్ లేదా చర్చకు ఉపయోగించవచ్చు.
> మా [Code of Conduct](CODE_OF_CONDUCT.md), [Contributing](CONTRIBUTING.md), [Translation](TRANSLATIONS.md), మరియు [Troubleshooting](TROUBLESHOOTING.md) మార్గనిర్దేశకాలను చూడండి. మీ అభిప్రాయాన్ని స్వాగతిస్తున్నాము! > మా [ప్రవర్తనా నియమాలు](CODE_OF_CONDUCT.md), [ఒపందం](CONTRIBUTING.md), [అనువాదం](TRANSLATIONS.md), మరియు [సమస్య పరిష్కారం](TROUBLESHOOTING.md) మార్గదర్శకాలని చూడండి. మీ అభిప్రాయాలను స్వాగతిస్తున్నాము!
## ప్రతి పాఠంలో ఉండేది ## ప్రతి పాఠం లో ఉంటాయి
- ఐచ్ఛిక స్కెచ్‌నోట్ - ఐచ్ఛిక స్కెట్చ్ నోట్స్
- ఐచ్ఛిక సహాయక వీడియో - ఐచ్ఛిక సహాయక వీడియో
- వీడియో నడుపుట (కొన్ని పాఠాలు మాత్రమే) - వీడియో వాక్‌థ్రూ (కొంతలు మాత్రమే)
- [పాఠమునుపటి వార్మ్-అప్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/) - [ప్రీ-లెక్చర్ వార్మప్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
- వ్రాత పాఠం - వ్రాత పాఠం
- ప్రాజెక్ట్-ఆధారిత పాఠాల కోసం, ప్రాజెక్టు నిర్మాణం పై దశలవారీ మార్గదర్శకాలు - ప్రాజెక్ట్ ఆధారిత పాఠాల కొరకు, ప్రాజెక్ట్‌ను ఎలా నిర్మించవచ్చో దశల వారీ గైడ్‌లు
- జ్ఞాన తనిఖీలు - జ్ఞాన eggచక్‌లు
- ఒక చాలెంజ్ - ఒక ఛాలెంజ్
- సహాయక పఠనం - అదనపు పఠనం
- అసైన్మెంట్ - అసైన్‌మెంట్
- [పాఠానంతర క్విజ్](https://ff-quizzes.netlify.app/en/ml/) - [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
> **భాషల గురించి ఒక గమనిక**: ఈ పాఠాలు ప్రధానంగా Pythonలో రాయబడ్డవి, కాని చాలా పాఠాలు Rలో కూడా అందుబాటులో ఉన్నాయి. R పాఠం పూర్తి చేయడానికి, మీరు `/solution` ఫోల్డర్‌లోకి వెళ్లి R పాఠాలను చూడండి. అవి .rmd యాక్స్టెన్షన్‌ కలిగి ఉంటాయి, ఇది **R Markdown** ఫైల్‌కు చెందినది, దీన్ని సులభంగా `code chunks` (R లేదా ఇతర భాషల కోడ్ భాగాలు) మరియు `YAML header` (PDF లాంటి అవుట్పుట్లను ఎలా ఫార్మాట్ చేయాలో మార్గనిర్దేశం చేసే)తో కూడిన `Markdown document`గా నిర్వచించవచ్చు. అందువల్ల, ఇది డేటా సైన్స్ కోసం ఒక ఆదర్శ రచనా ఫ్రేమ్‌వర్క్‌గా పనిచేస్తుంది, ఎందుకంటే మీరు మీ కోడ్, దాని అవుట్పుట్ మరియు మీ ఆలోచనలను Markdownలో వ్రాయడానికి అనుకూలిస్తుంది. ఇంకా, R Markdown డాక్యుమెంటులను PDF, HTML లేదా Word వంటి అవుట్పుట్ ఫార్మాట్లకు మార్చవచ్చు.
> **భాషల గురించి వ్యాఖ్య**: ఈ పాఠాలు ప్రధానంగా Python లో వ్రాసినవి, కానీ అనేక వాటి R లో కూడా ఉన్నాయి. R పాఠం పూర్తి చేయడానికి, `/solution` ఫోల్డర్ లోని R పాఠాలను చూడండి. అవి .rmd పొడిగింపు కలవు, ఇది **R Markdown** ఫైల్‌కి చెందినది, అంటే ఇది `code chunks` (R లేదా ఇతర భాషలలో) మరియు `YAML header` (PDF వంటి ఫలితాల ఆకృతీకరణకి మార్గదర్శకం) ను మార్క్డౌన్ డాక్యుమెంట్‌లో ఉన్నట్టుగా ఒక స్నేహపూర్వక రచనా ఫ్రేమ్‌వర్క్. డేటా సైన్స్ లో ఇది మీ కోడ్, దాని అవుట్‌పుట్ మరియు మీ ఆలోచనలని మార్క్డౌన్‌లో వ్రాయడానికి ఒక ఉత్తమ మార్గం. ఇంకా, R Markdown డాక్యుమెంట్‌లు PDF, HTML, లేదా Word వంటి అవుట్‌పుట్ ఫార్మాట్స్‌కి మార్చవచ్చు.
> **క్విజ్‌ల గురించి ఒక గమనిక**: అన్ని క్విజ్‌లు [Quiz App ఫోల్‌డర్](../../quiz-app)లో ఉన్నాయి, ప్రతి ఒక్కటి మూడు ప్రశ్నలతో కూడిన మొత్తం 52 క్విజ్‌లు. అవి పాఠాల మధ్య లింకై ఉంటాయి కానీ క్విజ్ యాప్‌ను స్థానికంగా నడపవచ్చు; `quiz-app` ఫోల్‌డర్‌లోని సూచనను అనుసరించి స్థానికంగా హోస్ట్ చేయండి లేదా Azureకి మోర్పించండి. > **క్విజ్‌ల గురించి ఒక గమనిక**: అన్ని క్విజ్‌లు [Quiz App ఫోల్డర్](../../quiz-app)లో ఉన్నాయి, మొత్తం 52 క్విజ్‌లు, ప్రతి ఒక్కటి మూడు ప్రశ్నలతో కూడుకున్నవి. అవి పాఠాలలో నుండి లింక్ చేయబడ్డాయి కానీ క్విజ్ యాప్‌ను స్థానికంగా రన్ చేయవచ్చు; స్థానికంగా హోస్ట్ చేయడానికి లేదా Azureలో డిప్లాయ్ చేసేందుకు `quiz-app` ఫోల్డర్‌లో ఇచ్చిన సూచనలను అనుసరించండి.
| పాఠం సంఖ్య | విషయం | పాఠ సమూహం | అభ్యసన లక్ష్యాలు | లింకు పెట్టబడిన పాఠం | రచయిత | | పాఠం సంఖ్య | విషయం | పాఠం సమూహం | అభ్యాస లక్ష్యాలు | లింక్ చేయబడిన పాఠం | రచయిత |
| :---------: | :------------------------------------------------------------: | :---------------------------------------------: | ---------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: | | :---------: | :------------------------------------------------------------: | :----------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :-----------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: |
| 01 | యంత్ర అధ్యయనానికి పరిచయం | [Introduction](1-Introduction/README.md) | యంత్ర అధ్యయనం స్థానిక భావనలను నేర్చుకోండి | [పాఠం](1-Introduction/1-intro-to-ML/README.md) | ముహమ్మద్ | | 01 | మెషీన్ లెర్నింగ్‌కు పరిచయం | [Introduction](1-Introduction/README.md) | మెషీన్ లెర్నింగ్ పునాదులు నేర్చుకోండి | [Lesson](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
| 02 | యంత్ర అధ్యయన చరిత్ర | [Introduction](1-Introduction/README.md) | ఈ రంగం వెనుక చరిత్రను తెలుసుకోండి | [పాఠం](1-Introduction/2-history-of-ML/README.md) | జెన్ మరియు ఎమీ | | 02 | మెషీన్ లెర్నింగ్ చరిత్ర | [Introduction](1-Introduction/README.md) | ఈ రంగం వెనుక ఉన్న చరిత్ర తెలుసుకోండి | [Lesson](1-Introduction/2-history-of-ML/README.md) | Jen and Amy |
| 03 | న్యాయం మరియు యంత్ర అధ్యయనం | [Introduction](1-Introduction/README.md) | యంత్ర మోడళ్లను నిర్మించేటప్పుడు మరియు వర్తింపజెయేటప్పుడు విద్యార్థులు పరిగణలోకి తీసుకోవలసిన న్యాయానికి సంబంధించిన ముఖ్య తత్త్వ అంశాలు ఏమిటి? | [పాఠం](1-Introduction/3-fairness/README.md) | టోమోమి | | 03 | ఇన్‌పాటు మరియు మెషీన్ లెర్నింగ్ | [Introduction](1-Introduction/README.md) | మెషీన్ లెర్నింగ్ నమూనాలు నిర్మించే మరియు ఉపయోగించే సమయంలో పరిశీలించవలసిన ఇన్‌పాటు సంబంధమైన ముఖ్య తత్త్వాలు ఏమిటి? | [Lesson](1-Introduction/3-fairness/README.md) | Tomomi |
| 04 | యంత్ర అధ్యయన సాంకేతికతలు | [Introduction](1-Introduction/README.md) | యంత్ర మోడళ్లను నిర్మించడానికి యంత్ర అధ్యయనం పరిశోధకులు ఉపయోగించే సాంకేతికతలు ఏమిటి? | [పాఠం](1-Introduction/4-techniques-of-ML/README.md) | క్రిస్ మరియు జెన్ | | 04 | మెషీన్ లెర్నింగ్ సాంకేతిక పద్ధతులు | [Introduction](1-Introduction/README.md) | మెషీన్ లెర్నింగ్ పరిశోధకులు ఎలాంటి పద్ధతులను ఉపయోగించి ML నమూనాలను నిర్మిస్తారు? | [Lesson](1-Introduction/4-techniques-of-ML/README.md) | Chris and Jen |
| 05 | రిగ్రెషన్‌కు పరిచయం | [Regression](2-Regression/README.md) | రిగ్రెషన్ మోడళ్ల కోసం Python మరియు Scikit-learn ఉపయోగించి ప్రారంభించండి | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | జెన్ • ఎరిక్ వాంజౌ | | 05 | రెగ్రెషన్‌కు పరిచయం | [Regression](2-Regression/README.md) | Python మరియు Scikit-learn ఉపయోగించి రెగ్రెషన్ మోడల్స్ మొదలు పెట్టండి | [Python](2-Regression/1-Tools/README.md) • [R](../../2-Regression/1-Tools/solution/R/lesson_1.html) | Jen • Eric Wanjau |
| 06 | ఉత్తర అమెరికన్ పంకిన్ ధరలు 🎃 | [Regression](2-Regression/README.md) | యంత్ర అధ్యయనానికి నిజమైన డేటా స్రవంతులను చూపించండి మరియు శుభ్రపరచండి | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | జెన్ • ఎరిక్ వాంజౌ | | 06 | నార్త్ అమెరికన్ పంశిన్ప్ ధరలు 🎃 | [Regression](2-Regression/README.md) | మెషీన్ లెర్నింగ్ కోసం డేటాను విజువలైజ్ చేసి శుభ్రం చేయండి | [Python](2-Regression/2-Data/README.md) • [R](../../2-Regression/2-Data/solution/R/lesson_2.html) | Jen • Eric Wanjau |
| 07 | ఉత్తర అమెరికన్ పంకిన్ ధరలు 🎃 | [Regression](2-Regression/README.md) | లీనియర్ మరియు పాలినామియల్ రిగ్రెషన్ మోడళ్లను నిర్మించండి | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | జెన్ మరియు డిమిత్రి • ఎరిక్ వాంజౌ | | 07 | నార్త్ అమెరికన్ పంశిన్ప్ ధరలు 🎃 | [Regression](2-Regression/README.md) | లీనియర్ మరియు పాలినామియల్ రెగ్రెషన్ మోడల్స్ నిర్మించండి | [Python](2-Regression/3-Linear/README.md) • [R](../../2-Regression/3-Linear/solution/R/lesson_3.html) | Jen and Dmitry • Eric Wanjau |
| 08 | ఉత్తర అమెరికన్ పంకిన్ ధరలు 🎃 | [Regression](2-Regression/README.md) | ఒక లాజిస్టిక్ రిగ్రెషన్ మోడల్‌ను నిర్మించండి | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | జెన్ • ఎరిక్ వాంజౌ | | 08 | నార్త్ అమెరికన్ పంశిన్ప్ ధరలు 🎃 | [Regression](2-Regression/README.md) | లాజిస్టిక్ రెగ్రెషన్ మోడల్ నిర్మించండి | [Python](2-Regression/4-Logistic/README.md) • [R](../../2-Regression/4-Logistic/solution/R/lesson_4.html) | Jen • Eric Wanjau |
| 09 | ఒక వెబ్ యాప్ 🔌 | [Web App](3-Web-App/README.md) | మీ శిక్షణ పొందిన మోడల్ ఉపయోగించడానికి ఒక వెబ్ యాప్ రూపొందించండి | [Python](3-Web-App/1-Web-App/README.md) | జెన్ | | 09 | వెబ్ యాప్ 🔌 | [Web App](3-Web-App/README.md) | మీరు ప్రక్షిక్షణ చేసిన మోడల్ ఉపయోగించే వెబ్ యాప్ నిర్మించండి | [Python](3-Web-App/1-Web-App/README.md) | Jen |
| 10 | వర్గీకరణకు పరిచయం | [Classification](4-Classification/README.md) | మీ డేటాను శుభ్రపరచండి, సిద్ధం చేయండి, మరియు దృశ్యీకరించండి; వర్గీకరణకు పరిచయం | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | జెన్ మరియు క్యాసీ • ఎరిక్ వాంజౌ | | 10 | వర్గీకరణకు పరిచయం | [Classification](4-Classification/README.md) | మీ డేటాను శుభ్రం చేయండి, సిద్ధం చేసుకోండి, విజువలైజ్ చేయండి; వర్గీకరణకు పరిచయం | [Python](4-Classification/1-Introduction/README.md) • [R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | Jen and Cassie • Eric Wanjau |
| 11 | రుచికరమైన ఆసియా మరియు భారతీయ వంటకాలు 🍜 | [Classification](4-Classification/README.md) | వర్గీకరణ కర్తల పరిచయం | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | జెన్ మరియు క్యాసీ • ఎరిక్ వాంజౌ | | 11 | ఆసియన్ మరియు ఇండియన్ వంటకాలు 🍜 | [Classification](4-Classification/README.md) | వర్గీకరణాల పరిచయం | [Python](4-Classification/2-Classifiers-1/README.md) • [R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | Jen and Cassie • Eric Wanjau |
| 12 | రుచికరమైన ఆసియా మరియు భారతీయ వంటకాలు 🍜 | [Classification](4-Classification/README.md) | మరిన్ని వర్గీకరణ కర్తల | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | జెన్ మరియు క్యాసీ • ఎరిక్ వాంజౌ | | 12 | ఆసియన్ మరియు ఇండియన్ వంటకాలు 🍜 | [Classification](4-Classification/README.md) | ఇంకా వర్గీకరణాలు | [Python](4-Classification/3-Classifiers-2/README.md) • [R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | Jen and Cassie • Eric Wanjau |
| 13 | రుచికరమైన ఆసియా మరియు భారతీయ వంటకాలు 🍜 | [Classification](4-Classification/README.md) | మీ మోడల్ ఉపయోగించి ఒక సిఫారసు చేసే వెబ్ యాప్‌ను నిర్మించండి | [Python](4-Classification/4-Applied/README.md) | జెన్ | | 13 | ఆసియన్ మరియు ఇండియన్ వంటకాలు 🍜 | [Classification](4-Classification/README.md) | మీ మోడల్ ఉపయోగించి రికమెండర్ వెబ్ యాప్ నిర్మించండి | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | క్లస్టరింగ్‌కు పరిచయం | [Clustering](5-Clustering/README.md) | మీ డేటాను శుభ్రపరచండి, సిద్ధం చేయండి, మరియు దృశ్యీకరించండి; క్లస్టరింగ్‌కు పరిచయం | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | జెన్ • ఎరిక్ వాంజౌ | | 14 | క్లస్టరింగ్‌కు పరిచయం | [Clustering](5-Clustering/README.md) | మీ డేటాను శుభ్రం చేసి సిద్ధం చేసుకోండి; క్లస్టరింగ్‌కు పరిచయం | [Python](5-Clustering/1-Visualize/README.md) • [R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | Jen • Eric Wanjau |
| 15 | నైజీరియన్ సంగీత రుచులను అన్వేషణ చేయడం 🎧 | [Clustering](5-Clustering/README.md) | K-Mీన్స్ క్లస్టరింగ్ పద్ధతిని అన్వేషించండి | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | జెన్ • ఎరిక్ వాంజౌ | | 15 | నైజీరియన్ సంగీత రుచులు 🎧 | [Clustering](5-Clustering/README.md) | K-Means క్లస్టరింగ్ పద్ధతిని అధ్యయనం చేయండి | [Python](5-Clustering/2-K-Means/README.md) • [R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | Jen • Eric Wanjau |
| 16 | సహజ భాష ప్రాసెసింగ్‌కు పరిచయం ☕️ | [Natural language processing](6-NLP/README.md) | ఒక సాధారణ బాట్ నిర్మించడం ద్వారా NLP గురించి ప్రాథమిక విషయాలను తెలుసుకోండి | [Python](6-NLP/1-Introduction-to-NLP/README.md) | స్టీఫెన్ | | 16 | సహజ భాషా ప్రాసెసింగ్‌కు పరిచయం ☕️ | [Natural language processing](6-NLP/README.md) | ఒక సులభమైన బాట్‌ను నిర్మించి NLP ప్రాథమికాంశాలను నేర్చుకోండి | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | సాధారణ NLP పనులు ☕️ | [Natural language processing](6-NLP/README.md) | భాషా సూత్రాలతో పని చేయేటప్పుడు అవసరమైన సాధారణ పనులను అర్థం చేసుకోవడంతో మీ NLP జ్ఞానాన్ని లోతుగా చేయండి | [Python](6-NLP/2-Tasks/README.md) | స్టీఫెన్ | | 17 | సాధారణ NLP పనులు ☕️ | [Natural language processing](6-NLP/README.md) | భాషా నిర్మాణాలతో వ్యవహరించేటప్పుడు అవసరమైన సాధారణ పనులను అర్థం చేసుకుని మీ NLP పరిజ్ఞానాన్ని లోతుగా ఆవలోకనం చేయండి | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | అనువాదం మరియు భావ విశ్లేషణ ♥️ | [Natural language processing](6-NLP/README.md) | జేన్ ఆస్టెన్‌తో అనువాదం మరియు భావ విశ్లేషణ | [Python](6-NLP/3-Translation-Sentiment/README.md) | స్టీఫెన్ | | 18 | అనువాదం మరియు భావ విశ్లేషణ ♥️ | [Natural language processing](6-NLP/README.md) | జేన్ ఆస్టెన్‌తో అనువాదం మరియు భావ విశ్లేషణ | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | యూరోప్‌లో రొమాంటిక్ హోటళ్ళు ♥️ | [Natural language processing](6-NLP/README.md) | హోటల్ సమీక్షలతో భావ విశ్లేషణ 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | స్టీఫెన్ | | 19 | యూరప్ రొమాంటిక్ హోటల్స్ ♥️ | [Natural language processing](6-NLP/README.md) | హోటల్ సమీక్షలతో భావ విశ్లేషణ 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
| 20 | యూరోప్‌లో రొమాంటిక్ హోటళ్ళు ♥️ | [Natural language processing](6-NLP/README.md) | హోటల్ సమీక్షలతో భావ విశ్లేషణ 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | స్టీఫెన్ | | 20 | యూరప్ రొమాంటిక్ హోటల్స్ ♥️ | [Natural language processing](6-NLP/README.md) | హోటల్ సమీక్షలతో భావ విశ్లేషణ 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| 21 | టైం సిరీస్ ఫోర్కాస్టింగ్‌కు పరిచయం | [Time series](7-TimeSeries/README.md) | టైం సిరీస్ ఫోర్కాస్టింగ్‌కు పరిచయం | [Python](7-TimeSeries/1-Introduction/README.md) | ఫ్రాన్సెస్కా | | 21 | టైమ్ సిరీస్ ఫోర్కాస్టింగ్‌కు పరిచయం | [Time series](7-TimeSeries/README.md) | టైమ్ సిరీస్ ఫోర్కాస్టింగ్ పరిచయం | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ ప్రపంచ శక్తి వినియోగం ⚡️ - ARIMAతో టైం సిరీస్ ఫోర్కాస్టింగ్ | [Time series](7-TimeSeries/README.md) | ARIMAతో టైం సిరీస్ ఫోర్కాస్టింగ్ | [Python](7-TimeSeries/2-ARIMA/README.md) | ఫ్రాన్సెస్కా | | 22 | ⚡️ ప్రపంచ విద్యుత్ వినియోగం ⚡️ - ARIMAతో టైమ్ సిరీస్ ఫోర్కాస్టింగ్ | [Time series](7-TimeSeries/README.md) | ARIMAతో టైమ్ సిరీస్ ఫోర్కాస్టింగ్ | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ ప్రపంచ శక్తి వినియోగం ⚡️ - SVRతో టైం సిరీస్ ఫోర్కాస్టింగ్ | [Time series](7-TimeSeries/README.md) | సపోర్ట్ వెక్టర్ రిగ్రెసర్‌తో టైం సిరీస్ ఫోర్కాస్టింగ్ | [Python](7-TimeSeries/3-SVR/README.md) | అనిర్బాన్ | | 23 | ⚡️ ప్రపంచ విద్యుత్ వినియోగం ⚡️ - SVRతో టైమ్ సిరీస్ ఫోర్కాస్టింగ్ | [Time series](7-TimeSeries/README.md) | Support Vector Regressorతో టైమ్ సిరీస్ ఫోర్కాస్టింగ్ | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
| 24 | రీయిన్ఫోర్స్‌మెంట learningకి పరిచయం | [Reinforcement learning](8-Reinforcement/README.md) | Q-Learningతో రీయిన్ఫోర్స్‌మెంట learningకి పరిచయం | [Python](8-Reinforcement/1-QLearning/README.md) | డిమిత్రి | | 24 | రీన్ఫోర్స్ మెంట్ లెర్నింగ్‌కు పరిచయం | [Reinforcement learning](8-Reinforcement/README.md) | Q-Learningతో రీన్ఫోర్స్ మెంట్ లెర్నింగ్ పరిచయం | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
| 25 | పీటర్‌ను నక్క నుండి రక్షించండి! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | రీయిన్ఫోర్స్‌మెంట learning జిమ్ | [Python](8-Reinforcement/2-Gym/README.md) | డిమిత్రి | | 25 | పీటర్ నక్కను తప్పించుకోండి! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | రీన్ఫోర్స్ మెంట్ లెర్నింగ్ జిమ్ | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
| పోస్ట్‌స్క్రిప్ట్ | వాస్తవ ప్రపంచ ML పరిస్థితులు మరియు అనువర్తనాలు | [ML in the Wild](9-Real-World/README.md) | క్లాసికల్ ML యొక్క ఆసక్తికరమైన మరియు వెలుగుల్లో వాస్తవ ప్రపంచ అనువర్తనాలు | [పాఠం](9-Real-World/1-Applications/README.md) | జట్టు | | పోస్ట్ స్క్రిప్ట్ | వాస్తవ ప్రపంచ ML సందర్భాలు మరియు అనువర్తనాలు | [ML in the Wild](9-Real-World/README.md) | క్లాసికల్ ML వాస్తవ ప్రపంచంలో ఆసక్తికరమైన మరియు ప్రకాశవంతమైన అనువర్తనాలు | [Lesson](9-Real-World/1-Applications/README.md) | Team |
| పోస్ట్‌స్క్రిప్ట్ | RAI డాష్‌బోర్డ్ ఉపయోగించి MLలో మోడల్ డీబగ్గింగ్ | [ML in the Wild](9-Real-World/README.md) | జవాబుదారీ AI డాష్‌బోర్డ్ భాగాలతో మెషీన్ లెర్నింగ్‌లో మోడల్ డీబగ్గింగ్ | [పాఠం](9-Real-World/2-Debugging-ML-Models/README.md) | రూత్ యకుబు | | పోస్ట్ స్క్రిప్ట్ | RAI డాష్‌బోర్డ్ ఉపయోగించి ML మోడల్ డీబగ్గింగ్ | [ML in the Wild](9-Real-World/README.md) | రిస్పాన్స్‌ిబుల్ AI డాష్‌బోర్డ్ భాగాల ద్వారా మెషీన్ లెర్నింగ్ మోడల్ డీబగ్గింగ్ | [Lesson](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> [ఈ కోర్సు కోసం అన్ని అదనపు వనరులను మా Microsoft Learn సేకరణలో కనుగొనండి](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum) > [ఈ కోర్సు గురించి మా Microsoft Learn సేకరణలో మొత్తం అదనపు వనరులను ఇక్కడ కనుగొనండి](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
## ఆఫ్‌లైన్ యాక్సెస్ ## ఆఫ్‌లైన్ యాక్సెస్
మీరు ఈ డాక్యుమెంటేషన్‌ను ఆఫ్‌లైన్‌లో [Docsify](https://docsify.js.org/#/) ఉపయోగించి నడపవచ్చు. ఈ రిపోను ఫోర్క్ చేసి, మీ స్థానిక యంత్రంలో [Docsifyని ఇన్‌స్టాల్](https://docsify.js.org/#/quickstart) చేయండి, ఆపై ఈ రిపో యొక్క రూట్ ఫోల్డర్లో `docsify serve` టైప్ చేయండి. వెబ్‌సైట్ మీ స్థానికహోస్ట్లో పోర్ట్ 3000 పై సర్వ్ అవుతుంది: `localhost:3000`. మీరు ఈ డాక్యుమెంటేషన్‌ను ఆఫ్‌లైన్‌లో [Docsify](https://docsify.js.org/#/) ఉపయోగించి రన్ చేయవచ్చు. ఈ రిపోని ఫోర్క్ చేసి, మీ స్థానిక యంత్రంలో [Docsify ఇన్‌స్టాల్](https://docsify.js.org/#/quickstart) చేసి, ఈ రిపో యొక్క రూట్ ఫోల్డర్‌లో `docsify serve` టైప్ చేయండి. వెబ్‌సైట్ స్థానికంగా పోర్ట్ 3000లో అందుబాటులో ఉంటుంది: `localhost:3000`.
## PDFలు ## PDFs
లింకులతో కూడిన పాఠ్యపథక PDFను [ఇక్కడ](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf) కనుగొనండి. అధ్యయన పాఠ్య ప్రణాళిక PDFను [ఇక్కడ](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf) కనుగొనండి.
## 🎒 ఇతర కోర్సులు ## 🎒 ఇతర కోర్సులు
మా జట్టు ఇతర కోర్సులు ఉత్పత్తి చేస్తుంది! చూడండి: మా టీమ్ ఇతర కోర్సులు కూడా సృష్టిస్తోంది! చూసుకోండి:
<!-- CO-OP TRANSLATOR OTHER COURSES START --> <!-- CO-OP TRANSLATOR OTHER COURSES START -->
### LangChain ### LangChain
@ -180,7 +190,7 @@ Microsoftలోని క్లౌడ్ అడ్వొకేట్లు మ
--- ---
### Generative AI Series ### జనరేటివ్ AI సిరీస్
[![Generative AI for Beginners](https://img.shields.io/badge/Generative%20AI%20for%20Beginners-8B5CF6?style=for-the-badge&labelColor=E5E7EB&color=8B5CF6)](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst) [![Generative AI for Beginners](https://img.shields.io/badge/Generative%20AI%20for%20Beginners-8B5CF6?style=for-the-badge&labelColor=E5E7EB&color=8B5CF6)](https://github.com/microsoft/generative-ai-for-beginners?WT.mc_id=academic-105485-koreyst)
[![Generative AI (.NET)](https://img.shields.io/badge/Generative%20AI%20(.NET)-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst) [![Generative AI (.NET)](https://img.shields.io/badge/Generative%20AI%20(.NET)-9333EA?style=for-the-badge&labelColor=E5E7EB&color=9333EA)](https://github.com/microsoft/Generative-AI-for-beginners-dotnet?WT.mc_id=academic-105485-koreyst)
[![Generative AI (Java)](https://img.shields.io/badge/Generative%20AI%20(Java)-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst) [![Generative AI (Java)](https://img.shields.io/badge/Generative%20AI%20(Java)-C084FC?style=for-the-badge&labelColor=E5E7EB&color=C084FC)](https://github.com/microsoft/generative-ai-for-beginners-java?WT.mc_id=academic-105485-koreyst)
@ -188,7 +198,7 @@ Microsoftలోని క్లౌడ్ అడ్వొకేట్లు మ
--- ---
### ప్రధాన అధ్యయనం ### మూలభూతం అభ్యాసం
[![ML for Beginners](https://img.shields.io/badge/ML%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=22C55E)](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst) [![ML for Beginners](https://img.shields.io/badge/ML%20for%20Beginners-22C55E?style=for-the-badge&labelColor=E5E7EB&color=22C55E)](https://aka.ms/ml-beginners?WT.mc_id=academic-105485-koreyst)
[![Data Science for Beginners](https://img.shields.io/badge/Data%20Science%20for%20Beginners-84CC16?style=for-the-badge&labelColor=E5E7EB&color=84CC16)](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst) [![Data Science for Beginners](https://img.shields.io/badge/Data%20Science%20for%20Beginners-84CC16?style=for-the-badge&labelColor=E5E7EB&color=84CC16)](https://aka.ms/datascience-beginners?WT.mc_id=academic-105485-koreyst)
[![AI for Beginners](https://img.shields.io/badge/AI%20for%20Beginners-A3E635?style=for-the-badge&labelColor=E5E7EB&color=A3E635)](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst) [![AI for Beginners](https://img.shields.io/badge/AI%20for%20Beginners-A3E635?style=for-the-badge&labelColor=E5E7EB&color=A3E635)](https://aka.ms/ai-beginners?WT.mc_id=academic-105485-koreyst)
@ -207,17 +217,22 @@ Microsoftలోని క్లౌడ్ అడ్వొకేట్లు మ
## సహాయం పొందడం ## సహాయం పొందడం
మీరు ఇబ్బంది పడితే లేదా AI యాప్స్ నిర్మించే సమయంలో ఏవైనా ప్రశ్నలు ఉంటే. MCP గురించి Fellow learners మరియు అనుభవజ్ఞులైన డెవలపర్లు చర్చల్లో చేరండి. ఇది ప్రశ్నలకు స్వాగతం పలుకుతున్న, జ్ఞానం స్వేచ్ఛగా పంచుకునే మద్దతు సమాజం. AI యాప్స్ తయారీలో మీరు అడ్డుకట్ట పడినట్లయితే లేదా ఏవైనా ప్రశ్నలు ఉంటే, MCP గురించి చర్చలలో పాఠశాల విద్యార్థులు మరియు అనుభవజ్ఞులైన డెవలపర్లు కలిసి చేరండి. ఇది ప్రశ్నలు అడగడానికి అనుకూలమైన కమ్యూనిటీ, ఇక్కడ విజ్ఞానం సడలింపుగా పంచుకుంటారు.
[![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG) [![Microsoft Foundry Discord](https://dcbadge.limes.pink/api/server/nTYy5BXMWG)](https://discord.gg/nTYy5BXMWG)
మీకు ఉత్పత్తి సంబంధించిన అభిప్రాయం లేదా నిర్మాణ సమయంలో లోపాలు ఉంటే సందర్శించండి: ఉత్పత్తి అభిప్రాయాలు లేదా బిల్డ్ చేస్తున్నప్పుడు పొరపాట్లు ఉంటే సందర్శించండి:
[![Microsoft Foundry Developer Forum](https://img.shields.io/badge/GitHub-Microsoft_Foundry_Developer_Forum-blue?style=for-the-badge&logo=github&color=000000&logoColor=fff)](https://aka.ms/foundry/forum) [![Microsoft Foundry Developer Forum](https://img.shields.io/badge/GitHub-Microsoft_Foundry_Developer_Forum-blue?style=for-the-badge&logo=github&color=000000&logoColor=fff)](https://aka.ms/foundry/forum)
## అదనపు అధ్యయన సూచనలు
- ప్రతి పాఠం తర్వాత నోట్బుక్స్‌ని సమీక్షించండి మరింత బాగా అర్థం చేసుకోవడానికి.
- స్వయంగా ఆల్గోరిథమ్స్ అమలు చేయాలని సాధన చేయండి.
- నేర్చుకున్న భావనలను ఉపయోగించి ప్రాక్టికల్ డేటా సెట్‌లను అన్వేషించండి.
--- ---
<!-- CO-OP TRANSLATOR DISCLAIMER START --> <!-- CO-OP TRANSLATOR DISCLAIMER START -->
**డిస్క్లెయిమర్**: **అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నిస్తున్నా, ఆటోమేటెడ్ అనువాదాలలో పొరపాట్లు లేదా అసముచితతలు ఉండవచ్చు. పద్ధతిగా, మూల పత్రం స్థానిక భాషలోనే అధికారిక మూలంగా తీసుకోవాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం మేలు. ఈ అనువాదం ఉపయోగం కారణంగా ఏర్పడిన ఏవైనా అపర్ధాలు లేదా తప్పుడు అర్థం చేసుకున్నట్లయితే మేము బాధ్యులు కంకాలము కదవము. ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నిస్తున్నప్పటికీ, ఆటోమేటిక్ అనువాదాలలో పొరపాట్లు లేదా తప్పులుండవచ్చు. స్వదేశీ భాషలో ఉన్న అసలు పత్రం అధికారిక మూలంగా పరిగణించబడాలి. ముఖ్యమైన సమాచారం కోసం, నిపుణుల మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదాన్ని ఉపయోగించి కలిగే ఏ ఇతరార్థాలు లేదా తప్పుదారితులను మేము బాధ్యులు కాదు.
<!-- CO-OP TRANSLATOR DISCLAIMER END --> <!-- CO-OP TRANSLATOR DISCLAIMER END -->
Write Preview
Loading…
Cancel
Save