




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       a					:

     '''simple docstring'''





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

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

         UpperCAmelCase_										=					self.get_config()

         return config, pixel_values, labels
     def   lowerCamelCase_       (     self       :      int    ):
         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   lowerCamelCase_       (     self       :      str ,   __snake_case       :      List[str] ,   __snake_case       :      Tuple ,   __snake_case       :      Optional[Any]    ):
         UpperCAmelCase_										=					TFResNetModel(config=__snake_case    )
         UpperCAmelCase_										=					model(__snake_case    )
         # 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   lowerCamelCase_       (     self       :      Union[str, Any] ,   __snake_case       :      int ,   __snake_case       :      Optional[Any] ,   __snake_case       :      str    ):
         UpperCAmelCase_										=					self.num_labels
         UpperCAmelCase_										=					TFResNetForImageClassification(__snake_case    )
         UpperCAmelCase_										=					model(__snake_case ,   labels=__snake_case    )
         self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.num_labels)    )




     def   lowerCamelCase_       (     self       :      List[str]    ):
         UpperCAmelCase_										=					self.prepare_config_and_inputs()
         UpperCAmelCase_			,							UpperCAmelCase_			,							UpperCAmelCase_										=					config_and_inputs
         UpperCAmelCase_										=					{'''pixel_values''': pixel_values}
         return config, inputs_dict



@require_tf
class       a					(       _A     ,       _A     ,       unittest.TestCase      ):

     '''simple docstring'''





     lowerCAmelCase    :	List[str]       		=  (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
     lowerCAmelCase    :	Any       		=  (
         {'feature-extraction': TFResNetModel, 'image-classification': TFResNetForImageClassification}
         if is_tf_available()
         else {}
     )

     lowerCAmelCase    :	str       		=  False
     lowerCAmelCase    :	int       		=  False
     lowerCAmelCase    :	Optional[Any]       		=  False
     lowerCAmelCase    :	Optional[Any]       		=  False
     lowerCAmelCase    :	Tuple       		=  False
     def   lowerCamelCase_       (     self       :      str    ):
         UpperCAmelCase_										=					TFResNetModelTester(self    )
         UpperCAmelCase_										=					ConfigTester(self ,   config_class=__snake_case ,   has_text_modality=__snake_case    )
     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         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    ):
         return
     @unittest.skip(reason='''ResNet does not use inputs_embeds'''    )
     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         pass
     @unittest.skip(reason='''ResNet does not support input and output embeddings'''    )
     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         pass
     def   lowerCamelCase_       (     self       :      Tuple    ):
         UpperCAmelCase_			,							UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs_for_common()

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

             UpperCAmelCase_										=					['''pixel_values''']
             self.assertListEqual(arg_names[:1] ,   __snake_case    )
     def   lowerCamelCase_       (     self       :      List[str]    ):
         UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__snake_case    )
     def   lowerCamelCase_       (     self       :      int    ):
         def check_hidden_states_output(__snake_case       :      Any ,   __snake_case       :      int ,   __snake_case       :      Any    ):
             UpperCAmelCase_										=					model_class(__snake_case    )
             UpperCAmelCase_										=					model(**self._prepare_for_class(__snake_case ,   __snake_case    )    )

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

             UpperCAmelCase_										=					self.model_tester.num_stages
             self.assertEqual(len(__snake_case    ) ,   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] ,   )

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

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

                 check_hidden_states_output(__snake_case ,   __snake_case ,   __snake_case    )
     def   lowerCamelCase_       (     self       :      List[Any]    ):
         UpperCAmelCase_										=					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__snake_case    )




     @slow
     def   lowerCamelCase_       (     self       :      List[Any]    ):
         for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCAmelCase_										=					TFResNetModel.from_pretrained(__snake_case    )
             self.assertIsNotNone(__snake_case    )




def  SCREAMING_SNAKE_CASE     (	)  ->							List[Any]:
    UpperCAmelCase_										=					Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
    return image



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

     '''simple docstring'''





     @cached_property
     def   lowerCamelCase_       (     self       :      Union[str, Any]    ):
         return (
             AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )
             if is_vision_available()
             else None
         )




     @slow
     def   lowerCamelCase_       (     self       :      str    ):
         UpperCAmelCase_										=					TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )

         UpperCAmelCase_										=					self.default_image_processor
         UpperCAmelCase_										=					prepare_img()
         UpperCAmelCase_										=					image_processor(images=__snake_case ,   return_tensors='''tf'''    )

         # forward pass
         UpperCAmelCase_										=					model(**__snake_case    )

         # verify the logits
         UpperCAmelCase_										=					tf.TensorShape((1, 10_00)    )
         self.assertEqual(outputs.logits.shape ,   __snake_case    )

         UpperCAmelCase_										=					tf.constant([-11.1_069, -9.7_877, -8.3_777]    )

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











import gc
import unittest

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

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


_lowerCamelCase      			=						False



class       a					(       unittest.TestCase      ):

     '''simple docstring'''





     def   lowerCamelCase_       (     self       :      str    ):
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()
     @property
     def   lowerCamelCase_       (     self       :      Any    ):
         return 12
     @property
     def   lowerCamelCase_       (     self       :      Union[str, Any]    ):
         return 12
     @property
     def   lowerCamelCase_       (     self       :      Optional[Any]    ):
         return 32
     @property
     def   lowerCamelCase_       (     self       :      List[Any]    ):
         torch.manual_seed(0    )
         UpperCAmelCase_										=					VQModel(
             block_out_channels=[32, 64] ,   in_channels=3 ,   out_channels=3 ,   down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] ,   up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] ,   latent_channels=3 ,   num_vq_embeddings=self.num_embed ,   vq_embed_dim=3 ,   )
         return model
     @property
     def   lowerCamelCase_       (     self       :      Tuple    ):
         UpperCAmelCase_										=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )
         return tokenizer
     @property
     def   lowerCamelCase_       (     self       :      int    ):
         torch.manual_seed(0    )
         UpperCAmelCase_										=					CLIPTextConfig(
             bos_token_id=0 ,   eos_token_id=2 ,   hidden_size=self.text_embedder_hidden_size ,   intermediate_size=37 ,   layer_norm_eps=1E-05 ,   num_attention_heads=4 ,   num_hidden_layers=5 ,   pad_token_id=1 ,   vocab_size=10_00 ,   )
         return CLIPTextModel(__snake_case    )
     @property
     def   lowerCamelCase_       (     self       :      Union[str, Any]    ):
         torch.manual_seed(0    )

         UpperCAmelCase_										=					12
         UpperCAmelCase_										=					12

         UpperCAmelCase_										=					{
             '''attention_bias''': True,
             '''cross_attention_dim''': 32,
             '''attention_head_dim''': height * width,
             '''num_attention_heads''': 1,
             '''num_vector_embeds''': self.num_embed,
             '''num_embeds_ada_norm''': self.num_embeds_ada_norm,
             '''norm_num_groups''': 32,
             '''sample_size''': width,
             '''activation_fn''': '''geglu-approximate''',
         }

         UpperCAmelCase_										=					TransformeraDModel(**__snake_case    )
         return model
     def   lowerCamelCase_       (     self       :      int    ):
         UpperCAmelCase_										=					'''cpu'''

         UpperCAmelCase_										=					self.dummy_vqvae
         UpperCAmelCase_										=					self.dummy_text_encoder
         UpperCAmelCase_										=					self.dummy_tokenizer
         UpperCAmelCase_										=					self.dummy_transformer
         UpperCAmelCase_										=					VQDiffusionScheduler(self.num_embed    )
         UpperCAmelCase_										=					LearnedClassifierFreeSamplingEmbeddings(learnable=__snake_case    )

         UpperCAmelCase_										=					VQDiffusionPipeline(
             vqvae=__snake_case ,   text_encoder=__snake_case ,   tokenizer=__snake_case ,   transformer=__snake_case ,   scheduler=__snake_case ,   learned_classifier_free_sampling_embeddings=__snake_case ,   )
         UpperCAmelCase_										=					pipe.to(__snake_case    )
         pipe.set_progress_bar_config(disable=__snake_case    )

         UpperCAmelCase_										=					'''teddy bear playing in the pool'''

         UpperCAmelCase_										=					torch.Generator(device=__snake_case    ).manual_seed(0    )
         UpperCAmelCase_										=					pipe([prompt] ,   generator=__snake_case ,   num_inference_steps=2 ,   output_type='''np'''    )
         UpperCAmelCase_										=					output.images

         UpperCAmelCase_										=					torch.Generator(device=__snake_case    ).manual_seed(0    )
         UpperCAmelCase_										=					pipe(
             [prompt] ,   generator=__snake_case ,   output_type='''np''' ,   return_dict=__snake_case ,   num_inference_steps=2    )[0]

         UpperCAmelCase_										=					image[0, -3:, -3:, -1]
         UpperCAmelCase_										=					image_from_tuple[0, -3:, -3:, -1]

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

         UpperCAmelCase_										=					np.array([0.6_551, 0.6_168, 0.5_008, 0.5_676, 0.5_659, 0.4_295, 0.6_073, 0.5_599, 0.4_992]    )

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




     def   lowerCamelCase_       (     self       :      str    ):
         UpperCAmelCase_										=					'''cpu'''

         UpperCAmelCase_										=					self.dummy_vqvae
         UpperCAmelCase_										=					self.dummy_text_encoder
         UpperCAmelCase_										=					self.dummy_tokenizer
         UpperCAmelCase_										=					self.dummy_transformer
         UpperCAmelCase_										=					VQDiffusionScheduler(self.num_embed    )
         UpperCAmelCase_										=					LearnedClassifierFreeSamplingEmbeddings(
             learnable=__snake_case ,   hidden_size=self.text_embedder_hidden_size ,   length=tokenizer.model_max_length    )

         UpperCAmelCase_										=					VQDiffusionPipeline(
             vqvae=__snake_case ,   text_encoder=__snake_case ,   tokenizer=__snake_case ,   transformer=__snake_case ,   scheduler=__snake_case ,   learned_classifier_free_sampling_embeddings=__snake_case ,   )
         UpperCAmelCase_										=					pipe.to(__snake_case    )
         pipe.set_progress_bar_config(disable=__snake_case    )

         UpperCAmelCase_										=					'''teddy bear playing in the pool'''

         UpperCAmelCase_										=					torch.Generator(device=__snake_case    ).manual_seed(0    )
         UpperCAmelCase_										=					pipe([prompt] ,   generator=__snake_case ,   num_inference_steps=2 ,   output_type='''np'''    )
         UpperCAmelCase_										=					output.images

         UpperCAmelCase_										=					torch.Generator(device=__snake_case    ).manual_seed(0    )
         UpperCAmelCase_										=					pipe(
             [prompt] ,   generator=__snake_case ,   output_type='''np''' ,   return_dict=__snake_case ,   num_inference_steps=2    )[0]

         UpperCAmelCase_										=					image[0, -3:, -3:, -1]
         UpperCAmelCase_										=					image_from_tuple[0, -3:, -3:, -1]

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

         UpperCAmelCase_										=					np.array([0.6_693, 0.6_075, 0.4_959, 0.5_701, 0.5_583, 0.4_333, 0.6_171, 0.5_684, 0.4_988]    )

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



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

     '''simple docstring'''





     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()




     def   lowerCamelCase_       (     self       :      Optional[int]    ):
         UpperCAmelCase_										=					load_numpy(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
             '''/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy'''    )

         UpperCAmelCase_										=					VQDiffusionPipeline.from_pretrained('''microsoft/vq-diffusion-ithq'''    )
         UpperCAmelCase_										=					pipeline.to(__snake_case    )
         pipeline.set_progress_bar_config(disable=__snake_case    )

         # requires GPU generator for gumbel softmax
         # don't use GPU generator in tests though
         UpperCAmelCase_										=					torch.Generator(device=__snake_case    ).manual_seed(0    )
         UpperCAmelCase_										=					pipeline(
             '''teddy bear playing in the pool''' ,   num_images_per_prompt=1 ,   generator=__snake_case ,   output_type='''np''' ,   )

         UpperCAmelCase_										=					output.images[0]

         assert image.shape == (2_56, 2_56, 3)
         assert np.abs(expected_image - image    ).max() < 2.0





