# ELECTRA [ELECTRA](https://huggingface.co/papers/2003.10555), BERT gibi geleneksel maskeli dil modellerinin ön eğitim hedefini değiştirir. Sadece tokenleri maskeleyip modelden bunları tahmin etmesini istemek yerine, ELECTRA bir üretici ve bir ayırt edici olmak üzere iki model eğitir. Üretici, bazı tokenleri olası alternatiflerle değiştirir; ayırt edici (aslında kullanacağınız model) ise hangi tokenlerin orijinal, hangilerinin değiştirildiğini tespit etmeyi öğrenir. Bu eğitim yaklaşımı oldukça verimlidir ve çok daha az hesaplama gücü kullanarak daha büyük modellere ölçeklenebilir. Bu yaklaşım son derece verimlidir çünkü ELECTRA, yalnızca maskelenmiş olanlardan değil, girdideki her tek token'dan öğrenir. Bu nedenle, küçük ELECTRA modelleri çok daha büyük modellerle eşleşebilir veya onları geride bırakabilirken çok daha az hesaplama kaynağı kullanır. Tüm orijinal ELECTRA kontrol noktalarını [ELECTRA](https://huggingface.co/collections/google/electra-release-64ff6e8b18830fabea30a1ab) sürümünde bulabilirsiniz. > [!TIP] > Farklı dil görevleri (sıralı sınıflandırma, token sınıflandırma ve soru yanıtlama gibi) için ELECTRA'nın nasıl kullanılacağına dair daha fazla örnek için sağ kenar çubuğuna tıklayın. Aşağıdaki örnek, metni [Pipeline](/docs/transformers/main/tr/main_classes/pipelines#transformers.Pipeline) veya [AutoModel](/docs/transformers/main/tr/model_doc/auto#transformers.AutoModel) sınıfı ile nasıl sınıflandıracağınızı göstermektedir. ```python from transformers import pipeline classifier = pipeline( task="text-classification", model="bhadresh-savani/electra-base-emotion", device=0 ) classifier("This restaurant has amazing food!") ``` ```python import torch from transformers import AutoModelForSequenceClassification, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained( "bhadresh-savani/electra-base-emotion", ) model = AutoModelForSequenceClassification.from_pretrained( "bhadresh-savani/electra-base-emotion", device_map="auto", ) inputs = tokenizer("ELECTRA is more efficient than BERT", return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) logits = outputs.logits predicted_class_id = logits.argmax(dim=-1).item() predicted_label = model.config.id2label[predicted_class_id] print(f"Predicted label: {predicted_label}") ``` ## Notlar - ELECTRA, bir üreteç (G) ve bir ayırt edici (D) olmak üzere iki transformer modelinden oluşur. Çoğu aşağı akış görevi için, üreteç yerine ayırt edici modelini (isimdeki `*-discriminator` ifadesiyle belirtildiği gibi) kullanın. - ELECTRA üç boyutta gelir: küçük (14M parametre), temel (110M parametre) ve büyük (335M parametre). - ELECTRA, verimlilik için gizli boyuttan daha küçük bir gömme boyutu kullanabilir. Yapılandırmada `embedding_size`, `hidden_size`'den küçükse, bu ikisini birbirine bağlayan bir projeksiyon katmanı kullanılır. - Dolgu (padding) içeren toplu (batched) girdiler kullanırken, modelin dolgu token'larına dikkat etmesini (attend) önlemek için dikkat maskelerinin (attention masks) kullanıldığından emin olun. ```py # Example of properly handling padding with attention masks inputs = tokenizer(["Short text", "This is a much longer text that needs padding"], padding=True, return_tensors="pt") outputs = model(**inputs) # automatically uses the attention_mask ``` - Aşağı akışlı bir görevde ayırt ediciyi (discriminator) kullanırken, onu ELECTRA model sınıflarından herhangi birine ([ElectraForSequenceClassification](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraForSequenceClassification), [ElectraForTokenClassification](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraForTokenClassification) vb.) yükleyebilirsiniz. ## ElectraConfig[[transformers.ElectraConfig]] #### transformers.ElectraConfig[[transformers.ElectraConfig]] ```python transformers.ElectraConfig(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 = 30522, embedding_size: int = 128, hidden_size: int = 256, num_hidden_layers: int = 12, num_attention_heads: int = 4, intermediate_size: int = 1024, 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, summary_type: str = 'first', summary_use_proj: bool = True, summary_activation: str = 'gelu', summary_last_dropout: float | int = 0.1, pad_token_id: int | None = 0, use_cache: bool = True, classifier_dropout: float | int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, tie_word_embeddings: bool = True) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/configuration_electra.py#L25) **Parametreler:** vocab_size (`int`, *isteğe bağlı*, varsayılan `30522`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar. embedding_size (`int`, *isteğe bağlı*, varsayılan `128`) : Gömme ve gizli durumların boyutluluğu. hidden_size (`int`, *isteğe bağlı*, varsayılan `256`) : Gizli temsillerin 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 `4`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı. intermediate_size (`int`, *isteğe bağlı*, varsayılan `1024`) : 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. summary_type (`str`, *isteğe bağlı*, varsayılan `"first"`) : Dizi özetleme yapılırken kullanılan argüman. Dizi sınıflandırma ve çoklu seçim modellerinde kullanılır. Aşağıdaki seçeneklerden biri olmalıdır: - `"last"`: Son token gizli durumunu alır (XLNet gibi). - `"first"`: İlk token gizli durumunu alır (BERT gibi). - `"mean"`: Tüm token gizli durumlarının ortalamasını alır. - `"cls_index"`: Sınıflandırma token konumu için bir Tensor sağlar (GPT/GPT-2 gibi). - `"attn"`: Şu an uygulanmadı, çok başlı dikkat kullanılır. summary_use_proj (`bool`, *isteğe bağlı*, varsayılan `True`) : Sıra özetleme yapılırken kullanılan argüman. Sıra sınıflandırma ve çoklu seçim modellerinde kullanılır. Vektör çıkarımından sonra bir projeksiyon eklenip eklenmeyeceğini belirtir. summary_activation (`str`, *isteğe bağlı*) : Sıra özetleme yapılırken kullanılan argüman. Sıra sınıflandırma ve çoklu seçim modellerinde kullanılır. Çıktıya gelu aktivasyonu uygulamak için `"gelu"` geçirin; başka herhangi bir değer aktivasyon uygulanmamasına neden olur. summary_last_dropout (`float`, *opsiyonel*, varsayılan 0.0) : Sıra özetleme yapılırken kullanılan argüman. Sıra sınıflandırma ve çoklu seçim modellerinde kullanılır. Projeksiyon ve aktivasyon sonrasında kullanılacak dropout oranı. pad_token_id (`int`, *isteğe bağlı*, varsayılan `0`) : Sözlükte dolgu için kullanılan token kimliği. use_cache (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin son anahtar/değer dikkatlerini döndürüp döndürmeyeceğini belirtir (tüm modellerde kullanılmaz). Yalnızca `config.is_decoder=True` olduğunda veya model yalnızca çözücü tabanlı üretken bir model olduğunda geçerlidir. classifier_dropout (`Union[float, int]`, *isteğe bağlı*) : Sınıflandırıcı için dropout oranı. is_decoder (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelin bir çözücü olarak kullanılıp kullanılmadığı. `False` ise model, bir kodlayıcı olarak kullanılır. add_cross_attention (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelde çapraz dikkat katmanlarının eklenip eklenmeyeceğini belirtir. bos_token_id (`int`, *isteğe bağlı*) : 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ı*) : 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 ElectraModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Electra modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [google/electra-small-discriminator](https://huggingface.co/google/electra-small-discriminator) ile benzer bir yapılandırma elde edilir. 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 ElectraConfig, ElectraModel >>> # Initializing a ELECTRA electra-base-uncased style configuration >>> configuration = ElectraConfig() >>> # Initializing a model (with random weights) from the electra-base-uncased style configuration >>> model = ElectraModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## ElectraTokenizer[[transformers.BertTokenizer]] #### transformers.BertTokenizer[[transformers.BertTokenizer]] ```python transformers.BertTokenizer(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bert/tokenization_bert.py#L41) **Parametreler:** 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. do_lower_case (`bool`, *isteğe bağlı*, varsayılan `True`) : Tokenize sırasında girdinin küçük harfe dönüştürülüp dönüştürülmemesi. unk_token (`str`, *isteğe bağlı*, varsayılan `"[UNK]"`) : Bilinmeyen jeton. Sözlükte yer almayan bir jeton, bir kimliğe dönüştürülemez ve bunun yerine bu jeton olarak ayarlanır. sep_token (`str`, *isteğe bağlı*, varsayılan `"[SEP]"`) : 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. Özel belirteçlerle oluşturulan bir dizinin son belirteci olarak da kullanılı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. cls_token (`str`, *isteğe bağlı*, varsayılan `"[CLS]"`) : 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ı tokenı. Özel tokenlarla oluşturulduğunda sıranın ilk tokenıdır. 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. tokenize_chinese_chars (`bool`, *isteğe bağlı*, varsayılan `True`) : Çin karakterlerinin tokenize edilip edilmeyeceği. strip_accents (`bool`, *isteğe bağlı*) : Tüm aksanların kaldırılıp kaldırılmayacağını belirtir. Bu seçenek belirtilmezse, `lowercase` değeri tarafından (orijinal BERT'te olduğu gibi) belirlenir. Bir BERT tokenizer'ı oluşturun (HuggingFace'in tokenizers kütüphanesi tarafından desteklenir). WordPiece tabanlıdır. Bu tokenizer, ana yöntemlerin çoğunu içeren [TokenizersBackend](/docs/transformers/main/tr/main_classes/tokenizer#transformers.TokenizersBackend) 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. ## Electra'ya özgü çıktılar[[transformers.models.electra.modeling_electra.ElectraForPreTrainingOutput]] #### transformers.models.electra.modeling_electra.ElectraForPreTrainingOutput[[transformers.models.electra.modeling_electra.ElectraForPreTrainingOutput]] ```python transformers.models.electra.modeling_electra.ElectraForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L530) **Parametreler:** loss (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) : Total loss of the ELECTRA objective. logits (`torch.Tensor`, şekli `(batch_size, sequence_length)`) : Başlığın tahmin puanları (SoftMax öncesi her token 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` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Modelin her katmanının çıktısındaki 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 başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır. [ElectraForPreTraining](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraForPreTraining) sınıfının çıktı türü. ## ElectraModel[[transformers.ElectraModel]] #### transformers.ElectraModel[[transformers.ElectraModel]] ```python transformers.ElectraModel(config: ElectraConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L545) **Parametreler:** config ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) : 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. Üzerinde herhangi bir özel başlık olmadan ham gizli durumları (hidden-states) üreten çıplak Electra 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.ElectraModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: list[torch.Tensor] | None = None, use_cache: bool | None = None, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L565) **Parametreler:** input_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi token'larının indeksleri. Dolgu (padding) varsayılan olarak yok sayı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 ID'leri nelerdir?](../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.Tensor`, ş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) 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. encoder_hidden_states (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : Kodlayıcının son katmanının çıktısındaki gizli durumlar dizisi. Model bir çözücü olarak yapılandırılmışsa çapraz dikkat (cross-attention) için kullanılır. encoder_attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Kodlayıcı girdisindeki dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. Model bir çözücü (decoder) olarak yapılandırılmışsa bu maske, çapraz dikkat (cross-attention) için kullanılır. `[0, 1]` aralığında seçilen maske değerleri: - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0. past_key_values (`list[torch.Tensor]`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez. use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`). **Dönüş:** [BaseModelOutputWithCrossAttentions](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithCrossAttentions) veya `tuple(torch.Tensor)` [BaseModelOutputWithCrossAttentions](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithCrossAttentions) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [ElectraModel](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraModel) 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. - **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. - **cross_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` ve `config.add_cross_attention=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. Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır. ## ElectraForPreTraining[[transformers.ElectraForPreTraining]] #### transformers.ElectraForPreTraining[[transformers.ElectraForPreTraining]] ```python transformers.ElectraForPreTraining(config: ElectraConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L867) **Parametreler:** config ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) : 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. Ön eğitim sırasında üretilen tokenleri belirlemek için üstünde kullanılan ikili sınıflandırma başlığına sahip Electra modeli. O modele ayırt edici (discriminator) kontrol noktasının yüklenmesi önerilir. 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.ElectraForPreTraining.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L876) **Parametreler:** input_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi token'larının indeksleri. Dolgu (padding) varsayılan olarak yok sayı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 ID'leri nelerdir?](../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.Tensor`, ş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) 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, sequence_length)`, *isteğe bağlı*) : ELECTRA kaybını hesaplamak için etiketler. Girdi, bir token dizisi olmalıdır (bkz. `input_ids` docstring). İndisler `[0, 1]` aralığında olmalıdır: - 0, token'ın orijinal bir token olduğunu belirtir, - 1, token'ın değiştirildiğini belirtir. **Dönüş:** [ElectraForPreTrainingOutput](/docs/transformers/main/tr/model_doc/electra#transformers.models.electra.modeling_electra.ElectraForPreTrainingOutput) veya `tuple(torch.Tensor)` [ElectraForPreTrainingOutput](/docs/transformers/main/tr/model_doc/electra#transformers.models.electra.modeling_electra.ElectraForPreTrainingOutput) veya `torch.Tensor` bir demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırmaya ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [ElectraForPreTraining](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraForPreTraining) 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** (`*optional*`, `labels` sağlandığında döndürülür, `torch.Tensor`, şekli `(1,)`) -- ELECTRA hedefinin toplam kaybı. - **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length)`) -- Başlığın tahmin puanları (SoftMax öncesi her token 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ı. - **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 ElectraForPreTraining, AutoTokenizer >>> import torch >>> discriminator = ElectraForPreTraining.from_pretrained("google/electra-base-discriminator") >>> tokenizer = AutoTokenizer.from_pretrained("google/electra-base-discriminator") >>> sentence = "The quick brown fox jumps over the lazy dog" >>> fake_sentence = "The quick brown fox fake over the lazy dog" >>> fake_tokens = tokenizer.tokenize(fake_sentence, add_special_tokens=True) >>> fake_inputs = tokenizer.encode(fake_sentence, return_tensors="pt") >>> discriminator_outputs = discriminator(fake_inputs) >>> predictions = torch.round((torch.sign(discriminator_outputs[0]) + 1) / 2) >>> fake_tokens ['[CLS]', 'the', 'quick', 'brown', 'fox', 'fake', 'over', 'the', 'lazy', 'dog', '[SEP]'] >>> predictions.squeeze().tolist() [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0] ``` ## ElectraForCausalLM[[transformers.ElectraForCausalLM]] #### transformers.ElectraForCausalLM[[transformers.ElectraForCausalLM]] ```python transformers.ElectraForCausalLM(config: ElectraConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L1245) **Parametreler:** config ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) : 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. CLM ince ayarı için üstünde `language modeling` başlığı bulunan ELECTRA 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.ElectraForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L1266) **Parametreler:** input_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi token'larının indeksleri. Dolgu (padding) varsayılan olarak yok sayı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 ID'leri nelerdir?](../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.Tensor`, ş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) 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. encoder_hidden_states (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : Kodlayıcının son katmanının çıktısındaki gizli durumlar dizisi. Model bir çözücü olarak yapılandırılmışsa çapraz dikkat (cross-attention) için kullanılır. encoder_attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Kodlayıcı girdisindeki dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. Model bir çözücü (decoder) olarak yapılandırılmışsa bu maske, çapraz dikkat (cross-attention) için kullanılır. `[0, 1]` aralığında seçilen maske değerleri: - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0. labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Soldan sağa dil modelleme kaybını (sonraki kelime tahmini) hesaplamak için etiketler. Endeksler `[-100, 0, ..., config.vocab_size]` aralığında olmalıdır (bkz. `input_ids` docstring). Endeksleri `-100` olarak ayarlanan jetonlar yok sayılır (maskelenir), kayıp yalnızca etiketleri `[0, ..., config.vocab_size]` aralığında olan jetonlar için hesaplanır. past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez. use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *isteğe bağlı*, varsayılan `0`) : `int` ise, son `logits_to_keep` token için logits hesaplanır. `0` ise, tüm `input_ids` için logits hesaplanır (özel durum). Üretim için yalnızca son token'ın logits'ine ihtiyaç duyulur ve bunların yalnızca o token için hesaplanması bellek tasarrufu sağlar; bu, uzun diziler veya büyük sözlük boyutu için oldukça önemli hale gelir. `torch.Tensor` ise, dizi uzunluğu boyutunda tutulacak indekslere karşılık gelen 1B olmalıdır. Bu, paketlenmiş tensor biçimini (batch ve dizi uzunluğu için tek boyut) kullanırken faydalıdır. **Dönüş:** [CausalLMOutputWithCrossAttentions](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) veya `tuple(torch.Tensor)` [CausalLMOutputWithCrossAttentions](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) veya `torch.Tensor` bir demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [ElectraForCausalLM](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraForCausalLM) 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) -- Dil modelleme kaybı (sonraki token tahmini için). - **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). - **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. - **cross_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ı çapraz dikkat ağırlıkları, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır. - **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın. Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (dikkat bloklarındaki anahtar ve değerler) içerir. Örnek: ```python >>> from transformers import AutoTokenizer, ElectraForCausalLM, ElectraConfig >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("google/electra-base-generator") >>> config = ElectraConfig.from_pretrained("google/electra-base-generator") >>> config.is_decoder = True >>> model = ElectraForCausalLM.from_pretrained("google/electra-base-generator", config=config) >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs) >>> prediction_logits = outputs.logits ``` ## ElectraForMaskedLM[[transformers.ElectraForMaskedLM]] #### transformers.ElectraForMaskedLM[[transformers.ElectraForMaskedLM]] ```python transformers.ElectraForMaskedLM(config: ElectraConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L959) **Parametreler:** config ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) : 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. Üzerinde bir dil modelleme başlığı bulunan Electra modeli. Her ne kadar hem ayırt edici hem de üretici bu modele yüklenebilse de, maskeli dil modelleme görevi için eğitilen tek model üreticidir. 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.ElectraForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L978) **Parametreler:** input_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi token'larının indeksleri. Dolgu (padding) varsayılan olarak yok sayı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 ID'leri nelerdir?](../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.Tensor`, ş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) 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, 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. **Dönüş:** [MaskedLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) veya `tuple(torch.Tensor)` [MaskedLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [ElectraForMaskedLM](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraForMaskedLM) 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) -- Maskeli dil modelleme (MLM) 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). - **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. Örnek: ```python >>> from transformers import AutoTokenizer, ElectraForMaskedLM >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator") >>> model = ElectraForMaskedLM.from_pretrained("google/electra-small-discriminator") >>> inputs = tokenizer("The capital of France is .", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> # retrieve index of >>> 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- tokens >>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100) >>> outputs = model(**inputs, labels=labels) >>> round(outputs.loss.item(), 2) ... ``` ## ElectraForSequenceClassification[[transformers.ElectraForSequenceClassification]] #### transformers.ElectraForSequenceClassification[[transformers.ElectraForSequenceClassification]] ```python transformers.ElectraForSequenceClassification(config: ElectraConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L793) **Parametreler:** config ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) : 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. Üzerinde bir dizi sınıflandırma/geri dönüşüm başlığı (toplanmış çıktının üzerinde doğrusal bir katman) bulunan ELECTRA 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.ElectraForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L804) **Parametreler:** input_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi token'larının indeksleri. Dolgu (padding) varsayılan olarak yok sayı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 ID'leri nelerdir?](../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.Tensor`, ş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) 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. **Dönüş:** [SequenceClassifierOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) veya `tuple(torch.Tensor)` [SequenceClassifierOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [ElectraForSequenceClassification](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraForSequenceClassification) 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` (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. Tek etiketli sınıflandırma örneği: ```python >>> import torch >>> from transformers import AutoTokenizer, ElectraForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator") >>> model = ElectraForSequenceClassification.from_pretrained("google/electra-small-discriminator") >>> 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 = ElectraForSequenceClassification.from_pretrained("google/electra-small-discriminator", 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, ElectraForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator") >>> model = ElectraForSequenceClassification.from_pretrained("google/electra-small-discriminator", 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 = ElectraForSequenceClassification.from_pretrained( ... "google/electra-small-discriminator", 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 ``` ## ElectraForMultipleChoice[[transformers.ElectraForMultipleChoice]] #### transformers.ElectraForMultipleChoice[[transformers.ElectraForMultipleChoice]] ```python transformers.ElectraForMultipleChoice(config: ElectraConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L1150) **Parametreler:** config ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) : 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 çoklu seçim sınıflandırma kafası (pooled çıktı üzerinde doğrusal bir katman ve softmax) bulunan Electra 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.ElectraForMultipleChoice.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L1161) **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) 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) **Dönüş:** [MultipleChoiceModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) veya `tuple(torch.Tensor)` [MultipleChoiceModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda); yapılandırma ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [ElectraForMultipleChoice](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraForMultipleChoice) 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` (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. Örnek: ```python >>> from transformers import AutoTokenizer, ElectraForMultipleChoice >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator") >>> model = ElectraForMultipleChoice.from_pretrained("google/electra-small-discriminator") >>> 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 ``` ## ElectraForTokenClassification[[transformers.ElectraForTokenClassification]] #### transformers.ElectraForTokenClassification[[transformers.ElectraForTokenClassification]] ```python transformers.ElectraForTokenClassification(config: ElectraConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L1025) **Parametreler:** config ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) : 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. Üzerinde bir token sınıflandırma başlığı bulunan Electra modeli. Hem ayırt edici hem de üretici bu modele yüklenebilir. 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.ElectraForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L1039) **Parametreler:** input_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi token'larının indeksleri. Dolgu (padding) varsayılan olarak yok sayı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 ID'leri nelerdir?](../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.Tensor`, ş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) 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, sequence_length)`, *isteğe bağlı*) : Token sınıflandırma kaybını hesaplamak için etiketler. İndisler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. **Dönüş:** [TokenClassifierOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) veya `tuple(torch.Tensor)` [TokenClassifierOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [ElectraForTokenClassification](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraForTokenClassification) 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` (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. Örnek: ```python >>> from transformers import AutoTokenizer, ElectraForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator") >>> model = ElectraForTokenClassification.from_pretrained("google/electra-small-discriminator") >>> 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) ... ``` ## ElectraForQuestionAnswering[[transformers.ElectraForQuestionAnswering]] #### transformers.ElectraForQuestionAnswering[[transformers.ElectraForQuestionAnswering]] ```python transformers.ElectraForQuestionAnswering(config: ElectraConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L1079) **Parametreler:** config ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) : 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 Electra dönüştürücüsü (gizli durum çıktısının üstünde, `span start logits` ve `span end logits` hesaplamak için bir doğrusal 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.ElectraForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/electra/modeling_electra.py#L1093) **Parametreler:** input_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi token'larının indeksleri. Dolgu (padding) varsayılan olarak yok sayı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 ID'leri nelerdir?](../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.Tensor`, ş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) 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.Tensor`, ş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.Tensor`, ş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. **Dönüş:** [QuestionAnsweringModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) veya `tuple(torch.Tensor)` [QuestionAnsweringModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([ElectraConfig](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [ElectraForQuestionAnswering](/docs/transformers/main/tr/model_doc/electra#transformers.ElectraForQuestionAnswering) 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)`) -- Span başlangıç puanları (SoftMax öncesi). - **end_logits** (`torch.Tensor`, şekli `(batch_size, sequence_length)`) -- Span 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` (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. Örnek: ```python >>> from transformers import AutoTokenizer, ElectraForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("google/electra-small-discriminator") >>> model = ElectraForQuestionAnswering.from_pretrained("google/electra-small-discriminator") >>> 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) ... ```