Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /tr /api /models /overview.md
mishig
about 16 hours ago
preview code
download
raw
30 kB
# Modeller

🤗 Diffusers, popüler algoritmalar için önceden eğitilmiş modeller ve özel difüzyon sistemleri oluşturmak için modüller sağlar. Modellerin ana işlevi, \\(p_{\theta}(x_{t-1}|x_{t})\\) dağılımı tarafından modellenen bir girdi örneğinin gürültüsünü azaltmaktır.
Tüm modeller, yerel olarak ve Hugging Face Hub'dan modellerin kaydedilmesi ve yüklenmesi için temel işlevselliği sağlayan [`torch.nn.Module`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html) olan temel [ModelMixin](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin) sınıfından oluşturulur.
## ModelMixin[[diffusers.ModelMixin]]
#### diffusers.ModelMixin[[diffusers.ModelMixin]]
```python
diffusers.ModelMixin()
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L243)
Tüm modellerin temel sınıfı.
[ModelMixin](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin), model yapılandırmasının depolanmasından sorumlu olup modelleri yükleme, indirme ve kaydetme yöntemleri sağlar.
- **config_name** (`str`) -- [save_pretrained()](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin.save_pretrained) çağrıldığında bir modelin kaydedileceği dosya adı.
#### compile_repeated_blocks[[diffusers.ModelMixin.compile_repeated_blocks]]
```python
compile_repeated_blocks(*args, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L1678)
Bir modelin yalnızca sık tekrarlanan alt modüllerini (ör. Transformer katmanları) *derler*, tüm modeli derlemez. Bu teknik—genellikle **bölgesel derleme** olarak adlandırılır (PyTorch tarifi: https://docs.pytorch.org/tutorials/recipes/regional_compilation.html)—tam bir `torch.compile`'den beklenen çalışma zamanı hızlandırmalarını korurken uçtan uca derleme süresini önemli ölçüde azaltabilir.

Derlenecek alt modüllerin kümesi, model tanımındaki **`_repeated_blocks`** özniteliğinin varlığıyla belirlenir. Bu özniteliği, model alt sınıfınızda sınıf adlarının (dizelerin) bir listesi/tuplü olarak tanımlayın. Sınıf adı eşleşen her modül derlenecektir.

Keşfedildikten sonra, her eşleşen alt modül `submodule.compile(*args, **kwargs)` çağrılarak derlenir. `compile_repeated_blocks` fonksiyonuna sağladığınız konumsal veya anahtar kelime argümanları, `torch.compile` fonksiyonuna olduğu gibi aktarılır.

#### cuda[[diffusers.ModelMixin.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ı yerine geçer (PEP 560 `__mro_entries__`), böylece gerçek alt sınıflar normal bir meta sınıfı korur ve `inspect.signature` sahtenin yerine gerçek `__init__` değerlerini okur.

#### dequantize[[diffusers.ModelMixin.dequantize]]

```python
dequantize()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L894)

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

#### disable_gradient_checkpointing[[diffusers.ModelMixin.disable_gradient_checkpointing]]

```python
disable_gradient_checkpointing()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L327)

Mevcut model için gradyan denetleme noktasını devre dışı bırakır (diğer çerçevelerde *aktivasyon denetleme noktası* veya *aktivasyon denetleme noktaları* olarak da adlandırılabilir).

#### disable_npu_flash_attention[[diffusers.ModelMixin.disable_npu_flash_attention]]

```python
disable_npu_flash_attention()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L358)

torch_npu'dan npu flash attention'ı devre dışı bırak
#### disable_xformers_memory_efficient_attention[[diffusers.ModelMixin.disable_xformers_memory_efficient_attention]]
```python
disable_xformers_memory_efficient_attention()
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L441)
[xFormers](https://facebookresearch.github.io/xformers/) için bellek verimli dikkati devre dışı bırakın.
#### disable_xla_flash_attention[[diffusers.ModelMixin.disable_xla_flash_attention]]
```python
disable_xla_flash_attention()
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L388)
torch_xla için flash attention pallals çekirdeğini devre dışı bırakın.
#### enable_gradient_checkpointing[[diffusers.ModelMixin.enable_gradient_checkpointing]]
```python
enable_gradient_checkpointing(gradient_checkpointing_func: typing.Optional[typing.Callable] = None)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L297)
**Parametreler:**
gradient_checkpointing_func (`Callable`, *isteğe bağlı*) : Gradyan denetleme noktası için kullanılacak işlev. `None` ise, varsayılan PyTorch denetleme noktası işlevi kullanılır (`torch.utils.checkpoint.checkpoint`).
Mevcut model için gradyan denetleme noktasını etkinleştirir (diğer çerçevelerde *aktivasyon denetleme noktası* veya *aktivasyon denetleme noktaları* olarak da adlandırılabilir).
#### enable_group_offload[[diffusers.ModelMixin.enable_group_offload]]
```python
enable_group_offload(onload_device: device, offload_device: device = torch.device(), offload_type: str = 'block_level', num_blocks_per_group: int | None = None, non_blocking: bool = False, use_stream: bool = False, record_stream: bool = False, low_cpu_mem_usage = False, offload_to_disk_path: str | None = None, block_modules: str | None = None, exclude_kwargs: str | None = None)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L532)
Mevcut model için grup boşaltmayı etkinleştirir.
Daha fazla bilgi için [apply_group_offloading()](/docs/diffusers/main/tr/api/utilities#diffusers.hooks.apply_group_offloading) bölümüne bakın.
Örnek:
```python
>>> from diffusers import CogVideoXTransformer3DModel

>>> transformer = CogVideoXTransformer3DModel.from_pretrained(
...     "THUDM/CogVideoX-5b", subfolder="transformer", torch_dtype=torch.bfloat16
... )

>>> transformer.enable_group_offload(
...     onload_device=torch.device("cuda"),
...     offload_device=torch.device("cpu"),
...     offload_type="leaf_level",
...     use_stream=True,
... )
```
#### enable_layerwise_casting[[diffusers.ModelMixin.enable_layerwise_casting]]
```python
enable_layerwise_casting(storage_dtype: dtype = torch.float8_e4m3fn, compute_dtype: typing.Optional[torch.dtype] = None, skip_modules_pattern: tuple[str, ...] | None = None, skip_modules_classes: tuple[typing.Type[torch.nn.Module], ...] | None = None, non_blocking: bool = False)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L447)
**Parametreler:**
storage_dtype (`torch.dtype`) : Modelin depolama için dönüştürülmesi gereken dtype.

compute_dtype (`torch.dtype`) : İleri geçiş sırasında model ağırlıklarının dönüştürüleceği dtype.
skip_modules_pattern (`tuple[str, ...]`, *isteğe bağlı*) : Katman bazlı dökümleme işlemi sırasında atlanacak modül adlarını eşleştirmek için desenlerin listesi. `None` olarak ayarlanırsa, modüllerin ve PEFT katmanlarının belirli iç katmanlarını yok saymak için varsayılan atlama desenleri kullanılır.
skip_modules_classes (`tuple[Type[torch.nn.Module], ...]`, *isteğe bağlı*) : Katman bazlı dökümleme işlemi sırasında atlanacak modül sınıflarının listesi.
non_blocking (`bool`, *isteğe bağlı*, varsayılan `False`) : `True` ise, ağırlık dönüştürme işlemleri engellenmez.

Mevcut model için katman bazlı dökümlemeyi etkinleştirir.

Katman bazlı dönüştürme (casting), model ağırlıklarını depolama için daha düşük hassasiyetli bir veri türüne (dtype) dönüştüren, ancak hesaplama sırasında bunları anlık olarak daha yüksek hassasiyetli bir veri türüne yükselten bir tekniktir. Bu işlem, model ağırlıklarından kaynaklanan bellek kullanımını önemli ölçüde azaltabilir, ancak çıktılarda bazı kalite düşüşlerine yol açabilir. Çoğu düşüş ihmal edilebilir düzeydedir ve büyük ölçüde normalizasyon ve modülasyon katmanlarındaki ağırlık dönüştürmesinden kaynaklanır.

Varsayılan olarak, diffusers'taki modellerin çoğu, yama gömme, konumsal gömme ve normalizasyon katmanlarını yok saymak için `_skip_layerwise_casting_patterns` özniteliğini ayarlar. Bunun nedeni, bu katmanların kalite açısından büyük olasılıkla hassasiyet açısından kritik olmasıdır. Bu davranışı değiştirmek isterseniz, `_skip_layerwise_casting_patterns` özniteliğini `None` olarak ayarlayabilir veya [apply_layerwise_casting()](/docs/diffusers/main/tr/api/utilities#diffusers.hooks.apply_layerwise_casting) fonksiyonunu özel argümanlarla çağırabilirsiniz.

Örnek:

[enable_layerwise_casting()](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin.enable_layerwise_casting) kullanılarak:

```python
>>> from diffusers import CogVideoXTransformer3DModel
>>> transformer = CogVideoXTransformer3DModel.from_pretrained(
...     "THUDM/CogVideoX-5b", subfolder="transformer", torch_dtype=torch.bfloat16
... )
>>> # Enable layerwise casting via the model, which ignores certain modules by default
>>> transformer.enable_layerwise_casting(storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16)
```

#### enable_npu_flash_attention[[diffusers.ModelMixin.enable_npu_flash_attention]]

```python
enable_npu_flash_attention()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L351)

torch_npu'dan npu flash attention'ı etkinleştirin
#### enable_xformers_memory_efficient_attention[[diffusers.ModelMixin.enable_xformers_memory_efficient_attention]]
```python
enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L409)
**Parametreler:**
attention_op (`Callable`, *isteğe bağlı*) : xFormers'in [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) fonksiyonunda `op` argümanı olarak kullanılmak üzere varsayılan `None` operatörünü geçersiz kılar.
[xFormers](https://facebookresearch.github.io/xformers/) ile bellek verimli dikkati etkinleştirin.
Bu seçenek etkinleştirildiğinde, GPU bellek kullanımının daha düşük olduğunu ve çıkarım sırasında olası bir hızlanma gözlemlemelisiniz. Eğitim sırasında hızlanma garanti edilmez.
> [!WARNING] > ⚠️ Hem memory efficient attention hem de sliced attention etkinleştirildiğinde, memory efficient
attention, > önceliğine sahiptir.
Örnekler:
```py
>>> import torch
>>> from diffusers import UNet2DConditionModel
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> model = UNet2DConditionModel.from_pretrained(
...     "stabilityai/stable-diffusion-2-1", subfolder="unet", torch_dtype=torch.float16
... )
>>> model = model.to("cuda")
>>> model.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
```
#### enable_xla_flash_attention[[diffusers.ModelMixin.enable_xla_flash_attention]]
```python
enable_xla_flash_attention(partition_spec: typing.Optional[typing.Callable] = None, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L382)
torch_xla için flash attention pallals çekirdeğini etkinleştirin.
#### from_pretrained[[diffusers.ModelMixin.from_pretrained]]
```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L906)
**Parametreler:**
pretrained_model_name_or_path (`str` veya `os.PathLike`, *isteğe bağlı*) : Şunlardan biri olabilir:  - Hub'da barındırılan önceden eğitilmiş bir modelin *model kimliği* (örneğin `google/ddpm-celebahq-256`) olan bir dize. - [save_pretrained()](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin.save_pretrained) ile kaydedilmiş model ağırlıklarını içeren bir *dizin* yolu (örneğin `./my_model_directory`).
cache_dir (`str | os.PathLike`, *isteğe bağlı*) : Standart önbellek kullanılmıyorsa, indirilen önceden eğitilmiş model yapılandırmasının önbelleğe alındığı dizinin yolu.

dtype (`torch.dtype`, *isteğe bağlı*) : Varsayılan `torch.dtype` değerini geçersiz kılar ve modeli başka bir dtype ile yükler.

force_download (`bool`, *isteğe bağlı*, varsayılan `False`) : Model ağırlıklarının ve yapılandırma dosyalarının (yeniden) indirilmesinin zorlanıp zorlanmayacağını belirler; önbellekteki sürümler varsa bunların üzerine yazar.
proxies (`dict[str, str]`, *isteğe bağlı*) : Protokol veya uç nokta bazında kullanılacak vekil sunucuların sözlüğü, örneğin `{'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`) : Yalnızca yerel model ağırlıklarının ve yapılandırma dosyalarının yüklenip yüklenmeyeceğini belirtir. `True` olarak ayarlanırsa, model Hub'dan indirilmez.
token (`str` veya *bool*, *isteğe bağlı*) : Uzaktaki dosyalar için HTTP bearer yetkilendirmesi olarak kullanılacak jeton. `True` ise, `diffusers-cli login` ile oluşturulan jeton (`~/.huggingface` içinde saklanır) kullanılır.
revision (`str`, *isteğe bağlı*, varsayılan `"main"`) : Kullanılacak belirli model sürümü. Bir dal adı, etiket adı, commit kimliği veya Git tarafından izin verilen herhangi bir tanımlayıcı olabilir.
subfolder (`str`, *isteğe bağlı*, varsayılan `""`) : Hub'da veya yerel olarak daha büyük bir model deposu içindeki bir model dosyasının alt klasör konumu.
mirror (`str`, *isteğe bağlı*) : Çin'de bir model indiriyorsanız erişilebilirlik sorunlarını çözmek için ayna kaynağı. Kaynağın güncelliğini veya güvenliğini garanti etmiyoruz; daha fazla bilgi için ayna sitesine başvurmalısınız.
device_map (`int | str | torch.device` veya `dict[str, int | str | torch.device]`, *isteğe bağlı*) : Her alt modülün nereye gönderileceğini belirten bir eşleme. Her parametre/buffer adı için tanımlanması gerekmez; belirli bir modül adı bir kez dahil edildiğinde, onun tüm alt modülleri aynı cihaza gönderilir. Varsayılan olarak `None`'dır, bu da modelin CPU üzerinde yükleneceği anlamına gelir. Örnekler: ```py >>> from diffusers import AutoModel >>> import torch  >>> # This works. >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map="cuda" ... ) >>> # This also works (integer accelerator device ID). >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map=0 ... ) >>> # Specifying a supported offloading strategy like "auto" also works. >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map="auto" ... ) >>> # Specifying a dictionary as `device_map` also works. >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", ...     subfolder="unet", ...     device_map={"": torch.device("cuda")}, ... ) ``` En optimize `device_map`'i 🤗 Accelerate tarafından otomatik olarak hesaplatmak için `device_map="auto"` ayarlayın. Her seçenek hakkında daha fazla bilgi için [cihar haritası tasarımı](https://huggingface.co/docs/accelerate/en/concept_guides/big_model_inference#the-devicemap) bölümüne bakın. Daha somut örnekler için [Diffusers'a özgü dokümantasyona](https://huggingface.co/docs/diffusers/main/en/training/distributed_inference#model-sharding) da başvurabilirsiniz.

max_memory (`Dict`, *isteğe bağlı*) : Maksimum bellek için bir sözlük cihaz tanımlayıcısı. Ayarlanmazsa, varsayılan olarak her GPU için kullanılabilir maksimum bellek ve kullanılabilir CPU RAM'i olacaktır.
offload_folder (`str` veya `os.PathLike`, *isteğe bağlı*) : `device_map` değeri `"disk"` içeriyorsa ağırlıkların taşınacağı yol.

offload_state_dict (`bool`, *isteğe bağlı*) : `True` ise, CPU durum sözlüğünün ağırlığı + checkpoint'in en büyük dilimi sığmıyorsa CPU RAM'inin dolmasını önlemek için CPU durum sözlüğü geçici olarak sabit diske aktarılır. Disk aktarımı varsa varsayılan olarak `True` değerine ayarlanır.

low_cpu_mem_usage (`bool`, *isteğe bağlı*, varsayılan olarak PyTorch sürümü >= 1.9.0 ise `True`, aksi halde `False`) : Ağırlıkları başlatmadan yalnızca önceden eğitilmiş ağırlıkları yükleyerek model yüklemesini hızlandırır. Bu, model yüklenirken (tepe bellek dahil) CPU belleğinde model boyutunun 1 katından fazlasını kullanmamaya da çalışır. Yalnızca PyTorch >= 1.9.0 için desteklenir. PyTorch'un daha eski bir sürümünü kullanıyorsanız, bu argümanı `True` olarak ayarlamak bir hata verecektir.
variant (`str`, *isteğe bağlı*) : Ağırlıkları, `"fp16"` veya `"ema"` gibi belirli bir `variant` dosya adından yükler.
use_safetensors (`bool`, *isteğe bağlı*, varsayılan `None`) : `None` olarak ayarlanırsa, `safetensors` ağırlıkları mevcut **ve** `safetensors` kütüphanesi yüklüyse indirilir. `True` olarak ayarlanırsa, model `safetensors` ağırlıklarından zorla yüklenir. `False` olarak ayarlanırsa, `safetensors` ağırlıkları yüklenmez.

disable_mmap ('bool', *isteğe bağlı*, varsayılan 'False') : Bir Safetensors modeli yüklenirken mmap'in devre dışı bırakılıp bırakılmayacağını belirtir. Model bir ağ biriminde veya sabit diskte olduğunda, bu ortamın mmap'in rastgele erişim (seek) davranışını iyi yönetememesi nedeniyle bu seçenek daha iyi performans gösterebilir.
use_flashpack (`bool`, *isteğe bağlı*, varsayılan `False`) : `True` olarak ayarlanırsa, model `flashpack` ağırlıklarından yüklenir.

flashpack_kwargs(`dict[str, Any]`, *isteğe bağlı*, varsayılan `{}`) : [`flashpack.deserialization.assign_from_file`](https://github.com/fal-ai/flashpack/blob/f1aa91c5cd9532a3dbf5bcc707ab9b01c274b76c/src/flashpack/deserialization.py#L408-L422) fonksiyonuna aktarılan Kwargs
Önceden eğitilmiş bir model yapılandırmasından önceden eğitilmiş bir PyTorch modeli örnekleyin.
Model varsayılan olarak değerlendirme moduna ayarlanır - `model.eval()` - ve dropout modülleri devre dışı bırakılır. Modeli eğitmek için `model.train()` ile eğitim moduna geri ayarlayın.
> [!TIP] > Özel veya [korumalı modelleri](https://huggingface.co/docs/hub/models-gated#gated-models) kullanmak için oturum açın
`hf > auth login` ile. Bu yöntemi bir > ["offline-mode"](https://huggingface.co/diffusers/installation.html#offline-mode) ile etkinleştirerek > güvenlik duvarlı bir ortamda da kullanabilirsiniz.
Örnek:
```py
from diffusers import UNet2DConditionModel
unet = UNet2DConditionModel.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", subfolder="unet")
```
Aşağıdaki hata mesajını alıyorsanız, aşağı akış göreviniz için ağırlıkları ince ayar yapmanız gerekir:
```bash
Some weights of UNet2DConditionModel were not initialized from the model checkpoint at stable-diffusion-v1-5/stable-diffusion-v1-5 and are newly initialized because the shapes did not match:
- conv_in.weight: found shape torch.Size([320, 4, 3, 3]) in the checkpoint and torch.Size([320, 9, 3, 3]) in the model instantiated
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
```
#### get_memory_footprint[[diffusers.ModelMixin.get_memory_footprint]]
```python
get_memory_footprint(return_buffers = True)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L2186)
**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
#### num_parameters[[diffusers.ModelMixin.num_parameters]]
```python
num_parameters(only_trainable: bool = False, exclude_embeddings: bool = False)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L2122)
**Parametreler:**
only_trainable (`bool`, *isteğe bağlı*, varsayılan `False`) : Yalnızca eğilebilir parametre sayısını döndürüp döndürmeyeceğ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ğini belirtir.
**Dönüş:** `int`
Parametre sayısı.
Modüldeki (eğitilebilir veya gömme olmayan) parametre sayısını alın.
Örnek:
```py
from diffusers import UNet2DConditionModel
model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
unet = UNet2DConditionModel.from_pretrained(model_id, subfolder="unet")
unet.num_parameters(only_trainable=True)
859520964
```
#### reset_attention_backend[[diffusers.ModelMixin.reset_attention_backend]]
```python
reset_attention_backend()
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L667)
Model için dikkat (attention) arka ucunu sıfırlar. `forward` çağrılarının ardından, ayarlanmışsa ortam varsayılanı, aksi halde torch yerel ölçekli nokta çarpımı dikkati (scaled dot product attention) kullanılır.
#### save_pretrained[[diffusers.ModelMixin.save_pretrained]]
```python
save_pretrained(save_directory: str | os.PathLike, is_main_process: bool = True, save_function: typing.Optional[typing.Callable] = None, safe_serialization: bool = True, variant: str | None = None, max_shard_size: int | str = '10GB', push_to_hub: bool = False, use_flashpack: bool = False, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L686)
**Parametreler:**
save_directory (`str` veya `os.PathLike`) : Bir model ve yapılandırma dosyasının kaydedileceği 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ığı. Dağıtık eğitim sırasında ve bu fonksiyonu tüm süreçlerde çağırmanız 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.

save_function (`Callable`) : Durum sözlüğünü (state dictionary) kaydetmek için kullanılacak işlev. Dağıtık eğitim sırasında `torch.save` yerine başka bir yöntem kullanmanız gerektiğinde faydalıdır. `DIFFUSERS_SAVE_MODE` ortam değişkeni ile yapılandırılabilir.
safe_serialization (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin `safetensors` ile mi yoksa geleneksel PyTorch yöntemiyle `pickle` kullanılarak mı kaydedileceğini belirtir.

variant (`str`, *isteğe bağlı*) : Belirtilirse, ağırlıklar `pytorch_model.<variant>.bin` biçiminde kaydedilir.

max_shard_size (`int` veya `str`, varsayılan `"10GB"`) : Bir kontrol noktasının parçalanmadan önceki maksimum boyutu. Parçalanan kontrol noktalarının her biri bu boyuttan küçük olacaktır. Dize olarak ifade ediliyorsa, birimden (örneğin `"5GB"`) önce rakamlar gelmelidir. Tamsayı olarak ifade ediliyorsa birim bayttır. Belirli bir süre sonra (Ekim 2024'ten itibaren) `diffusers`'ın en son sürümüne yükseltme yapabilmeleri için kullanıcıların bu sınırın düşürüleceğini unutmayın. Bu, Hugging Face ekosistemindeki farklı kütüphaneler (örneğin `transformers` ve `accelerate`) için bu argümana yönelik ortak bir varsayılan boyut belirlemek içindir.

push_to_hub (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelinizi kaydettikten sonra Hugging Face Hub'a 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).

kwargs (`dict[str, Any]`, *isteğe bağlı*) : [push_to_hub()](/docs/diffusers/main/tr/api/schedulers/overview#diffusers.utils.PushToHubMixin.push_to_hub) yöntemine iletilen ek anahtar kelime argümanları.

Bir modeli ve yapılandırma dosyasını, [from_pretrained()](/docs/diffusers/main/tr/api/models/overview#diffusers.ModelMixin.from_pretrained) sınıf yöntemiyle yeniden yüklenebilmesi için bir dizine kaydedin.

#### set_attention_backend[[diffusers.ModelMixin.set_attention_backend]]

```python
set_attention_backend(backend: str)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L608)

**Parametreler:**

backend (`str`) : Ayarlanacak backend'in adı. `AttentionBackendName` içinde tanımlanan mevcut backend'lerden biri olmalıdır. Kullanılabilir backend'ler `diffusers.attention_dispatch.AttentionBackendName` içinde bulunabilir. Varsayılan olarak backend olarak torch native scaled dot product attention kullanılır.

Model için dikkat (attention) arka ucunu ayarlayın.

#### set_use_npu_flash_attention[[diffusers.ModelMixin.set_use_npu_flash_attention]]

```python
set_use_npu_flash_attention(valid: bool)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L335)

npu flash attention için anahtarı ayarlayın.

#### 'e[[diffusers.ModelMixin.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ı yerine geçer (PEP 560 `__mro_entries__`), böylece gerçek alt sınıflar normal bir meta sınıfı korur ve `inspect.signature` sahtenin yerine gerçek `__init__` değerlerini okur.

## PushToHubMixin[[diffusers.utils.PushToHubMixin]]

#### diffusers.utils.PushToHubMixin[[diffusers.utils.PushToHubMixin]]

```python
diffusers.utils.PushToHubMixin()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/utils/hub_utils.py#L491)

Bir model, zamanlayıcı veya hattı Hugging Face Hub'a göndermek için bir Mixin.

#### push_to_hub[[diffusers.utils.PushToHubMixin.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, private: bool | None = None, token: str | None = None, create_pr: bool = False, safe_serialization: bool = True, variant: str | None = None, subfolder: str | None = None)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/utils/hub_utils.py#L526)

**Parametreler:**

repo_id (`str`) : Model, zamanlayıcı veya pipeline dosyalarınızı itmek istediğiniz depoyun adı. Bir organizasyona itme işlemi sırasında organizasyon adınızı içermelidir. `repo_id` ayrıca yerel bir dizine giden bir yol da olabilir.

commit_message (`str`, *isteğe bağlı*) : İterken commit edilecek mesaj. Varsayılan olarak `"Upload {object}"`.
private (`bool`, *isteğe bağlı*) : Depoyu ö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 (`str`, *isteğe bağlı*) : Uzaktaki dosyalar için HTTP bearer yetkilendirmesi olarak kullanılacak jeton. `hf auth login` çalıştırıldığında oluşturulan jeton (`~/.huggingface` içinde saklanır).
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ğı.

safe_serialization (`bool`, *isteğe bağlı*, varsayılan `True`) : Model ağırlıklarının `safetensors` biçimine dönüştürülüp dönüştürülmeyeceği.
variant (`str`, *isteğe bağlı*) : Belirtilirse, ağırlıklar `pytorch_model.<variant>.bin` biçiminde kaydedilir.

Model, zamanlayıcı veya boru hattı dosyalarını 🤗 Hugging Face Hub'a yükleyin.

Örnekler:

```python
from diffusers import UNet2DConditionModel
unet = UNet2DConditionModel.from_pretrained("stabilityai/stable-diffusion-2", subfolder="unet")
# Push the `unet` to your namespace with the name "my-finetuned-unet".
unet.push_to_hub("my-finetuned-unet")
# Push the `unet` to an organization with the name "my-finetuned-unet".
unet.push_to_hub("your-org/my-finetuned-unet")
```
Xet Storage Details

Size:: 30 kB
Xet hash:: b8f2176a2d6ee394805eafb79ef5d776ffe23b4c8e747183f1d946b9aba37445
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.