




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


 '''simple docstring'''







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



 def       lowerCAmelCase_  (							self  :		Dict						):
       SCREAMING_SNAKE_CASE_							=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

       SCREAMING_SNAKE_CASE_							=			self.get_config()

       return config, pixel_values, labels



 def       lowerCAmelCase_  (							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       lowerCAmelCase_  (							self  :		Optional[Any]				,				_lowerCAmelCase  :		Optional[int]				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		Dict						):
       SCREAMING_SNAKE_CASE_							=			TFResNetModel(config=snake_case__						)
       SCREAMING_SNAKE_CASE_							=			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  :		Optional[Any]				,				_lowerCAmelCase  :		Any				,				_lowerCAmelCase  :		Dict				,				_lowerCAmelCase  :		str						):
       SCREAMING_SNAKE_CASE_							=			self.num_labels
       SCREAMING_SNAKE_CASE_							=			TFResNetForImageClassification(snake_case__						)
       SCREAMING_SNAKE_CASE_							=			model(snake_case__				,				labels=snake_case__						)
       self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_labels)						)




 def       lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_							=			self.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE_							=			config_and_inputs
       SCREAMING_SNAKE_CASE_							=			{"pixel_values": pixel_values}
       return config, inputs_dict





@require_tf
class        lowerCamelCase_							(      A_       ,   A_       ,   unittest.TestCase					):


 '''simple docstring'''







 lowercase_				    =    (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
 lowercase_				    =    (
     {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
     if is_tf_available()
     else {}
 )

 lowercase_				    =    False
 lowercase_				    =    False
 lowercase_				    =    False
 lowercase_				    =    False
 lowercase_				    =    False



 def       lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_							=			TFResNetModelTester(self						)
       SCREAMING_SNAKE_CASE_							=			ConfigTester(self				,				config_class=snake_case__				,				has_text_modality=snake_case__						)



 def       lowerCAmelCase_  (							self  :		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  :		str						):
       return



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



 @unittest.skip(reason='ResNet does not support input and output embeddings'						)
 def       lowerCAmelCase_  (							self  :		Optional[Any]						):
       pass



 def       lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs_for_common()

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

             SCREAMING_SNAKE_CASE_							=			["pixel_values"]
             self.assertListEqual(arg_names[:1]				,				snake_case__						)



 def       lowerCAmelCase_  (							self  :		Any						):
       SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*snake_case__						)



 def       lowerCAmelCase_  (							self  :		Optional[int]						):


       def check_hidden_states_output(_lowerCAmelCase  :		Union[str, Any]				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		List[str]						):
             SCREAMING_SNAKE_CASE_							=			model_class(snake_case__						)
             SCREAMING_SNAKE_CASE_							=			model(**self._prepare_for_class(snake_case__				,				snake_case__						)						)

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

             SCREAMING_SNAKE_CASE_							=			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]				,				)

       SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE_							=			["basic", "bottleneck"]
       for model_class in self.all_model_classes:
             for layer_type in layers_type:
                   SCREAMING_SNAKE_CASE_							=			layer_type
                   SCREAMING_SNAKE_CASE_							=			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"]
                   SCREAMING_SNAKE_CASE_							=			True

                   check_hidden_states_output(snake_case__				,				snake_case__				,				snake_case__						)



 def       lowerCAmelCase_  (							self  :		List[Any]						):
       SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*snake_case__						)




 @slow
 def       lowerCAmelCase_  (							self  :		Any						):


       for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             SCREAMING_SNAKE_CASE_							=			TFResNetModel.from_pretrained(snake_case__						)
             self.assertIsNotNone(snake_case__						)


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





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


 '''simple docstring'''







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




 @slow
 def       lowerCAmelCase_  (							self  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_							=			TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)

       SCREAMING_SNAKE_CASE_							=			self.default_image_processor
       SCREAMING_SNAKE_CASE_							=			prepare_img()
       SCREAMING_SNAKE_CASE_							=			image_processor(images=snake_case__				,				return_tensors='tf'						)

       # forward pass
       SCREAMING_SNAKE_CASE_							=			model(**snake_case__						)

       # verify the logits
       SCREAMING_SNAKE_CASE_							=			tf.TensorShape((1, 1_000)						)
       self.assertEqual(outputs.logits.shape				,				snake_case__						)

       SCREAMING_SNAKE_CASE_							=			tf.constant([-11.1069, -9.7877, -8.3777]						)

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

import torch

from diffusers import DDIMParallelScheduler

from .test_schedulers import SchedulerCommonTest






class   UpperCAmelCase		(						A_ ):
   A__					:		Dict						     =     (DDIMParallelScheduler,)
   A__					:		Tuple						     =     (("eta", 0.0), ("num_inference_steps", 50))



   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple    ,						**snake_case__		:					Optional[int] )		->	Optional[Any]:


          '''simple docstring'''


          snake_case       :   Any							=      {
              "num_train_timesteps": 10_00,
              "beta_start": 0.0001,
              "beta_end": 0.02,
              "beta_schedule": "linear",
              "clip_sample": True,
          }

          config.update(**snake_case__ )
          return config



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict    ,						**snake_case__		:					Optional[int] )		->	Any:


          '''simple docstring'''


          snake_case       :   List[Any]							=      self.scheduler_classes[0]
          snake_case       :   Any							=      self.get_scheduler_config(**snake_case__ )
          snake_case       :   Any							=      scheduler_class(**snake_case__ )

          snake_case				,					snake_case       :   Union[str, Any]							=      10, 0.0

          snake_case       :   List[Any]							=      self.dummy_model()
          snake_case       :   Any							=      self.dummy_sample_deter

          scheduler.set_timesteps(snake_case__ )

          for t in scheduler.timesteps:
                 snake_case       :   Optional[int]							=      model(snake_case__    ,						snake_case__ )
                 snake_case       :   List[str]							=      scheduler.step(snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__ ).prev_sample

          return sample



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


          '''simple docstring'''


          for timesteps in [1_00, 5_00, 10_00]:
                 self.check_over_configs(num_train_timesteps=snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	int:


          '''simple docstring'''


          for steps_offset in [0, 1]:
                 self.check_over_configs(steps_offset=snake_case__ )

          snake_case       :   Optional[int]							=      self.scheduler_classes[0]
          snake_case       :   Optional[int]							=      self.get_scheduler_config(steps_offset=1 )
          snake_case       :   Union[str, Any]							=      scheduler_class(**snake_case__ )
          scheduler.set_timesteps(5 )
          assert torch.equal(scheduler.timesteps    ,						torch.LongTensor([8_01, 6_01, 4_01, 2_01, 1] ) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Tuple:


          '''simple docstring'''


          for beta_start, beta_end in zip([0.0001, 0.001, 0.01, 0.1]    ,						[0.002, 0.02, 0.2, 2] ):
                 self.check_over_configs(beta_start=snake_case__    ,						beta_end=snake_case__ )



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


          '''simple docstring'''


          for schedule in ["linear", "squaredcos_cap_v2"]:
                 self.check_over_configs(beta_schedule=snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	Dict:


          '''simple docstring'''


          for prediction_type in ["epsilon", "v_prediction"]:
                 self.check_over_configs(prediction_type=snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	List[str]:


          '''simple docstring'''


          for clip_sample in [True, False]:
                 self.check_over_configs(clip_sample=snake_case__ )



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


          '''simple docstring'''


          for timestep_spacing in ["trailing", "leading"]:
                 self.check_over_configs(timestep_spacing=snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	List[Any]:


          '''simple docstring'''


          for rescale_betas_zero_snr in [True, False]:
                 self.check_over_configs(rescale_betas_zero_snr=snake_case__ )



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


          '''simple docstring'''


          self.check_over_configs(thresholding=snake_case__ )
          for threshold in [0.5, 1.0, 2.0]:
                 for prediction_type in ["epsilon", "v_prediction"]:
                        self.check_over_configs(
                            thresholding=snake_case__    ,						prediction_type=snake_case__    ,						sample_max_value=snake_case__    ,						)



   def 				_SCREAMING_SNAKE_CASE   (self		:					Any )		->	Any:


          '''simple docstring'''


          for t in [1, 10, 49]:
                 self.check_over_forward(time_step=snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Any:


          '''simple docstring'''


          for t, num_inference_steps in zip([1, 10, 50]    ,						[10, 50, 5_00] ):
                 self.check_over_forward(time_step=snake_case__    ,						num_inference_steps=snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str] )		->	Optional[Any]:


          '''simple docstring'''


          for t, eta in zip([1, 10, 49]    ,						[0.0, 0.5, 1.0] ):
                 self.check_over_forward(time_step=snake_case__    ,						eta=snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	Optional[int]:


          '''simple docstring'''


          snake_case       :   Dict							=      self.scheduler_classes[0]
          snake_case       :   Tuple							=      self.get_scheduler_config()
          snake_case       :   Dict							=      scheduler_class(**snake_case__ )

          assert torch.sum(torch.abs(scheduler._get_variance(0    ,						0 ) - 0.0 ) ) < 1e-5
          assert torch.sum(torch.abs(scheduler._get_variance(4_20    ,						4_00 ) - 0.14771 ) ) < 1e-5
          assert torch.sum(torch.abs(scheduler._get_variance(9_80    ,						9_60 ) - 0.32460 ) ) < 1e-5
          assert torch.sum(torch.abs(scheduler._get_variance(0    ,						0 ) - 0.0 ) ) < 1e-5
          assert torch.sum(torch.abs(scheduler._get_variance(4_87    ,						4_86 ) - 0.00979 ) ) < 1e-5
          assert torch.sum(torch.abs(scheduler._get_variance(9_99    ,						9_98 ) - 0.02 ) ) < 1e-5



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Dict:


          '''simple docstring'''


          snake_case       :   Union[str, Any]							=      self.scheduler_classes[0]
          snake_case       :   List[Any]							=      self.get_scheduler_config()
          snake_case       :   int							=      scheduler_class(**snake_case__ )

          snake_case				,					snake_case       :   Any							=      10, 0.0
          scheduler.set_timesteps(snake_case__ )

          snake_case       :   Optional[Any]							=      self.dummy_model()
          snake_case       :   str							=      self.dummy_sample_deter
          snake_case       :   Dict							=      self.dummy_sample_deter + 0.1
          snake_case       :   Dict							=      self.dummy_sample_deter - 0.1

          snake_case       :   Optional[Any]							=      samplea.shape[0]
          snake_case       :   str							=      torch.stack([samplea, samplea, samplea]    ,						dim=0 )
          snake_case       :   Tuple							=      torch.arange(snake_case__ )[0:3, None].repeat(1    ,						snake_case__ )

          snake_case       :   Tuple							=      model(samples.flatten(0    ,						1 )    ,						timesteps.flatten(0    ,						1 ) )
          snake_case       :   List[str]							=      scheduler.batch_step_no_noise(snake_case__    ,						timesteps.flatten(0    ,						1 )    ,						samples.flatten(0    ,						1 )    ,						snake_case__ )

          snake_case       :   Dict							=      torch.sum(torch.abs(snake_case__ ) )
          snake_case       :   List[Any]							=      torch.mean(torch.abs(snake_case__ ) )

          assert abs(result_sum.item() - 1147.7904 ) < 1e-2
          assert abs(result_mean.item() - 0.4982 ) < 1e-3



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


          '''simple docstring'''


          snake_case       :   List[Any]							=      self.full_loop()

          snake_case       :   Optional[Any]							=      torch.sum(torch.abs(snake_case__ ) )
          snake_case       :   List[Any]							=      torch.mean(torch.abs(snake_case__ ) )

          assert abs(result_sum.item() - 172.0067 ) < 1e-2
          assert abs(result_mean.item() - 0.223967 ) < 1e-3



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


          '''simple docstring'''


          snake_case       :   Dict							=      self.full_loop(prediction_type="v_prediction" )

          snake_case       :   int							=      torch.sum(torch.abs(snake_case__ ) )
          snake_case       :   Optional[int]							=      torch.mean(torch.abs(snake_case__ ) )

          assert abs(result_sum.item() - 52.5302 ) < 1e-2
          assert abs(result_mean.item() - 0.0684 ) < 1e-3



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


          '''simple docstring'''


          snake_case       :   Dict							=      self.full_loop(set_alpha_to_one=snake_case__    ,						beta_start=0.01 )
          snake_case       :   str							=      torch.sum(torch.abs(snake_case__ ) )
          snake_case       :   Optional[Any]							=      torch.mean(torch.abs(snake_case__ ) )

          assert abs(result_sum.item() - 149.8295 ) < 1e-2
          assert abs(result_mean.item() - 0.1951 ) < 1e-3



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Optional[Any]:


          '''simple docstring'''


          snake_case       :   int							=      self.full_loop(set_alpha_to_one=snake_case__    ,						beta_start=0.01 )
          snake_case       :   Tuple							=      torch.sum(torch.abs(snake_case__ ) )
          snake_case       :   List[Any]							=      torch.mean(torch.abs(snake_case__ ) )

          assert abs(result_sum.item() - 149.0784 ) < 1e-2
          assert abs(result_mean.item() - 0.1941 ) < 1e-3





