# FluxControlInpaint FluxControlInpaintPipeline là một triển khai của Inpainting cho các mô hình Flux.1 Depth/Canny. Đây là một pipeline cho phép bạn inpaint hình ảnh bằng cách sử dụng các mô hình Flux.1 Depth/Canny. Pipeline nhận một hình ảnh và một mask làm đầu vào và trả về hình ảnh đã được inpaint. FLUX.1 Depth and Canny [dev] là một rectified flow transformer có 12 tỷ tham số, có khả năng tạo ra hình ảnh dựa trên mô tả bằng văn bản trong khi tuân theo cấu trúc của hình ảnh đầu vào được cung cấp. **Đây không phải là mô hình ControlNet**. | Kiểu điều khiển | Nhà phát triển | Liên kết | | -------- | ---------- | ---- | | Độ sâu | [Black Forest Labs](https://huggingface.co/black-forest-labs) | [Liên kết](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev) | | Canny | [Black Forest Labs](https://huggingface.co/black-forest-labs) | [Liên kết](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev) | > [!TIP] > Flux có thể khá tốn kém khi chạy trên các thiết bị phần cứng tiêu dùng. Tuy nhiên, bạn có thể thực hiện một loạt các tối ưu hóa để chạy nó nhanh hơn và thân thiện hơn với bộ nhớ. Xem [mục này](https://huggingface.co/blog/sd3#memory-optimizations-for-sd3) để biết thêm chi tiết. Ngoài ra, Flux có thể được hưởng lợi từ lượng tử hóa để đạt hiệu quả bộ nhớ, với sự đánh đổi về độ trễ suy luận. Tham khảo [bài đăng trên blog này](https://huggingface.co/blog/quanto-diffusers) để tìm hiểu thêm. Để có danh sách đầy đủ các tài nguyên, hãy xem [gist này](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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_inpaint.py#L204) **Tham số:** transformer ([FluxTransformer2DModel](/docs/diffusers/main/vi/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Kiến trúc Transformer điều kiện (MMDiT) để khử nhiễu các latents ảnh đã mã hóa. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/vi/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Một trình lập lịch được sử dụng kết hợp với `transformer` để khử nhiễu các latent ảnh đã mã hóa. vae ([AutoencoderKL](/docs/diffusers/main/vi/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Mô hình Variational Auto-Encoder (VAE) để mã hóa và giải mã hình ảnh sang và từ các biểu diễn ẩn. text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), cụ thể là biến thể [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), cụ thể là biến thể [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl). tokenizer (`CLIPTokenizer`) : Tokenizer của lớp [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer). tokenizer_2 (`T5TokenizerFast`) : Tokenizer thứ hai của lớp [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast). Pipeline Flux cho việc inpainting hình ảnh sử dụng Flux-dev-Depth/Canny. Tham khảo: 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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_inpaint.py#L753) **Tham số:** prompt (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt để hướng dẫn việc tạo ảnh. Nếu không được định nghĩa, bạn phải truyền `prompt_embeds` thay thế. prompt_2 (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt cần được gửi đến `tokenizer_2` và `text_encoder_2`. Nếu không được định nghĩa, `prompt` sẽ được sử dụng thay thế image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, hoặc `list[np.ndarray]`) : `Image`, mảng numpy hoặc tensor đại diện cho một lô ảnh (image batch) được sử dụng làm điểm khởi đầu. Đối với cả mảng numpy và tensor pytorch, khoảng giá trị mong đợi nằm trong `[0, 1]` Nếu là tensor hoặc danh sách các tensor, hình dạng mong đợi nên là `(B, C, H, W)` hoặc `(C, H, W)`. Nếu là mảng numpy hoặc danh sách các mảng, hình dạng mong đợi nên là `(B, H, W, C)` hoặc `(H, W, C)` Nó cũng có thể nhận các image latents dưới dạng `image`, nhưng nếu truyền trực tiếp latents thì chúng sẽ không được mã hóa lại. 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]]` hoặc `list[list[PIL.Image.Image]]`): Điều kiện đầu vào của ControlNet để cung cấp hướng dẫn cho `unet` trong quá trình tạo ảnh. Nếu kiểu được chỉ định là `torch.Tensor`, nó sẽ được truyền vào ControlNet nguyên vẹn. `PIL.Image.Image` cũng có thể được chấp nhận dưới dạng ảnh. Kích thước của ảnh đầu ra mặc định là kích thước của `image`. Nếu chiều cao và/hoặc chiều rộng được truyền vào, `image` sẽ được thay đổi kích thước cho phù hợp. Nếu nhiều ControlNet được chỉ định trong `init`, các ảnh phải được truyền dưới dạng danh sách sao cho mỗi phần tử của danh sách có thể được nhóm (batch) chính xác để làm đầu vào cho một ControlNet duy nhất. mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, hoặc `list[np.ndarray]`) : `Image`, mảng numpy hoặc tensor đại diện cho một lô ảnh cần che `image`. Các pixel trắng trong mask sẽ được tô lại trong khi các pixel đen được giữ nguyên. Nếu `mask_image` là ảnh PIL, nó sẽ được chuyển đổi thành một kênh duy nhất (độ sáng) trước khi sử dụng. Nếu là mảng numpy hoặc tensor pytorch, nó phải chứa một kênh màu (L) thay vì 3, do đó hình dạng mong đợi cho tensor pytorch sẽ là `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)`, `(H, W)`. Và cho mảng numpy sẽ là `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)`, hoặc `(H, W)`. masked_image_latents (`torch.Tensor`, `list[torch.Tensor]`) : `Tensor` đại diện cho một lô ảnh để che `image` được tạo bởi VAE. Nếu không được cung cấp, tensor latents của mask sẽ được tạo bởi `mask_image`. height (`int`, *optional*, mặc định là self.unet.config.sample_size * self.vae_scale_factor) : Chiều cao của hình ảnh được tạo ra, tính bằng pixel. Giá trị mặc định là 1024 để đạt kết quả tốt nhất. width (`int`, *optional*, mặc định là self.unet.config.sample_size * self.vae_scale_factor) : Độ rộng tính bằng pixel của hình ảnh được tạo ra. Mặc định được đặt là 1024 để đạt kết quả tốt nhất. strength (`float`, *optional*, mặc định là 1.0) : Chỉ định mức độ biến đổi ảnh tham chiếu `image`. Giá trị phải nằm trong khoảng từ 0 đến 1. `image` được dùng làm điểm khởi đầu và càng thêm nhiều nhiễu khi `strength` càng cao. Số bước khử nhiễu phụ thuộc vào lượng nhiễu được thêm vào ban đầu. Khi `strength` là 1, nhiễu được thêm vào là tối đa và quá trình khử nhiễu chạy đủ số lần lặp được chỉ định trong `num_inference_steps`. Giá trị 1 về cơ bản sẽ bỏ qua `image`. num_inference_steps (`int`, *optional*, mặc định là 50) : Số bước khử nhiễu. Số bước khử nhiễu nhiều hơn thường dẫn đến hình ảnh có chất lượng cao hơn, với cái giá là suy luận chậm hơn. sigmas (`list[float]`, *optional*) : Các sigma tùy chỉnh để sử dụng cho quá trình khử nhiễu với các trình lập lịch hỗ trợ tham số `sigmas` trong phương thức `set_timesteps` của chúng. Nếu không được định nghĩa, hành vi mặc định khi `num_inference_steps` được truyền vào sẽ được sử dụng. guidance_scale (`float`, *optional*, mặc định là 7.0) : Thang độ dẫn hướng như được định nghĩa trong [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` được định nghĩa là `w` của phương trình 2. trong [Imagen Paper](https://huggingface.co/papers/2205.11487). Thang độ dẫn hướng được kích hoạt bằng cách đặt `guidance_scale > 1`. Thang độ dẫn hướng cao hơn khuyến khích tạo ra các hình ảnh gắn kết chặt chẽ với `prompt` văn bản, thường phải đánh đổi bằng chất lượng hình ảnh thấp hơn. num_images_per_prompt (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng hình ảnh cần tạo cho mỗi prompt. generator (`torch.Generator` hoặc `list[torch.Generator]`, *tùy chọn*) : Một hoặc một danh sách [torch generator](https://pytorch.org/docs/stable/generated/torch.Generator.html) để đảm bảo quá trình sinh là tất định. latents (`torch.FloatTensor`, *tùy chọn*) : Các latents nhiễu đã được tạo trước, được lấy mẫu từ phân phối Gaussian, dùng làm đầu vào cho việc tạo ảnh. Có thể dùng để tinh chỉnh cùng một quá trình tạo với các prompt khác nhau. Nếu không được cung cấp, một tensor latents sẽ được tạo ra bằng cách lấy mẫu sử dụng `generator` ngẫu nhiên được cung cấp. prompt_embeds (`torch.FloatTensor`, *tùy chọn*) : Các vector nhúng văn bản đã được tạo trước. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *vd.* trọng số của prompt. Nếu không được cung cấp, các vector nhúng văn bản sẽ được tạo từ đối số đầu vào `prompt`. pooled_prompt_embeds (`torch.FloatTensor`, *tùy chọn*) : Các embedding văn bản đã được pool sẵn. Có thể dùng để dễ dàng điều chỉnh các đầu vào văn bản, *vd.* trọng số prompt. Nếu không được cung cấp, các embedding văn bản đã pool sẽ được tạo ra từ đối số đầu vào `prompt`. output_type (`str`, *tùy chọn*, mặc định là `"pil"`) : Định dạng đầu ra của hình ảnh được tạo. Chọn giữa [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` hoặc `np.array`. return_dict (`bool`, *tùy chọn*, mặc định là `True`) : Có nên trả về một `~pipelines.flux.FluxPipelineOutput` thay vì một tuple thông thường hay không. joint_attention_kwargs (`dict`, *tùy chọn*) : Một từ điển kwargs mà nếu được chỉ định sẽ được truyền đến `AttentionProcessor` như đã định nghĩa dưới `self.processor` trong [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). callback_on_step_end (`Callable`, *tùy chọn*) : Một hàm được gọi vào cuối mỗi bước khử nhiễu trong quá trình suy luận. Hàm này được gọi với các đối số sau: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` sẽ bao gồm một danh sách tất cả các tensor như được chỉ định bởi `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *optional*) : Danh sách các đầu vào tensor cho hàm `callback_on_step_end`. Các tensor được chỉ định trong danh sách sẽ được truyền dưới dạng tham số `callback_kwargs`. Bạn chỉ có thể bao gồm các biến được liệt kê trong thuộc tính `._callback_tensor_inputs` của lớp pipeline của bạn. max_sequence_length (`int` mặc định là 512) : Độ dài tối đa của chuỗi để sử dụng với `prompt`. **Trả về:** `~pipelines.flux.FluxPipelineOutput` hoặc `tuple` `~pipelines.flux.FluxPipelineOutput` nếu `return_dict` là True, ngược lại là một `tuple`. Khi trả về tuple, phần tử đầu tiên là một danh sách chứa các hình ảnh đã tạo. Hàm được gọi khi gọi pipeline cho việc sinh. Ví dụ: ```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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_inpaint.py#L376) **Tham số:** prompt (`str` hoặc `list[str]`, *tùy chọn*) : prompt cần được mã hóa prompt_2 (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt cần được gửi đến `tokenizer_2` và `text_encoder_2`. Nếu không được định nghĩa, `prompt` sẽ được sử dụng trong tất cả các text-encoder device : (`torch.device`): thiết bị torch num_images_per_prompt (`int`) : số lượng hình ảnh cần được tạo cho mỗi prompt prompt_embeds (`torch.FloatTensor`, *tùy chọn*) : Các vector nhúng văn bản đã được tạo trước. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *vd.* trọng số của prompt. Nếu không được cung cấp, các vector nhúng văn bản sẽ được tạo từ đối số đầu vào `prompt`. pooled_prompt_embeds (`torch.FloatTensor`, *tùy chọn*) : Các embedding văn bản đã được pool sẵn. Có thể dùng để dễ dàng điều chỉnh các đầu vào văn bản, *vd.* trọng số prompt. Nếu không được cung cấp, các embedding văn bản đã pool sẽ được tạo ra từ đối số đầu vào `prompt`. lora_scale (`float`, *tuỳ chọn*) : Một hệ số lora sẽ được áp dụng cho tất cả các lớp LoRA của text encoder nếu các lớp LoRA được nạp. ## 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) ``` [Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_output.py#L11) **Tham số:** images (`list[PIL.Image.Image]` hoặc `torch.Tensor` hoặc `np.ndarray`) : danh sách các hình ảnh PIL đã khử nhiễu có độ dài `batch_size` hoặc mảng numpy hoặc tensor torch có hình dạng `(batch_size, height, width, num_channels)`. Các hình ảnh PIL hoặc mảng numpy thể hiện các hình ảnh đã khử nhiễu của pipeline khuếch tán. Các tensor torch có thể đại diện cho các hình ảnh đã khử nhiễu hoặc các latent trung gian sẵn sàng để truyền vào bộ giải mã. Lớp đầu ra cho các pipeline tạo ảnh Flux.