|
|
# ಆಹಾರ ಶ್ರೇಣಿಗಾರರು 1
|
|
|
|
|
|
ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ಹಿಂದಿನ ಪಾಠದಿಂದ ಉಳಿಸಿಕೊಂಡ ಉತ್ತಮ ಸಮತೋಲನದ, ಶುಚಿತ್ವವಿರುವ ಆಹಾರ ಪದ್ದತಿಯ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಬಳಸಲಿದ್ದೀರಿ.
|
|
|
|
|
|
ನೀವು ಈ ಡೇಟಾಸೆಟ್ ಅನ್ನು ವಿವಿಧ ಶ್ರೇಣಿಗಾರರೊಂದಿಗೆ ಬಳಸುವಿರಿ _ಒಂದು ನೀಡಲಾದ ರಾಷ್ಟ್ರೀಯ ಆಹಾರವನ್ನು ಸಾಮಗ್ರಿಗಳ ಗುಂಪಿನ ಆಧಾರದ ಮೇಲೆ ಊಹಿಸಲು_. ಇದನ್ನು ಮಾಡುವಾಗ, ನೀವು ಶ್ರೇಣಿಗಾರಣ ಕಾರ್ಯಗಳಿಗೆ ಆಲ್ಗೊರಿದಮ್ಗಳು ಹೇಗೆ ಉಪಯೋಗಿಸಬಹುದೋ ಅದರ ಬಗ್ಗೆ ಹೆಚ್ಚು ತಿಳಿಯುವಿರಿ.
|
|
|
|
|
|
## [ಪಾಠದ ಮುಂಚೆಯ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
# ತಯಾರಿ
|
|
|
|
|
|
ನೀವು [ಪಾಠ 1](../1-Introduction/README.md) ಪೂರ್ಣಗೊಂಡಿರೆಂದು ಊಹಿಸಿಕೊಂಡರೆ, ಈ ನಾಲ್ಕು ಪಾಠಗಳಿಗೆ root `/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 ಗಳನ್ನು ಹೋಲಿಸಿ ಫಲಿತಾಂಶಗಳನ್ನು ದೃಶ್ಯರೂಪದಲ್ಲಿ ತೋರಿಸುತ್ತದೆ:
|
|
|
|
|
|
|
|
|
> 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) ಯಲ್ಲಿ ತಿಳಿಸಲಾಗಿದೆ. ಇಲ್ಲಿ, ನಮ್ಮ ಬಹುಶ್ರೇಣಿ ಸಮಸ್ಯೆಗೆ ನಾವು ಕೆಲವು ಆಯ್ಕೆಗಳು ಇದ್ದವೆಂದು ಕಂಡುಬರುತ್ತದೆ:
|
|
|
|
|
|
|
|
|
> Microsoftನ ಆಲ್ಗೊರಿದಮ್ ಚೀಟ್ಶೀಟ್ನ ಒಂದು ಭಾಗ, ಬಹುಶ್ರೇಣಿ ಶ್ರೇಣಿಗಾರಣ ಕುರಿತು ವಿವರಿಸುತ್ತಿದೆ
|
|
|
|
|
|
✅ ಈ ಚೀಟ್ಶೀಟ್ ಡೌನ್ಲೋಡ್ ಮಾಡಿ, ಪ್ರಿಂಟ್ ಮಾಡಿ, ನಿಮ್ಮ ಗೋಡೆಗೆ ಹಾಕಿ!
|
|
|
|
|
|
### ತರ್ಕ
|
|
|
|
|
|
ನಮ್ಮ ನಿಯಮಾವಳಿಗಳನ್ನು ಪರಿಗಣಿಸಿ ವಿಭಿನ್ನ ವಿಧಾನಗಳ ಮೂಲಕ ನಾವು ಹೇಗೆ ತರ್ಕ ಮಾಡಬಬಹುದೋ ನೋಡಿ:
|
|
|
|
|
|
- **ನೇರ ಅಂಗಾಂತರಗಳು ತುಂಬ ಭಾರಿ**. ನಮ್ಮ ಸ್ವಚ್ಚ ಆದರೆ ಕನಿಷ್ಠ ಡೇಟಾಸೆಟ್ ಮತ್ತು ನೋಟ್ಬುಕ್ ಮೂಲಕ ಸ್ಥಳೀಯವಾಗಿ ತರಬೇತಿಯನ್ನು ನಡೆಸುತ್ತಿರುವ ಕಾರಣ, ನೇರ ಅಂಗಾಂತರಗಳು ಈ ಕಾರ್ಯಕ್ಕೆ ತುಂಬ ಭಾರಿಯಾಗಿವೆ.
|
|
|
- **ಎರಡೂ ತರಗತಿಯ ಶ್ರೇಣಿಗಾರವಿಲ್ಲ**. ನಾವು ಎರಡೂ ತರಗತಿಯ ಶ್ರೇಣಿಗಾರವನ್ನು ಬಳಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಒನ್-ವರ್ಸ್-ಆಲ್ ನಿಯಮ ಹೊರಗೂ ಹೋಗುತ್ತದೆ.
|
|
|
- **ನಿರ್ಣಯ ಮರ ಅಥವಾ ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು**. ನಿರ್ಣಯ ಮರ ಕೆಲಸಮಾಡಬಹುದು, ಅಥವಾ ಬಹುಶ್ರೇಣಿ ಡೇಟಾಗಾಗಿ ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್.
|
|
|
- **ಬಹುಶ್ರೇಣಿ ಬೂಸ್ಟೆಡ್ ನಿರ್ಣಯ ಮರಗಳು ಒಂದು ವಿಭಿನ್ನ ಸಮಸ್ಯೆ ಪರಿಹರಿಸುತ್ತವೆ**. ಬಹುಶ್ರೇಣಿ ಬೂಸ್ಟೆಡ್ ನಿರ್ಣಯ ಮರಗಳು ಅಪ್ರಾಮಾಣಿಕ ಕಾರ್ಯಗಳಿಗೆ ಸೂಕ್ತ, ಉದಾ: ರ್ಯಾಂಕಿಂಗ್ ನಿರ್ಮಿಸುವ ಕಾರ್ಯಗಳಿಗೆ, ನಾವು ಬಳಸುವುದಕ್ಕೆ ಸಹಾಯವಾಗುವುದಿಲ್ಲ.
|
|
|
|
|
|
### 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` ಏನನ್ನು ಬಳಸಬೇಕೆಂಬ ಆಲ್ಗೊರಿದಮ್ ಆಗಿದೆ. ಎಲ್ಲಾ ಸಮಸ್ಯೆದ್ಯುಕ್ತ ಕೇಸ್ಗಳಿಗೆ ಎಲ್ಲಾ `multi_class` ಮೌಲ್ಯಗಳು ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ.
|
|
|
|
|
|
ಡಾಕ್ಯುಮೆಂಟ್ ಪ್ರಕಾರ, ಬಹುಶ್ರೇಣಿ ಪ್ರಕರಣದಲ್ಲಿ, ತರಬೇತಿ ಆಲ್ಗೊರಿದಮ್:
|
|
|
|
|
|
- **ಒನ್-ವರ್ಸ್-ರೆಸ್ಟ್ (OvR) ಯೋಜನೆಯನ್ನು ಬಳಸುತ್ತದೆ**, `multi_class` ಆಯ್ಕೆ `ovr` ಆಗಿದ್ದರೆ
|
|
|
- **ಕ್ರಾಸ್ ಎಂಟ್ರೋಪಿ ನಷ್ಟವನ್ನು ಬಳಸುತ್ತದೆ**, `multi_class` ಆಯ್ಕೆ `multinomial` ಆಗಿದ್ದರೆ. (ಪ್ರಸ್ತುತ `multinomial` ಆಯ್ಕೆ ‘lbfgs’, ‘sag’, ‘saga’ ಮತ್ತು ‘newton-cg’ ಪರಿಹಾರಕಾರರನ್ನೇ ಮಾತ್ರ ಬೆಂಬಲಿಸುತ್ತದೆ.)"
|
|
|
|
|
|
> 🎓 ಇಲ್ಲಿ 'ಯೋಜನೆ' ಎಂದರೆ '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 ಈ ಟೇಬಲ್ ಮೂಲಕ ವಿಭಿನ್ನ ರೀತಿಯ ಡೇಟಾ ರಚನೆಗಳಿಂದ ಉಂಟಾಗುವ ವಿವಿಧ ಸವಾಲುಗಳನ್ನು ಪರಿಹರಿಸುವ ಮೂಲಕ ಪರಿಹಾರಕಾರಿಕಳ ನಿರ್ವಹಣೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ:
|
|
|
|
|
|
|
|
|
|
|
|
## ಅಭ್ಯಾಸ - ಡೇಟಾವನ್ನು ವಿಭಜಿಸಿ
|
|
|
|
|
|
ನೀವು ಇತ್ತೀಚೆಗೆ ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ಇದನ್ನು ತಿಳಿದುಕೊಂಡಿರುವುದರಿಂದ ಮೊದಲ ತರಬೇತಿ ಪ್ರಯತ್ನಕ್ಕಾಗಿ ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್ ಮೇಲೆ ಗಮನಹರಿಸಬಹುದು. `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)
|
|
|
```
|
|
|
|
|
|
## ಅಭ್ಯಾಸ - ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್ ಅನ್ವಯಿಸಿ
|
|
|
|
|
|
ನೀವು ಬಹುಶ್ರೇಣಿ ಪ್ರಕರಣವನ್ನು ಬಳಸುತ್ತಿರುವುದರಿಂದ ಯಾವ _ಯೋಜನೆ_ ಬಳಸಬೇಕು ಮತ್ತು ಯಾವ _ಪರಿಹಾರಕಾರ_ಸೇರಿಸಬೇಕು ಎಂಬುದನ್ನು ಆಯ್ಕೆಮಾಡಬೇಕು. ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನನ್ನು ಬಹುಶ್ರೇಣಿ ಸಜ್ಜುಗೊಳಿಸುವಿಕೆಯೊಂದಿಗೆ ಮತ್ತು **liblinear** ಪರಿಹಾರಕಾರಿಕೆಯನ್ನು ಬಳಸಲು ತರಬೇತಿ ಮಾಡಿ.
|
|
|
|
|
|
1. multi_class ಅನ್ನು `ovr` ಗೆ, ಪರಹಾರಕಾರವನ್ನು `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` ಎಂಬ ಭಿನ್ನ ಪರಿಹಾರಕಾರಿಯನ್ನು ಪ್ರಯತ್ನಿಸಿ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಡೀಫಾಲ್ಟ್ ಆಗಿರುತ್ತದೆ
|
|
|
|
|
|
> ಗಮನಿಸಿ, ಅಗತ್ಯವಿದ್ದಾಗ ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಫ್ಲಾಟ್ ಮಾಡುವುದಕ್ಕೆ 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 |
|
|
|
|
|
|
## 🚀ಚೆಲಂಜ್
|
|
|
|
|
|
ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ನಿಮ್ಮ ಸ್ವಚ್ಛಮಾಡಿದ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು ಕೆಲವು घटಕಗಳ ಆಧಾರದಲ್ಲಿ ರಾಷ್ಟ್ರೀಯ ಆಹಾರವನ್ನು ಊಹಿಸಬಹುದಾದ ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿದ್ದೀರಿ. ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸಲು ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಒದಗಿಸುವ ಹಲವು ಆಯ್ಕೆಗಳನ್ನೂ ಓದುತ್ತಾ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ. 'ಸಾಲ್ವರ್' ಎಂಬ ಸಂಯೋಜನೆಯ ಬಗ್ಗೆ ವರ್ಗಗಳ ಹಿಂದೆ ಏನು ನಡೆಯುತ್ತಿದೆಯೆಂದು ಹೆಚ್ಚು ತಿಳಿದುಕೊಳ್ಳಿ.
|
|
|
|
|
|
## [ಪಾಠೋತ್ತರ ಪ್ರಶ್ನೋತ್ತರ](https://ff-quizzes.netlify.app/en/ml/)
|
|
|
|
|
|
## ವಿಮರ್ಶೆ & ಸ್ವಅಧ್ಯಯನ
|
|
|
|
|
|
ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್ ಹಿಂದಿನ ಗಣಿತವನ್ನು ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಲು [ಈ ಪಾಠ](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf) ಅನ್ನು ಓದಿ
|
|
|
## ನೀಡಲಾಗಿರುವ ಕಾರ್ಯ
|
|
|
|
|
|
[ಸಾಲ್ವರ್ಗಳ ಅಧ್ಯಯನ](assignment.md)
|
|
|
|
|
|
---
|
|
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
|
**ಅಸ್ವೀಕರಣ**:
|
|
|
ಈ ದಸ್ತಾವೇಜನ್ನು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವದಿಸಲಾಗಿದೆ. ನಾವು ಸರಿಯಾದ ಅನುವಾದ ನೀಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಾರತಮ್ಯಗಳಿರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ మూలವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವವಾದ ಮಾಹಿತಿಗೆ ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ. ಈ ಅನುವಾದವನ್ನು ಬಳಸುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು سمجھುತೆಗಳು ಅಥವಾ ವೈಖರಿಗಳಿಗಾಗಿ ನಾವು ಜವಾಬ್ದಾರಿಯಾಗುವುದಿಲ್ಲ.
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |
