# Modeller

Alt sınıf [PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel), bir modelin yerel bir dosya veya dizinden ya da kütüphanenin sağladığı önceden eğitilmiş bir model yapılandırmasından (HuggingFace'in Hub'ından indirilen) yüklenmesi/kaydedilmesi için ortak yöntemleri uygular.

[PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel), tüm modellerde ortak olan birkaç yöntemi de uygular:

- sözlüğe yeni tokenler eklendiğinde girdi token gömme boyutlarını yeniden boyutlandırın

Her modele ortak olan diğer yöntemler [ModuleUtilsMixin](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.modeling_utils.ModuleUtilsMixin) ve [GenerationMixin](/docs/transformers/v5.23.0/tr/main_classes/text_generation#transformers.GenerationMixin) içinde tanımlanmıştır.

## PreTrainedModel[[transformers.PreTrainedModel]]

#### transformers.PreTrainedModel[[transformers.PreTrainedModel]]

```python
transformers.PreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L1068)

Tüm modellerin temel sınıfı.

[PreTrainedModel](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel), modellerin yapılandırmasını saklamaktan sorumlu olup modellerin yüklenmesi, indirilmesi ve kaydedilmesine ilişkin yöntemleri ve tüm modellerde ortak olan birkaç yöntemi yönetir:

- girdi gömme boyutlarını yeniden ayarlayın

Sınıf özellikleri (türetilen sınıflar tarafından geçersiz kılınır):

- **config_class** ([PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig)) -- Bu model mimarisi için yapılandırma sınıfı olarak kullanılacak [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) alt sınıfı.
- **base_model_prefix** (`str`) -- Türetilmiş sınıflarda, temel modelin üzerine modüller ekleyen aynı mimariye sahip sınıflarda, temel modelle ilişkilendirilen özniteliği gösteren bir dize.
- **main_input_name** (`str`) -- Modelin ana girdisinin adı (NLP modelleri için genellikle `input_ids`, görme modelleri için `pixel_values` ve konuşma modelleri için `input_values`).
- **can_record_outputs** (dict):

#### push_to_hub[[transformers.PreTrainedModel.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/hub.py#L822)

**Parametreler:**

repo_id (`str`) : Modelinizi yüklemek istediğiniz depoyun adı. Belirli bir organizasyona yüklerken organizasyon adınızı içermelidir.

commit_message (`str`, *isteğe bağlı*) : İterilirken taahhüt edilecek mesaj. Varsayılan olarak `"Upload model"` olur.

commit_description (`str`, *isteğe bağlı*) : Oluşturulacak commit'in açıklaması

private (`bool`, *isteğe bağlı*) : Deponun özel yapılıp yapılmayacağını belirtir. `None` (varsayılan) ise, organizasyonun varsayılanı özel değilse depo herkese açık olur. Depo zaten mevcutsa bu değer yok sayılır.

token (`bool` veya `str`, *isteğe bağlı*) : Uzaktaki dosyalar için HTTP bearer yetkilendirmesi olarak kullanılacak belirteç. `True` (varsayılan) ise, `hf auth login` çalıştırıldığında oluşturulan belirteç ( `~/.huggingface` içinde saklanır) kullanılır.

revision (`str`, *isteğe bağlı*) : Yüklenen dosyaların itileceği dal.

create_pr (`bool`, *isteğe bağlı*, varsayılan `False`) : Yüklenen dosyalarla bir PR oluşturulup oluşturulmayacağı veya doğrudan commit atılıp atılmayacağı.

max_shard_size (`int` veya `str`, *isteğe bağlı*, varsayılan `"50GB"`) : Yalnızca modeller için geçerlidir. Bir checkpoint'in parçalanmadan önceki maksimum boyutu. Parçalanan checkpoint'lerin her biri bu boyuttan küçük olacaktır. Dize olarak ifade ediliyorsa, birimle (örneğin `"5MB"`) birlikte rakamlardan oluşmalıdır.

tags (`list[str]`, *isteğe bağlı*) : Hub'a itilecek etiketlerin listesi.

Model dosyasını 🤗 Model Hub'a yükleyin.

Örnekler:

```python
from transformers import AutoModel

model = AutoModel.from_pretrained("google-bert/bert-base-cased")

# Push the model to your namespace with the name "my-finetuned-bert".
model.push_to_hub("my-finetuned-bert")

# Push the model to an organization with the name "my-finetuned-bert".
model.push_to_hub("huggingface/my-finetuned-bert")
```

#### activation_checkpointing_disable[[transformers.PreTrainedModel.activation_checkpointing_disable]]

```python
activation_checkpointing_disable()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L3249)

Mevcut model için aktivasyon denetlemesini devre dışı bırakır.

#### activation_checkpointing_enable[[transformers.PreTrainedModel.activation_checkpointing_enable]]

```python
activation_checkpointing_enable(activation_checkpointing_kwargs = None, every_n_layers: int = 1, offload: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L3110)

**Parametreler:**

every_n_layers (`int`, *isteğe bağlı*, varsayılan 1) : Sadece her `every_n_layers`. decoder katmanında checkpoint alınır, diğerleri aktivasyonlarını korumaya devam eder. `1` her katmanda checkpoint alır; bu, normalde uygulanan tümü ya da hiçi davranışıdır. Daha büyük değerler, tam checkpoint ile açığa çıkan bellek kullanılmayacaksa, hız için bellekten ödün vermenizi sağlar.

offload (`bool`, *isteğe bağlı*, varsayılan `False`) : Yeniden hesaplama için kaydedilen aktivasyonları, hızlandırıcıda değil, sabitlenmiş (pinned) ana bellekte tutar. Bu, uzun dizi uzunluklarında baskın olan `layers x sequence x hidden` baytlık cihaz belleğini boşaltır; karşılığında ileri yayılımda cihazdan ana belleğe, geri yayılımda ise ana bellekten cihaza kopyalama maliyeti doğar. Her iki kopyalama da hesaplama akışında (compute stream) çalıştığı için adım yavaşlar.

activation_checkpointing_kwargs (dict, *isteğe bağlı*) : `torch.utils.checkpoint.checkpoint` fonksiyonuna iletilen ek anahtar kelime argümanları.

Mevcut model için aktivasyon denetlemesini etkinleştirir.

Modüllerin `__call__` yöntemini, `forward` yerine `__call__` modülün tüm kanca (hook) işlemlerini eklediği için geçiririz. https://discuss.pytorch.org/t/any-different-between-model-input-and-model-forward-input/3690/2

#### add_model_tags[[transformers.PreTrainedModel.add_model_tags]]

```python
add_model_tags(tags: list[str] | str)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L1360)

**Parametreler:**

tags (`Union[list[str], str]`) : Modelde enjekte edilmek istenen etiketler

Hugging Face Hub'a itilen modele özel etiketler ekler. Modeldeki mevcut etiketlerin üzerine yazmaz.

Örnekler:

```python
from transformers import AutoModel

model = AutoModel.from_pretrained("google-bert/bert-base-cased")

model.add_model_tags(["custom", "custom-bert"])

# Push the model to your namespace with the name "my-custom-bert".
model.push_to_hub("my-custom-bert")
```

#### can_generate[[transformers.PreTrainedModel.can_generate]]

```python
can_generate()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L1474)

**Dönüş:** `bool`

Bu modelin `.generate()` ile diziler üretebilip üretemeyeceği.

Bu modelin `GenerationMixin`'den veya benzer bir arayüze sahip bir sınıftan `.generate()` ile diziler üretebileceğini döndürür.

Arka planda, bu fonksiyon True dönen sınıflarda bazı üretim (generation) özelinde değişiklikler tetiklenir; örneğin, model örneği dolu bir `generation_config` özniteliğine sahip olur.

#### cuda[[transformers.PreTrainedModel.cuda]]

```python
cuda(*args, **kwargs)
```

Noktalı bir yol için sahte bir değer (ör. `torch.float32`): öznitelik erişim zincirleri, çağrılar geçiş (pass-through) dekoratörleri gibi davranır, `repr` noktalı yoldur ve bir taban sınıf olarak kullanıldığında düz bir `type` tabanı yerleştirilir (PEP 560 `__mro_entries__`), böylece gerçek alt sınıflar normal bir metasınıfı korur ve `inspect.signature` sahtenin yerine gerçek `__init__` değerlerini okur.

#### dequantize[[transformers.PreTrainedModel.dequantize]]

```python
dequantize(dtype = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L1342)

Eğer model, dequantizasyonu destekleyen bir kuantizasyon yöntemiyle kuantize edilmişse, modelin dequantize edilmesini potansiyel olarak gerçekleştirin.

#### disable_input_require_grads[[transformers.PreTrainedModel.disable_input_require_grads]]

```python
disable_input_require_grads()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2181)

`_require_grads_hook` öğesini kaldırır.

#### enable_input_require_grads[[transformers.PreTrainedModel.enable_input_require_grads]]

```python
enable_input_require_grads()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2137)

Girdi gömme (embedding) için gradyanları etkinleştirir. Bu, model ağırlıklarını sabit tutarken adaptör ağırlarını ince ayar yapmak için faydalıdır.

#### from_pretrained[[transformers.PreTrainedModel.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, *model_args, config: transformers.configuration_utils.PreTrainedConfig | str | os.PathLike | None = None, cache_dir: str | os.PathLike | None = None, ignore_mismatched_sizes: bool = False, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', use_safetensors: bool | None = None, weights_only: bool = True, fusion_config: dict[str, bool | dict[str, typing.Any]] | None = None, disable_mmap: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L3893)

**Parametreler:**

pretrained_model_name_or_path (`str` veya `os.PathLike`, *isteğe bağlı*) : Aşağıdakilerden biri olabilir:  - huggingface.co üzerindeki bir model deposunda barındırılan önceden eğitilmiş bir modelin *model kimliği* olan bir dize. - [save_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.save_pretrained) kullanılarak kaydedilmiş model ağırlıklarını içeren bir *dizin* yolu, örneğin `./my_model_directory/`. `save_pretrained(..., distributed_checkpoint=True)` ile kaydedilen dizinler, modelin mevcut mesh'ini ve yerleşimlerini koruyarak dağıtık checkpoint (DCP) ile algılanır ve yüklenir. Bunun için `torch>=2.7` gereklidir ve yükleme katıdır: modelin her anahtarı checkpoint'te bulunmalıdır. - Hem yapılandırmayı hem de durum sözlüğünü (sırasıyla `config` ve `state_dict` anahtar sözcük argümanlarıyla) sağlıyorsanız `None`.

model_args (konumsal argümanlar dizisi, *isteğe bağlı*) : Kalan tüm konumsal argümanlar, altta yatan modelin `__init__` yöntemine aktarılır.

config (`Union[PreTrainedConfig, str, os.PathLike]`, *isteğe bağlı*) : Aşağıdakilerden biri olabilir:  - [PreTrainedConfig](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) türevi bir sınıfın örneği, - [from_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained) girdisi olarak geçerli bir dize veya yol.  Otomatik olarak yüklenen yapılandırma yerine kullanılacak model yapılandırması. Yapılandırma aşağıdaki durumlarda otomatik olarak yüklenebilir:  - Model, kütüphane tarafından sağlanan bir model ise (önceden eğitilmiş bir modelin *model kimliği* dizesiyle yüklenir). - Model, [save_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.save_pretrained) kullanılarak kaydedilmiş ve kayıt dizini sağlanarak yeniden yükleniyorsa. - Model, `pretrained_model_name_or_path` olarak yerel bir dizin sağlanarak yükleniyor ve dizinde *config.json* adlı bir yapılandırma JSON dosyası bulunuyorsa.

state_dict (`dict[str, torch.Tensor]`, *isteğe bağlı*) : Kaydedilen ağırlık dosyasından yüklenen bir durum sözlüğü yerine kullanılacak bir durum sözlüğü. Bu seçenek, önceden eğitilmiş bir yapılandırmadan model oluşturmak istiyorsanız ancak kendi ağırlıklarınızı yüklemek istiyorsanız kullanılabilir. Ancak bu durumda, [save_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.save_pretrained) ve [from_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) kullanmanın daha basit bir seçenek olup olmadığını kontrol etmeniz gerekir.

cache_dir (`Union[str, os.PathLike]`, *isteğe bağlı*) : Standart önbellek kullanılmayacaksa, indirilen önceden eğitilmiş model yapılandırmasının önbelleğe alınacağı dizinin yolu.

ignore_mismatched_sizes (`bool`, *isteğe bağlı*, varsayılan `False`) : Kontrol noktasındaki ağırlıklardan bazıları, modelin ağırlıklarıyla aynı boyutta değilse hata fırlatılacak mı (örneğin, 3 etiketli bir kontrol noktasından 10 etiketli bir model oluşturuyorsanız).

force_download (`bool`, *isteğe bağlı*, varsayılan `False`) : Model ağırlıklarının ve yapılandırma dosyalarının (yeniden) indirilmesini, varsa önbellekteki sürümlerin üzerine yazılacak şekilde zorlayıp zorlamayacağı.

proxies (`dict[str, str]`, *isteğe bağlı*) : Protokol veya uç nokta bazında kullanılacak vekil sunucuların sözlüğü, örn. `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Vekiller her istekte kullanılır.

output_loading_info(`bool`, *isteğe bağlı*, varsayılan `False`) : Eksik anahtarlar, beklenmeyen anahtarlar ve hata mesajlarını içeren bir sözlüğün de döndürülüp döndürülmeyeceğini belirtir.

local_files_only(`bool`, *isteğe bağlı*, varsayılan `False`) : Sadece yerel dosyalara bakılacak mı (yani modelin indirilmeye çalışılmayacağı).

token (`str` veya `bool`, *isteğe bağlı*) : Uzaktaki dosyalar için HTTP bearer yetkilendirmesi olarak kullanılacak belirteç. `True` ise veya belirtilmezse, `hf auth login` çalıştırıldığında oluşturulan belirteç ( `~/.huggingface` içinde saklanır) kullanılır.

revision (`str`, *isteğe bağlı*, varsayılan `"main"`) : Kullanılacak belirli model sürümü. huggingface.co üzerinde modelleri ve diğer artefaktları depolamak için git tabanlı bir sistem kullandığımız için, bir dal adı, etiket adı veya commit kimliği olabilir; bu nedenle `revision`, git tarafından izin verilen herhangi bir tanımlayıcı olabilir.    Hub'da oluşturduğunuz bir pull request'i test etmek için `revision="refs/pr/<pr_number>"` parametresini iletebilirsiniz.

attn_implementation (`str`, *isteğe bağlı*) : Modelde kullanılacak dikkat (attention) uygulaması (ilgiliyse). Aşağıdakilerden biri olabilir - `"eager"` (dikkatin manuel uygulaması) - `"sdpa"` ([`F.scaled_dot_product_attention`](https://pytorch.org/docs/master/generated/torch.nn.functional.scaled_dot_product_attention.html) kullanılarak) - `"flash_attention_2"` ([Dao-AILab/flash-attention](https://github.com/Dao-AILab/flash-attention) kullanılarak) - `"flash_attention_3"` ([Dao-AILab/flash-attention/hopper](https://github.com/Dao-AILab/flash-attention/tree/main/hopper) kullanılarak) - `"flash_attention_4"` ([Dao-AILab/flash-attention/flash_attn/cute](https://github.com/Dao-AILab/flash-attention/tree/main/flash_attn/cute) kullanılarak). Varsayılan olarak, kullanılabilirse SDPA kullanılır. Aksi halde varsayılan, manuel `"eager"` uygulamasıdır.  HF çekirdek referanslarını şu formda kabul eder: /[@][:]  -  ve  herhangi bir "/" ve ":" dışı karakter dizisidir. - "@" isteğe bağlıdır (dal, etiket veya commit benzeri), örn. "@main", "@v1.2.0", "@abc123". - ":" isteğe bağlıdır ve çekirdek deposu içindeki bir işlevi seçer. - Her iki seçenek birlikte ve yalnızca bu sırada görünebilir: önce @revision, ardından :kernel_name. - Kod, yüklemeden önce bunu kaldırdığı için başlangıçta "|" önekinin (örn. "flash|...") bilinçli olarak izin verilmesi; burada karakter sınıflarında '|' hariç tutulmamıştır.  Eşleşen örnekler: "org/model" "org/model@main" "org/model:custom_kernel" "org/model@v1.2.3:custom_kernel"

experts_implementation (`str`, *isteğe bağlı*) : Modelde kullanılacak uzmanlar uygulaması (ilgiliyse). Aşağıdakilerden biri olabilir:  - `"eager"` (uzmanlar matris çarpımlarının ardışık uygulaması). - `"batched_mm"` ([`torch.bmm`](https://pytorch.org/docs/stable/generated/torch.bmm.html) kullanır). - `"grouped_mm"` ([`torch.nn.functional.grouped_mm`](https://docs.pytorch.org/docs/main/generated/torch.nn.functional.grouped_mm.html) kullanır).  Varsayılan olarak, model destekliyorsa `"grouped_mm"` kullanılır. Aksi halde varsayılan, elle yazılmış `"eager"` uygulamasıdır.

**Büyük model çıkarımı için parametreler:**

dtype (`str` veya `torch.dtype`, *opsiyonel*, varsayılan `"auto"`) : Varsayılan `torch_dtype` değerini geçersiz kılar ve modeli belirli bir `dtype` altında yükler. Farklı seçenekler şunlardır:  1. `torch.float16` veya `torch.bfloat16` veya `torch.float`: Belirtilen `dtype` ile yükler; eğer varsa modelin `config.dtype` değerini görmezden gelir. Belirtilmezse - model `torch.float` (fp32) olarak yüklenir.  2. `"auto"` - Modelin `config.json` dosyasındaki `dtype` veya `torch_dtype` girdisi kullanılmaya çalışılır. Bu girdi bulunamazsa, checkpoint'teki ilk ağırlığın `dtype` değeri kontrol edilir ve bu değer `dtype` olarak kullanılır. Bu, modeli eğitim sonunda kaydedildiği `dtype` ile yükler. Modelin nasıl eğitildiğine dair bir gösterge olarak kullanılamaz. Çünkü model yarı hassasiyetli bir dtype ile eğitilmiş olabilir ancak fp32 olarak kaydedilmiş olabilir.  3. Geçerli bir `torch.dtype` olan bir dize. Örneğin "float32" modeli `torch.float32` ile yükler, "float16" `torch.float16` ile yükler vb.    Bazı modeller için eğitimde kullanılan `dtype` bilinmiyor olabilir - modelin makalesini kontrol etmeyi veya yazarlarla iletişime geçerek bu bilginin model kartına eklenmesini ve `config.json` dosyasına hub üzerinde `dtype` veya `torch_dtype` girdisinin eklenmesini isteyebilirsiniz.

device_map (`str` veya `dict[str, Union[int, str, torch.device]]` veya `int` veya `torch.device`, *isteğe bağlı*) : Her alt modülün nereye yerleştirileceğini belirten bir eşleme. Her parametre/buffer adının ayrı ayrı belirtilmesine gerek yoktur; bir modül adı bir kez belirtildiğinde, o modülün tüm alt modülleri aynı cihaza gönderilir. Sadece modelin yerleştirileceği cihaz (*ör.*, `"cpu"`, `"cuda:1"`, `"mps"` veya `1` gibi bir GPU sıra numarası) geçirilirse, cihaz eşlemesi tüm modeli bu cihaza eşler. `device_map = 0` geçmek, tüm modeli GPU 0'a yerleştirmek anlamına gelir. Accelerate'ın en optimize `device_map` değerini otomatik olarak hesaplamasını istiyorsanız, `device_map="auto"` olarak ayarlayın. Her seçenek hakkında daha fazla bilgi için [bir cihaz eşlemesi tasarlamak](https://hf.co/docs/accelerate/main/en/usage_guides/big_modeling#designing-a-device-map) bölümüne bakın.

max_memory (`Dict`, *isteğe bağlı*) : `device_map` kullanılıyorsa, cihaz kimliği ile maksimum bellek arasındaki eşlemeyi içeren bir sözlük. Ayarlanmazsa, her GPU için kullanılabilir maksimum bellek ve mevcut CPU RAM'i varsayılan olarak kullanılır.

distributed_config ([DistributedConfig](/docs/transformers/v5.23.0/tr/expert_parallelism#transformers.DistributedConfig), *isteğe bağlı*) : Tensor paralelliği veya FSDP2 ile yerel dağıtık yükleme yapılandırması. Modelin önceden tanımlı tensor paralel planını kullanmak için `DistributedConfig(tp_size=N)`, bir tensor paralel planı belirtmek için `DistributedConfig(tp_plan=...)` veya FSDP2 için `DistributedConfig(fsdp_size=N)` geçin. `tp_size > 1` veya `fsdp_size > 1` olduğunda `torchrun` ve başlatılmış bir işlem grubu gerektirir. `device_map` ile birbirini dışlar.

device_mesh (`torch.distributed.DeviceMesh`, *isteğe bağlı*) : Bir torch cihaz ızgarası. Verilmezse varsayılan olarak dünya boyutuna (world size) ayarlanır. Şu an yalnızca tensor paralelliği için kullanılır. Verildiğinde, 1 boyuttan büyükse `"tp"` adında bir boyut içermelidir; bu boyut tensor paralelliği için kullanılacaktır

offload_folder (`str` veya `os.PathLike`, *isteğe bağlı*) : `device_map` içinde `"disk"` değeri varsa, ağırlıkların taşınacağı klasör.

offload_buffers (`bool`, *isteğe bağlı*) : Model parametreleriyle birlikte tamponların taşınacak (offload) olup olmayacağı.

quantization_config (`Union[QuantizationConfigMixin,Dict]`, *isteğe bağlı*) : Kuantizasyon için (ör. bitsandbytes, gptq) yapılandırma parametrelerinin sözlüğü veya bir QuantizationConfigMixin nesnesi.

subfolder (`str`, *isteğe bağlı*, varsayılan `""`) : İlgili dosyalar huggingface.co üzerindeki model deposunun bir alt klasöründe bulunuyorsa, buraya klasör adını belirtebilirsiniz.

variant (`str`, *isteğe bağlı*) : Belirtilirse, ağırlıklar `variant` dosya adından yüklenir, *ör.* pytorch_model..bin.

use_safetensors (`bool`, *isteğe bağlı*, varsayılan `None`) : `safetensors` kontrol noktalarının kullanılıp kullanılmayacağını belirtir. Varsayılan değeri `None`'dir. Belirtilmezse ve `safetensors` yüklü değilse, `False` olarak ayarlanır.

weights_only (`bool`, *isteğe bağlı*, varsayılan `True`) : unpickler'ın yalnızca tensörleri, ilkel tipleri, sözlükleri ve torch.serialization.add_safe_globals() aracılığıyla eklenen tipleri yüklemeye kısıtlanıp kısıtlanmayacağını belirtir. False olarak ayarlandığında, sarmalayıcı tensör alt sınıfı ağırlıkları yüklenebilir.

disable_mmap (`bool`, *isteğe bağlı*) : Safetensors kontrol noktalarını yüklerken bellek eşlemesini devre dışı bırakıp bırakmayacağını belirtir. `None` (varsayılan) olduğunda, kontrol noktası `hf-mount` FUSE dosya sisteminde (HF Spaces/Endpoints tarafından kullanılır) bulunuyorsa, mmap + paralel sayfa hatalarının ölü kilit (deadlock) oluşturabilmesi nedeniyle `True` olarak otomatik algılanır. `True` olduğunda, dosyalar tamamen belleğe okunur ve `safetensors.torch.load` ile ayrıştırılır. `False` olduğunda, varsayılan bellek eşlemeli yükleyici her zaman kullanılır.

fusion_config (`dict[str, bool | dict[str, Any]]`, *isteğe bağlı*) : Model örneklemesi öncesinde uygulanacak isteğe bağlı füzyon yapılandırması. Her anahtar bir füzyon ailesini etkinleştirir ve değeri, o füzyonu varsayılan seçeneklerle etkinleştirmek için `True` veya aileye özgü seçeneklerin sözlüğü olabilir. Örneğin, `{"patch_embeddings": True}` yama gömme füzyonunu etkinleştirir. Bu, çıktıları hafifçe değiştirebileceğinden yalnızca çıkarım optimizasyonu olarak kullanılmalıdır. Atlanırsa, `from_pretrained()` mevcut olduğunda `config.fusion_config` değerine geri döner. Daha fazla ayrıntı için `docs/source/en/fusion_mapping.md` içindeki füzyon eşleme kılavuzuna bakın.

key_mapping (`dict[str, str], *optional*) : Hub'da, bir Transformers mimarisiyle uyumlu ancak buna göre dönüştürülmemiş bir model kullanılıyorsa, ağırlık adları için olası bir eşleme.

kwargs (kalan anahtar kelime argümanları sözlüğü, *isteğe bağlı*) : Yapılandırma nesnesini (yüklenmesinin ardından) güncellemek ve modeli başlatmak için kullanılabilir (ör. `output_attentions=True`). Bir `config` sağlanıp sağlanmadığına veya otomatik olarak yüklenip yüklenmediğine göre farklı davranır:  - `config` ile bir yapılandırma sağlanırsa, `**kwargs` doğrudan alttaki modelin `__init__` yöntemine aktarılır (yapılandırmaya ilişkin tüm ilgili güncellemelerin zaten yapıldığı varsayılır) - Bir yapılandırma sağlanmazsa, `kwargs` önce yapılandırma sınıfı başlatma işlevine ([from_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained)) aktarılır. `kwargs`'nın, bir yapılandırma özniteliğine karşılık gelen her anahtarı, söz konusu özniteliği sağlanan `kwargs` değeriyle geçersiz kılmak için kullanılır. Hiçbir yapılandırma özniteliğine karşılık gelmeyen kalan anahtarlar, alttaki modelin `__init__` işlevine aktarılır.

Önceden eğitilmiş bir model yapılandırmasından önceden eğitilmiş bir pytorch modeli örnekleyin.

Model, varsayılan olarak `model.eval()` kullanılarak değerlendirme moduna ayarlanır (Dropout modülleri devre dışı bırakılır). Modeli eğitmek için önce `model.train()` ile eğitim moduna geri almanız gerekir.

*Weights from XXX not initialized from pretrained model* uyarısı, XXX ağırlıklarının modelin geri kalanıyla birlikte önceden eğitilmiş olarak gelmediği anlamına gelir. Bu ağırlıkları aşağı akışlı bir ince ayar göreviyle eğitmek size kalmıştır.

*XXX'ten gelen ağırlıklar YYY'de kullanılmıyor* uyarısı, XXX katmanının YYY tarafından kullanılmadığı ve bu nedenle bu ağırlıkların atıldığı anlamına gelir.

Bu yöntemi, duvarlı bir ortamda kullanmak için ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode) adlı özel modu etkinleştirin.

Örnekler:

```python
>>> from transformers import BertConfig, BertModel

>>> # Download model and configuration from huggingface.co and cache.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased")
>>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
>>> model = BertModel.from_pretrained("./test/saved_model/")
>>> # Update configuration during loading.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased", output_attentions=True)
>>> assert model.config.output_attentions == True
```

#### get_compiled_call[[transformers.PreTrainedModel.get_compiled_call]]

```python
get_compiled_call(compile_config: transformers.generation.configuration_utils.CompileConfig | None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L4811)

`torch.compile` ile derlenmiş bir `self.__call__` sürümü döndürür. Bu, özellikle prefill aşamasında (yeni şekillerle grafiğin yeniden hesaplanmasını önlemek için derlenmiş sürümü kullanmak istemediğimizde) ve iteratif çözümleme aşamasında (statik şekillerle derlenmiş sürümün hızlanmasından yararlanmak istediğimizde) çıkarım sırasında derlenmemiş/derlenmiş `forward` arasında dinamik olarak seçim yapabilmek için faydalıdır.

#### get_decoder[[transformers.PreTrainedModel.get_decoder]]

```python
get_decoder()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2254)

*decoder* modülünün en iyi çaba ile aranması.

Denemelerin sırası (mevcut kullanımın ~%85'ini kapsar):

1. `self.decoder/self.language_model/self.text_model`
2. `self.base_model`                  (birçok sarmalayıcı, decoder'ı burada saklar)
3. `self.base_model.get_decoder()`    (iç içe sarmalayıcılar)
4. fallback: özel bir kural gerektiren birkaç egzotik model için raise

#### get_encoder[[transformers.PreTrainedModel.get_encoder]]

```python
get_encoder(modality: str | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2196)

*encoder* modülünün en iyi çaba ile aranması. `modality` argümanı sağlanırsa, çok modlu modellerde moda özgü bir kodlayıcı arar (ör. "image_encoder"). Varsayılan olarak, fonksiyon varsa modelin metin kodlayıcısını, yoksa `self` değerini döndürür.

`modality` için olası değerler "image", "video" ve "audio"dur.

#### get_expanded_tied_weights_keys[[transformers.PreTrainedModel.get_expanded_tied_weights_keys]]

```python
get_expanded_tied_weights_keys(all_submodels: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2416)

Sadece mevcut model için, `all_submodels=True` ise tüm alt modeller için özyinelemeli olarak genişletilmiş bağlı ağırlık anahtarlarını (modüller veya regex desenleri içermeleri durumunda) döndürür (yani tüm alt modeller için yapılandırma değerlerini yeniden kontrol eder).

Neredeyse tüm modellerde yalnızca gömme bağlaması (tie the embeddings) gereklidir, bu nedenle modelin `_tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}` içsel özelliği vardır. Bu durumda eşleme zaten "genişletilmiş"tir, yani tam parametreleri zaten içerir ve bu fonksiyon yalnızca özelliğin bir kopyasını döndürür. Daha karmaşık desenler için, örneğin `DFineForObjectDetection` için, aşağıdaki özniteliğe sahibiz

```
_tied_weights_keys = {
    r"bbox_embed.(?![0])\d+": "bbox_embed.0",
    r"class_embed.(?![0])\d+": "class_embed.0",
    "model.decoder.class_embed": "class_embed",
    "model.decoder.bbox_embed": "bbox_embed",
}
```

Bu durumda, fonksiyon modelin tüm parametrelerini ve tamponlarını (buffers) arar ve tüm parametreleri eşleştirir,

şunları döndürür:
```
{
    'bbox_embed.1.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'bbox_embed.1.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    'bbox_embed.1.layers.1.bias': 'bbox_embed.0.layers.1.bias',
    'bbox_embed.1.layers.1.weight': 'bbox_embed.0.layers.1.weight',
    'bbox_embed.1.layers.2.bias': 'bbox_embed.0.layers.2.bias',
    'bbox_embed.1.layers.2.weight': 'bbox_embed.0.layers.2.weight',
    'bbox_embed.2.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'bbox_embed.2.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    ...
    'class_embed.1.bias': 'class_embed.0.bias',
    'class_embed.1.weight': 'class_embed.0.weight',
    'class_embed.2.bias': 'class_embed.0.bias',
    'class_embed.2.weight': 'class_embed.0.weight',
    ...
    'model.decoder.class_embed.0.bias': 'class_embed.0.bias',
    'model.decoder.class_embed.0.weight': 'class_embed.0.weight',
    'model.decoder.class_embed.1.bias': 'class_embed.0.bias',
    'model.decoder.class_embed.1.weight': 'class_embed.0.weight',
    ...
    'model.decoder.bbox_embed.0.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'model.decoder.bbox_embed.0.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    'model.decoder.bbox_embed.0.layers.1.bias': 'bbox_embed.0.layers.1.bias',
    'model.decoder.bbox_embed.0.layers.1.weight': 'bbox_embed.0.layers.1.weight',
    ...
}
```

yani `_tied_weights_keys` içindeki regex ve modül desenleriyle eşleşen tüm parametreler

#### get_experts_implementation[[transformers.PreTrainedModel.get_experts_implementation]]

```python
get_experts_implementation()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2064)

Bu modelin ve alt modellerinin uzman (experts) uygulamasını, `set_experts_implementation` tarafından kabul edilen biçimde bir `dict` olarak döndürür (`""` bu model için, her sub_config için bir giriş). Bu, `set_experts_implementation`'in karşılığıdır; örneğin mevcut uygulamanın anlık görüntüsünü almak ve daha sonra geri yüklemek için kullanılır.

#### get_memory_footprint[[transformers.PreTrainedModel.get_memory_footprint]]

```python
get_memory_footprint(return_buffers = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L3677)

**Parametreler:**

return_buffers (`bool`, *isteğe bağlı*, varsayılan `True`) : Bellek ayak izinin hesaplanmasında tampon tensörlerinin boyutunun döndürülüp döndürülmeyeceğini belirtir. Tamponlar, gradyan gerektirmeyen ve parametre olarak kaydedilmeyen tensörlerdir. Örneğin, batch norm katmanlarındaki ortalama ve standart sapma. Lütfen şuraya bakın: https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2

Bir modelin bellek ayak izini alın. Bu, mevcut modelin bayt cinsinden bellek ayak izini döndürür. Mevcut modelin bellek ayak izini ölçmek ve bazı testler tasarlamak için faydalıdır. Çözüm, PyTorch tartışmalarından ilham alınarak oluşturulmuştur: https://discuss.pytorch.org/t/gpu-memory-that-model-uses/56822/2

#### get_parameter_or_buffer[[transformers.PreTrainedModel.get_parameter_or_buffer]]

```python
get_parameter_or_buffer(target: str)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L4978)

`target` ile verilen parametreyi veya tamponu (buffer) var ise döndürür, yoksa bir hata fırlatır. Bu, `get_parameter()` ve `get_buffer()` işlevlerini tek bir kullanışlı fonksiyonda birleştirir. Hedef bir `_extra_state` özniteliği ise, modül tarafından sağlanan ek durumu döndürür. Dikkat edin, bu yalnızca `target` modelin bir yaprağı (leaf) ise çalışır.

#### gradient_checkpointing_disable[[transformers.PreTrainedModel.gradient_checkpointing_disable]]

```python
gradient_checkpointing_disable()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L3276)

[activation_checkpointing_disable()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_disable) için kullanımdan kaldırılmış bir takma ad, v6'da kaldırılacaktır.

#### gradient_checkpointing_enable[[transformers.PreTrainedModel.gradient_checkpointing_enable]]

```python
gradient_checkpointing_enable(gradient_checkpointing_kwargs = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L3191)

[activation_checkpointing_enable()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_enable) için kullanımdan kaldırılmış bir takma ad, v6'da kaldırılacaktır.

#### init_weights[[transformers.PreTrainedModel.init_weights]]

```python
init_weights()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L3098)

Gerekirse ağırlıkları başlatın ve bağlayın. Özel bir `PreTrainedModel` kullanıyorsanız, başlatma mantığını `_init_weights` içinde uygulamanız gerekir.

#### initialize_weights[[transformers.PreTrainedModel.initialize_weights]]

```python
initialize_weights()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2386)

Bu, `self.apply(self._initialize_weights)` çağrısına eşdeğerdir ancak bileşik modelleri doğru şekilde işler. Bu işlev, modül grafında rekürsif olarak ilerledikçe modüllere doğru `init_weights` işlevini dinamik olarak yönlendirir. İstediği sayıda alt modeli işleyebilir. Bu işlev olmasaydı, her bileşik modelin en dıştaki `_init_weights` içinde tüm alt modeller üzerinde ikinci kez açıkça rekürsif çalışması gerekirdi; bu durum son derece hata yapmaya yatkın ve verimsizdir.

#### is_custom_code[[transformers.PreTrainedModel.is_custom_code]]

```python
is_custom_code()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L5032)

Mevcut modelin özel kod olup olmadığını, yani kodun hub'dan yüklenmiş olması veya herhangi bir kullanıcıya özel modül/oturumda tanımlanmış olması durumunu döndürür.

#### is_remote_code[[transformers.PreTrainedModel.is_remote_code]]

```python
is_remote_code()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L5026)

Mevcut modelin özel kod olup olmadığını, yani hub'dan yüklenen kod mu yoksa `register_for_auto_class` ile kaydettiğimiz sınıf mı olduğunu döndürür.

#### mark_tied_weights_as_initialized[[transformers.PreTrainedModel.mark_tied_weights_as_initialized]]

```python
mark_tied_weights_as_initialized(loading_info)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L4950)

Daha sonra bağlanacak (dolayısıyla üzerine yazılacak) parametreler üzerinde `_is_hf_initialized` bayrağını ekler; böylece bunların daha sonra başlatılmasını önler. Bu çok önemlidir çünkü çoğu gömme (embedding) bağlıdır ve bunlar devasa parametrelerdir (kelime dağları genellikle 256k boyutundadır), dolayısıyla bunlar üzerinde başlatma işlemlerini çalıştırmak çok maliyetlidir.

#### named_non_persistent_buffers[[transformers.PreTrainedModel.named_non_persistent_buffers]]

```python
named_non_persistent_buffers(recurse: bool = True, remove_duplicate: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L5002)

`named_buffers`'a benzer, ancak yalnızca kalıcı olmayanları döndürür. Kalıcı olup olmadıklarını kesin olarak bilmek her zaman kolay olmadığından bu özellik işe yarar.

#### post_init[[transformers.PreTrainedModel.post_init]]

```python
post_init()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L1289)

Her Transformer modelinin başlatılmasının sonunda çalıştırılan bir yöntemdir; modelin modüllerinin düzgün şekilde başlatılmasını gerektiren kodun (ağırlık başlatma gibi) çalıştırılmasını sağlar. Ayrıca, bileşik modellerde (yani üst düzey modelin, alt modellerinden bu özellikleri bilmesi gereken durumlarda) tüm doğru statik özelliklerin (paralelleştirme planları, tied_weights_keys, _keep_in_fp32_modules vb.) doğru şekilde elde edilmesinde de kullanılır.

#### register_for_auto_class[[transformers.PreTrainedModel.register_for_auto_class]]

```python
register_for_auto_class(auto_class = 'AutoModel')
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L4657)

**Parametreler:**

auto_class (`str` veya `type`, *opsiyonel*, varsayılan `"AutoModel"`) : Bu yeni modelin kaydedileceği auto sınıfı.

Bu sınıfı, verilen bir otomatik sınıfa kaydedin. Bu, kütüphanedeki sınıflar zaten bir otomatik sınıfa eşlenmiş olduğu için yalnızca özel modeller için kullanılmalıdır.

#### resize_token_embeddings[[transformers.PreTrainedModel.resize_token_embeddings]]

```python
resize_token_embeddings(new_num_tokens: int | None = None, pad_to_multiple_of: int | None = None, mean_resizing: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2633)

**Parametreler:**

new_num_tokens (`int`, *opsiyonel*) : Gömme matrisindeki yeni token sayısı. Boyutu artırmak, sona yeni başlatılmış vektörler ekler. Boyutu azaltmak, vektörleri sondan kaldırır. Verilmezse veya `None` ise, hiçbir işlem yapmadan modelin girdi tokenları `torch.nn.Embedding` modülüne bir işaretçi döndürür.

pad_to_multiple_of (`int`, *isteğe bağlı*) : Ayarlanırsa, gömme matrisi verilen değerin katına kadar doldurulur. `new_num_tokens` `None` olarak ayarlanırsa, gömme yalnızca `pad_to_multiple_of` değerinin katına kadar doldurulur. Bu, hesaplama yeteneği `>= 7.5` (Volta) olan NVIDIA donanımlarında Tensor Core kullanımını etkinleştirmek veya 128'in katı olan dizi uzunluklarından faydalanan TPU'lar için özellikle faydalıdır. Bu konuyla ilgili daha fazla ayrıntı için veya yeniden boyutlandırmada doğru değeri seçme konusunda yardım için bu kılavuza başvurun: https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc

mean_resizing (`bool`) : Eklenen gömme değerlerinin, eski gömme değerlerinin ortalama ve kovaryansına sahip çok değişkenli normal dağılımdan mı yoksa ortalaması sıfır ve standart sapması `config.initializer_range` olan normal dağılımdan mı başlatılacağını belirtir. `mean_resizing` parametresini `True` olarak ayarlamak, nedensel dil modellerinde gömme boyutunu artırdığında faydalıdır; çünkü yeni gömme değerlerini eski gömme değerlerinin ortalamasıyla başlatmak, yeni gömme değerleri eklendikten önce ve sonra bir sonraki token olasılığı arasındaki kl-divergence'ı azaltacağından, üretilen token'ların olasılıkları eklenen gömme değerlerinden etkilenmez. Daha fazla bilgi için bu makaleye bakın: https://nlp.stanford.edu/~johnhew/vocab-expansion.html

**Dönüş:** `torch.nn.Embedding`

Modelin girdi token'ları Gömme Modülü'ne işaretçi.

`new_num_tokens != config.vocab_size` ise modelin girdi token gömme matrisini yeniden boyutlandırır.

Model sınıfının `tie_weights()` metodu varsa, sonrasında ağırlık gömme bağlamasını (weight tying) gerçekleştirir.

#### save_pretrained[[transformers.PreTrainedModel.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, is_main_process: bool = True, state_dict: dict | None = None, push_to_hub: bool = False, max_shard_size: int | str = '50GB', variant: str | None = None, token: str | bool | None = None, save_peft_format: bool = True, save_original_format: bool = True, distributed_checkpoint: bool = False, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L3310)

**Parametreler:**

save_directory (`str` veya `os.PathLike`) : Kaydedilecek dizin. Var değilse oluşturulur.

is_main_process (`bool`, *isteğe bağlı*, varsayılan `True`) : Bu işlemi çağıran sürecin ana süreç olup olmadığını belirtir. TPU'lar gibi dağıtık eğitim senaryolarında, bu fonksiyonun tüm süreçlerde çağrılması gerektiğinde kullanışlıdır. Bu durumda, yarış durumlarını (race condition) önlemek için `is_main_process=True` değerini yalnızca ana süreçte ayarlayın.

state_dict (`torch.Tensor` içeren iç içe sözlük) : Kaydedilecek modelin durum sözlüğü. Varsayılan olarak `self.state_dict()` kullanılır, ancak modelin yalnızca belirli kısımlarını kaydetmek veya bir modelin durum sözlüğünü geri yüklerken özel önlemler alınması gerektiğinde (örneğin model paralelliği kullanılırken) kullanılabilir.

push_to_hub (`bool`, *isteğe bağlı*, varsayılan `False`) : Modeli kaydettikten sonra Hugging Face model hub'ına gönderip göndermeyeceğinizi belirtir. Göndermek istediğiniz depoyu `repo_id` ile belirleyebilirsiniz (varsayılan olarak ad alanınızdaki `save_directory` adı kullanılır).

max_shard_size (`int` veya `str`, *isteğe bağlı*, varsayılan `"50GB"`) : Bir kontrol noktasının parçalanmadan önceki maksimum boyutu. Kontrol noktası parçaları, bu boyuttan küçük olacak şekilde oluşturulur. Dize olarak ifade ediliyorsa, birimle (örneğin `"5MB"`) birlikte rakamlardan oluşmalıdır.    Modelin tek bir ağırlığı `max_shard_size` değerinden büyükse, kendi kontrol noktası parçasında yer alır ve bu parça `max_shard_size` değerinden büyük olur.

variant (`str`, *isteğe bağlı*) : Belirtilirse, ağırlıklar model..safetensors biçiminde kaydedilir.

token (`str` veya `bool`, *isteğe bağlı*) : Uzaktaki dosyalar için HTTP bearer yetkilendirmesi olarak kullanılacak belirteç. `True` ise veya belirtilmezse, `hf auth login` çalıştırıldığında oluşturulan belirteç ( `~/.huggingface` içinde saklanır) kullanılır.

save_peft_format (`bool`, *isteğe bağlı*, varsayılan `True`) : PEFT kütüphanesiyle geriye dönük uyumluluk için, modelin üzerine adaptör ağırlıkları bağlanmışsa, adaptörlerin durum sözlüğündeki tüm anahtarların başına `base_model.model` eklenmelidir. Gelişmiş kullanıcılar, `save_peft_format` değerini `False` olarak ayarlayarak bu davranışı devre dışı bırakabilir.

save_original_format (`bool`, *isteğe bağlı*, varsayılan `True`) : `transformers`'in önceki sürümleriyle geriye dönük uyumluluk için kontrol noktasını ters eşlemesiyle birlikte kaydedebilirsiniz. Model, None eski kontrol noktasından yüklense bile ters eşleme var olmalıdır.

distributed_checkpoint (`bool`, *isteğe bağlı*, varsayılan `False`) : FSDP veya TP ile bölünmüş bir modeli kaydetirken, ağırlıkları önce CPU'ya toplamak yerine dağıtık denetleme noktası (DCP) ile safetensors yazılır. Her rank bu yöntemi çağırmalıdır. `False` olduğunda, yazmadan önce ağırlıklar `gather_full_state_dict` ile rank 0'da CPU'ya toplanır. Yalnızca eğitimden kaydetmek ve devam etmek için tasarlanmıştır; tam `save_pretrained` özelliklerini kullanmak istiyorsanız `False` olarak ayarlayın. `push_to_hub=True` ile rank 0, denetleme noktasını `consolidated/` alt dizininde birleştirir ve bu dizini yükler. `torch>=2.7` gerektirir.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : [push_to_hub()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) yöntemine iletilen ek anahtar kelime argümanları.

Bir modeli ve yapılandırma dosyasını bir dizine kaydedin; böylece [from_pretrained()](/docs/transformers/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) sınıf yöntemi kullanılarak yeniden yüklenebilir.

#### set_attn_implementation[[transformers.PreTrainedModel.set_attn_implementation]]

```python
set_attn_implementation(attn_implementation: str | dict, allow_all_kernels: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L1960)

**Parametreler:**

attn_implementation (`str` veya `dict`) : Bu model için ayarlanacak dikkat uygulaması. Bir `str` olabilir; bu durumda ilgili tüm alt modellere yönlendirilir. Ya da anahtarları sub_configs adları olan bir `dict` olabilir; bu durumda her alt model, kendisine ve içindeki tüm alt modellere karşılık gelen değeri yönlendirir. Bir değer, aynı formatta bir `dict` olabilir; bu, o alt modelin sub_configs'lerini hedeflemek içindir (iç içe geçmiş bir `attn_implementation` dict'i ile bir config başlatırken olduğu gibi).

allow_all_kernels (`bool`, isteğe bağlı) : `attn_implementation`, `kernels-community` hub deposunun dışında özel bir çekirdekse, çekirdeklerin doğrulanmamış hub depolarından yüklenip yüklenmeyeceğini belirtir.

Bu model için istenen `attn_implementation` değerini ayarlayın.

#### set_decoder[[transformers.PreTrainedModel.set_decoder]]

```python
set_decoder(decoder)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2277)

Simetrik ayarlayıcı. `get_decoder` içinde kullanılan arama mantığını yansıtır.

#### set_encoder[[transformers.PreTrainedModel.set_encoder]]

```python
set_encoder(encoder, modality: str | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2228)

Simetrik ayarlayıcı. `get_encoder` içinde kullanılan arama mantığını yansıtır.

#### set_experts_implementation[[transformers.PreTrainedModel.set_experts_implementation]]

```python
set_experts_implementation(experts_implementation: str | dict)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2077)

**Parametreler:**

experts_implementation (`str` veya `dict`) : Bu model için ayarlanacak uzmanlar uygulaması. İlgili durumlarda tüm alt modellere yönlendirilecek bir `str` olabilir veya anahtarları sub_configs adları olan bir `dict` olabilir; bu durumda her alt model ilgili değeri yönlendirir.

Bu model için istenen `experts_implementation` değerini ayarlayın.

#### set_use_kernels[[transformers.PreTrainedModel.set_use_kernels]]

```python
set_use_kernels(use_kernels, kernel_config: transformers.utils.kernel_config.KernelConfig | None = None, mode: Mode | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L3851)

**Parametreler:**

use_kernels (`bool`) : Modelin bazı katmanlarını kernelize etmek için `kernels` kütüphanesinin kullanılıp kullanılmayacağı.

kernel_config (`KernelConfig`, *isteğe bağlı*) : Modeli kernelize etmek için kullanılacak kernel yapılandırması. `None` ise, varsayılan kernel eşlemesi kullanılır.

mode (`Mode`, *isteğe bağlı*) : `kernelize` sırasında uygulanacak mod. İsteğe bağlıdır; varsayılan olarak, dahili `training` bayrağına göre eğitim veya çıkarım modu olarak ayarlanır.

Modelin bazı katmanlarını çekirdeklemek için `kernels` kütüphanesinin kullanılıp kullanılmayacağını belirleyin.

#### tie_weights[[transformers.PreTrainedModel.tie_weights]]

```python
tie_weights(missing_keys: set[str] | None = None, recompute_mapping: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L2530)

Model ağırlıklarını bağlayın. `recompute_mapping=False` ise (içeriden çağrıldığında varsayılan), bağlı parametreler için `{target: source}` eşlemesini içeren `model.all_tied_weights_keys` özniteliğine dayanır. `recompute_mapping=True` ise, bağlanması gereken parametreleri belirlemek için tüm iç alt modelleri ve yapılandırmalarını yeniden kontrol eder. Yapılandırma değerleri bir yerde değiştirilmiş olabileceğinden, `model.tie_weights()` `__init__` ve `from_pretrained` dışında kendi başına çağrıldığında varsayılan budur.

Not edin ki `from_pretrained` sırasında bağlama işlemi *simetriktir*: eşleme "tie target -> source" derken `source` checkpoint'te yoksa ancak `target` mevcutsa, her şeyi gerçekten var olan parametreye bağlayabilmek için kaynak ve hedefi *değiştiririz*.

#### 'e[[transformers.PreTrainedModel.to]]

```python
to(*args, **kwargs)
```

Noktalı bir yol için sahte bir değer (ör. `torch.float32`): öznitelik erişim zincirleri, çağrılar geçiş (pass-through) dekoratörleri gibi davranır, `repr` noktalı yoldur ve bir taban sınıf olarak kullanıldığında düz bir `type` tabanı yerleştirilir (PEP 560 `__mro_entries__`), böylece gerçek alt sınıflar normal bir metasınıfı korur ve `inspect.signature` sahtenin yerine gerçek `__init__` değerlerini okur.

#### warn_if_padding_and_no_attention_mask[[transformers.PreTrainedModel.warn_if_padding_and_no_attention_mask]]

```python
warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L4679)

Girdi input_ids dolgular içeriyor gibi görünüyorsa ve dikkat maskesi verilmediyse, tek seferlik bir uyarı gösterir.

Özel modeller, ilgili modele superfast init'in uygulanıp uygulanamayacağını belirleyen `_supports_assign_param_buffer` öğesini de içermelidir. Modelinizin buna ihtiyacı olduğuna dair bir işaret, `test_save_and_load_from_pretrained` testinin başarısız olmasıdır. Bu durumda bu değeri `False` olarak ayarlayın.

## ModuleUtilsMixin[[transformers.modeling_utils.ModuleUtilsMixin]]

#### transformers.modeling_utils.ModuleUtilsMixin[[transformers.modeling_utils.ModuleUtilsMixin]]

```python
transformers.modeling_utils.ModuleUtilsMixin()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L894)

`torch.nn.Modules` için, bir mixin olarak kullanılacak birkaç yardımcı araç.

#### num_parameters[[transformers.modeling_utils.ModuleUtilsMixin.num_parameters]]

```python
num_parameters(only_trainable: bool = False, exclude_embeddings: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L914)

**Parametreler:**

only_trainable (`bool`, *isteğe bağlı*, varsayılan `False`) : Yalnızca eğilebilir parametre sayısının döndürülüp döndürülmeyeceğini belirtir

exclude_embeddings (`bool`, *isteğe bağlı*, varsayılan `False`) : Yalnızca gömme olmayan parametre sayısını döndürüp döndürmeyeceği

**Dönüş:** `int`

Parametre sayısı.

Modüldeki (isteğe bağlı olarak, eğitilebilir veya gömme olmayan) parametre sayısını alın.

## Hub'a İtme[[transformers.utils.PushToHubMixin]]

#### transformers.utils.PushToHubMixin[[transformers.utils.PushToHubMixin]]

```python
transformers.utils.PushToHubMixin()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/hub.py#L728)

Hub'a bir model veya tokenizer gönderme işlevselliğini içeren bir Mixin.

#### push_to_hub[[transformers.utils.PushToHubMixin.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/hub.py#L822)

**Parametreler:**

repo_id (`str`) : {object} öğenizi göndermek istediğiniz deposunun adı. Belirli bir organizasyona gönderim yaparken organizasyon adınızı içermelidir.

commit_message (`str`, *isteğe bağlı*) : İterilirken taahhüt edilecek mesaj. Varsayılan olarak `"Upload {object}"` olur.

commit_description (`str`, *isteğe bağlı*) : Oluşturulacak commit'in açıklaması

private (`bool`, *isteğe bağlı*) : Deponun özel yapılıp yapılmayacağını belirtir. `None` (varsayılan) ise, organizasyonun varsayılanı özel değilse depo herkese açık olur. Depo zaten mevcutsa bu değer yok sayılır.

token (`bool` veya `str`, *isteğe bağlı*) : Uzaktaki dosyalar için HTTP bearer yetkilendirmesi olarak kullanılacak belirteç. `True` (varsayılan) ise, `hf auth login` çalıştırıldığında oluşturulan belirteç ( `~/.huggingface` içinde saklanır) kullanılır.

revision (`str`, *isteğe bağlı*) : Yüklenen dosyaların itileceği dal.

create_pr (`bool`, *isteğe bağlı*, varsayılan `False`) : Yüklenen dosyalarla bir PR oluşturulup oluşturulmayacağı veya doğrudan commit atılıp atılmayacağı.

max_shard_size (`int` veya `str`, *isteğe bağlı*, varsayılan `"50GB"`) : Yalnızca modeller için geçerlidir. Bir checkpoint'in parçalanmadan önceki maksimum boyutu. Parçalanan checkpoint'lerin her biri bu boyuttan küçük olacaktır. Dize olarak ifade ediliyorsa, birimle (örneğin `"5MB"`) birlikte rakamlardan oluşmalıdır.

tags (`list[str]`, *isteğe bağlı*) : Hub'a itilecek etiketlerin listesi.

{object_files} dosyalarını 🤗 Model Hub'a yükleyin.

Örnekler:

```python
from transformers import {object_class}

{object} = {object_class}.from_pretrained("google-bert/bert-base-cased")

# Push the {object} to your namespace with the name "my-finetuned-bert".
{object}.push_to_hub("my-finetuned-bert")

# Push the {object} to an organization with the name "my-finetuned-bert".
{object}.push_to_hub("huggingface/my-finetuned-bert")
```