ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ಹಿಂದಿನ ಪಾಠದಿಂದ ಉಳಿಸಿಕೊಂಡ ಉತ್ತಮ ಸಮತೋಲನದ, ಶುಚಿತ್ವವಿರುವ ಆಹಾರ ಪದ್ದತಿಯ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಬಳಸಲಿದ್ದೀರಿ.
ನೀವು ಈ ಡೇಟಾಸೆಟ್ ಅನ್ನು ವಿವಿಧ ಶ್ರೇಣಿಗಾರರೊಂದಿಗೆ ಬಳಸುವಿರಿ ಒಂದು ನೀಡಲಾದ ರಾಷ್ಟ್ರೀಯ ಆಹಾರವನ್ನು ಸಾಮಗ್ರಿಗಳ ಗುಂಪಿನ ಆಧಾರದ ಮೇಲೆ ಊಹಿಸಲು. ಇದನ್ನು ಮಾಡುವಾಗ, ನೀವು ಶ್ರೇಣಿಗಾರಣ ಕಾರ್ಯಗಳಿಗೆ ಆಲ್ಗೊರಿದಮ್ಗಳು ಹೇಗೆ ಉಪಯೋಗಿಸಬಹುದೋ ಅದರ ಬಗ್ಗೆ ಹೆಚ್ಚು ತಿಳಿಯುವಿರಿ.
ನೀವು ಪಾಠ 1 ಪೂರ್ಣಗೊಂಡಿರೆಂದು ಊಹಿಸಿಕೊಂಡರೆ, ಈ ನಾಲ್ಕು ಪಾಠಗಳಿಗೆ root /data ಫೋಲ್ಡರ್ನಲ್ಲಿ _cleaned_cuisines.csv_ಫೈಲ್ ಇರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
-
ಈ ಪಾಠದ notebook.ipynb ಫೋಲ್ಡರ್ನಲ್ಲಿ ಆ ಫೈಲಿನೊಂದಿಗೆ Pandas ಪುಸ್ತಕಾಲಯವನ್ನು ಆಮದುಮಾಡಿ:
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 |
-
ಈಗ, ಇನ್ನೂ ಹಲವಾರು ಪುಸ್ತಕಾಲಯಗಳನ್ನೂ ಆಮದುಮಾಡಿ:
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
-
ತರಬೇತಿ ಮಾಡಲು ಎರಡು ಡೇಟಾ ಫ್ರೇಮ್ಗಳಾಗಿ X ಮತ್ತು y ಸ್ಥಾನದವುಗಳನ್ನು ವಿಭಜಿಸಿ.
cuisineಲೇಬಲ್ ಫ್ರೇಮ್ ಆಗಬಹುದು:cuisines_label_df = cuisines_df['cuisine'] cuisines_label_df.head()
ಹೀಗೆ ಕಾಣುತ್ತದೆ:
0 indian 1 indian 2 indian 3 indian 4 indian Name: cuisine, dtype: object -
ಆ
Unnamed: 0ಅಡಿಗಳು ಮತ್ತುcuisineಅಡಿಗಳನ್ನುdrop()ಮೂಲಕ ತೆಗೆಯಿರಿ. ಉಳಿದ ಡೇಟಾವನ್ನು ತರಬೇತಿ ಮಾಡುವ ಲಕ್ಷಣಗಳಂತೆ ಉಳಿಸಿ: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 |
| 1 | 1 | 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 |
| 3 | 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 |
ಈಗ ನೀವು ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡಲು ಸಿದ್ಧರಾಗಿದ್ದೀರಿ!
ನಿಮ್ಮ ಡೇಟಾ ಶುಚಿತ್ವಗೊಂಡು ತರಬೇತಿಗೆ ಸಿದ್ಧವಾದ ಕಾರಣ, ನೀವು ಕೆಲಸಕ್ಕಾಗಿ ಯಾವ ಆಲ್ಗೊರಿದಮ್ ಬಳಸಬೇಕೆಂಬುದನ್ನು ನಿರ್ಧರಿಸಬೇಕು.
Scikit-learn, ಶ್ರೇಣಿಗಾರಣವನ್ನು ಮೇಲ್ವಿಚಾರಿತ ಕಲಿಕೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಮತ್ತು ಆ ವರ್ಗದಲ್ಲಿ ನೀವು ಶ್ರೇಣಿಗಾರಣಕ್ಕೆ ಅನೇಕ ವಿಧಾನಗಳನ್ನು ಕಾಣುತ್ತೀರಿ. ವೈವಿಧ್ಯ ಮೊದಲನೆಯ ನೋಟಕ್ಕೆ ಸ್ವಲ್ಪ ಗೊಂದಲಕಾರಿಯಾಗಿದೆ. ಕೆಳಗಿನ ಕ್ರಮಗಳು ಎಲ್ಲಾ ಶ್ರೇಣಿಗಾರಣ ತಂತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿವೆ:
- ರೇಖೀಯ ಮಾದರಿಗಳು
- ಬೆಂಬಲ ಸೇರೆ ಯಂತ್ರಗಳು
- ಸ್ಥೋಚ್ಚಿಕ ಪ್ರಮೇಯ ಇಳಿಜಾರಿನ ಇಳಿವು
- ಹತ್ತಿರದ ನೆರೆಹೊರೆಯವರು
- ಗೌಸಿಯನ್ ಪ್ರಕ್ರಿಯೆಗಳು
- ನಿರ್ಣಯ ಮರಗಳು
- ಸಂಯೋಜಿತ ವಿಧಾನಗಳು (ವಾೕಟಿಂಗ್ ಕ್ಲಾಸಿಫೈಯರ್)
- ಬಹುಶ್ರೇಣಿ ಮತ್ತು ಬಹು-ಪದಾರ್ಥ ಆಲ್ಗೊರಿದಮ್ಗಳು (ಬಹುಶ್ರೇಣಿ ಮತ್ತು ಬಹು-ಲೇಬಲ್ ವರ್ಗೀಕರಣ, ಬಹುಶ್ರೇಣಿ-ಬಹುಪರಿಣಾಮ ವರ್ಗೀಕರಣ)
ನೀವು ನೇರ ಅಂಗಾಂತರಗಳ ಮೂಲಕ ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸಲು ಬಳಸಬಹುದು, ಆದರೆ ಅದು ಈ ಪಾಠದ ವ್ಯಾಪ್ತಿಗೆ ಹೊರಗಿನದು.
ಹೀಗಾದರೆ, ನೀವು ಯಾವ ಶ್ರೇಣಿಗಾರನ್ನು ಆಯ್ಕೆಮಾಡಬೇಕು? ಹೆಚ್ಚಾಗಿ, ಹಲವಾರು ರನ್ ಮಾಡಿ ಉತ್ತಮ ಫಲಿತಾಂಶ ನೋಡելը ಪರೀಕ್ಷೆ ಮಾಡಲು ಒಂದು ಮಾರ್ಗ. Scikit-learn ಒಂದು ರಚಿಸಲಾದ ಡೇಟಾಸೆಟ್ಟಿನ ಮೇಲೆ ಬದಿಗೊಡಣೆ ನೀಡಿದೆ, ಅದು KNeighbors, SVC ಎರಡು ರೀತಿಗಳು, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB ಮತ್ತು QuadraticDiscrinationAnalysis ಗಳನ್ನು ಹೋಲಿಸಿ ಫಲಿತಾಂಶಗಳನ್ನು ದೃಶ್ಯರೂಪದಲ್ಲಿ ತೋರಿಸುತ್ತದೆ:
Scikit-learnದ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ನಲ್ಲಿ ರಚಿಸಲಾದ ಪ್ಲಾಟ್ಗಳು
AutoML ಈ ಸಮಸ್ಯೆಯನ್ನು ಕ್ಲೌಡ್ನಲ್ಲಿ ಈ ಹೋಲಿಕೆಗಳನ್ನು ನಡೆಸಿ ನಿಮ್ಮ ಡೇಟಾಕ್ಕೆ ಉತ್ತಮ ಆಲ್ಗೊರಿದಮ್ ಆಯ್ಕೆಮಾಡಲು ಸಹಾಯಮಾಡುತ್ತದೆ. ಇಲ್ಲಿ ಪ್ರಯತ್ನಿಸಿ ಇಲ್ಲಿ
ಆದರೆ, ಸುಳ್ಳು ಊಹಿಸುವುದಕ್ಕಿಂತ ಉತ್ತಮ ವಿಧಾನ ಡೌನ್ಲೋಡ್ ಮಾಡಬಹುದಾದ ML ಚೀಟ್ಶೀಟ್ ಯಲ್ಲಿ ತಿಳಿಸಲಾಗಿದೆ. ಇಲ್ಲಿ, ನಮ್ಮ ಬಹುಶ್ರೇಣಿ ಸಮಸ್ಯೆಗೆ ನಾವು ಕೆಲವು ಆಯ್ಕೆಗಳು ಇದ್ದವೆಂದು ಕಂಡುಬರುತ್ತದೆ:
Microsoftನ ಆಲ್ಗೊರಿದಮ್ ಚೀಟ್ಶೀಟ್ನ ಒಂದು ಭಾಗ, ಬಹುಶ್ರೇಣಿ ಶ್ರೇಣಿಗಾರಣ ಕುರಿತು ವಿವರಿಸುತ್ತಿದೆ
✅ ಈ ಚೀಟ್ಶೀಟ್ ಡೌನ್ಲೋಡ್ ಮಾಡಿ, ಪ್ರಿಂಟ್ ಮಾಡಿ, ನಿಮ್ಮ ಗೋಡೆಗೆ ಹಾಕಿ!
ನಮ್ಮ ನಿಯಮಾವಳಿಗಳನ್ನು ಪರಿಗಣಿಸಿ ವಿಭಿನ್ನ ವಿಧಾನಗಳ ಮೂಲಕ ನಾವು ಹೇಗೆ ತರ್ಕ ಮಾಡಬಬಹುದೋ ನೋಡಿ:
- ನೇರ ಅಂಗಾಂತರಗಳು ತುಂಬ ಭಾರಿ. ನಮ್ಮ ಸ್ವಚ್ಚ ಆದರೆ ಕನಿಷ್ಠ ಡೇಟಾಸೆಟ್ ಮತ್ತು ನೋಟ್ಬುಕ್ ಮೂಲಕ ಸ್ಥಳೀಯವಾಗಿ ತರಬೇತಿಯನ್ನು ನಡೆಸುತ್ತಿರುವ ಕಾರಣ, ನೇರ ಅಂಗಾಂತರಗಳು ಈ ಕಾರ್ಯಕ್ಕೆ ತುಂಬ ಭಾರಿಯಾಗಿವೆ.
- ಎರಡೂ ತರಗತಿಯ ಶ್ರೇಣಿಗಾರವಿಲ್ಲ. ನಾವು ಎರಡೂ ತರಗತಿಯ ಶ್ರೇಣಿಗಾರವನ್ನು ಬಳಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಒನ್-ವರ್ಸ್-ಆಲ್ ನಿಯಮ ಹೊರಗೂ ಹೋಗುತ್ತದೆ.
- ನಿರ್ಣಯ ಮರ ಅಥವಾ ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು. ನಿರ್ಣಯ ಮರ ಕೆಲಸಮಾಡಬಹುದು, ಅಥವಾ ಬಹುಶ್ರೇಣಿ ಡೇಟಾಗಾಗಿ ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್.
- ಬಹುಶ್ರೇಣಿ ಬೂಸ್ಟೆಡ್ ನಿರ್ಣಯ ಮರಗಳು ಒಂದು ವಿಭಿನ್ನ ಸಮಸ್ಯೆ ಪರಿಹರಿಸುತ್ತವೆ. ಬಹುಶ್ರೇಣಿ ಬೂಸ್ಟೆಡ್ ನಿರ್ಣಯ ಮರಗಳು ಅಪ್ರಾಮಾಣಿಕ ಕಾರ್ಯಗಳಿಗೆ ಸೂಕ್ತ, ಉದಾ: ರ್ಯಾಂಕಿಂಗ್ ನಿರ್ಮಿಸುವ ಕಾರ್ಯಗಳಿಗೆ, ನಾವು ಬಳಸುವುದಕ್ಕೆ ಸಹಾಯವಾಗುವುದಿಲ್ಲ.
ನಾವು Scikit-learn ಅನ್ನು ನಮ್ಮ ಡೇಟಾ ವಿಶ್ಲೇಷಿಸಲು ಬಳಸುತ್ತೇವೆ. ಆದಾಗ್ಯೂ, Scikit-learn ನಲ್ಲಿ ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್ ಬಳಸಲು ಹಲವಾರು ರೀತಿಗಳಿವೆ. ಪೇರಿಸಲಾಗುವ ಪ್ಯಾರಾಮೀಟರ್ಗಳನ್ನು ನೋಡಿ.
ಮೂಲತಃ ಎರಡು ಮುಖ್ಯ ಪ್ಯಾರಾಮೀಟರ್ಗಳಿವೆ - 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'. ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್ ಮೂಲತಃ ದ್ವಿಭಾಗೀಯ ವರ್ಗೀಕರಣ ಬೆಂಬಲಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಈ ಯೋಜನೆಗಳು ಅದಕ್ಕೆ ಉತ್ತಮ ರೀತಿಯಲ್ಲಿ ಬಹುಶ್ರೇಣಿ ವರ್ಗೀಕರಣ ನಿರ್ವಹಿಸಲು ಸಹಾಯಮಾಡುತ್ತವೆ. ಮೂಲ
🎓 'solver' ಎಂಬುದು "ಆಪ್ಟಿಮೈಸೇಶನ್ ಸಮಸ್ಯೆಯಲ್ಲಿ ಬಳಸುವ ಆಲ್ಗೊರಿದಮ್" ಎಂದು ನಿರ್ಧರಿಸಲಾಗಿದೆ. ಮೂಲ.
Scikit-learn ಈ ಟೇಬಲ್ ಮೂಲಕ ವಿಭಿನ್ನ ರೀತಿಯ ಡೇಟಾ ರಚನೆಗಳಿಂದ ಉಂಟಾಗುವ ವಿವಿಧ ಸವಾಲುಗಳನ್ನು ಪರಿಹರಿಸುವ ಮೂಲಕ ಪರಿಹಾರಕಾರಿಕಳ ನಿರ್ವಹಣೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ:
ನೀವು ಇತ್ತೀಚೆಗೆ ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ಇದನ್ನು ತಿಳಿದುಕೊಂಡಿರುವುದರಿಂದ ಮೊದಲ ತರಬೇತಿ ಪ್ರಯತ್ನಕ್ಕಾಗಿ ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್ ಮೇಲೆ ಗಮನಹರಿಸಬಹುದು. train_test_split() ಕರೆಯುತ್ತ ಡೇಟಾವನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಗುಂಪುಗಳಾಗಿ ವಿಭಜಿಸಿ:
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)ನೀವು ಬಹುಶ್ರೇಣಿ ಪ್ರಕರಣವನ್ನು ಬಳಸುತ್ತಿರುವುದರಿಂದ ಯಾವ ಯೋಜನೆ ಬಳಸಬೇಕು ಮತ್ತು ಯಾವ _ಪರಿಹಾರಕಾರ_ಸೇರಿಸಬೇಕು ಎಂಬುದನ್ನು ಆಯ್ಕೆಮಾಡಬೇಕು. ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನನ್ನು ಬಹುಶ್ರೇಣಿ ಸಜ್ಜುಗೊಳಿಸುವಿಕೆಯೊಂದಿಗೆ ಮತ್ತು liblinear ಪರಿಹಾರಕಾರಿಕೆಯನ್ನು ಬಳಸಲು ತರಬೇತಿ ಮಾಡಿ.
-
multi_class ಅನ್ನು
ovrಗೆ, ಪರಹಾರಕಾರವನ್ನುliblinearಗೆ ಸೆಟ್ ಮಾಡಿ ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್ ರಚಿಸಿ: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ಫಂಕ್ಷನ್ ಬಳಸಿ.ನಿಖರತೆ 80% ಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿದೆ!
-
ನೀವು ಈ ಮಾದರಿಯನ್ನು ಹಾದು ನೋಡಲು ಒಂದು ಸಾಲಿನ ಡೇಟಾದ (#50) ಪರೀಕ್ಷೆಯನ್ನು ಮಾಡಿ:
print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}') print(f'cuisine: {y_test.iloc[50]}')
ಫಲಿತಾಂಶ ಮುದ್ರಣ ಆಗುತ್ತದೆ:
ingredients: Index(['cilantro', 'onion', 'pea', 'potato', 'tomato', 'vegetable_oil'], dtype='object') cuisine: indian✅ ವಿಭಿನ್ನ ಸಾಲಿನ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಫಲಿತಾಂಶ ಗಮನಿಸಿ
-
ಇನ್ನೂ ಅಭ್ಯಾಸ ಮಾಡಿ, ನೀವು ಈ ಭವಿಷ್ಯವಾಣಿ ಸರಿಯಾಗಿರುವುದನ್ನು ಪರಿಶೀಲಿಸಬಹುದು:
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 ✅ ನೀವು ಏಕೆ ಮಾದರಿ ಬಹಳ ನಿಶ್ಚಿತವಾಗಿಯೂ ಇದು ಭಾರತೀಯ ಆಹಾರ ಎಂದು ಹೇಳುತ್ತಿರುವುದು ವಿವರಿಸಬಲ್ಲಿರಾ?
-
ಪೂರಕ ವಿವರಗಳನ್ನು ಪಡೆಯಲು, ನೀವು ರೆಗ್ರೆಶನ್ ಪಾಠಗಳಲ್ಲಿ ಮಾಡಿದಂತೆ ವರ್ಗೀಕರಣ ವರದಿಯನ್ನು ಮುದ್ರಿಸಿ:
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
ಈ ಪಾಠದಲ್ಲಿ, ನೀವು ನಿಮ್ಮ ಸ್ವಚ್ಛಮಾಡಿದ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು ಕೆಲವು घटಕಗಳ ಆಧಾರದಲ್ಲಿ ರಾಷ್ಟ್ರೀಯ ಆಹಾರವನ್ನು ಊಹಿಸಬಹುದಾದ ಯಂತ್ರ ಅಧ್ಯಯನ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಿದ್ದೀರಿ. ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸಲು ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಒದಗಿಸುವ ಹಲವು ಆಯ್ಕೆಗಳನ್ನೂ ಓದುತ್ತಾ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ. 'ಸಾಲ್ವರ್' ಎಂಬ ಸಂಯೋಜನೆಯ ಬಗ್ಗೆ ವರ್ಗಗಳ ಹಿಂದೆ ಏನು ನಡೆಯುತ್ತಿದೆಯೆಂದು ಹೆಚ್ಚು ತಿಳಿದುಕೊಳ್ಳಿ.
ಲಾಜಿಸ್ಟಿಕ್ ರೆಗ್ರೆಶನ್ ಹಿಂದಿನ ಗಣಿತವನ್ನು ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಲು ಈ ಪಾಠ ಅನ್ನು ಓದಿ
ಅಸ್ವೀಕರಣ:
ಈ ದಸ್ತಾವೇಜನ್ನು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವದಿಸಲಾಗಿದೆ. ನಾವು ಸರಿಯಾದ ಅನುವಾದ ನೀಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಾರತಮ್ಯಗಳಿರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ మూలವಾಗಿ ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವವಾದ ಮಾಹಿತಿಗೆ ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ. ಈ ಅನುವಾದವನ್ನು ಬಳಸುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು سمجھುತೆಗಳು ಅಥವಾ ವೈಖರಿಗಳಿಗಾಗಿ ನಾವು ಜವಾಬ್ದಾರಿಯಾಗುವುದಿಲ್ಲ.