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 9/10, 100 files)

Browse Source
pull/906/head
localizeflow[bot] 2 months ago
parent 9b20802b89
commit 4abb311b28
100 changed files with 25106 additions and 0 deletions
Show Stats Download Patch File Download Diff File

25
translations/ml/CONTRIBUTING.md
Unescape View File

@ -0,0 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "977ec5266dfd78ad1ce2bd8d46fccbda",
"translation_date": "2025-12-19T12:27:55+00:00",
"source_file": "CONTRIBUTING.md",
"language_code": "ml"
}
-->
# സംഭാവനകൾ
ഈ പ്രോജക്റ്റ് സംഭാവനകളും നിർദ്ദേശങ്ങളും സ്വാഗതം ചെയ്യുന്നു. മിക്ക സംഭാവനകൾക്കും നിങ്ങൾക്ക് Contributor License Agreement (CLA) യിൽ സമ്മതിക്കേണ്ടതുണ്ട്, അതിൽ നിങ്ങൾക്ക് നിങ്ങളുടെ സംഭാവന ഉപയോഗിക്കാൻ അവകാശമുണ്ടെന്ന്, യഥാർത്ഥത്തിൽ അവകാശം നൽകുന്നതായി പ്രഖ്യാപിക്കേണ്ടതുണ്ട്. വിശദാംശങ്ങൾക്ക്, സന്ദർശിക്കുക https://cla.microsoft.com.
> പ്രധാനപ്പെട്ടത്: ഈ റിപോസിറ്ററിയിലെ വാചകങ്ങൾ വിവർത്തനം ചെയ്യുമ്പോൾ, ദയവായി യന്ത്ര വിവർത്തനം ഉപയോഗിക്കരുത്. വിവർത്തനങ്ങൾ സമൂഹത്തിലൂടെ പരിശോധിക്കും, അതിനാൽ നിങ്ങൾ പ്രാവീണ്യമുള്ള ഭാഷകളിൽ മാത്രമേ വിവർത്തനങ്ങൾക്ക് സ്വമേധയാ സന്നദ്ധത നൽകൂ.
നിങ്ങൾ ഒരു പുൾ റിക്വസ്റ്റ് സമർപ്പിക്കുമ്പോൾ, CLA-ബോട്ട് സ്വയം നിങ്ങൾക്ക് CLA നൽകേണ്ടതുണ്ടോ എന്ന് നിർണ്ണയിച്ച് PR യഥാർത്ഥമായി അലങ്കരിക്കും (ഉദാ: ലേബൽ, കമന്റ്). ബോട്ടിന്റെ നിർദ്ദേശങ്ങൾ പാലിക്കുക. ഞങ്ങളുടെ CLA ഉപയോഗിക്കുന്ന എല്ലാ റിപോസിറ്ററികളിലും ഇത് നിങ്ങൾ ഒരിക്കൽ മാത്രം ചെയ്യേണ്ടതുണ്ട്.
ഈ പ്രോജക്റ്റ് [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/) സ്വീകരിച്ചിട്ടുണ്ട്. കൂടുതൽ വിവരങ്ങൾക്ക് [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) കാണുക അല്ലെങ്കിൽ [opencode@microsoft.com](mailto:opencode@microsoft.com) എന്ന വിലാസത്തിൽ അധിക ചോദ്യങ്ങൾക്കോ അഭിപ്രായങ്ങൾക്കോ ബന്ധപ്പെടുക.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

2840
translations/ml/PyTorch_Fundamentals.ipynb
View File

File diff suppressed because it is too large Load Diff

223
translations/ml/README.md
Unescape View File

@ -0,0 +1,223 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "c300f2380d9da91b7de8c707f69ce99b",
"translation_date": "2025-12-19T12:50:32+00:00",
"source_file": "README.md",
"language_code": "ml"
}
-->
[![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 ആക്ഷൻ വഴി പിന്തുണ (സ്വയം പ്രവർത്തിക്കുന്നതും എല്ലായ്പ്പോഴും പുതുക്കപ്പെട്ടതും)
<!-- 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/README.md) | [Chinese (Traditional, Hong Kong)](../hk/README.md) | [Chinese (Traditional, Macau)](../mo/README.md) | [Chinese (Traditional, Taiwan)](../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)](../br/README.md) | [Portuguese (Portugal)](../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)
<!-- CO-OP TRANSLATOR LANGUAGES TABLE END -->
#### ഞങ്ങളുടെ സമൂഹത്തിൽ ചേരുക
[![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 series](../../translated_images/3.9b58fd8d6c373c20c588c5070c4948a826ab074426c28ceb5889641294373dfc.ml.png)
# തുടക്കക്കാർക്കുള്ള മെഷീൻ ലേണിംഗ് - ഒരു പാഠ്യപദ്ധതി
> 🌍 ലോക സംസ്കാരങ്ങളിലൂടെ മെഷീൻ ലേണിംഗ് അന്വേഷിക്കുമ്പോൾ ലോകം ചുറ്റി യാത്ര ചെയ്യാം 🌍
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 Student Ambassador എഴുത്തുകാരും റിവ്യൂവർമാരും ഉള്ളടക്ക സംഭാവനക്കാർക്കും**, പ്രത്യേകിച്ച് Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila, Snigdha Agarwal
**🤩 Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi, Vidushi Gupta-യ്ക്ക് R പാഠങ്ങൾക്കുള്ള അധിക നന്ദി!**
# ആരംഭിക്കുന്നത്
ഈ ഘട്ടങ്ങൾ പിന്തുടരുക:
1. **റിപ്പോസിറ്ററി ഫോർക്ക് ചെയ്യുക**: ഈ പേജിന്റെ മുകളിൽ വലത് വശത്ത് "Fork" ബട്ടൺ ക്ലിക്ക് ചെയ്യുക.
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)
> 🔧 **സഹായം വേണോ?** ഇൻസ്റ്റാളേഷൻ, സെറ്റപ്പ്, പാഠങ്ങൾ പ്രവർത്തിപ്പിക്കൽ സംബന്ധിച്ച സാധാരണ പ്രശ്നങ്ങൾക്ക് പരിഹാരങ്ങൾക്കായി ഞങ്ങളുടെ [Troubleshooting Guide](TROUBLESHOOTING.md) പരിശോധിക്കുക.
**[വിദ്യാർത്ഥികൾ](https://aka.ms/student-page)**, ഈ പാഠ്യപദ്ധതി ഉപയോഗിക്കാൻ, മുഴുവൻ റിപോ നിങ്ങളുടെ സ്വന്തം GitHub അക്കൗണ്ടിലേക്ക് ഫോർക്ക് ചെയ്ത് സ്വയം അല്ലെങ്കിൽ ഗ്രൂപ്പുമായി അഭ്യാസങ്ങൾ പൂർത്തിയാക്കുക:
- പ്രീ-ലെക്ചർ ക്വിസ് ആരംഭിക്കുക.
- ലെക്ചർ വായിച്ച് പ്രവർത്തനങ്ങൾ പൂർത്തിയാക്കുക, ഓരോ അറിവ് പരിശോധനയിലും നിർത്തി ആലോചിക്കുക.
- പരിഹാര കോഡ് ഓടിക്കുന്നതിന് പകരം പാഠങ്ങൾ മനസ്സിലാക്കി പ്രോജക്ടുകൾ സൃഷ്ടിക്കാൻ ശ്രമിക്കുക; എന്നാൽ ആ കോഡ് ഓരോ പ്രോജക്ട്-കേന്ദ്രിത പാഠത്തിലെ `/solution` ഫോൾഡറുകളിൽ ലഭ്യമാണ്.
- പോസ്റ്റ്-ലെക്ചർ ക്വിസ് എടുക്കുക.
- ചലഞ്ച് പൂർത്തിയാക്കുക.
- അസൈൻമെന്റ് പൂർത്തിയാക്കുക.
- ഒരു പാഠം ഗ്രൂപ്പ് പൂർത്തിയാക്കിയ ശേഷം, [Discussion Board](https://github.com/microsoft/ML-For-Beginners/discussions) സന്ദർശിച്ച് അനുയോജ്യമായ PAT റൂബ്രിക് പൂരിപ്പിച്ച് "learn out loud" ചെയ്യുക. 'PAT' എന്നത് പ്രോഗ്രസ് അസസ്മെന്റ് ടൂൾ ആണ്, നിങ്ങളുടെ പഠനം മെച്ചപ്പെടുത്താൻ പൂരിപ്പിക്കുന്ന ഒരു റൂബ്രിക്. മറ്റുള്ള PAT-കൾക്ക് പ്രതികരിക്കാനും കഴിയും, അതിലൂടെ നാം ഒരുമിച്ച് പഠിക്കാം.
> കൂടുതൽ പഠനത്തിനായി, ഈ [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott) മോഡ്യൂളുകളും പഠന പാതകളും പിന്തുടരാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.
**അധ്യാപകർ**, ഈ പാഠ്യപദ്ധതി ഉപയോഗിക്കുന്നതിനുള്ള ചില നിർദ്ദേശങ്ങൾ ഞങ്ങൾ [ഉൾപ്പെടുത്തിയിട്ടുണ്ട്](for-teachers.md).
---
## വീഡിയോ വാക്ക്‌ത്രൂകൾ
ചില പാഠങ്ങൾ ചെറു വീഡിയോകളായി ലഭ്യമാണ്. ഈ വീഡിയോകൾ പാഠങ്ങളിൽ നേരിട്ട് കാണാനോ, [ML for Beginners പ്ലേലിസ്റ്റ് Microsoft Developer YouTube ചാനലിൽ](https://aka.ms/ml-beginners-videos) ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്ത് കാണാനോ കഴിയും.
[![ML for beginners banner](../../translated_images/ml-for-beginners-video-banner.63f694a100034bc6251134294459696e070a3a9a04632e9fe6a24aa0de4a7384.ml.png)](https://aka.ms/ml-beginners-videos)
---
## ടീം പരിചയം
[![Promo video](../../images/ml.gif)](https://youtu.be/Tj1XWrDSYJU)
**ഗിഫ്** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)
> 🎥 പ്രോജക്ടും അതിനെ സൃഷ്ടിച്ച ആളുകളും കുറിച്ചുള്ള വീഡിയോയ്ക്ക് മുകളിൽ കാണുന്ന ചിത്രത്തിൽ ക്ലിക്ക് ചെയ്യുക!
---
## പഠനരീതി
ഈ പാഠ്യപദ്ധതി നിർമ്മിക്കുമ്പോൾ ഞങ്ങൾ രണ്ട് പഠന സിദ്ധാന്തങ്ങൾ തിരഞ്ഞെടുക്കുകയുണ്ടായി: പ്രായോഗികമായ **പ്രോജക്ട്-അധിഷ്ഠിതം** ആകണം, കൂടാതെ **സാധാരണ ക്വിസുകൾ** ഉൾക്കൊള്ളണം. കൂടാതെ, ഈ പാഠ്യപദ്ധതിക്ക് ഒരു പൊതു **തീം** ഉണ്ട്, അത് ഏകോപനം നൽകുന്നു.
ഉള്ളടക്കം പ്രോജക്ടുകളുമായി പൊരുത്തപ്പെടുന്നതു ഉറപ്പാക്കുന്നതിലൂടെ, വിദ്യാർത്ഥികൾക്ക് കൂടുതൽ ആകർഷകവും ആശയങ്ങൾ കൂടുതൽ ദീർഘകാലം നിലനിൽക്കുന്നതുമായ ഒരു പഠനാനുഭവം ലഭിക്കും. ക്ലാസിന് മുമ്പുള്ള കുറഞ്ഞ സമ്മർദ്ദമുള്ള ക്വിസ് വിദ്യാർത്ഥിയുടെ പഠന ഉദ്ദേശ്യം സജ്ജമാക്കുന്നു, ക്ലാസിന് ശേഷം മറ്റൊരു ക്വിസ് കൂടുതൽ ഓർമ്മപ്പെടുത്തലിനായി സഹായിക്കുന്നു. ഈ പാഠ്യപദ്ധതി ലവച്ഛേദ്യവും രസകരവുമാണ്, മുഴുവനായോ ഭാഗികമായോ പഠിക്കാവുന്നതാണ്. പ്രോജക്ടുകൾ ചെറിയതിൽ നിന്ന് ആരംഭിച്ച് 12 ആഴ്ചകളുടെ അവസാനം കൂടുതൽ സങ്കീർണ്ണമാകുന്നു. ഈ പാഠ്യപദ്ധതിയിൽ ML-ന്റെ യഥാർത്ഥ ലോക പ്രയോഗങ്ങളെക്കുറിച്ചുള്ള ഒരു പോസ്റ്റ്‌സ്‌ക്രിപ്റ്റും ഉൾക്കൊള്ളുന്നു, ഇത് അധിക ക്രെഡിറ്റിനോ ചർച്ചയ്ക്കോ ഉപയോഗിക്കാം.
> ഞങ്ങളുടെ [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/)
> **ഭാഷകളെക്കുറിച്ചുള്ള ഒരു കുറിപ്പ്**: ഈ പാഠങ്ങൾ പ്രധാനമായും Python-ൽ എഴുതപ്പെട്ടതാണ്, എന്നാൽ പലതും R-ലും ലഭ്യമാണ്. R പാഠം പൂർത്തിയാക്കാൻ, `/solution` ഫോൾഡറിൽ പോയി R പാഠങ്ങൾ കണ്ടെത്തുക. അവയിൽ .rmd എക്സ്റ്റൻഷൻ ഉണ്ട്, ഇത് **R Markdown** ഫയലിനെ പ്രതിനിധീകരിക്കുന്നു, ഇത് `code chunks` (R അല്ലെങ്കിൽ മറ്റ് ഭാഷകളിൽ) ഒപ്പം `YAML header` (PDF പോലുള്ള ഔട്ട്പുട്ടുകൾ എങ്ങനെ ഫോർമാറ്റ് ചെയ്യാമെന്ന് നിർദ്ദേശിക്കുന്നു) അടങ്ങിയ ഒരു Markdown ഡോക്യുമെന്റ് ആണെന്ന് സൂചിപ്പിക്കുന്നു. അതിനാൽ, ഇത് ഡാറ്റാ സയൻസിനുള്ള ഒരു ഉദാഹരണാത്മക എഴുത്ത് ഘടനയായി പ്രവർത്തിക്കുന്നു, കാരണം നിങ്ങൾക്ക് നിങ്ങളുടെ കോഡ്, അതിന്റെ ഔട്ട്പുട്ട്, നിങ്ങളുടെ ചിന്തകൾ Markdown-ൽ എഴുതാൻ കഴിയും. കൂടാതെ, R Markdown ഡോക്യുമെന്റുകൾ PDF, HTML, Word പോലുള്ള ഔട്ട്പുട്ട് ഫോർമാറ്റുകളിലേക്ക് മാറ്റാം.
> **ക്വിസുകളെക്കുറിച്ചുള്ള ഒരു കുറിപ്പ്**: എല്ലാ ക്വിസുകളും [Quiz App ഫോൾഡറിൽ](../../quiz-app) ഉൾക്കൊള്ളുന്നു, മൂന്ന് ചോദ്യങ്ങളുള്ള 52 ക്വിസുകൾ. അവ പാഠങ്ങളിൽ നിന്ന് ലിങ്ക് ചെയ്തിട്ടുണ്ട്, പക്ഷേ ക്വിസ് ആപ്പ് ലോക്കലായി ഓടിക്കാം; ലോക്കലായി ഹോസ്റ്റ് ചെയ്യാനോ Azure-ലേക്ക് ഡിപ്ലോയ് ചെയ്യാനോ `quiz-app` ഫോൾഡറിലെ നിർദ്ദേശങ്ങൾ പിന്തുടരുക.
| പാഠം നമ്പർ | വിഷയം | പാഠം ഗ്രൂപ്പിംഗ് | പഠന ലക്ഷ്യങ്ങൾ | ലിങ്കുചെയ്ത പാഠം | എഴുത്തുകാരൻ |
| :-----------: | :------------------------------------------------------------: | :-------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: |
| 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) | ജെൻ ആൻഡ് എമി |
| 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) | ക്രിസ് ആൻഡ് ജെൻ |
| 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) | ജെൻ • എറിക് വാൻജൗ |
| 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) | ജെൻ • എറിക് വാൻജൗ |
| 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) | ജെൻ ആൻഡ് കാസ്സി • എറിക് വാൻജൗ |
| 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) | ജെൻ ആൻഡ് കാസ്സി • എറിക് വാൻജൗ |
| 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) | ജെൻ • എറിക് വാൻജൗ |
| 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) | സ്റ്റീഫൻ |
| 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) | സ്റ്റീഫൻ |
| 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) | സ്റ്റീഫൻ |
| 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) | ഫ്രാൻസെസ്ക |
| 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) | ഡ്മിത്രി |
| 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) | ടീം |
| Postscript | 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)
## ഓഫ്‌ലൈൻ ആക്‌സസ്
[Docsify](https://docsify.js.org/#/) ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ ഡോക്യുമെന്റേഷൻ ഓഫ്‌ലൈൻ പ്രവർത്തിപ്പിക്കാം. ഈ റിപോ ഫോർക്ക് ചെയ്യുക, നിങ്ങളുടെ ലോക്കൽ മെഷീനിൽ [Docsify ഇൻസ്റ്റാൾ ചെയ്യുക](https://docsify.js.org/#/quickstart), പിന്നീട് ഈ റിപോയുടെ റൂട്ട് ഫോൾഡറിൽ `docsify serve` ടൈപ്പ് ചെയ്യുക. വെബ്സൈറ്റ് നിങ്ങളുടെ ലോക്കൽഹോസ്റ്റിൽ പോർട്ട് 3000-ൽ സർവ് ചെയ്യും: `localhost:3000`.
## PDFകൾ
കുറിക്കുലത്തിന്റെ PDF ലിങ്കുകളോടെ [ഇവിടെ](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf) കണ്ടെത്തുക.
## 🎒 മറ്റ് കോഴ്സുകൾ
ഞങ്ങളുടെ ടീം മറ്റ് കോഴ്സുകളും നിർമ്മിക്കുന്നു! പരിശോധിക്കുക:
<!-- CO-OP TRANSLATOR OTHER COURSES START -->
### 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)
[![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)
---
### Azure / Edge / MCP / Agents
[![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)
[![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)
[![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)
[![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)
---
### Generative AI Series
[![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 (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)
---
### കോർ ലേണിംഗ്
[![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)
[![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)
[![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)
[![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)
[![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)
[![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)
---
### കോപൈലറ്റ് സീരീസ്
[![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)
[![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)
[![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 -->
## സഹായം നേടുക
നിങ്ങൾക്ക് AI ആപ്പുകൾ നിർമ്മിക്കുന്നതിൽ തടസ്സം നേരിടുകയോ എന്തെങ്കിലും ചോദ്യങ്ങളുണ്ടാകുകയോ ചെയ്താൽ, MCP-യിൽ fellow learners-ഉം പരിചയസമ്പന്നരായ ഡെവലപ്പർമാരും ചേർന്ന് ചർച്ചകളിൽ പങ്കെടുക്കുക. ചോദ്യങ്ങൾ സ്വാഗതം ചെയ്യപ്പെടുന്ന, അറിവ് സ്വതന്ത്രമായി പങ്കുവെക്കുന്ന ഒരു പിന്തുണയുള്ള സമൂഹമാണ് ഇത്.
[![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)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

53
translations/ml/SECURITY.md
Unescape View File

@ -0,0 +1,53 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "5e1b8da31aae9cca3d53ad243fa3365a",
"translation_date": "2025-12-19T12:44:40+00:00",
"source_file": "SECURITY.md",
"language_code": "ml"
}
-->
## Security
Microsoft നമ്മുടെ സോഫ്റ്റ്വെയർ ഉൽപ്പന്നങ്ങളും സേവനങ്ങളും സുരക്ഷിതമാക്കുന്നതിൽ ഗൗരവമുണ്ട്, ഇതിൽ നമ്മുടെ GitHub സംഘടനകൾ വഴി നിയന്ത്രിക്കുന്ന എല്ലാ സോഴ്‌സ് കോഡ് റിപോസിറ്ററികളും ഉൾപ്പെടുന്നു, അവയിൽ [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), കൂടാതെ [നമ്മുടെ GitHub സംഘടനകൾ](https://opensource.microsoft.com/) ഉൾപ്പെടുന്നു.
നിങ്ങൾക്ക് Microsoft-ഉടമയായ ഏതെങ്കിലും റിപോസിറ്ററിയിൽ [Microsoft-ന്റെ സുരക്ഷാ ദുർബലതയുടെ നിർവചനത്തിന്](https://docs.microsoft.com/previous-versions/tn-archive/cc751383(v=technet.10)?WT.mc_id=academic-77952-leestott) അനുയോജ്യമായ ഒരു സുരക്ഷാ ദുർബലത കണ്ടെത്തിയതായി തോന്നുന്നുവെങ്കിൽ, താഴെ വിവരിച്ചിരിക്കുന്നതുപോലെ അത് ഞങ്ങളോട് റിപ്പോർട്ട് ചെയ്യുക.
## സുരക്ഷാ പ്രശ്നങ്ങൾ റിപ്പോർട്ട് ചെയ്യൽ
**സുരക്ഷാ ദുർബലതകൾ പൊതു GitHub പ്രശ്നങ്ങളിലൂടെ റിപ്പോർട്ട് ചെയ്യരുത്.**
പകരം, ദയവായി അവ Microsoft Security Response Center (MSRC) ൽ [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report) എന്ന വിലാസത്തിൽ റിപ്പോർട്ട് ചെയ്യുക.
ലോഗിൻ ചെയ്യാതെ സമർപ്പിക്കാൻ നിങ്ങൾക്ക് ഇഷ്ടമെങ്കിൽ, [secure@microsoft.com](mailto:secure@microsoft.com) എന്ന ഇമെയിലിലേക്ക് അയയ്ക്കുക. സാധ്യമായെങ്കിൽ, ഞങ്ങളുടെ PGP കീ ഉപയോഗിച്ച് നിങ്ങളുടെ സന്ദേശം എൻക്രിപ്റ്റ് ചെയ്യുക; ദയവായി അത് [Microsoft Security Response Center PGP Key പേജിൽ](https://www.microsoft.com/en-us/msrc/pgp-key-msrc) നിന്ന് ഡൗൺലോഡ് ചെയ്യുക.
നിങ്ങൾക്ക് 24 മണിക്കൂറിനുള്ളിൽ ഒരു പ്രതികരണം ലഭിക്കണം. എന്തെങ്കിലും കാരണത്താൽ ലഭിക്കാത്ത പക്ഷം, നിങ്ങളുടെ പ്രാഥമിക സന്ദേശം ഞങ്ങൾ സ്വീകരിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കാൻ ഇമെയിൽ വഴി ഫോളോ അപ്പ് ചെയ്യുക. കൂടുതൽ വിവരങ്ങൾ [microsoft.com/msrc](https://www.microsoft.com/msrc) ൽ ലഭ്യമാണ്.
ദയവായി താഴെപ്പറയുന്ന ആവശ്യമായ വിവരങ്ങൾ (നിങ്ങൾക്ക് നൽകാൻ കഴിയുന്നത്ര) ഉൾപ്പെടുത്തുക, ഇത് പ്രശ്നത്തിന്റെ സ്വഭാവവും പരിധിയും നമുക്ക് മെച്ചമായി മനസ്സിലാക്കാൻ സഹായിക്കും:
* പ്രശ്നത്തിന്റെ തരം (ഉദാ: ബഫർ ഓവർഫ്ലോ, SQL ഇൻജക്ഷൻ, ക്രോസ്-സൈറ്റ് സ്ക്രിപ്റ്റിംഗ്, തുടങ്ങിയവ)
* പ്രശ്നം പ്രകടമാകുന്ന സോഴ്‌സ് ഫയലുകളുടെ പൂർണ്ണ പാതകൾ
* ബാധിച്ച സോഴ്‌സ് കോഡിന്റെ സ്ഥാനം (ടാഗ്/ബ്രാഞ്ച്/കമ്മിറ്റ് അല്ലെങ്കിൽ നേരിട്ട് URL)
* പ്രശ്നം പുനരാവർത്തിപ്പിക്കാൻ ആവശ്യമായ പ്രത്യേക കോൺഫിഗറേഷൻ
* പ്രശ്നം പുനരാവർത്തിപ്പിക്കാൻ ഘട്ടം ഘട്ടമായ നിർദ്ദേശങ്ങൾ
* പ്രൂഫ്-ഓഫ്-കോൺസെപ്റ്റ് അല്ലെങ്കിൽ എക്സ്പ്ലോയിറ്റ് കോഡ് (സാധ്യമായെങ്കിൽ)
* പ്രശ്നത്തിന്റെ പ്രഭാവം, അതിൽ ഒരു ആക്രമണകാരൻ എങ്ങനെ പ്രശ്നം ഉപയോഗപ്പെടുത്താമെന്ന് ഉൾപ്പെടെ
ഈ വിവരങ്ങൾ നിങ്ങളുടെ റിപ്പോർട്ട് വേഗത്തിൽ പരിശോധിക്കാൻ സഹായിക്കും.
നിങ്ങൾ ബഗ് ബൗണ്ടിക്ക് റിപ്പോർട്ട് ചെയ്യുകയാണെങ്കിൽ, കൂടുതൽ സമഗ്രമായ റിപ്പോർട്ടുകൾ ഉയർന്ന ബൗണ്ടി അവാർഡിന് സഹായകമാകും. ഞങ്ങളുടെ [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) പേജ് സന്ദർശിച്ച് സജീവ പ്രോഗ്രാമുകൾക്കുറിച്ച് കൂടുതൽ വിവരങ്ങൾ അറിയുക.
## ഇഷ്ടഭാഷകൾ
എല്ലാ ആശയവിനിമയവും ഇംഗ്ലീഷിൽ ആയിരിക്കണമെന്ന് ഞങ്ങൾ ഇഷ്ടപ്പെടുന്നു.
## നയം
Microsoft [Coordinated Vulnerability Disclosure](https://www.microsoft.com/en-us/msrc/cvd) എന്ന സിദ്ധാന്തം പിന്തുടരുന്നു.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

31
translations/ml/SUPPORT.md
Unescape View File

@ -0,0 +1,31 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "09623d7343ff1c26ff4f198c1b2d3176",
"translation_date": "2025-12-19T12:27:30+00:00",
"source_file": "SUPPORT.md",
"language_code": "ml"
}
-->
# പിന്തുണ
## പ്രശ്നങ്ങൾ ഫയൽ ചെയ്യാനും സഹായം ലഭിക്കാനും
പ്രശ്നം ഫയൽ ചെയ്യുന്നതിന് മുമ്പ്, ഇൻസ്റ്റാളേഷൻ, സെറ്റപ്പ്, പാഠങ്ങൾ നടത്തുന്നതുമായി ബന്ധപ്പെട്ട സാധാരണ പ്രശ്നങ്ങൾക്ക് പരിഹാരങ്ങൾക്കായി ഞങ്ങളുടെ [പ്രശ്നപരിഹാര ഗൈഡ്](TROUBLESHOOTING.md) പരിശോധിക്കുക.
ഈ പ്രോജക്ട് ബഗുകളും ഫീച്ചർ അഭ്യർത്ഥനകളും ട്രാക്ക് ചെയ്യാൻ GitHub Issues ഉപയോഗിക്കുന്നു. പുനരാവൃതികൾ ഒഴിവാക്കാൻ പുതിയ പ്രശ്നങ്ങൾ ഫയൽ ചെയ്യുന്നതിന് മുമ്പ് നിലവിലുള്ള പ്രശ്നങ്ങൾ തിരയുക. പുതിയ പ്രശ്നങ്ങൾക്കായി, നിങ്ങളുടെ ബഗ് അല്ലെങ്കിൽ ഫീച്ചർ അഭ്യർത്ഥന പുതിയ ഒരു Issue ആയി ഫയൽ ചെയ്യുക.
ഈ പ്രോജക്ട് ഉപയോഗിക്കുന്നതിനെക്കുറിച്ചുള്ള സഹായത്തിനും ചോദ്യങ്ങൾക്കുമായി, നിങ്ങൾക്ക് താഴെ പറയുന്നവ ചെയ്യാം:
- [പ്രശ്നപരിഹാര ഗൈഡ്](TROUBLESHOOTING.md) പരിശോധിക്കുക
- ഞങ്ങളുടെ [Discord Discussions #ml-for-beginners ചാനൽ](https://aka.ms/foundry/discord) സന്ദർശിക്കുക
- ഒരു പ്രശ്നം ഫയൽ ചെയ്യുക
## Microsoft പിന്തുണ നയം
ഈ റിപോസിറ്ററിയുടെ പിന്തുണ മുകളിൽ പറയപ്പെട്ട വിഭവങ്ങളിലേക്കാണ് പരിമിതമായിരിക്കുന്നത്.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

612
translations/ml/TROUBLESHOOTING.md
Unescape View File

@ -0,0 +1,612 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "134d8759f0e2ab886e9aa4f62362c201",
"translation_date": "2025-12-19T12:33:08+00:00",
"source_file": "TROUBLESHOOTING.md",
"language_code": "ml"
}
-->
# പ്രശ്നപരിഹാര ഗൈഡ്
Machine Learning for Beginners പാഠ്യപദ്ധതിയുമായി ജോലി ചെയ്യുമ്പോൾ സാധാരണയായി നേരിടുന്ന പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ ഈ ഗൈഡ് സഹായിക്കും. ഇവിടെ പരിഹാരം കണ്ടെത്താനാകുന്നില്ലെങ്കിൽ, ദയവായി ഞങ്ങളുടെ [Discord Discussions](https://aka.ms/foundry/discord) പരിശോധിക്കുക അല്ലെങ്കിൽ [ഒരു പ്രശ്നം തുറക്കുക](https://github.com/microsoft/ML-For-Beginners/issues).
## ഉള്ളടക്ക പട്ടിക
- [ഇൻസ്റ്റലേഷൻ പ്രശ്നങ്ങൾ](../..)
- [ജുപിറ്റർ നോട്ട്‌ബുക്ക് പ്രശ്നങ്ങൾ](../..)
- [പൈത്തൺ പാക്കേജ് പ്രശ്നങ്ങൾ](../..)
- [ആർ പരിസ്ഥിതി പ്രശ്നങ്ങൾ](../..)
- [ക്വിസ് അപ്ലിക്കേഷൻ പ്രശ്നങ്ങൾ](../..)
- [ഡാറ്റയും ഫയൽ പാതയും സംബന്ധിച്ച പ്രശ്നങ്ങൾ](../..)
- [സാധാരണ പിശക് സന്ദേശങ്ങൾ](../..)
- [പ്രകടന പ്രശ്നങ്ങൾ](../..)
- [പരിസ്ഥിതി ക്രമീകരണങ്ങൾ](../..)
---
## ഇൻസ്റ്റലേഷൻ പ്രശ്നങ്ങൾ
### പൈത്തൺ ഇൻസ്റ്റലേഷൻ
**പ്രശ്നം**: `python: command not found`
**പരിഹാരം**:
1. [python.org](https://www.python.org/downloads/) ൽ നിന്ന് Python 3.8 അല്ലെങ്കിൽ അതിനുമുകളിൽ ഇൻസ്റ്റാൾ ചെയ്യുക
2. ഇൻസ്റ്റലേഷൻ സ്ഥിരീകരിക്കുക: `python --version` അല്ലെങ്കിൽ `python3 --version`
3. macOS/Linux-ൽ, `python` പകരം `python3` ഉപയോഗിക്കേണ്ടതുണ്ടാകാം
**പ്രശ്നം**: പല പൈത്തൺ പതിപ്പുകൾ തമ്മിൽ സംഘർഷം ഉണ്ടാകുന്നു
**പരിഹാരം**:
```bash
# പ്രോജക്ടുകൾ വേർതിരിക്കാൻ വെർച്വൽ എൻവയോൺമെന്റുകൾ ഉപയോഗിക്കുക
python -m venv ml-env
# വെർച്വൽ എൻവയോൺമെന്റ് സജീവമാക്കുക
# വിൻഡോസ്-ൽ:
ml-env\Scripts\activate
# മാക്‌ഓഎസ്/ലിനക്സ്-ൽ:
source ml-env/bin/activate
```
### ജുപിറ്റർ ഇൻസ്റ്റലേഷൻ
**പ്രശ്നം**: `jupyter: command not found`
**പരിഹാരം**:
```bash
# Jupyter ഇൻസ്റ്റാൾ ചെയ്യുക
pip install jupyter
# അല്ലെങ്കിൽ pip3 ഉപയോഗിച്ച്
pip3 install jupyter
# ഇൻസ്റ്റലേഷൻ സ്ഥിരീകരിക്കുക
jupyter --version
```
**പ്രശ്നം**: ജുപിറ്റർ ബ്രൗസറിൽ ആരംഭിക്കുന്നില്ല
**പരിഹാരം**:
```bash
# ബ്രൗസർ വ്യക്തമാക്കാൻ ശ്രമിക്കുക
jupyter notebook --browser=chrome
# അല്ലെങ്കിൽ ടർമിനലിൽ നിന്നുള്ള ടോക്കൺ ഉള്ള URL കോപ്പി ചെയ്ത് ബ്രൗസറിൽ കൈയോടെ പേസ്റ്റ് ചെയ്യുക
# ഇതു നോക്കുക: http://localhost:8888/?token=...
```
### ആർ ഇൻസ്റ്റലേഷൻ
**പ്രശ്നം**: ആർ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയുന്നില്ല
**പരിഹാരം**:
```r
# നിങ്ങൾക്കുള്ള ഏറ്റവും പുതിയ R പതിപ്പ് ഉറപ്പാക്കുക
# ആശ്രിതങ്ങളോടുകൂടിയ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക
install.packages(c("tidyverse", "tidymodels", "caret"), dependencies = TRUE)
# സംയോജനം പരാജയപ്പെട്ടാൽ, ബൈനറി പതിപ്പുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ ശ്രമിക്കുക
install.packages("package-name", type = "binary")
```
**പ്രശ്നം**: ജുപിറ്ററിൽ IRkernel ലഭ്യമല്ല
**പരിഹാരം**:
```r
# R കൺസോളിൽ
install.packages('IRkernel')
IRkernel::installspec(user = TRUE)
```
---
## ജുപിറ്റർ നോട്ട്‌ബുക്ക് പ്രശ്നങ്ങൾ
### കർണൽ പ്രശ്നങ്ങൾ
**പ്രശ്നം**: കർണൽ തുടർച്ചയായി മരിക്കുന്നു അല്ലെങ്കിൽ പുനരാരംഭിക്കുന്നു
**പരിഹാരം**:
1. കർണൽ പുനരാരംഭിക്കുക: `Kernel → Restart`
2. ഔട്ട്പുട്ട് മായ്ച്ചു പുനരാരംഭിക്കുക: `Kernel → Restart & Clear Output`
3. മെമ്മറി പ്രശ്നങ്ങൾ പരിശോധിക്കുക ([Performance Issues](../..) കാണുക)
4. പ്രശ്നമുള്ള കോഡ് കണ്ടെത്താൻ സെല്ലുകൾ ഒറ്റയ്ക്ക് ഓടിക്കുക
**പ്രശ്നം**: തെറ്റായ പൈത്തൺ കർണൽ തിരഞ്ഞെടുക്കപ്പെട്ടിരിക്കുന്നു
**പരിഹാരം**:
1. നിലവിലെ കർണൽ പരിശോധിക്കുക: `Kernel → Change Kernel`
2. ശരിയായ പൈത്തൺ പതിപ്പ് തിരഞ്ഞെടുക്കുക
3. കർണൽ കാണാനില്ലെങ്കിൽ, സൃഷ്ടിക്കുക:
```bash
python -m ipykernel install --user --name=ml-env
```
**പ്രശ്നം**: കർണൽ ആരംഭിക്കുന്നില്ല
**പരിഹാരം**:
```bash
# ipykernel പുനഃസ്ഥാപിക്കുക
pip uninstall ipykernel
pip install ipykernel
# കർണൽ വീണ്ടും രജിസ്റ്റർ ചെയ്യുക
python -m ipykernel install --user
```
### നോട്ട്‌ബുക്ക് സെൽ പ്രശ്നങ്ങൾ
**പ്രശ്നം**: സെല്ലുകൾ ഓടുന്നു, പക്ഷേ ഔട്ട്പുട്ട് കാണിക്കുന്നില്ല
**പരിഹാരം**:
1. സെൽ ഇപ്പോഴും ഓടുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക (`[*]` സൂചകം നോക്കുക)
2. കർണൽ പുനരാരംഭിച്ച് എല്ലാ സെല്ലുകളും ഓടിക്കുക: `Kernel → Restart & Run All`
3. ബ്രൗസർ കോൺസോളിൽ ജാവാസ്ക്രിപ്റ്റ് പിശകുകൾ പരിശോധിക്കുക (F12)
**പ്രശ്നം**: സെല്ലുകൾ ഓടിക്കാൻ കഴിയുന്നില്ല - "Run" ക്ലിക്കുചെയ്യുമ്പോൾ പ്രതികരണം ഇല്ല
**പരിഹാരം**:
1. ടർമിനലിൽ ജുപിറ്റർ സർവർ ഇപ്പോഴും ഓടുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക
2. ബ്രൗസർ പേജ് റിഫ്രഷ് ചെയ്യുക
3. നോട്ട്‌ബുക്ക് അടച്ച് വീണ്ടും തുറക്കുക
4. ജുപിറ്റർ സർവർ പുനരാരംഭിക്കുക
---
## പൈത്തൺ പാക്കേജ് പ്രശ്നങ്ങൾ
### ഇറക്കുമതി പിശകുകൾ
**പ്രശ്നം**: `ModuleNotFoundError: No module named 'sklearn'`
**പരിഹാരം**:
```bash
pip install scikit-learn
# ഈ കോഴ്‌സിനുള്ള സാധാരണ ML പാക്കേജുകൾ
pip install scikit-learn pandas numpy matplotlib seaborn
```
**പ്രശ്നം**: `ImportError: cannot import name 'X' from 'sklearn'`
**പരിഹാരം**:
```bash
# scikit-learn ഏറ്റവും പുതിയ പതിപ്പിലേക്ക് അപ്ഡേറ്റ് ചെയ്യുക
pip install --upgrade scikit-learn
# പതിപ്പ് പരിശോധിക്കുക
python -c "import sklearn; print(sklearn.__version__)"
```
### പതിപ്പ് സംഘർഷങ്ങൾ
**പ്രശ്നം**: പാക്കേജ് പതിപ്പ് അസമർത്ഥത പിശകുകൾ
**പരിഹാരം**:
```bash
# പുതിയ ഒരു വെർച്വൽ എൻവയോൺമെന്റ് സൃഷ്ടിക്കുക
python -m venv fresh-env
source fresh-env/bin/activate # അല്ലെങ്കിൽ Windows-ൽ fresh-env\Scripts\activate
# പാക്കേജുകൾ പുതുതായി ഇൻസ്റ്റാൾ ചെയ്യുക
pip install jupyter scikit-learn pandas numpy matplotlib seaborn
# പ്രത്യേക പതിപ്പ് ആവശ്യമെങ്കിൽ
pip install scikit-learn==1.3.0
```
**പ്രശ്നം**: `pip install` അനുമതി പിശകുകളോടെ പരാജയപ്പെടുന്നു
**പരിഹാരം**:
```bash
# നിലവിലെ ഉപയോക്താവിനായി മാത്രമേ ഇൻസ്റ്റാൾ ചെയ്യൂ
pip install --user package-name
# അല്ലെങ്കിൽ വെർച്വൽ എൻവയോൺമെന്റ് ഉപയോഗിക്കുക (ശുപാർശ ചെയ്യുന്നു)
python -m venv venv
source venv/bin/activate
pip install package-name
```
### ഡാറ്റ ലോഡിംഗ് പ്രശ്നങ്ങൾ
**പ്രശ്നം**: CSV ഫയലുകൾ ലോഡ് ചെയ്യുമ്പോൾ `FileNotFoundError`
**പരിഹാരം**:
```python
import os
# നിലവിലെ പ്രവർത്തന ഡയറക്ടറി പരിശോധിക്കുക
print(os.getcwd())
# നോട്ട്‌ബുക്ക് സ്ഥിതിചെയ്യുന്ന സ്ഥലത്ത് നിന്ന് സാപേക്ഷ പാതകൾ ഉപയോഗിക്കുക
df = pd.read_csv('../../data/filename.csv')
# അല്ലെങ്കിൽ പൂർണ്ണ പാതകൾ ഉപയോഗിക്കുക
df = pd.read_csv('/full/path/to/data/filename.csv')
```
---
## ആർ പരിസ്ഥിതി പ്രശ്നങ്ങൾ
### പാക്കേജ് ഇൻസ്റ്റലേഷൻ
**പ്രശ്നം**: പാക്കേജ് ഇൻസ്റ്റലേഷൻ കോമ്പൈലേഷൻ പിശകുകളോടെ പരാജയപ്പെടുന്നു
**പരിഹാരം**:
```r
# ബൈനറി പതിപ്പ് ഇൻസ്റ്റാൾ ചെയ്യുക (Windows/macOS)
install.packages("package-name", type = "binary")
# പാക്കേജുകൾ ആവശ്യപ്പെടുന്നുവെങ്കിൽ R ഏറ്റവും പുതിയ പതിപ്പിലേക്ക് അപ്ഡേറ്റ് ചെയ്യുക
# R പതിപ്പ് പരിശോധിക്കുക
R.version.string
# സിസ്റ്റം ആശ്രിതങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുക (Linux)
# Ubuntu/Debian-ക്കായി, ടെർമിനലിൽ:
# sudo apt-get install r-base-dev
```
**പ്രശ്നം**: `tidyverse` ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയുന്നില്ല
**പരിഹാരം**:
```r
# ആദ്യം ആശ്രിതങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുക
install.packages(c("rlang", "vctrs", "pillar"))
# പിന്നീട് tidyverse ഇൻസ്റ്റാൾ ചെയ്യുക
install.packages("tidyverse")
# അല്ലെങ്കിൽ ഘടകങ്ങൾ വ്യക്തിഗതമായി ഇൻസ്റ്റാൾ ചെയ്യുക
install.packages(c("dplyr", "ggplot2", "tidyr", "readr"))
```
### ആർമാർക്ഡൗൺ പ്രശ്നങ്ങൾ
**പ്രശ്നം**: ആർമാർക്ഡൗൺ റെൻഡർ ചെയ്യുന്നില്ല
**പരിഹാരം**:
```r
# rmarkdown ഇൻസ്റ്റാൾ/അപ്ഡേറ്റ് ചെയ്യുക
install.packages("rmarkdown")
# ആവശ്യമെങ്കിൽ pandoc ഇൻസ്റ്റാൾ ചെയ്യുക
install.packages("pandoc")
# PDF ഔട്ട്പുട്ടിനായി tinytex ഇൻസ്റ്റാൾ ചെയ്യുക
install.packages("tinytex")
tinytex::install_tinytex()
```
---
## ക്വിസ് അപ്ലിക്കേഷൻ പ്രശ്നങ്ങൾ
### ബിൽഡ് & ഇൻസ്റ്റലേഷൻ
**പ്രശ്നം**: `npm install` പരാജയപ്പെടുന്നു
**പരിഹാരം**:
```bash
# npm കാഷെ ക്ലിയർ ചെയ്യുക
npm cache clean --force
# node_modules ഉം package-lock.json ഉം നീക്കം ചെയ്യുക
rm -rf node_modules package-lock.json
# വീണ്ടും ഇൻസ്റ്റാൾ ചെയ്യുക
npm install
# ഇതുവരെ പരാജയപ്പെട്ടാൽ, legacy peer deps ഉപയോഗിച്ച് ശ്രമിക്കുക
npm install --legacy-peer-deps
```
**പ്രശ്നം**: പോർട്ട് 8080 ഇതിനകം ഉപയോഗത്തിലാണ്
**പരിഹാരം**:
```bash
# വ്യത്യസ്ത പോർട്ട് ഉപയോഗിക്കുക
npm run serve -- --port 8081
# അല്ലെങ്കിൽ പോർട്ട് 8080 ഉപയോഗിക്കുന്ന പ്രോസസ് കണ്ടെത്തി നശിപ്പിക്കുക
# ലിനക്സ്/മാക്‌ഒഎസ്-ൽ:
lsof -ti:8080 | xargs kill -9
# വിൻഡോസ്-ൽ:
netstat -ano | findstr :8080
taskkill /PID <PID> /F
```
### ബിൽഡ് പിശകുകൾ
**പ്രശ്നം**: `npm run build` പരാജയപ്പെടുന്നു
**പരിഹാരം**:
```bash
# നോഡ്.js പതിപ്പ് പരിശോധിക്കുക (14+ ആയിരിക്കണം)
node --version
# ആവശ്യമെങ്കിൽ നോഡ്.js അപ്ഡേറ്റ് ചെയ്യുക
# പിന്നീട് ക്ലീൻ ഇൻസ്റ്റാൾ ചെയ്യുക
rm -rf node_modules package-lock.json
npm install
npm run build
```
**പ്രശ്നം**: ലിന്റിംഗ് പിശകുകൾ ബിൽഡ് തടയുന്നു
**പരിഹാരം**:
```bash
# സ്വയം പരിഹരിക്കാവുന്ന പ്രശ്നങ്ങൾ പരിഹരിക്കുക
npm run lint -- --fix
# അല്ലെങ്കിൽ താൽക്കാലികമായി ബിൽഡിൽ ലിന്റിംഗ് അപ്രാപ്തമാക്കുക
# (ഉത്പാദനത്തിനായി ശുപാർശ ചെയ്യപ്പെടുന്നില്ല)
```
---
## ഡാറ്റയും ഫയൽ പാതയും സംബന്ധിച്ച പ്രശ്നങ്ങൾ
### പാത പ്രശ്നങ്ങൾ
**പ്രശ്നം**: നോട്ട്‌ബുക്കുകൾ ഓടിക്കുമ്പോൾ ഡാറ്റ ഫയലുകൾ കണ്ടെത്താനാകുന്നില്ല
**പരിഹാരം**:
1. **എപ്പോഴും നോട്ട്‌ബുക്ക് ഉള്ള ഡയറക്ടറിയിൽ നിന്ന് ഓടിക്കുക**
```bash
cd /path/to/lesson/folder
jupyter notebook
```
2. **കോഡിൽ സാപേക്ഷ പാതകൾ പരിശോധിക്കുക**
```python
# നോട്ട്‌ബുക്ക് സ്ഥിതിചെയ്യുന്ന സ്ഥലത്തുനിന്നുള്ള ശരിയായ പാത
df = pd.read_csv('../data/filename.csv')
# നിങ്ങളുടെ ടെർമിനൽ സ്ഥിതിചെയ്യുന്ന സ്ഥലത്തുനിന്നല്ല
```
3. **ആവശ്യമായാൽ പൂർണ്ണ പാതകൾ ഉപയോഗിക്കുക**
```python
import os
base_path = os.path.dirname(os.path.abspath(__file__))
data_path = os.path.join(base_path, 'data', 'filename.csv')
```
### ഡാറ്റ ഫയലുകൾ കാണാനില്ല
**പ്രശ്നം**: ഡാറ്റസെറ്റ് ഫയലുകൾ കാണാനില്ല
**പരിഹാരം**:
1. ഡാറ്റ റിപോസിറ്ററിയിൽ ഉണ്ടോ എന്ന് പരിശോധിക്കുക - മിക്ക ഡാറ്റസെറ്റുകളും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്
2. ചില പാഠങ്ങൾ ഡാറ്റ ഡൗൺലോഡ് ചെയ്യേണ്ടതുണ്ടാകാം - പാഠം README പരിശോധിക്കുക
3. ഏറ്റവും പുതിയ മാറ്റങ്ങൾ പുൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക:
```bash
git pull origin main
```
---
## സാധാരണ പിശക് സന്ദേശങ്ങൾ
### മെമ്മറി പിശകുകൾ
**പിശക്**: `MemoryError` അല്ലെങ്കിൽ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുമ്പോൾ കർണൽ മരിക്കുന്നു
**പരിഹാരം**:
```python
# ഡാറ്റ ചങ്കുകളായി ലോഡ് ചെയ്യുക
for chunk in pd.read_csv('large_file.csv', chunksize=10000):
process(chunk)
# അല്ലെങ്കിൽ ആവശ്യമായ കോളങ്ങൾ മാത്രം വായിക്കുക
df = pd.read_csv('file.csv', usecols=['col1', 'col2'])
# പൂർത്തിയാക്കിയപ്പോൾ മെമ്മറി മോചനം ചെയ്യുക
del large_dataframe
import gc
gc.collect()
```
### കോൺവെർജൻസ് മുന്നറിയിപ്പുകൾ
**മുന്നറിയിപ്പ്**: `ConvergenceWarning: Maximum number of iterations reached`
**പരിഹാരം**:
```python
from sklearn.linear_model import LogisticRegression
# പരമാവധി ആവർത്തനങ്ങൾ വർദ്ധിപ്പിക്കുക
model = LogisticRegression(max_iter=1000)
# അല്ലെങ്കിൽ ആദ്യം നിങ്ങളുടെ ഫീച്ചറുകൾ സ്കെയിൽ ചെയ്യുക
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
```
### പ്ലോട്ടിംഗ് പ്രശ്നങ്ങൾ
**പ്രശ്നം**: ജുപിറ്ററിൽ പ്ലോട്ടുകൾ കാണിക്കുന്നില്ല
**പരിഹാരം**:
```python
# ഇൻലൈൻ പ്ലോട്ടിംഗ് സജ്ജമാക്കുക
%matplotlib inline
# pyplot ഇറക്കുമതി ചെയ്യുക
import matplotlib.pyplot as plt
# പ്ലോട്ട് വ്യക്തമായി കാണിക്കുക
plt.plot(data)
plt.show()
```
**പ്രശ്നം**: Seaborn പ്ലോട്ടുകൾ വ്യത്യസ്തമായി കാണപ്പെടുന്നു അല്ലെങ്കിൽ പിശകുകൾ കാണിക്കുന്നു
**പരിഹാരം**:
```python
import warnings
warnings.filterwarnings('ignore', category=UserWarning)
# അനുയോജ്യമായ പതിപ്പിലേക്ക് അപ്ഡേറ്റ് ചെയ്യുക
# pip install --upgrade seaborn matplotlib
```
### യൂണികോഡ്/എൻകോഡിംഗ് പിശകുകൾ
**പ്രശ്നം**: ഫയലുകൾ വായിക്കുമ്പോൾ `UnicodeDecodeError`
**പരിഹാരം**:
```python
# എൻകോഡിംഗ് വ്യക്തമായി വ്യക്തമാക്കുക
df = pd.read_csv('file.csv', encoding='utf-8')
# അല്ലെങ്കിൽ വ്യത്യസ്ത എൻകോഡിംഗ് പരീക്ഷിക്കുക
df = pd.read_csv('file.csv', encoding='latin-1')
# പ്രശ്നമുള്ള അക്ഷരങ്ങൾ ഒഴിവാക്കാൻ errors='ignore' ഉപയോഗിക്കുക
df = pd.read_csv('file.csv', encoding='utf-8', errors='ignore')
```
---
## പ്രകടന പ്രശ്നങ്ങൾ
### നോട്ട്‌ബുക്ക് ഓടിക്കൽ മന്ദഗതിയിലാണ്
**പ്രശ്നം**: നോട്ട്‌ബുക്കുകൾ ഓടിക്കാൻ വളരെ മന്ദമാണ്
**പരിഹാരം**:
1. **മെമ്മറി മോചിപ്പിക്കാൻ കർണൽ പുനരാരംഭിക്കുക**: `Kernel → Restart`
2. **ഉപയോഗിക്കാത്ത നോട്ട്‌ബുക്കുകൾ അടയ്ക്കുക**
3. **പരീക്ഷണത്തിനായി ചെറിയ ഡാറ്റ സാമ്പിളുകൾ ഉപയോഗിക്കുക**:
```python
# വികസനത്തിനിടെ ഉപസമൂഹത്തോടൊപ്പം പ്രവർത്തിക്കുക
df_sample = df.sample(n=1000)
```
4. **ബോട്ടിൽനെക്കുകൾ കണ്ടെത്താൻ നിങ്ങളുടെ കോഡ് പ്രൊഫൈൽ ചെയ്യുക**:
```python
%time operation() # ഏകക പ്രവർത്തന സമയം
%timeit operation() # പല റൺസുകളോടെയുള്ള സമയം
```
### ഉയർന്ന മെമ്മറി ഉപയോഗം
**പ്രശ്നം**: സിസ്റ്റം മെമ്മറി തീരുന്നു
**പരിഹാരം**:
```python
# മെമ്മറി ഉപയോഗം പരിശോധിക്കുക
df.info(memory_usage='deep')
# ഡാറ്റാ ടൈപ്പുകൾ മെച്ചപ്പെടുത്തുക
df['column'] = df['column'].astype('int32') # int64 പകരം
# അനാവശ്യ കോളങ്ങൾ ഒഴിവാക്കുക
df = df[['col1', 'col2']] # ആവശ്യമായ കോളങ്ങൾ മാത്രം സൂക്ഷിക്കുക
# ബാച്ചുകളായി പ്രോസസ്സ് ചെയ്യുക
for batch in np.array_split(df, 10):
process(batch)
```
---
## പരിസ്ഥിതി ക്രമീകരണങ്ങൾ
### വെർച്വൽ പരിസ്ഥിതി പ്രശ്നങ്ങൾ
**പ്രശ്നം**: വെർച്വൽ പരിസ്ഥിതി സജീവമാകുന്നില്ല
**പരിഹാരം**:
```bash
# വിൻഡോസ്
python -m venv venv
venv\Scripts\activate.bat
# മാക്‌ഒഎസ്/ലിനക്സ്
python3 -m venv venv
source venv/bin/activate
# സജീവമാണോ എന്ന് പരിശോധിക്കുക (പ്രോംപ്റ്റിൽ venv നാമം കാണിക്കണം)
which python # venv പൈത്തൺ കാണിക്കണം
```
**പ്രശ്നം**: പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്തിട്ടും നോട്ട്‌ബുക്കിൽ കാണുന്നില്ല
**പരിഹാരം**:
```bash
# നോട്ട്‌ബുക്ക് ശരിയായ കർണൽ ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക
# നിങ്ങളുടെ വിർച്വൽ എൻവയോൺമെന്റിൽ ipykernel ഇൻസ്റ്റാൾ ചെയ്യുക
pip install ipykernel
python -m ipykernel install --user --name=ml-env --display-name="Python (ml-env)"
# Jupyter-ൽ: Kernel → Change Kernel → Python (ml-env)
```
### Git പ്രശ്നങ്ങൾ
**പ്രശ്നം**: ഏറ്റവും പുതിയ മാറ്റങ്ങൾ പുൾ ചെയ്യാൻ കഴിയുന്നില്ല - മർജ് സംഘർഷങ്ങൾ
**പരിഹാരം**:
```bash
# നിങ്ങളുടെ മാറ്റങ്ങൾ സ്റ്റാഷ് ചെയ്യുക
git stash
# ഏറ്റവും പുതിയത് പുൾ ചെയ്യുക
git pull origin main
# നിങ്ങളുടെ മാറ്റങ്ങൾ വീണ്ടും പ്രയോഗിക്കുക
git stash pop
# സംഘർഷങ്ങൾ ഉണ്ടെങ്കിൽ, കൈമാറി പരിഹരിക്കുക അല്ലെങ്കിൽ:
git checkout --theirs path/to/file # റിമോട്ട് പതിപ്പ് സ്വീകരിക്കുക
git checkout --ours path/to/file # നിങ്ങളുടെ പതിപ്പ് നിലനിർത്തുക
```
### VS കോഡ് ഇന്റഗ്രേഷൻ
**പ്രശ്നം**: ജുപിറ്റർ നോട്ട്‌ബുക്കുകൾ VS കോഡിൽ തുറക്കാനാകുന്നില്ല
**പരിഹാരം**:
1. VS കോഡിൽ Python എക്സ്റ്റൻഷൻ ഇൻസ്റ്റാൾ ചെയ്യുക
2. VS കോഡിൽ Jupyter എക്സ്റ്റൻഷൻ ഇൻസ്റ്റാൾ ചെയ്യുക
3. ശരിയായ Python ഇന്റർപ്രിറ്റർ തിരഞ്ഞെടുക്കുക: `Ctrl+Shift+P` → "Python: Select Interpreter"
4. VS കോഡ് പുനരാരംഭിക്കുക
---
## അധിക സ്രോതസുകൾ
- **Discord Discussions**: [#ml-for-beginners ചാനലിൽ ചോദ്യങ്ങൾ ചോദിക്കുകയും പരിഹാരങ്ങൾ പങ്കുവെക്കുകയും ചെയ്യുക](https://aka.ms/foundry/discord)
- **Microsoft Learn**: [ML for Beginners മോഡ്യൂളുകൾ](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
- **വീഡിയോ ട്യൂട്ടോറിയലുകൾ**: [YouTube പ്ലേലിസ്റ്റ്](https://aka.ms/ml-beginners-videos)
- **ഇഷ്യൂ ട്രാക്കർ**: [പിശകുകൾ റിപ്പോർട്ട് ചെയ്യുക](https://github.com/microsoft/ML-For-Beginners/issues)
---
## ഇപ്പോഴും പ്രശ്നങ്ങളുണ്ടോ?
മുകളിൽ നൽകിയ പരിഹാരങ്ങൾ പരീക്ഷിച്ചിട്ടും പ്രശ്നങ്ങൾ തുടരുകയാണെങ്കിൽ:
1. **ഇതിനുമുമ്പുള്ള പ്രശ്നങ്ങൾ തിരയുക**: [GitHub Issues](https://github.com/microsoft/ML-For-Beginners/issues)
2. **Discord-ൽ ചർച്ചകൾ പരിശോധിക്കുക**: [Discord Discussions](https://aka.ms/foundry/discord)
3. **പുതിയ പ്രശ്നം തുറക്കുക**: ഉൾപ്പെടുത്തുക:
- നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റവും പതിപ്പും
- Python/R പതിപ്പ്
- പിശക് സന്ദേശം (പൂർണ്ണ ട്രേസ്ബാക്ക്)
- പ്രശ്നം പുനരാവർത്തിപ്പെടുത്താനുള്ള ഘട്ടങ്ങൾ
- നിങ്ങൾ ഇതിനകം പരീക്ഷിച്ച കാര്യങ്ങൾ
ഞങ്ങൾ സഹായിക്കാൻ ഇവിടെ ഉണ്ടാകുന്നു! 🚀
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കപ്പെടണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

59
translations/ml/docs/_sidebar.md
Unescape View File

@ -0,0 +1,59 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "68dd06c685f6ce840e0acfa313352e7c",
"translation_date": "2025-12-19T13:10:14+00:00",
"source_file": "docs/_sidebar.md",
"language_code": "ml"
}
-->
- പരിചയം
- [മെഷീൻ ലേണിങ്ങിലേക്ക് പരിചയം](../1-Introduction/1-intro-to-ML/README.md)
- [മെഷീൻ ലേണിങ്ങിന്റെ ചരിത്രം](../1-Introduction/2-history-of-ML/README.md)
- [എംഎൽയും നീതിയും](../1-Introduction/3-fairness/README.md)
- [എംഎൽ സാങ്കേതികവിദ്യകൾ](../1-Introduction/4-techniques-of-ML/README.md)
- റെഗ്രഷൻ
- [വ്യാപാര ഉപകരണങ്ങൾ](../2-Regression/1-Tools/README.md)
- [ഡാറ്റ](../2-Regression/2-Data/README.md)
- [രേഖീയ റെഗ്രഷൻ](../2-Regression/3-Linear/README.md)
- [ലോജിസ്റ്റിക് റെഗ്രഷൻ](../2-Regression/4-Logistic/README.md)
- വെബ് ആപ്പ് നിർമ്മിക്കുക
- [വെബ് ആപ്പ്](../3-Web-App/1-Web-App/README.md)
- വർഗ്ഗീകരണം
- [വർഗ്ഗീകരണത്തിലേക്ക് പരിചയം](../4-Classification/1-Introduction/README.md)
- [വർഗ്ഗീകരണ ഉപകരണങ്ങൾ 1](../4-Classification/2-Classifiers-1/README.md)
- [വർഗ്ഗീകരണ ഉപകരണങ്ങൾ 2](../4-Classification/3-Classifiers-2/README.md)
- [പ്രയോഗിച്ച എംഎൽ](../4-Classification/4-Applied/README.md)
- ക്ലസ്റ്ററിംഗ്
- [നിങ്ങളുടെ ഡാറ്റ ദൃശ്യവൽക്കരിക്കുക](../5-Clustering/1-Visualize/README.md)
- [കെ-മീൻസ്](../5-Clustering/2-K-Means/README.md)
- എൻഎൽപി
- [എൻഎൽപിയിലേക്ക് പരിചയം](../6-NLP/1-Introduction-to-NLP/README.md)
- [എൻഎൽപി ടാസ്കുകൾ](../6-NLP/2-Tasks/README.md)
- [ഭാഷാന്തരംയും മനോഭാവവും](../6-NLP/3-Translation-Sentiment/README.md)
- [ഹോട്ടൽ റിവ്യൂസ് 1](../6-NLP/4-Hotel-Reviews-1/README.md)
- [ഹോട്ടൽ റിവ്യൂസ് 2](../6-NLP/5-Hotel-Reviews-2/README.md)
- ടൈം സീരീസ് ഫോറ്കാസ്റ്റിംഗ്
- [ടൈം സീരീസ് ഫോറ്കാസ്റ്റിംഗിലേക്ക് പരിചയം](../7-TimeSeries/1-Introduction/README.md)
- [എറിമ](../7-TimeSeries/2-ARIMA/README.md)
- [എസ്‌വി‌ആർ](../7-TimeSeries/3-SVR/README.md)
- റീഇൻഫോഴ്‌സ്‌മെന്റ് ലേണിംഗ്
- [ക്യു-ലേണിംഗ്](../8-Reinforcement/1-QLearning/README.md)
- [ജിം](../8-Reinforcement/2-Gym/README.md)
- യഥാർത്ഥ ലോക എംഎൽ
- [പ്രയോഗങ്ങൾ](../9-Real-World/1-Applications/README.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

39
translations/ml/for-teachers.md
Unescape View File

@ -0,0 +1,39 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "b37de02054fa6c0438ede6fabe1fdfb8",
"translation_date": "2025-12-19T12:26:43+00:00",
"source_file": "for-teachers.md",
"language_code": "ml"
}
-->
## അധ്യാപകര്‍ക്കായി
ഈ പാഠ്യപദ്ധതി നിങ്ങളുടെ ക്ലാസ്സില്‍ ഉപയോഗിക്കണോ? ദയവായി സ്വതന്ത്രമായി ഉപയോഗിക്കൂ!
വാസ്തവത്തില്‍, GitHub Classroom ഉപയോഗിച്ച് GitHub-ലും ഇത് ഉപയോഗിക്കാം.
അതിനായി, ഈ റിപോ ഫോര്‍ക്ക് ചെയ്യുക. ഓരോ പാഠത്തിനും ഒരു റിപോ സൃഷ്ടിക്കേണ്ടതുണ്ട്, അതിനാല്‍ ഓരോ ഫോള്‍ഡറും വേര്‍പെടുത്തി ഒരു റിപോ ആയി മാറ്റേണ്ടതുണ്ട്. അങ്ങനെ, [GitHub Classroom](https://classroom.github.com/classrooms) ഓരോ പാഠവും വേര്‍പെടുത്തി സ്വീകരിക്കാം.
ഈ [പൂര്‍ണ നിര്‍ദ്ദേശങ്ങള്‍](https://github.blog/2020-03-18-set-up-your-digital-classroom-with-github-classroom/) നിങ്ങളുടെ ക്ലാസ്സ്‌റൂം എങ്ങനെ സജ്ജമാക്കാമെന്ന് ഒരു ആശയം നല്‍കും.
## നിലവിലുള്ള റിപോ ഉപയോഗിക്കുന്നത്
GitHub Classroom ഉപയോഗിക്കാതെ ഈ റിപോ നിലവിലുള്ള രൂപത്തില്‍ ഉപയോഗിക്കണമെങ്കില്‍ അത് സാധ്യമാണ്. ഏത് പാഠം ഒന്നിച്ച് പഠിക്കണമെന്ന് നിങ്ങളുടെ വിദ്യാര്‍ത്ഥികളുമായി സംവദിക്കേണ്ടതുണ്ട്.
ഓണ്‍ലൈന്‍ ഫോര്‍മാറ്റില്‍ (Zoom, Teams, അല്ലെങ്കില്‍ മറ്റേതെങ്കിലും) ക്വിസുകള്‍ക്കായി ബ്രേക്ക്ഔട്ട് റൂമുകള്‍ രൂപീകരിച്ച്, വിദ്യാര്‍ത്ഥികളെ പഠനത്തിന് തയ്യാറാക്കാന്‍ മെന്റര്‍ ചെയ്യാം. പിന്നീട് ക്വിസുകള്‍ക്ക് വിദ്യാര്‍ത്ഥികളെ ക്ഷണിച്ച്, ഒരു നിശ്ചിത സമയത്ത് അവരുടെ ഉത്തരം 'issues' ആയി സമര്‍പ്പിക്കാം. സമാനമായി അസൈന്‍മെന്റുകള്‍ കൂടി, വിദ്യാര്‍ത്ഥികള്‍ തുറന്നിടത്ത് സഹകരിച്ച് പ്രവര്‍ത്തിക്കാന്‍ ആഗ്രഹിക്കുന്നുവെങ്കില്‍ ചെയ്യാം.
കൂടുതല്‍ സ്വകാര്യമായ ഫോര്‍മാറ്റ് ഇഷ്ടപ്പെടുന്നുവെങ്കില്‍, നിങ്ങളുടെ വിദ്യാര്‍ത്ഥികളെ പാഠംപ്രതി ഈ പാഠ്യപദ്ധതി ഫോര്‍ക്ക് ചെയ്ത് അവരുടെ സ്വന്തം GitHub റിപോകളില്‍ സ്വകാര്യ റിപോകളായി സൃഷ്ടിച്ച് നിങ്ങള്‍ക്ക് ആക്‌സസ് നല്‍കാന്‍ പറയുക. പിന്നീട് അവർ ക്വിസുകളും അസൈന്‍മെന്റുകളും സ്വകാര്യമായി പൂര്‍ത്തിയാക്കി നിങ്ങളുടെ ക്ലാസ്സ്‌റൂം റിപോയിലെ issues വഴി സമര്‍പ്പിക്കാം.
ഓണ്‍ലൈന്‍ ക്ലാസ്സ്‌റൂം ഫോര്‍മാറ്റില്‍ ഇത് പ്രവര്‍ത്തിപ്പിക്കാന്‍ നിരവധി മാര്‍ഗ്ഗങ്ങളുണ്ട്. നിങ്ങള്‍ക്ക് ഏറ്റവും അനുയോജ്യമായത് എന്താണെന്ന് ഞങ്ങളെ അറിയിക്കുക!
## ദയവായി നിങ്ങളുടെ അഭിപ്രായങ്ങള്‍ നല്‍കൂ!
ഈ പാഠ്യപദ്ധതി നിങ്ങളുടെയും നിങ്ങളുടെ വിദ്യാര്‍ത്ഥികളുടെയും ആവശ്യങ്ങള്‍ക്ക് അനുയോജ്യമായതാക്കാന്‍ ഞങ്ങള്‍ ആഗ്രഹിക്കുന്നു. ദയവായി ഞങ്ങള്‍ക്ക് [പ്രതികരണം](https://forms.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR2humCsRZhxNuI79cm6n0hRUQzRVVU9VVlU5UlFLWTRLWlkyQUxORTg5WS4u) നല്‍കൂ.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് കരുതേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ വ്യാഖ്യാനക്കേടുകൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

128
translations/ml/quiz-app/README.md
Unescape View File

@ -0,0 +1,128 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "6d130dffca5db70d7e615f926cb1ad4c",
"translation_date": "2025-12-19T13:01:04+00:00",
"source_file": "quiz-app/README.md",
"language_code": "ml"
}
-->
# ക്വിസുകൾ
ഈ ക്വിസുകൾ https://aka.ms/ml-beginners ലെ ML പാഠ്യപദ്ധതിക്കുള്ള പ്രീ-ലക്ചർ, പോസ്റ്റ്-ലക്ചർ ക്വിസുകളാണ്
## പ്രോജക്ട് സജ്ജീകരണം
```
npm install
```
### വികസനത്തിനായി കോമ്പൈൽ ചെയ്ത് ഹോട്ട്-റീലോഡ് ചെയ്യുന്നു
```
npm run serve
```
### ഉത്പാദനത്തിനായി കോമ്പൈൽ ചെയ്ത് മിനിഫൈ ചെയ്യുന്നു
```
npm run build
```
### ഫയലുകൾ ലിന്റ് ചെയ്ത് ശരിയാക്കുന്നു
```
npm run lint
```
### കോൺഫിഗറേഷൻ ഇഷ്ടാനുസൃതമാക്കുക
കാണുക [Configuration Reference](https://cli.vuejs.org/config/) .
ക്രെഡിറ്റുകൾ: ഈ ക്വിസ് ആപ്പിന്റെ ഒറിജിനൽ വേർഷനിന് നന്ദി: https://github.com/arpan45/simple-quiz-vue
## Azure-ലേക്ക് ഡിപ്ലോയ് ചെയ്യൽ
തുടങ്ങാൻ സഹായിക്കുന്ന ഘട്ടം-ഘട്ടമായ മാർഗ്ഗനിർദ്ദേശം:
1. GitHub റിപോസിറ്ററി ഫോർക്ക് ചെയ്യുക
നിങ്ങളുടെ സ്റ്റാറ്റിക് വെബ് ആപ്പ് കോഡ് നിങ്ങളുടെ GitHub റിപോസിറ്ററിയിൽ ഉണ്ടെന്ന് ഉറപ്പാക്കുക. ഈ റിപോസിറ്ററി ഫോർക്ക് ചെയ്യുക.
2. Azure സ്റ്റാറ്റിക് വെബ് ആപ്പ് സൃഷ്ടിക്കുക
- ഒരു [Azure അക്കൗണ്ട്](http://azure.microsoft.com) സൃഷ്ടിക്കുക
- [Azure പോർട്ടൽ](https://portal.azure.com) സന്ദർശിക്കുക
- “Create a resource” ക്ലിക്ക് ചെയ്ത് “Static Web App” തിരയുക.
- “Create” ക്ലിക്ക് ചെയ്യുക.
3. സ്റ്റാറ്റിക് വെബ് ആപ്പ് കോൺഫിഗർ ചെയ്യുക
- അടിസ്ഥാനങ്ങൾ: സബ്സ്ക്രിപ്ഷൻ: നിങ്ങളുടെ Azure സബ്സ്ക്രിപ്ഷൻ തിരഞ്ഞെടുക്കുക.
- റിസോഴ്‌സ് ഗ്രൂപ്പ്: പുതിയ റിസോഴ്‌സ് ഗ്രൂപ്പ് സൃഷ്ടിക്കുക അല്ലെങ്കിൽ നിലവിലുള്ളത് ഉപയോഗിക്കുക.
- പേര്: നിങ്ങളുടെ സ്റ്റാറ്റിക് വെബ് ആപ്പിന് ഒരു പേര് നൽകുക.
- പ്രദേശം: നിങ്ങളുടെ ഉപയോക്താക്കൾക്ക് ഏറ്റവും അടുത്ത പ്രദേശം തിരഞ്ഞെടുക്കുക.
- #### ഡിപ്ലോയ്മെന്റ് വിശദാംശങ്ങൾ:
- സോഴ്‌സ്: “GitHub” തിരഞ്ഞെടുക്കുക.
- GitHub അക്കൗണ്ട്: Azure-ന് നിങ്ങളുടെ GitHub അക്കൗണ്ടിൽ പ്രവേശനം അനുവദിക്കുക.
- ഓർഗനൈസേഷൻ: നിങ്ങളുടെ GitHub ഓർഗനൈസേഷൻ തിരഞ്ഞെടുക്കുക.
- റിപോസിറ്ററി: നിങ്ങളുടെ സ്റ്റാറ്റിക് വെബ് ആപ്പ് ഉള്ള റിപോസിറ്ററി തിരഞ്ഞെടുക്കുക.
- ബ്രാഞ്ച്: ഡിപ്ലോയ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ബ്രാഞ്ച് തിരഞ്ഞെടുക്കുക.
- #### ബിൽഡ് വിശദാംശങ്ങൾ:
- ബിൽഡ് പ്രീസെറ്റുകൾ: നിങ്ങളുടെ ആപ്പ് നിർമ്മിച്ച ഫ്രെയിംവർക്ക് തിരഞ്ഞെടുക്കുക (ഉദാ: React, Angular, Vue, മുതലായവ).
- ആപ്പ് ലൊക്കേഷൻ: നിങ്ങളുടെ ആപ്പ് കോഡ് ഉള്ള ഫോൾഡർ വ്യക്തമാക്കുക (ഉദാ: റൂട്ട്-ൽ ആണെങ്കിൽ /).
- API ലൊക്കേഷൻ: API ഉണ്ടെങ്കിൽ, അതിന്റെ സ്ഥലം വ്യക്തമാക്കുക (ഐച്ഛികം).
- ഔട്ട്പുട്ട് ലൊക്കേഷൻ: ബിൽഡ് ഔട്ട്പുട്ട് സൃഷ്ടിക്കുന്ന ഫോൾഡർ വ്യക്തമാക്കുക (ഉദാ: build അല്ലെങ്കിൽ dist).
4. അവലോകനം ചെയ്ത് സൃഷ്ടിക്കുക
നിങ്ങളുടെ ക്രമീകരണങ്ങൾ അവലോകനം ചെയ്ത് “Create” ക്ലിക്ക് ചെയ്യുക. Azure ആവശ്യമായ റിസോഴ്‌സുകൾ സജ്ജമാക്കി GitHub Actions വർക്ക്‌ഫ്ലോ നിങ്ങളുടെ റിപോസിറ്ററിയിൽ സൃഷ്ടിക്കും.
5. GitHub Actions വർക്ക്‌ഫ്ലോ
Azure സ്വയം GitHub Actions വർക്ക്‌ഫ്ലോ ഫയൽ നിങ്ങളുടെ റിപോസിറ്ററിയിൽ (.github/workflows/azure-static-web-apps-<name>.yml) സൃഷ്ടിക്കും. ഈ വർക്ക്‌ഫ്ലോ ബിൽഡ്, ഡിപ്ലോയ്മെന്റ് പ്രക്രിയ കൈകാര്യം ചെയ്യും.
6. ഡിപ്ലോയ്മെന്റ് നിരീക്ഷിക്കുക
നിങ്ങളുടെ GitHub റിപോസിറ്ററിയിലെ “Actions” ടാബിലേക്ക് പോകുക.
ഒരു വർക്ക്‌ഫ്ലോ പ്രവർത്തിക്കുന്നതായി കാണണം. ഈ വർക്ക്‌ഫ്ലോ നിങ്ങളുടെ സ്റ്റാറ്റിക് വെബ് ആപ്പ് Azure-ലേക്ക് ബിൽഡ് ചെയ്ത് ഡിപ്ലോയ് ചെയ്യും.
വർക്ക്‌ഫ്ലോ പൂർത്തിയായാൽ, നിങ്ങളുടെ ആപ്പ് നൽകിയ Azure URL-ൽ ലൈവായി കാണാം.
### ഉദാഹരണ വർക്ക്‌ഫ്ലോ ഫയൽ
GitHub Actions വർക്ക്‌ഫ്ലോ ഫയൽ എങ്ങനെ കാണാമെന്ന് ഉദാഹരണം:
name: Azure Static Web Apps CI/CD
```
on:
push:
branches:
- main
pull_request:
types: [opened, synchronize, reopened, closed]
branches:
- main
jobs:
build_and_deploy_job:
runs-on: ubuntu-latest
name: Build and Deploy Job
steps:
- uses: actions/checkout@v2
- name: Build And Deploy
id: builddeploy
uses: Azure/static-web-apps-deploy@v1
with:
azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
repo_token: ${{ secrets.GITHUB_TOKEN }}
action: "upload"
app_location: "/quiz-app" # App source code path
api_location: ""API source code path optional
output_location: "dist" #Built app content directory - optional
```
### അധിക സ്രോതസുകൾ
- [Azure Static Web Apps ഡോക്യുമെന്റേഷൻ](https://learn.microsoft.com/azure/static-web-apps/getting-started)
- [GitHub Actions ഡോക്യുമെന്റേഷൻ](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ വ്യാഖ്യാനക്കേടുകൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

203
translations/ml/sketchnotes/LICENSE.md
Unescape View File

@ -0,0 +1,203 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "fba3b94d88bfb9b81369b869a1e9a20f",
"translation_date": "2025-12-19T13:16:39+00:00",
"source_file": "sketchnotes/LICENSE.md",
"language_code": "ml"
}
-->
അട്രിബ്യൂഷൻ-ഷെയർഅലൈക്ക് 4.0 ഇന്റർനാഷണൽ
=======================================================================
ക്രിയേറ്റീവ് കോമൺസ് കോർപ്പറേഷൻ ("ക്രിയേറ്റീവ് കോമൺസ്") ഒരു നിയമ സ്ഥാപനമല്ല, നിയമ സേവനങ്ങൾ അല്ലെങ്കിൽ നിയമ ഉപദേശം നൽകുന്നവയുമല്ല. ക്രിയേറ്റീവ് കോമൺസ് പബ്ലിക് ലൈസൻസുകളുടെ വിതരണം ഒരു അഭിഭാഷക-ക്ലയന്റ് അല്ലെങ്കിൽ മറ്റ് ബന്ധം സൃഷ്ടിക്കുന്നതല്ല. ക്രിയേറ്റീവ് കോമൺസ് അതിന്റെ ലൈസൻസുകളും ബന്ധപ്പെട്ട വിവരങ്ങളും "അസ്സ്-ഇസ്" അടിസ്ഥാനത്തിൽ ലഭ്യമാക്കുന്നു. ക്രിയേറ്റീവ് കോമൺസ് അതിന്റെ ലൈസൻസുകളുമായി ബന്ധപ്പെട്ട്, അവയുടെ നിബന്ധനകൾ പ്രകാരം ലൈസൻസ് ലഭിച്ച ഏതെങ്കിലും വസ്തുവിനും അല്ലെങ്കിൽ ബന്ധപ്പെട്ട വിവരങ്ങൾക്കുമായി യാതൊരു വാറന്റികളും നൽകുന്നില്ല. ക്രിയേറ്റീവ് കോമൺസ് അവയുടെ ഉപയോഗത്തിൽ നിന്നുണ്ടാകുന്ന നാശനഷ്ടങ്ങൾക്ക് പരമാവധി പരിധിയിൽ എല്ലാ ഉത്തരവാദിത്വവും ഒഴിവാക്കുന്നു.
ക്രിയേറ്റീവ് കോമൺസ് പബ്ലിക് ലൈസൻസുകൾ ഉപയോഗിക്കുന്നത്
ക്രിയേറ്റീവ് കോമൺസ് പബ്ലിക് ലൈസൻസുകൾ സൃഷ്ടാക്കൾക്കും മറ്റ് അവകാശ ഉടമകൾക്കും അവരുടേതായ കൃതികൾ, മറ്റ് പകർപ്പവകാശം ഉള്ള വസ്തുക്കൾ, താഴെ പറയുന്ന പബ്ലിക് ലൈസൻസിൽ നിർദ്ദേശിച്ചിട്ടുള്ള ചില മറ്റ് അവകാശങ്ങൾ എന്നിവ പങ്കുവെക്കാൻ ഉപയോഗിക്കാവുന്ന സാധാരണ നിബന്ധനകളും വ്യവസ്ഥകളും നൽകുന്നു. താഴെ പറയുന്ന കാര്യങ്ങൾ വിവരാർത്ഥമാണ് മാത്രമേ, അവ സമ്പൂർണമായവയല്ല, ഞങ്ങളുടെ ലൈസൻസുകളുടെ ഭാഗമല്ല.
ലൈസൻസർമാർക്കുള്ള പരിഗണനകൾ: ഞങ്ങളുടെ പബ്ലിക് ലൈസൻസുകൾ അവകാശം നൽകാൻ അധികാരമുള്ളവർക്കാണ് ഉദ്ദേശിച്ചിരിക്കുന്നത്, അവരുടേതായ വസ്തുക്കൾ പകർപ്പവകാശം ഉൾപ്പെടെയുള്ള ചില അവകാശങ്ങൾ പ്രകാരം നിയന്ത്രിതമായ രീതിയിൽ പൊതുജനങ്ങൾക്ക് ഉപയോഗിക്കാൻ അനുമതി നൽകാൻ. ഞങ്ങളുടെ ലൈസൻസുകൾ മാറ്റാനാകാത്തവയാണ്. ലൈസൻസർമാർ തിരഞ്ഞെടുക്കുന്ന ലൈസൻസിന്റെ നിബന്ധനകളും വ്യവസ്ഥകളും വായിച്ച് മനസ്സിലാക്കണം. ലൈസൻസർമാർ പൊതുജനങ്ങൾ പ്രതീക്ഷിക്കുന്ന വിധത്തിൽ വസ്തു പുനരുപയോഗം ചെയ്യാൻ ആവശ്യമായ എല്ലാ അവകാശങ്ങളും ഉറപ്പാക്കണം. ലൈസൻസിന് വിധേയമല്ലാത്ത വസ്തുക്കൾ വ്യക്തമായി അടയാളപ്പെടുത്തണം. ഇതിൽ മറ്റ് CC-ലൈസൻസുള്ള വസ്തുക്കൾ, അല്ലെങ്കിൽ പകർപ്പവകാശത്തിന് ഉള്ള ഒഴിവുകൾ അല്ലെങ്കിൽ പരിധികൾ പ്രകാരം ഉപയോഗിക്കുന്ന വസ്തുക്കൾ ഉൾപ്പെടുന്നു. കൂടുതൽ പരിഗണനകൾ: wiki.creativecommons.org/Considerations_for_licensors
പൊതുജനങ്ങൾക്ക് പരിഗണനകൾ: ഞങ്ങളുടെ പബ്ലിക് ലൈസൻസുകളിൽ ഒന്നോ അതിലധികമോ ഉപയോഗിച്ച്, ഒരു ലൈസൻസർ ലൈസൻസുചെയ്ത വസ്തു നിർദ്ദിഷ്ട നിബന്ധനകളിൽ പൊതുജനങ്ങൾക്ക് ഉപയോഗിക്കാൻ അനുമതി നൽകുന്നു. ലൈസൻസറുടെ അനുമതി ആവശ്യമായില്ലെങ്കിൽ—ഉദാഹരണത്തിന്, പകർപ്പവകാശത്തിന് ഉള്ള ഏതെങ്കിലും ബാധകമായ ഒഴിവ് അല്ലെങ്കിൽ പരിധി കാരണം—അപ്പോൾ ആ ഉപയോഗം ലൈസൻസിലൂടെ നിയന്ത്രിക്കപ്പെടുന്നില്ല. ഞങ്ങളുടെ ലൈസൻസുകൾ ലൈസൻസറിന് അനുമതി നൽകാനുള്ള പകർപ്പവകാശവും ചില മറ്റ് അവകാശങ്ങളും മാത്രമേ അനുവദിക്കൂ. വസ്തുവിൽ മറ്റുള്ളവർക്കും പകർപ്പവകാശം അല്ലെങ്കിൽ മറ്റ് അവകാശങ്ങൾ ഉണ്ടാകാം, അതിനാൽ ഉപയോഗം മറ്റൊരു കാരണത്താൽ നിയന്ത്രിക്കപ്പെടാം. ലൈസൻസർ പ്രത്യേക അഭ്യർത്ഥനകൾ ഉണ്ടാക്കാം, ഉദാഹരണത്തിന് എല്ലാ മാറ്റങ്ങളും അടയാളപ്പെടുത്തണമെന്നോ വിവരിക്കണമെന്നോ. ഞങ്ങളുടെ ലൈസൻസുകൾ ആവശ്യപ്പെടുന്നില്ലെങ്കിലും, യുക്തമായിടത്ത് ആ അഭ്യർത്ഥനകൾ മാനിക്കണമെന്ന് നിങ്ങൾക്ക് പ്രോത്സാഹനം നൽകുന്നു. കൂടുതൽ പരിഗണനകൾ: wiki.creativecommons.org/Considerations_for_licensees
=======================================================================
ക്രിയേറ്റീവ് കോമൺസ് അട്രിബ്യൂഷൻ-ഷെയർഅലൈക്ക് 4.0 ഇന്റർനാഷണൽ പബ്ലിക് ലൈസൻസ്
ലൈസൻസുചെയ്ത അവകാശങ്ങൾ (താഴെ നിർവചിച്ചവ) പ്രയോഗിച്ച്, നിങ്ങൾ ഈ ക്രിയേറ്റീവ് കോമൺസ് അട്രിബ്യൂഷൻ-ഷെയർഅലൈക്ക് 4.0 ഇന്റർനാഷണൽ പബ്ലിക് ലൈസൻസ് ("പബ്ലിക് ലൈസൻസ്") നിബന്ധനകൾക്ക് വിധേയനായി അംഗീകരിക്കുന്നു. ഈ പബ്ലിക് ലൈസൻസ് ഒരു കരാറായി വ്യാഖ്യാനിക്കപ്പെടുന്ന പരിധിയിൽ, ഈ നിബന്ധനകൾ സ്വീകരിക്കുന്നതിന് പരിഗണനയായി നിങ്ങൾക്ക് ലൈസൻസുചെയ്ത അവകാശങ്ങൾ അനുവദിക്കുന്നു, കൂടാതെ ലൈസൻസർ ഈ നിബന്ധനകൾ പ്രകാരം ലൈസൻസുചെയ്ത വസ്തു ലഭ്യമാക്കുന്നതിൽ നിന്നുള്ള ലാഭങ്ങൾ പരിഗണിച്ച് നിങ്ങൾക്ക് അവകാശങ്ങൾ നൽകുന്നു.
വിഭാഗം 1 -- നിർവചനങ്ങൾ.
a. അഡാപ്റ്റഡ് മെറ്റീരിയൽ എന്നത് പകർപ്പവകാശവും സമാന അവകാശങ്ങളും ബാധിക്കുന്ന, ലൈസൻസുചെയ്ത വസ്തുവിൽ നിന്നോ അതിന്റെ അടിസ്ഥാനത്തിലോ ഉത്ഭവിച്ച, അതിൽ ലൈസൻസുചെയ്ത വസ്തു വിവർത്തനം ചെയ്യപ്പെട്ട, മാറ്റം വരുത്തപ്പെട്ട, ക്രമീകരിച്ച, പരിവർത്തനം ചെയ്ത അല്ലെങ്കിൽ മറ്റേതെങ്കിലും വിധത്തിൽ പകർപ്പവകാശവും സമാന അവകാശങ്ങളും ഉള്ള ലൈസൻസറുടെ അനുമതി ആവശ്യമായ രീതിയിൽ മാറ്റം വരുത്തിയ വസ്തുവിനെ സൂചിപ്പിക്കുന്നു. ഈ പബ്ലിക് ലൈസൻസിന്റെ ഉദ്ദേശ്യത്തിന്, ലൈസൻസുചെയ്ത വസ്തു സംഗീത കൃതി, പ്രകടനം, അല്ലെങ്കിൽ ശബ്ദ രേഖപ്പെടുത്തലായിരിക്കുമ്പോൾ, ലൈസൻസുചെയ്ത വസ്തു ഒരു ചലിക്കുന്ന ചിത്രവുമായി സമയബന്ധിതമായി സിങ്ക് ചെയ്തിരിക്കുന്നിടത്ത് അഡാപ്റ്റഡ് മെറ്റീരിയൽ ഉണ്ടാകുന്നു.
b. അഡാപ്റ്ററുടെ ലൈസൻസ് എന്നത് നിങ്ങൾ ഈ പബ്ലിക് ലൈസൻസിന്റെ നിബന്ധനകൾക്ക് അനുസരിച്ച് അഡാപ്റ്റഡ് മെറ്റീരിയലിൽ നിങ്ങളുടെ സംഭാവനകളിൽ ഉള്ള പകർപ്പവകാശവും സമാന അവകാശങ്ങളിലും പ്രയോഗിക്കുന്ന ലൈസൻസാണ്.
c. BY-SA അനുയോജ്യമായ ലൈസൻസ് എന്നത് creativecommons.org/compatiblelicenses ലിസ്റ്റ് ചെയ്ത, ക്രിയേറ്റീവ് കോമൺസ് ഈ പബ്ലിക് ലൈസൻസിന്റെ തുല്യമായതായി അംഗീകരിച്ച ലൈസൻസാണ്.
d. പകർപ്പവകാശവും സമാന അവകാശങ്ങളും എന്നത് പകർപ്പവകാശം ഉൾപ്പെടെ, പരിമിതികളില്ലാതെ, പ്രകടനം, പ്രക്ഷേപണം, ശബ്ദ രേഖപ്പെടുത്തൽ, Sui Generis ഡാറ്റാബേസ് അവകാശങ്ങൾ എന്നിവ ഉൾപ്പെടുന്ന, അവകാശങ്ങൾ എങ്ങനെ ലേബൽ ചെയ്തിട്ടുള്ളതും വർഗ്ഗീകരിച്ചിട്ടുള്ളതും നോക്കാതെ അടുത്ത ബന്ധമുള്ള അവകാശങ്ങളാണ്. ഈ പബ്ലിക് ലൈസൻസിന്റെ ഉദ്ദേശ്യത്തിന്, വകുപ്പ് 2(b)(1)-(2)ൽ നിർദ്ദേശിച്ച അവകാശങ്ങൾ പകർപ്പവകാശവും സമാന അവകാശങ്ങളും അല്ല.
e. ഫലപ്രദമായ സാങ്കേതിക നടപടികൾ എന്നത്, December 20, 1996-ന് അംഗീകരിച്ച WIPO പകർപ്പവകാശ ഉടമ്പടിയുടെ ആർട്ടിക്കിൾ 11 പ്രകാരം ബാധ്യതകൾ നിറവേറ്റുന്ന നിയമങ്ങൾ പ്രകാരം യഥാർത്ഥ അധികാരമില്ലാതെ മറികടക്കാൻ പാടില്ലാത്ത നടപടികളാണ്.
f. ഒഴിവുകളും പരിധികളും എന്നത് നീതിപൂർവ്വമായ ഉപയോഗം, നീതിപൂർവ്വമായ ഇടപാട്, അല്ലെങ്കിൽ പകർപ്പവകാശവും സമാന അവകാശങ്ങളും ബാധിക്കുന്ന നിങ്ങളുടെ ലൈസൻസുചെയ്ത വസ്തു ഉപയോഗത്തിന് ബാധകമായ മറ്റ് ഏതെങ്കിലും ഒഴിവോ പരിധിയോ ആണ്.
g. ലൈസൻസ് ഘടകങ്ങൾ എന്നത് ക്രിയേറ്റീവ് കോമൺസ് പബ്ലിക് ലൈസൻസിന്റെ പേരിൽ ലിസ്റ്റ് ചെയ്ത ലൈസൻസ് ഗുണങ്ങളാണ്. ഈ പബ്ലിക് ലൈസൻസിന്റെ ലൈസൻസ് ഘടകങ്ങൾ അട്രിബ്യൂഷനും ഷെയർഅലൈക്കും ആണ്.
h. ലൈസൻസുചെയ്ത വസ്തു എന്നത് കലാപരമായ അല്ലെങ്കിൽ സാഹിത്യ കൃതി, ഡാറ്റാബേസ്, അല്ലെങ്കിൽ ലൈസൻസർ ഈ പബ്ലിക് ലൈസൻസ് പ്രയോഗിച്ച മറ്റ് വസ്തുക്കളാണ്.
i. ലൈസൻസുചെയ്ത അവകാശങ്ങൾ എന്നത് ഈ പബ്ലിക് ലൈസൻസിന്റെ നിബന്ധനകൾക്ക് വിധേയമായി നിങ്ങൾക്ക് അനുവദിച്ച അവകാശങ്ങളാണ്, അവ നിങ്ങളുടെ ലൈസൻസുചെയ്ത വസ്തു ഉപയോഗിക്കാൻ ബാധകമായ എല്ലാ പകർപ്പവകാശവും സമാന അവകാശങ്ങളും ഉൾപ്പെടുന്നു, കൂടാതെ ലൈസൻസറിന് അവ ലൈസൻസ് നൽകാനുള്ള അധികാരം ഉള്ളവയാണ്.
j. ലൈസൻസർ എന്നത് ഈ പബ്ലിക് ലൈസൻസ് പ്രകാരം അവകാശങ്ങൾ നൽകുന്ന വ്യക്തി(കൾ) അല്ലെങ്കിൽ സ്ഥാപന(ങ്ങൾ) ആണ്.
k. ഷെയർ എന്നത് ലൈസൻസുചെയ്ത അവകാശങ്ങൾ പ്രകാരം അനുമതി ആവശ്യമായ ഏതെങ്കിലും മാർഗ്ഗം അല്ലെങ്കിൽ പ്രക്രിയ വഴി പൊതുജനങ്ങൾക്ക് വസ്തു നൽകുന്നതും, പകർപ്പിക്കൽ, പൊതു പ്രദർശനം, പൊതു പ്രകടനം, വിതരണം, പ്രചാരം, സംവേദനം, ഇറക്കുമതി എന്നിവ ഉൾപ്പെടുന്നു, കൂടാതെ പൊതുജനങ്ങൾ വ്യക്തിഗതമായി തിരഞ്ഞെടുക്കുന്ന സ്ഥലത്തും സമയത്തും ആ വസ്തു ആക്‌സസ് ചെയ്യാൻ സാധിക്കുന്ന വിധത്തിൽ വസ്തു ലഭ്യമാക്കുന്നതും ആണ്.
l. Sui Generis ഡാറ്റാബേസ് അവകാശങ്ങൾ എന്നത് Directive 96/9/EC, യൂറോപ്യൻ പാർലമെന്റ് ആൻഡ് കൗൺസിൽ 11 മാർച്ച് 1996-ന് ഡാറ്റാബേസുകളുടെ നിയമപരമായ സംരക്ഷണത്തെക്കുറിച്ച് നൽകിയ നിർദ്ദേശം, അതിന്റെ ഭേദഗതികളും/അല്ലെങ്കിൽ പിന്‍ഗാമികളും, കൂടാതെ ലോകമെമ്പാടുമുള്ള സമാന അവകാശങ്ങളും ഉൾപ്പെടുന്നു.
m. നിങ്ങൾ എന്നത് ഈ പബ്ലിക് ലൈസൻസ് പ്രകാരം ലൈസൻസുചെയ്ത അവകാശങ്ങൾ പ്രയോഗിക്കുന്ന വ്യക്തി അല്ലെങ്കിൽ സ്ഥാപനമാണ്. നിങ്ങളുടെ എന്നതിന് അനുയോജ്യമായ അർത്ഥമുണ്ട്.
വിഭാഗം 2 -- പരിധി.
a. ലൈസൻസ് അനുവദിക്കൽ.
1. ഈ പബ്ലിക് ലൈസൻസിന്റെ നിബന്ധനകൾക്ക് വിധേയമായി, ലൈസൻസർ നിങ്ങൾക്ക് ലോകമാകെയുള്ള, റോയൽറ്റി-രഹിത, സബ്-ലൈസൻസ് ചെയ്യാനാകാത്ത, പ്രത്യേകതയില്ലാത്ത, മാറ്റാനാകാത്ത ലൈസൻസ് നൽകുന്നു, ഇതുവഴി നിങ്ങൾക്ക് ലൈസൻസുചെയ്ത വസ്തുവിൽ ലൈസൻസുചെയ്ത അവകാശങ്ങൾ പ്രയോഗിക്കാം:
a. ലൈസൻസുചെയ്ത വസ്തു മുഴുവനായോ ഭാഗികമായോ പകർപ്പിച്ച് ഷെയർ ചെയ്യുക;
b. അഡാപ്റ്റഡ് മെറ്റീരിയൽ നിർമ്മിക്കുക, പകർപ്പിച്ച് ഷെയർ ചെയ്യുക.
2. ഒഴിവുകളും പരിധികളും. നിങ്ങളുടെ ഉപയോഗത്തിന് ഒഴിവുകളും പരിധികളും ബാധകമായിടത്ത്, ഈ പബ്ലിക് ലൈസൻസ് ബാധകമല്ല, അതിന്റെ നിബന്ധനകൾ പാലിക്കേണ്ടതില്ല.
3. കാലാവധി. ഈ പബ്ലിക് ലൈസൻസിന്റെ കാലാവധി വകുപ്പ് 6(a)-ൽ വ്യക്തമാക്കിയിരിക്കുന്നു.
4. മീഡിയയും ഫോർമാറ്റുകളും; സാങ്കേതിക മാറ്റങ്ങൾ അനുവദനീയമാണ്. ലൈസൻസർ നിങ്ങൾക്ക് ഇപ്പോൾ അറിയപ്പെടുന്നോ പിന്നീട് സൃഷ്ടിക്കപ്പെടുന്നോ എല്ലാ മീഡിയകളിലും ഫോർമാറ്റുകളിലും ലൈസൻസുചെയ്ത അവകാശങ്ങൾ പ്രയോഗിക്കാൻ അനുമതി നൽകുന്നു, അതിനായി ആവശ്യമായ സാങ്കേതിക മാറ്റങ്ങൾ ചെയ്യാനും. ലൈസൻസർ നിങ്ങൾക്ക് സാങ്കേതിക മാറ്റങ്ങൾ ചെയ്യുന്നത് തടയാനുള്ള അവകാശം അവകാശപ്പെടുകയോ ഉപയോഗിക്കുകയോ ചെയ്യില്ല, ഫലപ്രദമായ സാങ്കേതിക നടപടികൾ മറികടക്കുന്നതിനുള്ള സാങ്കേതിക മാറ്റങ്ങളും ഉൾപ്പെടെ. ഈ വകുപ്പ് 2(a)(4) പ്രകാരം അനുവദിച്ച മാറ്റങ്ങൾ ചെയ്യുന്നത് അഡാപ്റ്റഡ് മെറ്റീരിയൽ ഉണ്ടാക്കുന്നില്ല.
5. താഴെക്കൊണ്ടുള്ള സ്വീകരിക്കുന്നവർ.
a. ലൈസൻസറിന്റെ ഓഫർ -- ലൈസൻസുചെയ്ത വസ്തു. ലൈസൻസുചെയ്ത വസ്തു സ്വീകരിക്കുന്ന ഓരോ വ്യക്തിക്കും സ്വയം ലൈസൻസർ ഈ പബ്ലിക് ലൈസൻസിന്റെ നിബന്ധനകൾ പ്രകാരം അവകാശങ്ങൾ പ്രയോഗിക്കാൻ ഓഫർ നൽകുന്നു.
b. ലൈസൻസറിന്റെ അധിക ഓഫർ -- അഡാപ്റ്റഡ് മെറ്റീരിയൽ. നിങ്ങൾ നൽകുന്ന അഡാപ്റ്റഡ് മെറ്റീരിയൽ സ്വീകരിക്കുന്ന ഓരോ വ്യക്തിക്കും സ്വയം ലൈസൻസർ, നിങ്ങൾ പ്രയോഗിക്കുന്ന അഡാപ്റ്ററുടെ ലൈസൻസിന്റെ നിബന്ധനകൾ പ്രകാരം അവകാശങ്ങൾ പ്രയോഗിക്കാൻ ഓഫർ നൽകുന്നു.
c. താഴെക്കൊണ്ടുള്ള നിയന്ത്രണങ്ങൾ ഇല്ല. നിങ്ങൾക്ക് ലൈസൻസുചെയ്ത വസ്തുവിൽ അധികം വ്യത്യസ്ത നിബന്ധനകൾ ഏർപ്പെടുത്താനോ ഫലപ്രദമായ സാങ്കേതിക നടപടികൾ പ്രയോഗിക്കാനോ പാടില്ല, ഇത് ലൈസൻസുചെയ്ത വസ്തു സ്വീകരിക്കുന്നവരുടെ അവകാശങ്ങൾ പ്രയോഗിക്കുന്നത് തടയുന്നുവെങ്കിൽ.
6. അംഗീകാരം ഇല്ല. ഈ പബ്ലിക് ലൈസൻസിൽ ഒന്നും നിങ്ങൾ ലൈസൻസുചെയ്ത വസ്തുവുമായി ബന്ധപ്പെട്ടു, സ്പോൺസർ ചെയ്തതായി, അംഗീകരിച്ചതായി, ഔദ്യോഗിക സ്ഥാനം നൽകിയതായി അവകാശപ്പെടാൻ അല്ലെങ്കിൽ സൂചിപ്പിക്കാൻ അനുവാദം നൽകുന്നില്ല.
b. മറ്റ് അവകാശങ്ങൾ.
1. മാനസിക അവകാശങ്ങൾ, ഉദാഹരണത്തിന് അഖണ്ഡതയുടെ അവകാശം, ഈ പബ്ലിക് ലൈസൻസ് പ്രകാരം ലൈസൻസ് ചെയ്യപ്പെട്ടിട്ടില്ല, പബ്ലിസിറ്റി, സ്വകാര്യത, മറ്റ് സമാന വ്യക്തിത്വ അവകാശങ്ങളും ഉൾപ്പെടുന്നു; എങ്കിലും, സാധ്യമായ പരിധിയിൽ, ലൈസൻസർ ഈ അവകാശങ്ങൾ അവകാശപ്പെടാതിരിക്കാനും നിങ്ങൾക്ക് ലൈസൻസുചെയ്ത അവകാശങ്ങൾ പ്രയോഗിക്കാൻ അനുവദിക്കാനും സമ്മതിക്കുന്നു, പക്ഷേ അതിലധികം അല്ല.
2. പാറ്റന്റ്, ട്രേഡ് മാർക്ക് അവകാശങ്ങൾ ഈ പബ്ലിക് ലൈസൻസ് പ്രകാരം ലൈസൻസ് ചെയ്യപ്പെട്ടിട്ടില്ല.
3. സാധ്യമായ പരിധിയിൽ, ലൈസൻസർ നിങ്ങൾക്ക് ലൈസൻസുചെയ്ത അവകാശങ്ങൾ പ്രയോഗിക്കുന്നതിന് റോയൽറ്റികൾ ശേഖരിക്കാനുള്ള അവകാശം ഒഴിവാക്കുന്നു, നേരിട്ട് അല്ലെങ്കിൽ സ്വമേധയാ അല്ലെങ്കിൽ നിർബന്ധിത ലൈസൻസിംഗ് പദ്ധതികൾ വഴി. മറ്റ് എല്ലാ സാഹചര്യങ്ങളിലും ലൈസൻസർ റോയൽറ്റികൾ ശേഖരിക്കാൻ അവകാശം സൂക്ഷിക്കുന്നു.
വിഭാഗം 3 -- ലൈസൻസ് നിബന്ധനകൾ.
നിങ്ങളുടെ ലൈസൻസുചെയ്ത അവകാശങ്ങൾ പ്രയോഗിക്കുന്നത് താഴെ പറയുന്ന നിബന്ധനകൾക്ക് വിധേയമാണ്.
a. അട്രിബ്യൂഷൻ.
1. നിങ്ങൾ ലൈസൻസുചെയ്ത വസ്തു (മാറ്റം വരുത്തിയ രൂപം ഉൾപ്പെടെ) ഷെയർ ചെയ്യുമ്പോൾ, നിങ്ങൾ:
a. ലൈസൻസർ ലൈസൻസുചെയ്ത വസ്തുവിനൊപ്പം നൽകുന്ന താഴെ പറയുന്നവ നിലനിർത്തണം:
i. ലൈസൻസുചെയ്ത വസ്തുവിന്റെ സൃഷ്ടാക്കൾക്കും അട്രിബ്യൂഷൻ ലഭിക്കേണ്ട മറ്റുള്ളവർക്കും (പseudonym ഉൾപ്പെടെ) ലൈസൻസർ ആവശ്യപ്പെടുന്ന യുക്തമായ രീതിയിൽ തിരിച്ചറിയൽ;
ii. പകർപ്പവകാശ നോട്ടീസ്;
iii. ഈ പബ്ലിക് ലൈസൻസിനെ സൂചിപ്പിക്കുന്ന നോട്ടീസ്;
iv. വാറന്റി ഒഴിവാക്കലിനെ സൂചിപ്പിക്കുന്ന നോട്ടീസ്;
v. യുക്തമായ പരിധിയിൽ ലൈസൻസുചെയ്ത വസ്തുവിലേക്ക് URI അല്ലെങ്കിൽ ഹൈപ്പർലിങ്ക്;
b. നിങ്ങൾ ലൈസൻസുചെയ്ത വസ്തു മാറ്റം വരുത്തിയിട്ടുണ്ടെങ്കിൽ അത് സൂചിപ്പിക്കുകയും മുൻപ് ഉണ്ടായ മാറ്റങ്ങൾ സൂചിപ്പിക്കുകയും ചെയ്യണം;
c. ലൈസൻസുചെയ്ത വസ്തു ഈ പബ്ലിക് ലൈസൻസിന്റെ കീഴിൽ ലൈസൻസ് ചെയ്തതാണെന്ന് സൂചിപ്പിക്കുകയും, ഈ പബ്ലിക് ലൈസൻസിന്റെ പാഠം അല്ലെങ്കിൽ URI അല്ലെങ്കിൽ ഹൈപ്പർലിങ്ക് ഉൾപ്പെടുത്തുകയും ചെയ്യണം.
2. നിങ്ങൾ ലൈസൻസുചെയ്ത വസ്തു ഷെയർ ചെയ്യുന്ന മീഡിയ, മാർഗ്ഗം, സാഹചര്യങ്ങൾ അടിസ്ഥാനമാക്കി, വകുപ്പ് 3(a)(1) നിബന്ധനകൾ യുക്തമായ രീതിയിൽ പാലിക്കാം. ഉദാഹരണത്തിന്, ആവശ്യമായ വിവരങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു റിസോഴ്‌സിലേക്ക് URI അല്ലെങ്കിൽ ഹൈപ്പർലിങ്ക് നൽകുന്നത് യുക്തമായിരിക്കാം.
3. ലൈസൻസർ ആവശ്യപ്പെട്ടാൽ, വകുപ്പ് 3(a)(1)(A) പ്രകാരം ആവശ്യമായ വിവരങ്ങൾ യുക്തമായ പരിധിയിൽ നീക്കം ചെയ്യണം.
b. ഷെയർഅലൈക്ക്.
വകുപ്പ് 3(a) നിബന്ധനകൾക്ക് പുറമേ, നിങ്ങൾ നിർമ്മിക്കുന്ന അഡാപ്റ്റഡ് മെറ്റീരിയൽ ഷെയർ ചെയ്യുമ്പോൾ താഴെ പറയുന്ന നിബന്ധനകളും ബാധകമാണ്.
1. നിങ്ങൾ പ്രയോഗിക്കുന്ന അഡാപ്റ്ററുടെ ലൈസൻസ് ഈ പബ്ലിക് ലൈസൻസിന്റെ സമാന ലൈസൻസ് ഘടകങ്ങളുള്ള ക്രിയേറ്റീവ് കോമൺസ് ലൈസൻസ് ആയിരിക്കണം, ഈ പതിപ്പോ അതിനുശേഷമുള്ള പതിപ്പോ, അല്ലെങ്കിൽ BY-SA അനുയോജ്യമായ ലൈസൻസ് ആയിരിക്കണം.
2. നിങ്ങൾ പ്രയോഗിക്കുന്ന അഡാപ്റ്ററുടെ ലൈസൻസിന്റെ പാഠം അല്ലെങ്കിൽ URI അല്ലെങ്കിൽ ഹൈപ്പർലിങ്ക് ഉൾപ്പെടുത്തണം. നിങ്ങൾ അഡാപ്റ്റഡ് മെറ്റീരിയൽ ഷെയർ ചെയ്യുന്ന മീഡിയ, മാർഗ്ഗം, സാഹചര്യങ്ങൾ അടിസ്ഥാനമാക്കി ഈ നിബന്ധന യുക്തമായ രീതിയിൽ പാലിക്കാം.
3. നിങ്ങൾ പ്രയോഗിക്കുന്ന അഡാപ്റ്ററുടെ ലൈസൻസിന്റെ കീഴിൽ അനുവദിച്ച അവകാശങ്ങൾ പ്രയോഗം തടയുന്ന അധിക വ്യത്യസ്ത നിബന്ധനകൾ ഏർപ്പെടുത്താനോ ഫലപ്രദമായ സാങ്കേതിക നടപടികൾ പ്രയോഗിക്കാനോ പാടില്ല.
വിഭാഗം 4 -- Sui Generis ഡാറ്റാബേസ് അവകാശങ്ങൾ.
ലൈസൻസുചെയ്ത അവകാശങ്ങളിൽ Sui Generis ഡാറ്റാബേസ് അവകാശങ്ങൾ ഉൾപ്പെടുന്നിടത്ത്, നിങ്ങളുടെ ലൈസൻസുചെയ്ത വസ്തു ഉപയോഗത്തിന് ബാധകമായ:
a. സംശയമില്ലാതാക്കാൻ, വകുപ്പ് 2(a)(1) നിങ്ങൾക്ക് ഡാറ്റാബേസിന്റെ ഉള്ളടക്കത്തിന്റെ മുഴുവൻ അല്ലെങ്കിൽ പ്രധാന ഭാഗം എടുക്കാനും, പുനരുപയോഗം ചെയ്യാനും, പകർപ്പിച്ച് ഷെയർ ചെയ്യാനും അവകാശം നൽകുന്നു;
b. നിങ്ങൾ Sui Generis ഡാറ്റാബേസ് ഉള്ള ഒരു ഡാറ്റാബേസിൽ മുഴുവൻ അല്ലെങ്കിൽ പ്രധാന ഭാഗം ഉൾപ്പെടുത്തുന്നുവെങ്കിൽ...
അവകാശങ്ങൾ, പിന്നെ നിങ്ങൾക്ക് Sui Generis ഡാറ്റാബേസ് അവകാശങ്ങൾ ഉള്ള ഡാറ്റാബേസ് (എന്നാൽ അതിന്റെ വ്യക്തിഗത ഉള്ളടക്കങ്ങൾ അല്ല) ഒരു അനുയോജ്യമായ വസ്തുവാണ്,
സെക്ഷൻ 3(b) ന്റെ ആവശ്യങ്ങൾക്കായി ഉൾപ്പെടെ; കൂടാതെ
c. നിങ്ങൾ ഡാറ്റാബേസിന്റെ മുഴുവൻ അല്ലെങ്കിൽ വലിയൊരു ഭാഗം പങ്കുവെച്ചാൽ, സെക്ഷൻ 3(a) യിലെ നിബന്ധനകൾ പാലിക്കണം.
സംശയം ഒഴിവാക്കാൻ, ഈ സെക്ഷൻ 4 ഈ പബ്ലിക് ലൈസൻസിന്റെ കീഴിലുള്ള നിങ്ങളുടെ ബാധ്യതകൾക്ക് പകരം അല്ല, പകരം കൂട്ടിച്ചേർക്കുന്നതാണ്, ലൈസൻസുചെയ്ത അവകാശങ്ങളിൽ മറ്റ് കോപ്പിറൈറ്റ്, സമാന അവകാശങ്ങൾ ഉൾപ്പെടുന്നിടത്ത്.
സെക്ഷൻ 5 -- വാറന്റികളുടെ ഒഴിവാക്കലും ഉത്തരവാദിത്വ പരിധിയും.
a. ലൈസൻസർ വേറെ വ്യത്യസ്തമായി ഏറ്റെടുക്കാത്തവരെ, സാധ്യമായ പരിധിയിൽ, ലൈസൻസർ ലൈസൻസുചെയ്ത വസ്തുവിനെ നിലവിലുള്ളതുപോലെ, ലഭ്യമായതുപോലെ നൽകുന്നു, ലൈസൻസുചെയ്ത വസ്തുവിനെക്കുറിച്ച് ഏതെങ്കിലും തരത്തിലുള്ള പ്രതിനിധാനങ്ങൾ അല്ലെങ്കിൽ വാറന്റികൾ നൽകുന്നില്ല, വ്യക്തമായതോ, സൂചനയോ, നിയമപരമോ അല്ലെങ്കിൽ മറ്റേതെങ്കിലും. ഇതിൽ, പരിമിതിയില്ലാതെ, തലവാചക വാറന്റികൾ, വ്യാപാരയോഗ്യത, പ്രത്യേക ഉദ്ദേശത്തിനുള്ള അനുയോജ്യത, ലംഘനരഹിതത്വം, മറഞ്ഞിരിക്കുന്ന അല്ലെങ്കിൽ മറ്റ് ദോഷങ്ങൾ ഇല്ലായ്മ, കൃത്യത, പിഴവുകളുടെ സാന്നിധ്യം അല്ലെങ്കിൽ അഭാവം ഉൾപ്പെടുന്നു, അറിയപ്പെടുകയോ കണ്ടെത്തപ്പെടുകയോ ചെയ്താലും. വാറന്റികളുടെ ഒഴിവാക്കലുകൾ പൂർണ്ണമായോ ഭാഗികമായോ അനുവദിക്കപ്പെടാത്തിടത്ത്, ഈ ഒഴിവാക്കൽ നിങ്ങൾക്ക് ബാധകമാകില്ല.
b. സാധ്യമായ പരിധിയിൽ, ഏതെങ്കിലും നിയമ സിദ്ധാന്തത്തിൽ (പരിമിതിയില്ലാതെ, ലാപരവ്യവഹാരം ഉൾപ്പെടെ) ലൈസൻസർ നിങ്ങൾക്ക് നേരിട്ട്, പ്രത്യേകമായി, പരോക്ഷമായി, അനുബന്ധമായി, ഫലപ്രദമായി, ശിക്ഷാത്മകമായി, ഉദാഹരണമായി അല്ലെങ്കിൽ മറ്റ് നഷ്ടങ്ങൾ, ചെലവുകൾ, ചിലവുകൾ, നാശനഷ്ടങ്ങൾക്കായി ഉത്തരവാദിയാകില്ല, ഈ പബ്ലിക് ലൈസൻസ് അല്ലെങ്കിൽ ലൈസൻസുചെയ്ത വസ്തുവിന്റെ ഉപയോഗം മൂലം, ലൈസൻസർ ഇത്തരം നഷ്ടങ്ങൾ, ചെലവുകൾ, ചിലവുകൾ, നാശനഷ്ടങ്ങൾ സംഭവിക്കാമെന്നു അറിയിച്ചിട്ടുണ്ടെങ്കിലും. ഉത്തരവാദിത്വ പരിധി പൂർണ്ണമായോ ഭാഗികമായോ അനുവദിക്കപ്പെടാത്തിടത്ത്, ഈ പരിധി നിങ്ങൾക്ക് ബാധകമാകില്ല.
c. മുകളിൽ നൽകിയ വാറന്റികളുടെ ഒഴിവാക്കലും ഉത്തരവാദിത്വ പരിധിയും സാധ്യമായ പരിധിയിൽ, പരമാവധി ഒരു പൂർണ്ണമായ ഒഴിവാക്കലും എല്ലാ ഉത്തരവാദിത്വവും ഉപേക്ഷിക്കുന്നതുമായ രീതിയിൽ വ്യാഖ്യാനിക്കപ്പെടണം.
സെക്ഷൻ 6 -- കാലാവധി, അവസാനിപ്പിക്കൽ.
a. ഈ പബ്ലിക് ലൈസൻസ് ഇവിടെ ലൈസൻസുചെയ്ത കോപ്പിറൈറ്റ്, സമാന അവകാശങ്ങളുടെ കാലാവധിക്കായി ബാധകമാണ്. എന്നാൽ, നിങ്ങൾ ഈ പബ്ലിക് ലൈസൻസ് പാലിക്കാത്ത പക്ഷം, ഈ പബ്ലിക് ലൈസൻസിന്റെ കീഴിലുള്ള നിങ്ങളുടെ അവകാശങ്ങൾ സ്വയം അവസാനിക്കും.
b. സെക്ഷൻ 6(a) പ്രകാരം നിങ്ങളുടെ ലൈസൻസുചെയ്ത വസ്തു ഉപയോഗിക്കുന്ന അവകാശം അവസാനിച്ചാൽ, അത് പുനഃസ്ഥാപിക്കും:
1. ലംഘനം പരിഹരിച്ച തീയതിയിൽ സ്വയം, ലംഘനം കണ്ടെത്തിയതിനു ശേഷം 30 ദിവസത്തിനുള്ളിൽ പരിഹരിച്ചാൽ; അല്ലെങ്കിൽ
2. ലൈസൻസർ വ്യക്തമായി പുനഃസ്ഥാപിച്ചാൽ.
സംശയം ഒഴിവാക്കാൻ, ഈ സെക്ഷൻ 6(b) നിങ്ങളുടെ ലംഘനങ്ങൾക്ക് ലൈസൻസർ പരിഹാരങ്ങൾ തേടാനുള്ള അവകാശത്തെ ബാധിക്കില്ല.
c. സംശയം ഒഴിവാക്കാൻ, ലൈസൻസർ വേറെ വ്യത്യസ്ത നിബന്ധനകളിൽ ലൈസൻസുചെയ്ത വസ്തു നൽകുകയോ വിതരണം നിർത്തുകയോ ചെയ്യാം; എന്നാൽ അതു ഈ പബ്ലിക് ലൈസൻസ് അവസാനിപ്പിക്കില്ല.
d. സെക്ഷനുകൾ 1, 5, 6, 7, 8 ഈ പബ്ലിക് ലൈസൻസ് അവസാനിച്ചതിനുശേഷവും നിലനിൽക്കും.
സെക്ഷൻ 7 -- മറ്റ് നിബന്ധനകളും വ്യവസ്ഥകളും.
a. നിങ്ങൾ വ്യക്തമായി സമ്മതിച്ചില്ലെങ്കിൽ, ലൈസൻസർ നിങ്ങൾ നൽകുന്ന അധികമോ വ്യത്യസ്തമോ ആയ നിബന്ധനകളാൽ ബാധിക്കപ്പെടുകയില്ല.
b. ഇവിടെ പറയാത്ത ലൈസൻസുചെയ്ത വസ്തുവിനെക്കുറിച്ചുള്ള ഏത് ക്രമീകരണങ്ങളും, മനസ്സിലാക്കലുകളും, കരാറുകളും ഈ പബ്ലിക് ലൈസൻസിന്റെ നിബന്ധനകളിൽ നിന്ന് സ്വതന്ത്രവും വ്യത്യസ്തവുമാണ്.
സെക്ഷൻ 8 -- വ്യാഖ്യാനം.
a. സംശയം ഒഴിവാക്കാൻ, ഈ പബ്ലിക് ലൈസൻസ് ലൈസൻസുചെയ്ത വസ്തു ഉപയോഗിക്കുന്നതിൽ നിയമപരമായി അനുമതിയുള്ള ഉപയോഗം കുറയ്ക്കുകയോ, പരിമിതപ്പെടുത്തുകയോ, നിയന്ത്രണങ്ങൾ ഏർപ്പെടുത്തുകയോ ചെയ്യില്ല.
b. സാധ്യമായ പരിധിയിൽ, ഈ പബ്ലിക് ലൈസൻസിന്റെ ഏത് വ്യവസ്ഥയും പ്രാബല്യരഹിതമെന്ന് കരുതിയാൽ, അത് പ്രാബല്യവാനാക്കാൻ ആവശ്യമായ ഏറ്റവും കുറഞ്ഞ പരിധിയിലേക്കു സ്വയം പരിഷ്കരിക്കപ്പെടും. പരിഷ്കരിക്കാൻ കഴിയാത്ത പക്ഷം, അത് ഈ പബ്ലിക് ലൈസൻസിൽ നിന്ന് വേർതിരിക്കപ്പെടും, ശേഷിക്കുന്ന നിബന്ധനകളുടെ പ്രാബല്യത്തെ ബാധിക്കാതെ.
c. ലൈസൻസർ വ്യക്തമായി സമ്മതിച്ചില്ലെങ്കിൽ, ഈ പബ്ലിക് ലൈസൻസിന്റെ ഏത് നിബന്ധനയും ഒഴിവാക്കുകയോ പാലിക്കാതിരിക്കാൻ സമ്മതിക്കുകയോ ചെയ്യില്ല.
d. ഈ പബ്ലിക് ലൈസൻസിൽ ഒന്നും ലൈസൻസറിനും നിങ്ങള്ക്കും ബാധകമായ ഏതെങ്കിലും പ്രത്യേക അവകാശങ്ങളും പ്രതിരോധങ്ങളും പരിമിതപ്പെടുത്തുകയോ ഒഴിവാക്കുകയോ ചെയ്യുന്നുവെന്നായി വ്യാഖ്യാനിക്കരുത്.
=======================================================================
ക്രിയേറ്റീവ് കോമൺസ് അതിന്റെ പബ്ലിക് ലൈസൻസുകളുടെ ഭാഗമല്ല. എന്നിരുന്നാലും, ക്രിയേറ്റീവ് കോമൺസ് പ്രസിദ്ധീകരിക്കുന്ന വസ്തുക്കൾക്ക് അതിന്റെ പബ്ലിക് ലൈസൻസുകളിൽ ഒന്നിനെ പ്രയോഗിക്കാൻ തിരഞ്ഞെടുക്കാം, അപ്പോൾ അത് "ലൈസൻസർ" ആയി കണക്കാക്കപ്പെടും. ക്രിയേറ്റീവ് കോമൺസിന്റെ പബ്ലിക് ലൈസൻസുകളുടെ വാചകം CC0 പബ്ലിക് ഡൊമെയ്ൻ ഡെഡിക്കേഷനിൽ പൊതുജന ഡൊമെയ്‌നിലേക്ക് സമർപ്പിച്ചിരിക്കുന്നു. ക്രിയേറ്റീവ് കോമൺസ് പബ്ലിക് ലൈസൻസുകൾ പ്രകാരം വസ്തു പങ്കുവെക്കപ്പെടുന്നുവെന്ന് സൂചിപ്പിക്കുന്നതിനുള്ള പരിമിതമായ ഉദ്ദേശം ഒഴികെ അല്ലെങ്കിൽcreativecommons.org/policies ൽ പ്രസിദ്ധീകരിച്ച ക്രിയേറ്റീവ് കോമൺസ് നയങ്ങൾ അനുസരിച്ച് അനുവദിച്ചിരിക്കുന്നതുപോലെ, ക്രിയേറ്റീവ് കോമൺസ് "Creative Commons" എന്ന ട്രേഡ്മാർക്ക് അല്ലെങ്കിൽ മറ്റ് ട്രേഡ്മാർക്കുകൾ അല്ലെങ്കിൽ ലോഗോകൾ അതിന്റെ മുൻകൂർ എഴുത്ത് സമ്മതം കൂടാതെ ഉപയോഗിക്കാൻ അനുമതിയില്ല, അതിൽ പരിമിതിയില്ലാതെ, അതിന്റെ പബ്ലിക് ലൈസൻസുകളിൽ അനധികൃത മാറ്റങ്ങൾ വരുത്തുന്നതുമായി ബന്ധപ്പെട്ട് അല്ലെങ്കിൽ ലൈസൻസുചെയ്ത വസ്തു ഉപയോഗിക്കുന്നതുമായി ബന്ധപ്പെട്ട മറ്റ് ക്രമീകരണങ്ങൾ, മനസ്സിലാക്കലുകൾ, കരാറുകൾ എന്നിവയുമായി ബന്ധപ്പെട്ട്. സംശയം ഒഴിവാക്കാൻ, ഈ പാരഗ്രാഫ് പബ്ലിക് ലൈസൻസുകളുടെ ഭാഗമല്ല.
ക്രിയേറ്റീവ് കോമൺസിനെ creativecommons.org ൽ ബന്ധപ്പെടാം.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാപത്രം**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, യന്ത്രം ചെയ്ത വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

23
translations/ml/sketchnotes/README.md
Unescape View File

@ -0,0 +1,23 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a88d5918c1b9da69a40d917a0840c497",
"translation_date": "2025-12-19T13:12:23+00:00",
"source_file": "sketchnotes/README.md",
"language_code": "ml"
}
-->
എല്ലാ പാഠ്യപദ്ധതിയുടെ സ്കെച്ച്നോട്ടുകളും ഇവിടെ ഡൗൺലോഡ് ചെയ്യാം.
🖨 ഉയർന്ന റെസല്യൂഷനിൽ പ്രിന്റ് ചെയ്യുന്നതിനായി, TIFF പതിപ്പുകൾ [ഈ റിപോയിൽ](https://github.com/girliemac/a-picture-is-worth-a-1000-words/tree/main/ml/tiff) ലഭ്യമാണ്.
🎨 സൃഷ്ടിച്ചത്: [Tomomi Imura](https://github.com/girliemac) (ട്വിറ്റർ: [@girlie_mac](https://twitter.com/girlie_mac))
[![CC BY-SA 4.0](https://img.shields.io/badge/License-CC%20BY--SA%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by-sa/4.0/)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

161
translations/te/1-Introduction/1-intro-to-ML/README.md
Unescape View File

@ -0,0 +1,161 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "69389392fa6346e0dfa30f664b7b6fec",
"translation_date": "2025-12-19T13:22:38+00:00",
"source_file": "1-Introduction/1-intro-to-ML/README.md",
"language_code": "te"
}
-->
# మెషీన్ లెర్నింగ్ పరిచయం
## [ప్రీ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
---
[![ML for beginners - Introduction to Machine Learning for Beginners](https://img.youtube.com/vi/6mSx_KJxcHI/0.jpg)](https://youtu.be/6mSx_KJxcHI "ML for beginners - Introduction to Machine Learning for Beginners")
> 🎥 ఈ పాఠం ద్వారా పనిచేసే చిన్న వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి.
క్లాసికల్ మెషీన్ లెర్నింగ్ పై ఈ కోర్సుకు స్వాగతం! మీరు ఈ విషయం గురించి పూర్తిగా కొత్తవారైనా, లేదా ఒక అనుభవజ్ఞులైన ML ప్రాక్టిషనర్ అయినా, మేము మీకు జాయిన్ కావడం ఆనందంగా ఉంది! మేము మీ ML అధ్యయనానికి స్నేహపూర్వక ప్రారంభ స్థలాన్ని సృష్టించాలని కోరుకుంటున్నాము మరియు మీ [ఫీడ్‌బ్యాక్](https://github.com/microsoft/ML-For-Beginners/discussions) ను అంచనా వేయడానికి, స్పందించడానికి మరియు చేర్చడానికి సంతోషిస్తాము.
[![Introduction to ML](https://img.youtube.com/vi/h0e2HAPTGF4/0.jpg)](https://youtu.be/h0e2HAPTGF4 "Introduction to ML")
> 🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి: MIT యొక్క జాన్ గుట్‌టాగ్ మెషీన్ లెర్నింగ్‌ను పరిచయం చేస్తున్నారు
---
## మెషీన్ లెర్నింగ్‌తో ప్రారంభం
ఈ పాఠ్యాంశం ప్రారంభించడానికి ముందు, మీ కంప్యూటర్‌ను స్థానికంగా నోట్బుక్స్ నడపడానికి సెట్ చేయాలి.
- **ఈ వీడియోలతో మీ మెషీన్‌ను కాన్ఫిగర్ చేయండి**. మీ సిస్టమ్‌లో [Python ను ఎలా ఇన్‌స్టాల్ చేయాలో](https://youtu.be/CXZYvNRIAKM) మరియు అభివృద్ధి కోసం [టెక్స్ట్ ఎడిటర్‌ను ఎలా సెట్ చేయాలో](https://youtu.be/EU8eayHWoZg) తెలుసుకోడానికి క్రింది లింకులను ఉపయోగించండి.
- **Python నేర్చుకోండి**. ఈ కోర్సులో ఉపయోగించే డేటా సైంటిస్టులకు ఉపయోగకరమైన ప్రోగ్రామింగ్ భాష అయిన [Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott) యొక్క ప్రాథమిక అవగాహన కలిగి ఉండటం సిఫార్సు చేయబడింది.
- **Node.js మరియు JavaScript నేర్చుకోండి**. వెబ్ యాప్స్ నిర్మాణంలో ఈ కోర్సులో JavaScript ను కొన్ని సార్లు ఉపయోగిస్తాము, కాబట్టి [node](https://nodejs.org) మరియు [npm](https://www.npmjs.com/) ఇన్‌స్టాల్ చేయాలి, అలాగే Python మరియు JavaScript అభివృద్ధికి [Visual Studio Code](https://code.visualstudio.com/) అందుబాటులో ఉండాలి.
- **GitHub ఖాతా సృష్టించండి**. మీరు ఇక్కడ [GitHub](https://github.com) లో మమ్మల్ని కనుగొన్నందున, మీకు ఇప్పటికే ఖాతా ఉండవచ్చు, లేకపోతే ఒకటి సృష్టించి ఈ పాఠ్యాంశాన్ని ఫోర్క్ చేసుకోండి. (మాకు ఒక స్టార్ ఇవ్వడం మర్చిపోకండి 😊)
- **Scikit-learn ను అన్వేషించండి**. ఈ పాఠాలలో సూచించే ML లైబ్రరీల సమాహారం అయిన [Scikit-learn](https://scikit-learn.org/stable/user_guide.html) తో పరిచయం అవ్వండి.
---
## మెషీన్ లెర్నింగ్ అంటే ఏమిటి?
'మెషీన్ లెర్నింగ్' అనే పదం ఈ రోజుల్లో అత్యంత ప్రాచుర్యం పొందిన మరియు తరచుగా ఉపయోగించే పదాలలో ఒకటి. మీరు టెక్నాలజీతో కొంత పరిచయం ఉన్నట్లయితే, మీరు ఈ పదాన్ని కనీసం ఒకసారి వినే అవకాశం ఉంది, మీరు ఏ రంగంలో పనిచేస్తున్నా సరే. అయితే మెషీన్ లెర్నింగ్ యొక్క యాంత్రికత చాలా మందికి రహస్యమే. ఒక మెషీన్ లెర్నింగ్ ప్రారంభకుడికి, ఈ విషయం కొన్నిసార్లు భయంకరంగా అనిపించవచ్చు. అందుకే, మెషీన్ లెర్నింగ్ నిజంగా ఏమిటి అనే దానిని అర్థం చేసుకోవడం మరియు దాన్ని ప్రాక్టికల్ ఉదాహరణల ద్వారా దశలవారీగా నేర్చుకోవడం ముఖ్యం.
---
## హైప్ కర్వ్
![ml hype curve](../../../../translated_images/hype.07183d711a17aafe70915909a0e45aa286ede136ee9424d418026ab00fec344c.te.png)
> గూగుల్ ట్రెండ్స్ 'మెషీన్ లెర్నింగ్' పదం యొక్క తాజా 'హైప్ కర్వ్' ను చూపిస్తుంది
---
## ఒక రహస్యమైన విశ్వం
మనం ఆసక్తికరమైన రహస్యాలతో నిండిన విశ్వంలో జీవిస్తున్నాము. స్టీఫెన్ హాకింగ్, ఆల్బర్ట్ ఐన్‌స్టీన్ వంటి గొప్ప శాస్త్రవేత్తలు మరియు మరెన్నో వారు మన చుట్టూ ఉన్న ప్రపంచ రహస్యాలను వెలికితీయడానికి అర్థవంతమైన సమాచారాన్ని వెతుకుతూ తమ జీవితాలను అంకితం చేశారు. ఇది మానవుల నేర్చుకునే స్వభావం: ఒక మానవ శిశువు కొత్త విషయాలను నేర్చుకుంటూ, వారి ప్రపంచ నిర్మాణాన్ని సంవత్సరాలుగా తెలుసుకుంటూ పెద్దవాడవుతుంది.
---
## పిల్లల మెదడు
పిల్లల మెదడు మరియు ఇంద్రియాలు వారి చుట్టూ ఉన్న వాస్తవాలను గ్రహించి, జీవితం యొక్క దాగి ఉన్న నమూనాలను క్రమంగా నేర్చుకుంటాయి, ఇవి పిల్లలకు నేర్చుకున్న నమూనాలను గుర్తించడానికి తార్కిక నియమాలను రూపొందించడంలో సహాయపడతాయి. మానవ మెదడు యొక్క నేర్చుకునే ప్రక్రియ మానవులను ఈ ప్రపంచంలో అత్యంత సున్నితమైన జీవిగా చేస్తుంది. దాగి ఉన్న నమూనాలను కనుగొని, ఆ నమూనాలపై సృజనాత్మకత చూపుతూ నిరంతరం నేర్చుకోవడం మన జీవితకాలం మొత్తం మనల్ని మెరుగుపరుస్తుంది. ఈ నేర్చుకునే సామర్థ్యం మరియు అభివృద్ధి చెందే సామర్థ్యం [బ్రెయిన్ ప్లాస్టిసిటీ](https://www.simplypsychology.org/brain-plasticity.html) అనే భావనతో సంబంధం కలిగి ఉంది. ఉపరితలంగా, మానవ మెదడు యొక్క నేర్చుకునే ప్రక్రియ మరియు మెషీన్ లెర్నింగ్ భావనల మధ్య కొన్ని ప్రేరణాత్మక సమానతలను గీయవచ్చు.
---
## మానవ మెదడు
[మానవ మెదడు](https://www.livescience.com/29365-human-brain.html) వాస్తవ ప్రపంచం నుండి విషయాలను గ్రహించి, గ్రహించిన సమాచారాన్ని ప్రాసెస్ చేసి, తార్కిక నిర్ణయాలు తీసుకుని, పరిస్థితుల ఆధారంగా కొన్ని చర్యలను నిర్వహిస్తుంది. దీన్ని మేధోమయంగా ప్రవర్తించడం అంటారు. మేధోమయ ప్రవర్తనా ప్రక్రియ యొక్క ఒక ప్రతిరూపాన్ని యంత్రానికి ప్రోగ్రామ్ చేస్తే, దాన్ని కృత్రిమ మేధస్సు (AI) అంటారు.
---
## కొన్ని పదజాలం
పదాలు గందరగోళంగా ఉండవచ్చు, కానీ మెషీన్ లెర్నింగ్ (ML) కృత్రిమ మేధస్సు యొక్క ఒక ముఖ్యమైన ఉపసమూహం. **ML ప్రత్యేక అల్గోరిథమ్స్ ఉపయోగించి గ్రహించిన డేటా నుండి అర్థవంతమైన సమాచారాన్ని కనుగొని దాగి ఉన్న నమూనాలను గుర్తించి, తార్కిక నిర్ణయ ప్రక్రియను బలపరచడంలో ఆసక్తి కలిగి ఉంటుంది**.
---
## AI, ML, డీప్ లెర్నింగ్
![AI, ML, deep learning, data science](../../../../translated_images/ai-ml-ds.537ea441b124ebf69c144a52c0eb13a7af63c4355c2f92f440979380a2fb08b8.te.png)
> AI, ML, డీప్ లెర్నింగ్ మరియు డేటా సైన్స్ మధ్య సంబంధాలను చూపించే డయాగ్రామ్. ఇన్ఫోగ్రాఫిక్ [జెన్ లూపర్](https://twitter.com/jenlooper) ద్వారా, ఈ గ్రాఫిక్ ఆధారంగా [ఇది](https://softwareengineering.stackexchange.com/questions/366996/distinction-between-ai-ml-neural-networks-deep-learning-and-data-mining)
---
## కవర్ చేయాల్సిన భావనలు
ఈ పాఠ్యాంశంలో, ప్రారంభకుడు తెలుసుకోవలసిన మెషీన్ లెర్నింగ్ యొక్క ప్రాథమిక భావనలను మాత్రమే కవర్ చేయబోతున్నాము. మేము 'క్లాసికల్ మెషీన్ లెర్నింగ్' అని పిలిచే వాటిని ప్రధానంగా Scikit-learn ఉపయోగించి కవర్ చేస్తాము, ఇది చాలా మంది విద్యార్థులు ప్రాథమికాలు నేర్చుకోవడానికి ఉపయోగించే అద్భుతమైన లైబ్రరీ. కృత్రిమ మేధస్సు లేదా డీప్ లెర్నింగ్ యొక్క విస్తృత భావనలను అర్థం చేసుకోవడానికి, మెషీన్ లెర్నింగ్ యొక్క బలమైన ప్రాథమిక జ్ఞానం అవసరం, అందుకే మేము దీన్ని ఇక్కడ అందించాలనుకుంటున్నాము.
---
## ఈ కోర్సులో మీరు నేర్చుకుంటారు:
- మెషీన్ లెర్నింగ్ యొక్క ప్రాథమిక భావనలు
- ML చరిత్ర
- ML మరియు న్యాయం
- రిగ్రెషన్ ML సాంకేతికతలు
- క్లాసిఫికేషన్ ML సాంకేతికతలు
- క్లస్టరింగ్ ML సాంకేతికతలు
- సహజ భాషా ప్రాసెసింగ్ ML సాంకేతికతలు
- టైమ్ సిరీస్ ఫోర్కాస్టింగ్ ML సాంకేతికతలు
- రీఇన్ఫోర్స్‌మెంట్ లెర్నింగ్
- ML కోసం వాస్తవ ప్రపంచ అనువర్తనాలు
---
## మేము కవర్ చేయనిదే
- డీప్ లెర్నింగ్
- న్యూరల్ నెట్‌వర్క్స్
- AI
మంచి నేర్చుకునే అనుభవం కోసం, మేము న్యూరల్ నెట్‌వర్క్స్, 'డీప్ లెర్నింగ్' - న్యూరల్ నెట్‌వర్క్స్ ఉపయోగించి బహుళ-పొరల మోడల్ నిర్మాణం - మరియు AI యొక్క క్లిష్టతలను తప్పించుకుంటాము, ఇవి వేరే పాఠ్యాంశంలో చర్చిస్తాము. మేము ఈ పెద్ద రంగంలో డేటా సైన్స్ పై దృష్టి పెట్టే రాబోయే పాఠ్యాంశాన్ని కూడా అందిస్తాము.
---
## ఎందుకు మెషీన్ లెర్నింగ్ నేర్చుకోవాలి?
సిస్టమ్స్ దృష్టికోణం నుండి, మెషీన్ లెర్నింగ్ అనేది డేటా నుండి దాగి ఉన్న నమూనాలను నేర్చుకుని, మేధోమయ నిర్ణయాలు తీసుకోవడంలో సహాయపడే ఆటోమేటెడ్ సిస్టమ్స్ సృష్టించడం అని నిర్వచించబడింది.
ఈ ప్రేరణ మానవ మెదడు బయట ప్రపంచం నుండి గ్రహించే డేటా ఆధారంగా కొన్ని విషయాలను ఎలా నేర్చుకుంటుందో దానితో సన్నిహితంగా ప్రేరేపించబడింది.
✅ ఒక నిమిషం ఆలోచించండి, ఒక వ్యాపారం ఎందుకు హార్డ్-కోడ్ చేసిన నియమాల ఇంజిన్ సృష్టించడంకంటే మెషీన్ లెర్నింగ్ వ్యూహాలను ఉపయోగించాలనుకుంటుంది.
---
## మెషీన్ లెర్నింగ్ అనువర్తనాలు
మెషీన్ లెర్నింగ్ అనువర్తనాలు ఇప్పుడు దాదాపు ప్రతిదీ చోట్ల ఉన్నాయి, మరియు మన సమాజాల్లో ప్రవహిస్తున్న డేటా లాంటివి, మన స్మార్ట్ ఫోన్లు, కనెక్ట్ అయిన పరికరాలు మరియు ఇతర సిస్టమ్స్ ద్వారా ఉత్పత్తి అవుతున్నాయి. ఆధునిక మెషీన్ లెర్నింగ్ అల్గోరిథమ్స్ యొక్క అపారమైన సామర్థ్యాన్ని పరిగణనలోకి తీసుకుంటే, పరిశోధకులు బహుళ-పరిమాణ మరియు బహుళ-శాస్త్రీయ వాస్తవ జీవిత సమస్యలను గొప్ప సానుకూల ఫలితాలతో పరిష్కరించడానికి వారి సామర్థ్యాన్ని అన్వేషిస్తున్నారు.
---
## అన్వయించిన ML ఉదాహరణలు
**మీరు మెషీన్ లెర్నింగ్‌ను అనేక విధాల ఉపయోగించవచ్చు**:
- రోగి వైద్య చరిత్ర లేదా నివేదికల నుండి వ్యాధి సంభావ్యతను అంచనా వేయడానికి.
- వాతావరణ డేటాను ఉపయోగించి వాతావరణ సంఘటనలను అంచనా వేయడానికి.
- ఒక టెక్స్ట్ యొక్క భావాన్ని అర్థం చేసుకోవడానికి.
- ప్రచారం వ్యాప్తిని ఆపడానికి ఫేక్ న్యూస్‌ను గుర్తించడానికి.
ఫైనాన్స్, ఆర్థిక శాస్త్రం, భూగర్భ శాస్త్రం, అంతరిక్ష అన్వేషణ, బయోమెడికల్ ఇంజనీరింగ్, జ్ఞాన శాస్త్రం మరియు మానవ శాస్త్రాలలో కూడా తమ రంగంలోని క్లిష్టమైన, డేటా-ప్రాసెసింగ్ భారమైన సమస్యలను పరిష్కరించడానికి మెషీన్ లెర్నింగ్‌ను అనుసరించారు.
---
## ముగింపు
మెషీన్ లెర్నింగ్ వాస్తవ ప్రపంచం లేదా ఉత్పత్తి చేసిన డేటా నుండి అర్థవంతమైన అవగాహనలను కనుగొని నమూనాలను స్వయంచాలకంగా కనుగొంటుంది. ఇది వ్యాపారం, ఆరోగ్యం, ఆర్థిక అనువర్తనాలలో అత్యంత విలువైనదిగా నిరూపించుకుంది.
సమీప భవిష్యత్తులో, మెషీన్ లెర్నింగ్ యొక్క ప్రాథమికాలను అర్థం చేసుకోవడం ఏ రంగం నుండి వచ్చిన వారికైనా తప్పనిసరి అవుతుంది, ఎందుకంటే దీని విస్తృతమైన స్వీకరణ ఉంది.
---
# 🚀 సవాలు
[Excalidraw](https://excalidraw.com/) వంటి ఆన్‌లైన్ యాప్ లేదా కాగితం మీద, AI, ML, డీప్ లెర్నింగ్ మరియు డేటా సైన్స్ మధ్య తేడాలను మీ అవగాహనను స్కెచ్ చేయండి. ఈ సాంకేతికతలు ఏ సమస్యలను పరిష్కరించడంలో మంచి అనుభవం కలిగి ఉన్నాయో కొన్ని ఆలోచనలు జోడించండి.
# [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
---
# సమీక్ష & స్వీయ అధ్యయనం
క్లౌడ్‌లో ML అల్గోరిథమ్స్‌తో ఎలా పని చేయాలో మరింత తెలుసుకోవడానికి, ఈ [లెర్నింగ్ పాత్](https://docs.microsoft.com/learn/paths/create-no-code-predictive-models-azure-machine-learning/?WT.mc_id=academic-77952-leestott) ను అనుసరించండి.
ML ప్రాథమికాల గురించి ఒక [లెర్నింగ్ పాత్](https://docs.microsoft.com/learn/modules/introduction-to-machine-learning/?WT.mc_id=academic-77952-leestott) తీసుకోండి.
---
# అసైన్‌మెంట్
[Get up and running](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకం వల్ల కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

25
translations/te/1-Introduction/1-intro-to-ML/assignment.md
Unescape View File

@ -0,0 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "4c4698044bb8af52cfb6388a4ee0e53b",
"translation_date": "2025-12-19T13:26:04+00:00",
"source_file": "1-Introduction/1-intro-to-ML/assignment.md",
"language_code": "te"
}
-->
# Get Up and Running
## సూచనలు
ఈ గ్రేడ్ లేని అసైన్‌మెంట్‌లో, మీరు Python పై పునఃసమీక్ష చేయాలి మరియు మీ వాతావరణాన్ని సెట్ చేసి నోట్బుక్స్ నడపగలగాలి.
ఈ [Python Learning Path](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott) తీసుకోండి, ఆపై ఈ పరిచయ వీడియోలను చూసి మీ సిస్టమ్స్ సెట్ చేయండి:
https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

167
translations/te/1-Introduction/2-history-of-ML/README.md
Unescape View File

@ -0,0 +1,167 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "6a05fec147e734c3e6bfa54505648e2b",
"translation_date": "2025-12-19T13:27:27+00:00",
"source_file": "1-Introduction/2-history-of-ML/README.md",
"language_code": "te"
}
-->
# మెషీన్ లెర్నింగ్ చరిత్ర
![మెషీన్ లెర్నింగ్ చరిత్ర యొక్క సారాంశం స్కెచ్ నోట్‌లో](../../../../translated_images/ml-history.a1bdfd4ce1f464d9a0502f38d355ffda384c95cd5278297a46c9a391b5053bc4.te.png)
> స్కెచ్ నోట్ [టోమోమీ ఇమురా](https://www.twitter.com/girlie_mac) ద్వారా
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
---
[![ప్రారంభికుల కోసం ML - మెషీన్ లెర్నింగ్ చరిత్ర](https://img.youtube.com/vi/N6wxM4wZ7V0/0.jpg)](https://youtu.be/N6wxM4wZ7V0 "ప్రారంభికుల కోసం ML - మెషీన్ లెర్నింగ్ చరిత్ర")
> 🎥 ఈ పాఠం ద్వారా పనిచేసే చిన్న వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి.
ఈ పాఠంలో, మేము మెషీన్ లెర్నింగ్ మరియు ఆర్టిఫిషియల్ ఇంటెలిజెన్స్ చరిత్రలో ప్రధాన మైలురాళ్లను పరిశీలిస్తాము.
ఆర్టిఫిషియల్ ఇంటెలిజెన్స్ (AI) రంగంగా చరిత్ర మెషీన్ లెర్నింగ్ చరిత్రతో అనుసంధానంగా ఉంది, ఎందుకంటే ML ఆధారంగా ఉన్న అల్గోరిథమ్స్ మరియు కంప్యూటేషనల్ అభివృద్ధులు AI అభివృద్ధికి సహకరించాయి. ఈ రంగాలు 1950లలో ప్రత్యేక పరిశోధనా ప్రాంతాలుగా crystallize కావడం ప్రారంభమైనప్పటికీ, ముఖ్యమైన [అల్గోరిథమిక్, గణాంక, గణిత, కంప్యూటేషనల్ మరియు సాంకేతిక ఆవిష్కరణలు](https://wikipedia.org/wiki/Timeline_of_machine_learning) ఈ కాలాన్ని మించి మరియు సమాంతరంగా ఉన్నాయి. వాస్తవానికి, ఈ ప్రశ్నల గురించి మనుషులు [నూరేళ్లుగా](https://wikipedia.org/wiki/History_of_artificial_intelligence) ఆలోచిస్తున్నారు: ఈ వ్యాసం 'ఆలోచించే యంత్రం' అనే ఆలోచన యొక్క చారిత్రక మేధో ఆధారాలను చర్చిస్తుంది.
---
## ముఖ్యమైన ఆవిష్కరణలు
- 1763, 1812 [బేస్ సిద్ధాంతం](https://wikipedia.org/wiki/Bayes%27_theorem) మరియు దాని పూర్వీకులు. ఈ సిద్ధాంతం మరియు దాని అనువర్తనాలు అనుమానాన్ని ఆధారపడి, ఒక సంఘటన జరిగే సంభావ్యతను వివరించును.
- 1805 [లీస్ట్ స్క్వేర్ సిద్ధాంతం](https://wikipedia.org/wiki/Least_squares) ఫ్రెంచ్ గణిత శాస్త్రజ్ఞుడు అడ్రియన్-మారీ లెజాండ్రే ద్వారా. ఈ సిద్ధాంతం, మీరు మా రిగ్రెషన్ యూనిట్‌లో నేర్చుకుంటారు, డేటా ఫిట్టింగ్‌లో సహాయపడుతుంది.
- 1913 [మార్కోవ్ చైన్స్](https://wikipedia.org/wiki/Markov_chain), రష్యన్ గణిత శాస్త్రజ్ఞుడు ఆండ్రే మార్కోవ్ పేరుతో, ఒక గత స్థితిపై ఆధారపడి సంభవించే సంఘటనల శ్రేణిని వివరించడానికి ఉపయోగిస్తారు.
- 1957 [పర్సెప్ట్రాన్](https://wikipedia.org/wiki/Perceptron) అమెరికన్ సైకాలజిస్ట్ ఫ్రాంక్ రోజెన్‌బ్లాట్ ఆవిష్కరించిన ఒక రేఖీయ వర్గీకరణ పద్ధతి, దీని ఆధారంగా డీప్ లెర్నింగ్ అభివృద్ధి జరిగింది.
---
- 1967 [నియరెస్ట్ నైబర్](https://wikipedia.org/wiki/Nearest_neighbor) మొదట రూట్లను మ్యాప్ చేయడానికి రూపొందించిన అల్గోరిథం. ML సందర్భంలో ఇది నమూనాలను గుర్తించడానికి ఉపయోగిస్తారు.
- 1970 [బ్యాక్‌ప్రొపగేషన్](https://wikipedia.org/wiki/Backpropagation) [ఫీడ్‌ఫార్వర్డ్ న్యూరల్ నెట్‌వర్క్స్](https://wikipedia.org/wiki/Feedforward_neural_network) శిక్షణకు ఉపయోగిస్తారు.
- 1982 [రికరెంట్ న్యూరల్ నెట్‌వర్క్స్](https://wikipedia.org/wiki/Recurrent_neural_network) ఫీడ్‌ఫార్వర్డ్ న్యూరల్ నెట్‌వర్క్స్ నుండి ఉద్భవించిన కృత్రిమ న్యూరల్ నెట్‌వర్క్స్, ఇవి కాలానుగుణ గ్రాఫ్‌లను సృష్టిస్తాయి.
✅ కొంత పరిశోధన చేయండి. ML మరియు AI చరిత్రలో మరే ఇతర తేదీలు కీలకమైనవిగా కనిపిస్తున్నాయా?
---
## 1950: ఆలోచించే యంత్రాలు
అలన్ ట్యూరింగ్, 2019లో [ప్రజల చేత](https://wikipedia.org/wiki/Icons:_The_Greatest_Person_of_the_20th_Century) 20వ శతాబ్దంలో గొప్ప శాస్త్రవేత్తగా ఎన్నుకోబడిన అసాధారణ వ్యక్తి, 'ఆలోచించే యంత్రం' అనే భావనకు పునాది వేసినవాడిగా గుర్తించబడ్డాడు. ఈ భావనకు సంబంధించిన అనుమానాలను మరియు తన స్వంత అనుభవ ఆధారాలను ఎదుర్కొంటూ, [ట్యూరింగ్ టెస్ట్](https://www.bbc.com/news/technology-18475646) ను సృష్టించాడు, దీన్ని మీరు మా NLP పాఠాలలో అన్వేషిస్తారు.
---
## 1956: డార్ట్‌మౌత్ సమ్మర్ రీసెర్చ్ ప్రాజెక్ట్
"డార్ట్‌మౌత్ సమ్మర్ రీసెర్చ్ ప్రాజెక్ట్ ఆర్టిఫిషియల్ ఇంటెలిజెన్స్ పై ఒక ప్రాముఖ్యమైన సంఘటన," మరియు ఇక్కడే 'ఆర్టిఫిషియల్ ఇంటెలిజెన్స్' అనే పదం రూపొందించబడింది ([మూలం](https://250.dartmouth.edu/highlights/artificial-intelligence-ai-coined-dartmouth)).
> నేర్చుకునే ప్రతి అంశం లేదా ఇంటెలిజెన్స్ యొక్క ఏ ఇతర లక్షణం సూత్రంగా అంతగా ఖచ్చితంగా వివరించబడవచ్చు, అప్పుడు ఒక యంత్రం దాన్ని అనుకరించగలదు.
---
ముఖ్య పరిశోధకుడు, గణిత శాస్త్ర ప్రొఫెసర్ జాన్ మెకార్తీ, "నేర్చుకునే ప్రతి అంశం లేదా ఇంటెలిజెన్స్ యొక్క ఏ ఇతర లక్షణం సూత్రంగా అంతగా ఖచ్చితంగా వివరించబడవచ్చు, అప్పుడు ఒక యంత్రం దాన్ని అనుకరించగలదు" అనే ఊహాపోకును ఆధారంగా ముందుకు సాగాలని ఆశించాడు. పాల్గొనేవారిలో మరొక ప్రముఖుడు మార్విన్ మిన్స్కీ కూడా ఉన్నారు.
ఈ వర్క్‌షాప్ "సింబాలిక్ పద్ధతుల పెరుగుదల, పరిమిత డొమైన్‌లపై కేంద్రీకృత వ్యవస్థలు (ప్రారంభ నిపుణుల వ్యవస్థలు), మరియు డెడక్టివ్ వ్యవస్థలు వర్సెస్ ఇండక్టివ్ వ్యవస్థలు" వంటి చర్చలను ప్రారంభించి ప్రోత్సహించిందని గుర్తించబడింది ([మూలం](https://wikipedia.org/wiki/Dartmouth_workshop)).
---
## 1956 - 1974: "సువర్ణ యుగం"
1950ల నుండి మధ్య 70ల వరకు, AI అనేక సమస్యలను పరిష్కరించగలదని ఆశలు ఎక్కువగా ఉండేవి. 1967లో, మార్విన్ మిన్స్కీ ధైర్యంగా "ఒక తరం లోపల ... 'ఆర్టిఫిషియల్ ఇంటెలిజెన్స్' సృష్టించే సమస్య సార్వత్రికంగా పరిష్కరించబడుతుంది" అని ప్రకటించాడు. (మిన్స్కీ, మార్విన్ (1967), కంప్యూటేషన్: ఫైనైట్ అండ్ ఇన్ఫినైట్ మెషీన్స్, ఎంగిల్వుడ్ క్లిఫ్స్, N.J.: ప్రెంటిస్-హాల్)
ప్రాకృతిక భాషా ప్రాసెసింగ్ పరిశోధన అభివృద్ధి చెందింది, శోధన మెరుగుపడింది మరియు శక్తివంతమైంది, మరియు 'మైక్రో-ప్రపంచాలు' అనే భావన సృష్టించబడింది, ఇక్కడ సాదా పనులు సాదా భాషా సూచనలతో పూర్తయ్యాయి.
---
ప్రభుత్వ సంస్థల ద్వారా పరిశోధనకు మంచి నిధులు అందించబడ్డాయి, కంప్యూటేషన్ మరియు అల్గోరిథమ్స్‌లో పురోగతి సాధించబడింది, మరియు తెలివైన యంత్రాల నమూనాలు నిర్మించబడ్డాయి. ఈ యంత్రాలలో కొన్ని:
* [షేకీ రోబోట్](https://wikipedia.org/wiki/Shakey_the_robot), ఇది చురుకైన విధంగా పనులు చేయగలదు మరియు నిర్ణయాలు తీసుకోగలదు.
![షేకీ, ఒక తెలివైన రోబోట్](../../../../translated_images/shakey.4dc17819c447c05bf4b52f76da0bdd28817d056fdb906252ec20124dd4cfa55e.te.jpg)
> 1972లో షేకీ
---
* ఎలిజా, ఒక ప్రారంభ 'చాటర్‌బాట్', ప్రజలతో సంభాషించగలదు మరియు ప్రాథమిక 'థెరపిస్ట్'గా పనిచేయగలదు. మీరు NLP పాఠాలలో ఎలిజా గురించి మరింత తెలుసుకుంటారు.
![ఎలిజా, ఒక బాట్](../../../../translated_images/eliza.84397454cda9559bb5ec296b5b8fff067571c0cccc5405f9c1ab1c3f105c075c.te.png)
> ఎలిజా యొక్క ఒక వెర్షన్, ఒక చాట్‌బాట్
---
* "బ్లాక్స్ వరల్డ్" అనేది ఒక మైక్రో-ప్రపంచం ఉదాహరణ, ఇక్కడ బ్లాక్స్‌ను క్రమబద్ధీకరించి, యంత్రాలను నిర్ణయాలు తీసుకోవడానికి శిక్షణ ఇవ్వడం పరీక్షించబడింది. [SHRDLU](https://wikipedia.org/wiki/SHRDLU) వంటి లైబ్రరీలతో అభివృద్ధి భాషా ప్రాసెసింగ్‌ను ముందుకు తీసుకెళ్లింది.
[![SHRDLUతో బ్లాక్స్ వరల్డ్](https://img.youtube.com/vi/QAJz4YKUwqw/0.jpg)](https://www.youtube.com/watch?v=QAJz4YKUwqw "SHRDLUతో బ్లాక్స్ వరల్డ్")
> 🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి: SHRDLUతో బ్లాక్స్ వరల్డ్
---
## 1974 - 1980: "AI శీతాకాలం"
1970ల మధ్యలో, 'తెలివైన యంత్రాలు' తయారీలో ఉన్న క్లిష్టత తక్కువగా అంచనా వేయబడిందని మరియు అందుబాటులో ఉన్న కంప్యూట్ శక్తి పరిమితి కారణంగా వాగ్దానం అధికంగా చూపబడిందని స్పష్టమైంది. నిధులు తగ్గిపోయాయి మరియు రంగంపై నమ్మకం తగ్గింది. నమ్మకాన్ని ప్రభావితం చేసిన కొన్ని సమస్యలు:
---
- **పరిమితులు**. కంప్యూట్ శక్తి చాలా పరిమితంగా ఉంది.
- **కాంబినేటోరియల్ పేలుడు**. కంప్యూటర్లకు ఎక్కువగా అడిగిన కొద్దీ శిక్షణకు అవసరమైన పారామితులు గణనీయంగా పెరిగాయి, కానీ కంప్యూట్ శక్తి మరియు సామర్థ్యం సమాంతరంగా అభివృద్ధి కాలేదు.
- **డేటా కొరత**. అల్గోరిథమ్స్‌ను పరీక్షించడం, అభివృద్ధి చేయడం మరియు మెరుగుపరచడం లో డేటా కొరత అడ్డంకిగా నిలిచింది.
- **మనం సరైన ప్రశ్నలు అడుగుతున్నామా?**. అడిగే ప్రశ్నలపై కూడా సందేహాలు వచ్చాయి. పరిశోధకులు తమ విధానాలపై విమర్శలు ఎదుర్కొన్నారు:
- ట్యూరింగ్ టెస్టులు 'చైనీస్ రూమ్ థియరీ' వంటి ఆలోచనల ద్వారా ప్రశ్నించబడ్డాయి, ఇది "డిజిటల్ కంప్యూటర్ ప్రోగ్రామింగ్ భాషను అర్థం చేసుకున్నట్లు కనిపించవచ్చు కానీ నిజమైన అర్థం ఇవ్వలేడు" అని సూచిస్తుంది. ([మూలం](https://plato.stanford.edu/entries/chinese-room/))
- "థెరపిస్ట్" ఎలిజా వంటి ఆర్టిఫిషియల్ ఇంటెలిజెన్సెస్‌ను సమాజంలో ప్రవేశపెట్టడంపై నైతికత ప్రశ్నించబడింది.
---
అదే సమయంలో, వివిధ AI ఆలోచనా పాఠశాలలు ఏర్పడటం ప్రారంభమయ్యాయి. ["స్క్రఫీ" వర్సెస్ "నీట్ AI"](https://wikipedia.org/wiki/Neats_and_scruffies) మధ్య విభేదం ఏర్పడింది. _స్క్రఫీ_ ప్రయోగశాలలు గంటల తరబడి ప్రోగ్రామ్లను సవరించి కావలసిన ఫలితాలు పొందేవి. _నీట్_ ప్రయోగశాలలు "తర్కం మరియు అధికారిక సమస్య పరిష్కారంపై" దృష్టి పెట్టేవి. ఎలిజా మరియు SHRDLU ప్రసిద్ధ _స్క్రఫీ_ వ్యవస్థలు. 1980లలో, ML వ్యవస్థలను పునరుత్పాదకంగా చేయాలనే డిమాండ్ పెరిగినప్పుడు, _నీట్_ విధానం ముందంజలోకి వచ్చింది ఎందుకంటే దాని ఫలితాలు మరింత వివరణాత్మకంగా ఉంటాయి.
---
## 1980ల నిపుణుల వ్యవస్థలు
రంగం పెరిగేకొద్దీ, వ్యాపారానికి దాని లాభం స్పష్టమైంది, మరియు 1980లలో 'నిపుణుల వ్యవస్థలు' విస్తరించాయి. "నిపుణుల వ్యవస్థలు ఆర్టిఫిషియల్ ఇంటెలిజెన్స్ (AI) సాఫ్ట్‌వేర్ యొక్క మొదటి విజయవంతమైన రూపాలలో ఒకటిగా ఉన్నాయి." ([మూలం](https://wikipedia.org/wiki/Expert_system)).
ఈ రకం వ్యవస్థ వాస్తవానికి _హైబ్రిడ్_, ఇది భాగంగా వ్యాపార అవసరాలను నిర్వచించే నియమాల ఇంజిన్ మరియు నియమాల వ్యవస్థను ఉపయోగించి కొత్త వాస్తవాలను తేల్చుకునే ఇన్ఫరెన్స్ ఇంజిన్ కలిగి ఉంటుంది.
ఈ యుగంలో న్యూరల్ నెట్‌వర్క్స్ పై పెరుగుతున్న దృష్టి కూడా కనిపించింది.
---
## 1987 - 1993: AI 'చిల్'
ప్రత్యేక నిపుణుల వ్యవస్థల హార్డ్వేర్ విస్తరణ చాలా ప్రత్యేకంగా మారింది. వ్యక్తిగత కంప్యూటర్ల పెరుగుదల ఈ పెద్ద, ప్రత్యేక, కేంద్రీకృత వ్యవస్థలతో పోటీ పడింది. కంప్యూటింగ్ ప్రజలందరికీ అందుబాటులోకి వచ్చింది, ఇది పెద్ద డేటా విప్లవానికి దారితీసింది.
---
## 1993 - 2011
ఈ కాలం ML మరియు AIకి కొత్త యుగాన్ని తెచ్చింది, ఇది ముందుగా డేటా మరియు కంప్యూట్ శక్తి కొరత కారణంగా ఏర్పడిన సమస్యలను పరిష్కరించగలిగింది. డేటా పరిమాణం వేగంగా పెరిగింది మరియు విస్తృతంగా అందుబాటులోకి వచ్చింది, ముఖ్యంగా 2007లో స్మార్ట్‌ఫోన్ ఆవిర్భావంతో. కంప్యూట్ శక్తి గణనీయంగా పెరిగింది, అల్గోరిథమ్స్ కూడా అభివృద్ధి చెందాయి. రంగం పూర్వపు స్వేచ్ఛా దశల నుండి ఒక నిజమైన శాస్త్రంగా మారింది.
---
## ఇప్పుడు
ఈ రోజుల్లో మెషీన్ లెర్నింగ్ మరియు AI మన జీవితాల ప్రతి భాగాన్ని స్పర్శిస్తున్నాయి. ఈ యుగం ఈ అల్గోరిథమ్స్ మనుషుల జీవితాలపై కలిగించే ప్రమాదాలు మరియు అవకాశాలను జాగ్రత్తగా అర్థం చేసుకోవాలని కోరుతుంది. మైక్రోసాఫ్ట్ బ్రాడ్ స్మిత్ చెప్పినట్లుగా, "సమాచార సాంకేతికత ప్రైవసీ మరియు వ్యక్తి అభివ్యక్తి స్వేచ్ఛ వంటి మౌలిక మానవ హక్కుల రక్షణకు సంబంధించిన అంశాలను తీసుకువస్తుంది. ఈ ఉత్పత్తులను సృష్టించే సాంకేతిక సంస్థలపై బాధ్యత పెరుగుతుంది. మా దృష్టిలో, ఇది ఆలోచనాత్మక ప్రభుత్వ నియంత్రణ మరియు అనుకూల ఉపయోగాల చుట్టూ నిబంధనల అభివృద్ధిని కూడా కోరుతుంది" ([మూలం](https://www.technologyreview.com/2019/12/18/102365/the-future-of-ais-impact-on-society/)).
---
భవిష్యత్తు ఏమి తెచ్చిపెడుతుందో చూడాలి, కానీ ఈ కంప్యూటర్ వ్యవస్థలు మరియు అవి నడిపే సాఫ్ట్‌వేర్ మరియు అల్గోరిథమ్స్‌ను అర్థం చేసుకోవడం ముఖ్యం. ఈ పాఠ్యక్రమం మీకు మెరుగైన అవగాహన ఇవ్వాలని మేము ఆశిస్తున్నాము, తద్వారా మీరు స్వయంగా నిర్ణయం తీసుకోవచ్చు.
[![డీప్ లెర్నింగ్ చరిత్ర](https://img.youtube.com/vi/mTtDfKgLm54/0.jpg)](https://www.youtube.com/watch?v=mTtDfKgLm54 "డీప్ లెర్నింగ్ చరిత్ర")
> 🎥 ఈ లెక్చర్‌లో డీప్ లెర్నింగ్ చరిత్రను యాన్ లెకన్ చర్చిస్తున్న వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి
---
## 🚀సవాలు
ఈ చారిత్రక క్షణాలలో ఒకదానిలో లోతుగా పరిశోధన చేయండి మరియు వాటి వెనుక ఉన్న వ్యక్తుల గురించి మరింత తెలుసుకోండి. ఆసక్తికరమైన వ్యక్తిత్వాలు ఉన్నాయి, మరియు ఎలాంటి శాస్త్రీయ ఆవిష్కరణ కూడా సాంస్కృతిక ఖాళీలో సృష్టించబడలేదు. మీరు ఏమి కనుగొంటారు?
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
---
## సమీక్ష & స్వీయ అధ్యయనం
ఇక్కడ చూడటానికి మరియు వినటానికి అంశాలు ఉన్నాయి:
[ఈ పోडकాస్ట్‌లో ఎమీ బాయిడ్ AI అభివృద్ధిని చర్చిస్తున్నారు](http://runasradio.com/Shows/Show/739)
[![ఎమీ బాయిడ్ ద్వారా AI చరిత్ర](https://img.youtube.com/vi/EJt3_bFYKss/0.jpg)](https://www.youtube.com/watch?v=EJt3_bFYKss "ఎమీ బాయిడ్ ద్వారా AI చరిత్ర")
---
## అసైన్‌మెంట్
[టైమ్‌లైన్ సృష్టించండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/1-Introduction/2-history-of-ML/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "eb6e4d5afd1b21a57d2b9e6d0aac3969",
"translation_date": "2025-12-19T13:32:15+00:00",
"source_file": "1-Introduction/2-history-of-ML/assignment.md",
"language_code": "te"
}
-->
# టైమ్‌లైన్ సృష్టించండి
## సూచనలు
[ఈ రిపో](https://github.com/Digital-Humanities-Toolkit/timeline-builder) ఉపయోగించి, అల్గోరిథమ్స్, గణితం, గణాంకాలు, AI, లేదా ML చరిత్రలోని ఏదైనా అంశం లేదా వాటి కలయికపై ఒక టైమ్‌లైన్ సృష్టించండి. మీరు ఒక వ్యక్తి, ఒక ఆలోచన, లేదా దీర్ఘకాలిక ఆలోచనల వ్యవధిపై దృష్టి పెట్టవచ్చు. మల్టీమీడియా అంశాలను జోడించడం తప్పనిసరి.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | ------------------------------------------------- | --------------------------------------- | ---------------------------------------------------------------- |
| | GitHub పేజీగా ఒక డిప్లాయ్ చేసిన టైమ్‌లైన్ అందించబడింది | కోడ్ అసంపూర్ణంగా ఉంది మరియు డిప్లాయ్ చేయబడలేదు | టైమ్‌లైన్ అసంపూర్ణం, బాగా పరిశోధించబడలేదు మరియు డిప్లాయ్ చేయబడలేదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

172
translations/te/1-Introduction/3-fairness/README.md
Unescape View File

@ -0,0 +1,172 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "9a6b702d1437c0467e3c5c28d763dac2",
"translation_date": "2025-12-19T13:39:37+00:00",
"source_file": "1-Introduction/3-fairness/README.md",
"language_code": "te"
}
-->
# బాధ్యతాయుత AIతో మెషీన్ లెర్నింగ్ పరిష్కారాలను నిర్మించడం
![మెషీన్ లెర్నింగ్‌లో బాధ్యతాయుత AI యొక్క సారాంశం స్కెచ్ నోట్](../../../../translated_images/ml-fairness.ef296ebec6afc98a44566d7b6c1ed18dc2bf1115c13ec679bb626028e852fa1d.te.png)
> స్కెచ్ నోట్: [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## పరిచయం
ఈ పాఠ్యक्रमంలో, మీరు మెషీన్ లెర్నింగ్ మన రోజువారీ జీవితాలను ఎలా ప్రభావితం చేస్తుందో మరియు చేస్తోంది అనేది కనుగొనడం ప్రారంభిస్తారు. ఇప్పటికీ, వ్యవస్థలు మరియు మోడల్స్ ఆరోగ్య సంరక్షణ నిర్ధారణలు, రుణ ఆమోదాలు లేదా మోసం గుర్తింపు వంటి రోజువారీ నిర్ణయాల పనుల్లో పాల్గొంటున్నాయి. కాబట్టి, ఈ మోడల్స్ విశ్వసనీయ ఫలితాలను అందించడానికి బాగా పనిచేయడం ముఖ్యం. ఏ సాఫ్ట్‌వేర్ అప్లికేషన్ లాగా, AI వ్యవస్థలు కూడా అంచనాలను మించిపోవచ్చు లేదా అనుచిత ఫలితాన్ని కలిగించవచ్చు. అందుకే AI మోడల్ యొక్క ప్రవర్తనను అర్థం చేసుకోవడం మరియు వివరించడం చాలా అవసరం.
మీరు ఈ మోడల్స్ నిర్మించడానికి ఉపయోగిస్తున్న డేటా కొన్ని జనాభా గుంపులను, ఉదాహరణకు జాతి, లింగం, రాజకీయ దృష్టికోణం, మతం లేకుండా లేదా అసమానంగా ప్రతిబింబిస్తే ఏమవుతుంది అని ఊహించండి. మోడల్ అవుట్‌పుట్ కొన్ని జనాభా గుంపులను ప్రాధాన్యం ఇస్తే ఏమవుతుంది? అప్లికేషన్‌కు దాని పరిణామం ఏమిటి? అదనంగా, మోడల్ ప్రతికూల ఫలితాన్ని కలిగించి ప్రజలకు హానికరంగా ఉంటే ఏమవుతుంది? AI వ్యవస్థ ప్రవర్తనకు ఎవరు బాధ్యత వహిస్తారు? ఈ పాఠ్యక్రమంలో మనం ఈ ప్రశ్నలను పరిశీలిస్తాము.
ఈ పాఠంలో మీరు:
- మెషీన్ లెర్నింగ్‌లో న్యాయసమ్మతత మరియు న్యాయసమ్మతత సంబంధిత హానుల ప్రాముఖ్యతపై అవగాహన పెంచుకోండి.
- విశ్వసనీయత మరియు భద్రతను నిర్ధారించడానికి అవుట్లయర్స్ మరియు అసాధారణ పరిస్థితులను పరిశీలించే ఆచరణకు పరిచయం పొందండి.
- సమగ్ర వ్యవస్థలను రూపకల్పన చేయడం ద్వారా అందరినీ శక్తివంతం చేయాల్సిన అవసరాన్ని అర్థం చేసుకోండి.
- డేటా మరియు ప్రజల గోప్యత మరియు భద్రతను రక్షించడం ఎంత ముఖ్యమో తెలుసుకోండి.
- AI మోడల్స్ ప్రవర్తనను వివరించడానికి గ్లాస్ బాక్స్ దృష్టికోణం ఉండటం ప్రాముఖ్యతను చూడండి.
- AI వ్యవస్థలపై నమ్మకాన్ని నిర్మించడానికి బాధ్యత ఎంత అవసరమో జాగ్రత్తగా ఉండండి.
## ముందస్తు అర్హత
ముందస్తుగా, "బాధ్యతాయుత AI సూత్రాలు" నేర్చుకునే మార్గాన్ని తీసుకోండి మరియు క్రింద వీడియోను చూడండి:
బాధ్యతాయుత AI గురించి మరింత తెలుసుకోడానికి ఈ [Learning Path](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77952-leestott) ను అనుసరించండి
[![Microsoft's Approach to Responsible AI](https://img.youtube.com/vi/dnC8-uUZXSc/0.jpg)](https://youtu.be/dnC8-uUZXSc "Microsoft's Approach to Responsible AI")
> 🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి: Microsoft's Approach to Responsible AI
## న్యాయసమ్మతత
AI వ్యవస్థలు అందరితో సమానంగా వ్యవహరించాలి మరియు సమానమైన ప్రజా గుంపులపై వేరువేరు ప్రభావాలు చూపకుండా ఉండాలి. ఉదాహరణకు, AI వ్యవస్థలు వైద్య చికిత్స, రుణ దరఖాస్తులు లేదా ఉద్యోగం గురించి మార్గదర్శనం అందిస్తే, సమాన లక్షణాలు, ఆర్థిక పరిస్థితులు లేదా వృత్తిపరమైన అర్హతలున్న అందరికీ అదే సిఫార్సులు ఇవ్వాలి. మనలో ప్రతి ఒక్కరూ మన నిర్ణయాలు మరియు చర్యలపై ప్రభావం చూపే వారసత్వ పక్షపాతాలను కలిగి ఉంటాము. ఈ పక్షపాతాలు AI వ్యవస్థలను శిక్షణ ఇచ్చే డేటాలో స్పష్టంగా ఉండవచ్చు. ఈ రకమైన మానిప్యులేషన్ అనుకోకుండా కూడా జరిగే అవకాశం ఉంది. మీరు డేటాలో పక్షపాతాన్ని ప్రవేశపెడుతున్నప్పుడు అది తెలుసుకోవడం చాలా కష్టం.
**“అన్యాయత”** అనేది జాతి, లింగం, వయస్సు లేదా వికలాంగత స్థితి వంటి ప్రమాణాల ప్రకారం నిర్వచించబడిన ప్రజా గుంపుకు ప్రతికూల ప్రభావాలు లేదా “హానులు” ను సూచిస్తుంది. ప్రధాన న్యాయసమ్మతత సంబంధిత హానులను ఈ విధంగా వర్గీకరించవచ్చు:
- **విభజన**, ఉదాహరణకు ఒక లింగం లేదా జాతి మరొకదానిపై ప్రాధాన్యం పొందడం.
- **సేవా నాణ్యత**. మీరు ఒక నిర్దిష్ట పరిస్థితికి డేటాను శిక్షణ ఇస్తే కానీ వాస్తవం చాలా క్లిష్టమైనదైతే, అది తక్కువ పనితీరు కలిగిన సేవకు దారితీస్తుంది. ఉదాహరణకు, చర్మం గాఢంగా ఉన్న వ్యక్తులను గుర్తించలేని హ్యాండ్ సోప్ డిస్పెన్సర్. [సూచన](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
- **అవమానం**. అన్యాయంగా విమర్శించడం మరియు ఏదైనా లేదా ఎవరోను లేబుల్ చేయడం. ఉదాహరణకు, ఒక చిత్రం లేబెలింగ్ సాంకేతికత చర్మం గాఢంగా ఉన్న వ్యక్తుల చిత్రాలను గోరిల్లాలుగా తప్పుగా లేబుల్ చేసింది.
- **అధిక లేదా తక్కువ ప్రాతినిధ్యం**. ఒక నిర్దిష్ట గుంపు ఒక నిర్దిష్ట వృత్తిలో కనిపించకపోవడం, మరియు ఆ సేవ లేదా ఫంక్షన్ ఆ గుంపును ప్రోత్సహించడం హానికరంగా మారడం.
- **స్టీరియోటైపింగ్**. ఒక గుంపును ముందుగా కేటాయించిన లక్షణాలతో అనుసంధానం చేయడం. ఉదాహరణకు, ఆంగ్లం మరియు టర్కిష్ మధ్య భాషా అనువాద వ్యవస్థలో లింగానికి సంబంధించిన స్టీరియోటైపికల్ పదాల కారణంగా తప్పులు ఉండవచ్చు.
![translation to Turkish](../../../../translated_images/gender-bias-translate-en-tr.f185fd8822c2d4372912f2b690f6aaddd306ffbb49d795ad8d12a4bf141e7af0.te.png)
> టర్కిష్‌కు అనువాదం
![translation back to English](../../../../translated_images/gender-bias-translate-tr-en.4eee7e3cecb8c70e13a8abbc379209bc8032714169e585bdeac75af09b1752aa.te.png)
> ఇంగ్లీష్‌కు తిరిగి అనువాదం
AI వ్యవస్థలను రూపకల్పన మరియు పరీక్షల సమయంలో, AI న్యాయసమ్మతమైనదిగా ఉండాలని మరియు పక్షపాత లేదా వివక్షాత్మక నిర్ణయాలు తీసుకోకుండా ప్రోగ్రామ్ చేయబడకూడదని నిర్ధారించాలి, ఇవి మానవులు కూడా చేయకూడదు. AI మరియు మెషీన్ లెర్నింగ్‌లో న్యాయసమ్మతతను హామీ చేయడం ఒక క్లిష్టమైన సామాజిక సాంకేతిక సవాలు.
### విశ్వసనీయత మరియు భద్రత
నమ్మకాన్ని నిర్మించడానికి, AI వ్యవస్థలు సాధారణ మరియు అనూహ్య పరిస్థితులలో విశ్వసనీయంగా, భద్రంగా మరియు సుసంగతంగా ఉండాలి. AI వ్యవస్థలు వివిధ పరిస్థితుల్లో ఎలా ప్రవర్తిస్తాయో, ముఖ్యంగా అవుట్లయర్స్ ఉన్నప్పుడు తెలుసుకోవడం ముఖ్యం. AI పరిష్కారాలను నిర్మించేటప్పుడు, AI పరిష్కారాలు ఎదుర్కొనే విస్తృత పరిస్థితులను ఎలా నిర్వహించాలో పెద్ద దృష్టి పెట్టాలి. ఉదాహరణకు, స్వయం-చాలించే కారు ప్రజల భద్రతను అత్యంత ప్రాధాన్యతగా ఉంచాలి. అందువల్ల, కారును నడిపించే AI రాత్రి, మెరుపులు లేదా మంచు తుఫానులు, పిల్లలు వీధి దాటడం, పెంపుడు జంతువులు, రోడ్డు నిర్మాణాలు వంటి అన్ని సాధ్యమైన పరిస్థితులను పరిగణలోకి తీసుకోవాలి. AI వ్యవస్థ విస్తృత పరిస్థితులను విశ్వసనీయంగా మరియు భద్రంగా ఎలా నిర్వహించగలదో, డేటా శాస్త్రవేత్త లేదా AI అభివృద్ధికర్త ఆ వ్యవస్థ రూపకల్పన లేదా పరీక్ష సమయంలో ఎంత ముందస్తుగా ఆలోచించారో ప్రతిబింబిస్తుంది.
> [🎥 వీడియో కోసం ఇక్కడ క్లిక్ చేయండి: ](https://www.microsoft.com/videoplayer/embed/RE4vvIl)
### సమగ్రత
AI వ్యవస్థలు అందరినీ పాల్గొనడానికి మరియు శక్తివంతం చేయడానికి రూపకల్పన చేయబడాలి. AI వ్యవస్థలను రూపకల్పన మరియు అమలు చేసే సమయంలో, డేటా శాస్త్రవేత్తలు మరియు AI అభివృద్ధికర్తలు అనుకోకుండా ప్రజలను బహిష్కరించే అవకాశమున్న అడ్డంకులను గుర్తించి పరిష్కరిస్తారు. ఉదాహరణకు, ప్రపంచంలో 1 బిలియన్ మంది వికలాంగులు ఉన్నారు. AI అభివృద్ధితో, వారు తమ రోజువారీ జీవితాల్లో విస్తృత సమాచారం మరియు అవకాశాలను సులభంగా పొందగలుగుతారు. అడ్డంకులను పరిష్కరించడం ద్వారా, అందరికీ లాభదాయకమైన మెరుగైన అనుభవాలతో AI ఉత్పత్తులను ఆవిష్కరించడానికి మరియు అభివృద్ధి చేయడానికి అవకాశాలు సృష్టించబడతాయి.
> [🎥 వీడియో కోసం ఇక్కడ క్లిక్ చేయండి: AIలో సమగ్రత](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
### భద్రత మరియు గోప్యత
AI వ్యవస్థలు భద్రంగా ఉండాలి మరియు ప్రజల గోప్యతను గౌరవించాలి. ప్రజలు తమ గోప్యత, సమాచారం లేదా జీవితం ప్రమాదంలో పడే వ్యవస్థలపై తక్కువ నమ్మకం కలిగి ఉంటారు. మెషీన్ లెర్నింగ్ మోడల్స్ శిక్షణకు, ఉత్తమ ఫలితాలను అందించడానికి డేటాపై ఆధారపడతాము. అందులో, డేటా మూలం మరియు సమగ్రతను పరిగణలోకి తీసుకోవాలి. ఉదాహరణకు, డేటా వినియోగదారు సమర్పించినదా లేదా ప్రజలకు అందుబాటులో ఉన్నదా? తదుపరి, డేటాతో పని చేసే సమయంలో, గోప్యమైన సమాచారాన్ని రక్షించగలిగే మరియు దాడులను నిరోధించగల AI వ్యవస్థలను అభివృద్ధి చేయడం అత్యంత ముఖ్యం. AI విస్తృతంగా ఉపయోగించబడుతున్నందున, గోప్యతను రక్షించడం మరియు వ్యక్తిగత మరియు వ్యాపార సమాచారాన్ని భద్రపరచడం మరింత కీలకంగా మరియు క్లిష్టంగా మారుతోంది. గోప్యత మరియు డేటా భద్రతా సమస్యలు AIకి ప్రత్యేక శ్రద్ధ అవసరం ఎందుకంటే AI వ్యవస్థలు ప్రజల గురించి ఖచ్చితమైన మరియు సమాచారంతో కూడిన అంచనాలు మరియు నిర్ణయాలు తీసుకోవడానికి డేటా యాక్సెస్ అవసరం.
> [🎥 వీడియో కోసం ఇక్కడ క్లిక్ చేయండి: AIలో భద్రత](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- పరిశ్రమగా, GDPR (సాధారణ డేటా రక్షణ నియంత్రణ) వంటి నియమావళుల ద్వారా గోప్యత మరియు భద్రతలో గణనీయమైన పురోగతులు సాధించాము.
- అయినప్పటికీ, AI వ్యవస్థలతో, వ్యవస్థలను మరింత వ్యక్తిగతంగా మరియు సమర్థవంతంగా చేయడానికి మరింత వ్యక్తిగత డేటా అవసరం మరియు గోప్యత మధ్య ఉన్న ఉద్వేగాన్ని అంగీకరించాలి.
- ఇంటర్నెట్‌తో కనెక్ట్ అయిన కంప్యూటర్ల జన్మతో పోలిస్తే, AIకి సంబంధించిన భద్రతా సమస్యల సంఖ్యలో కూడా భారీ పెరుగుదల కనిపిస్తోంది.
- అదే సమయంలో, భద్రతను మెరుగుపరచడానికి AI ఉపయోగించబడుతున్నది. ఉదాహరణకు, ఆధునిక యాంటీ-వైరస్ స్కానర్లు ఎక్కువగా AI హ్యూరిస్టిక్స్ ఆధారంగా పనిచేస్తున్నాయి.
- మన డేటా సైన్స్ ప్రక్రియలు తాజా గోప్యత మరియు భద్రతా ఆచారాలతో సజీవంగా కలిసిపోవాలి.
### పారదర్శకత
AI వ్యవస్థలు అర్థమయ్యే విధంగా ఉండాలి. పారదర్శకతలో ముఖ్యమైన భాగం AI వ్యవస్థల మరియు వాటి భాగాల ప్రవర్తనను వివరించడం. AI వ్యవస్థల అర్థం పెరగడానికి వాటి పనితీరు ఎలా మరియు ఎందుకు జరుగుతుందో వాటి భాగస్వాములు అర్థం చేసుకోవాలి, తద్వారా వారు పనితీరు సమస్యలు, భద్రత మరియు గోప్యతా సమస్యలు, పక్షపాతాలు, బహిష్కరణా ఆచారాలు లేదా అనుకోని ఫలితాలను గుర్తించగలుగుతారు. AI వ్యవస్థలను ఉపయోగించే వారు ఎప్పుడు, ఎందుకు, ఎలా వాటిని అమలు చేస్తారో నిజాయితీగా మరియు స్పష్టంగా ఉండాలి. అలాగే వారు ఉపయోగించే వ్యవస్థల పరిమితులను కూడా తెలియజేయాలి. ఉదాహరణకు, ఒక బ్యాంక్ తన వినియోగదారుల రుణ నిర్ణయాలను మద్దతు ఇవ్వడానికి AI వ్యవస్థను ఉపయోగిస్తే, ఫలితాలను పరిశీలించడం మరియు ఏ డేటా వ్యవస్థ సిఫార్సులకు ప్రభావం చూపుతుందో అర్థం చేసుకోవడం ముఖ్యం. ప్రభుత్వాలు పరిశ్రమలలో AI నియంత్రణ ప్రారంభిస్తున్నాయి, కాబట్టి డేటా శాస్త్రవేత్తలు మరియు సంస్థలు AI వ్యవస్థ నియంత్రణ అవసరాలు తీర్చుతుందా లేదా అనేది వివరించాలి, ముఖ్యంగా అనుచిత ఫలితాలు ఉన్నప్పుడు.
> [🎥 వీడియో కోసం ఇక్కడ క్లిక్ చేయండి: AIలో పారదర్శకత](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- AI వ్యవస్థలు చాలా క్లిష్టమైనవి కావడంతో అవి ఎలా పనిచేస్తాయో అర్థం చేసుకోవడం మరియు ఫలితాలను అనువదించడం కష్టం.
- ఈ అర్థం లేకపోవడం ఈ వ్యవస్థలను నిర్వహించడం, ఆపరేషన్ చేయడం మరియు డాక్యుమెంటేషన్ చేయడంపై ప్రభావం చూపుతుంది.
- ముఖ్యంగా, ఈ అర్థం లేకపోవడం ఈ వ్యవస్థలు ఉత్పత్తి చేసే ఫలితాల ఆధారంగా తీసుకునే నిర్ణయాలపై ప్రభావం చూపుతుంది.
### బాధ్యత
AI వ్యవస్థలను రూపకల్పన మరియు అమలు చేసే వారు వారి వ్యవస్థలు ఎలా పనిచేస్తాయో బాధ్యత వహించాలి. ముఖచిత్ర గుర్తింపు వంటి సున్నితమైన సాంకేతికతలతో బాధ్యత అవసరం మరింత కీలకం. ఇటీవల, ముఖచిత్ర గుర్తింపు సాంకేతికతకు పెరుగుతున్న డిమాండ్ ఉంది, ముఖ్యంగా మిస్సింగ్ పిల్లలను కనుగొనడంలో ఈ సాంకేతికత ఉపయోగపడుతుందని భావించే చట్ట అమలాదారుల నుండి. అయితే, ఈ సాంకేతికతలు ప్రభుత్వాలు తమ పౌరుల ప్రాథమిక స్వేచ్ఛలను ప్రమాదంలో పెట్టడానికి ఉపయోగించవచ్చు, ఉదాహరణకు నిర్దిష్ట వ్యక్తులపై నిరంతర పర్యవేక్షణను సులభతరం చేయడం. అందువల్ల, డేటా శాస్త్రవేత్తలు మరియు సంస్థలు వారి AI వ్యవస్థ వ్యక్తులు లేదా సమాజంపై ఎలా ప్రభావం చూపుతుందో బాధ్యత వహించాలి.
[![ముఖచిత్ర గుర్తింపు ద్వారా భారీ పర్యవేక్షణపై ప్రముఖ AI పరిశోధకుడు హెచ్చరిస్తున్నారు](../../../../translated_images/accountability.41d8c0f4b85b6231301d97f17a450a805b7a07aaeb56b34015d71c757cad142e.te.png)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Microsoft's Approach to Responsible AI")
> 🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి: ముఖచిత్ర గుర్తింపు ద్వారా భారీ పర్యవేక్షణ హెచ్చరికలు
మొత్తానికి, మన తరం, సమాజానికి AI తీసుకువస్తున్న మొదటి తరం, కంప్యూటర్లు ప్రజలకు బాధ్యత వహించేటట్లు ఎలా నిర్ధారించుకోవాలి మరియు కంప్యూటర్లు రూపకల్పన చేసే వారు అందరికి బాధ్యత వహించేటట్లు ఎలా నిర్ధారించుకోవాలి అనే ప్రశ్నలు మనకు పెద్ద సవాలు.
## ప్రభావం అంచనా
మెషీన్ లెర్నింగ్ మోడల్ శిక్షణకు ముందు, AI వ్యవస్థ యొక్క ఉద్దేశ్యం ఏమిటి; దాని ఉద్దేశించిన ఉపయోగం ఏమిటి; ఎక్కడ అమలు చేయబడుతుంది; మరియు ఎవరు వ్యవస్థతో పరస్పరం చేస్తారు అనే విషయాలను అర్థం చేసుకోవడానికి ప్రభావం అంచనాను నిర్వహించడం ముఖ్యం. ఇవి వ్యవస్థను సమీక్షించే వారు లేదా పరీక్షకులు పరిగణలోకి తీసుకోవాల్సిన అంశాలను తెలుసుకోవడానికి సహాయపడతాయి, తద్వారా వారు సంభావ్య ప్రమాదాలు మరియు ఆశించిన పరిణామాలను గుర్తించగలుగుతారు.
ప్రభావం అంచనా నిర్వహించే సమయంలో దృష్టి పెట్టాల్సిన ప్రాంతాలు:
* **వ్యక్తులపై ప్రతికూల ప్రభావం**. ఏవైనా పరిమితులు లేదా అవసరాలు, మద్దతు లేని ఉపయోగం లేదా వ్యవస్థ పనితీరును అడ్డుకునే ఏవైనా పరిమితులు ఉన్నాయా అని తెలుసుకోవడం ముఖ్యం, తద్వారా వ్యవస్థ వ్యక్తులకు హాని కలిగించే విధంగా ఉపయోగించబడకుండా ఉండాలి.
* **డేటా అవసరాలు**. వ్యవస్థ డేటాను ఎలా మరియు ఎక్కడ ఉపయోగిస్తుందో అర్థం చేసుకోవడం సమీక్షకులకు మీరు జాగ్రత్తగా ఉండాల్సిన డేటా అవసరాలను (ఉదా: GDPR లేదా HIPPA డేటా నియమాలు) పరిశీలించడానికి సహాయపడుతుంది. అదనంగా, శిక్షణకు డేటా మూలం లేదా పరిమాణం సరిపోతుందా అని పరిశీలించండి.
* **ప్రభావం సారాంశం**. వ్యవస్థ ఉపయోగం వల్ల సంభవించే సంభావ్య హానుల జాబితాను సేకరించండి. ML జీవనచక్రం అంతటా గుర్తించిన సమస్యలు తగ్గించబడ్డాయా లేదా పరిష్కరించబడ్డాయా అని సమీక్షించండి.
* ఆరు ప్రధాన సూత్రాల కోసం **ప్రయోజన లక్ష్యాలు**. ప్రతి సూత్రం నుండి లక్ష్యాలు చేరుకున్నాయా లేదా లోపాలు ఉన్నాయా అని అంచనా వేయండి.
## బాధ్యతాయుత AIతో డీబగ్గింగ్
సాఫ్ట్‌వేర్ అప్లికేషన్‌ను డీబగ్గింగ్ చేయడం లాగా, AI వ్యవస్థను డీబగ్గింగ్ చేయడం కూడా వ్యవస్థలో సమస్యలను గుర్తించి పరిష్కరించే అవసరమైన ప్రక్రియ. మోడల్ అంచనాల ప్రకారం కాకుండా లేదా బాధ్యతాయుతంగా పనిచేయకపోవడానికి అనేక కారణాలు ఉండవచ్చు. చాలా సాంప్రదాయ మోడల్ పనితీరు ప్రమాణాలు మోడల్ పనితీరు యొక్క పరిమాణాత్మక సమాహారాలు మాత్రమే, ఇవి బాధ్యతాయుత AI సూత్రాలను ఎలా ఉల్లంఘిస్తున్నాయో విశ్లేషించడానికి సరిపోదు. అదనంగా, మెషీన్ లెర్నింగ్ మోడల్ ఒక బ్లాక్ బాక్స్ లాగా ఉంటుంది, దాని ఫలితానికి కారణమయ్యే అంశాలను అర్థం చేసుకోవడం లేదా తప్పు చేసినప్పుడు వివరణ ఇవ్వడం కష్టం. ఈ కోర్సులో తరువాత, బాధ్యతాయుత AI డాష్‌బోర్డును ఉపయోగించి AI వ్యవస్థలను డీబగ్గింగ్ చేయడం నేర్చుకుంటాము. డాష్‌బోర్డు డేటా శాస్త్రవేత్తలు మరియు AI అభివృద్ధికర్తలకు సమగ్ర సాధనం అందిస్తుంది:
* **లోపాల విశ్లేషణ**. వ్యవస్థ న్యాయసమ్మతత లేదా విశ్వసనీయతను ప్రభావితం చేసే మోడల్ లోపాల పంపిణీని గుర్తించడానికి.
* **మోడల్ అవలోకనం**. డేటా కోహార్ట్లలో మోడల్ పనితీరులో ఉన్న వ్యత్యాసాలను కనుగొనడానికి.
* **డేటా విశ్లేషణ**. డేటా పంపిణీని అర్థం చేసుకోవడానికి మరియు న్యాయసమ్మతత, సమగ్రత మరియు విశ్వసనీయత సమస్యలకు దారితీసే ఏవైనా పక్షపాతాలను గుర్తించడానికి.
* **మోడల్ వివరణాత్మకత**. మోడల్ అంచనాలను ప్రభావితం చేసే అంశాలను అర్థం చేసుకోవడానికి. ఇది మోడల్ ప్రవర్తనను వివరించడంలో సహాయపడుతుంది, ఇది పారదర్శకత మరియు బాధ్యతకు ముఖ్యమైనది.
## 🚀 సవాలు
హానులు మొదట్లోనే ప్రవేశించకుండా ఉండేందుకు, మనం:
- వ్యవస్థలపై పనిచేసే వ్యక్తులలో వివిధ నేపథ్యాలు మరియు దృష్టికోణాలను కలిగి ఉండాలి
- మన సమాజం వైవిధ్యాన్ని ప్రతిబింబించే డేటాసెట్‌లలో పెట్టుబడి పెట్టాలి
- బాధ్యతాయుత AI సంభవించినప్పుడు గుర్తించడం మరియు సరిచేయడం కోసం మెషీన్ లెర్నింగ్ జీవనచక్రం అంతటా మెరుగైన పద్ధతులను అభివృద్ధి చేయాలి
మోడల్ నిర్మాణం మరియు ఉపయోగంలో మోడల్ నమ్మకహీనత స్పష్టంగా కనిపించే వాస్తవ జీవిత పరిస్థితులను ఆలోచించండి. మేము ఇంకేమి పరిగణించాలి?
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
ఈ పాఠంలో, మీరు మెషీన్ లెర్నింగ్‌లో న్యాయం మరియు అన్యాయం యొక్క కొన్ని ప్రాథమిక సూత్రాలను నేర్చుకున్నారు.
ఈ అంశాలలో మరింత లోతుగా తెలుసుకోవడానికి ఈ వర్క్‌షాప్‌ను చూడండి:
- బాధ్యతాయుత AI కోసం ప్రయత్నం: Besmira Nushi, Mehrnoosh Sameki మరియు Amit Sharma ద్వారా సూత్రాలను ఆచరణలోకి తీసుకురావడం
[![Responsible AI Toolbox: An open-source framework for building responsible AI](https://img.youtube.com/vi/tGgJCrA-MZU/0.jpg)](https://www.youtube.com/watch?v=tGgJCrA-MZU "RAI Toolbox: An open-source framework for building responsible AI")
> 🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి: Besmira Nushi, Mehrnoosh Sameki, మరియు Amit Sharma ద్వారా RAI Toolbox: బాధ్యతాయుత AI నిర్మాణానికి ఓ ఓపెన్-సోర్స్ ఫ్రేమ్‌వర్క్
ఇంకా చదవండి:
- Microsoft యొక్క RAI వనరుల కేంద్రం: [Responsible AI Resources – Microsoft AI](https://www.microsoft.com/ai/responsible-ai-resources?activetab=pivot1%3aprimaryr4)
- Microsoft యొక్క FATE పరిశోధనా గ్రూప్: [FATE: Fairness, Accountability, Transparency, and Ethics in AI - Microsoft Research](https://www.microsoft.com/research/theme/fate/)
RAI Toolbox:
- [Responsible AI Toolbox GitHub repository](https://github.com/microsoft/responsible-ai-toolbox)
Azure Machine Learning యొక్క న్యాయాన్ని నిర్ధారించడానికి ఉపయోగించే సాధనాల గురించి చదవండి:
- [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/concept-fairness-ml?WT.mc_id=academic-77952-leestott)
## అసైన్‌మెంట్
[RAI Toolbox ను అన్వేషించండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "dbda60e7b1fe5f18974e7858eff0004e",
"translation_date": "2025-12-19T13:43:21+00:00",
"source_file": "1-Introduction/3-fairness/assignment.md",
"language_code": "te"
}
-->
# బాధ్యతాయుత AI టూల్‌బాక్స్‌ను అన్వేషించండి
## సూచనలు
ఈ పాఠంలో మీరు బాధ్యతాయుత AI టూల్‌బాక్స్ గురించి తెలుసుకున్నారు, ఇది "డేటా శాస్త్రవేత్తలకు AI వ్యవస్థలను విశ్లేషించడానికి మరియు మెరుగుపరచడానికి సహాయపడే ఓపెన్-సోర్స్, కమ్యూనిటీ-చాలిత ప్రాజెక్ట్." ఈ అసైన్‌మెంట్ కోసం, RAI టూల్‌బాక్స్ యొక్క [నోట్‌బుక్స్](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb) లో ఒకదాన్ని అన్వేషించి, మీ కనుగొనిన విషయాలను ఒక పేపర్ లేదా ప్రెజెంటేషన్‌లో నివేదించండి.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతం | సరిపోతుంది | మెరుగుదల అవసరం |
| -------- | --------- | -------- | ----------------- |
| | Fairlearn యొక్క వ్యవస్థలు, నడిపించిన నోట్‌బుక్ మరియు దాన్ని నడిపిన తర్వాత తీసుకున్న తీరులను చర్చిస్తూ ఒక పేపర్ లేదా పవర్‌పాయింట్ ప్రెజెంటేషన్ అందించబడింది | తీరులు లేకుండా ఒక పేపర్ అందించబడింది | ఎలాంటి పేపర్ అందించబడలేదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం మంచిది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

134
translations/te/1-Introduction/4-techniques-of-ML/README.md
Unescape View File

@ -0,0 +1,134 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "9d91f3af3758fdd4569fb410575995ef",
"translation_date": "2025-12-19T13:34:27+00:00",
"source_file": "1-Introduction/4-techniques-of-ML/README.md",
"language_code": "te"
}
-->
# మెషీన్ లెర్నింగ్ సాంకేతికతలు
మెషీన్ లెర్నింగ్ మోడల్స్ మరియు అవి ఉపయోగించే డేటాను నిర్మించడం, ఉపయోగించడం మరియు నిర్వహించడం అనేది అనేక ఇతర అభివృద్ధి వర్క్‌ఫ్లోల నుండి చాలా భిన్నమైన ప్రక్రియ. ఈ పాఠంలో, మేము ఈ ప్రక్రియను సులభతరం చేస్తాము, మరియు మీరు తెలుసుకోవలసిన ప్రధాన సాంకేతికతలను వివరించబోతున్నాము. మీరు:
- మెషీన్ లెర్నింగ్ ఆధారిత ప్రక్రియలను ఉన్నత స్థాయిలో అర్థం చేసుకుంటారు.
- 'మోడల్స్', 'పూర్వానుమానాలు', మరియు 'శిక్షణ డేటా' వంటి ప్రాథమిక భావనలను అన్వేషిస్తారు.
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
[![ML for beginners - Techniques of Machine Learning](https://img.youtube.com/vi/4NGM0U2ZSHU/0.jpg)](https://youtu.be/4NGM0U2ZSHU "ML for beginners - Techniques of Machine Learning")
> 🎥 ఈ పాఠం ద్వారా పనిచేసే చిన్న వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి.
## పరిచయం
ఉన్నత స్థాయిలో, మెషీన్ లెర్నింగ్ (ML) ప్రక్రియలను సృష్టించే కళ అనేక దశలతో కూడి ఉంటుంది:
1. **ప్రశ్నను నిర్ణయించండి**. చాలా ML ప్రక్రియలు సాధారణ కండిషనల్ ప్రోగ్రామ్ లేదా నియమాల ఆధారిత ఇంజిన్ ద్వారా సమాధానం ఇవ్వలేని ప్రశ్న అడగడం ద్వారా ప్రారంభమవుతాయి. ఈ ప్రశ్నలు తరచుగా డేటా సేకరణ ఆధారంగా పూర్వానుమానాల చుట్టూ ఉంటాయి.
2. **డేటాను సేకరించి సిద్ధం చేయండి**. మీ ప్రశ్నకు సమాధానం ఇవ్వడానికి, మీరు డేటా అవసరం. మీ డేటా నాణ్యత మరియు కొన్నిసార్లు పరిమాణం మీ ప్రారంభ ప్రశ్నకు మీరు ఎంత బాగా సమాధానం ఇవ్వగలరో నిర్ణయిస్తుంది. డేటాను దృశ్యీకరించడం ఈ దశలో ముఖ్యమైన అంశం. ఈ దశలో డేటాను శిక్షణ మరియు పరీక్షా సమూహాలుగా విభజించడం కూడా ఉంటుంది.
3. **శిక్షణ పద్ధతిని ఎంచుకోండి**. మీ ప్రశ్న మరియు డేటా స్వభావం ఆధారంగా, మీరు మీ డేటాను ప్రతిబింబించే మరియు దాని పై ఖచ్చితమైన పూర్వానుమానాలు చేయగలిగే మోడల్‌ను శిక్షణ ఇవ్వడానికి ఎలా శిక్షణ ఇవ్వాలనే నిర్ణయించుకోవాలి. ఇది మీ ML ప్రక్రియలో ప్రత్యేక నైపుణ్యం మరియు తరచుగా అనేక ప్రయోగాలు అవసరమయ్యే భాగం.
4. **మోడల్‌ను శిక్షణ ఇవ్వండి**. మీ శిక్షణ డేటాను ఉపయోగించి, మీరు వివిధ అల్గోరిథమ్స్ ఉపయోగించి డేటాలో నమూనాలను గుర్తించే మోడల్‌ను శిక్షణ ఇస్తారు. మోడల్ అంతర్గత బరువులను ఉపయోగించి, డేటా యొక్క కొన్ని భాగాలను ప్రాధాన్యం ఇవ్వడానికి సర్దుబాటు చేయవచ్చు.
5. **మోడల్‌ను మూల్యాంకనం చేయండి**. మీరు సేకరించిన డేటా నుండి ఇప్పటివరకు చూడని డేటా (మీ పరీక్షా డేటా) ఉపయోగించి మోడల్ ఎలా పనిచేస్తుందో చూడండి.
6. **పారామీటర్ ట్యూనింగ్**. మీ మోడల్ పనితీరు ఆధారంగా, మీరు మోడల్ శిక్షణకు ఉపయోగించే అల్గోరిథమ్స్ ప్రవర్తనను నియంత్రించే వివిధ పారామీటర్లను మార్చి ప్రక్రియను మళ్లీ చేయవచ్చు.
7. **పూర్వానుమానం చేయండి**. మీ మోడల్ ఖచ్చితత్వాన్ని పరీక్షించడానికి కొత్త ఇన్‌పుట్‌లను ఉపయోగించండి.
## ఏ ప్రశ్న అడగాలి
కంప్యూటర్లు డేటాలో దాగి ఉన్న నమూనాలను కనుగొనడంలో ప్రత్యేక నైపుణ్యం కలిగి ఉంటాయి. ఈ ఉపయోగం, ఒక నిర్దిష్ట డొమైన్ గురించి ప్రశ్నలు ఉన్న పరిశోధకులకు చాలా సహాయకరం, వీటిని సులభంగా కండిషనల్ నియమాల ఇంజిన్ సృష్టించడం ద్వారా సమాధానం ఇవ్వలేము. ఉదాహరణకు, ఒక ఆక్చ్యూరియల్ పని కోసం, డేటా సైంటిస్ట్ పొగతాగేవారు మరియు పొగతాగని వారి మరణాలపై చేతితో తయారు చేసిన నియమాలను నిర్మించవచ్చు.
అయితే, మరిన్ని వేరియబుల్స్ ఈ సమీకరణలో చేర్చినప్పుడు, గత ఆరోగ్య చరిత్ర ఆధారంగా భవిష్యత్ మరణాల రేట్లను పూర్వానుమానించడానికి ML మోడల్ మరింత సమర్థవంతంగా ఉండవచ్చు. మరింత సంతోషకరమైన ఉదాహరణగా, ఒక నిర్దిష్ట ప్రదేశంలో ఏప్రిల్ నెలకు వాతావరణ పూర్వానుమానాలు చేయడం, ఇందులో అక్షాంశం, రేఖాంశం, వాతావరణ మార్పు, సముద్రానికి సమీపత, జెట్ స్ట్రీమ్ నమూనాలు మరియు మరిన్ని డేటా ఉంటాయి.
✅ ఈ [స్లైడ్ డెక్](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf) వాతావరణ మోడల్స్ పై ML వాడకం కోసం చారిత్రక దృష్టికోణాన్ని అందిస్తుంది.
## నిర్మాణానికి ముందు పనులు
మీ మోడల్‌ను నిర్మించడం ప్రారంభించే ముందు, మీరు పూర్తి చేయవలసిన కొన్ని పనులు ఉన్నాయి. మీ ప్రశ్నను పరీక్షించడానికి మరియు మోడల్ పూర్వానుమానాల ఆధారంగా ఒక హైపోథసిస్ రూపొందించడానికి, మీరు కొన్ని అంశాలను గుర్తించి కాన్ఫిగర్ చేయాలి.
### డేటా
మీ ప్రశ్నకు ఏదైనా స్థాయిలో సమాధానం ఇవ్వడానికి, మీరు సరైన రకమైన మంచి పరిమాణంలో డేటా అవసరం. ఈ సమయంలో మీరు చేయవలసిన రెండు విషయాలు:
- **డేటాను సేకరించండి**. డేటా విశ్లేషణలో న్యాయసమ్మతతపై గత పాఠాన్ని గుర్తుంచుకుని, జాగ్రత్తగా డేటాను సేకరించండి. ఈ డేటా మూలాలను, దాని లోపభూయిష్టతలను తెలుసుకోండి మరియు మూలాన్ని డాక్యుమెంట్ చేయండి.
- **డేటాను సిద్ధం చేయండి**. డేటా సిద్ధం ప్రక్రియలో అనేక దశలు ఉంటాయి. మీరు డేటాను సేకరించి, వేర్వేరు మూలాల నుండి వచ్చినట్లయితే సాధారణీకరించవలసి ఉంటుంది. మీరు డేటా నాణ్యత మరియు పరిమాణాన్ని మెరుగుపరచడానికి వివిధ పద్ధతులు ఉపయోగించవచ్చు, ఉదాహరణకు స్ట్రింగ్స్‌ను సంఖ్యలుగా మార్చడం ([క్లస్టరింగ్](../../5-Clustering/1-Visualize/README.md) లో చేయడం లాంటిది). మీరు కొత్త డేటాను కూడా సృష్టించవచ్చు, అసలు డేటా ఆధారంగా ([వర్గీకరణ](../../4-Classification/1-Introduction/README.md) లో చేయడం లాంటిది). మీరు డేటాను శుభ్రపరచి సవరించవచ్చు ([వెబ్ యాప్](../../3-Web-App/README.md) పాఠం ముందు). చివరగా, మీరు శిక్షణ సాంకేతికతలపై ఆధారపడి డేటాను యాదృచ్ఛికంగా మార్చి కలపవలసి ఉండవచ్చు.
✅ డేటాను సేకరించి ప్రాసెస్ చేసిన తర్వాత, దాని ఆకారం మీ ఉద్దేశించిన ప్రశ్నను పరిష్కరించగలదా అని ఒక క్షణం పరిశీలించండి. మీ డేటా మీ పని లో బాగా పనిచేయకపోవచ్చు, ఇది మేము మా [క్లస్టరింగ్](../../5-Clustering/1-Visualize/README.md) పాఠాలలో కనుగొంటాము!
### లక్షణాలు మరియు లక్ష్యం
[లక్షణం](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection) అనేది మీ డేటా యొక్క కొలవదగిన లక్షణం. అనేక డేటాసెట్‌లలో ఇది 'తేదీ', 'పరిమాణం' లేదా 'రంగు' వంటి కాలమ్ శీర్షికగా వ్యక్తమవుతుంది. మీ లక్షణ వేరియబుల్, సాధారణంగా కోడ్‌లో `X` గా సూచించబడుతుంది, మోడల్ శిక్షణకు ఉపయోగించే ఇన్‌పుట్ వేరియబుల్‌ను సూచిస్తుంది.
లక్ష్యం మీరు పూర్వానుమానం చేయదలచిన విషయం. లక్ష్యం సాధారణంగా కోడ్‌లో `y` గా సూచించబడుతుంది, ఇది మీరు మీ డేటాకు అడగదలచిన ప్రశ్నకు సమాధానం సూచిస్తుంది: డిసెంబర్‌లో, ఏ **రంగు** గుమ్మడికాయలు చౌకగా ఉంటాయి? సాన్ ఫ్రాన్సిస్కోలో, ఏ ప్రాంతాల్లో ఉత్తమ రియల్ ఎస్టేట్ **ధర** ఉంటుంది? కొన్నిసార్లు లక్ష్యాన్ని లేబుల్ అట్రిబ్యూట్ అని కూడా పిలుస్తారు.
### మీ లక్షణ వేరియబుల్‌ను ఎంచుకోవడం
🎓 **లక్షణ ఎంపిక మరియు లక్షణ ఉత్పత్తి** మోడల్ నిర్మిస్తున్నప్పుడు మీరు ఏ వేరియబుల్ ఎంచుకోవాలో ఎలా తెలుసుకుంటారు? మీరు ఎక్కువగా పనితీరు ఉన్న మోడల్ కోసం సరైన వేరియబుల్స్ ఎంచుకోవడానికి లక్షణ ఎంపిక లేదా లక్షణ ఉత్పత్తి ప్రక్రియలోకి వెళ్తారు. అవి ఒకే విషయం కాదు: "లక్షణ ఉత్పత్తి అసలు లక్షణాల ఫంక్షన్ల నుండి కొత్త లక్షణాలను సృష్టిస్తుంది, అయితే లక్షణ ఎంపిక లక్షణాల ఉపసమితిని తిరిగి ఇస్తుంది." ([మూలం](https://wikipedia.org/wiki/Feature_selection))
### మీ డేటాను దృశ్యీకరించండి
డేటా సైంటిస్ట్ టూల్‌కిట్‌లో ఒక ముఖ్యమైన అంశం అనేక అద్భుతమైన లైబ్రరీలు వంటి Seaborn లేదా MatPlotLib ఉపయోగించి డేటాను దృశ్యీకరించడం. మీ డేటాను దృశ్య రూపంలో ప్రదర్శించడం దాగి ఉన్న సంబంధాలను కనుగొనడానికి సహాయపడవచ్చు. మీ దృశ్యీకరణలు పక్షపాతం లేదా అసమతులిత డేటాను కూడా కనుగొనడంలో సహాయపడవచ్చు ([వర్గీకరణ](../../4-Classification/2-Classifiers-1/README.md) లో మేము కనుగొంటాము).
### మీ డేటాసెట్‌ను విభజించండి
శిక్షణకు ముందు, మీరు మీ డేటాసెట్‌ను రెండు లేదా అంతకంటే ఎక్కువ భాగాలుగా విభజించాలి, ఇవి అసమాన పరిమాణాలైనప్పటికీ డేటాను బాగా ప్రతిబింబించాలి.
- **శిక్షణ**. డేటాసెట్ ఈ భాగం మీ మోడల్‌కు సరిపోతుంది, దీని ద్వారా మోడల్ శిక్షణ పొందుతుంది. ఇది అసలు డేటాసెట్‌లో ఎక్కువ భాగాన్ని కలిగి ఉంటుంది.
- **పరీక్ష**. పరీక్షా డేటాసెట్ స్వతంత్ర డేటా సమూహం, తరచుగా అసలు డేటా నుండి సేకరించబడినది, దీన్ని మీరు నిర్మించిన మోడల్ పనితీరును నిర్ధారించడానికి ఉపయోగిస్తారు.
- **ధృవీకరణ**. ధృవీకరణ సెట్ అనేది చిన్న స్వతంత్ర ఉదాహరణల సమూహం, దీన్ని మీరు మోడల్ యొక్క హైపర్‌పారామీటర్లను లేదా నిర్మాణాన్ని మెరుగుపరచడానికి ఉపయోగిస్తారు. మీ డేటా పరిమాణం మరియు మీరు అడుగుతున్న ప్రశ్న ఆధారంగా, మీరు ఈ మూడవ సెట్‌ను నిర్మించాల్సిన అవసరం ఉండకపోవచ్చు ([టైమ్ సిరీస్ ఫోర్కాస్టింగ్](../../7-TimeSeries/1-Introduction/README.md) లో మేము గమనిస్తాము).
## మోడల్ నిర్మాణం
మీ శిక్షణ డేటాను ఉపయోగించి, మీరు వివిధ అల్గోరిథమ్స్ ఉపయోగించి మీ డేటా యొక్క గణాంకాత్మక ప్రాతినిధ్యంగా ఒక మోడల్‌ను **శిక్షణ** ఇవ్వడం లక్ష్యం. మోడల్ శిక్షణ డేటాను చూసి, దాని లోపల ఉన్న నమూనాలను గుర్తించి, అంచనాలు వేస్తుంది, వాటిని ధృవీకరిస్తుంది మరియు అంగీకరిస్తుంది లేదా తిరస్కరిస్తుంది.
### శిక్షణ పద్ధతిని నిర్ణయించండి
మీ ప్రశ్న మరియు డేటా స్వభావం ఆధారంగా, మీరు శిక్షణ ఇవ్వడానికి ఒక పద్ధతిని ఎంచుకుంటారు. ఈ కోర్సులో మేము ఉపయోగించే [Scikit-learn డాక్యుమెంటేషన్](https://scikit-learn.org/stable/user_guide.html) ద్వారా మీరు మోడల్ శిక్షణకు అనేక మార్గాలను అన్వేషించవచ్చు. మీ అనుభవం ఆధారంగా, మీరు ఉత్తమ మోడల్ నిర్మించడానికి అనేక పద్ధతులను ప్రయత్నించవలసి ఉండవచ్చు. డేటా సైంటిస్ట్‌లు మోడల్ పనితీరును అంచనా వేయడానికి, దాన్ని చూడని డేటాతో పరీక్షించి, ఖచ్చితత్వం, పక్షపాతం మరియు ఇతర నాణ్యతను తగ్గించే సమస్యలను పరిశీలించి, ఆ పని కోసం సరైన శిక్షణ పద్ధతిని ఎంచుకుంటారు.
### మోడల్‌ను శిక్షణ ఇవ్వండి
మీ శిక్షణ డేటాతో, మీరు దాన్ని 'ఫిట్' చేయడానికి సిద్ధంగా ఉంటారు. మీరు అనేక ML లైబ్రరీలలో 'model.fit' కోడ్‌ను కనుగొంటారు - ఈ సమయంలో మీరు మీ లక్షణ వేరియబుల్‌ను విలువల శ్రేణిగా (సాధారణంగా 'X') మరియు లక్ష్య వేరియబుల్‌ను (సాధారణంగా 'y') పంపిస్తారు.
### మోడల్‌ను మూల్యాంకనం చేయండి
శిక్షణ ప్రక్రియ పూర్తయిన తర్వాత (పెద్ద మోడల్ శిక్షణకు అనేక పునరావృతాలు లేదా 'ఎపోక్స్' అవసరం కావచ్చు), మీరు పరీక్షా డేటాను ఉపయోగించి మోడల్ నాణ్యతను అంచనా వేయగలుగుతారు. ఈ డేటా మోడల్ ముందుగా విశ్లేషించని అసలు డేటా ఉపసమితి. మీరు మీ మోడల్ నాణ్యత గురించి మెట్రిక్స్ పట్టికను ప్రింట్ చేయవచ్చు.
🎓 **మోడల్ ఫిట్టింగ్**
మెషీన్ లెర్నింగ్ సందర్భంలో, మోడల్ ఫిట్టింగ్ అనేది మోడల్ యొక్క అంతర్గత ఫంక్షన్ ఖచ్చితత్వాన్ని సూచిస్తుంది, ఇది పరిచయమయ్యే డేటాను విశ్లేషించడానికి ప్రయత్నిస్తుంది.
🎓 **అండర్‌ఫిట్టింగ్** మరియు **ఓవర్‌ఫిట్టింగ్** సాధారణ సమస్యలు, ఇవి మోడల్ నాణ్యతను తగ్గిస్తాయి, ఎందుకంటే మోడల్ సరైన రీతిలో సరిపోలడం లేదా ఎక్కువగా సరిపోలడం లేదు. ఓవర్‌ఫిట్ మోడల్ శిక్షణ డేటాను చాలా బాగా పూర్వానుమానిస్తుంది, ఎందుకంటే అది డేటా వివరాలు మరియు శబ్దాన్ని బాగా నేర్చుకుంది. అండర్‌ఫిట్ మోడల్ ఖచ్చితంగా లేదు, ఎందుకంటే అది తన శిక్షణ డేటాను లేదా ఇప్పటి వరకు 'చూసిన' డేటాను సరిగ్గా విశ్లేషించలేకపోతుంది.
![overfitting model](../../../../translated_images/overfitting.1c132d92bfd93cb63240baf63ebdf82c30e30a0a44e1ad49861b82ff600c2b5c.te.png)
> ఇన్ఫోగ్రాఫిక్ [జెన్ లూపర్](https://twitter.com/jenlooper) ద్వారా
## పారామీటర్ ట్యూనింగ్
మీ ప్రారంభ శిక్షణ పూర్తయిన తర్వాత, మోడల్ నాణ్యతను గమనించి, దాని 'హైపర్‌పారామీటర్లను' సర్దుబాటు చేయడం ద్వారా మెరుగుపరచాలని పరిగణించండి. ఈ ప్రక్రియ గురించి మరింత చదవండి [డాక్యుమెంటేషన్‌లో](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott).
## పూర్వానుమానం
ఇది మీరు పూర్తిగా కొత్త డేటాను ఉపయోగించి మీ మోడల్ ఖచ్చితత్వాన్ని పరీక్షించే క్షణం. 'అప్లైడ్' ML సెట్టింగ్‌లో, మీరు ప్రొడక్షన్‌లో మోడల్ ఉపయోగించడానికి వెబ్ ఆస్తులను నిర్మిస్తున్నప్పుడు, ఈ ప్రక్రియలో యూజర్ ఇన్‌పుట్ (ఉదాహరణకు బటన్ నొక్కడం) సేకరించి, వేరియబుల్ సెట్ చేసి, మోడల్‌కు ఇన్ఫరెన్స్ లేదా మూల్యాంకన కోసం పంపడం ఉండవచ్చు.
ఈ పాఠాలలో, మీరు ఈ దశలను ఉపయోగించి ఎలా సిద్ధం చేయాలో, నిర్మించాలో, పరీక్షించాలో, మూల్యాంకనం చేయాలో, మరియు పూర్వానుమానం చేయాలో తెలుసుకుంటారు - డేటా సైంటిస్ట్ యొక్క అన్ని చర్యలు మరియు మరిన్ని, మీరు 'ఫుల్ స్టాక్' ML ఇంజనీర్‌గా మారే ప్రయాణంలో.
---
## 🚀సవాలు
ML ప్రాక్టిషనర్ దశలను ప్రతిబింబించే ఒక ఫ్లో చార్ట్ డ్రా చేయండి. మీరు ప్రస్తుతంలో ఈ ప్రక్రియలో ఎక్కడ ఉన్నారు? మీరు ఎక్కడ కష్టాన్ని ఎదుర్కొంటారని భావిస్తున్నారు? మీకు ఏది సులభంగా అనిపిస్తుంది?
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
డేటా సైంటిస్ట్‌లు వారి రోజువారీ పనిని చర్చించే ఇంటర్వ్యూలను ఆన్‌లైన్‌లో వెతకండి. ఇక్కడ [ఒకటి](https://www.youtube.com/watch?v=Z3IjgbbCEfs) ఉంది.
## అసైన్‌మెంట్
[డేటా సైంటిస్ట్‌ను ఇంటర్వ్యూ చేయండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకం వల్ల కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల బాధ్యత మేము తీసుకోము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/1-Introduction/4-techniques-of-ML/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "70d65aeddc06170bc1aed5b27805f930",
"translation_date": "2025-12-19T13:38:55+00:00",
"source_file": "1-Introduction/4-techniques-of-ML/assignment.md",
"language_code": "te"
}
-->
# డేటా సైంటిస్ట్‌ను ఇంటర్వ్యూ చేయండి
## సూచనలు
మీ కంపెనీలో, యూజర్ గ్రూప్‌లో, లేదా మీ స్నేహితులు లేదా సహ విద్యార్థుల మధ్య, ప్రొఫెషనల్‌గా డేటా సైంటిస్ట్‌గా పనిచేసే ఎవరో ఒకరితో మాట్లాడండి. వారి రోజువారీ పనుల గురించి ఒక చిన్న పేపర్ (500 పదాలు) రాయండి. వారు నిపుణులా ఉంటారా, లేక 'ఫుల్ స్టాక్'గా పనిచేస్తారా?
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------ | --------------------- |
| | సరైన పొడవు ఉన్న వ్యాసం, మూలాలతో కూడినది, .doc ఫైల్‌గా సమర్పించబడింది | వ్యాసం సరైన మూలాలతో లేకపోవడం లేదా అవసరమైన పొడవు కంటే తక్కువగా ఉండటం | వ్యాసం సమర్పించబడలేదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

38
translations/te/1-Introduction/README.md
Unescape View File

@ -0,0 +1,38 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "cf8ecc83f28e5b98051d2179eca08e08",
"translation_date": "2025-12-19T12:56:16+00:00",
"source_file": "1-Introduction/README.md",
"language_code": "te"
}
-->
# మెషీన్ లెర్నింగ్ పరిచయం
ఈ పాఠ్యాంశంలో, మీరు మెషీన్ లెర్నింగ్ రంగానికి ఆధారమైన మూల భావనలను, అది ఏమిటి, మరియు పరిశోధకులు దీని తో పని చేయడానికి ఉపయోగించే చరిత్ర మరియు సాంకేతికతలను తెలుసుకుంటారు. ఈ కొత్త ML ప్రపంచాన్ని కలిసి అన్వేషిద్దాం!
![globe](../../../translated_images/globe.59f26379ceb40428672b4d9a568044618a2bf6292ecd53a5c481b90e3fa805eb.te.jpg)
> ఫోటో <a href="https://unsplash.com/@bill_oxford?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">బిల్ ఆక్స్ఫర్డ్</a> ద్వారా <a href="https://unsplash.com/s/photos/globe?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">అన్స్ప్లాష్</a>
### పాఠాలు
1. [మెషీన్ లెర్నింగ్ పరిచయం](1-intro-to-ML/README.md)
1. [మెషీన్ లెర్నింగ్ మరియు AI చరిత్ర](2-history-of-ML/README.md)
1. [న్యాయం మరియు మెషీన్ లెర్నింగ్](3-fairness/README.md)
1. [మెషీన్ లెర్నింగ్ సాంకేతికతలు](4-techniques-of-ML/README.md)
### క్రెడిట్స్
"మెషీన్ లెర్నింగ్ పరిచయం" ను ♥️ తో [ముహమ్మద్ సకీబ్ ఖాన్ ఇనాన్](https://twitter.com/Sakibinan), [ఒర్నెల్లా ఆల్టున్యాన్](https://twitter.com/ornelladotcom) మరియు [జెన్ లూపర్](https://twitter.com/jenlooper) సహా ఒక బృందం రాశారు
"మెషీన్ లెర్నింగ్ చరిత్ర" ను ♥️ తో [జెన్ లూపర్](https://twitter.com/jenlooper) మరియు [ఏమీ బాయిడ్](https://twitter.com/AmyKateNicho) రాశారు
"న్యాయం మరియు మెషీన్ లెర్నింగ్" ను ♥️ తో [టోమోమీ ఇమురా](https://twitter.com/girliemac) రాశారు
"మెషీన్ లెర్నింగ్ సాంకేతికతలు" ను ♥️ తో [జెన్ లూపర్](https://twitter.com/jenlooper) మరియు [క్రిస్ నోరింగ్](https://twitter.com/softchris) రాశారు
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

241
translations/te/2-Regression/1-Tools/README.md
Unescape View File

@ -0,0 +1,241 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "fa81d226c71d5af7a2cade31c1c92b88",
"translation_date": "2025-12-19T13:54:05+00:00",
"source_file": "2-Regression/1-Tools/README.md",
"language_code": "te"
}
-->
# రిగ్రెషన్ మోడల్స్ కోసం Python మరియు Scikit-learn తో ప్రారంభించండి
![Summary of regressions in a sketchnote](../../../../translated_images/ml-regression.4e4f70e3b3ed446e3ace348dec973e133fa5d3680fbc8412b61879507369b98d.te.png)
> Sketchnote by [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
> ### [ఈ పాఠం R లో అందుబాటులో ఉంది!](../../../../2-Regression/1-Tools/solution/R/lesson_1.html)
## పరిచయం
ఈ నాలుగు పాఠాలలో, మీరు రిగ్రెషన్ మోడల్స్ ఎలా నిర్మించాలో తెలుసుకుంటారు. వీటి ఉపయోగం గురించి త్వరలో చర్చిస్తాము. కానీ మీరు ఏదైనా చేయకముందు, ప్రారంభించడానికి సరైన సాధనాలు మీ వద్ద ఉన్నాయో లేదో నిర్ధారించుకోండి!
ఈ పాఠంలో, మీరు నేర్చుకుంటారు:
- స్థానిక మెషీన్ లెర్నింగ్ పనుల కోసం మీ కంప్యూటర్‌ను ఎలా కాన్ఫిగర్ చేయాలో.
- Jupyter నోట్బుక్స్‌తో ఎలా పని చేయాలో.
- Scikit-learn ఉపయోగించడం, ఇన్‌స్టాలేషన్ సహా.
- లీనియర్ రిగ్రెషన్‌ను ఒక ప్రాక్టికల్ వ్యాయామంతో అన్వేషించడం.
## ఇన్‌స్టాలేషన్లు మరియు కాన్ఫిగరేషన్లు
[![ML for beginners - Setup your tools ready to build Machine Learning models](https://img.youtube.com/vi/-DfeD2k2Kj0/0.jpg)](https://youtu.be/-DfeD2k2Kj0 "ML for beginners -Setup your tools ready to build Machine Learning models")
> 🎥 ML కోసం మీ కంప్యూటర్‌ను కాన్ఫిగర్ చేయడం గురించి చిన్న వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి.
1. **Python ఇన్‌స్టాల్ చేయండి**. మీ కంప్యూటర్‌లో [Python](https://www.python.org/downloads/) ఇన్‌స్టాల్ అయి ఉందని నిర్ధారించుకోండి. మీరు అనేక డేటా సైన్స్ మరియు మెషీన్ లెర్నింగ్ పనుల కోసం Python ఉపయోగిస్తారు. చాలా కంప్యూటర్ సిస్టమ్స్ ఇప్పటికే Python ఇన్‌స్టాలేషన్ కలిగి ఉంటాయి. కొంతమంది వినియోగదారుల కోసం సులభతరం చేయడానికి ఉపయోగకరమైన [Python కోడింగ్ ప్యాక్స్](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott) కూడా అందుబాటులో ఉన్నాయి.
Python యొక్క కొన్ని ఉపయోగాలు ఒక వెర్షన్ అవసరం అవుతాయి, మరికొన్ని వేరే వెర్షన్ అవసరం అవుతాయి. అందుకే, [వర్చువల్ ఎన్విరాన్‌మెంట్](https://docs.python.org/3/library/venv.html) లో పని చేయడం ఉపయోగకరం.
2. **Visual Studio Code ఇన్‌స్టాల్ చేయండి**. మీ కంప్యూటర్‌లో Visual Studio Code ఇన్‌స్టాల్ అయి ఉందని నిర్ధారించుకోండి. ప్రాథమిక ఇన్‌స్టాలేషన్ కోసం [Visual Studio Code ఇన్‌స్టాల్ చేయడం](https://code.visualstudio.com/) గురించి సూచనలను అనుసరించండి. ఈ కోర్సులో మీరు Visual Studio Code లో Python ఉపయోగించబోతున్నారు, కాబట్టి Python అభివృద్ధి కోసం [Visual Studio Code ను ఎలా కాన్ఫిగర్ చేయాలో](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott) తెలుసుకోవడం మంచిది.
> ఈ [Learn modules](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott) సేకరణ ద్వారా Python తో సౌకర్యంగా అవ్వండి
>
> [![Setup Python with Visual Studio Code](https://img.youtube.com/vi/yyQM70vi7V8/0.jpg)](https://youtu.be/yyQM70vi7V8 "Setup Python with Visual Studio Code")
>
> 🎥 పై చిత్రాన్ని క్లిక్ చేసి VS Code లో Python ఉపయోగించడం గురించి వీడియో చూడండి.
3. **Scikit-learn ఇన్‌స్టాల్ చేయండి**, [ఈ సూచనలను](https://scikit-learn.org/stable/install.html) అనుసరించండి. మీరు Python 3 ఉపయోగిస్తున్నారని నిర్ధారించుకోవాలి, అందుకే వర్చువల్ ఎన్విరాన్‌మెంట్ ఉపయోగించడం సిఫార్సు చేయబడింది. మీరు M1 Mac పై ఈ లైబ్రరీని ఇన్‌స్టాల్ చేస్తుంటే, పై లింకులో ప్రత్యేక సూచనలు ఉన్నాయి.
1. **Jupyter Notebook ఇన్‌స్టాల్ చేయండి**. మీరు [Jupyter ప్యాకేజీని ఇన్‌స్టాల్ చేయాలి](https://pypi.org/project/jupyter/).
## మీ ML రచనా వాతావరణం
మీరు Python కోడ్ అభివృద్ధి చేయడానికి మరియు మెషీన్ లెర్నింగ్ మోడల్స్ సృష్టించడానికి **నోట్బుక్స్** ఉపయోగించబోతున్నారు. ఈ రకమైన ఫైల్ డేటా సైంటిస్టులకు సాధారణ సాధనం, మరియు అవి వారి సఫిక్స్ లేదా ఎక్స్‌టెన్షన్ `.ipynb` ద్వారా గుర్తించబడతాయి.
నోట్బుక్స్ అనేవి ఒక ఇంటరాక్టివ్ వాతావరణం, ఇది డెవలపర్‌కు కోడ్ రాయడమే కాకుండా, కోడ్ చుట్టూ గమనికలు మరియు డాక్యుమెంటేషన్ కూడా జోడించడానికి అనుమతిస్తుంది, ఇది ప్రయోగాత్మక లేదా పరిశోధన-ఆధారిత ప్రాజెక్టులకు చాలా సహాయకరం.
[![ML for beginners - Set up Jupyter Notebooks to start building regression models](https://img.youtube.com/vi/7E-jC8FLA2E/0.jpg)](https://youtu.be/7E-jC8FLA2E "ML for beginners - Set up Jupyter Notebooks to start building regression models")
> 🎥 ఈ వ్యాయామం ద్వారా పని చేయడానికి పై చిత్రాన్ని క్లిక్ చేయండి.
### వ్యాయామం - నోట్బుక్‌తో పని చేయండి
ఈ ఫోల్డర్‌లో, మీరు _notebook.ipynb_ ఫైల్‌ను కనుగొంటారు.
1. Visual Studio Code లో _notebook.ipynb_ ను తెరవండి.
Python 3+ తో Jupyter సర్వర్ ప్రారంభమవుతుంది. మీరు నోట్బుక్‌లో `run` చేయగల కోడ్ భాగాలను కనుగొంటారు. ప్లే బటన్ లాంటి ఐకాన్‌ను ఎంచుకుని కోడ్ బ్లాక్‌ను నడపవచ్చు.
1. `md` ఐకాన్‌ను ఎంచుకుని కొంత మార్క్డౌన్ జోడించండి, మరియు ఈ క్రింది టెక్స్ట్ **# Welcome to your notebook** ను జోడించండి.
తరువాత, కొంత Python కోడ్ జోడించండి.
1. కోడ్ బ్లాక్‌లో **print('hello notebook')** టైప్ చేయండి.
1. కోడ్ నడపడానికి ఎరోను ఎంచుకోండి.
మీరు ఈ ముద్రిత స్టేట్‌మెంట్‌ను చూడగలరు:
```output
hello notebook
```
![VS Code with a notebook open](../../../../translated_images/notebook.4a3ee31f396b88325607afda33cadcc6368de98040ff33942424260aa84d75f2.te.jpg)
మీరు మీ కోడ్‌ను వ్యాఖ్యలతో కలిపి నోట్బుక్‌ను స్వయంగా డాక్యుమెంట్ చేయవచ్చు.
✅ ఒక వెబ్ డెవలపర్ వాతావరణం మరియు డేటా సైంటిస్ట్ వాతావరణం ఎంత భిన్నమో ఒక నిమిషం ఆలోచించండి.
## Scikit-learn తో ప్రారంభం
ఇప్పుడు Python మీ స్థానిక వాతావరణంలో సెట్ అయింది, మరియు మీరు Jupyter నోట్బుక్స్‌తో సౌకర్యంగా ఉన్నారు, Scikit-learn (దీనిని `sci` అని ఉచ్చరించండి, `science` లాగా) తో కూడా సౌకర్యంగా అవ్వండి. Scikit-learn మీకు ML పనులు చేయడానికి సహాయపడే [విస్తృత API](https://scikit-learn.org/stable/modules/classes.html#api-ref) అందిస్తుంది.
వారి [వెబ్‌సైట్](https://scikit-learn.org/stable/getting_started.html) ప్రకారం, "Scikit-learn అనేది ఓపెన్ సోర్స్ మెషీన్ లెర్నింగ్ లైబ్రరీ, ఇది సూపర్వైజ్డ్ మరియు అన్‌సూపర్వైజ్డ్ లెర్నింగ్‌ను మద్దతు ఇస్తుంది. ఇది మోడల్ ఫిట్టింగ్, డేటా ప్రీప్రాసెసింగ్, మోడల్ సెలెక్షన్ మరియు మూల్యాంకనం, మరియు అనేక ఇతర ఉపకరణాలను కూడా అందిస్తుంది."
ఈ కోర్సులో, మీరు Scikit-learn మరియు ఇతర సాధనాలను ఉపయోగించి మెషీన్ లెర్నింగ్ మోడల్స్ నిర్మించి 'సాంప్రదాయ మెషీన్ లెర్నింగ్' పనులు చేస్తారు. న్యూరల్ నెట్‌వర్క్స్ మరియు డీప్ లెర్నింగ్‌ను మేము ఉద్దేశపూర్వకంగా తప్పించుకున్నాము, అవి మా రాబోయే 'AI for Beginners' పాఠ్యాంశంలో బాగా కవర్ చేయబడతాయి.
Scikit-learn మోడల్స్ నిర్మించడం మరియు వాటిని ఉపయోగానికి మూల్యాంకనం చేయడం సులభం చేస్తుంది. ఇది ప్రధానంగా సంఖ్యాత్మక డేటాను ఉపయోగించడంపై దృష్టి సారిస్తుంది మరియు విద్యార్థుల కోసం ఉపయోగించడానికి సిద్ధంగా ఉన్న అనేక డేటాసెట్‌లను కలిగి ఉంటుంది. ఇది విద్యార్థులు ప్రయత్నించడానికి ముందుగా నిర్మించిన మోడల్స్‌ను కూడా కలిగి ఉంది. ముందుగా ప్యాకేజ్డ్ డేటాను లోడ్ చేయడం మరియు Scikit-learn తో ప్రాథమిక డేటాతో ఒక బిల్ట్-ఇన్ ఎస్టిమేటర్ ఉపయోగించి మొదటి ML మోడల్‌ను అన్వేషిద్దాం.
## వ్యాయామం - మీ మొదటి Scikit-learn నోట్బుక్
> ఈ ట్యుటోరియల్ Scikit-learn వెబ్‌సైట్‌లోని [లీనియర్ రిగ్రెషన్ ఉదాహరణ](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) నుండి ప్రేరణ పొందింది.
[![ML for beginners - Your First Linear Regression Project in Python](https://img.youtube.com/vi/2xkXL5EUpS0/0.jpg)](https://youtu.be/2xkXL5EUpS0 "ML for beginners - Your First Linear Regression Project in Python")
> 🎥 ఈ వ్యాయామం ద్వారా పని చేయడానికి పై చిత్రాన్ని క్లిక్ చేయండి.
ఈ పాఠానికి సంబంధించిన _notebook.ipynb_ ఫైల్‌లో, 'trash can' ఐకాన్‌ను నొక్కి అన్ని సెల్స్‌ను క్లియర్ చేయండి.
ఈ విభాగంలో, మీరు Scikit-learn లో నేర్చుకునే ప్రయోజనాల కోసం నిర్మించిన డయాబెటిస్ గురించి చిన్న డేటాసెట్‌తో పని చేస్తారు. మీరు డయాబెటిక్ రోగుల కోసం చికిత్సను పరీక్షించాలనుకుంటున్నారని ఊహించండి. మెషీన్ లెర్నింగ్ మోడల్స్ వేరియబుల్స్ కలయికల ఆధారంగా ఏ రోగులు చికిత్సకు మెరుగ్గా స్పందిస్తారో నిర్ణయించడంలో సహాయపడవచ్చు. ఒక చాలా ప్రాథమిక రిగ్రెషన్ మోడల్ కూడా, దృశ్యీకరించినప్పుడు, వేరియబుల్స్ గురించి సమాచారం చూపించి మీ సైద్ధాంతిక క్లినికల్ ట్రయల్స్‌ను సక్రమంగా నిర్వహించడంలో సహాయపడవచ్చు.
✅ రిగ్రెషన్ పద్ధతుల అనేక రకాలు ఉన్నాయి, మీరు ఎంచుకునేది మీరు కోరుకునే సమాధానంపై ఆధారపడి ఉంటుంది. మీరు ఒక వ్యక్తి వయస్సుకు అనుగుణంగా ఎత్తును అంచనా వేయాలనుకుంటే, మీరు లీనియర్ రిగ్రెషన్ ఉపయోగిస్తారు, ఎందుకంటే మీరు **సంఖ్యాత్మక విలువ** కోసం చూస్తున్నారు. మీరు ఒక వంటకాన్ని వెగన్‌గా పరిగణించాలా లేదా అనేది తెలుసుకోవాలనుకుంటే, మీరు **వర్గీకరణ** కోసం చూస్తున్నారు కాబట్టి లాజిస్టిక్ రిగ్రెషన్ ఉపయోగిస్తారు. మీరు తర్వాత లాజిస్టిక్ రిగ్రెషన్ గురించి మరింత తెలుసుకుంటారు. డేటా నుండి అడగగల కొన్ని ప్రశ్నల గురించి మరియు ఏ పద్ధతులు ఎక్కువగా సరిపోతాయో కొంచెం ఆలోచించండి.
ఈ పనిని ప్రారంభిద్దాం.
### లైబ్రరీలను దిగుమతి చేసుకోండి
ఈ పనికి కొన్ని లైబ్రరీలను దిగుమతి చేసుకుంటాము:
- **matplotlib**. ఇది ఉపయోగకరమైన [గ్రాఫింగ్ టూల్](https://matplotlib.org/) మరియు లైన్ ప్లాట్ సృష్టించడానికి ఉపయోగిస్తాము.
- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) అనేది Python లో సంఖ్యాత్మక డేటాను నిర్వహించడానికి ఉపయోగకరమైన లైబ్రరీ.
- **sklearn**. ఇది [Scikit-learn](https://scikit-learn.org/stable/user_guide.html) లైబ్రరీ.
మీ పనులకు సహాయపడే కొన్ని లైబ్రరీలను దిగుమతి చేసుకోండి.
1. క్రింది కోడ్ టైప్ చేసి దిగుమతులు జోడించండి:
```python
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, model_selection
```
పై కోడ్‌లో మీరు `matplotlib`, `numpy` ను దిగుమతి చేసుకుంటున్నారు మరియు `sklearn` నుండి `datasets`, `linear_model` మరియు `model_selection` ను దిగుమతి చేసుకుంటున్నారు. `model_selection` డేటాను ట్రైనింగ్ మరియు టెస్ట్ సెట్లుగా విభజించడానికి ఉపయోగిస్తారు.
### డయాబెటిస్ డేటాసెట్
బిల్ట్-ఇన్ [డయాబెటిస్ డేటాసెట్](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) 442 నమూనాల డేటాను కలిగి ఉంది, 10 ఫీచర్ వేరియబుల్స్‌తో, వాటిలో కొన్ని:
- వయస్సు: సంవత్సరాలలో వయస్సు
- bmi: బాడీ మాస్ ఇండెక్స్
- bp: సగటు రక్తపోటు
- s1 tc: T-సెల్స్ (తెల్ల రక్త కణాల ఒక రకం)
✅ ఈ డేటాసెట్ 'sex' అనే ఫీచర్ వేరియబుల్‌ను కలిగి ఉంది, ఇది డయాబెటిస్ పరిశోధనలో ముఖ్యమైనది. అనేక వైద్య డేటాసెట్‌లు ఈ రకమైన ద్విభాగ వర్గీకరణను కలిగి ఉంటాయి. ఈ వర్గీకరణలు జనాభాలోని కొన్ని భాగాలను చికిత్సల నుండి ఎలా తప్పించవచ్చు అనేది కొంచెం ఆలోచించండి.
ఇప్పుడు, X మరియు y డేటాను లోడ్ చేయండి.
> 🎓 గుర్తుంచుకోండి, ఇది సూపర్వైజ్డ్ లెర్నింగ్, కాబట్టి 'y' అనే లక్ష్యాన్ని అవసరం.
కొత్త కోడ్ సెల్‌లో, `load_diabetes()` ను పిలిచి డయాబెటిస్ డేటాసెట్‌ను లోడ్ చేయండి. ఇన్‌పుట్ `return_X_y=True` అంటే `X` డేటా మ్యాట్రిక్స్ అవుతుంది, మరియు `y` రిగ్రెషన్ లక్ష్యం అవుతుంది.
1. డేటా మ్యాట్రిక్స్ ఆకారం మరియు మొదటి అంశాన్ని చూపించడానికి కొన్ని ప్రింట్ కమాండ్లను జోడించండి:
```python
X, y = datasets.load_diabetes(return_X_y=True)
print(X.shape)
print(X[0])
```
మీరు పొందుతున్నది ఒక టుపుల్. మీరు టుపుల్ యొక్క మొదటి రెండు విలువలను వరుసగా `X` మరియు `y` కు కేటాయిస్తున్నారు. [టుపుల్స్ గురించి మరింత తెలుసుకోండి](https://wikipedia.org/wiki/Tuple).
ఈ డేటాలో 442 అంశాలు ఉన్నాయి, అవి 10 అంశాల అర్రేలుగా ఆకారంలో ఉన్నాయి:
```text
(442, 10)
[ 0.03807591 0.05068012 0.06169621 0.02187235 -0.0442235 -0.03482076
-0.04340085 -0.00259226 0.01990842 -0.01764613]
```
✅ డేటా మరియు రిగ్రెషన్ లక్ష్యం మధ్య సంబంధం గురించి కొంచెం ఆలోచించండి. లీనియర్ రిగ్రెషన్ ఫీచర్ X మరియు లక్ష్య వేరియబుల్ y మధ్య సంబంధాలను అంచనా వేస్తుంది. డయాబెటిస్ డేటాసెట్ కోసం [లక్ష్యం](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) ఏమిటి అని డాక్యుమెంటేషన్‌లో చూడండి? ఈ డేటాసెట్ ఏం చూపిస్తోంది?
2. తరువాత, ఈ డేటాసెట్‌లోని 3వ కాలమ్‌ను ఎంచుకుని ప్లాట్ చేయడానికి ఒక భాగాన్ని ఎంచుకోండి. మీరు అన్ని వరుసలను ఎంచుకోవడానికి `:` ఆపరేటర్ ఉపయోగించి, తరువాత 3వ కాలమ్‌ను సూచిక (2) ఉపయోగించి ఎంచుకోవచ్చు. ప్లాటింగ్ కోసం అవసరమైన 2D అర్రేగా డేటాను మార్చడానికి `reshape(n_rows, n_columns)` ఉపయోగించవచ్చు. ఒక పారామీటర్ -1 అయితే, ఆ కొలత ఆటోమేటిక్‌గా లెక్కించబడుతుంది.
```python
X = X[:, 2]
X = X.reshape((-1,1))
```
✅ ఎప్పుడైనా డేటా ఆకారాన్ని తనిఖీ చేయడానికి ప్రింట్ చేయండి.
3. ఇప్పుడు మీరు ప్లాట్ చేయడానికి డేటా సిద్ధంగా ఉన్నందున, ఈ డేటాసెట్‌లో సంఖ్యల మధ్య తార్కిక విభజనను యంత్రం నిర్ణయించగలదా అని చూడండి. దీని కోసం, మీరు డేటా (X) మరియు లక్ష్యం (y) రెండింటినీ టెస్ట్ మరియు ట్రైనింగ్ సెట్లుగా విభజించాలి. Scikit-learn దీనిని సులభంగా చేయడానికి ఒక విధానం కలిగి ఉంది; మీరు టెస్ట్ డేటాను ఒక నిర్దిష్ట పాయింట్ వద్ద విభజించవచ్చు.
```python
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
```
4. ఇప్పుడు మీరు మీ మోడల్‌ను ట్రైన్ చేయడానికి సిద్ధంగా ఉన్నారు! లీనియర్ రిగ్రెషన్ మోడల్‌ను లోడ్ చేసి, `model.fit()` ఉపయోగించి మీ X మరియు y ట్రైనింగ్ సెట్లతో ట్రైన్ చేయండి:
```python
model = linear_model.LinearRegression()
model.fit(X_train, y_train)
```
✅ `model.fit()` అనేది TensorFlow వంటి అనేక ML లైబ్రరీలలో కనిపించే ఫంక్షన్.
5. తరువాత, టెస్ట్ డేటా ఉపయోగించి `predict()` ఫంక్షన్ ద్వారా అంచనాను సృష్టించండి. ఇది డేటా గ్రూపుల మధ్య లైన్ డ్రా చేయడానికి ఉపయోగించబడుతుంది.
```python
y_pred = model.predict(X_test)
```
6. ఇప్పుడు డేటాను ప్లాట్‌లో చూపించాల్సిన సమయం. Matplotlib ఈ పనికి చాలా ఉపయోగకరమైన సాధనం. అన్ని X మరియు y టెస్ట్ డేటా యొక్క స్కాటర్‌ప్లాట్ సృష్టించి, అంచనాను ఉపయోగించి మోడల్ డేటా గ్రూపుల మధ్య సరైన చోట లైన్ డ్రా చేయండి.
```python
plt.scatter(X_test, y_test, color='black')
plt.plot(X_test, y_pred, color='blue', linewidth=3)
plt.xlabel('Scaled BMIs')
plt.ylabel('Disease Progression')
plt.title('A Graph Plot Showing Diabetes Progression Against BMI')
plt.show()
```
![a scatterplot showing datapoints around diabetes](../../../../translated_images/scatterplot.ad8b356bcbb33be68d54050e09b9b7bfc03e94fde7371f2609ae43f4c563b2d7.te.png)
✅ ఇక్కడ ఏమి జరుగుతుందో కొంచెం ఆలోచించండి. ఒక సరళ రేఖ అనేక చిన్న డాటా బిందువుల ద్వారా నడుస్తోంది, కానీ అది నిజంగా ఏమి చేస్తోంది? మీరు ఈ రేఖను ఉపయోగించి కొత్త, చూడని డాటా పాయింట్ ప్లాట్ యొక్క y అక్షానికి సంబంధించి ఎక్కడ సరిపోతుందో ఎలా అంచనా వేయాలో చూడగలరా? ఈ మోడల్ యొక్క ప్రాక్టికల్ ఉపయోగాన్ని పదాలలో వ్యక్తం చేయడానికి ప్రయత్నించండి.
అభినందనలు, మీరు మీ మొదటి లీనియర్ రిగ్రెషన్ మోడల్‌ను నిర్మించారు, దానితో ఒక అంచనాను సృష్టించారు, మరియు దాన్ని ఒక ప్లాట్‌లో ప్రదర్శించారు!
---
## 🚀సవాలు
ఈ డేటాసెట్ నుండి వేరే వేరియబుల్‌ను ప్లాట్ చేయండి. సూచన: ఈ లైన్‌ను సవరించండి: `X = X[:,2]`. ఈ డేటాసెట్ లక్ష్యాన్ని దృష్టిలో ఉంచుకుని, మధుమేహం వ్యాధిగా ఎలా అభివృద్ధి చెందుతుందో మీరు ఏమి కనుగొనగలరు?
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
ఈ ట్యుటోరియల్‌లో, మీరు సింపుల్ లీనియర్ రిగ్రెషన్‌తో పని చేశారు, యూనివేరియట్ లేదా మల్టిపుల్ లీనియర్ రిగ్రెషన్ కాకుండా. ఈ పద్ధతుల మధ్య తేడాల గురించి కొంచెం చదవండి, లేదా [ఈ వీడియో](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef) చూడండి.
రిగ్రెషన్ కాన్సెప్ట్ గురించి మరింత చదవండి మరియు ఈ సాంకేతికత ద్వారా ఏ రకమైన ప్రశ్నలకు సమాధానం ఇవ్వగలమో ఆలోచించండి. మీ అవగాహనను లోతుగా చేసుకోవడానికి ఈ [ట్యుటోరియల్](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott) తీసుకోండి.
## అసైన్‌మెంట్
[వేరే డేటాసెట్](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

29
translations/te/2-Regression/1-Tools/assignment.md
Unescape View File

@ -0,0 +1,29 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "74a5cf83e4ebc302afbcbc4f418afd0a",
"translation_date": "2025-12-19T13:57:07+00:00",
"source_file": "2-Regression/1-Tools/assignment.md",
"language_code": "te"
}
-->
# Scikit-learn తో రిగ్రెషన్
## సూచనలు
Scikit-learn లోని [Linnerud dataset](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_linnerud.html#sklearn.datasets.load_linnerud) ను పరిశీలించండి. ఈ డేటాసెట్‌లో బహుళ [లక్ష్యాలు](https://scikit-learn.org/stable/datasets/toy_dataset.html#linnerrud-dataset) ఉన్నాయి: 'ఇది ఒక ఫిట్‌నెస్ క్లబ్‌లో ఇరవై మధ్య వయస్కుల నుండి సేకరించిన మూడు వ్యాయామ (డేటా) మరియు మూడు శారీరక (లక్ష్యం) వేరియబుల్స్ కలిగి ఉంది'.
మీ స్వంత మాటల్లో, వెయిస్ట్‌లైన్ మరియు ఎంత సిటప్‌లు పూర్తయ్యాయో మధ్య సంబంధాన్ని చిత్రించగల రిగ్రెషన్ మోడల్‌ను ఎలా సృష్టించాలో వివరించండి. ఈ డేటాసెట్‌లోని ఇతర డేటాపాయింట్ల కోసం కూడా అదే చేయండి.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతం | సరిపోతుంది | మెరుగుదల అవసరం |
| ------------------------------ | ----------------------------------- | ----------------------------- | -------------------------- |
| వివరణాత్మక పేరాగ్రాఫ్ సమర్పించండి | బాగా రాసిన పేరాగ్రాఫ్ సమర్పించబడింది | కొన్ని వాక్యాలు సమర్పించబడ్డాయి | వివరణ అందించబడలేదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

0
translations/te/2-Regression/1-Tools/notebook.ipynb
Unescape View File

17
translations/te/2-Regression/1-Tools/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:09:06+00:00",
"source_file": "2-Regression/1-Tools/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

454
translations/te/2-Regression/1-Tools/solution/R/lesson_1-R.ipynb
Unescape View File

@ -0,0 +1,454 @@
{
"nbformat": 4,
"nbformat_minor": 2,
"metadata": {
"colab": {
"name": "lesson_1-R.ipynb",
"provenance": [],
"collapsed_sections": [],
"toc_visible": true
},
"kernelspec": {
"name": "ir",
"display_name": "R"
},
"language_info": {
"name": "R"
},
"coopTranslator": {
"original_hash": "c18d3bd0bd8ae3878597e89dcd1fa5c1",
"translation_date": "2025-12-19T16:29:38+00:00",
"source_file": "2-Regression/1-Tools/solution/R/lesson_1-R.ipynb",
"language_code": "te"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"# రిగ్రెషన్ మోడల్ నిర్మించండి: రిగ్రెషన్ మోడల్స్ కోసం R మరియు Tidymodels తో ప్రారంభించండి\n"
],
"metadata": {
"id": "YJUHCXqK57yz"
}
},
{
"cell_type": "markdown",
"source": [
"## రిగ్రెషన్ పరిచయం - పాఠం 1\n",
"\n",
"#### దాన్ని దృష్టిలో పెట్టుకోవడం\n",
"\n",
"✅ రిగ్రెషన్ పద్ధతుల అనేక రకాలు ఉన్నాయి, మీరు ఎంచుకునే పద్ధతి మీరు కోరుకునే సమాధానంపై ఆధారపడి ఉంటుంది. మీరు ఒక నిర్దిష్ట వయస్సు ఉన్న వ్యక్తి యొక్క సాధ్యమైన ఎత్తును అంచనా వేయాలనుకుంటే, మీరు `లీనియర్ రిగ్రెషన్` ఉపయోగిస్తారు, ఎందుకంటే మీరు **సంఖ్యాత్మక విలువ** కోసం చూస్తున్నారు. మీరు ఒక వంటకాన్ని వెగన్‌గా పరిగణించాలా లేదా అనేది తెలుసుకోవాలనుకుంటే, మీరు **వర్గీకరణ కేటగిరీ** కోసం చూస్తున్నారు కాబట్టి మీరు `లాజిస్టిక్ రిగ్రెషన్` ఉపయోగిస్తారు. లాజిస్టిక్ రిగ్రెషన్ గురించి మీరు తర్వాత మరింత తెలుసుకుంటారు. డేటా నుండి మీరు అడగగల కొన్ని ప్రశ్నల గురించి కొంచెం ఆలోచించండి, మరియు ఈ పద్ధతులలో ఏది ఎక్కువగా అనుకూలమో.\n",
"\n",
"ఈ విభాగంలో, మీరు [డయాబెటిస్ గురించి చిన్న డేటాసెట్](https://www4.stat.ncsu.edu/~boos/var.select/diabetes.html) తో పని చేస్తారు. మీరు డయాబెటిక్ రోగులకు చికిత్స పరీక్షించాలనుకుంటున్నారని ఊహించుకోండి. మెషీన్ లెర్నింగ్ మోడల్స్ వేరియబుల్స్ యొక్క కలయికల ఆధారంగా ఏ రోగులు చికిత్సకు మెరుగ్గా స్పందిస్తారో నిర్ణయించడంలో మీకు సహాయపడవచ్చు. ఒక చాలా ప్రాథమిక రిగ్రెషన్ మోడల్ కూడా, దృశ్యీకరించినప్పుడు, మీ స 이యతాత్మక క్లినికల్ ట్రయల్స్‌ను నిర్వహించడంలో సహాయపడే వేరియబుల్స్ గురించి సమాచారం చూపవచ్చు.\n",
"\n",
"అందువల్ల, ఈ పనిని ప్రారంభిద్దాం!\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/encouRage.e75d5fe0367fb9136b78104baf4e2032a7622bc42a2bc34c0ad36c294eeb83f5.te.jpg\"\n",
" width=\"630\"/>\n",
" <figcaption>@allison_horst చేత కళాకృతి</figcaption>\n",
"\n",
"<!--![Artwork by \\@allison_horst](../../../../../../translated_images/encouRage.e75d5fe0367fb9136b78104baf4e2032a7622bc42a2bc34c0ad36c294eeb83f5.te.jpg)<br>Artwork by @allison_horst-->\n"
],
"metadata": {
"id": "LWNNzfqd6feZ"
}
},
{
"cell_type": "markdown",
"source": [
"## 1. మన టూల్ సెట్‌ను లోడ్ చేయడం\n",
"\n",
"ఈ పనికి, మనకు క్రింది ప్యాకేజీలు అవసరం:\n",
"\n",
"- `tidyverse`: [tidyverse](https://www.tidyverse.org/) అనేది డేటా సైన్స్‌ను వేగవంతం చేయడానికి, సులభతరం చేయడానికి మరియు మరింత సరదాగా మార్చడానికి రూపొందించిన [R ప్యాకేజీల సేకరణ](https://www.tidyverse.org/packages).\n",
"\n",
"- `tidymodels`: [tidymodels](https://www.tidymodels.org/) ఫ్రేమ్‌వర్క్ అనేది మోడలింగ్ మరియు మెషీన్ లెర్నింగ్ కోసం [ప్యాకేజీల సేకరణ](https://www.tidymodels.org/packages/).\n",
"\n",
"మీరు వాటిని ఇన్‌స్టాల్ చేసుకోవచ్చు:\n",
"\n",
"`install.packages(c(\"tidyverse\", \"tidymodels\"))`\n",
"\n",
"క్రింది స్క్రిప్ట్ ఈ మాడ్యూల్‌ను పూర్తి చేయడానికి అవసరమైన ప్యాకేజీలు మీ వద్ద ఉన్నాయా లేదా అని తనిఖీ చేస్తుంది మరియు కొన్నివి లేవంటే వాటిని మీ కోసం ఇన్‌స్టాల్ చేస్తుంది.\n"
],
"metadata": {
"id": "FIo2YhO26wI9"
}
},
{
"cell_type": "code",
"execution_count": 2,
"source": [
"suppressWarnings(if(!require(\"pacman\")) install.packages(\"pacman\"))\n",
"pacman::p_load(tidyverse, tidymodels)"
],
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"Loading required package: pacman\n",
"\n"
]
}
],
"metadata": {
"id": "cIA9fz9v7Dss",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "2df7073b-86b2-4b32-cb86-0da605a0dc11"
}
},
{
"cell_type": "markdown",
"source": [
"ఇప్పుడు, ఈ అద్భుతమైన ప్యాకేజీలను లోడ్ చేసి మన ప్రస్తుత R సెషన్‌లో అందుబాటులో ఉంచుకుందాం. (ఇది కేవలం ఉదాహరణ కోసం, `pacman::p_load()` ఇప్పటికే మీ కోసం అది చేసింది)\n"
],
"metadata": {
"id": "gpO_P_6f9WUG"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# load the core Tidyverse packages\r\n",
"library(tidyverse)\r\n",
"\r\n",
"# load the core Tidymodels packages\r\n",
"library(tidymodels)\r\n"
],
"outputs": [],
"metadata": {
"id": "NLMycgG-9ezO"
}
},
{
"cell_type": "markdown",
"source": [
"## 2. మధుమేహ డేటాసెట్\n",
"\n",
"ఈ వ్యాయామంలో, మేము మధుమేహ డేటాసెట్‌పై అంచనాలు వేయడం ద్వారా మా రిగ్రెషన్ నైపుణ్యాలను ప్రదర్శించబోతున్నాము. [మధుమేహ డేటాసెట్](https://www4.stat.ncsu.edu/~boos/var.select/diabetes.rwrite1.txt) లో మధుమేహం గురించి `442 నమూనాలు` ఉన్నాయి, 10 సూచిక ఫీచర్ వేరియబుల్స్‌తో, `వయస్సు`, `లింగం`, `శరీర ద్రవ్యం సూచిక`, `సగటు రక్తపోటు`, మరియు `ఆరు రక్త సీరమ్ కొలతలు` అలాగే ఒక ఫలిత వేరియబుల్ `y`: ప్రాథమిక స్థితి తర్వాత ఒక సంవత్సరం లో వ్యాధి పురోగతి యొక్క పరిమాణాత్మక కొలత.\n",
"\n",
"|పరిశీలనల సంఖ్య|442|\n",
"|----------------------|:---|\n",
"|సూచికల సంఖ్య|మొదటి 10 కాలమ్స్ సంఖ్యాత్మక సూచికలు|\n",
"|ఫలితం/లక్ష్యం|11వ కాలమ్ ప్రాథమిక స్థితి తర్వాత ఒక సంవత్సరం లో వ్యాధి పురోగతి యొక్క పరిమాణాత్మక కొలత|\n",
"|సూచిక సమాచారం|- వయస్సు సంవత్సరాలలో\n",
"||- లింగం\n",
"||- bmi శరీర ద్రవ్యం సూచిక\n",
"||- bp సగటు రక్తపోటు\n",
"||- s1 tc, మొత్తం సీరమ్ కొలెస్ట్రాల్\n",
"||- s2 ldl, తక్కువ సాంద్రత లిపోప్రోటీన్లు\n",
"||- s3 hdl, అధిక సాంద్రత లిపోప్రోటీన్లు\n",
"||- s4 tch, మొత్తం కొలెస్ట్రాల్ / HDL\n",
"||- s5 ltg, సీరమ్ ట్రైగ్లిసరైడ్స్ స్థాయి యొక్క లాగ్ కావచ్చు\n",
"||- s6 glu, రక్తంలో చక్కెర స్థాయి|\n",
"\n",
"\n",
"\n",
"\n",
"> 🎓 గుర్తుంచుకోండి, ఇది పర్యవేక్షిత అభ్యాసం, మరియు మాకు 'y' అనే పేరుతో లక్ష్యం అవసరం.\n",
"\n",
"R తో డేటాను నిర్వహించడానికి ముందు, మీరు డేటాను R యొక్క మెమరీలో దిగుమతి చేసుకోవాలి, లేదా R డేటాను దూరంగా యాక్సెస్ చేయడానికి ఉపయోగించే కనెక్షన్‌ను నిర్మించాలి.\n",
"\n",
"> [readr](https://readr.tidyverse.org/) ప్యాకేజ్, ఇది Tidyverse భాగం, R లో చతురస్ర డేటాను వేగంగా మరియు స్నేహపూర్వకంగా చదవడానికి ఒక మార్గాన్ని అందిస్తుంది.\n",
"\n",
"ఇప్పుడు, ఈ మూల URL నుండి అందించిన మధుమేహ డేటాసెట్‌ను లోడ్ చేద్దాం: <https://www4.stat.ncsu.edu/~boos/var.select/diabetes.html>\n",
"\n",
"అలాగే, `glimpse()` ఉపయోగించి మా డేటాపై ఒక సానిటీ చెక్ నిర్వహించి, `slice()` ఉపయోగించి మొదటి 5 వరుసలను ప్రదర్శిస్తాము.\n",
"\n",
"మరింత ముందుకు వెళ్లేముందు, R కోడ్‌లో మీరు తరచుగా ఎదుర్కొనే ఒక విషయం పరిచయం చేద్దాం 🥁🥁: పైప్ ఆపరేటర్ `%>%`\n",
"\n",
"పైప్ ఆపరేటర్ (`%>%`) ఒక ఆబ్జెక్టును ఫంక్షన్ లేదా కాల్ ఎక్స్‌ప్రెషన్‌కు ముందుకు పంపుతూ లాజికల్ క్రమంలో ఆపరేషన్లను నిర్వహిస్తుంది. మీరు పైప్ ఆపరేటర్‌ను మీ కోడ్‌లో \"అప్పుడు\" అని చెప్పడం లాగా భావించవచ్చు.\n"
],
"metadata": {
"id": "KM6iXLH996Cl"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Import the data set\r\n",
"diabetes <- read_table2(file = \"https://www4.stat.ncsu.edu/~boos/var.select/diabetes.rwrite1.txt\")\r\n",
"\r\n",
"\r\n",
"# Get a glimpse and dimensions of the data\r\n",
"glimpse(diabetes)\r\n",
"\r\n",
"\r\n",
"# Select the first 5 rows of the data\r\n",
"diabetes %>% \r\n",
" slice(1:5)"
],
"outputs": [],
"metadata": {
"id": "Z1geAMhM-bSP"
}
},
{
"cell_type": "markdown",
"source": [
"`glimpse()` మనకు ఈ డేటాలో 442 వరుసలు మరియు 11 కాలమ్స్ ఉన్నాయని చూపిస్తుంది, అన్ని కాలమ్స్ డేటా టైప్ `double` గా ఉన్నాయి\n",
"\n",
"<br>\n",
"\n",
"\n",
"\n",
"> glimpse() మరియు slice() ఫంక్షన్లు [`dplyr`](https://dplyr.tidyverse.org/) లో ఉన్నాయి. Dplyr, Tidyverse భాగంగా, డేటా మానిప్యులేషన్ యొక్క ఒక వ్యాకరణం, ఇది సాధారణ డేటా మానిప్యులేషన్ సవాళ్లను పరిష్కరించడానికి సహాయపడే సజావుగా ఉండే క్రియాపదాల సెట్‌ను అందిస్తుంది\n",
"\n",
"<br>\n",
"\n",
"ఇప్పుడు మన దగ్గర డేటా ఉన్నందున, ఈ వ్యాయామం కోసం ఒక ఫీచర్ (`bmi`) పై దృష్టి సారిద్దాం. దీని కోసం మనం కావలసిన కాలమ్స్‌ను ఎంచుకోవాలి. కాబట్టి, మనం దీన్ని ఎలా చేస్తాం?\n",
"\n",
"[`dplyr::select()`](https://dplyr.tidyverse.org/reference/select.html) మనకు డేటా ఫ్రేమ్‌లో కాలమ్స్‌ను *ఎంచుకోవడానికి* (అవసరమైతే పేరు మార్చడానికి) అనుమతిస్తుంది.\n"
],
"metadata": {
"id": "UwjVT1Hz-c3Z"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Select predictor feature `bmi` and outcome `y`\r\n",
"diabetes_select <- diabetes %>% \r\n",
" select(c(bmi, y))\r\n",
"\r\n",
"# Print the first 5 rows\r\n",
"diabetes_select %>% \r\n",
" slice(1:10)"
],
"outputs": [],
"metadata": {
"id": "RDY1oAKI-m80"
}
},
{
"cell_type": "markdown",
"source": [
"## 3. శిక్షణ మరియు పరీక్ష డేటా\n",
"\n",
"పర్యవేక్షిత అభ్యాసంలో డేటాను రెండు ఉపసమూహాలుగా *విభజించడం* సాధారణ ఆచారం; ఒకటి (సాధారణంగా పెద్దది) మోడల్‌ను శిక్షణ ఇవ్వడానికి ఉపయోగించే సెట్, మరియు మరొక చిన్న \"హోల్డ్-బ్యాక్\" సెట్ మోడల్ ఎలా ప్రదర్శించిందో చూడటానికి ఉపయోగిస్తారు.\n",
"\n",
"ఇప్పుడు మనకు డేటా సిద్ధంగా ఉన్నందున, ఈ డేటాసెట్‌లోని సంఖ్యల మధ్య తార్కికమైన విభజనను యంత్రం సహాయంతో నిర్ణయించగలమా అని చూడవచ్చు. మనం Tidymodels ఫ్రేమ్‌వర్క్‌లో భాగమైన [rsample](https://tidymodels.github.io/rsample/) ప్యాకేజీని ఉపయోగించి, డేటాను *ఎలా* విభజించాలో సమాచారం కలిగిన ఒక ఆబ్జెక్ట్‌ను సృష్టించవచ్చు, మరియు ఆపై సృష్టించిన శిక్షణ మరియు పరీక్ష సెట్‌లను తీసుకోవడానికి రెండు మరిన్ని rsample ఫంక్షన్లను ఉపయోగించవచ్చు:\n"
],
"metadata": {
"id": "SDk668xK-tc3"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"set.seed(2056)\r\n",
"# Split 67% of the data for training and the rest for tesing\r\n",
"diabetes_split <- diabetes_select %>% \r\n",
" initial_split(prop = 0.67)\r\n",
"\r\n",
"# Extract the resulting train and test sets\r\n",
"diabetes_train <- training(diabetes_split)\r\n",
"diabetes_test <- testing(diabetes_split)\r\n",
"\r\n",
"# Print the first 3 rows of the training set\r\n",
"diabetes_train %>% \r\n",
" slice(1:10)"
],
"outputs": [],
"metadata": {
"id": "EqtHx129-1h-"
}
},
{
"cell_type": "markdown",
"source": [
"## 4. Tidymodels తో లీనియర్ రిగ్రెషన్ మోడల్‌ను శిక్షణ ఇవ్వండి\n",
"\n",
"ఇప్పుడు మనం మన మోడల్‌ను శిక్షణ ఇవ్వడానికి సిద్ధంగా ఉన్నాము!\n",
"\n",
"Tidymodels లో, మీరు `parsnip()` ఉపయోగించి మోడల్స్‌ను మూడు భావనలను పేర్కొనడం ద్వారా నిర్దేశిస్తారు:\n",
"\n",
"- మోడల్ **రకం** లీనియర్ రిగ్రెషన్, లాజిస్టిక్ రిగ్రెషన్, డెసిషన్ ట్రీ మోడల్స్ మరియు ఇతర మోడల్స్‌ను వేరుచేస్తుంది.\n",
"\n",
"- మోడల్ **మోడ్** రిగ్రెషన్ మరియు వర్గీకరణ వంటి సాధారణ ఎంపికలను కలిగి ఉంటుంది; కొన్ని మోడల్ రకాలు వీటిలో ఏదైనా మోడ్‌ను మద్దతు ఇస్తాయి, మరికొన్ని ఒక్క మోడ్ మాత్రమే కలిగి ఉంటాయి.\n",
"\n",
"- మోడల్ **ఇంజిన్** అనేది మోడల్‌ను ఫిట్ చేయడానికి ఉపయోగించే గణనాత్మక సాధనం. ఇవి తరచుగా R ప్యాకేజీలు, ఉదాహరణకు **`\"lm\"`** లేదా **`\"ranger\"`**\n",
"\n",
"ఈ మోడలింగ్ సమాచారం మోడల్ స్పెసిఫికేషన్‌లో సేకరించబడుతుంది, కాబట్టి ఒకదాన్ని నిర్మిద్దాం!\n"
],
"metadata": {
"id": "sBOS-XhB-6v7"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Build a linear model specification\r\n",
"lm_spec <- \r\n",
" # Type\r\n",
" linear_reg() %>% \r\n",
" # Engine\r\n",
" set_engine(\"lm\") %>% \r\n",
" # Mode\r\n",
" set_mode(\"regression\")\r\n",
"\r\n",
"\r\n",
"# Print the model specification\r\n",
"lm_spec"
],
"outputs": [],
"metadata": {
"id": "20OwEw20--t3"
}
},
{
"cell_type": "markdown",
"source": [
"మోడల్‌ను *స్పెసిఫై* చేసిన తర్వాత, మోడల్‌ను సాధారణంగా ఒక ఫార్ములా మరియు కొంత డేటా ఉపయోగించి [`fit()`](https://parsnip.tidymodels.org/reference/fit.html) ఫంక్షన్ ద్వారా `estimated` లేదా `trained` చేయవచ్చు.\n",
"\n",
"`y ~ .` అంటే మనం `y` ను అంచనా వేయబడే పరిమాణం/లక్ష్యంగా ఫిట్ చేస్తాము, ఇది అన్ని ప్రిడిక్టర్లు/ఫీచర్లు అంటే `.` ద్వారా వివరించబడుతుంది (ఈ సందర్భంలో, మనకు ఒకే ఒక ప్రిడిక్టర్ ఉంది: `bmi`)\n"
],
"metadata": {
"id": "_oDHs89k_CJj"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Build a linear model specification\r\n",
"lm_spec <- linear_reg() %>% \r\n",
" set_engine(\"lm\") %>%\r\n",
" set_mode(\"regression\")\r\n",
"\r\n",
"\r\n",
"# Train a linear regression model\r\n",
"lm_mod <- lm_spec %>% \r\n",
" fit(y ~ ., data = diabetes_train)\r\n",
"\r\n",
"# Print the model\r\n",
"lm_mod"
],
"outputs": [],
"metadata": {
"id": "YlsHqd-q_GJQ"
}
},
{
"cell_type": "markdown",
"source": [
"మోడల్ అవుట్పుట్ నుండి, మనం శిక్షణ సమయంలో నేర్చుకున్న గుణకాలను చూడవచ్చు. అవి నిజమైన మరియు అంచనా వేరియబుల్ మధ్య మొత్తం లోతైన పొరపాటు తక్కువగా ఉండే ఉత్తమ సరళి యొక్క గుణకాలను సూచిస్తాయి.\n",
"<br>\n",
"\n",
"## 5. పరీక్ష సెట్ పై అంచనాలు చేయండి\n",
"\n",
"ఇప్పుడు మనం ఒక మోడల్ శిక్షణ ఇచ్చినందున, దాన్ని ఉపయోగించి పరీక్ష డేటాసెట్ కోసం వ్యాధి పురోగతిని y అంచనా వేయవచ్చు [parsnip::predict()](https://parsnip.tidymodels.org/reference/predict.model_fit.html) ఉపయోగించి. ఇది డేటా సమూహాల మధ్య సరళి గీయడానికి ఉపయోగించబడుతుంది.\n"
],
"metadata": {
"id": "kGZ22RQj_Olu"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Make predictions for the test set\r\n",
"predictions <- lm_mod %>% \r\n",
" predict(new_data = diabetes_test)\r\n",
"\r\n",
"# Print out some of the predictions\r\n",
"predictions %>% \r\n",
" slice(1:5)"
],
"outputs": [],
"metadata": {
"id": "nXHbY7M2_aao"
}
},
{
"cell_type": "markdown",
"source": [
"వాహ్! 💃🕺 మేము ఒక మోడల్‌ను శిక్షణ ఇచ్చాము మరియు దాన్ని ఉపయోగించి అంచనాలు చేసాము!\n",
"\n",
"అంచనాలు చేయడంలో, tidymodels సంప్రదాయం ఎప్పుడూ ఫలితాల యొక్క టిబుల్/డేటా ఫ్రేమ్‌ను ప్రమాణీకృత కాలమ్ పేర్లతో ఉత్పత్తి చేయడం. ఇది అసలు డేటా మరియు అంచనాలను కలిపి తరువాతి ఆపరేషన్ల కోసం ఉపయోగించదగిన ఫార్మాట్‌లో ఉంచడం సులభం చేస్తుంది, ఉదాహరణకు ప్లాటింగ్.\n",
"\n",
"`dplyr::bind_cols()` అనేది బహుళ డేటా ఫ్రేమ్‌లను కాలమ్‌లుగా సమర్థవంతంగా బంధిస్తుంది.\n"
],
"metadata": {
"id": "R_JstwUY_bIs"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Combine the predictions and the original test set\r\n",
"results <- diabetes_test %>% \r\n",
" bind_cols(predictions)\r\n",
"\r\n",
"\r\n",
"results %>% \r\n",
" slice(1:5)"
],
"outputs": [],
"metadata": {
"id": "RybsMJR7_iI8"
}
},
{
"cell_type": "markdown",
"source": [
"## 6. మోడల్ ఫలితాలను చిత్రీకరించండి\n",
"\n",
"ఇప్పుడు, దీన్ని దృశ్యరూపంలో చూడాల్సిన సమయం 📈. టెస్ట్ సెట్‌లోని అన్ని `y` మరియు `bmi` విలువల scatter plot ను సృష్టిస్తాము, ఆపై మోడల్ డేటా గ్రూపింగ్‌ల మధ్య సరైన స్థలంలో prediction లను ఉపయోగించి ఒక రేఖను గీయుతాము.\n",
"\n",
"R లో గ్రాఫ్‌లను తయారు చేయడానికి అనేక విధానాలు ఉన్నాయి, కానీ `ggplot2` అత్యంత అందమైన మరియు బహుముఖమైన వాటిలో ఒకటి. ఇది **స్వతంత్ర భాగాలను కలిపి** గ్రాఫ్‌లను రూపొందించడానికి అనుమతిస్తుంది.\n"
],
"metadata": {
"id": "XJbYbMZW_n_s"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Set a theme for the plot\r\n",
"theme_set(theme_light())\r\n",
"# Create a scatter plot\r\n",
"results %>% \r\n",
" ggplot(aes(x = bmi)) +\r\n",
" # Add a scatter plot\r\n",
" geom_point(aes(y = y), size = 1.6) +\r\n",
" # Add a line plot\r\n",
" geom_line(aes(y = .pred), color = \"blue\", size = 1.5)"
],
"outputs": [],
"metadata": {
"id": "R9tYp3VW_sTn"
}
},
{
"cell_type": "markdown",
"source": [
"> ✅ ఇక్కడ ఏమి జరుగుతుందో కొంచెం ఆలోచించండి. ఒక సరళ రేఖ అనేక చిన్న డాటా బిందువుల ద్వారా నడుస్తోంది, కానీ అది నిజంగా ఏమి చేస్తోంది? మీరు ఈ రేఖను ఉపయోగించి కొత్త, చూడని డాటా పాయింట్ ప్లాట్ యొక్క y అక్షానికి సంబంధించి ఎక్కడ సరిపోతుందో ఎలా అంచనా వేయగలరో చూడగలరా? ఈ మోడల్ యొక్క ప్రాక్టికల్ ఉపయోగాన్ని పదాలలో వ్యక్తం చేయడానికి ప్రయత్నించండి.\n",
"\n",
"అభినందనలు, మీరు మీ మొదటి లీనియర్ రిగ్రెషన్ మోడల్‌ను నిర్మించారు, దానితో ఒక అంచనాను సృష్టించారు, మరియు దాన్ని ఒక ప్లాట్‌లో ప్రదర్శించారు!\n"
],
"metadata": {
"id": "zrPtHIxx_tNI"
}
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

677
translations/te/2-Regression/1-Tools/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

228
translations/te/2-Regression/2-Data/README.md
Unescape View File

@ -0,0 +1,228 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7c077988328ebfe33b24d07945f16eca",
"translation_date": "2025-12-19T13:58:37+00:00",
"source_file": "2-Regression/2-Data/README.md",
"language_code": "te"
}
-->
# Scikit-learn ఉపయోగించి రిగ్రెషన్ మోడల్ నిర్మించండి: డేటాను సిద్ధం చేయండి మరియు విజువలైజ్ చేయండి
![డేటా విజువలైజేషన్ ఇన్ఫోగ్రాఫిక్](../../../../translated_images/data-visualization.54e56dded7c1a804d00d027543f2881cb32da73aeadda2d4a4f10f3497526114.te.png)
ఇన్ఫోగ్రాఫిక్ [దాసాని మడిపల్లి](https://twitter.com/dasani_decoded) ద్వారా
## [ప్రీ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
> ### [ఈ పాఠం R లో అందుబాటులో ఉంది!](../../../../2-Regression/2-Data/solution/R/lesson_2.html)
## పరిచయం
Scikit-learn తో మెషీన్ లెర్నింగ్ మోడల్ నిర్మాణాన్ని ప్రారంభించడానికి మీరు అవసరమైన టూల్స్ సెట్ చేసుకున్న తర్వాత, మీరు మీ డేటాను ప్రశ్నించడానికి సిద్ధంగా ఉన్నారు. డేటాతో పని చేయడం మరియు ML పరిష్కారాలను వర్తింపజేయడం సమయంలో, మీ డేటాసెట్ యొక్క సామర్థ్యాలను సరిగ్గా అన్‌లాక్ చేయడానికి సరైన ప్రశ్నను అడగడం చాలా ముఖ్యం.
ఈ పాఠంలో, మీరు నేర్చుకుంటారు:
- మోడల్-నిర్మాణం కోసం మీ డేటాను ఎలా సిద్ధం చేయాలి.
- డేటా విజువలైజేషన్ కోసం Matplotlib ను ఎలా ఉపయోగించాలి.
## మీ డేటాకు సరైన ప్రశ్న అడగడం
మీరు సమాధానం కావలసిన ప్రశ్న మీకు ఉపయోగించే ML అల్గోరిథమ్స్ రకాన్ని నిర్ణయిస్తుంది. మీరు పొందే సమాధానం నాణ్యత మీ డేటా స్వభావంపై బలంగా ఆధారపడి ఉంటుంది.
ఈ పాఠం కోసం అందించిన [డేటాను](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) చూడండి. మీరు ఈ .csv ఫైల్‌ను VS Code లో తెరవవచ్చు. ఒక వేగవంతమైన పరిశీలనలోనే ఖాళీలు మరియు స్ట్రింగ్స్ మరియు న్యూమరిక్ డేటా మిశ్రమం ఉన్నట్లు కనిపిస్తుంది. 'Package' అనే విచిత్రమైన కాలమ్ కూడా ఉంది, ఇందులో డేటా 'sacks', 'bins' మరియు ఇతర విలువల మిశ్రమం. వాస్తవానికి, డేటా కొంత గందరగోళంగా ఉంది.
[![ML for beginners - How to Analyze and Clean a Dataset](https://img.youtube.com/vi/5qGjczWTrDQ/0.jpg)](https://youtu.be/5qGjczWTrDQ "ML for beginners - How to Analyze and Clean a Dataset")
> 🎥 ఈ పాఠం కోసం డేటాను సిద్ధం చేయడాన్ని చూపించే చిన్న వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి.
వాస్తవానికి, పూర్తిగా ఉపయోగించడానికి సిద్ధంగా ఉన్న డేటాసెట్‌ను బహుమతిగా పొందడం చాలా సాధారణం కాదు. ఈ పాఠంలో, మీరు ప్రామాణిక Python లైబ్రరీలను ఉపయోగించి రా డేటాసెట్‌ను ఎలా సిద్ధం చేయాలో నేర్చుకుంటారు. మీరు డేటాను విజువలైజ్ చేయడానికి వివిధ సాంకేతికతలను కూడా నేర్చుకుంటారు.
## కేసు అధ్యయనం: 'పంప్కిన్ మార్కెట్'
ఈ ఫోల్డర్‌లో మీరు రూట్ `data` ఫోల్డర్‌లో [US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv) అనే .csv ఫైల్‌ను కనుగొంటారు, ఇది నగరాల వారీగా వర్గీకరించిన పంప్కిన్ మార్కెట్ గురించి 1757 లైన్ల డేటాను కలిగి ఉంది. ఇది యునైటెడ్ స్టేట్స్ డిపార్ట్‌మెంట్ ఆఫ్ అగ్రికల్చర్ పంపిణీ చేసే [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) నుండి తీసుకున్న రా డేటా.
### డేటా సిద్ధం చేయడం
ఈ డేటా పబ్లిక్ డొమైన్‌లో ఉంది. USDA వెబ్ సైట్ నుండి ప్రతి నగరానికి వేర్వేరు ఫైళ్లలో డౌన్లోడ్ చేసుకోవచ్చు. చాలా వేర్వేరు ఫైళ్లను నివారించడానికి, మేము అన్ని నగరాల డేటాను ఒక స్ప్రెడ్షీట్‌లో కలిపాము, అందువల్ల మేము ఇప్పటికే డేటాను కొంతమేర _సిద్ధం_ చేసాము. తరువాత, డేటాను మరింత దగ్గరగా పరిశీలిద్దాం.
### పంప్కిన్ డేటా - ప్రారంభ తాత్త్వికాలు
ఈ డేటా గురించి మీరు ఏమి గమనించారు? మీరు ఇప్పటికే స్ట్రింగ్స్, నంబర్లు, ఖాళీలు మరియు విచిత్రమైన విలువల మిశ్రమం ఉన్నట్లు చూశారు, వాటిని అర్థం చేసుకోవాలి.
రిగ్రెషన్ సాంకేతికతను ఉపయోగించి ఈ డేటాకు మీరు ఏ ప్రశ్న అడగవచ్చు? "నిర్దిష్ట నెలలో అమ్మకానికి ఉన్న పంప్కిన్ ధరను అంచనా వేయండి" అని ఎలా ఉంటుంది? డేటాను మళ్లీ చూసినప్పుడు, ఈ పనికి అవసరమైన డేటా నిర్మాణాన్ని సృష్టించడానికి మీరు కొన్ని మార్పులు చేయాలి.
## వ్యాయామం - పంప్కిన్ డేటాను విశ్లేషించండి
డేటాను ఆకారంలోకి తెచ్చేందుకు చాలా ఉపయోగకరమైన పాండాస్ ([Pandas](https://pandas.pydata.org/)) ను ఉపయోగించి ఈ పంప్కిన్ డేటాను విశ్లేషించండి మరియు సిద్ధం చేయండి.
### మొదట, మిస్సింగ్ తేదీలను తనిఖీ చేయండి
ముందుగా మిస్సింగ్ తేదీలను తనిఖీ చేయడానికి చర్యలు తీసుకోవాలి:
1. తేదీలను నెల ఫార్మాట్‌కు మార్చండి (ఇవి US తేదీలు, కాబట్టి ఫార్మాట్ `MM/DD/YYYY`).
2. నెలను కొత్త కాలమ్‌గా తీసుకోండి.
Visual Studio Code లో _notebook.ipynb_ ఫైల్‌ను తెరవండి మరియు స్ప్రెడ్షీట్‌ను కొత్త Pandas డేటాఫ్రేమ్‌లో దిగుమతి చేసుకోండి.
1. మొదటి ఐదు వరుసలను చూడడానికి `head()` ఫంక్షన్‌ను ఉపయోగించండి.
```python
import pandas as pd
pumpkins = pd.read_csv('../data/US-pumpkins.csv')
pumpkins.head()
```
✅ చివరి ఐదు వరుసలను చూడడానికి మీరు ఏ ఫంక్షన్ ఉపయోగిస్తారు?
1. ప్రస్తుత డేటాఫ్రేమ్‌లో మిస్సింగ్ డేటా ఉందా అని తనిఖీ చేయండి:
```python
pumpkins.isnull().sum()
```
మిస్సింగ్ డేటా ఉంది, కానీ ఇది ప్రస్తుత పనికి ప్రభావం చూపకపోవచ్చు.
1. మీ డేటాఫ్రేమ్‌తో పని చేయడం సులభం కావడానికి, మీరు అవసరమైన కాలమ్స్ మాత్రమే `loc` ఫంక్షన్ ఉపయోగించి ఎంచుకోండి, ఇది ఒరిజినల్ డేటాఫ్రేమ్ నుండి వరుసలు (మొదటి పారామీటర్‌గా) మరియు కాలమ్స్ (రెండవ పారామీటర్‌గా) తీసుకుంటుంది. క్రింద ఉన్న `:` అన్నది "అన్ని వరుసలు" అని అర్థం.
```python
columns_to_select = ['Package', 'Low Price', 'High Price', 'Date']
pumpkins = pumpkins.loc[:, columns_to_select]
```
### రెండవది, పంప్కిన్ సగటు ధరను నిర్ణయించండి
నిర్దిష్ట నెలలో పంప్కిన్ సగటు ధరను ఎలా నిర్ణయించాలో ఆలోచించండి. ఈ పనికి మీరు ఏ కాలమ్స్ ఎంచుకుంటారు? సూచన: మీరు 3 కాలమ్స్ అవసరం.
పరిష్కారం: `Low Price` మరియు `High Price` కాలమ్స్ సగటు తీసుకుని కొత్త Price కాలమ్‌ను పూరించండి, మరియు Date కాలమ్‌ను నెల మాత్రమే చూపించేలా మార్చండి. అదృష్టవశాత్తు, పై తనిఖీ ప్రకారం, తేదీలు లేదా ధరల కోసం మిస్సింగ్ డేటా లేదు.
1. సగటు లెక్కించడానికి, క్రింది కోడ్ జోడించండి:
```python
price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
month = pd.DatetimeIndex(pumpkins['Date']).month
```
✅ మీరు `print(month)` ఉపయోగించి ఏ డేటా అయినా తనిఖీ చేయడానికి ప్రింట్ చేయవచ్చు.
2. ఇప్పుడు, మీ మార్చిన డేటాను కొత్త Pandas డేటాఫ్రేమ్‌లో కాపీ చేయండి:
```python
new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
```
మీ డేటాఫ్రేమ్‌ను ప్రింట్ చేస్తే, మీరు కొత్త రిగ్రెషన్ మోడల్ నిర్మించడానికి శుభ్రమైన, సజావుగా ఉన్న డేటాసెట్‌ను చూడగలుగుతారు.
### కానీ వేచి ఉండండి! ఇక్కడ ఒక విచిత్ర విషయం ఉంది
`Package` కాలమ్‌ను చూస్తే, పంప్కిన్లు అనేక వేర్వేరు ఆకృతుల్లో అమ్మబడుతున్నాయి. కొన్ని '1 1/9 బుషెల్' కొలతలలో, కొన్ని '1/2 బుషెల్' కొలతలలో, కొన్ని ఒక్కొక్క పంప్కిన్‌కు, కొన్ని పౌండ్లకు, మరియు కొన్ని విభిన్న వెడల్పుల పెద్ద బాక్స్‌లలో అమ్మబడుతున్నాయి.
> పంప్కిన్లను సరిగ్గా తూగడం చాలా కష్టం అనిపిస్తుంది
మూల డేటాలో లోతుగా చూస్తే, `Unit of Sale` 'EACH' లేదా 'PER BIN' ఉన్న వాటికి `Package` రకం అంగుళం, బిన్ లేదా 'each' అని ఉంటుంది. పంప్కిన్లను సరిగ్గా తూగడం చాలా కష్టం కనుక, `Package` కాలమ్‌లో 'bushel' స్ట్రింగ్ ఉన్న పంప్కిన్లను మాత్రమే ఎంచుకుని ఫిల్టర్ చేద్దాం.
1. ఫైల్ ప్రారంభంలో, మొదటి .csv దిగుమతి కింద ఫిల్టర్ జోడించండి:
```python
pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
```
ఇప్పుడు మీరు డేటాను ప్రింట్ చేస్తే, మీరు బుషెల్ ద్వారా పంప్కిన్లను కలిగిన సుమారు 415 వరుసల డేటాను మాత్రమే పొందుతున్నారని చూడగలుగుతారు.
### కానీ వేచి ఉండండి! ఇంకా ఒక పని చేయాలి
మీరు గమనించారా, బుషెల్ పరిమాణం వరుసల వారీగా మారుతుంది? మీరు ధరలను బుషెల్‌కు అనుగుణంగా సాధారణీకరించాలి, కాబట్టి ధరలను బుషెల్‌కు సరిపడేలా గణితం చేయండి.
1. కొత్త_pumpkins డేటాఫ్రేమ్ సృష్టించిన తర్వాత ఈ లైన్లను జోడించండి:
```python
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/(1 + 1/9)
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
```
✅ [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308) ప్రకారం, బుషెల్ బరువు ఉత్పత్తి రకంపై ఆధారపడి ఉంటుంది, ఎందుకంటే ఇది వాల్యూమ్ కొలత. "ఉదాహరణకు, టమోటాలు బుషెల్ 56 పౌండ్ల బరువు ఉండాలి... ఆకులు మరియు ఆకుకూరలు తక్కువ బరువుతో ఎక్కువ స్థలం తీసుకుంటాయి, కాబట్టి స్పినాచ్ బుషెల్ 20 పౌండ్లే ఉంటుంది." ఇది చాలా క్లిష్టం! బుషెల్-టు-పౌండ్ మార్పిడి చేయకుండా, బుషెల్ ప్రకారం ధర నిర్ణయిద్దాం. ఈ పంప్కిన్ బుషెల్ అధ్యయనం మీ డేటా స్వభావాన్ని అర్థం చేసుకోవడం ఎంత ముఖ్యమో చూపిస్తుంది!
ఇప్పుడు, మీరు బుషెల్ కొలత ఆధారంగా యూనిట్ ధరలను విశ్లేషించవచ్చు. మీరు డేటాను మరలా ప్రింట్ చేస్తే, అది ఎలా సాధారణీకరించబడిందో చూడవచ్చు.
✅ మీరు గమనించారా, సగం బుషెల్ ద్వారా అమ్మే పంప్కిన్లు చాలా ఖరీదైనవి? ఎందుకని మీరు అర్థం చేసుకోగలరా? సూచన: చిన్న పంప్కిన్లు పెద్ద వాటికంటే చాలా ఎక్కువ ధర కలిగి ఉంటాయి, ఎందుకంటే పెద్ద హాలో పాయ్ పంప్కిన్ తీసుకునే ఉపయోగించని స్థలం కారణంగా బుషెల్‌కు చాలా ఎక్కువ చిన్న పంప్కిన్లు ఉంటాయి.
## విజువలైజేషన్ వ్యూహాలు
డేటా సైంటిస్ట్ పాత్రలో భాగంగా వారు పని చేస్తున్న డేటా నాణ్యత మరియు స్వభావాన్ని ప్రదర్శించడం ఉంటుంది. దీని కోసం, వారు తరచుగా ఆసక్తికరమైన విజువలైజేషన్లు, ప్లాట్లు, గ్రాఫ్లు మరియు చార్ట్లు సృష్టిస్తారు, డేటా వివిధ కోణాలను చూపిస్తూ. ఈ విధంగా, వారు بصریంగా సంబంధాలు మరియు గ్యాప్స్ చూపగలుగుతారు, ఇవి ఇతరथा కనుగొనడం కష్టం.
[![ML for beginners - How to Visualize Data with Matplotlib](https://img.youtube.com/vi/SbUkxH6IJo0/0.jpg)](https://youtu.be/SbUkxH6IJo0 "ML for beginners - How to Visualize Data with Matplotlib")
> 🎥 ఈ పాఠం కోసం డేటాను విజువలైజ్ చేయడాన్ని చూపించే చిన్న వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి.
విజువలైజేషన్లు డేటాకు అత్యంత అనుకూలమైన మెషీన్ లెర్నింగ్ సాంకేతికతను నిర్ణయించడంలో కూడా సహాయపడతాయి. ఉదాహరణకు, ఒక స్కాటర్‌ప్లాట్ ఒక రేఖను అనుసరిస్తున్నట్లయితే, ఆ డేటా లీనియర్ రిగ్రెషన్ వ్యాయామానికి మంచి అభ్యర్థిగా ఉంటుంది.
Jupyter నోట్బుక్స్‌లో బాగా పనిచేసే ఒక డేటా విజువలైజేషన్ లైబ్రరీ [Matplotlib](https://matplotlib.org/) (ముందటి పాఠంలో మీరు చూసినది).
> [ఈ ట్యుటోరియల్స్](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott) లో డేటా విజువలైజేషన్ పై మరింత అనుభవం పొందండి.
## వ్యాయామం - Matplotlib తో ప్రయోగం చేయండి
మీరు సృష్టించిన కొత్త డేటాఫ్రేమ్‌ను ప్రదర్శించడానికి కొన్ని ప్రాథమిక ప్లాట్లు సృష్టించడానికి ప్రయత్నించండి. ఒక ప్రాథమిక లైన్ ప్లాట్ ఏమి చూపిస్తుంది?
1. ఫైల్ ప్రారంభంలో, Pandas దిగుమతి కింద Matplotlib ను దిగుమతి చేసుకోండి:
```python
import matplotlib.pyplot as plt
```
1. మొత్తం నోట్బుక్‌ను రీఫ్రెష్ చేయడానికి మళ్లీ నడపండి.
1. నోట్బుక్ చివరలో, డేటాను బాక్స్‌గా ప్లాట్ చేయడానికి ఒక సెల్ జోడించండి:
```python
price = new_pumpkins.Price
month = new_pumpkins.Month
plt.scatter(price, month)
plt.show()
```
![ధర మరియు నెల సంబంధాన్ని చూపించే స్కాటర్‌ప్లాట్](../../../../translated_images/scatterplot.b6868f44cbd2051c6680ccdbb1510697d06a3ff6cd4abda656f5009c0ed4e3fc.te.png)
ఇది ఉపయోగకరమైన ప్లాట్నా? ఇందులో ఏదైనా ఆశ్చర్యకరమైనది ఉందా?
ఇది ప్రత్యేకంగా ఉపయోగకరం కాదు, ఎందుకంటే ఇది మీ డేటాను ఒక నెలలో పాయింట్ల విస్తరణగా మాత్రమే ప్రదర్శిస్తుంది.
### దీన్ని ఉపయోగకరంగా చేయండి
చార్ట్లు ఉపయోగకరమైన డేటాను ప్రదర్శించాలంటే, మీరు సాధారణంగా డేటాను ఏదో విధంగా గ్రూప్ చేయాలి. నెలలను y అక్షంగా చూపించే మరియు డేటా పంపిణీని ప్రదర్శించే ప్లాట్ సృష్టించడానికి ప్రయత్నిద్దాం.
1. గ్రూప్ చేసిన బార్ చార్ట్ సృష్టించడానికి ఒక సెల్ జోడించండి:
```python
new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
plt.ylabel("Pumpkin Price")
```
![ధర మరియు నెల సంబంధాన్ని చూపించే బార్ చార్ట్](../../../../translated_images/barchart.a833ea9194346d769c77a3a870f7d8aee51574cd1138ca902e5500830a41cbce.te.png)
ఇది మరింత ఉపయోగకరమైన డేటా విజువలైజేషన్! ఇది పంప్కిన్ ధర సెప్టెంబర్ మరియు అక్టోబర్‌లో అత్యధికంగా ఉంటుందని సూచిస్తుంది. ఇది మీ అంచనాకు సరిపోతుందా? ఎందుకు లేదా ఎందుకు కాదు?
---
## 🚀సవాలు
Matplotlib అందించే వివిధ రకాల విజువలైజేషన్లను అన్వేషించండి. రిగ్రెషన్ సమస్యలకు ఏ రకాలు అత్యంత అనుకూలంగా ఉంటాయి?
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
డేటాను విజువలైజ్ చేయడానికి అనేక మార్గాలను పరిశీలించండి. వివిధ లైబ్రరీల జాబితాను తయారుచేసి, ఏవి ఏ రకాల పనులకు ఉత్తమం అవుతాయో గమనించండి, ఉదాహరణకు 2D విజువలైజేషన్లు vs. 3D విజువలైజేషన్లు. మీరు ఏమి కనుగొంటారు?
## అసైన్‌మెంట్
[విజువలైజేషన్ అన్వేషణ](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

25
translations/te/2-Regression/2-Data/assignment.md
Unescape View File

@ -0,0 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "4485a1ed4dd1b5647365e3d87456515d",
"translation_date": "2025-12-19T14:03:01+00:00",
"source_file": "2-Regression/2-Data/assignment.md",
"language_code": "te"
}
-->
# విజువలైజేషన్ల అన్వేషణ
డేటా విజువలైజేషన్ కోసం అందుబాటులో ఉన్న అనేక విభిన్న లైబ్రరీలు ఉన్నాయి. ఈ పాఠంలో ఉన్న Pumpkin డేటాను ఉపయోగించి matplotlib మరియు seaborn తో కొన్ని విజువలైజేషన్లు సృష్టించండి ఒక నమూనా నోట్‌బుక్‌లో. ఏ లైబ్రరీలు ఉపయోగించడానికి సులభంగా ఉంటాయి?
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతం | సరిపోతుంది | మెరుగుదల అవసరం |
| -------- | --------- | -------- | ----------------- |
| | రెండు అన్వేషణలు/విజువలైజేషన్లతో కూడిన నోట్‌బుక్ సమర్పించబడింది | ఒక అన్వేషణ/విజువలైజేషన్‌తో కూడిన నోట్‌బుక్ సమర్పించబడింది | నోట్‌బుక్ సమర్పించబడలేదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారులు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

46
translations/te/2-Regression/2-Data/notebook.ipynb
Unescape View File

@ -0,0 +1,46 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3-final"
},
"orig_nbformat": 2,
"kernelspec": {
"name": "python3",
"display_name": "Python 3",
"language": "python"
},
"coopTranslator": {
"original_hash": "1b2ab303ac6c604a34c6ca7a49077fc7",
"translation_date": "2025-12-19T16:18:09+00:00",
"source_file": "2-Regression/2-Data/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

17
translations/te/2-Regression/2-Data/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:09:35+00:00",
"source_file": "2-Regression/2-Data/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

673
translations/te/2-Regression/2-Data/solution/R/lesson_2-R.ipynb
Unescape View File

@ -0,0 +1,673 @@
{
"nbformat": 4,
"nbformat_minor": 2,
"metadata": {
"colab": {
"name": "lesson_2-R.ipynb",
"provenance": [],
"collapsed_sections": [],
"toc_visible": true
},
"kernelspec": {
"name": "ir",
"display_name": "R"
},
"language_info": {
"name": "R"
},
"coopTranslator": {
"original_hash": "f3c335f9940cfd76528b3ef918b9b342",
"translation_date": "2025-12-19T16:33:34+00:00",
"source_file": "2-Regression/2-Data/solution/R/lesson_2-R.ipynb",
"language_code": "te"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"# రిగ్రెషన్ మోడల్ నిర్మించండి: డేటాను సిద్ధం చేయండి మరియు విజువలైజ్ చేయండి\n",
"\n",
"## **పంప్కిన్స్ కోసం లీనియర్ రిగ్రెషన్ - పాఠం 2**\n",
"#### పరిచయం\n",
"\n",
"ఇప్పుడు మీరు Tidymodels మరియు Tidyverse తో మెషీన్ లెర్నింగ్ మోడల్ నిర్మాణాన్ని ప్రారంభించడానికి అవసరమైన టూల్స్ తో సెట్ అయ్యారు, మీరు మీ డేటాను ప్రశ్నించడానికి సిద్ధంగా ఉన్నారు. మీరు డేటాతో పని చేస్తూ ML పరిష్కారాలను వర్తింపజేస్తున్నప్పుడు, మీ డేటాసెట్ యొక్క సామర్థ్యాలను సరిగ్గా అన్లాక్ చేయడానికి సరైన ప్రశ్నను అడగడం చాలా ముఖ్యం.\n",
"\n",
"ఈ పాఠంలో, మీరు నేర్చుకుంటారు:\n",
"\n",
"- మోడల్-నిర్మాణం కోసం మీ డేటాను ఎలా సిద్ధం చేయాలి.\n",
"\n",
"- డేటా విజువలైజేషన్ కోసం `ggplot2` ను ఎలా ఉపయోగించాలి.\n",
"\n",
"మీరు అడగవలసిన ప్రశ్న మీకు ఉపయోగపడే ML అల్గోరిథమ్స్ రకాన్ని నిర్ణయిస్తుంది. మరియు మీరు పొందే సమాధానం యొక్క నాణ్యత మీ డేటా స్వభావంపై బలంగా ఆధారపడి ఉంటుంది.\n",
"\n",
"ప్రాక్టికల్ వ్యాయామం ద్వారా దీన్ని చూద్దాం.\n",
"\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/unruly_data.0eedc7ced92d2d919cf5ea197bfe0fe9a30780c4bf7cdcf14ff4e9dc5a4c7267.te.jpg\"\n",
" width=\"700\"/>\n",
" <figcaption>కళాకృతి @allison_horst</figcaption>\n"
],
"metadata": {
"id": "Pg5aexcOPqAZ"
}
},
{
"cell_type": "markdown",
"source": [
"## 1. పంప్కిన్స్ డేటాను దిగుమతి చేసుకోవడం మరియు టిడీవర్స్‌ను పిలవడం\n",
"\n",
"ఈ పాఠాన్ని స్లైస్ చేయడానికి మరియు డైస్ చేయడానికి క్రింది ప్యాకేజీలు అవసరం:\n",
"\n",
"- `tidyverse`: [tidyverse](https://www.tidyverse.org/) అనేది డేటా సైన్స్‌ను వేగవంతం చేయడానికి, సులభతరం చేయడానికి మరియు మరింత సరదాగా మార్చడానికి రూపొందించిన [R ప్యాకేజీల సేకరణ](https://www.tidyverse.org/packages)!\n",
"\n",
"మీరు వాటిని ఇన్‌స్టాల్ చేసుకోవచ్చు:\n",
"\n",
"`install.packages(c(\"tidyverse\"))`\n",
"\n",
"క్రింది స్క్రిప్ట్ ఈ మాడ్యూల్‌ను పూర్తి చేయడానికి అవసరమైన ప్యాకేజీలు మీ వద్ద ఉన్నాయా లేదా అని తనిఖీ చేస్తుంది మరియు కొన్నివి లేవంటే వాటిని మీ కోసం ఇన్‌స్టాల్ చేస్తుంది.\n"
],
"metadata": {
"id": "dc5WhyVdXAjR"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"suppressWarnings(if(!require(\"pacman\")) install.packages(\"pacman\"))\n",
"pacman::p_load(tidyverse)"
],
"outputs": [],
"metadata": {
"id": "GqPYUZgfXOBt"
}
},
{
"cell_type": "markdown",
"source": [
"ఇప్పుడు, కొన్ని ప్యాకేజీలను ప్రారంభించి ఈ పాఠం కోసం అందించిన [డేటా](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv)ని లోడ్ చేద్దాం!\n"
],
"metadata": {
"id": "kvjDTPDSXRr2"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Load the core Tidyverse packages\n",
"library(tidyverse)\n",
"\n",
"# Import the pumpkins data\n",
"pumpkins <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/2-Regression/data/US-pumpkins.csv\")\n",
"\n",
"\n",
"# Get a glimpse and dimensions of the data\n",
"glimpse(pumpkins)\n",
"\n",
"\n",
"# Print the first 50 rows of the data set\n",
"pumpkins %>% \n",
" slice_head(n =50)"
],
"outputs": [],
"metadata": {
"id": "VMri-t2zXqgD"
}
},
{
"cell_type": "markdown",
"source": [
"A quick `glimpse()` వెంటనే చూపిస్తుంది कि ఖాళీలు మరియు స్ట్రింగ్స్ (`chr`) మరియు సంఖ్యా డేటా (`dbl`) మిశ్రమం ఉన్నాయి. `Date` టైపు క్యారెక్టర్ మరియు ఒక విచిత్రమైన కాలమ్ ఉంది `Package` అని, అక్కడ డేటా `sacks`, `bins` మరియు ఇతర విలువల మిశ్రమం. డేటా, వాస్తవానికి, కొంత గందరగోళం 😤.\n",
"\n",
"వాస్తవానికి, పూర్తిగా ఉపయోగించడానికి సిద్ధంగా ఉన్న డేటాసెట్‌ను బహుమతిగా పొందడం చాలా సాధారణం కాదు ML మోడల్‌ను బాక్స్ నుండి సృష్టించడానికి. కానీ చింతించకండి, ఈ పాఠంలో, మీరు మౌలిక R లైబ్రరీలను ఉపయోగించి ఒక రా డేటాసెట్‌ను ఎలా సిద్ధం చేయాలో నేర్చుకుంటారు 🧑‍🔧. మీరు డేటాను విజువలైజ్ చేయడానికి వివిధ సాంకేతికతలను కూడా నేర్చుకుంటారు.📈📊\n",
"<br>\n",
"\n",
"> ఒక రిఫ్రెషర్: పైప్ ఆపరేటర్ (`%>%`) ఒక ఆబ్జెక్టును ఫంక్షన్ లేదా కాల్ ఎక్స్‌ప్రెషన్‌కు ముందుకు పంపడం ద్వారా లాజికల్ క్రమంలో ఆపరేషన్లను నిర్వహిస్తుంది. మీరు పైప్ ఆపరేటర్‌ను మీ కోడ్‌లో \"మరియు తరువాత\" అని చెప్పడం అని భావించవచ్చు.\n"
],
"metadata": {
"id": "REWcIv9yX29v"
}
},
{
"cell_type": "markdown",
"source": [
"## 2. లేని డేటా కోసం తనిఖీ చేయండి\n",
"\n",
"డేటా శాస్త్రవేత్తలు ఎదుర్కొనే అత్యంత సాధారణ సమస్యలలో ఒకటి అసంపూర్ణ లేదా లేని డేటా. R లో లేని లేదా తెలియని విలువలను ప్రత్యేక సెంటినెల్ విలువతో సూచిస్తారు: `NA` (అందుబాటులో లేదు).\n",
"\n",
"కాబట్టి డేటా ఫ్రేమ్ లో లేని విలువలు ఉన్నాయో లేదో ఎలా తెలుసుకోవాలి?\n",
"<br>\n",
"- ఒక సరళమైన విధానం base R ఫంక్షన్ `anyNA` ఉపయోగించడం, ఇది లాజికల్ ఆబ్జెక్టులు `TRUE` లేదా `FALSE` ను తిరిగి ఇస్తుంది.\n"
],
"metadata": {
"id": "Zxfb3AM5YbUe"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"pumpkins %>% \n",
" anyNA()"
],
"outputs": [],
"metadata": {
"id": "G--DQutAYltj"
}
},
{
"cell_type": "markdown",
"source": [
"చాలా బాగుంది, కొంత డేటా లేమి ఉంది అనిపిస్తోంది! అది ప్రారంభించడానికి మంచి స్థలం.\n",
"\n",
"- మరో మార్గం `is.na()` ఫంక్షన్ ఉపయోగించడం, ఇది ఏ వ్యక్తిగత కాలమ్ అంశాలు లేమి ఉన్నాయో లాజికల్ `TRUE` తో సూచిస్తుంది.\n"
],
"metadata": {
"id": "mU-7-SB6YokF"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"pumpkins %>% \n",
" is.na() %>% \n",
" head(n = 7)"
],
"outputs": [],
"metadata": {
"id": "W-DxDOR4YxSW"
}
},
{
"cell_type": "markdown",
"source": [
"సరే, పని పూర్తయింది కానీ ఇలాంటి పెద్ద డేటా ఫ్రేమ్‌తో, ప్రతి వరుస మరియు కాలమ్‌ను వ్యక్తిగతంగా సమీక్షించడం అనర్థకంగా మరియు ప్రాయోగికంగా అసాధ్యం అవుతుంది😴.\n",
"\n",
"- మరింత సులభమైన విధానం ప్రతి కాలమ్ కోసం లేని విలువల మొత్తం లెక్కించడం అవుతుంది:\n"
],
"metadata": {
"id": "xUWxipKYY0o7"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"pumpkins %>% \n",
" is.na() %>% \n",
" colSums()"
],
"outputs": [],
"metadata": {
"id": "ZRBWV6P9ZArL"
}
},
{
"cell_type": "markdown",
"source": [
"ఇంకా బాగుంది! కొంత డేటా మిస్సవుంది, కానీ ఈ పనికి అది పెద్ద సమస్య కాకపోవచ్చు. మరింత విశ్లేషణ ఏమి తెస్తుందో చూద్దాం.\n",
"\n",
"> అద్భుతమైన ప్యాకేజీలు మరియు ఫంక్షన్లతో పాటు, R కి చాలా మంచి డాక్యుమెంటేషన్ ఉంది. ఉదాహరణకు, ఫంక్షన్ గురించి మరింత తెలుసుకోవడానికి `help(colSums)` లేదా `?colSums` ఉపయోగించండి.\n"
],
"metadata": {
"id": "9gv-crB6ZD1Y"
}
},
{
"cell_type": "markdown",
"source": [
"## 3. Dplyr: డేటా మానిప్యులేషన్ యొక్క వ్యాకరణం\n",
"\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/dplyr_wrangling.f5f99c64fd4580f1377fee3ea428b6f8fd073845ec0f8409d483cfe148f0984e.te.png\"\n",
" width=\"569\"/>\n",
" <figcaption>@allison_horst చేత కళాకృతి</figcaption>\n",
"\n",
"\n",
"<!--![Artwork by \\@allison_horst](../../../../../../translated_images/dplyr_wrangling.f5f99c64fd4580f1377fee3ea428b6f8fd073845ec0f8409d483cfe148f0984e.te.png)<br/>Artwork by \\@allison_horst-->\n"
],
"metadata": {
"id": "o4jLY5-VZO2C"
}
},
{
"cell_type": "markdown",
"source": [
"[`dplyr`](https://dplyr.tidyverse.org/), Tidyverseలో ఒక ప్యాకేజ్, డేటా మానిప్యులేషన్ యొక్క వ్యాకరణం, ఇది మీకు సాధారణ డేటా మానిప్యులేషన్ సవాళ్లను పరిష్కరించడంలో సహాయపడే సुसंगతమైన క్రియాపదాల సమితిని అందిస్తుంది. ఈ విభాగంలో, మనం dplyr యొక్క కొన్ని క్రియాపదాలను పరిశీలించబోతున్నాము!\n",
"<br>\n"
],
"metadata": {
"id": "i5o33MQBZWWw"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::select()\n",
"\n",
"`select()` అనేది `dplyr` ప్యాకేజీలో ఉన్న ఒక ఫంక్షన్, ఇది మీరు నిలుపుకోవడానికి లేదా తప్పించుకోవడానికి కాలమ్స్‌ను ఎంచుకోవడంలో సహాయపడుతుంది.\n",
"\n",
"మీ డేటా ఫ్రేమ్‌తో పని చేయడం సులభం చేయడానికి, `select()` ఉపయోగించి దాని కొన్ని కాలమ్స్‌ను తొలగించండి, మీరు అవసరం ఉన్న కాలమ్స్ మాత్రమే నిలుపుకోండి.\n",
"\n",
"ఉదాహరణకు, ఈ వ్యాయామంలో, మా విశ్లేషణలో `Package`, `Low Price`, `High Price` మరియు `Date` కాలమ్స్ ఉంటాయి. ఈ కాలమ్స్‌ను ఎంచుకుందాం.\n"
],
"metadata": {
"id": "x3VGMAGBZiUr"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Select desired columns\n",
"pumpkins <- pumpkins %>% \n",
" select(Package, `Low Price`, `High Price`, Date)\n",
"\n",
"\n",
"# Print data set\n",
"pumpkins %>% \n",
" slice_head(n = 5)"
],
"outputs": [],
"metadata": {
"id": "F_FgxQnVZnM0"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::mutate()\n",
"\n",
"`mutate()` అనేది `dplyr` ప్యాకేజీలో ఒక ఫంక్షన్, ఇది మీరు ఉన్న కాలమ్స్‌ను ఉంచుతూ కొత్త కాలమ్స్‌ను సృష్టించడానికి లేదా మార్చడానికి సహాయపడుతుంది.\n",
"\n",
"mutate యొక్క సాధారణ నిర్మాణం:\n",
"\n",
"`data %>% mutate(new_column_name = what_it_contains)`\n",
"\n",
"`Date` కాలమ్‌ను ఉపయోగించి క్రింది ఆపరేషన్లను చేయడం ద్వారా `mutate` ను ప్రయత్నిద్దాం:\n",
"\n",
"1. తేదీలను (ప్రస్తుతం character రకం) నెల ఫార్మాట్‌కు మార్చండి (ఇవి US తేదీలు, కాబట్టి ఫార్మాట్ `MM/DD/YYYY`).\n",
"\n",
"2. తేదీల నుండి నెలను కొత్త కాలమ్‌గా తీసుకోండి.\n",
"\n",
"R లో, [lubridate](https://lubridate.tidyverse.org/) ప్యాకేజీ Date-time డేటాతో పని చేయడం సులభతరం చేస్తుంది. కాబట్టి, `dplyr::mutate()`, `lubridate::mdy()`, `lubridate::month()` ఉపయోగించి పై లక్ష్యాలను ఎలా సాధించాలో చూద్దాం. తరువాతి ఆపరేషన్లలో మళ్లీ అవసరం లేకపోవడంతో Date కాలమ్‌ను తీసివేయవచ్చు.\n"
],
"metadata": {
"id": "2KKo0Ed9Z1VB"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Load lubridate\n",
"library(lubridate)\n",
"\n",
"pumpkins <- pumpkins %>% \n",
" # Convert the Date column to a date object\n",
" mutate(Date = mdy(Date)) %>% \n",
" # Extract month from Date\n",
" mutate(Month = month(Date)) %>% \n",
" # Drop Date column\n",
" select(-Date)\n",
"\n",
"# View the first few rows\n",
"pumpkins %>% \n",
" slice_head(n = 7)"
],
"outputs": [],
"metadata": {
"id": "5joszIVSZ6xe"
}
},
{
"cell_type": "markdown",
"source": [
"వాహ్! 🤩\n",
"\n",
"తర్వాత, మనం కొత్త కాలమ్ `Price` ను సృష్టిద్దాం, ఇది ఒక పంప్కిన్ యొక్క సగటు ధరను సూచిస్తుంది. ఇప్పుడు, కొత్త Price కాలమ్‌ను నింపడానికి `Low Price` మరియు `High Price` కాలమ్‌ల సగటును తీసుకుందాం.\n",
"<br>\n"
],
"metadata": {
"id": "nIgLjNMCZ-6Y"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Create a new column Price\n",
"pumpkins <- pumpkins %>% \n",
" mutate(Price = (`Low Price` + `High Price`)/2)\n",
"\n",
"# View the first few rows of the data\n",
"pumpkins %>% \n",
" slice_head(n = 5)"
],
"outputs": [],
"metadata": {
"id": "Zo0BsqqtaJw2"
}
},
{
"cell_type": "markdown",
"source": [
"యీస్!💪\n",
"\n",
"\"కానీ వేచి ఉండండి!\", మీరు `View(pumpkins)` తో మొత్తం డేటా సెట్‌ను స్కిమ్ చేసిన తర్వాత చెప్పగలరు, \"ఇక్కడ ఏదో విచిత్రం ఉంది!\"🤔\n",
"\n",
"మీరు `Package` కాలమ్‌ను చూస్తే, పంప్కిన్లు అనేక వేర్వేరు ఆకృతుల్లో అమ్మబడుతున్నాయి. కొన్ని `1 1/9 బుషెల్` కొలతలలో, కొన్ని `1/2 బుషెల్` కొలతలలో, కొన్ని ఒక్కో పంప్కిన్‌కు, కొన్ని పౌండ్‌కు, మరియు కొన్ని విభిన్న వెడల్పుల పెద్ద బాక్స్‌లలో అమ్మబడుతున్నాయి.\n",
"\n",
"దీనిని నిర్ధారిద్దాం:\n"
],
"metadata": {
"id": "p77WZr-9aQAR"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Verify the distinct observations in Package column\n",
"pumpkins %>% \n",
" distinct(Package)"
],
"outputs": [],
"metadata": {
"id": "XISGfh0IaUy6"
}
},
{
"cell_type": "markdown",
"source": [
"అద్భుతం!👏\n",
"\n",
"పంప్కిన్లు సతతంగా తూగడం చాలా కష్టం అనిపిస్తోంది, కాబట్టి `Package` కాలమ్‌లో *bushel* అనే స్ట్రింగ్ ఉన్న పంప్కిన్లను మాత్రమే ఎంచుకుని వాటిని కొత్త డేటా ఫ్రేమ్ `new_pumpkins` లో ఉంచుదాం.\n",
"<br>\n"
],
"metadata": {
"id": "7sMjiVujaZxY"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::filter() మరియు stringr::str_detect()\n",
"\n",
"[`dplyr::filter()`](https://dplyr.tidyverse.org/reference/filter.html): మీ షరతులను తీరుస్తున్న **పంక్తులు** మాత్రమే కలిగిన డేటా ఉపసెట్‌ను సృష్టిస్తుంది, ఈ సందర్భంలో, `Package` కాలమ్‌లో *bushel* స్ట్రింగ్ ఉన్న పంప్కిన్లు.\n",
"\n",
"[stringr::str_detect()](https://stringr.tidyverse.org/reference/str_detect.html): స్ట్రింగ్‌లో ఒక నమూనా ఉన్నదో లేదో గుర్తిస్తుంది.\n",
"\n",
"[`stringr`](https://github.com/tidyverse/stringr) ప్యాకేజ్ సాధారణ స్ట్రింగ్ ఆపరేషన్ల కోసం సులభమైన ఫంక్షన్లను అందిస్తుంది.\n"
],
"metadata": {
"id": "L8Qfcs92ageF"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Retain only pumpkins with \"bushel\"\n",
"new_pumpkins <- pumpkins %>% \n",
" filter(str_detect(Package, \"bushel\"))\n",
"\n",
"# Get the dimensions of the new data\n",
"dim(new_pumpkins)\n",
"\n",
"# View a few rows of the new data\n",
"new_pumpkins %>% \n",
" slice_head(n = 5)"
],
"outputs": [],
"metadata": {
"id": "hy_SGYREampd"
}
},
{
"cell_type": "markdown",
"source": [
"మీరు చూడవచ్చు మనం సుమారు 415 వరుసల డేటా వరకు తగ్గించుకున్నాము, వాటిలో బషెల్ ద్వారా పంప్కిన్లు ఉన్నాయి.🤩\n",
"<br>\n"
],
"metadata": {
"id": "VrDwF031avlR"
}
},
{
"cell_type": "markdown",
"source": [
"#### dplyr::case_when()\n",
"\n",
"**కానీ వేచి ఉండండి! ఇంకా ఒక విషయం చేయాల్సి ఉంది**\n",
"\n",
"మీరు గమనించారా, బషెల్ పరిమాణం ప్రతి వరుసకు మారుతుంది? మీరు ధరలను సాధారణీకరించాలి, అంటే 1 1/9 లేదా 1/2 బషెల్‌కు కాకుండా ప్రతి బషెల్‌కు ధర చూపించాలి. దీని కోసం కొంత గణితం చేయాల్సి ఉంది.\n",
"\n",
"మనం కొన్ని షరతుల ఆధారంగా Price కాలమ్‌ను *mutate* చేయడానికి [`case_when()`](https://dplyr.tidyverse.org/reference/case_when.html) ఫంక్షన్‌ను ఉపయోగిస్తాము. `case_when` అనేది అనేక `if_else()` స్టేట్మెంట్లను వెక్టరైజ్ చేయడానికి అనుమతిస్తుంది.\n"
],
"metadata": {
"id": "mLpw2jH4a0tx"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Convert the price if the Package contains fractional bushel values\n",
"new_pumpkins <- new_pumpkins %>% \n",
" mutate(Price = case_when(\n",
" str_detect(Package, \"1 1/9\") ~ Price/(1 + 1/9),\n",
" str_detect(Package, \"1/2\") ~ Price/(1/2),\n",
" TRUE ~ Price))\n",
"\n",
"# View the first few rows of the data\n",
"new_pumpkins %>% \n",
" slice_head(n = 30)"
],
"outputs": [],
"metadata": {
"id": "P68kLVQmbM6I"
}
},
{
"cell_type": "markdown",
"source": [
"ఇప్పుడు, మనం వారి బషెల్ కొలత ఆధారంగా యూనిట్ ధరను విశ్లేషించవచ్చు. అయితే, పంప్కిన్ బషెల్లపై ఈ మొత్తం అధ్యయనం మీ డేటా స్వభావాన్ని `అర్థం చేసుకోవడం` ఎంత `ముఖ్యమైనది` అనేది చూపిస్తుంది!\n",
"\n",
"> ✅ [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308) ప్రకారం, బషెల్ బరువు ఉత్పత్తి రకంపై ఆధారపడి ఉంటుంది, ఎందుకంటే ఇది పరిమాణ కొలత. \"ఉదాహరణకు, టమోటాల బషెల్ బరువు 56 పౌండ్లు ఉండాలి... ఆకులు మరియు ఆకుకూరలు తక్కువ బరువుతో ఎక్కువ స్థలం తీసుకుంటాయి, కాబట్టి పాలకూర బషెల్ బరువు కేవలం 20 పౌండ్లు.\" ఇది అంతా చాలా క్లిష్టమైనది! బషెల్-టు-పౌండ్ మార్పిడి చేయకుండా, బషెల్ ప్రకారం ధర నిర్ణయిద్దాం. అయితే, పంప్కిన్ బషెల్లపై ఈ మొత్తం అధ్యయనం మీ డేటా స్వభావాన్ని అర్థం చేసుకోవడం ఎంత ముఖ్యమైనదో చూపిస్తుంది!\n",
">\n",
"> ✅ మీరు గమనించారా, సగం బషెల్ ద్వారా అమ్మే పంప్కిన్లు చాలా ఖరీదైనవి? మీరు ఎందుకు అనుకుంటున్నారా? సూచన: చిన్న పంప్కిన్లు పెద్దవాటికంటే చాలా ఎక్కువ ధర కలిగి ఉంటాయి, ఎందుకంటే ఒక పెద్ద గుండ్రటి పాయ్ పంప్కిన్ తీసుకునే ఉపయోగించని స్థలం కారణంగా, బషెల్‌కు చాలా ఎక్కువ చిన్న పంప్కిన్లు ఉంటాయి.\n",
"<br>\n"
],
"metadata": {
"id": "pS2GNPagbSdb"
}
},
{
"cell_type": "markdown",
"source": [
"ఇప్పుడు చివరగా, సాహసోపేతంగా 💁‍♀️, మనం Month కాలమ్‌ను మొదటి స్థానానికి కూడా మార్చుకుందాం అంటే `Package` కాలమ్ `ముందు`.\n",
"\n",
"కాలమ్ స్థానాలను మార్చడానికి `dplyr::relocate()` ఉపయోగిస్తారు.\n"
],
"metadata": {
"id": "qql1SowfbdnP"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Create a new data frame new_pumpkins\n",
"new_pumpkins <- new_pumpkins %>% \n",
" relocate(Month, .before = Package)\n",
"\n",
"new_pumpkins %>% \n",
" slice_head(n = 7)"
],
"outputs": [],
"metadata": {
"id": "JJ1x6kw8bixF"
}
},
{
"cell_type": "markdown",
"source": [
"చాలా బాగుంది!👌 ఇప్పుడు మీకు ఒక శుభ్రమైన, క్రమబద్ధమైన డేటాసెట్ ఉంది, దానిపై మీరు మీ కొత్త రిగ్రెషన్ మోడల్‌ను నిర్మించవచ్చు!\n",
"<br>\n"
],
"metadata": {
"id": "y8TJ0Za_bn5Y"
}
},
{
"cell_type": "markdown",
"source": [
"## 4. ggplot2 తో డేటా విజువలైజేషన్\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/data-visualization.54e56dded7c1a804d00d027543f2881cb32da73aeadda2d4a4f10f3497526114.te.png\"\n",
" width=\"600\"/>\n",
" <figcaption>ఇన్ఫోగ్రాఫిక్ - దసాని మడిపల్లి</figcaption>\n",
"\n",
"\n",
"<!--![Infographic by Dasani Madipalli](../../../../../../translated_images/data-visualization.54e56dded7c1a804d00d027543f2881cb32da73aeadda2d4a4f10f3497526114.te.png){width=\"600\"}-->\n",
"\n",
"ఇలా ఒక *జ్ఞానవంతమైన* మాట ఉంది:\n",
"\n",
"> \"సాధారణ గ్రాఫ్ డేటా విశ్లేషకుడి మనసుకు ఇతర ఏ పరికరం కంటే ఎక్కువ సమాచారం తీసుకొచ్చింది.\" --- జాన్ టుకీ\n",
"\n",
"డేటా సైంటిస్ట్ పాత్రలో ఒక భాగం వారు పని చేస్తున్న డేటా యొక్క నాణ్యత మరియు స్వభావాన్ని ప్రదర్శించడం. దీని కోసం, వారు తరచుగా ఆసక్తికరమైన విజువలైజేషన్లు, లేదా ప్లాట్లు, గ్రాఫ్లు, మరియు చార్ట్లు సృష్టిస్తారు, డేటా యొక్క వివిధ కోణాలను చూపిస్తూ. ఈ విధంగా, వారు بصریంగా సంబంధాలు మరియు గ్యాప్స్ చూపగలుగుతారు, ఇవి లేకపోతే కనుగొనడం కష్టం.\n",
"\n",
"విజువలైజేషన్లు డేటాకు అత్యంత అనుకూలమైన మెషీన్ లెర్నింగ్ సాంకేతికతను నిర్ణయించడంలో కూడా సహాయపడతాయి. ఉదాహరణకు, ఒక స్కాటర్‌ప్లాట్ ఒక రేఖను అనుసరిస్తున్నట్లు కనిపిస్తే, ఆ డేటా లీనియర్ రిగ్రెషన్ వ్యాయామానికి మంచి అభ్యర్థిగా ఉంటుంది.\n",
"\n",
"R అనేక గ్రాఫ్ తయారీ వ్యవస్థలను అందిస్తుంది, కానీ [`ggplot2`](https://ggplot2.tidyverse.org/index.html) అత్యంత అందమైన మరియు బహుముఖమైన వాటిలో ఒకటి. `ggplot2` మీరు **స్వతంత్ర భాగాలను కలిపి** గ్రాఫ్‌లను రూపొందించడానికి అనుమతిస్తుంది.\n",
"\n",
"Price మరియు Month కాలమ్స్ కోసం ఒక సాదా స్కాటర్ ప్లాట్ తో ప్రారంభిద్దాం.\n",
"\n",
"కాబట్టి ఈ సందర్భంలో, మేము [`ggplot()`](https://ggplot2.tidyverse.org/reference/ggplot.html) తో ప్రారంభించి, ఒక డేటాసెట్ మరియు ఎస్తెటిక్స్ మ్యాపింగ్ ( [`aes()`](https://ggplot2.tidyverse.org/reference/aes.html) తో) అందించి, తరువాత స్కాటర్ ప్లాట్ల కోసం [`geom_point()`](https://ggplot2.tidyverse.org/reference/geom_point.html) వంటి లేయర్లు జోడిస్తాము.\n"
],
"metadata": {
"id": "mYSH6-EtbvNa"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Set a theme for the plots\n",
"theme_set(theme_light())\n",
"\n",
"# Create a scatter plot\n",
"p <- ggplot(data = new_pumpkins, aes(x = Price, y = Month))\n",
"p + geom_point()"
],
"outputs": [],
"metadata": {
"id": "g2YjnGeOcLo4"
}
},
{
"cell_type": "markdown",
"source": [
"ఇది ఉపయోగకరమైన ప్లాట్ కాదా 🤷? దీని గురించి ఏదైనా ఆశ్చర్యంగా ఉందా?\n",
"\n",
"ఇది ప్రత్యేకంగా ఉపయోగకరం కాదు ఎందుకంటే ఇది మీ డేటాను ఒక నిర్దిష్ట నెలలో పాయింట్ల విస్తరణగా మాత్రమే ప్రదర్శిస్తుంది.\n",
"<br>\n"
],
"metadata": {
"id": "Ml7SDCLQcPvE"
}
},
{
"cell_type": "markdown",
"source": [
"### **మనం దీన్ని ఉపయోగకరంగా ఎలా చేస్తాము?**\n",
"\n",
"చార్ట్లు ఉపయోగకరమైన డేటాను ప్రదర్శించడానికి, మీరు సాధారణంగా డేటాను ఏదో విధంగా సమూహీకరించాలి. ఉదాహరణకు, మన కేసులో, ప్రతి నెలకు గుమ్మడికాయల సగటు ధరను కనుగొనడం మన డేటాలోని అంతర్గత నమూనాలపై మరింత అవగాహనను అందిస్తుంది. ఇది మాకు మరొక **dplyr** ఫ్లైబైకి దారితీస్తుంది:\n",
"\n",
"#### `dplyr::group_by() %>% summarize()`\n",
"\n",
"R లో సమూహీకృత సమ్మేళనం సులభంగా లెక్కించవచ్చు\n",
"\n",
"`dplyr::group_by() %>% summarize()`\n",
"\n",
"- `dplyr::group_by()` విశ్లేషణ యూనిట్‌ను పూర్తి డేటాసెట్ నుండి వ్యక్తిగత సమూహాలకు మార్చుతుంది, ఉదాహరణకు ప్రతి నెలకు.\n",
"\n",
"- `dplyr::summarize()` మీరు పేర్కొన్న సమ్మరీ గణాంకాల కోసం ప్రతి సమూహీకరణ వేరియబుల్‌కు ఒక కాలమ్ మరియు ఒక కొత్త డేటా ఫ్రేమ్‌ను సృష్టిస్తుంది.\n",
"\n",
"ఉదాహరణకు, మనం `dplyr::group_by() %>% summarize()` ను ఉపయోగించి గుమ్మడికాయలను **Month** కాలమ్ ఆధారంగా సమూహాలుగా విభజించి, ప్రతి నెలకు **సగటు ధర** కనుగొనవచ్చు.\n"
],
"metadata": {
"id": "jMakvJZIcVkh"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Find the average price of pumpkins per month\r\n",
"new_pumpkins %>%\r\n",
" group_by(Month) %>% \r\n",
" summarise(mean_price = mean(Price))"
],
"outputs": [],
"metadata": {
"id": "6kVSUa2Bcilf"
}
},
{
"cell_type": "markdown",
"source": [
"సంక్షిప్తంగా!✨\n",
"\n",
"నెలల వంటి వర్గీకరణ లక్షణాలను బార్ ప్లాట్ 📊 ఉపయోగించి మెరుగ్గా ప్రదర్శించవచ్చు. బార్ చార్ట్స్ కోసం బాధ్యత వహించే లేయర్లు `geom_bar()` మరియు `geom_col()` ఉన్నాయి. మరింత తెలుసుకోవడానికి `?geom_bar` ను చూడండి.\n",
"\n",
"ఒకటి తయారు చేద్దాం!\n"
],
"metadata": {
"id": "Kds48GUBcj3W"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Find the average price of pumpkins per month then plot a bar chart\r\n",
"new_pumpkins %>%\r\n",
" group_by(Month) %>% \r\n",
" summarise(mean_price = mean(Price)) %>% \r\n",
" ggplot(aes(x = Month, y = mean_price)) +\r\n",
" geom_col(fill = \"midnightblue\", alpha = 0.7) +\r\n",
" ylab(\"Pumpkin Price\")"
],
"outputs": [],
"metadata": {
"id": "VNbU1S3BcrxO"
}
},
{
"cell_type": "markdown",
"source": [
"🤩🤩 ఇది మరింత ఉపయోగకరమైన డేటా విజువలైజేషన్! ఇది సప్టెంబర్ మరియు అక్టోబర్ నెలల్లో గుమ్మడికాయల ధర అత్యధికంగా ఉంటుందని సూచిస్తున్నట్లు కనిపిస్తోంది. ఇది మీ అంచనాకు సరిపోతుందా? ఎందుకు లేదా ఎందుకు కాదు?\n",
"\n",
"రెండవ పాఠం పూర్తి చేసినందుకు అభినందనలు 👏! మీరు మీ డేటాను మోడల్ నిర్మాణానికి సిద్ధం చేసారు, ఆపై విజువలైజేషన్ల ద్వారా మరిన్ని అవగాహనలను కనుగొన్నారు!\n"
],
"metadata": {
"id": "zDm0VOzzcuzR"
}
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

439
translations/te/2-Regression/2-Data/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

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

@ -0,0 +1,383 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "40e64f004f3cb50aa1d8661672d3cd92",
"translation_date": "2025-12-19T13:45:41+00:00",
"source_file": "2-Regression/3-Linear/README.md",
"language_code": "te"
}
-->
# Scikit-learn ఉపయోగించి రిగ్రెషన్ మోడల్ నిర్మించండి: రిగ్రెషన్ నాలుగు విధానాలు
![లీనియర్ vs పాలినోమియల్ రిగ్రెషన్ ఇన్ఫోగ్రాఫిక్](../../../../translated_images/linear-polynomial.5523c7cb6576ccab0fecbd0e3505986eb2d191d9378e785f82befcf3a578a6e7.te.png)
> ఇన్ఫోగ్రాఫిక్ [దాసాని మడిపల్లి](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")
> 🎥 లీనియర్ రిగ్రెషన్ యొక్క సంక్షిప్త వీడియో అవలోకనానికి పై చిత్రం క్లిక్ చేయండి.
> ఈ పాఠ్యాంశం మొత్తం, మేము గణితంపై కనీస జ్ఞానం ఉన్నట్లు భావించి, ఇతర రంగాల నుండి వచ్చిన విద్యార్థులకు సులభంగా అర్థమయ్యేలా చేయడానికి ప్రయత్నిస్తాము, కాబట్టి గమనికలు, 🧮 కాల్ అవుట్లు, చిత్రాలు మరియు ఇతర అభ్యాస సాధనాలను గమనించండి.
### ముందస్తు అవగాహన
మీకు ఇప్పటివరకు పరిశీలిస్తున్న పంప్కిన్ డేటా నిర్మాణం గురించి పరిచయం కలిగి ఉండాలి. మీరు ఈ పాఠం యొక్క _notebook.ipynb_ ఫైల్‌లో ముందుగా లోడ్ చేసి శుభ్రపరిచిన డేటాను కనుగొనవచ్చు. ఆ ఫైల్‌లో, పంప్కిన్ ధర బషెల్‌కు ప్రదర్శించబడుతుంది. మీరు Visual Studio Code లో కర్నెల్స్‌లో ఈ నోట్‌బుక్స్ నడపగలగాలి.
### సిద్ధం కావడం
మరలా గుర్తు చేసుకోవడానికి, మీరు ఈ డేటాను లోడ్ చేస్తున్నారంటే దానిపై ప్రశ్నలు అడగడానికి.
- పంప్కిన్లను కొనుగోలు చేయడానికి ఉత్తమ సమయం ఎప్పుడు?
- మినీ పంప్కిన్ల కేసు ధర ఎంత ఉండవచ్చు?
- వాటిని అర్ధ బషెల్ బాస్కెట్లలో కొనాలా లేదా 1 1/9 బషెల్ బాక్స్ ద్వారా కొనాలా?
మనం ఈ డేటాలో మరింత లోతుగా వెళ్దాం.
మునుపటి పాఠంలో, మీరు Pandas డేటా ఫ్రేమ్ సృష్టించి, అసలు డేటాసెట్‌లోని భాగాన్ని బషెల్ ద్వారా ధరను ప్రమాణీకరించి నింపారు. అయితే, మీరు సుమారు 400 డేటాపాయింట్లు మాత్రమే సేకరించగలిగారు మరియు అవి కేవలం శరదృతువు నెలల కోసం మాత్రమే.
ఈ పాఠం యొక్క సహాయక నోట్‌బుక్‌లో ముందుగా లోడ్ చేసిన డేటాను చూడండి. డేటా ముందుగా లోడ్ చేయబడింది మరియు నెల డేటాను చూపించడానికి ప్రారంభ స్కాటర్‌ప్లాట్ రూపొందించబడింది. డేటా స్వభావం గురించి మరింత వివరాలు తెలుసుకోవడానికి మరింత శుభ్రపరచడం చేయవచ్చు.
## లీనియర్ రిగ్రెషన్ లైన్
పాఠం 1 లో మీరు నేర్చుకున్నట్లుగా, లీనియర్ రిగ్రెషన్ వ్యాయామం యొక్క లక్ష్యం ఒక లైన్‌ను ప్లాట్ చేయగలగడం:
- **వేరియబుల్ సంబంధాలను చూపించండి**. వేరియబుల్స్ మధ్య సంబంధాన్ని చూపించండి
- **అంచనాలు చేయండి**. కొత్త డేటాపాయింట్ ఆ లైన్‌కు సంబంధించి ఎక్కడ పడుతుందో ఖచ్చితంగా అంచనా వేయండి.
**లీస్ట్-స్క్వేర్ రిగ్రెషన్**లో ఈ రకమైన లైన్ డ్రా చేయడం సాధారణం. 'లీస్ట్-స్క్వేర్' అనే పదం అంటే రిగ్రెషన్ లైన్ చుట్టూ ఉన్న అన్ని డేటాపాయింట్లు స్క్వేర్ చేసి, వాటిని జోడించడం. ఆ తుది మొత్తం సాధ్యమైనంత తక్కువగా ఉండాలి, ఎందుకంటే మేము తప్పుల సంఖ్యను తక్కువగా ఉంచాలనుకుంటున్నాము, అంటే `లీస్ట్-స్క్వేర్`.
మేము ఈ విధంగా చేస్తాము ఎందుకంటే మేము మా డేటా పాయింట్లన్నింటి నుండి కనీస సమ్మిళిత దూరం కలిగిన లైన్‌ను మోడల్ చేయాలనుకుంటున్నాము. దిశ కాకుండా పరిమాణం గురించి ఆందోళన కలిగినందున, జోడించే ముందు పదాలను స్క్వేర్ చేస్తాము.
> **🧮 గణితం చూపించండి**
>
> ఈ లైన్, _లైన్ ఆఫ్ బెస్ట్ ఫిట్_ అని పిలవబడుతుంది, [సమీకరణ](https://en.wikipedia.org/wiki/Simple_linear_regression) ద్వారా వ్యక్తం చేయవచ్చు:
>
> ```
> Y = a + bX
> ```
>
> `X` అనేది 'వివరణాత్మక వేరియబుల్'. `Y` అనేది 'ఆధారిత వేరియబుల్'. లైన్ యొక్క స్లోప్ `b` మరియు `a` y-ఇంటర్సెప్ట్, అంటే `X = 0` ఉన్నప్పుడు `Y` విలువ.
>
>![స్లోప్ లెక్కించండి](../../../../translated_images/slope.f3c9d5910ddbfcf9096eb5564254ba22c9a32d7acd7694cab905d29ad8261db3.te.png)
>
> మొదట, స్లోప్ `b` లెక్కించండి. ఇన్ఫోగ్రాఫిక్ [జెన్ లూపర్](https://twitter.com/jenlooper) ద్వారా
>
> మరొక మాటలో చెప్పాలంటే, మా పంప్కిన్ డేటా యొక్క అసలు ప్రశ్నకు సంబంధించి: "నెల వారీగా పంప్కిన్ ధర అంచనా వేయండి", `X` ధరకు సూచిస్తుంది మరియు `Y` అమ్మకాల నెలకు సూచిస్తుంది.
>
>![సమీకరణ పూర్తి చేయండి](../../../../translated_images/calculation.a209813050a1ddb141cdc4bc56f3af31e67157ed499e16a2ecf9837542704c94.te.png)
>
> Y విలువ లెక్కించండి. మీరు సుమారు $4 చెల్లిస్తుంటే, అది ఏప్రిల్ కావాలి! ఇన్ఫోగ్రాఫిక్ [జెన్ లూపర్](https://twitter.com/jenlooper) ద్వారా
>
> లైన్ లెక్కించే గణితం స్లోప్‌ను చూపించాలి, ఇది ఇంటర్సెప్ట్‌పై ఆధారపడి ఉంటుంది, అంటే `X = 0` ఉన్నప్పుడు `Y` ఎక్కడ ఉంటుంది.
>
> ఈ విలువల లెక్కింపు పద్ధతిని మీరు [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 మధ్య ఎక్కడైనా పడ్డ స్కాటర్‌ప్లాట్‌కు తక్కువ సహసంబంధం ఉంటుంది.
మంచి లీనియర్ రిగ్రెషన్ మోడల్ అనేది లీస్ట్-స్క్వేర్ రిగ్రెషన్ పద్ధతితో రిగ్రెషన్ లైన్ ఉన్నప్పుడు 1 కి దగ్గరగా ఉన్న (0 కంటే ఎక్కువ) సహసంబంధ గుణకం కలిగి ఉంటుంది.
✅ ఈ పాఠం సహాయక నోట్‌బుక్ నడపండి మరియు నెల నుండి ధర స్కాటర్‌ప్లాట్ చూడండి. పంప్కిన్ అమ్మకాల కోసం నెల మరియు ధర మధ్య డేటా మీ విజువల్ అర్థం ప్రకారం అధిక లేదా తక్కువ సహసంబంధం ఉందా? మీరు `నెల` బదులు మరింత సూక్ష్మమైన కొలత ఉపయోగిస్తే, ఉదాహరణకు *సంవత్సరంలో రోజు* (అంటే సంవత్సర ప్రారంభం నుండి గడిచిన రోజుల సంఖ్య), అది మారుతుందా?
క్రింది కోడ్‌లో, మేము డేటాను శుభ్రపరిచినట్లు భావిస్తాము, మరియు `new_pumpkins` అనే డేటా ఫ్రేమ్ పొందాము, ఇది ఈ క్రింది విధంగా ఉంటుంది:
ID | నెల | సంవత్సరం లో రోజు | రకం | నగరం | ప్యాకేజీ | తక్కువ ధర | ఎక్కువ ధర | ధర
---|-------|-----------|---------|------|---------|-----------|------------|-------
70 | 9 | 267 | పై టైప్ | బాల్టిమోర్ | 1 1/9 బషెల్ కార్టన్లు | 15.0 | 15.0 | 13.636364
71 | 9 | 267 | పై టైప్ | బాల్టిమోర్ | 1 1/9 బషెల్ కార్టన్లు | 18.0 | 18.0 | 16.363636
72 | 10 | 274 | పై టైప్ | బాల్టిమోర్ | 1 1/9 బషెల్ కార్టన్లు | 18.0 | 18.0 | 16.363636
73 | 10 | 274 | పై టైప్ | బాల్టిమోర్ | 1 1/9 బషెల్ కార్టన్లు | 17.0 | 17.0 | 15.454545
74 | 10 | 281 | పై టైప్ | బాల్టిమోర్ | 1 1/9 బషెల్ కార్టన్లు | 15.0 | 15.0 | 13.636364
> డేటాను శుభ్రపరచడానికి కోడ్ [`notebook.ipynb`](notebook.ipynb) లో అందుబాటులో ఉంది. మేము మునుపటి పాఠంలో చేసిన శుభ్రపరిచే దశలను అమలు చేసాము, మరియు `DayOfYear` కాలమ్‌ను క్రింది వ్యక్తీకరణతో లెక్కించాము:
```python
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")
> 🎥 సహసంబంధం యొక్క సంక్షిప్త వీడియో అవలోకనానికి పై చిత్రం క్లిక్ చేయండి.
మునుపటి పాఠం నుండి మీరు చూసినట్లయితే, వివిధ నెలల సగటు ధర ఇలా ఉంటుంది:
<img alt="నెల వారీ సగటు ధర" src="../../../../translated_images/barchart.a833ea9194346d769c77a3a870f7d8aee51574cd1138ca902e5500830a41cbce.te.png" width="50%"/>
ఇది కొంత సహసంబంధం ఉండాలని సూచిస్తుంది, మరియు మేము `నెల` మరియు `ధర` మధ్య లేదా `DayOfYear` మరియు `ధర` మధ్య సంబంధాన్ని అంచనా వేయడానికి లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణ ఇవ్వవచ్చు. క్రింది స్కాటర్ ప్లాట్ ఆ తర్వాత సంబంధాన్ని చూపిస్తుంది:
<img alt="ధర vs. సంవత్సరం లో రోజు స్కాటర్ ప్లాట్" src="../../../../translated_images/scatter-dayofyear.bc171c189c9fd553fe93030180b9c00ed123148a577640e4d7481c4c01811972.te.png" width="50%" />
`corr` ఫంక్షన్ ఉపయోగించి సహసంబంధం ఉందా చూద్దాం:
```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
సహసంబంధం చాలా తక్కువగా ఉంది, `నెల` ద్వారా -0.15 మరియు `DayOfMonth` ద్వారా -0.17, కానీ మరో ముఖ్యమైన సంబంధం ఉండవచ్చు. వివిధ పంప్కిన్ రకాల ధరల వేర్వేరు క్లస్టర్లు ఉన్నట్లు కనిపిస్తోంది. ఈ హైపోథసిస్ నిర్ధారించడానికి, ప్రతి పంప్కిన్ వర్గాన్ని వేరే రంగుతో ప్లాట్ చేద్దాం. `scatter` ప్లాటింగ్ ఫంక్షన్‌కు `ax` పారామీటర్ ఇవ్వడం ద్వారా అన్ని పాయింట్లను ఒకే గ్రాఫ్‌లో ప్లాట్ చేయవచ్చు:
```python
ax=None
colors = ['red','blue','green','yellow']
for i,var in enumerate(new_pumpkins['Variety'].unique()):
df = new_pumpkins[new_pumpkins['Variety']==var]
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
```
<img alt="ధర vs. సంవత్సరం లో రోజు రంగు స్కాటర్ ప్లాట్" src="../../../../translated_images/scatter-dayofyear-color.65790faefbb9d54fb8f6223c566c445b9fac58a1c15f41f8641c3842af9d548b.te.png" width="50%" />
మా పరిశీలన ప్రకారం, రకం అమ్మకాల తేదీ కంటే మొత్తం ధరపై ఎక్కువ ప్రభావం చూపుతుంది. దీన్ని బార్ గ్రాఫ్‌తో చూడవచ్చు:
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
<img alt="ధర vs రకం బార్ గ్రాఫ్" src="../../../../translated_images/price-by-variety.744a2f9925d9bcb43a9a8c69469ce2520c9524fabfa270b1b2422cc2450d6d11.te.png" width="50%" />
ఇప్పుడు మనం కేవలం ఒక పంప్కిన్ రకం, 'పై టైప్' పై దృష్టి పెట్టి, తేదీ ధరపై ఎలాంటి ప్రభావం చూపుతుందో చూద్దాం:
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price')
```
<img alt="ధర vs. సంవత్సరం లో రోజు స్కాటర్ ప్లాట్" src="../../../../translated_images/pie-pumpkins-scatter.d14f9804a53f927e7fe39aa072486f4ed1bdd7f31c8bb08f476855f4b02350c3.te.png" width="50%" />
ఇప్పుడు `corr` ఫంక్షన్ ఉపయోగించి `ధర` మరియు `DayOfYear` మధ్య సహసంబంధం లెక్కిస్తే, సుమారు `-0.27` వస్తుంది - అంటే అంచనా వేయగల మోడల్ శిక్షణ ఇవ్వడం అర్థం.
> లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణకు ముందు, మా డేటా శుభ్రంగా ఉందని నిర్ధారించుకోవడం ముఖ్యం. లీనియర్ రిగ్రెషన్ లో మిస్సింగ్ విలువలతో పని చేయడం సరిగా ఉండదు, కాబట్టి అన్ని ఖాళీ సెల్స్ తొలగించడం మంచిది:
```python
pie_pumpkins.dropna(inplace=True)
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")
> 🎥 లీనియర్ మరియు పాలినోమియల్ రిగ్రెషన్ యొక్క సంక్షిప్త వీడియో అవలోకనానికి పై చిత్రం క్లిక్ చేయండి.
మా లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణకు, మేము **Scikit-learn** లైబ్రరీని ఉపయోగిస్తాము.
```python
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
మేము మొదట ఇన్‌పుట్ విలువలు (ఫీచర్లు) మరియు అంచనా వేయాల్సిన అవుట్‌పుట్ (లేబుల్) ను వేర్వేరు numpy అర్రేలలో విడగొడతాము:
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> గమనించండి, లీనియర్ రిగ్రెషన్ ప్యాకేజీ సరిగ్గా అర్థం చేసుకోవడానికి ఇన్‌పుట్ డేటాపై `reshape` చేయాల్సి వచ్చింది. లీనియర్ రిగ్రెషన్ 2D-అర్రేను ఇన్‌పుట్‌గా ఆశిస్తుంది, ఇందులో ప్రతి వరుస ఒక ఫీచర్ వెక్టర్‌కు సరిపోతుంది. మన కేసులో, ఒక్క ఇన్‌పుట్ ఉన్నందున, N×1 ఆకారంలో అర్రే కావాలి, ఇక్కడ N డేటాసెట్ పరిమాణం.
తర్వాత, మేము డేటాను శిక్షణ మరియు పరీక్ష డేటాసెట్‌లుగా విభజించాలి, తద్వారా శిక్షణ తర్వాత మోడల్‌ను ధృవీకరించవచ్చు:
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
చివరగా, లీనియర్ రిగ్రెషన్ మోడల్ శిక్షణ రెండు కోడ్ లైన్లలోనే జరుగుతుంది. మేము `LinearRegression` ఆబ్జెక్ట్‌ను నిర్వచించి, `fit` మెథడ్ ఉపయోగించి మా డేటాకు అనుగుణంగా చేస్తాము:
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
`fit` చేసిన తర్వాత `LinearRegression` ఆబ్జెక్ట్‌లో రిగ్రెషన్ యొక్క అన్ని కోఎఫిషియెంట్లు ఉంటాయి, వాటిని `.coef_` ప్రాపర్టీ ద్వారా యాక్సెస్ చేయవచ్చు. మన కేసులో, ఒక్క కోఎఫిషియెంట్ ఉంటుంది, అది సుమారు `-0.017` ఉంటుంది. అంటే ధరలు కాలంతో కొంత తగ్గుతున్నట్లు కనిపిస్తుంది, రోజుకు సుమారు 2 సెంట్లు. మేము రిగ్రెషన్ యొక్క Y-అక్షంతో ఇంటర్సెక్షన్ పాయింట్‌ను `lin_reg.intercept_` ద్వారా కూడా పొందవచ్చు - ఇది మన కేసులో సుమారు `21` ఉంటుంది, సంవత్సర ప్రారంభంలో ధరను సూచిస్తుంది.
మా మోడల్ ఎంత ఖచ్చితంగా ఉందో చూడటానికి, మేము టెస్ట్ డేటాసెట్‌పై ధరలను అంచనా వేయవచ్చు, ఆపై మా అంచనాలు ఆశించిన విలువలకు ఎంత దగ్గరగా ఉన్నాయో కొలవవచ్చు. ఇది మినీ స్క్వేర్ ఎర్రర్ (MSE) మెట్రిక్స్ ఉపయోగించి చేయవచ్చు, ఇది ఆశించిన మరియు అంచనా విలువల మధ్య అన్ని చదరపు తేడాల సగటు.
```python
pred = lin_reg.predict(X_test)
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
```
మా పొరపాటు సుమారు 2 పాయింట్ల చుట్టూ ఉంది, ఇది సుమారు 17%. చాలా బాగాలేదు. మోడల్ నాణ్యతకు మరో సూచిక **నిర్ణయ సహగుణం** (coefficient of determination), ఇది ఇలా పొందవచ్చు:
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
విలువ 0 అయితే, అంటే మోడల్ ఇన్‌పుట్ డేటాను పరిగణలోకి తీసుకోదు, మరియు *చెత్త లీనియర్ అంచనా వేయగలిగే* మోడల్‌గా పనిచేస్తుంది, ఇది ఫలితాల సగటు విలువ మాత్రమే. విలువ 1 అంటే మేము అన్ని ఆశించిన అవుట్‌పుట్‌లను పూర్తిగా అంచనా వేయగలమని అర్థం. మా సందర్భంలో, సహగుణం సుమారు 0.06, ఇది చాలా తక్కువ.
మేము టెస్ట్ డేటాను రిగ్రెషన్ లైన్‌తో కలిసి ప్లాట్ చేయవచ్చు, మా సందర్భంలో రిగ్రెషన్ ఎలా పనిచేస్తుందో మెరుగ్గా చూడటానికి:
```python
plt.scatter(X_test,y_test)
plt.plot(X_test,pred)
```
<img alt="Linear regression" src="../../../../translated_images/linear-results.f7c3552c85b0ed1ce2808276c870656733f6878c8fd37ec220812ee77686c3ef.te.png" width="50%" />
## పాలినోమియల్ రిగ్రెషన్
లీనియర్ రిగ్రెషన్ యొక్క మరో రకం పాలినోమియల్ రిగ్రెషన్. కొన్ని సార్లు వేరియబుల్స్ మధ్య లీనియర్ సంబంధం ఉంటుంది - వాల్యూమ్ లో పెద్ద పంక్‌కిన్ ఉంటే ధర ఎక్కువ - కానీ కొన్ని సార్లు ఈ సంబంధాలను ప్లేన్ లేదా సూటి రేఖగా చిత్రీకరించలేము.
✅ ఇక్కడ [మరిన్ని ఉదాహరణలు](https://online.stat.psu.edu/stat501/lesson/9/9.8) ఉన్నాయి, ఇవి పాలినోమియల్ రిగ్రెషన్ ఉపయోగించవచ్చు
తేదీ మరియు ధర మధ్య సంబంధాన్ని మరోసారి చూడండి. ఈ స్కాటర్‌ప్లాట్ తప్పనిసరిగా సూటి రేఖతో విశ్లేషించాల్సినదిగా అనిపిస్తుందా? ధరలు మారవచ్చునా? ఈ సందర్భంలో, మీరు పాలినోమియల్ రిగ్రెషన్ ప్రయత్నించవచ్చు.
✅ పాలినోమియల్స్ అనేవి ఒకటి లేదా ఎక్కువ వేరియబుల్స్ మరియు సహగుణాలతో కూడిన గణితీయ వ్యక్తీకరణలు
పాలినోమియల్ రిగ్రెషన్ వక్రీకృత రేఖను సృష్టించి, నాన్‌లీనియర్ డేటాకు మెరుగైన సరిపోయేలా చేస్తుంది. మా సందర్భంలో, ఇన్‌పుట్ డేటాలో స్క్వేర్ చేసిన `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 సృష్టిస్తాము:
```python
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
`PolynomialFeatures(2)` ఉపయోగించడం అంటే మేము ఇన్‌పుట్ డేటా నుండి అన్ని రెండవ-డిగ్రీ పాలినోమియల్స్‌ను చేర్చుతాము. మా సందర్భంలో ఇది కేవలం `DayOfYear`<sup>2</sup> మాత్రమే, కానీ రెండు ఇన్‌పుట్ వేరియబుల్స్ X మరియు Y ఉంటే, ఇది X<sup>2</sup>, XY మరియు Y<sup>2</sup> ను జోడిస్తుంది. మేము కావాలంటే ఎక్కువ డిగ్రీ పాలినోమియల్స్ కూడా ఉపయోగించవచ్చు.
Pipelines ను అసలు `LinearRegression` ఆబ్జెక్ట్ లాగా ఉపయోగించవచ్చు, అంటే మేము pipeline ను `fit` చేసి, ఆపై `predict` ఉపయోగించి అంచనా ఫలితాలు పొందవచ్చు. ఇక్కడ టెస్ట్ డేటా మరియు సన్నిహిత వక్రీకరణ వక్రాన్ని చూపించే గ్రాఫ్ ఉంది:
<img alt="Polynomial regression" src="../../../../translated_images/poly-results.ee587348f0f1f60bd16c471321b0b2f2457d0eaa99d99ec0ced4affc900fa96c.te.png" width="50%" />
పాలినోమియల్ రిగ్రెషన్ ఉపయోగించి, మేము కొంచెం తక్కువ MSE మరియు ఎక్కువ నిర్ణయ సహగుణం పొందవచ్చు, కానీ గణనీయంగా కాదు. మేము ఇతర ఫీచర్లను కూడా పరిగణలోకి తీసుకోవాలి!
> మీరు గమనించవచ్చు, కనిష్ఠ పంక్‌కిన్ ధరలు హాలోవీన్ సమీపంలో ఉంటాయి. దీన్ని మీరు ఎలా వివరిస్తారు?
🎃 అభినందనలు, మీరు ఇప్పుడు పాయ్ పంక్‌కిన్ ధర అంచనా వేయగలిగే మోడల్ సృష్టించారు. మీరు అన్ని పంక్‌కిన్ రకాల కోసం ఇదే ప్రక్రియను పునరావృతం చేయవచ్చు, కానీ అది కష్టమైన పని. ఇప్పుడు మనం మా మోడల్‌లో పంక్‌కిన్ రకాన్ని ఎలా పరిగణలోకి తీసుకోవాలో నేర్చుకుందాం!
## వర్గీకృత ఫీచర్లు
స идеల్ ప్రపంచంలో, మేము ఒకే మోడల్ ఉపయోగించి వివిధ పంక్‌కిన్ రకాల ధరలను అంచనా వేయగలగాలి. అయితే, `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")
> 🎥 పై చిత్రాన్ని క్లిక్ చేసి వర్గీకృత ఫీచర్ల ఉపయోగంపై చిన్న వీడియో అవలోకనం చూడండి.
ఇక్కడ మీరు వేరియటీపై సగటు ధర ఎలా ఆధారపడి ఉందో చూడవచ్చు:
<img alt="Average price by variety" src="../../../../translated_images/price-by-variety.744a2f9925d9bcb43a9a8c69469ce2520c9524fabfa270b1b2422cc2450d6d11.te.png" width="50%" />
వేరియటీని పరిగణలోకి తీసుకోవడానికి, ముందుగా దాన్ని సంఖ్యాత్మక రూపంలోకి మార్చాలి, లేదా **ఎంకోడ్** చేయాలి. దీని కోసం కొన్ని మార్గాలు ఉన్నాయి:
* సాదా **సంఖ్యాత్మక ఎంకోడింగ్** వేరియటీల పట్టికను సృష్టించి, ఆ పట్టికలోని సూచికతో వేరియటీ పేరును మార్చుతుంది. ఇది లీనియర్ రిగ్రెషన్‌కు ఉత్తమ ఆలోచన కాదు, ఎందుకంటే లీనియర్ రిగ్రెషన్ సూచిక యొక్క అసలు సంఖ్యాత్మక విలువను తీసుకుని, దానిని కొంత సహగుణంతో గుణించి ఫలితానికి జోడిస్తుంది. మా సందర్భంలో, సూచిక సంఖ్య మరియు ధర మధ్య సంబంధం స్పష్టంగా నాన్-లీనియర్, ఎప్పటికైనా సూచికలు నిర్దిష్ట రీతిలో క్రమబద్ధీకరించినా కూడా.
* **వన్-హాట్ ఎంకోడింగ్** `Variety` కాలమ్‌ను 4 వేర్వేరు కాలమ్స్‌గా మార్చుతుంది, ఒక్కో వేరియటీకి ఒకటి. ప్రతి కాలమ్‌లో ఆ వరుస ఆ వేరియటీకి చెందినదైతే `1`, లేకపోతే `0` ఉంటుంది. అంటే లీనియర్ రిగ్రెషన్‌లో నాలుగు సహగుణాలు ఉంటాయి, ఒక్కో పంక్‌కిన్ వేరియటీకి ఒకటి, ఆ ప్రత్యేక వేరియటీకి "ప్రారంభ ధర" (లేదా "అదనపు ధర") బాధ్యత వహిస్తుంది.
క్రింది కోడ్ వన్-హాట్ ఎంకోడింగ్ ఎలా చేయాలో చూపిస్తుంది:
```python
pd.get_dummies(new_pumpkins['Variety'])
```
ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
----|-----------|-----------|--------------------------|----------
70 | 0 | 0 | 0 | 1
71 | 0 | 0 | 0 | 1
... | ... | ... | ... | ...
1738 | 0 | 1 | 0 | 0
1739 | 0 | 1 | 0 | 0
1740 | 0 | 1 | 0 | 0
1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0
వన్-హాట్ ఎంకోడెడ్ వేరియటీని ఇన్‌పుట్‌గా ఉపయోగించి లీనియర్ రిగ్రెషన్ ట్రెయిన్ చేయడానికి, మేము కేవలం `X` మరియు `y` డేటాను సరిగ్గా ప్రారంభించాలి:
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
మిగతా కోడ్ మేము పైగా లీనియర్ రిగ్రెషన్ ట్రెయిన్ చేయడానికి ఉపయోగించినదే. మీరు ప్రయత్నిస్తే, సగటు చదరపు పొరపాటు సుమారు అదే ఉంటుంది, కానీ నిర్ణయ సహగుణం చాలా ఎక్కువగా ఉంటుంది (~77%). మరింత ఖచ్చితమైన అంచనాల కోసం, మేము మరిన్ని వర్గీకృత ఫీచర్లు మరియు సంఖ్యాత్మక ఫీచర్లు, ఉదాహరణకు `Month` లేదా `DayOfYear` కూడా పరిగణలోకి తీసుకోవచ్చు. ఒక పెద్ద ఫీచర్ అర్రే పొందడానికి, మేము `join` ఉపయోగించవచ్చు:
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
```
ఇక్కడ మేము `City` మరియు `Package` రకాలను కూడా పరిగణలోకి తీసుకుంటున్నాము, ఇది మాకు MSE 2.84 (10%) మరియు నిర్ణయ సహగుణం 0.94 ఇస్తుంది!
## అన్నింటినీ కలిపి
ఉత్తమ మోడల్ తయారుచేయడానికి, మేము పై ఉదాహరణలోని కలిపిన (వన్-హాట్ ఎంకోడెడ్ వర్గీకృత + సంఖ్యాత్మక) డేటాను పాలినోమియల్ రిగ్రెషన్‌తో కలిపి ఉపయోగించవచ్చు. మీ సౌకర్యానికి పూర్తి కోడ్ ఇక్కడ ఉంది:
```python
# శిక్షణ డేటాను సెట్ చేయండి
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
# శిక్షణ-పరీక్ష విభజన చేయండి
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.fit(X_train,y_train)
# పరీక్ష డేటాకు ఫలితాలను అంచనా వేయండి
pred = pipeline.predict(X_test)
# MSE మరియు నిర్ణయాన్ని లెక్కించండి
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
ఇది సుమారు 97% నిర్ణయ సహగుణం మరియు MSE=2.23 (~8% అంచనా పొరపాటు) ఇస్తుంది.
| మోడల్ | MSE | నిర్ణయ సహగుణం |
|-------|-----|---------------|
| `DayOfYear` లీనియర్ | 2.77 (17.2%) | 0.07 |
| `DayOfYear` పాలినోమియల్ | 2.73 (17.0%) | 0.08 |
| `Variety` లీనియర్ | 5.24 (19.7%) | 0.77 |
| అన్ని ఫీచర్లు లీనియర్ | 2.84 (10.5%) | 0.94 |
| అన్ని ఫీచర్లు పాలినోమియల్ | 2.23 (8.25%) | 0.97 |
🏆 బాగుంది! మీరు ఒక పాఠంలో నాలుగు రిగ్రెషన్ మోడల్స్ సృష్టించి, మోడల్ నాణ్యతను 97%కి పెంచారు. రిగ్రెషన్ చివరి భాగంలో, మీరు వర్గాలను నిర్ణయించడానికి లాజిస్టిక్ రిగ్రెషన్ గురించి నేర్చుకుంటారు.
---
## 🚀సవాలు
ఈ నోట్‌బుక్‌లో వివిధ వేరియబుల్స్‌ను పరీక్షించి, సహసంబంధం మోడల్ ఖచ్చితత్వానికి ఎలా అనుగుణంగా ఉందో చూడండి.
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
ఈ పాఠంలో మేము లీనియర్ రిగ్రెషన్ గురించి నేర్చుకున్నాము. ఇతర ముఖ్యమైన రిగ్రెషన్ రకాలు కూడా ఉన్నాయి. స్టెప్వైజ్, రిడ్జ్, లాస్సో మరియు ఎలాస్టిక్‌నెట్ సాంకేతికతల గురించి చదవండి. మరింత నేర్చుకోవడానికి మంచి కోర్సు [స్టాన్‌ఫర్డ్ స్టాటిస్టికల్ లెర్నింగ్ కోర్సు](https://online.stanford.edu/courses/sohs-ystatslearning-statistical-learning)
## అసైన్‌మెంట్
[మోడల్ నిర్మించండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం మంచిది. ఈ అనువాదం వలన కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల బాధ్యత మేము తీసుకోము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/2-Regression/3-Linear/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "cc471fa89c293bc735dd3a9a0fb79b1b",
"translation_date": "2025-12-19T13:53:26+00:00",
"source_file": "2-Regression/3-Linear/assignment.md",
"language_code": "te"
}
-->
# రిగ్రెషన్ మోడల్ సృష్టించండి
## సూచనలు
ఈ పాఠంలో మీరు లీనియర్ మరియు పాలినోమియల్ రిగ్రెషన్ రెండింటినీ ఉపయోగించి మోడల్‌ను ఎలా నిర్మించాలో చూపించారు. ఈ జ్ఞానాన్ని ఉపయోగించి, ఒక డేటాసెట్‌ను కనుగొనండి లేదా Scikit-learn యొక్క బిల్ట్-ఇన్ సెట్‌లలో ఒకదాన్ని ఉపయోగించి కొత్త మోడల్‌ను నిర్మించండి. మీరు ఎంచుకున్న సాంకేతికత ఎందుకు ఎంచుకున్నారో మీ నోట్‌బుక్‌లో వివరించండి, మరియు మీ మోడల్ యొక్క ఖచ్చితత్వాన్ని ప్రదర్శించండి. అది ఖచ్చితంగా లేకపోతే, ఎందుకు అనేదాన్ని వివరించండి.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతంగా | సరిపడా | మెరుగుదల అవసరం |
| -------- | ------------------------------------------------------------ | -------------------------- | ------------------------------- |
| | బాగా డాక్యుమెంటెడ్ పరిష్కారంతో పూర్తి నోట్‌బుక్‌ను అందిస్తుంది | పరిష్కారం అసంపూర్ణం | పరిష్కారం లోపభూయిష్టం లేదా బగ్గీ |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

128
translations/te/2-Regression/3-Linear/notebook.ipynb
Unescape View File

@ -0,0 +1,128 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Pumpkin Pricing\n",
"\n",
"Load up required libraries and dataset. Convert the data to a dataframe containing a subset of the data: \n",
"\n",
"- బస్సెల్ ద్వారా ధర పెట్టబడిన పంప్కిన్లను మాత్రమే పొందండి\n",
"- తేదీని నెలగా మార్చండి\n",
"- ధరను గరిష్ట మరియు కనిష్ట ధరల సగటుగా లెక్కించండి\n",
"- ధరను బస్సెల్ పరిమాణం ప్రకారం ప్రతిబింబించేలా మార్చండి\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"from datetime import datetime\n",
"\n",
"pumpkins = pd.read_csv('../data/US-pumpkins.csv')\n",
"\n",
"pumpkins.head()\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]\n",
"\n",
"columns_to_select = ['Package', 'Variety', 'City Name', 'Low Price', 'High Price', 'Date']\n",
"pumpkins = pumpkins.loc[:, columns_to_select]\n",
"\n",
"price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2\n",
"\n",
"month = pd.DatetimeIndex(pumpkins['Date']).month\n",
"day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)\n",
"\n",
"new_pumpkins = pd.DataFrame(\n",
" {'Month': month, \n",
" 'DayOfYear' : day_of_year, \n",
" 'Variety': pumpkins['Variety'], \n",
" 'City': pumpkins['City Name'], \n",
" 'Package': pumpkins['Package'], \n",
" 'Low Price': pumpkins['Low Price'],\n",
" 'High Price': pumpkins['High Price'], \n",
" 'Price': price})\n",
"\n",
"new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/1.1\n",
"new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price*2\n",
"\n",
"new_pumpkins.head()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ఒక ప్రాథమిక స్కాటర్ప్లాట్ మనకు ఆగస్టు నుండి డిసెంబర్ వరకు మాత్రమే నెలల డేటా ఉందని గుర్తుచేస్తుంది. రేఖీయంగా నిర్ణయాలు తీసుకోవడానికి మనకు ఎక్కువ డేటా అవసరం కావచ్చు.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"plt.scatter('Month','Price',data=new_pumpkins)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"\n",
"plt.scatter('DayOfYear','Price',data=new_pumpkins)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3-final"
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "b032d371c75279373507f003439a577e",
"translation_date": "2025-12-19T16:17:26+00:00",
"source_file": "2-Regression/3-Linear/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2
}

17
translations/te/2-Regression/3-Linear/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:08:35+00:00",
"source_file": "2-Regression/3-Linear/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

1086
translations/te/2-Regression/3-Linear/solution/R/lesson_3-R.ipynb
View File

File diff suppressed because it is too large Load Diff

1117
translations/te/2-Regression/3-Linear/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

409
translations/te/2-Regression/4-Logistic/README.md
Unescape View File

@ -0,0 +1,409 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "abf86d845c84330bce205a46b382ec88",
"translation_date": "2025-12-19T14:03:43+00:00",
"source_file": "2-Regression/4-Logistic/README.md",
"language_code": "te"
}
-->
# వర్గాలను అంచనా వేయడానికి లాజిస్టిక్ రిగ్రెషన్
![లాజిస్టిక్ vs. లీనియర్ రిగ్రెషన్ ఇన్ఫోగ్రాఫిక్](../../../../translated_images/linear-vs-logistic.ba180bf95e7ee66721ba10ebf2dac2666acbd64a88b003c83928712433a13c7d.te.png)
## [ప్రీ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
> ### [ఈ పాఠం R లో అందుబాటులో ఉంది!](../../../../2-Regression/4-Logistic/solution/R/lesson_4.html)
## పరిచయం
రిగ్రెషన్ పై ఈ చివరి పాఠంలో, ఒక ప్రాథమిక _క్లాసిక్_ ML సాంకేతికత అయిన లాజిస్టిక్ రిగ్రెషన్ ను చూద్దాం. మీరు ఈ సాంకేతికతను ద్విభాగ వర్గాలను అంచనా వేయడానికి నమూనాలు కనుగొనడానికి ఉపయోగిస్తారు. ఈ కాండీ చాక్లెట్ కాదా? ఈ వ్యాధి సంక్రమణీయమా? ఈ కస్టమర్ ఈ ఉత్పత్తిని ఎంచుకుంటాడా?
ఈ పాఠంలో మీరు నేర్చుకుంటారు:
- డేటా విజువలైజేషన్ కోసం కొత్త లైబ్రరీ
- లాజిస్టిక్ రిగ్రెషన్ సాంకేతికతలు
✅ ఈ రకమైన రిగ్రెషన్ తో పని చేయడంపై మీ అవగాహనను ఈ [Learn మాడ్యూల్](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-77952-leestott) లో మరింత లోతుగా పెంచుకోండి
## ముందస్తు అవసరాలు
పంప్కిన్ డేటాతో పని చేసినందున, ఇప్పుడు మనకు ఒక ద్విభాగ వర్గం ఉంది అని తెలుసుకున్నాం: `Color`.
కొన్ని వేరియబుల్స్ ఇచ్చినప్పుడు, ఒక పంప్కిన్ ఏ రంగులో ఉండే అవకాశం ఉందో అంచనా వేయడానికి లాజిస్టిక్ రిగ్రెషన్ మోడల్ నిర్మిద్దాం (ఆరెంజ్ 🎃 లేదా వైట్ 👻).
> రిగ్రెషన్ గురించి ఉన్న పాఠం సమూహంలో ద్విభాగ వర్గీకరణ గురించి ఎందుకు మాట్లాడుతున్నాం? భాషా సౌలభ్యం కోసం మాత్రమే, ఎందుకంటే లాజిస్టిక్ రిగ్రెషన్ [నిజానికి వర్గీకరణ పద్ధతి](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), అయినా లీనియర్ ఆధారితది. తదుపరి పాఠం సమూహంలో డేటాను వర్గీకరించే ఇతర మార్గాలను తెలుసుకోండి.
## ప్రశ్న నిర్వచించండి
మన ప్రయోజనాల కోసం, దీన్ని ద్విభాగంగా వ్యక్తీకరిస్తాము: 'వైట్' లేదా 'వైట్ కాదు'. మా డేటాసెట్‌లో 'స్ట్రైప్డ్' అనే వర్గం కూడా ఉంది కానీ దాని ఉదాహరణలు చాలా తక్కువగా ఉన్నందున దాన్ని ఉపయోగించము. నల్ విలువలను తొలగించిన తర్వాత అది కనబడదు.
> 🎃 సరదా విషయం, కొన్నిసార్లు వైట్ పంప్కిన్లను 'గోస్ట్' పంప్కిన్లు అంటాము. అవి తీయడం అంత సులభం కాదు, అందుకే ఆరెంజ్ పంప్కిన్లంతా ప్రాచుర్యం పొందలేదు కానీ అవి చల్లగా కనిపిస్తాయి! కాబట్టి మన ప్రశ్నను ఇలా కూడా మార్చుకోవచ్చు: 'గోస్ట్' లేదా 'గోస్ట్ కాదు'. 👻
## లాజిస్టిక్ రిగ్రెషన్ గురించి
లాజిస్టిక్ రిగ్రెషన్, మీరు ముందుగా నేర్చుకున్న లీనియర్ రిగ్రెషన్ నుండి కొన్ని ముఖ్యమైన మార్గాల్లో భిన్నంగా ఉంటుంది.
[![ML ప్రారంభకులకు - మెషీన్ లెర్నింగ్ వర్గీకరణ కోసం లాజిస్టిక్ రిగ్రెషన్ అర్థం చేసుకోవడం](https://img.youtube.com/vi/KpeCT6nEpBY/0.jpg)](https://youtu.be/KpeCT6nEpBY "ML ప్రారంభకులకు - మెషీన్ లెర్నింగ్ వర్గీకరణ కోసం లాజిస్టిక్ రిగ్రెషన్ అర్థం చేసుకోవడం")
> 🎥 లాజిస్టిక్ రిగ్రెషన్ పై చిన్న వీడియో అవలోకనం కోసం పై చిత్రాన్ని క్లిక్ చేయండి.
### ద్విభాగ వర్గీకరణ
లాజిస్టిక్ రిగ్రెషన్ లీనియర్ రిగ్రెషన్ లాంటి లక్షణాలను అందించదు. మొదటిది ద్విభాగ వర్గం గురించి అంచనా ఇస్తుంది ("వైట్ లేదా వైట్ కాదు") కానీ రెండవది నిరంతర విలువలను అంచనా వేయగలదు, ఉదాహరణకు పంప్కిన్ మూలం మరియు పంట కోత సమయం ఇచ్చినప్పుడు, _దాని ధర ఎంత పెరుగుతుందో_.
![Pumpkin classification Model](../../../../translated_images/pumpkin-classifier.562771f104ad5436b87d1c67bca02a42a17841133556559325c0a0e348e5b774.te.png)
> ఇన్ఫోగ్రాఫిక్: [దాసాని మడిపల్లి](https://twitter.com/dasani_decoded)
### ఇతర వర్గీకరణలు
మల్టినోమియల్ మరియు ఆర్డినల్ సహా ఇతర రకాల లాజిస్టిక్ రిగ్రెషన్ ఉన్నాయి:
- **మల్టినోమియల్**, అంటే ఒక కంటే ఎక్కువ వర్గాలు ఉండటం - "ఆరెంజ్, వైట్, మరియు స్ట్రైప్డ్".
- **ఆర్డినల్**, అంటే క్రమబద్ధమైన వర్గాలు, ఉదాహరణకు మన పంప్కిన్లు పరిమాణాల క్రమంలో (మినీ, చిన్న, మధ్య, పెద్ద, ఎక్స్ ఎల్, డబుల్ ఎక్స్ ఎల్) ఉంటే ఉపయోగపడుతుంది.
![మల్టినోమియల్ vs ఆర్డినల్ రిగ్రెషన్](../../../../translated_images/multinomial-vs-ordinal.36701b4850e37d86c9dd49f7bef93a2f94dbdb8fe03443eb68f0542f97f28f29.te.png)
### వేరియబుల్స్ తప్పనిసరిగా సంబంధం ఉండాల్సిన అవసరం లేదు
లీనియర్ రిగ్రెషన్ ఎక్కువ సంబంధిత వేరియబుల్స్ తో బాగా పనిచేస్తుంది అని గుర్తుంచుకోండి? లాజిస్టిక్ రిగ్రెషన్ మాత్రం విరుద్ధం - వేరియబుల్స్ సరిపోవాల్సిన అవసరం లేదు. ఇది కొంతమేర బలహీన సంబంధాలు ఉన్న డేటాకు సరిపోతుంది.
### మీరు చాలా శుభ్రమైన డేటా అవసరం
లాజిస్టిక్ రిగ్రెషన్ ఎక్కువ డేటా ఉపయోగిస్తే మరింత ఖచ్చితమైన ఫలితాలు ఇస్తుంది; మన చిన్న డేటాసెట్ ఈ పనికి సరిపోదు, దాన్ని గమనించండి.
[![ML ప్రారంభకులకు - లాజిస్టిక్ రిగ్రెషన్ కోసం డేటా విశ్లేషణ మరియు సిద్ధత](https://img.youtube.com/vi/B2X4H9vcXTs/0.jpg)](https://youtu.be/B2X4H9vcXTs "ML ప్రారంభకులకు - లాజిస్టిక్ రిగ్రెషన్ కోసం డేటా విశ్లేషణ మరియు సిద్ధత")
> 🎥 లీనియర్ రిగ్రెషన్ కోసం డేటా సిద్ధత పై చిన్న వీడియో అవలోకనం కోసం పై చిత్రాన్ని క్లిక్ చేయండి
✅ లాజిస్టిక్ రిగ్రెషన్ కు అనుకూలమైన డేటా రకాలను గురించి ఆలోచించండి
## వ్యాయామం - డేటాను శుభ్రపరచండి
ముందుగా, డేటాను కొంచెం శుభ్రపరచండి, నల్ విలువలను తొలగించి కొన్ని కాలమ్స్ మాత్రమే ఎంచుకోండి:
1. క్రింది కోడ్ జోడించండి:
```python
columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
pumpkins = full_pumpkins.loc[:, columns_to_select]
pumpkins.dropna(inplace=True)
```
మీ కొత్త డేటాఫ్రేమ్ ను ఎప్పుడైనా చూడవచ్చు:
```python
pumpkins.info
```
### విజువలైజేషన్ - వర్గీకరణ ప్లాట్
ఇప్పటికే మీరు [స్టార్టర్ నోట్‌బుక్](./notebook.ipynb) లో పంప్కిన్ డేటాను మళ్లీ లోడ్ చేసి, కొన్ని వేరియబుల్స్ తో కూడిన డేటాసెట్ ను నిలుపుకున్నారు, అందులో `Color` కూడా ఉంది. ఇప్పుడు మనం వేరే లైబ్రరీ ఉపయోగించి డేటాఫ్రేమ్ ను విజువలైజ్ చేద్దాం: [Seaborn](https://seaborn.pydata.org/index.html), ఇది Matplotlib పై నిర్మించబడింది, మనం ముందుగా ఉపయోగించాము.
Seaborn మీ డేటాను విజువలైజ్ చేయడానికి కొన్ని చక్కటి మార్గాలను అందిస్తుంది. ఉదాహరణకు, మీరు ప్రతి `Variety` మరియు `Color` కోసం డేటా పంపిణీలను వర్గీకరణ ప్లాట్ లో పోల్చవచ్చు.
1. `catplot` ఫంక్షన్ ఉపయోగించి ఇలాంటి ప్లాట్ సృష్టించండి, మన పంప్కిన్ డేటా `pumpkins` ఉపయోగించి, ప్రతి పంప్కిన్ వర్గానికి రంగు మ్యాపింగ్ (ఆరెంజ్ లేదా వైట్) నిర్దేశించండి:
```python
import seaborn as sns
palette = {
'ORANGE': 'orange',
'WHITE': 'wheat',
}
sns.catplot(
data=pumpkins, y="Variety", hue="Color", kind="count",
palette=palette,
)
```
![విజువలైజ్ చేసిన డేటా గ్రిడ్](../../../../translated_images/pumpkins_catplot_1.c55c409b71fea2ecc01921e64b91970542101f90bcccfa4aa3a205db8936f48b.te.png)
డేటాను పరిశీలించి, మీరు Color డేటా Variety తో ఎలా సంబంధం ఉన్నదో చూడవచ్చు.
✅ ఈ వర్గీకరణ ప్లాట్ ఇచ్చినప్పుడు, మీరు ఊహించగల కొన్ని ఆసక్తికర అన్వేషణలు ఏమిటి?
### డేటా ప్రీ-ప్రాసెసింగ్: ఫీచర్ మరియు లేబుల్ ఎంకోడింగ్
మన పంప్కిన్ల డేటాసెట్ లో అన్ని కాలమ్స్ స్ట్రింగ్ విలువలు కలిగి ఉన్నాయి. వర్గీకరణ డేటాతో పని చేయడం మనుషులకు సులభం కానీ యంత్రాలకు కాదు. మెషీన్ లెర్నింగ్ అల్గోరిథమ్స్ సంఖ్యలతో బాగా పనిచేస్తాయి. అందుకే ఎంకోడింగ్ డేటా ప్రీ-ప్రాసెసింగ్ దశలో చాలా ముఖ్యమైన దశ, ఇది వర్గీకరణ డేటాను సంఖ్యాత్మక డేటాగా మార్చడానికి సహాయపడుతుంది, ఎలాంటి సమాచారం కోల్పోకుండా. మంచి ఎంకోడింగ్ మంచి మోడల్ నిర్మాణానికి దారితీస్తుంది.
ఫీచర్ ఎంకోడింగ్ కోసం రెండు ప్రధాన రకాల ఎంకోడర్లు ఉన్నాయి:
1. ఆర్డినల్ ఎంకోడర్: ఇది ఆర్డినల్ వేరియబుల్స్ కు సరిపోతుంది, అవి వర్గీకరణ వేరియబుల్స్, వాటి డేటా తార్కిక క్రమంలో ఉంటుంది, మన డేటాసెట్ లో `Item Size` కాలమ్ లాంటిది. ఇది ప్రతి వర్గం ఒక సంఖ్యతో ప్రాతినిధ్యం వహించే మ్యాపింగ్ సృష్టిస్తుంది, అది ఆ కాలమ్ లో వర్గం క్రమం.
```python
from sklearn.preprocessing import OrdinalEncoder
item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']]
ordinal_features = ['Item Size']
ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
```
2. వర్గీకరణ ఎంకోడర్: ఇది నామినల్ వేరియబుల్స్ కు సరిపోతుంది, అవి వర్గీకరణ వేరియబుల్స్, వాటి డేటా తార్కిక క్రమంలో ఉండదు, మన డేటాసెట్ లో `Item Size` తప్ప అన్ని ఫీచర్స్. ఇది వన్-హాట్ ఎంకోడింగ్, అంటే ప్రతి వర్గం ఒక బైనరీ కాలమ్ తో ప్రాతినిధ్యం వహిస్తుంది: ఎంకోడెడ్ వేరియబుల్ 1 అవుతుంది ఆ పంప్కిన్ ఆ Variety కి చెందితే, లేకపోతే 0.
```python
from sklearn.preprocessing import OneHotEncoder
categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
categorical_encoder = OneHotEncoder(sparse_output=False)
```
తర్వాత, `ColumnTransformer` ఉపయోగించి అనేక ఎంకోడర్లను ఒకే దశలో కలిపి సరైన కాలమ్స్ కు వర్తింపజేస్తారు.
```python
from sklearn.compose import ColumnTransformer
ct = ColumnTransformer(transformers=[
('ord', ordinal_encoder, ordinal_features),
('cat', categorical_encoder, categorical_features)
])
ct.set_output(transform='pandas')
encoded_features = ct.fit_transform(pumpkins)
```
మరొకవైపు, లేబుల్ ఎంకోడింగ్ కోసం, మనం scikit-learn `LabelEncoder` క్లాస్ ఉపయోగిస్తాము, ఇది లేబుల్స్ ను 0 నుండి n_classes-1 (ఇక్కడ 0 మరియు 1) మధ్య విలువలుగా సాధారణీకరించడానికి సహాయపడే యుటిలిటీ క్లాస్.
```python
from sklearn.preprocessing import LabelEncoder
label_encoder = LabelEncoder()
encoded_label = label_encoder.fit_transform(pumpkins['Color'])
```
ఫీచర్స్ మరియు లేబుల్ ఎంకోడింగ్ చేసిన తర్వాత, వాటిని కొత్త డేటాఫ్రేమ్ `encoded_pumpkins` లో విలీనం చేయవచ్చు.
```python
encoded_pumpkins = encoded_features.assign(Color=encoded_label)
```
✅ `Item Size` కాలమ్ కోసం ఆర్డినల్ ఎంకోడర్ ఉపయోగించడంలో లాభాలు ఏమిటి?
### వేరియబుల్స్ మధ్య సంబంధాలను విశ్లేషించండి
ఇప్పుడు మనం డేటాను ప్రీ-ప్రాసెస్ చేశాము, ఫీచర్స్ మరియు లేబుల్ మధ్య సంబంధాలను విశ్లేషించి, ఫీచర్స్ ఇచ్చినప్పుడు మోడల్ లేబుల్ ను ఎంత బాగా అంచనా వేయగలదో అర్థం చేసుకోవచ్చు.
ఇలాంటి విశ్లేషణ చేయడానికి ఉత్తమ మార్గం డేటాను ప్లాట్ చేయడం. మళ్లీ Seaborn `catplot` ఫంక్షన్ ఉపయోగించి `Item Size`, `Variety` మరియు `Color` మధ్య సంబంధాలను వర్గీకరణ ప్లాట్ లో చూపిస్తాము. డేటాను మెరుగ్గా ప్లాట్ చేయడానికి ఎంకోడెడ్ `Item Size` కాలమ్ మరియు ఎంకోడింగ్ చేయని `Variety` కాలమ్ ఉపయోగిస్తాము.
```python
palette = {
'ORANGE': 'orange',
'WHITE': 'wheat',
}
pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']
g = sns.catplot(
data=pumpkins,
x="Item Size", y="Color", row='Variety',
kind="box", orient="h",
sharex=False, margin_titles=True,
height=1.8, aspect=4, palette=palette,
)
g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
g.set_titles(row_template="{row_name}")
```
![విజువలైజ్ చేసిన డేటా క్యాట్‌ప్లాట్](../../../../translated_images/pumpkins_catplot_2.87a354447880b3889278155957f8f60dd63db4598de5a6d0fda91c334d31f9f1.te.png)
### స్వార్మ్ ప్లాట్ ఉపయోగించండి
Color ఒక ద్విభాగ వర్గం (వైట్ లేదా కాదు) కావడంతో, దానికి 'విశేషమైన విజువలైజేషన్ దృష్టికోణం' అవసరం. ఈ వర్గం మరియు ఇతర వేరియబుల్స్ మధ్య సంబంధాన్ని చూపడానికి ఇతర మార్గాలు ఉన్నాయి.
Seaborn ప్లాట్లతో వేరియబుల్స్ ను పక్కపక్కన చూపవచ్చు.
1. విలువల పంపిణీ చూపడానికి 'స్వార్మ్' ప్లాట్ ప్రయత్నించండి:
```python
palette = {
0: 'orange',
1: 'wheat'
}
sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
```
![విజువలైజ్ చేసిన డేటా స్వార్మ్](../../../../translated_images/swarm_2.efeacfca536c2b577dc7b5f8891f28926663fbf62d893ab5e1278ae734ca104e.te.png)
**జాగ్రత్త**: పై కోడ్ ఒక హెచ్చరికను ఉత్పత్తి చేయవచ్చు, ఎందుకంటే seaborn ఇంత పెద్ద డేటా పాయింట్లను స్వార్మ్ ప్లాట్ లో చూపించలేకపోవచ్చు. ఒక పరిష్కారం 'size' పారామీటర్ ఉపయోగించి మార్కర్ పరిమాణం తగ్గించడం. అయితే, ఇది ప్లాట్ చదవడాన్ని ప్రభావితం చేస్తుంది.
> **🧮 గణితం చూపించండి**
>
> లాజిస్టిక్ రిగ్రెషన్ 'మాక్సిమమ్ లైక్లిహుడ్' సూత్రంపై ఆధారపడి ఉంటుంది, [సిగ్మాయిడ్ ఫంక్షన్లు](https://wikipedia.org/wiki/Sigmoid_function) ఉపయోగించి. ఒక 'సిగ్మాయిడ్ ఫంక్షన్' ప్లాట్ లో 'S' ఆకారంలో ఉంటుంది. ఇది ఒక విలువ తీసుకుని 0 మరియు 1 మధ్య ఎక్కడో మ్యాప్ చేస్తుంది. దీని వక్రరేఖను 'లాజిస్టిక్ వక్రరేఖ' అంటారు. దీని సూత్రం ఇలా ఉంటుంది:
>
> ![లాజిస్టిక్ ఫంక్షన్](../../../../translated_images/sigmoid.8b7ba9d095c789cf72780675d0d1d44980c3736617329abfc392dfc859799704.te.png)
>
> ఇక్కడ సిగ్మాయిడ్ మధ్యబిందువు x యొక్క 0 పాయింట్ వద్ద ఉంటుంది, L వక్రరేఖ గరిష్ట విలువ, k వక్రత యొక్క తీవ్రత. ఫంక్షన్ ఫలితం 0.5 కంటే ఎక్కువ అయితే, ఆ లేబుల్ '1' అనే ద్విభాగ ఎంపికకు ఇవ్వబడుతుంది. లేకపోతే, '0' గా వర్గీకరించబడుతుంది.
## మీ మోడల్ నిర్మించండి
ఈ ద్విభాగ వర్గీకరణను కనుగొనడానికి మోడల్ నిర్మించడం Scikit-learn లో ఆశ్చర్యకరంగా సులభం.
[![ML ప్రారంభకులకు - డేటా వర్గీకరణ కోసం లాజిస్టిక్ రిగ్రెషన్](https://img.youtube.com/vi/MmZS2otPrQ8/0.jpg)](https://youtu.be/MmZS2otPrQ8 "ML ప్రారంభకులకు - డేటా వర్గీకరణ కోసం లాజిస్టిక్ రిగ్రెషన్")
> 🎥 లీనియర్ రిగ్రెషన్ మోడల్ నిర్మాణం పై చిన్న వీడియో అవలోకనం కోసం పై చిత్రాన్ని క్లిక్ చేయండి
1. మీరు వర్గీకరణ మోడల్ లో ఉపయోగించదలచిన వేరియబుల్స్ ఎంచుకుని, `train_test_split()` పిలిచి ట్రైనింగ్ మరియు టెస్ట్ సెట్ లను విడగొట్టండి:
```python
from sklearn.model_selection import train_test_split
X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])]
y = encoded_pumpkins['Color']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
2. ఇప్పుడు మీరు మీ మోడల్ ను ట్రైన్ చేయవచ్చు, ట్రైనింగ్ డేటాతో `fit()` పిలిచి, ఫలితాన్ని ప్రింట్ చేయండి:
```python
from sklearn.metrics import f1_score, classification_report
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(classification_report(y_test, predictions))
print('Predicted labels: ', predictions)
print('F1-score: ', f1_score(y_test, predictions))
```
మీ మోడల్ స్కోర్బోర్డ్ ను చూడండి. ఇది చెడిగా లేదు, మీరు సుమారు 1000 వరుసల డేటా మాత్రమే కలిగి ఉన్నప్పటికీ:
```output
precision recall f1-score support
0 0.94 0.98 0.96 166
1 0.85 0.67 0.75 33
accuracy 0.92 199
macro avg 0.89 0.82 0.85 199
weighted avg 0.92 0.92 0.92 199
Predicted labels: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0
0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 1 0 0 0 0 0 0 0 0 1 1]
F1-score: 0.7457627118644068
```
## కన్ఫ్యూజన్ మ్యాట్రిక్స్ ద్వారా మెరుగైన అవగాహన
మీరు పై అంశాలను ప్రింట్ చేసి స్కోర్బోర్డ్ నివేదిక పొందవచ్చు [terms](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html?highlight=classification_report#sklearn.metrics.classification_report), కానీ మోడల్ పనితీరును అర్థం చేసుకోవడానికి [కన్ఫ్యూజన్ మ్యాట్రిక్స్](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix) ఉపయోగించడం సులభం.
> 🎓 '[కన్ఫ్యూజన్ మ్యాట్రిక్స్](https://wikipedia.org/wiki/Confusion_matrix)' (లేదా 'ఎర్రర్ మ్యాట్రిక్స్') అనేది మీ మోడల్ నిజమైన మరియు తప్పుడు పాజిటివ్ మరియు నెగటివ్ లను వ్యక్తం చేసే పట్టిక, తద్వారా అంచనాల ఖచ్చితత్వాన్ని కొలుస్తుంది.
1. కన్ఫ్యూజన్ మ్యాట్రిక్స్ ఉపయోగించడానికి, `confusion_matrix()` పిలవండి:
```python
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, predictions)
```
మీ మోడల్ కన్ఫ్యూజన్ మ్యాట్రిక్స్ ను చూడండి:
```output
array([[162, 4],
[ 11, 22]])
```
Scikit-learn లో, కన్ఫ్యూజన్ మ్యాట్రిక్స్ లో వరుసలు (అక్షం 0) నిజమైన లేబుల్స్, కాలమ్స్ (అక్షం 1) అంచనా లేబుల్స్.
| | 0 | 1 |
| :---: | :---: | :---: |
| 0 | TN | FP |
| 1 | FN | TP |
ఇక్కడ ఏమి జరుగుతోంది? మన మోడల్ పంప్కిన్లను రెండు ద్విభాగ వర్గాలుగా వర్గీకరించమని అడిగితే, 'వైట్' మరియు 'వైట్ కాదు' వర్గాలు.
- మీ మోడల్ ఒక పంప్కిన్ ను 'వైట్ కాదు' అని అంచనా వేసి, అది నిజంగా 'వైట్ కాదు' వర్గానికి చెందితే, దాన్ని నిజమైన నెగటివ్ అంటాము, ఇది ఎడమ పై సంఖ్యతో చూపబడుతుంది.
- మీ మోడల్ ఒక పంప్కిన్ ను 'వైట్' అని అంచనా వేసి, అది నిజంగా 'వైట్ కాదు' వర్గానికి చెందితే, దాన్ని తప్పుడు పాజిటివ్ అంటాము, ఇది ఎడమ కింద సంఖ్యతో చూపబడుతుంది.
- మీ మోడల్ ఒక పంప్కిన్ ను 'వైట్ కాదు' అని అంచనా వేసి, అది నిజంగా 'వైట్' వర్గానికి చెందితే, దాన్ని తప్పుడు నెగటివ్ అంటాము, ఇది కుడి పై సంఖ్యతో చూపబడుతుంది.
- మీ మోడల్ ఒక పంప్కిన్ ను 'వైట్' అని అంచనా వేసి, అది నిజంగా 'వైట్' వర్గానికి చెందితే, దాన్ని నిజమైన పాజిటివ్ అంటాము, ఇది కుడి కింద సంఖ్యతో చూపబడుతుంది.
మీరు ఊహించినట్లుగా, నిజమైన పాజిటివ్స్ మరియు నిజమైన నెగటివ్స్ సంఖ్య ఎక్కువగా ఉండటం మరియు తప్పు పాజిటివ్స్ మరియు తప్పు నెగటివ్స్ సంఖ్య తక్కువగా ఉండటం మంచిది, ఇది మోడల్ మెరుగ్గా పనిచేస్తుందని సూచిస్తుంది.
కన్ఫ్యూజన్ మ్యాట్రిక్స్ precision మరియు recall కు ఎలా సంబంధించిందో తెలుసుకుందాం? పైగా ప్రింట్ చేసిన classification report లో precision (0.85) మరియు recall (0.67) చూపించబడింది.
Precision = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461
Recall = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666
✅ ప్రశ్న: కన్ఫ్యూజన్ మ్యాట్రిక్స్ ప్రకారం, మోడల్ ఎలా పని చేసింది? జవాబు: బాగుంది; నిజమైన నెగటివ్స్ మంచి సంఖ్యలో ఉన్నాయి కానీ కొన్ని తప్పు నెగటివ్స్ కూడా ఉన్నాయి.
ముందుగా చూచిన పదాలను మళ్లీ చూడండి, కన్ఫ్యూజన్ మ్యాట్రిక్స్ లో TP/TN మరియు FP/FN మ్యాపింగ్ సహాయంతో:
🎓 Precision: TP/(TP + FP) తిరిగి పొందిన ఉదాహరణలలో సంబంధిత ఉదాహరణల శాతం (ఉదా: ఏ లేబుల్స్ బాగా లేబుల్ చేయబడ్డాయో)
🎓 Recall: TP/(TP + FN) సంబంధిత ఉదాహరణలలో తిరిగి పొందిన వాటి శాతం, బాగా లేబుల్ అయినా లేదా కాకపోయినా
🎓 f1-score: (2 * precision * recall)/(precision + recall) precision మరియు recall యొక్క బరువు కలిగిన సగటు, ఉత్తమం 1 మరియు చెత్తది 0
🎓 Support: ప్రతి లేబుల్ తిరిగి పొందిన సందర్భాల సంఖ్య
🎓 Accuracy: (TP + TN)/(TP + TN + FP + FN) నమూనా కోసం సరిగ్గా అంచనా వేసిన లేబుల్స్ శాతం
🎓 Macro Avg: ప్రతి లేబుల్ కోసం బరువు లేని సగటు గణన, లేబుల్ అసమతుల్యతను పరిగణలోకి తీసుకోదు
🎓 Weighted Avg: ప్రతి లేబుల్ కోసం సగటు గణన, లేబుల్ అసమతుల్యతను పరిగణలోకి తీసుకుని వాటి support (ప్రతి లేబుల్ కోసం నిజమైన ఉదాహరణల సంఖ్య) తో బరువు వేస్తుంది
✅ మీరు మీ మోడల్ తప్పు నెగటివ్స్ సంఖ్యను తగ్గించాలని అనుకుంటే ఏ మెట్రిక్ ను గమనించాలి అనుకుంటున్నారా?
## ఈ మోడల్ యొక్క ROC వక్రాన్ని దృశ్యీకరించండి
[![ML for beginners - Analyzing Logistic Regression Performance with ROC Curves](https://img.youtube.com/vi/GApO575jTA0/0.jpg)](https://youtu.be/GApO575jTA0 "ML for beginners - Analyzing Logistic Regression Performance with ROC Curves")
> 🎥 పై చిత్రాన్ని క్లిక్ చేసి ROC వక్రాలపై చిన్న వీడియో అవలోకనం చూడండి
మరి ఒక దృశ్యీకరణ చేద్దాం, దీనిని 'ROC' వక్రం అంటారు:
```python
from sklearn.metrics import roc_curve, roc_auc_score
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline
y_scores = model.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
fig = plt.figure(figsize=(6, 6))
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr, tpr)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.show()
```
Matplotlib ఉపయోగించి, మోడల్ యొక్క [Receiving Operating Characteristic](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html?highlight=roc) లేదా ROC ను ప్లాట్ చేయండి. ROC వక్రాలు తరచుగా క్లాసిఫయర్ అవుట్పుట్ ను నిజమైన మరియు తప్పు పాజిటివ్స్ పరంగా చూడటానికి ఉపయోగిస్తారు. "ROC వక్రాలు సాధారణంగా Y అక్షంపై నిజమైన పాజిటివ్ రేటును, X అక్షంపై తప్పు పాజిటివ్ రేటును చూపిస్తాయి." కాబట్టి వక్రం యొక్క తిప్పట మరియు మధ్య రేఖ మరియు వక్రం మధ్య ఉన్న స్థలం ముఖ్యం: మీరు త్వరగా పైకి వెళ్లి రేఖను దాటే వక్రం కావాలి. మన కేసులో, మొదట కొన్ని తప్పు పాజిటివ్స్ ఉన్నాయి, ఆ తర్వాత రేఖ సరిగ్గా పైకి వెళ్లి దాటుతుంది:
![ROC](../../../../translated_images/ROC_2.777f20cdfc4988ca683ade6850ac832cb70c96c12f1b910d294f270ef36e1a1c.te.png)
చివరగా, Scikit-learn యొక్క [`roc_auc_score` API](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html?highlight=roc_auc#sklearn.metrics.roc_auc_score) ఉపయోగించి వాస్తవ 'Area Under the Curve' (AUC) ను లెక్కించండి:
```python
auc = roc_auc_score(y_test,y_scores[:,1])
print(auc)
```
ఫలితం `0.9749908725812341`. AUC 0 నుండి 1 వరకు ఉంటుంది, మీరు పెద్ద స్కోరు కావాలి, ఎందుకంటే 100% సరిగ్గా అంచనా వేసే మోడల్ కు AUC 1 ఉంటుంది; ఈ సందర్భంలో, మోడల్ _చాలా బాగుంది_.
భవిష్యత్తు తరగతుల్లో మీరు మీ మోడల్ స్కోర్లు మెరుగుపరచడానికి ఎలా పునరావృతం చేయాలో నేర్చుకుంటారు. కానీ ఇప్పటికీ, అభినందనలు! మీరు ఈ రిగ్రెషన్ పాఠాలు పూర్తి చేసారు!
---
## 🚀సవాలు
లాజిస్టిక్ రిగ్రెషన్ గురించి ఇంకా చాలా తెలుసుకోవాల్సి ఉంది! కానీ నేర్చుకోవడానికి ఉత్తమ మార్గం ప్రయోగం చేయడం. ఈ రకమైన విశ్లేషణకు అనువైన డేటాసెట్ కనుగొని దానితో మోడల్ నిర్మించండి. మీరు ఏమి నేర్చుకుంటారు? సూచన: ఆసక్తికరమైన డేటాసెట్ల కోసం [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) ప్రయత్నించండి.
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
లాజిస్టిక్ రిగ్రెషన్ యొక్క కొన్ని ప్రాక్టికల్ ఉపయోగాలపై [స్టాన్‌ఫర్డ్ నుండి ఈ పేపర్](https://web.stanford.edu/~jurafsky/slp3/5.pdf) మొదటి కొన్ని పేజీలను చదవండి. ఇప్పటివరకు నేర్చుకున్న రిగ్రెషన్ పనులలో ఏది ఏ పనికి బాగా సరిపోతుందో ఆలోచించండి. ఏది ఉత్తమంగా పనిచేస్తుంది?
## అసైన్‌మెంట్
[ఈ రిగ్రెషన్ మళ్లీ ప్రయత్నించడం](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

26
translations/te/2-Regression/4-Logistic/assignment.md
Unescape View File

@ -0,0 +1,26 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "8af40209a41494068c1f42b14c0b450d",
"translation_date": "2025-12-19T14:07:49+00:00",
"source_file": "2-Regression/4-Logistic/assignment.md",
"language_code": "te"
}
-->
# కొంత రిగ్రెషన్ మళ్లీ ప్రయత్నించడం
## సూచనలు
పాఠంలో, మీరు పంప్కిన్ డేటా యొక్క ఒక ఉపసమితిని ఉపయోగించారు. ఇప్పుడు, అసలు డేటాకు తిరిగి వెళ్లి, దాన్ని శుభ్రపరిచి మరియు ప్రమాణీకరించి, మొత్తం డేటాను ఉపయోగించి లాజిస్టిక్ రిగ్రెషన్ మోడల్ నిర్మించడానికి ప్రయత్నించండి.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | ----------------------------------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------------------- |
| | బాగా వివరించబడిన మరియు బాగా పనిచేసే మోడల్ ఉన్న నోట్‌బుక్ అందించబడింది | కనీసంగా పనిచేసే మోడల్ ఉన్న నోట్‌బుక్ అందించబడింది | తక్కువ పనితీరు గల మోడల్ లేదా మోడల్ లేని నోట్‌బుక్ అందించబడింది |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

269
translations/te/2-Regression/4-Logistic/notebook.ipynb
Unescape View File

@ -0,0 +1,269 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## పంప్కిన్ రకాలు మరియు రంగు\n",
"\n",
"అవసరమైన లైబ్రరీలు మరియు డేటాసెట్‌ను లోడ్ చేయండి. డేటాను ఒక డేటాఫ్రేమ్‌గా మార్చండి, ఇది డేటా యొక్క ఉపసమితిని కలిగి ఉంటుంది:\n",
"\n",
"రంగు మరియు రకం మధ్య సంబంధాన్ని చూద్దాం\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>City Name</th>\n",
" <th>Type</th>\n",
" <th>Package</th>\n",
" <th>Variety</th>\n",
" <th>Sub Variety</th>\n",
" <th>Grade</th>\n",
" <th>Date</th>\n",
" <th>Low Price</th>\n",
" <th>High Price</th>\n",
" <th>Mostly Low</th>\n",
" <th>...</th>\n",
" <th>Unit of Sale</th>\n",
" <th>Quality</th>\n",
" <th>Condition</th>\n",
" <th>Appearance</th>\n",
" <th>Storage</th>\n",
" <th>Crop</th>\n",
" <th>Repack</th>\n",
" <th>Trans Mode</th>\n",
" <th>Unnamed: 24</th>\n",
" <th>Unnamed: 25</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>BALTIMORE</td>\n",
" <td>NaN</td>\n",
" <td>24 inch bins</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>4/29/17</td>\n",
" <td>270.0</td>\n",
" <td>280.0</td>\n",
" <td>270.0</td>\n",
" <td>...</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>E</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>BALTIMORE</td>\n",
" <td>NaN</td>\n",
" <td>24 inch bins</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>5/6/17</td>\n",
" <td>270.0</td>\n",
" <td>280.0</td>\n",
" <td>270.0</td>\n",
" <td>...</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>E</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>BALTIMORE</td>\n",
" <td>NaN</td>\n",
" <td>24 inch bins</td>\n",
" <td>HOWDEN TYPE</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>9/24/16</td>\n",
" <td>160.0</td>\n",
" <td>160.0</td>\n",
" <td>160.0</td>\n",
" <td>...</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>N</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>BALTIMORE</td>\n",
" <td>NaN</td>\n",
" <td>24 inch bins</td>\n",
" <td>HOWDEN TYPE</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>9/24/16</td>\n",
" <td>160.0</td>\n",
" <td>160.0</td>\n",
" <td>160.0</td>\n",
" <td>...</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>N</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>BALTIMORE</td>\n",
" <td>NaN</td>\n",
" <td>24 inch bins</td>\n",
" <td>HOWDEN TYPE</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>11/5/16</td>\n",
" <td>90.0</td>\n",
" <td>100.0</td>\n",
" <td>90.0</td>\n",
" <td>...</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>N</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"<p>5 rows × 26 columns</p>\n",
"</div>"
],
"text/plain": [
" City Name Type Package Variety Sub Variety Grade Date \\\n",
"0 BALTIMORE NaN 24 inch bins NaN NaN NaN 4/29/17 \n",
"1 BALTIMORE NaN 24 inch bins NaN NaN NaN 5/6/17 \n",
"2 BALTIMORE NaN 24 inch bins HOWDEN TYPE NaN NaN 9/24/16 \n",
"3 BALTIMORE NaN 24 inch bins HOWDEN TYPE NaN NaN 9/24/16 \n",
"4 BALTIMORE NaN 24 inch bins HOWDEN TYPE NaN NaN 11/5/16 \n",
"\n",
" Low Price High Price Mostly Low ... Unit of Sale Quality Condition \\\n",
"0 270.0 280.0 270.0 ... NaN NaN NaN \n",
"1 270.0 280.0 270.0 ... NaN NaN NaN \n",
"2 160.0 160.0 160.0 ... NaN NaN NaN \n",
"3 160.0 160.0 160.0 ... NaN NaN NaN \n",
"4 90.0 100.0 90.0 ... NaN NaN NaN \n",
"\n",
" Appearance Storage Crop Repack Trans Mode Unnamed: 24 Unnamed: 25 \n",
"0 NaN NaN NaN E NaN NaN NaN \n",
"1 NaN NaN NaN E NaN NaN NaN \n",
"2 NaN NaN NaN N NaN NaN NaN \n",
"3 NaN NaN NaN N NaN NaN NaN \n",
"4 NaN NaN NaN N NaN NaN NaN \n",
"\n",
"[5 rows x 26 columns]"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"\n",
"full_pumpkins = pd.read_csv('../data/US-pumpkins.csv')\n",
"\n",
"full_pumpkins.head()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.1"
},
"metadata": {
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "dee08c2b49057b0de8b6752c4dbca368",
"translation_date": "2025-12-19T16:18:23+00:00",
"source_file": "2-Regression/4-Logistic/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2
}

17
translations/te/2-Regression/4-Logistic/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:10:05+00:00",
"source_file": "2-Regression/4-Logistic/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

686
translations/te/2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb
Unescape View File

@ -0,0 +1,686 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## లాజిస్టిక్ రిగ్రెషన్ మోడల్ నిర్మాణం - పాఠం 4\n",
"\n",
"![లాజిస్టిక్ vs. లీనియర్ రిగ్రెషన్ ఇన్ఫోగ్రాఫిక్](../../../../../../translated_images/linear-vs-logistic.ba180bf95e7ee66721ba10ebf2dac2666acbd64a88b003c83928712433a13c7d.te.png)\n",
"\n",
"#### **[పూర్వ-ఉపన్యాస క్విజ్](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/15/)**\n",
"\n",
"#### పరిచయం\n",
"\n",
"రిగ్రెషన్ పై ఈ చివరి పాఠంలో, ఒక ప్రాథమిక *క్లాసిక్* ఎంఎల్ సాంకేతికత అయిన లాజిస్టిక్ రిగ్రెషన్‌ను పరిశీలిస్తాము. మీరు ఈ సాంకేతికతను ద్విభాగ వర్గీకరణలను అంచనా వేయడానికి ఉపయోగిస్తారు. ఈ కాండీ చాక్లెట్ కాదా? ఈ వ్యాధి సంక్రమణీయమా? ఈ కస్టమర్ ఈ ఉత్పత్తిని ఎంచుకుంటాడా?\n",
"\n",
"ఈ పాఠంలో, మీరు నేర్చుకుంటారు:\n",
"\n",
"- లాజిస్టిక్ రిగ్రెషన్ సాంకేతికతలు\n",
"\n",
"✅ ఈ రకమైన రిగ్రెషన్‌తో పని చేయడంపై మీ అవగాహనను ఈ [Learn module](https://learn.microsoft.com/training/modules/introduction-classification-models/?WT.mc_id=academic-77952-leestott) లో మరింత లోతుగా తెలుసుకోండి\n",
"\n",
"## ముందస్తు అవసరాలు\n",
"\n",
"పంప్కిన్ డేటాతో పని చేసినందున, ఇప్పుడు మనకు ఒక ద్విభాగ వర్గం ఉందని తెలుసు: `Color`.\n",
"\n",
"కొన్ని వేరియబుల్స్ ఇచ్చినప్పుడు, *ఏ రంగులో ఉండే అవకాశం ఉన్నదో* (ఆరెంజ్ 🎃 లేదా వైట్ 👻) అంచనా వేయడానికి లాజిస్టిక్ రిగ్రెషన్ మోడల్ నిర్మిద్దాం.\n",
"\n",
"> రిగ్రెషన్ గురించి ఉన్న పాఠం సమూహంలో ద్విభాగ వర్గీకరణ గురించి ఎందుకు మాట్లాడుతున్నాం? భాషా సౌలభ్యం కోసం మాత్రమే, ఎందుకంటే లాజిస్టిక్ రిగ్రెషన్ [నిజానికి వర్గీకరణ పద్ధతి](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), అయినప్పటికీ ఇది లీనియర్ ఆధారితది. తదుపరి పాఠం సమూహంలో డేటాను వర్గీకరించే ఇతర మార్గాలను తెలుసుకోండి.\n",
"\n",
"ఈ పాఠం కోసం, క్రింది ప్యాకేజీలు అవసరం:\n",
"\n",
"- `tidyverse`: [tidyverse](https://www.tidyverse.org/) అనేది డేటా సైన్స్‌ను వేగవంతం, సులభం మరియు మరింత సరదాగా చేయడానికి రూపొందించిన [R ప్యాకేజీల సేకరణ](https://www.tidyverse.org/packages)!\n",
"\n",
"- `tidymodels`: [tidymodels](https://www.tidymodels.org/) ఫ్రేమ్‌వర్క్ అనేది మోడలింగ్ మరియు మెషీన్ లెర్నింగ్ కోసం [ప్యాకేజీల సేకరణ](https://www.tidymodels.org/packages/)!\n",
"\n",
"- `janitor`: [janitor ప్యాకేజీ](https://github.com/sfirke/janitor) మురికి డేటాను పరిశీలించడానికి మరియు శుభ్రం చేయడానికి సులభమైన సాధనాలు అందిస్తుంది.\n",
"\n",
"- `ggbeeswarm`: [ggbeeswarm ప్యాకేజీ](https://github.com/eclarke/ggbeeswarm) ggplot2 ఉపయోగించి బీస్వార్మ్-స్టైల్ ప్లాట్లను సృష్టించడానికి పద్ధతులు అందిస్తుంది.\n",
"\n",
"మీరు వాటిని ఇన్‌స్టాల్ చేసుకోవచ్చు:\n",
"\n",
"`install.packages(c(\"tidyverse\", \"tidymodels\", \"janitor\", \"ggbeeswarm\"))`\n",
"\n",
"వేరే విధంగా, క్రింది స్క్రిప్ట్ ఈ మాడ్యూల్ పూర్తి చేయడానికి అవసరమైన ప్యాకేజీలు మీ వద్ద ఉన్నాయా లేదా అని తనిఖీ చేసి, లేనప్పుడు వాటిని ఇన్‌స్టాల్ చేస్తుంది.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"suppressWarnings(if (!require(\"pacman\"))install.packages(\"pacman\"))\n",
"\n",
"pacman::p_load(tidyverse, tidymodels, janitor, ggbeeswarm)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## **ప్రశ్నను నిర్వచించండి**\n",
"\n",
"మా ప్రయోజనాల కోసం, దీన్ని బైనరీగా వ్యక్తం చేస్తాము: 'తెల్ల' లేదా 'తెల్ల కాదు'. మా డేటాసెట్‌లో 'పట్టుదల' అనే వర్గం కూడా ఉంది కానీ దాని ఉదాహరణలు చాలా తక్కువగా ఉన్నందున, దాన్ని ఉపయోగించము. డేటాసెట్ నుండి నల్ విలువలను తీసివేస్తే అది కనుమరుగవుతుంది.\n",
"\n",
"> 🎃 సరదా విషయం, మేము కొన్నిసార్లు తెల్ల పండ్లను 'భూతం' పండ్లుగా పిలుస్తాము. అవి తీయడం చాలా సులభం కాదు, అందువల్ల అవి ఆరెంజ్ పండ్లంతా ప్రాచుర్యం పొందలేదు కానీ అవి చల్లగా కనిపిస్తాయి! కాబట్టి మేము మా ప్రశ్నను ఇలా కూడా పునఃరూపకల్పన చేయవచ్చు: 'భూతం' లేదా 'భూతం కాదు'. 👻\n",
"\n",
"## **లాజిస్టిక్ రిగ్రెషన్ గురించి**\n",
"\n",
"లాజిస్టిక్ రిగ్రెషన్, మీరు ముందుగా నేర్చుకున్న లీనియర్ రిగ్రెషన్ నుండి కొన్ని ముఖ్యమైన మార్గాల్లో భిన్నంగా ఉంటుంది.\n",
"\n",
"#### **బైనరీ వర్గీకరణ**\n",
"\n",
"లాజిస్టిక్ రిగ్రెషన్ లీనియర్ రిగ్రెషన్ వంటి లక్షణాలను అందించదు. ముందటి ఒక `బైనరీ వర్గం` (\"ఆరెంజ్ లేదా ఆరెంజ్ కాదు\") గురించి అంచనాను అందిస్తుంది, అయితే తర్వాతి `కొనసాగుతున్న విలువలను` అంచనా వేయగలదు, ఉదాహరణకు పండ్ల ఉత్పత్తి ప్రాంతం మరియు కోత సమయం ఇచ్చినప్పుడు, *దాని ధర ఎంత పెరుగుతుంది*.\n",
"\n",
"![Infographic by Dasani Madipalli](../../../../../../translated_images/pumpkin-classifier.562771f104ad5436b87d1c67bca02a42a17841133556559325c0a0e348e5b774.te.png)\n",
"\n",
"### ఇతర వర్గీకరణలు\n",
"\n",
"మల్టినోమియల్ మరియు ఆర్డినల్ సహా ఇతర రకాల లాజిస్టిక్ రిగ్రెషన్ ఉన్నాయి:\n",
"\n",
"- **మల్టినోమియల్**, ఇది ఒక కంటే ఎక్కువ వర్గాలు కలిగి ఉంటుంది - \"ఆరెంజ్, తెల్ల, మరియు పట్టుదల\".\n",
"\n",
"- **ఆర్డినల్**, ఇది క్రమబద్ధమైన వర్గాలను కలిగి ఉంటుంది, మన ఫలితాలను తార్కికంగా క్రమబద్ధీకరించాలనుకుంటే ఉపయోగపడుతుంది, ఉదాహరణకు మన పండ్లు పరిమాణాల పరిమిత సంఖ్య (మినీ, చిన్న, మధ్య, పెద్ద, ఎక్స్ ఎల్, ఎక్స్ ఎక్స్ ఎల్) ద్వారా క్రమబద్ధీకరించబడ్డాయి.\n",
"\n",
"![Multinomial vs ordinal regression](../../../../../../translated_images/multinomial-vs-ordinal.36701b4850e37d86c9dd49f7bef93a2f94dbdb8fe03443eb68f0542f97f28f29.te.png)\n",
"\n",
"#### **వేరియబుల్స్ అనుసంధానం అవసరం లేదు**\n",
"\n",
"లీనియర్ రిగ్రెషన్ ఎక్కువ అనుసంధానమైన వేరియబుల్స్‌తో మెరుగ్గా పనిచేస్తుందని గుర్తుంచుకోండి? లాజిస్టిక్ రిగ్రెషన్ మాత్రం విరుద్ధం - వేరియబుల్స్ సరిపోవాల్సిన అవసరం లేదు. ఇది కొంతమేర బలహీన అనుసంధానాలు ఉన్న ఈ డేటాకు సరిపోతుంది.\n",
"\n",
"#### **మీకు చాలా శుభ్రమైన డేటా అవసరం**\n",
"\n",
"లాజిస్టిక్ రిగ్రెషన్ ఎక్కువ డేటా ఉపయోగిస్తే మరింత ఖచ్చితమైన ఫలితాలను ఇస్తుంది; మా చిన్న డేటాసెట్ ఈ పనికి అనుకూలం కాదు, కాబట్టి దాన్ని గమనించండి.\n",
"\n",
"✅ లాజిస్టిక్ రిగ్రెషన్‌కు బాగా సరిపోయే డేటా రకాల గురించి ఆలోచించండి\n",
"\n",
"## వ్యాయామం - డేటాను శుభ్రం చేయండి\n",
"\n",
"ముందుగా, డేటాను కొంత శుభ్రం చేయండి, నల్ విలువలను తీసివేసి కొన్ని కాలమ్స్ మాత్రమే ఎంచుకోండి:\n",
"\n",
"1. క్రింది కోడ్‌ను జోడించండి:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Load the core tidyverse packages\n",
"library(tidyverse)\n",
"\n",
"# Import the data and clean column names\n",
"pumpkins <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/2-Regression/data/US-pumpkins.csv\") %>% \n",
" clean_names()\n",
"\n",
"# Select desired columns\n",
"pumpkins_select <- pumpkins %>% \n",
" select(c(city_name, package, variety, origin, item_size, color)) \n",
"\n",
"# Drop rows containing missing values and encode color as factor (category)\n",
"pumpkins_select <- pumpkins_select %>% \n",
" drop_na() %>% \n",
" mutate(color = factor(color))\n",
"\n",
"# View the first few rows\n",
"pumpkins_select %>% \n",
" slice_head(n = 5)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"మీ కొత్త డేటాఫ్రేమ్‌ను ఎప్పుడైనా ఒకసారి చూడవచ్చు, క్రింద చూపినట్లుగా [*glimpse()*](https://pillar.r-lib.org/reference/glimpse.html) ఫంక్షన్‌ను ఉపయోగించి:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"pumpkins_select %>% \n",
" glimpse()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"మనం నిజంగా బైనరీ వర్గీకరణ సమస్యను చేయబోతున్నామనే దాన్ని నిర్ధారిద్దాం:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Subset distinct observations in outcome column\n",
"pumpkins_select %>% \n",
" distinct(color)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### విజువలైజేషన్ - వర్గీకృత ప్లాట్\n",
"ఇప్పటికే మీరు మళ్లీ పంప్కిన్ డేటాను లోడ్ చేసి, కొన్ని వేరియబుల్స్‌ను, వాటిలో కలర్‌ను కూడా కలిగి ఉన్న డేటాసెట్‌ను సంరక్షించడానికి శుభ్రపరిచారు. ggplot లైబ్రరీని ఉపయోగించి నోట్‌బుక్‌లో డేటాఫ్రేమ్‌ను విజువలైజ్ చేద్దాం.\n",
"\n",
"ggplot లైబ్రరీ మీ డేటాను విజువలైజ్ చేయడానికి కొన్ని చక్కటి మార్గాలను అందిస్తుంది. ఉదాహరణకు, మీరు వర్గీకృత ప్లాట్‌లో ప్రతి Variety మరియు Color కోసం డేటా పంపిణీలను పోల్చవచ్చు.\n",
"\n",
"1. geombar ఫంక్షన్‌ను ఉపయోగించి, మా పంప్కిన్ డేటాను ఉపయోగించి, ప్రతి పంప్కిన్ వర్గం (ఆరెంజ్ లేదా వైట్) కోసం కలర్ మ్యాపింగ్‌ను నిర్దేశిస్తూ అలాంటి ప్లాట్‌ను సృష్టించండి:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "python"
}
},
"outputs": [],
"source": [
"# Specify colors for each value of the hue variable\n",
"palette <- c(ORANGE = \"orange\", WHITE = \"wheat\")\n",
"\n",
"# Create the bar plot\n",
"ggplot(pumpkins_select, aes(y = variety, fill = color)) +\n",
" geom_bar(position = \"dodge\") +\n",
" scale_fill_manual(values = palette) +\n",
" labs(y = \"Variety\", fill = \"Color\") +\n",
" theme_minimal()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"డేటాను పరిశీలించడం ద్వారా, మీరు కలర్ డేటా వేరైటీకి ఎలా సంబంధించిందో చూడవచ్చు.\n",
"\n",
"✅ ఈ వర్గీకరణ ప్లాట్ ఇచ్చినప్పుడు, మీరు ఊహించగల కొన్ని ఆసక్తికరమైన అన్వేషణలు ఏమిటి?\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### డేటా ప్రీ-ప్రాసెసింగ్: ఫీచర్ ఎంకోడింగ్\n",
"\n",
"మన పంప్కిన్స్ డేటాసెట్‌లో అన్ని కాలమ్స్‌కు స్ట్రింగ్ విలువలు ఉన్నాయి. వర్గీకృత డేటాతో పని చేయడం మనుషులకు సులభం కానీ యంత్రాలకు కాదు. యంత్ర అభ్యాస అల్గోరిథమ్స్ సంఖ్యలతో బాగా పనిచేస్తాయి. అందుకే ఎంకోడింగ్ డేటా ప్రీ-ప్రాసెసింగ్ దశలో చాలా ముఖ్యమైన దశ, ఎందుకంటే ఇది వర్గీకృత డేటాను సంఖ్యాత్మక డేటాగా మార్చడానికి సహాయపడుతుంది, ఎలాంటి సమాచారం కోల్పోకుండా. మంచి ఎంకోడింగ్ మంచి మోడల్ నిర్మాణానికి దారితీస్తుంది.\n",
"\n",
"ఫీచర్ ఎంకోడింగ్ కోసం రెండు ప్రధాన రకాల ఎంకోడర్లు ఉన్నాయి:\n",
"\n",
"1. ఆర్డినల్ ఎంకోడర్: ఇది ఆర్డినల్ వేరియబుల్స్‌కు బాగా సరిపోతుంది, ఇవి వర్గీకృత వేరియబుల్స్, వాటి డేటా తార్కిక క్రమాన్ని అనుసరిస్తుంది, మన డేటాసెట్‌లోని `item_size` కాలమ్ లాగా. ఇది ప్రతి వర్గాన్ని ఒక సంఖ్యతో ప్రతినిధ్యం చేస్తుంది, అది ఆ వర్గం కాలమ్‌లో ఉన్న క్రమం.\n",
"\n",
"2. వర్గీకృత ఎంకోడర్: ఇది నామినల్ వేరియబుల్స్‌కు బాగా సరిపోతుంది, ఇవి వర్గీకృత వేరియబుల్స్, వాటి డేటా తార్కిక క్రమాన్ని అనుసరించదు, మన డేటాసెట్‌లో `item_size` తప్ప అన్ని ఫీచర్ల లాగా. ఇది వన్-హాట్ ఎంకోడింగ్, అంటే ప్రతి వర్గం ఒక బైనరీ కాలమ్‌తో ప్రతినిధ్యం చేయబడుతుంది: ఎంకోడెడ్ వేరియబుల్ 1 అవుతుంది ఆ పంప్కిన్ ఆ వేరియటీకి చెందితే, లేకపోతే 0.\n",
"\n",
"Tidymodels మరో మంచి ప్యాకేజీని అందిస్తుంది: [recipes](https://recipes.tidymodels.org/) - డేటాను ప్రీప్రాసెస్ చేయడానికి ప్యాకేజీ. మనం ఒక `recipe` నిర్వచిస్తాము, ఇది అన్ని ప్రిడిక్టర్ కాలమ్స్‌ను ఒక సెట్ సంఖ్యలుగా ఎంకోడ్ చేయాలని సూచిస్తుంది, `prep` ద్వారా అవసరమైన పరిమాణాలు మరియు గణాంకాలను అంచనా వేస్తుంది, చివరగా `bake` ద్వారా కొత్త డేటాకు ఆ గణనలను వర్తింపజేస్తుంది.\n",
"\n",
"> సాధారణంగా, recipes మోడలింగ్ కోసం ప్రీప్రాసెసర్‌గా ఉపయోగిస్తారు, ఇది డేటా సెట్‌పై ఏ దశలు వర్తించాలో నిర్వచిస్తుంది, మోడలింగ్‌కు సిద్ధం చేయడానికి. ఆ సందర్భంలో మీరు `workflow()` ఉపయోగించడం **అత్యంత సిఫార్సు** చేయబడుతుంది, మానవీయంగా prep మరియు bake ఉపయోగించి recipe అంచనా వేయడం కాకుండా. మనం ఈ విషయాలను కొద్దిసేపట్లో చూడబోతున్నాము.\n",
">\n",
"> అయితే ఇప్పటికీ, మనం recipes + prep + bake ఉపయోగించి డేటా విశ్లేషణకు సిద్ధం చేయడానికి ఏ దశలు వర్తించాలో సూచిస్తున్నాము, ఆ దశలు వర్తించిన ప్రీప్రాసెస్ చేసిన డేటాను తీసుకోవడానికి.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Preprocess and extract data to allow some data analysis\n",
"baked_pumpkins <- recipe(color ~ ., data = pumpkins_select) %>%\n",
" # Define ordering for item_size column\n",
" step_mutate(item_size = ordered(item_size, levels = c('sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo'))) %>%\n",
" # Convert factors to numbers using the order defined above (Ordinal encoding)\n",
" step_integer(item_size, zero_based = F) %>%\n",
" # Encode all other predictors using one hot encoding\n",
" step_dummy(all_nominal(), -all_outcomes(), one_hot = TRUE) %>%\n",
" prep(data = pumpkin_select) %>%\n",
" bake(new_data = NULL)\n",
"\n",
"# Display the first few rows of preprocessed data\n",
"baked_pumpkins %>% \n",
" slice_head(n = 5)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"✅ ఐటెమ్ సైజ్ కాలమ్ కోసం ఆర్డినల్ ఎంకోడర్ ఉపయోగించడంలో有哪些 లాభాలు?\n",
"\n",
"### వేరియబుల్స్ మధ్య సంబంధాలను విశ్లేషించండి\n",
"\n",
"ఇప్పుడు మనం మన డేటాను ప్రీ-ప్రాసెస్ చేసినందున, ఫీచర్లు మరియు లేబుల్ మధ్య సంబంధాలను విశ్లేషించి, ఫీచర్లు ఇచ్చినప్పుడు మోడల్ లేబుల్‌ను ఎంత బాగా అంచనా వేయగలదో అర్థం చేసుకోవచ్చు. ఈ రకమైన విశ్లేషణను చేయడానికి ఉత్తమ మార్గం డేటాను ప్లాట్ చేయడం. \n",
"మనం మళ్లీ ggplot geom_boxplot_ ఫంక్షన్‌ను ఉపయోగించి, ఐటెమ్ సైజ్, వైవిధ్యం మరియు రంగు మధ్య సంబంధాలను వర్గీకృత ప్లాట్‌లో చూడబోతున్నాము. డేటాను మెరుగ్గా ప్లాట్ చేయడానికి, మనం ఎంకోడెడ్ ఐటెమ్ సైజ్ కాలమ్ మరియు ఎంకోడెడ్ కాని వైవిధ్యం కాలమ్‌ను ఉపయోగించబోతున్నాము.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Define the color palette\n",
"palette <- c(ORANGE = \"orange\", WHITE = \"wheat\")\n",
"\n",
"# We need the encoded Item Size column to use it as the x-axis values in the plot\n",
"pumpkins_select_plot<-pumpkins_select\n",
"pumpkins_select_plot$item_size <- baked_pumpkins$item_size\n",
"\n",
"# Create the grouped box plot\n",
"ggplot(pumpkins_select_plot, aes(x = `item_size`, y = color, fill = color)) +\n",
" geom_boxplot() +\n",
" facet_grid(variety ~ ., scales = \"free_x\") +\n",
" scale_fill_manual(values = palette) +\n",
" labs(x = \"Item Size\", y = \"\") +\n",
" theme_minimal() +\n",
" theme(strip.text = element_text(size = 12)) +\n",
" theme(axis.text.x = element_text(size = 10)) +\n",
" theme(axis.title.x = element_text(size = 12)) +\n",
" theme(axis.title.y = element_blank()) +\n",
" theme(legend.position = \"bottom\") +\n",
" guides(fill = guide_legend(title = \"Color\")) +\n",
" theme(panel.spacing = unit(0.5, \"lines\"))+\n",
" theme(strip.text.y = element_text(size = 4, hjust = 0)) \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### స్వార్మ్ ప్లాట్ ఉపయోగించండి\n",
"\n",
"రంగు ఒక ద్విముఖి వర్గం (తెల్లటి లేదా కాదు) కావడంతో, దాన్ని విజువలైజేషన్ కోసం 'ఒక [ప్రత్యేక విధానం](https://github.com/rstudio/cheatsheets/blob/main/data-visualization.pdf)' అవసరం.\n",
"\n",
"రంగు మరియు item_size సంబంధిత పంపిణీని చూపించడానికి `swarm plot` ప్రయత్నించండి.\n",
"\n",
"మేము [ggbeeswarm ప్యాకేజ్](https://github.com/eclarke/ggbeeswarm) ఉపయోగించబోతున్నాము, ఇది ggplot2 ఉపయోగించి బీస్వార్మ్-శైలి ప్లాట్లను సృష్టించడానికి పద్ధతులను అందిస్తుంది. బీస్వార్మ్ ప్లాట్లు సాధారణంగా ఒకదానితో ఒకటి ముడిపడే పాయింట్లను పక్కపక్కన పడేలా చూపించే విధానం.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Create beeswarm plots of color and item_size\n",
"baked_pumpkins %>% \n",
" mutate(color = factor(color)) %>% \n",
" ggplot(mapping = aes(x = color, y = item_size, color = color)) +\n",
" geom_quasirandom() +\n",
" scale_color_brewer(palette = \"Dark2\", direction = -1) +\n",
" theme(legend.position = \"none\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ఇప్పుడు మనకు రంగు యొక్క ద్విభాగ వర్గాలు మరియు పెద్ద పరిమాణాల సమూహం మధ్య సంబంధం గురించి ఒక ఆలోచన ఉన్నందున, ఒక నిర్దిష్ట పంప్కిన్ యొక్క సాధ్యమైన రంగును నిర్ణయించడానికి లాజిస్టిక్ రిగ్రెషన్‌ను పరిశీలిద్దాం.\n",
"\n",
"## మీ మోడల్‌ను నిర్మించండి\n",
"\n",
"మీ వర్గీకరణ మోడల్‌లో ఉపయోగించాలనుకునే వేరియబుల్స్‌ను ఎంచుకుని, డేటాను శిక్షణ మరియు పరీక్ష సెట్లుగా విభజించండి. [rsample](https://rsample.tidymodels.org/), Tidymodels‌లో ఒక ప్యాకేజ్, సమర్థవంతమైన డేటా విభజన మరియు రీసాంప్లింగ్ కోసం మౌలిక సదుపాయాలను అందిస్తుంది:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Split data into 80% for training and 20% for testing\n",
"set.seed(2056)\n",
"pumpkins_split <- pumpkins_select %>% \n",
" initial_split(prop = 0.8)\n",
"\n",
"# Extract the data in each split\n",
"pumpkins_train <- training(pumpkins_split)\n",
"pumpkins_test <- testing(pumpkins_split)\n",
"\n",
"# Print out the first 5 rows of the training set\n",
"pumpkins_train %>% \n",
" slice_head(n = 5)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"🙌 మేము ఇప్పుడు శిక్షణ ఫీచర్లను శిక్షణ లేబుల్ (రంగు) కు సరిపోల్చడం ద్వారా ఒక మోడల్‌ను శిక్షణ ఇవ్వడానికి సిద్ధంగా ఉన్నాము.\n",
"\n",
"మోడలింగ్‌కు సిద్ధం చేసుకోవడానికి మా డేటాపై నిర్వహించాల్సిన ప్రీప్రాసెసింగ్ దశలను నిర్దేశించే ఒక రెసిపీని సృష్టించడం ప్రారంభిస్తాము అంటే: వర్గీకృత వేరియబుల్స్‌ను ఒక సెట్ ఇంటిజర్లుగా ఎంకోడ్ చేయడం. `baked_pumpkins` లాగా, మేము ఒక `pumpkins_recipe` సృష్టిస్తాము కానీ దాన్ని `prep` మరియు `bake` చేయము ఎందుకంటే అది ఒక వర్క్‌ఫ్లోలో బండిల్ చేయబడుతుంది, మీరు కొన్ని దశలలోనే చూడబోతున్నారు.\n",
"\n",
"Tidymodels లో లాజిస్టిక్ రిగ్రెషన్ మోడల్‌ను నిర్దేశించడానికి అనేక మార్గాలు ఉన్నాయి. `?logistic_reg()` చూడండి. ప్రస్తుతానికి, మేము డిఫాల్ట్ `stats::glm()` ఇంజిన్ ద్వారా లాజిస్టిక్ రిగ్రెషన్ మోడల్‌ను నిర్దేశిస్తాము.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Create a recipe that specifies preprocessing steps for modelling\n",
"pumpkins_recipe <- recipe(color ~ ., data = pumpkins_train) %>% \n",
" step_mutate(item_size = ordered(item_size, levels = c('sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo'))) %>%\n",
" step_integer(item_size, zero_based = F) %>% \n",
" step_dummy(all_nominal(), -all_outcomes(), one_hot = TRUE)\n",
"\n",
"# Create a logistic model specification\n",
"log_reg <- logistic_reg() %>% \n",
" set_engine(\"glm\") %>% \n",
" set_mode(\"classification\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ఇప్పుడు మనకు ఒక రెసిపీ మరియు ఒక మోడల్ స్పెసిఫికేషన్ ఉన్నప్పుడు, వాటిని ఒక ఆబ్జెక్ట్‌గా బండిల్ చేయడానికి ఒక మార్గాన్ని కనుగొనాలి, ఇది మొదట డేటాను ప్రీప్రాసెస్ చేస్తుంది (ప్రీప్+బేక్ వెనుకన ఉన్నవి), ప్రీప్రాసెస్ చేసిన డేటాపై మోడల్‌ను ఫిట్ చేస్తుంది మరియు పోస్ట్-ప్రాసెసింగ్ కార్యకలాపాలకు కూడా అనుమతిస్తుంది.\n",
"\n",
"Tidymodelsలో, ఈ సౌకర్యవంతమైన ఆబ్జెక్ట్‌ను [`workflow`](https://workflows.tidymodels.org/) అని పిలుస్తారు మరియు ఇది మీ మోడలింగ్ భాగాలను సౌకర్యవంతంగా కలిగి ఉంటుంది.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Bundle modelling components in a workflow\n",
"log_reg_wf <- workflow() %>% \n",
" add_recipe(pumpkins_recipe) %>% \n",
" add_model(log_reg)\n",
"\n",
"# Print out the workflow\n",
"log_reg_wf\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ఒక వర్క్‌ఫ్లో *నిర్దేశించబడిన* తర్వాత, ఒక మోడల్‌ను [`fit()`](https://tidymodels.github.io/parsnip/reference/fit.html) ఫంక్షన్ ఉపయోగించి `శిక్షణ` ఇవ్వవచ్చు. వర్క్‌ఫ్లో ఒక రెసిపీని అంచనా వేస్తుంది మరియు శిక్షణకు ముందు డేటాను ప్రీప్రాసెస్ చేస్తుంది, కాబట్టి మనం prep మరియు bake ఉపయోగించి అది చేయాల్సిన అవసరం ఉండదు.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Train the model\n",
"wf_fit <- log_reg_wf %>% \n",
" fit(data = pumpkins_train)\n",
"\n",
"# Print the trained workflow\n",
"wf_fit\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"మోడల్ ప్రింట్ అవుట్ శిక్షణ సమయంలో నేర్చుకున్న గుణకాలను చూపిస్తుంది.\n",
"\n",
"ఇప్పుడు మేము శిక్షణ డేటాను ఉపయోగించి మోడల్‌ను శిక్షణ ఇచ్చినందున, [parsnip::predict()](https://parsnip.tidymodels.org/reference/predict.model_fit.html) ఉపయోగించి పరీక్షా డేటాపై అంచనాలు చేయవచ్చు. మన పరీక్షా సెట్ కోసం లేబుల్స్ మరియు ప్రతి లేబుల్ కోసం సంభావ్యతలను అంచనా వేయడానికి మోడల్‌ను ఉపయోగించడం ప్రారంభిద్దాం. సంభావ్యత 0.5 కంటే ఎక్కువగా ఉన్నప్పుడు, అంచనా తరగతి `WHITE` అవుతుంది, లేకపోతే `ORANGE`.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Make predictions for color and corresponding probabilities\n",
"results <- pumpkins_test %>% select(color) %>% \n",
" bind_cols(wf_fit %>% \n",
" predict(new_data = pumpkins_test)) %>%\n",
" bind_cols(wf_fit %>%\n",
" predict(new_data = pumpkins_test, type = \"prob\"))\n",
"\n",
"# Compare predictions\n",
"results %>% \n",
" slice_head(n = 10)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"చాలా బాగుంది! ఇది లాజిస్టిక్ రిగ్రెషన్ ఎలా పనిచేస్తుందో మరింత అవగాహనను అందిస్తుంది.\n",
"\n",
"### గందరగోళ మ్యాట్రిక్స్ ద్వారా మెరుగైన అవగాహన\n",
"\n",
"ప్రతి అంచనాను దాని సంబంధిత \"గ్రౌండ్ ట్రూత్\" వాస్తవ విలువతో పోల్చడం మోడల్ ఎంత బాగా అంచనా వేస్తుందో నిర్ణయించడానికి చాలా సమర్థవంతమైన మార్గం కాదు. అదృష్టవశాత్తు, Tidymodels వద్ద మరికొన్ని చిట్కాలు ఉన్నాయి: [`yardstick`](https://yardstick.tidymodels.org/) - పనితీరు ప్రమాణాలను ఉపయోగించి మోడల్స్ యొక్క సమర్థతను కొలవడానికి ఉపయోగించే ప్యాకేజ్.\n",
"\n",
"వర్గీకరణ సమస్యలకు సంబంధించిన ఒక పనితీరు ప్రమాణం [`confusion matrix`](https://wikipedia.org/wiki/Confusion_matrix). ఒక గందరగోళ మ్యాట్రిక్స్ వర్గీకరణ మోడల్ ఎంత బాగా పనిచేస్తుందో వివరిస్తుంది. ఒక గందరగోళ మ్యాట్రిక్స్ ప్రతి తరగతిలో ఎన్ని ఉదాహరణలు మోడల్ సరిగ్గా వర్గీకరించిందో పట్టిక రూపంలో చూపిస్తుంది. మన సందర్భంలో, ఇది ఎన్ని నారింజ పండ్లు నారింజగా వర్గీకరించబడ్డాయో మరియు ఎన్ని తెల్ల పండ్లు తెల్లగా వర్గీకరించబడ్డాయో చూపిస్తుంది; గందరగోళ మ్యాట్రిక్స్ మీరు ఎన్ని తప్పు వర్గాలలో వర్గీకరించబడ్డాయో కూడా చూపిస్తుంది.\n",
"\n",
"yardstick నుండి [**`conf_mat()`**](https://tidymodels.github.io/yardstick/reference/conf_mat.html) ఫంక్షన్ ఈ గమనించిన మరియు అంచనా వర్గాల క్రాస్-టాబ్యులేషన్‌ను లెక్కిస్తుంది.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Confusion matrix for prediction results\n",
"conf_mat(data = results, truth = color, estimate = .pred_class)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"మనం కాంఫ్యూజన్ మ్యాట్రిక్స్‌ను అర్థం చేసుకుందాం. మన మోడల్‌ను రెండు బైనరీ వర్గాలుగా పంప్కిన్లను వర్గీకరించమని అడిగారు, వర్గం `white` మరియు వర్గం `not-white`\n",
"\n",
"- మీ మోడల్ ఒక పంప్కిన్‌ను white గా అంచనా వేస్తే మరియు అది వాస్తవానికి 'white' వర్గానికి చెందితే, దాన్ని `true positive` అంటాము, ఇది పై ఎడమ సంఖ్య ద్వారా చూపబడుతుంది.\n",
"\n",
"- మీ మోడల్ ఒక పంప్కిన్‌ను not white గా అంచనా వేస్తే మరియు అది వాస్తవానికి 'white' వర్గానికి చెందితే, దాన్ని `false negative` అంటాము, ఇది కింద ఎడమ సంఖ్య ద్వారా చూపబడుతుంది.\n",
"\n",
"- మీ మోడల్ ఒక పంప్కిన్‌ను white గా అంచనా వేస్తే మరియు అది వాస్తవానికి 'not-white' వర్గానికి చెందితే, దాన్ని `false positive` అంటాము, ఇది పై కుడి సంఖ్య ద్వారా చూపబడుతుంది.\n",
"\n",
"- మీ మోడల్ ఒక పంప్కిన్‌ను not white గా అంచనా వేస్తే మరియు అది వాస్తవానికి 'not-white' వర్గానికి చెందితే, దాన్ని `true negative` అంటాము, ఇది కింద కుడి సంఖ్య ద్వారా చూపబడుతుంది.\n",
"\n",
"| Truth |\n",
"|:-----:|\n",
"\n",
"\n",
"| | | |\n",
"|---------------|--------|-------|\n",
"| **Predicted** | WHITE | ORANGE |\n",
"| WHITE | TP | FP |\n",
"| ORANGE | FN | TN |\n",
"\n",
"మీరు ఊహించినట్లుగా, ఎక్కువ true positives మరియు true negatives ఉండటం మంచిది, మరియు తక్కువ false positives మరియు false negatives ఉండటం మంచిది, ఇది మోడల్ మెరుగ్గా పనిచేస్తుందని సూచిస్తుంది.\n",
"\n",
"కాంఫ్యూజన్ మ్యాట్రిక్స్ ఉపయోగకరంగా ఉంటుంది ఎందుకంటే ఇది ఇతర మెట్రిక్స్‌కు దారి తీస్తుంది, ఇవి వర్గీకరణ మోడల్ పనితీరును మెరుగ్గా అంచనా వేయడంలో సహాయపడతాయి. వాటిలో కొన్ని ఇక్కడ ఉన్నాయి:\n",
"\n",
"🎓 Precision: `TP/(TP + FP)` ఇది అంచనా వేయబడిన పాజిటివ్స్‌లో వాస్తవానికి పాజిటివ్ అయిన వాటి భాగాన్ని నిర్వచిస్తుంది. దీనిని [positive predictive value](https://en.wikipedia.org/wiki/Positive_predictive_value \"Positive predictive value\") అని కూడా పిలుస్తారు.\n",
"\n",
"🎓 Recall: `TP/(TP + FN)` ఇది వాస్తవానికి పాజిటివ్ అయిన నమూనాల సంఖ్యలో నుండి పాజిటివ్ ఫలితాల భాగాన్ని నిర్వచిస్తుంది. దీనిని `sensitivity` అని కూడా పిలుస్తారు.\n",
"\n",
"🎓 Specificity: `TN/(TN + FP)` ఇది వాస్తవానికి నెగటివ్ అయిన నమూనాల సంఖ్యలో నుండి నెగటివ్ ఫలితాల భాగాన్ని నిర్వచిస్తుంది.\n",
"\n",
"🎓 Accuracy: `TP + TN/(TP + TN + FP + FN)` ఒక నమూనా కోసం సరిగ్గా అంచనా వేయబడిన లేబుల్స్ శాతం.\n",
"\n",
"🎓 F Measure: precision మరియు recall యొక్క బరువు సగటు, ఉత్తమం 1 మరియు చెత్తది 0.\n",
"\n",
"ఈ మెట్రిక్స్‌లను లెక్కించుకుందాం!\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Combine metric functions and calculate them all at once\n",
"eval_metrics <- metric_set(ppv, recall, spec, f_meas, accuracy)\n",
"eval_metrics(data = results, truth = color, estimate = .pred_class)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## ఈ మోడల్ యొక్క ROC వక్రాన్ని దృశ్యీకరించండి\n",
"\n",
"మనం మరొక దృశ్యీకరణ చేయబోతున్నాము, దీనిని [`ROC వక్రం`](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) అంటారు:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Make a roc_curve\n",
"results %>% \n",
" roc_curve(color, .pred_ORANGE) %>% \n",
" autoplot()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ROC వక్రరేఖలు తరచుగా ఒక వర్గీకర్త యొక్క అవుట్పుట్‌ను నిజమైన మరియు తప్పుడు పాజిటివ్‌ల పరంగా చూడటానికి ఉపయోగిస్తారు. ROC వక్రరేఖలు సాధారణంగా Y అక్షంపై `True Positive Rate`/సెన్సిటివిటీ మరియు X అక్షంపై `False Positive Rate`/1-స్పెసిఫిసిటీని చూపిస్తాయి. కాబట్టి, వక్రరేఖ యొక్క తిప్పట మరియు మధ్య రేఖ మరియు వక్రరేఖ మధ్య ఉన్న స్థలం ముఖ్యం: మీరు త్వరగా పైకి వెళ్లి రేఖను దాటే వక్రరేఖను కోరుకుంటారు. మన సందర్భంలో, మొదట తప్పుడు పాజిటివ్‌లు ఉంటాయి, ఆపై రేఖ సరిగ్గా పైకి వెళ్లి దాటుతుంది.\n",
"\n",
"చివరగా, వాస్తవంలో వక్రరేఖ క్రింద ప్రాంతాన్ని లెక్కించడానికి `yardstick::roc_auc()` ను ఉపయోగిద్దాం. AUC ని అర్థం చేసుకోవడానికి ఒక మార్గం ఏమిటంటే, మోడల్ యాదృచ్ఛిక పాజిటివ్ ఉదాహరణను యాదృచ్ఛిక నెగటివ్ ఉదాహరణ కంటే ఎక్కువ ర్యాంక్ చేసే అవకాశంగా భావించవచ్చు.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"vscode": {
"languageId": "r"
}
},
"outputs": [],
"source": [
"# Calculate area under curve\n",
"results %>% \n",
" roc_auc(color, .pred_ORANGE)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"ఫలితం సుమారు `0.975`. AUC 0 నుండి 1 వరకు ఉంటుందని, మీరు పెద్ద స్కోరు కావాలి, ఎందుకంటే 100% సరిగ్గా అంచనా వేయగల మోడల్‌కు AUC 1 ఉంటుంది; ఈ సందర్భంలో, మోడల్ *చాలా బాగుంది*.\n",
"\n",
"భవిష్యత్తు వర్గాల్లో వర్గీకరణలపై మీరు మీ మోడల్ స్కోర్లను ఎలా మెరుగుపరచాలో నేర్చుకుంటారు (ఈ సందర్భంలో అసమతుల్య డేటాతో ఎలా వ్యవహరించాలో).\n",
"\n",
"## 🚀సవాలు\n",
"\n",
"లాజిస్టిక్ రిగ్రెషన్ గురించి ఇంకా చాలా విషయాలు తెలుసుకోవాలి! కానీ నేర్చుకోవడానికి ఉత్తమ మార్గం అనుభవించడం. ఈ రకమైన విశ్లేషణకు అనువైన డేటాసెట్‌ను కనుగొని దానితో మోడల్ నిర్మించండి. మీరు ఏమి నేర్చుకుంటారు? సూచన: ఆసక్తికరమైన డేటాసెట్ల కోసం [Kaggle](https://www.kaggle.com/search?q=logistic+regression+datasets) ను ప్రయత్నించండి.\n",
"\n",
"## సమీక్ష & స్వీయ అధ్యయనం\n",
"\n",
"లాజిస్టిక్ రిగ్రెషన్ యొక్క కొన్ని ప్రాక్టికల్ ఉపయోగాలపై [స్టాన్‌ఫోర్డ్ నుండి ఈ పేపర్](https://web.stanford.edu/~jurafsky/slp3/5.pdf) మొదటి కొన్ని పేజీలను చదవండి. ఇప్పటి వరకు మనం అధ్యయనం చేసిన రిగ్రెషన్ పనులలో ఏది ఏ పనికి బాగా సరిపోతుందో ఆలోచించండి. ఏది ఉత్తమంగా పనిచేస్తుంది?\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
],
"metadata": {
"anaconda-cloud": "",
"kernelspec": {
"display_name": "R",
"langauge": "R",
"name": "ir"
},
"language_info": {
"codemirror_mode": "r",
"file_extension": ".r",
"mimetype": "text/x-r-source",
"name": "R",
"pygments_lexer": "r",
"version": "3.4.1"
},
"coopTranslator": {
"original_hash": "feaf125f481a89c468fa115bf2aed580",
"translation_date": "2025-12-19T16:39:14+00:00",
"source_file": "2-Regression/4-Logistic/solution/R/lesson_4-R.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 1
}

1261
translations/te/2-Regression/4-Logistic/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

56
translations/te/2-Regression/README.md
Unescape View File

@ -0,0 +1,56 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "508582278dbb8edd2a8a80ac96ef416c",
"translation_date": "2025-12-19T12:57:33+00:00",
"source_file": "2-Regression/README.md",
"language_code": "te"
}
-->
# మెషీన్ లెర్నింగ్ కోసం రిగ్రెషన్ మోడల్స్
## ప్రాంతీయ విషయం: ఉత్తర అమెరికాలో పంప్కిన్ ధరల కోసం రిగ్రెషన్ మోడల్స్ 🎃
ఉత్తర అమెరికాలో, హాలోవీన్ కోసం పంప్కిన్లను తరచుగా భయంకరమైన ముఖాలుగా కోసి తయారు చేస్తారు. ఈ ఆకర్షణీయమైన కూరగాయల గురించి మరింత తెలుసుకుందాం!
![jack-o-lanterns](../../../translated_images/jack-o-lanterns.181c661a9212457d7756f37219f660f1358af27554d856e5a991f16b4e15337c.te.jpg)
> ఫోటో <a href="https://unsplash.com/@teutschmann?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">బెత్ ట్యూట్ష్మాన్</a> ద్వారా <a href="https://unsplash.com/s/photos/jack-o-lanterns?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">అన్స్ప్లాష్</a> లో
## మీరు నేర్చుకునేది
[![Introduction to Regression](https://img.youtube.com/vi/5QnJtDad4iQ/0.jpg)](https://youtu.be/5QnJtDad4iQ "Regression Introduction video - Click to Watch!")
> 🎥 ఈ పాఠానికి త్వరిత పరిచయ వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి
ఈ విభాగంలోని పాఠాలు మెషీన్ లెర్నింగ్ సందర్భంలో రిగ్రెషన్ రకాల గురించి కవర్ చేస్తాయి. రిగ్రెషన్ మోడల్స్ వేరియబుల్స్ మధ్య _సంబంధం_ ను నిర్ణయించడంలో సహాయపడతాయి. ఈ రకం మోడల్ పొడవు, ఉష్ణోగ్రత లేదా వయస్సు వంటి విలువలను అంచనా వేయగలదు, కాబట్టి డేటా పాయింట్లను విశ్లేషిస్తూ వేరియబుల్స్ మధ్య సంబంధాలను కనుగొంటుంది.
ఈ పాఠాల సిరీస్‌లో, మీరు లీనియర్ మరియు లాజిస్టిక్ రిగ్రెషన్ మధ్య తేడాలను తెలుసుకుంటారు, మరియు ఎప్పుడు ఒకదాన్ని మరొకదానిపై ప్రాధాన్యం ఇవ్వాలో తెలుసుకుంటారు.
[![ML for beginners - Introduction to Regression models for Machine Learning](https://img.youtube.com/vi/XA3OaoW86R8/0.jpg)](https://youtu.be/XA3OaoW86R8 "ML for beginners - Introduction to Regression models for Machine Learning")
> 🎥 రిగ్రెషన్ మోడల్స్ పరిచయం చేసే చిన్న వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి.
ఈ పాఠాల సమూహంలో, మీరు మెషీన్ లెర్నింగ్ పనులను ప్రారంభించడానికి సెట్ అవుతారు, ఇందులో డేటా శాస్త్రవేత్తల సాధారణ వాతావరణం అయిన నోట్‌బుక్స్ నిర్వహణ కోసం విజువల్ స్టూడియో కోడ్‌ను కాన్ఫిగర్ చేయడం కూడా ఉంటుంది. మీరు మెషీన్ లెర్నింగ్ కోసం లైబ్రరీ అయిన స్కైకిట్-లెర్న్‌ను తెలుసుకుంటారు, మరియు ఈ అధ్యాయంలో రిగ్రెషన్ మోడల్స్‌పై దృష్టి పెట్టి మీ మొదటి మోడల్స్‌ను నిర్మిస్తారు.
> రిగ్రెషన్ మోడల్స్‌తో పని చేయడం గురించి నేర్చుకోవడానికి సహాయపడే ఉపయోగకరమైన లో-కోడ్ టూల్స్ ఉన్నాయి. ఈ పనికి [Azure ML ను ప్రయత్నించండి](https://docs.microsoft.com/learn/modules/create-regression-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
### పాఠాలు
1. [పని సాధనాలు](1-Tools/README.md)
2. [డేటా నిర్వహణ](2-Data/README.md)
3. [లీనియర్ మరియు పాలినోమియల్ రిగ్రెషన్](3-Linear/README.md)
4. [లాజిస్టిక్ రిగ్రెషన్](4-Logistic/README.md)
---
### క్రెడిట్స్
"ML with regression" ను ♥️ తో [జెన్ లూపర్](https://twitter.com/jenlooper) రాశారు
♥️ క్విజ్ సహకారులు: [ముహమ్మద్ సకీబ్ ఖాన్ ఇనాన్](https://twitter.com/Sakibinan) మరియు [ఒర్నెల్లా ఆల్టున్యాన్](https://twitter.com/ornelladotcom)
పంప్కిన్ డేటాసెట్‌ను [కాగుల్‌లో ఈ ప్రాజెక్ట్](https://www.kaggle.com/usda/a-year-of-pumpkin-prices) సూచించింది మరియు దాని డేటా యునైటెడ్ స్టేట్స్ డిపార్ట్‌మెంట్ ఆఫ్ అగ్రికల్చర్ పంపిణీ చేసే [స్పెషాల్టీ క్రాప్స్ టెర్మినల్ మార్కెట్స్ స్టాండర్డ్ రిపోర్ట్స్](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) నుండి తీసుకోబడింది. మేము వేరియటీ ఆధారంగా రంగు చుట్టూ కొన్ని పాయింట్లను జోడించి పంపిణీని సాధారణం చేసాము. ఈ డేటా పబ్లిక్ డొమైన్‌లో ఉంది.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం మంచిది. ఈ అనువాదం వలన కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల బాధ్యత మేము తీసుకోము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

361
translations/te/3-Web-App/1-Web-App/README.md
Unescape View File

@ -0,0 +1,361 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "e0b75f73e4a90d45181dc5581fe2ef5c",
"translation_date": "2025-12-19T14:11:15+00:00",
"source_file": "3-Web-App/1-Web-App/README.md",
"language_code": "te"
}
-->
# ML మోడల్ ఉపయోగించడానికి వెబ్ యాప్ నిర్మించండి
ఈ పాఠంలో, మీరు ఒక డేటా సెట్‌పై ML మోడల్‌ను శిక్షణ ఇస్తారు, ఇది ఈ ప్రపంచానికి చెందినది కాదు: _గత శతాబ్దంలో UFO దర్శనాలు_, NUFORC డేటాబేస్ నుండి సేకరించబడింది.
మీరు నేర్చుకుంటారు:
- శిక్షణ పొందిన మోడల్‌ను 'పికిల్' చేయడం ఎలా
- ఆ మోడల్‌ను Flask యాప్‌లో ఎలా ఉపయోగించాలి
మేము డేటాను శుభ్రపరచడానికి మరియు మా మోడల్‌ను శిక్షణ ఇవ్వడానికి నోట్‌బుక్స్‌ను ఉపయోగించడం కొనసాగిస్తాము, కానీ మీరు ఒక అడుగు ముందుకు తీసుకుని, ఒక మోడల్‌ను 'వనంలో' ఉపయోగించడం అన్వేషించవచ్చు: అంటే, వెబ్ యాప్‌లో.
ఇది చేయడానికి, మీరు Flask ఉపయోగించి ఒక వెబ్ యాప్‌ను నిర్మించాలి.
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## యాప్ నిర్మాణం
మెషీన్ లెర్నింగ్ మోడల్స్‌ను వినియోగించడానికి వెబ్ యాప్స్‌ను నిర్మించడానికి అనేక మార్గాలు ఉన్నాయి. మీ వెబ్ ఆర్కిటెక్చర్ మీ మోడల్ శిక్షణ విధానాన్ని ప్రభావితం చేయవచ్చు. మీరు ఒక వ్యాపారంలో పనిచేస్తున్నారని ఊహించుకోండి, అక్కడ డేటా సైన్స్ గ్రూప్ ఒక మోడల్‌ను శిక్షణ ఇచ్చింది, దాన్ని మీరు యాప్‌లో ఉపయోగించాలని కోరుకుంటున్నారు.
### పరిగణనలు
మీరు అడగవలసిన అనేక ప్రశ్నలు ఉన్నాయి:
- **ఇది వెబ్ యాప్ లేదా మొబైల్ యాప్?** మీరు మొబైల్ యాప్‌ను నిర్మిస్తున్నట్లయితే లేదా IoT సందర్భంలో మోడల్‌ను ఉపయోగించాల్సిన అవసరం ఉంటే, మీరు [TensorFlow Lite](https://www.tensorflow.org/lite/) ఉపయోగించి ఆండ్రాయిడ్ లేదా iOS యాప్‌లో మోడల్‌ను ఉపయోగించవచ్చు.
- **మోడల్ ఎక్కడ ఉంటుంది?** క్లౌడ్‌లోనా లేదా స్థానికంగా?
- **ఆఫ్లైన్ మద్దతు.** యాప్ ఆఫ్లైన్‌లో పనిచేయాలా?
- **మోడల్ శిక్షణకు ఏ సాంకేతికత ఉపయోగించబడింది?** ఎంచుకున్న సాంకేతికత మీరు ఉపయోగించాల్సిన టూలింగ్‌ను ప్రభావితం చేయవచ్చు.
- **TensorFlow ఉపయోగించడం.** ఉదాహరణకు, మీరు TensorFlow ఉపయోగించి మోడల్‌ను శిక్షణ ఇస్తున్నట్లయితే, ఆ ఎకోసిస్టమ్ [TensorFlow.js](https://www.tensorflow.org/js/) ఉపయోగించి వెబ్ యాప్‌లో ఉపయోగించడానికి TensorFlow మోడల్‌ను మార్చే సామర్థ్యాన్ని అందిస్తుంది.
- **PyTorch ఉపయోగించడం.** మీరు [PyTorch](https://pytorch.org/) వంటి లైబ్రరీ ఉపయోగించి మోడల్‌ను నిర్మిస్తుంటే, మీరు దాన్ని [ONNX](https://onnx.ai/) (Open Neural Network Exchange) ఫార్మాట్‌లో ఎగుమతి చేయవచ్చు, ఇది జావాస్క్రిప్ట్ వెబ్ యాప్స్‌లో ఉపయోగించడానికి [Onnx Runtime](https://www.onnxruntime.ai/) ఉపయోగించవచ్చు. ఈ ఎంపికను భవిష్యత్తు పాఠంలో Scikit-learn శిక్షణ పొందిన మోడల్ కోసం అన్వేషిస్తారు.
- **Lobe.ai లేదా Azure Custom Vision ఉపయోగించడం.** మీరు [Lobe.ai](https://lobe.ai/) లేదా [Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77952-leestott) వంటి ML SaaS (సాఫ్ట్‌వేర్ ఆజ్ ఎ సర్వీస్) వ్యవస్థను ఉపయోగించి మోడల్‌ను శిక్షణ ఇస్తుంటే, ఈ రకమైన సాఫ్ట్‌వేర్ అనేక ప్లాట్‌ఫారమ్‌లకు మోడల్‌ను ఎగుమతి చేయడానికి మార్గాలను అందిస్తుంది, మీ ఆన్‌లైన్ అప్లికేషన్ ద్వారా క్లౌడ్‌లో ప్రశ్నించదగిన ప్రత్యేక APIని కూడా నిర్మించవచ్చు.
మీకు ఒక పూర్తి Flask వెబ్ యాప్‌ను కూడా నిర్మించే అవకాశం ఉంది, ఇది వెబ్ బ్రౌజర్‌లోనే మోడల్‌ను శిక్షణ ఇస్తుంది. ఇది JavaScript సందర్భంలో TensorFlow.js ఉపయోగించి కూడా చేయవచ్చు.
మా ప్రయోజనాల కోసం, Python ఆధారిత నోట్‌బుక్స్‌తో పని చేస్తున్నందున, అలాంటి నోట్‌బుక్ నుండి శిక్షణ పొందిన మోడల్‌ను Python-నిర్మిత వెబ్ యాప్ చదవగల ఫార్మాట్‌కు ఎగుమతి చేయడానికి మీరు తీసుకోవలసిన దశలను అన్వేషిద్దాం.
## టూల్
ఈ పనికి, మీరు రెండు టూల్స్ అవసరం: Flask మరియు Pickle, ఇవి రెండూ Python పై నడుస్తాయి.
✅ [Flask](https://palletsprojects.com/p/flask/) అంటే ఏమిటి? దాని సృష్టికర్తలు 'మైక్రో-ఫ్రేమ్‌వర్క్'గా నిర్వచించిన Flask, Python మరియు టెంప్లేటింగ్ ఇంజిన్ ఉపయోగించి వెబ్ పేజీలను నిర్మించడానికి వెబ్ ఫ్రేమ్‌వర్క్‌ల ప్రాథమిక లక్షణాలను అందిస్తుంది. Flask తో నిర్మించడాన్ని అభ్యసించడానికి [ఈ Learn మాడ్యూల్](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-77952-leestott) చూడండి.
✅ [Pickle](https://docs.python.org/3/library/pickle.html) అంటే ఏమిటి? Pickle 🥒 అనేది Python మాడ్యూల్, ఇది Python ఆబ్జెక్ట్ నిర్మాణాన్ని సీరియలైజ్ మరియు డీసీరియలైజ్ చేస్తుంది. మీరు మోడల్‌ను 'పికిల్' చేస్తే, మీరు దాని నిర్మాణాన్ని వెబ్‌లో ఉపయోగించడానికి సీరియలైజ్ లేదా ఫ్లాటెన్ చేస్తారు. జాగ్రత్తగా ఉండండి: pickle స్వభావంగా సురక్షితం కాదు, కాబట్టి ఫైల్‌ను 'అన్-పికిల్' చేయమని అడిగితే జాగ్రత్తగా ఉండండి. పికిల్ చేసిన ఫైల్‌కు `.pkl` అనే సఫిక్స్ ఉంటుంది.
## వ్యాయామం - మీ డేటాను శుభ్రపరచండి
ఈ పాఠంలో మీరు [NUFORC](https://nuforc.org) (నేషనల్ UFO రిపోర్టింగ్ సెంటర్) సేకరించిన 80,000 UFO దర్శనాల డేటాను ఉపయోగిస్తారు. ఈ డేటాలో UFO దర్శనాల కొన్ని ఆసక్తికర వివరణలు ఉన్నాయి, ఉదాహరణకు:
- **విస్తృత ఉదాహరణ వివరణ.** "రాత్రి గడ్డి పొలంపై ప్రకాశించే కాంతి కిరణం నుండి ఒక మనిషి బయటకు వస్తాడు మరియు టెక్సాస్ ఇన్స్ట్రుమెంట్స్ పార్కింగ్ లాట్ వైపు పరుగెత్తుతాడు".
- **సంక్షిప్త ఉదాహరణ వివరణ.** "లైట్లు మమ్మల్ని వెంబడించాయి".
[ufos.csv](../../../../3-Web-App/1-Web-App/data/ufos.csv) స్ప్రెడ్షీట్‌లో `city`, `state` మరియు `country` గురించి కాలమ్స్ ఉన్నాయి, అక్కడ దర్శనం జరిగింది, ఆ వస్తువు యొక్క `shape` మరియు దాని `latitude` మరియు `longitude`.
ఈ పాఠంలో చేర్చబడిన ఖాళీ [నోట్‌బుక్](notebook.ipynb)లో:
1. మీరు గత పాఠాలలో చేసినట్లుగా `pandas`, `matplotlib`, మరియు `numpy` ను దిగుమతి చేసుకుని ufos స్ప్రెడ్షీట్‌ను దిగుమతి చేసుకోండి. మీరు ఒక నమూనా డేటా సెట్‌ను చూడవచ్చు:
```python
import pandas as pd
import numpy as np
ufos = pd.read_csv('./data/ufos.csv')
ufos.head()
```
1. ufos డేటాను కొత్త శీర్షికలతో చిన్న డేటాఫ్రేమ్‌గా మార్చండి. `Country` ఫీల్డ్‌లో ఉన్న ప్రత్యేక విలువలను తనిఖీ చేయండి.
```python
ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
ufos.Country.unique()
```
1. ఇప్పుడు, మనం వ్యవహరించాల్సిన డేటా పరిమాణాన్ని తగ్గించడానికి ఏ null విలువలైనా తొలగించి, 1-60 సెకన్ల మధ్య ఉన్న దర్శనాలను మాత్రమే దిగుమతి చేసుకోండి:
```python
ufos.dropna(inplace=True)
ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
ufos.info()
```
1. దేశాల కోసం టెక్స్ట్ విలువలను సంఖ్యగా మార్చడానికి Scikit-learn యొక్క `LabelEncoder` లైబ్రరీని దిగుమతి చేసుకోండి:
✅ LabelEncoder డేటాను అక్షరాల క్రమంలో ఎంకోడ్ చేస్తుంది
```python
from sklearn.preprocessing import LabelEncoder
ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
ufos.head()
```
మీ డేటా ఇలా కనిపించాలి:
```output
Seconds Country Latitude Longitude
2 20.0 3 53.200000 -2.916667
3 20.0 4 28.978333 -96.645833
14 30.0 4 35.823889 -80.253611
23 60.0 4 45.582778 -122.352222
24 3.0 3 51.783333 -0.783333
```
## వ్యాయామం - మీ మోడల్‌ను నిర్మించండి
ఇప్పుడు మీరు శిక్షణ మరియు పరీక్షా సమూహాలుగా డేటాను విభజించి మోడల్ శిక్షణకు సిద్ధం కావచ్చు.
1. మీరు శిక్షణ ఇవ్వదలచుకున్న మూడు లక్షణాలను X వెక్టర్‌గా ఎంచుకోండి, మరియు y వెక్టర్ `Country` అవుతుంది. మీరు `Seconds`, `Latitude` మరియు `Longitude` ను ఇన్‌పుట్‌గా ఇచ్చి దేశ ID ను పొందగలగాలి.
```python
from sklearn.model_selection import train_test_split
Selected_features = ['Seconds','Latitude','Longitude']
X = ufos[Selected_features]
y = ufos['Country']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
1. లాజిస్టిక్ రిగ్రెషన్ ఉపయోగించి మీ మోడల్‌ను శిక్షణ ఇవ్వండి:
```python
from sklearn.metrics import accuracy_score, classification_report
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(classification_report(y_test, predictions))
print('Predicted labels: ', predictions)
print('Accuracy: ', accuracy_score(y_test, predictions))
```
ఖచ్చితత్వం చెడుగా లేదు **(సుమారు 95%)**, ఆశ్చర్యకరం కాదు, ఎందుకంటే `Country` మరియు `Latitude/Longitude` పరస్పరం సంబంధం కలిగి ఉంటాయి.
మీరు సృష్టించిన మోడల్ చాలా విప్లవాత్మకంగా లేదు, ఎందుకంటే మీరు దాని `Latitude` మరియు `Longitude` నుండి ఒక `Country` ను అంచనా వేయగలరు, కానీ ఇది మీరు శుభ్రపరిచిన, ఎగుమతి చేసిన ముడి డేటా నుండి శిక్షణ ఇస్తూ, ఆ మోడల్‌ను వెబ్ యాప్‌లో ఉపయోగించడానికి మంచి వ్యాయామం.
## వ్యాయామం - మీ మోడల్‌ను 'పికిల్' చేయండి
ఇప్పుడు, మీ మోడల్‌ను _పికిల్_ చేయడానికి సమయం వచ్చింది! మీరు కొన్ని కోడ్ లైన్లలో ఇది చేయవచ్చు. ఒకసారి _పికిల్_ చేసిన తర్వాత, మీ పికిల్ చేసిన మోడల్‌ను లోడ్ చేసి, సెకన్లు, అక్షాంశం మరియు రేఖాంశం విలువలతో కూడిన నమూనా డేటా అర్రేపై పరీక్షించండి,
```python
import pickle
model_filename = 'ufo-model.pkl'
pickle.dump(model, open(model_filename,'wb'))
model = pickle.load(open('ufo-model.pkl','rb'))
print(model.predict([[50,44,-12]]))
```
మోడల్ **'3'** ను తిరిగి ఇస్తుంది, ఇది UK కోసం దేశ కోడ్. అద్భుతం! 👽
## వ్యాయామం - Flask యాప్ నిర్మించండి
ఇప్పుడు మీరు మీ మోడల్‌ను పిలిచి సమాన ఫలితాలను మరింత దృశ్యంగా అందించే Flask యాప్‌ను నిర్మించవచ్చు.
1. మొదటగా, మీ _notebook.ipynb_ ఫైల్ పక్కన **web-app** అనే ఫోల్డర్‌ను సృష్టించండి, అక్కడ మీ _ufo-model.pkl_ ఫైల్ ఉంటుంది.
1. ఆ ఫోల్డర్‌లో మూడు మరిన్ని ఫోల్డర్లను సృష్టించండి: **static**, దాని లోపల **css** ఫోల్డర్, మరియు **templates**. ఇప్పుడు మీ వద్ద ఈ క్రింది ఫైళ్లు మరియు డైరెక్టరీలు ఉండాలి:
```output
web-app/
static/
css/
templates/
notebook.ipynb
ufo-model.pkl
```
✅ పూర్తి యాప్‌ను చూడడానికి సొల్యూషన్ ఫోల్డర్‌ను చూడండి
1. _web-app_ ఫోల్డర్‌లో సృష్టించాల్సిన మొదటి ఫైల్ **requirements.txt**. JavaScript యాప్‌లో _package.json_ లాగా, ఈ ఫైల్ యాప్‌కు అవసరమైన డిపెండెన్సీలను జాబితా చేస్తుంది. **requirements.txt** లో ఈ లైన్లను జోడించండి:
```text
scikit-learn
pandas
numpy
flask
```
1. ఇప్పుడు, _web-app_ కు నావిగేట్ చేసి ఈ ఫైల్‌ను నడపండి:
```bash
cd web-app
```
1. మీ టెర్మినల్‌లో `pip install` టైప్ చేసి, _requirements.txt_ లో జాబితా చేసిన లైబ్రరీలను ఇన్‌స్టాల్ చేయండి:
```bash
pip install -r requirements.txt
```
1. ఇప్పుడు, యాప్‌ను పూర్తి చేయడానికి మూడు మరిన్ని ఫైళ్లను సృష్టించడానికి సిద్ధంగా ఉన్నారు:
1. రూట్‌లో **app.py** సృష్టించండి.
2. _templates_ డైరెక్టరీలో **index.html** సృష్టించండి.
3. _static/css_ డైరెక్టరీలో **styles.css** సృష్టించండి.
1. _styles.css_ ఫైల్‌ను కొన్ని శైలులతో నిర్మించండి:
```css
body {
width: 100%;
height: 100%;
font-family: 'Helvetica';
background: black;
color: #fff;
text-align: center;
letter-spacing: 1.4px;
font-size: 30px;
}
input {
min-width: 150px;
}
.grid {
width: 300px;
border: 1px solid #2d2d2d;
display: grid;
justify-content: center;
margin: 20px auto;
}
.box {
color: #fff;
background: #2d2d2d;
padding: 12px;
display: inline-block;
}
```
1. తరువాత, _index.html_ ఫైల్‌ను నిర్మించండి:
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>🛸 UFO Appearance Prediction! 👽</title>
<link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
</head>
<body>
<div class="grid">
<div class="box">
<p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>
<form action="{{ url_for('predict')}}" method="post">
<input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
<input type="text" name="latitude" placeholder="Latitude" required="required" />
<input type="text" name="longitude" placeholder="Longitude" required="required" />
<button type="submit" class="btn">Predict country where the UFO is seen</button>
</form>
<p>{{ prediction_text }}</p>
</div>
</div>
</body>
</html>
```
ఈ ఫైల్‌లో టెంప్లేటింగ్‌ను గమనించండి. యాప్ అందించే వేరియబుల్స్ చుట్టూ ఉన్న 'మస్టాచ్' సింటాక్స్: `{{}}` ను గమనించండి, ఉదాహరణకు prediction టెక్స్ట్. అలాగే, `/predict` రూట్‌కు prediction పోస్ట్ చేసే ఫారం కూడా ఉంది.
చివరగా, మోడల్ వినియోగం మరియు prediction ప్రదర్శనను నడిపే Python ఫైల్‌ను నిర్మించడానికి సిద్ధంగా ఉన్నారు:
1. `app.py` లో ఈ కోడ్ జోడించండి:
```python
import numpy as np
from flask import Flask, request, render_template
import pickle
app = Flask(__name__)
model = pickle.load(open("./ufo-model.pkl", "rb"))
@app.route("/")
def home():
return render_template("index.html")
@app.route("/predict", methods=["POST"])
def predict():
int_features = [int(x) for x in request.form.values()]
final_features = [np.array(int_features)]
prediction = model.predict(final_features)
output = prediction[0]
countries = ["Australia", "Canada", "Germany", "UK", "US"]
return render_template(
"index.html", prediction_text="Likely country: {}".format(countries[output])
)
if __name__ == "__main__":
app.run(debug=True)
```
> 💡 సూచన: Flask ఉపయోగించి వెబ్ యాప్ నడుపుతున్నప్పుడు [`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) జోడిస్తే, మీరు చేసిన ఏ మార్పు అయినా వెంటనే ప్రతిబింబిస్తుంది, సర్వర్‌ను రీస్టార్ట్ చేయాల్సిన అవసరం లేదు. జాగ్రత్త! ప్రొడక్షన్ యాప్‌లో ఈ మోడ్‌ను ఎనేబుల్ చేయవద్దు.
మీరు `python app.py` లేదా `python3 app.py` నడిపితే - మీ వెబ్ సర్వర్ స్థానికంగా ప్రారంభమవుతుంది, మరియు మీరు UFOలు ఎక్కడ దర్శించబడ్డాయో తెలుసుకోవడానికి ఒక చిన్న ఫారం నింపవచ్చు!
అదే ముందు, `app.py` భాగాలను చూడండి:
1. మొదట, డిపెండెన్సీలు లోడ్ అవుతాయి మరియు యాప్ ప్రారంభమవుతుంది.
1. తరువాత, మోడల్ దిగుమతి చేయబడుతుంది.
1. తరువాత, హోమ్ రూట్‌లో index.html రేండర్ అవుతుంది.
`/predict` రూట్‌లో, ఫారం పోస్ట్ అయినప్పుడు కొన్ని చర్యలు జరుగుతాయి:
1. ఫారం వేరియబుల్స్ సేకరించి numpy అర్రేకు మార్చబడతాయి. అవి మోడల్‌కు పంపబడతాయి మరియు prediction తిరిగి వస్తుంది.
2. మేము ప్రదర్శించదలచిన దేశాలు వారి అంచనా దేశ కోడ్ నుండి పఠనీయమైన టెక్స్ట్‌గా మళ్లీ రేండర్ చేయబడతాయి, ఆ విలువ index.html కు తిరిగి పంపబడుతుంది, టెంప్లేట్‌లో ప్రదర్శించడానికి.
Flask మరియు పికిల్ చేసిన మోడల్‌తో ఈ విధంగా మోడల్‌ను ఉపయోగించడం సాపేక్షంగా సులభం. కఠినమైన విషయం ఏమిటంటే, prediction పొందడానికి మోడల్‌కు పంపాల్సిన డేటా ఆకారాన్ని అర్థం చేసుకోవడం. అది మోడల్ శిక్షణ విధానంపై ఆధారపడి ఉంటుంది. ఈ మోడల్‌కు prediction కోసం మూడు డేటా పాయింట్లు ఇన్‌పుట్ కావాలి.
ప్రొఫెషనల్ పరిసరంలో, మోడల్‌ను శిక్షణ ఇస్తున్న వారు మరియు దాన్ని వెబ్ లేదా మొబైల్ యాప్‌లో వినియోగిస్తున్న వారు మధ్య మంచి కమ్యూనికేషన్ అవసరం అని మీరు చూడవచ్చు. మన సందర్భంలో, అది ఒక్క వ్యక్తి, మీరు!
---
## 🚀 సవాలు
నోట్‌బుక్‌లో పని చేయడం మరియు మోడల్‌ను Flask యాప్‌కు దిగుమతి చేసుకోవడం బదులు, మీరు Flask యాప్‌లోనే మోడల్‌ను శిక్షణ ఇస్తే ఎలా ఉంటుంది! మీ Python కోడ్‌ను నోట్‌బుక్‌లోని డేటా శుభ్రపరిచిన తర్వాత, `train` అనే రూట్‌లో యాప్‌లోనే మోడల్‌ను శిక్షణ ఇస్తూ మార్చండి. ఈ పద్ధతిని అనుసరించడంలో లాభాలు మరియు నష్టాలు ఏమిటి?
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
ML మోడల్స్‌ను వినియోగించడానికి వెబ్ యాప్‌ను నిర్మించడానికి అనేక మార్గాలు ఉన్నాయి. మీరు JavaScript లేదా Python ఉపయోగించి వెబ్ యాప్‌ను నిర్మించడానికి ఉపయోగించగల మార్గాల జాబితాను తయారుచేయండి. ఆర్కిటెక్చర్‌ను పరిగణించండి: మోడల్ యాప్‌లోనే ఉండాలా లేదా క్లౌడ్‌లో ఉండాలా? తర్వాతిది అయితే, దానిని ఎలా యాక్సెస్ చేస్తారు? ఒక వర్తింపజేసిన ML వెబ్ పరిష్కారం కోసం ఆర్కిటెక్చరల్ మోడల్‌ను డ్రా చేయండి.
## అసైన్‌మెంట్
[వేరే మోడల్ ప్రయత్నించండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకం వల్ల కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల బాధ్యత మేము తీసుకోము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/3-Web-App/1-Web-App/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a8e8ae10be335cbc745b75ee552317ff",
"translation_date": "2025-12-19T14:14:58+00:00",
"source_file": "3-Web-App/1-Web-App/assignment.md",
"language_code": "te"
}
-->
# వేరే మోడల్ ప్రయత్నించండి
## సూచనలు
మీరు ఒక శిక్షణ పొందిన రిగ్రెషన్ మోడల్ ఉపయోగించి ఒక వెబ్ యాప్ నిర్మించిన తర్వాత, ముందటి రిగ్రెషన్ పాఠం నుండి ఒక మోడల్ ఉపయోగించి ఈ వెబ్ యాప్‌ను మళ్లీ చేయండి. మీరు శైలి లేదా డిజైన్‌ను పంప్కిన్ డేటాను ప్రతిబింబించేలా వేరుగా ఉంచవచ్చు. మీ మోడల్ శిక్షణ పద్ధతిని ప్రతిబింబించేలా ఇన్‌పుట్‌లను మార్చేటప్పుడు జాగ్రత్తగా ఉండండి.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైన | సరిపడిన | మెరుగుదల అవసరం |
| -------------------------- | --------------------------------------------------------- | --------------------------------------------------------- | -------------------------------------- |
| | వెబ్ యాప్ ఆశించినట్లుగా నడుస్తుంది మరియు క్లౌడ్‌లో డిప్లాయ్ చేయబడింది | వెబ్ యాప్ లో లోపాలు లేదా అనూహ్య ఫలితాలు కనిపిస్తాయి | వెబ్ యాప్ సరిగ్గా పనిచేయదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

0
translations/te/3-Web-App/1-Web-App/notebook.ipynb
Unescape View File

269
translations/te/3-Web-App/1-Web-App/solution/notebook.ipynb
Unescape View File

@ -0,0 +1,269 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
},
"orig_nbformat": 2,
"kernelspec": {
"name": "python37364bit8d3b438fb5fc4430a93ac2cb74d693a7",
"display_name": "Python 3.7.0 64-bit ('3.7')"
},
"metadata": {
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"coopTranslator": {
"original_hash": "5fa2e8f4584c78250ca9729b46562ceb",
"translation_date": "2025-12-19T16:48:13+00:00",
"source_file": "3-Web-App/1-Web-App/solution/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"source": [
"## యుఎఫ్ఓ దర్శనంపై తెలుసుకోవడానికి రిగ్రెషన్ మోడల్ ఉపయోగించి వెబ్ యాప్ నిర్మించండి\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" datetime city state country shape \\\n",
"0 10/10/1949 20:30 san marcos tx us cylinder \n",
"1 10/10/1949 21:00 lackland afb tx NaN light \n",
"2 10/10/1955 17:00 chester (uk/england) NaN gb circle \n",
"3 10/10/1956 21:00 edna tx us circle \n",
"4 10/10/1960 20:00 kaneohe hi us light \n",
"\n",
" duration (seconds) duration (hours/min) \\\n",
"0 2700.0 45 minutes \n",
"1 7200.0 1-2 hrs \n",
"2 20.0 20 seconds \n",
"3 20.0 1/2 hour \n",
"4 900.0 15 minutes \n",
"\n",
" comments date posted latitude \\\n",
"0 This event took place in early fall around 194... 4/27/2004 29.883056 \n",
"1 1949 Lackland AFB&#44 TX. Lights racing acros... 12/16/2005 29.384210 \n",
"2 Green/Orange circular disc over Chester&#44 En... 1/21/2008 53.200000 \n",
"3 My older brother and twin sister were leaving ... 1/17/2004 28.978333 \n",
"4 AS a Marine 1st Lt. flying an FJ4B fighter/att... 1/22/2004 21.418056 \n",
"\n",
" longitude \n",
"0 -97.941111 \n",
"1 -98.581082 \n",
"2 -2.916667 \n",
"3 -96.645833 \n",
"4 -157.803611 "
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>datetime</th>\n <th>city</th>\n <th>state</th>\n <th>country</th>\n <th>shape</th>\n <th>duration (seconds)</th>\n <th>duration (hours/min)</th>\n <th>comments</th>\n <th>date posted</th>\n <th>latitude</th>\n <th>longitude</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>10/10/1949 20:30</td>\n <td>san marcos</td>\n <td>tx</td>\n <td>us</td>\n <td>cylinder</td>\n <td>2700.0</td>\n <td>45 minutes</td>\n <td>This event took place in early fall around 194...</td>\n <td>4/27/2004</td>\n <td>29.883056</td>\n <td>-97.941111</td>\n </tr>\n <tr>\n <th>1</th>\n <td>10/10/1949 21:00</td>\n <td>lackland afb</td>\n <td>tx</td>\n <td>NaN</td>\n <td>light</td>\n <td>7200.0</td>\n <td>1-2 hrs</td>\n <td>1949 Lackland AFB&amp;#44 TX. Lights racing acros...</td>\n <td>12/16/2005</td>\n <td>29.384210</td>\n <td>-98.581082</td>\n </tr>\n <tr>\n <th>2</th>\n <td>10/10/1955 17:00</td>\n <td>chester (uk/england)</td>\n <td>NaN</td>\n <td>gb</td>\n <td>circle</td>\n <td>20.0</td>\n <td>20 seconds</td>\n <td>Green/Orange circular disc over Chester&amp;#44 En...</td>\n <td>1/21/2008</td>\n <td>53.200000</td>\n <td>-2.916667</td>\n </tr>\n <tr>\n <th>3</th>\n <td>10/10/1956 21:00</td>\n <td>edna</td>\n <td>tx</td>\n <td>us</td>\n <td>circle</td>\n <td>20.0</td>\n <td>1/2 hour</td>\n <td>My older brother and twin sister were leaving ...</td>\n <td>1/17/2004</td>\n <td>28.978333</td>\n <td>-96.645833</td>\n </tr>\n <tr>\n <th>4</th>\n <td>10/10/1960 20:00</td>\n <td>kaneohe</td>\n <td>hi</td>\n <td>us</td>\n <td>light</td>\n <td>900.0</td>\n <td>15 minutes</td>\n <td>AS a Marine 1st Lt. flying an FJ4B fighter/att...</td>\n <td>1/22/2004</td>\n <td>21.418056</td>\n <td>-157.803611</td>\n </tr>\n </tbody>\n</table>\n</div>"
},
"metadata": {},
"execution_count": 23
}
],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"\n",
"ufos = pd.read_csv('../data/ufos.csv')\n",
"ufos.head()\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"array(['us', nan, 'gb', 'ca', 'au', 'de'], dtype=object)"
]
},
"metadata": {},
"execution_count": 24
}
],
"source": [
"\n",
"ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})\n",
"\n",
"ufos.Country.unique()\n",
"\n",
"# 0 au, 1 ca, 2 de, 3 gb, 4 us"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"<class 'pandas.core.frame.DataFrame'>\nInt64Index: 25863 entries, 2 to 80330\nData columns (total 4 columns):\n # Column Non-Null Count Dtype \n--- ------ -------------- ----- \n 0 Seconds 25863 non-null float64\n 1 Country 25863 non-null object \n 2 Latitude 25863 non-null float64\n 3 Longitude 25863 non-null float64\ndtypes: float64(3), object(1)\nmemory usage: 1010.3+ KB\n"
]
}
],
"source": [
"ufos.dropna(inplace=True)\n",
"\n",
"ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]\n",
"\n",
"ufos.info()"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" Seconds Country Latitude Longitude\n",
"2 20.0 3 53.200000 -2.916667\n",
"3 20.0 4 28.978333 -96.645833\n",
"14 30.0 4 35.823889 -80.253611\n",
"23 60.0 4 45.582778 -122.352222\n",
"24 3.0 3 51.783333 -0.783333"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>Seconds</th>\n <th>Country</th>\n <th>Latitude</th>\n <th>Longitude</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>2</th>\n <td>20.0</td>\n <td>3</td>\n <td>53.200000</td>\n <td>-2.916667</td>\n </tr>\n <tr>\n <th>3</th>\n <td>20.0</td>\n <td>4</td>\n <td>28.978333</td>\n <td>-96.645833</td>\n </tr>\n <tr>\n <th>14</th>\n <td>30.0</td>\n <td>4</td>\n <td>35.823889</td>\n <td>-80.253611</td>\n </tr>\n <tr>\n <th>23</th>\n <td>60.0</td>\n <td>4</td>\n <td>45.582778</td>\n <td>-122.352222</td>\n </tr>\n <tr>\n <th>24</th>\n <td>3.0</td>\n <td>3</td>\n <td>51.783333</td>\n <td>-0.783333</td>\n </tr>\n </tbody>\n</table>\n</div>"
},
"metadata": {},
"execution_count": 26
}
],
"source": [
"from sklearn.preprocessing import LabelEncoder\n",
"\n",
"ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])\n",
"\n",
"ufos.head()"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.model_selection import train_test_split\n",
"\n",
"Selected_features = ['Seconds','Latitude','Longitude']\n",
"\n",
"X = ufos[Selected_features]\n",
"y = ufos['Country']\n",
"\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)\n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
" FutureWarning)\n",
"/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:469: FutureWarning: Default multi_class will be changed to 'auto' in 0.22. Specify the multi_class option to silence this warning.\n",
" \"this warning.\", FutureWarning)\n",
" precision recall f1-score support\n",
"\n",
" 0 1.00 1.00 1.00 41\n",
" 1 1.00 0.02 0.05 250\n",
" 2 0.00 0.00 0.00 8\n",
" 3 0.94 1.00 0.97 131\n",
" 4 0.95 1.00 0.97 4743\n",
"\n",
" accuracy 0.95 5173\n",
" macro avg 0.78 0.60 0.60 5173\n",
"weighted avg 0.95 0.95 0.93 5173\n",
"\n",
"Predicted labels: [4 4 4 ... 3 4 4]\n",
"Accuracy: 0.9512855209742895\n",
"/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/sklearn/metrics/classification.py:1437: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples.\n",
" 'precision', 'predicted', average, warn_for)\n"
]
}
],
"source": [
"from sklearn.model_selection import train_test_split\n",
"from sklearn.metrics import accuracy_score, classification_report \n",
"from sklearn.linear_model import LogisticRegression\n",
"model = LogisticRegression()\n",
"model.fit(X_train, y_train)\n",
"predictions = model.predict(X_test)\n",
"\n",
"print(classification_report(y_test, predictions))\n",
"print('Predicted labels: ', predictions)\n",
"print('Accuracy: ', accuracy_score(y_test, predictions))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"[3]\n"
]
}
],
"source": [
"import pickle\n",
"model_filename = 'ufo-model.pkl'\n",
"pickle.dump(model, open(model_filename,'wb'))\n",
"\n",
"model = pickle.load(open('ufo-model.pkl','rb'))\n",
"print(model.predict([[50,44,-12]]))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

37
translations/te/3-Web-App/README.md
Unescape View File

@ -0,0 +1,37 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "9836ff53cfef716ddfd70e06c5f43436",
"translation_date": "2025-12-19T12:59:15+00:00",
"source_file": "3-Web-App/README.md",
"language_code": "te"
}
-->
# మీ ML మోడల్‌ను ఉపయోగించడానికి వెబ్ యాప్‌ను నిర్మించండి
ఈ పాఠ్యాంశంలో, మీరు ఒక అన్వయించిన ML అంశాన్ని పరిచయం చేయబడతారు: మీ Scikit-learn మోడల్‌ను ఫైల్‌గా ఎలా సేవ్ చేయాలో, అది వెబ్ అప్లికేషన్‌లో అంచనాలు చేయడానికి ఉపయోగించవచ్చు. మోడల్ సేవ్ అయిన తర్వాత, మీరు దాన్ని Flaskలో నిర్మించిన వెబ్ యాప్‌లో ఎలా ఉపయోగించాలో నేర్చుకుంటారు. మీరు మొదట UFO సాక్ష్యాల గురించి ఉన్న కొన్ని డేటాతో ఒక మోడల్‌ను సృష్టిస్తారు! ఆ తర్వాత, మీరు సెకన్ల సంఖ్య, అక్షాంశం మరియు రేఖాంశం విలువలను ఇన్‌పుట్‌గా ఇచ్చి ఏ దేశం UFO చూసిందని అంచనా వేయగల వెబ్ యాప్‌ను నిర్మిస్తారు.
![UFO Parking](../../../translated_images/ufo.9e787f5161da9d4d1dafc537e1da09be8210f2ee996cb638aa5cee1d92867a04.te.jpg)
ఫోటో <a href="https://unsplash.com/@mdherren?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Michael Herren</a> ద్వారా <a href="https://unsplash.com/s/photos/ufo?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
## పాఠాలు
1. [వెబ్ యాప్‌ను నిర్మించండి](1-Web-App/README.md)
## క్రెడిట్స్
"వెబ్ యాప్‌ను నిర్మించండి" ను ♥️ తో [Jen Looper](https://twitter.com/jenlooper) రాశారు.
♥️ క్విజ్‌లు రోహన్ రాజ్ రాశారు.
డేటాసెట్ [Kaggle](https://www.kaggle.com/NUFORC/ufo-sightings) నుండి తీసుకోబడింది.
వెబ్ యాప్ ఆర్కిటెక్చర్ భాగంగా సూచించబడింది [ఈ ఆర్టికల్](https://towardsdatascience.com/how-to-easily-deploy-machine-learning-models-using-flask-b95af8fe34d4) మరియు [ఈ రిపో](https://github.com/abhinavsagar/machine-learning-deployment) Abhinav Sagar ద్వారా.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

315
translations/te/4-Classification/1-Introduction/README.md
Unescape View File

@ -0,0 +1,315 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "aaf391d922bd6de5efba871d514c6d47",
"translation_date": "2025-12-19T15:16:46+00:00",
"source_file": "4-Classification/1-Introduction/README.md",
"language_code": "te"
}
-->
# వర్గీకరణకు పరిచయం
ఈ నాలుగు పాఠాలలో, మీరు క్లాసిక్ మెషీన్ లెర్నింగ్ యొక్క ఒక ప్రాథమిక దృష్టి - _వర్గీకరణ_ ను అన్వేషించబోతున్నారు. ఆసియా మరియు భారతదేశంలోని అన్ని అద్భుతమైన వంటకాల గురించి డేటాసెట్‌తో వివిధ వర్గీకరణ అల్గోరిథమ్స్ ఉపయోగించడం ద్వారా మనం నడవబోతున్నాము. మీరు ఆకలిగా ఉన్నారని ఆశిస్తున్నాము!
![just a pinch!](../../../../translated_images/pinch.1b035ec9ba7e0d408313b551b60c721c9c290b2dd2094115bc87e6ddacd114c9.te.png)
> ఈ పాఠాలలో పాన్-ఆసియన్ వంటకాలను జరుపుకోండి! చిత్రం [జెన్ లూపర్](https://twitter.com/jenlooper) ద్వారా
వర్గీకరణ అనేది [సూపర్వైజ్డ్ లెర్నింగ్](https://wikipedia.org/wiki/Supervised_learning) యొక్క ఒక రూపం, ఇది రిగ్రెషన్ సాంకేతికతలతో చాలా సామాన్యమైనది. మెషీన్ లెర్నింగ్ డేటాసెట్లను ఉపయోగించి విలువలు లేదా పేర్లను అంచనా వేయడమే అయితే, వర్గీకరణ సాధారణంగా రెండు గుంపులుగా విభజించబడుతుంది: _బైనరీ వర్గీకరణ_ మరియు _బహుళ వర్గీకరణ_.
[![Introduction to classification](https://img.youtube.com/vi/eg8DJYwdMyg/0.jpg)](https://youtu.be/eg8DJYwdMyg "Introduction to classification")
> 🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి: MIT యొక్క జాన్ గుట్‌టాగ్ వర్గీకరణను పరిచయం చేస్తారు
గమనించండి:
- **లీనియర్ రిగ్రెషన్** మీరు వేరియబుల్స్ మధ్య సంబంధాలను అంచనా వేయడంలో మరియు కొత్త డేటాపాయింట్ ఆ లైన్‌కు సంబంధించి ఎక్కడ పడుతుందో ఖచ్చితంగా అంచనా వేయడంలో సహాయపడింది. ఉదాహరణకు, మీరు _సెప్టెంబర్ మరియు డిసెంబర్‌లో పంప్కిన్ ధర ఎంత ఉంటుందో అంచనా వేయవచ్చు_.
- **లాజిస్టిక్ రిగ్రెషన్** "బైనరీ వర్గాలు" కనుగొనడంలో సహాయపడింది: ఈ ధర వద్ద, _ఈ పంప్కిన్ నారింజ రంగులో ఉందా లేదా కాదు_?
వర్గీకరణ వివిధ అల్గోరిథమ్స్ ఉపయోగించి డేటాపాయింట్ యొక్క లేబుల్ లేదా తరగతిని నిర్ణయించడానికి ఇతర మార్గాలను కనుగొంటుంది. మనం ఈ వంటకాల డేటాతో పని చేసి, ఒక సమూహం పదార్థాలను పరిశీలించి, దాని వంటక మూలాన్ని నిర్ణయించగలమా అని చూద్దాం.
## [పాఠం ముందు క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
> ### [ఈ పాఠం R లో అందుబాటులో ఉంది!](../../../../4-Classification/1-Introduction/solution/R/lesson_10.html)
### పరిచయం
వర్గీకరణ మెషీన్ లెర్నింగ్ పరిశోధకుడు మరియు డేటా శాస్త్రవేత్త యొక్క ప్రాథమిక కార్యకలాపాలలో ఒకటి. ఒక బైనరీ విలువ ("ఈ ఇమెయిల్ స్పామ్ కాదా?") యొక్క ప్రాథమిక వర్గీకరణ నుండి, కంప్యూటర్ విజన్ ఉపయోగించి సంక్లిష్ట చిత్రం వర్గీకరణ మరియు విభజన వరకు, డేటాను తరగతులుగా వర్గీకరించి దానిపై ప్రశ్నలు అడగడం ఎప్పుడూ ఉపయోగకరం.
ప్రక్రియను మరింత శాస్త్రీయంగా చెప్పాలంటే, మీ వర్గీకరణ పద్ధతి ఇన్‌పుట్ వేరియబుల్స్ మరియు అవుట్‌పుట్ వేరియబుల్స్ మధ్య సంబంధాన్ని మ్యాప్ చేయగల ఒక అంచనా మోడల్‌ను సృష్టిస్తుంది.
![binary vs. multiclass classification](../../../../translated_images/binary-multiclass.b56d0c86c81105a697dddd82242c1d11e4d78b7afefea07a44627a0f1111c1a9.te.png)
> వర్గీకరణ అల్గోరిథమ్స్ నిర్వహించాల్సిన బైనరీ మరియు బహుళ వర్గ సమస్యలు. ఇన్ఫోగ్రాఫిక్ [జెన్ లూపర్](https://twitter.com/jenlooper) ద్వారా
మన డేటాను శుభ్రపరచడం, దాన్ని విజువలైజ్ చేయడం మరియు ML పనుల కోసం సిద్ధం చేయడం ప్రారంభించే ముందు, మెషీన్ లెర్నింగ్ డేటాను వర్గీకరించడానికి ఉపయోగించగల వివిధ మార్గాల గురించి కొంత తెలుసుకుందాం.
[సంఖ్యాశాస్త్రం](https://wikipedia.org/wiki/Statistical_classification) నుండి ఉద్భవించిన వర్గీకరణ క్లాసిక్ మెషీన్ లెర్నింగ్ ఉపయోగించి `smoker`, `weight`, మరియు `age` వంటి లక్షణాలను ఉపయోగించి _X వ్యాధి అభివృద్ధి చెందే అవకాశాన్ని_ నిర్ణయిస్తుంది. మీరు ముందుగా చేసిన రిగ్రెషన్ వ్యాయామాల్లా, ఇది సూపర్వైజ్డ్ లెర్నింగ్ సాంకేతికత, మీ డేటా లేబుల్డ్ ఉంటుంది మరియు ML అల్గోరిథమ్స్ ఆ లేబుల్స్ ఉపయోగించి డేటాసెట్ యొక్క తరగతులు (లక్షణాలు) వర్గీకరించి వాటిని ఒక గుంపు లేదా ఫలితానికి కేటాయిస్తాయి.
✅ వంటకాల గురించి ఒక డేటాసెట్‌ను ఊహించండి. బహుళ వర్గ మోడల్ ఏమి సమాధానం చెప్పగలదు? బైనరీ మోడల్ ఏమి సమాధానం చెప్పగలదు? మీరు ఒక వంటకం మెంతులు ఉపయోగించే అవకాశం ఉందా అని నిర్ణయించాలనుకుంటే? మీరు ఒక గ్రోసరీ బ్యాగ్‌లో స్టార్ అనీస్, ఆర్టిచోక్స్, కాలీఫ్లవర్, మరియు హోర్సరాడిష్ ఉన్నప్పుడు, మీరు ఒక సాధారణ భారతీయ వంటకం తయారుచేయగలరా?
[![Crazy mystery baskets](https://img.youtube.com/vi/GuTeDbaNoEU/0.jpg)](https://youtu.be/GuTeDbaNoEU "Crazy mystery baskets")
> 🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి. 'Chopped' షో యొక్క మొత్తం భావన 'మిస్టరీ బాస్కెట్' - అక్కడ చెఫ్స్ రాండమ్ పదార్థాలతో వంటకం తయారుచేయాలి. ఖచ్చితంగా ML మోడల్ సహాయపడేది!
## హలో 'క్లాసిఫయర్'
ఈ వంటకాల డేటాసెట్ నుండి అడగదలచిన ప్రశ్న వాస్తవానికి **బహుళ వర్గ ప్రశ్న** ఎందుకంటే మనకు అనేక జాతీయ వంటకాలు ఉన్నాయి. పదార్థాల బ్యాచ్ ఇచ్చినప్పుడు, ఈ అనేక తరగతులలో ఏది డేటాకు సరిపోతుంది?
Scikit-learn వివిధ అల్గోరిథమ్స్ అందిస్తుంది, మీరు పరిష్కరించదలచిన సమస్య రకాన్ని ఆధారంగా డేటాను వర్గీకరించడానికి. తదుపరి రెండు పాఠాలలో, మీరు ఈ అల్గోరిథమ్స్ గురించి తెలుసుకుంటారు.
## వ్యాయామం - మీ డేటాను శుభ్రపరచి సమతుల్యం చేయండి
ఈ ప్రాజెక్ట్ ప్రారంభించే ముందు మొదటి పని, మీ డేటాను శుభ్రపరచి **సమతుల్యం** చేయడం, మెరుగైన ఫలితాలు పొందడానికి. ఈ ఫోల్డర్ రూట్‌లో ఉన్న ఖాళీ _notebook.ipynb_ ఫైల్‌తో ప్రారంభించండి.
మొదట ఇన్‌స్టాల్ చేయవలసినది [imblearn](https://imbalanced-learn.org/stable/). ఇది Scikit-learn ప్యాకేజీ, ఇది డేటాను మెరుగ్గా సమతుల్యం చేయడానికి సహాయపడుతుంది (ఈ పనిని మీరు కొద్దిసేపట్లో నేర్చుకుంటారు).
1. `imblearn` ఇన్‌స్టాల్ చేయడానికి, ఇలా `pip install` నడపండి:
```python
pip install imblearn
```
1. మీ డేటాను దిగుమతి చేసుకోవడానికి మరియు దాన్ని విజువలైజ్ చేయడానికి అవసరమైన ప్యాకేజీలను దిగుమతి చేసుకోండి, అలాగే `imblearn` నుండి `SMOTE` ను దిగుమతి చేసుకోండి.
```python
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np
from imblearn.over_sampling import SMOTE
```
ఇప్పుడు మీరు డేటాను దిగుమతి చేసుకోవడానికి సిద్ధంగా ఉన్నారు.
1. తదుపరి పని డేటాను దిగుమతి చేసుకోవడం:
```python
df = pd.read_csv('../data/cuisines.csv')
```
`read_csv()` ఉపయోగించి _cusines.csv_ ఫైల్ యొక్క కంటెంట్‌ను చదివి `df` వేరియబుల్‌లో ఉంచుతుంది.
1. డేటా ఆకారాన్ని తనిఖీ చేయండి:
```python
df.head()
```
మొదటి ఐదు వరుసలు ఇలా ఉంటాయి:
```output
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
| 0 | 65 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 1 | 66 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 67 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 68 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 69 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
```
1. `info()` పిలిచి ఈ డేటా గురించి సమాచారం పొందండి:
```python
df.info()
```
మీ అవుట్‌పుట్ ఇలా ఉంటుంది:
```output
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2448 entries, 0 to 2447
Columns: 385 entries, Unnamed: 0 to zucchini
dtypes: int64(384), object(1)
memory usage: 7.2+ MB
```
## వ్యాయామం - వంటకాల గురించి తెలుసుకోవడం
ఇప్పుడు పని మరింత ఆసక్తికరంగా మారుతుంది. వంటకాల వారీగా డేటా పంపిణీని కనుగొనండి
1. `barh()` పిలిచి డేటాను బార్లుగా ప్లాట్ చేయండి:
```python
df.cuisine.value_counts().plot.barh()
```
![cuisine data distribution](../../../../translated_images/cuisine-dist.d0cc2d551abe5c25f83d73a5f560927e4a061e9a4560bac1e97d35682ef3ca6d.te.png)
వంటకాల సంఖ్య పరిమితి ఉన్నప్పటికీ, డేటా పంపిణీ అసమానంగా ఉంది. మీరు దీన్ని సరిచేయవచ్చు! ముందుగా, మరింత అన్వేషించండి.
1. వంటకాల వారీగా ఎంత డేటా ఉందో కనుగొని ప్రింట్ చేయండి:
```python
thai_df = df[(df.cuisine == "thai")]
japanese_df = df[(df.cuisine == "japanese")]
chinese_df = df[(df.cuisine == "chinese")]
indian_df = df[(df.cuisine == "indian")]
korean_df = df[(df.cuisine == "korean")]
print(f'thai df: {thai_df.shape}')
print(f'japanese df: {japanese_df.shape}')
print(f'chinese df: {chinese_df.shape}')
print(f'indian df: {indian_df.shape}')
print(f'korean df: {korean_df.shape}')
```
అవుట్‌పుట్ ఇలా ఉంటుంది:
```output
thai df: (289, 385)
japanese df: (320, 385)
chinese df: (442, 385)
indian df: (598, 385)
korean df: (799, 385)
```
## పదార్థాలను కనుగొనడం
ఇప్పుడు మీరు డేటాలో లోతుగా వెళ్ళి వంటకాల వారీగా సాధారణ పదార్థాలు ఏమిటో తెలుసుకోవచ్చు. వంటకాల మధ్య గందరగోళం సృష్టించే పునరావృత డేటాను శుభ్రపరచాలి, కాబట్టి ఈ సమస్య గురించి తెలుసుకుందాం.
1. పదార్థాల డేటాఫ్రేమ్ సృష్టించడానికి Python లో `create_ingredient()` ఫంక్షన్ సృష్టించండి. ఈ ఫంక్షన్ ఉపయోగకరంలేని కాలమ్‌ను తొలగించి, పదార్థాలను వారి కౌంట్ ఆధారంగా సర్దుతుంది:
```python
def create_ingredient_df(df):
ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
inplace=False)
return ingredient_df
```
ఇప్పుడు మీరు ఆ ఫంక్షన్ ఉపయోగించి వంటకాల వారీగా టాప్ టెన్ అత్యంత ప్రాచుర్యం పొందిన పదార్థాల ఆలోచన పొందవచ్చు.
1. `create_ingredient()` పిలిచి `barh()` పిలిచి ప్లాట్ చేయండి:
```python
thai_ingredient_df = create_ingredient_df(thai_df)
thai_ingredient_df.head(10).plot.barh()
```
![thai](../../../../translated_images/thai.0269dbab2e78bd38a132067759fe980008bdb80b6d778e5313448dbe12bed846.te.png)
1. జపనీస్ డేటా కోసం అదే చేయండి:
```python
japanese_ingredient_df = create_ingredient_df(japanese_df)
japanese_ingredient_df.head(10).plot.barh()
```
![japanese](../../../../translated_images/japanese.30260486f2a05c463c8faa62ebe7b38f0961ed293bd9a6db8eef5d3f0cf17155.te.png)
1. ఇప్పుడు చైనీస్ పదార్థాల కోసం:
```python
chinese_ingredient_df = create_ingredient_df(chinese_df)
chinese_ingredient_df.head(10).plot.barh()
```
![chinese](../../../../translated_images/chinese.e62cafa5309f111afd1b54490336daf4e927ce32bed837069a0b7ce481dfae8d.te.png)
1. ఇండియన్ పదార్థాలను ప్లాట్ చేయండి:
```python
indian_ingredient_df = create_ingredient_df(indian_df)
indian_ingredient_df.head(10).plot.barh()
```
![indian](../../../../translated_images/indian.2c4292002af1a1f97a4a24fec6b1459ee8ff616c3822ae56bb62b9903e192af6.te.png)
1. చివరగా, కొరియన్ పదార్థాలను ప్లాట్ చేయండి:
```python
korean_ingredient_df = create_ingredient_df(korean_df)
korean_ingredient_df.head(10).plot.barh()
```
![korean](../../../../translated_images/korean.4a4f0274f3d9805a65e61f05597eeaad8620b03be23a2c0a705c023f65fad2c0.te.png)
1. ఇప్పుడు, వేర్వేరు వంటకాల మధ్య గందరగోళం సృష్టించే అత్యంత సాధారణ పదార్థాలను `drop()` పిలిచి తొలగించండి:
అందరూ అన్నం, వెల్లుల్లి మరియు అల్లం ఇష్టపడతారు!
```python
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
labels_df = df.cuisine #.unique()
feature_df.head()
```
## డేటాసెట్‌ను సమతుల్యం చేయండి
ఇప్పుడు మీరు డేటాను శుభ్రపరిచిన తర్వాత, [SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - "సింథటిక్ మైనారిటీ ఓవర్-సాంప్లింగ్ టెక్నిక్" - ఉపయోగించి దాన్ని సమతుల్యం చేయండి.
1. `fit_resample()` పిలవండి, ఈ వ్యూహం ఇంటర్‌పోలేషన్ ద్వారా కొత్త నమూనాలను సృష్టిస్తుంది.
```python
oversample = SMOTE()
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
```
మీ డేటాను సమతుల్యం చేయడం ద్వారా, మీరు దాన్ని వర్గీకరించేటప్పుడు మెరుగైన ఫలితాలు పొందుతారు. ఒక బైనరీ వర్గీకరణ గురించి ఆలోచించండి. మీ డేటాలో ఎక్కువ భాగం ఒక తరగతికి చెందినట్లయితే, ML మోడల్ ఆ తరగతిని ఎక్కువగా అంచనా వేయగలదు, ఎందుకంటే దానికి ఎక్కువ డేటా ఉంటుంది. డేటాను సమతుల్యం చేయడం ఏదైనా వక్రీకృత డేటాను తీసుకుని ఈ అసమతుల్యతను తొలగించడంలో సహాయపడుతుంది.
1. ఇప్పుడు పదార్థాల వారీగా లేబుల్స్ సంఖ్యను తనిఖీ చేయండి:
```python
print(f'new label count: {transformed_label_df.value_counts()}')
print(f'old label count: {df.cuisine.value_counts()}')
```
మీ అవుట్‌పుట్ ఇలా ఉంటుంది:
```output
new label count: korean 799
chinese 799
indian 799
japanese 799
thai 799
Name: cuisine, dtype: int64
old label count: korean 799
indian 598
chinese 442
japanese 320
thai 289
Name: cuisine, dtype: int64
```
డేటా చక్కగా శుభ్రపరచబడింది, సమతుల్యం చేయబడింది, మరియు చాలా రుచికరంగా ఉంది!
1. చివరి దశలో, లేబుల్స్ మరియు లక్షణాలను కలిగి ఉన్న మీ సమతుల్య డేటాను కొత్త డేటాఫ్రేమ్‌లో సేవ్ చేయండి, దీన్ని ఫైల్‌గా ఎగుమతి చేయవచ్చు:
```python
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
```
1. `transformed_df.head()` మరియు `transformed_df.info()` ఉపయోగించి డేటాను మరొకసారి చూడవచ్చు. భవిష్యత్తు పాఠాల కోసం ఈ డేటా కాపీని సేవ్ చేయండి:
```python
transformed_df.head()
transformed_df.info()
transformed_df.to_csv("../data/cleaned_cuisines.csv")
```
ఈ తాజా CSV ఇప్పుడు రూట్ డేటా ఫోల్డర్‌లో కనిపిస్తుంది.
---
## 🚀సవాలు
ఈ పాఠ్యాంశంలో అనేక ఆసక్తికరమైన డేటాసెట్లు ఉన్నాయి. `data` ఫోల్డర్లలో వెతకండి మరియు ఏవైనా బైనరీ లేదా బహుళ వర్గీకరణకు అనుకూలమైన డేటాసెట్లు ఉన్నాయా చూడండి? మీరు ఆ డేటాసెట్ నుండి ఏ ప్రశ్నలు అడగాలనుకుంటారు?
## [పాఠం తర్వాత క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
SMOTE యొక్క API ను అన్వేషించండి. ఇది ఏ ఉపయోగాల కోసం ఉత్తమంగా ఉపయోగించబడుతుంది? ఇది ఏ సమస్యలను పరిష్కరిస్తుంది?
## అసైన్‌మెంట్
[వర్గీకరణ పద్ధతులను అన్వేషించండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం మంచిది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారులు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/4-Classification/1-Introduction/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "b2a01912beb24cfb0007f83594dba801",
"translation_date": "2025-12-19T15:20:36+00:00",
"source_file": "4-Classification/1-Introduction/assignment.md",
"language_code": "te"
}
-->
# వర్గీకరణ పద్ధతులను అన్వేషించండి
## సూచనలు
[Scikit-learn డాక్యుమెంటేషన్](https://scikit-learn.org/stable/supervised_learning.html)లో మీరు డేటాను వర్గీకరించడానికి అనేక విధానాల జాబితాను కనుగొంటారు. ఈ డాక్యుమెంట్లలో ఒక చిన్న స్కావెంజర్ హంట్ చేయండి: మీ లక్ష్యం వర్గీకరణ పద్ధతులను చూడటం మరియు ఈ పాఠ్యాంశంలో ఉన్న ఒక డేటాసెట్, దానిపై మీరు అడగగల ప్రశ్న, మరియు వర్గీకరణ సాంకేతికతను సరిపోల్చడం. ఒక స్ప్రెడ్షీట్ లేదా .doc ఫైల్‌లో ఒక పట్టికను సృష్టించి, ఆ డేటాసెట్ వర్గీకరణ అల్గోరిథంతో ఎలా పనిచేస్తుందో వివరించండి.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | 5 అల్గోరిథమ్స్‌ను వర్గీకరణ సాంకేతికతతో పాటు సమీక్షిస్తూ ఒక డాక్యుమెంట్ సమర్పించబడింది. సమీక్ష బాగా వివరించబడింది మరియు విస్తృతంగా ఉంది. | 3 అల్గోరిథమ్స్‌ను వర్గీకరణ సాంకేతికతతో పాటు సమీక్షిస్తూ ఒక డాక్యుమెంట్ సమర్పించబడింది. సమీక్ష బాగా వివరించబడింది మరియు విస్తృతంగా ఉంది. | 3 కంటే తక్కువ అల్గోరిథమ్స్‌ను వర్గీకరణ సాంకేతికతతో పాటు సమీక్షిస్తూ ఒక డాక్యుమెంట్ సమర్పించబడింది మరియు సమీక్ష బాగా వివరించబడలేదు లేదా విస్తృతంగా లేదు. |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారులు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

41
translations/te/4-Classification/1-Introduction/notebook.ipynb
Unescape View File

@ -0,0 +1,41 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": 3
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "d544ef384b7ba73757d830a72372a7f2",
"translation_date": "2025-12-19T17:02:26+00:00",
"source_file": "4-Classification/1-Introduction/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"source": [
"# రుచికరమైన ఆసియన్లు మరియు భారతీయ వంటకాలు\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

17
translations/te/4-Classification/1-Introduction/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T15:36:49+00:00",
"source_file": "4-Classification/1-Introduction/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

732
translations/te/4-Classification/1-Introduction/solution/R/lesson_10-R.ipynb
Unescape View File

@ -0,0 +1,732 @@
{
"nbformat": 4,
"nbformat_minor": 2,
"metadata": {
"colab": {
"name": "lesson_10-R.ipynb",
"provenance": [],
"collapsed_sections": []
},
"kernelspec": {
"name": "ir",
"display_name": "R"
},
"language_info": {
"name": "R"
},
"coopTranslator": {
"original_hash": "2621e24705e8100893c9bf84e0fc8aef",
"translation_date": "2025-12-19T17:05:54+00:00",
"source_file": "4-Classification/1-Introduction/solution/R/lesson_10-R.ipynb",
"language_code": "te"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"# వర్గీకరణ మోడల్ నిర్మించండి: రుచికరమైన ఆసియన్లు మరియు భారతీయ వంటకాలు\n"
],
"metadata": {
"id": "ItETB4tSFprR"
}
},
{
"cell_type": "markdown",
"source": [
"## వర్గీకరణకు పరిచయం: మీ డేటాను శుభ్రపరచండి, సిద్ధం చేయండి, మరియు దృశ్యీకరించండి\n",
"\n",
"ఈ నాలుగు పాఠాలలో, మీరు క్లాసిక్ మెషీన్ లెర్నింగ్ యొక్క ఒక ప్రాథమిక దృష్టిని అన్వేషించబోతున్నారు - *వర్గీకరణ*. ఆసియా మరియు భారతదేశంలోని అన్ని అద్భుతమైన వంటకాల గురించి ఒక డేటాసెట్‌తో వివిధ వర్గీకరణ అల్గోరిథమ్స్ ఉపయోగించడం ద్వారా మనం నడవబోతున్నాము. మీరు ఆకలిగా ఉన్నారని ఆశిస్తున్నాము!\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/pinch.1b035ec9ba7e0d408313b551b60c721c9c290b2dd2094115bc87e6ddacd114c9.te.png\"\n",
" width=\"600\"/>\n",
" <figcaption>ఈ పాఠాలలో పాన్-ఆసియన్ వంటకాలను జరుపుకోండి! చిత్రం జెన్ లూపర్ ద్వారా</figcaption>\n",
"\n",
"\n",
"<!--![Celebrate pan-Asian cuisines in these lessons! Image by Jen Looper](../../../../../../translated_images/pinch.b33c0ba76f284aad94a3c4e3ed83e13ed1e17fbcf4db8ca8583c3a0c135e2e99.te.png)-->\n",
"\n",
"వర్గీకరణ అనేది [సూపర్వైజ్డ్ లెర్నింగ్](https://wikipedia.org/wiki/Supervised_learning) యొక్క ఒక రూపం, ఇది రిగ్రెషన్ సాంకేతికతలతో చాలా సామాన్యమైనది. వర్గీకరణలో, మీరు ఒక మోడల్‌ను శిక్షణ ఇస్తారు ఏ `వర్గం`కి ఒక అంశం చెందుతుందో అంచనా వేయడానికి. మెషీన్ లెర్నింగ్ అనేది డేటాసెట్లను ఉపయోగించి విలువలు లేదా పేర్లను అంచనా వేయడమే అయితే, వర్గీకరణ సాధారణంగా రెండు గుంపులుగా విభజించబడుతుంది: *బైనరీ వర్గీకరణ* మరియు *బహుళ వర్గీకరణ*.\n",
"\n",
"గమనించండి:\n",
"\n",
"- **లీనియర్ రిగ్రెషన్** మీరు వేరియబుల్స్ మధ్య సంబంధాలను అంచనా వేయడంలో సహాయపడింది మరియు కొత్త డేటాపాయింట్ ఆ రేఖకు సంబంధించి ఎక్కడ పడుతుందో ఖచ్చితంగా అంచనా వేయగలిగింది. ఉదాహరణకు, *సెప్టెంబర్ మరియు డిసెంబర్‌లో ఒక గుమ్మడికాయ ధర ఎంత ఉంటుందో* అంచనా వేయగలిగారు.\n",
"\n",
"- **లాజిస్టిక్ రిగ్రెషన్** మీరు \"బైనరీ వర్గాలు\" కనుగొనడంలో సహాయపడింది: ఈ ధర వద్ద, *ఈ గుమ్మడికాయ నారింజ రంగులో ఉందా లేదా కాదు*?\n",
"\n",
"వర్గీకరణ వివిధ అల్గోరిథమ్స్ ఉపయోగించి డేటాపాయింట్ యొక్క లేబుల్ లేదా వర్గాన్ని నిర్ణయించడానికి ఇతర మార్గాలను కనుగొంటుంది. ఈ వంటకాల డేటాతో పని చేసి, ఒక పదార్థాల సమూహాన్ని పరిశీలించి, దాని వంటక మూలాన్ని నిర్ణయించగలమా అని చూద్దాం.\n",
"\n",
"### [**పాఠం ముందు క్విజ్**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/19/)\n",
"\n",
"### **పరిచయం**\n",
"\n",
"వర్గీకరణ మెషీన్ లెర్నింగ్ పరిశోధకుడు మరియు డేటా శాస్త్రవేత్త యొక్క ప్రాథమిక కార్యకలాపాలలో ఒకటి. ఒక బైనరీ విలువ యొక్క ప్రాథమిక వర్గీకరణ (\"ఈ ఇమెయిల్ స్పామ్ కాదా?\") నుండి, కంప్యూటర్ విజన్ ఉపయోగించి సంక్లిష్ట చిత్రం వర్గీకరణ మరియు విభజన వరకు, డేటాను వర్గాలుగా వర్గీకరించి దానిపై ప్రశ్నలు అడగడం ఎప్పుడూ ఉపయోగకరం.\n",
"\n",
"ప్రక్రియను మరింత శాస్త్రీయంగా చెప్పాలంటే, మీ వర్గీకరణ పద్ధతి ఒక అంచనా మోడల్‌ను సృష్టిస్తుంది, ఇది ఇన్‌పుట్ వేరియబుల్స్ మరియు అవుట్‌పుట్ వేరియబుల్స్ మధ్య సంబంధాన్ని మ్యాప్ చేయడానికి సహాయపడుతుంది.\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/binary-multiclass.b56d0c86c81105a697dddd82242c1d11e4d78b7afefea07a44627a0f1111c1a9.te.png\"\n",
" width=\"600\"/>\n",
" <figcaption>వర్గీకరణ అల్గోరిథమ్స్ నిర్వహించాల్సిన బైనరీ మరియు బహుళ వర్గ సమస్యలు. ఇన్ఫోగ్రాఫిక్ జెన్ లూపర్ ద్వారా</figcaption>\n",
"\n",
"\n",
"\n",
"మా డేటాను శుభ్రపరచడం, దృశ్యీకరించడం మరియు మా ML పనుల కోసం సిద్ధం చేయడం ప్రారంభించే ముందు, మెషీన్ లెర్నింగ్ డేటాను వర్గీకరించడానికి ఉపయోగించగల వివిధ మార్గాల గురించి కొంత తెలుసుకుందాం.\n",
"\n",
"[సంఖ్యాశాస్త్రం](https://wikipedia.org/wiki/Statistical_classification) నుండి ఉద్భవించిన, క్లాసిక్ మెషీన్ లెర్నింగ్ ఉపయోగించి వర్గీకరణ `స్మోకర్`, `బరువు`, మరియు `వయస్సు` వంటి లక్షణాలను ఉపయోగించి *X వ్యాధి అభివృద్ధి చెందే అవకాశాన్ని* నిర్ణయిస్తుంది. మీరు ముందుగా చేసిన రిగ్రెషన్ వ్యాయామాలకు సమానమైన సూపర్వైజ్డ్ లెర్నింగ్ సాంకేతికతగా, మీ డేటాకు లేబుల్స్ ఉంటాయి మరియు ML అల్గోరిథమ్స్ ఆ లేబుల్స్‌ను ఉపయోగించి డేటాసెట్ యొక్క వర్గాలు (లేదా 'లక్షణాలు')ను వర్గీకరించి, వాటిని ఒక గుంపు లేదా ఫలితానికి కేటాయిస్తాయి.\n",
"\n",
"✅ వంటకాల గురించి ఒక డేటాసెట్‌ను ఊహించండి. బహుళ వర్గ మోడల్ ఏమి సమాధానం చెప్పగలదు? బైనరీ మోడల్ ఏమి సమాధానం చెప్పగలదు? మీరు ఒక వంటకం మెంతులు ఉపయోగించే అవకాశం ఉందా అని నిర్ణయించాలనుకుంటే? మీరు ఒక గ్రోసరీ బ్యాగ్‌లో స్టార్ అనీస్, ఆర్టిచోక్స్, కాలీఫ్లవర్, మరియు హోర్సరాడిష్ ఉన్నప్పుడు, మీరు ఒక సాధారణ భారతీయ వంటకం తయారు చేయగలరా అని చూడాలనుకుంటే?\n",
"\n",
"### **హలో 'వర్గీకర్త'**\n",
"\n",
"ఈ వంటకాల డేటాసెట్ నుండి అడగదలచిన ప్రశ్న వాస్తవానికి ఒక **బహుళ వర్గ ప్రశ్న**నే, ఎందుకంటే మనకు అనేక జాతీయ వంటకాలు ఉన్నాయి. పదార్థాల ఒక బ్యాచ్ ఇచ్చినప్పుడు, ఈ అనేక వర్గాలలో ఏది డేటాకు సరిపోతుంది?\n",
"\n",
"Tidymodels వివిధ సమస్యలను పరిష్కరించడానికి ఉపయోగించగల అనేక అల్గోరిథమ్స్‌ను అందిస్తుంది. తదుపరి రెండు పాఠాలలో, మీరు ఈ అల్గోరిథమ్స్ గురించి తెలుసుకుంటారు.\n",
"\n",
"#### **ముందస్తు అవసరం**\n",
"\n",
"ఈ పాఠం కోసం, మన డేటాను శుభ్రపరచడానికి, సిద్ధం చేయడానికి మరియు దృశ్యీకరించడానికి క్రింది ప్యాకేజీలను అవసరం:\n",
"\n",
"- `tidyverse`: [tidyverse](https://www.tidyverse.org/) అనేది డేటా సైన్స్‌ను వేగవంతం, సులభం మరియు మరింత సరదాగా మార్చడానికి రూపొందించిన [R ప్యాకేజీల సేకరణ](https://www.tidyverse.org/packages)!\n",
"\n",
"- `tidymodels`: [tidymodels](https://www.tidymodels.org/) ఫ్రేమ్‌వర్క్ అనేది మోడలింగ్ మరియు మెషీన్ లెర్నింగ్ కోసం [ప్యాకేజీల సేకరణ](https://www.tidymodels.org/packages/)!\n",
"\n",
"- `DataExplorer`: [DataExplorer ప్యాకేజీ](https://cran.r-project.org/web/packages/DataExplorer/vignettes/dataexplorer-intro.html) EDA ప్రక్రియ మరియు నివేదిక సృష్టిని సులభతరం చేయడానికి ఉద్దేశించబడింది.\n",
"\n",
"- `themis`: [themis ప్యాకేజీ](https://themis.tidymodels.org/) అసమతులిత డేటాతో వ్యవహరించడానికి అదనపు రెసిపీలు అందిస్తుంది.\n",
"\n",
"మీరు వాటిని ఇన్‌స్టాల్ చేసుకోవచ్చు:\n",
"\n",
"`install.packages(c(\"tidyverse\", \"tidymodels\", \"DataExplorer\", \"here\"))`\n",
"\n",
"వేరే విధంగా, క్రింది స్క్రిప్ట్ మీరు ఈ మాడ్యూల్ పూర్తి చేయడానికి అవసరమైన ప్యాకేజీలు ఉన్నాయా లేదా అని తనిఖీ చేసి, లేనప్పుడు వాటిని ఇన్‌స్టాల్ చేస్తుంది.\n"
],
"metadata": {
"id": "ri5bQxZ-Fz_0"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"suppressWarnings(if (!require(\"pacman\"))install.packages(\"pacman\"))\r\n",
"\r\n",
"pacman::p_load(tidyverse, tidymodels, DataExplorer, themis, here)"
],
"outputs": [],
"metadata": {
"id": "KIPxa4elGAPI"
}
},
{
"cell_type": "markdown",
"source": [
"మేము తరువాత ఈ అద్భుతమైన ప్యాకేజీలను లోడ్ చేసి మా ప్రస్తుత R సెషన్‌లో అందుబాటులో ఉంచుతాము. (ఇది కేవలం ఉదాహరణ కోసం, `pacman::p_load()` ఇప్పటికే మీ కోసం అది చేసింది)\n"
],
"metadata": {
"id": "YkKAxOJvGD4C"
}
},
{
"cell_type": "markdown",
"source": [
"## వ్యాయామం - మీ డేటాను శుభ్రం చేసి సమతుల్యం చేయండి\n",
"\n",
"ఈ ప్రాజెక్ట్ ప్రారంభించే ముందు మొదటి పని, మెరుగైన ఫలితాలు పొందడానికి మీ డేటాను శుభ్రం చేసి **సమతుల్యం** చేయడం\n",
"\n",
"డేటాను పరిచయం చేద్దాం!🕵️\n"
],
"metadata": {
"id": "PFkQDlk0GN5O"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Import data\r\n",
"df <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/4-Classification/data/cuisines.csv\")\r\n",
"\r\n",
"# View the first 5 rows\r\n",
"df %>% \r\n",
" slice_head(n = 5)\r\n"
],
"outputs": [],
"metadata": {
"id": "Qccw7okxGT0S"
}
},
{
"cell_type": "markdown",
"source": [
"ఆసక్తికరంగా ఉంది! దృష్టిలోకి తీసుకుంటే, మొదటి కాలమ్ ఒక రకమైన `id` కాలమ్ అని అనిపిస్తోంది. డేటా గురించి మరింత సమాచారం పొందుకుందాం.\n"
],
"metadata": {
"id": "XrWnlgSrGVmR"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Basic information about the data\r\n",
"df %>%\r\n",
" introduce()\r\n",
"\r\n",
"# Visualize basic information above\r\n",
"df %>% \r\n",
" plot_intro(ggtheme = theme_light())"
],
"outputs": [],
"metadata": {
"id": "4UcGmxRxGieA"
}
},
{
"cell_type": "markdown",
"source": [
"ఫలితంలోనుంచి, మనకు తక్షణమే కనిపిస్తుంది మన దగ్గర `2448` వరుసలు మరియు `385` కాలమ్స్ మరియు `0` మిస్సింగ్ విలువలు ఉన్నాయి. మన దగ్గర 1 డిస్క్రీట్ కాలమ్ కూడా ఉంది, *cuisine*.\n",
"\n",
"## వ్యాయామం - వంటకాల గురించి తెలుసుకోవడం\n",
"\n",
"ఇప్పుడు పని మరింత ఆసక్తికరంగా మారుతుంది. వంటకాల ప్రకారం డేటా పంపిణీని కనుగొనుకుందాం.\n"
],
"metadata": {
"id": "AaPubl__GmH5"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Count observations per cuisine\r\n",
"df %>% \r\n",
" count(cuisine) %>% \r\n",
" arrange(n)\r\n",
"\r\n",
"# Plot the distribution\r\n",
"theme_set(theme_light())\r\n",
"df %>% \r\n",
" count(cuisine) %>% \r\n",
" ggplot(mapping = aes(x = n, y = reorder(cuisine, -n))) +\r\n",
" geom_col(fill = \"midnightblue\", alpha = 0.7) +\r\n",
" ylab(\"cuisine\")"
],
"outputs": [],
"metadata": {
"id": "FRsBVy5eGrrv"
}
},
{
"cell_type": "markdown",
"source": [
"రుచుల సంఖ్య పరిమితమే, కానీ డేటా పంపిణీ అసమానంగా ఉంటుంది. మీరు దాన్ని సరిచేయవచ్చు! ఆ పని చేయడానికి ముందు, మరింత అన్వేషించండి.\n",
"\n",
"తర్వాత, ప్రతి రుచిని దాని వ్యక్తిగత టిబుల్‌లో కేటాయించి, ప్రతి రుచికి ఎంత డేటా (పంక్తులు, కాలమ్స్) అందుబాటులో ఉందో తెలుసుకుందాం.\n",
"\n",
"> ఒక [టిబుల్](https://tibble.tidyverse.org/) అనేది ఆధునిక డేటా ఫ్రేమ్.\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/dplyr_filter.b480b264b03439ff7051232a8de1df9a8fd4df723db316feb4f9f5e990db4318.te.jpg\"\n",
" width=\"600\"/>\n",
" <figcaption>కళాకృతి @allison_horst ద్వారా</figcaption>\n"
],
"metadata": {
"id": "vVvyDb1kG2in"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Create individual tibble for the cuisines\r\n",
"thai_df <- df %>% \r\n",
" filter(cuisine == \"thai\")\r\n",
"japanese_df <- df %>% \r\n",
" filter(cuisine == \"japanese\")\r\n",
"chinese_df <- df %>% \r\n",
" filter(cuisine == \"chinese\")\r\n",
"indian_df <- df %>% \r\n",
" filter(cuisine == \"indian\")\r\n",
"korean_df <- df %>% \r\n",
" filter(cuisine == \"korean\")\r\n",
"\r\n",
"\r\n",
"# Find out how much data is available per cuisine\r\n",
"cat(\" thai df:\", dim(thai_df), \"\\n\",\r\n",
" \"japanese df:\", dim(japanese_df), \"\\n\",\r\n",
" \"chinese_df:\", dim(chinese_df), \"\\n\",\r\n",
" \"indian_df:\", dim(indian_df), \"\\n\",\r\n",
" \"korean_df:\", dim(korean_df))"
],
"outputs": [],
"metadata": {
"id": "0TvXUxD3G8Bk"
}
},
{
"cell_type": "markdown",
"source": [
"Perfect!😋\n",
"\n",
"## **వ్యాయామం - dplyr ఉపయోగించి వంటకాల వారీగా టాప్ పదార్థాలను కనుగొనడం**\n",
"\n",
"ఇప్పుడు మీరు డేటాలో మరింత లోతుగా వెళ్ళి వంటకాల వారీగా సాధారణ పదార్థాలు ఏమిటి తెలుసుకోవచ్చు. వంటకాల మధ్య గందరగోళాన్ని సృష్టించే పునరావృత డేటాను మీరు శుభ్రం చేయాలి, కాబట్టి ఈ సమస్య గురించి తెలుసుకుందాం.\n",
"\n",
"R లో ఒక పదార్థ డేటాఫ్రేమ్‌ను తిరిగి ఇచ్చే `create_ingredient()` అనే ఫంక్షన్‌ను సృష్టించండి. ఈ ఫంక్షన్ ఒక ఉపయోగకరంలేని కాలమ్‌ను తొలగించడం ప్రారంభించి, పదార్థాలను వారి లెక్క ఆధారంగా సర్దుబాటు చేస్తుంది.\n",
"\n",
"R లో ఫంక్షన్ యొక్క ప్రాథమిక నిర్మాణం:\n",
"\n",
"`myFunction <- function(arglist){`\n",
"\n",
"**`...`**\n",
"\n",
"**`return`**`(value)`\n",
"\n",
"`}`\n",
"\n",
"R ఫంక్షన్లకు సంబంధించిన ఒక శుభ్రమైన పరిచయాన్ని మీరు [ఇక్కడ](https://skirmer.github.io/presentations/functions_with_r.html#1) చూడవచ్చు.\n",
"\n",
"మనం వెంటనే ప్రారంభిద్దాం! మనం గత పాఠాలలో నేర్చుకున్న [dplyr క్రియాపదాలు](https://dplyr.tidyverse.org/) ఉపయోగించబోతున్నాము. సారాంశంగా:\n",
"\n",
"- `dplyr::select()`: మీరు ఏ **కాలమ్స్** ఉంచాలో లేదా తీసివేయాలో ఎంచుకోవడంలో సహాయపడుతుంది.\n",
"\n",
"- `dplyr::pivot_longer()`: డేటాను \"పొడిగించడానికి\" సహాయపడుతుంది, పంక్తుల సంఖ్య పెరిగి కాలమ్స్ సంఖ్య తగ్గుతుంది.\n",
"\n",
"- `dplyr::group_by()` మరియు `dplyr::summarise()`: వేర్వేరు సమూహాల కోసం సారాంశ గణాంకాలను కనుగొనడంలో మరియు వాటిని మంచి పట్టికలో ఉంచడంలో సహాయపడతాయి.\n",
"\n",
"- `dplyr::filter()`: మీ షరతులకు అనుగుణంగా ఉన్న పంక్తులనే కలిగిన డేటా ఉపసమితిని సృష్టిస్తుంది.\n",
"\n",
"- `dplyr::mutate()`: కాలమ్స్ సృష్టించడంలో లేదా మార్చడంలో సహాయపడుతుంది.\n",
"\n",
"Allison Horst రాసిన ఈ [*కళ*-తో నిండిన learnr ట్యుటోరియల్](https://allisonhorst.shinyapps.io/dplyr-learnr/#section-welcome) ను చూడండి, ఇది dplyr లో కొన్ని ఉపయోగకరమైన డేటా వ్రాంగ్లింగ్ ఫంక్షన్లను పరిచయం చేస్తుంది *(Tidyverse భాగం)*\n"
],
"metadata": {
"id": "K3RF5bSCHC76"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Creates a functions that returns the top ingredients by class\r\n",
"\r\n",
"create_ingredient <- function(df){\r\n",
" \r\n",
" # Drop the id column which is the first colum\r\n",
" ingredient_df = df %>% select(-1) %>% \r\n",
" # Transpose data to a long format\r\n",
" pivot_longer(!cuisine, names_to = \"ingredients\", values_to = \"count\") %>% \r\n",
" # Find the top most ingredients for a particular cuisine\r\n",
" group_by(ingredients) %>% \r\n",
" summarise(n_instances = sum(count)) %>% \r\n",
" filter(n_instances != 0) %>% \r\n",
" # Arrange by descending order\r\n",
" arrange(desc(n_instances)) %>% \r\n",
" mutate(ingredients = factor(ingredients) %>% fct_inorder())\r\n",
" \r\n",
" \r\n",
" return(ingredient_df)\r\n",
"} # End of function"
],
"outputs": [],
"metadata": {
"id": "uB_0JR82HTPa"
}
},
{
"cell_type": "markdown",
"source": [
"ఇప్పుడు మనం ఆ ఫంక్షన్‌ను ఉపయోగించి వంటకాల వారీగా టాప్ టెన్ అత్యంత ప్రాచుర్యం పొందిన పదార్థాల ఆలోచన పొందవచ్చు. దీన్ని `thai_df` తో పరీక్షిద్దాం.\n"
],
"metadata": {
"id": "h9794WF8HWmc"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Call create_ingredient and display popular ingredients\r\n",
"thai_ingredient_df <- create_ingredient(df = thai_df)\r\n",
"\r\n",
"thai_ingredient_df %>% \r\n",
" slice_head(n = 10)"
],
"outputs": [],
"metadata": {
"id": "agQ-1HrcHaEA"
}
},
{
"cell_type": "markdown",
"source": [
"మునుపటి విభాగంలో, మేము `geom_col()` ఉపయోగించాము, ఇప్పుడు మీరు `geom_bar` ను కూడా ఎలా ఉపయోగించవచ్చో చూద్దాం, బార్ చార్ట్స్ సృష్టించడానికి. మరింత చదవడానికి `?geom_bar` ఉపయోగించండి.\n"
],
"metadata": {
"id": "kHu9ffGjHdcX"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Make a bar chart for popular thai cuisines\r\n",
"thai_ingredient_df %>% \r\n",
" slice_head(n = 10) %>% \r\n",
" ggplot(aes(x = n_instances, y = ingredients)) +\r\n",
" geom_bar(stat = \"identity\", width = 0.5, fill = \"steelblue\") +\r\n",
" xlab(\"\") + ylab(\"\")"
],
"outputs": [],
"metadata": {
"id": "fb3Bx_3DHj6e"
}
},
{
"cell_type": "markdown",
"source": [
"జపనీస్ డేటా కోసం కూడా అదే చేయండి\n"
],
"metadata": {
"id": "RHP_xgdkHnvM"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Get popular ingredients for Japanese cuisines and make bar chart\r\n",
"create_ingredient(df = japanese_df) %>% \r\n",
" slice_head(n = 10) %>%\r\n",
" ggplot(aes(x = n_instances, y = ingredients)) +\r\n",
" geom_bar(stat = \"identity\", width = 0.5, fill = \"darkorange\", alpha = 0.8) +\r\n",
" xlab(\"\") + ylab(\"\")\r\n"
],
"outputs": [],
"metadata": {
"id": "019v8F0XHrRU"
}
},
{
"cell_type": "markdown",
"source": [
"చైనీస్ వంటకాలు ఏమిటి?\n"
],
"metadata": {
"id": "iIGM7vO8Hu3v"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Get popular ingredients for Chinese cuisines and make bar chart\r\n",
"create_ingredient(df = chinese_df) %>% \r\n",
" slice_head(n = 10) %>%\r\n",
" ggplot(aes(x = n_instances, y = ingredients)) +\r\n",
" geom_bar(stat = \"identity\", width = 0.5, fill = \"cyan4\", alpha = 0.8) +\r\n",
" xlab(\"\") + ylab(\"\")"
],
"outputs": [],
"metadata": {
"id": "lHd9_gd2HyzU"
}
},
{
"cell_type": "markdown",
"source": [
"మనము భారతీయ వంటకాలను చూద్దాం 🌶️.\n"
],
"metadata": {
"id": "ir8qyQbNH1c7"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Get popular ingredients for Indian cuisines and make bar chart\r\n",
"create_ingredient(df = indian_df) %>% \r\n",
" slice_head(n = 10) %>%\r\n",
" ggplot(aes(x = n_instances, y = ingredients)) +\r\n",
" geom_bar(stat = \"identity\", width = 0.5, fill = \"#041E42FF\", alpha = 0.8) +\r\n",
" xlab(\"\") + ylab(\"\")"
],
"outputs": [],
"metadata": {
"id": "ApukQtKjH5FO"
}
},
{
"cell_type": "markdown",
"source": [
"చివరికి, కొరియన్ పదార్థాలను చిత్రీకరించండి.\n"
],
"metadata": {
"id": "qv30cwY1H-FM"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Get popular ingredients for Korean cuisines and make bar chart\r\n",
"create_ingredient(df = korean_df) %>% \r\n",
" slice_head(n = 10) %>%\r\n",
" ggplot(aes(x = n_instances, y = ingredients)) +\r\n",
" geom_bar(stat = \"identity\", width = 0.5, fill = \"#852419FF\", alpha = 0.8) +\r\n",
" xlab(\"\") + ylab(\"\")"
],
"outputs": [],
"metadata": {
"id": "lumgk9cHIBie"
}
},
{
"cell_type": "markdown",
"source": [
"డేటా విజువలైజేషన్ల నుండి, ఇప్పుడు మనం `dplyr::select()` ఉపయోగించి వేర్వేరు వంటకాల మధ్య గందరగోళం సృష్టించే అత్యంత సాధారణ పదార్థాలను తొలగించవచ్చు.\n",
"\n",
"ప్రతి ఒక్కరూ బియ్యం, వెల్లుల్లి మరియు అల్లం ప్రేమిస్తారు!\n"
],
"metadata": {
"id": "iO4veMXuIEta"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Drop id column, rice, garlic and ginger from our original data set\r\n",
"df_select <- df %>% \r\n",
" select(-c(1, rice, garlic, ginger))\r\n",
"\r\n",
"# Display new data set\r\n",
"df_select %>% \r\n",
" slice_head(n = 5)"
],
"outputs": [],
"metadata": {
"id": "iHJPiG6rIUcK"
}
},
{
"cell_type": "markdown",
"source": [
"## రెసిపీలను ఉపయోగించి డేటాను ప్రీప్రాసెస్ చేయడం 👩‍🍳👨‍🍳 - అసమతుల్య డేటాతో వ్యవహరించడం ⚖️\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/recipes.186acfa8ed2e8f0059ce17ef22c9452d7b25e7e1e4b044573bacec9a18e040d2.te.png\"\n",
" width=\"600\"/>\n",
" <figcaption>కళాకృతి @allison_horst</figcaption>\n",
"\n",
"ఈ పాఠం వంటకాల గురించి కావడంతో, మనం `recipes` ను సందర్భంలో పెట్టాలి.\n",
"\n",
"Tidymodels మరో చక్కటి ప్యాకేజీని అందిస్తుంది: `recipes` - డేటాను ప్రీప్రాసెస్ చేయడానికి ఒక ప్యాకేజీ.\n"
],
"metadata": {
"id": "kkFd-JxdIaL6"
}
},
{
"cell_type": "markdown",
"source": [
"మళ్లీ మన వంటకాల పంపిణీని చూద్దాం.\n"
],
"metadata": {
"id": "6l2ubtTPJAhY"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Distribution of cuisines\r\n",
"old_label_count <- df_select %>% \r\n",
" count(cuisine) %>% \r\n",
" arrange(desc(n))\r\n",
"\r\n",
"old_label_count"
],
"outputs": [],
"metadata": {
"id": "1e-E9cb7JDVi"
}
},
{
"cell_type": "markdown",
"source": [
"\n",
"మీరు చూడగలిగినట్లుగా, వంటకాల సంఖ్యలో చాలా అసమానమైన పంపిణీ ఉంది. కొరియన్ వంటకాలు థాయ్ వంటకాల కంటే సుమారు 3 రెట్లు ఎక్కువ ఉన్నాయి. అసమతుల్య డేటా తరచుగా మోడల్ పనితీరుపై ప్రతికూల ప్రభావాలు చూపుతుంది. ఒక ద్విభాగ వర్గీకరణను ఆలోచించండి. మీ డేటా ఎక్కువ భాగం ఒక వర్గం అయితే, ఒక ML మోడల్ ఆ వర్గాన్ని ఎక్కువగా అంచనా వేయడానికి ప్రయత్నిస్తుంది, ఎందుకంటే ఆ వర్గానికి ఎక్కువ డేటా ఉంటుంది. డేటాను సమతుల్యం చేయడం అనేది ఏదైనా వక్రీకృత డేటాను తీసుకుని ఈ అసమతుల్యతను తొలగించడంలో సహాయపడుతుంది. చాలా మోడల్స్ గమనికల సంఖ్య సమానంగా ఉన్నప్పుడు ఉత్తమంగా పనిచేస్తాయి, అందువల్ల అసమతుల్య డేటాతో పోరాడుతాయి.\n",
"\n",
"అసమతుల్య డేటా సెట్‌లను నిర్వహించడానికి ప్రధానంగా రెండు మార్గాలు ఉన్నాయి:\n",
"\n",
"- మైనారిటీ వర్గానికి గమనికలను జోడించడం: `ఓవర్-సాంప్లింగ్` ఉదా: SMOTE అల్గోరిథం ఉపయోగించడం\n",
"\n",
"- మెజారిటీ వర్గం నుండి గమనికలను తొలగించడం: `అండర్-సాంప్లింగ్`\n",
"\n",
"ఇప్పుడు `recipe` ఉపయోగించి అసమతుల్య డేటా సెట్‌లను ఎలా నిర్వహించాలో చూపిద్దాం. ఒక recipe అనేది డేటా విశ్లేషణకు సిద్ధం చేయడానికి డేటా సెట్‌పై ఏ దశలను వర్తించాలో వివరించే ఒక బ్లూప్రింట్‌గా భావించవచ్చు.\n"
],
"metadata": {
"id": "soAw6826JKx9"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Load themis package for dealing with imbalanced data\r\n",
"library(themis)\r\n",
"\r\n",
"# Create a recipe for preprocessing data\r\n",
"cuisines_recipe <- recipe(cuisine ~ ., data = df_select) %>% \r\n",
" step_smote(cuisine)\r\n",
"\r\n",
"cuisines_recipe"
],
"outputs": [],
"metadata": {
"id": "HS41brUIJVJy"
}
},
{
"cell_type": "markdown",
"source": [
"మనం మా ప్రీప్రాసెసింగ్ దశలను విడదీయండి.\n",
"\n",
"- ఫార్ములాతో `recipe()` కాల్ వేరియబుల్స్ యొక్క *పాత్రలను* `df_select` డేటాను సూచనగా ఉపయోగించి రిసిపీకి చెబుతుంది. ఉదాహరణకు `cuisine` కాలమ్‌కు `outcome` పాత్ర కేటాయించబడింది, మిగతా కాలమ్స్‌కు `predictor` పాత్ర కేటాయించబడింది.\n",
"\n",
"- [`step_smote(cuisine)`](https://themis.tidymodels.org/reference/step_smote.html) ఒక రిసిపీ దశ యొక్క *వివరణ* సృష్టిస్తుంది, ఇది ఈ కేసుల సమీప పొరుగువారిని ఉపయోగించి మైనారిటీ తరగతి యొక్క కొత్త ఉదాహరణలను సింథటిక్‌గా ఉత్పత్తి చేస్తుంది.\n",
"\n",
"ఇప్పుడు, మనం ప్రీప్రాసెస్డ్ డేటాను చూడాలనుకుంటే, మనం [**`prep()`**](https://recipes.tidymodels.org/reference/prep.html) మరియు [**`bake()`**](https://recipes.tidymodels.org/reference/bake.html) మా రిసిపీని ఉపయోగించాలి.\n",
"\n",
"`prep()`: శిక్షణ సెట్ నుండి అవసరమైన పారామితులను అంచనా వేస్తుంది, ఇవి తర్వాత ఇతర డేటా సెట్‌లకు వర్తించవచ్చు.\n",
"\n",
"`bake()`: ప్రిప్ చేసిన రిసిపీని తీసుకుని ఆపరేషన్లను ఏదైనా డేటా సెట్‌కు వర్తింపజేస్తుంది.\n"
],
"metadata": {
"id": "Yb-7t7XcJaC8"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Prep and bake the recipe\r\n",
"preprocessed_df <- cuisines_recipe %>% \r\n",
" prep() %>% \r\n",
" bake(new_data = NULL) %>% \r\n",
" relocate(cuisine)\r\n",
"\r\n",
"# Display data\r\n",
"preprocessed_df %>% \r\n",
" slice_head(n = 5)\r\n",
"\r\n",
"# Quick summary stats\r\n",
"preprocessed_df %>% \r\n",
" introduce()"
],
"outputs": [],
"metadata": {
"id": "9QhSgdpxJl44"
}
},
{
"cell_type": "markdown",
"source": [
"ఇప్పుడు మన వంటకాల పంపిణీని పరిశీలించి, అవి అసమతుల్య డేటాతో పోల్చుకుందాం.\n"
],
"metadata": {
"id": "dmidELh_LdV7"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Distribution of cuisines\r\n",
"new_label_count <- preprocessed_df %>% \r\n",
" count(cuisine) %>% \r\n",
" arrange(desc(n))\r\n",
"\r\n",
"list(new_label_count = new_label_count,\r\n",
" old_label_count = old_label_count)"
],
"outputs": [],
"metadata": {
"id": "aSh23klBLwDz"
}
},
{
"cell_type": "markdown",
"source": [
"యమ్! డేటా బాగుంది, శుభ్రంగా ఉంది, సమతుల్యం ఉంది, మరియు చాలా రుచికరంగా ఉంది 😋!\n",
"\n",
"> సాధారణంగా, ఒక రెసిపీ సాధారణంగా మోడలింగ్ కోసం ప్రీప్రాసెసర్‌గా ఉపయోగించబడుతుంది, ఇది మోడలింగ్ కోసం సిద్ధం చేయడానికి డేటా సెట్‌పై ఏ దశలను వర్తించాలో నిర్వచిస్తుంది. ఆ సందర్భంలో, మానవీయంగా రెసిపీ అంచనా వేయడం బదులు `workflow()` సాధారణంగా ఉపయోగించబడుతుంది (మనం మా గత పాఠాలలో ఇప్పటికే చూసినట్లుగా)\n",
">\n",
"> అందువల్ల, మీరు సాధారణంగా tidymodels ఉపయోగించినప్పుడు రెసిపీలను **`prep()`** మరియు **`bake()`** చేయాల్సిన అవసరం లేదు, కానీ అవి మీ టూల్‌కిట్‌లో ఉండే సహాయక ఫంక్షన్లు, మా సందర్భంలో ఉన్నట్లుగా రెసిపీలు మీరు ఆశించినట్లుగా పనిచేస్తున్నాయా అని నిర్ధారించుకోవడానికి.\n",
">\n",
"> మీరు **`bake()`** చేసినప్పుడు ప్రిప్ చేసిన రెసిపీతో **`new_data = NULL`** ఉంటే, మీరు రెసిపీ నిర్వచించినప్పుడు అందించిన డేటాను తిరిగి పొందుతారు, కానీ ప్రీప్రాసెసింగ్ దశల ద్వారా గడిచిన.\n",
"\n",
"ఇప్పుడు భవిష్యత్తు పాఠాలలో ఉపయోగించడానికి ఈ డేటా యొక్క కాపీని సేవ్ చేద్దాం:\n"
],
"metadata": {
"id": "HEu80HZ8L7ae"
}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Save preprocessed data\r\n",
"write_csv(preprocessed_df, \"../../../data/cleaned_cuisines_R.csv\")"
],
"outputs": [],
"metadata": {
"id": "cBmCbIgrMOI6"
}
},
{
"cell_type": "markdown",
"source": [
"ఈ తాజా CSV ఇప్పుడు రూట్ డేటా ఫోల్డర్‌లో కనుగొనవచ్చు.\n",
"\n",
"**🚀సవాలు**\n",
"\n",
"ఈ పాఠ్యక్రమంలో అనేక ఆసక్తికరమైన డేటాసెట్‌లు ఉన్నాయి. `data` ఫోల్డర్లలో గూఢచర్య చేయండి మరియు ఏవైనా బైనరీ లేదా బహుళ-వర్గ వర్గీకరణకు అనుకూలమైన డేటాసెట్‌లు ఉన్నాయా అని చూడండి? ఈ డేటాసెట్ నుండి మీరు ఏ ప్రశ్నలు అడగగలరు?\n",
"\n",
"## [**పోస్ట్-లెక్చర్ క్విజ్**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/20/)\n",
"\n",
"## **సమీక్ష & స్వీయ అధ్యయనం**\n",
"\n",
"- [package themis](https://github.com/tidymodels/themis) ను పరిశీలించండి. అసమతుల్య డేటాను నిర్వహించడానికి మేము ఉపయోగించగల ఇతర సాంకేతికతలు ఏమిటి?\n",
"\n",
"- Tidy మోడల్స్ [సూచన వెబ్‌సైట్](https://www.tidymodels.org/start/).\n",
"\n",
"- H. Wickham మరియు G. Grolemund, [*R for Data Science: Visualize, Model, Transform, Tidy, and Import Data*](https://r4ds.had.co.nz/).\n",
"\n",
"#### ధన్యవాదాలు:\n",
"\n",
"[`Allison Horst`](https://twitter.com/allison_horst/) కు R ను మరింత ఆహ్లాదకరంగా మరియు ఆకర్షణీయంగా మార్చే అద్భుతమైన చిత్రణలను సృష్టించినందుకు. ఆమె [గ్యాలరీ](https://www.google.com/url?q=https://github.com/allisonhorst/stats-illustrations&sa=D&source=editors&ust=1626380772530000&usg=AOvVaw3zcfyCizFQZpkSLzxiiQEM) లో మరిన్ని చిత్రణలను కనుగొనండి.\n",
"\n",
"[Cassie Breviu](https://www.twitter.com/cassieview) మరియు [Jen Looper](https://www.twitter.com/jenlooper) కు ఈ మాడ్యూల్ యొక్క అసలు Python సంస్కరణను సృష్టించినందుకు ♥️\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/r_learners_sm.cd14eb3581a9f28d32086cc042ee8c46f621a5b4e0d59c75f7c642d891327043.te.jpeg\"\n",
" width=\"600\"/>\n",
" <figcaption>Artwork by @allison_horst</figcaption>\n"
],
"metadata": {
"id": "WQs5621pMGwf"
}
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

677
translations/te/4-Classification/1-Introduction/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

257
translations/te/4-Classification/2-Classifiers-1/README.md
Unescape View File

@ -0,0 +1,257 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1a6e9e46b34a2e559fbbfc1f95397c7b",
"translation_date": "2025-12-19T15:30:48+00:00",
"source_file": "4-Classification/2-Classifiers-1/README.md",
"language_code": "te"
}
-->
# వంటకాల వర్గీకరణలు 1
ఈ పాఠంలో, మీరు గత పాఠం నుండి సేవ్ చేసిన సమతుల్యమైన, శుభ్రమైన వంటకాల డేటా సెట్‌ను ఉపయోగిస్తారు.
మీరు ఈ డేటా సెట్‌ను వివిధ వర్గీకరణలతో ఉపయోగించి _ఒక సమూహం పదార్థాల ఆధారంగా ఒక జాతీయ వంటకాన్ని అంచనా వేయడానికి_ ప్రయత్నిస్తారు. ఈ ప్రక్రియలో, వర్గీకరణ పనుల కోసం అల్గోరిథమ్స్‌ను ఎలా ఉపయోగించవచ్చో మీరు మరింత తెలుసుకుంటారు.
## [పాఠం ముందు క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
# సిద్ధత
మీరు [పాఠం 1](../1-Introduction/README.md) పూర్తి చేశారని అనుకుంటే, ఈ నాలుగు పాఠాల కోసం రూట్ `/data` ఫోల్డర్‌లో _cleaned_cuisines.csv_ ఫైల్ ఉందని నిర్ధారించుకోండి.
## వ్యాయామం - జాతీయ వంటకాన్ని అంచనా వేయండి
1. ఈ పాఠంలోని _notebook.ipynb_ ఫోల్డర్‌లో పని చేస్తూ, ఆ ఫైల్‌ను మరియు Pandas లైబ్రరీని దిగుమతి చేసుకోండి:
```python
import pandas as pd
cuisines_df = pd.read_csv("../data/cleaned_cuisines.csv")
cuisines_df.head()
```
డేటా ఇలా ఉంటుంది:
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
| 0 | 0 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 1 | 1 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 2 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 3 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 4 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
1. ఇప్పుడు, మరికొన్ని లైబ్రరీలను దిగుమతి చేసుకోండి:
```python
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
from sklearn.svm import SVC
import numpy as np
```
1. X మరియు y కోఆర్డినేట్లను రెండు డేటాఫ్రేమ్‌లుగా విభజించండి. `cuisine` లేబుల్స్ డేటాఫ్రేమ్ కావచ్చు:
```python
cuisines_label_df = cuisines_df['cuisine']
cuisines_label_df.head()
```
ఇది ఇలా కనిపిస్తుంది:
```output
0 indian
1 indian
2 indian
3 indian
4 indian
Name: cuisine, dtype: object
```
1. ఆ `Unnamed: 0` కాలమ్ మరియు `cuisine` కాలమ్‌ను `drop()` పిలిచి తొలగించండి. మిగతా డేటాను శిక్షణ ఫీచర్లుగా సేవ్ చేయండి:
```python
cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)
cuisines_feature_df.head()
```
మీ ఫీచర్లు ఇలా ఉంటాయి:
| | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | artemisia | artichoke | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
| ---: | -----: | -------: | ----: | ---------: | ----: | -----------: | ------: | -------: | --------: | --------: | ---: | ------: | ----------: | ---------: | ----------------------: | ---: | ---: | ---: | ----: | -----: | -------: |
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
ఇప్పుడు మీరు మీ మోడల్‌ను శిక్షణ ఇవ్వడానికి సిద్ధంగా ఉన్నారు!
## మీ వర్గీకరణకర్తను ఎంచుకోవడం
మీ డేటా శుభ్రంగా మరియు శిక్షణకు సిద్ధంగా ఉన్నప్పుడు, మీరు ఏ అల్గోరిథం ఉపయోగించాలో నిర్ణయించుకోవాలి.
Scikit-learn వర్గీకరణను సూపర్వైజ్డ్ లెర్నింగ్ కింద వర్గీకరిస్తుంది, ఆ విభాగంలో మీరు వర్గీకరించడానికి అనేక మార్గాలను కనుగొంటారు. [వివిధత](https://scikit-learn.org/stable/supervised_learning.html) మొదటి చూపులో కొంచెం గందరగోళంగా ఉంటుంది. క్రింది పద్ధతులు అన్ని వర్గీకరణ సాంకేతికతలను కలిగి ఉంటాయి:
- లీనియర్ మోడల్స్
- సపోర్ట్ వెక్టర్ మెషీన్స్
- స్టోకాస్టిక్ గ్రాడియెంట్ డిసెంట్
- సమీప పొరుగువారు
- గౌసియన్ ప్రాసెస్‌లు
- నిర్ణయ వృక్షాలు
- ఎంసెంబుల్ పద్ధతులు (వోటింగ్ క్లాసిఫయర్)
- మల్టిక్లాస్ మరియు మల్టీఔట్పుట్ అల్గోరిథమ్స్ (మల్టిక్లాస్ మరియు మల్టీలేబుల్ వర్గీకరణ, మల్టిక్లాస్-మల్టీఔట్పుట్ వర్గీకరణ)
> మీరు [న్యూరల్ నెట్‌వర్క్స్‌ను కూడా వర్గీకరణకు ఉపయోగించవచ్చు](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), కానీ అది ఈ పాఠం పరిధికి బయట ఉంది.
### ఏ వర్గీకరణకర్తను ఎంచుకోవాలి?
అయితే, మీరు ఏ వర్గీకరణకర్తను ఎంచుకోవాలి? తరచుగా, అనేక వర్గీకరణకర్తలను పరీక్షించి మంచి ఫలితాన్ని చూసే విధానం ఒక పరీక్షా మార్గం. Scikit-learn ఒక [పక్కపక్కన పోలిక](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html)ను సృష్టించిన డేటాసెట్‌పై అందిస్తుంది, ఇందులో KNeighbors, SVC రెండు విధాలుగా, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB మరియు QuadraticDiscrinationAnalysis పోల్చబడతాయి, ఫలితాలు విజువలైజ్ చేయబడ్డాయి:
![వర్గీకరణకర్తల పోలిక](../../../../translated_images/comparison.edfab56193a85e7fdecbeaa1b1f8c99e94adbf7178bed0de902090cf93d6734f.te.png)
> Scikit-learn డాక్యుమెంటేషన్‌లో రూపొందించిన ప్లాట్లు
> AutoML ఈ సమస్యను క్లౌడ్‌లో ఈ పోలికలను నడిపించి, మీ డేటాకు ఉత్తమ అల్గోరిథం ఎంచుకునే అవకాశం ఇస్తూ సులభంగా పరిష్కరిస్తుంది. దీన్ని [ఇక్కడ](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott) ప్రయత్నించండి
### మెరుగైన దృష్టికోణం
అనుమానించకుండా అంచనా వేయడం కంటే మెరుగైన మార్గం, ఈ డౌన్లోడ్ చేసుకునే [ML చీట్ షీట్](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott)లోని ఆలోచనలను అనుసరించడం. ఇక్కడ, మన మల్టిక్లాస్ సమస్య కోసం కొన్ని ఎంపికలు ఉన్నాయి:
![మల్టిక్లాస్ సమస్యల కోసం చీట్ షీట్](../../../../translated_images/cheatsheet.07a475ea444d22234cb8907a3826df5bdd1953efec94bd18e4496f36ff60624a.te.png)
> మైక్రోసాఫ్ట్ యొక్క అల్గోరిథం చీట్ షీట్‌లోని ఒక భాగం, మల్టిక్లాస్ వర్గీకరణ ఎంపికలను వివరించడం
✅ ఈ చీట్ షీట్‌ను డౌన్లోడ్ చేసుకుని, ప్రింట్ చేసి, మీ గోడపై పెట్టుకోండి!
### తర్కం
మన వద్ద ఉన్న పరిమితులను దృష్టిలో ఉంచుకుని వివిధ దృష్టికోణాలను తర్కం చేయగలమా చూద్దాం:
- **న్యూరల్ నెట్‌వర్క్స్ చాలా భారమైనవి**. మన శుభ్రమైన, కానీ కనిష్ట డేటాసెట్ మరియు నోట్బుక్స్ ద్వారా స్థానికంగా శిక్షణ నడుపుతున్నందున, న్యూరల్ నెట్‌వర్క్స్ ఈ పనికి చాలా భారమైనవి.
- **రెండు-వర్గ వర్గీకరణకర్త లేదు**. మేము రెండు-వర్గ వర్గీకరణకర్తను ఉపయోగించము, కాబట్టి ఒకటి-వర్సెస్-అల్ (one-vs-all) తప్పు అవుతుంది.
- **నిర్ణయ వృక్షం లేదా లాజిస్టిక్ రిగ్రెషన్ పనిచేయవచ్చు**. ఒక నిర్ణయ వృక్షం పనిచేయవచ్చు, లేదా మల్టిక్లాస్ డేటాకు లాజిస్టిక్ రిగ్రెషన్.
- **మల్టిక్లాస్ బూస్టెడ్ నిర్ణయ వృక్షాలు వేరే సమస్యను పరిష్కరిస్తాయి**. మల్టిక్లాస్ బూస్టెడ్ నిర్ణయ వృక్షం ప్రధానంగా నాన్‌పారామెట్రిక్ పనులకు అనుకూలం, ఉదా: ర్యాంకింగ్స్ నిర్మాణం కోసం, కాబట్టి మనకు ఉపయోగకరం కాదు.
### Scikit-learn ఉపయోగించడం
మనం Scikit-learn ఉపయోగించి మన డేటాను విశ్లేషించబోతున్నాము. అయితే, Scikit-learnలో లాజిస్టిక్ రిగ్రెషన్ ఉపయోగించడానికి అనేక మార్గాలు ఉన్నాయి. [పారామీటర్లను](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression) చూడండి.
మూలంగా రెండు ముఖ్యమైన పారామీటర్లు ఉన్నాయి - `multi_class` మరియు `solver` - ఇవి Scikit-learnకి లాజిస్టిక్ రిగ్రెషన్ చేయమని అడిగేటప్పుడు నిర్దేశించాలి. `multi_class` విలువ ఒక నిర్దిష్ట ప్రవర్తనను అమలు చేస్తుంది. solver విలువ అనేది ఏ అల్గోరిథం ఉపయోగించాలో సూచిస్తుంది. అన్ని solverలు అన్ని `multi_class` విలువలతో జత కాబోవు.
డాక్యుమెంటేషన్ ప్రకారం, మల్టిక్లాస్ సందర్భంలో శిక్షణ అల్గోరిథం:
- **ఒకటి-వర్సెస్-రెస్ట్ (OvR) పద్ధతిని ఉపయోగిస్తుంది**, `multi_class` ఎంపిక `ovr`గా ఉంటే
- **క్రాస్-ఎంట్రోపీ నష్టం ఉపయోగిస్తుంది**, `multi_class` ఎంపిక `multinomial`గా ఉంటే. (ప్రస్తుతం `multinomial` ఎంపిక ‘lbfgs’, ‘sag’, ‘saga’ మరియు ‘newton-cg’ solverలతో మాత్రమే మద్దతు ఇస్తుంది.)"
> 🎓 ఇక్కడ 'పద్ధతి' అంటే 'ovr' (ఒకటి-వర్సెస్-రెస్ట్) లేదా 'multinomial'. లాజిస్టిక్ రిగ్రెషన్ అసలు బైనరీ వర్గీకరణకు రూపొందించబడినందున, ఈ పద్ధతులు మల్టిక్లాస్ వర్గీకరణ పనులను మెరుగ్గా నిర్వహించడానికి సహాయపడతాయి. [మూలం](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
> 🎓 'solver' అనేది "ఆప్టిమైజేషన్ సమస్యలో ఉపయోగించే అల్గోరిథం" అని నిర్వచించబడింది. [మూలం](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
Scikit-learn ఈ పట్టికను అందిస్తుంది, వివిధ డేటా నిర్మాణాల సవాళ్లను solverలు ఎలా నిర్వహిస్తాయో వివరించడానికి:
![solverలు](../../../../translated_images/solvers.5fc648618529e627dfac29b917b3ccabda4b45ee8ed41b0acb1ce1441e8d1ef1.te.png)
## వ్యాయామం - డేటాను విభజించండి
మీరు ఇటీవల ఒక పాఠంలో లాజిస్టిక్ రిగ్రెషన్ గురించి నేర్చుకున్నందున, మొదటి శిక్షణ ప్రయత్నానికి లాజిస్టిక్ రిగ్రెషన్‌పై దృష్టి పెట్టవచ్చు.
`train_test_split()` పిలిచి మీ డేటాను శిక్షణ మరియు పరీక్షా సమూహాలుగా విభజించండి:
```python
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
```
## వ్యాయామం - లాజిస్టిక్ రిగ్రెషన్ వర్తించండి
మీరు మల్టిక్లాస్ సందర్భాన్ని ఉపయోగిస్తున్నందున, ఏ _పద్ధతి_ ఉపయోగించాలో మరియు ఏ _solver_ సెట్ చేయాలో ఎంచుకోవాలి. మల్టిక్లాస్ సెట్టింగ్‌తో మరియు **liblinear** solverతో LogisticRegression ఉపయోగించి శిక్షణ ఇవ్వండి.
1. multi_class ను `ovr`గా మరియు solver ను `liblinear`గా సెట్ చేసి లాజిస్టిక్ రిగ్రెషన్ సృష్టించండి:
```python
lr = LogisticRegression(multi_class='ovr',solver='liblinear')
model = lr.fit(X_train, np.ravel(y_train))
accuracy = model.score(X_test, y_test)
print ("Accuracy is {}".format(accuracy))
```
✅ తరచుగా డిఫాల్ట్‌గా సెట్ అయ్యే `lbfgs` వంటి వేరే solverను ప్రయత్నించండి
> గమనిక, అవసరమైతే మీ డేటాను ఫ్లాటెన్ చేయడానికి Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) ఫంక్షన్ ఉపయోగించండి.
ఖచ్చితత్వం **80%** కంటే ఎక్కువగా మంచి ఉంది!
1. మీరు ఈ మోడల్‌ను ఒక డేటా వరుస (#50) పరీక్షించి చూడవచ్చు:
```python
print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}')
print(f'cuisine: {y_test.iloc[50]}')
```
ఫలితం ముద్రించబడుతుంది:
```output
ingredients: Index(['cilantro', 'onion', 'pea', 'potato', 'tomato', 'vegetable_oil'], dtype='object')
cuisine: indian
```
✅ వేరే రో నంబర్ ప్రయత్నించి ఫలితాలను తనిఖీ చేయండి
1. మరింత లోతుగా పరిశీలిస్తే, మీరు ఈ అంచనాకు ఖచ్చితత్వాన్ని తనిఖీ చేయవచ్చు:
```python
test= X_test.iloc[50].values.reshape(-1, 1).T
proba = model.predict_proba(test)
classes = model.classes_
resultdf = pd.DataFrame(data=proba, columns=classes)
topPrediction = resultdf.T.sort_values(by=[0], ascending = [False])
topPrediction.head()
```
ఫలితం ముద్రించబడింది - భారతీయ వంటకం ఇది అత్యుత్తమ అంచనా, మంచి సంభావ్యతతో:
| | 0 |
| -------: | -------: |
| indian | 0.715851 |
| chinese | 0.229475 |
| japanese | 0.029763 |
| korean | 0.017277 |
| thai | 0.007634 |
✅ ఈ మోడల్ భారతీయ వంటకం అని ఎందుకు చాలా నమ్మకం కలిగి ఉందో మీరు వివరించగలరా?
1. మీరు రిగ్రెషన్ పాఠాలలో చేసినట్లుగా క్లాసిఫికేషన్ రిపోర్ట్ ముద్రించి మరింత వివరాలు పొందండి:
```python
y_pred = model.predict(X_test)
print(classification_report(y_test,y_pred))
```
| | precision | recall | f1-score | support |
| ------------ | --------- | ------ | -------- | ------- |
| chinese | 0.73 | 0.71 | 0.72 | 229 |
| indian | 0.91 | 0.93 | 0.92 | 254 |
| japanese | 0.70 | 0.75 | 0.72 | 220 |
| korean | 0.86 | 0.76 | 0.81 | 242 |
| thai | 0.79 | 0.85 | 0.82 | 254 |
| accuracy | 0.80 | 1199 | | |
| macro avg | 0.80 | 0.80 | 0.80 | 1199 |
| weighted avg | 0.80 | 0.80 | 0.80 | 1199 |
## 🚀సవాలు
ఈ పాఠంలో, మీరు శుభ్రపరిచిన డేటాను ఉపయోగించి పదార్థాల శ్రేణి ఆధారంగా జాతీయ వంటకాన్ని అంచనా వేయగల యంత్ర అభ్యాస మోడల్‌ను నిర్మించారు. డేటాను వర్గీకరించడానికి Scikit-learn అందించే అనేక ఎంపికలను చదవడానికి కొంత సమయం తీసుకోండి. 'solver' అనే భావనలో మరింత లోతుగా వెళ్ళి దాని వెనుక జరిగే ప్రక్రియలను అర్థం చేసుకోండి.
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
లాజిస్టిక్ రిగ్రెషన్ వెనుక గణితాన్ని మరింత లోతుగా తెలుసుకోండి [ఈ పాఠంలో](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)
## అసైన్‌మెంట్
[solvers ను అధ్యయనం చేయండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

25
translations/te/4-Classification/2-Classifiers-1/assignment.md
Unescape View File

@ -0,0 +1,25 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "de6025f96841498b0577e9d1aee18d1f",
"translation_date": "2025-12-19T15:35:54+00:00",
"source_file": "4-Classification/2-Classifiers-1/assignment.md",
"language_code": "te"
}
-->
# పరిష్కారకులను అధ్యయనం చేయండి
## సూచనలు
ఈ పాఠంలో మీరు యంత్ర అభ్యాస ప్రక్రియతో అల్గోరిథమ్స్ జతచేసే వివిధ పరిష్కారకుల గురించి నేర్చుకున్నారు, అవి ఖచ్చితమైన మోడల్‌ను సృష్టిస్తాయి. పాఠంలో పేర్కొన్న పరిష్కారకులను పరిశీలించి రెండు ఎంచుకోండి. మీ స్వంత మాటల్లో, ఈ రెండు పరిష్కారకులను పోల్చి, వ్యత్యాసాలను వివరించండి. అవి ఏ రకమైన సమస్యలను పరిష్కరిస్తాయి? అవి వివిధ డేటా నిర్మాణాలతో ఎలా పనిచేస్తాయి? ఒకదానిని మరొకదానిపై ఎందుకు ఎంచుకుంటారు?
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------ | ---------------------------- |
| | రెండు పరిష్కారకులపై ఒక్కో పేరాగ్రాఫ్‌తో కూడిన .doc ఫైల్ సమర్పించబడింది, అవి ఆలోచనాత్మకంగా పోల్చబడ్డాయి. | ఒక్క పేరాగ్రాఫ్‌తో కూడిన .doc ఫైల్ సమర్పించబడింది | అసైన్‌మెంట్ పూర్తి కాలేదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

41
translations/te/4-Classification/2-Classifiers-1/notebook.ipynb
Unescape View File

@ -0,0 +1,41 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": 3
},
"orig_nbformat": 2,
"coopTranslator": {
"original_hash": "68829b06b4dcd512d3327849191f4d7f",
"translation_date": "2025-12-19T17:03:17+00:00",
"source_file": "4-Classification/2-Classifiers-1/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"source": [
"# వర్గీకరణ మోడల్స్ నిర్మించండి\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

17
translations/te/4-Classification/2-Classifiers-1/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T15:37:55+00:00",
"source_file": "4-Classification/2-Classifiers-1/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

1302
translations/te/4-Classification/2-Classifiers-1/solution/R/lesson_11-R.ipynb
View File

File diff suppressed because one or more lines are too long

281
translations/te/4-Classification/2-Classifiers-1/solution/notebook.ipynb
Unescape View File

@ -0,0 +1,281 @@
{
"cells": [
{
"source": [
"# వర్గీకరణ మోడల్స్ నిర్మించండి\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" Unnamed: 0 cuisine almond angelica anise anise_seed apple \\\n",
"0 0 indian 0 0 0 0 0 \n",
"1 1 indian 1 0 0 0 0 \n",
"2 2 indian 0 0 0 0 0 \n",
"3 3 indian 0 0 0 0 0 \n",
"4 4 indian 0 0 0 0 0 \n",
"\n",
" apple_brandy apricot armagnac ... whiskey white_bread white_wine \\\n",
"0 0 0 0 ... 0 0 0 \n",
"1 0 0 0 ... 0 0 0 \n",
"2 0 0 0 ... 0 0 0 \n",
"3 0 0 0 ... 0 0 0 \n",
"4 0 0 0 ... 0 0 0 \n",
"\n",
" whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
"0 0 0 0 0 0 0 0 \n",
"1 0 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 1 0 \n",
"\n",
"[5 rows x 382 columns]"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>Unnamed: 0</th>\n <th>cuisine</th>\n <th>almond</th>\n <th>angelica</th>\n <th>anise</th>\n <th>anise_seed</th>\n <th>apple</th>\n <th>apple_brandy</th>\n <th>apricot</th>\n <th>armagnac</th>\n <th>...</th>\n <th>whiskey</th>\n <th>white_bread</th>\n <th>white_wine</th>\n <th>whole_grain_wheat_flour</th>\n <th>wine</th>\n <th>wood</th>\n <th>yam</th>\n <th>yeast</th>\n <th>yogurt</th>\n <th>zucchini</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>0</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>1</th>\n <td>1</td>\n <td>indian</td>\n <td>1</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>2</th>\n <td>2</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>3</th>\n <td>3</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>4</th>\n <td>4</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>1</td>\n <td>0</td>\n </tr>\n </tbody>\n</table>\n<p>5 rows × 382 columns</p>\n</div>"
},
"metadata": {},
"execution_count": 1
}
],
"source": [
"import pandas as pd\n",
"cuisines_df = pd.read_csv(\"../../data/cleaned_cuisines.csv\")\n",
"cuisines_df.head()"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.linear_model import LogisticRegression\n",
"from sklearn.model_selection import train_test_split, cross_val_score\n",
"from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve\n",
"from sklearn.svm import SVC\n",
"import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"0 indian\n",
"1 indian\n",
"2 indian\n",
"3 indian\n",
"4 indian\n",
"Name: cuisine, dtype: object"
]
},
"metadata": {},
"execution_count": 3
}
],
"source": [
"cuisines_label_df = cuisines_df['cuisine']\n",
"cuisines_label_df.head()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" almond angelica anise anise_seed apple apple_brandy apricot \\\n",
"0 0 0 0 0 0 0 0 \n",
"1 1 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 0 0 \n",
"\n",
" armagnac artemisia artichoke ... whiskey white_bread white_wine \\\n",
"0 0 0 0 ... 0 0 0 \n",
"1 0 0 0 ... 0 0 0 \n",
"2 0 0 0 ... 0 0 0 \n",
"3 0 0 0 ... 0 0 0 \n",
"4 0 0 0 ... 0 0 0 \n",
"\n",
" whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
"0 0 0 0 0 0 0 0 \n",
"1 0 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 1 0 \n",
"\n",
"[5 rows x 380 columns]"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>almond</th>\n <th>angelica</th>\n <th>anise</th>\n <th>anise_seed</th>\n <th>apple</th>\n <th>apple_brandy</th>\n <th>apricot</th>\n <th>armagnac</th>\n <th>artemisia</th>\n <th>artichoke</th>\n <th>...</th>\n <th>whiskey</th>\n <th>white_bread</th>\n <th>white_wine</th>\n <th>whole_grain_wheat_flour</th>\n <th>wine</th>\n <th>wood</th>\n <th>yam</th>\n <th>yeast</th>\n <th>yogurt</th>\n <th>zucchini</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>1</th>\n <td>1</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>2</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>3</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>4</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>1</td>\n <td>0</td>\n </tr>\n </tbody>\n</table>\n<p>5 rows × 380 columns</p>\n</div>"
},
"metadata": {},
"execution_count": 4
}
],
"source": [
"cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n",
"cuisines_feature_df.head()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Accuracy is 0.8181818181818182\n"
]
}
],
"source": [
"lr = LogisticRegression(multi_class='ovr',solver='liblinear')\n",
"model = lr.fit(X_train, np.ravel(y_train))\n",
"\n",
"accuracy = model.score(X_test, y_test)\n",
"print (\"Accuracy is {}\".format(accuracy))"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"ingredients: Index(['artemisia', 'black_pepper', 'mushroom', 'shiitake', 'soy_sauce',\n 'vegetable_oil'],\n dtype='object')\ncuisine: korean\n"
]
}
],
"source": [
"# test an item\n",
"print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}')\n",
"print(f'cuisine: {y_test.iloc[50]}')"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" 0\n",
"korean 0.392231\n",
"chinese 0.372872\n",
"japanese 0.218825\n",
"thai 0.013427\n",
"indian 0.002645"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>0</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>korean</th>\n <td>0.392231</td>\n </tr>\n <tr>\n <th>chinese</th>\n <td>0.372872</td>\n </tr>\n <tr>\n <th>japanese</th>\n <td>0.218825</td>\n </tr>\n <tr>\n <th>thai</th>\n <td>0.013427</td>\n </tr>\n <tr>\n <th>indian</th>\n <td>0.002645</td>\n </tr>\n </tbody>\n</table>\n</div>"
},
"metadata": {},
"execution_count": 8
}
],
"source": [
"#rehsape to 2d array and transpose\n",
"test= X_test.iloc[50].values.reshape(-1, 1).T\n",
"# predict with score\n",
"proba = model.predict_proba(test)\n",
"classes = model.classes_\n",
"# create df with classes and scores\n",
"resultdf = pd.DataFrame(data=proba, columns=classes)\n",
"\n",
"# create df to show results\n",
"topPrediction = resultdf.T.sort_values(by=[0], ascending = [False])\n",
"topPrediction.head()"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
" precision recall f1-score support\n\n chinese 0.75 0.73 0.74 223\n indian 0.93 0.88 0.90 255\n japanese 0.78 0.78 0.78 253\n korean 0.87 0.86 0.86 236\n thai 0.76 0.84 0.80 232\n\n accuracy 0.82 1199\n macro avg 0.82 0.82 0.82 1199\nweighted avg 0.82 0.82 0.82 1199\n\n"
]
}
],
"source": [
"y_pred = model.predict(X_test)\r\n",
"print(classification_report(y_test,y_pred))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
],
"metadata": {
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3.7.0 64-bit ('3.7')"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
},
"metadata": {
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"coopTranslator": {
"original_hash": "9408506dd864f2b6e334c62f80c0cfcc",
"translation_date": "2025-12-19T17:18:12+00:00",
"source_file": "4-Classification/2-Classifiers-1/solution/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 4
}

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

@ -0,0 +1,251 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "49047911108adc49d605cddfb455749c",
"translation_date": "2025-12-19T15:22:00+00:00",
"source_file": "4-Classification/3-Classifiers-2/README.md",
"language_code": "te"
}
-->
# వంటక వర్గీకరణలు 2
ఈ రెండవ వర్గీకరణ పాఠంలో, మీరు సంఖ్యాత్మక డేటాను వర్గీకరించడానికి మరిన్ని మార్గాలను అన్వేషిస్తారు. మీరు ఒక వర్గీకర్తను మరొకదానితో పోల్చినప్పుడు కలిగే ప్రభావాల గురించి కూడా తెలుసుకుంటారు.
## [పాఠం ముందు క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
### ముందస్తు అర్హత
ముందటి పాఠాలు మీరు పూర్తి చేశారని మరియు మీ `data` ఫోల్డర్‌లో _cleaned_cuisines.csv_ అనే శుభ్రపరిచిన డేటాసెట్ ఉందని మేము అనుకుంటున్నాము, ఇది ఈ 4-పాఠాల ఫోల్డర్ యొక్క రూట్‌లో ఉంది.
### సిద్ధం
మేము మీ _notebook.ipynb_ ఫైల్‌లో శుభ్రపరిచిన డేటాసెట్‌ను లోడ్ చేసి, మోడల్ నిర్మాణ ప్రక్రియ కోసం X మరియు y డేటాఫ్రేమ్‌లుగా విభజించాము.
## ఒక వర్గీకరణ మ్యాప్
ముందుగా, మీరు మైక్రోసాఫ్ట్ యొక్క చీట్ షీట్ ఉపయోగించి డేటాను వర్గీకరించేటప్పుడు మీకు ఉన్న వివిధ ఎంపికల గురించి తెలుసుకున్నారు. Scikit-learn ఒక సమానమైన, కానీ మరింత సూక్ష్మమైన చీట్ షీట్ అందిస్తుంది, ఇది మీ అంచనాదారులను (ఇంకో పేరు వర్గీకర్తలు) మరింత సన్నిహితంగా తగ్గించడంలో సహాయపడుతుంది:
![ML Map from Scikit-learn](../../../../translated_images/map.e963a6a51349425ab107b38f6c7307eb4c0d0c7ccdd2e81a5e1919292bab9ac7.te.png)
> సూచన: [ఈ మ్యాప్‌ను ఆన్‌లైన్‌లో సందర్శించండి](https://scikit-learn.org/stable/tutorial/machine_learning_map/) మరియు దారిలో క్లిక్ చేసి డాక్యుమెంటేషన్ చదవండి.
### ప్రణాళిక
మీ డేటాను స్పష్టంగా అర్థం చేసుకున్న తర్వాత ఈ మ్యాప్ చాలా సహాయకారి, ఎందుకంటే మీరు దాని మార్గాలను అనుసరించి నిర్ణయం తీసుకోవచ్చు:
- మాకు >50 నమూనాలు ఉన్నాయి
- మేము ఒక వర్గాన్ని అంచనా వేయాలనుకుంటున్నాము
- మాకు లేబుల్ చేయబడిన డేటా ఉంది
- మాకు 100K కన్నా తక్కువ నమూనాలు ఉన్నాయి
- ✨ మేము లీనియర్ SVC ఎంచుకోవచ్చు
- అది పనిచేయకపోతే, ఎందుకంటే మాకు సంఖ్యాత్మక డేటా ఉంది
- మేము ✨ KNeighbors Classifier ప్రయత్నించవచ్చు
- అది పనిచేయకపోతే, ✨ SVC మరియు ✨ Ensemble Classifiers ప్రయత్నించండి
ఇది అనుసరించడానికి చాలా సహాయకారి మార్గం.
## వ్యాయామం - డేటాను విభజించండి
ఈ మార్గాన్ని అనుసరించి, మేము ఉపయోగించడానికి కొన్ని లైబ్రరీలను దిగుమతి చేసుకోవడం ప్రారంభించాలి.
1. అవసరమైన లైబ్రరీలను దిగుమతి చేసుకోండి:
```python
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
import numpy as np
```
1. మీ శిక్షణ మరియు పరీక్ష డేటాను విభజించండి:
```python
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
```
## లీనియర్ 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 వర్తించండి
వర్గీకర్తల అర్రేను సృష్టించడం ప్రారంభించండి. పరీక్షల సమయంలో మీరు ఈ అర్రేకు క్రమంగా జోడిస్తారు.
1. లీనియర్ SVC తో ప్రారంభించండి:
```python
C = 10
# వేర్వేరు వర్గీకరణలను సృష్టించండి.
classifiers = {
'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
}
```
2. లీనియర్ SVC ఉపయోగించి మీ మోడల్‌ను శిక్షణ ఇవ్వండి మరియు నివేదికను ప్రింట్ చేయండి:
```python
n_classifiers = len(classifiers)
for index, (name, classifier) in enumerate(classifiers.items()):
classifier.fit(X_train, np.ravel(y_train))
y_pred = classifier.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy (train) for %s: %0.1f%% " % (name, accuracy * 100))
print(classification_report(y_test,y_pred))
```
ఫలితం చాలా బాగుంది:
```output
Accuracy (train) for Linear SVC: 78.6%
precision recall f1-score support
chinese 0.71 0.67 0.69 242
indian 0.88 0.86 0.87 234
japanese 0.79 0.74 0.76 254
korean 0.85 0.81 0.83 242
thai 0.71 0.86 0.78 227
accuracy 0.79 1199
macro avg 0.79 0.79 0.79 1199
weighted avg 0.79 0.79 0.79 1199
```
## K-నెయిబర్స్ వర్గీకర్త
K-నెయిబర్స్ అనేది "నెయిబర్స్" కుటుంబానికి చెందిన ML పద్ధతి, ఇది పర్యవేక్షిత మరియు పర్యవేక్షణలేని రెండింటికీ ఉపయోగించవచ్చు. ఈ పద్ధతిలో, ముందుగా నిర్దేశించిన సంఖ్యలో పాయింట్లు సృష్టించబడతాయి మరియు డేటా ఈ పాయింట్ల చుట్టూ సేకరించబడుతుంది, తద్వారా సాధారణీకృత లేబుల్స్‌ను అంచనా వేయవచ్చు.
### వ్యాయామం - K-నెయిబర్స్ వర్గీకర్తను వర్తించండి
ముందటి వర్గీకర్త బాగుంది మరియు డేటాతో బాగా పనిచేసింది, కానీ మేము మెరుగైన ఖచ్చితత్వం పొందవచ్చని అనుకుంటున్నాము. K-నెయిబర్స్ వర్గీకర్తను ప్రయత్నించండి.
1. మీ వర్గీకర్త అర్రేలో ఒక లైన్ జోడించండి (లీనియర్ SVC అంశం తర్వాత కామా జోడించండి):
```python
'KNN classifier': KNeighborsClassifier(C),
```
ఫలితం కొంచెం తక్కువగా ఉంది:
```output
Accuracy (train) for KNN classifier: 73.8%
precision recall f1-score support
chinese 0.64 0.67 0.66 242
indian 0.86 0.78 0.82 234
japanese 0.66 0.83 0.74 254
korean 0.94 0.58 0.72 242
thai 0.71 0.82 0.76 227
accuracy 0.74 1199
macro 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)
## సపోర్ట్ వెక్టర్ వర్గీకర్త
సపోర్ట్-వెక్టర్ వర్గీకర్తలు [సపోర్ట్-వెక్టర్ మెషీన్](https://wikipedia.org/wiki/Support-vector_machine) కుటుంబానికి చెందిన ML పద్ధతులు, ఇవి వర్గీకరణ మరియు రిగ్రెషన్ పనుల కోసం ఉపయోగిస్తారు. SVMలు "శిక్షణ ఉదాహరణలను స్థలంలో పాయింట్లుగా మ్యాప్ చేస్తాయి" రెండు వర్గాల మధ్య దూరాన్ని గరిష్టం చేయడానికి. తరువాతి డేటాను ఈ స్థలంలో మ్యాప్ చేసి వారి వర్గాన్ని అంచనా వేస్తారు.
### వ్యాయామం - సపోర్ట్ వెక్టర్ వర్గీకర్తను వర్తించండి
కొంచెం మెరుగైన ఖచ్చితత్వం కోసం సపోర్ట్ వెక్టర్ వర్గీకర్తను ప్రయత్నిద్దాం.
1. K-నెయిబర్స్ అంశం తర్వాత కామా జోడించి, ఈ లైన్ జోడించండి:
```python
'SVC': SVC(),
```
ఫలితం చాలా బాగుంది!
```output
Accuracy (train) for SVC: 83.2%
precision recall f1-score support
chinese 0.79 0.74 0.76 242
indian 0.88 0.90 0.89 234
japanese 0.87 0.81 0.84 254
korean 0.91 0.82 0.86 242
thai 0.74 0.90 0.81 227
accuracy 0.83 1199
macro 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)
## ఎన్‌సెంబుల్ వర్గీకర్తలు
ముందటి పరీక్ష చాలా బాగుండగా కూడా, చివరి వరకు ఈ మార్గాన్ని అనుసరించుకుందాం. కొన్ని 'ఎన్‌సెంబుల్ వర్గీకర్తలు', ముఖ్యంగా రాండమ్ ఫారెస్ట్ మరియు అడాబూస్ట్ ప్రయత్నిద్దాం:
```python
'RFST': RandomForestClassifier(n_estimators=100),
'ADA': AdaBoostClassifier(n_estimators=100)
```
ఫలితం చాలా బాగుంది, ముఖ్యంగా రాండమ్ ఫారెస్ట్ కోసం:
```output
Accuracy (train) for RFST: 84.5%
precision recall f1-score support
chinese 0.80 0.77 0.78 242
indian 0.89 0.92 0.90 234
japanese 0.86 0.84 0.85 254
korean 0.88 0.83 0.85 242
thai 0.80 0.87 0.83 227
accuracy 0.84 1199
macro avg 0.85 0.85 0.84 1199
weighted avg 0.85 0.84 0.84 1199
Accuracy (train) for ADA: 72.4%
precision recall f1-score support
chinese 0.64 0.49 0.56 242
indian 0.91 0.83 0.87 234
japanese 0.68 0.69 0.69 254
korean 0.73 0.79 0.76 242
thai 0.67 0.83 0.74 227
accuracy 0.72 1199
macro avg 0.73 0.73 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#forest), ఒక సగటు పద్ధతి, 'డిసిషన్ ట్రీల' 'ఫారెస్ట్'ను నిర్మిస్తుంది, ఇది ఓవర్‌ఫిట్టింగ్ నివారించడానికి యాదృచ్ఛికతతో నింపబడింది. n_estimators పారామీటర్ ట్రీల సంఖ్యకు సెట్ చేయబడింది.
- [అడాబూస్ట్](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ఒక వర్గీకర్తను డేటాసెట్‌కు సరిపోల్చి, ఆ వర్గీకర్త యొక్క కాపీలను అదే డేటాసెట్‌కు సరిపోల్చుతుంది. ఇది తప్పుగా వర్గీకరించిన అంశాల బరువులపై దృష్టి సారించి, తదుపరి వర్గీకర్త సరిపోల్చడాన్ని సరిచేస్తుంది.
---
## 🚀సవాలు
ఈ ప్రతి సాంకేతికతకు మీరు సర్దుబాటు చేయగల పెద్ద సంఖ్యలో పారామీటర్లు ఉన్నాయి. ప్రతి ఒకటి యొక్క డిఫాల్ట్ పారామీటర్లను పరిశోధించి, ఈ పారామీటర్ల సర్దుబాటు మోడల్ నాణ్యతకు ఏమి అర్థం అవుతుందో ఆలోచించండి.
## [పాఠం తర్వాత క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
ఈ పాఠాలలో చాలా జార్గన్ ఉంది, కాబట్టి [ఈ జాబితా](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) ఉపయోగకరమైన పదజాలాన్ని సమీక్షించడానికి ఒక నిమిషం తీసుకోండి!
## అసైన్‌మెంట్
[పారామీటర్ ప్లే](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/4-Classification/3-Classifiers-2/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "58dfdaf79fb73f7d34b22bdbacf57329",
"translation_date": "2025-12-19T15:24:49+00:00",
"source_file": "4-Classification/3-Classifiers-2/assignment.md",
"language_code": "te"
}
-->
# పారామీటర్ ప్లే
## సూచనలు
ఈ క్లాసిఫైయర్లతో పని చేసే సమయంలో డిఫాల్ట్‌గా సెట్ చేయబడిన అనేక పారామీటర్లు ఉంటాయి. VS కోడ్‌లోని ఇంటెలిసెన్స్ మీకు వాటిని లోతుగా తెలుసుకోవడంలో సహాయపడుతుంది. ఈ పాఠంలో ఒక ML క్లాసిఫికేషన్ సాంకేతికతను ఎంచుకుని వివిధ పారామీటర్ విలువలను సర్దుబాటు చేస్తూ మోడల్స్‌ను మళ్లీ శిక్షణ ఇవ్వండి. కొన్ని మార్పులు మోడల్ నాణ్యతకు ఎలా సహాయపడతాయో, మరికొన్ని ఎలా దెబ్బతీస్తాయో వివరించే నోట్‌బుక్‌ను నిర్మించండి. మీ సమాధానంలో వివరంగా ఉండండి.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- | ----------------------------- |
| | ఒక క్లాసిఫైయర్ పూర్తిగా నిర్మించబడిన నోట్‌బుక్ మరియు దాని పారామీటర్లను సర్దుబాటు చేసి మార్పులను టెక్స్ట్‌బాక్స్‌లలో వివరించినది | ఒక నోట్‌బుక్ భాగంగా లేదా బాగా వివరించబడలేదు | ఒక నోట్‌బుక్ బగ్గీ లేదా లోపభూయిష్టమైనది |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

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

@ -0,0 +1,165 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# వర్గీకరణ మోడల్ నిర్మించండి\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" Unnamed: 0 cuisine almond angelica anise anise_seed apple \\\n",
"0 0 indian 0 0 0 0 0 \n",
"1 1 indian 1 0 0 0 0 \n",
"2 2 indian 0 0 0 0 0 \n",
"3 3 indian 0 0 0 0 0 \n",
"4 4 indian 0 0 0 0 0 \n",
"\n",
" apple_brandy apricot armagnac ... whiskey white_bread white_wine \\\n",
"0 0 0 0 ... 0 0 0 \n",
"1 0 0 0 ... 0 0 0 \n",
"2 0 0 0 ... 0 0 0 \n",
"3 0 0 0 ... 0 0 0 \n",
"4 0 0 0 ... 0 0 0 \n",
"\n",
" whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
"0 0 0 0 0 0 0 0 \n",
"1 0 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 1 0 \n",
"\n",
"[5 rows x 382 columns]"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>Unnamed: 0</th>\n <th>cuisine</th>\n <th>almond</th>\n <th>angelica</th>\n <th>anise</th>\n <th>anise_seed</th>\n <th>apple</th>\n <th>apple_brandy</th>\n <th>apricot</th>\n <th>armagnac</th>\n <th>...</th>\n <th>whiskey</th>\n <th>white_bread</th>\n <th>white_wine</th>\n <th>whole_grain_wheat_flour</th>\n <th>wine</th>\n <th>wood</th>\n <th>yam</th>\n <th>yeast</th>\n <th>yogurt</th>\n <th>zucchini</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>0</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>1</th>\n <td>1</td>\n <td>indian</td>\n <td>1</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>2</th>\n <td>2</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>3</th>\n <td>3</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>4</th>\n <td>4</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>1</td>\n <td>0</td>\n </tr>\n </tbody>\n</table>\n<p>5 rows × 382 columns</p>\n</div>"
},
"metadata": {},
"execution_count": 9
}
],
"source": [
"import pandas as pd\n",
"cuisines_df = pd.read_csv(\"../data/cleaned_cuisines.csv\")\n",
"cuisines_df.head()"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"0 indian\n",
"1 indian\n",
"2 indian\n",
"3 indian\n",
"4 indian\n",
"Name: cuisine, dtype: object"
]
},
"metadata": {},
"execution_count": 10
}
],
"source": [
"cuisines_label_df = cuisines_df['cuisine']\n",
"cuisines_label_df.head()"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" almond angelica anise anise_seed apple apple_brandy apricot \\\n",
"0 0 0 0 0 0 0 0 \n",
"1 1 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 0 0 \n",
"\n",
" armagnac artemisia artichoke ... whiskey white_bread white_wine \\\n",
"0 0 0 0 ... 0 0 0 \n",
"1 0 0 0 ... 0 0 0 \n",
"2 0 0 0 ... 0 0 0 \n",
"3 0 0 0 ... 0 0 0 \n",
"4 0 0 0 ... 0 0 0 \n",
"\n",
" whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
"0 0 0 0 0 0 0 0 \n",
"1 0 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 1 0 \n",
"\n",
"[5 rows x 380 columns]"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>almond</th>\n <th>angelica</th>\n <th>anise</th>\n <th>anise_seed</th>\n <th>apple</th>\n <th>apple_brandy</th>\n <th>apricot</th>\n <th>armagnac</th>\n <th>artemisia</th>\n <th>artichoke</th>\n <th>...</th>\n <th>whiskey</th>\n <th>white_bread</th>\n <th>white_wine</th>\n <th>whole_grain_wheat_flour</th>\n <th>wine</th>\n <th>wood</th>\n <th>yam</th>\n <th>yeast</th>\n <th>yogurt</th>\n <th>zucchini</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>1</th>\n <td>1</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>2</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>3</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>4</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>1</td>\n <td>0</td>\n </tr>\n </tbody>\n</table>\n<p>5 rows × 380 columns</p>\n</div>"
},
"metadata": {},
"execution_count": 11
}
],
"source": [
"cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n",
"cuisines_feature_df.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
],
"metadata": {
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3.7.0 64-bit ('3.7')"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
},
"metadata": {
"interpreter": {
"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_minor": 4
}

17
translations/te/4-Classification/3-Classifiers-2/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T15:37:22+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

655
translations/te/4-Classification/3-Classifiers-2/solution/R/lesson_12-R.ipynb
Unescape View File

@ -0,0 +1,655 @@
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"name": "lesson_12-R.ipynb",
"provenance": [],
"collapsed_sections": []
},
"kernelspec": {
"name": "ir",
"display_name": "R"
},
"language_info": {
"name": "R"
},
"coopTranslator": {
"original_hash": "fab50046ca413a38939d579f8432274f",
"translation_date": "2025-12-19T17:10:44+00:00",
"source_file": "4-Classification/3-Classifiers-2/solution/R/lesson_12-R.ipynb",
"language_code": "te"
}
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "jsFutf_ygqSx"
},
"source": [
"# వర్గీకరణ మోడల్ నిర్మించండి: రుచికరమైన ఆసియన్లు మరియు భారతీయ వంటకాలు\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "HD54bEefgtNO"
},
"source": [
"## వంటక వర్గీకరణలు 2\n",
"\n",
"ఈ రెండవ వర్గీకరణ పాఠంలో, వర్గీకరణాత్మక డేటాను వర్గీకరించడానికి `మరిన్ని మార్గాలు` గురించి పరిశీలిస్తాము. ఒక వర్గీకర్తను మరొకదానిపై ఎంచుకోవడంలో ఉన్న ప్రభావాల గురించి కూడా నేర్చుకుంటాము.\n",
"\n",
"### [**పూర్వ-ఉపన్యాస క్విజ్**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/23/)\n",
"\n",
"### **ముందస్తు అవసరం**\n",
"\n",
"మేము మీరు గత పాఠాలు పూర్తి చేశారని అనుకుంటున్నాము ఎందుకంటే మేము ముందుగా నేర్చుకున్న కొన్ని భావనలను కొనసాగించబోతున్నాము.\n",
"\n",
"ఈ పాఠం కోసం, మేము క్రింది ప్యాకేజీలను అవసరం:\n",
"\n",
"- `tidyverse`: [tidyverse](https://www.tidyverse.org/) అనేది డేటా సైన్స్‌ను వేగవంతం, సులభం మరియు మరింత సరదాగా చేయడానికి రూపొందించిన [R ప్యాకేజీల సేకరణ](https://www.tidyverse.org/packages).\n",
"\n",
"- `tidymodels`: [tidymodels](https://www.tidymodels.org/) ఫ్రేమ్‌వర్క్ అనేది మోడలింగ్ మరియు మెషీన్ లెర్నింగ్ కోసం [ప్యాకేజీల సేకరణ](https://www.tidymodels.org/packages/).\n",
"\n",
"- `themis`: [themis ప్యాకేజీ](https://themis.tidymodels.org/) అసమతుల్య డేటాతో వ్యవహరించడానికి అదనపు రెసిపీలు అందిస్తుంది.\n",
"\n",
"మీరు వాటిని ఇన్‌స్టాల్ చేసుకోవచ్చు:\n",
"\n",
"`install.packages(c(\"tidyverse\", \"tidymodels\", \"kernlab\", \"themis\", \"ranger\", \"xgboost\", \"kknn\"))`\n",
"\n",
"వేరే విధంగా, క్రింది స్క్రిప్ట్ మీరు ఈ మాడ్యూల్ పూర్తి చేయడానికి అవసరమైన ప్యాకేజీలు ఉన్నాయా లేదా అని తనిఖీ చేసి, అవి లేనప్పుడు వాటిని ఇన్‌స్టాల్ చేస్తుంది.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "vZ57IuUxgyQt"
},
"source": [
"suppressWarnings(if (!require(\"pacman\"))install.packages(\"pacman\"))\n",
"\n",
"pacman::p_load(tidyverse, tidymodels, themis, kernlab, ranger, xgboost, kknn)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "z22M-pj4g07x"
},
"source": [
"ఇప్పుడు, మనం వెంటనే ప్రారంభిద్దాం!\n",
"\n",
"## **1. ఒక వర్గీకరణ మ్యాప్**\n",
"\n",
"మన [మునుపటి పాఠంలో](https://github.com/microsoft/ML-For-Beginners/tree/main/4-Classification/2-Classifiers-1), మేము ఈ ప్రశ్నను పరిష్కరించడానికి ప్రయత్నించాము: మనం అనేక మోడల్స్ మధ్య ఎలా ఎంచుకోవాలి? చాలా మేరకు, ఇది డేటా లక్షణాలు మరియు మనం పరిష్కరించదలచుకున్న సమస్య రకంపై ఆధారపడి ఉంటుంది (ఉదాహరణకు వర్గీకరణ లేదా రిగ్రెషన్?)\n",
"\n",
"మునుపటి పాఠంలో, మైక్రోసాఫ్ట్ యొక్క చీట్ షీట్ ఉపయోగించి డేటాను వర్గీకరించేటప్పుడు మీకు ఉన్న వివిధ ఎంపికల గురించి నేర్చుకున్నాము. పైథాన్ యొక్క మెషీన్ లెర్నింగ్ ఫ్రేమ్‌వర్క్, స్కైకిట్-లెర్న్, ఒక సమానమైన కానీ మరింత సూక్ష్మమైన చీట్ షీట్‌ను అందిస్తుంది, ఇది మీ అంచనాదారులను (మరొక పదం వర్గీకరణకర్తలకు) మరింత సన్నిహితంగా తగ్గించడంలో సహాయపడుతుంది:\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/map.e963a6a51349425ab107b38f6c7307eb4c0d0c7ccdd2e81a5e1919292bab9ac7.te.png\"\n",
" width=\"700\"/>\n",
" <figcaption></figcaption>\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "u1i3xRIVg7vG"
},
"source": [
"> సూచన: [ఈ మ్యాప్‌ను ఆన్‌లైన్‌లో సందర్శించండి](https://scikit-learn.org/stable/tutorial/machine_learning_map/) మరియు దారిలో క్లిక్ చేసి డాక్యుమెంటేషన్ చదవండి.\n",
">\n",
"> [Tidymodels సూచిక సైట్](https://www.tidymodels.org/find/parsnip/#models) కూడా వివిధ రకాల మోడళ్ల గురించి అద్భుతమైన డాక్యుమెంటేషన్ అందిస్తుంది.\n",
"\n",
"### **ప్రణాళిక** 🗺️\n",
"\n",
"మీ డేటాను స్పష్టంగా అర్థం చేసుకున్న తర్వాత ఈ మ్యాప్ చాలా సహాయకారి, ఎందుకంటే మీరు దాని మార్గాల ద్వారా 'నడవచ్చు' నిర్ణయం తీసుకోవడానికి:\n",
"\n",
"- మాకు \\>50 నమూనాలు ఉన్నాయి\n",
"\n",
"- మేము ఒక వర్గాన్ని అంచనా వేయాలనుకుంటున్నాము\n",
"\n",
"- మాకు లేబుల్ చేయబడిన డేటా ఉంది\n",
"\n",
"- మాకు 100K కన్నా తక్కువ నమూనాలు ఉన్నాయి\n",
"\n",
"- ✨ మేము లీనియర్ SVC ఎంచుకోవచ్చు\n",
"\n",
"- అది పనిచేయకపోతే, ఎందుకంటే మాకు సంఖ్యాత్మక డేటా ఉంది\n",
"\n",
" - మేము ✨ KNeighbors క్లాసిఫైయర్ ప్రయత్నించవచ్చు\n",
"\n",
" - అది పనిచేయకపోతే, ✨ SVC మరియు ✨ ఎంసెంబుల్ క్లాసిఫైయర్లను ప్రయత్నించండి\n",
"\n",
"ఇది అనుసరించడానికి చాలా సహాయకారి మార్గం. ఇప్పుడు, [tidymodels](https://www.tidymodels.org/) మోడలింగ్ ఫ్రేమ్‌వర్క్ ఉపయోగించి నేరుగా ప్రారంభిద్దాం: ఇది మంచి గణాంక పద్ధతిని ప్రోత్సహించడానికి అభివృద్ధి చేయబడిన R ప్యాకేజీల సుసंगత మరియు సౌలభ్యమైన సేకరణ 😊.\n",
"\n",
"## 2. డేటాను విభజించి అసమతుల్య డేటా సెట్‌ను నిర్వహించండి.\n",
"\n",
"మా గత పాఠాల నుండి, మనం తెలుసుకున్నాము మన వంటకాలలో సాధారణ పదార్థాల సమూహం ఉంది. అలాగే, వంటకాల సంఖ్యలో అసమాన పంపిణీ ఉంది.\n",
"\n",
"మేము ఈ సమస్యలను ఇలా పరిష్కరిస్తాము\n",
"\n",
"- `dplyr::select()` ఉపయోగించి వేర్వేరు వంటకాల మధ్య గందరగోళం సృష్టించే అత్యంత సాధారణ పదార్థాలను తొలగించడం.\n",
"\n",
"- `over-sampling` అల్గోరిథం వర్తింపజేసి డేటాను మోడలింగ్‌కు సిద్ధం చేసే `recipe` ఉపయోగించడం.\n",
"\n",
"మేము ఈ విషయాలను గత పాఠంలో ఇప్పటికే చూశాము కాబట్టి ఇది చాలా సులభం 🥳!\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "6tj_rN00hClA"
},
"source": [
"# Load the core Tidyverse and Tidymodels packages\n",
"library(tidyverse)\n",
"library(tidymodels)\n",
"\n",
"# Load the original cuisines data\n",
"df <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/4-Classification/data/cuisines.csv\")\n",
"\n",
"# Drop id column, rice, garlic and ginger from our original data set\n",
"df_select <- df %>% \n",
" select(-c(1, rice, garlic, ginger)) %>%\n",
" # Encode cuisine column as categorical\n",
" mutate(cuisine = factor(cuisine))\n",
"\n",
"\n",
"# Create data split specification\n",
"set.seed(2056)\n",
"cuisines_split <- initial_split(data = df_select,\n",
" strata = cuisine,\n",
" prop = 0.7)\n",
"\n",
"# Extract the data in each split\n",
"cuisines_train <- training(cuisines_split)\n",
"cuisines_test <- testing(cuisines_split)\n",
"\n",
"# Display distribution of cuisines in the training set\n",
"cuisines_train %>% \n",
" count(cuisine) %>% \n",
" arrange(desc(n))"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "zFin5yw3hHb1"
},
"source": [
"### అసమతుల్య డేటాతో వ్యవహరించడం\n",
"\n",
"అసమతుల్య డేటా తరచుగా మోడల్ పనితీరుపై ప్రతికూల ప్రభావాలు చూపుతుంది. చాలా మోడల్స్ గమనికల సంఖ్య సమానంగా ఉన్నప్పుడు ఉత్తమంగా పనిచేస్తాయి, అందువల్ల అసమతుల్య డేటాతో సమస్యలు ఎదుర్కొంటాయి.\n",
"\n",
"అసమతుల్య డేటా సెట్‌లతో వ్యవహరించడానికి ప్రధానంగా రెండు మార్గాలు ఉన్నాయి:\n",
"\n",
"- మైనారిటీ క్లాస్‌కు గమనికలు జోడించడం: `ఓవర్-సాంప్లింగ్` ఉదాహరణకు SMOTE అల్గోరిథం ఉపయోగించడం, ఇది ఈ కేసుల సమీప పొరుగువారిని ఉపయోగించి మైనారిటీ క్లాస్ యొక్క కొత్త ఉదాహరణలను సృజనాత్మకంగా ఉత్పత్తి చేస్తుంది.\n",
"\n",
"- మెజారిటీ క్లాస్ నుండి గమనికలు తీసివేయడం: `అండర్-సాంప్లింగ్`\n",
"\n",
"మా గత పాఠంలో, మేము `recipe` ఉపయోగించి అసమతుల్య డేటా సెట్‌లతో ఎలా వ్యవహరించాలో చూపించాము. ఒక recipe అనేది డేటా విశ్లేషణకు సిద్ధం చేయడానికి డేటా సెట్‌పై ఏ దశలను వర్తించాలో వివరించే బ్లూప్రింట్‌గా భావించవచ్చు. మా సందర్భంలో, మా `training set` కోసం వంటకాల సంఖ్యలో సమాన పంపిణీ ఉండాలని మేము కోరుకుంటున్నాము. దీని కోసం నేరుగా ప్రారంభిద్దాం.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "cRzTnHolhLWd"
},
"source": [
"# Load themis package for dealing with imbalanced data\n",
"library(themis)\n",
"\n",
"# Create a recipe for preprocessing training data\n",
"cuisines_recipe <- recipe(cuisine ~ ., data = cuisines_train) %>%\n",
" step_smote(cuisine) \n",
"\n",
"# Print recipe\n",
"cuisines_recipe"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "KxOQ2ORhhO81"
},
"source": [
"ఇప్పుడు మేము మోడల్స్‌ను శిక్షణ ఇవ్వడానికి సిద్ధంగా ఉన్నాము 👩‍💻👨‍💻!\n",
"\n",
"## 3. మల్టినోమియల్ రిగ్రెషన్ మోడల్స్ కంటే మించి\n",
"\n",
"మా గత పాఠంలో, మేము మల్టినోమియల్ రిగ్రెషన్ మోడల్స్‌ను చూశాము. వర్గీకరణ కోసం మరింత సౌకర్యవంతమైన కొన్ని మోడల్స్‌ను పరిశీలిద్దాం.\n",
"\n",
"### సపోర్ట్ వెక్టర్ మెషీన్లు.\n",
"\n",
"వర్గీకరణ సందర్భంలో, `సపోర్ట్ వెక్టర్ మెషీన్లు` అనేది ఒక మెషీన్ లెర్నింగ్ సాంకేతికత, ఇది తరగతులను \"మంచిగా\" వేరు చేసే *హైపర్ప్లేన్* ను కనుగొనడానికి ప్రయత్నిస్తుంది. ఒక సులభమైన ఉదాహరణను చూద్దాం:\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/svm.621ae7b516d678e08ed23af77ff1750b5fe392976917f0606861567b779e8862.te.png\"\n",
" width=\"300\"/>\n",
" <figcaption>https://commons.wikimedia.org/w/index.php?curid=22877598</figcaption>\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "C4Wsd0vZhXYu"
},
"source": [
"H1~ తరగతులను వేరుచేయదు. H2~ వేరుచేస్తుంది, కానీ కేవలం చిన్న మార్జిన్‌తో మాత్రమే. H3~ వాటిని గరిష్ట మార్జిన్‌తో వేరుచేస్తుంది.\n",
"\n",
"#### లీనియర్ సపోర్ట్ వెక్టర్ క్లాసిఫైయర్\n",
"\n",
"సపోర్ట్-వెక్టర్ క్లస్టరింగ్ (SVC) అనేది ML సాంకేతికతల సపోర్ట్-వెక్టర్ యంత్రాల కుటుంబంలో ఒక పిల్లవాడు. SVCలో, హైపర్ప్లేన్‌ను శిక్షణ పరిశీలనలలో `అధిక భాగాన్ని` సరిగా వేరుచేయడానికి ఎంచుకుంటారు, కానీ కొన్ని పరిశీలనలను `తప్పుగా వర్గీకరించవచ్చు`. కొన్ని పాయింట్లను తప్పు వైపున ఉంచుకోవడానికి అనుమతించడం ద్వారా, SVM అవుట్లయర్లకు మరింత రాబస్ట్గా మారుతుంది కాబట్టి కొత్త డేటాకు మెరుగైన సాధారణీకరణ ఉంటుంది. ఈ ఉల్లంఘనను నియంత్రించే పారామీటర్‌ను `cost` అని పిలుస్తారు, దీని డిఫాల్ట్ విలువ 1 (చూడండి `help(\"svm_poly\")`).\n",
"\n",
"పోలినోమియల్ SVM మోడల్‌లో `degree = 1` సెట్ చేసి లీనియర్ SVCని సృష్టిద్దాం.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "vJpp6nuChlBz"
},
"source": [
"# Make a linear SVC specification\n",
"svc_linear_spec <- svm_poly(degree = 1) %>% \n",
" set_engine(\"kernlab\") %>% \n",
" set_mode(\"classification\")\n",
"\n",
"# Bundle specification and recipe into a worklow\n",
"svc_linear_wf <- workflow() %>% \n",
" add_recipe(cuisines_recipe) %>% \n",
" add_model(svc_linear_spec)\n",
"\n",
"# Print out workflow\n",
"svc_linear_wf"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "rDs8cWNkhoqu"
},
"source": [
"ఇప్పుడు మనం ప్రీప్రాసెసింగ్ దశలు మరియు మోడల్ స్పెసిఫికేషన్‌ను *workflow* లో నమోదు చేసుకున్నాము, కాబట్టి మనం linear SVC ను శిక్షణ ఇవ్వగలము మరియు ఫలితాలను అంచనా వేయగలము. పనితీరు ప్రమాణాల కోసం, మనం క్రింది వాటిని అంచనా వేయగల metric set ను సృష్టిద్దాం: `accuracy`, `sensitivity`, `Positive Predicted Value` మరియు `F Measure`\n",
"\n",
"> `augment()` ఇచ్చిన డేటాకు అంచనాల కోసం కాలమ్(లు)ను జోడిస్తుంది.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "81wiqcwuhrnq"
},
"source": [
"# Train a linear SVC model\n",
"svc_linear_fit <- svc_linear_wf %>% \n",
" fit(data = cuisines_train)\n",
"\n",
"# Create a metric set\n",
"eval_metrics <- metric_set(ppv, sens, accuracy, f_meas)\n",
"\n",
"\n",
"# Make predictions and Evaluate model performance\n",
"svc_linear_fit %>% \n",
" augment(new_data = cuisines_test) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "0UFQvHf-huo3"
},
"source": [
"#### సపోర్ట్ వెక్టర్ మెషీన్\n",
"\n",
"సపోర్ట్ వెక్టర్ మెషీన్ (SVM) అనేది తరగతుల మధ్య రేఖీయమైన సరిహద్దును మించిపోయే సపోర్ట్ వెక్టర్ క్లాసిఫయర్ యొక్క విస్తరణ. సారాంశంగా, SVMలు తరగతుల మధ్య రేఖీయ కాని సంబంధాలకు అనుగుణంగా ఫీచర్ స్థలాన్ని విస్తరించడానికి *కర్నెల్ ట్రిక్* ను ఉపయోగిస్తాయి. SVMలు ఉపయోగించే ఒక ప్రముఖ మరియు అత్యంత అనుకూలమైన కర్నెల్ ఫంక్షన్ *రేడియల్ బేసిస్ ఫంక్షన్* (Radial basis function). మన డేటాపై ఇది ఎలా ప్రదర్శిస్తుందో చూద్దాం.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "-KX4S8mzhzmp"
},
"source": [
"set.seed(2056)\n",
"\n",
"# Make an RBF SVM specification\n",
"svm_rbf_spec <- svm_rbf() %>% \n",
" set_engine(\"kernlab\") %>% \n",
" set_mode(\"classification\")\n",
"\n",
"# Bundle specification and recipe into a worklow\n",
"svm_rbf_wf <- workflow() %>% \n",
" add_recipe(cuisines_recipe) %>% \n",
" add_model(svm_rbf_spec)\n",
"\n",
"\n",
"# Train an RBF model\n",
"svm_rbf_fit <- svm_rbf_wf %>% \n",
" fit(data = cuisines_train)\n",
"\n",
"\n",
"# Make predictions and Evaluate model performance\n",
"svm_rbf_fit %>% \n",
" augment(new_data = cuisines_test) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "QBFSa7WSh4HQ"
},
"source": [
"మంచిది 🤩!\n",
"\n",
"> ✅ దయచేసి చూడండి:\n",
">\n",
"> - [*సపోర్ట్ వెక్టర్ మెషీన్లు*](https://bradleyboehmke.github.io/HOML/svm.html), R తో హ్యాండ్స్-ఆన్ మెషీన్ లెర్నింగ్\n",
">\n",
"> - [*సపోర్ట్ వెక్టర్ మెషీన్లు*](https://www.statlearning.com/), R లో అనువర్తనాలతో గణాంకీయ లెర్నింగ్ కు పరిచయం\n",
">\n",
"> మరింత చదవడానికి.\n",
"\n",
"### సమీప పొరుగుల వర్గీకరణ\n",
"\n",
"*K*-సమీప పొరుగుడు (KNN) అనేది ఒక అల్గోరిథం, ఇందులో ప్రతి పరిశీలన దాని *సమానత్వం* ఆధారంగా ఇతర పరిశీలనలకు అంచనా వేయబడుతుంది.\n",
"\n",
"మన డేటాకు ఒకటి సరిపెట్టుకుందాం.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "k4BxxBcdh9Ka"
},
"source": [
"# Make a KNN specification\n",
"knn_spec <- nearest_neighbor() %>% \n",
" set_engine(\"kknn\") %>% \n",
" set_mode(\"classification\")\n",
"\n",
"# Bundle recipe and model specification into a workflow\n",
"knn_wf <- workflow() %>% \n",
" add_recipe(cuisines_recipe) %>% \n",
" add_model(knn_spec)\n",
"\n",
"# Train a boosted tree model\n",
"knn_wf_fit <- knn_wf %>% \n",
" fit(data = cuisines_train)\n",
"\n",
"\n",
"# Make predictions and Evaluate model performance\n",
"knn_wf_fit %>% \n",
" augment(new_data = cuisines_test) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "HaegQseriAcj"
},
"source": [
"ఈ మోడల్ అంతగా బాగా పనిచేయడం లేదు అనిపిస్తోంది. మోడల్ యొక్క ఆర్గ్యుమెంట్లను మార్చడం (చూడండి `help(\"nearest_neighbor\")`) మోడల్ పనితీరును మెరుగుపరచవచ్చు. దయచేసి దీన్ని ప్రయత్నించండి.\n",
"\n",
"> ✅ దయచేసి చూడండి:\n",
">\n",
"> - [Hands-on Machine Learning with R](https://bradleyboehmke.github.io/HOML/)\n",
">\n",
"> - [An Introduction to Statistical Learning with Applications in R](https://www.statlearning.com/)\n",
">\n",
"> *K*-Nearest Neighbors క్లాసిఫైయర్ల గురించి మరింత తెలుసుకోవడానికి.\n",
"\n",
"### ఎన్‌సెంబుల్ క్లాసిఫైయర్లు\n",
"\n",
"ఎన్‌సెంబుల్ అల్గోరిథమ్స్ అనేవి అనేక బేస్ ఎస్టిమేటర్లను కలిపి ఒక ఆప్టిమల్ మోడల్‌ను ఉత్పత్తి చేస్తాయి, ఇది క్రింది విధంగా ఉంటుంది:\n",
"\n",
"`bagging`: బేస్ మోడల్స్ సేకరణపై *సగటు ఫంక్షన్* ను వర్తింపజేయడం\n",
"\n",
"`boosting`: ఒకదానిపై మరొకటి నిర్మించి ప్రిడిక్టివ్ పనితీరును మెరుగుపరచే మోడల్స్ సీక్వెన్స్‌ను నిర్మించడం.\n",
"\n",
"మనం మొదట రాండమ్ ఫారెస్ట్ మోడల్‌ను ప్రయత్నిద్దాం, ఇది పెద్ద సంఖ్యలో డిసిషన్ ట్రీలను నిర్మించి, మెరుగైన మొత్తం మోడల్ కోసం సగటు ఫంక్షన్‌ను వర్తింపజేస్తుంది.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "49DPoVs6iK1M"
},
"source": [
"# Make a random forest specification\n",
"rf_spec <- rand_forest() %>% \n",
" set_engine(\"ranger\") %>% \n",
" set_mode(\"classification\")\n",
"\n",
"# Bundle recipe and model specification into a workflow\n",
"rf_wf <- workflow() %>% \n",
" add_recipe(cuisines_recipe) %>% \n",
" add_model(rf_spec)\n",
"\n",
"# Train a random forest model\n",
"rf_wf_fit <- rf_wf %>% \n",
" fit(data = cuisines_train)\n",
"\n",
"\n",
"# Make predictions and Evaluate model performance\n",
"rf_wf_fit %>% \n",
" augment(new_data = cuisines_test) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "RGVYwC_aiUWc"
},
"source": [
"బాగుంది 👏!\n",
"\n",
"మనం Boosted Tree మోడల్‌తో కూడా ప్రయోగం చేద్దాం.\n",
"\n",
"Boosted Tree అనేది ఒక ఎంసెంబుల్ పద్ధతి, ఇది ఒక వరుసగా నిర్ణయ వృక్షాలను సృష్టిస్తుంది, ప్రతి వృక్షం గత వృక్షాల ఫలితాలపై ఆధారపడి, దోషాన్ని క్రమంగా తగ్గించడానికి ప్రయత్నిస్తుంది. ఇది తప్పుగా వర్గీకరించబడిన అంశాల బరువులపై దృష్టి సారించి, తదుపరి వర్గీకర్తకు సరైన సరిపోయేలా సర్దుబాటు చేస్తుంది.\n",
"\n",
"ఈ మోడల్‌ను సరిపెట్టడానికి వివిధ మార్గాలు ఉన్నాయి (`help(\"boost_tree\")` చూడండి). ఈ ఉదాహరణలో, మనం `xgboost` ఇంజిన్ ద్వారా Boosted trees ను సరిపెట్టబోతున్నాం.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "Py1YWo-micWs"
},
"source": [
"# Make a boosted tree specification\n",
"boost_spec <- boost_tree(trees = 200) %>% \n",
" set_engine(\"xgboost\") %>% \n",
" set_mode(\"classification\")\n",
"\n",
"# Bundle recipe and model specification into a workflow\n",
"boost_wf <- workflow() %>% \n",
" add_recipe(cuisines_recipe) %>% \n",
" add_model(boost_spec)\n",
"\n",
"# Train a boosted tree model\n",
"boost_wf_fit <- boost_wf %>% \n",
" fit(data = cuisines_train)\n",
"\n",
"\n",
"# Make predictions and Evaluate model performance\n",
"boost_wf_fit %>% \n",
" augment(new_data = cuisines_test) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class)"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "zNQnbuejigZM"
},
"source": [
"> ✅ దయచేసి చూడండి:\n",
">\n",
"> - [సామాజిక శాస్త్రజ్ఞుల కోసం మెషీన్ లెర్నింగ్](https://cimentadaj.github.io/ml_socsci/tree-based-methods.html#random-forests)\n",
">\n",
"> - [R తో హ్యాండ్స్-ఆన్ మెషీన్ లెర్నింగ్](https://bradleyboehmke.github.io/HOML/)\n",
">\n",
"> - [R లో అనువర్తనాలతో గణాంకీయ లెర్నింగ్ కు పరిచయం](https://www.statlearning.com/)\n",
">\n",
"> - <https://algotech.netlify.app/blog/xgboost/> - xgboost కు మంచి ప్రత్యామ్నాయం అయిన AdaBoost మోడల్ ను పరిశీలిస్తుంది.\n",
">\n",
"> ఎంసెంబుల్ క్లాసిఫైయర్ల గురించి మరింత తెలుసుకోవడానికి.\n",
"\n",
"## 4. అదనపు - బహుళ మోడల్స్ ను పోల్చడం\n",
"\n",
"మేము ఈ ప్రయోగశాలలో చాలా మోడల్స్ ను ఫిట్ చేసాము 🙌. వేర్వేరు ప్రీప్రాసెసర్ల సెట్‌లు మరియు/లేదా మోడల్ స్పెసిఫికేషన్ల నుండి అనేక వర్క్‌ఫ్లోలను సృష్టించడం మరియు ఆపై పనితీరు మెట్రిక్స్ ను ఒక్కొక్కటిగా లెక్కించడం కష్టంగా లేదా భారంగా మారవచ్చు.\n",
"\n",
"ఇది పరిష్కరించగలమా అని చూద్దాం, ట్రైనింగ్ సెట్ పై వర్క్‌ఫ్లోల జాబితాను ఫిట్ చేసే ఒక ఫంక్షన్ సృష్టించి, ఆపై టెస్ట్ సెట్ ఆధారంగా పనితీరు మెట్రిక్స్ ను తిరిగి ఇస్తుంది. జాబితాలోని ప్రతి అంశానికి ఫంక్షన్లను వర్తింపజేయడానికి [purrr](https://purrr.tidyverse.org/) ప్యాకేజీ నుండి `map()` మరియు `map_dfr()` ను ఉపయోగిస్తాము.\n",
"\n",
"> [`map()`](https://purrr.tidyverse.org/reference/map.html) ఫంక్షన్లు అనేక for లూప్‌లను మరింత సంక్షిప్తంగా మరియు చదవడానికి సులభంగా ఉండే కోడ్‌తో మార్చడానికి అనుమతిస్తాయి. [`map()`](https://purrr.tidyverse.org/reference/map.html) ఫంక్షన్ల గురించి తెలుసుకోవడానికి ఉత్తమ స్థలం R ఫర్ డేటా సైన్స్ లోని [ఇటరేషన్ అధ్యాయం](http://r4ds.had.co.nz/iteration.html).\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "Qzb7LyZnimd2"
},
"source": [
"set.seed(2056)\n",
"\n",
"# Create a metric set\n",
"eval_metrics <- metric_set(ppv, sens, accuracy, f_meas)\n",
"\n",
"# Define a function that returns performance metrics\n",
"compare_models <- function(workflow_list, train_set, test_set){\n",
" \n",
" suppressWarnings(\n",
" # Fit each model to the train_set\n",
" map(workflow_list, fit, data = train_set) %>% \n",
" # Make predictions on the test set\n",
" map_dfr(augment, new_data = test_set, .id = \"model\") %>%\n",
" # Select desired columns\n",
" select(model, cuisine, .pred_class) %>% \n",
" # Evaluate model performance\n",
" group_by(model) %>% \n",
" eval_metrics(truth = cuisine, estimate = .pred_class) %>% \n",
" ungroup()\n",
" )\n",
" \n",
"} # End of function"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "Fwa712sNisDA"
},
"source": [
"మన ఫంక్షన్‌ను పిలిచి, మోడల్స్ మధ్య ఖచ్చితత్వాన్ని పోల్చుకుందాం.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "3i4VJOi2iu-a"
},
"source": [
"# Make a list of workflows\n",
"workflow_list <- list(\n",
" \"svc\" = svc_linear_wf,\n",
" \"svm\" = svm_rbf_wf,\n",
" \"knn\" = knn_wf,\n",
" \"random_forest\" = rf_wf,\n",
" \"xgboost\" = boost_wf)\n",
"\n",
"# Call the function\n",
"set.seed(2056)\n",
"perf_metrics <- compare_models(workflow_list = workflow_list, train_set = cuisines_train, test_set = cuisines_test)\n",
"\n",
"# Print out performance metrics\n",
"perf_metrics %>% \n",
" group_by(.metric) %>% \n",
" arrange(desc(.estimate)) %>% \n",
" slice_head(n=7)\n",
"\n",
"# Compare accuracy\n",
"perf_metrics %>% \n",
" filter(.metric == \"accuracy\") %>% \n",
" arrange(desc(.estimate))\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "KuWK_lEli4nW"
},
"source": [
"\n",
"[**workflowset**](https://workflowsets.tidymodels.org/) ప్యాకేజ్ వినియోగదారులకు పెద్ద సంఖ్యలో మోడల్స్ సృష్టించడానికి మరియు సులభంగా ఫిట్ చేయడానికి అనుమతిస్తుంది కానీ ఇది ఎక్కువగా `cross-validation` వంటి రీసాంప్లింగ్ సాంకేతికతలతో పనిచేయడానికి రూపొందించబడింది, ఇది మనం ఇంకా కవర్ చేయాల్సి ఉంది.\n",
"\n",
"## **🚀సవాలు**\n",
"\n",
"ఈ సాంకేతికతలలో ప్రతి ఒక్కదానికి మీరు సర్దుబాటు చేయగల పెద్ద సంఖ్యలో పారామితులు ఉంటాయి ఉదాహరణకు SVMs లో `cost`, KNN లో `neighbors`, Random Forest లో `mtry` (యాదృచ్ఛికంగా ఎంపిక చేసిన ప్రిడిక్టర్లు).\n",
"\n",
"ప్రతి ఒక్కటి యొక్క డిఫాల్ట్ పారామితులను పరిశోధించి, ఈ పారామితులను సర్దుబాటు చేయడం మోడల్ నాణ్యతకు ఏమి అర్థం అవుతుందో ఆలోచించండి.\n",
"\n",
"ఒక నిర్దిష్ట మోడల్ మరియు దాని పారామితుల గురించి మరింత తెలుసుకోవడానికి, ఉపయోగించండి: `help(\"model\")` ఉదా: `help(\"rand_forest\")`\n",
"\n",
"> ప్రాక్టికల్ లో, మనం సాధారణంగా ఈ విలువలలో *ఉత్తమ విలువలను* అంచనా వేస్తాము అనేక మోడల్స్ ను ఒక `సిమ్యులేటెడ్ డేటా సెట్` పై శిక్షణ ఇచ్చి, ఈ మోడల్స్ ఎంత బాగా ప్రదర్శిస్తాయో కొలిచి. ఈ ప్రక్రియను **ట్యూనింగ్** అంటారు.\n",
"\n",
"### [**పోస్ట్-లెక్చర్ క్విజ్**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/24/)\n",
"\n",
"### **సమీక్ష & స్వీయ అధ్యయనం**\n",
"\n",
"ఈ పాఠాలలో చాలా జార్గన్ ఉంది, కాబట్టి [ఈ జాబితా](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) ఉపయోగకరమైన పదజాలాన్ని సమీక్షించడానికి ఒక నిమిషం తీసుకోండి!\n",
"\n",
"#### ధన్యవాదాలు:\n",
"\n",
"[`Allison Horst`](https://twitter.com/allison_horst/) కు R ను మరింత ఆహ్లాదకరంగా మరియు ఆకర్షణీయంగా మార్చే అద్భుతమైన చిత్రణలను సృష్టించినందుకు. ఆమె మరిన్ని చిత్రణలను ఆమె [గ్యాలరీ](https://www.google.com/url?q=https://github.com/allisonhorst/stats-illustrations&sa=D&source=editors&ust=1626380772530000&usg=AOvVaw3zcfyCizFQZpkSLzxiiQEM) లో చూడండి.\n",
"\n",
"[Cassie Breviu](https://www.twitter.com/cassieview) మరియు [Jen Looper](https://www.twitter.com/jenlooper) కు ఈ మాడ్యూల్ యొక్క ఒరిజినల్ పైథాన్ వెర్షన్ సృష్టించినందుకు ♥️\n",
"\n",
"సంతోషంగా నేర్చుకోండి,\n",
"\n",
"[Eric](https://twitter.com/ericntay), గోల్డ్ మైక్రోసాఫ్ట్ లెర్న్ స్టూడెంట్ అంబాసిడర్.\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/r_learners_sm.f9199f76f1e2e49304b19155ebcfb8bad375aface4625be7e95404486a48d332.te.jpeg\"\n",
" width=\"569\"/>\n",
" <figcaption>Artwork by @allison_horst</figcaption>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

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

@ -0,0 +1,304 @@
{
"cells": [
{
"source": [
"# మరిన్ని వర్గీకరణ మోడల్స్ నిర్మించండి\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" Unnamed: 0 cuisine almond angelica anise anise_seed apple \\\n",
"0 0 indian 0 0 0 0 0 \n",
"1 1 indian 1 0 0 0 0 \n",
"2 2 indian 0 0 0 0 0 \n",
"3 3 indian 0 0 0 0 0 \n",
"4 4 indian 0 0 0 0 0 \n",
"\n",
" apple_brandy apricot armagnac ... whiskey white_bread white_wine \\\n",
"0 0 0 0 ... 0 0 0 \n",
"1 0 0 0 ... 0 0 0 \n",
"2 0 0 0 ... 0 0 0 \n",
"3 0 0 0 ... 0 0 0 \n",
"4 0 0 0 ... 0 0 0 \n",
"\n",
" whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
"0 0 0 0 0 0 0 0 \n",
"1 0 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 1 0 \n",
"\n",
"[5 rows x 382 columns]"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>Unnamed: 0</th>\n <th>cuisine</th>\n <th>almond</th>\n <th>angelica</th>\n <th>anise</th>\n <th>anise_seed</th>\n <th>apple</th>\n <th>apple_brandy</th>\n <th>apricot</th>\n <th>armagnac</th>\n <th>...</th>\n <th>whiskey</th>\n <th>white_bread</th>\n <th>white_wine</th>\n <th>whole_grain_wheat_flour</th>\n <th>wine</th>\n <th>wood</th>\n <th>yam</th>\n <th>yeast</th>\n <th>yogurt</th>\n <th>zucchini</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>0</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>1</th>\n <td>1</td>\n <td>indian</td>\n <td>1</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>2</th>\n <td>2</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>3</th>\n <td>3</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>4</th>\n <td>4</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>1</td>\n <td>0</td>\n </tr>\n </tbody>\n</table>\n<p>5 rows × 382 columns</p>\n</div>"
},
"metadata": {},
"execution_count": 1
}
],
"source": [
"import pandas as pd\n",
"cuisines_df = pd.read_csv(\"../../data/cleaned_cuisines.csv\")\n",
"cuisines_df.head()"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"0 indian\n",
"1 indian\n",
"2 indian\n",
"3 indian\n",
"4 indian\n",
"Name: cuisine, dtype: object"
]
},
"metadata": {},
"execution_count": 2
}
],
"source": [
"cuisines_label_df = cuisines_df['cuisine']\n",
"cuisines_label_df.head()"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" almond angelica anise anise_seed apple apple_brandy apricot \\\n",
"0 0 0 0 0 0 0 0 \n",
"1 1 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 0 0 \n",
"\n",
" armagnac artemisia artichoke ... whiskey white_bread white_wine \\\n",
"0 0 0 0 ... 0 0 0 \n",
"1 0 0 0 ... 0 0 0 \n",
"2 0 0 0 ... 0 0 0 \n",
"3 0 0 0 ... 0 0 0 \n",
"4 0 0 0 ... 0 0 0 \n",
"\n",
" whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
"0 0 0 0 0 0 0 0 \n",
"1 0 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 1 0 \n",
"\n",
"[5 rows x 380 columns]"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>almond</th>\n <th>angelica</th>\n <th>anise</th>\n <th>anise_seed</th>\n <th>apple</th>\n <th>apple_brandy</th>\n <th>apricot</th>\n <th>armagnac</th>\n <th>artemisia</th>\n <th>artichoke</th>\n <th>...</th>\n <th>whiskey</th>\n <th>white_bread</th>\n <th>white_wine</th>\n <th>whole_grain_wheat_flour</th>\n <th>wine</th>\n <th>wood</th>\n <th>yam</th>\n <th>yeast</th>\n <th>yogurt</th>\n <th>zucchini</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>1</th>\n <td>1</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>2</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>3</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>4</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>1</td>\n <td>0</td>\n </tr>\n </tbody>\n</table>\n<p>5 rows × 380 columns</p>\n</div>"
},
"metadata": {},
"execution_count": 3
}
],
"source": [
"cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)\n",
"cuisines_feature_df.head()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# వేరే వేరే వర్గీకరణలను ప్రయత్నించండి\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.neighbors import KNeighborsClassifier\n",
"from sklearn.linear_model import LogisticRegression\n",
"from sklearn.svm import SVC\n",
"from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n",
"from sklearn.model_selection import train_test_split, cross_val_score\n",
"from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve\n",
"import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"\n",
"C = 10\n",
"# Create different classifiers.\n",
"classifiers = {\n",
" 'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0),\n",
" 'KNN classifier': KNeighborsClassifier(C),\n",
" 'SVC': SVC(),\n",
" 'RFST': RandomForestClassifier(n_estimators=100),\n",
" 'ADA': AdaBoostClassifier(n_estimators=100)\n",
" \n",
"}\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Accuracy (train) for Linear SVC: 76.4% \n",
" precision recall f1-score support\n",
"\n",
" chinese 0.64 0.66 0.65 242\n",
" indian 0.91 0.86 0.89 236\n",
" japanese 0.72 0.73 0.73 245\n",
" korean 0.83 0.75 0.79 234\n",
" thai 0.75 0.82 0.78 242\n",
"\n",
" accuracy 0.76 1199\n",
" macro avg 0.77 0.76 0.77 1199\n",
"weighted avg 0.77 0.76 0.77 1199\n",
"\n",
"Accuracy (train) for KNN classifier: 70.7% \n",
" precision recall f1-score support\n",
"\n",
" chinese 0.65 0.63 0.64 242\n",
" indian 0.84 0.81 0.82 236\n",
" japanese 0.60 0.81 0.69 245\n",
" korean 0.89 0.53 0.67 234\n",
" thai 0.69 0.75 0.72 242\n",
"\n",
" accuracy 0.71 1199\n",
" macro avg 0.73 0.71 0.71 1199\n",
"weighted avg 0.73 0.71 0.71 1199\n",
"\n",
"Accuracy (train) for SVC: 80.1% \n",
" precision recall f1-score support\n",
"\n",
" chinese 0.71 0.69 0.70 242\n",
" indian 0.92 0.92 0.92 236\n",
" japanese 0.77 0.78 0.77 245\n",
" korean 0.87 0.77 0.82 234\n",
" thai 0.75 0.86 0.80 242\n",
"\n",
" accuracy 0.80 1199\n",
" macro avg 0.80 0.80 0.80 1199\n",
"weighted avg 0.80 0.80 0.80 1199\n",
"\n",
"Accuracy (train) for RFST: 82.8% \n",
" precision recall f1-score support\n",
"\n",
" chinese 0.80 0.75 0.77 242\n",
" indian 0.90 0.91 0.90 236\n",
" japanese 0.82 0.78 0.80 245\n",
" korean 0.85 0.82 0.83 234\n",
" thai 0.78 0.89 0.83 242\n",
"\n",
" accuracy 0.83 1199\n",
" macro avg 0.83 0.83 0.83 1199\n",
"weighted avg 0.83 0.83 0.83 1199\n",
"\n",
"Accuracy (train) for ADA: 71.1% \n",
" precision recall f1-score support\n",
"\n",
" chinese 0.60 0.57 0.58 242\n",
" indian 0.87 0.84 0.86 236\n",
" japanese 0.71 0.60 0.65 245\n",
" korean 0.68 0.78 0.72 234\n",
" thai 0.70 0.78 0.74 242\n",
"\n",
" accuracy 0.71 1199\n",
" macro avg 0.71 0.71 0.71 1199\n",
"weighted avg 0.71 0.71 0.71 1199\n",
"\n"
]
}
],
"source": [
"n_classifiers = len(classifiers)\n",
"\n",
"for index, (name, classifier) in enumerate(classifiers.items()):\n",
" classifier.fit(X_train, np.ravel(y_train))\n",
"\n",
" y_pred = classifier.predict(X_test)\n",
" accuracy = accuracy_score(y_test, y_pred)\n",
" print(\"Accuracy (train) for %s: %0.1f%% \" % (name, accuracy * 100))\n",
" print(classification_report(y_test,y_pred))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
],
"metadata": {
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3.7.0 64-bit ('3.7')"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
},
"metadata": {
"interpreter": {
"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_minor": 4
}

331
translations/te/4-Classification/4-Applied/README.md
Unescape View File

@ -0,0 +1,331 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "61bdec27ed2da8b098cd9065405d9bb0",
"translation_date": "2025-12-19T15:26:05+00:00",
"source_file": "4-Classification/4-Applied/README.md",
"language_code": "te"
}
-->
# వంటక సిఫార్సు వెబ్ యాప్ నిర్మించండి
ఈ పాఠంలో, మీరు గత పాఠాలలో నేర్చుకున్న కొన్ని సాంకేతికతలను ఉపయోగించి మరియు ఈ సిరీస్ అంతటా ఉపయోగించిన రుచికరమైన వంటక డేటాసెట్‌తో ఒక వర్గీకరణ మోడల్‌ను నిర్మిస్తారు. అదనంగా, మీరు ఒక చిన్న వెబ్ యాప్‌ను నిర్మించి, సేవ్ చేసిన మోడల్‌ను ఉపయోగించడానికి Onnx యొక్క వెబ్ రన్‌టైమ్‌ను ఉపయోగిస్తారు.
యంత్ర అభ్యాసం యొక్క అత్యంత ఉపయోగకరమైన ప్రాయోగిక ఉపయోగాలలో ఒకటి సిఫార్సు వ్యవస్థలను నిర్మించడం, మరియు మీరు ఈ దిశలో మొదటి అడుగు వేయవచ్చు!
[![ఈ వెబ్ యాప్‌ను ప్రదర్శించడం](https://img.youtube.com/vi/17wdM9AHMfg/0.jpg)](https://youtu.be/17wdM9AHMfg "Applied ML")
> 🎥 వీడియో కోసం పై చిత్రాన్ని క్లిక్ చేయండి: జెన్ లూపర్ వర్గీకరించిన వంటక డేటాను ఉపయోగించి వెబ్ యాప్‌ను నిర్మిస్తున్నారు
## [పాఠం ముందు క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
ఈ పాఠంలో మీరు నేర్చుకుంటారు:
- మోడల్‌ను ఎలా నిర్మించి Onnx మోడల్‌గా సేవ్ చేయాలి
- మోడల్‌ను పరిశీలించడానికి Netron ను ఎలా ఉపయోగించాలి
- మీ మోడల్‌ను వెబ్ యాప్‌లో ఇన్ఫరెన్స్ కోసం ఎలా ఉపయోగించాలి
## మీ మోడల్‌ను నిర్మించండి
అప్లైడ్ ML వ్యవస్థలను నిర్మించడం మీ వ్యాపార వ్యవస్థల కోసం ఈ సాంకేతికతలను ఉపయోగించుకోవడంలో ముఖ్యమైన భాగం. మీరు మీ వెబ్ అప్లికేషన్లలో మోడల్స్‌ను ఉపయోగించవచ్చు (అవసరమైతే ఆఫ్‌లైన్ సందర్భంలో కూడా ఉపయోగించవచ్చు) Onnx ఉపయోగించి.
[మునుపటి పాఠంలో](../../3-Web-App/1-Web-App/README.md), మీరు UFO సైట్‌ల గురించి రిగ్రెషన్ మోడల్‌ను నిర్మించి, దాన్ని "పికిల్" చేసి, Flask యాప్‌లో ఉపయోగించారు. ఈ ఆర్కిటెక్చర్ తెలుసుకోవడం చాలా ఉపయోగకరం అయినప్పటికీ, ఇది పూర్తి-స్టాక్ Python యాప్, మరియు మీ అవసరాలు JavaScript అప్లికేషన్ ఉపయోగించడాన్ని కూడా కలిగి ఉండవచ్చు.
ఈ పాఠంలో, మీరు ఇన్ఫరెన్స్ కోసం ఒక ప్రాథమిక JavaScript ఆధారిత వ్యవస్థను నిర్మించవచ్చు. అయితే, ముందుగా మీరు ఒక మోడల్‌ను శిక్షణ ఇచ్చి, దాన్ని Onnx కోసం మార్చాలి.
## వ్యాయామం - వర్గీకరణ మోడల్ శిక్షణ
ముందుగా, మనం ఉపయోగించిన శుభ్రపరిచిన వంటక డేటాసెట్‌ను ఉపయోగించి వర్గీకరణ మోడల్‌ను శిక్షణ ఇవ్వండి.
1. ఉపయోగకరమైన లైబ్రరీలను దిగుమతి చేసుకోవడం ప్రారంభించండి:
```python
!pip install skl2onnx
import pandas as pd
```
మీ Scikit-learn మోడల్‌ను Onnx ఫార్మాట్‌కు మార్చడానికి '[skl2onnx](https://onnx.ai/sklearn-onnx/)' అవసరం.
1. తరువాత, మీరు గత పాఠాలలో చేసినట్లుగా, `read_csv()` ఉపయోగించి CSV ఫైల్‌ను చదవడం ద్వారా మీ డేటాతో పని చేయండి:
```python
data = pd.read_csv('../data/cleaned_cuisines.csv')
data.head()
```
1. మొదటి రెండు అవసరం లేని కాలమ్స్‌ను తీసివేసి మిగిలిన డేటాను 'X'గా సేవ్ చేయండి:
```python
X = data.iloc[:,2:]
X.head()
```
1. లేబుల్స్‌ను 'y'గా సేవ్ చేయండి:
```python
y = data[['cuisine']]
y.head()
```
### శిక్షణ రొటీన్ ప్రారంభించండి
మనం మంచి ఖచ్చితత్వం కలిగిన 'SVC' లైబ్రరీని ఉపయోగిస్తాము.
1. Scikit-learn నుండి సరైన లైబ్రరీలను దిగుమతి చేసుకోండి:
```python
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report
```
1. శిక్షణ మరియు పరీక్ష సెట్లను వేరు చేయండి:
```python
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3)
```
1. మీరు గత పాఠంలో చేసినట్లుగా SVC వర్గీకరణ మోడల్‌ను నిర్మించండి:
```python
model = SVC(kernel='linear', C=10, probability=True,random_state=0)
model.fit(X_train,y_train.values.ravel())
```
1. ఇప్పుడు, మీ మోడల్‌ను పరీక్షించండి, `predict()` ను పిలవండి:
```python
y_pred = model.predict(X_test)
```
1. మోడల్ నాణ్యతను తనిఖీ చేయడానికి వర్గీకరణ నివేదికను ముద్రించండి:
```python
print(classification_report(y_test,y_pred))
```
మునుపటి విధంగా, ఖచ్చితత్వం మంచి ఉంది:
```output
precision recall f1-score support
chinese 0.72 0.69 0.70 257
indian 0.91 0.87 0.89 243
japanese 0.79 0.77 0.78 239
korean 0.83 0.79 0.81 236
thai 0.72 0.84 0.78 224
accuracy 0.79 1199
macro avg 0.79 0.79 0.79 1199
weighted avg 0.79 0.79 0.79 1199
```
### మీ మోడల్‌ను Onnx కు మార్చండి
సరైన టెన్సర్ సంఖ్యతో మార్చడం నిర్ధారించండి. ఈ డేటాసెట్‌లో 380 పదార్థాలు ఉన్నాయి, కాబట్టి మీరు `FloatTensorType` లో ఆ సంఖ్యను సూచించాలి:
1. 380 టెన్సర్ సంఖ్యతో మార్చండి.
```python
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType
initial_type = [('float_input', FloatTensorType([None, 380]))]
options = {id(model): {'nocl': True, 'zipmap': False}}
```
1. onx సృష్టించి **model.onnx** ఫైల్‌గా సేవ్ చేయండి:
```python
onx = convert_sklearn(model, initial_types=initial_type, options=options)
with open("./model.onnx", "wb") as f:
f.write(onx.SerializeToString())
```
> గమనిక, మీరు మీ మార్చే స్క్రిప్ట్‌లో [ఆప్షన్లు](https://onnx.ai/sklearn-onnx/parameterized.html) ఇవ్వవచ్చు. ఈ సందర్భంలో, 'nocl' ను True గా మరియు 'zipmap' ను False గా ఇచ్చాము. ఇది వర్గీకరణ మోడల్ కావడంతో, ZipMap ను తీసివేయవచ్చు, ఇది డిక్షనరీల జాబితాను ఉత్పత్తి చేస్తుంది (అవసరం లేదు). `nocl` అనేది మోడల్‌లో తరగతి సమాచారాన్ని సూచిస్తుంది. `nocl` ను 'True' గా సెట్ చేసి మీ మోడల్ పరిమాణాన్ని తగ్గించండి.
పూర్తి నోట్‌బుక్‌ను నడిపితే ఇప్పుడు Onnx మోడల్ నిర్మించి ఈ ఫోల్డర్‌లో సేవ్ చేస్తుంది.
## మీ మోడల్‌ను వీక్షించండి
Onnx మోడల్స్ Visual Studio కోడ్‌లో చాలా స్పష్టంగా కనిపించవు, కానీ చాలా పరిశోధకులు ఉపయోగించే ఒక మంచి ఉచిత సాఫ్ట్‌వేర్ ఉంది, ఇది మోడల్ సరిగ్గా నిర్మించబడిందో లేదో చూడటానికి ఉపయోగపడుతుంది. [Netron](https://github.com/lutzroeder/Netron) డౌన్లోడ్ చేసి మీ model.onnx ఫైల్‌ను తెరవండి. మీరు మీ సాదారణ మోడల్‌ను దాని 380 ఇన్‌పుట్లు మరియు వర్గీకరణతో చూడవచ్చు:
![Netron visual](../../../../translated_images/netron.a05f39410211915e0f95e2c0e8b88f41e7d13d725faf660188f3802ba5c9e831.te.png)
Netron మీ మోడల్స్‌ను వీక్షించడానికి సహాయక సాధనం.
ఇప్పుడు మీరు ఈ చక్కని మోడల్‌ను వెబ్ యాప్‌లో ఉపయోగించడానికి సిద్ధంగా ఉన్నారు. మీరు మీ ఫ్రిజ్‌లో ఉన్న మిగిలిన పదార్థాల కలయికను చూసి, మీ మోడల్ నిర్ణయించిన వంటకం ఏదో తెలుసుకోవడానికి ఉపయోగపడే యాప్‌ను నిర్మిద్దాం.
## సిఫార్సు వెబ్ అప్లికేషన్ నిర్మించండి
మీ మోడల్‌ను నేరుగా వెబ్ యాప్‌లో ఉపయోగించవచ్చు. ఈ ఆర్కిటెక్చర్ స్థానికంగా మరియు అవసరమైతే ఆఫ్‌లైన్‌లో కూడా నడపడానికి అనుమతిస్తుంది. మీరు `model.onnx` ఫైల్‌ను సేవ్ చేసిన అదే ఫోల్డర్‌లో `index.html` ఫైల్‌ను సృష్టించడం ప్రారంభించండి.
1. ఈ _index.html_ ఫైల్‌లో క్రింది మార్కప్‌ను జోడించండి:
```html
<!DOCTYPE html>
<html>
<header>
<title>Cuisine Matcher</title>
</header>
<body>
...
</body>
</html>
```
1. ఇప్పుడు, `body` ట్యాగ్‌లలో, కొన్ని పదార్థాలను ప్రతిబింబించే చెక్‌బాక్స్‌ల జాబితాను చూపించడానికి కొంత మార్కప్ జోడించండి:
```html
<h1>Check your refrigerator. What can you create?</h1>
<div id="wrapper">
<div class="boxCont">
<input type="checkbox" value="4" class="checkbox">
<label>apple</label>
</div>
<div class="boxCont">
<input type="checkbox" value="247" class="checkbox">
<label>pear</label>
</div>
<div class="boxCont">
<input type="checkbox" value="77" class="checkbox">
<label>cherry</label>
</div>
<div class="boxCont">
<input type="checkbox" value="126" class="checkbox">
<label>fenugreek</label>
</div>
<div class="boxCont">
<input type="checkbox" value="302" class="checkbox">
<label>sake</label>
</div>
<div class="boxCont">
<input type="checkbox" value="327" class="checkbox">
<label>soy sauce</label>
</div>
<div class="boxCont">
<input type="checkbox" value="112" class="checkbox">
<label>cumin</label>
</div>
</div>
<div style="padding-top:10px">
<button onClick="startInference()">What kind of cuisine can you make?</button>
</div>
```
ప్రతి చెక్‌బాక్స్‌కు ఒక విలువ ఇవ్వబడింది గమనించండి. ఇది డేటాసెట్ ప్రకారం పదార్థం కనుగొనబడిన సూచికను సూచిస్తుంది. ఉదాహరణకు, ఆపిల్ ఈ అక్షరాల క్రమంలో ఐదవ కాలమ్‌లో ఉంది, కాబట్టి దాని విలువ '4' (0 నుండి లెక్కించడం ప్రారంభిస్తాం). మీరు [పదార్థాల స్ప్రెడ్షీట్](../../../../4-Classification/data/ingredient_indexes.csv) ను చూడవచ్చు ఒక పదార్థం సూచిక తెలుసుకోవడానికి.
index.html ఫైల్‌లో మీ పని కొనసాగిస్తూ, చివరి మూసివేత `</div>` తర్వాత మోడల్ పిలవబడే స్క్రిప్ట్ బ్లాక్‌ను జోడించండి.
1. మొదట, [Onnx Runtime](https://www.onnxruntime.ai/) ను దిగుమతి చేసుకోండి:
```html
<script src="https://cdn.jsdelivr.net/npm/onnxruntime-web@1.9.0/dist/ort.min.js"></script>
```
> Onnx Runtime అనేది విస్తృత హార్డ్‌వేర్ ప్లాట్‌ఫారమ్‌లపై మీ Onnx మోడల్స్‌ను నడపడానికి ఉపయోగిస్తారు, ఆప్టిమైజేషన్లు మరియు APIతో సహా.
1. Runtime సిద్ధంగా ఉన్న తర్వాత, మీరు దాన్ని పిలవవచ్చు:
```html
<script>
const ingredients = Array(380).fill(0);
const checks = [...document.querySelectorAll('.checkbox')];
checks.forEach(check => {
check.addEventListener('change', function() {
// toggle the state of the ingredient
// based on the checkbox's value (1 or 0)
ingredients[check.value] = check.checked ? 1 : 0;
});
});
function testCheckboxes() {
// validate if at least one checkbox is checked
return checks.some(check => check.checked);
}
async function startInference() {
let atLeastOneChecked = testCheckboxes()
if (!atLeastOneChecked) {
alert('Please select at least one ingredient.');
return;
}
try {
// create a new session and load the model.
const session = await ort.InferenceSession.create('./model.onnx');
const input = new ort.Tensor(new Float32Array(ingredients), [1, 380]);
const feeds = { float_input: input };
// feed inputs and run
const results = await session.run(feeds);
// read from results
alert('You can enjoy ' + results.label.data[0] + ' cuisine today!')
} catch (e) {
console.log(`failed to inference ONNX model`);
console.error(e);
}
}
</script>
```
ఈ కోడ్‌లో కొన్ని విషయాలు జరుగుతున్నాయి:
1. మీరు 380 సాధ్యమైన విలువల (1 లేదా 0) అrrayని సృష్టించారు, ఇది మోడల్‌కు ఇన్ఫరెన్స్ కోసం పంపబడుతుంది, చెక్‌బాక్స్ ఎంచుకున్నదో లేదో ఆధారంగా.
2. మీరు చెక్‌బాక్స్‌ల అrray మరియు వాటిని ఎంచుకున్నదో లేదో తెలుసుకునే `init` ఫంక్షన్‌ను సృష్టించారు, ఇది యాప్ ప్రారంభంలో పిలవబడుతుంది. చెక్‌బాక్స్ ఎంచుకున్నప్పుడు, `ingredients` అrray ఎంచుకున్న పదార్థాన్ని ప్రతిబింబించడానికి మార్చబడుతుంది.
3. మీరు `testCheckboxes` ఫంక్షన్‌ను సృష్టించారు, ఇది ఏదైనా చెక్‌బాక్స్ ఎంచుకున్నదో లేదో తనిఖీ చేస్తుంది.
4. మీరు బటన్ నొక్కినప్పుడు `startInference` ఫంక్షన్‌ను ఉపయోగించి, ఏదైనా చెక్‌బాక్స్ ఎంచుకున్నట్లయితే ఇన్ఫరెన్స్ ప్రారంభిస్తారు.
5. ఇన్ఫరెన్స్ రొటీన్‌లో:
1. మోడల్‌ను అసింక్రనస్‌గా లోడ్ చేయడం
2. మోడల్‌కు పంపడానికి టెన్సర్ నిర్మాణం సృష్టించడం
3. మీరు శిక్షణ సమయంలో సృష్టించిన `float_input` ఇన్‌పుట్‌ను ప్రతిబింబించే 'feeds' సృష్టించడం (ఆ పేరు Netron ద్వారా ధృవీకరించవచ్చు)
4. ఈ 'feeds' ను మోడల్‌కు పంపించి ప్రతిస్పందన కోసం వేచివుండడం
## మీ అప్లికేషన్‌ను పరీక్షించండి
Visual Studio Codeలో మీ index.html ఫైల్ ఉన్న ఫోల్డర్‌లో టెర్మినల్ సెషన్‌ను తెరవండి. మీరు [http-server](https://www.npmjs.com/package/http-server) ను గ్లోబల్‌గా ఇన్‌స్టాల్ చేసుకున్నారని నిర్ధారించుకుని, ప్రాంప్ట్ వద్ద `http-server` టైప్ చేయండి. ఒక localhost తెరుచుకుంటుంది మరియు మీరు మీ వెబ్ యాప్‌ను వీక్షించవచ్చు. వివిధ పదార్థాల ఆధారంగా ఏ వంటకం సిఫార్సు అవుతుందో తనిఖీ చేయండి:
![ingredient web app](../../../../translated_images/web-app.4c76450cabe20036f8ec6d5e05ccc0c1c064f0d8f2fe3304d3bcc0198f7dc139.te.png)
అభినందనలు, మీరు కొన్ని ఫీల్డ్స్‌తో 'సిఫార్సు' వెబ్ యాప్‌ను సృష్టించారు. ఈ వ్యవస్థను మరింత అభివృద్ధి చేసేందుకు కొంత సమయం కేటాయించండి!
## 🚀సవాలు
మీ వెబ్ యాప్ చాలా సాదారణంగా ఉంది, కాబట్టి [ingredient_indexes](../../../../4-Classification/data/ingredient_indexes.csv) డేటా నుండి పదార్థాలు మరియు వాటి సూచికలను ఉపయోగించి దీన్ని మరింత అభివృద్ధి చేయండి. ఏ రుచుల కలయికలు ఒక నిర్దిష్ట జాతీయ వంటకం తయారుచేస్తాయో తెలుసుకోండి?
## [పాఠం తర్వాత క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
ఈ పాఠం ఆహార పదార్థాల కోసం సిఫార్సు వ్యవస్థను సృష్టించే ఉపయోగకరతను తాకింది, కానీ ML అప్లికేషన్ల ఈ విభాగం ఉదాహరణలతో చాలా సంపన్నంగా ఉంది. ఈ వ్యవస్థలు ఎలా నిర్మించబడతాయో మరింత చదవండి:
- https://www.sciencedirect.com/topics/computer-science/recommendation-engine
- https://www.technologyreview.com/2014/08/25/171547/the-ultimate-challenge-for-recommendation-engines/
- https://www.technologyreview.com/2015/03/23/168831/everything-is-a-recommendation/
## అసైన్‌మెంట్
[కొత్త సిఫార్సు యాప్ నిర్మించండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/4-Classification/4-Applied/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "799ed651e2af0a7cad17c6268db11578",
"translation_date": "2025-12-19T15:29:09+00:00",
"source_file": "4-Classification/4-Applied/assignment.md",
"language_code": "te"
}
-->
# సిఫార్సుదారుడిని నిర్మించండి
## సూచనలు
ఈ పాఠంలో మీ వ్యాయామాలను బట్టి, మీరు ఇప్పుడు Onnx Runtime మరియు మార్చిన Onnx మోడల్ ఉపయోగించి జావాస్క్రిప్ట్ ఆధారిత వెబ్ యాప్‌ను ఎలా నిర్మించాలో తెలుసుకున్నారు. ఈ పాఠాల నుండి లేదా ఇతర మూలాల నుండి డేటాను ఉపయోగించి కొత్త సిఫార్సుదారుడిని నిర్మించడంలో ప్రయోగించండి (దయచేసి క్రెడిట్ ఇవ్వండి). వివిధ వ్యక్తిత్వ లక్షణాలను బట్టి పెట్ సిఫార్సుదారుడిని లేదా వ్యక్తి మూడ్ ఆధారంగా సంగీత జానర్ సిఫార్సుదారుడిని సృష్టించవచ్చు. సృజనాత్మకంగా ఉండండి!
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | ---------------------------------------------------------------------- | ------------------------------------- | --------------------------------- |
| | ఒక వెబ్ యాప్ మరియు నోట్బుక్ అందించబడ్డాయి, రెండూ బాగా డాక్యుమెంటెడ్ మరియు నడుస్తున్నవి | వాటిలో ఒకటి లేకపోవడం లేదా లోపం కలిగి ఉండటం | రెండూ లేకపోవడం లేదా లోపం కలిగి ఉండటం |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

41
translations/te/4-Classification/4-Applied/notebook.ipynb
Unescape View File

@ -0,0 +1,41 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": 3
},
"orig_nbformat": 4,
"coopTranslator": {
"original_hash": "2f3e0d9e9ac5c301558fb8bf733ac0cb",
"translation_date": "2025-12-19T17:03:01+00:00",
"source_file": "4-Classification/4-Applied/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"source": [
"# వంటక సిఫారసు యంత్రం నిర్మించండి\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

292
translations/te/4-Classification/4-Applied/solution/notebook.ipynb
Unescape View File

@ -0,0 +1,292 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.0"
},
"orig_nbformat": 2,
"kernelspec": {
"name": "python3",
"display_name": "Python 3.7.0 64-bit ('3.7')"
},
"metadata": {
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
}
},
"interpreter": {
"hash": "70b38d7a306a849643e446cd70466270a13445e5987dfa1344ef2b127438fa4d"
},
"coopTranslator": {
"original_hash": "49325d6dd12a3628fc64fa7ccb1a80ff",
"translation_date": "2025-12-19T17:17:53+00:00",
"source_file": "4-Classification/4-Applied/solution/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"source": [
"# వంటక సిఫారసు యంత్రం నిర్మించండి\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Requirement already satisfied: skl2onnx in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (1.8.0)\n",
"Requirement already satisfied: protobuf in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from skl2onnx) (3.8.0)\n",
"Requirement already satisfied: numpy>=1.15 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from skl2onnx) (1.19.2)\n",
"Requirement already satisfied: onnx>=1.2.1 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from skl2onnx) (1.9.0)\n",
"Requirement already satisfied: six in /Users/jenlooper/Library/Python/3.7/lib/python/site-packages (from skl2onnx) (1.12.0)\n",
"Requirement already satisfied: onnxconverter-common<1.9,>=1.6.1 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from skl2onnx) (1.8.1)\n",
"Requirement already satisfied: scikit-learn>=0.19 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from skl2onnx) (0.24.2)\n",
"Requirement already satisfied: scipy>=1.0 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from skl2onnx) (1.4.1)\n",
"Requirement already satisfied: setuptools in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from protobuf->skl2onnx) (45.1.0)\n",
"Requirement already satisfied: typing-extensions>=3.6.2.1 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from onnx>=1.2.1->skl2onnx) (3.10.0.0)\n",
"Requirement already satisfied: threadpoolctl>=2.0.0 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from scikit-learn>=0.19->skl2onnx) (2.1.0)\n",
"Requirement already satisfied: joblib>=0.11 in /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages (from scikit-learn>=0.19->skl2onnx) (0.16.0)\n",
"\u001b[33mWARNING: You are using pip version 20.2.3; however, version 21.1.2 is available.\n",
"You should consider upgrading via the '/Library/Frameworks/Python.framework/Versions/3.7/bin/python3.7 -m pip install --upgrade pip' command.\u001b[0m\n",
"Note: you may need to restart the kernel to use updated packages.\n"
]
}
],
"source": [
"!pip install skl2onnx"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd \n"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" Unnamed: 0 cuisine almond angelica anise anise_seed apple \\\n",
"0 0 indian 0 0 0 0 0 \n",
"1 1 indian 1 0 0 0 0 \n",
"2 2 indian 0 0 0 0 0 \n",
"3 3 indian 0 0 0 0 0 \n",
"4 4 indian 0 0 0 0 0 \n",
"\n",
" apple_brandy apricot armagnac ... whiskey white_bread white_wine \\\n",
"0 0 0 0 ... 0 0 0 \n",
"1 0 0 0 ... 0 0 0 \n",
"2 0 0 0 ... 0 0 0 \n",
"3 0 0 0 ... 0 0 0 \n",
"4 0 0 0 ... 0 0 0 \n",
"\n",
" whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
"0 0 0 0 0 0 0 0 \n",
"1 0 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 1 0 \n",
"\n",
"[5 rows x 382 columns]"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>Unnamed: 0</th>\n <th>cuisine</th>\n <th>almond</th>\n <th>angelica</th>\n <th>anise</th>\n <th>anise_seed</th>\n <th>apple</th>\n <th>apple_brandy</th>\n <th>apricot</th>\n <th>armagnac</th>\n <th>...</th>\n <th>whiskey</th>\n <th>white_bread</th>\n <th>white_wine</th>\n <th>whole_grain_wheat_flour</th>\n <th>wine</th>\n <th>wood</th>\n <th>yam</th>\n <th>yeast</th>\n <th>yogurt</th>\n <th>zucchini</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>0</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>1</th>\n <td>1</td>\n <td>indian</td>\n <td>1</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>2</th>\n <td>2</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>3</th>\n <td>3</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>4</th>\n <td>4</td>\n <td>indian</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>1</td>\n <td>0</td>\n </tr>\n </tbody>\n</table>\n<p>5 rows × 382 columns</p>\n</div>"
},
"metadata": {},
"execution_count": 60
}
],
"source": [
"data = pd.read_csv('../../data/cleaned_cuisines.csv')\n",
"data.head()"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" almond angelica anise anise_seed apple apple_brandy apricot \\\n",
"0 0 0 0 0 0 0 0 \n",
"1 1 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 0 0 \n",
"\n",
" armagnac artemisia artichoke ... whiskey white_bread white_wine \\\n",
"0 0 0 0 ... 0 0 0 \n",
"1 0 0 0 ... 0 0 0 \n",
"2 0 0 0 ... 0 0 0 \n",
"3 0 0 0 ... 0 0 0 \n",
"4 0 0 0 ... 0 0 0 \n",
"\n",
" whole_grain_wheat_flour wine wood yam yeast yogurt zucchini \n",
"0 0 0 0 0 0 0 0 \n",
"1 0 0 0 0 0 0 0 \n",
"2 0 0 0 0 0 0 0 \n",
"3 0 0 0 0 0 0 0 \n",
"4 0 0 0 0 0 1 0 \n",
"\n",
"[5 rows x 380 columns]"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>almond</th>\n <th>angelica</th>\n <th>anise</th>\n <th>anise_seed</th>\n <th>apple</th>\n <th>apple_brandy</th>\n <th>apricot</th>\n <th>armagnac</th>\n <th>artemisia</th>\n <th>artichoke</th>\n <th>...</th>\n <th>whiskey</th>\n <th>white_bread</th>\n <th>white_wine</th>\n <th>whole_grain_wheat_flour</th>\n <th>wine</th>\n <th>wood</th>\n <th>yam</th>\n <th>yeast</th>\n <th>yogurt</th>\n <th>zucchini</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>1</th>\n <td>1</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>2</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>3</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n </tr>\n <tr>\n <th>4</th>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>...</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>0</td>\n <td>1</td>\n <td>0</td>\n </tr>\n </tbody>\n</table>\n<p>5 rows × 380 columns</p>\n</div>"
},
"metadata": {},
"execution_count": 61
}
],
"source": [
"X = data.iloc[:,2:]\n",
"X.head()"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
" cuisine\n",
"0 indian\n",
"1 indian\n",
"2 indian\n",
"3 indian\n",
"4 indian"
],
"text/html": "<div>\n<style scoped>\n .dataframe tbody tr th:only-of-type {\n vertical-align: middle;\n }\n\n .dataframe tbody tr th {\n vertical-align: top;\n }\n\n .dataframe thead th {\n text-align: right;\n }\n</style>\n<table border=\"1\" class=\"dataframe\">\n <thead>\n <tr style=\"text-align: right;\">\n <th></th>\n <th>cuisine</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <th>0</th>\n <td>indian</td>\n </tr>\n <tr>\n <th>1</th>\n <td>indian</td>\n </tr>\n <tr>\n <th>2</th>\n <td>indian</td>\n </tr>\n <tr>\n <th>3</th>\n <td>indian</td>\n </tr>\n <tr>\n <th>4</th>\n <td>indian</td>\n </tr>\n </tbody>\n</table>\n</div>"
},
"metadata": {},
"execution_count": 62
}
],
"source": [
"y = data[['cuisine']]\n",
"y.head()"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.model_selection import train_test_split\n",
"from sklearn.svm import SVC\n",
"from sklearn.model_selection import cross_val_score\n",
"from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report"
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {},
"outputs": [],
"source": [
"X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3)"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"SVC(C=10, kernel='linear', probability=True, random_state=0)"
]
},
"metadata": {},
"execution_count": 65
}
],
"source": [
"model = SVC(kernel='linear', C=10, probability=True,random_state=0)\n",
"model.fit(X_train,y_train.values.ravel())\n"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {},
"outputs": [],
"source": [
"y_pred = model.predict(X_test)"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
" precision recall f1-score support\n\n chinese 0.72 0.70 0.71 236\n indian 0.91 0.88 0.89 243\n japanese 0.80 0.75 0.77 240\n korean 0.80 0.81 0.81 230\n thai 0.76 0.85 0.80 250\n\n accuracy 0.80 1199\n macro avg 0.80 0.80 0.80 1199\nweighted avg 0.80 0.80 0.80 1199\n\n"
]
}
],
"source": [
"print(classification_report(y_test,y_pred))"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {},
"outputs": [],
"source": [
"from skl2onnx import convert_sklearn\n",
"from skl2onnx.common.data_types import FloatTensorType\n",
"\n",
"initial_type = [('float_input', FloatTensorType([None, 380]))]\n",
"options = {id(model): {'nocl': True, 'zipmap': False}}\n",
"onx = convert_sklearn(model, initial_types=initial_type, options=options)\n",
"with open(\"./model.onnx\", \"wb\") as f:\n",
" f.write(onx.SerializeToString())\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

43
translations/te/4-Classification/README.md
Unescape View File

@ -0,0 +1,43 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "74e809ffd1e613a1058bbc3e9600859e",
"translation_date": "2025-12-19T13:06:34+00:00",
"source_file": "4-Classification/README.md",
"language_code": "te"
}
-->
# వర్గీకరణతో ప్రారంభించడం
## ప్రాంతీయ విషయం: రుచికరమైన ఆసియా మరియు భారతీయ వంటకాలు 🍜
ఆసియా మరియు భారతదేశంలో, ఆహార సంప్రదాయాలు చాలా వైవిధ్యంగా ఉంటాయి, మరియు చాలా రుచికరంగా ఉంటాయి! వారి పదార్థాలను అర్థం చేసుకోవడానికి ప్రాంతీయ వంటకాల గురించి డేటాను చూద్దాం.
![Thai food seller](../../../translated_images/thai-food.c47a7a7f9f05c21892a1f9dc7bf30669e6d18dfda420c5c7ebb4153f6a304edd.te.jpg)
> ఫోటో <a href="https://unsplash.com/@changlisheng?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">లిషెంగ్ చాంగ్</a> ద్వారా <a href="https://unsplash.com/s/photos/asian-food?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">అన్స్ప్లాష్</a>లో
## మీరు నేర్చుకునేది
ఈ విభాగంలో, మీరు మీ ముందటి రిగ్రెషన్ అధ్యయనంపై ఆధారపడి, డేటాను మెరుగ్గా అర్థం చేసుకోవడానికి ఉపయోగించగల ఇతర వర్గీకరణకర్తలను నేర్చుకుంటారు.
> వర్గీకరణ మోడళ్లతో పని చేయడాన్ని నేర్చుకోవడానికి సహాయపడే ఉపయోగకరమైన తక్కువ-కోడ్ టూల్స్ ఉన్నాయి. ఈ పనికి [Azure ML ను ప్రయత్నించండి](https://docs.microsoft.com/learn/modules/create-classification-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
## పాఠాలు
1. [వర్గీకరణకు పరిచయం](1-Introduction/README.md)
2. [ఇంకా వర్గీకరణకర్తలు](2-Classifiers-1/README.md)
3. [మరిన్ని వర్గీకరణకర్తలు](3-Classifiers-2/README.md)
4. [అప్లైడ్ ML: వెబ్ యాప్ నిర్మాణం](4-Applied/README.md)
## క్రెడిట్స్
"వర్గీకరణతో ప్రారంభించడం" ను ♥️ తో [క్యాసీ బ్రేవియూ](https://www.twitter.com/cassiebreviu) మరియు [జెన్ లూపర్](https://www.twitter.com/jenlooper) రాశారు
రుచికరమైన వంటకాల డేటాసెట్ [కాగుల్](https://www.kaggle.com/hoandan/asian-and-indian-cuisines) నుండి సేకరించబడింది.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

348
translations/te/5-Clustering/1-Visualize/README.md
Unescape View File

@ -0,0 +1,348 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "730225ea274c9174fe688b21d421539d",
"translation_date": "2025-12-19T14:56:36+00:00",
"source_file": "5-Clustering/1-Visualize/README.md",
"language_code": "te"
}
-->
# క్లస్టరింగ్ పరిచయం
క్లస్టరింగ్ అనేది [అనియంత్రిత అభ్యాసం](https://wikipedia.org/wiki/Unsupervised_learning) యొక్క ఒక రకం, ఇది ఒక డేటాసెట్ లేబుల్ చేయబడలేదు లేదా దాని ఇన్‌పుట్లు ముందుగా నిర్వచించిన అవుట్‌పుట్లతో సరిపోలడం లేదు అని ఊహిస్తుంది. ఇది వివిధ అల్గోరిథమ్లను ఉపయోగించి లేబుల్ చేయబడని డేటాను వర్గీకరించి, డేటాలో కనిపించే నమూనాల ప్రకారం సమూహాలను అందిస్తుంది.
[![No One Like You by PSquare](https://img.youtube.com/vi/ty2advRiWJM/0.jpg)](https://youtu.be/ty2advRiWJM "No One Like You by PSquare")
> 🎥 పై చిత్రాన్ని క్లిక్ చేయండి వీడియో కోసం. మీరు క్లస్టరింగ్‌తో మెషీన్ లెర్నింగ్ అధ్యయనం చేస్తున్నప్పుడు, కొన్ని నైజీరియన్ డాన్స్ హాల్ ట్రాక్స్‌ను ఆస్వాదించండి - ఇది 2014లో PSquare నుండి అత్యధిక రేటింగ్ పొందిన పాట.
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
### పరిచయం
[క్లస్టరింగ్](https://link.springer.com/referenceworkentry/10.1007%2F978-0-387-30164-8_124) డేటా అన్వేషణకు చాలా ఉపయోగకరం. నైజీరియన్ ప్రేక్షకులు సంగీతాన్ని ఎలా వినుతారో దాని లోపల ధోరణులు మరియు నమూనాలను కనుగొనడంలో ఇది సహాయపడుతుందో చూద్దాం.
✅ క్లస్టరింగ్ ఉపయోగాల గురించి ఒక నిమిషం ఆలోచించండి. వాస్తవ జీవితంలో, మీరు ఒక బట్టల గుంపు ఉన్నప్పుడు మరియు మీ కుటుంబ సభ్యుల బట్టలను వర్గీకరించాల్సినప్పుడు క్లస్టరింగ్ జరుగుతుంది 🧦👕👖🩲. డేటా సైన్స్‌లో, క్లస్టరింగ్ ఒక వినియోగదారుడి అభిరుచులను విశ్లేషించేటప్పుడు లేదా ఏదైనా లేబుల్ చేయబడని డేటాసెట్ లక్షణాలను నిర్ణయించేటప్పుడు జరుగుతుంది. క్లస్టరింగ్, ఒక విధంగా, గందరగోళాన్ని అర్థం చేసుకోవడంలో సహాయపడుతుంది, ఒక మోజు డ్రాయర్ లాగా.
[![Introduction to ML](https://img.youtube.com/vi/esmzYhuFnds/0.jpg)](https://youtu.be/esmzYhuFnds "Introduction to Clustering")
> 🎥 పై చిత్రాన్ని క్లిక్ చేయండి వీడియో కోసం: MIT యొక్క జాన్ గుట్‌టాగ్ క్లస్టరింగ్‌ను పరిచయం చేస్తారు
వృత్తిపరమైన పరిసరాల్లో, క్లస్టరింగ్ మార్కెట్ విభజన, వయస్సు గుంపులు ఏ వస్తువులు కొనుగోలు చేస్తాయో నిర్ణయించడం వంటి విషయాలను నిర్ణయించడానికి ఉపయోగించవచ్చు. మరో ఉపయోగం అనామలీ గుర్తింపు, ఉదాహరణకు క్రెడిట్ కార్డ్ లావాదేవీల డేటాసెట్ నుండి మోసం గుర్తించడానికి. లేదా మీరు క్లస్టరింగ్‌ను వైద్య స్కాన్ల బ్యాచ్‌లో ట్యూమర్లను గుర్తించడానికి ఉపయోగించవచ్చు.
✅ బ్యాంకింగ్, ఈ-కామర్స్ లేదా వ్యాపార పరిసరాల్లో మీరు క్లస్టరింగ్‌ను 'వనంలో' ఎలా ఎదుర్కొన్నారో ఒక నిమిషం ఆలోచించండి.
> 🎓 ఆసక్తికరంగా, క్లస్టర్ విశ్లేషణ 1930లలో మానవ శాస్త్రం మరియు మానసిక శాస్త్రం రంగాలలో ప్రారంభమైంది. మీరు దీన్ని ఎలా ఉపయోగించారో ఊహించగలరా?
వేరే విధంగా, మీరు శోధన ఫలితాలను వర్గీకరించడానికి ఉపయోగించవచ్చు - ఉదాహరణకు షాపింగ్ లింకులు, చిత్రాలు లేదా సమీక్షల ద్వారా. క్లస్టరింగ్ పెద్ద డేటాసెట్ ఉన్నప్పుడు మరియు మీరు దానిని తగ్గించి మరింత సూక్ష్మ విశ్లేషణ చేయాలనుకుంటే ఉపయోగకరం, కాబట్టి ఈ సాంకేతికతను ఇతర మోడల్స్ నిర్మించకముందు డేటా గురించి తెలుసుకోవడానికి ఉపయోగించవచ్చు.
✅ ఒకసారి మీ డేటా క్లస్టర్లలో సక్రమంగా ఏర్పాటు చేసిన తర్వాత, మీరు దానికి క్లస్టర్ ID కేటాయిస్తారు, మరియు ఈ సాంకేతికత డేటాసెట్ గోప్యతను కాపాడటంలో ఉపయోగకరంగా ఉంటుంది; మీరు డేటా పాయింట్‌ను మరింత వెల్లడించే గుర్తింపు డేటా ద్వారా కాకుండా దాని క్లస్టర్ ID ద్వారా సూచించవచ్చు. మీరు మరే ఇతర కారణాలు గుర్తించగలరా ఎందుకు మీరు క్లస్టర్ ID ద్వారా దానిని గుర్తించాలనుకుంటారు?
ఈ [Learn module](https://docs.microsoft.com/learn/modules/train-evaluate-cluster-models?WT.mc_id=academic-77952-leestott) లో క్లస్టరింగ్ సాంకేతికతలపై మీ అవగాహనను లోతుగా చేసుకోండి
## క్లస్టరింగ్ ప్రారంభం
[Scikit-learn పెద్ద శ్రేణి](https://scikit-learn.org/stable/modules/clustering.html) పద్ధతులను క్లస్టరింగ్ కోసం అందిస్తుంది. మీరు ఎంచుకునే రకం మీ ఉపయోగ కేసుపై ఆధారపడి ఉంటుంది. డాక్యుమెంటేషన్ ప్రకారం, ప్రతి పద్ధతికి వివిధ లాభాలు ఉన్నాయి. ఇక్కడ Scikit-learn మద్దతు ఇచ్చే పద్ధతులు మరియు వాటి సరైన ఉపయోగాల సరళమైన పట్టిక ఉంది:
| పద్ధతి పేరు | ఉపయోగం |
| :--------------------------- | :--------------------------------------------------------------------- |
| K-Means | సాధారణ ప్రయోజనం, సూచనాత్మక |
| Affinity propagation | చాలా, అసమాన క్లస్టర్లు, సూచనాత్మక |
| Mean-shift | చాలా, అసమాన క్లస్టర్లు, సూచనాత్మక |
| Spectral clustering | కొద్దిగా, సమాన క్లస్టర్లు, ప్రత్యక్షాత్మక |
| Ward hierarchical clustering | చాలా, పరిమిత క్లస్టర్లు, ప్రత్యక్షాత్మక |
| Agglomerative clustering | చాలా, పరిమిత, నాన్ యూక్లిడియన్ దూరాలు, ప్రత్యక్షాత్మక |
| DBSCAN | నాన్-ఫ్లాట్ జ్యామితి, అసమాన క్లస్టర్లు, ప్రత్యక్షాత్మక |
| OPTICS | నాన్-ఫ్లాట్ జ్యామితి, మార్పిడి సాంద్రతతో అసమాన క్లస్టర్లు, ప్రత్యక్షాత్మక |
| Gaussian mixtures | ఫ్లాట్ జ్యామితి, సూచనాత్మక |
| BIRCH | పెద్ద డేటాసెట్ అవుట్లయర్స్‌తో, సూచనాత్మక |
> 🎓 మనం క్లస్టర్లు ఎలా సృష్టిస్తామో అనేది డేటా పాయింట్లను సమూహాలుగా ఎలా సేకరిస్తామో చాలా సంబంధం కలిగి ఉంటుంది. కొన్ని పదజాలాన్ని వివరించుకుందాం:
>
> 🎓 ['ప్రత్యక్షాత్మక' vs. 'సూచనాత్మక'](https://wikipedia.org/wiki/Transduction_(machine_learning))
>
> ప్రత్యక్షాత్మక నిర్ధారణ అనేది నిర్దిష్ట పరీక్ష కేసులకు మ్యాప్ అయ్యే పరిశీలించిన శిక్షణ కేసుల నుండి ఉత్పన్నమవుతుంది. సూచనాత్మక నిర్ధారణ సాధారణ నియమాలకు మ్యాప్ అయ్యే శిక్షణ కేసుల నుండి ఉత్పన్నమవుతుంది, అవి తరువాత మాత్రమే పరీక్ష కేసులకు వర్తింపజేయబడతాయి.
>
> ఉదాహరణ: మీ దగ్గర ఒక డేటాసెట్ భాగంగా మాత్రమే లేబుల్ చేయబడింది అని ఊహించండి. కొన్ని వస్తువులు 'రికార్డులు', కొన్ని 'సీడీలు', మరియు కొన్ని ఖాళీగా ఉన్నాయి. ఖాళీలకు లేబుళ్లు ఇవ్వడం మీ పని. మీరు సూచనాత్మక దృష్టికోణాన్ని ఎంచుకుంటే, మీరు 'రికార్డులు' మరియు 'సీడీలు' కోసం మోడల్ శిక్షణ ఇస్తారు, మరియు ఆ లేబుళ్లను లేబుల్ చేయబడని డేటాకు వర్తింపజేస్తారు. ఈ దృష్టికోణం వాస్తవానికి 'కాసెట్‌లు' అయిన వస్తువులను వర్గీకరించడంలో ఇబ్బంది పడుతుంది. ప్రత్యక్షాత్మక దృష్టికోణం, మరోవైపు, ఈ తెలియని డేటాను సమర్థవంతంగా నిర్వహిస్తుంది, ఇది సమాన వస్తువులను సమూహాలుగా కూర్చి, ఆ సమూహానికి లేబుల్ వర్తింపజేస్తుంది. ఈ సందర్భంలో, క్లస్టర్లు 'వృత్తాకార సంగీత వస్తువులు' మరియు 'చతురస్ర సంగీత వస్తువులు'ని ప్రతిబింబించవచ్చు.
>
> 🎓 ['నాన్-ఫ్లాట్' vs. 'ఫ్లాట్' జ్యామితి](https://datascience.stackexchange.com/questions/52260/terminology-flat-geometry-in-the-context-of-clustering)
>
> గణిత శాస్త్ర పదజాలం నుండి ఉద్భవించిన, నాన్-ఫ్లాట్ vs. ఫ్లాట్ జ్యామితి అనేది పాయింట్ల మధ్య దూరాలను 'ఫ్లాట్' ([యూక్లిడియన్](https://wikipedia.org/wiki/Euclidean_geometry)) లేదా 'నాన్-ఫ్లాట్' (నాన్-యూక్లిడియన్) జ్యామితి పద్ధతుల ద్వారా కొలవడాన్ని సూచిస్తుంది.
>
>'ఫ్లాట్' ఈ సందర్భంలో యూక్లిడియన్ జ్యామితిని సూచిస్తుంది (దాని భాగాలు 'ప్లేన్' జ్యామితిగా బోధించబడతాయి), మరియు నాన్-ఫ్లాట్ అనేది నాన్-యూక్లిడియన్ జ్యామితి. జ్యామితి మెషీన్ లెర్నింగ్‌కు ఏమి సంబంధం? గణితంలో ఆధారపడిన రెండు రంగాలుగా, క్లస్టర్లలో పాయింట్ల మధ్య దూరాలను కొలవడానికి సాధారణ మార్గం ఉండాలి, అది 'ఫ్లాట్' లేదా 'నాన్-ఫ్లాట్' విధంగా చేయవచ్చు, డేటా స్వభావం ఆధారంగా. [యూక్లిడియన్ దూరాలు](https://wikipedia.org/wiki/Euclidean_distance) రెండు పాయింట్ల మధ్య రేఖా భాగం పొడవుగా కొలవబడతాయి. [నాన్-యూక్లిడియన్ దూరాలు](https://wikipedia.org/wiki/Non-Euclidean_geometry) వక్రరేఖపై కొలవబడతాయి. మీ డేటా, దృశ్యరూపంలో, ఒక సమతలంపై లేనట్టుగా కనిపిస్తే, మీరు దానిని నిర్వహించడానికి ప్రత్యేక అల్గోరిథం అవసరం కావచ్చు.
>
![ఫ్లాట్ vs నాన్-ఫ్లాట్ జ్యామితి ఇన్ఫోగ్రాఫిక్](../../../../translated_images/flat-nonflat.d1c8c6e2a96110c1d57fa0b72913f6aab3c245478524d25baf7f4a18efcde224.te.png)
> ఇన్ఫోగ్రాఫిక్ [దాసాని మడిపల్లి](https://twitter.com/dasani_decoded) ద్వారా
>
> 🎓 ['దూరాలు'](https://web.stanford.edu/class/cs345a/slides/12-clustering.pdf)
>
> క్లస్టర్లు వాటి దూర మ్యాట్రిక్స్ ద్వారా నిర్వచించబడతాయి, ఉదా: పాయింట్ల మధ్య దూరాలు. ఈ దూరం కొన్ని మార్గాల్లో కొలవబడవచ్చు. యూక్లిడియన్ క్లస్టర్లు పాయింట్ విలువల సగటు ద్వారా నిర్వచించబడతాయి, మరియు 'సెంట్రాయిడ్' లేదా కేంద్ర పాయింట్ కలిగి ఉంటాయి. దూరాలు ఆ సెంట్రాయిడ్ దూరం ద్వారా కొలవబడతాయి. నాన్-యూక్లిడియన్ దూరాలు 'క్లస్ట్రాయిడ్స్'ను సూచిస్తాయి, అంటే ఇతర పాయింట్లకు అత్యంత సమీపమైన పాయింట్. క్లస్ట్రాయిడ్స్ వివిధ రకాలుగా నిర్వచించబడవచ్చు.
>
> 🎓 ['పరిమిత'](https://wikipedia.org/wiki/Constrained_clustering)
>
> [పరిమిత క్లస్టరింగ్](https://web.cs.ucdavis.edu/~davidson/Publications/ICDMTutorial.pdf) ఈ అనియంత్రిత పద్ధతిలో 'సెమీ-సూపర్వైజ్డ్' అభ్యాసాన్ని పరిచయం చేస్తుంది. పాయింట్ల మధ్య సంబంధాలు 'లింక్ చేయకూడదు' లేదా 'లింక్ చేయాలి' అని గుర్తించబడతాయి కాబట్టి కొన్ని నియమాలు డేటాసెట్‌పై బలవంతంగా అమలవుతాయి.
>
>ఉదాహరణ: ఒక అల్గోరిథం లేబుల్ చేయబడని లేదా సెమీ-లేబుల్ చేయబడిన డేటా బ్యాచ్‌పై స్వేచ్ఛగా అమలవుతే, అది ఉత్పత్తి చేసే క్లస్టర్లు తక్కువ నాణ్యత కలిగి ఉండవచ్చు. పై ఉదాహరణలో, క్లస్టర్లు 'వృత్తాకార సంగీత వస్తువులు', 'చతురస్ర సంగీత వస్తువులు', 'త్రిభుజాకార వస్తువులు' మరియు 'కుకీలు'గా వర్గీకరించవచ్చు. కొన్ని పరిమితులు లేదా నియమాలు ("వస్తువు ప్లాస్టిక్‌తో తయారవాలి", "వస్తువు సంగీతం ఉత్పత్తి చేయగలగాలి") ఇవ్వబడితే, ఇది అల్గోరిథం మెరుగైన ఎంపికలు చేయడానికి సహాయపడుతుంది.
>
> 🎓 'సాంద్రత'
>
> 'శబ్దం' ఉన్న డేటాను 'సాంద్రంగా' పరిగణిస్తారు. దాని ప్రతి క్లస్టర్‌లో పాయింట్ల మధ్య దూరాలు పరిశీలనలో ఎక్కువ లేదా తక్కువ సాంద్రత లేదా 'గొడవ'గా ఉండవచ్చు, కాబట్టి ఈ డేటాను సరైన క్లస్టరింగ్ పద్ధతితో విశ్లేషించాలి. [ఈ వ్యాసం](https://www.kdnuggets.com/2020/02/understanding-density-based-clustering.html) K-Means క్లస్టరింగ్ మరియు HDBSCAN అల్గోరిథమ్లను ఉపయోగించి అసమాన క్లస్టర్ సాంద్రతతో శబ్దం ఉన్న డేటాసెట్‌ను అన్వేషించడంలో తేడాను చూపిస్తుంది.
## క్లస్టరింగ్ అల్గోరిథమ్లు
100కి పైగా క్లస్టరింగ్ అల్గోరిథమ్లు ఉన్నాయి, మరియు వాటి ఉపయోగం డేటా స్వభావంపై ఆధారపడి ఉంటుంది. కొన్ని ప్రధానమైన వాటిని చర్చిద్దాం:
- **హైరార్కికల్ క్లస్టరింగ్**. ఒక వస్తువు దాని సమీప వస్తువుతో సమీపత ఆధారంగా వర్గీకరించబడితే, దూరం ఆధారంగా క్లస్టర్లు ఏర్పడతాయి. Scikit-learn యొక్క అగ్లోమెరేటివ్ క్లస్టరింగ్ హైరార్కికల్.
![హైరార్కికల్ క్లస్టరింగ్ ఇన్ఫోగ్రాఫిక్](../../../../translated_images/hierarchical.bf59403aa43c8c47493bfdf1cc25230f26e45f4e38a3d62e8769cd324129ac15.te.png)
> ఇన్ఫోగ్రాఫిక్ [దాసాని మడిపల్లి](https://twitter.com/dasani_decoded) ద్వారా
- **సెంట్రాయిడ్ క్లస్టరింగ్**. ఈ ప్రాచుర్యం పొందిన అల్గోరిథం 'k' లేదా ఏర్పరచాల్సిన క్లస్టర్ల సంఖ్యను ఎంచుకోవాలి, ఆ తర్వాత అల్గోరిథం క్లస్టర్ కేంద్ర పాయింట్‌ను నిర్ణయించి ఆ పాయింట్ చుట్టూ డేటాను సేకరిస్తుంది. [K-means క్లస్టరింగ్](https://wikipedia.org/wiki/K-means_clustering) సెంట్రాయిడ్ క్లస్టరింగ్ యొక్క ప్రాచుర్యం పొందిన వెర్షన్. కేంద్రం సమీప సగటు ద్వారా నిర్ణయించబడుతుంది, అందుకే పేరు. క్లస్టర్ నుండి చతురస్ర దూరం తగ్గించబడుతుంది.
![సెంట్రాయిడ్ క్లస్టరింగ్ ఇన్ఫోగ్రాఫిక్](../../../../translated_images/centroid.097fde836cf6c9187d0b2033e9f94441829f9d86f4f0b1604dd4b3d1931aee34.te.png)
> ఇన్ఫోగ్రాఫిక్ [దాసాని మడిపల్లి](https://twitter.com/dasani_decoded) ద్వారా
- **వితరణ ఆధారిత క్లస్టరింగ్**. గణాంక నమూనాలపై ఆధారపడి, వితరణ ఆధారిత క్లస్టరింగ్ ఒక డేటా పాయింట్ ఒక క్లస్టర్‌కు చెందే సంభావ్యతను నిర్ణయించి, దానికి అనుగుణంగా కేటాయిస్తుంది. గౌసియన్ మిశ్రమ పద్ధతులు ఈ రకానికి చెందుతాయి.
- **సాంద్రత ఆధారిత క్లస్టరింగ్**. డేటా పాయింట్లు వారి సాంద్రత లేదా ఒకరితో ఒకరు సమూహంగా ఉండటం ఆధారంగా క్లస్టర్లకు కేటాయించబడతాయి. సమూహం నుండి దూరంగా ఉన్న డేటా పాయింట్లు అవుట్లయర్స్ లేదా శబ్దంగా పరిగణించబడతాయి. DBSCAN, Mean-shift మరియు OPTICS ఈ రకమైన క్లస్టరింగ్‌కు చెందుతాయి.
- **గ్రిడ్ ఆధారిత క్లస్టరింగ్**. బహుమాణ డేటాసెట్‌ల కోసం, ఒక గ్రిడ్ సృష్టించి డేటాను గ్రిడ్ సెల్‌ల మధ్య విభజించి క్లస్టర్లు సృష్టిస్తారు.
## వ్యాయామం - మీ డేటాను క్లస్టర్ చేయండి
క్లస్టరింగ్ సాంకేతికత సరైన దృశ్యీకరణతో చాలా సహాయపడుతుంది, కాబట్టి మన సంగీత డేటాను దృశ్యీకరించడం ప్రారంభిద్దాం. ఈ వ్యాయామం మనకు ఈ డేటా స్వభావానికి ఏ క్లస్టరింగ్ పద్ధతిని సమర్థవంతంగా ఉపయోగించాలో నిర్ణయించడంలో సహాయపడుతుంది.
1. ఈ ఫోల్డర్‌లోని [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/1-Visualize/notebook.ipynb) ఫైల్‌ను తెరవండి.
1. మంచి డేటా దృశ్యీకరణ కోసం `Seaborn` ప్యాకేజీని దిగుమతి చేసుకోండి.
```python
!pip install seaborn
```
1. [_nigerian-songs.csv_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/data/nigerian-songs.csv) నుండి పాటల డేటాను జోడించండి. పాటల గురించి కొంత డేటాతో డేటాఫ్రేమ్‌ను లోడ్ చేయండి. లైబ్రరీలను దిగుమతి చేసుకుని డేటాను ప్రదర్శించడానికి సిద్ధంగా ఉండండి:
```python
import matplotlib.pyplot as plt
import pandas as pd
df = pd.read_csv("../data/nigerian-songs.csv")
df.head()
```
మొదటి కొన్ని లైన్ల డేటాను తనిఖీ చేయండి:
| | name | album | artist | artist_top_genre | release_date | length | popularity | danceability | acousticness | energy | instrumentalness | liveness | loudness | speechiness | tempo | time_signature |
| --- | ------------------------ | ---------------------------- | ------------------- | ---------------- | ------------ | ------ | ---------- | ------------ | ------------ | ------ | ---------------- | -------- | -------- | ----------- | ------- | -------------- |
| 0 | Sparky | Mandy & The Jungle | Cruel Santino | alternative r&b | 2019 | 144000 | 48 | 0.666 | 0.851 | 0.42 | 0.534 | 0.11 | -6.699 | 0.0829 | 133.015 | 5 |
| 1 | shuga rush | EVERYTHING YOU HEARD IS TRUE | Odunsi (The Engine) | afropop | 2020 | 89488 | 30 | 0.71 | 0.0822 | 0.683 | 0.000169 | 0.101 | -5.64 | 0.36 | 129.993 | 3 |
| 2 | LITT! | LITT! | AYLØ | ఇండీ ఆర్&బి | 2018 | 207758 | 40 | 0.836 | 0.272 | 0.564 | 0.000537 | 0.11 | -7.127 | 0.0424 | 130.005 | 4 |
| 3 | Confident / Feeling Cool | Enjoy Your Life | Lady Donli | నైజీరియన్ పాప్ | 2019 | 175135 | 14 | 0.894 | 0.798 | 0.611 | 0.000187 | 0.0964 | -4.961 | 0.113 | 111.087 | 4 |
| 4 | wanted you | rare. | Odunsi (The Engine) | ఆఫ్రోపాప్ | 2018 | 152049 | 25 | 0.702 | 0.116 | 0.833 | 0.91 | 0.348 | -6.044 | 0.0447 | 105.115 | 4 |
1. డేటాఫ్రేమ్ గురించి కొంత సమాచారం పొందండి, `info()` ను పిలవండి:
```python
df.info()
```
అవుట్పుట్ ఇలా ఉంటుంది:
```output
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 530 entries, 0 to 529
Data columns (total 16 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 name 530 non-null object
1 album 530 non-null object
2 artist 530 non-null object
3 artist_top_genre 530 non-null object
4 release_date 530 non-null int64
5 length 530 non-null int64
6 popularity 530 non-null int64
7 danceability 530 non-null float64
8 acousticness 530 non-null float64
9 energy 530 non-null float64
10 instrumentalness 530 non-null float64
11 liveness 530 non-null float64
12 loudness 530 non-null float64
13 speechiness 530 non-null float64
14 tempo 530 non-null float64
15 time_signature 530 non-null int64
dtypes: float64(8), int64(4), object(4)
memory usage: 66.4+ KB
```
1. నల్ విలువల కోసం డబుల్-చెక్ చేయండి, `isnull()` ను పిలవడం ద్వారా మరియు మొత్తం 0 అని నిర్ధారించండి:
```python
df.isnull().sum()
```
బాగుంది:
```output
name 0
album 0
artist 0
artist_top_genre 0
release_date 0
length 0
popularity 0
danceability 0
acousticness 0
energy 0
instrumentalness 0
liveness 0
loudness 0
speechiness 0
tempo 0
time_signature 0
dtype: int64
```
1. డేటాను వివరించండి:
```python
df.describe()
```
| | విడుదల తేదీ | పొడవు | ప్రాచుర్యం | డ్యాన్సబిలిటీ | అకౌస్టిక్‌నెస్ | ఎనర్జీ | ఇన్‌స్ట్రుమెంటల్‌నెస్ | లైవ్‌నెస్ | లౌడ్నెస్ | స్పీచినెస్ | టెంపో | టైమ్ సిగ్నేచర్ |
| ----- | ------------ | ----------- | ---------- | ------------ | ------------ | -------- | ---------------- | -------- | --------- | ----------- | ---------- | -------------- |
| కౌంట్ | 530 | 530 | 530 | 530 | 530 | 530 | 530 | 530 | 530 | 530 | 530 | 530 |
| సగటు | 2015.390566 | 222298.1698 | 17.507547 | 0.741619 | 0.265412 | 0.760623 | 0.016305 | 0.147308 | -4.953011 | 0.130748 | 116.487864 | 3.986792 |
| స్టాండర్డ్ డెవియేషన్ | 3.131688 | 39696.82226 | 18.992212 | 0.117522 | 0.208342 | 0.148533 | 0.090321 | 0.123588 | 2.464186 | 0.092939 | 23.518601 | 0.333701 |
| కనిష్ఠం | 1998 | 89488 | 0 | 0.255 | 0.000665 | 0.111 | 0 | 0.0283 | -19.362 | 0.0278 | 61.695 | 3 |
| 25% | 2014 | 199305 | 0 | 0.681 | 0.089525 | 0.669 | 0 | 0.07565 | -6.29875 | 0.0591 | 102.96125 | 4 |
| 50% | 2016 | 218509 | 13 | 0.761 | 0.2205 | 0.7845 | 0.000004 | 0.1035 | -4.5585 | 0.09795 | 112.7145 | 4 |
| 75% | 2017 | 242098.5 | 31 | 0.8295 | 0.403 | 0.87575 | 0.000234 | 0.164 | -3.331 | 0.177 | 125.03925 | 4 |
| గరిష్ఠం | 2020 | 511738 | 73 | 0.966 | 0.954 | 0.995 | 0.91 | 0.811 | 0.582 | 0.514 | 206.007 | 5 |
> 🤔 మనం క్లస్టరింగ్‌తో పని చేస్తున్నప్పుడు, లేబుల్డ్ డేటా అవసరం లేని ఒక అన్‌సూపర్వైజ్డ్ పద్ధతి, ఎందుకు ఈ డేటాను లేబుల్స్‌తో చూపిస్తున్నాం? డేటా అన్వేషణ దశలో అవి ఉపయోగకరంగా ఉంటాయి, కానీ క్లస్టరింగ్ అల్గోరిథమ్స్ పనిచేయడానికి అవి అవసరం కాదు. మీరు కాలమ్ హెడ్డర్లను తీసేసి కాలమ్ నంబర్ ద్వారా డేటాను సూచించవచ్చు.
డేటా యొక్క సాధారణ విలువలను చూడండి. ప్రాచుర్యం '0' కావచ్చు, అంటే ర్యాంకింగ్ లేని పాటలు. వాటిని త్వరలో తీసివేద్దాం.
1. అత్యంత ప్రాచుర్యం ఉన్న జానర్లను కనుగొనడానికి బార్ప్లాట్ ఉపయోగించండి:
```python
import seaborn as sns
top = df['artist_top_genre'].value_counts()
plt.figure(figsize=(10,7))
sns.barplot(x=top[:5].index,y=top[:5].values)
plt.xticks(rotation=45)
plt.title('Top genres',color = 'blue')
```
![most popular](../../../../translated_images/popular.9c48d84b3386705f98bf44e26e9655bee9eb7c849d73be65195e37895bfedb5d.te.png)
✅ మీరు ఎక్కువ టాప్ విలువలు చూడాలనుకుంటే, టాప్ `[:5]` ను పెద్ద విలువగా మార్చండి లేదా అన్ని చూడటానికి తీసివేయండి.
గమనించండి, టాప్ జానర్ 'Missing' గా ఉంటే, అంటే Spotify దాన్ని వర్గీకరించలేదు, కాబట్టి దాన్ని తీసివేయండి.
1. మిస్సింగ్ డేటాను ఫిల్టర్ చేసి తీసివేయండి
```python
df = df[df['artist_top_genre'] != 'Missing']
top = df['artist_top_genre'].value_counts()
plt.figure(figsize=(10,7))
sns.barplot(x=top.index,y=top.values)
plt.xticks(rotation=45)
plt.title('Top genres',color = 'blue')
```
ఇప్పుడు జానర్లను మళ్లీ తనిఖీ చేయండి:
![most popular](../../../../translated_images/all-genres.1d56ef06cefbfcd61183023834ed3cb891a5ee638a3ba5c924b3151bf80208d7.te.png)
1. ఇప్పటి వరకు, టాప్ మూడు జానర్లు ఈ డేటాసెట్‌ను ఆధిపత్యం చేస్తాయి. `afro dancehall`, `afropop`, మరియు `nigerian pop` పై దృష్టి పెట్టండి, అదనంగా 0 ప్రాచుర్యం విలువ ఉన్న ఏదైనా డేటాను తీసివేయండి (అంటే డేటాసెట్‌లో ప్రాచుర్యం తో వర్గీకరించబడలేదు మరియు మన ప్రయోజనాలకు శబ్దం గా పరిగణించవచ్చు):
```python
df = df[(df['artist_top_genre'] == 'afro dancehall') | (df['artist_top_genre'] == 'afropop') | (df['artist_top_genre'] == 'nigerian pop')]
df = df[(df['popularity'] > 0)]
top = df['artist_top_genre'].value_counts()
plt.figure(figsize=(10,7))
sns.barplot(x=top.index,y=top.values)
plt.xticks(rotation=45)
plt.title('Top genres',color = 'blue')
```
1. డేటా ఏదైనా బలమైన సంబంధం కలిగి ఉందా అని త్వరిత పరీక్ష చేయండి:
```python
corrmat = df.corr(numeric_only=True)
f, ax = plt.subplots(figsize=(12, 9))
sns.heatmap(corrmat, vmax=.8, square=True)
```
![correlations](../../../../translated_images/correlation.a9356bb798f5eea51f47185968e1ebac5c078c92fce9931e28ccf0d7fab71c2b.te.png)
ఒకే బలమైన సంబంధం `energy` మరియు `loudness` మధ్య ఉంది, ఇది ఆశ్చర్యకరం కాదు, ఎందుకంటే శబ్దమైన సంగీతం సాధారణంగా చాలా శక్తివంతంగా ఉంటుంది. మిగతా సంబంధాలు తక్కువ బలంగా ఉన్నాయి. ఈ డేటాను క్లస్టరింగ్ అల్గోరిథం ఎలా ఉపయోగిస్తుందో చూడటం ఆసక్తికరం.
> 🎓 సంబంధం కారణాన్ని సూచించదు! మనకు సంబంధం ఉన్నదని సాక్ష్యం ఉంది కానీ కారణం ఉన్నదని లేదు. ఒక [వినోదాత్మక వెబ్ సైట్](https://tylervigen.com/spurious-correlations) ఈ విషయాన్ని హైలైట్ చేస్తుంది.
ఈ డేటాసెట్‌లో పాట యొక్క భావిత ప్రాచుర్యం మరియు డ్యాన్సబిలిటీ మధ్య ఏదైనా సమీకరణ ఉందా? ఒక FacetGrid చూపిస్తుంది, జానర్‌ను పక్కన పెట్టినా, సెంట్రిక్ సర్కిల్స్ సరిపోతున్నాయి. నైజీరియన్ రుచులు ఈ జానర్ కోసం ఒక నిర్దిష్ట డ్యాన్సబిలిటీ స్థాయిలో సమీకరించవచ్చా?
✅ వేరే డేటాపాయింట్లు (energy, loudness, speechiness) మరియు మరిన్ని లేదా వేరే సంగీత జానర్లను ప్రయత్నించండి. మీరు ఏమి కనుగొంటారు? `df.describe()` పట్టికను చూడండి డేటా పాయింట్ల సాధారణ వ్యాప్తిని తెలుసుకోవడానికి.
### వ్యాయామం - డేటా పంపిణీ
ఈ మూడు జానర్లు వారి డ్యాన్సబిలిటీ భావనలో ప్రాచుర్యం ఆధారంగా గణనీయంగా భిన్నమా?
1. మన టాప్ మూడు జానర్ల డేటా పంపిణీని ప్రాచుర్యం మరియు డ్యాన్సబిలిటీ కోసం ఒక నిర్దిష్ట x మరియు y అక్షాలపై పరిశీలించండి.
```python
sns.set_theme(style="ticks")
g = sns.jointplot(
data=df,
x="popularity", y="danceability", hue="artist_top_genre",
kind="kde",
)
```
మీరు సెంట్రిక్ సర్కిల్స్ కనుగొనవచ్చు, ఒక సాధారణ సమీకరణ పాయింట్ చుట్టూ, పాయింట్ల పంపిణీని చూపిస్తూ.
> 🎓 ఈ ఉదాహరణలో KDE (కర్నెల్ డెన్సిటీ ఎస్టిమేట్) గ్రాఫ్ ఉపయోగించబడింది, ఇది డేటాను నిరంతర ప్రాబబిలిటీ డెన్సిటీ వక్రంగా ప్రదర్శిస్తుంది. ఇది బహుళ పంపిణీలతో పని చేసే సమయంలో డేటాను అర్థం చేసుకోవడానికి సహాయపడుతుంది.
సాధారణంగా, ఈ మూడు జానర్లు వారి ప్రాచుర్యం మరియు డ్యాన్సబిలిటీ పరంగా సడలిన సరిపోలికలో ఉంటాయి. ఈ సడలిన సరిపోలిక డేటాలో క్లస్టర్లను నిర్ణయించడం ఒక సవాలు:
![distribution](../../../../translated_images/distribution.9be11df42356ca958dc8e06e87865e09d77cab78f94fe4fea8a1e6796c64dc4b.te.png)
1. ఒక స్కాటర్ ప్లాట్ సృష్టించండి:
```python
sns.FacetGrid(df, hue="artist_top_genre", height=5) \
.map(plt.scatter, "popularity", "danceability") \
.add_legend()
```
అదే అక్షాల స్కాటర్‌ప్లాట్ ఒక సమానమైన సమీకరణ నమూనాను చూపిస్తుంది
![Facetgrid](../../../../translated_images/facetgrid.9b2e65ce707eba1f983b7cdfed5d952e60f385947afa3011df6e3cc7d200eb5b.te.png)
సాధారణంగా, క్లస్టరింగ్ కోసం, మీరు డేటా క్లస్టర్లను చూపించడానికి స్కాటర్‌ప్లాట్లను ఉపయోగించవచ్చు, కాబట్టి ఈ రకమైన విజువలైజేషన్‌ను నేర్చుకోవడం చాలా ఉపయోగకరం. తదుపరి పాఠంలో, మనం ఈ ఫిల్టర్ చేసిన డేటాను తీసుకుని k-means క్లస్టరింగ్ ఉపయోగించి ఈ డేటాలో ఆసక్తికరమైన రీతిలో ఓవర్‌ల్యాప్ అయ్యే గ్రూపులను కనుగొంటాము.
---
## 🚀సవాలు
తదుపరి పాఠానికి సిద్ధంగా, మీరు కనుగొనగల మరియు ఉత్పత్తి వాతావరణంలో ఉపయోగించగల వివిధ క్లస్టరింగ్ అల్గోరిథమ్స్ గురించి ఒక చార్ట్ తయారుచేయండి. క్లస్టరింగ్ ఏ రకాల సమస్యలను పరిష్కరించడానికి ప్రయత్నిస్తోంది?
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
క్లస్టరింగ్ అల్గోరిథమ్స్‌ను వర్తింపజేసే ముందు, మనం నేర్చుకున్నట్లుగా, మీ డేటాసెట్ స్వభావాన్ని అర్థం చేసుకోవడం మంచిది. ఈ విషయంపై మరింత చదవండి [ఇక్కడ](https://www.kdnuggets.com/2019/10/right-clustering-algorithm.html)
[ఈ సహాయక వ్యాసం](https://www.freecodecamp.org/news/8-clustering-algorithms-in-machine-learning-that-all-data-scientists-should-know/) వివిధ డేటా ఆకారాలపై వివిధ క్లస్టరింగ్ అల్గోరిథమ్స్ ఎలా ప్రవర్తిస్తాయో మీకు చూపిస్తుంది.
## అసైన్‌మెంట్
[క్లస్టరింగ్ కోసం ఇతర విజువలైజేషన్లపై పరిశోధన చేయండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/5-Clustering/1-Visualize/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "589fa015a5e7d9e67bd629f7d47b53de",
"translation_date": "2025-12-19T15:04:32+00:00",
"source_file": "5-Clustering/1-Visualize/assignment.md",
"language_code": "te"
}
-->
# క్లస్టరింగ్ కోసం ఇతర విజువలైజేషన్లపై పరిశోధన
## సూచనలు
ఈ పాఠంలో, మీరు క్లస్టరింగ్‌కు సిద్ధం చేసుకునేందుకు మీ డేటాను ప్లాట్ చేయడంలో సహాయపడే కొన్ని విజువలైజేషన్ సాంకేతికతలతో పని చేశారు. ప్రత్యేకంగా, స్కాటర్‌ప్లాట్లు వస్తువుల సమూహాలను కనుగొనడంలో ఉపయోగకరంగా ఉంటాయి. స్కాటర్‌ప్లాట్లు సృష్టించడానికి వివిధ మార్గాలు మరియు వివిధ లైబ్రరీలను పరిశోధించి, మీ పని ఒక నోట్బుక్‌లో డాక్యుమెంట్ చేయండి. మీరు ఈ పాఠం నుండి, ఇతర పాఠాల నుండి లేదా మీరు స్వయంగా పొందిన డేటాను ఉపయోగించవచ్చు (అయితే దాని మూలాన్ని మీ నోట్బుక్‌లో క్రెడిట్ చేయండి). స్కాటర్‌ప్లాట్లను ఉపయోగించి కొంత డేటాను ప్లాట్ చేసి, మీరు కనుగొన్న విషయాలను వివరించండి.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | -------------------------------------------------------------- | ---------------------------------------------------------------------------------------- | ----------------------------------- |
| | ఐదు బాగా డాక్యుమెంట్ చేయబడిన స్కాటర్‌ప్లాట్లతో కూడిన నోట్బుక్ అందించబడింది | ఐదు కన్నా తక్కువ స్కాటర్‌ప్లాట్లతో కూడిన మరియు తక్కువగా డాక్యుమెంట్ చేయబడిన నోట్బుక్ అందించబడింది | అసంపూర్ణమైన నోట్బుక్ అందించబడింది |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

52
translations/te/5-Clustering/1-Visualize/notebook.ipynb
Unescape View File

@ -0,0 +1,52 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3"
},
"orig_nbformat": 2,
"kernelspec": {
"name": "python383jvsc74a57bd0e134e05457d34029b6460cd73bbf1ed73f339b5b6d98c95be70b69eba114fe95",
"display_name": "Python 3.8.3 64-bit (conda)"
},
"coopTranslator": {
"original_hash": "40e0707e96b3e1899a912776006264f9",
"translation_date": "2025-12-19T16:50:39+00:00",
"source_file": "5-Clustering/1-Visualize/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"source": [
"# స్పాటిఫై నుండి సేకరించిన నైజీరియన్ సంగీతం - ఒక విశ్లేషణ\n"
],
"cell_type": "markdown",
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

17
translations/te/5-Clustering/1-Visualize/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T15:06:00+00:00",
"source_file": "5-Clustering/1-Visualize/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

500
translations/te/5-Clustering/1-Visualize/solution/R/lesson_14-R.ipynb
Unescape View File

@ -0,0 +1,500 @@
{
"cells": [
{
"cell_type": "markdown",
"source": [
"## **స్పాటిఫై నుండి సేకరించిన నైజీరియన్ సంగీతం - ఒక విశ్లేషణ**\n",
"\n",
"క్లస్టరింగ్ అనేది [అనియంత్రిత అభ్యాసం](https://wikipedia.org/wiki/Unsupervised_learning) యొక్క ఒక రకం, ఇది ఒక డేటాసెట్ లేబుల్ చేయబడలేదు లేదా దాని ఇన్‌పుట్లు ముందుగా నిర్వచించిన అవుట్‌పుట్లతో సరిపోలడం లేదని ఊహిస్తుంది. ఇది వివిధ అల్గోరిథమ్లను ఉపయోగించి లేబుల్ చేయబడని డేటాను వర్గీకరించి, డేటాలో కనిపించే నమూనాల ప్రకారం సమూహాలను అందిస్తుంది.\n",
"\n",
"[**పూర్వ-లెక్చర్ క్విజ్**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/27/)\n",
"\n",
"### **పరిచయం**\n",
"\n",
"[క్లస్టరింగ్](https://link.springer.com/referenceworkentry/10.1007%2F978-0-387-30164-8_124) డేటా అన్వేషణకు చాలా ఉపయోగకరం. నైజీరియన్ ప్రేక్షకులు సంగీతాన్ని ఎలా వినుతారో దాని లోపల ట్రెండ్లు మరియు నమూనాలను కనుగొనడంలో ఇది సహాయపడుతుందో చూద్దాం.\n",
"\n",
"> ✅ క్లస్టరింగ్ ఉపయోగాల గురించి ఒక నిమిషం ఆలోచించండి. నిజ జీవితంలో, మీరు ఒక బట్టల గుంపు ఉన్నప్పుడు మీ కుటుంబ సభ్యుల బట్టలను వర్గీకరించాల్సినప్పుడు క్లస్టరింగ్ జరుగుతుంది 🧦👕👖🩲. డేటా సైన్స్‌లో, క్లస్టరింగ్ ఒక వినియోగదారుడి ఇష్టాలను విశ్లేషించేటప్పుడు లేదా ఏదైనా లేబుల్ చేయబడని డేటాసెట్ లక్షణాలను నిర్ణయించేటప్పుడు జరుగుతుంది. క్లస్టరింగ్ ఒక విధంగా గందరగోళాన్ని అర్థం చేసుకోవడంలో సహాయపడుతుంది, ఒక సాక్స్ డ్రాయర్ లాగా.\n",
"\n",
"వృత్తిపరమైన పరిసరాల్లో, మార్కెట్ విభజన, వయస్సు గుంపులు ఏ వస్తువులు కొనుగోలు చేస్తాయో నిర్ణయించడం వంటి విషయాలను నిర్ణయించడానికి క్లస్టరింగ్ ఉపయోగించవచ్చు. మరో ఉపయోగం అనామలీ గుర్తింపు, ఉదాహరణకు క్రెడిట్ కార్డ్ లావాదేవీల డేటాసెట్ నుండి మోసం గుర్తించడానికి. లేదా మీరు క్లస్టరింగ్‌ను వైద్య స్కాన్ల బ్యాచ్‌లో ట్యూమర్లను గుర్తించడానికి ఉపయోగించవచ్చు.\n",
"\n",
"✅ బ్యాంకింగ్, ఈ-కామర్స్ లేదా వ్యాపార పరిసరాల్లో మీరు క్లస్టరింగ్‌ను 'వనంలో' ఎలా ఎదుర్కొన్నారో ఒక నిమిషం ఆలోచించండి.\n",
"\n",
"> 🎓 ఆసక్తికరంగా, క్లస్టర్ విశ్లేషణ 1930లలో మానవ శాస్త్రం మరియు మానసిక శాస్త్రం రంగాలలో ప్రారంభమైంది. మీరు దీన్ని ఎలా ఉపయోగించారో ఊహించగలరా?\n",
"\n",
"వేరే విధంగా, మీరు శోధన ఫలితాలను వర్గీకరించడానికి ఉపయోగించవచ్చు - ఉదాహరణకు షాపింగ్ లింకులు, చిత్రాలు లేదా సమీక్షల ద్వారా. క్లస్టరింగ్ పెద్ద డేటాసెట్ ఉన్నప్పుడు దాన్ని తగ్గించడానికి మరియు మరింత సూక్ష్మ విశ్లేషణ చేయడానికి ఉపయోగపడుతుంది, కాబట్టి ఈ సాంకేతికత ఇతర మోడల్స్ నిర్మించక ముందు డేటా గురించి తెలుసుకోవడానికి ఉపయోగపడుతుంది.\n",
"\n",
"✅ ఒకసారి మీ డేటా క్లస్టర్లలో సక్రమంగా ఏర్పడిన తర్వాత, మీరు దానికి క్లస్టర్ ID కేటాయిస్తారు, మరియు ఈ సాంకేతికత డేటాసెట్ గోప్యతను కాపాడటంలో ఉపయోగపడుతుంది; మీరు ఒక డేటా పాయింట్‌ను మరింత వెల్లడించే గుర్తింపు డేటా ద్వారా కాకుండా దాని క్లస్టర్ ID ద్వారా సూచించవచ్చు. మీరు మరెన్ని కారణాలు గుర్తించగలరా, ఎందుకు మీరు క్లస్టర్ ID ద్వారా దాన్ని గుర్తించాలనుకుంటారు?\n",
"\n",
"### క్లస్టరింగ్ ప్రారంభించడం\n",
"\n",
"> 🎓 మేము క్లస్టర్లను ఎలా సృష్టిస్తామో అది డేటా పాయింట్లను సమూహాలుగా ఎలా సేకరిస్తామో చాలా సంబంధం కలిగి ఉంటుంది. కొన్ని పదజాలాలను వివరించుకుందాం:\n",
">\n",
"> 🎓 ['ట్రాన్స్‌డక్టివ్' vs. 'ఇండక్టివ్'](https://wikipedia.org/wiki/Transduction_(machine_learning))\n",
">\n",
"> ట్రాన్స్‌డక్టివ్ ఇన్ఫరెన్స్ అనేది నిర్దిష్ట పరీక్ష కేసులకు మ్యాప్ అయ్యే పరిశీలించిన శిక్షణ కేసుల నుండి ఉత్పన్నమవుతుంది. ఇండక్టివ్ ఇన్ఫరెన్స్ సాధారణ నియమాలకు మ్యాప్ అయ్యే శిక్షణ కేసుల నుండి ఉత్పన్నమవుతుంది, అవి తర్వాత మాత్రమే పరీక్ష కేసులకు వర్తింపజేయబడతాయి.\n",
">\n",
"> ఉదాహరణ: మీరు ఒక డేటాసెట్‌ను కలిగి ఉన్నారు, అది భాగంగా మాత్రమే లేబుల్ చేయబడింది. కొన్ని 'రికార్డులు', కొన్ని 'సీడీలు', మరియు కొన్ని ఖాళీగా ఉన్నాయి. మీ పని ఖాళీలకు లేబుల్స్ ఇవ్వడం. మీరు ఇండక్టివ్ పద్ధతిని ఎంచుకుంటే, మీరు 'రికార్డులు' మరియు 'సీడీలు' కోసం ఒక మోడల్‌ను శిక్షణ ఇస్తారు, మరియు ఆ లేబుల్స్‌ను లేబుల్ చేయబడని డేటాకు వర్తింపజేస్తారు. ఈ పద్ధతి నిజంగా 'కాసెట్స్' అయిన వాటిని వర్గీకరించడంలో ఇబ్బంది పడుతుంది. మరోవైపు, ట్రాన్స్‌డక్టివ్ పద్ధతి ఈ తెలియని డేటాను మరింత సమర్థవంతంగా నిర్వహిస్తుంది, ఇది సమానమైన అంశాలను సమూహాలుగా కలిపి ఆ సమూహానికి లేబుల్‌ను వర్తింపజేస్తుంది. ఈ సందర్భంలో, క్లస్టర్లు 'వృత్తాకార సంగీత వస్తువులు' మరియు 'చతురస్ర సంగీత వస్తువులు'ని ప్రతిబింబించవచ్చు.\n",
">\n",
"> 🎓 ['నాన్-ఫ్లాట్' vs. 'ఫ్లాట్' జ్యామితి](https://datascience.stackexchange.com/questions/52260/terminology-flat-geometry-in-the-context-of-clustering)\n",
">\n",
"> గణిత శాస్త్ర పదజాలం నుండి ఉద్భవించిన, నాన్-ఫ్లాట్ vs. ఫ్లాట్ జ్యామితి అనేది పాయింట్ల మధ్య దూరాలను 'ఫ్లాట్' ([యూక్లిడియన్](https://wikipedia.org/wiki/Euclidean_geometry)) లేదా 'నాన్-ఫ్లాట్' (నాన్-యూక్లిడియన్) జ్యామితి పద్ధతుల ద్వారా కొలవడాన్ని సూచిస్తుంది.\n",
">\n",
"> ఇక్కడ 'ఫ్లాట్' అనగా యూక్లిడియన్ జ్యామితి (దాని భాగాలు 'ప్లేన్' జ్యామితిగా బోధించబడతాయి), మరియు నాన్-ఫ్లాట్ అనగా నాన్-యూక్లిడియన్ జ్యామితి. జ్యామితి కి మెషీన్ లెర్నింగ్ తో సంబంధం ఏమిటి? గణిత శాస్త్రంలో ఆధారపడిన రెండు రంగాలుగా, క్లస్టర్లలో పాయింట్ల మధ్య దూరాలను కొలవడానికి ఒక సాధారణ మార్గం ఉండాలి, అది 'ఫ్లాట్' లేదా 'నాన్-ఫ్లాట్' విధంగా చేయవచ్చు, డేటా స్వభావం ఆధారంగా. [యూక్లిడియన్ దూరాలు](https://wikipedia.org/wiki/Euclidean_distance) రెండు పాయింట్ల మధ్య రేఖా భాగం పొడవుగా కొలవబడతాయి. [నాన్-యూక్లిడియన్ దూరాలు](https://wikipedia.org/wiki/Non-Euclidean_geometry) వక్రరేఖపై కొలవబడతాయి. మీ డేటా, దృశ్యరూపంలో, ఒక ప్లేన్ పై లేనట్టుగా కనిపిస్తే, మీరు దాన్ని నిర్వహించడానికి ప్రత్యేక అల్గోరిథం అవసరం కావచ్చు.\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/flat-nonflat.d1c8c6e2a96110c1d57fa0b72913f6aab3c245478524d25baf7f4a18efcde224.te.png\"\n",
" width=\"600\"/>\n",
" <figcaption>ఇన్ఫోగ్రాఫిక్ - దాసాని మడిపల్లి</figcaption>\n",
"\n",
"\n",
"\n",
"> 🎓 ['దూరాలు'](https://web.stanford.edu/class/cs345a/slides/12-clustering.pdf)\n",
">\n",
"> క్లస్టర్లు వాటి దూర మ్యాట్రిక్స్ ద్వారా నిర్వచించబడతాయి, ఉదా: పాయింట్ల మధ్య దూరాలు. ఈ దూరం కొలవడంలో కొన్ని మార్గాలు ఉన్నాయి. యూక్లిడియన్ క్లస్టర్లు పాయింట్ విలువల సగటు ద్వారా నిర్వచించబడతాయి, మరియు 'సెంట్రాయిడ్' లేదా కేంద్ర పాయింట్ కలిగి ఉంటాయి. దూరాలు ఆ సెంట్రాయిడ్ దూరం ద్వారా కొలవబడతాయి. నాన్-యూక్లిడియన్ దూరాలు 'క్లస్ట్రాయిడ్స్' కు సంబంధించినవి, అంటే ఇతర పాయింట్లకు అత్యంత సమీపమైన పాయింట్. క్లస్ట్రాయిడ్స్ వివిధ రకాలుగా నిర్వచించబడవచ్చు.\n",
">\n",
"> 🎓 ['కన్స్ట్రెయిన్డ్'](https://wikipedia.org/wiki/Constrained_clustering)\n",
">\n",
"> [కన్స్ట్రెయిన్డ్ క్లస్టరింగ్](https://web.cs.ucdavis.edu/~davidson/Publications/ICDMTutorial.pdf) ఈ అనియంత్రిత పద్ధతిలో 'సెమీ-సూపర్వైజ్డ్' లెర్నింగ్‌ను పరిచయం చేస్తుంది. పాయింట్ల మధ్య సంబంధాలు 'లింక్ చేయకూడదు' లేదా 'లింక్ చేయాలి' అని గుర్తించబడతాయి, కాబట్టి కొన్ని నియమాలు డేటాసెట్‌పై అమలవుతాయి.\n",
">\n",
"> ఉదాహరణ: ఒక అల్గోరిథం లేబుల్ చేయబడని లేదా సెమీ-లేబుల్ చేయబడిన డేటా బ్యాచ్‌పై స్వేచ్ఛగా అమలవుతే, అది ఉత్పత్తి చేసే క్లస్టర్లు తక్కువ నాణ్యత కలిగి ఉండవచ్చు. పై ఉదాహరణలో, క్లస్టర్లు 'వృత్తాకార సంగీత వస్తువులు', 'చతురస్ర సంగీత వస్తువులు', 'త్రిభుజాకార వస్తువులు' మరియు 'కుకీస్' గా వర్గీకరించవచ్చు. కొన్ని నియమాలు లేదా నియమాలను (\"వస్తువు ప్లాస్టిక్‌తో తయారవాలి\", \"వస్తువు సంగీతం ఉత్పత్తి చేయగలగాలి\") ఇవ్వడం ద్వారా అల్గోరిథం మెరుగైన ఎంపికలు చేయడానికి 'కన్స్ట్రెయిన్' చేయవచ్చు.\n",
">\n",
"> 🎓 'డెన్సిటీ'\n",
">\n",
"> 'నాయిసీ'గా పరిగణించబడే డేటా 'డెన్స్' గా పరిగణించబడుతుంది. దాని ప్రతి క్లస్టర్‌లో పాయింట్ల మధ్య దూరాలు పరిశీలనలో ఎక్కువ లేదా తక్కువగా ఉండవచ్చు, లేదా 'గొడవ'గా ఉండవచ్చు, కాబట్టి ఈ డేటాను సరైన క్లస్టరింగ్ పద్ధతితో విశ్లేషించాలి. [ఈ వ్యాసం](https://www.kdnuggets.com/2020/02/understanding-density-based-clustering.html) K-Means క్లస్టరింగ్ మరియు HDBSCAN అల్గోరిథమ్లను ఉపయోగించి అసమానమైన క్లస్టర్ డెన్సిటీ ఉన్న నాయిసీ డేటాసెట్‌ను అన్వేషించడంలో తేడాను చూపిస్తుంది.\n",
"\n",
"ఈ [లెర్న్ మాడ్యూల్](https://docs.microsoft.com/learn/modules/train-evaluate-cluster-models?WT.mc_id=academic-77952-leestott) లో క్లస్టరింగ్ సాంకేతికతలపై మీ అవగాహనను లోతుగా పెంచుకోండి\n",
"\n",
"### **క్లస్టరింగ్ అల్గోరిథమ్లు**\n",
"\n",
"100కి పైగా క్లస్టరింగ్ అల్గోరిథమ్లు ఉన్నాయి, మరియు వాటి ఉపయోగం డేటా స్వభావంపై ఆధారపడి ఉంటుంది. కొన్ని ప్రధాన అల్గోరిథమ్లను చర్చిద్దాం:\n",
"\n",
"- **హైరార్కికల్ క్లస్టరింగ్**. ఒక వస్తువు దాని సమీపంలోని వస్తువుతో సమీపత ఆధారంగా వర్గీకరించబడితే, దూరం ఆధారంగా క్లస్టర్లు ఏర్పడతాయి. హైరార్కికల్ క్లస్టరింగ్ రెండు క్లస్టర్లను పునరావృతంగా కలిపే విధంగా ఉంటుంది.\n",
"\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/hierarchical.bf59403aa43c8c47493bfdf1cc25230f26e45f4e38a3d62e8769cd324129ac15.te.png\"\n",
" width=\"600\"/>\n",
" <figcaption>ఇన్ఫోగ్రాఫిక్ - దాసాని మడిపల్లి</figcaption>\n",
"\n",
"\n",
"\n",
"- **సెంట్రాయిడ్ క్లస్టరింగ్**. ఈ ప్రాచుర్యం పొందిన అల్గోరిథం 'k' అనే క్లస్టర్ల సంఖ్యను ఎంచుకోవాలి, ఆ తర్వాత అల్గోరిథం ఒక క్లస్టర్ కేంద్ర పాయింట్‌ను నిర్ణయించి ఆ పాయింట్ చుట్టూ డేటాను సేకరిస్తుంది. [K-means క్లస్టరింగ్](https://wikipedia.org/wiki/K-means_clustering) సెంట్రాయిడ్ క్లస్టరింగ్ యొక్క ఒక ప్రాచుర్యం పొందిన వెర్షన్, ఇది డేటా సెట్‌ను ముందుగా నిర్వచించిన K గుంపులుగా విడగొడుతుంది. కేంద్రం సమీప సగటు ద్వారా నిర్ణయించబడుతుంది, అందుకే పేరు. క్లస్టర్ నుండి చతురస్ర దూరం తగ్గించబడుతుంది.\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/centroid.097fde836cf6c9187d0b2033e9f94441829f9d86f4f0b1604dd4b3d1931aee34.te.png\"\n",
" width=\"600\"/>\n",
" <figcaption>ఇన్ఫోగ్రాఫిక్ - దాసాని మడిపల్లి</figcaption>\n",
"\n",
"\n",
"\n",
"- **వితరణ ఆధారిత క్లస్టరింగ్**. గణాంక నమూనాలపై ఆధారపడి, వితరణ ఆధారిత క్లస్టరింగ్ ఒక డేటా పాయింట్ ఒక క్లస్టర్‌కు చెందే సంభావ్యతను నిర్ణయించి దానికి అనుగుణంగా కేటాయిస్తుంది. గౌసియన్ మిశ్రమ పద్ధతులు ఈ రకానికి చెందుతాయి.\n",
"\n",
"- **సాంద్రత ఆధారిత క్లస్టరింగ్**. డేటా పాయింట్లు వారి సాంద్రత లేదా ఒకరితో ఒకరు సమూహాలుగా ఉండటం ఆధారంగా క్లస్టర్లకు కేటాయించబడతాయి. సమూహం నుండి దూరంగా ఉన్న డేటా పాయింట్లు అవుట్లయర్స్ లేదా శబ్దంగా పరిగణించబడతాయి. DBSCAN, Mean-shift మరియు OPTICS ఈ రకమైన క్లస్టరింగ్‌కు చెందుతాయి.\n",
"\n",
"- **గ్రిడ్ ఆధారిత క్లస్టరింగ్**. బహుముఖ డేటాసెట్‌ల కోసం, ఒక గ్రిడ్ సృష్టించి డేటాను గ్రిడ్ సెల్స్ మధ్య విభజించి క్లస్టర్లు సృష్టిస్తారు.\n",
"\n",
"క్లస్టరింగ్ గురించి నేర్చుకోవడానికి ఉత్తమ మార్గం మీరు స్వయంగా ప్రయత్నించడం, కాబట్టి ఈ వ్యాయామంలో మీరు అదే చేస్తారు.\n",
"\n",
"ఈ మాడ్యూల్‌ను పూర్తి చేయడానికి కొన్ని ప్యాకేజీలను అవసరం. మీరు వాటిని ఇన్‌స్టాల్ చేయవచ్చు: `install.packages(c('tidyverse', 'tidymodels', 'DataExplorer', 'summarytools', 'plotly', 'paletteer', 'corrplot', 'patchwork'))`\n",
"\n",
"వేరే విధంగా, క్రింది స్క్రిప్ట్ ఈ మాడ్యూల్ పూర్తి చేయడానికి అవసరమైన ప్యాకేజీలు మీ వద్ద ఉన్నాయా లేదా అని తనిఖీ చేసి, కొన్నీ లేనప్పుడు వాటిని ఇన్‌స్టాల్ చేస్తుంది.\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"suppressWarnings(if(!require(\"pacman\")) install.packages(\"pacman\"))\r\n",
"\r\n",
"pacman::p_load('tidyverse', 'tidymodels', 'DataExplorer', 'summarytools', 'plotly', 'paletteer', 'corrplot', 'patchwork')\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"## వ్యాయామం - మీ డేటాను క్లస్టర్ చేయండి\n",
"\n",
"క్లస్టరింగ్ ఒక సాంకేతికతగా సరైన విజువలైజేషన్ ద్వారా చాలా సహాయపడుతుంది, కాబట్టి మన సంగీత డేటాను విజువలైజ్ చేయడం ప్రారంభిద్దాం. ఈ వ్యాయామం మనకు ఈ డేటా స్వభావానికి ఏ క్లస్టరింగ్ పద్ధతిని అత్యంత సమర్థవంతంగా ఉపయోగించాలో నిర్ణయించడంలో సహాయపడుతుంది.\n",
"\n",
"డేటాను దిగుమతి చేసుకోవడం ద్వారా ప్రారంభిద్దాం.\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Load the core tidyverse and make it available in your current R session\r\n",
"library(tidyverse)\r\n",
"\r\n",
"# Import the data into a tibble\r\n",
"df <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/5-Clustering/data/nigerian-songs.csv\")\r\n",
"\r\n",
"# View the first 5 rows of the data set\r\n",
"df %>% \r\n",
" slice_head(n = 5)\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"కొన్నిసార్లు, మన డేటా గురించి కొంచెం ఎక్కువ సమాచారం కావచ్చు. మనం [*glimpse()*](https://pillar.r-lib.org/reference/glimpse.html) ఫంక్షన్ ఉపయోగించి `డేటా` మరియు `దాని నిర్మాణం` ను చూడవచ్చు:\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Glimpse into the data set\r\n",
"df %>% \r\n",
" glimpse()\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"చాలా బాగుంది!💪\n",
"\n",
"మనం గమనించవచ్చు `glimpse()` మీకు మొత్తం వరుసల సంఖ్య (పరిశీలనలు) మరియు కాలమ్స్ (వేరియబుల్స్) ఇస్తుంది, ఆపై, ప్రతి వేరియబుల్ పేరుతో పాటు ఆ వేరియబుల్ యొక్క మొదటి కొన్ని ఎంట్రీలను ఒక వరుసలో చూపిస్తుంది. అదనంగా, వేరియబుల్ యొక్క *డేటా టైపు* ప్రతి వేరియబుల్ పేరుకు వెంటనే `< >` లో ఇవ్వబడుతుంది.\n",
"\n",
"`DataExplorer::introduce()` ఈ సమాచారాన్ని సుస్పష్టంగా సారాంశం చేయగలదు:\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Describe basic information for our data\r\n",
"df %>% \r\n",
" introduce()\r\n",
"\r\n",
"# A visual display of the same\r\n",
"df %>% \r\n",
" plot_intro()\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"అద్భుతం! మన డేటాలో ఎటువంటి మిస్సింగ్ విలువలు లేవని మనం ఇప్పుడే తెలుసుకున్నాము.\n",
"\n",
"మనం ఇదే సమయంలో, సాధారణ కేంద్ర ధోరణి గణాంకాలు (ఉదా: [సగటు](https://en.wikipedia.org/wiki/Arithmetic_mean) మరియు [మధ్యమం](https://en.wikipedia.org/wiki/Median)) మరియు వ్యాప్తి కొలతలు (ఉదా: [స్టాండర్డ్ డివియేషన్](https://en.wikipedia.org/wiki/Standard_deviation)) ను `summarytools::descr()` ఉపయోగించి పరిశీలించవచ్చు.\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Describe common statistics\r\n",
"df %>% \r\n",
" descr(stats = \"common\")\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"డేటా యొక్క సాధారణ విలువలను చూద్దాం. ప్రాచుర్యం `0` కావచ్చు, అంటే ర్యాంకింగ్ లేని పాటలను చూపిస్తుంది. వాటిని త్వరలోనే తొలగిస్తాము.\n",
"\n",
"> 🤔 మనం లేబుల్ చేయబడిన డేటా అవసరం లేని, క్లస్టరింగ్ అనే అనుసూచిత పద్ధతితో పని చేస్తుంటే, ఈ డేటాను లేబుల్స్‌తో ఎందుకు చూపిస్తున్నాం? డేటా అన్వేషణ దశలో అవి ఉపయోగకరంగా ఉంటాయి, కానీ క్లస్టరింగ్ అల్గోరిథమ్స్ పనిచేయడానికి అవి అవసరం కాదు.\n",
"\n",
"### 1. ప్రాచుర్యం ఉన్న జానర్లను అన్వేషించండి\n",
"\n",
"ఇప్పుడు మనం అత్యంత ప్రాచుర్యం ఉన్న జానర్లను 🎶 కనుగొనడానికి, అవి కనిపించే సందర్భాల సంఖ్యను లెక్కించుకుందాం.\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Popular genres\r\n",
"top_genres <- df %>% \r\n",
" count(artist_top_genre, sort = TRUE) %>% \r\n",
"# Encode to categorical and reorder the according to count\r\n",
" mutate(artist_top_genre = factor(artist_top_genre) %>% fct_inorder())\r\n",
"\r\n",
"# Print the top genres\r\n",
"top_genres\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"అది బాగానే జరిగింది! వారు అంటారు ఒక చిత్రం డేటా ఫ్రేమ్ యొక్క వెయ్యి వరుసల విలువను కలిగి ఉంటుంది (నిజానికి ఎవరూ అలాంటి మాటలు చెప్పరు 😅). కానీ మీరు అర్థం చేసుకున్నట్లేనా, కదా?\n",
"\n",
"వర్గీకృత డేటాను (అక్షర లేదా ఫ్యాక్టర్ వేరియబుల్స్) దృశ్యీకరించడానికి ఒక మార్గం బార్ప్లాట్లు ఉపయోగించడం. టాప్ 10 జానర్ల బార్ప్లాట్ తయారు చేద్దాం:\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Change the default gray theme\r\n",
"theme_set(theme_light())\r\n",
"\r\n",
"# Visualize popular genres\r\n",
"top_genres %>%\r\n",
" slice(1:10) %>% \r\n",
" ggplot(mapping = aes(x = artist_top_genre, y = n,\r\n",
" fill = artist_top_genre)) +\r\n",
" geom_col(alpha = 0.8) +\r\n",
" paletteer::scale_fill_paletteer_d(\"rcartocolor::Vivid\") +\r\n",
" ggtitle(\"Top genres\") +\r\n",
" theme(plot.title = element_text(hjust = 0.5),\r\n",
" # Rotates the X markers (so we can read them)\r\n",
" axis.text.x = element_text(angle = 90))\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"ఇప్పుడు మనకు `missing` జానర్లున్నాయని గుర్తించడం చాలా సులభం 🧐!\n",
"\n",
"> ఒక మంచి విజువలైజేషన్ మీరు ఆశించని విషయాలను చూపిస్తుంది, లేదా డేటా గురించి కొత్త ప్రశ్నలను రేకెత్తిస్తుంది - హాడ్లీ విక్హామ్ మరియు గారెట్ గ్రోలెమండ్, [R For Data Science](https://r4ds.had.co.nz/introduction.html)\n",
"\n",
"గమనిక, టాప్ జానర్ `Missing`గా వర్ణించబడితే, అంటే Spotify దాన్ని వర్గీకరించలేదు, కాబట్టి దాన్ని తొలగిద్దాం.\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Visualize popular genres\r\n",
"top_genres %>%\r\n",
" filter(artist_top_genre != \"Missing\") %>% \r\n",
" slice(1:10) %>% \r\n",
" ggplot(mapping = aes(x = artist_top_genre, y = n,\r\n",
" fill = artist_top_genre)) +\r\n",
" geom_col(alpha = 0.8) +\r\n",
" paletteer::scale_fill_paletteer_d(\"rcartocolor::Vivid\") +\r\n",
" ggtitle(\"Top genres\") +\r\n",
" theme(plot.title = element_text(hjust = 0.5),\r\n",
" # Rotates the X markers (so we can read them)\r\n",
" axis.text.x = element_text(angle = 90))\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"చిన్న డేటా అన్వేషణ నుండి, ఈ డేటాసెట్‌ను టాప్ మూడు జానర్లు ఆధిపత్యం వహిస్తున్నాయని తెలుసుకుంటాము. మనం `afro dancehall`, `afropop`, మరియు `nigerian pop` పై దృష్టి సారిద్దాం, అదనంగా 0 ప్రాచుర్యం విలువ ఉన్న ఏదైనా డేటాను తొలగించడానికి ఫిల్టర్ చేయండి (అర్థం ఇది డేటాసెట్‌లో ప్రాచుర్యం తో వర్గీకరించబడలేదు మరియు మన ప్రయోజనాల కోసం శబ్దంగా పరిగణించవచ్చు):\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"nigerian_songs <- df %>% \r\n",
" # Concentrate on top 3 genres\r\n",
" filter(artist_top_genre %in% c(\"afro dancehall\", \"afropop\",\"nigerian pop\")) %>% \r\n",
" # Remove unclassified observations\r\n",
" filter(popularity != 0)\r\n",
"\r\n",
"\r\n",
"\r\n",
"# Visualize popular genres\r\n",
"nigerian_songs %>%\r\n",
" count(artist_top_genre) %>%\r\n",
" ggplot(mapping = aes(x = artist_top_genre, y = n,\r\n",
" fill = artist_top_genre)) +\r\n",
" geom_col(alpha = 0.8) +\r\n",
" paletteer::scale_fill_paletteer_d(\"ggsci::category10_d3\") +\r\n",
" ggtitle(\"Top genres\") +\r\n",
" theme(plot.title = element_text(hjust = 0.5))\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"మన డేటా సెట్‌లో సంఖ్యాత్మక వేరియబుల్స్ మధ్య ఏదైనా స్పష్టమైన రేఖీయ సంబంధం ఉందో లేదో చూద్దాం. ఈ సంబంధాన్ని గణితంగా [correlation statistic](https://en.wikipedia.org/wiki/Correlation) ద్వారా కొలుస్తారు.\n",
"\n",
"correlation statistic అనేది -1 మరియు 1 మధ్య విలువ, ఇది సంబంధం యొక్క బలాన్ని సూచిస్తుంది. 0 కంటే పైగా ఉన్న విలువలు *ధనాత్మక* సంబంధాన్ని సూచిస్తాయి (ఒక వేరియబుల్ యొక్క అధిక విలువలు మరొక వేరియబుల్ యొక్క అధిక విలువలతో సాధారణంగా కలుస్తాయి), 0 కంటే తక్కువ విలువలు *ప్రతికూల* సంబంధాన్ని సూచిస్తాయి (ఒక వేరియబుల్ యొక్క అధిక విలువలు మరొక వేరియబుల్ యొక్క తక్కువ విలువలతో సాధారణంగా కలుస్తాయి).\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Narrow down to numeric variables and fid correlation\r\n",
"corr_mat <- nigerian_songs %>% \r\n",
" select(where(is.numeric)) %>% \r\n",
" cor()\r\n",
"\r\n",
"# Visualize correlation matrix\r\n",
"corrplot(corr_mat, order = 'AOE', col = c('white', 'black'), bg = 'gold2') \r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"డేటా బలంగా సంబంధం లేదు, తప్ప `energy` మరియు `loudness` మధ్య మాత్రమే, ఇది అర్థం చేసుకోవడానికి సులభం, ఎందుకంటే గట్టిగా ఉన్న సంగీతం సాధారణంగా చాలా శక్తివంతంగా ఉంటుంది. `Popularity` కు `release date` తో సంబంధం ఉంది, ఇది కూడా అర్థం చేసుకోవడానికి సులభం, ఎందుకంటే తాజా పాటలు ఎక్కువగా ప్రాచుర్యం పొందినవే కావచ్చు. Length మరియు energy కూడా సంబంధం ఉన్నట్లు కనిపిస్తున్నాయి.\n",
"\n",
"ఈ డేటాను క్లస్టరింగ్ అల్గోరిథం ఎలా విశ్లేషిస్తుందో చూడటం ఆసక్తికరం!\n",
"\n",
"> 🎓 గమనిక: సంబంధం కారణాన్ని సూచించదు! మనకు సంబంధం ఉన్నదని సాక్ష్యం ఉంది కానీ కారణం ఉన్నదని సాక్ష్యం లేదు. ఒక [వినోదాత్మక వెబ్ సైట్](https://tylervigen.com/spurious-correlations) ఈ విషయాన్ని హైలైట్ చేసే కొన్ని విజువల్స్ కలిగి ఉంది.\n",
"\n",
"### 2. డేటా పంపిణీని అన్వేషించండి\n",
"\n",
"మనం మరింత సున్నితమైన ప్రశ్నలు అడుద్దాం. వారి ప్రాచుర్యం ఆధారంగా జానర్ల డాన్స్ చేయగలిగే సామర్థ్యం గ్రహణలో గణనీయంగా భిన్నమా? మనం టాప్ మూడు జానర్ల డేటా పంపిణీని ప్రాచుర్యం మరియు డాన్స్ చేయగలిగే సామర్థ్యం కోసం ఇచ్చిన x మరియు y అక్షాలపై [density plots](https://www.khanacademy.org/math/ap-statistics/density-curves-normal-distribution-ap/density-curves/v/density-curves) ఉపయోగించి పరిశీలిద్దాం.\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# Perform 2D kernel density estimation\r\n",
"density_estimate_2d <- nigerian_songs %>% \r\n",
" ggplot(mapping = aes(x = popularity, y = danceability, color = artist_top_genre)) +\r\n",
" geom_density_2d(bins = 5, size = 1) +\r\n",
" paletteer::scale_color_paletteer_d(\"RSkittleBrewer::wildberry\") +\r\n",
" xlim(-20, 80) +\r\n",
" ylim(0, 1.2)\r\n",
"\r\n",
"# Density plot based on the popularity\r\n",
"density_estimate_pop <- nigerian_songs %>% \r\n",
" ggplot(mapping = aes(x = popularity, fill = artist_top_genre, color = artist_top_genre)) +\r\n",
" geom_density(size = 1, alpha = 0.5) +\r\n",
" paletteer::scale_fill_paletteer_d(\"RSkittleBrewer::wildberry\") +\r\n",
" paletteer::scale_color_paletteer_d(\"RSkittleBrewer::wildberry\") +\r\n",
" theme(legend.position = \"none\")\r\n",
"\r\n",
"# Density plot based on the danceability\r\n",
"density_estimate_dance <- nigerian_songs %>% \r\n",
" ggplot(mapping = aes(x = danceability, fill = artist_top_genre, color = artist_top_genre)) +\r\n",
" geom_density(size = 1, alpha = 0.5) +\r\n",
" paletteer::scale_fill_paletteer_d(\"RSkittleBrewer::wildberry\") +\r\n",
" paletteer::scale_color_paletteer_d(\"RSkittleBrewer::wildberry\")\r\n",
"\r\n",
"\r\n",
"# Patch everything together\r\n",
"library(patchwork)\r\n",
"density_estimate_2d / (density_estimate_pop + density_estimate_dance)\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"మేము చూస్తున్నాము, జానర్‌ను పరిగణనలోకి తీసుకోకుండా, సెంట్రిక్ సర్కిల్స్ సరిపోతున్నాయి. ఈ జానర్ కోసం నైజీరియన్ రుచులు ఒక నిర్దిష్ట డ్యాన్సబిలిటీ స్థాయిలో కలిసిపోతాయా?\n",
"\n",
"సాధారణంగా, ఈ మూడు జానర్లు వారి ప్రాచుర్యం మరియు డ్యాన్సబిలిటీ పరంగా సరిపోతున్నాయి. ఈ సడలించిన సరిపోలిన డేటాలో క్లస్టర్లను నిర్ణయించడం ఒక సవాలు అవుతుంది. ఒక స్కాటర్ ప్లాట్ దీనిని మద్దతు ఇస్తుందో లేదో చూద్దాం.\n"
],
"metadata": {}
},
{
"cell_type": "code",
"execution_count": null,
"source": [
"# A scatter plot of popularity and danceability\r\n",
"scatter_plot <- nigerian_songs %>% \r\n",
" ggplot(mapping = aes(x = popularity, y = danceability, color = artist_top_genre, shape = artist_top_genre)) +\r\n",
" geom_point(size = 2, alpha = 0.8) +\r\n",
" paletteer::scale_color_paletteer_d(\"futurevisions::mars\")\r\n",
"\r\n",
"# Add a touch of interactivity\r\n",
"ggplotly(scatter_plot)\r\n"
],
"outputs": [],
"metadata": {}
},
{
"cell_type": "markdown",
"source": [
"అదే అక్షాల స్కాటర్‌ప్లాట్ సమానమైన సమీకరణ నమూనాను చూపిస్తుంది.\n",
"\n",
"సాధారణంగా, క్లస్టరింగ్ కోసం, మీరు డేటా క్లస్టర్లను చూపించడానికి స్కాటర్‌ప్లాట్లను ఉపయోగించవచ్చు, కాబట్టి ఈ రకమైన విజువలైజేషన్‌ను నైపుణ్యం సాధించడం చాలా ఉపయోగకరం. తదుపరి పాఠంలో, మేము ఈ ఫిల్టర్ చేయబడిన డేటాను తీసుకుని k-మీన్ క్లస్టరింగ్‌ను ఉపయోగించి ఈ డేటాలో ఆసక్తికరమైన విధాలుగా ఓవర్లాప్ అయ్యే గ్రూపులను కనుగొంటాము.\n",
"\n",
"## **🚀 సవాలు**\n",
"\n",
"తదుపరి పాఠానికి సిద్ధంగా ఉండటానికి, మీరు ప్రొడక్షన్ వాతావరణంలో కనుగొనగల మరియు ఉపయోగించగల వివిధ క్లస్టరింగ్ అల్గోరిథమ్ల గురించి ఒక చార్ట్ తయారు చేయండి. క్లస్టరింగ్ ఏ రకమైన సమస్యలను పరిష్కరించడానికి ప్రయత్నిస్తోంది?\n",
"\n",
"## [**పోస్ట్-లెక్చర్ క్విజ్**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/28/)\n",
"\n",
"## **సమీక్ష & స్వీయ అధ్యయనం**\n",
"\n",
"మీరు క్లస్టరింగ్ అల్గోరిథమ్లను వర్తింపజేసే ముందు, మేము నేర్చుకున్నట్లుగా, మీ డేటాసెట్ స్వభావాన్ని అర్థం చేసుకోవడం మంచి ఆలోచన. ఈ విషయంపై మరింత చదవండి [ఇక్కడ](https://www.kdnuggets.com/2019/10/right-clustering-algorithm.html)\n",
"\n",
"క్లస్టరింగ్ సాంకేతికతలపై మీ అవగాహనను లోతుగా చేసుకోండి:\n",
"\n",
"- [Tidymodels మరియు ఫ్రెండ్స్ ఉపయోగించి క్లస్టరింగ్ మోడల్స్‌ను శిక్షణ మరియు మూల్యాంకనం చేయడం](https://rpubs.com/eR_ic/clustering)\n",
"\n",
"- బ్రాడ్లీ బోహ్మ్కే & బ్రాండన్ గ్రీన్‌వెల్, [*Hands-On Machine Learning with R*](https://bradleyboehmke.github.io/HOML/)*.*\n",
"\n",
"## **అసైన్‌మెంట్**\n",
"\n",
"[క్లస్టరింగ్ కోసం ఇతర విజువలైజేషన్లపై పరిశోధన చేయండి](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/1-Visualize/assignment.md)\n",
"\n",
"## ధన్యవాదాలు:\n",
"\n",
"[జెన్ లూపర్](https://www.twitter.com/jenlooper) ఈ మాడ్యూల్ యొక్క అసలు పైథాన్ వెర్షన్ సృష్టించినందుకు ♥️\n",
"\n",
"[`దాసాని మడిపల్లి`](https://twitter.com/dasani_decoded) మెషీన్ లెర్నింగ్ కాన్సెప్ట్‌లను మరింత అర్థమయ్యేలా మరియు సులభంగా అర్థం చేసుకునేలా చేసే అద్భుతమైన చిత్రణలను సృష్టించినందుకు.\n",
"\n",
"సంతోషకరమైన అభ్యాసం,\n",
"\n",
"[ఎరిక్](https://twitter.com/ericntay), గోల్డ్ మైక్రోసాఫ్ట్ లెర్న్ స్టూడెంట్ అంబాసిడర్.\n"
],
"metadata": {}
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
],
"metadata": {
"anaconda-cloud": "",
"kernelspec": {
"display_name": "R",
"language": "R",
"name": "ir"
},
"language_info": {
"codemirror_mode": "r",
"file_extension": ".r",
"mimetype": "text/x-r-source",
"name": "R",
"pygments_lexer": "r",
"version": "3.4.1"
},
"coopTranslator": {
"original_hash": "99c36449cad3708a435f6798cfa39972",
"translation_date": "2025-12-19T16:59:31+00:00",
"source_file": "5-Clustering/1-Visualize/solution/R/lesson_14-R.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 1
}

831
translations/te/5-Clustering/1-Visualize/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

263
translations/te/5-Clustering/2-K-Means/README.md
Unescape View File

@ -0,0 +1,263 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "7cdd17338d9bbd7e2171c2cd462eb081",
"translation_date": "2025-12-19T14:50:18+00:00",
"source_file": "5-Clustering/2-K-Means/README.md",
"language_code": "te"
}
-->
# K-Means క్లస్టరింగ్
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
ఈ పాఠంలో, మీరు Scikit-learn మరియు మీరు ముందుగా దిగుమతి చేసుకున్న నైజీరియన్ సంగీత డేటాసెట్ ఉపయోగించి క్లస్టర్లను ఎలా సృష్టించాలో నేర్చుకుంటారు. మేము K-Means క్లస్టరింగ్ యొక్క ప్రాథమిక అంశాలను కవర్ చేస్తాము. మీరు ముందుగా నేర్చుకున్నట్లుగా, క్లస్టర్లతో పని చేయడానికి అనేక మార్గాలు ఉన్నాయి మరియు మీరు ఉపయోగించే పద్ధతి మీ డేటాపై ఆధారపడి ఉంటుంది. K-Means ను ప్రయత్నిస్తాము ఎందుకంటే ఇది అత్యంత సాధారణ క్లస్టరింగ్ సాంకేతికత. మొదలు పెడదాం!
మీరు నేర్చుకునే పదాలు:
- సిల్హౌట్ స్కోరింగ్
- ఎల్బో పద్ధతి
- ఇనర్షియా
- వైవిధ్యం
## పరిచయం
[K-Means క్లస్టరింగ్](https://wikipedia.org/wiki/K-means_clustering) సిగ్నల్ ప్రాసెసింగ్ డొమైన్ నుండి ఉద్భవించిన పద్ధతి. ఇది డేటా సమూహాలను 'k' క్లస్టర్లుగా విభజించడానికి మరియు విభజించడానికి ఉపయోగిస్తారు, ఒక శ్రేణి పరిశీలనల ద్వారా. ప్రతి పరిశీలన ఒక నిర్దిష్ట డేటాపాయింట్‌ను దాని సమీప 'మీన' లేదా క్లస్టర్ యొక్క కేంద్ర బిందువు దగ్గరగా సమూహీకరించడానికి పనిచేస్తుంది.
క్లస్టర్లు [Voronoi డయాగ్రామ్స్](https://wikipedia.org/wiki/Voronoi_diagram) గా దృశ్యమానమవుతాయి, ఇవి ఒక బిందువు (లేదా 'సీడ్') మరియు దాని సంబంధిత ప్రాంతాన్ని కలిగి ఉంటాయి.
![voronoi diagram](../../../../translated_images/voronoi.1dc1613fb0439b9564615eca8df47a4bcd1ce06217e7e72325d2406ef2180795.te.png)
> ఇన్ఫోగ్రాఫిక్ [Jen Looper](https://twitter.com/jenlooper) ద్వారా
K-Means క్లస్టరింగ్ ప్రక్రియ [మూడు దశల ప్రక్రియలో అమలు అవుతుంది](https://scikit-learn.org/stable/modules/clustering.html#k-means):
1. అల్గోరిథం డేటాసెట్ నుండి నమూనాలు తీసుకుని k-సంఖ్యా కేంద్ర బిందువులను ఎంచుకుంటుంది. దీని తర్వాత, ఇది లూప్ చేస్తుంది:
1. ప్రతి నమూనాను సమీప సెంట్రాయిడ్‌కు కేటాయిస్తుంది.
2. గత సెంట్రాయిడ్‌లకు కేటాయించిన అన్ని నమూనాల సగటు విలువ తీసుకుని కొత్త సెంట్రాయిడ్‌లను సృష్టిస్తుంది.
3. ఆపై, కొత్త మరియు పాత సెంట్రాయిడ్‌ల మధ్య తేడాను లెక్కించి, సెంట్రాయిడ్‌లు స్థిరపడేవరకు పునరావృతం చేస్తుంది.
K-Means ఉపయోగించడంలో ఒక లోపం ఏమిటంటే, మీరు 'k' అంటే సెంట్రాయిడ్‌ల సంఖ్యను నిర్ణయించాలి. అదృష్టవశాత్తు 'ఎల్బో పద్ధతి' మంచి ప్రారంభ విలువను అంచనా వేయడంలో సహాయపడుతుంది. మీరు దీన్ని కొద్దిసేపట్లో ప్రయత్నిస్తారు.
## ముందస్తు అవసరాలు
ఈ పాఠంలో మీరు [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/2-K-Means/notebook.ipynb) ఫైల్‌లో పని చేస్తారు, ఇందులో మీరు గత పాఠంలో చేసిన డేటా దిగుమతి మరియు ప్రాథమిక శుభ్రపరిచే పనులు ఉన్నాయి.
## వ్యాయామం - సిద్ధం కావడం
మళ్లీ పాటల డేటాను పరిశీలించడం ప్రారంభించండి.
1. ప్రతి కాలమ్ కోసం `boxplot()` పిలిచి బాక్స్‌ప్లాట్ సృష్టించండి:
```python
plt.figure(figsize=(20,20), dpi=200)
plt.subplot(4,3,1)
sns.boxplot(x = 'popularity', data = df)
plt.subplot(4,3,2)
sns.boxplot(x = 'acousticness', data = df)
plt.subplot(4,3,3)
sns.boxplot(x = 'energy', data = df)
plt.subplot(4,3,4)
sns.boxplot(x = 'instrumentalness', data = df)
plt.subplot(4,3,5)
sns.boxplot(x = 'liveness', data = df)
plt.subplot(4,3,6)
sns.boxplot(x = 'loudness', data = df)
plt.subplot(4,3,7)
sns.boxplot(x = 'speechiness', data = df)
plt.subplot(4,3,8)
sns.boxplot(x = 'tempo', data = df)
plt.subplot(4,3,9)
sns.boxplot(x = 'time_signature', data = df)
plt.subplot(4,3,10)
sns.boxplot(x = 'danceability', data = df)
plt.subplot(4,3,11)
sns.boxplot(x = 'length', data = df)
plt.subplot(4,3,12)
sns.boxplot(x = 'release_date', data = df)
```
ఈ డేటా కొంత శబ్దంగా ఉంది: ప్రతి కాలమ్‌ను బాక్స్‌ప్లాట్‌గా పరిశీలించడం ద్వారా మీరు అవుట్లయర్స్‌ను చూడవచ్చు.
![outliers](../../../../translated_images/boxplots.8228c29dabd0f29227dd38624231a175f411f1d8d4d7c012cb770e00e4fdf8b6.te.png)
మీరు డేటాసెట్‌ను పరిశీలించి అవుట్లయర్స్‌ను తొలగించవచ్చు, కానీ అది డేటాను చాలా తక్కువగా చేస్తుంది.
1. ఇప్పటికీ, మీరు క్లస్టరింగ్ వ్యాయామం కోసం ఉపయోగించబోయే కాలమ్‌లను ఎంచుకోండి. సమాన పరిధులున్న వాటిని ఎంచుకోండి మరియు `artist_top_genre` కాలమ్‌ను సంఖ్యాత్మక డేటాగా ఎన్‌కోడ్ చేయండి:
```python
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
X = df.loc[:, ('artist_top_genre','popularity','danceability','acousticness','loudness','energy')]
y = df['artist_top_genre']
X['artist_top_genre'] = le.fit_transform(X['artist_top_genre'])
y = le.transform(y)
```
1. ఇప్పుడు మీరు ఎన్ని క్లస్టర్లను లక్ష్యంగా పెట్టుకోవాలో ఎంచుకోవాలి. మీరు డేటాసెట్ నుండి 3 పాటల జానర్లను తీసుకున్నారని తెలుసు, కాబట్టి 3 ను ప్రయత్నిద్దాం:
```python
from sklearn.cluster import KMeans
nclusters = 3
seed = 0
km = KMeans(n_clusters=nclusters, random_state=seed)
km.fit(X)
# ప్రతి డేటా పాయింట్ కోసం క్లస్టర్‌ను అంచనా వేయండి
y_cluster_kmeans = km.predict(X)
y_cluster_kmeans
```
మీరు డేటాఫ్రేమ్ యొక్క ప్రతి వరుసకు అంచనా వేయబడిన క్లస్టర్ల (0, 1, లేదా 2)తో కూడిన ఒక అర్రే ప్రింట్ అవుతుందని చూస్తారు.
1. ఈ అర్రే ఉపయోగించి 'సిల్హౌట్ స్కోర్' లెక్కించండి:
```python
from sklearn import metrics
score = metrics.silhouette_score(X, y_cluster_kmeans)
score
```
## సిల్హౌట్ స్కోర్
1కి దగ్గరగా ఉన్న సిల్హౌట్ స్కోర్ కోసం చూడండి. ఈ స్కోర్ -1 నుండి 1 వరకు మారుతుంది, మరియు స్కోర్ 1 అయితే, క్లస్టర్ సాంద్రంగా ఉంటుంది మరియు ఇతర క్లస్టర్ల నుండి బాగా వేరుగా ఉంటుంది. 0కి సమీపమైన విలువ సమీప క్లస్టర్ల మధ్య నమూనాలు నిర్ణయ సరిహద్దు దగ్గరగా ఉండే ఓవర్‌ల్యాపింగ్ క్లస్టర్లను సూచిస్తుంది. [(మూలం)](https://dzone.com/articles/kmeans-silhouette-score-explained-with-python-exam)
మన స్కోర్ **.53** ఉంది, అంటే మధ్యలో ఉంది. ఇది మన డేటా ఈ రకమైన క్లస్టరింగ్‌కు ప్రత్యేకంగా అనుకూలంగా లేనట్టుగా సూచిస్తుంది, కానీ మనం కొనసాగుదాం.
### వ్యాయామం - మోడల్ నిర్మాణం
1. `KMeans` ను దిగుమతి చేసుకుని క్లస్టరింగ్ ప్రక్రియ ప్రారంభించండి.
```python
from sklearn.cluster import KMeans
wcss = []
for i in range(1, 11):
kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
kmeans.fit(X)
wcss.append(kmeans.inertia_)
```
ఇక్కడ కొన్ని భాగాలు వివరణ అవసరం.
> 🎓 range: ఇవి క్లస్టరింగ్ ప్రక్రియ యొక్క పునరావృతాలు
> 🎓 random_state: "సెంట్రాయిడ్ ప్రారంభానికి రాండమ్ నంబర్ జనరేషన్‌ను నిర్ణయిస్తుంది." [మూలం](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html#sklearn.cluster.KMeans)
> 🎓 WCSS: "within-cluster sums of squares" అనేది క్లస్టర్‌లోని అన్ని పాయింట్ల సెంట్రాయిడ్‌కు సగటు చతురస్ర దూరాన్ని కొలుస్తుంది. [మూలం](https://medium.com/@ODSC/unsupervised-learning-evaluating-clusters-bd47eed175ce).
> 🎓 ఇనర్షియా: K-Means అల్గోరిథమ్స్ 'ఇనర్షియా'ని తగ్గించేలా సెంట్రాయిడ్‌లను ఎంచుకోవడానికి ప్రయత్నిస్తాయి, ఇది "క్లస్టర్లు అంతర్గతంగా ఎంత సुसంబద్ధంగా ఉన్నాయో కొలిచే కొలమానం." [మూలం](https://scikit-learn.org/stable/modules/clustering.html). ఈ విలువ ప్రతి పునరావృతంలో wcss వేరియబుల్‌కు జతచేయబడుతుంది.
> 🎓 k-means++: [Scikit-learn](https://scikit-learn.org/stable/modules/clustering.html#k-means)లో మీరు 'k-means++' ఆప్టిమైజేషన్‌ను ఉపయోగించవచ్చు, ఇది "సెంట్రాయిడ్‌లను సాధారణంగా ఒకరినొకరు దూరంగా ప్రారంభిస్తుంది, ఇది రాండమ్ ప్రారంభం కంటే మెరుగైన ఫలితాలు ఇస్తుంది."
### ఎల్బో పద్ధతి
ముందుగా, మీరు 3 పాటల జానర్లను లక్ష్యంగా పెట్టుకున్నందున 3 క్లస్టర్లను ఎంచుకోవాలని అనుకున్నారు. కానీ అది నిజమేనా?
1. 'ఎల్బో పద్ధతి' ఉపయోగించి నిర్ధారించండి.
```python
plt.figure(figsize=(10,5))
sns.lineplot(x=range(1, 11), y=wcss, marker='o', color='red')
plt.title('Elbow')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS')
plt.show()
```
మీరు గత దశలో నిర్మించిన `wcss` వేరియబుల్ ఉపయోగించి ఒక చార్ట్ సృష్టించండి, ఇందులో ఎల్బోలో 'వంక' ఎక్కడ ఉందో చూపిస్తుంది, ఇది ఉత్తమ క్లస్టర్ సంఖ్యను సూచిస్తుంది. కావచ్చు అది **3**నే!
![elbow method](../../../../translated_images/elbow.72676169eed744ff03677e71334a16c6b8f751e9e716e3d7f40dd7cdef674cca.te.png)
## వ్యాయామం - క్లస్టర్లను ప్రదర్శించండి
1. మళ్లీ ప్రక్రియను ప్రయత్నించండి, ఈసారి మూడు క్లస్టర్లను సెట్ చేసి, క్లస్టర్లను స్కాటర్‌ప్లాట్‌గా ప్రదర్శించండి:
```python
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters = 3)
kmeans.fit(X)
labels = kmeans.predict(X)
plt.scatter(df['popularity'],df['danceability'],c = labels)
plt.xlabel('popularity')
plt.ylabel('danceability')
plt.show()
```
1. మోడల్ యొక్క ఖచ్చితత్వాన్ని తనిఖీ చేయండి:
```python
labels = kmeans.labels_
correct_labels = sum(y == labels)
print("Result: %d out of %d samples were correctly labeled." % (correct_labels, y.size))
print('Accuracy score: {0:0.2f}'. format(correct_labels/float(y.size)))
```
ఈ మోడల్ యొక్క ఖచ్చితత్వం చాలా మంచిది కాదు, మరియు క్లస్టర్ల ఆకారం మీకు కారణాన్ని సూచిస్తుంది.
![clusters](../../../../translated_images/clusters.b635354640d8e4fd4a49ef545495518e7be76172c97c13bd748f5b79f171f69a.te.png)
ఈ డేటా చాలా అసమతుల్యంగా ఉంది, తక్కువ సంబంధం కలిగి ఉంది మరియు కాలమ్ విలువల మధ్య చాలా వైవిధ్యం ఉంది కాబట్టి బాగా క్లస్టర్ చేయడం కష్టం. వాస్తవానికి, ఏర్పడిన క్లస్టర్లు పై పేర్కొన్న మూడు జానర్ వర్గాల ప్రభావంతో లేదా వక్రీకృతమై ఉండవచ్చు. అది ఒక నేర్చుకునే ప్రక్రియ!
Scikit-learn డాక్యుమెంటేషన్‌లో, మీరు ఇలాంటి మోడల్, అంటే క్లస్టర్లు బాగా వేరుగా లేని మోడల్, 'వైవిధ్యం' సమస్యను కలిగి ఉందని చూడవచ్చు:
![problem models](../../../../translated_images/problems.f7fb539ccd80608e1f35c319cf5e3ad1809faa3c08537aead8018c6b5ba2e33a.te.png)
> Scikit-learn నుండి ఇన్ఫోగ్రాఫిక్
## వైవిధ్యం
వైవిధ్యం అంటే "సగటు నుండి చతురస్ర తేడాల సగటు" [(మూలం)](https://www.mathsisfun.com/data/standard-deviation.html). ఈ క్లస్టరింగ్ సమస్య సందర్భంలో, ఇది మన డేటాసెట్ సంఖ్యలు సగటు నుండి కొంత ఎక్కువగా విభిన్నమవుతాయని సూచిస్తుంది.
✅ ఇది ఈ సమస్యను సరిచేయడానికి మీరు చేయగల అన్ని మార్గాల గురించి ఆలోచించడానికి మంచి సమయం. డేటాను మరింత సవరించాలా? వేరే కాలమ్‌లను ఉపయోగించాలా? వేరే అల్గోరిథమ్ ఉపయోగించాలా? సూచన: [మీ డేటాను స్కేల్ చేయడం](https://www.mygreatlearning.com/blog/learning-data-science-with-k-means-clustering/) ద్వారా సాధారణీకరించి ఇతర కాలమ్‌లను పరీక్షించండి.
> ఈ '[వైవిధ్యం క్యాల్క్యులేటర్](https://www.calculatorsoup.com/calculators/statistics/variance-calculator.php)' ను ప్రయత్నించి ఈ భావనను మరింత అర్థం చేసుకోండి.
---
## 🚀సవాలు
ఈ నోట్‌బుక్‌తో కొంత సమయం గడపండి, పారామితులను సవరించండి. డేటాను మరింత శుభ్రపరిచి (ఉదాహరణకు అవుట్లయర్స్ తొలగించడం) మోడల్ ఖచ్చితత్వాన్ని మెరుగుపరచగలరా? మీరు కొన్ని డేటా నమూనాలకు ఎక్కువ బరువు ఇవ్వడానికి వెయిట్స్ ఉపయోగించవచ్చు. మరేమి చేయగలరు మంచి క్లస్టర్లు సృష్టించడానికి?
సూచన: మీ డేటాను స్కేల్ చేయడానికి ప్రయత్నించండి. నోట్‌బుక్‌లో కామెంట్ చేసిన కోడ్ ఉంది, ఇది డేటా కాలమ్‌లను పరస్పరం సమాన పరిధిలో ఉండేలా స్టాండర్డ్ స్కేలింగ్ జోడిస్తుంది. మీరు గమనిస్తారు సిల్హౌట్ స్కోర్ తగ్గినా, ఎల్బో గ్రాఫ్‌లో 'కింక్' సాఫీగా మారుతుంది. ఇది డేటాను స్కేల్ చేయకుండా వదిలివేయడం వల్ల తక్కువ వైవిధ్యం ఉన్న డేటాకు ఎక్కువ బరువు వస్తుంది. ఈ సమస్య గురించి మరింత చదవండి [ఇక్కడ](https://stats.stackexchange.com/questions/21222/are-mean-normalization-and-feature-scaling-needed-for-k-means-clustering/21226#21226).
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
K-Means సిమ్యులేటర్‌ను చూడండి [ఇలా ఒకటి](https://user.ceng.metu.edu.tr/~akifakkus/courses/ceng574/k-means/). మీరు ఈ టూల్ ఉపయోగించి నమూనా డేటా పాయింట్లను దృశ్యమానపరచవచ్చు మరియు దాని సెంట్రాయిడ్‌లను నిర్ణయించవచ్చు. మీరు డేటా రాండమ్నెస్, క్లస్టర్ల సంఖ్య మరియు సెంట్రాయిడ్‌ల సంఖ్యను సవరించవచ్చు. ఇది డేటాను ఎలా సమూహీకరించవచ్చో మీకు ఆలోచన ఇస్తుందా?
అలాగే, స్టాన్ఫోర్డ్ నుండి [K-Means పై ఈ హ్యాండౌట్](https://stanford.edu/~cpiech/cs221/handouts/kmeans.html) ను చూడండి.
## అసైన్‌మెంట్
[వేరే క్లస్టరింగ్ పద్ధతులను ప్రయత్నించండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/5-Clustering/2-K-Means/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "b8e17eff34ad1680eba2a5d3cf9ffc41",
"translation_date": "2025-12-19T14:54:15+00:00",
"source_file": "5-Clustering/2-K-Means/assignment.md",
"language_code": "te"
}
-->
# వేరే క్లస్టరింగ్ పద్ధతులను ప్రయత్నించండి
## సూచనలు
ఈ పాఠంలో మీరు K-Means క్లస్టరింగ్ గురించి నేర్చుకున్నారు. కొన్ని సార్లు K-Means మీ డేటాకు అనుకూలంగా ఉండదు. ఈ పాఠాల నుండి లేదా మరేదైనా మూలం నుండి డేటాను ఉపయోగించి (మీ మూలాన్ని సూచించండి) ఒక నోట్‌బుక్ సృష్టించి K-Means ఉపయోగించకుండా వేరే క్లస్టరింగ్ పద్ధతిని చూపండి. మీరు ఏమి నేర్చుకున్నారు?
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | --------------------------------------------------------------- | -------------------------------------------------------------------- | ---------------------------- |
| | బాగా డాక్యుమెంటెడ్ క్లస్టరింగ్ మోడల్‌తో కూడిన నోట్‌బుక్ అందించబడింది | మంచి డాక్యుమెంటేషన్ లేకుండా మరియు/లేదా అసంపూర్ణంగా ఉన్న నోట్‌బుక్ అందించబడింది | అసంపూర్ణ పని సమర్పించబడింది |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

233
translations/te/5-Clustering/2-K-Means/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

17
translations/te/5-Clustering/2-K-Means/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T15:05:25+00:00",
"source_file": "5-Clustering/2-K-Means/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

642
translations/te/5-Clustering/2-K-Means/solution/R/lesson_15-R.ipynb
Unescape View File

@ -0,0 +1,642 @@
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"anaconda-cloud": "",
"kernelspec": {
"display_name": "R",
"language": "R",
"name": "ir"
},
"language_info": {
"codemirror_mode": "r",
"file_extension": ".r",
"mimetype": "text/x-r-source",
"name": "R",
"pygments_lexer": "r",
"version": "3.4.1"
},
"colab": {
"name": "lesson_14.ipynb",
"provenance": [],
"collapsed_sections": [],
"toc_visible": true
},
"coopTranslator": {
"original_hash": "ad65fb4aad0a156b42216e4929f490fc",
"translation_date": "2025-12-19T16:53:53+00:00",
"source_file": "5-Clustering/2-K-Means/solution/R/lesson_15-R.ipynb",
"language_code": "te"
}
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "GULATlQXLXyR"
},
"source": [
"## R మరియు Tidy డేటా సూత్రాలను ఉపయోగించి K-Means క్లస్టరింగ్‌ను అన్వేషించండి.\n",
"\n",
"### [**పూర్వ-లెక్చర్ క్విజ్**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/29/)\n",
"\n",
"ఈ పాఠంలో, మీరు Tidymodels ప్యాకేజీ మరియు R ఎకోసిస్టమ్‌లోని ఇతర ప్యాకేజీలను (మేము వాటిని స్నేహితులు 🧑‍🤝‍🧑 అని పిలుస్తాము) ఉపయోగించి క్లస్టర్లను ఎలా సృష్టించాలో నేర్చుకుంటారు, మరియు మీరు ముందుగా దిగుమతి చేసిన నైజీరియన్ సంగీత డేటాసెట్‌ను ఉపయోగిస్తారు. మేము K-Means క్లస్టరింగ్ యొక్క ప్రాథమిక అంశాలను కవర్ చేస్తాము. మీరు ముందుగా నేర్చుకున్నట్లుగా, క్లస్టర్లతో పని చేయడానికి అనేక మార్గాలు ఉన్నాయి మరియు మీరు ఉపయోగించే పద్ధతి మీ డేటాపై ఆధారపడి ఉంటుంది. K-Means ను ప్రయత్నిస్తాము ఎందుకంటే ఇది అత్యంత సాధారణ క్లస్టరింగ్ సాంకేతికత. మొదలు పెడదాం!\n",
"\n",
"మీరు నేర్చుకునే పదాలు:\n",
"\n",
"- సిల్హౌట్ స్కోరింగ్\n",
"\n",
"- ఎల్బో పద్ధతి\n",
"\n",
"- ఇనర్షియా\n",
"\n",
"- వైవిధ్యం\n",
"\n",
"### **పరిచయం**\n",
"\n",
"[K-Means క్లస్టరింగ్](https://wikipedia.org/wiki/K-means_clustering) సిగ్నల్ ప్రాసెసింగ్ డొమైన్ నుండి ఉద్భవించిన పద్ధతి. ఇది డేటా గుంపులను వారి లక్షణాలలో సారూప్యతల ఆధారంగా `k క్లస్టర్లుగా` విభజించడానికి ఉపయోగిస్తారు.\n",
"\n",
"క్లస్టర్లు [Voronoi డయాగ్రామ్స్](https://wikipedia.org/wiki/Voronoi_diagram) గా దృశ్యమానమవుతాయి, ఇవి ఒక పాయింట్ (లేదా 'సీడ్') మరియు దాని సంబంధిత ప్రాంతాన్ని కలిగి ఉంటాయి.\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/voronoi.1dc1613fb0439b9564615eca8df47a4bcd1ce06217e7e72325d2406ef2180795.te.png\"\n",
" width=\"500\"/>\n",
" <figcaption>ఇన్ఫోగ్రాఫిక్ జెన్ లూపర్ ద్వారా</figcaption>\n",
"\n",
"\n",
"K-Means క్లస్టరింగ్ క్రింది దశలను కలిగి ఉంటుంది:\n",
"\n",
"1. డేటా శాస్త్రవేత్త మొదట సృష్టించవలసిన క్లస్టర్ల సంఖ్యను నిర్దేశిస్తారు.\n",
"\n",
"2. తరువాత, అల్గోరిథం డేటా సెట్ నుండి యాదృచ్ఛికంగా K పరిశీలనలను ఎంపిక చేసి అవి క్లస్టర్ల ప్రారంభ కేంద్రాలుగా (అంటే, సెంట్రాయిడ్లు) ఉపయోగిస్తారు.\n",
"\n",
"3. తరువాత, మిగిలిన ప్రతి పరిశీలనను దాని సమీప సెంట్రాయిడ్‌కు కేటాయిస్తారు.\n",
"\n",
"4. తరువాత, ప్రతి క్లస్టర్ యొక్క కొత్త సగటును లెక్కించి సెంట్రాయిడ్‌ను ఆ సగటుకు తరలిస్తారు.\n",
"\n",
"5. ఇప్పుడు కేంద్రాలు పునః లెక్కించబడ్డాయి, ప్రతి పరిశీలనను మరో క్లస్టర్‌కు సమీపంగా ఉందా అని మళ్లీ తనిఖీ చేస్తారు. అన్ని అంశాలను నవీకరించిన క్లస్టర్ సగటులను ఉపయోగించి మళ్లీ కేటాయిస్తారు. క్లస్టర్ కేటాయింపు మరియు సెంట్రాయిడ్ నవీకరణ దశలను పునరావృతంగా చేస్తారు, క్లస్టర్ కేటాయింపులు మారడం ఆగేవరకు (అంటే, సమీకరణ సాధించబడినప్పుడు). సాధారణంగా, ప్రతి కొత్త పునరావృతం సెంట్రాయిడ్‌ల కదలిక తక్కువగా ఉన్నప్పుడు మరియు క్లస్టర్లు స్థిరంగా ఉన్నప్పుడు అల్గోరిథం ముగుస్తుంది.\n",
"\n",
"<div>\n",
"\n",
"> ప్రారంభ సెంట్రాయిడ్‌లుగా ఉపయోగించే యాదృచ్ఛిక k పరిశీలనల కారణంగా, ప్రతి సారి ఈ ప్రక్రియను అమలు చేసినప్పుడు కొంత భిన్నమైన ఫలితాలు రావచ్చు. అందుకే, ఎక్కువ అల్గోరిథములు అనేక *యాదృచ్ఛిక ప్రారంభాలు* ఉపయోగించి, తక్కువ WCSS ఉన్న పునరావృతాన్ని ఎంచుకుంటాయి. కాబట్టి, *అనుచిత స్థానిక గరిష్ఠాన్ని* నివారించడానికి ఎప్పుడూ K-Means ను అనేక *nstart* విలువలతో నడపడం బలంగా సిఫార్సు చేయబడుతుంది.\n",
"\n",
"</div>\n",
"\n",
"Allison Horst యొక్క [కళాకృతి](https://github.com/allisonhorst/stats-illustrations) ఉపయోగించి ఈ చిన్న యానిమేషన్ క్లస్టరింగ్ ప్రక్రియను వివరిస్తుంది:\n",
"\n",
"<p >\n",
" <img src=\"../../images/kmeans.gif\"\n",
" width=\"550\"/>\n",
" <figcaption>@allison_horst కళాకృతి</figcaption>\n",
"\n",
"\n",
"\n",
"క్లస్టరింగ్‌లో ఉత్పన్నమయ్యే ఒక ప్రాథమిక ప్రశ్న ఇది: మీ డేటాను ఎన్ని క్లస్టర్లుగా విభజించాలో మీరు ఎలా తెలుసుకుంటారు? K-Means ఉపయోగించడంలో ఒక లోపం ఏమిటంటే, మీరు `k` ను, అంటే `సెంట్రాయిడ్‌ల సంఖ్య` ను నిర్ణయించవలసి ఉంటుంది. అదృష్టవశాత్తు `ఎల్బో పద్ధతి` మంచి ప్రారంభ విలువను అంచనా వేయడంలో సహాయపడుతుంది. మీరు దీన్ని కొద్దిసేపట్లో ప్రయత్నిస్తారు.\n",
"\n",
"### \n",
"\n",
"**ముందస్తు అవసరం**\n",
"\n",
"మేము [మునుపటి పాఠం](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/1-Visualize/solution/R/lesson_14-R.ipynb) నుండి ఆపకుండా కొనసాగుతాము, అక్కడ మేము డేటా సెట్‌ను విశ్లేషించి, అనేక దృశ్యీకరణలు చేశాము మరియు ఆసక్తికరమైన పరిశీలనలకు డేటా సెట్‌ను ఫిల్టర్ చేసాము. దాన్ని తప్పకుండా చూడండి!\n",
"\n",
"ఈ మాడ్యూల్‌ను పూర్తి చేయడానికి కొన్ని ప్యాకేజీలు అవసరం. మీరు వాటిని ఇలాగే ఇన్‌స్టాల్ చేసుకోవచ్చు: `install.packages(c('tidyverse', 'tidymodels', 'cluster', 'summarytools', 'plotly', 'paletteer', 'factoextra', 'patchwork'))`\n",
"\n",
"వేరే విధంగా, క్రింది స్క్రిప్ట్ ఈ మాడ్యూల్‌ను పూర్తి చేయడానికి అవసరమైన ప్యాకేజీలు మీ వద్ద ఉన్నాయా లేదా అని తనిఖీ చేసి, కొన్నివి లేకపోతే వాటిని ఇన్‌స్టాల్ చేస్తుంది.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "ah_tBi58LXyi"
},
"source": [
"suppressWarnings(if(!require(\"pacman\")) install.packages(\"pacman\"))\n",
"\n",
"pacman::p_load('tidyverse', 'tidymodels', 'cluster', 'summarytools', 'plotly', 'paletteer', 'factoextra', 'patchwork')\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "7e--UCUTLXym"
},
"source": [
"మనం వెంటనే ప్రారంభిద్దాం!\n",
"\n",
"## 1. డేటాతో నృత్యం: 3 అత్యంత ప్రాచుర్యం పొందిన సంగీత శైలులను తగ్గించుకోండి\n",
"\n",
"ఇది మునుపటి పాఠంలో మనం చేసినదానికి ఒక సారాంశం. మనం కొంత డేటాను కట్ చేసి, విశ్లేషిద్దాం!\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "Ycamx7GGLXyn"
},
"source": [
"# Load the core tidyverse and make it available in your current R session\n",
"library(tidyverse)\n",
"\n",
"# Import the data into a tibble\n",
"df <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/5-Clustering/data/nigerian-songs.csv\", show_col_types = FALSE)\n",
"\n",
"# Narrow down to top 3 popular genres\n",
"nigerian_songs <- df %>% \n",
" # Concentrate on top 3 genres\n",
" filter(artist_top_genre %in% c(\"afro dancehall\", \"afropop\",\"nigerian pop\")) %>% \n",
" # Remove unclassified observations\n",
" filter(popularity != 0)\n",
"\n",
"\n",
"\n",
"# Visualize popular genres using bar plots\n",
"theme_set(theme_light())\n",
"nigerian_songs %>%\n",
" count(artist_top_genre) %>%\n",
" ggplot(mapping = aes(x = artist_top_genre, y = n,\n",
" fill = artist_top_genre)) +\n",
" geom_col(alpha = 0.8) +\n",
" paletteer::scale_fill_paletteer_d(\"ggsci::category10_d3\") +\n",
" ggtitle(\"Top genres\") +\n",
" theme(plot.title = element_text(hjust = 0.5))\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "b5h5zmkPLXyp"
},
"source": [
"🤩 అది బాగానే జరిగింది!\n",
"\n",
"## 2. మరిన్ని డేటా అన్వేషణ.\n",
"\n",
"ఈ డేటా ఎంత శుభ్రంగా ఉంది? బాక్స్ ప్లాట్లను ఉపయోగించి అవుట్లయర్లను తనిఖీ చేద్దాం. మేము తక్కువ అవుట్లయర్లతో ఉన్న సంఖ్యాత్మక కాలమ్స్‌పై దృష్టి సారిస్తాము (అయితే మీరు అవుట్లయర్లను శుభ్రం చేయవచ్చు). బాక్స్‌ప్లాట్లు డేటా పరిధిని చూపగలవు మరియు ఏ కాలమ్స్ ఉపయోగించాలో ఎంచుకోవడంలో సహాయపడతాయి. గమనించండి, బాక్స్‌ప్లాట్లు వ్యత్యాసాన్ని చూపవు, ఇది మంచి క్లస్టరబుల్ డేటా యొక్క ముఖ్యమైన అంశం. మరింత చదవడానికి [ఈ చర్చ](https://stats.stackexchange.com/questions/91536/deduce-variance-from-boxplot) చూడండి.\n",
"\n",
"[బాక్స్‌ప్లాట్లు](https://en.wikipedia.org/wiki/Box_plot) సంఖ్యాత్మక డేటా పంపిణీని గ్రాఫికల్‌గా చూపడానికి ఉపయోగిస్తారు, కాబట్టి ప్రాచుర్యం పొందిన సంగీత శైలులతో పాటు అన్ని సంఖ్యాత్మక కాలమ్స్‌ను *ఎంచుకోవడం* ప్రారంభిద్దాం.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "HhNreJKLLXyq"
},
"source": [
"# Select top genre column and all other numeric columns\n",
"df_numeric <- nigerian_songs %>% \n",
" select(artist_top_genre, where(is.numeric)) \n",
"\n",
"# Display the data\n",
"df_numeric %>% \n",
" slice_head(n = 5)\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "uYXrwJRaLXyq"
},
"source": [
"ఎలా సెలక్షన్ హెల్పర్ `where` దీన్ని సులభం చేస్తుందో చూడండి 💁? ఇలాంటి ఇతర ఫంక్షన్లను [ఇక్కడ](https://tidyselect.r-lib.org/) అన్వేషించండి.\n",
"\n",
"ప్రతి సంఖ్యా లక్షణానికి బాక్స్‌ప్లాట్ తయారు చేయబోతున్నాము మరియు లూప్‌లను ఉపయోగించకుండా ఉండాలనుకుంటున్నాము, కాబట్టి మన డేటాను *దీర్ఘమైన* ఫార్మాట్‌లో పునఃరూపకల్పన చేద్దాం, ఇది మనకు `facets` - ప్రతి ఉపసమితి డేటాను ప్రదర్శించే ఉపగ్రాఫ్‌లను ఉపయోగించుకునే అవకాశం ఇస్తుంది.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "gd5bR3f8LXys"
},
"source": [
"# Pivot data from wide to long\n",
"df_numeric_long <- df_numeric %>% \n",
" pivot_longer(!artist_top_genre, names_to = \"feature_names\", values_to = \"values\") \n",
"\n",
"# Print out data\n",
"df_numeric_long %>% \n",
" slice_head(n = 15)\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "-7tE1swnLXyv"
},
"source": [
"ఇంకా చాలా పొడవుగా! ఇప్పుడు కొంత `ggplots` సమయం! కాబట్టి ఏ `geom` ను ఉపయోగించబోతున్నాం?\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "r88bIsyuLXyy"
},
"source": [
"# Make a box plot\n",
"df_numeric_long %>% \n",
" ggplot(mapping = aes(x = feature_names, y = values, fill = feature_names)) +\n",
" geom_boxplot() +\n",
" facet_wrap(~ feature_names, ncol = 4, scales = \"free\") +\n",
" theme(legend.position = \"none\")\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "EYVyKIUELXyz"
},
"source": [
"Easy-gg!\n",
"\n",
"ఇప్పుడు మనం ఈ డేటా కొంచెం శబ్దంగా ఉందని చూడవచ్చు: ప్రతి కాలమ్‌ను బాక్స్‌ప్లాట్‌గా పరిశీలించడం ద్వారా, మీరు అవుట్లయర్లను చూడవచ్చు. మీరు డేటాసెట్‌ను గమనించి ఈ అవుట్లయర్లను తొలగించవచ్చు, కానీ అది డేటాను చాలా తక్కువగా చేస్తుంది.\n",
"\n",
"ప్రస్తుతం, మనం క్లస్టరింగ్ వ్యాయామం కోసం ఉపయోగించబోయే కాలమ్‌లను ఎంచుకుందాం. సమాన పరిధులున్న సంఖ్యాత్మక కాలమ్‌లను ఎంచుకుందాం. మనం `artist_top_genre` ను సంఖ్యాత్మకంగా ఎన్‌కోడ్ చేయవచ్చు కానీ ఇప్పటికీ దాన్ని వదిలేస్తాము.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "-wkpINyZLXy0"
},
"source": [
"# Select variables with similar ranges\n",
"df_numeric_select <- df_numeric %>% \n",
" select(popularity, danceability, acousticness, loudness, energy) \n",
"\n",
"# Normalize data\n",
"# df_numeric_select <- scale(df_numeric_select)\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "D7dLzgpqLXy1"
},
"source": [
"## 3. R లో k-means క్లస్టరింగ్ లెక్కించడం\n",
"\n",
"మనం R లో బిల్ట్-ఇన్ `kmeans` ఫంక్షన్ తో k-means లెక్కించవచ్చు, చూడండి `help(\"kmeans()\")`. `kmeans()` ఫంక్షన్ ప్రాథమిక ఆర్గ్యుమెంట్ గా అన్ని న్యూమరిక్ కాలమ్స్ ఉన్న డేటా ఫ్రేమ్ ను అంగీకరిస్తుంది.\n",
"\n",
"k-means క్లస్టరింగ్ ఉపయోగించే మొదటి దశ చివరి పరిష్కారంలో ఉత్పత్తి చేయబడే క్లస్టర్ల సంఖ్య (k) ను నిర్దేశించడం. మనం డేటాసెట్ నుండి 3 పాట జానర్లను తీసుకున్నామని తెలుసు, కాబట్టి 3 ను ప్రయత్నిద్దాం:\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "uC4EQ5w7LXy5"
},
"source": [
"set.seed(2056)\n",
"# Kmeans clustering for 3 clusters\n",
"kclust <- kmeans(\n",
" df_numeric_select,\n",
" # Specify the number of clusters\n",
" centers = 3,\n",
" # How many random initial configurations\n",
" nstart = 25\n",
")\n",
"\n",
"# Display clustering object\n",
"kclust\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "hzfhscWrLXy-"
},
"source": [
"kmeans ఆబ్జెక్ట్‌లో `help(\"kmeans()\")` లో బాగా వివరించబడిన అనేక సమాచారం భాగాలు ఉంటాయి. ఇప్పటికీ, కొన్ని విషయాలపై దృష్టి పెట్టుకుందాం. డేటా 65, 110, 111 పరిమాణాల 3 క్లస్టర్లుగా విభజించబడిందని మనం చూస్తున్నాము. అవుట్పుట్‌లో 5 వేరియబుల్స్ అంతటా 3 గ్రూపుల క్లస్టర్ సెంటర్లు (సగటులు) కూడా ఉంటాయి.\n",
"\n",
"క్లస్టరింగ్ వెక్టర్ అనేది ప్రతి పరిశీలనకు క్లస్టర్ కేటాయింపు. అసలు డేటా సెట్‌కు క్లస్టర్ కేటాయింపును జోడించడానికి `augment` ఫంక్షన్‌ను ఉపయోగిద్దాం.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "0XwwpFGQLXy_"
},
"source": [
"# Add predicted cluster assignment to data set\n",
"augment(kclust, df_numeric_select) %>% \n",
" relocate(.cluster) %>% \n",
" slice_head(n = 10)\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "NXIVXXACLXzA"
},
"source": [
"సరే, మనం ఇప్పుడు మన డేటా సెట్‌ను 3 గ్రూపుల సెట్‌గా విభజించాము. కాబట్టి, మన క్లస్టరింగ్ ఎంత మంచిదో చూద్దాం 🤷? మనం `Silhouette score` ని చూద్దాం\n",
"\n",
"### **Silhouette score**\n",
"\n",
"[Silhouette విశ్లేషణ](https://en.wikipedia.org/wiki/Silhouette_(clustering)) ఫలితంగా వచ్చిన క్లస్టర్ల మధ్య విడిపోవడం దూరాన్ని అధ్యయనం చేయడానికి ఉపయోగించవచ్చు. ఈ స్కోరు -1 నుండి 1 వరకు మారుతుంది, మరియు స్కోరు 1కి దగ్గరగా ఉంటే, క్లస్టర్ సాంద్రంగా ఉంటుంది మరియు ఇతర క్లస్టర్ల నుండి బాగా వేరుగా ఉంటుంది. 0కి దగ్గరగా ఉన్న విలువ సమీప క్లస్టర్లతో decision boundaryకి చాలా దగ్గరగా ఉన్న నమూనాలను సూచిస్తుంది.[source](https://dzone.com/articles/kmeans-silhouette-score-explained-with-python-exam).\n",
"\n",
"సగటు silhouette పద్ధతి వివిధ *k* విలువల కోసం పరిశీలనల సగటు silhouetteని లెక్కిస్తుంది. ఒక అధిక సగటు silhouette స్కోరు మంచి క్లస్టరింగ్‌ను సూచిస్తుంది.\n",
"\n",
"సగటు silhouette వెడల్పును లెక్కించడానికి cluster ప్యాకేజీలోని `silhouette` ఫంక్షన్ ఉపయోగించవచ్చు.\n",
"\n",
"> silhouetteని ఏదైనా [distance](https://en.wikipedia.org/wiki/Distance \"Distance\") మెట్రిక్‌తో లెక్కించవచ్చు, ఉదాహరణకు మనం [మునుపటి పాఠంలో](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/1-Visualize/solution/R/lesson_14-R.ipynb) చర్చించిన [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance \"Euclidean distance\") లేదా [Manhattan distance](https://en.wikipedia.org/wiki/Manhattan_distance \"Manhattan distance\") వంటి.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "Jn0McL28LXzB"
},
"source": [
"# Load cluster package\n",
"library(cluster)\n",
"\n",
"# Compute average silhouette score\n",
"ss <- silhouette(kclust$cluster,\n",
" # Compute euclidean distance\n",
" dist = dist(df_numeric_select))\n",
"mean(ss[, 3])\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "QyQRn97nLXzC"
},
"source": [
"మా స్కోరు **.549** ఉంది, కాబట్టి మధ్యలోనే ఉంది. ఇది మా డేటా ఈ రకమైన క్లస్టరింగ్‌కు ప్రత్యేకంగా అనుకూలంగా లేనట్టుగా సూచిస్తుంది. మనం ఈ అనుమానాన్ని దృశ్యరూపంలో నిర్ధారించగలమా చూద్దాం. [factoextra ప్యాకేజ్](https://rpkgs.datanovia.com/factoextra/index.html) క్లస్టరింగ్‌ను దృశ్యీకరించడానికి (`fviz_cluster()`) ఫంక్షన్లను అందిస్తుంది.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "7a6Km1_FLXzD"
},
"source": [
"library(factoextra)\n",
"\n",
"# Visualize clustering results\n",
"fviz_cluster(kclust, df_numeric_select)\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "IBwCWt-0LXzD"
},
"source": [
"క్లస్టర్లలో ఉన్న ఓవర్‌ల్యాప్ మన డేటా ఈ రకమైన క్లస్టరింగ్‌కు ప్రత్యేకంగా అనుకూలంగా లేనట్టుగా సూచిస్తుంది కానీ మనం కొనసాగుదాం.\n",
"\n",
"## 4. ఉత్తమ క్లస్టర్లను నిర్ణయించడం\n",
"\n",
"K-Means క్లస్టరింగ్‌లో తరచుగా ఎదురయ్యే ఒక ప్రాథమిక ప్రశ్న ఇది - తెలియని క్లాస్ లేబుల్స్ లేకుండా, మీరు మీ డేటాను ఎన్ని క్లస్టర్లుగా విడగొట్టాలో ఎలా తెలుసుకుంటారు?\n",
"\n",
"మనం తెలుసుకోవడానికి ప్రయత్నించగల ఒక మార్గం డేటా నమూనాను ఉపయోగించి `క్లస్టర్ల సంఖ్య పెరుగుతూ` (ఉదా: 1-10 వరకు) క్లస్టరింగ్ మోడల్స్ సిరీస్‌ను సృష్టించడం, మరియు **సిల్హౌట్ స్కోర్** వంటి క్లస్టరింగ్ మెట్రిక్స్‌ను మూల్యాంకనం చేయడం.\n",
"\n",
"విభిన్న *k* విలువల కోసం క్లస్టరింగ్ అల్గోరిథమ్‌ను గణించి, **Within Cluster Sum of Squares** (WCSS) ను మూల్యాంకనం చేయడం ద్వారా ఉత్తమ క్లస్టర్ల సంఖ్యను నిర్ణయిద్దాం. మొత్తం వితిన్-క్లస్టర్ సమ్ ఆఫ్ స్క్వేర్ (WCSS) క్లస్టరింగ్ యొక్క సన్నిహితతను కొలుస్తుంది మరియు మనం దీన్ని όσο తక్కువగా ఉండాలని కోరుకుంటాము, తక్కువ విలువలు డేటా పాయింట్లు దగ్గరగా ఉన్నట్లు సూచిస్తాయి.\n",
"\n",
"1 నుండి 10 వరకు `k` యొక్క వివిధ ఎంపికల ప్రభావాన్ని ఈ క్లస్టరింగ్‌పై పరిశీలిద్దాం.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "hSeIiylDLXzE"
},
"source": [
"# Create a series of clustering models\n",
"kclusts <- tibble(k = 1:10) %>% \n",
" # Perform kmeans clustering for 1,2,3 ... ,10 clusters\n",
" mutate(model = map(k, ~ kmeans(df_numeric_select, centers = .x, nstart = 25)),\n",
" # Farm out clustering metrics eg WCSS\n",
" glanced = map(model, ~ glance(.x))) %>% \n",
" unnest(cols = glanced)\n",
" \n",
"\n",
"# View clustering rsulsts\n",
"kclusts\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "m7rS2U1eLXzE"
},
"source": [
"ఇప్పుడు మనకు ప్రతి క్లస్టరింగ్ అల్గోరిథం కోసం సెంటర్ *k* తో మొత్తం వితిన్-క్లస్టర్ సమ్-ఆఫ్-స్క్వేర్ల (tot.withinss) ఉంది, మనం [ఎల్బో పద్ధతి](https://en.wikipedia.org/wiki/Elbow_method_(clustering)) ఉపయోగించి ఆప్టిమల్ క్లస్టర్ల సంఖ్యను కనుగొంటాము. ఈ పద్ధతి క్లస్టర్ల సంఖ్య యొక్క ఫంక్షన్‌గా WCSS ను ప్లాట్ చేయడం మరియు వాడాల్సిన క్లస్టర్ల సంఖ్యగా [వక్ర రేఖ యొక్క ఎల్బో](https://en.wikipedia.org/wiki/Elbow_of_the_curve \"Elbow of the curve\") ను ఎంచుకోవడం కలిగి ఉంటుంది.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "o_DjHGItLXzF"
},
"source": [
"set.seed(2056)\n",
"# Use elbow method to determine optimum number of clusters\n",
"kclusts %>% \n",
" ggplot(mapping = aes(x = k, y = tot.withinss)) +\n",
" geom_line(size = 1.2, alpha = 0.8, color = \"#FF7F0EFF\") +\n",
" geom_point(size = 2, color = \"#FF7F0EFF\")\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "pLYyt5XSLXzG"
},
"source": [
"ప్లాట్ ఒక నుండి రెండు క్లస్టర్లకు సంఖ్య పెరిగినప్పుడు WCSSలో పెద్ద తగ్గుదల (కాబట్టి ఎక్కువ *టైట్‌నెస్*) చూపిస్తుంది, మరియు రెండు నుండి మూడు క్లస్టర్లకు మరింత గమనించదగిన తగ్గుదల ఉంటుంది. ఆ తర్వాత, తగ్గుదల తక్కువగా ఉంటుంది, ఫలితంగా చార్ట్‌లో సుమారు మూడు క్లస్టర్ల వద్ద ఒక `ఎల్బో` 💪 ఉంటుంది. ఇది రెండు నుండి మూడు తగినంతగా వేరు చేసిన డేటా పాయింట్ల క్లస్టర్లు ఉన్నాయని మంచి సూచన.\n",
"\n",
"ఇప్పుడు మనం `k = 3` ఉన్న క్లస్టరింగ్ మోడల్‌ను తీసుకోవచ్చు:\n",
"\n",
"> `pull()`: ఒకే కాలమ్‌ను తీసుకోవడానికి ఉపయోగిస్తారు\n",
">\n",
"> `pluck()`: జాబితాలు వంటి డేటా నిర్మాణాలను సూచించడానికి ఉపయోగిస్తారు\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "JP_JPKBILXzG"
},
"source": [
"# Extract k = 3 clustering\n",
"final_kmeans <- kclusts %>% \n",
" filter(k == 3) %>% \n",
" pull(model) %>% \n",
" pluck(1)\n",
"\n",
"\n",
"final_kmeans\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "l_PDTu8tLXzI"
},
"source": [
"చాలా బాగుంది! మనం పొందిన క్లస్టర్లను దృశ్యీకరించుకుందాం. `plotly` ఉపయోగించి కొంత ఇంటరాక్టివిటీ కావాలా?\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "dNcleFe-LXzJ"
},
"source": [
"# Add predicted cluster assignment to data set\n",
"results <- augment(final_kmeans, df_numeric_select) %>% \n",
" bind_cols(df_numeric %>% select(artist_top_genre)) \n",
"\n",
"# Plot cluster assignments\n",
"clust_plt <- results %>% \n",
" ggplot(mapping = aes(x = popularity, y = danceability, color = .cluster, shape = artist_top_genre)) +\n",
" geom_point(size = 2, alpha = 0.8) +\n",
" paletteer::scale_color_paletteer_d(\"ggthemes::Tableau_10\")\n",
"\n",
"ggplotly(clust_plt)\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "6JUM_51VLXzK"
},
"source": [
"ప్రతి క్లస్టర్ (వివిధ రంగులతో ప్రాతినిధ్యం వహించబడిన) వేర్వేరు జానర్లను (వివిధ ఆకారాలతో ప్రాతినిధ్యం వహించబడిన) కలిగి ఉంటుందని మనం ఆశించవచ్చు.\n",
"\n",
"మోడల్ యొక్క ఖచ్చితత్వాన్ని చూద్దాం.\n"
]
},
{
"cell_type": "code",
"metadata": {
"id": "HdIMUGq7LXzL"
},
"source": [
"# Assign genres to predefined integers\n",
"label_count <- results %>% \n",
" group_by(artist_top_genre) %>% \n",
" mutate(id = cur_group_id()) %>% \n",
" ungroup() %>% \n",
" summarise(correct_labels = sum(.cluster == id))\n",
"\n",
"\n",
"# Print results \n",
"cat(\"Result:\", label_count$correct_labels, \"out of\", nrow(results), \"samples were correctly labeled.\")\n",
"\n",
"cat(\"\\nAccuracy score:\", label_count$correct_labels/nrow(results))\n"
],
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "C50wvaAOLXzM"
},
"source": [
"ఈ మోడల్ యొక్క ఖచ్చితత్వం చెడుగా లేదు, కానీ గొప్పదిగా లేదు. డేటా K-Means క్లస్టరింగ్‌కు బాగా సరిపోవకపోవచ్చు. ఈ డేటా చాలా అసమతుల్యంగా ఉంది, చాలా తక్కువ సంబంధం ఉంది మరియు కాలమ్ విలువల మధ్య చాలా వ్యత్యాసం ఉంది కాబట్టి బాగా క్లస్టర్ చేయడం కష్టం. వాస్తవానికి, ఏర్పడే క్లస్టర్లు పైగా నిర్వచించిన మూడు జానర్ వర్గాల ద్వారా బలంగా ప్రభావితం లేదా వక్రీకృతమయ్యే అవకాశం ఉంది.\n",
"\n",
"అయితే, అది చాలా నేర్చుకునే ప్రక్రియ!\n",
"\n",
"Scikit-learn డాక్యుమెంటేషన్‌లో, మీరు ఇలాంటి మోడల్, క్లస్టర్లు బాగా వేరుగా లేని, 'వేరియన్స్' సమస్యను కలిగి ఉంటుందని చూడవచ్చు:\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/problems.f7fb539ccd80608e1f35c319cf5e3ad1809faa3c08537aead8018c6b5ba2e33a.te.png\"\n",
" width=\"500\"/>\n",
" <figcaption>Scikit-learn నుండి ఇన్ఫోగ్రాఫిక్</figcaption>\n",
"\n",
"\n",
"\n",
"## **వేరియన్స్**\n",
"\n",
"వేరియన్స్ అనేది \"సగటు నుండి చదరపు తేడాల సగటు\"గా నిర్వచించబడింది [మూలం](https://www.mathsisfun.com/data/standard-deviation.html). ఈ క్లస్టరింగ్ సమస్య సందర్భంలో, ఇది మా డేటాసెట్ సంఖ్యలు సగటు నుండి కొంత ఎక్కువగా విభిన్నమవుతాయని సూచిస్తుంది.\n",
"\n",
"✅ ఈ సమస్యను సరిచేయడానికి మీరు చేయగల అన్ని మార్గాల గురించి ఆలోచించడానికి ఇది గొప్ప క్షణం. డేటాను కొంచెం సవరించాలా? వేరే కాలమ్స్ ఉపయోగించాలా? వేరే అల్గోరిథం ఉపయోగించాలా? సూచన: దాన్ని సాధారణీకరించడానికి [మీ డేటాను స్కేల్ చేయడం](https://www.mygreatlearning.com/blog/learning-data-science-with-k-means-clustering/) ప్రయత్నించండి మరియు ఇతర కాలమ్స్‌ను పరీక్షించండి.\n",
"\n",
"> ఈ '[వేరియన్స్ క్యాల్క్యులేటర్](https://www.calculatorsoup.com/calculators/statistics/variance-calculator.php)' ను ప్రయత్నించి ఈ భావనను మరింత అర్థం చేసుకోండి.\n",
"\n",
"------------------------------------------------------------------------\n",
"\n",
"## **🚀సవాలు**\n",
"\n",
"ఈ నోట్‌బుక్‌తో కొంత సమయం గడపండి, పారామితులను సవరించండి. డేటాను మరింత శుభ్రపరచడం ద్వారా (ఉదాహరణకు అవుట్లయర్స్ తొలగించడం) మోడల్ ఖచ్చితత్వాన్ని మెరుగుపరచగలరా? మీరు ఇచ్చిన డేటా నమూనాలకు ఎక్కువ బరువు ఇవ్వడానికి బరువులను ఉపయోగించవచ్చు. మరేమి చేయగలరు మంచి క్లస్టర్లు సృష్టించడానికి?\n",
"\n",
"సూచన: మీ డేటాను స్కేల్ చేయడానికి ప్రయత్నించండి. నోట్‌బుక్‌లో కామెంట్ చేసిన కోడ్ ఉంది, ఇది డేటా కాలమ్స్‌ను పరస్పరం పరిధి పరంగా మరింత సమానంగా చేయడానికి స్టాండర్డ్ స్కేలింగ్‌ను జోడిస్తుంది. సిల్హౌట్ స్కోరు తగ్గినప్పటికీ, ఎల్బో గ్రాఫ్‌లో 'కింక్' సాఫీగా మారుతుంది. ఇది డేటాను స్కేల్ చేయకుండా వదిలివేయడం వల్ల తక్కువ వేరియన్స్ ఉన్న డేటాకు ఎక్కువ బరువు కలుగుతుందని సూచిస్తుంది. ఈ సమస్యపై మరింత చదవండి [ఇక్కడ](https://stats.stackexchange.com/questions/21222/are-mean-normalization-and-feature-scaling-needed-for-k-means-clustering/21226#21226).\n",
"\n",
"## [**పోస్ట్-లెక్చర్ క్విజ్**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/30/)\n",
"\n",
"## **సమీక్ష & స్వీయ అధ్యయనం**\n",
"\n",
"- K-Means సిమ్యులేటర్‌ను [ఇలా ఒకటి](https://user.ceng.metu.edu.tr/~akifakkus/courses/ceng574/k-means/) చూడండి. మీరు ఈ టూల్‌ను ఉపయోగించి నమూనా డేటా పాయింట్లను విజువలైజ్ చేసి దాని సెంట్రాయిడ్లను నిర్ణయించవచ్చు. మీరు డేటా రాండమ్నెస్, క్లస్టర్ల సంఖ్య మరియు సెంట్రాయిడ్ల సంఖ్యను సవరించవచ్చు. ఇది డేటాను ఎలా గ్రూప్ చేయవచ్చో మీకు ఆలోచన ఇస్తుందా?\n",
"\n",
"- అలాగే, స్టాన్ఫోర్డ్ నుండి [K-Means పై ఈ హ్యాండౌట్](https://stanford.edu/~cpiech/cs221/handouts/kmeans.html) చూడండి.\n",
"\n",
"మీరు కొత్తగా పొందిన క్లస్టరింగ్ నైపుణ్యాలను K-Means క్లస్టరింగ్‌కు బాగా సరిపోయే డేటా సెట్‌లపై ప్రయత్నించాలనుకుంటున్నారా? దయచేసి చూడండి:\n",
"\n",
"- [ట్రైన్ మరియు క్లస్టరింగ్ మోడల్స్‌ను మూల్యాంకనం చేయండి](https://rpubs.com/eR_ic/clustering) Tidymodels మరియు స్నేహితులతో\n",
"\n",
"- [K-means క్లస్టర్ విశ్లేషణ](https://uc-r.github.io/kmeans_clustering), UC బిజినెస్ అనలిటిక్స్ R ప్రోగ్రామింగ్ గైడ్\n",
"\n",
"- [tidy డేటా సూత్రాలతో K-means క్లస్టరింగ్](https://www.tidymodels.org/learn/statistics/k-means/)\n",
"\n",
"## **అసైన్‌మెంట్**\n",
"\n",
"[వేరే క్లస్టరింగ్ పద్ధతులను ప్రయత్నించండి](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/2-K-Means/assignment.md)\n",
"\n",
"## ధన్యవాదాలు:\n",
"\n",
"[జెన్ లూపర్](https://www.twitter.com/jenlooper) ఈ మాడ్యూల్ యొక్క అసలు Python వెర్షన్ సృష్టించినందుకు ♥️\n",
"\n",
"[`అలిసన్ హోర్స్ట్`](https://twitter.com/allison_horst/) R ను మరింత ఆహ్లాదకరంగా మరియు ఆకర్షణీయంగా చేసే అద్భుతమైన చిత్రణలను సృష్టించినందుకు. ఆమె [గ్యాలరీ](https://www.google.com/url?q=https://github.com/allisonhorst/stats-illustrations&sa=D&source=editors&ust=1626380772530000&usg=AOvVaw3zcfyCizFQZpkSLzxiiQEM)లో మరిన్ని చిత్రణలను చూడండి.\n",
"\n",
"సంతోషకరమైన అభ్యాసం,\n",
"\n",
"[ఎరిక్](https://twitter.com/ericntay), గోల్డ్ మైక్రోసాఫ్ట్ లెర్న్ స్టూడెంట్ అంబాసిడర్.\n",
"\n",
"<p >\n",
" <img src=\"../../../../../../translated_images/r_learners_sm.e4a71b113ffbedfe727048ec69741a9295954195d8761c35c46f20277de5f684.te.jpeg\"\n",
" width=\"500\"/>\n",
" <figcaption>@allison_horst చేత కళాకృతి</figcaption>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

554
translations/te/5-Clustering/2-K-Means/solution/notebook.ipynb
View File

File diff suppressed because one or more lines are too long

345
translations/te/5-Clustering/2-K-Means/solution/tester.ipynb
View File

File diff suppressed because one or more lines are too long

44
translations/te/5-Clustering/README.md
Unescape View File

@ -0,0 +1,44 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "b28a3a4911584062772c537b653ebbc7",
"translation_date": "2025-12-19T13:03:53+00:00",
"source_file": "5-Clustering/README.md",
"language_code": "te"
}
-->
# మెషీన్ లెర్నింగ్ కోసం క్లస్టరింగ్ మోడల్స్
క్లస్టరింగ్ అనేది ఒక మెషీన్ లెర్నింగ్ పని, ఇందులో ఒకదానితో మరొకటి పోలిక ఉన్న వస్తువులను కనుగొని వాటిని క్లస్టర్లు అని పిలవబడే సమూహాలలో గుంపు చేస్తుంది. మెషీన్ లెర్నింగ్‌లో ఇతర పద్ధతుల నుండి క్లస్టరింగ్ వేరుగా ఉండేది ఏమిటంటే, ఇది ఆటోమేటిక్‌గా జరుగుతుంది, వాస్తవానికి, ఇది సూపర్వైజ్డ్ లెర్నింగ్‌కు వ్యతిరేకంగా ఉంటుంది అని చెప్పవచ్చు.
## ప్రాంతీయ విషయం: నైజీరియన్ ప్రేక్షకుల సంగీత రుచికి క్లస్టరింగ్ మోడల్స్ 🎧
నైజీరియాలోని విభిన్న ప్రేక్షకులు విభిన్న సంగీత రుచులు కలిగి ఉన్నారు. Spotify నుండి సేకరించిన డేటాను ఉపయోగించి ([ఈ ఆర్టికల్](https://towardsdatascience.com/country-wise-visual-analysis-of-music-taste-using-spotify-api-seaborn-in-python-77f5b749b421) నుండి ప్రేరణ పొందిన), నైజీరియాలో ప్రాచుర్యం పొందిన కొన్ని సంగీతాలను చూద్దాం. ఈ డేటాసెట్‌లో వివిధ పాటల 'డాన్స్‌బిలిటీ' స్కోరు, 'అకౌస్టిక్‌నెస్', లౌడ్నెస్, 'స్పీచినెస్', ప్రాచుర్యం మరియు ఎనర్జీ గురించి డేటా ఉంది. ఈ డేటాలో నమూనాలను కనుగొనడం ఆసక్తికరం!
![A turntable](../../../translated_images/turntable.f2b86b13c53302dc106aa741de9dc96ac372864cf458dd6f879119857aab01da.te.jpg)
> ఫోటో <a href="https://unsplash.com/@marcelalaskoski?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">మార్సెలా లాస్కోస్కి</a> ద్వారా <a href="https://unsplash.com/s/photos/nigerian-music?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">అన్స్ప్లాష్</a>లో
ఈ పాఠమాల సిరీస్‌లో, మీరు క్లస్టరింగ్ సాంకేతికతలను ఉపయోగించి డేటాను విశ్లేషించే కొత్త మార్గాలను కనుగొంటారు. క్లస్టరింగ్ ప్రత్యేకంగా ఉపయోగకరంగా ఉంటుంది, మీ డేటాసెట్‌లో లేబుల్స్ లేకపోతే. లేబుల్స్ ఉంటే, మీరు గత పాఠాలలో నేర్చుకున్న వర్గీకరణ సాంకేతికతలు మరింత ఉపయోగకరంగా ఉండవచ్చు. కానీ లేబుల్స్ లేని డేటాను గుంపు చేయాలనుకుంటే, క్లస్టరింగ్ నమూనాలను కనుగొనడానికి గొప్ప మార్గం.
> క్లస్టరింగ్ మోడల్స్‌తో పని చేయడం నేర్చుకోవడానికి సహాయపడే ఉపయోగకరమైన లో-కోడ్ టూల్స్ ఉన్నాయి. ఈ పనికి [Azure ML ను ప్రయత్నించండి](https://docs.microsoft.com/learn/modules/create-clustering-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
## పాఠాలు
1. [క్లస్టరింగ్ పరిచయం](1-Visualize/README.md)
2. [కె-మీన్స్ క్లస్టరింగ్](2-K-Means/README.md)
## క్రెడిట్స్
ఈ పాఠాలు 🎶 [జెన్ లూపర్](https://www.twitter.com/jenlooper) ద్వారా రాయబడ్డాయి, సహాయక సమీక్షలతో [రిషిత్ దాగ్లీ](https://rishit_dagli) మరియు [ముహమ్మద్ సకీబ్ ఖాన్ ఇనాన్](https://twitter.com/Sakibinan).
[Nigerian Songs](https://www.kaggle.com/sootersaalu/nigerian-songs-spotify) డేటాసెట్ Spotify నుండి స్క్రాప్ చేసి Kaggle నుండి పొందబడింది.
ఈ పాఠం సృష్టించడంలో సహాయపడిన ఉపయోగకరమైన కె-మీన్స్ ఉదాహరణలు ఈ [ఐరిస్ అన్వేషణ](https://www.kaggle.com/bburns/iris-exploration-pca-k-means-and-gmm-clustering), ఈ [పరిచయ నోట్బుక్](https://www.kaggle.com/prashant111/k-means-clustering-with-python), మరియు ఈ [హైపోథెటికల్ NGO ఉదాహరణ](https://www.kaggle.com/ankandash/pca-k-means-clustering-hierarchical-clustering) ఉన్నాయి.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకం వల్ల కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల బాధ్యత మేము తీసుకోము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

181
translations/te/6-NLP/1-Introduction-to-NLP/README.md
Unescape View File

@ -0,0 +1,181 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1c2ec40cf55c98a028a359c27ef7e45a",
"translation_date": "2025-12-19T14:26:28+00:00",
"source_file": "6-NLP/1-Introduction-to-NLP/README.md",
"language_code": "te"
}
-->
# సహజ భాషా ప్రాసెసింగ్ పరిచయం
ఈ పాఠం *సహజ భాషా ప్రాసెసింగ్* యొక్క సంక్షిప్త చరిత్ర మరియు ముఖ్యమైన భావనలను కవర్ చేస్తుంది, ఇది *కంప్యూటేషనల్ లింగ్విస్టిక్స్* యొక్క ఉపశాఖ.
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## పరిచయం
NLP, సాధారణంగా పిలవబడేది, యంత్ర అభ్యాసం అన్వయించబడిన మరియు ఉత్పత్తి సాఫ్ట్‌వేర్‌లో ఉపయోగించిన అత్యంత ప్రసిద్ధ ప్రాంతాలలో ఒకటి.
✅ మీరు ప్రతిరోజూ ఉపయోగించే సాఫ్ట్‌వేర్‌లో ఏదైనా NLP ఎంబెడ్డెడ్ ఉన్నదని మీరు అనుకుంటున్నారా? మీ వర్డ్ ప్రాసెసింగ్ ప్రోగ్రాములు లేదా మీరు తరచుగా ఉపయోగించే మొబైల్ యాప్స్ గురించి ఏమిటి?
మీరు నేర్చుకునే విషయాలు:
- **భాషల ఆలోచన**. భాషలు ఎలా అభివృద్ధి చెందాయో మరియు ప్రధాన అధ్యయన ప్రాంతాలు ఏమిటో.
- **నిర్వచన మరియు భావనలు**. కంప్యూటర్లు టెక్స్ట్‌ను ఎలా ప్రాసెస్ చేస్తాయో, పార్సింగ్, వ్యాకరణం, నామవాచకాలు మరియు క్రియలను గుర్తించడం వంటి నిర్వచనాలు మరియు భావనలు మీరు నేర్చుకుంటారు. ఈ పాఠంలో కొన్ని కోడింగ్ పనులు ఉన్నాయి, మరియు మీరు తర్వాతి పాఠాలలో కోడ్ చేయడం నేర్చుకునే కొన్ని ముఖ్యమైన భావనలు పరిచయం చేయబడ్డాయి.
## కంప్యూటేషనల్ లింగ్విస్టిక్స్
కంప్యూటేషనల్ లింగ్విస్టిక్స్ అనేది అనేక దశాబ్దాలుగా పరిశోధన మరియు అభివృద్ధి చేసే ఒక విభాగం, ఇది కంప్యూటర్లు భాషలతో ఎలా పని చేయగలవో, అర్థం చేసుకోగలవో, అనువదించగలవో మరియు సంభాషించగలవో అధ్యయనం చేస్తుంది. సహజ భాషా ప్రాసెసింగ్ (NLP) అనేది సంబంధిత రంగం, ఇది కంప్యూటర్లు 'సహజ' లేదా మానవ భాషలను ఎలా ప్రాసెస్ చేయగలవో పై దృష్టి సారిస్తుంది.
### ఉదాహరణ - ఫోన్ డిక్టేషన్
మీరు ఎప్పుడైనా టైప్ చేయకుండా మీ ఫోన్‌కు డిక్టేట్ చేసినట్లయితే లేదా వర్చువల్ అసిస్టెంట్‌కు ప్రశ్న అడిగితే, మీ మాటలను టెక్స్ట్ రూపంలోకి మార్చి, మీరు మాట్లాడిన భాష నుండి ప్రాసెస్ లేదా *పార్స్* చేయబడింది. గుర్తించిన కీలకపదాలు ఫోన్ లేదా అసిస్టెంట్ అర్థం చేసుకుని చర్య తీసుకునే ఫార్మాట్‌లో ప్రాసెస్ చేయబడ్డాయి.
![comprehension](../../../../translated_images/comprehension.619708fc5959b0f6a24ebffba2ad7b0625391a476141df65b43b59de24e45c6f.te.png)
> నిజమైన భాషా అవగాహన కష్టం! చిత్రం [జెన్ లూపర్](https://twitter.com/jenlooper) ద్వారా
### ఈ సాంకేతికత ఎలా సాధ్యమైంది?
ఇది సాధ్యమైంది ఎందుకంటే ఎవరో ఒకరు ఈ పని చేయడానికి కంప్యూటర్ ప్రోగ్రామ్ రాశారు. కొన్ని దశాబ్దాల క్రితం, కొన్ని సైన్స్ ఫిక్షన్ రచయితలు ప్రజలు ఎక్కువగా తమ కంప్యూటర్లతో మాట్లాడతారని, మరియు కంప్యూటర్లు ఎప్పుడూ వారు అర్థం చేసుకున్నారని ఊహించారు. దురదృష్టవశాత్తు, ఇది అనుకున్నదానికంటే కష్టం అని తేలింది, మరియు ఇది ఈ రోజు చాలా బాగా అర్థం చేసుకున్న సమస్య అయినప్పటికీ, వాక్య అర్థం అర్థం చేసుకోవడంలో 'పర్ఫెక్ట్' సహజ భాషా ప్రాసెసింగ్ సాధించడంలో గణనీయమైన సవాళ్లు ఉన్నాయి. ఇది హాస్యం అర్థం చేసుకోవడంలో లేదా వాక్యంలో వ్యంగ్య భావనలను గుర్తించడంలో ప్రత్యేకంగా కష్టం.
ఈ సమయంలో, మీరు పాఠశాల తరగతులను గుర్తు చేసుకుంటున్నారా, అక్కడ ఉపాధ్యాయుడు వాక్యంలోని వ్యాకరణ భాగాలను కవర్ చేశారు. కొన్ని దేశాలలో, విద్యార్థులకు వ్యాకరణం మరియు లింగ్విస్టిక్స్ ప్రత్యేక విషయంగా బోధించబడుతుంది, కానీ చాలా చోట్ల ఈ విషయాలు భాష నేర్చుకునే భాగంగా ఉంటాయి: మీ మొదటి భాష ప్రాథమిక పాఠశాలలో (చదవడం మరియు రాయడం నేర్చుకోవడం) మరియు రెండవ భాష పోస్ట్-ప్రాథమిక లేదా హై స్కూల్‌లో. నామవాచకాలు, క్రియలు లేదా క్రియావిశేషణాలు, విశేషణాలు మధ్య తేడా తెలియకపోయినా ఆందోళన చెందకండి!
*సింపుల్ ప్రెజెంట్* మరియు *ప్రెజెంట్ ప్రోగ్రెసివ్* మధ్య తేడా మీకు క్లిష్టంగా ఉంటే, మీరు ఒంటరిగా లేరు. ఇది చాలా మందికి, భాష స్థానిక వక్తలకు కూడా కష్టం. మంచి విషయం ఏమిటంటే, కంప్యూటర్లు ఫార్మల్ నియమాలను అమలు చేయడంలో చాలా మంచి, మరియు మీరు ఒక వాక్యాన్ని మానవుడిలా *పార్స్* చేయగల కోడ్ రాయడం నేర్చుకుంటారు. మీరు తర్వాత పరిశీలించే పెద్ద సవాలు వాక్య *అర్థం* మరియు *భావం* అర్థం చేసుకోవడమే.
## ముందస్తు అవసరాలు
ఈ పాఠం కోసం, ప్రధాన ముందస్తు అవసరం ఈ పాఠం భాషను చదవడం మరియు అర్థం చేసుకోవడం. ఎటువంటి గణిత సమస్యలు లేదా సమీకరణాలు పరిష్కరించాల్సిన అవసరం లేదు. అసలు రచయిత ఈ పాఠాన్ని ఇంగ్లీష్‌లో రాశారు, కానీ ఇది ఇతర భాషలలో కూడా అనువదించబడింది, కాబట్టి మీరు అనువాదం చదువుతున్నట్లయితే కూడా సరే. వివిధ భాషల వ్యాకరణ నియమాలను పోల్చడానికి కొన్ని ఉదాహరణలు ఉన్నాయి. అవి *అనువదించబడవు*, కానీ వివరణాత్మక వచనం అనువదించబడింది, కాబట్టి అర్థం స్పష్టంగా ఉంటుంది.
కోడింగ్ పనుల కోసం, మీరు Python ఉపయోగిస్తారు మరియు ఉదాహరణలు Python 3.8 ఉపయోగిస్తున్నాయి.
ఈ విభాగంలో, మీరు అవసరం మరియు ఉపయోగిస్తారు:
- **Python 3 అవగాహన**. Python 3లో ప్రోగ్రామింగ్ భాష అవగాహన, ఈ పాఠం ఇన్‌పుట్, లూప్స్, ఫైల్ రీడింగ్, అర్రేస్ ఉపయోగిస్తుంది.
- **Visual Studio Code + ఎక్స్‌టెన్షన్**. మేము Visual Studio Code మరియు దాని Python ఎక్స్‌టెన్షన్ ఉపయోగిస్తాము. మీరు మీ ఇష్టమైన Python IDE కూడా ఉపయోగించవచ్చు.
- **TextBlob**. [TextBlob](https://github.com/sloria/TextBlob) అనేది Python కోసం సరళీకృత టెక్స్ట్ ప్రాసెసింగ్ లైబ్రరీ. TextBlob సైట్‌లో సూచనలను అనుసరించి మీ సిస్టమ్‌లో ఇన్‌స్టాల్ చేయండి (కోర్పోరా కూడా ఇన్‌స్టాల్ చేయండి, క్రింద చూపినట్లుగా):
```bash
pip install -U textblob
python -m textblob.download_corpora
```
> 💡 సూచన: మీరు VS Code వాతావరణాల్లో నేరుగా Python నడపవచ్చు. మరిన్ని సమాచారం కోసం [డాక్స్](https://code.visualstudio.com/docs/languages/python?WT.mc_id=academic-77952-leestott) చూడండి.
## యంత్రాలతో మాట్లాడటం
కంప్యూటర్లు మానవ భాషను అర్థం చేసుకోవడానికి ప్రయత్నించిన చరిత్ర అనేక దశాబ్దాలుగా ఉంది, మరియు సహజ భాషా ప్రాసెసింగ్‌ను పరిశీలించిన మొదటి శాస్త్రవేత్తలలో ఒకరు *అలన్ ట్యూరింగ్*.
### 'ట్యూరింగ్ టెస్ట్'
1950లలో ట్యూరింగ్ *కృత్రిమ మేధస్సు* పరిశోధన చేస్తున్నప్పుడు, ఒక సంభాషణ పరీక్షను మానవుడు మరియు కంప్యూటర్ (టైప్ చేసిన లేఖల ద్వారా) మధ్య ఇవ్వవచ్చా అని పరిశీలించాడు, అందులో సంభాషణలో ఉన్న మానవుడు మరొక మానవుడితోనా లేక కంప్యూటర్‌తోనా మాట్లాడుతున్నాడో తెలియకపోవచ్చు.
ఒక నిర్దిష్ట సంభాషణ తర్వాత, మానవుడు సమాధానాలు కంప్యూటర్ నుండి వచ్చాయో లేదో నిర్ణయించలేకపోతే, ఆ కంప్యూటర్ *ఆలోచిస్తున్నదని* చెప్పవచ్చా?
### ప్రేరణ - 'నకిలీ ఆట'
ఈ ఆలోచన ఒక పార్టీ ఆట నుండి వచ్చింది, దీనిని *ది ఇమిటేషన్ గేమ్* అంటారు, ఇందులో ఒక విచారణకర్త ఒక గదిలో ఒంటరిగా ఉంటాడు మరియు మరో గదిలో ఉన్న ఇద్దరు వ్యక్తులలో ఎవరు పురుషుడు మరియు ఎవరు మహిళ అని నిర్ణయించాలి. విచారణకర్త గమనికలు పంపవచ్చు, మరియు రహస్య వ్యక్తి లింగాన్ని వెల్లడించే విధంగా రాసిన సమాధానాలను తెలుసుకునే ప్రశ్నలు ఆలోచించాలి. ఖచ్చితంగా, మరొక గదిలో ఉన్న ఆటగాళ్లు విచారణకర్తను మోసం చేయడానికి లేదా గందరగోళం చేయడానికి ప్రయత్నిస్తారు, కానీ నిజాయితీగా సమాధానం ఇస్తున్నట్లు కనిపించాలి.
### ఎలిజా అభివృద్ధి
1960లలో MIT శాస్త్రవేత్త *జోసెఫ్ వైజెన్‌బౌమ్* [*ఎలిజా*](https://wikipedia.org/wiki/ELIZA) అనే కంప్యూటర్ 'థెరపిస్ట్'ను అభివృద్ధి చేశారు, ఇది మానవుడిని ప్రశ్నించి వారి సమాధానాలను అర్థం చేసుకున్నట్లు కనిపించేది. అయితే, ఎలిజా ఒక వాక్యాన్ని పార్స్ చేసి కొన్ని వ్యాకరణ నిర్మాణాలు మరియు కీలకపదాలను గుర్తించి సరైన సమాధానం ఇవ్వగలిగింది, కానీ వాక్యాన్ని *అర్థం చేసుకుంది* అని చెప్పలేము. ఎలిజాకు "**నేను** <u>దుఃఖంగా ఉన్నాను</u>" అనే వాక్యం ఇచ్చినప్పుడు, అది వాక్యాన్ని పునఃసంఘటించి "మీరు ఎంతకాలంగా <u>దుఃఖంగా ఉన్నారు</u>" అని ప్రతిస్పందించవచ్చు.
ఇది ఎలిజా ఆ వాక్యాన్ని అర్థం చేసుకుని తదుపరి ప్రశ్న అడుగుతున్నట్లు అనిపించేది, కానీ వాస్తవానికి అది కాలాన్ని మార్చి కొన్ని పదాలు జోడించడం మాత్రమే. ఎలిజా గుర్తించని కీలకపదానికి సమాధానం లేకపోతే, అది అనేక వాక్యాలకు వర్తించే యాదృచ్ఛిక సమాధానం ఇస్తుంది. ఎలిజాను సులభంగా మోసం చేయవచ్చు, ఉదాహరణకు ఒక వినియోగదారు "**మీరు** ఒక <u>సైకిల్</u>" అని రాసినప్పుడు, అది "నేను ఎంతకాలంగా ఒక <u>సైకిల్</u>ను?" అని ప్రతిస్పందించవచ్చు, బదులుగా తగిన సమాధానం ఇవ్వకుండా.
[![ఎలిజాతో చాట్](https://img.youtube.com/vi/RMK9AphfLco/0.jpg)](https://youtu.be/RMK9AphfLco "ఎలిజాతో చాట్")
> 🎥 పై చిత్రాన్ని క్లిక్ చేసి అసలు ELIZA ప్రోగ్రామ్ గురించి వీడియో చూడండి
> గమనిక: మీరు 1966లో ప్రచురించిన [ఎలిజా](https://cacm.acm.org/magazines/1966/1/13317-elizaa-computer-program-for-the-study-of-natural-language-communication-between-man-and-machine/abstract) అసలు వివరణను చదవవచ్చు, మీకు ACM ఖాతా ఉంటే. లేకపోతే, ఎలిజా గురించి [వికీపీడియా](https://wikipedia.org/wiki/ELIZA)లో చదవండి.
## వ్యాయామం - ప్రాథమిక సంభాషణ బాట్ కోడింగ్
ఎలిజా లాంటి సంభాషణ బాట్ అనేది వినియోగదారుల ఇన్‌పుట్‌ను పొందే, అర్థం చేసుకున్నట్లు మరియు తెలివిగా స్పందించే ప్రోగ్రామ్. ఎలిజా లాగా, మా బాట్‌కు తెలివైన సంభాషణ ఉన్నట్లు కనిపించే అనేక నియమాలు ఉండవు. బదులుగా, మా బాట్‌కు ఒకే సామర్థ్యం ఉంటుంది, అది ఏదైనా సాధారణ సంభాషణలో పనిచేసే యాదృచ్ఛిక సమాధానాలతో సంభాషణ కొనసాగించడం.
### ప్రణాళిక
సంభాషణ బాట్ నిర్మాణంలో మీ దశలు:
1. వినియోగదారుని బాట్‌తో ఎలా మాట్లాడాలో సూచనలు ముద్రించండి
2. లూప్ ప్రారంభించండి
1. వినియోగదారుని ఇన్‌పుట్ స్వీకరించండి
2. వినియోగదారు ఎగ్జిట్ అడిగితే, బయటకు రండి
3. వినియోగదారుని ఇన్‌పుట్‌ను ప్రాసెస్ చేసి సమాధానం నిర్ణయించండి (ఈ సందర్భంలో, సమాధానం సాధారణ సమాధానాల జాబితా నుండి యాదృచ్ఛిక ఎంపిక)
4. సమాధానం ముద్రించండి
3. దశ 2కి తిరిగి లూప్ చేయండి
### బాట్ నిర్మాణం
ఇప్పుడు బాట్‌ను సృష్టిద్దాం. కొన్ని వాక్యాలను నిర్వచించడం ప్రారంభిద్దాం.
1. ఈ బాట్‌ను Pythonలో క్రింది యాదృచ్ఛిక సమాధానాలతో మీరే సృష్టించండి:
```python
random_responses = ["That is quite interesting, please tell me more.",
"I see. Do go on.",
"Why do you say that?",
"Funny weather we've been having, isn't it?",
"Let's change the subject.",
"Did you catch the game last night?"]
```
మీకు మార్గనిర్దేశం చేయడానికి కొన్ని నమూనా అవుట్పుట్ (వినియోగదారుని ఇన్‌పుట్ `>` తో ప్రారంభమయ్యే లైన్లలో ఉంటుంది):
```output
Hello, I am Marvin, the simple robot.
You can end this conversation at any time by typing 'bye'
After typing each answer, press 'enter'
How are you today?
> I am good thanks
That is quite interesting, please tell me more.
> today I went for a walk
Did you catch the game last night?
> I did, but my team lost
Funny weather we've been having, isn't it?
> yes but I hope next week is better
Let's change the subject.
> ok, lets talk about music
Why do you say that?
> because I like music!
Why do you say that?
> bye
It was nice talking to you, goodbye!
```
ఈ పనికి ఒక సాధ్యమైన పరిష్కారం [ఇక్కడ](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/1-Introduction-to-NLP/solution/bot.py)
✅ ఆగి ఆలోచించండి
1. యాదృచ్ఛిక సమాధానాలు ఎవరికైనా బాట్ నిజంగా అర్థం చేసుకున్నట్లు 'మోసం' చేయగలవని మీరు అనుకుంటున్నారా?
2. బాట్ మరింత సమర్థవంతంగా ఉండేందుకు ఏ లక్షణాలు అవసరం?
3. ఒక బాట్ వాక్య అర్థం నిజంగా 'అర్థం చేసుకుంటే', అది సంభాషణలో గత వాక్యాల అర్థాన్ని కూడా 'మరచిపోకుండా' ఉంచాల్సి ఉంటుందా?
---
## 🚀సవాలు
పై "ఆగి ఆలోచించండి" అంశాలలో ఒకదాన్ని ఎంచుకుని, దాన్ని కోడ్‌లో అమలు చేయడానికి ప్రయత్నించండి లేదా పేపర్‌పై ప్సూడోకోడ్ ఉపయోగించి పరిష్కారం రాయండి.
తర్వాతి పాఠంలో, సహజ భాషను పార్స్ చేయడానికి మరియు యంత్ర అభ్యాసానికి అనేక ఇతర విధానాలను మీరు నేర్చుకుంటారు.
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
క్రింద ఇచ్చిన సూచనలను మరింత చదవడానికి అవకాశాలుగా చూడండి.
### సూచనలు
1. షుబెర్ట్, లెన్హార్ట్, "కంప్యూటేషనల్ లింగ్విస్టిక్స్", *ది స్టాన్ఫర్డ్ ఎన్‌సైక్లోపీడియా ఆఫ్ ఫిలాసఫీ* (స్ప్రింగ్ 2020 ఎడిషన్), ఎడ్వర్డ్ ఎన్. జాల్టా (ఎడిటర్), URL = <https://plato.stanford.edu/archives/spr2020/entries/computational-linguistics/>.
2. ప్రిన్స్టన్ యూనివర్సిటీ "వర్డ్‌నెట్ గురించి." [WordNet](https://wordnet.princeton.edu/). ప్రిన్స్టన్ యూనివర్సిటీ. 2010.
## అసైన్‌మెంట్
[బాట్ కోసం శోధించండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/6-NLP/1-Introduction-to-NLP/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "1d7583e8046dacbb0c056d5ba0a71b16",
"translation_date": "2025-12-19T14:30:35+00:00",
"source_file": "6-NLP/1-Introduction-to-NLP/assignment.md",
"language_code": "te"
}
-->
# బాట్ కోసం శోధించండి
## సూచనలు
బాట్లు ఎక్కడా ఉన్నారు. మీ పని: ఒకటిని కనుగొని దాన్ని దత్తత తీసుకోండి! మీరు వాటిని వెబ్ సైట్లలో, బ్యాంకింగ్ అప్లికేషన్లలో, మరియు ఫోన్‌లో కూడా కనుగొనవచ్చు, ఉదాహరణకు మీరు ఆర్థిక సేవల కంపెనీలను సలహా లేదా ఖాతా సమాచారం కోసం కాల్ చేసినప్పుడు. బాట్‌ను విశ్లేషించి మీరు దాన్ని గందరగోళపరచగలరా అని చూడండి. మీరు బాట్‌ను గందరగోళపరచగలిగితే, అది ఎందుకు జరిగిందని మీరు భావిస్తున్నారు? మీ అనుభవం గురించి ఒక చిన్న పత్రాన్ని రాయండి.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైన | సరిపడిన | మెరుగుదల అవసరం |
| -------- | ------------------------------------------------------------------------------------------------------------- | -------------------------------------------- | --------------------- |
| | ఒక పూర్తి పేజీ పత్రం రాయబడింది, అనుమానిత బాట్ నిర్మాణాన్ని వివరించి, దాని అనుభవాన్ని వివరించింది | పత్రం అసంపూర్ణంగా లేదా బాగా పరిశోధించబడలేదు | పత్రం సమర్పించబడలేదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలో ఉన్నది అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

230
translations/te/6-NLP/2-Tasks/README.md
Unescape View File

@ -0,0 +1,230 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "5f3cb462e3122e1afe7ab0050ccf2bd3",
"translation_date": "2025-12-19T14:32:08+00:00",
"source_file": "6-NLP/2-Tasks/README.md",
"language_code": "te"
}
-->
# సాధారణ సహజ భాషా ప్రాసెసింగ్ పనులు మరియు సాంకేతికతలు
అధిక భాగం *సహజ భాషా ప్రాసెసింగ్* పనుల కోసం, ప్రాసెస్ చేయవలసిన టెక్స్ట్‌ను విభజించి, పరిశీలించి, ఫలితాలను నియమాలు మరియు డేటా సెట్‌లతో నిల్వ చేయాలి లేదా క్రాస్ రిఫరెన్స్ చేయాలి. ఈ పనులు, ప్రోగ్రామర్‌కు టెక్స్ట్‌లోని పదాలు మరియు పదబంధాల యొక్క _అర్థం_ లేదా _ఉద్దేశ్యం_ లేదా కేవలం _సాంద్రత_ ను పొందడానికి సహాయపడతాయి.
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
టెక్స్ట్ ప్రాసెసింగ్‌లో ఉపయోగించే సాధారణ సాంకేతికతలను తెలుసుకుందాం. మెషీన్ లెర్నింగ్‌తో కలిపితే, ఈ సాంకేతికతలు పెద్ద మొత్తంలో టెక్స్ట్‌ను సమర్థవంతంగా విశ్లేషించడంలో సహాయపడతాయి. అయితే, ఈ పనులకు ML వర్తింపజేయకముందు, NLP నిపుణుడు ఎదుర్కొనే సమస్యలను అర్థం చేసుకుందాం.
## NLPకి సాధారణమైన పనులు
మీరు పని చేస్తున్న టెక్స్ట్‌ను విశ్లేషించడానికి వివిధ మార్గాలు ఉన్నాయి. మీరు చేయగల పనులు ఉన్నాయి, మరియు ఈ పనుల ద్వారా మీరు టెక్స్ట్‌ను అర్థం చేసుకుని నిర్ణయాలు తీసుకోవచ్చు. మీరు సాధారణంగా ఈ పనులను ఒక క్రమంలో నిర్వహిస్తారు.
### టోకనైజేషన్
బహుశా చాలా NLP అల్గోరిథమ్స్ మొదట చేయవలసిన పని టెక్స్ట్‌ను టోకెన్స్ లేదా పదాలుగా విభజించడం. ఇది సులభంగా అనిపించినప్పటికీ, విరామ చిహ్నాలు మరియు వివిధ భాషల పదాలు, వాక్య విభజనలను పరిగణలోకి తీసుకోవడం కష్టంగా ఉంటుంది. మీరు విభజనలను నిర్ణయించడానికి వివిధ పద్ధతులు ఉపయోగించవలసి ఉంటుంది.
![tokenization](../../../../translated_images/tokenization.1641a160c66cd2d93d4524e8114e93158a9ce0eba3ecf117bae318e8a6ad3487.te.png)
> **Pride and Prejudice** నుండి ఒక వాక్యాన్ని టోకనైజ్ చేయడం. ఇన్ఫోగ్రాఫిక్ [Jen Looper](https://twitter.com/jenlooper) ద్వారా
### ఎంబెడ్డింగ్స్
[పద ఎంబెడ్డింగ్స్](https://wikipedia.org/wiki/Word_embedding) అనేవి మీ టెక్స్ట్ డేటాను సంఖ్యలుగా మార్చే ఒక విధానం. ఎంబెడ్డింగ్స్ అలా చేయబడతాయి, అర్థం సమానమైన లేదా కలిసి ఉపయోగించే పదాలు సమీపంగా క్లస్టర్ అవుతాయి.
![word embeddings](../../../../translated_images/embedding.2cf8953c4b3101d188c2f61a5de5b6f53caaa5ad4ed99236d42bc3b6bd6a1fe2.te.png)
> "నేను మీ నర్వ్స్‌కు అత్యంత గౌరవం కలిగి ఉన్నాను, అవి నా పాత స్నేహితులు." - **Pride and Prejudice** లో ఒక వాక్యానికి పద ఎంబెడ్డింగ్స్. ఇన్ఫోగ్రాఫిక్ [Jen Looper](https://twitter.com/jenlooper) ద్వారా
✅ పద ఎంబెడ్డింగ్స్‌తో ప్రయోగించడానికి [ఈ ఆసక్తికరమైన టూల్](https://projector.tensorflow.org/) ను ప్రయత్నించండి. ఒక పదాన్ని క్లిక్ చేస్తే సమానమైన పదాల క్లస్టర్లు చూపబడతాయి: 'toy' క్లస్టర్‌లో 'disney', 'lego', 'playstation', మరియు 'console' ఉన్నాయి.
### పార్సింగ్ & పార్ట్-ఆఫ్-స్పీచ్ ట్యాగింగ్
ప్రతి టోకనైజ్ చేసిన పదాన్ని భాగంగా ట్యాగ్ చేయవచ్చు - నామవాచకం, క్రియ, లేదా విశేషణం. వాక్యం `the quick red fox jumped over the lazy brown dog` లో fox = నామవాచకం, jumped = క్రియ అని POS ట్యాగ్ చేయవచ్చు.
![parsing](../../../../translated_images/parse.d0c5bbe1106eae8fe7d60a183cd1736c8b6cec907f38000366535f84f3036101.te.png)
> **Pride and Prejudice** నుండి ఒక వాక్యాన్ని పార్స్ చేయడం. ఇన్ఫోగ్రాఫిక్ [Jen Looper](https://twitter.com/jenlooper) ద్వారా
పార్సింగ్ అనేది వాక్యంలో ఏ పదాలు పరస్పరం సంబంధం ఉన్నాయో గుర్తించడం - ఉదాహరణకు `the quick red fox jumped` అనేది ఒక విశేషణ-నామవాచకం-క్రియ క్రమం, ఇది `lazy brown dog` క్రమం నుండి వేరుగా ఉంటుంది.
### పదాలు మరియు పదబంధాల సాంద్రతలు
పెద్ద టెక్స్ట్‌ను విశ్లేషించేటప్పుడు ఉపయోగకరమైన ప్రక్రియ ప్రతి పదం లేదా ఆసక్తి ఉన్న పదబంధం మరియు అవి ఎంతసార్లు కనిపిస్తాయో ఒక నిఘంటువు తయారు చేయడం. వాక్యం `the quick red fox jumped over the lazy brown dog` లో the పదానికి సాంద్రత 2.
పదాల సాంద్రతను లెక్కించే ఉదాహరణ టెక్స్ట్ చూద్దాం. రుడ్యార్డ్ కిప్లింగ్ కవిత "The Winners" లో ఈ కవితా శ్లోకం ఉంది:
```output
What the moral? Who rides may read.
When the night is thick and the tracks are blind
A friend at a pinch is a friend, indeed,
But a fool to wait for the laggard behind.
Down to Gehenna or up to the Throne,
He travels the fastest who travels alone.
```
పదబంధాల సాంద్రతలు అవసరమైతే కేస్ ఇన్సెన్సిటివ్ లేదా కేస్ సెన్సిటివ్ కావచ్చు, ఉదాహరణకు `a friend` కు సాంద్రత 2, `the` కు 6, మరియు `travels` కు 2.
### ఎన్-గ్రామ్స్
ఒక టెక్స్ట్‌ను ఒక నిర్దిష్ట పొడవు కలిగిన పదాల క్రమాలుగా విభజించవచ్చు, ఒక పదం (యూనిగ్రామ్), రెండు పదాలు (బిగ్రామ్), మూడు పదాలు (ట్రైగ్రామ్) లేదా ఏ సంఖ్యలో పదాలు (ఎన్-గ్రామ్స్).
ఉదాహరణకు `the quick red fox jumped over the lazy brown dog` ను ఎన్-గ్రామ్ స్కోర్ 2తో విభజిస్తే ఈ క్రింది ఎన్-గ్రామ్స్ వస్తాయి:
1. the quick
2. quick red
3. red fox
4. fox jumped
5. jumped over
6. over the
7. the lazy
8. lazy brown
9. brown dog
ఇది వాక్యం మీద స్లైడింగ్ బాక్స్ లాగా ఊహించవచ్చు. ఇక్కడ 3 పదాల ఎన్-గ్రామ్స్ కోసం, ప్రతి వాక్యంలో ఎన్-గ్రామ్ బోల్డ్‌లో ఉంది:
1. <u>**the quick red**</u> fox jumped over the lazy brown dog
2. the **<u>quick red fox</u>** jumped over the lazy brown dog
3. the quick **<u>red fox jumped</u>** over the lazy brown dog
4. the quick red **<u>fox jumped over</u>** the lazy brown dog
5. the quick red fox **<u>jumped over the</u>** lazy brown dog
6. the quick red fox jumped **<u>over the lazy</u>** brown dog
7. the quick red fox jumped over <u>**the lazy brown**</u> dog
8. the quick red fox jumped over the **<u>lazy brown dog</u>**
![n-grams sliding window](../../../../6-NLP/2-Tasks/images/n-grams.gif)
> ఎన్-గ్రామ్ విలువ 3: ఇన్ఫోగ్రాఫిక్ [Jen Looper](https://twitter.com/jenlooper) ద్వారా
### నామవాచక పదబంధం తీసివేత
చాలా వాక్యాలలో, ఒక నామవాచకం ఉంటుంది, అది వాక్యపు విషయం లేదా కర్మ. ఆంగ్లంలో, అది తరచుగా 'a' లేదా 'an' లేదా 'the' ముందు ఉండటం ద్వారా గుర్తించవచ్చు. వాక్య అర్థం అర్థం చేసుకోవడానికి 'నామవాచక పదబంధం తీసివేత' ఒక సాధారణ NLP పని.
✅ "I cannot fix on the hour, or the spot, or the look or the words, which laid the foundation. It is too long ago. I was in the middle before I knew that I had begun." వాక్యంలో నామవాచక పదబంధాలను గుర్తించగలరా?
వాక్యం `the quick red fox jumped over the lazy brown dog` లో 2 నామవాచక పదబంధాలు ఉన్నాయి: **quick red fox** మరియు **lazy brown dog**.
### భావ విశ్లేషణ
ఒక వాక్యం లేదా టెక్స్ట్ భావానికి విశ్లేషించవచ్చు, అది ఎంత *ధనాత్మక* లేదా *నెగటివ్* అనేది. భావం *పోలారిటీ* మరియు *వస్తునిష్ఠత/వ్యక్తిగతత* లో కొలవబడుతుంది. పోలారిటీ -1.0 నుండి 1.0 వరకు (నెగటివ్ నుండి పాజిటివ్) మరియు 0.0 నుండి 1.0 వరకు (అత్యంత వస్తునిష్ఠ నుండి అత్యంత వ్యక్తిగత) కొలవబడుతుంది.
✅ తర్వాత మీరు మెషీన్ లెర్నింగ్ ఉపయోగించి భావాన్ని నిర్ణయించే వివిధ మార్గాలు నేర్చుకుంటారు, కానీ ఒక మార్గం అంటే మానవ నిపుణుడు పాజిటివ్ లేదా నెగటివ్‌గా వర్గీకరించిన పదాలు మరియు పదబంధాల జాబితాను కలిగి ఉండటం మరియు ఆ మోడల్‌ను టెక్స్ట్‌పై వర్తింపజేసి పోలారిటీ స్కోర్ లెక్కించడం. కొన్ని సందర్భాల్లో ఇది ఎలా పనిచేస్తుందో, మరికొన్ని సందర్భాల్లో తక్కువగా ఎలా పనిచేస్తుందో మీరు చూడగలరా?
### రూపాంతరం
రూపాంతరం ద్వారా మీరు ఒక పదాన్ని singular లేదా plural రూపంలో పొందవచ్చు.
### లెమటైజేషన్
*లెమ్మా* అనేది పదాల సమూహానికి మూలం లేదా ప్రధాన పదం, ఉదాహరణకు *flew*, *flies*, *flying* కు క్రియ *fly* అనే లెమ్మా ఉంటుంది.
NLP పరిశోధకులకు ఉపయోగకరమైన డేటాబేస్‌లు కూడా ఉన్నాయి, ముఖ్యంగా:
### WordNet
[WordNet](https://wordnet.princeton.edu/) అనేది పదాలు, సమానార్థకాలు, విరుద్ధార్థకాలు మరియు అనేక ఇతర వివరాల డేటాబేస్, అనేక భాషలలో ప్రతి పదానికి. ఇది అనువాదాలు, స్పెల్ చెకర్లు లేదా ఏ రకమైన భాషా సాధనాలు తయారు చేయడంలో చాలా ఉపయోగకరం.
## NLP లైబ్రరీలు
సంతోషకరం, మీరు ఈ సాంకేతికతలన్నింటినీ స్వయంగా నిర్మించాల్సిన అవసరం లేదు, ఎందుకంటే సహజ భాషా ప్రాసెసింగ్ లేదా మెషీన్ లెర్నింగ్‌లో ప్రత్యేకత లేని డెవలపర్లకు చాలా సులభంగా ఉండే అద్భుతమైన Python లైబ్రరీలు అందుబాటులో ఉన్నాయి. తదుపరి పాఠాలలో వీటి మరిన్ని ఉదాహరణలు ఉంటాయి, కానీ ఇక్కడ మీరు తదుపరి పనికి సహాయపడే కొన్ని ఉపయోగకరమైన ఉదాహరణలను నేర్చుకుంటారు.
### వ్యాయామం - `TextBlob` లైబ్రరీ ఉపయోగించడం
ఈ రకమైన పనులను ఎదుర్కొనేందుకు సహాయపడే APIలు కలిగిన TextBlob అనే లైబ్రరీని ఉపయోగిద్దాం. TextBlob "పెద్ద [NLTK](https://nltk.org) మరియు [pattern](https://github.com/clips/pattern) పై ఆధారపడి, రెండింటితో బాగా పనిచేస్తుంది." దీని APIలో చాలా ML కూడా ఉంది.
> గమనిక: TextBlob కోసం ఒక ఉపయోగకరమైన [క్విక్ స్టార్ట్](https://textblob.readthedocs.io/en/dev/quickstart.html#quickstart) గైడ్ ఉంది, ఇది అనుభవజ్ఞులైన Python డెవలపర్లకు సిఫార్సు చేయబడింది
*నామవాచక పదబంధాలను* గుర్తించేటప్పుడు, TextBlob అనేక ఎక్స్‌ట్రాక్టర్ల ఎంపికలను అందిస్తుంది.
1. `ConllExtractor` ను పరిశీలించండి.
```python
from textblob import TextBlob
from textblob.np_extractors import ConllExtractor
# దిగుమతి చేసుకుని తర్వాత ఉపయోగించడానికి Conll ఎక్స్‌ట్రాక్టర్ సృష్టించండి
extractor = ConllExtractor()
# తర్వాత మీరు నామవాచక పదబంధ ఎక్స్‌ట్రాక్టర్ అవసరం ఉన్నప్పుడు:
user_input = input("> ")
user_input_blob = TextBlob(user_input, np_extractor=extractor) # డిఫాల్ట్ కాని ఎక్స్‌ట్రాక్టర్ పేర్కొనబడింది అని గమనించండి
np = user_input_blob.noun_phrases
```
> ఇక్కడ ఏమి జరుగుతోంది? [ConllExtractor](https://textblob.readthedocs.io/en/dev/api_reference.html?highlight=Conll#textblob.en.np_extractors.ConllExtractor) అనేది "ConLL-2000 శిక్షణ కార్పస్‌తో శిక్షణ పొందిన చంక్ పార్సింగ్ ఉపయోగించే నామవాచక పదబంధ ఎక్స్‌ట్రాక్టర్." ConLL-2000 అనేది 2000లో జరిగిన సహజ భాషా లెర్నింగ్ పై సదస్సు. ప్రతి సంవత్సరం ఈ సదస్సు ఒక క్లిష్టమైన NLP సమస్యను పరిష్కరించడానికి వర్క్‌షాప్ నిర్వహించేది, 2000లో అది నామ చంకింగ్. వాల్ స్ట్రీట్ జర్నల్‌పై శిక్షణ పొందిన మోడల్, "సెక్షన్లు 15-18 శిక్షణ డేటాగా (211727 టోకెన్స్) మరియు సెక్షన్ 20 పరీక్ష డేటాగా (47377 టోకెన్స్)" ఉపయోగించబడింది. మీరు ఉపయోగించిన విధానాలను [ఇక్కడ](https://www.clips.uantwerpen.be/conll2000/chunking/) మరియు ఫలితాలను [ఇక్కడ](https://ifarm.nl/erikt/research/np-chunking.html) చూడవచ్చు.
### సవాలు - NLPతో మీ బాట్‌ను మెరుగుపరచడం
మునుపటి పాఠంలో మీరు చాలా సులభమైన Q&A బాట్‌ను నిర్మించారు. ఇప్పుడు, మీరు మీ ఇన్‌పుట్‌ను భావ విశ్లేషణ కోసం విశ్లేషించి, భావానికి సరిపోయే ప్రతిస్పందనను ముద్రించి, మరింత అనుకూలంగా మారుస్తారు. మీరు `noun_phrase` ను గుర్తించి దాని గురించి మరిన్ని ఇన్‌పుట్ అడగాలి.
మంచి సంభాషణ బాట్‌ను నిర్మించే మీ దశలు:
1. బాట్‌తో ఎలా సంభాషించాలో వినియోగదారుని సూచనలు ముద్రించండి
2. లూప్ ప్రారంభించండి
1. వినియోగదారుని ఇన్‌పుట్ స్వీకరించండి
2. వినియోగదారు ఎగ్జిట్ అడిగితే, ఎగ్జిట్ అవ్వండి
3. వినియోగదారుని ఇన్‌పుట్‌ను ప్రాసెస్ చేసి సరైన భావ ప్రతిస్పందన నిర్ణయించండి
4. భావంలో noun phrase గుర్తించబడితే, దాన్ని బహువచనంలో మార్చి ఆ విషయం గురించి మరిన్ని ఇన్‌పుట్ అడగండి
5. ప్రతిస్పందన ముద్రించండి
3. దశ 2కి తిరిగి లూప్ చేయండి
TextBlob ఉపయోగించి భావాన్ని నిర్ణయించే కోడ్ స్నిపెట్ ఇక్కడ ఉంది. నాలుగు *గ్రేడియెంట్లు* మాత్రమే ఉన్నాయి (మీకు కావాలంటే మరిన్ని ఉండవచ్చు):
```python
if user_input_blob.polarity <= -0.5:
response = "Oh dear, that sounds bad. "
elif user_input_blob.polarity <= 0:
response = "Hmm, that's not great. "
elif user_input_blob.polarity <= 0.5:
response = "Well, that sounds positive. "
elif user_input_blob.polarity <= 1:
response = "Wow, that sounds great. "
```
మీకు మార్గదర్శకంగా కొన్ని నమూనా అవుట్పుట్ ఇక్కడ ఉన్నాయి (వినియోగదారుని ఇన్‌పుట్ > తో ప్రారంభమయ్యే లైన్లలో ఉంది):
```output
Hello, I am Marvin, the friendly robot.
You can end this conversation at any time by typing 'bye'
After typing each answer, press 'enter'
How are you today?
> I am ok
Well, that sounds positive. Can you tell me more?
> I went for a walk and saw a lovely cat
Well, that sounds positive. Can you tell me more about lovely cats?
> cats are the best. But I also have a cool dog
Wow, that sounds great. Can you tell me more about cool dogs?
> I have an old hounddog but he is sick
Hmm, that's not great. Can you tell me more about old hounddogs?
> bye
It was nice talking to you, goodbye!
```
ఈ పనికి ఒక సాధ్యమైన పరిష్కారం [ఇక్కడ](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/2-Tasks/solution/bot.py) ఉంది
✅ జ్ఞాన పరీక్ష
1. అనుకూలమైన ప్రతిస్పందనలు బాట్ నిజంగా అర్థం చేసుకున్నట్లు ఎవరికైనా 'మోసం' చేయగలవా?
2. నామవాచక పదబంధం గుర్తించడం బాట్‌ను మరింత 'నమ్మదగినది' గా చేస్తుందా?
3. వాక్యం నుండి 'నామవాచక పదబంధం' తీసివేత చేయడం ఎందుకు ఉపయోగకరం?
---
మునుపటి జ్ఞాన పరీక్షలో బాట్‌ను అమలు చేసి మిత్రుడిపై పరీక్షించండి. అది వారిని మోసం చేయగలదా? మీరు మీ బాట్‌ను మరింత 'నమ్మదగినది' గా మార్చగలరా?
## 🚀సవాలు
మునుపటి జ్ఞాన పరీక్షలోని ఒక పనిని తీసుకుని దాన్ని అమలు చేయండి. బాట్‌ను మిత్రుడిపై పరీక్షించండి. అది వారిని మోసం చేయగలదా? మీరు మీ బాట్‌ను మరింత 'నమ్మదగినది' గా మార్చగలరా?
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
తదుపరి కొన్ని పాఠాలలో మీరు భావ విశ్లేషణ గురించి మరింత నేర్చుకుంటారు. ఈ ఆసక్తికర సాంకేతికతను [KDNuggets](https://www.kdnuggets.com/tag/nlp) వంటి వ్యాసాలలో పరిశోధించండి
## అసైన్‌మెంట్
[బాట్‌ను మాట్లాడించండి](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/6-NLP/2-Tasks/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "2efc4c2aba5ed06c780c05539c492ae3",
"translation_date": "2025-12-19T14:36:20+00:00",
"source_file": "6-NLP/2-Tasks/assignment.md",
"language_code": "te"
}
-->
# ఒక బాట్ తిరిగి మాట్లాడించండి
## సూచనలు
గత కొన్ని పాఠాలలో, మీరు చాట్ చేయడానికి ఒక ప్రాథమిక బాట్‌ను ప్రోగ్రామ్ చేసారు. ఈ బాట్ మీరు 'bye' అనేవరకు యాదృచ్ఛిక సమాధానాలు ఇస్తుంది. మీరు సమాధానాలను కొంచెం తక్కువ యాదృచ్ఛికంగా చేయగలరా, మరియు మీరు 'why' లేదా 'how' వంటి ప్రత్యేక విషయాలు చెప్పినప్పుడు సమాధానాలు ప్రేరేపించగలరా? మీరు మీ బాట్‌ను విస్తరించేటప్పుడు ఈ రకమైన పనిని తక్కువ మాన్యువల్‌గా చేయడానికి మెషీన్ లెర్నింగ్ ఎలా సహాయపడుతుందో కొంచెం ఆలోచించండి. మీ పనులను సులభతరం చేయడానికి మీరు NLTK లేదా TextBlob లైబ్రరీలను ఉపయోగించవచ్చు.
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైనది | సరిపడినది | మెరుగుదల అవసరం |
| -------- | --------------------------------------------- | ------------------------------------------------ | ----------------------- |
| | ఒక కొత్త bot.py ఫైల్ అందించబడింది మరియు డాక్యుమెంటేషన్ చేయబడింది | ఒక కొత్త బాట్ ఫైల్ అందించబడింది కానీ దానిలో బగ్స్ ఉన్నాయి | ఫైల్ అందించబడలేదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

202
translations/te/6-NLP/3-Translation-Sentiment/README.md
Unescape View File

@ -0,0 +1,202 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "be03c8182982b87ced155e4e9d1438e8",
"translation_date": "2025-12-19T14:15:39+00:00",
"source_file": "6-NLP/3-Translation-Sentiment/README.md",
"language_code": "te"
}
-->
# అనువాదం మరియు భావ విశ్లేషణ ML తో
మునుపటి పాఠాలలో మీరు `TextBlob` ఉపయోగించి ఒక ప్రాథమిక బాట్‌ను ఎలా నిర్మించాలో నేర్చుకున్నారు, ఇది MLని వెనుకనుంచి చేర్చి ప్రాథమిక NLP పనులను, ఉదాహరణకు నామవాచక పదబంధాల వెలికితీయడం వంటి పనులను చేస్తుంది. కంప్యూటేషనల్ లింగ్విస్టిక్స్‌లో మరో ముఖ్యమైన సవాలు ఒక వాక్యాన్ని ఒక మాట్లాడే లేదా రాసే భాష నుండి మరొక భాషకు ఖచ్చితంగా _అనువదించడం_.
## [పాఠం ముందు క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
అనువాదం చాలా కష్టం, ఎందుకంటే వేలాది భాషలు ఉన్నాయి మరియు ప్రతి భాషకు చాలా భిన్నమైన వ్యాకరణ నియమాలు ఉండవచ్చు. ఒక దృష్టికోణం ఒక భాష, ఉదాహరణకు ఇంగ్లీష్, యొక్క ఫార్మల్ వ్యాకరణ నియమాలను భాషాపరమైన ఆధారపడని నిర్మాణంగా మార్చడం, ఆపై మరొక భాషకు తిరిగి మార్చడం ద్వారా అనువదించడం. ఈ దృష్టికోణం మీరు ఈ క్రింది దశలను తీసుకోవాలని సూచిస్తుంది:
1. **గుర్తింపు**. ఇన్‌పుట్ భాషలోని పదాలను నామవాచకాలు, క్రియలు మొదలైన వాటిగా గుర్తించడం లేదా ట్యాగ్ చేయడం.
2. **అనువాదం సృష్టించడం**. లక్ష్య భాష ఫార్మాట్‌లో ప్రతి పదానికి ప్రత్యక్ష అనువాదం చేయడం.
### ఉదాహరణ వాక్యం, ఇంగ్లీష్ నుండి ఐరిష్
'ఇంగ్లీష్'లో, వాక్యం _I feel happy_ మూడు పదాలతో ఈ క్రమంలో ఉంటుంది:
- **విషయం** (I)
- **క్రియా** (feel)
- **విశేషణం** (happy)
కానీ, 'ఐరిష్' భాషలో అదే వాక్యం చాలా భిన్నమైన వ్యాకరణ నిర్మాణం కలిగి ఉంటుంది - "*happy*" లేదా "*sad*" వంటి భావాలు మీపై *ఉన్నట్లు* వ్యక్తం చేయబడతాయి.
ఇంగ్లీష్ పదబంధం `I feel happy` ఐరిష్‌లో `Tá athas orm` అవుతుంది. ఒక *నిజమైన* అనువాదం `Happy is upon me` అవుతుంది.
ఐరిష్ మాట్లాడేవారు ఇంగ్లీష్‌కు అనువదిస్తే `I feel happy` అంటారు, `Happy is upon me` కాదు, ఎందుకంటే వారు వాక్యార్థాన్ని అర్థం చేసుకుంటారు, పదాలు మరియు వాక్య నిర్మాణం వేరు అయినా.
ఐరిష్‌లో వాక్యానికి ఫార్మల్ క్రమం:
- **క్రియా** (Tá లేదా is)
- **విశేషణం** (athas, లేదా happy)
- **విషయం** (orm, లేదా upon me)
## అనువాదం
సాధారణ అనువాద ప్రోగ్రామ్ పదాలను మాత్రమే అనువదించి, వాక్య నిర్మాణాన్ని పక్కన పెట్టవచ్చు.
✅ మీరు పెద్దవయసులో రెండో (లేదా మూడో లేదా మరిన్ని) భాష నేర్చుకున్నట్లయితే, మీరు మొదట మీ స్వదేశీ భాషలో ఆలోచించి, ఆ భావాన్ని పదం పదంగా రెండో భాషలో అనువదించి, ఆ అనువాదాన్ని మాట్లాడటం మొదలుపెట్టినట్లే ఉంటుంది. ఇది సాధారణ అనువాద కంప్యూటర్ ప్రోగ్రాములు చేస్తున్న దానికి సమానంగా ఉంటుంది. మీరు ఈ దశను దాటిపోవడం ముఖ్యం, తద్వారా ప్రవాహం సాధించవచ్చు!
సాధారణ అనువాదం చెడ్డ (మరియు కొన్నిసార్లు హాస్యాస్పద) తప్పు అనువాదాలకు దారితీస్తుంది: `I feel happy` ఐరిష్‌లో నేరుగా అనువదిస్తే `Mise bhraitheann athas` అవుతుంది. దీని అర్థం (నేరుగా) `me feel happy` మరియు ఇది సరైన ఐరిష్ వాక్యం కాదు. ఇంగ్లీష్ మరియు ఐరిష్ రెండు సమీప ద్వీపాలలో మాట్లాడే భాషలు అయినప్పటికీ, అవి చాలా భిన్నమైన వ్యాకరణ నిర్మాణాలు కలిగి ఉంటాయి.
> మీరు ఐరిష్ భాషా సంప్రదాయాల గురించి కొన్ని వీడియోలు చూడవచ్చు, ఉదాహరణకు [ఇది](https://www.youtube.com/watch?v=mRIaLSdRMMs)
### మెషీన్ లెర్నింగ్ దృష్టికోణాలు
ఇప్పటివరకు, మీరు సహజ భాషా ప్రాసెసింగ్‌కు ఫార్మల్ నియమాల దృష్టికోణం గురించి నేర్చుకున్నారు. మరో దృష్టికోణం పదాల అర్థాన్ని పక్కన పెట్టి, _మెషీన్ లెర్నింగ్ ఉపయోగించి నమూనాలను గుర్తించడం_. ఇది అనువాదంలో పనిచేస్తుంది, మీరు మూలం మరియు లక్ష్య భాషలలో చాలా టెక్స్ట్‌లు (ఒక *కోర్పస్* లేదా *కోర్పోరా*) కలిగి ఉంటే.
ఉదాహరణకు, 1813లో జేన్ ఆస్టెన్ రాసిన ప్రసిద్ధ ఇంగ్లీష్ నవల *Pride and Prejudice* ను పరిగణించండి. మీరు ఆ పుస్తకాన్ని ఇంగ్లీష్‌లో మరియు ఫ్రెంచ్‌లో మానవ అనువాదంతో చూసినప్పుడు, ఒక భాషలో ఉన్న పదబంధాలు మరొక భాషలో _సాంప్రదాయాత్మకంగా_ అనువదించబడ్డాయని గుర్తించవచ్చు. మీరు దీన్ని కొద్దిసేపట్లో చేస్తారు.
ఉదాహరణకు, ఇంగ్లీష్ పదబంధం `I have no money` ను ఫ్రెంచ్‌కు నేరుగా అనువదిస్తే, అది `Je n'ai pas de monnaie` అవుతుంది. "Monnaie" అనేది ఒక క్లిష్టమైన ఫ్రెంచ్ 'తప్పు సారూప్యం' (false cognate), ఎందుకంటే 'money' మరియు 'monnaie' సమానార్థకాలు కావు. మానవుడు చేసే మంచి అనువాదం `Je n'ai pas d'argent` అవుతుంది, ఎందుకంటే ఇది మీరు డబ్బు లేనట్టుగా అర్థం చెప్పడంలో మెరుగ్గా ఉంటుంది (మరియు 'monnaie' అర్థం 'చిన్న నాణేలు').
![monnaie](../../../../translated_images/monnaie.606c5fa8369d5c3b3031ef0713e2069485c87985dd475cd9056bdf4c76c1f4b8.te.png)
> చిత్రం [Jen Looper](https://twitter.com/jenlooper) ద్వారా
ఒక ML మోడల్‌కు మానవ అనువాదాలు చాలానే ఉంటే, అది రెండు భాషల నిపుణులచే ముందుగా అనువదించబడిన టెక్స్ట్‌లలో సాధారణ నమూనాలను గుర్తించి అనువాద ఖచ్చితత్వాన్ని మెరుగుపరచవచ్చు.
### వ్యాయామం - అనువాదం
మీరు వాక్యాలను అనువదించడానికి `TextBlob` ఉపయోగించవచ్చు. ప్రసిద్ధ **Pride and Prejudice** మొదటి వాక్యాన్ని ప్రయత్నించండి:
```python
from textblob import TextBlob
blob = TextBlob(
"It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want of a wife!"
)
print(blob.translate(to="fr"))
```
`TextBlob` అనువాదంలో మంచి పనితనం చూపిస్తుంది: "C'est une vérité universellement reconnue, qu'un homme célibataire en possession d'une bonne fortune doit avoir besoin d'une femme!".
వాస్తవానికి, TextBlob అనువాదం 1932లో V. Leconte మరియు Ch. Pressoir చేసిన ఫ్రెంచ్ అనువాదం కంటే చాలా ఖచ్చితంగా ఉండవచ్చు:
"C'est une vérité universelle qu'un célibataire pourvu d'une belle fortune doit avoir envie de se marier, et, si peu que l'on sache de son sentiment à cet egard, lorsqu'il arrive dans une nouvelle résidence, cette idée est si bien fixée dans l'esprit de ses voisins qu'ils le considèrent sur-le-champ comme la propriété légitime de l'une ou l'autre de leurs filles."
ఈ సందర్భంలో, ML ఆధారిత అనువాదం మానవ అనువాదకుడి కంటే మెరుగ్గా పనిచేస్తుంది, ఎందుకంటే మానవుడు అసలు రచయిత మాటల్లో అవసరంలేని పదాలను చేర్చాడు 'స్పష్టత' కోసం.
> ఇది ఏమిటి? మరియు TextBlob అనువాదం ఎందుకు అంత మంచి? వెనుకనుంచి, ఇది Google translate ఉపయోగిస్తుంది, ఇది లక్షలాది పదబంధాలను విశ్లేషించి ఉత్తమ స్ట్రింగ్స్‌ను అంచనా వేయగల సాంకేతిక AI. ఇక్కడ ఏ మానవీయ చర్య లేదు మరియు `blob.translate` ఉపయోగించడానికి ఇంటర్నెట్ కనెక్షన్ అవసరం.
✅ మరికొన్ని వాక్యాలు ప్రయత్నించండి. ఏది మెరుగ్గా ఉంది, ML లేదా మానవ అనువాదం? ఏ సందర్భాల్లో?
## భావ విశ్లేషణ
మెషీన్ లెర్నింగ్ చాలా బాగా పనిచేసే మరో ప్రాంతం భావ విశ్లేషణ. ఒక non-ML దృష్టికోణం భావాన్ని గుర్తించడానికి 'ధనాత్మక' మరియు 'నెగటివ్' పదాలు, పదబంధాలను గుర్తించడం. ఆపై, కొత్త టెక్స్ట్ ఇచ్చినప్పుడు, ధనాత్మక, నెగటివ్ మరియు న్యూట్రల్ పదాల మొత్తం విలువను లెక్కించి మొత్తం భావాన్ని గుర్తించడం.
ఈ దృష్టికోణం సులభంగా మోసగించబడుతుంది, మీరు Marvin టాస్క్‌లో చూసినట్లే - వాక్యం `Great, that was a wonderful waste of time, I'm glad we are lost on this dark road` ఒక వ్యంగ్యాత్మక, నెగటివ్ భావ వాక్యం, కానీ సాదా అల్గోరిథం 'great', 'wonderful', 'glad' ను ధనాత్మకంగా, 'waste', 'lost' మరియు 'dark' ను నెగటివ్‌గా గుర్తిస్తుంది. మొత్తం భావం ఈ విరుద్ధ పదాల వల్ల తిప్పబడుతుంది.
✅ ఒక క్షణం ఆగి మనుష్యులు వ్యంగ్యాన్ని ఎలా వ్యక్తం చేస్తామో ఆలోచించండి. స్వరం ఉచ్చారణ చాలా పాత్ర పోషిస్తుంది. "Well, that film was awesome" అనే పదబంధాన్ని వేర్వేరు రీతుల్లో చెప్పి మీ స్వరం అర్థాన్ని ఎలా వ్యక్తం చేస్తుందో తెలుసుకోండి.
### ML దృష్టికోణాలు
ML దృష్టికోణం నెగటివ్ మరియు పాజిటివ్ టెక్స్ట్‌లను - ట్వీట్లు, సినిమా సమీక్షలు లేదా మానవుడు స్కోరు మరియు అభిప్రాయం ఇచ్చిన ఏదైనా - సేకరించడం. ఆపై NLP సాంకేతికతలను అభిప్రాయాలు మరియు స్కోర్లు మీద వర్తింపజేసి నమూనాలు బయటపడతాయి (ఉదా: ధనాత్మక సినిమా సమీక్షల్లో 'Oscar worthy' పదబంధం ఎక్కువగా ఉంటుంది, నెగటివ్ సమీక్షల్లో తక్కువగా, లేదా ధనాత్మక రెస్టారెంట్ సమీక్షల్లో 'gourmet' ఎక్కువగా ఉంటుంది 'disgusting' కంటే).
> ⚖️ **ఉదాహరణ**: మీరు ఒక రాజకీయ నాయకుడి కార్యాలయంలో పనిచేస్తున్నారని, కొత్త చట్టం చర్చలో ఉందని అనుకోండి. ప్రజలు ఆ చట్టానికి మద్దతుగా లేదా వ్యతిరేకంగా ఇమెయిల్స్ రాస్తారు. మీరు ఆ ఇమెయిల్స్ చదివి రెండు గుంపులుగా, *మద్దతు* మరియు *వ్యతిరేకం* గా వర్గీకరించాల్సి ఉంటుంది. ఇమెయిల్స్ చాలా ఉంటే, వాటన్నింటినీ చదవడం కష్టమవుతుంది. ఒక బాట్ వాటన్నింటినీ చదివి అర్థం చేసుకుని ఏ ఇమెయిల్ ఏ గుంపులో ఉందో చెప్పగలిగితే బాగుండేది కదా?
>
> దీన్ని సాధించడానికి మెషీన్ లెర్నింగ్ ఉపయోగించవచ్చు. మీరు *వ్యతిరేక* ఇమెయిల్స్ మరియు *మద్దతు* ఇమెయిల్స్ కొంత భాగంతో మోడల్‌ను శిక్షణ ఇస్తారు. మోడల్ పదబంధాలు మరియు పదాలను వ్యతిరేక మరియు మద్దతు వైపులుగా అనుసంధానిస్తుంది, *కానీ అది ఏదైనా విషయాన్ని అర్థం చేసుకోదు*, కేవలం కొన్ని పదాలు మరియు నమూనాలు ఒక వైపు ఎక్కువగా కనిపిస్తాయని మాత్రమే తెలుసుకుంటుంది. మీరు శిక్షణలో ఉపయోగించని కొన్ని ఇమెయిల్స్‌తో పరీక్షిస్తారు, మీరు చేసిన నిర్ణయంతో సమానంగా ఉందో చూడండి. మీరు మోడల్ ఖచ్చితత్వంతో సంతృప్తి చెందాక, భవిష్యత్ ఇమెయిల్స్‌ను చదవకుండా ప్రాసెస్ చేయవచ్చు.
✅ ఈ ప్రక్రియ మీరు మునుపటి పాఠాలలో ఉపయోగించిన ప్రక్రియలకు సమానంగా ఉందా?
## వ్యాయామం - భావ వాక్యాలు
భావాన్ని -1 నుండి 1 వరకు *పోలారిటీ*తో కొలుస్తారు, అంటే -1 అత్యంత నెగటివ్ భావం, 1 అత్యంత పాజిటివ్ భావం. భావాన్ని 0 - 1 స్కోర్‌తో కూడా కొలుస్తారు, 0 అంటే ఆబ్జెక్టివిటీ, 1 అంటే సబ్జెక్టివిటీ.
మళ్ళీ జేన్ ఆస్టెన్ యొక్క *Pride and Prejudice* ను చూడండి. పాఠ్యం [Project Gutenberg](https://www.gutenberg.org/files/1342/1342-h/1342-h.htm) వద్ద అందుబాటులో ఉంది. క్రింది నమూనా ప్రోగ్రామ్ పుస్తకంలోని మొదటి మరియు చివరి వాక్యాల భావాన్ని విశ్లేషించి, దాని పోలారిటీ మరియు సబ్జెక్టివిటీ/ఆబ్జెక్టివిటీ స్కోర్‌ను ప్రదర్శిస్తుంది.
ఈ క్రింది టాస్క్‌లో మీరు `TextBlob` లైబ్రరీ (పై వివరించినది) ఉపయోగించి `sentiment` నిర్ణయించాలి (మీరు మీ స్వంత భావ గణన యంత్రం రాయాల్సిన అవసరం లేదు).
```python
from textblob import TextBlob
quote1 = """It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want of a wife."""
quote2 = """Darcy, as well as Elizabeth, really loved them; and they were both ever sensible of the warmest gratitude towards the persons who, by bringing her into Derbyshire, had been the means of uniting them."""
sentiment1 = TextBlob(quote1).sentiment
sentiment2 = TextBlob(quote2).sentiment
print(quote1 + " has a sentiment of " + str(sentiment1))
print(quote2 + " has a sentiment of " + str(sentiment2))
```
మీకు క్రింది అవుట్పుట్ కనిపిస్తుంది:
```output
It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want # of a wife. has a sentiment of Sentiment(polarity=0.20952380952380953, subjectivity=0.27142857142857146)
Darcy, as well as Elizabeth, really loved them; and they were
both ever sensible of the warmest gratitude towards the persons
who, by bringing her into Derbyshire, had been the means of
uniting them. has a sentiment of Sentiment(polarity=0.7, subjectivity=0.8)
```
## సవాలు - భావ పోలారిటీ తనిఖీ
మీ టాస్క్, భావ పోలారిటీ ఉపయోగించి, *Pride and Prejudice* లో పూర్తిగా పాజిటివ్ వాక్యాలు పూర్తిగా నెగటివ్ వాక్యాల కంటే ఎక్కువ ఉన్నాయా అని నిర్ణయించడం. ఈ టాస్క్ కోసం, పోలారిటీ స్కోర్ 1 లేదా -1 ఉన్న వాక్యాలు పూర్తిగా పాజిటివ్ లేదా నెగటివ్ అని భావించవచ్చు.
**దశలు:**
1. Project Gutenberg నుండి [Pride and Prejudice](https://www.gutenberg.org/files/1342/1342-h/1342-h.htm) .txt ఫైల్ డౌన్లోడ్ చేసుకోండి. ఫైల్ ప్రారంభం మరియు ముగింపు మెటాడేటాను తీసివేసి అసలు పాఠ్యాన్ని మాత్రమే ఉంచండి
2. Pythonలో ఫైల్ తెరిచి కంటెంట్‌ను స్ట్రింగ్‌గా తీసుకోండి
3. పుస్తక స్ట్రింగ్‌తో TextBlob సృష్టించండి
4. పుస్తకంలోని ప్రతి వాక్యాన్ని లూప్‌లో విశ్లేషించండి
1. పోలారిటీ 1 లేదా -1 అయితే ఆ వాక్యాన్ని పాజిటివ్ లేదా నెగటివ్ సందేశాల జాబితాలో నిల్వ చేయండి
5. చివరలో, అన్ని పాజిటివ్ మరియు నెగటివ్ వాక్యాలను (వేరుగా) మరియు వాటి సంఖ్యను ప్రింట్ చేయండి.
ఇది ఒక నమూనా [పరిష్కారం](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/3-Translation-Sentiment/solution/notebook.ipynb).
✅ జ్ఞాన తనిఖీ
1. భావం వాక్యంలో ఉపయోగించిన పదాల ఆధారంగా ఉంటుంది, కానీ కోడ్ పదాలను *అర్థం చేసుకుంటుందా*?
2. మీరు భావ పోలారిటీ ఖచ్చితమని అనుకుంటున్నారా, లేదా మరొక మాటల్లో, స్కోర్లతో మీరు *అంగీకరిస్తున్నారా*?
1. ముఖ్యంగా, ఈ వాక్యాల పూర్తి **పాజిటివ్** పోలారిటీతో మీరు అంగీకరిస్తున్నారా లేదా విరుద్ధంగా ఉన్నారా?
* “What an excellent father you have, girls!” said she, when the door was shut.
* “Your examination of Mr. Darcy is over, I presume,” said Miss Bingley; “and pray what is the result?” “I am perfectly convinced by it that Mr. Darcy has no defect.
* How wonderfully these sort of things occur!
* I have the greatest dislike in the world to that sort of thing.
* Charlotte is an excellent manager, I dare say.
* “This is delightful indeed!
* I am so happy!
* Your idea of the ponies is delightful.
2. ఈ తర్వాతి 3 వాక్యాలు పూర్తి పాజిటివ్ భావంతో స్కోర్ చేయబడ్డాయి, కానీ సమీపంగా చదివితే అవి పాజిటివ్ వాక్యాలు కావు. భావ విశ్లేషణ అవి పాజిటివ్ వాక్యాలు అని ఎందుకు భావించింది?
* Happy shall I be, when his stay at Netherfield is over!” “I wish I could say anything to comfort you,” replied Elizabeth; “but it is wholly out of my power.
* If I could but see you as happy!
* Our distress, my dear Lizzy, is very great.
3. ఈ క్రింది వాక్యాల పూర్తి **నెగటివ్** పోలారిటీతో మీరు అంగీకరిస్తున్నారా లేదా విరుద్ధంగా ఉన్నారా?
- Everybody is disgusted with his pride.
- “I should like to know how he behaves among strangers.” “You shall hear then—but prepare yourself for something very dreadful.
- The pause was to Elizabeth’s feelings dreadful.
- It would be dreadful!
✅ జేన్ ఆస్టెన్ అభిమానులు అర్థం చేసుకుంటారు ఆమె తరచుగా తన పుస్తకాలను ఇంగ్లీష్ రెజెన్సీ సమాజంలోని అర్థరహిత అంశాలను విమర్శించడానికి ఉపయోగిస్తారని. *Pride and Prejudice* లో ప్రధాన పాత్ర ఎలిజబెత్ బెన్నెట్ ఒక చురుకైన సామాజిక పరిశీలకురాలు (రచయితలా) మరియు ఆమె భాష తరచుగా చాలా సున్నితంగా ఉంటుంది. కథలో ప్రేమ ఆసక్తి అయిన మిస్టర్ డార్సీ కూడా ఎలిజబెత్ యొక్క ఆటపాట మరియు చమత్కార భాషా వినియోగాన్ని గమనిస్తాడు: "నేను మీ పరిచయాన్ని చాలాసేపు పొందాను, మీరు నిజానికి మీ స్వంతం కాని అభిప్రాయాలను అప్పుడప్పుడు ప్రకటించడం లో చాలా ఆనందం పొందుతారని తెలుసుకున్నాను."
---
## 🚀సవాలు
మార్విన్‌ను మరింత మెరుగుపరచడానికి వినియోగదారు ఇన్‌పుట్ నుండి ఇతర లక్షణాలను తీసుకురావచ్చు?
## [పాఠం తర్వాత క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
పాఠ్యంతో నుండి భావోద్వేగాన్ని తీసుకోవడానికి అనేక మార్గాలు ఉన్నాయి. ఈ సాంకేతికతను ఉపయోగించే వ్యాపార అనువర్తనాలను ఆలోచించండి. ఇది ఎలా తప్పు కావచ్చు అనేది గురించి ఆలోచించండి. [Azure Text Analysis](https://docs.microsoft.com/azure/cognitive-services/Text-Analytics/how-tos/text-analytics-how-to-sentiment-analysis?tabs=version-3-1?WT.mc_id=academic-77952-leestott) వంటి భావోద్వేగాన్ని విశ్లేషించే సున్నితమైన ఎంటర్ప్రైజ్-సిద్ధమైన వ్యవస్థల గురించి మరింత చదవండి. పై ప్రైడ్ అండ్ ప్రెజుడిస్ వాక్యాలను కొంత పరీక్షించి, ఇది సూక్ష్మతను గుర్తించగలదా చూడండి.
## అసైన్‌మెంట్
[Poetic license](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

27
translations/te/6-NLP/3-Translation-Sentiment/assignment.md
Unescape View File

@ -0,0 +1,27 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "9d2a734deb904caff310d1a999c6bd7a",
"translation_date": "2025-12-19T14:18:17+00:00",
"source_file": "6-NLP/3-Translation-Sentiment/assignment.md",
"language_code": "te"
}
-->
# కవిత్వ అనుమతి
## సూచనలు
[ఈ నోట్‌బుక్](https://www.kaggle.com/jenlooper/emily-dickinson-word-frequency)లో మీరు 500కి పైగా ఎమిలీ డికిన్సన్ కవితలను కనుగొనవచ్చు, ఇవి ముందుగా Azure టెక్స్ట్ అనలిటిక్స్ ఉపయోగించి భావ విశ్లేషణకు అన్వయించబడ్డాయి. ఈ డేటాసెట్‌ను ఉపయోగించి, పాఠంలో వివరించిన సాంకేతికతలను ఉపయోగించి విశ్లేషించండి. ఒక కవిత యొక్క సూచించిన భావం Azure సేవ యొక్క మరింత సున్నితమైన నిర్ణయంతో సరిపోతుందా? మీ అభిప్రాయంలో ఎందుకు లేదా ఎందుకు కాదు? ఏదైనా ఆశ్చర్యం కలిగిస్తుందా?
## రూబ్రిక్
| ప్రమాణాలు | అద్భుతమైన | సరిపడిన | మెరుగుదల అవసరం |
| -------- | -------------------------------------------------------------------------- | ------------------------------------------------------- | ------------------------ |
| | రచయిత యొక్క నమూనా అవుట్‌పుట్‌పై బలమైన విశ్లేషణతో ఒక నోట్‌బుక్ అందించబడింది | నోట్‌బుక్ అసంపూర్ణంగా ఉంది లేదా విశ్లేషణ చేయదు | ఎలాంటి నోట్‌బుక్ అందించబడలేదు |
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలో ఉన్నది అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/te/6-NLP/3-Translation-Sentiment/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:46:23+00:00",
"source_file": "6-NLP/3-Translation-Sentiment/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

17
translations/te/6-NLP/3-Translation-Sentiment/solution/R/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "81db6ff2cf6e62fbe2340b094bb9509e",
"translation_date": "2025-12-19T14:46:54+00:00",
"source_file": "6-NLP/3-Translation-Sentiment/solution/R/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారులు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

100
translations/te/6-NLP/3-Translation-Sentiment/solution/notebook.ipynb
Unescape View File

@ -0,0 +1,100 @@
{
"metadata": {
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": 3
},
"orig_nbformat": 4,
"coopTranslator": {
"original_hash": "27de2abc0235ebd22080fc8f1107454d",
"translation_date": "2025-12-19T16:49:12+00:00",
"source_file": "6-NLP/3-Translation-Sentiment/solution/notebook.ipynb",
"language_code": "te"
}
},
"nbformat": 4,
"nbformat_minor": 2,
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from textblob import TextBlob\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# You should download the book text, clean it, and import it here\n",
"with open(\"pride.txt\", encoding=\"utf8\") as f:\n",
" file_contents = f.read()\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"book_pride = TextBlob(file_contents)\n",
"positive_sentiment_sentences = []\n",
"negative_sentiment_sentences = []"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for sentence in book_pride.sentences:\n",
" if sentence.sentiment.polarity == 1:\n",
" positive_sentiment_sentences.append(sentence)\n",
" if sentence.sentiment.polarity == -1:\n",
" negative_sentiment_sentences.append(sentence)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"The \" + str(len(positive_sentiment_sentences)) + \" most positive sentences:\")\n",
"for sentence in positive_sentiment_sentences:\n",
" print(\"+ \" + str(sentence.replace(\"\\n\", \"\").replace(\" \", \" \")))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"The \" + str(len(negative_sentiment_sentences)) + \" most negative sentences:\")\n",
"for sentence in negative_sentiment_sentences:\n",
" print(\"- \" + str(sentence.replace(\"\\n\", \"\").replace(\" \", \" \")))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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"
]
}
]
}

419
translations/te/6-NLP/4-Hotel-Reviews-1/README.md
Unescape View File

@ -0,0 +1,419 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "8d32dadeda93c6fb5c43619854882ab1",
"translation_date": "2025-12-19T14:18:58+00:00",
"source_file": "6-NLP/4-Hotel-Reviews-1/README.md",
"language_code": "te"
}
-->
# హోటల్ సమీక్షలతో భావ విశ్లేషణ - డేటాను ప్రాసెస్ చేయడం
ఈ విభాగంలో మీరు గత పాఠాలలోని సాంకేతికతలను ఉపయోగించి పెద్ద డేటాసెట్ యొక్క అన్వేషణాత్మక డేటా విశ్లేషణ చేయబోతున్నారు. వివిధ కాలమ్స్ యొక్క ఉపయోగకరతను బాగా అర్థం చేసుకున్న తర్వాత, మీరు నేర్చుకుంటారు:
- అవసరం లేని కాలమ్స్‌ను ఎలా తొలగించాలి
- ఉన్న కాలమ్స్ ఆధారంగా కొత్త డేటాను ఎలా లెక్కించాలి
- తుది సవాలు కోసం ఫలిత డేటాసెట్‌ను ఎలా సేవ్ చేయాలి
## [పూర్వ-పాఠం క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
### పరిచయం
ఇప్పటివరకు మీరు నేర్చుకున్నది ఏమిటంటే, టెక్స్ట్ డేటా సంఖ్యాత్మక డేటా రకాలతో చాలా భిన్నంగా ఉంటుంది. అది మనుష్యుడు రాసిన లేదా మాట్లాడిన టెక్స్ట్ అయితే, దానిని నమూనాలు మరియు తరచుదలలు, భావం మరియు అర్థం కనుగొనడానికి విశ్లేషించవచ్చు. ఈ పాఠం మీకు ఒక నిజమైన డేటా సెట్ మరియు నిజమైన సవాలు తీసుకువస్తుంది: **[యూరోప్‌లో 515K హోటల్ సమీక్షల డేటా](https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe)** మరియు ఇందులో [CC0: పబ్లిక్ డొమైన్ లైసెన్స్](https://creativecommons.org/publicdomain/zero/1.0/) ఉంది. ఇది Booking.com నుండి పబ్లిక్ మూలాల నుండి స్క్రాప్ చేయబడింది. డేటాసెట్ సృష్టికర్త జియాషెన్ లియు.
### సిద్ధం కావడం
మీకు అవసరం:
* Python 3 ఉపయోగించి .ipynb నోట్బుక్స్ నడపగల సామర్థ్యం
* pandas
* NLTK, [దాన్ని మీరు స్థానికంగా ఇన్‌స్టాల్ చేయాలి](https://www.nltk.org/install.html)
* Kaggleలో అందుబాటులో ఉన్న డేటాసెట్ [515K హోటల్ సమీక్షల డేటా యూరోప్‌లో](https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe). ఇది అన్‌జిప్ చేసినప్పుడు సుమారు 230 MB ఉంటుంది. దీన్ని ఈ NLP పాఠాలతో సంబంధం ఉన్న రూట్ `/data` ఫోల్డర్‌లో డౌన్లోడ్ చేయండి.
## అన్వేషణాత్మక డేటా విశ్లేషణ
ఈ సవాలు మీరు భావ విశ్లేషణ మరియు అతిథి సమీక్ష స్కోర్లను ఉపయోగించి హోటల్ సిఫార్సు బాట్‌ను నిర్మిస్తున్నారని అనుకుంటుంది. మీరు ఉపయోగించబోయే డేటాసెట్‌లో 6 నగరాలలో 1493 విభిన్న హోటల్స్ యొక్క సమీక్షలు ఉన్నాయి.
Python, హోటల్ సమీక్షల డేటాసెట్ మరియు NLTK భావ విశ్లేషణ ఉపయోగించి మీరు తెలుసుకోవచ్చు:
* సమీక్షలలో అత్యంత తరచుగా ఉపయోగించే పదాలు మరియు పదబంధాలు ఏమిటి?
* హోటల్‌ను వివరిస్తున్న అధికారిక *ట్యాగ్లు* సమీక్ష స్కోర్లతో సంబంధం ఉందా (ఉదా: ఒక హోటల్‌కు *యువ పిల్లలతో కుటుంబం* కోసం మరింత నెగటివ్ సమీక్షలు ఉంటాయా, *సోలో ప్రయాణికుడు* కంటే, ఇది *సోలో ప్రయాణికులకు* మంచిదని సూచించవచ్చా?)
* NLTK భావ స్కోర్లు హోటల్ సమీక్షకుల సంఖ్యాత్మక స్కోర్‌తో 'అంగీకరిస్తాయా'?
#### డేటాసెట్
మీరు డౌన్లోడ్ చేసి స్థానికంగా సేవ్ చేసిన డేటాసెట్‌ను అన్వేషిద్దాం. ఫైల్‌ను VS కోడ్ లేదా Excel వంటి ఎడిటర్‌లో తెరవండి.
డేటాసెట్‌లో హెడర్లు ఈ విధంగా ఉన్నాయి:
*Hotel_Address, Additional_Number_of_Scoring, Review_Date, Average_Score, Hotel_Name, Reviewer_Nationality, Negative_Review, Review_Total_Negative_Word_Counts, Total_Number_of_Reviews, Positive_Review, Review_Total_Positive_Word_Counts, Total_Number_of_Reviews_Reviewer_Has_Given, Reviewer_Score, Tags, days_since_review, lat, lng*
ఇవి పరిశీలించడానికి సులభంగా ఉండే విధంగా ఈ క్రింది విధంగా వర్గీకరించబడ్డాయి:
##### హోటల్ కాలమ్స్
* `Hotel_Name`, `Hotel_Address`, `lat` (అక్షాంశం), `lng` (రేఖాంశం)
* *lat* మరియు *lng* ఉపయోగించి Pythonతో హోటల్ స్థానాలను చూపించే మ్యాప్‌ను ప్లాట్ చేయవచ్చు (నెగటివ్ మరియు పాజిటివ్ సమీక్షలకు వర్ణం కోడ్ చేయవచ్చు)
* Hotel_Address మనకు స్పష్టంగా ఉపయోగకరం కాదు, మరియు సులభంగా వర్గీకరించడానికి & శోధించడానికి దీన్ని దేశంతో మార్చవచ్చు
**హోటల్ మెటా-సమీక్ష కాలమ్స్**
* `Average_Score`
* డేటాసెట్ సృష్టికర్త ప్రకారం, ఈ కాలమ్ *గత సంవత్సరం చివరి వ్యాఖ్య ఆధారంగా హోటల్ యొక్క సగటు స్కోర్* ను సూచిస్తుంది. ఇది స్కోర్ లెక్కించే అసాధారణ విధానం అనిపిస్తుంది, కానీ ఇది స్క్రాప్ చేసిన డేటా కాబట్టి ప్రస్తుతానికి దీన్ని నిజంగా తీసుకోవచ్చు.
✅ ఈ డేటాలోని ఇతర కాలమ్స్ ఆధారంగా, సగటు స్కోర్ లెక్కించే మరో మార్గం మీకు ఏమైనా ఆలోచన ఉందా?
* `Total_Number_of_Reviews`
* ఈ హోటల్ అందుకున్న సమీక్షల మొత్తం సంఖ్య - ఇది డేటాసెట్‌లోని సమీక్షలకు సంబంధించినదో లేదో (కొడితే కోడ్ రాయకుండా) స్పష్టంగా లేదు.
* `Additional_Number_of_Scoring`
* సమీక్షకుడు సమీక్ష రాయకపోయినా సమీక్ష స్కోర్ ఇచ్చిన సందర్భం
**సమీక్ష కాలమ్స్**
- `Reviewer_Score`
- ఇది కనీసం 1 దశాంశ స్థానం కలిగిన సంఖ్యాత్మక విలువ, కనిష్టం 2.5 మరియు గరిష్టం 10 మధ్య
- 2.5 కనిష్ట స్కోర్ ఎందుకు అనేది వివరించబడలేదు
- `Negative_Review`
- సమీక్షకుడు ఏమీ రాయకపోతే, ఈ ఫీల్డ్‌లో "**No Negative**" ఉంటుంది
- సమీక్షకుడు నెగటివ్ సమీక్ష కాలమ్‌లో పాజిటివ్ సమీక్ష రాయవచ్చు (ఉదా: "ఈ హోటల్ గురించి ఏదీ చెడు లేదు")
- `Review_Total_Negative_Word_Counts`
- ఎక్కువ నెగటివ్ పదాల సంఖ్య తక్కువ స్కోర్ సూచిస్తుంది (భావాన్ని తనిఖీ చేయకుండా)
- `Positive_Review`
- సమీక్షకుడు ఏమీ రాయకపోతే, ఈ ఫీల్డ్‌లో "**No Positive**" ఉంటుంది
- సమీక్షకుడు పాజిటివ్ సమీక్ష కాలమ్‌లో నెగటివ్ సమీక్ష రాయవచ్చు (ఉదా: "ఈ హోటల్ గురించి ఏదీ మంచిది లేదు")
- `Review_Total_Positive_Word_Counts`
- ఎక్కువ పాజిటివ్ పదాల సంఖ్య ఎక్కువ స్కోర్ సూచిస్తుంది (భావాన్ని తనిఖీ చేయకుండా)
- `Review_Date` మరియు `days_since_review`
- సమీక్షకు తాజాదనం లేదా పాతదనం కొలమానం వర్తించవచ్చు (పాత సమీక్షలు కొత్తవాటికంటే తక్కువ ఖచ్చితంగా ఉండవచ్చు, ఎందుకంటే హోటల్ నిర్వహణ మారింది, మరమ్మతులు జరిగాయి, లేదా స్విమ్మింగ్ పూల్ జోడించబడింది)
- `Tags`
- ఇవి సమీక్షకుడు అతిథి రకం (ఉదా: సోలో లేదా కుటుంబం), గది రకం, ఉండే కాలం మరియు సమీక్ష ఎలా సమర్పించబడిందో వివరించడానికి ఎంచుకునే చిన్న వివరణలు
- దురదృష్టవశాత్తు, ఈ ట్యాగ్లను ఉపయోగించడం సమస్యాత్మకం, వాటి ఉపయోగకరతను చర్చించే క్రింది విభాగాన్ని చూడండి
**సమీక్షకుడు కాలమ్స్**
- `Total_Number_of_Reviews_Reviewer_Has_Given`
- ఇది సిఫార్సు మోడల్‌లో ఒక అంశం కావచ్చు, ఉదా: మీరు గుర్తించగలిగితే ఎక్కువ సమీక్షలు ఇచ్చిన సమీక్షకులు ఎక్కువగా నెగటివ్ సమీక్షలు ఇస్తారని. అయితే, ఏ సమీక్షకుడి సమీక్ష అనేది ప్రత్యేక కోడ్‌తో గుర్తించబడలేదు, కాబట్టి సమీక్షల సమూహంతో లింక్ చేయలేము. 100 లేదా అంతకంటే ఎక్కువ సమీక్షలు ఇచ్చిన 30 సమీక్షకులు ఉన్నారు, కానీ ఇది సిఫార్సు మోడల్‌కు ఎలా సహాయపడుతుందో అర్థం కావడం కష్టం.
- `Reviewer_Nationality`
- కొంతమంది భావిస్తారు కొన్ని జాతులు పాజిటివ్ లేదా నెగటివ్ సమీక్ష ఇవ్వడానికి ఎక్కువ అవకాశం ఉంటుందని. అలాంటి అనుభవాల ఆధారంగా మోడల్స్‌లో జాతి ఆధారిత అభిప్రాయాలు చేర్చడంలో జాగ్రత్త వహించండి. ఇవి జాతీయ (మరియు కొన్నిసార్లు జాతి) సాంప్రదాయాలు, ప్రతి సమీక్షకుడు తన అనుభవం ఆధారంగా సమీక్ష రాశాడు. ఇది వారి గత హోటల్ stays, ప్రయాణ దూరం, వ్యక్తిగత స్వభావం వంటి అనేక దృక్కోణాల ద్వారా ఫిల్టర్ అయి ఉండవచ్చు. వారి జాతి సమీక్ష స్కోర్‌కు కారణమని భావించడం కష్టం.
##### ఉదాహరణలు
| సగటు స్కోర్ | మొత్తం సమీక్షల సంఖ్య | సమీక్షకుడి స్కోర్ | నెగటివ్ <br />సమీక్ష | పాజిటివ్ సమీక్ష | ట్యాగ్లు |
| -------------- | ---------------------- | ---------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------- | ----------------------------------------------------------------------------------------- |
| 7.8 | 1945 | 2.5 | ఇది ప్రస్తుతం హోటల్ కాదు, కానీ నిర్మాణ స్థలం. నేను ఉదయం మొదలుకొని మొత్తం రోజంతా అంగీకారయోగ్యమైన నిర్మాణ శబ్దంతో భయపడ్డాను, దీర్ఘ ప్రయాణం తర్వాత విశ్రాంతి తీసుకుంటూ గదిలో పని చేస్తున్నాను. పక్క గదుల్లో జాక్‌హ్యామర్లు ఉపయోగించి రోజంతా పని జరిగింది. గది మార్చాలని అడిగాను కానీ నిశ్శబ్ద గది అందుబాటులో లేదు. మరింత చెడుగా, నాకు అధిక చార్జ్ చేశారు. నేను సాయంత్రం చెక్ అవుట్ అయ్యాను ఎందుకంటే నాకు చాలా తొందరగా విమానం ఉండేది మరియు సరైన బిల్ అందుకున్నాను. ఒక రోజు తర్వాత హోటల్ నా అనుమతి లేకుండా బుక్ చేసిన ధర కంటే ఎక్కువ చార్జ్ చేసింది. ఇది భయంకరమైన స్థలం. ఇక్కడ బుక్ చేయడం ద్వారా మీకు శిక్ష వేయకండి | ఏమీ లేదు భయంకరమైన స్థలం దూరంగా ఉండండి | వ్యాపార ప్రయాణం జంట స్టాండర్డ్ డబుల్ గది 2 రాత్రులు ఉండటం |
మీరు చూడగలిగినట్లుగా, ఈ అతిథి ఈ హోటల్‌లో సంతోషంగా ఉండలేదు. హోటల్‌కు మంచి సగటు స్కోర్ 7.8 మరియు 1945 సమీక్షలు ఉన్నాయి, కానీ ఈ సమీక్షకుడు 2.5 ఇచ్చి తన అనుభవం ఎంత నెగటివ్ అనేదాన్ని 115 పదాలతో వర్ణించాడు. వారు Positive_Review కాలమ్‌లో ఏమీ రాయకపోతే, మీరు పాజిటివ్ ఏమీ లేదని ఊహించవచ్చు, కానీ వారు 7 పదాల హెచ్చరిక రాశారు. మనం పదాలను మాత్రమే లెక్కిస్తే లేదా పదాల భావాన్ని పరిగణించకపోతే, సమీక్షకుడి ఉద్దేశం తప్పుడు అర్థం కావచ్చు. ఆశ్చర్యకరం గా, వారి స్కోర్ 2.5 గందరగోళంగా ఉంది, ఎందుకంటే ఆ హోటల్ stay అంత చెడుగా ఉంటే, ఎందుకు ఏదైనా పాయింట్లు ఇస్తారు? డేటాసెట్‌ను సన్నిహితంగా పరిశీలిస్తే, కనీస స్కోర్ 2.5, 0 కాదు. గరిష్ట స్కోర్ 10.
##### ట్యాగ్లు
పైన చెప్పినట్లుగా, మొదట చూపులో, `Tags` ఉపయోగించి డేటాను వర్గీకరించడం అర్థం చేసుకోవచ్చు. దురదృష్టవశాత్తు, ఈ ట్యాగ్లు ప్రమాణీకరించబడలేదు, అంటే ఒక హోటల్‌లో ఎంపికలు *సింగిల్ రూమ్*, *ట్విన్ రూమ్*, మరియు *డబుల్ రూమ్* ఉండవచ్చు, కానీ తదుపరి హోటల్‌లో అవి *డీలక్స్ సింగిల్ రూమ్*, *క్లాసిక్ క్వీన్ రూమ్*, మరియు *ఎగ్జిక్యూటివ్ కింగ్ రూమ్* ఉంటాయి. ఇవి ఒకే విషయాలు కావచ్చు, కానీ ఎన్నో వేరియేషన్లు ఉండటం వల్ల ఎంపిక:
1. అన్ని పదాలను ఒకే ప్రమాణానికి మార్చడానికి ప్రయత్నించడం, ఇది చాలా కష్టం, ఎందుకంటే ప్రతి సందర్భంలో మార్పు మార్గం స్పష్టంగా లేదు (ఉదా: *క్లాసిక్ సింగిల్ రూమ్* అనేది *సింగిల్ రూమ్* కు మ్యాప్ అవుతుంది కానీ *సుపీరియర్ క్వీన్ రూమ్ విత్ కోర్ట్‌యార్డ్ గార్డెన్ లేదా సిటీ వ్యూ* మ్యాప్ చేయడం చాలా కష్టం)
1. NLP దృష్టికోణం తీసుకుని, ప్రతి హోటల్‌కు వర్తించే *సోలో*, *బిజినెస్ ట్రావెలర్*, లేదా *యువ పిల్లలతో కుటుంబం* వంటి పదాల తరచుదల కొలవడం మరియు దానిని సిఫార్సు లోకి చేర్చడం
ట్యాగ్లు సాధారణంగా (కానీ ఎప్పుడూ కాదు) ఒకే ఫీల్డ్‌లో 5 నుండి 6 కామాతో విడగొట్టబడిన విలువల జాబితా ఉంటాయి, అవి *ప్రయాణ రకం*, *అతిథుల రకం*, *గది రకం*, *రాత్రుల సంఖ్య*, మరియు *సమీక్ష సమర్పించిన పరికరం రకం* కు సరిపోతాయి. అయితే, కొంతమంది సమీక్షకులు ప్రతి ఫీల్డ్‌ను నింపకపోవచ్చు (ఒకదాన్ని ఖాళీగా వదిలివేయవచ్చు), కాబట్టి విలువలు ఎప్పుడూ ఒకే క్రమంలో ఉండవు.
ఉదాహరణకు, *గ్రూప్ రకం* తీసుకోండి. `Tags` కాలమ్‌లో ఈ ఫీల్డ్‌లో 1025 ప్రత్యేక అవకాశాలు ఉన్నాయి, దురదృష్టవశాత్తు వాటిలో కొన్నింటి మాత్రమే గ్రూప్‌కు సంబంధించినవి (కొన్ని గది రకానికి సంబంధించినవి). మీరు కుటుంబాన్ని మాత్రమే ఫిల్టర్ చేస్తే, ఫలితాల్లో చాలా *ఫ్యామిలీ రూమ్* రకాలు ఉంటాయి. మీరు *with* పదాన్ని కూడా చేర్చితే, అంటే *Family with* విలువలను లెక్కిస్తే, ఫలితాలు మెరుగ్గా ఉంటాయి, 515,000 ఫలితాల్లో 80,000 కంటే ఎక్కువ "Family with young children" లేదా "Family with older children" పదబంధం కలిగి ఉంటాయి.
దీని అర్థం ఏమిటంటే, ట్యాగ్స్ కాలమ్ పూర్తిగా ఉపయోగరహితం కాదు, కానీ ఉపయోగకరంగా మార్చడానికి కొంత పని చేయాలి.
##### సగటు హోటల్ స్కోర్
డేటా సెట్‌లో కొన్ని విచిత్రతలు లేదా విరుద్ధతలు ఉన్నాయి, నేను అవి ఏమిటో అర్థం చేసుకోలేకపోతున్నాను, కానీ మీరు మీ మోడల్స్ నిర్మిస్తున్నప్పుడు అవి తెలుసుకోవాలి. మీరు అర్థం చేసుకుంటే, దయచేసి చర్చ విభాగంలో తెలియజేయండి!
డేటాసెట్‌లో సగటు స్కోర్ మరియు సమీక్షల సంఖ్యకు సంబంధించిన కాలమ్స్:
1. Hotel_Name
2. Additional_Number_of_Scoring
3. Average_Score
4. Total_Number_of_Reviews
5. Reviewer_Score
ఈ డేటాసెట్‌లో అత్యధిక సమీక్షలతో ఉన్న హోటల్ *Britannia International Hotel Canary Wharf* 4789 సమీక్షలతో ఉంది. కానీ ఈ హోటల్‌కు సంబంధించిన `Total_Number_of_Reviews` విలువ 9086. మీరు ఊహించవచ్చు సమీక్షలు లేకుండా మరిన్ని స్కోర్లు ఉన్నాయని, కాబట్టి `Additional_Number_of_Scoring` విలువను చేర్చాలి. ఆ విలువు 2682, దీన్ని 4789కి జోడిస్తే 7,471 వస్తుంది, ఇది ఇంకా `Total_Number_of_Reviews` కంటే 1615 తక్కువ.
`Average_Score` కాలమ్స్ తీసుకుంటే, ఇది డేటాసెట్‌లోని సమీక్షల సగటు అని ఊహించవచ్చు, కానీ Kaggle వివరణ "*గత సంవత్సరం చివరి వ్యాఖ్య ఆధారంగా హోటల్ యొక్క సగటు స్కోర్*" అని ఉంది. ఇది అంత ఉపయోగకరం అనిపించదు, కానీ మేము డేటాసెట్‌లోని సమీక్ష స్కోర్ల ఆధారంగా మా సొంత సగటు లెక్కించవచ్చు. అదే హోటల్ ఉదాహరణగా తీసుకుంటే, సగటు హోటల్ స్కోర్ 7.1 గా ఇవ్వబడింది కానీ లెక్కించిన స్కోర్ (డేటాసెట్‌లోని సగటు సమీక్షకుడి స్కోర్) 6.8. ఇది దగ్గరగా ఉంది, కానీ అదే కాదు, మరియు `Additional_Number_of_Scoring` సమీక్షలలో ఇచ్చిన స్కోర్లు సగటును 7.1కి పెంచినట్టు ఊహించవచ్చు. దురదృష్టవశాత్తు, ఆ అభిప్రాయాన్ని పరీక్షించడానికి లేదా నిరూపించడానికి మార్గం లేకపోవడంతో, `Average_Score`, `Additional_Number_of_Scoring` మరియు `Total_Number_of_Reviews` ను ఆధారంగా లేదా సూచించే డేటా లేకపోతే ఉపయోగించడం లేదా నమ్మకం పెట్టుకోవడం కష్టం.
మరింత క్లిష్టతకు, రెండవ అత్యధిక సమీక్షలతో ఉన్న హోటల్ లెక్కించిన సగటు స్కోర్ 8.12 మరియు డేటాసెట్ `Average_Score` 8.1. ఇది సరైన స్కోర్ యాదృచ్ఛికమా లేదా మొదటి హోటల్ విరుద్ధతనా?
ఈ హోటల్స్ అవుట్‌లయర్ కావచ్చు అనే అవకాశాన్ని పరిగణనలోకి తీసుకుంటే, మరియు ఎక్కువ భాగం విలువలు సరిపోతాయని (కానీ కొన్ని కారణాల వల్ల సరిపోకపోవచ్చు) మనం డేటాసెట్‌లోని విలువలను అన్వేషించడానికి మరియు విలువల సరైన ఉపయోగం (లేదా ఉపయోగం లేకపోవడం) నిర్ణయించడానికి ఒక చిన్న ప్రోగ్రామ్ రాయబోతున్నాము.
> 🚨 జాగ్రత్త సూచన
>
> ఈ డేటాసెట్‌తో పని చేస్తున్నప్పుడు మీరు టెక్స్ట్ నుండి ఏదైనా గణన చేయడానికి కోడ్ రాస్తారు, మీరు టెక్స్ట్‌ను స్వయంగా చదవాల్సిన అవసరం లేకుండా. ఇది NLP యొక్క సారాంశం, అర్థం లేదా భావాన్ని మానవుడు చేయకుండా అర్థం చేసుకోవడం. అయితే, మీరు కొన్ని నెగటివ్ సమీక్షలను చదవవచ్చు. నేను మీరు వాటిని చదవకూడదని సూచిస్తాను, ఎందుకంటే మీరు చదవాల్సిన అవసరం లేదు. వాటిలో కొన్ని అర్థరహితమైనవి లేదా సంబంధం లేని నెగటివ్ హోటల్ సమీక్షలు, ఉదాహరణకు "వాతావరణం బాగాలేదు" అనే సమీక్ష, ఇది హోటల్ నియంత్రణలో లేనిది, లేదా ఎవరైనా నియంత్రించలేని విషయం. కానీ కొన్ని సమీక్షలకు నల్ల వైపు కూడా ఉంటుంది. కొన్ని సార్లు నెగటివ్ సమీక్షలు జాతిపితృత్వం, లింగవాదం లేదా వయస్సు ఆధారిత వివక్ష కలిగి ఉంటాయి. ఇది దురదృష్టకరం కానీ ప్రజా వెబ్‌సైట్ నుండి సేకరించిన డేటాసెట్‌లో ఆశించదగిన విషయం. కొన్ని సమీక్షకులు అసహ్యకరమైన, అసౌకర్యకరమైన లేదా బాధాకరమైన సమీక్షలు వదిలిపెడతారు. వాటిని మీరు చదవకుండా కోడ్ భావాన్ని కొలవడం మంచిది. అయితే, ఇలాంటి సమీక్షలు రాయేవారు తక్కువ సంఖ్యలో ఉన్నారు, కానీ ఉన్నారు.
## వ్యాయామం - డేటా అన్వేషణ
### డేటాను లోడ్ చేయండి
డేటాను దృష్టిగోచరంగా పరిశీలించడం సరిపోతుంది, ఇప్పుడు మీరు కొంత కోడ్ రాసి కొన్ని సమాధానాలు పొందబోతున్నారు! ఈ విభాగం pandas లైబ్రరీని ఉపయోగిస్తుంది. మీ మొదటి పని CSV డేటాను లోడ్ చేసి చదవగలగడం నిర్ధారించుకోవడం. pandas లైబ్రరీకి వేగవంతమైన CSV లోడర్ ఉంది, ఫలితం ఒక డేటాఫ్రేమ్‌లో ఉంచబడుతుంది, గత పాఠాలలో చేసినట్లుగా. మనం లోడ్ చేస్తున్న CSVలో సగం మించి వరుసలు ఉన్నాయి, కానీ కేవలం 17 కాలమ్స్ మాత్రమే. pandas డేటాఫ్రేమ్‌తో పరస్పరం చర్యలు చేయడానికి అనేక శక్తివంతమైన మార్గాలను అందిస్తుంది, ప్రతి వరుసపై ఆపరేషన్లు చేయగల సామర్థ్యం సహా.
ఈ పాఠం నుండి, కోడ్ స్నిపెట్లు, కొంత వివరణలు మరియు ఫలితాల అర్థం గురించి చర్చ ఉంటుంది. మీ కోడ్ కోసం చేర్చబడిన _notebook.ipynb_ ఉపయోగించండి.
మీరు ఉపయోగించబోయే డేటా ఫైల్‌ను లోడ్ చేయడం ప్రారంభిద్దాం:
```python
# CSV నుండి హోటల్ సమీక్షలను లోడ్ చేయండి
import pandas as pd
import time
# ఫైల్ లోడింగ్ సమయాన్ని లెక్కించడానికి ప్రారంభ మరియు ముగింపు సమయాన్ని ఉపయోగించడానికి టైమ్‌ను దిగుమతి చేసుకుంటోంది
print("Loading data file now, this could take a while depending on file size")
start = time.time()
# df అనేది 'డేటాఫ్రేమ్' - మీరు ఫైల్‌ను డేటా ఫోల్డర్‌కు డౌన్లోడ్ చేసుకున్నారని నిర్ధారించుకోండి
df = pd.read_csv('../../data/Hotel_Reviews.csv')
end = time.time()
print("Loading took " + str(round(end - start, 2)) + " seconds")
```
ఇప్పుడు డేటా లోడ్ అయింది, దానిపై కొన్ని ఆపరేషన్లు చేయవచ్చు. ఈ కోడ్‌ను మీ ప్రోగ్రామ్ టాప్‌లో ఉంచండి తదుపరి భాగం కోసం.
## డేటాను అన్వేషించండి
ఈ సందర్భంలో, డేటా ఇప్పటికే *శుభ్రంగా* ఉంది, అంటే ఇది పని చేయడానికి సిద్ధంగా ఉంది, మరియు ఇతర భాషల అక్షరాలు లేవు, ఇవి కేవలం ఇంగ్లీష్ అక్షరాలను ఆశించే అల్గోరిథమ్స్‌ను గందరగోళం చేయవచ్చు.
✅ మీరు కొన్నిసార్లు NLP సాంకేతికతలు వర్తింపజేయడానికి ముందు డేటాను ప్రాథమిక ప్రాసెసింగ్ చేయాల్సి ఉండవచ్చు, కానీ ఈసారి కాదు. మీరు చేయాల్సి ఉంటే, మీరు ఎలా నాన్-ఇంగ్లీష్ అక్షరాలను నిర్వహిస్తారు?
ఒక క్షణం తీసుకుని డేటా లోడ్ అయిన తర్వాత మీరు కోడ్‌తో దాన్ని అన్వేషించగలరని నిర్ధారించుకోండి. మీరు సాధారణంగా `Negative_Review` మరియు `Positive_Review` కాలమ్స్‌పై దృష్టి పెట్టాలనుకుంటారు. అవి మీ NLP అల్గోరిథమ్స్ ప్రాసెస్ చేయడానికి సహజ టెక్స్ట్‌తో నింపబడ్డాయి. కానీ వేచి ఉండండి! NLP మరియు భావాన్ని ప్రారంభించే ముందు, మీరు క్రింద ఇచ్చిన కోడ్‌ను అనుసరించి డేటాసెట్‌లోని విలువలు మీరు pandas తో లెక్కించిన విలువలకు సరిపోతున్నాయా అని నిర్ధారించుకోండి.
## డేటాఫ్రేమ్ ఆపరేషన్లు
ఈ పాఠంలో మొదటి పని డేటాఫ్రేమ్‌ను పరిశీలించి (మార్చకుండా) క్రింది నిర్ధారణలు సరైనవా అని కోడ్ రాయడం.
> అనేక ప్రోగ్రామింగ్ పనుల్లా, దీన్ని పూర్తి చేయడానికి అనేక మార్గాలు ఉన్నాయి, కానీ మంచి సలహా మీరు తిరిగి ఈ కోడ్‌ను చూడగలిగేటప్పుడు అర్థం చేసుకోవడానికి సులభమైన, సరళమైన మార్గంలో చేయడం. డేటాఫ్రేమ్‌లకు సమగ్ర API ఉంటుంది, ఇది మీరు కోరుకున్న పనిని సమర్థవంతంగా చేయడానికి మార్గం కలిగి ఉంటుంది.
క్రింది ప్రశ్నలను కోడింగ్ పనులుగా పరిగణించి పరిష్కారం చూడకుండా సమాధానాలు ఇవ్వడానికి ప్రయత్నించండి.
1. మీరు ఇప్పుడే లోడ్ చేసిన డేటాఫ్రేమ్ యొక్క *ఆకారం* (shape) ను ప్రింట్ చేయండి (ఆకారం అంటే వరుసలు మరియు కాలమ్స్ సంఖ్య)
2. సమీక్షకుల జాతీయతల ఫ్రీక్వెన్సీ కౌంట్ లెక్కించండి:
1. `Reviewer_Nationality` కాలమ్‌లో ఎన్ని వేర్వేరు విలువలు ఉన్నాయి మరియు అవి ఏమిటి?
2. డేటాసెట్‌లో అత్యధికంగా కనిపించే సమీక్షకుల జాతీయత ఏది? (దేశం మరియు సమీక్షల సంఖ్య ప్రింట్ చేయండి)
3. తదుపరి టాప్ 10 అత్యధికంగా కనిపించే జాతీయతలు మరియు వాటి ఫ్రీక్వెన్సీ కౌంట్ ఏమిటి?
3. టాప్ 10 సమీక్షకుల జాతీయతల కోసం అత్యధికంగా సమీక్షించిన హోటల్ ఏది?
4. డేటాసెట్‌లో ప్రతి హోటల్‌కు ఎన్ని సమీక్షలు ఉన్నాయి? (హోటల్ ఫ్రీక్వెన్సీ కౌంట్)
5. డేటాసెట్‌లో ప్రతి హోటల్‌కు `Average_Score` కాలమ్ ఉన్నప్పటికీ, మీరు కూడా సగటు స్కోర్ లెక్కించవచ్చు (ప్రతి హోటల్‌కు డేటాసెట్‌లోని అన్ని సమీక్షకుల స్కోర్ల సగటు). మీ డేటాఫ్రేమ్‌కు `Calc_Average_Score` అనే కొత్త కాలమ్ జోడించండి, ఇందులో లెక్కించిన సగటు ఉంటుంది.
6. ఏ హోటల్స్‌కు (1 దశాంశ స్థాయికి రౌండ్ చేసిన) `Average_Score` మరియు `Calc_Average_Score` ఒకేలా ఉన్నాయా?
1. ఒక Python ఫంక్షన్ రాయండి, ఇది ఒక Series (ఒక వరుస)ని ఆర్గ్యుమెంట్‌గా తీసుకుని విలువలను పోల్చి, విలువలు సమానంగా లేనప్పుడు సందేశం ప్రింట్ చేస్తుంది. ఆపై `.apply()` మెథడ్ ఉపయోగించి ప్రతి వరుసపై ఆ ఫంక్షన్‌ను అమలు చేయండి.
7. `Negative_Review` కాలమ్‌లో "No Negative" విలువ ఉన్న వరుసల సంఖ్య లెక్కించి ప్రింట్ చేయండి
8. `Positive_Review` కాలమ్‌లో "No Positive" విలువ ఉన్న వరుసల సంఖ్య లెక్కించి ప్రింట్ చేయండి
9. `Positive_Review` కాలమ్‌లో "No Positive" మరియు `Negative_Review` కాలమ్‌లో "No Negative" ఉన్న వరుసల సంఖ్య లెక్కించి ప్రింట్ చేయండి
### కోడ్ సమాధానాలు
1. మీరు ఇప్పుడే లోడ్ చేసిన డేటాఫ్రేమ్ యొక్క *ఆకారం* (shape) ను ప్రింట్ చేయండి (ఆకారం అంటే వరుసలు మరియు కాలమ్స్ సంఖ్య)
```python
print("The shape of the data (rows, cols) is " + str(df.shape))
> The shape of the data (rows, cols) is (515738, 17)
```
2. సమీక్షకుల జాతీయతల ఫ్రీక్వెన్సీ కౌంట్ లెక్కించండి:
1. `Reviewer_Nationality` కాలమ్‌లో ఎన్ని వేర్వేరు విలువలు ఉన్నాయి మరియు అవి ఏమిటి?
2. డేటాసెట్‌లో అత్యధికంగా కనిపించే సమీక్షకుల జాతీయత ఏది? (దేశం మరియు సమీక్షల సంఖ్య ప్రింట్ చేయండి)
```python
# value_counts() ఒక సిరీస్ ఆబ్జెక్ట్‌ను సృష్టిస్తుంది, దీనిలో సూచిక మరియు విలువలు ఉంటాయి, ఈ సందర్భంలో దేశం మరియు వారు సమీక్షకుల జాతి లో కనిపించే సాంఖ్యికత
nationality_freq = df["Reviewer_Nationality"].value_counts()
print("There are " + str(nationality_freq.size) + " different nationalities")
# సిరీస్ యొక్క మొదటి మరియు చివరి వరుసలను ముద్రించండి. అన్ని డేటాను ముద్రించడానికి nationality_freq.to_string() గా మార్చండి
print(nationality_freq)
There are 227 different nationalities
United Kingdom 245246
United States of America 35437
Australia 21686
Ireland 14827
United Arab Emirates 10235
...
Comoros 1
Palau 1
Northern Mariana Islands 1
Cape Verde 1
Guinea 1
Name: Reviewer_Nationality, Length: 227, dtype: int64
```
3. తదుపరి టాప్ 10 అత్యధికంగా కనిపించే జాతీయతలు మరియు వాటి ఫ్రీక్వెన్సీ కౌంట్ ఏమిటి?
```python
print("The highest frequency reviewer nationality is " + str(nationality_freq.index[0]).strip() + " with " + str(nationality_freq[0]) + " reviews.")
# విలువల ముందు ఒక స్థలం ఉందని గమనించండి, ప్రింటింగ్ కోసం strip() దాన్ని తీసివేస్తుంది
# టాప్ 10 అత్యంత సాధారణ జాతీయతలు మరియు వాటి సాంద్రతలు ఏమిటి?
print("The next 10 highest frequency reviewer nationalities are:")
print(nationality_freq[1:11].to_string())
The highest frequency reviewer nationality is United Kingdom with 245246 reviews.
The next 10 highest frequency reviewer nationalities are:
United States of America 35437
Australia 21686
Ireland 14827
United Arab Emirates 10235
Saudi Arabia 8951
Netherlands 8772
Switzerland 8678
Germany 7941
Canada 7894
France 7296
```
3. టాప్ 10 సమీక్షకుల జాతీయతల కోసం అత్యధికంగా సమీక్షించిన హోటల్ ఏది?
```python
# టాప్ 10 జాతీయతల కోసం అత్యధికంగా సమీక్షించిన హోటల్ ఏది
# సాధారణంగా pandas తో మీరు స్పష్టమైన లూప్‌ను నివారిస్తారు, కానీ ప్రమాణాలను ఉపయోగించి కొత్త డేటాఫ్రేమ్ సృష్టించడం చూపించాలనుకున్నాను (పెద్ద మొత్తంలో డేటాతో ఇది చాలా నెమ్మదిగా ఉండవచ్చు కాబట్టి చేయవద్దు)
for nat in nationality_freq[:10].index:
# మొదట, ప్రమాణాలకు సరిపోయే అన్ని వరుసలను కొత్త డేటాఫ్రేమ్‌లో తీసుకోండి
nat_df = df[df["Reviewer_Nationality"] == nat]
# ఇప్పుడు హోటల్ ఫ్రీక్వెన్సీ పొందండి
freq = nat_df["Hotel_Name"].value_counts()
print("The most reviewed hotel for " + str(nat).strip() + " was " + str(freq.index[0]) + " with " + str(freq[0]) + " reviews.")
The most reviewed hotel for United Kingdom was Britannia International Hotel Canary Wharf with 3833 reviews.
The most reviewed hotel for United States of America was Hotel Esther a with 423 reviews.
The most reviewed hotel for Australia was Park Plaza Westminster Bridge London with 167 reviews.
The most reviewed hotel for Ireland was Copthorne Tara Hotel London Kensington with 239 reviews.
The most reviewed hotel for United Arab Emirates was Millennium Hotel London Knightsbridge with 129 reviews.
The most reviewed hotel for Saudi Arabia was The Cumberland A Guoman Hotel with 142 reviews.
The most reviewed hotel for Netherlands was Jaz Amsterdam with 97 reviews.
The most reviewed hotel for Switzerland was Hotel Da Vinci with 97 reviews.
The most reviewed hotel for Germany was Hotel Da Vinci with 86 reviews.
The most reviewed hotel for Canada was St James Court A Taj Hotel London with 61 reviews.
```
4. డేటాసెట్‌లో ప్రతి హోటల్‌కు ఎన్ని సమీక్షలు ఉన్నాయి? (హోటల్ ఫ్రీక్వెన్సీ కౌంట్)
```python
# పాత డేటాఫ్రేమ్ ఆధారంగా కొత్త డేటాఫ్రేమ్‌ను మొదట సృష్టించండి, అవసరం లేని కాలమ్స్‌ను తీసివేయండి
hotel_freq_df = df.drop(["Hotel_Address", "Additional_Number_of_Scoring", "Review_Date", "Average_Score", "Reviewer_Nationality", "Negative_Review", "Review_Total_Negative_Word_Counts", "Positive_Review", "Review_Total_Positive_Word_Counts", "Total_Number_of_Reviews_Reviewer_Has_Given", "Reviewer_Score", "Tags", "days_since_review", "lat", "lng"], axis = 1)
# వరుసలను Hotel_Name ద్వారా గ్రూప్ చేసి, వాటిని లెక్కించి ఫలితాన్ని కొత్త కాలమ్ Total_Reviews_Found లో ఉంచండి
hotel_freq_df['Total_Reviews_Found'] = hotel_freq_df.groupby('Hotel_Name').transform('count')
# అన్ని డూప్లికేట్ వరుసలను తొలగించండి
hotel_freq_df = hotel_freq_df.drop_duplicates(subset = ["Hotel_Name"])
display(hotel_freq_df)
```
| Hotel_Name | Total_Number_of_Reviews | Total_Reviews_Found |
| :----------------------------------------: | :---------------------: | :-----------------: |
| Britannia International Hotel Canary Wharf | 9086 | 4789 |
| Park Plaza Westminster Bridge London | 12158 | 4169 |
| Copthorne Tara Hotel London Kensington | 7105 | 3578 |
| ... | ... | ... |
| Mercure Paris Porte d Orleans | 110 | 10 |
| Hotel Wagner | 135 | 10 |
| Hotel Gallitzinberg | 173 | 8 |
మీరు గమనించవచ్చు, డేటాసెట్‌లో లెక్కించిన ఫలితాలు `Total_Number_of_Reviews` విలువతో సరిపోలవు. ఈ విలువ హోటల్‌కు ఉన్న మొత్తం సమీక్షల సంఖ్యను సూచించవచ్చు, కానీ అన్ని సమీక్షలు స్క్రాప్ చేయబడలేదు, లేదా మరొక లెక్కింపు. ఈ అస్పష్టత కారణంగా `Total_Number_of_Reviews` మోడల్‌లో ఉపయోగించబడదు.
5. డేటాసెట్‌లో ప్రతి హోటల్‌కు `Average_Score` కాలమ్ ఉన్నప్పటికీ, మీరు కూడా సగటు స్కోర్ లెక్కించవచ్చు (ప్రతి హోటల్‌కు డేటాసెట్‌లోని అన్ని సమీక్షకుల స్కోర్ల సగటు). మీ డేటాఫ్రేమ్‌కు `Calc_Average_Score` అనే కొత్త కాలమ్ జోడించండి, ఇందులో లెక్కించిన సగటు ఉంటుంది. `Hotel_Name`, `Average_Score`, మరియు `Calc_Average_Score` కాలమ్స్ ప్రింట్ చేయండి.
```python
# ఒక వరుసను తీసుకుని దానితో కొన్ని లెక్కింపులు చేసే ఫంక్షన్‌ను నిర్వచించండి
def get_difference_review_avg(row):
return row["Average_Score"] - row["Calc_Average_Score"]
# 'mean' అనేది 'సగటు' కోసం గణిత పదం
df['Calc_Average_Score'] = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)
# రెండు సగటు స్కోర్ల మధ్య తేడాతో కొత్త కాలమ్‌ను జోడించండి
df["Average_Score_Difference"] = df.apply(get_difference_review_avg, axis = 1)
# Hotel_Name యొక్క అన్ని ప్రతులేని df సృష్టించండి (అంటే ప్రతి హోటల్‌కు ఒక్క వరుస మాత్రమే)
review_scores_df = df.drop_duplicates(subset = ["Hotel_Name"])
# తక్కువ మరియు ఎక్కువ సగటు స్కోర్ తేడాను కనుగొనడానికి డేటాఫ్రేమ్‌ను సర్దుబాటు చేయండి
review_scores_df = review_scores_df.sort_values(by=["Average_Score_Difference"])
display(review_scores_df[["Average_Score_Difference", "Average_Score", "Calc_Average_Score", "Hotel_Name"]])
```
మీరు `Average_Score` విలువ గురించి ఆశ్చర్యపోవచ్చు, ఎందుకు అది లెక్కించిన సగటు స్కోర్‌తో కొన్నిసార్లు భిన్నంగా ఉంటుంది. కొన్ని విలువలు సరిపోతున్నాయి, మరికొన్నవి తేడా చూపుతున్నాయి ఎందుకు అనేది మనకు తెలియదు, కాబట్టి మనం కలిగిన సమీక్ష స్కోర్లను ఉపయోగించి సగటు స్వయంగా లెక్కించడం ఉత్తమం. అయితే, తేడాలు సాధారణంగా చాలా చిన్నవే, ఇక్కడ డేటాసెట్ సగటు మరియు లెక్కించిన సగటు మధ్య అత్యధిక తేడా ఉన్న హోటల్స్ ఉన్నాయి:
| Average_Score_Difference | Average_Score | Calc_Average_Score | Hotel_Name |
| :----------------------: | :-----------: | :----------------: | ------------------------------------------: |
| -0.8 | 7.7 | 8.5 | Best Western Hotel Astoria |
| -0.7 | 8.8 | 9.5 | Hotel Stendhal Place Vend me Paris MGallery |
| -0.7 | 7.5 | 8.2 | Mercure Paris Porte d Orleans |
| -0.7 | 7.9 | 8.6 | Renaissance Paris Vendome Hotel |
| -0.5 | 7.0 | 7.5 | Hotel Royal Elys es |
| ... | ... | ... | ... |
| 0.7 | 7.5 | 6.8 | Mercure Paris Op ra Faubourg Montmartre |
| 0.8 | 7.1 | 6.3 | Holiday Inn Paris Montparnasse Pasteur |
| 0.9 | 6.8 | 5.9 | Villa Eugenie |
| 0.9 | 8.6 | 7.7 | MARQUIS Faubourg St Honor Relais Ch teaux |
| 1.3 | 7.2 | 5.9 | Kube Hotel Ice Bar |
ఒకే హోటల్‌కు 1 కంటే ఎక్కువ తేడా ఉన్నందున, తేడాను పట్టించుకోకుండా లెక్కించిన సగటు స్కోర్‌ను ఉపయోగించడం మంచిది.
6. `Negative_Review` కాలమ్‌లో "No Negative" విలువ ఉన్న వరుసల సంఖ్య లెక్కించి ప్రింట్ చేయండి
7. `Positive_Review` కాలమ్‌లో "No Positive" విలువ ఉన్న వరుసల సంఖ్య లెక్కించి ప్రింట్ చేయండి
8. `Positive_Review` కాలమ్‌లో "No Positive" మరియు `Negative_Review` కాలమ్‌లో "No Negative" ఉన్న వరుసల సంఖ్య లెక్కించి ప్రింట్ చేయండి
```python
# లాంబ్డాలతో:
start = time.time()
no_negative_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" else False , axis=1)
print("Number of No Negative reviews: " + str(len(no_negative_reviews[no_negative_reviews == True].index)))
no_positive_reviews = df.apply(lambda x: True if x['Positive_Review'] == "No Positive" else False , axis=1)
print("Number of No Positive reviews: " + str(len(no_positive_reviews[no_positive_reviews == True].index)))
both_no_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" and x['Positive_Review'] == "No Positive" else False , axis=1)
print("Number of both No Negative and No Positive reviews: " + str(len(both_no_reviews[both_no_reviews == True].index)))
end = time.time()
print("Lambdas took " + str(round(end - start, 2)) + " seconds")
Number of No Negative reviews: 127890
Number of No Positive reviews: 35946
Number of both No Negative and No Positive reviews: 127
Lambdas took 9.64 seconds
```
## మరో విధానం
లాంబ్డా లేకుండా అంశాలను లెక్కించడానికి మరియు వరుసలను లెక్కించడానికి సం(మొత్తం) ఉపయోగించండి:
```python
# లాంబ్డాలు లేకుండా (మీకు రెండింటినీ ఉపయోగించవచ్చని చూపించడానికి వివిధ సూచనల మిశ్రమాన్ని ఉపయోగించడం)
start = time.time()
no_negative_reviews = sum(df.Negative_Review == "No Negative")
print("Number of No Negative reviews: " + str(no_negative_reviews))
no_positive_reviews = sum(df["Positive_Review"] == "No Positive")
print("Number of No Positive reviews: " + str(no_positive_reviews))
both_no_reviews = sum((df.Negative_Review == "No Negative") & (df.Positive_Review == "No Positive"))
print("Number of both No Negative and No Positive reviews: " + str(both_no_reviews))
end = time.time()
print("Sum took " + str(round(end - start, 2)) + " seconds")
Number of No Negative reviews: 127890
Number of No Positive reviews: 35946
Number of both No Negative and No Positive reviews: 127
Sum took 0.19 seconds
```
మీరు గమనించవచ్చు, `Negative_Review` మరియు `Positive_Review` కాలమ్స్‌లో వరుసలు 127 ఉన్నాయి, వీటిలో "No Negative" మరియు "No Positive" విలువలు ఉన్నాయి. అంటే సమీక్షకుడు హోటల్‌కు సంఖ్యాత్మక స్కోర్ ఇచ్చారు, కానీ పాజిటివ్ లేదా నెగటివ్ సమీక్ష రాయలేదు. అదృష్టవశాత్తు ఇది చాలా తక్కువ వరుసలు (515738లో 127, అంటే 0.02%), కాబట్టి ఇది మన మోడల్ లేదా ఫలితాలను ఏ దిశలోనూ ప్రభావితం చేయదు. కానీ సమీక్షల డేటాసెట్‌లో సమీక్షలు లేకపోవడం ఆశ్చర్యకరం, కాబట్టి ఇలాంటి వరుసలను కనుగొనడం విలువైనది.
ఇప్పుడు మీరు డేటాసెట్‌ను అన్వేషించారు, తదుపరి పాఠంలో మీరు డేటాను ఫిల్టర్ చేసి భావ విశ్లేషణ జోడిస్తారు.
---
## 🚀సవాలు
ఈ పాఠం, గత పాఠాలలో చూచినట్లుగా, మీ డేటాను మరియు దాని లోపాలను అర్థం చేసుకోవడం ఎంత ముఖ్యమో చూపిస్తుంది. ప్రత్యేకంగా టెక్స్ట్ ఆధారిత డేటా జాగ్రత్తగా పరిశీలించాలి. వివిధ టెక్స్ట్-భారీ డేటాసెట్‌లను పరిశీలించి, మోడల్‌లో పక్షపాతం లేదా త్రుటి భావాన్ని కలిగించే ప్రాంతాలను కనుగొనగలరా చూడండి.
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ml/)
## సమీక్ష & స్వీయ అధ్యయనం
[ఈ NLP లెర్నింగ్ పాత్](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77952-leestott) తీసుకోండి, స్పీచ్ మరియు టెక్స్ట్-భారీ మోడల్స్ నిర్మించేటప్పుడు ప్రయత్నించవలసిన టూల్స్ తెలుసుకోండి.
## అసైన్‌మెంట్
[NLTK](assignment.md)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

21
translations/te/6-NLP/4-Hotel-Reviews-1/assignment.md
Unescape View File

@ -0,0 +1,21 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "bf39bceb833cd628f224941dca8041df",
"translation_date": "2025-12-19T14:24:30+00:00",
"source_file": "6-NLP/4-Hotel-Reviews-1/assignment.md",
"language_code": "te"
}
-->
# NLTK
## సూచనలు
NLTK అనేది కంప్యూటేషనల్ లింగ్విస్టిక్స్ మరియు NLP లో ఉపయోగించే ప్రసిద్ధ లైబ్రరీ. ఈ అవకాశాన్ని ఉపయోగించి '[NLTK పుస్తకం](https://www.nltk.org/book/)' ను చదవండి మరియు దాని వ్యాయామాలను ప్రయత్నించండి. ఈ అగ్రేడ్ కాని అసైన్‌మెంట్‌లో, మీరు ఈ లైబ్రరీని మరింత లోతుగా తెలుసుకోగలుగుతారు.
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. అసలు పత్రం దాని స్వదేశీ భాషలోనే అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->

0
translations/te/6-NLP/4-Hotel-Reviews-1/notebook.ipynb
Unescape View File

17
translations/te/6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md
Unescape View File

@ -0,0 +1,17 @@
<!--
CO_OP_TRANSLATOR_METADATA:
{
"original_hash": "a39c15d63f3b2795ee2284a82b986b93",
"translation_date": "2025-12-19T14:47:29+00:00",
"source_file": "6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md",
"language_code": "te"
}
-->
ఇది తాత్కాలిక ప్లేస్‌హోల్డర్‌입니다
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
Write Preview
Loading…
Cancel
Save