ML-For-Beginners/translations/kn/4-Classification/3-Classifiers-2

ಆಹಾರ ವರ್ಗೀಕರಣಗಳು 2

ಈ ಎರಡನೇ ವರ್ಗೀಕರಣ ಪಾಠದಲ್ಲಿ, ನೀವು ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುವ ಇನ್ನಷ್ಟು ವಿಧಾನಗಳನ್ನು ಅನ್ವೇಷಿಸುವಿರಿ. ನೀವು ಒಂದು ವರ್ಗೀಕರಣಕಾರಿಯನ್ನು ಇನ್ನೊಂದರಿಗಿಂತ ಆಯ್ಕೆಮಾಡುವ ಪರಿಣಾಮಗಳ ಬಗ್ಗೆ ಸಹ ತಿಳಿಯುವಿರಿ.

ಪೂರ್ವ-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ

ಪೂರ್ವಾಪೇಕ್ಷೆ

ನೀವು ಹಿಂದಿನ ಪಾಠಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ್ದೀರಿ ಮತ್ತು ನಿಮ್ಮ data ಫೋಲ್ಡರ್‌ನಲ್ಲಿ cleaned_cuisines.csv ಎಂಬ ಸ್ವಚ್ಛಗೊಳಿಸಿದ ಡೇಟಾಸೆಟ್ ಇದೆ ಎಂದು ನಾವು ಊಹಿಸುತ್ತೇವೆ, ಇದು ಈ 4-ಪಾಠ ಫೋಲ್ಡರ್‌ನ ರೂಟ್‌ನಲ್ಲಿ ಇದೆ.

ತಯಾರಿ

ನಾವು ನಿಮ್ಮ notebook.ipynb ಫೈಲ್ ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿದ ಡೇಟಾಸೆಟ್‌ನೊಂದಿಗೆ ಲೋಡ್ ಮಾಡಿದ್ದೇವೆ ಮತ್ತು ಅದನ್ನು X ಮತ್ತು y ಡೇಟಾಫ್ರೇಮ್‌ಗಳಾಗಿ ವಿಭಜಿಸಿದ್ದೇವೆ, ಮಾದರಿ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಗೆ ಸಿದ್ಧವಾಗಿದೆ.

ವರ್ಗೀಕರಣ ನಕ್ಷೆ

ಹಿಂದೆ, ನೀವು ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುವಾಗ Microsoft ನ ಚೀಟ್ ಶೀಟ್ ಬಳಸಿ ವಿವಿಧ ಆಯ್ಕೆಗಳ ಬಗ್ಗೆ ಕಲಿತಿದ್ದೀರಿ. Scikit-learn ಒಂದು ಸಮಾನವಾದ, ಆದರೆ ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮ ಚೀಟ್ ಶೀಟ್ ಅನ್ನು ನೀಡುತ್ತದೆ, ಇದು ನಿಮ್ಮ ಅಂದಾಜುಕಾರರನ್ನು (ಮತ್ತೊಂದು ಪದದಲ್ಲಿ ವರ್ಗೀಕರಣಕಾರರು) ಇನ್ನಷ್ಟು ನಿಖರಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ:

ಟಿಪ್: ಈ ನಕ್ಷೆಯನ್ನು ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ಭೇಟಿ ನೀಡಿ ಮತ್ತು ದಾರಿಯಲ್ಲಿ ಕ್ಲಿಕ್ ಮಾಡಿ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಓದಿ.

ಯೋಜನೆ

ನಿಮ್ಮ ಡೇಟಾ ಸ್ಪಷ್ಟವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಂಡ ನಂತರ ಈ ನಕ್ಷೆ ಬಹಳ ಸಹಾಯಕವಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ನೀವು ಅದರ ದಾರಿಗಳಲ್ಲಿ 'ನಡೆದು' ನಿರ್ಧಾರಕ್ಕೆ ಬರಬಹುದು:

• ನಮಗೆ >50 ಮಾದರಿಗಳು ಇವೆ
• ನಾವು ಒಂದು ವರ್ಗವನ್ನು ಊಹಿಸಲು ಬಯಸುತ್ತೇವೆ
• ನಮಗೆ ಲೇಬಲ್ ಮಾಡಲಾದ ಡೇಟಾ ಇದೆ
• ನಮಗೆ 100K ಕ್ಕಿಂತ ಕಡಿಮೆ ಮಾದರಿಗಳು ಇವೆ
• ✨ ನಾವು ಲೀನಿಯರ್ SVC ಆಯ್ಕೆಮಾಡಬಹುದು
• ಅದು ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ಏಕೆಂದರೆ ನಮಗೆ ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾ ಇದೆ
  • ನಾವು ✨ KNeighbors ವರ್ಗೀಕರಣಕಾರಿಯನ್ನು ಪ್ರಯತ್ನಿಸಬಹುದು
    • ಅದು ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ✨ SVC ಮತ್ತು ✨ Ensemble ವರ್ಗೀಕರಣಕಾರಿಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿ

ಇದು ಅನುಸರಿಸಲು ಬಹಳ ಸಹಾಯಕ ದಾರಿಯಾಗಿದೆ.

ಅಭ್ಯಾಸ - ಡೇಟಾವನ್ನು ವಿಭಜಿಸಿ

ಈ ದಾರಿಯನ್ನು ಅನುಸರಿಸಿ, ನಾವು ಕೆಲವು ಲೈಬ್ರರಿಗಳನ್ನು ಆಮದುಮಾಡುವುದರಿಂದ ಪ್ರಾರಂಭಿಸಬೇಕು.

1. ಅಗತ್ಯವಿರುವ ಲೈಬ್ರರಿಗಳನ್ನು ಆಮದುಮಾಡಿ:

   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. ನಿಮ್ಮ ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ವಿಭಜಿಸಿ:

   X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
   

ಲೀನಿಯರ್ SVC ವರ್ಗೀಕರಣಕಾರ

ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ಕ್ಲಸ್ಟರಿಂಗ್ (SVC) ಎಂಬುದು ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ಯಂತ್ರಗಳ ಕುಟುಂಬದ ಒಂದು ಭಾಗವಾಗಿದೆ (ಈ ಬಗ್ಗೆ ಕೆಳಗೆ ಇನ್ನಷ್ಟು ತಿಳಿಯಿರಿ). ಈ ವಿಧಾನದಲ್ಲಿ, ನೀವು ಲೇಬಲ್‌ಗಳನ್ನು ಹೇಗೆ ಕ್ಲಸ್ಟರ್ ಮಾಡಬೇಕೆಂದು ನಿರ್ಧರಿಸಲು 'ಕರ್ಣಲ್' ಆಯ್ಕೆಮಾಡಬಹುದು. 'C' ಪರಿಮಾಣವು 'ನಿಯಮಿತತೆ'ಗೆ ಸಂಬಂಧಿಸಿದೆ, ಇದು ಪರಿಮಾಣಗಳ ಪ್ರಭಾವವನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ. ಕರ್ಣಲ್ ಬಹುಮಾನಗಳಲ್ಲೊಂದು ಆಗಿರಬಹುದು; ಇಲ್ಲಿ ನಾವು ಲೀನಿಯರ್ SVC ಬಳಸಲು 'linear' ಎಂದು ಹೊಂದಿಸಿದ್ದೇವೆ. Probability ಡೀಫಾಲ್ಟ್ 'false' ಆಗಿದೆ; ಇಲ್ಲಿ ನಾವು 'true' ಎಂದು ಹೊಂದಿಸಿದ್ದೇವೆ ಪ್ರಾಬಬಿಲಿಟಿ ಅಂದಾಜುಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು. ಡೇಟಾವನ್ನು ಶಫಲ್ ಮಾಡಲು random state ಅನ್ನು '0' ಎಂದು ಹೊಂದಿಸಿದ್ದೇವೆ.

ಅಭ್ಯಾಸ - ಲೀನಿಯರ್ SVC ಅನ್ವಯಿಸಿ

ವರ್ಗೀಕರಣಕಾರರ ಅರೆ ಅನ್ನು ರಚಿಸುವುದರಿಂದ ಪ್ರಾರಂಭಿಸಿ. ನಾವು ಪರೀಕ್ಷಿಸುವಂತೆ ಈ ಅರೆಗೆ ಕ್ರಮೇಣ ಸೇರಿಸುತ್ತೇವೆ.

1. ಲೀನಿಯರ್ SVC ನಿಂದ ಪ್ರಾರಂಭಿಸಿ:

   C = 10
   # ವಿಭಿನ್ನ ವರ್ಗೀಕರಿಸುವವರನ್ನು ರಚಿಸಿ.
   classifiers = {
       'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
   }
   

2. ಲೀನಿಯರ್ SVC ಬಳಸಿ ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ತರಬೇತಿಮಾಡಿ ಮತ್ತು ವರದಿಯನ್ನು ಮುದ್ರಿಸಿ:

   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))
   

   ಫಲಿತಾಂಶ ಚೆನ್ನಾಗಿದೆ:

   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 ಐಟಂನ ನಂತರ ಕಾಮಾ ಸೇರಿಸಿ):

   'KNN classifier': KNeighborsClassifier(C),
   

   ಫಲಿತಾಂಶ ಸ್ವಲ್ಪ ಕೆಟ್ಟಿದೆ:

   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-ನೆರೆಹೊರೆಯವರು ಬಗ್ಗೆ ತಿಳಿಯಿರಿ

ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರ

ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರಗಳು ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್ ಯಂತ್ರ ಕುಟುಂಬದ ಭಾಗವಾಗಿದ್ದು, ವರ್ಗೀಕರಣ ಮತ್ತು ರಿಗ್ರೆಷನ್ ಕಾರ್ಯಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತವೆ. SVM ಗಳು "ತರಬೇತಿ ಉದಾಹರಣೆಗಳನ್ನು ಸ್ಥಳದಲ್ಲಿ ಬಿಂದುಗಳಾಗಿ ನಕ್ಷೆ ಮಾಡುತ್ತವೆ" ಎರಡು ವರ್ಗಗಳ ನಡುವಿನ ದೂರವನ್ನು ಗರಿಷ್ಠಗೊಳಿಸಲು. ನಂತರದ ಡೇಟಾವನ್ನು ಈ ಸ್ಥಳದಲ್ಲಿ ನಕ್ಷೆ ಮಾಡಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಅವುಗಳ ವರ್ಗವನ್ನು ಊಹಿಸಬಹುದು.

ಅಭ್ಯಾಸ - ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರ ಅನ್ವಯಿಸಿ

ಸಪೋರ್ಟ್ ವೆಕ್ಟರ್ ವರ್ಗೀಕರಣಕಾರದೊಂದಿಗೆ ಸ್ವಲ್ಪ ಉತ್ತಮ ನಿಖರತೆಯನ್ನು ಪ್ರಯತ್ನಿಸೋಣ.

1. K-ನೆರೆಹೊರೆಯವರ ಐಟಂನ ನಂತರ ಕಾಮಾ ಸೇರಿಸಿ, ನಂತರ ಈ ಸಾಲನ್ನು ಸೇರಿಸಿ:

   'SVC': SVC(),
   

   ಫಲಿತಾಂಶ ಬಹಳ ಚೆನ್ನಾಗಿದೆ!

   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
   

   ✅ ಸಪೋರ್ಟ್-ವೆಕ್ಟರ್‌ಗಳ ಬಗ್ಗೆ ತಿಳಿಯಿರಿ

ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರಗಳು

ಹಿಂದಿನ ಪರೀಕ್ಷೆ ಚೆನ್ನಾಗಿದ್ದರೂ, ನಾವು ದಾರಿಯ ಕೊನೆಯಲ್ಲಿ ಇರುವ ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರಗಳನ್ನು ಪ್ರಯತ್ನಿಸೋಣ, ವಿಶೇಷವಾಗಿ ರ್ಯಾಂಡಮ್ ಫಾರೆಸ್ಟ್ ಮತ್ತು ಅಡಾಬೂಸ್ಟ್:

  'RFST': RandomForestClassifier(n_estimators=100),
  'ADA': AdaBoostClassifier(n_estimators=100)

ಫಲಿತಾಂಶ ಬಹಳ ಚೆನ್ನಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ರ್ಯಾಂಡಮ್ ಫಾರೆಸ್ಟ್‌ಗೆ:

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

✅ ಎನ್ಸೆಂಬಲ್ ವರ್ಗೀಕರಣಕಾರಗಳು ಬಗ್ಗೆ ತಿಳಿಯಿರಿ

ಈ ಯಂತ್ರ ಕಲಿಕೆಯ ವಿಧಾನವು "ಕೆಲವು ಮೂಲ ಅಂದಾಜುಕಾರರ ಭವಿಷ್ಯವಾಣಿಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ" ಮಾದರಿಯ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸಲು. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ರ್ಯಾಂಡಮ್ ಟ್ರೀಸ್ ಮತ್ತು ಅಡಾಬೂಸ್ಟ್ ಬಳಸಿದ್ದೇವೆ.

• ರ್ಯಾಂಡಮ್ ಫಾರೆಸ್ಟ್, ಸರಾಸರಿ ವಿಧಾನ, 'ನಿರ್ಣಯ ಮರಗಳ' ಒಂದು 'ಕಾಡನ್ನು' ರಚಿಸುತ್ತದೆ, ಇದು ಅತಿಯಾದ ಹೊಂದಾಣಿಕೆಯನ್ನು ತಪ್ಪಿಸಲು ಯಾದೃಚ್ಛಿಕತೆಯನ್ನು ಒಳಗೊಂಡಿದೆ. n_estimators ಪರಿಮಾಣವನ್ನು ಮರಗಳ ಸಂಖ್ಯೆಗೆ ಹೊಂದಿಸಲಾಗಿದೆ.

• ಅಡಾಬೂಸ್ಟ್ ಒಂದು ವರ್ಗೀಕರಣಕಾರವನ್ನು ಡೇಟಾಸೆಟ್‌ಗೆ ಹೊಂದಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಆ ವರ್ಗೀಕರಣಕಾರದ ನಕಲುಗಳನ್ನು ಅದೇ ಡೇಟಾಸೆಟ್‌ಗೆ ಹೊಂದಿಸುತ್ತದೆ. ಇದು ತಪ್ಪಾಗಿ ವರ್ಗೀಕರಿಸಿದ ಐಟಂಗಳ ತೂಕಗಳ ಮೇಲೆ ಗಮನಹರಿಸಿ, ಮುಂದಿನ ವರ್ಗೀಕರಣಕಾರದ ಹೊಂದಾಣಿಕೆಯನ್ನು ಸರಿಪಡಿಸುತ್ತದೆ.

---

🚀ಸವಾಲು

ಈ ತಂತ್ರಗಳ ಪ್ರತಿಯೊಂದಕ್ಕೂ ನೀವು ತಿದ್ದುಪಡಿ ಮಾಡಬಹುದಾದ ಅನೇಕ ಪರಿಮಾಣಗಳಿವೆ. ಪ್ರತಿಯೊಂದರ ಡೀಫಾಲ್ಟ್ ಪರಿಮಾಣಗಳನ್ನು ಸಂಶೋಧಿಸಿ ಮತ್ತು ಈ ಪರಿಮಾಣಗಳನ್ನು ತಿದ್ದುಪಡಿ ಮಾಡುವುದು ಮಾದರಿಯ ಗುಣಮಟ್ಟಕ್ಕೆ ಏನು ಅರ್ಥವಾಗುತ್ತದೆ ಎಂದು ಯೋಚಿಸಿ.

ಪೋಸ್ಟ್-ಪಾಠ ಪ್ರಶ್ನೋತ್ತರ

ವಿಮರ್ಶೆ & ಸ್ವಯಂ ಅಧ್ಯಯನ

ಈ ಪಾಠಗಳಲ್ಲಿ ಬಹಳಷ್ಟು ತಾಂತ್ರಿಕ ಪದಗಳಿವೆ, ಆದ್ದರಿಂದ ಈ ಪಟ್ಟಿ ಯನ್ನು ಪರಿಶೀಲಿಸಲು ಒಂದು ನಿಮಿಷ ತೆಗೆದುಕೊಳ್ಳಿ!

ನಿಯೋಜನೆ

ಪರಿಮಾಣ ಆಟ

---

ಅಸ್ವೀಕರಣ:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪುಗಳು ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.