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/)
|
|
|
|
### ముందస్తు అర్హత
|
|
|
|
మీరు గత పాఠాలను పూర్తి చేసి, ఈ 4-పాఠాల ఫోల్డర్ రూట్లోని `data` ఫోల్డర్లో _cleaned_cuisines.csv_ అనే శుభ్రపరిచిన డేటాసెట్ ఉందని మేము భావిస్తాము.
|
|
|
|
### సిద్ధత
|
|
|
|
మేము మీ _notebook.ipynb_ ఫైల్లో శుభ్రపరిచిన డేటాను లోడ్ చేసి, మోడల్ నిర్మాణ ప్రక్రియకి సిద్ధంగా X మరియు y డేటాఫ్రేమ్లుగా విభజించాం.
|
|
|
|
## ఒక వర్గీకరణ మ్యాప్
|
|
|
|
మునుపటి పాఠంలో మీరు మైక్రోసాఫ్ట్ యొక్క చీట్ షీట్ ఉపయోగించి డేటాను వర్గీకరించేటప్పుడు అనేక ఎంపికలు తెలుసుకున్నారు. Scikit-learn మరింత సూటిగా మరియు విస్తృతంగా సహాయం చేసే చీట్ షీట్ను అందిస్తుంది, ఇది మీ అంచనాకర్తలను (ఇంకా వర్గీకర్తలు అని పిలవబడే) మరింత కుదించడంలో సహాయం చేస్తుంది:
|
|
|
|
|
|
> సూచన: [ఈ మ్యాప్ను ఆన్లైన్లో సందర్శించండి](https://scikit-learn.org/stable/tutorial/machine_learning_map/) మరియు దారిని క్లిక్ చేసి డాక్యుమెంటేషన్ చదవండి.
|
|
|
|
### ప్రణాళిక
|
|
|
|
ఈ మ్యాప్ మీ డేటాను స్పష్టంగా అర్థం చేసుకున్న తర్వాత చాలా ఉపయోగకరం, ఎందుకంటే మీరు దాని దారులను 'నడవచ్చు' మరియు నిర్ణయం తీసుకోవచ్చు:
|
|
|
|
- మాకు 50కి పైగా నమూనాలు ఉన్నాయి
|
|
- మేము ఒక వర్గాన్ని అంచనా వేయాలి
|
|
- మాకు లేబుల్ చేయబడిన డేటా ఉంది
|
|
- మాకు 100K కన్నా తక్కువ నమూనాలు ఉన్నాయి
|
|
- ✨ మేము లీనియర్ SVC ని ఎంచుకోవచ్చు
|
|
- అది పనిచేయకపోతే, సంఖ్యాత్మక డేటా ఉందాకాక మరి
|
|
- మేము ✨ KNeighbors వర్గీకర్త ప్రయత్నించవచ్చు
|
|
- అది పనిచేయకపోతే, ✨ SVC మరియు ✨ ఎంసెంబుల్ వర్గీకర్తలను ప్రయత్నించండి
|
|
|
|
ఇది అనుసరించడానికి చాలా ఉపయోగకరమైన ట్రైల్.
|
|
|
|
## వ్యాయామం - డేటాను విభజించండి
|
|
|
|
ఈ దారిని అనుసరించి, కొన్ని లైబ్రరీలను దిగుమతి చేయడం మొదలుపెట్టాలి.
|
|
|
|
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)
|
|
```
|
|
|
|
## లీనియర్ SVC వర్గీకర్త
|
|
|
|
సపోర్ట్-వెక్టర్ క్లస్టరింగ్ (SVC) అనేది SVM పద్ధతుల కుటుంబానికి చెందినది (ఇవి గురించి దిగువ తెలుసుకోండి). ఈ పద్ధతిలో, మీరు లేబుళ్లను ఎలా క్లస్టర్ చేయాలో నిర్ణయించేందుకు 'కెర్నెల్'ను ఎంచుకోవచ్చు. 'C' పరామితి అనేది 'రెగ్యులరైజేషన్'కి సంబంధించినది, ఇది ప్రామాణాలను నియంత్రిస్తుంది. కెర్నెల్ [బహువిధాలుగా](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC) ఉండవచ్చు; ఇక్కడ లీనియర్ SVC కోసం 'linear' గా సెట్ చేసాం. ప్రాబబిలిటీ డిఫాల్ట్గా 'false'; ఇక్కడ probability estimates సేకరించేందుకు 'true' గా సెట్ చేసాం. రాండమ్ స్టేట్ 0 ప్లేస్ చేసి డేటాను షఫుల్ చేసి ప్రాబబిలిటీలను పొందుతాము.
|
|
|
|
### వ్యాయామం - లీనియర్ SVC ఉపయోగించండి
|
|
|
|
వర్గీకర్తాల సరసన ఒక అర్రే తయారు చేయడం మొదలుపెట్టండి. పరీక్షలతో క్రమంగా దీన్ని పెంచుతారు.
|
|
|
|
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-Neighbors వర్గీకర్త
|
|
|
|
K-Neighbors అనేది "నైబర్స్" కుటుంబంలోని ML పద్ధతికి చెందినది, ఇది పర్యవేక్షిత మరియు అపర్యవేక్షిత రెండింటి కోసం ఉపయోగించవచ్చు. ఈ పద్ధతిలో, ముందుగా నిర్దేశించిన కొంత పాయింట్లు సృష్టించి, ఆ పాయింట్ల చుట్టూ డేటా సేకరించి, సాధారణీకరించిన లేబుళ్లను అంచనా వేయడం జరుగుతుంది.
|
|
|
|
### వ్యాయామం - K-Neighbors వర్గీకర్త ఉపయోగించండి
|
|
|
|
గత వర్గీకర్త బాగుంది, డేటాతో బాగా పని చేసింది, కానీ బెటర్ ఖచ్చితత్వం రావచ్చు. మీరు K-Neighbors వర్గీకర్తను ప్రయత్నించండి.
|
|
|
|
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-Neighbors గురించి నేర్చుకోండి](https://scikit-learn.org/stable/modules/neighbors.html#neighbors)
|
|
|
|
## సపోర్ట్ వెక్టర్ వర్గీకర్త
|
|
|
|
సపోర్ట్-వెక్టర్ వర్గీకర్తలు [సపోర్ట్-వెక్టర్ మిషన్](https://wikipedia.org/wiki/Support-vector_machine) కుటుంబానికి చెందిన ML పద్ధతులు, ఇవి వర్గీకరణ మరియు రేగ్రెషన్ పనుల కోసం ఉపయోగిస్తారు. SVMలు "శిక్షణ ఉదాహరణలను స్థలాలలో పాయింట్లుగా మ్యాప్" చేసి రెండు వర్గాల మధ్య దూరాన్ని గరిష్టం చేస్తాయి. తదుపరి డేటాను ఈ స్థలంలో మ్యాప్ చేసి వారి వర్గం అంచనా వేయబడుతుంది.
|
|
|
|
### వ్యాయామం - సపోర్ట్ వెక్టర్ వర్గీకర్త అన్వయించండి
|
|
|
|
మంచి ఖచ్చితత్వానికి సపోర్ట్ వెక్టర్ వర్గీకర్త ప్రయత్నిద్దాం.
|
|
|
|
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
|
|
```
|
|
|
|
✅ [సపోర్ట్-వెక్టర్లు గురించి తెలుసుకోండి](https://scikit-learn.org/stable/modules/svm.html#svm)
|
|
|
|
## ఎంసెంబుల్ వర్గీకర్తలు
|
|
|
|
మునుపటి పరీక్ష బాగుంది కానీ చివరకు ప్రయోగం ముగించడానికి ‘ఎంసెంబుల్ వర్గీకర్తలు’, ముఖ్యంగా రాండమ్ ఫారెస్ట్ మరియు AdaBoost ప్రయత్నిద్దాం:
|
|
|
|
```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)
|
|
|
|
ఈ యంత్ర అభ్యాస పద్ధతి "చాలా బేస్ అంచనాలు కలిపి" మోడల్ నాణ్యతను మెరుగుపరుస్తుంది. ఉదాహరణకు, మనం రాండమ్ ట్రీ మరియు AdaBoost ఉపయోగించాము.
|
|
|
|
- [రాండమ్ ఫారెస్ట్](https://scikit-learn.org/stable/modules/ensemble.html#forest), అవరేజ్ పద్ధతి, ఒవర్ఫిటింగ్ నివారించేందుకు యాదృచ్ఛికతతో 'దిశ 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 --> |