class_docstr: <Tip warning={true}>
  
  This is an experimental feature!
  
  </Tip>
  
  Pipeline for text-guided image inpainting using Stable Diffusion and DiffEdit.
  
  This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
  implemented for all pipelines (downloading, saving, running on a particular device, etc.).
  
  The pipeline also inherits the following loading and saving methods:
      - [`~loaders.TextualInversionLoaderMixin.load_textual_inversion`] for loading textual inversion embeddings
      - [`~loaders.LoraLoaderMixin.load_lora_weights`] for loading LoRA weights
      - [`~loaders.LoraLoaderMixin.save_lora_weights`] for saving LoRA weights
  
  Args:
      vae ([`AutoencoderKL`]):
          Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.
      text_encoder ([`~transformers.CLIPTextModel`]):
          Frozen text-encoder ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
      tokenizer ([`~transformers.CLIPTokenizer`]):
          A `CLIPTokenizer` to tokenize text.
      unet ([`UNet2DConditionModel`]):
          A `UNet2DConditionModel` to denoise the encoded image latents.
      scheduler ([`SchedulerMixin`]):
          A scheduler to be used in combination with `unet` to denoise the encoded image latents.
      inverse_scheduler ([`DDIMInverseScheduler`]):
          A scheduler to be used in combination with `unet` to fill in the unmasked part of the input latents.
      safety_checker ([`StableDiffusionSafetyChecker`]):
          Classification module that estimates whether generated images could be considered offensive or harmful.
          Please refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for more details
          about a model's potential harms.
      feature_extractor ([`~transformers.CLIPImageProcessor`]):
          A `CLIPImageProcessor` to extract features from generated images; used as inputs to the `safety_checker`.
class_docstr_tok: ["<","Tip","warning=","{","true","}",">","This","is","an","experimental","feature","!","<","\/Tip",">","Pipeline","for","text-guided","image","inpainting","using","Stable","Diffusion","and","DiffEdit",".","This","model","inherits","from","[","`","DiffusionPipeline","`","]",".","Check","the","superclass","documentation","for","the","generic","methods","implemented","for","all","pipelines","(","downloading",",","saving",",","running","on","a","particular","device",",","etc.",")",".","The","pipeline","also","inherits","the","following","loading","and","saving","methods",":","-","[","`","~loaders.TextualInversionLoaderMixin.load_textual_inversion","`","]","for","loading","textual","inversion","embeddings","-","[","`","~loaders.LoraLoaderMixin.load_lora_weights","`","]","for","loading","LoRA","weights","-","[","`","~loaders.LoraLoaderMixin.save_lora_weights","`","]","for","saving","LoRA","weights","Args",":","vae","(","[","`","AutoencoderKL","`","]",")",":","Variational","Auto-Encoder","(","VAE",")","model","to","encode","and","decode","images","to","and","from","latent","representations",".","text_encoder","(","[","`","~transformers.CLIPTextModel","`","]",")",":","Frozen","text-encoder","(","[","clip-vit-large-patch14","]","(","https",":","\/\/huggingface.co\/openai\/clip-vit-large-patch14",")",")",".","tokenizer","(","[","`","~transformers.CLIPTokenizer","`","]",")",":","A","`","CLIPTokenizer","`","to","tokenize","text",".","unet","(","[","`","UNet2DConditionModel","`","]",")",":","A","`","UNet2DConditionModel","`","to","denoise","the","encoded","image","latents",".","scheduler","(","[","`","SchedulerMixin","`","]",")",":","A","scheduler","to","be","used","in","combination","with","`","unet","`","to","denoise","the","encoded","image","latents",".","inverse_scheduler","(","[","`","DDIMInverseScheduler","`","]",")",":","A","scheduler","to","be","used","in","combination","with","`","unet","`","to","fill","in","the","unmasked","part","of","the","input","latents",".","safety_checker","(","[","`","StableDiffusionSafetyChecker","`","]",")",":","Classification","module","that","estimates","whether","generated","images","could","be","considered","offensive","or","harmful",".","Please","refer","to","the","[","model","card","]","(","https",":","\/\/huggingface.co\/runwayml\/stable-diffusion-v1-5",")","for","more","details","about","a","model","'s","potential","harms",".","feature_extractor","(","[","`","~transformers.CLIPImageProcessor","`","]",")",":","A","`","CLIPImageProcessor","`","to","extract","features","from","generated","images",";","used","as","inputs","to","the","`","safety_checker","`","."]
docstr: Generate a latent mask given a mask prompt, a target prompt, and an image.
  
  Args:
      image (`PIL.Image.Image`):
          `Image` or tensor representing an image batch to be used for computing the mask.
      target_prompt (`str` or `List[str]`, *optional*):
          The prompt or prompts to guide semantic mask generation. If not defined, you need to pass
          `prompt_embeds`.
      target_negative_prompt (`str` or `List[str]`, *optional*):
          The prompt or prompts to guide what to not include in image generation. If not defined, you need to
          pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).
      target_prompt_embeds (`torch.FloatTensor`, *optional*):
          Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
          provided, text embeddings are generated from the `prompt` input argument.
      target_negative_prompt_embeds (`torch.FloatTensor`, *optional*):
          Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
          not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument.
      source_prompt (`str` or `List[str]`, *optional*):
          The prompt or prompts to guide semantic mask generation using DiffEdit. If not defined, you need to
          pass `source_prompt_embeds` or `source_image` instead.
      source_negative_prompt (`str` or `List[str]`, *optional*):
          The prompt or prompts to guide semantic mask generation away from using DiffEdit. If not defined, you
          need to pass `source_negative_prompt_embeds` or `source_image` instead.
      source_prompt_embeds (`torch.FloatTensor`, *optional*):
          Pre-generated text embeddings to guide the semantic mask generation. Can be used to easily tweak text
          inputs (prompt weighting). If not provided, text embeddings are generated from `source_prompt` input
          argument.
      source_negative_prompt_embeds (`torch.FloatTensor`, *optional*):
          Pre-generated text embeddings to negatively guide the semantic mask generation. Can be used to easily
          tweak text inputs (prompt weighting). If not provided, text embeddings are generated from
          `source_negative_prompt` input argument.
      num_maps_per_mask (`int`, *optional*, defaults to 10):
          The number of noise maps sampled to generate the semantic mask using DiffEdit.
      mask_encode_strength (`float`, *optional*, defaults to 0.5):
          The strength of the noise maps sampled to generate the semantic mask using DiffEdit. Must be between 0
          and 1.
      mask_thresholding_ratio (`float`, *optional*, defaults to 3.0):
          The maximum multiple of the mean absolute difference used to clamp the semantic guidance map before
          mask binarization.
      num_inference_steps (`int`, *optional*, defaults to 50):
          The number of denoising steps. More denoising steps usually lead to a higher quality image at the
          expense of slower inference.
      guidance_scale (`float`, *optional*, defaults to 7.5):
          A higher guidance scale value encourages the model to generate images closely linked to the text
          `prompt` at the expense of lower image quality. Guidance scale is enabled when `guidance_scale > 1`.
      generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
          A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
          generation deterministic.
      output_type (`str`, *optional*, defaults to `"pil"`):
          The output format of the generated image. Choose between `PIL.Image` or `np.array`.
      cross_attention_kwargs (`dict`, *optional*):
          A kwargs dictionary that if specified is passed along to the
          [`~models.attention_processor.AttnProcessor`] as defined in
          [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
  
  Examples:
  
  Returns:
      `List[PIL.Image.Image]` or `np.array`:
          When returning a `List[PIL.Image.Image]`, the list consists of a batch of single-channel binary images
          with dimensions `(height // self.vae_scale_factor, width // self.vae_scale_factor)`. If it's
          `np.array`, the shape is `(batch_size, height // self.vae_scale_factor, width //
          self.vae_scale_factor)`.
docstr_tok: ["Generate","a","latent","mask","given","a","mask","prompt",",","a","target","prompt",",","and","an","image",".","Args",":","image","(","`","PIL.Image.Image","`",")",":","`","Image","`","or","tensor","representing","an","image","batch","to","be","used","for","computing","the","mask",".","target_prompt","(","`","str","`","or","`","List","[","str","]","`",",","*","optional","*",")",":","The","prompt","or","prompts","to","guide","semantic","mask","generation",".","If","not","defined",",","you","need","to","pass","`","prompt_embeds","`",".","target_negative_prompt","(","`","str","`","or","`","List","[","str","]","`",",","*","optional","*",")",":","The","prompt","or","prompts","to","guide","what","to","not","include","in","image","generation",".","If","not","defined",",","you","need","to","pass","`","negative_prompt_embeds","`","instead",".","Ignored","when","not","using","guidance","(","`","guidance_scale","<","1","`",")",".","target_prompt_embeds","(","`","torch.FloatTensor","`",",","*","optional","*",")",":","Pre-generated","text","embeddings",".","Can","be","used","to","easily","tweak","text","inputs","(","prompt","weighting",")",".","If","not","provided",",","text","embeddings","are","generated","from","the","`","prompt","`","input","argument",".","target_negative_prompt_embeds","(","`","torch.FloatTensor","`",",","*","optional","*",")",":","Pre-generated","negative","text","embeddings",".","Can","be","used","to","easily","tweak","text","inputs","(","prompt","weighting",")",".","If","not","provided",",","`","negative_prompt_embeds","`","are","generated","from","the","`","negative_prompt","`","input","argument",".","source_prompt","(","`","str","`","or","`","List","[","str","]","`",",","*","optional","*",")",":","The","prompt","or","prompts","to","guide","semantic","mask","generation","using","DiffEdit",".","If","not","defined",",","you","need","to","pass","`","source_prompt_embeds","`","or","`","source_image","`","instead",".","source_negative_prompt","(","`","str","`","or","`","List","[","str","]","`",",","*","optional","*",")",":","The","prompt","or","prompts","to","guide","semantic","mask","generation","away","from","using","DiffEdit",".","If","not","defined",",","you","need","to","pass","`","source_negative_prompt_embeds","`","or","`","source_image","`","instead",".","source_prompt_embeds","(","`","torch.FloatTensor","`",",","*","optional","*",")",":","Pre-generated","text","embeddings","to","guide","the","semantic","mask","generation",".","Can","be","used","to","easily","tweak","text","inputs","(","prompt","weighting",")",".","If","not","provided",",","text","embeddings","are","generated","from","`","source_prompt","`","input","argument",".","source_negative_prompt_embeds","(","`","torch.FloatTensor","`",",","*","optional","*",")",":","Pre-generated","text","embeddings","to","negatively","guide","the","semantic","mask","generation",".","Can","be","used","to","easily","tweak","text","inputs","(","prompt","weighting",")",".","If","not","provided",",","text","embeddings","are","generated","from","`","source_negative_prompt","`","input","argument",".","num_maps_per_mask","(","`","int","`",",","*","optional","*",",","defaults","to","10",")",":","The","number","of","noise","maps","sampled","to","generate","the","semantic","mask","using","DiffEdit",".","mask_encode_strength","(","`","float","`",",","*","optional","*",",","defaults","to","0.5",")",":","The","strength","of","the","noise","maps","sampled","to","generate","the","semantic","mask","using","DiffEdit",".","Must","be","between","0","and","1.","mask_thresholding_ratio","(","`","float","`",",","*","optional","*",",","defaults","to","3.0",")",":","The","maximum","multiple","of","the","mean","absolute","difference","used","to","clamp","the","semantic","guidance","map","before","mask","binarization",".","num_inference_steps","(","`","int","`",",","*","optional","*",",","defaults","to","50",")",":","The","number","of","denoising","steps",".","More","denoising","steps","usually","lead","to","a","higher","quality","image","at","the","expense","of","slower","inference",".","guidance_scale","(","`","float","`",",","*","optional","*",",","defaults","to","7.5",")",":","A","higher","guidance","scale","value","encourages","the","model","to","generate","images","closely","linked","to","the","text","`","prompt","`","at","the","expense","of","lower","image","quality",".","Guidance","scale","is","enabled","when","`","guidance_scale",">","1","`",".","generator","(","`","torch.Generator","`","or","`","List","[","torch.Generator","]","`",",","*","optional","*",")",":","A","[","`","torch.Generator","`","]","(","https",":","\/\/pytorch.org\/docs\/stable\/generated\/torch.Generator.html",")","to","make","generation","deterministic",".","output_type","(","`","str","`",",","*","optional","*",",","defaults","to","`","``","pil","''","`",")",":","The","output","format","of","the","generated","image",".","Choose","between","`","PIL.Image","`","or","`","np.array","`",".","cross_attention_kwargs","(","`","dict","`",",","*","optional","*",")",":","A","kwargs","dictionary","that","if","specified","is","passed","along","to","the","[","`","~models.attention_processor.AttnProcessor","`","]","as","defined","in","[","`","self.processor","`","]","(","https",":","\/\/github.com\/huggingface\/diffusers\/blob\/main\/src\/diffusers\/models\/attention_processor.py",")",".","Examples",":","Returns",":","`","List","[","PIL.Image.Image","]","`","or","`","np.array","`",":","When","returning","a","`","List","[","PIL.Image.Image","]","`",",","the","list","consists","of","a","batch","of","single-channel","binary","images","with","dimensions","`","(","height","\/\/","self.vae_scale_factor",",","width","\/\/","self.vae_scale_factor",")","`",".","If","it's","`","np.array","`",",","the","shape","is","`","(","batch_size",",","height","\/\/","self.vae_scale_factor",",","width","\/\/","self.vae_scale_factor",")","`","."]
code: def generate_mask(
      self,
      image: Union[torch.FloatTensor, PIL.Image.Image] = None,
      target_prompt: Optional[Union[str, List[str]]] = None,
      target_negative_prompt: Optional[Union[str, List[str]]] = None,
      target_prompt_embeds: Optional[torch.FloatTensor] = None,
      target_negative_prompt_embeds: Optional[torch.FloatTensor] = None,
      source_prompt: Optional[Union[str, List[str]]] = None,
      source_negative_prompt: Optional[Union[str, List[str]]] = None,
      source_prompt_embeds: Optional[torch.FloatTensor] = None,
      source_negative_prompt_embeds: Optional[torch.FloatTensor] = None,
      num_maps_per_mask: Optional[int] = 10,
      mask_encode_strength: Optional[float] = 0.5,
      mask_thresholding_ratio: Optional[float] = 3.0,
      num_inference_steps: int = 50,
      guidance_scale: float = 7.5,
      generator: Optional[
          Union[torch.Generator, List[torch.Generator]]
      ] = None,
      output_type: Optional[str] = "np",
      cross_attention_kwargs: Optional[Dict[str, Any]] = None,
  ):
      r"""
      Generate a latent mask given a mask prompt, a target prompt, and an image.
  
      Args:
          image (`PIL.Image.Image`):
              `Image` or tensor representing an image batch to be used for computing the mask.
          target_prompt (`str` or `List[str]`, *optional*):
              The prompt or prompts to guide semantic mask generation. If not defined, you need to pass
              `prompt_embeds`.
          target_negative_prompt (`str` or `List[str]`, *optional*):
              The prompt or prompts to guide what to not include in image generation. If not defined, you need to
              pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).
          target_prompt_embeds (`torch.FloatTensor`, *optional*):
              Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
              provided, text embeddings are generated from the `prompt` input argument.
          target_negative_prompt_embeds (`torch.FloatTensor`, *optional*):
              Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
              not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument.
          source_prompt (`str` or `List[str]`, *optional*):
              The prompt or prompts to guide semantic mask generation using DiffEdit. If not defined, you need to
              pass `source_prompt_embeds` or `source_image` instead.
          source_negative_prompt (`str` or `List[str]`, *optional*):
              The prompt or prompts to guide semantic mask generation away from using DiffEdit. If not defined, you
              need to pass `source_negative_prompt_embeds` or `source_image` instead.
          source_prompt_embeds (`torch.FloatTensor`, *optional*):
              Pre-generated text embeddings to guide the semantic mask generation. Can be used to easily tweak text
              inputs (prompt weighting). If not provided, text embeddings are generated from `source_prompt` input
              argument.
          source_negative_prompt_embeds (`torch.FloatTensor`, *optional*):
              Pre-generated text embeddings to negatively guide the semantic mask generation. Can be used to easily
              tweak text inputs (prompt weighting). If not provided, text embeddings are generated from
              `source_negative_prompt` input argument.
          num_maps_per_mask (`int`, *optional*, defaults to 10):
              The number of noise maps sampled to generate the semantic mask using DiffEdit.
          mask_encode_strength (`float`, *optional*, defaults to 0.5):
              The strength of the noise maps sampled to generate the semantic mask using DiffEdit. Must be between 0
              and 1.
          mask_thresholding_ratio (`float`, *optional*, defaults to 3.0):
              The maximum multiple of the mean absolute difference used to clamp the semantic guidance map before
              mask binarization.
          num_inference_steps (`int`, *optional*, defaults to 50):
              The number of denoising steps. More denoising steps usually lead to a higher quality image at the
              expense of slower inference.
          guidance_scale (`float`, *optional*, defaults to 7.5):
              A higher guidance scale value encourages the model to generate images closely linked to the text
              `prompt` at the expense of lower image quality. Guidance scale is enabled when `guidance_scale > 1`.
          generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
              A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
              generation deterministic.
          output_type (`str`, *optional*, defaults to `"pil"`):
              The output format of the generated image. Choose between `PIL.Image` or `np.array`.
          cross_attention_kwargs (`dict`, *optional*):
              A kwargs dictionary that if specified is passed along to the
              [`~models.attention_processor.AttnProcessor`] as defined in
              [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
  
      Examples:
  
      Returns:
          `List[PIL.Image.Image]` or `np.array`:
              When returning a `List[PIL.Image.Image]`, the list consists of a batch of single-channel binary images
              with dimensions `(height // self.vae_scale_factor, width // self.vae_scale_factor)`. If it's
              `np.array`, the shape is `(batch_size, height // self.vae_scale_factor, width //
              self.vae_scale_factor)`.
      """
  
      # 1. Check inputs (Provide dummy argument for callback_steps)
      self.check_inputs(
          target_prompt,
          mask_encode_strength,
          1,
          target_negative_prompt,
          target_prompt_embeds,
          target_negative_prompt_embeds,
      )
  
      self.check_source_inputs(
          source_prompt,
          source_negative_prompt,
          source_prompt_embeds,
          source_negative_prompt_embeds,
      )
  
      if (num_maps_per_mask is None) or (
          num_maps_per_mask is not None
          and (
              not isinstance(num_maps_per_mask, int)
              or num_maps_per_mask <= 0
          )
      ):
          raise ValueError(
              f"`num_maps_per_mask` has to be a positive integer but is {num_maps_per_mask} of type"
              f" {type(num_maps_per_mask)}."
          )
  
      if (
          mask_thresholding_ratio is None
          or mask_thresholding_ratio <= 0
      ):
          raise ValueError(
              f"`mask_thresholding_ratio` has to be positive but is {mask_thresholding_ratio} of type"
              f" {type(mask_thresholding_ratio)}."
          )
  
      # 2. Define call parameters
      if target_prompt is not None and isinstance(target_prompt, str):
          batch_size = 1
      elif target_prompt is not None and isinstance(
          target_prompt, list
      ):
          batch_size = len(target_prompt)
      else:
          batch_size = target_prompt_embeds.shape[0]
      if cross_attention_kwargs is None:
          cross_attention_kwargs = {}
  
      device = self._execution_device
      # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
      # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
      # corresponds to doing no classifier free guidance.
      do_classifier_free_guidance = guidance_scale > 1.0
  
      # 3. Encode input prompts
      (
          cross_attention_kwargs.get("scale", None)
          if cross_attention_kwargs is not None
          else None
      )
      (
          target_negative_prompt_embeds,
          target_prompt_embeds,
      ) = self.encode_prompt(
          target_prompt,
          device,
          num_maps_per_mask,
          do_classifier_free_guidance,
          target_negative_prompt,
          prompt_embeds=target_prompt_embeds,
          negative_prompt_embeds=target_negative_prompt_embeds,
      )
      # For classifier free guidance, we need to do two forward passes.
      # Here we concatenate the unconditional and text embeddings into a single batch
      # to avoid doing two forward passes
      if do_classifier_free_guidance:
          target_prompt_embeds = torch.cat(
              [target_negative_prompt_embeds, target_prompt_embeds]
          )
  
      (
          source_negative_prompt_embeds,
          source_prompt_embeds,
      ) = self.encode_prompt(
          source_prompt,
          device,
          num_maps_per_mask,
          do_classifier_free_guidance,
          source_negative_prompt,
          prompt_embeds=source_prompt_embeds,
          negative_prompt_embeds=source_negative_prompt_embeds,
      )
      if do_classifier_free_guidance:
          source_prompt_embeds = torch.cat(
              [source_negative_prompt_embeds, source_prompt_embeds]
          )
  
      # 4. Preprocess image
      image = self.image_processor.preprocess(image).repeat_interleave(
          num_maps_per_mask, dim=0
      )
  
      # 5. Set timesteps
      self.scheduler.set_timesteps(num_inference_steps, device=device)
      timesteps, _ = self.get_timesteps(
          num_inference_steps, mask_encode_strength, device
      )
      encode_timestep = timesteps[0]
  
      # 6. Prepare image latents and add noise with specified strength
      image_latents = self.prepare_image_latents(
          image,
          batch_size * num_maps_per_mask,
          self.vae.dtype,
          device,
          generator,
      )
      noise = randn_tensor(
          image_latents.shape,
          generator=generator,
          device=device,
          dtype=self.vae.dtype,
      )
      image_latents = self.scheduler.add_noise(
          image_latents, noise, encode_timestep
      )
  
      latent_model_input = torch.cat(
          [image_latents] * (4 if do_classifier_free_guidance else 2)
      )
      latent_model_input = self.scheduler.scale_model_input(
          latent_model_input, encode_timestep
      )
  
      # 7. Predict the noise residual
      prompt_embeds = torch.cat(
          [source_prompt_embeds, target_prompt_embeds]
      )
      noise_pred = self.unet(
          latent_model_input,
          encode_timestep,
          encoder_hidden_states=prompt_embeds,
          cross_attention_kwargs=cross_attention_kwargs,
      ).sample
  
      if do_classifier_free_guidance:
          (
              noise_pred_neg_src,
              noise_pred_source,
              noise_pred_uncond,
              noise_pred_target,
          ) = noise_pred.chunk(4)
          noise_pred_source = noise_pred_neg_src + guidance_scale * (
              noise_pred_source - noise_pred_neg_src
          )
          noise_pred_target = noise_pred_uncond + guidance_scale * (
              noise_pred_target - noise_pred_uncond
          )
      else:
          noise_pred_source, noise_pred_target = noise_pred.chunk(2)
  
      # 8. Compute the mask from the absolute difference of predicted noise residuals
      # TODO: Consider smoothing mask guidance map
      mask_guidance_map = (
          torch.abs(noise_pred_target - noise_pred_source)
          .reshape(
              batch_size,
              num_maps_per_mask,
              *noise_pred_target.shape[-3:],
          )
          .mean([1, 2])
      )
      clamp_magnitude = (
          mask_guidance_map.mean() * mask_thresholding_ratio
      )
      semantic_mask_image = (
          mask_guidance_map.clamp(0, clamp_magnitude) / clamp_magnitude
      )
      semantic_mask_image = torch.where(
          semantic_mask_image <= 0.5, 0, 1
      )
      mask_image = semantic_mask_image.cpu().numpy()
  
      # 9. Convert to Numpy array or PIL.
      if output_type == "pil":
          mask_image = self.image_processor.numpy_to_pil(mask_image)
  
      # Offload all models
      self.maybe_free_model_hooks()
  
      return mask_image
  
imports: import inspect
  from dataclasses import dataclass
  from typing import Any, Callable, Dict, List, Optional, Union
  import numpy
  import PIL.Image
  import torch
  from packaging import version
  from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer
  from ...configuration_utils import FrozenDict
  from ...image_processor import VaeImageProcessor
  from ...loaders import LoraLoaderMixin, TextualInversionLoaderMixin
  from ...models import AutoencoderKL, UNet2DConditionModel
  from ...models.lora import adjust_lora_scale_text_encoder
  from ...schedulers import DDIMInverseScheduler, KarrasDiffusionSchedulers
  from ...utils import PIL_INTERPOLATION, USE_PEFT_BACKEND, BaseOutput, deprecate, logging, replace_example_docstring, scale_lora_layers, unscale_lora_layers
  from ...utils.torch_utils import randn_tensor
  from ..pipeline_utils import DiffusionPipeline
  from .None import StableDiffusionPipelineOutput
  from .safety_checker import StableDiffusionSafetyChecker
label_desc: Use image node_id 18 for calling the StableDiffusionDiffEditPipeline obj's underlying member method code with example usage: obj.generate_mask(image, target_prompt, target_negative_prompt, target_prompt_embeds, target_negative_prompt_embeds, source_prompt, source_negative_prompt, source_prompt_embeds, source_negative_prompt_embeds, num_maps_per_mask, mask_encode_strength, mask_thresholding_ratio, num_inference_steps, guidance_scale, generator, output_type, cross_attention_kwargs) and returns: mask_image