# أدوات التوليد

تُدرج هذه الصفحة جميع دوال الأداة المستخدمة في [generate()](/docs/transformers/main/ar/main_classes/text_generation#transformers.GenerationMixin.generate).

## توليد المخرجات[[transformers.generation.GenerateDecoderOnlyOutput]]

المخرجات الخاصة بـ [generate()](/docs/transformers/main/ar/main_classes/text_generation#transformers.GenerationMixin.generate) هي كائن من فئة فرعية من [ModelOutput](/docs/transformers/main/ar/main_classes/output#transformers.utils.ModelOutput). هذه المخرجات هي بنية بيانات تحتوي على جميع المعلومات التي تُرجعها [generate()](/docs/transformers/main/ar/main_classes/text_generation#transformers.GenerationMixin.generate)، لكنها يمكن أن تُستخدم أيضاً كـ tuple أو dictionary.

إليك مثالاً:

```python
from transformers import GPT2Tokenizer, GPT2LMHeadModel

tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2")
model = GPT2LMHeadModel.from_pretrained("openai-community/gpt2")

inputs = tokenizer("Hello, my dog is cute and ", return_tensors="pt")
generation_output = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
```

كائن `generation_output` هو [GenerateDecoderOnlyOutput](/docs/transformers/main/ar/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput)، وكما نرى في توثيق هذه الفئة أدناه، فهذا يعني أنه يحتوي على السمات التالية:

- `sequences`: تسلسلات الرموز المولّدة
- `scores` (اختياري): درجات التنبؤ لرأس نمذجة اللغة، لكل خطوة توليد
- `hidden_states` (اختياري): حالات النموذج المخفية، لكل خطوة توليد
- `attentions` (اختياري): أوزان الانتباه للنموذج، لكل خطوة توليد

هنا لدينا `scores` لأننا مررنا `output_scores=True`، لكن لا نملك `hidden_states` و`attentions` لأننا لم نمرر `output_hidden_states=True` أو `output_attentions=True`.

يمكنك الوصول إلى كل سمة بالطريقة المعتادة، وإذا لم يُرجع النموذج تلك السمة، فستحصل على `None`. هنا على سبيل المثال، `generation_output.scores` هي جميع درجات التنبؤ المولّدة من رأس نمذجة اللغة، و`generation_output.attentions` هي `None`.

عند استخدام كائن `generation_output` الخاص بنا على أنه tuple، فإنه يحتفظ فقط بالخصائص التي لا تحمل قيم `None`. هنا، على سبيل المثال، يحتوي على عنصرين، `loss` ثم `logits`، لذا

```python
generation_output[:2]
```

سيُرجع على سبيل المثال المجموعة المرتبة `(generation_output.sequences, generation_output.scores)`.

عند استخدام كائن `generation_output` الخاص بنا كمعجم، فإنه يحتفظ فقط بالخصائص التي لا تحمل قيم `None`. هنا، على سبيل المثال، يحتوي على مفتاحين هما `sequences` و`scores`.

نوثّق هنا جميع أنواع المخرجات.

#### transformers.generation.GenerateDecoderOnlyOutput[[transformers.generation.GenerateDecoderOnlyOutput]]

```python
transformers.generation.GenerateDecoderOnlyOutput(sequences: LongTensor, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, attentions: tuple[tuple[torch.Tensor]] | None = None, hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L183)

**المعاملات:**

sequences (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : التسلسلات المولّدة. يكون البُعد الثاني (sequence_length) مساوياً لـ`max_length` أو أقصر منه إذا انتهت جميع الدفعات مبكراً بسبب `eos_token_id`.

scores (`tuple(torch.Tensor)` *اختياري*، يُعاد عند `output_scores=True`) : درجات التنبؤ المعالجة لرأس نمذجة اللغة (درجات كل رمز في المفردات قبل SoftMax) في كل خطوة من خطوات التوليد. مجموعة من `torch.Tensor` تحتوي على ما يصل إلى `max_new_tokens` عنصرًا (عنصر واحد لكل رمز مُولَّد)، حيث يكون شكل كل متجه `(batch_size, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *اختياري*، يُعاد عند `output_logits=True`) : درجات التنبؤ غير المعالجة لرأس نمذجة اللغة (درجات لكل رمز في المفردات قبل SoftMax) في كل خطوة من خطوات التوليد. مجموعة من `torch.Tensor` تحتوي على ما يصل إلى `max_new_tokens` عنصرًا (عنصر واحد لكل رمز مُولَّد)، حيث يكون شكل كل متجه `(batch_size, config.vocab_size)`.

attentions (`tuple(tuple(torch.Tensor))`، *اختياري*، يُعاد عند `output_attentions=True`) : مجموعة (عنصر واحد لكل رمز مُولَّد) من المجموعات (عنصر واحد لكل طبقة من طبقات المُفكِّك) من `torch.Tensor` بأبعاد `(batch_size, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`، *اختياري*، يُعاد عند `output_hidden_states=True`) : مجموعة (عنصر واحد لكل رمز مُولَّد) من المجموعات (عنصر واحد لكل طبقة من طبقات المُفكِّك) من `torch.Tensor` بأبعاد `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`، *اختياري*، يُعاد عند `use_cache=True`) : يعيد كاش النموذج، ويُستخدم لتسريع فك الترميز. يختلف تنسيق الكاش من نموذج إلى آخر، لذا راجع توثيق النموذج. عادةً، يكون هذا كائنًا من [Cache](/docs/transformers/main/ar/internal/generation_utils#transformers.Cache).

مخرجات نماذج التوليد المعتمدة على المُفكِّك فقط، عند استخدام طرق غير حِزمية.

#### transformers.generation.GenerateEncoderDecoderOutput[[transformers.generation.GenerateEncoderDecoderOutput]]

```python
transformers.generation.GenerateEncoderDecoderOutput(sequences: LongTensor, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[tuple[torch.Tensor]] | None = None, cross_attentions: tuple[tuple[torch.Tensor]] | None = None, decoder_hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L219)

**المعاملات:**

sequences (`torch.LongTensor` من الشكل `(batch_size*num_return_sequences, sequence_length)`) : التسلسلات المولّدة. يكون البُعد الثاني (sequence_length) مساوياً لـ`max_length` أو أقصر منه إذا انتهت جميع الدفعات مبكراً بسبب `eos_token_id`.

scores (`tuple(torch.Tensor)` *اختياري*، يُعاد عند `output_scores=True`) : درجات التنبؤ المعالجة لرأس نمذجة اللغة (درجات كل رمز في المفردات قبل SoftMax) في كل خطوة من خطوات التوليد. مجموعة من `torch.Tensor` تحتوي على ما يصل إلى `max_new_tokens` عنصرًا (عنصر واحد لكل رمز مُولَّد)، حيث يكون شكل كل متجه `(batch_size, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *اختياري*، يُعاد عند `output_logits=True`) : درجات التنبؤ غير المعالجة لرأس نمذجة اللغة (درجات لكل رمز في المفردات قبل SoftMax) في كل خطوة من خطوات التوليد. مجموعة من `torch.Tensor` تحتوي على ما يصل إلى `max_new_tokens` عنصرًا (عنصر واحد لكل رمز مُولَّد)، حيث يكون شكل كل متجه `(batch_size, config.vocab_size)`.

encoder_attentions (`tuple(torch.Tensor)`، *اختياري*، يُعاد عند `output_attentions=True`) : مجموعة من `torch.Tensor` (واحدة لكل طبقة من طبقات المُفكِّك) بأبعاد `(batch_size, num_heads, sequence_length, sequence_length)`.

encoder_hidden_states (`tuple(torch.Tensor)`، *اختياري*، يُعاد عند `output_hidden_states=True`) : مجموعة من `torch.Tensor` (واحدة لمخرجات التضمينات + واحدة لمخرجات كل طبقة) من الشكل `(batch_size, sequence_length, hidden_size)`.

decoder_attentions (`tuple(tuple(torch.Tensor))`، *اختياري*، يُعاد عند `output_attentions=True`) : مجموعة (عنصر واحد لكل رمز مُولَّد) من المجموعات (عنصر واحد لكل طبقة من طبقات المُفكِّك) من `torch.Tensor` بأبعاد `(batch_size, num_heads, generated_length, sequence_length)`.

cross_attentions (`tuple(tuple(torch.Tensor))`، *اختياري*، يُعاد عند `output_attentions=True`) : مجموعة (عنصر واحد لكل رمز مُولَّد) من المجموعات (عنصر واحد لكل طبقة من طبقات المُفكِّك) من `torch.Tensor` بأبعاد `(batch_size, num_heads, generated_length, sequence_length)`.

decoder_hidden_states (`tuple(tuple(torch.Tensor))`، *اختياري*، يُعاد عند `output_hidden_states=True`) : مجموعة (عنصر واحد لكل رمز مُولَّد) من المجموعات (عنصر واحد لكل طبقة من طبقات المُفكِّك) من `torch.Tensor` بأبعاد `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`، *اختياري*، يُعاد عند `use_cache=True`) : يعيد كاش النموذج، ويُستخدم لتسريع فك الترميز. يختلف تنسيق الكاش من نموذج إلى آخر، لذا راجع توثيق النموذج. عادةً، يكون هذا كائنًا من [Cache](/docs/transformers/main/ar/internal/generation_utils#transformers.Cache).

مخرجات نماذج التوليد المشفّرة-المفكّكة عند استخدام طرق غير الحزمة.

#### transformers.generation.GenerateBeamDecoderOnlyOutput[[transformers.generation.GenerateBeamDecoderOnlyOutput]]

```python
transformers.generation.GenerateBeamDecoderOnlyOutput(sequences: LongTensor, sequences_scores: typing.Optional[torch.Tensor] = None, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, beam_indices: typing.Optional[torch.LongTensor] = None, attentions: tuple[tuple[torch.Tensor]] | None = None, hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L267)

**المعاملات:**

sequences (`torch.LongTensor` من الشكل `(batch_size*num_return_sequences, sequence_length)`) : التسلسلات المولّدة. يكون البُعد الثاني (sequence_length) مساوياً لـ`max_length` أو أقصر منه إذا انتهت جميع الدفعات مبكراً بسبب `eos_token_id`.

sequences_scores (`torch.Tensor` من الشكل `(batch_size*num_return_sequences)`، *اختياري*، يُعاد عند `output_scores=True`) : درجات الحزمة النهائية للـ`sequences` المولّدة.

scores (`tuple(torch.Tensor)` *اختياري*، يُعاد عند `output_scores=True`) : درجات انتقال الحزمة لكل رمز في قاموس الكلمات في كل خطوة من خطوات التوليد. تتكون درجات انتقال الحزمة من احتمالات اللوغاريتمية للرموز المشروطة على لوغاريتم softmax للرموز المولَّدة سابقًا في هذه الحزمة. مجموعة مرتبة من `torch.Tensor` تحتوي على ما يصل إلى `max_new_tokens` عنصرًا (عنصر واحد لكل رمز مولَّد)، حيث يكون شكل كل متجه `(batch_size*num_beams, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *اختياري*، يُعاد عند `output_logits=True`) : درجات التنبؤ غير المعالجة لرأس نمذجة اللغة (درجات كل رمز في المفردات قبل SoftMax) في كل خطوة من خطوات التوليد. مجموعة من `torch.Tensor` تحتوي على ما يصل إلى `max_new_tokens` عنصرًا (عنصر واحد لكل رمز مُولَّد)، حيث يكون شكل كل متجه `(batch_size*num_beams, config.vocab_size)`.

beam_indices (`torch.LongTensor`، *اختياري*، يُعاد عند `output_scores=True`) : فهارس الحزم (Beam indices) لمعرّفات الرموز المولّدة في كل خطوة من خطوات التوليد. `torch.LongTensor` من الشكل `(batch_size*num_return_sequences, sequence_length)`.

attentions (`tuple(tuple(torch.Tensor))`، *اختياري*، يُعاد عند `output_attentions=True`) : مجموعة (عنصر واحد لكل رمز مُولَّد) من المجموعات (عنصر واحد لكل طبقة من طبقات المُفكِّك) من `torch.Tensor` بأبعاد `(batch_size*num_beams, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`، *اختياري*، يُعاد عند `output_hidden_states=True`) : مجموعة (عنصر واحد لكل رمز مُولَّد) من المجموعات (عنصر واحد لكل طبقة من طبقات المُفكِّك) من `torch.Tensor` بأبعاد `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.

past_key_values (`Cache`، *اختياري*، يُعاد عند `use_cache=True`) : يعيد كاش النموذج، ويُستخدم لتسريع فك الترميز. يختلف تنسيق الكاش من نموذج إلى آخر، لذا راجع توثيق النموذج. عادةً، يكون هذا كائنًا من [Cache](/docs/transformers/main/ar/internal/generation_utils#transformers.Cache).

مخرجات نماذج التوليد المعتمدة على المُفكِّك فقط، عند استخدام طرق الحزمة.

#### transformers.generation.GenerateBeamEncoderDecoderOutput[[transformers.generation.GenerateBeamEncoderDecoderOutput]]

```python
transformers.generation.GenerateBeamEncoderDecoderOutput(sequences: LongTensor, sequences_scores: typing.Optional[torch.Tensor] = None, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, beam_indices: typing.Optional[torch.LongTensor] = None, encoder_attentions: tuple[torch.Tensor] | None = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[tuple[torch.Tensor]] | None = None, cross_attentions: tuple[tuple[torch.Tensor]] | None = None, decoder_hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L311)

**المعاملات:**

sequences (`torch.LongTensor` من الشكل `(batch_size*num_return_sequences, sequence_length)`) : التسلسلات المولّدة. يكون البُعد الثاني (sequence_length) مساوياً لـ`max_length` أو أقصر منه إذا انتهت جميع الدفعات مبكراً بسبب `eos_token_id`.

sequences_scores (`torch.Tensor` من الشكل `(batch_size*num_return_sequences)`، *اختياري*، يُعاد عند `output_scores=True`) : درجات الحزمة النهائية للـ`sequences` المولّدة.

scores (`tuple(torch.Tensor)` *اختياري*، يُعاد عند `output_scores=True`) : درجات انتقال الحزمة لكل رمز في قاموس الكلمات في كل خطوة من خطوات التوليد. تتكون درجات انتقال الحزمة من احتمالات اللوغاريتمية للرموز المشروطة على لوغاريتم softmax للرموز المولَّدة سابقًا في هذه الحزمة. مجموعة مرتبة من `torch.Tensor` تحتوي على ما يصل إلى `max_new_tokens` عنصرًا (عنصر واحد لكل رمز مولَّد)، حيث يكون شكل كل متجه `(batch_size*num_beams, config.vocab_size)`.

logits (`tuple(torch.Tensor)` *اختياري*، يُعاد عند `output_logits=True`) : درجات التنبؤ غير المعالجة لرأس نمذجة اللغة (درجات كل رمز في المفردات قبل SoftMax) في كل خطوة من خطوات التوليد. مجموعة من `torch.Tensor` تحتوي على ما يصل إلى `max_new_tokens` عنصرًا (عنصر واحد لكل رمز مُولَّد)، حيث يكون شكل كل متجه `(batch_size*num_beams, config.vocab_size)`.

beam_indices (`torch.LongTensor`، *اختياري*، يُعاد عند `output_scores=True`) : فهارس الحزم (Beam indices) لمعرّفات الرموز المولّدة في كل خطوة من خطوات التوليد. `torch.LongTensor` من الشكل `(batch_size*num_return_sequences, sequence_length)`.

encoder_attentions (`tuple(torch.Tensor)`، *اختياري*، يُعاد عند `output_attentions=True`) : مجموعة من `torch.Tensor` (واحدة لكل طبقة من طبقات المُفكِّك) بأبعاد `(batch_size, num_heads, sequence_length, sequence_length)`.

encoder_hidden_states (`tuple(torch.Tensor)`، *اختياري*، يُعاد عند `output_hidden_states=True`) : مجموعة من `torch.Tensor` (واحدة لمخرجات التضمينات + واحدة لمخرجات كل طبقة) من الشكل `(batch_size*num_beams*num_return_sequences, sequence_length, hidden_size)`.

decoder_attentions (`tuple(tuple(torch.Tensor))`، *اختياري*، يُعاد عند `output_attentions=True`) : مجموعة (عنصر واحد لكل رمز مُولَّد) من المجموعات (عنصر واحد لكل طبقة من طبقات المُفكِّك) من `torch.Tensor` بأبعاد `(batch_size*num_beams*num_return_sequences, num_heads, generated_length, sequence_length)`.

cross_attentions (`tuple(tuple(torch.Tensor))`، *اختياري*، يُعاد عند `output_attentions=True`) : مجموعة (عنصر واحد لكل رمز مُولَّد) من المجموعات (عنصر واحد لكل طبقة من طبقات المُفكِّك) من `torch.Tensor` بأبعاد `(batch_size, num_heads, generated_length, sequence_length)`.

decoder_hidden_states (`tuple(tuple(torch.Tensor))`، *اختياري*، يُعاد عند `output_hidden_states=True`) : مجموعة (عنصر واحد لكل رمز مُولَّد) من المجموعات (عنصر واحد لكل طبقة من طبقات المُفكِّك) من `torch.Tensor` بأبعاد `(batch_size*num_beams*num_return_sequences, generated_length, hidden_size)`.

past_key_values (`Cache`، *اختياري*، يُعاد عند `use_cache=True`) : يعيد كاش النموذج، ويُستخدم لتسريع فك الترميز. يختلف تنسيق الكاش من نموذج إلى آخر، لذا راجع توثيق النموذج. عادةً، يكون هذا كائنًا من [Cache](/docs/transformers/main/ar/internal/generation_utils#transformers.Cache).

مخرجات نماذج التوليد المشفّرة-المفكّكة عند استخدام طرق الحزمة.

## LogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]]

يمكن استخدام [LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) لتعديل درجات التنبؤ لرأس نموذج اللغة أثناء التوليد.

#### transformers.AlternatingCodebooksLogitsProcessor[[transformers.AlternatingCodebooksLogitsProcessor]]

```python
transformers.AlternatingCodebooksLogitsProcessor(input_start_len: int, semantic_vocab_size: int, codebook_size: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2222)

**المعاملات:**

input_start_len (`int`) : طول تسلسل الإدخال الأولي.

semantic_vocab_size (`int`) : حجم مفردات الجزء الدلالي، أي عدد الرموز المرتبطة بمفردات الدلالة.

codebook_size (`int`) : عدد الرموز المرتبطة بكتاب الرموز.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) يفرض التوليد بالتناوب بين كتيبي الرمزين في Bark.

هذا المعالج الخاص بالقيم اللوجستية متوافق حصريًا مع النموذج الفرعي الدقيق الخاص بـ [Bark](https://huggingface.co/docs/transformers/en/model_doc/bark). راجع توثيق النموذج للحصول على أمثلة.

#### __call__[[transformers.AlternatingCodebooksLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2251)

#### transformers.ClassifierFreeGuidanceLogitsProcessor[[transformers.ClassifierFreeGuidanceLogitsProcessor]]

```python
transformers.ClassifierFreeGuidanceLogitsProcessor(guidance_scale)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2158)

**المعاملات:**

guidance_scale (float) : مقياس التوجيه للتوجيه الحر من التصنيف (CFG). يتم تفعيل CFG عن طريق تعيين `guidance_scale > 1`. كلما زاد مقياس التوجيه، شجّع النموذج على توليد عينات أكثر ارتباطاً بالموجّه المدخل، وعادةً على حساب انخفاض الجودة.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) للإرشاد الحر من التصنيف (CFG). يتم تقسيم الدرجات على بُعد الدفعة (batch dimension)، حيث يتوافق النصف الأول مع قيم اللوجيت الشرطية (المُقدَّرة من موجه الإدخال)، ويتوافق النصف الثاني مع قيم اللوجيت غير الشرطية (المُقدَّرة من موجه فارغ أو «null»). يقوم المعالج بحساب متوسط مرجح بين قيم اللوجيت الشرطية وغير الشرطية، مُعَيَّنًا بمعامل `guidance_scale`.

راجع [الورقة البحثية](https://huggingface.co/papers/2306.05284) لمزيد من المعلومات.

هذا المعالج الخاص بالقيم اللوجستية متوافق حصريًا مع [MusicGen](https://huggingface.co/docs/transformers/main/en/model_doc/musicgen)

أمثلة:

```python
>>> from transformers import AutoProcessor, MusicgenForConditionalGeneration

>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")

>>> inputs = processor(
...     text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
...     padding=True,
...     return_tensors="pt",
... )
>>> audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
```

#### __call__[[transformers.ClassifierFreeGuidanceLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2206)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.EncoderNoRepeatNGramLogitsProcessor[[transformers.EncoderNoRepeatNGramLogitsProcessor]]

```python
transformers.EncoderNoRepeatNGramLogitsProcessor(encoder_ngram_size: int, encoder_input_ids: LongTensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1173)

**المعاملات:**

encoder_ngram_size (`int`) : جميع النغرامات (ngrams) ذات الحجم `ngram_size` يمكن أن تظهر فقط ضمن معرّفات مدخلات المُشفِّر (encoder input ids).

encoder_input_ids (`int`) : معرّفات encoder_input_ids التي يجب ألا تتكرر ضمن معرّفات المُفكِّك.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) يعمل بشكل مشابه لـ [NoRepeatNGramLogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.NoRepeatNGramLogitsProcessor)، لكنه يُطبَّق حصريًا لمنع تكرار n-grams الموجودة في الموجّه.

صُمِّم لتعزيز التفاعلية في نموذج اللغة، من خلال منع توليد مجموعات الكلمات (n-grams) الموجودة في جولات المحادثة السابقة.

أمثلة:

```py
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("Alice: I love cats. What do you love?\nBob:", return_tensors="pt")

>>> # With greedy decoding, we see Bob repeating Alice's opinion. If Bob was a chatbot, it would be a poor one.
>>> outputs = model.generate(**inputs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice: I love cats. What do you love?
Bob: I love cats. What do you

>>> # With this logits processor, we can prevent Bob from repeating Alice's opinion.
>>> outputs = model.generate(**inputs, encoder_no_repeat_ngram_size=2)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice: I love cats. What do you love?
Bob: My cats are very cute.
```

#### __call__[[transformers.EncoderNoRepeatNGramLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1222)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.EncoderRepetitionPenaltyLogitsProcessor[[transformers.EncoderRepetitionPenaltyLogitsProcessor]]

```python
transformers.EncoderRepetitionPenaltyLogitsProcessor(penalty: float, encoder_input_ids: LongTensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L440)

**المعاملات:**

penalty (`float`) : معامل عقوبة التكرار. القيمة 1.0 تعني عدم وجود عقوبة. القيم أعلى من 1.0 تكافئ رموز الموجّه. القيم بين 0.0 و 1.0 تعاقب رموز الموجّه.

encoder_input_ids (`torch.LongTensor`) : هي encoder_input_ids التي يجب تكرارها داخل معرفات المُفكِّك (decoder ids).

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) يعمل بشكل مشابه لـ [RepetitionPenaltyLogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.RepetitionPenaltyLogitsProcessor)، لكن مع عقوبة *عكسية* تُطبَّق على الرموز الموجودة في الاستعلام. بمعنى آخر، فإن العقوبة التي تتجاوز 1.0 تزيد من احتمالية اختيار الرموز التي كانت موجودة في الاستعلام.

صُمِّم لتجنّب الهلوسة في المهام المعتمدة على المدخلات، مثل تلخيص النصوص. وعلى الرغم من أنه كان مخصصًا في الأصل لنماذج المُشفِّر-المُفكِّك (encoder-decoder)، إلا أنه يمكن استخدامه أيضًا مع النماذج التي تعتمد على المُفكِّك فقط، مثل نماذج اللغة الكبيرة (LLMs).

أمثلة:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")
>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer(["Alice and Bob. The third member's name was"], return_tensors="pt")
>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
Alice and Bob. The third member's name was not mentioned.

>>> # With the `encoder_repetition_penalty` argument we can trigger this logits processor in `generate`, which can
>>> # promote the use of prompt tokens ("Bob" in this example)
>>> gen_out = model.generate(**inputs, encoder_repetition_penalty=1.2)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
Alice and Bob. The third member's name was Bob. The third member's name was Bob.
```

#### __call__[[transformers.EncoderRepetitionPenaltyLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L486)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.EpsilonLogitsWarper[[transformers.EpsilonLogitsWarper]]

```python
transformers.EpsilonLogitsWarper(epsilon: float, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L897)

**المعاملات:**

epsilon (`float`) : إذا تم ضبطه على قيمة > 0، فسيتم الاحتفاظ فقط بأكثر الرموز التي تبلغ احتمالاتها `epsilon` أو أعلى لتوليد النص.

filter_value (`float`، *اختياري*، القيمة الافتراضية -inf) : سيتم تعيين جميع القيم المفلترة إلى قيمة float هذه.

min_tokens_to_keep (`int`، *اختياري*، القيمة الافتراضية 1) : الحد الأدنى لعدد الرموز التي لا يمكن تصفيتها.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يقوم بتطبيق أخذ عينات إبسيلون، أي تقييد العملية على الرموز التي تحقق `prob >= epsilon`. وفي حال عدم وجود رموز تحقق من هذا الشرط، يتم اختيار أكبر عدد من الرموز المحدد بواسطة min_tokens_to_keep. راجع [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) لمزيد من المعلومات.

أمثلة:
```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With epsilon sampling, the output gets restricted to high-probability tokens. Note that this is similar to
>>> # Top P sampling, which restricts tokens based on their cumulative probability.
>>> # Pro tip: The paper recommends using `epsilon_cutoff` values between 3e-4 and 9e-4
>>> outputs = model.generate(**inputs, do_sample=True, epsilon_cutoff=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9
```

#### __call__[[transformers.EpsilonLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L952)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.EtaLogitsWarper[[transformers.EtaLogitsWarper]]

```python
transformers.EtaLogitsWarper(epsilon: float, filter_value: float = -inf, min_tokens_to_keep: int = 1, device: str = 'cpu')
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L966)

**المعاملات:**

epsilon (`float`) : قيمة من نوع float تقع ضمن المدى (0, 1). معامل خوارزمي يُستخدم لحساب قيمة القطع الديناميكي، `eta`. تتراوح القيم المقترحة من الورقة البحثية بين 3e-4 و4e-3 اعتمادًا على حجم النموذج.

filter_value (`float`، *اختياري*، القيمة الافتراضية -inf) : تُضبط جميع القيم التي يُكتشف أنها أقل من قيمة القطع الديناميكي، `eta`، على قيمة float هذه. يُعد هذا المعامل مفيدًا عندما تحتاج القيم اللوجستية (logits) إلى التعديل للرموز ذات الاحتمال المنخفض جدًا والتي يجب استبعادها من التوليد بالكامل.

min_tokens_to_keep (`int`، *اختياري*، القيمة الافتراضية 1) : يحدد الحد الأدنى لعدد الرموز التي يجب الاحتفاظ بها للتوليد، بغض النظر عن احتمالاتها. على سبيل المثال، إذا تم تعيين `min_tokens_to_keep` إلى 1، فسيتم دائمًا الاحتفاظ برمز واحد على الأقل للتوليد، حتى لو كانت احتمالات جميع الرموز أقل من حد القطع `eta`.

device (`str`، *اختياري*، القيمة الافتراضية `"cpu"`) : الجهاز الذي سيُخصَّص فيه المتجهات.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يقوم بتطبيق تقنية eta-sampling، وهي تقنية تُستخدم لتصفية الرموز التي تكون احتمالاتها أقل من قيمة حدّية ديناميكية، `eta`، تُحسب بناءً على مزيج من المعامل `epsilon` وإنتروبيا احتمالات الرموز، أي `eta := min(epsilon, sqrt(epsilon * e^-entropy(probabilities)))`. وفي حال عدم وجود رموز تحقق من هذا الشرط، يتم اختيار أكبر عدد من الرموز المحدد بواسطة min_tokens_to_keep. تعالج هذه التقنية مشكلة ضعف الجودة في النصوص الطويلة التي تولّدها نماذج اللغة العصبية، مما يؤدي إلى نصوص أكثر تماسكاً وسلاسة. راجع [Truncation Sampling as Language Model Desmoothing](https://huggingface.co/papers/2210.15191) لمزيد من المعلومات. ملاحظة: يجب ضبط `do_sample` على `True` لكي يعمل هذا `LogitsProcessor`.

أمثلة:
```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With eta sampling, the output gets restricted to high-probability tokens. You can see it as a dynamic form of
>>> # epsilon sampling that adapts its cutoff probability based on the entropy (high entropy = lower cutoff).
>>> # Pro tip: The paper recommends using `eta_cutoff` values between 3e-4 to 4e-3
>>> outputs = model.generate(**inputs, do_sample=True, eta_cutoff=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9
```

#### __call__[[transformers.EtaLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1035)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.ExponentialDecayLengthPenalty[[transformers.ExponentialDecayLengthPenalty]]

```python
transformers.ExponentialDecayLengthPenalty(exponential_decay_length_penalty: tuple, eos_token_id: typing.Union[int, list[int], torch.Tensor], input_ids_seq_length: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1712)

**المعاملات:**

exponential_decay_length_penalty (`tuple(int, float)`) : يتكوّن هذا المصفوف من: `(start_index, decay_factor)` حيث يشير `start_index` إلى نقطة بدء العقوبة، ويمثل `decay_factor` معامل الاضمحلال الأسي

eos_token_id (`Union[int, list[int], torch.Tensor]`) : المعرّف أو المعرّفات لرمز *نهاية التسلسل*.

input_ids_seq_length (`int`) : طول تسلسل الإدخال.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يزيد من درجة `eos_token_id` بشكل أُسّي بعد بلوغ `start_index`. وهذا يتيح توليد تسلسلات أقصر دون الحاجة إلى حدّ نهائي صارم، مما يسمح بتنبؤ `eos_token` في موضع ذي معنى.

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")

>>> text = "Just wanted to let you know, I"
>>> inputs = tokenizer(text, return_tensors="pt")

>>> # Let's consider that we want short sentences, so we limit `max_length=30`. However, we observe that the answer
>>> # tends to end abruptly.
>>> set_seed(1)
>>> outputs = model.generate(**inputs, do_sample=True, temperature=0.9, max_length=30, pad_token_id=50256)
>>> print(tokenizer.batch_decode(outputs)[0])
Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which was
published in 2010. Although

>>> # To promote the appearance of the EOS token at the right time, we add the `exponential_decay_length_penalty =
>>> # (start_index, decay_factor)`. Instead of cutting at max_tokens, the output comes to an end before and usually
>>> # with more meaning. What happens is that starting from `start_index` the EOS token score will be increased
>>> # by `decay_factor` exponentially. However, if you set a high decay factor, you may also end up with abruptly
>>> # ending sequences.
>>> set_seed(1)
>>> outputs = model.generate(
...     **inputs,
...     do_sample=True,
...     temperature=0.9,
...     max_length=30,
...     pad_token_id=50256,
...     exponential_decay_length_penalty=(15, 1.6),
... )
>>> print(tokenizer.batch_decode(outputs)[0])
Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network
which<|endoftext|>

>>> # With a small decay factor, you will have a higher chance of getting a meaningful sequence.
>>> set_seed(1)
>>> outputs = model.generate(
...     **inputs,
...     do_sample=True,
...     temperature=0.9,
...     max_length=30,
...     pad_token_id=50256,
...     exponential_decay_length_penalty=(15, 1.01),
... )
>>> print(tokenizer.batch_decode(outputs)[0])
Just wanted to let you know, I received a link to an ebook, the book How To Start A Social Network which was
published in 2010.<|endoftext|>
```

#### __call__[[transformers.ExponentialDecayLengthPenalty.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1798)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.ForcedBOSTokenLogitsProcessor[[transformers.ForcedBOSTokenLogitsProcessor]]

```python
transformers.ForcedBOSTokenLogitsProcessor(bos_token_id: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1590)

**المعاملات:**

bos_token_id (`int`) : المعرّف الخاص بالرمز الذي يجب إجباره ليكون الرمز الأول المُولَّد.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يفرض الرمز المحدد ليكون الرمز الأول المولَّد. يُستخدم مع نماذج المُشفِّر-المُفكِّك.

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

>>> model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small")
>>> tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small")

>>> inputs = tokenizer("Translate from English to German: I love cats.", return_tensors="pt")

>>> # By default, it continues generating according to the model's logits
>>> outputs = model.generate(**inputs, max_new_tokens=10)
>>> print(tokenizer.batch_decode(outputs)[0])
<pad> Ich liebe Kitty.</s>

>>> # We can use `forced_bos_token_id` to force the start of generation with an encoder-decoder model
>>> # (including forcing it to end straight away with an EOS token)
>>> outputs = model.generate(**inputs, max_new_tokens=10, forced_bos_token_id=tokenizer.eos_token_id)
>>> print(tokenizer.batch_decode(outputs)[0])
<pad></s>
```

#### __call__[[transformers.ForcedBOSTokenLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1625)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.ForcedEOSTokenLogitsProcessor[[transformers.ForcedEOSTokenLogitsProcessor]]

```python
transformers.ForcedEOSTokenLogitsProcessor(max_length: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu')
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1635)

**المعاملات:**

max_length (`int`) : الحد الأقصى لطول التسلسل المراد توليده.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : المعرّف أو المعرّفات لرمز *نهاية التسلسل*.

device (`str`، *اختياري*، القيمة الافتراضية `"cpu"`) : الجهاز الذي سيُخصَّص فيه المتجهات.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) يفرض أن يكون الرمز المحدد هو الرمز الأخير المولّد عند الوصول إلى `max_length`.

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2, 3", return_tensors="pt")

>>> # By default, it continues generating according to the model's logits
>>> outputs = model.generate(**inputs, max_new_tokens=10)
>>> print(tokenizer.batch_decode(outputs)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8

>>> # `forced_eos_token_id` ensures the generation ends with a EOS token
>>> outputs = model.generate(**inputs, max_new_tokens=10, forced_eos_token_id=tokenizer.eos_token_id)
>>> print(tokenizer.batch_decode(outputs)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7,<|endoftext|>
```

#### __call__[[transformers.ForcedEOSTokenLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1681)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.InfNanRemoveLogitsProcessor[[transformers.InfNanRemoveLogitsProcessor]]

```python
transformers.InfNanRemoveLogitsProcessor()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1691)

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يزيل جميع قيم `nan` و`inf` لتفادي فشل طريقة التوليد. يُرجى ملاحظة أنه يجب استخدام معالج اللوجيت فقط عند الضرورة، إذ قد يُبطئ طريقة التوليد.

لا يوجد لهذا المعالج `generate` مثال، إذ لا ينبغي أن تكون هناك مجموعة صحيحة من الأعلام تبرر استخدامه.

#### __call__[[transformers.InfNanRemoveLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1700)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.LogitNormalization[[transformers.LogitNormalization]]

```python
transformers.LogitNormalization()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1814)

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) لتطبيع الدرجات باستخدام log-softmax. من المهم تطبيع الدرجات أثناء بحث الحزمة (beam search)، بعد تطبيق معالجات أو مشوّهات اللوجيتات، لأن خوارزمية البحث المستخدمة في هذه المكتبة لا تقوم بذلك (إنها تقوم به فقط قبل ذلك، لكن قد يكون هناك حاجة إلى إعادة تطبيع) رغم أنها تفترض أن الدرجات مُطبَّعة عند مقارنة الفرضيات.

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM
>>> import torch

>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2, 3", return_tensors="pt")

>>> # By default, the scores are not normalized -- the sum of their exponentials is NOT a normalized probability
>>> # distribution, summing to 1
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
>>> print(torch.allclose(torch.sum(torch.exp(outputs.scores[-1])), torch.Tensor((1.000,)), rtol=1e-4))
False

>>> # Normalizing them may have a positive impact on beam methods, or when using the scores on your application
>>> outputs = model.generate(**inputs, renormalize_logits=True, return_dict_in_generate=True, output_scores=True)
>>> print(torch.allclose(torch.sum(torch.exp(outputs.scores[-1])), torch.Tensor((1.000,)), rtol=1e-4))
True
```

#### __call__[[transformers.LogitNormalization.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1845)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.LogitsProcessor[[transformers.LogitsProcessor]]

```python
transformers.LogitsProcessor()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L49)

فئة أساسية مجردة لجميع معالجات اللوغيت التي يمكن تطبيقها أثناء التوليد.

#### __call__[[transformers.LogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L56)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.LogitsProcessorList[[transformers.LogitsProcessorList]]

```python
transformers.LogitsProcessorList(iterable = ())
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L63)

يمكن استخدام هذه الفئة لإنشاء قائمة من [LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) لمعالجة مدخلات متجه `scores` لاحقًا. ترث هذه الفئة من list وتضيف طريقة *__call__* محددة لتطبيق كل [LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) على المدخلات.

#### __call__[[transformers.LogitsProcessorList.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L70)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

kwargs (`dict[str, Any]`، *اختياري*) : معاملات إضافية (kwargs) خاصة بمعالج القيم اللوجستية (logits processor).

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.MinLengthLogitsProcessor[[transformers.MinLengthLogitsProcessor]]

```python
transformers.MinLengthLogitsProcessor(min_length: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu')
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L101)

**المعاملات:**

min_length (`int`) : الحد الأدنى للطول الذي إذا انخفضت عنه قيمة `eos_token_id` يتم ضبطها على `-float("Inf")`.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : المعرّف أو المعرّفات لرمز *نهاية التسلسل*.

device (`str`، *اختياري*، القيمة الافتراضية `"cpu"`) : الجهاز الذي سيُخصَّص فيه المتجهات.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) يفرض حدًا أدنى للطول عن طريق ضبط احتمال EOS على 0. لاحظ أنه، في حالة النماذج التي تعتمد على المُفكِّك فقط مثل معظم نماذج LLM، فإن الطول يشمل النص التمهيدي.

أمثلة:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")
>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("A number:", return_tensors="pt")
>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one

>>> # setting `min_length` to a value smaller than the uncontrolled output length has no impact
>>> gen_out = model.generate(**inputs, min_length=3)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one

>>> # setting a larger `min_length` will force the model to generate beyond its natural ending point, which is not
>>> # necessarily incorrect
>>> gen_out = model.generate(**inputs, min_length=10)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one thousand, nine hundred and ninety-four
```

#### __call__[[transformers.MinLengthLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L154)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.MinNewTokensLengthLogitsProcessor[[transformers.MinNewTokensLengthLogitsProcessor]]

```python
transformers.MinNewTokensLengthLogitsProcessor(prompt_length_to_skip: int, min_new_tokens: int, eos_token_id: typing.Union[int, list[int], torch.Tensor], device: str = 'cpu')
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L164)

**المعاملات:**

prompt_length_to_skip (`int`) : طول الرموز المدخلة. ليس حجةً صالحةً عند الاستخدام مع `generate` لأنه سيُسند طول الإدخال تلقائيًا.

min_new_tokens (`int`) : الحد الأدنى لطول الرموز *الجديدة* الذي إذا انخفضت عنه القيمة، يتم تعيين درجة `eos_token_id` إلى `-float("Inf")`.

eos_token_id (`Union[int, list[int], torch.Tensor]`) : المعرّف أو المعرّفات لرمز *نهاية التسلسل*.

device (`str`، *اختياري*، القيمة الافتراضية `"cpu"`) : الجهاز الذي سيُخصَّص فيه المتجهات.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) يفرض حدًا أدنى لطول الرموز الجديدة عن طريق ضبط احتمال رمز نهاية التسلسل (EOS) على 0. على عكس [MinLengthLogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.MinLengthLogitsProcessor)، يتجاهل هذا المعالج النص المُدخل.

أمثلة:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")
>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer(["A number:"], return_tensors="pt")
>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one

>>> # setting `min_new_tokens` will force the model to generate beyond its natural ending point, which is not
>>> # necessarily incorrect
>>> gen_out = model.generate(**inputs, min_new_tokens=2)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
A number: one thousand
```

#### __call__[[transformers.MinNewTokensLengthLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L226)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.MinPLogitsWarper[[transformers.MinPLogitsWarper]]

```python
transformers.MinPLogitsWarper(min_p: float, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L733)

**المعاملات:**

min_p (`float`) : الحد الأدنى لاحتمالية الرمز، والذي سيُضرب في احتمال الرمز الأكثر احتمالاً. يجب أن يكون قيمة بين 0 و 1. القيم النموذجية تقع في نطاق 0.01-0.2، وهي انتقائية بشكل مقارب لضبط `top_p` في نطاق 0.99-0.8 (استخدم القيم المعاكسة لقيم `top_p` المعتادة).

filter_value (`float`، *اختياري*، القيمة الافتراضية -inf) : سيتم تعيين جميع القيم المفلترة إلى قيمة float هذه.

min_tokens_to_keep (`int`، *اختياري*، القيمة الافتراضية 1) : الحد الأدنى لعدد الرموز التي لا يمكن تصفيتها.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي ينفّذ min-p، أي يحتفظ بجميع الرموز التي تتجاوز حدًّا أدنى من الاحتمال، مُقيَّسًا على احتمال الرمز الأكثر ترجيحًا. ونتيجةً لذلك، يصبح المرشّح أكثر صرامةً في وجود رموز ذات احتمالات عالية، وهو ما يُعدّ مؤشرًا على مخرَج واثق لا ينبغي الانحراف عنه.

يُستخدم غالبًا معًا مع [TemperatureLogitsWarper](/docs/transformers/main/ar/internal/generation_utils#transformers.TemperatureLogitsWarper). يُستخدم كبديل لـ [TopPLogitsWarper](/docs/transformers/main/ar/internal/generation_utils#transformers.TopPLogitsWarper) و [TopKLogitsWarper](/docs/transformers/main/ar/internal/generation_utils#transformers.TopKLogitsWarper).

أنشأه @menhguin و @kalomaze (معرّفات GitHub). تم تكييف الكود من [هذا الطلب الخارجي](https://github.com/oobabooga/text-generation-webui/pull/4449/files)

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With `min_p` sampling, the output gets restricted to high-probability tokens.
>>> # Pro tip: In practice, LLMs use `min_p` in the 0.01-0.2 range.
>>> outputs = model.generate(**inputs, do_sample=True, min_p=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9
```

#### __call__[[transformers.MinPLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L790)

#### transformers.NoBadWordsLogitsProcessor[[transformers.NoBadWordsLogitsProcessor]]

```python
transformers.NoBadWordsLogitsProcessor(bad_words_ids: list, eos_token_id: typing.Union[int, list[int], torch.Tensor, NoneType] = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1426)

**المعاملات:**

bad_words_ids (`list[list[int]]`) : قائمة من قوائم معرّفات الرموز التي لا يُسمح بتوليدها.

eos_token_id (`Union[int, list[int], torch.Tensor]`، *اختياري*) : المعرّف أو المعرّفات لرمز *نهاية التسلسل*.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) يفرض عدم اختيار تسلسلات محددة أبداً.

للحصول على معرّفات الرموز (token ids) للكلمات التي يجب ألا تظهر في النص المولّد، تأكد من تعيين `add_prefix_space=True` عند تهيئة مُجزّئ الرموز (tokenizer)، واستخدم `tokenizer(bad_words, add_special_tokens=False).input_ids`. يُدعم معامل `add_prefix_space` فقط لبعض مُجزّئات الرموز البطيئة، لأن سلوك إضافة البادئة في المُجزّئات السريعة يأتي من `pre tokenizers`. اقرأ المزيد [هنا](https://huggingface.co/docs/tokenizers/api/pre-tokenizers).

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> inputs = tokenizer(["In a word, the cake is a"], return_tensors="pt")

>>> output_ids = model.generate(inputs["input_ids"], max_new_tokens=5, pad_token_id=tokenizer.eos_token_id)
>>> print(tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0])
In a word, the cake is a bit of a mess.

>>> # Now let's take the bad words out. Please note that the tokenizer is initialized differently
>>> tokenizer_with_prefix_space = AutoTokenizer.from_pretrained("openai-community/gpt2", add_prefix_space=True)

>>> def get_tokens_as_list(word_list):
...     "Converts a sequence of words into a list of tokens"
...     tokens_list = []
...     for word in word_list:
...         tokenized_word = tokenizer_with_prefix_space([word], add_special_tokens=False).input_ids[0]
...         tokens_list.append(tokenized_word)
...     return tokens_list

>>> bad_words_ids = get_tokens_as_list(word_list=["mess"])
>>> output_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=5, bad_words_ids=bad_words_ids, pad_token_id=tokenizer.eos_token_id
... )
>>> print(tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0])
In a word, the cake is a bit of a surprise.
```

#### __call__[[transformers.NoBadWordsLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1318)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.NoRepeatNGramLogitsProcessor[[transformers.NoRepeatNGramLogitsProcessor]]

```python
transformers.NoRepeatNGramLogitsProcessor(ngram_size: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1102)

**المعاملات:**

ngram_size (`int`) : جميع الـ ngrams ذات الحجم `ngram_size` يمكن أن تظهر مرة واحدة فقط.

تُعدّ N-grams مجموعات من "n" كلمات أو أحرف أو رموز متتالية مأخوذة من تسلسل نصي. فبالنظر إلى الجملة: "She runs fast"، تكون ثنائيات الكلمات (n=2) هي ("she", "runs") و("runs", "fast"). في توليد النصوص، يؤدي تجنّب تكرار تسلسلات الكلمات إلى مخرجات أكثر تنوعاً. يفرض [LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) هذا عدم تكرار n-grams عن طريق تعيين درجات الرموز المحظورة إلى سالب ما لا نهاية، مما يستبعد تلك الرموز من الاعتبار عند المعالجة اللاحقة للدرجات. يُرجى ملاحظة أنه، في نماذج المُفكِّك فقط (decoder-only) مثل معظم LLMs، يُؤخذ في الاعتبار أيضاً النص التمهيد (prompt) للحصول على n-grams. [Fairseq](https://github.com/pytorch/fairseq/blob/a07cb6f40480928c9e0548b737aadd36ee66ac76/fairseq/sequence_generator.py#L345).

استخدم عقوبات n-gram بحذر. على سبيل المثال، معاقبة ثنائيات الكلمات (bigrams) في مقال عن مدينة نيويورك قد يؤدي إلى نتائج غير مرغوب فيها حيث يظهر اسم المدينة مرة واحدة فقط في النص بأكمله. [مرجع](https://huggingface.co/blog/how-to-generate)

أمثلة:

```py
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")
>>> inputs = tokenizer(["Today I"], return_tensors="pt")

>>> output = model.generate(**inputs)
>>> print(tokenizer.decode(output[0], skip_special_tokens=True))
Today I'm not sure if I'm going to be able to do it.

>>> # Now let's add ngram size using `no_repeat_ngram_size`. This stops the repetitions ("I'm") in the output.
>>> output = model.generate(**inputs, no_repeat_ngram_size=2)
>>> print(tokenizer.decode(output[0], skip_special_tokens=True))
Today I'm not sure if I can get a better understanding of the nature of this issue
```

#### __call__[[transformers.NoRepeatNGramLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1149)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.PrefixConstrainedLogitsProcessor[[transformers.PrefixConstrainedLogitsProcessor]]

```python
transformers.PrefixConstrainedLogitsProcessor(prefix_allowed_tokens_fn: Callable, num_beams: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1515)

**المعاملات:**

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`) : تُقيّد هذه دالة عملية البحث بالحزمة (beam search) على الرموز المسموح بها فقط في كل خطوة. تستقبل هذه الدالة حجتين: `inputs_ids` ومعرف الدفعة `batch_id`. يجب أن تُرجع قائمة بالرموز المسموح بها للخطوة التالية من التوليد، مشروطةً بالرموز المولَّدة سابقًا `inputs_ids` ومعرف الدفعة `batch_id`.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يفرض التوليد المقيد، وهو مفيد للتوليد المقيد المشروط على بادئة. راجع [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904) لمزيد من المعلومات.

أمثلة:

```py
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("Alice and Bob", return_tensors="pt")

>>> # By default, it continues generating according to the model's logits
>>> outputs = model.generate(**inputs, max_new_tokens=5)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice and Bob are friends

>>> # We can constrain it with `prefix_allowed_tokens_fn` to force a certain behavior based on a prefix.
>>> # For instance, we can force an entire entity to be generated when its beginning is detected.
>>> entity = tokenizer(" Bob Marley", return_tensors="pt").input_ids[0]  # 3 tokens
>>> def prefix_allowed_tokens_fn(batch_id, input_ids):
...     '''
...     Attempts to generate 'Bob Marley' when 'Bob' is detected.
...     In this case, `batch_id` is not used, but you can set rules for each batch member.
...     '''
...     if input_ids[-1] == entity[0]:
...         return [entity[1].item()]
...     elif input_ids[-2] == entity[0] and input_ids[-1] == entity[1]:
...         return [entity[2].item()]
...     return list(range(tokenizer.vocab_size))  # If no match, allow all tokens

>>> outputs = model.generate(**inputs, max_new_tokens=5, prefix_allowed_tokens_fn=prefix_allowed_tokens_fn)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
Alice and Bob Marley
```

#### __call__[[transformers.PrefixConstrainedLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1566)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.RepetitionPenaltyLogitsProcessor[[transformers.RepetitionPenaltyLogitsProcessor]]

```python
transformers.RepetitionPenaltyLogitsProcessor(penalty: float, prompt_ignore_length: typing.Union[int, torch.Tensor, NoneType] = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L306)

**المعاملات:**

penalty (`float`) : معامل عقوبة التكرار. القيمة 1.0 تعني عدم وجود عقوبة. القيم أعلى من 1.0 تفرض عقوبة على الرموز التي تم توليدها سابقًا. القيم بين 0.0 و 1.0 تمنح مكافأة للرموز التي تم توليدها سابقًا.

prompt_ignore_length (`int` أو `torch.LongTensor`، *اختياري*) : عدد الرموز الأولية التي يجب تجاهلها، مع إمكانية تحديد ذلك لكل عنصر في الدفعة.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) يمنع تكرار الرموز السابقة من خلال عقوبة. تُطبَّق هذه العقوبة مرة واحدة كحد أقصى لكل رمز. لاحظ أنه، في نماذج المُفكِّك فقط مثل معظم نماذج اللغة الكبيرة، تشمل الرموز المُعتبَرة النص المُدخل افتراضياً.

في [الورقة](https://huggingface.co/papers/1909.05858) الأصلية، يقترح المؤلفون استخدام عقوبة تبلغ حوالي 1.2 لتحقيق توازن جيد بين التوليد الصادق وغياب التكرار. لعقاب التكرار وتقليله، استخدم قيم `penalty` أعلى من 1.0، حيث إن القيمة الأعلى تعني عقوبة أقوى. لمكافأة التكرار وتشجيعه، استخدم قيم `penalty` بين 0.0 و1.0، حيث إن القيمة الأدنى تعني مكافأة أقوى.

أمثلة:

```py
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, RepetitionPenaltyLogitsProcessor

>>> # Initializing the model and tokenizer for it
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")
>>> inputs = tokenizer(["I'm not going to"], return_tensors="pt")

>>> # This shows a normal generate without any specific parameters
>>> summary_ids = model.generate(**inputs)
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True)[0])
I'm not going to be able to do that. I'm going to be able to do that

>>> # This generates a penalty for repeated tokens
>>> penalized_ids = model.generate(**inputs, repetition_penalty=1.1)
>>> print(tokenizer.batch_decode(penalized_ids, skip_special_tokens=True)[0])
I'm not going to be able to do that. I'll just have to go out and play

>>> # We can also exclude the input prompt by creating an instance of this class
>>> # with a `prompt_ignore_length` and passing it as a custom logit processor
>>> rep_pen_processor = RepetitionPenaltyLogitsProcessor(
...     penalty=1.1,
...     prompt_ignore_length=inputs["input_ids"].shape[-1]
... )
>>> penalized_ids = model.generate(**inputs, logits_processor=[rep_pen_processor])
>>> print(tokenizer.batch_decode(penalized_ids, skip_special_tokens=True)[0])
I'm not going to be able to do that. I'm going to have to go through a lot of things, and
```

#### __call__[[transformers.RepetitionPenaltyLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L373)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.SequenceBiasLogitsProcessor[[transformers.SequenceBiasLogitsProcessor]]

```python
transformers.SequenceBiasLogitsProcessor(sequence_bias: list)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1242)

**المعاملات:**

sequence_bias (`list[list[Union[list[int], float]]]`) : قائمة من القوائم تُطابق تسلسلًا من الرموز (tokens) مع حدّ انحيازها (e.g. `[[[10, 45], -2.0], [[64], -7.5]]`). تزيد الانحيازات الموجبة من احتمالية اختيار التسلسل، بينما تفعل الانحيازات السالبة العكس. إذا كان طول التسلسل يساوي 1، فسيُطبَّق انحيازه دائمًا. وإلا، فلن يُطبَّق الانحياز إلا إذا كان التسلسل المعني على وشك الاكتمال (في خطوة اختيار الرمز بعد تطبيق هذا المعالج).

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) يطبّق انحيازاً إضافياً على التسلسلات. يُطبَّق الانحياز على الرمز الأخير في التسلسل عندما يمكن للرمز المولَّد التالي إكمال هذا التسلسل. وبالتالي، للاستفادة القصوى من انحياز التسلسلات التي تتكون من أكثر من رمز، يُنصح باستخدام طرق الحزمة (لتجاوز التسلسلات المكتملة جزئياً ذات الانحياز السلبي بسلاسة) وتطبيق الانحياز على بادئاتها (لضمان تطبيق الانحياز في مرحلة مبكرة).

على مستوى الرموز، فإن تحيّز كلمة يختلف عن تحيّز كلمة يسبقها مسافة. إذا كنت ترغب في تحيّز "foo" في منتصف الجملة، فمن المرجح أنك ستحتاج إلى إضافة مسافة بادئة وتحيّز " foo" بدلاً من ذلك. راجع قسم المرمّز في دورة معالجة اللغة الطبيعية لدينا لمعرفة السبب: https://huggingface.co/learn/nlp-course/chapter2/4?fw=pt

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
>>> inputs = tokenizer(["The full name of Donald is Donald"], return_tensors="pt")

>>> summary_ids = model.generate(inputs["input_ids"], max_new_tokens=4, do_sample=False)
>>> print(tokenizer.batch_decode(summary_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald John Trump Sr.

>>> def get_tokens(word):
...     return tokenizer([word], add_special_tokens=False).input_ids[0]

>>> # IMPORTANT: Remember our tip about adding spaces before words to bias them correctly.
>>> sequence_bias = [[get_tokens("Trump"), -10.0],]  # will fail to apply bias
>>> biased_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=4, do_sample=False, sequence_bias=sequence_bias
... )
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald John Trump Sr.

>>> sequence_bias = [[get_tokens(" Trump"), -10.0],]  # will work
>>> biased_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=4, do_sample=False, sequence_bias=sequence_bias
... )
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald John Harper. He

>>> # We can also add a positive bias to nudge the model towards specific tokens or continuations. This technique
>>> # is also more effective when paired up with beam search.
>>> sequence_bias = [[get_tokens(" Donald Duck"), 10.0],]
>>> biased_ids = model.generate(
...     inputs["input_ids"], max_new_tokens=4, num_beams=4, do_sample=False, sequence_bias=sequence_bias
... )
>>> print(tokenizer.batch_decode(biased_ids, skip_special_tokens=True)[0])
The full name of Donald is Donald Duck. He is
```

#### __call__[[transformers.SequenceBiasLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1318)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.SuppressTokensAtBeginLogitsProcessor[[transformers.SuppressTokensAtBeginLogitsProcessor]]

```python
transformers.SuppressTokensAtBeginLogitsProcessor(begin_suppress_tokens, begin_index, device: str = 'cpu')
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1851)

يُكبح [SuppressTokensAtBeginLogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.SuppressTokensAtBeginLogitsProcessor) قائمةً من الرموز فور بدء دالة `generate` في التوليد باستخدام رموز `begin_index`. وهذا يضمن عدم توليد الرموز المعرّفة بواسطة `begin_suppress_tokens` في البداية. أُنشئ في الأصل لـ [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper).

أمثلة:

```python
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")

>>> # Whisper has `begin_suppress_tokens` set by default (= `[220, 50256]`). 50256 is the EOS token, so this means
>>> # it can't generate and EOS token in the first iteration, but it can in the others.
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
>>> print(outputs.scores[0][0, 50256])
tensor(-inf)
>>> print(outputs.scores[-1][0, 50256])  # in other places we can see some probability mass for EOS
tensor(29.9010)

>>> # If we disable `begin_suppress_tokens`, we can generate EOS in the first iteration.
>>> outputs = model.generate(
...     **inputs, return_dict_in_generate=True, output_scores=True, begin_suppress_tokens=None
... )
>>> print(outputs.scores[0][0, 50256])
tensor(11.2027)
```

#### __call__[[transformers.SuppressTokensAtBeginLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1893)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.SuppressTokensLogitsProcessor[[transformers.SuppressTokensLogitsProcessor]]

```python
transformers.SuppressTokensLogitsProcessor(suppress_tokens, device: str = 'cpu')
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1904)

يمكن استخدام هذا المعالج لإخفاء قائمة من الرموز. سيقوم المعالج بإعداد احتمالات السجل الخاصة بها إلى `-inf` حتى لا يتم توليدها. تم إنشاؤه في الأصل لـ [Whisper](https://huggingface.co/docs/transformers/model_doc/whisper).

أمثلة:

```python
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")

>>> # Whisper has a long list of suppressed tokens. For instance, in this case, the token 1 is suppressed by default.
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True)
>>> print(outputs.scores[1][0, 1])  # 1 (and not 0) is the first freely generated token
tensor(-inf)

>>> # If we disable `suppress_tokens`, we can generate it.
>>> outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True, suppress_tokens=None)
>>> print(outputs.scores[1][0, 1])
tensor(6.0678)
```

#### __call__[[transformers.SuppressTokensLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1936)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.SynthIDTextWatermarkLogitsProcessor[[transformers.SynthIDTextWatermarkLogitsProcessor]]

```python
transformers.SynthIDTextWatermarkLogitsProcessor(ngram_len: int, keys: list, sampling_table_size: int, sampling_table_seed: int, context_history_size: int, device: device, skip_first_ngram_calls: bool = False, debug_mode: bool = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2605)

**المعاملات:**

ngram_len (`int`) : طول Ngram.

keys (`list[int]`) : تسلسل من مفاتيح العلامة المائية، مفتاح واحد لكل عمق.

sampling_table_size (`int`) : حجم جدول العينة.

sampling_table_seed (`int`) : البذرة العشوائية لتوليد جدول العينة.

context_history_size (`int`) : حجم المصفوفة (Tensor) لتتبع السياقات التي تم رصدها.

device (`torch.device`) : الجهاز المستخدم.

skip_first_ngram_calls (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان سيتم تخطي استدعاءات ngram الأولى.

debug_mode (`bool`، *اختياري*، القيمة الافتراضية `False`) : يتم تعديل القيم اللوجستية (Logits) لتصبح موحّدة قبل تطبيق تعديل العلامة المائية. يُستخدم هذا الاختبار للتحقق من صحة التنفيذ.

معالج logits يطبّق تقنيات العلامة المائية لنماذج توليد النص. يسهّل هذا الصنف تطبيق العلامة المائية SynthID للنص، وهي طريقة لزرع إشارات غير محسوسة في النص المولّد للمساعدة في اكتشاف المحتوى الاصطناعي. يعمل هذا المعالج عن طريق التلاعب الدقيق في احتمالات اختيار الرموز أثناء توليد النص، بطريقة يمكن استعادتها لاحقًا بشكل موثوق لأغراض التحقق.

الميزات الرئيسية:
* **إدارة الحالة:** يحافظ على حالة داخلية لتتبع تسلسلات الرموز وتوليد مفاتيح العلامة المائية
ديناميكيًا.

* **توليد المفاتيح:** يحسب التجزئات (hashes) بناءً على تسلسلات الرموز (tokens) ومعلمات العلامة المائية لإنشاء مفاتيح فريدة
لكل موضع.

* **عينة قيمة G:** تستخدم جدول عينات محسوباً مسبقاً لأخذ عينات من قيم العلامة المائية (قيم g) بناءً على
المفاتيح المولّدة.

* **تعديل الدرجة:** يطبّق قيم g المحسوبة لتعديل احتمالات الرموز أثناء التوليد، مع تضمين
علامة مائية.

* **معالجة تكرار السياق:** تتضمن منطقاً لتجنب وضع علامة مائية على الرموز في السياقات المتكررة،
الحفاظ على الطابع الطبيعي.

* **إخفاء رمز نهاية الجملة:** يدعم إخفاء رموز نهاية الجملة لمنع تضمينها في العلامة المائية
الحسابات.

* **دوال الأداة:** توفر دوالًا لحساب قيم g مباشرةً، والتحقق من تكرار السياق، وإنشاء
أقنعة رمز EOS، وتقدير قيم g المتوسطة المتوقعة.

راجع رابط الورقة: https://www.nature.com/articles/s41586-024-08025-4 لمزيد من التفاصيل حول هذا الموضوع.

أمثلة:
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig

>>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b', padding_side="left")
>>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b')

>>> # SynthID Text configuration
>>> watermarking_config = SynthIDTextWatermarkingConfig(
...     keys=[654, 400, 836, 123, 340, 443, 597, 160, 57],
...     ngram_len=5,
... )

>>> # Generation with watermarking
>>> tokenized_prompts = tokenizer(["Once upon a time, "], return_tensors="pt", padding=True)
>>> output_sequences = model.generate(
...     **tokenized_prompts, watermarking_config=watermarking_config, do_sample=True, max_new_tokens=10
... )
>>> watermarked_text = tokenizer.batch_decode(output_sequences, skip_special_tokens=True)
```

#### __call__[[transformers.SynthIDTextWatermarkLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2743)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.TemperatureLogitsWarper[[transformers.TemperatureLogitsWarper]]

```python
transformers.TemperatureLogitsWarper(temperature: float)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L238)

**المعاملات:**

temperature (`float`) : قيمة فاصلة عشرية موجبة تمامًا تُستخدم لضبط توزيع اللوغيت. تقلل القيمة الأصغر من `1` من العشوائية (والعكس صحيح)، حيث يُعادل `0` نقل كل كتلة الاحتمال إلى الرمز الأكثر احتمالًا.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) لدرجة الحرارة (تصعيد أُسّي لتوزيع احتمالات الإخراج)، مما يعني عملياً أنه يمكنه التحكم في عشوائية الرموز المتوقعة. يُستخدم غالباً مع [TopPLogitsWarper](/docs/transformers/main/ar/internal/generation_utils#transformers.TopPLogitsWarper) و[TopKLogitsWarper](/docs/transformers/main/ar/internal/generation_utils#transformers.TopKLogitsWarper).

تأكد من تضمين `do_sample=True` في معاملات `generate`، وإلا فلن يكون لقيمة درجة الحرارة أي تأثير.

أمثلة:

```python
>>> import torch
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(0)  # for reproducibility

>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> model.config.pad_token_id = model.config.eos_token_id
>>> inputs = tokenizer(["Hugging Face Company is"], return_tensors="pt")

>>> # With temperature=1.0, the default, we consistently get random outputs due to random sampling.
>>> generate_kwargs = {"max_new_tokens": 10, "do_sample": True, "temperature": 1.0, "num_return_sequences": 2}
>>> outputs = model.generate(**inputs, **generate_kwargs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
['Hugging Face Company is one of these companies that is going to take a',
"Hugging Face Company is a brand created by Brian A. O'Neil"]

>>> # However, with temperature close to 0, it approximates greedy decoding strategies (invariant)
>>> generate_kwargs["temperature"] = 0.0001
>>> outputs = model.generate(**inputs, **generate_kwargs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True))
['Hugging Face Company is a company that has been around for over 20 years',
'Hugging Face Company is a company that has been around for over 20 years']
```

#### __call__[[transformers.TemperatureLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L300)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.TopHLogitsWarper[[transformers.TopHLogitsWarper]]

```python
transformers.TopHLogitsWarper(top_h: float, filter_value: float = -inf)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L627)

**المعاملات:**

top_h (`float`) : معامل التوسيع للعتبة القائمة على الإنتروبيا (`tau`). يجب أن يكون ضمن المدى `(0, 1]`.

filter_value (`float`، *اختياري*، القيمة الافتراضية -inf) : سيتم تعيين جميع القيم المفلترة إلى قيمة float هذه.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يطبّق أخذ العينات Top-H، وهو أسلوب فكّ ترميز يختار بشكل تكيفي مجموعة فرعية من الرموز ذات الاحتمالية العالية بناءً على قيود الإنتروبيا والاحتمالية التراكمية.

تحدد هذه الطريقة ديناميكيًا عدد الرموز التي يجب الاحتفاظ بها من خلال تحليل فرق الإنتروبيا في التوزيع المختار، مما يحقق التوازن بين الاستكشاف والاستغلال. كما تضمن أن النص المولّد يحافظ على التناسق والتماسك معًا.

مرجع: للاطلاع على التفاصيل، راجع *فك الترميز Top-H: تكييف الإبداع والاتساق باستخدام إنتروبيا محدودة في توليد النص* (NeurIPS 2025): https://arxiv.org/abs/2509.02510

مثال:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> outputs = model.generate(**inputs, do_sample=True, top_h=0.4)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9
```

#### __call__[[transformers.TopHLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L678)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : معرّفات الرموز المدخلة.

scores (`torch.Tensor` من الشكل `(batch_size, vocab_size)`) : القيم الخام (logits) من النموذج.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, vocab_size)`

القيم الناتجة (Logits) بعد المعالجة حيث يتم إخفاء الرموز غير الصالحة باستخدام `-inf`.

يقوم بترشيح القيم اللوجستية (logits) باستخدام أخذ العينة Top-H.

#### transformers.TopKLogitsWarper[[transformers.TopKLogitsWarper]]

```python
transformers.TopKLogitsWarper(top_k: int, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L571)

**المعاملات:**

top_k (`int`) : عدد رموز المفردات ذات أعلى احتمالات التي يجب الاحتفاظ بها لتصفية top-k.

filter_value (`float`، *اختياري*، القيمة الافتراضية -inf) : سيتم تعيين جميع القيم المفلترة إلى قيمة float هذه.

min_tokens_to_keep (`int`، *اختياري*، القيمة الافتراضية 1) : الحد الأدنى لعدد الرموز التي لا يمكن تصفيتها.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يقوم بتنفيذ top-k، أي تقييد النتائج على العناصر ذات الاحتمالية الأعلى عددها k. يُستخدم غالباً مع [TemperatureLogitsWarper](/docs/transformers/main/ar/internal/generation_utils#transformers.TemperatureLogitsWarper) و[TopPLogitsWarper](/docs/transformers/main/ar/internal/generation_utils#transformers.TopPLogitsWarper).

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: A, B, C, D", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: A, B, C, D, E — S — O, P — R

>>> # With `top_k` sampling, the output gets restricted the k most likely tokens.
>>> # Pro tip: In practice, LLMs use `top_k` in the 5-50 range.
>>> outputs = model.generate(**inputs, do_sample=True, top_k=2)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: A, B, C, D, E, F, G, H, I
```

#### __call__[[transformers.TopKLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L618)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.TopPLogitsWarper[[transformers.TopPLogitsWarper]]

```python
transformers.TopPLogitsWarper(top_p: float, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L502)

**المعاملات:**

top_p (`float`) : إذا تم ضبطه على قيمة أقل من 1، فإن مجموعة الرموز الأكثر احتمالاً الأصغر، التي تضيف احتمالاتها إلى `top_p` أو أعلى، هي التي تُحتفظ بها فقط للتوليد.

filter_value (`float`، *اختياري*، القيمة الافتراضية -inf) : سيتم تعيين جميع القيم المفلترة إلى قيمة float هذه.

min_tokens_to_keep (`int`، *اختياري*، القيمة الافتراضية 1) : الحد الأدنى لعدد الرموز التي لا يمكن تصفيتها.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يقوم بتطبيق top-p، أي تقييد النماذج على الرموز العلوية التي يبلغ مجموعها prob_cut_off <= prob_cut_off. يُستخدم غالباً مع [TemperatureLogitsWarper](/docs/transformers/main/ar/internal/generation_utils#transformers.TemperatureLogitsWarper) و[TopKLogitsWarper](/docs/transformers/main/ar/internal/generation_utils#transformers.TopKLogitsWarper).

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> set_seed(1)
>>> model = AutoModelForCausalLM.from_pretrained("distilbert/distilgpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilgpt2")

>>> inputs = tokenizer("A sequence: 1, 2", return_tensors="pt")

>>> # With sampling, the output is unexpected -- sometimes too unexpected.
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3 | < 4 (left-hand pointer) ;
<BLANKLINE>
<BLANKLINE>

>>> # With `top_p` sampling, the output gets restricted to high-probability tokens.
>>> # Pro tip: In practice, LLMs use `top_p` in the 0.9-0.95 range.
>>> outputs = model.generate(**inputs, do_sample=True, top_p=0.1)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
A sequence: 1, 2, 3, 4, 5, 6, 7, 8, 9
```

#### __call__[[transformers.TopPLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L555)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.TypicalLogitsWarper[[transformers.TypicalLogitsWarper]]

```python
transformers.TypicalLogitsWarper(mass: float = 0.9, filter_value: float = -inf, min_tokens_to_keep: int = 1)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L809)

**المعاملات:**

mass (`float`، *اختياري*، القيمة الافتراضية 0.9) : قيمة typical_p بين 0 و1 شاملة الطرفين، والقيمة الافتراضية هي 0.9.

filter_value (`float`، *اختياري*، القيمة الافتراضية -inf) : سيتم تعيين جميع القيم المفلترة إلى قيمة float هذه.

min_tokens_to_keep (`int`، *اختياري*، القيمة الافتراضية 1) : الحد الأدنى لعدد الرموز التي لا يمكن تصفيتها.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يقوم بفك الترميز النموذجي. مستوحى من طريقة استخدام البشر للغة، فإنه يعطي الأولوية للرموز التي تكون احتمالية السجل (log probability) الخاصة بها قريبة من إنتروبيا توزيع احتمالات الرموز. وهذا يعني أن الرموز الأكثر احتمالاً قد تُستبعد أثناء العملية.

راجع [التفكيك النموذجي لتوليد اللغة الطبيعية](https://huggingface.co/papers/2202.00666) لمزيد من المعلومات.

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, set_seed

>>> model = AutoModelForCausalLM.from_pretrained("bigscience/bloomz-560m")
>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloomz-560m")

>>> inputs = tokenizer("1, 2, 3", return_tensors="pt")

>>> # We can see that greedy decoding produces a sequence of numbers
>>> outputs = model.generate(**inputs)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

>>> # For this particular seed, we can see that sampling produces nearly the same low-information (= low entropy)
>>> # sequence
>>> set_seed(18)
>>> outputs = model.generate(**inputs, do_sample=True)
>>> print(tokenizer.batch_decode(outputs, skip_special_tokens=True)[0])
1, 2, 3, 4, 5, 6, 7, 8, 9 and 10

>>> # With `typical_p` set, the most obvious sequence is no longer produced, which may be good for your problem
>>> set_seed(18)
>>> outputs = model.generate(
...     **inputs, do_sample=True, typical_p=0.1, return_dict_in_generate=True, output_scores=True
... )
>>> print(tokenizer.batch_decode(outputs.sequences, skip_special_tokens=True)[0])
1, 2, 3 and 5

>>> # We can see that the token corresponding to "4" (token 934) in the second position, the most likely token
>>> # as seen with greedy decoding, was entirely blocked out
>>> print(outputs.scores[1][0, 934])
tensor(-inf)
```

#### __call__[[transformers.TypicalLogitsWarper.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L873)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor[[transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor]]

```python
transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor(guidance_scale: float, model, unconditional_ids: typing.Optional[torch.LongTensor] = None, unconditional_attention_mask: typing.Optional[torch.LongTensor] = None, use_cache: bool = True)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2267)

**المعاملات:**

guidance_scale (`float`) : مقياس التوجيه الخاص بالتوجيه الحر للمصنّف (CFG). يتم تفعيل CFG عن طريق تعيين `guidance_scale != 1`. كلما زاد مقياس التوجيه، شجّع النموذج على توليد عينات أكثر ارتباطًا بعبارة الإدخال، وعادةً على حساب جودة أدنى. أما القيمة الأصغر من 1 فتُحدث التأثير العكسي، مع جعل العبارة السلبية المُقدَّمة عبر negative_prompt_ids (إن وُجدت) تعمل كعبارة إيجابية.

model (`PreTrainedModel`) : النموذج الذي يحسب الدرجات غير الشرطية. يُفترض أن يكون هو نفسه النموذج الذي يحسب الدرجات الشرطية. يجب أن يستخدم كلا النموذجين نفس المرمّز (tokenizer).

unconditional_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`، *اختياري*) : فهارس رموز تسلسل الإدخال في قاموس الكلمات لفرع عدم الشرطية. إذا لم يتم تعيينه، فسيتم افتراض الرمز الأخير من الموجه.

unconditional_attention_mask (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`، *اختياري*) : قناع الانتباه (Attention mask) الخاص بـ unconditional_ids.

use_cache (`bool`، *اختياري*، القيمة الافتراضية `True`) : ما إذا كان سيتم تخزين المفاتيح/القيم مؤقتًا (cache) أثناء تمرير الأمامي للموجّه السلبي.

معالج اللوغيتس للإرشاد الحر من التصنيف (CFG). يحسب المعالج متوسطًا مرجّحًا عبر الدرجات المستمدة من اللوغيتس الشرطية على الموجّه وغير الشرطية (أو السالبة)، معتمداً على المعامل `guidance_scale`. تُحسب الدرجات غير الشرطية داخلياً عن طريق تقديم `unconditional_ids` إلى `model`.

راجع [الورقة البحثية](https://huggingface.co/papers/2306.17806) لمزيد من المعلومات.

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> inputs = tokenizer(["Today, a dragon flew over Paris, France,"], return_tensors="pt")
>>> out = model.generate(inputs["input_ids"], guidance_scale=1.5)
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Today, a dragon flew over Paris, France, killing at least 50 people and injuring more than 100'

>>> # with a negative prompt
>>> neg_inputs = tokenizer(["A very happy event happened,"], return_tensors="pt")
>>> out = model.generate(inputs["input_ids"], guidance_scale=2, negative_prompt_ids=neg_inputs["input_ids"])
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Today, a dragon flew over Paris, France, killing at least 130 people. French media reported that'

>>> # with a positive prompt
>>> neg_inputs = tokenizer(["A very happy event happened,"], return_tensors="pt")
>>> out = model.generate(inputs["input_ids"], guidance_scale=0, negative_prompt_ids=neg_inputs["input_ids"])
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
"Today, a dragon flew over Paris, France, and I'm very happy to be here. I"
```

#### __call__[[transformers.UnbatchedClassifierFreeGuidanceLogitsProcessor.__call__]]

```python
__call__(input_ids, scores)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2373)

#### transformers.WhisperTimeStampLogitsProcessor[[transformers.WhisperTimeStampLogitsProcessor]]

```python
transformers.WhisperTimeStampLogitsProcessor(generate_config: GenerationConfig, begin_index: int, _detect_timestamp_from_logprob: bool | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L1944)

**المعاملات:**

generate_config (`GenerateConfig`) : إعدادات التوليد المستخدمة لتوليد المخرجات. المعلمات التالية مطلوبة: eos_token_id (`int`، *اختياري*، القيمة الافتراضية 50257): المعرّف الخاص برمz *نهاية التسلسل*. no_timestamps_token_id (`int`، *اختياري*، القيمة الافتراضية 50363): المعرّف الخاص برمz `"<|notimestamps|>"`. max_initial_timestamp_index (`int`، *اختياري*، القيمة الافتراضية 1): يُستخدم لضبط القيمة القصوى للوقت الزمني الأولي. يُستخدم هذا لمنع النموذج من التنبؤ بأوقات زمنية بعيدة جداً في المستقبل.

begin_index (`int`) : فهرس الرمز (Token) للرمز الأول الذي يولّده النموذج.

_detect_timestamp_from_logprob (`bool`، *اختياري*) : ما إذا كان يمكن التنبؤ بالطوابع الزمنية من الاحتمالات اللوجستية (logprobs) لجميع الطوابع الزمنية.

[LogitsProcessor](/docs/transformers/main/ar/internal/generation_utils#transformers.LogitsProcessor) الذي يعدّل القيم الأولية (logits) الخاصة بتوليد أختام الزمان في النص المنقول. عندما تصل الرموز المدخلة إلى حدّ معين، يضبط المعالج القيم على سالب ما لا نهاية. ويضمن المعالج ظهور رموز أختام الزمان في أزواج، وذلك عبر إخفاء القيم الأولية التي من شأنها أن تكسر نمط هذا الاقتران. يتم ذلك للحفاظ على اتساق وبنية أختام الزمان المولّدة. كما يضمن أنه عندما تكون الاحتمالية المتوقعة لأخذ أي من رموز أختام الزمان أكبر من أي رمز غير ختم زمان على حدة، تُضبط القيم الأولية للرموز غير أختام الزمان على سالب ما لا نهاية. يتم ذلك لضمان توليد أختام الزمان بدلاً من الرموز الأخرى المحتملة.

راجع [الورقة البحثية](https://huggingface.co/papers/2212.04356) لمزيد من المعلومات.

أمثلة:
``` python
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration, GenerationConfig
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[3]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features

>>> #Displaying timestamps
>>> generated_ids = model.generate(inputs=input_features, return_timestamps=True)
>>> transcription = processor.batch_decode(generated_ids, decode_with_timestamps=True)[0]
>>> print("Transcription:", transcription)
Transcription: <|startoftranscript|><|0.00|> He has grave doubts whether Sir Frederick Layton's work is really Greek after all, and can<|6.44|><|6.44|> discover in it but little of rocky Ithaca.<|9.44|><|endoftext|>

>>> #No timestamps & change EOS:
>>> #This allows the user to select a specific token to terminate the sequence on, in this case it's the word "can"(460)
>>> model.generation_config.eos_token_id = 460
>>> generated_ids = model.generate(inputs=input_features,return_timestamps=False)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print("Transcription:", transcription)
Transcription:  He has grave doubts whether Sir Frederick Layton's work is really Greek after all and can
```

#### __call__[[transformers.WhisperTimeStampLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2034)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

#### transformers.WatermarkLogitsProcessor[[transformers.WatermarkLogitsProcessor]]

```python
transformers.WatermarkLogitsProcessor(vocab_size, device, greenlist_ratio: float = 0.25, bias: float = 2.0, hashing_key: int = 15485863, seeding_scheme: str = 'lefthash', context_width: int = 1)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2432)

**المعاملات:**

vocab_size (`int`) : حجم مفردات مُجزِّئ النموذج (vocab_size). يُستخدم لحساب نسبة الرموز "الخضراء".

device (`str`) : الجهاز الذي يُخصَّص عليه النموذج.

greenlist_ratio (`float`، اختياري، *اختياري*، القيمة الافتراضية 0.25) : نسبة الرموز "الخضراء" المستخدمة إلى حجم المفردات. القيمة الافتراضية هي 0.25.

bias (`float`، اختياري، *اختياري*، القيمة الافتراضية 2.0) : الانحياز المُضاف إلى قيم logits للرموز "الخضراء" المحددة. يُنصح بخفض قيمة `bias` إذا تدهورت جودة توليد النص. القيم الموصى بها تقع ضمن النطاق [0.5، 2.0]. القيمة الافتراضية هي 2.0.

hashing_key (`int`، اختياري، *اختياري*، القيمة الافتراضية 15485863) : المفتاح المستخدم للتجزئة. إذا كنت تنشر هذا العلامة المائية، فننصحك باستخدام مفتاح خاص آخر. القيمة الافتراضية هي 15485863 (العدد الأولي المليون).

seeding_scheme (`str`، اختياري، *اختياري*، القيمة الافتراضية `"lefthash"`) : مخطط التهيئة المستخدم لاختيار الرموز "الخضراء". يقبل القيم التالية: - "lefthash" (الافتراضي): يعتمد اختيار الرموز "الخضراء" على الرمز الأخير (الخوارزمية 2 من الورقة البحثية) - "selfhash": يعتمد اختيار الرموز "الخضراء" على الرمز الحالي نفسه (الخوارزمية 3 من الورقة البحثية) العيب في هذا المخطط أنه يأخذ في الاعتبار جميع الرموز التالية المحتملة، وقد يكون أبطأ من "lefthash". طول السياق للرموز السابقة المستخدمة في التهيئة. كلما زاد طول السياق، أصبحت العلامة المائية أكثر متانة.

context_width (`int`، *اختياري*، القيمة الافتراضية 1) : عدد الرموز السابقة المستخدمة عند تعيين البذرة.

معالج اللوغيتس (Logits) لوضع علامة مائية على النص المولّد. يعدّل المعالج درجات مخرجات النموذج عن طريق إضافة انحياز صغير إلى مجموعة عشوائية من الرموز "الخضراء" قبل توليد الرمز التالي. تعتمد عملية اختيار الرموز "الخضراء" على `seeding_scheme` المستخدم. استُند الكود إلى [المستودع الأصلي](https://github.com/jwkirchenbauer/lm-watermarking/tree/main).

يمكن اكتشاف النص الذي يولّده هذا `LogitsProcessor` باستخدام `WatermarkDetector`. راجع [__call__()](/docs/transformers/main/ar/internal/generation_utils#transformers.WatermarkDetector.__call__) للتفاصيل،

راجع [الورقة البحثية](https://huggingface.co/papers/2306.04634) لمزيد من المعلومات.

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkingConfig

>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> inputs = tokenizer(["Alice and Bob are"], return_tensors="pt")

>>> # normal generation
>>> out = model.generate(inputs["input_ids"], max_length=20, do_sample=False)
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Alice and Bob are both in the same room.\n\n"I\'m not sure if you\'re'

>>> # watermarked generation
>>> watermarking_config = WatermarkingConfig(bias=2.5, context_width=2, seeding_scheme="selfhash")
>>> out = model.generate(inputs["input_ids"], watermarking_config=watermarking_config, max_length=20, do_sample=False)
>>> tokenizer.batch_decode(out, skip_special_tokens=True)[0]
'Alice and Bob are both still alive and well and the story is pretty much a one-hour adventure'

>>> # to detect watermarked text use the WatermarkDetector class
>>> from transformers import WatermarkDetector
>>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config= watermarking_config)
>>> detection_preds = detector(out)
>>> detection_preds
array([ True])
```

#### __call__[[transformers.WatermarkLogitsProcessor.__call__]]

```python
__call__(input_ids: LongTensor, scores: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/logits_process.py#L2554)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`torch.Tensor` من الشكل `(batch_size, config.vocab_size)`) : درجات التنبؤ لرأس نمذجة اللغة. يمكن أن تكون هذه القيم قيم لوجيت (logits) لكل عنصر في المفردات عند عدم استخدام بحث الحزمة (beam search)، أو قيم لوج سوفت ماكس (log softmax) لكل رمز في المفردات عند استخدام بحث الحزمة.

**يعيد:** `torch.Tensor` من الشكل `(batch_size, config.vocab_size)`

درجات التنبؤ المعالجة.

## StoppingCriteria[[transformers.StoppingCriteria]]

يمكن استخدام [StoppingCriteria](/docs/transformers/main/ar/internal/generation_utils#transformers.StoppingCriteria) لتغيير وقت إيقاف التوليد (باستثناء رمز EOS). يرجى ملاحظة أن هذا متاح حصريًا لتنفيذات PyTorch الخاصة بنا.

#### transformers.StoppingCriteria[[transformers.StoppingCriteria]]

```python
transformers.StoppingCriteria()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L48)

فئة أساسية مجردة لجميع معايير التوقف التي يمكن تطبيقها أثناء التوليد.

إذا كان معيار التوقف لديك يعتمد على مدخل `scores`، فتأكد من تمرير `return_dict_in_generate=True, output_scores=True` إلى `generate`.

#### __call__[[transformers.StoppingCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L55)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. يمكن الحصول على الفهارس باستخدام [AutoTokenizer](/docs/transformers/main/ar/model_doc/auto#transformers.AutoTokenizer). راجع [PreTrainedTokenizer.encode()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) و [PreTrainedTokenizer.__call__()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) للتفاصيل. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : درجات التنبؤ لرأس نمذجة اللغة، على شكل مجموعة (tuple) تحتوي على مصفوفة (tensor) واحدة لكل خطوة توليد، وكل منها على شكل `(batch_size, config.vocab_size)`. يمكن أن تكون هذه الدرجات لكل رمز في المفردات قبل SoftMax أو بعد SoftMax. إذا كان معيار التوقف يعتمد على مدخل `scores`، فتأكد من تمرير `return_dict_in_generate=True, output_scores=True` إلى `generate`، وإلا فسيتم تمرير `None`.

kwargs (`dict[str, Any]`، *اختياري*) : معايير إيقاف إضافية محددة عبر معاملات kwargs.

**يعيد:** `torch.BoolTensor`. (`torch.BoolTensor` من الشكل `(batch_size, 1)`)

`True` يشير إلى أننا نتوقف عن التوليد لصف معين. `False` يشير إلى أنه يجب علينا المتابعة.

#### transformers.StoppingCriteriaList[[transformers.StoppingCriteriaList]]

```python
transformers.StoppingCriteriaList(iterable = ())
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L610)

#### __call__[[transformers.StoppingCriteriaList.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L611)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. يمكن الحصول على الفهارس باستخدام [AutoTokenizer](/docs/transformers/main/ar/model_doc/auto#transformers.AutoTokenizer). راجع [PreTrainedTokenizer.encode()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) و [PreTrainedTokenizer.__call__()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) للتفاصيل. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : درجات التنبؤ لرأس نمذجة اللغة، على شكل مجموعة (tuple) تحتوي على مصفوفة (tensor) واحدة لكل خطوة توليد، وكل منها على شكل `(batch_size, config.vocab_size)`. يمكن أن تكون هذه الدرجات لكل رمز في المفردات قبل SoftMax أو بعد SoftMax. إذا كان معيار التوقف يعتمد على مدخل `scores`، فتأكد من تمرير `return_dict_in_generate=True, output_scores=True` إلى `generate`، وإلا فسيتم تمرير `None`.

kwargs (`dict[str, Any]`، *اختياري*) : معايير إيقاف إضافية محددة عبر معاملات kwargs.

**يعيد:** `torch.BoolTensor`. (`torch.BoolTensor` من الشكل `(batch_size, 1)`)

`True` يشير إلى أننا نتوقف عن التوليد لصف معين. `False` يشير إلى أنه يجب علينا المتابعة.

#### transformers.MaxLengthCriteria[[transformers.MaxLengthCriteria]]

```python
transformers.MaxLengthCriteria(max_length: int, max_position_embeddings: int | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L60)

**المعاملات:**

max_length (`int`) : الحد الأقصى للطول الذي يمكن أن تصل إليه تسلسل المخرجات بعدد الرموز.

max_position_embeddings (`int`، *اختياري*) : الحد الأقصى لطول النموذج، كما هو محدد بواسطة خاصية `config.max_position_embeddings` الخاصة بالنموذج.

يمكن استخدام هذه الفئة لإيقاف التوليد في أي وقت يتجاوز فيه العدد الكلي للرموز المولَّدة `max_length`. تجدر الإشارة إلى أن نماذج التحويل من النوع المُفكِّك فقط (decoder-only) ستشمل الرموز الأولية المُدخَلة في الطلب.

#### __call__[[transformers.MaxLengthCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L76)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. يمكن الحصول على الفهارس باستخدام [AutoTokenizer](/docs/transformers/main/ar/model_doc/auto#transformers.AutoTokenizer). راجع [PreTrainedTokenizer.encode()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) و [PreTrainedTokenizer.__call__()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) للتفاصيل. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : درجات التنبؤ لرأس نمذجة اللغة، على شكل مجموعة (tuple) تحتوي على مصفوفة (tensor) واحدة لكل خطوة توليد، وكل منها على شكل `(batch_size, config.vocab_size)`. يمكن أن تكون هذه الدرجات لكل رمز في المفردات قبل SoftMax أو بعد SoftMax. إذا كان معيار التوقف يعتمد على مدخل `scores`، فتأكد من تمرير `return_dict_in_generate=True, output_scores=True` إلى `generate`، وإلا فسيتم تمرير `None`.

kwargs (`dict[str, Any]`، *اختياري*) : معايير إيقاف إضافية محددة عبر معاملات kwargs.

**يعيد:** `torch.BoolTensor`. (`torch.BoolTensor` من الشكل `(batch_size, 1)`)

`True` يشير إلى أننا نتوقف عن التوليد لصف معين. `False` يشير إلى أنه يجب علينا المتابعة.

#### transformers.MaxTimeCriteria[[transformers.MaxTimeCriteria]]

```python
transformers.MaxTimeCriteria(max_time: float, initial_timestamp: float | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L89)

**المعاملات:**

max_time (`float`) : الحد الأقصى المسموح به للزمن بالثواني للولادة.

initial_timestamp (`float`، *اختياري*، القيمة الافتراضية `time.time()`) : بداية الوقت المسموح به للتوليد.

يمكن استخدام هذه الفئة لإيقاف التوليد في أي وقت يتجاوز فيه التوليد الكامل مدة زمنية معينة. افتراضياً، يبدأ احتساب الوقت عند تهيئة هذه الدالة. يمكنك تجاوز ذلك عن طريق تمرير `initial_timestamp`.

#### __call__[[transformers.MaxTimeCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L106)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. يمكن الحصول على الفهارس باستخدام [AutoTokenizer](/docs/transformers/main/ar/model_doc/auto#transformers.AutoTokenizer). راجع [PreTrainedTokenizer.encode()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) و [PreTrainedTokenizer.__call__()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) للتفاصيل. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : درجات التنبؤ لرأس نمذجة اللغة، على شكل مجموعة (tuple) تحتوي على مصفوفة (tensor) واحدة لكل خطوة توليد، وكل منها على شكل `(batch_size, config.vocab_size)`. يمكن أن تكون هذه الدرجات لكل رمز في المفردات قبل SoftMax أو بعد SoftMax. إذا كان معيار التوقف يعتمد على مدخل `scores`، فتأكد من تمرير `return_dict_in_generate=True, output_scores=True` إلى `generate`، وإلا فسيتم تمرير `None`.

kwargs (`dict[str, Any]`، *اختياري*) : معايير إيقاف إضافية محددة عبر معاملات kwargs.

**يعيد:** `torch.BoolTensor`. (`torch.BoolTensor` من الشكل `(batch_size, 1)`)

`True` يشير إلى أننا نتوقف عن التوليد لصف معين. `False` يشير إلى أنه يجب علينا المتابعة.

#### transformers.StopStringCriteria[[transformers.StopStringCriteria]]

```python
transformers.StopStringCriteria(tokenizer: PreTrainedTokenizerBase, stop_strings: str | list[str])
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L112)

**المعاملات:**

tokenizer (`PreTrainedTokenizer`) : مُجزِّئ النصوص المرتبط بالنموذج (مطلوب لاستخراج قاموس الكلمات وتجزئة تسلسلات الإنهاء)

stop_strings (`Union[str, list[str]]`) : قائمة من السلاسل النصية التي يجب أن تُنهي التوليد. إذا تم تمرير سلسلة نصية واحدة، فسيتم التعامل معها كأنها قائمة تحتوي على عنصر واحد.

يمكن استخدام هذه الفئة لإيقاف التوليد كلما تم توليد تسلسلات نصية محددة. فهي تعالج النصوص مسبقًا مع قاموس المُجزّئ (tokenizer) للعثور على المواضع التي يمكن فيها للرموز (tokens) إكمال نصوص الإيقاف بشكل صالح.

تُوقف عملية التوليد فور توليد رمز يكمل أيًا من سلاسل التوقف. نرغب في التقاط أي حالة تكون فيها سلسلة التوقف موجودة في المخرجات المفكوكة، مما يعني أنه يجب علينا أيضًا التقاط الحالات التي تتضمن "امتدادات" من طرف واحد أو كلا الطرفين. لجعل هذا أكثر وضوحًا، فبالنسبة لسلسلة التوقف "stop"، فإن أيًا من تسلسلات الرموز التالية سيُطلق التطابق:

- ["st", "op"]
- ["stop"]
- ["st", "opera"]
- ["sto", "pper"]
- ["las", "topper"]
- ["s", "to", "pped"]

لاحظ أن التطابق لن يتم تفعيله إلا إذا كانت سلسلة التوقف في نهاية التسلسل المولّد. بعبارة أخرى، لن تُفعّل هذه التسلسلات التطابق:

- ["stop", "at"]
- ["st", "op", "at"]
- ["st", "opera", "tion"]

السبب في عدم تطابق هذه الحالات هو أن سلسلة التوقف لا تتداخل مع الرمز الأخير. إذا كان بإمكانك إزالة رمز واحد أو أكثر من نهاية التسلسل دون تدمير سلسلة التوقف، فلن يطابق هذا المعيار تلك السلسلة. هذا الأمر مقصود؛ نظرًا لأن هذا الفحص يُنفَّذ بعد توليد كل رمز، فلا يمكن أن نفوت سلسلة توقف صالحة إذا تم توليدها، لكننا لا نريد إيقاف التوليد لمجرد وجود سلسلة التوقف في مكان ما ضمن مدخلات input_ids السابقة.

كيف يتم تنفيذ المطابقة فعليًا؟ نقوم بذلك بطريقة مربكة إلى حد ما، لأننا نريد أن تكون عملية المطابقة بأكملها قابلة للتجميع باستخدام Torch أو XLA، مما يعني أننا لا نستطيع استخدام طرق السلاسل القياسية. ومع ذلك، من الممكن، مع بعض الجهد، تنفيذ مطابقة السلاسل باستخدام عمليات المصفوفات البحتة. سنبدأ بوصف الخوارزمية التي نستخدمها مع عمليات السلاسل القياسية، ثم في النهاية سنشرح كيف يتم تحويل ذلك إلى عمليات مصفوفات بحتة.

يكمن مفتاح الخوارزمية في ملاحظة: بما أن سلسلة التوقف يجب أن تتداخل مع نهاية تسلسل الرموز، يمكننا البدء من نهاية التسلسل والتحرك إلى الخلف. تحديداً، نتحقق من وجود تداخل بين بداية الرمز الأخير ونهاية stop_string، أو بصياغة أخرى، stop_string[-i:] == token[:i] لبعض i > 0. إذا نظرت إلى الأمثلة الإيجابية أعلاه، فسترى أن الرمز الأخير في جميعها يحقق هذه الخاصية:

- ["st", "op"] (التداخل هو "op"، وطول التداخل == 2)
- ["stop"]  (التداخل هو "stop"، وطول التداخل == 4)
- ["st", "opera"] (التداخل هو "op"، طول التداخل == 2)
- ["sto", "pper"] (التداخل هو "p"، طول التداخل == 1)
- ["las", "topper"] (التداخل هو "top"، وطول التداخل == 3)
- ["s", "to", "pped"] (التداخل هو "p"، طول التداخل == 1)

من المستحيل بناء تسلسل مطابق لا يتسم بهذه الخاصية (يمكنك التحقق من ذلك بنفسك). ومع ذلك، على الرغم من أن هذا التداخل بين بداية الرمز الأخير ونهاية سلسلة التوقف ضروري للمطابقة، إلا أنه غير كافٍ. نحتاج أيضاً إلى التحقق من أن بقية تسلسل الرموز متسقة مع سلسلة التوقف.

How do we do that? Let's use ["s", "to", "pped"] as an example. We know that the final token, "pped", has an overlap of 1 with the stop string, "stop". We then go back to the previous token, "to". Since we have already matched 1 character from the stop string, the remainder to check is "sto". We check that the next token "to" matches the end of the remainder, which it does. We have now matched 3 characters from the stop string, and the remainder to match is "s". We go back to the previous token again, which is also "s". This is a match, and so we have matched the entire stop string.

كيف يعمل الأمر عندما تتجاوز الرموز بداية سلسلة التوقف؟ لنأخذ مثال ["las", "topper"]. الرمز الأخير، "topper"، يتداخل مع سلسلة التوقف، "stop"، بمقدار 3. وبالتالي، فإن الجزء المتبقي من سلسلة التوقف للمطابقة هو "s". نعود إلى الرمز السابق، "las". بما أن الجزء المتبقي للمطابقة هو "s" فقط، بطول 1، فإننا نأخذ في الاعتبار حرفاً واحداً فقط من نهاية الرمز، وهو "s". يتطابق هذا مع سلسلة التوقف، وبالتالي يتم مطابقة السلسلة بأكملها.

كيف نحسب هذه التطابقات باستخدام عمليات المصفوفات؟ ببساطة: نحسب مسبقًا وبكفاءة المعلومات اللازمة لجميع الرموز! لكل رمز، نحسب:
- تداخلها مع نهاية سلسلة التوقف، إن وُجد
- المواضع داخل سلسلة التوقف التي يتطابق فيها الرمز، بما في ذلك التطابقات التي تمتد خارج البداية.
- الطول الكلي للرمز

على سبيل المثال، بالنسبة للرمز "pped"، نحسب تداخلاً نهائياً مقداره 1، ولا توجد مواضع مطابقة داخلية، وطول مقداره 4. وبالنسبة للرمز "to"، نحسب عدم وجود تداخل نهائي، وموضعاً داخلياً واحداً للمطابقة عند الموضع 1 (بالعدّ من النهاية)، وطول مقداره 2. وبالنسبة للرمز "s"، نحسب عدم وجود تداخل نهائي، وموضعاً داخلياً واحداً للمطابقة عند الموضع 3 (مرة أخرى بالعدّ من النهاية)، وطول مقداره 1.

ما دام لدينا هذه المعلومات، يمكننا تنفيذ الخوارزمية المذكورة أعلاه دون أي عمليات مقارنة سلاسل. ما علينا سوى تنفيذ الخطوات التالية:
- تحقق مما إذا كان الرمز الأخير يحتوي على تداخل نهائي مع السلسلة الافتتاحية
- تابع التراجع، مع الحفاظ على تتبع مقدار الجزء المطابق حتى الآن من سلسلة التوقف
- في كل نقطة، تحقق مما إذا كان الرمز التالي يحتوي على الموقع الحالي كأحد مواقعِه الصالحة
- استمر حتى يفشل التطابق، أو حتى يتم تطابق سلسلة التوقف بالكامل

Again, consider ["s", "to", "pped"] as an example. "pped" has an end overlap of 1, so we can begin a match. We have matched 1 character so far, so we check that the next token "to", has 1 as a valid position (again, counting from the end). It does, so we add the length of "to" to our position tracker. We have now matched 3 characters, so we check that the next token "s" has 3 as a valid position. It does, so we add its length to the position tracker. The position tracker is now 4, which is the length of the stop string. We have matched the entire stop string.

في الحالة الثانية، ["las", "topper"]، فإن "topper" لديها تداخل نهائي يبلغ 3، لذا يمكننا بدء المطابقة. لقد قمنا بمطابقة 3 أحرف حتى الآن، لذا نتحقق من أن الرمز التالي "las" لديه 3 كموضع صالح. وهذا صحيح، لأننا نسمح للأرموز بمطابقة المواضع التي تتجاوز بداية سلسلة التوقف. نضيف طول الرمز إلى متتبع الموضع. أصبح متتبع الموضع الآن 6، وهو أكبر من طول سلسلة التوقف! لا داعي للذعر، فهذا يُحسب أيضاً كمطابقة لسلسلة التوقف. لقد قمنا بمطابقة سلسلة التوقف بأكملها.

أمثلة:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-2")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/phi-2")
>>> inputs = tokenizer("The biggest states in the USA by land area:", return_tensors="pt")

>>> gen_out = model.generate(**inputs)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
The biggest states in the USA by land area:
- Alaska
- Texas
- California

>>> # Passing one or more stop strings will halt generation after those strings are emitted
>>> # Note that generating with stop strings requires you to pass the tokenizer too
>>> gen_out = model.generate(**inputs, stop_strings=["Texas"], tokenizer=tokenizer)
>>> print(tokenizer.batch_decode(gen_out, skip_special_tokens=True)[0])
The biggest states in the USA by land area:
- Alaska
- Texas
```

#### __call__[[transformers.StopStringCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L475)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. يمكن الحصول على الفهارس باستخدام [AutoTokenizer](/docs/transformers/main/ar/model_doc/auto#transformers.AutoTokenizer). راجع [PreTrainedTokenizer.encode()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) و [PreTrainedTokenizer.__call__()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) للتفاصيل. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : درجات التنبؤ لرأس نمذجة اللغة، على شكل مجموعة (tuple) تحتوي على مصفوفة (tensor) واحدة لكل خطوة توليد، وكل منها على شكل `(batch_size, config.vocab_size)`. يمكن أن تكون هذه الدرجات لكل رمز في المفردات قبل SoftMax أو بعد SoftMax. إذا كان معيار التوقف يعتمد على مدخل `scores`، فتأكد من تمرير `return_dict_in_generate=True, output_scores=True` إلى `generate`، وإلا فسيتم تمرير `None`.

kwargs (`dict[str, Any]`، *اختياري*) : معايير إيقاف إضافية محددة عبر معاملات kwargs.

**يعيد:** `torch.BoolTensor`. (`torch.BoolTensor` من الشكل `(batch_size, 1)`)

`True` يشير إلى أننا نتوقف عن التوليد لصف معين. `False` يشير إلى أنه يجب علينا المتابعة.

#### transformers.EosTokenCriteria[[transformers.EosTokenCriteria]]

```python
transformers.EosTokenCriteria(eos_token_id: typing.Union[int, list[int], torch.Tensor])
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L537)

**المعاملات:**

eos_token_id (`Union[int, list[int], torch.Tensor]`) : المعرّف أو المعرّفات لرمز *نهاية التسلسل*.

يمكن استخدام هذه الفئة لإيقاف التوليد في أي وقت يتم فيه إنشاء رمز "نهاية التسلسل". افتراضيًا، تستخدم `model.generation_config.eos_token_id`.

#### __call__[[transformers.EosTokenCriteria.__call__]]

```python
__call__(input_ids: LongTensor, scores: tuple[torch.Tensor] | None, new_token_length: int = 1, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/stopping_criteria.py#L554)

**المعاملات:**

input_ids (`torch.LongTensor` من الشكل `(batch_size, sequence_length)`) : فهارس رموز تسلسل الإدخال في قاموس الكلمات. يمكن الحصول على الفهارس باستخدام [AutoTokenizer](/docs/transformers/main/ar/model_doc/auto#transformers.AutoTokenizer). راجع [PreTrainedTokenizer.encode()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) و [PreTrainedTokenizer.__call__()](/docs/transformers/main/ar/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) للتفاصيل. [ما هي معرّفات الإدخال؟](../glossary#input-ids)

scores (`tuple(torch.Tensor)`) : درجات التنبؤ لرأس نمذجة اللغة، على شكل مجموعة (tuple) تحتوي على مصفوفة (tensor) واحدة لكل خطوة توليد، وكل منها على شكل `(batch_size, config.vocab_size)`. يمكن أن تكون هذه الدرجات لكل رمز في المفردات قبل SoftMax أو بعد SoftMax. إذا كان معيار التوقف يعتمد على مدخل `scores`، فتأكد من تمرير `return_dict_in_generate=True, output_scores=True` إلى `generate`، وإلا فسيتم تمرير `None`.

new_token_length (`int`، *اختياري*، القيمة الافتراضية `1`) : عدد الرموز التي سيتم فحصها مقابل المعايير. سيتم فحص أحدث `new_token_length` رموز في كل عنصر من عناصر الدفعة.

kwargs (`dict[str, Any]`، *اختياري*) : معايير إيقاف إضافية محددة عبر معاملات kwargs.

**يعيد:** `torch.BoolTensor`. (`torch.BoolTensor` من الشكل `(batch_size, 1)`)

`True` يشير إلى أننا نتوقف عن التوليد لصف معين. `False` يشير إلى أنه يجب علينا المتابعة.

## بثّات[[transformers.TextStreamer]]

#### transformers.TextStreamer[[transformers.TextStreamer]]

```python
transformers.TextStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, **decode_kwargs: Any)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L41)

**المعاملات:**

tokenizer (`AutoTokenizer`) : المُجزِّئ المستخدم لفك ترميز الرموز.

skip_prompt (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان سيتم تخطي الأمر الموجّه إلى `.generate()` أم لا. مفيد على سبيل المثال في روبوتات المحادثة.

decode_kwargs (`dict`، *اختياري*) : حُجج إضافية بمفاتيح مراد تمريرها إلى طريقة `decode` في المُجزّئ.

بث نصي بسيط يطبع الرموز إلى الإخراج القياسي فور اكتمال الكلمات.

أمثلة:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer

>>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt")
>>> streamer = TextStreamer(tok)

>>> # Despite returning the usual output, the streamer will also print the generated text to stdout.
>>> _ = model.generate(**inputs, streamer=streamer, max_new_tokens=20)
An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,
```

#### نهاية[[transformers.TextStreamer.end]]

```python
end()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L113)

يفرّغ أي ذاكرة مؤقتة متبقية ويكتب سطرًا جديدًا إلى الإخراج القياسي.

#### on_finalized_text[[transformers.TextStreamer.on_finalized_text]]

```python
on_finalized_text(text: str, stream_end: bool = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L127)

يطبع النص الجديد إلى stdout. إذا كان التدفق في نهايته، يطبع أيضًا سطرًا جديدًا.

#### put[[transformers.TextStreamer.put]]

```python
put(value)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L79)

يستقبل الرموز، ويفكك تشفيرها، ثم يطبعها في الإخراج القياسي فور تشكيلها كلمات كاملة.

#### transformers.TextIteratorStreamer[[transformers.TextIteratorStreamer]]

```python
transformers.TextIteratorStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, timeout: float | None = None, **decode_kwargs: Any)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L156)

**المعاملات:**

tokenizer (`AutoTokenizer`) : المُجزِّئ المستخدم لفك ترميز الرموز.

skip_prompt (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان سيتم تخطي الأمر الموجّه إلى `.generate()` أم لا. مفيد على سبيل المثال في روبوتات المحادثة.

timeout (`float`، *اختياري*) : مهلة انتهاء الوقت لطابور النص. إذا كانت `None`، فسيبقى الطابور محجوزًا بشكل غير محدود. مفيد للتعامل مع الاستثناءات في `.generate()`، عند استدعائه في خيط منفصل.

decode_kwargs (`dict`، *اختياري*) : حُجج إضافية بمفاتيح مراد تمريرها إلى طريقة `decode` في المُجزّئ.

بثّ (Streamer) يخزّن النص الجاهز للطباعة في طابور (queue)، ليُستخدم من قبل تطبيق تالٍ كمُكرِّر (iterator). وهذا مفيد للتطبيقات التي تستفيد من الوصول إلى النص المولَّد بطريقة غير حاصِرة (non-blocking) (مثل عرض Gradio التفاعلي).

أمثلة:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
>>> from threading import Thread

>>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt")
>>> streamer = TextIteratorStreamer(tok)

>>> # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way.
>>> generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=20)
>>> thread = Thread(target=model.generate, kwargs=generation_kwargs)
>>> thread.start()
>>> generated_text = ""
>>> for new_text in streamer:
...     generated_text += new_text
>>> generated_text
'An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,'
```

#### on_finalized_text[[transformers.TextIteratorStreamer.on_finalized_text]]

```python
on_finalized_text(text: str, stream_end: bool = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L208)

ضع النص الجديد في الطابور. إذا كان البث على وشك الانتهاء، فضع إشارة التوقف في الطابور أيضًا.

#### transformers.AsyncTextIteratorStreamer[[transformers.AsyncTextIteratorStreamer]]

```python
transformers.AsyncTextIteratorStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, timeout: float | None = None, **decode_kwargs: Any)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L225)

**المعاملات:**

tokenizer (`AutoTokenizer`) : المُجزِّئ المستخدم لفك ترميز الرموز.

skip_prompt (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان سيتم تخطي الأمر الموجّه إلى `.generate()` أم لا. مفيد على سبيل المثال في روبوتات المحادثة.

timeout (`float`، *اختياري*) : مهلة انتهاء الوقت لطابور النص. إذا كانت `None`، فسيبقى الطابور محجوزًا بشكل غير محدود. مفيد للتعامل مع الاستثناءات في `.generate()`، عند استدعائه في خيط منفصل.

decode_kwargs (`dict`، *اختياري*) : حُجج إضافية بمفاتيح مراد تمريرها إلى طريقة `decode` في المُجزّئ.

**يُطلق:** ``TimeoutError``

- ``TimeoutError`` -- إذا تجاوز وقت توليد الرموز القيمة المحددة لحدّ المهلة.

بثّ (Streamer) يخزّن النصّ الجاهز للطباعة في طابور (queue)، ليُستخدم من قِبل تطبيقٍ تالٍ كمُكرِّر غير متزامن (async iterator). وهذا مفيد للتطبيقات التي تستفيد من الوصول إلى النصّ المولَّد بشكل غير متزامن (مثل عرض تفاعلي في Gradio).

أمثلة:

```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, AsyncTextIteratorStreamer
>>> from threading import Thread
>>> import asyncio

>>> tok = AutoTokenizer.from_pretrained("openai-community/gpt2")
>>> model = AutoModelForCausalLM.from_pretrained("openai-community/gpt2")
>>> inputs = tok(["An increasing sequence: one,"], return_tensors="pt")

>>> # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way.
>>> async def main():
...     # Important: AsyncTextIteratorStreamer must be initialized inside a coroutine!
...     streamer = AsyncTextIteratorStreamer(tok)
...     generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=20)
...     thread = Thread(target=model.generate, kwargs=generation_kwargs)
...     thread.start()
...     generated_text = ""
...     async for new_text in streamer:
...         generated_text += new_text
>>>     print(generated_text)
>>> asyncio.run(main())
An increasing sequence: one, two, three, four, five, six, seven, eight, nine, ten, eleven,
```

#### on_finalized_text[[transformers.AsyncTextIteratorStreamer.on_finalized_text]]

```python
on_finalized_text(text: str, stream_end: bool = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L285)

ضع النص الجديد في الطابور. إذا كان البث على وشك الانتهاء، فضع إشارة التوقف في الطابور أيضًا.

#### transformers.TextDiffusionStreamer[[transformers.TextDiffusionStreamer]]

```python
transformers.TextDiffusionStreamer(tokenizer: PreTrainedTokenizerBase, skip_prompt: bool = False, sleep_time: float | None = None, **decode_kwargs: Any)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L303)

**المعاملات:**

tokenizer (`AutoTokenizer`) : المُرمِّز المستخدم لفك ترميز الرموز.

skip_prompt (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان سيتم تخطي الأمر الموجّه إلى `.generate()` أم لا. مفيد على سبيل المثال في روبوتات المحادثة.

sleep_time (`float`، *اختياري*) : مدة النوم بين مسودات الانتشار، وقد يكون ذلك مفيدًا لتصور المخرجات الوسيطة.

decode_kwargs (`dict`، *اختياري*) : حُجج إضافية بمفاتيح مراد تمريرها إلى طريقة `decode` في المُجزّئ.

بثّات تُطبع مخرجات انتشار النص. خطوات الانتشار الوسيطة (المسودات) مؤقتة وتُستبدل بالمسودات اللاحقة، وتُحذف عند طباعة النص المؤكَّد.

إذا كنت تعمل في بيئة مثل tmux، فقد يفشل النص المسودة في تجاوز نفسه.

أمثلة:

```python
>>> from transformers import DiffusionGemmaForBlockDiffusion, AutoProcessor, TextDiffusionStreamer

>>> model = DiffusionGemmaForBlockDiffusion.from_pretrained(
...     "google/diffusiongemma-26B-A4B-it", device_map="auto",
... )
>>> processor = AutoProcessor.from_pretrained("google/diffusiongemma-26B-A4B-it")

>>> chat = [{"role": "user", "content": "Why is the sky blue?"},]
>>> input_ids = processor.apply_chat_template(
...     chat, tokenize=True, return_tensors="pt", add_generation_prompt=True
... )
>>> streamer = TextDiffusionStreamer(tokenizer=processor.tokenizer)
>>> model.generate(input_ids.to(model.device), max_new_tokens=512, streamer=streamer)
```

#### نهاية[[transformers.TextDiffusionStreamer.end]]

```python
end()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L392)

يفرّغ أي ذاكرة مؤقتة متبقية ويخرج سطرًا جديدًا.

#### put[[transformers.TextDiffusionStreamer.put]]

```python
put(value)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L387)

يستقبل الرموز المؤكدة، ويمسح المسودة، ثم يطبعها بشكل دائم.

#### put_draft[[transformers.TextDiffusionStreamer.put_draft]]

```python
put_draft(value, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/streamers.py#L365)

يستقبل تسلسل الرموز المسودة الكامل، ويفكّك ترميزها، ثم يطبعها باللون الأصفر. يستبدل المسودة السابقة.

## الذاكرة المؤقتة[[transformers.CacheLayerMixin]]

#### transformers.CacheLayerMixin[[transformers.CacheLayerMixin]]

```python
transformers.CacheLayerMixin(**kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L23)

فئة أساسية مجردة لذاكرة مؤقتة لطبقة واحدة.

#### تحديث[[transformers.CacheLayerMixin.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L52)

#### get_seq_length[[transformers.CacheLayerMixin.get_seq_length]]

```python
get_seq_length()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L60)

#### get_mask_sizes[[transformers.CacheLayerMixin.get_mask_sizes]]

```python
get_mask_sizes(query_length: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L57)

#### get_max_length[[transformers.CacheLayerMixin.get_max_length]]

```python
get_max_length()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L63)

تُعيد الطول الأقصى للتسلسل الذي يمكن للطبقة احتواؤه. القيمة `-1` تعني عدم وجود حد أقصى، أو أن الحد الأقصى غير معرّف، على سبيل المثال طبقة انتباه ديناميكية تنمو بلا حدود، أو طبقة انتباه خطي لا تحتوي على بُعد لطول التسلسل.

#### إعادة تعيين[[transformers.CacheLayerMixin.reset]]

```python
reset()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L84)

يعيد تعيين قيم ذاكرة التخزين المؤقت مع الحفاظ على الكائنات

#### reorder_cache[[transformers.CacheLayerMixin.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L97)

يعيد ترتيب ذاكرة التخزين المؤقت لهذه الطبقة للبحث بالحزمة.

#### lazy_initialization[[transformers.CacheLayerMixin.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L49)

#### transformers.DynamicLayer[[transformers.DynamicLayer]]

```python
transformers.DynamicLayer(**kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L104)

طبقة تخزين مؤقت تنمو ديناميكيًا كلما تم توليد المزيد من الرموز. هذا هو الافتراضي للنماذج التوليدية. تخزن حالات المفتاح والقيمة كمُتجهات (تِنسورز) بأبعاد `[batch_size, num_heads, seq_len, head_dim]`.

#### تحديث[[transformers.DynamicLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L119)

**المعاملات:**

key_states (`torch.Tensor`) : حالات المفاتيح الجديدة التي يجب تخزينها مؤقتًا.

value_states (`torch.Tensor`) : القيم الجديدة التي يجب تخزينها مؤقتًا.

**يعيد:** tuple[`torch.Tensor`, `torch.Tensor`]

حالات المفتاح والقيمة.

حدّث كاشات المفتاح والقيمة في مكانها، وأعدّ حالات المفاتيح والقيم اللازمة.

#### lazy_initialization[[transformers.DynamicLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113)

#### قص[[transformers.DynamicLayer.crop]]

```python
crop(tokens_to_remove: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L164)

أزل رموز `tokens_to_remove` من طبقة التخزين المؤقت الحالية.

#### batch_repeat_interleave[[transformers.DynamicLayer.batch_repeat_interleave]]

```python
batch_repeat_interleave(repeats: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L183)

كرر الكاش `repeats` مرات في بُعد الدفعة.

#### batch_select_indices[[transformers.DynamicLayer.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L189)

احتفظ فقط بـ`indices` في بُعد الدفعة (batch dimension) للكاش.

#### transformers.StaticLayer[[transformers.StaticLayer]]

```python
transformers.StaticLayer(max_cache_len: int, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L403)

**المعاملات:**

max_cache_len (`int`) : الحد الأقصى لعدد الرموز التي يمكن تخزينها، ويُستخدم لتهيئة المسبق للمصفوفات.

طبقة تخزين مؤقت ثابتة تحفظ حالات المفاتيح والقيم كمُتجهات ثابتة من الشكل `[batch_size, num_heads, max_cache_len, head_dim]`. تقوم بتخصيص مُتجهات الدعم الكاملة الخاصة بها بشكل كسول، ثم تعدّلها في مكانها. صُممت لدعم `torch.compile`.

#### تحديث[[transformers.StaticLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L461)

**المعاملات:**

key_states (`torch.Tensor`) : حالات المفاتيح الجديدة التي يجب تخزينها مؤقتًا.

value_states (`torch.Tensor`) : القيم الجديدة التي يجب تخزينها مؤقتًا.

**يعيد:** tuple[`torch.Tensor`, `torch.Tensor`]

حالات المفتاح والقيمة.

حدّث كاشات المفتاح والقيمة في مكانها، وأعدّ حالات المفاتيح والقيم اللازمة.

#### lazy_initialization[[transformers.StaticLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L423)

تهيئة كسولة لمصفوفات المفاتيح والقيم. يتيح ذلك الحصول على جميع الخصائص (dtype، device، num_heads في حالة TP، إلخ...) وقت التشغيل مباشرةً، وهو أمر عملي للغاية لأنه يتجنب نقل الأجهزة وأنواع البيانات (dtypes) وغيرها لاحقًا لكل عملية `update` (والتي قد تُكسر عناوين dynamo الثابتة أيضًا).

إذا لم يكن هذا مرغوبًا فيه، يمكن استدعاء `early_initialization(...)` مباشرةً على كائن Cache، مما يؤدي إلى استدعاء هذه الدالة مسبقًا (وهو أمر مطلوب على سبيل المثال لـ `torch.export`). كما يُشترط ذلك في كل مرة ينتهي فيها prefill نفسه داخل منطقة مُجمّعة (compiled region) (مثلًا عند استخدام prefill المقسّم).

#### transformers.StaticSlidingWindowLayer[[transformers.StaticSlidingWindowLayer]]

```python
transformers.StaticSlidingWindowLayer(max_cache_len: int, sliding_window: int, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L510)

**المعاملات:**

max_cache_len (`int`) : الحد الأقصى لعدد الرموز التي يمكن تخزينها، ويُستخدم لتهيئة المسبق للمصفوفات.

sliding_window (`int`) : حجم النافذة المنزلقة.

طبقة تخزين مؤقت ثابتة تحفظ حالات المفتاح والقيمة كمُتجهات ثابتة من الشكل `[batch_size, num_heads, min(max_cache_len, sliding_window), head_dim]`. تقوم بتخصيص مُتجهات الدعم الكاملة الخاصة بها بشكل كسول، ثم تعدّلها في مكانها. صُممت لدعم `torch.compile`.

#### تحديث[[transformers.StaticSlidingWindowLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L531)

**المعاملات:**

key_states (`torch.Tensor`) : حالات المفاتيح الجديدة التي يجب تخزينها مؤقتًا.

value_states (`torch.Tensor`) : القيم الجديدة التي يجب تخزينها مؤقتًا.

**يعيد:** tuple[`torch.Tensor`, `torch.Tensor`]

حالات المفتاح والقيمة.

حدّث كاشات المفتاح والقيمة في مكانها، وأعدّ حالات المفاتيح والقيم اللازمة.

#### lazy_initialization[[transformers.StaticSlidingWindowLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L423)

تهيئة كسولة لمصفوفات المفاتيح والقيم. يتيح ذلك الحصول على جميع الخصائص (dtype، device، num_heads في حالة TP، إلخ...) وقت التشغيل مباشرةً، وهو أمر عملي للغاية لأنه يتجنب نقل الأجهزة وأنواع البيانات (dtypes) وغيرها لاحقًا لكل عملية `update` (والتي قد تُكسر عناوين dynamo الثابتة أيضًا).

إذا لم يكن هذا مرغوبًا فيه، يمكن استدعاء `early_initialization(...)` مباشرةً على كائن Cache، مما يؤدي إلى استدعاء هذه الدالة مسبقًا (وهو أمر مطلوب على سبيل المثال لـ `torch.export`). كما يُشترط ذلك في كل مرة ينتهي فيها prefill نفسه داخل منطقة مُجمّعة (compiled region) (مثلًا عند استخدام prefill المقسّم).

#### transformers.QuantoQuantizedLayer[[transformers.QuantoQuantizedLayer]]

```python
transformers.QuantoQuantizedLayer(nbits: int = 4, axis_key: int = 0, axis_value: int = 0, q_group_size: int = 64, residual_length: int = 128)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L854)

#### تحديث[[transformers.QuantoQuantizedLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L781)

**المعاملات:**

key_states (`torch.Tensor`) : حالات المفاتيح الجديدة التي يجب تخزينها مؤقتًا.

value_states (`torch.Tensor`) : القيم الجديدة التي يجب تخزينها مؤقتًا.

**يعيد:** tuple[`torch.Tensor`, `torch.Tensor`]

حالات المفتاح والقيمة.

حدّث كاشات المفتاح والقيمة في مكانها، وأعدّ حالات المفاتيح والقيم اللازمة.

#### lazy_initialization[[transformers.QuantoQuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113)

#### transformers.HQQQuantizedLayer[[transformers.HQQQuantizedLayer]]

```python
transformers.HQQQuantizedLayer(nbits: int = 4, axis_key: int = 0, axis_value: int = 0, q_group_size: int = 64, residual_length: int = 128)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L909)

#### تحديث[[transformers.HQQQuantizedLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L781)

**المعاملات:**

key_states (`torch.Tensor`) : حالات المفاتيح الجديدة التي يجب تخزينها مؤقتًا.

value_states (`torch.Tensor`) : القيم الجديدة التي يجب تخزينها مؤقتًا.

**يعيد:** tuple[`torch.Tensor`, `torch.Tensor`]

حالات المفتاح والقيمة.

حدّث كاشات المفتاح والقيمة في مكانها، وأعدّ حالات المفاتيح والقيم اللازمة.

#### lazy_initialization[[transformers.HQQQuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L113)

#### transformers.Fp8QuantizedLayer[[transformers.Fp8QuantizedLayer]]

```python
transformers.Fp8QuantizedLayer()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L966)

طبقة مُكمّمة تخزّن حالات المفتاح والقيمة بنقطة عائمة 8-بت. يتم تجميد معامل التدرّج لكل متجه بعد أول `update`، لذا تُضاف الحالات الجديدة كما هي: بدون ذاكرة مؤقتة متبقية، وبدون إعادة تكميم.

تنتمي نسخة أكثر دقة هنا بدلاً من وضعها تحت `QuantizedLayer`، إذ إن التجميع على بُعد الرأس يحافظ على قابلية إضافة الحالات ويحوّل المقياس المخزَّن إلى متجه فقط.

#### تحديث[[transformers.Fp8QuantizedLayer.update]]

```python
update(key_states: Tensor, value_states: Tensor, *args, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L994)

**المعاملات:**

key_states (`torch.Tensor`) : حالات المفاتيح الجديدة التي يجب تخزينها مؤقتًا.

value_states (`torch.Tensor`) : القيم الجديدة التي يجب تخزينها مؤقتًا.

**يعيد:** tuple[`torch.Tensor`, `torch.Tensor`]

حالات المفتاح والقيمة.

حدّث كاشات المفتاح والقيمة في مكانها، وأعدّ حالات المفاتيح والقيم اللازمة.

#### lazy_initialization[[transformers.Fp8QuantizedLayer.lazy_initialization]]

```python
lazy_initialization(key_states: Tensor, value_states: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L978)

#### transformers.Cache[[transformers.Cache]]

```python
transformers.Cache(layers: list[transformers.cache_utils.CacheLayerMixin | transformers.cache_utils.LinearAttentionCacheLayerMixin | transformers.cache_utils.DummyLayer] | None = None, layer_class_to_replicate: type[transformers.cache_utils.CacheLayerMixin | transformers.cache_utils.LinearAttentionCacheLayerMixin] | None = None, offloading: bool = False, offload_only_non_sliding: bool = True)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1453)

**المعاملات:**

layers (`Optional`، *اختياري*) : قائمة بطبقات `CacheLayerMixin` أو `LinearAttentionCacheLayerMixin` مُنشأة مسبقًا. إذا تم تجاهله (`None`)، فسيتم استخدام `layer_class_to_replicate`.

layer_class_to_replicate (`type[CacheLayerMixin | LinearAttentionCacheLayerMixin]`، *اختياري*) : يُستخدم فقط إذا تم إغفال `layers` (`None`)، وفي هذه الحالة سيُستخدم كالفئة الأساسية لكل طبقة، وستُضاف الطبقات بشكل كسول بمجرد استدعاء `update` مع `layer_idx` أكبر من قائمة الطبقات الحالية.

offloading (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان سيتم تنفيذ نقل الطبقات إلى `cpu`، لتوفير ذاكرة وحدة معالجة الرسوميات.

offload_only_non_sliding (`bool`، *اختياري*، القيمة الافتراضية `True`) : إذا كانت `offloading` هي `True`، فإن هذا الخيار يحدد ما إذا كان سيتم تفريغ الطبقات غير المنزلقة فقط (لأن الطبقات المنزلقة عادةً ما تكون صغيرة الحجم، فلا حاجة إلى تفريغها، وتخطيها أسرع).

يُعدّ `Cache` في الغالب قائمة من كائنات `CacheLayerMixin`، كائن واحد لكل طبقة في النموذج. وهو يعمل كحاوية لـ Cache لكل طبقة.

#### تحديث[[transformers.Cache.update]]

```python
update(key_states: Tensor, value_states: Tensor, layer_idx: int, *args, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1540)

**المعاملات:**

key_states (`torch.Tensor`) : حالات المفاتيح الجديدة التي يجب تخزينها مؤقتًا.

value_states (`torch.Tensor`) : القيم الجديدة التي يجب تخزينها مؤقتًا.

layer_idx (`int`) : فهرس الطبقة التي سيتم تخزين حالاتها.

**يعيد:**

مجموعة (tuple) تحتوي على حالات المفتاح والقيمة المحدّثة.

يحدّث ذاكرة التخزين المؤقت بحالات المفاتيح الجديدة `key_states` وحالات القيم `value_states` للطبقة `layer_idx`.

#### early_initialization[[transformers.Cache.early_initialization]]

```python
early_initialization(batch_size: int, num_heads: int | list[int], head_dim: int | list[int], dtype: dtype, device: device)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1669)

قم بتبني جميع الطبقات مسبقاً (وإلا فسيتم تبنّيها بشكل كسول عند أول استدعاء لـ`update`). هذا مفيد لوصفات `export` لدينا، لأن `export` يحتاج إلى كل شيء مسبقاً.

#### get_seq_length[[transformers.Cache.get_seq_length]]

```python
get_seq_length(layer_idx: int = 0)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1706)

يعيد طول التسلسل للكاش الخاص بالطبقة المحددة.

#### get_mask_sizes[[transformers.Cache.get_mask_sizes]]

```python
get_mask_sizes(query_length: int, layer_idx: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1776)

تُعيد هذه الدالة مجموعة (tuple) من القيم (kv_length, kv_offset) التي تتوافق مع الطول والإزاحة اللذين سيُعادان للطبقة المحددة عند `layer_idx`. ثم تُجهَّز الأقنعة (masks) وفقاً للأطوال (kv_length, kv_offset) والأنماط (patterns) لكل طبقة.

#### get_max_length[[transformers.Cache.get_max_length]]

```python
get_max_length(layer_idx: int | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1730)

يعيد الطول الأقصى للذاكرة المؤقتة. إذا لم يُقدَّم `layer_idx` (الافتراضي)، فإن هذا يعيد القيمة القصوى عبر جميع الطبقات. وإلا، يعيد القيمة القصوى المدعومة للطبقة المحددة. القيمة `-1` تعني عدم وجود حد أقصى، أو أن الحد الأقصى غير معرّف، على سبيل المثال لطبقات الانتباه الديناميكي التي يمكن أن تنمو بلا حدود، أو لطبقات الانتباه الخطي التي لا تملك بُعدًا لطول التسلسل.

#### إعادة تعيين[[transformers.Cache.reset]]

```python
reset()
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1813)

إعادة تعيين جميع متجهات الطبقات بشكل تكراري

#### reorder_cache[[transformers.Cache.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1818)

إعادة ترتيب ذاكرة التخزين المؤقت للبحث بالحزمة

#### قص[[transformers.Cache.crop]]

```python
crop(tokens_to_remove: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1823)

أزل رموز `tokens_to_remove` من الذاكرة المؤقتة (Cache) الحالية. بالنسبة للطبقات التي لا تحتاج إلى الاحتفاظ بجميع الحالات السابقة في الذاكرة، مثل طبقات النافذة المنزلقة أو طبقات الانتباه الخطي، فإن هذا الإجراء سيُقيّد حجم الحالات المخزنة مؤقتاً أيضاً إلى حجمها التشغيلي الأدنى. وهذا يعني أن `crop(0)` لن يكون بالضرورة عملية لا تؤثر في كل الأحوال، إذ قد يزال حالات غير مفيدة (أي الحالات غير المطلوبة للتالي `forward`) من الذاكرة المؤقتة.

#### batch_repeat_interleave[[transformers.Cache.batch_repeat_interleave]]

```python
batch_repeat_interleave(repeats: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1833)

كرر ذاكرة التخزين المؤقت وابدلها

#### batch_select_indices[[transformers.Cache.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1838)

اختيار الفهارس من ذاكرة التخزين المؤقت

#### transformers.DynamicCache[[transformers.DynamicCache]]

```python
transformers.DynamicCache(ddp_cache_data: collections.abc.Iterable[tuple[typing.Optional[torch.Tensor], ...]] | None = None, config: transformers.configuration_utils.PreTrainedConfig | None = None, offloading: bool = False, offload_only_non_sliding: bool = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L1960)

**المعاملات:**

ddp_cache_data (`Iterable[tuple[torch.Tensor, torch.Tensor]]`، *اختياري*) : أُضيف في الأصل لضمان التوافق مع `torch.distributed` (DDP). باختصار، هو `map(gather_map, zip(*caches))`، أي أن كل عنصر في القابل للتكرار يحتوي على حالات المفتاح والقيمة لطبقة واحدة تم تجميعها عبر النسخ بواسطة torch.distributed (الشكل=[حجم الدفعة العالمية، عدد الرؤوس، طول التسلسل، بُعد الرأس]). ملاحظة: يجب أن يكون الحجة الأولى أيضًا حتى يعمل بشكل صحيح

config (`PreTrainedConfig`، *اختياري*) : إعدادات النموذج الذي سيُستخدم هذا الكاش (Cache) له. إذا تم تمريرها، فستُستخدم للتحقق من بنية الطبقات المنزلقة أو الهجينة، مما يقلل بشكل كبير من متطلبات الذاكرة للموترات المخزنة مؤقتًا إلى `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`.

offloading (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان سيتم تنفيذ نقل الطبقات إلى `cpu`، لتوفير ذاكرة وحدة معالجة الرسوميات.

offload_only_non_sliding (`bool`، *اختياري*، القيمة الافتراضية `False`) : إذا كانت `offloading` هي `True`، فإن هذا يحدد ما إذا كان سيتم تفريغ الطبقات غير المنزلقة فقط (لأن الطبقات المنزلقة عادةً ما تكون صغيرة الحجم، فلا حاجة إلى تفريغها، وتخطيها أسرع).

ذاكرة مؤقتة تنمو ديناميكيًا كلما تم توليد المزيد من الرموز. هذا هو الافتراضي للنماذج التوليدية. تخزّن حالات المفتاح والقيمة كقائمة من `CacheLayer`، واحدة لكل طبقة. الشكل المتوقع لكل متجه في `CacheLayer`s هو `[batch_size, num_heads, seq_len, head_dim]`. إذا تم تمرير إعداد، فسيُجري فحصًا إضافيًا لبنية ذاكرة المؤقت المنزلقة أو الهجينة، مما يقلل بشكل كبير من متطلبات الذاكرة للمتجهات المخزنة المؤقتًا إلى `[batch_size, num_heads, min(seq_len, sliding_window), head_dim]`.

راجع `Cache` للاطلاع على التفاصيل المتعلقة بالطرق الشائعة التي تنفذها جميع فئات الكاش.

مثال:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, DynamicCache

>>> model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
>>> tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")

>>> inputs = tokenizer(text="My name is Qwen2", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> past_key_values = DynamicCache(config=model.config)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
```

#### transformers.StaticCache[[transformers.StaticCache]]

```python
transformers.StaticCache(config: PreTrainedConfig, max_cache_len: int, offloading: bool = False, offload_only_non_sliding: bool = True, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2056)

**المعاملات:**

config (`PreTrainedConfig`) : إعدادات النموذج الذي سيُستخدم هذا الكاش لخدمته. ستُستخدم للتحقق من بنية الطبقات المنزلقة أو الهجينة، وتهيئة كل طبقة وفقًا لذلك.

max_cache_len (`int`) : الحد الأقصى لعدد الرموز التي يجب أن يحتفظ بها هذا الكاش.

offloading (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان سيتم تنفيذ نقل الطبقات إلى `cpu`، لتوفير ذاكرة وحدة معالجة الرسوميات.

offload_only_non_sliding (`bool`، *اختياري*، القيمة الافتراضية `True`) : إذا كانت `offloading` هي `True`، فإن هذا الخيار يحدد ما إذا كان سيتم تفريغ الطبقات غير المنزلقة فقط (لأن الطبقات المنزلقة عادةً ما تكون صغيرة الحجم، فلا حاجة إلى تفريغها، وتخطيها أسرع).

فئة Static Cache للاستخدام مع `torch.compile(model)` و`torch.export()`. ستفحص `config` بحثًا عن هيكل ذاكرة مؤقتة هجينة محتمل، وتُهيّئ كل طبقة وفقًا لذلك.

راجع `Cache` للاطلاع على التفاصيل المتعلقة بالطرق الشائعة التي تنفذها جميع فئات الكاش.

مثال:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, StaticCache

>>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-chat-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-chat-hf")

>>> inputs = tokenizer(text="My name is Llama", return_tensors="pt")

>>> # Prepare a cache class and pass it to model's forward
>>> # Leave empty space for 10 new tokens, which can be used when calling forward iteratively 10 times to generate
>>> max_generated_length = inputs.input_ids.shape[1] + 10
>>> past_key_values = StaticCache(config=model.config, max_cache_len=max_generated_length)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
StaticCache()
```

#### transformers.QuantizedCache[[transformers.QuantizedCache]]

```python
transformers.QuantizedCache(backend: str, config: PreTrainedConfig, nbits: int | None = None, axis_key: int | None = None, axis_value: int | None = None, q_group_size: int | None = None, residual_length: int | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2113)

**المعاملات:**

backend (`str`) : واجهة الكمية (quantization backend) المستخدمة. أحد القيم التالية: `("quanto", "hqq", "fp8")`.

config (`PreTrainedConfig`) : إعدادات النموذج الذي سيُستخدم هذا الكاش (Cache) له.

nbits (`int`، *اختياري*، القيمة الافتراضية 4) : عدد البتات المستخدمة في التكميم.

axis_key (`int`، *اختياري*، القيمة الافتراضية 0) : المحور الذي سيتم عليه تكميم المفاتيح.

axis_value (`int`، *اختياري*، القيمة الافتراضية 0) : المحور الذي سيتم عليه تكميم القيم.

q_group_size (`int`، *اختياري*، القيمة الافتراضية 64) : يتم تنفيذ التكميم لكل قناة وفقاً لمجموعة `q_group_size` لكل من المفاتيح والقيم.

residual_length (`int`، *اختياري*، القيمة الافتراضية 128) : الحد الأقصى لسعة ذاكرة التخزين المؤقت للدقة الأصلية.

ذاكرة مؤقتة للمُكمِّم (Quantizer) مماثلة لما هو موصوف في ورقة [KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache](https://huggingface.co/papers/2402.02750). تتيح هذه الذاكرة للنموذج توليد تسلسلات أطول دون تخصيص ذاكرة كبيرة للمفاتيح والقيم من خلال تطبيق التكميم. تحتوي الذاكرة المؤقتة على نوعين من التخزين، أحدهما للدقة الأصلية والآخر للذاكرة المؤقتة المُكمَّمة. يتم تحديد `residual length` كسعة قصوى للذاكرة المؤقتة ذات الدقة الأصلية. عندما يتجاوز الطول السعة القصوى، يتم التخلي عن ذاكرة الدقة الأصلية ونقلها إلى الذاكرة المؤقتة المُكمَّمة. يتم إجراء التكميم لكل قناة (per-channel) باستخدام مجموعة محددة من `q_group_size` لكل من المفاتيح والقيم، على عكس ما تم وصفه في الورقة.

راجع `Cache` للاطلاع على التفاصيل المتعلقة بالطرق الشائعة التي تنفذها جميع فئات الكاش.

تُهيّئ الحُجج الخمسة الأخيرة واجهات الخلفية للأعداد الصحيحة على مستوى المجموعات. بينما يقوم واجهة الخلفية `fp8` بتكميم على مستوى الموتر (per-tensor) ويرفض هذه الحُجج.

#### transformers.EncoderDecoderCache[[transformers.EncoderDecoderCache]]

```python
transformers.EncoderDecoderCache(*caches)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2199)

**المعاملات:**

caches (`Iterable`) : عادةً ما يكون قابلًا للتكرار بطول 2، ويحتوي على كائنين من `Cache`، الأول لانتباه الذات (self-attention) والثاني لانتباه التقاطع (cross-attention). يمكن أن يكون اختياريًا أيضًا قابلًا للتكرار بطول 1، ويحتوي على `tuple[tuple[torch.Tensor]]` (يُستخدم عادةً للتوافق مع torch dp و ddp).

فئة أساسية مجردة لجميع ذاكرات التخزين (الكاش) لمشفّرات-المفكّكات. يمكن استخدامها لحمل تركيبات من ذاكرات الانتباه الذاتي والانتباه المتقاطع.

راجع `Cache` للاطلاع على التفاصيل المتعلقة بالطرق الشائعة التي تنفذها جميع فئات الكاش.

مثال:

```python
>>> from transformers import AutoProcessor, AutoModelForCausalLM, DynamicCache, EncoderDecoderCache

>>> model = AutoModelForCausalLM.from_pretrained("openai/whisper-small")
>>> processor = AutoProcessor.from_pretrained("openai/whisper-small")

>>> inputs = processor(audio=YOUR-AUDIO, return_tensors="pt")

>>> # Prepare cache classes for encoder and decoder and pass it to model's forward
>>> self_attention_cache = DynamicCache(config=self.config)
>>> cross_attention_cache = DynamicCache(config=self.config)
>>> past_key_values = EncoderDecoderCache(self_attention_cache, cross_attention_cache)
>>> outputs = model(**inputs, past_key_values=past_key_values, use_cache=True)
>>> outputs.past_key_values # access cache filled with key/values from generation
EncoderDecoderCache()
```

#### batch_repeat_interleave[[transformers.EncoderDecoderCache.batch_repeat_interleave]]

```python
batch_repeat_interleave(repeats: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2316)

كرر الكاش `repeats` مرات في بُعد الدفعة. يُستخدم في البحث التبايني (على Hub).

#### batch_select_indices[[transformers.EncoderDecoderCache.batch_select_indices]]

```python
batch_select_indices(indices: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2322)

احتفظ فقط بـ`indices` في بُعد الدفعة (batch dimension) للكاش. يُستخدم في البحث التبايني (على Hub).

#### قص[[transformers.EncoderDecoderCache.crop]]

```python
crop(tokens_to_remove: int)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2309)

أزل رموز `tokens_to_remove` من طبقة التخزين المؤقت الحالية.

#### get_max_length[[transformers.EncoderDecoderCache.get_max_length]]

```python
get_max_length(layer_idx: int | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2284)

يعيد أقصى طول للتسلسل (أي السعة القصوى) لكائن التخزين المؤقت

#### get_seq_length[[transformers.EncoderDecoderCache.get_seq_length]]

```python
get_seq_length(layer_idx: int = 0)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2280)

يعيد طول التسلسل للحالات المخزنة مؤقتًا. يمكن تمرير فهرس طبقة بشكل اختياري.

#### reorder_cache[[transformers.EncoderDecoderCache.reorder_cache]]

```python
reorder_cache(beam_idx: LongTensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/cache_utils.py#L2294)

يعيد ترتيب ذاكرة التخزين المؤقت للبحث بالحزمة، بناءً على فهارس الحزم المحددة.

## أدوات العلامة المائية[[transformers.WatermarkingConfig]]

#### transformers.WatermarkingConfig[[transformers.WatermarkingConfig]]

```python
transformers.WatermarkingConfig(greenlist_ratio: float = 0.25, bias: float = 2.0, hashing_key: int = 15485863, seeding_scheme: str = 'lefthash', context_width: int = 1)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1458)

فئة تحتوي على حُجج توليد العلامة المائية، ويجب تمريرها إلى `GenerationConfig` أثناء `generate`. راجع [هذا الورق](https://huggingface.co/papers/2306.04634) لمزيد من التفاصيل حول الحُجج.

يقبل المفاتيح التالية:
- greenlist_ratio (`float`): يُستخدم للتعليم المائي. نسبة الرموز "الخضراء" المستخدمة إلى حجم المفردات. القيمة الافتراضية هي 0.25.
- bias (`float`): يُستخدم مع العلامة المائية. هو الانحياز المُضاف إلى قيم اللوجيت (logits) للرموز "الخضراء" المحددة. القيمة الافتراضية هي 2.0.
- hashing_key (`int`): مفتاح التجزئة المستخدم للتعليم المائي. القيمة الافتراضية هي 15485863 (العدد الأولي المليون).
- seeding_scheme (`str`): الخوارزمية المستخدمة للتوقيع المائي. تقبل القيم التالية:
  - "lefthash" (الافتراضي): تعتمد عملية اختيار الرموز "الخضراء" على الرمز الأخير (الخوارزمية 2 من الورقة البحثية)
  - يعتمد اختيار الرموز ذات قيمة "selfhash": "green" على الرمز الحالي نفسه (الخوارزمية 3 من الورقة البحثية). والعيوب في هذا المخطط أنه يأخذ في الاعتبار جميع الرموز التالية المحتملة، وقد يكون أبطأ من "lefthash".
- context_width(`int`): طول السياق للرموز السابقة المستخدمة في التهيئة. كلما زاد طول السياق، زادت متانة العلامة المائية.

#### __call__[[transformers.WatermarkingConfig.__call__]]

```python
__call__(*args, **kwargs)
```

استدعاء self كدالة.

#### transformers.WatermarkDetector[[transformers.WatermarkDetector]]

```python
transformers.WatermarkDetector(model_config: PreTrainedConfig, device: str, watermarking_config: typing.Union[ForwardRef('WatermarkingConfig'), dict], ignore_repeated_ngrams: bool = False, max_cache_size: int = 128)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L71)

**المعاملات:**

model_config (`PreTrainedConfig`) : إعدادات النموذج التي ستُستخدم للحصول على الحُجج الخاصة بالنموذج المستخدمة أثناء التوليد.

device (`str`) : الجهاز الذي تم استخدامه أثناء توليد النص المُعلَّم.

watermarking_config (Union[`WatermarkingConfig`, `Dict`]) : إعدادات وحوافز العلامة المائية نفسها تمامًا التي استُخدمت عند توليد النص.

ignore_repeated_ngrams (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان يجب عدّ كل ngram فريد مرة واحدة فقط أم لا.

max_cache_size (`int`، *اختياري*، القيمة الافتراضية 128) : الحد الأقصى للحجم المستخدم لتخزين مؤقت (LRU caching) لخوارزميات البذر/العينة التي تُستدعى لكل رمز.

كاشف للنص المولّد الذي يحمل علامة مائية. يجب تزويد الكاشف بالإعدادات نفسها تمامًا التي تم استخدامها أثناء توليد النص، وذلك لإعادة إنتاج توليد قائمة العلامة المائية الخضراء وبالتالي اكتشاف العلامة المائية. وتشمل هذه الإعدادات الجهاز الصحيح الذي تم استخدامه أثناء توليد النص، وحجج العلامة المائية الصحيحة، وحجم مفردات المُجزّئ الصحيح. استُند الكود إلى [المستودع الأصلي](https://github.com/jwkirchenbauer/lm-watermarking/tree/main).

راجع [الورقة البحثية](https://huggingface.co/papers/2306.04634) لمزيد من المعلومات.

أمثلة:

```python
>>> from transformers import AutoTokenizer, AutoModelForCausalLM, WatermarkDetector, WatermarkingConfig

>>> model_id = "openai-community/gpt2"
>>> model = AutoModelForCausalLM.from_pretrained(model_id)
>>> tok = AutoTokenizer.from_pretrained(model_id)
>>> tok.pad_token_id = tok.eos_token_id
>>> tok.padding_side = "left"

>>> inputs = tok(["This is the beginning of a long story", "Alice and Bob are"], padding=True, return_tensors="pt")
>>> input_len = inputs["input_ids"].shape[-1]

>>> # first generate text with watermark and without
>>> watermarking_config = WatermarkingConfig(bias=2.5, seeding_scheme="selfhash")
>>> out_watermarked = model.generate(**inputs, watermarking_config=watermarking_config, do_sample=False, max_length=20)
>>> out = model.generate(**inputs, do_sample=False, max_length=20)

>>> # now we can instantiate the detector and check the generated text
>>> detector = WatermarkDetector(model_config=model.config, device="cpu", watermarking_config=watermarking_config)
>>> detection_out_watermarked = detector(out_watermarked, return_dict=True)
>>> detection_out = detector(out, return_dict=True)
>>> detection_out_watermarked.prediction
array([ True,  True])

>>> detection_out.prediction
array([False,  False])
```

#### __call__[[transformers.WatermarkDetector.__call__]]

```python
__call__(input_ids: LongTensor, z_threshold: float = 3.0, return_dict: bool = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L193)

**المعاملات:**

input_ids (`torch.LongTensor`) : النص المولّد المُعلَّم. يُنصح بإزالة الأمر (prompt)، إذ قد يؤثر ذلك على عملية الكشف.

z_threshold (`Dict`، *اختياري*، القيمة الافتراضية `3.0`) : تغيير هذا العتبة سيغيّر حساسية الكاشف. عتبة z الأعلى تعطي حساسية أقل، والعكس صحيح لعتبة z الأدنى.

return_dict (`bool`، *اختياري*، الافتراضي `False`) : ما إذا كان يجب إرجاع `~generation.WatermarkDetectorOutput` أم لا. إذا لم يكن كذلك، فسيُرجع تنبؤات منطقية،

**يعيد:** `WatermarkDetectorOutput` أو `np.ndarray`

`WatermarkDetectorOutput` إذا كان `return_dict=True` وإلا `np.ndarray`.

ma

#### transformers.BayesianDetectorConfig[[transformers.BayesianDetectorConfig]]

```python
transformers.BayesianDetectorConfig(watermarking_depth: int | None = None, base_rate: float = 0.5, **kwargs)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L252)

**المعاملات:**

watermarking_depth (`int`، *اختياري*) : عدد طبقات البطولة.

base_rate (`float`، *اختياري*، القيمة الافتراضية 0.5) : الاحتمال المسبق P(w) لأن يكون النص مُعلَّمًا مائيًا.

هذه فئة الإعدادات المخزنة لإعدادات [BayesianDetectorModel](/docs/transformers/main/ar/internal/generation_utils#transformers.BayesianDetectorModel). تُستخدم لاستنساخ نموذج Bayesian Detector وفقاً للحجج المحددة.

ترث كائنات الإعداد من [PreTrainedConfig](/docs/transformers/main/ar/main_classes/configuration#transformers.PreTrainedConfig) ويمكن استخدامها للتحكم في مخرجات النموذج. اقرأ التوثيق الخاص بـ [PreTrainedConfig](/docs/transformers/main/ar/main_classes/configuration#transformers.PreTrainedConfig) لمزيد من المعلومات.

#### transformers.BayesianDetectorModel[[transformers.BayesianDetectorModel]]

```python
transformers.BayesianDetectorModel(config)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L359)

**المعاملات:**

config ([BayesianDetectorConfig](/docs/transformers/main/ar/internal/generation_utils#transformers.BayesianDetectorConfig)) : فئة إعدادات النموذج التي تحتوي على جميع معاملات النموذج. عند التهيئة باستخدام ملف إعدادات، لا يتم تحميل الأوزان المرتبطة بالنموذج، بل الإعدادات فقط. راجع طريقة [from_pretrained()](/docs/transformers/main/ar/main_classes/model#transformers.PreTrainedModel.from_pretrained) لتحميل أوزان النموذج.

مصنّف بايزي لكشف العلامة المائية.

يستخدم هذا الكاشف قاعدة بايز لحساب درجة العلامة المائية، وهي دالة سيجمويد (sigmoid) لللوغاريتم لنسبة الاحتمالات اللاحقة P(watermarked|g_values) إلى P(unwatermarked|g_values). يرجى الرجوع إلى القسم الخاص بـ BayesianScore في الورقة البحثية لمزيد من التفاصيل. رابط الورقة: https://www.nature.com/articles/s41586-024-08025-4

لاحظ أن هذا الكاشف يعمل فقط مع علامات مائية غير مشوهة تعتمد على نظام Turnament باستخدام توزيع g-value من نوع Bernoulli(0.5).

يرث هذا النموذج من [PreTrainedModel](/docs/transformers/main/ar/main_classes/model#transformers.PreTrainedModel). راجع توثيق الفئة الأصلية لمعرفة الطرق العامة التي تنفذها المكتبة لجميع نماذجها (مثل التنزيل أو الحفظ، وتغيير حجم تضمينات الإدخال، وقص الرؤوس، وما إلى ذلك).

هذا النموذج هو أيضاً فئة فرعية من [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) في PyTorch. استخدمه كوحدة PyTorch عادية، وارجع إلى توثيق PyTorch لكل ما يتعلق بالاستخدام العام والسلوك.

#### forward[[transformers.BayesianDetectorModel.forward]]

```python
forward(g_values: Tensor, mask: Tensor, labels: typing.Optional[torch.Tensor] = None, loss_batch_weight = 1, return_dict = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L448)

**المعاملات:**

g_values (`torch.Tensor` من الشكل `(batch_size, seq_len, watermarking_depth, ...)`) : قيم g (بقيم 0 أو 1)

mask : مصفوفة ثنائية الشكل [batch_size, seq_len] تُحدد القيم g التي يجب استخدامها. تُستبعد قيم g التي تكون قيمة القناع الخاصة بها 0.

**يعيد:**

p(watermarked | g_values)، من الشكل [batch_size].

يحسب التوزيع اللاحق المُعلَّم مائيًا P(watermarked|g_values).

#### transformers.SynthIDTextWatermarkingConfig[[transformers.SynthIDTextWatermarkingConfig]]

```python
transformers.SynthIDTextWatermarkingConfig(ngram_len: int, keys: list, context_history_size: int = 1024, sampling_table_seed: int = 0, sampling_table_size: int = 65536, skip_first_ngram_calls: bool = False, debug_mode: bool = False)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1538)

**المعاملات:**

ngram_len (`int`) : طول Ngram.

keys (`list[int]`) : تسلسل من مفاتيح العلامة المائية، مفتاح واحد لكل عمق.

context_history_size (`int`، *اختياري*، القيمة الافتراضية 1024) : حجم المصفوفة (tensor) لتتبع السياقات التي تم رؤيتها.

sampling_table_seed (`int`، *اختياري*، القيمة الافتراضية 0) : البذرة العشوائية لتوليد جدول العينة.

sampling_table_size (`int`، *اختياري*، القيمة الافتراضية 65536) : حجم جدول العينة.

skip_first_ngram_calls (`bool`، *اختياري*، القيمة الافتراضية `False`) : ما إذا كان سيتم تخطي استدعاءات ngram الأولى.

debug_mode (`bool`، *اختياري*، القيمة الافتراضية `False`) : يتم تعديل القيم اللوجستية (Logits) لتصبح موحّدة قبل تطبيق تعديل العلامة المائية. يُستخدم هذا الاختبار للتحقق من صحة التنفيذ.

فئة تحتوي على حُجج توليد العلامة المائية، ويجب تمريرها إلى `GenerationConfig` أثناء `generate`. راجع [هذا الورق](https://www.nature.com/articles/s41586-024-08025-4) لمزيد من التفاصيل حول الحُجج.

أمثلة:
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, SynthIDTextWatermarkingConfig

>>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b', padding_side="left")
>>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b')

>>> # SynthID Text configuration
>>> watermarking_config = SynthIDTextWatermarkingConfig(
...     keys=[654, 400, 836, 123, 340, 443, 597, 160, 57],
...     ngram_len=5,
... )

>>> # Generation with watermarking
>>> tokenized_prompts = tokenizer(["Once upon a time, "], return_tensors="pt", padding=True)
>>> output_sequences = model.generate(
...     **tokenized_prompts, watermarking_config=watermarking_config, do_sample=True, max_new_tokens=10
... )
>>> watermarked_text = tokenizer.batch_decode(output_sequences, skip_special_tokens=True)
```

#### transformers.SynthIDTextWatermarkDetector[[transformers.SynthIDTextWatermarkDetector]]

```python
transformers.SynthIDTextWatermarkDetector(detector_module: BayesianDetectorModel, logits_processor: SynthIDTextWatermarkLogitsProcessor, tokenizer: Any)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L492)

**المعاملات:**

detector_module ([BayesianDetectorModel](/docs/transformers/main/ar/internal/generation_utils#transformers.BayesianDetectorModel)) : كائن وحدة كاشف بايزي مُهيّأ بالمعاملات. راجع https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text للاستخدام.

logits_processor (`SynthIDTextWatermarkLogitsProcessor`) : مُعالِج القيم المستخدمة لتطبيق العلامة المائية.

tokenizer (`Any`) : مُجزِّئ الرموز المستخدم للنموذج.

فئة كاشف علامة SynthID المائية للنص.

يجب تهيئة هذه الفئة مع وحدة الكاشف البايزي المدرّب، ويمكن الاطلاع على ذلك في سكربت الفحص الموجود في examples/synthid_text/detector_training.py، على سبيل المثال في تدريب/حفظ/تحميل وحدة الكاشف هذه. كما تُظهر المجلد نفسه حالة استخدام نموذجية لهذا الكاشف.

أمثلة:
```python
>>> from transformers import (
...     AutoTokenizer, BayesianDetectorModel, SynthIDTextWatermarkLogitsProcessor, SynthIDTextWatermarkDetector
... )

>>> # Load the detector. See https://github.com/huggingface/transformers-research-projects/tree/main/synthid_text for training a detector.
>>> detector_model = BayesianDetectorModel.from_pretrained("joaogante/dummy_synthid_detector")
>>> logits_processor = SynthIDTextWatermarkLogitsProcessor(
...     **detector_model.config.watermarking_config, device="cpu"
... )
>>> tokenizer = AutoTokenizer.from_pretrained(detector_model.config.model_name)
>>> detector = SynthIDTextWatermarkDetector(detector_model, logits_processor, tokenizer)

>>> # Test whether a certain string is watermarked
>>> test_input = tokenizer(["This is a test input"], return_tensors="pt")
>>> is_watermarked = detector(test_input.input_ids)
```

#### __call__[[transformers.SynthIDTextWatermarkDetector.__call__]]

```python
__call__(tokenized_outputs: Tensor)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/watermarking.py#L539)

## أدوات الترجمة[[transformers.CompileConfig]]

#### transformers.CompileConfig[[transformers.CompileConfig]]

```python
transformers.CompileConfig(fullgraph: bool = False, dynamic: bool | None = None, backend: str | collections.abc.Callable = 'inductor', mode: str = 'reduce-overhead', options: dict | None = None)
```

[المصدر](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/configuration_utils.py#L1630)

**المعاملات:**

fullgraph (`bool`، *اختياري*، القيمة الافتراضية `False`) : إذا كانت القيمة False (الافتراضية)، فسيتم محاولة اكتشاف المناطق القابلة للتجميع التي سيتم تحسينها. أما إذا كانت True، فسيُشترط أن يكون بالإمكان التقاط الدالة بأكملها في رسم بياني واحد. وإذا لم يكن ذلك ممكنًا (أي إذا كانت هناك انقطاعات في الرسم البياني)، فسيتم رفع خطأ.

dynamic (`bool` أو `None`، *اختياري*) : ما إذا كان يجب محاولة استخدام رسوميات الأشكال الديناميكية.

backend (`str` أو `Callable`، *اختياري*، القيمة الافتراضية `"inductor"`) : الخلفية (Backend) التي سيتم استخدامها.

mode (`str`، *اختياري*، القيمة الافتراضية `"reduce-overhead"`) : يتحكم في التوازن بين الأداء والتكلفة الإضافية.

options (`dict`، *اختياري*) : قاموس لخيارات تُمرَّر إلى الخلفية.

فئة تحتوي على الحُجج المتعلقة بسلوك `torch.compile` عند استخدام التجميع التلقائي في `generate`. راجع [`torch.compile`](https://pytorch.org/docs/stable/generated/torch.compile.html) لمزيد من التفاصيل حول الحُجج.

أمثلة:
```python
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, CompileConfig

>>> tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b')
>>> model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b').cuda()

>>> # Automatic compile configuration, used with static cache
>>> compile_config = CompileConfig(dynamic=True)

>>> # Generation with static cache and compile config
>>> input = tokenizer.encode("Hello there, how", return_tensors="pt").cuda()
>>> output = model.generate(
...     input, do_sample=False, max_new_tokens=300, cache_implementation="static", compile_config=compile_config
... )
>>> output_text = tokenizer.batch_decode(output, skip_special_tokens=True)[0]
```

#### __call__[[transformers.CompileConfig.__call__]]

```python
__call__(*args, **kwargs)
```

استدعاء self كدالة.