# Course

## Docs

- [फाइन-ट्यूनिंग, चेक!](https://huggingface.co/learn/course/hi/chapter3/5.md)
- [परिचय](https://huggingface.co/learn/course/hi/chapter3/1.md)
- [मॉडल कि Trainer API के साथ](https://huggingface.co/learn/course/hi/chapter3/3.md)
- [अध्याय-का-अंत प्रश्नोत्तरी](https://huggingface.co/learn/course/hi/chapter3/6.md)
- [मॉडल कि फाइन-ट्यूनिंग Keras के साथ](https://huggingface.co/learn/course/hi/chapter3/3_tf.md)
- [एक पूर्ण प्रशिक्षण](https://huggingface.co/learn/course/hi/chapter3/4.md)
- [डेटा संसाधित करना](https://huggingface.co/learn/course/hi/chapter3/2.md)
- [परिचय](https://huggingface.co/learn/course/hi/chapter2/1.md)
- [परिचय](https://huggingface.co/learn/course/hi/chapter0/1.md)
- [सारांश](https://huggingface.co/learn/course/hi/chapter1/9.md)
- [एनकोडर मॉडल](https://huggingface.co/learn/course/hi/chapter1/5.md)
- [परिचय](https://huggingface.co/learn/course/hi/chapter1/1.md)
- [ट्रांसफार्मर, वे क्या कर सकते हैं?](https://huggingface.co/learn/course/hi/chapter1/3.md)
- [डिकोडर मॉडल](https://huggingface.co/learn/course/hi/chapter1/6.md)
- [अध्याय के अंत की प्रश्नोत्तरी](https://huggingface.co/learn/course/hi/chapter1/10.md)
- [पूर्वाग्रह और सीमाएं](https://huggingface.co/learn/course/hi/chapter1/8.md)
- [ट्रांसफॉर्मर कैसे काम करते हैं?](https://huggingface.co/learn/course/hi/chapter1/4.md)
- [अनुक्रम-से-अनुक्रम मॉडल](https://huggingface.co/learn/course/hi/chapter1/7.md)
- [प्राकृतिक भाषा प्रसंस्करण](https://huggingface.co/learn/course/hi/chapter1/2.md)

### फाइन-ट्यूनिंग, चेक!
https://huggingface.co/learn/course/hi/chapter3/5.md

# फाइन-ट्यूनिंग, चेक!

<CourseFloatingBanner
    chapter={3}
    classNames="absolute z-10 right-0 top-0"
/>

काफी मजेदार था! पहले दो अध्यायों में आपने मॉडल और टोकननाइज़रस  के बारे में सीखा, और अब आप जानते हैं कि उन्हें अपने डेटा के लिए कैसे ठीक यानि फाइन-ट्यून किया जाए। संक्षेप में, इस अध्याय में आपने:

{#if fw === 'pt'}
* [हब](https://huggingface.co/datasets) में डेटासेट के बारे में सीखा।
* डायनेमिक पैडिंग और कोलेटर्स का उपयोग करने सहित डेटासेट को लोड और पूर्व प्रसंस्करण यानि प्रीप्रोसेस करना सीखा ।
* अपने खुद की मॉडल की फाइन-ट्यूनिंग और मूल्यांकन को इम्प्लमेन्ट किया।
* निचले-स्तर के प्रशिक्षण लूप को इम्प्लमेन्ट किया
* आपके प्रशिक्षण लूप को आसानी से अनुकूलित करने के लिए 🤗 Accelerate का उपयोग किया ताकि यह कई GPUs या TPUs के लिए काम करे। 

{:else}
* [हब](https://huggingface.co/datasets) में डेटासेट के बारे में सीखा।
* डेटासेट को लोड और पूर्व प्रसंस्करण यानि प्रीप्रोसेस करना सीखा। 
* Keras के साथ एक मॉडल को फाइन-ट्यून और मूल्यांकन करना सीखा।
* एक कस्टम मीट्रिक इम्प्लमेन्ट किया गया

{/if}


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter3/5.mdx" />

### परिचय
https://huggingface.co/learn/course/hi/chapter3/1.md

# परिचय

<CourseFloatingBanner
    chapter={3}
    classNames="absolute z-10 right-0 top-0"
/>

[अध्याय 2](/course/chapter2) में हमने जाना कि कैसे भविष्यवाणी करने के लिए टोकननाइज़र और पूर्व-प्रशिक्षित मॉडल का उपयोग किया जाता है । लेकिन तब क्या यदि आप अपने स्वयं के डेटासेट के लिए एक पूर्व-प्रशिक्षित मॉडल को ठीक करना चाहते हैं? यही इस अध्याय का विषय है! आप सीखेंगे कि:

{#if fw === 'pt'}
* हब से एक बड़ा डेटासेट कैसे तैयार किया जाता है
* किसी मॉडल को फाइन-ट्यून करने के लिए उच्च स्तरीय `Trainer` API का उपयोग कैसे करें
* तदनुकूल प्रशिक्षण लूप का उपयोग कैसे करें
* किसी भी वितरित सेटअप पर उस तदनुकूल प्रशिक्षण लूप को आसानी से चलाने के लिए 🤗 एक्सेलेरेट लाइब्रेरी का लाभ कैसे उठाएं

{:else}
* हब से एक बड़ा डेटासेट कैसे तैयार करें
* मॉडल को फाइन-ट्यून करने के लिए Keras का उपयोग कैसे करें
* पूर्वानुमान लगाने के लिए Keras का उपयोग कैसे करें
* कस्टम मीट्रिक का उपयोग कैसे करें

{/if}

हगिंग फेस हब पर अपनी प्रशिक्षित चौकियों को अपलोड करने के लिए, आपको एक huggingface.co खाते की आवश्यकता होगी: [खाता बनाएं](https://huggingface.co/join)

<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter3/1.mdx" />

### मॉडल कि Trainer API के साथ
https://huggingface.co/learn/course/hi/chapter3/3.md

# मॉडल कि Trainer API के साथ

<CourseFloatingBanner chapter={3}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/hi/chapter3/section3.ipynb"},
    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/hi/chapter3/section3.ipynb"},
]} />

<Youtube id="nvBXf7s7vTI"/>

🤗 ट्रान्सफ़ॉर्मर एक `ट्रेनर` क्लास प्रदान करता है जिससे आपको उपलब्ध कराए गए किसी भी पूर्व-प्रशिक्षित मॉडल को अपने डेटासेट पर  फाइन-ट्यून करने में मदद मिलती है। एक बार जब आप अंतिम खंड में सभी डेटा पूर्व प्रसंस्करण कार्य कर लेते हैं, तो आपके पास `ट्रेनर` को परिभाषित करने के लिए बस कुछ ही चरण शेष हैं। सबसे कठिन हिस्सा `Trainer.train()` को चलाने के लिए वातावरण को तैयार करने की संभावना है, क्योंकि यह CPU पर बहुत धीमी गति से चलेगा। यदि आपके पास GPU सेट अप नहीं है, तो आप [Google Colab](https://colab.research.google.com/) पर निःशुल्क GPUs या TPUs का एक्सेस प्राप्त कर सकते हैं।

नीचे दिए गए कोड उदाहरण मानते हैं कि आपने पिछले खंड में उदाहरणों को पहले ही निष्पादित कर दिया है। यहां एक संक्षिप्त सारांश दिया गया है जिसकी आपको आवश्यकता है:

```py
from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding

raw_datasets = load_dataset("glue", "mrpc")
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)


def tokenize_function(example):
    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)


tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
```

### प्रशिक्षण

हमारे `ट्रेनर` को परिभाषित करने से पहले पहला कदम है एक `TrainingArguments` क्लास  को परिभाषित करना जिसमें प्रशिक्षण और मूल्यांकन के लिए `ट्रेनर` द्वारा उपयोग किए जाने वाले सभी हाइपरपैरामीटर शामिल होंगे। एकमात्र आर्गूमेन्ट जो आपको प्रदान करना है वह है एक निर्देशिका जहां प्रशिक्षित मॉडल सहेजा जाएगा, साथ ही साथ चौकियों को भी। बाकी सभी के लिए, आप डिफ़ॉल्ट रूप में छोड़ सकते हैं, जो एक बुनियादी फ़ाइन-ट्यूनिंग के लिए बहुत अच्छी तरह से काम करना चाहिए।

```py
from transformers import TrainingArguments

training_args = TrainingArguments("test-trainer")
```

<Tip>

💡 यदि आप प्रशिक्षण के दौरान अपने मॉडल को हब पर स्वचालित रूप से अपलोड करना चाहते हैं, तो आप `TrainingArguments` में `push_to_hub=True` के साथ पास कर सकते हैं। हम इसके बारे में [अध्याय 4](/course/chapter4/3) में और जानेंगे

</Tip>

दूसरा कदम हमारे मॉडल को परिभाषित करना है। [पिछले अध्याय](/course/chapter2) की तरह, हम `AutoModelForSequenceClassification` वर्ग का उपयोग करेंगे, दो लेबल के साथ :

```py
from transformers import AutoModelForSequenceClassification

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
```

आप देखेंगे कि [अध्याय 2](/course/chapter2) के विपरीत, आपको इस पूर्व-प्रशिक्षित मॉडल को इन्स्टैन्शीऐट करने के बाद एक चेतावनी मिलती है। ऐसा इसलिए है क्योंकि BERT को वाक्यों के जोड़े का वर्गीकरण करने के लिए पूर्व प्रशिक्षित नहीं किया गया है, इसलिए पूर्व-प्रशिक्षित मॉडल के प्रमुख को त्याग दिया गया है और इसके बजाये अनुक्रम वर्गीकरण के लिए उपयुक्त एक नया प्रमुख डाला गया है। इन चेतावनियों से संकेत मिलता है कि कुछ वज़न का उपयोग नहीं किया गया था (त्यागे गए पूर्व-प्रशिक्षण के प्रमुख के अनुरूप) और कुछ अन्य क्रमरहित रूप से प्रारंभ किए गए थे (नए प्रमुख के लिए वाले)। यह समापन आपको मॉडल को प्रशिक्षित करने के लिए प्रोत्साहित करने के साथ होगा, जो कि अब हम करने जा रहे हैं।

एक बार जब हमारे पास हमारा मॉडल होगा, तो हम एक `Trainer` को परिभाषित अब तक की निर्मित सभी वस्तुओं को पास करके कर सकते है — `model`, `training_args`, प्रशिक्षण और सत्यापन डेटासेट, हमारे `data_collator`, और हमारे `tokenizer`:

```py
from transformers import Trainer

trainer = Trainer(
    model,
    training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"],
    data_collator=data_collator,
    tokenizer=tokenizer,
)
```

ध्यान दें कि जब आप `tokenizer` पास करते हैं जैसा कि हमने यहां किया था, तो `Trainer` द्वारा उपयोग किया जाने वाला डिफ़ॉल्ट `data_colllator` एक `DataCollatorWithPadding` होगा जैसा कि पहले परिभाषित किया गया था, इसलिए आप इस कॉल में `data_collator=data_collator` लाइन को छोड़ सकते हैं। आपको प्रोसेसिंग के इस भाग को खंड 2 में दिखाना फिर भी महत्वपूर्ण था!

मॉडल को हमारे डेटासेट पर फाइन-ट्यून करने के लिए, हमें बस अपने `Trainer` के `train()` विधि को कॉल करना होगा:

```py
trainer.train()
```

यह फाइन-ट्यूनिंग को शुरू करेगा (जिसमें GPU पर कुछ मिनट लगने चाहिए) और हर 500 कदम पर प्रशिक्षण लॉस की रिपोर्ट करेगा । हालांकि, यह आपको यह नहीं बताएगा कि आपका मॉडल कितना अच्छा (या खराब) प्रदर्शन कर रहा है। यह है क्योंकि:

1. हमने `Trainer` को नहीं बताया की प्रशिक्षण के दौरान मूल्यांकन करने के लिए  `evaluation_strategy` को या तो `"steps"`(हर `eval_steps` का मूल्यांकन करें) या `"epoch"` (प्रत्येक एपॉक के अंत में मूल्यांकन) को सेट करे।
2. हमने `Trainer` को `compute_metrics()` फ़ंक्शन के साथ प्रदान नहीं किया जो मूल्यांकन के दौरान मीट्रिक की गणना करता है (अन्यथा मूल्यांकन ने केवल लॉस को मुद्रित किया होगा, जो बहुत सहज संख्या नहीं है)


### मूल्यांकन

आइए देखें कि हम एक उपयोगी `compute_metrics()` फ़ंक्शन कैसे बना सकते हैं और अगली बार जब हम प्रशिक्षण करेंगे तो इसका उपयोग कैसे कर सकते हैं। फ़ंक्शन को एक `EvalPrediction` ऑब्जेक्ट लेना होगा (जो एक `predictions` फ़ील्ड और एक `label_ids` फ़ील्ड के साथ एक नामित टपल है) और लौटाएगा एक डिक्शनरी जो मैप करेगा स्ट्रिंग्स को फ़्लोट में (स्ट्रिंग्स लौटाए गए मेट्रिक्स के नाम हैं, और फ़्लोट उनकी वैल्यूज)। हमारे मॉडल से कुछ प्रिडिक्शन्स प्राप्त करने के लिए, हम `Trainer.predict()` कमांड का उपयोग कर सकते हैं:

```py
predictions = trainer.predict(tokenized_datasets["validation"])
print(predictions.predictions.shape, predictions.label_ids.shape)
```

```python out
(408, 2) (408,)
```

`predict()` विधि का आउटपुट नामित टपल है तीन क्षेत्रों के साथ : `predictions`, `label_ids`, और `metrics`। `metrics` फ़ील्ड में केवल पास किए गए डेटासेट पर होने वाला लॉस होगा, साथ ही साथ कुछ समय मीट्रिक (कुल और औसत रूप से प्रिडिक्ट करने में कितना समय लगा) शामिल होंगे। एक बार जब हम अपना `compute_metrics()` फ़ंक्शन पूरा कर लेते हैं और इसे `ट्रेनर` को पास कर देते हैं, तो उस फ़ील्ड में `compute_metrics()` द्वारा लौटाए गए मीट्रिक भी शामिल होंगे।

जैसा कि आप देख सकते हैं, `predictions` एक 2-डिमेन्शनल सरणी है जिसका आकार 408 x 2 (408 हमारे द्वारा उपयोग किए गए डेटासेट में तत्वों की संख्या है)। वे डेटासेट के प्रत्येक तत्व के लिए लॉगिट हैं जिन्हें हमने `predict()` में पास किया है (जैसा कि आपने [पिछले अध्याय](/course/chapter2) में देखा था, सभी ट्रांसफॉर्मर मॉडल लॉगिट लौटाते हैं)। उन्हें भविष्यवाणियों यानि प्रिडिक्शन्स में बदलने के लिए जिन्हें हम अपने लेबल से तुलना कर सकते हैं, हमें दूसरी एक्सिस पर अधिकतम मूल्य के साथ इन्डेक्स लेने की आवश्यकता है:

```py
import numpy as np

preds = np.argmax(predictions.predictions, axis=-1)
```

अब हम उन `preds` की तुलना लेबल से कर सकते हैं। हमारे `compute_metric()` फ़ंक्शन को बनाने के लिए, हम 🤗 [मूल्यांकन करना](https://github.com/huggingface/evaluate/) लाइब्रेरी के मेट्रिक्स पर निर्भर है। हम MRPC डेटासेट से जुड़े मेट्रिक्स को उतनी ही आसानी से लोड कर सकते हैं, जितनी आसानी से हमने डेटासेट लोड किया, इस बार `evaluate.load()` फ़ंक्शन के साथ। इसने एक वस्तु लौटाया जिसमे एक `compute()` विधि है जिसका उपयोग हम मीट्रिक गणना करने के लिए कर सकते हैं:

```py
import evaluate

metric = evaluate.load("glue", "mrpc")
metric.compute(predictions=preds, references=predictions.label_ids)
```

```python out
{'accuracy': 0.8578431372549019, 'f1': 0.8996539792387542}
```

आपको मिलने वाले सटीक परिणाम अलग-अलग हो सकते हैं, क्योंकि मॉडल हेड के क्रमरहित इनिशियलाइज़ेशन से प्राप्त मेट्रिक्स में बदलाव हो सकता है। यहां, हम देख सकते हैं कि हमारे मॉडल का सत्यापन सेट पर 85.78% की सटीकता है और 89.97 का F1 स्कोर है। वे दो  मेट्रिक्स हैं जिनका उपयोग GLUE बेंचमार्क के लिए MRPC डेटासेट पर परिणामों का मूल्यांकन करने के लिए किया जाता है। [BERT पेपर](https://arxiv.org/pdf/1810.04805.pdf) में टेबल ने बेस मॉडल के लिए F1 स्कोर 88.9 बताया। वह एक `uncased` मॉडल था जबकि हम वर्तमान में `cased` मॉडल का उपयोग कर रहे हैं, जो बेहतर परिणाम की व्याख्या करता है।

सब कुछ एक साथ लपेटकर, हमें अपना `compute_metrics()` फ़ंक्शन मिलता है:

```py
def compute_metrics(eval_preds):
    metric = evaluate.load("glue", "mrpc")
    logits, labels = eval_preds
    predictions = np.argmax(logits, axis=-1)
    return metric.compute(predictions=predictions, references=labels)
```

और इसे प्रत्येक एपॉक के अंत में मेट्रिक्स की रिपोर्ट करने के लिए इसके उपयोग की क्रिया को देखने के लिए, यहां बताया गया है कि हम इस `compute_metrics()` फ़ंक्शन के साथ एक नया `Trainer` कैसे परिभाषित करते हैं:

```py
training_args = TrainingArguments("test-trainer", evaluation_strategy="epoch")
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

trainer = Trainer(
    model,
    training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"],
    data_collator=data_collator,
    tokenizer=tokenizer,
    compute_metrics=compute_metrics,
)
```

ध्यान दें कि हम एक नया `TrainingArguments` उसके `evaluation_strategy` जिसे सेट किया है `"epoch"` और एक नए मॉडल के साथ बनाते है — अन्यथा, हम केवल उस मॉडल का प्रशिक्षण जारी रख रहे होते जिसे हमने पहले ही प्रशिक्षित किया है। एक नया प्रशिक्षण रन शुरू करने के लिए, हम निष्पादित यानि एक्सक्यूट करते हैं:

```
trainer.train()
```

इस बार, यह सत्यापन लॉस और मेट्रिक्स की रिपोर्ट हर एपॉक के अंत में प्रशिक्षण लॉस के ऊपर करेगा। फिर से, एक सटीक एक्यूरेसी/F1 स्कोर जिसपे हम पहुंचे थोड़ा अलग हो सकता है उससे जो हमने पाया, क्योंकि मॉडल के रैंडम हेड इनिशियलाइज़ेशन के कारण, लेकिन यह उसी बॉलपार्क में होना चाहिए।

`Trainer` कई GPUs या TPUs पर बिलकुल हटकर काम करेगा और बहुत सारे विकल्प प्रदान करता है, जैसे मिश्रित-सटीक प्रशिक्षण (अपने प्रशिक्षण आर्गूमेन्ट में `fp16 = True` का उपयोग करें)। हम अध्याय 10 में इसके द्वारा समर्थित हर चीज पर अध्ययन करेंगे।

यह `Trainer` API का उपयोग करके फाइन-ट्यूनिंग के परिचय को समाप्त करता है। अधिकांश सामान्य NLP कार्यों के लिए ऐसा करने का एक उदाहरण [अध्याय 7](course/chapter7) में दिया जाएगा,  लेकिन अभी के लिए आइए देखें कि शुद्ध PyTorch में वही काम कैसे करें।

<Tip>

✏️ **कोशिश करके देखे!** GLUE SST-2 डेटासेट पर एक मॉडल को फाइन-ट्यून करें, डेटा प्रसंस्करण यानि डेटा प्रोसेसिंग का उपयोग करके जिसे आपने सेक्शन 2 में किया था

</Tip>



<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter3/3.mdx" />

### अध्याय-का-अंत प्रश्नोत्तरी
https://huggingface.co/learn/course/hi/chapter3/6.md

# अध्याय-का-अंत प्रश्नोत्तरी

<CourseFloatingBanner
    chapter={3}
    classNames="absolute z-10 right-0 top-0"
/>

इस अध्याय में आपने जो सीखा, उसका परीक्षण करें!

### 1. `इमोशन` डेटासेट में ट्विटर संदेश है जिनहे भावनाओं के साथ लेबल किया गया है। इसे [हब](https://huggingface.co/datasets) में खोजें, और डेटासेट कार्ड पढ़ें। इनमें से कौन सा इसकी मूल भावनाओं में से एक नहीं है?

<Question
	choices={[
		{
			text: "हर्ष",
			explain: "पुनः प्रयास करें — यह भावना उस डेटासेट में मौजूद है!"
		},
		{
			text: "प्रेम",
			explain: "पुनः प्रयास करें — यह भावना उस डेटासेट में मौजूद है!"
		},
		{
			text: "कन्फ्यूश़न",
			explain: "सही! भ्रम छह बुनियादी भावनाओं में से एक नहीं है।",
            correct: true
		},
        {
			text: "सप्राइज़",
			explain: "सप्राइज़! एक बार फिर कोशिश करें!"
		}
	]}
/>

### 2. [हब](https://huggingface.co/datasets) में `ar_sarcasm` डेटासेट खोजें। यह कौन से कार्य का समर्थन करता है?

<Question
	choices={[
		{
			text: "भाव वर्गीकरण",
			explain: "ये सही है! आप टैग को धन्यवाद दे सकते हैं।",
            correct: true
		},
		{
			text: "मशीन अनुवाद",
			explain: "यह बात नहीं है — <a href='https://huggingface.co/datasets/ar_sarcasm'>डेटासेट कार्ड</a> पर एक और नज़र डालें !"
		},
		{
			text: "नैम्ड एन्टिटी रेकग्निशन",
			explain: "यह बात नहीं है — <a href='https://huggingface.co/datasets/ar_sarcasm'>डेटासेट कार्ड</a> पर एक और नज़र डालें !"
		},
        {
			text: "क्वेश्चन आंसरिंग",
			explain: "हाय! इस प्रश्न का उत्तर सही नहीं दिया। पुनः प्रयास करें!"
		}
	]}
/>

### 3. BERT मॉडल वाक्यों की एक जोड़ी को कैसे संसाधित करने की अपेक्षा करता है?

<Question
	choices={[
		{
			text: "वाक्य_के_टोकन_1 [SEP] वाक्य_के_टोकन_2",
			explain: "दो वाक्यों को अलग करने के लिए एक <code>[SEP]</code> विशेष टोकन की आवश्यकता है, लेकिन केवल यही एक चीज नहीं है!"
		},
		{
			text: "[CLS] वाक्य_के_टोकन_1 वाक्य_के_टोकन_2",
			explain: "शुरुआत में एक <code>[CLS]</code> विशेष टोकन की आवश्यकता होती है, लेकिन केवल यही एक चीज नहीं है!"
		},
		{
			text: "[CLS] वाक्य_के_टोकन_1 [SEP] वाक्य_के_टोकन_2 [SEP]",
			explain: "यह सही है!",
            correct: true
		},
        {
			text: "[CLS] वाक्य_के_टोकन_1 [SEP] वाक्य_के_टोकन_2",
			explain: "शुरुआत में एक <code>[CLS]</code> विशेष टोकन की आवश्यकता होती है और साथ ही साथ दो वाक्यों को अलग करने के लिए एक <code>[SEP]</code> विशेष टोकन की आवश्यकता होती है, लेकिन यही सब नहीं है!"
		}
	]}
/>

{#if fw === 'pt'}
### 4. `Dataset.map()` विधि के क्या लाभ हैं?

<Question
	choices={[
		{
			text: "फ़ंक्शन के परिणाम कैश किए जाते हैं, इसलिए यदि हम कोड को फिर से निष्पादित करते हैं तो इसमें कोई समय नहीं लगेगा।",
			explain: "यह वास्तव में इस पद्धति के स्वच्छ लाभों में से एक है! हालांकि यह अकेला नहीं है...",
            correct: true
		},
		{
			text: "यह डेटासेट के प्रत्येक तत्व पर फ़ंक्शन को लागू करने के बजाए तेज़ी से आगे बढ़ने के लिए बहुप्रक्रमण लागू कर सकता है।",
			explain: "यह इस पद्धति की एक साफ-सुथरी विशेषता है, लेकिन केवल यही एक नहीं है!",
            correct: true
		},
		{
			text: "यह पूरे डेटासेट को मेमोरी में लोड नहीं करता है, जैसे ही एक तत्व संसाधित होता है उसके परिणामो को सहेजता हैं।",
			explain: "यह इस विधि का एक फायदा है। हालांकि अन्य भी हैं!",
            correct: true
		},
	]}
/>

### 5. डायनेमिक पैडिंग का क्या अर्थ है?

<Question
	choices={[
		{
			text: "यह तब होता है जब आप प्रत्येक बैच के लिए इनपुट को अधिकतम लंबाई तक संपूर्ण डेटासेट में पैड करते हैं।",
			explain: "इसका मतलब है बैच बनाते समय पैडिंग करना, लेकिन पूरे डेटासेट में अधिकतम लंबाई तक नहीं।"
		},
		{
			text: "यह तब होता है जब आप बैच बनाते समय अपने इनपुट को पैड करते हैं, उस बैच के अंदर वाक्यों की अधिकतम लंबाई तक।",
			explain: "यह सही है! \"डायनेमिक\" भाग इस तथ्य से आता है कि प्रत्येक बैच का आकार निर्माण के समय निर्धारित होता है, और परिणामस्वरूप आपके सभी बैचों के अलग-अलग आकार हो सकते हैं।",
            correct: true
		},
		{
			text: "यह तब होता है जब आप अपने इनपुट को पैड करते हैं ताकि प्रत्येक वाक्य में टोकन की समान संख्या हो जितने पिछले वाले में है डेटासेट के।",
			explain: "यह गलत है, साथ ही डेटासेट में ऑर्डर को देखने का कोई मतलब ही नहीं है क्योंकि हम इसे प्रशिक्षण के दौरान फेरबदल यानि शफल करते हैं।"
		},
	]}
/>

### 6. कोलेट फ़ंक्शन का उद्देश्य क्या है?

<Question
	choices={[
		{
			text: "यह सुनिश्चित करता है कि डेटासेट में सभी अनुक्रमों की लंबाई समान हो।",
			explain: "एक कोलेट फ़ंक्शन अलग-अलग बैचों को संभालने में शामिल होता है, संपूर्ण डेटासेट नहीं। इसके अतिरिक्त, हम सामान्य कोलेट फ़ंक्शंस के बारे में बात कर रहे हैं, न कि विशेष रूप से <code>DataCollatorWithPadding</code> की।"
		},
		{
			text: "यह सभी सैम्पल्स को एक बैच में एक साथ रखता है।",
			explain: "सही! आप कोलेट फ़ंक्शन को <code>DataLoader</code> के वितर्क के रूप में पास कर सकते हैं। हमने <code>DataCollatorWithPadding</code> फ़ंक्शन का उपयोग किया है, जो एक बैच में सभी आइटम्स को पैड करता है ताकि उनकी लंबाई समान हो।",
            correct: true
		},
		{
			text: "यह पूरे डेटासेट को पूर्व प्रसंस्करण यानि प्रीप्रोसेस करता है।",
			explain: "यह एक प्रीप्रोसेसिंग फ़ंक्शन होगा, न कि कोलेट फ़ंक्शन।"
		},
        {
			text: "यह डेटासेट में अनुक्रमों को छोटा कर देता है।",
			explain: "एक कोलेट फ़ंक्शन अलग-अलग बैचों को संभालने में शामिल होता है, संपूर्ण डेटासेट नहीं। यदि आप काट-छाँट करने में रुचि रखते हैं, तो आप <code>tokenizer</code> के <code>truncate</code> वितर्क का उपयोग कर सकते हैं।"
		}
	]}
/>

### 7. क्या होता है जब आप `AutoModelForXxx` कक्षाओं में से एक को पूर्व-प्रशिक्षित भाषा मॉडल (जैसे कि `बर्ट-बेस-अनकेस्ड`) के साथ इन्स्टैन्शीऐट करते हैं, जो भिन्न कार्य से मेल खाता है बजाये उसके जिसके लिए उसे प्रशिक्षित किया गया ?

<Question
	choices={[
		{
			text: "कुछ नहीं, लेकिन आपको चेतावनी मिलती है।",
			explain: "आपको एक चेतावनी मिलती है, लेकिन इतना ही नहीं!"
		},
		{
			text: "पूर्व-प्रशिक्षित मॉडल के प्रमुख को त्याग दिया जाता है और इसके बजाये कार्य के लिए उपयुक्त एक नया प्रमुख डाला जाता है।",
			explain: "सही। उदाहरण के लिए, जब हमने <code>AutoModelForSequenceClassification</code> का उपयोग <code>bert-base-uncased</code> के साथ किया, तो मॉडल को इन्स्टैन्शीऐट करते समय हमें चेतावनियां मिलीं। अनुक्रम वर्गीकरण कार्य के लिए पूर्व-प्रशिक्षित के प्रमुख का उपयोग नहीं किया जाता है, इसलिए इसे त्याग दिया जाता है और क्रमरहित भार के साथ एक नये प्रमुख को इन्स्टैन्शीऐट किया जाता है।",
            correct: true
		},
		{
			text: "पूर्व-प्रशिक्षित मॉडल के प्रमुख को त्याग दिया जाता है ।",
			explain: "कुछ और होना चाहिए। पुनः प्रयास करें!"
		},
        {
			text: "कुछ भी नहीं, चूंकि मॉडल को अभी भी भिन्न कार्य के लिए ठीक यानि फाइन-ट्यून किया जा सकता है।",
			explain: "इस कार्य को हल करने के लिए पूर्व-प्रशिक्षित मॉडल के प्रमुख को प्रशिक्षित नहीं किया गया था, इसलिए हमें प्रमुख को त्याग देना चाहिए!"
		}
	]}
/>

### 8. `TrainingArguments` का क्या उद्देश्य है?

<Question
	choices={[
		{
			text: "इसमें <code>Trainer</code> के साथ प्रशिक्षण और मूल्यांकन के लिए उपयोग किए जाने वाले सभी हाइपरपैरामीटर शामिल हैं।",
			explain: "सही!",
            correct: true
		},
		{
			text: "यह मॉडल के आकार को निर्दिष्ट करता है।",
			explain: "मॉडल का आकार मॉडल कॉन्फ़िगरेशन द्वारा परिभाषित किया जाता है, न कि कक्षा <code>TrainingArguments</code> द्वारा।"
		},
		{
			text: "इसमें केवल मूल्यांकन के लिए उपयोग किए जाने वाले हाइपरपैरामीटर शामिल हैं।",
			explain: "उदाहरण में, हमने निर्दिष्ट किया कि मॉडल और उसकी चौकियों को कहाँ सहेजा जाएगा। पुनः प्रयास करें!"
		},
        {
			text: "इसमें सिर्फ प्रशिक्षण के लिए उपयोग किए जाने वाले हाइपरपैरामीटर शामिल हैं।",
			explain: "उदाहरण में, हमने <code>evaluation_strategy</code> का भी इस्तेमाल किया है, इसलिए यह मूल्यांकन को प्रभावित करता है। पुनः प्रयास करें!"
		}
	]}
/>

### 9. आपको 🤗 Accelerate लाइब्रेरी का उपयोग क्यों करना चाहिए?

<Question
	choices={[
		{
			text: "यह तेज मॉडल तक पहुंच प्रदान करता है।",
			explain: "नहीं, 🤗 Accelerate लाइब्रेरी कोई मॉडल प्रदान नहीं करती है।"
		},
		{
			text: "यह एक उच्च स्तरीय API प्रदान करता है इसलिए मुझे अपना खुद का प्रशिक्षण लूप लागू करने की आवश्यकता नहीं है।",
			explain: "हमने <code>Trainer</code> के साथ यही किया है, न की 🤗 Accelerate लाइब्रेरी ने। पुनः प्रयास करें!"
		},
		{
			text: "यह हमारे प्रशिक्षण लूप्स को वितरित रणनीतियों पर काम कराता है",
			explain: "सही! 🤗 Accelerate के साथ, आपका प्रशिक्षण लूप कई GPUs और TPUs के लिए काम करेगा।",
            correct: true
		},
        {
			text: "यह अधिक ऑप्टिमाइजेशन फंक्शन्स प्रदान करता है।",
			explain: "नहीं, 🤗 Accelerate लाइब्रेरी कोई ऑप्टिमाइजेशन फंक्शन्स प्रदान नहीं करता है।"
		}
	]}
/>

{:else}
### 4. क्या होता है जब आप `TFAutoModelForXxx` कक्षाओं में से एक को पूर्व-प्रशिक्षित भाषा मॉडल (जैसे कि `बर्ट-बेस-अनकेस्ड`) के साथ इन्स्टैन्शीऐट करते हैं, जो भिन्न कार्य से मेल खाता है बजाये उसके जिसके लिए उसे प्रशिक्षित किया गया ?

<Question
	choices={[
		{
			text: "कुछ नहीं, लेकिन आपको चेतावनी मिलती है।",
			explain: "आपको एक चेतावनी मिलती है, लेकिन इतना ही नहीं!"
		},
		{
			text: "पूर्व-प्रशिक्षित मॉडल के प्रमुख को त्याग दिया जाता है और इसके बजाये कार्य के लिए उपयुक्त एक नया प्रमुख डाला जाता है।",
			explain: "सही। उदाहरण के लिए, जब हमने <code>TFAutoModelForSequenceClassification</code> का उपयोग <code>bert-base-uncased</code> के साथ किया, तो मॉडल को इन्स्टैन्शीऐट करते समय हमें चेतावनियां मिलीं। अनुक्रम वर्गीकरण कार्य के लिए पूर्व-प्रशिक्षित के प्रमुख का उपयोग नहीं किया जाता है, इसलिए इसे त्याग दिया जाता है और क्रमरहित भार के साथ एक नये प्रमुख को इन्स्टैन्शीऐट किया जाता है।",
            correct: true
		},
		{
			text: "पूर्व-प्रशिक्षित मॉडल के प्रमुख को त्याग दिया जाता है ।",
			explain: "कुछ और होना चाहिए। पुनः प्रयास करें!"
		},
        {
			text: "कुछ भी नहीं, चूंकि मॉडल को अभी भी भिन्न कार्य के लिए ठीक यानि फाइन-ट्यून किया जा सकता है।",
			explain: "इस कार्य को हल करने के लिए पूर्व-प्रशिक्षित मॉडल के प्रमुख को प्रशिक्षित नहीं किया गया था, इसलिए हमें प्रमुख को त्याग देना चाहिए!"
		}
	]}
/>

### 5. `ट्रांसफॉर्मर` से TensorFlow मॉडल पहले से ही Keras मॉडल हैं। यह क्या लाभ प्रदान करता है?

<Question
	choices={[
		{
			text: "मॉडल बॉक्स के बाहर एक टीपीयू पर काम करते हैं।",
			explain: "लगभग! कुछ छोटे अतिरिक्त परिवर्तनों की आवश्यकता है। उदाहरण के लिए, आपको सब कुछ एक <code>TPUStrategy</code> दायरे में चलाने की जरूरत है, जिसमें मॉडल का इनिशियलाइज़ेशन भी शामिल है।"
		},
		{
			text: "आप <code>compile()</code>, <code>fit()</code>, और <code>predict()</code> जैसी मौजूदा विधियों का लाभ उठा सकते हैं।",
			explain: "सही! एक बार आपके पास डेटा हो जाने के बाद, उस पर प्रशिक्षण के लिए बहुत कम काम की आवश्यकता होती है।",
            correct: true
		},
		{
			text: "आपको Keras के साथ-साथ ट्रांसफार्मरस भी सीखने को मिलते हैं।",
			explain: "सही है, लेकिन हम कुछ और ढूंढ रहे हैं :)",
			correct: true
		},
        {
			text: "आप डेटासेट से संबंधित मेट्रिक्स की आसानी से गणना कर सकते हैं।",
			explain: "आप डेटासेट से संबंधित मेट्रिक्स की आसानी से गणना कर सकते हैं।"
		}
	]}
/>

### 6. आप अपनी खुद की कस्टम मीट्रिक कैसे परिभाषित कर सकते हैं?

<Question
	choices={[
		{
			text: "<code>tf.keras.metrics.Metric</code> की उपवर्गीकरण करके।",
			explain: "बहुत बढ़िया !",
			correct: true
		},
		{
			text: "Keras क्रियात्मक API का उपयोग करना।",
			explain: "पुनः प्रयास करें!"
		},
		{
			text: "हस्ताक्षर <code>metric_fn(y_true, y_pred)</code> के साथ प्रतिदेय का उपयोग करना।",
			explain: "सही!",
			correct: true
		},
        {
			text: "इसे गुगल करके।",
			explain: "यह वह उत्तर नहीं है जिसकी हम तलाश कर रहे हैं, लेकिन इससे आपको उसे खोजने में मदद मिलेगी।",
			correct: true
		}
	]}
/>

{/if}


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter3/6.mdx" />

### मॉडल कि फाइन-ट्यूनिंग Keras के साथ
https://huggingface.co/learn/course/hi/chapter3/3_tf.md

# मॉडल कि फाइन-ट्यूनिंग Keras के साथ

<CourseFloatingBanner chapter={3}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/hi/chapter3/section3_tf.ipynb"},
    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/hi/chapter3/section3_tf.ipynb"},
]} />

एक बार जब आप अंतिम खंड में सभी डेटा पूर्व प्रसंस्करण कार्य कर लेते हैं, तो आपके पास मॉडल को प्रशिक्षित करने के लिए बस कुछ ही चरण शेष हैं। हालाँकि, ध्यान दें कि `model.fit()` कमांड CPU पर बहुत धीमी गति से चलेगा। यदि आपके पास GPU सेट अप नहीं है, तो आप [Google Colab](https://colab.research.google.com/) पर निःशुल्क GPU या TPU का एक्सेस प्राप्त कर सकते हैं।

नीचे दिए गए कोड उदाहरण मानते हैं कि आपने पिछले खंड में उदाहरणों को पहले ही निष्पादित कर दिया है। यहां एक संक्षिप्त सारांश दिया गया है जिसकी आपको आवश्यकता है:

```py
from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding
import numpy as np

raw_datasets = load_dataset("glue", "mrpc")
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)


def tokenize_function(example):
    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)


tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)

data_collator = DataCollatorWithPadding(tokenizer=tokenizer, return_tensors="tf")

tf_train_dataset = tokenized_datasets["train"].to_tf_dataset(
    columns=["attention_mask", "input_ids", "token_type_ids"],
    label_cols=["labels"],
    shuffle=True,
    collate_fn=data_collator,
    batch_size=8,
)

tf_validation_dataset = tokenized_datasets["validation"].to_tf_dataset(
    columns=["attention_mask", "input_ids", "token_type_ids"],
    label_cols=["labels"],
    shuffle=False,
    collate_fn=data_collator,
    batch_size=8,
)
```

### प्रशिक्षण

🤗 ट्रांसफॉर्मर से आयात किए गए TensorFlow मॉडल पहले से ही Keras मॉडल हैं। यहाँ Keras का संक्षिप्त परिचय दिया गया है।

<Youtube id="rnTGBy2ax1c"/>

इसका मतलब है कि एक बार जब हमारे पास हमारा डेटा होता है, तो उस पर प्रशिक्षण शुरू करने के लिए बहुत कम काम करने की आवश्यकता होती है।

<Youtube id="AUozVp78dhk"/>

[पिछले अध्याय](/course/chapter2) की तरह, हम `TFAutoModelForSequenceClassification` क्लास का उपयोग दो लेबल के साथ करेंगे: 

```py
from transformers import TFAutoModelForSequenceClassification

model = TFAutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
```

आप देखेंगे कि [अध्याय 2](/course/chapter2) के विपरीत, आपको इस पूर्व-प्रशिक्षित मॉडल को इन्स्टैन्शीऐट करने के बाद एक चेतावनी मिलती है। ऐसा इसलिए है क्योंकि BERT को वाक्यों के जोड़े का वर्गीकरण करने के लिए पूर्व प्रशिक्षित नहीं किया गया है, इसलिए पूर्व-प्रशिक्षित मॉडल के प्रमुख को त्याग दिया गया है और इसके बजाये अनुक्रम वर्गीकरण के लिए उपयुक्त एक नया प्रमुख डाला गया है। इन चेतावनियों से संकेत मिलता है कि कुछ वज़न का उपयोग नहीं किया गया था (त्यागे गए पूर्व-प्रशिक्षण के प्रमुख के अनुरूप) और कुछ अन्य क्रमरहित रूप से प्रारंभ किए गए थे (नए प्रमुख के लिए वाले)। यह समापन आपको मॉडल को प्रशिक्षित करने के लिए प्रोत्साहित करने के साथ होगा, जो कि अब हम करने जा रहे हैं।

अपने डेटासेट पर मॉडल को फाइन-ट्यून करने के लिए, हमें बस अपने मॉडल को `compile()` करना होगा और फिर अपने डेटा को `fit()` विधि में पास करना होगा। यह फ़ाइन-ट्यूनिंग प्रक्रिया को शुरू करेगा (जो GPU पर कुछ मिनट लेगा) और आगे जा कर यह हर युग यानि एपॉच के अंत में प्रशिक्षण हानि यानि लॉस साथ ही सत्यापन हानि की रिपोर्ट करेगा।

<Tip>

ध्यान दें कि 🤗 ट्रांसफॉर्मर मॉडल में एक विशेष क्षमता होती है जो कि अधिकांश Keras मॉडल नहीं होती - वे स्वचालित रूप से एक उचित हानि यानि लॉस का उपयोग कर सकते हैं जिसे वे आंतरिक रूप से गणना करते हैं। वे डिफ़ॉल्ट रूप से इस लॉस का उपयोग करेगा अगर आप `compile()` में लॉस आर्गूमेन्ट सेट नहीं करते हैं तो। ध्यान दें कि आंतरिक लॉस का उपयोग करने के लिए आपको अपने लेबल को इनपुट के हिस्से के रूप में पास करना होगा, न कि एक अलग लेबल के रूप में, जो कि Keras मॉडल के साथ लेबल का उपयोग करने का सामान्य तरीका है। आप पाठ्यक्रम के भाग 2 में इसके उदाहरण देखेंगे, जहां सही लॉस फ़ंक्शन को परिभाषित करना पेचीदा हो सकता है। अनुक्रम वर्गीकरण के लिए, हालांकि, एक मानक Keras लॉस फ़ंक्शन ठीक काम करता है, इसलिए हम यहां इसका उपयोग करेंगे।

</Tip>

```py
from tensorflow.keras.losses import SparseCategoricalCrossentropy

model.compile(
    optimizer="adam",
    loss=SparseCategoricalCrossentropy(from_logits=True),
    metrics=["accuracy"],
)
model.fit(
    tf_train_dataset,
    validation_data=tf_validation_dataset,
)
```

<Tip warning={true}>

यहां एक बहुत ही सामान्य नुकसान पर ध्यान दें - आप केवल लॉस का नाम स्ट्रिंग के रूप मे Keras को पास *कर सकते* है, लेकिन डिफ़ॉल्ट रूप से Keras यह मानेगा कि आपने पहले ही अपने आउटपुट में सॉफ्टमैक्स लागू कर दिया है। हालाँकि, कई मॉडल सॉफ्टमैक्स लागू होने से ठीक पहले मानों यानि वैल्यूज़ को आउटपुट करते हैं, जिन्हें *logits* के रूप में भी जाना जाता है। हमें लॉस फ़ंक्शन को यह बताने की आवश्यकता है कि हमारा मॉडल क्या करता है, और ऐसा करने का एकमात्र तरीका है कि इसे सीधे कॉल करना, बजाय एक स्ट्रिंग के नाम से।

</Tip>


### प्रशिक्षण प्रदर्शन में सुधार करना

<Youtube id="cpzq6ESSM5c"/>

यदि आप उपर दिए गए कोड का प्रयास करते हैं, तो यह निश्चित रूप से चलता है, लेकिन आप पाएंगे कि लॉस केवल धीरे-धीरे या छिटपुट रूप से घटता
है। इसका मुख्य कारण है सीखने की दर यानि *लर्निंग रेट*। लॉस के साथ, जब हम Keras को ऑप्टिमाइज़र का नाम स्ट्रिंग के रूप में पास करते है, तो
Keras उस ऑप्टिमाइज़र को लर्निंग रेट सहित सभी मापदंडों के लिए डिफ़ॉल्ट वैल्यूज़ के साथ आरंभ यानि इनिशलाइज़ करता है। लंबे अनुभव से,
हालांकि, हम जानते हैं कि ट्रांसफॉर्मर मॉडल डिफ़ॉल्ट एडम की तुलना में बहुत कम लर्निंग रेट से लाभ होता हैं, जो कि 1e-3 है, जिसे 10 की पॉवर -3 या
0.001  के रूप में भी लिखा जाता है। 5e-5 (0.00005), जो कुछ बीस गुना कम है, एक बेहतर प्रारंभिक बिंदु है।

सीखने की दर यानि लर्निंग रेट को कम करने के अलावा, हमारे पास एक दूसरी चाल है: हम प्रशिक्षण के दौरान लर्निंग रेट को
धीरे-धीरे कम कर सकते हैं । साहित्य में, आप कभी-कभी इसे *क्षय* या *एनीलिंग* लर्निंग रेट के रूप में संदर्भित देखेंगे।
केरस में, ऐसा करने का सबसे अच्छा तरीका एक *लर्निंग रेट शेड्यूलर* का उपयोग करना है। उपयोग करने के लिए एक अच्छा है
`PolynomialDecay` — नाम के बावजूद, डिफ़ॉल्ट सेटिंग्स के साथ यह प्रशिक्षण के दौरान प्रारंभिक वैल्यूज़ से अंतिम वैल्यूज़ तक
सीखने की दर को रैखिक रूप से कम कर देता है, जो वास्तव में हम चाहते हैं। शेड्यूलर का सही तरीके से उपयोग करने के लिए,
 हालांकि, हमें यह बताना होगा कि प्रशिक्षण कितना लंबा होगा। हम इसकी गणना नीचे `num_train_steps` के रूप में करते हैं।

```py
from tensorflow.keras.optimizers.schedules import PolynomialDecay

batch_size = 8
num_epochs = 3
# The number of training steps is the number of samples in the dataset, divided by the batch size then multiplied
# by the total number of epochs. Note that the tf_train_dataset here is a batched tf.data.Dataset,
# not the original Hugging Face Dataset, so its len() is already num_samples // batch_size.
num_train_steps = len(tf_train_dataset) * num_epochs
lr_scheduler = PolynomialDecay(
    initial_learning_rate=5e-5, end_learning_rate=0.0, decay_steps=num_train_steps
)
from tensorflow.keras.optimizers import Adam

opt = Adam(learning_rate=lr_scheduler)
```

<Tip>

🤗 ट्रांसफॉर्मर्स लाइब्रेरी में एक `create_optimizer()` फ़ंक्शन भी है जो लर्निंग रेट क्षय के साथ एक `AdamW` ऑप्टिमाइज़र बनाएगा। यह एक सुविधाजनक शॉर्टकट है जिसे आप पाठ्यक्रम के भविष्य के अनुभागों में विस्तार से देखेंगे।

</Tip>

अब हमारे पास हमारा बिल्कुल नया ऑप्टिमाइज़र है, और हम इसके साथ प्रशिक्षण का प्रयास कर सकते हैं। सबसे पहले, मॉडल को फिर से लोड करें, ताकि हमारे द्वारा अभी-अभी किए गए प्रशिक्षण रन से वज़न में परिवर्तन को रीसेट कर सके, और फिर हम इसे नए ऑप्टिमाइज़र के साथ कंपाइल कर सकते हैं:

```py
import tensorflow as tf

model = TFAutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
model.compile(optimizer=opt, loss=loss, metrics=["accuracy"])
```

अब, हम फिर से फिट करेगे:

```py
model.fit(tf_train_dataset, validation_data=tf_validation_dataset, epochs=3)
```

<Tip>

💡 यदि आप प्रशिक्षण के दौरान अपने मॉडल को हब पर स्वचालित रूप से अपलोड करना चाहते हैं, तो आप `model.fit()` विधि में `PushToHubCallback` के साथ पास कर सकते हैं। हम इसके बारे में [अध्याय 4](/course/chapter4/3) में और जानेंगे

</Tip>

### मॉडल के पूर्वानुमान

<Youtube id="nx10eh4CoOs"/>


प्रशिक्षण और लॉस को कम होते देखना बहुत अच्छा है, लेकिन क्या होगा अगर हम वास्तव में प्रशिक्षित मॉडल से आउटपुट प्राप्त करना चाहते हैं, या तो कुछ मेट्रिक्स की गणना करने के लिए, या उत्पादन में मॉडल का उपयोग करने के लिए? ऐसा करने के लिए, हम केवल `predict()` विधि का उपयोग कर सकते हैं। यह एक प्रति क्लास, मॉडल के आउटपुट हेड से *logits* लौटाएगा।

```py
preds = model.predict(tf_validation_dataset)["logits"]
```

हम उच्चतम लॉगिट् को खोजने के लिए `argmax` का उपयोग करके इन लॉगिट्स को मॉडल के क्लास पूर्वानुमान में बदल सकते हैं, जो सबसे संभावित क्लास से मेल खाता है:

```py
class_preds = np.argmax(preds, axis=1)
print(preds.shape, class_preds.shape)
```

```python out
(408, 2) (408,)
```

अब, कुछ मेट्रिक्स की गणना करने के लिए उन `preds` का उपयोग करते हैं! हम MRPC डेटासेट से जुड़े मेट्रिक्स को उतनी ही आसानी से लोड कर सकते हैं, जितनी आसानी से हमने डेटासेट लोड किया, इस बार `evaluate.load()` फ़ंक्शन के साथ। इसने एक वस्तु लौटाया जिसमे एक `compute()` विधि है जिसका उपयोग हम मीट्रिक गणना करने के लिए कर सकते हैं:

```py
import evaluate

metric = evaluate.load("glue", "mrpc")
metric.compute(predictions=class_preds, references=raw_datasets["validation"]["label"])
```

```python out
{'accuracy': 0.8578431372549019, 'f1': 0.8996539792387542}
```

आपको मिलने वाले सटीक परिणाम अलग-अलग हो सकते हैं, क्योंकि मॉडल हेड के क्रमरहित इनिशियलाइज़ेशन से प्राप्त मेट्रिक्स में बदलाव हो सकता है। यहां, हम देख सकते हैं कि हमारे मॉडल का सत्यापन सेट पर 85.78% की सटीकता है और 89.97 का F1 स्कोर है। वे दो  मेट्रिक्स हैं जिनका उपयोग GLUE बेंचमार्क के लिए MRPC डेटासेट पर परिणामों का मूल्यांकन करने के लिए किया जाता है। [BERT पेपर](https://arxiv.org/pdf/1810.04805.pdf) में टेबल ने बेस मॉडल के लिए F1 स्कोर 88.9 बताया। वह एक `uncased` मॉडल था जबकि हम वर्तमान में `cased` मॉडल का उपयोग कर रहे हैं, जो बेहतर परिणाम की व्याख्या करता है।

यह Keras API का उपयोग करके फाइन-ट्यूनिंग के परिचय को समाप्त करता है। अधिकांश सामान्य NLP कार्यों के लिए ऐसा करने का एक उदाहरण [अध्याय 7](course/chapter7) में दिया जाएगा। यदि आप Keras API पर अपने कौशल को सुधारना चाहते हैं, तो GLUE SST-2 डेटासेट पर एक मॉडल को फाइन-ट्यून करने का प्रयास करें, डेटा प्रसंस्करण यानि डेटा प्रोसेसिंग का उपयोग करके जिसे आपने सेक्शन 2 में किया था


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter3/3_tf.mdx" />

### एक पूर्ण प्रशिक्षण
https://huggingface.co/learn/course/hi/chapter3/4.md

# एक पूर्ण प्रशिक्षण

<CourseFloatingBanner chapter={3}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/hi/chapter3/section4.ipynb"},
    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/hi/chapter3/section4.ipynb"},
]} />

<Youtube id="Dh9CL8fyG80"/>

अब हम देखेंगे कि `Trainer` क्लास का उपयोग किए बिना कैसे हम समान  परिणाम प्राप्त करे जैसा की हमने पिछले खंड प्राप्त किया था। फिर से, हम मानते हैं कि आपने अनुभाग 2 में डेटा प्रसंस्करण यानि डेटा प्रोसेसिंग कर ली है। यहां एक संक्षिप्त सारांश दिया गया है जो वह सब कुछ शामिल कर रहा है जिसकी आपको आवश्यकता होगी:

```py
from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding

raw_datasets = load_dataset("glue", "mrpc")
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)


def tokenize_function(example):
    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)


tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
```

### प्रशिक्षण के लिए तैयार करें

हमारे प्रशिक्षण लूप वास्तव में लिखने से पहले, हमें कुछ वस्तुओं को परिभाषित करने की आवश्यकता होगी। पहले है डेटालोडर्स  जिनका उपयोग हम बैचों पर पुनरावृति करने के लिए करेंगे। लेकिन इससे पहले कि हम उन डेटालोडर्स को परिभाषित कर सके, हमें अपने `tokenized_datasets` में कुछ पोस्टप्रोसेसिंग लागू करने की जरूरत है, ताकि कुछ चीजों का ख्याल रखा जा सके जो `Trainer` ने हमारे लिए स्वचालित रूप से किया था। विशेष रूप से, हमें जरूरत है की:

- उन वैल्यूज के अनुरूप कॉलम निकालें जिनकी मॉडल अपेक्षा नहीं करता (जैसे `sentence1` और `sentence2` कॉलम)।
- कॉलम `label` का नाम बदलकर `labels` कर दें (क्योंकि मॉडल उम्मीद करता है की वितर्क का नाम `labels` हो)।
- डेटासेट का प्रारूप सेट करें ताकि वे सूचियों के बजाय PyTorch टेंसर लौटाएं।

हमारे `tokenized_datasets` में उनमे से प्रत्येक चरण के लिए एक विधि है:

```py
tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"])
tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
tokenized_datasets.set_format("torch")
tokenized_datasets["train"].column_names
```

हम फिर जांच सकते हैं कि परिणाम में केवल कॉलम है जिन्हें हमारा मॉडल स्वीकार करेगा:

```python
["attention_mask", "input_ids", "labels", "token_type_ids"]
```

अब जब यह हो गया है, तो हम आसानी से अपने डेटालोडर्स को परिभाषित कर सकते हैं:

```py
from torch.utils.data import DataLoader

train_dataloader = DataLoader(
    tokenized_datasets["train"], shuffle=True, batch_size=8, collate_fn=data_collator
)
eval_dataloader = DataLoader(
    tokenized_datasets["validation"], batch_size=8, collate_fn=data_collator
)
```

यह जांचने के लिए कि डेटा प्रोसेसिंग में कोई गलती तो नहीं है, हम इस तरह एक बैच का निरीक्षण कर सकते हैं:

```py
for batch in train_dataloader:
    break
{k: v.shape for k, v in batch.items()}
```

```python out
{'attention_mask': torch.Size([8, 65]),
 'input_ids': torch.Size([8, 65]),
 'labels': torch.Size([8]),
 'token_type_ids': torch.Size([8, 65])}
```

ध्यान दें कि वास्तविक आकार आपके लिए शायद थोड़ा अलग होगा क्योंकि हमने प्रशिक्षण डेटालोडर के लिए `shuffle=True` सेट किया है और हम बैच के अंदर अधिकतम लंबाई तक पैडिंग कर रहे हैं।

अब जबकि हम डेटा प्रीप्रोसेसिंग (एक संतोषजनक लेकिन मायावी लक्ष्य किसी भी ML प्रैक्टिशनर के लिए) के साथ पूरी तरह से समाप्त कर चुके हैं, आइए मॉडल की ओर मुड़ें। हम इसे ठीक वैसे ही इन्स्टैन्शीऐट करते हैं जैसे हमने पिछले सेक्शन में किया था:

```py
from transformers import AutoModelForSequenceClassification

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
```

यह सुनिश्चित करने के लिए कि प्रशिक्षण के दौरान सब कुछ सुचारू रूप से चले, हम अपने बैच को इस मॉडल में पास करते हैं:

```py
outputs = model(**batch)
print(outputs.loss, outputs.logits.shape)
```

```python out
tensor(0.5441, grad_fn=<NllLossBackward>) torch.Size([8, 2])
```

सभी 🤗 ट्रांसफॉर्मर मॉडल लॉस लौटाएंगे जब `labels` प्रदान किया जाते है, और हमें logits भी मिलते हैं (हमारे बैच में प्रत्येक इनपुट के लिए दो, इसलिए टेंसर आकार का 8 x 2)।

हम अपना प्रशिक्षण लूप लिखने के लिए लगभग तैयार हैं! हम केवल दो चीजें खो रहे हैं: एक ऑप्टिमाइज़र और एक लर्निंग रेट अनुसूचक। चूंकि `Trainer` जो कर रहा था उसे हम खुद से दोहराने की कोशिश कर रहे हैं, तो हम उन्ही डिफ़ॉल्ट का उपयोग करेंगे। `Trainer` द्वारा उपयोग किया जाने वाला ऑप्टिमाइज़र `AdamW` है, जो Adam के समान है, लेकिन एक मोड़ के साथ वजन क्षय नियमितीकरण के लिए (इल्या लोशिलोव और फ्रैंक हटर द्वारा ["डीकपलड वेट डेके रेगुलराइजेशन"](https://arxiv.org/abs/1711.05101) देखें):

```py
from torch.optim import AdamW

optimizer = AdamW(model.parameters(), lr=5e-5)
```

अंत में, लर्निंग रेट अनुसूचक जिसे डिफ़ॉल्ट रूप से उपयोग किया जाता है केवल एक रैखिक क्षय है जो अधिकतम मूल्य (5e-5) से 0 तक है। इसे ठीक से परिभाषित करने के लिए, हमें यह जानना होगा कि हम कितने प्रशिक्षण कदम उठाएंगे, जो कि है युगों यानि एपोक की संख्या जिन्हे हमे रन करना है उसका गुणा प्रशिक्षण बैचों की संख्या से करना (जो कि हमारे प्रशिक्षण डेटालोडर की लंबाई है)। `Trainer` डिफ़ॉल्ट रूप से तीन युगों यानि एपोक का उपयोग करता है, इसलिए हम उसका अनुसरण करेंगे:

```py
from transformers import get_scheduler

num_epochs = 3
num_training_steps = num_epochs * len(train_dataloader)
lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)
print(num_training_steps)
```

```python out
1377
```

### ट्रेनिंग लूप

एक आखिरी बात: हम GPU का उपयोग करना चाहेंगे अगर हमारे पास एक का एक्सेस है तो (CPU पर, प्रशिक्षण में कुछ मिनटों के बजाय कई घंटे लग सकते हैं)। ऐसा करने के लिए, हम एक `device` को परिभाषित करेंगे, जिस पर हम अपने मॉडल को और अपने बैचों को रखेंगे:

```py
import torch

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)
device
```

```python out
device(type='cuda')
```

अब हम प्रशिक्षण के लिए तैयार हैं! यह जानने के लिए कि प्रशिक्षण कब समाप्त होगा, हम `tqdm` लाइब्रेरी का उपयोग करके अपने प्रशिक्षण चरणों की संख्या पर एक प्रगति पट्टी जोड़ेगे:

```py
from tqdm.auto import tqdm

progress_bar = tqdm(range(num_training_steps))

model.train()
for epoch in range(num_epochs):
    for batch in train_dataloader:
        batch = {k: v.to(device) for k, v in batch.items()}
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)
```

आप देख सकते हैं कि प्रशिक्षण लूप का मूल जो परिचय में है उसके समान दिखता है। हमने कोई रिपोर्टिंग नहीं मांगी, इसलिए यह प्रशिक्षण लूप हमें इस बारे में कुछ नहीं बताएगा कि मॉडल का किराया कैसा है। हमें उसके लिए एक मूल्यांकन लूप जोड़ने की जरूरत है।


### मूल्यांकन लूप

जैसा कि हमने पहले किया था, हम 🤗 मूल्यांकन करना लाइब्रेरी द्वारा प्रदान किए गए मीट्रिक का उपयोग करेंगे। हम पहले ही `metric.compute()` विधि देख चुके हैं, लेकिन मेट्रिक्स वास्तव में हमारे लिए बैच जमा कर सकते हैं जब हम भविष्यवाणी लूप पर जाते हैं `add_batch()` विधि के साथ । एक बार जब हम सभी बैचों को जमा कर लेते हैं, तो हम `metric.compute()` के साथ अंतिम परिणाम प्राप्त कर सकते हैं। मूल्यांकन लूप में इन सभी को कार्यान्वित करने का तरीका यहां दिया गया है:

```py
import evaluate

metric = evaluate.load("glue", "mrpc")
model.eval()
for batch in eval_dataloader:
    batch = {k: v.to(device) for k, v in batch.items()}
    with torch.no_grad():
        outputs = model(**batch)

    logits = outputs.logits
    predictions = torch.argmax(logits, dim=-1)
    metric.add_batch(predictions=predictions, references=batch["labels"])

metric.compute()
```

```python out
{'accuracy': 0.8431372549019608, 'f1': 0.8907849829351535}
```

फिर से, मॉडल हेड इनिशियलाइज़ेशन और डेटा फेरबदल में क्रमरहित होने के कारण आपके परिणाम थोड़े भिन्न होंगे, लेकिन वे एक ही बॉलपार्क में होने चाहिए।

<Tip>

✏️ **कोशिश करके देखे!** पिछले प्रशिक्षण लूप को संशोधित करें ताकि अपने मॉडल को SST-2 डेटासेट पर फाइन-ट्यून कर सके। 

</Tip>

### अपने प्रशिक्षण लूप को सुपरचार्ज करें 🤗 Accelerate के साथ।

<Youtube id="s7dy8QRgjJ0" />

हमने पहले जो ट्रेनिंग लूप परिभाषित किया था, वह सिंगल CPU या GPU पर ठीक काम करता है। लेकिन  [🤗 Accelerate](https://github.com/huggingface/accelerate) लाइब्रेरी का उपयोग करके, बस कुछ समायोजन के साथ हम कई GPUs या TPUs पर वितरित प्रशिक्षण को सक्षम कर सकते हैं। शुरुआत प्रशिक्षण और सत्यापन डेटा लोडर के निर्माण से हुई, यहाँ हमारा मैनुअल प्रशिक्षण लूप कैसा दिखता है:

```py
from torch.optim import AdamW
from transformers import AutoModelForSequenceClassification, get_scheduler

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
optimizer = AdamW(model.parameters(), lr=3e-5)

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)

num_epochs = 3
num_training_steps = num_epochs * len(train_dataloader)
lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)

progress_bar = tqdm(range(num_training_steps))

model.train()
for epoch in range(num_epochs):
    for batch in train_dataloader:
        batch = {k: v.to(device) for k, v in batch.items()}
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)
```

और परिवर्तन यहाँ हैं:

```diff
+ from accelerate import Accelerator
  from torch.optim import AdamW
  from transformers import AutoModelForSequenceClassification, get_scheduler

+ accelerator = Accelerator()

  model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
  optimizer = AdamW(model.parameters(), lr=3e-5)

- device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
- model.to(device)

+ train_dataloader, eval_dataloader, model, optimizer = accelerator.prepare(
+     train_dataloader, eval_dataloader, model, optimizer
+ )

  num_epochs = 3
  num_training_steps = num_epochs * len(train_dataloader)
  lr_scheduler = get_scheduler(
      "linear",
      optimizer=optimizer,
      num_warmup_steps=0,
      num_training_steps=num_training_steps
  )

  progress_bar = tqdm(range(num_training_steps))

  model.train()
  for epoch in range(num_epochs):
      for batch in train_dataloader:
-         batch = {k: v.to(device) for k, v in batch.items()}
          outputs = model(**batch)
          loss = outputs.loss
-         loss.backward()
+         accelerator.backward(loss)

          optimizer.step()
          lr_scheduler.step()
          optimizer.zero_grad()
          progress_bar.update(1)
```

सबसे पहली लाइन जो जोड़नी है वो है इम्पोर्ट लाइन। दूसरी लाइन एक `Accelerator` वस्तु को इन्स्टैन्शीऐट करती है जो वातावरण को देखेगी और उचित वितरित सेटअप को इनिशियलाइज़ करेगी। 🤗 Accelerate आपके लिए डिवाइस प्लेसमेंट को हैंडल करता है, ताकि आप उन लाइनों को हटा सकें जो मॉडल को डिवाइस पर रखती हैं (या, यदि आप चाहें, तो उन्हें `device` के बजाय `accelerator.device` का उपयोग करने के लिए बदलें)।

फिर काम का मुख्य हिस्सा उस लाइन में किया जाता है जो डेटालोडर्स, मॉडल और ऑप्टिमाइज़र को `accelerator.prepare()` पर भेजता है। यह उन वस्तुओं को उचित कंटेनर में लपेट देगा ताकि यह सुनिश्चित हो सके कि आपका वितरित प्रशिक्षण उद्देश्य के अनुसार काम करता है। शेष परिवर्तन है उस लाइन को हटाना जो बैच को `device` पर रखता है (फिर से, यदि आप इसे रखना चाहते हैं तो आप इसे केवल `accelerator.device` का उपयोग करने के लिए बदल सकते हैं) और `loss.backward()` को `accelerator.backward(loss)` के साथ बदलना।

<Tip>
⚠️ Cloud TPUs द्वारा पेश किए गए स्पीड-अप से लाभ उठाने के लिए, हम अनुशंसा करते हैं कि आप अपने सैम्पल्स को टोकननाइज़र के `padding="max_length"` और `max_length` प्राचल यानि आर्गुमेंट के साथ एक निश्चित लंबाई तक पैडिंग करें।
</Tip>

यदि आप इसे खेलने के लिए कॉपी और पेस्ट करना चाहते हैं, तो यहां बताया गया है कि 🤗 Accelerate के साथ पूरा प्रशिक्षण लूप कैसा दिखता है:

```py
from accelerate import Accelerator
from torch.optim import AdamW
from transformers import AutoModelForSequenceClassification, get_scheduler

accelerator = Accelerator()

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
optimizer = AdamW(model.parameters(), lr=3e-5)

train_dl, eval_dl, model, optimizer = accelerator.prepare(
    train_dataloader, eval_dataloader, model, optimizer
)

num_epochs = 3
num_training_steps = num_epochs * len(train_dl)
lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)

progress_bar = tqdm(range(num_training_steps))

model.train()
for epoch in range(num_epochs):
    for batch in train_dl:
        outputs = model(**batch)
        loss = outputs.loss
        accelerator.backward(loss)

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)
```

इसे एक `train.py` स्क्रिप्ट में रखने से वह स्क्रिप्ट किसी भी प्रकार के वितरित सेटअप पर चलने योग्य हो जाएगी। इसे अपने वितरित सेटअप में आज़माने के लिए, कमांड चलाएँ:

```bash
accelerate config
```

जो आपको कुछ सवालों के जवाब देने के लिए प्रेरित करेगा और इस कमांड द्वारा उपयोग की जाने वाली कॉन्फ़िगरेशन फ़ाइल में आपके उत्तरों को डंप कर देगा:

```
accelerate launch train.py
```

जो वितरित प्रशिक्षण को शुरू करेगा।

यदि आप इसे नोटबुक में आज़माना चाहते हैं (उदाहरण के लिए, Colab पर TPUs के साथ इसका परीक्षण करने के लिए), तो बस कोड को `training_function()` में पेस्ट करें और एक अंतिम सेल चलाएँ साथ में:

```python
from accelerate import notebook_launcher

notebook_launcher(training_function)
```

आप कई अधिक उदाहरण [🤗 Accelerate repo](https://github.com/huggingface/accelerate/tree/main/examples) में पा सकते है।


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter3/4.mdx" />

### डेटा संसाधित करना
https://huggingface.co/learn/course/hi/chapter3/2.md

# डेटा संसाधित करना

{#if fw === 'pt'}

<CourseFloatingBanner chapter={3}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/hi/chapter3/section2_pt.ipynb"},
    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/hi/chapter3/section2_pt.ipynb"},
]} />

{:else}

<CourseFloatingBanner chapter={3}
  classNames="absolute z-10 right-0 top-0"
  notebooks={[
    {label: "Google Colab", value: "https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/hi/chapter3/section2_tf.ipynb"},
    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/hi/chapter3/section2_tf.ipynb"},
]} />

{/if}

{#if fw === 'pt'}
[पिछले अध्याय](/course/chapter2) के उदाहरण को जारी रखते हुए, यहां बताया गया है कि हम PyTorch में एक बैच पर अनुक्रम वर्गीकारक को कैसे प्रशिक्षित करेंगे:

```python
import torch
from torch.optim import AdamW
from transformers import AutoTokenizer, AutoModelForSequenceClassification

# Same as before
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
sequences = [
    "I've been waiting for a HuggingFace course my whole life.",
    "This course is amazing!",
]
batch = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt")

# This is new
batch["labels"] = torch.tensor([1, 1])

optimizer = AdamW(model.parameters())
loss = model(**batch).loss
loss.backward()
optimizer.step()
```
{:else}
[पिछले अध्याय](/course/chapter2) के उदाहरण को जारी रखते हुए, यहां बताया गया है कि हम TensorFlow में एक बैच पर अनुक्रम वर्गीकारक को कैसे प्रशिक्षित करेंगे:

```python
import tensorflow as tf
import numpy as np
from transformers import AutoTokenizer, TFAutoModelForSequenceClassification

# Same as before
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = TFAutoModelForSequenceClassification.from_pretrained(checkpoint)
sequences = [
    "I've been waiting for a HuggingFace course my whole life.",
    "This course is amazing!",
]
batch = dict(tokenizer(sequences, padding=True, truncation=True, return_tensors="tf"))

# This is new
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy")
labels = tf.convert_to_tensor([1, 1])
model.train_on_batch(batch, labels)
```
{/if}

बेशक, केवल दो वाक्यों पर मॉडल को प्रशिक्षित करने से बहुत अच्छे परिणाम नहीं मिलेंगे। बेहतर परिणाम प्राप्त करने के लिए, आपको एक बड़ा डेटासेट तैयार करना होगा।

इस खंड में हम एक उदाहरण के रूप में MRPC (Microsoft Research Paraphrase Corpus) डेटासेट का उपयोग करेंगे, जिसे विलियम बी. डोलन और क्रिस ब्रोकेट द्वारा एक [पेपर](https://www.aclweb.org/anthology/I05-5002.pdf) में पेश किया गया था। डेटासेट में 5,801 वाक्यों के जोड़े हैं, साथ मे एक लेबल जो दर्शाता है कि वे पैराफ्रेज हैं या नहीं (यानी, क्या दोनों वाक्यों का मतलब एक ही है)। हमने इसे इस अध्याय के लिए चुना है क्योंकि यह एक छोटा डेटासेट है, इसलिए इस पर प्रशिक्षण के साथ प्रयोग करना आसान है।

### हब से डेटासेट लोड करना

{#if fw === 'pt'}
<Youtube id="_BZearw7f0w"/>
{:else}
<Youtube id="W_gMJF0xomE"/>
{/if}

हब में केवल मॉडल ही नहीं हैं; इसमें कई अलग-अलग भाषाओं में कई डेटासेट भी हैं। आप [यहां](https://huggingface.co/datasets) डेटासेट ब्राउज़ कर सकते हैं, और हम अनुशंसा करते हैं कि आप इस अनुभाग को पढ़ने के बाद एक नए डेटासेट को लोड और संसाधित करने का प्रयास करें ([यहां](https://huggingface.co/docs/datasets/loading) सामान्य दस्तावेज देखें)। लेकिन अभी के लिए, आइए MRPC डेटासेट पर ध्यान दें! यह [GLUE बेंचमार्क](https://gluebenchmark.com/) की रचना करने वाले 10 डेटासेट में से एक है, जो एक अकादमिक बेंचमार्क है जिसका उपयोग 10 अलग-अलग पाठ वर्गीकरण कार्यों में ML मॉडल के प्रदर्शन को मापने के लिए किया जाता है।

🤗 डेटासेट लाइब्रेरी एक बहुत ही सरल कमांड प्रदान करती है हब पर डेटासेट को डाउनलोड और कैश करने के लिए। हम MRPC डेटासेट को इस तरह डाउनलोड कर सकते हैं:

<Tip>
⚠️ **चेतावनी** सुनिश्चित करें कि `datasets` स्थापित है। इसके लिए `pip install datasets` चलाएँ। फिर, MRPC डेटासेट को लोड करें और देखें कि इसमें क्या है।
</Tip>

```py
from datasets import load_dataset

raw_datasets = load_dataset("glue", "mrpc")
raw_datasets
```

```python out
DatasetDict({
    train: Dataset({
        features: ['sentence1', 'sentence2', 'label', 'idx'],
        num_rows: 3668
    })
    validation: Dataset({
        features: ['sentence1', 'sentence2', 'label', 'idx'],
        num_rows: 408
    })
    test: Dataset({
        features: ['sentence1', 'sentence2', 'label', 'idx'],
        num_rows: 1725
    })
})
```

जैसा कि आप देख सकते हैं, हमें एक `DatasetDict` वस्तु मिला जिसमें प्रशिक्षण सेट, सत्यापन सेट और परीक्षण सेट है। उनमें से प्रत्येक में कई कॉलम (`sentence1`, `sentence2`, `label`, और `idx`) और एक चर पंक्तियों की संख्या, जो प्रत्येक सेट में तत्वों की संख्या है (तो, वाक्यों के 3,668 जोड़े प्रशिक्षण सेट में, 408 सत्यापन सेट में, और परीक्षण सेट में 1,725 है)।

यह कमांड डेटासेट को डाउनलोड और कैश करता हैं, जो डिफ़ॉल्ट रूप से इस जगह मे *~/.cache/huggingface/dataset* जाता हैं। अध्याय 2 से याद करें कि आप `HF_HOME` पर्यावरण चर सेट करके अपने कैशे फ़ोल्डर को अनुकूलित कर जगह बदल सकते हैं।

हम अपने `raw_datasets` वस्तु में वाक्यों की प्रत्येक जोड़ी को अनुक्रमणित करके अभिगम कर सकते हैं, जैसे किसी शब्दकोश के साथ:

```py
raw_train_dataset = raw_datasets["train"]
raw_train_dataset[0]
```

```python out
{'idx': 0,
 'label': 1,
 'sentence1': 'Amrozi accused his brother , whom he called " the witness " , of deliberately distorting his evidence .',
 'sentence2': 'Referring to him as only " the witness " , Amrozi accused his brother of deliberately distorting his evidence .'}
```

हम देख सकते हैं कि लेबल पहले से ही पूर्णांक हैं, इसलिए हमें वहां कोई पूर्व प्रसंस्करण नहीं करना होगा। यह जानने के लिए कि कौन सा पूर्णांक किस लेबल से मेल खाता है, हम अपने `raw_train_dataset` की `features` का निरीक्षण कर सकते हैं। यह हमें प्रत्येक कॉलम का प्रकार बताएगा:

```py
raw_train_dataset.features
```

```python out
{'sentence1': Value(dtype='string', id=None),
 'sentence2': Value(dtype='string', id=None),
 'label': ClassLabel(num_classes=2, names=['not_equivalent', 'equivalent'], names_file=None, id=None),
 'idx': Value(dtype='int32', id=None)}
```

परदे के पीछे, `label` प्रकार `ClassLabel` का है, और पूर्णांक का लेबल नाम से मानचित्रण *names* फ़ोल्डर में संग्रहित किया जाता है। `0` मेल खाता है `not_equivalent` से, और `1` मेल खाता है `equivalent` से।

<Tip>

✏️ **कोशिश करके देखे!** प्रशिक्षण सेट के तत्व 15 और सत्यापन सेट के तत्व 87 को देखें। उनके लेबल क्या हैं?

</Tip>

### डेटासेट का पूर्वप्रक्रमण करना

{#if fw === 'pt'}
<Youtube id="0u3ioSwev3s"/>
{:else}
<Youtube id="P-rZWqcB6CE"/>
{/if}

डेटासेट को पूर्व संसाधित करने के लिए, हमें टेक्स्ट को उन नंबरों में बदलने की जरूरत है, जिन्हें मॉडल समझ सकता है। जैसा कि आपने [पिछले अध्याय](/course/chapter2) में देखा, यह एक टोकननाइज़र के साथ किया जाता है। हम टोकननाइज़र मे एक वाक्य या वाक्यों की एक सूची डाल सकते हैं, ताकि हम सीधे सभी पहले वाक्यों और सभी दूसरे वाक्यों की प्रत्येक जोड़ी को टोकननाइज कर सके इस तरह से :

```py
from transformers import AutoTokenizer

checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
tokenized_sentences_1 = tokenizer(raw_datasets["train"]["sentence1"])
tokenized_sentences_2 = tokenizer(raw_datasets["train"]["sentence2"])
```

हालाँकि, हम केवल दो अनुक्रमों को मॉडल में पारित नहीं कर सकते और प्रिडिक्शन कर सकते कि दो वाक्य पैराफ्रेश हैं या नहीं। हमें दो अनुक्रमों को एक जोड़ी के रूप में संभालने की जरूरत है, और उपयुक्त पूर्व प्रसंस्करण लागू करना है। सौभाग्य से, टोकननाइज़र अनुक्रमों की जोड़ी भी ले सकता है और इसे हमारे BERT मॉडल की अपेक्षा के अनुसार तैयार कर सकता है: 

```py
inputs = tokenizer("This is the first sentence.", "This is the second one.")
inputs
```

```python out
{ 
  'input_ids': [101, 2023, 2003, 1996, 2034, 6251, 1012, 102, 2023, 2003, 1996, 2117, 2028, 1012, 102],
  'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
  'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
}
```

हमने [अध्याय 2](/course/chapter2) में `input_ids` और `attention_mask` कुंजियों पर चर्चा की, लेकिन हमने `token_type_ids` के बारे में बात नहीं की। इस उदाहरण में, यह कुंजी मॉडल को बताता है कि इनपुट का कौन सा हिस्सा पहला वाक्य है और कौन सा दूसरा वाक्य है।

<Tip>

✏️ **कोशिश करके देखे!** प्रशिक्षण सेट के तत्व 15 को लें और टोकननाइज करें दो वाक्यों को अलग-अलग और एक जोड़ी के रूप में। दोनों परिणामों में क्या अंतर है?

</Tip>

यदि हम `input_ids` के अंदर IDs को शब्दों में वापस व्याख्या करते हैं:

```py
tokenizer.convert_ids_to_tokens(inputs["input_ids"])
```

हमें मिलेगा:

```python out
['[CLS]', 'this', 'is', 'the', 'first', 'sentence', '.', '[SEP]', 'this', 'is', 'the', 'second', 'one', '.', '[SEP]']
```

तो हम देख सकते हैं कि मॉडल अपेक्षा करता है कि इनपुट का फॉर्म `[CLS] sentence1 [SEP] sentence2 [SEP]` का होगा जब दो वाक्य हों। इसे `token_type_ids` के साथ संरेखित करने से हमें यह मिलता है:

```python out
['[CLS]', 'this', 'is', 'the', 'first', 'sentence', '.', '[SEP]', 'this', 'is', 'the', 'second', 'one', '.', '[SEP]']
[      0,      0,    0,     0,       0,          0,   0,       0,      1,    1,     1,        1,     1,   1,       1]
```

जैसा कि आप देख सकते हैं, इनपुट के जो हिस्से `[CLS] sentence1 [SEP]` के अनुरूप है, उन सभी के पास टोकन टाइप आईडी है `0`, जबकि अन्य हिस्से, जो `sentence2 [SEP]` के अनुरूप है, सभी के पास एक टोकन टाइप आईडी है `1`।

ध्यान दें कि यदि आप एक अलग चेकपॉइंट का चयन करते हैं, तो जरूरी नहीं कि आपके टोकननाइज इनपुट में `token_type_ids` हों (उदाहरण के लिए, यदि आप DistilBERT मॉडल का उपयोग करते हैं तो वे वापस नहीं आते हैं)। उन्हें केवल तभी लौटाया जाता है जब मॉडल को पता चल जाएगा कि उनके साथ क्या करना है, क्योंकि इसने उन्हें अपने पूर्व प्रशिक्षण के दौरान देखा है। 

यहां, BERT को टोकन टाइप आईडी के साथ पूर्व प्रशिक्षित किया गया है, और नकाबपोश भाषा मॉडलिंग का उद्देश्य जिसकी हमने [अध्याय 1](/course/chapter1) में बात की थी के शीर्ष पर, इसका एक अतिरिक्त उद्देश्य है जिसे _अगले वाक्य पूर्वानुमान_ कहा जाता है। इस कार्य का लक्ष्य वाक्यों के जोड़े के बीच संबंध को मॉडल करना है।

अगले वाक्य पूर्वानुमान के साथ, मॉडल को वाक्यों के जोड़े (बेतरतीब ढंग से नकाबपोश टोकन के साथ) प्रदान किए जाते हैं और पूछा जाता है कि पूर्वानुमान लगाओ कि क्या दूसरा वाक्य पहले का अनुसरण करता है। कार्य को गैर-तुच्छ बनाने के लिए, आधे समय में वाक्य एक-दूसरे का अनुसरण करते हैं मूल दस्तावेज़ में, और दूसरे आधे समय में दो वाक्य दो अलग-अलग दस्तावेज़ों से आते हैं। 

सामान्य तौर पर, आपको इस बारे में चिंता करने की आवश्यकता नहीं है कि आपके टोकननाइज़ड इनपुट में `token_type_ids` हैं या नहीं: जब तक आप टोकननाइज़र और मॉडल के लिए एक ही चेकपॉइंट का उपयोग करते हैं, तब तक सब कुछ ठीक रहेगा क्योंकि टोकननाइज़र जानता है कि उसके मॉडल को क्या प्रदान करना है।

अब जब हमने देखा कि कैसे हमारा टोकननाइज़र वाक्यों की एक जोड़ी से निपटता है, हम इसका उपयोग अपने पूरे डेटासेट को टोकननाइज़ करने के लिए कर सकते हैं: [पिछले अध्याय](/course/chapter2) की तरह, हम टोकननाइज़र को पहले वाक्यों की सूची, फिर दूसरे वाक्यों की सूची देकर वाक्यों के जोड़े की सूची खिला सकते है। यह पैडिंग और ट्रंकेशन विकल्पों के साथ भी  संगत है जिसे हमने [अध्याय 2](/course/chapter2) में देखा था। इसलिए, प्रशिक्षण डेटासेट को पूर्व प्रसंस्करण करने का एक तरीका है:

```py
tokenized_dataset = tokenizer(
    raw_datasets["train"]["sentence1"],
    raw_datasets["train"]["sentence2"],
    padding=True,
    truncation=True,
)
```

यह अच्छी तरह से काम करता है, लेकिन इसमें एक शब्दकोश (साथ में हमारी कुंजी, `input_ids`, `attention_mask`, और `token_type_ids`, और मान जो सूचियों की सूचियां हैं) के लौटने का नुकसान है। यह केवल तभी काम करेगा जब आपके पास पर्याप्त RAM हो अपने पूरे डेटासेट को टोकननाइजेशन के दौरान स्टोर करने के लिए (जबकि 🤗 डेटासेट लाइब्रेरी के डेटासेट [अपाचे एरो](https://arrow.apache.org/) फाइलें हैं जो डिस्क पर संग्रहीत है, तो आप केवल उन सैम्पल्स को रखते हैं जिन्हें आप मेमोरी मे लोड करना चाहतें है)।

डेटा को डेटासेट के रूप में रखने के लिए, हम [`Dataset.map()`](https://huggingface.co/docs/datasets/package_reference/main_classes#datasets.Dataset.map) पद्धति का उपयोग करेंगे। अगर हमें सिर्फ टोकननाइजेशन की तुलना में अधिक पूर्व प्रसंस्करण की आवश्यकता होती है, तो यह हमें कुछ अधिक लचीलेपन की भी अनुमति देता है।  `map()` विधि डेटासेट के प्रत्येक तत्व पर एक फ़ंक्शन लागू करके काम करती है, तो चलिए एक फ़ंक्शन को परिभाषित करते हैं जो हमारे इनपुट को टोकननाइज़ करेगा :

```py
def tokenize_function(example):
    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)
```

यह फ़ंक्शन एक शब्दकोश लेता है (जैसे हमारे डेटासेट के आइटम) और `input_ids`, `attention_mask`, और `token_type_ids` कुंजियों के साथ एक नया शब्दकोश देता है। ध्यान दें कि यह तब भी काम करता है जब `example` शब्दकोश में कई सैम्पल्स हों (प्रत्येक कुंजी वाक्यों की सूची के रूप में) क्योंकि `टोकनाइज़र` वाक्यों के जोड़े की सूची पर काम करता है, जैसा कि पहले देखा गया था। यह हमें हमारे `map()` के कॉल में `batched=True` विकल्प का उपयोग करने की अनुमति देगा, जो टोकनाइजेशन को बहुत तेज करेगा। `टोकनाइज़र` को [🤗 टोकननाइज़रस](https://github.com/huggingface/tokenizers) लाइब्रेरी से टोकननाइज़र जो Rust में लिखा है द्वारा समर्थित किया जाता है। यह टोकननाइज़र बहुत तेज़ हो सकता है, लेकिन केवल तभी जब हम इसे एक साथ ढेर सारे इनपुट दें।

ध्यान दें कि हमने अभी के लिए अपने टोकननाइजेशन फ़ंक्शन में `पैडिंग` आर्गूमेन्ट को छोड़ दिया है। ऐसा इसलिए है क्योंकि सभी सैम्पल्स को अधिकतम लंबाई तक पैडिंग करना कुशल नहीं है: जब हम बैच बना रहे हों तो सैम्पल्स को पैड करना बेहतर होता है, क्योंकि तब हमें केवल उस बैच में अधिकतम लंबाई तक पैड करने की आवश्यकता होती है, और न कि पुरे डेटासेट मे अधिकतम लंबाई तक। यह बहुत समय और प्रसंस्करण शक्ति को बचा सकता है जब इनपुट में बहुत परिवर्तनशील लंबाई होती है! 

यहां बताया गया है कि हम अपने सभी डेटासेट पर एक बार में टोकननाइजेशन फ़ंक्शन कैसे लागू करते हैं। हम `batched=True` का उपयोग कर रहे है `map` को कॉल करने के लिए, इसलिए फ़ंक्शन हमारे डेटासेट के कई तत्वों पर एक साथ लागू होता है, न कि प्रत्येक तत्व पर अलग से। यह तेजी से पूर्व प्रसंस्करण की अनुमति देता है।

```py
tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
tokenized_datasets
```

🤗 डेटासेट लाइब्रेरी इस प्रसंस्करण को लागू करने के लिए , डेटासेट में नए फ़ील्ड जोड़ते है, जो प्रीप्रोसेसिंग फ़ंक्शन द्वारा लौटाए गए शब्दकोश में प्रत्येक कुंजी के लिए एक होता है:

```python out
DatasetDict({
    train: Dataset({
        features: ['attention_mask', 'idx', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'],
        num_rows: 3668
    })
    validation: Dataset({
        features: ['attention_mask', 'idx', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'],
        num_rows: 408
    })
    test: Dataset({
        features: ['attention_mask', 'idx', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'],
        num_rows: 1725
    })
})
```

आप बहुप्रक्रमण का भी उपयोग कर सकते हैं बस अपने पूर्व प्रसंस्करण फ़ंक्शन को `map()` के साथ लागू करते समय `num_proc` तर्क को पास करना है।  हमने यहां ऐसा नहीं किया क्योंकि 🤗 टोकनाइज़रस लाइब्रेरी पहले से ही हमारे सैम्पल्स को तेज़ी से टोकनाइज़ करने के लिए कई थ्रेड्स का उपयोग करती है, लेकिन यदि आप इस लाइब्रेरी द्वारा समर्थित तेज़ टोकनाइज़र का उपयोग नहीं कर रहे हैं, तो यह आपके पूर्व प्रसंस्करण को गति दे सकता है।

हमारा `tokenize_function` एक शब्दकोश `input_ids`, `attention_mask`, और `token_type_ids` कुंजियों के साथ देता है, इसलिए उन तीनो क्षेत्रों को हमारे डेटासेट के सभी विभाजनों में जोड़ दिया जाता है। ध्यान दें कि हम मौजूदा फ़ील्डस को भी बदल सकते थे यदि हमारे प्रीप्रोसेसिंग फ़ंक्शन ने डेटासेट में मौजूदा कुंजी के लिए एक नया मान लौटाया होता, जिस पर हमने `map()` लागू किया।

आखिरी चीज जो हमें करने की आवश्यकता होगी वह है सभी उदाहरणों को सबसे लंबे तत्व की लंबाई तक पैड करना जब हम तत्वों को एक साथ बैच करते हैं — यह एक तकनीक है जिसे हम *डायनामिक पैडिंग* के रूप में संदर्भित करते हैं।

### डायनामिक पैडिंग

<Youtube id="7q5NyFT8REg"/>

{#if fw === 'pt'}
जो फ़ंक्शन बैच के अंदर सैम्पल्स को एक साथ रखने के लिए जिम्मेदार हो उसे *collate function* कहा जाता है। यह एक आर्गूमेन्ट है जिसे आप एक `DataLoader` बनाते समय पारित कर सकते हैं, वरना एक ऐसा फ़ंक्शन है जो आपके सैम्पल्स को केवल PyTorch टेंसर में बदल देगा और उन्हें जोड़ देगा (पुनरावर्ती यदि आपके तत्व सूचियां, टुपल्स या शब्दकोश हैं)। हमारे मामले में यह संभव नहीं होगा क्योंकि हमारे पास जो इनपुट हैं वे सभी एक ही आकार के नहीं होंगे। हमने जानबूझकर पैडिंग को स्थगित कर दिया है, केवल इसे प्रत्येक बैच पर आवश्यक रूप से लागू करने के लिए और बहुत अधिक पैडिंग के साथ अधिक लंबे इनपुट से बचने के लिए। यह प्रशिक्षण को काफी तेज कर देगा, लेकिन ध्यान दें कि यदि आप TPU पर प्रशिक्षण कर रहे हैं तो यह समस्या पैदा कर सकता है — TPUs निश्चित आकार पसंद करते हैं, तब भी जब इसके लिए अतिरिक्त पैडिंग की आवश्यकता होती है।

{:else}

जो फ़ंक्शन बैच के अंदर सैम्पल्स को एक साथ रखने के लिए जिम्मेदार हो उसे *collate function* कहा जाता है। डिफ़ॉल्ट कोलेटर एक ऐसा फ़ंक्शन है जो आपके सैम्पल्स को tf.Tensor में बदल देगा और उन्हें जोड़ देगा (पुनरावर्ती यदि आपके तत्व सूचियां, टुपल्स या शब्दकोश हैं)। हमारे मामले में यह संभव नहीं होगा क्योंकि हमारे पास जो इनपुट हैं वे सभी एक ही आकार के नहीं होंगे। हमने जानबूझकर पैडिंग को स्थगित कर दिया है, केवल इसे प्रत्येक बैच पर आवश्यक रूप से लागू करने के लिए और बहुत अधिक पैडिंग के साथ अधिक लंबे इनपुट से बचने के लिए। यह प्रशिक्षण को काफी तेज कर देगा, लेकिन ध्यान दें कि यदि आप TPU पर प्रशिक्षण कर रहे हैं तो यह समस्या पैदा कर सकता है — TPUs निश्चित आकार पसंद करते हैं, तब भी जब इसके लिए अतिरिक्त पैडिंग की आवश्यकता होती है।

{/if}

व्यवहार में ऐसा करने के लिए, हमें एक कोलेट फ़ंक्शन को परिभाषित करना होगा जो उस डेटासेट के आइटम पर सही मात्रा में पैडिंग लागू करेगा जिसे हम एक साथ बैच बनाना हैं। सौभाग्य से, 🤗 ट्रान्सफ़ॉर्मर्स लाइब्रेरी हमें `DataCollatorWithPadding` के माध्यम से ऐसा फ़ंक्शन प्रदान करती है। जब आप इसे इन्स्टैन्शीऐट करते हैं तो यह एक टोकननाइज़र लेता है (यह जानने के लिए कि किस पैडिंग टोकन का उपयोग करना है, और क्या मॉडल को पैडिंग के बाईं ओर या इनपुट के दाईं ओर चाहिए) और वह सब कुछ करेगा जो आपको चाहिए:

{#if fw === 'pt'}
```py
from transformers import DataCollatorWithPadding

data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
```
{:else}
```py
from transformers import DataCollatorWithPadding

data_collator = DataCollatorWithPadding(tokenizer=tokenizer, return_tensors="tf")
```
{/if}

इस नए खिलौने का परीक्षण करने के लिए, आइए हमारे प्रशिक्षण सेट से कुछ सैम्पल्स लें जिन्हें हम एक साथ बैच बनाना चाहेंगे। यहां, हम कॉलम `idx`, `sentence1`, और `sentence2` को हटा देते हैं क्योंकि उनकी आवश्यकता नहीं होगी और इसमें स्ट्रिंग्स होंगे (और हम स्ट्रिंग्स के साथ टेंसर नहीं बना सकते) और आइये बैच में प्रत्येक प्रविष्टि की लंबाई पर एक नज़र डाले:

```py
samples = tokenized_datasets["train"][:8]
samples = {k: v for k, v in samples.items() if k not in ["idx", "sentence1", "sentence2"]}
[len(x) for x in samples["input_ids"]]
```

```python out
[50, 59, 47, 67, 59, 50, 62, 32]
```

कोई आश्चर्य नहीं, हमें 32 से 67 तक की अलग-अलग लंबाई के सैम्पल्स मिलते हैं। डायनेमिक पैडिंग का मतलब है कि इस बैच के सभी सैम्पल्स को 67 की लंबाई तक पैड किया जाना चाहिए, जो की सबसे अधिकतम लंबाई है बैच के अंदर की। डायनेमिक पैडिंग के बिना, सभी सैम्पल्स को पूरे डेटासेट में अधिकतम लंबाई तक या मॉडल द्वारा स्वीकार की जा सकने वाली अधिकतम लंबाई तक पैड करना होगा। आइए दोबारा जांचें कि हमारा  `data_collator` बैच को डायनेमिकली पैडिंग कर रहा है:

```py
batch = data_collator(samples)
{k: v.shape for k, v in batch.items()}
```

{#if fw === 'tf'}

```python out
{'attention_mask': TensorShape([8, 67]),
 'input_ids': TensorShape([8, 67]),
 'token_type_ids': TensorShape([8, 67]),
 'labels': TensorShape([8])}
```

{:else}

```python out
{'attention_mask': torch.Size([8, 67]),
 'input_ids': torch.Size([8, 67]),
 'token_type_ids': torch.Size([8, 67]),
 'labels': torch.Size([8])}
```

देखने में सही है! अब जबकि हम देख चुके है की हमारा मॉडल कच्चे टेक्स्ट से बैचस तक निपट सकता है, तो अब हम इसे फ़ाइन ट्यून करने के लिए तैयार हैं!

{/if}

<Tip>

✏️ **कोशिश करके देखे!** कोशिश करके देखे! GLUE SST-2 डेटासेट पर प्रीप्रोसेसिंग को दोहराएं। यह थोड़ा अलग है क्योंकि यह जोड़े के बजाय एकल वाक्यों से बना है, लेकिन बाकी जो हमने किया वो वैसा ही दिखना चाहिए। एक कठिन चुनौती के लिए, एक प्रीप्रोसेसिंग फ़ंक्शन लिखने का प्रयास करें जो किसी भी GLUE कार्यों पर काम करता हो।

</Tip>

{#if fw === 'tf'}

अब जब हमारे पास हमारे डेटासेट और डेटा कोलेटर हैं, तो हमें उन्हें एक साथ रखना है। हम मैन्युअल रूप से बैचस को लोड कर सकते हैं और उनका मिलान कर सकते हैं, लेकिन यह बहुत काम है, और शायद बहुत अच्छा प्रदर्शन करने वाला भी नहीं है। इसके बजाय, एक सरल विधि है जो इस समस्या का एक निष्पादक समाधान प्रदान करती है: `to_tf_dataset()`। यह एक वैकल्पिक कोलेशन फ़ंक्शन के साथ, आपके डेटासेट के चारों ओर एक `tf.data.Dataset` लपेट देगा। `tf.data.Dataset` एक देशी TensorFlow प्रारूप है जिसे Keras उपयोग करता है `model.fit()` के लिए, इसलिए यह एक विधि तुरंत 🤗 डेटासेट को एक प्रारूप में परिवर्तित कर देती है जो प्रशिक्षण के लिए तैयार है। आइए इसे अपने डेटासेट के साथ क्रिया में देखें!

```py
tf_train_dataset = tokenized_datasets["train"].to_tf_dataset(
    columns=["attention_mask", "input_ids", "token_type_ids"],
    label_cols=["labels"],
    shuffle=True,
    collate_fn=data_collator,
    batch_size=8,
)

tf_validation_dataset = tokenized_datasets["validation"].to_tf_dataset(
    columns=["attention_mask", "input_ids", "token_type_ids"],
    label_cols=["labels"],
    shuffle=False,
    collate_fn=data_collator,
    batch_size=8,
)
```

और बस! डेटा पूर्व प्रसंस्करण की कड़ी मेहनत के बाद हम उन डेटासेट को अगले व्याख्यान में आगे ले जा सकते हैं, जहां प्रशिक्षण सुखद रूप से सीधा होगा।

{/if}


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter3/2.mdx" />

### परिचय
https://huggingface.co/learn/course/hi/chapter2/1.md

# परिचय

<CourseFloatingBanner
    chapter={2}
    classNames="absolute z-10 right-0 top-0"
/>

जैसा कि आपने [अध्याय 1](/course/chapter1) में देखा, ट्रांसफार्मर मॉडल आमतौर पर बहुत बड़े होते हैं। लाखों से दसियों अरबों पैरामीटर्स के साथ, इन मॉडलों का प्रशिक्षण और डिप्लॉय करना एक पेचीदा उपक्रम है। इसके अलावा, नए मॉडल लगभग दैनिक आधार पर जारी किए जा रहे हैं और प्रत्येक का अपना कार्यान्वयन है, उन सभी को आज़माना कोई आसान काम नहीं है।

इस समस्या को हल करने के लिए 🤗 ट्रांसफॉर्मर्स लाइब्रेरी बनाई गई थी। इसका लक्ष्य एक एपीआई प्रदान करना है जिसके माध्यम से किसी भी ट्रांसफार्मर मॉडल को लोड, प्रशिक्षित और सेव किया जा सकता है। पुस्तकालय की मुख्य विशेषताएं हैं:

- **उपयोग में आसानी**: निष्कर्ष के लिए एक अत्याधुनिक एनएलपी मॉडल को डाउनलोड करना, लोड करना और उपयोग करना कोड की केवल दो पंक्तियों में किया जा सकता है।
- **सुविधाजनक**: उनके मूल में, सभी मॉडल सरल PyTorch `nn.Module` या TensorFlow `tf.keras.Model` वर्ग हैं और उनके संबंधित मशीन लर्निंग (ML) ढांचे में किसी भी अन्य मॉडल की तरह नियंत्रित किया जा सकता है।
- **सरलता**: पुस्तकालय में शायद ही कोई अमूर्तन किया गया हो। "ऑल इन वन फाइल" एक मुख्य अवधारणा है: एक मॉडल का फॉरवर्ड पास पूरी तरह से एक फाइल में परिभाषित किया जाता है, ताकि कोड स्वयं समझने योग्य और हैक करने योग्य हो।

यह अंतिम विशेषता 🤗 ट्रांसफॉर्मर को अन्य ML पुस्तकालयों से काफी अलग बनाती है। मॉडल उन मॉड्यूल पर नहीं बने हैं
जो फाइल्स के बीच शेयर होती हैं; इसके बजाय, प्रत्येक मॉडल की अपनी परतें होती हैं। मॉडलों को अधिक सुलभ और समझने योग्य बनाने के अलावा, यह आपको दूसरों को प्रभावित किए बिना एक मॉडल पर आसानी से परीक्षण करने देती है।

यह अध्याय एक एंड-टू-एंड उदाहरण के साथ शुरू होगा जहां हम [अध्याय 1](/course/chapter1) में पेश किए गए `pipeline()` फ़ंक्शन को दोहराने के लिए एक मॉडल और एक टोकननाइज़र का एक साथ उपयोग करते हैं। इसके बाद, हम मॉडल API पर चर्चा करेंगे: हम मॉडल और कॉन्फ़िगरेशन कक्षाओं को पढ़ेंगे, और आपको दिखाएंगे कि मॉडल को कैसे लोड किया जाए और यह आउटपुट पूर्वानुमानो के लिए संख्यात्मक इनपुट को कैसे संसाधित करता है।

फिर हम टोकननाइज़र API को देखेंगे, जो `pipeline()` फ़ंक्शन का अन्य मुख्य अंग है। टोकेनाइज़र पहले और अंतिम प्रसंस्करण चरणों का ध्यान रखते हैं, न्यूरल नेटवर्क के लिए पाठ से संख्यात्मक इनपुट में परिवर्तन को संभालते हैं, और आवश्यकता होने पर पाठ में परिवर्तन वापस करते हैं। अंत में, हम आपको दिखाएंगे कि एक तैयार बैच में एक मॉडल के माध्यम से कई वाक्यों को भेजने से कैसे निपटना है, फिर उच्च-स्तरीय `tokenizer()` फ़ंक्शन को करीब से  देखकर इसका अंत करेंगे।

<Tip>
⚠️ मॉडल हब और 🤗 ट्रांसफॉर्मर के साथ उपलब्ध सभी सुविधाओं का लाभ उठाने के लिए, हम <a href="https://huggingface.co/join">खाता बनाने</a> की अनुशंसा करते हैं।
</Tip>



<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter2/1.mdx" />

### परिचय
https://huggingface.co/learn/course/hi/chapter0/1.md

# परिचय

हगिंग फेस में आपका स्वागत है! यह परिचय कार्य वातावरण स्थापित करने में आपका मार्गदर्शन करेगा। यदि आप अभी पाठ्यक्रम शुरू कर रहे हैं, तो हम अनुशंसा करते हैं कि आप पहले [अध्याय 1](course/chapter1) पर एक नज़र डालें, फिर वापस आएं और अपना वातावरण सेट करें ताकि आप कोड को स्वयं आज़मा सकें।

इस पाठ्यक्रम में हम जिन सभी पुस्तकालयों का उपयोग करेंगे, वे पायथन पैकेज के रूप में उपलब्ध हैं, इसलिए यहां हम आपको दिखाएंगे कि पायथन वातावरण कैसे स्थापित करें और विशिष्ट पुस्तकालयों को स्थापित करें जिनकी आपको आवश्यकता होगी।

हम आपके कार्य परिवेश को स्थापित करने के दो तरीकों को कवर करेंगे, एक Colab नोटबुक या एक पायथन आभासी वातावरण का उपयोग करके। बेझिझक वह चुनें जो आपके साथ सबसे अधिक प्रतिध्वनित हो। शुरुआती लोगों के लिए, हम दृढ़ता से अनुशंसा करते हैं कि आप Colab नोटबुक का उपयोग करके शुरुआत करें।

ध्यान दें कि हम विंडोज सिस्टम को कवर नहीं करेंगे। यदि आप Windows पर चल रहे हैं, तो हम अनुशंसा करते हैं कि Colab नोटबुक का उपयोग करने के साथ-साथ अनुसरण करें। यदि आप Linux वितरण या macOS का उपयोग कर रहे हैं, तो आप यहाँ वर्णित किसी भी दृष्टिकोण का उपयोग कर सकते हैं।

अधिकांश पाठ्यक्रम आपके हगिंग फेस खाते पर निर्भर करता है। हम अभी एक बनाने की सलाह देते हैं: [एक खाता बनाएँ](https://huggingface.co/join)।

## Google Colab नोटबुक का उपयोग करना

Colab नोटबुक का उपयोग करना सबसे आसान संभव सेटअप है; अपने ब्राउज़र में एक नोटबुक बूट करें और सीधे कोडिंग पर जाएं!

यदि आप Colab से परिचित नहीं हैं, तो हम अनुशंसा करते हैं कि आप [परिचय](https://colab.research.google.com/notebooks/intro.ipynb) का पालन करके शुरुआत करें। Colab आपको GPU या TPU जैसे कुछ त्वरित हार्डवेयर का उपयोग करने की अनुमति देता है, और यह छोटे कार्यभार के लिए मुफ़्त है।

एक बार जब आप 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>

अगला चरण उन पुस्तकालयों को स्थापित करना है जिनका हम इस पाठ्यक्रम में उपयोग करेंगे। हम स्थापना के लिए `pip` का उपयोग करेंगे, जो कि पायथन के लिए पैकेज मैनेजर है। नोटबुक्स में, आप `!` वर्ण से पहले सिस्टम कमांड चला सकते हैं, इसलिए आप ट्रान्सफ़ॉर्मर लाइब्रेरी को निम्नानुसार स्थापित कर सकते हैं:
अगला चरण उन पुस्तकालयों को स्थापित करना है जिनका हम इस पाठ्यक्रम में उपयोग करेंगे। हम स्थापना के लिए `pip` का उपयोग करेंगे, जो कि पायथन के लिए पैकेज मैनेजर है। नोटबुक्स में, आप `!` वर्ण से पहले सिस्टम कमांड चला सकते हैं, इसलिए आप 🤗 ट्रान्सफ़ॉर्मर लाइब्रेरी को निम्नानुसार स्थापित कर सकते हैं:

```
!pip install transformers
```

आप यह सुनिश्चित कर सकते हैं कि पैकेज आपके पायथन रनटाइम के भीतर आयात करके सही ढंग से स्थापित किया गया है:

```
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>

यह 🤗 ट्रांसफॉर्मर का एक बहुत हल्का संस्करण स्थापित करता है। विशेष रूप से, कोई विशिष्ट मशीन लर्निंग फ्रेमवर्क (जैसे PyTorch या TensorFlow) स्थापित नहीं हैं। चूंकि हम पुस्तकालय की कई अलग-अलग विशेषताओं का उपयोग करेंगे, हम विकास संस्करण को स्थापित करने की सलाह देते हैं, जो किसी भी कल्पनाशील उपयोग के मामले के लिए सभी आवश्यक निर्भरताओं के साथ आता है:

```
!pip install transformers[sentencepiece]
```

इसमें थोड़ा समय लगेगा, लेकिन फिर आप बाकी पाठ्यक्रम के लिए तैयार हो जाएंगे।

## पायथन आभासी वातावरण का उपयोग करना

यदि आप एक पायथन आभासी वातावरण का उपयोग करना पसंद करते हैं, तो पहला कदम आपके सिस्टम पर पायथन को स्थापित करना है। हम आरंभ करने के लिए [इस गाइड](https://realpython.com/installing-python/) का पालन करने की सलाह देते हैं। 

एक बार जब आप पायथन स्थापित कर लेते हैं, तो आपको अपने टर्मिनल में पायथन आदेश चलाने में सक्षम होना चाहिए। अगले चरण पर आगे बढ़ने से पहले यह सुनिश्चित करने के लिए कि यह सही ढंग से स्थापित है, आप निम्न आदेश चलाकर प्रारंभ कर सकते हैं: `python --version`. यह आपके सिस्टम पर अब उपलब्ध पायथन संस्करण को प्रिंट करना चाहिए।

अपने टर्मिनल में पायथन आदेश चलाते समय, जैसे `python --version` आदेश को चलाने वाले प्रोग्राम को अपने सिस्टम में "main" पायथन के रूप में सोचना चाहिए। हम अनुशंसा करते हैं कि इस मुख्य स्थापना को किसी भी पैकेज से मुक्त रखें, और इसका उपयोग प्रत्येक एप्लिकेशन के लिए अलग वातावरण बनाने के लिए करें, जिस पर आप काम कर रहे हैं - इस तरह, प्रत्येक एप्लिकेशन की अपनी निर्भरताएं और पैकेज होंगे, और आपको अन्य एप्लिकेशन के साथ संभावित संगतता समस्याओं के बारे में चिंता करने की आवश्यकता नहीं होगी।

पायथन में यह [आभासी वातावरण](https://docs.python.org/3/tutorial/venv.html) के साथ किया जाता है, जो स्व-निहित निर्देशिका ट्री हैं जिनमें से प्रत्येक में एक विशेष पायथन संस्करण के साथ एक पायथन स्थापना होती है, जिसमें सभी पैकेजों के साथ एप्लिकेशन की आवश्यकता होती है। इस तरह के आभासी वातावरण का निर्माण कई अलग-अलग उपकरणों के साथ किया जा सकता है, लेकिन हम उस उद्देश्य के लिए आधिकारिक पायथन पैकेज का उपयोग करेंगे, जिसे कहा जाता है [`venv`](https://docs.python.org/3/library/venv.html#module-venv)।

सबसे पहले, एक निर्देशिका बनाएं जिसमें आप अपने आवेदन में रहना चाहते हैं - उदाहरण के लिए, आप अपनी होम निर्देशिका के मूल में *transformers-course* नामक एक नई निर्देशिका बनाना चाहेंगे:

```
mkdir ~/transformers-course
cd ~/transformers-course
```

इस निर्देशिका के अंदर, पायथन `venv` मॉड्यूल का उपयोग करके एक आभासी वातावरण बनाएं:

```
python3 -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
```

## निर्भरता स्थापित करना

Google Colab इंस्टेंस का उपयोग करने पर पिछले अनुभाग की तरह, अब आपको जारी रखने के लिए आवश्यक पैकेजों को स्थापित करने की आवश्यकता होगी। फिर से, आप `pip` पैकेज मैनेजर का उपयोग करके 🤗 ट्रांसफॉर्मर के विकास संस्करण को स्थापित कर सकते हैं:

```
pip install "transformers[sentencepiece]"
```

अब आप पूरी तरह से तैयार हैं!


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter0/1.mdx" />

### सारांश
https://huggingface.co/learn/course/hi/chapter1/9.md

# सारांश

<CourseFloatingBanner
    chapter={1}
    classNames="absolute z-10 right-0 top-0"
/>

इस अध्याय में, आपने देखा कि 🤗 ट्रांसफॉर्मर के उच्च-स्तरीय `पाइपलाइन ()` फ़ंक्शन का उपयोग करके विभिन्न प्राकृतिक भाषा प्रसंस्करण कार्यों को कैसे किया जाता है। आपने यह भी देखा कि हब में मॉडलों की खोज और उनका उपयोग कैसे करें, साथ ही सीधे अपने ब्राउज़र में मॉडलों का परीक्षण करने के लिए अनुमान API का उपयोग कैसे करें।

हमने चर्चा की कि ट्रांसफॉर्मर मॉडल उच्च स्तर पर कैसे काम करते हैं और ट्रांसफर लर्निंग और फाइन-ट्यूनिंग के महत्व के बारे में बात की। एक महत्वपूर्ण पहलू यह है कि आप पूर्ण आर्किटेक्चर या केवल एन्कोडर या डिकोडर का उपयोग कर सकते हैं, यह इस बात पर निर्भर करता है कि आप किस प्रकार के कार्य को हल करना चाहते हैं। निम्न तालिका इसे सारांशित करती है:

| मॉडल            | उदाहरण                                     | कार्य                                                                            |
|-----------------|--------------------------------------------|----------------------------------------------------------------------------------|
| एनकोडर         | ALBERT, BERT, DistilBERT, ELECTRA, RoBERTa | वाक्य वर्गीकरण, नामित इकाई मान्यता,  प्रश्न उत्तर निकालने वाला |
| डिकोडर         | CTRL, GPT, GPT-2, Transformer XL           | पाठ निर्माण                                                                  |
| एनकोडर-डिकोडर | BART, T5, Marian, mBART                    | संक्षिप्तीकरण, अनुवाद, प्रश्न उत्तर बनाना                        |


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter1/9.mdx" />

### एनकोडर मॉडल
https://huggingface.co/learn/course/hi/chapter1/5.md

# एनकोडर मॉडल

<CourseFloatingBanner
    chapter={1}
    classNames="absolute z-10 right-0 top-0"
/>

<Youtube id="MUqNwgPjJvQ" />

एन्कोडर मॉडल केवल ट्रांसफ़ॉर्मर मॉडल के एन्कोडर का उपयोग करते हैं। प्रत्येक चरण में, ध्यान की परतें प्रारंभिक वाक्य में सभी शब्दों तक पहुंच सकती हैं। इन मॉडलों को अक्सर "द्वि-दिशात्मक" ध्यान देने के रूप में वर्णित किया जाता है, और इन्हें अक्सर *ऑटो-एन्कोडिंग मॉडल* कहा जाता है।

इन मॉडलों का पूर्व-प्रशिक्षण आमतौर पर किसी दिए गए वाक्य को भ्रष्ट करने के लिए घूमता है (उदाहरण के लिए, इसमें यादृच्छिक शब्दों को मास्क करके) और प्रारंभिक वाक्य को खोजने या पुनर्निर्माण के साथ मॉडल को काम पर रखना।

एनकोडर मॉडल उन कार्यों के लिए सबसे उपयुक्त होते हैं जिनमें पूर्ण वाक्य की समझ की आवश्यकता होती है, जैसे वाक्य वर्गीकरण, नामित इकाई पहचान (और अधिक सामान्य शब्द वर्गीकरण), और निकालने वाले प्रश्न उत्तर।

मॉडल के इस परिवार के प्रतिनिधियों में शामिल हैं:

- [ALBERT](https://huggingface.co/transformers/model_doc/albert.html)
- [BERT](https://huggingface.co/transformers/model_doc/bert.html)
- [DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)
- [ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)
- [RoBERTa](https://huggingface.co/transformers/model_doc/roberta.html)


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter1/5.mdx" />

### परिचय
https://huggingface.co/learn/course/hi/chapter1/1.md

# परिचय

<CourseFloatingBanner
    chapter={1}
    classNames="absolute z-10 right-0 top-0"
/>

## 🤗 पाठ्यक्रम में आपका स्वागत है!

<Youtube id="00GKzGyWFEs" />

यह पाठ्यक्रम आपको [Hugging Face](https://huggingface.co) पारिस्थितिकी तंत्र - [🤗 ट्रान्सफ़ॉर्मर](https://github.com/huggingface/transformers), [🤗 डेटासेट](https://github.com/huggingface/datasets), [🤗 टोकनीज़र](https://github.com/huggingface/tokenizers), तथा [🤗 एक्सेलेरेट](https://github.com/huggingface/accelerate) - इसके साथ ही [हगिंग फेस हब](https://huggingface.co/models) पुस्तकालयों का उपयोग करके प्राकृतिक भाषा प्रसंस्करण (एनएलपी) के बारे में सिखाएगा। यह पूरी तरह से मुफ़्त है और विज्ञापनों के बिना है।

## क्या उम्मीद करें?

यहां पाठ्यक्रम का संक्षिप्त विवरण दिया गया है।

<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="Brief overview of the chapters of the course.">
    <img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/summary-dark.svg" alt="Brief overview of the chapters of the course.">
</div>

- अध्याय 1 से 4 🤗 ट्रान्सफ़ॉर्मर पुस्तकालय की मुख्य अवधारणाओं का परिचय प्रदान करते हैं। पाठ्यक्रम के इस भाग के अंत तक, आप इस बात से परिचित होंगे कि ट्रांसफार्मर मॉडल कैसे काम करते हैं और [हगिंग फेस हब](https://huggingface.co/models) से मॉडल का उपयोग करना जानते हैं, इसे ठीक करें। डेटासेट पर, और हब पर अपने परिणाम साझा करें!
- अध्याय 5 से 8 क्लासिक एनएलपी कार्यों में गोता लगाने से पहले 🤗 डेटासेट और 🤗 टोकनाइज़र की मूल बातें सिखाते हैं। इस भाग के अंत तक, आप सबसे आम एनएलपी समस्याओं से स्वयं निपटने में सक्षम होंगे।
- अध्याय 9 से 12 एनएलपी से आगे जाते हैं और यह पता लगाते हैं कि भाषा प्रसंस्करण और कंप्यूटर दृष्टि में कार्यों से निपटने के लिए ट्रांसफार्मर मॉडल का उपयोग कैसे किया जा सकता है। साथ ही, आप सीखेंगे कि अपने मॉडलों के डेमो कैसे बनाएं और साझा करें, और उन्हें उत्पादन परिवेशों के लिए अनुकूलित करें। इस भाग के अंत तक, आप (लगभग) किसी भी मशीन सीखने की समस्या के लिए 🤗 ट्रांसफॉर्मर लगाने के लिए तैयार होंगे!

यह पाठ्यक्रम के लिए:

* पायथन के अच्छे ज्ञान की आवश्यकता है
* प्रारंभिक गहन शिक्षण पाठ्यक्रम, जैसे [fast.ai के](https://www.fast.ai/) [कोडर्स के लिए प्रैक्टिकल डीप लर्निंग](https://course.fast.ai/) के बाद लेना बेहतर है। 
* पूर्व [PyTorch](https://pytorch.org/) या [TensorFlow](https://www.tensorflow.org/) ज्ञान की अपेक्षा नहीं करता है, हालांकि इनमें से किसी के साथ कुछ परिचित होने से मदद मिलेगी।

आपके द्वारा इस पाठ्यक्रम को पूरा करने के बाद, हम आपको DeepLearning.AI की [प्राकृतिक भाषा संसाधन विशेषज्ञता](https://www.coursera.org/specializations/natural-language-processing?utm_source=deeplearning-ai&utm_medium=institutes&utm_campaign=20211011-nlp-2-hugging_face-page-nlp-refresh) की जाँच करने की सलाह देते हैं। जो पारंपरिक NLP मॉडल जैसे कि Naive Bayes और LSTMs की एक विस्तृत श्रृंखला को कवर करता है, जो अच्छी तरह से जानने योग्य हैं!

## हम कौन हैं?

लेखक के बारे में:

**मैथ्यू कैरिगन** हगिंग फेस में मशीन लर्निंग इंजीनियर हैं। वह डबलिन, आयरलैंड में रहता है, और पहले Parse.ly में एक एमएल इंजीनियर के रूप में काम करता था और उससे पहले ट्रिनिटी कॉलेज डबलिन में पोस्ट-डॉक्टरेट शोधकर्ता के रूप में काम करता था। वह विश्वास नहीं कर सकता कि हम मौजूदा आर्किटेक्चर को स्केल करके एजीआई तक पहुंचने जा रहे हैं, लेकिन रोबोट अमरता की परवाह किए बिना उच्च उम्मीदें हैं।

**लिसेंड्रे डेब्यू** हगिंग फेस में एक मशीन लर्निंग इंजीनियर है और बहुत प्रारंभिक विकास चरणों के बाद से 🤗 ट्रांसफॉर्मर्स लाइब्रेरी पर काम कर रहा है। उनका उद्देश्य एक बहुत ही सरल एपीआई के साथ उपकरण विकसित करके एनएलपी को सभी के लिए सुलभ बनाना है।

**सिल्वेन गुगर** हगिंग फेस में एक रिसर्च इंजीनियर हैं और 🤗 ट्रान्सफ़ॉर्मर्स लाइब्रेरी के मुख्य अनुरक्षकों में से एक हैं। पहले वे fast.ai में एक शोध वैज्ञानिक थे, और उन्होंने _[डीप लर्निंग फॉर कोडर्स विद फास्टाई और पायटॉर्च](https://learning.oreilly.com/library/view/deep-learning-for/9781492045519/) का सह-लेखन किया जेरेमी हॉवर्ड के साथ। उनके शोध का मुख्य फोकस तकनीकों को डिजाइन और सुधार करके गहन शिक्षण को और अधिक सुलभ बनाने पर है जो मॉडल को सीमित संसाधनों पर तेजी से प्रशिक्षित करने की अनुमति देता है।

**मर्व नोयान** हगिंग फेस में एक डेवलपर एडवोकेट है, जो सभी के लिए मशीन लर्निंग का लोकतंत्रीकरण करने के लिए टूल विकसित करने और उनके आसपास सामग्री बनाने पर काम कर रहे है।

**ल्यूसिले शाॅलनियर** हगिंग फेस में एक मशीन लर्निंग इंजीनियर है, जो ओपन-सोर्स टूल के उपयोग का विकास और समर्थन करता है। वह सहयोगात्मक प्रशिक्षण और बिगसाइंस जैसे प्राकृतिक भाषा प्रसंस्करण के क्षेत्र में कई शोध परियोजनाओं में भी सक्रिय रूप से शामिल हैं।

**लुईस ट्यूनस्टाल** हगिंग फेस में एक मशीन लर्निंग इंजीनियर है, जो ओपन-सोर्स टूल विकसित करने और उन्हें व्यापक समुदाय के लिए सुलभ बनाने पर केंद्रित है। वह आगामी [ओ'रेली बुक ऑन ट्रांसफॉर्मर्स](https://www.oreilly.com/library/view/natural-language-processing/9781098136789/) के सह-लेखक भी हैं।

**लिंड्रो वॉन वेरा** हगिंग फेस की ओपन-सोर्स टीम में मशीन लर्निंग इंजीनियर हैं और आगामी [ओ'रेली बुक ऑन ट्रांसफॉर्मर्स](https://www.oreilly.com/library/view/natural-language-processing/9781098136789/) के सह-लेखक भी हैं। पूरे मशीन लर्निंग स्टैक में काम करके एनएलपी परियोजनाओं को उत्पादन में लाने के लिए उनके पास कई वर्षों का औद्योगिक अनुभव है।

क्या आप तैयार हैं? इस अध्याय में आप सीखेंगे:
* पाठ निर्माण और वर्गीकरण जैसे एनएलपी कार्यों को हल करने के लिए `pipeline()` फ़ंक्शन का उपयोग कैसे करें
* ट्रांसफार्मर आर्किटेक्चर के बारे में
* एन्कोडर, डिकोडर और एन्कोडर-डिकोडर आर्किटेक्चर के बीच अंतर कैसे करें और उपयोग करें


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter1/1.mdx" />

### ट्रांसफार्मर, वे क्या कर सकते हैं?
https://huggingface.co/learn/course/hi/chapter1/3.md

# ट्रांसफार्मर, वे क्या कर सकते हैं?

<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/hi/chapter1/section3.ipynb"},
    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/hi/chapter1/section3.ipynb"},
]} />

इस खंड में, हम देखेंगे कि ट्रांसफॉर्मर मॉडल क्या कर सकते हैं और 🤗 ट्रांसफॉर्मर्स लाइब्रेरी: `पाइपलाइन ()` फ़ंक्शन से हमारे पहले टूल का उपयोग कर सकते हैं।

<Tip>

👀 ऊपर दाईं ओर *Colab में खोलें* बटन देखें? इस अनुभाग के सभी कोड नमूनों के साथ Google Colab नोटबुक खोलने के लिए उस पर क्लिक करें। यह बटन कोड उदाहरणों वाले किसी भी अनुभाग में मौजूद होगा।

यदि आप उदाहरणों को स्थानीय रूप से चलाना चाहते हैं, तो हम <a href="/course/chapter0">सेटअप</a> पर एक नज़र डालने की अनुशंसा करते हैं।

</Tip>

## ट्रांसफॉर्मर हर जगह हैं!

पिछले अनुभाग में उल्लिखित सभी प्रकार के एनएलपी कार्यों को हल करने के लिए ट्रांसफार्मर मॉडल का उपयोग किया जाता है। हगिंग फेस और ट्रांसफॉर्मर मॉडल का उपयोग करने वाली कुछ कंपनियां और संगठन यहां दिए गए हैं, जो अपने मॉडल साझा करके समुदाय में वापस योगदान करते हैं:

<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/companies.PNG" alt="Companies using Hugging Face" width="100%">

[🤗 ट्रांसफॉर्मर्स लाइब्रेरी](https://github.com/huggingface/transformers) उन साझा मॉडलों को बनाने और उपयोग करने की कार्यक्षमता प्रदान करती है। [मॉडल हब](https://huggingface.co/models) में हजारों पूर्व-प्रशिक्षित मॉडल हैं जिन्हें कोई भी डाउनलोड और उपयोग कर सकता है। आप हब पर अपने स्वयं के मॉडल भी अपलोड कर सकते हैं!

<Tip>
 ⚠️ हगिंग फेस हब ट्रांसफॉर्मर मॉडल तक सीमित नहीं है। कोई भी किसी भी प्रकार के मॉडल या डेटासेट साझा कर सकता है! सभी उपलब्ध सुविधाओं का लाभ उठाने के लिए एक <a href="https://huggingface.co/join">हगिंगफेस खाता बनाएं!</a>
  </Tip>

ट्रांसफॉर्मर मॉडल हुड के तहत कैसे काम करते हैं, यह जानने से पहले, आइए कुछ उदाहरण देखें कि कुछ दिलचस्प प्राकृतिक भाषा प्रसंस्करण समस्याओं को हल करने के लिए उनका उपयोग कैसे किया जा सकता है।

## पाइपलाइनों के साथ काम करना

<Youtube id="tiZFewofSLM" />

🤗 ट्रान्सफ़ॉर्मर्स लाइब्रेरी में सबसे बुनियादी वस्तु `पाइपलाइन ()` फ़ंक्शन है। यह एक मॉडल को इसके आवश्यक प्रीप्रोसेसिंग और पोस्टप्रोसेसिंग चरणों से जोड़ता है, जिससे हम किसी भी टेक्स्ट को सीधे इनपुट कर सकते हैं और एक समझदार उत्तर प्राप्त कर सकते हैं:

```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}]
```

डिफ़ॉल्ट रूप से, यह पाइपलाइन एक विशेष पूर्व-प्रशिक्षित मॉडल का चयन करती है जिसे अंग्रेजी में भावना विश्लेषण के लिए ठीक किया गया है। जब आप `क्लासिफायर` ऑब्जेक्ट बनाते हैं तो मॉडल डाउनलोड और कैश किया जाता है। यदि आप कमांड को फिर से चलाते हैं, तो इसके बजाय कैश्ड मॉडल का उपयोग किया जाएगा और मॉडल को फिर से डाउनलोड करने की कोई आवश्यकता नहीं है।

जब आप किसी टेक्स्ट को पाइपलाइन में पास करते हैं तो इसमें तीन मुख्य चरण शामिल होते हैं:

1. पाठ को एक प्रारूप में पूर्वसंसाधित किया जाता है जिसे मॉडल समझ सकता है।
2. प्रीप्रोसेस्ड इनपुट मॉडल को पास कर दिए जाते हैं।
3. मॉडल की भविष्यवाणियां पोस्ट-प्रोसेस की जाती हैं, इसलिए आप उन्हें समझ सकते हैं।


वर्तमान में कुछ [उपलब्ध पाइपलाइन](https://huggingface.co/transformers/main_classes/pipelines.html) हैं:

- `feature-extraction` (पाठ का वेक्टर प्रतिनिधित्व प्राप्त करें)
- `fill-mask`
- `ner` (नामित इकाई मान्यता)
- `question-answering`
- `sentiment-analysis`
- `summarization`
- `text-generation`
- `translation`
- `zero-shot-classification`

आइए इनमें से कुछ पर एक नजर डालते हैं!

## जीरो-शॉट वर्गीकरण

हम एक अधिक चुनौतीपूर्ण कार्य से निपटने के साथ शुरू करेंगे जहां हमें उन ग्रंथों को वर्गीकृत करने की आवश्यकता है जिन्हें लेबल नहीं किया गया है। वास्तविक दुनिया की परियोजनाओं में यह एक सामान्य परिदृश्य है क्योंकि व्याख्या पाठ आमतौर पर समय लेने वाला होता है और इसके लिए डोमेन विशेषज्ञता की आवश्यकता होती है। इस उपयोग के मामले के लिए, 'शून्य-शॉट-वर्गीकरण' पाइपलाइन बहुत शक्तिशाली है: यह आपको यह निर्दिष्ट करने की अनुमति देती है कि वर्गीकरण के लिए कौन से लेबल का उपयोग करना है, इसलिए आपको पूर्व-प्रशिक्षित मॉडल के लेबल पर भरोसा करने की आवश्यकता नहीं है। आप पहले ही देख चुके हैं कि कैसे मॉडल उन दो लेबलों का उपयोग करके एक वाक्य को सकारात्मक या नकारात्मक के रूप में वर्गीकृत कर सकता है - लेकिन यह आपके द्वारा पसंद किए जाने वाले लेबल के किसी अन्य सेट का उपयोग करके टेक्स्ट को वर्गीकृत भी कर सकता है।

```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]}
```

```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]}
```

इस पाइपलाइन को _शून्य-शॉट_ कहा जाता है क्योंकि इसका उपयोग करने के लिए आपको अपने डेटा पर मॉडल को फ़ाइन-ट्यून करने की आवश्यकता नहीं है। यह आपके इच्छित लेबल की किसी भी सूची के लिए सीधे संभाव्यता स्कोर लौटा सकता है!

<Tip>
  
 ✏️ **कोशिश करके देखो!** अपने स्वयं के अनुक्रमों और लेबलों के साथ खेलें और देखें कि मॉडल कैसा व्यवहार करता है।
  
</Tip>

## पाठ निर्माण

अब देखते हैं कि कुछ पाठ उत्पन्न करने के लिए पाइपलाइन का उपयोग कैसे करें। यहां मुख्य विचार यह है कि आप एक संकेत प्रदान करते हैं और शेष पाठ उत्पन्न करके मॉडल इसे स्वतः पूर्ण कर देगा। यह प्रेडिक्टिव टेक्स्ट फीचर के समान है जो कई फोन पर पाया जाता है। पाठ निर्माण में यादृच्छिकता शामिल है, इसलिए यदि आपको नीचे दिखाए गए अनुसार समान परिणाम नहीं मिलते हैं तो यह सामान्य है।

```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>
  
✏️ **कोशिश करके देखो!** 15 शब्दों के दो वाक्य बनाने के लिए `num_return_sequences` और `max_length` तर्कों का उपयोग करें।
  
</Tip>

## हब से पाइपलाइन में किसी भी मॉडल का उपयोग करना

पिछले उदाहरणों में कार्य के लिए डिफ़ॉल्ट मॉडल का उपयोग किया गया था, लेकिन आप किसी विशिष्ट कार्य के लिए पाइपलाइन में उपयोग करने के लिए हब से एक विशेष मॉडल भी चुन सकते हैं - जैसे, टेक्स्ट जनरेशन। [मॉडल हब](https://huggingface.co/models) पर जाएं और उस कार्य के लिए केवल समर्थित मॉडल प्रदर्शित करने के लिए बाईं ओर संबंधित टैग पर क्लिक करें। आपको [इस](https://huggingface.co/models?pipeline_tag=text-generation) जैसे पेज पर पहुंचना चाहिए।

आइए [`distilgpt2`](https://huggingface.co/distilgpt2) मॉडल को आज़माएं! इसे पहले की तरह उसी पाइपलाइन में लोड करने का तरीका यहां दिया गया है:

```python
from transformers import pipeline

generator = pipeline("text-generation", model="distilgpt2")
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'}]
```

आप भाषा टैग पर क्लिक करके और किसी अन्य भाषा में पाठ उत्पन्न करने वाला मॉडल चुनकर मॉडल के लिए अपनी खोज को परिष्कृत कर सकते हैं। मॉडल हब में बहुभाषी मॉडल के लिए चौकियां भी शामिल हैं जो कई भाषाओं का समर्थन करती हैं।

एक बार जब आप उस पर क्लिक करके एक मॉडल का चयन करते हैं, तो आप देखेंगे कि एक विजेट है जो आपको इसे सीधे ऑनलाइन आज़माने में सक्षम बनाता है। इस प्रकार आप मॉडल को डाउनलोड करने से पहले उसकी क्षमताओं का शीघ्रता से परीक्षण कर सकते हैं।

<Tip>
  
 ✏️ **कोशिश करके देखो!** किसी अन्य भाषा के लिए टेक्स्ट जनरेशन मॉडल खोजने के लिए फ़िल्टर का उपयोग करें। विजेट के साथ खेलने के लिए स्वतंत्र महसूस करें और इसे पाइपलाइन में उपयोग करें!
  
</Tip>

## अनुमान एपीआई

हगिंग फेस [वेबसाइट](https://huggingface.co/) पर उपलब्ध इनफरेंस एपीआई का उपयोग करके सभी मॉडलों का सीधे आपके ब्राउज़र के माध्यम से परीक्षण किया जा सकता है। आप कस्टम टेक्स्ट इनपुट करके और इनपुट डेटा की मॉडल प्रक्रिया को देखकर सीधे इस पृष्ठ पर मॉडल के साथ खेल सकते हैं।

विजेट को शक्ति प्रदान करने वाला अनुमान एपीआई एक सशुल्क उत्पाद के रूप में भी उपलब्ध है, जो आपके वर्कफ़्लो के लिए ज़रूरत पड़ने पर काम आता है। अधिक विवरण के लिए [मूल्य निर्धारण पृष्ठ](https://huggingface.co/pricing) देखें।

## मास्क भरना

अगली पाइपलाइन जो आप आजमाएंगे वह है `फिल-मास्क`। इस कार्य का विचार किसी दिए गए पाठ में रिक्त स्थान को भरना है:

```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>` शब्द भरता है, जिसे अक्सर *मास्क टोकन* के रूप में संदर्भित किया जाता है। अन्य मुखौटा-भरने वाले मॉडलों में अलग-अलग मुखौटा टोकन हो सकते हैं, इसलिए अन्य मॉडलों की खोज करते समय उचित मुखौटा शब्द को सत्यापित करना हमेशा अच्छा होता है। इसे जांचने का एक तरीका विजेट में प्रयुक्त मुखौटा शब्द को देखकर है।

<Tip>

 ✏️ **कोशिश करके देखो!** हब पर `बर्ट-बेस-केस्ड` मॉडल खोजें और अनुमान एपीआई विजेट में इसके मुखौटा शब्द की पहचान करें। यह मॉडल उपरोक्त हमारे `पाइपलाइन` उदाहरण में वाक्य के लिए क्या भविष्यवाणी करता है?
  
</Tip>

## नामित इकाई मान्यता

नामांकित इकाई पहचान (एनईआर) एक ऐसा कार्य है जहां मॉडल को यह पता लगाना होता है कि इनपुट टेक्स्ट के कौन से हिस्से व्यक्तियों, स्थानों या संगठनों जैसी संस्थाओं से मेल खाते हैं। आइए एक उदाहरण देखें:

```python
from transformers import pipeline

ner = pipeline("ner", grouped_entities=True)
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}
]
```

यहां मॉडल ने सही ढंग से पहचाना कि सिल्वेन एक व्यक्ति (पीईआर), हगिंग फेस एक संगठन (ओआरजी), और ब्रुकलिन एक स्थान (एलओसी) है।

हम पाइपलाइन निर्माण फ़ंक्शन में विकल्प `grouped_entities=True` पास करते हैं ताकि पाइपलाइन को एक ही इकाई के अनुरूप वाक्य के हिस्सों को एक साथ फिर से समूहित करने के लिए कहा जा सके: यहां मॉडल ने एक ही संगठन के रूप में "हगिंग" और "फेस" को सही ढंग से समूहीकृत किया है, भले ही नाम में कई शब्द हों। वास्तव में, जैसा कि हम अगले अध्याय में देखेंगे, प्रीप्रोसेसिंग कुछ शब्दों को छोटे भागों में भी विभाजित करता है। उदाहरण के लिए, `सिल्वेन` को चार भागों में बांटा गया है: `S`, `##yl`, `##va`, और `##in`। प्रसंस्करण के बाद के चरण में, पाइपलाइन ने उन टुकड़ों को सफलतापूर्वक पुन: समूहित किया।

<Tip>
  
 ✏️ **कोशिश करके देखो!** अंग्रेजी में पार्ट-ऑफ-स्पीच टैगिंग (आमतौर पर पीओएस के रूप में संक्षिप्त) करने में सक्षम मॉडल के लिए मॉडल हब खोजें। यह मॉडल उपरोक्त उदाहरण में वाक्य के लिए क्या भविष्यवाणी करता है?
  
</Tip>

## प्रश्न उत्तर

'प्रश्न-उत्तर' पाइपलाइन किसी दिए गए संदर्भ से जानकारी का उपयोग करके प्रश्नों का उत्तर देती है:

```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'}
```

ध्यान दें कि यह पाइपलाइन दिए गए संदर्भ से जानकारी निकालकर काम करती है; यह उत्तर उत्पन्न नहीं करता है।

## संक्षिप्तीकरण

पाठ में संदर्भित महत्वपूर्ण पहलुओं के सभी (या अधिकतर) को रखते हुए पाठ को छोटे पाठ में कम करने का कार्य सारांशीकरण है। यहाँ एक उदाहरण है:

```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_en_to_fr"`), लेकिन सबसे आसान तरीका है उस मॉडल को चुनना जिसे आप [मॉडल हब](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>
  
✏️ **कोशिश करके देखो!** अन्य भाषाओं में अनुवाद मॉडल खोजें और पिछले वाक्य का कुछ भिन्न भाषाओं में अनुवाद करने का प्रयास करें।
  
</Tip>

अब तक दिखाई गई पाइपलाइनें ज्यादातर प्रदर्शनकारी उद्देश्यों के लिए हैं। वे विशिष्ट कार्यों के लिए प्रोग्राम किए गए थे और उनमें से विविधताएं नहीं कर सकते। अगले अध्याय में, आप सीखेंगे कि 'पाइपलाइन ()' फ़ंक्शन के अंदर क्या है और इसके व्यवहार को कैसे अनुकूलित किया जाए।


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter1/3.mdx" />

### डिकोडर मॉडल
https://huggingface.co/learn/course/hi/chapter1/6.md

# डिकोडर मॉडल

<CourseFloatingBanner
    chapter={1}
    classNames="absolute z-10 right-0 top-0"
/>

<Youtube id="d_ixlCubqQw" />

डिकोडर मॉडल केवल ट्रांसफॉर्मर मॉडल के डिकोडर का उपयोग करते हैं। प्रत्येक चरण में, किसी दिए गए शब्द के लिए ध्यान की परतें केवल वाक्य में उसके सामने स्थित शब्दों तक पहुंच सकती हैं। इन मॉडलों को अक्सर *स्वतः प्रतिगामी मॉडल* कहा जाता है।

डिकोडर मॉडल का पूर्व-प्रशिक्षण आमतौर पर वाक्य में अगले शब्द की भविष्यवाणी करने के इर्द-गिर्द घूमता है।

ये मॉडल टेक्स्ट जनरेशन से जुड़े कार्यों के लिए सबसे उपयुक्त हैं।

मॉडल के इस परिवार के प्रतिनिधियों में शामिल हैं:

- [CTRL](https://huggingface.co/transformers/model_doc/ctrl.html)
- [GPT](https://huggingface.co/docs/transformers/model_doc/openai-gpt)
- [GPT-2](https://huggingface.co/transformers/model_doc/gpt2.html)
- [Transformer XL](https://huggingface.co/transformers/model_doc/transfo-xl.html)


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter1/6.mdx" />

### अध्याय के अंत की प्रश्नोत्तरी
https://huggingface.co/learn/course/hi/chapter1/10.md

# अध्याय के अंत की प्रश्नोत्तरी

<CourseFloatingBanner
    chapter={1}
    classNames="absolute z-10 right-0 top-0"
/>

इस अध्याय में बहुत सारी जमीन शामिल है! यदि आप सभी विवरणों को नहीं समझ पाए हैं तो चिंता न करें; अगले अध्याय आपको यह समझने में मदद करेंगे कि चीजें हुड के तहत कैसे काम करती हैं।

लेकिन, आइए पहले यह जाँचें कि आपने इस अध्याय में क्या सीखा!

### 1. हब को एक्सप्लोर करें और `रॉबर्टा-लार्ज-एमएनली` चेकपॉइंट देखें। यह कौन सा कार्य करता है?

<Question
	choices={[
		{
			text: "संक्षेपण",
			explain: "<a href=\"https://huggingface.co/roberta-large-mnli\">roberta-large-mnli पेज</a> पर फिर से देखें।"
		},
		{
			text: "पाठ वर्गीकरण",
			explain: "अधिक सटीक रूप से, यह वर्गीकृत करता है कि क्या दो वाक्य तार्किक रूप से तीन लेबल (विरोधाभास, तटस्थ, प्रवेश) से जुड़े हुए हैं - एक कार्य जिसे <em>प्राकृतिक भाषा अनुमान</em> भी कहा जाता है।",
			correct: true
		},
		{
			text: "पाठ निर्माण",
			explain: "<a href=\"https://huggingface.co/roberta-large-mnli\">roberta-large-mnli पेज</a> पर फिर से देखें।"
		}
	]}
/>

### 2. निम्नलिखित कोड क्या लौटाएगा?

```py
from transformers import pipeline

ner = pipeline("ner", grouped_entities=True)
ner("My name is Sylvain and I work at Hugging Face in Brooklyn.")
```

<Question
	choices={[
		{
			text: "यह इस वाक्य के लिए \"सकारात्मक\" या \"नकारात्मक\" लेबल के साथ वर्गीकरण स्कोर लौटाएगा।",
			explain: "यह गलत है — यह एक <code>भावना-विश्लेषण</code> पाइपलाइन होगी।"
		},
		{
			text: "यह इस वाक्य को पूरा करने वाला एक उत्पन्न पाठ लौटाएगा।",
			explain: "यह गलत है — यह एक <code>टेक्स्ट-जनरेशन</code> पाइपलाइन होगी।",
		},
		{
			text: "यह व्यक्तियों, संगठनों या स्थानों का प्रतिनिधित्व करने वाले शब्दों को वापस कर देगा।",
			explain: "इसके अलावा, <code>grouped_entities=True</code> के साथ, यह एक ही इकाई से संबंधित शब्दों को एक साथ समूहित करेगा, जैसे \"हगिंग फेस\"।",
			correct: true
		}
	]}
/>

### 3. क्या प्रतिस्थापित करना चाहिए ... इस कोड नमूने में?

```py
from transformers import pipeline

filler = pipeline("fill-mask", model="bert-base-cased")
result = filler("...")
```

<Question
	choices={[
		{
			text: "यह &#60;mask> आपका इंतजार कर रहा है।",
			explain: "यह गलत है। <code>bert-base-cased</code> मॉडल कार्ड देखें और अपनी गलती का पता लगाने का प्रयास करें।"
		},
		{
			text: "यह [मास्क] आपका इंतजार कर रहा है।",
			explain: "सही! इस मॉडल का मास्क टोकन [MASK] है।",
			correct: true
		},
		{
			text: "यह आदमी तुम्हारा इंतजार कर रहा है।",
			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: "🤗 ट्रान्सफ़ॉर्मर पुस्तकालय हमेशा की तरह टूटा हुआ है।",
			explain: "हम इस उत्तर को एक टिप्पणी के साथ सम्मानित नहीं करेंगे!!"
		},
		{
			text: "इस पाइपलाइन को लंबे समय तक इनपुट की आवश्यकता है; यह बहुत छोटा है।",
			explain: "यह गलत है। ध्यान दें कि इस पाइपलाइन द्वारा संसाधित किए जाने पर एक बहुत लंबा टेक्स्ट छोटा कर दिया जाएगा।"
		}
	]}
/>

### 5. "ट्रांसफर लर्निंग" का क्या अर्थ है?

<Question
	choices={[
		{
			text: "एक पूर्व-प्रशिक्षित मॉडल के ज्ञान को उसी डेटासेट पर प्रशिक्षण देकर एक नए मॉडल में स्थानांतरित करना।",
			explain: "नहीं, यह एक ही मॉडल के दो संस्करण होंगे।"
		},
		{
			text: "पहले मॉडल के वजन के साथ दूसरे मॉडल को इनिशियलाइज़ करके एक पूर्व-प्रशिक्षित मॉडल के ज्ञान को एक नए मॉडल में स्थानांतरित करना।",
			explain: "सही: जब दूसरे मॉडल को एक नए कार्य के लिए प्रशिक्षित किया जाता है, तो यह पहले मॉडल के ज्ञान को *स्थानांतरित* करता है।",
			correct: true
		},
		{
			text: "पहले मॉडल के समान आर्किटेक्चर के साथ दूसरे मॉडल का निर्माण करके एक पूर्व-प्रशिक्षित मॉडल के ज्ञान को एक नए मॉडल में स्थानांतरित करना।",
			explain: "आर्किटेक्चर ठीक उसी तरह है जैसे मॉडल बनाया गया है; इस मामले में कोई ज्ञान साझा या स्थानांतरित नहीं किया गया है।"
		}
	]}
/>

### 6. सही या गलत? एक भाषा मॉडल को आमतौर पर इसके पूर्व-प्रशिक्षण के लिए लेबल की आवश्यकता नहीं होती है।

<Question
	choices={[
		{
			text: "सही",
			explain: "पूर्व-प्रशिक्षण आमतौर पर <em>स्व-पर्यवेक्षित</em> होता है, जिसका अर्थ है कि लेबल स्वचालित रूप से इनपुट से बनाए जाते हैं (जैसे अगले शब्द की भविष्यवाणी करना या कुछ नकाबपोश शब्दों को भरना)।",
			correct: true
		},
		{
			text: "गलत",
			explain: "यह सही उत्तर नहीं है।"
		}
	]}
/>

### 7. उस वाक्य का चयन करें जो "मॉडल," "वास्तुकला," और "वजन" शब्दों का सबसे अच्छा वर्णन करता है।

<Question
	choices={[
		{
			text: "यदि कोई मॉडल एक इमारत है, तो उसकी वास्तुकला खाका है और वजन अंदर रहने वाले लोग हैं।",
			explain: "इस रूपक के बाद, इमारत के निर्माण के लिए उपयोग की जाने वाली ईंटों और अन्य सामग्रियों का वजन होगा।"
		},
		{
			text: "वास्तुकला एक मॉडल के निर्माण के लिए एक नक्शा है और इसके भार मानचित्र पर दर्शाए गए शहर हैं।",
			explain: "इस रूपक के साथ समस्या यह है कि एक नक्शा आमतौर पर एक मौजूदा वास्तविकता का प्रतिनिधित्व करता है (फ्रांस में पेरिस नाम का केवल एक शहर है)। किसी दिए गए आर्किटेक्चर के लिए, कई वज़न संभव हैं।"
		},
		{
			text: "आर्किटेक्चर एक मॉडल बनाने के लिए गणितीय कार्यों का एक क्रम है और इसके भार वे फ़ंक्शन पैरामीटर हैं।",
			explain: "विभिन्न मापदंडों (वजन) का उपयोग करके विभिन्न मॉडलों के निर्माण के लिए गणितीय कार्यों (वास्तुकला) के एक ही सेट का उपयोग किया जा सकता है।",
			correct: true
		}
	]}
/>

### 8. आप जनरेट किए गए टेक्स्ट के साथ संकेतों को पूरा करने के लिए इनमें से किस प्रकार के मॉडल का उपयोग करेंगे?

<Question
	choices={[
		{
			text: "एक एन्कोडर मॉडल",
			explain: "एक एन्कोडर मॉडल पूरे वाक्य का प्रतिनिधित्व करता है जो वर्गीकरण जैसे कार्यों के लिए बेहतर अनुकूल है।"
		},
		{
			text: "एक डिकोडर मॉडल",
			explain: "डिकोडर मॉडल एक प्रॉम्प्ट से टेक्स्ट जनरेशन के लिए पूरी तरह से अनुकूल हैं।",
			correct: true
		},
		{
			text: "अनुक्रम-से-अनुक्रम मॉडल",
			explain: "अनुक्रम-से-अनुक्रम मॉडल उन कार्यों के लिए बेहतर अनुकूल हैं जहां आप इनपुट वाक्यों के संबंध में वाक्य उत्पन्न करना चाहते हैं, दिए गए संकेत नहीं।"
		}
	]}
/>

### 9. पाठों को सारांशित करने के लिए आप इनमें से किस प्रकार के मॉडल का उपयोग करेंगे?

<Question
	choices={[
		{
			text: "एक एन्कोडर मॉडल",
			explain: "एक एन्कोडर मॉडल पूरे वाक्य का प्रतिनिधित्व करता है जो वर्गीकरण जैसे कार्यों के लिए बेहतर अनुकूल है।"
		},
		{
			text: "एक डिकोडर मॉडल",
			explain: "डिकोडर मॉडल आउटपुट टेक्स्ट (सारांश की तरह) उत्पन्न करने के लिए अच्छे हैं, लेकिन उनके पास सारांशित करने के लिए संपूर्ण टेक्स्ट जैसे संदर्भ का फायदा उठाने की क्षमता नहीं है।"
		},
		{
			text: "अनुक्रम-से-अनुक्रम मॉडल",
			explain: "अनुक्रम-से-अनुक्रम मॉडल संक्षेप कार्य के लिए पूरी तरह उपयुक्त हैं।",
			correct: true
		}
	]}
/>

### 10. कुछ लेबल के अनुसार टेक्स्ट इनपुट को वर्गीकृत करने के लिए आप इनमें से किस प्रकार के मॉडल का उपयोग करेंगे?

<Question
	choices={[
		{
			text: "एक एन्कोडर मॉडल",
			explain: "एक एन्कोडर मॉडल पूरे वाक्य का प्रतिनिधित्व करता है जो वर्गीकरण जैसे कार्य के लिए पूरी तरह उपयुक्त है।",
			correct: true
		},
		{
			text: "एक डिकोडर मॉडल",
			explain: "डिकोडर मॉडल आउटपुट टेक्स्ट जेनरेट करने के लिए अच्छे होते हैं, न कि किसी वाक्य से किसी लेबल को निकालने के लिए।"
		},
		{
			text: "अनुक्रम-से-अनुक्रम मॉडल",
			explain: "अनुक्रम-से-अनुक्रम मॉडल उन कार्यों के लिए बेहतर अनुकूल हैं जहां आप एक इनपुट वाक्य के आधार पर पाठ उत्पन्न करना चाहते हैं, न कि एक लेबल।",
		}
	]}
/>

### 11. एक मॉडल में देखे गए पूर्वाग्रह के संभावित स्रोत क्या हो सकते हैं?

<Question
	choices={[
		{
			text: "मॉडल एक पूर्व-प्रशिक्षित मॉडल का एक परिष्कृत संस्करण है और इसने इससे अपना पूर्वाग्रह उठाया।",
			explain: "ट्रांसफर लर्निंग को लागू करते समय, इस्तेमाल किए गए पूर्व-प्रशिक्षित मॉडल में पूर्वाग्रह फाइन-ट्यून मॉडल में होता है।",
			correct: true
		},
		{
			text: "जिस डेटा पर मॉडल को प्रशिक्षित किया गया था वह पक्षपाती है।",
			explain: "यह पूर्वाग्रह का सबसे स्पष्ट स्रोत है, लेकिन केवल एक ही नहीं है।",
			correct: true
		},
		{
			text: "जिस मीट्रिक के लिए मॉडल को अनुकूलित किया गया था, वह पक्षपाती है।",
			explain: "मॉडल को प्रशिक्षित करने का तरीका पूर्वाग्रह का एक कम स्पष्ट स्रोत है। आपका मॉडल बिना किसी दूसरे विचार के, आपके द्वारा चुने गए किसी भी मीट्रिक के लिए आँख बंद करके अनुकूलन करेगा।",
			correct: true
		}
	]}
/>


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter1/10.mdx" />

### पूर्वाग्रह और सीमाएं
https://huggingface.co/learn/course/hi/chapter1/8.md

# पूर्वाग्रह और सीमाएं

<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/hi/chapter1/section8.ipynb"},
    {label: "Aws Studio", value: "https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/hi/chapter1/section8.ipynb"},
]} />

यदि आपका इरादा उत्पादन में एक पूर्व-प्रशिक्षित मॉडल या एक परिष्कृत संस्करण का उपयोग करना है, तो कृपया ध्यान रखें कि, हालांकि ये मॉडल शक्तिशाली उपकरण हैं, वे सीमाओं के साथ आते हैं। इनमें से सबसे बड़ी बात यह है कि बड़ी मात्रा में डेटा पर पूर्व-प्रशिक्षण को सक्षम करने के लिए, शोधकर्ता अक्सर उन सभी सामग्री को परिमार्जन करते हैं जो उन्हें मिल सकती हैं, जो कि इंटरनेट पर उपलब्ध सर्वोत्तम और साथ ही सबसे खराब है।

एक त्वरित उदाहरण देने के लिए, आइए BERT मॉडल के साथ `फिल-मास्क` पाइपलाइन के उदाहरण पर वापस जाएं:

```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']
```

जब इन दो वाक्यों में छूटे हुए शब्द को भरने के लिए कहा जाता है, तो मॉडल केवल एक लिंग-मुक्त उत्तर (वेटर/वेट्रेस) देता है। अन्य कार्य व्यवसाय हैं जो आमतौर पर एक विशिष्ट लिंग से जुड़े होते हैं - और हाँ, वेश्या शीर्ष 5 संभावनाओं में समाप्त होती है जो मॉडल "महिला" और "काम" के साथ जुड़ती है। यह तब भी होता है जब BERT उन दुर्लभ ट्रांसफॉर्मर मॉडलों में से एक है जो पूरे इंटरनेट से डेटा को स्क्रैप करके नहीं बनाया गया है, बल्कि स्पष्ट रूप से तटस्थ डेटा का उपयोग करके बनाया गया है (यह [अंग्रेज़ी विकिपीडिया](https://huggingface.co/datasets/wikipedia) पर प्रशिक्षित है। ) और [बुककॉर्पस](https://huggingface.co/datasets/bookcorpus) डेटासेट)।

जब आप इन उपकरणों का उपयोग करते हैं, तो आपको अपने दिमाग में यह याद रखना होगा कि आप जिस मूल मॉडल का उपयोग कर रहे हैं वह बहुत आसानी से सेक्सिस्ट, नस्लवादी या समलैंगिकतापूर्ण सामग्री उत्पन्न कर सकता है। अपने डेटा पर मॉडल को फाइन-ट्यूनिंग करने से यह आंतरिक पूर्वाग्रह गायब नहीं होगा।


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter1/8.mdx" />

### ट्रांसफॉर्मर कैसे काम करते हैं?
https://huggingface.co/learn/course/hi/chapter1/4.md

# ट्रांसफॉर्मर कैसे काम करते हैं?

<CourseFloatingBanner
    chapter={1}
    classNames="absolute z-10 right-0 top-0"
/>

इस खंड में, हम ट्रांसफॉर्मर मॉडल की वास्तुकला पर एक उच्च-स्तरीय नज़र डालेंगे।

## ट्रांसफार्मर का थोड़ा सा इतिहास

ट्रांसफॉर्मर मॉडल के (संक्षिप्त) इतिहास में कुछ संदर्भ बिंदु यहां दिए गए हैं:

<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="A brief chronology of Transformers models.">
<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/transformers_chrono-dark.svg" alt="A brief chronology of Transformers models.">
</div>

[ट्रांसफॉर्मर आर्किटेक्चर](https://arxiv.org/abs/1706.03762) को जून 2017 में पेश किया गया था। मूल शोध का फोकस अनुवाद कार्यों पर था। इसके बाद कई प्रभावशाली मॉडल पेश किए गए, जिनमें शामिल हैं:

- **जून 2018**: [GPT](https://cdn.openai.com/research-covers/language-unsupervised/language_understanding_paper.pdf), पहला पूर्व प्रशिक्षित ट्रांसफॉर्मर मॉडल, जिसका उपयोग विभिन्न प्राकृतिक भाषा प्रसंस्करण कार्यों पर फाइन-ट्यूनिंग के लिए किया जाता है और राज्य का प्राप्त किया जाता है- कला परिणाम।
- **अक्टूबर 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**: [DistilBERT](https://arxiv.org/abs/1910.01108), BERT का एक डिस्टिल्ड संस्करण जो 60% तेज, मेमोरी में 40% हल्का है, और अभी भी BERT के प्रदर्शन का 97% बरकरार रखता है।
-  **अक्टूबर 2019**: [BART](https://arxiv.org/abs/1910.13461) और [T5](https://arxiv.org/abs/1910.10683), दो बड़े पूर्व-प्रशिक्षित मॉडल जो मूल ट्रांसफॉर्मर मॉडल के समान आर्किटेक्चर का उपयोग करते हैं ( ऐसा करने वाले पहले संस्करण)।
-  **मई 2020**: [GPT-3](https://arxiv.org/abs/2005.14165), GPT-2 का और भी बड़ा संस्करण जो फाइन-ट्यूनिंग की आवश्यकता के बिना विभिन्न कार्यों पर अच्छा प्रदर्शन करने में सक्षम है (जिसे _जीरो शॉट लर्निंग_ कहा जाता है)।

यह सूची व्यापक से बहुत दूर है और केवल कुछ विभिन्न प्रकार के ट्रांसफार्मर मॉडल को उजागर करने के लिए है। मोटे तौर पर उन्हें तीन श्रेणियों में बांटा जा सकता है:

- GPT- जैसा (जिसे _auto-regressive_ Transformer मॉडल भी कहा जाता है)
- BERT- जैसा (जिसे _auto-encoding_ Transformer मॉडल भी कहा जाता है)
- BART/T5- जैस (जिसे _अनुक्रम-से-अनुक्रम_ट्रांसफॉर्मर मॉडल भी कहा जाता है)

हम इन परिवारों के बारे में बाद में और गहराई से जानेंगे।

## ट्रांसफॉर्मर भाषा मॉडल हैं

ऊपर वर्णित सभी ट्रांसफार्मर मॉडल (जीपीटी, बीईआरटी, बार्ट, टी5, आदि) को *भाषा मॉडल* के रूप में प्रशिक्षित किया गया है। इसका मतलब है कि उन्हें स्व-निगरानी फैशन में बड़ी मात्रा में कच्चे पाठ पर प्रशिक्षित किया गया है। स्व-पर्यवेक्षित शिक्षण एक प्रकार का प्रशिक्षण है जिसमें मॉडल के इनपुट से उद्देश्य की स्वचालित रूप से गणना की जाती है। इसका मतलब है कि मनुष्यों को डेटा लेबल करने की आवश्यकता नहीं है!

इस प्रकार का मॉडल उस भाषा की सांख्यिकीय समझ विकसित करता है जिस पर इसे प्रशिक्षित किया गया है, लेकिन यह विशिष्ट व्यावहारिक कार्यों के लिए बहुत उपयोगी नहीं है। इस वजह से, सामान्य पूर्व-प्रशिक्षित मॉडल तब *ट्रांसफर लर्निंग* नामक प्रक्रिया से गुजरता है। इस प्रक्रिया के दौरान, मॉडल को पर्यवेक्षित तरीके से ठीक-ठीक ट्यून किया जाता है - अर्थात, मानव-एनोटेटेड लेबल का उपयोग करके - किसी दिए गए कार्य पर।

कार्य का एक उदाहरण *n* पिछले शब्दों को पढ़कर वाक्य में अगले शब्द की भविष्यवाणी करना है। इसे *कारण भाषा मॉडलिंग* कहा जाता है क्योंकि आउटपुट अतीत और वर्तमान इनपुट पर निर्भर करता है, लेकिन भविष्य के इनपुट पर नहीं।

<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="Example of causal language modeling in which the next word from a sentence is predicted.">
<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/causal_modeling-dark.svg" alt="Example of causal language modeling in which the next word from a sentence is predicted.">
</div>

एक अन्य उदाहरण *मुखौटा भाषा मॉडलिंग* है, जिसमें मॉडल वाक्य में एक नकाबपोश शब्द की भविष्यवाणी करता है।

<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="Example of masked language modeling in which a masked word from a sentence is predicted.">
<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/masked_modeling-dark.svg" alt="Example of masked language modeling in which a masked word from a sentence is predicted.">
</div>

## ट्रांसफॉर्मर हैं बड़े मॉडल

कुछ आउटलेयर (जैसे डिस्टिलबर्ट) के अलावा, बेहतर प्रदर्शन प्राप्त करने की सामान्य रणनीति मॉडल के आकार के साथ-साथ उन डेटा की मात्रा को बढ़ाकर है जिन पर वे पूर्व-प्रशिक्षित हैं।

<div class="flex justify-center">
<img src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/model_parameters.png" alt="Number of parameters of recent Transformers models" 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="The carbon footprint of a large language model.">
<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/carbon_footprint-dark.svg" alt="The carbon footprint of a large language model.">
</div>

<Youtube id="ftWlj4FBHTg"/>

और यह पूर्व-प्रशिक्षण के पर्यावरणीय प्रभाव को कम करने की कोशिश कर रही एक टीम द्वारा तैयार किए गए (बहुत बड़े के लिए) एक परियोजना दिखा रहा है। सर्वोत्तम हाइपरपैरामीटर प्राप्त करने के लिए बहुत सारे परीक्षण चलाने का पदचिह्न और भी अधिक होगा।

कल्पना कीजिए कि अगर हर बार एक शोध दल, एक छात्र संगठन, या कोई कंपनी किसी मॉडल को प्रशिक्षित करना चाहती है, तो उसने ऐसा शुरू से ही किया। इससे भारी, अनावश्यक वैश्विक लागत आएगी!

यही कारण है कि भाषा मॉडल साझा करना सर्वोपरि है: पहले से प्रशिक्षित वजन के ऊपर प्रशिक्षित वजन और निर्माण को साझा करना समग्र गणना लागत और समुदाय के कार्बन पदचिह्न को कम करता है।


## स्थानांतरण सीखना

<Youtube id="BqqfQnyjmgg" />

*पूर्व-प्रशिक्षण* एक मॉडल को खरोंच से प्रशिक्षित करने का कार्य है: वज़न को बेतरतीब ढंग से आरंभ किया जाता है, और प्रशिक्षण बिना किसी पूर्व ज्ञान के शुरू होता है।

<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="The pretraining of a language model is costly in both time and money.">
<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/pretraining-dark.svg" alt="The pretraining of a language model is costly in both time and money.">
</div>

यह पूर्व-प्रशिक्षण आमतौर पर बहुत बड़ी मात्रा में डेटा पर किया जाता है। इसलिए, इसके लिए बहुत अधिक डेटा की आवश्यकता होती है, और प्रशिक्षण में कई सप्ताह तक लग सकते हैं।

दूसरी ओर, *फाइन-ट्यूनिंग*, किसी मॉडल के पूर्व-प्रशिक्षित **होने के बाद** किया जाने वाला प्रशिक्षण है। फ़ाइन-ट्यूनिंग करने के लिए, आप पहले एक पूर्व-प्रशिक्षित भाषा मॉडल प्राप्त करते हैं, फिर अपने कार्य के लिए विशिष्ट डेटासेट के साथ अतिरिक्त प्रशिक्षण करते हैं। रुको - क्यों न केवल अंतिम कार्य के लिए सीधे प्रशिक्षण दिया जाए? वहाँ के लिए बहुत कारण है:

* पूर्व-प्रशिक्षित मॉडल को पहले से ही एक डेटासेट पर प्रशिक्षित किया गया था जिसमें फ़ाइन-ट्यूनिंग डेटासेट के साथ कुछ समानताएँ हैं। इस प्रकार फाइन-ट्यूनिंग प्रक्रिया प्रारंभिक मॉडल द्वारा पूर्व-प्रशिक्षण के दौरान प्राप्त ज्ञान का लाभ उठाने में सक्षम है (उदाहरण के लिए, प्राकृतिक भाषा प्रसंस्करण समस्याओं के साथ, पूर्व-प्रशिक्षित मॉडल को उस भाषा की किसी प्रकार की सांख्यिकीय समझ होगी जिसका आप उपयोग कर रहे हैं। आपका कार्य)।
* चूंकि पूर्व-प्रशिक्षित मॉडल पहले से ही बहुत सारे डेटा पर प्रशिक्षित था, इसलिए फाइन-ट्यूनिंग को अच्छे परिणाम प्राप्त करने के लिए बहुत कम डेटा की आवश्यकता होती है।
* उसी कारण से, अच्छे परिणाम प्राप्त करने के लिए आवश्यक समय और संसाधनों की मात्रा बहुत कम है।

उदाहरण के लिए, कोई व्यक्ति अंग्रेजी भाषा में प्रशिक्षित एक पूर्व-प्रशिक्षित मॉडल का लाभ उठा सकता है और फिर उसे एक आर्क्सिव कॉर्पस पर ठीक कर सकता है, जिसके परिणामस्वरूप विज्ञान/अनुसंधान-आधारित मॉडल बन सकता है। फाइन-ट्यूनिंग के लिए केवल सीमित मात्रा में डेटा की आवश्यकता होगी: पूर्व-प्रशिक्षित मॉडल ने जो ज्ञान हासिल किया है वह "स्थानांतरित" है, इसलिए शब्द *ट्रांसफर लर्निंग*।

<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="The fine-tuning of a language model is cheaper than pretraining in both time and money.">
<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/finetuning-dark.svg" alt="The fine-tuning of a language model is cheaper than pretraining in both time and money.">
</div>

एक मॉडल को फाइन-ट्यूनिंग, इसलिए कम समय, डेटा, वित्तीय और पर्यावरणीय लागत है। विभिन्न फाइन-ट्यूनिंग योजनाओं पर पुनरावृति करना भी तेज और आसान है, क्योंकि प्रशिक्षण पूर्ण पूर्व-प्रशिक्षण की तुलना में कम विवश है।

यह प्रक्रिया खरोंच से प्रशिक्षण की तुलना में बेहतर परिणाम प्राप्त करेगी (जब तक कि आपके पास बहुत अधिक डेटा न हो), यही कारण है कि आपको हमेशा पूर्व-प्रशिक्षित मॉडल का लाभ उठाने का प्रयास करना चाहिए - जो आपके हाथ में काम के जितना करीब हो सके - और इसे फाइन-ट्यून करें।

## सामान्य वास्तुकला

इस खंड में, हम ट्रान्सफ़ॉर्मर मॉडल की सामान्य संरचना के बारे में जानेंगे। यदि आप कुछ अवधारणाओं को नहीं समझते हैं, तो चिंता न करें; बाद में प्रत्येक घटक को कवर करने वाले विस्तृत खंड हैं।

<Youtube id="H39Z_720T5s" />

## परिचय

मॉडल मुख्य रूप से दो ब्लॉकों से बना है:

* **एनकोडर (बाएं)**: एन्कोडर इनपुट प्राप्त करता है और इसका प्रतिनिधित्व करता है (इसकी विशेषताएं)। इसका मतलब है कि इनपुट से समझ हासिल करने के लिए मॉडल को अनुकूलित किया गया है।
* **डिकोडर (दाएं)**: लक्ष्य अनुक्रम उत्पन्न करने के लिए डिकोडर अन्य इनपुट के साथ एन्कोडर के प्रतिनिधित्व (सुविधाओं) का उपयोग करता है। इसका मतलब है कि मॉडल आउटपुट उत्पन्न करने के लिए अनुकूलित है।

<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="Architecture of a Transformers models">
<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/transformers_blocks-dark.svg" alt="Architecture of a Transformers models">
</div>

इनमें से प्रत्येक भाग का उपयोग कार्य के आधार पर स्वतंत्र रूप से किया जा सकता है:

* **केवल-एनकोडर मॉडल**: उन कार्यों के लिए अच्छा है जिनके लिए इनपुट की समझ की आवश्यकता होती है, जैसे वाक्य वर्गीकरण और नामित इकाई पहचान।
* **केवल डिकोडर मॉडल**: पाठ निर्माण जैसे जनरेटिव कार्यों के लिए अच्छा है।
* **एनकोडर-डिकोडर मॉडल** or **अनुक्रम-से-अनुक्रम मॉडल**: Good for generative tasks that require an input, such as translation or summarization.

हम बाद के खंडों में स्वतंत्र रूप से उन वास्तुकलाओं में गोता लगाएँगे।

## ध्यान परतें

ट्रांसफार्मर मॉडल की एक प्रमुख विशेषता यह है कि वे विशेष परतों के साथ निर्मित होते हैं जिन्हें *ध्यान परत* कहा जाता है। वास्तव में, ट्रांसफॉर्मर आर्किटेक्चर को पेश करने वाले पेपर का शीर्षक था ["अटेंशन इज़ ऑल यू नीड"](https://arxiv.org/abs/1706.03762)! हम पाठ्यक्रम में बाद में ध्यान परतों के विवरण का पता लगाएंगे; अभी के लिए, आपको केवल यह जानने की जरूरत है कि यह परत मॉडल को आपके द्वारा पारित वाक्य में कुछ शब्दों पर विशेष ध्यान देने के लिए कहेगी (और कमोबेश दूसरों की उपेक्षा करें) प्रत्येक शब्द के प्रतिनिधित्व के साथ व्यवहार करते समय।

इसे संदर्भ में रखने के लिए, अंग्रेजी से फ्रेंच में पाठ का अनुवाद करने के कार्य पर विचार करें। इनपुट "आप इस पाठ्यक्रम को पसंद करते हैं" को देखते हुए, एक अनुवाद मॉडल को "पसंद" शब्द के लिए उचित अनुवाद प्राप्त करने के लिए आसन्न शब्द "यू" में भी भाग लेने की आवश्यकता होगी, क्योंकि फ्रेंच में क्रिया "पसंद" अलग-अलग संयुग्मित होती है पर निर्भर करता है विषय। हालाँकि, शेष वाक्य उस शब्द के अनुवाद के लिए उपयोगी नहीं है। उसी तरह, "इस" का अनुवाद करते समय मॉडल को "कोर्स" शब्द पर भी ध्यान देने की आवश्यकता होगी, क्योंकि "यह" अलग-अलग अनुवाद करता है जो इस बात पर निर्भर करता है कि संबंधित संज्ञा पुल्लिंग है या स्त्रीलिंग। फिर, वाक्य के दूसरे शब्द "इस" के अनुवाद के लिए कोई मायने नहीं रखेंगे। अधिक जटिल वाक्यों (और अधिक जटिल व्याकरण नियमों) के साथ, मॉडल को उन शब्दों पर विशेष ध्यान देने की आवश्यकता होगी जो प्रत्येक शब्द का ठीक से अनुवाद करने के लिए वाक्य में दूर दिखाई दे सकते हैं। 

प्राकृतिक भाषा से जुड़े किसी भी कार्य पर भी यही अवधारणा लागू होती है: एक शब्द का अपने आप में एक अर्थ होता है, लेकिन वह अर्थ संदर्भ से गहराई से प्रभावित होता है, जो शब्द के अध्ययन से पहले या बाद में कोई अन्य शब्द (या शब्द) हो सकता है।

अब जब आपको पता चल गया है कि ध्यान की परतें क्या हैं, तो आइए ट्रांसफॉर्मर आर्किटेक्चर पर करीब से नज़र डालें।

## मूल वास्तुकला

ट्रांसफॉर्मर आर्किटेक्चर मूल रूप से अनुवाद के लिए डिज़ाइन किया गया था। प्रशिक्षण के दौरान, एनकोडर एक निश्चित भाषा में इनपुट (वाक्य) प्राप्त करता है, जबकि डिकोडर वांछित लक्ष्य भाषा में समान वाक्य प्राप्त करता है। एनकोडर में, ध्यान की परतें एक वाक्य में सभी शब्दों का उपयोग कर सकती हैं (चूंकि, जैसा कि हमने अभी देखा, किसी दिए गए शब्द का अनुवाद इस बात पर निर्भर हो सकता है कि वाक्य में क्या है और इसके पहले क्या है)। हालाँकि, डिकोडर क्रमिक रूप से काम करता है और केवल उस वाक्य में शब्दों पर ध्यान दे सकता है जिसका उसने पहले ही अनुवाद किया है (इसलिए, वर्तमान में उत्पन्न होने वाले शब्द से पहले के शब्द)। उदाहरण के लिए, जब हमने अनुवादित लक्ष्य के पहले तीन शब्दों की भविष्यवाणी की है, तो हम उन्हें डिकोडर को देते हैं जो चौथे शब्द की भविष्यवाणी करने के लिए एन्कोडर के सभी इनपुट का उपयोग करता है।

प्रशिक्षण के दौरान चीजों को गति देने के लिए (जब मॉडल के पास लक्ष्य वाक्यों तक पहुंच होती है), डिकोडर को पूरे लक्ष्य को खिलाया जाता है, लेकिन भविष्य के शब्दों का उपयोग करने की अनुमति नहीं है (यदि भविष्यवाणी करने की कोशिश करते समय स्थिति 2 पर शब्द तक पहुंच थी) स्थिति 2 पर शब्द, समस्या बहुत कठिन नहीं होगी!)। उदाहरण के लिए, जब चौथे शब्द की भविष्यवाणी करने की कोशिश की जाती है, तो ध्यान परत के पास केवल 1 से 3 की स्थिति वाले शब्दों तक ही पहुंच होगी।

मूल ट्रांसफॉर्मर आर्किटेक्चर इस तरह दिखता था, बाईं ओर एन्कोडर और दाईं ओर डिकोडर:

<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="Architecture of a Transformers models">
<img class="hidden dark:block" src="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter1/transformers-dark.svg" alt="Architecture of a Transformers models">
</div>

ध्यान दें कि डिकोडर ब्लॉक में पहली ध्यान परत डिकोडर के सभी (अतीत) इनपुट पर ध्यान देती है, लेकिन दूसरी ध्यान परत एन्कोडर के आउटपुट का उपयोग करती है। इस प्रकार यह वर्तमान शब्द का सर्वोत्तम अनुमान लगाने के लिए संपूर्ण इनपुट वाक्य तक पहुंच सकता है। यह बहुत उपयोगी है क्योंकि विभिन्न भाषाओं में व्याकरण संबंधी नियम हो सकते हैं जो शब्दों को अलग-अलग क्रम में रखते हैं, या वाक्य में बाद में दिए गए कुछ संदर्भ किसी दिए गए शब्द का सर्वोत्तम अनुवाद निर्धारित करने में सहायक हो सकते हैं।

मॉडल को कुछ विशेष शब्दों पर ध्यान देने से रोकने के लिए *ध्यान मास्क* का उपयोग एन्कोडर/डिकोडर में भी किया जा सकता है - उदाहरण के लिए, विशेष पैडिंग शब्द जिसका उपयोग वाक्यों को एक साथ बैच करते समय सभी इनपुट को समान लंबाई बनाने के लिए किया जाता है।

## आर्किटेक्चर बनाम चेकपॉइंट

जैसे ही हम इस पाठ्यक्रम में ट्रांसफॉर्मर मॉडल में गोता लगाते हैं, आप *आर्किटेक्चर* और *चेकपॉइंट्स* के साथ-साथ *मॉडल* का उल्लेख देखेंगे। इन सभी शब्दों के थोड़े अलग अर्थ हैं:

* **आर्किटेक्चर**: यह मॉडल का कंकाल है - प्रत्येक परत की परिभाषा और मॉडल के भीतर होने वाले प्रत्येक ऑपरेशन।
* **जांच की चौकी**: ये वे वज़न हैं जिन्हें किसी दिए गए आर्किटेक्चर में लोड किया जाएगा।
* **मॉडल**: यह एक छत्र शब्द है जो "आर्किटेक्चर" या "चेकपॉइंट" जितना सटीक नहीं है: इसका मतलब दोनों हो सकता है। अस्पष्टता को कम करने के लिए यह पाठ्यक्रम *वास्तुकला* या *चेकपॉइंट* निर्दिष्ट करेगा।

उदाहरण के लिए, BERT एक आर्किटेक्चर है, जबकि `बर्ट-बेस-केस्ड`, BERT की पहली रिलीज़ के लिए Google टीम द्वारा प्रशिक्षित वज़न का एक सेट एक चेकपॉइंट है। हालांकि, कोई "बीईआरटी मॉडल" और "`बर्ट-बेस-केसेड` मॉडल" कह सकता है।


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter1/4.mdx" />

### अनुक्रम-से-अनुक्रम मॉडल
https://huggingface.co/learn/course/hi/chapter1/7.md

# अनुक्रम-से-अनुक्रम मॉडल

<CourseFloatingBanner
    chapter={1}
    classNames="absolute z-10 right-0 top-0"
/>

<Youtube id="0_4KEb08xrE" />

एनकोडर-डिकोडर मॉडल (जिसे *सीक्वेंस-टू-सीक्वेंस मॉडल* भी कहा जाता है) ट्रांसफॉर्मर आर्किटेक्चर के दोनों हिस्सों का उपयोग करते हैं। प्रत्येक चरण में, एन्कोडर की ध्यान परतें प्रारंभिक वाक्य में सभी शब्दों तक पहुंच सकती हैं, जबकि डिकोडर की ध्यान परतें केवल इनपुट में दिए गए शब्द से पहले स्थित शब्दों तक पहुंच सकती हैं।

इन मॉडलों का पूर्व-प्रशिक्षण एन्कोडर या डिकोडर मॉडल के उद्देश्यों का उपयोग करके किया जा सकता है, लेकिन इसमें आमतौर पर कुछ अधिक जटिल होता है। उदाहरण के लिए, [T5](https://huggingface.co/t5-base) को टेक्स्ट के रैंडम स्पैन (जिसमें कई शब्द हो सकते हैं) को एक ही मास्क विशेष शब्द से बदलकर पूर्व-प्रशिक्षित किया जाता है, और इसका उद्देश्य भविष्यवाणी करना है वह पाठ जिसे यह मुखौटा शब्द बदल देता है।

अनुक्रम-से-अनुक्रम मॉडल किसी दिए गए इनपुट के आधार पर नए वाक्यों को उत्पन्न करने के इर्द-गिर्द घूमने वाले कार्यों के लिए सबसे उपयुक्त हैं, जैसे कि सारांश, अनुवाद, या जनरेटिव प्रश्न उत्तर।

मॉडल के इस परिवार के प्रतिनिधियों में शामिल हैं:

- [BART](https://huggingface.co/transformers/model_doc/bart.html)
- [mBART](https://huggingface.co/transformers/model_doc/mbart.html)
- [Marian](https://huggingface.co/transformers/model_doc/marian.html)
- [T5](https://huggingface.co/transformers/model_doc/t5.html)


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter1/7.mdx" />

### प्राकृतिक भाषा प्रसंस्करण
https://huggingface.co/learn/course/hi/chapter1/2.md

# प्राकृतिक भाषा प्रसंस्करण

<CourseFloatingBanner
    chapter={1}
    classNames="absolute z-10 right-0 top-0"
/>

ट्रांसफॉर्मर मॉडल में जाने से पहले, आइए एक त्वरित अवलोकन करें कि प्राकृतिक भाषा प्रसंस्करण क्या है और हम इसकी परवाह क्यों करते हैं।

## प्राकृतिक भाषा प्रसंस्करण क्या है?

प्राकृतिक भाषा प्रसंस्करण भाषा विज्ञान और मशीन सीखने का एक क्षेत्र है जो मानव भाषा से संबंधित हर चीज को समझने पर केंद्रित है। एनएलपी कार्यों का उद्देश्य न केवल एक शब्द को व्यक्तिगत रूप से समझना है, बल्कि उन शब्दों के संदर्भ को समझने में सक्षम होना है।

निम्नलिखित सामान्य प्राकृतिक भाषा प्रसंस्करण कार्यों की एक सूची है, जिनमें से प्रत्येक के कुछ उदाहरण हैं:
- **पूरे वाक्यों को वर्गीकृत करना**: समीक्षा की भावना प्राप्त करना, यह पता लगाना कि क्या कोई ईमेल स्पैम है, यह निर्धारित करना कि कोई वाक्य व्याकरणिक रूप से सही है या दो वाक्य तार्किक रूप से संबंधित हैं या नहीं।
- **प्रत्येक शब्द को एक वाक्य में वर्गीकृत करना**: एक वाक्य (संज्ञा, क्रिया, विशेषण), या नामित संस्थाओं (व्यक्ति, स्थान, संगठन) के व्याकरणिक घटकों की पहचान करना।
- **पाठ सामग्री उत्पन्न करना**: ऑटो-जेनरेटेड टेक्स्ट के साथ एक प्रॉम्प्ट को पूरा करना, टेक्स्ट में रिक्त स्थान को नकाबपोश शब्दों से भरना।
- **किसी पाठ से उत्तर निकालना**: एक प्रश्न और एक संदर्भ को देखते हुए, संदर्भ में दी गई जानकारी के आधार पर प्रश्न का उत्तर निकालना।
- **इनपुट टेक्स्ट से एक नया वाक्य बनाना**: एक पाठ को दूसरी भाषा में अनुवाद करना, एक पाठ को सारांशित करना।

प्राकृतिक भाषा प्रसंस्करण हालांकि लिखित पाठ तक ही सीमित नहीं है। यह वाक् पहचान और कंप्यूटर विज़न में जटिल चुनौतियों से भी निपटता है, जैसे कि ऑडियो नमूने की प्रतिलिपि बनाना या किसी छवि का विवरण।

## यह चुनौतीपूर्ण क्यों है?

कंप्यूटर इंसानों की तरह सूचनाओं को प्रोसेस नहीं करते हैं। उदाहरण के लिए, जब हम "मुझे भूख लगी है" वाक्य पढ़ते हैं, तो हम इसका अर्थ आसानी से समझ सकते हैं। इसी तरह, "मैं भूखा हूँ" और "मैं उदास हूँ" जैसे दो वाक्यों को देखते हुए, हम आसानी से यह निर्धारित करने में सक्षम हैं कि वे कितने समान हैं। मशीन लर्निंग (एमएल) मॉडल के लिए, ऐसे कार्य अधिक कठिन होते हैं। पाठ को इस तरह से संसाधित करने की आवश्यकता है जो मॉडल को इससे सीखने में सक्षम बनाता है। और क्योंकि भाषा जटिल है, हमें ध्यान से सोचने की जरूरत है कि यह प्रसंस्करण कैसे किया जाना चाहिए। पाठ का प्रतिनिधित्व करने के तरीके पर बहुत शोध किया गया है, और हम अगले अध्याय में कुछ विधियों को देखेंगे।


<EditOnGithub source="https://github.com/huggingface/course/blob/main/chapters/hi/chapter1/2.mdx" />
