# FlauBERT ## Genel Bakış FlauBERT modeli, Hang Le ve diğerleri tarafından [FlauBERT: Unsupervised Language Model Pre-training for French](https://huggingface.co/papers/1912.05372) adlı makalede önerilmiştir. BERT gibi, maskeli dil modelleme (MLM) hedefi kullanılarak ön eğitilmiş bir transformer modelidir. Makalenin özeti aşağıdaki gibidir: *Dil modelleri, birçok farklı Doğal Dil İşleme (NLP) görevinde son derece başarılı sonuçlara ulaşmanın anahtarı haline gelmiştir. Günümüzde mevcut olan devasa miktardaki etiketsiz metinlerden yararlanarak, cümle düzeyindeki bağlamsallaştırmalarıyla birlikte bir sonraki aşama görevi için ince ayar yapılabilecek sürekli kelime temsillerini ön eğitmek için verimli bir yol sunarlar. Bu durum, bağlamsal temsiller kullanılarak İngilizce için geniş çapta kanıtlanmıştır (Dai and Le, 2015; Peters et al., 2018; Howard and Ruder, 2018; Radford et al., 2018; Devlin et al., 2019; Yang et al., 2019b). Bu makalede, çok büyük ve heterojen bir Fransızca korpusu üzerinde öğrenilen FlauBERT modelini tanıtıyor ve paylaşıyoruz. Farklı boyutlardaki modeller, yeni CNRS (Fransız Ulusal Bilimsel Araştırma Merkezi) Jean Zay süper bilgisayarı kullanılarak eğitilmektedir. Fransızca dil modellerimizi çeşitli NLP görevlerine (metin sınıflandırma, yeniden ifade etme, doğal dil çıkarımı, ayrıştırma, kelime anlamı belirsizliğini giderme) uyguluyor ve çoğu durumda diğer ön eğitim yaklaşımlarından daha iyi performans gösterdiklerini gösteriyoruz. FlauBERT'in farklı sürümleri ve bir sonraki aşama görevleri için FLUE (French Language Understanding Evaluation) olarak adlandırılan birleşik bir değerlendirme protokolü, Fransızca NLP'de daha fazla tekrarlanabilir deney için araştırma topluluğuyla paylaşılıyor.* Bu model [formiel](https://huggingface.co/formiel) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/getalp/Flaubert) bulunabilir. İpuçları: - RoBERTa gibi, ancak cümle sıralama tahmini olmadan (yani yalnızca MLM hedefi üzerinde eğitilmiş). ## Kaynaklar - [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) ## FlaubertConfig[[transformers.FlaubertConfig]] #### transformers.FlaubertConfig[[transformers.FlaubertConfig]] ```python transformers.FlaubertConfig(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, pre_norm: bool = False, layerdrop: float | int = 0.0, vocab_size: int = 30145, emb_dim: int = 2048, n_layers: int = 12, n_heads: int = 16, dropout: float | int = 0.1, attention_dropout: float | int = 0.1, gelu_activation: bool = True, sinusoidal_embeddings: bool = False, causal: bool = False, asm: bool = False, n_langs: int = 1, use_lang_emb: bool = True, max_position_embeddings: int = 512, embed_init_std: float = 0.02209708691207961, layer_norm_eps: float = 1e-12, init_std: float = 0.02, bos_index: int = 0, eos_index: int = 1, pad_index: int = 2, unk_index: int = 3, mask_index: int = 5, is_encoder: bool = True, summary_type: str = 'first', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, start_n_top: int = 5, end_n_top: int = 5, mask_token_id: int = 0, lang_id: int = 0, pad_token_id: int | None = 2, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, tie_word_embeddings: bool = True) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/configuration_flaubert.py#L24) **Parametreler:** pre_norm (`bool`, *isteğe bağlı*, varsayılan `False`) : Her katmandaki dikkat sonrası ileri besleme katmanından önce mi yoksa sonra mı katman normalizasyonu uygulanacağı (Vaswani et al., Tensor2Tensor for Neural Machine Translation. 2018) layerdrop (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : LayerDrop olasılığı. Daha fazla ayrıntı için [LayerDrop makalesine](see https://huggingface.co/papers/1909.11556) bakın. vocab_size (`int`, *isteğe bağlı*, varsayılan `30145`) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar. emb_dim (`int`, *isteğe bağlı*, varsayılan 2048) : Gömme katmanının boyutluluğu. n_layers (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer decoder'ındaki gizli katman sayısı. n_heads (`int`, *isteğe bağlı*, varsayılan `16`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı. dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Tüm dropout katmanları için oran. attention_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Dikkat olasılıkları için dropout oranı. gelu_activation (`bool`, *isteğe bağlı*, varsayılan True) : GeLU aktivasyon fonksiyonunun kullanılıp kullanılmayacağı. sinusoidal_embeddings (`bool`, *isteğe bağlı*, varsayılan `False`) : Mutlak konumsal gömme yerine sinüzoidal konumsal gömme kullanılıp kullanılmayacağı. causal (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelin nedensel (causal) bir şekilde davranıp davranmayacağı. Nedensel modeller, çift yönlü bir bağlam yerine yalnızca sol taraftaki bağlama odaklanmak için üçgen bir dikkat maskesi kullanır. asm (`bool`, *isteğe bağlı*, varsayılan `False`) : Tahmin katmanı için doğrusal bir katman yerine adaptif log softmax projeksiyon katmanı kullanılıp kullanılmayacağı. n_langs (`int`, *isteğe bağlı*, varsayılan 1) : Modelin işlediği dil sayısı. Tek dilli modeller için 1 olarak ayarlayın. use_lang_emb (`bool`, *isteğe bağlı*, varsayılan `True`) : Dil gömme (embedding) kullanılıp kullanılmayacağı. Bazı modeller ek dil gömmeleri kullanır; bunların nasıl kullanılacağına dair bilgi için [çok dilli modeller sayfasına](http://huggingface.co/transformers/multilingual.html#xlm-language-embeddings) bakın. embed_init_std (`float`, *opsiyonel*, varsayılan 2048^-0.5) : Gömme matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması. max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `512`) : Bu modelin kullanılabileceği maksimum dizi uzunluğu. embed_init_std (`float`, *isteğe bağlı*, varsayılan `2048**-0.5`) : Gömme katmanları için başlatıcı std. layer_norm_eps (`float`, *opsiyonel*, varsayılan `1e-12`) : Katman normalizasyonu katmanları tarafından kullanılan epsilon. init_std (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması. bos_index (`int`, *isteğe bağlı*, varsayılan 0) : Sözlükte cümle başlangıcı belirtecinin (token) indeksi. eos_index (`int`, *isteğe bağlı*, varsayılan 1) : Sözlükte cümle sonu token'ının indeksi. pad_index (`int`, *isteğe bağlı*, varsayılan 2) : Sözlükte dolgu belirtecinin (padding token) indeksi. unk_index (`int`, *isteğe bağlı*, varsayılan 3) : Sözlükteki bilinmeyen token'in indeksi. mask_index (`int`, *isteğe bağlı*, varsayılan 5) : Sözlükte maskeleme jetonunun indeksi. is_encoder (`bool`, *isteğe bağlı*, varsayılan True) : Modelin bir kodlayıcı olarak kullanılıp kullanılmadığı. summary_type (`string`, *opsiyonel*, 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 tanh aktivasyonu uygulamak için `"tanh"` geçirin; başka herhangi bir değer aktivasyon uygulanmamasına neden olur. summary_proj_to_labels (`bool`, *isteğe bağlı*, varsayılan `True`) : Sıralama sınıflandırma ve çoklu seçim modellerinde kullanılır. Projeksiyon çıktıları `config.num_labels` veya `config.hidden_size` sınıf içermelidir. summary_first_dropout (`float`, *opsiyonel*, varsayılan 0.1) : Sıralama sınıflandırma ve çoklu seçim modellerinde kullanılır. Projeksiyon ve aktivasyon sonrasında kullanılacak dropout oranı. start_n_top (`int`, *isteğe bağlı*, varsayılan 5) : SQuAD değerlendirme betiğinde kullanılır. end_n_top (`int`, *isteğe bağlı*, varsayılan 5) : SQuAD değerlendirme betiğinde kullanılır. mask_token_id (`int`, *isteğe bağlı*, varsayılan 0) : MLM bağlamında metin üretirken maskelenmiş token'ları belirlemek için model agnostik parametre. lang_id (`int`, *isteğe bağlı*, varsayılan 1) : Modelin kullandığı dilin kimliği. Bu parametre, belirli bir dilde metin üretirken kullanılır. pad_token_id (`int`, *isteğe bağlı*, varsayılan `2`) : 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 `1`) : 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 FlaubertModel'in yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Flaubert modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [flaubert/flaubert_base_uncased](https://huggingface.co/flaubert/flaubert_base_uncased) 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. ## FlaubertTokenizer[[transformers.FlaubertTokenizer]] #### transformers.FlaubertTokenizer[[transformers.FlaubertTokenizer]] ```python transformers.FlaubertTokenizer(vocab_file, merges_file, do_lowercase = False, unk_token = '', bos_token = '', sep_token = '', pad_token = '', cls_token = '', mask_token = '', additional_special_tokens = ['', '', '', '', '', '', '', '', '', ''], lang2id = None, id2lang = None, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/tokenization_flaubert.py#L121) **Parametreler:** vocab_file (`str`) : Sözlük dosyası. merges_file (`str`) : Dosyayı birleştirir. do_lowercase (`bool`, *isteğe bağlı*, varsayılan `False`) : Küçük harfe çevirmeyi kontrol eder. unk_token (`str`, *isteğe bağlı*, varsayılan `""`) : 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. bos_token (`str`, *isteğe bağlı*, varsayılan `""`) : Ö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. sep_token (`str`, *isteğe bağlı*, varsayılan `""`) : 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. pad_token (`str`, *isteğe bağlı*, varsayılan `""`) : 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 `""`) : 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 token'larla oluşturulduğunda sıranın ilk token'ıdır. mask_token (`str`, *isteğe bağlı*, varsayılan `""`) : 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. additional_special_tokens (`List[str]`, *isteğe bağlı*, varsayılan `['', '', '', '', '', '', '', '', '', '']`) : Ek özel jetonların listesi. lang2id (`Dict[str, int]`, *isteğe bağlı*) : Dil dizgi tanımlayıcılarını kimliklerine eşleyen sözlük. id2lang (`Dict[int, str]`, *isteğe bağlı*) : Dil kimliklerini, dizge tanımlayıcılarına eşleyen sözlük. Flaubert tokenizer'ı oluşturun. Bayt-Çift Kodlamaya (Byte-Pair Encoding) dayanır. Tokenizasyon süreci şu şekildedir: - Moses ön işleme ve tokenizasyonu. - Tüm girdi metinlerini normalize etme. - `special_tokens` argümanı ve `set_special_tokens` fonksiyonu, bir sözlüğe ek semboller (örneğin "__classify__") eklemek için kullanılabilir. - `do_lowercase` argümanı, küçük harfe çevirmeyi kontrol eder (önceden eğitilmiş sözlükler için otomatik olarak ayarlanır). 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. #### build_inputs_with_special_tokens[[transformers.FlaubertTokenizer.build_inputs_with_special_tokens]] ```python build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: list[int] | None = None) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/tokenization_flaubert.py#L430) **Parametreler:** token_ids_0 (`List[int]`) : Özel jetonların ekleneceği kimliklerin listesi. token_ids_1 (`List[int]`, *isteğe bağlı*) : Sıralı çiftler için isteğe bağlı ikinci kimlik listesi. **Dönüş:** `List[int]` Uygun özel jetonlarla [girdi kimlikleri](../glossary#input-ids) listesi. Sınıflandırma görevleri için bir diziden veya diziler çiftinden model girdilerini birleştirerek ve özel jetonlar ekleyerek oluşturun. XLM dizisi aşağıdaki biçime sahiptir: - tek dizi: ` X ` - dizi çifti: ` A B ` #### convert_tokens_to_string[[transformers.FlaubertTokenizer.convert_tokens_to_string]] ```python convert_tokens_to_string(tokens) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/tokenization_flaubert.py#L424) Bir dizi belirteci (dizgi) tek bir dizgide birleştirir. #### get_special_tokens_mask[[transformers.FlaubertTokenizer.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list, token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/tokenization_flaubert.py#L458) **Parametreler:** token_ids_0 (`List[int]`) : Kimlik listesi. token_ids_1 (`List[int]`, *isteğe bağlı*) : Sıralı çiftler için isteğe bağlı ikinci kimlik listesi. already_has_special_tokens (`bool`, *isteğe bağlı*, varsayılan `False`) : Token listesinin, model için özel token'larla zaten biçimlendirilmiş olup olmadığı. **Dönüş:** `List[int]` [0, 1] aralığında tamsayıların bir listesi: özel bir jeton için 1, bir dizi jetonu için 0. Özel token eklenmemiş bir token listesinden dizi kimliklerini alır. Bu yöntem, tokenizer'ın `prepare_for_model` yöntemi kullanılarak özel token eklenirken çağrılır. ## FlaubertModel[[transformers.FlaubertModel]] #### transformers.FlaubertModel[[transformers.FlaubertModel]] ```python transformers.FlaubertModel(config: FlaubertConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L690) **Parametreler:** config ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) : 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 bakın. Üzerinde herhangi bir özel başlık olmadan ham gizli durumları (hidden-states) üreten çıplak Flaubert 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.FlaubertModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, lengths: typing.Optional[torch.LongTensor] = None, cache: dict[str, torch.Tensor] | None = 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/flaubert/modeling_flaubert.py#L763) **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) langs (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdideki her token'ın dilini belirtmek için kullanılacak paralel token dizisi. İndeksler, model yapılandırmasında sağlanan iki dönüşüm eşlemesi kullanılarak dil adlarından elde edilebilen dil kimlikleridir (yalnızca çok dilli modeller için sağlanır). Daha spesifik olarak, *dil adından dil kimliğine* eşleme `model.config.lang2id` içindedir (string'ten int'e bir sözlük) ve *dil kimliğinden dil adına* eşleme `model.config.id2lang` içindedir (int'ten string'e bir sözlük). Kullanım örnekleri, [çok dilli belgelendirme](../multilingual) içinde ayrıntılı olarak açıklanmıştır. 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) lengths (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Dolgu token indekslerinde dikkat işleminin uygulanmasını önlemek için kullanılabilen her cümlenin uzunluğu. Aynı sonucu elde etmek için `attention_mask` parametresini de kullanabilirsiniz (bkz. yukarıdaki açıklama); bu parametre uyumluluk amacıyla burada tutulmuştur. `[0, ..., input_ids.size(-1)]` aralığında seçilen indeksler: cache (`dict[str, torch.Tensor]`, *isteğe bağlı*) : Model tarafından hesaplanan, dikkat bloklarındaki gizli durumları (anahtarlar ve değerler) içeren `torch.Tensor` nesnelerine giden bir sözlük (aşağıdaki `cache` çıktısına bakın). Sıralı çözümlemeyi hızlandırmak için kullanılabilir. Sözlük nesnesi, ileri geçiş sırasında yeni hesaplanan gizli durumları eklemek üzere yerinde değiştirilir. 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üş:** [BaseModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya `tuple(torch.Tensor)` Yapılandırmaya ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşan bir [BaseModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.BaseModelOutput) veya `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda). [FlaubertModel](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertModel) 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. ## FlaubertWithLMHeadModel[[transformers.FlaubertWithLMHeadModel]] #### transformers.FlaubertWithLMHeadModel[[transformers.FlaubertWithLMHeadModel]] ```python transformers.FlaubertWithLMHeadModel(config: FlaubertConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L940) **Parametreler:** config ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) : 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 bakın. Üzerinde bir dil modelleme kafası (giriş gömlemelerine ağırlıkları bağlı doğrusal katman) bulunan Flaubert Model 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.FlaubertWithLMHeadModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/flaubert/modeling_flaubert.py#L972) **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) langs (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdideki her token'ın dilini belirtmek için kullanılacak paralel token dizisi. İndeksler, model yapılandırmasında sağlanan iki dönüşüm eşlemesi kullanılarak dil adlarından elde edilebilen dil kimlikleridir (yalnızca çok dilli modeller için sağlanır). Daha spesifik olarak, *dil adından dil kimliğine* eşleme `model.config.lang2id` içindedir (string'ten int'e bir sözlük) ve *dil kimliğinden dil adına* eşleme `model.config.id2lang` içindedir (int'ten string'e bir sözlük). Kullanım örnekleri, [çok dilli belgelendirme](../multilingual) içinde ayrıntılı olarak açıklanmıştır. 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) lengths (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Dolgu token indekslerinde dikkat işleminin uygulanmasını önlemek için kullanılabilen her cümlenin uzunluğu. Aynı sonucu elde etmek için `attention_mask` parametresini de kullanabilirsiniz (bkz. yukarıdaki açıklama); bu parametre uyumluluk amacıyla burada tutulmuştur. `[0, ..., input_ids.size(-1)]` aralığında seçilen indeksler: cache (`dict[str, torch.Tensor]`, *isteğe bağlı*) : Model tarafından hesaplanan, dikkat bloklarındaki gizli durumları (anahtarlar ve değerler) içeren `torch.Tensor` nesnelerine giden bir sözlük (aşağıdaki `cache` çıktısına bakın). Sıralı çözümlemeyi hızlandırmak için kullanılabilir. Sözlük nesnesi, ileri geçiş sırasında yeni hesaplanan gizli durumları eklemek üzere yerinde değiştirilir. 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ı*) : Dil modelleme için etiketler. Not: Etiketler model içinde **kaydırılır**, yani `labels = input_ids` olarak ayarlayabilirsiniz. İndisler `[-100, 0, ..., config.vocab_size]` aralığından seçilir. `-100` olarak ayarlanan tüm etiketler yok sayılır (maske uygulanır), kayıp yalnızca `[0, ..., config.vocab_size]` aralığındaki etiketler için 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üş:** [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 ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [FlaubertWithLMHeadModel](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertWithLMHeadModel) 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 >>> import torch >>> from transformers import AutoTokenizer, FlaubertWithLMHeadModel >>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased") >>> model = FlaubertWithLMHeadModel.from_pretrained("flaubert/flaubert_base_uncased") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs, labels=inputs["input_ids"]) >>> loss = outputs.loss >>> logits = outputs.logits ``` ## FlaubertForSequenceClassification[[transformers.FlaubertForSequenceClassification]] #### transformers.FlaubertForSequenceClassification[[transformers.FlaubertForSequenceClassification]] ```python transformers.FlaubertForSequenceClassification(config: FlaubertConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1049) **Parametreler:** config ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) : 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 bakın. Üstünde bir dizi sınıflandırma/geri dönüş (regression) başlığı bulunan (toplanmış çıktının üzerinde doğrusal bir katman) Flaubert Modeli, ö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.FlaubertForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/flaubert/modeling_flaubert.py#L1061) **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) langs (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdideki her token'ın dilini belirtmek için kullanılacak paralel token dizisi. İndeksler, model yapılandırmasında sağlanan iki dönüşüm eşlemesi kullanılarak dil adlarından elde edilebilen dil kimlikleridir (yalnızca çok dilli modeller için sağlanır). Daha spesifik olarak, *dil adından dil kimliğine* eşleme `model.config.lang2id` içindedir (string'ten int'e bir sözlük) ve *dil kimliğinden dil adına* eşleme `model.config.id2lang` içindedir (int'ten string'e bir sözlük). Kullanım örnekleri, [çok dilli belgelendirme](../multilingual) içinde ayrıntılı olarak açıklanmıştır. 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) lengths (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Dolgu token indekslerinde dikkat işleminin uygulanmasını önlemek için kullanılabilen her cümlenin uzunluğu. Aynı sonucu elde etmek için *attention_mask* parametresini de kullanabilirsiniz (bkz. yukarıdaki açıklama); bu parametre uyumluluk amacıyla burada tutulmuştur. `[0, ..., input_ids.size(-1)]` aralığından seçilen indeksler. cache (`dict[str, torch.Tensor]`, *isteğe bağlı*) : `EncoderDecoderCache` sınıfının, önceden hesaplanmış KV durumlarını içeren bir örneği. Sıralı çözümlemeyi hızlandırmak için kullanılabilir. 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üş:** [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 ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [FlaubertForSequenceClassification](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertForSequenceClassification) 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, FlaubertForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased") >>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased") >>> 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 = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased", 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, FlaubertForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased") >>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased", 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 = FlaubertForSequenceClassification.from_pretrained( ... "flaubert/flaubert_base_uncased", 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 ``` ## FlaubertForMultipleChoice[[transformers.FlaubertForMultipleChoice]] #### transformers.FlaubertForMultipleChoice[[transformers.FlaubertForMultipleChoice]] ```python transformers.FlaubertForMultipleChoice(config: FlaubertConfig, *inputs, **kwargs) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1496) **Parametreler:** config ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) : 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 bakın. Üstünde çoktan seçmeli sınıflandırma kafası (toplanmış çıktının üzerinde doğrusal bir katman ve softmax) bulunan Flaubert 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.FlaubertForMultipleChoice.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/flaubert/modeling_flaubert.py#L1507) **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) langs (`torch.LongTensor`, şekli `(batch_size, num_choices, sequence_length)`, *isteğe bağlı*) : Girdideki her token'ın dilini belirtmek için kullanılacak paralel token dizisi. İndeksler, model yapılandırmasında sağlanan iki dönüşüm eşlemesi kullanılarak dil adlarından elde edilebilen dil kimlikleridir (yalnızca çok dilli modeller için sağlanır). Daha spesifik olarak, *dil adından dil kimliğine* eşleme `model.config.lang2id` içindedir (string'ten int'e bir sözlük) ve *dil kimliğinden dil adına* eşleme `model.config.id2lang` içindedir (int'ten string'e bir sözlük). Kullanım örnekleri, [çok dilli belgelendirme](../multilingual) içinde ayrıntılı olarak verilmiştir. 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) lengths (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Dolgu token indekslerinde dikkat işleminin uygulanmasını önlemek için kullanılabilen her cümlenin uzunluğu. Aynı sonucu elde etmek için *attention_mask* parametresini de kullanabilirsiniz (bkz. yukarıdaki açıklama); bu parametre uyumluluk amacıyla burada tutulmuştur. `[0, ..., input_ids.size(-1)]` aralığından seçilen indeksler. cache (`dict[str, torch.Tensor]`, *isteğe bağlı*) : `EncoderDecoderCache` sınıfının, önceden hesaplanmış KV durumlarını içeren bir örneği. Sıralı çözümlemeyi hızlandırmak için kullanılabilir. 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üş:** [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 ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [FlaubertForMultipleChoice](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertForMultipleChoice) 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, FlaubertForMultipleChoice >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased") >>> model = FlaubertForMultipleChoice.from_pretrained("flaubert/flaubert_base_uncased") >>> 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 ``` ## FlaubertForTokenClassification[[transformers.FlaubertForTokenClassification]] #### transformers.FlaubertForTokenClassification[[transformers.FlaubertForTokenClassification]] ```python transformers.FlaubertForTokenClassification(config: FlaubertConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1151) **Parametreler:** config ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) : 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 bakın. Üzerinde bir token sınıflandırma başlığı (gizli durumlar çıktısının üzerine yerleştirilen doğrusal bir katman) bulunan Flaubert transformer'ı, örneğin Adlandırılmış Varlık Tanıma (NER) 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.FlaubertForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/flaubert/modeling_flaubert.py#L1163) **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) langs (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdideki her token'ın dilini belirtmek için kullanılacak paralel token dizisi. İndeksler, model yapılandırmasında sağlanan iki dönüşüm eşlemesi kullanılarak dil adlarından elde edilebilen dil kimlikleridir (yalnızca çok dilli modeller için sağlanır). Daha spesifik olarak, *dil adından dil kimliğine* eşleme `model.config.lang2id` içindedir (string'ten int'e bir sözlük) ve *dil kimliğinden dil adına* eşleme `model.config.id2lang` içindedir (int'ten string'e bir sözlük). Kullanım örnekleri, [çok dilli belgelendirme](../multilingual) içinde ayrıntılı olarak açıklanmıştır. 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) lengths (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Dolgu token indekslerinde dikkat işleminin uygulanmasını önlemek için kullanılabilen her cümlenin uzunluğu. Aynı sonucu elde etmek için *attention_mask* parametresini de kullanabilirsiniz (bkz. yukarıdaki açıklama); bu parametre uyumluluk amacıyla burada tutulmuştur. `[0, ..., input_ids.size(-1)]` aralığından seçilen indeksler. cache (`dict[str, torch.Tensor]`, *isteğe bağlı*) : `EncoderDecoderCache` sınıfının, önceden hesaplanmış KV durumlarını içeren bir örneği. Sıralı çözümlemeyi hızlandırmak için kullanılabilir. 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. 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üş:** [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 ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [FlaubertForTokenClassification](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertForTokenClassification) 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, FlaubertForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased") >>> model = FlaubertForTokenClassification.from_pretrained("flaubert/flaubert_base_uncased") >>> 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) ... ``` ## FlaubertForQuestionAnsweringSimple[[transformers.FlaubertForQuestionAnsweringSimple]] #### transformers.FlaubertForQuestionAnsweringSimple[[transformers.FlaubertForQuestionAnsweringSimple]] ```python transformers.FlaubertForQuestionAnsweringSimple(config: FlaubertConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1242) **Parametreler:** config ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) : 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 bakın. SQuAD gibi çıkarımsal soru-cevap görevleri için üstünde bir aralık sınıflandırma kafası bulunan Flaubert Modeli (gizli durum çıktısının üzerine, `span start logits` ve `span end logits` hesaplamak için eklenen doğrusal katmanlar). 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.FlaubertForQuestionAnsweringSimple.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: 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/flaubert/modeling_flaubert.py#L1252) **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) langs (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdideki her token'ın dilini belirtmek için kullanılacak paralel token dizisi. İndeksler, model yapılandırmasında sağlanan iki dönüşüm eşlemesi kullanılarak dil adlarından elde edilebilen dil kimlikleridir (yalnızca çok dilli modeller için sağlanır). Daha spesifik olarak, *dil adından dil kimliğine* eşleme `model.config.lang2id` içindedir (string'ten int'e bir sözlük) ve *dil kimliğinden dil adına* eşleme `model.config.id2lang` içindedir (int'ten string'e bir sözlük). Kullanım örnekleri, [çok dilli belgelendirme](../multilingual) içinde ayrıntılı olarak açıklanmıştır. 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) lengths (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Dolgu token indekslerinde dikkat işleminin uygulanmasını önlemek için kullanılabilen her cümlenin uzunluğu. Aynı sonucu elde etmek için *attention_mask* parametresini de kullanabilirsiniz (bkz. yukarıdaki açıklama); bu parametre uyumluluk amacıyla burada tutulmuştur. `[0, ..., input_ids.size(-1)]` aralığından seçilen indeksler. cache (`dict[str, torch.Tensor]`, *isteğe bağlı*) : `EncoderDecoderCache` sınıfının, önceden hesaplanmış KV durumlarını içeren bir örneği. Sıralı çözümlemeyi hızlandırmak için kullanılabilir. 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. 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üş:** [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 ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [FlaubertForQuestionAnsweringSimple](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertForQuestionAnsweringSimple) 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, FlaubertForQuestionAnsweringSimple >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased") >>> model = FlaubertForQuestionAnsweringSimple.from_pretrained("flaubert/flaubert_base_uncased") >>> 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) ... ``` ## FlaubertForQuestionAnswering[[transformers.FlaubertForQuestionAnswering]] #### transformers.FlaubertForQuestionAnswering[[transformers.FlaubertForQuestionAnswering]] ```python transformers.FlaubertForQuestionAnswering(config: FlaubertConfig) ``` [Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/flaubert/modeling_flaubert.py#L1377) **Parametreler:** config ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) : 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 bakın. SQuAD gibi çıkarımsal soru-cevap görevleri için üstünde bir aralık sınıflandırma kafası bulunan Flaubert dönüştürücüsü (gizli durum çıktısının üzerine, `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.FlaubertForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, is_impossible: typing.Optional[torch.Tensor] = None, cls_index: typing.Optional[torch.Tensor] = None, p_mask: 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/flaubert/modeling_flaubert.py#L1387) **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) langs (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdideki her token'ın dilini belirtmek için kullanılacak paralel token dizisi. İndeksler, model yapılandırmasında sağlanan iki dönüşüm eşlemesi kullanılarak dil adlarından elde edilebilen dil kimlikleridir (yalnızca çok dilli modeller için sağlanır). Daha spesifik olarak, *dil adından dil kimliğine* eşleme `model.config.lang2id` içindedir (string'ten int'e bir sözlük) ve *dil kimliğinden dil adına* eşleme `model.config.id2lang` içindedir (int'ten string'e bir sözlük). Kullanım örnekleri, [çok dilli belgelendirme](../multilingual) içinde ayrıntılı olarak açıklanmıştır. 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) lengths (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Dolgu token indekslerinde dikkat işleminin uygulanmasını önlemek için kullanılabilen her cümlenin uzunluğu. Aynı sonucu elde etmek için *attention_mask* parametresini de kullanabilirsiniz (bkz. yukarıdaki açıklama); bu parametre uyumluluk amacıyla burada tutulmuştur. `[0, ..., input_ids.size(-1)]` aralığından seçilen indeksler. cache (`dict[str, torch.Tensor]`, *isteğe bağlı*) : `EncoderDecoderCache` sınıfının, önceden hesaplanmış KV durumlarını içeren bir örneği. Sıralı çözümlemeyi hızlandırmak için kullanılabilir. 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. is_impossible (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Bir sorunun cevabının olup olmadığını etiketler (SQuAD 2.0) cls_index (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Cevabın geçerliliğini hesaplamak için girdi olarak kullanılacak sınıflandırma jetonunun konumunun (indeksinin) etiketleri. p_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Cevaplarda yer alamayacak token'ların isteğe bağlı maskesi (ör. [CLS], [PAD], ...). 1.0, token'ın maskelenmesi gerektiğini belirtir. 0.0, token'ın maskelenmediğini 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üş:** `FlaubertForQuestionAnsweringOutput` veya `tuple(torch.Tensor)` `FlaubertForQuestionAnsweringOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([FlaubertConfig](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur. [FlaubertForQuestionAnswering](/docs/transformers/main/tr/model_doc/flaubert#transformers.FlaubertForQuestionAnswering) 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ı*, `start_positions` ve `end_positions` sağlanırsa döndürülür) -- Başlangıç tokeni, bitiş tokeni (ve sağlanırsa is_impossible) sınıflandırma kayıplarının toplamı olarak sınıflandırma kaybı. - **start_top_log_probs** (`torch.Tensor`, şekli `(batch_size, config.start_n_top)`, *isteğe bağlı*, `start_positions` veya `end_positions` sağlanmadığında döndürülür) -- config.start_n_top başlangıç tokeni olasılıkları için log olasılıklar (beam-search). - **start_top_index** (`torch.LongTensor`, şekli `(batch_size, config.start_n_top)`, *isteğe bağlı*, `start_positions` veya `end_positions` sağlanmadığında döndürülür) -- En iyi config.start_n_top başlangıç tokeni olasılıkları için indeksler (beam-search). - **end_top_log_probs** (`torch.Tensor`, şekli `(batch_size, config.start_n_top * config.end_n_top)`, *isteğe bağlı*, `start_positions` veya `end_positions` sağlanmadığında döndürülür) -- En iyi `config.start_n_top * config.end_n_top` bitiş token olasılıkları için log olasılıklar (beam-search). - **end_top_index** (`torch.LongTensor`, şekli `(batch_size, config.start_n_top * config.end_n_top)`, *isteğe bağlı*, `start_positions` veya `end_positions` sağlanmadığında döndürülür) -- En iyi `config.start_n_top * config.end_n_top` son token olasılıklarının (beam-search) indeksleri. - **cls_logits** (`torch.Tensor`, şekli `(batch_size,)`, *isteğe bağlı*, `start_positions` veya `end_positions` sağlanmadığında döndürülür) -- Cevapların `is_impossible` etiketi için log olasılıkları. - **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. Örnek: ```python >>> from transformers import AutoTokenizer, FlaubertForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> model = FlaubertForQuestionAnswering.from_pretrained("FacebookAI/xlm-mlm-en-2048") >>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze( ... 0 ... ) # Batch size 1 >>> start_positions = torch.tensor([1]) >>> end_positions = torch.tensor([3]) >>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions) >>> loss = outputs.loss ```