From fba79f31f6ae8350fbc97e801f6994949b571139 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 01:12:29 +0530
Subject: [PATCH 01/44] Add Malayalam (ml) _toctree.yml for chapters 0-1

---
 chapters/ml/_toctree.yml | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 chapters/ml/_toctree.yml

diff --git a/chapters/ml/_toctree.yml b/chapters/ml/_toctree.yml
new file mode 100644
index 000000000..c66dbf17c
--- /dev/null
+++ b/chapters/ml/_toctree.yml
@@ -0,0 +1,30 @@
+- title: 0. സജ്ജീകരണം
+  sections:
+  - local: chapter0/1
+    title: ആമുഖം
+
+- title: 1. Transformer മോഡലുകൾ
+  sections:
+  - local: chapter1/1
+    title: ആമുഖം
+  - local: chapter1/2
+    title: നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗും ലാർജ് ലാംഗ്വേജ് മോഡലുകളും
+  - local: chapter1/3
+    title: Transformer-കൾക്ക് എന്തെല്ലാം ചെയ്യാൻ കഴിയും?
+  - local: chapter1/4
+    title: Transformer-കൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു?
+  - local: chapter1/5
+    title: 🤗 Transformers എങ്ങനെ ടാസ്‌ക്കുകൾ പരിഹരിക്കുന്നു
+  - local: chapter1/6
+    title: Transformer ആർക്കിടെക്ചറുകൾ
+  - local: chapter1/7
+    title: ചെറു ക്വിസ്
+  - local: chapter1/8
+    title: LLM-കൾ ഉപയോഗിച്ചുള്ള ഇൻഫറൻസ്
+  - local: chapter1/9
+    title: പക്ഷപാതവും പരിമിതികളും
+  - local: chapter1/10
+    title: സംഗ്രഹം
+  - local: chapter1/11
+    title: സർട്ടിഫിക്കേഷൻ പരീക്ഷ
+    quiz: 1

From 3369fe74df19372b6a2c96fec869ee16d406a629 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 01:15:24 +0530
Subject: [PATCH 02/44] Add Malayalam TRANSLATING.txt (glossary and style
 notes)

---
 chapters/ml/TRANSLATING.txt | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 chapters/ml/TRANSLATING.txt

diff --git a/chapters/ml/TRANSLATING.txt b/chapters/ml/TRANSLATING.txt
new file mode 100644
index 000000000..2775fdea6
--- /dev/null
+++ b/chapters/ml/TRANSLATING.txt
@@ -0,0 +1,34 @@
+1. ഈ വിവർത്തനത്തിന്റെ ലക്ഷ്യം മലയാളം സംസാരിക്കുന്ന പഠിതാക്കൾക്ക് സ്വാഭാവികമായി വായിക്കാവുന്ന, വ്യക്തമായ ഒരു കോഴ്‌സ് നൽകുകയാണ് — വാക്കിനുവാക്ക് പരിഭാഷയല്ല, അർത്ഥം കൃത്യമായി കൈമാറുന്ന പരിഭാഷയാണ് വേണ്ടത്.
+
+2. സാങ്കേതിക പദങ്ങൾ (technical terms): മെഷീൻ ലേണിംഗ് / NLP മേഖലയിലെ സ്ഥാപിതമായ ഇംഗ്ലീഷ് പദങ്ങൾ ഇംഗ്ലീഷിൽ തന്നെ നിലനിർത്തുക, അല്ലെങ്കിൽ മലയാള ലിപിയിൽ എഴുതുക (transliteration). ഉദാഹരണം:
+   - Transformer → Transformer / ട്രാൻസ്‌ഫോർമർ
+   - model → മോഡൽ
+   - token / tokenizer / tokenization → ടോക്കൺ / ടോക്കണൈസർ / ടോക്കണൈസേഷൻ
+   - fine-tuning → ഫൈൻ-ട്യൂണിംഗ്
+   - pretraining → പ്രീട്രെയിനിംഗ്
+   - encoder / decoder → എൻകോഡർ / ഡീകോഡർ
+   - attention → അറ്റൻഷൻ
+   - embedding → എംബെഡ്ഡിംഗ്
+   - dataset → ഡേറ്റാസെറ്റ്
+   - pipeline → പൈപ്പ്‌ലൈൻ
+   - inference → ഇൻഫറൻസ്
+   - prompt → പ്രോംപ്‌റ്റ്
+   - checkpoint → ചെക്ക്‌പോയിന്റ്
+   - library → ലൈബ്രറി
+   - notebook → നോട്ട്‌ബുക്ക്
+   - GPU / CPU / API / LLM / NLP → അതേപടി (ഇംഗ്ലീഷിൽ)
+   ആദ്യമായി ഒരു പദം വരുമ്പോൾ ആവശ്യമെങ്കിൽ ബ്രാക്കറ്റിൽ ഇംഗ്ലീഷ് പദം ചേർക്കാം: ഉദാ. "അറ്റൻഷൻ (attention)".
+
+3. ഇവ വിവർത്തനം ചെയ്യരുത്:
+   - കോഡ് ബ്ലോക്കുകൾ, ഇൻലൈൻ കോഡ് (`...`), ഫയൽ/ഫോൾഡർ പേരുകൾ, കമാൻഡുകൾ
+   - URL-കൾ, ചിത്രങ്ങളുടെ പാതകൾ (image paths)
+   - MDX ഘടകങ്ങൾ (<CourseFloatingBanner>, <Youtube>, <Question>, <Tip>, <div> ...) — ഇവയുടെ ആട്രിബ്യൂട്ടുകൾ അതേപടി വയ്ക്കുക; വായിക്കാവുന്ന ടെക്‌സ്‌റ്റ് മാത്രം (text, explain, alt) വിവർത്തനം ചെയ്യുക
+   - തലക്കെട്ടുകളിലെ anchor ID-കൾ: `## തലക്കെട്ട്[[anchor-id]]` — anchor ഇംഗ്ലീഷിൽ അതേപടി നിലനിർത്തുക
+   - മോഡലുകളുടെയും ലൈബ്രറികളുടെയും കമ്പനികളുടെയും പേരുകൾ (BERT, GPT, Llama, 🤗 Transformers, Hugging Face Hub, Google Colab, PyTorch ...)
+   - വ്യക്തികളുടെ പേരുകൾ (ഇംഗ്ലീഷിൽ നിലനിർത്തുക)
+
+4. ശൈലി: വായനക്കാരനെ ബഹുമാനപൂർവ്വം "നിങ്ങൾ" എന്ന് അഭിസംബോധന ചെയ്യുക. ലളിതവും സംഭാഷണാത്മകവുമായ, എന്നാൽ കൃത്യമായ മലയാളം ഉപയോഗിക്കുക. വളരെ സംസ്‌കൃതവത്കൃതമായ പദങ്ങളെക്കാൾ സാധാരണ ഉപയോഗത്തിലുള്ള പദങ്ങൾക്ക് മുൻഗണന നൽകുക.
+
+5. അക്ഷരവിന്യാസം: ഏകീകൃതമായ യൂണികോഡ് മലയാളം (ചില്ലക്ഷരങ്ങൾക്ക് atomic chillu: ൻ ർ ൽ ൾ ൺ) ഉപയോഗിക്കുക. ആവശ്യമുള്ളിടത്ത് ZWJ/ZWNJ ഉപയോഗിക്കാം.
+
+6. Markdown ഘടന (തലക്കെട്ടുകളുടെ ലെവൽ, ലിസ്റ്റുകൾ, ബോൾഡ്/ഇറ്റാലിക്, ടേബിളുകൾ, ഒഴിഞ്ഞ വരികൾ) ഇംഗ്ലീഷ് മൂലത്തിന് സമാനമായി നിലനിർത്തുക.

From ae8faf924ec9ac1eb7ce7479ac850962ac646d31 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 01:19:49 +0530
Subject: [PATCH 03/44] Add Malayalam translation of chapter0/1.mdx (Setup)

---
 chapters/ml/chapter0/1.mdx | 110 +++++++++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 chapters/ml/chapter0/1.mdx

diff --git a/chapters/ml/chapter0/1.mdx b/chapters/ml/chapter0/1.mdx
new file mode 100644
index 000000000..25b78f665
--- /dev/null
+++ b/chapters/ml/chapter0/1.mdx
@@ -0,0 +1,110 @@
+# ആമുഖം[[introduction]]
+
+Hugging Face കോഴ്‌സിലേക്ക് സ്വാഗതം! ഈ ആമുഖം നിങ്ങളെ ഒരു വർക്കിംഗ് എൻവയോൺമെന്റ് (working environment) സജ്ജമാക്കാൻ സഹായിക്കും. നിങ്ങൾ കോഴ്‌സ് ഇപ്പോൾ തുടങ്ങുകയാണെങ്കിൽ, ആദ്യം [അധ്യായം 1](/course/chapter1) ഒന്ന് നോക്കുകയും, പിന്നീട് തിരിച്ചുവന്ന് എൻവയോൺമെന്റ് സജ്ജമാക്കുകയും ചെയ്യാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു — അങ്ങനെ കോഡ് നിങ്ങൾക്ക് സ്വയം പരീക്ഷിച്ചുനോക്കാം.
+
+ഈ കോഴ്‌സിൽ നാം ഉപയോഗിക്കുന്ന എല്ലാ ലൈബ്രറികളും Python പാക്കേജുകളായി ലഭ്യമാണ്. അതിനാൽ ഒരു Python എൻവയോൺമെന്റ് എങ്ങനെ സജ്ജമാക്കാമെന്നും നിങ്ങൾക്ക് ആവശ്യമായ ലൈബ്രറികൾ എങ്ങനെ ഇൻസ്‌റ്റാൾ ചെയ്യാമെന്നും ഇവിടെ കാണിച്ചുതരാം.
+
+വർക്കിംഗ് എൻവയോൺമെന്റ് സജ്ജമാക്കാനുള്ള രണ്ട് വഴികളാണ് നാം ഇവിടെ പരിചയപ്പെടുന്നത്: ഒരു Colab നോട്ട്‌ബുക്ക് ഉപയോഗിക്കുക, അല്ലെങ്കിൽ ഒരു Python വിർച്വൽ എൻവയോൺമെന്റ് (virtual environment) ഉപയോഗിക്കുക. നിങ്ങൾക്ക് ഏറ്റവും ഇണങ്ങുന്നത് ഏതാണോ അത് തിരഞ്ഞെടുക്കാം. തുടക്കക്കാർക്ക് Colab നോട്ട്‌ബുക്ക് ഉപയോഗിച്ച് ആരംഭിക്കാനാണ് ഞങ്ങൾ ശക്തമായി ശുപാർശ ചെയ്യുന്നത്.
+
+Windows സിസ്‌റ്റം ഇവിടെ പ്രതിപാദിക്കുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക. നിങ്ങൾ Windows-ലാണെങ്കിൽ, ഒരു Colab നോട്ട്‌ബുക്ക് ഉപയോഗിച്ച് പിന്തുടരാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു. Linux ഡിസ്ട്രിബ്യൂഷനോ macOS-ഓ ആണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, ഇവിടെ വിവരിക്കുന്ന രണ്ട് രീതികളിൽ ഏതും ഉപയോഗിക്കാം.
+
+കോഴ്‌സിന്റെ ഭൂരിഭാഗവും നിങ്ങൾക്ക് ഒരു Hugging Face അക്കൗണ്ട് ഉണ്ടെന്ന അനുമാനത്തിലാണ്. ഇപ്പോൾ തന്നെ ഒന്ന് ഉണ്ടാക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു: [ഒരു അക്കൗണ്ട് ഉണ്ടാക്കുക](https://huggingface.co/join).
+
+## ഒരു Google Colab നോട്ട്‌ബുക്ക് ഉപയോഗിക്കുന്നത്[[using-a-google-colab-notebook]]
+
+Colab നോട്ട്‌ബുക്ക് ഉപയോഗിക്കുന്നതാണ് സാധ്യമായതിൽ ഏറ്റവും ലളിതമായ സെറ്റപ്പ്; ബ്രൗസറിൽ ഒരു നോട്ട്‌ബുക്ക് തുറന്ന് നേരെ കോഡിംഗിലേക്ക് കടക്കാം! 
+
+Colab നിങ്ങൾക്ക് പരിചിതമല്ലെങ്കിൽ, [ആമുഖം](https://colab.research.google.com/notebooks/intro.ipynb) പിന്തുടർന്ന് തുടങ്ങാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു. GPU-കൾ, TPU-കൾ പോലുള്ള ആക്സിലറേറ്റിംഗ് ഹാർഡ്‌വെയർ ഉപയോഗിക്കാൻ Colab അനുവദിക്കുന്നു, ചെറിയ വർക്ക്‌ലോഡുകൾക്ക് ഇത് സൗജന്യവുമാണ്.
+
+Colab-ൽ സഞ്ചരിക്കാൻ നിങ്ങൾക്ക് സൌകര്യമായിക്കഴിഞ്ഞാൽ, ഒരു പുതിയ നോട്ട്‌ബുക്ക് ഉണ്ടാക്കി സെറ്റപ്പ് ആരംഭിക്കുക:
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter0/new_colab.png" alt="ഒരു ഒഴിഞ്ഞ colab നോട്ട്‌ബുക്ക്" width="80%"/>
+</div>
+
+അടുത്ത പടി ഈ കോഴ്‌സിൽ നാം ഉപയോഗിക്കുന്ന ലൈബ്രറികൾ ഇൻസ്‌റ്റാൾ ചെയ്യുകയാണ്. ഇൻസ്‌റ്റാളേഷനായി നാം Python-ന്റെ പാക്കേജ് മാനേജറായ `pip` ഉപയോഗിക്കും. നോട്ട്‌ബുക്കുകളിൽ, കമാൻഡിന് മുന്നിൽ `!` എന്ന ചിഹ്നം ചേർത്ത് സിസ്‌റ്റം കമാൻഡുകൾ റൺ ചെയ്യാം. അതിനാൽ 🤗 Transformers ലൈബ്രറി ഇങ്ങനെ ഇൻസ്‌റ്റാൾ ചെയ്യാം:
+
+```
+!pip install transformers
+```
+
+Python റൺടൈമിനുള്ളിൽ ഇംപോർട്ട് ചെയ്തുനോക്കി പാക്കേജ് ശരിയായി ഇൻസ്‌റ്റാൾ ആയെന്ന് ഉറപ്പാക്കാം:
+
+```
+import transformers
+```
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter0/install.gif" alt="മുകളിലെ രണ്ട് കമാൻഡുകളുടെ ഫലം കാണിക്കുന്ന ഒരു gif: ഇൻസ്‌റ്റാളേഷനും ഇംപോർട്ടും" width="80%"/>
+</div>
+
+ഇത് 🤗 Transformers-ന്റെ വളരെ ലഘുവായ ഒരു പതിപ്പാണ് ഇൻസ്‌റ്റാൾ ചെയ്യുന്നത്. പ്രത്യേകിച്ച്, ഒരു മെഷീൻ ലേണിംഗ് ഫ്രെയിംവർക്കും (PyTorch അല്ലെങ്കിൽ TensorFlow പോലുള്ളവ) ഇതിൽ ഇൻസ്‌റ്റാൾ ആകുന്നില്ല. ലൈബ്രറിയുടെ പലതരം ഫീച്ചറുകൾ നാം ഉപയോഗിക്കാൻ പോകുന്നതിനാൽ, ഡെവലപ്‌മെന്റ് പതിപ്പ് ഇൻസ്‌റ്റാൾ ചെയ്യാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു — ഊഹിക്കാവുന്ന ഏതാണ്ട് എല്ലാ ഉപയോഗങ്ങൾക്കും ആവശ്യമായ ഡിപ്പൻഡൻസികൾ (dependencies) ഇതിനൊപ്പം വരും:
+
+```
+!pip install transformers[sentencepiece]
+```
+
+ഇതിന് അൽപ്പം സമയമെടുക്കും, പക്ഷേ അതു കഴിഞ്ഞാൽ കോഴ്‌സിന്റെ ബാക്കി ഭാഗത്തിന് നിങ്ങൾ തയ്യാറായി!
+
+## ഒരു Python വിർച്വൽ എൻവയോൺമെന്റ് ഉപയോഗിക്കുന്നത്[[using-a-python-virtual-environment]]
+
+ഒരു Python വിർച്വൽ എൻവയോൺമെന്റ് ഉപയോഗിക്കാനാണ് നിങ്ങൾക്ക് താൽപ്പര്യമെങ്കിൽ, ആദ്യ പടി നിങ്ങളുടെ സിസ്‌റ്റത്തിൽ Python ഇൻസ്‌റ്റാൾ ചെയ്യുകയാണ്. തുടങ്ങാൻ [ഈ ഗൈഡ്](https://realpython.com/installing-python/) പിന്തുടരാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.
+
+Python ഇൻസ്‌റ്റാൾ ചെയ്തുകഴിഞ്ഞാൽ, നിങ്ങളുടെ ടെർമിനലിൽ Python കമാൻഡുകൾ റൺ ചെയ്യാൻ കഴിയണം. അടുത്ത ഘട്ടങ്ങളിലേക്ക് പോകുന്നതിന് മുമ്പ്, അത് ശരിയായി ഇൻസ്‌റ്റാൾ ആയെന്ന് ഉറപ്പാക്കാൻ ഈ കമാൻഡ് റൺ ചെയ്തുനോക്കാം: `python --version`. നിങ്ങളുടെ സിസ്‌റ്റത്തിൽ ഇപ്പോൾ ലഭ്യമായ Python പതിപ്പ് ഇത് പ്രിന്റ് ചെയ്യണം.
+
+ടെർമിനലിൽ `python --version` പോലുള്ള ഒരു Python കമാൻഡ് റൺ ചെയ്യുമ്പോൾ, നിങ്ങളുടെ കമാൻഡ് റൺ ചെയ്യുന്ന പ്രോഗ്രാമിനെ സിസ്‌റ്റത്തിലെ "പ്രധാന" (main) Python ആയി കണക്കാക്കണം. ഈ പ്രധാന ഇൻസ്‌റ്റാളേഷനിൽ ഒരു പാക്കേജും ഇൻസ്‌റ്റാൾ ചെയ്യാതെ സൂക്ഷിക്കാനും, നിങ്ങൾ പ്രവർത്തിക്കുന്ന ഓരോ ആപ്ലിക്കേഷനും വെവ്വേറെ എൻവയോൺമെന്റുകൾ ഉണ്ടാക്കാൻ അത് ഉപയോഗിക്കാനുമാണ് ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നത് — ഇങ്ങനെ ചെയ്താൽ ഓരോ ആപ്ലിക്കേഷനും അതിന്റേതായ ഡിപ്പൻഡൻസികളും പാക്കേജുകളും ഉണ്ടാകും, മറ്റ് ആപ്ലിക്കേഷനുകളുമായി ഉണ്ടാകാവുന്ന കോംപാറ്റിബിലിറ്റി പ്രശ്‌നങ്ങളെക്കുറിച്ച് നിങ്ങൾ ആശങ്കപ്പെടേണ്ടതുമില്ല.
+
+Python-ൽ ഇത് ചെയ്യുന്നത് [*വിർച്വൽ എൻവയോൺമെന്റുകൾ*](https://docs.python.org/3/tutorial/venv.html) ഉപയോഗിച്ചാണ്. ഇവ സ്വയംപൂർണ്ണമായ ഡയറക്ടറി ട്രീകളാണ് — ഓരോന്നിലും ഒരു നിശ്ചിത Python പതിപ്പുള്ള Python ഇൻസ്‌റ്റാളേഷനും ആപ്ലിക്കേഷന് ആവശ്യമായ എല്ലാ പാക്കേജുകളും അടങ്ങിയിരിക്കും. ഇത്തരമൊരു വിർച്വൽ എൻവയോൺമെന്റ് ഉണ്ടാക്കാൻ പല ടൂളുകളും ഉണ്ട്, എന്നാൽ നാം അതിനായി [`venv`](https://docs.python.org/3/library/venv.html#module-venv) എന്ന ഔദ്യോഗിക Python പാക്കേജ് ഉപയോഗിക്കും.
+
+ആദ്യം, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ സൂക്ഷിക്കാനുദ്ദേശിക്കുന്ന ഡയറക്ടറി ഉണ്ടാക്കുക — ഉദാഹരണത്തിന്, ഹോം ഡയറക്ടറിയുടെ റൂട്ടിൽ *transformers-course* എന്ന പേരിൽ ഒരു പുതിയ ഡയറക്ടറി ഉണ്ടാക്കാം:
+
+```
+mkdir ~/transformers-course
+cd ~/transformers-course
+```
+
+ഈ ഡയറക്ടറിക്കുള്ളിൽ നിന്ന്, Python-ന്റെ `venv` മൊഡ്യൂൾ ഉപയോഗിച്ച് ഒരു വിർച്വൽ എൻവയോൺമെന്റ് ഉണ്ടാക്കുക:
+
+```
+python -m venv .env
+```
+
+അല്ലാതെ ഒഴിഞ്ഞുകിടക്കുന്ന നിങ്ങളുടെ ഫോൾഡറിൽ ഇപ്പോൾ *.env* എന്ന ഒരു ഡയറക്ടറി ഉണ്ടായിരിക്കണം:
+
+```
+ls -a
+```
+
+```out
+.      ..    .env
+```
+
+`activate`, `deactivate` എന്നീ സ്‌ക്രിപ്‌റ്റുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് വിർച്വൽ എൻവയോൺമെന്റിലേക്ക് കടക്കാനും അതിൽ നിന്ന് പുറത്തുവരാനും കഴിയും:
+
+```
+# Activate the virtual environment
+source .env/bin/activate
+
+# Deactivate the virtual environment
+deactivate
+```
+
+`which python` എന്ന കമാൻഡ് റൺ ചെയ്ത് എൻവയോൺമെന്റ് ആക്ടിവേറ്റ് ആയെന്ന് ഉറപ്പാക്കാം: അത് വിർച്വൽ എൻവയോൺമെന്റിലേക്കാണ് ചൂണ്ടുന്നതെങ്കിൽ, നിങ്ങൾ അത് വിജയകരമായി ആക്ടിവേറ്റ് ചെയ്തിരിക്കുന്നു!
+
+```
+which python
+```
+
+```out
+/home/<user>/transformers-course/.env/bin/python
+```
+
+### ഡിപ്പൻഡൻസികൾ ഇൻസ്‌റ്റാൾ ചെയ്യുന്നത്[[installing-dependencies]]
+
+Google Colab ഇൻസ്‌റ്റൻസുകൾ ഉപയോഗിക്കുന്നതിനെക്കുറിച്ചുള്ള മുൻ വിഭാഗത്തിലെപ്പോലെ, തുടരാൻ ആവശ്യമായ പാക്കേജുകൾ ഇപ്പോൾ നിങ്ങൽ ഇൻസ്‌റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. `pip` പാക്കേജ് മാനേജർ ഉപയോഗിച്ച് 🤗 Transformers-ന്റെ ഡെവലപ്‌മെന്റ് പതിപ്പ് വീണ്ടും ഇങ്ങനെ ഇൻസ്‌റ്റാൾ ചെയ്യാം:
+
+```
+pip install "transformers[sentencepiece]"
+```
+
+ഇപ്പോൾ എല്ലാം സജ്ജമായി, നിങ്ങൾ മുന്നോട്ടുപോകാൻ തയ്യാറാണ്!

From 26ac87224158e46af5e1bf409d0d90153d09c167 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 01:28:26 +0530
Subject: [PATCH 04/44] Add Malayalam translation of chapter1/1.mdx
 (Introduction)

---
 chapters/ml/chapter1/1.mdx | 160 +++++++++++++++++++++++++++++++++++++
 1 file changed, 160 insertions(+)
 create mode 100644 chapters/ml/chapter1/1.mdx

diff --git a/chapters/ml/chapter1/1.mdx b/chapters/ml/chapter1/1.mdx
new file mode 100644
index 000000000..16164f74f
--- /dev/null
+++ b/chapters/ml/chapter1/1.mdx
@@ -0,0 +1,160 @@
+# ആമുഖം[[introduction]]
+
+<CourseFloatingBanner
+    chapter={1}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+## 🤗 കോഴ്‌സിലേക്ക് സ്വാഗതം![[welcome-to-the-course]]
+
+<Youtube id="00GKzGyWFEs" />
+
+[Hugging Face](https://huggingface.co/) ഇക്കോസിസ്‌റ്റത്തിലെ ലൈബ്രറികൾ — [🤗 Transformers](https://github.com/huggingface/transformers), [🤗 Datasets](https://github.com/huggingface/datasets), [🤗 Tokenizers](https://github.com/huggingface/tokenizers), [🤗 Accelerate](https://github.com/huggingface/accelerate) — എന്നിവയും [Hugging Face Hub](https://huggingface.co/models)-ഉം ഉപയോഗിച്ച് ലാർജ് ലാംഗ്വേജ് മോഡലുകളെ (LLM) കുറിച്ചും നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗിനെ (NLP) കുറിച്ചും ഈ കോഴ്‌സ് നിങ്ങളെ പഠിപ്പിക്കും. 
+
+Hugging Face ഇക്കോസിസ്‌റ്റത്തിന് പുറത്തുള്ള ലൈബ്രറികളും നാം പരിചയപ്പെടും. AI സമൂഹത്തിനുള്ള മികച്ച സംഭാവനകളും അത്യധികം ഉപകാരപ്രദമായ ടൂളുകളുമാണ് അവ.
+
+ഇത് പൂർണ്ണമായും സൗജന്യമാണ്, പരസ്യങ്ങളൊന്നുമില്ല.
+
+## NLP-യും LLM-കളും മനസ്സിലാക്കുന്നത്[[understanding-nlp-and-llms]]
+
+ഈ കോഴ്‌സ് തുടക്കത്തിൽ NLP-യിൽ (Natural Language Processing) ആയിരുന്നു ശ്രദ്ധ കേന്ദ്രീകരിച്ചിരുന്നതെങ്കിലും, ഈ മേഖലയിലെ ഏറ്റവും പുതിയ മുന്നേറ്റമായ ലാർജ് ലാംഗ്വേജ് മോഡലുകൾക്ക് (LLM) ഊന്നൽ നൽകുന്ന രീതിയിലേക്ക് ഇത് വികസിച്ചിരിക്കുന്നു. 
+
+**എന്താണ് വ്യത്യാസം?**
+- **NLP (Natural Language Processing)** എന്നത് കമ്പ്യൂട്ടറുകൾക്ക് മനുഷ്യഭാഷ മനസ്സിലാക്കാനും വ്യാഖ്യാനിക്കാനും സൃഷ്‌ടിക്കാനും കഴിവ് നൽകുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്ന വിശാലമായ മേഖലയാണ്. സെന്റിമെന്റ് അനാലിസിസ് (sentiment analysis), നെയിംഡ് എന്റിറ്റി റെക്കഗ്നിഷൻ (named entity recognition), മെഷീൻ ട്രാൻസ്‌ലേഷൻ (machine translation) തുടങ്ങി നിരവധി സങ്കേതങ്ങളും ടാസ്‌ക്കുകളും NLP-യിൽ ഉൾപ്പെടുന്നു.
+- **LLM-കൾ (Large Language Models)** NLP മോഡലുകളുടെ ശക്തമായ ഒരു ഉപവിഭാഗമാണ് — ഭീമമായ വലിപ്പം, വിപുലമായ ട്രെയിനിംഗ് ഡേറ്റ, ടാസ്‌ക്-നിർദ്ദിഷ്‌ട ട്രെയിനിംഗ് വളരെ കുറച്ചുമാത്രം നൽകിയാലും വൈവിധ്യമാർന്ന ഭാഷാ ടാസ്‌ക്കുകൾ ചെയ്യാനുള്ള കഴിവ് എന്നിവയാണ് ഇവയുടെ സവിശേഷതകൾ. Llama, GPT, Claude സീരീസ് പോലുള്ള മോഡലുകൾ NLP-യിൽ സാധ്യമായതിനെ അടിമുടി മാറ്റിമറിച്ച LLM-കൾക്കുള്ള ഉദാഹരണങ്ങളാണ്.
+
+ഈ കോഴ്‌സിലുടനീളം, പരമ്പരാഗത NLP ആശയങ്ങളും അത്യാധുനിക LLM സങ്കേതങ്ങളും നിങ്ങൾ പഠിക്കും — കാരണം LLM-കളുമായി ഫലപ്രദമായി പ്രവർത്തിക്കാൻ NLP-യുടെ അടിസ്ഥാനങ്ങൾ മനസ്സിലാക്കുന്നത് അത്യാവശ്യമാണ്.
+
+## എന്താണ് പ്രതീക്ഷിക്കേണ്ടത്?[[what-to-expect]]
+
+കോഴ്‌സിന്റെ ഒരു ഹ്രസ്വ അവലോകനം ഇതാ:
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/summary.svg" alt="കോഴ്‌സിലെ അധ്യായങ്ങളുടെ ഹ്രസ്വ അവലോകനം.">
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/summary-dark.svg" alt="കോഴ്‌സിലെ അധ്യായങ്ങളുടെ ഹ്രസ്വ അവലോകനം.">
+</div>
+
+- അധ്യായങ്ങൾ 1 മുതൽ 4 വരെ 🤗 Transformers ലൈബ്രറിയുടെ പ്രധാന ആശയങ്ങളിലേക്ക് ഒരു ആമുഖം നൽകുന്നു. കോഴ്‌സിന്റെ ഈ ഭാഗം പൂർത്തിയാകുമ്പോൾ, Transformer മോഡലുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നത് നിങ്ങൾക്ക് പരിചിതമാകും; [Hugging Face Hub](https://huggingface.co/models)-ൽ നിന്ന് ഒരു മോഡൽ ഉപയോഗിക്കാനും, ഒരു ഡേറ്റാസെറ്റിൽ അത് ഫൈൻ-ട്യൂൺ ചെയ്യാനും, നിങ്ങളുടെ ഫലങ്ങൾ Hub-ൽ പങ്കുവയ്ക്കാനും നിങ്ങൾക്ക് അറിയാമായിരിക്കും!
+- അധ്യായങ്ങൾ 5 മുതൽ 8 വരെ 🤗 Datasets-ന്റെയും 🤗 Tokenizers-ന്റെയും അടിസ്ഥാനങ്ങൾ പഠിപ്പിച്ചശേഷം ക്ലാസിക് NLP ടാസ്‌ക്കുകളിലേക്കും LLM സങ്കേതങ്ങളിലേക്കും കടക്കുന്നു. ഈ ഭാഗം പൂർത്തിയാകുമ്പോൾ, ഏറ്റവും സാധാരണമായ ഭാഷാ പ്രോസസ്സിംഗ് വെല്ലുവിളികളെ സ്വയം നേരിടാൻ നിങ്ങൾക്ക് കഴിയും.
+- അധ്യായം 9 NLP-ക്ക് അപ്പുറം കടന്ന്, നിങ്ങളുടെ മോഡലുകളുടെ ഡെമോകൾ 🤗 Hub-ൽ എങ്ങനെ നിർമ്മിക്കാമെന്നും പങ്കുവയ്ക്കാമെന്നും വിവരിക്കുന്നു. ഈ ഭാഗം പൂർത്തിയാകുമ്പോൾ, നിങ്ങളുടെ 🤗 Transformers ആപ്ലിക്കേഷൻ ലോകത്തിന് മുന്നിൽ അവതരിപ്പിക്കാൻ നിങ്ങൾ തയ്യാറായിരിക്കും!
+- അധ്യായങ്ങൾ 10 മുതൽ 12 വരെ ഫൈൻ-ട്യൂണിംഗ്, ഉയർന്ന ഗുണനിലവാരമുള്ള ഡേറ്റാസെറ്റുകൾ തയ്യാറാക്കൽ, റീസണിംഗ് മോഡലുകൾ (reasoning models) നിർമ്മിക്കൽ തുടങ്ങിയ അഡ്വാൻസ്‌ഡ് LLM വിഷയങ്ങളിലേക്ക് ആഴത്തിൽ കടക്കുന്നു.
+
+ഈ കോഴ്‌സ്:
+
+* Python-ൽ നല്ല അറിവ് ആവശ്യപ്പെടുന്നു
+* [fast.ai-യുടെ](https://www.fast.ai/) [Practical Deep Learning for Coders](https://course.fast.ai/) അല്ലെങ്കിൽ [DeepLearning.AI](https://www.deeplearning.ai/) വികസിപ്പിച്ച പ്രോഗ്രാമുകളിലൊന്ന് പോലുള്ള ഒരു ആമുഖ ഡീപ് ലേണിംഗ് കോഴ്‌സിന് ശേഷം പഠിക്കുന്നതാണ് കൂടുതൽ നല്ലത്
+* [PyTorch](https://pytorch.org/) അല്ലെങ്കിൽ [TensorFlow](https://www.tensorflow.org/) മുൻപരിചയം പ്രതീക്ഷിക്കുന്നില്ല, എങ്കിലും ഇവയിലേതെങ്കിലുമൊന്നിലുള്ള അൽപ്പം പരിചയം സഹായകമാകും
+
+ഈ കോഴ്‌സ് പൂർത്തിയാക്കിയശേഷം, DeepLearning.AI-യുടെ [Natural Language Processing Specialization](https://www.coursera.org/specializations/natural-language-processing?utm_source=deeplearning-ai&utm_medium=institutions&utm_campaign=20211011-nlp-2-hugging_face-page-nlp-refresh) ഒന്ന് പരിശോധിക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു — naive Bayes, LSTM-കൾ പോലുള്ള, അറിഞ്ഞിരിക്കേണ്ടതായ നിരവധി പരമ്പരാഗത NLP മോഡലുകൾ ഇത് ഉൾക്കൊള്ളുന്നു!
+
+## ഞങ്ങൾ ആരാണ്?[[who-are-we]]
+
+രചയിതാക്കളെക്കുറിച്ച്:
+
+[**Abubakar Abid**](https://huggingface.co/abidlabs) Stanford-ൽ അപ്ലൈഡ് മെഷീൻ ലേണിംഗിൽ PhD പൂർത്തിയാക്കി. PhD കാലത്ത് അദ്ദേഹം [Gradio](https://github.com/gradio-app/gradio) എന്ന ഓപ്പൺ സോഴ്‌സ് Python ലൈബ്രറി സ്ഥാപിച്ചു — 600,000-ത്തിലധികം മെഷീൻ ലേണിംഗ് ഡെമോകൾ നിർമ്മിക്കാൻ ഇത് ഉപയോഗിച്ചിട്ടുണ്ട്. Gradio-യെ Hugging Face ഏറ്റെടുത്തു, അവിടെ Abubakar ഇപ്പോൾ മെഷീൻ ലേണിംഗ് ടീം ലീഡായി പ്രവർത്തിക്കുന്നു.
+
+[**Ben Burtenshaw**](https://huggingface.co/burtenshaw) Hugging Face-ൽ മെഷീൻ ലേണിംഗ് എഞ്ചിനീയറാണ്. University of Antwerp-ൽ നിന്ന് Natural Language Processing-ൽ PhD പൂർത്തിയാക്കിയ അദ്ദേഹം, അവിടെ സാക്ഷരതാ കഴിവുകൾ മെച്ചപ്പെടുത്തുക എന്ന ലക്ഷ്യത്തോടെ കുട്ടികൾക്കുള്ള കഥകൾ സൃഷ്‌ടിക്കാൻ Transformer മോഡലുകൾ പ്രയോഗിച്ചു. അതിനുശേഷം, വിശാലമായ സമൂഹത്തിനുള്ള വിദ്യാഭ്യാസ സാമഗ്രികളിലും ടൂളുകളിലുമാണ് അദ്ദേഹം ശ്രദ്ധ കേന്ദ്രീകരിച്ചിരിക്കുന്നത്.
+
+[**Matthew Carrigan**](https://huggingface.co/Rocketknight1) Hugging Face-ൽ മെഷീൻ ലേണിംഗ് എഞ്ചിനീയറാണ്. അയർലൻഡിലെ ഡബ്ലിനിൽ താമസിക്കുന്ന അദ്ദേഹം മുമ്പ് Parse.ly-യിൽ ML എഞ്ചിനീയറായും അതിനു മുമ്പ് Trinity College Dublin-ൽ പോസ്‌റ്റ്-ഡോക്ടറൽ ഗവേഷകനായും പ്രവർത്തിച്ചിരുന്നു. നിലവിലുള്ള ആർക്കിടെക്‌ചറുകൾ വലുതാക്കി AGI-യിലേക്ക് എത്താനാകുമെന്ന് അദ്ദേഹം വിശ്വസിക്കുന്നില്ല, എങ്കിലും റോബോട്ട് അമരത്വത്തിൽ അദ്ദേഹത്തിന് വലിയ പ്രതീക്ഷയുണ്ട്.
+
+[**Lysandre Debut**](https://huggingface.co/lysandre) Hugging Face-ൽ മെഷീൻ ലേണിംഗ് എഞ്ചിനീയറാണ്; വികസനത്തിന്റെ വളരെ ആദ്യഘട്ടങ്ങൾ മുതൽ 🤗 Transformers ലൈബ്രറിയിൽ പ്രവർത്തിച്ചുവരുന്നു. വളരെ ലളിതമായ API-യുള്ള ടൂളുകൾ വികസിപ്പിച്ച് NLP എല്ലാവർക്കും പ്രാപ്യമാക്കുകയാണ് അദ്ദേഹത്തിന്റെ ലക്ഷ്യം.
+
+[**Sylvain Gugger**](https://huggingface.co/sgugger) Hugging Face-ൽ റിസർച്ച് എഞ്ചിനീയറും 🤗 Transformers ലൈബ്രറിയുടെ പ്രധാന മെയിന്റെയ്‌നർമാരിൽ ഒരാളുമാണ്. മുമ്പ് fast.ai-യിൽ റിസർച്ച് സയന്റിസ്‌റ്റായിരുന്ന അദ്ദേഹം Jeremy Howard-നൊപ്പം _[Deep Learning for Coders with fastai and PyTorch](https://learning.oreilly.com/library/view/deep-learning-for/9781492045519/)_ എന്ന പുസ്‌തകം സഹരചിച്ചു. പരിമിതമായ വിഭവങ്ങളിൽ മോഡലുകളെ വേഗത്തിൽ ട്രെയിൻ ചെയ്യാൻ സഹായിക്കുന്ന സങ്കേതങ്ങൾ രൂപകൽപ്പന ചെയ്യുകയും മെച്ചപ്പെടുത്തുകയും ചെയ്തുകൊണ്ട് ഡീപ് ലേണിംഗ് കൂടുതൽ പ്രാപ്യമാക്കുകയാണ് അദ്ദേഹത്തിന്റെ ഗവേഷണത്തിന്റെ പ്രധാന ലക്ഷ്യം.
+
+[**Dawood Khan**](https://huggingface.co/dawoodkhan82) Hugging Face-ൽ മെഷീൻ ലേണിംഗ് എഞ്ചിനീയറാണ്. NYC-യിൽ നിന്നുള്ള അദ്ദേഹം New York University-യിൽ നിന്ന് കമ്പ്യൂട്ടർ സയൻസിൽ ബിരുദം നേടി. കുറച്ചു വർഷം iOS എഞ്ചിനീയറായി ജോലി ചെയ്തശേഷം, സഹസ്ഥാപകർക്കൊപ്പം Gradio ആരംഭിക്കാനായി Dawood ആ ജോലി ഉപേക്ഷിച്ചു. പിന്നീട് Gradio-യെ Hugging Face ഏറ്റെടുത്തു.
+
+[**Merve Noyan**](https://huggingface.co/merve) Hugging Face-ൽ ഡെവലപ്പർ അഡ്വക്കേറ്റാണ്; മെഷീൻ ലേണിംഗ് എല്ലാവർക്കും പ്രാപ്യമാക്കാൻ ടൂളുകൾ വികസിപ്പിക്കുകയും അവയെക്കുറിച്ചുള്ള ഉള്ളടക്കം നിർമ്മിക്കുകയും ചെയ്യുന്നു.
+
+[**Lucile Saulnier**](https://huggingface.co/SaulLu) Hugging Face-ൽ മെഷീൻ ലേണിംഗ് എഞ്ചിനീയറാണ്; ഓപ്പൺ സോഴ്‌സ് ടൂളുകൾ വികസിപ്പിക്കുകയും അവയുടെ ഉപയോഗത്തിന് പിന്തുണ നൽകുകയും ചെയ്യുന്നു. കൊളാബറേറ്റീവ് ട്രെയിനിംഗ്, BigScience തുടങ്ങിയ Natural Language Processing മേഖലയിലെ നിരവധി ഗവേഷണ പദ്ധതികളിലും അവർ സജീവമായി പങ്കാളിയാണ്.
+
+[**Lewis Tunstall**](https://huggingface.co/lewtun) Hugging Face-ൽ മെഷീൻ ലേണിംഗ് എഞ്ചിനീയറാണ്; ഓപ്പൺ സോഴ്‌സ് ടൂളുകൾ വികസിപ്പിക്കുന്നതിലും അവ വിശാലമായ സമൂഹത്തിന് പ്രാപ്യമാക്കുന്നതിലുമാണ് ശ്രദ്ധ. O'Reilly-യുടെ [Natural Language Processing with Transformers](https://www.oreilly.com/library/view/natural-language-processing/9781098136789/) എന്ന പുസ്‌തകത്തിന്റെ സഹരചയിതാവ് കൂടിയാണ് അദ്ദേഹം.
+
+[**Leandro von Werra**](https://huggingface.co/lvwerra) Hugging Face-ലെ ഓപ്പൺ സോഴ്‌സ് ടീമിൽ മെഷീൻ ലേണിംഗ് എഞ്ചിനീയറാണ്; O'Reilly-യുടെ [Natural Language Processing with Transformers](https://www.oreilly.com/library/view/natural-language-processing/9781098136789/) എന്ന പുസ്‌തകത്തിന്റെ സഹരചയിതാവ് കൂടിയാണ്. മെഷീൻ ലേണിംഗ് സ്‌റ്റാക്കിന്റെ എല്ലാ തലങ്ങളിലും പ്രവർത്തിച്ച് NLP പ്രോജക്‌ടുകൾ പ്രൊഡക്ഷനിൽ എത്തിച്ച നിരവധി വർഷത്തെ വ്യവസായ പരിചയം അദ്ദേഹത്തിനുണ്ട്.
+
+## പതിവുചോദ്യങ്ങൾ (FAQ)[[faq]]
+
+പതിവായി ചോദിക്കുന്ന ചില ചോദ്യങ്ങൾക്കുള്ള ഉത്തരങ്ങൾ ഇതാ:
+
+- **ഈ കോഴ്‌സ് ചെയ്താൽ സർട്ടിഫിക്കേഷൻ ലഭിക്കുമോ?**
+നിലവിൽ ഈ കോഴ്‌സിന് സർട്ടിഫിക്കേഷനൊന്നുമില്ല. എന്നാൽ Hugging Face ഇക്കോസിസ്‌റ്റത്തിനായി ഒരു സർട്ടിഫിക്കേഷൻ പ്രോഗ്രാം ഞങ്ങൾ തയ്യാറാക്കിക്കൊണ്ടിരിക്കുന്നു — കാത്തിരിക്കൂ!
+
+- **ഈ കോഴ്‌സിനായി എത്ര സമയം ചെലവഴിക്കണം?**
+ഈ കോഴ്‌സിലെ ഓരോ അധ്യായവും 1 ആഴ്‌ചയിൽ, ആഴ്‌ചയിൽ ഏകദേശം 6-8 മണിക്കൂർ ജോലിയോടെ, പൂർത്തിയാക്കാവുന്ന രീതിയിലാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. എന്നാൽ കോഴ്‌സ് പൂർത്തിയാക്കാൻ നിങ്ങൾക്ക് ആവശ്യമുള്ളത്ര സമയം എടുക്കാം.
+
+- **ഒരു ചോദ്യമുണ്ടെങ്കിൽ എവിടെ ചോദിക്കാം?**
+കോഴ്‌സിന്റെ ഏതെങ്കിലും വിഭാഗത്തെക്കുറിച്ച് ചോദ്യമുണ്ടെങ്കിൽ, പേജിന്റെ മുകളിലുള്ള "*Ask a question*" ബാനറിൽ ക്ലിക്ക് ചെയ്യുക — [Hugging Face ഫോറങ്ങളിലെ](https://discuss.huggingface.co/) ശരിയായ വിഭാഗത്തിലേക്ക് നിങ്ങൾ സ്വയമേവ എത്തിക്കപ്പെടും:
+
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/forum-button.png" alt="Hugging Face ഫോറങ്ങളിലേക്കുള്ള ലിങ്ക്" width="75%">
+
+കോഴ്‌സ് പൂർത്തിയാക്കിയശേഷം കൂടുതൽ പരിശീലിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, [പ്രോജക്‌ട് ആശയങ്ങളുടെ](https://discuss.huggingface.co/c/course/course-event/25) ഒരു പട്ടികയും ഫോറങ്ങളിൽ ലഭ്യമാണെന്ന് ശ്രദ്ധിക്കുക.
+
+- **കോഴ്‌സിന്റെ കോഡ് എവിടെ കിട്ടും?**
+ഓരോ വിഭാഗത്തിനും, പേജിന്റെ മുകളിലുള്ള ബാനറിൽ ക്ലിക്ക് ചെയ്ത് Google Colab-ലോ Amazon SageMaker Studio Lab-ലോ കോഡ് റൺ ചെയ്യാം:
+
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/notebook-buttons.png" alt="Hugging Face കോഴ്‌സ് നോട്ട്‌ബുക്കുകളിലേക്കുള്ള ലിങ്ക്" width="75%">
+
+കോഴ്‌സിലെ എല്ലാ കോഡും അടങ്ങിയ Jupyter നോട്ട്‌ബുക്കുകൾ [`huggingface/notebooks`](https://github.com/huggingface/notebooks) റിപ്പോയിൽ ഹോസ്‌റ്റ് ചെയ്തിരിക്കുന്നു. അവ ലോക്കലായി ജനറേറ്റ് ചെയ്യാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, GitHub-ലെ [`course`](https://github.com/huggingface/course#-jupyter-notebooks) റിപ്പോയിലെ നിർദ്ദേശങ്ങൾ നോക്കുക.
+
+
+- **കോഴ്‌സിലേക്ക് എനിക്ക് എങ്ങനെ സംഭാവന ചെയ്യാം?**
+കോഴ്‌സിലേക്ക് സംഭാവന ചെയ്യാൻ പല വഴികളുണ്ട്! ഒരു അക്ഷരത്തെറ്റോ ബഗ്ഗോ കണ്ടെത്തിയാൽ, [`course`](https://github.com/huggingface/course) റിപ്പോയിൽ ഒരു ഇഷ്യൂ തുറക്കുക. കോഴ്‌സ് നിങ്ങളുടെ മാതൃഭാഷയിലേക്ക് വിവർത്തനം ചെയ്യാൻ സഹായിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, [ഇവിടെയുള്ള](https://github.com/huggingface/course#translating-the-course-into-your-language) നിർദ്ദേശങ്ങൾ നോക്കുക.
+
+- ** ഓരോ വിവർത്തനത്തിലും എന്തെല്ലാം തിരഞ്ഞെടുപ്പുകളാണ് നടത്തിയത്?**
+ഓരോ വിവർത്തനത്തിനും ഒരു ഗ്ലോസറിയും, മെഷീൻ ലേണിംഗ് പദാവലി തുടങ്ങിയവയ്ക്കായി എടുത്ത തീരുമാനങ്ങൾ വിശദീകരിക്കുന്ന `TRANSLATING.txt` ഫയലും ഉണ്ട്. ജർമ്മൻ ഭാഷയ്ക്കുള്ള ഒരു ഉദാഹരണം [ഇവിടെ](https://github.com/huggingface/course/blob/main/chapters/de/TRANSLATING.txt) കാണാം.
+
+
+- **ഈ കോഴ്‌സ് എനിക്ക് പുനരുപയോഗിക്കാമോ?**
+തീർച്ചയായും! ഈ കോഴ്‌സ് ഉദാരമായ [Apache 2 ലൈസൻസിന്](https://www.apache.org/licenses/LICENSE-2.0.html) കീഴിലാണ് പുറത്തിറക്കിയിരിക്കുന്നത്. അതായത്, നിങ്ങൾ ഉചിതമായ ക്രെഡിറ്റ് നൽകണം, ലൈസൻസിലേക്ക് ഒരു ലിങ്ക് നൽകണം, മാറ്റങ്ങൾ വരുത്തിയിട്ടുണ്ടെങ്കിൽ അത് സൂചിപ്പിക്കണം. ന്യായമായ ഏത് രീതിയിലും ഇത് ചെയ്യാം, എന്നാൽ ലൈസൻസ് നൽകുന്നവർ നിങ്ങളെയോ നിങ്ങളുടെ ഉപയോഗത്തെയോ അംഗീകരിക്കുന്നു എന്ന് തോന്നിക്കുന്ന രീതിയിൽ ആകരുത്. കോഴ്‌സ് ഉദ്ധരിക്കാൻ (cite) താൽപ്പര്യമുണ്ടെങ്കിൽ, ഈ BibTeX ഉപയോഗിക്കുക:
+
+```
+@misc{huggingfacecourse,
+  author = {Hugging Face},
+  title = {The Hugging Face Course, 2022},
+  howpublished = "\url{https://huggingface.co/course}",
+  year = {2022},
+  note = "[Online; accessed <today>]"
+}
+```
+
+## ഭാഷകളും വിവർത്തനങ്ങളും[[languages-and-translations]]
+
+ഞങ്ങളുടെ അതുല്യമായ സമൂഹത്തിന് നന്ദി, ഇംഗ്ലീഷിന് പുറമേ നിരവധി ഭാഷകളിൽ ഈ കോഴ്‌സ് ലഭ്യമാണ് 🔥! ഏതെല്ലാം ഭാഷകൾ ലഭ്യമാണെന്നും വിവർത്തനങ്ങളിലേക്ക് ആരെല്ലാം സംഭാവന ചെയ്‌തുവെന്നും അറിയാൻ താഴെയുള്ള പട്ടിക നോക്കുക:
+
+| Language                                                                      | Authors                                                                                                                                                                                                                                                                                                                                                  |
+|:------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [French](https://huggingface.co/course/fr/chapter1/1)                         | [@lbourdois](https://github.com/lbourdois), [@ChainYo](https://github.com/ChainYo), [@melaniedrevet](https://github.com/melaniedrevet), [@abdouaziz](https://github.com/abdouaziz)                                                                                                                                                                       |
+| [Vietnamese](https://huggingface.co/course/vi/chapter1/1)                     | [@honghanhh](https://github.com/honghanhh)                                                                                                                                                                                                                                                                                                               |
+| [Chinese (simplified)](https://huggingface.co/course/zh-CN/chapter1/1)        | [@zhlhyx](https://github.com/zhlhyx), [petrichor1122](https://github.com/petrichor1122), [@yaoqih](https://github.com/yaoqih)                                                                                                                                                                                                                    |
+| [Bengali](https://huggingface.co/course/bn/chapter1/1) (WIP)                  | [@avishek-018](https://github.com/avishek-018), [@eNipu](https://github.com/eNipu)                                                                                                                                                                                                                                                                       |
+| [German](https://huggingface.co/course/de/chapter1/1) (WIP)                   | [@JesperDramsch](https://github.com/JesperDramsch), [@MarcusFra](https://github.com/MarcusFra), [@fabridamicelli](https://github.com/fabridamicelli)                                                                                                                                                                                                     |
+| [Spanish](https://huggingface.co/course/es/chapter1/1) (WIP)                  | [@camartinezbu](https://github.com/camartinezbu), [@munozariasjm](https://github.com/munozariasjm), [@fordaz](https://github.com/fordaz)                                                                                                                                                                                                                 |
+| [Persian](https://huggingface.co/course/fa/chapter1/1) (WIP)                  | [@jowharshamshiri](https://github.com/jowharshamshiri), [@schoobani](https://github.com/schoobani)                                                                                                                                                                                                                                                       |
+| [Gujarati](https://huggingface.co/course/gu/chapter1/1) (WIP)                 | [@pandyaved98](https://github.com/pandyaved98)                                                                                                                                                                                                                                                                                                           |
+| [Hebrew](https://huggingface.co/course/he/chapter1/1) (WIP)                   | [@omer-dor](https://github.com/omer-dor)                                                                                                                                                                                                                                                                                                                 |
+| [Hindi](https://huggingface.co/course/hi/chapter1/1) (WIP)                    | [@pandyaved98](https://github.com/pandyaved98)                                                                                                                                                                                                                                                                                                           |
+| [Bahasa Indonesia](https://huggingface.co/course/id/chapter1/1) (WIP)         | [@gstdl](https://github.com/gstdl)                                                                                                                                                                                                                                                                                                                       |
+| [Italian](https://huggingface.co/course/it/chapter1/1) (WIP)                  | [@CaterinaBi](https://github.com/CaterinaBi), [@ClonedOne](https://github.com/ClonedOne),    [@Nolanogenn](https://github.com/Nolanogenn), [@EdAbati](https://github.com/EdAbati), [@gdacciaro](https://github.com/gdacciaro)                                                                                                                            |
+| [Japanese](https://huggingface.co/course/ja/chapter1/1) (WIP)                 | [@hiromu166](https://github.com/@hiromu166), [@younesbelkada](https://github.com/@younesbelkada), [@HiromuHota](https://github.com/@HiromuHota)                                                                                                                                                                                                          |
+| [Korean](https://huggingface.co/course/ko/chapter1/1) (WIP)                   | [@Doohae](https://github.com/Doohae), [@wonhyeongseo](https://github.com/wonhyeongseo), [@dlfrnaos19](https://github.com/dlfrnaos19)                                                                                                                                                                                                                     |
+| [Portuguese](https://huggingface.co/course/pt/chapter1/1) (WIP)               | [@johnnv1](https://github.com/johnnv1), [@victorescosta](https://github.com/victorescosta), [@LincolnVS](https://github.com/LincolnVS)                                                                                                                                                                                                                   |
+| [Russian](https://huggingface.co/course/ru/chapter1/1) (WIP)                  | [@pdumin](https://github.com/pdumin), [@svv73](https://github.com/svv73)                                                                                                                                                                                                                                                                                 |
+| [Thai](https://huggingface.co/course/th/chapter1/1) (WIP)                     | [@peeraponw](https://github.com/peeraponw), [@a-krirk](https://github.com/a-krirk), [@jomariya23156](https://github.com/jomariya23156), [@ckingkan](https://github.com/ckingkan)                                                                                                                                                                         |
+| [Turkish](https://huggingface.co/course/tr/chapter1/1) (WIP)                  | [@tanersekmen](https://github.com/tanersekmen), [@mertbozkir](https://github.com/mertbozkir), [@ftarlaci](https://github.com/ftarlaci), [@akkasayaz](https://github.com/akkasayaz)                                                                                                                                                                       |
+| [Chinese (traditional)](https://huggingface.co/course/zh-TW/chapter1/1) (WIP) | [@davidpeng86](https://github.com/davidpeng86)                                                                                                                                                                                                                                                                                                           |
+| [Malayalam](https://huggingface.co/course/ml/chapter1/1) (WIP) | [@nikhilkilivayil](https://github.com/nikhilkilivayil) |
+
+ചില ഭാഷകൾക്ക്, [കോഴ്‌സിന്റെ YouTube വീഡിയോകൾക്ക്](https://youtube.com/playlist?list=PLo2EIpI_JMQvWfQndUesu0nPBAtZ9gP1o) ആ ഭാഷയിൽ സബ്‌ടൈറ്റിലുകൾ ഉണ്ട്. വീഡിയോയുടെ താഴെ വലത് മൂലയിലുള്ള _CC_ ബട്ടണിൽ ആദ്യം ക്ലിക്ക് ചെയ്ത് അവ പ്രവർത്തനക്ഷമമാക്കാം. തുടർന്ന്, സെറ്റിംഗ്‌സ് ഐക്കണിന് ⚙️ കീഴിൽ, _Subtitles/CC_ ഓപ്‌ഷൻ തിരഞ്ഞെടുത്ത് നിങ്ങൾക്ക് വേണ്ട ഭാഷ തിരഞ്ഞെടുക്കാം.
+
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/subtitles.png" alt="Hugging Face കോഴ്‌സ് YouTube വീഡിയോകൾക്ക് സബ്‌ടൈറ്റിലുകൾ പ്രവർത്തനക്ഷമമാക്കുന്നത്" width="75%">
+
+> [!TIP]
+> മുകളിലെ പട്ടികയിൽ നിങ്ങളുടെ ഭാഷ കാണുന്നില്ലേ, അല്ലെങ്കിൽ നിലവിലുള്ള ഒരു വിവർത്തനത്തിലേക്ക് സംഭാവന ചെയ്യാൻ താൽപ്പര്യമുണ്ടോ? <a href="https://github.com/huggingface/course#translating-the-course-into-your-language">ഇവിടെയുള്ള</a> നിർദ്ദേശങ്ങൾ പിന്തുടർന്ന് കോഴ്‌സ് വിവർത്തനം ചെയ്യാൻ നിങ്ങൾക്ക് ഞങ്ങളെ സഹായിക്കാം.
+
+## നമുക്ക് തുടങ്ങാം 🚀
+
+തയ്യാറാണോ? ഈ അധ്യായത്തിൽ നിങ്ങൾ പഠിക്കുന്നത്:
+
+* ടെക്‌സ്‌റ്റ് ജനറേഷൻ, ക്ലാസിഫിക്കേഷൻ പോലുള്ള NLP ടാസ്‌ക്കുകൾ പരിഹരിക്കാൻ `pipeline()` ഫംഗ്‌ഷൻ എങ്ങനെ ഉപയോഗിക്കാം
+* Transformer ആർക്കിടെക്‌ചറിനെക്കുറിച്ച്
+* എൻകോഡർ, ഡീകോഡർ, എൻകോഡർ-ഡീകോഡർ ആർക്കിടെക്‌ചറുകളും അവയുടെ ഉപയോഗങ്ങളും എങ്ങനെ വേർതിരിച്ചറിയാം
+

From 56f94e607b723fd879eaa97fd9ef8f6978ced784 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 01:34:06 +0530
Subject: [PATCH 05/44] Add Malayalam translation of chapter1/2.mdx (NLP and
 LLMs)

This document provides an overview of Natural Language Processing (NLP) and Large Language Models (LLMs), discussing their significance, capabilities, challenges, and the evolution of NLP tasks.
---
 chapters/ml/chapter1/2.mdx | 52 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 chapters/ml/chapter1/2.mdx

diff --git a/chapters/ml/chapter1/2.mdx b/chapters/ml/chapter1/2.mdx
new file mode 100644
index 000000000..5aa12ea29
--- /dev/null
+++ b/chapters/ml/chapter1/2.mdx
@@ -0,0 +1,52 @@
+# നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗും ലാർജ് ലാംഗ്വേജ് മോഡലുകളും[[natural-language-processing-and-large-language-models]]
+
+<CourseFloatingBanner
+    chapter={1}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+Transformer മോഡലുകളിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗ് (natural language processing) എന്താണ്, ലാർജ് ലാംഗ്വേജ് മോഡലുകൾ ഈ മേഖലയെ എങ്ങനെ മാറ്റിമറിച്ചു, നമ്മൾ എന്തുകൊണ്ട് ഇതിൽ ശ്രദ്ധ ചെലുത്തുന്നു എന്നിവയെക്കുറിച്ച് ഒരു ചെറിയ അവലോകനം നടത്താം.
+
+## NLP എന്താണ്?[[what-is-nlp]]
+
+<Youtube id="iNzlxWUAjd4" />
+
+മനുഷ്യഭാഷയുമായി ബന്ധപ്പെട്ട എല്ലാ കാര്യങ്ങളും മനസ്സിലാക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്ന, ഭാഷാശാസ്ത്രവും മെഷീൻ ലേണിംഗും ചേരുന്ന ഒരു മേഖലയാണ് NLP. ഓരോ വാക്കും വെവ്വേറെ മനസ്സിലാക്കുക മാത്രമല്ല, ആ വാക്കുകളുടെ സന്ദർഭം (context) മനസ്സിലാക്കാൻ കഴിയുക എന്നതാണ് NLP ടാസ്‌ക്കുകളുടെ ലക്ഷ്യം.
+
+സാധാരണ NLP ടാസ്‌ക്കുകളുടെ ഒരു പട്ടികയും ഓരോന്നിന്റെയും ചില ഉദാഹരണങ്ങളും താഴെ കൊടുക്കുന്നു:
+
+- **വാക്യങ്ങളെ മൊത്തത്തിൽ വർഗ്ഗീകരിക്കുക**: ഒരു റിവ്യൂവിന്റെ വികാരം (sentiment) കണ്ടെത്തുക, ഒരു ഇമെയിൽ സ്പാം ആണോ എന്ന് തിരിച്ചറിയുക, ഒരു വാക്യം വ്യാകരണപരമായി ശരിയാണോ എന്നോ രണ്ട് വാക്യങ്ങൾ യുക്തിപരമായി ബന്ധപ്പെട്ടിരിക്കുന്നുണ്ടോ എന്നോ നിർണ്ണയിക്കുക
+- **ഒരു വാക്യത്തിലെ ഓരോ വാക്കും വർഗ്ഗീകരിക്കുക**: ഒരു വാക്യത്തിന്റെ വ്യാകരണഘടകങ്ങൾ (നാമം, ക്രിയ, വിശേഷണം) അല്ലെങ്കിൽ നാമ-സത്തകൾ (named entities — വ്യക്തി, സ്ഥലം, സ്ഥാപനം) തിരിച്ചറിയുക
+- **ടെക്‌സ്‌റ്റ് ഉള്ളടക്കം സൃഷ്ടിക്കുക**: ഒരു പ്രോംപ്‌റ്റിനെ സ്വയമേവ സൃഷ്ടിച്ച ടെക്‌സ്‌റ്റ് കൊണ്ട് പൂർത്തിയാക്കുക, മാസ്‌ക് ചെയ്ത വാക്കുകളുള്ള ഒരു ടെക്‌സ്‌റ്റിലെ വിട്ടഭാഗങ്ങൾ പൂരിപ്പിക്കുക
+- **ഒരു ടെക്‌സ്‌റ്റിൽ നിന്ന് ഉത്തരം കണ്ടെത്തുക**: ഒരു ചോദ്യവും ഒരു സന്ദർഭവും (context) നൽകിയാൽ, സന്ദർഭത്തിൽ നൽകിയിരിക്കുന്ന വിവരങ്ങളുടെ അടിസ്ഥാനത്തിൽ ചോദ്യത്തിന്റെ ഉത്തരം കണ്ടെത്തുക
+- **ഇൻപുട്ട് ടെക്‌സ്‌റ്റിൽ നിന്ന് ഒരു പുതിയ വാക്യം സൃഷ്ടിക്കുക**: ഒരു ടെക്‌സ്‌റ്റ് മറ്റൊരു ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്യുക, ഒരു ടെക്‌സ്‌റ്റ് സംഗ്രഹിക്കുക
+
+എന്നാൽ NLP എഴുതപ്പെട്ട ടെക്‌സ്‌റ്റിൽ മാത്രം ഒതുങ്ങുന്നില്ല. ഒരു ഓഡിയോ സാമ്പിളിന്റെ ട്രാൻസ്‌ക്രിപ്‌റ്റ് തയ്യാറാക്കുക, ഒരു ചിത്രത്തിന്റെ വിവരണം സൃഷ്ടിക്കുക എന്നിങ്ങനെ സ്പീച്ച് റെക്കഗ്നിഷനിലെയും കമ്പ്യൂട്ടർ വിഷനിലെയും സങ്കീർണ്ണമായ വെല്ലുവിളികളും ഇത് കൈകാര്യം ചെയ്യുന്നു.
+
+## ലാർജ് ലാംഗ്വേജ് മോഡലുകളുടെ (LLM) ഉയർച്ച[[rise-of-llms]]
+
+സമീപ വർഷങ്ങളിൽ, ലാർജ് ലാംഗ്വേജ് മോഡലുകൾ (LLM) NLP മേഖലയിൽ ഒരു വിപ്ലവം തന്നെ സൃഷ്ടിച്ചിട്ടുണ്ട്. GPT (Generative Pre-trained Transformer), [Llama](https://huggingface.co/meta-llama) തുടങ്ങിയ ആർക്കിടെക്‌ചറുകൾ ഉൾപ്പെടുന്ന ഈ മോഡലുകൾ ഭാഷാ പ്രോസസ്സിംഗിൽ സാധ്യമായതിന്റെ അതിരുകൾ തന്നെ മാറ്റിയെഴുതി.
+
+> [!TIP]
+> ഒരു ലാർജ് ലാംഗ്വേജ് മോഡൽ (LLM) എന്നത് വളരെ വലിയ അളവിലുള്ള ടെക്‌സ്‌റ്റ് ഡേറ്റയിൽ പരിശീലിപ്പിച്ച ഒരു AI മോഡലാണ്. ഇതിന് മനുഷ്യരെപ്പോലെ ടെക്‌സ്‌റ്റ് മനസ്സിലാക്കാനും സൃഷ്ടിക്കാനും, ഭാഷയിലെ പാറ്റേണുകൾ തിരിച്ചറിയാനും, ഓരോ ടാസ്‌ക്കിനും വേണ്ടി പ്രത്യേകം പരിശീലനം നൽകാതെ തന്നെ വിവിധതരം ഭാഷാ ടാസ്‌ക്കുകൾ ചെയ്യാനും കഴിയും. നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗ് (NLP) മേഖലയിലെ ഒരു സുപ്രധാന മുന്നേറ്റമാണ് ഇവ.
+
+LLM-കളുടെ പ്രധാന സവിശേഷതകൾ ഇവയാണ്:
+- **വലിപ്പം (Scale)**: ഇവയിൽ ദശലക്ഷക്കണക്കിനോ, ശതകോടിക്കണക്കിനോ, അല്ലെങ്കിൽ നൂറുകണക്കിന് ശതകോടി പാരാമീറ്ററുകളോ ഉണ്ടാകും
+- **പൊതുവായ കഴിവുകൾ**: ഓരോ ടാസ്‌ക്കിനും വേണ്ടി പ്രത്യേകം പരിശീലനം നൽകാതെ തന്നെ ഇവയ്ക്ക് പല ടാസ്‌ക്കുകളും ചെയ്യാൻ കഴിയും
+- **ഇൻ-കോൺടെക്‌സ്‌റ്റ് ലേണിംഗ് (In-context learning)**: പ്രോംപ്‌റ്റിൽ നൽകുന്ന ഉദാഹരണങ്ങളിൽ നിന്ന് ഇവയ്ക്ക് പഠിക്കാൻ കഴിയും
+- **ഉയർന്നുവരുന്ന കഴിവുകൾ (Emergent abilities)**: ഈ മോഡലുകളുടെ വലിപ്പം കൂടുന്നതിനനുസരിച്ച്, വ്യക്തമായി പ്രോഗ്രാം ചെയ്യാത്തതോ പ്രതീക്ഷിക്കാത്തതോ ആയ കഴിവുകൾ ഇവ പ്രകടിപ്പിക്കുന്നു
+
+LLM-കളുടെ വരവോടെ, ഓരോ NLP ടാസ്‌ക്കിനും വേണ്ടി പ്രത്യേക മോഡലുകൾ നിർമ്മിക്കുന്ന രീതിയിൽ നിന്ന്, വൈവിധ്യമാർന്ന ഭാഷാ ടാസ്‌ക്കുകൾ കൈകാര്യം ചെയ്യാൻ പ്രോംപ്‌റ്റ് നൽകാനോ ഫൈൻ-ട്യൂൺ ചെയ്യാനോ കഴിയുന്ന ഒരൊറ്റ വലിയ മോഡൽ ഉപയോഗിക്കുന്ന രീതിയിലേക്ക് ചിന്താഗതി മാറി. ഇത് നൂതനമായ ഭാഷാ പ്രോസസ്സിംഗ് കൂടുതൽ ആളുകൾക്ക് പ്രാപ്യമാക്കി; അതേസമയം കാര്യക്ഷമത, നൈതികത, ഡിപ്ലോയ്‌മെന്റ് തുടങ്ങിയ മേഖലകളിൽ പുതിയ വെല്ലുവിളികളും കൊണ്ടുവന്നു. 
+
+എന്നിരുന്നാലും, LLM-കൾക്ക് ചില പ്രധാന പരിമിതികളുമുണ്ട്:
+- **ഹാലൂസിനേഷനുകൾ (Hallucinations)**: തെറ്റായ വിവരങ്ങൾ ഇവ ആത്മവിശ്വാസത്തോടെ സൃഷ്ടിച്ചേക്കാം
+- **യഥാർത്ഥ ധാരണയുടെ അഭാവം**: ലോകത്തെക്കുറിച്ച് ഇവയ്ക്ക് യഥാർത്ഥ ധാരണയില്ല; സ്ഥിതിവിവര പാറ്റേണുകളുടെ (statistical patterns) അടിസ്ഥാനത്തിൽ മാത്രമാണ് ഇവ പ്രവർത്തിക്കുന്നത്
+- **പക്ഷപാതം (Bias)**: പരിശീലന ഡേറ്റയിലോ ഇൻപുട്ടുകളിലോ ഉള്ള പക്ഷപാതങ്ങൾ ഇവ ആവർത്തിച്ചേക്കാം.
+- **കോൺടെക്‌സ്‌റ്റ് വിൻഡോകൾ**: ഇവയുടെ കോൺടെക്‌സ്‌റ്റ് വിൻഡോ പരിമിതമാണ് (ഇത് മെച്ചപ്പെട്ടുവരുന്നുണ്ടെങ്കിലും)
+- **കമ്പ്യൂട്ടേഷണൽ വിഭവങ്ങൾ**: ഇവയ്ക്ക് വലിയ അളവിൽ കമ്പ്യൂട്ടേഷണൽ വിഭവങ്ങൾ ആവശ്യമാണ്
+
+## ഭാഷാ പ്രോസസ്സിംഗ് എന്തുകൊണ്ട് വെല്ലുവിളി നിറഞ്ഞതാണ്?[[why-is-it-challenging]]
+
+കമ്പ്യൂട്ടറുകൾ മനുഷ്യരെപ്പോലെയല്ല വിവരങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നത്. ഉദാഹരണത്തിന്, "I am hungry" എന്ന വാക്യം വായിക്കുമ്പോൾ നമുക്ക് അതിന്റെ അർത്ഥം എളുപ്പത്തിൽ മനസ്സിലാകും. അതുപോലെ, "I am hungry", "I am sad" എന്നീ രണ്ട് വാക്യങ്ങൾ നൽകിയാൽ, അവ എത്രത്തോളം സമാനമാണെന്ന് നമുക്ക് എളുപ്പത്തിൽ പറയാൻ കഴിയും. എന്നാൽ മെഷീൻ ലേണിംഗ് (ML) മോഡലുകൾക്ക് ഇത്തരം ടാസ്‌ക്കുകൾ കൂടുതൽ ബുദ്ധിമുട്ടുള്ളതാണ്. മോഡലിന് അതിൽ നിന്ന് പഠിക്കാൻ കഴിയുന്ന വിധത്തിൽ ടെക്‌സ്‌റ്റ് പ്രോസസ്സ് ചെയ്യേണ്ടതുണ്ട്. ഭാഷ സങ്കീർണ്ണമായതിനാൽ, ഈ പ്രോസസ്സിംഗ് എങ്ങനെ ചെയ്യണം എന്നതിനെക്കുറിച്ച് നമ്മൾ ശ്രദ്ധാപൂർവ്വം ചിന്തിക്കേണ്ടതുണ്ട്. ടെക്‌സ്‌റ്റിനെ എങ്ങനെ പ്രതിനിധീകരിക്കാം എന്നതിനെക്കുറിച്ച് ധാരാളം ഗവേഷണങ്ങൾ നടന്നിട്ടുണ്ട്; അടുത്ത അധ്യായത്തിൽ അതിലെ ചില രീതികൾ നമ്മൾ പരിശോധിക്കും.
+
+LLM-കളിലെ പുരോഗതി ഉണ്ടായിട്ടും, അടിസ്ഥാനപരമായ പല വെല്ലുവിളികളും ഇപ്പോഴും നിലനിൽക്കുന്നു. അവ്യക്തത (ambiguity), സാംസ്‌കാരിക സന്ദർഭം, പരിഹാസം (sarcasm), നർമ്മം എന്നിവ മനസ്സിലാക്കുന്നത് ഇതിൽ ഉൾപ്പെടുന്നു. വൈവിധ്യമാർന്ന ഡേറ്റാസെറ്റുകളിൽ വൻതോതിൽ പരിശീലനം നൽകിയാണ് LLM-കൾ ഈ വെല്ലുവിളികളെ നേരിടുന്നത്; എന്നിട്ടും സങ്കീർണ്ണമായ പല സാഹചര്യങ്ങളിലും മനുഷ്യതലത്തിലുള്ള ധാരണയിലേക്ക് എത്താൻ അവയ്ക്ക് പലപ്പോഴും കഴിയാറില്ല.

From 6be2af6cceb53de31fc41aab8fafd6c5db8b6bbb Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 01:48:14 +0530
Subject: [PATCH 06/44] Add Malayalam translation of chapter1/3.mdx
 (Transformers, what can they do?)

---
 chapters/ml/chapter1/3.mdx | 390 +++++++++++++++++++++++++++++++++++++
 1 file changed, 390 insertions(+)
 create mode 100644 chapters/ml/chapter1/3.mdx

diff --git a/chapters/ml/chapter1/3.mdx b/chapters/ml/chapter1/3.mdx
new file mode 100644
index 000000000..124c63ea8
--- /dev/null
+++ b/chapters/ml/chapter1/3.mdx
@@ -0,0 +1,390 @@
+# Transformer-കൾ, അവയ്ക്ക് എന്തൊക്കെ ചെയ്യാൻ കഴിയും?[[transformers-what-can-they-do]]
+
+<CourseFloatingBanner chapter={1}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter1/section3.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter1/section3.ipynb"},
+]} />
+
+ഈ ഭാഗത്തിൽ, Transformer മോഡലുകൾക്ക് എന്തൊക്കെ ചെയ്യാൻ കഴിയുമെന്ന് നമ്മൾ നോക്കും, കൂടാതെ 🤗 Transformers ലൈബ്രറിയിലെ നമ്മുടെ ആദ്യത്തെ ടൂൾ ഉപയോഗിക്കും: `pipeline()` ഫംഗ്‌ഷൻ.
+
+> [!TIP]
+> 👀 മുകളിൽ വലതുവശത്തുള്ള <em>Open in Colab</em> ബട്ടൺ കണ്ടോ? ഈ ഭാഗത്തിലെ എല്ലാ കോഡ് ഉദാഹരണങ്ങളും അടങ്ങിയ ഒരു Google Colab നോട്ട്‌ബുക്ക് തുറക്കാൻ അതിൽ ക്ലിക്ക് ചെയ്യുക. കോഡ് ഉദാഹരണങ്ങൾ ഉള്ള ഏത് ഭാഗത്തിലും ഈ ബട്ടൺ ഉണ്ടായിരിക്കും. 
+>
+> ഉദാഹരണങ്ങൾ നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ തന്നെ (locally) റൺ ചെയ്യാൻ ആഗ്രഹിക്കുന്നെങ്കിൽ, <a href="/course/chapter0">സെറ്റപ്പ്</a> ഒന്ന് നോക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.
+
+## Transformer-കൾ എല്ലായിടത്തുമുണ്ട്![[transformers-are-everywhere]]
+
+നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗ് (NLP), കമ്പ്യൂട്ടർ വിഷൻ, ഓഡിയോ പ്രോസസ്സിംഗ് തുടങ്ങി വിവിധ മോഡാലിറ്റികളിലുള്ള എല്ലാത്തരം ടാസ്‌ക്കുകളും പരിഹരിക്കാൻ Transformer മോഡലുകൾ ഉപയോഗിക്കുന്നു. Hugging Face-ഉം Transformer മോഡലുകളും ഉപയോഗിക്കുന്ന, തങ്ങളുടെ മോഡലുകൾ പങ്കുവെച്ചുകൊണ്ട് കമ്മ്യൂണിറ്റിക്ക് തിരികെ സംഭാവന ചെയ്യുന്ന ചില കമ്പനികളും സ്ഥാപനങ്ങളും ഇവയാണ്:
+
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/companies.PNG" alt="Hugging Face ഉപയോഗിക്കുന്ന കമ്പനികൾ" width="100%">
+
+പങ്കുവെച്ചിട്ടുള്ള ഈ മോഡലുകൾ സൃഷ്ടിക്കാനും ഉപയോഗിക്കാനുമുള്ള സൗകര്യം [🤗 Transformers ലൈബ്രറി](https://github.com/huggingface/transformers) നൽകുന്നു. ആർക്കും ഡൗൺലോഡ് ചെയ്ത് ഉപയോഗിക്കാവുന്ന ദശലക്ഷക്കണക്കിന് പ്രീട്രെയിൻഡ് മോഡലുകൾ [Model Hub](https://huggingface.co/models)-ൽ ഉണ്ട്. നിങ്ങളുടെ സ്വന്തം മോഡലുകളും Hub-ലേക്ക് അപ്‌ലോഡ് ചെയ്യാം!
+
+> [!TIP]
+> ⚠️ Hugging Face Hub Transformer മോഡലുകളിൽ മാത്രം ഒതുങ്ങുന്നില്ല. ആർക്കും ഏതുതരം മോഡലുകളും ഡേറ്റാസെറ്റുകളും പങ്കുവെക്കാം! ലഭ്യമായ എല്ലാ സവിശേഷതകളും പ്രയോജനപ്പെടുത്താൻ <a href="https://huggingface.co/join">ഒരു huggingface.co അക്കൗണ്ട് ഉണ്ടാക്കുക</a>!
+
+Transformer മോഡലുകൾ അകമേ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, രസകരമായ ചില NLP പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ അവ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിന്റെ ചില ഉദാഹരണങ്ങൾ നോക്കാം.
+
+## പൈപ്പ്‌ലൈനുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു[[working-with-pipelines]]
+
+<Youtube id="tiZFewofSLM" />
+
+🤗 Transformers ലൈബ്രറിയിലെ ഏറ്റവും അടിസ്ഥാനപരമായ ഒബ്‌ജക്റ്റ് `pipeline()` ഫംഗ്‌ഷനാണ്. ഇത് ഒരു മോഡലിനെ അതിന് ആവശ്യമായ പ്രീപ്രോസസ്സിംഗ്, പോസ്‌റ്റ്‌പ്രോസസ്സിംഗ് ഘട്ടങ്ങളുമായി ബന്ധിപ്പിക്കുന്നു; അതുവഴി ഏത് ടെക്‌സ്‌റ്റും നേരിട്ട് ഇൻപുട്ടായി നൽകി മനസ്സിലാക്കാവുന്ന ഒരു ഉത്തരം നേടാൻ നമുക്ക് കഴിയും:
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("sentiment-analysis")
+classifier("I've been waiting for a HuggingFace course my whole life.")
+```
+
+```python out
+[{'label': 'POSITIVE', 'score': 0.9598047137260437}]
+```
+
+ഒന്നിലധികം വാക്യങ്ങൾ പോലും നമുക്ക് നൽകാം!
+
+```python
+classifier(
+    ["I've been waiting for a HuggingFace course my whole life.", "I hate this so much!"]
+)
+```
+
+```python out
+[{'label': 'POSITIVE', 'score': 0.9598047137260437},
+ {'label': 'NEGATIVE', 'score': 0.9994558095932007}]
+```
+
+ഡിഫോൾട്ടായി, ഇംഗ്ലീഷിലുള്ള സെന്റിമെന്റ് അനാലിസിസിനായി ഫൈൻ-ട്യൂൺ ചെയ്ത ഒരു പ്രത്യേക പ്രീട്രെയിൻഡ് മോഡലാണ് ഈ പൈപ്പ്‌ലൈൻ തിരഞ്ഞെടുക്കുന്നത്. നിങ്ങൾ `classifier` ഒബ്‌ജക്റ്റ് ഉണ്ടാക്കുമ്പോൾ മോഡൽ ഡൗൺലോഡ് ചെയ്ത് കാഷ് (cache) ചെയ്യപ്പെടുന്നു. കമാൻഡ് വീണ്ടും റൺ ചെയ്താൽ, കാഷ് ചെയ്ത മോഡൽ ഉപയോഗിക്കും; മോഡൽ വീണ്ടും ഡൗൺലോഡ് ചെയ്യേണ്ട ആവശ്യമില്ല.
+
+ഒരു പൈപ്പ്‌ലൈനിലേക്ക് ടെക്‌സ്‌റ്റ് നൽകുമ്പോൾ മൂന്ന് പ്രധാന ഘട്ടങ്ങൾ നടക്കുന്നു:
+
+1. ടെക്‌സ്‌റ്റ് മോഡലിന് മനസ്സിലാകുന്ന ഒരു ഫോർമാറ്റിലേക്ക് പ്രീപ്രോസസ്സ് ചെയ്യപ്പെടുന്നു.
+2. പ്രീപ്രോസസ്സ് ചെയ്ത ഇൻപുട്ടുകൾ മോഡലിലേക്ക് നൽകുന്നു.
+3. മോഡലിന്റെ പ്രവചനങ്ങൾ (predictions) പോസ്‌റ്റ്-പ്രോസസ്സ് ചെയ്യുന്നു, അതുവഴി നിങ്ങൾക്ക് അവ മനസ്സിലാക്കാൻ കഴിയും.
+
+## വിവിധ മോഡാലിറ്റികൾക്കായി ലഭ്യമായ പൈപ്പ്‌ലൈനുകൾ
+
+`pipeline()` ഫംഗ്‌ഷൻ ഒന്നിലധികം മോഡാലിറ്റികളെ പിന്തുണയ്ക്കുന്നു; ടെക്‌സ്‌റ്റ്, ചിത്രങ്ങൾ, ഓഡിയോ, മൾട്ടിമോഡൽ ടാസ്‌ക്കുകൾ എന്നിവയുമായി പോലും പ്രവർത്തിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഈ കോഴ്‌സിൽ നമ്മൾ ടെക്‌സ്‌റ്റ് ടാസ്‌ക്കുകളിലാണ് ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നത്, എന്നാൽ Transformer ആർക്കിടെക്‌ചറിന്റെ സാധ്യതകൾ മനസ്സിലാക്കുന്നത് പ്രയോജനകരമായതിനാൽ അതിനെക്കുറിച്ച് ഒരു ചെറിയ രൂപരേഖ നൽകാം. 
+
+ലഭ്യമായവയുടെ ഒരു അവലോകനം ഇതാ:
+
+> [!TIP]
+> പൈപ്പ്‌ലൈനുകളുടെ പൂർണ്ണവും കാലികവുമായ പട്ടികയ്ക്ക്, [🤗 Transformers ഡോക്യുമെന്റേഷൻ](https://huggingface.co/docs/hub/en/models-tasks) കാണുക.
+
+### ടെക്‌സ്‌റ്റ് പൈപ്പ്‌ലൈനുകൾ
+
+- `text-generation`: ഒരു പ്രോംപ്‌റ്റിൽ നിന്ന് ടെക്‌സ്‌റ്റ് സൃഷ്ടിക്കുക
+- `text-classification`: ടെക്‌സ്‌റ്റിനെ മുൻകൂട്ടി നിശ്ചയിച്ച വിഭാഗങ്ങളിലേക്ക് വർഗ്ഗീകരിക്കുക
+- `summarization`: പ്രധാന വിവരങ്ങൾ നിലനിർത്തിക്കൊണ്ട് ഒരു ടെക്‌സ്‌റ്റിന്റെ ചെറിയ പതിപ്പ് ഉണ്ടാക്കുക
+- `translation`: ടെക്‌സ്‌റ്റ് ഒരു ഭാഷയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് വിവർത്തനം ചെയ്യുക
+- `zero-shot-classification`: നിശ്ചിത ലേബലുകളിൽ മുൻകൂർ പരിശീലനം ഇല്ലാതെ ടെക്‌സ്‌റ്റ് വർഗ്ഗീകരിക്കുക
+- `feature-extraction`: ടെക്‌സ്‌റ്റിന്റെ വെക്‌റ്റർ പ്രതിനിധാനങ്ങൾ (vector representations) വേർതിരിച്ചെടുക്കുക
+
+### ഇമേജ് പൈപ്പ്‌ലൈനുകൾ
+
+- `image-to-text`: ചിത്രങ്ങളുടെ ടെക്‌സ്‌റ്റ് വിവരണങ്ങൾ സൃഷ്ടിക്കുക
+- `image-classification`: ഒരു ചിത്രത്തിലെ വസ്തുക്കൾ തിരിച്ചറിയുക
+- `object-detection`: ചിത്രങ്ങളിലെ വസ്തുക്കളുടെ സ്ഥാനം കണ്ടെത്തി അവയെ തിരിച്ചറിയുക
+
+### ഓഡിയോ പൈപ്പ്‌ലൈനുകൾ
+
+- `automatic-speech-recognition`: സംസാരം ടെക്‌സ്‌റ്റിലേക്ക് മാറ്റുക
+- `audio-classification`: ഓഡിയോയെ വിഭാഗങ്ങളായി വർഗ്ഗീകരിക്കുക
+- `text-to-speech`: ടെക്‌സ്‌റ്റിനെ സംസാര ഓഡിയോയിലേക്ക് മാറ്റുക
+
+### മൾട്ടിമോഡൽ പൈപ്പ്‌ലൈനുകൾ
+
+- `image-text-to-text`: ഒരു ടെക്‌സ്‌റ്റ് പ്രോംപ്‌റ്റിന്റെ അടിസ്ഥാനത്തിൽ ഒരു ചിത്രത്തോട് പ്രതികരിക്കുക
+
+ഈ പൈപ്പ്‌ലൈനുകളിൽ ചിലത് കൂടുതൽ വിശദമായി പരിശോധിക്കാം!
+
+## Zero-shot ക്ലാസിഫിക്കേഷൻ[[zero-shot-classification]]
+
+ലേബൽ ചെയ്യപ്പെടാത്ത ടെക്‌സ്‌റ്റുകൾ വർഗ്ഗീകരിക്കേണ്ടിവരുന്ന, കുറച്ചുകൂടി വെല്ലുവിളി നിറഞ്ഞ ഒരു ടാസ്‌ക്കിൽ നിന്ന് നമുക്ക് തുടങ്ങാം. ടെക്‌സ്‌റ്റ് അനോട്ടേറ്റ് ചെയ്യുന്നത് സാധാരണയായി സമയമെടുക്കുന്നതും വിഷയത്തിൽ വൈദഗ്ധ്യം ആവശ്യമുള്ളതുമായതിനാൽ, യഥാർത്ഥ പ്രോജക്റ്റുകളിൽ ഇത് സാധാരണമായി കാണുന്ന ഒരു സാഹചര്യമാണ്. ഈ ഉപയോഗത്തിന് `zero-shot-classification` പൈപ്പ്‌ലൈൻ വളരെ ശക്തമാണ്: വർഗ്ഗീകരണത്തിന് ഏതൊക്കെ ലേബലുകൾ ഉപയോഗിക്കണം എന്ന് നിങ്ങൾക്ക് തന്നെ വ്യക്തമാക്കാൻ ഇത് അനുവദിക്കുന്നു, അതിനാൽ പ്രീട്രെയിൻഡ് മോഡലിന്റെ ലേബലുകളെ ആശ്രയിക്കേണ്ടതില്ല. positive, negative എന്ന രണ്ട് ലേബലുകൾ ഉപയോഗിച്ച് മോഡൽ ഒരു വാക്യത്തെ എങ്ങനെ വർഗ്ഗീകരിക്കുന്നു എന്ന് നിങ്ങൾ ഇതിനകം കണ്ടു — എന്നാൽ നിങ്ങൾക്ക് ഇഷ്ടമുള്ള മറ്റേതൊരു ലേബൽ കൂട്ടം ഉപയോഗിച്ചും ഇതിന് ടെക്‌സ്‌റ്റ് വർഗ്ഗീകരിക്കാൻ കഴിയും.
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("zero-shot-classification")
+classifier(
+    "This is a course about the Transformers library",
+    candidate_labels=["education", "politics", "business"],
+)
+```
+
+```python out
+{'sequence': 'This is a course about the Transformers library',
+ 'labels': ['education', 'business', 'politics'],
+ 'scores': [0.8445963859558105, 0.111976258456707, 0.043427448719739914]}
+```
+
+ഈ പൈപ്പ്‌ലൈൻ ഉപയോഗിക്കാൻ നിങ്ങളുടെ ഡേറ്റയിൽ മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യേണ്ട ആവശ്യമില്ലാത്തതിനാലാണ് ഇതിനെ _zero-shot_ എന്ന് വിളിക്കുന്നത്. നിങ്ങൾക്ക് വേണ്ട ഏത് ലേബൽ പട്ടികയ്ക്കും ഇത് നേരിട്ട് പ്രോബബിലിറ്റി സ്‌കോറുകൾ നൽകും!
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** നിങ്ങളുടെ സ്വന്തം വാക്യങ്ങളും ലേബലുകളും ഉപയോഗിച്ച് പരീക്ഷിച്ചുനോക്കി മോഡൽ എങ്ങനെ പെരുമാറുന്നു എന്ന് കാണുക.
+
+
+## ടെക്‌സ്‌റ്റ് ജനറേഷൻ[[text-generation]]
+
+ഇനി ടെക്‌സ്‌റ്റ് സൃഷ്ടിക്കാൻ ഒരു പൈപ്പ്‌ലൈൻ എങ്ങനെ ഉപയോഗിക്കാം എന്ന് നോക്കാം. നിങ്ങൾ ഒരു പ്രോംപ്‌റ്റ് നൽകുന്നു, ബാക്കി ടെക്‌സ്‌റ്റ് സൃഷ്ടിച്ച് മോഡൽ അത് സ്വയം പൂർത്തിയാക്കുന്നു — ഇതാണ് ഇവിടത്തെ പ്രധാന ആശയം. പല ഫോണുകളിലും കാണുന്ന പ്രെഡിക്‌റ്റീവ് ടെക്‌സ്‌റ്റ് സവിശേഷതയോട് ഇത് സാമ്യമുള്ളതാണ്. ടെക്‌സ്‌റ്റ് ജനറേഷനിൽ റാൻഡംനെസ് ഉള്ളതിനാൽ, താഴെ കാണിച്ചിരിക്കുന്ന അതേ ഫലങ്ങൾ നിങ്ങൾക്ക് ലഭിച്ചില്ലെങ്കിൽ അത് സ്വാഭാവികമാണ്.
+
+```python
+from transformers import pipeline
+
+generator = pipeline("text-generation")
+generator("In this course, we will teach you how to")
+```
+
+```python out
+[{'generated_text': 'In this course, we will teach you how to understand and use '
+                    'data flow and data interchange when handling user data. We '
+                    'will be working with one or more of the most commonly used '
+                    'data flows — data flows of various types, as seen by the '
+                    'HTTP'}]
+```
+
+`num_return_sequences` എന്ന ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് എത്ര വ്യത്യസ്ത സീക്വൻസുകൾ സൃഷ്ടിക്കണം എന്നും, `max_length` എന്ന ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് ഔട്ട്‌പുട്ട് ടെക്‌സ്‌റ്റിന്റെ മൊത്തം നീളവും നിങ്ങൾക്ക് നിയന്ത്രിക്കാം.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** `num_return_sequences`, `max_length` എന്നീ ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് 15 വാക്കുകൾ വീതമുള്ള രണ്ട് വാക്യങ്ങൾ സൃഷ്ടിക്കുക.
+
+## Hub-ലെ ഏത് മോഡലും ഒരു പൈപ്പ്‌ലൈനിൽ ഉപയോഗിക്കുന്നു[[using-any-model-from-the-hub-in-a-pipeline]]
+
+മുൻ ഉദാഹരണങ്ങളിൽ അതത് ടാസ്‌ക്കിനുള്ള ഡിഫോൾട്ട് മോഡലാണ് ഉപയോഗിച്ചത്, എന്നാൽ ഒരു നിശ്ചിത ടാസ്‌ക്കിനായി — ഉദാഹരണത്തിന്, ടെക്‌സ്‌റ്റ് ജനറേഷൻ — പൈപ്പ്‌ലൈനിൽ ഉപയോഗിക്കാൻ Hub-ൽ നിന്ന് ഒരു പ്രത്യേക മോഡൽ തിരഞ്ഞെടുക്കാനും നിങ്ങൾക്ക് കഴിയും. [Model Hub](https://huggingface.co/models)-ലേക്ക് പോയി, ആ ടാസ്‌ക്കിനെ പിന്തുണയ്ക്കുന്ന മോഡലുകൾ മാത്രം കാണാൻ ഇടതുവശത്തുള്ള അനുബന്ധ ടാഗിൽ ക്ലിക്ക് ചെയ്യുക. [ഇതുപോലൊരു](https://huggingface.co/models?pipeline_tag=text-generation) പേജിലേക്ക് നിങ്ങൾ എത്തണം.
+
+[`HuggingFaceTB/SmolLM2-360M`](https://huggingface.co/HuggingFaceTB/SmolLM2-360M) മോഡൽ ഒന്ന് പരീക്ഷിക്കാം! മുമ്പത്തെ അതേ പൈപ്പ്‌ലൈനിൽ ഇത് എങ്ങനെ ലോഡ് ചെയ്യാം എന്ന് നോക്കുക:
+
+```python
+from transformers import pipeline
+
+generator = pipeline("text-generation", model="HuggingFaceTB/SmolLM2-360M")
+generator(
+    "In this course, we will teach you how to",
+    max_length=30,
+    num_return_sequences=2,
+)
+```
+
+```python out
+[{'generated_text': 'In this course, we will teach you how to manipulate the world and '
+                    'move your mental and physical capabilities to your advantage.'},
+ {'generated_text': 'In this course, we will teach you how to become an expert and '
+                    'practice realtime, and with a hands on experience on both real '
+                    'time and real'}]
+```
+
+ഭാഷാ ടാഗുകളിൽ ക്ലിക്ക് ചെയ്ത് നിങ്ങളുടെ മോഡൽ തിരയൽ കൂടുതൽ കൃത്യമാക്കാനും, മറ്റൊരു ഭാഷയിൽ ടെക്‌സ്‌റ്റ് സൃഷ്ടിക്കുന്ന ഒരു മോഡൽ തിരഞ്ഞെടുക്കാനും കഴിയും. ഒന്നിലധികം ഭാഷകളെ പിന്തുണയ്ക്കുന്ന ബഹുഭാഷാ (multilingual) മോഡലുകളുടെ ചെക്ക്‌പോയിന്റുകൾ പോലും Model Hub-ൽ ഉണ്ട്.
+
+ഒരു മോഡലിൽ ക്ലിക്ക് ചെയ്ത് അത് തിരഞ്ഞെടുത്താൽ, അത് നേരിട്ട് ഓൺലൈനായി പരീക്ഷിക്കാൻ കഴിയുന്ന ഒരു വിജറ്റ് നിങ്ങൾക്ക് കാണാം. ഇങ്ങനെ, മോഡൽ ഡൗൺലോഡ് ചെയ്യുന്നതിന് മുമ്പ് അതിന്റെ കഴിവുകൾ വേഗത്തിൽ പരിശോധിക്കാൻ കഴിയും.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** ഫിൽട്ടറുകൾ ഉപയോഗിച്ച് മറ്റൊരു ഭാഷയ്ക്കുള്ള ഒരു ടെക്‌സ്‌റ്റ് ജനറേഷൻ മോഡൽ കണ്ടെത്തുക. വിജറ്റ് ഉപയോഗിച്ച് പരീക്ഷിച്ചുനോക്കാനും ഒരു പൈപ്പ്‌ലൈനിൽ അത് ഉപയോഗിക്കാനും മടിക്കേണ്ട!
+
+### Inference Providers[[inference-providers]]
+
+Hugging Face [വെബ്‌സൈറ്റിൽ](https://huggingface.co/docs/inference-providers/en/index) ലഭ്യമായ Inference Providers ഉപയോഗിച്ച് എല്ലാ മോഡലുകളും നിങ്ങളുടെ ബ്രൗസറിലൂടെ നേരിട്ട് പരീക്ഷിക്കാം. ഈ പേജിൽ സ്വന്തം ടെക്‌സ്‌റ്റ് ഇൻപുട്ടായി നൽകി, മോഡൽ ആ ഇൻപുട്ട് ഡേറ്റ പ്രോസസ്സ് ചെയ്യുന്നത് കണ്ടുകൊണ്ട് നിങ്ങൾക്ക് മോഡലുമായി നേരിട്ട് പരീക്ഷണം നടത്താം.
+
+വിജറ്റിന് പിന്നിൽ പ്രവർത്തിക്കുന്ന Inference Providers ഒരു പെയ്ഡ് ഉൽപ്പന്നമായും ലഭ്യമാണ്; നിങ്ങളുടെ വർക്ക്‌ഫ്ലോകളിൽ ഇത് ആവശ്യമായി വന്നാൽ അത് ഉപകാരപ്രദമാകും. കൂടുതൽ വിവരങ്ങൾക്ക് [പ്രൈസിംഗ് പേജ്](https://huggingface.co/docs/inference-providers/en/pricing) കാണുക.
+
+## മാസ്‌ക് പൂരിപ്പിക്കൽ (Mask filling)[[mask-filling]]
+
+നിങ്ങൾ അടുത്തതായി പരീക്ഷിക്കുന്ന പൈപ്പ്‌ലൈൻ `fill-mask` ആണ്. നൽകിയ ഒരു ടെക്‌സ്‌റ്റിലെ വിട്ടഭാഗങ്ങൾ പൂരിപ്പിക്കുക എന്നതാണ് ഈ ടാസ്‌ക്കിന്റെ ആശയം:
+
+```python
+from transformers import pipeline
+
+unmasker = pipeline("fill-mask")
+unmasker("This course will teach you all about <mask> models.", top_k=2)
+```
+
+```python out
+[{'sequence': 'This course will teach you all about mathematical models.',
+  'score': 0.19619831442832947,
+  'token': 30412,
+  'token_str': ' mathematical'},
+ {'sequence': 'This course will teach you all about computational models.',
+  'score': 0.04052725434303284,
+  'token': 38163,
+  'token_str': ' computational'}]
+```
+
+എത്ര സാധ്യതകൾ പ്രദർശിപ്പിക്കണം എന്ന് `top_k` ആർഗ്യുമെന്റ് നിയന്ത്രിക്കുന്നു. ഇവിടെ മോഡൽ പൂരിപ്പിക്കുന്നത് `<mask>` എന്ന പ്രത്യേക വാക്കാണ് എന്നത് ശ്രദ്ധിക്കുക; ഇതിനെ പലപ്പോഴും *മാസ്‌ക് ടോക്കൺ* (mask token) എന്ന് വിളിക്കുന്നു. മറ്റ് മാസ്‌ക്-ഫില്ലിംഗ് മോഡലുകൾക്ക് വ്യത്യസ്ത മാസ്‌ക് ടോക്കണുകൾ ഉണ്ടാകാം, അതിനാൽ മറ്റ് മോഡലുകൾ പരിശോധിക്കുമ്പോൾ ശരിയായ മാസ്‌ക് വാക്ക് ഉറപ്പുവരുത്തുന്നത് എപ്പോഴും നല്ലതാണ്. വിജറ്റിൽ ഉപയോഗിച്ചിരിക്കുന്ന മാസ്‌ക് വാക്ക് നോക്കുന്നതാണ് ഇത് പരിശോധിക്കാനുള്ള ഒരു വഴി.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** Hub-ൽ `bert-base-cased` മോഡൽ തിരഞ്ഞ്, Inference API വിജറ്റിൽ അതിന്റെ മാസ്‌ക് വാക്ക് കണ്ടെത്തുക. മുകളിലെ നമ്മുടെ `pipeline` ഉദാഹരണത്തിലെ വാക്യത്തിന് ഈ മോഡൽ എന്ത് പ്രവചിക്കുന്നു?
+
+## നാമ-സത്ത തിരിച്ചറിയൽ (Named entity recognition)[[named-entity-recognition]]
+
+നാമ-സത്ത തിരിച്ചറിയൽ (NER) എന്നത്, ഇൻപുട്ട് ടെക്‌സ്‌റ്റിന്റെ ഏതൊക്കെ ഭാഗങ്ങൾ വ്യക്തികൾ, സ്ഥലങ്ങൾ, സ്ഥാപനങ്ങൾ തുടങ്ങിയ എന്റിറ്റികളെ സൂചിപ്പിക്കുന്നു എന്ന് മോഡൽ കണ്ടെത്തേണ്ട ഒരു ടാസ്‌ക്കാണ്. ഒരു ഉദാഹരണം നോക്കാം:
+
+```python
+from transformers import pipeline
+
+ner = pipeline("ner", aggregation_strategy="simple")
+ner("My name is Sylvain and I work at Hugging Face in Brooklyn.")
+```
+
+```python out
+[{'entity_group': 'PER', 'score': 0.99816, 'word': 'Sylvain', 'start': 11, 'end': 18}, 
+ {'entity_group': 'ORG', 'score': 0.97960, 'word': 'Hugging Face', 'start': 33, 'end': 45}, 
+ {'entity_group': 'LOC', 'score': 0.99321, 'word': 'Brooklyn', 'start': 49, 'end': 57}
+]
+```
+
+ഇവിടെ Sylvain ഒരു വ്യക്തിയാണെന്നും (PER), Hugging Face ഒരു സ്ഥാപനമാണെന്നും (ORG), Brooklyn ഒരു സ്ഥലമാണെന്നും (LOC) മോഡൽ കൃത്യമായി തിരിച്ചറിഞ്ഞു.
+
+ഒരേ എന്റിറ്റിയെ സൂചിപ്പിക്കുന്ന വാക്യഭാഗങ്ങളെ ഒരുമിച്ച് കൂട്ടിച്ചേർക്കാൻ പൈപ്പ്‌ലൈനിനോട് പറയാനാണ് പൈപ്പ്‌ലൈൻ ഉണ്ടാക്കുന്ന ഫംഗ്‌ഷനിൽ `aggregation_strategy="simple"` എന്ന ഓപ്‌ഷൻ നമ്മൾ നൽകുന്നത്: ഇവിടെ, പേരിൽ ഒന്നിലധികം വാക്കുകൾ ഉണ്ടെങ്കിലും, "Hugging", "Face" എന്നിവയെ ഒരൊറ്റ സ്ഥാപനമായി മോഡൽ കൃത്യമായി കൂട്ടിച്ചേർത്തു. വാസ്തവത്തിൽ, അടുത്ത അധ്യായത്തിൽ നമ്മൾ കാണുന്നതുപോലെ, പ്രീപ്രോസസ്സിംഗ് ചില വാക്കുകളെ കൂടുതൽ ചെറിയ ഭാഗങ്ങളായി പോലും വിഭജിക്കുന്നു. ഉദാഹരണത്തിന്, `Sylvain` എന്നത് നാല് ഭാഗങ്ങളായി വിഭജിക്കപ്പെടുന്നു: `S`, `##yl`, `##va`, `##in`. പോസ്‌റ്റ്-പ്രോസസ്സിംഗ് ഘട്ടത്തിൽ, പൈപ്പ്‌ലൈൻ ആ ഭാഗങ്ങളെ വിജയകരമായി വീണ്ടും കൂട്ടിച്ചേർത്തു.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** ഇംഗ്ലീഷിൽ part-of-speech ടാഗിംഗ് (സാധാരണയായി POS എന്ന് ചുരുക്കി വിളിക്കുന്നു) ചെയ്യാൻ കഴിയുന്ന ഒരു മോഡൽ Model Hub-ൽ തിരയുക. മുകളിലെ ഉദാഹരണത്തിലെ വാക്യത്തിന് ഈ മോഡൽ എന്ത് പ്രവചിക്കുന്നു?
+
+## ചോദ്യോത്തരം (Question answering)[[question-answering]]
+
+`question-answering` പൈപ്പ്‌ലൈൻ, നൽകിയ ഒരു സന്ദർഭത്തിലെ (context) വിവരങ്ങൾ ഉപയോഗിച്ച് ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുന്നു:
+
+```python
+from transformers import pipeline
+
+question_answerer = pipeline("question-answering")
+question_answerer(
+    question="Where do I work?",
+    context="My name is Sylvain and I work at Hugging Face in Brooklyn",
+)
+```
+
+```python out
+{'score': 0.6385916471481323, 'start': 33, 'end': 45, 'answer': 'Hugging Face'}
+```
+
+നൽകിയ സന്ദർഭത്തിൽ നിന്ന് വിവരങ്ങൾ വേർതിരിച്ചെടുത്താണ് ഈ പൈപ്പ്‌ലൈൻ പ്രവർത്തിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കുക; ഇത് ഉത്തരം സൃഷ്ടിക്കുന്നില്ല.
+
+## സംഗ്രഹം (Summarization)[[summarization]]
+
+ഒരു ടെക്‌സ്‌റ്റിൽ പരാമർശിക്കുന്ന പ്രധാന കാര്യങ്ങൾ എല്ലാം (അല്ലെങ്കിൽ മിക്കതും) നിലനിർത്തിക്കൊണ്ട് അതിനെ ഒരു ചെറിയ ടെക്‌സ്‌റ്റായി ചുരുക്കുന്ന ടാസ്‌ക്കാണ് സംഗ്രഹം. ഒരു ഉദാഹരണം ഇതാ:
+
+```python
+from transformers import pipeline
+
+summarizer = pipeline("summarization")
+summarizer(
+    """
+    America has changed dramatically during recent years. Not only has the number of 
+    graduates in traditional engineering disciplines such as mechanical, civil, 
+    electrical, chemical, and aeronautical engineering declined, but in most of 
+    the premier American universities engineering curricula now concentrate on 
+    and encourage largely the study of engineering science. As a result, there 
+    are declining offerings in engineering subjects dealing with infrastructure, 
+    the environment, and related issues, and greater concentration on high 
+    technology subjects, largely supporting increasingly complex scientific 
+    developments. While the latter is important, it should not be at the expense 
+    of more traditional engineering.
+
+    Rapidly developing economies such as China and India, as well as other 
+    industrial countries in Europe and Asia, continue to encourage and advance 
+    the teaching of engineering. Both China and India, respectively, graduate 
+    six and eight times as many traditional engineers as does the United States. 
+    Other industrial countries at minimum maintain their output, while America 
+    suffers an increasingly serious decline in the number of engineering graduates 
+    and a lack of well-educated engineers.
+"""
+)
+```
+
+```python out
+[{'summary_text': ' America has changed dramatically during recent years . The '
+                  'number of engineering graduates in the U.S. has declined in '
+                  'traditional engineering disciplines such as mechanical, civil '
+                  ', electrical, chemical, and aeronautical engineering . Rapidly '
+                  'developing economies such as China and India, as well as other '
+                  'industrial countries in Europe and Asia, continue to encourage '
+                  'and advance engineering .'}]
+```
+
+ടെക്‌സ്‌റ്റ് ജനറേഷനിലേതുപോലെ, ഫലത്തിന് ഒരു `max_length` അല്ലെങ്കിൽ `min_length` നിങ്ങൾക്ക് വ്യക്തമാക്കാം.
+
+
+## വിവർത്തനം (Translation)[[translation]]
+
+വിവർത്തനത്തിന്, ടാസ്‌ക്കിന്റെ പേരിൽ ഒരു ഭാഷാ ജോഡി നൽകിയാൽ (ഉദാഹരണത്തിന് `"translation_en_to_fr"`) ഒരു ഡിഫോൾട്ട് മോഡൽ ഉപയോഗിക്കാം, എന്നാൽ ഏറ്റവും എളുപ്പമുള്ള വഴി [Model Hub](https://huggingface.co/models)-ൽ നിന്ന് നിങ്ങൾക്ക് ഉപയോഗിക്കേണ്ട മോഡൽ തിരഞ്ഞെടുക്കുന്നതാണ്. ഇവിടെ ഫ്രഞ്ചിൽ നിന്ന് ഇംഗ്ലീഷിലേക്ക് വിവർത്തനം ചെയ്യാൻ ശ്രമിക്കാം:
+
+```python
+from transformers import pipeline
+
+translator = pipeline("translation", model="Helsinki-NLP/opus-mt-fr-en")
+translator("Ce cours est produit par Hugging Face.")
+```
+
+```python out
+[{'translation_text': 'This course is produced by Hugging Face.'}]
+```
+
+ടെക്‌സ്‌റ്റ് ജനറേഷനിലേയും സംഗ്രഹത്തിലേയും പോലെ, ഫലത്തിന് ഒരു `max_length` അല്ലെങ്കിൽ `min_length` നിങ്ങൾക്ക് വ്യക്തമാക്കാം.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** മറ്റ് ഭാഷകളിലുള്ള വിവർത്തന മോഡലുകൾ തിരഞ്ഞ്, മുമ്പത്തെ വാക്യം കുറച്ച് വ്യത്യസ്ത ഭാഷകളിലേക്ക് വിവർത്തനം ചെയ്യാൻ ശ്രമിക്കുക.
+
+## ഇമേജ്, ഓഡിയോ പൈപ്പ്‌ലൈനുകൾ
+
+ടെക്‌സ്‌റ്റിനപ്പുറം, Transformer മോഡലുകൾക്ക് ചിത്രങ്ങളും ഓഡിയോയും കൈകാര്യം ചെയ്യാനും കഴിയും. ചില ഉദാഹരണങ്ങൾ ഇതാ:
+
+### ഇമേജ് ക്ലാസിഫിക്കേഷൻ
+
+```python
+from transformers import pipeline
+
+image_classifier = pipeline(
+    task="image-classification", model="google/vit-base-patch16-224"
+)
+result = image_classifier(
+    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
+)
+print(result)
+```
+
+```python out
+[{'label': 'lynx, catamount', 'score': 0.43350091576576233},
+ {'label': 'cougar, puma, catamount, mountain lion, painter, panther, Felis concolor',
+  'score': 0.034796204417943954},
+ {'label': 'snow leopard, ounce, Panthera uncia',
+  'score': 0.03240183740854263},
+ {'label': 'Egyptian cat', 'score': 0.02394474856555462},
+ {'label': 'tiger cat', 'score': 0.02288915030658245}]
+```
+
+### ഓട്ടോമാറ്റിക് സ്പീച്ച് റെക്കഗ്നിഷൻ
+
+```python
+from transformers import pipeline
+
+transcriber = pipeline(
+    task="automatic-speech-recognition", model="openai/whisper-large-v3"
+)
+result = transcriber(
+    "https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac"
+)
+print(result)
+```
+
+```python out
+{'text': ' I have a dream that one day this nation will rise up and live out the true meaning of its creed.'}
+```
+
+## ഒന്നിലധികം സ്രോതസ്സുകളിൽ നിന്നുള്ള ഡേറ്റ സംയോജിപ്പിക്കുന്നു
+
+ഒന്നിലധികം സ്രോതസ്സുകളിൽ നിന്നുള്ള ഡേറ്റ സംയോജിപ്പിക്കാനും പ്രോസസ്സ് ചെയ്യാനുമുള്ള കഴിവാണ് Transformer മോഡലുകളുടെ ശക്തമായ ഒരു പ്രയോഗം. താഴെ പറയുന്ന സാഹചര്യങ്ങളിൽ ഇത് പ്രത്യേകിച്ചും ഉപകാരപ്രദമാണ്:
+
+1. ഒന്നിലധികം ഡേറ്റാബേസുകളിലോ റിപ്പോസിറ്ററികളിലോ തിരയേണ്ടിവരുമ്പോൾ
+2. വ്യത്യസ്ത ഫോർമാറ്റുകളിലുള്ള (ടെക്‌സ്‌റ്റ്, ചിത്രങ്ങൾ, ഓഡിയോ) വിവരങ്ങൾ ഒരുമിപ്പിക്കേണ്ടിവരുമ്പോൾ
+3. പരസ്പരബന്ധിതമായ വിവരങ്ങളുടെ ഒരു ഏകീകൃത കാഴ്ച ഉണ്ടാക്കേണ്ടിവരുമ്പോൾ
+
+ഉദാഹരണത്തിന്, താഴെ പറയുന്നവ ചെയ്യുന്ന ഒരു സിസ്റ്റം നിങ്ങൾക്ക് നിർമ്മിക്കാം:
+- ടെക്‌സ്‌റ്റ്, ഇമേജ് തുടങ്ങിയ ഒന്നിലധികം മോഡാലിറ്റികളിലുള്ള ഡേറ്റാബേസുകളിൽ വിവരങ്ങൾ തിരയുന്നു.
+- വ്യത്യസ്ത സ്രോതസ്സുകളിൽ നിന്നുള്ള ഫലങ്ങൾ ഒരൊറ്റ യോജിച്ച പ്രതികരണമായി സംയോജിപ്പിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു ഓഡിയോ ഫയലിൽ നിന്നും ഒരു ടെക്‌സ്‌റ്റ് വിവരണത്തിൽ നിന്നും.
+- ഡോക്യുമെന്റുകളുടെയും മെറ്റാഡേറ്റയുടെയും ഒരു ഡേറ്റാബേസിൽ നിന്ന് ഏറ്റവും പ്രസക്തമായ വിവരങ്ങൾ അവതരിപ്പിക്കുന്നു.
+
+## ഉപസംഹാരം
+
+ഈ അധ്യായത്തിൽ കാണിച്ച പൈപ്പ്‌ലൈനുകൾ പ്രധാനമായും പ്രദർശന ആവശ്യങ്ങൾക്കുള്ളതാണ്. അവ നിശ്ചിത ടാസ്‌ക്കുകൾക്കായി പ്രോഗ്രാം ചെയ്തവയാണ്, അവയുടെ വ്യതിയാനങ്ങൾ ചെയ്യാൻ അവയ്ക്ക് കഴിയില്ല. അടുത്ത അധ്യായത്തിൽ, ഒരു `pipeline()` ഫംഗ്‌ഷന്റെ ഉള്ളിൽ എന്താണുള്ളതെന്നും അതിന്റെ പ്രവർത്തനം എങ്ങനെ ഇഷ്ടാനുസൃതമാക്കാമെന്നും നിങ്ങൾ പഠിക്കും.

From f74f65b38b77c753ec6a1a9ddfe2f15e70e39757 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 02:17:27 +0530
Subject: [PATCH 07/44] Add Malayalam translation of chapter1/4.mdx (How do
 Transformers work?)

---
 chapters/ml/chapter1/4.mdx | 189 +++++++++++++++++++++++++++++++++++++
 1 file changed, 189 insertions(+)
 create mode 100644 chapters/ml/chapter1/4.mdx

diff --git a/chapters/ml/chapter1/4.mdx b/chapters/ml/chapter1/4.mdx
new file mode 100644
index 000000000..4d0d0fdd5
--- /dev/null
+++ b/chapters/ml/chapter1/4.mdx
@@ -0,0 +1,189 @@
+# Transformer-കൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു?[[how-do-transformers-work]]
+
+<CourseFloatingBanner
+    chapter={1}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+ഈ ഭാഗത്ത്, Transformer മോഡലുകളുടെ ആർക്കിടെക്ചർ നാം പരിശോധിക്കുകയും അറ്റൻഷൻ (attention), എൻകോഡർ-ഡീകോഡർ ആർക്കിടെക്ചർ തുടങ്ങിയ ആശയങ്ങളിലേക്ക് കൂടുതൽ ആഴത്തിൽ ഇറങ്ങുകയും ചെയ്യും.
+
+> [!WARNING]
+> 🚀 ഇവിടെ നാം കാര്യങ്ങൾ ഒരു പടി മുന്നോട്ട് കൊണ്ടുപോകുന്നു. ഈ ഭാഗം വിശദവും സാങ്കേതികവുമാണ്, അതിനാൽ എല്ലാം ഉടനടി മനസ്സിലായില്ലെങ്കിൽ വിഷമിക്കേണ്ട. കോഴ്‌സിൽ പിന്നീട് ഈ ആശയങ്ങളിലേക്ക് നാം തിരിച്ചുവരും.
+
+## Transformer-ന്റെ ചരിത്രത്തിൽ നിന്ന് അൽപ്പം[[a-bit-of-transformer-history]]
+
+Transformer മോഡലുകളുടെ (ഹ്രസ്വമായ) ചരിത്രത്തിലെ ചില നാഴികക്കല്ലുകൾ ഇതാ:
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/transformers_chrono.svg" alt="Transformer മോഡലുകളുടെ ഒരു ഹ്രസ്വ കാലരേഖ.">
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/transformers_chrono-dark.svg" alt="Transformer മോഡലുകളുടെ ഒരു ഹ്രസ്വ കാലരേഖ.">
+</div>
+
+[Transformer ആർക്കിടെക്ചർ](https://arxiv.org/abs/1706.03762) 2017 ജൂണിൽ അവതരിപ്പിക്കപ്പെട്ടു. മൂല ഗവേഷണത്തിന്റെ ശ്രദ്ധ വിവർത്തന ടാസ്‌ക്കുകളിലായിരുന്നു. ഇതിനെ തുടർന്ന് സ്വാധീനശക്തിയുള്ള നിരവധി മോഡലുകൾ അവതരിപ്പിക്കപ്പെട്ടു, അവയിൽ ചിലത്:
+
+- **2018 ജൂൺ**: [GPT](https://cdn.openai.com/research-covers/language-unsupervised/language_understanding_paper.pdf), ആദ്യത്തെ പ്രീട്രെയിൻ ചെയ്ത Transformer മോഡൽ; വിവിധ NLP ടാസ്‌ക്കുകളിൽ ഫൈൻ-ട്യൂണിംഗിനായി ഉപയോഗിക്കുകയും അത്യാധുനിക (state-of-the-art) ഫലങ്ങൾ നേടുകയും ചെയ്തു
+
+- **2018 ഒക്‌ടോബർ**: [BERT](https://arxiv.org/abs/1810.04805), മറ്റൊരു വലിയ പ്രീട്രെയിൻ ചെയ്ത മോഡൽ; വാക്യങ്ങളുടെ മികച്ച സംഗ്രഹങ്ങൾ ഉണ്ടാക്കാൻ രൂപകൽപ്പന ചെയ്തത് (ഇതേക്കുറിച്ച് കൂടുതൽ അടുത്ത അധ്യായത്തിൽ!)
+
+- **2019 ഫെബ്രുവരി**: [GPT-2](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf), GPT-യുടെ മെച്ചപ്പെടുത്തിയ (കൂടുതൽ വലിയ) പതിപ്പ്; ധാർമ്മിക ആശങ്കകൾ കാരണം ഉടനടി പൊതുജനങ്ങൾക്ക് ലഭ്യമാക്കിയിരുന്നില്ല
+
+- **2019 ഒക്‌ടോബർ**: [T5](https://huggingface.co/papers/1910.10683), sequence-to-sequence Transformer ആർക്കിടെക്ചറിന്റെ മൾട്ടി-ടാസ്‌ക് കേന്ദ്രീകൃതമായ ഒരു ഇംപ്ലിമെന്റേഷൻ.
+
+- **2020 മെയ്**, [GPT-3](https://huggingface.co/papers/2005.14165), GPT-2-ന്റെ അതിലും വലിയ പതിപ്പ്; ഫൈൻ-ട്യൂണിംഗിന്റെ ആവശ്യമില്ലാതെ തന്നെ വിവിധ ടാസ്‌ക്കുകളിൽ നന്നായി പ്രവർത്തിക്കാൻ കഴിവുള്ളത് (_zero-shot learning_ എന്ന് വിളിക്കുന്നു)
+
+- **2022 ജനുവരി**: [InstructGPT](https://huggingface.co/papers/2203.02155), നിർദ്ദേശങ്ങൾ (instructions) കൂടുതൽ നന്നായി പിന്തുടരാൻ പരിശീലിപ്പിച്ച GPT-3-ന്റെ ഒരു പതിപ്പ്.
+
+- **2023 ജനുവരി**: [Llama](https://huggingface.co/papers/2302.13971), വിവിധ ഭാഷകളിൽ ടെക്‌സ്‌റ്റ് ജനറേറ്റ് ചെയ്യാൻ കഴിവുള്ള ഒരു വലിയ ഭാഷാ മോഡൽ (large language model).
+
+- **2023 മാർച്ച്**: [Mistral](https://huggingface.co/papers/2310.06825), 7 ബില്യൺ പാരാമീറ്ററുകളുള്ള ഒരു ഭാഷാ മോഡൽ; വിലയിരുത്തിയ എല്ലാ ബെഞ്ച്‌മാർക്കുകളിലും Llama 2 13B-യെ മറികടക്കുന്നു. വേഗത്തിലുള്ള ഇൻഫറൻസിനായി grouped-query attention-ഉം ഏത് നീളത്തിലുള്ള സീക്വൻസുകളും കൈകാര്യം ചെയ്യാൻ sliding window attention-ഉം ഇത് ഉപയോഗിക്കുന്നു.
+
+- **2024 മെയ്**: [Gemma 2](https://huggingface.co/papers/2408.00118), 2B മുതൽ 27B വരെ പാരാമീറ്ററുകളുള്ള, ഭാരം കുറഞ്ഞ, അത്യാധുനിക ഓപ്പൺ മോഡലുകളുടെ ഒരു കുടുംബം. ഇവ interleaved local-global attention-ഉം group-query attention-ഉം ഉൾക്കൊള്ളുന്നു; ചെറിയ മോഡലുകൾ knowledge distillation ഉപയോഗിച്ച് പരിശീലിപ്പിച്ചതിനാൽ 2-3 മടങ്ങ് വലിയ മോഡലുകളോട് കിടപിടിക്കുന്ന പ്രകടനം നൽകുന്നു.
+
+- **2024 നവംബർ**: [SmolLM2](https://huggingface.co/papers/2502.02737), അത്യാധുനികമായ ഒരു ചെറിയ ഭാഷാ മോഡൽ (135 ദശലക്ഷം മുതൽ 1.7 ബില്യൺ വരെ പാരാമീറ്ററുകൾ); ചെറിയ വലിപ്പമായിട്ടും ശ്രദ്ധേയമായ പ്രകടനം കാഴ്ചവയ്ക്കുകയും മൊബൈൽ, എഡ്ജ് ഉപകരണങ്ങൾക്ക് പുതിയ സാധ്യതകൾ തുറന്നുകൊടുക്കുകയും ചെയ്യുന്നു.
+
+ഈ പട്ടിക ഒരിക്കലും സമ്പൂർണ്ണമല്ല; വിവിധ തരം Transformer മോഡലുകളിൽ ചിലതിനെ എടുത്തുകാണിക്കാൻ മാത്രമാണ് ഇത് ഉദ്ദേശിച്ചിട്ടുള്ളത്. വിശാലമായി പറഞ്ഞാൽ, ഇവയെ മൂന്ന് വിഭാഗങ്ങളായി തിരിക്കാം:
+
+- GPT-സമാനമായവ (_auto-regressive_ Transformer മോഡലുകൾ എന്നും വിളിക്കുന്നു)
+- BERT-സമാനമായവ (_auto-encoding_ Transformer മോഡലുകൾ എന്നും വിളിക്കുന്നു) 
+- T5-സമാനമായവ (_sequence-to-sequence_ Transformer മോഡലുകൾ എന്നും വിളിക്കുന്നു)
+
+ഈ കുടുംബങ്ങളെക്കുറിച്ച് പിന്നീട് നാം കൂടുതൽ ആഴത്തിൽ പഠിക്കും.
+
+## Transformer-കൾ ഭാഷാ മോഡലുകളാണ്[[transformers-are-language-models]]
+
+മുകളിൽ പറഞ്ഞ എല്ലാ Transformer മോഡലുകളും (GPT, BERT, T5 മുതലായവ) *ഭാഷാ മോഡലുകൾ* (language models) ആയാണ് പരിശീലിപ്പിച്ചിട്ടുള്ളത്. അതായത്, വലിയ അളവിലുള്ള അസംസ്‌കൃത ടെക്‌സ്‌റ്റിൽ self-supervised രീതിയിലാണ് ഇവയെ പരിശീലിപ്പിച്ചിട്ടുള്ളത്. 
+
+Self-supervised learning എന്നത് മോഡലിന്റെ ഇൻപുട്ടുകളിൽ നിന്ന് തന്നെ പരിശീലന ലക്ഷ്യം (objective) സ്വയമേവ കണക്കാക്കപ്പെടുന്ന ഒരു തരം പരിശീലനമാണ്. അതിനർത്ഥം ഡേറ്റ ലേബൽ ചെയ്യാൻ മനുഷ്യരുടെ ആവശ്യമില്ല എന്നാണ്!
+
+ഇത്തരം മോഡലുകൾ അവയെ പരിശീലിപ്പിച്ച ഭാഷയെക്കുറിച്ച് ഒരു സ്ഥിതിവിവരപരമായ (statistical) ധാരണ വികസിപ്പിക്കുന്നു, എന്നാൽ നിർദ്ദിഷ്ട പ്രായോഗിക ടാസ്‌ക്കുകൾക്ക് ഇവ അത്ര ഉപയോഗപ്രദമല്ല. ഇക്കാരണത്താൽ, പൊതുവായ പ്രീട്രെയിൻ ചെയ്ത മോഡൽ പിന്നീട് *transfer learning* അഥവാ *ഫൈൻ-ട്യൂണിംഗ്* എന്ന ഒരു പ്രക്രിയയിലൂടെ കടന്നുപോകുന്നു. ഈ പ്രക്രിയയിൽ, ഒരു നിശ്ചിത ടാസ്‌ക്കിനായി supervised രീതിയിൽ -- അതായത്, മനുഷ്യർ നൽകിയ ലേബലുകൾ ഉപയോഗിച്ച് -- മോഡലിനെ ഫൈൻ-ട്യൂൻ ചെയ്യുന്നു.
+
+ഒരു ടാസ്‌ക്കിന്റെ ഉദാഹരണമാണ് മുൻപുള്ള *n* വാക്കുകൾ വായിച്ചതിനുശേഷം ഒരു വാക്യത്തിലെ അടുത്ത വാക്ക് പ്രവചിക്കുന്നത്. ഔട്ട്‌പുട്ട് ഭൂതകാല, വർത്തമാനകാല ഇൻപുട്ടുകളെ ആശ്രയിക്കുകയും ഭാവിയിലുള്ളവയെ ആശ്രയിക്കാതിരിക്കുകയും ചെയ്യുന്നതിനാൽ ഇതിനെ *causal language modeling* എന്ന് വിളിക്കുന്നു.
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/causal_modeling.svg" alt="ഒരു വാക്യത്തിലെ അടുത്ത വാക്ക് പ്രവചിക്കുന്ന causal language modeling-ന്റെ ഉദാഹരണം.">
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/causal_modeling-dark.svg" alt="ഒരു വാക്യത്തിലെ അടുത്ത വാക്ക് പ്രവചിക്കുന്ന causal language modeling-ന്റെ ഉദാഹരണം.">
+</div>
+
+മറ്റൊരു ഉദാഹരണം *masked language modeling* ആണ്; ഇതിൽ വാക്യത്തിലെ മാസ്‌ക് ചെയ്ത ഒരു വാക്ക് മോഡൽ പ്രവചിക്കുന്നു.
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/masked_modeling.svg" alt="ഒരു വാക്യത്തിലെ മാസ്‌ക് ചെയ്ത വാക്ക് പ്രവചിക്കുന്ന masked language modeling-ന്റെ ഉദാഹരണം.">
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/masked_modeling-dark.svg" alt="ഒരു വാക്യത്തിലെ മാസ്‌ക് ചെയ്ത വാക്ക് പ്രവചിക്കുന്ന masked language modeling-ന്റെ ഉദാഹരണം.">
+</div>
+
+## Transformer-കൾ വലിയ മോഡലുകളാണ്[[transformers-are-big-models]]
+
+ചില അപവാദങ്ങൾ (DistilBERT പോലുള്ളവ) ഒഴിച്ചാൽ, മികച്ച പ്രകടനം നേടാനുള്ള പൊതുവായ തന്ത്രം മോഡലുകളുടെ വലിപ്പവും അവയെ പ്രീട്രെയിൻ ചെയ്യുന്ന ഡേറ്റയുടെ അളവും വർദ്ധിപ്പിക്കുക എന്നതാണ്.
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/model_parameters.png" alt="സമീപകാല Transformer മോഡലുകളുടെ പാരാമീറ്ററുകളുടെ എണ്ണം" width="90%">
+</div>
+
+നിർഭാഗ്യവശാൽ, ഒരു മോഡൽ പരിശീലിപ്പിക്കാൻ, പ്രത്യേകിച്ച് വലിയ ഒന്ന്, വലിയ അളവിൽ ഡേറ്റ ആവശ്യമാണ്. സമയത്തിന്റെയും കമ്പ്യൂട്ട് വിഭവങ്ങളുടെയും കാര്യത്തിൽ ഇത് വളരെ ചെലവേറിയതായി മാറുന്നു. താഴെയുള്ള ഗ്രാഫിൽ കാണാവുന്നതുപോലെ, ഇത് പരിസ്ഥിതിയെ ബാധിക്കുന്നതിലേക്കും നയിക്കുന്നു.
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/carbon_footprint.svg" alt="ഒരു വലിയ ഭാഷാ മോഡലിന്റെ കാർബൺ കാൽപ്പാട്.">
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/carbon_footprint-dark.svg" alt="ഒരു വലിയ ഭാഷാ മോഡലിന്റെ കാർബൺ കാൽപ്പാട്.">
+</div>
+
+<Youtube id="ftWlj4FBHTg"/>
+
+പ്രീട്രെയിനിംഗിന്റെ പാരിസ്ഥിതിക ആഘാതം കുറയ്ക്കാൻ ബോധപൂർവ്വം ശ്രമിക്കുന്ന ഒരു ടീം നയിച്ച (വളരെ വലിയ) ഒരു മോഡലിന്റെ പ്രോജക്റ്റാണ് ഇവിടെ കാണിക്കുന്നത്. മികച്ച ഹൈപ്പർപാരാമീറ്ററുകൾ കണ്ടെത്താൻ നിരവധി പരീക്ഷണങ്ങൾ നടത്തുന്നതിന്റെ കാൽപ്പാട് ഇതിലും വളരെ കൂടുതലായിരിക്കും.
+
+ഒരു ഗവേഷക ടീമോ, വിദ്യാർത്ഥി സംഘടനയോ, കമ്പനിയോ ഒരു മോഡൽ പരിശീലിപ്പിക്കാൻ ആഗ്രഹിക്കുമ്പോഴെല്ലാം അത് പൂജ്യത്തിൽ നിന്ന് (from scratch) ചെയ്യുന്നു എന്ന് സങ്കൽപ്പിക്കുക. ഇത് ആഗോളതലത്തിൽ ഭീമവും അനാവശ്യവുമായ ചെലവുകളിലേക്ക് നയിക്കും!
+
+ഇതുകൊണ്ടാണ് ഭാഷാ മോഡലുകൾ പങ്കുവയ്ക്കുന്നത് അതിപ്രധാനമാകുന്നത്: പരിശീലിപ്പിച്ച വെയ്‌റ്റുകൾ (weights) പങ്കുവയ്ക്കുന്നതും ഇതിനകം പരിശീലിപ്പിച്ച വെയ്‌റ്റുകളുടെ മേൽ കെട്ടിപ്പടുക്കുന്നതും കമ്യൂണിറ്റിയുടെ മൊത്തത്തിലുള്ള കമ്പ്യൂട്ട് ചെലവും കാർബൺ കാൽപ്പാടും കുറയ്ക്കുന്നു.
+
+അതുകൂടാതെ, നിങ്ങളുടെ മോഡലുകളുടെ പരിശീലനത്തിന്റെ കാർബൺ കാൽപ്പാട് പല ടൂളുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് വിലയിരുത്താം. ഉദാഹരണത്തിന് [ML CO2 Impact](https://mlco2.github.io/impact/) അല്ലെങ്കിൽ 🤗 Transformers-ൽ സംയോജിപ്പിച്ചിട്ടുള്ള [Code Carbon]( https://codecarbon.io/). ഇതേക്കുറിച്ച് കൂടുതൽ അറിയാൻ, നിങ്ങളുടെ പരിശീലനത്തിന്റെ കാൽപ്പാടിന്റെ ഒരു കണക്കുകൂട്ടലടങ്ങിയ `emissions.csv` ഫയൽ എങ്ങനെ ഉണ്ടാക്കാമെന്ന് കാണിക്കുന്ന ഈ [ബ്ലോഗ് പോസ്റ്റ്](https://huggingface.co/blog/carbon-emissions-on-the-hub) വായിക്കാം; അതുപോലെ ഈ വിഷയം കൈകാര്യം ചെയ്യുന്ന 🤗 Transformers-ന്റെ [ഡോക്യുമെന്റേഷനും](https://huggingface.co/docs/hub/model-cards-co2) വായിക്കാം.
+
+
+## Transfer Learning[[transfer-learning]]
+
+<Youtube id="BqqfQnyjmgg" />
+
+*പ്രീട്രെയിനിംഗ്* എന്നത് ഒരു മോഡലിനെ പൂജ്യത്തിൽ നിന്ന് പരിശീലിപ്പിക്കുന്ന പ്രവർത്തനമാണ്: വെയ്‌റ്റുകൾ ക്രമരഹിതമായി (randomly) ഇനിഷ്യലൈസ് ചെയ്യപ്പെടുന്നു, മുൻകൂർ അറിവ് ഒന്നുമില്ലാതെ പരിശീലനം ആരംഭിക്കുന്നു.
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/pretraining.svg" alt="ഒരു ഭാഷാ മോഡലിന്റെ പ്രീട്രെയിനിംഗ് സമയത്തിന്റെയും പണത്തിന്റെയും കാര്യത്തിൽ ചെലവേറിയതാണ്.">
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/pretraining-dark.svg" alt="ഒരു ഭാഷാ മോഡലിന്റെ പ്രീട്രെയിനിംഗ് സമയത്തിന്റെയും പണത്തിന്റെയും കാര്യത്തിൽ ചെലവേറിയതാണ്.">
+</div>
+
+ഈ പ്രീട്രെയിനിംഗ് സാധാരണയായി വളരെ വലിയ അളവിലുള്ള ഡേറ്റയിലാണ് ചെയ്യുന്നത്. അതിനാൽ, ഇതിന് വളരെ വലിയ ഒരു ഡേറ്റാ കോർപ്പസ് ആവശ്യമാണ്, പരിശീലനം പല ആഴ്ചകൾ വരെ നീണ്ടുനിൽക്കാം.
+
+മറുവശത്ത്, *ഫൈൻ-ട്യൂണിംഗ്* എന്നത് ഒരു മോഡൽ പ്രീട്രെയിൻ ചെയ്തതിനു **ശേഷം** നടത്തുന്ന പരിശീലനമാണ്. ഫൈൻ-ട്യൂണിംഗ് നടത്താൻ, നിങ്ങൽ ആദ്യം പ്രീട്രെയിൻ ചെയ്ത ഒരു ഭാഷാ മോഡൽ സ്വന്തമാക്കുന്നു, പിന്നീട് നിങ്ങളുടെ ടാസ്‌ക്കിന് പ്രത്യേകമായ ഒരു ഡേറ്റാസെറ്റ് ഉപയോഗിച്ച് അധിക പരിശീലനം നടത്തുന്നു. ഒരു നിമിഷം -- എന്തുകൊണ്ട് നിങ്ങളുടെ അന്തിമ ഉപയോഗത്തിനായി തുടക്കം മുതൽ (**scratch**) തന്നെ മോഡലിനെ പരിശീലിപ്പിക്കുന്നില്ല? അതിന് ചില കാരണങ്ങളുണ്ട്:
+
+*  ഫൈൻ-ട്യൂണിംഗ് ഡേറ്റാസെറ്റുമായി ചില സാമ്യങ്ങളുള്ള ഒരു ഡേറ്റാസെറ്റിൽ പ്രീട്രെയിൻ ചെയ്ത മോഡൽ ഇതിനകം പരിശീലിപ്പിക്കപ്പെട്ടിട്ടുണ്ട്. അതിനാൽ പ്രീട്രെയിനിംഗ് സമയത്ത് ആദ്യ മോഡൽ നേടിയ അറിവ് ഫൈൻ-ട്യൂണിംഗ് പ്രക്രിയയ്ക്ക് പ്രയോജനപ്പെടുത്താൻ കഴിയും (ഉദാഹരണത്തിന്, NLP പ്രശ്നങ്ങളിൽ, നിങ്ങളുടെ ടാസ്‌ക്കിനായി നിങ്ങൾ ഉപയോഗിക്കുന്ന ഭാഷയെക്കുറിച്ച് പ്രീട്രെയിൻ ചെയ്ത മോഡലിന് ഏതെങ്കിലും തരത്തിലുള്ള സ്ഥിതിവിവരപരമായ ധാരണ ഉണ്ടായിരിക്കും). 
+*  പ്രീട്രെയിൻ ചെയ്ത മോഡൽ ഇതിനകം ധാരാളം ഡേറ്റയിൽ പരിശീലിപ്പിക്കപ്പെട്ടതിനാൽ, തൃപ്തികരമായ ഫലങ്ങൾ ലഭിക്കാൻ ഫൈൻ-ട്യൂണിംഗിന് വളരെ കുറച്ച് ഡേറ്റ മതി.
+*  അതേ കാരണത്താൽ, നല്ല ഫലങ്ങൾ ലഭിക്കാൻ ആവശ്യമായ സമയവും വിഭവങ്ങളും വളരെ കുറവാണ്.
+
+ഉദാഹരണത്തിന്, ഇംഗ്ലീഷ് ഭാഷയിൽ പരിശീലിപ്പിച്ച ഒരു പ്രീട്രെയിൻ ചെയ്ത മോഡൽ എടുത്ത് ഒരു arXiv കോർപ്പസിൽ ഫൈൻ-ട്യൂൻ ചെയ്താൽ, ശാസ്ത്ര/ഗവേഷണ അധിഷ്ഠിതമായ ഒരു മോഡൽ ലഭിക്കും. ഫൈൻ-ട്യൂണിംഗിന് പരിമിതമായ അളവിലുള്ള ഡേറ്റ മാത്രമേ ആവശ്യമുള്ളൂ: പ്രീട്രെയിൻ ചെയ്ത മോഡൽ നേടിയ അറിവ് "കൈമാറ്റം ചെയ്യപ്പെടുന്നു" (transferred), അതുകൊണ്ടാണ് *transfer learning* എന്ന പേര്.
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/finetuning.svg" alt="ഒരു ഭാഷാ മോഡലിന്റെ ഫൈൻ-ട്യൂണിംഗ് സമയത്തിന്റെയും പണത്തിന്റെയും കാര്യത്തിൽ പ്രീട്രെയിനിംഗിനെക്കാൾ ചെലവ് കുറഞ്ഞതാണ്.">
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/finetuning-dark.svg" alt="ഒരു ഭാഷാ മോഡലിന്റെ ഫൈൻ-ട്യൂണിംഗ് സമയത്തിന്റെയും പണത്തിന്റെയും കാര്യത്തിൽ പ്രീട്രെയിനിംഗിനെക്കാൾ ചെലവ് കുറഞ്ഞതാണ്.">
+</div>
+
+അതിനാൽ ഒരു മോഡൽ ഫൈൻ-ട്യൂൻ ചെയ്യുന്നതിന് സമയം, ഡേറ്റ, പണം, പരിസ്ഥിതി എന്നിവയുടെ കാര്യത്തിൽ ചെലവ് കുറവാണ്. പൂർണ്ണമായ പ്രീട്രെയിനിംഗിനെക്കാൾ പരിശീലനത്തിന് നിയന്ത്രണങ്ങൾ കുറവായതിനാൽ, വ്യത്യസ്ത ഫൈൻ-ട്യൂണിംഗ് രീതികൾ പരീക്ഷിച്ചുനോക്കുന്നതും കൂടുതൽ വേഗത്തിലും എളുപ്പത്തിലും സാധിക്കും.
+
+ഈ പ്രക്രിയ പൂജ്യത്തിൽ നിന്ന് പരിശീലിപ്പിക്കുന്നതിനെക്കാൾ മികച്ച ഫലങ്ങളും നൽകും (നിങ്ങൾക്ക് ധാരാളം ഡേറ്റ ഇല്ലെങ്കിൽ). അതുകൊണ്ടാണ് നിങ്ങൾ എപ്പോഴും പ്രീട്രെയിൻ ചെയ്ത ഒരു മോഡൽ -- നിങ്ങളുടെ കൈയിലുള്ള ടാസ്‌ക്കിനോട് കഴിയുന്നത്ര അടുത്തുനിൽക്കുന്ന ഒന്ന് -- പ്രയോജനപ്പെടുത്തി അതിനെ ഫൈൻ-ട്യൂൻ ചെയ്യാൻ ശ്രമിക്കേണ്ടത്.
+
+## Transformer-ന്റെ പൊതുവായ ആർക്കിടെക്ചർ[[general-transformer-architecture]]
+
+ഈ ഭാഗത്ത്, Transformer മോഡലിന്റെ പൊതുവായ ആർക്കിടെക്ചർ നാം പരിശോധിക്കും. ചില ആശയങ്ങൾ മനസ്സിലായില്ലെങ്കിൽ വിഷമിക്കേണ്ട; ഓരോ ഘടകത്തെയും വിശദമായി പ്രതിപാദിക്കുന്ന ഭാഗങ്ങൾ പിന്നീടുണ്ട്.
+
+<Youtube id="H39Z_720T5s" />
+
+മോഡൽ പ്രധാനമായും രണ്ട് ബ്ലോക്കുകൾ ചേർന്നതാണ്:
+
+* **എൻകോഡർ (ഇടത്)**: എൻകോഡർ ഒരു ഇൻപുട്ട് സ്വീകരിക്കുകയും അതിന്റെ ഒരു പ്രതിനിധാനം (representation, അതായത് അതിന്റെ ഫീച്ചറുകൾ) നിർമ്മിക്കുകയും ചെയ്യുന്നു. അതായത്, ഇൻപുട്ടിൽ നിന്ന് ധാരണ നേടാൻ മോഡൽ ഒപ്‌റ്റിമൈസ് ചെയ്യപ്പെട്ടിരിക്കുന്നു.
+* **ഡീകോഡർ (വലത്)**: ഡീകോഡർ എൻകോഡറിന്റെ പ്രതിനിധാനവും (ഫീച്ചറുകൾ) മറ്റ് ഇൻപുട്ടുകളും ഉപയോഗിച്ച് ഒരു ടാർഗെറ്റ് സീക്വൻസ് ജനറേറ്റ് ചെയ്യുന്നു. അതായത്, ഔട്ട്‌പുട്ടുകൾ ജനറേറ്റ് ചെയ്യാൻ മോഡൽ ഒപ്‌റ്റിമൈസ് ചെയ്യപ്പെട്ടിരിക്കുന്നു.
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/transformers_blocks.svg" alt="Transformer മോഡലുകളുടെ ആർക്കിടെക്ചർ">
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/transformers_blocks-dark.svg" alt="Transformer മോഡലുകളുടെ ആർക്കിടെക്ചർ">
+</div>
+
+ടാസ്‌ക്കിനെ ആശ്രയിച്ച്, ഈ ഭാഗങ്ങളിൽ ഓരോന്നും സ്വതന്ത്രമായി ഉപയോഗിക്കാം: 
+
+* **എൻകോഡർ-മാത്രം (Encoder-only) മോഡലുകൾ**: വാക്യ വർഗ്ഗീകരണം (sentence classification), named entity recognition എന്നിവ പോലെ ഇൻപുട്ടിനെക്കുറിച്ചുള്ള ധാരണ ആവശ്യമായ ടാസ്‌ക്കുകൾക്ക് നല്ലത്.
+* **ഡീകോഡർ-മാത്രം (Decoder-only) മോഡലുകൾ**: ടെക്‌സ്‌റ്റ് ജനറേഷൻ പോലുള്ള ജനറേറ്റീവ് ടാസ്‌ക്കുകൾക്ക് നല്ലത്.
+* **എൻകോഡർ-ഡീകോഡർ മോഡലുകൾ** അഥവാ **sequence-to-sequence മോഡലുകൾ**: വിവർത്തനം, സംഗ്രഹം (summarization) എന്നിവ പോലെ ഒരു ഇൻപുട്ട് ആവശ്യമായ ജനറേറ്റീവ് ടാസ്‌ക്കുകൾക്ക് നല്ലത്.
+
+ഈ ആർക്കിടെക്ചറുകളെ ഓരോന്നായി പിന്നീടുള്ള ഭാഗങ്ങളിൽ നാം വിശദമായി പഠിക്കും.
+
+## അറ്റൻഷൻ ലെയറുകൾ[[attention-layers]]
+
+Transformer മോഡലുകളുടെ ഒരു പ്രധാന സവിശേഷത അവ *അറ്റൻഷൻ ലെയറുകൾ* (attention layers) എന്ന പ്രത്യേക ലെയറുകൾ ഉപയോഗിച്ചാണ് നിർമ്മിച്ചിട്ടുള്ളത് എന്നതാണ്. വാസ്തവത്തിൽ, Transformer ആർക്കിടെക്ചർ അവതരിപ്പിച്ച പ്രബന്ധത്തിന്റെ തലക്കെട്ട് തന്നെ ["Attention Is All You Need"](https://arxiv.org/abs/1706.03762) എന്നായിരുന്നു! അറ്റൻഷൻ ലെയറുകളുടെ വിശദാംശങ്ങൾ കോഴ്‌സിൽ പിന്നീട് നാം പരിശോധിക്കും; ഇപ്പോൾ നിങ്ങൾ അറിയേണ്ടത് ഇത്രമാത്രം: ഓരോ വാക്കിന്റെയും പ്രതിനിധാനം കൈകാര്യം ചെയ്യുമ്പോൾ, നിങ്ങൾ നൽകിയ വാക്യത്തിലെ ചില പ്രത്യേക വാക്കുകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാനും (മറ്റുള്ളവയെ ഏറെക്കുറെ അവഗണിക്കാനും) ഈ ലെയർ മോഡലിനോട് പറയുന്നു.
+
+ഇത് സന്ദർഭത്തിൽ മനസ്സിലാക്കാൻ, ഇംഗ്ലീഷിൽ നിന്ന് ഫ്രഞ്ചിലേക്ക് ടെക്‌സ്‌റ്റ് വിവർത്തനം ചെയ്യുന്ന ടാസ്‌ക് പരിഗണിക്കുക. "You like this course" എന്ന ഇൻപുട്ട് നൽകിയാൽ, "like" എന്ന വാക്കിന്റെ ശരിയായ വിവർത്തനം ലഭിക്കാൻ ഒരു വിവർത്തന മോഡലിന് അതിനോട് ചേർന്നുള്ള "You" എന്ന വാക്കിലും ശ്രദ്ധിക്കേണ്ടിവരും, കാരണം ഫ്രഞ്ചിൽ "like" എന്ന ക്രിയയുടെ രൂപം കർത്താവിനെ ആശ്രയിച്ച് മാറുന്നു. എന്നാൽ വാക്യത്തിന്റെ ബാക്കി ഭാഗം ആ വാക്കിന്റെ വിവർത്തനത്തിന് ഉപകാരപ്രദമല്ല. അതുപോലെ, "this" വിവർത്തനം ചെയ്യുമ്പോൾ മോഡലിന് "course" എന്ന വാക്കിലും ശ്രദ്ധിക്കേണ്ടിവരും, കാരണം ബന്ധപ്പെട്ട നാമം പുല്ലിംഗമോ സ്ത്രീലിംഗമോ എന്നതനുസരിച്ച് "this" വ്യത്യസ്തമായി വിവർത്തനം ചെയ്യപ്പെടുന്നു. ഇവിടെയും, "course" വിവർത്തനം ചെയ്യുന്നതിന് വാക്യത്തിലെ മറ്റ് വാക്കുകൾ പ്രസക്തമല്ല. കൂടുതൽ സങ്കീർണ്ണമായ വാക്യങ്ങളിൽ (കൂടുതൽ സങ്കീർണ്ണമായ വ്യാകരണ നിയമങ്ങളിലും), ഓരോ വാക്കും ശരിയായി വിവർത്തനം ചെയ്യാൻ വാക്യത്തിൽ വളരെ അകലെ വരുന്ന വാക്കുകളിലും മോഡലിന് പ്രത്യേക ശ്രദ്ധ കൊടുക്കേണ്ടിവരും.
+
+സ്വാഭാവിക ഭാഷയുമായി ബന്ധപ്പെട്ട ഏത് ടാസ്‌ക്കിനും ഇതേ ആശയം ബാധകമാണ്: ഒരു വാക്കിന് അതിന്റേതായ അർത്ഥമുണ്ട്, എന്നാൽ ആ അർത്ഥത്തെ സന്ദർഭം ആഴത്തിൽ സ്വാധീനിക്കുന്നു — ആ സന്ദർഭം പഠിക്കുന്ന വാക്കിന് മുൻപോ പിൻപോ വരുന്ന ഏതെങ്കിലും വാക്കോ (വാക്കുകളോ) ആകാം.
+
+അറ്റൻഷൻ ലെയറുകൾ എന്തിനെക്കുറിച്ചാണെന്ന് ഇപ്പോൾ നിങ്ങൾക്കൊരു ധാരണ ലഭിച്ചതിനാൽ, Transformer ആർക്കിടെക്ചറിനെ കൂടുതൽ അടുത്ത് നോക്കാം.
+
+## മൂല ആർക്കിടെക്ചർ[[the-original-architecture]]
+
+Transformer ആർക്കിടെക്ചർ ആദ്യം വിവർത്തനത്തിനായി രൂപകൽപ്പന ചെയ്തതാണ്. പരിശീലന സമയത്ത്, എൻകോഡർ ഒരു നിശ്ചിത ഭാഷയിലുള്ള ഇൻപുട്ടുകൾ (വാക്യങ്ങൾ) സ്വീകരിക്കുന്നു, അതേസമയം ഡീകോഡർ അതേ വാക്യങ്ങൾ ആവശ്യമുള്ള ടാർഗെറ്റ് ഭാഷയിൽ സ്വീകരിക്കുന്നു. എൻകോഡറിൽ, അറ്റൻഷൻ ലെയറുകൾക്ക് ഒരു വാക്യത്തിലെ എല്ലാ വാക്കുകളും ഉപയോഗിക്കാം (കാരണം, നാം ഇപ്പോൾ കണ്ടതുപോലെ, ഒരു വാക്കിന്റെ വിവർത്തനം വാക്യത്തിൽ അതിന് മുൻപുള്ളതിനെയും പിൻപുള്ളതിനെയും ആശ്രയിച്ചിരിക്കാം). എന്നാൽ ഡീകോഡർ ക്രമാനുഗതമായി (sequentially) പ്രവർത്തിക്കുന്നു, അതിന് ഇതിനകം വിവർത്തനം ചെയ്ത വാക്കുകളിൽ മാത്രമേ ശ്രദ്ധിക്കാൻ കഴിയൂ (അതായത്, ഇപ്പോൾ ജനറേറ്റ് ചെയ്യുന്ന വാക്കിന് മുൻപുള്ള വാക്കുകളിൽ മാത്രം). ഉദാഹരണത്തിന്, വിവർത്തനം ചെയ്ത ടാർഗെറ്റിന്റെ ആദ്യ മൂന്ന് വാക്കുകൾ പ്രവചിച്ചുകഴിഞ്ഞാൽ, അവ നാം ഡീകോഡറിന് നൽകുന്നു, അത് പിന്നീട് എൻകോഡറിന്റെ എല്ലാ ഇൻപുട്ടുകളും ഉപയോഗിച്ച് നാലാമത്തെ വാക്ക് പ്രവചിക്കാൻ ശ്രമിക്കുന്നു.
+
+പരിശീലന സമയത്ത് (മോഡലിന് ടാർഗെറ്റ് വാക്യങ്ങളിലേക്ക് ആക്‌സസ് ഉള്ളപ്പോൾ) കാര്യങ്ങൾ വേഗത്തിലാക്കാൻ, ഡീകോഡറിന് മുഴുവൻ ടാർഗെറ്റും നൽകുന്നു, എന്നാൽ ഭാവിയിലെ വാക്കുകൾ ഉപയോഗിക്കാൻ അതിനെ അനുവദിക്കുന്നില്ല (സ്ഥാനം 2-ലെ വാക്ക് പ്രവചിക്കാൻ ശ്രമിക്കുമ്പോൾ സ്ഥാനം 2-ലെ വാക്കിലേക്ക് ആക്‌സസ് ഉണ്ടായിരുന്നെങ്കിൽ, പ്രശ്നം അത്ര ബുദ്ധിമുട്ടുള്ളതാകുമായിരുന്നില്ല!). ഉദാഹരണത്തിന്, നാലാമത്തെ വാക്ക് പ്രവചിക്കാൻ ശ്രമിക്കുമ്പോൾ, അറ്റൻഷൻ ലെയറിന് 1 മുതൽ 3 വരെയുള്ള സ്ഥാനങ്ങളിലെ വാക്കുകളിലേക്ക് മാത്രമേ ആക്‌സസ് ഉണ്ടാകൂ.
+
+മൂല Transformer ആർക്കിടെക്ചർ ഇങ്ങനെയായിരുന്നു — ഇടതുവശത്ത് എൻകോഡറും വലതുവശത്ത് ഡീകോഡറും:
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/transformers.svg" alt="Transformer മോഡലുകളുടെ ആർക്കിടെക്ചർ">
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/transformers-dark.svg" alt="Transformer മോഡലുകളുടെ ആർക്കിടെക്ചർ">
+</div>
+
+ഒരു ഡീകോഡർ ബ്ലോക്കിലെ ആദ്യത്തെ അറ്റൻഷൻ ലെയർ ഡീകോഡറിലേക്കുള്ള എല്ലാ (മുൻകാല) ഇൻപുട്ടുകളിലും ശ്രദ്ധിക്കുന്നു, എന്നാൽ രണ്ടാമത്തെ അറ്റൻഷൻ ലെയർ എൻകോഡറിന്റെ ഔട്ട്‌പുട്ട് ഉപയോഗിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. അതിനാൽ നിലവിലെ വാക്ക് ഏറ്റവും നന്നായി പ്രവചിക്കാൻ അതിന് മുഴുവൻ ഇൻപുട്ട് വാക്യവും ആക്‌സസ് ചെയ്യാൻ കഴിയും. വ്യത്യസ്ത ഭാഷകളിൽ വാക്കുകളെ വ്യത്യസ്ത ക്രമത്തിൽ വയ്ക്കുന്ന വ്യാകരണ നിയമങ്ങൾ ഉണ്ടാകാം, അല്ലെങ്കിൽ വാക്യത്തിൽ പിന്നീട് നൽകുന്ന ചില സന്ദർഭങ്ങൾ ഒരു വാക്കിന്റെ ഏറ്റവും മികച്ച വിവർത്തനം നിർണ്ണയിക്കാൻ സഹായകമായേക്കാം എന്നതിനാൽ ഇത് വളരെ ഉപയോഗപ്രദമാണ്.
+
+ചില പ്രത്യേക വാക്കുകളിൽ മോഡൽ ശ്രദ്ധിക്കുന്നത് തടയാൻ എൻകോഡറിലും ഡീകോഡറിലും *അറ്റൻഷൻ മാസ്‌ക്* (attention mask) ഉപയോഗിക്കാം -- ഉദാഹരണത്തിന്, വാക്യങ്ങൾ ഒരുമിച്ച് ബാച്ച് ചെയ്യുമ്പോൾ എല്ലാ ഇൻപുട്ടുകളും ഒരേ നീളത്തിലാക്കാൻ ഉപയോഗിക്കുന്ന പ്രത്യേക പാഡിംഗ് (padding) വാക്ക്.
+
+##  ആർക്കിടെക്ചറുകളും ചെക്ക്‌പോയിന്റുകളും[[architecture-vs-checkpoints]]
+
+ഈ കോഴ്‌സിൽ Transformer മോഡലുകളിലേക്ക് നാം ആഴത്തിൽ ഇറങ്ങുമ്പോൾ, *ആർക്കിടെക്ചറുകൾ*, *ചെക്ക്‌പോയിന്റുകൾ*, *മോഡലുകൾ* എന്നിവയെക്കുറിച്ചുള്ള പരാമർശങ്ങൾ നിങ്ങൾ കാണും. ഈ പദങ്ങൾക്കെല്ലാം അൽപ്പം വ്യത്യസ്തമായ അർത്ഥങ്ങളുണ്ട്: 
+
+* **ആർക്കിടെക്ചർ**: ഇത് മോഡലിന്റെ അസ്ഥികൂടമാണ് -- മോഡലിനുള്ളിൽ നടക്കുന്ന ഓരോ ലെയറിന്റെയും ഓരോ പ്രവർത്തനത്തിന്റെയും നിർവചനം. 
+* **ചെക്ക്‌പോയിന്റുകൾ**: ഒരു നിശ്ചിത ആർക്കിടെക്ചറിൽ ലോഡ് ചെയ്യപ്പെടുന്ന വെയ്‌റ്റുകളാണ് ഇവ.
+* **മോഡൽ**: ഇത് "ആർക്കിടെക്ചർ" അല്ലെങ്കിൽ "ചെക്ക്‌പോയിന്റ്" പോലെ കൃത്യമല്ലാത്ത ഒരു പൊതുപദമാണ്: ഇതിന് രണ്ടും അർത്ഥമാക്കാം. അവ്യക്തത കുറയ്ക്കാൻ ആവശ്യമുള്ളിടത്ത് ഈ കോഴ്‌സ് *ആർക്കിടെക്ചർ* അല്ലെങ്കിൽ *ചെക്ക്‌പോയിന്റ്* എന്ന് വ്യക്തമാക്കും.
+
+ഉദാഹരണത്തിന്, BERT ഒരു ആർക്കിടെക്ചറാണ്, അതേസമയം BERT-ന്റെ ആദ്യ റിലീസിനായി Google ടീം പരിശീലിപ്പിച്ച വെയ്‌റ്റുകളുടെ ഒരു കൂട്ടമായ `bert-base-cased` ഒരു ചെക്ക്‌പോയിന്റാണ്. എന്നിരുന്നാലും, "BERT മോഡൽ" എന്നും "`bert-base-cased` മോഡൽ" എന്നും പറയാവുന്നതാണ്.

From 804959061da41198e6a6d0f834db1f7ad2cc6e46 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 02:35:38 +0530
Subject: [PATCH 08/44] Add Malayalam translation of chapter1/5.mdx (How
 Transformers solve tasks)

---
 chapters/ml/chapter1/5.mdx | 235 +++++++++++++++++++++++++++++++++++++
 1 file changed, 235 insertions(+)
 create mode 100644 chapters/ml/chapter1/5.mdx

diff --git a/chapters/ml/chapter1/5.mdx b/chapters/ml/chapter1/5.mdx
new file mode 100644
index 000000000..a9a31901b
--- /dev/null
+++ b/chapters/ml/chapter1/5.mdx
@@ -0,0 +1,235 @@
+# 🤗 Transformers എങ്ങനെ ടാസ്‌കുകൾ പരിഹരിക്കുന്നു
+
+<Youtube id="zsfR7eY9Uho" />
+
+[Transformers, അവയ്ക്ക് എന്തൊക്കെ ചെയ്യാൻ കഴിയും?](/course/chapter1/3) എന്ന ഭാഗത്തിൽ, നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗ് (NLP), സ്പീച്ച് ആൻഡ് ഓഡിയോ, കമ്പ്യൂട്ടർ വിഷൻ ടാസ്‌കുകൾ എന്നിവയെക്കുറിച്ചും അവയുടെ ചില പ്രധാന പ്രയോഗങ്ങളെക്കുറിച്ചും നിങ്ങൾ പഠിച്ചു. മോഡലുകൾ ഈ ടാസ്‌കുകൾ എങ്ങനെ പരിഹരിക്കുന്നു എന്ന് ഈ പേജ് അടുത്തു നിന്ന് പരിശോധിക്കുകയും, ഉള്ളിൽ എന്താണ് സംഭവിക്കുന്നത് എന്ന് വിശദീകരിക്കുകയും ചെയ്യും. ഒരു ടാസ്‌ക് പരിഹരിക്കാൻ പല വഴികളുണ്ട്; ചില മോഡലുകൾ പ്രത്യേക ടെക്‌നിക്കുകൾ ഉപയോഗിക്കുകയോ പുതിയൊരു കോണിൽ നിന്ന് ടാസ്‌കിനെ സമീപിക്കുകയോ ചെയ്യാം. എന്നാൽ Transformer മോഡലുകളുടെ കാര്യത്തിൽ പൊതുവായ ആശയം ഒന്നുതന്നെയാണ്. അതിന്റെ വഴക്കമുള്ള ആർക്കിടെക്ചർ കാരണം, ഭൂരിഭാഗം മോഡലുകളും ഒരു എൻകോഡർ, ഒരു ഡീകോഡർ, അല്ലെങ്കിൽ എൻകോഡർ-ഡീകോഡർ ഘടനയുടെ ഏതെങ്കിലും ഒരു വകഭേദമാണ്.
+
+> [!TIP]
+> പ്രത്യേക ആർക്കിടെക്ചർ വകഭേദങ്ങളിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, മിക്ക ടാസ്‌കുകളും ഒരേ മാതൃക പിന്തുടരുന്നു എന്ന് മനസ്സിലാക്കുന്നത് സഹായകമാണ്: ഇൻപുട്ട് ഡേറ്റ ഒരു മോഡലിലൂടെ പ്രോസസ്സ് ചെയ്യപ്പെടുന്നു, ഔട്ട്‌പുട്ട് ഒരു പ്രത്യേക ടാസ്‌കിനായി വ്യാഖ്യാനിക്കപ്പെടുന്നു. വ്യത്യാസങ്ങൾ ഡേറ്റ എങ്ങനെ തയ്യാറാക്കുന്നു, ഏത് മോഡൽ ആർക്കിടെക്ചർ വകഭേദം ഉപയോഗിക്കുന്നു, ഔട്ട്‌പുട്ട് എങ്ങനെ പ്രോസസ്സ് ചെയ്യുന്നു എന്നിവയിലാണ്.
+
+ടാസ്‌കുകൾ എങ്ങനെ പരിഹരിക്കപ്പെടുന്നു എന്ന് വിശദീകരിക്കാൻ, ഉപയോഗപ്രദമായ പ്രവചനങ്ങൾ (predictions) പുറത്തുവിടാൻ മോഡലിനുള്ളിൽ എന്താണ് നടക്കുന്നത് എന്ന് നാം പരിശോധിക്കും. താഴെ പറയുന്ന മോഡലുകളും അവയുമായി ബന്ധപ്പെട്ട ടാസ്‌കുകളും നാം ചർച്ച ചെയ്യും:
+
+- ഓഡിയോ ക്ലാസിഫിക്കേഷനും ഓട്ടോമാറ്റിക് സ്പീച്ച് റെക്കഗ്നിഷനും (ASR) വേണ്ടി [Wav2Vec2](https://huggingface.co/docs/transformers/model_doc/wav2vec2)
+- ഇമേജ് ക്ലാസിഫിക്കേഷനായി [Vision Transformer (ViT)](https://huggingface.co/docs/transformers/model_doc/vit), [ConvNeXT](https://huggingface.co/docs/transformers/model_doc/convnext)
+- ഒബ്‌ജക്റ്റ് ഡിറ്റക്ഷനായി [DETR](https://huggingface.co/docs/transformers/model_doc/detr)
+- ഇമേജ് സെഗ്‌മെന്റേഷനായി [Mask2Former](https://huggingface.co/docs/transformers/model_doc/mask2former)
+- ഡെപ്ത് എസ്റ്റിമേഷനായി [GLPN](https://huggingface.co/docs/transformers/model_doc/glpn)
+- എൻകോഡർ ഉപയോഗിക്കുന്ന ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷൻ, ടോക്കൺ ക്ലാസിഫിക്കേഷൻ, ക്വസ്‌ഷൻ ആൻസറിംഗ് പോലുള്ള NLP ടാസ്‌കുകൾക്കായി [BERT](https://huggingface.co/docs/transformers/model_doc/bert)
+- ഡീകോഡർ ഉപയോഗിക്കുന്ന ടെക്‌സ്‌റ്റ് ജനറേഷൻ പോലുള്ള NLP ടാസ്‌കുകൾക്കായി [GPT2](https://huggingface.co/docs/transformers/model_doc/gpt2)
+- എൻകോഡർ-ഡീകോഡർ ഉപയോഗിക്കുന്ന സമ്മറൈസേഷൻ, ട്രാൻസ്ലേഷൻ പോലുള്ള NLP ടാസ്‌കുകൾക്കായി [BART](https://huggingface.co/docs/transformers/model_doc/bart)
+
+> [!TIP]
+> മുന്നോട്ട് പോകുന്നതിന് മുമ്പ്, യഥാർത്ഥ Transformer ആർക്കിടെക്ചറിനെക്കുറിച്ച് കുറച്ച് അടിസ്ഥാന അറിവ് ഉണ്ടായിരിക്കുന്നത് നല്ലതാണ്. എൻകോഡറുകൾ, ഡീകോഡറുകൾ, അറ്റൻഷൻ എന്നിവ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് അറിയുന്നത്, വ്യത്യസ്ത Transformer മോഡലുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാൻ നിങ്ങളെ സഹായിക്കും. കൂടുതൽ വിവരങ്ങൾക്ക് ഞങ്ങളുടെ [മുൻ ഭാഗം](https://huggingface.co/course/chapter1/4?fw=pt) തീർച്ചയായും പരിശോധിക്കുക!
+
+## ഭാഷയ്ക്കുള്ള Transformer മോഡലുകൾ
+
+ആധുനിക NLP-യുടെ ഹൃദയമാണ് ലാംഗ്വേജ് മോഡലുകൾ. ടെക്‌സ്‌റ്റിലെ വാക്കുകൾക്കോ ടോക്കണുകൾക്കോ ഇടയിലുള്ള സ്ഥിതിവിവര മാതൃകകളും (statistical patterns) ബന്ധങ്ങളും പഠിച്ചെടുത്ത് മനുഷ്യഭാഷ മനസ്സിലാക്കാനും സൃഷ്ടിക്കാനുമാണ് അവ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.
+
+Transformer തുടക്കത്തിൽ മെഷീൻ ട്രാൻസ്ലേഷനായി രൂപകൽപ്പന ചെയ്തതാണ്; അതിനുശേഷം, എല്ലാ AI ടാസ്‌കുകളും പരിഹരിക്കാനുള്ള സ്ഥിരം ആർക്കിടെക്ചറായി അത് മാറി. ചില ടാസ്‌കുകൾ Transformer-ന്റെ എൻകോഡർ ഘടനയ്ക്ക് യോജിച്ചവയാണ്, മറ്റുള്ളവ ഡീകോഡറിന് കൂടുതൽ അനുയോജ്യമാണ്. ഇനിയും ചില ടാസ്‌കുകൾ Transformer-ന്റെ എൻകോഡർ-ഡീകോഡർ ഘടന മുഴുവനായി ഉപയോഗപ്പെടുത്തുന്നു.
+
+### ലാംഗ്വേജ് മോഡലുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു
+
+ചുറ്റുമുള്ള വാക്കുകളുടെ സന്ദർഭം (context) നോക്കി ഒരു വാക്കിന്റെ സാധ്യത (probability) പ്രവചിക്കാൻ പരിശീലിപ്പിക്കപ്പെടുന്നതിലൂടെയാണ് ലാംഗ്വേജ് മോഡലുകൾ പ്രവർത്തിക്കുന്നത്. ഇത് അവയ്ക്ക് ഭാഷയെക്കുറിച്ച് ഒരു അടിസ്ഥാന ധാരണ നൽകുന്നു, അത് മറ്റ് ടാസ്‌കുകളിലേക്കും വ്യാപിപ്പിക്കാൻ (generalize) കഴിയും.
+
+ഒരു transformer മോഡൽ പരിശീലിപ്പിക്കാൻ രണ്ട് പ്രധാന സമീപനങ്ങളുണ്ട്:
+
+1. **മാസ്‌ക്ഡ് ലാംഗ്വേജ് മോഡലിംഗ് (MLM)**: BERT പോലുള്ള എൻകോഡർ മോഡലുകൾ ഉപയോഗിക്കുന്ന ഈ സമീപനം, ഇൻപുട്ടിലെ ചില ടോക്കണുകൾ ക്രമരഹിതമായി മറയ്ക്കുകയും (mask), ചുറ്റുമുള്ള സന്ദർഭത്തിന്റെ അടിസ്ഥാനത്തിൽ യഥാർത്ഥ ടോക്കണുകൾ പ്രവചിക്കാൻ മോഡലിനെ പരിശീലിപ്പിക്കുകയും ചെയ്യുന്നു. ഇത് മോഡലിന് ദ്വിദിശ സന്ദർഭം (bidirectional context) പഠിക്കാൻ അനുവദിക്കുന്നു (മറച്ച വാക്കിന് മുമ്പും പിമ്പുമുള്ള വാക്കുകൾ നോക്കുന്നു).
+
+2. **കോസൽ ലാംഗ്വേജ് മോഡലിംഗ് (CLM)**: GPT പോലുള്ള ഡീകോഡർ മോഡലുകൾ ഉപയോഗിക്കുന്ന ഈ സമീപനം, സീക്വൻസിലെ മുൻപുള്ള എല്ലാ ടോക്കണുകളുടെയും അടിസ്ഥാനത്തിൽ അടുത്ത ടോക്കൺ പ്രവചിക്കുന്നു. അടുത്ത ടോക്കൺ പ്രവചിക്കാൻ മോഡലിന് ഇടതുവശത്തുള്ള സന്ദർഭം (മുൻപുള്ള ടോക്കണുകൾ) മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ.
+
+### ലാംഗ്വേജ് മോഡലുകളുടെ തരങ്ങൾ
+
+Transformers ലൈബ്രറിയിൽ, ലാംഗ്വേജ് മോഡലുകൾ പൊതുവെ മൂന്ന് ആർക്കിടെക്ചർ വിഭാഗങ്ങളിൽ പെടുന്നു:
+
+1. **എൻകോഡർ-ഒൺലി മോഡലുകൾ** (BERT പോലുള്ളവ): ഈ മോഡലുകൾ രണ്ട് ദിശകളിൽ നിന്നും സന്ദർഭം മനസ്സിലാക്കാൻ ഒരു ദ്വിദിശ സമീപനം ഉപയോഗിക്കുന്നു. ക്ലാസിഫിക്കേഷൻ, നെയിംഡ് എന്റിറ്റി റെക്കഗ്നിഷൻ, ക്വസ്‌ഷൻ ആൻസറിംഗ് പോലെ ടെക്‌സ്‌റ്റിനെക്കുറിച്ച് ആഴത്തിലുള്ള ധാരണ ആവശ്യമായ ടാസ്‌കുകൾക്ക് ഇവ ഏറ്റവും അനുയോജ്യമാണ്.
+
+2. **ഡീകോഡർ-ഒൺലി മോഡലുകൾ** (GPT, Llama പോലുള്ളവ): ഈ മോഡലുകൾ ടെക്‌സ്‌റ്റ് ഇടത്തുനിന്ന് വലത്തോട്ട് പ്രോസസ്സ് ചെയ്യുന്നു, ടെക്‌സ്‌റ്റ് ജനറേഷൻ ടാസ്‌കുകളിൽ ഇവ പ്രത്യേകിച്ച് മികച്ചതാണ്. ഒരു പ്രോംപ്‌റ്റിന്റെ അടിസ്ഥാനത്തിൽ ഇവയ്ക്ക് വാക്യങ്ങൾ പൂർത്തിയാക്കാനും ലേഖനങ്ങൾ എഴുതാനും കോഡ് വരെ സൃഷ്ടിക്കാനും കഴിയും.
+
+3. **എൻകോഡർ-ഡീകോഡർ മോഡലുകൾ** (T5, BART പോലുള്ളവ): ഈ മോഡലുകൾ രണ്ട് സമീപനങ്ങളും സംയോജിപ്പിക്കുന്നു — ഇൻപുട്ട് മനസ്സിലാക്കാൻ ഒരു എൻകോഡറും ഔട്ട്‌പുട്ട് സൃഷ്ടിക്കാൻ ഒരു ഡീകോഡറും ഉപയോഗിക്കുന്നു. ട്രാൻസ്ലേഷൻ, സമ്മറൈസേഷൻ, ക്വസ്‌ഷൻ ആൻസറിംഗ് പോലുള്ള സീക്വൻസ്-ടു-സീക്വൻസ് ടാസ്‌കുകളിൽ ഇവ മികവ് പുലർത്തുന്നു.
+
+![ഭാഷയ്ക്കുള്ള transformer മോഡലുകൾ](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/transformers_architecture.png)
+
+മുൻ ഭാഗത്തിൽ നാം കണ്ടതുപോലെ, ലാംഗ്വേജ് മോഡലുകൾ സാധാരണയായി വലിയ അളവിലുള്ള ടെക്‌സ്‌റ്റ് ഡേറ്റയിൽ സെൽഫ്-സൂപ്പർവൈസ്ഡ് രീതിയിൽ (മനുഷ്യർ നൽകുന്ന അനോട്ടേഷനുകൾ ഇല്ലാതെ) പ്രീട്രെയിൻ ചെയ്യപ്പെടുകയും, പിന്നീട് പ്രത്യേക ടാസ്‌കുകളിൽ ഫൈൻ-ട്യൂൻ ചെയ്യപ്പെടുകയും ചെയ്യുന്നു. ട്രാൻസ്ഫർ ലേണിംഗ് (transfer learning) എന്നറിയപ്പെടുന്ന ഈ സമീപനം, താരതമ്യേന ചെറിയ അളവിലുള്ള ടാസ്‌ക്-നിർദ്ദിഷ്ട ഡേറ്റ ഉപയോഗിച്ച് പല വ്യത്യസ്ത NLP ടാസ്‌കുകളിലേക്കും പൊരുത്തപ്പെടാൻ ഈ മോഡലുകളെ അനുവദിക്കുന്നു.
+
+തുടർന്നുള്ള ഭാഗങ്ങളിൽ, പ്രത്യേക മോഡൽ ആർക്കിടെക്ചറുകളും അവ സ്പീച്ച്, വിഷൻ, ടെക്‌സ്‌റ്റ് മേഖലകളിലെ വിവിധ ടാസ്‌കുകളിൽ എങ്ങനെ പ്രയോഗിക്കപ്പെടുന്നു എന്നതും നാം പരിശോധിക്കും.
+
+> [!TIP]
+> ഒരു പ്രത്യേക NLP ടാസ്‌കിന് Transformer ആർക്കിടെക്ചറിന്റെ ഏത് ഭാഗം (എൻകോഡർ, ഡീകോഡർ, അല്ലെങ്കിൽ രണ്ടും) ഏറ്റവും അനുയോജ്യമാണ് എന്ന് മനസ്സിലാക്കുന്നത് ശരിയായ മോഡൽ തിരഞ്ഞെടുക്കുന്നതിൽ നിർണായകമാണ്. പൊതുവെ, ദ്വിദിശ സന്ദർഭം ആവശ്യമായ ടാസ്‌കുകൾ എൻകോഡറുകൾ ഉപയോഗിക്കുന്നു, ടെക്‌സ്‌റ്റ് സൃഷ്ടിക്കുന്ന ടാസ്‌കുകൾ ഡീകോഡറുകൾ ഉപയോഗിക്കുന്നു, ഒരു സീക്വൻസിനെ മറ്റൊന്നിലേക്ക് മാറ്റുന്ന ടാസ്‌കുകൾ എൻകോഡർ-ഡീകോഡറുകൾ ഉപയോഗിക്കുന്നു.
+
+### ടെക്‌സ്‌റ്റ് ജനറേഷൻ
+
+ഒരു പ്രോംപ്‌റ്റിന്റെയോ ഇൻപുട്ടിന്റെയോ അടിസ്ഥാനത്തിൽ യുക്തിസഹവും സന്ദർഭത്തിന് അനുയോജ്യവുമായ ടെക്‌സ്‌റ്റ് സൃഷ്ടിക്കുന്നതാണ് ടെക്‌സ്‌റ്റ് ജനറേഷൻ.
+
+[GPT-2](https://huggingface.co/docs/transformers/model_doc/gpt2) വലിയ അളവിലുള്ള ടെക്‌സ്‌റ്റിൽ പ്രീട്രെയിൻ ചെയ്ത ഒരു ഡീകോഡർ-ഒൺലി മോഡലാണ്. ഒരു പ്രോംപ്‌റ്റ് നൽകിയാൽ അതിന് വിശ്വസനീയമായ (എപ്പോഴും സത്യമല്ലെങ്കിലും!) ടെക്‌സ്‌റ്റ് സൃഷ്ടിക്കാനും, പ്രത്യേകം പരിശീലിപ്പിച്ചിട്ടില്ലെങ്കിലും ക്വസ്‌ഷൻ ആൻസറിംഗ് പോലുള്ള മറ്റ് NLP ടാസ്‌കുകൾ പൂർത്തിയാക്കാനും കഴിയും.
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gpt2_architecture.png"/>
+</div>
+
+1. വാക്കുകൾ ടോക്കണൈസ് ചെയ്യാനും ഒരു ടോക്കൺ എംബെഡ്ഡിംഗ് സൃഷ്ടിക്കാനും GPT-2 [byte pair encoding (BPE)](https://huggingface.co/docs/transformers/tokenizer_summary#bytepair-encoding-bpe) ഉപയോഗിക്കുന്നു. സീക്വൻസിലെ ഓരോ ടോക്കണിന്റെയും സ്ഥാനം സൂചിപ്പിക്കാൻ ടോക്കൺ എംബെഡ്ഡിംഗുകളിലേക്ക് പൊസിഷണൽ എൻകോഡിംഗുകൾ (positional encodings) കൂട്ടിച്ചേർക്കുന്നു. ഇൻപുട്ട് എംബെഡ്ഡിംഗുകൾ ഒന്നിലധികം ഡീകോഡർ ബ്ലോക്കുകളിലൂടെ കടത്തിവിട്ട് ഒരു അന്തിമ ഹിഡൻ സ്റ്റേറ്റ് (final hidden state) ഔട്ട്‌പുട്ട് ചെയ്യുന്നു. ഓരോ ഡീകോഡർ ബ്ലോക്കിനുള്ളിലും GPT-2 ഒരു *മാസ്‌ക്ഡ് സെൽഫ്-അറ്റൻഷൻ* ലെയർ ഉപയോഗിക്കുന്നു, അതായത് GPT-2-ന് ഭാവിയിലെ ടോക്കണുകളിലേക്ക് ശ്രദ്ധ (attend) നൽകാൻ കഴിയില്ല. ഇടതുവശത്തുള്ള ടോക്കണുകളിലേക്ക് മാത്രമേ ശ്രദ്ധ നൽകാൻ അനുവാദമുള്ളൂ. ഇത് BERT-ന്റെ [`mask`] ടോക്കണിൽ നിന്ന് വ്യത്യസ്തമാണ്, കാരണം മാസ്‌ക്ഡ് സെൽഫ്-അറ്റൻഷനിൽ, ഭാവിയിലെ ടോക്കണുകളുടെ സ്‌കോർ `0` ആയി സെറ്റ് ചെയ്യാൻ ഒരു അറ്റൻഷൻ മാസ്‌ക് ഉപയോഗിക്കുന്നു.
+
+2. ഡീകോഡറിൽ നിന്നുള്ള ഔട്ട്‌പുട്ട് ഒരു ലാംഗ്വേജ് മോഡലിംഗ് ഹെഡിലേക്ക് (language modeling head) കൈമാറുന്നു, അത് ഹിഡൻ സ്റ്റേറ്റുകളെ ലോജിറ്റുകളാക്കി (logits) മാറ്റാൻ ഒരു ലീനിയർ ട്രാൻസ്ഫർമേഷൻ നടത്തുന്നു. സീക്വൻസിലെ അടുത്ത ടോക്കണാണ് ലേബൽ; ലോജിറ്റുകളെ ഒരു സ്ഥാനം വലത്തോട്ട് മാറ്റിയാണ് (shift) ഇവ സൃഷ്ടിക്കുന്നത്. അടുത്ത ഏറ്റവും സാധ്യതയുള്ള ടോക്കൺ ഔട്ട്‌പുട്ട് ചെയ്യാൻ, മാറ്റിയ ലോജിറ്റുകൾക്കും ലേബലുകൾക്കും ഇടയിൽ ക്രോസ്-എൻട്രോപ്പി ലോസ് (cross-entropy loss) കണക്കാക്കുന്നു.
+
+GPT-2-ന്റെ പ്രീട്രെയിനിംഗ് ലക്ഷ്യം പൂർണ്ണമായും [കോസൽ ലാംഗ്വേജ് മോഡലിംഗ്](https://huggingface.co/docs/transformers/glossary#causal-language-modeling) അടിസ്ഥാനമാക്കിയുള്ളതാണ് — ഒരു സീക്വൻസിലെ അടുത്ത വാക്ക് പ്രവചിക്കുക. ഇത് ടെക്‌സ്‌റ്റ് സൃഷ്ടിക്കുന്ന ടാസ്‌കുകളിൽ GPT-2-നെ പ്രത്യേകിച്ച് മികച്ചതാക്കുന്നു.
+
+ടെക്‌സ്‌റ്റ് ജനറേഷൻ സ്വയം പരീക്ഷിക്കാൻ തയ്യാറാണോ? DistilGPT-2 എങ്ങനെ ഫൈൻ-ട്യൂൻ ചെയ്യാമെന്നും ഇൻഫറൻസിനായി ഉപയോഗിക്കാമെന്നും പഠിക്കാൻ ഞങ്ങളുടെ പൂർണ്ണമായ [കോസൽ ലാംഗ്വേജ് മോഡലിംഗ് ഗൈഡ്](https://huggingface.co/docs/transformers/tasks/language_modeling#causal-language-modeling) പരിശോധിക്കുക!
+
+> [!TIP]
+> ടെക്‌സ്‌റ്റ് ജനറേഷനെക്കുറിച്ച് കൂടുതൽ വിവരങ്ങൾക്ക്, [ടെക്‌സ്‌റ്റ് ജനറേഷൻ സ്ട്രാറ്റജികൾ](https://huggingface.co/docs/transformers/generation_strategies#generation-strategies) എന്ന ഗൈഡ് പരിശോധിക്കുക!
+
+### ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷൻ
+
+സെന്റിമെന്റ് അനാലിസിസ്, ടോപ്പിക് ക്ലാസിഫിക്കേഷൻ, സ്പാം ഡിറ്റക്ഷൻ എന്നിവ പോലെ, ടെക്‌സ്‌റ്റ് ഡോക്യുമെന്റുകൾക്ക് മുൻകൂട്ടി നിശ്ചയിച്ച വിഭാഗങ്ങൾ നൽകുന്നതാണ് ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷൻ.
+
+[BERT](https://huggingface.co/docs/transformers/model_doc/bert) ഒരു എൻകോഡർ-ഒൺലി മോഡലാണ്; വാക്കുകളുടെ ഇരുവശത്തുമുള്ള വാക്കുകളിലേക്ക് ശ്രദ്ധ നൽകി ടെക്‌സ്‌റ്റിന്റെ കൂടുതൽ സമ്പന്നമായ പ്രതിനിധാനങ്ങൾ (representations) പഠിക്കാൻ ആഴത്തിലുള്ള ദ്വിദിശാത്വം (deep bidirectionality) ഫലപ്രദമായി നടപ്പിലാക്കിയ ആദ്യ മോഡലാണിത്.
+
+1. ടെക്‌സ്‌റ്റിന്റെ ഒരു ടോക്കൺ എംബെഡ്ഡിംഗ് സൃഷ്ടിക്കാൻ BERT [WordPiece](https://huggingface.co/docs/transformers/tokenizer_summary#wordpiece) ടോക്കണൈസേഷൻ ഉപയോഗിക്കുന്നു. ഒരൊറ്റ വാക്യവും ഒരു ജോടി വാക്യങ്ങളും തമ്മിലുള്ള വ്യത്യാസം തിരിച്ചറിയാൻ, അവയെ വേർതിരിക്കുന്ന ഒരു പ്രത്യേക `[SEP]` ടോക്കൺ ചേർക്കുന്നു. ഓരോ ടെക്‌സ്‌റ്റ് സീക്വൻസിന്റെയും തുടക്കത്തിൽ ഒരു പ്രത്യേക `[CLS]` ടോക്കൺ ചേർക്കുന്നു. `[CLS]` ടോക്കണിനൊപ്പമുള്ള അന്തിമ ഔട്ട്‌പുട്ട്, ക്ലാസിഫിക്കേഷൻ ടാസ്‌കുകൾക്കായി ക്ലാസിഫിക്കേഷൻ ഹെഡിലേക്കുള്ള ഇൻപുട്ടായി ഉപയോഗിക്കുന്നു. ഒരു ജോടി വാക്യങ്ങളിൽ ഒരു ടോക്കൺ ആദ്യത്തെ വാക്യത്തിലാണോ രണ്ടാമത്തേതിലാണോ എന്ന് സൂചിപ്പിക്കാൻ BERT ഒരു സെഗ്‌മെന്റ് എംബെഡ്ഡിംഗും ചേർക്കുന്നു.
+
+2. BERT രണ്ട് ലക്ഷ്യങ്ങളോടെ പ്രീട്രെയിൻ ചെയ്യപ്പെടുന്നു: മാസ്‌ക്ഡ് ലാംഗ്വേജ് മോഡലിംഗും നെക്‌സ്‌റ്റ്-സെന്റൻസ് പ്രെഡിക്ഷനും. മാസ്‌ക്ഡ് ലാംഗ്വേജ് മോഡലിംഗിൽ, ഇൻപുട്ട് ടോക്കണുകളുടെ ഒരു നിശ്ചിത ശതമാനം ക്രമരഹിതമായി മറയ്ക്കുന്നു, മോഡൽ അവ പ്രവചിക്കണം. മോഡൽ എല്ലാ വാക്കുകളും കണ്ടിട്ട് അടുത്ത വാക്ക് "പ്രവചിച്ച്" കബളിപ്പിക്കാൻ കഴിയുന്ന ദ്വിദിശാത്വത്തിന്റെ പ്രശ്നം ഇത് പരിഹരിക്കുന്നു. പ്രവചിച്ച മാസ്‌ക് ടോക്കണുകളുടെ അന്തിമ ഹിഡൻ സ്റ്റേറ്റുകൾ, മറച്ച വാക്ക് പ്രവചിക്കാൻ വൊക്കാബുലറിക്ക് മേൽ ഒരു softmax ഉള്ള ഒരു ഫീഡ്‌ഫോർവേഡ് നെറ്റ്‌വർക്കിലേക്ക് കൈമാറുന്നു.
+
+    രണ്ടാമത്തെ പ്രീട്രെയിനിംഗ് ലക്ഷ്യം നെക്‌സ്‌റ്റ്-സെന്റൻസ് പ്രെഡിക്ഷനാണ്. വാക്യം A-യെ തുടർന്ന് വാക്യം B വരുന്നുണ്ടോ എന്ന് മോഡൽ പ്രവചിക്കണം. പകുതി സമയവും വാക്യം B അടുത്ത വാക്യമായിരിക്കും, ബാക്കി പകുതി സമയം വാക്യം B ഒരു ക്രമരഹിത വാക്യമായിരിക്കും. അടുത്ത വാക്യമാണോ അല്ലയോ എന്ന പ്രവചനം, രണ്ട് ക്ലാസുകൾക്ക് (`IsNext`, `NotNext`) മേൽ ഒരു softmax ഉള്ള ഒരു ഫീഡ്‌ഫോർവേഡ് നെറ്റ്‌വർക്കിലേക്ക് കൈമാറുന്നു.
+
+3. ഇൻപുട്ട് എംബെഡ്ഡിംഗുകൾ ഒന്നിലധികം എൻകോഡർ ലെയറുകളിലൂടെ കടത്തിവിട്ട് അന്തിമ ഹിഡൻ സ്റ്റേറ്റുകൾ ഔട്ട്‌പുട്ട് ചെയ്യുന്നു.
+
+പ്രീട്രെയിൻ ചെയ്ത മോഡൽ ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷനായി ഉപയോഗിക്കാൻ, അടിസ്ഥാന BERT മോഡലിന് മുകളിൽ ഒരു സീക്വൻസ് ക്ലാസിഫിക്കേഷൻ ഹെഡ് ചേർക്കുക. സീക്വൻസ് ക്ലാസിഫിക്കേഷൻ ഹെഡ് എന്നത് അന്തിമ ഹിഡൻ സ്റ്റേറ്റുകൾ സ്വീകരിച്ച് അവയെ ലോജിറ്റുകളാക്കി മാറ്റാൻ ഒരു ലീനിയർ ട്രാൻസ്ഫർമേഷൻ നടത്തുന്ന ഒരു ലീനിയർ ലെയറാണ്. ഏറ്റവും സാധ്യതയുള്ള ലേബൽ കണ്ടെത്താൻ ലോജിറ്റുകൾക്കും ടാർഗെറ്റിനും ഇടയിൽ ക്രോസ്-എൻട്രോപ്പി ലോസ് കണക്കാക്കുന്നു.
+
+ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷൻ സ്വയം പരീക്ഷിക്കാൻ തയ്യാറാണോ? DistilBERT എങ്ങനെ ഫൈൻ-ട്യൂൻ ചെയ്യാമെന്നും ഇൻഫറൻസിനായി ഉപയോഗിക്കാമെന്നും പഠിക്കാൻ ഞങ്ങളുടെ പൂർണ്ണമായ [ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷൻ ഗൈഡ്](https://huggingface.co/docs/transformers/tasks/sequence_classification) പരിശോധിക്കുക!
+
+### ടോക്കൺ ക്ലാസിഫിക്കേഷൻ
+
+നെയിംഡ് എന്റിറ്റി റെക്കഗ്നിഷനിലോ പാർട്ട്-ഓഫ്-സ്പീച്ച് ടാഗിംഗിലോ ഉള്ളതുപോലെ, ഒരു സീക്വൻസിലെ ഓരോ ടോക്കണിനും ഒരു ലേബൽ നൽകുന്നതാണ് ടോക്കൺ ക്ലാസിഫിക്കേഷൻ.
+
+നെയിംഡ് എന്റിറ്റി റെക്കഗ്നിഷൻ (NER) പോലുള്ള ടോക്കൺ ക്ലാസിഫിക്കേഷൻ ടാസ്‌കുകൾക്ക് BERT ഉപയോഗിക്കാൻ, അടിസ്ഥാന BERT മോഡലിന് മുകളിൽ ഒരു ടോക്കൺ ക്ലാസിഫിക്കേഷൻ ഹെഡ് ചേർക്കുക. ടോക്കൺ ക്ലാസിഫിക്കേഷൻ ഹെഡ് എന്നത് അന്തിമ ഹിഡൻ സ്റ്റേറ്റുകൾ സ്വീകരിച്ച് അവയെ ലോജിറ്റുകളാക്കി മാറ്റാൻ ഒരു ലീനിയർ ട്രാൻസ്ഫർമേഷൻ നടത്തുന്ന ഒരു ലീനിയർ ലെയറാണ്. ഏറ്റവും സാധ്യതയുള്ള ലേബൽ കണ്ടെത്താൻ ലോജിറ്റുകൾക്കും ഓരോ ടോക്കണിനും ഇടയിൽ ക്രോസ്-എൻട്രോപ്പി ലോസ് കണക്കാക്കുന്നു.
+
+ടോക്കൺ ക്ലാസിഫിക്കേഷൻ സ്വയം പരീക്ഷിക്കാൻ തയ്യാറാണോ? DistilBERT എങ്ങനെ ഫൈൻ-ട്യൂൻ ചെയ്യാമെന്നും ഇൻഫറൻസിനായി ഉപയോഗിക്കാമെന്നും പഠിക്കാൻ ഞങ്ങളുടെ പൂർണ്ണമായ [ടോക്കൺ ക്ലാസിഫിക്കേഷൻ ഗൈഡ്](https://huggingface.co/docs/transformers/tasks/token_classification) പരിശോധിക്കുക!
+
+### ക്വസ്‌ഷൻ ആൻസറിംഗ്
+
+നൽകിയ ഒരു സന്ദർഭത്തിലോ ഖണ്ഡികയിലോ നിന്ന് ഒരു ചോദ്യത്തിന്റെ ഉത്തരം കണ്ടെത്തുന്നതാണ് ക്വസ്‌ഷൻ ആൻസറിംഗ്.
+
+ക്വസ്‌ഷൻ ആൻസറിംഗിനായി BERT ഉപയോഗിക്കാൻ, അടിസ്ഥാന BERT മോഡലിന് മുകളിൽ ഒരു സ്പാൻ ക്ലാസിഫിക്കേഷൻ ഹെഡ് ചേർക്കുക. ഈ ലീനിയർ ലെയർ അന്തിമ ഹിഡൻ സ്റ്റേറ്റുകൾ സ്വീകരിച്ച്, ഉത്തരത്തിന് അനുയോജ്യമായ `span`-ന്റെ തുടക്കത്തിന്റെയും അവസാനത്തിന്റെയും ലോജിറ്റുകൾ കണക്കാക്കാൻ ഒരു ലീനിയർ ട്രാൻസ്ഫർമേഷൻ നടത്തുന്നു. ഉത്തരത്തിന് അനുയോജ്യമായ, ഏറ്റവും സാധ്യതയുള്ള ടെക്‌സ്‌റ്റ് സ്പാൻ കണ്ടെത്താൻ ലോജിറ്റുകൾക്കും ലേബൽ പൊസിഷനും ഇടയിൽ ക്രോസ്-എൻട്രോപ്പി ലോസ് കണക്കാക്കുന്നു.
+
+ക്വസ്‌ഷൻ ആൻസറിംഗ് സ്വയം പരീക്ഷിക്കാൻ തയ്യാറാണോ? DistilBERT എങ്ങനെ ഫൈൻ-ട്യൂൻ ചെയ്യാമെന്നും ഇൻഫറൻസിനായി ഉപയോഗിക്കാമെന്നും പഠിക്കാൻ ഞങ്ങളുടെ പൂർണ്ണമായ [ക്വസ്‌ഷൻ ആൻസറിംഗ് ഗൈഡ്](https://huggingface.co/docs/transformers/tasks/question_answering) പരിശോധിക്കുക!
+
+> [!TIP]
+> 💡 ഒരിക്കൽ പ്രീട്രെയിൻ ചെയ്തുകഴിഞ്ഞാൽ, വ്യത്യസ്ത ടാസ്‌കുകൾക്ക് BERT ഉപയോഗിക്കുന്നത് എത്ര എളുപ്പമാണെന്ന് ശ്രദ്ധിക്കുക. ഹിഡൻ സ്റ്റേറ്റുകളെ നിങ്ങൾക്ക് ആവശ്യമുള്ള ഔട്ട്‌പുട്ടിലേക്ക് മാറ്റാൻ പ്രീട്രെയിൻ ചെയ്ത മോഡലിലേക്ക് ഒരു പ്രത്യേക ഹെഡ് ചേർത്താൽ മാത്രം മതി!
+
+### സമ്മറൈസേഷൻ
+
+ഒരു നീണ്ട ടെക്‌സ്‌റ്റിന്റെ പ്രധാന വിവരങ്ങളും അർത്ഥവും നിലനിർത്തിക്കൊണ്ട് അതിനെ ചെറിയൊരു രൂപത്തിലേക്ക് ചുരുക്കുന്നതാണ് സമ്മറൈസേഷൻ.
+
+[BART](https://huggingface.co/docs/transformers/model_doc/bart), [T5](model_doc/t5) പോലുള്ള എൻകോഡർ-ഡീകോഡർ മോഡലുകൾ ഒരു സമ്മറൈസേഷൻ ടാസ്‌കിന്റെ സീക്വൻസ്-ടു-സീക്വൻസ് മാതൃകയ്ക്കായി രൂപകൽപ്പന ചെയ്തവയാണ്. ഈ ഭാഗത്തിൽ BART എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് നാം വിശദീകരിക്കും, തുടർന്ന് അവസാനം T5 ഫൈൻ-ട്യൂൻ ചെയ്യാൻ നിങ്ങൾക്ക് ശ്രമിക്കാം.
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bart_architecture.png"/>
+</div>
+
+1. BART-ന്റെ എൻകോഡർ ആർക്കിടെക്ചർ BERT-നോട് വളരെ സാമ്യമുള്ളതാണ്; അത് ടെക്‌സ്‌റ്റിന്റെ ഒരു ടോക്കൺ എംബെഡ്ഡിംഗും പൊസിഷണൽ എംബെഡ്ഡിംഗും സ്വീകരിക്കുന്നു. ഇൻപുട്ടിനെ വികലമാക്കി (corrupt) പിന്നീട് ഡീകോഡർ ഉപയോഗിച്ച് അത് പുനർനിർമ്മിച്ചാണ് BART പ്രീട്രെയിൻ ചെയ്യുന്നത്. പ്രത്യേക വികലമാക്കൽ തന്ത്രങ്ങളുള്ള മറ്റ് എൻകോഡറുകളിൽ നിന്ന് വ്യത്യസ്തമായി, BART-ന് ഏത് തരത്തിലുള്ള വികലമാക്കലും പ്രയോഗിക്കാൻ കഴിയും. എന്നിരുന്നാലും *ടെക്‌സ്‌റ്റ് ഇൻഫില്ലിംഗ്* (text infilling) എന്ന തന്ത്രമാണ് ഏറ്റവും നന്നായി പ്രവർത്തിക്കുന്നത്. ടെക്‌സ്‌റ്റ് ഇൻഫില്ലിംഗിൽ, നിരവധി ടെക്‌സ്‌റ്റ് സ്പാനുകൾ **ഒരൊറ്റ** [`mask`] ടോക്കൺ കൊണ്ട് മാറ്റിസ്ഥാപിക്കുന്നു. ഇത് പ്രധാനമാണ്, കാരണം മോഡലിന് മറച്ച ടോക്കണുകൾ പ്രവചിക്കേണ്ടതുണ്ട്; കൂടാതെ എത്ര ടോക്കണുകൾ നഷ്ടപ്പെട്ടിട്ടുണ്ട് എന്ന് പ്രവചിക്കാനും ഇത് മോഡലിനെ പഠിപ്പിക്കുന്നു. ഇൻപുട്ട് എംബെഡ്ഡിംഗുകളും മറച്ച സ്പാനുകളും എൻകോഡറിലൂടെ കടത്തിവിട്ട് അന്തിമ ഹിഡൻ സ്റ്റേറ്റുകൾ ഔട്ട്‌പുട്ട് ചെയ്യുന്നു; എന്നാൽ BERT-ൽ നിന്ന് വ്യത്യസ്തമായി, ഒരു വാക്ക് പ്രവചിക്കാൻ BART അവസാനം ഒരു ഫീഡ്‌ഫോർവേഡ് നെറ്റ്‌വർക്ക് ചേർക്കുന്നില്ല.
+
+2. എൻകോഡറിന്റെ ഔട്ട്‌പുട്ട് ഡീകോഡറിലേക്ക് കൈമാറുന്നു; എൻകോഡറിന്റെ ഔട്ട്‌പുട്ടിൽ നിന്ന് മറച്ച ടോക്കണുകളും വികലമാക്കാത്ത ഏതെങ്കിലും ടോക്കണുകളും ഡീകോഡർ പ്രവചിക്കണം. യഥാർത്ഥ ടെക്‌സ്‌റ്റ് പുനഃസ്ഥാപിക്കാൻ ഡീകോഡറിനെ സഹായിക്കുന്ന അധിക സന്ദർഭം ഇത് നൽകുന്നു. ഡീകോഡറിൽ നിന്നുള്ള ഔട്ട്‌പുട്ട് ഒരു ലാംഗ്വേജ് മോഡലിംഗ് ഹെഡിലേക്ക് കൈമാറുന്നു, അത് ഹിഡൻ സ്റ്റേറ്റുകളെ ലോജിറ്റുകളാക്കി മാറ്റാൻ ഒരു ലീനിയർ ട്രാൻസ്ഫർമേഷൻ നടത്തുന്നു. ലോജിറ്റുകൾക്കും ലേബലിനും ഇടയിൽ ക്രോസ്-എൻട്രോപ്പി ലോസ് കണക്കാക്കുന്നു; ലേബൽ എന്നത് വലത്തോട്ട് ഒരു സ്ഥാനം മാറ്റിയ ടോക്കൺ മാത്രമാണ്.
+
+സമ്മറൈസേഷൻ സ്വയം പരീക്ഷിക്കാൻ തയ്യാറാണോ? T5 എങ്ങനെ ഫൈൻ-ട്യൂൻ ചെയ്യാമെന്നും ഇൻഫറൻസിനായി ഉപയോഗിക്കാമെന്നും പഠിക്കാൻ ഞങ്ങളുടെ പൂർണ്ണമായ [സമ്മറൈസേഷൻ ഗൈഡ്](https://huggingface.co/docs/transformers/tasks/summarization) പരിശോധിക്കുക!
+
+> [!TIP]
+> ടെക്‌സ്‌റ്റ് ജനറേഷനെക്കുറിച്ച് കൂടുതൽ വിവരങ്ങൾക്ക്, [ടെക്‌സ്‌റ്റ് ജനറേഷൻ സ്ട്രാറ്റജികൾ](https://huggingface.co/docs/transformers/generation_strategies) എന്ന ഗൈഡ് പരിശോധിക്കുക!
+
+### ട്രാൻസ്ലേഷൻ
+
+അർത്ഥം നിലനിർത്തിക്കൊണ്ട് ടെക്‌സ്‌റ്റ് ഒരു ഭാഷയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് മാറ്റുന്നതാണ് ട്രാൻസ്ലേഷൻ. സീക്വൻസ്-ടു-സീക്വൻസ് ടാസ്‌കിന്റെ മറ്റൊരു ഉദാഹരണമാണ് ട്രാൻസ്ലേഷൻ, അതായത് ഇത് ചെയ്യാൻ [BART](https://huggingface.co/docs/transformers/model_doc/bart) അല്ലെങ്കിൽ [T5](model_doc/t5) പോലുള്ള ഒരു എൻകോഡർ-ഡീകോഡർ മോഡൽ നിങ്ങൾക്ക് ഉപയോഗിക്കാം. ഈ ഭാഗത്തിൽ BART എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് നാം വിശദീകരിക്കും, തുടർന്ന് അവസാനം T5 ഫൈൻ-ട്യൂൻ ചെയ്യാൻ നിങ്ങൾക്ക് ശ്രമിക്കാം.
+
+ഒരു സോഴ്‌സ് ഭാഷയെ, ടാർഗെറ്റ് ഭാഷയിലേക്ക് ഡീകോഡ് ചെയ്യാവുന്ന ഒരു ഇൻപുട്ടിലേക്ക് മാപ്പ് ചെയ്യുന്നതിനായി, ക്രമരഹിതമായി ഇനിഷ്യലൈസ് ചെയ്ത ഒരു പ്രത്യേക എൻകോഡർ കൂട്ടിച്ചേർത്താണ് BART ട്രാൻസ്ലേഷനിലേക്ക് പൊരുത്തപ്പെടുന്നത്. ഈ പുതിയ എൻകോഡറിന്റെ എംബെഡ്ഡിംഗുകൾ, യഥാർത്ഥ വേഡ് എംബെഡ്ഡിംഗുകൾക്ക് പകരം പ്രീട്രെയിൻ ചെയ്ത എൻകോഡറിലേക്ക് കൈമാറുന്നു. മോഡൽ ഔട്ട്‌പുട്ടിൽ നിന്നുള്ള ക്രോസ്-എൻട്രോപ്പി ലോസ് ഉപയോഗിച്ച് സോഴ്‌സ് എൻകോഡർ, പൊസിഷണൽ എംബെഡ്ഡിംഗുകൾ, ഇൻപുട്ട് എംബെഡ്ഡിംഗുകൾ എന്നിവ അപ്‌ഡേറ്റ് ചെയ്താണ് സോഴ്‌സ് എൻകോഡർ പരിശീലിപ്പിക്കുന്നത്. ഈ ആദ്യ ഘട്ടത്തിൽ മോഡൽ പാരാമീറ്ററുകൾ ഫ്രീസ് ചെയ്തിരിക്കും, രണ്ടാം ഘട്ടത്തിൽ എല്ലാ മോഡൽ പാരാമീറ്ററുകളും ഒരുമിച്ച് പരിശീലിപ്പിക്കുന്നു.
+പിന്നീട് BART-ന് പിന്നാലെ mBART എന്ന ഒരു ബഹുഭാഷാ പതിപ്പ് വന്നു; ട്രാൻസ്ലേഷനായി ഉദ്ദേശിച്ചുള്ളതും വ്യത്യസ്തങ്ങളായ പല ഭാഷകളിൽ പ്രീട്രെയിൻ ചെയ്തതുമാണ് അത്.
+
+ട്രാൻസ്ലേഷൻ സ്വയം പരീക്ഷിക്കാൻ തയ്യാറാണോ? T5 എങ്ങനെ ഫൈൻ-ട്യൂൻ ചെയ്യാമെന്നും ഇൻഫറൻസിനായി ഉപയോഗിക്കാമെന്നും പഠിക്കാൻ ഞങ്ങളുടെ പൂർണ്ണമായ [ട്രാൻസ്ലേഷൻ ഗൈഡ്](https://huggingface.co/docs/transformers/tasks/translation) പരിശോധിക്കുക!
+
+> [!TIP]
+> ഈ ഗൈഡിലുടനീളം നിങ്ങൾ കണ്ടതുപോലെ, വ്യത്യസ്ത ടാസ്‌കുകളെ അഭിസംബോധന ചെയ്യുന്നുണ്ടെങ്കിലും പല മോഡലുകളും സമാനമായ മാതൃകകൾ പിന്തുടരുന്നു. ഈ പൊതു മാതൃകകൾ മനസ്സിലാക്കുന്നത്, പുതിയ മോഡലുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നും നിലവിലുള്ള മോഡലുകളെ നിങ്ങളുടെ പ്രത്യേക ആവശ്യങ്ങൾക്ക് എങ്ങനെ പൊരുത്തപ്പെടുത്താം എന്നും വേഗത്തിൽ ഗ്രഹിക്കാൻ നിങ്ങളെ സഹായിക്കും.
+
+## ടെക്‌സ്‌റ്റിനപ്പുറമുള്ള മോഡാലിറ്റികൾ
+
+Transformers ടെക്‌സ്‌റ്റിൽ മാത്രം ഒതുങ്ങുന്നില്ല. സ്പീച്ച് ആൻഡ് ഓഡിയോ, ഇമേജുകൾ, വീഡിയോ പോലുള്ള മറ്റ് മോഡാലിറ്റികളിലും അവ പ്രയോഗിക്കാൻ കഴിയും. തീർച്ചയായും, ഈ കോഴ്‌സിൽ നാം ടെക്‌സ്‌റ്റിലാണ് ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നത്, എന്നാൽ മറ്റ് മോഡാലിറ്റികളെ ചുരുക്കമായി പരിചയപ്പെടുത്താം.
+
+### സ്പീച്ച് ആൻഡ് ഓഡിയോ
+
+ടെക്‌സ്‌റ്റിനെയോ ഇമേജുകളെയോ അപേക്ഷിച്ച് സവിശേഷമായ വെല്ലുവിളികൾ ഉയർത്തുന്ന സ്പീച്ച്, ഓഡിയോ ഡേറ്റ Transformer മോഡലുകൾ എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്ന് പരിശോധിച്ചുകൊണ്ട് തുടങ്ങാം.
+
+[Whisper](https://huggingface.co/docs/transformers/main/en/model_doc/whisper) 680,000 മണിക്കൂർ ലേബൽ ചെയ്ത ഓഡിയോ ഡേറ്റയിൽ പ്രീട്രെയിൻ ചെയ്ത ഒരു എൻകോഡർ-ഡീകോഡർ (സീക്വൻസ്-ടു-സീക്വൻസ്) transformer ആണ്. ഈ അളവിലുള്ള പ്രീട്രെയിനിംഗ് ഡേറ്റ, ഇംഗ്ലീഷിലും മറ്റ് പല ഭാഷകളിലുമുള്ള ഓഡിയോ ടാസ്‌കുകളിൽ സീറോ-ഷോട്ട് (zero-shot) പ്രകടനം സാധ്യമാക്കുന്നു. എൻകോഡർ പഠിച്ചെടുത്ത സ്പീച്ച് പ്രതിനിധാനങ്ങളെ, അധിക ഫൈൻ-ട്യൂണിംഗ് ഇല്ലാതെ തന്നെ ടെക്‌സ്‌റ്റ് പോലുള്ള ഉപയോഗപ്രദമായ ഔട്ട്‌പുട്ടുകളിലേക്ക് മാപ്പ് ചെയ്യാൻ ഡീകോഡർ Whisper-നെ അനുവദിക്കുന്നു. Whisper നേരിട്ട് അതേപടി പ്രവർത്തിക്കുന്നു.
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/whisper_architecture.png"/>
+</div>
+
+ഈ ഡയഗ്രം [Whisper പേപ്പറിൽ](https://huggingface.co/papers/2212.04356) നിന്നുള്ളതാണ്.
+
+ഈ മോഡലിന് രണ്ട് പ്രധാന ഘടകങ്ങളുണ്ട്:
+
+1. ഒരു **എൻകോഡർ** ഇൻപുട്ട് ഓഡിയോ പ്രോസസ്സ് ചെയ്യുന്നു. റോ ഓഡിയോ ആദ്യം ഒരു log-Mel സ്പെക്ട്രോഗ്രാമിലേക്ക് മാറ്റുന്നു. ഈ സ്പെക്ട്രോഗ്രാം പിന്നീട് ഒരു Transformer എൻകോഡർ നെറ്റ്‌വർക്കിലൂടെ കടത്തിവിടുന്നു.
+
+2. ഒരു **ഡീകോഡർ** എൻകോഡ് ചെയ്ത ഓഡിയോ പ്രതിനിധാനം സ്വീകരിച്ച്, അതിന് അനുയോജ്യമായ ടെക്‌സ്‌റ്റ് ടോക്കണുകൾ ഓട്ടോറിഗ്രസ്സീവായി (autoregressively) പ്രവചിക്കുന്നു. മുൻപുള്ള ടോക്കണുകളും എൻകോഡർ ഔട്ട്‌പുട്ടും നൽകിയാൽ അടുത്ത ടെക്‌സ്‌റ്റ് ടോക്കൺ പ്രവചിക്കാൻ പരിശീലിപ്പിച്ച ഒരു സ്റ്റാൻഡേർഡ് Transformer ഡീകോഡറാണിത്. ട്രാൻസ്ക്രിപ്ഷൻ, ട്രാൻസ്ലേഷൻ, ഭാഷ തിരിച്ചറിയൽ പോലുള്ള പ്രത്യേക ടാസ്‌കുകളിലേക്ക് മോഡലിനെ നയിക്കാൻ ഡീകോഡർ ഇൻപുട്ടിന്റെ തുടക്കത്തിൽ പ്രത്യേക ടോക്കണുകൾ ഉപയോഗിക്കുന്നു.
+
+വെബിൽ നിന്ന് ശേഖരിച്ച 680,000 മണിക്കൂർ ലേബൽ ചെയ്ത ഓഡിയോ ഡേറ്റ അടങ്ങിയ ഒരു ബൃഹത്തും വൈവിധ്യപൂർണ്ണവുമായ ഡേറ്റാസെറ്റിലാണ് Whisper പ്രീട്രെയിൻ ചെയ്തത്. വലിയ തോതിലുള്ള, ദുർബലമായി മേൽനോട്ടം വഹിക്കപ്പെട്ട (weakly supervised) ഈ പ്രീട്രെയിനിംഗാണ് പല ഭാഷകളിലും ടാസ്‌കുകളിലുമുള്ള അതിന്റെ ശക്തമായ സീറോ-ഷോട്ട് പ്രകടനത്തിന്റെ താക്കോൽ.
+
+ഇപ്പോൾ Whisper പ്രീട്രെയിൻ ചെയ്തിരിക്കുന്നതിനാൽ, സീറോ-ഷോട്ട് ഇൻഫറൻസിനായി നിങ്ങൾക്ക് അത് നേരിട്ട് ഉപയോഗിക്കാം, അല്ലെങ്കിൽ ഓട്ടോമാറ്റിക് സ്പീച്ച് റെക്കഗ്നിഷൻ അഥവാ സ്പീച്ച് ട്രാൻസ്ലേഷൻ പോലുള്ള പ്രത്യേക ടാസ്‌കുകളിൽ മെച്ചപ്പെട്ട പ്രകടനത്തിനായി നിങ്ങളുടെ ഡേറ്റയിൽ അത് ഫൈൻ-ട്യൂൻ ചെയ്യാം!
+
+> [!TIP]
+> Whisper-ന്റെ പ്രധാന നവീകരണം, ഇന്റർനെറ്റിൽ നിന്നുള്ള വൈവിധ്യപൂർണ്ണവും ദുർബലമായി മേൽനോട്ടം വഹിക്കപ്പെട്ടതുമായ ഓഡിയോ ഡേറ്റയിൽ മുമ്പെങ്ങുമില്ലാത്ത തോതിൽ നടത്തിയ പരിശീലനമാണ്. ടാസ്‌ക്-നിർദ്ദിഷ്ട ഫൈൻ-ട്യൂണിംഗ് ഇല്ലാതെ തന്നെ വ്യത്യസ്ത ഭാഷകളിലേക്കും ഉച്ചാരണരീതികളിലേക്കും ടാസ്‌കുകളിലേക്കും ശ്രദ്ധേയമായ രീതിയിൽ വ്യാപിക്കാൻ ഇത് അതിനെ അനുവദിക്കുന്നു.
+
+### ഓട്ടോമാറ്റിക് സ്പീച്ച് റെക്കഗ്നിഷൻ
+
+പ്രീട്രെയിൻ ചെയ്ത മോഡൽ ഓട്ടോമാറ്റിക് സ്പീച്ച് റെക്കഗ്നിഷനായി ഉപയോഗിക്കാൻ, അതിന്റെ പൂർണ്ണമായ എൻകോഡർ-ഡീകോഡർ ഘടന നിങ്ങൽ പ്രയോജനപ്പെടുത്തുന്നു. എൻകോഡർ ഓഡിയോ ഇൻപുട്ട് പ്രോസസ്സ് ചെയ്യുന്നു, ഡീകോഡർ ട്രാൻസ്ക്രിപ്‌റ്റ് ടോക്കൺ ടോക്കണായി ഓട്ടോറിഗ്രസ്സീവായി സൃഷ്ടിക്കുന്നു. ഫൈൻ-ട്യൂണിംഗ് ചെയ്യുമ്പോൾ, ഓഡിയോ ഇൻപുട്ടിന്റെ അടിസ്ഥാനത്തിൽ ശരിയായ ടെക്‌സ്‌റ്റ് ടോക്കണുകൾ പ്രവചിക്കാൻ ഒരു സ്റ്റാൻഡേർഡ് സീക്വൻസ്-ടു-സീക്വൻസ് ലോസ് (ക്രോസ്-എൻട്രോപ്പി പോലുള്ളത്) ഉപയോഗിച്ചാണ് മോഡൽ സാധാരണയായി പരിശീലിപ്പിക്കുന്നത്.
+
+ഫൈൻ-ട്യൂൻ ചെയ്ത ഒരു മോഡൽ ഇൻഫറൻസിനായി ഉപയോഗിക്കാനുള്ള ഏറ്റവും എളുപ്പമുള്ള മാർഗം ഒരു `pipeline`-നുള്ളിലാണ്.
+
+```python
+from transformers import pipeline
+
+transcriber = pipeline(
+    task="automatic-speech-recognition", model="openai/whisper-base.en"
+)
+transcriber("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")
+# Output: {'text': ' I have a dream that one day this nation will rise up and live out the true meaning of its creed.'}
+```
+
+ഓട്ടോമാറ്റിക് സ്പീച്ച് റെക്കഗ്നിഷൻ സ്വയം പരീക്ഷിക്കാൻ തയ്യാറാണോ? Whisper എങ്ങനെ ഫൈൻ-ട്യൂൻ ചെയ്യാമെന്നും ഇൻഫറൻസിനായി ഉപയോഗിക്കാമെന്നും പഠിക്കാൻ ഞങ്ങളുടെ പൂർണ്ണമായ [ഓട്ടോമാറ്റിക് സ്പീച്ച് റെക്കഗ്നിഷൻ ഗൈഡ്](https://huggingface.co/docs/transformers/tasks/asr) പരിശോധിക്കുക!
+
+### കമ്പ്യൂട്ടർ വിഷൻ
+
+ഇനി നമുക്ക് കമ്പ്യൂട്ടർ വിഷൻ ടാസ്‌കുകളിലേക്ക് കടക്കാം; ഇമേജുകളിൽ നിന്നോ വീഡിയോകളിൽ നിന്നോ ഉള്ള ദൃശ്യവിവരങ്ങൾ മനസ്സിലാക്കുകയും വ്യാഖ്യാനിക്കുകയും ചെയ്യുന്നതാണ് ഇവ.
+
+കമ്പ്യൂട്ടർ വിഷൻ ടാസ്‌കുകളെ സമീപിക്കാൻ രണ്ട് വഴികളുണ്ട്:
+
+1. ഒരു ഇമേജിനെ പാച്ചുകളുടെ (patches) ഒരു സീക്വൻസായി വിഭജിച്ച്, അവയെ ഒരു Transformer ഉപയോഗിച്ച് സമാന്തരമായി പ്രോസസ്സ് ചെയ്യുക.
+2. [ConvNeXT](https://huggingface.co/docs/transformers/model_doc/convnext) പോലുള്ള ഒരു ആധുനിക CNN ഉപയോഗിക്കുക; ഇത് കൺവൊല്യൂഷണൽ ലെയറുകളെ ആശ്രയിക്കുന്നു, എന്നാൽ ആധുനിക നെറ്റ്‌വർക്ക് ഡിസൈനുകൾ സ്വീകരിക്കുന്നു.
+
+> [!TIP]
+> മൂന്നാമതൊരു സമീപനം Transformers-നെ കൺവൊല്യൂഷനുകളുമായി കൂട്ടിക്കലർത്തുന്നു (ഉദാഹരണത്തിന്, [Convolutional Vision Transformer](https://huggingface.co/docs/transformers/model_doc/cvt) അല്ലെങ്കിൽ [LeViT](https://huggingface.co/docs/transformers/model_doc/levit)). നാം ഇവിടെ പരിശോധിക്കുന്ന രണ്ട് സമീപനങ്ങളെ വെറുതെ സംയോജിപ്പിക്കുന്നവയായതിനാൽ അവയെക്കുറിച്ച് നാം ചർച്ച ചെയ്യുന്നില്ല.
+
+ViT-യും ConvNeXT-ഉം സാധാരണയായി ഇമേജ് ക്ലാസിഫിക്കേഷനായി ഉപയോഗിക്കുന്നു, എന്നാൽ ഒബ്‌ജക്റ്റ് ഡിറ്റക്ഷൻ, സെഗ്‌മെന്റേഷൻ, ഡെപ്ത് എസ്റ്റിമേഷൻ പോലുള്ള മറ്റ് വിഷൻ ടാസ്‌കുകൾക്കായി നാം യഥാക്രമം DETR, Mask2Former, GLPN എന്നിവ പരിശോധിക്കും; ഈ മോഡലുകൾ ആ ടാസ്‌കുകൾക്ക് കൂടുതൽ അനുയോജ്യമാണ്.
+
+### ഇമേജ് ക്ലാസിഫിക്കേഷൻ
+
+അടിസ്ഥാന കമ്പ്യൂട്ടർ വിഷൻ ടാസ്‌കുകളിൽ ഒന്നാണ് ഇമേജ് ക്ലാസിഫിക്കേഷൻ. വ്യത്യസ്ത മോഡൽ ആർക്കിടെക്ചറുകൾ ഈ പ്രശ്നത്തെ എങ്ങനെ സമീപിക്കുന്നു എന്ന് നോക്കാം.
+
+ViT-യും ConvNeXT-ഉം രണ്ടും ഇമേജ് ക്ലാസിഫിക്കേഷനായി ഉപയോഗിക്കാം; പ്രധാന വ്യത്യാസം ViT ഒരു അറ്റൻഷൻ മെക്കാനിസം ഉപയോഗിക്കുന്നു, ConvNeXT കൺവൊല്യൂഷനുകൾ ഉപയോഗിക്കുന്നു എന്നതാണ്.
+
+[ViT](https://huggingface.co/docs/transformers/model_doc/vit) കൺവൊല്യൂഷനുകളെ പൂർണ്ണമായും ഒരു ശുദ്ധ Transformer ആർക്കിടെക്ചർ കൊണ്ട് മാറ്റിസ്ഥാപിക്കുന്നു. യഥാർത്ഥ Transformer നിങ്ങൾക്ക് പരിചിതമാണെങ്കിൽ, ViT മനസ്സിലാക്കുന്നതിലേക്കുള്ള വഴിയുടെ ഭൂരിഭാഗവും നിങ്ങൾ ഇതിനകം പിന്നിട്ടിരിക്കുന്നു.  
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/vit_architecture.jpg"/>
+</div>
+
+ViT കൊണ്ടുവന്ന പ്രധാന മാറ്റം ഇമേജുകൾ ഒരു Transformer-ലേക്ക് എങ്ങനെ നൽകുന്നു എന്നതിലാണ്:
+
+1. ഒരു ഇമേജിനെ പരസ്പരം ഓവർലാപ്പ് ചെയ്യാത്ത ചതുര പാച്ചുകളായി വിഭജിക്കുന്നു; ഇവ ഓരോന്നും ഒരു വെക്റ്ററായി അഥവാ *പാച്ച് എംബെഡ്ഡിംഗ്* ആയി മാറുന്നു. ശരിയായ ഇൻപുട്ട് ഡൈമെൻഷനുകൾ സൃഷ്ടിക്കുന്ന ഒരു കൺവൊല്യൂഷണൽ 2D ലെയറിൽ നിന്നാണ് പാച്ച് എംബെഡ്ഡിംഗുകൾ സൃഷ്ടിക്കുന്നത് (ഒരു അടിസ്ഥാന Transformer-ന് ഇത് ഓരോ പാച്ച് എംബെഡ്ഡിംഗിനും 768 മൂല്യങ്ങളാണ്). നിങ്ങൾക്ക് 224x224 പിക്‌സൽ ഇമേജ് ഉണ്ടെങ്കിൽ, അതിനെ 16x16 വലുപ്പമുള്ള 196 ഇമേജ് പാച്ചുകളായി വിഭജിക്കാം. ടെക്‌സ്‌റ്റ് വാക്കുകളായി ടോക്കണൈസ് ചെയ്യുന്നതുപോലെ, ഒരു ഇമേജ് പാച്ചുകളുടെ ഒരു സീക്വൻസായി "ടോക്കണൈസ്" ചെയ്യപ്പെടുന്നു.
+
+2. BERT-ലേതുപോലെ, ഒരു *ലേണബിൾ എംബെഡ്ഡിംഗ്* (learnable embedding) — ഒരു പ്രത്യേക `[CLS]` ടോക്കൺ — പാച്ച് എംബെഡ്ഡിംഗുകളുടെ തുടക്കത്തിൽ ചേർക്കുന്നു. `[CLS]` ടോക്കണിന്റെ അന്തിമ ഹിഡൻ സ്റ്റേറ്റ്, ഘടിപ്പിച്ചിരിക്കുന്ന ക്ലാസിഫിക്കേഷൻ ഹെഡിലേക്കുള്ള ഇൻപുട്ടായി ഉപയോഗിക്കുന്നു; മറ്റ് ഔട്ട്‌പുട്ടുകൾ അവഗണിക്കുന്നു. ഇമേജിന്റെ ഒരു പ്രതിനിധാനം എങ്ങനെ എൻകോഡ് ചെയ്യണമെന്ന് പഠിക്കാൻ ഈ ടോക്കൺ മോഡലിനെ സഹായിക്കുന്നു.
+
+3. പാച്ച് എംബെഡ്ഡിംഗുകളിലേക്കും ലേണബിൾ എംബെഡ്ഡിംഗുകളിലേക്കും അവസാനമായി ചേർക്കേണ്ടത് *പൊസിഷൻ എംബെഡ്ഡിംഗുകൾ* (position embeddings) ആണ്, കാരണം ഇമേജ് പാച്ചുകൾ എങ്ങനെയാണ് ക്രമീകരിച്ചിരിക്കുന്നത് എന്ന് മോഡലിന് അറിയില്ല. പൊസിഷൻ എംബെഡ്ഡിംഗുകളും ലേണബിൾ ആണ്, അവയ്ക്ക് പാച്ച് എംബെഡ്ഡിംഗുകളുടെ അതേ വലുപ്പമുണ്ട്. അവസാനം, എല്ലാ എംബെഡ്ഡിംഗുകളും Transformer എൻകോഡറിലേക്ക് കൈമാറുന്നു.
+
+4. ഔട്ട്‌പുട്ട് — കൃത്യമായി പറഞ്ഞാൽ `[CLS]` ടോക്കണിനൊപ്പമുള്ള ഔട്ട്‌പുട്ട് മാത്രം — ഒരു മൾട്ടിലെയർ പെർസെപ്ട്രോൺ ഹെഡിലേക്ക് (MLP) കൈമാറുന്നു. ViT-യുടെ പ്രീട്രെയിനിംഗ് ലക്ഷ്യം ലളിതമായി ക്ലാസിഫിക്കേഷനാണ്. മറ്റ് ക്ലാസിഫിക്കേഷൻ ഹെഡുകൾ പോലെ, MLP ഹെഡ് ഔട്ട്‌പുട്ടിനെ ക്ലാസ് ലേബലുകൾക്ക് മേലുള്ള ലോജിറ്റുകളാക്കി മാറ്റുകയും, ഏറ്റവും സാധ്യതയുള്ള ക്ലാസ് കണ്ടെത്താൻ ക്രോസ്-എൻട്രോപ്പി ലോസ് കണക്കാക്കുകയും ചെയ്യുന്നു.
+
+ഇമേജ് ക്ലാസിഫിക്കേഷൻ സ്വയം പരീക്ഷിക്കാൻ തയ്യാറാണോ? ViT എങ്ങനെ ഫൈൻ-ട്യൂൻ ചെയ്യാമെന്നും ഇൻഫറൻസിനായി ഉപയോഗിക്കാമെന്നും പഠിക്കാൻ ഞങ്ങളുടെ പൂർണ്ണമായ [ഇമേജ് ക്ലാസിഫിക്കേഷൻ ഗൈഡ്](https://huggingface.co/docs/transformers/tasks/image_classification) പരിശോധിക്കുക!  
+
+
+> [!TIP]
+> ViT-യും BERT-ഉം തമ്മിലുള്ള സമാന്തരം ശ്രദ്ധിക്കുക: രണ്ടും മൊത്തത്തിലുള്ള പ്രതിനിധാനം പിടിച്ചെടുക്കാൻ ഒരു പ്രത്യേക ടോക്കൺ (<code>[CLS]</code>) ഉപയോഗിക്കുന്നു, രണ്ടും അവയുടെ എംബെഡ്ഡിംഗുകളിലേക്ക് സ്ഥാന വിവരങ്ങൾ ചേർക്കുന്നു, രണ്ടും ടോക്കണുകളുടെ/പാച്ചുകളുടെ സീക്വൻസ് പ്രോസസ്സ് ചെയ്യാൻ ഒരു Transformer എൻകോഡർ ഉപയോഗിക്കുന്നു.

From 342fa8022d24c9aaeb12e6e4e428dd863e326f06 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 02:46:51 +0530
Subject: [PATCH 09/44] Add Malayalam translation of chapter1/6.mdx
 (Transformer Architectures)

---
 chapters/ml/chapter1/6.mdx | 203 +++++++++++++++++++++++++++++++++++++
 1 file changed, 203 insertions(+)
 create mode 100644 chapters/ml/chapter1/6.mdx

diff --git a/chapters/ml/chapter1/6.mdx b/chapters/ml/chapter1/6.mdx
new file mode 100644
index 000000000..5d94d809f
--- /dev/null
+++ b/chapters/ml/chapter1/6.mdx
@@ -0,0 +1,203 @@
+<CourseFloatingBanner
+    chapter={1}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+# Transformer ആർക്കിടെക്ചറുകൾ[[transformer-architectures]]
+
+മുൻ വിഭാഗങ്ങളിൽ നാം Transformer-ന്റെ പൊതുവായ ആർക്കിടെക്ചർ പരിചയപ്പെടുത്തുകയും, ഈ മോഡലുകൾ വിവിധ ടാസ്‌കുകൾ എങ്ങനെ പരിഹരിക്കുന്നു എന്ന് പരിശോധിക്കുകയും ചെയ്തു. ഇനി, Transformer മോഡലുകളുടെ മൂന്ന് പ്രധാന ആർക്കിടെക്ചർ വകഭേദങ്ങളെ കൂടുതൽ അടുത്തു നോക്കുകയും ഓരോന്നും എപ്പോൾ ഉപയോഗിക്കണം എന്ന് മനസ്സിലാക്കുകയും ചെയ്യാം. അതിനുശേഷം, ഈ ആർക്കിടെക്ചറുകൾ വ്യത്യസ്ത ഭാഷാ ടാസ്‌കുകളിൽ എങ്ങനെ പ്രയോഗിക്കുന്നു എന്ന് നോക്കാം. 
+
+ഈ വിഭാഗത്തിൽ, Transformer മോഡലുകളുടെ മൂന്ന് പ്രധാന ആർക്കിടെക്ചർ വകഭേദങ്ങളിലേക്ക് നാം ആഴത്തിൽ ഇറങ്ങുകയും ഓരോന്നും എപ്പോൾ ഉപയോഗിക്കണം എന്ന് മനസ്സിലാക്കുകയും ചെയ്യും.
+
+
+> [!TIP]
+> മിക്ക Transformer മോഡലുകളും മൂന്ന് ആർക്കിടെക്ചറുകളിൽ ഒന്ന് ഉപയോഗിക്കുന്നു എന്ന് ഓർക്കുക: എൻകോഡർ-മാത്രം (encoder-only), ഡീകോഡർ-മാത്രം (decoder-only), അല്ലെങ്കിൽ എൻകോഡർ-ഡീകോഡർ (sequence-to-sequence). ഈ വ്യത്യാസങ്ങൾ മനസ്സിലാക്കുന്നത് നിങ്ങളുടെ പ്രത്യേക ടാസ്‌കിന് അനുയോജ്യമായ മോഡൽ തിരഞ്ഞെടുക്കാൻ സഹായിക്കും.
+
+## എൻകോഡർ മോഡലുകൾ[[encoder-models]]
+
+<Youtube id="MUqNwgPjJvQ" />
+
+എൻകോഡർ മോഡലുകൾ ഒരു Transformer മോഡലിന്റെ എൻകോഡർ ഭാഗം മാത്രമാണ് ഉപയോഗിക്കുന്നത്. ഓരോ ഘട്ടത്തിലും, അറ്റൻഷൻ ലെയറുകൾക്ക് ആദ്യ വാക്യത്തിലെ എല്ലാ വാക്കുകളും ആക്‌സസ് ചെയ്യാൻ കഴിയും. ഈ മോഡലുകൾക്ക് "ദ്വിദിശ" (bi-directional) അറ്റൻഷൻ ഉണ്ടെന്ന് പൊതുവെ പറയപ്പെടുന്നു, അവയെ പലപ്പോഴും *ഓട്ടോ-എൻകോഡിംഗ് മോഡലുകൾ* (auto-encoding models) എന്ന് വിളിക്കുന്നു.
+
+ഈ മോഡലുകളുടെ പ്രീട്രെയിനിംഗ് സാധാരണയായി ഒരു നിശ്ചിത വാക്യത്തെ ഏതെങ്കിലും വിധത്തിൽ വികലമാക്കുകയും (ഉദാഹരണത്തിന്, അതിലെ ചില വാക്കുകൾ ക്രമരഹിതമായി മറച്ചുകൊണ്ട്), ആദ്യ വാക്യം കണ്ടെത്താനോ പുനർനിർമ്മിക്കാനോ മോഡലിനെ ചുമതലപ്പെടുത്തുകയും ചെയ്യുന്നതിനെ ചുറ്റിപ്പറ്റിയാണ്.
+
+വാക്യം പൂർണ്ണമായി മനസ്സിലാക്കേണ്ട ടാസ്‌കുകൾക്ക് എൻകോഡർ മോഡലുകളാണ് ഏറ്റവും അനുയോജ്യം — ഉദാഹരണത്തിന്, വാക്യ വർഗ്ഗീകരണം (sentence classification), നെയിംഡ് എന്റിറ്റി റെക്കഗ്നിഷൻ (കൂടുതൽ പൊതുവായി പറഞ്ഞാൽ വാക്ക് വർഗ്ഗീകരണം), എക്‌സ്ട്രാക്റ്റീവ് ചോദ്യോത്തരം (extractive question answering) തുടങ്ങിയവ.
+
+> [!TIP]
+> [🤗 Transformers ടാസ്‌കുകൾ എങ്ങനെ പരിഹരിക്കുന്നു](https://huggingface.co/learn/llm-course/chapter1/5) എന്ന വിഭാഗത്തിൽ കണ്ടതുപോലെ, BERT പോലുള്ള എൻകോഡർ മോഡലുകൾ ടെക്‌സ്‌റ്റ് മനസ്സിലാക്കുന്നതിൽ മികവ് പുലർത്തുന്നു, കാരണം അവയ്ക്ക് രണ്ട് ദിശകളിലുമുള്ള മുഴുവൻ സന്ദർഭവും (context) നോക്കാൻ കഴിയും. ഇൻപുട്ട് മുഴുവനായി ഗ്രഹിക്കേണ്ട ടാസ്‌കുകൾക്ക് ഇത് അവയെ ഏറ്റവും അനുയോജ്യമാക്കുന്നു.
+
+ഈ കുടുംബത്തിലെ പ്രതിനിധി മോഡലുകളിൽ ഉൾപ്പെടുന്നവ:
+
+- [BERT](https://huggingface.co/docs/transformers/model_doc/bert)
+- [DistilBERT](https://huggingface.co/docs/transformers/model_doc/distilbert)
+- [ModernBERT](https://huggingface.co/docs/transformers/en/model_doc/modernbert)
+
+## ഡീകോഡർ മോഡലുകൾ[[decoder-models]]
+
+<Youtube id="d_ixlCubqQw" />
+
+ഡീകോഡർ മോഡലുകൾ ഒരു Transformer മോഡലിന്റെ ഡീകോഡർ ഭാഗം മാത്രമാണ് ഉപയോഗിക്കുന്നത്. ഓരോ ഘട്ടത്തിലും, ഒരു നിശ്ചിത വാക്കിന് വേണ്ടി അറ്റൻഷൻ ലെയറുകൾക്ക് വാക്യത്തിൽ അതിനു മുൻപ് വരുന്ന വാക്കുകൾ മാത്രമേ ആക്‌സസ് ചെയ്യാൻ കഴിയൂ. ഈ മോഡലുകളെ പലപ്പോഴും *ഓട്ടോ-റിഗ്രസ്സീവ് മോഡലുകൾ* (auto-regressive models) എന്ന് വിളിക്കുന്നു.
+
+ഡീകോഡർ മോഡലുകളുടെ പ്രീട്രെയിനിംഗ് സാധാരണയായി വാക്യത്തിലെ അടുത്ത വാക്ക് പ്രവചിക്കുന്നതിനെ ചുറ്റിപ്പറ്റിയാണ്.
+
+ടെക്‌സ്‌റ്റ് ജനറേഷൻ ഉൾപ്പെടുന്ന ടാസ്‌കുകൾക്ക് ഈ മോഡലുകളാണ് ഏറ്റവും അനുയോജ്യം.
+
+> [!TIP]
+> GPT പോലുള്ള ഡീകോഡർ മോഡലുകൾ ഒരു സമയം ഒരു ടോക്കൺ വീതം പ്രവചിച്ച് ടെക്‌സ്‌റ്റ് ജനറേറ്റ് ചെയ്യാനാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. [🤗 Transformers ടാസ്‌കുകൾ എങ്ങനെ പരിഹരിക്കുന്നു](https://huggingface.co/learn/llm-course/chapter1/5) എന്ന വിഭാഗത്തിൽ നാം കണ്ടതുപോലെ, അവയ്ക്ക് മുൻപുള്ള ടോക്കണുകൾ മാത്രമേ കാണാൻ കഴിയൂ. ഇത് അവയെ സർഗ്ഗാത്മക ടെക്‌സ്‌റ്റ് ജനറേഷനിൽ മികച്ചതാക്കുന്നു, എന്നാൽ ദ്വിദിശ ധാരണ ആവശ്യമുള്ള ടാസ്‌കുകൾക്ക് അത്ര അനുയോജ്യമല്ലാതാക്കുന്നു.
+
+ഈ കുടുംബത്തിലെ പ്രതിനിധി മോഡലുകളിൽ ഉൾപ്പെടുന്നവ:
+
+- [Hugging Face SmolLM Series](https://huggingface.co/HuggingFaceTB/SmolLM2-1.7B-Instruct)
+- [Meta's Llama Series](https://huggingface.co/docs/transformers/en/model_doc/llama4)
+- [Google's Gemma Series](https://huggingface.co/docs/transformers/main/en/model_doc/gemma3)
+- [DeepSeek's V3](https://huggingface.co/deepseek-ai/DeepSeek-V3)
+
+### ആധുനിക ലാർജ് ലാംഗ്വേജ് മോഡലുകൾ (LLMs)
+
+മിക്ക ആധുനിക ലാർജ് ലാംഗ്വേജ് മോഡലുകളും (LLMs) ഡീകോഡർ-മാത്രം ആർക്കിടെക്ചറാണ് ഉപയോഗിക്കുന്നത്. കഴിഞ്ഞ കുറച്ച് വർഷങ്ങളിൽ ഈ മോഡലുകൾ വലിപ്പത്തിലും കഴിവുകളിലും വൻതോതിൽ വളർന്നിട്ടുണ്ട്; ഏറ്റവും വലിയ ചില മോഡലുകളിൽ നൂറുകണക്കിന് ബില്യൻ പാരാമീറ്ററുകൾ അടങ്ങിയിരിക്കുന്നു.
+
+ആധുനിക LLM-കൾ സാധാരണയായി രണ്ട് ഘട്ടങ്ങളിലായാണ് ട്രെയിൻ ചെയ്യപ്പെടുന്നത്:
+1. **പ്രീട്രെയിനിംഗ്**: വലിയ അളവിലുള്ള ടെക്‌സ്‌റ്റ് ഡേറ്റയിൽ അടുത്ത ടോക്കൺ പ്രവചിക്കാൻ മോഡൽ പഠിക്കുന്നു
+2. **ഇൻസ്ട്രക്ഷൻ ട്യൂണിംഗ്**: നിർദ്ദേശങ്ങൾ പിന്തുടരാനും സഹായകമായ പ്രതികരണങ്ങൾ ജനറേറ്റ് ചെയ്യാനും മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യപ്പെടുന്നു
+
+വിശാലമായ വിഷയങ്ങളിലും ടാസ്‌കുകളിലും മനുഷ്യസമാനമായ ടെക്‌സ്‌റ്റ് മനസ്സിലാക്കാനും ജനറേറ്റ് ചെയ്യാനും കഴിയുന്ന മോഡലുകളിലേക്ക് ഈ സമീപനം നയിച്ചു.
+
+#### ആധുനിക LLM-കളുടെ പ്രധാന കഴിവുകൾ
+
+ആധുനിക ഡീകോഡർ-അധിഷ്ഠിത LLM-കൾ ശ്രദ്ധേയമായ കഴിവുകൾ പ്രകടിപ്പിച്ചിട്ടുണ്ട്:
+
+| കഴിവ് | വിവരണം | ഉദാഹരണം |
+|------------|-------------|---------|
+| ടെക്‌സ്‌റ്റ് ജനറേഷൻ | യോജിപ്പുള്ളതും സന്ദർഭോചിതവുമായ ടെക്‌സ്‌റ്റ് സൃഷ്ടിക്കുക | ഉപന്യാസങ്ങൾ, കഥകൾ, അല്ലെങ്കിൽ ഇമെയിലുകൾ എഴുതുക |
+| സംഗ്രഹം (Summarization) | നീണ്ട ഡോക്യുമെന്റുകളെ ചെറിയ പതിപ്പുകളായി ചുരുക്കുക | റിപ്പോർട്ടുകളുടെ എക്‌സിക്യൂട്ടീവ് സംഗ്രഹങ്ങൾ തയ്യാറാക്കുക |
+| വിവർത്തനം | ടെക്‌സ്‌റ്റ് ഒരു ഭാഷയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് മാറ്റുക | ഇംഗ്ലീഷിൽ നിന്ന് സ്പാനിഷിലേക്ക് വിവർത്തനം ചെയ്യുക |
+| ചോദ്യോത്തരം | വസ്തുതാപരമായ ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുക | "ഫ്രാൻസിന്റെ തലസ്ഥാനം ഏതാണ്?" |
+| കോഡ് ജനറേഷൻ | കോഡ് സ്‌നിപ്പെറ്റുകൾ എഴുതുകയോ പൂർത്തിയാക്കുകയോ ചെയ്യുക | ഒരു വിവരണത്തെ അടിസ്ഥാനമാക്കി ഒരു ഫംഗ്‌ഷൻ എഴുതുക |
+| യുക്തിചിന്ത (Reasoning) | പ്രശ്നങ്ങൾ ഘട്ടം ഘട്ടമായി പരിഹരിക്കുക | ഗണിത പ്രശ്നങ്ങളോ ലോജിക്കൽ പസിലുകളോ പരിഹരിക്കുക |
+| ഫ്യൂ-ഷോട്ട് ലേണിംഗ് | പ്രോംപ്‌റ്റിലെ ഏതാനും ഉദാഹരണങ്ങളിൽ നിന്ന് പഠിക്കുക | 2-3 ഉദാഹരണങ്ങൾ മാത്രം കണ്ടതിനുശേഷം ടെക്‌സ്‌റ്റ് വർഗ്ഗീകരിക്കുക |
+
+Hub-ലെ മോഡൽ റിപ്പോ പേജുകൾ വഴി നിങ്ങളുടെ ബ്രൗസറിൽ നേരിട്ട് ഡീകോഡർ-അധിഷ്ഠിത LLM-കൾ പരീക്ഷിച്ചു നോക്കാം. ക്ലാസിക് [GPT-2](https://huggingface.co/openai-community/gpt2) (OpenAI-യുടെ ഏറ്റവും മികച്ച ഓപ്പൺ സോഴ്‌സ് മോഡൽ!) ഉപയോഗിച്ചുള്ള ഒരു ഉദാഹരണം ഇതാ:
+
+<a 
+  href="https://huggingface.co/openai-community/gpt2" target="_blank">
+  GPT-2 മോഡൽ Hugging Face-ൽ കാണുക
+</a>
+
+## Sequence-to-sequence മോഡലുകൾ[[sequence-to-sequence-models]]
+
+<Youtube id="0_4KEb08xrE" />
+
+എൻകോഡർ-ഡീകോഡർ മോഡലുകൾ (*sequence-to-sequence മോഡലുകൾ* എന്നും വിളിക്കപ്പെടുന്നു) Transformer ആർക്കിടെക്ചറിന്റെ രണ്ട് ഭാഗങ്ങളും ഉപയോഗിക്കുന്നു. ഓരോ ഘട്ടത്തിലും, എൻകോഡറിന്റെ അറ്റൻഷൻ ലെയറുകൾക്ക് ആദ്യ വാക്യത്തിലെ എല്ലാ വാക്കുകളും ആക്‌സസ് ചെയ്യാൻ കഴിയും, അതേസമയം ഡീകോഡറിന്റെ അറ്റൻഷൻ ലെയറുകൾക്ക് ഇൻപുട്ടിൽ ഒരു നിശ്ചിത വാക്കിന് മുൻപ് വരുന്ന വാക്കുകൾ മാത്രമേ ആക്‌സസ് ചെയ്യാൻ കഴിയൂ.
+
+ഈ മോഡലുകളുടെ പ്രീട്രെയിനിംഗ് വ്യത്യസ്ത രൂപങ്ങളിൽ ആകാം, എന്നാൽ പലപ്പോഴും ഇൻപുട്ട് ഏതെങ്കിലും വിധത്തിൽ വികലമാക്കപ്പെട്ട (ഉദാഹരണത്തിന്, ക്രമരഹിതമായ വാക്കുകൾ മറച്ചുകൊണ്ട്) ഒരു വാക്യം പുനർനിർമ്മിക്കുന്നത് അതിൽ ഉൾപ്പെടുന്നു. T5 മോഡലിന്റെ പ്രീട്രെയിനിംഗിൽ, ടെക്‌സ്‌റ്റിലെ ക്രമരഹിതമായ ഭാഗങ്ങളെ (നിരവധി വാക്കുകൾ അടങ്ങിയവയാകാം) ഒരൊറ്റ മാസ്‌ക് സ്‌പെഷ്യൽ ടോക്കൺ കൊണ്ട് പകരം വയ്ക്കുന്നു; ആ മാസ്‌ക് ടോക്കൺ മറച്ച ടെക്‌സ്‌റ്റ് പ്രവചിക്കുകയാണ് പിന്നീടുള്ള ടാസ്‌ക്.
+
+ഒരു നിശ്ചിത ഇൻപുട്ടിനെ ആശ്രയിച്ച് പുതിയ വാക്യങ്ങൾ ജനറേറ്റ് ചെയ്യുന്ന ടാസ്‌കുകൾക്ക് sequence-to-sequence മോഡലുകളാണ് ഏറ്റവും അനുയോജ്യം — ഉദാഹരണത്തിന്, സംഗ്രഹം, വിവർത്തനം, അല്ലെങ്കിൽ ജനറേറ്റീവ് ചോദ്യോത്തരം.
+
+> [!TIP]
+> [🤗 Transformers ടാസ്‌കുകൾ എങ്ങനെ പരിഹരിക്കുന്നു](https://huggingface.co/learn/llm-course/chapter1/5) എന്ന വിഭാഗത്തിൽ കണ്ടതുപോലെ, BART, T5 പോലുള്ള എൻകോഡർ-ഡീകോഡർ മോഡലുകൾ രണ്ട് ആർക്കിടെക്ചറുകളുടെയും ശക്തികൾ സംയോജിപ്പിക്കുന്നു. എൻകോഡർ ഇൻപുട്ടിനെക്കുറിച്ച് ആഴത്തിലുള്ള ദ്വിദിശ ധാരണ നൽകുന്നു, അതേസമയം ഡീകോഡർ അനുയോജ്യമായ ഔട്ട്‌പുട്ട് ടെക്‌സ്‌റ്റ് ജനറേറ്റ് ചെയ്യുന്നു. വിവർത്തനം അല്ലെങ്കിൽ സംഗ്രഹം പോലെ, ഒരു സീക്വൻസിനെ മറ്റൊന്നാക്കി മാറ്റുന്ന ടാസ്‌കുകൾക്ക് ഇത് അവയെ ഏറ്റവും അനുയോജ്യമാക്കുന്നു.
+
+### പ്രായോഗിക ഉപയോഗങ്ങൾ
+
+അർത്ഥം നിലനിർത്തിക്കൊണ്ട് ടെക്‌സ്‌റ്റിന്റെ ഒരു രൂപത്തെ മറ്റൊന്നാക്കി മാറ്റേണ്ട ടാസ്‌കുകളിൽ sequence-to-sequence മോഡലുകൾ മികവ് പുലർത്തുന്നു. ചില പ്രായോഗിക ഉപയോഗങ്ങൾ ഇവയാണ്:
+
+| ഉപയോഗം | വിവരണം | ഉദാഹരണ മോഡൽ |
+|-------------|-------------|---------------|
+| മെഷീൻ ട്രാൻസ്‌ലേഷൻ | ടെക്‌സ്‌റ്റ് ഒരു ഭാഷയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് മാറ്റുക | Marian, T5 |
+| ടെക്‌സ്‌റ്റ് സംഗ്രഹം | നീണ്ട ടെക്‌സ്‌റ്റുകളുടെ സംക്ഷിപ്ത സംഗ്രഹങ്ങൾ തയ്യാറാക്കുക | BART, T5 |
+| ഡേറ്റയിൽ നിന്ന് ടെക്‌സ്‌റ്റ് ജനറേഷൻ | ഘടനാപരമായ ഡേറ്റയെ സ്വാഭാവിക ഭാഷയാക്കി മാറ്റുക | T5 |
+| വ്യാകരണ തിരുത്തൽ | ടെക്‌സ്‌റ്റിലെ വ്യാകരണ പിശകുകൾ തിരുത്തുക | T5 |
+| ചോദ്യോത്തരം | സന്ദർഭത്തെ അടിസ്ഥാനമാക്കി ഉത്തരങ്ങൾ ജനറേറ്റ് ചെയ്യുക | BART, T5 |
+
+വിവർത്തനത്തിനുള്ള ഒരു sequence-to-sequence മോഡലിന്റെ ഇന്ററാക്ടീവ് ഡെമോ ഇതാ:
+
+<iframe
+	src="https://course-demos-speech-to-speech-translation.hf.space"
+	frameborder="0"
+	width="850"
+	height="450"
+></iframe>
+
+ഈ കുടുംബത്തിലെ പ്രതിനിധി മോഡലുകളിൽ ഉൾപ്പെടുന്നവ:
+
+- [BART](https://huggingface.co/docs/transformers/model_doc/bart)
+- [mBART](https://huggingface.co/docs/transformers/model_doc/mbart)
+- [Marian](https://huggingface.co/docs/transformers/model_doc/marian)
+- [T5](https://huggingface.co/docs/transformers/model_doc/t5)
+
+## അനുയോജ്യമായ ആർക്കിടെക്ചർ തിരഞ്ഞെടുക്കൽ[[choosing-the-right-architecture]]
+
+ഒരു പ്രത്യേക NLP ടാസ്‌കിൽ പ്രവർത്തിക്കുമ്പോൾ, ഏത് ആർക്കിടെക്ചർ ഉപയോഗിക്കണം എന്ന് നിങ്ങൾ എങ്ങനെ തീരുമാനിക്കും? ഒരു ദ്രുത ഗൈഡ് ഇതാ:
+
+| ടാസ്‌ക് | നിർദ്ദേശിക്കുന്ന ആർക്കിടെക്ചർ | ഉദാഹരണങ്ങൾ |
+|------|------------------------|----------|
+| ടെക്‌സ്‌റ്റ് വർഗ്ഗീകരണം (വികാരം, വിഷയം) | എൻകോഡർ | BERT, RoBERTa |
+| ടെക്‌സ്‌റ്റ് ജനറേഷൻ (സർഗ്ഗാത്മക രചന) | ഡീകോഡർ | GPT, LLaMA |
+| വിവർത്തനം | എൻകോഡർ-ഡീകോഡർ | T5, BART |
+| സംഗ്രഹം | എൻകോഡർ-ഡീകോഡർ | BART, T5 |
+| നെയിംഡ് എന്റിറ്റി റെക്കഗ്നിഷൻ | എൻകോഡർ | BERT, RoBERTa |
+| ചോദ്യോത്തരം (എക്‌സ്ട്രാക്റ്റീവ്) | എൻകോഡർ | BERT, RoBERTa |
+| ചോദ്യോത്തരം (ജനറേറ്റീവ്) | എൻകോഡർ-ഡീകോഡർ അല്ലെങ്കിൽ ഡീകോഡർ | T5, GPT |
+| സംഭാഷണ AI | ഡീകോഡർ | GPT, LLaMA |
+
+> [!TIP]
+> ഏത് മോഡൽ ഉപയോഗിക്കണം എന്ന് സംശയമുണ്ടെങ്കിൽ, ഇവ പരിഗണിക്കുക:  
+>
+> 1. നിങ്ങളുടെ ടാസ്‌കിന് ഏത് തരത്തിലുള്ള ധാരണയാണ് വേണ്ടത്? (ദ്വിദിശയോ ഏകദിശയോ)  
+> 2. നിങ്ങൾ പുതിയ ടെക്‌സ്‌റ്റ് ജനറേറ്റ് ചെയ്യുകയാണോ, അതോ നിലവിലുള്ള ടെക്‌സ്‌റ്റ് വിശകലനം ചെയ്യുകയാണോ?  
+> 3. ഒരു സീക്വൻസിനെ മറ്റൊന്നാക്കി മാറ്റേണ്ടതുണ്ടോ?  
+>
+> ഈ ചോദ്യങ്ങളുടെ ഉത്തരങ്ങൾ നിങ്ങളെ അനുയോജ്യമായ ആർക്കിടെക്ചറിലേക്ക് നയിക്കും. 
+
+## LLM-കളുടെ പരിണാമം
+
+സമീപ വർഷങ്ങളിൽ ലാർജ് ലാംഗ്വേജ് മോഡലുകൾ അതിവേഗം പരിണമിച്ചിട്ടുണ്ട്; ഓരോ തലമുറയും കഴിവുകളിൽ ഗണ്യമായ പുരോഗതി കൊണ്ടുവന്നിട്ടുണ്ട്. 
+
+## അറ്റൻഷൻ മെക്കാനിസങ്ങൾ[[attention-mechanisms]]
+
+മിക്ക transformer മോഡലുകളും പൂർണ്ണ അറ്റൻഷൻ (full attention) ഉപയോഗിക്കുന്നു — അതായത്, അറ്റൻഷൻ മാട്രിക്‌സ് ചതുരാകൃതിയിലുള്ളതാണ്. നീണ്ട ടെക്‌സ്‌റ്റുകൾ ഉള്ളപ്പോൾ ഇത് ഒരു വലിയ
+കമ്പ്യൂട്ടേഷണൽ തടസ്സമായി (bottleneck) മാറാം. Longformer, Reformer എന്നിവ കൂടുതൽ കാര്യക്ഷമമാകാൻ ശ്രമിക്കുന്ന മോഡലുകളാണ്; ട്രെയിനിംഗ് വേഗത്തിലാക്കാൻ അവ
+അറ്റൻഷൻ മാട്രിക്‌സിന്റെ ഒരു സ്‌പാഴ്‌സ് (sparse) പതിപ്പ് ഉപയോഗിക്കുന്നു.
+
+> [!TIP]
+> സാധാരണ അറ്റൻഷൻ മെക്കാനിസങ്ങൾക്ക് O(n²) കമ്പ്യൂട്ടേഷണൽ കോംപ്ലക്‌സിറ്റിയാണ് ഉള്ളത്, ഇവിടെ n എന്നത് സീക്വൻസിന്റെ നീളമാണ്. വളരെ നീണ്ട സീക്വൻസുകൾക്ക് ഇത് പ്രശ്നമാകുന്നു. താഴെ പറയുന്ന പ്രത്യേക അറ്റൻഷൻ മെക്കാനിസങ്ങൾ ഈ പരിമിതി പരിഹരിക്കാൻ സഹായിക്കുന്നു.
+
+### LSH അറ്റൻഷൻ
+
+[Reformer](https://huggingface.co/docs/transformers/model_doc/reformer) LSH അറ്റൻഷൻ ഉപയോഗിക്കുന്നു. softmax(QK^t)-ൽ, QK^t മാട്രിക്‌സിലെ ഏറ്റവും വലിയ ഘടകങ്ങൾ (softmax ഡൈമെൻഷനിൽ) മാത്രമേ ഉപയോഗപ്രദമായ സംഭാവനകൾ നൽകുകയുള്ളൂ. അതിനാൽ Q-യിലെ ഓരോ ക്വറി q-നും, q-നോട് അടുത്തുനിൽക്കുന്ന
+K-യിലെ കീകൾ k മാത്രം പരിഗണിച്ചാൽ മതി. q-യും k-യും അടുത്താണോ എന്ന് നിർണ്ണയിക്കാൻ ഒരു ഹാഷ് ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നു. നിലവിലെ ടോക്കണെ മറയ്ക്കാൻ (ആദ്യ സ്ഥാനത്തൊഴികെ) അറ്റൻഷൻ മാസ്‌ക്
+പരിഷ്‌കരിക്കുന്നു, കാരണം അത് തുല്യമായ (അതിനാൽ പരസ്‌പരം വളരെ സാമ്യമുള്ള) ഒരു ക്വറിയും കീയും നൽകും. ഹാഷ് അൽപ്പം ക്രമരഹിതമാകാമെന്നതിനാൽ, പ്രായോഗികമായി നിരവധി ഹാഷ് ഫംഗ്‌ഷനുകൾ
+(ഒരു n_rounds പാരാമീറ്റർ കൊണ്ട് നിർണ്ണയിക്കപ്പെടുന്നു) ഉപയോഗിക്കുകയും പിന്നീട് അവയുടെ ശരാശരി എടുക്കുകയും ചെയ്യുന്നു.
+
+### ലോക്കൽ അറ്റൻഷൻ
+
+[Longformer](https://huggingface.co/docs/transformers/model_doc/longformer) ലോക്കൽ അറ്റൻഷൻ ഉപയോഗിക്കുന്നു: പലപ്പോഴും, ഒരു നിശ്ചിത ടോക്കണിന് വേണ്ടി തീരുമാനമെടുക്കാൻ ലോക്കൽ സന്ദർഭം (ഉദാ., ഇടത്തും വലത്തുമുള്ള രണ്ട് ടോക്കണുകൾ ഏതൊക്കെയാണ്?) മതിയാകും. കൂടാതെ, ചെറിയ വിൻഡോയുള്ള അറ്റൻഷൻ ലെയറുകൾ
+അടുക്കി വയ്ക്കുന്നതിലൂടെ, അവസാന ലെയറിന് വിൻഡോയിലെ ടോക്കണുകളെക്കാൾ വിശാലമായ ഒരു റിസപ്‌റ്റീവ് ഫീൽഡ് ലഭിക്കും, ഇത് വാക്യം മുഴുവന്റെയും ഒരു
+പ്രതിനിധാനം (representation) നിർമ്മിക്കാൻ അവയെ അനുവദിക്കുന്നു.
+
+മുൻകൂട്ടി തിരഞ്ഞെടുത്ത ചില ഇൻപുട്ട് ടോക്കണുകൾക്ക് ഗ്ലോബൽ അറ്റൻഷനും നൽകുന്നു: ആ ചുരുക്കം ടോക്കണുകൾക്ക്, അറ്റൻഷൻ മാട്രിക്‌സിന്
+എല്ലാ ടോക്കണുകളും ആക്‌സസ് ചെയ്യാൻ കഴിയും, ഈ പ്രക്രിയ സമമിതമാണ് (symmetric): മറ്റെല്ലാ ടോക്കണുകൾക്കും (അവയുടെ ലോക്കൽ വിൻഡോയിലുള്ളവയ്ക്ക് പുറമേ) ആ പ്രത്യേക ടോക്കണുകളിലേക്ക്
+ആക്‌സസ് ഉണ്ട്. ഇത് പേപ്പറിലെ Figure 2d-ൽ കാണിച്ചിരിക്കുന്നു; ഒരു മാതൃകാ അറ്റൻഷൻ മാസ്‌ക് താഴെ കാണുക:
+
+<div class="flex justify-center">
+    <img scale="50 %" align="center" src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/local_attention_mask.png"/>
+</div>
+
+കുറഞ്ഞ പാരാമീറ്ററുകളുള്ള ഈ അറ്റൻഷൻ മാട്രിക്‌സുകൾ ഉപയോഗിക്കുന്നത്, കൂടുതൽ നീളമുള്ള സീക്വൻസുകൾ ഇൻപുട്ടായി സ്വീകരിക്കാൻ
+മോഡലിനെ പ്രാപ്‌തമാക്കുന്നു.
+
+### ആക്‌സിയൽ പൊസിഷണൽ എൻകോഡിംഗുകൾ
+
+[Reformer](https://huggingface.co/docs/transformers/model_doc/reformer) ആക്‌സിയൽ പൊസിഷണൽ എൻകോഡിംഗുകൾ (axial positional encodings) ഉപയോഗിക്കുന്നു: പരമ്പരാഗത transformer മോഡലുകളിൽ, പൊസിഷണൽ എൻകോഡിംഗ്
+E എന്നത് \\(l\\) x \\(d\\) വലിപ്പമുള്ള ഒരു മാട്രിക്‌സാണ്, ഇവിടെ \\(l\\) സീക്വൻസിന്റെ നീളവും \\(d\\) ഹിഡൻ സ്‌റ്റേറ്റിന്റെ
+ഡൈമെൻഷനുമാണ്. വളരെ നീണ്ട ടെക്‌സ്‌റ്റുകൾ ഉണ്ടെങ്കിൽ, ഈ മാട്രിക്‌സ് വളരെ വലുതാകുകയും GPU-വിൽ അമിതമായ സ്ഥലം എടുക്കുകയും ചെയ്യാം. ഇത് ലഘൂകരിക്കാൻ,
+ആക്‌സിയൽ പൊസിഷണൽ എൻകോഡിംഗുകൾ ആ വലിയ മാട്രിക്‌സ് E-യെ E1, E2 എന്നീ രണ്ട് ചെറിയ മാട്രിക്‌സുകളായി ഫാക്ടറൈസ് ചെയ്യുന്നു; ഇവയുടെ
+ഡൈമെൻഷനുകൾ \\(l_{1} \times d_{1}\\) ഉം \\(l_{2} \times d_{2}\\) ഉം ആണ്, അതായത് \\(l_{1} \times l_{2} = l\\) ഉം
+\\(d_{1} + d_{2} = d\\) ഉം (നീളങ്ങളുടെ ഗുണനഫലം കാരണം, ഇത് വളരെ ചെറുതായിത്തീരുന്നു). E-യിലെ ടൈം സ്‌റ്റെപ്പ് \\(j\\)-യുടെ
+എംബെഡ്ഡിംഗ്, E1-ലെ ടൈംസ്‌റ്റെപ്പ് \\(j \% l1\\)-ന്റെയും E2-ലെ \\(j // l1\\)-ന്റെയും എംബെഡ്ഡിംഗുകൾ
+കൂട്ടിച്ചേർത്ത് (concatenate) ലഭിക്കുന്നു.
+
+## ഉപസംഹാരം[[conclusion]]
+
+ഈ വിഭാഗത്തിൽ, മൂന്ന് പ്രധാന Transformer ആർക്കിടെക്ചറുകളും ചില പ്രത്യേക അറ്റൻഷൻ മെക്കാനിസങ്ങളും നാം പരിശോധിച്ചു. നിങ്ങളുടെ പ്രത്യേക NLP ടാസ്‌കിന് അനുയോജ്യമായ മോഡൽ തിരഞ്ഞെടുക്കാൻ ഈ ആർക്കിടെക്ചർ വ്യത്യാസങ്ങൾ മനസ്സിലാക്കുന്നത് നിർണ്ണായകമാണ്.
+
+കോഴ്‌സിൽ മുന്നോട്ട് പോകുമ്പോൾ, ഈ വ്യത്യസ്ത ആർക്കിടെക്ചറുകളുമായി നിങ്ങൾക്ക് പ്രായോഗിക പരിചയം ലഭിക്കുകയും, നിങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുസരിച്ച് അവയെ എങ്ങനെ ഫൈൻ-ട്യൂൺ ചെയ്യാമെന്ന് പഠിക്കുകയും ചെയ്യും. അടുത്ത വിഭാഗത്തിൽ, ഈ മോഡലുകൾ വിന്യസിക്കുമ്പോൾ (deploy) നിങ്ങൾ അറിഞ്ഞിരിക്കേണ്ട ചില പരിമിതികളും പക്ഷപാതങ്ങളും (biases) നാം പരിശോധിക്കും.

From a1a50d5e29c6ccc8824dadc6cce82ec094a3544d Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 02:58:13 +0530
Subject: [PATCH 10/44] Add ungraded quiz for Chapter 1

This file introduces an ungraded quiz for Chapter 1, containing questions related to the Transformers library and its functionalities, specifically focusing on models and their applications.
---
 chapters/ml/chapter1/7.mdx | 257 +++++++++++++++++++++++++++++++++++++
 1 file changed, 257 insertions(+)
 create mode 100644 chapters/ml/chapter1/7.mdx

diff --git a/chapters/ml/chapter1/7.mdx b/chapters/ml/chapter1/7.mdx
new file mode 100644
index 000000000..f7201b057
--- /dev/null
+++ b/chapters/ml/chapter1/7.mdx
@@ -0,0 +1,257 @@
+<!-- DISABLE-FRONTMATTER-SECTIONS -->
+
+# ഗ്രേഡ് ഇല്ലാത്ത ക്വിസ്[[ungraded-quiz]]
+
+<CourseFloatingBanner
+    chapter={1}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+ഇതുവരെ, ഈ അധ്യായം ഒട്ടേറെ കാര്യങ്ങൾ കൈകാര്യം ചെയ്തു! എല്ലാ വിശദാംശങ്ങളും പിടികിട്ടിയില്ലെങ്കിൽ വിഷമിക്കേണ്ട; ഇതുവരെ പഠിച്ചത് ഒരു ക്വിസിലൂടെ ഒന്ന് ഓർത്തുനോക്കാനുള്ള അവസരമാണിത്. 
+
+ഈ ക്വിസിന് ഗ്രേഡ് ഇല്ല, അതിനാൽ എത്ര തവണ വേണമെങ്കിലും നിങ്ങൾക്ക് ഇത് ചെയ്യാം. ചില ചോദ്യങ്ങളിൽ ബുദ്ധിമുട്ട് തോന്നിയാൽ, നൽകിയിരിക്കുന്ന സൂചനകൾ പിന്തുടർന്ന് പാഠഭാഗം വീണ്ടും വായിക്കുക. സർട്ടിഫിക്കേഷൻ പരീക്ഷയിൽ ഈ വിഷയങ്ങളെക്കുറിച്ച് വീണ്ടും ചോദ്യങ്ങളുണ്ടാകും.
+
+### 1. Hub-ൽ പരതി `roberta-large-mnli` ചെക്ക്‌പോയിന്റ് കണ്ടെത്തുക. അത് ഏത് ടാസ്‌ക് ആണ് ചെയ്യുന്നത്?
+
+
+<Question
+	choices={[
+		{
+			text: "സംഗ്രഹം (Summarization)",
+			explain: "<a href=\"https://huggingface.co/roberta-large-mnli\">roberta-large-mnli പേജ്</a> ഒന്നുകൂടി നോക്കുക."
+		},
+		{
+			text: "ടെക്‌സ്‌റ്റ് വർഗ്ഗീകരണം (Text classification)",
+			explain: "കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, രണ്ട് വാക്യങ്ങൾ യുക്തിപരമായി ബന്ധപ്പെട്ടിരിക്കുന്നുണ്ടോ എന്ന് മൂന്ന് ലേബലുകളിലായി (contradiction, neutral, entailment) ഇത് വർഗ്ഗീകരിക്കുന്നു — ഈ ടാസ്‌കിനെ <em>natural language inference</em> എന്നും വിളിക്കുന്നു.",
+			correct: true
+		},
+		{
+			text: "ടെക്‌സ്‌റ്റ് ജനറേഷൻ (Text generation)",
+			explain: "<a href=\"https://huggingface.co/roberta-large-mnli\">roberta-large-mnli പേജ്</a> ഒന്നുകൂടി നോക്കുക."
+		}
+	]}
+/>
+
+### 2. താഴെ കൊടുത്ത കോഡ് എന്ത് റിട്ടേൺ ചെയ്യും?
+
+```py
+from transformers import pipeline
+
+ner = pipeline("ner", aggregation_strategy="simple")
+ner("My name is Sylvain and I work at Hugging Face in Brooklyn.")
+```
+
+<Question
+	choices={[
+		{
+			text: "ഈ വാക്യത്തിന് \"positive\" അല്ലെങ്കിൽ \"negative\" എന്ന ലേബലുകളോടെ വർഗ്ഗീകരണ സ്‌കോറുകൾ റിട്ടേൺ ചെയ്യും.",
+			explain: "ഇത് തെറ്റാണ് — അത് ഒരു <code>sentiment-analysis</code> പൈപ്പ്‌ലൈൻ ആയിരിക്കും."
+		},
+		{
+			text: "ഈ വാക്യം പൂർത്തിയാക്കുന്ന ഒരു ജനറേറ്റ് ചെയ്ത ടെക്‌സ്‌റ്റ് റിട്ടേൺ ചെയ്യും.",
+			explain: "ഇത് തെറ്റാണ് — അത് ഒരു <code>text-generation</code> പൈപ്പ്‌ലൈൻ ആയിരിക്കും.",
+		},
+		{
+			text: "വ്യക്തികളെയോ സ്ഥാപനങ്ങളെയോ സ്ഥലങ്ങളെയോ സൂചിപ്പിക്കുന്ന വാക്കുകൾ റിട്ടേൺ ചെയ്യും.",
+			explain: "കൂടാതെ, <code>aggregation_strategy=&quot;simple&quot;</code> ഉപയോഗിക്കുന്നതിനാൽ, \"Hugging Face\" പോലെ ഒരേ എന്റിറ്റിയിൽ പെടുന്ന വാക്കുകളെ ഇത് ഒരുമിച്ച് ഗ്രൂപ്പ് ചെയ്യും.",
+			correct: true
+		}
+	]}
+/>
+
+### 3. ഈ കോഡ് സാമ്പിളിൽ ... എന്നതിന്റെ സ്ഥാനത്ത് എന്ത് വരണം?
+
+```py
+from transformers import pipeline
+
+filler = pipeline("fill-mask", model="bert-base-cased")
+result = filler("...")
+```
+
+<Question
+	choices={[
+		{
+			text: "This &#60;mask> has been waiting for you.",
+			explain: "ഇത് തെറ്റാണ്. <code>bert-base-cased</code> മോഡൽ കാർഡ് പരിശോധിച്ച് നിങ്ങളുടെ തെറ്റ് കണ്ടെത്താൻ ശ്രമിക്കുക."
+		},
+		{
+			text: "This [MASK] has been waiting for you.",
+			explain: "ഈ മോഡലിന്റെ മാസ്‌ക് ടോക്കൺ [MASK] ആണ്.",
+			correct: true
+		},
+		{
+			text: "This man has been waiting for you.",
+			explain: "ഇത് തെറ്റാണ്. ഈ പൈപ്പ്‌ലൈൻ മറച്ചുവെച്ച വാക്കുകൾ പൂരിപ്പിക്കുന്നതാണ്, അതിനാൽ എവിടെയെങ്കിലും ഒരു മാസ്‌ക് ടോക്കൺ ആവശ്യമാണ്."
+		}
+	]}
+/>
+
+### 4. ഈ കോഡ് എന്തുകൊണ്ട് പരാജയപ്പെടും?
+
+```py
+from transformers import pipeline
+
+classifier = pipeline("zero-shot-classification")
+result = classifier("This is a course about the Transformers library")
+```
+
+<Question
+	choices={[
+		{
+			text: "ഈ ടെക്‌സ്‌റ്റ് വർഗ്ഗീകരിക്കാൻ ലേബലുകൾ നൽകണമെന്ന് ഈ പൈപ്പ്‌ലൈൻ ആവശ്യപ്പെടുന്നു.",
+			explain: "ശരിയാണ് — ശരിയായ കോഡിൽ <code>candidate_labels=[...]</code> ഉൾപ്പെടുത്തേണ്ടതുണ്ട്.",
+			correct: true
+		},
+		{
+			text: "ഈ പൈപ്പ്‌ലൈനിന് ഒന്നല്ല, നിരവധി വാക്യങ്ങൾ ആവശ്യമാണ്.",
+			explain: "ഇത് തെറ്റാണ്; എന്നാൽ ശരിയായി ഉപയോഗിക്കുമ്പോൾ, (മറ്റെല്ലാ പൈപ്പ്‌ലൈനുകളെയും പോലെ) ഈ പൈപ്പ്‌ലൈനിനും പ്രോസസ്സ് ചെയ്യാൻ വാക്യങ്ങളുടെ ഒരു ലിസ്‌റ്റ് സ്വീകരിക്കാൻ കഴിയും."
+		},
+		{
+			text: "🤗 Transformers ലൈബ്രറി, പതിവുപോലെ, തകരാറിലാണ്.",
+			explain: "ഈ ഉത്തരത്തിന് ഒരു അഭിപ്രായം പറഞ്ഞ് ഞങ്ങൾ മാന്യത നൽകുന്നില്ല!"
+		},
+		{
+			text: "ഈ പൈപ്പ്‌ലൈനിന് കൂടുതൽ നീളമുള്ള ഇൻപുട്ടുകൾ ആവശ്യമാണ്; ഇത് വളരെ ചെറുതാണ്.",
+			explain: "ഇത് തെറ്റാണ്. വളരെ നീണ്ട ഒരു ടെക്‌സ്‌റ്റ് ഈ പൈപ്പ്‌ലൈൻ പ്രോസസ്സ് ചെയ്യുമ്പോൾ അത് വെട്ടിച്ചുരുക്കപ്പെടും (truncate) എന്ന് ശ്രദ്ധിക്കുക."
+		}
+	]}
+/>
+
+### 5. "ട്രാൻസ്‌ഫർ ലേണിംഗ്" (transfer learning) എന്നാൽ എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "ഒരു പ്രീട്രെയിൻഡ് മോഡലിന്റെ അറിവ്, അതേ ഡേറ്റാസെറ്റിൽ ട്രെയിൻ ചെയ്തുകൊണ്ട് ഒരു പുതിയ മോഡലിലേക്ക് കൈമാറുക.",
+			explain: "അല്ല, അത് ഒരേ മോഡലിന്റെ രണ്ട് പതിപ്പുകളായിരിക്കും."
+		},
+		{
+			text: "ഒരു പ്രീട്രെയിൻഡ് മോഡലിന്റെ അറിവ്, രണ്ടാമത്തെ മോഡലിനെ ആദ്യ മോഡലിന്റെ വെയ്‌റ്റുകൾ കൊണ്ട് ഇനിഷ്യലൈസ് ചെയ്യുന്നതിലൂടെ ഒരു പുതിയ മോഡലിലേക്ക് കൈമാറുക.",
+			explain: "രണ്ടാമത്തെ മോഡൽ ഒരു പുതിയ ടാസ്‌കിൽ ട്രെയിൻ ചെയ്യപ്പെടുമ്പോൾ, അത് ആദ്യ മോഡലിന്റെ അറിവ് *കൈമാറുന്നു*.",
+			correct: true
+		},
+		{
+			text: "ഒരു പ്രീട്രെയിൻഡ് മോഡലിന്റെ അറിവ്, രണ്ടാമത്തെ മോഡലിനെ ആദ്യ മോഡലിന്റെ അതേ ആർക്കിടെക്ചറിൽ നിർമ്മിക്കുന്നതിലൂടെ ഒരു പുതിയ മോഡലിലേക്ക് കൈമാറുക.",
+			explain: "ആർക്കിടെക്ചർ എന്നത് മോഡൽ നിർമ്മിച്ചിരിക്കുന്ന രീതി മാത്രമാണ്; ഈ സാഹചര്യത്തിൽ അറിവ് പങ്കുവയ്ക്കപ്പെടുകയോ കൈമാറപ്പെടുകയോ ചെയ്യുന്നില്ല."
+		}
+	]}
+/>
+
+### 6. ശരിയോ തെറ്റോ? ഒരു ലാംഗ്വേജ് മോഡലിന് അതിന്റെ പ്രീട്രെയിനിംഗിന് സാധാരണയായി ലേബലുകൾ ആവശ്യമില്ല.
+
+<Question
+	choices={[
+		{
+			text: "ശരി",
+			explain: "പ്രീട്രെയിനിംഗ് സാധാരണയായി <em>self-supervised</em> ആണ്, അതായത് ലേബലുകൾ ഇൻപുട്ടുകളിൽ നിന്ന് സ്വയമേവ സൃഷ്ടിക്കപ്പെടുന്നു (ഉദാഹരണത്തിന്, അടുത്ത വാക്ക് പ്രവചിക്കുക അല്ലെങ്കിൽ മറച്ചുവെച്ച ചില വാക്കുകൾ പൂരിപ്പിക്കുക).",
+			correct: true
+		},
+		{
+			text: "തെറ്റ്",
+			explain: "ഇത് ശരിയായ ഉത്തരമല്ല."
+		}
+	]}
+/>
+
+### 7. "മോഡൽ", "ആർക്കിടെക്ചർ", "വെയ്‌റ്റുകൾ" എന്നീ പദങ്ങളെ ഏറ്റവും നന്നായി വിവരിക്കുന്ന വാക്യം തിരഞ്ഞെടുക്കുക.
+
+<Question
+	choices={[
+		{
+			text: "ഒരു മോഡൽ ഒരു കെട്ടിടമാണെങ്കിൽ, അതിന്റെ ആർക്കിടെക്ചർ ബ്ലൂപ്രിന്റും വെയ്‌റ്റുകൾ അതിനുള്ളിൽ താമസിക്കുന്ന ആളുകളുമാണ്.",
+			explain: "ഈ ഉപമ പിന്തുടർന്നാൽ, വെയ്‌റ്റുകൾ എന്നത് കെട്ടിടം നിർമ്മിക്കാൻ ഉപയോഗിച്ച ഇഷ്ടികകളും മറ്റ് സാമഗ്രികളുമായിരിക്കും."
+		},
+		{
+			text: "ആർക്കിടെക്ചർ എന്നത് ഒരു മോഡൽ നിർമ്മിക്കാനുള്ള ഭൂപടമാണ്, അതിന്റെ വെയ്‌റ്റുകൾ ആ ഭൂപടത്തിൽ കാണിച്ചിരിക്കുന്ന നഗരങ്ങളാണ്.",
+			explain: "ഈ ഉപമയുടെ പ്രശ്നം, ഒരു ഭൂപടം സാധാരണയായി നിലവിലുള്ള ഒരേയൊരു യാഥാർത്ഥ്യത്തെയാണ് പ്രതിനിധീകരിക്കുന്നത് എന്നതാണ് (ഫ്രാൻസിൽ Paris എന്ന പേരിൽ ഒരേയൊരു നഗരം മാത്രമേയുള്ളൂ). ഒരു നിശ്ചിത ആർക്കിടെക്ചറിന് ഒന്നിലധികം വെയ്‌റ്റുകൾ സാധ്യമാണ്."
+		},
+		{
+			text: "ആർക്കിടെക്ചർ എന്നത് ഒരു മോഡൽ നിർമ്മിക്കാനുള്ള ഗണിത ഫംഗ്‌ഷനുകളുടെ ഒരു ശ്രേണിയാണ്, അതിന്റെ വെയ്‌റ്റുകൾ ആ ഫംഗ്‌ഷനുകളുടെ പാരാമീറ്ററുകളാണ്.",
+			explain: "ഒരേ കൂട്ടം ഗണിത ഫംഗ്‌ഷനുകൾ (ആർക്കിടെക്ചർ) വ്യത്യസ്ത പാരാമീറ്ററുകൾ (വെയ്‌റ്റുകൾ) ഉപയോഗിച്ച് വ്യത്യസ്ത മോഡലുകൾ നിർമ്മിക്കാൻ ഉപയോഗിക്കാം.",
+			correct: true
+		}
+	]}
+/>
+
+
+### 8. ജനറേറ്റ് ചെയ്ത ടെക്‌സ്‌റ്റ് കൊണ്ട് പ്രോംപ്‌റ്റുകൾ പൂർത്തിയാക്കാൻ ഈ മോഡൽ തരങ്ങളിൽ ഏതാണ് നിങ്ങൾ ഉപയോഗിക്കുക?
+
+<Question
+	choices={[
+		{
+			text: "ഒരു എൻകോഡർ മോഡൽ",
+			explain: "ഒരു എൻകോഡർ മോഡൽ വാക്യം മുഴുവന്റെയും ഒരു പ്രതിനിധാനം (representation) ജനറേറ്റ് ചെയ്യുന്നു, അത് വർഗ്ഗീകരണം പോലുള്ള ടാസ്‌കുകൾക്ക് കൂടുതൽ അനുയോജ്യമാണ്."
+		},
+		{
+			text: "ഒരു ഡീകോഡർ മോഡൽ",
+			explain: "ഒരു പ്രോംപ്‌റ്റിൽ നിന്ന് ടെക്‌സ്‌റ്റ് ജനറേറ്റ് ചെയ്യാൻ ഡീകോഡർ മോഡലുകൾ ഏറ്റവും അനുയോജ്യമാണ്.",
+			correct: true
+		},
+		{
+			text: "ഒരു sequence-to-sequence മോഡൽ",
+			explain: "ഒരു നിശ്ചിത പ്രോംപ്‌റ്റല്ല, ഇൻപുട്ട് വാക്യങ്ങളുമായി ബന്ധപ്പെട്ട വാക്യങ്ങൾ ജനറേറ്റ് ചെയ്യേണ്ട ടാസ്‌കുകൾക്കാണ് sequence-to-sequence മോഡലുകൾ കൂടുതൽ അനുയോജ്യം."
+		}
+	]}
+/>
+
+### 9. ടെക്‌സ്‌റ്റുകൾ സംഗ്രഹിക്കാൻ ഈ മോഡൽ തരങ്ങളിൽ ഏതാണ് നിങ്ങൾ ഉപയോഗിക്കുക?
+
+<Question
+	choices={[
+		{
+			text: "ഒരു എൻകോഡർ മോഡൽ",
+			explain: "ഒരു എൻകോഡർ മോഡൽ വാക്യം മുഴുവന്റെയും ഒരു പ്രതിനിധാനം (representation) ജനറേറ്റ് ചെയ്യുന്നു, അത് വർഗ്ഗീകരണം പോലുള്ള ടാസ്‌കുകൾക്ക് കൂടുതൽ അനുയോജ്യമാണ്."
+		},
+		{
+			text: "ഒരു ഡീകോഡർ മോഡൽ",
+			explain: "ഔട്ട്‌പുട്ട് ടെക്‌സ്‌റ്റ് (സംഗ്രഹങ്ങൾ പോലുള്ളവ) ജനറേറ്റ് ചെയ്യാൻ ഡീകോഡർ മോഡലുകൾ നല്ലതാണ്, എന്നാൽ സംഗ്രഹിക്കേണ്ട ടെക്‌സ്‌റ്റ് മുഴുവൻ പോലുള്ള ഒരു സന്ദർഭം (context) പ്രയോജനപ്പെടുത്താനുള്ള കഴിവ് അവയ്ക്കില്ല."
+		},
+		{
+			text: "ഒരു sequence-to-sequence മോഡൽ",
+			explain: "ഒരു സംഗ്രഹ ടാസ്‌കിന് sequence-to-sequence മോഡലുകൾ ഏറ്റവും അനുയോജ്യമാണ്.",
+			correct: true
+		}
+	]}
+/>
+
+### 10. ചില ലേബലുകൾ അനുസരിച്ച് ടെക്‌സ്‌റ്റ് ഇൻപുട്ടുകൾ വർഗ്ഗീകരിക്കാൻ ഈ മോഡൽ തരങ്ങളിൽ ഏതാണ് നിങ്ങൾ ഉപയോഗിക്കുക?
+
+<Question
+	choices={[
+		{
+			text: "ഒരു എൻകോഡർ മോഡൽ",
+			explain: "ഒരു എൻകോഡർ മോഡൽ വാക്യം മുഴുവന്റെയും ഒരു പ്രതിനിധാനം (representation) ജനറേറ്റ് ചെയ്യുന്നു, അത് വർഗ്ഗീകരണം പോലുള്ള ഒരു ടാസ്‌കിന് ഏറ്റവും അനുയോജ്യമാണ്.",
+			correct: true
+		},
+		{
+			text: "ഒരു ഡീകോഡർ മോഡൽ",
+			explain: "ഡീകോഡർ മോഡലുകൾ ഔട്ട്‌പുട്ട് ടെക്‌സ്‌റ്റുകൾ ജനറേറ്റ് ചെയ്യാൻ നല്ലതാണ്, ഒരു വാക്യത്തിൽ നിന്ന് ഒരു ലേബൽ കണ്ടെത്താനല്ല."
+		},
+		{
+			text: "ഒരു sequence-to-sequence മോഡൽ",
+			explain: "ഒരു ലേബലല്ല, ഒരു ഇൻപുട്ട് വാക്യത്തെ അടിസ്ഥാനമാക്കി ടെക്‌സ്‌റ്റ് ജനറേറ്റ് ചെയ്യേണ്ട ടാസ്‌കുകൾക്കാണ് sequence-to-sequence മോഡലുകൾ കൂടുതൽ അനുയോജ്യം.",
+		}
+	]}
+/>
+
+### 11. ഒരു മോഡലിൽ കാണുന്ന പക്ഷപാതത്തിന് (bias) സാധ്യമായ ഉറവിടം എന്താകാം?
+
+<Question
+	choices={[
+		{
+			text: "മോഡൽ ഒരു പ്രീട്രെയിൻഡ് മോഡലിന്റെ ഫൈൻ-ട്യൂൺ ചെയ്ത പതിപ്പാണ്, അതിൽ നിന്ന് അത് പക്ഷപാതം സ്വീകരിച്ചു.",
+			explain: "ട്രാൻസ്‌ഫർ ലേണിംഗ് പ്രയോഗിക്കുമ്പോൾ, ഉപയോഗിച്ച പ്രീട്രെയിൻഡ് മോഡലിലെ പക്ഷപാതം ഫൈൻ-ട്യൂൺ ചെയ്ത മോഡലിലും നിലനിൽക്കുന്നു.",
+			correct: true
+		},
+		{
+			text: "മോഡൽ ട്രെയിൻ ചെയ്ത ഡേറ്റ പക്ഷപാതപരമാണ്.",
+			explain: "ഇതാണ് പക്ഷപാതത്തിന്റെ ഏറ്റവും വ്യക്തമായ ഉറവിടം, എന്നാൽ ഇത് മാത്രമല്ല.",
+			correct: true
+		},
+		{
+			text: "മോഡൽ ഒപ്‌റ്റിമൈസ് ചെയ്യുന്ന മെട്രിക് പക്ഷപാതപരമാണ്.",
+			explain: "അത്ര വ്യക്തമല്ലാത്ത ഒരു പക്ഷപാത ഉറവിടം മോഡൽ ട്രെയിൻ ചെയ്യുന്ന രീതിയാണ്. നിങ്ങൾ തിരഞ്ഞെടുത്ത ഏത് മെട്രിക്കിനും വേണ്ടി, മറ്റൊന്നും ആലോചിക്കാതെ, നിങ്ങളുടെ മോഡൽ അന്ധമായി ഒപ്‌റ്റിമൈസ് ചെയ്യും.",
+			correct: true
+		}
+	]}
+/>

From 2287b64ff75bcce2651c75a4da2f5c4ddc78e2ca Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:13:15 +0530
Subject: [PATCH 11/44] Update fmt.Println message from 'Hello' to 'Goodbye'

---
 chapters/ml/chapter1/8.mdx | 263 +++++++++++++++++++++++++++++++++++++
 1 file changed, 263 insertions(+)
 create mode 100644 chapters/ml/chapter1/8.mdx

diff --git a/chapters/ml/chapter1/8.mdx b/chapters/ml/chapter1/8.mdx
new file mode 100644
index 000000000..1384fbb93
--- /dev/null
+++ b/chapters/ml/chapter1/8.mdx
@@ -0,0 +1,263 @@
+# LLM-കൾ ഉപയോഗിച്ചുള്ള ടെക്‌സ്‌റ്റ് ജനറേഷൻ ഇൻഫറൻസ് — ഒരു ആഴത്തിലുള്ള പഠനം[[inference-with-llms]]
+
+<CourseFloatingBanner
+    chapter={1}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+<Youtube id="Xp2w1_LKZN4" />
+
+ഇതുവരെ നാം ട്രാൻസ്‌ഫോർമർ ആർക്കിടെക്ചറിനെ ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷൻ, സംഗ്രഹം (summarization) തുടങ്ങിയ വ്യത്യസ്ത ടാസ്‌ക്കുകളുമായി ബന്ധപ്പെടുത്തിയാണ് പരിചയപ്പെട്ടത്. എന്നാൽ, Large Language Model-കൾ (LLM-കൾ) ഏറ്റവുമധികം ഉപയോഗിക്കപ്പെടുന്നത് ടെക്‌സ്‌റ്റ് ജനറേഷനുവേണ്ടിയാണ്; ഈ അധ്യായത്തിൽ നാം അതാണ് പരിശോധിക്കുന്നത്.
+
+ഈ പേജിൽ, LLM ഇൻഫറൻസിന്റെ അടിസ്ഥാന ആശയങ്ങൾ നാം പരിശോധിക്കും — ഈ മോഡലുകൾ എങ്ങനെ ടെക്‌സ്‌റ്റ് ഉണ്ടാക്കുന്നു എന്നതും ഇൻഫറൻസ് പ്രക്രിയയിലെ പ്രധാന ഘടകങ്ങൾ ഏതെല്ലാമെന്നതും സമഗ്രമായി മനസ്സിലാക്കാൻ ഇത് സഹായിക്കും.
+
+## അടിസ്ഥാനങ്ങൾ മനസ്സിലാക്കാം
+
+നമുക്ക് അടിസ്ഥാന കാര്യങ്ങളിൽനിന്ന് തുടങ്ങാം. ട്രെയിൻ ചെയ്ത ഒരു LLM ഉപയോഗിച്ച്, നൽകിയ ഒരു ഇൻപുട്ട് പ്രോംപ്‌റ്റിൽനിന്ന് മനുഷ്യർ എഴുതുന്നതുപോലുള്ള ടെക്‌സ്‌റ്റ് ഉണ്ടാക്കുന്ന പ്രക്രിയയാണ് ഇൻഫറൻസ് (inference). ഭാഷാ മോഡലുകൾ ട്രെയിനിംഗിൽനിന്ന് നേടിയ അറിവ് ഉപയോഗിച്ച് ഒരു സമയം ഒരു വാക്ക് വീതം മറുപടി രൂപപ്പെടുത്തുന്നു. കോടിക്കണക്കിന് പാരാമീറ്ററുകളിൽനിന്ന് പഠിച്ചെടുത്ത പ്രോബബിലിറ്റികൾ ഉപയോഗിച്ചാണ് മോഡൽ ഒരു ശ്രേണിയിലെ അടുത്ത ടോക്കൺ പ്രവചിക്കുന്നതും ഉണ്ടാക്കുന്നതും. ഈ ക്രമാനുഗതമായ (sequential) ജനറേഷനാണ് LLM-കൾക്ക് യോജിപ്പുള്ളതും സന്ദർഭത്തിന് അനുയോജ്യവുമായ ടെക്‌സ്‌റ്റ് ഉണ്ടാക്കാൻ കഴിവ് നൽകുന്നത്.
+
+## അറ്റൻഷന്റെ പങ്ക്
+
+LLM-കൾക്ക് സന്ദർഭം മനസ്സിലാക്കാനും യോജിപ്പുള്ള മറുപടികൾ ഉണ്ടാക്കാനും കഴിവ് നൽകുന്നത് അറ്റൻഷൻ (attention) മെക്കാനിസമാണ്. അടുത്ത വാക്ക് പ്രവചിക്കുമ്പോൾ, ഒരു വാക്യത്തിലെ എല്ലാ വാക്കുകൾക്കും ഒരേ പ്രാധാന്യമല്ല ഉള്ളത് — ഉദാഹരണത്തിന്, *"The capital of France is ..."* എന്ന വാക്യത്തിൽ, അടുത്തതായി "Paris" വരണം എന്ന് നിർണ്ണയിക്കാൻ "France", "capital" എന്ന വാക്കുകളാണ് നിർണ്ണായകം. പ്രസക്തമായ വിവരങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാനുള്ള ഈ കഴിവിനെയാണ് നാം അറ്റൻഷൻ എന്ന് വിളിക്കുന്നത്.
+
+<img src="https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/unit1/AttentionSceneFinal.gif" alt="അറ്റൻഷന്റെ ദൃശ്യാവിഷ്കാരം (Gif)" width="60%">
+
+അടുത്ത ടോക്കൺ പ്രവചിക്കാൻ ഏറ്റവും പ്രസക്തമായ വാക്കുകൾ കണ്ടെത്തുന്ന ഈ പ്രക്രിയ അസാധാരണമായി ഫലപ്രദമാണെന്ന് തെളിഞ്ഞിട്ടുണ്ട്. LLM-കളെ ട്രെയിൻ ചെയ്യുന്നതിന്റെ അടിസ്ഥാന തത്വം — അടുത്ത ടോക്കൺ പ്രവചിക്കുക — BERT, GPT-2 എന്നിവയുടെ കാലം മുതൽ ഏറെക്കുറെ മാറ്റമില്ലാതെ തുടരുന്നുണ്ടെങ്കിലും, ന്യൂറൽ നെറ്റ്‌വർക്കുകളെ വലുതാക്കുന്നതിലും (scaling), കൂടുതൽ കൂടുതൽ നീളമുള്ള ശ്രേണികളിൽ കുറഞ്ഞ ചെലവിൽ അറ്റൻഷൻ മെക്കാനിസം പ്രവർത്തിപ്പിക്കുന്നതിലും കാര്യമായ പുരോഗതി ഉണ്ടായിട്ടുണ്ട്.
+
+> [!TIP]
+> ചുരുക്കത്തിൽ, യോജിപ്പുള്ളതും സന്ദർഭം അറിയുന്നതുമായ ടെക്‌സ്‌റ്റ് ഉണ്ടാക്കാൻ LLM-കൾക്ക് കഴിയുന്നതിന്റെ താക്കോൽ അറ്റൻഷൻ മെക്കാനിസമാണ്. ഇതാണ് ആധുനിക LLM-കളെ മുൻതലമുറ ഭാഷാ മോഡലുകളിൽനിന്ന് വേറിട്ടുനിർത്തുന്നത്.
+
+### കോൺടെക്‌സ്‌റ്റ് ലെങ്ത്തും അറ്റൻഷൻ സ്പാനും
+
+അറ്റൻഷൻ എന്താണെന്ന് മനസ്സിലായ സ്ഥിതിക്ക്, ഒരു LLM-ന് യഥാർത്ഥത്തിൽ എത്ര സന്ദർഭം (context) കൈകാര്യം ചെയ്യാൻ കഴിയും എന്ന് നോക്കാം. ഇത് നമ്മെ കോൺടെക്‌സ്‌റ്റ് ലെങ്ത് (context length), അഥവാ മോഡലിന്റെ 'അറ്റൻഷൻ സ്പാൻ' എന്ന ആശയത്തിലേക്ക് എത്തിക്കുന്നു.
+
+ഒരു LLM-ന് ഒരേസമയം പ്രോസസ്സ് ചെയ്യാൻ കഴിയുന്ന പരമാവധി ടോക്കണുകളുടെ (വാക്കുകൾ അല്ലെങ്കിൽ വാക്കുകളുടെ ഭാഗങ്ങൾ) എണ്ണത്തെയാണ് കോൺടെക്‌സ്‌റ്റ് ലെങ്ത് എന്ന് പറയുന്നത്. ഇതിനെ മോഡലിന്റെ വർക്കിംഗ് മെമ്മറിയുടെ വലുപ്പമായി കരുതാം.
+
+ഈ കഴിവുകൾക്ക് പല പ്രായോഗിക ഘടകങ്ങളും പരിമിതികൾ സൃഷ്ടിക്കുന്നു:
+- മോഡലിന്റെ ആർക്കിടെക്ചറും വലുപ്പവും
+- ലഭ്യമായ കമ്പ്യൂട്ടേഷണൽ വിഭവങ്ങൾ
+- ഇൻപുട്ടിന്റെയും ആവശ്യമുള്ള ഔട്ട്‌പുട്ടിന്റെയും സങ്കീർണ്ണത
+
+ഒരു ഉത്തമലോകത്തിൽ നമുക്ക് പരിധിയില്ലാത്ത കോൺടെക്‌സ്‌റ്റ് മോഡലിന് നൽകാമായിരുന്നു; എന്നാൽ ഹാർഡ്‌വെയർ പരിമിതികളും കമ്പ്യൂട്ടേഷണൽ ചെലവുകളും ഇത് അപ്രായോഗികമാക്കുന്നു. അതുകൊണ്ടാണ് കഴിവും കാര്യക്ഷമതയും തമ്മിൽ സന്തുലനം നിലനിർത്താൻ വ്യത്യസ്ത മോഡലുകൾ വ്യത്യസ്ത കോൺടെക്‌സ്‌റ്റ് ലെങ്ത്തുകളോടെ രൂപകൽപ്പന ചെയ്യപ്പെടുന്നത്.
+
+> [!TIP]
+> ഒരു മറുപടി ഉണ്ടാക്കുമ്പോൾ മോഡലിന് ഒരേസമയം പരിഗണിക്കാൻ കഴിയുന്ന പരമാവധി ടോക്കണുകളുടെ എണ്ണമാണ് കോൺടെക്‌സ്‌റ്റ് ലെങ്ത്.
+
+### പ്രോംപ്‌റ്റിംഗിന്റെ കല
+
+LLM-കൾക്ക് വിവരങ്ങൾ നൽകുമ്പോൾ, LLM-ന്റെ ജനറേഷനെ നമുക്ക് ആവശ്യമുള്ള ഔട്ട്‌പുട്ടിലേക്ക് നയിക്കുന്ന രീതിയിലാണ് നാം ഇൻപുട്ട് ക്രമീകരിക്കുന്നത്. ഇതിനെ _പ്രോംപ്‌റ്റിംഗ്_ (prompting) എന്ന് വിളിക്കുന്നു.
+
+LLM-കൾ വിവരങ്ങൾ എങ്ങനെ പ്രോസസ്സ് ചെയ്യുന്നു എന്ന് മനസ്സിലാക്കുന്നത് മികച്ച പ്രോംപ്‌റ്റുകൾ തയ്യാറാക്കാൻ നമ്മെ സഹായിക്കും. ഓരോ ഇൻപുട്ട് ടോക്കണിന്റെയും പ്രാധാന്യം വിശകലനം ചെയ്ത് അടുത്ത ടോക്കൺ പ്രവചിക്കുകയാണ് മോഡലിന്റെ പ്രധാന ജോലി എന്നതിനാൽ, നിങ്ങളുടെ ഇൻപുട്ട് ശ്രേണിയിലെ വാക്കുകളുടെ തിരഞ്ഞെടുപ്പ് നിർണ്ണായകമാകുന്നു.
+
+> [!TIP]
+> പ്രോംപ്‌റ്റ് ശ്രദ്ധയോടെ രൂപകൽപ്പന ചെയ്യുന്നത് **LLM-ന്റെ ജനറേഷനെ ആവശ്യമുള്ള ഔട്ട്‌പുട്ടിലേക്ക് നയിക്കുന്നത്** എളുപ്പമാക്കുന്നു.
+
+## രണ്ട് ഘട്ടങ്ങളുള്ള ഇൻഫറൻസ് പ്രക്രിയ
+
+അടിസ്ഥാന ഘടകങ്ങൾ മനസ്സിലായ സ്ഥിതിക്ക്, LLM-കൾ യഥാർത്ഥത്തിൽ എങ്ങനെ ടെക്‌സ്‌റ്റ് ഉണ്ടാക്കുന്നു എന്ന് ആഴത്തിൽ നോക്കാം. ഈ പ്രക്രിയയെ പ്രധാനമായി രണ്ട് ഘട്ടങ്ങളായി തിരിക്കാം: പ്രീഫിൽ (prefill), ഡീകോഡ് (decode). ഒരു അസംബ്ലി ലൈൻ പോലെ ഈ ഘട്ടങ്ങൾ ഒരുമിച്ച് പ്രവർത്തിക്കുന്നു; യോജിപ്പുള്ള ടെക്‌സ്‌റ്റ് ഉണ്ടാക്കുന്നതിൽ ഓരോന്നിനും നിർണ്ണായക പങ്കുണ്ട്.
+
+### പ്രീഫിൽ ഘട്ടം
+
+പ്രീഫിൽ ഘട്ടം പാചകത്തിലെ ഒരുക്കത്തിന്റെ ഘട്ടം പോലെയാണ് — ആദ്യ ചേരുവകളെല്ലാം ഇവിടെയാണ് പ്രോസസ്സ് ചെയ്ത് തയ്യാറാക്കുന്നത്. ഈ ഘട്ടത്തിൽ മൂന്ന് പ്രധാന പടികളുണ്ട്:
+
+1. **ടോക്കണൈസേഷൻ**: ഇൻപുട്ട് ടെക്‌സ്‌റ്റിനെ ടോക്കണുകളാക്കി മാറ്റുന്നു (മോഡലിന് മനസ്സിലാകുന്ന അടിസ്ഥാന നിർമ്മാണഘടകങ്ങളായി ഇവയെ കരുതാം)
+2. **എംബെഡ്ഡിംഗ് പരിവർത്തനം**: ഈ ടോക്കണുകളെ അവയുടെ അർത്ഥം ഉൾക്കൊള്ളുന്ന സംഖ്യാരൂപങ്ങളാക്കി (numerical representations) മാറ്റുന്നു
+3. **പ്രാരംഭ പ്രോസസ്സിംഗ്**: സന്ദർഭത്തെക്കുറിച്ച് സമ്പന്നമായ ഒരു ധാരണ ഉണ്ടാക്കാൻ ഈ എംബെഡ്ഡിംഗുകളെ മോഡലിന്റെ ന്യൂറൽ നെറ്റ്‌വർക്കുകളിലൂടെ കടത്തിവിടുന്നു
+
+എല്ലാ ഇൻപുട്ട് ടോക്കണുകളും ഒരേസമയം പ്രോസസ്സ് ചെയ്യേണ്ടതുകൊണ്ട് ഈ ഘട്ടത്തിന് ധാരാളം കമ്പ്യൂട്ടേഷൻ ആവശ്യമാണ്. ഒരു മറുപടി എഴുതാൻ തുടങ്ങുന്നതിനുമുമ്പ് ഒരു ഖണ്ഡിക മുഴുവൻ വായിച്ച് മനസ്സിലാക്കുന്നതുപോലെയാണിത്.
+
+താഴെയുള്ള ഇന്ററാക്ടീവ് പ്ലേഗ്രൗണ്ടിൽ വ്യത്യസ്ത ടോക്കണൈസറുകൾ നിങ്ങൾക്ക് പരീക്ഷിച്ചുനോക്കാം:
+
+<iframe
+	src="https://agents-course-the-tokenizer-playground.static.hf.space"
+	frameborder="0"
+	width="850"
+	height="450"
+></iframe>
+
+### ഡീകോഡ് ഘട്ടം
+
+പ്രീഫിൽ ഘട്ടം ഇൻപുട്ട് പ്രോസസ്സ് ചെയ്തുകഴിഞ്ഞാൽ, നാം ഡീകോഡ് ഘട്ടത്തിലേക്ക് കടക്കുന്നു — യഥാർത്ഥ ടെക്‌സ്‌റ്റ് ജനറേഷൻ നടക്കുന്നത് ഇവിടെയാണ്. ഓട്ടോറിഗ്രസ്സീവ് (autoregressive) പ്രക്രിയ എന്ന് നാം വിളിക്കുന്ന രീതിയിൽ (ഓരോ പുതിയ ടോക്കണും അതിന് മുമ്പുള്ള എല്ലാ ടോക്കണുകളെയും ആശ്രയിച്ചിരിക്കുന്നു) മോഡൽ ഒരു സമയം ഒരു ടോക്കൺ വീതം ഉണ്ടാക്കുന്നു.
+
+ഡീകോഡ് ഘട്ടത്തിൽ, ഓരോ പുതിയ ടോക്കണിനും വേണ്ടി നടക്കുന്ന പ്രധാന പടികൾ ഇവയാണ്:
+1. **അറ്റൻഷൻ കണക്കുകൂട്ടൽ**: സന്ദർഭം മനസ്സിലാക്കാൻ മുമ്പുള്ള എല്ലാ ടോക്കണുകളിലേക്കും തിരിഞ്ഞുനോക്കുന്നു
+2. **പ്രോബബിലിറ്റി കണക്കുകൂട്ടൽ**: സാധ്യമായ ഓരോ അടുത്ത ടോക്കണിന്റെയും സാധ്യത നിർണ്ണയിക്കുന്നു
+3. **ടോക്കൺ തിരഞ്ഞെടുപ്പ്**: ഈ പ്രോബബിലിറ്റികളെ അടിസ്ഥാനമാക്കി അടുത്ത ടോക്കൺ തിരഞ്ഞെടുക്കുന്നു
+4. **തുടരണോ എന്ന പരിശോധന**: ജനറേഷൻ തുടരണോ നിർത്തണോ എന്ന് തീരുമാനിക്കുന്നു
+
+മുമ്പ് ഉണ്ടാക്കിയ എല്ലാ ടോക്കണുകളും അവയ്ക്കിടയിലുള്ള ബന്ധങ്ങളും മോഡലിന് ഓർത്തുവയ്ക്കേണ്ടതുകൊണ്ട് ഈ ഘട്ടത്തിന് ധാരാളം മെമ്മറി ആവശ്യമാണ്.
+
+## സാംപ്ലിംഗ് സ്ട്രാറ്റജികൾ
+
+മോഡൽ എങ്ങനെ ടെക്‌സ്‌റ്റ് ഉണ്ടാക്കുന്നു എന്ന് മനസ്സിലായ സ്ഥിതിക്ക്, ഈ ജനറേഷൻ പ്രക്രിയയെ നിയന്ത്രിക്കാനുള്ള വിവിധ മാർഗ്ഗങ്ങൾ നോക്കാം. ഒരു എഴുത്തുകാരൻ കൂടുതൽ സർഗ്ഗാത്മകമാകണോ കൂടുതൽ കൃത്യമാകണോ എന്ന് തിരഞ്ഞെടുക്കുന്നതുപോലെ, മോഡൽ ടോക്കണുകൾ തിരഞ്ഞെടുക്കുന്ന രീതി നമുക്ക് ക്രമീകരിക്കാം.
+
+ഈ Space-ൽ SmolLM2 ഉപയോഗിച്ച് അടിസ്ഥാന ഡീകോഡിംഗ് പ്രക്രിയ നിങ്ങൾക്ക് സ്വയം പരീക്ഷിക്കാം (ഓർക്കുക, ഒരു **EOS** ടോക്കണിൽ എത്തുന്നതുവരെ ഇത് ഡീകോഡ് ചെയ്യും; ഈ മോഡലിന് അത് **<|im_end|>** ആണ്):
+
+<iframe
+	src="https://agents-course-decoding-visualizer.hf.space"
+	frameborder="0"
+	width="850"
+	height="450"
+></iframe>
+
+### ടോക്കൺ തിരഞ്ഞെടുപ്പ് മനസ്സിലാക്കാം: പ്രോബബിലിറ്റികളിൽനിന്ന് ടോക്കൺ തിരഞ്ഞെടുപ്പുകളിലേക്ക്
+
+അടുത്ത ടോക്കൺ തിരഞ്ഞെടുക്കേണ്ടിവരുമ്പോൾ, മോഡൽ തന്റെ വൊക്കാബുലറിയിലെ ഓരോ വാക്കിനുമുള്ള അസംസ്കൃത പ്രോബബിലിറ്റികളിൽനിന്നാണ് (ഇവയെ ലോജിറ്റ്‌സ് — logits — എന്ന് വിളിക്കുന്നു) തുടങ്ങുന്നത്. എന്നാൽ ഈ പ്രോബബിലിറ്റികളെ യഥാർത്ഥ തിരഞ്ഞെടുപ്പുകളാക്കി മാറ്റുന്നത് എങ്ങനെയാണ്? ഈ പ്രക്രിയ പടിപടിയായി നോക്കാം:
+
+![image](https://huggingface.co/reasoning-course/images/resolve/main/inference/1.png)  
+
+1. **റോ ലോജിറ്റ്‌സ് (Raw Logits)**: സാധ്യമായ ഓരോ അടുത്ത വാക്കിനെക്കുറിച്ചുമുള്ള മോഡലിന്റെ ആദ്യ ഉൾവിളി (gut feeling) ആയി ഇവയെ കരുതാം
+2. **ടെമ്പറേച്ചർ നിയന്ത്രണം (Temperature Control)**: ഒരു സർഗ്ഗാത്മകതാ ഡയൽ പോലെ — ഉയർന്ന മൂല്യങ്ങൾ (>1.0) തിരഞ്ഞെടുപ്പുകളെ കൂടുതൽ ക്രമരഹിതവും സർഗ്ഗാത്മകവുമാക്കുന്നു, താഴ്ന്ന മൂല്യങ്ങൾ (<1.0) അവയെ കൂടുതൽ ഏകാഗ്രവും നിർണ്ണീതവുമാക്കുന്നു (deterministic)
+3. **Top-p (Nucleus) സാംപ്ലിംഗ്**: സാധ്യമായ എല്ലാ വാക്കുകളും പരിഗണിക്കുന്നതിനുപകരം, നാം തിരഞ്ഞെടുത്ത പ്രോബബിലിറ്റി പരിധിയിലേക്ക് (ഉദാ. മുൻനിരയിലെ 90%) കൂട്ടിച്ചേരുന്ന ഏറ്റവും സാധ്യതയുള്ള വാക്കുകൾ മാത്രം നോക്കുന്നു
+4. **Top-k ഫിൽറ്ററിംഗ്**: ഏറ്റവും സാധ്യതയുള്ള k അടുത്ത വാക്കുകൾ മാത്രം പരിഗണിക്കുന്ന ഒരു ബദൽ രീതി
+
+### ആവർത്തനം നിയന്ത്രിക്കൽ: ഔട്ട്‌പുട്ട് പുതുമയോടെ നിലനിർത്താം
+
+LLM-കളിലെ ഒരു സാധാരണ വെല്ലുവിളി അവ സ്വയം ആവർത്തിക്കാനുള്ള പ്രവണതയാണ് — ഒരേ കാര്യങ്ങളിലേക്ക് വീണ്ടും വീണ്ടും മടങ്ങിവരുന്ന ഒരു പ്രാസംഗികനെപ്പോലെ. ഇത് പരിഹരിക്കാൻ നാം രണ്ട് തരം പെനാൽറ്റികൾ ഉപയോഗിക്കുന്നു:
+
+1. **പ്രസൻസ് പെനാൽറ്റി (Presence Penalty)**: മുമ്പ് പ്രത്യക്ഷപ്പെട്ട ഏതൊരു ടോക്കണിനും, എത്ര തവണ വന്നു എന്നത് പരിഗണിക്കാതെ, ചുമത്തുന്ന ഒരു നിശ്ചിത പെനാൽറ്റി. ഒരേ വാക്കുകൾ മോഡൽ വീണ്ടും ഉപയോഗിക്കുന്നത് തടയാൻ ഇത് സഹായിക്കുന്നു.
+2. **ഫ്രീക്വൻസി പെനാൽറ്റി (Frequency Penalty)**: ഒരു ടോക്കൺ എത്ര തവണ ഉപയോഗിച്ചു എന്നതിനനുസരിച്ച് വർദ്ധിക്കുന്ന ഒരു അനുപാതിക പെനാൽറ്റി. ഒരു വാക്ക് എത്ര കൂടുതൽ പ്രത്യക്ഷപ്പെടുന്നുവോ, അത്രയും കുറവായിരിക്കും അത് വീണ്ടും തിരഞ്ഞെടുക്കപ്പെടാനുള്ള സാധ്യത.
+
+![image](https://huggingface.co/reasoning-course/images/resolve/main/inference/2.png)  
+
+ടോക്കൺ തിരഞ്ഞെടുപ്പ് പ്രക്രിയയുടെ തുടക്കത്തിൽത്തന്നെ ഈ പെനാൽറ്റികൾ പ്രയോഗിക്കുന്നു; മറ്റ് സാംപ്ലിംഗ് സ്ട്രാറ്റജികൾ പ്രയോഗിക്കുന്നതിനുമുമ്പ് അസംസ്കൃത പ്രോബബിലിറ്റികളെ ഇവ ക്രമീകരിക്കുന്നു. പുതിയ പദങ്ങൾ പരീക്ഷിക്കാൻ മോഡലിനെ പ്രോത്സാഹിപ്പിക്കുന്ന മൃദുവായ തള്ളലുകളായി ഇവയെ കരുതാം.
+
+### ജനറേഷൻ ദൈർഘ്യം നിയന്ത്രിക്കൽ: അതിരുകൾ നിശ്ചയിക്കാം
+
+ഒരു നല്ല കഥയ്ക്ക് ശരിയായ വേഗവും നീളവും വേണ്ടതുപോലെ, നമ്മുടെ LLM എത്ര ടെക്‌സ്‌റ്റ് ഉണ്ടാക്കണം എന്ന് നിയന്ത്രിക്കാനുള്ള മാർഗ്ഗങ്ങളും നമുക്ക് വേണം. പ്രായോഗിക ആപ്ലിക്കേഷനുകളിൽ ഇത് നിർണ്ണായകമാണ് — ഒരു ട്വീറ്റിന്റെ നീളമുള്ള മറുപടിയാണോ അതോ ഒരു പൂർണ്ണ ബ്ലോഗ് പോസ്റ്റാണോ നാം ഉണ്ടാക്കുന്നത് എന്നതിനനുസരിച്ച്.
+
+ജനറേഷൻ ദൈർഘ്യം നമുക്ക് പല രീതികളിൽ നിയന്ത്രിക്കാം:
+1. **ടോക്കൺ പരിധികൾ**: ഏറ്റവും കുറഞ്ഞതും കൂടിയതുമായ ടോക്കൺ എണ്ണം നിശ്ചയിക്കുക
+2. **സ്റ്റോപ്പ് സീക്വൻസുകൾ**: ജനറേഷന്റെ അവസാനം സൂചിപ്പിക്കുന്ന നിശ്ചിത പാറ്റേണുകൾ നിർവചിക്കുക
+3. **എൻഡ്-ഓഫ്-സീക്വൻസ് കണ്ടെത്തൽ**: മോഡലിനെ സ്വാഭാവികമായി മറുപടി അവസാനിപ്പിക്കാൻ അനുവദിക്കുക
+
+ഉദാഹരണത്തിന്, ഒരു ഖണ്ഡിക മാത്രം ഉണ്ടാക്കണമെങ്കിൽ, പരമാവധി 100 ടോക്കണുകൾ എന്ന് നിശ്ചയിക്കുകയും "\n\n" ഒരു സ്റ്റോപ്പ് സീക്വൻസായി ഉപയോഗിക്കുകയും ചെയ്യാം. ഇത് നമ്മുടെ ഔട്ട്‌പുട്ട് ഏകാഗ്രവും ഉദ്ദേശ്യത്തിന് അനുയോജ്യമായ വലുപ്പത്തിലുള്ളതുമായി തുടരുന്നു എന്ന് ഉറപ്പാക്കുന്നു.
+
+![image](https://huggingface.co/reasoning-course/images/resolve/main/inference/3.png)  
+
+### ബീം സെർച്ച്: കൂടുതൽ യോജിപ്പിനായി മുന്നോട്ട് നോക്കാം
+
+ഇതുവരെ നാം ചർച്ച ചെയ്ത സ്ട്രാറ്റജികൾ ഒരു സമയം ഒരു ടോക്കൺ വീതം തീരുമാനങ്ങൾ എടുക്കുമ്പോൾ, ബീം സെർച്ച് (beam search) കൂടുതൽ സമഗ്രമായ ഒരു സമീപനമാണ് സ്വീകരിക്കുന്നത്. ഓരോ പടിയിലും ഒരൊറ്റ തിരഞ്ഞെടുപ്പിൽ ഉറച്ചുനിൽക്കുന്നതിനുപകരം, ഇത് സാധ്യമായ പല പാതകളും ഒരേസമയം പരിശോധിക്കുന്നു — പല നീക്കങ്ങൾ മുന്നോട്ട് ചിന്തിക്കുന്ന ഒരു ചെസ്സ് കളിക്കാരനെപ്പോലെ.
+
+![image](https://huggingface.co/reasoning-course/images/resolve/main/inference/4.png)  
+
+ഇത് പ്രവർത്തിക്കുന്നത് ഇങ്ങനെയാണ്:
+1. ഓരോ പടിയിലും ഒന്നിലധികം സ്ഥാനാർത്ഥി ശ്രേണികൾ (സാധാരണയായി 5-10) നിലനിർത്തുന്നു
+2. ഓരോ സ്ഥാനാർത്ഥിക്കും അടുത്ത ടോക്കണിനുള്ള പ്രോബബിലിറ്റികൾ കണക്കുകൂട്ടുന്നു
+3. ശ്രേണികളുടെയും അടുത്ത ടോക്കണുകളുടെയും ഏറ്റവും സാധ്യതയുള്ള സംയോജനങ്ങൾ മാത്രം നിലനിർത്തുന്നു
+4. ആവശ്യമുള്ള ദൈർഘ്യത്തിലോ സ്റ്റോപ്പ് വ്യവസ്ഥയിലോ എത്തുന്നതുവരെ ഈ പ്രക്രിയ തുടരുന്നു
+5. മൊത്തത്തിൽ ഏറ്റവും ഉയർന്ന പ്രോബബിലിറ്റിയുള്ള ശ്രേണി തിരഞ്ഞെടുക്കുന്നു
+
+ബീം സെർച്ച് ദൃശ്യരൂപത്തിൽ ഇവിടെ നിങ്ങൾക്ക് പരിശോധിക്കാം:
+
+<iframe
+	src="https://agents-course-beam-search-visualizer.hf.space"
+	frameborder="0"
+	width="850"
+	height="450"
+></iframe>
+
+ഈ സമീപനം പലപ്പോഴും കൂടുതൽ യോജിപ്പുള്ളതും വ്യാകരണപരമായി ശരിയായതുമായ ടെക്‌സ്‌റ്റ് ഉണ്ടാക്കുന്നു; എന്നാൽ ലളിതമായ രീതികളെക്കാൾ കൂടുതൽ കമ്പ്യൂട്ടേഷണൽ വിഭവങ്ങൾ ഇതിന് ആവശ്യമാണ്.
+
+## പ്രായോഗിക വെല്ലുവിളികളും ഒപ്റ്റിമൈസേഷനും
+
+LLM ഇൻഫറൻസിനെക്കുറിച്ചുള്ള നമ്മുടെ പര്യവേക്ഷണം അവസാനിപ്പിക്കുന്നതിനുമുമ്പ്, ഈ മോഡലുകൾ ഡിപ്ലോയ് ചെയ്യുമ്പോൾ നിങ്ങൾ നേരിടേണ്ടിവരുന്ന പ്രായോഗിക വെല്ലുവിളികളും, അവയുടെ പ്രകടനം എങ്ങനെ അളക്കാമെന്നും ഒപ്റ്റിമൈസ് ചെയ്യാമെന്നും നോക്കാം.
+
+### പ്രധാന പെർഫോമൻസ് മെട്രിക്കുകൾ
+
+LLM-കളുമായി പ്രവർത്തിക്കുമ്പോൾ, നാല് നിർണ്ണായക മെട്രിക്കുകൾ നിങ്ങളുടെ ഇംപ്ലിമെന്റേഷൻ തീരുമാനങ്ങളെ രൂപപ്പെടുത്തും:
+
+1. **Time to First Token (TTFT)**: എത്ര വേഗത്തിൽ ആദ്യ മറുപടി ലഭിക്കും? ഉപയോക്തൃ അനുഭവത്തിന് ഇത് നിർണ്ണായകമാണ്; പ്രധാനമായും പ്രീഫിൽ ഘട്ടമാണ് ഇതിനെ സ്വാധീനിക്കുന്നത്.
+2. **Time Per Output Token (TPOT)**: തുടർന്നുള്ള ടോക്കണുകൾ എത്ര വേഗത്തിൽ ഉണ്ടാക്കാൻ കഴിയും? ഇത് മൊത്തത്തിലുള്ള ജനറേഷൻ വേഗം നിർണ്ണയിക്കുന്നു.
+3. **Throughput**: ഒരേസമയം എത്ര അഭ്യർത്ഥനകൾ (requests) കൈകാര്യം ചെയ്യാൻ കഴിയും? ഇത് സ്കെയിലിംഗിനെയും ചെലവ് കാര്യക്ഷമതയെയും ബാധിക്കുന്നു.
+4. **VRAM ഉപയോഗം**: എത്ര GPU മെമ്മറി ആവശ്യമാണ്? യഥാർത്ഥ ആപ്ലിക്കേഷനുകളിൽ ഇത് പലപ്പോഴും പ്രധാന പരിമിതിയായി മാറുന്നു.
+
+### കോൺടെക്‌സ്‌റ്റ് ലെങ്ത് എന്ന വെല്ലുവിളി
+
+LLM ഇൻഫറൻസിലെ ഏറ്റവും പ്രധാനപ്പെട്ട വെല്ലുവിളികളിലൊന്ന് കോൺടെക്‌സ്‌റ്റ് ലെങ്ത് ഫലപ്രദമായി കൈകാര്യം ചെയ്യുന്നതാണ്. നീളമുള്ള കോൺടെക്‌സ്‌റ്റുകൾ കൂടുതൽ വിവരങ്ങൾ നൽകുന്നു, എന്നാൽ അവയ്ക്ക് കാര്യമായ ചെലവുകളുമുണ്ട്:
+
+- **മെമ്മറി ഉപയോഗം**: കോൺടെക്‌സ്‌റ്റ് ലെങ്ത്തിനനുസരിച്ച് ക്വാഡ്രാറ്റിക് ആയി (quadratically) വർദ്ധിക്കുന്നു
+- **പ്രോസസ്സിംഗ് വേഗം**: നീളമുള്ള കോൺടെക്‌സ്‌റ്റുകളിൽ രേഖീയമായി (linearly) കുറയുന്നു
+- **വിഭവ വിന്യാസം**: VRAM ഉപയോഗത്തിന്റെ ശ്രദ്ധാപൂർവ്വമായ സന്തുലനം ആവശ്യമാണ്
+
+[Qwen2.5-1M](https://huggingface.co/Qwen/Qwen2.5-14B-Instruct-1M) പോലുള്ള സമീപകാല മോഡലുകൾ 1M ടോക്കണുകളുടെ ശ്രദ്ധേയമായ കോൺടെക്‌സ്‌റ്റ് വിൻഡോ നൽകുന്നു; എന്നാൽ ഇതിന് വളരെ മന്ദഗതിയിലുള്ള ഇൻഫറൻസ് സമയം എന്ന വില കൊടുക്കേണ്ടിവരുന്നു. നിങ്ങളുടെ പ്രത്യേക ഉപയോഗത്തിന് ശരിയായ സന്തുലനം കണ്ടെത്തുന്നതാണ് ഇവിടെ പ്രധാനം.  
+
+
+<div style="max-width: 800px; margin: 20px auto; padding: 20px; 
+font-family: system-ui;">
+    <div style="border: 2px solid #ddd; border-radius: 8px; 
+    padding: 20px; margin-bottom: 20px;">
+        <div style="display: flex; align-items: center; 
+        margin-bottom: 15px;">
+            <div style="flex: 1; text-align: center; padding: 
+            10px; background: #f0f0f0; border-radius: 4px;">
+                ഇൻപുട്ട് ടെക്‌സ്‌റ്റ് (അസംസ്കൃതം)
+            </div>
+            <div style="margin: 0 10px;">→</div>
+            <div style="flex: 1; text-align: center; padding: 
+            10px; background: #e1f5fe; border-radius: 4px;">
+                ടോക്കണൈസ് ചെയ്ത ഇൻപുട്ട്
+            </div>
+        </div>
+        <div style="display: flex; margin-bottom: 15px;">
+            <div style="flex: 1; border: 1px solid #ccc; 
+            padding: 10px; margin: 5px; background: #e8f5e9; 
+            border-radius: 4px; text-align: center;">
+                കോൺടെക്‌സ്‌റ്റ് വിൻഡോ<br/>(ഉദാ. 4K ടോക്കണുകൾ)
+                <div style="display: flex; margin-top: 10px;">
+                    <div style="flex: 1; background: #81c784; 
+                    margin: 2px; height: 20px; border-radius: 
+                    2px;"></div>
+                    <div style="flex: 1; background: #81c784; 
+                    margin: 2px; height: 20px; border-radius: 
+                    2px;"></div>
+                    <div style="flex: 1; background: #81c784; 
+                    margin: 2px; height: 20px; border-radius: 
+                    2px;"></div>
+                    <div style="flex: 1; background: #81c784; 
+                    margin: 2px; height: 20px; border-radius: 
+                    2px;"></div>
+                </div>
+            </div>
+        </div>
+        <div style="display: flex; justify-content: 
+        space-between; text-align: center; font-size: 0.9em; 
+        color: #666;">
+            <div style="flex: 1;">
+                <div style="border: 1px solid #ffcc80; padding: 
+                8px; margin: 5px; background: #fff3e0; 
+                border-radius: 4px;">
+                    മെമ്മറി ഉപയോഗം<br/>∝ Length²
+                </div>
+            </div>
+            <div style="flex: 1;">
+                <div style="border: 1px solid #90caf9; padding: 
+                8px; margin: 5px; background: #e3f2fd; 
+                border-radius: 4px;">
+                    പ്രോസസ്സിംഗ് സമയം<br/>∝ Length
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+### KV കാഷ് ഒപ്റ്റിമൈസേഷൻ
+
+ഈ വെല്ലുവിളികൾ പരിഹരിക്കാനുള്ള ഏറ്റവും ശക്തമായ ഒപ്റ്റിമൈസേഷനുകളിലൊന്ന് KV (Key-Value) കാഷിംഗ് ആണ്. ഇടക്കാല കണക്കുകൂട്ടലുകൾ സംഭരിച്ച് വീണ്ടും ഉപയോഗിക്കുന്നതിലൂടെ ഈ വിദ്യ ഇൻഫറൻസ് വേഗം കാര്യമായി മെച്ചപ്പെടുത്തുന്നു. ഈ ഒപ്റ്റിമൈസേഷൻ:
+- ആവർത്തിച്ചുള്ള കണക്കുകൂട്ടലുകൾ കുറയ്ക്കുന്നു
+- ജനറേഷൻ വേഗം മെച്ചപ്പെടുത്തുന്നു
+- നീളമുള്ള കോൺടെക്‌സ്‌റ്റുള്ള ജനറേഷനെ പ്രായോഗികമാക്കുന്നു
+
+ഇതിന്റെ വിലയായി അധിക മെമ്മറി ഉപയോഗം വേണ്ടിവരും; എന്നാൽ പ്രകടനത്തിലെ നേട്ടങ്ങൾ സാധാരണയായി ഈ ചെലവിനെ ബഹുദൂരം മറികടക്കുന്നു.
+
+## ഉപസംഹാരം
+
+ശക്തമായ ഈ മോഡലുകൾ ഫലപ്രദമായി ഡിപ്ലോയ് ചെയ്യാനും ഒപ്റ്റിമൈസ് ചെയ്യാനും LLM ഇൻഫറൻസ് മനസ്സിലാക്കുന്നത് നിർണ്ണായകമാണ്. നാം പരിശോധിച്ച പ്രധാന ഘടകങ്ങൾ:
+
+- അറ്റൻഷന്റെയും കോൺടെക്‌സ്‌റ്റിന്റെയും അടിസ്ഥാന പങ്ക്
+- രണ്ട് ഘട്ടങ്ങളുള്ള ഇൻഫറൻസ് പ്രക്രിയ
+- ജനറേഷൻ നിയന്ത്രിക്കാനുള്ള വിവിധ സാംപ്ലിംഗ് സ്ട്രാറ്റജികൾ
+- പ്രായോഗിക വെല്ലുവിളികളും ഒപ്റ്റിമൈസേഷനുകളും
+
+ഈ ആശയങ്ങളിൽ പ്രാവീണ്യം നേടുന്നതിലൂടെ, LLM-കളെ ഫലപ്രദമായും കാര്യക്ഷമമായും ഉപയോഗിക്കുന്ന ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ നിങ്ങൾ കൂടുതൽ സജ്ജരാകും.
+
+LLM ഇൻഫറൻസ് എന്ന മേഖല അതിവേഗം വികസിച്ചുകൊണ്ടിരിക്കുന്നു എന്നും, പുതിയ വിദ്യകളും ഒപ്റ്റിമൈസേഷനുകളും നിരന്തരം ഉയർന്നുവരുന്നുണ്ട് എന്നും ഓർക്കുക. ജിജ്ഞാസ നിലനിർത്തുക; നിങ്ങളുടെ പ്രത്യേക ഉപയോഗങ്ങൾക്ക് ഏറ്റവും അനുയോജ്യമായത് കണ്ടെത്താൻ വ്യത്യസ്ത സമീപനങ്ങൾ പരീക്ഷിച്ചുകൊണ്ടിരിക്കുക.

From 977fa55abfe04b65be24286f4291255f1ab05a66 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:16:12 +0530
Subject: [PATCH 12/44] Add Malayalam translation of chapter1/9.mdx (Bias and
 limitations)

This section discusses biases and limitations of pre-trained models, using BERT as an example to illustrate potential gender biases in outputs.
---
 chapters/ml/chapter1/9.mdx | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 chapters/ml/chapter1/9.mdx

diff --git a/chapters/ml/chapter1/9.mdx b/chapters/ml/chapter1/9.mdx
new file mode 100644
index 000000000..86a9d76e9
--- /dev/null
+++ b/chapters/ml/chapter1/9.mdx
@@ -0,0 +1,32 @@
+# പക്ഷപാതവും പരിമിതികളും[[bias-and-limitations]]
+
+<CourseFloatingBanner chapter={1}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter1/section8.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter1/section8.ipynb"},
+]} />
+
+പ്രീട്രെയിൻ ചെയ്ത ഒരു മോഡലോ ഫൈൻ-ട്യൂൻ ചെയ്ത ഒരു പതിപ്പോ പ്രൊഡക്ഷനിൽ ഉപയോഗിക്കാനാണ് നിങ്ങളുടെ ഉദ്ദേശ്യമെങ്കിൽ, ഈ മോഡലുകൾ ശക്തമായ ടൂളുകളാണെങ്കിലും അവയ്ക്ക് പരിമിതികളുണ്ടെന്ന് ദയവായി ഓർക്കുക. അവയിൽ ഏറ്റവും വലുത് ഇതാണ്: വലിയ അളവിലുള്ള ഡേറ്റയിൽ പ്രീട്രെയിനിംഗ് സാധ്യമാക്കാൻ, ഗവേഷകർ പലപ്പോഴും കണ്ടെത്താനാവുന്ന എല്ലാ ഉള്ളടക്കവും സ്‌ക്രേപ്പ് ചെയ്യുന്നു — ഇന്റർനെറ്റിൽ ലഭ്യമായതിൽ ഏറ്റവും നല്ലതും ഏറ്റവും മോശവുമായതെല്ലാം ഉൾപ്പെടെ. 
+
+ഒരു ചെറിയ ഉദാഹരണം കാണിക്കാൻ, BERT മോഡൽ ഉപയോഗിക്കുന്ന `fill-mask` പൈപ്പ്‌ലൈനിന്റെ ഉദാഹരണത്തിലേക്ക് നമുക്ക് തിരിച്ചുപോകാം:
+
+```python
+from transformers import pipeline
+
+unmasker = pipeline("fill-mask", model="bert-base-uncased")
+result = unmasker("This man works as a [MASK].")
+print([r["token_str"] for r in result])
+
+result = unmasker("This woman works as a [MASK].")
+print([r["token_str"] for r in result])
+```
+
+```python out
+['lawyer', 'carpenter', 'doctor', 'waiter', 'mechanic']
+['nurse', 'waitress', 'teacher', 'maid', 'prostitute']
+```
+
+ഈ രണ്ട് വാക്യങ്ങളിലെയും വിട്ടുപോയ വാക്ക് പൂരിപ്പിക്കാൻ ആവശ്യപ്പെട്ടപ്പോൾ, ലിംഗഭേദമില്ലാത്ത ഒരേയൊരു ഉത്തരം മാത്രമേ മോഡൽ നൽകുന്നുള്ളൂ (waiter/waitress). ബാക്കിയുള്ളവ സാധാരണയായി ഒരു പ്രത്യേക ലിംഗവുമായി ബന്ധപ്പെടുത്തുന്ന തൊഴിലുകളാണ് -- അതെ, "woman" (സ്ത്രീ), "work" (ജോലി) എന്നിവയുമായി മോഡൽ ബന്ധപ്പെടുത്തുന്ന ആദ്യ 5 സാധ്യതകളിൽ prostitute എന്ന വാക്ക് വരെ വന്നു. ഇന്റർനെറ്റിലുടനീളമുള്ള ഡേറ്റ സ്‌ക്രേപ്പ് ചെയ്ത് നിർമ്മിക്കാത്ത, പകരം പ്രത്യക്ഷത്തിൽ നിഷ്‌പക്ഷമെന്ന് തോന്നുന്ന ഡേറ്റ ഉപയോഗിച്ച് നിർമ്മിച്ച അപൂർവ്വം Transformer മോഡലുകളിൽ ഒന്നാണ് BERT എന്നിരിക്കെയാണ് ഇത് സംഭവിക്കുന്നത് ([English Wikipedia](https://huggingface.co/datasets/wikipedia), [BookCorpus](https://huggingface.co/datasets/bookcorpus) എന്നീ ഡേറ്റാസെറ്റുകളിലാണ് ഇത് പരിശീലിപ്പിച്ചിട്ടുള്ളത്). 
+
+അതിനാൽ ഈ ടൂളുകൾ ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾ ഉപയോഗിക്കുന്ന മൂല മോഡൽ ലിംഗവിവേചനപരമോ, വംശീയമോ, സ്വവർഗ്ഗാനുരാഗവിരുദ്ധമോ ആയ ഉള്ളടക്കം വളരെ എളുപ്പത്തിൽ ജനറേറ്റ് ചെയ്യാനിടയുണ്ട് എന്നത് നിങ്ങൾ മനസ്സിൽ സൂക്ഷിക്കേണ്ടതുണ്ട്. നിങ്ങളുടെ ഡേറ്റയിൽ മോഡൽ ഫൈൻ-ട്യൂൻ ചെയ്താലും ഈ അന്തർലീനമായ പക്ഷപാതം ഇല്ലാതാകില്ല.

From bdd512cdf5d01d824f7f9d853f643052bfb8f60a Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:21:49 +0530
Subject: [PATCH 13/44] Add Malayalam translation of chapter1/10.mdx (Summary)

Introduced a new chapter on Transformers and Large Language Models, covering fundamental concepts, capabilities, architectures, recent developments, and practical applications.
---
 chapters/ml/chapter1/10.mdx | 66 +++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 chapters/ml/chapter1/10.mdx

diff --git a/chapters/ml/chapter1/10.mdx b/chapters/ml/chapter1/10.mdx
new file mode 100644
index 000000000..539b425bc
--- /dev/null
+++ b/chapters/ml/chapter1/10.mdx
@@ -0,0 +1,66 @@
+# സംഗ്രഹം[[summary]]
+
+<CourseFloatingBanner
+    chapter={1}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+ഈ അധ്യായത്തിൽ, Transformer മോഡലുകളുടെയും വലിയ ഭാഷാ മോഡലുകളുടെയും (Large Language Models, LLM-കൾ) അടിസ്ഥാനങ്ങളും, അവ AI-യിലും അതിനപ്പുറവും എങ്ങനെ വിപ്ലവം സൃഷ്ടിക്കുന്നു എന്നതും നിങ്ങൾക്ക് പരിചയപ്പെടുത്തി.
+
+## പ്രതിപാദിച്ച പ്രധാന ആശയങ്ങൾ
+
+### Natural Language Processing-ഉം LLM-കളും
+
+NLP എന്താണെന്നും വലിയ ഭാഷാ മോഡലുകൾ ഈ മേഖലയെ എങ്ങനെ മാറ്റിമറിച്ചു എന്നും നാം പരിശോധിച്ചു. നിങ്ങൾ പഠിച്ചത്:
+- വർഗ്ഗീകരണം (classification) മുതൽ ജനറേഷൻ വരെ വിപുലമായ ടാസ്‌ക്കുകൾ NLP ഉൾക്കൊള്ളുന്നു
+- LLM-കൾ വൻതോതിലുള്ള ടെക്‌സ്‌റ്റ് ഡേറ്റയിൽ പരിശീലിപ്പിച്ച ശക്തമായ മോഡലുകളാണ്
+- ഈ മോഡലുകൾക്ക് ഒരൊറ്റ ആർക്കിടെക്ചറിനുള്ളിൽ ഒന്നിലധികം ടാസ്‌ക്കുകൾ നിർവഹിക്കാൻ കഴിയും
+- കഴിവുകൾ ഉണ്ടെങ്കിലും, hallucination-ഉം പക്ഷപാതവും (bias) ഉൾപ്പെടെയുള്ള പരിമിതികൾ LLM-കൾക്കുണ്ട്
+
+### Transformer-ന്റെ കഴിവുകൾ
+
+🤗 Transformers-ലെ `pipeline()` ഫംഗ്‌ഷൻ വിവിധ ടാസ്‌ക്കുകൾക്കായി പ്രീട്രെയിൻ ചെയ്ത മോഡലുകൾ ഉപയോഗിക്കുന്നത് എങ്ങനെ എളുപ്പമാക്കുന്നു എന്ന് നിങ്ങൾ കണ്ടു:
+- ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷൻ, ടോക്കൺ ക്ലാസിഫിക്കേഷൻ, ചോദ്യോത്തരം (question answering)
+- ടെക്‌സ്‌റ്റ് ജനറേഷനും സംഗ്രഹവും (summarization)
+- വിവർത്തനവും മറ്റ് sequence-to-sequence ടാസ്‌ക്കുകളും
+- സംഭാഷണം തിരിച്ചറിയലും (speech recognition) ഇമേജ് ക്ലാസിഫിക്കേഷനും
+
+### Transformer ആർക്കിടെക്ചർ
+
+Transformer മോഡലുകൾ ഉയർന്ന തലത്തിൽ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് നാം ചർച്ച ചെയ്തു, ഇവ ഉൾപ്പെടെ:
+- അറ്റൻഷൻ മെക്കാനിസത്തിന്റെ പ്രാധാന്യം
+- നിർദ്ദിഷ്ട ടാസ്‌ക്കുകളിലേക്ക് പൊരുത്തപ്പെടാൻ transfer learning മോഡലുകളെ എങ്ങനെ പ്രാപ്തമാക്കുന്നു
+- മൂന്ന് പ്രധാന ആർക്കിടെക്ചർ വകഭേദങ്ങൾ: എൻകോഡർ-മാത്രം, ഡീകോഡർ-മാത്രം, എൻകോഡർ-ഡീകോഡർ
+
+### മോഡൽ ആർക്കിടെക്ചറുകളും അവയുടെ പ്രയോഗങ്ങളും
+വ്യത്യസ്ത ടാസ്‌ക്കുകൾക്ക് ഏത് ആർക്കിടെക്ചർ ഉപയോഗിക്കണം എന്ന് മനസ്സിലാക്കുന്നത് ഈ അധ്യായത്തിന്റെ ഒരു പ്രധാന ഭാഗമായിരുന്നു:
+
+| മോഡൽ           | ഉദാഹരണങ്ങൾ                                   | ടാസ്‌ക്കുകൾ                                                                            |
+|-----------------|--------------------------------------------|----------------------------------------------------------------------------------|
+| എൻകോഡർ-മാത്രം    | BERT, DistilBERT, ModernBERT               | വാക്യ വർഗ്ഗീകരണം, named entity recognition, extractive question answering |
+| ഡീകോഡർ-മാത്രം    | GPT, LLaMA, Gemma, SmolLM                  | ടെക്‌സ്‌റ്റ് ജനറേഷൻ, സംഭാഷണാത്മക AI, സർഗ്ഗാത്മക രചന                             |
+| എൻകോഡർ-ഡീകോഡർ | BART, T5, Marian, mBART                    | സംഗ്രഹം, വിവർത്തനം, generative question answering                        |
+
+### ആധുനിക LLM സംഭവവികാസങ്ങൾ
+ഈ മേഖലയിലെ സമീപകാല സംഭവവികാസങ്ങളെക്കുറിച്ചും നിങ്ങൾ പഠിച്ചു:
+- കാലക്രമേണ LLM-കൾ വലിപ്പത്തിലും കഴിവിലും എങ്ങനെ വളർന്നു
+- സ്‌കെയിലിംഗ് നിയമങ്ങൾ (scaling laws) എന്ന ആശയവും അവ മോഡൽ വികസനത്തെ എങ്ങനെ നയിക്കുന്നു എന്നതും
+- ദൈർഘ്യമേറിയ സീക്വൻസുകൾ പ്രോസസ്സ് ചെയ്യാൻ മോഡലുകളെ സഹായിക്കുന്ന പ്രത്യേക അറ്റൻഷൻ മെക്കാനിസങ്ങൾ
+- പ്രീട്രെയിനിംഗും instruction tuning-ഉം എന്ന രണ്ട് ഘട്ടങ്ങളുള്ള പരിശീലന സമീപനം
+
+### പ്രായോഗിക പ്രയോഗങ്ങൾ
+അധ്യായത്തിലുടനീളം, ഈ മോഡലുകൾ യഥാർത്ഥ ലോക പ്രശ്നങ്ങളിൽ എങ്ങനെ പ്രയോഗിക്കാം എന്ന് നിങ്ങൾ കണ്ടു:
+- പ്രീട്രെയിൻ ചെയ്ത മോഡലുകൾ കണ്ടെത്താനും ഉപയോഗിക്കാനും Hugging Face Hub ഉപയോഗിക്കുന്നത്
+- നിങ്ങളുടെ ബ്രൗസറിൽ നേരിട്ട് മോഡലുകൾ പരീക്ഷിക്കാൻ Inference API പ്രയോജനപ്പെടുത്തുന്നത്
+- നിർദ്ദിഷ്ട ടാസ്‌ക്കുകൾക്ക് ഏറ്റവും അനുയോജ്യമായ മോഡലുകൾ ഏതെന്ന് മനസ്സിലാക്കുന്നത്
+
+## മുന്നോട്ടുള്ള വഴി
+
+Transformer മോഡലുകൾ എന്താണെന്നും ഉയർന്ന തലത്തിൽ അവ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ചും ഉറച്ച ധാരണ ലഭിച്ചതിനാൽ, അവ ഫലപ്രദമായി എങ്ങനെ ഉപയോഗിക്കാം എന്നതിലേക്ക് കൂടുതൽ ആഴത്തിൽ ഇറങ്ങാൻ നിങ്ങൾ തയ്യാറാണ്. അടുത്ത അധ്യായങ്ങളിൽ, നിങ്ങൾ പഠിക്കുന്നത്:
+
+- മോഡലുകൾ ലോഡ് ചെയ്യാനും ഫൈൻ-ട്യൂൻ ചെയ്യാനും Transformers ലൈബ്രറി ഉപയോഗിക്കുന്നത്
+- മോഡൽ ഇൻപുട്ടിനായി വിവിധ തരം ഡേറ്റ പ്രോസസ്സ് ചെയ്യുന്നത്
+- പ്രീട്രെയിൻ ചെയ്ത മോഡലുകളെ നിങ്ങളുടെ നിർദ്ദിഷ്ട ടാസ്‌ക്കുകളിലേക്ക് പൊരുത്തപ്പെടുത്തുന്നത്
+- പ്രായോഗിക പ്രയോഗങ്ങൾക്കായി മോഡലുകൾ ഡിപ്ലോയ് ചെയ്യുന്നത്
+
+വരാനിരിക്കുന്ന ഭാഗങ്ങളിൽ കൂടുതൽ വിപുലമായ വിഷയങ്ങളും സാങ്കേതിക വിദ്യകളും പരിശോധിക്കുമ്പോൾ, ഈ അധ്യായത്തിൽ നിങ്ങൾ കെട്ടിപ്പടുത്ത അടിത്തറ നിങ്ങൾക്ക് ഏറെ പ്രയോജനപ്പെടും.

From 5cb786ba0e395524c6d19367228cb70391c72ec9 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:23:00 +0530
Subject: [PATCH 14/44] Add Malayalam translation of chapter1/11.mdx
 (Certification exam)

Added a quiz section to test knowledge on chapter concepts.
---
 chapters/ml/chapter1/11.mdx | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 chapters/ml/chapter1/11.mdx

diff --git a/chapters/ml/chapter1/11.mdx b/chapters/ml/chapter1/11.mdx
new file mode 100644
index 000000000..60af7b209
--- /dev/null
+++ b/chapters/ml/chapter1/11.mdx
@@ -0,0 +1,21 @@
+# പരീക്ഷാ സമയം!
+
+നിങ്ങളുടെ അറിവ് പരീക്ഷിക്കാനുള്ള സമയമായി! ഈ അധ്യായത്തിൽ പ്രതിപാദിച്ച ആശയങ്ങളെക്കുറിച്ചുള്ള നിങ്ങളുടെ ധാരണ പരിശോധിക്കാൻ ഒരു ചെറിയ ക്വിസ് നാം തയ്യാറാക്കിയിട്ടുണ്ട്.
+
+ക്വിസിൽ പങ്കെടുക്കാൻ, നിങ്ങൾ ഈ ഘട്ടങ്ങൾ പിന്തുടരേണ്ടതുണ്ട്:
+
+1. നിങ്ങളുടെ Hugging Face അക്കൗണ്ടിലേക്ക് സൈൻ ഇൻ ചെയ്യുക.
+2. ക്വിസിലെ ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുക.
+3. നിങ്ങളുടെ ഉത്തരങ്ങൾ സമർപ്പിക്കുക.
+
+
+## മൾട്ടിപ്പിൾ ചോയ്‌സ് ക്വിസ്
+
+ഈ ക്വിസിൽ, ഓപ്‌ഷനുകളുടെ ഒരു പട്ടികയിൽ നിന്ന് ശരിയായ ഉത്തരം തിരഞ്ഞെടുക്കാൻ നിങ്ങളോട് ആവശ്യപ്പെടും. supervised ഫൈൻ-ട്യൂണിംഗിന്റെ അടിസ്ഥാനങ്ങളിലാണ് നാം നിങ്ങളെ പരീക്ഷിക്കുന്നത്.
+
+<iframe
+	src="https://huggingface-course-chapter-1-exam.hf.space"
+	frameborder="0"
+	width="850"
+	height="450"
+></iframe>

From ad1a9f49f96a15f199717b153cba09f147ec10b5 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:23:48 +0530
Subject: [PATCH 15/44] Add Malayalam row to translations table in
 chapters/en/chapter1/1.mdx

Added Malayalam language link for chapter 1.
---
 chapters/en/chapter1/1.mdx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/chapters/en/chapter1/1.mdx b/chapters/en/chapter1/1.mdx
index 9294f9af1..e36ac521f 100644
--- a/chapters/en/chapter1/1.mdx
+++ b/chapters/en/chapter1/1.mdx
@@ -141,6 +141,7 @@ Thanks to our wonderful community, the course is available in many languages bey
 | [Thai](https://huggingface.co/course/th/chapter1/1) (WIP)                     | [@peeraponw](https://github.com/peeraponw), [@a-krirk](https://github.com/a-krirk), [@jomariya23156](https://github.com/jomariya23156), [@ckingkan](https://github.com/ckingkan)                                                                                                                                                                         |
 | [Turkish](https://huggingface.co/course/tr/chapter1/1) (WIP)                  | [@tanersekmen](https://github.com/tanersekmen), [@mertbozkir](https://github.com/mertbozkir), [@ftarlaci](https://github.com/ftarlaci), [@akkasayaz](https://github.com/akkasayaz)                                                                                                                                                                       |
 | [Chinese (traditional)](https://huggingface.co/course/zh-TW/chapter1/1) (WIP) | [@davidpeng86](https://github.com/davidpeng86)                                                                                                                                                                                                                                                                                                           |
+| [Malayalam](https://huggingface.co/course/ml/chapter1/1) (WIP)                | [@nikhilkilivayil](https://github.com/nikhilkilivayil)                                                                                                                                                  |
 
 For some languages, the [course YouTube videos](https://youtube.com/playlist?list=PLo2EIpI_JMQvWfQndUesu0nPBAtZ9gP1o) have subtitles in the language. You can enable them by first clicking the _CC_ button in the bottom right corner of the video. Then, under the settings icon ⚙️, you can select the language you want by selecting the _Subtitles/CC_ option.
 

From 77f5730676e26cd0c8cb5f502f969a7e16018ced Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:24:37 +0530
Subject: [PATCH 16/44] Add Malayalam (ml) to README translations table

Added Malayalam language section for course translation.
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index d26b326b1..d1ba443ad 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,7 @@ This repo contains the content that's used to create the **[Hugging Face course]
 | [Chinese (simplified)](https://huggingface.co/course/zh-CN/chapter1/1)  | [`chapters/zh-CN`](https://github.com/huggingface/course/tree/main/chapters/zh-CN) | [@zhlhyx](https://github.com/zhlhyx), [petrichor1122](https://github.com/petrichor1122), [@1375626371](https://github.com/1375626371)                                                                                                                                                                                                                    |
 | [Chinese (traditional)](https://huggingface.co/course/zh-TW/chapter1/1) (WIP) | [`chapters/zh-TW`](https://github.com/huggingface/course/tree/main/chapters/zh-TW) | [@davidpeng86](https://github.com/davidpeng86), [@thliang01](https://github.com/thliang01)                                                                                                                                                                                                                                                                                                           |
 | [Romanian](https://huggingface.co/course/ro/chapter1/1) (WIP) | [`chapters/ro`](https://github.com/huggingface/course/tree/main/chapters/ro) | [@Sigmoid](https://github.com/SigmoidAI), [@eduard-balamatiuc](https://github.com/eduard-balamatiuc), [@FriptuLudmila](https://github.com/FriptuLudmila), [@tokyo-s](https://github.com/tokyo-s), [@hbkdesign](https://github.com/hbkdesign), [@grumpycatyo-collab](https://github.com/grumpycatyo-collab), [@Angroys](https://github.com/Angroys)                                                                                                                                                                                                                                                                                                             |
+| [Malayalam](https://huggingface.co/course/ml/chapter1/1) (WIP) | [`chapters/ml`](https://github.com/huggingface/course/tree/main/chapters/ml) | [@nikhilkilivayil](https://github.com/nikhilkilivayil) |
 
 ### Translating the course into your language
 

From 7ff3f8b9a6b26bc6dd9cfb743ed5ccb597a28bd7 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:25:29 +0530
Subject: [PATCH 17/44] Add ml to docs build languages
 (build_documentation.yml)

---
 .github/workflows/build_documentation.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build_documentation.yml b/.github/workflows/build_documentation.yml
index a3e462fbe..339d7a254 100644
--- a/.github/workflows/build_documentation.yml
+++ b/.github/workflows/build_documentation.yml
@@ -14,6 +14,6 @@ jobs:
       package: course
       path_to_docs: course/chapters/
       additional_args: --not_python_module
-      languages: ar bn de en es fa fr gj he hi id it ja ko my ne pl pt ru ro te th tr vi zh-CN zh-TW
+      languages: ar bn de en es fa fr gj he hi id it ja ko ml my ne pl pt ru ro te th tr vi zh-CN zh-TW
     secrets:
       hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}

From 0111f1c25baa2f9a718a2e28e8c5e81fb2017038 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:26:29 +0530
Subject: [PATCH 18/44] Add ml to PR docs build languages
 (build_pr_documentation.yml)

---
 .github/workflows/build_pr_documentation.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build_pr_documentation.yml b/.github/workflows/build_pr_documentation.yml
index 7bceda10f..dde410abc 100644
--- a/.github/workflows/build_pr_documentation.yml
+++ b/.github/workflows/build_pr_documentation.yml
@@ -16,4 +16,4 @@ jobs:
       package: course
       path_to_docs: course/chapters/
       additional_args: --not_python_module
-      languages: ar bn de en es fa fr gj he hi id it ja ko my ne pl pt ru ro te th tr vi zh-CN zh-TW
+      languages: ar bn de en es fa fr gj he hi id it ja ko ml my ne pl pt ru ro te th tr vi zh-CN zh-TW

From b87ddd65e7d29a2e57cfbeccec944e5d355fa381 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:27:39 +0530
Subject: [PATCH 19/44] =?UTF-8?q?Fix=20typo=20in=20chapter0/1.mdx=20(?=
 =?UTF-8?q?=E0=B4=A8=E0=B4=BF=E0=B4=99=E0=B5=8D=E0=B4=99=E0=B5=BE)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 chapters/ml/chapter0/1.mdx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/chapters/ml/chapter0/1.mdx b/chapters/ml/chapter0/1.mdx
index 25b78f665..8d992746f 100644
--- a/chapters/ml/chapter0/1.mdx
+++ b/chapters/ml/chapter0/1.mdx
@@ -101,7 +101,7 @@ which python
 
 ### ഡിപ്പൻഡൻസികൾ ഇൻസ്‌റ്റാൾ ചെയ്യുന്നത്[[installing-dependencies]]
 
-Google Colab ഇൻസ്‌റ്റൻസുകൾ ഉപയോഗിക്കുന്നതിനെക്കുറിച്ചുള്ള മുൻ വിഭാഗത്തിലെപ്പോലെ, തുടരാൻ ആവശ്യമായ പാക്കേജുകൾ ഇപ്പോൾ നിങ്ങൽ ഇൻസ്‌റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. `pip` പാക്കേജ് മാനേജർ ഉപയോഗിച്ച് 🤗 Transformers-ന്റെ ഡെവലപ്‌മെന്റ് പതിപ്പ് വീണ്ടും ഇങ്ങനെ ഇൻസ്‌റ്റാൾ ചെയ്യാം:
+Google Colab ഇൻസ്‌റ്റൻസുകൾ ഉപയോഗിക്കുന്നതിനെക്കുറിച്ചുള്ള മുൻ വിഭാഗത്തിലെപ്പോലെ, തുടരാൻ ആവശ്യമായ പാക്കേജുകൾ ഇപ്പോൾ നിങ്ങൾ ഇൻസ്‌റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. `pip` പാക്കേജ് മാനേജർ ഉപയോഗിച്ച് 🤗 Transformers-ന്റെ ഡെവലപ്‌മെന്റ് പതിപ്പ് വീണ്ടും ഇങ്ങനെ ഇൻസ്‌റ്റാൾ ചെയ്യാം:
 
 ```
 pip install "transformers[sentencepiece]"

From 07b145ac28f267ee8417a5f56bf287922b3ec5d5 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:29:02 +0530
Subject: [PATCH 20/44] =?UTF-8?q?Fix=20typo=20in=20chapter1/4.mdx=20(?=
 =?UTF-8?q?=E0=B4=A8=E0=B4=BF=E0=B4=99=E0=B5=8D=E0=B4=99=E0=B5=BE)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 chapters/ml/chapter1/4.mdx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/chapters/ml/chapter1/4.mdx b/chapters/ml/chapter1/4.mdx
index 4d0d0fdd5..d79d68d6e 100644
--- a/chapters/ml/chapter1/4.mdx
+++ b/chapters/ml/chapter1/4.mdx
@@ -110,7 +110,7 @@ Self-supervised learning എന്നത് മോഡലിന്റെ ഇൻ
 
 ഈ പ്രീട്രെയിനിംഗ് സാധാരണയായി വളരെ വലിയ അളവിലുള്ള ഡേറ്റയിലാണ് ചെയ്യുന്നത്. അതിനാൽ, ഇതിന് വളരെ വലിയ ഒരു ഡേറ്റാ കോർപ്പസ് ആവശ്യമാണ്, പരിശീലനം പല ആഴ്ചകൾ വരെ നീണ്ടുനിൽക്കാം.
 
-മറുവശത്ത്, *ഫൈൻ-ട്യൂണിംഗ്* എന്നത് ഒരു മോഡൽ പ്രീട്രെയിൻ ചെയ്തതിനു **ശേഷം** നടത്തുന്ന പരിശീലനമാണ്. ഫൈൻ-ട്യൂണിംഗ് നടത്താൻ, നിങ്ങൽ ആദ്യം പ്രീട്രെയിൻ ചെയ്ത ഒരു ഭാഷാ മോഡൽ സ്വന്തമാക്കുന്നു, പിന്നീട് നിങ്ങളുടെ ടാസ്‌ക്കിന് പ്രത്യേകമായ ഒരു ഡേറ്റാസെറ്റ് ഉപയോഗിച്ച് അധിക പരിശീലനം നടത്തുന്നു. ഒരു നിമിഷം -- എന്തുകൊണ്ട് നിങ്ങളുടെ അന്തിമ ഉപയോഗത്തിനായി തുടക്കം മുതൽ (**scratch**) തന്നെ മോഡലിനെ പരിശീലിപ്പിക്കുന്നില്ല? അതിന് ചില കാരണങ്ങളുണ്ട്:
+മറുവശത്ത്, *ഫൈൻ-ട്യൂണിംഗ്* എന്നത് ഒരു മോഡൽ പ്രീട്രെയിൻ ചെയ്തതിനു **ശേഷം** നടത്തുന്ന പരിശീലനമാണ്. ഫൈൻ-ട്യൂണിംഗ് നടത്താൻ, നിങ്ങൾ ആദ്യം പ്രീട്രെയിൻ ചെയ്ത ഒരു ഭാഷാ മോഡൽ സ്വന്തമാക്കുന്നു, പിന്നീട് നിങ്ങളുടെ ടാസ്‌ക്കിന് പ്രത്യേകമായ ഒരു ഡേറ്റാസെറ്റ് ഉപയോഗിച്ച് അധിക പരിശീലനം നടത്തുന്നു. ഒരു നിമിഷം -- എന്തുകൊണ്ട് നിങ്ങളുടെ അന്തിമ ഉപയോഗത്തിനായി തുടക്കം മുതൽ (**scratch**) തന്നെ മോഡലിനെ പരിശീലിപ്പിക്കുന്നില്ല? അതിന് ചില കാരണങ്ങളുണ്ട്:
 
 *  ഫൈൻ-ട്യൂണിംഗ് ഡേറ്റാസെറ്റുമായി ചില സാമ്യങ്ങളുള്ള ഒരു ഡേറ്റാസെറ്റിൽ പ്രീട്രെയിൻ ചെയ്ത മോഡൽ ഇതിനകം പരിശീലിപ്പിക്കപ്പെട്ടിട്ടുണ്ട്. അതിനാൽ പ്രീട്രെയിനിംഗ് സമയത്ത് ആദ്യ മോഡൽ നേടിയ അറിവ് ഫൈൻ-ട്യൂണിംഗ് പ്രക്രിയയ്ക്ക് പ്രയോജനപ്പെടുത്താൻ കഴിയും (ഉദാഹരണത്തിന്, NLP പ്രശ്നങ്ങളിൽ, നിങ്ങളുടെ ടാസ്‌ക്കിനായി നിങ്ങൾ ഉപയോഗിക്കുന്ന ഭാഷയെക്കുറിച്ച് പ്രീട്രെയിൻ ചെയ്ത മോഡലിന് ഏതെങ്കിലും തരത്തിലുള്ള സ്ഥിതിവിവരപരമായ ധാരണ ഉണ്ടായിരിക്കും). 
 *  പ്രീട്രെയിൻ ചെയ്ത മോഡൽ ഇതിനകം ധാരാളം ഡേറ്റയിൽ പരിശീലിപ്പിക്കപ്പെട്ടതിനാൽ, തൃപ്തികരമായ ഫലങ്ങൾ ലഭിക്കാൻ ഫൈൻ-ട്യൂണിംഗിന് വളരെ കുറച്ച് ഡേറ്റ മതി.

From 16e76e16e9cedce78ff8e6def9f67799163eb503 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 03:30:38 +0530
Subject: [PATCH 21/44] =?UTF-8?q?Fix=20typo=20in=20chapter1/5.mdx=20(?=
 =?UTF-8?q?=E0=B4=A8=E0=B4=BF=E0=B4=99=E0=B5=8D=E0=B4=99=E0=B5=BE)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Updated the explanation of using a pre-trained model for automatic speech recognition, clarifying the encoder-decoder structure and training process.
---
 chapters/ml/chapter1/5.mdx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/chapters/ml/chapter1/5.mdx b/chapters/ml/chapter1/5.mdx
index a9a31901b..dd8992503 100644
--- a/chapters/ml/chapter1/5.mdx
+++ b/chapters/ml/chapter1/5.mdx
@@ -176,7 +176,7 @@ Transformers ടെക്‌സ്‌റ്റിൽ മാത്രം ഒത
 
 ### ഓട്ടോമാറ്റിക് സ്പീച്ച് റെക്കഗ്നിഷൻ
 
-പ്രീട്രെയിൻ ചെയ്ത മോഡൽ ഓട്ടോമാറ്റിക് സ്പീച്ച് റെക്കഗ്നിഷനായി ഉപയോഗിക്കാൻ, അതിന്റെ പൂർണ്ണമായ എൻകോഡർ-ഡീകോഡർ ഘടന നിങ്ങൽ പ്രയോജനപ്പെടുത്തുന്നു. എൻകോഡർ ഓഡിയോ ഇൻപുട്ട് പ്രോസസ്സ് ചെയ്യുന്നു, ഡീകോഡർ ട്രാൻസ്ക്രിപ്‌റ്റ് ടോക്കൺ ടോക്കണായി ഓട്ടോറിഗ്രസ്സീവായി സൃഷ്ടിക്കുന്നു. ഫൈൻ-ട്യൂണിംഗ് ചെയ്യുമ്പോൾ, ഓഡിയോ ഇൻപുട്ടിന്റെ അടിസ്ഥാനത്തിൽ ശരിയായ ടെക്‌സ്‌റ്റ് ടോക്കണുകൾ പ്രവചിക്കാൻ ഒരു സ്റ്റാൻഡേർഡ് സീക്വൻസ്-ടു-സീക്വൻസ് ലോസ് (ക്രോസ്-എൻട്രോപ്പി പോലുള്ളത്) ഉപയോഗിച്ചാണ് മോഡൽ സാധാരണയായി പരിശീലിപ്പിക്കുന്നത്.
+പ്രീട്രെയിൻ ചെയ്ത മോഡൽ ഓട്ടോമാറ്റിക് സ്പീച്ച് റെക്കഗ്നിഷനായി ഉപയോഗിക്കാൻ, അതിന്റെ പൂർണ്ണമായ എൻകോഡർ-ഡീകോഡർ ഘടന നിങ്ങൾ പ്രയോജനപ്പെടുത്തുന്നു. എൻകോഡർ ഓഡിയോ ഇൻപുട്ട് പ്രോസസ്സ് ചെയ്യുന്നു, ഡീകോഡർ ട്രാൻസ്ക്രിപ്‌റ്റ് ടോക്കൺ ടോക്കണായി ഓട്ടോറിഗ്രസ്സീവായി സൃഷ്ടിക്കുന്നു. ഫൈൻ-ട്യൂണിംഗ് ചെയ്യുമ്പോൾ, ഓഡിയോ ഇൻപുട്ടിന്റെ അടിസ്ഥാനത്തിൽ ശരിയായ ടെക്‌സ്‌റ്റ് ടോക്കണുകൾ പ്രവചിക്കാൻ ഒരു സ്റ്റാൻഡേർഡ് സീക്വൻസ്-ടു-സീക്വൻസ് ലോസ് (ക്രോസ്-എൻട്രോപ്പി പോലുള്ളത്) ഉപയോഗിച്ചാണ് മോഡൽ സാധാരണയായി പരിശീലിപ്പിക്കുന്നത്.
 
 ഫൈൻ-ട്യൂൻ ചെയ്ത ഒരു മോഡൽ ഇൻഫറൻസിനായി ഉപയോഗിക്കാനുള്ള ഏറ്റവും എളുപ്പമുള്ള മാർഗം ഒരു `pipeline`-നുള്ളിലാണ്.
 

From b85e2e2f969fa6afe75001389f0d2fbf44b93bfb Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 12:11:30 +0530
Subject: [PATCH 22/44] Add Malayalam translation for chapter2/1.mdx

---
 chapters/ml/chapter2/1.mdx | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 chapters/ml/chapter2/1.mdx

diff --git a/chapters/ml/chapter2/1.mdx b/chapters/ml/chapter2/1.mdx
new file mode 100644
index 000000000..1afcfcc6e
--- /dev/null
+++ b/chapters/ml/chapter2/1.mdx
@@ -0,0 +1,24 @@
+# ആമുഖം[[introduction]]
+
+<CourseFloatingBanner
+    chapter={2}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+[അധ്യായം 1](/course/chapter1)-ൽ നിങ്ങൾ കണ്ടതുപോലെ, Transformer മോഡലുകൾ സാധാരണയായി വളരെ വലുതാണ്. ദശലക്ഷക്കണക്കിന് മുതൽ പല *ബില്യൺ* വരെ പാരാമീറ്ററുകളുള്ള ഈ മോഡലുകളെ പരിശീലിപ്പിക്കുന്നതും വിന്യസിക്കുന്നതും (deploy) സങ്കീർണ്ണമായ ഒരു ജോലിയാണ്. കൂടാതെ, ഏകദേശം ദിവസേനയെന്നോണം പുതിയ മോഡലുകൾ പുറത്തിറങ്ങുന്നതും അവയ്ക്ക് ഓരോന്നിനും അതിന്റേതായ ഇംപ്ലിമെന്റേഷൻ ഉള്ളതും കാരണം, അവയെല്ലാം പരീക്ഷിച്ചുനോക്കുക എന്നത് എളുപ്പമുള്ള കാര്യമല്ല.
+
+ഈ പ്രശ്നം പരിഹരിക്കാനാണ് 🤗 Transformers ലൈബ്രറി സൃഷ്ടിച്ചത്. ഏത് Transformer മോഡലും ലോഡ് ചെയ്യാനും പരിശീലിപ്പിക്കാനും സേവ് ചെയ്യാനും കഴിയുന്ന ഒരൊറ്റ API നൽകുക എന്നതാണ് ഇതിന്റെ ലക്ഷ്യം. ലൈബ്രറിയുടെ പ്രധാന സവിശേഷതകൾ ഇവയാണ്:
+
+- **ഉപയോഗിക്കാനുള്ള എളുപ്പം**: അത്യാധുനികമായ ഒരു NLP മോഡൽ ഡൗൺലോഡ് ചെയ്യുന്നതും ലോഡ് ചെയ്യുന്നതും ഇൻഫറൻസിനായി ഉപയോഗിക്കുന്നതും വെറും രണ്ട് വരി കോഡിൽ ചെയ്യാൻ കഴിയും.
+- **വഴക്കം (Flexibility)**: അടിസ്ഥാനപരമായി, എല്ലാ മോഡലുകളും ലളിതമായ PyTorch `nn.Module` ക്ലാസുകളാണ്; അതത് മെഷീൻ ലേണിംഗ് (ML) ഫ്രെയിംവർക്കുകളിലെ മറ്റേതൊരു മോഡലിനെയും പോലെ ഇവയെ കൈകാര്യം ചെയ്യാം.
+- **ലാളിത്യം**: ലൈബ്രറിയിലുടനീളം അബ്‌സ്ട്രാക്‌ഷനുകൾ ഏറെക്കുറെ ഇല്ല എന്നു പറയാം. "എല്ലാം ഒരൊറ്റ ഫയലിൽ" (All in one file) എന്നത് ഒരു അടിസ്ഥാന ആശയമാണ്: ഒരു മോഡലിന്റെ ഫോർവേഡ് പാസ് (forward pass) പൂർണ്ണമായും ഒരൊറ്റ ഫയലിലാണ് നിർവചിച്ചിരിക്കുന്നത്; അതിനാൽ കോഡ് തന്നെ മനസ്സിലാക്കാവുന്നതും മാറ്റം വരുത്തി പരീക്ഷിക്കാവുന്നതും (hackable) ആണ്.
+
+ഈ അവസാനത്തെ സവിശേഷത 🤗 Transformers-നെ മറ്റ് ML ലൈബ്രറികളിൽ നിന്ന് തികച്ചും വ്യത്യസ്തമാക്കുന്നു. ഫയലുകൾക്കിടയിൽ പങ്കുവെക്കപ്പെടുന്ന മൊഡ്യൂളുകളുടെ മേലല്ല മോഡലുകൾ 
+നിർമ്മിച്ചിരിക്കുന്നത്; പകരം, ഓരോ മോഡലിനും അതിന്റേതായ ലെയറുകളുണ്ട്. മോഡലുകളെ കൂടുതൽ സമീപിക്കാവുന്നതും മനസ്സിലാക്കാവുന്നതുമാക്കുന്നതിനു പുറമേ, മറ്റ് മോഡലുകളെ ബാധിക്കാതെ ഒരു മോഡലിൽ എളുപ്പത്തിൽ പരീക്ഷണം നടത്താനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.
+
+[അധ്യായം 1](/course/chapter1)-ൽ പരിചയപ്പെടുത്തിയ `pipeline()` ഫംഗ്‌ഷനെ ഒരു മോഡലും ഒരു ടോക്കണൈസറും ഒരുമിച്ച് ഉപയോഗിച്ച് പുനഃസൃഷ്ടിക്കുന്ന, തുടക്കം മുതൽ അവസാനം വരെയുള്ള (end-to-end) ഒരു ഉദാഹരണത്തോടെയാണ് ഈ അധ്യായം ആരംഭിക്കുന്നത്. അടുത്തതായി, മോഡൽ API-യെക്കുറിച്ച് നമ്മൾ ചർച്ച ചെയ്യും: മോഡൽ ക്ലാസുകളിലേക്കും കോൺഫിഗറേഷൻ ക്ലാസുകളിലേക്കും ആഴത്തിൽ കടന്ന്, ഒരു മോഡൽ എങ്ങനെ ലോഡ് ചെയ്യാമെന്നും അത് സംഖ്യാ ഇൻപുട്ടുകളെ പ്രോസസ്സ് ചെയ്ത് എങ്ങനെ പ്രവചനങ്ങൾ ഔട്ട്‌പുട്ട് ചെയ്യുന്നു എന്നും ഞങ്ങൾ കാണിച്ചുതരും. 
+
+തുടർന്ന്, `pipeline()` ഫംഗ്‌ഷന്റെ മറ്റൊരു പ്രധാന ഘടകമായ ടോക്കണൈസർ API-യിലേക്ക് നമ്മൾ കടക്കും. പ്രോസസ്സിംഗിന്റെ ആദ്യത്തെയും അവസാനത്തെയും ഘട്ടങ്ങൾ കൈകാര്യം ചെയ്യുന്നത് ടോക്കണൈസറുകളാണ് — ടെക്‌സ്‌റ്റിനെ ന്യൂറൽ നെറ്റ്‌വർക്കിനുള്ള സംഖ്യാ ഇൻപുട്ടുകളാക്കി മാറ്റുന്നതും, ആവശ്യമുള്ളപ്പോൾ അവയെ തിരികെ ടെക്‌സ്‌റ്റാക്കി മാറ്റുന്നതും. അവസാനമായി, തയ്യാറാക്കിയ ഒരു ബാച്ചായി ഒന്നിലധികം വാക്യങ്ങൾ ഒരു മോഡലിലൂടെ എങ്ങനെ കടത്തിവിടാമെന്ന് ഞങ്ങൾ കാണിച്ചുതരും; പിന്നീട് ഉയർന്ന തലത്തിലുള്ള (high-level) `tokenizer()` ഫംഗ്‌ഷനെ കൂടുതൽ അടുത്തറിഞ്ഞുകൊണ്ട് എല്ലാം ഉപസംഹരിക്കും.
+
+> [!TIP]
+> ⚠️ Model Hub-ഉം 🤗 Transformers-ഉം നൽകുന്ന എല്ലാ സവിശേഷതകളും പ്രയോജനപ്പെടുത്താൻ, <a href="https://huggingface.co/join">ഒരു അക്കൗണ്ട് ഉണ്ടാക്കാൻ</a> ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.

From 028193305b98091b01918af1beb3e689a7d22ba9 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 12:18:28 +0530
Subject: [PATCH 23/44] Add Malayalam translation for chapter2/2.mdx

---
 chapters/ml/chapter2/2.mdx | 232 +++++++++++++++++++++++++++++++++++++
 1 file changed, 232 insertions(+)
 create mode 100644 chapters/ml/chapter2/2.mdx

diff --git a/chapters/ml/chapter2/2.mdx b/chapters/ml/chapter2/2.mdx
new file mode 100644
index 000000000..04f2773e3
--- /dev/null
+++ b/chapters/ml/chapter2/2.mdx
@@ -0,0 +1,232 @@
+<FrameworkSwitchCourse {fw} />
+
+# പൈപ്പ്‌ലൈനിന്റെ പിന്നിൽ[[behind-the-pipeline]]
+
+<CourseFloatingBanner chapter={2}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter2/section2_pt.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter2/section2_pt.ipynb"},
+]} />
+
+<Youtube id="1pedAIvTWXk"/>
+
+[അധ്യായം 1](/course/chapter1)-ൽ താഴെ കൊടുത്ത കോഡ് നമ്മൾ റൺ ചെയ്തപ്പോൾ തിരശ്ശീലയ്ക്ക് പിന്നിൽ എന്താണ് സംഭവിച്ചത് എന്ന് പരിശോധിച്ചുകൊണ്ട്, ഒരു പൂർണ്ണമായ ഉദാഹരണത്തിൽ നിന്ന് തുടങ്ങാം:
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("sentiment-analysis")
+classifier(
+    [
+        "I've been waiting for a HuggingFace course my whole life.",
+        "I hate this so much!",
+    ]
+)
+```
+
+അപ്പോൾ നമുക്ക് ലഭിച്ചത്:
+
+```python out
+[{'label': 'POSITIVE', 'score': 0.9598047137260437},
+ {'label': 'NEGATIVE', 'score': 0.9994558095932007}]
+```
+
+[അധ്യായം 1](/course/chapter1)-ൽ നമ്മൾ കണ്ടതുപോലെ, ഈ പൈപ്പ്‌ലൈൻ മൂന്ന് ഘട്ടങ്ങളെ ഒരുമിച്ച് ചേർക്കുന്നു: പ്രീപ്രോസസ്സിംഗ്, ഇൻപുട്ടുകൾ മോഡലിലൂടെ കടത്തിവിടൽ, പോസ്‌റ്റ്‌പ്രോസസ്സിംഗ്:
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter2/full_nlp_pipeline.svg" alt="പൂർണ്ണമായ NLP പൈപ്പ്‌ലൈൻ: ടെക്‌സ്‌റ്റിന്റെ ടോക്കണൈസേഷൻ, ID-കളിലേക്കുള്ള മാറ്റം, Transformer മോഡലിലൂടെയും മോഡൽ ഹെഡിലൂടെയുമുള്ള ഇൻഫറൻസ്."/>
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter2/full_nlp_pipeline-dark.svg" alt="പൂർണ്ണമായ NLP പൈപ്പ്‌ലൈൻ: ടെക്‌സ്‌റ്റിന്റെ ടോക്കണൈസേഷൻ, ID-കളിലേക്കുള്ള മാറ്റം, Transformer മോഡലിലൂടെയും മോഡൽ ഹെഡിലൂടെയുമുള്ള ഇൻഫറൻസ്."/>
+</div>
+
+ഇവയോരോന്നും വേഗത്തിൽ ഒന്ന് നോക്കാം.
+
+## ഒരു ടോക്കണൈസർ ഉപയോഗിച്ചുള്ള പ്രീപ്രോസസ്സിംഗ്[[preprocessing-with-a-tokenizer]]
+
+മറ്റ് ന്യൂറൽ നെറ്റ്‌വർക്കുകളെപ്പോലെ, Transformer മോഡലുകൾക്കും അസംസ്‌കൃത ടെക്‌സ്‌റ്റ് (raw text) നേരിട്ട് പ്രോസസ്സ് ചെയ്യാൻ കഴിയില്ല; അതിനാൽ നമ്മുടെ പൈപ്പ്‌ലൈനിന്റെ ആദ്യ ഘട്ടം ടെക്‌സ്‌റ്റ് ഇൻപുട്ടുകളെ മോഡലിന് മനസ്സിലാക്കാൻ കഴിയുന്ന സംഖ്യകളാക്കി മാറ്റുകയാണ്. ഇതിനായി നമ്മൾ ഒരു *ടോക്കണൈസർ* ഉപയോഗിക്കുന്നു; അതിന്റെ ചുമതലകൾ ഇവയാണ്:
+
+- ഇൻപുട്ടിനെ *ടോക്കണുകൾ* എന്ന് വിളിക്കുന്ന വാക്കുകളായോ ഉപവാക്കുകളായോ (subwords) ചിഹ്നങ്ങളായോ (വിരാമചിഹ്നങ്ങൾ പോലെ) വിഭജിക്കുക
+- ഓരോ ടോക്കണെയും ഒരു പൂർണ്ണസംഖ്യയുമായി (integer) ബന്ധപ്പെടുത്തുക
+- മോഡലിന് ഉപകാരപ്രദമാകാവുന്ന അധിക ഇൻപുട്ടുകൾ ചേർക്കുക
+
+ഈ പ്രീപ്രോസസ്സിംഗ് മുഴുവനും മോഡൽ പ്രീട്രെയിൻ ചെയ്തപ്പോൾ ചെയ്ത അതേ രീതിയിൽ തന്നെ ചെയ്യേണ്ടതുണ്ട്; അതിനാൽ ആ വിവരങ്ങൾ ആദ്യം [Model Hub](https://huggingface.co/models)-ൽ നിന്ന് ഡൗൺലോഡ് ചെയ്യണം. ഇതിനായി നമ്മൾ `AutoTokenizer` ക്ലാസും അതിന്റെ `from_pretrained()` മെത്തേഡും ഉപയോഗിക്കുന്നു. നമ്മുടെ മോഡലിന്റെ ചെക്ക്‌പോയിന്റ് പേര് ഉപയോഗിച്ച്, മോഡലിന്റെ ടോക്കണൈസറുമായി ബന്ധപ്പെട്ട ഡേറ്റ ഇത് സ്വയമേവ എടുത്ത് കാഷ് ചെയ്യും (അതിനാൽ താഴെയുള്ള കോഡ് നിങ്ങൾ ആദ്യമായി റൺ ചെയ്യുമ്പോൾ മാത്രമേ ഇത് ഡൗൺലോഡ് ചെയ്യപ്പെടുകയുള്ളൂ).
+
+`sentiment-analysis` പൈപ്പ്‌ലൈനിന്റെ ഡിഫോൾട്ട് ചെക്ക്‌പോയിന്റ് `distilbert-base-uncased-finetuned-sst-2-english` ആയതിനാൽ (അതിന്റെ മോഡൽ കാർഡ് [ഇവിടെ](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english) കാണാം), നമ്മൾ താഴെ പറയുന്നത് റൺ ചെയ്യുന്നു:
+
+```python
+from transformers import AutoTokenizer
+
+checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+```
+
+ടോക്കണൈസർ കിട്ടിക്കഴിഞ്ഞാൽ, നമ്മുടെ വാക്യങ്ങൾ നേരിട്ട് അതിലേക്ക് നൽകാം; മോഡലിലേക്ക് നൽകാൻ തയ്യാറായ ഒരു ഡിക്‌ഷണറി നമുക്ക് തിരികെ ലഭിക്കും! ഇനി ചെയ്യാനുള്ള ഒരേയൊരു കാര്യം ഇൻപുട്ട് ID-കളുടെ ലിസ്‌റ്റിനെ ടെൻസറുകളാക്കി (tensors) മാറ്റുകയാണ്.
+
+ബാക്കെൻഡായി ഏത് ML ഫ്രെയിംവർക്കാണ് ഉപയോഗിക്കുന്നത് എന്നതിനെക്കുറിച്ച് വിഷമിക്കാതെ നിങ്ങൾക്ക് 🤗 Transformers ഉപയോഗിക്കാം; ചില മോഡലുകൾക്ക് അത് PyTorch ആകാം, അല്ലെങ്കിൽ Flax ആകാം. എന്നിരുന്നാലും, Transformer മോഡലുകൾ *ടെൻസറുകൾ* മാത്രമേ ഇൻപുട്ടായി സ്വീകരിക്കുകയുള്ളൂ. ടെൻസറുകളെക്കുറിച്ച് നിങ്ങൾ ആദ്യമായി കേൾക്കുന്നതാണെങ്കിൽ, അവയെ NumPy അറേകളായി കരുതാം. ഒരു NumPy അറേ ഒരു സ്‌കെയിലർ (0D) ആകാം, ഒരു വെക്‌റ്റർ (1D) ആകാം, ഒരു മാട്രിക്‌സ് (2D) ആകാം, അല്ലെങ്കിൽ കൂടുതൽ ഡൈമെൻഷനുകൾ ഉള്ളതാകാം. ഫലത്തിൽ അത് ഒരു ടെൻസറാണ്; മറ്റ് ML ഫ്രെയിംവർക്കുകളിലെ ടെൻസറുകളും ഇതുപോലെ തന്നെ പെരുമാറുന്നു, സാധാരണയായി NumPy അറേകൾ പോലെ എളുപ്പത്തിൽ അവ ഉണ്ടാക്കാനും (instantiate) കഴിയും.
+
+നമുക്ക് തിരികെ ലഭിക്കേണ്ട ടെൻസറുകളുടെ തരം (PyTorch അല്ലെങ്കിൽ സാധാരണ NumPy) വ്യക്തമാക്കാൻ, `return_tensors` ആർഗ്യുമെന്റ് ഉപയോഗിക്കുന്നു:
+
+```python
+raw_inputs = [
+    "I've been waiting for a HuggingFace course my whole life.",
+    "I hate this so much!",
+]
+inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt")
+print(inputs)
+```
+
+പാഡിംഗിനെയും ട്രങ്കേഷനെയും (truncation) കുറിച്ച് ഇപ്പോൾ വിഷമിക്കേണ്ട; അവ പിന്നീട് വിശദീകരിക്കാം. ഇവിടെ ഓർത്തിരിക്കേണ്ട പ്രധാന കാര്യങ്ങൾ ഇവയാണ്: ഒരു വാക്യമോ വാക്യങ്ങളുടെ ഒരു ലിസ്‌റ്റോ നിങ്ങൾക്ക് നൽകാം, കൂടാതെ തിരികെ ലഭിക്കേണ്ട ടെൻസറുകളുടെ തരവും വ്യക്തമാക്കാം (തരം ഒന്നും നൽകിയില്ലെങ്കിൽ, ഫലമായി ലിസ്‌റ്റുകളുടെ ഒരു ലിസ്‌റ്റ് ലഭിക്കും).
+
+PyTorch ടെൻസറുകളായി ഫലങ്ങൾ ഇങ്ങനെയാണ് കാണപ്പെടുന്നത്:
+
+```python out
+{
+    'input_ids': tensor([
+        [  101,  1045,  1005,  2310,  2042,  3403,  2005,  1037, 17662, 12172, 2607,  2026,  2878,  2166,  1012,   102],
+        [  101,  1045,  5223,  2023,  2061,  2172,   999,   102,     0,     0,     0,     0,     0,     0,     0,     0]
+    ]), 
+    'attention_mask': tensor([
+        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+        [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
+    ])
+}
+```
+
+ഔട്ട്‌പുട്ട് തന്നെ `input_ids`, `attention_mask` എന്ന രണ്ട് കീകൾ അടങ്ങിയ ഒരു ഡിക്‌ഷണറിയാണ്. `input_ids`-ൽ പൂർണ്ണസംഖ്യകളുടെ രണ്ട് വരികൾ (ഓരോ വാക്യത്തിനും ഒന്ന്) അടങ്ങിയിരിക്കുന്നു; ഓരോ വാക്യത്തിലെയും ടോക്കണുകളുടെ അനന്യമായ തിരിച്ചറിയൽ സംഖ്യകളാണ് (unique identifiers) ഇവ. `attention_mask` എന്താണെന്ന് ഈ അധ്യായത്തിൽ പിന്നീട് വിശദീകരിക്കാം. 
+
+## മോഡലിലൂടെ കടന്നുപോകുന്നു[[going-through-the-model]]
+
+ടോക്കണൈസർ ഡൗൺലോഡ് ചെയ്ത അതേ രീതിയിൽ നമ്മുടെ പ്രീട്രെയിൻഡ് മോഡലും ഡൗൺലോഡ് ചെയ്യാം. 🤗 Transformers ഒരു `AutoModel` ക്ലാസ് നൽകുന്നു; ഇതിനും ഒരു `from_pretrained()` മെത്തേഡ് ഉണ്ട്:
+
+```python
+from transformers import AutoModel
+
+checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+model = AutoModel.from_pretrained(checkpoint)
+```
+
+ഈ കോഡ് ഭാഗത്തിൽ, മുമ്പ് നമ്മുടെ പൈപ്പ്‌ലൈനിൽ ഉപയോഗിച്ച അതേ ചെക്ക്‌പോയിന്റ് നമ്മൾ ഡൗൺലോഡ് ചെയ്യുകയും (വാസ്തവത്തിൽ അത് ഇതിനകം കാഷ് ചെയ്യപ്പെട്ടിരിക്കണം) അതുപയോഗിച്ച് ഒരു മോഡൽ ഉണ്ടാക്കുകയും (instantiate) ചെയ്തു.
+
+ഈ ആർക്കിടെക്ചറിൽ അടിസ്ഥാന Transformer മൊഡ്യൂൾ മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ: ചില ഇൻപുട്ടുകൾ നൽകിയാൽ, *ഹിഡൻ സ്റ്റേറ്റുകൾ* (hidden states) എന്ന് നമ്മൾ വിളിക്കുന്ന — *ഫീച്ചറുകൾ* (features) എന്നും അറിയപ്പെടുന്ന — ഔട്ട്‌പുട്ടാണ് ഇത് നൽകുന്നത്. ഓരോ മോഡൽ ഇൻപുട്ടിനും, **Transformer മോഡൽ ആ ഇൻപുട്ടിനെ സന്ദർഭാനുസൃതമായി മനസ്സിലാക്കിയതിനെ** പ്രതിനിധീകരിക്കുന്ന ഉയർന്ന ഡൈമെൻഷനുള്ള ഒരു വെക്‌റ്റർ നമുക്ക് ലഭിക്കും.
+
+ഇത് മനസ്സിലായില്ലെങ്കിൽ വിഷമിക്കേണ്ട. എല്ലാം പിന്നീട് വിശദീകരിക്കാം.
+
+ഈ ഹിഡൻ സ്റ്റേറ്റുകൾ അവ തന്നെയായി ഉപകാരപ്രദമാകാമെങ്കിലും, സാധാരണയായി അവ മോഡലിന്റെ *ഹെഡ്* (head) എന്നറിയപ്പെടുന്ന മറ്റൊരു ഭാഗത്തിലേക്കുള്ള ഇൻപുട്ടുകളാണ്. [അധ്യായം 1](/course/chapter1)-ലെ വ്യത്യസ്ത ടാസ്‌ക്കുകൾ ഒരേ ആർക്കിടെക്ചർ ഉപയോഗിച്ച് ചെയ്യാമായിരുന്നു, എന്നാൽ ഈ ടാസ്‌ക്കുകളിൽ ഓരോന്നിനും അതുമായി ബന്ധപ്പെട്ട വ്യത്യസ്തമായ ഒരു ഹെഡ് ഉണ്ടായിരിക്കും.
+
+### ഉയർന്ന ഡൈമെൻഷനുള്ള ഒരു വെക്‌റ്റർ?[[a-high-dimensional-vector]]
+
+Transformer മൊഡ്യൂൾ ഔട്ട്‌പുട്ട് ചെയ്യുന്ന വെക്‌റ്റർ സാധാരണയായി വലുതാണ്. അതിന് പൊതുവെ മൂന്ന് ഡൈമെൻഷനുകളുണ്ട്:
+
+- **ബാച്ച് സൈസ്**: ഒരു സമയത്ത് പ്രോസസ്സ് ചെയ്യുന്ന സീക്വൻസുകളുടെ എണ്ണം (നമ്മുടെ ഉദാഹരണത്തിൽ 2).
+- **സീക്വൻസ് ലെങ്ത്**: സീക്വൻസിന്റെ സംഖ്യാ പ്രതിനിധാനത്തിന്റെ നീളം (നമ്മുടെ ഉദാഹരണത്തിൽ 16).
+- **ഹിഡൻ സൈസ്**: ഓരോ മോഡൽ ഇൻപുട്ടിന്റെയും വെക്‌റ്റർ ഡൈമെൻഷൻ.
+
+അവസാനത്തെ മൂല്യം കാരണമാണ് ഇതിനെ "ഉയർന്ന ഡൈമെൻഷനുള്ളത്" എന്ന് പറയുന്നത്. ഹിഡൻ സൈസ് വളരെ വലുതാകാം (ചെറിയ മോഡലുകളിൽ 768 സാധാരണമാണ്, വലിയ മോഡലുകളിൽ ഇത് 3072-ഓ അതിലധികമോ വരെ എത്താം).
+
+നമ്മൾ പ്രീപ്രോസസ്സ് ചെയ്ത ഇൻപുട്ടുകൾ മോഡലിലേക്ക് നൽകിയാൽ ഇത് കാണാൻ കഴിയും:
+
+```python
+outputs = model(**inputs)
+print(outputs.last_hidden_state.shape)
+```
+
+```python out
+torch.Size([2, 16, 768])
+```
+
+🤗 Transformers മോഡലുകളുടെ ഔട്ട്‌പുട്ടുകൾ `namedtuple`-കളോ ഡിക്‌ഷണറികളോ പോലെയാണ് പെരുമാറുന്നത് എന്നത് ശ്രദ്ധിക്കുക. ആട്രിബ്യൂട്ടുകൾ വഴിയോ (നമ്മൾ ചെയ്തതുപോലെ) കീ വഴിയോ (`outputs["last_hidden_state"]`) നിങ്ങൾക്ക് ഘടകങ്ങൾ ആക്‌സസ് ചെയ്യാം; നിങ്ങൾ തിരയുന്നത് കൃത്യമായി എവിടെയാണെന്ന് അറിയാമെങ്കിൽ ഇൻഡെക്‌സ് വഴിയും (`outputs[0]`) ആക്‌സസ് ചെയ്യാം.
+
+### മോഡൽ ഹെഡുകൾ: സംഖ്യകളിൽ നിന്ന് അർത്ഥം കണ്ടെത്തുന്നു[[model-heads-making-sense-out-of-numbers]]
+
+മോഡൽ ഹെഡുകൾ ഹിഡൻ സ്റ്റേറ്റുകളുടെ ഉയർന്ന ഡൈമെൻഷനുള്ള വെക്‌റ്റർ ഇൻപുട്ടായി സ്വീകരിച്ച് അവയെ മറ്റൊരു ഡൈമെൻഷനിലേക്ക് പ്രൊജക്റ്റ് ചെയ്യുന്നു. സാധാരണയായി ഒന്നോ ഏതാനുമോ ലീനിയർ ലെയറുകൾ ചേർന്നതാണ് ഇവ:
+
+<div class="flex justify-center">
+<img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter2/transformer_and_head.svg" alt="ഒരു Transformer നെറ്റ്‌വർക്കും അതിന്റെ ഹെഡും."/>
+<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter2/transformer_and_head-dark.svg" alt="ഒരു Transformer നെറ്റ്‌വർക്കും അതിന്റെ ഹെഡും."/>
+</div>
+
+Transformer മോഡലിന്റെ ഔട്ട്‌പുട്ട് പ്രോസസ്സ് ചെയ്യപ്പെടാനായി നേരിട്ട് മോഡൽ ഹെഡിലേക്ക് അയയ്ക്കുന്നു.
+
+ഈ ചിത്രത്തിൽ, മോഡലിനെ അതിന്റെ എംബെഡ്ഡിംഗ് ലെയറും തുടർന്നുള്ള ലെയറുകളും ചേർന്നാണ് പ്രതിനിധീകരിക്കുന്നത്. ടോക്കണൈസ് ചെയ്ത ഇൻപുട്ടിലെ ഓരോ ഇൻപുട്ട് ID-യെയും അതുമായി ബന്ധപ്പെട്ട ടോക്കണെ പ്രതിനിധീകരിക്കുന്ന ഒരു വെക്‌റ്ററാക്കി എംബെഡ്ഡിംഗ് ലെയർ മാറ്റുന്നു. തുടർന്നുള്ള ലെയറുകൾ അറ്റൻഷൻ മെക്കാനിസം ഉപയോഗിച്ച് ആ വെക്‌റ്ററുകളിൽ പ്രവർത്തിച്ച് വാക്യങ്ങളുടെ അന്തിമ പ്രതിനിധാനം സൃഷ്ടിക്കുന്നു.
+
+🤗 Transformers-ൽ വ്യത്യസ്തങ്ങളായ നിരവധി ആർക്കിടെക്ചറുകൾ ലഭ്യമാണ്; ഓരോന്നും ഒരു നിശ്ചിത ടാസ്‌ക്ക് കൈകാര്യം ചെയ്യാൻ രൂപകൽപ്പന ചെയ്തവയാണ്. പൂർണ്ണമല്ലാത്ത ഒരു പട്ടിക ഇതാ:
+
+- `*Model` (ഹിഡൻ സ്റ്റേറ്റുകൾ ലഭ്യമാക്കുന്നു)
+- `*ForCausalLM`
+- `*ForMaskedLM`
+- `*ForMultipleChoice`
+- `*ForQuestionAnswering`
+- `*ForSequenceClassification`
+- `*ForTokenClassification`
+- മറ്റുള്ളവയും 🤗
+
+നമ്മുടെ ഉദാഹരണത്തിന്, ഒരു സീക്വൻസ് ക്ലാസിഫിക്കേഷൻ ഹെഡുള്ള ഒരു മോഡൽ ആവശ്യമാണ് (വാക്യങ്ങളെ positive അല്ലെങ്കിൽ negative എന്ന് വർഗ്ഗീകരിക്കാൻ കഴിയാൻ). അതിനാൽ, നമ്മൾ യഥാർത്ഥത്തിൽ `AutoModel` ക്ലാസല്ല, `AutoModelForSequenceClassification` ആണ് ഉപയോഗിക്കുന്നത്:
+
+```python
+from transformers import AutoModelForSequenceClassification
+
+checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+outputs = model(**inputs)
+```
+
+ഇപ്പോൾ നമ്മുടെ ഔട്ട്‌പുട്ടുകളുടെ ഷേപ്പ് (shape) നോക്കിയാൽ, ഡൈമെൻഷണാലിറ്റി വളരെ കുറവായിരിക്കും: മോഡൽ ഹെഡ് നമ്മൾ മുമ്പ് കണ്ട ഉയർന്ന ഡൈമെൻഷനുള്ള വെക്‌റ്ററുകളെ ഇൻപുട്ടായി സ്വീകരിച്ച്, രണ്ട് മൂല്യങ്ങൾ (ഓരോ ലേബലിനും ഒന്ന്) അടങ്ങിയ വെക്‌റ്ററുകൾ ഔട്ട്‌പുട്ട് ചെയ്യുന്നു:
+
+```python
+print(outputs.logits.shape)
+```
+
+```python out
+torch.Size([2, 2])
+```
+
+നമുക്ക് രണ്ട് വാക്യങ്ങളും രണ്ട് ലേബലുകളും മാത്രമുള്ളതിനാൽ, മോഡലിൽ നിന്ന് നമുക്ക് ലഭിക്കുന്ന ഫലത്തിന്റെ ഷേപ്പ് 2 x 2 ആണ്.
+
+## ഔട്ട്‌പുട്ടിന്റെ പോസ്‌റ്റ്‌പ്രോസസ്സിംഗ്[[postprocessing-the-output]]
+
+മോഡലിൽ നിന്ന് ഔട്ട്‌പുട്ടായി നമുക്ക് ലഭിക്കുന്ന മൂല്യങ്ങൾ അവ തന്നെയായി അർത്ഥവത്താകണമെന്നില്ല. ഒന്ന് നോക്കാം:
+
+```python
+print(outputs.logits)
+```
+
+```python out
+tensor([[-1.5607,  1.6123],
+        [ 4.1692, -3.3464]], grad_fn=<AddmmBackward>)
+```
+
+നമ്മുടെ മോഡൽ ആദ്യ വാക്യത്തിന് `[-1.5607, 1.6123]` എന്നും രണ്ടാമത്തേതിന് `[ 4.1692, -3.3464]` എന്നും പ്രവചിച്ചു. ഇവ പ്രോബബിലിറ്റികളല്ല, *ലോജിറ്റുകൾ* (logits) ആണ് — മോഡലിന്റെ അവസാന ലെയർ ഔട്ട്‌പുട്ട് ചെയ്യുന്ന അസംസ്‌കൃതവും നോർമലൈസ് ചെയ്യാത്തതുമായ സ്‌കോറുകൾ. പ്രോബബിലിറ്റികളാക്കി മാറ്റാൻ, ഇവ ഒരു [SoftMax](https://en.wikipedia.org/wiki/Softmax_function) ലെയറിലൂടെ കടന്നുപോകേണ്ടതുണ്ട് (എല്ലാ 🤗 Transformers മോഡലുകളും ലോജിറ്റുകളാണ് ഔട്ട്‌പുട്ട് ചെയ്യുന്നത്, കാരണം പരിശീലനത്തിനുള്ള ലോസ് ഫംഗ്‌ഷൻ സാധാരണയായി SoftMax പോലുള്ള അവസാന ആക്റ്റിവേഷൻ ഫംഗ്‌ഷനെ ക്രോസ് എൻട്രോപ്പി പോലുള്ള യഥാർത്ഥ ലോസ് ഫംഗ്‌ഷനുമായി സംയോജിപ്പിക്കും):
+
+```py
+import torch
+
+predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+print(predictions)
+```
+
+```python out
+tensor([[4.0195e-02, 9.5980e-01],
+        [9.9946e-01, 5.4418e-04]], grad_fn=<SoftmaxBackward>)
+```
+
+ഇപ്പോൾ, മോഡൽ ആദ്യ വാക്യത്തിന് `[0.0402, 0.9598]` എന്നും രണ്ടാമത്തേതിന് `[0.9995,  0.0005]` എന്നും പ്രവചിച്ചതായി കാണാം. ഇവ തിരിച്ചറിയാവുന്ന പ്രോബബിലിറ്റി സ്‌കോറുകളാണ്.
+
+ഓരോ സ്ഥാനത്തിനും അനുയോജ്യമായ ലേബലുകൾ ലഭിക്കാൻ, മോഡൽ കോൺഫിഗിന്റെ `id2label` ആട്രിബ്യൂട്ട് പരിശോധിക്കാം (ഇതിനെക്കുറിച്ച് കൂടുതൽ അടുത്ത ഭാഗത്തിൽ):
+
+```python
+model.config.id2label
+```
+
+```python out
+{0: 'NEGATIVE', 1: 'POSITIVE'}
+```
+
+മോഡൽ താഴെ പറയുന്നവ പ്രവചിച്ചു എന്ന് ഇപ്പോൾ നമുക്ക് നിഗമനത്തിലെത്താം:
+ 
+- ആദ്യ വാക്യം: NEGATIVE: 0.0402, POSITIVE: 0.9598
+- രണ്ടാമത്തെ വാക്യം: NEGATIVE: 0.9995, POSITIVE: 0.0005
+
+പൈപ്പ്‌ലൈനിന്റെ മൂന്ന് ഘട്ടങ്ങളും നമ്മൾ വിജയകരമായി പുനഃസൃഷ്ടിച്ചു: ടോക്കണൈസറുകൾ ഉപയോഗിച്ചുള്ള പ്രീപ്രോസസ്സിംഗ്, ഇൻപുട്ടുകൾ മോഡലിലൂടെ കടത്തിവിടൽ, പോസ്‌റ്റ്‌പ്രോസസ്സിംഗ്! ഇനി ഈ ഘട്ടങ്ങളിൽ ഓരോന്നിലേക്കും കുറച്ചുകൂടി ആഴത്തിൽ ഇറങ്ങാൻ കുറച്ച് സമയമെടുക്കാം.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** നിങ്ങളുടെ സ്വന്തം രണ്ടോ (അതിലധികമോ) ടെക്‌സ്‌റ്റുകൾ തിരഞ്ഞെടുത്ത് `sentiment-analysis` പൈപ്പ്‌ലൈനിലൂടെ റൺ ചെയ്യുക. തുടർന്ന്, ഇവിടെ കണ്ട ഘട്ടങ്ങൾ നിങ്ങൾ സ്വയം ആവർത്തിച്ച്, അതേ ഫലങ്ങൾ ലഭിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക!

From 5c2176e0b2b6aaa9ffca2f6772a2d00968855fd2 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 12:24:05 +0530
Subject: [PATCH 24/44] Add Malayalam translation for chapter2/3.mdx

---
 chapters/ml/chapter2/3.mdx | 297 +++++++++++++++++++++++++++++++++++++
 1 file changed, 297 insertions(+)
 create mode 100644 chapters/ml/chapter2/3.mdx

diff --git a/chapters/ml/chapter2/3.mdx b/chapters/ml/chapter2/3.mdx
new file mode 100644
index 000000000..41a66a80c
--- /dev/null
+++ b/chapters/ml/chapter2/3.mdx
@@ -0,0 +1,297 @@
+<FrameworkSwitchCourse {fw} />
+
+# മോഡലുകൾ[[the-models]]
+
+<CourseFloatingBanner chapter={2}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter2/section3_pt.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter2/section3_pt.ipynb"},
+]} />
+
+<Youtube id="AhChOFRegn4"/>
+
+ഈ ഭാഗത്തിൽ, മോഡലുകൾ ഉണ്ടാക്കുന്നതും ഉപയോഗിക്കുന്നതും കൂടുതൽ അടുത്ത് പരിശോധിക്കാം. ഒരു ചെക്ക്‌പോയിന്റിൽ നിന്ന് ഏത് മോഡലും ഉണ്ടാക്കാൻ (instantiate) ആഗ്രഹിക്കുമ്പോൾ സൗകര്യപ്രദമായ `AutoModel` ക്ലാസാണ് നമ്മൾ ഉപയോഗിക്കുന്നത്.
+
+## ഒരു Transformer ഉണ്ടാക്കുന്നു[[creating-a-transformer]]
+
+ഒരു `AutoModel` നമ്മൾ ഉണ്ടാക്കുമ്പോൾ എന്താണ് സംഭവിക്കുന്നത് എന്ന് പരിശോധിച്ചുകൊണ്ട് തുടങ്ങാം:
+
+```py
+from transformers import AutoModel
+
+model = AutoModel.from_pretrained("bert-base-cased")
+```
+
+ടോക്കണൈസറിന്റെ കാര്യത്തിലേതുപോലെ, `from_pretrained()` മെത്തേഡ് Hugging Face Hub-ൽ നിന്ന് മോഡൽ ഡേറ്റ ഡൗൺലോഡ് ചെയ്ത് കാഷ് ചെയ്യും. മുമ്പ് പറഞ്ഞതുപോലെ, ചെക്ക്‌പോയിന്റ് പേര് ഒരു നിശ്ചിത മോഡൽ ആർക്കിടെക്ചറിനെയും വെയ്‌റ്റുകളെയും സൂചിപ്പിക്കുന്നു; ഈ സാഹചര്യത്തിൽ, അടിസ്ഥാന ആർക്കിടെക്ചറുള്ള (12 ലെയറുകൾ, 768 ഹിഡൻ സൈസ്, 12 അറ്റൻഷൻ ഹെഡുകൾ) ഒരു BERT മോഡലും cased ഇൻപുട്ടുകളും (അതായത്, വലിയക്ഷരം/ചെറിയക്ഷരം എന്ന വ്യത്യാസം പ്രധാനമാണ് എന്നർത്ഥം). Hub-ൽ നിരവധി ചെക്ക്‌പോയിന്റുകൾ ലഭ്യമാണ് — അവ [ഇവിടെ](https://huggingface.co/models) നിങ്ങൾക്ക് പരിശോധിക്കാം.
+
+`AutoModel` ക്ലാസും അതിന്റെ കൂട്ടാളികളും യഥാർത്ഥത്തിൽ, തന്നിരിക്കുന്ന ഒരു ചെക്ക്‌പോയിന്റിന് അനുയോജ്യമായ മോഡൽ ആർക്കിടെക്ചർ കണ്ടെത്താൻ രൂപകൽപ്പന ചെയ്ത ലളിതമായ റാപ്പറുകളാണ് (wrappers). ഇത് ഒരു "auto" ക്ലാസാണ്; അതായത്, അനുയോജ്യമായ മോഡൽ ആർക്കിടെക്ചർ ഇത് നിങ്ങൾക്കായി ഊഹിച്ചെടുത്ത്, ശരിയായ മോഡൽ ക്ലാസ് ഉണ്ടാക്കും. എന്നിരുന്നാലും, ഉപയോഗിക്കേണ്ട മോഡലിന്റെ തരം നിങ്ങൾക്ക് അറിയാമെങ്കിൽ, അതിന്റെ ആർക്കിടെക്ചർ നിർവചിക്കുന്ന ക്ലാസ് നേരിട്ട് ഉപയോഗിക്കാം:
+
+```py
+from transformers import BertModel
+
+model = BertModel.from_pretrained("bert-base-cased")
+```
+
+## ലോഡ് ചെയ്യലും സേവ് ചെയ്യലും[[loading-and-saving]]
+
+ഒരു മോഡൽ സേവ് ചെയ്യുന്നത് ഒരു ടോക്കണൈസർ സേവ് ചെയ്യുന്നതുപോലെ എളുപ്പമാണ്. വാസ്തവത്തിൽ, മോഡലുകൾക്കും അതേ `save_pretrained()` മെത്തേഡ് തന്നെയാണ് ഉള്ളത്; ഇത് മോഡലിന്റെ വെയ്‌റ്റുകളും ആർക്കിടെക്ചർ കോൺഫിഗറേഷനും സേവ് ചെയ്യുന്നു:
+
+```py
+model.save_pretrained("directory_on_my_computer")
+```
+
+ഇത് നിങ്ങളുടെ ഡിസ്‌കിലേക്ക് രണ്ട് ഫയലുകൾ സേവ് ചെയ്യും:
+
+```
+ls directory_on_my_computer
+
+config.json model.safetensors
+```
+
+*config.json* ഫയലിനുള്ളിൽ നോക്കിയാൽ, മോഡൽ ആർക്കിടെക്ചർ നിർമ്മിക്കാൻ ആവശ്യമായ എല്ലാ ആട്രിബ്യൂട്ടുകളും നിങ്ങൾക്ക് കാണാം. ചെക്ക്‌പോയിന്റ് എവിടെ നിന്ന് ഉത്ഭവിച്ചു, ചെക്ക്‌പോയിന്റ് അവസാനമായി സേവ് ചെയ്തപ്പോൾ നിങ്ങൾ ഏത് 🤗 Transformers പതിപ്പാണ് ഉപയോഗിച്ചിരുന്നത് തുടങ്ങിയ ചില മെറ്റാഡേറ്റയും ഈ ഫയലിൽ അടങ്ങിയിരിക്കുന്നു.
+
+*pytorch_model.safetensors* ഫയൽ സ്റ്റേറ്റ് ഡിക്‌ഷണറി (state dictionary) എന്നാണ് അറിയപ്പെടുന്നത്; നിങ്ങളുടെ മോഡലിന്റെ എല്ലാ വെയ്‌റ്റുകളും ഇതിൽ അടങ്ങിയിരിക്കുന്നു. ഈ രണ്ട് ഫയലുകളും ഒരുമിച്ചാണ് പ്രവർത്തിക്കുന്നത്: മോഡൽ ആർക്കിടെക്ചറിനെക്കുറിച്ച് അറിയാൻ കോൺഫിഗറേഷൻ ഫയൽ ആവശ്യമാണ്, അതേസമയം മോഡൽ വെയ്‌റ്റുകൾ മോഡലിന്റെ പാരാമീറ്ററുകളാണ്.
+
+സേവ് ചെയ്ത ഒരു മോഡൽ വീണ്ടും ഉപയോഗിക്കാൻ, `from_pretrained()` മെത്തേഡ് വീണ്ടും ഉപയോഗിക്കുക:
+
+```py
+from transformers import AutoModel
+
+model = AutoModel.from_pretrained("directory_on_my_computer")
+```
+
+മോഡലുകളും ടോക്കണൈസറുകളും കമ്മ്യൂണിറ്റിയുമായി എളുപ്പത്തിൽ പങ്കുവെക്കാനുള്ള കഴിവാണ് 🤗 Transformers ലൈബ്രറിയുടെ അതിമനോഹരമായ ഒരു സവിശേഷത. ഇതിനായി, [Hugging Face](https://huggingface.co)-ൽ നിങ്ങൾക്ക് ഒരു അക്കൗണ്ട് ഉണ്ടെന്ന് ഉറപ്പാക്കുക. നിങ്ങൾ ഒരു നോട്ട്‌ബുക്ക് ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ, ഇതുപയോഗിച്ച് എളുപ്പത്തിൽ ലോഗിൻ ചെയ്യാം:
+
+```python
+from huggingface_hub import notebook_login
+
+notebook_login()
+```
+
+അല്ലെങ്കിൽ, നിങ്ങളുടെ ടെർമിനലിൽ ഇത് റൺ ചെയ്യുക:
+
+```bash
+huggingface-cli login
+```
+
+തുടർന്ന് `push_to_hub()` മെത്തേഡ് ഉപയോഗിച്ച് മോഡൽ Hub-ലേക്ക് പുഷ് ചെയ്യാം:
+
+```py
+model.push_to_hub("my-awesome-model")
+```
+
+ഇത് മോഡൽ ഫയലുകൾ Hub-ലേക്ക്, നിങ്ങളുടെ നെയിംസ്‌പേസിന് കീഴിലുള്ള *my-awesome-model* എന്ന റിപ്പോസിറ്ററിയിലേക്ക് അപ്‌ലോഡ് ചെയ്യും. പിന്നീട്, ആർക്കും `from_pretrained()` മെത്തേഡ് ഉപയോഗിച്ച് നിങ്ങളുടെ മോഡൽ ലോഡ് ചെയ്യാം!
+
+```py
+from transformers import AutoModel
+
+model = AutoModel.from_pretrained("your-username/my-awesome-model")
+```
+
+Hub API ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇനിയും ഒരുപാട് കാര്യങ്ങൾ ചെയ്യാം:
+- ഒരു ലോക്കൽ റിപ്പോസിറ്ററിയിൽ നിന്ന് ഒരു മോഡൽ പുഷ് ചെയ്യുക
+- എല്ലാം വീണ്ടും അപ്‌ലോഡ് ചെയ്യാതെ നിശ്ചിത ഫയലുകൾ മാത്രം അപ്‌ഡേറ്റ് ചെയ്യുക
+- മോഡലിന്റെ കഴിവുകൾ, പരിമിതികൾ, അറിയപ്പെടുന്ന പക്ഷപാതങ്ങൾ (biases) മുതലായവ രേഖപ്പെടുത്താൻ മോഡൽ കാർഡുകൾ ചേർക്കുക
+
+ഇതിനെക്കുറിച്ചുള്ള ഒരു പൂർണ്ണമായ ട്യൂട്ടോറിയലിന് [ഡോക്യുമെന്റേഷൻ](https://huggingface.co/docs/huggingface_hub/how-to-upstream) കാണുക, അല്ലെങ്കിൽ കൂടുതൽ ഉയർന്ന തലത്തിലുള്ള [അധ്യായം 4](/course/chapter4) നോക്കുക.
+
+## ടെക്‌സ്‌റ്റ് എൻകോഡ് ചെയ്യുന്നു[[encoding-text]]
+
+Transformer മോഡലുകൾ ഇൻപുട്ടുകളെ സംഖ്യകളാക്കി മാറ്റിയാണ് ടെക്‌സ്‌റ്റ് കൈകാര്യം ചെയ്യുന്നത്. നിങ്ങളുടെ ടെക്‌സ്‌റ്റ് ടോക്കണൈസർ പ്രോസസ്സ് ചെയ്യുമ്പോൾ കൃത്യമായി എന്താണ് സംഭവിക്കുന്നത് എന്ന് ഇവിടെ നമ്മൾ നോക്കും. ടോക്കണൈസറുകൾ ടെക്‌സ്‌റ്റിനെ ടോക്കണുകളായി വിഭജിക്കുകയും പിന്നീട് ഈ ടോക്കണുകളെ സംഖ്യകളാക്കി മാറ്റുകയും ചെയ്യുന്നു എന്ന് [അധ്യായം 1](/course/chapter1)-ൽ നമ്മൾ ഇതിനകം കണ്ടു. ഒരു ലളിതമായ ടോക്കണൈസറിലൂടെ ഈ മാറ്റം നമുക്ക് കാണാം:
+
+```py
+from transformers import AutoTokenizer
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+
+encoded_input = tokenizer("Hello, I'm a single sentence!")
+print(encoded_input)
+```
+
+```python out
+{'input_ids': [101, 8667, 117, 1000, 1045, 1005, 1049, 2235, 17662, 12172, 1012, 102], 
+ 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
+ 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
+```
+
+താഴെ പറയുന്ന ഫീൽഡുകളുള്ള ഒരു ഡിക്‌ഷണറി നമുക്ക് ലഭിക്കുന്നു:
+- input_ids: നിങ്ങളുടെ ടോക്കണുകളുടെ സംഖ്യാ പ്രതിനിധാനങ്ങൾ
+- token_type_ids: ഇൻപുട്ടിന്റെ ഏത് ഭാഗം വാക്യം A ആണെന്നും ഏത് ഭാഗം വാക്യം B ആണെന്നും ഇവ മോഡലിനോട് പറയുന്നു (അടുത്ത ഭാഗത്തിൽ കൂടുതൽ ചർച്ച ചെയ്യുന്നു)
+- attention_mask: ഏതൊക്കെ ടോക്കണുകൾ ശ്രദ്ധിക്കണം (attend), ഏതൊക്കെ ശ്രദ്ധിക്കേണ്ടതില്ല എന്ന് ഇത് സൂചിപ്പിക്കുന്നു (അൽപ്പം കഴിഞ്ഞ് കൂടുതൽ ചർച്ച ചെയ്യുന്നു)
+
+യഥാർത്ഥ ടെക്‌സ്‌റ്റ് തിരികെ ലഭിക്കാൻ ഇൻപുട്ട് ID-കൾ ഡീകോഡ് ചെയ്യാം:
+
+```py
+tokenizer.decode(encoded_input["input_ids"])
+```
+
+```python out
+"[CLS] Hello, I'm a single sentence! [SEP]"
+```
+
+മോഡലിന് ആവശ്യമായ പ്രത്യേക ടോക്കണുകൾ — `[CLS]`, `[SEP]` — ടോക്കണൈസർ ചേർത്തിട്ടുണ്ടെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കും. എല്ലാ മോഡലുകൾക്കും പ്രത്യേക ടോക്കണുകൾ ആവശ്യമില്ല; ഒരു മോഡൽ അവ ഉപയോഗിച്ച് പ്രീട്രെയിൻ ചെയ്തിട്ടുണ്ടെങ്കിലാണ് അവ ഉപയോഗപ്പെടുത്തുന്നത്; അങ്ങനെയുള്ള സാഹചര്യത്തിൽ, ആ മോഡൽ ഈ ടോക്കണുകൾ പ്രതീക്ഷിക്കുന്നതിനാൽ ടോക്കണൈസർ അവ ചേർക്കേണ്ടതുണ്ട്.
+
+ഒന്നിലധികം വാക്യങ്ങൾ ഒരേസമയം എൻകോഡ് ചെയ്യാം — അവയെ ഒരുമിച്ച് ബാച്ച് ചെയ്യുന്നതിലൂടെയോ (ഇത് ഉടൻ ചർച്ച ചെയ്യും) ഒരു ലിസ്‌റ്റ് നൽകുന്നതിലൂടെയോ:
+
+```py
+encoded_input = tokenizer("How are you?", "I'm fine, thank you!")
+print(encoded_input)
+```
+
+```python out
+{'input_ids': [[101, 1731, 1132, 1128, 136, 102], [101, 1045, 1005, 1049, 2503, 117, 5763, 1128, 136, 102]], 
+ 'token_type_ids': [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 
+ 'attention_mask': [[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}
+```
+
+ഒന്നിലധികം വാക്യങ്ങൾ നൽകുമ്പോൾ, ഓരോ ഡിക്‌ഷണറി മൂല്യത്തിനും ഓരോ വാക്യത്തിനുമായി ഒരു ലിസ്‌റ്റ് വീതം ടോക്കണൈസർ തിരികെ നൽകുന്നു എന്നത് ശ്രദ്ധിക്കുക. PyTorch-ൽ നിന്നുള്ള ടെൻസറുകൾ നേരിട്ട് തിരികെ നൽകാനും ടോക്കണൈസറിനോട് ആവശ്യപ്പെടാം:
+
+```py
+encoded_input = tokenizer("How are you?", "I'm fine, thank you!", return_tensors="pt")
+print(encoded_input)
+```
+
+```python out
+{'input_ids': tensor([[  101,  1731,  1132,  1128,   136,   102],
+         [  101,  1045,  1005,  1049,  2503,   117,  5763,  1128,   136,   102]]), 
+ 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 
+ 'attention_mask': tensor([[1, 1, 1, 1, 1, 1],
+         [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}
+```
+
+എന്നാൽ ഇവിടെ ഒരു പ്രശ്നമുണ്ട്: രണ്ട് ലിസ്‌റ്റുകൾക്കും ഒരേ നീളമല്ല! അറേകളും ടെൻസറുകളും ചതുരാകൃതിയിലുള്ളതാകണം (rectangular), അതിനാൽ ഈ ലിസ്‌റ്റുകളെ അതേപടി ഒരു PyTorch ടെൻസറാക്കി (അല്ലെങ്കിൽ NumPy അറേയാക്കി) മാറ്റാൻ കഴിയില്ല. ഇതിനായി ടോക്കണൈസർ ഒരു ഓപ്‌ഷൻ നൽകുന്നു: പാഡിംഗ്.
+
+### ഇൻപുട്ടുകൾ പാഡ് ചെയ്യുന്നു[[padding-inputs]]
+
+ഇൻപുട്ടുകൾ പാഡ് ചെയ്യാൻ ടോക്കണൈസറിനോട് ആവശ്യപ്പെട്ടാൽ, ഏറ്റവും നീളമുള്ള വാക്യത്തേക്കാൾ ചെറിയ വാക്യങ്ങളിൽ ഒരു പ്രത്യേക പാഡിംഗ് ടോക്കൺ ചേർത്ത് അത് എല്ലാ വാക്യങ്ങളെയും ഒരേ നീളത്തിലാക്കും:
+
+```py
+encoded_input = tokenizer(
+    ["How are you?", "I'm fine, thank you!"], padding=True, return_tensors="pt"
+)
+print(encoded_input)
+```
+
+```python out
+{'input_ids': tensor([[  101,  1731,  1132,  1128,   136,   102,     0,     0,     0,     0],
+         [  101,  1045,  1005,  1049,  2503,   117,  5763,  1128,   136,   102]]), 
+ 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 
+ 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
+         [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])}
+```
+
+ഇപ്പോൾ നമുക്ക് ചതുരാകൃതിയിലുള്ള ടെൻസറുകൾ ലഭിച്ചു! പാഡിംഗ് ടോക്കണുകൾ ID 0 ഉള്ള ഇൻപുട്ട് ID-കളായി എൻകോഡ് ചെയ്യപ്പെട്ടിരിക്കുന്നു എന്നതും, അവയുടെ അറ്റൻഷൻ മാസ്‌ക് മൂല്യവും 0 ആണെന്നതും ശ്രദ്ധിക്കുക. ആ പാഡിംഗ് ടോക്കണുകൾ മോഡൽ വിശകലനം ചെയ്യേണ്ടതില്ല എന്നതാണ് ഇതിന് കാരണം: അവ യഥാർത്ഥ വാക്യത്തിന്റെ ഭാഗമല്ല.
+
+### ഇൻപുട്ടുകൾ ട്രങ്കേറ്റ് ചെയ്യുന്നു[[truncating-inputs]]
+
+മോഡലിന് പ്രോസസ്സ് ചെയ്യാൻ കഴിയാത്തവിധം ടെൻസറുകൾ വളരെ വലുതായേക്കാം. ഉദാഹരണത്തിന്, BERT 512 ടോക്കണുകൾ വരെയുള്ള സീക്വൻസുകൾ ഉപയോഗിച്ച് മാത്രമാണ് പ്രീട്രെയിൻ ചെയ്തിട്ടുള്ളത്, അതിനാൽ അതിനേക്കാൾ നീളമുള്ള സീക്വൻസുകൾ ഇതിന് പ്രോസസ്സ് ചെയ്യാൻ കഴിയില്ല. മോഡലിന് കൈകാര്യം ചെയ്യാൻ കഴിയുന്നതിലും നീളമുള്ള സീക്വൻസുകൾ നിങ്ങൾക്കുണ്ടെങ്കിൽ, `truncation` പാരാമീറ്റർ ഉപയോഗിച്ച് അവ ട്രങ്കേറ്റ് ചെയ്യേണ്ടിവരും (വെട്ടിച്ചുരുക്കേണ്ടിവരും):
+
+```py
+encoded_input = tokenizer(
+    "This is a very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very long sentence.",
+    truncation=True,
+)
+print(encoded_input["input_ids"])
+```
+
+```python out
+[101, 1188, 1110, 170, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1179, 5650, 119, 102]
+```
+
+പാഡിംഗ്, ട്രങ്കേഷൻ ആർഗ്യുമെന്റുകൾ സംയോജിപ്പിച്ച്, നിങ്ങളുടെ ടെൻസറുകൾക്ക് ആവശ്യമായ കൃത്യമായ വലിപ്പം ഉണ്ടെന്ന് ഉറപ്പാക്കാം:
+
+```py
+encoded_input = tokenizer(
+    ["How are you?", "I'm fine, thank you!"],
+    padding=True,
+    truncation=True,
+    max_length=5,
+    return_tensors="pt",
+)
+print(encoded_input)
+```
+
+```python out
+{'input_ids': tensor([[  101,  1731,  1132,  1128,   102],
+         [  101,  1045,  1005,  1049,   102]]), 
+ 'token_type_ids': tensor([[0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0]]), 
+ 'attention_mask': tensor([[1, 1, 1, 1, 1],
+         [1, 1, 1, 1, 1]])}
+```
+
+### പ്രത്യേക ടോക്കണുകൾ ചേർക്കുന്നു
+
+പ്രത്യേക ടോക്കണുകൾ (അല്ലെങ്കിൽ കുറഞ്ഞപക്ഷം അവയുടെ ആശയം) BERT-നും അതിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ മോഡലുകൾക്കും വിശേഷിച്ചും പ്രധാനമാണ്. ഒരു വാക്യത്തിന്റെ തുടക്കം (`[CLS]`) അല്ലെങ്കിൽ വാക്യങ്ങൾക്കിടയിലുള്ള വേർതിരിവ് (`[SEP]`) പോലുള്ള വാക്യ അതിരുകളെ കൂടുതൽ നന്നായി പ്രതിനിധീകരിക്കാനാണ് ഈ ടോക്കണുകൾ ചേർക്കുന്നത്. ഒരു ലളിതമായ ഉദാഹരണം നോക്കാം:
+
+```py
+encoded_input = tokenizer("How are you?")
+print(encoded_input["input_ids"])
+tokenizer.decode(encoded_input["input_ids"])
+```
+
+```python out
+[101, 1731, 1132, 1128, 136, 102]
+'[CLS] How are you? [SEP]'
+```
+
+ഈ പ്രത്യേക ടോക്കണുകൾ ടോക്കണൈസർ സ്വയമേവ ചേർക്കുന്നവയാണ്. എല്ലാ മോഡലുകൾക്കും പ്രത്യേക ടോക്കണുകൾ ആവശ്യമില്ല; ഒരു മോഡൽ അവ ഉപയോഗിച്ച് പ്രീട്രെയിൻ ചെയ്തിട്ടുണ്ടെങ്കിലാണ് പ്രധാനമായും അവ ഉപയോഗിക്കുന്നത്; അങ്ങനെയുള്ള സാഹചര്യത്തിൽ, മോഡൽ അവ പ്രതീക്ഷിക്കുന്നതിനാൽ ടോക്കണൈസർ അവ ചേർക്കും.
+
+### ഇതെല്ലാം എന്തിനാണ് ആവശ്യം?
+
+വ്യക്തമായ ഒരു ഉദാഹരണം ഇതാ. ഈ എൻകോഡ് ചെയ്ത സീക്വൻസുകൾ പരിഗണിക്കുക:
+
+```py
+sequences = [
+    "I've been waiting for a HuggingFace course my whole life.",
+    "I hate this so much!",
+]
+```
+
+ടോക്കണൈസ് ചെയ്തുകഴിഞ്ഞാൽ, നമുക്ക് ലഭിക്കുന്നത്:
+
+```python
+encoded_sequences = [
+    [
+        101,
+        1045,
+        1005,
+        2310,
+        2042,
+        3403,
+        2005,
+        1037,
+        17662,
+        12172,
+        2607,
+        2026,
+        2878,
+        2166,
+        1012,
+        102,
+    ],
+    [101, 1045, 5223, 2023, 2061, 2172, 999, 102],
+]
+```
+
+ഇത് എൻകോഡ് ചെയ്ത സീക്വൻസുകളുടെ ഒരു ലിസ്‌റ്റാണ്: ലിസ്‌റ്റുകളുടെ ഒരു ലിസ്‌റ്റ്. ടെൻസറുകൾ ചതുരാകൃതിയിലുള്ള ഷേപ്പുകൾ മാത്രമേ സ്വീകരിക്കുകയുള്ളൂ (മാട്രിക്‌സുകൾ എന്ന് കരുതുക). ഈ "അറേ" ഇതിനകം ചതുരാകൃതിയിലുള്ളതാണ്, അതിനാൽ അതിനെ ഒരു ടെൻസറാക്കി മാറ്റുന്നത് എളുപ്പമാണ്:
+
+```py
+import torch
+
+model_inputs = torch.tensor(encoded_sequences)
+```
+
+### ടെൻസറുകളെ മോഡലിന്റെ ഇൻപുട്ടുകളായി ഉപയോഗിക്കുന്നു[[using-the-tensors-as-inputs-to-the-model]]
+
+ടെൻസറുകളെ മോഡലിനൊപ്പം ഉപയോഗിക്കുന്നത് അതീവ ലളിതമാണ് — ഇൻപുട്ടുകൾ നൽകി മോഡലിനെ വിളിച്ചാൽ (call) മതി:
+
+```py
+output = model(model_inputs)
+```
+
+മോഡൽ വ്യത്യസ്തങ്ങളായ നിരവധി ആർഗ്യുമെന്റുകൾ സ്വീകരിക്കുമെങ്കിലും, ഇൻപുട്ട് ID-കൾ മാത്രമേ അത്യാവശ്യമുള്ളൂ. മറ്റ് ആർഗ്യുമെന്റുകൾ എന്ത് ചെയ്യുന്നു എന്നും അവ എപ്പോഴാണ് ആവശ്യമായി വരുന്നത് എന്നും പിന്നീട് വിശദീകരിക്കാം, 
+എന്നാൽ അതിനുമുമ്പ്, ഒരു Transformer മോഡലിന് മനസ്സിലാക്കാൻ കഴിയുന്ന ഇൻപുട്ടുകൾ നിർമ്മിക്കുന്ന ടോക്കണൈസറുകളെ നമ്മൾ കൂടുതൽ അടുത്ത് പരിശോധിക്കേണ്ടതുണ്ട്.

From 5b281eb920fcdeed41f42a84fa7e130c5c8e5b02 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 12:32:22 +0530
Subject: [PATCH 25/44] Add Malayalam translation for chapter2/4.mdx

---
 chapters/ml/chapter2/4.mdx | 218 +++++++++++++++++++++++++++++++++++++
 1 file changed, 218 insertions(+)
 create mode 100644 chapters/ml/chapter2/4.mdx

diff --git a/chapters/ml/chapter2/4.mdx b/chapters/ml/chapter2/4.mdx
new file mode 100644
index 000000000..751423346
--- /dev/null
+++ b/chapters/ml/chapter2/4.mdx
@@ -0,0 +1,218 @@
+<FrameworkSwitchCourse {fw} />
+
+# ടോക്കണൈസറുകൾ[[tokenizers]]
+
+<CourseFloatingBanner chapter={2}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter2/section4_pt.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter2/section4_pt.ipynb"},
+]} />
+
+<Youtube id="VFp38yj8h3A"/>
+
+NLP പൈപ്പ്‌ലൈനിന്റെ അടിസ്ഥാന ഘടകങ്ങളിലൊന്നാണ് ടോക്കണൈസറുകൾ. അവയ്ക്ക് ഒരേയൊരു ലക്ഷ്യമാണുള്ളത്: ടെക്‌സ്‌റ്റിനെ മോഡലിന് പ്രോസസ്സ് ചെയ്യാൻ കഴിയുന്ന ഡേറ്റയിലേക്ക് മാറ്റുക. മോഡലുകൾക്ക് സംഖ്യകൾ മാത്രമേ പ്രോസസ്സ് ചെയ്യാൻ കഴിയൂ, അതിനാൽ നമ്മുടെ ടെക്‌സ്‌റ്റ് ഇൻപുട്ടുകളെ സംഖ്യാ ഡേറ്റയിലേക്ക് മാറ്റേണ്ട ജോലി ടോക്കണൈസറുകൾക്കാണ്. ടോക്കണൈസേഷൻ പൈപ്പ്‌ലൈനിൽ കൃത്യമായി എന്താണ് സംഭവിക്കുന്നത് എന്ന് ഈ ഭാഗത്തിൽ നമ്മൾ പരിശോധിക്കും. 
+
+NLP ടാസ്‌ക്കുകളിൽ സാധാരണയായി പ്രോസസ്സ് ചെയ്യുന്ന ഡേറ്റ അസംസ്കൃത ടെക്‌സ്‌റ്റ് (raw text) ആണ്. അത്തരം ടെക്‌സ്‌റ്റിന്റെ ഒരു ഉദാഹരണം ഇതാ:
+
+```
+Jim Henson was a puppeteer
+```
+
+എന്നാൽ, മോഡലുകൾക്ക് സംഖ്യകൾ മാത്രമേ പ്രോസസ്സ് ചെയ്യാൻ കഴിയൂ, അതിനാൽ അസംസ്കൃത ടെക്‌സ്‌റ്റിനെ സംഖ്യകളാക്കി മാറ്റാൻ ഒരു വഴി നമ്മൾ കണ്ടെത്തേണ്ടതുണ്ട്. അതാണ് ടോക്കണൈസറുകൾ ചെയ്യുന്നത്, ഇത് ചെയ്യാൻ ഒരുപാട് വഴികളുമുണ്ട്. ഏറ്റവും അർത്ഥവത്തായ പ്രതിനിധാനം (representation) — അതായത്, മോഡലിന് ഏറ്റവും അർത്ഥപൂർണ്ണമായി തോന്നുന്നത് — കണ്ടെത്തുകയാണ് ലക്ഷ്യം; സാധ്യമെങ്കിൽ, ഏറ്റവും ചെറിയ പ്രതിനിധാനവും.
+
+ടോക്കണൈസേഷൻ അൽഗോരിതങ്ങളുടെ ചില ഉദാഹരണങ്ങൾ നോക്കാം, ടോക്കണൈസേഷനെക്കുറിച്ച് നിങ്ങൾക്കുണ്ടാകാവുന്ന ചില ചോദ്യങ്ങൾക്ക് ഉത്തരം കണ്ടെത്താൻ ശ്രമിക്കാം.
+
+## വാക്ക് അടിസ്ഥാനമാക്കിയുള്ളത് (Word-based)[[word-based]]
+
+<Youtube id="nhJxYji1aho"/>
+
+ആദ്യം മനസ്സിൽ വരുന്ന തരം ടോക്കണൈസർ _വാക്ക് അടിസ്ഥാനമാക്കിയുള്ളത്_ (word-based) ആണ്. കുറച്ച് നിയമങ്ങൾ മാത്രം ഉപയോഗിച്ച് ഇത് സെറ്റപ്പ് ചെയ്യാനും ഉപയോഗിക്കാനും പൊതുവേ വളരെ എളുപ്പമാണ്, പലപ്പോഴും ഇത് തൃപ്തികരമായ ഫലങ്ങളും നൽകുന്നു. ഉദാഹരണത്തിന്, താഴെയുള്ള ചിത്രത്തിൽ, അസംസ്കൃത ടെക്‌സ്‌റ്റിനെ വാക്കുകളായി വിഭജിച്ച് അവയോരോന്നിനും ഒരു സംഖ്യാ പ്രതിനിധാനം കണ്ടെത്തുകയാണ് ലക്ഷ്യം:
+
+<div class="flex justify-center">
+  <img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter2/word_based_tokenization.svg" alt="വാക്ക് അടിസ്ഥാനമാക്കിയുള്ള ടോക്കണൈസേഷന്റെ ഒരു ഉദാഹരണം."/>
+  <img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter2/word_based_tokenization-dark.svg" alt="വാക്ക് അടിസ്ഥാനമാക്കിയുള്ള ടോക്കണൈസേഷന്റെ ഒരു ഉദാഹരണം."/>
+</div>
+
+ടെക്‌സ്‌റ്റ് വിഭജിക്കാൻ വ്യത്യസ്ത വഴികളുണ്ട്. ഉദാഹരണത്തിന്, Python-ന്റെ `split()` ഫംഗ്‌ഷൻ ഉപയോഗിച്ച്, വൈറ്റ്‌സ്‌പേസ് (whitespace) അടിസ്ഥാനമാക്കി ടെക്‌സ്‌റ്റിനെ വാക്കുകളായി ടോക്കണൈസ് ചെയ്യാം:
+
+```py
+tokenized_text = "Jim Henson was a puppeteer".split()
+print(tokenized_text)
+```
+
+```python out
+['Jim', 'Henson', 'was', 'a', 'puppeteer']
+```
+
+ചിഹ്നങ്ങൾക്കായി (punctuation) അധിക നിയമങ്ങളുള്ള വേഡ് ടോക്കണൈസറുകളുടെ വകഭേദങ്ങളുമുണ്ട്. ഇത്തരം ടോക്കണൈസർ ഉപയോഗിക്കുമ്പോൾ, വളരെ വലിയ "വൊക്കാബുലറികൾ" (vocabularies) നമുക്ക് ലഭിക്കാം; നമ്മുടെ കോർപ്പസിൽ (corpus) ഉള്ള സ്വതന്ത്ര ടോക്കണുകളുടെ മൊത്തം എണ്ണമാണ് ഒരു വൊക്കാബുലറിയെ നിർവചിക്കുന്നത്.
+
+ഓരോ വാക്കിനും 0 മുതൽ വൊക്കാബുലറിയുടെ വലുപ്പം വരെയുള്ള ഒരു ID നൽകപ്പെടുന്നു. ഓരോ വാക്കിനെയും തിരിച്ചറിയാൻ മോഡൽ ഈ ID-കൾ ഉപയോഗിക്കുന്നു.
+
+വാക്ക് അടിസ്ഥാനമാക്കിയുള്ള ഒരു ടോക്കണൈസർ ഉപയോഗിച്ച് ഒരു ഭാഷയെ പൂർണ്ണമായി ഉൾക്കൊള്ളണമെങ്കിൽ, ആ ഭാഷയിലെ ഓരോ വാക്കിനും ഒരു ഐഡന്റിഫയർ വേണ്ടിവരും, അത് വളരെയധികം ടോക്കണുകൾ സൃഷ്ടിക്കും. ഉദാഹരണത്തിന്, ഇംഗ്ലീഷ് ഭാഷയിൽ 500,000-ത്തിലധികം വാക്കുകളുണ്ട്, അതിനാൽ ഓരോ വാക്കിൽ നിന്നും ഒരു ഇൻപുട്ട് ID-യിലേക്കുള്ള ഒരു മാപ്പ് ഉണ്ടാക്കാൻ അത്രയും ID-കൾ നമ്മൾ സൂക്ഷിക്കേണ്ടിവരും. കൂടാതെ, "dog" പോലുള്ള വാക്കുകൾ "dogs" പോലുള്ള വാക്കുകളിൽ നിന്ന് വ്യത്യസ്തമായാണ് പ്രതിനിധീകരിക്കപ്പെടുന്നത്, "dog"-ഉം "dogs"-ഉം സമാനമാണെന്ന് അറിയാൻ മോഡലിന് തുടക്കത്തിൽ ഒരു വഴിയുമില്ല: രണ്ട് വാക്കുകളെയും പരസ്പരബന്ധമില്ലാത്തവയായി അത് തിരിച്ചറിയും. "run", "running" പോലുള്ള മറ്റ് സമാന വാക്കുകൾക്കും ഇത് ബാധകമാണ്; തുടക്കത്തിൽ മോഡൽ അവയെ സമാനമായി കാണില്ല.
+
+അവസാനമായി, നമ്മുടെ വൊക്കാബുലറിയിൽ ഇല്ലാത്ത വാക്കുകളെ പ്രതിനിധീകരിക്കാൻ ഒരു പ്രത്യേക ടോക്കൺ നമുക്ക് ആവശ്യമാണ്. ഇത് "unknown" ടോക്കൺ എന്ന് അറിയപ്പെടുന്നു, പലപ്പോഴും "[UNK]" അല്ലെങ്കിൽ "&lt;unk&gt;" എന്ന് പ്രതിനിധീകരിക്കപ്പെടുന്നു. ടോക്കണൈസർ ഇത്തരം ടോക്കണുകൾ ഒരുപാട് സൃഷ്ടിക്കുന്നതായി കണ്ടാൽ അത് പൊതുവേ ഒരു മോശം ലക്ഷണമാണ്, കാരണം ഒരു വാക്കിന്റെ അർത്ഥവത്തായ ഒരു പ്രതിനിധാനം കണ്ടെത്താൻ അതിന് കഴിഞ്ഞില്ല എന്നും ആ വഴിയിൽ നിങ്ങൾക്ക് വിവരങ്ങൾ നഷ്ടപ്പെടുന്നു എന്നുമാണ് അതിനർത്ഥം. വൊക്കാബുലറി രൂപപ്പെടുത്തുമ്പോൾ, കഴിയുന്നത്ര കുറച്ച് വാക്കുകൾ മാത്രം unknown ടോക്കണിലേക്ക് ടോക്കണൈസ് ചെയ്യപ്പെടുന്ന രീതിയിൽ അത് ചെയ്യുകയാണ് ലക്ഷ്യം.
+
+unknown ടോക്കണുകളുടെ എണ്ണം കുറയ്ക്കാനുള്ള ഒരു വഴി, ഒരു തലം കൂടി താഴേക്ക് പോയി _അക്ഷരം അടിസ്ഥാനമാക്കിയുള്ള_ (character-based) ഒരു ടോക്കണൈസർ ഉപയോഗിക്കുന്നതാണ്.
+
+## അക്ഷരം അടിസ്ഥാനമാക്കിയുള്ളത് (Character-based)[[character-based]]
+
+<Youtube id="ssLq_EK2jLE"/>
+
+അക്ഷരം അടിസ്ഥാനമാക്കിയുള്ള ടോക്കണൈസറുകൾ ടെക്‌സ്‌റ്റിനെ വാക്കുകളായല്ല, അക്ഷരങ്ങളായാണ് വിഭജിക്കുന്നത്. ഇതിന് രണ്ട് പ്രധാന ഗുണങ്ങളുണ്ട്:
+
+- വൊക്കാബുലറി വളരെ ചെറുതാണ്.
+- ഓരോ വാക്കും അക്ഷരങ്ങളിൽ നിന്ന് നിർമ്മിക്കാൻ കഴിയുന്നതിനാൽ, വൊക്കാബുലറിക്ക് പുറത്തുള്ള (unknown) ടോക്കണുകൾ വളരെ കുറവാണ്.
+
+എന്നാൽ ഇവിടെയും സ്‌പേസുകളെയും ചിഹ്നങ്ങളെയും സംബന്ധിച്ച് ചില ചോദ്യങ്ങൾ ഉയരുന്നു:
+
+<div class="flex justify-center">
+  <img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter2/character_based_tokenization.svg" alt="അക്ഷരം അടിസ്ഥാനമാക്കിയുള്ള ടോക്കണൈസേഷന്റെ ഒരു ഉദാഹരണം."/>
+  <img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter2/character_based_tokenization-dark.svg" alt="അക്ഷരം അടിസ്ഥാനമാക്കിയുള്ള ടോക്കണൈസേഷന്റെ ഒരു ഉദാഹരണം."/>
+</div>
+
+ഈ സമീപനവും പൂർണ്ണമല്ല. പ്രതിനിധാനം ഇപ്പോൾ വാക്കുകളെയല്ല അക്ഷരങ്ങളെയാണ് അടിസ്ഥാനമാക്കുന്നത് എന്നതിനാൽ, അവബോധപരമായി ഇത് അർത്ഥം കുറഞ്ഞതാണെന്ന് ഒരാൾക്ക് വാദിക്കാം: ഓരോ അക്ഷരത്തിനും സ്വന്തമായി വലിയ അർത്ഥമില്ല, എന്നാൽ വാക്കുകളുടെ കാര്യത്തിൽ അങ്ങനെയല്ല. എങ്കിലും, ഇതും ഭാഷയനുസരിച്ച് വ്യത്യാസപ്പെടുന്നു; ഉദാഹരണത്തിന്, ചൈനീസിൽ ഓരോ അക്ഷരവും ഒരു ലാറ്റിൻ ഭാഷയിലെ അക്ഷരത്തെക്കാൾ കൂടുതൽ വിവരങ്ങൾ വഹിക്കുന്നു.
+
+പരിഗണിക്കേണ്ട മറ്റൊരു കാര്യം, നമ്മുടെ മോഡലിന് പ്രോസസ്സ് ചെയ്യാൻ വളരെ വലിയ അളവിലുള്ള ടോക്കണുകൾ ഉണ്ടാകും എന്നതാണ്: വാക്ക് അടിസ്ഥാനമാക്കിയുള്ള ഒരു ടോക്കണൈസറിൽ ഒരു വാക്ക് ഒരൊറ്റ ടോക്കൺ മാത്രമായിരിക്കുമ്പോൾ, അക്ഷരങ്ങളാക്കി മാറ്റുമ്പോൾ അത് എളുപ്പത്തിൽ 10-ഓ അതിലധികമോ ടോക്കണുകളായി മാറാം.
+
+രണ്ടിന്റെയും മികച്ച വശങ്ങൾ നേടാൻ, ഈ രണ്ട് സമീപനങ്ങളെയും സംയോജിപ്പിക്കുന്ന മൂന്നാമതൊരു സങ്കേതം നമുക്ക് ഉപയോഗിക്കാം: *സബ്‌വേഡ് ടോക്കണൈസേഷൻ* (subword tokenization).
+
+## സബ്‌വേഡ് ടോക്കണൈസേഷൻ[[subword-tokenization]]
+
+<Youtube id="zHvTiHr506c"/>
+
+പതിവായി ഉപയോഗിക്കുന്ന വാക്കുകളെ ചെറിയ സബ്‌വേഡുകളായി വിഭജിക്കരുത്, എന്നാൽ അപൂർവ വാക്കുകളെ അർത്ഥവത്തായ സബ്‌വേഡുകളായി വിഘടിപ്പിക്കണം എന്ന തത്ത്വത്തെയാണ് സബ്‌വേഡ് ടോക്കണൈസേഷൻ അൽഗോരിതങ്ങൾ ആശ്രയിക്കുന്നത്.
+
+ഉദാഹരണത്തിന്, "annoyingly" ഒരു അപൂർവ വാക്കായി കണക്കാക്കപ്പെടാം, അതിനെ "annoying", "ly" എന്നിങ്ങനെ വിഘടിപ്പിക്കാം. ഇവ രണ്ടും സ്വതന്ത്ര സബ്‌വേഡുകളായി കൂടുതൽ പതിവായി പ്രത്യക്ഷപ്പെടാൻ സാധ്യതയുണ്ട്; അതേസമയം, "annoying", "ly" എന്നിവയുടെ സംയുക്ത അർത്ഥത്തിലൂടെ "annoyingly"-യുടെ അർത്ഥം നിലനിർത്തപ്പെടുകയും ചെയ്യുന്നു.
+
+"Let's do tokenization!" എന്ന സീക്വൻസിനെ ഒരു സബ്‌വേഡ് ടോക്കണൈസേഷൻ അൽഗോരിതം എങ്ങനെ ടോക്കണൈസ് ചെയ്യും എന്ന് കാണിക്കുന്ന ഒരു ഉദാഹരണം ഇതാ:
+
+<div class="flex justify-center">
+  <img class="block dark:hidden" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter2/bpe_subword.svg" alt="ഒരു സബ്‌വേഡ് ടോക്കണൈസേഷൻ അൽഗോരിതം."/>
+  <img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter2/bpe_subword-dark.svg" alt="ഒരു സബ്‌വേഡ് ടോക്കണൈസേഷൻ അൽഗോരിതം."/>
+</div>
+
+ഈ സബ്‌വേഡുകൾ ധാരാളം അർത്ഥപരമായ (semantic) വിവരങ്ങൾ നൽകുന്നു: ഉദാഹരണത്തിന്, മുകളിലെ ഉദാഹരണത്തിൽ "tokenization" എന്നത് "token", "ization" എന്നീ രണ്ട് ടോക്കണുകളായി വിഭജിക്കപ്പെട്ടു — ഇവ രണ്ടിനും അർത്ഥപരമായ പ്രാധാന്യമുണ്ട്, അതേസമയം സ്ഥലം ലാഭിക്കുകയും ചെയ്യുന്നു (ഒരു നീണ്ട വാക്കിനെ പ്രതിനിധീകരിക്കാൻ രണ്ട് ടോക്കണുകൾ മാത്രം മതി). ചെറിയ വൊക്കാബുലറികൾ ഉപയോഗിച്ച് താരതമ്യേന മികച്ച കവറേജ് നേടാനും, unknown ടോക്കണുകൾ ഏതാണ്ട് ഇല്ലാതാക്കാനും ഇത് നമ്മെ സഹായിക്കുന്നു.
+
+സബ്‌വേഡുകൾ കൂട്ടിച്ചേർത്ത് (ഏതാണ്ട്) എത്ര നീളമുള്ള സങ്കീർണ്ണ വാക്കുകളും രൂപപ്പെടുത്താൻ കഴിയുന്ന ടർക്കിഷ് പോലുള്ള സംയോജക (agglutinative) ഭാഷകളിൽ ഈ സമീപനം പ്രത്യേകിച്ചും ഉപകാരപ്രദമാണ്.
+
+### ഇനിയും ഉണ്ട്![[and-more]]
+
+പ്രതീക്ഷിക്കാവുന്നതുപോലെ, ഇനിയും ഒട്ടേറെ സങ്കേതങ്ങളുണ്ട്. ചിലത് പറയുകയാണെങ്കിൽ:
+
+- GPT-2-ൽ ഉപയോഗിക്കുന്ന Byte-level BPE
+- BERT-ൽ ഉപയോഗിക്കുന്ന WordPiece
+- പല ബഹുഭാഷാ മോഡലുകളിലും ഉപയോഗിക്കുന്ന SentencePiece അല്ലെങ്കിൽ Unigram
+
+API ഉപയോഗിച്ച് തുടങ്ങാൻ ആവശ്യമായത്ര അറിവ്, ടോക്കണൈസറുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് ഇപ്പോൾ നിങ്ങൾക്ക് ഉണ്ടായിരിക്കണം.
+
+## ലോഡ് ചെയ്യലും സേവ് ചെയ്യലും[[loading-and-saving]]
+
+ടോക്കണൈസറുകൾ ലോഡ് ചെയ്യുന്നതും സേവ് ചെയ്യുന്നതും മോഡലുകളുടെ കാര്യത്തിലേതുപോലെ തന്നെ ലളിതമാണ്. വാസ്തവത്തിൽ, ഇത് അതേ രണ്ട് മെത്തേഡുകളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്: `from_pretrained()`, `save_pretrained()`. ഈ മെത്തേഡുകൾ ടോക്കണൈസർ ഉപയോഗിക്കുന്ന അൽഗോരിതവും (മോഡലിന്റെ *ആർക്കിടെക്‌ചർ* പോലെ) അതിന്റെ വൊക്കാബുലറിയും (മോഡലിന്റെ *വെയ്‌റ്റുകൾ* പോലെ) ലോഡ് ചെയ്യുകയോ സേവ് ചെയ്യുകയോ ചെയ്യും.
+
+BERT-ന്റെ അതേ ചെക്ക്‌പോയിന്റ് ഉപയോഗിച്ച് പരിശീലിപ്പിച്ച BERT ടോക്കണൈസർ ലോഡ് ചെയ്യുന്നത് മോഡൽ ലോഡ് ചെയ്യുന്ന അതേ രീതിയിലാണ്, ഒരു വ്യത്യാസം മാത്രം: നമ്മൾ `BertTokenizer` ക്ലാസ് ഉപയോഗിക്കുന്നു:
+
+```py
+from transformers import BertTokenizer
+
+tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
+```
+
+`AutoModel`-ന് സമാനമായി, `AutoTokenizer` ക്ലാസ് ചെക്ക്‌പോയിന്റിന്റെ പേരിന്റെ അടിസ്ഥാനത്തിൽ ലൈബ്രറിയിലെ ശരിയായ ടോക്കണൈസർ ക്ലാസ് കണ്ടെത്തും, ഏത് ചെക്ക്‌പോയിന്റിനോടൊപ്പവും ഇത് നേരിട്ട് ഉപയോഗിക്കാം:
+
+```py
+from transformers import AutoTokenizer
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+```
+
+മുൻ ഭാഗത്തിൽ കാണിച്ചതുപോലെ ഇപ്പോൾ നമുക്ക് ടോക്കണൈസർ ഉപയോഗിക്കാം:
+
+```python
+tokenizer("Using a Transformer network is simple")
+```
+
+```python out
+{'input_ids': [101, 7993, 170, 11303, 1200, 2443, 1110, 3014, 102],
+ 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]}
+```
+
+ഒരു ടോക്കണൈസർ സേവ് ചെയ്യുന്നത് ഒരു മോഡൽ സേവ് ചെയ്യുന്നതിന് സമാനമാണ്:
+
+```py
+tokenizer.save_pretrained("directory_on_my_computer")
+```
+
+`token_type_ids`-നെക്കുറിച്ച് [അധ്യായം 3](/course/chapter3)-ൽ നമ്മൾ കൂടുതൽ സംസാരിക്കും, `attention_mask` കീ കുറച്ചു കഴിഞ്ഞ് വിശദീകരിക്കും. ആദ്യം, `input_ids` എങ്ങനെ സൃഷ്ടിക്കപ്പെടുന്നു എന്ന് നോക്കാം. ഇതിനായി, ടോക്കണൈസറിന്റെ ഇടനില മെത്തേഡുകൾ (intermediate methods) നമ്മൾ പരിശോധിക്കേണ്ടതുണ്ട്.
+
+## എൻകോഡിംഗ്[[encoding]]
+
+<Youtube id="Yffk5aydLzg"/>
+
+ടെക്‌സ്‌റ്റിനെ സംഖ്യകളാക്കി മാറ്റുന്നതിനെ _എൻകോഡിംഗ്_ (encoding) എന്ന് വിളിക്കുന്നു. എൻകോഡിംഗ് രണ്ട് ഘട്ടങ്ങളുള്ള ഒരു പ്രക്രിയയായാണ് നടക്കുന്നത്: ആദ്യം ടോക്കണൈസേഷൻ, തുടർന്ന് ഇൻപുട്ട് ID-കളിലേക്കുള്ള മാറ്റം.
+
+നമ്മൾ കണ്ടതുപോലെ, ആദ്യ ഘട്ടം ടെക്‌സ്‌റ്റിനെ വാക്കുകളായി (അല്ലെങ്കിൽ വാക്കുകളുടെ ഭാഗങ്ങൾ, ചിഹ്നങ്ങൾ തുടങ്ങിയവയായി) വിഭജിക്കുന്നതാണ്; ഇവയെ സാധാരണയായി *ടോക്കണുകൾ* എന്ന് വിളിക്കുന്നു. ആ പ്രക്രിയയെ നിയന്ത്രിക്കാൻ കഴിയുന്ന പല നിയമങ്ങളുണ്ട്, അതുകൊണ്ടാണ് മോഡലിന്റെ പേര് ഉപയോഗിച്ച് ടോക്കണൈസർ ഇൻസ്‌റ്റാൻഷ്യേറ്റ് ചെയ്യേണ്ടത് — മോഡൽ പ്രീട്രെയിൻ ചെയ്തപ്പോൾ ഉപയോഗിച്ച അതേ നിയമങ്ങൾ തന്നെയാണ് നമ്മൾ ഉപയോഗിക്കുന്നത് എന്ന് ഉറപ്പാക്കാൻ.
+
+രണ്ടാമത്തെ ഘട്ടം ആ ടോക്കണുകളെ സംഖ്യകളാക്കി മാറ്റുന്നതാണ്, അതുവഴി അവയിൽ നിന്ന് ഒരു ടെൻസർ (tensor) നിർമ്മിച്ച് മോഡലിലേക്ക് നൽകാൻ നമുക്ക് കഴിയും. ഇതിനായി, ടോക്കണൈസറിന് ഒരു *വൊക്കാബുലറി* ഉണ്ട്; `from_pretrained()` മെത്തേഡ് ഉപയോഗിച്ച് ടോക്കണൈസർ ഇൻസ്‌റ്റാൻഷ്യേറ്റ് ചെയ്യുമ്പോൾ നമ്മൾ ഡൗൺലോഡ് ചെയ്യുന്ന ഭാഗമാണ് ഇത്. ഇവിടെയും, മോഡൽ പ്രീട്രെയിൻ ചെയ്തപ്പോൾ ഉപയോഗിച്ച അതേ വൊക്കാബുലറി തന്നെ നമ്മൾ ഉപയോഗിക്കേണ്ടതുണ്ട്.
+
+ഈ രണ്ട് ഘട്ടങ്ങളും കൂടുതൽ നന്നായി മനസ്സിലാക്കാൻ, നമ്മൾ അവയെ വെവ്വേറെ പരിശോധിക്കും. ആ ഘട്ടങ്ങളുടെ ഇടക്കാല ഫലങ്ങൾ നിങ്ങൾക്ക് കാണിച്ചുതരാൻ, ടോക്കണൈസേഷൻ പൈപ്പ്‌ലൈനിന്റെ ഭാഗങ്ങൾ വെവ്വേറെ നിർവഹിക്കുന്ന ചില മെത്തേഡുകൾ നമ്മൾ ഉപയോഗിക്കും; എന്നാൽ പ്രായോഗികമായി, നിങ്ങളുടെ ഇൻപുട്ടുകളിൽ ടോക്കണൈസർ നേരിട്ട് വിളിക്കുകയാണ് വേണ്ടത് (ഭാഗം 2-ൽ കാണിച്ചതുപോലെ).
+
+### ടോക്കണൈസേഷൻ[[tokenization]]
+
+ടോക്കണൈസേഷൻ പ്രക്രിയ ടോക്കണൈസറിന്റെ `tokenize()` മെത്തേഡ് ആണ് നിർവഹിക്കുന്നത്:
+
+```py
+from transformers import AutoTokenizer
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+
+sequence = "Using a Transformer network is simple"
+tokens = tokenizer.tokenize(sequence)
+
+print(tokens)
+```
+
+ഈ മെത്തേഡിന്റെ ഔട്ട്‌പുട്ട് സ്ട്രിംഗുകളുടെ, അതായത് ടോക്കണുകളുടെ, ഒരു ലിസ്‌റ്റാണ്:
+
+```python out
+['Using', 'a', 'transform', '##er', 'network', 'is', 'simple']
+```
+
+ഈ ടോക്കണൈസർ ഒരു സബ്‌വേഡ് ടോക്കണൈസറാണ്: അതിന്റെ വൊക്കാബുലറി ഉപയോഗിച്ച് പ്രതിനിധീകരിക്കാൻ കഴിയുന്ന ടോക്കണുകൾ ലഭിക്കുന്നതുവരെ ഇത് വാക്കുകളെ വിഭജിക്കുന്നു. ഇവിടെ `transformer`-ന്റെ കാര്യത്തിൽ അതാണ് സംഭവിച്ചത്; അത് രണ്ട് ടോക്കണുകളായി വിഭജിക്കപ്പെട്ടു: `transform`, `##er`.
+
+### ടോക്കണുകളിൽ നിന്ന് ഇൻപുട്ട് ID-കളിലേക്ക്[[from-tokens-to-input-ids]]
+
+ഇൻപുട്ട് ID-കളിലേക്കുള്ള മാറ്റം ടോക്കണൈസറിന്റെ `convert_tokens_to_ids()` മെത്തേഡ് ആണ് കൈകാര്യം ചെയ്യുന്നത്:
+
+```py
+ids = tokenizer.convert_tokens_to_ids(tokens)
+
+print(ids)
+```
+
+```python out
+[7993, 170, 11303, 1200, 2443, 1110, 3014]
+```
+
+ഈ ഔട്ട്‌പുട്ടുകൾ, അനുയോജ്യമായ ഫ്രെയിംവർക്ക് ടെൻസറിലേക്ക് മാറ്റിയ ശേഷം, ഈ അധ്യായത്തിൽ മുമ്പ് കണ്ടതുപോലെ ഒരു മോഡലിന്റെ ഇൻപുട്ടുകളായി ഉപയോഗിക്കാം.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** ഭാഗം 2-ൽ നമ്മൾ ഉപയോഗിച്ച ഇൻപുട്ട് വാക്യങ്ങളിൽ ("I've been waiting for a HuggingFace course my whole life.", "I hate this so much!") അവസാനത്തെ രണ്ട് ഘട്ടങ്ങൾ (ടോക്കണൈസേഷനും ഇൻപുട്ട് ID-കളിലേക്കുള്ള മാറ്റവും) ആവർത്തിക്കുക. മുമ്പ് നമുക്ക് ലഭിച്ച അതേ ഇൻപുട്ട് ID-കൾ തന്നെയാണ് നിങ്ങൾക്കും ലഭിക്കുന്നത് എന്ന് ഉറപ്പുവരുത്തുക!
+
+## ഡീകോഡിംഗ്[[decoding]]
+
+*ഡീകോഡിംഗ്* (decoding) എന്നത് ഇതിന്റെ വിപരീത ദിശയിലുള്ള യാത്രയാണ്: വൊക്കാബുലറി ഇൻഡെക്‌സുകളിൽ നിന്ന് ഒരു സ്ട്രിംഗ് ലഭിക്കണം. താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ `decode()` മെത്തേഡ് ഉപയോഗിച്ച് ഇത് ചെയ്യാം:
+
+```py
+decoded_string = tokenizer.decode([7993, 170, 11303, 1200, 2443, 1110, 3014])
+print(decoded_string)
+```
+
+```python out
+'Using a Transformer network is simple'
+```
+
+`decode` മെത്തേഡ് ഇൻഡെക്‌സുകളെ ടോക്കണുകളാക്കി തിരികെ മാറ്റുക മാത്രമല്ല, വായിക്കാവുന്ന ഒരു വാക്യം ഉണ്ടാക്കാൻ ഒരേ വാക്കിന്റെ ഭാഗമായിരുന്ന ടോക്കണുകളെ ഒരുമിച്ച് കൂട്ടിച്ചേർക്കുകയും ചെയ്യുന്നു എന്നത് ശ്രദ്ധിക്കുക. പുതിയ ടെക്‌സ്‌റ്റ് പ്രവചിക്കുന്ന മോഡലുകൾ ഉപയോഗിക്കുമ്പോൾ (ഒരു പ്രോംപ്‌റ്റിൽ നിന്ന് സൃഷ്ടിക്കുന്ന ടെക്‌സ്‌റ്റ് ആയാലും, വിവർത്തനം അല്ലെങ്കിൽ സംഗ്രഹം പോലുള്ള സീക്വൻസ്-ടു-സീക്വൻസ് പ്രശ്നങ്ങൾക്കായാലും) ഈ പ്രവർത്തനരീതി അത്യധികം ഉപകാരപ്രദമാകും.
+
+ഒരു ടോക്കണൈസറിന് കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന അടിസ്ഥാന പ്രവർത്തനങ്ങൾ ഇപ്പോൾ നിങ്ങൾക്ക് മനസ്സിലായിട്ടുണ്ടാകണം: ടോക്കണൈസേഷൻ, ID-കളിലേക്കുള്ള മാറ്റം, ID-കളെ തിരികെ ഒരു സ്ട്രിംഗിലേക്ക് മാറ്റൽ. എന്നാൽ, നമ്മൾ മഞ്ഞുമലയുടെ അറ്റം മാത്രമേ തൊട്ടിട്ടുള്ളൂ. അടുത്ത ഭാഗത്തിൽ, നമ്മുടെ സമീപനത്തെ അതിന്റെ പരിധികളിലേക്ക് കൊണ്ടുപോകുകയും അവയെ എങ്ങനെ മറികടക്കാം എന്ന് നോക്കുകയും ചെയ്യും.

From f2f607bb1c05173cb0b9fa876a9a62736f5de4c4 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 12:36:38 +0530
Subject: [PATCH 26/44] Add Malayalam translation for chapter2/5.mdx

---
 chapters/ml/chapter2/5.mdx | 200 +++++++++++++++++++++++++++++++++++++
 1 file changed, 200 insertions(+)
 create mode 100644 chapters/ml/chapter2/5.mdx

diff --git a/chapters/ml/chapter2/5.mdx b/chapters/ml/chapter2/5.mdx
new file mode 100644
index 000000000..be00a241e
--- /dev/null
+++ b/chapters/ml/chapter2/5.mdx
@@ -0,0 +1,200 @@
+<FrameworkSwitchCourse {fw} />
+
+# ഒന്നിലധികം സീക്വൻസുകൾ കൈകാര്യം ചെയ്യുന്നു[[handling-multiple-sequences]]
+
+<CourseFloatingBanner chapter={2}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter2/section5_pt.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter2/section5_pt.ipynb"},
+]} />
+
+<Youtube id="M6adb1j2jPI"/>
+
+മുൻ ഭാഗത്തിൽ, ഏറ്റവും ലളിതമായ ഉപയോഗസന്ദർഭം നമ്മൾ പരിശോധിച്ചു: ചെറിയ നീളമുള്ള ഒരൊറ്റ സീക്വൻസിൽ ഇൻഫറൻസ് നടത്തുക. എന്നാൽ, ഇപ്പോൾ തന്നെ ചില ചോദ്യങ്ങൾ ഉയർന്നുവരുന്നു:
+
+- ഒന്നിലധികം സീക്വൻസുകൾ നമ്മൾ എങ്ങനെ കൈകാര്യം ചെയ്യും?
+- *വ്യത്യസ്ത നീളമുള്ള* ഒന്നിലധികം സീക്വൻസുകൾ നമ്മൾ എങ്ങനെ കൈകാര്യം ചെയ്യും?
+- ഒരു മോഡൽ നന്നായി പ്രവർത്തിക്കാൻ സഹായിക്കുന്ന ഒരേയൊരു ഇൻപുട്ട് വൊക്കാബുലറി ഇൻഡെക്‌സുകൾ മാത്രമാണോ?
+- വളരെ നീണ്ട സീക്വൻസ് എന്നൊരു കാര്യമുണ്ടോ?
+
+ഈ ചോദ്യങ്ങൾ ഏതുതരം പ്രശ്നങ്ങളാണ് ഉയർത്തുന്നത് എന്നും, 🤗 Transformers API ഉപയോഗിച്ച് അവ എങ്ങനെ പരിഹരിക്കാം എന്നും നോക്കാം.
+
+## മോഡലുകൾ പ്രതീക്ഷിക്കുന്നത് ഇൻപുട്ടുകളുടെ ഒരു ബാച്ചാണ്[[models-expect-a-batch-of-inputs]]
+
+മുൻ അഭ്യാസത്തിൽ, സീക്വൻസുകൾ എങ്ങനെ സംഖ്യകളുടെ ലിസ്‌റ്റുകളായി മാറ്റപ്പെടുന്നു എന്ന് നിങ്ങൾ കണ്ടു. ഈ സംഖ്യകളുടെ ലിസ്‌റ്റിനെ ഒരു ടെൻസറാക്കി മാറ്റി മോഡലിലേക്ക് അയയ്ക്കാം:
+
+```py
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+
+sequence = "I've been waiting for a HuggingFace course my whole life."
+
+tokens = tokenizer.tokenize(sequence)
+ids = tokenizer.convert_tokens_to_ids(tokens)
+input_ids = torch.tensor(ids)
+# This line will fail.
+model(input_ids)
+```
+
+```python out
+IndexError: Dimension out of range (expected to be in range of [-1, 0], but got 1)
+```
+
+അയ്യോ! ഇത് എന്തുകൊണ്ടാണ് പരാജയപ്പെട്ടത്? ഭാഗം 2-ലെ പൈപ്പ്‌ലൈനിലെ ഘട്ടങ്ങൾ തന്നെയാണല്ലോ നമ്മൾ പിന്തുടർന്നത്.
+
+പ്രശ്നം ഇതാണ്: നമ്മൾ മോഡലിലേക്ക് ഒരൊറ്റ സീക്വൻസ് അയച്ചു, എന്നാൽ 🤗 Transformers മോഡലുകൾ ഡിഫോൾട്ടായി ഒന്നിലധികം വാക്യങ്ങളാണ് പ്രതീക്ഷിക്കുന്നത്. ഒരു `sequence`-ൽ ടോക്കണൈസർ പ്രയോഗിച്ചപ്പോൾ അത് തിരശ്ശീലയ്ക്ക് പിന്നിൽ ചെയ്ത എല്ലാ കാര്യങ്ങളും ഇവിടെ നമ്മൾ സ്വയം ചെയ്യാൻ ശ്രമിച്ചു. എന്നാൽ സൂക്ഷിച്ചുനോക്കിയാൽ, ടോക്കണൈസർ ഇൻപുട്ട് ID-കളുടെ ലിസ്‌റ്റിനെ വെറുതെ ഒരു ടെൻസറാക്കി മാറ്റുക മാത്രമല്ല ചെയ്തത്, അതിന് മുകളിൽ ഒരു ഡൈമെൻഷൻ കൂടി ചേർത്തു എന്ന് നിങ്ങൾ കാണും:
+
+```py
+tokenized_inputs = tokenizer(sequence, return_tensors="pt")
+print(tokenized_inputs["input_ids"])
+```
+
+```python out
+tensor([[  101,  1045,  1005,  2310,  2042,  3403,  2005,  1037, 17662, 12172,
+          2607,  2026,  2878,  2166,  1012,   102]])
+```
+
+ഒരു പുതിയ ഡൈമെൻഷൻ ചേർത്ത് വീണ്ടും ശ്രമിക്കാം:
+
+```py
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+
+sequence = "I've been waiting for a HuggingFace course my whole life."
+
+tokens = tokenizer.tokenize(sequence)
+ids = tokenizer.convert_tokens_to_ids(tokens)
+
+input_ids = torch.tensor([ids])
+print("Input IDs:", input_ids)
+
+output = model(input_ids)
+print("Logits:", output.logits)
+```
+
+ഇൻപുട്ട് ID-കളും അതിന്റെ ഫലമായി ലഭിക്കുന്ന ലോജിറ്റുകളും നമ്മൾ പ്രിന്റ് ചെയ്യുന്നു — ഔട്ട്‌പുട്ട് ഇതാ:
+
+```python out
+Input IDs: [[ 1045,  1005,  2310,  2042,  3403,  2005,  1037, 17662, 12172,  2607, 2026,  2878,  2166,  1012]]
+Logits: [[-2.7276,  2.8789]]
+```
+
+ഒന്നിലധികം വാക്യങ്ങൾ ഒരുമിച്ച്, ഒറ്റയടിക്ക് മോഡലിലൂടെ കടത്തിവിടുന്നതിനെയാണ് *ബാച്ചിംഗ്* (batching) എന്ന് പറയുന്നത്. നിങ്ങൾക്ക് ഒരു വാക്യം മാത്രമേ ഉള്ളൂവെങ്കിൽ, ഒരൊറ്റ സീക്വൻസ് ഉള്ള ഒരു ബാച്ച് ഉണ്ടാക്കിയാൽ മതി: 
+
+```
+batched_ids = [ids, ids]
+```
+
+ഇത് ഒരേപോലുള്ള രണ്ട് സീക്വൻസുകളുടെ ഒരു ബാച്ചാണ്!
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** ഈ `batched_ids` ലിസ്‌റ്റിനെ ഒരു ടെൻസറാക്കി മാറ്റി നിങ്ങളുടെ മോഡലിലൂടെ കടത്തിവിടുക. മുമ്പത്തെ അതേ ലോജിറ്റുകൾ തന്നെയാണ് (പക്ഷേ രണ്ടുതവണ) നിങ്ങൾക്ക് ലഭിക്കുന്നത് എന്ന് ഉറപ്പുവരുത്തുക!
+
+ഒന്നിലധികം വാക്യങ്ങൾ നൽകുമ്പോൾ മോഡൽ പ്രവർത്തിക്കാൻ ബാച്ചിംഗ് സഹായിക്കുന്നു. ഒന്നിലധികം സീക്വൻസുകൾ ഉപയോഗിക്കുന്നത്, ഒരൊറ്റ സീക്വൻസ് ഉള്ള ഒരു ബാച്ച് ഉണ്ടാക്കുന്നതുപോലെ തന്നെ ലളിതമാണ്. എന്നാൽ, രണ്ടാമതൊരു പ്രശ്നമുണ്ട്. രണ്ടോ (അതിലധികമോ) വാക്യങ്ങൾ ഒരുമിച്ച് ബാച്ച് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ, അവ വ്യത്യസ്ത നീളമുള്ളവയായിരിക്കാം. നിങ്ങൾ മുമ്പ് ടെൻസറുകളുമായി പ്രവർത്തിച്ചിട്ടുണ്ടെങ്കിൽ, അവ ചതുരാകൃതിയിലുള്ളവയായിരിക്കണം (rectangular shape) എന്ന് നിങ്ങൾക്കറിയാം; അതിനാൽ ഇൻപുട്ട് ID-കളുടെ ലിസ്‌റ്റിനെ നേരിട്ട് ഒരു ടെൻസറാക്കി മാറ്റാൻ നിങ്ങൾക്ക് കഴിയില്ല. ഈ പ്രശ്നം മറികടക്കാൻ, സാധാരണയായി നമ്മൾ ഇൻപുട്ടുകളെ *പാഡ്* (pad) ചെയ്യുന്നു.
+
+## ഇൻപുട്ടുകൾ പാഡ് ചെയ്യുന്നു[[padding-the-inputs]]
+
+താഴെയുള്ള ലിസ്‌റ്റുകളുടെ ലിസ്‌റ്റ് ഒരു ടെൻസറാക്കി മാറ്റാൻ കഴിയില്ല:
+
+```py no-format
+batched_ids = [
+    [200, 200, 200],
+    [200, 200]
+]
+```
+
+ഇത് മറികടക്കാൻ, നമ്മുടെ ടെൻസറുകൾക്ക് ചതുരാകൃതി ലഭിക്കാനായി നമ്മൾ *പാഡിംഗ്* (padding) ഉപയോഗിക്കും. കുറച്ച് മൂല്യങ്ങൾ മാത്രമുള്ള വാക്യങ്ങളിലേക്ക് *പാഡിംഗ് ടോക്കൺ* എന്ന് വിളിക്കുന്ന ഒരു പ്രത്യേക വാക്ക് ചേർത്ത്, നമ്മുടെ എല്ലാ വാക്യങ്ങൾക്കും ഒരേ നീളം ഉണ്ടെന്ന് പാഡിംഗ് ഉറപ്പാക്കുന്നു. ഉദാഹരണത്തിന്, 10 വാക്കുകൾ വീതമുള്ള 10 വാക്യങ്ങളും 20 വാക്കുകളുള്ള 1 വാക്യവും നിങ്ങൾക്കുണ്ടെങ്കിൽ, എല്ലാ വാക്യങ്ങൾക്കും 20 വാക്കുകൾ ഉണ്ടെന്ന് പാഡിംഗ് ഉറപ്പാക്കും. നമ്മുടെ ഉദാഹരണത്തിൽ, ഫലമായി ലഭിക്കുന്ന ടെൻസർ ഇങ്ങനെയിരിക്കും:
+
+```py no-format
+padding_id = 100
+
+batched_ids = [
+    [200, 200, 200],
+    [200, 200, padding_id],
+]
+```
+
+പാഡിംഗ് ടോക്കണിന്റെ ID `tokenizer.pad_token_id`-ൽ കാണാം. ഇത് ഉപയോഗിച്ച്, നമ്മുടെ രണ്ട് വാക്യങ്ങളെ വെവ്വേറെയായും ഒരുമിച്ച് ബാച്ച് ചെയ്തും മോഡലിലൂടെ കടത്തിവിടാം:
+
+```py no-format
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+
+sequence1_ids = [[200, 200, 200]]
+sequence2_ids = [[200, 200]]
+batched_ids = [
+    [200, 200, 200],
+    [200, 200, tokenizer.pad_token_id],
+]
+
+print(model(torch.tensor(sequence1_ids)).logits)
+print(model(torch.tensor(sequence2_ids)).logits)
+print(model(torch.tensor(batched_ids)).logits)
+```
+
+```python out
+tensor([[ 1.5694, -1.3895]], grad_fn=<AddmmBackward>)
+tensor([[ 0.5803, -0.4125]], grad_fn=<AddmmBackward>)
+tensor([[ 1.5694, -1.3895],
+        [ 1.3373, -1.2163]], grad_fn=<AddmmBackward>)
+```
+
+നമ്മുടെ ബാച്ച് ചെയ്ത പ്രവചനങ്ങളിലെ ലോജിറ്റുകളിൽ എന്തോ പിശകുണ്ട്: രണ്ടാമത്തെ വരി രണ്ടാമത്തെ വാക്യത്തിന്റെ ലോജിറ്റുകൾക്ക് തുല്യമായിരിക്കണം, പക്ഷേ നമുക്ക് ലഭിച്ചത് തീർത്തും വ്യത്യസ്തമായ മൂല്യങ്ങളാണ്!
+
+ഓരോ ടോക്കണിനെയും *സന്ദർഭവത്കരിക്കുന്ന* (contextualize) അറ്റൻഷൻ ലെയറുകളാണ് Transformer മോഡലുകളുടെ പ്രധാന സവിശേഷത എന്നതാണ് ഇതിന് കാരണം. ഒരു സീക്വൻസിലെ എല്ലാ ടോക്കണുകളിലേക്കും ഇവ ശ്രദ്ധ കൊടുക്കുന്നതിനാൽ (attend), പാഡിംഗ് ടോക്കണുകളെയും ഇവ കണക്കിലെടുക്കും. വ്യത്യസ്ത നീളമുള്ള വാക്യങ്ങളെ വെവ്വേറെ മോഡലിലൂടെ കടത്തിവിടുമ്പോഴും, അതേ വാക്യങ്ങളെ പാഡിംഗ് പ്രയോഗിച്ച് ഒരു ബാച്ചായി കടത്തിവിടുമ്പോഴും ഒരേ ഫലം ലഭിക്കാൻ, പാഡിംഗ് ടോക്കണുകളെ അവഗണിക്കാൻ ആ അറ്റൻഷൻ ലെയറുകളോട് നമ്മൾ പറയേണ്ടതുണ്ട്. ഒരു അറ്റൻഷൻ മാസ്‌ക് ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത്.
+
+## അറ്റൻഷൻ മാസ്‌ക്കുകൾ[[attention-masks]]
+
+*അറ്റൻഷൻ മാസ്‌ക്കുകൾ* (attention masks) എന്നത് ഇൻപുട്ട് ID-കളുടെ ടെൻസറിന്റെ അതേ ആകൃതിയുള്ള (shape), 0-കളും 1-കളും നിറഞ്ഞ ടെൻസറുകളാണ്: 1-കൾ അതത് ടോക്കണുകളിലേക്ക് ശ്രദ്ധ കൊടുക്കണം എന്ന് സൂചിപ്പിക്കുന്നു, 0-കൾ അതത് ടോക്കണുകളിലേക്ക് ശ്രദ്ധ കൊടുക്കേണ്ടതില്ല എന്ന് സൂചിപ്പിക്കുന്നു (അതായത്, മോഡലിന്റെ അറ്റൻഷൻ ലെയറുകൾ അവയെ അവഗണിക്കണം).
+
+മുൻ ഉദാഹരണം ഒരു അറ്റൻഷൻ മാസ്‌ക് ചേർത്ത് പൂർത്തിയാക്കാം:
+
+```py no-format
+batched_ids = [
+    [200, 200, 200],
+    [200, 200, tokenizer.pad_token_id],
+]
+
+attention_mask = [
+    [1, 1, 1],
+    [1, 1, 0],
+]
+
+outputs = model(torch.tensor(batched_ids), attention_mask=torch.tensor(attention_mask))
+print(outputs.logits)
+```
+
+```python out
+tensor([[ 1.5694, -1.3895],
+        [ 0.5803, -0.4125]], grad_fn=<AddmmBackward>)
+```
+
+ഇപ്പോൾ ബാച്ചിലെ രണ്ടാമത്തെ വാക്യത്തിന് നമുക്ക് അതേ ലോജിറ്റുകൾ ലഭിക്കുന്നു.
+
+രണ്ടാമത്തെ സീക്വൻസിന്റെ അവസാന മൂല്യം ഒരു പാഡിംഗ് ID ആണെന്നും, അറ്റൻഷൻ മാസ്‌ക്കിൽ അത് 0 എന്ന മൂല്യമാണെന്നും ശ്രദ്ധിക്കുക.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** ഭാഗം 2-ൽ ഉപയോഗിച്ച രണ്ട് വാക്യങ്ങളിൽ ("I've been waiting for a HuggingFace course my whole life.", "I hate this so much!") ടോക്കണൈസേഷൻ സ്വയം (manually) പ്രയോഗിക്കുക. അവയെ മോഡലിലൂടെ കടത്തിവിട്ട്, ഭാഗം 2-ലെ അതേ ലോജിറ്റുകൾ തന്നെയാണ് ലഭിക്കുന്നത് എന്ന് ഉറപ്പുവരുത്തുക. ഇനി പാഡിംഗ് ടോക്കൺ ഉപയോഗിച്ച് അവയെ ഒരുമിച്ച് ബാച്ച് ചെയ്യുക, തുടർന്ന് ശരിയായ അറ്റൻഷൻ മാസ്‌ക് ഉണ്ടാക്കുക. മോഡലിലൂടെ കടത്തിവിടുമ്പോൾ അതേ ഫലങ്ങൾ തന്നെ ലഭിക്കുന്നു എന്ന് ഉറപ്പുവരുത്തുക!
+
+## കൂടുതൽ നീണ്ട സീക്വൻസുകൾ[[longer-sequences]]
+
+Transformer മോഡലുകളുടെ കാര്യത്തിൽ, മോഡലുകളിലേക്ക് നമുക്ക് നൽകാൻ കഴിയുന്ന സീക്വൻസുകളുടെ നീളത്തിന് ഒരു പരിധിയുണ്ട്. മിക്ക മോഡലുകളും 512 അല്ലെങ്കിൽ 1024 ടോക്കണുകൾ വരെയുള്ള സീക്വൻസുകൾ കൈകാര്യം ചെയ്യുന്നു, അതിലും നീണ്ട സീക്വൻസുകൾ പ്രോസസ്സ് ചെയ്യാൻ ആവശ്യപ്പെട്ടാൽ അവ ക്രാഷ് ആകും. ഈ പ്രശ്നത്തിന് രണ്ട് പരിഹാരങ്ങളുണ്ട്:
+
+- കൂടുതൽ നീണ്ട സീക്വൻസ് നീളം പിന്തുണയ്ക്കുന്ന ഒരു മോഡൽ ഉപയോഗിക്കുക.
+- നിങ്ങളുടെ സീക്വൻസുകൾ വെട്ടിച്ചുരുക്കുക (truncate).
+
+വ്യത്യസ്ത മോഡലുകൾ വ്യത്യസ്ത സീക്വൻസ് നീളങ്ങളാണ് പിന്തുണയ്ക്കുന്നത്, ചിലവ വളരെ നീണ്ട സീക്വൻസുകൾ കൈകാര്യം ചെയ്യുന്നതിൽ പ്രത്യേക വൈദഗ്ധ്യമുള്ളവയാണ്. [Longformer](https://huggingface.co/docs/transformers/model_doc/longformer) ഒരു ഉദാഹരണമാണ്, മറ്റൊന്ന് [LED](https://huggingface.co/docs/transformers/model_doc/led) ആണ്. വളരെ നീണ്ട സീക്വൻസുകൾ ആവശ്യമുള്ള ഒരു ടാസ്‌ക്കിലാണ് നിങ്ങൾ പ്രവർത്തിക്കുന്നതെങ്കിൽ, ആ മോഡലുകൾ ഒന്ന് നോക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.
+
+അല്ലാത്തപക്ഷം, `max_sequence_length` പാരാമീറ്റർ വ്യക്തമാക്കി നിങ്ങളുടെ സീക്വൻസുകൾ വെട്ടിച്ചുരുക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു:
+
+```py
+sequence = sequence[:max_sequence_length]
+```

From 0fab1fa73bded082fcdc3de639a14912fd4da16b Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 12:39:21 +0530
Subject: [PATCH 27/44] Add Malayalam translation for chapter2/6.mdx

---
 chapters/ml/chapter2/6.mdx | 133 +++++++++++++++++++++++++++++++++++++
 1 file changed, 133 insertions(+)
 create mode 100644 chapters/ml/chapter2/6.mdx

diff --git a/chapters/ml/chapter2/6.mdx b/chapters/ml/chapter2/6.mdx
new file mode 100644
index 000000000..978d93b3d
--- /dev/null
+++ b/chapters/ml/chapter2/6.mdx
@@ -0,0 +1,133 @@
+<FrameworkSwitchCourse {fw} />
+
+# എല്ലാം ഒരുമിച്ച് ചേർക്കുന്നു[[putting-it-all-together]]
+
+<CourseFloatingBanner chapter={2}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter2/section6_pt.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter2/section6_pt.ipynb"},
+]} />
+
+കഴിഞ്ഞ കുറച്ച് ഭാഗങ്ങളിൽ, മിക്ക ജോലികളും കഴിയുന്നത്ര സ്വന്തം കൈകൊണ്ട് ചെയ്യാൻ നമ്മൾ ശ്രമിച്ചുവരികയായിരുന്നു. ടോക്കണൈസറുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് നമ്മൾ പരിശോധിച്ചു; ടോക്കണൈസേഷൻ, ഇൻപുട്ട് ID-കളിലേക്കുള്ള മാറ്റം, പാഡിംഗ്, ട്രങ്കേഷൻ (truncation), അറ്റൻഷൻ മാസ്‌ക്കുകൾ എന്നിവയും നോക്കി.
+
+എന്നാൽ, ഭാഗം 2-ൽ നമ്മൾ കണ്ടതുപോലെ, ഇതെല്ലാം നമുക്കുവേണ്ടി കൈകാര്യം ചെയ്യാൻ 🤗 Transformers API-ക്ക് ഒരു ഉയർന്ന തലത്തിലുള്ള (high-level) ഫംഗ്‌ഷനുണ്ട്; അതിലേക്കാണ് ഇവിടെ നമ്മൾ ആഴത്തിൽ കടക്കുന്നത്. നിങ്ങളുടെ `tokenizer` വാക്യത്തിൽ നേരിട്ട് വിളിക്കുമ്പോൾ, മോഡലിലൂടെ കടത്തിവിടാൻ തയ്യാറായ ഇൻപുട്ടുകൾ നിങ്ങൾക്ക് തിരികെ ലഭിക്കുന്നു:
+
+```py
+from transformers import AutoTokenizer
+
+checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+
+sequence = "I've been waiting for a HuggingFace course my whole life."
+
+model_inputs = tokenizer(sequence)
+```
+
+ഇവിടെ, ഒരു മോഡൽ നന്നായി പ്രവർത്തിക്കാൻ ആവശ്യമായ എല്ലാ കാര്യങ്ങളും `model_inputs` എന്ന വേരിയബിളിൽ അടങ്ങിയിരിക്കുന്നു. DistilBERT-ന്, ഇതിൽ ഇൻപുട്ട് ID-കളും അറ്റൻഷൻ മാസ്‌ക്കും ഉൾപ്പെടുന്നു. അധിക ഇൻപുട്ടുകൾ സ്വീകരിക്കുന്ന മറ്റ് മോഡലുകൾക്ക്, അവയും `tokenizer` ഒബ്‌ജക്റ്റ് ഔട്ട്‌പുട്ടായി നൽകും.
+
+താഴെയുള്ള ചില ഉദാഹരണങ്ങളിൽ നമ്മൾ കാണുന്നതുപോലെ, ഈ മെത്തേഡ് വളരെ ശക്തമാണ്. ആദ്യമായി, ഇതിന് ഒരൊറ്റ സീക്വൻസ് ടോക്കണൈസ് ചെയ്യാൻ കഴിയും:
+
+```py
+sequence = "I've been waiting for a HuggingFace course my whole life."
+
+model_inputs = tokenizer(sequence)
+```
+
+API-യിൽ ഒരു മാറ്റവുമില്ലാതെ, ഒരേസമയം ഒന്നിലധികം സീക്വൻസുകളും ഇത് കൈകാര്യം ചെയ്യുന്നു:
+
+```py
+sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
+
+model_inputs = tokenizer(sequences)
+```
+
+പല ലക്ഷ്യങ്ങൾക്കനുസരിച്ച് ഇതിന് പാഡ് ചെയ്യാൻ കഴിയും:
+
+```py
+# Will pad the sequences up to the maximum sequence length
+model_inputs = tokenizer(sequences, padding="longest")
+
+# Will pad the sequences up to the model max length
+# (512 for BERT or DistilBERT)
+model_inputs = tokenizer(sequences, padding="max_length")
+
+# Will pad the sequences up to the specified max length
+model_inputs = tokenizer(sequences, padding="max_length", max_length=8)
+```
+
+ഇതിന് സീക്വൻസുകൾ വെട്ടിച്ചുരുക്കാനും (truncate) കഴിയും:
+
+```py
+sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
+
+# Will truncate the sequences that are longer than the model max length
+# (512 for BERT or DistilBERT)
+model_inputs = tokenizer(sequences, truncation=True)
+
+# Will truncate the sequences that are longer than the specified max length
+model_inputs = tokenizer(sequences, max_length=8, truncation=True)
+```
+
+പ്രത്യേക ഫ്രെയിംവർക്ക് ടെൻസറുകളിലേക്കുള്ള മാറ്റവും `tokenizer` ഒബ്‌ജക്റ്റിന് കൈകാര്യം ചെയ്യാൻ കഴിയും; അവയെ പിന്നീട് നേരിട്ട് മോഡലിലേക്ക് അയയ്ക്കാം. ഉദാഹരണത്തിന്, താഴെയുള്ള കോഡ് സാമ്പിളിൽ, വ്യത്യസ്ത ഫ്രെയിംവർക്കുകളിൽ നിന്നുള്ള ടെൻസറുകൾ തിരികെ നൽകാൻ നമ്മൾ ടോക്കണൈസറോട് ആവശ്യപ്പെടുന്നു — `"pt"` PyTorch ടെൻസറുകൾ നൽകുന്നു, `"np"` NumPy അറേകൾ നൽകുന്നു:
+
+```py
+sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
+
+# Returns PyTorch tensors
+model_inputs = tokenizer(sequences, padding=True, return_tensors="pt")
+
+# Returns NumPy arrays
+model_inputs = tokenizer(sequences, padding=True, return_tensors="np")
+```
+
+## പ്രത്യേക ടോക്കണുകൾ[[special-tokens]]
+
+ടോക്കണൈസർ തിരികെ നൽകിയ ഇൻപുട്ട് ID-കൾ ഒന്ന് നോക്കിയാൽ, അവ മുമ്പ് നമുക്ക് ലഭിച്ചതിൽ നിന്ന് അൽപ്പം വ്യത്യസ്തമാണെന്ന് കാണാം:
+
+```py
+sequence = "I've been waiting for a HuggingFace course my whole life."
+
+model_inputs = tokenizer(sequence)
+print(model_inputs["input_ids"])
+
+tokens = tokenizer.tokenize(sequence)
+ids = tokenizer.convert_tokens_to_ids(tokens)
+print(ids)
+```
+
+```python out
+[101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102]
+[1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012]
+```
+
+തുടക്കത്തിൽ ഒരു ടോക്കൺ ID-യും അവസാനം ഒരു ടോക്കൺ ID-യും ചേർക്കപ്പെട്ടിരിക്കുന്നു. ഇത് എന്തിനെക്കുറിച്ചാണെന്ന് കാണാൻ മുകളിലെ രണ്ട് ID സീക്വൻസുകളും ഡീകോഡ് ചെയ്യാം:
+
+```py
+print(tokenizer.decode(model_inputs["input_ids"]))
+print(tokenizer.decode(ids))
+```
+
+```python out
+"[CLS] i've been waiting for a huggingface course my whole life. [SEP]"
+"i've been waiting for a huggingface course my whole life."
+```
+
+ടോക്കണൈസർ തുടക്കത്തിൽ `[CLS]` എന്ന പ്രത്യേക വാക്കും അവസാനം `[SEP]` എന്ന പ്രത്യേക വാക്കും ചേർത്തു. മോഡൽ ഇവ ഉപയോഗിച്ചാണ് പ്രീട്രെയിൻ ചെയ്തത് എന്നതാണ് ഇതിന് കാരണം; അതിനാൽ ഇൻഫറൻസിൽ അതേ ഫലങ്ങൾ ലഭിക്കാൻ നമ്മളും ഇവ ചേർക്കേണ്ടതുണ്ട്. ചില മോഡലുകൾ പ്രത്യേക വാക്കുകൾ ചേർക്കുന്നില്ല, അല്ലെങ്കിൽ വ്യത്യസ്തമായവ ചേർക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക; ചില മോഡലുകൾ ഈ പ്രത്യേക വാക്കുകൾ തുടക്കത്തിൽ മാത്രമോ അവസാനം മാത്രമോ ചേർക്കുകയും ചെയ്യാം. എന്തായാലും, ഏതൊക്കെയാണ് പ്രതീക്ഷിക്കുന്നത് എന്ന് ടോക്കണൈസറിന് അറിയാം, അത് നിങ്ങൾക്കായി ഇത് കൈകാര്യം ചെയ്യും.
+
+## ഉപസംഹാരം: ടോക്കണൈസറിൽ നിന്ന് മോഡലിലേക്ക്[[wrapping-up-from-tokenizer-to-model]]
+
+ടെക്‌സ്‌റ്റുകളിൽ പ്രയോഗിക്കുമ്പോൾ `tokenizer` ഒബ്‌ജക്റ്റ് ഉപയോഗിക്കുന്ന ഓരോ ഘട്ടവും നമ്മൾ ഇപ്പോൾ കണ്ടുകഴിഞ്ഞു. ഇനി അവസാനമായി ഒരിക്കൽ കൂടി, അതിന്റെ പ്രധാന API ഉപയോഗിച്ച് ഒന്നിലധികം സീക്വൻസുകൾ (പാഡിംഗ്!), വളരെ നീണ്ട സീക്വൻസുകൾ (ട്രങ്കേഷൻ!), പലതരം ടെൻസറുകൾ എന്നിവ ഇത് എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്ന് നോക്കാം:
+
+```py
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
+
+tokens = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt")
+output = model(**tokens)
+```

From 97fafca0e50d41ead104ed02d75f8523ed8cc1d1 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 12:42:31 +0530
Subject: [PATCH 28/44] Add Malayalam translation for chapter2/7.mdx

---
 chapters/ml/chapter2/7.mdx | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 chapters/ml/chapter2/7.mdx

diff --git a/chapters/ml/chapter2/7.mdx b/chapters/ml/chapter2/7.mdx
new file mode 100644
index 000000000..5aa0b1990
--- /dev/null
+++ b/chapters/ml/chapter2/7.mdx
@@ -0,0 +1,18 @@
+# അടിസ്ഥാന ഉപയോഗം പൂർത്തിയായി![[basic-usage-completed]]
+
+<CourseFloatingBanner
+    chapter={2}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+ഇതുവരെ കോഴ്‌സ് പിന്തുടർന്നതിന് അഭിനന്ദനങ്ങൾ! ഒന്ന് ഓർത്തെടുക്കാം, ഈ അധ്യായത്തിൽ നിങ്ങൾ:
+
+- ഒരു Transformer മോഡലിന്റെ അടിസ്ഥാന നിർമ്മാണഘടകങ്ങൾ പഠിച്ചു.
+- ഒരു ടോക്കണൈസേഷൻ പൈപ്പ്‌ലൈനിൽ എന്തൊക്കെ ഉൾപ്പെടുന്നു എന്ന് പഠിച്ചു.
+- ഒരു Transformer മോഡൽ പ്രായോഗികമായി എങ്ങനെ ഉപയോഗിക്കാം എന്ന് കണ്ടു.
+- ടെക്‌സ്‌റ്റിനെ മോഡലിന് മനസ്സിലാകുന്ന ടെൻസറുകളാക്കി മാറ്റാൻ ഒരു ടോക്കണൈസർ എങ്ങനെ പ്രയോജനപ്പെടുത്താം എന്ന് പഠിച്ചു.
+- ടെക്‌സ്‌റ്റിൽ നിന്ന് പ്രവചനങ്ങളിലേക്ക് എത്താൻ ഒരു ടോക്കണൈസറും ഒരു മോഡലും ഒരുമിച്ച് സെറ്റപ്പ് ചെയ്തു.
+- ഇൻപുട്ട് ID-കളുടെ പരിമിതികൾ മനസ്സിലാക്കി, അറ്റൻഷൻ മാസ്‌ക്കുകളെക്കുറിച്ച് പഠിച്ചു.
+- വൈവിധ്യമാർന്നതും ക്രമീകരിക്കാവുന്നതുമായ ടോക്കണൈസർ മെത്തേഡുകൾ പരീക്ഷിച്ചുനോക്കി.
+
+ഇനി മുതൽ, 🤗 Transformers ഡോക്യുമെന്റേഷനിലൂടെ സ്വതന്ത്രമായി സഞ്ചരിക്കാൻ നിങ്ങൾക്ക് കഴിയണം: അതിലെ പദാവലി പരിചിതമായി തോന്നും, മിക്കപ്പോഴും നിങ്ങൾ ഉപയോഗിക്കാൻ പോകുന്ന മെത്തേഡുകൾ നിങ്ങൾ ഇതിനകം കണ്ടുകഴിഞ്ഞു.

From 6c09c153246fdc4c14ba4621e5c87497d26a8443 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 12:51:54 +0530
Subject: [PATCH 29/44] Add Malayalam translation for chapter2/8.mdx

---
 chapters/ml/chapter2/8.mdx | 857 +++++++++++++++++++++++++++++++++++++
 1 file changed, 857 insertions(+)
 create mode 100644 chapters/ml/chapter2/8.mdx

diff --git a/chapters/ml/chapter2/8.mdx b/chapters/ml/chapter2/8.mdx
new file mode 100644
index 000000000..6e322e0b0
--- /dev/null
+++ b/chapters/ml/chapter2/8.mdx
@@ -0,0 +1,857 @@
+# ഒപ്റ്റിമൈസ് ചെയ്ത ഇൻഫറൻസ് ഡിപ്ലോയ്‌മെന്റ്
+
+ഈ ഭാഗത്തിൽ, LLM ഡിപ്ലോയ്‌മെന്റുകൾ ഒപ്റ്റിമൈസ് ചെയ്യാനുള്ള നൂതന ഫ്രെയിംവർക്കുകളായ Text Generation Inference (TGI), vLLM, llama.cpp എന്നിവ നമ്മൾ പരിചയപ്പെടും. ഉപയോക്താക്കൾക്ക് LLM-കൾ സേവനമായി നൽകാൻ (serve) പ്രൊഡക്ഷൻ പരിതസ്ഥിതികളിലാണ് ഈ ആപ്ലിക്കേഷനുകൾ പ്രധാനമായും ഉപയോഗിക്കുന്നത്. ഒരൊറ്റ മെഷീനിൽ ഇൻഫറൻസിനായി ഇവ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിനെക്കാൾ, ഈ ഫ്രെയിംവർക്കുകൾ പ്രൊഡക്ഷനിൽ എങ്ങനെ ഡിപ്ലോയ് ചെയ്യാം എന്നതിലാണ് ഈ ഭാഗം ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നത്.
+
+ഈ ടൂളുകൾ ഇൻഫറൻസ് കാര്യക്ഷമത എങ്ങനെ പരമാവധി ഉയർത്തുന്നു എന്നും ലാർജ് ലാംഗ്വേജ് മോഡലുകളുടെ പ്രൊഡക്ഷൻ ഡിപ്ലോയ്‌മെന്റുകൾ എങ്ങനെ ലളിതമാക്കുന്നു എന്നും നമ്മൾ പരിശോധിക്കും.
+
+## ഫ്രെയിംവർക്ക് തിരഞ്ഞെടുക്കാനുള്ള ഗൈഡ്
+
+TGI, vLLM, llama.cpp എന്നിവ സമാനമായ ആവശ്യങ്ങൾക്കാണ് ഉപയോഗിക്കുന്നതെങ്കിലും, വ്യത്യസ്ത ഉപയോഗ സാഹചര്യങ്ങൾക്ക് (use cases) കൂടുതൽ യോജിച്ചവയാക്കുന്ന തനതായ സവിശേഷതകൾ ഓരോന്നിനുമുണ്ട്. പ്രകടനത്തിലും (performance) ഇന്റഗ്രേഷനിലും ശ്രദ്ധ കേന്ദ്രീകരിച്ച്, അവയ്ക്കിടയിലുള്ള പ്രധാന വ്യത്യാസങ്ങൾ നോക്കാം.
+
+### മെമ്മറി മാനേജ്‌മെന്റും പ്രകടനവും
+
+**TGI** പ്രൊഡക്ഷനിൽ സ്ഥിരതയോടെയും പ്രവചിക്കാവുന്ന രീതിയിലും പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്തതാണ്; മെമ്മറി ഉപയോഗം സ്ഥിരമായി നിലനിർത്താൻ ഇത് നിശ്ചിത സീക്വൻസ് ലെങ്ത്തുകൾ ഉപയോഗിക്കുന്നു. Flash Attention 2, കണ്ടിന്യുവസ് ബാച്ചിംഗ് (continuous batching) എന്നീ വിദ്യകൾ ഉപയോഗിച്ചാണ് TGI മെമ്മറി കൈകാര്യം ചെയ്യുന്നത്. അതായത്, അറ്റൻഷൻ കണക്കുകൂട്ടലുകൾ വളരെ കാര്യക്ഷമമായി പ്രോസസ്സ് ചെയ്യാനും, GPU-വിന് നിരന്തരം ജോലി നൽകിക്കൊണ്ട് അതിനെ തിരക്കിലാക്കി നിർത്താനും ഇതിന് കഴിയും. ആവശ്യമുള്ളപ്പോൾ മോഡലിന്റെ ഭാഗങ്ങൾ CPU-വിനും GPU-വിനും ഇടയിൽ മാറ്റാൻ ഈ സിസ്റ്റത്തിന് കഴിയും; ഇത് കൂടുതൽ വലിയ മോഡലുകൾ കൈകാര്യം ചെയ്യാൻ സഹായിക്കുന്നു. 
+
+<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/tgi/flash-attn.png" alt="Flash Attention" />
+
+<Tip title="Flash Attention എങ്ങനെ പ്രവർത്തിക്കുന്നു">
+
+മെമ്മറി ബാൻഡ്‌വിഡ്ത്ത് തടസ്സങ്ങൾ (bottlenecks) പരിഹരിച്ചുകൊണ്ട് Transformer മോഡലുകളിലെ അറ്റൻഷൻ മെക്കാനിസം ഒപ്റ്റിമൈസ് ചെയ്യുന്ന ഒരു വിദ്യയാണ് Flash Attention. [അധ്യായം 1.8](/course/chapter1/8)-ൽ നേരത്തെ ചർച്ച ചെയ്തതുപോലെ, അറ്റൻഷൻ മെക്കാനിസത്തിന്റെ സങ്കീർണ്ണതയും മെമ്മറി ഉപയോഗവും ക്വാഡ്രാറ്റിക് (quadratic) ആണ്; ഇത് നീണ്ട സീക്വൻസുകൾക്ക് അതിനെ കാര്യക്ഷമമല്ലാതാക്കുന്നു.
+
+High Bandwidth Memory (HBM)-യും അതിലും വേഗതയേറിയ SRAM കാഷും തമ്മിലുള്ള മെമ്മറി കൈമാറ്റങ്ങൾ എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്നതിലാണ് ഇതിന്റെ പ്രധാന നൂതനത്വം. പരമ്പരാഗത അറ്റൻഷൻ HBM-നും SRAM-നും ഇടയിൽ ഡേറ്റ ആവർത്തിച്ച് കൈമാറുന്നു; ഇത് GPU-വിനെ വെറുതെയിരുത്തി തടസ്സങ്ങൾ സൃഷ്ടിക്കുന്നു. Flash Attention ഡേറ്റ ഒരിക്കൽ മാത്രം SRAM-ലേക്ക് ലോഡ് ചെയ്ത് എല്ലാ കണക്കുകൂട്ടലുകളും അവിടെത്തന്നെ നടത്തുന്നു; അതുവഴി ചെലവേറിയ മെമ്മറി കൈമാറ്റങ്ങൾ ഏറ്റവും കുറയ്ക്കുന്നു. 
+
+ട്രെയിനിംഗ് സമയത്താണ് ഇതിന്റെ പ്രയോജനങ്ങൾ ഏറ്റവും പ്രകടമാകുന്നതെങ്കിലും, Flash Attention-ന്റെ കുറഞ്ഞ VRAM ഉപയോഗവും മെച്ചപ്പെട്ട കാര്യക്ഷമതയും ഇൻഫറൻസിനും അതിനെ വിലപ്പെട്ടതാക്കുന്നു; കൂടുതൽ വേഗതയേറിയതും സ്കേലബിളായതുമായ LLM സെർവിംഗ് ഇത് സാധ്യമാക്കുന്നു.
+
+</Tip>
+
+**vLLM** PagedAttention ഉപയോഗിച്ച് വ്യത്യസ്തമായ ഒരു സമീപനമാണ് സ്വീകരിക്കുന്നത്. ഒരു കമ്പ്യൂട്ടർ തന്റെ മെമ്മറി പേജുകളായി കൈകാര്യം ചെയ്യുന്നതുപോലെ, vLLM മോഡലിന്റെ മെമ്മറിയെ ചെറിയ ബ്ലോക്കുകളായി വിഭജിക്കുന്നു. ഈ ബുദ്ധിപൂർവ്വമായ സംവിധാനം കാരണം, വ്യത്യസ്ത വലുപ്പത്തിലുള്ള റിക്വസ്‌റ്റുകൾ കൂടുതൽ വഴക്കത്തോടെ കൈകാര്യം ചെയ്യാൻ ഇതിന് കഴിയുന്നു, മെമ്മറി സ്ഥലം പാഴാക്കുന്നുമില്ല. വ്യത്യസ്ത റിക്വസ്‌റ്റുകൾക്കിടയിൽ മെമ്മറി പങ്കുവയ്ക്കുന്നതിൽ ഇത് പ്രത്യേകിച്ചും മികച്ചതാണ്; മെമ്മറി ഫ്രാഗ്‌മെന്റേഷൻ കുറയ്ക്കുകയും ചെയ്യുന്നു, ഇത് സിസ്റ്റത്തെ മൊത്തത്തിൽ കൂടുതൽ കാര്യക്ഷമമാക്കുന്നു.
+
+<Tip title="PagedAttention എങ്ങനെ പ്രവർത്തിക്കുന്നു">
+
+LLM ഇൻഫറൻസിലെ മറ്റൊരു നിർണ്ണായക തടസ്സം പരിഹരിക്കുന്ന ഒരു വിദ്യയാണ് PagedAttention: KV കാഷ് മെമ്മറി മാനേജ്‌മെന്റ്. [അധ്യായം 1.8](/course/chapter1/8)-ൽ ചർച്ച ചെയ്തതുപോലെ, ടെക്‌സ്‌റ്റ് ജനറേഷൻ സമയത്ത്, ആവർത്തിച്ചുള്ള കണക്കുകൂട്ടലുകൾ കുറയ്ക്കാൻ മോഡൽ ജനറേറ്റ് ചെയ്ത ഓരോ ടോക്കണിന്റെയും അറ്റൻഷൻ കീകളും വാല്യൂകളും (KV കാഷ്) സംഭരിച്ചുവയ്ക്കുന്നു. പ്രത്യേകിച്ച് നീണ്ട സീക്വൻസുകളോ ഒരേസമയം ഒന്നിലധികം റിക്വസ്‌റ്റുകളോ ഉള്ളപ്പോൾ, KV കാഷ് വളരെ വലുതായി മാറാം.
+
+ഈ കാഷ് എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്നതിലാണ് vLLM-ന്റെ പ്രധാന നൂതനത്വം:
+
+1. **മെമ്മറി പേജിംഗ് (Memory Paging)**: KV കാഷിനെ ഒരൊറ്റ വലിയ ബ്ലോക്കായി കണക്കാക്കുന്നതിനുപകരം, അതിനെ നിശ്ചിത വലുപ്പമുള്ള "പേജുകളായി" വിഭജിക്കുന്നു (ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലെ വിർച്വൽ മെമ്മറിക്ക് സമാനമായി).
+2. **തുടർച്ചയല്ലാത്ത സംഭരണം (Non-contiguous Storage)**: പേജുകൾ GPU മെമ്മറിയിൽ തുടർച്ചയായി സംഭരിക്കേണ്ട ആവശ്യമില്ല; ഇത് കൂടുതൽ വഴക്കമുള്ള മെമ്മറി അലോക്കേഷൻ സാധ്യമാക്കുന്നു.
+3. **പേജ് ടേബിൾ മാനേജ്‌മെന്റ് (Page Table Management)**: ഏതൊക്കെ പേജുകൾ ഏത് സീക്വൻസിന്റേതാണ് എന്ന് ഒരു പേജ് ടേബിൾ ട്രാക്ക് ചെയ്യുന്നു; ഇത് കാര്യക്ഷമമായ തിരയലും ആക്‌സസ്സും സാധ്യമാക്കുന്നു.
+4. **മെമ്മറി പങ്കുവയ്ക്കൽ (Memory Sharing)**: പാരലൽ സാംപ്ലിംഗ് പോലുള്ള പ്രവർത്തനങ്ങളിൽ, പ്രോംപ്‌റ്റിന്റെ KV കാഷ് സംഭരിക്കുന്ന പേജുകൾ ഒന്നിലധികം സീക്വൻസുകൾക്കിടയിൽ പങ്കുവയ്ക്കാം.
+
+പരമ്പരാഗത രീതികളെ അപേക്ഷിച്ച് 24 മടങ്ങ് വരെ ഉയർന്ന ത്രൂപുട്ട് (throughput) നേടാൻ PagedAttention സമീപനത്തിന് കഴിയും; ഇത് പ്രൊഡക്ഷൻ LLM ഡിപ്ലോയ്‌മെന്റുകളിൽ വലിയ മാറ്റം കൊണ്ടുവരുന്ന ഒന്നാണ്. PagedAttention എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിലേക്ക് ശരിക്കും ആഴത്തിൽ ഇറങ്ങണമെന്നുണ്ടെങ്കിൽ, [vLLM ഡോക്യുമെന്റേഷനിലെ ഗൈഡ്](https://docs.vllm.ai/en/latest/design/kernel/paged_attention.html) നിങ്ങൾക്ക് വായിക്കാം.
+
+</Tip>
+
+**llama.cpp** സാധാരണ ഉപഭോക്തൃ ഹാർഡ്‌വെയറിൽ (consumer hardware) LLaMA മോഡലുകൾ റൺ ചെയ്യാനായി ആദ്യം രൂപകൽപ്പന ചെയ്ത, ഉയർന്ന തോതിൽ ഒപ്റ്റിമൈസ് ചെയ്ത ഒരു C/C++ ഇംപ്ലിമെന്റേഷനാണ്. ഓപ്‌ഷണലായ GPU ആക്‌സിലറേഷനോടുകൂടി CPU കാര്യക്ഷമതയിലാണ് ഇത് ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നത്; വിഭവങ്ങൾ പരിമിതമായ പരിതസ്ഥിതികൾക്ക് ഇത് ഏറ്റവും അനുയോജ്യമാണ്. മികച്ച പ്രകടനം നിലനിർത്തിക്കൊണ്ടുതന്നെ മോഡലിന്റെ വലുപ്പവും മെമ്മറി ആവശ്യങ്ങളും കുറയ്ക്കാൻ llama.cpp ക്വാണ്ടൈസേഷൻ (quantization) വിദ്യകൾ ഉപയോഗിക്കുന്നു. വിവിധ CPU ആർക്കിടെക്ചറുകൾക്കായി ഒപ്റ്റിമൈസ് ചെയ്ത കെർണലുകൾ ഇത് ഇംപ്ലിമെന്റ് ചെയ്യുന്നു, കൂടാതെ കാര്യക്ഷമമായ ടോക്കൺ ജനറേഷനായി അടിസ്ഥാന KV കാഷ് മാനേജ്‌മെന്റിനെ പിന്തുണയ്ക്കുന്നു.
+
+<Tip title="llama.cpp ക്വാണ്ടൈസേഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു">
+
+llama.cpp-യിലെ ക്വാണ്ടൈസേഷൻ മോഡൽ വെയ്‌റ്റുകളുടെ പ്രിസിഷൻ 32-ബിറ്റ് അല്ലെങ്കിൽ 16-ബിറ്റ് ഫ്ലോട്ടിംഗ് പോയിന്റിൽ നിന്ന് 8-ബിറ്റ് ഇന്റിജർ (INT8), 4-ബിറ്റ്, അതിലും താഴെ എന്നിങ്ങനെയുള്ള കുറഞ്ഞ പ്രിസിഷൻ ഫോർമാറ്റുകളിലേക്ക് കുറയ്ക്കുന്നു. ഗുണനിലവാരത്തിൽ ഏറ്റവും കുറഞ്ഞ നഷ്ടത്തോടെ ഇത് മെമ്മറി ഉപയോഗം കാര്യമായി കുറയ്ക്കുകയും ഇൻഫറൻസ് വേഗം മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു.
+
+llama.cpp-യിലെ പ്രധാന ക്വാണ്ടൈസേഷൻ സവിശേഷതകൾ ഇവയാണ്:
+1. **ഒന്നിലധികം ക്വാണ്ടൈസേഷൻ ലെവലുകൾ (Multiple Quantization Levels)**: 8-ബിറ്റ്, 4-ബിറ്റ്, 3-ബിറ്റ്, എന്തിന്, 2-ബിറ്റ് ക്വാണ്ടൈസേഷൻ വരെ പിന്തുണയ്ക്കുന്നു
+2. **GGML/GGUF ഫോർമാറ്റ്**: ക്വാണ്ടൈസ്ഡ് ഇൻഫറൻസിനായി ഒപ്റ്റിമൈസ് ചെയ്ത കസ്‌റ്റം ടെൻസർ ഫോർമാറ്റുകൾ ഉപയോഗിക്കുന്നു
+3. **മിക്‌സഡ് പ്രിസിഷൻ (Mixed Precision)**: മോഡലിന്റെ വ്യത്യസ്ത ഭാഗങ്ങൾക്ക് വ്യത്യസ്ത ക്വാണ്ടൈസേഷൻ ലെവലുകൾ പ്രയോഗിക്കാൻ കഴിയും
+4. **ഹാർഡ്‌വെയർ-നിർദ്ദിഷ്ട ഒപ്റ്റിമൈസേഷനുകൾ (Hardware-Specific Optimizations)**: വിവിധ CPU ആർക്കിടെക്ചറുകൾക്കായി (AVX2, AVX-512, NEON) ഒപ്റ്റിമൈസ് ചെയ്ത കോഡ് പാതകൾ ഉൾപ്പെടുന്നു
+
+പരിമിതമായ മെമ്മറിയുള്ള സാധാരണ ഉപഭോക്തൃ ഹാർഡ്‌വെയറിൽ ബില്യൺ കണക്കിന് പാരാമീറ്ററുകളുള്ള മോഡലുകൾ റൺ ചെയ്യാൻ ഈ സമീപനം സാധ്യമാക്കുന്നു; ഇത് ലോക്കൽ ഡിപ്ലോയ്‌മെന്റുകൾക്കും എഡ്ജ് ഡിവൈസുകൾക്കും ഇതിനെ തികച്ചും അനുയോജ്യമാക്കുന്നു.
+
+</Tip>
+
+### ഡിപ്ലോയ്‌മെന്റും ഇന്റഗ്രേഷനും
+
+ഇനി ഈ ഫ്രെയിംവർക്കുകൾ തമ്മിലുള്ള ഡിപ്ലോയ്‌മെന്റ്, ഇന്റഗ്രേഷൻ വ്യത്യാസങ്ങളിലേക്ക് കടക്കാം.
+
+**TGI** അതിന്റെ പ്രൊഡക്ഷൻ-റെഡി സവിശേഷതകൾ കൊണ്ട് എന്റർപ്രൈസ് തലത്തിലുള്ള ഡിപ്ലോയ്‌മെന്റിൽ മികച്ചുനിൽക്കുന്നു. ബിൽറ്റ്-ഇൻ Kubernetes പിന്തുണയോടെ വരുന്ന ഇതിൽ, Prometheus, Grafana എന്നിവ വഴിയുള്ള മോണിറ്ററിംഗ്, ഓട്ടോമാറ്റിക് സ്കേലിംഗ്, സമഗ്രമായ സുരക്ഷാ സവിശേഷതകൾ എന്നിങ്ങനെ പ്രൊഡക്ഷനിൽ റൺ ചെയ്യാൻ നിങ്ങൾക്ക് ആവശ്യമുള്ളതെല്ലാം ഉൾപ്പെടുന്നു. നിങ്ങളുടെ ഡിപ്ലോയ്‌മെന്റ് സുരക്ഷിതവും സ്ഥിരതയുള്ളതുമായി നിലനിർത്താൻ എന്റർപ്രൈസ്-ഗ്രേഡ് ലോഗിംഗും, കണ്ടന്റ് ഫിൽറ്ററിംഗ്, റേറ്റ് ലിമിറ്റിംഗ് തുടങ്ങിയ വിവിധ സംരക്ഷണ നടപടികളും ഈ സിസ്റ്റത്തിൽ ഉൾപ്പെടുന്നു.
+
+**vLLM** ഡിപ്ലോയ്‌മെന്റിനോട് കൂടുതൽ വഴക്കമുള്ളതും ഡെവലപ്പർ-സൗഹൃദവുമായ ഒരു സമീപനമാണ് സ്വീകരിക്കുന്നത്. Python-നെ കാതലാക്കി നിർമ്മിച്ചിരിക്കുന്ന ഇതിന്, നിങ്ങളുടെ നിലവിലുള്ള ആപ്ലിക്കേഷനുകളിൽ OpenAI-യുടെ API-യെ എളുപ്പത്തിൽ പകരം വയ്ക്കാൻ കഴിയും. ഈ ഫ്രെയിംവർക്ക് അസംസ്കൃത പ്രകടനം (raw performance) നൽകുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു; നിങ്ങളുടെ പ്രത്യേക ആവശ്യങ്ങൾക്ക് അനുസരിച്ച് ഇത് ഇഷ്ടാനുസൃതമാക്കാനും കഴിയും. ക്ലസ്‌റ്ററുകൾ കൈകാര്യം ചെയ്യാൻ Ray-യുമായി ഇത് പ്രത്യേകിച്ചും നന്നായി പ്രവർത്തിക്കുന്നു; ഉയർന്ന പ്രകടനവും അനുരൂപപ്പെടാനുള്ള കഴിവും ആവശ്യമുള്ളപ്പോൾ ഇത് മികച്ചൊരു തിരഞ്ഞെടുപ്പാണ്.
+
+**llama.cpp** ലാളിത്യത്തിനും പോർട്ടബിലിറ്റിക്കും മുൻഗണന നൽകുന്നു. ഇതിന്റെ സെർവർ ഇംപ്ലിമെന്റേഷൻ ഭാരം കുറഞ്ഞതാണ്; ശക്തമായ സെർവറുകളിൽ നിന്ന് സാധാരണ ലാപ്‌ടോപ്പുകളിലേക്കും, എന്തിന്, ചില ഹൈ-എൻഡ് മൊബൈൽ ഡിവൈസുകളിലേക്കും വരെ, വിപുലമായ ഹാർഡ്‌വെയർ ശ്രേണിയിൽ ഇത് റൺ ചെയ്യാൻ കഴിയും. ഏറ്റവും കുറഞ്ഞ ഡിപ്പൻഡൻസികളും ലളിതമായ ഒരു C/C++ കാതലും ഉള്ളതിനാൽ, Python ഫ്രെയിംവർക്കുകൾ ഇൻസ്‌റ്റാൾ ചെയ്യുന്നത് വെല്ലുവിളിയാകുന്ന പരിതസ്ഥിതികളിൽ ഇത് ഡിപ്ലോയ് ചെയ്യാൻ എളുപ്പമാണ്. മറ്റ് പരിഹാരങ്ങളെ അപേക്ഷിച്ച് വളരെ ചെറിയ റിസോഴ്‌സ് ഉപയോഗം (resource footprint) നിലനിർത്തിക്കൊണ്ടുതന്നെ ഈ സെർവർ OpenAI-അനുയോജ്യമായ ഒരു API നൽകുന്നു.
+
+## തുടങ്ങാം
+
+ഇൻസ്‌റ്റലേഷനും അടിസ്ഥാന സെറ്റപ്പും മുതൽ തുടങ്ങി, LLM-കൾ ഡിപ്ലോയ് ചെയ്യാൻ ഈ ഫ്രെയിംവർക്കുകൾ എങ്ങനെ ഉപയോഗിക്കാം എന്ന് നോക്കാം.
+
+### ഇൻസ്‌റ്റലേഷനും അടിസ്ഥാന സെറ്റപ്പും
+
+<hfoptions id="inference-frameworks" >
+
+<hfoption value="tgi" label="TGI">
+
+TGI ഇൻസ്‌റ്റാൾ ചെയ്യാനും ഉപയോഗിക്കാനും എളുപ്പമാണ്; Hugging Face ഇക്കോസിസ്‌റ്റവുമായി ഇതിന് ആഴത്തിലുള്ള ഇന്റഗ്രേഷനുണ്ട്.
+
+ആദ്യം, Docker ഉപയോഗിച്ച് TGI സെർവർ ലോഞ്ച് ചെയ്യുക:
+
+```sh
+docker run --gpus all \
+    --shm-size 1g \
+    -p 8080:80 \
+    -v ~/.cache/huggingface:/data \
+    ghcr.io/huggingface/text-generation-inference:latest \
+    --model-id HuggingFaceTB/SmolLM2-360M-Instruct
+```
+
+തുടർന്ന്, Hugging Face-ന്റെ InferenceClient ഉപയോഗിച്ച് അതുമായി സംവദിക്കുക:
+
+```python
+from huggingface_hub import InferenceClient
+
+# Initialize client pointing to TGI endpoint
+client = InferenceClient(
+    model="http://localhost:8080",  # URL to the TGI server
+)
+
+# Text generation
+response = client.text_generation(
+    "Tell me a story",
+    max_new_tokens=100,
+    temperature=0.7,
+    top_p=0.95,
+    details=True,
+    stop_sequences=[],
+)
+print(response.generated_text)
+
+# For chat format
+response = client.chat_completion(
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Tell me a story"},
+    ],
+    max_tokens=100,
+    temperature=0.7,
+    top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+പകരമായി, OpenAI ക്ലയന്റും നിങ്ങൾക്ക് ഉപയോഗിക്കാം:
+
+```python
+from openai import OpenAI
+
+# Initialize client pointing to TGI endpoint
+client = OpenAI(
+    base_url="http://localhost:8080/v1",  # Make sure to include /v1
+    api_key="not-needed",  # TGI doesn't require an API key by default
+)
+
+# Chat completion
+response = client.chat.completions.create(
+    model="HuggingFaceTB/SmolLM2-360M-Instruct",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Tell me a story"},
+    ],
+    max_tokens=100,
+    temperature=0.7,
+    top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+</hfoption>
+
+<hfoption value="llama.cpp" label="llama.cpp">
+
+llama.cpp ഇൻസ്‌റ്റാൾ ചെയ്യാനും ഉപയോഗിക്കാനും എളുപ്പമാണ്; ഇതിന് ഏറ്റവും കുറഞ്ഞ ഡിപ്പൻഡൻസികൾ മാത്രമേ ആവശ്യമുള്ളൂ, CPU, GPU ഇൻഫറൻസ് രണ്ടും ഇത് പിന്തുണയ്ക്കുന്നു.
+
+ആദ്യം, llama.cpp ഇൻസ്‌റ്റാൾ ചെയ്ത് ബിൽഡ് ചെയ്യുക:
+
+```sh
+# Clone the repository
+git clone https://github.com/ggerganov/llama.cpp
+cd llama.cpp
+
+# Build the project
+make
+
+# Download the SmolLM2-1.7B-Instruct-GGUF model
+curl -L -O https://huggingface.co/HuggingFaceTB/SmolLM2-1.7B-Instruct-GGUF/resolve/main/smollm2-1.7b-instruct.Q4_K_M.gguf
+```
+
+തുടർന്ന്, സെർവർ ലോഞ്ച് ചെയ്യുക (OpenAI API അനുയോജ്യതയോടെ):
+
+```sh
+# Start the server
+./server \
+    -m smollm2-1.7b-instruct.Q4_K_M.gguf \
+    --host 0.0.0.0 \
+    --port 8080 \
+    -c 4096 \
+    --n-gpu-layers 0  # Set to a higher number to use GPU
+```
+
+Hugging Face-ന്റെ InferenceClient ഉപയോഗിച്ച് സെർവറുമായി സംവദിക്കുക:
+
+```python
+from huggingface_hub import InferenceClient
+
+# Initialize client pointing to llama.cpp server
+client = InferenceClient(
+    model="http://localhost:8080/v1",  # URL to the llama.cpp server
+    token="sk-no-key-required",  # llama.cpp server requires this placeholder
+)
+
+# Text generation
+response = client.text_generation(
+    "Tell me a story",
+    max_new_tokens=100,
+    temperature=0.7,
+    top_p=0.95,
+    details=True,
+)
+print(response.generated_text)
+
+# For chat format
+response = client.chat_completion(
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Tell me a story"},
+    ],
+    max_tokens=100,
+    temperature=0.7,
+    top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+പകരമായി, OpenAI ക്ലയന്റും നിങ്ങൾക്ക് ഉപയോഗിക്കാം:
+
+```python
+from openai import OpenAI
+
+# Initialize client pointing to llama.cpp server
+client = OpenAI(
+    base_url="http://localhost:8080/v1",
+    api_key="sk-no-key-required",  # llama.cpp server requires this placeholder
+)
+
+# Chat completion
+response = client.chat.completions.create(
+    model="smollm2-1.7b-instruct",  # Model identifier can be anything as server only loads one model
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Tell me a story"},
+    ],
+    max_tokens=100,
+    temperature=0.7,
+    top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+</hfoption>
+
+<hfoption value="vllm" label="vLLM">
+
+vLLM ഇൻസ്‌റ്റാൾ ചെയ്യാനും ഉപയോഗിക്കാനും എളുപ്പമാണ്; OpenAI API അനുയോജ്യതയും ഒരു നേറ്റീവ് Python ഇന്റർഫേസും ഇതിനുണ്ട്.
+
+ആദ്യം, vLLM-ന്റെ OpenAI-അനുയോജ്യമായ സെർവർ ലോഞ്ച് ചെയ്യുക:
+
+```sh
+python -m vllm.entrypoints.openai.api_server \
+    --model HuggingFaceTB/SmolLM2-360M-Instruct \
+    --host 0.0.0.0 \
+    --port 8000
+```
+
+തുടർന്ന്, Hugging Face-ന്റെ InferenceClient ഉപയോഗിച്ച് അതുമായി സംവദിക്കുക:
+
+```python
+from huggingface_hub import InferenceClient
+
+# Initialize client pointing to vLLM endpoint
+client = InferenceClient(
+    model="http://localhost:8000/v1",  # URL to the vLLM server
+)
+
+# Text generation
+response = client.text_generation(
+    "Tell me a story",
+    max_new_tokens=100,
+    temperature=0.7,
+    top_p=0.95,
+    details=True,
+)
+print(response.generated_text)
+
+# For chat format
+response = client.chat_completion(
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Tell me a story"},
+    ],
+    max_tokens=100,
+    temperature=0.7,
+    top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+പകരമായി, OpenAI ക്ലയന്റും നിങ്ങൾക്ക് ഉപയോഗിക്കാം:
+
+```python
+from openai import OpenAI
+
+# Initialize client pointing to vLLM endpoint
+client = OpenAI(
+    base_url="http://localhost:8000/v1",
+    api_key="not-needed",  # vLLM doesn't require an API key by default
+)
+
+# Chat completion
+response = client.chat.completions.create(
+    model="HuggingFaceTB/SmolLM2-360M-Instruct",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Tell me a story"},
+    ],
+    max_tokens=100,
+    temperature=0.7,
+    top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+</hfoption>
+
+</hfoptions>
+
+### അടിസ്ഥാന ടെക്‌സ്‌റ്റ് ജനറേഷൻ
+
+ഈ ഫ്രെയിംവർക്കുകൾ ഉപയോഗിച്ചുള്ള ടെക്‌സ്‌റ്റ് ജനറേഷന്റെ ഉദാഹരണങ്ങൾ നോക്കാം:
+
+<hfoptions id="inference-frameworks" >
+
+<hfoption value="tgi" label="TGI">
+
+ആദ്യം, നൂതന പാരാമീറ്ററുകളോടെ TGI ഡിപ്ലോയ് ചെയ്യുക:
+```sh
+docker run --gpus all \
+    --shm-size 1g \
+    -p 8080:80 \
+    -v ~/.cache/huggingface:/data \
+    ghcr.io/huggingface/text-generation-inference:latest \
+    --model-id HuggingFaceTB/SmolLM2-360M-Instruct \
+    --max-total-tokens 4096 \
+    --max-input-length 3072 \
+    --max-batch-total-tokens 8192 \
+    --waiting-served-ratio 1.2
+```
+
+വഴക്കമുള്ള ടെക്‌സ്‌റ്റ് ജനറേഷനായി InferenceClient ഉപയോഗിക്കുക:
+
+```python
+from huggingface_hub import InferenceClient
+
+client = InferenceClient(model="http://localhost:8080")
+
+# Advanced parameters example
+response = client.chat_completion(
+    messages=[
+        {"role": "system", "content": "You are a creative storyteller."},
+        {"role": "user", "content": "Write a creative story"},
+    ],
+    temperature=0.8,
+    max_tokens=200,
+    top_p=0.95,
+)
+print(response.choices[0].message.content)
+
+# Raw text generation
+response = client.text_generation(
+    "Write a creative story about space exploration",
+    max_new_tokens=200,
+    temperature=0.8,
+    top_p=0.95,
+    repetition_penalty=1.1,
+    do_sample=True,
+    details=True,
+)
+print(response.generated_text)
+```
+
+അല്ലെങ്കിൽ OpenAI ക്ലയന്റ് ഉപയോഗിക്കുക:
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed")
+
+# Advanced parameters example
+response = client.chat.completions.create(
+    model="HuggingFaceTB/SmolLM2-360M-Instruct",
+    messages=[
+        {"role": "system", "content": "You are a creative storyteller."},
+        {"role": "user", "content": "Write a creative story"},
+    ],
+    temperature=0.8,  # Higher for more creativity
+)
+print(response.choices[0].message.content)
+```
+
+</hfoption>
+
+<hfoption value="llama.cpp" label="llama.cpp">
+
+llama.cpp-യിൽ, സെർവർ ലോഞ്ച് ചെയ്യുമ്പോൾ തന്നെ നൂതന പാരാമീറ്ററുകൾ സെറ്റ് ചെയ്യാം:
+
+```sh
+./server \
+    -m smollm2-1.7b-instruct.Q4_K_M.gguf \
+    --host 0.0.0.0 \
+    --port 8080 \
+    -c 4096 \            # Context size
+    --threads 8 \        # CPU threads to use
+    --batch-size 512 \   # Batch size for prompt evaluation
+    --n-gpu-layers 0     # GPU layers (0 = CPU only)
+```
+
+InferenceClient ഉപയോഗിക്കുക:
+
+```python
+from huggingface_hub import InferenceClient
+
+client = InferenceClient(model="http://localhost:8080/v1", token="sk-no-key-required")
+
+# Advanced parameters example
+response = client.chat_completion(
+    messages=[
+        {"role": "system", "content": "You are a creative storyteller."},
+        {"role": "user", "content": "Write a creative story"},
+    ],
+    temperature=0.8,
+    max_tokens=200,
+    top_p=0.95,
+)
+print(response.choices[0].message.content)
+
+# For direct text generation
+response = client.text_generation(
+    "Write a creative story about space exploration",
+    max_new_tokens=200,
+    temperature=0.8,
+    top_p=0.95,
+    repetition_penalty=1.1,
+    details=True,
+)
+print(response.generated_text)
+```
+
+അല്ലെങ്കിൽ, സാംപ്ലിംഗ് പാരാമീറ്ററുകളുടെ മേൽ നിയന്ത്രണത്തോടെ ജനറേറ്റ് ചെയ്യാൻ OpenAI ക്ലയന്റ് ഉപയോഗിക്കുക:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:8080/v1", api_key="sk-no-key-required")
+
+# Advanced parameters example
+response = client.chat.completions.create(
+    model="smollm2-1.7b-instruct",
+    messages=[
+        {"role": "system", "content": "You are a creative storyteller."},
+        {"role": "user", "content": "Write a creative story"},
+    ],
+    temperature=0.8,  # Higher for more creativity
+    top_p=0.95,  # Nucleus sampling probability
+    frequency_penalty=0.5,  # Reduce repetition of frequent tokens
+    presence_penalty=0.5,  # Reduce repetition by penalizing tokens already present
+    max_tokens=200,  # Maximum generation length
+)
+print(response.choices[0].message.content)
+```
+
+കൂടുതൽ നിയന്ത്രണത്തിനായി llama.cpp-യുടെ നേറ്റീവ് ലൈബ്രറിയും നിങ്ങൾക്ക് ഉപയോഗിക്കാം:
+
+```python
+# Using llama-cpp-python package for direct model access
+from llama_cpp import Llama
+
+# Load the model
+llm = Llama(
+    model_path="smollm2-1.7b-instruct.Q4_K_M.gguf",
+    n_ctx=4096,  # Context window size
+    n_threads=8,  # CPU threads
+    n_gpu_layers=0,  # GPU layers (0 = CPU only)
+)
+
+# Format prompt according to the model's expected format
+prompt = """<|im_start|>system
+You are a creative storyteller.
+<|im_end|>
+<|im_start|>user
+Write a creative story
+<|im_end|>
+<|im_start|>assistant
+"""
+
+# Generate response with precise parameter control
+output = llm(
+    prompt,
+    max_tokens=200,
+    temperature=0.8,
+    top_p=0.95,
+    frequency_penalty=0.5,
+    presence_penalty=0.5,
+    stop=["<|im_end|>"],
+)
+
+print(output["choices"][0]["text"])
+```
+
+</hfoption>
+
+<hfoption value="vllm" label="vLLM">
+
+vLLM-ന്റെ നൂതന ഉപയോഗത്തിനായി, InferenceClient നിങ്ങൾക്ക് ഉപയോഗിക്കാം:
+
+```python
+from huggingface_hub import InferenceClient
+
+client = InferenceClient(model="http://localhost:8000/v1")
+
+# Advanced parameters example
+response = client.chat_completion(
+    messages=[
+        {"role": "system", "content": "You are a creative storyteller."},
+        {"role": "user", "content": "Write a creative story"},
+    ],
+    temperature=0.8,
+    max_tokens=200,
+    top_p=0.95,
+)
+print(response.choices[0].message.content)
+
+# For direct text generation
+response = client.text_generation(
+    "Write a creative story about space exploration",
+    max_new_tokens=200,
+    temperature=0.8,
+    top_p=0.95,
+    details=True,
+)
+print(response.generated_text)
+```
+
+OpenAI ക്ലയന്റും നിങ്ങൾക്ക് ഉപയോഗിക്കാം:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")
+
+# Advanced parameters example
+response = client.chat.completions.create(
+    model="HuggingFaceTB/SmolLM2-360M-Instruct",
+    messages=[
+        {"role": "system", "content": "You are a creative storyteller."},
+        {"role": "user", "content": "Write a creative story"},
+    ],
+    temperature=0.8,
+    top_p=0.95,
+    max_tokens=200,
+)
+print(response.choices[0].message.content)
+```
+
+സൂക്ഷ്മമായ നിയന്ത്രണം (fine-grained control) നൽകുന്ന ഒരു നേറ്റീവ് Python ഇന്റർഫേസും vLLM നൽകുന്നു:
+
+```python
+from vllm import LLM, SamplingParams
+
+# Initialize the model with advanced parameters
+llm = LLM(
+    model="HuggingFaceTB/SmolLM2-360M-Instruct",
+    gpu_memory_utilization=0.85,
+    max_num_batched_tokens=8192,
+    max_num_seqs=256,
+    block_size=16,
+)
+
+# Configure sampling parameters
+sampling_params = SamplingParams(
+    temperature=0.8,  # Higher for more creativity
+    top_p=0.95,  # Consider top 95% probability mass
+    max_tokens=100,  # Maximum length
+    presence_penalty=1.1,  # Reduce repetition
+    frequency_penalty=1.1,  # Reduce repetition
+    stop=["\n\n", "###"],  # Stop sequences
+)
+
+# Generate text
+prompt = "Write a creative story"
+outputs = llm.generate(prompt, sampling_params)
+print(outputs[0].outputs[0].text)
+
+# For chat-style interactions
+chat_prompt = [
+    {"role": "system", "content": "You are a creative storyteller."},
+    {"role": "user", "content": "Write a creative story"},
+]
+formatted_prompt = llm.get_chat_template()(chat_prompt)  # Uses model's chat template
+outputs = llm.generate(formatted_prompt, sampling_params)
+print(outputs[0].outputs[0].text)
+```
+
+</hfoption>
+
+</hfoptions>
+
+## നൂതന ജനറേഷൻ നിയന്ത്രണം
+
+### ടോക്കൺ തിരഞ്ഞെടുപ്പും സാംപ്ലിംഗും
+
+ടെക്‌സ്‌റ്റ് ജനറേറ്റ് ചെയ്യുന്ന പ്രക്രിയയിൽ ഓരോ ഘട്ടത്തിലും അടുത്ത ടോക്കൺ തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്. ഈ തിരഞ്ഞെടുപ്പ് പ്രക്രിയ വിവിധ പാരാമീറ്ററുകളിലൂടെ നിയന്ത്രിക്കാം:
+
+1. **റോ ലോജിറ്റ്‌സ് (Raw Logits)**: ഓരോ ടോക്കണിനുമുള്ള പ്രാരംഭ ഔട്ട്‌പുട്ട് പ്രോബബിലിറ്റികൾ
+2. **ടെമ്പറേച്ചർ (Temperature)**: തിരഞ്ഞെടുപ്പിലെ ക്രമരഹിതത (randomness) നിയന്ത്രിക്കുന്നു (ഉയർന്നത് = കൂടുതൽ സർഗ്ഗാത്മകം)
+3. **Top-p (Nucleus) സാംപ്ലിംഗ്**: പ്രോബബിലിറ്റി മാസ്സിന്റെ X% വരുന്ന മുൻനിര ടോക്കണുകളിലേക്ക് ഫിൽറ്റർ ചെയ്യുന്നു
+4. **Top-k ഫിൽറ്ററിംഗ്**: ഏറ്റവും സാധ്യതയുള്ള k ടോക്കണുകളിലേക്ക് തിരഞ്ഞെടുപ്പ് പരിമിതപ്പെടുത്തുന്നു
+
+ഈ പാരാമീറ്ററുകൾ എങ്ങനെ കോൺഫിഗർ ചെയ്യാം എന്ന് നോക്കാം:
+
+<hfoptions id="inference-frameworks" >
+
+<hfoption value="tgi" label="TGI">
+
+```python
+client.generate(
+    "Write a creative story",
+    temperature=0.8,  # Higher for more creativity
+    top_p=0.95,  # Consider top 95% probability mass
+    top_k=50,  # Consider top 50 tokens
+    max_new_tokens=100,  # Maximum length
+    repetition_penalty=1.1,  # Reduce repetition
+)
+```
+
+</hfoption>
+
+<hfoption value="llama.cpp" label="llama.cpp">
+
+```python
+# Via OpenAI API compatibility
+response = client.completions.create(
+    model="smollm2-1.7b-instruct",  # Model name (can be any string for llama.cpp server)
+    prompt="Write a creative story",
+    temperature=0.8,  # Higher for more creativity
+    top_p=0.95,  # Consider top 95% probability mass
+    frequency_penalty=1.1,  # Reduce repetition
+    presence_penalty=0.1,  # Reduce repetition
+    max_tokens=100,  # Maximum length
+)
+
+# Via llama-cpp-python direct access
+output = llm(
+    "Write a creative story",
+    temperature=0.8,
+    top_p=0.95,
+    top_k=50,
+    max_tokens=100,
+    repeat_penalty=1.1,
+)
+```
+
+</hfoption>
+
+<hfoption value="vllm" label="vLLM">
+
+```python
+params = SamplingParams(
+    temperature=0.8,  # Higher for more creativity
+    top_p=0.95,  # Consider top 95% probability mass
+    top_k=50,  # Consider top 50 tokens
+    max_tokens=100,  # Maximum length
+    presence_penalty=0.1,  # Reduce repetition
+)
+llm.generate("Write a creative story", sampling_params=params)
+```
+
+</hfoption>
+
+</hfoptions>
+
+### ആവർത്തനം നിയന്ത്രിക്കുന്നു
+
+ആവർത്തന സ്വഭാവമുള്ള ടെക്‌സ്‌റ്റ് ജനറേഷൻ തടയാനുള്ള മാർഗ്ഗങ്ങൾ ഈ ഫ്രെയിംവർക്കുകളെല്ലാം നൽകുന്നു:
+
+<hfoptions id="inference-frameworks" >
+
+<hfoption value="tgi" label="TGI">
+
+```python
+client.generate(
+    "Write a varied text",
+    repetition_penalty=1.1,  # Penalize repeated tokens
+    no_repeat_ngram_size=3,  # Prevent 3-gram repetition
+)
+```
+
+</hfoption>
+
+<hfoption value="llama.cpp" label="llama.cpp">
+
+```python
+# Via OpenAI API
+response = client.completions.create(
+    model="smollm2-1.7b-instruct",
+    prompt="Write a varied text",
+    frequency_penalty=1.1,  # Penalize frequent tokens
+    presence_penalty=0.8,  # Penalize tokens already present
+)
+
+# Via direct library
+output = llm(
+    "Write a varied text",
+    repeat_penalty=1.1,  # Penalize repeated tokens
+    frequency_penalty=0.5,  # Additional frequency penalty
+    presence_penalty=0.5,  # Additional presence penalty
+)
+```
+
+</hfoption>
+
+<hfoption value="vllm" label="vLLM">
+
+```python
+params = SamplingParams(
+    presence_penalty=0.1,  # Penalize token presence
+    frequency_penalty=0.1,  # Penalize token frequency
+)
+```
+
+</hfoption>
+
+</hfoptions>
+
+### ദൈർഘ്യ നിയന്ത്രണവും സ്‌റ്റോപ്പ് സീക്വൻസുകളും
+
+ജനറേഷന്റെ ദൈർഘ്യം നിയന്ത്രിക്കാനും എപ്പോൾ നിർത്തണം എന്ന് വ്യക്തമാക്കാനും നിങ്ങൾക്ക് കഴിയും:
+
+<hfoptions id="inference-frameworks" >
+
+<hfoption value="tgi" label="TGI">
+
+```python
+client.generate(
+    "Generate a short paragraph",
+    max_new_tokens=100,
+    min_new_tokens=10,
+    stop_sequences=["\n\n", "###"],
+)
+```
+
+</hfoption>
+
+<hfoption value="llama.cpp" label="llama.cpp">
+
+```python
+# Via OpenAI API
+response = client.completions.create(
+    model="smollm2-1.7b-instruct",
+    prompt="Generate a short paragraph",
+    max_tokens=100,
+    stop=["\n\n", "###"],
+)
+
+# Via direct library
+output = llm("Generate a short paragraph", max_tokens=100, stop=["\n\n", "###"])
+```
+
+</hfoption>
+
+<hfoption value="vllm" label="vLLM">
+
+```python
+params = SamplingParams(
+    max_tokens=100,
+    min_tokens=10,
+    stop=["###", "\n\n"],
+    ignore_eos=False,
+    skip_special_tokens=True,
+)
+```
+
+</hfoption>
+
+</hfoptions>
+
+## മെമ്മറി മാനേജ്‌മെന്റ്
+
+കാര്യക്ഷമമായ ഇൻഫറൻസിനായി ഈ ഫ്രെയിംവർക്കുകളെല്ലാം നൂതന മെമ്മറി മാനേജ്‌മെന്റ് വിദ്യകൾ ഇംപ്ലിമെന്റ് ചെയ്യുന്നു.
+
+<hfoptions id="inference-frameworks" >
+
+<hfoption value="tgi" label="TGI">
+
+TGI Flash Attention 2-ഉം കണ്ടിന്യുവസ് ബാച്ചിംഗും ഉപയോഗിക്കുന്നു:
+
+```sh
+# Docker deployment with memory optimization
+docker run --gpus all -p 8080:80 \
+    --shm-size 1g \
+    ghcr.io/huggingface/text-generation-inference:latest \
+    --model-id HuggingFaceTB/SmolLM2-1.7B-Instruct \
+    --max-batch-total-tokens 8192 \
+    --max-input-length 4096
+```
+
+</hfoption>
+
+<hfoption value="llama.cpp" label="llama.cpp">
+
+llama.cpp ക്വാണ്ടൈസേഷനും ഒപ്റ്റിമൈസ് ചെയ്ത മെമ്മറി ലേഔട്ടും ഉപയോഗിക്കുന്നു:
+
+```sh
+# Server with memory optimizations
+./server \
+    -m smollm2-1.7b-instruct.Q4_K_M.gguf \
+    --host 0.0.0.0 \
+    --port 8080 \
+    -c 2048 \               # Context size
+    --threads 4 \           # CPU threads
+    --n-gpu-layers 32 \     # Use more GPU layers for larger models
+    --mlock \               # Lock memory to prevent swapping
+    --cont-batching         # Enable continuous batching
+```
+
+നിങ്ങളുടെ GPU-വിന് താങ്ങാനാവാത്തത്ര വലിയ മോഡലുകൾക്ക്, CPU ഓഫ്‌ലോഡിംഗ് ഉപയോഗിക്കാം:
+
+```sh
+./server \
+    -m smollm2-1.7b-instruct.Q4_K_M.gguf \
+    --n-gpu-layers 20 \     # Keep first 20 layers on GPU
+    --threads 8             # Use more CPU threads for CPU layers
+```
+
+</hfoption>
+
+<hfoption value="vllm" label="vLLM">
+
+ഏറ്റവും മികച്ച മെമ്മറി മാനേജ്‌മെന്റിനായി vLLM PagedAttention ഉപയോഗിക്കുന്നു:
+
+```python
+from vllm.engine.arg_utils import AsyncEngineArgs
+
+engine_args = AsyncEngineArgs(
+    model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+    gpu_memory_utilization=0.85,
+    max_num_batched_tokens=8192,
+    block_size=16,
+)
+
+llm = LLM(engine_args=engine_args)
+```
+
+</hfoption>
+
+</hfoptions>
+
+## റിസോഴ്‌സുകൾ
+
+- [Text Generation Inference ഡോക്യുമെന്റേഷൻ](https://huggingface.co/docs/text-generation-inference)
+- [TGI GitHub റിപ്പോസിറ്ററി](https://github.com/huggingface/text-generation-inference)
+- [vLLM ഡോക്യുമെന്റേഷൻ](https://vllm.readthedocs.io/)
+- [vLLM GitHub റിപ്പോസിറ്ററി](https://github.com/vllm-project/vllm)
+- [PagedAttention പേപ്പർ](https://arxiv.org/abs/2309.06180)
+- [llama.cpp GitHub റിപ്പോസിറ്ററി](https://github.com/ggerganov/llama.cpp)
+- [llama-cpp-python റിപ്പോസിറ്ററി](https://github.com/abetlen/llama-cpp-python)

From a66e16ad1f44418993d996da85cb99caea091a8a Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 12:56:48 +0530
Subject: [PATCH 30/44] Add Malayalam translation for chapter2/9.mdx

---
 chapters/ml/chapter2/9.mdx | 252 +++++++++++++++++++++++++++++++++++++
 1 file changed, 252 insertions(+)
 create mode 100644 chapters/ml/chapter2/9.mdx

diff --git a/chapters/ml/chapter2/9.mdx b/chapters/ml/chapter2/9.mdx
new file mode 100644
index 000000000..4eedeb1a5
--- /dev/null
+++ b/chapters/ml/chapter2/9.mdx
@@ -0,0 +1,252 @@
+<FrameworkSwitchCourse {fw} />
+
+<!-- DISABLE-FRONTMATTER-SECTIONS -->
+
+# അധ്യായത്തിന്റെ അവസാന ക്വിസ്[[end-of-chapter-quiz]]
+
+<CourseFloatingBanner
+    chapter={2}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+### 1. ലാംഗ്വേജ് മോഡലിംഗ് പൈപ്പ്‌ലൈനിന്റെ ക്രമം എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "ആദ്യം മോഡൽ; അത് ടെക്‌സ്‌റ്റ് കൈകാര്യം ചെയ്ത് അസംസ്കൃത പ്രവചനങ്ങൾ (raw predictions) റിട്ടേൺ ചെയ്യുന്നു. തുടർന്ന് ടോക്കണൈസർ ഈ പ്രവചനങ്ങൾ മനസ്സിലാക്കി, ആവശ്യമുള്ളപ്പോൾ അവയെ തിരികെ ടെക്‌സ്‌റ്റാക്കി മാറ്റുന്നു.",
+			explain: "മോഡലിന് ടെക്‌സ്‌റ്റ് മനസ്സിലാക്കാൻ കഴിയില്ല! മോഡലിന് മനസ്സിലാകുന്ന രൂപത്തിലാക്കാൻ ടോക്കണൈസർ ആദ്യം ടെക്‌സ്‌റ്റ് ടോക്കണൈസ് ചെയ്ത് ID-കളാക്കി മാറ്റണം."
+		},
+		{
+			text: "ആദ്യം ടോക്കണൈസർ; അത് ടെക്‌സ്‌റ്റ് കൈകാര്യം ചെയ്ത് ID-കൾ റിട്ടേൺ ചെയ്യുന്നു. മോഡൽ ഈ ID-കൾ കൈകാര്യം ചെയ്ത് ഒരു പ്രവചനം ഔട്ട്‌പുട്ട് ചെയ്യുന്നു; അത് ഏതെങ്കിലും ടെക്‌സ്‌റ്റ് ആകാം.",
+			explain: "മോഡലിന്റെ പ്രവചനം നേരിട്ട് ടെക്‌സ്‌റ്റ് ആകാൻ കഴിയില്ല. പ്രവചനത്തെ തിരികെ ടെക്‌സ്‌റ്റാക്കി മാറ്റാൻ ടോക്കണൈസർ ഉപയോഗിക്കേണ്ടതുണ്ട്!"
+		},
+		{
+			text: "ടോക്കണൈസർ ടെക്‌സ്‌റ്റ് കൈകാര്യം ചെയ്ത് ID-കൾ റിട്ടേൺ ചെയ്യുന്നു. മോഡൽ ഈ ID-കൾ കൈകാര്യം ചെയ്ത് ഒരു പ്രവചനം ഔട്ട്‌പുട്ട് ചെയ്യുന്നു. തുടർന്ന് ഈ പ്രവചനങ്ങളെ തിരികെ ടെക്‌സ്‌റ്റാക്കി മാറ്റാൻ ടോക്കണൈസർ ഒരിക്കൽക്കൂടി ഉപയോഗിക്കാം.",
+			explain: "ടോക്കണൈസ് ചെയ്യാനും ഡീ-ടോക്കണൈസ് ചെയ്യാനും ടോക്കണൈസർ ഉപയോഗിക്കാം.",
+            correct: true
+		}
+	]}
+/>
+
+### 2. അടിസ്ഥാന Transformer മോഡൽ ഔട്ട്‌പുട്ട് ചെയ്യുന്ന ടെൻസറിന് എത്ര ഡൈമൻഷനുകളുണ്ട്, അവ ഏതൊക്കെയാണ്?
+
+<Question
+	choices={[
+		{
+			text: "2: സീക്വൻസ് ലെങ്ത്തും ബാച്ച് സൈസും",
+			explain: "തെറ്റ്! മോഡൽ ഔട്ട്‌പുട്ട് ചെയ്യുന്ന ടെൻസറിന് ഒരു മൂന്നാം ഡൈമൻഷനുണ്ട്: ഹിഡൻ സൈസ്."
+		},
+		{
+			text: "2: സീക്വൻസ് ലെങ്ത്തും ഹിഡൻ സൈസും",
+			explain: "തെറ്റ്! എല്ലാ Transformer മോഡലുകളും ബാച്ചുകളാണ് കൈകാര്യം ചെയ്യുന്നത്, ഒരൊറ്റ സീക്വൻസ് ആണെങ്കിൽ പോലും; അപ്പോൾ ബാച്ച് സൈസ് 1 ആയിരിക്കും!"
+		},
+		{
+			text: "3: സീക്വൻസ് ലെങ്ത്, ബാച്ച് സൈസ്, ഹിഡൻ സൈസ്",
+			explain: "നന്നായി!",
+            correct: true
+		}
+	]}
+/>
+
+### 3. താഴെ പറയുന്നവയിൽ ഏതാണ് സബ്‌വേഡ് ടോക്കണൈസേഷന്റെ (subword tokenization) ഒരു ഉദാഹരണം?
+
+<Question
+	choices={[
+		{
+			text: "WordPiece",
+			explain: "അതെ, അത് സബ്‌വേഡ് ടോക്കണൈസേഷന്റെ ഒരു ഉദാഹരണമാണ്!",
+            correct: true
+		},
+		{
+			text: "ക്യാരക്‌ടർ-അധിഷ്ഠിത ടോക്കണൈസേഷൻ (Character-based tokenization)",
+			explain: "ക്യാരക്‌ടർ-അധിഷ്ഠിത ടോക്കണൈസേഷൻ സബ്‌വേഡ് ടോക്കണൈസേഷന്റെ ഒരു തരമല്ല."
+		},
+		{
+			text: "വൈറ്റ്‌സ്‌പേസും ചിഹ്നങ്ങളും (punctuation) അടിസ്ഥാനമാക്കി വിഭജിക്കുന്നത്",
+			explain: "അത് ഒരു വേഡ്-അധിഷ്ഠിത (word-based) ടോക്കണൈസേഷൻ രീതിയാണ്!"
+		},
+		{
+			text: "BPE",
+			explain: "അതെ, അത് സബ്‌വേഡ് ടോക്കണൈസേഷന്റെ ഒരു ഉദാഹരണമാണ്!",
+            correct: true
+        },
+		{
+			text: "Unigram",
+			explain: "അതെ, അത് സബ്‌വേഡ് ടോക്കണൈസേഷന്റെ ഒരു ഉദാഹരണമാണ്!",
+            correct: true
+        },
+		{
+			text: "ഇവയൊന്നുമല്ല",
+			explain: "തെറ്റ്!"
+        }
+	]}
+/>
+
+### 4. എന്താണ് ഒരു മോഡൽ ഹെഡ് (model head)?
+
+<Question
+	choices={[
+		{
+			text: "ടെൻസറുകളെ അവയുടെ ശരിയായ ലെയറുകളിലേക്ക് തിരിച്ചുവിടുന്ന, അടിസ്ഥാന Transformer നെറ്റ്‌വർക്കിന്റെ ഒരു ഘടകം",
+			explain: "അങ്ങനെയൊരു ഘടകമില്ല."
+		},
+		{
+			text: "സെൽഫ്-അറ്റൻഷൻ മെക്കാനിസം എന്നും അറിയപ്പെടുന്ന ഇത്, സീക്വൻസിലെ മറ്റ് ടോക്കണുകൾക്ക് അനുസരിച്ച് ഒരു ടോക്കണിന്റെ പ്രതിനിധാനം (representation) ക്രമീകരിക്കുന്നു",
+			explain: "സെൽഫ്-അറ്റൻഷൻ ലെയറിൽ അറ്റൻഷൻ \"ഹെഡുകൾ\" ഉണ്ട് എന്നത് ശരിയാണ്, എന്നാൽ അവ അഡാപ്‌റ്റേഷൻ ഹെഡുകളല്ല."
+		},
+		{
+			text: "Transformer-ന്റെ പ്രവചനങ്ങളെ ഒരു ടാസ്‌ക്-നിർദ്ദിഷ്ട ഔട്ട്‌പുട്ടാക്കി മാറ്റാനുള്ള, സാധാരണയായി ഒന്നോ ഏതാനുമോ ലെയറുകൾ ചേർന്ന, ഒരു അധിക ഘടകം",
+			explain: "ശരിയാണ്. ലളിതമായി ഹെഡുകൾ എന്നും അറിയപ്പെടുന്ന അഡാപ്‌റ്റേഷൻ ഹെഡുകൾ വിവിധ രൂപങ്ങളിൽ വരുന്നു: ലാംഗ്വേജ് മോഡലിംഗ് ഹെഡുകൾ, ചോദ്യോത്തര (question answering) ഹെഡുകൾ, സീക്വൻസ് ക്ലാസിഫിക്കേഷൻ ഹെഡുകൾ... ",
+			correct: true
+		} 
+	]}
+/>
+
+### 5. എന്താണ് ഒരു AutoModel?
+
+<Question
+	choices={[
+		{
+			text: "നിങ്ങളുടെ ഡേറ്റയിൽ സ്വയമേവ ട്രെയിൻ ചെയ്യുന്ന ഒരു മോഡൽ",
+			explain: "ഞങ്ങളുടെ <a href='https://huggingface.co/autotrain'>AutoTrain</a> ഉൽപ്പന്നവുമായി നിങ്ങൾ ഇതിനെ തെറ്റിദ്ധരിക്കുന്നുണ്ടോ?"
+		},
+		{
+			text: "ചെക്ക്‌പോയിന്റിനെ അടിസ്ഥാനമാക്കി ശരിയായ ആർക്കിടെക്ചർ റിട്ടേൺ ചെയ്യുന്ന ഒരു ഒബ്‌ജക്റ്റ്",
+			explain: "കൃത്യമായി: ശരിയായ ആർക്കിടെക്ചർ റിട്ടേൺ ചെയ്യാൻ, ഏത് ചെക്ക്‌പോയിന്റിൽ നിന്ന് ഇനിഷ്യലൈസ് ചെയ്യണം എന്ന് മാത്രം അറിഞ്ഞാൽ <code>AutoModel</code>-ന് മതി.",
+			correct: true
+		},
+		{
+			text: "ശരിയായ വെയ്‌റ്റുകൾ ലോഡ് ചെയ്യാൻ, ഇൻപുട്ടുകളിൽ ഉപയോഗിച്ചിരിക്കുന്ന ഭാഷ സ്വയമേവ കണ്ടെത്തുന്ന ഒരു മോഡൽ",
+			explain: "ചില ചെക്ക്‌പോയിന്റുകൾക്കും മോഡലുകൾക്കും ഒന്നിലധികം ഭാഷകൾ കൈകാര്യം ചെയ്യാൻ കഴിയുമെങ്കിലും, ഭാഷയ്ക്ക് അനുസരിച്ച് സ്വയമേവ ചെക്ക്‌പോയിന്റ് തിരഞ്ഞെടുക്കാനുള്ള ബിൽറ്റ്-ഇൻ ടൂളുകളൊന്നുമില്ല. നിങ്ങളുടെ ടാസ്‌കിന് ഏറ്റവും അനുയോജ്യമായ ചെക്ക്‌പോയിന്റ് കണ്ടെത്താൻ <a href='https://huggingface.co/models'>Model Hub</a>-ലേക്ക് പോകുക!"
+		} 
+	]}
+/>
+
+### 6. വ്യത്യസ്ത നീളമുള്ള സീക്വൻസുകൾ ഒരുമിച്ച് ബാച്ച് ചെയ്യുമ്പോൾ അറിഞ്ഞിരിക്കേണ്ട വിദ്യകൾ ഏതൊക്കെയാണ്?
+
+<Question
+	choices={[
+		{
+			text: "വെട്ടിച്ചുരുക്കൽ (Truncating)",
+			explain: "അതെ, സീക്വൻസുകളെ ഒരു ചതുരാകൃതിയിൽ ഒതുങ്ങുന്ന വിധത്തിൽ ഒരേ നീളത്തിലാക്കാനുള്ള ഒരു ശരിയായ മാർഗ്ഗമാണ് വെട്ടിച്ചുരുക്കൽ (truncation). പക്ഷേ, അത് മാത്രമാണോ ഉള്ളത്?",
+			correct: true
+		},
+		{
+			text: "ടെൻസറുകൾ റിട്ടേൺ ചെയ്യൽ (Returning tensors)",
+			explain: "മറ്റ് വിദ്യകൾ ചതുരാകൃതിയിലുള്ള ടെൻസറുകൾ റിട്ടേൺ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുമെങ്കിലും, സീക്വൻസുകൾ ഒരുമിച്ച് ബാച്ച് ചെയ്യുമ്പോൾ ടെൻസറുകൾ റിട്ടേൺ ചെയ്യുന്നത് സഹായകമല്ല."
+		},
+		{
+			text: "പാഡിംഗ് (Padding)",
+			explain: "അതെ, സീക്വൻസുകളെ ഒരു ചതുരാകൃതിയിൽ ഒതുങ്ങുന്ന വിധത്തിൽ ഒരേ നീളത്തിലാക്കാനുള്ള ഒരു ശരിയായ മാർഗ്ഗമാണ് പാഡിംഗ്. പക്ഷേ, അത് മാത്രമാണോ ഉള്ളത്?",
+			correct: true
+		}, 
+		{
+			text: "അറ്റൻഷൻ മാസ്‌കിംഗ് (Attention masking)",
+			explain: "തീർച്ചയായും! വ്യത്യസ്ത നീളമുള്ള സീക്വൻസുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ അറ്റൻഷൻ മാസ്‌കുകൾക്ക് പരമപ്രധാനമായ സ്ഥാനമുണ്ട്. എന്നാൽ, അറിഞ്ഞിരിക്കേണ്ട ഒരേയൊരു വിദ്യ ഇതല്ല.",
+			correct: true
+		} 
+	]}
+/>
+
+### 7. ഒരു സീക്വൻസ് ക്ലാസിഫിക്കേഷൻ മോഡൽ ഔട്ട്‌പുട്ട് ചെയ്യുന്ന ലോജിറ്റ്‌സിൽ ഒരു SoftMax ഫംഗ്‌ഷൻ പ്രയോഗിക്കുന്നതിന്റെ ഉദ്ദേശ്യം എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "ലോജിറ്റ്‌സിനെ കൂടുതൽ വിശ്വസനീയമാക്കാൻ ഇത് അവയെ മൃദുവാക്കുന്നു.",
+			explain: "അല്ല, SoftMax ഫംഗ്‌ഷൻ ഫലങ്ങളുടെ വിശ്വാസ്യതയെ ബാധിക്കുന്നില്ല."
+		},
+		{
+			text: "മനസ്സിലാക്കാവുന്ന രീതിയിലാക്കാൻ ഇത് അവയ്ക്ക് ഒരു താഴ്ന്ന പരിധിയും ഉയർന്ന പരിധിയും നൽകുന്നു.",
+			explain: "ഫലമായി ലഭിക്കുന്ന മൂല്യങ്ങൾ 0-നും 1-നും ഇടയിലായിരിക്കും. എന്നാൽ, നമ്മൾ SoftMax ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നതിന്റെ ഒരേയൊരു കാരണം അതല്ല.",
+            correct: true
+		},
+		{
+			text: "അപ്പോൾ ഔട്ട്‌പുട്ടിന്റെ ആകെത്തുക 1 ആയിരിക്കും; ഇത് ഒരു പ്രോബബിലിസ്‌റ്റിക് വ്യാഖ്യാനം സാധ്യമാക്കുന്നു.",
+			explain: "ശരിയാണ്! എന്നാൽ, നമ്മൾ SoftMax ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നതിന്റെ ഒരേയൊരു കാരണം അതല്ല.",
+            correct: true
+		}
+	]}
+/>
+
+### 8. ടോക്കണൈസർ API-യുടെ ഭൂരിഭാഗവും ഏത് മെത്തേഡിനെ കേന്ദ്രീകരിച്ചാണ്?
+
+<Question
+	choices={[
+		{
+			text: "<code>encode</code>, കാരണം ഇതിന് ടെക്‌സ്‌റ്റിനെ ID-കളായും ID-കളെ പ്രവചനങ്ങളായും എൻകോഡ് ചെയ്യാൻ കഴിയും",
+			explain: "തെറ്റ്! ടോക്കണൈസറുകളിൽ <code>encode</code> മെത്തേഡ് ഉണ്ടെങ്കിലും, മോഡലുകളിൽ അതില്ല."
+		},
+		{
+			text: "ടോക്കണൈസർ ഒബ്‌ജക്റ്റിനെ നേരിട്ട് വിളിക്കുന്നത് (call ചെയ്യുന്നത്).",
+			explain: "കൃത്യമായി! ടോക്കണൈസറിന്റെ <code>__call__</code> മെത്തേഡ്, ഏറെക്കുറെ എന്തും കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന വളരെ ശക്തമായ ഒരു മെത്തേഡാണ്. ഒരു മോഡലിൽ നിന്ന് പ്രവചനങ്ങൾ നേടാൻ ഉപയോഗിക്കുന്ന മെത്തേഡും ഇതുതന്നെയാണ്.",
+			correct: true
+		},
+		{
+			text: "<code>pad</code>",
+			explain: "തെറ്റ്! പാഡിംഗ് വളരെ ഉപകാരപ്രദമാണ്, എന്നാൽ അത് ടോക്കണൈസർ API-യുടെ ഒരു ഭാഗം മാത്രമാണ്."
+		},
+		{
+			text: "<code>tokenize</code>",
+			explain: "<code>tokenize</code> മെത്തേഡ് ഏറ്റവും ഉപകാരപ്രദമായ മെത്തേഡുകളിലൊന്നാണെന്ന് പറയാം, എന്നാൽ അത് ടോക്കണൈസർ API-യുടെ കാതലല്ല."
+		}
+	]}
+/>
+
+### 9. ഈ കോഡ് സാമ്പിളിൽ `result` എന്ന വേരിയബിളിൽ എന്താണ് അടങ്ങിയിരിക്കുന്നത്?
+
+```py
+from transformers import AutoTokenizer
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+result = tokenizer.tokenize("Hello!")
+```
+
+<Question
+	choices={[
+		{
+			text: "സ്‌ട്രിംഗുകളുടെ ഒരു ലിസ്‌റ്റ്; ഓരോ സ്‌ട്രിംഗും ഒരു ടോക്കൺ ആണ്",
+			explain: "തീർച്ചയായും! ഇതിനെ ID-കളാക്കി മാറ്റി ഒരു മോഡലിലേക്ക് അയയ്ക്കുക!",
+            correct: true
+		},
+		{
+			text: "ID-കളുടെ ഒരു ലിസ്‌റ്റ്",
+			explain: "തെറ്റാണ്; അതിനുള്ളതാണ് <code>__call__</code> അല്ലെങ്കിൽ <code>convert_tokens_to_ids</code> മെത്തേഡ്!"
+		},
+		{
+			text: "എല്ലാ ടോക്കണുകളും അടങ്ങിയ ഒരു സ്‌ട്രിംഗ്",
+			explain: "ഇത് അത്ര ഉചിതമാകില്ല, കാരണം സ്‌ട്രിംഗിനെ ഒന്നിലധികം ടോക്കണുകളായി വിഭജിക്കുക എന്നതാണ് ലക്ഷ്യം."
+		}
+	]}
+/>
+
+### 10. താഴെ കൊടുത്ത കോഡിൽ എന്തെങ്കിലും തെറ്റുണ്ടോ?
+
+```py
+from transformers import AutoTokenizer, AutoModel
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+model = AutoModel.from_pretrained("gpt2")
+
+encoded = tokenizer("Hey!", return_tensors="pt")
+result = model(**encoded)
+```
+
+<Question
+	choices={[
+		{
+			text: "ഇല്ല, ഇത് ശരിയാണെന്ന് തോന്നുന്നു.",
+			explain: "നിർഭാഗ്യവശാൽ, മറ്റൊരു ചെക്ക്‌പോയിന്റിനൊപ്പം ട്രെയിൻ ചെയ്ത ഒരു ടോക്കണൈസറുമായി ഒരു മോഡലിനെ കൂട്ടിയിണക്കുന്നത് അപൂർവ്വമായേ നല്ല ആശയമാകൂ. ഈ ടോക്കണൈസറിന്റെ ഔട്ട്‌പുട്ട് മനസ്സിലാക്കാൻ മോഡലിനെ ട്രെയിൻ ചെയ്തിട്ടില്ല, അതിനാൽ മോഡലിന്റെ ഔട്ട്‌പുട്ടിന് (അത് റൺ ചെയ്യുകയാണെങ്കിൽത്തന്നെ!) ഒരു അർത്ഥവുമുണ്ടാകില്ല."
+		},
+		{
+			text: "ടോക്കണൈസറും മോഡലും എപ്പോഴും ഒരേ ചെക്ക്‌പോയിന്റിൽ നിന്നുള്ളതായിരിക്കണം.",
+			explain: "ശരിയാണ്!",
+            correct: true
+		},
+		{
+			text: "ഓരോ ഇൻപുട്ടും ഒരു ബാച്ച് ആയതിനാൽ, ടോക്കണൈസർ ഉപയോഗിച്ച് പാഡ് ചെയ്യുന്നതും വെട്ടിച്ചുരുക്കുന്നതും (truncate) നല്ല രീതിയാണ്.",
+			explain: "ഓരോ മോഡൽ ഇൻപുട്ടും ഒരു ബാച്ച് ആയിരിക്കണം എന്നത് ശരിയാണ്. എന്നാൽ, ഇവിടെ ഒരൊറ്റ സീക്വൻസ് മാത്രമേ ഉള്ളതിനാൽ ഇതിനെ വെട്ടിച്ചുരുക്കുന്നതോ പാഡ് ചെയ്യുന്നതോ അർത്ഥവത്താകണമെന്നില്ല; അവ വാക്യങ്ങളുടെ ഒരു ലിസ്‌റ്റ് ഒരുമിച്ച് ബാച്ച് ചെയ്യാനുള്ള വിദ്യകളാണ്."
+		}
+	]}
+/>

From 8f142d84faaa86879e13ae6a36c9a7d09103ebe8 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 12:59:12 +0530
Subject: [PATCH 31/44] Add Malayalam translation for chapter3/1.mdx

---
 chapters/ml/chapter3/1.mdx | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 chapters/ml/chapter3/1.mdx

diff --git a/chapters/ml/chapter3/1.mdx b/chapters/ml/chapter3/1.mdx
new file mode 100644
index 000000000..9237a9fd3
--- /dev/null
+++ b/chapters/ml/chapter3/1.mdx
@@ -0,0 +1,35 @@
+<FrameworkSwitchCourse {fw} />
+
+# ആമുഖം[[introduction]]
+
+<CourseFloatingBanner
+    chapter={3}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+[അധ്യായം 2](/course/chapter2)-ൽ, പ്രവചനങ്ങൾ (predictions) നടത്താൻ ടോക്കണൈസറുകളും പ്രീട്രെയിൻഡ് മോഡലുകളും എങ്ങനെ ഉപയോഗിക്കാം എന്ന് നമ്മൾ പരിശോധിച്ചു. എന്നാൽ ഒരു നിശ്ചിത ടാസ്‌ക്ക് പരിഹരിക്കാൻ ഒരു പ്രീട്രെയിൻഡ് മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യണമെങ്കിലോ? അതാണ് ഈ അധ്യായത്തിന്റെ വിഷയം! നിങ്ങൾ പഠിക്കുന്നത്:
+
+* ഏറ്റവും പുതിയ 🤗 Datasets സവിശേഷതകൾ ഉപയോഗിച്ച് Hub-ൽ നിന്ന് ഒരു വലിയ ഡേറ്റാസെറ്റ് എങ്ങനെ തയ്യാറാക്കാം
+* ആധുനിക മികച്ച രീതികൾ (best practices) പിന്തുടർന്ന് ഒരു മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ ഹൈ-ലെവൽ `Trainer` API എങ്ങനെ ഉപയോഗിക്കാം
+* ഒപ്‌റ്റിമൈസേഷൻ ടെക്‌നിക്കുകൾ ഉൾപ്പെടുത്തി ഒരു കസ്‌റ്റം ട്രെയിനിംഗ് ലൂപ്പ് എങ്ങനെ നടപ്പിലാക്കാം
+* ഏത് സെറ്റപ്പിലും ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ് എളുപ്പത്തിൽ റൺ ചെയ്യാൻ 🤗 Accelerate ലൈബ്രറി എങ്ങനെ പ്രയോജനപ്പെടുത്താം
+* പരമാവധി പ്രകടനത്തിനായി ഇന്നത്തെ ഫൈൻ-ട്യൂണിംഗ് മികച്ച രീതികൾ എങ്ങനെ പ്രയോഗിക്കാം
+
+> [!TIP]
+> 📚 **അത്യാവശ്യ വിഭവങ്ങൾ**: തുടങ്ങുന്നതിന് മുമ്പ്, ഡേറ്റാ പ്രോസസ്സിംഗിനെക്കുറിച്ചുള്ള [🤗 Datasets ഡോക്യുമെന്റേഷൻ](https://huggingface.co/docs/datasets/) ഒന്ന് നോക്കുന്നത് നല്ലതായിരിക്കും.
+
+🤗 Transformers ലൈബ്രറിക്ക് പുറമെയുള്ള ചില Hugging Face ലൈബ്രറികളിലേക്കുള്ള ഒരു ആമുഖമായും ഈ അധ്യായം പ്രവർത്തിക്കും! 🤗 Datasets, 🤗 Tokenizers, 🤗 Accelerate, 🤗 Evaluate തുടങ്ങിയ ലൈബ്രറികൾ മോഡലുകളെ കൂടുതൽ കാര്യക്ഷമമായും ഫലപ്രദമായും ട്രെയിൻ ചെയ്യാൻ നിങ്ങളെ എങ്ങനെ സഹായിക്കുന്നു എന്ന് നമ്മൾ കാണും.
+
+ഈ അധ്യായത്തിലെ പ്രധാന ഭാഗങ്ങൾ ഓരോന്നും വ്യത്യസ്തമായ എന്തെങ്കിലും നിങ്ങളെ പഠിപ്പിക്കും:
+- **ഭാഗം 2**: ആധുനിക ഡേറ്റാ പ്രീപ്രോസസ്സിംഗ് ടെക്‌നിക്കുകളും കാര്യക്ഷമമായ ഡേറ്റാസെറ്റ് കൈകാര്യവും പഠിക്കുക
+- **ഭാഗം 3**: ശക്തമായ Trainer API-യും അതിന്റെ ഏറ്റവും പുതിയ എല്ലാ സവിശേഷതകളും സ്വായത്തമാക്കുക
+- **ഭാഗം 4**: ട്രെയിനിംഗ് ലൂപ്പുകൾ ആദ്യം മുതൽ നടപ്പിലാക്കുകയും Accelerate ഉപയോഗിച്ചുള്ള ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ് മനസ്സിലാക്കുകയും ചെയ്യുക
+
+ഈ അധ്യായത്തിന്റെ അവസാനത്തോടെ, ഈ മേഖലയിലെ ഏറ്റവും പുതിയ മികച്ച രീതികൾ പ്രയോഗിച്ചുകൊണ്ട്, ഹൈ-ലെവൽ API-കളും കസ്‌റ്റം ട്രെയിനിംഗ് ലൂപ്പുകളും ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം ഡേറ്റാസെറ്റുകളിൽ മോഡലുകൾ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ നിങ്ങൾക്ക് കഴിയും.
+
+> [!TIP]
+> 🎯 **നിങ്ങൾ എന്ത് നിർമ്മിക്കും**: ഈ അധ്യായത്തിന്റെ അവസാനത്തോടെ, ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷനായി ഒരു BERT മോഡൽ നിങ്ങൾ ഫൈൻ-ട്യൂൺ ചെയ്തിട്ടുണ്ടാകും; കൂടാതെ ഈ ടെക്‌നിക്കുകൾ നിങ്ങളുടെ സ്വന്തം ഡേറ്റാസെറ്റുകളിലേക്കും ടാസ്‌ക്കുകളിലേക്കും എങ്ങനെ അനുരൂപപ്പെടുത്താം എന്നും നിങ്ങൾക്ക് മനസ്സിലാകും.
+
+ആധുനിക ഡീപ് ലേണിംഗ് ഗവേഷണത്തിലും പ്രൊഡക്‌ഷനിലും സ്റ്റാൻഡേർഡ് ഫ്രെയിംവർക്കായി മാറിയതിനാൽ, ഈ അധ്യായം **PyTorch**-ൽ മാത്രമായി ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. Hugging Face ഇക്കോസിസ്റ്റത്തിലെ ഏറ്റവും പുതിയ API-കളും മികച്ച രീതികളും നമ്മൾ ഉപയോഗിക്കും.
+
+നിങ്ങൾ ട്രെയിൻ ചെയ്ത മോഡലുകൾ Hugging Face Hub-ലേക്ക് അപ്‌ലോഡ് ചെയ്യാൻ, നിങ്ങൾക്ക് ഒരു Hugging Face അക്കൗണ്ട് ആവശ്യമാണ്: [ഒരു അക്കൗണ്ട് ഉണ്ടാക്കുക](https://huggingface.co/join)

From 34a790cd00dcd878cbe1e05958753ad7660ac612 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 13:23:18 +0530
Subject: [PATCH 32/44] Add Malayalam translation for chapter3/2.mdx

---
 chapters/ml/chapter3/2.mdx | 419 +++++++++++++++++++++++++++++++++++++
 1 file changed, 419 insertions(+)
 create mode 100644 chapters/ml/chapter3/2.mdx

diff --git a/chapters/ml/chapter3/2.mdx b/chapters/ml/chapter3/2.mdx
new file mode 100644
index 000000000..0271f526b
--- /dev/null
+++ b/chapters/ml/chapter3/2.mdx
@@ -0,0 +1,419 @@
+# ഡേറ്റ പ്രോസസ്സ് ചെയ്യുന്നു[[processing-the-data]]
+
+<CourseFloatingBanner chapter={3}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter3/section2.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter3/section2.ipynb"},
+]} />
+
+[മുൻ അധ്യായത്തിലെ](/course/chapter2) ഉദാഹരണം തുടർന്നുകൊണ്ട്, ഒരു ബാച്ചിൽ ഒരു സീക്വൻസ് ക്ലാസിഫയർ നമ്മൾ എങ്ങനെ ട്രെയിൻ ചെയ്യും എന്ന് ഇതാ:
+
+```python
+import torch
+from torch.optim import AdamW
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+# Same as before
+checkpoint = "bert-base-uncased"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+sequences = [
+    "I've been waiting for a HuggingFace course my whole life.",
+    "This course is amazing!",
+]
+batch = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt")
+
+# This is new
+batch["labels"] = torch.tensor([1, 1])
+
+optimizer = AdamW(model.parameters())
+loss = model(**batch).loss
+loss.backward()
+optimizer.step()
+```
+
+തീർച്ചയായും, വെറും രണ്ട് വാക്യങ്ങളിൽ മോഡൽ ട്രെയിൻ ചെയ്തതുകൊണ്ട് വളരെ മികച്ച ഫലങ്ങൾ ലഭിക്കാൻ പോകുന്നില്ല. മികച്ച ഫലങ്ങൾ ലഭിക്കാൻ, നിങ്ങൾ ഒരു വലിയ ഡേറ്റാസെറ്റ് തയ്യാറാക്കേണ്ടതുണ്ട്.
+
+ഈ ഭാഗത്തിൽ, William B. Dolan-ഉം Chris Brockett-ഉം ചേർന്ന് ഒരു [പ്രബന്ധത്തിൽ](https://www.aclweb.org/anthology/I05-5002.pdf) അവതരിപ്പിച്ച MRPC (Microsoft Research Paraphrase Corpus) ഡേറ്റാസെറ്റ് നമ്മൾ ഉദാഹരണമായി ഉപയോഗിക്കും. 5,801 വാക്യജോഡികൾ അടങ്ങിയ ഈ ഡേറ്റാസെറ്റിൽ, ഓരോ ജോഡിയും പാരാഫ്രേസുകളാണോ അല്ലയോ (അതായത്, രണ്ട് വാക്യങ്ങളും ഒരേ അർത്ഥമാണോ നൽകുന്നത്) എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ലേബലുമുണ്ട്. ചെറിയ ഒരു ഡേറ്റാസെറ്റായതിനാൽ അതിൽ ട്രെയിനിംഗ് പരീക്ഷിക്കാൻ എളുപ്പമാണ് എന്നതുകൊണ്ടാണ് ഈ അധ്യായത്തിനായി നമ്മൾ ഇത് തിരഞ്ഞെടുത്തത്.
+
+### Hub-ൽ നിന്ന് ഒരു ഡേറ്റാസെറ്റ് ലോഡ് ചെയ്യുന്നു[[loading-a-dataset-from-the-hub]]
+
+<Youtube id="_BZearw7f0w"/>
+
+Hub-ൽ മോഡലുകൾ മാത്രമല്ല ഉള്ളത്; വിവിധ ഭാഷകളിലുള്ള ഒട്ടേറെ ഡേറ്റാസെറ്റുകളും അതിലുണ്ട്. നിങ്ങൾക്ക് ഡേറ്റാസെറ്റുകൾ [ഇവിടെ](https://huggingface.co/datasets) ബ്രൗസ് ചെയ്യാം; ഈ ഭാഗം പൂർത്തിയാക്കിയ ശേഷം ഒരു പുതിയ ഡേറ്റാസെറ്റ് ലോഡ് ചെയ്ത് പ്രോസസ്സ് ചെയ്യാൻ ശ്രമിക്കണമെന്ന് ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു (പൊതുവായ ഡോക്യുമെന്റേഷൻ [ഇവിടെ](https://huggingface.co/docs/datasets/loading) കാണുക). എന്നാൽ ഇപ്പോൾ, MRPC ഡേറ്റാസെറ്റിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാം! [GLUE ബെഞ്ച്‌മാർക്ക്](https://gluebenchmark.com/) രൂപപ്പെടുത്തുന്ന 10 ഡേറ്റാസെറ്റുകളിൽ ഒന്നാണിത്; 10 വ്യത്യസ്ത ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷൻ ടാസ്‌ക്കുകളിൽ ML മോഡലുകളുടെ പ്രകടനം അളക്കാൻ ഉപയോഗിക്കുന്ന ഒരു അക്കാദമിക് ബെഞ്ച്‌മാർക്കാണ് GLUE.
+
+Hub-ലുള്ള ഒരു ഡേറ്റാസെറ്റ് ഡൗൺലോഡ് ചെയ്ത് കാഷ് ചെയ്യാൻ 🤗 Datasets ലൈബ്രറി വളരെ ലളിതമായ ഒരു കമാൻഡ് നൽകുന്നു. MRPC ഡേറ്റാസെറ്റ് നമുക്ക് ഇങ്ങനെ ഡൗൺലോഡ് ചെയ്യാം:
+
+> [!TIP]
+> 💡 **അധിക വിഭവങ്ങൾ**: കൂടുതൽ ഡേറ്റാസെറ്റ് ലോഡിംഗ് രീതികൾക്കും ഉദാഹരണങ്ങൾക്കും, [🤗 Datasets ഡോക്യുമെന്റേഷൻ](https://huggingface.co/docs/datasets/) പരിശോധിക്കുക. 
+
+```py
+from datasets import load_dataset
+
+raw_datasets = load_dataset("glue", "mrpc")
+raw_datasets
+```
+
+```python out
+DatasetDict({
+    train: Dataset({
+        features: ['sentence1', 'sentence2', 'label', 'idx'],
+        num_rows: 3668
+    })
+    validation: Dataset({
+        features: ['sentence1', 'sentence2', 'label', 'idx'],
+        num_rows: 408
+    })
+    test: Dataset({
+        features: ['sentence1', 'sentence2', 'label', 'idx'],
+        num_rows: 1725
+    })
+})
+```
+
+നിങ്ങൾക്ക് കാണാൻ കഴിയുന്നതുപോലെ, ട്രെയിനിംഗ് സെറ്റ്, വാലിഡേഷൻ സെറ്റ്, ടെസ്‌റ്റ് സെറ്റ് എന്നിവ അടങ്ങിയ ഒരു `DatasetDict` ഒബ്‌ജക്റ്റാണ് നമുക്ക് ലഭിക്കുന്നത്. ഇവയിൽ ഓരോന്നിലും പല കോളങ്ങളും (`sentence1`, `sentence2`, `label`, `idx`) വ്യത്യസ്ത എണ്ണം വരികളും ഉണ്ട്; വരികളുടെ എണ്ണം ഓരോ സെറ്റിലെയും ഘടകങ്ങളുടെ എണ്ണമാണ് (അതായത്, ട്രെയിനിംഗ് സെറ്റിൽ 3,668 വാക്യജോഡികളും, വാലിഡേഷൻ സെറ്റിൽ 408-ഉം, ടെസ്‌റ്റ് സെറ്റിൽ 1,725-ഉം ഉണ്ട്).
+
+> [!TIP]
+> ഈ കമാൻഡ് ഡേറ്റാസെറ്റ് ഡൗൺലോഡ് ചെയ്ത് കാഷ് ചെയ്യുന്നു; ഡിഫോൾട്ടായി *~/.cache/huggingface/datasets*-ൽ. `HF_HOME` എൻവയോൺമെന്റ് വേരിയബിൾ സെറ്റ് ചെയ്ത് നിങ്ങളുടെ കാഷ് ഫോൾഡർ ഇഷ്ടാനുസൃതമാക്കാം എന്ന് അധ്യായം 2-ൽ നിന്ന് ഓർക്കുക.
+
+ഒരു ഡിക്‌ഷണറിയിലേതുപോലെ ഇൻഡെക്‌സിംഗ് ഉപയോഗിച്ച്, നമ്മുടെ `raw_datasets` ഒബ്‌ജക്റ്റിലെ ഓരോ വാക്യജോഡിയും നമുക്ക് ആക്‌സസ് ചെയ്യാം:
+
+```py
+raw_train_dataset = raw_datasets["train"]
+raw_train_dataset[0]
+```
+
+```python out
+{'idx': 0,
+ 'label': 1,
+ 'sentence1': 'Amrozi accused his brother , whom he called " the witness " , of deliberately distorting his evidence .',
+ 'sentence2': 'Referring to him as only " the witness " , Amrozi accused his brother of deliberately distorting his evidence .'}
+```
+
+ലേബലുകൾ ഇതിനകം തന്നെ ഇന്റിജറുകളാണ് (integers) എന്ന് നമുക്ക് കാണാം, അതിനാൽ അവിടെ ഒരു പ്രീപ്രോസസ്സിംഗും ചെയ്യേണ്ടതില്ല. ഏത് ഇന്റിജർ ഏത് ലേബലിനെ സൂചിപ്പിക്കുന്നു എന്നറിയാൻ, നമ്മുടെ `raw_train_dataset`-ന്റെ `features` പരിശോധിക്കാം. ഇത് ഓരോ കോളത്തിന്റെയും ടൈപ്പ് നമുക്ക് പറഞ്ഞുതരും:
+
+```py
+raw_train_dataset.features
+```
+
+```python out
+{'sentence1': Value(dtype='string', id=None),
+ 'sentence2': Value(dtype='string', id=None),
+ 'label': ClassLabel(num_classes=2, names=['not_equivalent', 'equivalent'], names_file=None, id=None),
+ 'idx': Value(dtype='int32', id=None)}
+```
+
+അകമേ, `label` എന്നത് `ClassLabel` ടൈപ്പിലുള്ളതാണ്; ഇന്റിജറുകളെ ലേബൽ പേരുകളുമായി ബന്ധിപ്പിക്കുന്ന മാപ്പിംഗ് *names* ഫോൾഡറിൽ സൂക്ഷിച്ചിരിക്കുന്നു. `0` എന്നത് `not_equivalent`-നെയും `1` എന്നത് `equivalent`-നെയും സൂചിപ്പിക്കുന്നു.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** ട്രെയിനിംഗ് സെറ്റിന്റെ ഘടകം 15-ഉം വാലിഡേഷൻ സെറ്റിന്റെ ഘടകം 87-ഉം നോക്കുക. അവയുടെ ലേബലുകൾ എന്തൊക്കെയാണ്?
+
+### ഒരു ഡേറ്റാസെറ്റ് പ്രീപ്രോസസ്സ് ചെയ്യുന്നു[[preprocessing-a-dataset]]
+
+<Youtube id="0u3ioSwev3s"/>
+
+ഡേറ്റാസെറ്റ് പ്രീപ്രോസസ്സ് ചെയ്യാൻ, ടെക്‌സ്‌റ്റിനെ മോഡലിന് മനസ്സിലാക്കാൻ കഴിയുന്ന സംഖ്യകളാക്കി മാറ്റേണ്ടതുണ്ട്. [മുൻ അധ്യായത്തിൽ](/course/chapter2) നിങ്ങൾ കണ്ടതുപോലെ, ഇത് ഒരു ടോക്കണൈസർ ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്. ടോക്കണൈസറിന് ഒരു വാക്യമോ വാക്യങ്ങളുടെ ഒരു ലിസ്‌റ്റോ നൽകാം, അതിനാൽ ഓരോ ജോഡിയിലെയും എല്ലാ ആദ്യ വാക്യങ്ങളും എല്ലാ രണ്ടാം വാക്യങ്ങളും നമുക്ക് നേരിട്ട് ഇങ്ങനെ ടോക്കണൈസ് ചെയ്യാം:
+
+```py
+from transformers import AutoTokenizer
+
+checkpoint = "bert-base-uncased"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+tokenized_sentences_1 = tokenizer(raw_datasets["train"]["sentence1"])
+tokenized_sentences_2 = tokenizer(raw_datasets["train"]["sentence2"])
+```
+
+> [!TIP]
+> 💡 **ആഴത്തിൽ അറിയാൻ**: കൂടുതൽ വിപുലമായ ടോക്കണൈസേഷൻ ടെക്‌നിക്കുകൾക്കും വ്യത്യസ്ത ടോക്കണൈസറുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാനും, [🤗 Tokenizers ഡോക്യുമെന്റേഷനും](https://huggingface.co/docs/transformers/main/en/tokenizer_summary) [കുക്ക്‌ബുക്കിലെ ടോക്കണൈസേഷൻ ഗൈഡും](https://huggingface.co/learn/cookbook/en/advanced_rag#tokenization-strategies) പരിശോധിക്കുക.
+
+എന്നിരുന്നാലും, രണ്ട് സീക്വൻസുകൾ വെറുതെ മോഡലിന് നൽകി, ആ രണ്ട് വാക്യങ്ങൾ പാരാഫ്രേസുകളാണോ അല്ലയോ എന്ന പ്രവചനം നേടാൻ കഴിയില്ല. രണ്ട് സീക്വൻസുകളെയും ഒരു ജോഡിയായി കൈകാര്യം ചെയ്ത്, അനുയോജ്യമായ പ്രീപ്രോസസ്സിംഗ് പ്രയോഗിക്കേണ്ടതുണ്ട്. ഭാഗ്യവശാൽ, ടോക്കണൈസറിന് ഒരു ജോഡി സീക്വൻസുകൾ സ്വീകരിച്ച്, നമ്മുടെ BERT മോഡൽ പ്രതീക്ഷിക്കുന്ന രീതിയിൽ അത് തയ്യാറാക്കാനും കഴിയും: 
+
+```py
+inputs = tokenizer("This is the first sentence.", "This is the second one.")
+inputs
+```
+
+```python out
+{ 
+  'input_ids': [101, 2023, 2003, 1996, 2034, 6251, 1012, 102, 2023, 2003, 1996, 2117, 2028, 1012, 102],
+  'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
+  'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+}
+```
+
+`input_ids`, `attention_mask` എന്നീ കീകളെക്കുറിച്ച് [അധ്യായം 2](/course/chapter2)-ൽ നമ്മൾ ചർച്ച ചെയ്തു, എന്നാൽ `token_type_ids`-നെക്കുറിച്ച് പറയുന്നത് നമ്മൾ മാറ്റിവെച്ചിരുന്നു. ഈ ഉദാഹരണത്തിൽ, ഇൻപുട്ടിന്റെ ഏത് ഭാഗം ആദ്യ വാക്യമാണെന്നും ഏത് ഭാഗം രണ്ടാം വാക്യമാണെന്നും മോഡലിനോട് പറയുന്നത് ഇതാണ്.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** ട്രെയിനിംഗ് സെറ്റിന്റെ ഘടകം 15 എടുത്ത്, അതിലെ രണ്ട് വാക്യങ്ങളും വെവ്വേറെയായും ഒരു ജോഡിയായും ടോക്കണൈസ് ചെയ്യുക. രണ്ട് ഫലങ്ങൾക്കിടയിലുള്ള വ്യത്യാസം എന്താണ്?
+
+`input_ids`-നുള്ളിലെ ID-കൾ വീണ്ടും വാക്കുകളിലേക്ക് ഡീകോഡ് ചെയ്താൽ:
+
+```py
+tokenizer.convert_ids_to_tokens(inputs["input_ids"])
+```
+
+നമുക്ക് ലഭിക്കുന്നത്:
+
+```python out
+['[CLS]', 'this', 'is', 'the', 'first', 'sentence', '.', '[SEP]', 'this', 'is', 'the', 'second', 'one', '.', '[SEP]']
+```
+
+അതായത്, രണ്ട് വാക്യങ്ങൾ ഉള്ളപ്പോൾ ഇൻപുട്ടുകൾ `[CLS] sentence1 [SEP] sentence2 [SEP]` എന്ന രൂപത്തിലായിരിക്കണം എന്നാണ് മോഡൽ പ്രതീക്ഷിക്കുന്നത് എന്ന് നമ്മൾ കാണുന്നു. ഇതിനെ `token_type_ids`-മായി ചേർത്തുവെച്ചാൽ നമുക്ക് ലഭിക്കുന്നത്:
+
+```python out
+['[CLS]', 'this', 'is', 'the', 'first', 'sentence', '.', '[SEP]', 'this', 'is', 'the', 'second', 'one', '.', '[SEP]']
+[      0,      0,    0,     0,       0,          0,   0,       0,      1,    1,     1,        1,     1,   1,       1]
+```
+
+നിങ്ങൾക്ക് കാണാൻ കഴിയുന്നതുപോലെ, ഇൻപുട്ടിൽ `[CLS] sentence1 [SEP]`-ന് അനുയോജ്യമായ ഭാഗങ്ങൾക്കെല്ലാം ടോക്കൺ ടൈപ്പ് ID `0` ആണ്, അതേസമയം `sentence2 [SEP]`-ന് അനുയോജ്യമായ മറ്റ് ഭാഗങ്ങൾക്കെല്ലാം ടോക്കൺ ടൈപ്പ് ID `1` ആണ്.
+
+മറ്റൊരു ചെക്ക്‌പോയിന്റ് തിരഞ്ഞെടുത്താൽ, നിങ്ങളുടെ ടോക്കണൈസ് ചെയ്ത ഇൻപുട്ടുകളിൽ `token_type_ids` ഉണ്ടാകണമെന്നില്ല എന്നത് ശ്രദ്ധിക്കുക (ഉദാഹരണത്തിന്, ഒരു DistilBERT മോഡൽ ഉപയോഗിച്ചാൽ അവ തിരികെ ലഭിക്കില്ല). മോഡൽ അവയെ പ്രീട്രെയിനിംഗ് സമയത്ത് കണ്ടിട്ടുള്ളതിനാൽ അവ എന്തുചെയ്യണമെന്ന് മോഡലിന് അറിയാമെങ്കിൽ മാത്രമേ അവ തിരികെ ലഭിക്കൂ. 
+
+ഇവിടെ, BERT ടോക്കൺ ടൈപ്പ് ID-കളോടെയാണ് പ്രീട്രെയിൻ ചെയ്തിരിക്കുന്നത്; [അധ്യായം 1](/course/chapter1)-ൽ നമ്മൾ സംസാരിച്ച മാസ്‌ക്ഡ് ലാംഗ്വേജ് മോഡലിംഗ് ലക്ഷ്യത്തിന് പുറമെ, _next sentence prediction_ (അടുത്ത വാക്യ പ്രവചനം) എന്ന ഒരു അധിക ലക്ഷ്യവും ഇതിനുണ്ട്. വാക്യജോഡികൾക്കിടയിലുള്ള ബന്ധം മോഡൽ ചെയ്യുക എന്നതാണ് ഈ ടാസ്‌ക്കിന്റെ ലക്ഷ്യം.
+
+Next sentence prediction-ൽ, മോഡലിന് (റാൻഡമായി മാസ്‌ക് ചെയ്ത ടോക്കണുകളുള്ള) വാക്യജോഡികൾ നൽകുകയും, രണ്ടാം വാക്യം ആദ്യത്തേതിന് തൊട്ടുപിന്നാലെ വരുന്നതാണോ എന്ന് പ്രവചിക്കാൻ ആവശ്യപ്പെടുകയും ചെയ്യുന്നു. ടാസ്‌ക്ക് വളരെ എളുപ്പമാകാതിരിക്കാൻ, പകുതി തവണ ആ വാക്യങ്ങൾ അവ എടുത്ത യഥാർത്ഥ ഡോക്യുമെന്റിൽ ഒന്നിന് പിന്നാലെ ഒന്നായി വരുന്നവയാണ്; മറ്റേ പകുതി തവണ, രണ്ട് വാക്യങ്ങളും രണ്ട് വ്യത്യസ്ത ഡോക്യുമെന്റുകളിൽ നിന്നുള്ളവയാണ്. 
+
+പൊതുവേ, നിങ്ങളുടെ ടോക്കണൈസ് ചെയ്ത ഇൻപുട്ടുകളിൽ `token_type_ids` ഉണ്ടോ ഇല്ലയോ എന്നതിനെക്കുറിച്ച് നിങ്ങൾ വിഷമിക്കേണ്ടതില്ല: ടോക്കണൈസറിനും മോഡലിനും ഒരേ ചെക്ക്‌പോയിന്റ് ഉപയോഗിക്കുന്നിടത്തോളം, തന്റെ മോഡലിന് എന്ത് നൽകണമെന്ന് ടോക്കണൈസറിന് അറിയാവുന്നതിനാൽ എല്ലാം ശരിയായിരിക്കും.
+
+നമ്മുടെ ടോക്കണൈസർ ഒരു വാക്യജോഡിയെ എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്ന് കണ്ടുകഴിഞ്ഞ സ്ഥിതിക്ക്, നമ്മുടെ മുഴുവൻ ഡേറ്റാസെറ്റും ടോക്കണൈസ് ചെയ്യാൻ ഇത് ഉപയോഗിക്കാം: [മുൻ അധ്യായത്തിലേതുപോലെ](/course/chapter2), ആദ്യ വാക്യങ്ങളുടെ ലിസ്‌റ്റും പിന്നെ രണ്ടാം വാക്യങ്ങളുടെ ലിസ്‌റ്റും നൽകിക്കൊണ്ട് ടോക്കണൈസറിന് വാക്യജോഡികളുടെ ഒരു ലിസ്‌റ്റ് നൽകാം. [അധ്യായം 2](/course/chapter2)-ൽ നമ്മൾ കണ്ട പാഡിംഗ്, ട്രങ്കേഷൻ ഓപ്‌ഷനുകളുമായും ഇത് പൊരുത്തപ്പെടുന്നു. അതിനാൽ, ട്രെയിനിംഗ് ഡേറ്റാസെറ്റ് പ്രീപ്രോസസ്സ് ചെയ്യാനുള്ള ഒരു വഴി ഇതാണ്:
+
+```py
+tokenized_dataset = tokenizer(
+    raw_datasets["train"]["sentence1"],
+    raw_datasets["train"]["sentence2"],
+    padding=True,
+    truncation=True,
+)
+```
+
+ഇത് നന്നായി പ്രവർത്തിക്കും, എന്നാൽ ഒരു ഡിക്‌ഷണറി (നമ്മുടെ കീകളായ `input_ids`, `attention_mask`, `token_type_ids` എന്നിവയും, ലിസ്‌റ്റുകളുടെ ലിസ്‌റ്റുകളായ മൂല്യങ്ങളും ഉള്ളത്) തിരികെ നൽകുന്നു എന്ന പോരായ്മ ഇതിനുണ്ട്. കൂടാതെ, ടോക്കണൈസേഷൻ സമയത്ത് നിങ്ങളുടെ മുഴുവൻ ഡേറ്റാസെറ്റും സൂക്ഷിക്കാൻ മതിയായ RAM ഉണ്ടെങ്കിൽ മാത്രമേ ഇത് പ്രവർത്തിക്കൂ (അതേസമയം 🤗 Datasets ലൈബ്രറിയിലെ ഡേറ്റാസെറ്റുകൾ ഡിസ്‌കിൽ സൂക്ഷിച്ചിരിക്കുന്ന [Apache Arrow](https://arrow.apache.org/) ഫയലുകളാണ്, അതിനാൽ നിങ്ങൾ ആവശ്യപ്പെടുന്ന സാമ്പിളുകൾ മാത്രമേ മെമ്മറിയിൽ ലോഡ് ചെയ്യപ്പെടുന്നുള്ളൂ).
+
+ഡേറ്റയെ ഒരു ഡേറ്റാസെറ്റായി തന്നെ നിലനിർത്താൻ, നമ്മൾ [`Dataset.map()`](https://huggingface.co/docs/datasets/package_reference/main_classes#datasets.Dataset.map) മെത്തേഡ് ഉപയോഗിക്കും. ടോക്കണൈസേഷന് പുറമെ കൂടുതൽ പ്രീപ്രോസസ്സിംഗ് ആവശ്യമായി വന്നാൽ, ഇത് നമുക്ക് കുറച്ച് അധിക വഴക്കവും (flexibility) നൽകുന്നു. ഡേറ്റാസെറ്റിലെ ഓരോ ഘടകത്തിലും ഒരു ഫംഗ്‌ഷൻ പ്രയോഗിച്ചാണ് `map()` മെത്തേഡ് പ്രവർത്തിക്കുന്നത്, അതിനാൽ നമ്മുടെ ഇൻപുട്ടുകൾ ടോക്കണൈസ് ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷൻ നിർവചിക്കാം:
+
+```py
+def tokenize_function(example):
+    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)
+```
+
+ഈ ഫംഗ്‌ഷൻ ഒരു ഡിക്‌ഷണറി (നമ്മുടെ ഡേറ്റാസെറ്റിലെ ഐറ്റങ്ങൾ പോലെ) സ്വീകരിച്ച്, `input_ids`, `attention_mask`, `token_type_ids` എന്നീ കീകളുള്ള ഒരു പുതിയ ഡിക്‌ഷണറി തിരികെ നൽകുന്നു. മുമ്പ് കണ്ടതുപോലെ `tokenizer` വാക്യജോഡികളുടെ ലിസ്‌റ്റുകളിൽ പ്രവർത്തിക്കുന്നതിനാൽ, `example` ഡിക്‌ഷണറിയിൽ ഒന്നിലധികം സാമ്പിളുകൾ (ഓരോ കീയും വാക്യങ്ങളുടെ ഒരു ലിസ്‌റ്റായി) ഉണ്ടെങ്കിലും ഇത് പ്രവർത്തിക്കും എന്നത് ശ്രദ്ധിക്കുക. `map()` വിളിക്കുമ്പോൾ `batched=True` എന്ന ഓപ്‌ഷൻ ഉപയോഗിക്കാൻ ഇത് നമ്മെ അനുവദിക്കും, അത് ടോക്കണൈസേഷൻ വളരെയധികം വേഗത്തിലാക്കും. [🤗 Tokenizers](https://github.com/huggingface/tokenizers) ലൈബ്രറിയിൽ നിന്നുള്ള, Rust-ൽ എഴുതിയ ഒരു ടോക്കണൈസറാണ് `tokenizer`-ന് പിന്നിൽ പ്രവർത്തിക്കുന്നത്. ഈ ടോക്കണൈസർ വളരെ വേഗതയുള്ളതാകാം, എന്നാൽ ഒരേസമയം ധാരാളം ഇൻപുട്ടുകൾ നൽകിയാൽ മാത്രം.
+
+നമ്മുടെ ടോക്കണൈസേഷൻ ഫംഗ്‌ഷനിൽ `padding` ആർഗ്യുമെന്റ് ഇപ്പോൾ ഒഴിവാക്കിയിരിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക. എല്ലാ സാമ്പിളുകളെയും പരമാവധി നീളത്തിലേക്ക് പാഡ് ചെയ്യുന്നത് കാര്യക്ഷമമല്ല എന്നതാണ് ഇതിന് കാരണം: ഒരു ബാച്ച് നിർമ്മിക്കുമ്പോൾ സാമ്പിളുകൾ പാഡ് ചെയ്യുന്നതാണ് നല്ലത്, കാരണം അപ്പോൾ മുഴുവൻ ഡേറ്റാസെറ്റിലെയും പരമാവധി നീളത്തിലേക്കല്ല, ആ ബാച്ചിലെ പരമാവധി നീളത്തിലേക്ക് മാത്രം പാഡ് ചെയ്താൽ മതി. ഇൻപുട്ടുകളുടെ നീളം വളരെയധികം വ്യത്യാസപ്പെടുമ്പോൾ ഇത് ധാരാളം സമയവും പ്രോസസ്സിംഗ് ശേഷിയും ലാഭിക്കും!
+
+> [!TIP]
+> 📚 **പെർഫോമൻസ് ടിപ്പുകൾ**: കാര്യക്ഷമമായ ഡേറ്റാ പ്രോസസ്സിംഗ് ടെക്‌നിക്കുകളെക്കുറിച്ച് കൂടുതൽ അറിയാൻ [🤗 Datasets പെർഫോമൻസ് ഗൈഡ്](https://huggingface.co/docs/datasets/about_arrow) കാണുക.
+
+നമ്മുടെ എല്ലാ ഡേറ്റാസെറ്റുകളിലും ഒറ്റയടിക്ക് ടോക്കണൈസേഷൻ ഫംഗ്‌ഷൻ എങ്ങനെ പ്രയോഗിക്കാം എന്ന് ഇതാ. `map` വിളിക്കുമ്പോൾ നമ്മൾ `batched=True` ഉപയോഗിക്കുന്നു, അതിനാൽ ഫംഗ്‌ഷൻ ഓരോ ഘടകത്തിലും വെവ്വേറെയല്ല, നമ്മുടെ ഡേറ്റാസെറ്റിലെ ഒന്നിലധികം ഘടകങ്ങളിൽ ഒരേസമയം പ്രയോഗിക്കപ്പെടുന്നു. ഇത് കൂടുതൽ വേഗത്തിലുള്ള പ്രീപ്രോസസ്സിംഗ് സാധ്യമാക്കുന്നു.
+
+```py
+tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
+tokenized_datasets
+```
+
+പ്രീപ്രോസസ്സിംഗ് ഫംഗ്‌ഷൻ തിരികെ നൽകുന്ന ഡിക്‌ഷണറിയിലെ ഓരോ കീയ്ക്കും ഒന്ന് വീതം, ഡേറ്റാസെറ്റുകളിലേക്ക് പുതിയ ഫീൽഡുകൾ ചേർത്താണ് 🤗 Datasets ലൈബ്രറി ഈ പ്രോസസ്സിംഗ് പ്രയോഗിക്കുന്നത്:
+
+```python out
+DatasetDict({
+    train: Dataset({
+        features: ['attention_mask', 'idx', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'],
+        num_rows: 3668
+    })
+    validation: Dataset({
+        features: ['attention_mask', 'idx', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'],
+        num_rows: 408
+    })
+    test: Dataset({
+        features: ['attention_mask', 'idx', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'],
+        num_rows: 1725
+    })
+})
+```
+
+`num_proc` എന്ന ആർഗ്യുമെന്റ് നൽകിക്കൊണ്ട്, `map()` ഉപയോഗിച്ച് പ്രീപ്രോസസ്സിംഗ് ഫംഗ്‌ഷൻ പ്രയോഗിക്കുമ്പോൾ മൾട്ടിപ്രോസസ്സിംഗ് പോലും നിങ്ങൾക്ക് ഉപയോഗിക്കാം. നമ്മുടെ സാമ്പിളുകൾ വേഗത്തിൽ ടോക്കണൈസ് ചെയ്യാൻ 🤗 Tokenizers ലൈബ്രറി ഇതിനകം തന്നെ ഒന്നിലധികം ത്രെഡുകൾ ഉപയോഗിക്കുന്നതിനാൽ ഇവിടെ നമ്മൾ അത് ചെയ്തില്ല; എന്നാൽ ഈ ലൈബ്രറിയുടെ പിന്തുണയുള്ള ഒരു ഫാസ്‌റ്റ് ടോക്കണൈസർ അല്ല നിങ്ങൾ ഉപയോഗിക്കുന്നതെങ്കിൽ, ഇത് നിങ്ങളുടെ പ്രീപ്രോസസ്സിംഗ് വേഗത്തിലാക്കാം.
+
+നമ്മുടെ `tokenize_function` `input_ids`, `attention_mask`, `token_type_ids` എന്നീ കീകളുള്ള ഒരു ഡിക്‌ഷണറി തിരികെ നൽകുന്നു, അതിനാൽ ആ മൂന്ന് ഫീൽഡുകളും നമ്മുടെ ഡേറ്റാസെറ്റിന്റെ എല്ലാ സ്‌പ്ലിറ്റുകളിലേക്കും ചേർക്കപ്പെടുന്നു. `map()` പ്രയോഗിച്ച ഡേറ്റാസെറ്റിൽ ഇതിനകമുള്ള ഒരു കീയ്ക്ക് നമ്മുടെ പ്രീപ്രോസസ്സിംഗ് ഫംഗ്‌ഷൻ ഒരു പുതിയ മൂല്യം തിരികെ നൽകിയിരുന്നെങ്കിൽ, നിലവിലുള്ള ഫീൽഡുകൾ മാറ്റാനും നമുക്ക് കഴിയുമായിരുന്നു എന്നത് ശ്രദ്ധിക്കുക.
+
+ഘടകങ്ങളെ ഒരുമിച്ച് ബാച്ച് ചെയ്യുമ്പോൾ എല്ലാ ഉദാഹരണങ്ങളെയും ഏറ്റവും നീളമുള്ള ഘടകത്തിന്റെ നീളത്തിലേക്ക് പാഡ് ചെയ്യുക എന്നതാണ് നമുക്ക് ചെയ്യാൻ ബാക്കിയുള്ള അവസാന കാര്യം — ഈ ടെക്‌നിക്കിനെ നമ്മൾ *ഡൈനാമിക് പാഡിംഗ്* (dynamic padding) എന്ന് വിളിക്കുന്നു.
+
+##### ഡൈനാമിക് പാഡിംഗ്[[dynamic-padding]]
+
+<Youtube id="7q5NyFT8REg"/>
+
+ഒരു ബാച്ചിനുള്ളിൽ സാമ്പിളുകളെ ഒരുമിച്ച് ചേർക്കുന്നതിന് ഉത്തരവാദിയായ ഫംഗ്‌ഷനെ *കൊളേറ്റ് ഫംഗ്‌ഷൻ* (collate function) എന്ന് വിളിക്കുന്നു. ഒരു `DataLoader` നിർമ്മിക്കുമ്പോൾ നിങ്ങൾക്ക് നൽകാവുന്ന ഒരു ആർഗ്യുമെന്റാണിത്; ഡിഫോൾട്ടായി ഇത്, നിങ്ങളുടെ സാമ്പിളുകളെ PyTorch ടെൻസറുകളാക്കി മാറ്റി അവയെ കൂട്ടിച്ചേർക്കുക മാത്രം ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷനാണ് (നിങ്ങളുടെ ഘടകങ്ങൾ ലിസ്‌റ്റുകളോ ട്യൂപ്പിളുകളോ ഡിക്‌ഷണറികളോ ആണെങ്കിൽ റിക്കർസീവായി). നമ്മുടെ ഇൻപുട്ടുകൾ എല്ലാം ഒരേ വലുപ്പത്തിലാകില്ല എന്നതിനാൽ നമ്മുടെ കാര്യത്തിൽ ഇത് സാധ്യമാകില്ല. ഓരോ ബാച്ചിലും ആവശ്യമുള്ളത്ര മാത്രം പാഡിംഗ് പ്രയോഗിക്കാനും, ധാരാളം പാഡിംഗുള്ള അമിതനീളമുള്ള ഇൻപുട്ടുകൾ ഒഴിവാക്കാനുമാണ് നമ്മൾ പാഡിംഗ് മനഃപൂർവ്വം മാറ്റിവെച്ചത്. ഇത് ട്രെയിനിംഗ് നല്ലതുപോലെ വേഗത്തിലാക്കും, എന്നാൽ ഒരു TPU-വിലാണ് ട്രെയിൻ ചെയ്യുന്നതെങ്കിൽ ഇത് പ്രശ്‌നങ്ങൾ ഉണ്ടാക്കാം എന്നത് ശ്രദ്ധിക്കുക — അധിക പാഡിംഗ് ആവശ്യമായി വന്നാലും, TPU-കൾ നിശ്ചിത ഷെയ്‌പ്പുകളാണ് ഇഷ്ടപ്പെടുന്നത്.
+
+> [!TIP]
+> 🚀 **ഒപ്‌റ്റിമൈസേഷൻ ഗൈഡ്**: പാഡിംഗ് തന്ത്രങ്ങളും TPU സംബന്ധമായ പരിഗണനകളും ഉൾപ്പെടെ, ട്രെയിനിംഗ് പെർഫോമൻസ് ഒപ്‌റ്റിമൈസ് ചെയ്യുന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക് [🤗 Transformers പെർഫോമൻസ് ഡോക്യുമെന്റേഷൻ](https://huggingface.co/docs/transformers/main/en/performance) കാണുക.
+
+ഇത് പ്രായോഗികമായി ചെയ്യാൻ, ഒരുമിച്ച് ബാച്ച് ചെയ്യേണ്ട ഡേറ്റാസെറ്റ് ഐറ്റങ്ങൾക്ക് ശരിയായ അളവിൽ പാഡിംഗ് പ്രയോഗിക്കുന്ന ഒരു കൊളേറ്റ് ഫംഗ്‌ഷൻ നമ്മൾ നിർവചിക്കേണ്ടതുണ്ട്. ഭാഗ്യവശാൽ, `DataCollatorWithPadding` വഴി 🤗 Transformers ലൈബ്രറി അത്തരമൊരു ഫംഗ്‌ഷൻ നമുക്ക് നൽകുന്നു. ഇത് ഇൻസ്‌റ്റാൻഷിയേറ്റ് ചെയ്യുമ്പോൾ ഒരു ടോക്കണൈസർ സ്വീകരിക്കുന്നു (ഏത് പാഡിംഗ് ടോക്കൺ ഉപയോഗിക്കണമെന്നും, പാഡിംഗ് ഇൻപുട്ടുകളുടെ ഇടതുവശത്താണോ വലതുവശത്താണോ മോഡൽ പ്രതീക്ഷിക്കുന്നത് എന്നും അറിയാൻ), കൂടാതെ നിങ്ങൾക്ക് ആവശ്യമായതെല്ലാം ഇത് ചെയ്യും:
+
+```py
+from transformers import DataCollatorWithPadding
+
+data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+```
+
+ഈ പുതിയ കളിപ്പാട്ടം പരീക്ഷിക്കാൻ, ഒരുമിച്ച് ബാച്ച് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന കുറച്ച് സാമ്പിളുകൾ നമ്മുടെ ട്രെയിനിംഗ് സെറ്റിൽ നിന്ന് എടുക്കാം. ഇവിടെ, `idx`, `sentence1`, `sentence2` എന്നീ കോളങ്ങൾ നമ്മൾ നീക്കം ചെയ്യുന്നു, കാരണം അവ ആവശ്യമില്ല, മാത്രമല്ല അവയിൽ സ്ട്രിംഗുകളാണുള്ളത് (സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് ടെൻസറുകൾ ഉണ്ടാക്കാൻ കഴിയില്ല); തുടർന്ന് ബാച്ചിലെ ഓരോ എൻട്രിയുടെയും നീളം നോക്കാം:
+
+```py
+samples = tokenized_datasets["train"][:8]
+samples = {k: v for k, v in samples.items() if k not in ["idx", "sentence1", "sentence2"]}
+[len(x) for x in samples["input_ids"]]
+```
+
+```python out
+[50, 59, 47, 67, 59, 50, 62, 32]
+```
+
+അതിശയമില്ല, 32 മുതൽ 67 വരെ വ്യത്യസ്ത നീളമുള്ള സാമ്പിളുകളാണ് നമുക്ക് ലഭിക്കുന്നത്. ഡൈനാമിക് പാഡിംഗ് എന്നാൽ, ഈ ബാച്ചിലെ എല്ലാ സാമ്പിളുകളെയും ബാച്ചിനുള്ളിലെ പരമാവധി നീളമായ 67-ലേക്ക് പാഡ് ചെയ്യണം എന്നാണ്. ഡൈനാമിക് പാഡിംഗ് ഇല്ലെങ്കിൽ, എല്ലാ സാമ്പിളുകളെയും മുഴുവൻ ഡേറ്റാസെറ്റിലെയും പരമാവധി നീളത്തിലേക്കോ, അല്ലെങ്കിൽ മോഡലിന് സ്വീകരിക്കാൻ കഴിയുന്ന പരമാവധി നീളത്തിലേക്കോ പാഡ് ചെയ്യേണ്ടി വരും. നമ്മുടെ `data_collator` ബാച്ചിനെ ശരിയായി ഡൈനാമിക്കായി പാഡ് ചെയ്യുന്നുണ്ടോ എന്ന് ഒന്നുകൂടി ഉറപ്പുവരുത്താം:
+
+```py
+batch = data_collator(samples)
+{k: v.shape for k, v in batch.items()}
+```
+
+```python out
+{'attention_mask': torch.Size([8, 67]),
+ 'input_ids': torch.Size([8, 67]),
+ 'token_type_ids': torch.Size([8, 67]),
+ 'labels': torch.Size([8])}
+```
+
+കൊള്ളാം! അസംസ്‌കൃത ടെക്‌സ്‌റ്റിൽ നിന്ന് നമ്മുടെ മോഡലിന് കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ബാച്ചുകളിലേക്ക് നമ്മൾ എത്തിയ സ്ഥിതിക്ക്, ഇനി അതിനെ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ നമ്മൾ തയ്യാറാണ്!
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** GLUE SST-2 ഡേറ്റാസെറ്റിൽ ഈ പ്രീപ്രോസസ്സിംഗ് ആവർത്തിക്കുക. ജോഡികൾക്ക് പകരം ഒറ്റ വാക്യങ്ങളാണ് അതിലുള്ളത് എന്നതിനാൽ ഇത് ചെറുതായി വ്യത്യസ്തമാണ്, എന്നാൽ നമ്മൾ ചെയ്ത ബാക്കിയെല്ലാം ഒരുപോലെ തന്നെയായിരിക്കണം. കൂടുതൽ കഠിനമായ ഒരു വെല്ലുവിളിക്ക്, GLUE ടാസ്‌ക്കുകളിൽ ഏതിലും പ്രവർത്തിക്കുന്ന ഒരു പ്രീപ്രോസസ്സിംഗ് ഫംഗ്‌ഷൻ എഴുതാൻ ശ്രമിക്കുക.
+>
+> 📖 **അധിക പരിശീലനം**: [🤗 Transformers ഉദാഹരണങ്ങളിൽ](https://huggingface.co/docs/transformers/main/en/notebooks) നിന്നുള്ള ഈ പ്രായോഗിക ഉദാഹരണങ്ങൾ പരിശോധിക്കുക.
+
+വളരെ നന്നായി! 🤗 Datasets ലൈബ്രറിയിലെ ഏറ്റവും പുതിയ മികച്ച രീതികൾ ഉപയോഗിച്ച് നമ്മുടെ ഡേറ്റ പ്രീപ്രോസസ്സ് ചെയ്തുകഴിഞ്ഞ സ്ഥിതിക്ക്, ആധുനിക Trainer API ഉപയോഗിച്ച് നമ്മുടെ മോഡൽ ട്രെയിൻ ചെയ്യുന്നതിലേക്ക് നീങ്ങാൻ നമ്മൾ തയ്യാറാണ്. Hugging Face ഇക്കോസിസ്റ്റത്തിൽ ലഭ്യമായ ഏറ്റവും പുതിയ സവിശേഷതകളും ഒപ്‌റ്റിമൈസേഷനുകളും ഉപയോഗിച്ച് നിങ്ങളുടെ മോഡൽ എങ്ങനെ ഫലപ്രദമായി ഫൈൻ-ട്യൂൺ ചെയ്യാം എന്ന് അടുത്ത ഭാഗം കാണിച്ചുതരും.
+
+## ഈ ഭാഗത്തിന്റെ ക്വിസ്[[section-quiz]]
+
+ഡേറ്റാ പ്രോസസ്സിംഗ് ആശയങ്ങളെക്കുറിച്ചുള്ള നിങ്ങളുടെ ധാരണ പരീക്ഷിക്കുക:
+
+### 1. `batched=True` ഉപയോഗിച്ച് `Dataset.map()` പ്രയോഗിക്കുന്നതിന്റെ പ്രധാന നേട്ടം എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "ഇത് കുറച്ച് മെമ്മറി ഉപയോഗിക്കുന്നു.",
+			explain: "ഇത് കൂടുതൽ മെമ്മറി-കാര്യക്ഷമമാകാമെങ്കിലും, ഇതല്ല പ്രധാന നേട്ടം."
+		},
+		{
+			text: "ഇത് ഒന്നിലധികം ഉദാഹരണങ്ങൾ ഒരേസമയം പ്രോസസ്സ് ചെയ്യുന്നു, അതുവഴി ടോക്കണൈസേഷൻ വളരെ വേഗത്തിലാക്കുന്നു.",
+			explain: "ശരി! ബാച്ചുകളായി പ്രോസസ്സ് ചെയ്യുന്നത് ഫാസ്‌റ്റ് ടോക്കണൈസറിന് ഒന്നിലധികം ഉദാഹരണങ്ങളിൽ ഒരേസമയം പ്രവർത്തിക്കാൻ അനുവദിക്കുന്നു, ഇത് വേഗത ഗണ്യമായി മെച്ചപ്പെടുത്തുന്നു.",
+            correct: true
+		},
+		{
+			text: "ഇത് നിങ്ങൾക്കായി പാഡിംഗ് സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു.",
+			explain: "ബാച്ചിംഗ് പാഡിംഗ് സ്വയമേവ കൈകാര്യം ചെയ്യുന്നില്ല - അത് ഡേറ്റാ കൊളേറ്റർ ചെയ്യുന്ന കാര്യമാണ്."
+		},
+        {
+			text: "ഇത് ഡേറ്റയെ PyTorch ടെൻസറുകളാക്കി മാറ്റുന്നു.",
+			explain: "ടെൻസർ പരിവർത്തനം നടക്കുന്നത് നിങ്ങൾ ഫോർമാറ്റ് സെറ്റ് ചെയ്യുമ്പോഴാണ്, ബാച്ച്ഡ് മാപ്പിംഗ് സമയത്തല്ല."
+		}
+	]}
+/>
+
+### 2. ഡേറ്റാസെറ്റിലെ പരമാവധി നീളത്തിലേക്ക് എല്ലാ സീക്വൻസുകളെയും പാഡ് ചെയ്യുന്നതിന് പകരം ഡൈനാമിക് പാഡിംഗ് ഉപയോഗിക്കുന്നത് എന്തുകൊണ്ട്?
+
+<Question
+	choices={[
+		{
+			text: "മോഡൽ ആർക്കിടെക്‌ചറിന് ഡൈനാമിക് പാഡിംഗ് അനിവാര്യമാണ്.",
+			explain: "അല്ല, മോഡലുകൾക്ക് ഫിക്‌സഡ് പാഡിംഗും ഡൈനാമിക് പാഡിംഗും കൈകാര്യം ചെയ്യാൻ കഴിയും."
+		},
+		{
+			text: "ഓരോ ബാച്ചിലെയും പരമാവധി നീളത്തിലേക്ക് മാത്രം പാഡ് ചെയ്യുന്നതിലൂടെ ഇത് കമ്പ്യൂട്ടേഷണൽ ഓവർഹെഡ് കുറയ്ക്കുന്നു.",
+			explain: "ശരി! ഡേറ്റാസെറ്റിലെ പരമാവധി നീളത്തിലേക്കല്ല, ബാച്ചിലെ പരമാവധി നീളത്തിലേക്ക് മാത്രം പാഡ് ചെയ്യുന്നതിലൂടെ, പാഡിംഗ് ടോക്കണുകളിലെ അനാവശ്യ കമ്പ്യൂട്ടേഷൻ ഡൈനാമിക് പാഡിംഗ് ഒഴിവാക്കുന്നു.",
+            correct: true
+		},
+		{
+			text: "ഇത് മോഡലിന്റെ കൃത്യത മെച്ചപ്പെടുത്തുന്നു.",
+			explain: "പാഡിംഗ് തന്ത്രം മോഡലിന്റെ കൃത്യതയെ നേരിട്ട് ബാധിക്കുന്നില്ല."
+		},
+        {
+			text: "DataCollatorWithPadding ഉപയോഗിക്കുമ്പോൾ ഇത് അനിവാര്യമാണ്.",
+			explain: "DataCollatorWithPadding ഡൈനാമിക് പാഡിംഗ് സാധ്യമാക്കുന്നു, എന്നാൽ വേണമെങ്കിൽ നിങ്ങൾക്ക് ഇപ്പോഴും ഫിക്‌സഡ് പാഡിംഗ് ഉപയോഗിക്കാം."
+		}
+	]}
+/>
+
+### 3. BERT ടോക്കണൈസേഷനിൽ `token_type_ids` ഫീൽഡ് എന്തിനെ പ്രതിനിധീകരിക്കുന്നു?
+
+<Question
+	choices={[
+		{
+			text: "സീക്വൻസിലെ ഓരോ ടോക്കണിന്റെയും സ്ഥാനം.",
+			explain: "അത് പൊസിഷൻ എംബെഡ്ഡിംഗുകളാണ്, token_type_ids അല്ല."
+		},
+		{
+			text: "വാക്യജോഡികൾ പ്രോസസ്സ് ചെയ്യുമ്പോൾ ഓരോ ടോക്കണും ഏത് വാക്യത്തിൽ ഉൾപ്പെടുന്നു എന്നത്.",
+			explain: "ശരി! വാക്യജോഡി ടാസ്‌ക്കുകളിൽ ആദ്യ വാക്യത്തെയും (0) രണ്ടാം വാക്യത്തെയും (1) token_type_ids വേർതിരിക്കുന്നു.",
+            correct: true
+		},
+		{
+			text: "ഓരോ ടോക്കണിന്റെയും അറ്റൻഷൻ മാസ്‌ക്.",
+			explain: "ഏതൊക്കെ ടോക്കണുകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കണം എന്ന് സൂചിപ്പിക്കുന്ന ഒരു പ്രത്യേക ഫീൽഡാണ് അറ്റൻഷൻ മാസ്‌ക്."
+		},
+        {
+			text: "ഓരോ ടോക്കണിന്റെയും വൊക്കാബുലറി ID.",
+			explain: "അത് input_ids ഫീൽഡാണ്, token_type_ids അല്ല."
+		}
+	]}
+/>
+
+### 4. `load_dataset('glue', 'mrpc')` ഉപയോഗിച്ച് ഒരു ഡേറ്റാസെറ്റ് ലോഡ് ചെയ്യുമ്പോൾ, രണ്ടാമത്തെ ആർഗ്യുമെന്റ് എന്താണ് വ്യക്തമാക്കുന്നത്?
+
+<Question
+	choices={[
+		{
+			text: "ലോഡ് ചെയ്യേണ്ട ഡേറ്റാസെറ്റിന്റെ പതിപ്പ് (version).",
+			explain: "പതിപ്പ് വ്യക്തമാക്കാൻ വ്യത്യസ്ത പാരാമീറ്ററുകളാണ് ഉപയോഗിക്കുന്നത്."
+		},
+		{
+			text: "GLUE ബെഞ്ച്‌മാർക്കിനുള്ളിലെ നിശ്ചിത ടാസ്‌ക്ക് അല്ലെങ്കിൽ ഉപവിഭാഗം (subset).",
+			explain: "ശരി! വലിയ GLUE ബെഞ്ച്‌മാർക്ക് ശേഖരത്തിനുള്ളിലെ നിശ്ചിത ടാസ്‌ക്കുകളിൽ ഒന്നാണ് MRPC.",
+            correct: true
+		},
+		{
+			text: "ഡേറ്റാസെറ്റിന്റെ സ്‌പ്ലിറ്റ് (train/validation/test).",
+			explain: "സ്‌പ്ലിറ്റുകൾ ലോഡ് ചെയ്ത ശേഷമാണ് ആക്‌സസ് ചെയ്യുന്നത്, load_dataset വിളിയിൽ വ്യക്തമാക്കുന്നതല്ല."
+		},
+        {
+			text: "ഡേറ്റ തിരികെ നൽകേണ്ട ഫോർമാറ്റ്.",
+			explain: "ലോഡ് ചെയ്ത ശേഷം set_format() മെത്തേഡ് ഉപയോഗിച്ചാണ് ഫോർമാറ്റ് സെറ്റ് ചെയ്യുന്നത്."
+		}
+	]}
+/>
+
+### 5. ട്രെയിനിംഗിന് മുമ്പ് 'sentence1', 'sentence2' തുടങ്ങിയ കോളങ്ങൾ നീക്കം ചെയ്യുന്നതിന്റെ ഉദ്ദേശ്യം എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "ട്രെയിനിംഗ് സമയത്ത് മെമ്മറി ലാഭിക്കാൻ.",
+			explain: "ഇത് കുറച്ച് മെമ്മറി ലാഭിക്കുമെങ്കിലും, ഇതല്ല പ്രധാന കാരണം."
+		},
+		{
+			text: "മോഡൽ ഈ അസംസ്‌കൃത ടെക്‌സ്‌റ്റ് കോളങ്ങൾ പ്രതീക്ഷിക്കുന്നില്ല, അതിനാൽ ഒരു എറർ ഉണ്ടാകും.",
+			explain: "ശരി! മോഡലുകൾ പ്രതീക്ഷിക്കുന്നത് സംഖ്യാ ടെൻസറുകളാണ്, അസംസ്‌കൃത ടെക്‌സ്‌റ്റ് സ്ട്രിംഗുകളല്ല. ടെക്‌സ്‌റ്റ് കോളങ്ങൾ നിലനിർത്തിയാൽ എററുകൾ ഉണ്ടാകും.",
+            correct: true
+		},
+		{
+			text: "ഈ കോളങ്ങൾ ഇവാലുവേഷന് ആവശ്യമില്ല.",
+			explain: "ഇത് ശരിയാണെങ്കിലും, മോഡലിന് അസംസ്‌കൃത ടെക്‌സ്‌റ്റ് പ്രോസസ്സ് ചെയ്യാൻ കഴിയില്ല എന്നതാണ് പ്രധാന കാരണം."
+		},
+        {
+			text: "ഇത് ട്രെയിനിംഗ് വേഗത ഗണ്യമായി മെച്ചപ്പെടുത്തുന്നു.",
+			explain: "പൊരുത്തപ്പെടാത്ത ഡേറ്റാ ടൈപ്പുകൾ മൂലമുള്ള എററുകൾ ഒഴിവാക്കുന്നതുമായി താരതമ്യം ചെയ്യുമ്പോൾ വേഗതയിലെ മെച്ചം വളരെ ചെറുതാണ്."
+		}
+	]}
+/>
+
+> [!TIP]
+> 💡 **പ്രധാന പാഠങ്ങൾ:**
+> - ഗണ്യമായി വേഗത്തിലുള്ള പ്രീപ്രോസസ്സിംഗിനായി `Dataset.map()`-നോടൊപ്പം `batched=True` ഉപയോഗിക്കുക
+> - `DataCollatorWithPadding` ഉപയോഗിച്ചുള്ള ഡൈനാമിക് പാഡിംഗ്, നിശ്ചിത നീളത്തിലേക്കുള്ള പാഡിംഗിനെക്കാൾ കാര്യക്ഷമമാണ്
+> - നിങ്ങളുടെ മോഡൽ പ്രതീക്ഷിക്കുന്നതിന് (സംഖ്യാ ടെൻസറുകൾ, ശരിയായ കോളം പേരുകൾ) അനുസൃതമായി എപ്പോഴും ഡേറ്റ പ്രീപ്രോസസ്സ് ചെയ്യുക
+> - വലിയ തോതിൽ കാര്യക്ഷമമായ ഡേറ്റാ പ്രോസസ്സിംഗിനുള്ള ശക്തമായ ടൂളുകൾ 🤗 Datasets ലൈബ്രറി നൽകുന്നു

From a03d63f39b3b24be951819ca2f5c7c7c3a477ee9 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 13:32:12 +0530
Subject: [PATCH 33/44] Add Malayalam translation for chapter3/3.mdx

---
 chapters/ml/chapter3/3.mdx | 372 +++++++++++++++++++++++++++++++++++++
 1 file changed, 372 insertions(+)
 create mode 100644 chapters/ml/chapter3/3.mdx

diff --git a/chapters/ml/chapter3/3.mdx b/chapters/ml/chapter3/3.mdx
new file mode 100644
index 000000000..d2a7e9ff5
--- /dev/null
+++ b/chapters/ml/chapter3/3.mdx
@@ -0,0 +1,372 @@
+<FrameworkSwitchCourse {fw} />
+
+# Trainer API ഉപയോഗിച്ച് ഒരു മോഡൽ ഫൈൻ-ട്യൂൻ ചെയ്യുന്നു[[fine-tuning-a-model-with-the-trainer-api]]
+
+<CourseFloatingBanner chapter={3}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter3/section3.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter3/section3.ipynb"},
+]} />
+
+<Youtube id="nvBXf7s7vTI"/>
+
+🤗 Transformers-ൽ ലഭ്യമായ ഏത് പ്രീട്രെയിൻഡ് മോഡലും, ആധുനികമായ മികച്ച രീതികൾ (best practices) പിന്തുടർന്ന്, നിങ്ങളുടെ ഡേറ്റാസെറ്റിൽ ഫൈൻ-ട്യൂൻ ചെയ്യാൻ സഹായിക്കുന്ന ഒരു `Trainer` ക്ലാസ് 🤗 Transformers നൽകുന്നു. കഴിഞ്ഞ ഭാഗത്തിലെ ഡേറ്റാ പ്രീപ്രോസസ്സിംഗ് ജോലികളെല്ലാം പൂർത്തിയാക്കിക്കഴിഞ്ഞാൽ, `Trainer` നിർവചിക്കാൻ ഇനി ഏതാനും ഘട്ടങ്ങൾ മാത്രമേ ബാക്കിയുള്ളൂ. `Trainer.train()` റൺ ചെയ്യാനുള്ള എൻവയോൺമെന്റ് തയ്യാറാക്കുന്നതായിരിക്കും ഒരുപക്ഷേ ഏറ്റവും ബുദ്ധിമുട്ടുള്ള ഭാഗം, കാരണം ഒരു CPU-വിൽ ഇത് വളരെ പതുക്കെയായിരിക്കും റൺ ചെയ്യുക. നിങ്ങൾക്ക് ഒരു GPU സെറ്റപ്പ് ചെയ്തിട്ടില്ലെങ്കിൽ, [Google Colab](https://colab.research.google.com/)-ൽ സൗജന്യ GPU-കളോ TPU-കളോ നിങ്ങൾക്ക് ഉപയോഗിക്കാം.
+
+> [!TIP]
+> 📚 **ട്രെയിനിംഗ് റിസോഴ്‌സുകൾ**: ട്രെയിനിംഗിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, സമഗ്രമായ [🤗 Transformers ട്രെയിനിംഗ് ഗൈഡ്](https://huggingface.co/docs/transformers/main/en/training) പരിചയപ്പെടുകയും [ഫൈൻ-ട്യൂണിംഗ് കുക്ക്‌ബുക്കിലെ](https://huggingface.co/learn/cookbook/en/fine_tuning_code_llm_on_single_gpu) പ്രായോഗിക ഉദാഹരണങ്ങൾ പരിശോധിക്കുകയും ചെയ്യുക.
+
+മുൻ ഭാഗത്തിലെ ഉദാഹരണങ്ങൾ നിങ്ങൾ ഇതിനകം റൺ ചെയ്തിട്ടുണ്ട് എന്ന അനുമാനത്തിലാണ് താഴെയുള്ള കോഡ് ഉദാഹരണങ്ങൾ. നിങ്ങൾക്ക് ആവശ്യമുള്ളവ ഓർമ്മിപ്പിക്കുന്ന ഒരു ചെറിയ സംഗ്രഹം ഇതാ:
+
+```py
+from datasets import load_dataset
+from transformers import AutoTokenizer, DataCollatorWithPadding
+
+raw_datasets = load_dataset("glue", "mrpc")
+checkpoint = "bert-base-uncased"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+
+
+def tokenize_function(example):
+    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)
+
+
+tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
+data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+```
+
+### ട്രെയിനിംഗ്[[training]]
+
+നമ്മുടെ `Trainer` നിർവചിക്കുന്നതിന് മുമ്പുള്ള ആദ്യ ഘട്ടം, ട്രെയിനിംഗിനും ഇവാല്യുവേഷനും (evaluation) `Trainer` ഉപയോഗിക്കുന്ന എല്ലാ ഹൈപ്പർപാരാമീറ്ററുകളും ഉൾക്കൊള്ളുന്ന ഒരു `TrainingArguments` ക്ലാസ് നിർവചിക്കുകയാണ്. ട്രെയിൻ ചെയ്ത മോഡലും ഇടയ്ക്കിടെയുള്ള ചെക്ക്‌പോയിന്റുകളും സേവ് ചെയ്യേണ്ട ഡയറക്ടറി മാത്രമാണ് നിങ്ങൾ നിർബന്ധമായും നൽകേണ്ട ഒരേയൊരു ആർഗ്യുമെന്റ്. ബാക്കിയെല്ലാം ഡിഫോൾട്ടുകളായി വിടാം; ഒരു അടിസ്ഥാന ഫൈൻ-ട്യൂണിംഗിന് അവ നന്നായി പ്രവർത്തിക്കേണ്ടതാണ്.
+
+```py
+from transformers import TrainingArguments
+
+training_args = TrainingArguments("test-trainer")
+```
+
+ട്രെയിനിംഗ് സമയത്ത് നിങ്ങളുടെ മോഡൽ Hub-ലേക്ക് സ്വയമേവ അപ്‌ലോഡ് ചെയ്യണമെങ്കിൽ, `TrainingArguments`-ൽ `push_to_hub=True` നൽകുക. ഇതേക്കുറിച്ച് [അധ്യായം 4](/course/chapter4/3)-ൽ നമ്മൾ കൂടുതൽ പഠിക്കും
+
+> [!TIP]
+> 🚀 **അഡ്വാൻസ്ഡ് കോൺഫിഗറേഷൻ**: ലഭ്യമായ എല്ലാ ട്രെയിനിംഗ് ആർഗ്യുമെന്റുകളെയും ഒപ്‌റ്റിമൈസേഷൻ തന്ത്രങ്ങളെയും കുറിച്ചുള്ള വിശദമായ വിവരങ്ങൾക്ക്, [TrainingArguments ഡോക്യുമെന്റേഷനും](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments) [ട്രെയിനിംഗ് കോൺഫിഗറേഷൻ കുക്ക്‌ബുക്കും](https://huggingface.co/learn/cookbook/en/fine_tuning_code_llm_on_single_gpu) പരിശോധിക്കുക.
+
+രണ്ടാമത്തെ ഘട്ടം നമ്മുടെ മോഡൽ നിർവചിക്കുകയാണ്. [മുൻ അധ്യായത്തിലേതുപോലെ](/course/chapter2), രണ്ട് ലേബലുകളോടെ `AutoModelForSequenceClassification` ക്ലാസ് നമ്മൾ ഉപയോഗിക്കും:
+
+```py
+from transformers import AutoModelForSequenceClassification
+
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
+```
+
+[അധ്യായം 2](/course/chapter2)-ൽ നിന്ന് വ്യത്യസ്തമായി, ഈ പ്രീട്രെയിൻഡ് മോഡൽ ഇൻസ്‌റ്റാൻഷിയേറ്റ് ചെയ്ത ശേഷം നിങ്ങൾക്ക് ഒരു മുന്നറിയിപ്പ് (warning) ലഭിക്കുന്നത് നിങ്ങൾ ശ്രദ്ധിക്കും. വാക്യജോഡികൾ വർഗ്ഗീകരിക്കാൻ BERT പ്രീട്രെയിൻ ചെയ്യപ്പെട്ടിട്ടില്ല എന്നതാണ് ഇതിന് കാരണം; അതിനാൽ പ്രീട്രെയിൻഡ് മോഡലിന്റെ ഹെഡ് (head) ഒഴിവാക്കി, പകരം സീക്വൻസ് ക്ലാസിഫിക്കേഷന് അനുയോജ്യമായ ഒരു പുതിയ ഹെഡ് ചേർത്തിരിക്കുന്നു. ചില വെയ്‌റ്റുകൾ ഉപയോഗിച്ചിട്ടില്ലെന്നും (ഒഴിവാക്കിയ പ്രീട്രെയിനിംഗ് ഹെഡിന്റേത്) മറ്റു ചിലത് ക്രമരഹിതമായി (randomly) ഇനിഷ്യലൈസ് ചെയ്യപ്പെട്ടിരിക്കുന്നു എന്നും (പുതിയ ഹെഡിന്റേത്) ഈ മുന്നറിയിപ്പുകൾ സൂചിപ്പിക്കുന്നു. മോഡൽ ട്രെയിൻ ചെയ്യാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിച്ചുകൊണ്ടാണ് അത് അവസാനിക്കുന്നത് — അതുതന്നെയാണ് നമ്മൾ ഇപ്പോൾ ചെയ്യാൻ പോകുന്നതും.
+
+മോഡൽ തയ്യാറായിക്കഴിഞ്ഞാൽ, ഇതുവരെ നിർമ്മിച്ച എല്ലാ ഒബ്‌ജക്റ്റുകളും — `model`, `training_args`, ട്രെയിനിംഗ്, വാലിഡേഷൻ ഡേറ്റാസെറ്റുകൾ, നമ്മുടെ `data_collator`, നമ്മുടെ `processing_class` — നൽകിക്കൊണ്ട് ഒരു `Trainer` നിർവചിക്കാം. `processing_class` എന്ന പാരാമീറ്റർ അടുത്തകാലത്ത് ചേർത്ത ഒന്നാണ്; പ്രോസസ്സിംഗിന് ഏത് ടോക്കണൈസർ ഉപയോഗിക്കണമെന്ന് ഇത് Trainer-നോട് പറയുന്നു:
+
+```py
+from transformers import Trainer
+
+trainer = Trainer(
+    model,
+    training_args,
+    train_dataset=tokenized_datasets["train"],
+    eval_dataset=tokenized_datasets["validation"],
+    data_collator=data_collator,
+    processing_class=tokenizer,
+)
+```
+
+`processing_class` ആയി ഒരു ടോക്കണൈസർ നൽകുമ്പോൾ, `Trainer` ഉപയോഗിക്കുന്ന ഡിഫോൾട്ട് `data_collator` ഒരു `DataCollatorWithPadding` ആയിരിക്കും. ഈ സാഹചര്യത്തിൽ `data_collator=data_collator` എന്ന വരി നിങ്ങൾക്ക് ഒഴിവാക്കാം, എന്നാൽ പ്രോസസ്സിംഗ് പൈപ്പ്‌ലൈനിന്റെ ഈ പ്രധാന ഭാഗം നിങ്ങൾക്ക് കാണിച്ചുതരാനാണ് ഞങ്ങൾ ഇവിടെ അത് ഉൾപ്പെടുത്തിയത്.
+
+> [!TIP]
+> 📖 **കൂടുതൽ അറിയാൻ**: Trainer ക്ലാസിനെയും അതിന്റെ പാരാമീറ്ററുകളെയും കുറിച്ചുള്ള സമഗ്രമായ വിവരങ്ങൾക്ക്, [Trainer API ഡോക്യുമെന്റേഷൻ](https://huggingface.co/docs/transformers/main/en/main_classes/trainer) സന്ദർശിക്കുകയും [ട്രെയിനിംഗ് കുക്ക്‌ബുക്ക് റെസിപ്പികളിലെ](https://huggingface.co/learn/cookbook/en/fine_tuning_code_llm_on_single_gpu) അഡ്വാൻസ്ഡ് ഉപയോഗരീതികൾ പരിശോധിക്കുകയും ചെയ്യുക.
+
+നമ്മുടെ ഡേറ്റാസെറ്റിൽ മോഡൽ ഫൈൻ-ട്യൂൻ ചെയ്യാൻ, നമ്മുടെ `Trainer`-ന്റെ `train()` മെത്തേഡ് വിളിച്ചാൽ മാത്രം മതി:
+
+```py
+trainer.train()
+```
+
+ഇത് ഫൈൻ-ട്യൂണിംഗ് ആരംഭിക്കുകയും (ഒരു GPU-വിൽ ഇതിന് ഏതാനും മിനിറ്റുകൾ എടുക്കും) ഓരോ 500 സ്‌റ്റെപ്പിലും ട്രെയിനിംഗ് ലോസ് റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യും. എന്നാൽ, നിങ്ങളുടെ മോഡൽ എത്ര നന്നായി (അല്ലെങ്കിൽ മോശമായി) പ്രവർത്തിക്കുന്നു എന്ന് ഇത് നിങ്ങളോട് പറയില്ല. അതിന് കാരണം:
+
+1. `TrainingArguments`-ലെ `eval_strategy` `"steps"` (ഓരോ `eval_steps`-ലും ഇവാല്യുവേറ്റ് ചെയ്യുക) അല്ലെങ്കിൽ `"epoch"` (ഓരോ എപ്പോക്കിന്റെയും അവസാനം ഇവാല്യുവേറ്റ് ചെയ്യുക) എന്ന് സെറ്റ് ചെയ്തുകൊണ്ട്, ട്രെയിനിംഗ് സമയത്ത് ഇവാല്യുവേറ്റ് ചെയ്യാൻ നമ്മൾ `Trainer`-നോട് പറഞ്ഞില്ല.
+2. ആ ഇവാല്യുവേഷൻ സമയത്ത് ഒരു മെട്രിക് കണക്കാക്കാനുള്ള `compute_metrics()` ഫംഗ്‌ഷൻ നമ്മൾ `Trainer`-ന് നൽകിയില്ല (അല്ലാത്തപക്ഷം ഇവാല്യുവേഷൻ ലോസ് മാത്രമേ പ്രിന്റ് ചെയ്യുമായിരുന്നുള്ളൂ, അത് അത്ര അവബോധജന്യമായ ഒരു സംഖ്യയല്ല).
+
+
+### ഇവാല്യുവേഷൻ[[evaluation]]
+
+ഉപകാരപ്രദമായ ഒരു `compute_metrics()` ഫംഗ്‌ഷൻ എങ്ങനെ നിർമ്മിക്കാമെന്നും അടുത്ത തവണ ട്രെയിൻ ചെയ്യുമ്പോൾ അത് എങ്ങനെ ഉപയോഗിക്കാമെന്നും നോക്കാം. ഈ ഫംഗ്‌ഷൻ ഒരു `EvalPrediction` ഒബ്‌ജക്റ്റ് സ്വീകരിക്കണം (`predictions` എന്ന ഫീൽഡും `label_ids` എന്ന ഫീൽഡും ഉള്ള ഒരു named tuple ആണിത്), കൂടാതെ സ്‌ട്രിംഗുകളെ ഫ്ലോട്ടുകളുമായി ബന്ധിപ്പിക്കുന്ന ഒരു ഡിക്‌ഷണറി റിട്ടേൺ ചെയ്യും (സ്‌ട്രിംഗുകൾ റിട്ടേൺ ചെയ്യുന്ന മെട്രിക്കുകളുടെ പേരുകളും, ഫ്ലോട്ടുകൾ അവയുടെ മൂല്യങ്ങളുമാണ്). നമ്മുടെ മോഡലിൽ നിന്ന് ചില പ്രവചനങ്ങൾ (predictions) ലഭിക്കാൻ, `Trainer.predict()` കമാൻഡ് ഉപയോഗിക്കാം:
+
+```py
+predictions = trainer.predict(tokenized_datasets["validation"])
+print(predictions.predictions.shape, predictions.label_ids.shape)
+```
+
+```python out
+(408, 2) (408,)
+```
+
+`predict()` മെത്തേഡിന്റെ ഔട്ട്‌പുട്ട് മൂന്ന് ഫീൽഡുകളുള്ള മറ്റൊരു named tuple ആണ്: `predictions`, `label_ids`, `metrics`. `metrics` ഫീൽഡിൽ, നൽകിയ ഡേറ്റാസെറ്റിലെ ലോസും ചില സമയ മെട്രിക്കുകളും (പ്രവചിക്കാൻ മൊത്തത്തിലും ശരാശരിയായും എത്ര സമയമെടുത്തു) മാത്രമേ ഉണ്ടാകൂ. നമ്മുടെ `compute_metrics()` ഫംഗ്‌ഷൻ പൂർത്തിയാക്കി `Trainer`-ന് നൽകിക്കഴിഞ്ഞാൽ, `compute_metrics()` റിട്ടേൺ ചെയ്യുന്ന മെട്രിക്കുകളും ആ ഫീൽഡിൽ ഉണ്ടാകും.
+
+നിങ്ങൾക്ക് കാണാവുന്നതുപോലെ, `predictions` എന്നത് 408 x 2 ഷേപ്പുള്ള ഒരു ദ്വിമാന അറേ (two-dimensional array) ആണ് (408 എന്നത് നമ്മൾ ഉപയോഗിച്ച ഡേറ്റാസെറ്റിലെ എലമെന്റുകളുടെ എണ്ണമാണ്). `predict()`-ന് നമ്മൾ നൽകിയ ഡേറ്റാസെറ്റിലെ ഓരോ എലമെന്റിന്റെയും ലോജിറ്റുകളാണ് (logits) ഇവ ([മുൻ അധ്യായത്തിൽ](/course/chapter2) നിങ്ങൾ കണ്ടതുപോലെ, എല്ലാ Transformer മോഡലുകളും ലോജിറ്റുകളാണ് റിട്ടേൺ ചെയ്യുന്നത്). നമ്മുടെ ലേബലുകളുമായി താരതമ്യം ചെയ്യാവുന്ന പ്രവചനങ്ങളാക്കി ഇവയെ മാറ്റാൻ, രണ്ടാമത്തെ ആക്‌സിസിൽ ഏറ്റവും ഉയർന്ന മൂല്യമുള്ള ഇൻഡെക്‌സ് നമ്മൾ എടുക്കണം:
+
+```py
+import numpy as np
+
+preds = np.argmax(predictions.predictions, axis=-1)
+```
+
+ഇപ്പോൾ ആ `preds` ലേബലുകളുമായി നമുക്ക് താരതമ്യം ചെയ്യാം. നമ്മുടെ `compute_metric()` ഫംഗ്‌ഷൻ നിർമ്മിക്കാൻ, 🤗 [Evaluate](https://github.com/huggingface/evaluate/) ലൈബ്രറിയിലെ മെട്രിക്കുകളെ നമ്മൾ ആശ്രയിക്കും. ഡേറ്റാസെറ്റ് ലോഡ് ചെയ്തതുപോലെ അത്ര എളുപ്പത്തിൽ MRPC ഡേറ്റാസെറ്റുമായി ബന്ധപ്പെട്ട മെട്രിക്കുകളും ലോഡ് ചെയ്യാം; ഇത്തവണ `evaluate.load()` ഫംഗ്‌ഷൻ ഉപയോഗിച്ചാണ്. റിട്ടേൺ ചെയ്യുന്ന ഒബ്‌ജക്റ്റിന്, മെട്രിക് കണക്കുകൂട്ടലിനായി ഉപയോഗിക്കാവുന്ന ഒരു `compute()` മെത്തേഡ് ഉണ്ട്:
+
+```py
+import evaluate
+
+metric = evaluate.load("glue", "mrpc")
+metric.compute(predictions=preds, references=predictions.label_ids)
+```
+
+```python out
+{'accuracy': 0.8578431372549019, 'f1': 0.8996539792387542}
+```
+
+> [!TIP]
+> വിവിധ ഇവാല്യുവേഷൻ മെട്രിക്കുകളെയും തന്ത്രങ്ങളെയും കുറിച്ച് [🤗 Evaluate ഡോക്യുമെന്റേഷനിൽ](https://huggingface.co/docs/evaluate/) പഠിക്കുക.
+
+മോഡൽ ഹെഡിന്റെ ക്രമരഹിതമായ ഇനിഷ്യലൈസേഷൻ അത് നേടുന്ന മെട്രിക്കുകളെ മാറ്റിയേക്കാം എന്നതിനാൽ, നിങ്ങൾക്ക് ലഭിക്കുന്ന കൃത്യമായ ഫലങ്ങൾ വ്യത്യാസപ്പെടാം. ഇവിടെ, നമ്മുടെ മോഡലിന് വാലിഡേഷൻ സെറ്റിൽ 85.78% അക്യുറസിയും (accuracy) 89.97 F1 സ്‌കോറും ഉണ്ടെന്ന് കാണാം. GLUE ബെഞ്ച്‌മാർക്കിനായി MRPC ഡേറ്റാസെറ്റിലെ ഫലങ്ങൾ ഇവാല്യുവേറ്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്ന രണ്ട് മെട്രിക്കുകളാണ് ഇവ. [BERT പ്രബന്ധത്തിലെ](https://arxiv.org/pdf/1810.04805.pdf) പട്ടിക ബേസ് മോഡലിന് 88.9 എന്ന F1 സ്‌കോർ റിപ്പോർട്ട് ചെയ്തിരുന്നു. അത് `uncased` മോഡലായിരുന്നു, നമ്മൾ ഇപ്പോൾ ഉപയോഗിക്കുന്നത് `cased` മോഡലാണ്; അതാണ് മെച്ചപ്പെട്ട ഫലത്തിന്റെ കാരണം.
+
+എല്ലാം ഒരുമിച്ച് ചേർത്താൽ, നമ്മുടെ `compute_metrics()` ഫംഗ്‌ഷൻ ലഭിക്കും:
+
+```py
+def compute_metrics(eval_preds):
+    metric = evaluate.load("glue", "mrpc")
+    logits, labels = eval_preds
+    predictions = np.argmax(logits, axis=-1)
+    return metric.compute(predictions=predictions, references=labels)
+```
+
+ഓരോ എപ്പോക്കിന്റെയും അവസാനം മെട്രിക്കുകൾ റിപ്പോർട്ട് ചെയ്യാൻ ഇത് പ്രവർത്തിക്കുന്നത് കാണാൻ, ഈ `compute_metrics()` ഫംഗ്‌ഷനോടെ ഒരു പുതിയ `Trainer` എങ്ങനെ നിർവചിക്കാമെന്ന് ഇതാ:
+
+```py
+training_args = TrainingArguments("test-trainer", eval_strategy="epoch")
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
+
+trainer = Trainer(
+    model,
+    training_args,
+    train_dataset=tokenized_datasets["train"],
+    eval_dataset=tokenized_datasets["validation"],
+    data_collator=data_collator,
+    processing_class=tokenizer,
+    compute_metrics=compute_metrics,
+)
+```
+
+`eval_strategy` `"epoch"` എന്ന് സെറ്റ് ചെയ്ത ഒരു പുതിയ `TrainingArguments`-ഉം ഒരു പുതിയ മോഡലും നമ്മൾ ഉണ്ടാക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക — അല്ലാത്തപക്ഷം, ഇതിനകം ട്രെയിൻ ചെയ്ത മോഡലിന്റെ ട്രെയിനിംഗ് തുടരുകയാകും നമ്മൾ ചെയ്യുന്നത്. ഒരു പുതിയ ട്രെയിനിംഗ് റൺ ആരംഭിക്കാൻ, നമ്മൾ ഇത് എക്‌സിക്യൂട്ട് ചെയ്യുന്നു:
+
+```py
+trainer.train()
+```
+
+ഇത്തവണ, ട്രെയിനിംഗ് ലോസിനൊപ്പം ഓരോ എപ്പോക്കിന്റെയും അവസാനം വാലിഡേഷൻ ലോസും മെട്രിക്കുകളും ഇത് റിപ്പോർട്ട് ചെയ്യും. മോഡൽ ഹെഡിന്റെ ക്രമരഹിതമായ ഇനിഷ്യലൈസേഷൻ കാരണം, നിങ്ങൾക്ക് ലഭിക്കുന്ന കൃത്യമായ അക്യുറസി/F1 സ്‌കോർ നമ്മൾ കണ്ടതിൽ നിന്ന് അൽപ്പം വ്യത്യസ്തമായിരിക്കാം, എന്നാൽ അത് ഏറെക്കുറെ അതേ പരിധിയിലായിരിക്കണം.
+
+### അഡ്വാൻസ്ഡ് ട്രെയിനിംഗ് സവിശേഷതകൾ[[advanced-training-features]]
+
+ആധുനിക ഡീപ് ലേണിംഗിലെ മികച്ച രീതികൾ എളുപ്പത്തിൽ ലഭ്യമാക്കുന്ന ധാരാളം ബിൽറ്റ്-ഇൻ സവിശേഷതകളോടെയാണ് `Trainer` വരുന്നത്:
+
+**മിക്‌സഡ് പ്രിസിഷൻ ട്രെയിനിംഗ് (Mixed Precision Training)**: വേഗതയേറിയ ട്രെയിനിംഗിനും കുറഞ്ഞ മെമ്മറി ഉപയോഗത്തിനും നിങ്ങളുടെ ട്രെയിനിംഗ് ആർഗ്യുമെന്റുകളിൽ `fp16=True` ഉപയോഗിക്കുക:
+
+```py
+training_args = TrainingArguments(
+    "test-trainer",
+    eval_strategy="epoch",
+    fp16=True,  # Enable mixed precision
+)
+```
+
+**ഗ്രേഡിയന്റ് അക്യുമുലേഷൻ (Gradient Accumulation)**: GPU മെമ്മറി പരിമിതമായിരിക്കുമ്പോൾ ഫലത്തിൽ വലിയ ബാച്ച് സൈസുകൾ ലഭിക്കാൻ:
+
+```py
+training_args = TrainingArguments(
+    "test-trainer",
+    eval_strategy="epoch",
+    per_device_train_batch_size=4,
+    gradient_accumulation_steps=4,  # Effective batch size = 4 * 4 = 16
+)
+```
+
+**ലേണിംഗ് റേറ്റ് ഷെഡ്യൂളിംഗ് (Learning Rate Scheduling)**: Trainer ഡിഫോൾട്ടായി ലീനിയർ ഡികേ (linear decay) ഉപയോഗിക്കുന്നു, എന്നാൽ ഇത് നിങ്ങൾക്ക് ഇഷ്ടാനുസൃതമാക്കാം:
+
+```py
+training_args = TrainingArguments(
+    "test-trainer",
+    eval_strategy="epoch",
+    learning_rate=2e-5,
+    lr_scheduler_type="cosine",  # Try different schedulers
+)
+```
+
+> [!TIP]
+> 🎯 **പെർഫോമൻസ് ഒപ്‌റ്റിമൈസേഷൻ**: ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ്, മെമ്മറി ഒപ്‌റ്റിമൈസേഷൻ, ഹാർഡ്‌വെയർ-നിർദ്ദിഷ്ട ഒപ്‌റ്റിമൈസേഷനുകൾ എന്നിവയുൾപ്പെടെയുള്ള കൂടുതൽ അഡ്വാൻസ്ഡ് ട്രെയിനിംഗ് ടെക്‌നിക്കുകൾക്കായി, [🤗 Transformers പെർഫോമൻസ് ഗൈഡ്](https://huggingface.co/docs/transformers/main/en/performance) പരിശോധിക്കുക.
+
+`Trainer` ഒന്നിലധികം GPU-കളിലോ TPU-കളിലോ യാതൊരു അധിക സജ്ജീകരണവുമില്ലാതെ പ്രവർത്തിക്കും, കൂടാതെ ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗിനായി ധാരാളം ഓപ്‌ഷനുകളും നൽകുന്നു. ഇത് പിന്തുണയ്ക്കുന്ന എല്ലാ കാര്യങ്ങളും അധ്യായം 10-ൽ നമ്മൾ പരിശോധിക്കും.
+
+`Trainer` API ഉപയോഗിച്ചുള്ള ഫൈൻ-ട്യൂണിംഗിന്റെ ആമുഖം ഇവിടെ അവസാനിക്കുന്നു. ഏറ്റവും സാധാരണമായ NLP ടാസ്‌ക്കുകൾക്ക് ഇത് എങ്ങനെ ചെയ്യാമെന്നതിന്റെ ഒരു ഉദാഹരണം [അധ്യായം 7](/course/chapter7)-ൽ നൽകും, എന്നാൽ ഇപ്പോൾ ഇതേ കാര്യം ശുദ്ധമായ PyTorch ട്രെയിനിംഗ് ലൂപ്പ് ഉപയോഗിച്ച് എങ്ങനെ ചെയ്യാമെന്ന് നോക്കാം.
+
+> [!TIP]
+> 📝 **കൂടുതൽ ഉദാഹരണങ്ങൾ**: [🤗 Transformers നോട്ട്‌ബുക്കുകളുടെ](https://huggingface.co/docs/transformers/main/en/notebooks) സമഗ്രമായ ശേഖരം പരിശോധിക്കുക.
+
+## സെക്‌ഷൻ ക്വിസ്[[section-quiz]]
+
+Trainer API-യെയും ഫൈൻ-ട്യൂണിംഗ് ആശയങ്ങളെയും കുറിച്ചുള്ള നിങ്ങളുടെ ധാരണ പരീക്ഷിക്കുക:
+
+### 1. Trainer-ലെ <code>processing_class</code> പാരാമീറ്ററിന്റെ ഉദ്ദേശ്യം എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "ഏത് മോഡൽ ആർക്കിടെക്ചർ ഉപയോഗിക്കണമെന്ന് ഇത് വ്യക്തമാക്കുന്നു.",
+			explain: "മോഡൽ ആർക്കിടെക്ചർ വ്യക്തമാക്കുന്നത് മോഡൽ ലോഡ് ചെയ്യുമ്പോഴാണ്, Trainer-ൽ അല്ല."
+		},
+		{
+			text: "ഡേറ്റ പ്രോസസ്സ് ചെയ്യാൻ ഏത് ടോക്കണൈസർ ഉപയോഗിക്കണമെന്ന് ഇത് Trainer-നോട് പറയുന്നു.",
+			explain: "ഏത് ടോക്കണൈസർ ഉപയോഗിക്കണമെന്ന് Trainer-ന് അറിയാൻ സഹായിക്കുന്ന, അടുത്തകാലത്ത് ചേർത്ത ഒരു പാരാമീറ്ററാണ് processing_class.",
+            correct: true
+		},
+		{
+			text: "ട്രെയിനിംഗിനുള്ള ബാച്ച് സൈസ് ഇത് നിർണ്ണയിക്കുന്നു.",
+			explain: "ബാച്ച് സൈസ് TrainingArguments-ൽ ആണ് സെറ്റ് ചെയ്യുന്നത്, processing_class വഴിയല്ല."
+		},
+        {
+			text: "ഇവാല്യുവേഷന്റെ ആവൃത്തി ഇത് നിയന്ത്രിക്കുന്നു.",
+			explain: "ഇവാല്യുവേഷന്റെ ആവൃത്തി നിയന്ത്രിക്കുന്നത് TrainingArguments-ലെ eval_strategy ആണ്."
+		}
+	]}
+/>
+
+### 2. ട്രെയിനിംഗ് സമയത്ത് എത്ര ഇടവിട്ട് ഇവാല്യുവേഷൻ നടക്കണമെന്ന് നിയന്ത്രിക്കുന്ന TrainingArguments പാരാമീറ്റർ ഏതാണ്?
+
+<Question
+	choices={[
+		{
+			text: "eval_frequency",
+			explain: "TrainingArguments-ൽ eval_frequency എന്ന ഒരു പാരാമീറ്റർ ഇല്ല."
+		},
+		{
+			text: "eval_strategy",
+			explain: "ഇവാല്യുവേഷന്റെ സമയം നിയന്ത്രിക്കാൻ eval_strategy 'epoch', 'steps', അല്ലെങ്കിൽ 'no' എന്ന് സെറ്റ് ചെയ്യാം.",
+            correct: true
+		},
+		{
+			text: "evaluation_steps",
+			explain: "ഇവാല്യുവേഷനുകൾക്കിടയിലെ സ്‌റ്റെപ്പുകളുടെ എണ്ണം eval_steps സെറ്റ് ചെയ്യുന്നു, എന്നാൽ ഇവാല്യുവേഷൻ നടക്കണോ/എപ്പോൾ നടക്കണം എന്ന് നിർണ്ണയിക്കുന്നത് eval_strategy ആണ്."
+		},
+        {
+			text: "do_eval",
+			explain: "ആധുനിക TrainingArguments-ൽ do_eval എന്ന ഒരു പാരാമീറ്റർ ഇല്ല."
+		}
+	]}
+/>
+
+### 3. TrainingArguments-ലെ <code>fp16=True</code> എന്താണ് പ്രവർത്തനക്ഷമമാക്കുന്നത്?
+
+<Question
+	choices={[
+		{
+			text: "വേഗതയേറിയ ട്രെയിനിംഗിനായി 16-ബിറ്റ് ഇന്റിജർ പ്രിസിഷൻ.",
+			explain: "fp16 എന്നത് ഫ്ലോട്ടിംഗ്-പോയിന്റ് പ്രിസിഷനെയാണ് സൂചിപ്പിക്കുന്നത്, ഇന്റിജർ പ്രിസിഷനെയല്ല."
+		},
+		{
+			text: "വേഗതയേറിയ ട്രെയിനിംഗിനും കുറഞ്ഞ മെമ്മറി ഉപയോഗത്തിനുമായി 16-ബിറ്റ് ഫ്ലോട്ടിംഗ്-പോയിന്റ് സംഖ്യകൾ ഉപയോഗിച്ചുള്ള മിക്‌സഡ് പ്രിസിഷൻ ട്രെയിനിംഗ്.",
+			explain: "മിക്‌സഡ് പ്രിസിഷൻ ട്രെയിനിംഗ് ഫോർവേഡ് പാസിന് 16-ബിറ്റ് ഫ്ലോട്ടുകളും ഗ്രേഡിയന്റുകൾക്ക് 32-ബിറ്റും ഉപയോഗിക്കുന്നു; ഇത് വേഗത കൂട്ടുകയും മെമ്മറി ഉപയോഗം കുറയ്ക്കുകയും ചെയ്യുന്നു.",
+            correct: true
+		},
+		{
+			text: "കൃത്യം 16 എപ്പോക്കുകൾ ട്രെയിൻ ചെയ്യുന്നു.",
+			explain: "fp16-ന് എപ്പോക്കുകളുടെ എണ്ണവുമായി ഒരു ബന്ധവുമില്ല."
+		},
+        {
+			text: "ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗിനായി 16 GPU-കൾ ഉപയോഗിക്കുന്നു.",
+			explain: "GPU-കളുടെ എണ്ണം fp16 പാരാമീറ്റർ കൊണ്ടല്ല നിയന്ത്രിക്കുന്നത്."
+		}
+	]}
+/>
+
+### 4. Trainer-ലെ <code>compute_metrics</code> ഫംഗ്‌ഷന്റെ പങ്ക് എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "ട്രെയിനിംഗ് സമയത്ത് ഇത് ലോസ് കണക്കാക്കുന്നു.",
+			explain: "ലോസ് കണക്കുകൂട്ടൽ മോഡൽ സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു, compute_metrics അല്ല."
+		},
+		{
+			text: "ഇത് ലോജിറ്റുകളെ പ്രവചനങ്ങളാക്കി മാറ്റുകയും അക്യുറസി, F1 പോലുള്ള ഇവാല്യുവേഷൻ മെട്രിക്കുകൾ കണക്കാക്കുകയും ചെയ്യുന്നു.",
+			explain: "compute_metrics പ്രവചനങ്ങളും ലേബലുകളും സ്വീകരിച്ച്, ഇവാല്യുവേഷനുള്ള മെട്രിക്കുകൾ റിട്ടേൺ ചെയ്യുന്നു.",
+            correct: true
+		},
+		{
+			text: "ഏത് ഒപ്‌റ്റിമൈസർ ഉപയോഗിക്കണമെന്ന് ഇത് നിർണ്ണയിക്കുന്നു.",
+			explain: "ഒപ്‌റ്റിമൈസർ തിരഞ്ഞെടുക്കുന്നത് compute_metrics കൈകാര്യം ചെയ്യുന്നില്ല."
+		},
+        {
+			text: "ഇത് ട്രെയിനിംഗ് ഡേറ്റ പ്രീപ്രോസസ്സ് ചെയ്യുന്നു.",
+			explain: "ഡേറ്റാ പ്രീപ്രോസസ്സിംഗ് ട്രെയിനിംഗിന് മുമ്പാണ് ചെയ്യുന്നത്, ഇവാല്യുവേഷൻ സമയത്ത് compute_metrics വഴിയല്ല."
+		}
+	]}
+/>
+
+### 5. Trainer-ന് ഒരു <code>eval_dataset</code> നൽകാതിരുന്നാൽ എന്ത് സംഭവിക്കും?
+
+<Question
+	choices={[
+		{
+			text: "ട്രെയിനിംഗ് ഒരു എറർ കാണിച്ച് പരാജയപ്പെടും.",
+			explain: "eval_dataset ഇല്ലാതെയും ട്രെയിനിംഗ് മുന്നോട്ട് പോകും, എന്നാൽ ഇവാല്യുവേഷൻ മെട്രിക്കുകൾ നിങ്ങൾക്ക് ലഭിക്കില്ല."
+		},
+		{
+			text: "ഇവാല്യുവേഷനായി Trainer ട്രെയിനിംഗ് ഡേറ്റ സ്വയമേവ വിഭജിക്കും.",
+			explain: "Trainer സ്വയമേവ വാലിഡേഷൻ സ്‌പ്ലിറ്റുകൾ ഉണ്ടാക്കുന്നില്ല."
+		},
+		{
+			text: "ട്രെയിനിംഗ് സമയത്ത് ഇവാല്യുവേഷൻ മെട്രിക്കുകൾ ലഭിക്കില്ല, എന്നാൽ ട്രെയിനിംഗ് പ്രവർത്തിക്കും.",
+			explain: "ഇവാല്യുവേഷൻ ഓപ്‌ഷണലാണ് - അതില്ലാതെയും നിങ്ങൾക്ക് ട്രെയിൻ ചെയ്യാം, എന്നാൽ വാലിഡേഷൻ മെട്രിക്കുകൾ കാണാൻ കഴിയില്ല.",
+            correct: true
+		},
+        {
+			text: "ഇവാല്യുവേഷനായി മോഡൽ ട്രെയിനിംഗ് ഡേറ്റ ഉപയോഗിക്കും.",
+			explain: "Trainer ഇവാല്യുവേഷനായി ട്രെയിനിംഗ് ഡേറ്റ സ്വയമേവ ഉപയോഗിക്കില്ല - അത് ഇവാല്യുവേറ്റ് ചെയ്യാതിരിക്കും, അത്രമാത്രം."
+		}
+	]}
+/>
+
+### 6. ഗ്രേഡിയന്റ് അക്യുമുലേഷൻ എന്താണ്, അത് എങ്ങനെ പ്രവർത്തനക്ഷമമാക്കാം?
+
+<Question
+	choices={[
+		{
+			text: "ഇത് ഗ്രേഡിയന്റുകൾ ഡിസ്‌കിലേക്ക് സേവ് ചെയ്യുന്നു; save_gradients=True ഉപയോഗിച്ച് പ്രവർത്തനക്ഷമമാക്കാം.",
+			explain: "ഗ്രേഡിയന്റ് അക്യുമുലേഷനിൽ ഗ്രേഡിയന്റുകൾ ഡിസ്‌കിലേക്ക് സേവ് ചെയ്യുന്നില്ല."
+		},
+		{
+			text: "അപ്‌ഡേറ്റ് ചെയ്യുന്നതിന് മുമ്പ് ഒന്നിലധികം ബാച്ചുകളിലായി ഇത് ഗ്രേഡിയന്റുകൾ സഞ്ചയിക്കുന്നു; gradient_accumulation_steps ഉപയോഗിച്ച് പ്രവർത്തനക്ഷമമാക്കാം.",
+			explain: "ഒന്നിലധികം ഫോർവേഡ് പാസുകളിലായി ഗ്രേഡിയന്റുകൾ സഞ്ചയിച്ചുകൊണ്ട് വലിയ ബാച്ച് സൈസുകൾ അനുകരിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.",
+            correct: true
+		},
+		{
+			text: "ഇത് ഗ്രേഡിയന്റ് കണക്കുകൂട്ടൽ വേഗത്തിലാക്കുന്നു; fp16 ഉപയോഗിക്കുമ്പോൾ സ്വയമേവ പ്രവർത്തനക്ഷമമാകുന്നു.",
+			explain: "fp16 ട്രെയിനിംഗ് വേഗത്തിലാക്കുമെങ്കിലും, ഗ്രേഡിയന്റ് അക്യുമുലേഷൻ ഒരു വ്യത്യസ്ത ടെക്‌നിക്കാണ്."
+		},
+        {
+			text: "ഇത് ഗ്രേഡിയന്റ് ഓവർഫ്ലോ തടയുന്നു; gradient_clipping=True ഉപയോഗിച്ച് പ്രവർത്തനക്ഷമമാക്കാം.",
+			explain: "അത് ഗ്രേഡിയന്റ് ക്ലിപ്പിംഗിന്റെ വിവരണമാണ്, ഗ്രേഡിയന്റ് അക്യുമുലേഷന്റേതല്ല."
+		}
+	]}
+/>
+
+> [!TIP]
+> 💡 **പ്രധാന പാഠങ്ങൾ:**
+> - `Trainer` API ട്രെയിനിംഗിന്റെ സങ്കീർണ്ണതകളിൽ മിക്കതും കൈകാര്യം ചെയ്യുന്ന ഒരു ഉയർന്ന തലത്തിലുള്ള (high-level) ഇന്റർഫേസ് നൽകുന്നു
+> - ശരിയായ ഡേറ്റാ കൈകാര്യത്തിനായി നിങ്ങളുടെ ടോക്കണൈസർ വ്യക്തമാക്കാൻ `processing_class` ഉപയോഗിക്കുക
+> - `TrainingArguments` ട്രെയിനിംഗിന്റെ എല്ലാ വശങ്ങളും നിയന്ത്രിക്കുന്നു: ലേണിംഗ് റേറ്റ്, ബാച്ച് സൈസ്, ഇവാല്യുവേഷൻ സ്‌ട്രാറ്റജി, ഒപ്‌റ്റിമൈസേഷനുകൾ
+> - ട്രെയിനിംഗ് ലോസിനപ്പുറം ഇഷ്ടാനുസൃത ഇവാല്യുവേഷൻ മെട്രിക്കുകൾ `compute_metrics` സാധ്യമാക്കുന്നു
+> - മിക്‌സഡ് പ്രിസിഷൻ (`fp16=True`), ഗ്രേഡിയന്റ് അക്യുമുലേഷൻ പോലുള്ള ആധുനിക സവിശേഷതകൾ ട്രെയിനിംഗ് കാര്യക്ഷമത ഗണ്യമായി മെച്ചപ്പെടുത്തും
+

From c086a132f77d7e883b1636a0b51e3d290ccc14d5 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 13:42:45 +0530
Subject: [PATCH 34/44] Add Malayalam translation for chapter3/4.mdx

---
 chapters/ml/chapter3/4.mdx | 543 +++++++++++++++++++++++++++++++++++++
 1 file changed, 543 insertions(+)
 create mode 100644 chapters/ml/chapter3/4.mdx

diff --git a/chapters/ml/chapter3/4.mdx b/chapters/ml/chapter3/4.mdx
new file mode 100644
index 000000000..088c0741a
--- /dev/null
+++ b/chapters/ml/chapter3/4.mdx
@@ -0,0 +1,543 @@
+# ഒരു പൂർണ്ണ ട്രെയിനിംഗ് ലൂപ്പ്[[a-full-training]]
+
+<CourseFloatingBanner chapter={3}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter3/section4.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter3/section4.ipynb"},
+]} />
+
+<Youtube id="Dh9CL8fyG80"/>
+
+`Trainer` ക്ലാസ് ഉപയോഗിക്കാതെ, ആധുനിക PyTorch മികച്ച രീതികൾ (best practices) പിന്തുടർന്ന് തുടക്കം മുതൽ ഒരു ട്രെയിനിംഗ് ലൂപ്പ് ഇംപ്ലിമെന്റ് ചെയ്തുകൊണ്ട്, കഴിഞ്ഞ വിഭാഗത്തിൽ നേടിയ അതേ ഫലങ്ങൾ എങ്ങനെ നേടാം എന്ന് ഇനി നമ്മൾ നോക്കും. വിഭാഗം 2-ലെ ഡേറ്റ പ്രോസസ്സിംഗ് നിങ്ങൾ ചെയ്തിട്ടുണ്ടെന്ന് ഇവിടെയും നമ്മൾ അനുമാനിക്കുന്നു. നിങ്ങൾക്ക് ആവശ്യമായതെല്ലാം ഉൾക്കൊള്ളുന്ന ഒരു ചെറിയ സംഗ്രഹം ഇതാ:
+
+> [!TIP]
+> 🏗️ **തുടക്കം മുതൽ ട്രെയിൻ ചെയ്യുന്നു**: ഈ വിഭാഗം മുൻ ഉള്ളടക്കത്തിന്മേൽ കെട്ടിപ്പടുത്തിരിക്കുന്നതാണ്. PyTorch ട്രെയിനിംഗ് ലൂപ്പുകളെയും മികച്ച രീതികളെയും കുറിച്ചുള്ള സമഗ്രമായ മാർഗ്ഗനിർദ്ദേശങ്ങൾക്ക്, [🤗 Transformers ട്രെയിനിംഗ് ഡോക്യുമെന്റേഷനും](https://huggingface.co/docs/transformers/main/en/training#train-in-native-pytorch) [കസ്‌റ്റം ട്രെയിനിംഗ് കുക്ക്‌ബുക്കും](https://huggingface.co/learn/cookbook/en/fine_tuning_code_llm_on_single_gpu#model) നോക്കുക.
+
+```py
+from datasets import load_dataset
+from transformers import AutoTokenizer, DataCollatorWithPadding
+
+raw_datasets = load_dataset("glue", "mrpc")
+checkpoint = "bert-base-uncased"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+
+
+def tokenize_function(example):
+    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)
+
+
+tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
+data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+```
+
+### ട്രെയിനിംഗിനായി തയ്യാറെടുക്കുന്നു[[prepare-for-training]]
+
+നമ്മുടെ ട്രെയിനിംഗ് ലൂപ്പ് യഥാർത്ഥത്തിൽ എഴുതുന്നതിന് മുമ്പ്, ഏതാനും ഒബ്‌ജക്റ്റുകൾ നമുക്ക് നിർവചിക്കേണ്ടതുണ്ട്. ബാച്ചുകളിലൂടെ ആവർത്തിച്ച് കടന്നുപോകാൻ (iterate) നമ്മൾ ഉപയോഗിക്കുന്ന ഡേറ്റാലോഡറുകളാണ് (dataloaders) ആദ്യത്തേത്. എന്നാൽ ആ ഡേറ്റാലോഡറുകൾ നിർവചിക്കുന്നതിന് മുമ്പ്, `Trainer` നമുക്കായി സ്വയമേവ ചെയ്തുതന്ന ചില കാര്യങ്ങൾ കൈകാര്യം ചെയ്യാൻ, നമ്മുടെ `tokenized_datasets`-ൽ കുറച്ച് പോസ്‌റ്റ്‌പ്രോസസ്സിംഗ് നമുക്ക് ചെയ്യേണ്ടതുണ്ട്. കൃത്യമായി പറഞ്ഞാൽ, നമ്മൾ ചെയ്യേണ്ടത്:
+
+- മോഡൽ പ്രതീക്ഷിക്കാത്ത മൂല്യങ്ങളുമായി ബന്ധപ്പെട്ട കോളങ്ങൾ (`sentence1`, `sentence2` കോളങ്ങൾ പോലുള്ളവ) നീക്കം ചെയ്യുക.
+- `label` എന്ന കോളത്തിന്റെ പേര് `labels` എന്നാക്കി മാറ്റുക (കാരണം ആർഗ്യുമെന്റിന്റെ പേര് `labels` ആയിരിക്കണമെന്നാണ് മോഡൽ പ്രതീക്ഷിക്കുന്നത്).
+- ലിസ്‌റ്റുകൾക്ക് പകരം PyTorch ടെൻസറുകൾ റിട്ടേൺ ചെയ്യുന്ന വിധത്തിൽ ഡേറ്റാസെറ്റുകളുടെ ഫോർമാറ്റ് സെറ്റ് ചെയ്യുക.
+
+ഈ ഓരോ ഘട്ടത്തിനും നമ്മുടെ `tokenized_datasets`-ൽ ഒരു മെത്തേഡ് വീതമുണ്ട്:
+
+```py
+tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"])
+tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+tokenized_datasets.set_format("torch")
+tokenized_datasets["train"].column_names
+```
+
+നമ്മുടെ മോഡൽ സ്വീകരിക്കുന്ന കോളങ്ങൾ മാത്രമേ ഫലത്തിൽ ഉള്ളൂ എന്ന് പിന്നീട് നമുക്ക് പരിശോധിക്കാം:
+
+```python
+["attention_mask", "input_ids", "labels", "token_type_ids"]
+```
+
+ഇത് പൂർത്തിയായ സ്ഥിതിക്ക്, നമ്മുടെ ഡേറ്റാലോഡറുകൾ എളുപ്പത്തിൽ നിർവചിക്കാം:
+
+```py
+from torch.utils.data import DataLoader
+
+train_dataloader = DataLoader(
+    tokenized_datasets["train"], shuffle=True, batch_size=8, collate_fn=data_collator
+)
+eval_dataloader = DataLoader(
+    tokenized_datasets["validation"], batch_size=8, collate_fn=data_collator
+)
+```
+
+ഡേറ്റ പ്രോസസ്സിംഗിൽ തെറ്റുകളൊന്നുമില്ലെന്ന് വേഗത്തിൽ ഉറപ്പുവരുത്താൻ, ഒരു ബാച്ച് ഇങ്ങനെ പരിശോധിക്കാം:
+
+```py
+for batch in train_dataloader:
+    break
+{k: v.shape for k, v in batch.items()}
+```
+
+```python out
+{'attention_mask': torch.Size([8, 65]),
+ 'input_ids': torch.Size([8, 65]),
+ 'labels': torch.Size([8]),
+ 'token_type_ids': torch.Size([8, 65])}
+```
+
+ട്രെയിനിംഗ് ഡേറ്റാലോഡറിന് `shuffle=True` എന്ന് സെറ്റ് ചെയ്തിരിക്കുന്നതിനാലും ബാച്ചിനുള്ളിലെ പരമാവധി നീളത്തിലേക്ക് നമ്മൾ പാഡിംഗ് ചെയ്യുന്നതിനാലും, യഥാർത്ഥ ഷേപ്പുകൾ (shapes) നിങ്ങൾക്ക് ഒരുപക്ഷേ ചെറുതായി വ്യത്യസ്തമായിരിക്കും എന്നത് ശ്രദ്ധിക്കുക.
+
+ഡേറ്റ പ്രീപ്രോസസ്സിംഗ് പൂർണ്ണമായി തീർന്ന സ്ഥിതിക്ക് (ഏതൊരു ML പ്രാക്റ്റീഷണർക്കും സംതൃപ്തി നൽകുന്ന, എന്നാൽ അപൂർവ്വമായി മാത്രം കൈവരുന്ന ഒരു ലക്ഷ്യം), ഇനി മോഡലിലേക്ക് തിരിയാം. മുൻ വിഭാഗത്തിൽ ചെയ്തതുപോലെ തന്നെ നമ്മൾ അത് ഇൻസ്‌റ്റാൻഷിയേറ്റ് ചെയ്യുന്നു:
+
+```py
+from transformers import AutoModelForSequenceClassification
+
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
+```
+
+ട്രെയിനിംഗ് സമയത്ത് എല്ലാം സുഗമമായി നടക്കുമെന്ന് ഉറപ്പാക്കാൻ, നമ്മുടെ ബാച്ച് ഈ മോഡലിലേക്ക് നൽകുന്നു:
+
+```py
+outputs = model(**batch)
+print(outputs.loss, outputs.logits.shape)
+```
+
+```python out
+tensor(0.5441, grad_fn=<NllLossBackward>) torch.Size([8, 2])
+```
+
+`labels` നൽകുമ്പോൾ എല്ലാ 🤗 Transformers മോഡലുകളും ലോസ് (loss) റിട്ടേൺ ചെയ്യും; കൂടാതെ ലോജിറ്റുകളും (logits) നമുക്ക് ലഭിക്കും (നമ്മുടെ ബാച്ചിലെ ഓരോ ഇൻപുട്ടിനും രണ്ട് വീതം, അതിനാൽ 8 x 2 വലിപ്പമുള്ള ഒരു ടെൻസർ).
+
+നമ്മുടെ ട്രെയിനിംഗ് ലൂപ്പ് എഴുതാൻ നമ്മൾ ഏകദേശം തയ്യാറായി! രണ്ട് കാര്യങ്ങൾ മാത്രമാണ് ഇനി വേണ്ടത്: ഒരു ഒപ്‌റ്റിമൈസറും (optimizer) ഒരു ലേണിംഗ് റേറ്റ് ഷെഡ്യൂളറും (learning rate scheduler). `Trainer` ചെയ്തിരുന്നത് സ്വന്തമായി പുനഃസൃഷ്ടിക്കാനാണ് നമ്മൾ ശ്രമിക്കുന്നത് എന്നതിനാൽ, അതേ ഡിഫോൾട്ടുകൾ തന്നെ ഉപയോഗിക്കും. `Trainer` ഉപയോഗിക്കുന്ന ഒപ്‌റ്റിമൈസർ `AdamW` ആണ്; ഇത് Adam-ന് തുല്യമാണ്, എന്നാൽ വെയ്‌റ്റ് ഡികേ റെഗുലറൈസേഷനിൽ (weight decay regularization) ഒരു ചെറിയ മാറ്റമുണ്ട് (Ilya Loshchilov, Frank Hutter എന്നിവരുടെ ["Decoupled Weight Decay Regularization"](https://arxiv.org/abs/1711.05101) കാണുക):
+
+```py
+from torch.optim import AdamW
+
+optimizer = AdamW(model.parameters(), lr=5e-5)
+```
+
+> [!TIP]
+> 💡 **ആധുനിക ഒപ്‌റ്റിമൈസേഷൻ നുറുങ്ങുകൾ**: കൂടുതൽ മികച്ച പ്രകടനത്തിനായി, ഇവ പരീക്ഷിക്കാം:
+> - **വെയ്‌റ്റ് ഡികേയോടുകൂടിയ AdamW**: `AdamW(model.parameters(), lr=5e-5, weight_decay=0.01)`
+> - **8-bit Adam**: മെമ്മറി-കാര്യക്ഷമമായ ഒപ്‌റ്റിമൈസേഷനായി `bitsandbytes` ഉപയോഗിക്കുക
+> - **വ്യത്യസ്ത ലേണിംഗ് റേറ്റുകൾ**: വലിയ മോഡലുകൾക്ക് കുറഞ്ഞ ലേണിംഗ് റേറ്റുകൾ (1e-5 മുതൽ 3e-5 വരെ) പലപ്പോഴും കൂടുതൽ നന്നായി പ്രവർത്തിക്കും
+>
+> 🚀 **ഒപ്‌റ്റിമൈസേഷൻ വിഭവങ്ങൾ**: ഒപ്‌റ്റിമൈസറുകളെയും ട്രെയിനിംഗ് തന്ത്രങ്ങളെയും കുറിച്ച് കൂടുതൽ അറിയാൻ [🤗 Transformers ഒപ്‌റ്റിമൈസേഷൻ ഗൈഡ്](https://huggingface.co/docs/transformers/main/en/performance#optimizer) കാണുക.
+
+അവസാനമായി, ഡിഫോൾട്ടായി ഉപയോഗിക്കുന്ന ലേണിംഗ് റേറ്റ് ഷെഡ്യൂളർ പരമാവധി മൂല്യത്തിൽ (5e-5) നിന്ന് 0-ലേക്കുള്ള ഒരു ലീനിയർ ഡികേ (linear decay) മാത്രമാണ്. ഇത് ശരിയായി നിർവചിക്കാൻ, നമ്മൾ എടുക്കുന്ന ട്രെയിനിംഗ് സ്‌റ്റെപ്പുകളുടെ എണ്ണം അറിയേണ്ടതുണ്ട്; അത് നമുക്ക് റൺ ചെയ്യേണ്ട എപ്പോക്കുകളുടെ (epochs) എണ്ണത്തെ ട്രെയിനിംഗ് ബാച്ചുകളുടെ എണ്ണം (അതായത് നമ്മുടെ ട്രെയിനിംഗ് ഡേറ്റാലോഡറിന്റെ നീളം) കൊണ്ട് ഗുണിച്ചതാണ്. `Trainer` ഡിഫോൾട്ടായി മൂന്ന് എപ്പോക്കുകൾ ഉപയോഗിക്കുന്നു, അതിനാൽ നമ്മളും അത് പിന്തുടരും:
+
+```py
+from transformers import get_scheduler
+
+num_epochs = 3
+num_training_steps = num_epochs * len(train_dataloader)
+lr_scheduler = get_scheduler(
+    "linear",
+    optimizer=optimizer,
+    num_warmup_steps=0,
+    num_training_steps=num_training_steps,
+)
+print(num_training_steps)
+```
+
+```python out
+1377
+```
+
+### ട്രെയിനിംഗ് ലൂപ്പ്[[the-training-loop]]
+
+അവസാനത്തെ ഒരു കാര്യം: ഒരു GPU ലഭ്യമാണെങ്കിൽ അത് ഉപയോഗിക്കാൻ നമ്മൾ ആഗ്രഹിക്കും (ഒരു CPU-വിൽ, ട്രെയിനിംഗിന് ഏതാനും മിനിറ്റുകൾക്ക് പകരം മണിക്കൂറുകൾ എടുത്തേക്കാം). ഇതിനായി, നമ്മുടെ മോഡലും ബാച്ചുകളും വയ്ക്കാനുള്ള ഒരു `device` നമ്മൾ നിർവചിക്കുന്നു:
+
+```py
+import torch
+
+device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+model.to(device)
+device
+```
+
+```python out
+device(type='cuda')
+```
+
+ഇനി നമ്മൾ ട്രെയിൻ ചെയ്യാൻ തയ്യാറാണ്! ട്രെയിനിംഗ് എപ്പോൾ പൂർത്തിയാകും എന്നതിനെക്കുറിച്ച് ഒരു ധാരണ ലഭിക്കാൻ, `tqdm` ലൈബ്രറി ഉപയോഗിച്ച് നമ്മുടെ ട്രെയിനിംഗ് സ്‌റ്റെപ്പുകളുടെ എണ്ണത്തിന് മേൽ ഒരു പ്രോഗ്രസ് ബാർ ചേർക്കുന്നു:
+
+```py
+from tqdm.auto import tqdm
+
+progress_bar = tqdm(range(num_training_steps))
+
+model.train()
+for epoch in range(num_epochs):
+    for batch in train_dataloader:
+        batch = {k: v.to(device) for k, v in batch.items()}
+        outputs = model(**batch)
+        loss = outputs.loss
+        loss.backward()
+
+        optimizer.step()
+        lr_scheduler.step()
+        optimizer.zero_grad()
+        progress_bar.update(1)
+```
+
+> [!TIP]
+> 💡 **ആധുനിക ട്രെയിനിംഗ് ഒപ്‌റ്റിമൈസേഷനുകൾ**: നിങ്ങളുടെ ട്രെയിനിംഗ് ലൂപ്പ് കൂടുതൽ കാര്യക്ഷമമാക്കാൻ, ഇവ പരിഗണിക്കുക:
+>
+> - **ഗ്രേഡിയന്റ് ക്ലിപ്പിംഗ് (Gradient Clipping)**: `optimizer.step()`-ന് മുമ്പ് `torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)` ചേർക്കുക
+> - **മിക്‌സഡ് പ്രിസിഷൻ (Mixed Precision)**: വേഗത്തിലുള്ള ട്രെയിനിംഗിനായി `torch.cuda.amp.autocast()`, `GradScaler` എന്നിവ ഉപയോഗിക്കുക
+> - **ഗ്രേഡിയന്റ് അക്യുമുലേഷൻ (Gradient Accumulation)**: വലിയ ബാച്ച് സൈസുകൾ അനുകരിക്കാൻ ഒന്നിലധികം ബാച്ചുകളിലായി ഗ്രേഡിയന്റുകൾ സംഭരിക്കുക
+> - **ചെക്ക്‌പോയിന്റിംഗ് (Checkpointing)**: ട്രെയിനിംഗ് തടസ്സപ്പെട്ടാൽ പുനരാരംഭിക്കാൻ കഴിയുന്ന വിധത്തിൽ മോഡൽ ചെക്ക്‌പോയിന്റുകൾ ഇടയ്ക്കിടെ സേവ് ചെയ്യുക
+>
+> 🔧 **ഇംപ്ലിമെന്റേഷൻ ഗൈഡ്**: ഈ ഒപ്‌റ്റിമൈസേഷനുകളുടെ വിശദമായ ഉദാഹരണങ്ങൾക്ക്, [🤗 Transformers കാര്യക്ഷമ ട്രെയിനിംഗ് ഗൈഡും](https://huggingface.co/docs/transformers/main/en/perf_train_gpu_one) [ലഭ്യമായ ഒപ്‌റ്റിമൈസറുകളുടെ പട്ടികയും](https://huggingface.co/docs/transformers/main/en/optimizers) കാണുക.
+
+ട്രെയിനിംഗ് ലൂപ്പിന്റെ കാതലായ ഭാഗം ആമുഖത്തിൽ കണ്ടതിനോട് ഏറെ സാമ്യമുള്ളതാണെന്ന് നിങ്ങൾക്ക് കാണാം. നമ്മൾ ഒരു റിപ്പോർട്ടിംഗും ആവശ്യപ്പെട്ടിട്ടില്ല, അതിനാൽ മോഡൽ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് ഈ ട്രെയിനിംഗ് ലൂപ്പ് നമ്മോട് ഒന്നും പറയില്ല. അതിനായി ഒരു ഇവാലുവേഷൻ ലൂപ്പ് (evaluation loop) നമുക്ക് ചേർക്കേണ്ടതുണ്ട്.
+
+
+### ഇവാലുവേഷൻ ലൂപ്പ്[[the-evaluation-loop]]
+
+മുമ്പ് ചെയ്തതുപോലെ, 🤗 Evaluate ലൈബ്രറി നൽകുന്ന ഒരു മെട്രിക് നമ്മൾ ഉപയോഗിക്കും. `metric.compute()` മെത്തേഡ് നമ്മൾ ഇതിനകം കണ്ടിട്ടുണ്ട്, എന്നാൽ പ്രെഡിക്‌ഷൻ ലൂപ്പിലൂടെ കടന്നുപോകുമ്പോൾ `add_batch()` മെത്തേഡ് ഉപയോഗിച്ച് മെട്രിക്കുകൾക്ക് നമുക്കായി ബാച്ചുകൾ സംഭരിച്ചുവയ്ക്കാനും കഴിയും. എല്ലാ ബാച്ചുകളും സംഭരിച്ചുകഴിഞ്ഞാൽ, `metric.compute()` ഉപയോഗിച്ച് അന്തിമ ഫലം നമുക്ക് ലഭിക്കും. ഇതെല്ലാം ഒരു ഇവാലുവേഷൻ ലൂപ്പിൽ എങ്ങനെ ഇംപ്ലിമെന്റ് ചെയ്യാം എന്ന് ഇതാ:
+
+> [!TIP]
+> 📊 **ഇവാലുവേഷനിലെ മികച്ച രീതികൾ**: കൂടുതൽ സങ്കീർണ്ണമായ ഇവാലുവേഷൻ തന്ത്രങ്ങൾക്കും മെട്രിക്കുകൾക്കും, [🤗 Evaluate ഡോക്യുമെന്റേഷനും](https://huggingface.co/docs/evaluate/) [സമഗ്രമായ ഇവാലുവേഷൻ കുക്ക്‌ബുക്കും](https://github.com/huggingface/evaluation-guidebook) പരിശോധിക്കുക.
+
+```py
+import evaluate
+
+metric = evaluate.load("glue", "mrpc")
+model.eval()
+for batch in eval_dataloader:
+    batch = {k: v.to(device) for k, v in batch.items()}
+    with torch.no_grad():
+        outputs = model(**batch)
+
+    logits = outputs.logits
+    predictions = torch.argmax(logits, dim=-1)
+    metric.add_batch(predictions=predictions, references=batch["labels"])
+
+metric.compute()
+```
+
+```python out
+{'accuracy': 0.8431372549019608, 'f1': 0.8907849829351535}
+```
+
+മോഡൽ ഹെഡിന്റെ ഇനിഷ്യലൈസേഷനിലെയും ഡേറ്റ ഷഫ്‌ളിംഗിലെയും റാൻഡംനെസ് കാരണം നിങ്ങളുടെ ഫലങ്ങൾ ഇവിടെയും ചെറുതായി വ്യത്യസ്തമായിരിക്കും, എന്നാൽ അവ ഏകദേശം ഇതേ പരിധിയിൽ തന്നെ വരണം.
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** SST-2 ഡേറ്റാസെറ്റിൽ നിങ്ങളുടെ മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ മുമ്പത്തെ ട്രെയിനിംഗ് ലൂപ്പ് പരിഷ്‌കരിക്കുക.
+
+### 🤗 Accelerate ഉപയോഗിച്ച് നിങ്ങളുടെ ട്രെയിനിംഗ് ലൂപ്പിന് കൂടുതൽ കരുത്ത് പകരുക[[supercharge-your-training-loop-with-accelerate]]
+
+<Youtube id="s7dy8QRgjJ0" />
+
+നമ്മൾ മുമ്പ് നിർവചിച്ച ട്രെയിനിംഗ് ലൂപ്പ് ഒരൊറ്റ CPU-വിലോ GPU-വിലോ നന്നായി പ്രവർത്തിക്കും. എന്നാൽ [🤗 Accelerate](https://github.com/huggingface/accelerate) ലൈബ്രറി ഉപയോഗിച്ച്, ഏതാനും ചെറിയ മാറ്റങ്ങൾ മാത്രം വരുത്തി, ഒന്നിലധികം GPU-കളിലോ TPU-കളിലോ ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ് (distributed training) നമുക്ക് സാധ്യമാക്കാം. ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ്, മിക്‌സഡ് പ്രിസിഷൻ, ഡിവൈസ് പ്ലേസ്‌മെന്റ് എന്നിവയുടെ സങ്കീർണ്ണതകൾ 🤗 Accelerate സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു. ട്രെയിനിംഗ്, വാലിഡേഷൻ ഡേറ്റാലോഡറുകൾ സൃഷ്ടിക്കുന്നിടത്തു നിന്ന് തുടങ്ങിയാൽ, നമ്മുടെ മാനുവൽ ട്രെയിനിംഗ് ലൂപ്പ് ഇങ്ങനെയാണ് കാണപ്പെടുന്നത്:
+
+> [!TIP]
+> ⚡ **Accelerate-ലേക്ക് ആഴത്തിൽ**: ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ്, മിക്‌സഡ് പ്രിസിഷൻ, ഹാർഡ്‌വെയർ ഒപ്‌റ്റിമൈസേഷൻ എന്നിവയെക്കുറിച്ച് എല്ലാം [🤗 Accelerate ഡോക്യുമെന്റേഷനിൽ](https://huggingface.co/docs/accelerate/) പഠിക്കുക, [transformers ഡോക്യുമെന്റേഷനിലെ](https://huggingface.co/docs/transformers/main/en/accelerate) പ്രായോഗിക ഉദാഹരണങ്ങൾ പരിശോധിക്കുക.
+
+```py
+from accelerate import Accelerator
+from torch.optim import AdamW
+from transformers import AutoModelForSequenceClassification, get_scheduler
+
+accelerator = Accelerator()
+
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
+optimizer = AdamW(model.parameters(), lr=3e-5)
+
+train_dl, eval_dl, model, optimizer = accelerator.prepare(
+    train_dataloader, eval_dataloader, model, optimizer
+)
+
+num_epochs = 3
+num_training_steps = num_epochs * len(train_dl)
+lr_scheduler = get_scheduler(
+    "linear",
+    optimizer=optimizer,
+    num_warmup_steps=0,
+    num_training_steps=num_training_steps,
+)
+
+progress_bar = tqdm(range(num_training_steps))
+
+model.train()
+for epoch in range(num_epochs):
+    for batch in train_dl:
+        outputs = model(**batch)
+        loss = outputs.loss
+        accelerator.backward(loss)
+
+        optimizer.step()
+        lr_scheduler.step()
+        optimizer.zero_grad()
+        progress_bar.update(1)
+```
+
+ചേർക്കേണ്ട ആദ്യ വരി ഇംപോർട്ട് വരിയാണ്. രണ്ടാമത്തെ വരി ഒരു `Accelerator` ഒബ്‌ജക്റ്റ് ഇൻസ്‌റ്റാൻഷിയേറ്റ് ചെയ്യുന്നു; അത് പരിസ്ഥിതി (environment) പരിശോധിച്ച് ശരിയായ ഡിസ്‌ട്രിബ്യൂട്ടഡ് സെറ്റപ്പ് ഇനിഷ്യലൈസ് ചെയ്യും. ഡിവൈസ് പ്ലേസ്‌മെന്റ് 🤗 Accelerate നിങ്ങൾക്കായി കൈകാര്യം ചെയ്യുന്നു, അതിനാൽ മോഡലിനെ ഡിവൈസിൽ വയ്ക്കുന്ന വരികൾ നിങ്ങൾക്ക് നീക്കം ചെയ്യാം (അല്ലെങ്കിൽ, വേണമെങ്കിൽ, `device`-ന് പകരം `accelerator.device` ഉപയോഗിക്കുന്ന വിധത്തിൽ അവ മാറ്റാം).
+
+പിന്നീട്, ഡേറ്റാലോഡറുകളും മോഡലും ഒപ്‌റ്റിമൈസറും `accelerator.prepare()`-ലേക്ക് അയയ്ക്കുന്ന വരിയിലാണ് പ്രധാന ജോലിയുടെ സിംഹഭാഗവും നടക്കുന്നത്. നിങ്ങളുടെ ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ് ഉദ്ദേശിച്ചതുപോലെ പ്രവർത്തിക്കുമെന്ന് ഉറപ്പാക്കാൻ ഇത് ആ ഒബ്‌ജക്റ്റുകളെ ശരിയായ കണ്ടെയ്‌നറിൽ പൊതിയും (wrap). ബാക്കി വരുത്തേണ്ട മാറ്റങ്ങൾ ഇവയാണ്: ബാച്ചിനെ `device`-ൽ വയ്ക്കുന്ന വരി നീക്കം ചെയ്യുക (ഇത് നിലനിർത്തണമെങ്കിൽ, `accelerator.device` ഉപയോഗിക്കുന്ന വിധത്തിൽ മാറ്റിയാൽ മതി), `loss.backward()`-ന് പകരം `accelerator.backward(loss)` ഉപയോഗിക്കുക.
+
+> [!TIP]
+> ⚠️ Cloud TPU-കൾ നൽകുന്ന വേഗതാവർദ്ധനവ് പ്രയോജനപ്പെടുത്താൻ, ടോക്കണൈസറിന്റെ `padding="max_length"`, `max_length` എന്നീ ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ സാമ്പിളുകൾ ഒരു നിശ്ചിത നീളത്തിലേക്ക് പാഡ് ചെയ്യാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.
+
+കോപ്പി-പേസ്‌റ്റ് ചെയ്ത് പരീക്ഷിച്ചുനോക്കാൻ നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, 🤗 Accelerate ഉപയോഗിച്ചുള്ള പൂർണ്ണമായ ട്രെയിനിംഗ് ലൂപ്പ് ഇങ്ങനെയാണ്:
+
+```py
+from accelerate import Accelerator
+from torch.optim import AdamW
+from transformers import AutoModelForSequenceClassification, get_scheduler
+
+accelerator = Accelerator()
+
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
+optimizer = AdamW(model.parameters(), lr=3e-5)
+
+train_dl, eval_dl, model, optimizer = accelerator.prepare(
+    train_dataloader, eval_dataloader, model, optimizer
+)
+
+num_epochs = 3
+num_training_steps = num_epochs * len(train_dl)
+lr_scheduler = get_scheduler(
+    "linear",
+    optimizer=optimizer,
+    num_warmup_steps=0,
+    num_training_steps=num_training_steps,
+)
+
+progress_bar = tqdm(range(num_training_steps))
+
+model.train()
+for epoch in range(num_epochs):
+    for batch in train_dl:
+        outputs = model(**batch)
+        loss = outputs.loss
+        accelerator.backward(loss)
+
+        optimizer.step()
+        lr_scheduler.step()
+        optimizer.zero_grad()
+        progress_bar.update(1)
+```
+
+ഇത് ഒരു `train.py` സ്‌ക്രിപ്‌റ്റിൽ ഇട്ടാൽ, ഏതുതരം ഡിസ്‌ട്രിബ്യൂട്ടഡ് സെറ്റപ്പിലും ആ സ്‌ക്രിപ്‌റ്റ് റൺ ചെയ്യാൻ കഴിയും. നിങ്ങളുടെ ഡിസ്‌ട്രിബ്യൂട്ടഡ് സെറ്റപ്പിൽ ഇത് പരീക്ഷിക്കാൻ, ഈ കമാൻഡ് റൺ ചെയ്യുക:
+
+```bash
+accelerate config
+```
+
+ഇത് ഏതാനും ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകാൻ നിങ്ങളോട് ആവശ്യപ്പെടുകയും, നിങ്ങളുടെ ഉത്തരങ്ങൾ താഴെപ്പറയുന്ന കമാൻഡ് ഉപയോഗിക്കുന്ന ഒരു കോൻഫിഗറേഷൻ ഫയലിൽ എഴുതിവയ്ക്കുകയും ചെയ്യും:
+
+```
+accelerate launch train.py
+```
+
+ഇത് ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ് ആരംഭിക്കും.
+
+ഇത് ഒരു നോട്ട്‌ബുക്കിൽ പരീക്ഷിക്കണമെങ്കിൽ (ഉദാഹരണത്തിന്, Colab-ൽ TPU-കൾ ഉപയോഗിച്ച് ടെസ്‌റ്റ് ചെയ്യാൻ), കോഡ് ഒരു `training_function()`-ൽ പേസ്‌റ്റ് ചെയ്ത്, അവസാന സെൽ ഇങ്ങനെ റൺ ചെയ്താൽ മതി:
+
+```python
+from accelerate import notebook_launcher
+
+notebook_launcher(training_function)
+```
+
+കൂടുതൽ ഉദാഹരണങ്ങൾ [🤗 Accelerate റിപ്പോയിൽ](https://github.com/huggingface/accelerate/tree/main/examples) കാണാം.
+
+> [!TIP]
+> 🌐 **ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ്**: മൾട്ടി-GPU, മൾട്ടി-നോഡ് ട്രെയിനിംഗിനെക്കുറിച്ചുള്ള സമഗ്രമായ വിവരങ്ങൾക്ക്, [🤗 Transformers ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ് ഗൈഡും](https://huggingface.co/docs/transformers/main/en/perf_train_gpu_many) [സ്‌കേലിംഗ് ട്രെയിനിംഗ് കുക്ക്‌ബുക്കും](https://huggingface.co/docs/transformers/main/en/accelerate) നോക്കുക.
+
+### അടുത്ത ഘട്ടങ്ങളും മികച്ച രീതികളും[[next-steps-and-best-practices]]
+
+തുടക്കം മുതൽ ട്രെയിനിംഗ് എങ്ങനെ ഇംപ്ലിമെന്റ് ചെയ്യാമെന്ന് നിങ്ങൾ പഠിച്ച സ്ഥിതിക്ക്, പ്രൊഡക്‌ഷൻ ഉപയോഗത്തിനായി പരിഗണിക്കേണ്ട ചില അധിക കാര്യങ്ങൾ ഇതാ:
+
+**മോഡൽ ഇവാലുവേഷൻ**: നിങ്ങളുടെ മോഡൽ എപ്പോഴും ഒന്നിലധികം മെട്രിക്കുകളിൽ വിലയിരുത്തുക, അക്യുറസി (accuracy) മാത്രം നോക്കരുത്. സമഗ്രമായ ഇവാലുവേഷനായി 🤗 Evaluate ലൈബ്രറി ഉപയോഗിക്കുക.
+
+**ഹൈപ്പർപാരാമീറ്റർ ട്യൂണിംഗ്**: വ്യവസ്ഥാപിതമായ ഹൈപ്പർപാരാമീറ്റർ ഒപ്‌റ്റിമൈസേഷനായി Optuna, Ray Tune പോലുള്ള ലൈബ്രറികൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.
+
+**മോഡൽ മോണിറ്ററിംഗ്**: ട്രെയിനിംഗിലുടനീളം ട്രെയിനിംഗ് മെട്രിക്കുകൾ, ലേണിംഗ് കർവുകൾ, വാലിഡേഷൻ പ്രകടനം എന്നിവ നിരീക്ഷിക്കുക.
+
+**മോഡൽ പങ്കുവയ്ക്കൽ**: ട്രെയിൻ ചെയ്തുകഴിഞ്ഞാൽ, കമ്മ്യൂണിറ്റിക്ക് ലഭ്യമാക്കാൻ നിങ്ങളുടെ മോഡൽ Hugging Face Hub-ൽ പങ്കുവയ്ക്കുക.
+
+**കാര്യക്ഷമത**: വലിയ മോഡലുകൾക്ക്, ഗ്രേഡിയന്റ് ചെക്ക്‌പോയിന്റിംഗ്, പാരാമീറ്റർ-കാര്യക്ഷമമായ ഫൈൻ-ട്യൂണിംഗ് (LoRA, AdaLoRA), ക്വാണ്ടൈസേഷൻ (quantization) രീതികൾ തുടങ്ങിയ സങ്കേതങ്ങൾ പരിഗണിക്കുക.
+
+കസ്‌റ്റം ട്രെയിനിംഗ് ലൂപ്പുകൾ ഉപയോഗിച്ചുള്ള ഫൈൻ-ട്യൂണിംഗിലേക്കുള്ള നമ്മുടെ ആഴത്തിലുള്ള അന്വേഷണം ഇവിടെ അവസാനിക്കുന്നു. ട്രെയിനിംഗ് പ്രക്രിയയിൽ പൂർണ്ണ നിയന്ത്രണം ആവശ്യമായി വരുമ്പോഴോ, `Trainer` API നൽകുന്നതിനപ്പുറമുള്ള കസ്‌റ്റം ട്രെയിനിംഗ് ലോജിക് ഇംപ്ലിമെന്റ് ചെയ്യാൻ ആഗ്രഹിക്കുമ്പോഴോ, ഇവിടെ നിങ്ങൾ പഠിച്ച കഴിവുകൾ നിങ്ങൾക്ക് ഏറെ ഉപകാരപ്പെടും.
+
+## വിഭാഗ ക്വിസ്[[section-quiz]]
+
+കസ്‌റ്റം ട്രെയിനിംഗ് ലൂപ്പുകളെയും വിപുലമായ ട്രെയിനിംഗ് സങ്കേതങ്ങളെയും കുറിച്ചുള്ള നിങ്ങളുടെ ധാരണ പരീക്ഷിക്കുക:
+
+### 1. Adam, AdamW എന്നീ ഒപ്‌റ്റിമൈസറുകൾക്കിടയിലെ പ്രധാന വ്യത്യാസം എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "AdamW വ്യത്യസ്തമായ ഒരു ലേണിംഗ് റേറ്റ് ഷെഡ്യൂൾ ഉപയോഗിക്കുന്നു.",
+			explain: "ലേണിംഗ് റേറ്റ് ഷെഡ്യൂളിംഗ് ഒപ്‌റ്റിമൈസർ തിരഞ്ഞെടുപ്പിൽ നിന്ന് വേറിട്ട ഒരു കാര്യമാണ്."
+		},
+		{
+			text: "AdamW-യിൽ ഡീകപ്പിൾഡ് വെയ്‌റ്റ് ഡികേ റെഗുലറൈസേഷൻ (decoupled weight decay regularization) ഉൾപ്പെടുന്നു.",
+			explain: "ശരിയാണ്! AdamW ഗ്രേഡിയന്റ് അടിസ്ഥാനമാക്കിയുള്ള പാരാമീറ്റർ അപ്‌ഡേറ്റുകളിൽ നിന്ന് വെയ്‌റ്റ് ഡികേയെ വേർതിരിക്കുന്നു, ഇത് മികച്ച റെഗുലറൈസേഷനിലേക്ക് നയിക്കുന്നു.",
+            correct: true
+		},
+		{
+			text: "AdamW transformer മോഡലുകളിൽ മാത്രമേ പ്രവർത്തിക്കൂ.",
+			explain: "AdamW ഏത് മോഡൽ ആർക്കിടെക്‌ചറിലും ഉപയോഗിക്കാം, transformer-കളിൽ മാത്രമല്ല."
+		},
+        {
+			text: "AdamW-യ്ക്ക് Adam-നെക്കാൾ കുറഞ്ഞ മെമ്മറി മതി.",
+			explain: "രണ്ട് ഒപ്‌റ്റിമൈസറുകൾക്കും ഏകദേശം സമാനമായ മെമ്മറി ആവശ്യകതകളാണുള്ളത്."
+		}
+	]}
+/>
+
+### 2. ഒരു ട്രെയിനിംഗ് ലൂപ്പിൽ, പ്രവർത്തനങ്ങളുടെ ശരിയായ ക്രമം ഏതാണ്?
+
+<Question
+	choices={[
+		{
+			text: "ഫോർവേഡ് പാസ് → ബാക്ക്‌വേഡ് പാസ് → ഒപ്‌റ്റിമൈസർ സ്‌റ്റെപ്പ് → ഗ്രേഡിയന്റുകൾ പൂജ്യമാക്കുക",
+			explain: "ഏകദേശം ശരിയാണ്, എന്നാൽ പഴയ ഗ്രേഡിയന്റുകൾ കുമിഞ്ഞുകൂടാതിരിക്കാൻ അടുത്ത ഫോർവേഡ് പാസിന് മുമ്പ് ഗ്രേഡിയന്റുകൾ പൂജ്യമാക്കേണ്ടതുണ്ട്."
+		},
+		{
+			text: "ഫോർവേഡ് പാസ് → ബാക്ക്‌വേഡ് പാസ് → ഒപ്‌റ്റിമൈസർ സ്‌റ്റെപ്പ് → ഷെഡ്യൂളർ സ്‌റ്റെപ്പ് → ഗ്രേഡിയന്റുകൾ പൂജ്യമാക്കുക",
+			explain: "ശരിയാണ്! ഇതാണ് ശരിയായ ക്രമം: ലോസ് കണക്കാക്കുക, ഗ്രേഡിയന്റുകൾ കണക്കാക്കുക, പാരാമീറ്ററുകൾ അപ്‌ഡേറ്റ് ചെയ്യുക, ലേണിംഗ് റേറ്റ് അപ്‌ഡേറ്റ് ചെയ്യുക, പിന്നീട് ഗ്രേഡിയന്റുകൾ മായ്ക്കുക.",
+            correct: true
+		},
+		{
+			text: "ഗ്രേഡിയന്റുകൾ പൂജ്യമാക്കുക → ഫോർവേഡ് പാസ് → ഒപ്‌റ്റിമൈസർ സ്‌റ്റെപ്പ് → ബാക്ക്‌വേഡ് പാസ്",
+			explain: "ലോസിൽ നിന്ന് ഗ്രേഡിയന്റുകൾ കണക്കാക്കാൻ ബാക്ക്‌വേഡ് പാസ് ഫോർവേഡ് പാസിന് ശേഷം വരണം."
+		},
+        {
+			text: "ഫോർവേഡ് പാസ് → ഗ്രേഡിയന്റുകൾ പൂജ്യമാക്കുക → ബാക്ക്‌വേഡ് പാസ് → ഒപ്‌റ്റിമൈസർ സ്‌റ്റെപ്പ്",
+			explain: "ബാക്ക്‌വേഡ് പാസിന് മുമ്പ് ഗ്രേഡിയന്റുകൾ പൂജ്യമാക്കിയാൽ നിങ്ങൾ ഇപ്പോൾ കണക്കാക്കിയ ഗ്രേഡിയന്റുകൾ നഷ്ടപ്പെടും."
+		}
+	]}
+/>
+
+### 3. 🤗 Accelerate ലൈബ്രറി പ്രധാനമായും എന്തിനാണ് സഹായിക്കുന്നത്?
+
+<Question
+	choices={[
+		{
+			text: "ഫോർവേഡ് പാസ് ഒപ്‌റ്റിമൈസ് ചെയ്ത് നിങ്ങളുടെ മോഡലുകൾ വേഗത്തിൽ ട്രെയിൻ ചെയ്യാൻ സഹായിക്കുന്നു.",
+			explain: "Accelerate മോഡൽ ആർക്കിടെക്‌ചറിനെ തന്നെ ഒപ്‌റ്റിമൈസ് ചെയ്യുന്നില്ല."
+		},
+		{
+			text: "ഏറ്റവും മികച്ച ഹൈപ്പർപാരാമീറ്ററുകൾ സ്വയമേവ തിരഞ്ഞെടുക്കുന്നു.",
+			explain: "Accelerate ഹൈപ്പർപാരാമീറ്റർ ഒപ്‌റ്റിമൈസേഷൻ ചെയ്യുന്നില്ല."
+		},
+		{
+			text: "കുറഞ്ഞ കോഡ് മാറ്റങ്ങളോടെ ഒന്നിലധികം GPU-കളിലോ TPU-കളിലോ ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ് സാധ്യമാക്കുന്നു.",
+			explain: "ശരിയാണ്! ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗിന്റെ സങ്കീർണ്ണത Accelerate കൈകാര്യം ചെയ്യുന്നു, അതുവഴി നിങ്ങളുടെ കോഡ് ഒറ്റ ഡിവൈസിലോ ഒന്നിലധികം ഡിവൈസുകളിലോ തടസ്സമില്ലാതെ റൺ ചെയ്യാൻ കഴിയും.",
+            correct: true
+		},
+        {
+			text: "മോഡലുകളെ TensorFlow പോലുള്ള മറ്റ് ഫ്രെയിംവർക്കുകളിലേക്ക് മാറ്റുന്നു.",
+			explain: "Accelerate PyTorch-നുള്ളിലാണ് പ്രവർത്തിക്കുന്നത്; ഫ്രെയിംവർക്കുകൾക്കിടയിൽ മാറ്റം നടത്തുന്നില്ല."
+		}
+	]}
+/>
+
+### 4. ഒരു ട്രെയിനിംഗ് ലൂപ്പിൽ ബാച്ചുകളെ നമ്മൾ ഡിവൈസിലേക്ക് മാറ്റുന്നത് എന്തുകൊണ്ട്?
+
+<Question
+	choices={[
+		{
+			text: "ട്രെയിനിംഗ് വേഗത്തിലാക്കാൻ.",
+			explain: "ഇത് വേഗതയെ ബാധിക്കാമെങ്കിലും, പ്രധാന കാരണം അനുയോജ്യതയാണ് (compatibility)."
+		},
+		{
+			text: "കണക്കുകൂട്ടലിനായി മോഡലും ഡേറ്റയും ഒരേ ഡിവൈസിൽ (CPU/GPU) ആയിരിക്കണം എന്നതിനാൽ.",
+			explain: "ശരിയാണ്! ഓപ്പറേഷനുകൾ പ്രവർത്തിക്കാൻ ടെൻസറുകൾ ഒരേ ഡിവൈസിൽ ആയിരിക്കണമെന്ന് PyTorch ആവശ്യപ്പെടുന്നു.",
+            correct: true
+		},
+		{
+			text: "മെമ്മറി ലാഭിക്കാൻ.",
+			explain: "ഡിവൈസിലേക്ക് മാറ്റുന്നത് അതിൽത്തന്നെ മെമ്മറി ലാഭിക്കുന്നില്ല."
+		},
+        {
+			text: "DataLoader ഇത് ആവശ്യപ്പെടുന്നു.",
+			explain: "DataLoader-ന് ഒരു പ്രത്യേക ഡിവൈസ് പ്ലേസ്‌മെന്റ് ആവശ്യമില്ല."
+		}
+	]}
+/>
+
+### 5. ഇവാലുവേഷന് മുമ്പ് `model.eval()` എന്താണ് ചെയ്യുന്നത്?
+
+<Question
+	choices={[
+		{
+			text: "മോഡൽ പാരാമീറ്ററുകൾ അപ്‌ഡേറ്റ് ചെയ്യാൻ കഴിയാത്ത വിധം അവയെ ഇത് ഫ്രീസ് ചെയ്യുന്നു.",
+			explain: "model.eval() പാരാമീറ്ററുകൾ ഫ്രീസ് ചെയ്യുന്നില്ല - അത് requires_grad=False എന്ന് സെറ്റ് ചെയ്താണ് ചെയ്യുന്നത്."
+		},
+		{
+			text: "ഇൻഫറൻസിനായി ഡ്രോപ്പൗട്ട്, ബാച്ച് നോർമലൈസേഷൻ പോലുള്ള ലെയറുകളുടെ പെരുമാറ്റം ഇത് മാറ്റുന്നു.",
+			explain: "ശരിയാണ്! eval() മോഡ് ഡ്രോപ്പൗട്ട് പ്രവർത്തനരഹിതമാക്കുകയും, ബാച്ച് നോമിന് നിലവിലെ ബാച്ചിൽ നിന്ന് കണക്കാക്കുന്നതിന് പകരം റണ്ണിംഗ് സ്‌റ്റാറ്റിസ്‌റ്റിക്‌സ് ഉപയോഗിക്കുകയും ചെയ്യുന്നു.",
+            correct: true
+		},
+		{
+			text: "ഇവാലുവേഷൻ മെട്രിക്കുകൾക്കായി ഇത് ഗ്രേഡിയന്റ് കണക്കുകൂട്ടൽ പ്രവർത്തനക്ഷമമാക്കുന്നു.",
+			explain: "വാസ്തവത്തിൽ, ഗ്രേഡിയന്റ് കണക്കുകൂട്ടൽ പ്രവർത്തനരഹിതമാക്കാൻ ഇവാലുവേഷൻ സമയത്ത് നമ്മൾ സാധാരണയായി torch.no_grad() ഉപയോഗിക്കുന്നു."
+		},
+        {
+			text: "ഇത് ഇവാലുവേഷൻ മെട്രിക്കുകൾ സ്വയമേവ കണക്കാക്കുന്നു.",
+			explain: "model.eval() ലെയറുകളുടെ പെരുമാറ്റം മാത്രമേ മാറ്റുന്നുള്ളൂ - മെട്രിക് കണക്കുകൂട്ടൽ നിങ്ങൾ ഇപ്പോഴും വെവ്വേറെ ഇംപ്ലിമെന്റ് ചെയ്യേണ്ടതുണ്ട്."
+		}
+	]}
+/>
+
+### 6. ഇവാലുവേഷൻ സമയത്ത് `torch.no_grad()`-ന്റെ ഉദ്ദേശ്യം എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "മോഡൽ പ്രവചനങ്ങൾ നടത്തുന്നത് തടയാൻ.",
+			explain: "torch.no_grad() പ്രവചനങ്ങളെ തടയുന്നില്ല, ഗ്രേഡിയന്റ് കണക്കുകൂട്ടലിനെ മാത്രമാണ് തടയുന്നത്."
+		},
+		{
+			text: "ഗ്രേഡിയന്റ് ട്രാക്കിംഗ് പ്രവർത്തനരഹിതമാക്കി മെമ്മറി ലാഭിക്കാനും കണക്കുകൂട്ടൽ വേഗത്തിലാക്കാനും.",
+			explain: "ശരിയാണ്! ഇവാലുവേഷന് ഗ്രേഡിയന്റുകൾ ആവശ്യമില്ലാത്തതിനാൽ, അവ പ്രവർത്തനരഹിതമാക്കുന്നത് മെമ്മറിയും കണക്കുകൂട്ടലും ലാഭിക്കുന്നു.",
+            correct: true
+		},
+		{
+			text: "മോഡലിന് ഇവാലുവേഷൻ മോഡ് പ്രവർത്തനക്ഷമമാക്കാൻ.",
+			explain: "ഇവാലുവേഷൻ മോഡ് പ്രവർത്തനക്ഷമമാക്കുന്നത് model.eval() ഉപയോഗിച്ചാണ്, torch.no_grad() ഉപയോഗിച്ചല്ല."
+		},
+        {
+			text: "വ്യത്യസ്ത റണ്ണുകളിൽ സ്ഥിരതയുള്ള ഫലങ്ങൾ ഉറപ്പാക്കാൻ.",
+			explain: "പുനരുത്പാദനക്ഷമത (reproducibility) കൈകാര്യം ചെയ്യുന്നത് റാൻഡം സീഡുകൾ സെറ്റ് ചെയ്താണ്, torch.no_grad() ഉപയോഗിച്ചല്ല."
+		}
+	]}
+/>
+
+### 7. നിങ്ങളുടെ ട്രെയിനിംഗ് ലൂപ്പിൽ 🤗 Accelerate ഉപയോഗിക്കുമ്പോൾ എന്താണ് മാറുന്നത്?
+
+<Question
+	choices={[
+		{
+			text: "നിങ്ങളുടെ ട്രെയിനിംഗ് ലൂപ്പ് മുഴുവൻ തുടക്കം മുതൽ വീണ്ടും എഴുതണം.",
+			explain: "നിലവിലുള്ള PyTorch കോഡിൽ വളരെ കുറഞ്ഞ മാറ്റങ്ങൾ മാത്രമേ Accelerate ആവശ്യപ്പെടുന്നുള്ളൂ."
+		},
+		{
+			text: "പ്രധാന ഒബ്‌ജക്റ്റുകളെ accelerator.prepare() ഉപയോഗിച്ച് പൊതിയുകയും loss.backward()-ന് പകരം accelerator.backward() ഉപയോഗിക്കുകയും ചെയ്യുന്നു.",
+			explain: "ശരിയാണ്! ഇവയാണ് പ്രധാന മാറ്റങ്ങൾ - നിങ്ങളുടെ ഒബ്‌ജക്റ്റുകൾ prepare ചെയ്യുക, ശരിയായ ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗിനായി accelerator.backward() ഉപയോഗിക്കുക.",
+            correct: true
+		},
+		{
+			text: "നിങ്ങളുടെ കോഡിൽ GPU-കളുടെ എണ്ണം വ്യക്തമാക്കേണ്ടതുണ്ട്.",
+			explain: "ലഭ്യമായ ഹാർഡ്‌വെയർ Accelerate സ്വയമേവ കണ്ടെത്തുന്നു."
+		},
+        {
+			text: "വ്യത്യസ്തമായ ഒരു ഒപ്‌റ്റിമൈസറും ഷെഡ്യൂളറും ഉപയോഗിക്കണം.",
+			explain: "Accelerate-നൊപ്പം അതേ ഒപ്‌റ്റിമൈസറുകളും ഷെഡ്യൂളറുകളും തന്നെ ഉപയോഗിക്കാം."
+		}
+	]}
+/>
+
+> [!TIP]
+> 💡 **പ്രധാന പാഠങ്ങൾ:**
+> - മാനുവൽ ട്രെയിനിംഗ് ലൂപ്പുകൾ നിങ്ങൾക്ക് പൂർണ്ണ നിയന്ത്രണം നൽകുന്നു, എന്നാൽ ശരിയായ ക്രമം മനസ്സിലാക്കേണ്ടതുണ്ട്: ഫോർവേഡ് → ബാക്ക്‌വേഡ് → ഒപ്‌റ്റിമൈസർ സ്‌റ്റെപ്പ് → ഷെഡ്യൂളർ സ്‌റ്റെപ്പ് → ഗ്രേഡിയന്റുകൾ പൂജ്യമാക്കുക
+> - transformer മോഡലുകൾക്ക് ശുപാർശ ചെയ്യുന്ന ഒപ്‌റ്റിമൈസർ വെയ്‌റ്റ് ഡികേയോടുകൂടിയ AdamW ആണ്
+> - ശരിയായ പെരുമാറ്റത്തിനും കാര്യക്ഷമതയ്ക്കും ഇവാലുവേഷൻ സമയത്ത് എപ്പോഴും `model.eval()`, `torch.no_grad()` എന്നിവ ഉപയോഗിക്കുക
+> - കുറഞ്ഞ കോഡ് മാറ്റങ്ങളോടെ ഡിസ്‌ട്രിബ്യൂട്ടഡ് ട്രെയിനിംഗ് 🤗 Accelerate എളുപ്പത്തിൽ ലഭ്യമാക്കുന്നു
+> - PyTorch ഓപ്പറേഷനുകൾക്ക് ഡിവൈസ് മാനേജ്‌മെന്റ് (ടെൻസറുകളെ GPU/CPU-വിലേക്ക് മാറ്റുന്നത്) നിർണ്ണായകമാണ്
+> - മിക്‌സഡ് പ്രിസിഷൻ, ഗ്രേഡിയന്റ് അക്യുമുലേഷൻ, ഗ്രേഡിയന്റ് ക്ലിപ്പിംഗ് പോലുള്ള ആധുനിക സങ്കേതങ്ങൾ ട്രെയിനിംഗ് കാര്യക്ഷമത ഗണ്യമായി മെച്ചപ്പെടുത്തും

From 617e5b2ff4c3aee333a8bbcd5c9c08094b86f667 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 13:54:05 +0530
Subject: [PATCH 35/44] Add Malayalam translation for chapter3/5.mdx

---
 chapters/ml/chapter3/5.mdx | 408 +++++++++++++++++++++++++++++++++++++
 1 file changed, 408 insertions(+)
 create mode 100644 chapters/ml/chapter3/5.mdx

diff --git a/chapters/ml/chapter3/5.mdx b/chapters/ml/chapter3/5.mdx
new file mode 100644
index 000000000..cb94bb470
--- /dev/null
+++ b/chapters/ml/chapter3/5.mdx
@@ -0,0 +1,408 @@
+# ലേണിംഗ് കർവുകൾ മനസ്സിലാക്കുന്നു[[understanding-learning-curves]]
+
+<CourseFloatingBanner chapter={3}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter3/section7.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter3/section7.ipynb"},
+]} />
+
+`Trainer` API ഉപയോഗിച്ചും കസ്‌റ്റം ട്രെയിനിംഗ് ലൂപ്പുകൾ ഉപയോഗിച്ചും ഫൈൻ-ട്യൂണിംഗ് എങ്ങനെ നടപ്പിലാക്കാം എന്ന് ഇപ്പോൾ നിങ്ങൾ പഠിച്ചുകഴിഞ്ഞു; അതിനാൽ ആ ഫലങ്ങൾ എങ്ങനെ വ്യാഖ്യാനിക്കണം എന്ന് മനസ്സിലാക്കുന്നത് വളരെ പ്രധാനമാണ്. ട്രെയിനിംഗ് സമയത്ത് നിങ്ങളുടെ മോഡലിന്റെ പ്രകടനം വിലയിരുത്താനും, പ്രകടനം കുറയ്ക്കുന്നതിന് മുമ്പ് തന്നെ സാധ്യമായ പ്രശ്നങ്ങൾ തിരിച്ചറിയാനും സഹായിക്കുന്ന അമൂല്യമായ ടൂളുകളാണ് ലേണിംഗ് കർവുകൾ (learning curves).
+
+ഈ ഭാഗത്തിൽ, അക്യുറസി (accuracy) കർവുകളും ലോസ് (loss) കർവുകളും എങ്ങനെ വായിക്കാമെന്നും വ്യാഖ്യാനിക്കാമെന്നും നമ്മൾ പരിശോധിക്കും; വ്യത്യസ്ത കർവ് ആകൃതികൾ നമ്മുടെ മോഡലിന്റെ പെരുമാറ്റത്തെക്കുറിച്ച് എന്താണ് പറയുന്നതെന്ന് മനസ്സിലാക്കും; സാധാരണ ട്രെയിനിംഗ് പ്രശ്നങ്ങൾ എങ്ങനെ പരിഹരിക്കാമെന്നും പഠിക്കും.
+
+## ലേണിംഗ് കർവുകൾ എന്താണ്?[[what-are-learning-curves]]
+
+ട്രെയിനിംഗ് സമയത്ത് കാലക്രമേണ നിങ്ങളുടെ മോഡലിന്റെ പ്രകടന മെട്രിക്കുകൾ എങ്ങനെ മാറുന്നു എന്നതിന്റെ ദൃശ്യ പ്രതിനിധാനങ്ങളാണ് ലേണിംഗ് കർവുകൾ. നിരീക്ഷിക്കേണ്ട ഏറ്റവും പ്രധാനപ്പെട്ട രണ്ട് കർവുകൾ ഇവയാണ്:
+
+- **ലോസ് കർവുകൾ**: ട്രെയിനിംഗ് സ്‌റ്റെപ്പുകളിലൂടെയോ എപ്പോക്കുകളിലൂടെയോ (epochs) മോഡലിന്റെ പിഴവ് (ലോസ്) എങ്ങനെ മാറുന്നു എന്ന് കാണിക്കുന്നു
+- **അക്യുറസി കർവുകൾ**: ട്രെയിനിംഗ് സ്‌റ്റെപ്പുകളിലൂടെയോ എപ്പോക്കുകളിലൂടെയോ ശരിയായ പ്രവചനങ്ങളുടെ ശതമാനം എങ്ങനെ മാറുന്നു എന്ന് കാണിക്കുന്നു
+
+നമ്മുടെ മോഡൽ ഫലപ്രദമായി പഠിക്കുന്നുണ്ടോ എന്ന് മനസ്സിലാക്കാൻ ഈ കർവുകൾ നമ്മെ സഹായിക്കുന്നു; പ്രകടനം മെച്ചപ്പെടുത്താൻ എന്തൊക്കെ മാറ്റങ്ങൾ വരുത്തണം എന്നതിലും ഇവ നമുക്ക് വഴികാട്ടിയാകും. Transformers-ൽ, ഈ മെട്രിക്കുകൾ ഓരോ ബാച്ചിനും വെവ്വേറെ കണക്കാക്കി ഡിസ്‌കിലേക്ക് ലോഗ് ചെയ്യുന്നു. തുടർന്ന്, ഈ കർവുകൾ ദൃശ്യവത്കരിക്കാനും കാലക്രമേണ നമ്മുടെ മോഡലിന്റെ പ്രകടനം ട്രാക്ക് ചെയ്യാനും [Weights & Biases](https://wandb.ai/) പോലുള്ള ലൈബ്രറികൾ നമുക്ക് ഉപയോഗിക്കാം.
+
+### ലോസ് കർവുകൾ[[loss-curves]]
+
+കാലക്രമേണ മോഡലിന്റെ പിഴവ് എങ്ങനെ കുറയുന്നു എന്ന് ലോസ് കർവ് കാണിക്കുന്നു. വിജയകരമായ ഒരു സാധാരണ ട്രെയിനിംഗ് റണ്ണിൽ, താഴെ കാണുന്നതിന് സമാനമായ ഒരു കർവ് നിങ്ങൾ കാണും:
+
+![ലോസ് കർവ്](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/1.png)
+
+- **ഉയർന്ന പ്രാരംഭ ലോസ്**: ഒപ്‌ടിമൈസേഷൻ ഒന്നും ഇല്ലാതെയാണ് മോഡൽ തുടങ്ങുന്നത്, അതിനാൽ തുടക്കത്തിൽ പ്രവചനങ്ങൾ മോശമായിരിക്കും
+- **കുറഞ്ഞുവരുന്ന ലോസ്**: ട്രെയിനിംഗ് പുരോഗമിക്കുമ്പോൾ, ലോസ് പൊതുവെ കുറയണം
+- **കൺവർജൻസ് (convergence)**: ഒടുവിൽ, ലോസ് ഒരു താഴ്ന്ന മൂല്യത്തിൽ സ്ഥിരത കൈവരിക്കുന്നു; ഡേറ്റയിലെ പാറ്റേണുകൾ മോഡൽ പഠിച്ചു എന്നാണ് ഇത് സൂചിപ്പിക്കുന്നത്
+
+മുൻ അധ്യായങ്ങളിലേതുപോലെ, ഈ മെട്രിക്കുകൾ ട്രാക്ക് ചെയ്യാനും ഒരു ഡാഷ്‌ബോർഡിൽ ദൃശ്യവത്കരിക്കാനും `Trainer` API നമുക്ക് ഉപയോഗിക്കാം. Weights & Biases ഉപയോഗിച്ച് ഇത് എങ്ങനെ ചെയ്യാം എന്നതിന്റെ ഒരു ഉദാഹരണം താഴെ കൊടുക്കുന്നു.
+
+```python
+# Example of tracking loss during training with the Trainer
+from transformers import Trainer, TrainingArguments
+import wandb
+
+# Initialize Weights & Biases for experiment tracking
+wandb.init(project="transformer-fine-tuning", name="bert-mrpc-analysis")
+
+training_args = TrainingArguments(
+    output_dir="./results",
+    eval_strategy="steps",
+    eval_steps=50,
+    save_steps=100,
+    logging_steps=10,  # Log metrics every 10 steps
+    num_train_epochs=3,
+    per_device_train_batch_size=16,
+    per_device_eval_batch_size=16,
+    report_to="wandb",  # Send logs to Weights & Biases
+)
+
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_datasets["train"],
+    eval_dataset=tokenized_datasets["validation"],
+    data_collator=data_collator,
+    processing_class=tokenizer,
+    compute_metrics=compute_metrics,
+)
+
+# Train and automatically log metrics
+trainer.train()
+```
+
+### അക്യുറസി കർവുകൾ[[accuracy-curves]]
+
+കാലക്രമേണ ശരിയായ പ്രവചനങ്ങളുടെ ശതമാനം എങ്ങനെ മാറുന്നു എന്ന് അക്യുറസി കർവ് കാണിക്കുന്നു. ലോസ് കർവുകളിൽ നിന്ന് വ്യത്യസ്തമായി, മോഡൽ പഠിക്കുന്നതിനനുസരിച്ച് അക്യുറസി കർവുകൾ പൊതുവെ ഉയരണം; സാധാരണയായി ലോസ് കർവിനെക്കാൾ കൂടുതൽ സ്‌റ്റെപ്പുകൾ ഇവയിൽ ഉൾപ്പെടാം.
+
+![അക്യുറസി കർവ്](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/2.png)
+
+- **താഴ്ന്ന നിലയിൽ തുടങ്ങുന്നു**: ഡേറ്റയിലെ പാറ്റേണുകൾ മോഡൽ ഇതുവരെ പഠിച്ചിട്ടില്ലാത്തതിനാൽ, പ്രാരംഭ അക്യുറസി താഴ്ന്നതായിരിക്കും
+- **ട്രെയിനിംഗിനൊപ്പം ഉയരുന്നു**: ഡേറ്റയിലെ പാറ്റേണുകൾ പഠിക്കാൻ മോഡലിന് കഴിയുന്നുണ്ടെങ്കിൽ, അത് പഠിക്കുന്നതിനനുസരിച്ച് അക്യുറസി പൊതുവെ മെച്ചപ്പെടണം
+- **പ്ലേറ്റോകൾ (plateaus) കാണിക്കാം**: മോഡൽ ശരിയായ ലേബലുകളോട് അടുത്ത പ്രവചനങ്ങൾ നടത്തുമ്പോൾ, അക്യുറസി പലപ്പോഴും സുഗമമായി ഉയരുന്നതിന് പകരം വേറിട്ട കുതിപ്പുകളായാണ് (discrete jumps) ഉയരുന്നത്
+
+> [!TIP]
+> 💡 **അക്യുറസി കർവുകൾ എന്തുകൊണ്ട് "പടിപടിയായി" (steppy) കാണപ്പെടുന്നു**: തുടർച്ചയായ (continuous) ഒരു അളവായ ലോസിൽ നിന്ന് വ്യത്യസ്തമായി, അക്യുറസി കണക്കാക്കുന്നത് വേറിട്ട (discrete) പ്രവചനങ്ങളെ ശരിയായ ലേബലുകളുമായി താരതമ്യം ചെയ്താണ്. മോഡലിന്റെ ആത്മവിശ്വാസത്തിലെ (confidence) ചെറിയ പുരോഗതികൾ അന്തിമ പ്രവചനത്തെ മാറ്റണമെന്നില്ല; അതിനാൽ ഒരു പരിധി (threshold) കടക്കുന്നതുവരെ അക്യുറസി മാറ്റമില്ലാതെ തുടരുന്നു.
+
+### കൺവർജൻസ്[[convergence]]
+
+മോഡലിന്റെ പ്രകടനം സ്ഥിരത കൈവരിക്കുകയും ലോസ്, അക്യുറസി കർവുകൾ നിരപ്പാകുകയും ചെയ്യുമ്പോഴാണ് കൺവർജൻസ് സംഭവിക്കുന്നത്. ഡേറ്റയിലെ പാറ്റേണുകൾ മോഡൽ പഠിച്ചുവെന്നും അത് ഉപയോഗിക്കാൻ തയ്യാറാണെന്നും ഇത് സൂചിപ്പിക്കുന്നു. ലളിതമായി പറഞ്ഞാൽ, ഓരോ തവണ ട്രെയിൻ ചെയ്യുമ്പോഴും മോഡൽ സ്ഥിരമായ ഒരു പ്രകടനത്തിലേക്ക് കൺവർജ് ചെയ്യണം എന്നതാണ് നമ്മുടെ ലക്ഷ്യം.
+
+![കൺവർജൻസ്](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/4.png)
+
+മോഡലുകൾ കൺവർജ് ചെയ്തുകഴിഞ്ഞാൽ, പുതിയ ഡേറ്റയിൽ പ്രവചനങ്ങൾ നടത്താൻ നമുക്ക് അവ ഉപയോഗിക്കാം; മോഡൽ എത്ര നന്നായി പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാൻ ഇവാലുവേഷൻ മെട്രിക്കുകൾ പരിശോധിക്കുകയും ചെയ്യാം.
+
+## ലേണിംഗ് കർവ് പാറ്റേണുകൾ വ്യാഖ്യാനിക്കുന്നു[[interpreting-learning-curve-patterns]]
+
+വ്യത്യസ്ത കർവ് ആകൃതികൾ നിങ്ങളുടെ മോഡലിന്റെ ട്രെയിനിംഗിന്റെ വ്യത്യസ്ത വശങ്ങൾ വെളിപ്പെടുത്തുന്നു. ഏറ്റവും സാധാരണമായ പാറ്റേണുകളും അവയുടെ അർത്ഥവും നമുക്ക് പരിശോധിക്കാം.
+
+### ആരോഗ്യകരമായ ലേണിംഗ് കർവുകൾ[[healthy-learning-curves]]
+
+നന്നായി നടക്കുന്ന ഒരു ട്രെയിനിംഗ് റൺ സാധാരണയായി താഴെ കാണുന്നതിന് സമാനമായ കർവ് ആകൃതികൾ കാണിക്കും:
+
+![ആരോഗ്യകരമായ ലോസ് കർവ്](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/5.png)
+
+മുകളിലെ ചിത്രം നോക്കാം. ഇത് ലോസ് കർവും (ഇടതുവശത്ത്) അതിനോട് ബന്ധപ്പെട്ട അക്യുറസി കർവും (വലതുവശത്ത്) കാണിക്കുന്നു. ഈ കർവുകൾക്ക് വ്യത്യസ്തമായ സവിശേഷതകളുണ്ട്.
+
+കാലക്രമേണ മോഡലിന്റെ ലോസ് മൂല്യം എങ്ങനെ മാറുന്നു എന്ന് ലോസ് കർവ് കാണിക്കുന്നു. തുടക്കത്തിൽ ലോസ് ഉയർന്നതാണ്, പിന്നീട് അത് ക്രമേണ കുറയുന്നു; മോഡൽ മെച്ചപ്പെടുന്നു എന്നാണ് ഇത് സൂചിപ്പിക്കുന്നത്. പ്രവചിച്ച ഔട്ട്‌പുട്ടും യഥാർത്ഥ ഔട്ട്‌പുട്ടും തമ്മിലുള്ള പിഴവാണ് ലോസ് പ്രതിനിധീകരിക്കുന്നത് എന്നതിനാൽ, ലോസ് മൂല്യം കുറയുന്നത് മോഡൽ മികച്ച പ്രവചനങ്ങൾ നടത്തുന്നു എന്നതിന്റെ സൂചനയാണ്.
+
+ഇനി നമ്മുടെ ശ്രദ്ധ അക്യുറസി കർവിലേക്ക് തിരിക്കാം. കാലക്രമേണ മോഡലിന്റെ അക്യുറസി എങ്ങനെ മാറുന്നു എന്നാണ് ഇത് കാണിക്കുന്നത്. അക്യുറസി കർവ് താഴ്ന്ന ഒരു മൂല്യത്തിൽ തുടങ്ങി, ട്രെയിനിംഗ് പുരോഗമിക്കുന്നതിനനുസരിച്ച് ഉയരുന്നു. ശരിയായി വർഗ്ഗീകരിച്ച ഉദാഹരണങ്ങളുടെ അനുപാതമാണ് അക്യുറസി അളക്കുന്നത്. അതിനാൽ, അക്യുറസി കർവ് ഉയരുമ്പോൾ, മോഡൽ കൂടുതൽ ശരിയായ പ്രവചനങ്ങൾ നടത്തുന്നു എന്നാണ് അർത്ഥം.
+
+ഈ കർവുകൾ തമ്മിലുള്ള ശ്രദ്ധേയമായ ഒരു വ്യത്യാസം, അവയുടെ സുഗമതയും അക്യുറസി കർവിലെ "പ്ലേറ്റോകളുടെ" സാന്നിധ്യവുമാണ്. ലോസ് സുഗമമായി കുറയുമ്പോൾ, അക്യുറസി കർവിലെ പ്ലേറ്റോകൾ സൂചിപ്പിക്കുന്നത് അക്യുറസി തുടർച്ചയായി ഉയരുന്നതിന് പകരം വേറിട്ട കുതിപ്പുകളായി ഉയരുന്നു എന്നാണ്. അക്യുറസി അളക്കുന്ന രീതിയാണ് ഈ പെരുമാറ്റത്തിന് കാരണം. അന്തിമ പ്രവചനം ഇപ്പോഴും തെറ്റാണെങ്കിലും, മോഡലിന്റെ ഔട്ട്‌പുട്ട് ലക്ഷ്യത്തോട് കൂടുതൽ അടുക്കുമ്പോൾ ലോസ് മെച്ചപ്പെടാം. എന്നാൽ അക്യുറസി മെച്ചപ്പെടുന്നത്, പ്രവചനം ശരിയാകാനുള്ള പരിധി കടക്കുമ്പോൾ മാത്രമാണ്.
+
+ഉദാഹരണത്തിന്, പൂച്ചകളെ (0) നായ്ക്കളിൽ (1) നിന്ന് വേർതിരിക്കുന്ന ഒരു ബൈനറി ക്ലാസിഫയറിൽ, ഒരു നായയുടെ ചിത്രത്തിന് (യഥാർത്ഥ മൂല്യം 1) മോഡൽ 0.3 എന്ന് പ്രവചിച്ചാൽ, അത് 0 ആയി റൗണ്ട് ചെയ്യപ്പെടുകയും തെറ്റായ വർഗ്ഗീകരണമാകുകയും ചെയ്യുന്നു. അടുത്ത സ്‌റ്റെപ്പിൽ അത് 0.4 എന്ന് പ്രവചിച്ചാലും, അപ്പോഴും തെറ്റാണ്. 0.3-നെക്കാൾ 0.4 ആണ് 1-നോട് അടുത്തത് എന്നതിനാൽ ലോസ് കുറഞ്ഞിട്ടുണ്ടാകും, എന്നാൽ അക്യുറസി മാറ്റമില്ലാതെ തുടരുന്നു — ഇതാണ് ഒരു പ്ലേറ്റോ ഉണ്ടാക്കുന്നത്. 1 ആയി റൗണ്ട് ചെയ്യപ്പെടുന്ന, 0.5-ൽ കൂടുതലുള്ള ഒരു മൂല്യം മോഡൽ പ്രവചിക്കുമ്പോൾ മാത്രമേ അക്യുറസി മുകളിലേക്ക് കുതിക്കുകയുള്ളൂ.
+
+> [!TIP]
+> **ആരോഗ്യകരമായ കർവുകളുടെ സവിശേഷതകൾ:**
+> - **ലോസിലെ സുഗമമായ കുറവ്**: ട്രെയിനിംഗ് ലോസും വാലിഡേഷൻ ലോസും സ്ഥിരമായി കുറയുന്നു
+> - **ട്രെയിനിംഗ്/വാലിഡേഷൻ പ്രകടനങ്ങൾ അടുത്തടുത്ത്**: ട്രെയിനിംഗ്, വാലിഡേഷൻ മെട്രിക്കുകൾ തമ്മിൽ ചെറിയ വിടവ് മാത്രം
+> - **കൺവർജൻസ്**: കർവുകൾ നിരപ്പാകുന്നു; മോഡൽ പാറ്റേണുകൾ പഠിച്ചു എന്ന് ഇത് സൂചിപ്പിക്കുന്നു
+
+### പ്രായോഗിക ഉദാഹരണങ്ങൾ[[practical-examples]]
+
+ലേണിംഗ് കർവുകളുടെ ചില പ്രായോഗിക ഉദാഹരണങ്ങൾ നമുക്ക് പരിശോധിക്കാം. ആദ്യം, ട്രെയിനിംഗ് സമയത്ത് ലേണിംഗ് കർവുകൾ നിരീക്ഷിക്കാനുള്ള ചില രീതികൾ നമ്മൾ എടുത്തുകാണിക്കും. അതിനു താഴെ, ലേണിംഗ് കർവുകളിൽ കാണാൻ കഴിയുന്ന വ്യത്യസ്ത പാറ്റേണുകൾ നമ്മൾ വിശദമായി പരിശോധിക്കും.
+
+#### ട്രെയിനിംഗ് സമയത്ത്[[during-training]]
+
+ട്രെയിനിംഗ് പ്രോസസ്സിനിടയിൽ (`trainer.train()` റൺ ചെയ്തതിന് ശേഷം), ഈ പ്രധാന സൂചകങ്ങൾ നിങ്ങൾക്ക് നിരീക്ഷിക്കാം:
+
+1. **ലോസ് കൺവർജൻസ്**: ലോസ് ഇപ്പോഴും കുറയുന്നുണ്ടോ, അതോ ഒരു പ്ലേറ്റോയിൽ എത്തിയോ?
+2. **ഓവർഫിറ്റിംഗിന്റെ (overfitting) ലക്ഷണങ്ങൾ**: ട്രെയിനിംഗ് ലോസ് കുറയുമ്പോൾ വാലിഡേഷൻ ലോസ് ഉയരാൻ തുടങ്ങുന്നുണ്ടോ?
+3. **ലേണിംഗ് റേറ്റ്**: കർവുകൾ അമിതമായി ചാഞ്ചാടുന്നുണ്ടോ (LR വളരെ ഉയർന്നത്), അതോ അമിതമായി പരന്നതാണോ (LR വളരെ താഴ്ന്നത്)?
+4. **സ്ഥിരത**: പ്രശ്നങ്ങളെ സൂചിപ്പിക്കുന്ന പെട്ടെന്നുള്ള കുതിപ്പുകളോ വീഴ്ചകളോ ഉണ്ടോ?
+
+#### ട്രെയിനിംഗിന് ശേഷം[[after-training]]
+
+ട്രെയിനിംഗ് പ്രോസസ്സ് പൂർത്തിയായ ശേഷം, മോഡലിന്റെ പ്രകടനം മനസ്സിലാക്കാൻ പൂർണ്ണമായ കർവുകൾ നിങ്ങൾക്ക് വിശകലനം ചെയ്യാം.
+
+1. **അന്തിമ പ്രകടനം**: മോഡൽ സ്വീകാര്യമായ പ്രകടന നിലവാരത്തിൽ എത്തിയോ?
+2. **കാര്യക്ഷമത**: കുറച്ച് എപ്പോക്കുകൾ കൊണ്ട് അതേ പ്രകടനം നേടാൻ കഴിയുമായിരുന്നോ?
+3. **ജനറലൈസേഷൻ (generalization)**: ട്രെയിനിംഗ്, വാലിഡേഷൻ പ്രകടനങ്ങൾ എത്രത്തോളം അടുത്താണ്?
+4. **പ്രവണതകൾ**: കൂടുതൽ ട്രെയിനിംഗ് നടത്തിയാൽ പ്രകടനം മെച്ചപ്പെടാൻ സാധ്യതയുണ്ടോ?
+
+> [!TIP]
+> 🔍 **W&B ഡാഷ്‌ബോർഡ് സവിശേഷതകൾ**: നിങ്ങളുടെ ലേണിംഗ് കർവുകളുടെ മനോഹരവും ഇന്ററാക്‌ടീവുമായ പ്ലോട്ടുകൾ Weights & Biases സ്വയമേവ സൃഷ്ടിക്കുന്നു. നിങ്ങൾക്ക് ചെയ്യാവുന്നത്:
+> - ഒന്നിലധികം റണ്ണുകൾ അടുത്തടുത്ത് വെച്ച് താരതമ്യം ചെയ്യുക
+> - കസ്‌റ്റം മെട്രിക്കുകളും വിഷ്വലൈസേഷനുകളും ചേർക്കുക  
+> - അസാധാരണമായ പെരുമാറ്റങ്ങൾക്ക് അലേർട്ടുകൾ സജ്ജീകരിക്കുക
+> - ഫലങ്ങൾ നിങ്ങളുടെ ടീമുമായി പങ്കുവെക്കുക
+>
+> കൂടുതലറിയാൻ [Weights & Biases ഡോക്യുമെന്റേഷൻ](https://docs.wandb.ai/) കാണുക.
+
+#### ഓവർഫിറ്റിംഗ്[[overfitting]]
+
+ട്രെയിനിംഗ് ഡേറ്റയിൽ നിന്ന് മോഡൽ അമിതമായി പഠിക്കുകയും, വ്യത്യസ്ത ഡേറ്റയിലേക്ക് (വാലിഡേഷൻ സെറ്റ് പ്രതിനിധീകരിക്കുന്നത്) ജനറലൈസ് ചെയ്യാൻ കഴിയാതെ വരികയും ചെയ്യുമ്പോഴാണ് ഓവർഫിറ്റിംഗ് സംഭവിക്കുന്നത്.
+
+![ഓവർഫിറ്റിംഗ്](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/10.png)
+
+**ലക്ഷണങ്ങൾ:**
+
+- ട്രെയിനിംഗ് ലോസ് കുറഞ്ഞുകൊണ്ടിരിക്കുമ്പോൾ വാലിഡേഷൻ ലോസ് ഉയരുകയോ ഒരു പ്ലേറ്റോയിൽ എത്തുകയോ ചെയ്യുന്നു
+- ട്രെയിനിംഗ് അക്യുറസിയും വാലിഡേഷൻ അക്യുറസിയും തമ്മിൽ വലിയ വിടവ്
+- വാലിഡേഷൻ അക്യുറസിയെക്കാൾ ട്രെയിനിംഗ് അക്യുറസി വളരെ ഉയർന്നത്
+
+**ഓവർഫിറ്റിംഗിനുള്ള പരിഹാരങ്ങൾ:**
+- **റെഗുലറൈസേഷൻ (regularization)**: ഡ്രോപ്പ്ഔട്ട്, വെയ്‌റ്റ് ഡികേ, അല്ലെങ്കിൽ മറ്റ് റെഗുലറൈസേഷൻ ടെക്‌നിക്കുകൾ ചേർക്കുക
+- **എർലി സ്‌റ്റോപ്പിംഗ് (early stopping)**: വാലിഡേഷൻ പ്രകടനം മെച്ചപ്പെടാതെ വരുമ്പോൾ ട്രെയിനിംഗ് നിർത്തുക
+- **ഡേറ്റ ഓഗ്‌മെന്റേഷൻ (data augmentation)**: ട്രെയിനിംഗ് ഡേറ്റയുടെ വൈവിധ്യം കൂട്ടുക
+- **മോഡലിന്റെ സങ്കീർണ്ണത കുറയ്ക്കുക**: ചെറിയ ഒരു മോഡലോ കുറച്ച് പാരാമീറ്ററുകളോ ഉപയോഗിക്കുക
+
+താഴെയുള്ള ഉദാഹരണത്തിൽ, ഓവർഫിറ്റിംഗ് തടയാൻ നമ്മൾ എർലി സ്‌റ്റോപ്പിംഗ് ഉപയോഗിക്കുന്നു. `early_stopping_patience` നമ്മൾ 3 ആയി സെറ്റ് ചെയ്യുന്നു; അതായത്, തുടർച്ചയായ 3 എപ്പോക്കുകളിൽ വാലിഡേഷൻ ലോസ് മെച്ചപ്പെട്ടില്ലെങ്കിൽ ട്രെയിനിംഗ് നിർത്തും.
+
+```python
+# Example of detecting overfitting with early stopping
+from transformers import EarlyStoppingCallback
+
+training_args = TrainingArguments(
+    output_dir="./results",
+    eval_strategy="steps",
+    eval_steps=100,
+    save_strategy="steps",
+    save_steps=100,
+    load_best_model_at_end=True,
+    metric_for_best_model="eval_loss",
+    greater_is_better=False,
+    num_train_epochs=10,  # Set high, but we'll stop early
+)
+
+# Add early stopping to prevent overfitting
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_datasets["train"],
+    eval_dataset=tokenized_datasets["validation"],
+    data_collator=data_collator,
+    processing_class=tokenizer,
+    compute_metrics=compute_metrics,
+    callbacks=[EarlyStoppingCallback(early_stopping_patience=3)],
+)
+```
+
+#### 2. അണ്ടർഫിറ്റിംഗ്[[underfitting]]
+
+ഡേറ്റയിലെ അടിസ്ഥാന പാറ്റേണുകൾ പിടിച്ചെടുക്കാൻ കഴിയാത്തവിധം മോഡൽ വളരെ ലളിതമാകുമ്പോഴാണ് അണ്ടർഫിറ്റിംഗ് (underfitting) സംഭവിക്കുന്നത്. ഇത് പല കാരണങ്ങളാൽ സംഭവിക്കാം:
+
+- മോഡൽ വളരെ ചെറുതാണ്, അല്ലെങ്കിൽ പാറ്റേണുകൾ പഠിക്കാനുള്ള ശേഷി (capacity) അതിനില്ല
+- ലേണിംഗ് റേറ്റ് വളരെ താഴ്ന്നതാണ്, അതിനാൽ പഠനം മന്ദഗതിയിലാകുന്നു
+- ഡേറ്റാസെറ്റ് വളരെ ചെറുതാണ്, അല്ലെങ്കിൽ പ്രശ്നത്തെ ശരിയായി പ്രതിനിധീകരിക്കുന്നില്ല
+- മോഡൽ ശരിയായി റെഗുലറൈസ് ചെയ്തിട്ടില്ല
+
+![അണ്ടർഫിറ്റിംഗ്](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/7.png)
+
+**ലക്ഷണങ്ങൾ:**
+- ട്രെയിനിംഗ് ലോസും വാലിഡേഷൻ ലോസും ഉയർന്നുതന്നെ നിൽക്കുന്നു
+- ട്രെയിനിംഗിന്റെ തുടക്കത്തിൽ തന്നെ മോഡലിന്റെ പ്രകടനം ഒരു പ്ലേറ്റോയിൽ എത്തുന്നു
+- ട്രെയിനിംഗ് അക്യുറസി പ്രതീക്ഷിച്ചതിലും താഴ്ന്നതാണ്
+
+**അണ്ടർഫിറ്റിംഗിനുള്ള പരിഹാരങ്ങൾ:**
+- **മോഡലിന്റെ ശേഷി കൂട്ടുക**: വലിയ ഒരു മോഡലോ കൂടുതൽ പാരാമീറ്ററുകളോ ഉപയോഗിക്കുക
+- **കൂടുതൽ സമയം ട്രെയിൻ ചെയ്യുക**: എപ്പോക്കുകളുടെ എണ്ണം കൂട്ടുക
+- **ലേണിംഗ് റേറ്റ് ക്രമീകരിക്കുക**: വ്യത്യസ്ത ലേണിംഗ് റേറ്റുകൾ പരീക്ഷിക്കുക
+- **ഡേറ്റയുടെ ഗുണനിലവാരം പരിശോധിക്കുക**: നിങ്ങളുടെ ഡേറ്റ ശരിയായി പ്രീപ്രോസസ്സ് ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക
+
+താഴെയുള്ള ഉദാഹരണത്തിൽ, ഡേറ്റയിലെ പാറ്റേണുകൾ മോഡലിന് പഠിക്കാൻ കഴിയുമോ എന്ന് കാണാൻ നമ്മൾ കൂടുതൽ എപ്പോക്കുകൾ ട്രെയിൻ ചെയ്യുന്നു.
+
+```python
+from transformers import TrainingArguments
+
+training_args = TrainingArguments(
+    output_dir="./results",
+    -num_train_epochs=5,
+    +num_train_epochs=10,
+)
+```
+
+#### 3. ചാഞ്ചാടുന്ന ലേണിംഗ് കർവുകൾ[[erratic-learning-curves]]
+
+മോഡൽ ഫലപ്രദമായി പഠിക്കാത്തപ്പോഴാണ് ചാഞ്ചാടുന്ന (erratic) ലേണിംഗ് കർവുകൾ ഉണ്ടാകുന്നത്. ഇത് പല കാരണങ്ങളാൽ സംഭവിക്കാം:
+
+- ലേണിംഗ് റേറ്റ് വളരെ ഉയർന്നതാണ്, അതിനാൽ മോഡൽ ഒപ്‌ടിമൽ പാരാമീറ്ററുകളെ മറികടന്നുപോകുന്നു (overshoot)
+- ബാച്ച് സൈസ് വളരെ ചെറുതാണ്, അതിനാൽ മോഡൽ മന്ദഗതിയിൽ പഠിക്കുന്നു
+- മോഡൽ ശരിയായി റെഗുലറൈസ് ചെയ്തിട്ടില്ല, അതിനാൽ അത് ട്രെയിനിംഗ് ഡേറ്റയിലേക്ക് ഓവർഫിറ്റ് ചെയ്യുന്നു
+- ഡേറ്റാസെറ്റ് ശരിയായി പ്രീപ്രോസസ്സ് ചെയ്തിട്ടില്ല, അതിനാൽ മോഡൽ നോയ്‌സിൽ (noise) നിന്ന് പഠിക്കുന്നു
+
+![ചാഞ്ചാടുന്ന ലേണിംഗ് കർവുകൾ](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/3.png)
+
+**ലക്ഷണങ്ങൾ:**
+- ലോസിലോ അക്യുറസിയിലോ ഇടയ്ക്കിടെയുള്ള ചാഞ്ചാട്ടങ്ങൾ
+- കർവുകൾ ഉയർന്ന വേരിയൻസോ അസ്ഥിരതയോ കാണിക്കുന്നു
+- വ്യക്തമായ പ്രവണതയില്ലാതെ പ്രകടനം മുകളിലേക്കും താഴേക്കും ആടുന്നു
+
+ട്രെയിനിംഗ് കർവും വാലിഡേഷൻ കർവും ചാഞ്ചാടുന്ന പെരുമാറ്റം കാണിക്കുന്നു.
+
+![ചാഞ്ചാടുന്ന ലേണിംഗ് കർവുകൾ](https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter3/9.png)
+
+**ചാഞ്ചാടുന്ന കർവുകൾക്കുള്ള പരിഹാരങ്ങൾ:**
+- **ലേണിംഗ് റേറ്റ് കുറയ്ക്കുക**: കൂടുതൽ സ്ഥിരതയുള്ള ട്രെയിനിംഗിനായി സ്‌റ്റെപ്പ് സൈസ് കുറയ്ക്കുക
+- **ബാച്ച് സൈസ് കൂട്ടുക**: വലിയ ബാച്ചുകൾ കൂടുതൽ സ്ഥിരതയുള്ള ഗ്രേഡിയന്റുകൾ നൽകുന്നു
+- **ഗ്രേഡിയന്റ് ക്ലിപ്പിംഗ് (gradient clipping)**: ഗ്രേഡിയന്റുകൾ അമിതമായി വളരുന്നത് (exploding gradients) തടയുക
+- **മികച്ച ഡേറ്റ പ്രീപ്രോസസ്സിംഗ്**: ഡേറ്റയുടെ ഗുണനിലവാരം ഏകീകൃതമാണെന്ന് ഉറപ്പാക്കുക
+
+താഴെയുള്ള ഉദാഹരണത്തിൽ, നമ്മൾ ലേണിംഗ് റേറ്റ് കുറയ്ക്കുകയും ബാച്ച് സൈസ് കൂട്ടുകയും ചെയ്യുന്നു.
+
+```python
+from transformers import TrainingArguments
+
+training_args = TrainingArguments(
+    output_dir="./results",
+    -learning_rate=1e-5,
+    +learning_rate=1e-4,
+    -per_device_train_batch_size=16,
+    +per_device_train_batch_size=32,
+)
+```
+
+## പ്രധാന പാഠങ്ങൾ[[key-takeaways]]
+
+ഫലപ്രദമായ ഒരു മെഷീൻ ലേണിംഗ് പ്രാക്‌ടീഷണറാകാൻ ലേണിംഗ് കർവുകൾ മനസ്സിലാക്കുന്നത് അത്യാവശ്യമാണ്. നിങ്ങളുടെ മോഡലിന്റെ ട്രെയിനിംഗ് പുരോഗതിയെക്കുറിച്ച് ഈ ദൃശ്യ ടൂളുകൾ തത്സമയ ഫീഡ്‌ബാക്ക് നൽകുന്നു; എപ്പോൾ ട്രെയിനിംഗ് നിർത്തണം, ഹൈപ്പർപാരാമീറ്ററുകൾ എപ്പോൾ ക്രമീകരിക്കണം, അല്ലെങ്കിൽ എപ്പോൾ വ്യത്യസ്ത സമീപനങ്ങൾ പരീക്ഷിക്കണം എന്നതിനെക്കുറിച്ച് അറിവോടെയുള്ള തീരുമാനങ്ങൾ എടുക്കാൻ ഇവ നിങ്ങളെ സഹായിക്കുന്നു. പരിശീലനത്തിലൂടെ, ആരോഗ്യകരമായ ലേണിംഗ് കർവുകൾ എങ്ങനെയിരിക്കും എന്നതിനെക്കുറിച്ചും പ്രശ്നങ്ങൾ ഉണ്ടാകുമ്പോൾ അവ എങ്ങനെ പരിഹരിക്കാം എന്നതിനെക്കുറിച്ചും ഒരു അവബോധപൂർവ്വമായ ധാരണ നിങ്ങൾ വികസിപ്പിക്കും. 
+
+> [!TIP]
+> 💡 **പ്രധാന പാഠങ്ങൾ:**
+> - മോഡൽ ട്രെയിനിംഗിന്റെ പുരോഗതി മനസ്സിലാക്കാനുള്ള അത്യാവശ്യ ടൂളുകളാണ് ലേണിംഗ് കർവുകൾ
+> - ലോസ് കർവും അക്യുറസി കർവും രണ്ടും നിരീക്ഷിക്കുക, എന്നാൽ അവയ്ക്ക് വ്യത്യസ്ത സവിശേഷതകളുണ്ടെന്ന് ഓർക്കുക
+> - ട്രെയിനിംഗ്/വാലിഡേഷൻ പ്രകടനങ്ങൾ പരസ്പരം അകന്നുപോകുന്നതായാണ് ഓവർഫിറ്റിംഗ് പ്രത്യക്ഷപ്പെടുന്നത്
+> - ട്രെയിനിംഗ് ഡേറ്റയിലും വാലിഡേഷൻ ഡേറ്റയിലും മോശം പ്രകടനമായാണ് അണ്ടർഫിറ്റിംഗ് പ്രത്യക്ഷപ്പെടുന്നത്
+> - Weights & Biases പോലുള്ള ടൂളുകൾ ലേണിംഗ് കർവുകൾ ട്രാക്ക് ചെയ്യുന്നതും വിശകലനം ചെയ്യുന്നതും എളുപ്പമാക്കുന്നു
+> - എർലി സ്‌റ്റോപ്പിംഗും ശരിയായ റെഗുലറൈസേഷനും ഉപയോഗിച്ച് സാധാരണ ട്രെയിനിംഗ് പ്രശ്നങ്ങളിൽ മിക്കതും പരിഹരിക്കാം
+>
+> 🔬 **അടുത്ത ഘട്ടങ്ങൾ**: നിങ്ങളുടെ സ്വന്തം ഫൈൻ-ട്യൂണിംഗ് പരീക്ഷണങ്ങളിൽ ലേണിംഗ് കർവുകൾ വിശകലനം ചെയ്ത് പരിശീലിക്കുക. വ്യത്യസ്ത ഹൈപ്പർപാരാമീറ്ററുകൾ പരീക്ഷിച്ച്, അവ കർവുകളുടെ ആകൃതിയെ എങ്ങനെ ബാധിക്കുന്നു എന്ന് നിരീക്ഷിക്കുക. ട്രെയിനിംഗ് പുരോഗതി വായിക്കാനുള്ള അവബോധം വികസിപ്പിക്കാനുള്ള ഏറ്റവും നല്ല മാർഗ്ഗം ഈ പ്രായോഗിക അനുഭവമാണ്.
+
+## ഈ ഭാഗത്തിന്റെ ക്വിസ്[[section-quiz]]
+
+ലേണിംഗ് കർവുകളെയും ട്രെയിനിംഗ് വിശകലനത്തെയും കുറിച്ചുള്ള നിങ്ങളുടെ ധാരണ പരീക്ഷിക്കുക:
+
+### 1. ട്രെയിനിംഗ് ലോസ് കുറയുമ്പോൾ വാലിഡേഷൻ ലോസ് ഉയരാൻ തുടങ്ങിയാൽ, അത് സാധാരണയായി എന്താണ് അർത്ഥമാക്കുന്നത്?
+
+<Question
+	choices={[
+		{
+			text: "മോഡൽ വിജയകരമായി പഠിക്കുന്നു, തുടർന്നും മെച്ചപ്പെടും.",
+			explain: "ട്രെയിനിംഗ് ലോസ് കുറയുമ്പോൾ വാലിഡേഷൻ ലോസ് ഉയരുന്നുണ്ടെങ്കിൽ, അത് വിജയത്തെയല്ല, ഒരു പ്രശ്നത്തെയാണ് സൂചിപ്പിക്കുന്നത്."
+		},
+		{
+			text: "മോഡൽ ട്രെയിനിംഗ് ഡേറ്റയിലേക്ക് ഓവർഫിറ്റ് ചെയ്യുന്നു.",
+			explain: "ശരിയാണ്! ഇത് ഓവർഫിറ്റിംഗിന്റെ ഒരു ക്ലാസിക് ലക്ഷണമാണ് - മോഡൽ ട്രെയിനിംഗ് ഡേറ്റയിൽ നന്നായി പ്രവർത്തിക്കുന്നു, എന്നാൽ മുമ്പ് കാണാത്ത വാലിഡേഷൻ ഡേറ്റയിൽ മോശമായി പ്രവർത്തിക്കുന്നു.",
+            correct: true
+		},
+		{
+			text: "ലേണിംഗ് റേറ്റ് വളരെ താഴ്ന്നതാണ്.",
+			explain: "താഴ്ന്ന ലേണിംഗ് റേറ്റ് പഠനം മന്ദഗതിയിലാക്കും; ട്രെയിനിംഗ്, വാലിഡേഷൻ പ്രകടനങ്ങൾ തമ്മിലുള്ള അകൽച്ചയ്ക്ക് അത് കാരണമാകില്ല."
+		},
+        {
+			text: "ഡേറ്റാസെറ്റ് വളരെ ചെറുതാണ്.",
+			explain: "ചെറിയ ഡേറ്റാസെറ്റുകൾ ഓവർഫിറ്റിംഗിന് കാരണമാകാമെങ്കിലും, ഡേറ്റാസെറ്റിന്റെ വലുപ്പം എന്തായാലും ഈ പ്രത്യേക പാറ്റേൺ തന്നെയാണ് ഓവർഫിറ്റിംഗിന്റെ നിർവചനം."
+		}
+	]}
+/>
+
+### 2. അക്യുറസി കർവുകൾ സുഗമമായ ഉയർച്ചയ്ക്ക് പകരം "പടിപടിയായ" അല്ലെങ്കിൽ പ്ലേറ്റോ പോലുള്ള പാറ്റേൺ പലപ്പോഴും കാണിക്കുന്നത് എന്തുകൊണ്ട്?
+
+<Question
+	choices={[
+		{
+			text: "അക്യുറസി കണക്കുകൂട്ടലിൽ ഒരു പിഴവുണ്ട്.",
+			explain: "പടിപടിയായ പാറ്റേൺ സാധാരണവും പ്രതീക്ഷിക്കുന്നതുമാണ്, ഒരു പിഴവല്ല."
+		},
+		{
+			text: "പ്രവചനങ്ങൾ തീരുമാന അതിരുകൾ (decision boundaries) കടക്കുമ്പോൾ മാത്രം മാറുന്ന ഒരു വേറിട്ട (discrete) മെട്രിക്കാണ് അക്യുറസി.",
+			explain: "ശരിയാണ്! ലോസിൽ നിന്ന് വ്യത്യസ്തമായി, അക്യുറസി വേറിട്ട പ്രവചന തീരുമാനങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു; അതിനാൽ ആത്മവിശ്വാസത്തിലെ ചെറിയ പുരോഗതികൾ ഒരു പരിധി കടക്കുന്നതുവരെ അന്തിമ അക്യുറസിയെ മാറ്റണമെന്നില്ല.",
+            correct: true
+		},
+		{
+			text: "മോഡൽ ഫലപ്രദമായി പഠിക്കുന്നില്ല.",
+			explain: "മോഡൽ നന്നായി പഠിക്കുമ്പോഴും പടിപടിയായ അക്യുറസി കർവുകൾ സാധാരണമാണ്."
+		},
+        {
+			text: "ബാച്ച് സൈസ് വളരെ ചെറുതാണ്.",
+			explain: "ബാച്ച് സൈസ് ട്രെയിനിംഗിന്റെ സ്ഥിരതയെ ബാധിക്കുമെങ്കിലും, അക്യുറസി മെട്രിക്കുകളുടെ അന്തർലീനമായ വേറിട്ട സ്വഭാവത്തെ അത് വിശദീകരിക്കുന്നില്ല."
+		}
+	]}
+/>
+
+### 3. ചാഞ്ചാടുന്ന, വളരെയധികം ഏറ്റക്കുറച്ചിലുകളുള്ള ലേണിംഗ് കർവുകൾ കാണുമ്പോൾ ഏറ്റവും നല്ല സമീപനം എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "കൺവർജൻസ് വേഗത്തിലാക്കാൻ ലേണിംഗ് റേറ്റ് കൂട്ടുക.",
+			explain: "ലേണിംഗ് റേറ്റ് കൂട്ടുന്നത് ചാഞ്ചാട്ടങ്ങളെ കൂടുതൽ വഷളാക്കാനാണ് സാധ്യത."
+		},
+		{
+			text: "ലേണിംഗ് റേറ്റ് കുറയ്ക്കുക, ഒപ്പം സാധ്യമെങ്കിൽ ബാച്ച് സൈസ് കൂട്ടുക.",
+			explain: "ശരിയാണ്! താഴ്ന്ന ലേണിംഗ് റേറ്റുകളും വലിയ ബാച്ച് സൈസുകളും സാധാരണയായി കൂടുതൽ സ്ഥിരതയുള്ള ട്രെയിനിംഗിലേക്ക് നയിക്കുന്നു.",
+            correct: true
+		},
+		{
+			text: "മോഡൽ മെച്ചപ്പെടില്ല എന്നതിനാൽ ഉടൻ തന്നെ ട്രെയിനിംഗ് നിർത്തുക.",
+			explain: "ചാഞ്ചാടുന്ന കർവുകൾ പലപ്പോഴും ഹൈപ്പർപാരാമീറ്റർ ക്രമീകരണങ്ങളിലൂടെ പരിഹരിക്കാൻ കഴിയും."
+		},
+        {
+			text: "തീർത്തും വ്യത്യസ്തമായ ഒരു മോഡൽ ആർക്കിടെക്‌ചറിലേക്ക് മാറുക.",
+			explain: "ഇത് വളരെ നേരത്തെയുള്ള ഒരു തീരുമാനമാണ് - ചാഞ്ചാടുന്ന കർവുകൾ സാധാരണയായി ഹൈപ്പർപാരാമീറ്റർ ട്യൂണിംഗിലൂടെ പരിഹരിക്കാവുന്നതാണ്."
+		}
+	]}
+/>
+
+### 4. എർലി സ്‌റ്റോപ്പിംഗ് ഉപയോഗിക്കുന്നത് എപ്പോഴാണ് പരിഗണിക്കേണ്ടത്?
+
+<Question
+	choices={[
+		{
+			text: "എപ്പോഴും, കാരണം അത് എല്ലാത്തരം ഓവർഫിറ്റിംഗും തടയുന്നു.",
+			explain: "എർലി സ്‌റ്റോപ്പിംഗ് ഉപകാരപ്രദമാണ്, എന്നാൽ എപ്പോഴും ആവശ്യമില്ല; പ്രത്യേകിച്ച് മറ്റ് റെഗുലറൈസേഷൻ രീതികൾ ഫലപ്രദമായി പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ."
+		},
+		{
+			text: "വാലിഡേഷൻ പ്രകടനം മെച്ചപ്പെടാതെ വരുമ്പോൾ അല്ലെങ്കിൽ മോശമാകാൻ തുടങ്ങുമ്പോൾ.",
+			explain: "ശരിയാണ്! മോഡൽ കൂടുതൽ മെച്ചമായി ജനറലൈസ് ചെയ്യാതെ വരുമ്പോൾ ട്രെയിനിംഗ് നിർത്തുന്നതിലൂടെ ഓവർഫിറ്റിംഗ് തടയാൻ എർലി സ്‌റ്റോപ്പിംഗ് സഹായിക്കുന്നു.",
+            correct: true
+		},
+		{
+			text: "ട്രെയിനിംഗ് ലോസ് ഇപ്പോഴും വേഗത്തിൽ കുറയുമ്പോൾ മാത്രം.",
+			explain: "ട്രെയിനിംഗ് ലോസ് വേഗത്തിൽ കുറയുകയും വാലിഡേഷൻ പ്രകടനം നല്ലതായിരിക്കുകയും ചെയ്യുന്നുണ്ടെങ്കിൽ, നിങ്ങൾ ട്രെയിനിംഗ് തുടരാൻ ആഗ്രഹിച്ചേക്കാം."
+		},
+        {
+			text: "ഒരിക്കലും വേണ്ട, കാരണം അത് മോഡലിനെ അതിന്റെ പൂർണ്ണ ശേഷിയിൽ എത്തുന്നതിൽ നിന്ന് തടയുന്നു.",
+			explain: "ഓവർഫിറ്റിംഗ് തടയുന്നതിലൂടെ മോഡലിന്റെ അന്തിമ പ്രകടനം പലപ്പോഴും മെച്ചപ്പെടുത്തുന്ന വിലപ്പെട്ട ഒരു ടെക്‌നിക്കാണ് എർലി സ്‌റ്റോപ്പിംഗ്."
+		}
+	]}
+/>
+
+### 5. നിങ്ങളുടെ മോഡൽ അണ്ടർഫിറ്റ് ചെയ്യുന്നുണ്ടാകാം എന്ന് സൂചിപ്പിക്കുന്നത് എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "വാലിഡേഷൻ അക്യുറസിയെക്കാൾ ട്രെയിനിംഗ് അക്യുറസി വളരെ ഉയർന്നതാണ്.",
+			explain: "ഇത് അണ്ടർഫിറ്റിംഗിനെയല്ല, ഓവർഫിറ്റിംഗിനെയാണ് വിവരിക്കുന്നത്."
+		},
+		{
+			text: "ട്രെയിനിംഗ് പ്രകടനവും വാലിഡേഷൻ പ്രകടനവും മോശമാണ്, രണ്ടും നേരത്തെ തന്നെ ഒരു പ്ലേറ്റോയിൽ എത്തുന്നു.",
+			explain: "ശരിയാണ്! പാറ്റേണുകൾ പഠിക്കാനുള്ള ശേഷി മോഡലിന് ഇല്ലാതെ വരുമ്പോഴാണ് അണ്ടർഫിറ്റിംഗ് സംഭവിക്കുന്നത്; അതിന്റെ ഫലമായി ട്രെയിനിംഗ് ഡേറ്റയിലും വാലിഡേഷൻ ഡേറ്റയിലും പ്രകടനം മോശമാകുന്നു.",
+            correct: true
+		},
+		{
+			text: "ലേണിംഗ് കർവുകൾ ചാഞ്ചാട്ടങ്ങളൊന്നുമില്ലാതെ വളരെ സുഗമമാണ്.",
+			explain: "സുഗമമായ കർവുകൾ പൊതുവെ നല്ലതാണ്, അവ അണ്ടർഫിറ്റിംഗിനെ സൂചിപ്പിക്കുന്നില്ല."
+		},
+        {
+			text: "ട്രെയിനിംഗ് ലോസിനെക്കാൾ വേഗത്തിൽ വാലിഡേഷൻ ലോസ് കുറയുന്നു.",
+			explain: "ഇത് വാസ്തവത്തിൽ ഒരു നല്ല സൂചനയാണ്, പ്രശ്നമല്ല."
+		}
+	]}
+/>
+

From 39b6670f26a3f34dd5ddd31481e757ace5e8f3c3 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 13:56:45 +0530
Subject: [PATCH 36/44] Add Malayalam translation for chapter3/6.mdx

---
 chapters/ml/chapter3/6.mdx | 40 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 chapters/ml/chapter3/6.mdx

diff --git a/chapters/ml/chapter3/6.mdx b/chapters/ml/chapter3/6.mdx
new file mode 100644
index 000000000..aa14a0148
--- /dev/null
+++ b/chapters/ml/chapter3/6.mdx
@@ -0,0 +1,40 @@
+<FrameworkSwitchCourse {fw} />
+
+# ഫൈൻ-ട്യൂണിംഗ്, പൂർത്തിയായി![[fine-tuning-check]]
+
+<CourseFloatingBanner
+    chapter={3}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+അത് വളരെ സമഗ്രമായിരുന്നു! ആദ്യത്തെ രണ്ട് അധ്യായങ്ങളിൽ നിങ്ങൾ മോഡലുകളെയും ടോക്കണൈസറുകളെയും കുറിച്ച് പഠിച്ചു; ഇപ്പോൾ ആധുനികമായ മികച്ച രീതികൾ (best practices) ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം ഡേറ്റയ്ക്കായി അവ എങ്ങനെ ഫൈൻ-ട്യൂൻ ചെയ്യാമെന്നും നിങ്ങൾക്കറിയാം. ഒന്ന് ഓർത്തുനോക്കിയാൽ, ഈ അധ്യായത്തിൽ നിങ്ങൾ:
+
+* [Hub](https://huggingface.co/datasets)-ലെ ഡേറ്റാസെറ്റുകളെക്കുറിച്ചും ആധുനിക ഡേറ്റാ പ്രോസസ്സിംഗ് ടെക്‌നിക്കുകളെക്കുറിച്ചും പഠിച്ചു
+* ഡൈനാമിക് പാഡിംഗും ഡേറ്റാ കൊളേറ്ററുകളും ഉപയോഗിക്കുന്നതുൾപ്പെടെ, ഡേറ്റാസെറ്റുകൾ കാര്യക്ഷമമായി ലോഡ് ചെയ്യാനും പ്രീപ്രോസസ്സ് ചെയ്യാനും പഠിച്ചു
+* ഏറ്റവും പുതിയ സവിശേഷതകളോടെ, ഉയർന്ന തലത്തിലുള്ള (high-level) `Trainer` API ഉപയോഗിച്ച് ഫൈൻ-ട്യൂണിംഗും ഇവാല്യുവേഷനും ഇംപ്ലിമെന്റ് ചെയ്തു
+* PyTorch ഉപയോഗിച്ച് പൂജ്യത്തിൽ നിന്ന് ഒരു പൂർണ്ണമായ കസ്‌റ്റം ട്രെയിനിംഗ് ലൂപ്പ് ഇംപ്ലിമെന്റ് ചെയ്തു
+* നിങ്ങളുടെ ട്രെയിനിംഗ് കോഡ് ഒന്നിലധികം GPU-കളിലോ TPU-കളിലോ തടസ്സമില്ലാതെ പ്രവർത്തിക്കാൻ 🤗 Accelerate ഉപയോഗിച്ചു
+* മിക്‌സഡ് പ്രിസിഷൻ ട്രെയിനിംഗ്, ഗ്രേഡിയന്റ് അക്യുമുലേഷൻ പോലുള്ള ആധുനിക ഒപ്‌റ്റിമൈസേഷൻ ടെക്‌നിക്കുകൾ പ്രയോഗിച്ചു
+
+> [!TIP]
+> 🎉 **അഭിനന്ദനങ്ങൾ!** Transformer മോഡലുകൾ ഫൈൻ-ട്യൂൻ ചെയ്യുന്നതിന്റെ അടിസ്ഥാനങ്ങൾ നിങ്ങൾ സ്വായത്തമാക്കിയിരിക്കുന്നു. യഥാർത്ഥ ലോകത്തിലെ ML പ്രോജക്റ്റുകൾ ഏറ്റെടുക്കാൻ ഇപ്പോൾ നിങ്ങൾ തയ്യാറാണ്!
+>
+> 📖 **പഠനം തുടരുക**: നിങ്ങളുടെ അറിവ് ആഴത്തിലാക്കാൻ ഈ റിസോഴ്‌സുകൾ പരിശോധിക്കുക:
+> - നിർദ്ദിഷ്ട NLP ടാസ്‌ക്കുകൾക്കായി [🤗 Transformers ടാസ്‌ക് ഗൈഡുകൾ](https://huggingface.co/docs/transformers/main/en/tasks/sequence_classification)
+> - സമഗ്രമായ നോട്ട്‌ബുക്കുകൾക്കായി [🤗 Transformers ഉദാഹരണങ്ങൾ](https://huggingface.co/docs/transformers/main/en/notebooks)
+>
+> 🚀 **അടുത്ത ഘട്ടങ്ങൾ**: 
+> - നിങ്ങൾ പഠിച്ച ടെക്‌നിക്കുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം ഡേറ്റാസെറ്റിൽ ഫൈൻ-ട്യൂണിംഗ് പരീക്ഷിക്കുക
+> - [Hugging Face Hub](https://huggingface.co/models)-ൽ ലഭ്യമായ വ്യത്യസ്ത മോഡൽ ആർക്കിടെക്ചറുകൾ ഉപയോഗിച്ച് പരീക്ഷണം നടത്തുക
+> - നിങ്ങളുടെ പ്രോജക്റ്റുകൾ പങ്കുവയ്ക്കാനും സഹായം നേടാനും [Hugging Face കമ്മ്യൂണിറ്റിയിൽ](https://discuss.huggingface.co/) ചേരുക
+
+🤗 Transformers-നൊപ്പമുള്ള നിങ്ങളുടെ യാത്രയുടെ തുടക്കം മാത്രമാണിത്. അടുത്ത അധ്യായത്തിൽ, നിങ്ങളുടെ മോഡലുകളും ടോക്കണൈസറുകളും കമ്മ്യൂണിറ്റിയുമായി എങ്ങനെ പങ്കുവയ്ക്കാമെന്നും, നിരന്തരം വളരുന്ന പ്രീട്രെയിൻഡ് മോഡലുകളുടെ ഇക്കോസിസ്‌റ്റത്തിലേക്ക് എങ്ങനെ സംഭാവന ചെയ്യാമെന്നും നമ്മൾ പരിശോധിക്കും.
+
+നിങ്ങൾ ഇവിടെ വികസിപ്പിച്ച കഴിവുകൾ - ഡേറ്റാ പ്രീപ്രോസസ്സിംഗ്, ട്രെയിനിംഗ് കോൺഫിഗറേഷൻ, ഇവാല്യുവേഷൻ, ഒപ്‌റ്റിമൈസേഷൻ - ഏതൊരു മെഷീൻ ലേണിംഗ് പ്രോജക്റ്റിനും അടിസ്ഥാനപരമാണ്. ടെക്‌സ്‌റ്റ് വർഗ്ഗീകരണം, നാമ-സത്ത തിരിച്ചറിയൽ (named entity recognition), ചോദ്യോത്തരം (question answering), അല്ലെങ്കിൽ മറ്റേതെങ്കിലും NLP ടാസ്‌ക് — ഏതിലാണ് നിങ്ങൾ പ്രവർത്തിക്കുന്നതെങ്കിലും, ഈ ടെക്‌നിക്കുകൾ നിങ്ങൾക്ക് നന്നായി ഉപകാരപ്പെടും.
+
+> [!TIP]
+> 💡 **വിജയത്തിനുള്ള പ്രോ ടിപ്പുകൾ**:
+> - കസ്‌റ്റം ട്രെയിനിംഗ് ലൂപ്പുകൾ ഇംപ്ലിമെന്റ് ചെയ്യുന്നതിന് മുമ്പ്, എപ്പോഴും `Trainer` API ഉപയോഗിച്ച് ശക്തമായ ഒരു ബേസ്‌ലൈനിൽ നിന്ന് തുടങ്ങുക
+> - മികച്ച തുടക്കത്തിനായി, നിങ്ങളുടെ ടാസ്‌ക്കിനോട് അടുത്തുനിൽക്കുന്ന പ്രീട്രെയിൻഡ് മോഡലുകൾ കണ്ടെത്താൻ 🤗 Hub ഉപയോഗിക്കുക
+> - ശരിയായ ഇവാല്യുവേഷൻ മെട്രിക്കുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ ട്രെയിനിംഗ് നിരീക്ഷിക്കുക, ചെക്ക്‌പോയിന്റുകൾ സേവ് ചെയ്യാൻ മറക്കരുത്
+> - കമ്മ്യൂണിറ്റിയെ പ്രയോജനപ്പെടുത്തുക - മറ്റുള്ളവരെ സഹായിക്കാനും നിങ്ങളുടെ ജോലിയെക്കുറിച്ച് ഫീഡ്‌ബാക്ക് നേടാനും നിങ്ങളുടെ മോഡലുകളും ഡേറ്റാസെറ്റുകളും പങ്കുവയ്ക്കുക

From 6104ec6886a046b66463708e90899c2019dc3df7 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 13:58:10 +0530
Subject: [PATCH 37/44] Add Malayalam translation for chapter3/7.mdx

---
 chapters/ml/chapter3/7.mdx | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 chapters/ml/chapter3/7.mdx

diff --git a/chapters/ml/chapter3/7.mdx b/chapters/ml/chapter3/7.mdx
new file mode 100644
index 000000000..99b8c6212
--- /dev/null
+++ b/chapters/ml/chapter3/7.mdx
@@ -0,0 +1,27 @@
+<!-- DISABLE-FRONTMATTER-SECTIONS -->
+
+# അധ്യായം പൂർത്തിയാക്കിയതിനുള്ള സർട്ടിഫിക്കറ്റ്
+
+<CourseFloatingBanner chapter={3}
+  classNames="absolute z-10 right-0 top-0"
+/>
+
+കോഴ്‌സ് പൂർത്തിയാക്കിയതിന് അഭിനന്ദനങ്ങൾ! പ്രീട്രെയിൻഡ് മോഡലുകൾ എങ്ങനെ ഫൈൻ-ട്യൂൻ ചെയ്യാമെന്നും, ലേണിംഗ് കർവുകൾ (learning curves) എങ്ങനെ മനസ്സിലാക്കാമെന്നും, നിങ്ങളുടെ മോഡലുകൾ കമ്മ്യൂണിറ്റിയുമായി എങ്ങനെ പങ്കുവയ്ക്കാമെന്നും നിങ്ങൾ പഠിച്ചു. ഇനി നിങ്ങളുടെ അറിവ് പരീക്ഷിക്കാനും സർട്ടിഫിക്കറ്റ് നേടാനും ക്വിസിൽ പങ്കെടുക്കാനുള്ള സമയമായി.
+
+ക്വിസിൽ പങ്കെടുക്കാൻ, നിങ്ങൾ ഈ ഘട്ടങ്ങൾ പിന്തുടരേണ്ടതുണ്ട്:
+
+1. നിങ്ങളുടെ Hugging Face അക്കൗണ്ടിലേക്ക് സൈൻ ഇൻ ചെയ്യുക.
+2. ക്വിസിലെ ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുക.
+3. നിങ്ങളുടെ ഉത്തരങ്ങൾ സമർപ്പിക്കുക.
+
+
+## മൾട്ടിപ്പിൾ ചോയ്‌സ് ക്വിസ്
+
+ഈ ക്വിസിൽ, ഓപ്‌ഷനുകളുടെ ഒരു പട്ടികയിൽ നിന്ന് ശരിയായ ഉത്തരം തിരഞ്ഞെടുക്കാൻ നിങ്ങളോട് ആവശ്യപ്പെടും. supervised ഫൈൻ-ട്യൂണിംഗിന്റെ അടിസ്ഥാനങ്ങളിലാണ് നാം നിങ്ങളെ പരീക്ഷിക്കുന്നത്.
+
+<iframe
+	src="https://huggingface-course-unit-3-quiz.hf.space"
+	frameborder="0"
+	width="850"
+	height="450"
+></iframe>

From b114e185d39675f14c50fe70d6fba6358b6709e3 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 14:00:13 +0530
Subject: [PATCH 38/44] Add Malayalam translation for chapter4/1.mdx

---
 chapters/ml/chapter4/1.mdx | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 chapters/ml/chapter4/1.mdx

diff --git a/chapters/ml/chapter4/1.mdx b/chapters/ml/chapter4/1.mdx
new file mode 100644
index 000000000..f2a4a6e2d
--- /dev/null
+++ b/chapters/ml/chapter4/1.mdx
@@ -0,0 +1,22 @@
+# Hugging Face Hub[[the-hugging-face-hub]]
+
+<CourseFloatingBanner
+    chapter={4}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+[Hugging Face Hub](https://huggingface.co/) –- ഞങ്ങളുടെ പ്രധാന വെബ്‌സൈറ്റ് –- അത്യാധുനിക (state-of-the-art) മോഡലുകളും ഡേറ്റാസെറ്റുകളും കണ്ടെത്താനും ഉപയോഗിക്കാനും പുതിയവ സംഭാവന ചെയ്യാനും ആർക്കും കഴിയുന്ന ഒരു കേന്ദ്ര പ്ലാറ്റ്‌ഫോമാണ്. പലതരത്തിലുള്ള മോഡലുകൾ ഇത് ഹോസ്‌റ്റ് ചെയ്യുന്നു; അവയിൽ 10,000-ത്തിലധികം പൊതുവായി ലഭ്യമാണ്. ഈ അധ്യായത്തിൽ നമ്മൾ മോഡലുകളിലാണ് ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നത്; ഡേറ്റാസെറ്റുകൾ അധ്യായം 5-ൽ നോക്കാം.
+
+Hub-ലെ മോഡലുകൾ 🤗 Transformers-ലോ NLP-യിലോ മാത്രം ഒതുങ്ങുന്നില്ല. ചിലത് മാത്രം പറയുകയാണെങ്കിൽ, NLP-ക്കായി [Flair](https://github.com/flairNLP/flair), [AllenNLP](https://github.com/allenai/allennlp) എന്നിവയിൽ നിന്നുള്ള മോഡലുകളും, സ്പീച്ചിനായി [Asteroid](https://github.com/asteroid-team/asteroid), [pyannote](https://github.com/pyannote/pyannote-audio) എന്നിവയിൽ നിന്നുള്ളവയും, വിഷനായി [timm](https://github.com/rwightman/pytorch-image-models)-ൽ നിന്നുള്ളവയും ഇവിടെയുണ്ട്. 
+
+ഈ മോഡലുകൾ ഓരോന്നും ഒരു Git റിപ്പോസിറ്ററിയായാണ് ഹോസ്‌റ്റ് ചെയ്യപ്പെടുന്നത്; ഇത് വേർഷനിംഗും (versioning) പുനരുൽപ്പാദനക്ഷമതയും (reproducibility) സാധ്യമാക്കുന്നു. ഒരു മോഡൽ Hub-ൽ പങ്കുവെക്കുക എന്നാൽ അത് കമ്മ്യൂണിറ്റിക്ക് തുറന്നുകൊടുക്കുകയും, എളുപ്പത്തിൽ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന ആർക്കും അത് ലഭ്യമാക്കുകയും ചെയ്യുക എന്നാണ്; അതുവഴി അവർക്ക് സ്വന്തമായി ഒരു മോഡൽ ട്രെയിൻ ചെയ്യേണ്ട ആവശ്യം ഇല്ലാതാകുകയും, പങ്കുവെക്കലും ഉപയോഗവും ലളിതമാകുകയും ചെയ്യുന്നു. 
+
+കൂടാതെ, ഒരു മോഡൽ Hub-ൽ പങ്കുവെക്കുമ്പോൾ ആ മോഡലിനായി ഒരു ഹോസ്‌റ്റഡ് Inference API സ്വയമേവ ഡിപ്ലോയ് ചെയ്യപ്പെടുന്നു. കമ്മ്യൂണിറ്റിയിലെ ആർക്കും, സ്വന്തം ഇൻപുട്ടുകളും അനുയോജ്യമായ വിജറ്റുകളും ഉപയോഗിച്ച്, മോഡലിന്റെ പേജിൽ നേരിട്ട് അത് പരീക്ഷിച്ചുനോക്കാം.
+
+ഏറ്റവും നല്ല കാര്യം, Hub-ലെ ഏത് പൊതു മോഡലും പങ്കുവെക്കുന്നതും ഉപയോഗിക്കുന്നതും പൂർണ്ണമായും സൗജന്യമാണ് എന്നതാണ്! മോഡലുകൾ സ്വകാര്യമായി പങ്കുവെക്കാൻ ആഗ്രഹിക്കുന്നെങ്കിൽ [പെയ്ഡ് പ്ലാനുകളും](https://huggingface.co/pricing) ലഭ്യമാണ്.
+
+Hub-ൽ എങ്ങനെ സഞ്ചരിക്കാം (navigate) എന്ന് താഴെയുള്ള വീഡിയോ കാണിക്കുന്നു.
+
+<Youtube id="XvSGPZFEjDY"/>
+
+ഈ ഭാഗം പിന്തുടരാൻ ഒരു huggingface.co അക്കൗണ്ട് ആവശ്യമാണ്, കാരണം നമ്മൾ Hugging Face Hub-ൽ റിപ്പോസിറ്ററികൾ ഉണ്ടാക്കുകയും കൈകാര്യം ചെയ്യുകയും ചെയ്യും: [ഒരു അക്കൗണ്ട് ഉണ്ടാക്കുക](https://huggingface.co/join)

From ed94d7b1c3b7271c83e7524ffe7f0549e9f8e7ad Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 14:02:33 +0530
Subject: [PATCH 39/44] Add Malayalam translation for chapter4/2.mdx

---
 chapters/ml/chapter4/2.mdx | 95 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 chapters/ml/chapter4/2.mdx

diff --git a/chapters/ml/chapter4/2.mdx b/chapters/ml/chapter4/2.mdx
new file mode 100644
index 000000000..759e132a3
--- /dev/null
+++ b/chapters/ml/chapter4/2.mdx
@@ -0,0 +1,95 @@
+<FrameworkSwitchCourse {fw} />
+
+# പ്രീട്രെയിൻഡ് മോഡലുകൾ ഉപയോഗിക്കുന്നു[[using-pretrained-models]]
+
+{#if fw === 'pt'}
+
+<CourseFloatingBanner chapter={4}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter4/section2_pt.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter4/section2_pt.ipynb"},
+]} />
+
+{:else}
+
+<CourseFloatingBanner chapter={4}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter4/section2_tf.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter4/section2_tf.ipynb"},
+]} />
+
+{/if}
+
+അനുയോജ്യമായ മോഡൽ തിരഞ്ഞെടുക്കുന്നത് Model Hub ലളിതമാക്കുന്നു; അതുവഴി ഏത് ഡൗൺസ്ട്രീം ലൈബ്രറിയിലും ഏതാനും വരി കോഡ് കൊണ്ട് അത് ഉപയോഗിക്കാൻ കഴിയും. ഈ മോഡലുകളിൽ ഒന്ന് യഥാർത്ഥത്തിൽ എങ്ങനെ ഉപയോഗിക്കാമെന്നും, കമ്മ്യൂണിറ്റിക്ക് തിരികെ എങ്ങനെ സംഭാവന ചെയ്യാമെന്നും നോക്കാം.
+
+മാസ്‌ക് ഫില്ലിംഗ് ചെയ്യാൻ കഴിയുന്ന, ഫ്രഞ്ച് ഭാഷ അടിസ്ഥാനമാക്കിയ ഒരു മോഡലാണ് നമ്മൾ തിരയുന്നത് എന്ന് കരുതുക.
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/camembert.gif" alt="Camembert മോഡൽ തിരഞ്ഞെടുക്കുന്നു." width="80%"/>
+</div>
+
+ഇത് പരീക്ഷിച്ചുനോക്കാൻ നമ്മൾ `camembert-base` ചെക്ക്‌പോയിന്റ് തിരഞ്ഞെടുക്കുന്നു. ഇത് ഉപയോഗിക്കാൻ തുടങ്ങാൻ `camembert-base` എന്ന ഐഡന്റിഫയർ മാത്രം മതി! മുൻ അധ്യായങ്ങളിൽ കണ്ടതുപോലെ, `pipeline()` ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് നമുക്ക് ഇത് ഇൻസ്‌റ്റാൻഷിയേറ്റ് ചെയ്യാം:
+
+```py
+from transformers import pipeline
+
+camembert_fill_mask = pipeline("fill-mask", model="camembert-base")
+results = camembert_fill_mask("Le camembert est <mask> :)")
+```
+
+```python out
+[
+  {'sequence': 'Le camembert est délicieux :)', 'score': 0.49091005325317383, 'token': 7200, 'token_str': 'délicieux'}, 
+  {'sequence': 'Le camembert est excellent :)', 'score': 0.1055697426199913, 'token': 2183, 'token_str': 'excellent'}, 
+  {'sequence': 'Le camembert est succulent :)', 'score': 0.03453313186764717, 'token': 26202, 'token_str': 'succulent'}, 
+  {'sequence': 'Le camembert est meilleur :)', 'score': 0.0330314114689827, 'token': 528, 'token_str': 'meilleur'}, 
+  {'sequence': 'Le camembert est parfait :)', 'score': 0.03007650189101696, 'token': 1654, 'token_str': 'parfait'}
+]
+```
+
+നിങ്ങൾ കാണുന്നതുപോലെ, ഒരു പൈപ്പ്‌ലൈനിനുള്ളിൽ ഒരു മോഡൽ ലോഡ് ചെയ്യുന്നത് അതീവ ലളിതമാണ്. തിരഞ്ഞെടുത്ത ചെക്ക്‌പോയിന്റ് അത് ഉപയോഗിക്കാൻ പോകുന്ന ടാസ്‌ക്കിന് അനുയോജ്യമാണോ എന്നത് മാത്രമാണ് നിങ്ങൾ ശ്രദ്ധിക്കേണ്ട ഒരേയൊരു കാര്യം. ഉദാഹരണത്തിന്, ഇവിടെ നമ്മൾ `camembert-base` ചെക്ക്‌പോയിന്റ് `fill-mask` പൈപ്പ്‌ലൈനിൽ ലോഡ് ചെയ്യുന്നു, അത് തികച്ചും ശരിയാണ്. എന്നാൽ ഈ ചെക്ക്‌പോയിന്റ് `text-classification` പൈപ്പ്‌ലൈനിൽ ലോഡ് ചെയ്താൽ, ഫലങ്ങൾക്ക് ഒരു അർത്ഥവുമുണ്ടാകില്ല, കാരണം `camembert-base`-ന്റെ ഹെഡ് (head) ഈ ടാസ്‌ക്കിന് അനുയോജ്യമല്ല! അനുയോജ്യമായ ചെക്ക്‌പോയിന്റുകൾ തിരഞ്ഞെടുക്കാൻ Hugging Face Hub ഇന്റർഫേസിലെ ടാസ്‌ക് സെലക്ടർ ഉപയോഗിക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു:
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/tasks.png" alt="വെബ് ഇന്റർഫേസിലെ ടാസ്‌ക് സെലക്ടർ." width="80%"/>
+</div>
+
+മോഡൽ ആർക്കിടെക്‌ചർ നേരിട്ട് ഉപയോഗിച്ചും നിങ്ങൾക്ക് ചെക്ക്‌പോയിന്റ് ഇൻസ്‌റ്റാൻഷിയേറ്റ് ചെയ്യാം:
+
+{#if fw === 'pt'}
+```py
+from transformers import CamembertTokenizer, CamembertForMaskedLM
+
+tokenizer = CamembertTokenizer.from_pretrained("camembert-base")
+model = CamembertForMaskedLM.from_pretrained("camembert-base")
+```
+
+എന്നിരുന്നാലും, പകരം [`Auto*` ക്ലാസുകൾ](https://huggingface.co/transformers/model_doc/auto?highlight=auto#auto-classes) ഉപയോഗിക്കാനാണ് ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നത്, കാരണം ഇവ രൂപകൽപ്പനയിൽ തന്നെ ആർക്കിടെക്‌ചർ-നിരപേക്ഷമാണ് (architecture-agnostic). മുമ്പത്തെ കോഡ് സാമ്പിൾ ഉപയോക്താക്കളെ CamemBERT ആർക്കിടെക്‌ചറിൽ ലോഡ് ചെയ്യാവുന്ന ചെക്ക്‌പോയിന്റുകളിലേക്ക് പരിമിതപ്പെടുത്തുമ്പോൾ, `Auto*` ക്ലാസുകൾ ഉപയോഗിക്കുന്നത് ചെക്ക്‌പോയിന്റുകൾ മാറ്റുന്നത് ലളിതമാക്കുന്നു:
+
+```py
+from transformers import AutoTokenizer, AutoModelForMaskedLM
+
+tokenizer = AutoTokenizer.from_pretrained("camembert-base")
+model = AutoModelForMaskedLM.from_pretrained("camembert-base")
+```
+{:else}
+```py
+from transformers import CamembertTokenizer, TFCamembertForMaskedLM
+
+tokenizer = CamembertTokenizer.from_pretrained("camembert-base")
+model = TFCamembertForMaskedLM.from_pretrained("camembert-base")
+```
+
+എന്നിരുന്നാലും, പകരം [`TFAuto*` ക്ലാസുകൾ](https://huggingface.co/transformers/model_doc/auto?highlight=auto#auto-classes) ഉപയോഗിക്കാനാണ് ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നത്, കാരണം ഇവ രൂപകൽപ്പനയിൽ തന്നെ ആർക്കിടെക്‌ചർ-നിരപേക്ഷമാണ് (architecture-agnostic). മുമ്പത്തെ കോഡ് സാമ്പിൾ ഉപയോക്താക്കളെ CamemBERT ആർക്കിടെക്‌ചറിൽ ലോഡ് ചെയ്യാവുന്ന ചെക്ക്‌പോയിന്റുകളിലേക്ക് പരിമിതപ്പെടുത്തുമ്പോൾ, `TFAuto*` ക്ലാസുകൾ ഉപയോഗിക്കുന്നത് ചെക്ക്‌പോയിന്റുകൾ മാറ്റുന്നത് ലളിതമാക്കുന്നു:
+
+```py
+from transformers import AutoTokenizer, TFAutoModelForMaskedLM
+
+tokenizer = AutoTokenizer.from_pretrained("camembert-base")
+model = TFAutoModelForMaskedLM.from_pretrained("camembert-base")
+```
+{/if}
+
+> [!TIP]
+> ഒരു പ്രീട്രെയിൻഡ് മോഡൽ ഉപയോഗിക്കുമ്പോൾ, അത് എങ്ങനെ ട്രെയിൻ ചെയ്തു, ഏതൊക്കെ ഡേറ്റാസെറ്റുകളിൽ, അതിന്റെ പരിമിതികൾ, അതിന്റെ പക്ഷപാതങ്ങൾ (biases) എന്നിവ പരിശോധിക്കാൻ മറക്കരുത്. ഈ വിവരങ്ങളെല്ലാം അതിന്റെ മോഡൽ കാർഡിൽ സൂചിപ്പിച്ചിരിക്കണം.

From 26bb83403fa27fd7242acb448ac879f8828af9a5 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 14:14:25 +0530
Subject: [PATCH 40/44] Add Malayalam translation for chapter4/3.mdx

---
 chapters/ml/chapter4/3.mdx | 637 +++++++++++++++++++++++++++++++++++++
 1 file changed, 637 insertions(+)
 create mode 100644 chapters/ml/chapter4/3.mdx

diff --git a/chapters/ml/chapter4/3.mdx b/chapters/ml/chapter4/3.mdx
new file mode 100644
index 000000000..8040dd426
--- /dev/null
+++ b/chapters/ml/chapter4/3.mdx
@@ -0,0 +1,637 @@
+<FrameworkSwitchCourse {fw} />
+
+# പ്രീട്രെയിൻഡ് മോഡലുകൾ പങ്കുവെക്കുന്നു[[sharing-pretrained-models]]
+
+{#if fw === 'pt'}
+
+<CourseFloatingBanner chapter={4}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter4/section3_pt.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter4/section3_pt.ipynb"},
+]} />
+
+{:else}
+
+<CourseFloatingBanner chapter={4}
+  classNames="absolute z-10 right-0 top-0"
+  notebooks={[
+    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/en/chapter4/section3_tf.ipynb"},
+    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/en/chapter4/section3_tf.ipynb"},
+]} />
+
+{/if}
+
+താഴെയുള്ള ഘട്ടങ്ങളിൽ, പ്രീട്രെയിൻഡ് മോഡലുകൾ 🤗 Hub-ലേക്ക് പങ്കുവെക്കാനുള്ള ഏറ്റവും എളുപ്പമുള്ള വഴികൾ നമ്മൾ നോക്കും. Hub-ൽ നേരിട്ട് മോഡലുകൾ പങ്കുവെക്കാനും അപ്‌ഡേറ്റ് ചെയ്യാനും ലളിതമാക്കുന്ന ടൂളുകളും യൂട്ടിലിറ്റികളും ലഭ്യമാണ്; അവ നമ്മൾ താഴെ പരിശോധിക്കും.
+
+<Youtube id="9yY3RB_GSPM"/>
+
+മോഡലുകൾ ട്രെയിൻ ചെയ്യുന്ന എല്ലാ ഉപയോക്താക്കളെയും അവ കമ്മ്യൂണിറ്റിയുമായി പങ്കുവെച്ച് സംഭാവന ചെയ്യാൻ ഞങ്ങൾ പ്രോത്സാഹിപ്പിക്കുന്നു — വളരെ പ്രത്യേകമായ ഡേറ്റാസെറ്റുകളിൽ ട്രെയിൻ ചെയ്തവയാണെങ്കിൽ പോലും, മോഡലുകൾ പങ്കുവെക്കുന്നത് മറ്റുള്ളവർക്ക് സഹായകമാകും; അത് അവരുടെ സമയവും കമ്പ്യൂട്ട് വിഭവങ്ങളും ലാഭിക്കുകയും, ഉപകാരപ്രദമായ ട്രെയിൻഡ് ആർട്ടിഫാക്റ്റുകളിലേക്ക് പ്രവേശനം നൽകുകയും ചെയ്യുന്നു. അതുപോലെ, മറ്റുള്ളവർ ചെയ്ത ജോലിയിൽ നിന്ന് നിങ്ങൾക്കും പ്രയോജനം നേടാം!
+
+പുതിയ മോഡൽ റിപ്പോസിറ്ററികൾ ഉണ്ടാക്കാൻ മൂന്ന് വഴികളുണ്ട്:
+
+- `push_to_hub` API ഉപയോഗിച്ച്
+- `huggingface_hub` Python ലൈബ്രറി ഉപയോഗിച്ച്
+- വെബ് ഇന്റർഫേസ് ഉപയോഗിച്ച്
+
+ഒരു റിപ്പോസിറ്ററി ഉണ്ടാക്കിക്കഴിഞ്ഞാൽ, git-ഉം git-lfs-ഉം വഴി അതിലേക്ക് ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യാം. തുടർന്നുള്ള വിഭാഗങ്ങളിൽ മോഡൽ റിപ്പോസിറ്ററികൾ ഉണ്ടാക്കുന്നതും അവയിലേക്ക് ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യുന്നതും ഞങ്ങൾ ഘട്ടം ഘട്ടമായി കാണിച്ചുതരാം.
+
+
+## `push_to_hub` API ഉപയോഗിക്കുന്നു[[using-the-pushtohub-api]]
+
+{#if fw === 'pt'}
+
+<Youtube id="Zh0FfmVrKX0"/>
+
+{:else}
+
+<Youtube id="pUh5cGmNV8Y"/>
+
+{/if}
+
+Hub-ലേക്ക് ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യാനുള്ള ഏറ്റവും ലളിതമായ വഴി `push_to_hub` API പ്രയോജനപ്പെടുത്തുന്നതാണ്.
+
+മുന്നോട്ട് പോകുന്നതിന് മുമ്പ്, നിങ്ങൾ ആരാണെന്നും ഏതൊക്കെ നെയിംസ്‌പേസുകളിൽ നിങ്ങൾക്ക് എഴുതാനുള്ള അനുമതി (write access) ഉണ്ടെന്നും `huggingface_hub` API-ക്ക് അറിയാൻ ഒരു ഓതന്റിക്കേഷൻ ടോക്കൺ നിങ്ങൾ ജനറേറ്റ് ചെയ്യേണ്ടതുണ്ട്. `transformers` ഇൻസ്‌റ്റാൾ ചെയ്തിട്ടുള്ള ഒരു എൻവയോൺമെന്റിലാണ് നിങ്ങൾ എന്ന് ഉറപ്പാക്കുക ([സെറ്റപ്പ്](/course/chapter0) കാണുക). നിങ്ങൾ ഒരു നോട്ട്‌ബുക്കിലാണെങ്കിൽ, ലോഗിൻ ചെയ്യാൻ താഴെയുള്ള ഫംഗ്‌ഷൻ ഉപയോഗിക്കാം:
+
+```python
+from huggingface_hub import notebook_login
+
+notebook_login()
+```
+
+ഒരു ടെർമിനലിൽ, നിങ്ങൾക്ക് ഇത് റൺ ചെയ്യാം:
+
+```bash
+huggingface-cli login
+```
+
+രണ്ട് സാഹചര്യങ്ങളിലും, നിങ്ങളുടെ യൂസർനെയിമും പാസ്‌വേഡും ചോദിക്കും; Hub-ൽ ലോഗിൻ ചെയ്യാൻ നിങ്ങൾ ഉപയോഗിക്കുന്ന അതേ വിവരങ്ങളാണ് ഇവ. നിങ്ങൾക്ക് ഇതുവരെ ഒരു Hub പ്രൊഫൈൽ ഇല്ലെങ്കിൽ, [ഇവിടെ](https://huggingface.co/join) ഒന്ന് ഉണ്ടാക്കുക.
+
+കൊള്ളാം! നിങ്ങളുടെ ഓതന്റിക്കേഷൻ ടോക്കൺ ഇപ്പോൾ നിങ്ങളുടെ കാഷ് ഫോൾഡറിൽ സംഭരിച്ചിരിക്കുന്നു. ഇനി കുറച്ച് റിപ്പോസിറ്ററികൾ ഉണ്ടാക്കാം!
+
+{#if fw === 'pt'}
+
+ഒരു മോഡൽ ട്രെയിൻ ചെയ്യാൻ `Trainer` API നിങ്ങൾ പരീക്ഷിച്ചിട്ടുണ്ടെങ്കിൽ, അത് Hub-ലേക്ക് അപ്‌ലോഡ് ചെയ്യാനുള്ള ഏറ്റവും എളുപ്പമുള്ള വഴി നിങ്ങളുടെ `TrainingArguments` നിർവചിക്കുമ്പോൾ `push_to_hub=True` എന്ന് സെറ്റ് ചെയ്യുന്നതാണ്:
+
+```py
+from transformers import TrainingArguments
+
+training_args = TrainingArguments(
+    "bert-finetuned-mrpc", save_strategy="epoch", push_to_hub=True
+)
+```
+
+നിങ്ങൾ `trainer.train()` വിളിക്കുമ്പോൾ, മോഡൽ സേവ് ചെയ്യപ്പെടുന്ന ഓരോ തവണയും (ഇവിടെ ഓരോ എപ്പോക്കിലും) `Trainer` അത് നിങ്ങളുടെ നെയിംസ്‌പേസിലെ ഒരു റിപ്പോസിറ്ററിയിലേക്ക് Hub-ൽ അപ്‌ലോഡ് ചെയ്യും. നിങ്ങൾ തിരഞ്ഞെടുത്ത ഔട്ട്‌പുട്ട് ഡയറക്ടറിയുടെ പേരായിരിക്കും (ഇവിടെ `bert-finetuned-mrpc`) ആ റിപ്പോസിറ്ററിക്ക്, എന്നാൽ `hub_model_id = "a_different_name"` ഉപയോഗിച്ച് നിങ്ങൾക്ക് മറ്റൊരു പേര് തിരഞ്ഞെടുക്കാം.
+
+നിങ്ങൾ അംഗമായ ഒരു ഓർഗനൈസേഷനിലേക്ക് നിങ്ങളുടെ മോഡൽ അപ്‌ലോഡ് ചെയ്യാൻ, `hub_model_id = "my_organization/my_repo_name"` എന്ന് നൽകിയാൽ മതി.
+
+ട്രെയിനിംഗ് പൂർത്തിയായിക്കഴിഞ്ഞാൽ, നിങ്ങളുടെ മോഡലിന്റെ അവസാന പതിപ്പ് അപ്‌ലോഡ് ചെയ്യാൻ അവസാനമായി ഒരു `trainer.push_to_hub()` ചെയ്യണം. ഉപയോഗിച്ച ഹൈപ്പർപാരാമീറ്ററുകളും ഇവാല്യുവേഷൻ ഫലങ്ങളും റിപ്പോർട്ട് ചെയ്യുന്ന, പ്രസക്തമായ എല്ലാ മെറ്റാഡേറ്റയും അടങ്ങിയ ഒരു മോഡൽ കാർഡും ഇത് ജനറേറ്റ് ചെയ്യും! അങ്ങനെയുള്ള ഒരു മോഡൽ കാർഡിൽ നിങ്ങൾ കണ്ടേക്കാവുന്ന ഉള്ളടക്കത്തിന്റെ ഒരു ഉദാഹരണം ഇതാ:
+
+<div class="flex justify-center">
+  <img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/model_card.png" alt="സ്വയമേവ ജനറേറ്റ് ചെയ്ത ഒരു മോഡൽ കാർഡിന്റെ ഉദാഹരണം." width="100%"/>
+</div>
+
+{:else}
+
+നിങ്ങളുടെ മോഡൽ ട്രെയിൻ ചെയ്യാൻ Keras ആണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, അത് Hub-ലേക്ക് അപ്‌ലോഡ് ചെയ്യാനുള്ള ഏറ്റവും എളുപ്പമുള്ള വഴി `model.fit()` വിളിക്കുമ്പോൾ ഒരു `PushToHubCallback` കൈമാറുന്നതാണ്:
+
+```py
+from transformers import PushToHubCallback
+
+callback = PushToHubCallback(
+    "bert-finetuned-mrpc", save_strategy="epoch", tokenizer=tokenizer
+)
+```
+
+തുടർന്ന് നിങ്ങളുടെ `model.fit()` കോളിൽ `callbacks=[callback]` ചേർക്കണം. മോഡൽ സേവ് ചെയ്യപ്പെടുന്ന ഓരോ തവണയും (ഇവിടെ ഓരോ എപ്പോക്കിലും) കോൾബാക്ക് അത് നിങ്ങളുടെ നെയിംസ്‌പേസിലെ ഒരു റിപ്പോസിറ്ററിയിലേക്ക് Hub-ൽ അപ്‌ലോഡ് ചെയ്യും. നിങ്ങൾ തിരഞ്ഞെടുത്ത ഔട്ട്‌പുട്ട് ഡയറക്ടറിയുടെ പേരായിരിക്കും (ഇവിടെ `bert-finetuned-mrpc`) ആ റിപ്പോസിറ്ററിക്ക്, എന്നാൽ `hub_model_id = "a_different_name"` ഉപയോഗിച്ച് നിങ്ങൾക്ക് മറ്റൊരു പേര് തിരഞ്ഞെടുക്കാം.
+
+നിങ്ങൾ അംഗമായ ഒരു ഓർഗനൈസേഷനിലേക്ക് നിങ്ങളുടെ മോഡൽ അപ്‌ലോഡ് ചെയ്യാൻ, `hub_model_id = "my_organization/my_repo_name"` എന്ന് നൽകിയാൽ മതി.
+
+{/if}
+
+കുറച്ചുകൂടി താഴ്ന്ന തലത്തിൽ, മോഡലുകൾ, ടോക്കണൈസറുകൾ, കോൺഫിഗറേഷൻ ഒബ്‌ജക്റ്റുകൾ എന്നിവയുടെ `push_to_hub()` മെത്തേഡ് വഴി അവയിൽ നേരിട്ട് Model Hub ആക്‌സസ് ചെയ്യാം. റിപ്പോസിറ്ററി ഉണ്ടാക്കുന്നതും മോഡൽ, ടോക്കണൈസർ ഫയലുകൾ നേരിട്ട് റിപ്പോസിറ്ററിയിലേക്ക് പുഷ് ചെയ്യുന്നതും ഈ മെത്തേഡ് തന്നെ കൈകാര്യം ചെയ്യുന്നു. താഴെ നമ്മൾ കാണുന്ന API-യിൽ നിന്ന് വ്യത്യസ്തമായി, ഇവിടെ മാനുവലായി ഒന്നും ചെയ്യേണ്ടതില്ല.
+
+ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാൻ, ആദ്യം ഒരു മോഡലും ഒരു ടോക്കണൈസറും ഇനിഷ്യലൈസ് ചെയ്യാം:
+
+{#if fw === 'pt'}
+```py
+from transformers import AutoModelForMaskedLM, AutoTokenizer
+
+checkpoint = "camembert-base"
+
+model = AutoModelForMaskedLM.from_pretrained(checkpoint)
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+```
+{:else}
+```py
+from transformers import TFAutoModelForMaskedLM, AutoTokenizer
+
+checkpoint = "camembert-base"
+
+model = TFAutoModelForMaskedLM.from_pretrained(checkpoint)
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+```
+{/if}
+
+ഇവ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇഷ്ടമുള്ളതെന്തും ചെയ്യാം — ടോക്കണൈസറിലേക്ക് ടോക്കണുകൾ ചേർക്കുക, മോഡൽ ട്രെയിൻ ചെയ്യുക, ഫൈൻ-ട്യൂൺ ചെയ്യുക. ലഭിച്ച മോഡൽ, വെയ്‌റ്റുകൾ, ടോക്കണൈസർ എന്നിവയിൽ നിങ്ങൾ തൃപ്തരായിക്കഴിഞ്ഞാൽ, `model` ഒബ്‌ജക്റ്റിൽ നേരിട്ട് ലഭ്യമായ `push_to_hub()` മെത്തേഡ് നിങ്ങൾക്ക് പ്രയോജനപ്പെടുത്താം:
+
+```py
+model.push_to_hub("dummy-model")
+```
+
+ഇത് നിങ്ങളുടെ പ്രൊഫൈലിൽ `dummy-model` എന്ന പുതിയ റിപ്പോസിറ്ററി ഉണ്ടാക്കി, നിങ്ങളുടെ മോഡൽ ഫയലുകൾ അതിൽ നിറയ്ക്കും.
+ടോക്കണൈസറിനും ഇതേ കാര്യം ചെയ്യുക, അങ്ങനെ എല്ലാ ഫയലുകളും ഇപ്പോൾ ഈ റിപ്പോസിറ്ററിയിൽ ലഭ്യമാകും:
+
+```py
+tokenizer.push_to_hub("dummy-model")
+```
+
+നിങ്ങൾ ഒരു ഓർഗനൈസേഷനിൽ അംഗമാണെങ്കിൽ, ആ ഓർഗനൈസേഷന്റെ നെയിംസ്‌പേസിലേക്ക് അപ്‌ലോഡ് ചെയ്യാൻ `organization` ആർഗ്യുമെന്റ് വ്യക്തമാക്കിയാൽ മതി:
+
+```py
+tokenizer.push_to_hub("dummy-model", organization="huggingface")
+```
+
+ഒരു പ്രത്യേക Hugging Face ടോക്കൺ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നെങ്കിൽ, അതും `push_to_hub()` മെത്തേഡിന് നൽകാൻ നിങ്ങൾക്ക് സ്വാതന്ത്ര്യമുണ്ട്:
+
+```py
+tokenizer.push_to_hub("dummy-model", organization="huggingface", use_auth_token="<TOKEN>")
+```
+
+ഇനി Model Hub-ലേക്ക് പോയി നിങ്ങൾ പുതുതായി അപ്‌ലോഡ് ചെയ്ത മോഡൽ കണ്ടെത്തുക: *https://huggingface.co/user-or-organization/dummy-model*.
+
+"Files and versions" ടാബിൽ ക്ലിക്ക് ചെയ്യുക; താഴെയുള്ള സ്ക്രീൻഷോട്ടിൽ കാണുന്ന ഫയലുകൾ നിങ്ങൾക്ക് കാണാൻ കഴിയണം:
+
+{#if fw === 'pt'}
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/push_to_hub_dummy_model.png" alt="ടോക്കണൈസർ ഫയലുകളും മോഡൽ ഫയലുകളും അടങ്ങിയ ഡമ്മി മോഡൽ." width="80%"/>
+</div>
+{:else}
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/push_to_hub_dummy_model_tf.png" alt="ടോക്കണൈസർ ഫയലുകളും മോഡൽ ഫയലുകളും അടങ്ങിയ ഡമ്മി മോഡൽ." width="80%"/>
+</div>
+{/if}
+
+> [!TIP]
+> ✏️ **സ്വയം പരീക്ഷിക്കുക!** `bert-base-cased` ചെക്ക്‌പോയിന്റുമായി ബന്ധപ്പെട്ട മോഡലും ടോക്കണൈസറും എടുത്ത്, `push_to_hub()` മെത്തേഡ് ഉപയോഗിച്ച് നിങ്ങളുടെ നെയിംസ്‌പേസിലെ ഒരു റിപ്പോയിലേക്ക് അപ്‌ലോഡ് ചെയ്യുക. റിപ്പോ ഡിലീറ്റ് ചെയ്യുന്നതിന് മുമ്പ് അത് നിങ്ങളുടെ പേജിൽ ശരിയായി കാണുന്നുണ്ടെന്ന് ഒന്നുകൂടി ഉറപ്പുവരുത്തുക.
+
+നിങ്ങൾ കണ്ടതുപോലെ, `push_to_hub()` മെത്തേഡ് പല ആർഗ്യുമെന്റുകൾ സ്വീകരിക്കുന്നു; അതുവഴി ഒരു പ്രത്യേക റിപ്പോസിറ്ററിയിലേക്കോ ഓർഗനൈസേഷൻ നെയിംസ്‌പേസിലേക്കോ അപ്‌ലോഡ് ചെയ്യാനും, മറ്റൊരു API ടോക്കൺ ഉപയോഗിക്കാനും സാധിക്കും. എന്തൊക്കെ സാധ്യമാണ് എന്ന് മനസ്സിലാക്കാൻ [🤗 Transformers ഡോക്യുമെന്റേഷനിൽ](https://huggingface.co/transformers/model_sharing) നേരിട്ട് ലഭ്യമായ മെത്തേഡ് സ്‌പെസിഫിക്കേഷൻ ഒന്ന് നോക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.
+
+`push_to_hub()` മെത്തേഡിന് പിന്നിൽ പ്രവർത്തിക്കുന്നത് [`huggingface_hub`](https://github.com/huggingface/huggingface_hub) Python പാക്കേജാണ്; ഇത് Hugging Face Hub-ലേക്ക് ഒരു നേരിട്ടുള്ള API നൽകുന്നു. 🤗 Transformers-ലും, [`allenlp`](https://github.com/allenai/allennlp) പോലുള്ള മറ്റ് പല മെഷീൻ ലേണിംഗ് ലൈബ്രറികളിലും ഇത് ഇന്റഗ്രേറ്റ് ചെയ്തിട്ടുണ്ട്. ഈ അധ്യായത്തിൽ നമ്മൾ 🤗 Transformers ഇന്റഗ്രേഷനിലാണ് ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നതെങ്കിലും, നിങ്ങളുടെ സ്വന്തം കോഡിലോ ലൈബ്രറിയിലോ ഇത് ഇന്റഗ്രേറ്റ് ചെയ്യുന്നത് ലളിതമാണ്.
+
+നിങ്ങൾ പുതുതായി ഉണ്ടാക്കിയ റിപ്പോസിറ്ററിയിലേക്ക് ഫയലുകൾ എങ്ങനെ അപ്‌ലോഡ് ചെയ്യാമെന്ന് കാണാൻ അവസാന വിഭാഗത്തിലേക്ക് പോകുക!
+
+## `huggingface_hub` Python ലൈബ്രറി ഉപയോഗിക്കുന്നു[[using-the-huggingfacehub-python-library]]
+
+`huggingface_hub` Python ലൈബ്രറി, മോഡൽ, ഡേറ്റാസെറ്റ് ഹബ്ബുകൾക്കായുള്ള ഒരു കൂട്ടം ടൂളുകൾ നൽകുന്ന ഒരു പാക്കേജാണ്. Hub-ലെ റിപ്പോസിറ്ററികളെക്കുറിച്ചുള്ള വിവരങ്ങൾ നേടുക, അവ കൈകാര്യം ചെയ്യുക തുടങ്ങിയ 
+സാധാരണ ടാസ്‌ക്കുകൾക്കായി ലളിതമായ മെത്തേഡുകളും ക്ലാസുകളും ഇത് നൽകുന്നു. ആ റിപ്പോസിറ്ററികളുടെ ഉള്ളടക്കം കൈകാര്യം ചെയ്യാനും നിങ്ങളുടെ പ്രോജക്റ്റുകളിലും ലൈബ്രറികളിലും Hub-നെ
+സംയോജിപ്പിക്കാനും git-ന് മുകളിൽ പ്രവർത്തിക്കുന്ന ലളിതമായ API-കളും ഇത് നൽകുന്നു.
+
+`push_to_hub` API ഉപയോഗിക്കുന്നതുപോലെ, ഇതിനും നിങ്ങളുടെ API ടോക്കൺ കാഷിൽ സേവ് ചെയ്തിരിക്കണം. അതിനായി, മുൻ വിഭാഗത്തിൽ പറഞ്ഞതുപോലെ CLI-യിലെ `login` കമാൻഡ് നിങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട് (Google Colab-ൽ റൺ ചെയ്യുന്നെങ്കിൽ ഈ കമാൻഡുകൾക്ക് മുന്നിൽ `!` എന്ന ചിഹ്നം ചേർക്കാൻ വീണ്ടും ഓർക്കുക):
+
+```bash
+huggingface-cli login
+```
+
+നമ്മുടെ ആവശ്യത്തിന് ഉപകാരപ്രദമായ പല മെത്തേഡുകളും ക്ലാസുകളും `huggingface_hub` പാക്കേജ് നൽകുന്നു. ആദ്യമായി, റിപ്പോസിറ്ററി ഉണ്ടാക്കൽ, ഡിലീറ്റ് ചെയ്യൽ തുടങ്ങിയവ കൈകാര്യം ചെയ്യാൻ ഏതാനും മെത്തേഡുകളുണ്ട്:
+
+```python no-format
+from huggingface_hub import (
+    # User management
+    login,
+    logout,
+    whoami,
+
+    # Repository creation and management
+    create_repo,
+    delete_repo,
+    update_repo_visibility,
+
+    # And some methods to retrieve/change information about the content
+    list_models,
+    list_datasets,
+    list_metrics,
+    list_repo_files,
+    upload_file,
+    delete_file,
+)
+```
+
+
+കൂടാതെ, ഒരു ലോക്കൽ റിപ്പോസിറ്ററി കൈകാര്യം ചെയ്യാൻ വളരെ ശക്തമായ `Repository` ക്ലാസും ഇത് നൽകുന്നു. ഇവ എങ്ങനെ പ്രയോജനപ്പെടുത്താം എന്ന് മനസ്സിലാക്കാൻ അടുത്ത ഏതാനും വിഭാഗങ്ങളിൽ ഈ മെത്തേഡുകളും ആ ക്ലാസും നമ്മൾ പരിശോധിക്കും.
+
+Hub-ൽ ഒരു പുതിയ റിപ്പോസിറ്ററി ഉണ്ടാക്കാൻ `create_repo` മെത്തേഡ് ഉപയോഗിക്കാം:
+
+```py
+from huggingface_hub import create_repo
+
+create_repo("dummy-model")
+```
+
+ഇത് നിങ്ങളുടെ നെയിംസ്‌പേസിൽ `dummy-model` എന്ന റിപ്പോസിറ്ററി ഉണ്ടാക്കും. വേണമെങ്കിൽ, `organization` ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് റിപ്പോസിറ്ററി ഏത് ഓർഗനൈസേഷന്റേതായിരിക്കണം എന്ന് നിങ്ങൾക്ക് വ്യക്തമാക്കാം:
+
+```py
+from huggingface_hub import create_repo
+
+create_repo("dummy-model", organization="huggingface")
+```
+
+നിങ്ങൾ ആ ഓർഗനൈസേഷനിൽ അംഗമാണെങ്കിൽ, ഇത് `huggingface` നെയിംസ്‌പേസിൽ `dummy-model` റിപ്പോസിറ്ററി ഉണ്ടാക്കും.
+ഉപകാരപ്രദമാകാവുന്ന മറ്റ് ആർഗ്യുമെന്റുകൾ:
+
+- `private`, റിപ്പോസിറ്ററി മറ്റുള്ളവർക്ക് കാണാവുന്നതായിരിക്കണോ വേണ്ടയോ എന്ന് വ്യക്തമാക്കാൻ.
+- `token`, നിങ്ങളുടെ കാഷിൽ സംഭരിച്ചിരിക്കുന്ന ടോക്കണിന് പകരം ഒരു നിശ്ചിത ടോക്കൺ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നെങ്കിൽ.
+- `repo_type`, ഒരു മോഡലിന് പകരം ഒരു `dataset` അല്ലെങ്കിൽ ഒരു `space` ഉണ്ടാക്കാൻ ആഗ്രഹിക്കുന്നെങ്കിൽ. സ്വീകരിക്കുന്ന മൂല്യങ്ങൾ `"dataset"`, `"space"` എന്നിവയാണ്.
+
+റിപ്പോസിറ്ററി ഉണ്ടാക്കിക്കഴിഞ്ഞാൽ, അതിലേക്ക് ഫയലുകൾ ചേർക്കണം! ഇത് ചെയ്യാവുന്ന മൂന്ന് വഴികൾ കാണാൻ അടുത്ത വിഭാഗത്തിലേക്ക് പോകുക.
+
+
+## വെബ് ഇന്റർഫേസ് ഉപയോഗിക്കുന്നു[[using-the-web-interface]]
+
+Hub-ൽ നേരിട്ട് റിപ്പോസിറ്ററികൾ കൈകാര്യം ചെയ്യാനുള്ള ടൂളുകൾ വെബ് ഇന്റർഫേസ് നൽകുന്നു. ഇന്റർഫേസ് ഉപയോഗിച്ച്, റിപ്പോസിറ്ററികൾ ഉണ്ടാക്കാനും, ഫയലുകൾ (വലുതായവ പോലും!) ചേർക്കാനും, മോഡലുകൾ പരിശോധിക്കാനും, ഡിഫുകൾ (diffs) കാണാനും, മറ്റ് പലതും എളുപ്പത്തിൽ ചെയ്യാം.
+
+ഒരു പുതിയ റിപ്പോസിറ്ററി ഉണ്ടാക്കാൻ, [huggingface.co/new](https://huggingface.co/new) സന്ദർശിക്കുക:
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/new_model.png" alt="ഒരു പുതിയ മോഡൽ റിപ്പോസിറ്ററി ഉണ്ടാക്കാൻ ഉപയോഗിക്കുന്ന പേജ്." width="80%"/>
+</div>
+
+ആദ്യം, റിപ്പോസിറ്ററിയുടെ ഉടമ ആരാണെന്ന് വ്യക്തമാക്കുക: ഇത് നിങ്ങളോ, നിങ്ങൾ ഭാഗമായ ഏതെങ്കിലും ഓർഗനൈസേഷനോ ആകാം. ഒരു ഓർഗനൈസേഷൻ തിരഞ്ഞെടുത്താൽ, മോഡൽ ആ ഓർഗനൈസേഷന്റെ പേജിൽ പ്രദർശിപ്പിക്കപ്പെടും, കൂടാതെ ഓർഗനൈസേഷനിലെ ഓരോ അംഗത്തിനും റിപ്പോസിറ്ററിയിലേക്ക് സംഭാവന ചെയ്യാൻ കഴിയും.
+
+അടുത്തതായി, നിങ്ങളുടെ മോഡലിന്റെ പേര് നൽകുക. ഇത് തന്നെയായിരിക്കും റിപ്പോസിറ്ററിയുടെ പേരും. അവസാനമായി, നിങ്ങളുടെ മോഡൽ പബ്ലിക് ആയിരിക്കണോ പ്രൈവറ്റ് ആയിരിക്കണോ എന്ന് വ്യക്തമാക്കാം. പ്രൈവറ്റ് മോഡലുകൾ പൊതുജനങ്ങൾക്ക് കാണാൻ കഴിയില്ല.
+
+നിങ്ങളുടെ മോഡൽ റിപ്പോസിറ്ററി ഉണ്ടാക്കിയ ശേഷം, ഇതുപോലൊരു പേജ് നിങ്ങൾക്ക് കാണാൻ കഴിയണം:
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/empty_model.png" alt="ഒരു പുതിയ റിപ്പോസിറ്ററി ഉണ്ടാക്കിയ ശേഷമുള്ള ഒഴിഞ്ഞ മോഡൽ പേജ്." width="80%"/>
+</div>
+
+ഇവിടെയാണ് നിങ്ങളുടെ മോഡൽ ഹോസ്‌റ്റ് ചെയ്യപ്പെടുന്നത്. ഇതിൽ ഉള്ളടക്കം ചേർക്കാൻ തുടങ്ങാൻ, വെബ് ഇന്റർഫേസിൽ നിന്ന് നേരിട്ട് ഒരു README ഫയൽ ചേർക്കാം.
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/dummy_model.png" alt="Markdown സാധ്യതകൾ കാണിക്കുന്ന README ഫയൽ." width="80%"/>
+</div>
+
+README ഫയൽ Markdown-ലാണ് — അതിൽ നിങ്ങൾക്ക് ഇഷ്ടമുള്ളതുപോലെ പരീക്ഷിക്കാം! ഈ അധ്യായത്തിന്റെ മൂന്നാം ഭാഗം ഒരു മോഡൽ കാർഡ് നിർമ്മിക്കുന്നതിനായി മാറ്റിവെച്ചിരിക്കുന്നു. നിങ്ങളുടെ മോഡലിന് മൂല്യം നൽകുന്നതിൽ ഇവയ്ക്ക് വളരെ പ്രധാന പങ്കുണ്ട്, കാരണം മോഡലിന് എന്തൊക്കെ ചെയ്യാൻ കഴിയുമെന്ന് മറ്റുള്ളവരോട് പറയുന്നത് ഇവിടെയാണ്.
+
+"Files and versions" ടാബ് നോക്കിയാൽ, അവിടെ ഇതുവരെ അധികം ഫയലുകൾ ഇല്ലെന്ന് കാണാം — നിങ്ങൾ ഇപ്പോൾ ഉണ്ടാക്കിയ *README.md*-ഉം, വലിയ ഫയലുകളുടെ ട്രാക്ക് സൂക്ഷിക്കുന്ന *.gitattributes* ഫയലും മാത്രം.
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/files.png" alt="'Files and versions' ടാബിൽ .gitattributes, README.md ഫയലുകൾ മാത്രം കാണിക്കുന്നു." width="80%"/>
+</div>
+
+അടുത്തതായി, കുറച്ച് പുതിയ ഫയലുകൾ എങ്ങനെ ചേർക്കാം എന്ന് നോക്കാം.
+
+## മോഡൽ ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യുന്നു[[uploading-the-model-files]]
+
+Hugging Face Hub-ൽ ഫയലുകൾ കൈകാര്യം ചെയ്യുന്ന സിസ്‌റ്റം, സാധാരണ ഫയലുകൾക്ക് git-ഉം, വലിയ ഫയലുകൾക്ക് git-lfs-ഉം ([Git Large File Storage](https://git-lfs.github.com/) എന്നതിന്റെ ചുരുക്കം) അടിസ്ഥാനമാക്കിയുള്ളതാണ്. 
+
+അടുത്ത വിഭാഗത്തിൽ, Hub-ലേക്ക് ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യാനുള്ള മൂന്ന് വ്യത്യസ്ത വഴികൾ നമ്മൾ പരിശോധിക്കും: `huggingface_hub` വഴിയും git കമാൻഡുകൾ വഴിയും.
+
+### `upload_file` രീതി[[the-uploadfile-approach]]
+
+`upload_file` ഉപയോഗിക്കാൻ നിങ്ങളുടെ സിസ്‌റ്റത്തിൽ git-ഉം git-lfs-ഉം ഇൻസ്‌റ്റാൾ ചെയ്തിരിക്കണമെന്നില്ല. HTTP POST റിക്വസ്‌റ്റുകൾ ഉപയോഗിച്ച് ഇത് ഫയലുകൾ നേരിട്ട് 🤗 Hub-ലേക്ക് പുഷ് ചെയ്യുന്നു. 5GB-യിൽ കൂടുതൽ വലുപ്പമുള്ള ഫയലുകൾ ഇത് കൈകാര്യം ചെയ്യില്ല എന്നതാണ് ഈ രീതിയുടെ ഒരു പരിമിതി.
+നിങ്ങളുടെ ഫയലുകൾ 5GB-യിൽ കൂടുതലാണെങ്കിൽ, താഴെ വിശദീകരിക്കുന്ന മറ്റ് രണ്ട് രീതികൾ പിന്തുടരുക.
+
+API ഇങ്ങനെ ഉപയോഗിക്കാം:
+
+```py
+from huggingface_hub import upload_file
+
+upload_file(
+    "<path_to_file>/config.json",
+    path_in_repo="config.json",
+    repo_id="<namespace>/dummy-model",
+)
+```
+
+ഇത് `<path_to_file>`-ൽ ലഭ്യമായ `config.json` ഫയലിനെ `config.json` എന്ന പേരിൽ `dummy-model` റിപ്പോസിറ്ററിയുടെ റൂട്ടിലേക്ക് അപ്‌ലോഡ് ചെയ്യും.
+ഉപകാരപ്രദമാകാവുന്ന മറ്റ് ആർഗ്യുമെന്റുകൾ:
+
+- `token`, നിങ്ങളുടെ കാഷിൽ സംഭരിച്ചിരിക്കുന്ന ടോക്കണിന് പകരം ഒരു നിശ്ചിത ടോക്കൺ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നെങ്കിൽ.
+- `repo_type`, ഒരു മോഡലിന് പകരം ഒരു `dataset`-ലേക്കോ `space`-ലേക്കോ അപ്‌ലോഡ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നെങ്കിൽ. സ്വീകരിക്കുന്ന മൂല്യങ്ങൾ `"dataset"`, `"space"` എന്നിവയാണ്.
+
+
+### `Repository` ക്ലാസ്[[the-repository-class]]
+
+`Repository` ക്ലാസ് ഒരു ലോക്കൽ റിപ്പോസിറ്ററിയെ git-ന് സമാനമായ രീതിയിൽ കൈകാര്യം ചെയ്യുന്നു. git ഉപയോഗിക്കുമ്പോൾ ഉണ്ടാകാവുന്ന മിക്ക ബുദ്ധിമുട്ടുകളും മറച്ചുവെച്ച് (abstract), നമുക്ക് ആവശ്യമായ എല്ലാ ഫീച്ചറുകളും ഇത് നൽകുന്നു. 
+
+ഈ ക്ലാസ് ഉപയോഗിക്കാൻ git-ഉം git-lfs-ഉം ഇൻസ്‌റ്റാൾ ചെയ്തിരിക്കണം; അതിനാൽ തുടങ്ങുന്നതിന് മുമ്പ് git-lfs ഇൻസ്‌റ്റാൾ ചെയ്ത് (ഇൻസ്‌റ്റാളേഷൻ നിർദ്ദേശങ്ങൾക്ക് [ഇവിടെ](https://git-lfs.github.com/) കാണുക) സെറ്റപ്പ് ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. 
+
+നമ്മൾ ഇപ്പോൾ ഉണ്ടാക്കിയ റിപ്പോസിറ്ററിയുമായി പ്രവർത്തിക്കാൻ തുടങ്ങാൻ, റിമോട്ട് റിപ്പോസിറ്ററി ക്ലോൺ ചെയ്ത് അതിനെ ഒരു ലോക്കൽ ഫോൾഡറിലേക്ക് ഇനിഷ്യലൈസ് ചെയ്യുന്നതിലൂടെ തുടങ്ങാം:
+
+```py
+from huggingface_hub import Repository
+
+repo = Repository("<path_to_dummy_folder>", clone_from="<namespace>/dummy-model")
+```
+
+ഇത് നമ്മുടെ വർക്കിംഗ് ഡയറക്ടറിയിൽ `<path_to_dummy_folder>` എന്ന ഫോൾഡർ ഉണ്ടാക്കി. `create_repo` വഴി റിപ്പോസിറ്ററി ഉണ്ടാക്കുമ്പോൾ സൃഷ്ടിക്കപ്പെടുന്ന ഒരേയൊരു ഫയൽ `.gitattributes` ആയതിനാൽ, ഈ ഫോൾഡറിൽ ആ ഫയൽ മാത്രമേ ഉണ്ടാകൂ.
+
+ഇവിടെ നിന്ന്, പരമ്പരാഗത git മെത്തേഡുകളിൽ പലതും നമുക്ക് പ്രയോജനപ്പെടുത്താം:
+
+```py
+repo.git_pull()
+repo.git_add()
+repo.git_commit()
+repo.git_push()
+repo.git_tag()
+```
+
+ഇനിയും പലതും! ലഭ്യമായ എല്ലാ മെത്തേഡുകളുടെയും ഒരു അവലോകനത്തിനായി [ഇവിടെ](https://github.com/huggingface/huggingface_hub/tree/main/src/huggingface_hub#advanced-programmatic-repository-management) ലഭ്യമായ `Repository` ഡോക്യുമെന്റേഷൻ ഒന്ന് നോക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.
+
+ഇപ്പോൾ, Hub-ലേക്ക് പുഷ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ഒരു മോഡലും ഒരു ടോക്കണൈസറും നമ്മുടെ പക്കലുണ്ട്. റിപ്പോസിറ്ററി നമ്മൾ വിജയകരമായി ക്ലോൺ ചെയ്തിട്ടുണ്ട്, അതിനാൽ ആ റിപ്പോസിറ്ററിക്കുള്ളിൽ നമുക്ക് ഫയലുകൾ സേവ് ചെയ്യാം.
+
+ഏറ്റവും പുതിയ മാറ്റങ്ങൾ പുൾ ചെയ്ത് നമ്മുടെ ലോക്കൽ ക്ലോൺ കാലികമാണെന്ന് ആദ്യം ഉറപ്പാക്കാം:
+
+```py
+repo.git_pull()
+```
+
+അത് കഴിഞ്ഞാൽ, മോഡൽ, ടോക്കണൈസർ ഫയലുകൾ സേവ് ചെയ്യാം:
+
+```py
+model.save_pretrained("<path_to_dummy_folder>")
+tokenizer.save_pretrained("<path_to_dummy_folder>")
+```
+
+`<path_to_dummy_folder>`-ൽ ഇപ്പോൾ എല്ലാ മോഡൽ, ടോക്കണൈസർ ഫയലുകളും ഉണ്ട്. ഫയലുകൾ സ്‌റ്റേജിംഗ് ഏരിയയിലേക്ക് ചേർത്ത്, കമ്മിറ്റ് ചെയ്ത്, Hub-ലേക്ക് പുഷ് ചെയ്യുന്ന സാധാരണ git വർക്ക്‌ഫ്ലോ നമ്മൾ പിന്തുടരുന്നു:
+
+```py
+repo.git_add()
+repo.git_commit("Add model and tokenizer files")
+repo.git_push()
+```
+
+അഭിനന്ദനങ്ങൾ! നിങ്ങൾ ആദ്യമായി Hub-ലേക്ക് ഫയലുകൾ പുഷ് ചെയ്തിരിക്കുന്നു.
+
+### git അടിസ്ഥാനമാക്കിയ രീതി[[the-git-based-approach]]
+
+ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യാനുള്ള ഏറ്റവും അടിസ്ഥാനപരമായ രീതിയാണിത്: git-ഉം git-lfs-ഉം നേരിട്ട് ഉപയോഗിച്ചാണ് നമ്മൾ ഇത് ചെയ്യുന്നത്. മുമ്പത്തെ രീതികൾ ബുദ്ധിമുട്ടുകളിൽ ഭൂരിഭാഗവും മറച്ചുവെക്കുന്നു, എന്നാൽ താഴെയുള്ള രീതിയിൽ ചില മുന്നറിയിപ്പുകൾ (caveats) ഉള്ളതിനാൽ കുറച്ചുകൂടി സങ്കീർണ്ണമായ ഒരു ഉപയോഗസന്ദർഭം നമ്മൾ പിന്തുടരും.
+
+ഈ ക്ലാസ് ഉപയോഗിക്കാൻ git-ഉം git-lfs-ഉം ഇൻസ്‌റ്റാൾ ചെയ്തിരിക്കണം; അതിനാൽ തുടങ്ങുന്നതിന് മുമ്പ് [git-lfs](https://git-lfs.github.com/) ഇൻസ്‌റ്റാൾ ചെയ്ത് (ഇൻസ്‌റ്റാളേഷൻ നിർദ്ദേശങ്ങൾക്ക് ഇവിടെ കാണുക) സെറ്റപ്പ് ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. 
+
+ആദ്യം git-lfs ഇനിഷ്യലൈസ് ചെയ്ത് തുടങ്ങാം:
+
+```bash
+git lfs install
+```
+
+```bash
+Updated git hooks.
+Git LFS initialized.
+```
+
+അത് കഴിഞ്ഞാൽ, ആദ്യ ഘട്ടം നിങ്ങളുടെ മോഡൽ റിപ്പോസിറ്ററി ക്ലോൺ ചെയ്യുകയാണ്:
+
+```bash
+git clone https://huggingface.co/<namespace>/<your-model-id>
+```
+
+എന്റെ യൂസർനെയിം `lysandre` ആണ്, ഞാൻ `dummy` എന്ന മോഡൽ പേരാണ് ഉപയോഗിച്ചത്; അതിനാൽ എനിക്ക് കമാൻഡ് ഇങ്ങനെയാണ് വരുന്നത്:
+
+```
+git clone https://huggingface.co/lysandre/dummy
+```
+
+ഇപ്പോൾ എന്റെ വർക്കിംഗ് ഡയറക്ടറിയിൽ *dummy* എന്ന പേരിൽ ഒരു ഫോൾഡർ ഉണ്ട്. ആ ഫോൾഡറിലേക്ക് `cd` ചെയ്ത് അതിലെ ഉള്ളടക്കം നോക്കാം:
+
+```bash
+cd dummy && ls
+```
+
+```bash
+README.md
+```
+
+Hugging Face Hub-ന്റെ `create_repo` മെത്തേഡ് ഉപയോഗിച്ചാണ് നിങ്ങൾ റിപ്പോസിറ്ററി ഉണ്ടാക്കിയതെങ്കിൽ, ഈ ഫോൾഡറിൽ മറഞ്ഞിരിക്കുന്ന (hidden) ഒരു `.gitattributes` ഫയൽ മാത്രമേ ഉണ്ടാകൂ. മുൻ വിഭാഗത്തിലെ നിർദ്ദേശങ്ങൾ പിന്തുടർന്ന് വെബ് ഇന്റർഫേസ് ഉപയോഗിച്ചാണ് റിപ്പോസിറ്ററി ഉണ്ടാക്കിയതെങ്കിൽ, ഇവിടെ കാണിച്ചിരിക്കുന്നതുപോലെ, മറഞ്ഞിരിക്കുന്ന `.gitattributes` ഫയലിനൊപ്പം ഒരു *README.md* ഫയലും ഫോൾഡറിൽ ഉണ്ടാകും.
+
+ഒരു കോൺഫിഗറേഷൻ ഫയൽ, ഒരു വൊക്കാബുലറി ഫയൽ, അല്ലെങ്കിൽ ഏതാനും മെഗാബൈറ്റിൽ താഴെയുള്ള ഏത് ഫയലും പോലുള്ള സാധാരണ വലുപ്പമുള്ള ഒരു ഫയൽ ചേർക്കുന്നത്, git അടിസ്ഥാനമാക്കിയ ഏത് സിസ്‌റ്റത്തിലും ചെയ്യുന്നതുപോലെ തന്നെയാണ്. എന്നാൽ, വലിയ ഫയലുകൾ *huggingface.co*-യിലേക്ക് പുഷ് ചെയ്യാൻ അവ git-lfs വഴി രജിസ്‌റ്റർ ചെയ്യണം. 
+
+നമ്മുടെ dummy റിപ്പോസിറ്ററിയിലേക്ക് കമ്മിറ്റ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ഒരു മോഡലും ടോക്കണൈസറും ജനറേറ്റ് ചെയ്യാൻ, കുറച്ചുനേരത്തേക്ക് Python-ലേക്ക് തിരികെ പോകാം:
+
+{#if fw === 'pt'}
+```py
+from transformers import AutoModelForMaskedLM, AutoTokenizer
+
+checkpoint = "camembert-base"
+
+model = AutoModelForMaskedLM.from_pretrained(checkpoint)
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+
+# Do whatever with the model, train it, fine-tune it...
+
+model.save_pretrained("<path_to_dummy_folder>")
+tokenizer.save_pretrained("<path_to_dummy_folder>")
+```
+{:else}
+```py
+from transformers import TFAutoModelForMaskedLM, AutoTokenizer
+
+checkpoint = "camembert-base"
+
+model = TFAutoModelForMaskedLM.from_pretrained(checkpoint)
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+
+# Do whatever with the model, train it, fine-tune it...
+
+model.save_pretrained("<path_to_dummy_folder>")
+tokenizer.save_pretrained("<path_to_dummy_folder>")
+```
+{/if}
+
+ഇപ്പോൾ കുറച്ച് മോഡൽ, ടോക്കണൈസർ ആർട്ടിഫാക്റ്റുകൾ സേവ് ചെയ്തിരിക്കുന്നതിനാൽ, *dummy* ഫോൾഡർ ഒന്നുകൂടി നോക്കാം:
+
+```bash
+ls
+```
+
+{#if fw === 'pt'}
+```bash
+config.json  pytorch_model.bin  README.md  sentencepiece.bpe.model  special_tokens_map.json tokenizer_config.json  tokenizer.json
+```
+
+ഫയലുകളുടെ വലുപ്പം നോക്കിയാൽ (ഉദാഹരണത്തിന്, `ls -lh` ഉപയോഗിച്ച്), 400 MB-യിൽ കൂടുതൽ വലുപ്പമുള്ള മോഡൽ സ്‌റ്റേറ്റ് ഡിക്‌റ്റ് ഫയൽ (*pytorch_model.bin*) മാത്രമാണ് വേറിട്ടുനിൽക്കുന്നത് എന്ന് കാണാം.
+
+{:else}
+```bash
+config.json  README.md  sentencepiece.bpe.model  special_tokens_map.json  tf_model.h5  tokenizer_config.json  tokenizer.json
+```
+
+ഫയലുകളുടെ വലുപ്പം നോക്കിയാൽ (ഉദാഹരണത്തിന്, `ls -lh` ഉപയോഗിച്ച്), 400 MB-യിൽ കൂടുതൽ വലുപ്പമുള്ള മോഡൽ സ്‌റ്റേറ്റ് ഡിക്‌റ്റ് ഫയൽ (*t5_model.h5*) മാത്രമാണ് വേറിട്ടുനിൽക്കുന്നത് എന്ന് കാണാം.
+
+{/if}
+
+> [!TIP]
+> ✏️ വെബ് ഇന്റർഫേസിൽ നിന്ന് റിപ്പോസിറ്ററി ഉണ്ടാക്കുമ്പോൾ, *.bin*, *.h5* പോലുള്ള ചില എക്‌സ്‌റ്റൻഷനുകളുള്ള ഫയലുകളെ വലിയ ഫയലുകളായി പരിഗണിക്കാൻ *.gitattributes* ഫയൽ സ്വയമേവ സെറ്റപ്പ് ചെയ്യപ്പെടുന്നു; നിങ്ങളുടെ ഭാഗത്ത് ഒരു സെറ്റപ്പും ആവശ്യമില്ലാതെ git-lfs അവയെ ട്രാക്ക് ചെയ്യും. 
+
+ഇനി പരമ്പരാഗത Git റിപ്പോസിറ്ററികളിൽ സാധാരണ ചെയ്യുന്നതുപോലെ നമുക്ക് മുന്നോട്ട് പോകാം. `git add` കമാൻഡ് ഉപയോഗിച്ച് എല്ലാ ഫയലുകളും Git-ന്റെ സ്‌റ്റേജിംഗ് എൻവയോൺമെന്റിലേക്ക് ചേർക്കാം:
+
+```bash
+git add .
+```
+
+തുടർന്ന് ഇപ്പോൾ സ്‌റ്റേജ് ചെയ്തിരിക്കുന്ന ഫയലുകൾ ഒന്ന് നോക്കാം:
+
+```bash
+git status
+```
+
+{#if fw === 'pt'}
+```bash
+On branch main
+Your branch is up to date with 'origin/main'.
+
+Changes to be committed:
+  (use "git restore --staged <file>..." to unstage)
+  modified:   .gitattributes
+	new file:   config.json
+	new file:   pytorch_model.bin
+	new file:   sentencepiece.bpe.model
+	new file:   special_tokens_map.json
+	new file:   tokenizer.json
+	new file:   tokenizer_config.json
+```
+{:else}
+```bash
+On branch main
+Your branch is up to date with 'origin/main'.
+
+Changes to be committed:
+  (use "git restore --staged <file>..." to unstage)
+  modified:   .gitattributes
+  	new file:   config.json
+	new file:   sentencepiece.bpe.model
+	new file:   special_tokens_map.json
+	new file:   tf_model.h5
+	new file:   tokenizer.json
+	new file:   tokenizer_config.json
+```
+{/if}
+
+അതുപോലെ, git-lfs-ന്റെ `status` കമാൻഡ് ഉപയോഗിച്ച് അത് ശരിയായ ഫയലുകളാണ് ട്രാക്ക് ചെയ്യുന്നതെന്ന് ഉറപ്പാക്കാം:
+
+```bash
+git lfs status
+```
+
+{#if fw === 'pt'}
+```bash
+On branch main
+Objects to be pushed to origin/main:
+
+
+Objects to be committed:
+
+	config.json (Git: bc20ff2)
+	pytorch_model.bin (LFS: 35686c2)
+	sentencepiece.bpe.model (LFS: 988bc5a)
+	special_tokens_map.json (Git: cb23931)
+	tokenizer.json (Git: 851ff3e)
+	tokenizer_config.json (Git: f0f7783)
+
+Objects not staged for commit:
+
+
+```
+
+*pytorch_model.bin*, *sentencepiece.bpe.model* എന്നിവ ഒഴികെ എല്ലാ ഫയലുകൾക്കും `Git` ആണ് ഹാൻഡ്‌ലർ എന്ന് കാണാം; ആ രണ്ടെണ്ണത്തിന് `LFS` ആണ്. കൊള്ളാം!
+
+{:else}
+```bash
+On branch main
+Objects to be pushed to origin/main:
+
+
+Objects to be committed:
+
+	config.json (Git: bc20ff2)
+	sentencepiece.bpe.model (LFS: 988bc5a)
+	special_tokens_map.json (Git: cb23931)
+	tf_model.h5 (LFS: 86fce29)
+	tokenizer.json (Git: 851ff3e)
+	tokenizer_config.json (Git: f0f7783)
+
+Objects not staged for commit:
+
+
+```
+
+*t5_model.h5* ഒഴികെ എല്ലാ ഫയലുകൾക്കും `Git` ആണ് ഹാൻഡ്‌ലർ എന്ന് കാണാം; അതിന് `LFS` ആണ്. കൊള്ളാം!
+
+{/if}
+
+ഇനി അവസാന ഘട്ടങ്ങളിലേക്ക് കടക്കാം: കമ്മിറ്റ് ചെയ്യുകയും *huggingface.co* റിമോട്ട് റിപ്പോസിറ്ററിയിലേക്ക് പുഷ് ചെയ്യുകയും:
+
+```bash
+git commit -m "First model version"
+```
+
+{#if fw === 'pt'}
+```bash
+[main b08aab1] First model version
+ 7 files changed, 29027 insertions(+)
+  6 files changed, 36 insertions(+)
+ create mode 100644 config.json
+ create mode 100644 pytorch_model.bin
+ create mode 100644 sentencepiece.bpe.model
+ create mode 100644 special_tokens_map.json
+ create mode 100644 tokenizer.json
+ create mode 100644 tokenizer_config.json
+```
+{:else}
+```bash
+[main b08aab1] First model version
+ 6 files changed, 36 insertions(+)
+ create mode 100644 config.json
+ create mode 100644 sentencepiece.bpe.model
+ create mode 100644 special_tokens_map.json
+ create mode 100644 tf_model.h5
+ create mode 100644 tokenizer.json
+ create mode 100644 tokenizer_config.json
+```
+{/if}
+
+നിങ്ങളുടെ ഇന്റർനെറ്റ് കണക്ഷന്റെ വേഗതയും ഫയലുകളുടെ വലുപ്പവും അനുസരിച്ച്, പുഷ് ചെയ്യാൻ കുറച്ച് സമയമെടുക്കാം:
+
+```bash
+git push
+```
+
+```bash
+Uploading LFS objects: 100% (1/1), 433 MB | 1.3 MB/s, done.
+Enumerating objects: 11, done.
+Counting objects: 100% (11/11), done.
+Delta compression using up to 12 threads
+Compressing objects: 100% (9/9), done.
+Writing objects: 100% (9/9), 288.27 KiB | 6.27 MiB/s, done.
+Total 9 (delta 1), reused 0 (delta 0), pack-reused 0
+To https://huggingface.co/lysandre/dummy
+   891b41d..b08aab1  main -> main
+```
+
+{#if fw === 'pt'}
+ഇത് പൂർത്തിയാകുമ്പോൾ മോഡൽ റിപ്പോസിറ്ററി നോക്കിയാൽ, അടുത്തിടെ ചേർത്ത എല്ലാ ഫയലുകളും നമുക്ക് കാണാം:
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/full_model.png" alt="'Files and versions' ടാബിൽ ഇപ്പോൾ അടുത്തിടെ അപ്‌ലോഡ് ചെയ്ത എല്ലാ ഫയലുകളും ഉണ്ട്." width="80%"/>
+</div>
+
+മോഡൽ ഫയലുകളും കമ്മിറ്റുകളും പരിശോധിക്കാനും ഓരോ കമ്മിറ്റും വരുത്തിയ ഡിഫ് കാണാനും UI നിങ്ങളെ അനുവദിക്കുന്നു:
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/diffs.gif" alt="സമീപകാല കമ്മിറ്റ് വരുത്തിയ ഡിഫ്." width="80%"/>
+</div>
+{:else}
+ഇത് പൂർത്തിയാകുമ്പോൾ മോഡൽ റിപ്പോസിറ്ററി നോക്കിയാൽ, അടുത്തിടെ ചേർത്ത എല്ലാ ഫയലുകളും നമുക്ക് കാണാം:
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/full_model_tf.png" alt="'Files and versions' ടാബിൽ ഇപ്പോൾ അടുത്തിടെ അപ്‌ലോഡ് ചെയ്ത എല്ലാ ഫയലുകളും ഉണ്ട്." width="80%"/>
+</div>
+
+മോഡൽ ഫയലുകളും കമ്മിറ്റുകളും പരിശോധിക്കാനും ഓരോ കമ്മിറ്റും വരുത്തിയ ഡിഫ് കാണാനും UI നിങ്ങളെ അനുവദിക്കുന്നു:
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter4/diffstf.gif" alt="സമീപകാല കമ്മിറ്റ് വരുത്തിയ ഡിഫ്." width="80%"/>
+</div>
+{/if}

From ca0c69fec2cc983c44f323f72ca38d761945481e Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 14:19:16 +0530
Subject: [PATCH 41/44] Add Malayalam translation for chapter4/4.mdx

---
 chapters/ml/chapter4/4.mdx | 87 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 87 insertions(+)
 create mode 100644 chapters/ml/chapter4/4.mdx

diff --git a/chapters/ml/chapter4/4.mdx b/chapters/ml/chapter4/4.mdx
new file mode 100644
index 000000000..dd1123f72
--- /dev/null
+++ b/chapters/ml/chapter4/4.mdx
@@ -0,0 +1,87 @@
+# ഒരു മോഡൽ കാർഡ് നിർമ്മിക്കുന്നു[[building-a-model-card]]
+
+<CourseFloatingBanner
+    chapter={4}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+ഒരു മോഡൽ റിപ്പോസിറ്ററിയിലെ മോഡൽ, ടോക്കണൈസർ ഫയലുകളോളം തന്നെ പ്രധാനമാണെന്ന് പറയാവുന്ന ഒരു ഫയലാണ് മോഡൽ കാർഡ്. ഇത് മോഡലിന്റെ കേന്ദ്ര നിർവചനമാണ്: കമ്മ്യൂണിറ്റിയിലെ മറ്റ് അംഗങ്ങൾക്ക് മോഡൽ പുനരുപയോഗിക്കാൻ കഴിയുമെന്നും ഫലങ്ങൾ വീണ്ടും ഉണ്ടാക്കിയെടുക്കാൻ കഴിയുമെന്നും (reproducibility) ഇത് ഉറപ്പുവരുത്തുന്നു, കൂടാതെ മറ്റ് അംഗങ്ങൾക്ക് തങ്ങളുടെ ആർട്ടിഫാക്റ്റുകൾ നിർമ്മിച്ചെടുക്കാനുള്ള ഒരു അടിത്തറയും ഇത് നൽകുന്നു. 
+
+ട്രെയിനിംഗ്, ഇവാലുവേഷൻ (evaluation) പ്രക്രിയകൾ ഡോക്യുമെന്റ് ചെയ്യുന്നത്, ഒരു മോഡലിൽ നിന്ന് എന്ത് പ്രതീക്ഷിക്കണം എന്ന് മറ്റുള്ളവർക്ക് മനസ്സിലാക്കാൻ സഹായിക്കുന്നു — കൂടാതെ ഉപയോഗിച്ച ഡേറ്റയെക്കുറിച്ചും അതിൽ ചെയ്ത പ്രീപ്രോസസ്സിംഗിനെയും പോസ്‌റ്റ്‌പ്രോസസ്സിംഗിനെയും കുറിച്ചും മതിയായ വിവരങ്ങൾ നൽകുന്നത്, മോഡലിന്റെ പരിമിതികളും പക്ഷപാതങ്ങളും (biases), മോഡൽ ഉപകാരപ്രദമാകുന്നതും അല്ലാത്തതുമായ സന്ദർഭങ്ങളും തിരിച്ചറിയാനും മനസ്സിലാക്കാനും കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.
+
+അതിനാൽ, നിങ്ങളുടെ മോഡലിനെ വ്യക്തമായി നിർവചിക്കുന്ന ഒരു മോഡൽ കാർഡ് ഉണ്ടാക്കുന്നത് വളരെ പ്രധാനപ്പെട്ട ഒരു ഘട്ടമാണ്. ഇതിന് നിങ്ങളെ സഹായിക്കുന്ന ചില നുറുങ്ങുകൾ ഇവിടെ ഞങ്ങൾ നൽകുന്നു. നിങ്ങൾ മുമ്പ് കണ്ട *README.md* ഫയലിലൂടെയാണ് മോഡൽ കാർഡ് ഉണ്ടാക്കുന്നത്; അത് ഒരു Markdown ഫയലാണ്.
+
+"മോഡൽ കാർഡ്" എന്ന ആശയം Google-ലെ ഒരു ഗവേഷണ ദിശയിൽ നിന്ന് ഉത്ഭവിച്ചതാണ്; Margaret Mitchell et al. എഴുതിയ ["Model Cards for Model Reporting"](https://arxiv.org/abs/1810.03993) എന്ന പ്രബന്ധത്തിലാണ് ഇത് ആദ്യമായി പങ്കുവെച്ചത്. ഇവിടെ അടങ്ങിയിരിക്കുന്ന വിവരങ്ങളിൽ ഏറെയും ആ പ്രബന്ധത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്; പുനരുൽപ്പാദനക്ഷമത (reproducibility), പുനരുപയോഗം (reusability), നീതി (fairness) എന്നിവയ്ക്ക് വിലകൽപ്പിക്കുന്ന ഒരു ലോകത്ത് മോഡൽ കാർഡുകൾ എന്തുകൊണ്ട് ഇത്ര പ്രധാനമാണ് എന്ന് മനസ്സിലാക്കാൻ അത് ഒന്ന് വായിച്ചുനോക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.
+
+മോഡൽ എന്തിനുള്ളതാണ് എന്നതിന്റെ വളരെ ഹ്രസ്വമായ, ഉയർന്ന തലത്തിലുള്ള ഒരു അവലോകനത്തോടെയാണ് മോഡൽ കാർഡ് സാധാരണയായി ആരംഭിക്കുന്നത്; അതിനെ തുടർന്ന് താഴെ പറയുന്ന വിഭാഗങ്ങളിൽ കൂടുതൽ വിശദാംശങ്ങൾ വരുന്നു:
+
+- മോഡൽ വിവരണം (Model description)
+- ഉദ്ദേശിച്ച ഉപയോഗങ്ങളും പരിമിതികളും (Intended uses & limitations)
+- എങ്ങനെ ഉപയോഗിക്കണം (How to use)
+- പരിമിതികളും പക്ഷപാതവും (Limitations and bias)
+- ട്രെയിനിംഗ് ഡേറ്റ (Training data) 
+- ട്രെയിനിംഗ് നടപടിക്രമം (Training procedure)
+- ഇവാലുവേഷൻ ഫലങ്ങൾ (Evaluation results) 
+
+ഈ വിഭാഗങ്ങളിൽ ഓരോന്നിലും എന്തൊക്കെ ഉണ്ടായിരിക്കണം എന്ന് നോക്കാം.
+
+### മോഡൽ വിവരണം (Model description)[[model-description]]
+
+മോഡൽ വിവരണം മോഡലിനെക്കുറിച്ചുള്ള അടിസ്ഥാന വിശദാംശങ്ങൾ നൽകുന്നു. ആർക്കിടെക്ചർ, പതിപ്പ് (version), ഇത് ഒരു പ്രബന്ധത്തിലാണോ അവതരിപ്പിച്ചത്, ഒറിജിനൽ ഇംപ്ലിമെന്റേഷൻ ലഭ്യമാണോ, രചയിതാവ് ആരാണ്, മോഡലിനെക്കുറിച്ചുള്ള പൊതുവായ വിവരങ്ങൾ എന്നിവ ഇതിൽ ഉൾപ്പെടുന്നു. പകർപ്പവകാശം (copyright) എന്തെങ്കിലുമുണ്ടെങ്കിൽ അത് ഇവിടെ രേഖപ്പെടുത്തണം. ട്രെയിനിംഗ് നടപടിക്രമങ്ങളെയും പാരാമീറ്ററുകളെയും കുറിച്ചുള്ള പൊതുവിവരങ്ങളും പ്രധാനപ്പെട്ട നിരാകരണങ്ങളും (disclaimers) ഈ വിഭാഗത്തിൽ പരാമർശിക്കാം.
+
+### ഉദ്ദേശിച്ച ഉപയോഗങ്ങളും പരിമിതികളും (Intended uses & limitations)[[intended-uses-limitations]]
+
+മോഡൽ ഏതൊക്കെ ഉപയോഗ സാഹചര്യങ്ങൾക്കായി (use cases) ഉദ്ദേശിച്ചിട്ടുള്ളതാണ് എന്ന് ഇവിടെ നിങ്ങൾ വിവരിക്കുന്നു — അത് പ്രയോഗിക്കാൻ കഴിയുന്ന ഭാഷകൾ, മേഖലകൾ, ഡൊമെയ്‌നുകൾ എന്നിവ ഉൾപ്പെടെ. മോഡലിന്റെ പരിധിക്ക് പുറത്താണെന്ന് അറിയപ്പെടുന്നതോ, മോഡൽ മികച്ച രീതിയിൽ പ്രവർത്തിക്കാൻ സാധ്യതയില്ലാത്തതോ ആയ മേഖലകളും മോഡൽ കാർഡിന്റെ ഈ വിഭാഗത്തിൽ രേഖപ്പെടുത്താം.
+
+### എങ്ങനെ ഉപയോഗിക്കണം (How to use)[[how-to-use]]
+
+മോഡൽ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിന്റെ ചില ഉദാഹരണങ്ങൾ ഈ വിഭാഗത്തിൽ ഉൾപ്പെടുത്തണം. `pipeline()` ഫംഗ്‌ഷന്റെ ഉപയോഗം, മോഡൽ, ടോക്കണൈസർ ക്ലാസുകളുടെ ഉപയോഗം, സഹായകമാകുമെന്ന് നിങ്ങൾ കരുതുന്ന മറ്റേതെങ്കിലും കോഡ് എന്നിവ ഇവിടെ കാണിക്കാം.
+
+### ട്രെയിനിംഗ് ഡേറ്റ (Training data)[[training-data]]
+
+മോഡൽ ഏത് ഡേറ്റാസെറ്റിലാണ് (അല്ലെങ്കിൽ ഡേറ്റാസെറ്റുകളിലാണ്) ട്രെയിൻ ചെയ്തത് എന്ന് ഈ ഭാഗം സൂചിപ്പിക്കണം. ഡേറ്റാസെറ്റുകളുടെ ഒരു ഹ്രസ്വ വിവരണവും നൽകുന്നത് നല്ലതാണ്.
+
+### ട്രെയിനിംഗ് നടപടിക്രമം (Training procedure)[[training-procedure]]
+
+പുനരുൽപ്പാദനക്ഷമതയുടെ (reproducibility) കാഴ്ചപ്പാടിൽ ഉപകാരപ്രദമായ, ട്രെയിനിംഗിന്റെ പ്രസക്തമായ എല്ലാ വശങ്ങളും ഈ വിഭാഗത്തിൽ നിങ്ങൾ വിവരിക്കണം. ഡേറ്റയിൽ ചെയ്ത പ്രീപ്രോസസ്സിംഗും പോസ്‌റ്റ്‌പ്രോസസ്സിംഗും, മോഡൽ എത്ര എപ്പോക്കുകൾ (epochs) ട്രെയിൻ ചെയ്തു, ബാച്ച് സൈസ്, ലേണിംഗ് റേറ്റ് തുടങ്ങിയ വിശദാംശങ്ങളും ഇതിൽ ഉൾപ്പെടുന്നു.
+
+### വേരിയബിളുകളും മെട്രിക്കുകളും (Variable and metrics)[[variable-and-metrics]]
+
+ഇവാലുവേഷനായി നിങ്ങൾ ഉപയോഗിക്കുന്ന മെട്രിക്കുകളും നിങ്ങൾ അളക്കുന്ന വിവിധ ഘടകങ്ങളും ഇവിടെ വിവരിക്കണം. ഏതൊക്കെ മെട്രിക്കുകൾ ഉപയോഗിച്ചു, ഏത് ഡേറ്റാസെറ്റിലും ഏത് ഡേറ്റാസെറ്റ് സ്‌പ്ലിറ്റിലും എന്ന് പരാമർശിക്കുന്നത്, നിങ്ങളുടെ മോഡലിന്റെ പ്രകടനം മറ്റ് മോഡലുകളുടേതുമായി താരതമ്യം ചെയ്യുന്നത് എളുപ്പമാക്കുന്നു. ഉദ്ദേശിച്ച ഉപയോക്താക്കൾ, ഉപയോഗ സാഹചര്യങ്ങൾ തുടങ്ങിയ മുൻ വിഭാഗങ്ങളിലെ വിവരങ്ങളെ അടിസ്ഥാനമാക്കിയായിരിക്കണം ഇവ തിരഞ്ഞെടുക്കുന്നത്.
+
+### ഇവാലുവേഷൻ ഫലങ്ങൾ (Evaluation results)[[evaluation-results]]
+
+അവസാനമായി, ഇവാലുവേഷൻ ഡേറ്റാസെറ്റിൽ മോഡൽ എത്ര നന്നായി പ്രവർത്തിക്കുന്നു എന്നതിന്റെ ഒരു സൂചന നൽകുക. മോഡൽ ഒരു ഡിസിഷൻ ത്രെഷോൾഡ് (decision threshold) ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ, ഇവാലുവേഷനിൽ ഉപയോഗിച്ച ത്രെഷോൾഡ് നൽകുകയോ, അല്ലെങ്കിൽ ഉദ്ദേശിച്ച ഉപയോഗങ്ങൾക്കായി വ്യത്യസ്ത ത്രെഷോൾഡുകളിൽ നടത്തിയ ഇവാലുവേഷന്റെ വിശദാംശങ്ങൾ നൽകുകയോ ചെയ്യുക.
+
+## ഉദാഹരണം[[example]]
+
+നന്നായി തയ്യാറാക്കിയ മോഡൽ കാർഡുകളുടെ ചില ഉദാഹരണങ്ങൾക്കായി താഴെ പറയുന്നവ നോക്കുക:
+
+- [`bert-base-cased`](https://huggingface.co/bert-base-cased)
+- [`gpt2`](https://huggingface.co/gpt2)
+- [`distilbert`](https://huggingface.co/distilbert-base-uncased)
+
+വിവിധ സ്ഥാപനങ്ങളിൽ നിന്നും കമ്പനികളിൽ നിന്നുമുള്ള കൂടുതൽ ഉദാഹരണങ്ങൾ [ഇവിടെ](https://github.com/huggingface/model_card/blob/master/examples.md) ലഭ്യമാണ്.
+
+## കുറിപ്പ്[[note]]
+
+മോഡലുകൾ പ്രസിദ്ധീകരിക്കുമ്പോൾ മോഡൽ കാർഡുകൾ നിർബന്ധമല്ല; ഒന്ന് ഉണ്ടാക്കുമ്പോൾ മുകളിൽ വിവരിച്ച എല്ലാ വിഭാഗങ്ങളും ഉൾപ്പെടുത്തേണ്ട ആവശ്യവുമില്ല. എന്നിരുന്നാലും, മോഡലിന്റെ വ്യക്തമായ ഡോക്യുമെന്റേഷൻ ഭാവിയിലെ ഉപയോക്താക്കൾക്ക് ഗുണം മാത്രമേ ചെയ്യൂ; അതിനാൽ നിങ്ങളുടെ അറിവും കഴിവും അനുസരിച്ച് കഴിയുന്നത്ര വിഭാഗങ്ങൾ പൂരിപ്പിക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു.
+
+## മോഡൽ കാർഡ് മെറ്റാഡേറ്റ[[model-card-metadata]]
+
+Hugging Face Hub ഒന്ന് പരതി നോക്കിയിട്ടുണ്ടെങ്കിൽ, ചില മോഡലുകൾ ചില പ്രത്യേക വിഭാഗങ്ങളിൽ പെടുന്നതായി നിങ്ങൾ കണ്ടിട്ടുണ്ടാകും: ടാസ്‌കുകൾ, ഭാഷകൾ, ലൈബ്രറികൾ തുടങ്ങിയവ അനുസരിച്ച് അവയെ ഫിൽട്ടർ ചെയ്യാൻ കഴിയും. മോഡൽ കാർഡിന്റെ ഹെഡറിൽ നിങ്ങൾ ചേർക്കുന്ന മെറ്റാഡേറ്റ അനുസരിച്ചാണ് ഒരു മോഡൽ ഏതൊക്കെ വിഭാഗങ്ങളിൽ പെടുന്നു എന്ന് തിരിച്ചറിയുന്നത്.
+
+ഉദാഹരണത്തിന്, [`camembert-base` മോഡൽ കാർഡ്](https://huggingface.co/camembert-base/blob/main/README.md) ഒന്ന് നോക്കിയാൽ, മോഡൽ കാർഡ് ഹെഡറിൽ താഴെ പറയുന്ന വരികൾ നിങ്ങൾക്ക് കാണാം:
+
+```
+---
+language: fr
+license: mit
+datasets:
+- oscar
+---
+```
+
+ഈ മെറ്റാഡേറ്റ Hugging Face Hub പാഴ്‌സ് ചെയ്യുന്നു; അതിലൂടെ, ഈ മോഡൽ MIT ലൈസൻസുള്ള, Oscar ഡേറ്റാസെറ്റിൽ ട്രെയിൻ ചെയ്ത ഒരു ഫ്രഞ്ച് മോഡലാണെന്ന് Hub തിരിച്ചറിയുന്നു.
+
+ഭാഷകൾ, ലൈസൻസുകൾ, ടാഗുകൾ, ഡേറ്റാസെറ്റുകൾ, മെട്രിക്കുകൾ എന്നിവയും, ട്രെയിനിംഗ് സമയത്ത് മോഡൽ നേടിയ ഇവാലുവേഷൻ ഫലങ്ങളും വ്യക്തമാക്കാൻ [പൂർണ്ണ മോഡൽ കാർഡ് സ്‌പെസിഫിക്കേഷൻ](https://github.com/huggingface/hub-docs/blame/main/modelcard.md) അനുവദിക്കുന്നു.

From e7b141eec91f33ff492ddca5a951034c692aacbd Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 14:20:39 +0530
Subject: [PATCH 42/44] Add Malayalam translation for chapter4/5.mdx

---
 chapters/ml/chapter4/5.mdx | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 chapters/ml/chapter4/5.mdx

diff --git a/chapters/ml/chapter4/5.mdx b/chapters/ml/chapter4/5.mdx
new file mode 100644
index 000000000..251b99ce0
--- /dev/null
+++ b/chapters/ml/chapter4/5.mdx
@@ -0,0 +1,12 @@
+# ഭാഗം 1 പൂർത്തിയായി![[part-1-completed]]
+
+<CourseFloatingBanner
+    chapter={4}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+ഇത് കോഴ്‌സിന്റെ ആദ്യ ഭാഗത്തിന്റെ അവസാനമാണ്! ഭാഗം 2 നവംബർ 15-ന് ഒരു വലിയ കമ്മ്യൂണിറ്റി ഇവന്റോടെ പുറത്തിറങ്ങും; കൂടുതൽ വിവരങ്ങൾ [ഇവിടെ](https://huggingface.co/blog/course-launch-event) കാണുക.
+
+ഒരു ടെക്‌സ്‌റ്റ് ക്ലാസിഫിക്കേഷൻ പ്രശ്നത്തിൽ (ഒറ്റ വാക്യങ്ങളോ വാക്യ ജോഡികളോ) ഒരു പ്രീട്രെയിൻഡ് മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യാനും അതിന്റെ ഫലം Model Hub-ലേക്ക് അപ്‌ലോഡ് ചെയ്യാനും ഇപ്പോൾ നിങ്ങൾക്ക് കഴിയണം. ഈ ആദ്യ ഭാഗം നിങ്ങൾ നന്നായി പഠിച്ചു എന്ന് ഉറപ്പാക്കാൻ, നിങ്ങൾക്ക് താൽപ്പര്യമുള്ള ഒരു പ്രശ്നത്തിൽ കൃത്യമായി അതുതന്നെ ചെയ്തുനോക്കണം (നിങ്ങൾ മറ്റൊരു ഭാഷ സംസാരിക്കുന്ന ആളാണെങ്കിൽ അത് ഇംഗ്ലീഷിൽ തന്നെ ആകണമെന്നില്ല)! [Hugging Face ഫോറങ്ങളിൽ](https://discuss.huggingface.co/) നിങ്ങൾക്ക് സഹായം ലഭിക്കും; പൂർത്തിയാക്കിയ ശേഷം നിങ്ങളുടെ പ്രോജക്റ്റ് [ഈ ടോപ്പിക്കിൽ](https://discuss.huggingface.co/t/share-your-projects/6803) പങ്കുവെക്കാം.
+
+ഇതുപയോഗിച്ച് നിങ്ങൾ എന്തൊക്കെ നിർമ്മിക്കുമെന്ന് കാണാൻ ഞങ്ങൾ ആകാംക്ഷയോടെ കാത്തിരിക്കുന്നു!

From e7575ede489735420b17e11d9fc17e2290680c51 Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 14:24:23 +0530
Subject: [PATCH 43/44] Add Malayalam translation for chapter4/6.mdx

---
 chapters/ml/chapter4/6.mdx | 228 +++++++++++++++++++++++++++++++++++++
 1 file changed, 228 insertions(+)
 create mode 100644 chapters/ml/chapter4/6.mdx

diff --git a/chapters/ml/chapter4/6.mdx b/chapters/ml/chapter4/6.mdx
new file mode 100644
index 000000000..e57ada3c6
--- /dev/null
+++ b/chapters/ml/chapter4/6.mdx
@@ -0,0 +1,228 @@
+<FrameworkSwitchCourse {fw} />
+
+<!-- DISABLE-FRONTMATTER-SECTIONS -->
+
+# അധ്യായത്തിന്റെ അവസാന ക്വിസ്[[end-of-chapter-quiz]]
+
+<CourseFloatingBanner
+    chapter={4}
+    classNames="absolute z-10 right-0 top-0"
+/>
+
+ഈ അധ്യായത്തിൽ നിങ്ങൾ പഠിച്ചത് ഒന്ന് പരീക്ഷിച്ചുനോക്കാം!
+  
+### 1. Hub-ലെ മോഡലുകൾ എന്തിലേക്കാണ് പരിമിതപ്പെടുത്തിയിരിക്കുന്നത്?
+
+<Question
+	choices={[
+		{
+			text: "🤗 Transformers ലൈബ്രറിയിൽ നിന്നുള്ള മോഡലുകൾ.",
+			explain: "🤗 Transformers ലൈബ്രറിയിൽ നിന്നുള്ള മോഡലുകൾ Hugging Face Hub-ൽ പിന്തുണയ്ക്കുന്നുണ്ടെങ്കിലും, അവ മാത്രമല്ല അവിടെയുള്ളത്!"
+		},
+		{
+			text: "🤗 Transformers-ന് സമാനമായ ഇന്റർഫേസുള്ള എല്ലാ മോഡലുകളും.",
+			explain: "Hugging Face Hub-ലേക്ക് മോഡലുകൾ അപ്‌ലോഡ് ചെയ്യുമ്പോൾ ഇന്റർഫേസ് സംബന്ധിച്ച് ഒരു നിബന്ധനയും ഇല്ല. "
+		},
+		{
+			text: "പരിമിതികളൊന്നുമില്ല.",
+			explain: "ശരിയാണ്! Hub-ലേക്ക് മോഡലുകൾ അപ്‌ലോഡ് ചെയ്യുമ്പോൾ പരിമിതികളൊന്നുമില്ല.",
+            correct: true
+		},
+        {
+			text: "ഏതെങ്കിലും വിധത്തിൽ NLP-യുമായി ബന്ധപ്പെട്ട മോഡലുകൾ.",
+			explain: "പ്രയോഗ മേഖല സംബന്ധിച്ച് ഒരു നിബന്ധനയും ഇല്ല!"
+		}
+	]}
+/>
+
+### 2. Hub-ലെ മോഡലുകൾ എങ്ങനെ കൈകാര്യം ചെയ്യാം?
+
+<Question
+	choices={[
+		{
+			text: "ഒരു GCP അക്കൗണ്ട് വഴി.",
+			explain: "തെറ്റാണ്!"
+		},
+		{
+			text: "പിയർ-ടു-പിയർ വിതരണം വഴി.",
+			explain: "തെറ്റാണ്!"
+		},
+		{
+			text: "git-ഉം git-lfs-ഉം വഴി.",
+			explain: "ശരിയാണ്! Hub-ലെ മോഡലുകൾ ലളിതമായ Git റിപ്പോസിറ്ററികളാണ്; വലിയ ഫയലുകൾക്കായി അവ <code>git-lfs</code> ഉപയോഗിക്കുന്നു.",
+            correct: true
+		}
+	]}
+/>
+
+### 3. Hugging Face Hub വെബ് ഇന്റർഫേസ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് എന്തൊക്കെ ചെയ്യാൻ കഴിയും? 
+
+<Question
+	choices={[
+		{
+			text: "നിലവിലുള്ള ഒരു റിപ്പോസിറ്ററി ഫോർക്ക് ചെയ്യുക.",
+			explain: "Hugging Face Hub-ൽ ഒരു റിപ്പോസിറ്ററി ഫോർക്ക് ചെയ്യാൻ സാധ്യമല്ല."
+		},
+		{
+			text: "ഒരു പുതിയ മോഡൽ റിപ്പോസിറ്ററി ഉണ്ടാക്കുക.",
+			explain: "ശരിയാണ്! എന്നാൽ നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്നത് ഇത് മാത്രമല്ല.",
+            correct: true
+		},
+		{
+			text: "ഫയലുകൾ കൈകാര്യം ചെയ്യുകയും എഡിറ്റ് ചെയ്യുകയും ചെയ്യുക.",
+			explain: "ശരിയാണ്! എന്നാൽ ഇത് മാത്രമല്ല ശരിയായ ഉത്തരം.",
+            correct: true
+		},
+        {
+			text: "ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യുക.",
+			explain: "ശരിയാണ്! എന്നാൽ അത് മാത്രമല്ല.",
+            correct: true
+		},
+        {
+			text: "വിവിധ പതിപ്പുകൾക്കിടയിലുള്ള വ്യത്യാസങ്ങൾ (diffs) കാണുക.",
+			explain: "ശരിയാണ്! എന്നാൽ നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്നത് ഇത് മാത്രമല്ല.",
+            correct: true
+		}
+	]}
+/>
+
+### 4. എന്താണ് ഒരു മോഡൽ കാർഡ്?
+
+<Question
+	choices={[
+		{
+			text: "മോഡലിന്റെ ഏകദേശ വിവരണം, അതിനാൽ മോഡൽ, ടോക്കണൈസർ ഫയലുകളെക്കാൾ പ്രാധാന്യം കുറഞ്ഞത്.",
+			explain: "ഇത് തീർച്ചയായും മോഡലിന്റെ ഒരു വിവരണമാണ്, എന്നാൽ ഇത് പ്രധാനപ്പെട്ട ഒരു ഭാഗമാണ്: ഇത് അപൂർണ്ണമോ ഇല്ലാത്തതോ ആണെങ്കിൽ മോഡലിന്റെ ഉപയോഗക്ഷമത ഗണ്യമായി കുറയുന്നു."
+		},
+		{
+			text: "പുനരുൽപ്പാദനക്ഷമത (reproducibility), പുനരുപയോഗം (reusability), നീതി (fairness) എന്നിവ ഉറപ്പാക്കാനുള്ള ഒരു മാർഗ്ഗം.",
+			explain: "ശരിയാണ്! മോഡൽ കാർഡിൽ ശരിയായ വിവരങ്ങൾ പങ്കുവെക്കുന്നത്, ഉപയോക്താക്കൾക്ക് നിങ്ങളുടെ മോഡൽ പ്രയോജനപ്പെടുത്താനും അതിന്റെ പരിമിതികളെയും പക്ഷപാതങ്ങളെയും കുറിച്ച് ബോധവാന്മാരാകാനും സഹായിക്കും. ",
+            correct: true
+		},
+		{
+			text: "മോഡലിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ ലഭിക്കാൻ റൺ ചെയ്യാവുന്ന ഒരു Python ഫയൽ.",
+			explain: "മോഡൽ കാർഡുകൾ ലളിതമായ Markdown ഫയലുകളാണ്."
+		}
+	]}
+/>
+
+### 5. 🤗 Transformers ലൈബ്രറിയിലെ ഈ ഒബ്‌ജക്റ്റുകളിൽ ഏതൊക്കെ `push_to_hub()` ഉപയോഗിച്ച് Hub-ൽ നേരിട്ട് പങ്കുവെക്കാൻ കഴിയും?
+
+{#if fw === 'pt'}
+<Question
+	choices={[
+		{
+			text: "ഒരു ടോക്കണൈസർ",
+			explain: "ശരിയാണ്! എല്ലാ ടോക്കണൈസറുകൾക്കും <code>push_to_hub</code> മെത്തേഡ് ഉണ്ട്; അത് ഉപയോഗിച്ചാൽ ടോക്കണൈസറിന്റെ എല്ലാ ഫയലുകളും (വൊക്കാബുലറി, ടോക്കണൈസറിന്റെ ആർക്കിടെക്ചർ മുതലായവ) ഒരു നിശ്ചിത റിപ്പോയിലേക്ക് പുഷ് ചെയ്യപ്പെടും. എന്നാൽ ഇത് മാത്രമല്ല ശരിയായ ഉത്തരം!",
+            correct: true
+		},
+		{
+			text: "ഒരു മോഡൽ കോൺഫിഗറേഷൻ",
+			explain: "ശരിയാണ്! എല്ലാ മോഡൽ കോൺഫിഗറേഷനുകൾക്കും <code>push_to_hub</code> മെത്തേഡ് ഉണ്ട്; അത് ഉപയോഗിച്ചാൽ അവ ഒരു നിശ്ചിത റിപ്പോയിലേക്ക് പുഷ് ചെയ്യപ്പെടും. മറ്റെന്തൊക്കെ നിങ്ങൾക്ക് പങ്കുവെക്കാൻ കഴിയും?",
+            correct: true
+		},
+		{
+			text: "ഒരു മോഡൽ",
+			explain: "ശരിയാണ്! എല്ലാ മോഡലുകൾക്കും <code>push_to_hub</code> മെത്തേഡ് ഉണ്ട്; അത് ഉപയോഗിച്ചാൽ മോഡലുകളും അവയുടെ കോൺഫിഗറേഷൻ ഫയലുകളും ഒരു നിശ്ചിത റിപ്പോയിലേക്ക് പുഷ് ചെയ്യപ്പെടും. എന്നാൽ നിങ്ങൾക്ക് പങ്കുവെക്കാൻ കഴിയുന്നത് ഇത് മാത്രമല്ല.",
+            correct: true
+		},
+        {
+			text: "ഒരു Trainer",
+			explain: "ശരിയാണ് — <code>Trainer</code>-ഉം <code>push_to_hub</code> മെത്തേഡ് ഇംപ്ലിമെന്റ് ചെയ്യുന്നു; അത് ഉപയോഗിച്ചാൽ മോഡൽ, അതിന്റെ കോൺഫിഗറേഷൻ, ടോക്കണൈസർ, ഒരു മോഡൽ കാർഡ് ഡ്രാഫ്‌റ്റ് എന്നിവ ഒരു നിശ്ചിത റിപ്പോയിലേക്ക് അപ്‌ലോഡ് ചെയ്യപ്പെടും. മറ്റൊരു ഉത്തരം കൂടി പരീക്ഷിക്കുക!",
+            correct: true
+		}
+	]}
+/>
+{:else}
+<Question
+	choices={[
+		{
+			text: "ഒരു ടോക്കണൈസർ",
+			explain: "ശരിയാണ്! എല്ലാ ടോക്കണൈസറുകൾക്കും <code>push_to_hub</code> മെത്തേഡ് ഉണ്ട്; അത് ഉപയോഗിച്ചാൽ ടോക്കണൈസറിന്റെ എല്ലാ ഫയലുകളും (വൊക്കാബുലറി, ടോക്കണൈസറിന്റെ ആർക്കിടെക്ചർ മുതലായവ) ഒരു നിശ്ചിത റിപ്പോയിലേക്ക് പുഷ് ചെയ്യപ്പെടും. എന്നാൽ ഇത് മാത്രമല്ല ശരിയായ ഉത്തരം!",
+            correct: true
+		},
+		{
+			text: "ഒരു മോഡൽ കോൺഫിഗറേഷൻ",
+			explain: "ശരിയാണ്! എല്ലാ മോഡൽ കോൺഫിഗറേഷനുകൾക്കും <code>push_to_hub</code> മെത്തേഡ് ഉണ്ട്; അത് ഉപയോഗിച്ചാൽ അവ ഒരു നിശ്ചിത റിപ്പോയിലേക്ക് പുഷ് ചെയ്യപ്പെടും. മറ്റെന്തൊക്കെ നിങ്ങൾക്ക് പങ്കുവെക്കാൻ കഴിയും?",
+            correct: true
+		},
+		{
+			text: "ഒരു മോഡൽ",
+			explain: "ശരിയാണ്! എല്ലാ മോഡലുകൾക്കും <code>push_to_hub</code> മെത്തേഡ് ഉണ്ട്; അത് ഉപയോഗിച്ചാൽ മോഡലുകളും അവയുടെ കോൺഫിഗറേഷൻ ഫയലുകളും ഒരു നിശ്ചിത റിപ്പോയിലേക്ക് പുഷ് ചെയ്യപ്പെടും. എന്നാൽ നിങ്ങൾക്ക് പങ്കുവെക്കാൻ കഴിയുന്നത് ഇത് മാത്രമല്ല.",
+            correct: true
+		},
+		{
+			text: "ഒരു പ്രത്യേക callback ഉപയോഗിച്ച് മുകളിൽ പറഞ്ഞവയെല്ലാം",
+			explain: "ശരിയാണ് — <code>PushToHubCallback</code> ട്രെയിനിംഗ് സമയത്ത് ഈ ഒബ്‌ജക്റ്റുകളെല്ലാം കൃത്യമായ ഇടവേളകളിൽ ഒരു റിപ്പോയിലേക്ക് അയയ്ക്കും.",
+            correct: true
+		}
+	]}
+/>
+{/if}
+
+### 6. `push_to_hub()` മെത്തേഡോ CLI ടൂളുകളോ ഉപയോഗിക്കുമ്പോൾ ആദ്യ ഘട്ടം എന്താണ്?
+
+<Question
+	choices={[
+		{
+			text: "വെബ്‌സൈറ്റിൽ ലോഗിൻ ചെയ്യുക.",
+			explain: "ഇത് നിങ്ങളുടെ ലോക്കൽ മെഷീനിൽ സഹായിക്കില്ല."
+		},
+		{
+			text: "ഒരു ടെർമിനലിൽ 'huggingface-cli login' റൺ ചെയ്യുക.",
+			explain: "ശരിയാണ് — ഇത് നിങ്ങളുടെ വ്യക്തിഗത ടോക്കൺ ഡൗൺലോഡ് ചെയ്ത് കാഷ് ചെയ്യും.",
+            correct: true
+		},
+		{
+			text: "ഒരു നോട്ട്‌ബുക്കിൽ 'notebook_login()' റൺ ചെയ്യുക.",
+			explain: "ശരിയാണ് — നിങ്ങൾക്ക് ഓതന്റിക്കേറ്റ് ചെയ്യാനുള്ള ഒരു വിജറ്റ് ഇത് പ്രദർശിപ്പിക്കും.",
+            correct: true
+		},
+	]}
+/>
+
+### 7. നിങ്ങൾ ഒരു മോഡലും ഒരു ടോക്കണൈസറും ഉപയോഗിക്കുന്നു — അവ എങ്ങനെ Hub-ലേക്ക് അപ്‌ലോഡ് ചെയ്യാം?
+
+<Question
+	choices={[
+		{
+			text: "മോഡലിലും ടോക്കണൈസറിലും നേരിട്ട് push_to_hub മെത്തേഡ് വിളിച്ചുകൊണ്ട്.",
+			explain: "ശരിയാണ്!",
+            correct: true
+		},
+		{
+			text: "Python റൺടൈമിനുള്ളിൽ, അവയെ ഒരു <code>huggingface_hub</code> യൂട്ടിലിറ്റിയിൽ പൊതിഞ്ഞുകൊണ്ട് (wrap).",
+			explain: "മോഡലുകളും ടോക്കണൈസറുകളും ഇതിനകം തന്നെ <code>huggingface_hub</code> യൂട്ടിലിറ്റികൾ പ്രയോജനപ്പെടുത്തുന്നുണ്ട്: അധികമായി പൊതിയേണ്ട ആവശ്യമില്ല!"
+		},
+		{
+			text: "അവയെ ഡിസ്‌കിൽ സേവ് ചെയ്ത് <code>transformers-cli upload-model</code> വിളിച്ചുകൊണ്ട്",
+			explain: "<code>upload-model</code> എന്ന കമാൻഡ് നിലവിലില്ല."
+		}
+	]}
+/>
+
+### 8. `Repository` ക്ലാസ് ഉപയോഗിച്ച് ഏതൊക്കെ git ഓപ്പറേഷനുകൾ നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയും?
+
+<Question
+	choices={[
+		{
+			text: "ഒരു കമ്മിറ്റ് (commit).",
+			explain: "ശരിയാണ്, അതിനായി <code>git_commit()</code> മെത്തേഡ് ഉണ്ട്.",
+            correct: true
+		},
+		{
+			text: "ഒരു പുൾ (pull)",
+			explain: "അതാണ് <code>git_pull()</code> മെത്തേഡിന്റെ ഉദ്ദേശ്യം.",
+            correct: true
+		},
+		{
+			text: "ഒരു പുഷ് (push)",
+			explain: "<code>git_push()</code> മെത്തേഡ് ഇത് ചെയ്യുന്നു.",
+            correct: true
+		},
+		{
+			text: "ഒരു മെർജ് (merge)",
+			explain: "ഇല്ല, ഈ API ഉപയോഗിച്ച് ആ ഓപ്പറേഷൻ ഒരിക്കലും സാധ്യമാകില്ല."
+		}
+	]}
+/>

From a4869a612d4a382417b546f5973303ee9912826f Mon Sep 17 00:00:00 2001
From: Nikhil Kilivayil <nikhilkilivayil@gmail.com>
Date: Mon, 7 Sep 2026 14:25:58 +0530
Subject: [PATCH 44/44] Add chapters 2-4 to Malayalam _toctree.yml

---
 chapters/ml/_toctree.yml | 56 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/chapters/ml/_toctree.yml b/chapters/ml/_toctree.yml
index c66dbf17c..dc33668eb 100644
--- a/chapters/ml/_toctree.yml
+++ b/chapters/ml/_toctree.yml
@@ -28,3 +28,59 @@
   - local: chapter1/11
     title: സർട്ടിഫിക്കേഷൻ പരീക്ഷ
     quiz: 1
+
+- title: 2. 🤗 Transformers ഉപയോഗിക്കുന്നത്
+  sections:
+  - local: chapter2/1
+    title: ആമുഖം
+  - local: chapter2/2
+    title: പൈപ്പ്‌ലൈനിന്റെ പിന്നിൽ
+  - local: chapter2/3
+    title: മോഡലുകൾ
+  - local: chapter2/4
+    title: ടോക്കണൈസറുകൾ
+  - local: chapter2/5
+    title: ഒന്നിലധികം സീക്വൻസുകൾ കൈകാര്യം ചെയ്യുന്നത്
+  - local: chapter2/6
+    title: എല്ലാം ഒരുമിച്ച് ചേർക്കുന്നത്
+  - local: chapter2/7
+    title: അടിസ്ഥാന ഉപയോഗം പൂർത്തിയായി!
+  - local: chapter2/8
+    title: ഒപ്‌റ്റിമൈസ് ചെയ്ത ഇൻഫറൻസ് ഡിപ്ലോയ്‌മെന്റ്
+  - local: chapter2/9
+    title: അധ്യായാന്ത്യ ക്വിസ്
+    quiz: 2
+
+- title: 3. ഒരു പ്രീട്രെയിൻഡ് മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യുന്നത്
+  sections:
+  - local: chapter3/1
+    title: ആമുഖം
+  - local: chapter3/2
+    title: ഡേറ്റ പ്രോസസ്സ് ചെയ്യുന്നത്
+  - local: chapter3/3
+    title: Trainer API ഉപയോഗിച്ച് ഒരു മോഡൽ ഫൈൻ-ട്യൂൺ ചെയ്യുന്നത്
+  - local: chapter3/4
+    title: ഒരു പൂർണ്ണ ട്രെയിനിംഗ് ലൂപ്പ്
+  - local: chapter3/5
+    title: ലേണിംഗ് കർവുകൾ മനസ്സിലാക്കുന്നത്
+  - local: chapter3/6
+    title: ഫൈൻ-ട്യൂണിംഗ്, പൂർത്തിയായി!
+  - local: chapter3/7
+    title: അധ്യായാന്ത്യ ക്വിസ്
+    quiz: 3
+
+- title: 4. മോഡലുകളും ടോക്കണൈസറുകളും പങ്കുവയ്ക്കുന്നത്
+  sections:
+  - local: chapter4/1
+    title: Hugging Face Hub
+  - local: chapter4/2
+    title: പ്രീട്രെയിൻഡ് മോഡലുകൾ ഉപയോഗിക്കുന്നത്
+  - local: chapter4/3
+    title: പ്രീട്രെയിൻഡ് മോഡലുകൾ പങ്കുവയ്ക്കുന്നത്
+  - local: chapter4/4
+    title: ഒരു മോഡൽ കാർഡ് നിർമ്മിക്കുന്നത്
+  - local: chapter4/5
+    title: ഭാഗം 1 പൂർത്തിയായി!
+  - local: chapter4/6
+    title: അധ്യായാന്ത്യ ക്വിസ്
+    quiz: 4