diff --git a/chapters/mr/chapter 0/1.mdx b/chapters/mr/chapter 0/1.mdx
new file mode 100644
index 000000000..b0b6b4319
--- /dev/null
+++ b/chapters/mr/chapter 0/1.mdx
@@ -0,0 +1,51 @@
+# परिचय[[introduction]]
+
+हगिंग फेस (Hugging Face) कोर्समध्ये आपले स्वागत आहे! हा परिचय तुम्हाला तुमचे वर्किंग एन्व्हायर्नमेंट (working environment) सेट करण्यासाठी मार्गदर्शन करेल. जर तुम्ही हा कोर्स नुकताच सुरू करत असाल, तर आम्ही शिफारस करतो की तुम्ही आधी [प्रकरण १](/course/chapter1) पहावे, आणि नंतर परत येऊन तुमचे एन्व्हायर्नमेंट सेट करावे म्हणजे तुम्ही स्वतः कोड चालवून पाहू शकाल.
+
+या कोर्समध्ये आपण वापरणार असलेल्या सर्व लायब्ररीज पायथन पॅकेजेस (Python packages) म्हणून उपलब्ध आहेत, त्यामुळे आपण येथे पायथन एन्व्हायर्नमेंट कसे सेट करायचे आणि आवश्यक असलेल्या विशिष्ट लायब्ररीज कशा इन्स्टॉल करायच्या हे पाहणार आहोत.
+
+आपण तुमचे वर्किंग एन्व्हायर्नमेंट सेट करण्याच्या दोन पद्धती पाहणार आहोत: कोलॅब नोटबुक (Colab notebook) वापरणे किंवा पायथन व्हर्च्युअल एन्व्हायर्नमेंट (Python virtual environment) वापरणे. तुम्हाला सर्वात योग्य वाटेल अशी पद्धत तुम्ही निवडू शकता. नवशिक्यांसाठी (beginners), आम्ही कोलॅब नोटबुक वापरून सुरुवात करण्याची जोरदार शिफारस करतो.
+
+लक्षात घ्या की आपण विंडोज सिस्टीम कव्हर करणार नाही आहोत. जर तुम्ही विंडोज वापरत असाल, तर आम्ही तुम्हाला कोलॅब नोटबुक वापरूनच हा कोर्स पुढे चालू ठेवण्याची शिफारस करतो. जर तुम्ही लिनक्स (Linux) डिस्ट्रिब्युशन किंवा मॅकओएस (macOS) वापरत असाल, तर तुम्ही येथे वर्णन केलेल्या दोनपैकी कोणतीही पद्धत वापरू शकता.
+
+कोर्सचा बहुतांश भाग तुमच्याकडे हगिंग फेस अकाउंट असण्यावर अवलंबून आहे. आम्ही आताच एक तयार करण्याची शिफारस करतो: [खाते तयार करा](https://huggingface.co/join).
+
+## गुगल कोलॅब नोटबुक वापरणे[[using-a-google-colab-notebook]]
+
+कोलॅब नोटबुक वापरणे हा सर्वात सोपा सेटअप आहे; तुमच्या ब्राउझरमध्ये नोटबुक सुरू करा आणि थेट कोडिंगला लागा!
+
+जर तुम्हाला कोलॅबची माहिती नसेल, तर आम्ही [परिचय](https://colab.research.google.com/notebooks/intro.ipynb) वाचून सुरुवात करण्याची शिफारस करतो. कोलॅब तुम्हाला GPU किंवा TPU सारखे काही प्रवेगक हार्डवेअर (accelerating hardware) वापरण्याची परवानगी देते, आणि ते लहान वर्कलोड्ससाठी मोफत आहे.
+
+एकदा तुम्हाला कोलॅबची चांगली ओळख झाल्यावर, नवीन नोटबुक तयार करा आणि सेटअपला सुरुवात करा:
+
+
+
+
+
+
+
+
+
+
+लक्षात घ्या की कोर्स पूर्ण केल्यानंतर जर तुम्हाला अधिक सराव करायचा असेल तर फोरमवर [प्रोजेक्ट आयडियाज (project ideas)](https://discuss.huggingface.co/c/course/course-event/25) ची यादी देखील उपलब्ध आहे.
+
+- **मला कोर्ससाठीचा कोड कुठे मिळेल?**
+प्रत्येक विभागासाठी, Google Colab किंवा Amazon SageMaker Studio Lab मध्ये कोड चालवण्यासाठी (run) पृष्ठाच्या शीर्षस्थानी असलेल्या बॅनरवर क्लिक करा:
+
+
+
+कोर्समधील सर्व कोड असलेल्या ज्युपिटर नोटबुक्स (Jupyter notebooks) [`huggingface/notebooks`](https://github.com/huggingface/notebooks) रेपोवर होस्ट केलेल्या आहेत. जर तुम्हाला त्या लोकली जनरेट करायच्या असतील, तर GitHub वरील [`course`](https://github.com/huggingface/course#-jupyter-notebooks) रेपो मधील सूचना पहा.
+
+- **मी कोर्समध्ये कसे योगदान देऊ शकतो?**
+कोर्समध्ये योगदान देण्याचे अनेक मार्ग आहेत! जर तुम्हाला एखादी टायपो (typo) किंवा बग (bug) आढळल्यास, कृपया [`course`](https://github.com/huggingface/course) रेपोवर एखादा इश्यू (issue) ओपन करा. जर तुम्हाला हा कोर्स तुमच्या मातृभाषेत अनुवादित करण्यात मदत करायची असेल, तर [येथे](https://github.com/huggingface/course#translating-the-course-into-your-language) दिलेल्या सूचना पहा.
+
+- **प्रत्येक भाषांतरासाठी कोणत्या निवडी केल्या गेल्या?**
+प्रत्येक भाषांतरासाठी एक शब्दकोष (glossary) आणि `TRANSLATING.txt` फाईल असते ज्यामध्ये मशीन लर्निंगमधील तांत्रिक शब्दांसाठी (jargon) केलेल्या निवडींचा तपशील दिलेला असतो. तुम्ही जर्मन भाषेसाठी एक उदाहरण [येथे](https://github.com/huggingface/course/blob/main/chapters/de/TRANSLATING.txt) शोधू शकता.
+
+- **मी हा कोर्स पुन्हा वापरू शकतो का?**
+नक्कीच! हा कोर्स परमिसिव्ह (permissive) [अपाचे २ लायसन्स (Apache 2 license)](https://www.apache.org/licenses/LICENSE-2.0.html) अंतर्गत प्रकाशित करण्यात आला आहे. याचा अर्थ असा की तुम्ही योग्य श्रेय (credit) दिले पाहिजे, लायसन्सची लिंक दिली पाहिजे आणि जर काही बदल केले असतील तर ते नमूद केले पाहिजेत. तुम्ही हे कोणत्याही वाजवी मार्गाने करू शकता, परंतु कोणत्याही प्रकारे परवाना देणाऱ्याने (licensor) तुम्हाला किंवा तुमच्या वापराला मान्यता दिली आहे असे सुचवता येणार नाही. जर तुम्हाला या कोर्सचा संदर्भ (cite) द्यायचा असेल, तर कृपया खालील BibTeX वापरा:
\ No newline at end of file
diff --git a/chapters/mr/chapter 1/10.mdx b/chapters/mr/chapter 1/10.mdx
new file mode 100644
index 000000000..e69de29bb
diff --git a/chapters/mr/chapter 1/11.mdx b/chapters/mr/chapter 1/11.mdx
new file mode 100644
index 000000000..e69de29bb
diff --git a/chapters/mr/chapter 1/2.mdx b/chapters/mr/chapter 1/2.mdx
new file mode 100644
index 000000000..1f856f6db
--- /dev/null
+++ b/chapters/mr/chapter 1/2.mdx
@@ -0,0 +1,52 @@
+# नॅचरल लँग्वेज प्रोसेसिंग आणि लार्ज लँग्वेज मॉडेल्स[[natural-language-processing-and-large-language-models]]
+
+
+
+ट्रान्सफॉर्मर (Transformer) मॉडेल्सकडे वळण्यापूर्वी, नॅचरल लँग्वेज प्रोसेसिंग म्हणजे काय, लार्ज लँग्वेज मॉडेल्सनी या क्षेत्रात कसा बदल घडवून आणला आहे आणि आपण त्याची काळजी का करतो, याचा थोडक्यात आढावा घेऊया.
+
+## NLP म्हणजे काय?[[what-is-nlp]]
+
+
+
+NLP हे भाषाशास्त्र (linguistics) आणि मशीन लर्निंगचे एक क्षेत्र आहे जे मानवी भाषेशी संबंधित सर्व काही समजून घेण्यावर केंद्रित आहे. NLP टास्कचा उद्देश केवळ एकेरी शब्दांचा स्वतंत्रपणे अर्थ समजून घेणे हा नसून, त्या शब्दांचा संदर्भ (context) समजून घेण्यास सक्षम असणे हा आहे.
+
+खाली काही सामान्य NLP टास्क्सची यादी त्यांच्या काही उदाहरणांसह दिली आहे:
+
+- **संपूर्ण वाक्यांचे वर्गीकरण करणे (Classifying whole sentences)**: रिव्ह्यूचे सेंटिमेंट (sentiment) मिळवणे, ईमेल स्पॅम आहे की नाही हे शोधणे, वाक्य व्याकरणदृष्ट्या योग्य आहे की नाही किंवा दोन वाक्ये तार्किकदृष्ट्या संबंधित आहेत की नाही हे ठरवणे.
+- **वाक्यातील प्रत्येक शब्दाचे वर्गीकरण करणे**: वाक्यातील व्याकरणाचे घटक (नाम, क्रियापद, विशेषण) किंवा नेम्ड एंटिटीज (व्यक्ती, ठिकाण, संस्था) ओळखणे.
+- **टेक्स्ट कंटेंट तयार करणे (Generating text content)**: ऑटोजेनरेटेड (auto-generated) टेक्स्टसह प्रॉम्प्ट पूर्ण करणे, टेक्स्ट मधील रिकाम्या जागा मास्क्ड (masked) शब्दांनी भरणे.
+- **टेक्स्ट मधून उत्तर काढणे**: दिलेला प्रश्न आणि संदर्भ (context) यावर आधारित, संदर्भात दिलेल्या माहितीवरून प्रश्नाचे उत्तर शोधून काढणे.
+- **इनपुट टेक्स्ट वरून नवीन वाक्य तयार करणे**: टेक्स्टचा दुसऱ्या भाषेत अनुवाद करणे, टेक्स्टचा सारांश (summarizing) काढणे.
+
+तथापि, NLP केवळ लिखित टेक्स्टपुरते मर्यादित नाही. ते स्पीच रेकग्निशन (speech recognition) आणि कॉम्प्युटर व्हिजनमधील (computer vision) जटिल आव्हानांना देखील सामोरे जाते, जसे की ऑडिओ सॅम्पलची ट्रान्सक्रिप्ट किंवा इमेजचे वर्णन तयार करणे.
+
+## लार्ज लँग्वेज मॉडेल्सचा (LLMs) उदय[[rise-of-llms]]
+
+अलिकडच्या वर्षांत, लार्ज लँग्वेज मॉडेल्सनी (LLMs) NLP क्षेत्रात क्रांती घडवून आणली आहे. GPT (जनरेटिव्ह प्री-ट्रेन्ड ट्रान्सफॉर्मर) आणि [Llama](https://huggingface.co/meta-llama) सारख्या आर्किटेक्चर्सचा समावेश असलेल्या या मॉडेल्सनी लँग्वेज प्रोसेसिंगमध्ये काय शक्य आहे हे पूर्णपणे बदलून टाकले आहे.
+
+> [!TIP]
+> लार्ज लँग्वेज मॉडेल (LLM) हे एक AI मॉडेल आहे जे मोठ्या प्रमाणातील टेक्स्ट डेटावर ट्रेन केलेले असते आणि ते मानवासारखे टेक्स्ट समजून घेऊ आणि तयार करू शकते, भाषेतील पॅटर्न ओळखू शकते आणि कोणत्याही विशिष्ट टास्कच्या ट्रेनिंगशिवाय अनेक प्रकारची भाषिक कार्ये करू शकते. ते नॅचरल लँग्वेज प्रोसेसिंग (NLP) क्षेत्रातील एक महत्त्वपूर्ण प्रगती दर्शवतात.
+
+LLMs ची वैशिष्ट्ये खालीलप्रमाणे आहेत:
+- **स्केल (Scale)**: त्यांच्यात लाखो, अब्जावधी किंवा शेकडो अब्जावधी पॅरामीटर्स (parameters) असतात.
+- **सामान्य क्षमता (General capabilities)**: ते टास्क-विशिष्ट (task-specific) ट्रेनिंगशिवाय अनेक कार्ये करू शकतात.
+- **इन-कॉन्टेक्स्ट लर्निंग (In-context learning)**: ते प्रॉम्प्टमध्ये दिलेल्या उदाहरणांवरून शिकू शकतात.
+- **इमर्जंट ॲबिलिटीज (Emergent abilities)**: जसजसा या मॉडेल्सचा आकार वाढतो, तसतसे ते अशा क्षमता दाखवतात ज्या स्पष्टपणे प्रोग्राम केलेल्या किंवा अपेक्षित नव्हत्या.
+
+LLMs च्या आगमनाने विशिष्ट NLP कार्यांसाठी विशेष मॉडेल्स तयार करण्याच्या पद्धतीकडून एकाच, मोठ्या मॉडेलचा वापर करण्याकडे एक स्थित्यंतर (paradigm shift) घडवून आणले आहे, ज्याला विविध भाषिक कार्यांसाठी प्रॉम्प्ट किंवा फाइन-ट्यून (fine-tune) केले जाऊ शकते. यामुळे प्रगत लँग्वेज प्रोसेसिंग अधिक सुलभ झाले आहे, पण सोबतच कार्यक्षमता, नैतिकता (ethics) आणि डिप्लॉयमेंट यांसारख्या क्षेत्रांमध्ये नवीन आव्हाने देखील उभी केली आहेत.
+
+तथापि, LLMs च्या काही महत्त्वाच्या मर्यादा देखील आहेत:
+- **हॅलुसिनेशन्स (Hallucinations)**: ते अत्यंत आत्मविश्वासाने चुकीची माहिती तयार करू शकतात.
+- **खऱ्या समजेचा अभाव**: त्यांच्याकडे जगाची खरी समज नसते आणि ते पूर्णपणे सांख्यिकीय पॅटर्नवर (statistical patterns) कार्य करतात.
+- **बायस (Bias / पूर्वग्रह)**: ते त्यांच्या ट्रेनिंग डेटामध्ये किंवा इनपुटमध्ये असलेले पूर्वग्रह पुन्हा निर्माण करू शकतात.
+- **कॉन्टेक्स्ट विंडोज (Context windows)**: त्यांच्याकडे मर्यादित कॉन्टेक्स्ट विंडोज असतात (जरी यामध्ये सुधारणा होत असली तरीही).
+- **कम्प्युटेशनल रिसोर्सेस (Computational resources)**: त्यांना मोठ्या प्रमाणावर संगणकीय संसाधनांची आवश्यकता असते.
+
+## लँग्वेज प्रोसेसिंग आव्हानात्मक का आहे?[[why-is-it-challenging]]
+
+संगणक माणसांप्रमाणे माहितीवर प्रक्रिया करत नाहीत. उदाहरणार्थ, जेव्हा आपण "मला भूक लागली आहे" हे वाक्य वाचतो, तेव्हा आपण त्याचा अर्थ सहज समजू शकतो. त्याचप्रमाणे, "मला भूक लागली आहे" आणि "मी दुःखी आहे" यासारखी दोन वाक्ये दिली असता, त्यांच्यात किती साम्य आहे हे आपण सहज ठरवू शकतो. मशीन लर्निंग (ML) मॉडेल्ससाठी अशी कार्ये अधिक कठीण असतात. टेक्स्टवर अशा प्रकारे प्रक्रिया करणे आवश्यक आहे ज्यामुळे मॉडेलला त्यातून शिकण्यास सक्षम करता येईल. आणि भाषा अत्यंत क्लिष्ट असल्यामुळे, ही प्रक्रिया कशी केली जावी याबद्दल आपल्याला काळजीपूर्वक विचार करणे आवश्यक आहे. टेक्स्टचे प्रतिनिधित्व (represent) कसे करावे यावर बरेच संशोधन झाले आहे, आणि आपण पुढील प्रकरणात काही पद्धती पाहणार आहोत.
+
+LLMs मधील प्रगतीनंतरही, अनेक मूलभूत आव्हाने अजूनही कायम आहेत. यामध्ये संदिग्धता (ambiguity), सांस्कृतिक संदर्भ, उपहास (sarcasm) आणि विनोद समजून घेणे यांचा समावेश आहे. विविध प्रकारच्या डेटासेटवर मोठ्या प्रमाणावर ट्रेनिंग देऊन LLMs या आव्हानांना सामोरे जातात, परंतु अनेक गुंतागुंतीच्या परिस्थितींमध्ये मानवी पातळीवरील समजूतदारपणाच्या तुलनेत ते अजूनही कमी पडतात.
diff --git a/chapters/mr/chapter 1/3.mdx b/chapters/mr/chapter 1/3.mdx
new file mode 100644
index 000000000..68492950a
--- /dev/null
+++ b/chapters/mr/chapter 1/3.mdx
@@ -0,0 +1,49 @@
+ट्रान्सफॉर्मर्स, ते काय करू शकतात?[[transformers-what-can-they-do]]
+
+या विभागात, आपण ट्रान्सफॉर्मर मॉडेल्स काय करू शकतात हे पाहू आणि 🤗 Transformers लायब्ररीतील आपले पहिले साधन वापरू: pipeline() फंक्शन.
+
+[!TIP] 👀 वर उजवीकडे Open in Colab बटण दिसतंय का? या विभागातील सर्व कोड उदाहरणांसह Google Colab नोटबुक उघडण्यासाठी त्यावर क्लिक करा. कोड उदाहरणे असलेल्या प्रत्येक विभागात हे बटण दिसेल.
+
+जर तुम्हाला उदाहरणे स्थानिक पातळीवर (locally) चालवायची असतील, तर सेटअप पाहण्याची शिफारस करतो.
+
+ट्रान्सफॉर्मर्स सर्वत्र आहेत![[transformers-are-everywhere]]
+
+नैसर्गिक भाषा प्रक्रिया (NLP), संगणकीय दृष्टी (computer vision), ऑडिओ प्रक्रिया आणि इतर विविध क्षेत्रांतील सर्व प्रकारची कामे सोडवण्यासाठी ट्रान्सफॉर्मर मॉडेल्स वापरली जातात. Hugging Face आणि ट्रान्सफॉर्मर मॉडेल्स वापरणाऱ्या आणि समुदायाला परत योगदान देणाऱ्या (त्यांची मॉडेल्स शेअर करून) काही कंपन्या आणि संस्था इथे दाखवल्या आहेत:
+
+
+
+🤗 Transformers लायब्ररी ही शेअर केलेली मॉडेल्स तयार करण्याची आणि वापरण्याची क्षमता पुरवते. Model Hub मध्ये लाखो प्रशिक्षित (pretrained) मॉडेल्स आहेत, जी कोणीही डाउनलोड करून वापरू शकतं. तुम्ही तुमची स्वतःची मॉडेल्ससुद्धा Hub वर अपलोड करू शकता!
+
+[!TIP] ⚠️ Hugging Face Hub फक्त ट्रान्सफॉर्मर मॉडेल्सपुरतं मर्यादित नाही. कोणीही कोणत्याही प्रकारची मॉडेल्स किंवा डेटासेट्स शेअर करू शकतो! सर्व उपलब्ध वैशिष्ट्यांचा लाभ घेण्यासाठी huggingface.co खातं तयार करा!
+
+ट्रान्सफॉर्मर मॉडेल्स आतून कशी काम करतात हे पाहण्याआधी, काही मनोरंजक NLP समस्या सोडवण्यासाठी ती कशी वापरली जाऊ शकतात याची काही उदाहरणं पाहूया.
+
+पाइपलाइन्ससोबत काम करणे[[working-with-pipelines]]
+
+🤗 Transformers लायब्ररीतील सर्वात मूलभूत ऑब्जेक्ट म्हणजे pipeline() फंक्शन. हे मॉडेलला त्याच्या आवश्यक प्री-प्रोसेसिंग आणि पोस्ट-प्रोसेसिंग पायऱ्यांशी जोडतं, ज्यामुळे आपण थेट कोणताही मजकूर इनपुट करून समजण्याजोगं उत्तर मिळवू शकतो:
+
+python
+from transformers import pipeline
+
+classifier = pipeline("sentiment-analysis")
+classifier("I've been waiting for a HuggingFace course my whole life.")
+python
+[{'label': 'POSITIVE', 'score': 0.9598047137260437}]
+
+आपण अनेक वाक्येसुद्धा एकत्र पाठवू शकतो!
+
+python
+classifier(
+ ["I've been waiting for a HuggingFace course my whole life.", "I hate this so much!"]
+)
+python
+[{'label': 'POSITIVE', 'score': 0.9598047137260437},
+ {'label': 'NEGATIVE', 'score': 0.9994558095932007}]
+
+डिफॉल्टनुसार, ही पाइपलाइन इंग्रजीतील भावना विश्लेषणासाठी (sentiment analysis) फाइन-ट्यून केलेलं एक विशिष्ट पूर्व-प्रशिक्षित मॉडेल निवडते. जेव्हा तुम्ही classifier ऑब्जेक्ट तयार करता, तेव्हा मॉडेल डाउनलोड होऊन कॅश (cache) होतं. जर तुम्ही कमांड पुन्हा चालवली, तर कॅश केलेलं मॉडेल वापरलं जाईल आणि पुन्हा डाउनलोड करण्याची गरज पडणार नाही.
+
+जेव्हा तुम्ही पाइपलाइनला काही मजकूर पाठवता, तेव्हा तीन मुख्य पायऱ्या घडतात:
+
+मजकूर मॉडेलला समजेल अशा स्वरूपात प्री-प्रोसेस केला जातो.
+प्री-प्रोसेस केलेले इनपुट मॉडेलकडे पाठवले जातात.
+मॉडेलचे अंदाज (predictions) पोस्ट-प्रोसेस केले जातात, जेणेकरून तुम्हाला त्यांचा अर्थ समजू शकेल.
\ No newline at end of file
diff --git a/chapters/mr/chapter 1/4.mdx b/chapters/mr/chapter 1/4.mdx
new file mode 100644
index 000000000..a89ab03df
--- /dev/null
+++ b/chapters/mr/chapter 1/4.mdx
@@ -0,0 +1,133 @@
+ट्रान्सफॉर्मर्स कसे काम करतात?[[how-do-transformers-work]]
+या विभागात, आपण ट्रान्सफॉर्मर मॉडेल्सच्या आर्किटेक्चर (रचनेवर) एक नजर टाकू आणि अटेन्शन, एन्कोडर-डिकोडर आर्किटेक्चर आणि इतर संकल्पना अधिक सखोलपणे समजून घेऊ.
+
+[!WARNING]
+🚀 आपण येथे एक पाऊल पुढे टाकत आहोत. हा विभाग तपशीलवार आणि तांत्रिक आहे, त्यामुळे तुम्हाला सर्व काही लगेच समजले नाही तरी काळजी करू नका. आपण या कोर्समध्ये नंतर या संकल्पनांवर पुन्हा सविस्तर चर्चा करू.
+
+ट्रान्सफॉर्मरचा थोडा इतिहास[[a-bit-of-transformer-history]]
+ट्रान्सफॉर्मर मॉडेल्सच्या (लहान) इतिहासातील काही महत्त्वाचे टप्पे (reference points) येथे दिले आहेत:
+
+ट्रान्सफॉर्मर आर्किटेक्चर जून २०१७ मध्ये सादर केले गेले. मूळ संशोधनाचा मुख्य भर भाषांतर (translation) कार्यांवर होता. यानंतर अनेक प्रभावशाली मॉडेल्स सादर केली गेली, ज्यामध्ये खालील मॉडेल्सचा समावेश आहे:
+
+जून २०१८: GPT, पहिले प्री-ट्रेंड ट्रान्सफॉर्मर मॉडेल, जे विविध NLP (नॅचरल लँग्वेज प्रोसेसिंग) कार्यांवर फाइन-ट्युनिंगसाठी वापरले गेले आणि ज्याने उत्कृष्ट (state-of-the-art) परिणाम मिळवले.
+
+ऑक्टोबर २०१८: BERT, दुसरे मोठे प्री-ट्रेंड मॉडेल, जे वाक्यांचे अधिक चांगले सारांश तयार करण्यासाठी डिझाइन केले गेले (पुढील प्रकरणात याबद्दल अधिक माहिती!).
+
+फेब्रुवारी २०१९: GPT-2, GPT ची सुधारित (आणि मोठी) आवृत्ती जी नैतिक चिंतांमुळे (ethical concerns) त्वरित सार्वजनिकपणे प्रदर्शित केली गेली नाही.
+
+ऑक्टोबर २०१९: T5, सिक्वेन्स-टू-सिक्वेन्स ट्रान्सफॉर्मर आर्किटेक्चरचे मल्टी-टास्क केंद्रित अंमलबजावणी मॉडेल.
+
+मे २०२०: GPT-3, GPT-2 ची आणखी मोठी आवृत्ती जी फाइन-ट्युनिंगच्या गरजेशिवाय विविध कामे उत्तम प्रकारे करू शकते (याला झिरो-शॉट लर्निंग म्हणतात).
+
+जानेवारी २०२२: InstructGPT, GPT-3 ची एक आवृत्ती ज्याला सूचनांचे (instructions) अधिक चांगल्या प्रकारे पालन करण्यासाठी प्रशिक्षित केले गेले.
+
+जानेवारी २०२३: Llama, एक लार्ज लँग्वेज मॉडेल (LLM) जे विविध भाषांमध्ये मजकूर तयार करू शकते.
+
+मार्च २०२३: Mistral, ७-अब्ज-पॅरामीटर्सचे लँग्वेज मॉडेल जे Llama 2 13B ला सर्व मूल्यमापन केलेल्या बेंचमार्कवर मागे टाकते. हे जलद इन्फरन्ससाठी ग्रुप्ड-क्वेरी अटेन्शन (grouped-query attention) आणि कोणत्याही लांबीच्या सिक्वेन्स हाताळण्यासाठी स्लाइडिंग विंडो अटेन्शन (sliding window attention) चा वापर करते.
+
+मे २०२४: Gemma 2, २ अब्ज (2B) ते २७ अब्ज (27B) पॅरामीटर्सपर्यंतच्या हलक्या (lightweight), अत्याधुनिक ओपन मॉडेल्सचा समूह, ज्यामध्ये इंटरलीव्ह्ड लोकल-ग्लोबल अटेन्शन आणि ग्रुप-क्वेरी अटेन्शन समाविष्ट आहे. यातील लहान मॉडेल्स नॉलेज डिस्टिलेशन (knowledge distillation) वापरून प्रशिक्षित केली गेली आहेत, जी त्यांच्यापेक्षा २-३ पट मोठ्या मॉडेल्सच्या तुलनेत उत्कृष्ट कामगिरी देतात.
+
+नोव्हेंबर २०२४: SmolLM2, एक अत्याधुनिक लहान लँग्वेज मॉडेल (१३५ दशलक्ष ते १.७ अब्ज पॅरामीटर्स) जे त्याच्या लहान आकारमान असूनही प्रभावी कामगिरी साध्य करते आणि मोबाइल आणि एज (edge) उपकरणांसाठी नवीन शक्यता उघडते.
+
+ही यादी पूर्णपणे सर्वसमावेशक नाही, आणि ती फक्त काही वेगवेगळ्या प्रकारच्या ट्रान्सफॉर्मर मॉडेल्सवर प्रकाश टाकण्यासाठी आहे. सामान्यतः, त्यांना तीन श्रेणींमध्ये विभागले जाऊ शकते:
+
+GPT-सारखे (ज्यांना ऑटो-रिग्रेसिव्ह ट्रान्सफॉर्मर मॉडेल्स असेही म्हणतात)
+
+BERT-सारखे (ज्यांना ऑटो-एन्कोडिंग ट्रान्सफॉर्मर मॉडेल्स असेही म्हणतात)
+
+T5-सारखे (ज्यांना सिक्वेन्स-टू-सिक्वेन्स ट्रान्सफॉर्मर मॉडेल्स असेही म्हणतात)
+
+आपण पुढे या श्रेणींबद्दल (families) अधिक सविस्तर जाणून घेऊ.
+
+ट्रान्सफॉर्मर्स हे लँग्वेज मॉडेल्स आहेत[[transformers-are-language-models]]
+वर नमूद केलेली सर्व ट्रान्सफॉर्मर मॉडेल्स (GPT, BERT, T5 इ.) लँग्वेज मॉडेल्स (भाषा मॉडेल्स) म्हणून प्रशिक्षित केली गेली आहेत. याचा अर्थ त्यांना सेल्फ-सुपरवाइज्ड (self-supervised) पद्धतीने मोठ्या प्रमाणातील कच्च्या (raw) मजकुरावर प्रशिक्षित केले गेले आहे.
+
+सेल्फ-सुपरवाइज्ड लर्निंग (Self-supervised learning) हा प्रशिक्षणाचा एक प्रकार आहे ज्यामध्ये मॉडेलच्या इनपुटमधून उद्दिष्ट (objective) स्वयंचलितपणे मोजले जाते. याचा अर्थ असा की डेटाला लेबल करण्यासाठी मानवांची आवश्यकता नाही!
+
+अशा प्रकारचे मॉडेल ज्या भाषेवर प्रशिक्षित केले जाते, तिची सांख्यिकीय (statistical) समज विकसित करते, परंतु ते विशिष्ट व्यावहारिक कार्यांसाठी कमी उपयुक्त असते. यामुळे, सामान्य प्री-ट्रेंड मॉडेल त्यानंतर ट्रान्सफर लर्निंग (transfer learning) किंवा फाइन-ट्युनिंग (fine-tuning) नावाच्या प्रक्रियेतून जाते. या प्रक्रियेदरम्यान, मॉडेलला एखाद्या विशिष्ट कार्यासाठी सुपरवाइज्ड पद्धतीने -- म्हणजेच, मानवी-चिन्हांकित लेबल्स वापरून -- फाइन-ट्यून केले जाते.
+
+एखाद्या कार्याचे उदाहरण म्हणजे n मागील शब्द वाचून वाक्यातील पुढील शब्दाचा अंदाज लावणे (predict करणे). याला कॉझल लँग्वेज मॉडेलिंग (causal language modeling) म्हणतात कारण आउटपुट भूतकाळातील आणि वर्तमान इनपुट्सवर अवलंबून असते, परंतु भविष्यातील इनपुट्सवर नाही.
+
+दुसरे उदाहरण म्हणजे मास्क्ड लँग्वेज मॉडेलिंग (masked language modeling), ज्यामध्ये मॉडेल वाक्यातील लपवलेल्या (masked) शब्दाचा अंदाज लावते.
+
+ट्रान्सफॉर्मर्स हे मोठे मॉडेल्स आहेत[[transformers-are-big-models]]
+(DistilBERT सारखे) काही अपवाद वगळता, चांगली कामगिरी मिळवण्यासाठी सामान्य धोरण म्हणजे मॉडेल्सचा आकार वाढवणे तसेच त्यांना ज्या डेटावर प्री-ट्रेन केले जाते त्याचे प्रमाण वाढवणे.
+
+दुर्दैवाने, मॉडेलला प्रशिक्षित करण्यासाठी, विशेषतः मोठ्या मॉडेलला, मोठ्या प्रमाणावर डेटा लागतो. हे वेळ आणि संगणकीय संसाधनांच्या (compute resources) बाबतीत खूप खर्चिक बनते. खालील आलेखात पाहिल्याप्रमाणे, याचा पर्यावरणावर देखील परिणाम होतो.
+
+आणि हे एका (खूप मोठ्या) मॉडेलच्या प्रकल्पासाठी दर्शविले आहे ज्याचे नेतृत्व अशा टीमने केले आहे जे प्री-ट्रेनिंगचा पर्यावरणीय प्रभाव जाणीवपूर्वक कमी करण्याचा प्रयत्न करत आहेत. सर्वोत्तम हायपरपॅरामीटर्स मिळवण्यासाठी अनेक चाचण्या घेण्याचा पर्यावरणीय प्रभाव (carbon footprint) याहूनही जास्त असेल.
+
+कल्पना करा की प्रत्येक वेळी एखादी संशोधन संस्था, विद्यार्थी संघटना किंवा कंपनीला मॉडेल प्रशिक्षित करायचे असेल, आणि त्यांनी ते शून्यापासून (from scratch) सुरू केले तर काय होईल. यामुळे मोठ्या प्रमाणावर अनावश्यक जागतिक खर्च वाढेल!
+
+म्हणूनच लँग्वेज मॉडेल्स शेअर करणे अत्यंत महत्त्वाचे आहे: प्रशिक्षित वेट्स (trained weights) सामायिक करणे आणि आधीच प्रशिक्षित असलेल्या वेट्सच्या आधारे पुढील काम करणे यामुळे समुदायाचा एकूण संगणकीय खर्च आणि कार्बन फूटप्रिंट कमी होतो.
+
+तसे पाहता, तुम्ही तुमच्या मॉडेल्सच्या प्रशिक्षणाचा कार्बन फूटप्रिंट अनेक साधनांद्वारे मोजू शकता. उदाहरणार्थ, ML CO2 Impact किंवा Code Carbon जे 🤗 Transformers मध्ये समाकलित (integrated) केले आहे. याबद्दल अधिक जाणून घेण्यासाठी, तुम्ही ही ब्लॉग पोस्ट वाचू शकता जी तुम्हाला तुमच्या प्रशिक्षणाच्या फूटप्रिंटचा अंदाज असलेल्या emissions.csv फाइल कशी तयार करायची ते दर्शवेल, तसेच 🤗 Transformers चे डॉक्युमेंटेशन जे या विषयावर मार्गदर्शन करते.
+
+ट्रान्सफर लर्निंग (Transfer Learning)[[transfer-learning]]
+प्री-ट्रेनिंग (Pretraining) म्हणजे एखाद्या मॉडेलला शून्यापासून (from scratch) प्रशिक्षित करण्याची प्रक्रिया: यामध्ये वेट्स (weights) यादृच्छिकपणे (randomly) सुरू केले जातात आणि कोणत्याही पूर्वज्ञानाशिवाय प्रशिक्षण सुरू होते.
+
+हे प्री-ट्रेनिंग सहसा अत्यंत मोठ्या प्रमाणातील डेटावर केले जाते. त्यामुळे, यासाठी डेटाचा खूप मोठा संग्रह (corpus) लागतो, आणि प्रशिक्षणासाठी कित्येक आठवडे लागू शकतात.
+
+दुसरीकडे, फाइन-ट्युनिंग (Fine-tuning) हे मॉडेलला प्री-ट्रेन केल्यानंतर केले जाणारे प्रशिक्षण आहे. फाइन-ट्युनिंग करण्यासाठी, तुम्ही आधी एक प्री-ट्रेंड लँग्वेज मॉडेल मिळवता, आणि नंतर तुमच्या विशिष्ट कार्यासाठी तयार केलेल्या डेटासेटसह अतिरिक्त प्रशिक्षण देता. थांबा -- तुमच्या अंतिम उपयोगासाठी (use case) मॉडेलला सुरुवातीपासूनच (शून्यापासून/scratch) का प्रशिक्षित करू नये? याची काही कारणे आहेत:
+
+प्री-ट्रेंड मॉडेल आधीच अशा डेटासेटवर प्रशिक्षित केलेले असते ज्याचे फाइन-ट्युनिंग डेटासेटशी काही साधर्म्य असते. त्यामुळे फाइन-ट्युनिंग प्रक्रिया प्रारंभिक मॉडेलने प्री-ट्रेनिंग दरम्यान मिळवलेल्या ज्ञानाचा फायदा घेऊ शकते (उदाहरणार्थ, NLP समस्यांमध्ये, प्री-ट्रेंड मॉडेलला तुम्ही तुमच्या कामासाठी वापरत असलेल्या भाषेची काही प्रमाणात सांख्यिकीय समज असेल).
+
+प्री-ट्रेंड मॉडेल आधीच भरपूर डेटावर प्रशिक्षित झालेले असल्याने, चांगले परिणाम मिळवण्यासाठी फाइन-ट्युनिंगला खूप कमी डेटा लागतो.
+
+याच कारणामुळे, चांगले परिणाम मिळवण्यासाठी लागणारा वेळ आणि संसाधने खूप कमी असतात.
+
+उदाहरणार्थ, इंग्रजी भाषेवर प्रशिक्षित केलेले एखादे प्री-ट्रेंड मॉडेल वापरून नंतर ते arXiv कॉर्पसवर (विज्ञान संशोधनातील पेपर्स) फाइन-ट्यून केले जाऊ शकते, ज्यामुळे विज्ञान/संशोधन-आधारित मॉडेल तयार होईल. या फाइन-ट्युनिंगला फक्त मर्यादित प्रमाणात डेटा लागेल: प्री-ट्रेंड मॉडेलने जे ज्ञान आधीच मिळवले आहे ते "हस्तांतरित" (transferred) केले जाते, म्हणूनच याला ट्रान्सफर लर्निंग (transfer learning) असे म्हणतात.
+
+मॉडेल फाइन-ट्यून करण्यामुळे वेळ, डेटा, आर्थिक खर्च आणि पर्यावरणीय प्रभाव कमी असतो. वेगवेगळ्या फाइन-ट्युनिंग योजनांवर काम करणे देखील अधिक जलद आणि सोपे असते, कारण हे प्रशिक्षण पूर्ण प्री-ट्रेनिंगपेक्षा कमी वेळखाऊ असते.
+
+या प्रक्रियेमुळे शून्यापासून प्रशिक्षण देण्याच्या तुलनेत (तुमच्याकडे भरपूर डेटा असल्याशिवाय) चांगले परिणाम मिळतील. म्हणूनच तुम्ही नेहमी एखाद्या प्री-ट्रेंड मॉडेलचा फायदा घेण्याचा प्रयत्न केला पाहिजे -- जे मॉडेल तुमच्या कामाशी शक्य तितके जवळचे असेल -- आणि त्याला फाइन-ट्यून केले पाहिजे.
+
+सामान्य ट्रान्सफॉर्मर आर्किटेक्चर[[general-transformer-architecture]]
+या विभागात, आपण ट्रान्सफॉर्मर मॉडेलच्या सामान्य आर्किटेक्चरवर (रचनेवर) चर्चा करू. तुम्हाला काही संकल्पना समजल्या नाहीत तर काळजी करू नका; पुढील भागांमध्ये प्रत्येक घटकावर सविस्तर चर्चा केली आहे.
+
+हे मॉडेल प्रामुख्याने दोन ब्लॉक्सचे बनलेले असते:
+
+एन्कोडर (डावीकडे): एन्कोडरला इनपुट मिळते आणि तो त्याचे प्रतिनिधित्व (representation) म्हणजेच वैशिष्ट्ये (features) तयार करतो. याचा अर्थ असा की हे मॉडेल इनपुटमधून समज मिळवण्यासाठी अनुकूल (optimized) केलेले असते.
+
+डिकोडर (उजवीकडे): डिकोडर टार्गेट सिक्वेन्स (लक्ष्य क्रम) तयार करण्यासाठी एन्कोडरचे प्रतिनिधित्व (वैशिष्ट्ये) आणि इतर इनपुट्स वापरतो. याचा अर्थ असा की हे मॉडेल आउटपुट जनरेट करण्यासाठी अनुकूल केलेले असते.
+
+कामाच्या स्वरूपानुसार हे दोन्ही भाग स्वतंत्रपणे वापरले जाऊ शकतात:
+
+फक्त-एन्कोडर मॉडेल्स (Encoder-only models): वाक्यांचे वर्गीकरण (sentence classification) आणि नेम्ड एंटिटी रेकग्निशन (named entity recognition) यासारख्या इनपुट समजून घेण्याची आवश्यकता असलेल्या कार्यांसाठी चांगले.
+
+फक्त-डिकोडर मॉडेल्स (Decoder-only models): मजकूर निर्मितीसारख्या (text generation) जनरेटिव्ह (generative) कार्यांसाठी चांगले.
+
+एन्कोडर-डिकोडर मॉडेल्स किंवा सिक्वेन्स-टू-सिक्वेन्स मॉडेल्स: भाषांतर (translation) किंवा सारांश (summarization) यासारख्या इनपुटची आवश्यकता असलेल्या जनरेटिव्ह कार्यांसाठी चांगले.
+
+आपण पुढील विभागांमध्ये या आर्किटेक्चर्सबद्दल स्वतंत्रपणे सविस्तर माहिती घेऊ.
+
+अटेन्शन लेयर्स (Attention layers)[[attention-layers]]
+ट्रान्सफॉर्मर मॉडेल्सचे एक प्रमुख वैशिष्ट्य म्हणजे ते अटेन्शन लेयर्स (attention layers) नावाच्या विशेष स्तरांनी बनलेले असतात. किंबहुना, ट्रान्सफॉर्मर आर्किटेक्चर सादर करणाऱ्या पेपरचे शीर्षकच "Attention Is All You Need" असे होते! आपण कोर्समध्ये नंतर अटेन्शन लेयर्सचे तपशील पाहू; सध्या तुम्हाला फक्त एवढेच माहित असणे आवश्यक आहे की हा लेयर मॉडेलला प्रत्येक शब्दाच्या प्रतिनिधित्वावर (representation) काम करताना, तुम्ही दिलेल्या वाक्यातील विशिष्ट शब्दांवर विशेष लक्ष देण्यास (आणि बाकीच्यांकडे कमी लक्ष देण्यास किंवा दुर्लक्ष करण्यास) सांगतो.
+
+हे संदर्भासह समजून घेण्यासाठी, इंग्रजीतून फ्रेंचमध्ये मजकूर भाषांतरित करण्याचे कार्य विचारात घ्या. "You like this course" हे इनपुट दिल्यास, ट्रान्सलेशन मॉडेलला "like" शब्दाचे योग्य भाषांतर करण्यासाठी त्याच्या लगतच्या "You" या शब्दाकडे देखील लक्ष (attend) द्यावे लागेल, कारण फ्रेंचमध्ये "like" हे क्रियापद कर्त्यानुसार (subject) वेगळ्या प्रकारे चालवले जाते. मात्र, वाक्याचा उरलेला भाग त्या शब्दाच्या भाषांतरासाठी उपयोगी नाही. त्याचप्रमाणे, "this" चे भाषांतर करताना मॉडेलला "course" या शब्दाकडे देखील लक्ष द्यावे लागेल, कारण "this" चे भाषांतर निगडीत नाम (noun) पुल्लिंगी आहे की स्त्रीलिंगी यावर अवलंबून बदलते. पुन्हा, वाक्यातील इतर शब्दांचा "course" च्या भाषांतरासाठी काहीही फरक पडणार नाही. अधिक गुंतागुंतीच्या वाक्यांसह (आणि अधिक गुंतागुंतीच्या व्याकरणाच्या नियमांसह), मॉडेलला प्रत्येक शब्दाचे योग्य भाषांतर करण्यासाठी वाक्यात दूरवर असलेल्या शब्दांवर विशेष लक्ष द्यावे लागेल.
+
+हीच संकल्पना नैसर्गिक भाषेशी (natural language) संबंधित कोणत्याही कार्याला लागू होते: शब्दाचा स्वतःचा एक अर्थ असतो, परंतु तो अर्थ संदर्भाने (context) खूप प्रभावित होतो, जो अभ्यासल्या जात असलेल्या शब्दाच्या आधीचा किंवा नंतरचा कोणताही अन्य शब्द (किंवा शब्द) असू शकतो.
+
+आता तुम्हाला अटेन्शन लेयर्स म्हणजे काय याची कल्पना आली आहे, तर आपण ट्रान्सफॉर्मर आर्किटेक्चर अधिक जवळून पाहूया.
+
+मूळ आर्किटेक्चर (The original architecture)[[the-original-architecture]]
+ट्रान्सफॉर्मर आर्किटेक्चर मूळतः भाषांतरासाठी डिझाइन केले गेले होते. प्रशिक्षणादरम्यान, एन्कोडरला एका विशिष्ट भाषेत इनपुट (वाक्ये) मिळतात, तर डिकोडरला तीच वाक्ये अपेक्षित लक्ष्य भाषेत (target language) मिळतात. एन्कोडरमध्ये, अटेन्शन लेयर्स वाक्यातील सर्व शब्द वापरू शकतात (कारण, आपण आत्ताच पाहिल्याप्रमाणे, एखाद्या शब्दाचे भाषांतर त्याच्या आधी तसेच नंतर काय आहे यावर अवलंबून असू शकते). मात्र, डिकोडर अनुक्रमे (sequentially) कार्य करतो आणि त्याने आधीच भाषांतरित केलेल्या वाक्यातील शब्दांवरच लक्ष देऊ शकतो (म्हणजेच, सध्या जनरेट होत असलेल्या शब्दाच्या आधीच्या शब्दांवरच). उदाहरणार्थ, जेव्हा आपण अनुवादित लक्ष्याचे पहिले तीन शब्द शोधतो (predict करतो), तेव्हा आपण ते डिकोडरला देतो जो नंतर चौथा शब्द शोधण्याचा प्रयत्न करण्यासाठी एन्कोडरचे सर्व इनपुट्स वापरतो.
+
+प्रशिक्षणादरम्यान वेगाने काम करण्यासाठी (जेव्हा मॉडेलला टार्गेट वाक्यांचा अ‍ॅक्सेस असतो), डिकोडरला संपूर्ण टार्गेट दिले जाते, परंतु त्याला भविष्यातील शब्द वापरण्याची परवानगी नसते (जर त्याला २ रा शब्द शोधताना २ ऱ्या स्थानावरील शब्दाचा अ‍ॅक्सेस मिळाला, तर ही समस्या फार अवघड राहणार नाही!). उदाहरणार्थ, चौथा शब्द शोधण्याचा प्रयत्न करताना, अटेन्शन लेयरला फक्त १ ते ३ स्थानांवरील शब्दांचाच अ‍ॅक्सेस असेल.
+
+मूळ ट्रान्सफॉर्मर आर्किटेक्चर डावीकडे एन्कोडर आणि उजवीकडे डिकोडरसह असे दिसत होते:
+
+लक्षात घ्या की डिकोडर ब्लॉकमधील पहिला अटेन्शन लेयर डिकोडरच्या सर्व (मागील) इनपुट्सकडे लक्ष देतो, परंतु दुसरा अटेन्शन लेयर एन्कोडरचे आउटपुट वापरतो. त्यामुळे तो सध्याचा शब्द उत्तम प्रकारे शोधण्यासाठी (predict करण्यासाठी) संपूर्ण इनपुट वाक्याचा अ‍ॅक्सेस मिळवू शकतो. हे खूप उपयुक्त आहे कारण वेगवेगळ्या भाषांमध्ये व्याकरणाचे नियम असू शकतात जे शब्दांना वेगवेगळ्या क्रमाने ठेवतात किंवा वाक्यात नंतर दिलेला काही संदर्भ एखाद्या शब्दाचे सर्वोत्तम भाषांतर ठरवण्यासाठी उपयुक्त ठरू शकतो.
+
+एन्कोडर/डिकोडरमध्ये मॉडेलला काही विशेष शब्दांकडे लक्ष देण्यापासून रोखण्यासाठी अटेन्शन मास्क (attention mask) देखील वापरला जाऊ शकतो -- उदाहरणार्थ, वाक्ये एकत्र बॅच (batch) करताना सर्व इनपुट्स समान लांबीचे करण्यासाठी वापरलेला विशेष पॅडिंग (padding) शब्द.
+
+आर्किटेक्चर्स वि. चेकपॉइंट्स (Architectures vs. checkpoints)[[architecture-vs-checkpoints]]
+जसजसे आपण या कोर्समध्ये ट्रान्सफॉर्मर मॉडेल्सबद्दल खोलवर जाणून घेऊ, तसतसे तुम्हाला आर्किटेक्चर्स (architectures) आणि चेकपॉइंट्स (checkpoints) तसेच मॉडेल्स चे संदर्भ दिसतील. या सर्व संज्ञांचे अर्थ थोडे वेगळे आहेत:
+
+आर्किटेक्चर (Architecture): हा मॉडेलचा सांगाडा (skeleton) आहे -- प्रत्येक लेयरची व्याख्या आणि मॉडेलमध्ये होणारी प्रत्येक क्रिया (operation).
+
+चेकपॉइंट्स (Checkpoints): हे असे वेट्स (weights) आहेत जे दिलेल्या आर्किटेक्चरमध्ये लोड केले जातील.
+
+मॉडेल (Model): ही एक सर्वसमावेशक (umbrella) संज्ञा आहे जी "आर्किटेक्चर" किंवा "चेकपॉइंट" इतकी अचूक नाही: याचा अर्थ दोन्ही असू शकतो. संदिग्धता कमी करण्यासाठी जेव्हा महत्त्वाचे असेल तेव्हा हा कोर्स आर्किटेक्चर किंवा चेकपॉइंट नमूद करेल.
+
+उदाहरणार्थ, BERT हे एक आर्किटेक्चर आहे तर bert-base-cased (जे BERT च्या पहिल्या रिलीझसाठी गुगल टीमने प्रशिक्षित केलेल्या वेट्सचा संच आहे) हा एक चेकपॉइंट आहे. तथापि, कोणीही "BERT मॉडेल" आणि "bert-base-cased मॉडेल" असे म्हणू शकतो.
\ No newline at end of file
diff --git a/chapters/mr/chapter 1/5.mdx b/chapters/mr/chapter 1/5.mdx
new file mode 100644
index 000000000..e69de29bb
diff --git a/chapters/mr/chapter 1/6.mdx b/chapters/mr/chapter 1/6.mdx
new file mode 100644
index 000000000..e69de29bb
diff --git a/chapters/mr/chapter 1/7.mdx b/chapters/mr/chapter 1/7.mdx
new file mode 100644
index 000000000..e69de29bb
diff --git a/chapters/mr/chapter 1/8.mdx b/chapters/mr/chapter 1/8.mdx
new file mode 100644
index 000000000..e69de29bb
diff --git a/chapters/mr/chapter 1/9.mdx b/chapters/mr/chapter 1/9.mdx
new file mode 100644
index 000000000..e69de29bb
diff --git a/chapters/mr/chapter 2/1.mdx b/chapters/mr/chapter 2/1.mdx
new file mode 100644
index 000000000..d28cd3766
--- /dev/null
+++ b/chapters/mr/chapter 2/1.mdx
@@ -0,0 +1,20 @@
+परिचय[[परिचय]]
+
+
+
+तुम्ही प्रकरण 1 मध्ये पाहिल्याप्रमाणे, ट्रान्सफॉर्मर मॉडेल्स सहसा खूप मोठे असतात. लाखो ते हजारो कोटी पॅरामीटर्ससह, या मॉडेल्सना प्रशिक्षण देणे आणि तैनात करणे ही एक गुंतागुंतीची प्रक्रिया आहे. शिवाय, जवळजवळ दररोज नवीन मॉडेल्स प्रकाशित होत असल्याने आणि प्रत्येकाची स्वतःची अंमलबजावणी असल्याने, ती सर्व वापरून पाहणे सोपे काम नाही.
+
+ही समस्या सोडवण्यासाठी 🤗 ट्रान्सफॉर्मर्स लायब्ररी तयार करण्यात आली. कोणतेही ट्रान्सफॉर्मर मॉडेल लोड करण्यासाठी, प्रशिक्षण देण्यासाठी आणि जतन करण्यासाठी एकच API प्रदान करणे हे तिचे उद्दिष्ट आहे. लायब्ररीची मुख्य वैशिष्ट्ये अशी आहेत:
+
+वापरण्यास सुलभता: निष्कर्षासाठी (inference) अत्याधुनिक NLP मॉडेल डाउनलोड करणे, लोड करणे आणि वापरणे फक्त दोन ओळींच्या कोडमध्ये करता येते.
+लवचिकता: त्यांच्या गाभ्यात, सर्व मॉडेल्स साधे PyTorch nn.Module वर्ग आहेत आणि त्यांच्या संबंधित मशीन लर्निंग (ML) फ्रेमवर्क्समधील इतर कोणत्याही मॉडेल्सप्रमाणे हाताळता येतात.
+साधेपणा: संपूर्ण लायब्ररीमध्ये फारसे अ‍ॅबस्ट्रॅक्शन्स केलेले नाहीत. "ऑल इन वन फाइल" ही एक मुख्य संकल्पना आहे: मॉडेलचा फॉरवर्ड पास संपूर्णपणे एकाच फाइलमध्ये परिभाषित केलेला असतो, त्यामुळे कोड स्वतःच समजण्याजोगा आणि हॅक करण्यायोग्य असतो.
+
+हे शेवटचे वैशिष्ट्य 🤗 ट्रान्सफॉर्मर्सला इतर ML लायब्ररींपेक्षा बरेच वेगळे बनवते. मॉडेल्स फाइल्समध्ये सामायिक केलेल्या मॉड्यूल्सवर तयार केलेले नाहीत; त्याऐवजी, प्रत्येक मॉडेलचे स्वतःचे स्तर (layers) असतात. मॉडेल्स अधिक सुगम आणि समजण्याजोगे बनवण्याबरोबरच, यामुळे तुम्हाला इतर मॉडेल्सवर परिणाम न करता एका मॉडेलवर सहजपणे प्रयोग करता येतो.
+
+हे प्रकरण एका एंड-टू-एंड उदाहरणाने सुरू होईल, ज्यामध्ये आपण प्रकरण 1 मध्ये सादर केलेल्या pipeline() फंक्शनची पुनरावृत्ती करण्यासाठी मॉडेल आणि टोकनायझर एकत्र वापरू. पुढे, आपण मॉडेल API बद्दल चर्चा करू: आपण मॉडेल आणि कॉन्फिगरेशन वर्गांमध्ये सखोलपणे जाऊ, आणि मॉडेल कसे लोड करावे आणि ते संख्यात्मक इनपुट्सना आउटपुट भाकितांमध्ये कसे प्रक्रिया करते हे तुम्हाला दाखवू.
+
+त्यानंतर आपण टोकनायझर API कडे पाहू, जो pipeline() फंक्शनचा दुसरा मुख्य घटक आहे. टोकनायझर्स पहिल्या आणि शेवटच्या प्रक्रिया पायऱ्या हाताळतात, मजकुरापासून न्यूरल नेटवर्कसाठी संख्यात्मक इनपुट्समध्ये रूपांतर करतात, आणि आवश्यक असेल तेव्हा पुन्हा मजकुरात रूपांतर करतात. शेवटी, तयार केलेल्या बॅचमध्ये अनेक वाक्ये मॉडेलमधून कशी पाठवायची हे आपण तुम्हाला दाखवू, आणि नंतर उच्च-स्तरीय tokenizer() फंक्शनवर सखोल नजर टाकून सर्व काही पूर्ण करू.
+
+[!TIP]
+⚠️ मॉडेल हब आणि 🤗 ट्रान्सफॉर्मर्ससोबत उपलब्ध असलेल्या सर्व वैशिष्ट्यांचा लाभ घेण्यासाठी, आम्ही खाते तयार करण्याची शिफारस करतो.
\ No newline at end of file
diff --git a/chapters/mr/chapter 2/2.mdx b/chapters/mr/chapter 2/2.mdx
new file mode 100644
index 000000000..1838d28e3
--- /dev/null
+++ b/chapters/mr/chapter 2/2.mdx
@@ -0,0 +1,232 @@
+
+
+# पाइपलाइनच्या मागे[[behind-the-pipeline]]
+
+
+
+
+
+चला एका संपूर्ण उदाहरणापासून सुरुवात करूया, जेव्हा आपण [प्रकरण 1](/course/chapter1) मध्ये खालील कोड कार्यान्वित केला तेव्हा पडद्यामागे नेमके काय घडले ते पाहूया:
+
+```python
+from transformers import pipeline
+
+classifier = pipeline("sentiment-analysis")
+classifier(
+ [
+ "I've been waiting for a HuggingFace course my whole life.",
+ "I hate this so much!",
+ ]
+)
+```
+
+आणि आपल्याला मिळाले:
+
+```python out
+[{'label': 'POSITIVE', 'score': 0.9598047137260437},
+ {'label': 'NEGATIVE', 'score': 0.9994558095932007}]
+```
+
+[प्रकरण 1](/course/chapter1) मध्ये आपण पाहिल्याप्रमाणे, ही पाइपलाइन तीन टप्पे एकत्र करते: प्रीप्रोसेसिंग, इनपुट्स मॉडेलमधून पाठवणे, आणि पोस्टप्रोसेसिंग:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Flash Attention हे एक तंत्र आहे जे मेमरी बँडविड्थ अडथळ्यांचे निराकरण करून ट्रान्सफॉर्मर मॉडेल्समधील अटेंशन यंत्रणा ऑप्टिमाइझ करते. आधी [प्रकरण 1.8](/course/chapter1/8) मध्ये चर्चा केल्याप्रमाणे, अटेंशन यंत्रणेची क्वाड्रॅटिक कॉम्प्लेक्सिटी आणि मेमरी वापर असतो, ज्यामुळे लांब सिक्वेन्सेससाठी ती अकार्यक्षम ठरते.
+
+मुख्य नावीन्य म्हणजे ते High Bandwidth Memory (HBM) आणि जलद SRAM कॅश दरम्यान मेमरी ट्रान्सफर्स कसे व्यवस्थापित करते यात आहे. पारंपरिक अटेंशन HBM आणि SRAM दरम्यान वारंवार डेटा ट्रान्सफर करते, ज्यामुळे GPU निष्क्रिय राहून अडथळे निर्माण होतात. Flash Attention डेटा एकदाच SRAM मध्ये लोड करते आणि सर्व गणना तिथेच करते, ज्यामुळे महागडे मेमरी ट्रान्सफर्स कमीत कमी होतात.
+
+प्रशिक्षणादरम्यान फायदे सर्वात लक्षणीय असले तरी, Flash Attention चा कमी झालेला VRAM वापर आणि सुधारित कार्यक्षमता इन्फरन्ससाठी देखील मौल्यवान ठरते, ज्यामुळे जलद आणि अधिक स्केलेबल LLM सर्व्हिंग शक्य होते.
+
+
+
+**vLLM** PagedAttention वापरून वेगळा दृष्टिकोन घेते. ज्याप्रमाणे संगणक त्याची मेमरी पेजेसमध्ये व्यवस्थापित करतो, त्याचप्रमाणे vLLM मॉडेलच्या मेमरीला लहान ब्लॉक्समध्ये विभागते. या हुशार प्रणालीमुळे ते वेगवेगळ्या आकाराच्या रिक्वेस्ट्सना अधिक लवचिकपणे हाताळू शकते आणि मेमरी स्पेस वाया घालवत नाही. वेगवेगळ्या रिक्वेस्ट्समध्ये मेमरी शेअर करण्यात हे विशेषतः चांगले आहे आणि मेमरी फ्रॅगमेंटेशन कमी करते, ज्यामुळे संपूर्ण प्रणाली अधिक कार्यक्षम बनते.
+
+
+
+PagedAttention हे एक तंत्र आहे जे LLM इन्फरन्समधील आणखी एका महत्त्वाच्या अडथळ्याचे निराकरण करते: KV कॅश मेमरी व्यवस्थापन. [प्रकरण 1.8](/course/chapter1/8) मध्ये चर्चा केल्याप्रमाणे, मजकूर निर्मितीदरम्यान, मॉडेल पुनरावृत्ती होणाऱ्या गणना कमी करण्यासाठी प्रत्येक तयार झालेल्या टोकनसाठी अटेंशन कीज आणि व्हॅल्यूज (KV कॅश) साठवते. विशेषतः लांब सिक्वेन्सेस किंवा अनेक समवर्ती रिक्वेस्ट्ससह KV कॅश प्रचंड मोठे होऊ शकते.
+
+vLLM चे मुख्य नावीन्य ते हा कॅश कसे व्यवस्थापित करते यात आहे:
+
+1. **मेमरी पेजिंग**: KV कॅशला एक मोठा ब्लॉक मानण्याऐवजी, त्याचे निश्चित आकाराच्या "पेजेस" मध्ये विभाजन केले जाते (ऑपरेटिंग सिस्टम्समधील व्हर्च्युअल मेमरीसारखे).
+2. **नॉन-कॉन्टिग्युअस स्टोरेज**: पेजेसना GPU मेमरीमध्ये सलग साठवण्याची गरज नसते, ज्यामुळे अधिक लवचिक मेमरी वाटप शक्य होते.
+3. **पेज टेबल व्यवस्थापन**: एक पेज टेबल कोणती पेजेस कोणत्या सिक्वेन्सशी संबंधित आहेत याचा मागोवा ठेवते, ज्यामुळे कार्यक्षम शोध आणि प्रवेश शक्य होतो.
+4. **मेमरी शेअरिंग**: पॅरलल सॅम्पलिंगसारख्या ऑपरेशन्ससाठी, प्रॉम्प्टचे KV कॅश साठवणारी पेजेस अनेक सिक्वेन्सेसमध्ये शेअर केली जाऊ शकतात.
+
+PagedAttention दृष्टिकोन पारंपरिक पद्धतींच्या तुलनेत 24 पट जास्त थ्रूपुटपर्यंत नेऊ शकतो, ज्यामुळे तो प्रोडक्शन LLM डिप्लॉयमेंट्ससाठी गेम-चेंजर ठरतो. PagedAttention कसे कार्य करते याबद्दल अधिक सखोलपणे जाणून घ्यायचे असल्यास, तुम्ही [vLLM डॉक्युमेंटेशनमधील मार्गदर्शक](https://docs.vllm.ai/en/latest/design/kernel/paged_attention.html) वाचू शकता.
+
+
+
+**llama.cpp** हे मूळतः कन्झ्युमर हार्डवेअरवर LLaMA मॉडेल्स चालवण्यासाठी डिझाइन केलेले अत्यंत ऑप्टिमाइझ केलेले C/C++ इम्प्लिमेंटेशन आहे. ते पर्यायी GPU प्रवेगासह CPU कार्यक्षमतेवर लक्ष केंद्रित करते आणि संसाधन-मर्यादित वातावरणांसाठी आदर्श आहे. llama.cpp चांगली कामगिरी राखत मॉडेलचा आकार आणि मेमरी आवश्यकता कमी करण्यासाठी क्वांटायझेशन तंत्रांचा वापर करते. ते वेगवेगळ्या CPU आर्किटेक्चर्ससाठी ऑप्टिमाइझ केलेले कर्नल्स इम्प्लिमेंट करते आणि कार्यक्षम टोकन जनरेशनसाठी मूलभूत KV कॅश व्यवस्थापन सपोर्ट करते.
+
+
+
+llama.cpp मधील क्वांटायझेशन मॉडेल वेट्सची अचूकता 32-बिट किंवा 16-बिट फ्लोटिंग पॉइंटवरून 8-बिट इंटिजर्स (INT8), 4-बिट, किंवा त्याहूनही कमी अचूकतेच्या फॉरमॅट्सपर्यंत कमी करते. यामुळे किमान गुणवत्ता हानीसह मेमरी वापर लक्षणीयरीत्या कमी होतो आणि इन्फरन्स गती सुधारते.
+
+llama.cpp मधील मुख्य क्वांटायझेशन वैशिष्ट्यांमध्ये समाविष्ट आहे:
+1. **अनेक क्वांटायझेशन लेव्हल्स**: 8-बिट, 4-बिट, 3-बिट, आणि अगदी 2-बिट क्वांटायझेशन सपोर्ट करते
+2. **GGML/GGUF फॉरमॅट**: क्वांटाइज्ड इन्फरन्ससाठी ऑप्टिमाइझ केलेले कस्टम टेन्सर फॉरमॅट्स वापरते
+3. **मिश्र अचूकता**: मॉडेलच्या वेगवेगळ्या भागांना वेगवेगळे क्वांटायझेशन लेव्हल्स लागू करू शकते
+4. **हार्डवेअर-विशिष्ट ऑप्टिमायझेशन्स**: वेगवेगळ्या CPU आर्किटेक्चर्ससाठी (AVX2, AVX-512, NEON) ऑप्टिमाइझ केलेले कोड पाथ्स समाविष्ट करते
+
+हा दृष्टिकोन मर्यादित मेमरी असलेल्या कन्झ्युमर हार्डवेअरवर अब्जावधी-पॅरामीटर मॉडेल्स चालवणे शक्य करतो, ज्यामुळे तो स्थानिक डिप्लॉयमेंट्स आणि एज डिव्हाइसेससाठी परिपूर्ण ठरतो.
+
+
+
+### डिप्लॉयमेंट आणि इंटिग्रेशन
+
+चला फ्रेमवर्क्समधील डिप्लॉयमेंट आणि इंटिग्रेशन फरकांकडे वळूया.
+
+**TGI** त्याच्या प्रोडक्शन-रेडी वैशिष्ट्यांसह एंटरप्राइझ-स्तरीय डिप्लॉयमेंटमध्ये उत्कृष्ट आहे. ते Kubernetes साठी अंगभूत सपोर्टसह येते आणि प्रोडक्शनमध्ये चालवण्यासाठी आवश्यक असलेले सर्वकाही समाविष्ट करते, जसे की Prometheus आणि Grafana द्वारे मॉनिटरिंग, स्वयंचलित स्केलिंग, आणि सर्वसमावेशक सुरक्षा वैशिष्ट्ये. प्रणालीमध्ये एंटरप्राइझ-दर्जाचे लॉगिंग आणि तुमचे डिप्लॉयमेंट सुरक्षित आणि स्थिर ठेवण्यासाठी कंटेंट फिल्टरिंग आणि रेट लिमिटिंग सारखे विविध संरक्षणात्मक उपाय देखील समाविष्ट आहेत.
+
+**vLLM** डिप्लॉयमेंटसाठी अधिक लवचिक, डेव्हलपर-अनुकूल दृष्टिकोन घेते. ते Python च्या गाभ्यासह तयार केले गेले आहे आणि तुमच्या विद्यमान अ‍ॅप्लिकेशन्समध्ये OpenAI च्या API ला सहजपणे बदलू शकते. फ्रेमवर्क कच्च्या कामगिरीवर लक्ष केंद्रित करते आणि तुमच्या विशिष्ट गरजांनुसार कस्टमाइझ केले जाऊ शकते. क्लस्टर व्यवस्थापित करण्यासाठी हे Ray सोबत विशेषतः चांगले काम करते, ज्यामुळे तुम्हाला उच्च कामगिरी आणि अनुकूलतेची गरज असताना हा एक उत्तम पर्याय ठरतो.
+
+**llama.cpp** साधेपणा आणि पोर्टेबिलिटीला प्राधान्य देते. त्याची सर्व्हर इम्प्लिमेंटेशन हलकी आहे आणि शक्तिशाली सर्व्हर्सपासून ते कन्झ्युमर लॅपटॉप्स आणि काही उच्च-दर्जाच्या मोबाइल डिव्हाइसेसपर्यंत विविध हार्डवेअरवर चालू शकते. किमान अवलंबित्व आणि साधा C/C++ कोर असल्यामुळे, Python फ्रेमवर्क्स इन्स्टॉल करणे आव्हानात्मक असलेल्या वातावरणांमध्ये देखील ते सहजपणे डिप्लॉय करता येते. सर्व्हर इतर सोल्युशन्सपेक्षा खूपच लहान रिसोर्स फूटप्रिंट राखत OpenAI-सुसंगत API पुरवते.
+
+## सुरुवात करणे
+
+चला LLMs डिप्लॉय करण्यासाठी हे फ्रेमवर्क्स कसे वापरायचे ते पाहूया, इन्स्टॉलेशन आणि मूलभूत सेटअपपासून सुरुवात करून.
+
+### इन्स्टॉलेशन आणि मूलभूत सेटअप
+
+
+
+
+
+TGI इन्स्टॉल करणे आणि वापरणे सोपे आहे, Hugging Face इकोसिस्टमसह सखोल इंटिग्रेशनसह.
+
+प्रथम, Docker वापरून TGI सर्व्हर लाँच करा:
+
+```sh
+docker run --gpus all \
+ --shm-size 1g \
+ -p 8080:80 \
+ -v ~/.cache/huggingface:/data \
+ ghcr.io/huggingface/text-generation-inference:latest \
+ --model-id HuggingFaceTB/SmolLM2-360M-Instruct
+```
+
+नंतर Hugging Face च्या InferenceClient चा वापर करून त्याच्याशी संवाद साधा:
+
+```python
+from huggingface_hub import InferenceClient
+
+# Initialize client pointing to TGI endpoint
+client = InferenceClient(
+ model="http://localhost:8080", # URL to the TGI server
+)
+
+# Text generation
+response = client.text_generation(
+ "Tell me a story",
+ max_new_tokens=100,
+ temperature=0.7,
+ top_p=0.95,
+ details=True,
+ stop_sequences=[],
+)
+print(response.generated_text)
+
+# For chat format
+response = client.chat_completion(
+ messages=[
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Tell me a story"},
+ ],
+ max_tokens=100,
+ temperature=0.7,
+ top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+पर्यायाने, तुम्ही OpenAI क्लायंट वापरू शकता:
+
+```python
+from openai import OpenAI
+
+# Initialize client pointing to TGI endpoint
+client = OpenAI(
+ base_url="http://localhost:8080/v1", # Make sure to include /v1
+ api_key="not-needed", # TGI doesn't require an API key by default
+)
+
+# Chat completion
+response = client.chat.completions.create(
+ model="HuggingFaceTB/SmolLM2-360M-Instruct",
+ messages=[
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Tell me a story"},
+ ],
+ max_tokens=100,
+ temperature=0.7,
+ top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+
+
+
+
+llama.cpp इन्स्टॉल करणे आणि वापरणे सोपे आहे, किमान अवलंबित्वाची आवश्यकता असते आणि CPU व GPU दोन्ही इन्फरन्स सपोर्ट करते.
+
+प्रथम, llama.cpp इन्स्टॉल आणि बिल्ड करा:
+
+```sh
+# Clone the repository
+git clone https://github.com/ggerganov/llama.cpp
+cd llama.cpp
+
+# Build the project
+make
+
+# Download the SmolLM2-1.7B-Instruct-GGUF model
+curl -L -O https://huggingface.co/HuggingFaceTB/SmolLM2-1.7B-Instruct-GGUF/resolve/main/smollm2-1.7b-instruct.Q4_K_M.gguf
+```
+
+नंतर, सर्व्हर लाँच करा (OpenAI API सुसंगततेसह):
+
+```sh
+# Start the server
+./server \
+ -m smollm2-1.7b-instruct.Q4_K_M.gguf \
+ --host 0.0.0.0 \
+ --port 8080 \
+ -c 4096 \
+ --n-gpu-layers 0 # Set to a higher number to use GPU
+```
+
+Hugging Face च्या InferenceClient चा वापर करून सर्व्हरशी संवाद साधा:
+
+```python
+from huggingface_hub import InferenceClient
+
+# Initialize client pointing to llama.cpp server
+client = InferenceClient(
+ model="http://localhost:8080/v1", # URL to the llama.cpp server
+ token="sk-no-key-required", # llama.cpp server requires this placeholder
+)
+
+# Text generation
+response = client.text_generation(
+ "Tell me a story",
+ max_new_tokens=100,
+ temperature=0.7,
+ top_p=0.95,
+ details=True,
+)
+print(response.generated_text)
+
+# For chat format
+response = client.chat_completion(
+ messages=[
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Tell me a story"},
+ ],
+ max_tokens=100,
+ temperature=0.7,
+ top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+पर्यायाने, तुम्ही OpenAI क्लायंट वापरू शकता:
+
+```python
+from openai import OpenAI
+
+# Initialize client pointing to llama.cpp server
+client = OpenAI(
+ base_url="http://localhost:8080/v1",
+ api_key="sk-no-key-required", # llama.cpp server requires this placeholder
+)
+
+# Chat completion
+response = client.chat.completions.create(
+ model="smollm2-1.7b-instruct", # Model identifier can be anything as server only loads one model
+ messages=[
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Tell me a story"},
+ ],
+ max_tokens=100,
+ temperature=0.7,
+ top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+
+
+
+
+vLLM इन्स्टॉल करणे आणि वापरणे सोपे आहे, OpenAI API सुसंगतता आणि नेटिव्ह Python इंटरफेस दोन्हीसह.
+
+प्रथम, vLLM OpenAI-सुसंगत सर्व्हर लाँच करा:
+
+```sh
+python -m vllm.entrypoints.openai.api_server \
+ --model HuggingFaceTB/SmolLM2-360M-Instruct \
+ --host 0.0.0.0 \
+ --port 8000
+```
+
+नंतर Hugging Face च्या InferenceClient चा वापर करून त्याच्याशी संवाद साधा:
+
+```python
+from huggingface_hub import InferenceClient
+
+# Initialize client pointing to vLLM endpoint
+client = InferenceClient(
+ model="http://localhost:8000/v1", # URL to the vLLM server
+)
+
+# Text generation
+response = client.text_generation(
+ "Tell me a story",
+ max_new_tokens=100,
+ temperature=0.7,
+ top_p=0.95,
+ details=True,
+)
+print(response.generated_text)
+
+# For chat format
+response = client.chat_completion(
+ messages=[
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Tell me a story"},
+ ],
+ max_tokens=100,
+ temperature=0.7,
+ top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+पर्यायाने, तुम्ही OpenAI क्लायंट वापरू शकता:
+
+```python
+from openai import OpenAI
+
+# Initialize client pointing to vLLM endpoint
+client = OpenAI(
+ base_url="http://localhost:8000/v1",
+ api_key="not-needed", # vLLM doesn't require an API key by default
+)
+
+# Chat completion
+response = client.chat.completions.create(
+ model="HuggingFaceTB/SmolLM2-360M-Instruct",
+ messages=[
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Tell me a story"},
+ ],
+ max_tokens=100,
+ temperature=0.7,
+ top_p=0.95,
+)
+print(response.choices[0].message.content)
+```
+
+
+
+
+
+### मूलभूत मजकूर निर्मिती
+
+चला फ्रेमवर्क्ससह मजकूर निर्मितीची उदाहरणे पाहूया:
+
+
+
+
+
+प्रथम, प्रगत पॅरामीटर्ससह TGI डिप्लॉय करा:
+```sh
+docker run --gpus all \
+ --shm-size 1g \
+ -p 8080:80 \
+ -v ~/.cache/huggingface:/data \
+ ghcr.io/huggingface/text-generation-inference:latest \
+ --model-id HuggingFaceTB/SmolLM2-360M-Instruct \
+ --max-total-tokens 4096 \
+ --max-input-length 3072 \
+ --max-batch-total-tokens 8192 \
+ --waiting-served-ratio 1.2
+```
+
+लवचिक मजकूर निर्मितीसाठी InferenceClient वापरा:
+
+```python
+from huggingface_hub import InferenceClient
+
+client = InferenceClient(model="http://localhost:8080")
+
+# Advanced parameters example
+response = client.chat_completion(
+ messages=[
+ {"role": "system", "content": "You are a creative storyteller."},
+ {"role": "user", "content": "Write a creative story"},
+ ],
+ temperature=0.8,
+ max_tokens=200,
+ top_p=0.95,
+)
+print(response.choices[0].message.content)
+
+# Raw text generation
+response = client.text_generation(
+ "Write a creative story about space exploration",
+ max_new_tokens=200,
+ temperature=0.8,
+ top_p=0.95,
+ repetition_penalty=1.1,
+ do_sample=True,
+ details=True,
+)
+print(response.generated_text)
+```
+
+किंवा OpenAI क्लायंट वापरा:
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed")
+
+# Advanced parameters example
+response = client.chat.completions.create(
+ model="HuggingFaceTB/SmolLM2-360M-Instruct",
+ messages=[
+ {"role": "system", "content": "You are a creative storyteller."},
+ {"role": "user", "content": "Write a creative story"},
+ ],
+ temperature=0.8, # Higher for more creativity
+)
+print(response.choices[0].message.content)
+```
+
+
+
+
+
+llama.cpp साठी, तुम्ही सर्व्हर लाँच करताना प्रगत पॅरामीटर्स सेट करू शकता:
+
+```sh
+./server \
+ -m smollm2-1.7b-instruct.Q4_K_M.gguf \
+ --host 0.0.0.0 \
+ --port 8080 \
+ -c 4096 \ # Context size
+ --threads 8 \ # CPU threads to use
+ --batch-size 512 \ # Batch size for prompt evaluation
+ --n-gpu-layers 0 # GPU layers (0 = CPU only)
+```
+
+InferenceClient वापरा:
+
+```python
+from huggingface_hub import InferenceClient
+
+client = InferenceClient(model="http://localhost:8080/v1", token="sk-no-key-required")
+
+# Advanced parameters example
+response = client.chat_completion(
+ messages=[
+ {"role": "system", "content": "You are a creative storyteller."},
+ {"role": "user", "content": "Write a creative story"},
+ ],
+ temperature=0.8,
+ max_tokens=200,
+ top_p=0.95,
+)
+print(response.choices[0].message.content)
+
+# For direct text generation
+response = client.text_generation(
+ "Write a creative story about space exploration",
+ max_new_tokens=200,
+ temperature=0.8,
+ top_p=0.95,
+ repetition_penalty=1.1,
+ details=True,
+)
+print(response.generated_text)
+```
+
+किंवा सॅम्पलिंग पॅरामीटर्सवर नियंत्रणासह जनरेशनसाठी OpenAI क्लायंट वापरा:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:8080/v1", api_key="sk-no-key-required")
+
+# Advanced parameters example
+response = client.chat.completions.create(
+ model="smollm2-1.7b-instruct",
+ messages=[
+ {"role": "system", "content": "You are a creative storyteller."},
+ {"role": "user", "content": "Write a creative story"},
+ ],
+ temperature=0.8, # Higher for more creativity
+ top_p=0.95, # Nucleus sampling probability
+ frequency_penalty=0.5, # Reduce repetition of frequent tokens
+ presence_penalty=0.5, # Reduce repetition by penalizing tokens already present
+ max_tokens=200, # Maximum generation length
+)
+print(response.choices[0].message.content)
+```
+
+तुम्ही आणखी अधिक नियंत्रणासाठी llama.cpp ची नेटिव्ह लायब्ररी देखील वापरू शकता:
+
+```python
+# Using llama-cpp-python package for direct model access
+from llama_cpp import Llama
+
+# Load the model
+llm = Llama(
+ model_path="smollm2-1.7b-instruct.Q4_K_M.gguf",
+ n_ctx=4096, # Context window size
+ n_threads=8, # CPU threads
+ n_gpu_layers=0, # GPU layers (0 = CPU only)
+)
+
+# Format prompt according to the model's expected format
+prompt = """<|im_start|>system
+You are a creative storyteller.
+<|im_end|>
+<|im_start|>user
+Write a creative story
+<|im_end|>
+<|im_start|>assistant
+"""
+
+# Generate response with precise parameter control
+output = llm(
+ prompt,
+ max_tokens=200,
+ temperature=0.8,
+ top_p=0.95,
+ frequency_penalty=0.5,
+ presence_penalty=0.5,
+ stop=["<|im_end|>"],
+)
+
+print(output["choices"][0]["text"])
+```
+
+
+
+
+
+vLLM सह प्रगत वापरासाठी, तुम्ही InferenceClient वापरू शकता:
+
+```python
+from huggingface_hub import InferenceClient
+
+client = InferenceClient(model="http://localhost:8000/v1")
+
+# Advanced parameters example
+response = client.chat_completion(
+ messages=[
+ {"role": "system", "content": "You are a creative storyteller."},
+ {"role": "user", "content": "Write a creative story"},
+ ],
+ temperature=0.8,
+ max_tokens=200,
+ top_p=0.95,
+)
+print(response.choices[0].message.content)
+
+# For direct text generation
+response = client.text_generation(
+ "Write a creative story about space exploration",
+ max_new_tokens=200,
+ temperature=0.8,
+ top_p=0.95,
+ details=True,
+)
+print(response.generated_text)
+```
+
+तुम्ही OpenAI क्लायंट देखील वापरू शकता:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")
+
+# Advanced parameters example
+response = client.chat.completions.create(
+ model="HuggingFaceTB/SmolLM2-360M-Instruct",
+ messages=[
+ {"role": "system", "content": "You are a creative storyteller."},
+ {"role": "user", "content": "Write a creative story"},
+ ],
+ temperature=0.8,
+ top_p=0.95,
+ max_tokens=200,
+)
+print(response.choices[0].message.content)
+```
+
+vLLM बारकाईने नियंत्रणासह एक नेटिव्ह Python इंटरफेस देखील पुरवते:
+
+```python
+from vllm import LLM, SamplingParams
+
+# Initialize the model with advanced parameters
+llm = LLM(
+ model="HuggingFaceTB/SmolLM2-360M-Instruct",
+ gpu_memory_utilization=0.85,
+ max_num_batched_tokens=8192,
+ max_num_seqs=256,
+ block_size=16,
+)
+
+# Configure sampling parameters
+sampling_params = SamplingParams(
+ temperature=0.8, # Higher for more creativity
+ top_p=0.95, # Consider top 95% probability mass
+ max_tokens=100, # Maximum length
+ presence_penalty=1.1, # Reduce repetition
+ frequency_penalty=1.1, # Reduce repetition
+ stop=["\n\n", "###"], # Stop sequences
+)
+
+# Generate text
+prompt = "Write a creative story"
+outputs = llm.generate(prompt, sampling_params)
+print(outputs[0].outputs[0].text)
+
+# For chat-style interactions
+chat_prompt = [
+ {"role": "system", "content": "You are a creative storyteller."},
+ {"role": "user", "content": "Write a creative story"},
+]
+formatted_prompt = llm.get_chat_template()(chat_prompt) # Uses model's chat template
+outputs = llm.generate(formatted_prompt, sampling_params)
+print(outputs[0].outputs[0].text)
+```
+
+
+
+
+
+## प्रगत जनरेशन नियंत्रण
+
+### टोकन निवड आणि सॅम्पलिंग
+
+मजकूर निर्मितीच्या प्रक्रियेत प्रत्येक टप्प्यावर पुढील टोकन निवडणे समाविष्ट असते. या निवड प्रक्रियेला विविध पॅरामीटर्सद्वारे नियंत्रित केले जाऊ शकते:
+
+1. **कच्चे लॉजिट्स (Raw Logits)**: प्रत्येक टोकनसाठी प्रारंभिक आउटपुट संभाव्यता
+2. **तापमान (Temperature)**: निवडीतील यादृच्छिकता नियंत्रित करते (जास्त = अधिक सर्जनशील)
+3. **टॉप-p (Nucleus) सॅम्पलिंग**: संभाव्यतेच्या X% भाग बनवणाऱ्या टॉप टोकन्सपर्यंत फिल्टर करते
+4. **टॉप-k फिल्टरिंग**: निवड सर्वात संभाव्य k टोकन्सपुरती मर्यादित करते
+
+हे पॅरामीटर्स कसे कॉन्फिगर करायचे ते इथे आहे:
+
+
+
+
+
+```python
+client.generate(
+ "Write a creative story",
+ temperature=0.8, # Higher for more creativity
+ top_p=0.95, # Consider top 95% probability mass
+ top_k=50, # Consider top 50 tokens
+ max_new_tokens=100, # Maximum length
+ repetition_penalty=1.1, # Reduce repetition
+)
+```
+
+
+
+
+
+```python
+# Via OpenAI API compatibility
+response = client.completions.create(
+ model="smollm2-1.7b-instruct", # Model name (can be any string for llama.cpp server)
+ prompt="Write a creative story",
+ temperature=0.8, # Higher for more creativity
+ top_p=0.95, # Consider top 95% probability mass
+ frequency_penalty=1.1, # Reduce repetition
+ presence_penalty=0.1, # Reduce repetition
+ max_tokens=100, # Maximum length
+)
+
+# Via llama-cpp-python direct access
+output = llm(
+ "Write a creative story",
+ temperature=0.8,
+ top_p=0.95,
+ top_k=50,
+ max_tokens=100,
+ repeat_penalty=1.1,
+)
+```
+
+
+
+
+
+```python
+params = SamplingParams(
+ temperature=0.8, # Higher for more creativity
+ top_p=0.95, # Consider top 95% probability mass
+ top_k=50, # Consider top 50 tokens
+ max_tokens=100, # Maximum length
+ presence_penalty=0.1, # Reduce repetition
+)
+llm.generate("Write a creative story", sampling_params=params)
+```
+
+
+
+
+
+### पुनरावृत्ती नियंत्रित करणे
+
+दोन्ही फ्रेमवर्क्स पुनरावृत्ती होणारी मजकूर निर्मिती रोखण्याचे मार्ग पुरवतात:
+
+
+
+
+
+```python
+client.generate(
+ "Write a varied text",
+ repetition_penalty=1.1, # Penalize repeated tokens
+ no_repeat_ngram_size=3, # Prevent 3-gram repetition
+)
+```
+
+
+
+
+
+```python
+# Via OpenAI API
+response = client.completions.create(
+ model="smollm2-1.7b-instruct",
+ prompt="Write a varied text",
+ frequency_penalty=1.1, # Penalize frequent tokens
+ presence_penalty=0.8, # Penalize tokens already present
+)
+
+# Via direct library
+output = llm(
+ "Write a varied text",
+ repeat_penalty=1.1, # Penalize repeated tokens
+ frequency_penalty=0.5, # Additional frequency penalty
+ presence_penalty=0.5, # Additional presence penalty
+)
+```
+
+
+
+
+
+```python
+params = SamplingParams(
+ presence_penalty=0.1, # Penalize token presence
+ frequency_penalty=0.1, # Penalize token frequency
+)
+```
+
+
+
+
+
+### लांबी नियंत्रण आणि स्टॉप सिक्वेन्सेस
+
+तुम्ही जनरेशनची लांबी नियंत्रित करू शकता आणि ते केव्हा थांबवायचे हे निर्दिष्ट करू शकता:
+
+
+
+
+
+```python
+client.generate(
+ "Generate a short paragraph",
+ max_new_tokens=100,
+ min_new_tokens=10,
+ stop_sequences=["\n\n", "###"],
+)
+```
+
+
+
+
+
+```python
+# Via OpenAI API
+response = client.completions.create(
+ model="smollm2-1.7b-instruct",
+ prompt="Generate a short paragraph",
+ max_tokens=100,
+ stop=["\n\n", "###"],
+)
+
+# Via direct library
+output = llm("Generate a short paragraph", max_tokens=100, stop=["\n\n", "###"])
+```
+
+
+
+
+
+```python
+params = SamplingParams(
+ max_tokens=100,
+ min_tokens=10,
+ stop=["###", "\n\n"],
+ ignore_eos=False,
+ skip_special_tokens=True,
+)
+```
+
+
+
+
+
+## मेमरी व्यवस्थापन
+
+कार्यक्षम इन्फरन्ससाठी दोन्ही फ्रेमवर्क्स प्रगत मेमरी व्यवस्थापन तंत्रे इम्प्लिमेंट करतात.
+
+
+
+
+
+TGI Flash Attention 2 आणि सतत बॅचिंग वापरते:
+
+```sh
+# Docker deployment with memory optimization
+docker run --gpus all -p 8080:80 \
+ --shm-size 1g \
+ ghcr.io/huggingface/text-generation-inference:latest \
+ --model-id HuggingFaceTB/SmolLM2-1.7B-Instruct \
+ --max-batch-total-tokens 8192 \
+ --max-input-length 4096
+```
+
+
+
+
+
+llama.cpp क्वांटायझेशन आणि ऑप्टिमाइझ केलेला मेमरी लेआउट वापरते:
+
+```sh
+# Server with memory optimizations
+./server \
+ -m smollm2-1.7b-instruct.Q4_K_M.gguf \
+ --host 0.0.0.0 \
+ --port 8080 \
+ -c 2048 \ # Context size
+ --threads 4 \ # CPU threads
+ --n-gpu-layers 32 \ # Use more GPU layers for larger models
+ --mlock \ # Lock memory to prevent swapping
+ --cont-batching # Enable continuous batching
+```
+
+तुमच्या GPU साठी खूप मोठ्या असलेल्या मॉडेल्ससाठी, तुम्ही CPU ऑफलोडिंग वापरू शकता:
+
+```sh
+./server \
+ -m smollm2-1.7b-instruct.Q4_K_M.gguf \
+ --n-gpu-layers 20 \ # Keep first 20 layers on GPU
+ --threads 8 # Use more CPU threads for CPU layers
+```
+
+
+
+
+
+vLLM उत्कृष्ट मेमरी व्यवस्थापनासाठी PagedAttention वापरते:
+
+```python
+from vllm.engine.arg_utils import AsyncEngineArgs
+
+engine_args = AsyncEngineArgs(
+ model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+ gpu_memory_utilization=0.85,
+ max_num_batched_tokens=8192,
+ block_size=16,
+)
+
+llm = LLM(engine_args=engine_args)
+```
+
+
+
+
+
+## संसाधने
+
+- [Text Generation Inference डॉक्युमेंटेशन](https://huggingface.co/docs/text-generation-inference)
+- [TGI GitHub रिपॉझिटरी](https://github.com/huggingface/text-generation-inference)
+- [vLLM डॉक्युमेंटेशन](https://vllm.readthedocs.io/)
+- [vLLM GitHub रिपॉझिटरी](https://github.com/vllm-project/vllm)
+- [PagedAttention पेपर](https://arxiv.org/abs/2309.06180)
+- [llama.cpp GitHub रिपॉझिटरी](https://github.com/ggerganov/llama.cpp)
+- [llama-cpp-python रिपॉझिटरी](https://github.com/abetlen/llama-cpp-python)
\ No newline at end of file
diff --git a/chapters/mr/chapter 2/9.mdx b/chapters/mr/chapter 2/9.mdx
new file mode 100644
index 000000000..00084a24e
--- /dev/null
+++ b/chapters/mr/chapter 2/9.mdx
@@ -0,0 +1,252 @@
+
+
+
+
+# प्रकरणाच्या शेवटी क्विझ[[end-of-chapter-quiz]]
+
+
+
+### 1. लँग्वेज मॉडेलिंग पाइपलाइनचा क्रम काय आहे?
+
+
+
+### 2. बेस ट्रान्सफॉर्मर मॉडेलद्वारे आउटपुट केलेल्या टेन्सरला किती डायमेंशन्स असतात, आणि ते कोणते आहेत?
+
+
+
+### 3. खालीलपैकी कोणते सबवर्ड टोकनायझेशनचे उदाहरण आहे?
+
+
+
+### 4. मॉडेल हेड म्हणजे काय?
+
+
+
+### 5. AutoModel म्हणजे काय?
+
+AutoTrain प्रॉडक्टशी गोंधळत आहात का?"
+ },
+ {
+ text: "एक ऑब्जेक्ट जो चेकपॉइंटच्या आधारे योग्य आर्किटेक्चर परत करतो",
+ explain: "बरोबर: AutoModel ला योग्य आर्किटेक्चर परत करण्यासाठी फक्त कोणत्या चेकपॉइंटवरून इन्स्टंशिएट करायचे हे माहीत असणे आवश्यक आहे.",
+ correct: true
+ },
+ {
+ text: "असे मॉडेल जे योग्य वेट्स लोड करण्यासाठी त्याच्या इनपुट्ससाठी वापरलेली भाषा स्वयंचलितपणे शोधते",
+ explain: "काही चेकपॉइंट्स आणि मॉडेल्स अनेक भाषा हाताळण्यास सक्षम असले तरी, भाषेनुसार स्वयंचलित चेकपॉइंट निवडीसाठी कोणतीही अंगभूत टूल्स नाहीत. तुमच्या कामासाठी सर्वोत्तम चेकपॉइंट शोधण्यासाठी तुम्ही Model Hub कडे जावे!"
+ }
+ ]}
+/>
+
+### 6. वेगवेगळ्या लांबीच्या सिक्वेन्सेसना एकत्र बॅच करताना कोणत्या तंत्रांबद्दल जागरूक असणे आवश्यक आहे?
+
+
+
+### 7. सिक्वेन्स क्लासिफिकेशन मॉडेलद्वारे आउटपुट केलेल्या लॉजिट्सवर SoftMax फंक्शन लागू करण्याचा उद्देश काय आहे?
+
+
+
+### 8. बहुतांश टोकनायझर API कोणत्या पद्धतीभोवती केंद्रित आहे?
+
+encode, कारण ती मजकुराला IDs मध्ये आणि IDs ला भाकितांमध्ये एन्कोड करू शकते",
+ explain: "चूक! टोकनायझर्सवर encode पद्धत अस्तित्वात असली तरी, ती मॉडेल्सवर अस्तित्वात नाही."
+ },
+ {
+ text: "टोकनायझर ऑब्जेक्टला थेट कॉल करणे.",
+ explain: "अगदी बरोबर! टोकनायझरची __call__ पद्धत एक अत्यंत शक्तिशाली पद्धत आहे जी जवळजवळ कोणतीही गोष्ट हाताळू शकते. मॉडेलकडून भाकिते मिळवण्यासाठी वापरली जाणारी हीच पद्धत आहे.",
+ correct: true
+ },
+ {
+ text: "pad",
+ explain: "चूक! पॅडिंग खूप उपयुक्त आहे, पण तो टोकनायझर API चा फक्त एकच भाग आहे."
+ },
+ {
+ text: "tokenize",
+ explain: "tokenize पद्धत ही निश्चितपणे सर्वात उपयुक्त पद्धतींपैकी एक आहे, पण ती टोकनायझर API चा गाभा नाही."
+ }
+ ]}
+/>
+
+### 9. या कोड नमुन्यात `result` व्हेरिएबलमध्ये काय समाविष्ट आहे?
+
+```py
+from transformers import AutoTokenizer
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+result = tokenizer.tokenize("Hello!")
+```
+
+__call__ किंवा convert_tokens_to_ids पद्धत आहे!"
+ },
+ {
+ text: "सर्व टोकन्स असलेली एक स्ट्रिंग",
+ explain: "हे सर्वोत्तम नसेल, कारण उद्दिष्ट स्ट्रिंगचे अनेक टोकन्समध्ये विभाजन करणे हे आहे."
+ }
+ ]}
+/>
+
+### 10. खालील कोडमध्ये काही चुकीचे आहे का?
+
+```py
+from transformers import AutoTokenizer, AutoModel
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+model = AutoModel.from_pretrained("gpt2")
+
+encoded = tokenizer("Hey!", return_tensors="pt")
+result = model(**encoded)
+```
+
+
\ No newline at end of file