




import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()
class      a__       (   snake_case__					,							snake_case__					,							unittest.TestCase ):
						_a				:       str   =       StableDiffusionXLPipeline
						_a				:       Optional[int]   =       TEXT_TO_IMAGE_PARAMS
						_a				:       List[str]   =       TEXT_TO_IMAGE_BATCH_PARAMS
						_a				:       Optional[Any]   =       TEXT_TO_IMAGE_IMAGE_PARAMS
						_a				:       Union[str, Any]   =       TEXT_TO_IMAGE_IMAGE_PARAMS






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											torch.manual_seed(0     )
											__lowerCAmelCase							  =			UNetaDConditionModel(
											    block_out_channels=(3_2, 6_4)						,     layers_per_block=2						,     sample_size=3_2						,     in_channels=4						,     out_channels=4						,     down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")						,     up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")						,     attention_head_dim=(2, 4)						,     use_linear_projection=__snake_case						,     addition_embed_type="text_time"						,     addition_time_embed_dim=8						,     transformer_layers_per_block=(1, 2)						,     projection_class_embeddings_input_dim=8_0						,     cross_attention_dim=6_4						,     )
											__lowerCAmelCase							  =			EulerDiscreteScheduler(
											    beta_start=0.0_00_85						,     beta_end=0.0_12						,     steps_offset=1						,     beta_schedule="scaled_linear"						,     timestep_spacing="leading"						,     )
											torch.manual_seed(0     )
											__lowerCAmelCase							  =			AutoencoderKL(
											    block_out_channels=[3_2, 6_4]						,     in_channels=3						,     out_channels=3						,     down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]						,     up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]						,     latent_channels=4						,     sample_size=1_2_8						,     )
											torch.manual_seed(0     )
											__lowerCAmelCase							  =			CLIPTextConfig(
											    bos_token_id=0						,     eos_token_id=2						,     hidden_size=3_2						,     intermediate_size=3_7						,     layer_norm_eps=1E-0_5						,     num_attention_heads=4						,     num_hidden_layers=5						,     pad_token_id=1						,     vocab_size=1_0_0_0						,     hidden_act="gelu"						,     projection_dim=3_2						,     )
											__lowerCAmelCase							  =			CLIPTextModel(__snake_case     )
											__lowerCAmelCase							  =			CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						,     local_files_only=__snake_case     )

											__lowerCAmelCase							  =			CLIPTextModelWithProjection(__snake_case     )
											__lowerCAmelCase							  =			CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						,     local_files_only=__snake_case     )

											__lowerCAmelCase							  =			{
											    '''unet''': unet,
											    '''scheduler''': scheduler,
											    '''vae''': vae,
											    '''text_encoder''': text_encoder,
											    '''tokenizer''': tokenizer,
											    '''text_encoder_2''': text_encoder_a,
											    '''tokenizer_2''': tokenizer_a,
											    # "safety_checker": None,
											    # "feature_extractor": None,
											}
											return components






						def 							__SCREAMING_SNAKE_CASE(  self						,     _A						,     _A=0     ):




											"""simple docstring"""



											if str(__snake_case     ).startswith("mps"     ):
																__lowerCAmelCase							  =			torch.manual_seed(__snake_case     )
											else:
																__lowerCAmelCase							  =			torch.Generator(device=__snake_case     ).manual_seed(__snake_case     )
											__lowerCAmelCase							  =			{
											    '''prompt''': '''A painting of a squirrel eating a burger''',
											    '''generator''': generator,
											    '''num_inference_steps''': 2,
											    '''guidance_scale''': 5.0,
											    '''output_type''': '''numpy''',
											}
											return inputs






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											__lowerCAmelCase							  =			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
											__lowerCAmelCase							  =			self.get_dummy_components()
											__lowerCAmelCase							  =			StableDiffusionXLPipeline(**__snake_case     )
											__lowerCAmelCase							  =			sd_pipe.to(__snake_case     )
											sd_pipe.set_progress_bar_config(disable=__snake_case     )

											__lowerCAmelCase							  =			self.get_dummy_inputs(__snake_case     )
											__lowerCAmelCase							  =			sd_pipe(**__snake_case     ).images
											__lowerCAmelCase							  =			image[0, -3:, -3:, -1]

											assert image.shape == (1, 6_4, 6_4, 3)
											__lowerCAmelCase							  =			np.array([0.58_73, 0.61_28, 0.47_97, 0.51_22, 0.56_74, 0.46_39, 0.52_27, 0.51_49, 0.47_47]     )

											assert np.abs(image_slice.flatten() - expected_slice     ).max() < 1E-2






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											__lowerCAmelCase							  =			self.get_dummy_components()
											__lowerCAmelCase							  =			StableDiffusionXLPipeline(**__snake_case     )
											__lowerCAmelCase							  =			sd_pipe.to(__snake_case     )
											__lowerCAmelCase							  =			sd_pipe.to(__snake_case     )
											sd_pipe.set_progress_bar_config(disable=__snake_case     )

											# forward without prompt embeds
											__lowerCAmelCase							  =			self.get_dummy_inputs(__snake_case     )
											__lowerCAmelCase							  =			3 * ['''this is a negative prompt''']
											__lowerCAmelCase							  =			negative_prompt
											__lowerCAmelCase							  =			3 * [inputs['''prompt''']]

											__lowerCAmelCase							  =			sd_pipe(**__snake_case     )
											__lowerCAmelCase							  =			output.images[0, -3:, -3:, -1]

											# forward with prompt embeds
											__lowerCAmelCase							  =			self.get_dummy_inputs(__snake_case     )
											__lowerCAmelCase							  =			3 * ['''this is a negative prompt''']
											__lowerCAmelCase							  =			3 * [inputs.pop("prompt"     )]

											(
											    __lowerCAmelCase   
											)							  =			sd_pipe.encode_prompt(__snake_case						,     negative_prompt=__snake_case     )

											__lowerCAmelCase							  =			sd_pipe(
											    **__snake_case						,     prompt_embeds=__snake_case						,     negative_prompt_embeds=__snake_case						,     pooled_prompt_embeds=__snake_case						,     negative_pooled_prompt_embeds=__snake_case						,     )
											__lowerCAmelCase							  =			output.images[0, -3:, -3:, -1]

											# make sure that it's equal
											assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()     ).max() < 1E-4






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											super().test_attention_slicing_forward_pass(expected_max_diff=3E-3     )






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											super().test_inference_batch_single_identical(expected_max_diff=3E-3     )






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






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()






						def 							__SCREAMING_SNAKE_CASE(  self						,     _A						,     _A="cpu"						,     _A=torch.floataa						,     _A=0     ):




											"""simple docstring"""



											__lowerCAmelCase							  =			torch.Generator(device=__snake_case     ).manual_seed(__snake_case     )
											__lowerCAmelCase							  =			np.random.RandomState(__snake_case     ).standard_normal((1, 4, 6_4, 6_4)     )
											__lowerCAmelCase							  =			torch.from_numpy(__snake_case     ).to(device=__snake_case						,     dtype=__snake_case     )
											__lowerCAmelCase							  =			{
											    '''prompt''': '''a photograph of an astronaut riding a horse''',
											    '''latents''': latents,
											    '''generator''': generator,
											    '''num_inference_steps''': 3,
											    '''guidance_scale''': 7.5,
											    '''output_type''': '''numpy''',
											}
											return inputs






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



											__lowerCAmelCase							  =			DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-base"     )
											pipe.to(__snake_case     )
											pipe.set_progress_bar_config(disable=__snake_case     )

											__lowerCAmelCase							  =			self.get_inputs(__snake_case     )
											__lowerCAmelCase							  =			pipe(**__snake_case     ).images
											__lowerCAmelCase							  =			image[0, -3:, -3:, -1].flatten()

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__lowerCAmelCase							  =			np.array([0.4_94_93, 0.4_78_96, 0.4_07_98, 0.5_42_14, 0.5_32_12, 0.4_82_02, 0.4_76_56, 0.4_63_29, 0.4_85_06]     )
											assert np.abs(image_slice - expected_slice     ).max() < 7E-3








import argparse

from transformers import CanineConfig, CanineModel, CanineTokenizer, load_tf_weights_in_canine
from transformers.utils import logging


logging.set_verbosity_info()
def   snake_case_    (			__lowercase      ,							__lowercase							):
   # Initialize PyTorch model
   UpperCAmelCase_				:   Optional[Any]							= CanineConfig()
   UpperCAmelCase_				:   Any							= CanineModel(__lowercase							)
   model.eval()

   print(F'''Building PyTorch model from configuration: {config}'''							)

   # Load weights from tf checkpoint
   load_tf_weights_in_canine(__lowercase      ,							__lowercase      ,							__lowercase							)

   # Save pytorch-model (weights and configuration)
   print(F'''Save PyTorch model to {pytorch_dump_path}'''							)
   model.save_pretrained(__lowercase							)

   # Save tokenizer files
   UpperCAmelCase_				:   List[Any]							= CanineTokenizer()
   print(F'''Save tokenizer files to {pytorch_dump_path}'''							)
   tokenizer.save_pretrained(__lowercase							)


if __name__ == "__main__":
       __UpperCamelCase					:	int          =				argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           '--tf_checkpoint_path',
           default=None,
           type=str,
           required=True,
           help='Path to the TensorFlow checkpoint. Should end with model.ckpt',
       )
       parser.add_argument(
           '--pytorch_dump_path',
           default=None,
           type=str,
           required=True,
           help='Path to a folder where the PyTorch model will be placed.',
       )
       __UpperCamelCase					:	str          =				parser.parse_args()
       convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.pytorch_dump_path)