# வகைப்பாட்டிற்கான அறிமுகம்

இந்த நான்கு பாடங்களில், நீங்கள் பாரம்பரிய இயந்திரக் கற்றலின் முக்கியமான அம்சமான _வகைப்பாட்டை_ ஆராய்வீர்கள். ஆசியா மற்றும் இந்தியாவின் அற்புதமான சமையல்களைப் பற்றிய தரவுத்தொகுப்புடன் பல வகைப்பாட்டு الگorithம்களைப் பயன்படுத்துவது பற்றி நாம் கற்றுக்கொள்வோம். உங்களுக்குப் பசிக்கிறதா?

![சிறிது சுவை!](../../../../translated_images/ta/pinch.1b035ec9ba7e0d40.webp)

> இந்த பாடங்களில் பான்-ஆசிய சமையல்களை கொண்டாடுங்கள்! படம்: [Jen Looper](https://twitter.com/jenlooper)

வகைப்பாடு என்பது [மேற்பார்வை கற்றல்](https://wikipedia.org/wiki/Supervised_learning) என்ற முறையின் ஒரு வடிவமாகும், இது மீள்பார்வை நுட்பங்களுடன் பல பொதுவான அம்சங்களை கொண்டுள்ளது. இயந்திரக் கற்றல் என்பது தரவுத்தொகுப்புகளைப் பயன்படுத்தி மதிப்புகள் அல்லது பெயர்களை முன்னறிவிப்பது பற்றியது என்றால், வகைப்பாடு பொதுவாக இரண்டு குழுக்களில் வருகிறது: _இரட்டை வகைப்பாடு_ மற்றும் _பலவகை வகைப்பாடு_.

[![வகைப்பாட்டிற்கான அறிமுகம்](https://img.youtube.com/vi/eg8DJYwdMyg/0.jpg)](https://youtu.be/eg8DJYwdMyg "வகைப்பாட்டிற்கான அறிமுகம்")

> 🎥 மேலே உள்ள படத்தை கிளிக் செய்து வீடியோவைப் பாருங்கள்: MIT-இன் ஜான் குட்டாக் வகைப்பாட்டை அறிமுகப்படுத்துகிறார்

மறக்காதீர்கள்:

- **நேரியல் மீள்பார்வை** உங்களுக்கு மாறிலிகளுக்கிடையிலான உறவுகளை முன்னறிவிக்கவும், புதிய தரவுப் புள்ளி அந்த கோட்டின் தொடர்பில் எங்கு இருக்கும் என்பதை துல்லியமாக முன்னறிவிக்கவும் உதவியது. எனவே, _செப்டம்பர் மற்றும் டிசம்பர் மாதங்களில் ஒரு பூசணிக்காயின் விலை என்ன இருக்கும்_ என்பதை நீங்கள் முன்னறிவிக்க முடியும்.
- **லாஜிஸ்டிக் மீள்பார்வை** உங்களுக்கு "இரட்டை வகைகள்" கண்டுபிடிக்க உதவியது: இந்த விலைப் புள்ளியில், _இந்த பூசணிக்காய் ஆரஞ்சு நிறமா அல்லது ஆரஞ்சு நிறமல்லவா_?

வகைப்பாடு தரவுப் புள்ளியின் லேபிள் அல்லது வகையைத் தீர்மானிக்க பல الگorithம்களைப் பயன்படுத்துகிறது. இந்த சமையல் தரவுடன் வேலை செய்து, ஒரு பொருட்களின் குழுவைப் பார்த்து, அதன் சமையல் மூலத்தைத் தீர்மானிக்க முடியுமா என்பதைப் பார்ப்போம்.

## [பாடத்திற்கு முன் வினாடி வினா](https://ff-quizzes.netlify.app/en/ml/)

> ### [இந்த பாடம் R-இல் கிடைக்கிறது!](../../../../4-Classification/1-Introduction/solution/R/lesson_10.html)

### அறிமுகம்

வகைப்பாடு என்பது இயந்திரக் கற்றல் ஆராய்ச்சியாளரும் தரவுத் விஞ்ஞானியுமான அடிப்படை செயல்பாடுகளில் ஒன்றாகும். ஒரு இரட்டை மதிப்பின் அடிப்படை வகைப்பாட்டிலிருந்து ("இந்த மின்னஞ்சல் ஸ்பாம் தானா அல்லது இல்லை?"), கணினி பார்வையைப் பயன்படுத்தி சிக்கலான பட வகைப்பாடு மற்றும் பிரிவுக்கு, தரவுகளை வகைகளில் வரிசைப்படுத்தவும் அதில் கேள்விகள் கேட்கவும் எப்போதும் பயனுள்ளதாக இருக்கும்.

இந்த செயல்முறையை அறிவியல் முறையில் கூறுவதற்கு, உங்கள் வகைப்பாட்டு முறை உள்தொகை மாறிலிகளுக்கும் வெளிப்புற மாறிலிகளுக்கும் இடையிலான உறவுகளை வரைபடமாக்க அனுமதிக்கும் ஒரு முன்னறிவிப்பு மாதிரியை உருவாக்குகிறது.

![இரட்டை மற்றும் பலவகை வகைப்பாடு](../../../../translated_images/ta/binary-multiclass.b56d0c86c81105a6.webp)

> வகைப்பாட்டு الگorithம்கள் கையாள வேண்டிய இரட்டை மற்றும் பலவகை பிரச்சினைகள். தகவல்படம்: [Jen Looper](https://twitter.com/jenlooper)

நமது தரவுகளை சுத்தம் செய்யும், காட்சிப்படுத்தும் மற்றும் எம்.எல். பணிகளுக்காக தயாரிக்கும் செயல்முறையைத் தொடங்குவதற்கு முன், தரவுகளை வகைப்படுத்த இயந்திரக் கற்றல் எவ்வாறு பயன்படுத்தப்படுகிறது என்பதைப் பற்றி கொஞ்சம் கற்றுக்கொள்வோம்.

[புள்ளியியல்](https://wikipedia.org/wiki/Statistical_classification) மூலம் பெறப்பட்ட வகைப்பாடு, பாரம்பரிய இயந்திரக் கற்றல் `smoker`, `weight`, மற்றும் `age` போன்ற அம்சங்களைப் பயன்படுத்தி _X நோயை உருவாக்கும் சாத்தியக்கூறுகளை_ தீர்மானிக்கிறது. நீங்கள் முன்பே செய்த மீள்பார்வை பயிற்சிகளுக்கு ஒத்த மேற்பார்வை கற்றல் நுட்பமாக, உங்கள் தரவுகள் லேபிள் செய்யப்பட்டுள்ளன, மேலும் எம்.எல். الگorithம்கள் அந்த லேபிள்களைப் பயன்படுத்தி தரவுத்தொகுப்பின் வகைகள் (அல்லது 'அம்சங்கள்') மற்றும் அவற்றை ஒரு குழு அல்லது முடிவுக்கு ஒதுக்குகின்றன.

✅ ஒரு சமையல் தரவுத்தொகுப்பைப் பற்றி கற்பனை செய்ய ஒரு நிமிடம் எடுத்துக்கொள்ளுங்கள். ஒரு பலவகை மாதிரி என்ன பதிலளிக்க முடியும்? ஒரு இரட்டை மாதிரி என்ன பதிலளிக்க முடியும்? ஒரு குறிப்பிட்ட சமையல் வெந்தயத்தைப் பயன்படுத்த வாய்ப்பு உள்ளதா என்பதை நீங்கள் தீர்மானிக்க விரும்பினால் என்ன? ஒரு grocery பையில் நட்சத்திர சோம்பு, artichokes, பூக்கோசு மற்றும் முள்ளங்கி இருந்தால், நீங்கள் ஒரு பாரம்பரிய இந்திய உணவை உருவாக்க முடியுமா என்பதைப் பார்க்க விரும்பினால் என்ன?

[![கிரேசி மிஸ்டரி பாஸ்கெட்ஸ்](https://img.youtube.com/vi/GuTeDbaNoEU/0.jpg)](https://youtu.be/GuTeDbaNoEU "கிரேசி மிஸ்டரி பாஸ்கெட்ஸ்")

> 🎥 மேலே உள்ள படத்தை கிளிக் செய்து வீடியோவைப் பாருங்கள். 'Chopped' நிகழ்ச்சியின் முழு அடிப்படை 'மிஸ்டரி பாஸ்கெட்' ஆகும், இதில் சமையல்காரர்கள் சில சீரற்ற பொருட்களிலிருந்து ஒரு உணவை உருவாக்க வேண்டும். நிச்சயமாக ஒரு எம்.எல். மாதிரி உதவியிருக்கும்!

## வணக்கம் 'classifier'

இந்த சமையல் தரவுத்தொகுப்பில் நாம் கேட்க விரும்பும் கேள்வி உண்மையில் ஒரு **பலவகை கேள்வி**, ஏனெனில் நமக்கு பல தேசிய சமையல்களைப் பயன்படுத்த வாய்ப்பு உள்ளது. பொருட்களின் ஒரு தொகுப்பைத் தரவாகக் கொண்டால், இந்த பல வகைகளில் எது பொருந்தும்?

Scikit-learn பல்வேறு الگorithம்களை வழங்குகிறது, நீங்கள் தீர்க்க விரும்பும் பிரச்சினையின் வகையைப் பொறுத்து தரவுகளை வகைப்படுத்த பயன்படுத்த. அடுத்த இரண்டு பாடங்களில், இந்த الگorithம்களில் பலவற்றைப் பற்றி நீங்கள் கற்றுக்கொள்வீர்கள்.

## பயிற்சி - உங்கள் தரவுகளை சுத்தம் செய்து சமநிலைப்படுத்துங்கள்

இந்த திட்டத்தைத் தொடங்குவதற்கு முன் செய்ய வேண்டிய முதல் பணியாக, உங்கள் தரவுகளை சுத்தம் செய்து **சமநிலைப்படுத்த** வேண்டும், இதனால் சிறந்த முடிவுகளைப் பெறலாம். இந்த கோப்பகத்தின் அடிப்பகுதியில் உள்ள _notebook.ipynb_ கோப்புடன் தொடங்குங்கள்.

முதலில் நிறுவ வேண்டியது [imblearn](https://imbalanced-learn.org/stable/) ஆகும். இது Scikit-learn தொகுப்பு, இது தரவுகளைச் சிறப்பாக சமநிலைப்படுத்த உதவும் (இந்த பணியைப் பற்றி நீங்கள் ஒரு நிமிடத்தில் மேலும் கற்றுக்கொள்வீர்கள்).

1. `imblearn` ஐ நிறுவ `pip install` ஐ இயக்கவும், இதுபோல:

    ```python
    pip install imblearn
    ```

1. உங்கள் தரவுகளை இறக்குமதி செய்யவும் காட்சிப்படுத்தவும் தேவையான தொகுப்புகளை இறக்குமதி செய்யவும், `SMOTE` ஐ `imblearn`-இல் இருந்து இறக்குமதி செய்யவும்.

    ```python
    import pandas as pd
    import matplotlib.pyplot as plt
    import matplotlib as mpl
    import numpy as np
    from imblearn.over_sampling import SMOTE
    ```

    இப்போது நீங்கள் தரவுகளை இறக்குமதி செய்ய தயாராக உள்ளீர்கள்.

1. அடுத்த பணியாக தரவுகளை இறக்குமதி செய்ய வேண்டும்:

    ```python
    df  = pd.read_csv('../data/cuisines.csv')
    ```

   `read_csv()` ஐப் பயன்படுத்துவது _cusines.csv_ கோப்பின் உள்ளடக்கத்தைப் படிக்கவும், அதை `df` மாறிலியில் வைக்கவும்.

1. தரவின் வடிவத்தைச் சரிபார்க்கவும்:

    ```python
    df.head()
    ```

   முதல் ஐந்து வரிகள் இவ்வாறு தோன்றும்:

    ```output
    |     | 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   | 65         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
    | 1   | 66         | indian  | 1      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
    | 2   | 67         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
    | 3   | 68         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
    | 4   | 69         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 1      | 0        |
    ```

1. இந்த தரவின் தகவலை `info()` ஐ அழைப்பதன் மூலம் பெறுங்கள்:

    ```python
    df.info()
    ```

    உங்கள் வெளியீடு இவ்வாறு தோன்றும்:

    ```output
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 2448 entries, 0 to 2447
    Columns: 385 entries, Unnamed: 0 to zucchini
    dtypes: int64(384), object(1)
    memory usage: 7.2+ MB
    ```

## பயிற்சி - சமையல்களைப் பற்றி கற்றல்

இப்போது வேலை மேலும் சுவாரஸ்யமாக மாறத் தொடங்குகிறது. தரவின் விநியோகத்தை, சமையல் ஒன்றுக்கு, கண்டறியலாம் 

1. `barh()` ஐ அழைப்பதன் மூலம் தரவுகளை பட்டைகளாக வரைபடம்:

    ```python
    df.cuisine.value_counts().plot.barh()
    ```

    ![சமையல் தரவின் விநியோகம்](../../../../translated_images/ta/cuisine-dist.d0cc2d551abe5c25.webp)

    சமையல்களின் எண்ணிக்கை முடிவுறுத்தப்பட்டுள்ளன, ஆனால் தரவின் விநியோகம் சமமாக இல்லை. அதை சரிசெய்யலாம்! அதைச் செய்வதற்கு முன், மேலும் ஆராயுங்கள்.

1. சமையல் ஒன்றுக்கு எவ்வளவு தரவு கிடைக்கிறது என்பதை கண்டறிந்து அச்சிடுங்கள்:

    ```python
    thai_df = df[(df.cuisine == "thai")]
    japanese_df = df[(df.cuisine == "japanese")]
    chinese_df = df[(df.cuisine == "chinese")]
    indian_df = df[(df.cuisine == "indian")]
    korean_df = df[(df.cuisine == "korean")]
    
    print(f'thai df: {thai_df.shape}')
    print(f'japanese df: {japanese_df.shape}')
    print(f'chinese df: {chinese_df.shape}')
    print(f'indian df: {indian_df.shape}')
    print(f'korean df: {korean_df.shape}')
    ```

    வெளியீடு இவ்வாறு தோன்றும்:

    ```output
    thai df: (289, 385)
    japanese df: (320, 385)
    chinese df: (442, 385)
    indian df: (598, 385)
    korean df: (799, 385)
    ```

## பொருட்களை கண்டறிதல்

இப்போது நீங்கள் தரவுகளை மேலும் ஆழமாக ஆராய்ந்து, ஒவ்வொரு சமையலுக்கும் பொதுவான பொருட்கள் என்ன என்பதை அறியலாம். சமையல்களுக்கு இடையே குழப்பத்தை உருவாக்கும் மீண்டும் மீண்டும் வரும் தரவுகளை சுத்தம் செய்ய வேண்டும், எனவே இந்த பிரச்சினையைப் பற்றி கற்றுக்கொள்வோம்.

1. Python-இல் `create_ingredient()` என்ற ஒரு செயல்பாட்டை உருவாக்கி, ஒரு பொருள் தரவுத்தொகுப்பை உருவாக்குங்கள். இந்த செயல்பாடு உதவாத ஒரு நெடுவரிசையை நீக்குவதன் மூலம் தொடங்கும் மற்றும் பொருட்களை அவற்றின் எண்ணிக்கையால் வரிசைப்படுத்தும்:

    ```python
    def create_ingredient_df(df):
        ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
        ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
        ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
        inplace=False)
        return ingredient_df
    ```

   இப்போது நீங்கள் ஒவ்வொரு சமையலுக்கும் முதல் பத்து மிகவும் பிரபலமான பொருட்களைப் பற்றிய ஒரு யோசனையைப் பெற இந்த செயல்பாட்டைப் பயன்படுத்தலாம்.

1. `create_ingredient()` ஐ அழைத்து, `barh()` ஐ அழைப்பதன் மூலம் அதை வரைபடம்:

    ```python
    thai_ingredient_df = create_ingredient_df(thai_df)
    thai_ingredient_df.head(10).plot.barh()
    ```

    ![thai](../../../../translated_images/ta/thai.0269dbab2e78bd38.webp)

1. ஜப்பானிய தரவுகளுக்கு இதையே செய்யுங்கள்:

    ```python
    japanese_ingredient_df = create_ingredient_df(japanese_df)
    japanese_ingredient_df.head(10).plot.barh()
    ```

    ![japanese](../../../../translated_images/ta/japanese.30260486f2a05c46.webp)

1. இப்போது சீன பொருட்களுக்கு:

    ```python
    chinese_ingredient_df = create_ingredient_df(chinese_df)
    chinese_ingredient_df.head(10).plot.barh()
    ```

    ![chinese](../../../../translated_images/ta/chinese.e62cafa5309f111a.webp)

1. இந்திய பொருட்களை வரைபடம்:

    ```python
    indian_ingredient_df = create_ingredient_df(indian_df)
    indian_ingredient_df.head(10).plot.barh()
    ```

    ![indian](../../../../translated_images/ta/indian.2c4292002af1a1f9.webp)

1. இறுதியாக, கொரிய பொருட்களை வரைபடம்:

    ```python
    korean_ingredient_df = create_ingredient_df(korean_df)
    korean_ingredient_df.head(10).plot.barh()
    ```

    ![korean](../../../../translated_images/ta/korean.4a4f0274f3d9805a.webp)

1. இப்போது, `drop()` ஐ அழைப்பதன் மூலம் தனித்துவமான சமையல்களுக்கு இடையே குழப்பத்தை உருவாக்கும் பொதுவான பொருட்களை நீக்குங்கள்: 

   அனைவருக்கும் அரிசி, பூண்டு மற்றும் இஞ்சி பிடிக்கும்!

    ```python
    feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
    labels_df = df.cuisine #.unique()
    feature_df.head()
    ```

## தரவுத்தொகுப்பை சமநிலைப்படுத்துங்கள்

இப்போது நீங்கள் தரவுகளை சுத்தம் செய்துள்ளீர்கள், [SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - "Synthetic Minority Over-sampling Technique" - ஐ பயன்படுத்தி அதை சமநிலைப்படுத்துங்கள்.

1. `fit_resample()` ஐ அழைக்கவும், இந்த உத்தி இடைநிலையாக்கத்தின் மூலம் புதிய மாதிரிகளை உருவாக்குகிறது.

    ```python
    oversample = SMOTE()
    transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
    ```

    உங்கள் தரவுகளை சமநிலைப்படுத்துவதன் மூலம், அதை வகைப்படுத்தும்போது சிறந்த முடிவுகளைப் பெறுவீர்கள். ஒரு இரட்டை வகைப்பாட்டைப் பற்றி சிந்தியுங்கள். உங்கள் தரவின் பெரும்பாலானவை ஒரு வகையாக இருந்தால், ஒரு எம்.எல். மாதிரி அந்த வகையை அடிக்கடி முன்னறிவிக்கப் போகிறது, ஏனெனில் அதற்காக அதிக தரவுகள் உள்ளன. தரவுகளை சமநிலைப்படுத்துவது எந்தவொரு சாய்ந்த தரவையும் எடுத்து, இந்த சமநிலையற்ற தன்மையை நீக்க உதவுகிறது.

1. இப்போது ஒவ்வொரு பொருளுக்கும் லேபிள்களின் எண்ணிக்கையைச் சரிபார்க்கலாம்:

    ```python
    print(f'new label count: {transformed_label_df.value_counts()}')
    print(f'old label count: {df.cuisine.value_counts()}')
    ```

    உங்கள் வெளியீடு இவ்வாறு தோன்றும்:

    ```output
    new label count: korean      799
    chinese     799
    indian      799
    japanese    799
    thai        799
    Name: cuisine, dtype: int64
    old label count: korean      799
    indian      598
    chinese     442
    japanese    320
    thai        289
    Name: cuisine, dtype: int64
    ```

    தரவுகள் அழகாகவும் சுத்தமாகவும், சமநிலையாகவும், மிகவும் சுவையாகவும் உள்ளன!

1. இறுதியாக, லேபிள்கள் மற்றும் அம்சங்களை உள்ளடக்கிய உங்கள் சமநிலைப்படுத்தப்பட்ட தரவுகளை ஒரு புதிய தரவுத்தொகுப்பில் சேமிக்கவும், அதை ஒரு கோப்பில் ஏற்றுமதி செய்யலாம்:

    ```python
    transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
    ```

1. `transformed_df.head()` மற்றும் `transformed_df.info()` ஐப் பயன்படுத்தி தரவுகளை ஒரு முறை மேலும் பார்க்கலாம். எதிர்கால பாடங்களில் பயன்படுத்த இந்த தரவின் ஒரு பிரதியை சேமிக்கவும்:

    ```python
    transformed_df.head()
    transformed_df.info()
    transformed_df.to_csv("../data/cleaned_cuisines.csv")
    ```

    இந்த புதிய CSV இப்போது அடிப்பகுதி தரவுக் கோப்பகத்தில் கிடைக்கிறது.

---

## 🚀சவால்

இந்த பாடத்திட்டத்தில் பல சுவாரஸ்யமான தரவுத்தொகுப்புகள் உள்ளன. `data` கோப்பகங்களைத் தேடுங்கள், மற்றும் எந்தவொரு தரவுத்தொகுப்புகள் இரட்டை அல்லது பலவகை வகைப்பாட்டிற்கு பொருத்தமானதாக இருக்கும் என்பதைப் பாருங்கள்? இந்த தரவுத்தொகுப்புக்கு நீங்கள் என்ன கேள்விகளை கேட்பீர்கள்?

## [பாடத்திற்குப் பின் வினாடி வினா](https://ff-quizzes.netlify.app/en/ml/)

## மதிப்பீடு மற்றும் சுயபடிப்பு

SMOTE-இன் API-யை ஆராயுங்கள். இது எந்த பயன்பாடுகளுக்கு சிறந்தது? இது எந்த பிரச்சினைகளைத் தீர்க்கிறது?

## பணிக்கட்டளை 

[வகைப்பாட்டு முறைகளை ஆராயுங்கள்](assignment.md)

---

**குறிப்பு**:  
இந்த ஆவணம் [Co-op Translator](https://github.com/Azure/co-op-translator) என்ற AI மொழிபெயர்ப்பு சேவையை பயன்படுத்தி மொழிபெயர்க்கப்பட்டுள்ளது. எங்கள் தரச்செயல்முறைகளுக்கு முக்கியத்துவம் அளிக்கின்றோம், ஆனால் தானியக்க மொழிபெயர்ப்புகளில் பிழைகள் அல்லது துல்லியமின்மைகள் இருக்கக்கூடும் என்பதை தயவுசெய்து கவனத்தில் கொள்ளவும். அதன் தாய்மொழியில் உள்ள அசல் ஆவணம் அதிகாரப்பூர்வ ஆதாரமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்முறை மனித மொழிபெயர்ப்பு பரிந்துரைக்கப்படுகிறது. இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதால் ஏற்படும் தவறான புரிதல்கள் அல்லது தவறான விளக்கங்களுக்கு நாங்கள் பொறுப்பல்ல.