
"""simple docstring"""





import argparse
import json
from pathlib import Path

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import (
    BitConfig,
    ViTHybridConfig,
    ViTHybridForImageClassification,
    ViTHybridImageProcessor,
    ViTHybridModel,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
__magic_name__       =			logging.get_logger(__name__)



def 						_lowerCAmelCase				(				UpperCamelCase_  ,				UpperCamelCase_=False				):
		__SCREAMING_SNAKE_CASE            = []

		# fmt: off
		# stem:
		rename_keys.append(("""cls_token""", """vit.embeddings.cls_token""")				)
		rename_keys.append(("""pos_embed""", """vit.embeddings.position_embeddings""")				)

		rename_keys.append(("""patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight""")				)
		rename_keys.append(("""patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias""")				)

		# backbone
		rename_keys.append(("""patch_embed.backbone.stem.conv.weight""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.convolution.weight""")				)
		rename_keys.append(("""patch_embed.backbone.stem.norm.weight""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.weight""")				)
		rename_keys.append(("""patch_embed.backbone.stem.norm.bias""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.bias""")				)

		for stage_idx in range(len(config.backbone_config.depths				)				):
				for layer_idx in range(config.backbone_config.depths[stage_idx]				):
						rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv1.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv1.weight")				)
						rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.weight")				)
						rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.bias")				)
						rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv2.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv2.weight")				)
						rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.weight")				)
						rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.bias")				)
						rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv3.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv3.weight")				)
						rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.weight")				)
						rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.bias")				)

				rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.conv.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.conv.weight")				)
				rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.weight", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.weight")				)
				rename_keys.append((f"patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.bias", f"vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.bias")				)

		# transformer encoder
		for i in range(config.num_hidden_layers				):
				# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
				rename_keys.append((f"blocks.{i}.norm1.weight", f"vit.encoder.layer.{i}.layernorm_before.weight")				)
				rename_keys.append((f"blocks.{i}.norm1.bias", f"vit.encoder.layer.{i}.layernorm_before.bias")				)
				rename_keys.append((f"blocks.{i}.attn.proj.weight", f"vit.encoder.layer.{i}.attention.output.dense.weight")				)
				rename_keys.append((f"blocks.{i}.attn.proj.bias", f"vit.encoder.layer.{i}.attention.output.dense.bias")				)
				rename_keys.append((f"blocks.{i}.norm2.weight", f"vit.encoder.layer.{i}.layernorm_after.weight")				)
				rename_keys.append((f"blocks.{i}.norm2.bias", f"vit.encoder.layer.{i}.layernorm_after.bias")				)
				rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"vit.encoder.layer.{i}.intermediate.dense.weight")				)
				rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"vit.encoder.layer.{i}.intermediate.dense.bias")				)
				rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"vit.encoder.layer.{i}.output.dense.weight")				)
				rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"vit.encoder.layer.{i}.output.dense.bias")				)

		if base_model:
				# layernorm + pooler
				rename_keys.extend(
				    [
				        ("""norm.weight""", """layernorm.weight"""),
				        ("""norm.bias""", """layernorm.bias"""),
				        ("""pre_logits.fc.weight""", """pooler.dense.weight"""),
				        ("""pre_logits.fc.bias""", """pooler.dense.bias"""),
				    ]				)

				# if just the base model, we should remove "vit" from all keys that start with "vit"
				__SCREAMING_SNAKE_CASE            = [(pair[0], pair[1][4:]) if pair[1].startswith("""vit"""				) else pair for pair in rename_keys]
		else:
				# layernorm + classification head
				rename_keys.extend(
				    [
				        ("""norm.weight""", """vit.layernorm.weight"""),
				        ("""norm.bias""", """vit.layernorm.bias"""),
				        ("""head.weight""", """classifier.weight"""),
				        ("""head.bias""", """classifier.bias"""),
				    ]				)
		# fmt: on

		return rename_keys



def 						_lowerCAmelCase				(				UpperCamelCase_  ,				UpperCamelCase_  ,				UpperCamelCase_=False				):
		for i in range(config.num_hidden_layers				):
				if base_model:
						__SCREAMING_SNAKE_CASE            = """"""
				else:
						__SCREAMING_SNAKE_CASE            = """vit."""
				# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
				__SCREAMING_SNAKE_CASE            = state_dict.pop(f"blocks.{i}.attn.qkv.weight"				)
				__SCREAMING_SNAKE_CASE            = state_dict.pop(f"blocks.{i}.attn.qkv.bias"				)
				# next, add query, keys and values (in that order) to the state dict
				__SCREAMING_SNAKE_CASE            = in_proj_weight[
				    : config.hidden_size, :
				]
				__SCREAMING_SNAKE_CASE            = in_proj_bias[: config.hidden_size]
				__SCREAMING_SNAKE_CASE            = in_proj_weight[
				    config.hidden_size : config.hidden_size * 2, :
				]
				__SCREAMING_SNAKE_CASE            = in_proj_bias[
				    config.hidden_size : config.hidden_size * 2
				]
				__SCREAMING_SNAKE_CASE            = in_proj_weight[
				    -config.hidden_size :, :
				]
				__SCREAMING_SNAKE_CASE            = in_proj_bias[-config.hidden_size :]



def 						_lowerCAmelCase				(				UpperCamelCase_				):
		__SCREAMING_SNAKE_CASE            = ["""head.weight""", """head.bias"""]
		for k in ignore_keys:
				state_dict.pop(UpperCamelCase_  ,				UpperCamelCase_				)



def 						_lowerCAmelCase				(				UpperCamelCase_  ,				UpperCamelCase_  ,				UpperCamelCase_				):
		__SCREAMING_SNAKE_CASE            = dct.pop(UpperCamelCase_				)
		__SCREAMING_SNAKE_CASE            = val



def 						_lowerCAmelCase				(				):
		__SCREAMING_SNAKE_CASE            = """http://images.cocodataset.org/val2017/000000039769.jpg"""
		__SCREAMING_SNAKE_CASE            = Image.open(requests.get(UpperCamelCase_  ,				stream=UpperCamelCase_				).raw				)
		return im



@torch.no_grad()
def 						_lowerCAmelCase				(				UpperCamelCase_  ,				UpperCamelCase_  ,				UpperCamelCase_=False				):
		__SCREAMING_SNAKE_CASE            = BitConfig(
		    global_padding="""same"""  ,				layer_type="""bottleneck"""  ,				depths=(3, 4, 9)  ,				out_features=["""stage3"""]  ,				embedding_dynamic_padding=UpperCamelCase_  ,				)
		__SCREAMING_SNAKE_CASE            = ViTHybridConfig(backbone_config=UpperCamelCase_  ,				image_size=384  ,				num_labels=1000				)
		__SCREAMING_SNAKE_CASE            = False

		# load original model from timm
		__SCREAMING_SNAKE_CASE            = timm.create_model(UpperCamelCase_  ,				pretrained=UpperCamelCase_				)
		timm_model.eval()

		# load state_dict of original model, remove and rename some keys
		__SCREAMING_SNAKE_CASE            = timm_model.state_dict()
		if base_model:
				remove_classification_head_(UpperCamelCase_				)
		__SCREAMING_SNAKE_CASE            = create_rename_keys(UpperCamelCase_  ,				UpperCamelCase_				)
		for src, dest in rename_keys:
				rename_key(UpperCamelCase_  ,				UpperCamelCase_  ,				UpperCamelCase_				)
		read_in_q_k_v(UpperCamelCase_  ,				UpperCamelCase_  ,				UpperCamelCase_				)

		__SCREAMING_SNAKE_CASE            = """huggingface/label-files"""
		__SCREAMING_SNAKE_CASE            = """imagenet-1k-id2label.json"""
		__SCREAMING_SNAKE_CASE            = json.load(open(hf_hub_download(UpperCamelCase_  ,				UpperCamelCase_  ,				repo_type="""dataset"""				)  ,				"""r"""				)				)
		__SCREAMING_SNAKE_CASE            = {int(UpperCamelCase_				): v for k, v in idalabel.items()}
		__SCREAMING_SNAKE_CASE            = idalabel
		__SCREAMING_SNAKE_CASE            = {v: k for k, v in idalabel.items()}

		# load HuggingFace model
		if vit_name[-5:] == "in21k":
				__SCREAMING_SNAKE_CASE            = ViTHybridModel(UpperCamelCase_				).eval()
		else:
				__SCREAMING_SNAKE_CASE            = ViTHybridForImageClassification(UpperCamelCase_				).eval()
		model.load_state_dict(UpperCamelCase_				)

		# create image processor
		__SCREAMING_SNAKE_CASE            = create_transform(**resolve_data_config({}  ,				model=UpperCamelCase_				)				)
		__SCREAMING_SNAKE_CASE            = transform.transforms

		__SCREAMING_SNAKE_CASE            = {
		    """bilinear""": PILImageResampling.BILINEAR,
		    """bicubic""": PILImageResampling.BICUBIC,
		    """nearest""": PILImageResampling.NEAREST,
		}

		__SCREAMING_SNAKE_CASE            = ViTHybridImageProcessor(
		    do_resize=UpperCamelCase_  ,				size={"""shortest_edge""": timm_transforms[0].size}  ,				resample=pillow_resamplings[timm_transforms[0].interpolation.value]  ,				do_center_crop=UpperCamelCase_  ,				crop_size={"""height""": timm_transforms[1].size[0], """width""": timm_transforms[1].size[1]}  ,				do_normalize=UpperCamelCase_  ,				image_mean=timm_transforms[-1].mean.tolist()  ,				image_std=timm_transforms[-1].std.tolist()  ,				)

		__SCREAMING_SNAKE_CASE            = prepare_img()
		__SCREAMING_SNAKE_CASE            = transform(UpperCamelCase_				).unsqueeze(0				)
		__SCREAMING_SNAKE_CASE            = processor(UpperCamelCase_  ,				return_tensors="""pt"""				).pixel_values

		# verify pixel values
		assert torch.allclose(UpperCamelCase_  ,				UpperCamelCase_				)

		# verify logits
		with torch.no_grad():
				__SCREAMING_SNAKE_CASE            = model(UpperCamelCase_				)
				__SCREAMING_SNAKE_CASE            = outputs.logits

		print("""Predicted class:"""  ,				logits.argmax(-1				).item()				)
		if base_model:
				__SCREAMING_SNAKE_CASE            = timm_model.forward_features(UpperCamelCase_				)
				assert timm_pooled_output.shape == outputs.pooler_output.shape
				assert torch.allclose(UpperCamelCase_  ,				outputs.pooler_output  ,				atol=1e-3				)
		else:
				__SCREAMING_SNAKE_CASE            = timm_model(UpperCamelCase_				)
				assert timm_logits.shape == outputs.logits.shape
				assert torch.allclose(UpperCamelCase_  ,				outputs.logits  ,				atol=1e-3				)
		print("""Looks ok!"""				)

		if pytorch_dump_folder_path is not None:
				Path(UpperCamelCase_				).mkdir(exist_ok=UpperCamelCase_				)
				print(f"Saving model {vit_name} to {pytorch_dump_folder_path}"				)
				model.save_pretrained(UpperCamelCase_				)
				print(f"Saving processor to {pytorch_dump_folder_path}"				)
				processor.save_pretrained(UpperCamelCase_				)

		if push_to_hub:
				print(f"Pushing model and processor to the hub {vit_name}"				)
				model.push_to_hub(f"ybelkada/{vit_name}"				)
				processor.push_to_hub(f"ybelkada/{vit_name}"				)


if __name__ == "__main__":
							__magic_name__       =			argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    "--vit_name",
							    default="vit_base_r50_s16_384",
							    type=str,
							    help="Name of the hybrid ViT timm model you'd like to convert.",
							)
							parser.add_argument(
							    "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
							)
							parser.add_argument(
							    "--push_to_hub", action="store_true", help="Whether to upload the model to the HuggingFace hub."
							)

							__magic_name__       =			parser.parse_args()
							convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path, args.push_to_hub)






"""simple docstring"""





__magic_name__       =			"0.18.2"

from .configuration_utils import ConfigMixin
from .utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    logging,
)


try:
							if not is_onnx_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_onnx_objects import *  # noqa F403
else:
							from .pipelines import OnnxRuntimeModel

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_pt_objects import *  # noqa F403
else:
							from .models import (
							    AutoencoderKL,
							    ControlNetModel,
							    ModelMixin,
							    PriorTransformer,
							    TaFilmDecoder,
							    TransformeraDModel,
							    UNetaDModel,
							    UNetaDConditionModel,
							    UNetaDModel,
							    UNetaDConditionModel,
							    VQModel,
							)
							from .optimization import (
							    get_constant_schedule,
							    get_constant_schedule_with_warmup,
							    get_cosine_schedule_with_warmup,
							    get_cosine_with_hard_restarts_schedule_with_warmup,
							    get_linear_schedule_with_warmup,
							    get_polynomial_decay_schedule_with_warmup,
							    get_scheduler,
							)
							from .pipelines import (
							    AudioPipelineOutput,
							    ConsistencyModelPipeline,
							    DanceDiffusionPipeline,
							    DDIMPipeline,
							    DDPMPipeline,
							    DiffusionPipeline,
							    DiTPipeline,
							    ImagePipelineOutput,
							    KarrasVePipeline,
							    LDMPipeline,
							    LDMSuperResolutionPipeline,
							    PNDMPipeline,
							    RePaintPipeline,
							    ScoreSdeVePipeline,
							)
							from .schedulers import (
							    CMStochasticIterativeScheduler,
							    DDIMInverseScheduler,
							    DDIMParallelScheduler,
							    DDIMScheduler,
							    DDPMParallelScheduler,
							    DDPMScheduler,
							    DEISMultistepScheduler,
							    DPMSolverMultistepInverseScheduler,
							    DPMSolverMultistepScheduler,
							    DPMSolverSinglestepScheduler,
							    EulerAncestralDiscreteScheduler,
							    EulerDiscreteScheduler,
							    HeunDiscreteScheduler,
							    IPNDMScheduler,
							    KarrasVeScheduler,
							    KDPMaAncestralDiscreteScheduler,
							    KDPMaDiscreteScheduler,
							    PNDMScheduler,
							    RePaintScheduler,
							    SchedulerMixin,
							    ScoreSdeVeScheduler,
							    UnCLIPScheduler,
							    UniPCMultistepScheduler,
							    VQDiffusionScheduler,
							)
							from .training_utils import EMAModel

try:
							if not (is_torch_available() and is_scipy_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
							from .schedulers import LMSDiscreteScheduler

try:
							if not (is_torch_available() and is_torchsde_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
							from .schedulers import DPMSolverSDEScheduler

try:
							if not (is_torch_available() and is_transformers_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
							from .pipelines import (
							    AltDiffusionImgaImgPipeline,
							    AltDiffusionPipeline,
							    AudioLDMPipeline,
							    CycleDiffusionPipeline,
							    IFImgaImgPipeline,
							    IFImgaImgSuperResolutionPipeline,
							    IFInpaintingPipeline,
							    IFInpaintingSuperResolutionPipeline,
							    IFPipeline,
							    IFSuperResolutionPipeline,
							    ImageTextPipelineOutput,
							    KandinskyImgaImgPipeline,
							    KandinskyInpaintPipeline,
							    KandinskyPipeline,
							    KandinskyPriorPipeline,
							    KandinskyVaaControlnetImgaImgPipeline,
							    KandinskyVaaControlnetPipeline,
							    KandinskyVaaImgaImgPipeline,
							    KandinskyVaaInpaintPipeline,
							    KandinskyVaaPipeline,
							    KandinskyVaaPriorEmbaEmbPipeline,
							    KandinskyVaaPriorPipeline,
							    LDMTextToImagePipeline,
							    PaintByExamplePipeline,
							    SemanticStableDiffusionPipeline,
							    ShapEImgaImgPipeline,
							    ShapEPipeline,
							    StableDiffusionAttendAndExcitePipeline,
							    StableDiffusionControlNetImgaImgPipeline,
							    StableDiffusionControlNetInpaintPipeline,
							    StableDiffusionControlNetPipeline,
							    StableDiffusionDepthaImgPipeline,
							    StableDiffusionDiffEditPipeline,
							    StableDiffusionImageVariationPipeline,
							    StableDiffusionImgaImgPipeline,
							    StableDiffusionInpaintPipeline,
							    StableDiffusionInpaintPipelineLegacy,
							    StableDiffusionInstructPixaPixPipeline,
							    StableDiffusionLatentUpscalePipeline,
							    StableDiffusionLDMaDPipeline,
							    StableDiffusionModelEditingPipeline,
							    StableDiffusionPanoramaPipeline,
							    StableDiffusionParadigmsPipeline,
							    StableDiffusionPipeline,
							    StableDiffusionPipelineSafe,
							    StableDiffusionPixaPixZeroPipeline,
							    StableDiffusionSAGPipeline,
							    StableDiffusionUpscalePipeline,
							    StableUnCLIPImgaImgPipeline,
							    StableUnCLIPPipeline,
							    TextToVideoSDPipeline,
							    TextToVideoZeroPipeline,
							    UnCLIPImageVariationPipeline,
							    UnCLIPPipeline,
							    UniDiffuserModel,
							    UniDiffuserPipeline,
							    UniDiffuserTextDecoder,
							    VersatileDiffusionDualGuidedPipeline,
							    VersatileDiffusionImageVariationPipeline,
							    VersatileDiffusionPipeline,
							    VersatileDiffusionTextToImagePipeline,
							    VideoToVideoSDPipeline,
							    VQDiffusionPipeline,
							)

try:
							if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
							from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
							if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
							from .pipelines import StableDiffusionKDiffusionPipeline

try:
							if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
							from .pipelines import (
							    OnnxStableDiffusionImgaImgPipeline,
							    OnnxStableDiffusionInpaintPipeline,
							    OnnxStableDiffusionInpaintPipelineLegacy,
							    OnnxStableDiffusionPipeline,
							    OnnxStableDiffusionUpscalePipeline,
							    StableDiffusionOnnxPipeline,
							)

try:
							if not (is_torch_available() and is_librosa_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
							from .pipelines import AudioDiffusionPipeline, Mel

try:
							if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
							from .pipelines import SpectrogramDiffusionPipeline

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_flax_objects import *  # noqa F403
else:
							from .models.controlnet_flax import FlaxControlNetModel
							from .models.modeling_flax_utils import FlaxModelMixin
							from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel
							from .models.vae_flax import FlaxAutoencoderKL
							from .pipelines import FlaxDiffusionPipeline
							from .schedulers import (
							    FlaxDDIMScheduler,
							    FlaxDDPMScheduler,
							    FlaxDPMSolverMultistepScheduler,
							    FlaxKarrasVeScheduler,
							    FlaxLMSDiscreteScheduler,
							    FlaxPNDMScheduler,
							    FlaxSchedulerMixin,
							    FlaxScoreSdeVeScheduler,
							)


try:
							if not (is_flax_available() and is_transformers_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
							from .pipelines import (
							    FlaxStableDiffusionControlNetPipeline,
							    FlaxStableDiffusionImgaImgPipeline,
							    FlaxStableDiffusionInpaintPipeline,
							    FlaxStableDiffusionPipeline,
							)

try:
							if not (is_note_seq_available()):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from .utils.dummy_note_seq_objects import *  # noqa F403
else:
							from .pipelines import MidiProcessor




