




'''simple docstring'''






import argparse
import json

import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm.models import create_model

from transformers import (
    BeitImageProcessor,
    DataaVecVisionConfig,
    DataaVecVisionForImageClassification,
    DataaVecVisionModel,
)

def       __lowerCAmelCase (   snake_case__ ,				snake_case__=False ,				snake_case__=False ,				snake_case__="data2vec."						):
			__UpperCamelCase				:      str									=       "backbone." if is_semantic else ""

			__UpperCamelCase				:      Optional[int]									=       []
			for i in range(config.num_hidden_layers						):
						# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
						rename_keys.append(
						    (F"{prefix}blocks.{i}.norm1.weight", F"{hf_prefix}encoder.layer.{i}.layernorm_before.weight")						)
						rename_keys.append((F"{prefix}blocks.{i}.norm1.bias", F"{hf_prefix}encoder.layer.{i}.layernorm_before.bias")						)
						rename_keys.append(
						    (F"{prefix}blocks.{i}.attn.proj.weight", F"{hf_prefix}encoder.layer.{i}.attention.output.dense.weight")						)
						rename_keys.append(
						    (F"{prefix}blocks.{i}.attn.proj.bias", F"{hf_prefix}encoder.layer.{i}.attention.output.dense.bias")						)
						rename_keys.append(
						    (F"{prefix}blocks.{i}.norm2.weight", F"{hf_prefix}encoder.layer.{i}.layernorm_after.weight")						)
						rename_keys.append((F"{prefix}blocks.{i}.norm2.bias", F"{hf_prefix}encoder.layer.{i}.layernorm_after.bias")						)
						rename_keys.append(
						    (F"{prefix}blocks.{i}.mlp.fc1.weight", F"{hf_prefix}encoder.layer.{i}.intermediate.dense.weight")						)
						rename_keys.append(
						    (F"{prefix}blocks.{i}.mlp.fc1.bias", F"{hf_prefix}encoder.layer.{i}.intermediate.dense.bias")						)
						rename_keys.append((F"{prefix}blocks.{i}.mlp.fc2.weight", F"{hf_prefix}encoder.layer.{i}.output.dense.weight")						)
						rename_keys.append((F"{prefix}blocks.{i}.mlp.fc2.bias", F"{hf_prefix}encoder.layer.{i}.output.dense.bias")						)

			# projection layer + position embeddings
			rename_keys.extend(
			    [
			        (F"{prefix}cls_token", F"{hf_prefix}embeddings.cls_token"),
			        (F"{prefix}patch_embed.proj.weight", F"{hf_prefix}embeddings.patch_embeddings.projection.weight"),
			        (F"{prefix}patch_embed.proj.bias", F"{hf_prefix}embeddings.patch_embeddings.projection.bias"),
			    ]						)

			if has_lm_head:
						# mask token + shared relative position bias + layernorm
						rename_keys.extend(
						    [
						        ("mask_token", F"{hf_prefix}embeddings.mask_token"),
						        (
						            "rel_pos_bias.relative_position_bias_table",
						            F"{hf_prefix}encoder.relative_position_bias.relative_position_bias_table",
						        ),
						        (
						            "rel_pos_bias.relative_position_index",
						            F"{hf_prefix}encoder.relative_position_bias.relative_position_index",
						        ),
						        ("norm.weight", "layernorm.weight"),
						        ("norm.bias", "layernorm.bias"),
						    ]						)
			elif is_semantic:
						# semantic segmentation classification heads
						rename_keys.extend(
						    [
						        ("decode_head.conv_seg.weight", "decode_head.classifier.weight"),
						        ("decode_head.conv_seg.bias", "decode_head.classifier.bias"),
						        ("auxiliary_head.conv_seg.weight", "auxiliary_head.classifier.weight"),
						        ("auxiliary_head.conv_seg.bias", "auxiliary_head.classifier.bias"),
						    ]						)
			else:
						# layernorm + classification head
						rename_keys.extend(
						    [
						        ("fc_norm.weight", F"{hf_prefix}pooler.layernorm.weight"),
						        ("fc_norm.bias", F"{hf_prefix}pooler.layernorm.bias"),
						        ("head.weight", "classifier.weight"),
						        ("head.bias", "classifier.bias"),
						    ]						)

			return rename_keys

def       __lowerCAmelCase (   snake_case__ ,				snake_case__ ,				snake_case__=False ,				snake_case__=False ,				snake_case__="data2vec_vision."						):
			for i in range(config.num_hidden_layers						):
						__UpperCamelCase				:      Union[str, Any]									=       "backbone." if is_semantic else ""
						# queries, keys and values
						__UpperCamelCase				:      Union[str, Any]									=       state_dict.pop(F"{prefix}blocks.{i}.attn.qkv.weight"						)
						__UpperCamelCase				:      Dict									=       state_dict.pop(F"{prefix}blocks.{i}.attn.q_bias"						)
						__UpperCamelCase				:      int									=       state_dict.pop(F"{prefix}blocks.{i}.attn.v_bias"						)

						__UpperCamelCase				:      str									=       in_proj_weight[
						    : config.hidden_size, :
						]
						__UpperCamelCase				:      Optional[Any]									=       q_bias
						__UpperCamelCase				:      List[str]									=       in_proj_weight[
						    config.hidden_size : config.hidden_size * 2, :
						]
						__UpperCamelCase				:      List[Any]									=       in_proj_weight[
						    -config.hidden_size :, :
						]
						__UpperCamelCase				:      Any									=       v_bias

						# gamma_1 and gamma_2
						# we call them lambda because otherwise they are renamed when using .from_pretrained
						__UpperCamelCase				:      List[str]									=       state_dict.pop(F"{prefix}blocks.{i}.gamma_1"						)
						__UpperCamelCase				:      Optional[Any]									=       state_dict.pop(F"{prefix}blocks.{i}.gamma_2"						)

						__UpperCamelCase				:      Dict									=       gamma_a
						__UpperCamelCase				:      Dict									=       gamma_a

						# relative_position bias table + index
						if not has_lm_head:
									# each layer has its own relative position bias
									__UpperCamelCase				:      Union[str, Any]									=       state_dict.pop(F"{prefix}blocks.{i}.attn.relative_position_bias_table"						)
									__UpperCamelCase				:      Any									=       state_dict.pop(F"{prefix}blocks.{i}.attn.relative_position_index"						)

									__UpperCamelCase				:      Union[str, Any]									=       table
									__UpperCamelCase				:      List[str]									=       index

def       __lowerCAmelCase (   ):
			__UpperCamelCase				:      str									=       argparse.ArgumentParser(
			    "Convert Data2VecVision to HF for image classification and pretraining" ,				add_help=snake_case__						)
			parser.add_argument("--hf_checkpoint_name" ,				type=snake_case__						)
			parser.add_argument("--input_size" ,				default=224 ,				type=snake_case__ ,				help="images input size"						)
			parser.add_argument("--beit_checkpoint" ,				default="" ,				help="beit checkpoint"						)

			return parser.parse_args()

def       __lowerCAmelCase (   snake_case__ ,				snake_case__ ,				snake_case__						):
			def load_state_dict(snake_case__ ,				snake_case__ ,				snake_case__="" ,				snake_case__="relative_position_index"						):
						__UpperCamelCase				:      str									=       []
						__UpperCamelCase				:      Optional[int]									=       []
						__UpperCamelCase				:      Optional[Any]									=       []
						# copy state_dict so _load_from_state_dict can modify it
						__UpperCamelCase				:      int									=       getattr(snake_case__ ,				"_metadata" ,				snake_case__						)
						__UpperCamelCase				:      Optional[Any]									=       state_dict.copy()
						if metadata is not None:
									__UpperCamelCase				:      Optional[int]									=       metadata

						def load(snake_case__ ,				snake_case__=""						):
									__UpperCamelCase				:      Optional[int]									=       {} if metadata is None else metadata.get(prefix[:-1] ,				{}						)
									module._load_from_state_dict(
									    snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__						)
									for name, child in module._modules.items():
												if child is not None:
															load(snake_case__ ,				prefix + name + "."						)

						load(snake_case__ ,				prefix=snake_case__						)

						__UpperCamelCase				:      Optional[int]									=       []
						__UpperCamelCase				:      Optional[Any]									=       []
						for key in missing_keys:
									__UpperCamelCase				:      Dict									=       True
									for ignore_key in ignore_missing.split("|"						):
												if ignore_key in key:
															__UpperCamelCase				:      Optional[int]									=       False
															break
									if keep_flag:
												warn_missing_keys.append(snake_case__						)
									else:
												ignore_missing_keys.append(snake_case__						)

						__UpperCamelCase				:      Optional[int]									=       warn_missing_keys

						if len(snake_case__						) > 0:
									print(
									    "Weights of {} not initialized from pretrained model: {}".format(
									        model.__class__.__name__ ,				snake_case__						)						)
						if len(snake_case__						) > 0:
									print("Weights from pretrained model not used in {}: {}".format(model.__class__.__name__ ,				snake_case__						)						)
						if len(snake_case__						) > 0:
									print(
									    "Ignored weights of {} not initialized from pretrained model: {}".format(
									        model.__class__.__name__ ,				snake_case__						)						)
						if len(snake_case__						) > 0:
									print("\n".join(snake_case__						)						)

			__UpperCamelCase				:      List[str]									=       {
			    "pretrained": False,
			    "use_shared_rel_pos_bias": True,
			    "use_abs_pos_emb": False,
			    "init_values": 0.1,
			}

			if is_finetuned:
						model_kwargs.update(
						    {
						        "num_classes": 1_000,
						        "use_mean_pooling": True,
						        "init_scale": 0.001,
						        "use_rel_pos_bias": True,
						    }						)

			__UpperCamelCase				:      Dict									=       create_model(
			    "beit_large_patch16_224" if is_large else "beit_base_patch16_224" ,				**snake_case__ ,				)
			__UpperCamelCase				:      Optional[int]									=       model.patch_embed.patch_size
			__UpperCamelCase				:      List[Any]									=       (args.input_size // patch_size[0], args.input_size // patch_size[1])
			__UpperCamelCase				:      Union[str, Any]									=       torch.load(args.beit_checkpoint ,				map_location="cpu"						)

			print(F"Load ckpt from {args.beit_checkpoint}"						)
			__UpperCamelCase				:      Optional[Any]									=       None
			for model_key in ("model", "module"):
						if model_key in checkpoint:
									__UpperCamelCase				:      int									=       checkpoint[model_key]
									print(F"Load state_dict by model_key = {model_key}"						)
									break

			__UpperCamelCase				:      Any									=       list(checkpoint_model.keys()						)
			for key in all_keys:
						if "relative_position_index" in key:
									checkpoint_model.pop(snake_case__						)

						if "relative_position_bias_table" in key:
									__UpperCamelCase				:      List[Any]									=       checkpoint_model[key]
									__UpperCamelCase		, __UpperCamelCase				:      List[Any]									=       rel_pos_bias.size()
									__UpperCamelCase		, __UpperCamelCase				:      Optional[Any]									=       model.state_dict()[key].size()
									__UpperCamelCase				:      Optional[int]									=       model.patch_embed.patch_shape
									if dst_patch_shape[0] != dst_patch_shape[1]:
												raise NotImplementedError()

			load_state_dict(snake_case__ ,				snake_case__ ,				prefix=""						)

			return model

def       __lowerCAmelCase (   ):
			__UpperCamelCase				:      Any									=       get_args()

			__UpperCamelCase				:      str									=       "ft1k" in args.hf_checkpoint_name
			__UpperCamelCase				:      Tuple									=       "large" in args.hf_checkpoint_name

			if is_finetuned:
						# To convert Beit's data2vec_vision to HF you need to copy
						# https://github.com/facebookresearch/data2vec_vision/blob/main/beit/modeling_finetune.py
						# into this folder.
						import modeling_finetune  # noqa: F401
			else:
						# To convert Beit's data2vec_vision to HF you need to copy
						# https://github.com/facebookresearch/data2vec_vision/blob/main/beit/modeling_cyclical.py
						# into this folder
						# IMPORTANT: Note that for now we've only converted the down-stream
						# model and not the full pretrained model. This means for the integration
						# test you need to add a `return x` after the following line:
						# https://github.com/facebookresearch/data2vec_vision/blob/af9a36349aaed59ae66e69b5dabeef2d62fdc5da/beit/modeling_cyclical.py#L197
						# to make the integration test pass.
						import modeling_cyclical  # noqa: F401

			# 1. Create model config
			__UpperCamelCase				:      List[Any]									=       DataaVecVisionConfig()
			if is_finetuned:
						__UpperCamelCase				:      int									=       True
						__UpperCamelCase				:      Any									=       False
						__UpperCamelCase				:      Dict									=       True
						__UpperCamelCase				:      Optional[int]									=       1_000

						__UpperCamelCase				:      Optional[Any]									=       "huggingface/label-files"
						__UpperCamelCase				:      Union[str, Any]									=       "imagenet-1k-id2label.json"
						__UpperCamelCase				:      Union[str, Any]									=       json.load(open(hf_hub_download(snake_case__ ,				snake_case__ ,				repo_type="dataset"						) ,				"r"						)						)
						__UpperCamelCase				:      List[str]									=       {int(snake_case__						): v for k, v in idalabel.items()}
						__UpperCamelCase				:      Tuple									=       idalabel
						__UpperCamelCase				:      Dict									=       {v: k for k, v in idalabel.items()}
			else:
						__UpperCamelCase				:      int									=       False
						__UpperCamelCase				:      int									=       True
						__UpperCamelCase				:      str									=       False

			if is_large:
						__UpperCamelCase				:      Tuple									=       1_024
						__UpperCamelCase				:      str									=       4_096
						__UpperCamelCase				:      Optional[int]									=       24
						__UpperCamelCase				:      Any									=       16

			# 2. Load Beit model
			__UpperCamelCase				:      Dict									=       load_beit_model(snake_case__ ,				snake_case__ ,				snake_case__						)
			orig_model.eval()

			# 3. Forward Beit model
			__UpperCamelCase				:      Dict									=       BeitImageProcessor(size=config.image_size ,				do_center_crop=snake_case__						)
			__UpperCamelCase				:      Tuple									=       Image.open("../../../../tests/fixtures/tests_samples/COCO/000000039769.png"						)
			__UpperCamelCase				:      List[str]									=       image_processor(images=snake_case__ ,				return_tensors="pt"						)
			__UpperCamelCase				:      List[str]									=       encoding["pixel_values"]

			__UpperCamelCase				:      str									=       (pixel_values,) if is_finetuned else (pixel_values, None)
			with torch.no_grad():
						__UpperCamelCase				:      int									=       orig_model(*snake_case__						)

			# 4. Load HF Data2VecVision model
			if is_finetuned:
						__UpperCamelCase				:      Tuple									=       DataaVecVisionForImageClassification(snake_case__						)
						hf_model.eval()
						__UpperCamelCase				:      List[Any]									=       False
						__UpperCamelCase				:      List[str]									=       "data2vec_vision."
			else:
						__UpperCamelCase				:      List[Any]									=       DataaVecVisionModel(snake_case__						)
						hf_model.eval()
						__UpperCamelCase				:      List[Any]									=       True
						__UpperCamelCase				:      int									=       ""

			__UpperCamelCase				:      int									=       create_rename_keys(snake_case__ ,				hf_prefix=snake_case__ ,				has_lm_head=snake_case__						)
			__UpperCamelCase				:      Any									=       orig_model.state_dict()
			for src, dest in rename_keys:
						__UpperCamelCase				:      List[Any]									=       state_dict.pop(snake_case__						)
						__UpperCamelCase				:      List[str]									=       val

			read_in_q_k_v(snake_case__ ,				snake_case__ ,				hf_prefix=snake_case__ ,				has_lm_head=snake_case__						)
			__UpperCamelCase		, __UpperCamelCase				:      str									=       hf_model.load_state_dict(snake_case__ ,				strict=snake_case__						)
			print("HF missing" ,				snake_case__						)
			print("HF unexpected_keys" ,				snake_case__						)

			# 5. Forward HF Data2VecVision model
			with torch.no_grad():
						__UpperCamelCase				:      List[Any]									=       hf_model(snake_case__						)

			__UpperCamelCase				:      Any									=       hf_model_output.logits if is_finetuned else hf_model_output.last_hidden_state

			# 6. Compare
			__UpperCamelCase				:      List[Any]									=       torch.max(torch.abs(hf_output - orig_model_output						)						).item()

			print(F"max_absolute_diff = {max_absolute_diff}"						)
			__UpperCamelCase				:      List[Any]									=       torch.allclose(snake_case__ ,				snake_case__ ,				atol=1E-3						)
			print("Do both models output the same tensors?" ,				"🔥" if success else "💩"						)
			if not success:
						raise Exception("Something went wRoNg"						)

			# 7. Save
			print(F"Saving to {args.hf_checkpoint_name}"						)
			hf_model.save_pretrained(args.hf_checkpoint_name						)
			image_processor.save_pretrained(args.hf_checkpoint_name						)


if __name__ == "__main__":
				main()
				# Run the following to convert checkpoints
				#  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
				#          --beit_checkpoint ./pretrained_base.pt \
				#          --hf_checkpoint_name "./data2vec-vision-base"
				#  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
				#          --beit_checkpoint ./finetuned_base.pt \
				#          --hf_checkpoint_name "./data2vec-vision-base-ft1k"
				#  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
				#          --beit_checkpoint ./pretrained_large.pt \
				#          --hf_checkpoint_name "./data2vec-vision-large"
				#  python ./convert_data2vec_vision_original_pytorch_checkpoint_to_pytorch.py \
				#          --beit_checkpoint ./finetuned_large.pt \
				#          --hf_checkpoint_name "./data2vec-vision-large-ft1k"









'''simple docstring'''






from typing import Any, Callable, Dict, List, Optional, Union

import PIL.Image
import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionImgaImgPipeline,
    StableDiffusionInpaintPipelineLegacy,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.configuration_utils import FrozenDict
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.utils import deprecate, logging


_lowerCAmelCase				     = logging.get_logger(__name__)  # pylint: disable=invalid-name



class  A		(			SCREAMING_SNAKE_CASE__		):




				'''simple docstring'''





				A				     =    ["safety_checker", "feature_extractor"]
				def __init__(self			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase = True			,  )     ->	List[str]:
							super().__init__()
							if hasattr(scheduler.config			,  "steps_offset"      ) and scheduler.config.steps_offset != 1:
										__UpperCamelCase				:      List[str]									=       (
										    f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
										    f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
										    "to update the config accordingly as leaving `steps_offset` might led to incorrect results"
										    " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
										    " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
										    " file"
										)
										deprecate("steps_offset!=1"			,  "1.0.0"			,  _UpperCAmelCase			,  standard_warn=_UpperCAmelCase      )
										__UpperCamelCase				:      str									=       dict(scheduler.config      )
										__UpperCamelCase				:      Optional[Any]									=       1
										__UpperCamelCase				:      Dict									=       FrozenDict(_UpperCAmelCase      )

							self.register_modules(
							    vae=_UpperCAmelCase			,  text_encoder=_UpperCAmelCase			,  tokenizer=_UpperCAmelCase			,  unet=_UpperCAmelCase			,  scheduler=_UpperCAmelCase			,  safety_checker=_UpperCAmelCase			,  feature_extractor=_UpperCAmelCase			,  )
							self.register_to_config(requires_safety_checker=_UpperCAmelCase      )
				@property
				def 	a_	(self      )     ->	Dict[str, Any]:
							return {k: getattr(self			,  _UpperCAmelCase      ) for k in self.config.keys() if not k.startswith("_"      )}
				def 	a_	(self			,  _UpperCAmelCase = "auto"      )     ->	List[str]:
							if slice_size == "auto":
										# half the attention head size is usually a good trade-off between
										# speed and memory
										__UpperCamelCase				:      Dict									=       self.unet.config.attention_head_dim // 2
							self.unet.set_attention_slice(_UpperCAmelCase      )
				def 	a_	(self      )     ->	Dict:
							self.enable_attention_slicing(_UpperCAmelCase      )
				@torch.no_grad()
				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase = 0.8			,  _UpperCAmelCase = 5_0			,  _UpperCAmelCase = 7.5			,  _UpperCAmelCase = None			,  _UpperCAmelCase = 1			,  _UpperCAmelCase = 0.0			,  _UpperCAmelCase = None			,  _UpperCAmelCase = "pil"			,  _UpperCAmelCase = True			,  _UpperCAmelCase = None			,  _UpperCAmelCase = 1			,  )     ->	List[str]:
							# For more information on how this function works, please see: https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion#diffusers.StableDiffusionImg2ImgPipeline
							return StableDiffusionInpaintPipelineLegacy(**self.components      )(
							    prompt=_UpperCAmelCase			,  image=_UpperCAmelCase			,  mask_image=_UpperCAmelCase			,  strength=_UpperCAmelCase			,  num_inference_steps=_UpperCAmelCase			,  guidance_scale=_UpperCAmelCase			,  negative_prompt=_UpperCAmelCase			,  num_images_per_prompt=_UpperCAmelCase			,  eta=_UpperCAmelCase			,  generator=_UpperCAmelCase			,  output_type=_UpperCAmelCase			,  return_dict=_UpperCAmelCase			,  callback=_UpperCAmelCase			,  )
				@torch.no_grad()
				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase			,  _UpperCAmelCase = 0.8			,  _UpperCAmelCase = 5_0			,  _UpperCAmelCase = 7.5			,  _UpperCAmelCase = None			,  _UpperCAmelCase = 1			,  _UpperCAmelCase = 0.0			,  _UpperCAmelCase = None			,  _UpperCAmelCase = "pil"			,  _UpperCAmelCase = True			,  _UpperCAmelCase = None			,  _UpperCAmelCase = 1			,  **_UpperCAmelCase			,  )     ->	Optional[Any]:
							# For more information on how this function works, please see: https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion#diffusers.StableDiffusionImg2ImgPipeline
							return StableDiffusionImgaImgPipeline(**self.components      )(
							    prompt=_UpperCAmelCase			,  image=_UpperCAmelCase			,  strength=_UpperCAmelCase			,  num_inference_steps=_UpperCAmelCase			,  guidance_scale=_UpperCAmelCase			,  negative_prompt=_UpperCAmelCase			,  num_images_per_prompt=_UpperCAmelCase			,  eta=_UpperCAmelCase			,  generator=_UpperCAmelCase			,  output_type=_UpperCAmelCase			,  return_dict=_UpperCAmelCase			,  callback=_UpperCAmelCase			,  callback_steps=_UpperCAmelCase			,  )





				@torch.no_grad()
				def 	a_	(self			,  _UpperCAmelCase			,  _UpperCAmelCase = 5_1_2			,  _UpperCAmelCase = 5_1_2			,  _UpperCAmelCase = 5_0			,  _UpperCAmelCase = 7.5			,  _UpperCAmelCase = None			,  _UpperCAmelCase = 1			,  _UpperCAmelCase = 0.0			,  _UpperCAmelCase = None			,  _UpperCAmelCase = None			,  _UpperCAmelCase = "pil"			,  _UpperCAmelCase = True			,  _UpperCAmelCase = None			,  _UpperCAmelCase = 1			,  )     ->	Union[str, Any]:
							# For more information on how this function https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion#diffusers.StableDiffusionPipeline
							return StableDiffusionPipeline(**self.components      )(
							    prompt=_UpperCAmelCase			,  height=_UpperCAmelCase			,  width=_UpperCAmelCase			,  num_inference_steps=_UpperCAmelCase			,  guidance_scale=_UpperCAmelCase			,  negative_prompt=_UpperCAmelCase			,  num_images_per_prompt=_UpperCAmelCase			,  eta=_UpperCAmelCase			,  generator=_UpperCAmelCase			,  latents=_UpperCAmelCase			,  output_type=_UpperCAmelCase			,  return_dict=_UpperCAmelCase			,  callback=_UpperCAmelCase			,  callback_steps=_UpperCAmelCase			,  )



