Buckets:
# Flux
Flux adalah serangkaian model generasi teks-ke-gambar yang didasarkan pada diffusion transformers. Untuk mengetahui lebih lanjut tentang Flux, lihat [artikel blog](https://blackforestlabs.ai/announcing-black-forest-labs/) asli oleh para pencipta Flux, Black Forest Labs.
Checkpoint model asli untuk Flux dapat ditemukan [di sini](https://huggingface.co/black-forest-labs). Kode inferensi asli dapat ditemukan [di sini](https://github.com/black-forest-labs/flux).
> [!TIP]
> Flux dapat cukup mahal untuk dijalankan pada perangkat keras konsumen. Namun, Anda dapat melakukan serangkaian optimasi untuk menjalankannya lebih cepat dan dengan cara yang lebih hemat memori. Lihat [bagian ini](https://huggingface.co/blog/sd3#memory-optimizations-for-sd3) untuk detail lebih lanjut. Selain itu, Flux dapat diuntungkan dari kuantisasi untuk efisiensi memori dengan trade-off pada latensi inferensi. Rujuk [artikel blog ini](https://huggingface.co/blog/quanto-diffusers) untuk mempelajari lebih lanjut. Untuk daftar sumber daya yang komprehensif, lihat [gist ini](https://gist.github.com/sayakpaul/b664605caf0aa3bf8585ab109dd5ac9c).
>
> [Caching](../../optimization/cache) juga dapat mempercepat inferensi dengan menyimpan dan menggunakan kembali output antara.
Flux hadir dalam varian berikut:
| tipe model | id model |
|:----------:|:--------:|
| Timestep-distilled | [`black-forest-labs/FLUX.1-schnell`](https://huggingface.co/black-forest-labs/FLUX.1-schnell) |
| Guidance-distilled | [`black-forest-labs/FLUX.1-dev`](https://huggingface.co/black-forest-labs/FLUX.1-dev) |
| Isi Inpainting/Outpainting (Guidance-distilled) | [`black-forest-labs/FLUX.1-Fill-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Fill-dev) |
| Canny Control (Guidance-distilled) | [`black-forest-labs/FLUX.1-Canny-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev) |
| Kontrol Kedalaman (Guidance-distilled) | [`black-forest-labs/FLUX.1-Depth-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev) |
| Canny Control (LoRA) | [`black-forest-labs/FLUX.1-Canny-dev-lora`](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev-lora) |
| Kontrol Kedalaman (LoRA) | [`black-forest-labs/FLUX.1-Depth-dev-lora`](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev-lora) |
| Redux (Adapter) | [`black-forest-labs/FLUX.1-Redux-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Redux-dev) |
| Konteks | [`black-forest-labs/FLUX.1-kontext`](https://huggingface.co/black-forest-labs/FLUX.1-Kontext-dev) |
Semua checkpoint memiliki penggunaan yang berbeda, yang kami rinci di bawah ini.
### Timestep-distilled
* `max_sequence_length` tidak boleh lebih dari 256.
* `guidance_scale` harus 0.
* Karena ini adalah model yang telah melalui distilasi timestep, model ini mendapat manfaat dari jumlah langkah sampling yang lebih sedikit.
```python
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
out = pipe(
prompt=prompt,
guidance_scale=0.,
height=768,
width=1360,
num_inference_steps=4,
max_sequence_length=256,
).images[0]
out.save("image.png")
```
### Guidance-distilled
* Varian guidance-distilled membutuhkan sekitar 50 langkah sampling untuk menghasilkan generasi berkualitas baik.
* Tidak memiliki batasan terkait `max_sequence_length`.
```python
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()
prompt = "a tiny astronaut hatching from an egg on the moon"
out = pipe(
prompt=prompt,
guidance_scale=3.5,
height=768,
width=1360,
num_inference_steps=50,
).images[0]
out.save("image.png")
```
### Isi Inpainting/Outpainting
* Pipeline Flux Fill tidak memerlukan `strength` sebagai input seperti pipeline inpainting biasa.
* Itu mendukung inpainting dan outpainting.
```python
import torch
from diffusers import FluxFillPipeline
from diffusers.utils import load_image
image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup.png")
mask = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup_mask.png")
repo_id = "black-forest-labs/FLUX.1-Fill-dev"
pipe = FluxFillPipeline.from_pretrained(repo_id, dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
image = pipe(
prompt="a white paper cup",
image=image,
mask_image=mask,
height=1632,
width=1232,
max_sequence_length=512,
generator=torch.Generator("cpu").manual_seed(0)
).images[0]
image.save(f"output.png")
```
### Canny Control
**Catatan:** `black-forest-labs/Flux.1-Canny-dev` _bukan_ model [ControlNetModel](/docs/diffusers/main/id/api/models/controlnet#diffusers.ControlNetModel). Model ControlNet adalah komponen terpisah dari UNet/Transformer, di mana residualnya ditambahkan ke model dasar yang sebenarnya. Canny Control adalah arsitektur alternatif yang mencapai hasil yang secara efektif sama dengan model ControlNet, dengan menggunakan concatenation per channel dengan kondisi kontrol input dan memastikan transformer mempelajari kontrol struktur dengan mengikuti kondisi tersebut sedekat mungkin.
```python
# !pip install -U controlnet-aux
import torch
from controlnet_aux import CannyDetector
from diffusers import FluxControlPipeline
from diffusers.utils import load_image
pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-Canny-dev", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")
processor = CannyDetector()
control_image = processor(control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024)
image = pipe(
prompt=prompt,
control_image=control_image,
height=1024,
width=1024,
num_inference_steps=50,
guidance_scale=30.0,
).images[0]
image.save("output.png")
```
Canny Control juga memungkinkan dengan varian LoRA dari kondisi ini. Pemakaiannya adalah sebagai berikut:
```python
# !pip install -U controlnet-aux
import torch
from controlnet_aux import CannyDetector
from diffusers import FluxControlPipeline
from diffusers.utils import load_image
pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
pipe.load_lora_weights("black-forest-labs/FLUX.1-Canny-dev-lora")
prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")
processor = CannyDetector()
control_image = processor(control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024)
image = pipe(
prompt=prompt,
control_image=control_image,
height=1024,
width=1024,
num_inference_steps=50,
guidance_scale=30.0,
).images[0]
image.save("output.png")
```
### Kontrol Kedalaman
**Catatan:** `black-forest-labs/Flux.1-Depth-dev` _bukan_ model ControlNet. Model [ControlNetModel](/docs/diffusers/main/id/api/models/controlnet#diffusers.ControlNetModel) adalah komponen terpisah dari UNet/Transformer, di mana residualnya ditambahkan ke model dasar yang sebenarnya. Depth Control adalah arsitektur alternatif yang mencapai hasil yang secara efektif sama dengan model ControlNet, dengan menggunakan concatenation per channel dengan kondisi kontrol input dan memastikan transformer mempelajari kontrol struktur dengan mengikuti kondisi tersebut sedekat mungkin.
```python
# !pip install git+https://github.com/huggingface/image_gen_aux
import torch
from diffusers import FluxControlPipeline, FluxTransformer2DModel
from diffusers.utils import load_image
from image_gen_aux import DepthPreprocessor
pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-Depth-dev", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")
processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(control_image)[0].convert("RGB")
image = pipe(
prompt=prompt,
control_image=control_image,
height=1024,
width=1024,
num_inference_steps=30,
guidance_scale=10.0,
generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")
```
Kontrol Kedalaman juga dimungkinkan dengan varian LoRA dari kondisi ini. Pemakaiannya adalah sebagai berikut:
```python
# !pip install git+https://github.com/huggingface/image_gen_aux
import torch
from diffusers import FluxControlPipeline, FluxTransformer2DModel
from diffusers.utils import load_image
from image_gen_aux import DepthPreprocessor
pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
pipe.load_lora_weights("black-forest-labs/FLUX.1-Depth-dev-lora")
prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")
processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(control_image)[0].convert("RGB")
image = pipe(
prompt=prompt,
control_image=control_image,
height=1024,
width=1024,
num_inference_steps=30,
guidance_scale=10.0,
generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")
```
### Redux
* Pipeline Flux Redux adalah adapter untuk model dasar FLUX.1. Pipeline ini dapat digunakan dengan flux-dev dan flux-schnell, untuk generasi gambar-ke-gambar.
* Anda dapat terlebih dahulu menggunakan `FluxPriorReduxPipeline` untuk mendapatkan `prompt_embeds` dan `pooled_prompt_embeds`, lalu memasukkannya ke dalam `FluxPipeline` untuk generasi gambar-ke-gambar.
* Saat menggunakan `FluxPriorReduxPipeline` dengan pipeline dasar, Anda dapat mengatur `text_encoder=None` dan `text_encoder_2=None` di pipeline dasar untuk menghemat VRAM.
```python
import torch
from diffusers import FluxPriorReduxPipeline, FluxPipeline
from diffusers.utils import load_image
device = "cuda" # or "mps", "xpu", "cpu"
dtype = torch.bfloat16
repo_redux = "black-forest-labs/FLUX.1-Redux-dev"
repo_base = "black-forest-labs/FLUX.1-dev"
pipe_prior_redux = FluxPriorReduxPipeline.from_pretrained(repo_redux, dtype=dtype).to(device)
pipe = FluxPipeline.from_pretrained(
repo_base,
text_encoder=None,
text_encoder_2=None,
dtype=torch.bfloat16
).to(device)
image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/style_ziggy/img5.png")
pipe_prior_output = pipe_prior_redux(image)
images = pipe(
guidance_scale=2.5,
num_inference_steps=50,
generator=torch.Generator("cpu").manual_seed(0),
**pipe_prior_output,
).images
images[0].save("flux-redux.png")
```
### Konteks
Flux Kontext adalah model yang memungkinkan kontrol in-context pada proses pembuatan gambar, sehingga memungkinkan pengeditan, penyempurnaan, pencahayaan ulang, transfer gaya, kustomisasi karakter, dan lainnya.
```python
import torch
from diffusers import FluxKontextPipeline
from diffusers.utils import load_image
pipe = FluxKontextPipeline.from_pretrained(
"black-forest-labs/FLUX.1-Kontext-dev", dtype=torch.bfloat16
)
pipe.to("cuda") # or "mps", "xpu", "cpu"
image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png").convert("RGB")
prompt = "Make Pikachu hold a sign that says 'Black Forest Labs is awesome', yarn art style, detailed, vibrant colors"
image = pipe(
image=image,
prompt=prompt,
guidance_scale=2.5,
generator=torch.Generator().manual_seed(42),
).images[0]
image.save("flux-kontext.png")
```
Flux Kontext dilengkapi dengan pemeriksa keselamatan integritas, yang harus dijalankan setelah langkah pembuatan gambar. Untuk menjalankan pemeriksa keselamatan, instal repositori resmi dari [black-forest-labs/flux](https://github.com/black-forest-labs/flux) dan tambahkan kode berikut:
```python
from flux.content_filters import PixtralContentFilter
# ... pipeline invocation to generate images
integrity_checker = PixtralContentFilter(torch.device("cuda"))
image_ = np.array(image) / 255.0
image_ = 2 * image_ - 1
image_ = torch.from_numpy(image_).to("cuda", dtype=torch.float32).unsqueeze(0).permute(0, 3, 1, 2)
if integrity_checker.test_image(image_):
raise ValueError("Your image has been flagged. Choose another prompt/image or try again.")
```
### Kontext Inpainting
`FluxKontextInpaintPipeline` memungkinkan modifikasi gambar di dalam area mask yang tetap. Saat ini, pipeline ini mendukung kondisioning berbasis teks dan kondisioning berbasis referensi gambar.
```python
import torch
from diffusers import FluxKontextInpaintPipeline
from diffusers.utils import load_image
prompt = "Change the yellow dinosaur to green one"
img_url = (
"https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_input.jpeg?raw=true"
)
mask_url = (
"https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_mask.png?raw=true"
)
source = load_image(img_url)
mask = load_image(mask_url)
pipe = FluxKontextInpaintPipeline.from_pretrained(
"black-forest-labs/FLUX.1-Kontext-dev", dtype=torch.bfloat16
)
pipe.to("cuda") # or "mps", "xpu", "cpu"
image = pipe(prompt=prompt, image=source, mask_image=mask, strength=1.0).images[0]
image.save("kontext_inpainting_normal.png")
```
```python
import torch
from diffusers import FluxKontextInpaintPipeline
from diffusers.utils import load_image
pipe = FluxKontextInpaintPipeline.from_pretrained(
"black-forest-labs/FLUX.1-Kontext-dev", dtype=torch.bfloat16
)
pipe.to("cuda") # or "mps", "xpu", "cpu"
prompt = "Replace this ball"
img_url = "https://images.pexels.com/photos/39362/the-ball-stadion-football-the-pitch-39362.jpeg?auto=compress&cs=tinysrgb&dpr=1&w=500"
mask_url = "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/ball_mask.png?raw=true"
image_reference_url = "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTah3x6OL_ECMBaZ5ZlJJhNsyC-OSMLWAI-xw&s"
source = load_image(img_url)
mask = load_image(mask_url)
image_reference = load_image(image_reference_url)
mask = pipe.mask_processor.blur(mask, blur_factor=12)
image = pipe(
prompt=prompt, image=source, mask_image=mask, image_reference=image_reference, strength=1.0
).images[0]
image.save("kontext_inpainting_ref.png")
```
## Menggabungkan Flux Turbo LoRAs dengan Flux Control, Fill, dan Redux
Kita dapat menggabungkan Flux Turbo LoRAs dengan Flux Control dan pipeline lain seperti Fill dan Redux untuk memungkinkan inferensi dalam beberapa langkah. Contoh di bawah ini menunjukkan cara melakukannya untuk Flux Control LoRA untuk kedalaman dan turbo LoRA dari [`ByteDance/Hyper-SD`](https://hf.co/ByteDance/Hyper-SD).
```py
from diffusers import FluxControlPipeline
from image_gen_aux import DepthPreprocessor
from diffusers.utils import load_image
from huggingface_hub import hf_hub_download
import torch
control_pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16)
control_pipe.load_lora_weights("black-forest-labs/FLUX.1-Depth-dev-lora", adapter_name="depth")
control_pipe.load_lora_weights(
hf_hub_download("ByteDance/Hyper-SD", "Hyper-FLUX.1-dev-8steps-lora.safetensors"), adapter_name="hyper-sd"
)
control_pipe.set_adapters(["depth", "hyper-sd"], adapter_weights=[0.85, 0.125])
control_pipe.enable_model_cpu_offload()
prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")
processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(control_image)[0].convert("RGB")
image = control_pipe(
prompt=prompt,
control_image=control_image,
height=1024,
width=1024,
num_inference_steps=8,
guidance_scale=10.0,
generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")
```
## Catatan tentang `unload_lora_weights()` saat menggunakan Flux LoRAs
Saat memuat ulang bobot Control LoRA, panggil `pipe.unload_lora_weights(reset_to_overwritten_params=True)` untuk mengatur ulang `pipe.transformer` sepenuhnya ke bentuk aslinya. Pipeline yang dihasilkan kemudian dapat digunakan dengan metode seperti [DiffusionPipeline.from_pipe()](/docs/diffusers/main/id/api/pipelines/overview#diffusers.DiffusionPipeline.from_pipe). Detail lebih lanjut tentang argumen ini tersedia di [PR ini](https://github.com/huggingface/diffusers/pull/10397).
## IP-Adapter
> [!TIP]
> Lihat [IP-Adapter](../../using-diffusers/ip_adapter) untuk mempelajari lebih lanjut tentang cara kerja IP-Adapter.
IP-Adapter memungkinkan Anda memberikan prompt ke Flux menggunakan gambar, di samping prompt teks. Hal ini sangat berguna ketika Anda perlu menggambarkan konsep kompleks yang sulit diungkapkan hanya melalui teks dan Anda memiliki gambar referensi.
```python
import torch
from diffusers import FluxPipeline
from diffusers.utils import load_image
pipe = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16
).to("cuda") # or "mps", "xpu", "cpu"
image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flux_ip_adapter_input.jpg").resize((1024, 1024))
pipe.load_ip_adapter(
"XLabs-AI/flux-ip-adapter",
weight_name="ip_adapter.safetensors",
image_encoder_pretrained_model_name_or_path="openai/clip-vit-large-patch14"
)
pipe.set_ip_adapter_scale(1.0)
image = pipe(
width=1024,
height=1024,
prompt="wearing sunglasses",
negative_prompt="",
true_cfg_scale=4.0,
generator=torch.Generator().manual_seed(4444),
ip_adapter_image=image,
).images[0]
image.save('flux_ip_adapter_output.jpg')
```
Contoh IP-Adapter dengan prompt "wearing sunglasses"
## Optimalkan
Flux adalah model yang sangat besar dan membutuhkan sekitar 50GB RAM/VRAM untuk memuat semua komponen pemodelan. Aktifkan beberapa optimasi di bawah ini untuk menurunkan kebutuhan memori.
### Offloading grup
[Group offloading](../../optimization/memory#group-offloading) menurunkan penggunaan VRAM dengan meng-offload kelompok lapisan internal, bukan seluruh model atau bobot. Anda perlu menggunakan [apply_group_offloading()](/docs/diffusers/main/id/api/utilities#diffusers.hooks.apply_group_offloading) pada semua komponen model dari sebuah pipeline. Parameter `offload_type` memungkinkan Anda untuk beralih antara offloading tingkat blok dan tingkat daun. Mengaturnya ke `leaf_level` akan meng-offload parameter tingkat daun terendah ke CPU, bukan meng-offload pada tingkat modul.
Pada perangkat CUDA yang mendukung streaming data asinkron, atur `use_stream=True` untuk menumpuk transfer data dan komputasi guna mempercepat inferensi.
> [!TIP]
> Dimungkinkan untuk mencampurkan offloading tingkat blok dan tingkat daun untuk komponen yang berbeda dalam sebuah pipeline.
```py
import torch
from diffusers import FluxPipeline
from diffusers.hooks import apply_group_offloading
model_id = "black-forest-labs/FLUX.1-dev"
dtype = torch.bfloat16
pipe = FluxPipeline.from_pretrained(
model_id,
dtype=dtype,
)
apply_group_offloading(
pipe.transformer,
offload_type="leaf_level",
offload_device=torch.device("cpu"),
onload_device=torch.device("cuda"),
use_stream=True,
)
apply_group_offloading(
pipe.text_encoder,
offload_device=torch.device("cpu"),
onload_device=torch.device("cuda"),
offload_type="leaf_level",
use_stream=True,
)
apply_group_offloading(
pipe.text_encoder_2,
offload_device=torch.device("cpu"),
onload_device=torch.device("cuda"),
offload_type="leaf_level",
use_stream=True,
)
apply_group_offloading(
pipe.vae,
offload_device=torch.device("cpu"),
onload_device=torch.device("cuda"),
offload_type="leaf_level",
use_stream=True,
)
prompt="A cat wearing sunglasses and working as a lifeguard at pool."
generator = torch.Generator().manual_seed(181201)
image = pipe(
prompt,
width=576,
height=1024,
num_inference_steps=30,
generator=generator
).images[0]
image
```
### Menjalankan inferensi FP16
Flux dapat menghasilkan gambar berkualitas tinggi dengan FP16 (yaitu untuk mempercepat inferensi pada GPU Turing/Volta) tetapi menghasilkan output yang berbeda dibandingkan dengan FP32/BF16. Masalahnya adalah beberapa aktivasi di text encoder harus dipangkas (clipped) saat dijalankan dalam FP16, yang memengaruhi keseluruhan gambar. Memaksa text encoder untuk berjalan dengan inferensi FP32 sehingga menghilangkan perbedaan output ini. Lihat [di sini](https://github.com/huggingface/diffusers/pull/9097#issuecomment-2272292516) untuk detailnya.
Kode inferensi FP16:
```python
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16) # can replace schnell with dev
# to run on low vram GPUs (i.e. between 4 and 32 GB VRAM)
pipe.enable_sequential_cpu_offload()
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()
pipe.to(torch.float16) # casting here instead of in the pipeline constructor because doing so in the constructor loads all models into CPU memory at once
prompt = "A cat holding a sign that says hello world"
out = pipe(
prompt=prompt,
guidance_scale=0.,
height=768,
width=1360,
num_inference_steps=4,
max_sequence_length=256,
).images[0]
out.save("image.png")
```
### Kuantisasi
Quantization membantu mengurangi kebutuhan memori untuk model yang sangat besar dengan menyimpan bobot model dalam tipe data presisi yang lebih rendah. Namun, quantization dapat memiliki dampak yang bervariasi terhadap kualitas video tergantung pada model video yang digunakan.
Lihat ringkasan [Quantization](../../quantization/overview) untuk mempelajari lebih lanjut tentang backend kuantisasi yang didukung dan memilih backend kuantisasi yang mendukung kasus penggunaan Anda. Contoh di bawah ini menunjukkan cara memuat [FluxPipeline](/docs/diffusers/main/id/api/pipelines/flux#diffusers.FluxPipeline) yang dikuantisasi untuk inferensi dengan bitsandbytes.
```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, FluxTransformer2DModel, FluxPipeline
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel
quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
"black-forest-labs/FLUX.1-dev",
subfolder="text_encoder_2",
quantization_config=quant_config,
dtype=torch.float16,
)
quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = FluxTransformer2DModel.from_pretrained(
"black-forest-labs/FLUX.1-dev",
subfolder="transformer",
quantization_config=quant_config,
dtype=torch.float16,
)
pipeline = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.1-dev",
text_encoder_2=text_encoder_8bit,
transformer=transformer_8bit,
dtype=torch.float16,
device_map="balanced",
)
prompt = "a tiny astronaut hatching from an egg on the moon"
image = pipeline(prompt, guidance_scale=3.5, height=768, width=1360, num_inference_steps=50).images[0]
image.save("flux.png")
```
## Memuat File Tunggal untuk `FluxTransformer2DModel`
`FluxTransformer2DModel` mendukung pemuatan checkpoint dalam format asli yang dirilis oleh Black Forest Labs. Hal ini juga berguna saat mencoba memuat finetune atau versi kuantisasi dari model yang telah dipublikasikan oleh komunitas.
> [!TIP]
> Inferensi `FP8` dapat menjadi tidak stabil tergantung pada jenis GPU, versi CUDA, dan versi `torch` yang Anda gunakan. Disarankan untuk menggunakan pustaka `optimum-quanto` agar dapat menjalankan inferensi FP8 di mesin Anda.
Contoh berikut menunjukkan cara menjalankan Flux dengan VRAM kurang dari 16GB.
Pertama, instal `optimum-quanto`
```shell
pip install optimum-quanto
```
Lalu jalankan contoh berikut
```python
import torch
from diffusers import FluxTransformer2DModel, FluxPipeline
from transformers import T5EncoderModel, CLIPTextModel
from optimum.quanto import freeze, qfloat8, quantize
bfl_repo = "black-forest-labs/FLUX.1-dev"
dtype = torch.bfloat16
transformer = FluxTransformer2DModel.from_single_file("https://huggingface.co/Kijai/flux-fp8/blob/main/flux1-dev-fp8.safetensors", dtype=dtype)
quantize(transformer, weights=qfloat8)
freeze(transformer)
text_encoder_2 = T5EncoderModel.from_pretrained(bfl_repo, subfolder="text_encoder_2", dtype=dtype)
quantize(text_encoder_2, weights=qfloat8)
freeze(text_encoder_2)
pipe = FluxPipeline.from_pretrained(bfl_repo, transformer=None, text_encoder_2=None, dtype=dtype)
pipe.transformer = transformer
pipe.text_encoder_2 = text_encoder_2
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
image = pipe(
prompt,
guidance_scale=3.5,
output_type="pil",
num_inference_steps=20,
generator=torch.Generator("cpu").manual_seed(0)
).images[0]
image.save("flux-fp8-dev.png")
```
## FluxPipeline[[diffusers.FluxPipeline]]
#### diffusers.FluxPipeline[[diffusers.FluxPipeline]]
```python
diffusers.FluxPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux.py#L146)
**Parameter:**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline Flux untuk generasi teks-ke-gambar.
Referensi: https://blackforestlabs.ai/announcing-black-forest-labs/
#### __call__[[diffusers.FluxPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux.py#L600)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` akan digunakan sebagai gantinya.
negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `true_cfg_scale` tidak lebih besar dari `1`).
negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di semua text-encoder.
true_cfg_scale (`float`, *opsional*, default 1.0) : True classifier-free guidance (skala panduan) diaktifkan ketika `true_cfg_scale` > 1 dan `negative_prompt` disediakan.
height (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
width (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.
guidance_scale (`float`, *opsional*, default 3.5) : Embedded guiddance scale diaktifkan dengan mengatur `guidance_scale` > 1. Nilai `guidance_scale` yang lebih tinggi mendorong model untuk menghasilkan gambar yang lebih selaras dengan `prompt` dengan mengorbankan kualitas gambar yang lebih rendah. Model yang telah melalui distilasi guidance mengaproksimasi true classifer-free guidance untuk `guidance_scale` > 1. Lihat [paper](https://huggingface.co/papers/2210.03142) untuk mempelajari lebih lanjut.
num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters.
ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`.
negative_ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters.
negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`.
negative_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`.
output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPipelineOutput` alih-alih tuple biasa.
joint_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.
max_sequence_length (`int` defaultnya 512) : Panjang maksimum sekuens yang digunakan dengan `prompt`.
**Mengembalikan:** `~pipelines.flux.FluxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
```py
>>> import torch
>>> from diffusers import FluxPipeline
>>> pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A cat holding a sign that says hello world"
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> image = pipe(prompt, num_inference_steps=4, guidance_scale=0.0).images[0]
>>> image.save("flux.png")
```
#### encode_prompt[[diffusers.FluxPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux.py#L312)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
## FluxImg2ImgPipeline[[diffusers.FluxImg2ImgPipeline]]
#### diffusers.FluxImg2ImgPipeline[[diffusers.FluxImg2ImgPipeline]]
```python
diffusers.FluxImg2ImgPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_img2img.py#L169)
**Parameter:**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline Flux untuk inpainting gambar.
Referensi: https://blackforestlabs.ai/announcing-black-forest-labs/
#### __call__[[diffusers.FluxImg2ImgPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_img2img.py#L678)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` akan digunakan sebagai gantinya
negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `true_cfg_scale` tidak lebih besar dari `1`).
negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di semua text-encoder.
true_cfg_scale (`float`, *opsional*, default 1.0) : True classifier-free guidance (skala panduan) diaktifkan ketika `true_cfg_scale` > 1 dan `negative_prompt` disediakan.
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk digunakan sebagai titik awal. Untuk array numpy dan tensor pytorch, rentang nilai yang diharapkan adalah antara `[0, 1]` Jika berupa tensor atau daftar tensor, bentuk (shape) yang diharapkan adalah `(B, C, H, W)` atau `(C, H, W)`. Jika berupa array numpy atau daftar array, bentuk yang diharapkan adalah `(B, H, W, C)` atau `(H, W, C)` Parameter ini juga dapat menerima latents gambar sebagai `image`, namun jika latents dilewatkan secara langsung, latents tersebut tidak akan di-encode ulang.
height (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
width (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
strength (`float`, *opsional*, default 1.0) : Menunjukkan sejauh mana transformasi dilakukan pada `image` referensi. Nilai harus berada di antara 0 dan 1. `image` digunakan sebagai titik awal, dan semakin tinggi nilai `strength`, semakin banyak noise yang ditambahkan. Jumlah langkah denoising bergantung pada jumlah noise yang ditambahkan di awal. Ketika `strength` bernilai 1, noise yang ditambahkan maksimal dan proses denoising berjalan untuk jumlah iterasi penuh yang ditentukan dalam `num_inference_steps`. Nilai 1 pada dasarnya mengabaikan `image`.
num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.
guidance_scale (`float`, *opsional*, default 7.0) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://huggingface.co/papers/2205.11487). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi gambar yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah.
num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
negative_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`.
ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters.
ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`.
negative_ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters.
negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`.
output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPipelineOutput` alih-alih tuple biasa.
joint_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.
max_sequence_length (`int` defaultnya 512) : Panjang maksimum sekuens yang digunakan dengan `prompt`.
**Mengembalikan:** `~pipelines.flux.FluxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
```py
>>> import torch
>>> from diffusers import FluxImg2ImgPipeline
>>> from diffusers.utils import load_image
>>> device = "cuda"
>>> pipe = FluxImg2ImgPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
>>> pipe = pipe.to(device)
>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
>>> init_image = load_image(url).resize((1024, 1024))
>>> prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney, 8k"
>>> images = pipe(
... prompt=prompt, image=init_image, num_inference_steps=4, strength=0.95, guidance_scale=0.0
... ).images[0]
```
#### encode_prompt[[diffusers.FluxImg2ImgPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_img2img.py#L335)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
## FluxInpaintPipeline[[diffusers.FluxInpaintPipeline]]
#### diffusers.FluxInpaintPipeline[[diffusers.FluxInpaintPipeline]]
```python
diffusers.FluxInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_inpaint.py#L166)
**Parameter:**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline Flux untuk inpainting gambar.
Referensi: https://blackforestlabs.ai/announcing-black-forest-labs/
#### __call__[[diffusers.FluxInpaintPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 0.6, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_inpaint.py#L777)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` akan digunakan sebagai gantinya
negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `true_cfg_scale` tidak lebih besar dari `1`).
negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di semua text-encoder.
true_cfg_scale (`float`, *opsional*, default 1.0) : True classifier-free guidance (skala panduan) diaktifkan ketika `true_cfg_scale` > 1 dan `negative_prompt` disediakan.
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk digunakan sebagai titik awal. Untuk array numpy dan tensor pytorch, rentang nilai yang diharapkan adalah antara `[0, 1]` Jika berupa tensor atau daftar tensor, bentuk (shape) yang diharapkan adalah `(B, C, H, W)` atau `(C, H, W)`. Jika berupa array numpy atau daftar array, bentuk yang diharapkan adalah `(B, H, W, C)` atau `(H, W, C)` Parameter ini juga dapat menerima latents gambar sebagai `image`, namun jika latents dilewatkan secara langsung, latents tersebut tidak akan di-encode ulang.
mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk memasker `image`. Piksel putih pada mask akan diwarnai ulang, sedangkan piksel hitam dipertahankan. Jika `mask_image` adalah gambar PIL, gambar tersebut dikonversi menjadi satu saluran (luminance) sebelum digunakan. Jika berupa array numpy atau tensor pytorch, array/tensor tersebut harus berisi satu saluran warna (L) alih-alih 3, sehingga bentuk yang diharapkan untuk tensor pytorch adalah `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)`, atau `(H, W)`. Dan untuk array numpy, bentuknya adalah `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)`, atau `(H, W)`.
masked_image_latents (`torch.Tensor`, `list[torch.Tensor]`) : `Tensor` yang merepresentasikan batch gambar untuk memasker `image` yang dihasilkan oleh VAE. Jika tidak disediakan, tensor latens mask akan dihasilkan oleh `mask_image`.
height (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
width (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
padding_mask_crop (`int`, *opsional*, defaultnya `None`) : Ukuran margin pada crop yang akan diterapkan ke gambar dan masking. Jika `None`, tidak ada crop yang diterapkan ke image dan mask_image. Jika `padding_mask_crop` bukan `None`, sistem akan terlebih dahulu menemukan area persegi panjang dengan rasio aspek yang sama dengan gambar dan mencakup semua area yang di-mask, kemudian memperluas area tersebut berdasarkan `padding_mask_crop`. Gambar dan mask_image kemudian akan di-crop berdasarkan area yang telah diperluas sebelum di-resize ke ukuran gambar asli untuk inpainting. Hal ini berguna ketika area yang di-mask kecil sementara gambarnya besar dan mengandung informasi yang tidak relevan untuk inpainting, seperti latar belakang.
strength (`float`, *opsional*, default 1.0) : Menunjukkan sejauh mana transformasi dilakukan pada `image` referensi. Nilai harus berada di antara 0 dan 1. `image` digunakan sebagai titik awal, dan semakin tinggi nilai `strength`, semakin banyak noise yang ditambahkan. Jumlah langkah denoising bergantung pada jumlah noise yang ditambahkan di awal. Ketika `strength` bernilai 1, noise yang ditambahkan maksimal dan proses denoising berjalan untuk jumlah iterasi penuh yang ditentukan dalam `num_inference_steps`. Nilai 1 pada dasarnya mengabaikan `image`.
num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.
guidance_scale (`float`, *opsional*, default 7.0) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://huggingface.co/papers/2205.11487). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi gambar yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah.
num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
negative_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`.
ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters.
ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`.
negative_ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters.
negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`.
output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPipelineOutput` alih-alih tuple biasa.
joint_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.
max_sequence_length (`int` defaultnya 512) : Panjang maksimum sekuens yang digunakan dengan `prompt`.
**Mengembalikan:** `~pipelines.flux.FluxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
```py
>>> import torch
>>> from diffusers import FluxInpaintPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxInpaintPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
>>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
>>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> image = pipe(prompt=prompt, image=source, mask_image=mask).images[0]
>>> image.save("flux_inpainting.png")
```
#### encode_prompt[[diffusers.FluxInpaintPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_inpaint.py#L339)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
## FluxControlNetInpaintPipeline[[diffusers.FluxControlNetInpaintPipeline]]
#### diffusers.FluxControlNetInpaintPipeline[[diffusers.FluxControlNetInpaintPipeline]]
```python
diffusers.FluxControlNetInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, controlnet: diffusers.models.controlnets.controlnet_flux.FluxControlNetModel | list[diffusers.models.controlnets.controlnet_flux.FluxControlNetModel] | tuple[diffusers.models.controlnets.controlnet_flux.FluxControlNetModel] | diffusers.models.controlnets.controlnet_flux.FluxMultiControlNetModel)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_inpainting.py#L174)
**Parameter:**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline controlnet Flux untuk inpainting.
Referensi: https://blackforestlabs.ai/announcing-black-forest-labs/
#### __call__[[diffusers.FluxControlNetInpaintPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, padding_mask_crop: int | None = None, sigmas: list[float] | None = None, num_inference_steps: int = 28, guidance_scale: float = 7.0, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_mode: int | list[int] | None = None, controlnet_conditioning_scale: float | list[float] = 1.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_inpainting.py#L741)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`.
image (`PIL.Image.Image` atau `list[PIL.Image.Image]` atau `torch.FloatTensor`) : Gambar yang akan di-inpaint.
mask_image (`PIL.Image.Image` atau `list[PIL.Image.Image]` atau `torch.FloatTensor`) : Gambar mask yang akan digunakan untuk inpainting. Piksel putih pada mask akan diwarnai ulang, sedangkan piksel hitam akan dipertahankan.
masked_image_latents (`torch.FloatTensor`, *opsional*) : Laten gambar ber-masker yang telah dibuat sebelumnya.
control_image (`PIL.Image.Image` atau `list[PIL.Image.Image]` atau `torch.FloatTensor`) : Kondisi input ControlNet. Gambar untuk mengontrol generasi.
height (`int`, *opsional*, defaultnya self.default_sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel.
width (`int`, *opsional*, defaultnya self.default_sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel.
strength (`float`, *opsional*, default 0.6) : Secara konseptual, menunjukkan seberapa banyak area yang dimasker akan di-inpaint. Harus berada di antara 0 dan 1.
padding_mask_crop (`int`, *opsional*) : Ukuran padding yang digunakan saat memotong mask.
num_inference_steps (`int`, *opsional*, defaultnya 28) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.
guidance_scale (`float`, *opsional*, default 7.0) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598).
control_guidance_start (`float` atau `list[float]`, *opsional*, default 0.0) : Persentase dari total langkah di mana ControlNet mulai diterapkan.
control_guidance_end (`float` atau `list[float]`, *opsional*, default 1.0) : Persentase dari total langkah di mana ControlNet berhenti diterapkan.
control_mode (`int` atau `list[int]`, *opsional*) : Mode untuk ControlNet. Jika beberapa ControlNet digunakan, ini harus berupa daftar.
controlnet_conditioning_scale (`float` atau `list[float]`, *opsional*, default 1.0) : Output dari ControlNet dikalikan dengan `controlnet_conditioning_scale` sebelum ditambahkan ke residual pada transformer asli.
num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau lebih [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks pooled yang telah dibuat sebelumnya.
output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara `PIL.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPipelineOutput` alih-alih tuple biasa.
joint_attention_kwargs (`dict`, *opsional*) : Argumen kata kunci tambahan yang akan diteruskan ke mekanisme perhatian gabungan.
callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi.
callback_on_step_end_tensor_inputs (`list[str]`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`.
max_sequence_length (`int`, *opsional*, defaultnya 512) : Panjang maksimum dari urutan yang akan dihasilkan.
**Mengembalikan:** `~pipelines.flux.FluxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
```py
>>> import torch
>>> from diffusers import FluxControlNetInpaintPipeline
>>> from diffusers.models import FluxControlNetModel
>>> from diffusers.utils import load_image
>>> controlnet = FluxControlNetModel.from_pretrained(
... "InstantX/FLUX.1-dev-controlnet-canny", torch_dtype=torch.float16
... )
>>> pipe = FluxControlNetInpaintPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-schnell", controlnet=controlnet, torch_dtype=torch.float16
... )
>>> pipe.to("cuda")
>>> control_image = load_image(
... "https://huggingface.co/InstantX/FLUX.1-dev-Controlnet-Canny-alpha/resolve/main/canny.jpg"
... )
>>> init_image = load_image(
... "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
... )
>>> mask_image = load_image(
... "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
... )
>>> prompt = "A girl holding a sign that says InstantX"
>>> image = pipe(
... prompt,
... image=init_image,
... mask_image=mask_image,
... control_image=control_image,
... control_guidance_start=0.2,
... control_guidance_end=0.8,
... controlnet_conditioning_scale=0.7,
... strength=0.7,
... num_inference_steps=28,
... guidance_scale=3.5,
... ).images[0]
>>> image.save("flux_controlnet_inpaint.png")
```
#### encode_prompt[[diffusers.FluxControlNetInpaintPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_inpainting.py#L349)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
## FluxControlNetImg2ImgPipeline[[diffusers.FluxControlNetImg2ImgPipeline]]
#### diffusers.FluxControlNetImg2ImgPipeline[[diffusers.FluxControlNetImg2ImgPipeline]]
```python
diffusers.FluxControlNetImg2ImgPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, controlnet: diffusers.models.controlnets.controlnet_flux.FluxControlNetModel | list[diffusers.models.controlnets.controlnet_flux.FluxControlNetModel] | tuple[diffusers.models.controlnets.controlnet_flux.FluxControlNetModel] | diffusers.models.controlnets.controlnet_flux.FluxMultiControlNetModel)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_image_to_image.py#L172)
**Parameter:**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline Flux controlnet untuk generasi gambar-ke-gambar.
Referensi: https://blackforestlabs.ai/announcing-black-forest-labs/
#### __call__[[diffusers.FluxControlNetImg2ImgPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_mode: int | list[int] | None = None, controlnet_conditioning_scale: float | list[float] = 1.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_image_to_image.py#L637)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`.
image (`PIL.Image.Image` atau `list[PIL.Image.Image]` atau `torch.FloatTensor`) : Gambar yang akan dimodifikasi dengan pipeline.
control_image (`PIL.Image.Image` atau `list[PIL.Image.Image]` atau `torch.FloatTensor`) : Kondisi input ControlNet. Gambar untuk mengontrol generasi.
height (`int`, *opsional*, defaultnya self.default_sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel.
width (`int`, *opsional*, defaultnya self.default_sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel.
strength (`float`, *opsional*, default 0.6) : Secara konseptual, menunjukkan seberapa besar transformasi pada `image` referensi. Harus berada di antara 0 dan 1.
num_inference_steps (`int`, *opsional*, defaultnya 28) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.
guidance_scale (`float`, *opsional*, default 7.0) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598).
control_mode (`int` atau `list[int]`, *opsional*) : Mode untuk ControlNet. Jika beberapa ControlNet digunakan, ini harus berupa daftar.
controlnet_conditioning_scale (`float` atau `list[float]`, *opsional*, default 1.0) : Output dari ControlNet dikalikan dengan `controlnet_conditioning_scale` sebelum ditambahkan ke residual pada transformer asli.
control_guidance_start (`float` atau `list[float]`, *opsional*, default 0.0) : Persentase dari total langkah di mana ControlNet mulai diterapkan.
control_guidance_end (`float` atau `list[float]`, *opsional*, default 1.0) : Persentase dari total langkah di mana ControlNet berhenti diterapkan.
num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau lebih [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks pooled yang telah dibuat sebelumnya.
output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara `PIL.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPipelineOutput` alih-alih tuple biasa.
joint_attention_kwargs (`dict`, *opsional*) : Argumen kata kunci tambahan yang akan diteruskan ke mekanisme perhatian gabungan.
callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi.
callback_on_step_end_tensor_inputs (`list[str]`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`.
max_sequence_length (`int`, *opsional*, defaultnya 512) : Panjang maksimum dari urutan yang akan dihasilkan.
**Mengembalikan:** `~pipelines.flux.FluxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
```py
>>> import torch
>>> from diffusers import FluxControlNetImg2ImgPipeline, FluxControlNetModel
>>> from diffusers.utils import load_image
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> controlnet = FluxControlNetModel.from_pretrained(
... "InstantX/FLUX.1-dev-Controlnet-Canny-alpha", torch_dtype=torch.bfloat16
... )
>>> pipe = FluxControlNetImg2ImgPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-schnell", controlnet=controlnet, torch_dtype=torch.float16
... )
>>> pipe.text_encoder.to(torch.float16)
>>> pipe.controlnet.to(torch.float16)
>>> pipe.to("cuda")
>>> control_image = load_image("https://huggingface.co/InstantX/SD3-Controlnet-Canny/resolve/main/canny.jpg")
>>> init_image = load_image(
... "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
... )
>>> prompt = "A girl in city, 25 years old, cool, futuristic"
>>> image = pipe(
... prompt,
... image=init_image,
... control_image=control_image,
... control_guidance_start=0.2,
... control_guidance_end=0.8,
... controlnet_conditioning_scale=1.0,
... strength=0.7,
... num_inference_steps=2,
... guidance_scale=3.5,
... ).images[0]
>>> image.save("flux_controlnet_img2img.png")
```
#### encode_prompt[[diffusers.FluxControlNetImg2ImgPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_image_to_image.py#L338)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
## FluxControlPipeline[[diffusers.FluxControlPipeline]]
#### diffusers.FluxControlPipeline[[diffusers.FluxControlPipeline]]
```python
diffusers.FluxControlPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control.py#L159)
**Parameter:**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline Flux untuk generasi teks-ke-gambar yang dapat dikendalikan dengan kondisi gambar.
Referensi: https://bfl.ai/flux-1-tools
#### __call__[[diffusers.FluxControlPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control.py#L583)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` akan digunakan sebagai gantinya
control_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`, : `list[list[torch.Tensor]]`, `list[list[np.ndarray]]` atau `list[list[PIL.Image.Image]]`): Kondisi input ControlNet untuk memberikan panduan kepada `unet` dalam proses generasi. Jika tipe yang ditentukan adalah `torch.Tensor`, data diteruskan ke ControlNet apa adanya. `PIL.Image.Image` juga dapat diterima sebagai gambar. Dimensi gambar output secara default mengikuti dimensi `image`. Jika tinggi dan/atau lebar diteruskan, `image` akan di-resize sesuai dengan nilai tersebut. Jika beberapa ControlNet ditentukan dalam `init`, gambar harus diteruskan sebagai daftar sehingga setiap elemen dalam daftar dapat di-batch dengan benar untuk input ke satu ControlNet.
height (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
width (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.
guidance_scale (`float`, *opsional*, default 3.5) : Embedded guidance scale diaktifkan dengan mengatur `guidance_scale` > 1. Nilai `guidance_scale` yang lebih tinggi mendorong model untuk menghasilkan gambar yang lebih selaras dengan prompt, dengan mengorbankan kualitas gambar yang lebih rendah. Model guidance-distilled mengaproksimasi true classifier-free guidance untuk `guidance_scale` > 1. Lihat [paper](https://huggingface.co/papers/2210.03142) untuk mempelajari lebih lanjut.
num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPipelineOutput` alih-alih tuple biasa.
joint_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.
max_sequence_length (`int` defaultnya 512) : Panjang maksimum sekuens yang digunakan dengan `prompt`.
**Mengembalikan:** `~pipelines.flux.FluxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
```py
>>> import torch
>>> from controlnet_aux import CannyDetector
>>> from diffusers import FluxControlPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxControlPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Canny-dev", torch_dtype=torch.bfloat16
... ).to("cuda")
>>> prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
>>> control_image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png"
... )
>>> processor = CannyDetector()
>>> control_image = processor(
... control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024
... )
>>> image = pipe(
... prompt=prompt,
... control_image=control_image,
... height=1024,
... width=1024,
... num_inference_steps=50,
... guidance_scale=30.0,
... ).images[0]
>>> image.save("output.png")
```
#### encode_prompt[[diffusers.FluxControlPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control.py#L326)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
## FluxControlImg2ImgPipeline[[diffusers.FluxControlImg2ImgPipeline]]
#### diffusers.FluxControlImg2ImgPipeline[[diffusers.FluxControlImg2ImgPipeline]]
```python
diffusers.FluxControlImg2ImgPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_img2img.py#L178)
**Parameter:**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline Flux untuk inpainting gambar.
Referensi: https://blackforestlabs.ai/announcing-black-forest-labs/
#### __call__[[diffusers.FluxControlImg2ImgPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_img2img.py#L636)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` akan digunakan sebagai gantinya
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk digunakan sebagai titik awal. Untuk array numpy dan tensor pytorch, rentang nilai yang diharapkan adalah antara `[0, 1]` Jika berupa tensor atau daftar tensor, bentuk (shape) yang diharapkan adalah `(B, C, H, W)` atau `(C, H, W)`. Jika berupa array numpy atau daftar array, bentuk yang diharapkan adalah `(B, H, W, C)` atau `(H, W, C)` Parameter ini juga dapat menerima latents gambar sebagai `image`, namun jika latents dilewatkan secara langsung, latents tersebut tidak akan di-encode ulang.
control_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`, : `list[list[torch.Tensor]]`, `list[list[np.ndarray]]` atau `list[list[PIL.Image.Image]]`): Kondisi input ControlNet untuk memberikan panduan kepada `unet` dalam proses generasi. Jika tipe yang ditentukan adalah `torch.Tensor`, data diteruskan ke ControlNet apa adanya. `PIL.Image.Image` juga dapat diterima sebagai gambar. Dimensi gambar output secara default mengikuti dimensi `image`. Jika tinggi dan/atau lebar diteruskan, `image` akan di-resize sesuai dengan nilai tersebut. Jika beberapa ControlNet ditentukan dalam `init`, gambar harus diteruskan sebagai daftar sehingga setiap elemen dalam daftar dapat di-batch dengan benar untuk input ke satu ControlNet.
height (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
width (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
strength (`float`, *opsional*, default 1.0) : Menunjukkan sejauh mana transformasi dilakukan pada `image` referensi. Nilai harus berada di antara 0 dan 1. `image` digunakan sebagai titik awal, dan semakin tinggi nilai `strength`, semakin banyak noise yang ditambahkan. Jumlah langkah denoising bergantung pada jumlah noise yang ditambahkan di awal. Ketika `strength` bernilai 1, noise yang ditambahkan maksimal dan proses denoising berjalan untuk jumlah iterasi penuh yang ditentukan dalam `num_inference_steps`. Nilai 1 pada dasarnya mengabaikan `image`.
num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.
guidance_scale (`float`, *opsional*, default 7.0) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://huggingface.co/papers/2205.11487). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi gambar yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah.
num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPipelineOutput` alih-alih tuple biasa.
joint_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.
max_sequence_length (`int` defaultnya 512) : Panjang maksimum sekuens yang digunakan dengan `prompt`.
**Mengembalikan:** `~pipelines.flux.FluxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
```py
>>> import torch
>>> from controlnet_aux import CannyDetector
>>> from diffusers import FluxControlImg2ImgPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxControlImg2ImgPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Canny-dev", torch_dtype=torch.bfloat16
... ).to("cuda")
>>> prompt = "A robot made of exotic candies and chocolates of different kinds. Abstract background"
>>> image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/watercolor-painting.jpg"
... )
>>> control_image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png"
... )
>>> processor = CannyDetector()
>>> control_image = processor(
... control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024
... )
>>> image = pipe(
... prompt=prompt,
... image=image,
... control_image=control_image,
... strength=0.8,
... height=1024,
... width=1024,
... num_inference_steps=50,
... guidance_scale=30.0,
... ).images[0]
>>> image.save("output.png")
```
#### encode_prompt[[diffusers.FluxControlImg2ImgPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_img2img.py#L337)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
## FluxPriorReduxPipeline[[diffusers.FluxPriorReduxPipeline]]
#### diffusers.FluxPriorReduxPipeline[[diffusers.FluxPriorReduxPipeline]]
```python
diffusers.FluxPriorReduxPipeline(image_encoder: SiglipVisionModel, feature_extractor: SiglipImageProcessorPil, image_embedder: ReduxImageEncoder, text_encoder: CLIPTextModel = None, tokenizer: CLIPTokenizer = None, text_encoder_2: T5EncoderModel = None, tokenizer_2: T5Tokenizer = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_prior_redux.py#L83)
**Parameter:**
image_encoder (`SiglipVisionModel`) : model visi SIGLIP untuk mengodekan gambar input.
feature_extractor (`SiglipImageProcessor`) : Pemroses gambar untuk prapemrosesan gambar untuk model SIGLIP.
image_embedder (`ReduxImageEncoder`) : Encoder gambar Redux untuk memproses embedding SIGLIP.
text_encoder (`CLIPTextModel`, *opsional*) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`, *opsional*) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`, *opsional*) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`, *opsional*) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline Flux Redux untuk generasi gambar-ke-gambar.
Referensi: https://blackforestlabs.ai/flux-1-tools/
#### __call__[[diffusers.FluxPriorReduxPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, prompt_embeds_scale: float | list[float] | None = 1.0, pooled_prompt_embeds_scale: float | list[float] | None = 1.0, return_dict: bool = True)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_prior_redux.py#L378)
**Parameter:**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk digunakan sebagai titik awal. Untuk array numpy dan tensor pytorch, rentang nilai yang diharapkan adalah antara `[0, 1]` Jika berupa tensor atau daftar tensor, bentuk (shape) yang diharapkan adalah `(B, C, H, W)` atau `(C, H, W)`. Jika berupa array numpy atau daftar array, bentuk yang diharapkan adalah `(B, H, W, C)` atau `(H, W, C)`
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. **fitur eksperimental**: untuk menggunakan fitur ini, pastikan untuk memuat text encoder secara eksplisit ke pipeline. Prompt akan diabaikan jika text encoder tidak dimuat.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks pooled yang telah dibuat sebelumnya.
prompt_embeds_scale (`float` atau `list[float]`, *opsional*, default 1.0) : Faktor skala (atau daftar faktor skala per gambar) yang diterapkan pada embedding prompt redux sebelum dikembalikan.
pooled_prompt_embeds_scale (`float` atau `list[float]`, *opsional*, default 1.0) : Faktor skala (atau daftar faktor skala per gambar) yang diterapkan pada redux pooled prompt embeddings sebelum dikembalikan.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPriorReduxPipelineOutput` alih-alih tuple biasa.
**Mengembalikan:** `~pipelines.flux.FluxPriorReduxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPriorReduxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
```py
>>> import torch
>>> from diffusers import FluxPriorReduxPipeline, FluxPipeline
>>> from diffusers.utils import load_image
>>> device = "cuda"
>>> dtype = torch.bfloat16
>>> repo_redux = "black-forest-labs/FLUX.1-Redux-dev"
>>> repo_base = "black-forest-labs/FLUX.1-dev"
>>> pipe_prior_redux = FluxPriorReduxPipeline.from_pretrained(repo_redux, torch_dtype=dtype).to(device)
>>> pipe = FluxPipeline.from_pretrained(
... repo_base, text_encoder=None, text_encoder_2=None, torch_dtype=torch.bfloat16
... ).to(device)
>>> image = load_image(
... "https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/style_ziggy/img5.png"
... )
>>> pipe_prior_output = pipe_prior_redux(image)
>>> images = pipe(
... guidance_scale=2.5,
... num_inference_steps=50,
... generator=torch.Generator("cpu").manual_seed(0),
... **pipe_prior_output,
... ).images
>>> images[0].save("flux-redux.png")
```
#### encode_prompt[[diffusers.FluxPriorReduxPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_prior_redux.py#L299)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
## FluxFillPipeline[[diffusers.FluxFillPipeline]]
#### diffusers.FluxFillPipeline[[diffusers.FluxFillPipeline]]
```python
diffusers.FluxFillPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_fill.py#L167)
**Parameter:**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline Flux Fill untuk inpainting/outpainting gambar.
Referensi: https://blackforestlabs.ai/flux-1-tools/
#### __call__[[diffusers.FluxFillPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Optional[torch.FloatTensor] = None, mask_image: typing.Optional[torch.FloatTensor] = None, masked_image_latents: typing.Optional[torch.FloatTensor] = None, height: int | None = None, width: int | None = None, strength: float = 1.0, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float = 30.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_fill.py#L700)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` akan digunakan sebagai gantinya
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk digunakan sebagai titik awal. Untuk array numpy dan tensor pytorch, rentang nilai yang diharapkan adalah antara `[0, 1]`. Jika berupa tensor atau daftar tensor, bentuk (shape) yang diharapkan adalah `(B, C, H, W)` atau `(C, H, W)`. Jika berupa array numpy atau daftar array, bentuk yang diharapkan adalah `(B, H, W, C)` atau `(H, W, C)`.
mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk memasker `image`. Piksel putih pada mask akan diwarnai ulang, sedangkan piksel hitam dipertahankan. Jika `mask_image` adalah gambar PIL, gambar tersebut dikonversi menjadi satu saluran (luminance) sebelum digunakan. Jika berupa array numpy atau tensor pytorch, array/tensor tersebut harus berisi satu saluran warna (L) alih-alih 3, sehingga bentuk yang diharapkan untuk tensor pytorch adalah `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)`, atau `(H, W)`. Dan untuk array numpy, bentuknya adalah `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)`, atau `(H, W)`.
masked_image_latents (`torch.Tensor`, `list[torch.Tensor]`) : `Tensor` yang merepresentasikan batch gambar untuk memasker `image` yang dihasilkan oleh VAE. Jika tidak disediakan, tensor latens mask akan dihasilkan oleh `mask_image`.
height (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
width (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
strength (`float`, *opsional*, default 1.0) : Menunjukkan sejauh mana transformasi dilakukan pada `image` referensi. Nilai harus berada di antara 0 dan 1. `image` digunakan sebagai titik awal, dan semakin tinggi nilai `strength`, semakin banyak noise yang ditambahkan. Jumlah langkah denoising bergantung pada jumlah noise yang ditambahkan di awal. Ketika `strength` bernilai 1, noise yang ditambahkan maksimal dan proses denoising berjalan untuk jumlah iterasi penuh yang ditentukan dalam `num_inference_steps`. Nilai 1 pada dasarnya mengabaikan `image`.
num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.
guidance_scale (`float`, *opsional*, default 30.0) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://huggingface.co/papers/2205.11487). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi gambar yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah.
num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPipelineOutput` alih-alih tuple biasa.
joint_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.
max_sequence_length (`int` defaultnya 512) : Panjang maksimum sekuens yang digunakan dengan `prompt`.
**Mengembalikan:** `~pipelines.flux.FluxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
```py
>>> import torch
>>> from diffusers import FluxFillPipeline
>>> from diffusers.utils import load_image
>>> image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup.png")
>>> mask = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup_mask.png")
>>> pipe = FluxFillPipeline.from_pretrained("black-forest-labs/FLUX.1-Fill-dev", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload() # save some VRAM by offloading the model to CPU
>>> image = pipe(
... prompt="a white paper cup",
... image=image,
... mask_image=mask,
... height=1632,
... width=1232,
... guidance_scale=30,
... num_inference_steps=50,
... max_sequence_length=512,
... generator=torch.Generator("cpu").manual_seed(0),
... ).images[0]
>>> image.save("flux_fill.png")
```
#### encode_prompt[[diffusers.FluxFillPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_fill.py#L421)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
## FluxKontextPipeline[[diffusers.FluxKontextPipeline]]
#### diffusers.FluxKontextPipeline[[diffusers.FluxKontextPipeline]]
```python
diffusers.FluxKontextPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext.py#L190)
**Parameter:**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline Flux Kontext untuk generasi gambar-ke-gambar dan teks-ke-gambar.
Referensi: https://bfl.ai/announcements/flux-1-kontext-dev
#### __call__[[diffusers.FluxKontextPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, max_area: int = 1048576, _auto_resize: bool = True)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext.py#L695)
**Parameter:**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk digunakan sebagai titik awal. Untuk array numpy dan tensor pytorch, rentang nilai yang diharapkan adalah antara `[0, 1]` Jika berupa tensor atau daftar tensor, bentuk (shape) yang diharapkan adalah `(B, C, H, W)` atau `(C, H, W)`. Jika berupa array numpy atau daftar array, bentuk yang diharapkan adalah `(B, H, W, C)` atau `(H, W, C)` Parameter ini juga dapat menerima latents gambar sebagai `image`, namun jika latents dilewatkan secara langsung, latents tersebut tidak akan di-encode ulang.
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` akan digunakan sebagai gantinya.
negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `true_cfg_scale` tidak lebih besar dari `1`).
negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di semua text-encoder.
true_cfg_scale (`float`, *opsional*, default 1.0) : Ketika > 1.0 dan `negative_prompt` disediakan, mengaktifkan true classifier-free guidance.
height (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
width (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.
guidance_scale (`float`, *opsional*, default 3.5) : Embedded guidance scale diaktifkan dengan mengatur `guidance_scale` > 1. Nilai `guidance_scale` yang lebih tinggi mendorong model untuk menghasilkan gambar yang lebih selaras dengan prompt, dengan mengorbankan kualitas gambar yang lebih rendah. Model guidance-distilled mengaproksimasi true classifier-free guidance untuk `guidance_scale` > 1. Lihat [paper](https://huggingface.co/papers/2210.03142) untuk mempelajari lebih lanjut.
num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters.
ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`.
negative_ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters.
negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`.
negative_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`.
output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPipelineOutput` alih-alih tuple biasa.
joint_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.
max_sequence_length (`int` defaultnya 512) : Panjang maksimum sekuens yang digunakan dengan `prompt`.
max_area (`int`, defaultnya `1024 ** 2`) : Area maksimum dari gambar yang dihasilkan dalam piksel. Tinggi dan lebar akan disesuaikan agar muat dalam area ini sambil mempertahankan rasio aspek.
_auto_resize (`bool`, *opsional*, defaultnya `True`) : Apakah akan secara otomatis mengubah ukuran gambar input ke resolusi yang disarankan.
**Mengembalikan:** `~pipelines.flux.FluxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
```py
>>> import torch
>>> from diffusers import FluxKontextPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxKontextPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
... ).convert("RGB")
>>> prompt = "Make Pikachu hold a sign that says 'Black Forest Labs is awesome', yarn art style, detailed, vibrant colors"
>>> image = pipe(
... image=image,
... prompt=prompt,
... guidance_scale=2.5,
... generator=torch.Generator().manual_seed(42),
... ).images[0]
>>> image.save("output.png")
```
#### encode_prompt[[diffusers.FluxKontextPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext.py#L360)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
## FluxKontextInpaintPipeline[[diffusers.FluxKontextInpaintPipeline]]
#### diffusers.FluxKontextInpaintPipeline[[diffusers.FluxKontextInpaintPipeline]]
```python
diffusers.FluxKontextInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext_inpaint.py#L214)
**Parameter:**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.
vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), khususnya varian [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer dari kelas [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Tokenizer kedua dari kelas [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Pipeline Flux Kontext untuk generasi teks-ke-gambar.
Referensi: https://blackforestlabs.ai/announcing-black-forest-labs/
#### __call__[[diffusers.FluxKontextInpaintPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, image_reference: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, height: int | None = None, width: int | None = None, strength: float = 1.0, padding_mask_crop: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, max_area: int = 1048576, _auto_resize: bool = True)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext_inpaint.py#L884)
**Parameter:**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk di-inpaint (bagian mana dari gambar yang akan dimask dengan `mask_image` dan dilukis ulang sesuai dengan `prompt` dan `image_reference`). Baik untuk array numpy maupun tensor pytorch, rentang nilai yang diharapkan adalah antara `[0, 1]` Jika berupa tensor atau daftar tensor, bentuk yang diharapkan adalah `(B, C, H, W)` atau `(C, H, W)`. Jika berupa array numpy atau daftar array, bentuk yang diharapkan adalah `(B, H, W, C)` atau `(H, W, C)` Parameter ini juga dapat menerima latents gambar sebagai `image`, namun jika latents dilewatkan secara langsung, latents tersebut tidak akan di-encode ulang.
image_reference (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk digunakan sebagai titik awal untuk area yang dimasker. Untuk array numpy dan tensor pytorch, rentang nilai yang diharapkan adalah antara `[0, 1]` Jika berupa tensor atau daftar tensor, bentuk yang diharapkan seharusnya `(B, C, H, W)` atau `(C, H, W)` Jika berupa array numpy atau daftar array, bentuk yang diharapkan seharusnya `(B, H, W, C)` atau `(H, W, C)` Ini juga dapat menerima latens gambar sebagai `image`, tetapi jika latens dilewatkan secara langsung, ia tidak akan di-encode lagi.
mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, atau `list[np.ndarray]`) : `Image`, array numpy, atau tensor yang merepresentasikan batch gambar untuk memasker `image`. Piksel putih pada mask akan diwarnai ulang, sedangkan piksel hitam dipertahankan. Jika `mask_image` adalah gambar PIL, gambar tersebut dikonversi menjadi satu saluran (luminance) sebelum digunakan. Jika berupa array numpy atau tensor pytorch, array/tensor tersebut harus berisi satu saluran warna (L) alih-alih 3, sehingga bentuk yang diharapkan untuk tensor pytorch adalah `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)`, atau `(H, W)`. Dan untuk array numpy, bentuknya adalah `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)`, atau `(H, W)`.
prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya.
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` akan digunakan sebagai gantinya.
negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `true_cfg_scale` tidak lebih besar dari `1`).
negative_prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar untuk dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `negative_prompt` digunakan di semua text-encoder.
true_cfg_scale (`float`, *opsional*, default 1.0) : True classifier-free guidance (skala panduan) diaktifkan ketika `true_cfg_scale` > 1 dan `negative_prompt` disediakan.
height (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
width (`int`, *opsional*, defaultnya self.unet.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel. Ini diatur ke 1024 secara default untuk hasil terbaik.
strength (`float`, *opsional*, default 1.0) : Menunjukkan sejauh mana transformasi dilakukan pada `image` referensi. Nilai harus berada di antara 0 dan 1. `image` digunakan sebagai titik awal, dan semakin tinggi nilai `strength`, semakin banyak noise yang ditambahkan. Jumlah langkah denoising bergantung pada jumlah noise yang ditambahkan di awal. Ketika `strength` bernilai 1, noise yang ditambahkan maksimal dan proses denoising berjalan untuk jumlah iterasi penuh yang ditentukan dalam `num_inference_steps`. Nilai 1 pada dasarnya mengabaikan `image`.
padding_mask_crop (`int`, *opsional*, defaultnya `None`) : Ukuran margin pada crop yang akan diterapkan ke gambar dan masking. Jika `None`, tidak ada crop yang diterapkan ke image dan mask_image. Jika `padding_mask_crop` bukan `None`, sistem akan terlebih dahulu menemukan area persegi panjang dengan rasio aspek yang sama dengan gambar dan mencakup semua area yang di-mask, kemudian memperluas area tersebut berdasarkan `padding_mask_crop`. Gambar dan mask_image kemudian akan di-crop berdasarkan area yang telah diperluas sebelum di-resize ke ukuran gambar asli untuk inpainting. Hal ini berguna ketika area yang di-mask kecil sementara gambarnya besar dan mengandung informasi yang tidak relevan untuk inpainting, seperti latar belakang.
num_inference_steps (`int`, *opsional*, defaultnya 50) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.
sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.
guidance_scale (`float`, *opsional*, default 3.5) : Skala panduan tertanam diaktifkan dengan mengatur `guidance_scale` > 1. Nilai `guidance_scale` yang lebih tinggi mendorong model untuk menghasilkan gambar yang lebih selaras dengan `prompt` dengan mengorbankan kualitas gambar yang lebih rendah. Model yang telah melalui distilasi panduan mengaproksimasi panduan bebas-klasifikator sejati untuk `guidance_scale` > 1. Lihat [makalah](https://huggingface.co/papers/2210.03142) untuk mempelajari lebih lanjut.
num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.
generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.
latents (`torch.FloatTensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters.
ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`.
negative_ip_adapter_image : (`PipelineImageInput`, *opsional*): Input gambar opsional untuk bekerja dengan IP Adapters.
negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *opsional*) : Embedding gambar yang telah dibuat sebelumnya untuk IP-Adapter. Ini harus berupa daftar dengan panjang yang sama dengan jumlah IP-adapter. Setiap elemen harus berupa tensor dengan bentuk `(batch_size, num_images, emb_dim)`. Jika tidak disediakan, embedding dihitung dari argumen input `ip_adapter_image`.
negative_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks negatif yang sudah dipooling sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, pooled negative_prompt_embeds akan dihasilkan dari argumen input `negative_prompt`.
output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`.
return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.flux.FluxPipelineOutput` alih-alih tuple biasa.
joint_attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` akan berisi daftar semua tensor sesuai yang ditentukan oleh `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen `callback_kwargs`. Anda hanya dapat menyertakan variabel yang tercantum dalam atribut `._callback_tensor_inputs` dari kelas pipeline Anda.
max_sequence_length (`int` defaultnya 512) : Panjang maksimum sekuens yang digunakan dengan `prompt`.
max_area (`int`, defaultnya `1024 ** 2`) : Area maksimum dari gambar yang dihasilkan dalam piksel. Tinggi dan lebar akan disesuaikan agar muat dalam area ini sambil mempertahankan rasio aspek.
_auto_resize (`bool`, *opsional*, defaultnya `True`) : Apakah akan secara otomatis mengubah ukuran gambar input ke resolusi yang disarankan.
**Mengembalikan:** `~pipelines.flux.FluxPipelineOutput` atau `tuple`
`~pipelines.flux.FluxPipelineOutput` jika `return_dict` bernilai True, selain itu berupa `tuple`. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.
Fungsi yang dipanggil saat memanggil pipeline untuk generasi.
Contoh:
# Inpainting hanya dengan teks
```py
>>> import torch
>>> from diffusers import FluxKontextInpaintPipeline
>>> from diffusers.utils import load_image
>>> prompt = "Change the yellow dinosaur to green one"
>>> img_url = (
... "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_input.jpeg?raw=true"
... )
>>> mask_url = (
... "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_mask.png?raw=true"
... )
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> pipe = FluxKontextInpaintPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> image = pipe(prompt=prompt, image=source, mask_image=mask, strength=1.0).images[0]
>>> image.save("kontext_inpainting_normal.png")
```
# Inpainting dengan kondisioning gambar
```py
>>> import torch
>>> from diffusers import FluxKontextInpaintPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxKontextInpaintPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> prompt = "Replace this ball"
>>> img_url = "https://images.pexels.com/photos/39362/the-ball-stadion-football-the-pitch-39362.jpeg?auto=compress&cs=tinysrgb&dpr=1&w=500"
>>> mask_url = (
... "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/ball_mask.png?raw=true"
... )
>>> image_reference_url = (
... "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTah3x6OL_ECMBaZ5ZlJJhNsyC-OSMLWAI-xw&s"
... )
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> image_reference = load_image(image_reference_url)
>>> mask = pipe.mask_processor.blur(mask, blur_factor=12)
>>> image = pipe(
... prompt=prompt, image=source, mask_image=mask, image_reference=image_reference, strength=1.0
... ).images[0]
>>> image.save("kontext_inpainting_ref.png")
```
#### encode_prompt[[diffusers.FluxKontextInpaintPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext_inpaint.py#L393)
**Parameter:**
prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod
prompt_2 (`str` atau `list[str]`, *opsional*) : Prompt atau prompt yang akan dikirim ke `tokenizer_2` dan `text_encoder_2`. Jika tidak didefinisikan, `prompt` digunakan di semua text-encoder
device : (`torch.device`): perangkat torch
num_images_per_prompt (`int`) : jumlah gambar yang harus dihasilkan per prompt
prompt_embeds (`torch.FloatTensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.
pooled_prompt_embeds (`torch.FloatTensor`, *opsional*) : Pooled text embeddings yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* pembobotan prompt. Jika tidak disediakan, pooled text embeddings akan dibuat dari argumen input `prompt`.
lora_scale (`float`, *opsional*) : Skala lora yang akan diterapkan ke semua lapisan LoRA dari text encoder jika lapisan LoRA dimuat.
# Flux
Flux adalah serangkaian model generasi teks-ke-gambar yang didasarkan pada diffusion transformers. Untuk mengetahui lebih lanjut tentang Flux, lihat [artikel blog](https://blackforestlabs.ai/announcing-black-forest-labs/) asli oleh para pencipta Flux, Black Forest Labs.
Checkpoint model asli untuk Flux dapat ditemukan [di sini](https://huggingface.co/black-forest-labs). Kode inferensi asli dapat ditemukan [di sini](https://github.com/black-forest-labs/flux).
> [!TIP]
> Flux dapat cukup mahal untuk dijalankan pada perangkat keras konsumen. Namun, Anda dapat melakukan serangkaian optimasi untuk menjalankannya lebih cepat dan dengan cara yang lebih hemat memori. Lihat [bagian ini](https://huggingface.co/blog/sd3#memory-optimizations-for-sd3) untuk detail lebih lanjut. Selain itu, Flux dapat diuntungkan dari kuantisasi untuk efisiensi memori dengan trade-off pada latensi inferensi. Rujuk [artikel blog ini](https://huggingface.co/blog/quanto-diffusers) untuk mempelajari lebih lanjut. Untuk daftar sumber daya yang komprehensif, lihat [gist ini](https://gist.github.com/sayakpaul/b664605caf0aa3bf8585ab109dd5ac9c).
>
> [Caching](../../optimization/cache) juga dapat mempercepat inferensi dengan menyimpan dan menggunakan kembali output antara.
Flux hadir dalam varian berikut:
| tipe model | id model |
|:----------:|:--------:|
| Timestep-distilled | [`black-forest-labs/FLUX.1-schnell`](https://huggingface.co/black-forest-labs/FLUX.1-schnell) |
| Guidance-distilled | [`black-forest-labs/FLUX.1-dev`](https://huggingface.co/black-forest-labs/FLUX.1-dev) |
| Isi Inpainting/Outpainting (Guidance-distilled) | [`black-forest-labs/FLUX.1-Fill-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Fill-dev) |
| Canny Control (Guidance-distilled) | [`black-forest-labs/FLUX.1-Canny-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev) |
| Kontrol Kedalaman (Guidance-distilled) | [`black-forest-labs/FLUX.1-Depth-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev) |
| Canny Control (LoRA) | [`black-forest-labs/FLUX.1-Canny-dev-lora`](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev-lora) |
| Kontrol Kedalaman (LoRA) | [`black-forest-labs/FLUX.1-Depth-dev-lora`](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev-lora) |
| Redux (Adapter) | [`black-forest-labs/FLUX.1-Redux-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Redux-dev) |
| Konteks | [`black-forest-labs/FLUX.1-kontext`](https://huggingface.co/black-forest-labs/FLUX.1-Kontext-dev) |
Semua checkpoint memiliki penggunaan yang berbeda, yang kami rinci di bawah ini.
### Timestep-distilled
* `max_sequence_length` tidak boleh lebih dari 256.
* `guidance_scale` harus 0.
* Karena ini adalah model yang telah melalui distilasi timestep, model ini mendapat manfaat dari jumlah langkah sampling yang lebih sedikit.
```python
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
out = pipe(
prompt=prompt,
guidance_scale=0.,
height=768,
width=1360,
num_inference_steps=4,
max_sequence_length=256,
).images[0]
out.save("image.png")
```
### Guidance-distilled
* Varian guidance-distilled membutuhkan sekitar 50 langkah sampling untuk menghasilkan generasi berkualitas baik.
* Tidak memiliki batasan terkait `max_sequence_length`.
```python
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()
prompt = "a tiny astronaut hatching from an egg on the moon"
out = pipe(
prompt=prompt,
guidance_scale=3.5,
height=768,
width=1360,
num_inference_steps=50,
).images[0]
out.save("image.png")
```
### Isi Inpainting/Outpainting
* Pipeline Flux Fill tidak memerlukan `strength` sebagai input seperti pipeline inpainting biasa.
* Itu mendukung inpainting dan outpainting.
```python
import torch
from diffusers import FluxFillPipeline
from diffusers.utils import load_image
image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup.png")
mask = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup_mask.png")
repo_id = "black-forest-labs/FLUX.1-Fill-dev"
pipe = FluxFillPipeline.from_pretrained(repo_id, dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
image = pipe(
prompt="a white paper cup",
image=image,
mask_image=mask,
height=1632,
width=1232,
Xet Storage Details
- Size:
- 173 kB
- Xet hash:
- 81876133f304c3959216c603ebf6f96558d6ee18479d937a15730e71af06edcc
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.