# వంటక వర్గీకరణలు 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/te/map.e963a6a51349425a.webp)
> సూచన: [ఈ మ్యాప్‌ను ఆన్‌లైన్‌లో సందర్శించండి](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 -->