# FluxControlInpaint FluxControlInpaintPipeline, Flux.1 Depth/Canny modelleri için Inpainting'in bir uygulamasıdır. Bu pipeline, Flux.1 Depth/Canny modellerini kullanarak görsellerde inpainting yapmanıza olanak tanır. Pipeline, girdi olarak bir görsel ve bir maske alır ve inpainting uygulanmış görseli döndürür. FLUX.1 Depth and Canny [dev], verilen bir girdi görselinin yapısını takip ederken metin açıklamasına dayalı görsel üretebilen 12 milyar parametreli bir rectified flow transformer'dır. **Bu bir ControlNet modeli değildir**. | Kontrol türü | Geliştirici | Bağlantı | | -------- | ---------- | ---- | | Derinlik | [Black Forest Labs](https://huggingface.co/black-forest-labs) | [Bağlantı](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev) | | Canny | [Black Forest Labs](https://huggingface.co/black-forest-labs) | [Bağlantı](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev) | > [!TIP] > Flux, tüketici donanım cihazlarında çalıştırıldığında oldukça maliyetli olabilir. Ancak, onu daha hızlı ve bellek açısından daha verimli bir şekilde çalıştırmak için bir dizi optimizasyon uygulayabilirsiniz. Daha fazla ayrıntı için [bu bölümü](https://huggingface.co/blog/sd3#memory-optimizations-for-sd3) inceleyin. Ayrıca, Flux, çıkarım gecikmesinde bir ödün karşılığında bellek verimliliği için kuantizasyondan faydalanabilir. Daha fazla bilgi edinmek için [bu blog yazısına](https://huggingface.co/blog/quanto-diffusers) göz atın. Kapsamlı bir kaynak listesi için [bu gist'e](https://gist.github.com/sayakpaul/b664605caf0aa3bf8585ab109dd5ac9c) bakın. ```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) ``` [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_inpaint.py#L204) **Parametreler:** transformer ([FluxTransformer2DModel](/docs/diffusers/main/tr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : Kodlanmış görüntü latentlerini gürültüden arındırmak için kullanılan Koşullu Transformer (MMDiT) mimarisi. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/tr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Kodlanmış görüntü latentlerini gürültüden arındırmak için `transformer` ile birlikte kullanılacak bir zamanlayıcı. vae ([AutoencoderKL](/docs/diffusers/main/tr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Görüntüleri gizil (latent) temsillere kodlamak ve bu temsillerden görüntülere çözmek için kullanılan Varyasyonel Oto-Kodlayıcı (VAE) Modeli. text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), özellikle [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) varyantı. text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), özellikle [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl) varyantı. tokenizer (`CLIPTokenizer`) : [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer) sınıfının tokenizer'ı. tokenizer_2 (`T5TokenizerFast`) : [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast) sınıfının ikinci Tokenizer'ı. Flux-dev-Depth/Canny kullanarak görüntü inpainting için Flux hattı. Referans: 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 = ['latents'], max_sequence_length: int = 512) ``` [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_inpaint.py#L753) **Parametreler:** prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmek için istem veya istemler. Tanımlanmamışsa, bunun yerine `prompt_embeds` geçirilmelidir. prompt_2 (`str` veya `list[str]`, *isteğe bağlı*) : `tokenizer_2` ve `text_encoder_2`'ye gönderilecek istem veya istemler. Tanımlanmamışsa bunun yerine `prompt` kullanılır image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` veya `list[np.ndarray]`) : Başlangıç noktası olarak kullanılacak bir görüntü partisyonunu temsil eden `Image`, numpy dizisi veya tensör. Hem numpy dizisi hem de pytorch tensörü için beklenen değer aralığı `[0, 1]` arasındadır. Tensör veya tensör listesi olması durumunda beklenen şekil `(B, C, H, W)` veya `(C, H, W)` olmalıdır. Numpy dizisi veya dizi listesi olması durumunda beklenen şekil `(B, H, W, C)` veya `(H, W, C)` olmalıdır. Ayrıca `image` olarak görüntü latentlerini de kabul edebilir, ancak latentler doğrudan geçirildiğinde tekrar kodlanmaz. 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]]` veya `list[list[PIL.Image.Image]]`): Üretim sırasında `unet`'e rehberlik sağlamak için sağlanacak ControlNet giriş koşulu. Tür `torch.Tensor` olarak belirtilirse, ControlNet'e olduğu gibi iletilir. `PIL.Image.Image` de bir görüntü olarak kabul edilebilir. Çıktı görüntüsünün boyutları varsayılan olarak `image`'ın boyutlarına eşittir. Yükseklik ve/veya genişlik geçirilirse, `image` buna göre yeniden boyutlandırılır. `init` içinde birden fazla ControlNet belirtilmişse, her bir ControlNet'e girdi olarak doğru şekilde toplu işlenebilmesi için görüntülerin bir liste olarak geçirilmesi gerekir. mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` veya `list[np.ndarray]`) : `image` için maske uygulanacak görüntü partisyonunu temsil eden `Image`, numpy dizisi veya tensör. Maske içindeki beyaz pikseller yeniden boyanırken siyah pikseller korunur. `mask_image` bir PIL görüntüsü ise, kullanılmadan önce tek kanala (parlaklık) dönüştürülür. Numpy dizisi veya pytorch tensörü ise 3 kanal yerine tek renk kanalı (L) içermelidir; bu nedenle pytorch tensörü için beklenen şekil `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)` veya `(H, W)` olur. Numpy dizisi için ise `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)` veya `(H, W)` şeklindedir. masked_image_latents (`torch.Tensor`, `list[torch.Tensor]`) : VAE tarafından üretilen `image`'ı maskelemek için bir görüntü partisini temsil eden `Tensor`. Sağlanmazsa, maske latentsi tensörü `mask_image` tarafından oluşturulur. height (`int`, *isteğe bağlı*, varsayılan olarak self.unet.config.sample_size * self.vae_scale_factor) : Üretilen görüntünün piksel cinsinden yüksekliği. En iyi sonuçlar için varsayılan olarak 1024 olarak ayarlanır. width (`int`, *isteğe bağlı*, varsayılan olarak self.unet.config.sample_size * self.vae_scale_factor) : Üretilen görüntünün piksel cinsinden genişliği. En iyi sonuçlar için varsayılan olarak 1024 olarak ayarlanır. strength (`float`, *opsiyonel*, varsayılan 1.0) : Referans `image`'in ne ölçüde dönüştürüleceğini belirtir. 0 ile 1 arasında olmalıdır. `image` bir başlangıç noktası olarak kullanılır ve `strength` değeri arttıkça daha fazla gürültü eklenir. Gürültü azaltma adımlarının sayısı, başlangıçta eklenen gürültü miktarına bağlıdır. `strength` 1 olduğunda eklenen gürültü maksimumdur ve gürültü azaltma süreci, `num_inference_steps` içinde belirtilen tam tekrar sayısı kadar çalışır. 1 değeri, `image`'ı fiilen yok sayar. num_inference_steps (`int`, *isteğe bağlı*, varsayılan 50) : Gürültü azaltma adım sayısı. Daha fazla gürültü azaltma adımı genellikle daha yavaş çıkarım pahasına daha yüksek kaliteli bir görüntüye yol açar. sigmas (`list[float]`, *isteğe bağlı*) : `set_timesteps` metodunda `sigmas` argümanını destekleyen zamanlayıcılarla gürültü azaltma süreci için kullanılacak özel sigmalar. Tanımlanmamışsa, `num_inference_steps` geçirildiğinde varsayılan davranış kullanılacaktır. guidance_scale (`float`, *isteğe bağlı*, varsayılan 7.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. num_images_per_prompt (`int`, *isteğe bağlı*, varsayılan 1) : Her istem için üretilecek görsel sayısı. generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir veya [torch üreteci(leri)](https://pytorch.org/docs/stable/generated/torch.Generator.html) listesi. latents (`torch.FloatTensor`, *isteğe bağlı*) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenmiş önceden oluşturulmuş gürültülü latensler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele `generator` kullanılarak örneklemeye dayalı bir latens tensörü oluşturulur. prompt_embeds (`torch.FloatTensor`, *isteğe bağlı*) : Ön oluşturulmuş metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, metin gömme değerleri `prompt` girdi argümanından oluşturulur. pooled_prompt_embeds (`torch.FloatTensor`, *isteğe bağlı*) : Önceden oluşturulmuş havuzlanmış metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, havuzlanmış metin gömme değerleri `prompt` girdi argümanından oluşturulur. output_type (`str`, *isteğe bağlı*, varsayılan `"pil"`) : Üretilen görüntünün çıktı biçimi. [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` veya `np.array` arasında seçim yapın. return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine `~pipelines.flux.FluxPipelineOutput` döndürülecek mi? joint_attention_kwargs (`dict`, *isteğe bağlı*) : Belirtilirse, [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py) içinde `self.processor` altında tanımlanan `AttentionProcessor`'a iletilen bir kwargs sözlüğü. callback_on_step_end (`Callable`, *isteğe bağlı*) : Çıkarım sırasında her gürültü azaltma adımının sonunda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs`, `callback_on_step_end_tensor_inputs` tarafından belirtilen tüm tensörlerin listesini içerir. callback_on_step_end_tensor_inputs (`list`, *isteğe bağlı*) : `callback_on_step_end` işlevi için girdi tensörlerinin listesi. Listede belirtilen tensörler, `callback_kwargs` argümanı olarak geçirilir. Yalnızca pipeline sınıfınızın `._callback_tensor_inputs` özniteliğinde listelenen değişkenleri dahil edebilirsiniz. max_sequence_length (`int` varsayılanı 512) : `prompt` ile kullanılacak maksimum dizi uzunluğu. **Dönüş:** `~pipelines.flux.FluxPipelineOutput` veya `tuple` `return_dict` True ise `~pipelines.flux.FluxPipelineOutput`, aksi halde bir `tuple`. Tuple döndürüldüğünde, ilk öğe üretilen görsellerin listesidir. Üretim için pipeline çağrıldığında tetiklenen işlev. Örnekler: ```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) ``` [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_inpaint.py#L376) **Parametreler:** prompt (`str` veya `list[str]`, *isteğe bağlı*) : kodlanacak istem prompt_2 (`str` veya `list[str]`, *isteğe bağlı*) : `tokenizer_2` ve `text_encoder_2`'ye gönderilecek istem veya istemler. Tanımlanmamışsa, tüm metin kodlayıcılarda `prompt` kullanılır device : (`torch.device`): torch cihazı num_images_per_prompt (`int`) : her istem için oluşturulacak görsel sayısı prompt_embeds (`torch.FloatTensor`, *isteğe bağlı*) : Ön oluşturulmuş metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, metin gömme değerleri `prompt` girdi argümanından oluşturulur. pooled_prompt_embeds (`torch.FloatTensor`, *isteğe bağlı*) : Önceden oluşturulmuş havuzlanmış metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, havuzlanmış metin gömme değerleri `prompt` girdi argümanından oluşturulur. lora_scale (`float`, *isteğe bağlı*) : LoRA katmanları yüklendiyse, metin kodlayıcısının tüm LoRA katmanlarına uygulanacak bir lora ölçeği. ## 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) ``` [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_output.py#L11) **Parametreler:** images (`list[PIL.Image.Image]` veya `torch.Tensor` veya `np.ndarray`) : `batch_size` uzunluğunda gürültüsü azaltılmış PIL görüntülerinin listesi veya `(batch_size, height, width, num_channels)` biçiminde numpy dizisi veya torch tensörü. PIL görüntüleri veya numpy dizisi, difüzyon hattının gürültüsü azaltılmış görüntülerini temsil eder. Torch tensörleri, gürültüsü azaltılmış görüntüleri ya da dekodöre aktarılmaya hazır ara latentleri temsil edebilir. Flux görüntü oluşturma hatları için çıktı sınıfı.