# FluxControlInpaint FluxControlInpaintPipeline adalah implementasi Inpainting untuk model Flux.1 Depth/Canny. Ini adalah pipeline yang memungkinkan Anda melakukan inpainting pada gambar menggunakan model Flux.1 Depth/Canny. Pipeline ini menerima gambar dan mask sebagai input, lalu mengembalikan gambar hasil inpainting. FLUX.1 Depth and Canny [dev] adalah transformer aliran termodifikasi (rectified flow) dengan 12 miliar parameter yang mampu menghasilkan gambar berdasarkan deskripsi teks sambil mengikuti struktur gambar masukan yang diberikan. **Ini bukan model ControlNet**. | Jenis kontrol | Pengembang | Tautan | | -------- | ---------- | ---- | | Kedalaman | [Black Forest Labs](https://huggingface.co/black-forest-labs) | [Tautan](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev) | | Canny | [Black Forest Labs](https://huggingface.co/black-forest-labs) | [Tautan](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev) | > [!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). ```python import torch from diffusers import FluxControlInpaintPipeline from diffusers.models.transformers import FluxTransformer2DModel from transformers import T5EncoderModel from diffusers.utils import load_image, make_image_grid from image_gen_aux import DepthPreprocessor # https://github.com/huggingface/image_gen_aux from PIL import Image import numpy as np pipe = FluxControlInpaintPipeline.from_pretrained( "black-forest-labs/FLUX.1-Depth-dev", dtype=torch.bfloat16, ) # use following lines if you have GPU constraints # --------------------------------------------------------------- transformer = FluxTransformer2DModel.from_pretrained( "sayakpaul/FLUX.1-Depth-dev-nf4", subfolder="transformer", dtype=torch.bfloat16 ) text_encoder_2 = T5EncoderModel.from_pretrained( "sayakpaul/FLUX.1-Depth-dev-nf4", subfolder="text_encoder_2", dtype=torch.bfloat16 ) pipe.transformer = transformer pipe.text_encoder_2 = text_encoder_2 pipe.enable_model_cpu_offload() # --------------------------------------------------------------- pipe.to("cuda") # or "mps", "xpu", "cpu" prompt = "a blue robot singing opera with human-like expressions" image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png") head_mask = np.zeros_like(image) head_mask[65:580,300:642] = 255 mask_image = Image.fromarray(head_mask) processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf") control_image = processor(image)[0].convert("RGB") output = pipe( prompt=prompt, image=image, control_image=control_image, mask_image=mask_image, num_inference_steps=30, strength=0.9, guidance_scale=10.0, generator=torch.Generator().manual_seed(42), ).images[0] make_image_grid([image, control_image, mask_image, output.resize(image.size)], rows=1, cols=4).save("output.png") ``` ## FluxControlInpaintPipeline[[diffusers.FluxControlInpaintPipeline]] #### diffusers.FluxControlInpaintPipeline[[diffusers.FluxControlInpaintPipeline]] ```python diffusers.FluxControlInpaintPipeline(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/v0.43.0/src/diffusers/pipelines/flux/pipeline_flux_control_inpaint.py#L204) **Parameter:** transformer ([FluxTransformer2DModel](/docs/diffusers/v0.43.0/id/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Arsitektur Conditional Transformer (MMDiT) untuk mendenoise latens gambar yang telah dikodekan. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/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/v0.43.0/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 menggunakan Flux-dev-Depth/Canny. Referensi: https://blackforestlabs.ai/announcing-black-forest-labs/ #### __call__[[diffusers.FluxControlInpaintPipeline.__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, 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, 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/v0.43.0/src/diffusers/pipelines/flux/pipeline_flux_control_inpaint.py#L753) **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. 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 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 diffusers import FluxControlInpaintPipeline from diffusers.models.transformers import FluxTransformer2DModel from transformers import T5EncoderModel from diffusers.utils import load_image, make_image_grid from image_gen_aux import DepthPreprocessor # https://github.com/huggingface/image_gen_aux from PIL import Image import numpy as np pipe = FluxControlInpaintPipeline.from_pretrained( "black-forest-labs/FLUX.1-Depth-dev", torch_dtype=torch.bfloat16, ) # use following lines if you have GPU constraints # --------------------------------------------------------------- transformer = FluxTransformer2DModel.from_pretrained( "sayakpaul/FLUX.1-Depth-dev-nf4", subfolder="transformer", torch_dtype=torch.bfloat16 ) text_encoder_2 = T5EncoderModel.from_pretrained( "sayakpaul/FLUX.1-Depth-dev-nf4", subfolder="text_encoder_2", torch_dtype=torch.bfloat16 ) pipe.transformer = transformer pipe.text_encoder_2 = text_encoder_2 pipe.enable_model_cpu_offload() # --------------------------------------------------------------- pipe.to("cuda") prompt = "a blue robot singing opera with human-like expressions" image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png") head_mask = np.zeros_like(image) head_mask[65:580, 300:642] = 255 mask_image = Image.fromarray(head_mask) processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf") control_image = processor(image)[0].convert("RGB") output = pipe( prompt=prompt, image=image, control_image=control_image, mask_image=mask_image, num_inference_steps=30, strength=0.9, guidance_scale=10.0, generator=torch.Generator().manual_seed(42), ).images[0] make_image_grid([image, control_image, mask_image, output.resize(image.size)], rows=1, cols=4).save( "output.png" ) ``` #### encode_prompt[[diffusers.FluxControlInpaintPipeline.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/v0.43.0/src/diffusers/pipelines/flux/pipeline_flux_control_inpaint.py#L376) **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. ## FluxPipelineOutput[[diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput]] #### diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput[[diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput]] ```python diffusers.pipelines.flux.pipeline_output.FluxPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) ``` [Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/flux/pipeline_output.py#L11) **Parameter:** images (`list[PIL.Image.Image]` atau `torch.Tensor` atau `np.ndarray`) : daftar gambar PIL yang telah didenoise dengan panjang `batch_size` atau array numpy atau tensor torch dengan bentuk `(batch_size, height, width, num_channels)`. Gambar PIL atau array numpy menyajikan gambar-gambar yang telah didenoise dari pipeline difusi. Tensor torch dapat merepresentasikan gambar yang telah didenoise atau latens intermediat yang siap diteruskan ke decoder. Kelas output untuk pipeline generasi gambar Flux.