
"""simple docstring"""



import gc
import random
import unittest

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

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

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


enable_full_determinism()

class       lowerCAmelCase__				(						A_ ,	A_ ,	unittest.TestCase	):
     __a						=					StableDiffusionXLImgaImgPipeline
     __a						=					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
     __a						=					PipelineTesterMixin.required_optional_params - {"""latents"""}
     __a						=					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     __a						=					IMAGE_TO_IMAGE_IMAGE_PARAMS
     __a						=					IMAGE_TO_IMAGE_IMAGE_PARAMS







     def      lowercase	(							self			:			Optional[Any]			):
       torch.manual_seed(0			)
       _snake_case					     =       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''')    ,      attention_head_dim=(2, 4)    ,      use_linear_projection=_lowerCamelCase    ,      addition_embed_type='''text_time'''    ,      addition_time_embed_dim=8    ,      transformer_layers_per_block=(1, 2)    ,      projection_class_embeddings_input_dim=80    ,      cross_attention_dim=64    ,      )
       _snake_case					     =       EulerDiscreteScheduler(
           beta_start=0.0_0_0_8_5    ,      beta_end=0.0_1_2    ,      steps_offset=1    ,      beta_schedule='''scaled_linear'''    ,      timestep_spacing='''leading'''    ,      )
       torch.manual_seed(0			)
       _snake_case					     =       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    ,      sample_size=128    ,      )
       torch.manual_seed(0			)
       _snake_case					     =       CLIPTextConfig(
           bos_token_id=0    ,      eos_token_id=2    ,      hidden_size=32    ,      intermediate_size=37    ,      layer_norm_eps=1e-05    ,      num_attention_heads=4    ,      num_hidden_layers=5    ,      pad_token_id=1    ,      vocab_size=1000    ,      hidden_act='''gelu'''    ,      projection_dim=32    ,      )
       _snake_case					     =       CLIPTextModel(_lowerCamelCase			)
       _snake_case					     =       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    ,      local_files_only=_lowerCamelCase			)

       _snake_case					     =       CLIPTextModelWithProjection(_lowerCamelCase			)
       _snake_case					     =       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    ,      local_files_only=_lowerCamelCase			)

       _snake_case					     =       {
           '''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      lowercase	(							self			:			Optional[int]    ,      _lowerCamelCase			:			str    ,      _lowerCamelCase			:			int=0			):
       _snake_case					     =       floats_tensor((1, 3, 32, 32)    ,      rng=random.Random(_lowerCamelCase			)			).to(_lowerCamelCase			)
       _snake_case					     =       image / 2 + 0.5
       if str(_lowerCamelCase			).startswith('''mps'''			):
         _snake_case					     =       torch.manual_seed(_lowerCamelCase			)
       else:
         _snake_case					     =       torch.Generator(device=_lowerCamelCase			).manual_seed(_lowerCamelCase			)
       _snake_case					     =       {
           '''prompt''': '''A painting of a squirrel eating a burger''',
           '''image''': image,
           '''generator''': generator,
           '''num_inference_steps''': 2,
           '''guidance_scale''': 5.0,
           '''output_type''': '''numpy''',
           '''strength''': 0.7_5,
       }
       return inputs







     def      lowercase	(							self			:			Optional[int]			):
       _snake_case					     =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
       _snake_case					     =       self.get_dummy_components()
       _snake_case					     =       StableDiffusionXLImgaImgPipeline(**_lowerCamelCase			)
       _snake_case					     =       sd_pipe.to(_lowerCamelCase			)
       sd_pipe.set_progress_bar_config(disable=_lowerCamelCase			)

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

       assert image.shape == (1, 32, 32, 3)

       _snake_case					     =       np.array([0.4_6_5_6, 0.4_8_4_0, 0.4_4_3_9, 0.6_6_9_8, 0.5_5_7_4, 0.4_5_2_4, 0.5_7_9_9, 0.5_9_4_3, 0.5_1_6_5]			)

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







     def      lowercase	(							self			:			Dict			):
       super().test_attention_slicing_forward_pass(expected_max_diff=3e-3			)







     def      lowercase	(							self			:			List[str]			):
       super().test_inference_batch_single_identical(expected_max_diff=3e-3			)







     def      lowercase	(							self			:			str			):
       pass







     def      lowercase	(							self			:			List[str]			):
       _snake_case					     =       self.get_dummy_components()
       _snake_case					     =       StableDiffusionXLImgaImgPipeline(**_lowerCamelCase			)
       _snake_case					     =       sd_pipe.to(_lowerCamelCase			)
       _snake_case					     =       sd_pipe.to(_lowerCamelCase			)
       sd_pipe.set_progress_bar_config(disable=_lowerCamelCase			)

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

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

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

       (
           (
           _snake_case
       )     ,					(
           _snake_case
       )     ,					(
           _snake_case
       )     ,					(
           _snake_case
       )     ,					
       )					     =       sd_pipe.encode_prompt(_lowerCamelCase    ,      negative_prompt=_lowerCamelCase			)

       _snake_case					     =       sd_pipe(
           **_lowerCamelCase    ,      prompt_embeds=_lowerCamelCase    ,      negative_prompt_embeds=_lowerCamelCase    ,      pooled_prompt_embeds=_lowerCamelCase    ,      negative_pooled_prompt_embeds=_lowerCamelCase    ,      )
       _snake_case					     =       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






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







     def      lowercase	(							self			:			Optional[Any]			):
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()







     def      lowercase	(							self			:			Dict    ,      _lowerCamelCase			:			List[str]    ,      _lowerCamelCase			:			List[Any]="cpu"    ,      _lowerCamelCase			:			List[str]=torch.floataa    ,      _lowerCamelCase			:			int=0			):
       _snake_case					     =       torch.Generator(device=_lowerCamelCase			).manual_seed(_lowerCamelCase			)
       _snake_case					     =       np.random.RandomState(_lowerCamelCase			).standard_normal((1, 4, 64, 64)			)
       _snake_case					     =       torch.from_numpy(_lowerCamelCase			).to(device=_lowerCamelCase    ,      dtype=_lowerCamelCase			)
       _snake_case					     =       {
           '''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      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''			)
       pipe.to(_lowerCamelCase			)
       pipe.set_progress_bar_config(disable=_lowerCamelCase			)

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

       assert image.shape == (1, 512, 512, 3)
       _snake_case					     =       np.array([0.4_9_4_9_3, 0.4_7_8_9_6, 0.4_0_7_9_8, 0.5_4_2_1_4, 0.5_3_2_1_2, 0.4_8_2_0_2, 0.4_7_6_5_6, 0.4_6_3_2_9, 0.4_8_5_0_6]			)
       assert np.abs(image_slice - expected_slice			).max() < 7e-3





"""simple docstring"""



from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import TFResNetForImageClassification, TFResNetModel
 from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor

class       lowerCAmelCase__				:







     def __init__(							self			:			Dict    ,      _lowerCamelCase			:			int    ,      _lowerCamelCase			:			Optional[int]=3    ,      _lowerCamelCase			:			List[str]=32    ,      _lowerCamelCase			:			Optional[int]=3    ,      _lowerCamelCase			:			Dict=10    ,      _lowerCamelCase			:			Tuple=[10, 20, 30, 40]    ,      _lowerCamelCase			:			int=[1, 1, 2, 1]    ,      _lowerCamelCase			:			int=True    ,      _lowerCamelCase			:			Optional[int]=True    ,      _lowerCamelCase			:			Optional[int]="relu"    ,      _lowerCamelCase			:			List[Any]=3    ,      _lowerCamelCase			:			Dict=None    ,      ):
       _snake_case					     =       parent
       _snake_case					     =       batch_size
       _snake_case					     =       image_size
       _snake_case					     =       num_channels
       _snake_case					     =       embeddings_size
       _snake_case					     =       hidden_sizes
       _snake_case					     =       depths
       _snake_case					     =       is_training
       _snake_case					     =       use_labels
       _snake_case					     =       hidden_act
       _snake_case					     =       num_labels
       _snake_case					     =       scope
       _snake_case					     =       len(_lowerCamelCase			)







     def      lowercase	(							self			:			Optional[int]			):
       _snake_case					     =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

       _snake_case					     =       None
       if self.use_labels:
         _snake_case					     =       ids_tensor([self.batch_size]    ,      self.num_labels			)

       _snake_case					     =       self.get_config()

       return config, pixel_values, labels







     def      lowercase	(							self			:			Tuple			):
       return ResNetConfig(
           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      lowercase	(							self			:			List[Any]    ,      _lowerCamelCase			:			List[str]    ,      _lowerCamelCase			:			str    ,      _lowerCamelCase			:			List[Any]			):
       _snake_case					     =       TFResNetModel(config=_lowerCamelCase			)
       _snake_case					     =       model(_lowerCamelCase			)
       # expected last hidden states: B, C, H // 32, W // 32
       self.parent.assertEqual(
           result.last_hidden_state.shape    ,      (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)    ,      )







     def      lowercase	(							self			:			Dict    ,      _lowerCamelCase			:			str    ,      _lowerCamelCase			:			Optional[Any]    ,      _lowerCamelCase			:			Tuple			):
       _snake_case					     =       self.num_labels
       _snake_case					     =       TFResNetForImageClassification(_lowerCamelCase			)
       _snake_case					     =       model(_lowerCamelCase    ,      labels=_lowerCamelCase			)
       self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.num_labels)			)







     def      lowercase	(							self			:			Tuple			):
       _snake_case					     =       self.prepare_config_and_inputs()
       _snake_case     ,					_snake_case     ,					_snake_case					     =       config_and_inputs
       _snake_case					     =       {'''pixel_values''': pixel_values}
       return config, inputs_dict






@require_tf
class       lowerCAmelCase__				(						A_ ,	A_ ,	unittest.TestCase	):
     __a						=					(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
     __a						=					(
         {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
         if is_tf_available()
         else {}
     )

     __a						=					False
     __a						=					False
     __a						=					False
     __a						=					False
     __a						=					False







     def      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       TFResNetModelTester(self			)
       _snake_case					     =       ConfigTester(self    ,      config_class=_lowerCamelCase    ,      has_text_modality=_lowerCamelCase			)







     def      lowercase	(							self			:			Tuple			):
       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      lowercase	(							self			:			List[Any]			):
       return







     @unittest.skip(reason='''ResNet does not use inputs_embeds'''			)
     def      lowercase	(							self			:			Any			):
       pass







     @unittest.skip(reason='''ResNet does not support input and output embeddings'''			)
     def      lowercase	(							self			:			List[str]			):
       pass







     def      lowercase	(							self			:			int			):
       _snake_case     ,					_snake_case					     =       self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
         _snake_case					     =       model_class(_lowerCamelCase			)
         _snake_case					     =       inspect.signature(model.call			)
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         _snake_case					     =       [*signature.parameters.keys()]

         _snake_case					     =       ['''pixel_values''']
         self.assertListEqual(arg_names[:1]    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			List[str]			):
       _snake_case					     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]			):
       def check_hidden_states_output(_lowerCamelCase			:			int    ,      _lowerCamelCase			:			List[Any]    ,      _lowerCamelCase			:			str			):
         _snake_case					     =       model_class(_lowerCamelCase			)
         _snake_case					     =       model(**self._prepare_for_class(_lowerCamelCase    ,      _lowerCamelCase			)			)

         _snake_case					     =       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

         _snake_case					     =       self.model_tester.num_stages
         self.assertEqual(len(_lowerCamelCase			)    ,      expected_num_stages + 1			)

         # ResNet's feature maps are of shape (batch_size, num_channels, height, width)
         self.assertListEqual(
             list(hidden_states[0].shape[-2:]			)    ,      [self.model_tester.image_size // 4, self.model_tester.image_size // 4]    ,      )

       _snake_case     ,					_snake_case					     =       self.model_tester.prepare_config_and_inputs_for_common()
       _snake_case					     =       ['''basic''', '''bottleneck''']
       for model_class in self.all_model_classes:
         for layer_type in layers_type:
           _snake_case					     =       layer_type
           _snake_case					     =       True
           check_hidden_states_output(_lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase			)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           _snake_case					     =       True

           check_hidden_states_output(_lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]			):
       _snake_case					     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase			)







     @slow
     def      lowercase	(							self			:			List[str]			):
       for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _snake_case					     =       TFResNetModel.from_pretrained(_lowerCamelCase			)
         self.assertIsNotNone(_lowerCamelCase			)






def 					_UpperCAmelCase      ( )     ->					Union[str, Any]:
  _snake_case					     =       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
  return image

@require_tf
@require_vision
class       lowerCAmelCase__				(						unittest.TestCase	):







     @cached_property
     def      lowercase	(							self			:			Dict			):
       return (
           AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)
           if is_vision_available()
           else None
       )







     @slow
     def      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)

       _snake_case					     =       self.default_image_processor
       _snake_case					     =       prepare_img()
       _snake_case					     =       image_processor(images=_lowerCamelCase    ,      return_tensors='''tf'''			)

       # forward pass
       _snake_case					     =       model(**_lowerCamelCase			)

       # verify the logits
       _snake_case					     =       tf.TensorShape((1, 1000)			)
       self.assertEqual(outputs.logits.shape    ,      _lowerCamelCase			)

       _snake_case					     =       tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]			)

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



