


import argparse
import collections
import os
import re
import tempfile

import pandas as pd
from datasets import Dataset
from huggingface_hub import hf_hub_download, upload_folder

from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/update_metadata.py
__magic_name__  	=     '''src/transformers'''


# This is to make sure the transformers module imported is the one in the repo.
__magic_name__  	=     direct_transformers_import(TRANSFORMERS_PATH)


# Regexes that match TF/Flax/PT model names.
__magic_name__  	=     re.compile(R'''TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)''')
__magic_name__  	=     re.compile(R'''Flax(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)''')
# Will match any TF or Flax model too so need to be in an else branch afterthe two previous regexes.
__magic_name__  	=     re.compile(R'''(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)''')


# Fill this with tuples (pipeline_tag, model_mapping, auto_model)
__magic_name__  	=     [
    ('''pretraining''', '''MODEL_FOR_PRETRAINING_MAPPING_NAMES''', '''AutoModelForPreTraining'''),
    ('''feature-extraction''', '''MODEL_MAPPING_NAMES''', '''AutoModel'''),
    ('''audio-classification''', '''MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES''', '''AutoModelForAudioClassification'''),
    ('''text-generation''', '''MODEL_FOR_CAUSAL_LM_MAPPING_NAMES''', '''AutoModelForCausalLM'''),
    ('''automatic-speech-recognition''', '''MODEL_FOR_CTC_MAPPING_NAMES''', '''AutoModelForCTC'''),
    ('''image-classification''', '''MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES''', '''AutoModelForImageClassification'''),
    ('''image-segmentation''', '''MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMES''', '''AutoModelForImageSegmentation'''),
    ('''fill-mask''', '''MODEL_FOR_MASKED_LM_MAPPING_NAMES''', '''AutoModelForMaskedLM'''),
    ('''object-detection''', '''MODEL_FOR_OBJECT_DETECTION_MAPPING_NAMES''', '''AutoModelForObjectDetection'''),
    (
        '''zero-shot-object-detection''',
        '''MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING_NAMES''',
        '''AutoModelForZeroShotObjectDetection''',
    ),
    ('''question-answering''', '''MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES''', '''AutoModelForQuestionAnswering'''),
    ('''text2text-generation''', '''MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES''', '''AutoModelForSeq2SeqLM'''),
    ('''text-classification''', '''MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES''', '''AutoModelForSequenceClassification'''),
    ('''automatic-speech-recognition''', '''MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES''', '''AutoModelForSpeechSeq2Seq'''),
    (
        '''table-question-answering''',
        '''MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING_NAMES''',
        '''AutoModelForTableQuestionAnswering''',
    ),
    ('''token-classification''', '''MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES''', '''AutoModelForTokenClassification'''),
    ('''multiple-choice''', '''MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES''', '''AutoModelForMultipleChoice'''),
    (
        '''next-sentence-prediction''',
        '''MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES''',
        '''AutoModelForNextSentencePrediction''',
    ),
    (
        '''audio-frame-classification''',
        '''MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING_NAMES''',
        '''AutoModelForAudioFrameClassification''',
    ),
    ('''audio-xvector''', '''MODEL_FOR_AUDIO_XVECTOR_MAPPING_NAMES''', '''AutoModelForAudioXVector'''),
    (
        '''document-question-answering''',
        '''MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES''',
        '''AutoModelForDocumentQuestionAnswering''',
    ),
    (
        '''visual-question-answering''',
        '''MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING_NAMES''',
        '''AutoModelForVisualQuestionAnswering''',
    ),
    ('''image-to-text''', '''MODEL_FOR_FOR_VISION_2_SEQ_MAPPING_NAMES''', '''AutoModelForVision2Seq'''),
    (
        '''zero-shot-image-classification''',
        '''MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING_NAMES''',
        '''AutoModelForZeroShotImageClassification''',
    ),
    ('''depth-estimation''', '''MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES''', '''AutoModelForDepthEstimation'''),
    ('''video-classification''', '''MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMES''', '''AutoModelForVideoClassification'''),
    ('''mask-generation''', '''MODEL_FOR_MASK_GENERATION_MAPPING_NAMES''', '''AutoModelForMaskGeneration'''),
]







def 							__magic_name__    (     lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				int              =  re.finditer(".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)"     ,	a_)
	return [m.group(0) for m in matches]







def 							__magic_name__    (     ):
	'''simple docstring'''


	lowerCamelCase_					:				Optional[int]              =  transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
	lowerCamelCase_					:				Union[str, Any]              =  {
	    config.replace("Config"     ,	""): model_type for model_type, config in config_maping_names.items()
	}

	# Dictionaries flagging if each model prefix has a backend in PT/TF/Flax.
	lowerCamelCase_					:				Optional[int]              =  collections.defaultdict(a_)
	lowerCamelCase_					:				List[str]              =  collections.defaultdict(a_)
	lowerCamelCase_					:				List[Any]              =  collections.defaultdict(a_)

	# Let's lookup through all transformers object (once) and find if models are supported by a given backend.
	for attr_name in dir(a_):
		lowerCamelCase_					:				Dict              =  None
		if _re_tf_models.match(a_) is not None:
			lowerCamelCase_					:				List[str]              =  tf_models
			lowerCamelCase_					:				Any              =  _re_tf_models.match(a_).groups()[0]
		elif _re_flax_models.match(a_) is not None:
			lowerCamelCase_					:				Tuple              =  flax_models
			lowerCamelCase_					:				int              =  _re_flax_models.match(a_).groups()[0]
		elif _re_pt_models.match(a_) is not None:
			lowerCamelCase_					:				Tuple              =  pt_models
			lowerCamelCase_					:				str              =  _re_pt_models.match(a_).groups()[0]

		if lookup_dict is not None:
			while len(a_) > 0:
				if attr_name in model_prefix_to_model_type:
					lowerCamelCase_					:				str              =  True
					break
				# Try again after removing the last word in the name
				lowerCamelCase_					:				Union[str, Any]              =  "".join(camel_case_split(a_)[:-1])

	lowerCamelCase_					:				List[Any]              =  set(list(pt_models.keys()) + list(tf_models.keys()) + list(flax_models.keys()))
	lowerCamelCase_					:				int              =  list(a_)
	all_models.sort()

	lowerCamelCase_					:				int              =  {"model_type": all_models}
	lowerCamelCase_					:				str              =  [pt_models[t] for t in all_models]
	lowerCamelCase_					:				str              =  [tf_models[t] for t in all_models]
	lowerCamelCase_					:				str              =  [flax_models[t] for t in all_models]

	# Now let's use the auto-mapping names to make sure
	lowerCamelCase_					:				str              =  {}
	for t in all_models:
		if t in transformers_module.models.auto.processing_auto.PROCESSOR_MAPPING_NAMES:
			lowerCamelCase_					:				Optional[Any]              =  "AutoProcessor"
		elif t in transformers_module.models.auto.tokenization_auto.TOKENIZER_MAPPING_NAMES:
			lowerCamelCase_					:				List[str]              =  "AutoTokenizer"
		elif t in transformers_module.models.auto.feature_extraction_auto.FEATURE_EXTRACTOR_MAPPING_NAMES:
			lowerCamelCase_					:				Union[str, Any]              =  "AutoFeatureExtractor"
		else:
			# Default to AutoTokenizer if a model has nothing, for backward compatibility.
			lowerCamelCase_					:				int              =  "AutoTokenizer"

	lowerCamelCase_					:				str              =  [processors[t] for t in all_models]

	return pd.DataFrame(a_)







def 							__magic_name__    (     lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Any              =  [
	    transformers_module.models.auto.modeling_auto,
	    transformers_module.models.auto.modeling_tf_auto,
	    transformers_module.models.auto.modeling_flax_auto,
	]
	for pipeline_tag, model_mapping, auto_class in PIPELINE_TAGS_AND_AUTO_MODELS:
		lowerCamelCase_					:				Any              =  [model_mapping, F"""TF_{model_mapping}""", F"""FLAX_{model_mapping}"""]
		lowerCamelCase_					:				Union[str, Any]              =  [auto_class, F"""TF_{auto_class}""", F"""Flax_{auto_class}"""]
		# Loop through all three frameworks
		for module, cls, mapping in zip(a_     ,	a_     ,	a_):
			# The type of pipeline may not exist in this framework
			if not hasattr(a_     ,	a_):
				continue
			# First extract all model_names
			lowerCamelCase_					:				Union[str, Any]              =  []
			for name in getattr(a_     ,	a_).values():
				if isinstance(a_     ,	a_):
					model_names.append(a_)
				else:
					model_names.extend(list(a_))

					  # Add pipeline tag and auto model class for those models
			table.update({model_name: (pipeline_tag, cls) for model_name in model_names})

	return table







def 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Dict              =  get_frameworks_table()
	lowerCamelCase_					:				List[Any]              =  Dataset.from_pandas(a_)

	lowerCamelCase_					:				int              =  hf_hub_download(
	    "huggingface/transformers-metadata"     ,	"pipeline_tags.json"     ,	repo_type="dataset"     ,	token=a_)
	lowerCamelCase_					:				Dict              =  Dataset.from_json(a_)
	lowerCamelCase_					:				Optional[int]              =  {
	    tags_dataset[i]["model_class"]: (tags_dataset[i]["pipeline_tag"], tags_dataset[i]["auto_class"])
	    for i in range(len(a_))
	}
	lowerCamelCase_					:				Optional[int]              =  update_pipeline_and_auto_class_table(a_)

	# Sort the model classes to avoid some nondeterministic updates to create false update commits.
	lowerCamelCase_					:				List[Any]              =  sorted(table.keys())
	lowerCamelCase_					:				List[Any]              =  pd.DataFrame(
	    {
	        "model_class": model_classes,
	        "pipeline_tag": [table[m][0] for m in model_classes],
	        "auto_class": [table[m][1] for m in model_classes],
	    })
	lowerCamelCase_					:				Tuple              =  Dataset.from_pandas(a_)

	with tempfile.TemporaryDirectory() as tmp_dir:
		frameworks_dataset.to_json(os.path.join(a_     ,	"frameworks.json"))
		tags_dataset.to_json(os.path.join(a_     ,	"pipeline_tags.json"))

		if commit_sha is not None:
			lowerCamelCase_					:				int              =  (
			    F"""Update with commit {commit_sha}\n\nSee: """
			    F"""https://github.com/huggingface/transformers/commit/{commit_sha}"""
			)
		else:
			lowerCamelCase_					:				int              =  "Update"

		upload_folder(
		    repo_id="huggingface/transformers-metadata"     ,	folder_path=a_     ,	repo_type="dataset"     ,	token=a_     ,	commit_message=a_     ,	)







def 							__magic_name__    (     ):
	'''simple docstring'''


	lowerCamelCase_					:				Union[str, Any]              =  {tag: cls for tag, _, cls in PIPELINE_TAGS_AND_AUTO_MODELS}
	lowerCamelCase_					:				Tuple              =  transformers_module.pipelines.SUPPORTED_TASKS
	lowerCamelCase_					:				List[Any]              =  []
	for key in pipeline_tasks:
		if key not in in_table:
			lowerCamelCase_					:				Optional[int]              =  pipeline_tasks[key]["pt"]
			if isinstance(a_     ,	(list, tuple)):
				lowerCamelCase_					:				Any              =  model[0]
			lowerCamelCase_					:				Any              =  model.__name__
			if model not in in_table.values():
				missing.append(a_)

	if len(a_) > 0:
		lowerCamelCase_					:				Optional[Any]              =  ", ".join(a_)
		raise ValueError(
		    "The following pipeline tags are not present in the `PIPELINE_TAGS_AND_AUTO_MODELS` constant inside "
		    F"""`utils/update_metadata.py`: {msg}. Please add them!""")


if __name__ == "__main__":
							__magic_name__  	=     argparse.ArgumentParser()
							parser.add_argument('''--token''', type=str, help='''The token to use to push to the transformers-metadata dataset.''')
							parser.add_argument('''--commit_sha''', type=str, help='''The sha of the commit going with this update.''')
							parser.add_argument('''--check-only''', action='''store_true''', help='''Activate to just check all pipelines are present.''')
							__magic_name__  	=     parser.parse_args()

							if args.check_only:
														check_pipeline_tags()
							else:
														update_metadata(args.token, args.commit_sha)







'''simple docstring'''


import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()





class  __lowercase    (	__magic_name__							,				__magic_name__							,				__magic_name__							,				unittest.TestCase			):
   _a    						=   StableUnCLIPImgaImgPipeline
   _a    						=   TEXT_GUIDED_IMAGE_VARIATION_PARAMS
   _a    						=   TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
   _a    						=   frozenset(
       []			)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
   _a    						=   frozenset([]			)







   def 		UpperCamelCase__      (						self   )					->     List[str]:
     __a								=       32
     __a								=       embedder_hidden_size

     # image encoding components

     __a								=       CLIPImageProcessor(crop_size=32   ,				size=32   )

     torch.manual_seed(0   )
     __a								=       CLIPVisionModelWithProjection(
         CLIPVisionConfig(
             hidden_size=UpperCamelCase   ,				projection_dim=UpperCamelCase   ,				num_hidden_layers=5   ,				num_attention_heads=4   ,				image_size=32   ,				intermediate_size=37   ,				patch_size=1   ,				)   )

     # regular denoising components

     torch.manual_seed(0   )
     __a								=       StableUnCLIPImageNormalizer(embedding_dim=UpperCamelCase   )
     __a								=       DDPMScheduler(beta_schedule='squaredcos_cap_v2'   )

     torch.manual_seed(0   )
     __a								=       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   )

     torch.manual_seed(0   )
     __a								=       CLIPTextModel(
         CLIPTextConfig(
             bos_token_id=0   ,				eos_token_id=2   ,				hidden_size=UpperCamelCase   ,				projection_dim=32   ,				intermediate_size=37   ,				layer_norm_eps=1e-05   ,				num_attention_heads=4   ,				num_hidden_layers=5   ,				pad_token_id=1   ,				vocab_size=1000   ,				)   )

     torch.manual_seed(0   )
     __a								=       UNetaDConditionModel(
         sample_size=32   ,				in_channels=4   ,				out_channels=4   ,				down_block_types=('CrossAttnDownBlock2D', 'DownBlock2D')   ,				up_block_types=('UpBlock2D', 'CrossAttnUpBlock2D')   ,				block_out_channels=(32, 64)   ,				attention_head_dim=(2, 4)   ,				class_embed_type='projection'   ,				projection_class_embeddings_input_dim=embedder_projection_dim * 2   ,				cross_attention_dim=UpperCamelCase   ,				layers_per_block=1   ,				upcast_attention=UpperCamelCase   ,				use_linear_projection=UpperCamelCase   ,				)

     torch.manual_seed(0   )
     __a								=       DDIMScheduler(
         beta_schedule='scaled_linear'   ,				beta_start=0.00_085   ,				beta_end=0.012   ,				prediction_type='v_prediction'   ,				set_alpha_to_one=UpperCamelCase   ,				steps_offset=1   ,				)

     torch.manual_seed(0   )
     __a								=       AutoencoderKL()

     __a								=       {
         # image encoding components
         'feature_extractor': feature_extractor,
         'image_encoder': image_encoder.eval(),
         # image noising components
         'image_normalizer': image_normalizer.eval(),
         'image_noising_scheduler': image_noising_scheduler,
         # regular denoising components
         'tokenizer': tokenizer,
         'text_encoder': text_encoder.eval(),
         'unet': unet.eval(),
         'scheduler': scheduler,
         'vae': vae.eval(),
     }

     return components







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase=0   ,				UpperCamelCase=True   )					->     Dict:
     if str(UpperCamelCase   ).startswith('mps'   ):
       __a								=       torch.manual_seed(UpperCamelCase   )
     else:
       __a								=       torch.Generator(device=UpperCamelCase   ).manual_seed(UpperCamelCase   )

     __a								=       floats_tensor((1, 3, 32, 32)   ,				rng=random.Random(UpperCamelCase   )   ).to(UpperCamelCase   )

     if pil_image:
       __a								=       input_image * 0.5 + 0.5
       __a								=       input_image.clamp(0   ,				1   )
       __a								=       input_image.cpu().permute(0   ,				2   ,				3   ,				1   ).float().numpy()
       __a								=       DiffusionPipeline.numpy_to_pil(UpperCamelCase   )[0]

     return {
         "prompt": "An anime racoon running a marathon",
         "image": input_image,
         "generator": generator,
         "num_inference_steps": 2,
         "output_type": "np",
     }







   @skip_mps
   def 		UpperCamelCase__      (						self   )					->     int:
     __a								=       'cpu'  # ensure determinism for the device-dependent torch.Generator
     __a								=       self.get_dummy_components()
     __a								=       StableUnCLIPImgaImgPipeline(**UpperCamelCase   )
     __a								=       sd_pipe.to(UpperCamelCase   )
     sd_pipe.set_progress_bar_config(disable=UpperCamelCase   )

     __a								=       self.get_dummy_inputs(UpperCamelCase   )
     inputs.update({'image_embeds': None}   )
     __a								=       sd_pipe(**UpperCamelCase   ).images
     __a								=       image[0, -3:, -3:, -1]

     assert image.shape == (1, 32, 32, 3)
     __a								=       np.array([0.3_872, 0.7_224, 0.5_601, 0.4_741, 0.6_872, 0.5_814, 0.4_636, 0.3_867, 0.5_078]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-3







   def 		UpperCamelCase__      (						self   )					->     Any:
     __a								=       torch_device in ['cpu', 'mps']

     self._test_attention_slicing_forward_pass(test_max_difference=UpperCamelCase   )







   def 		UpperCamelCase__      (						self   )					->     Union[str, Any]:
     __a								=       torch_device in ['cpu', 'mps']

     self._test_inference_batch_single_identical(test_max_difference=UpperCamelCase   )







   @unittest.skipIf(
       torch_device != 'cuda' or not is_xformers_available()   ,				reason='XFormers attention is only available with CUDA and `xformers` installed'   ,				)
   def 		UpperCamelCase__      (						self   )					->     Optional[Any]:
     self._test_xformers_attention_forwardGenerator_pass(test_max_difference=UpperCamelCase   )





@slow
@require_torch_gpu
class  __lowercase    (	unittest.TestCase			):







   def 		UpperCamelCase__      (						self   )					->     List[Any]:
     # clean up the VRAM after each test
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()







   def 		UpperCamelCase__      (						self   )					->     str:
     __a								=       load_image(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'   )

     __a								=       load_numpy(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy'   )

     __a								=       StableUnCLIPImgaImgPipeline.from_pretrained(
         'fusing/stable-unclip-2-1-l-img2img'   ,				torch_dtype=torch.floataa   )
     pipe.to(UpperCamelCase   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )
     # stable unclip will oom when integration tests are run on a V100,
     # so turn on memory savings
     pipe.enable_attention_slicing()
     pipe.enable_sequential_cpu_offload()

     __a								=       torch.Generator(device='cpu'   ).manual_seed(0   )
     __a								=       pipe(UpperCamelCase   ,				'anime turle'   ,				generator=UpperCamelCase   ,				output_type='np'   )

     __a								=       output.images[0]

     assert image.shape == (768, 768, 3)

     assert_mean_pixel_difference(UpperCamelCase   ,				UpperCamelCase   )







   def 		UpperCamelCase__      (						self   )					->     Optional[int]:
     __a								=       load_image(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'   )

     __a								=       load_numpy(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy'   )

     __a								=       StableUnCLIPImgaImgPipeline.from_pretrained(
         'fusing/stable-unclip-2-1-h-img2img'   ,				torch_dtype=torch.floataa   )
     pipe.to(UpperCamelCase   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )
     # stable unclip will oom when integration tests are run on a V100,
     # so turn on memory savings
     pipe.enable_attention_slicing()
     pipe.enable_sequential_cpu_offload()

     __a								=       torch.Generator(device='cpu'   ).manual_seed(0   )
     __a								=       pipe(UpperCamelCase   ,				'anime turle'   ,				generator=UpperCamelCase   ,				output_type='np'   )

     __a								=       output.images[0]

     assert image.shape == (768, 768, 3)

     assert_mean_pixel_difference(UpperCamelCase   ,				UpperCamelCase   )







   def 		UpperCamelCase__      (						self   )					->     Union[str, Any]:
     __a								=       load_image(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'   )

     torch.cuda.empty_cache()
     torch.cuda.reset_max_memory_allocated()
     torch.cuda.reset_peak_memory_stats()

     __a								=       StableUnCLIPImgaImgPipeline.from_pretrained(
         'fusing/stable-unclip-2-1-h-img2img'   ,				torch_dtype=torch.floataa   )
     __a								=       pipe.to(UpperCamelCase   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )
     pipe.enable_attention_slicing()
     pipe.enable_sequential_cpu_offload()

     __a								=       pipe(
         UpperCamelCase   ,				'anime turtle'   ,				num_inference_steps=2   ,				output_type='np'   ,				)

     __a								=       torch.cuda.max_memory_allocated()
     # make sure that less than 7 GB is allocated
     assert mem_bytes < 7 * 10**9



