You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
242 lines
18 KiB
242 lines
18 KiB
# स्वयंपाक वर्गीकरण器 2
|
|
|
|
या दुसऱ्या वर्गीकरण धड्यांमध्ये, तुम्ही संख्यात्मक डेटाचे वर्गीकरण करण्याचे अधिक मार्ग शोधाल. तुम्हाला एक वर्गीकरण器 दुसऱ्या पेक्षा निवडण्याचे परिणाम देखील समजतील.
|
|
|
|
## [पूर्व-व्याख्यान क्विझ](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
### पूर्वअट
|
|
|
|
आपण गृहित धरतो की तुम्ही मागील धडे पूर्ण केले आहेत आणि तुमच्या `data` फोल्डरमध्ये _cleaned_cuisines.csv_ नावाचा स्वच्छ डेटा संच आहे, जो या 4-धोड्यांच्या फोल्डरच्या मूळामध्ये आहे.
|
|
|
|
### तयारी
|
|
|
|
आम्ही तुमचा _notebook.ipynb_ फाईल स्वच्छ डेटासेटसह लोड केला आहे आणि त्याला X आणि y डेटा फ्रेम्समध्ये विभाजित केले आहे, जे मॉडेल तयार करण्याच्या प्रक्रियेसाठी तयार आहेत.
|
|
|
|
## वर्गीकरण नकाशा
|
|
|
|
पूर्वी तुम्ही Microsoft च्या चीट शीट वापरून डेटाचे वर्गीकरण करताना उपलब्ध पर्यायांविषयी शिकलात. Scikit-learn हा एक समान, पण अधिक सूक्ष्म चीट शीट देतो जो तुमच्या अंदाजकांवर (वर्गीकरण器चा दुसरा शब्द) अधिक सहकार्य करू शकतो:
|
|
|
|
|
|
> सूचना: [या नकाशाला ऑनलाइन भेट द्या](https://scikit-learn.org/stable/tutorial/machine_learning_map/) आणि दस्तऐवज वाचण्यासाठी मार्गावर क्लिक करा.
|
|
|
|
### योजना
|
|
|
|
हा नकाशा तुमच्या डेटाची स्पष्ट कल्पना असताना खूप उपयुक्त आहे, कारण तुम्ही निर्णयासाठी त्याच्यावर 'चालू' शकता:
|
|
|
|
- आपल्याकडे >50 नमुने आहेत
|
|
- आपल्याला एखाद्या वर्गाची भाकीत करायची आहे
|
|
- आपल्याकडे लेबलेड डेटा आहे
|
|
- आपल्याकडे 100K पेक्षा कमी नमुने आहेत
|
|
- ✨ आपण Linear SVC निवडू शकतो
|
|
- जर ते कार्य केले नाही, तर आपल्याकडे संख्यात्मक डेटा असल्याने
|
|
- आपण एक ✨ KNeighbors वर्गीकरण器 वापरू शकतो
|
|
- जर तेही कार्य केले नाही, तर ✨ SVC आणि ✨ Ensemble वर्गीकरण器 वापरून पहा
|
|
|
|
ही एक खूप उपयुक्त मार्गदर्शिका आहे.
|
|
|
|
## सराव - डेटाचे विभाजन करा
|
|
|
|
या मार्गाचा अनुसरण करताना, आपण वापरण्यास काही लायब्ररीज आयात करुया.
|
|
|
|
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_features_df, cuisines_label_df, test_size=0.3)
|
|
```
|
|
|
|
## Linear SVC वर्गीकरण器
|
|
|
|
Support-Vector clustering (SVC) म्हणजे ML तंत्रज्ञानांच्या Support-Vector मशीन कुटुंबातील एक उपशाखा आहे (खाली याबद्दल अधिक वाचा). या पद्धतीत, तुम्ही लेबले कसे क्लस्टर करावेत हे ठरवण्यासाठी एक 'kernel' निवडू शकता. 'C' हा पॅरामीटर 'regularization' शी संबंधित आहे जो पॅरामीटरच्या प्रभावाला नियंत्रित करतो. kernel ही [काही](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC) असू शकते; येथे आम्ही ते 'linear' सेट केले आहे जेणेकरून आपण linear SVC वापरू. Probability ची मूल्ये डीफॉल्ट म्हणजे 'false'; येथे आम्ही ते 'true' ठेवले आहे जेणेकरून प्रॉबॅबिलिटी अंदाज मिळतील. आम्ही random state ला '0' सेट केले आहे ज्यामुळे डेटा शफल होतो आणि प्रॉबॅबिलिटी मिळते.
|
|
|
|
### सराव - linear SVC लागू करा
|
|
|
|
वर्गीकरण器ची एक यादी तयार करा. आपण चाचणी करताना हळूहळू या यादीत भर टाकाल.
|
|
|
|
1. Linear SVC ने सुरू करा:
|
|
|
|
```python
|
|
C = 10
|
|
# वेगवेगळे वर्गीकरण तयार करा.
|
|
classifiers = {
|
|
'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
|
|
}
|
|
```
|
|
|
|
2. Linear 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-Neighbors वर्गीकरण器
|
|
|
|
K-Neighbors हा ML पद्धतीच्या "शेजार्यांचे" कुटुंबातील एक भाग आहे, जो सुपर्वाइझ्ड आणि अनसुपर्वाइझ्ड दोन्ही शिक्षणासाठी वापरला जातो. या पद्धतीत, पूर्वनिर्धारित संख्येने पॉइंट्स तयार केले जातात आणि डेटा ह्या पॉइंट्सच्या भोवती जमलेला असतो ज्यामुळे सामान्यीकृत लेबले भाकीत केली जाऊ शकतात.
|
|
|
|
### सराव - K-Neighbors वर्गीकरण器 लागू करा
|
|
|
|
मागील वर्गीकरण器 चांगला होता आणि डेटाशी चांगले दिसला, पण कदाचित आपण चांगला अचूकता मिळवू शकू. K-Neighbors वर्गीकरण器 वापरून बघा.
|
|
|
|
1. तुमच्या वर्गीकरण器 यादीत एक नवीन ओळ जोडा (Linear 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-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors) बद्दल जाणून घ्या
|
|
|
|
## Support Vector वर्गीकरण器
|
|
|
|
Support-Vector वर्गीकरण器 हे ML पद्धतीच्या [Support-Vector मशीन](https://wikipedia.org/wiki/Support-vector_machine) कुटुंबाचा भाग आहेत जे वर्गीकरण आणि रिग्रेशन कार्यासाठी वापरले जातात. SVM "प्रशिक्षण उदाहरणांना स्पेसमधील बिंदूंवर नकाशित करतात" ज्यामुळे दोन वर्गांमधील अंतर जास्तीत जास्त होते. नंतरचा डेटा या स्पेसमध्ये नकाशित होतो आणि त्याच्या वर्गाची भाकीत केली जाते.
|
|
|
|
### सराव - Support Vector वर्गीकरण器 लागू करा
|
|
|
|
Support Vector वर्गीकरण器 वापरून थोडी अधिक अचूकता मिळवण्याचा प्रयत्न करूया.
|
|
|
|
1. K-Neighbors नंतर कॉमा लावा आणि नंतर ही ओळ जोडा:
|
|
|
|
```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
|
|
```
|
|
|
|
✅ [Support-Vectors](https://scikit-learn.org/stable/modules/svm.html#svm) बद्दल जाणून घ्या
|
|
|
|
## Ensemble वर्गीकरण器
|
|
|
|
पूर्वीचा परीक्षण चांगला असल्याने, तरीही आपल्याला शेवटच्या टप्प्यापर्यंत जायचे आहे. आपण 'Ensemble वर्गीकरण器 वापरून बघू, विशेषतः Random Forest आणि AdaBoost:
|
|
|
|
```python
|
|
'RFST': RandomForestClassifier(n_estimators=100),
|
|
'ADA': AdaBoostClassifier(n_estimators=100)
|
|
```
|
|
|
|
निकाल खूप चांगला आहे, विशेषत: Random Forest साठी:
|
|
|
|
```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
|
|
```
|
|
|
|
✅ [Ensemble वर्गीकरण器](https://scikit-learn.org/stable/modules/ensemble.html) बद्दल जाणून घ्या
|
|
|
|
या मशीन लर्निंग पद्धती "अनेक बेस अंदाजकांच्या भाकितांचे एकत्रीकरण" करतात ज्यामुळे मॉडेलची गुणवत्ता वाढते. आपल्या उदाहरणात, आपण Random Trees आणि AdaBoost वापरले.
|
|
|
|
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), एक सरासरीकरण पद्धत, ज्यात विविधता टाळण्यासाठी 'decision trees' चा जंगल तयार केला जातो. n_estimators हा पॅरामीटर वृक्षांची संख्या दर्शवितो.
|
|
|
|
- [AdaBoost](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 --> |