# Reprodusibilitas

Diffusion adalah proses acak yang menghasilkan output berbeda setiap kali. Untuk kasus penggunaan seperti pengujian dan replikasi hasil, Anda ingin menghasilkan hasil yang sama setiap kali, di antara rilis dan platform dalam rentang toleransi tertentu.

Panduan ini akan menunjukkan cara Anda mengendalikan sumber keacakan dan mengaktifkan algoritma deterministik.

## Generator

Pipelines bergantung pada [torch.randn](https://pytorch.org/docs/stable/generated/torch.randn.html), yang menggunakan seed acak yang berbeda setiap kali, untuk membuat tensor berisik awal. Untuk menghasilkan output yang sama di CPU atau GPU, gunakan [Generator](https://docs.pytorch.org/docs/stable/generated/torch.Generator.html) untuk mengelola cara nilai acak dihasilkan.

> [!TIP]
> Jika reproduktibilitas penting, Anda sebaiknya menggunakan `Generator` CPU. Penurunan kinerja sering kali dapat diabaikan dan Anda akan menghasilkan nilai yang lebih mirip.

Gunakan `Generator` CPU ketika Anda mengutamakan reproduktibilitas. RNG CPU lebih stabil di antara berbagai mesin.

Saat Anda meneruskan `Generator` CPU, [randn_tensor()](/docs/diffusers/v0.43.0/id/api/utilities#diffusers.utils.torch_utils.randn_tensor) Diffusers mengambil sampel di CPU dan memindahkan tensor ke GPU di dalam pipeline. Anda tidak perlu memanggil `randn_tensor` atau `.to("cuda")` sendiri. `Generator` GPU mengambil sampel langsung di perangkat dan dapat menghasilkan hasil yang berbeda dari CPU.

Gunakan [manual_seed](https://docs.pytorch.org/docs/stable/generated/torch.manual_seed.html) untuk mengatur seed.

```py
import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "Qwen/Qwen-Image", dtype=torch.bfloat16, device_map="cuda"  # or "mps", "xpu", "cpu"
)
generator = torch.manual_seed(0)
image = pipeline(
    prompt="a red apple on a wooden table",
    generator=generator,
    num_inference_steps=4,
).images[0]
```

Buat `Generator` CPU dan atur seed dengan [Generator.manual_seed](https://docs.pytorch.org/docs/stable/generated/torch.Generator.html#torch.Generator.manual_seed).

```py
import torch
from diffusers import DiffusionPipeline

pipeline = DiffusionPipeline.from_pretrained(
    "Qwen/Qwen-Image", dtype=torch.bfloat16, device_map="cpu"
)
generator = torch.Generator(device="cpu").manual_seed(0)
image = pipeline(
    prompt="a red apple on a wooden table",
    generator=generator,
    num_inference_steps=4,
).images[0]
```

Lewatkan objek `Generator` ke pipeline alih-alih seed integer. `Generator` menyimpan keadaan acak yang dikonsumsi dan diperbarui saat Anda menggunakannya. Setelah itu, objek yang sama menghasilkan hasil yang berbeda pada pemanggilan berikutnya, bahkan di antara pipeline, karena keadaannya telah berubah. Set ulang seed-nya atau buat `Generator` baru sebelum setiap pemanggilan ketika Anda membutuhkan seed yang sama lagi.

```py
import torch

prompt = "a red apple on a wooden table"

for _ in range(5):
    generator = torch.manual_seed(0)
    image = pipeline(prompt, generator=generator, num_inference_steps=4).images[0]
```

## Algoritma deterministik

PyTorch mendukung [algoritma deterministik](https://docs.pytorch.org/docs/stable/notes/randomness.html#avoiding-nondeterministic-algorithms) (jika tersedia) untuk operasi tertentu agar menghasilkan hasil yang sama. Algoritma deterministik mungkin lebih lambat dan menurunkan kinerja.

Gunakan `enable_full_determinism()` dari Diffusers untuk mengaktifkan algoritma deterministik.

```py
from diffusers.utils.torch_utils import enable_full_determinism

enable_full_determinism()
```

`enable_full_determinism` bekerja dengan cara:

- Mengatur variabel lingkungan `CUDA_LAUNCH_BLOCKING` menjadi `1`
- Mengatur variabel lingkungan [CUBLAS_WORKSPACE_CONFIG](https://docs.nvidia.com/cuda/cublas/index.html#results-reproducibility) menjadi `:16:8` agar cuBLAS menggunakan tata letak workspace tetap saat runtime
- Memanggil `torch.use_deterministic_algorithms(True)`
- Mengatur `torch.backends.cudnn.deterministic = True`
- Mengatur `torch.backends.cudnn.benchmark = False` agar cuDNN tidak memilih algoritma konvolusi yang berbeda pada setiap eksekusi
- Menonaktifkan TensorFloat32 (TF32) dengan `torch.backends.cuda.matmul.allow_tf32 = False` demi matmul presisi penuh yang lebih akurat

## Langkah selanjutnya

Anda sebaiknya membaca catatan pengembang PyTorch tentang [Reproducibility](https://docs.pytorch.org/docs/stable/notes/randomness.html). Anda dapat mencoba membatasi keacakan, tetapi hal ini tidak *terjamin* bahkan dengan seed yang identik.