# Model

🤗 Diffusers menyediakan model terlatih untuk algoritma populer dan modul untuk membuat sistem difusi kustom. Fungsi utama dari model adalah untuk menghilangkan noise dari sampel input sebagaimana dimodelkan oleh distribusi \\(p_{\theta}(x_{t-1}|x_{t})\\).

Semua model dibangun dari kelas dasar [ModelMixin](/docs/diffusers/v0.43.0/id/api/models/overview#diffusers.ModelMixin) yang merupakan [`torch.nn.Module`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html) yang menyediakan fungsionalitas dasar untuk menyimpan dan memuat model, baik secara lokal maupun dari Hugging Face Hub.

## ModelMixin[[diffusers.ModelMixin]]

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

```python
diffusers.ModelMixin()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L240)

Kelas dasar untuk semua model.

[ModelMixin](/docs/diffusers/v0.43.0/id/api/models/overview#diffusers.ModelMixin) menangani penyimpanan konfigurasi model dan menyediakan metode untuk memuat, mengunduh, dan menyimpan model.

- **config_name** (`str`) -- Nama file untuk menyimpan model saat memanggil [save_pretrained()](/docs/diffusers/v0.43.0/id/api/models/overview#diffusers.ModelMixin.save_pretrained).

#### compile_repeated_blocks[[diffusers.ModelMixin.compile_repeated_blocks]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L1646)

Mengompilasi *hanya* sub-modul yang sering diulang dari sebuah model (misalnya lapisan Transformer) alih-alih mengompilasi seluruh model. Teknik ini—sering disebut **kompilasi regional** (lihat resep PyTorch https://docs.pytorch.org/tutorials/recipes/regional_compilation.html) dapat mengurangi waktu kompilasi end-to-end secara signifikan, sambil mempertahankan peningkatan kecepatan runtime yang Anda harapkan dari `torch.compile` penuh.

Set sub-modul yang akan dikompilasi ditemukan melalui keberadaan atribut **`_repeated_blocks`** dalam definisi model. Definisikan atribut ini pada subclass model Anda sebagai list/tuple dari nama kelas (string). Setiap modul yang nama kelasnya cocok akan dikompilasi.

Setelah ditemukan, setiap sub-modul yang cocok dikompilasi dengan memanggil `submodule.compile(*args, **kwargs)`. Argumen posisi atau kata kunci apa pun yang Anda berikan ke `compile_repeated_blocks` diteruskan apa adanya ke `torch.compile`.

#### cuda[[diffusers.ModelMixin.cuda]]

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

Nilai mock untuk jalur bertitik (mis. `torch.float32`): rantai akses atribut, panggilan berperilaku sebagai dekorator pass-through, `repr` adalah jalur bertitik, dan penggunaannya sebagai kelas dasar menggantikan kelas dasar `type` polos (PEP 560 `__mro_entries__`), sehingga subclass asli tetap mempertahankan metaclass normal dan `inspect.signature` membaca `__init__` asli mereka, bukan milik mock.

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

```python
dequantize()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L890)

Potensi dequantize model jika model tersebut telah dikuantisasi dengan metode kuantisasi yang mendukung dequantization.

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

```python
disable_gradient_checkpointing()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L323)

Menonaktifkan gradient checkpointing untuk model saat ini (dapat disebut sebagai *activation checkpointing* atau *checkpoint activations* di framework lain).

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

```python
disable_npu_flash_attention()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L354)

nonaktifkan npu flash attention dari torch_npu

#### disable_xformers_memory_efficient_attention[[diffusers.ModelMixin.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L437)

Nonaktifkan perhatian hemat memori dari [xFormers](https://facebookresearch.github.io/xformers/).

#### disable_xla_flash_attention[[diffusers.ModelMixin.disable_xla_flash_attention]]

```python
disable_xla_flash_attention()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L384)

Nonaktifkan kernel pallals flash attention untuk torch_xla.

#### enable_gradient_checkpointing[[diffusers.ModelMixin.enable_gradient_checkpointing]]

```python
enable_gradient_checkpointing(gradient_checkpointing_func: typing.Optional[typing.Callable] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L294)

**Parameter:**

gradient_checkpointing_func (`Callable`, *opsional*) : Fungsi yang digunakan untuk gradient checkpointing. Jika `None`, fungsi checkpointing PyTorch default digunakan (`torch.utils.checkpoint.checkpoint`).

Mengaktifkan gradient checkpointing untuk model saat ini (dapat disebut sebagai *activation checkpointing* atau *checkpoint activations* di framework lain).

#### 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L528)

Mengaktifkan offloading grup untuk model saat ini.

Lihat [apply_group_offloading()](/docs/diffusers/v0.43.0/id/api/utilities#diffusers.hooks.apply_group_offloading) untuk informasi lebih lanjut.

Contoh:

```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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L443)

**Parameter:**

storage_dtype (`torch.dtype`) : dtype yang harus digunakan untuk meng-cast model agar dapat disimpan.

compute_dtype (`torch.dtype`) : dtype yang harus digunakan untuk mengonversi bobot model selama forward pass.

skip_modules_pattern (`tuple[str, ...]`, *opsional*) : Daftar pola untuk mencocokkan nama modul yang akan dilewati selama proses pencetakan per lapisan. Jika diatur ke `None`, pola lompatan default digunakan untuk mengabaikan lapisan internal tertentu dari modul dan lapisan PEFT.

skip_modules_classes (`tuple[Type[torch.nn.Module], ...]`, *opsional*) : Daftar kelas modul yang akan dilewati selama proses pencetakan lapisan demi lapisan.

non_blocking (`bool`, *opsional*, defaultnya `False`) : Jika `True`, operasi casting bobot bersifat non-blocking.

Mengaktifkan pencetakan layerwise untuk model saat ini.

Layerwise casting adalah teknik yang mengubah (cast) bobot model ke dtype presisi yang lebih rendah untuk penyimpanan, tetapi mengubahnya (upcast) secara langsung ke dtype presisi yang lebih tinggi untuk komputasi. Proses ini dapat mengurangi jejak memori dari bobot model secara signifikan, tetapi dapat menyebabkan penurunan kualitas tertentu pada output. Sebagian besar penurunan kualitas dapat diabaikan, terutama berasal dari pengubahan bobot pada lapisan normalisasi dan modulasi.

Secara default, sebagian besar model di diffusers menetapkan atribut `_skip_layerwise_casting_patterns` untuk mengabaikan patch embedding, positional embedding, dan lapisan normalisasi. Hal ini karena lapisan-lapisan tersebut kemungkinan besar sangat kritis terhadap presisi untuk kualitas. Jika Anda ingin mengubah perilaku ini, Anda dapat menetapkan atribut `_skip_layerwise_casting_patterns` ke `None`, atau memanggil [apply_layerwise_casting()](/docs/diffusers/v0.43.0/id/api/utilities#diffusers.hooks.apply_layerwise_casting) dengan argumen kustom.

Contoh:

Menggunakan [enable_layerwise_casting()](/docs/diffusers/v0.43.0/id/api/models/overview#diffusers.ModelMixin.enable_layerwise_casting):

```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()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L347)

Aktifkan npu flash attention dari torch_npu

#### 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L405)

**Parameter:**

attention_op (`Callable`, *opsional*) : Menimpa operator `None` bawaan untuk digunakan sebagai argumen `op` pada fungsi [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) dari xFormers.

Aktifkan perhatian hemat memori dari [xFormers](https://facebookresearch.github.io/xformers/).

Ketika opsi ini diaktifkan, Anda seharusnya mengamati penggunaan memori GPU yang lebih rendah dan potensi percepatan selama inferensi. Percepatan selama pelatihan tidak dijamin.

> [!WARNING] > ⚠️ Ketika memory efficient attention dan sliced attention keduanya diaktifkan, memory efficient
attention memiliki > preseden.

Contoh:

```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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L378)

Aktifkan kernel pallals flash attention untuk torch_xla.

#### from_pretrained[[diffusers.ModelMixin.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L902)

**Parameter:**

pretrained_model_name_or_path (`str` atau `os.PathLike`, *opsional*) : Bisa berupa:  - String, *model id* (misalnya `google/ddpm-celebahq-256`) dari model pretrained yang dihosting di Hub. - Path ke *direktori* (misalnya `./my_model_directory`) yang berisi bobot model yang disimpan dengan [save_pretrained()](/docs/diffusers/v0.43.0/id/api/models/overview#diffusers.ModelMixin.save_pretrained).

cache_dir (`str | os.PathLike`, *opsional*) : Path ke direktori tempat konfigurasi model pretrained yang diunduh di-cache jika cache standar tidak digunakan.

dtype (`torch.dtype`, *opsional*) : Menimpa `torch.dtype` bawaan dan memuat model dengan dtype lain.

force_download (`bool`, *opsional*, defaultnya `False`) : Apakah akan memaksa (mengunduh ulang) bobot model dan file konfigurasi, menimpa versi yang di-cache jika ada.

proxies (`dict[str, str]`, *opsional*) : Kamus server proxy yang akan digunakan berdasarkan protokol atau endpoint, misalnya `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Proxy digunakan pada setiap permintaan.

output_loading_info (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengembalikan juga kamus yang berisi kunci yang hilang, kunci yang tidak terduga, dan pesan kesalahan.

local_files_only(`bool`, *opsional*, default `False`) : Apakah hanya memuat bobot model dan file konfigurasi lokal atau tidak. Jika diatur ke `True`, model tidak akan diunduh dari Hub.

token (`str` atau *bool*, *opsional*) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True`, token yang dihasilkan dari `diffusers-cli login` (disimpan di `~/.huggingface`) akan digunakan.

revision (`str`, *opsional*, defaultnya `"main"`) : Versi model spesifik yang akan digunakan. Bisa berupa nama branch, nama tag, id commit, atau identifikasi apa pun yang diizinkan oleh Git.

subfolder (`str`, *opsional*, defaultnya `""`) : Lokasi subfolder dari file model di dalam repositori model yang lebih besar di Hub atau secara lokal.

mirror (`str`, *opsional*) : Sumber cermin untuk menyelesaikan masalah aksesibilitas jika Anda mengunduh model di Tiongkok. Kami tidak menjamin ketepatan waktu atau keamanan sumber, dan Anda harus merujuk ke situs cermin untuk informasi lebih lanjut.

device_map (`int | str | torch.device` atau `dict[str, int | str | torch.device]`, *opsional*) : Peta yang menentukan ke mana setiap submodul harus ditempatkan. Tidak perlu didefinisikan untuk setiap nama parameter/buffer; begitu nama modul tertentu ada di dalamnya, setiap submodulnya akan dikirim ke perangkat yang sama. Defaultnya adalah `None`, yang berarti model akan dimuat di CPU. Contoh: ```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")}, ... ) ``` Setel `device_map="auto"` agar 🤗 Accelerate secara otomatis menghitung `device_map` yang paling dioptimalkan. Untuk informasi lebih lanjut tentang setiap opsi, lihat [mendesain device map](https://huggingface.co/docs/accelerate/en/concept_guides/big_model_inference#the-devicemap). Anda juga dapat merujuk ke [dokumentasi khusus Diffusers](https://huggingface.co/docs/diffusers/main/en/optimization/device_map) untuk contoh yang lebih konkret.

max_memory (`Dict`, *opsional*) : Kamus pengidentifikasi perangkat untuk memori maksimum. Akan secara default menggunakan memori maksimum yang tersedia untuk setiap GPU dan RAM CPU yang tersedia jika tidak disetel.

offload_folder (`str` atau `os.PathLike`, *opsional*) : Path untuk offload weights jika `device_map` berisi nilai `"disk"`.

offload_state_dict (`bool`, *opsional*) : Jika `True`, secara sementara memindahkan state dict CPU ke hard drive untuk menghindari kehabisan RAM CPU jika bobot state dict CPU + shard terbesar dari checkpoint tidak muat. Bawaan adalah `True` jika ada disk offload.

low_cpu_mem_usage (`bool`, *opsional*, defaultnya `True` jika versi torch >= 1.9.0 selain itu `False`) : Mempercepat pemuatan model dengan hanya memuat bobot pretrained dan tidak menginisialisasi bobot. Ini juga berusaha untuk tidak menggunakan lebih dari 1x ukuran model di memori CPU (termasuk memori puncak) saat memuat model. Hanya didukung untuk PyTorch >= 1.9.0. Jika Anda menggunakan versi PyTorch yang lebih lama, mengatur argumen ini ke `True` akan memicu error.

variant (`str`, *opsional*) : Muat bobot dari nama file `variant` yang ditentukan, seperti `"fp16"` atau `"ema"`.

use_safetensors (`bool`, *opsional*, defaultnya `None`) : Jika diatur ke `None`, bobot `safetensors` akan diunduh jika tersedia **dan** jika pustaka `safetensors` terpasang. Jika diatur ke `True`, model dipaksa dimuat dari bobot `safetensors`. Jika diatur ke `False`, bobot `safetensors` tidak dimuat.

disable_mmap ('bool', *opsional*, default 'False') : Apakah akan menonaktifkan mmap saat memuat model Safetensors. Opsi ini dapat memberikan performa yang lebih baik ketika model berada di network mount atau hard drive, yang mungkin tidak menangani sifat seeky dari mmap dengan baik.

use_flashpack (`bool`, *opsional*, defaultnya `False`) : Jika diatur ke `True`, model dimuat dari bobot `flashpack`.

flashpack_kwargs(`dict[str, Any]`, *opsional*, default `{}`) : Kwargs yang diteruskan ke [`flashpack.deserialization.assign_from_file`](https://github.com/fal-ai/flashpack/blob/f1aa91c5cd9532a3dbf5bcc707ab9b01c274b76c/src/flashpack/deserialization.py#L408-L422)

Instansiasi model PyTorch pretrained dari konfigurasi model pretrained.

Model diatur dalam mode evaluasi - `model.eval()` - secara default, dan modul dropout dinonaktifkan. Untuk melatih model, kembalikan ke mode pelatihan dengan `model.train()`.

> [!TIP] > Untuk menggunakan model privat atau [model bergerbang](https://huggingface.co/docs/hub/models-gated#gated-models), masuk
dengan `hf > auth login`. Anda juga dapat mengaktifkan mode khusus > ["offline-mode"](https://huggingface.co/diffusers/installation.html#offline-mode) untuk menggunakan metode ini di lingkungan yang > dibatasi firewall.

Contoh:

```py
from diffusers import UNet2DConditionModel

unet = UNet2DConditionModel.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", subfolder="unet")
```

Jika Anda menerima pesan kesalahan di bawah ini, Anda perlu melakukan penyesuaian bobot untuk tugas turunan Anda:

```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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L2154)

**Parameter:**

return_buffers (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan ukuran tensor buffer dalam perhitungan jejak memori. Buffer adalah tensor yang tidak memerlukan gradien dan tidak terdaftar sebagai parameter. Contoh: mean dan std pada lapisan batch norm. Silakan lihat: https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2

Dapatkan jejak memori dari sebuah model. Ini akan mengembalikan jejak memori dari model saat ini dalam byte. Berguna untuk melakukan benchmark jejak memori dari model saat ini dan merancang beberapa pengujian. Solusi terinspirasi dari diskusi PyTorch: 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L2090)

**Parameter:**

only_trainable (`bool`, *opsional*, defaultnya `False`) : Apakah hanya mengembalikan jumlah parameter yang dapat dilatih.

exclude_embeddings (`bool`, *opsional*, defaultnya `False`) : Apakah hanya mengembalikan jumlah parameter non-embedding.

**Mengembalikan:** `int`

Jumlah parameter.

Dapatkan jumlah parameter (yang dapat dilatih atau non-embedding) dalam modul.

Contoh:

```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()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L663)

Mengatur ulang backend perhatian untuk model. Panggilan ke `forward` selanjutnya akan menggunakan default lingkungan, jika diatur, atau scaled dot product attention native torch.

#### 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L682)

**Parameter:**

save_directory (`str` atau `os.PathLike`) : Direktori untuk menyimpan model dan file konfigurasinya. Akan dibuat jika belum ada.

is_main_process (`bool`, *opsional*, defaultnya `True`) : Apakah proses yang memanggil ini adalah proses utama atau tidak. Berguna selama pelatihan terdistribusi dan Anda perlu memanggil fungsi ini di semua proses. Dalam kasus ini, atur `is_main_process=True` hanya pada proses utama untuk menghindari kondisi balapan.

save_function (`Callable`) : Fungsi yang digunakan untuk menyimpan state dictionary. Berguna selama pelatihan terdistribusi ketika Anda perlu mengganti `torch.save` dengan metode lain. Dapat dikonfigurasi dengan variabel lingkungan `DIFFUSERS_SAVE_MODE`.

safe_serialization (`bool`, *opsional*, defaultnya `True`) : Apakah model disimpan menggunakan `safetensors` atau cara tradisional PyTorch dengan `pickle`.

variant (`str`, *opsional*) : Jika ditentukan, bobot disimpan dalam format `pytorch_model.<variant>.bin`.

max_shard_size (`int` atau `str`, defaultnya `"10GB"`) : Ukuran maksimum untuk checkpoint sebelum di-shard. Checkpoint yang di-shard kemudian akan masing-masing berukuran lebih kecil dari ukuran ini. Jika dinyatakan sebagai string, harus berupa angka diikuti oleh satuan (seperti `"5GB"`). Jika dinyatakan sebagai integer, satuannya adalah byte. Perhatikan bahwa batas ini akan dikurangi setelah periode waktu tertentu (mulai dari Okt 2024) untuk memungkinkan pengguna melakukan upgrade ke versi terbaru dari `diffusers`. Hal ini dilakukan untuk menetapkan ukuran default yang umum untuk argumen ini di antara berbagai pustaka dalam ekosistem Hugging Face (misalnya `transformers`, dan `accelerate`).

push_to_hub (`bool`, *opsional*, defaultnya `False`) : Apakah model akan didorong ke Hugging Face Hub setelah disimpan. Anda dapat menentukan repositori tujuan dengan `repo_id` (defaultnya adalah nama `save_directory` di namespace Anda).

kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan yang diteruskan ke metode [push_to_hub()](/docs/diffusers/v0.43.0/id/api/schedulers/overview#diffusers.utils.PushToHubMixin.push_to_hub).

Simpan model dan file konfigurasinya ke sebuah direktori agar dapat dimuat ulang menggunakan metode kelas [from_pretrained()](/docs/diffusers/v0.43.0/id/api/models/overview#diffusers.ModelMixin.from_pretrained).

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L604)

**Parameter:**

backend (`str`) : Nama backend yang akan disetel. Harus salah satu dari backend yang tersedia yang didefinisikan dalam `AttentionBackendName`. Backend yang tersedia dapat ditemukan di `diffusers.attention_dispatch.AttentionBackendName`. Secara default menggunakan torch native scaled dot product attention sebagai backend.

Atur backend perhatian untuk model.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_utils.py#L331)

Atur sakelar untuk npu flash attention.

#### ke[[diffusers.ModelMixin.to]]

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

Nilai mock untuk jalur bertitik (mis. `torch.float32`): rantai akses atribut, panggilan berperilaku sebagai dekorator pass-through, `repr` adalah jalur bertitik, dan penggunaannya sebagai kelas dasar menggantikan kelas dasar `type` polos (PEP 560 `__mro_entries__`), sehingga subclass asli tetap mempertahankan metaclass normal dan `inspect.signature` membaca `__init__` asli mereka, bukan milik mock.

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

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L491)

Mixin untuk mendorong model, scheduler, atau pipeline ke Hugging Face Hub.

#### 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/utils/hub_utils.py#L526)

**Parameter:**

repo_id (`str`) : Nama repositori tempat Anda ingin mendorong file model, scheduler, atau pipeline Anda. Seharusnya berisi nama organisasi Anda saat mendorong ke organisasi. `repo_id` juga bisa berupa path ke direktori lokal.

commit_message (`str`, *opsional*) : Pesan untuk commit saat push. Default ke `"Upload {object}"`.

private (`bool`, *opsional*) : Apakah membuat repo menjadi privat. Jika `None` (default), repo akan menjadi publik kecuali default organisasi adalah privat. Nilai ini diabaikan jika repo sudah ada.

token (`str`, *opsional*) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Token yang dihasilkan saat menjalankan `hf auth login` (disimpan di `~/.huggingface`).

create_pr (`bool`, *opsional*, defaultnya `False`) : Apakah akan membuat PR dengan file yang diunggah atau langsung melakukan commit.

safe_serialization (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengonversi bobot model ke format `safetensors` atau tidak.

variant (`str`, *opsional*) : Jika ditentukan, bobot disimpan dalam format `pytorch_model.<variant>.bin`.

Unggah file model, scheduler, atau pipeline ke 🤗 Hugging Face Hub.

Contoh:

```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")
```