



import inspect
import unittest

from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
							import jax
							import jax.numpy as jnp

							from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel

if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor



class  lowerCamelCase__    (							unittest.TestCase):




		'''simple docstring'''



		def __init__(self	,__lowerCamelCase	,__lowerCamelCase=3	,__lowerCamelCase=32	,__lowerCamelCase=3	,__lowerCamelCase=10	,__lowerCamelCase=[10, 20, 30, 40]	,__lowerCamelCase=[1, 1, 2, 1]	,__lowerCamelCase=True	,__lowerCamelCase=True	,__lowerCamelCase="relu"	,__lowerCamelCase=3	,__lowerCamelCase=None	,)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[Any]				=  parent
						lowerCAmelCase__  :       str				=  batch_size
						lowerCAmelCase__  :       Optional[int]				=  image_size
						lowerCAmelCase__  :       Optional[Any]				=  num_channels
						lowerCAmelCase__  :       int				=  embeddings_size
						lowerCAmelCase__  :       List[str]				=  hidden_sizes
						lowerCAmelCase__  :       Any				=  depths
						lowerCAmelCase__  :       List[str]				=  is_training
						lowerCAmelCase__  :       Optional[Any]				=  use_labels
						lowerCAmelCase__  :       List[str]				=  hidden_act
						lowerCAmelCase__  :       Dict				=  num_labels
						lowerCAmelCase__  :       Optional[Any]				=  scope
						lowerCAmelCase__  :       Union[str, Any]				=  len(__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    List[str]:

						"""simple docstring"""






						lowerCAmelCase__  :       int				=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

						lowerCAmelCase__  :       List[Any]				=  self.get_config()

						return config, pixel_values



		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						return RegNetConfig(
						    num_channels=self.num_channels	,embeddings_size=self.embeddings_size	,hidden_sizes=self.hidden_sizes	,depths=self.depths	,hidden_act=self.hidden_act	,num_labels=self.num_labels	,image_size=self.image_size	,)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase				)  ->    Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  FlaxRegNetModel(config=__lowerCamelCase				)
						lowerCAmelCase__  :       str				=  model(__lowerCamelCase				)

						# Output shape (b, c, h, w)
						self.parent.assertEqual(
						    result.last_hidden_state.shape	,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)	,)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase				)  ->    Optional[int]:

						"""simple docstring"""






						lowerCAmelCase__  :       str				=  self.num_labels
						lowerCAmelCase__  :       str				=  FlaxRegNetForImageClassification(config=__lowerCamelCase				)
						lowerCAmelCase__  :       Optional[Any]				=  model(__lowerCamelCase				)
						self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.num_labels)				)



		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[int]				=  self.prepare_config_and_inputs()
						lowerCAmelCase__		,	lowerCAmelCase__  :       Dict				=  config_and_inputs
						lowerCAmelCase__  :       List[Any]				=  {'''pixel_values''': pixel_values}
						return config, inputs_dict



@require_flax
class  lowerCamelCase__    (							lowerCamelCase__   ,       unittest.TestCase):




		'''simple docstring'''



		snake_case_			=(FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

		snake_case_			=False
		snake_case_			=False
		snake_case_			=False



		def 	lowerCAmelCase__   (self				)  ->    None:

						"""simple docstring"""






						lowerCAmelCase__  :       List[str]				=  FlaxRegNetModelTester(self				)
						lowerCAmelCase__  :       Tuple				=  ConfigTester(self	,config_class=__lowerCamelCase	,has_text_modality=__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    str:

						"""simple docstring"""






						self.create_and_test_config_common_properties()
						self.config_tester.create_and_test_config_to_json_string()
						self.config_tester.create_and_test_config_to_json_file()
						self.config_tester.create_and_test_config_from_and_save_pretrained()
						self.config_tester.create_and_test_config_with_num_labels()
						self.config_tester.check_config_can_be_init_without_params()
						self.config_tester.check_config_arguments_init()



		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






						return



		def 	lowerCAmelCase__   (self				)  ->    List[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       int				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[Any]				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase				)



		@unittest.skip(reason='''RegNet does not use inputs_embeds'''				)
		def 	lowerCAmelCase__   (self				)  ->    Dict:

						"""simple docstring"""






						pass



		@unittest.skip(reason='''RegNet does not support input and output embeddings'''				)
		def 	lowerCAmelCase__   (self				)  ->    str:

						"""simple docstring"""






						pass



		def 	lowerCAmelCase__   (self				)  ->    List[Any]:

						"""simple docstring"""






						lowerCAmelCase__		,	lowerCAmelCase__  :       List[Any]				=  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
										lowerCAmelCase__  :       int				=  model_class(__lowerCamelCase				)
										lowerCAmelCase__  :       Tuple				=  inspect.signature(model.__call__				)
										# signature.parameters is an OrderedDict => so arg_names order is deterministic
										lowerCAmelCase__  :       List[Any]				=  [*signature.parameters.keys()]

										lowerCAmelCase__  :       Optional[Any]				=  ['''pixel_values''']
										self.assertListEqual(arg_names[:1]	,__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






						def check_hidden_states_output(__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				):
										lowerCAmelCase__  :       Optional[int]				=  model_class(__lowerCamelCase				)

										lowerCAmelCase__  :       Any				=  model(**self._prepare_for_class(__lowerCamelCase	,__lowerCamelCase				)				)

										lowerCAmelCase__  :       Tuple				=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

										lowerCAmelCase__  :       int				=  self.model_tester.num_stages
										self.assertEqual(len(__lowerCamelCase				)	,expected_num_stages + 1				)

						lowerCAmelCase__		,	lowerCAmelCase__  :       str				=  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
										lowerCAmelCase__  :       int				=  True
										check_hidden_states_output(__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										lowerCAmelCase__  :       Optional[int]				=  True

										check_hidden_states_output(__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






						lowerCAmelCase__		,	lowerCAmelCase__  :       str				=  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
										with self.subTest(model_class.__name__				):
														lowerCAmelCase__  :       Optional[Any]				=  self._prepare_for_class(__lowerCamelCase	,__lowerCamelCase				)
														lowerCAmelCase__  :       str				=  model_class(__lowerCamelCase				)

														@jax.jit
														def model_jitted(__lowerCamelCase	,**__lowerCamelCase				):
																		return model(pixel_values=__lowerCamelCase	,**__lowerCamelCase				)

														with self.subTest('''JIT Enabled'''				):
																		lowerCAmelCase__  :       str				=  model_jitted(**__lowerCamelCase				).to_tuple()

														with self.subTest('''JIT Disabled'''				):
																		with jax.disable_jit():
																						lowerCAmelCase__  :       Dict				=  model_jitted(**__lowerCamelCase				).to_tuple()

														self.assertEqual(len(__lowerCamelCase				)	,len(__lowerCamelCase				)				)
														for jitted_output, output in zip(__lowerCamelCase	,__lowerCamelCase				):
																		self.assertEqual(jitted_output.shape	,output.shape				)






def 			lowerCAmelCase__	(					):





				'''simple docstring'''

				lowerCAmelCase__  :       Optional[int]				=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
				return image



@require_flax
class  lowerCamelCase__    (							unittest.TestCase):




		'''simple docstring'''



		@cached_property
		def 	lowerCAmelCase__   (self				)  ->    Optional[int]:

						"""simple docstring"""






						return AutoImageProcessor.from_pretrained('''facebook/regnet-y-040'''				) if is_vision_available() else None



		@slow
		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       Union[str, Any]				=  FlaxRegNetForImageClassification.from_pretrained('''facebook/regnet-y-040'''				)

						lowerCAmelCase__  :       List[Any]				=  self.default_image_processor
						lowerCAmelCase__  :       List[Any]				=  prepare_img()
						lowerCAmelCase__  :       Dict				=  image_processor(images=__lowerCamelCase	,return_tensors='''np'''				)

						lowerCAmelCase__  :       int				=  model(**__lowerCamelCase				)

						# verify the logits
						lowerCAmelCase__  :       int				=  (1, 10_00)
						self.assertEqual(outputs.logits.shape	,__lowerCamelCase				)

						lowerCAmelCase__  :       Union[str, Any]				=  jnp.array([-0.4180, -1.5051, -3.4836]				)

						self.assertTrue(jnp.allclose(outputs.logits[0, :3]	,__lowerCamelCase	,atol=1e-4				)				)






import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, XLMRobertaTokenizer

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
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 PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class  lowerCamelCase__    (							lowerCamelCase__   ,       lowerCamelCase__   ,       lowerCamelCase__   ,       unittest.TestCase):




		'''simple docstring'''



		snake_case_			=AltDiffusionPipeline
		snake_case_			=TEXT_TO_IMAGE_PARAMS
		snake_case_			=TEXT_TO_IMAGE_BATCH_PARAMS
		snake_case_			=TEXT_TO_IMAGE_IMAGE_PARAMS
		snake_case_			=TEXT_TO_IMAGE_IMAGE_PARAMS



		def 	lowerCAmelCase__   (self				)  ->    Dict:

						"""simple docstring"""






						torch.manual_seed(0				)
						lowerCAmelCase__  :       int				=  UNetaDConditionModel(
						    block_out_channels=(32, 64)	,layers_per_block=2	,sample_size=32	,in_channels=4	,out_channels=4	,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')	,cross_attention_dim=32	,)
						lowerCAmelCase__  :       List[str]				=  DDIMScheduler(
						    beta_start=0.0_0085	,beta_end=0.012	,beta_schedule='''scaled_linear'''	,clip_sample=__lowerCamelCase	,set_alpha_to_one=__lowerCamelCase	,)
						torch.manual_seed(0				)
						lowerCAmelCase__  :       Optional[Any]				=  AutoencoderKL(
						    block_out_channels=[32, 64]	,in_channels=3	,out_channels=3	,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']	,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']	,latent_channels=4	,)

						# TODO: address the non-deterministic text encoder (fails for save-load tests)
						# torch.manual_seed(0)
						# text_encoder_config = RobertaSeriesConfig(
						#     hidden_size=32,
						#     project_dim=32,
						#     intermediate_size=37,
						#     layer_norm_eps=1e-05,
						#     num_attention_heads=4,
						#     num_hidden_layers=5,
						#     vocab_size=5002,
						# )
						# text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

						torch.manual_seed(0				)
						lowerCAmelCase__  :       Dict				=  CLIPTextConfig(
						    bos_token_id=0	,eos_token_id=2	,hidden_size=32	,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=50_02	,)
						lowerCAmelCase__  :       int				=  CLIPTextModel(__lowerCamelCase				)

						lowerCAmelCase__  :       str				=  XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''				)
						lowerCAmelCase__  :       Union[str, Any]				=  77

						lowerCAmelCase__  :       str				=  {
						    '''unet''': unet,
						    '''scheduler''': scheduler,
						    '''vae''': vae,
						    '''text_encoder''': text_encoder,
						    '''tokenizer''': tokenizer,
						    '''safety_checker''': None,
						    '''feature_extractor''': None,
						}
						return components



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase=0				)  ->    Optional[Any]:

						"""simple docstring"""






						if str(__lowerCamelCase				).startswith('''mps'''				):
										lowerCAmelCase__  :       Tuple				=  torch.manual_seed(__lowerCamelCase				)
						else:
										lowerCAmelCase__  :       Any				=  torch.Generator(device=__lowerCamelCase				).manual_seed(__lowerCamelCase				)
						lowerCAmelCase__  :       Optional[Any]				=  {
						    '''prompt''': '''A painting of a squirrel eating a burger''',
						    '''generator''': generator,
						    '''num_inference_steps''': 2,
						    '''guidance_scale''': 6.0,
						    '''output_type''': '''numpy''',
						}
						return inputs



		def 	lowerCAmelCase__   (self				)  ->    str:

						"""simple docstring"""






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



		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






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



		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       List[str]				=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator

						lowerCAmelCase__  :       int				=  self.get_dummy_components()
						torch.manual_seed(0				)
						lowerCAmelCase__  :       str				=  RobertaSeriesConfig(
						    hidden_size=32	,project_dim=32	,intermediate_size=37	,layer_norm_eps=1e-05	,num_attention_heads=4	,num_hidden_layers=5	,vocab_size=50_02	,)
						# TODO: remove after fixing the non-deterministic text encoder
						lowerCAmelCase__  :       Any				=  RobertaSeriesModelWithTransformation(__lowerCamelCase				)
						lowerCAmelCase__  :       List[str]				=  text_encoder

						lowerCAmelCase__  :       List[Any]				=  AltDiffusionPipeline(**__lowerCamelCase				)
						lowerCAmelCase__  :       Optional[Any]				=  alt_pipe.to(__lowerCamelCase				)
						alt_pipe.set_progress_bar_config(disable=__lowerCamelCase				)

						lowerCAmelCase__  :       List[str]				=  self.get_dummy_inputs(__lowerCamelCase				)
						lowerCAmelCase__  :       str				=  '''A photo of an astronaut'''
						lowerCAmelCase__  :       Any				=  alt_pipe(**__lowerCamelCase				)
						lowerCAmelCase__  :       int				=  output.images
						lowerCAmelCase__  :       List[Any]				=  image[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)
						lowerCAmelCase__  :       Optional[Any]				=  np.array(
						    [0.574_8162, 0.6044_7145, 0.4882_1217, 0.5010_0636, 0.543_1185, 0.4576_3683, 0.4965_7696, 0.4813_2733, 0.4757_3093]				)

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



		def 	lowerCAmelCase__   (self				)  ->    Optional[int]:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator

						lowerCAmelCase__  :       str				=  self.get_dummy_components()
						lowerCAmelCase__  :       Optional[Any]				=  PNDMScheduler(skip_prk_steps=__lowerCamelCase				)
						torch.manual_seed(0				)
						lowerCAmelCase__  :       int				=  RobertaSeriesConfig(
						    hidden_size=32	,project_dim=32	,intermediate_size=37	,layer_norm_eps=1e-05	,num_attention_heads=4	,num_hidden_layers=5	,vocab_size=50_02	,)
						# TODO: remove after fixing the non-deterministic text encoder
						lowerCAmelCase__  :       Tuple				=  RobertaSeriesModelWithTransformation(__lowerCamelCase				)
						lowerCAmelCase__  :       List[str]				=  text_encoder
						lowerCAmelCase__  :       List[Any]				=  AltDiffusionPipeline(**__lowerCamelCase				)
						lowerCAmelCase__  :       str				=  alt_pipe.to(__lowerCamelCase				)
						alt_pipe.set_progress_bar_config(disable=__lowerCamelCase				)

						lowerCAmelCase__  :       Union[str, Any]				=  self.get_dummy_inputs(__lowerCamelCase				)
						lowerCAmelCase__  :       Optional[int]				=  alt_pipe(**__lowerCamelCase				)
						lowerCAmelCase__  :       Optional[int]				=  output.images
						lowerCAmelCase__  :       str				=  image[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)
						lowerCAmelCase__  :       Union[str, Any]				=  np.array(
						    [0.5160_5093, 0.570_7241, 0.4736_5507, 0.5057_8886, 0.563_3877, 0.464_2503, 0.518_2081, 0.4876_3484, 0.4908_4237]				)

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



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




		'''simple docstring'''



		def 	lowerCAmelCase__   (self				)  ->    List[Any]:

						"""simple docstring"""






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



		def 	lowerCAmelCase__   (self				)  ->    List[str]:

						"""simple docstring"""






						lowerCAmelCase__  :       Union[str, Any]				=  AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''	,safety_checker=__lowerCamelCase				)
						lowerCAmelCase__  :       List[Any]				=  alt_pipe.to(__lowerCamelCase				)
						alt_pipe.set_progress_bar_config(disable=__lowerCamelCase				)

						lowerCAmelCase__  :       Any				=  '''A painting of a squirrel eating a burger'''
						lowerCAmelCase__  :       List[Any]				=  torch.manual_seed(0				)
						lowerCAmelCase__  :       str				=  alt_pipe([prompt]	,generator=__lowerCamelCase	,guidance_scale=6.0	,num_inference_steps=20	,output_type='''np'''				)

						lowerCAmelCase__  :       str				=  output.images

						lowerCAmelCase__  :       int				=  image[0, -3:, -3:, -1]

						assert image.shape == (1, 5_12, 5_12, 3)
						lowerCAmelCase__  :       Dict				=  np.array([0.1010, 0.0800, 0.0794, 0.0885, 0.0843, 0.0762, 0.0769, 0.0729, 0.0586]				)

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



		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  DDIMScheduler.from_pretrained('''BAAI/AltDiffusion'''	,subfolder='''scheduler'''				)

						lowerCAmelCase__  :       List[str]				=  AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''	,scheduler=__lowerCamelCase	,safety_checker=__lowerCamelCase				)
						lowerCAmelCase__  :       Union[str, Any]				=  alt_pipe.to(__lowerCamelCase				)
						alt_pipe.set_progress_bar_config(disable=__lowerCamelCase				)

						lowerCAmelCase__  :       List[Any]				=  '''A painting of a squirrel eating a burger'''
						lowerCAmelCase__  :       Optional[Any]				=  torch.manual_seed(0				)

						lowerCAmelCase__  :       List[str]				=  alt_pipe([prompt]	,generator=__lowerCamelCase	,num_inference_steps=2	,output_type='''numpy'''				)
						lowerCAmelCase__  :       List[str]				=  output.images

						lowerCAmelCase__  :       Optional[int]				=  image[0, -3:, -3:, -1]

						assert image.shape == (1, 5_12, 5_12, 3)
						lowerCAmelCase__  :       List[Any]				=  np.array([0.4019, 0.4052, 0.3810, 0.4119, 0.3916, 0.3982, 0.4651, 0.4195, 0.5323]				)

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

