# LUKE

## Genel Bakış

LUKE modeli, Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda ve Yuji Matsumoto tarafından [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention](https://huggingface.co/papers/2010.01057) makalesinde önerilmiştir. RoBERTa tabanlıdır ve varlık gömme (entity embeddings) ile varlık farkındalıklı öz-dikkat (entity-aware self-attention) mekanizması ekler; bu da adlandırılmış varlık tanıma, çıkarımsal ve cloze tarzı soru-cevap, varlık sınıflandırma ve ilişki sınıflandırma gibi varlıklar hakkında akıl yürütme içeren çeşitli aşağı akış görevlerinde performansı iyileştirmeye yardımcı olur.

Makalenin özeti aşağıdaki gibidir:

*Varlık temsilleri, varlıklar içeren doğal dil işlerinde faydalıdır. Bu makalede, çift yönlü dönüştürücüye dayalı, kelimelerin ve varlıkların yeni önceden eğitilmiş bağlamsal temsillerini öneriyoruz. Önerilen model, verilen bir metindeki kelimeleri ve varlıkları bağımsız jetonlar olarak ele alır ve bunların bağlamsal temsillerini üretir. Modelimiz, BERT'in maskeli dil modeline dayalı yeni bir ön eğitim görevi kullanılarak eğitilir. Görev, Wikipedia'dan alınan büyük bir varlık etiketli korpus içinde rastgele maskelenen kelimeleri ve varlıkları tahmin etmeyi içerir. Ayrıca, dönüştürücünün öz-dikkat mekanizmasının bir uzantısı olan ve dikkat puanlarını hesaplarca jeton türlerini (kelimeler veya varlıklar) dikkate alan varlık-farkındalıklı bir öz-dikkat mekanizması öneriyoruz. Önerilen model, geniş bir yelpazedeki varlıkla ilgili görevlerde etkileyici ampirik performans elde eder. Özellikle, beş tanınmış veri setinde en iyi sonuçları (state-of-the-art) elde eder: Open Entity (varlık sınıflandırma), TACRED (ilişki sınıflandırma), CoNLL-2003 (adlandırılmış varlık tanıma), ReCoRD (cloze tarzı soru-cevap) ve SQuAD 1.1 (çıkarımsal soru-cevap).*

Bu model [ikuyamada](https://huggingface.co/ikuyamada) ve [nielsr](https://huggingface.co/nielsr) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/studio-ousia/luke) bulunabilir.

## Kullanım ipuçları

- Bu uygulama, [RobertaModel](/docs/transformers/main/tr/model_doc/roberta#transformers.RobertaModel) ile aynıdır; ancak varlık gömme (entity embeddings) ve varlık farkındalıklı öz-dikkat (entity-aware self-attention) mekanizması eklenmiştir. Bu eklemeler, varlıklar hakkında akıl yürütme gerektiren görevlerde performansı artırır.
- LUKE, varlıkları girdi jetonları olarak ele alır; bu nedenle `entity_ids`, `entity_attention_mask`, `entity_token_type_ids` ve `entity_position_ids` değerlerini ek girdi olarak alır. Bu değerleri [LukeTokenizer](/docs/transformers/main/tr/model_doc/luke#transformers.LukeTokenizer) kullanarak elde edebilirsiniz.
- [LukeTokenizer](/docs/transformers/main/tr/model_doc/luke#transformers.LukeTokenizer), `entities` ve `entity_spans` (girdi metnindeki varlıkların karakter tabanlı başlangıç ve bitiş konumları) gibi ek girdiler alır. `entities` genellikle [MASK] varlıkları veya Wikipedia varlıklarından oluşur. Bu varlıkları girdi olarak verirken kısa açıklamalar aşağıdaki gibidir:

  - *[MASK] varlıklarını girerek varlık temsillerini hesaplama*: [MASK] varlığı, ön eğitim sırasında tahmin edilecek varlıkları maskelemek için kullanılır. LUKE, [MASK] varlığını aldığında, girdi metninden varlığa ilişkin bilgileri toplayarak orijinal varlığı tahmin etmeye çalışır. Bu nedenle, [MASK] varlığı, metindeki varlıkların bilgisini gerektiren varlık sınıflandırma, ilişki sınıflandırma ve adlandırılmış varlık tanıma gibi aşağı akış görevlerini ele almak için kullanılabilir.
  - *Wikipedia varlıklarını girdi olarak kullanarak bilgi destekli token temsillemeleri hesaplamak*: LUKE, ön eğitim sırasında Wikipedia varlıkları hakkında zengin bilgi (veya bilgi birikimi) öğrenir ve bu bilgiyi varlık gömme (embedding) içinde saklar. Wikipedia varlıkları girdi token'ları olarak kullanıldığında, LUKE bu varlıkların gömmelerinde saklanan bilgiyle zenginleştirilmiş token temsillemeleri üretir. Bu, soru-cevap gibi gerçek dünya bilgisi gerektiren görevler için özellikle etkilidir.

- Önceki kullanım senaryosu için üç baş modeli bulunmaktadır:

  - [LukeForEntityClassification](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForEntityClassification), bir girdi metnindeki tek bir varlığı sınıflandırmak için varlık tiplendirme gibi görevlerde kullanılır, örneğin [Open Entity dataset](https://www.cs.utexas.edu/~eunsol/html_pages/open_entity.html). Bu model, çıktı varlık temsilinin üzerine doğrusal bir başlık yerleştirir.
  - İki varlık arasındaki ilişkiyi sınıflandıran görevler, örneğin ilişki sınıflandırması gibi, [TACRED veri seti](https://nlp.stanford.edu/projects/tacred/) için [LukeForEntityPairClassification](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForEntityPairClassification). Bu model, verilen varlık çiftinin birleştirilmiş çıktı temsilinin üzerine doğrusal bir başlık yerleştirir.
  - [LukeForEntitySpanClassification](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForEntitySpanClassification), adlandırılmış varlık tanıma (NER) gibi varlık aralıklarının dizisini sınıflandırmak için görevlerde kullanılır. Bu model, çıktı varlık temsillerinin üzerine doğrusal bir başlık yerleştirir. Bu modelle NER işini, metindeki tüm olası varlık aralıklarını modele girdi olarak vererek ele alabilirsiniz.

  [LukeTokenizer](/docs/transformers/main/tr/model_doc/luke#transformers.LukeTokenizer)'in, `task="entity_classification"`, `task="entity_pair_classification"` veya `task="entity_span_classification"` belirtmek suretiyle bu head modellerine girdi oluşturmanızı kolaylaştıran bir `task` argümanı vardır. Lütfen her head modelinin örnek koduna başvurun.

Kullanım örneği:

```python
from transformers import LukeForEntityPairClassification, LukeModel, LukeTokenizer

model = LukeModel.from_pretrained("studio-ousia/luke-base", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
# Example 1: Computing the contextualized entity representation corresponding to the entity mention "Beyoncé"

text = "Beyoncé lives in Los Angeles."
entity_spans = [(0, 7)]  # character-based entity span corresponding to "Beyoncé"
inputs = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 2: Inputting Wikipedia entities to obtain enriched contextualized representations

entities = [
    "Beyoncé",
    "Los Angeles",
]  # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
entity_spans = [(0, 7), (17, 28)]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 3: Classifying the relationship between two entities using LukeForEntityPairClassification head model

model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
entity_spans = [(0, 7), (17, 28)]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt").to(model.device)
outputs = model(**inputs)
logits = outputs.logits
predicted_class_idx = int(logits[0].argmax())
print("Predicted class:", model.config.id2label[predicted_class_idx])
```

## Kaynaklar

- [[LukeForEntityPairClassification](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForEntityPairClassification) için ilişki sınıflandırma amacıyla ince ayar yapmanın nasıl yapılacağını gösteren bir demo defter](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/LUKE)
- [LUKE'nin HuggingFace uygulamasıyla makalede raporlanan sonuçları nasıl yeniden üretebileceğinizi gösteren defterler](https://github.com/studio-ousia/luke/tree/master/notebooks)
- [Metin sınıflandırma görevi kılavuzu](../tasks/sequence_classification)
- [Token sınıflandırma görevi kılavuzu](../tasks/token_classification)
- [Soru yanıtlama görevi kılavuzu](../tasks/question_answering)
- [Masked dil modelleme görevi kılavuzu](../tasks/masked_language_modeling)
- [Çoktan seçmeli görev kılavuzu](../tasks/multiple_choice)

## LukeConfig[[transformers.LukeConfig]]

#### transformers.LukeConfig[[transformers.LukeConfig]]

```python
transformers.LukeConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 50267, entity_vocab_size: int = 500000, hidden_size: int = 768, entity_emb_size: int = 256, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, use_entity_aware_attention: bool = True, classifier_dropout: float | int | None = None, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/configuration_luke.py#L24)

**Parametreler:**

vocab_size (`int`, *isteğe bağlı*, varsayılan `50267`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

entity_vocab_size (`int`, *isteğe bağlı*, varsayılan 500000) : LUKE modelinin varlık sözlük boyutu. [LukeModel](/docs/transformers/main/tr/model_doc/luke#transformers.LukeModel) çağrılırken geçirilen `entity_ids` tarafından temsil edilebilecek farklı varlıkların sayısını tanımlar.

hidden_size (`int`, *isteğe bağlı*, varsayılan `768`) : Gizli temsillerin boyutu.

entity_emb_size (`int`, *isteğe bağlı*, varsayılan 256) : Varlık gömme (embedding) boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

intermediate_size (`int`, *isteğe bağlı*, varsayılan `3072`) : MLP temsil boyutu.

hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

hidden_dropout_prob (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Gömme, kodlayıcı ve havuzlayıcıdaki tüm tam bağlı katmanlar için dropout olasılığı.

attention_probs_dropout_prob (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Dikkat olasılıkları için dropout oranı.

max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `512`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu.

type_vocab_size (`int`, *isteğe bağlı*, varsayılan `2`) : `token_type_ids` için sözlük boyutu.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

layer_norm_eps (`float`, *opsiyonel*, varsayılan `1e-12`) : Katman normalizasyonu katmanları tarafından kullanılan epsilon.

use_entity_aware_attention (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin, [LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention (Yamada et al.)](https://huggingface.co/papers/2010.01057) makalesinde önerilen varlık farkındalıklı öz-dikkat mekanizmasını kullanıp kullanmayacağı.

classifier_dropout (`Union[float, int]`, *isteğe bağlı*) : Sınıflandırıcı için dropout oranı.

pad_token_id (`int`, *isteğe bağlı*, varsayılan `1`) : Sözlükte dolgu için kullanılan token kimliği.

bos_token_id (`int`, *isteğe bağlı*, varsayılan `0`) : Sözlükte akış başlangıcı için kullanılan token kimliği.

eos_token_id (`Union[int, list[int]]`, *isteğe bağlı*, varsayılan `2`) : Sözlükte akış sonu için kullanılan token kimliği.

tie_word_embeddings (`bool`, *isteğe bağlı*, varsayılan `True`) : Ağırlık gömme bağlamalarının, modelin `tied_weights_keys` eşlemesine göre yapılıp yapılmayacağını belirtir.

Bu, bir LukeModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Luke modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [studio-ousia/luke-base](https://huggingface.co/studio-ousia/luke-base) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnekler:

```python
>>> from transformers import LukeConfig, LukeModel

>>> # Initializing a LUKE configuration
>>> configuration = LukeConfig()

>>> # Initializing a model from the configuration
>>> model = LukeModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## LukeTokenizer[[transformers.LukeTokenizer]]

#### transformers.LukeTokenizer[[transformers.LukeTokenizer]]

```python
transformers.LukeTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, entity_vocab: str | dict | list | None = None, errors = 'replace', bos_token = '<s>', eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', mask_token = '<mask>', add_prefix_space = False, task = None, max_entity_length = 32, max_mention_length = 30, entity_1_token = '<ent>', entity_2_token = '<ent2>', entity_unk_token = '[UNK]', entity_pad_token = '[PAD]', entity_mask_token = '[MASK]', entity_mask2_token = '[MASK2]', **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/tokenization_luke.py#L131)

**Parametreler:**

vocab_file (`str`) : Sözlük dosyasının yolu.

merges_file (`str`) : Birleştirme dosyasının yolu.

vocab (`str` veya `dict[str, int]`, *isteğe bağlı*) : Özel sözlük. Sağlanmazsa, sözlük `vocab_file` içinden yüklenir.

merges (`str` veya `list[str]`, *isteğe bağlı*) : Özel birleştirme listesi. Sağlanmazsa, birleştirmeler `merges_file` içinden yüklenir.

entity_vocab_file (`str`) : Varlık sözlük dosyasının yolu.

task (`str`, *isteğe bağlı*) : Dizileri hazırlamak istediğiniz görev. `"entity_classification"`, `"entity_pair_classification"` veya `"entity_span_classification"` değerlerinden biri. Bu argümanı belirtirseniz, varlık dizisi verilen varlık aralığına (aralıklarına) göre otomatik olarak oluşturulur.

max_entity_length (`int`, *isteğe bağlı*, varsayılan 32) : `entity_ids`'nin maksimum uzunluğu.

max_mention_length (`int`, *isteğe bağlı*, varsayılan 30) : Bir varlık aralığındaki en fazla token sayısı.

entity_1_token (`str`, *isteğe bağlı*, varsayılan `<ent>`) : Kelime token dizisinde bir varlık aralığını temsil etmek için kullanılan özel token. Bu token yalnızca `task` `"entity_classification"` veya `"entity_pair_classification"` olarak ayarlandığında kullanılır.

entity_2_token (`str`, *isteğe bağlı*, varsayılan `<ent2>`) : Bir kelime belirteci dizisinde varlık aralığını temsil etmek için kullanılan özel belirteç. Bu belirteç yalnızca `task` `"entity_pair_classification"` olarak ayarlandığında kullanılır.

errors (`str`, *isteğe bağlı*, varsayılan `"replace"`) : Baytların UTF-8'e çözümlenirken izlenecek paradigma. Daha fazla bilgi için [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode)'e bakın.

bos_token (`str`, *isteğe bağlı*, varsayılan `"<s>"`) : Ön eğitim sırasında kullanılan dizinin başlangıç jetonu. Bir dizi sınıflandırıcı jetonu olarak kullanılabilir. Özel jetonlar kullanılarak bir dizi oluşturulduğunda, dizinin başlangıcı için kullanılan jeton bu değildir. Kullanılan jeton `cls_token`'dur.

eos_token (`str`, *isteğe bağlı*, varsayılan `"</s>"`) : Sıra sonu belirteci. Özel belirteçler kullanılarak bir sıra oluşturulduğunda, sıra sonu için kullanılan belirteç bu değildir. Kullanılan belirteç `sep_token`'tur.

sep_token (`str`, *isteğe bağlı*, varsayılan `"</s>"`) : Birden fazla diziden bir dizi oluşturulurken kullanılan ayraç belirteci, örneğin dizi sınıflandırması için iki dizi veya soru cevaplamada bir metin ve bir soru için. Özel belirteçlerle oluşturulan bir dizinin son belirteci olarak da kullanılır.

cls_token (`str`, *isteğe bağlı*, varsayılan `"<s>"`) : Sıralı sınıflandırma (token başına sınıflandırma yerine tüm sıranın sınıflandırılması) yapılırken kullanılan sınıflandırıcı jetonu. Özel jetonlarla oluşturulduğunda sıranın ilk jetonudur.

unk_token (`str`, *isteğe bağlı*, varsayılan `"<unk>"`) : Bilinmeyen token. Sözlükte yer almayan bir token, bir kimliğe dönüştürülemez ve bunun yerine bu token olarak ayarlanır.

pad_token (`str`, *isteğe bağlı*, varsayılan `"<pad>"`) : Dolgu için kullanılan jeton, örneğin farklı uzunluklardaki dizileri toplu işleme (batching) sırasında.

mask_token (`str`, *isteğe bağlı*, varsayılan `"<mask>"`) : Değerleri maskelemek için kullanılan belirteç. Bu, modelin maskeli dil modelleme ile eğitildiğinde kullanılan belirteçtir. Modelin tahmin etmeye çalışacağı belirteç budur.

add_prefix_space (`bool`, *isteğe bağlı*, varsayılan `False`) : Girdinin başına bir boşluk eklenip eklenmeyeceğini belirtir. Bu, baştaki kelimenin diğer kelimelerle aynı şekilde ele alınmasını sağlar. (LUKE tokenizer, kelimelerin başlangıcını önceki boşlukla tespit eder).

GPT-2 tokenizer'ından türetilmiş, bayt düzeyinde Byte-Pair-Encoding kullanan bir LUKE tokenizer'ı oluşturur.

Bu tokenizer, boşlukları tokenların parçaları gibi işlemek üzere eğitilmiştir (biraz da sentencepiece gibi) bu yüzden bir kelime

cümle başında (boşluksuz) mı yoksa değil mi olduğuna göre farklı kodlanabilir:

```python
>>> from transformers import LukeTokenizer

>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]
```

Bu davranışın etrafından dolaşmak için bu tokenizer'ı örneklerken veya bazı metinler üzerinde çağırdığınızda `add_prefix_space=True` parametresini iletebilirsiniz; ancak model bu şekilde ön eğitilmediğinden, performans düşüşüne yol açabilir.

`is_split_into_words=True` ile kullanıldığında, bu tokenizer her kelimenin (ilk kelime dahil) başına bir boşluk ekler.

Bu tokenizer, ana yöntemlerin çoğunu içeren [PreTrainedTokenizer](/docs/transformers/main/tr/main_classes/tokenizer#transformers.PythonBackend) sınıfından devralır. Kullanıcıların bu yöntemler hakkında daha fazla bilgi için bu üst sınıfa başvurması gerekir. Ayrıca LUKE modeli tarafından kullanılacak varlık dizilerini, yani `entity_ids`, `entity_attention_mask`, `entity_token_type_ids` ve `entity_position_ids` oluşturur.

#### __call__[[transformers.LukeTokenizer.__call__]]

```python
__call__(text: str | list[str], text_pair: str | list[str] | None = None, entity_spans: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = None, entity_spans_pair: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = None, entities: list[str] | list[list[str]] | None = None, entities_pair: list[str] | list[list[str]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, max_entity_length: int | None = None, stride: int = 0, is_split_into_words: bool | None = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/tokenization_luke.py#L411)

**Dönüş:** [BatchEncoding](/docs/transformers/main/tr/main_classes/tokenizer#transformers.BatchEncoding)

Aşağıdaki alanlara sahip bir [BatchEncoding](/docs/transformers/main/tr/main_classes/tokenizer#transformers.BatchEncoding):

- **input_ids** -- Bir modele verilecek token kimliklerinin listesi.

  [Girdi kimlikleri nelerdir?](../glossary#input-ids)

- **token_type_ids** -- Bir modele verilecek token türü kimlikleri listesi (`return_token_type_ids=True` olduğunda veya `self.model_input_names` içinde *"token_type_ids"* varsa).

  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

- **attention_mask** -- Modelin hangi token'lara dikkat etmesi gerektiğini belirleyen indeks listesi (`return_attention_mask=True` olduğunda veya *"attention_mask"* `self.model_input_names` içinde olduğunda).

  [Dikkat maskeleri nedir?](../glossary#attention-mask)

- **entity_ids** -- Bir modele verilecek varlık kimliklerinin listesi.

  [Girdi kimlikleri nelerdir?](../glossary#input-ids)

- **entity_position_ids** -- Bir modele verilecek girdi dizisindeki varlık konumlarının listesi.

- **entity_token_type_ids** -- Bir modele verilecek varlık token türü kimlikleri listesi (`return_token_type_ids=True` olduğunda veya *"entity_token_type_ids"* `self.model_input_names` içinde olduğunda).

  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

- **entity_attention_mask** -- Modelin hangi varlıklara dikkat etmesi gerektiğini belirleyen indeks listesi (`return_attention_mask=True` olduğunda veya *"entity_attention_mask"* `self.model_input_names` içinde olduğunda).

  [Dikkat maskeleri nedir?](../glossary#attention-mask)

- **entity_start_positions** -- Kelime belirteç dizisindeki varlıkların başlangıç konumlarının listesi (`task="entity_span_classification"` durumunda).
- **entity_end_positions** -- Kelime belirteç dizisindeki varlıkların bitiş konumlarının listesi (`task="entity_span_classification"` durumunda).
- **overflowing_tokens** -- Taşan token dizileri listesi (`max_length` belirtildiğinde ve `return_overflowing_tokens=True` olduğunda).
- **num_truncated_tokens** -- Kırpılan token sayısı (`max_length` belirtildiğinde ve `return_overflowing_tokens=True` olduğunda).
- **special_tokens_mask** -- 0 ve 1'lerden oluşan liste; 1 eklenen özel tokenları, 0 ise normal dizi tokenlarını belirtir (`add_special_tokens=True` ve `return_special_tokens_mask=True` olduğunda).
- **length** -- Girdilerin uzunluğu (`return_length=True` olduğunda)

add_special_tokens (`bool`, *isteğe bağlı*, varsayılan `True`): Dizileri kodlarken özel jetonların eklenip eklenmeyeceğini belirtir. Bu, girdi kimliklerine otomatik olarak hangi jetonların ekleneceğini tanımlayan alttaki `PretrainedTokenizerBase.build_inputs_with_special_tokens` işlevini kullanır. `bos` veya `eos` jetonlarını otomatik olarak eklemek istiyorsanız bu işe yarar. padding (`bool`, `str` veya [PaddingStrategy](/docs/transformers/main/tr/internal/file_utils#transformers.utils.PaddingStrategy), *isteğe bağlı*, varsayılan `False`): Dolguyu etkinleştirir ve kontrol eder. Aşağıdaki değerleri kabul eder:

- `True` veya `'longest'`: Toplu işlemdeki en uzun dizinin uzunluğuna kadar dolgu yapılır (yalnızca tek bir dizi sağlanıyorsa dolgu yapılmaz).
- `'max_length'`: `max_length` argümanı ile belirtilen maksimum uzunluğa veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum giriş uzunluğuna kadar doldurur.
- `False` veya `'do_not_pad'` (varsayılan): Dolgu yok (yani, farklı uzunluklarda diziler içeren bir parti çıktı olarak üretilebilir).
truncation (`bool`, `str` veya [TruncationStrategy](/docs/transformers/main/tr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opsiyonel*, varsayılan `False`): Kesme işlemini etkinleştirir ve kontrol eder. Aşağıdaki değerleri kabul eder:

- `True` veya `'longest_first'`: `max_length` argümanı ile belirtilen maksimum uzunluğa veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum giriş uzunluğuna kısaltılır. Bu işlem, token bazında gerçekleşir; bir çift dizi (veya çift dizilerden oluşan bir batch) sağlandığında, çiftteki en uzun diziden bir token kaldırılır.
- `'only_first'`: `max_length` argümanı ile belirtilen maksimum uzunluğa veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum giriş uzunluğuna kısaltır. Bir çift dizi (veya çiftlerin bir partisi) sağlandığında, yalnızca çiftin ilk dizisini kısaltır.
- `'only_second'`: `max_length` argümanı ile belirtilen maksimum uzunluğa veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum giriş uzunluğuna kısaltır. Bu, yalnızca bir çift dizi (veya çiftlerin bir partisi) sağlandığında çiftin ikinci dizisini kısaltır.
- `False` veya `'do_not_truncate'` (varsayılan): Kesme yapılmaz (yani, modelin kabul edebileceği maksimum giriş boyutundan daha uzun dizi uzunluklarına sahip bir çıktı partisi üretilebilir).
max_length (`int`, *isteğe bağlı*): Kesme/doldurma parametrelerinden biri tarafından kullanılacak maksimum uzunluğu kontrol eder.

Eğer ayarlanmazsa veya `None` olarak ayarlanırsa, kırpma/dolgu parametrelerinden biri maksimum uzunluk gerektiriyorsa, önceden tanımlanmış model maksimum uzunluğu kullanılacaktır. Modelin belirli bir maksimum giriş uzunluğu yoksa (ör. XLNet), maksimum uzunluğa kırpma/dolgu devre dışı bırakılacaktır. stride (`int`, *isteğe bağlı*, varsayılan 0): `max_length` ile birlikte bir sayı olarak ayarlanırsa, `return_overflowing_tokens=True` olduğunda döndürülen taşan jetonlar, kırpılmış ve taşan diziler arasında bazı örtüşme sağlamak için kırpılmış dizinin sonundan döndürülen bazı jetonları içerecektir. Bu argümanın değeri, örtüşen jeton sayısını tanımlar. is_split_into_words (`bool`, *isteğe bağlı*, varsayılan `False`): Girdinin zaten önceden jetonlaştırılmış olup olmadığını belirtir (ör. kelimelere ayrılmış). `True` olarak ayarlanırsa, tokenizer girdinin zaten kelimelere ayrılmış olduğunu (örneğin boşluklara göre bölünerek) ve bunları jetonlaştıracak varsayar. Bu, NER veya jeton sınıflandırması için kullanışlıdır. pad_to_multiple_of (`int`, *isteğe bağlı*): Ayarlanırsa, diziyi sağlanan değerin katına doldurur. Bunun için `padding` etkinleştirilmelidir. Bu, hesaplama yeteneği `>= 7.5` (Volta) olan NVIDIA donanımlarında Tensor Cores kullanımını etkinleştirmek için özellikle kullanışlıdır. padding_side (`str`, *isteğe bağlı*): Modelde dolgunun uygulanması gereken taraf. ['right', 'left'] arasından seçilmelidir. Varsayılan değer, aynı ada sahip sınıf özelliğinden seçilir. return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *isteğe bağlı*): Ayarlanırsa, python tamsayı listesi yerine tensörler döndürülür. Kabul edilebilir değerler:

- `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür.
- `'np'`: Numpy `np.ndarray` nesnelerini döndürür.

return_token_type_ids (`bool`, *isteğe bağlı*): Token türü kimliklerinin döndürülüp döndürülmeyeceğini belirtir. Varsayılan bırakılırsa, `return_outputs` özniteliği tarafından tanımlanan, ilgili tokenizer'ın varsayılanına göre token türü kimlikleri döndürülür.

[Token type ID'leri nelerdir?](../glossary#token-type-ids) return_attention_mask (`bool`, *isteğe bağlı*): Dikkat maskesinin (attention mask) döndürülüp döndürülmeyeceğini belirtir. Varsayılan bırakılırsa, `return_outputs` özniteliği tarafından tanımlanan, ilgili tokenizer'ın varsayılanına göre dikkat maskesini döndürür.

[Dikkat maskeleri nedir?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *isteğe bağlı*, varsayılan `False`): Taşan token dizilerinin döndürülüp döndürülmeyeceğini belirtir. Girdi kimlikleri çiftlerinden (veya çiftlerden oluşan bir partiden) bir çift, `truncation_strategy = longest_first` veya `True` ile sağlanırsa, taşan tokenları döndürmek yerine bir hata oluşturulur. return_special_tokens_mask (`bool`, *isteğe bağlı*, varsayılan `False`): Özel token maskesi bilgisinin döndürülüp döndürülmeyeceğini belirtir. return_offsets_mapping (`bool`, *isteğe bağlı*, varsayılan `False`): Her token için `(char_start, char_end)` değerlerinin döndürülüp döndürülmeyeceğini belirtir.

Bu özellik yalnızca [PreTrainedTokenizerFast](/docs/transformers/main/tr/main_classes/tokenizer#transformers.TokenizersBackend)'ten türeyen hızlı tokenizörlerde mevcuttur; Python tokenizörü kullanılırsa bu yöntem `NotImplementedError` fırlatır. return_length (`bool`, *isteğe bağlı*, varsayılan `False`): Kodlanmış girdilerin uzunluklarının döndürülüp döndürülmeyeceğini belirtir. verbose (`bool`, *isteğe bağlı*, varsayılan `True`): Daha fazla bilgi ve uyarı basılıp basılmayacağını belirtir. **kwargs: `self.tokenize()` yöntemine aktarılır

#### save_vocabulary[[transformers.LukeTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L546)

## LukeModel[[transformers.LukeModel]]

#### transformers.LukeModel[[transformers.LukeModel]]

```python
transformers.LukeModel(config: LukeConfig, add_pooling_layer: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L788)

**Parametreler:**

config ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

add_pooling_layer (`bool`, *isteğe bağlı*, varsayılan `True`) : Bir havuzlama katmanı eklenip eklenmeyeceği

Hiçbir işlem uygulanmadan hem kelime token'ları hem de varlıklar için ham gizli durumları (hidden-states) üreten çıplak LUKE modeli dönüştürücüsü

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.LukeModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L818)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`) : Varlık sözlüğündeki varlık jetonlarının dizinleri. Dizinler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) bkz.

entity_attention_mask (`torch.Tensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Dolgu varlık token indekslerinde dikkat işleminin uygulanmamasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** varlık tokenları için 1, - **maske uygulanan** varlık tokenları için 0.

entity_token_type_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Varlık token girdilerinin ilk ve ikinci bölümlerini belirtmek için segment token indeksleri. İndeksler `[0, 1]` aralığından seçilir:  - 0, *A bölümü* varlık token'ına karşılık gelir, - 1, *B bölümü* varlık token'ına karşılık gelir.

entity_position_ids (`torch.LongTensor`, şekli `(batch_size, entity_length, max_mention_length)`, *isteğe bağlı*) : Girdi varlıklarının her birinin konum gömme içindeki konum indeksleri. `[0, config.max_position_embeddings - 1]` aralığında seçilir.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `BaseLukeModelOutputWithPooling` veya `tuple(torch.Tensor)`

`BaseLukeModelOutputWithPooling` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LukeModel](/docs/transformers/main/tr/model_doc/luke#transformers.LukeModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- Sıranın ilk token'ının (sınıflandırma token'ı) son katman gizli durumu, ayrıca bir Linear katmanı ve Tanh aktivasyon fonksiyonu ile işlenir.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **entity_last_hidden_state** (`torch.Tensor`, şekli `(batch_size, entity_length, hidden_size)`) -- Modelin son katmanının çıktısındaki varlık gizli durumları dizisi.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, entity_length, hidden_size)`. Modelin her katman çıktısındaki varlık gizli durumları ve başlangıç varlık gömme çıktıları.

Örnekler:

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

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeModel.from_pretrained("studio-ousia/luke-base")
# Compute the contextualized entity representation corresponding to the entity mention "Beyoncé"

>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)]  # character-based entity span corresponding to "Beyoncé"

>>> encoding = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Input Wikipedia entities to obtain enriched contextualized representations of word tokens

>>> text = "Beyoncé lives in Los Angeles."
>>> entities = [
...     "Beyoncé",
...     "Los Angeles",
... ]  # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
>>> entity_spans = [
...     (0, 7),
...     (17, 28),
... ]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"

>>> encoding = tokenizer(
...     text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt"
... )
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
```

## LukeForMaskedLM[[transformers.LukeForMaskedLM]]

#### transformers.LukeForMaskedLM[[transformers.LukeForMaskedLM]]

```python
transformers.LukeForMaskedLM(config: LukeConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1019)

**Parametreler:**

config ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Maskeli dil modellemesi ve maskeli varlık tahmini için üstünde dil modelleme kafası ve varlık tahmini kafası bulunan LUKE modeli.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.LukeForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.LongTensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, entity_labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1044)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`) : Varlık sözlüğündeki varlık jetonlarının dizinleri. Dizinler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) bkz.

entity_attention_mask (`torch.Tensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Dolgu varlık token indekslerinde dikkat işleminin uygulanmamasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** varlık tokenları için 1, - **maske uygulanan** varlık tokenları için 0.

entity_token_type_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Varlık token girdilerinin ilk ve ikinci bölümlerini belirtmek için segment token indeksleri. İndeksler `[0, 1]` aralığından seçilir:  - 0, *A bölümü* varlık token'ına karşılık gelir, - 1, *B bölümü* varlık token'ına karşılık gelir.

entity_position_ids (`torch.LongTensor`, şekli `(batch_size, entity_length, max_mention_length)`, *isteğe bağlı*) : Girdi varlıklarının her birinin konum gömme içindeki konum indeksleri. `[0, config.max_position_embeddings - 1]` aralığında seçilir.

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[-100, 0, ..., config.vocab_size]` aralığında olmalıdır (bkz. `input_ids` docstring). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca etiketleri `[0, ..., config.vocab_size]` aralığında olan tokenlar için hesaplanır.

entity_labels (`torch.LongTensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[-100, 0, ..., config.vocab_size]` aralığında olmalıdır (bkz. `input_ids` docstring). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir); kayıp yalnızca etiketleri `[0, ..., config.vocab_size]` aralığında olan tokenlar için hesaplanır.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `LukeMaskedLMOutput` veya `tuple(torch.Tensor)`

`LukeMaskedLMOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LukeForMaskedLM](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForMaskedLM) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *opsiyonel*, `labels` sağlandığında döndürülür) -- Maskeli dil modelleme (MLM) kaybı ile varlık tahmin kaybının toplamı.
- **mlm_loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Maskeli dil modelleme (MLM) kaybı.
- **mep_loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Maskeli varlık tahmini (MEP) kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar).
- **entity_logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Varlık tahmin başlığının tahmin puanları (SoftMax öncesi her varlık sözlük belirteci için puanlar).
- **hidden_states** (`tuple[torch.Tensor]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren ve `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, entity_length, hidden_size)`. Modelin her katman çıktısındaki varlık gizli durumları ve başlangıç varlık gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnek:

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

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMaskedLM.from_pretrained("studio-ousia/luke-base")

>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...
```

## LukeForEntityClassification[[transformers.LukeForEntityClassification]]

#### transformers.LukeForEntityClassification[[transformers.LukeForEntityClassification]]

```python
transformers.LukeForEntityClassification(config: LukeConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1162)

**Parametreler:**

config ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Open Entity gibi varlık sınıflandırma görevleri için, ilk varlık token'ının gizli durumu üzerine bir doğrusal katman eklenmiş sınıflandırma başlığına sahip LUKE modeli.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.LukeForEntityClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1175)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`) : Varlık sözlüğündeki varlık jetonlarının dizinleri. Dizinler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) bkz.

entity_attention_mask (`torch.Tensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Dolgu varlık token indekslerinde dikkat işleminin uygulanmamasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** varlık tokenları için 1, - **maske uygulanan** varlık tokenları için 0.

entity_token_type_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Varlık token girdilerinin ilk ve ikinci bölümlerini belirtmek için segment token indeksleri. İndeksler `[0, 1]` aralığından seçilir:  - 0, *A bölümü* varlık token'ına karşılık gelir, - 1, *B bölümü* varlık token'ına karşılık gelir.

entity_position_ids (`torch.LongTensor`, şekli `(batch_size, entity_length, max_mention_length)`, *isteğe bağlı*) : Girdi varlıklarının her birinin konum gömme içindeki konum indeksleri. `[0, config.max_position_embeddings - 1]` aralığında seçilir.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

labels (`torch.LongTensor`, şekli `(batch_size,)` veya `(batch_size, num_labels)`, *isteğe bağlı*) : Sınıflandırma kaybını hesaplamak için etiketler. Şekil `(batch_size,)` ise, tek etiketli sınıflandırma için çapraz entropi kaybı kullanılır. Bu durumda, etiketler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. Şekil `(batch_size, num_labels)` ise, çoklu etiketli sınıflandırma için ikili çapraz entropi kaybı kullanılır. Bu durumda, etiketler yalnızca `[0, 1]` içermelidir; burada 0 ve 1 sırasıyla yanlış ve doğruyu belirtir.

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `EntityClassificationOutput` veya `tuple(torch.Tensor)`

A `EntityClassificationOutput` veya bir `torch.Tensor` tuple'ı (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırmaya ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LukeForEntityClassification](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForEntityClassification) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Sınıflandırma kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, config.num_labels)`) -- Sınıflandırma puanları (SoftMax öncesi).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, entity_length, hidden_size)`. Modelin her katman çıktısındaki varlık gizli durumları ve başlangıç varlık gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnekler:

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

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> model = LukeForEntityClassification.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")

>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)]  # character-based entity span corresponding to "Beyoncé"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: person
```

## LukeForEntityPairClassification[[transformers.LukeForEntityPairClassification]]

#### transformers.LukeForEntityPairClassification[[transformers.LukeForEntityPairClassification]]

```python
transformers.LukeForEntityPairClassification(config: LukeConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1291)

**Parametreler:**

config ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

TACRED gibi varlık çifti sınıflandırma görevleri için, iki varlık token'ının gizli durumlarının üzerine yerleştirilen doğrusal bir katman olan sınıflandırma başlığına sahip LUKE modeli.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.LukeForEntityPairClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1304)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`) : Varlık sözlüğündeki varlık jetonlarının dizinleri. Dizinler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) bkz.

entity_attention_mask (`torch.Tensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Dolgu varlık token indekslerinde dikkat işleminin uygulanmamasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** varlık tokenları için 1, - **maske uygulanan** varlık tokenları için 0.

entity_token_type_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Varlık token girdilerinin ilk ve ikinci bölümlerini belirtmek için segment token indeksleri. İndeksler `[0, 1]` aralığından seçilir:  - 0, *A bölümü* varlık token'ına karşılık gelir, - 1, *B bölümü* varlık token'ına karşılık gelir.

entity_position_ids (`torch.LongTensor`, şekli `(batch_size, entity_length, max_mention_length)`, *isteğe bağlı*) : Girdi varlıklarının her birinin konum gömme içindeki konum indeksleri. `[0, config.max_position_embeddings - 1]` aralığında seçilir.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

labels (`torch.LongTensor`, şekli `(batch_size,)` veya `(batch_size, num_labels)`, *isteğe bağlı*) : Sınıflandırma kaybını hesaplamak için etiketler. Şekil `(batch_size,)` ise, tek etiketli sınıflandırma için çapraz entropi kaybı kullanılır. Bu durumda, etiketler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. Şekil `(batch_size, num_labels)` ise, çoklu etiketli sınıflandırma için ikili çapraz entropi kaybı kullanılır. Bu durumda, etiketler yalnızca `[0, 1]` içermelidir; burada 0 ve 1 sırasıyla yanlış ve doğruyu belirtir.

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `EntityPairClassificationOutput` veya `tuple(torch.Tensor)`

`EntityPairClassificationOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LukeForEntityPairClassification](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForEntityPairClassification) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Sınıflandırma kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, config.num_labels)`) -- Sınıflandırma puanları (SoftMax öncesi).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, entity_length, hidden_size)`. Modelin her katman çıktısındaki varlık gizli durumları ve başlangıç varlık gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnekler:

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

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred")

>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [
...     (0, 7),
...     (17, 28),
... ]  # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: per:cities_of_residence
```

## LukeForEntitySpanClassification[[transformers.LukeForEntitySpanClassification]]

#### transformers.LukeForEntitySpanClassification[[transformers.LukeForEntitySpanClassification]]

```python
transformers.LukeForEntitySpanClassification(config: LukeConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1425)

**Parametreler:**

config ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Adlandırılmış varlık tanıma gibi görevler için üstünde bir span sınıflandırma kafası (gizli durumlar çıktısının üzerine yerleştirilen doğrusal bir katman) bulunan LUKE modeli.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.LukeForEntitySpanClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.LongTensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, entity_start_positions: typing.Optional[torch.LongTensor] = None, entity_end_positions: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1438)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`) : Varlık sözlüğündeki varlık jetonlarının dizinleri. Dizinler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) bkz.

entity_attention_mask (`torch.Tensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Dolgu varlık token indekslerinde dikkat işleminin uygulanmamasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** varlık tokenları için 1, - **maske uygulanan** varlık tokenları için 0.

entity_token_type_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Varlık token girdilerinin ilk ve ikinci bölümlerini belirtmek için segment token indeksleri. İndeksler `[0, 1]` aralığından seçilir:  - 0, *A bölümü* varlık token'ına karşılık gelir, - 1, *B bölümü* varlık token'ına karşılık gelir.

entity_position_ids (`torch.LongTensor`, şekli `(batch_size, entity_length, max_mention_length)`, *isteğe bağlı*) : Girdi varlıklarının her birinin konum gömme içindeki konum indeksleri. `[0, config.max_position_embeddings - 1]` aralığında seçilir.

entity_start_positions (`torch.LongTensor`, *isteğe bağlı*) : Kelime token dizisindeki varlıkların başlangıç konumları.

entity_end_positions (`torch.LongTensor`, *isteğe bağlı*) : Kelime token dizisindeki varlıkların bitiş konumları.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

labels (`torch.LongTensor`, şekli `(batch_size, entity_length)` veya `(batch_size, entity_length, num_labels)`, *isteğe bağlı*) : Sınıflandırma kaybını hesaplamak için etiketler. Şekil `(batch_size, entity_length)` ise, tek etiketli sınıflandırma için çapraz entropi kaybı kullanılır. Bu durumda, etiketler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. Şekil `(batch_size, entity_length, num_labels)` ise, çoklu etiketli sınıflandırma için ikili çapraz entropi kaybı kullanılır. Bu durumda, etiketler yalnızca `[0, 1]` içermelidir; burada 0 ve 1 sırasıyla yanlış ve doğruyu belirtir.

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `EntitySpanClassificationOutput` veya `tuple(torch.Tensor)`

`EntitySpanClassificationOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LukeForEntitySpanClassification](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForEntitySpanClassification) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Sınıflandırma kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, entity_length, config.num_labels)`) -- Sınıflandırma puanları (SoftMax öncesi).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, entity_length, hidden_size)`. Modelin her katman çıktısındaki varlık gizli durumları ve başlangıç varlık gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnekler:

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

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> model = LukeForEntitySpanClassification.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")

>>> text = "Beyoncé lives in Los Angeles"
# List all possible entity spans in the text

>>> word_start_positions = [0, 8, 14, 17, 21]  # character-based start positions of word tokens
>>> word_end_positions = [7, 13, 16, 20, 28]  # character-based end positions of word tokens
>>> entity_spans = []
>>> for i, start_pos in enumerate(word_start_positions):
...     for end_pos in word_end_positions[i:]:
...         entity_spans.append((start_pos, end_pos))

>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_indices = logits.argmax(-1).squeeze().tolist()
>>> for span, predicted_class_idx in zip(entity_spans, predicted_class_indices):
...     if predicted_class_idx != 0:
...         print(text[span[0] : span[1]], model.config.id2label[predicted_class_idx])
Beyoncé PER
Los Angeles LOC
```

## LukeForSequenceClassification[[transformers.LukeForSequenceClassification]]

#### transformers.LukeForSequenceClassification[[transformers.LukeForSequenceClassification]]

```python
transformers.LukeForSequenceClassification(config: LukeConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1583)

**Parametreler:**

config ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üstünde bir dizi sınıflandırma/geri dönüş (regresyon) başlığı (toplanmış çıktının üzerinde doğrusal bir katman) bulunan LUKE Model transformer'ı, örneğin GLUE görevleri için.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.LukeForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1596)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`) : Varlık sözlüğündeki varlık jetonlarının dizinleri. Dizinler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) bkz.

entity_attention_mask (`torch.Tensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Dolgu varlık token indekslerinde dikkat işleminin uygulanmamasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** varlık tokenları için 1, - **maske uygulanan** varlık tokenları için 0.

entity_token_type_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Varlık token girdilerinin ilk ve ikinci bölümlerini belirtmek için segment token indeksleri. İndeksler `[0, 1]` aralığından seçilir:  - 0, *A bölümü* varlık token'ına karşılık gelir, - 1, *B bölümü* varlık token'ına karşılık gelir.

entity_position_ids (`torch.LongTensor`, şekli `(batch_size, entity_length, max_mention_length)`, *isteğe bağlı*) : Girdi varlıklarının her birinin konum gömme içindeki konum indeksleri. `[0, config.max_position_embeddings - 1]` aralığında seçilir.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

labels (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Sınıflandırma/geri dönüş kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. `config.num_labels == 1` ise bir geri dönüş kaybı (Ortalama Kare kaybı) hesaplanır, `config.num_labels > 1` ise bir sınıflandırma kaybı (Çapraz Entropi) hesaplanır.

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `LukeSequenceClassifierOutput` veya `tuple(torch.Tensor)`

`LukeSequenceClassifierOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LukeForSequenceClassification](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForSequenceClassification) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Sınıflandırma (config.num_labels==1 ise regresyon) kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, config.num_labels)`) -- Sınıflandırma (veya config.num_labels==1 ise regresyon) puanları (SoftMax öncesi).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, entity_length, hidden_size)`. Modelin her katman çıktısındaki varlık gizli durumları ve başlangıç varlık gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Tek etiketli sınıflandırma örneği:

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

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

Çok etiketli sınıflandırma örneği:

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

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LukeForSequenceClassification.from_pretrained(
...     "studio-ousia/luke-base", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## LukeForMultipleChoice[[transformers.LukeForMultipleChoice]]

#### transformers.LukeForMultipleChoice[[transformers.LukeForMultipleChoice]]

```python
transformers.LukeForMultipleChoice(config: LukeConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1926)

**Parametreler:**

config ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üstünde çoktan seçmeli sınıflandırma kafası (pooled çıktı üzerine bir lineer katman ve softmax) bulunan Luke Modeli, örneğin RocStories/SWAG görevleri için.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.LukeForMultipleChoice.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1939)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, num_choices, sequence_length)`) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, şekli `(batch_size, num_choices, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, num_choices, sequence_length)`, *isteğe bağlı*) : Girdi dizileri token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.max_position_embeddings - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`) : Varlık sözlüğündeki varlık jetonlarının dizinleri. Dizinler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) bkz.

entity_attention_mask (`torch.Tensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Dolgu varlık token indekslerinde dikkat işleminin uygulanmamasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** varlık tokenları için 1, - **maske uygulanan** varlık tokenları için 0.

entity_token_type_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Varlık token girdilerinin ilk ve ikinci bölümlerini belirtmek için segment token indeksleri. İndeksler `[0, 1]` aralığından seçilir:  - 0, *A bölümü* varlık token'ına karşılık gelir, - 1, *B bölümü* varlık token'ına karşılık gelir.

entity_position_ids (`torch.LongTensor`, şekli `(batch_size, entity_length, max_mention_length)`, *isteğe bağlı*) : Girdi varlıklarının her birinin konum gömme içindeki konum indeksleri. `[0, config.max_position_embeddings - 1]` aralığında seçilir.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, num_choices, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` dizinlerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

labels (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Çoklu seçim sınıflandırma kaybını hesaplamak için etiketler. İndisler, `num_choices`'ün giriş tensörlerinin ikinci boyutunun boyutu olduğu `[0, ..., num_choices-1]` aralığında olmalıdır. (Yukarıdaki `input_ids`'e bakın)

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `LukeMultipleChoiceModelOutput` veya `tuple(torch.Tensor)`

`LukeMultipleChoiceModelOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LukeForMultipleChoice](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForMultipleChoice) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli *(1,)*, *opsiyonel*, `labels` sağlandığında döndürülür) -- Sınıflandırma kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, num_choices)`) -- *num_choices*, girdi tensörlerinin ikinci boyutudur (bkz. yukarıdaki *input_ids*).

  Sınıflandırma puanları (SoftMax öncesi).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, entity_length, hidden_size)`. Modelin her katman çıktısındaki varlık gizli durumları ve başlangıç varlık gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnek:

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

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMultipleChoice.from_pretrained("studio-ousia/luke-base")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## LukeForTokenClassification[[transformers.LukeForTokenClassification]]

#### transformers.LukeForTokenClassification[[transformers.LukeForTokenClassification]]

```python
transformers.LukeForTokenClassification(config: LukeConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1705)

**Parametreler:**

config ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üstünde bir token sınıflandırma başlığı (gizli durumlar çıktısının üzerinde doğrusal bir katman) bulunan LUKE Modeli. LUKE ile Adlandırılmış Varlık Tanıma (NER) görevini çözmek için bu sınıftan ziyade `LukeForEntitySpanClassification` daha uygundur.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.LukeForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1719)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`) : Varlık sözlüğündeki varlık jetonlarının dizinleri. Dizinler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) bkz.

entity_attention_mask (`torch.Tensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Dolgu varlık token indekslerinde dikkat işleminin uygulanmamasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** varlık tokenları için 1, - **maske uygulanan** varlık tokenları için 0.

entity_token_type_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Varlık token girdilerinin ilk ve ikinci bölümlerini belirtmek için segment token indeksleri. İndeksler `[0, 1]` aralığından seçilir:  - 0, *A bölümü* varlık token'ına karşılık gelir, - 1, *B bölümü* varlık token'ına karşılık gelir.

entity_position_ids (`torch.LongTensor`, şekli `(batch_size, entity_length, max_mention_length)`, *isteğe bağlı*) : Girdi varlıklarının her birinin konum gömme içindeki konum indeksleri. `[0, config.max_position_embeddings - 1]` aralığında seçilir.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

labels (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Çoklu seçim sınıflandırma kaybını hesaplamak için etiketler. İndisler, `num_choices`'ün giriş tensörlerinin ikinci boyutunun boyutu olduğu `[0, ..., num_choices-1]` aralığında olmalıdır. (Yukarıdaki `input_ids`'e bakın)

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `LukeTokenClassifierOutput` veya `tuple(torch.Tensor)`

`LukeTokenClassifierOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LukeForTokenClassification](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForTokenClassification) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Sınıflandırma kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.num_labels)`) -- Sınıflandırma puanları (SoftMax öncesi).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, entity_length, hidden_size)`. Modelin her katman çıktısındaki varlık gizli durumları ve başlangıç varlık gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnek:

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

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForTokenClassification.from_pretrained("studio-ousia/luke-base")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

## LukeForQuestionAnswering[[transformers.LukeForQuestionAnswering]]

#### transformers.LukeForQuestionAnswering[[transformers.LukeForQuestionAnswering]]

```python
transformers.LukeForQuestionAnswering(config: LukeConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1808)

**Parametreler:**

config ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

SQuAD gibi çıkarımsal soru-cevap görevleri için üstünde bir aralık sınıflandırma kafası bulunan Luke transformer (gizli durum çıktısının üzerine, `span start logits` ve `span end logits` hesaplamak için eklenen doğrusal bir katman).

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.LukeForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.Tensor] = None, entity_ids: typing.Optional[torch.LongTensor] = None, entity_attention_mask: typing.Optional[torch.Tensor] = None, entity_token_type_ids: typing.Optional[torch.LongTensor] = None, entity_position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/luke/modeling_luke.py#L1820)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizileri token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

entity_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`) : Varlık sözlüğündeki varlık jetonlarının dizinleri. Dizinler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) bkz.

entity_attention_mask (`torch.Tensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Dolgu varlık token indekslerinde dikkat işleminin uygulanmamasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** varlık tokenları için 1, - **maske uygulanan** varlık tokenları için 0.

entity_token_type_ids (`torch.LongTensor`, şekli `(batch_size, entity_length)`, *isteğe bağlı*) : Varlık token girdilerinin ilk ve ikinci bölümlerini belirtmek için segment token indeksleri. İndeksler `[0, 1]` aralığından seçilir:  - 0, *A bölümü* varlık token'ına karşılık gelir, - 1, *B bölümü* varlık token'ına karşılık gelir.

entity_position_ids (`torch.LongTensor`, şekli `(batch_size, entity_length, max_mention_length)`, *isteğe bağlı*) : Girdi varlıklarının her birinin konum gömme içindeki konum indeksleri. `[0, config.max_position_embeddings - 1]` aralığında seçilir.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

start_positions (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Token sınıflandırma kaybını hesaplamak için etiketli aralığın başlangıç konumunun (indeksinin) etiketleri. Konumlar, dizinin uzunluğuna (`sequence_length`) sınırlanır. Dizi dışındaki konumlar, kaybın hesaplanmasında dikkate alınmaz.

end_positions (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Token sınıflandırma kaybını hesaplamak için etiketli aralığın sonundaki konumun (indeksin) etiketleri. Konumlar, dizinin uzunluğuna (`sequence_length`) göre sınırlandırılır. Dizi dışındaki konumlar, kaybın hesaplanmasında dikkate alınmaz.

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `LukeQuestionAnsweringModelOutput` veya `tuple(torch.Tensor)`

Bir `LukeQuestionAnsweringModelOutput` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırma ([LukeConfig](/docs/transformers/main/tr/model_doc/luke#transformers.LukeConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[LukeForQuestionAnswering](/docs/transformers/main/tr/model_doc/luke#transformers.LukeForQuestionAnswering) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Toplam span çıkarım kaybı, başlangıç ve bitiş konumları için Çapraz Entropinin (Cross-Entropy) toplamıdır.
- **start_logits** (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) -- Span başlangıç puanları (SoftMax öncesi).
- **end_logits** (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) -- Aralık sonu puanları (SoftMax öncesi).
- **hidden_states** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **entity_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, entity_length, hidden_size)`. Modelin her katman çıktısındaki varlık gizli durumları ve başlangıç varlık gömme çıktıları.
- **attentions** (`tuple[torch.Tensor, ...]`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnek:

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

>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForQuestionAnswering.from_pretrained("studio-ousia/luke-base")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```