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.
ML-For-Beginners/translations/kn/4-Classification/3-Classifiers-2/README.md

242 lines
19 KiB

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

# ಆಹಾರ ವರ್ಗೀಕರಣಕಾರರು 2
ಈ ಎರಡನೇ ವರ್ಗೀಕರಣ ಪಾಠದಲ್ಲಿ, ನೀವು ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುವ ಇನ್ನೂ ಹೆಚ್ಚಿನ ರೀತಿಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೀರಿ. ನೀವು ಒಂದು ವರ್ಗೀಕರಣಕಾರಿಯನ್ನು ಮತ್ತೊಂದರ ಮೇಲೆ ಆರಿಸುವುದರ ಪರಿಣಾಮಗಳ ಬಗ್ಗೆ ಕೂಡ ತಿಳಿದುಕೊಳ್ಳುತ್ತೀರಿ.
## [ಪೂರ್ವ-ಪಾಠ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ml/)
### ಪೂರ್ವಾಪಶ್ಚಾತ್
ನೀವು ಹಿಂದಿನ ಪಾಠಗಳನ್ನು ಮುಗಿಸಿಕೊಂಡಿದ್ದೀರೆಂದು ಮತ್ತು ಈ 4-ಪಾಠಗಳ ಫೋಲ್ಡರ್ ರೂಟ್‌ನಲ್ಲಿ `data` ಫೋಲ್ಡರ್‌ನಲ್ಲಿ _cleaned_cuisines.csv_ ಎಂಬ ಶುಧ್ಧೀಕರಿಸಲಾದ ಡೇಟಾಸೆಟ್ ಹೊಂದಿದ್ದೀರಿ ಎಂದು ನಾವು ನಿರ್ಧರಿಸುತ್ತೇವೆ.
### ತಯಾರಿ
ನಾವು ನಿಮ್ಮ _notebook.ipynb_ ಫೈಲ್‌ನ್ನು ಶುಧ್ಧೀಕರಿಸಲಾದ ಡೇಟಾಸೆಟ್‌ನೊಂದಿಗೆ ಲೋಡ್ ಮಾಡಿದ್ದೇವೆ ಮತ್ತು ಇದನ್ನು X ಮತ್ತು y ಡೇಟಾಫ್ರೇಮ್ಗಳಾಗಿ ವಿಭಜಿಸಿ ಮೋಡಲ್ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಗೆ ಸಿದ್ಧಪಡಿಸಿದ್ದೇವೆ.
## ವರ್ಗೀಕರಣ ನಕ್ಷೆ
ಹಿಂದೆ, ನೀವು ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುವಾಗ ನಿಮಗೆ ಇರುವ ವಿಭಿನ್ನ ಆಯ್ಕೆಗಳ ಬಗ್ಗೆ Microsoft's ಚೀಟ್ ಶೀಟ್ ಮೂಲಕ ತಿಳಿದುಕೊಂಡಿದ್ದಿರಿ. Scikit-learn ಸಹ ಹೋಲುವ, ಆದರೆ ಇನ್ನಷ್ಟು ಸೂಕ್ಷ್ಮವಾಗಿರುವ ಚೀಟ್ ಶೀಟ್ ಅನ್ನು ನೀಡುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಅಂದಾಜುಕರರನ್ನು (ವರ್ಗೀಕರಣಕಾರರು ಎಂದು ಬೇರೆ ಹೆಸರು) ಇನ್ನಷ್ಟು ಸಂಕೋಚಿತಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ:
![ML Map from Scikit-learn](../../../../translated_images/kn/map.e963a6a51349425a.webp)
> ಟಿಪ್: [ಈ ನಕ್ಷೆಯನ್ನು ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ಸಂದರ್ಶಿಸಿ](https://scikit-learn.org/stable/tutorial/machine_learning_map/) ಮತ್ತು ದಾರಿಯಲ್ಲಿ ಕ್ಲಿಕ್ ಮಾಡಿ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಓದಿರಿ.
### ಯೋಜನೆ
ನಿಮ್ಮ ಡೇಟಾದ ಸ್ಪಷ್ಟ ಗ್ರಹಿಕೆಯಿದ್ದಾಗ ಈ ನಕ್ಷೆ ತುಂಬ ಸಹಾಯಕವಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ನೀವು ನಿರ್ಧಾರಕ್ಕೆ ಈ ದಾರಿಗಳನ್ನು 'ನಡೆದು' ಹೋಗಬಹುದು:
- ನಮ್ಮ ಬಳಿ >50 ಮಾದರಿಗಳು ಇವೆ
- ನಾವು ಶ್ರೇಣಿಯನ್ನು ಊಹಿಸಲು ಬಯಸುತ್ತೇವೆ
- ನಮಗೆ ಲೇಬಲ್ ಮಾಡಲಾದ ಡೇಟಾ ಇದೆ
- ನಮಗಿರುವ ಮಾದರಿಗಳು 100K ಕ್ಕಿಂತ ಕಡಿಮೆ
- ✨ ನಾವು ಲಿನಿಯರ್ 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
```
2. ನಿಮ್ಮ ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ವಿಭಜಿಸಿ:
```python
X_train, X_test, y_train, y_test = train_test_split(cuisines_features_df, cuisines_label_df, test_size=0.3)
```
## ಲಿನಿಯರ್ SVC ವರ್ಗೀಕರಣಕಾರ
ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ಕ್ಲಸ್ಟರಿಂಗ್ (SVC) ಯು Support-Vector ಮೆಷೀನುಗಳ ಕುಟುಂಬದ ಒಂದು ಭಾಗವಾಗಿದೆ (ನಿಮಗೆ ಈ ಕೆಳಗೆ ಇದರ ಬಗ್ಗೆ ಹೆಚ್ಚು ತಿಳಿಯಬಹುದು). ಈ ವಿಧಾನದಲ್ಲಿ, ಟ್ಯಾಗ್‌ಗಳನ್ನು ಕ್ಲಸ್ಟರ್ ಮಾಡಲು ನೀವು 'ಕರ್ಣಲ್' ಅನ್ನು ಆಯ್ಕೆಮಾಡಬಹುದು. C ಪರಿಮಾಣ 'ರೆಗ್ಯುಲರೈಸೇಶನ್' ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಇದು ಪರಿಮಾಣಗಳ ಪ್ರಭಾವವನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ. ಕರ್ಣಲ್ ಒಂದೇ ಒಂದು [ಹಣ] (https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); ಇಲ್ಲಿ ನಾವು ಲಿನಿಯರ್ ಎಂದು ಸೆಟ್ಟಾಗಿ ನೇರ SVC ನ ಉಪಯೋಗವನ್ನು ಖಚಿತಪಡಿಸುತ್ತೇವೆ. ಪ್ರಾಬಬಿಲಿಟಿ ಡೀಫಾಲ್ಟ್ 'false'; ಇಲ್ಲಿ ನಾವು ಪ್ರಾಬಬಿಲಿಟಿ ಅಂದಾಜುಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು 'true' ಗೆ ಸೆಟ್ ಮಾಡಿದ್ದೇವೆ. ನಾವು ಡೇಟಾವನ್ನು ಮಿಶ್ರಣಗೊಳಿಸಲು ಮತ್ತು ಪ್ರಮಾಣವನ್ನು ಪಡೆಯಲು random state ಅನ್ನು '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) ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳಿ
## ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರ
ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರಗಳು [Support-Vector Machine](https://wikipedia.org/wiki/Support-vector_machine) ಕುಟುಂಬದ ಭಾಗವಾಗಿದ್ದು ವರ್ಗೀಕರಣ ಮತ್ತು ರೆಗ್ರೆಷನ್ ಕಾರ್ಯಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತವೆ. 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) ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳಿ
## ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರರು
ಹಿಂದಿನ ಪರೀಕ್ಷೆ ತುಂಬಾ ಉತ್ತಮವಾಗಿದ್ದರೂ, ನಾವು ದಾರಿಯನ್ನು ಕೊನೆವರೆಗೆ ಅನುಸರಿಸೋಣ. ನಾವು ಕೆಲವು 'ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರರನ್ನು' ಪ್ರಯತ್ನಿಸೋಣ, ವಿಶೇಷವಾಗಿ 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
```
✅ [ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರರ](https://scikit-learn.org/stable/modules/ensemble.html) ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳಿ
ಈ ಮೆಷಿನ್ ಲರ್ನಿಂಗ್ ವಿಧಾನವು "ಕೆಲವು ಮೂಲ ಅಂದಾಜುಕರರ ಭವಿಷ್ಯಾಣಗಳನ್ನು ಏಕರೂಪಗೊಳಿಸುತ್ತದೆ" ಮತ್ತು ಮಾದರಿಯ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು Random Trees ಮತ್ತು AdaBoost ಅನ್ನು ಬಳಸಿದ್ದೇವೆ.
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), ಸರಾಸರಿ ಮಾಡುವ ವಿಧಾನ, ಯಾದೃಚ್ಛಿಕತೆಯಿಂದ ತುಂಬಿದ 'ನಿರ್ಣಯ ಮರಗಳ' 'ಕಾಡನ್ನು' ನಿರ್ಮಿಸಿ ಓವರ್‌ಫಿಟಿಂಗ್‌ನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. 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 -->