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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] 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/21] =?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/21] =?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/21] =?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`-നുള്ളിലാണ്.