# K-മീൻസ് ക്ലസ്റ്ററിംഗ്

## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)

ഈ പാഠത്തിൽ, നിങ്ങൾ മുമ്പ് ഇറക്കുമതി ചെയ്ത നൈജീരിയൻ സംഗീത ഡാറ്റാസെറ്റ് ഉപയോഗിച്ച് Scikit-learn ഉപയോഗിച്ച് ക്ലസ്റ്ററുകൾ സൃഷ്ടിക്കുന്നത് എങ്ങനെ എന്നത് പഠിക്കും. ക്ലസ്റ്ററിംഗിനുള്ള K-മീൻസ് അടിസ്ഥാനങ്ങൾ ഞങ്ങൾ ഉൾക്കൊള്ളും. മുമ്പത്തെ പാഠത്തിൽ നിങ്ങൾ പഠിച്ചതുപോലെ, ക്ലസ്റ്ററുകളുമായി പ്രവർത്തിക്കാൻ നിരവധി മാർഗ്ഗങ്ങളുണ്ട്, നിങ്ങൾ ഉപയോഗിക്കുന്ന രീതി നിങ്ങളുടെ ഡാറ്റയെ ആശ്രയിച്ചിരിക്കും. ഏറ്റവും സാധാരണമായ ക്ലസ്റ്ററിംഗ് സാങ്കേതിക വിദ്യയായ K-മീൻസ് ഞങ്ങൾ പരീക്ഷിക്കും. തുടങ്ങാം!

നിങ്ങൾ പഠിക്കേണ്ട പദങ്ങൾ:

- സിലഹ്വെറ്റ് സ്കോറിംഗ്
- എൽബോ മെത്തഡ്
- ഇൻർഷ്യ
- വ്യത്യാസം

## പരിചയം

[K-മീൻസ് ക്ലസ്റ്ററിംഗ്](https://wikipedia.org/wiki/K-means_clustering) സിഗ്നൽ പ്രോസസ്സിംഗ് മേഖലയിലെ ഒരു രീതി ആണ്. നിരീക്ഷണങ്ങളുടെ ഒരു പരമ്പര ഉപയോഗിച്ച് ഡാറ്റാ ഗ്രൂപ്പുകൾ 'k' ക്ലസ്റ്ററുകളായി വിഭജിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു. ഓരോ നിരീക്ഷണവും ഒരു ഡാറ്റാപോയിന്റിനെ അതിന്റെ അടുത്ത 'മീൻ' അല്ലെങ്കിൽ ക്ലസ്റ്ററിന്റെ കേന്ദ്രബിന്ദുവിലേക്ക് കൂട്ടിച്ചേർക്കാൻ പ്രവർത്തിക്കുന്നു.

ക്ലസ്റ്ററുകൾ [വോറോണോയി ഡയഗ്രാമുകൾ](https://wikipedia.org/wiki/Voronoi_diagram) ആയി ദൃശ്യവത്കരിക്കാം, അവയിൽ ഒരു പോയിന്റ് (അഥവാ 'സീഡ്') അതിന്റെ അനുബന്ധ പ്രദേശം ഉൾക്കൊള്ളുന്നു.

![voronoi diagram](../../../../translated_images/ml/voronoi.1dc1613fb0439b95.webp)

> ഇൻഫോഗ്രാഫിക് [ജെൻ ലൂപ്പർ](https://twitter.com/jenlooper) tarafından

K-മീൻസ് ക്ലസ്റ്ററിംഗ് പ്രക്രിയ [മൂന്ന് ഘട്ടങ്ങളിൽ പ്രവർത്തിക്കുന്നു](https://scikit-learn.org/stable/modules/clustering.html#k-means):

1. ആൽഗോരിതം ഡാറ്റാസെറ്റിൽ നിന്ന് സാമ്പിൾ ചെയ്ത് k-എണ്ണം കേന്ദ്രബിന്ദുക്കൾ തിരഞ്ഞെടുക്കുന്നു. ഇതിന് ശേഷം ഇത് ലൂപ്പ് ചെയ്യുന്നു:
    1. ഓരോ സാമ്പിളും അടുത്ത സെൻട്രോയിഡിലേക്ക് നിയോഗിക്കുന്നു.
    2. മുൻ സെൻട്രോയിഡുകൾക്ക് നിയോഗിച്ച എല്ലാ സാമ്പിളുകളുടെ ശരാശരി മൂല്യം എടുത്ത് പുതിയ സെൻട്രോയിഡുകൾ സൃഷ്ടിക്കുന്നു.
    3. പുതിയ സെൻട്രോയിഡുകളും പഴയ സെൻട്രോയിഡുകളും തമ്മിലുള്ള വ്യത്യാസം കണക്കാക്കി സെൻട്രോയിഡുകൾ സ്ഥിരതയുള്ളതാകുന്നത് വരെ ആവർത്തിക്കുന്നു.

K-മീൻസ് ഉപയോഗിക്കുന്നതിന്റെ ഒരു ദോഷം 'k' എന്ന സെൻട്രോയിഡുകളുടെ എണ്ണം നിശ്ചയിക്കേണ്ടതായിരിക്കുന്നു എന്നതാണ്. ഭാഗ്യവശാൽ 'എൽബോ മെത്തഡ്' 'k' നുള്ള നല്ല ആരംഭ മൂല്യം കണക്കാക്കാൻ സഹായിക്കുന്നു. നിങ്ങൾക്ക് ഇത് ഒരു നിമിഷം പരീക്ഷിക്കാം.

## മുൻകൂർ ആവശ്യകത

ഈ പാഠത്തിലെ [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/2-K-Means/notebook.ipynb) ഫയലിൽ നിങ്ങൾ പ്രവർത്തിക്കും, ഇതിൽ നിങ്ങൾ കഴിഞ്ഞ പാഠത്തിൽ ചെയ്ത ഡാറ്റ ഇറക്കുമതി ചെയ്യലും പ്രാഥമിക ശുചീകരണവും ഉൾക്കൊള്ളുന്നു.

## അഭ്യാസം - തയ്യാറെടുപ്പ്

പാട്ടുകളുടെ ഡാറ്റ വീണ്ടും പരിശോധിച്ച് തുടങ്ങുക.

1. ഓരോ കോളത്തിനും `boxplot()` വിളിച്ച് ഒരു ബോക്സ്‌പ്ലോട്ട് സൃഷ്ടിക്കുക:

    ```python
    plt.figure(figsize=(20,20), dpi=200)
    
    plt.subplot(4,3,1)
    sns.boxplot(x = 'popularity', data = df)
    
    plt.subplot(4,3,2)
    sns.boxplot(x = 'acousticness', data = df)
    
    plt.subplot(4,3,3)
    sns.boxplot(x = 'energy', data = df)
    
    plt.subplot(4,3,4)
    sns.boxplot(x = 'instrumentalness', data = df)
    
    plt.subplot(4,3,5)
    sns.boxplot(x = 'liveness', data = df)
    
    plt.subplot(4,3,6)
    sns.boxplot(x = 'loudness', data = df)
    
    plt.subplot(4,3,7)
    sns.boxplot(x = 'speechiness', data = df)
    
    plt.subplot(4,3,8)
    sns.boxplot(x = 'tempo', data = df)
    
    plt.subplot(4,3,9)
    sns.boxplot(x = 'time_signature', data = df)
    
    plt.subplot(4,3,10)
    sns.boxplot(x = 'danceability', data = df)
    
    plt.subplot(4,3,11)
    sns.boxplot(x = 'length', data = df)
    
    plt.subplot(4,3,12)
    sns.boxplot(x = 'release_date', data = df)
    ```

    ഈ ഡാറ്റ കുറച്ച് ശബ്ദമുള്ളതാണ്: ഓരോ കോളവും ബോക്സ്‌പ്ലോട്ട് ആയി നിരീക്ഷിച്ചാൽ, ഔട്ട്‌ലൈയർമാർ കാണാം.

    ![outliers](../../../../translated_images/ml/boxplots.8228c29dabd0f292.webp)

ഡാറ്റാസെറ്റ് പരിശോധിച്ച് ഈ ഔട്ട്‌ലൈയർമാർ നീക്കം ചെയ്യാം, പക്ഷേ അത് ഡാറ്റ വളരെ കുറവാക്കും.

1. ഇപ്പോൾ, ക്ലസ്റ്ററിംഗ് അഭ്യാസത്തിനായി നിങ്ങൾ ഉപയോഗിക്കാനിരിക്കുന്ന കോളങ്ങൾ തിരഞ്ഞെടുക്കുക. സമാനമായ പരിധികളുള്ളവ തിരഞ്ഞെടുക്കുക, കൂടാതെ `artist_top_genre` കോളം സംഖ്യാത്മക ഡാറ്റയായി എൻകോഡ് ചെയ്യുക:

    ```python
    from sklearn.preprocessing import LabelEncoder
    le = LabelEncoder()
    
    X = df.loc[:, ('artist_top_genre','popularity','danceability','acousticness','loudness','energy')]
    
    y = df['artist_top_genre']
    
    X['artist_top_genre'] = le.fit_transform(X['artist_top_genre'])
    
    y = le.transform(y)
    ```

1. ഇപ്പോൾ നിങ്ങൾ എത്ര ക്ലസ്റ്ററുകൾ ലക്ഷ്യമിടണമെന്ന് തിരഞ്ഞെടുക്കണം. ഡാറ്റാസെറ്റിൽ നിന്നുള്ള 3 പാട്ട് ജാനറുകൾ ഉണ്ട് എന്ന് നിങ്ങൾ അറിയാം, അതിനാൽ 3 പരീക്ഷിക്കാം:

    ```python
    from sklearn.cluster import KMeans
    
    nclusters = 3 
    seed = 0
    
    km = KMeans(n_clusters=nclusters, random_state=seed)
    km.fit(X)
    
    # ഓരോ ഡാറ്റാ പോയിന്റിനും ക്ലസ്റ്റർ പ്രവചിക്കുക
    
    y_cluster_kmeans = km.predict(X)
    y_cluster_kmeans
    ```

ഡാറ്റാഫ്രെയിമിലെ ഓരോ വരിയ്ക്കും പ്രവചിച്ച ക്ലസ്റ്ററുകൾ (0, 1, അല്ലെങ്കിൽ 2) ഉള്ള ഒരു അറേ പ്രിന്റ് ചെയ്യപ്പെടുന്നു.

1. ഈ അറേ ഉപയോഗിച്ച് 'സിലഹ്വെറ്റ് സ്കോർ' കണക്കാക്കുക:

    ```python
    from sklearn import metrics
    score = metrics.silhouette_score(X, y_cluster_kmeans)
    score
    ```

## സിലഹ്വെറ്റ് സ്കോർ

1-നോട് അടുത്ത സിലഹ്വെറ്റ് സ്കോർ നോക്കുക. ഈ സ്കോർ -1 മുതൽ 1 വരെ വ്യത്യാസപ്പെടുന്നു, സ്കോർ 1 ആണെങ്കിൽ, ക്ലസ്റ്റർ സാന്ദ്രവും മറ്റുള്ള ക്ലസ്റ്ററുകളിൽ നിന്ന് നന്നായി വേർതിരിച്ചിട്ടുള്ളതും ആണ്. 0-നോട് അടുത്ത മൂല്യം സമീപമുള്ള ക്ലസ്റ്ററുകളുടെ തീരുമാന അതിരിനോട് വളരെ അടുത്ത സാമ്പിളുകളുള്ള ഒവർലാപ്പിംഗ് ക്ലസ്റ്ററുകളെ പ്രതിനിധീകരിക്കുന്നു. [(മൂലം)](https://dzone.com/articles/kmeans-silhouette-score-explained-with-python-exam)

നമ്മുടെ സ്കോർ **.53** ആണ്, അതായത് മധ്യത്തിൽ. ഇത് നമ്മുടെ ഡാറ്റ ഈ തരത്തിലുള്ള ക്ലസ്റ്ററിംഗിനായി പ്രത്യേകിച്ച് അനുയോജ്യമല്ലെന്ന് സൂചിപ്പിക്കുന്നു, പക്ഷേ നാം തുടരാം.

### അഭ്യാസം - മോഡൽ നിർമ്മിക്കുക

1. `KMeans` ഇറക്കുമതി ചെയ്ത് ക്ലസ്റ്ററിംഗ് പ്രക്രിയ ആരംഭിക്കുക.

    ```python
    from sklearn.cluster import KMeans
    wcss = []
    
    for i in range(1, 11):
        kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
        kmeans.fit(X)
        wcss.append(kmeans.inertia_)
    
    ```

    ഇവിടെ ചില ഭാഗങ്ങൾ വിശദീകരിക്കേണ്ടതാണ്.

    > 🎓 range: ക്ലസ്റ്ററിംഗ് പ്രക്രിയയുടെ ആവർത്തനങ്ങൾ

    > 🎓 random_state: "സെൻട്രോയിഡ് ആരംഭത്തിനുള്ള റാൻഡം നമ്പർ ജനറേഷൻ നിർണ്ണയിക്കുന്നു." [മൂലം](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html#sklearn.cluster.KMeans)

    > 🎓 WCSS: "within-cluster sums of squares" ക്ലസ്റ്ററിലെ എല്ലാ പോയിന്റുകളുടെയും സെൻട്രോയിഡിനോട് ഉള്ള ചതുരശ്ര ശരാശരി ദൂരം അളക്കുന്നു. [മൂലം](https://medium.com/@ODSC/unsupervised-learning-evaluating-clusters-bd47eed175ce). 

    > 🎓 Inertia: K-മീൻസ് ആൽഗോരിതങ്ങൾ 'inertia' കുറയ്ക്കാൻ സെൻട്രോയിഡുകൾ തിരഞ്ഞെടുക്കാൻ ശ്രമിക്കുന്നു, "ക്ലസ്റ്ററുകൾ 얼마나 ആന്തരികമായി ഏകോപിതമാണെന്ന് അളക്കുന്ന ഒരു മാനദണ്ഡം." [മൂലം](https://scikit-learn.org/stable/modules/clustering.html). ഓരോ ആവർത്തനത്തിലും ഈ മൂല്യം wcss വേരിയബിളിൽ ചേർക്കുന്നു.

    > 🎓 k-means++: [Scikit-learn](https://scikit-learn.org/stable/modules/clustering.html#k-means) ൽ 'k-means++' ഓപ്റ്റിമൈസേഷൻ ഉപയോഗിക്കാം, ഇത് "സെൻട്രോയിഡുകൾ സാധാരണയായി പരസ്പരം ദൂരമുള്ളവയായി ആരംഭിക്കുന്നു, ഇത് റാൻഡം ആരംഭത്തേക്കാൾ നല്ല ഫലങ്ങൾ നൽകാൻ സാധ്യതയുണ്ട്."

### എൽബോ മെത്തഡ്

മുൻപ്, 3 പാട്ട് ജാനറുകൾ ലക്ഷ്യമിട്ടതിനാൽ 3 ക്ലസ്റ്ററുകൾ തിരഞ്ഞെടുക്കണമെന്ന് നിങ്ങൾ കരുതിയിരുന്നു. പക്ഷേ അതെല്ലാം ശരിയാണോ?

1. 'എൽബോ മെത്തഡ്' ഉപയോഗിച്ച് ഉറപ്പാക്കുക.

    ```python
    plt.figure(figsize=(10,5))
    sns.lineplot(x=range(1, 11), y=wcss, marker='o', color='red')
    plt.title('Elbow')
    plt.xlabel('Number of clusters')
    plt.ylabel('WCSS')
    plt.show()
    ```

    മുൻപത്തെ ഘട്ടത്തിൽ നിർമ്മിച്ച `wcss` വേരിയബിൾ ഉപയോഗിച്ച് എൽബോയിൽ 'വളവ്' എവിടെയാണ് എന്ന് കാണിക്കുന്ന ചാർട്ട് സൃഷ്ടിക്കുക, ഇത് ഏറ്റവും അനുയോജ്യമായ ക്ലസ്റ്റർ എണ്ണം സൂചിപ്പിക്കുന്നു. അത് **3** ആകാം!

    ![elbow method](../../../../translated_images/ml/elbow.72676169eed744ff.webp)

## അഭ്യാസം - ക്ലസ്റ്ററുകൾ പ്രദർശിപ്പിക്കുക

1. വീണ്ടും പ്രക്രിയ പരീക്ഷിക്കുക, ഈ തവണ മൂന്ന് ക്ലസ്റ്ററുകൾ സജ്ജമാക്കി, ക്ലസ്റ്ററുകൾ സ്കാറ്റർപ്ലോട്ട് ആയി പ്രദർശിപ്പിക്കുക:

    ```python
    from sklearn.cluster import KMeans
    kmeans = KMeans(n_clusters = 3)
    kmeans.fit(X)
    labels = kmeans.predict(X)
    plt.scatter(df['popularity'],df['danceability'],c = labels)
    plt.xlabel('popularity')
    plt.ylabel('danceability')
    plt.show()
    ```

1. മോഡലിന്റെ കൃത്യത പരിശോധിക്കുക:

    ```python
    labels = kmeans.labels_
    
    correct_labels = sum(y == labels)
    
    print("Result: %d out of %d samples were correctly labeled." % (correct_labels, y.size))
    
    print('Accuracy score: {0:0.2f}'. format(correct_labels/float(y.size)))
    ```

    ഈ മോഡലിന്റെ കൃത്യത വളരെ നല്ലതല്ല, ക്ലസ്റ്ററുകളുടെ ആകൃതി ഇതിന് കാരണം നൽകുന്നു.

    ![clusters](../../../../translated_images/ml/clusters.b635354640d8e4fd.webp)

    ഈ ഡാറ്റ വളരെ അസമതുലിതമാണ്, correlation കുറവാണ്, കോളം മൂല്യങ്ങൾക്കിടയിൽ വ്യത്യാസം കൂടുതലാണ്, അതിനാൽ നല്ല ക്ലസ്റ്ററിംഗ് സാധ്യമല്ല. യഥാർത്ഥത്തിൽ, രൂപപ്പെടുന്ന ക്ലസ്റ്ററുകൾ മുകളിൽ നിർവചിച്ച മൂന്ന് ജാനർ വിഭാഗങ്ങൾ മൂലം ശക്തമായി സ്വാധീനിക്കപ്പെട്ടതായിരിക്കാം. അത് ഒരു പഠന പ്രക്രിയ ആയിരുന്നു!

    Scikit-learn ഡോക്യുമെന്റേഷനിൽ, ഈ പോലുള്ള മോഡലുകൾക്ക്, ക്ലസ്റ്ററുകൾ നന്നായി വേർതിരിച്ചിട്ടില്ലാത്തതിനാൽ, 'വ്യത്യാസം' പ്രശ്നമുണ്ട്:

    ![problem models](../../../../translated_images/ml/problems.f7fb539ccd80608e.webp)
    > Scikit-learn ഇൻഫോഗ്രാഫിക്

## വ്യത്യാസം

വ്യത്യാസം "ശരാശരിയിൽ നിന്നുള്ള ചതുരശ്ര വ്യത്യാസങ്ങളുടെ ശരാശരി" ആയി നിർവചിക്കുന്നു [(മൂലം)](https://www.mathsisfun.com/data/standard-deviation.html). ഈ ക്ലസ്റ്ററിംഗ് പ്രശ്നത്തിന്റെ സാന്ദർഭ്യത്തിൽ, ഡാറ്റാസെറ്റിലെ സംഖ്യകൾ ശരാശരിയിൽ നിന്ന് വളരെ വ്യത്യാസപ്പെടുന്നു എന്നർത്ഥമാണ്.

✅ ഈ പ്രശ്നം പരിഹരിക്കാൻ നിങ്ങൾക്ക് ഉള്ള എല്ലാ മാർഗ്ഗങ്ങളെ കുറിച്ച് ചിന്തിക്കാൻ ഇത് നല്ല അവസരമാണ്. ഡാറ്റ കുറച്ച് കൂടുതൽ ക്രമീകരിക്കാമോ? വ്യത്യസ്ത കോളങ്ങൾ ഉപയോഗിക്കാമോ? വ്യത്യസ്ത ആൽഗോരിതം പരീക്ഷിക്കാമോ? സൂചന: ഡാറ്റ നോർമലൈസ് ചെയ്യാൻ [സ്കെയിലിംഗ്](https://www.mygreatlearning.com/blog/learning-data-science-with-k-means-clustering/) പരീക്ഷിച്ച് മറ്റ് കോളങ്ങൾ പരീക്ഷിക്കുക.

> ഈ '[വ്യത്യാസം കാൽക്കുലേറ്റർ](https://www.calculatorsoup.com/calculators/statistics/variance-calculator.php)' പരീക്ഷിച്ച് ആശയം കൂടുതൽ മനസ്സിലാക്കുക.

---

## 🚀ചലഞ്ച്

ഈ നോട്ട്‌ബുക്കിൽ ചില സമയം ചെലവഴിക്കുക, പാരാമീറ്ററുകൾ ക്രമീകരിക്കുക. ഡാറ്റ കൂടുതൽ ശുചീകരിച്ച് (ഉദാഹരണത്തിന്, ഔട്ട്‌ലൈയർമാർ നീക്കംചെയ്ത്) മോഡലിന്റെ കൃത്യത മെച്ചപ്പെടുത്താൻ കഴിയുമോ? നിങ്ങൾക്ക് ചില ഡാറ്റ സാമ്പിളുകൾക്ക് കൂടുതൽ ഭാരമിടാൻ weights ഉപയോഗിക്കാം. മികച്ച ക്ലസ്റ്ററുകൾ സൃഷ്ടിക്കാൻ മറ്റെന്തെല്ലാം ചെയ്യാം?

സൂചന: നിങ്ങളുടെ ഡാറ്റ സ്കെയിൽ ചെയ്യാൻ ശ്രമിക്കുക. ഡാറ്റ കോളങ്ങൾ പരസ്പരം പരിധിയിൽ കൂടുതൽ സമാനമാക്കാൻ സ്റ്റാൻഡേർഡ് സ്കെയിലിംഗ് ചേർക്കുന്ന കോഡ് നോട്ട്‌ബുക്കിൽ കമന്റ് ചെയ്തിട്ടുണ്ട്. സിലഹ്വെറ്റ് സ്കോർ കുറയുമ്പോഴും, എൽബോ ഗ്രാഫിലെ 'കിങ്ക്' മൃദുവാകുന്നതായി കാണും. കാരണം, ഡാറ്റ സ്കെയിൽ ചെയ്യാതെ വെച്ചാൽ കുറവ് വ്യത്യാസമുള്ള ഡാറ്റ കൂടുതൽ ഭാരമിടാൻ കഴിയും. ഈ പ്രശ്നത്തെ കുറിച്ച് കൂടുതൽ വായിക്കുക [ഇവിടെ](https://stats.stackexchange.com/questions/21222/are-mean-normalization-and-feature-scaling-needed-for-k-means-clustering/21226#21226).

## [പോസ്റ്റ്-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ml/)

## അവലോകനം & സ്വയം പഠനം

[K-മീൻസ് സിമുലേറ്റർ](https://user.ceng.metu.edu.tr/~akifakkus/courses/ceng574/k-means/) പോലുള്ള ഒരു ടൂൾ പരിശോധിക്കുക. ഈ ടൂൾ ഉപയോഗിച്ച് സാമ്പിൾ ഡാറ്റ പോയിന്റുകൾ ദൃശ്യവത്കരിച്ച് സെൻട്രോയിഡുകൾ നിർണ്ണയിക്കാം. ഡാറ്റയുടെ റാൻഡംനസ്, ക്ലസ്റ്ററുകളുടെ എണ്ണം, സെൻട്രോയിഡുകളുടെ എണ്ണം എഡിറ്റ് ചെയ്യാം. ഇത് ഡാറ്റ എങ്ങനെ ഗ്രൂപ്പുചെയ്യാമെന്ന് മനസ്സിലാക്കാൻ സഹായിക്കുന്നുണ്ടോ?

കൂടാതെ, സ്റ്റാൻഫോർഡിന്റെ [K-മീൻസ് ഹാൻഡ്‌ഔട്ട്](https://stanford.edu/~cpiech/cs221/handouts/kmeans.html) നോക്കുക.

## അസൈൻമെന്റ്

[വ്യത്യസ്ത ക്ലസ്റ്ററിംഗ് രീതികൾ പരീക്ഷിക്കുക](assignment.md)

---

<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**അസൂയാ**:  
ഈ രേഖ AI വിവർത്തന സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->