


"""simple docstring"""





import inspect
import unittest

from transformers import ResNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch
  from torch import nn

  from transformers import ResNetBackbone, ResNetForImageClassification, ResNetModel
  from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor


class       __lowerCamelCase	:







   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       ,	lowerCamelCase=["stage2", "stage3", "stage4"]       ,	lowerCamelCase=[2, 3, 4]       ,	):




      '''simple docstring'''




      _lowerCAmelCase					     =		parent
      _lowerCAmelCase					     =		batch_size
      _lowerCAmelCase					     =		image_size
      _lowerCAmelCase					     =		num_channels
      _lowerCAmelCase					     =		embeddings_size
      _lowerCAmelCase					     =		hidden_sizes
      _lowerCAmelCase					     =		depths
      _lowerCAmelCase					     =		is_training
      _lowerCAmelCase					     =		use_labels
      _lowerCAmelCase					     =		hidden_act
      _lowerCAmelCase					     =		num_labels
      _lowerCAmelCase					     =		scope
      _lowerCAmelCase					     =		len(lowerCamelCase				)
      _lowerCAmelCase					     =		out_features
      _lowerCAmelCase					     =		out_indices







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

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

      _lowerCAmelCase					     =		self.get_config()

      return config, pixel_values, labels







   def 							A__						(self				):




      '''simple docstring'''




      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       ,	out_features=self.out_features       ,	out_indices=self.out_indices       ,	)







   def 							A__						(self       ,	lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				):




      '''simple docstring'''




      _lowerCAmelCase					     =		ResNetModel(config=lowerCamelCase				)
      model.to(lowerCamelCase				)
      model.eval()
      _lowerCAmelCase					     =		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 							A__						(self       ,	lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.num_labels
      _lowerCAmelCase					     =		ResNetForImageClassification(lowerCamelCase				)
      model.to(lowerCamelCase				)
      model.eval()
      _lowerCAmelCase					     =		model(lowerCamelCase       ,	labels=lowerCamelCase				)
      self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.num_labels)				)







   def 							A__						(self       ,	lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				):




      '''simple docstring'''




      _lowerCAmelCase					     =		ResNetBackbone(config=lowerCamelCase				)
      model.to(lowerCamelCase				)
      model.eval()
      _lowerCAmelCase					     =		model(lowerCamelCase				)

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps				)       ,	len(config.out_features				)				)
      self.parent.assertListEqual(list(result.feature_maps[0].shape				)       ,	[self.batch_size, self.hidden_sizes[1], 4, 4]				)

      # verify channels
      self.parent.assertEqual(len(model.channels				)       ,	len(config.out_features				)				)
      self.parent.assertListEqual(model.channels       ,	config.hidden_sizes[1:]				)

      # verify backbone works with out_features=None
      _lowerCAmelCase					     =		None
      _lowerCAmelCase					     =		ResNetBackbone(config=lowerCamelCase				)
      model.to(lowerCamelCase				)
      model.eval()
      _lowerCAmelCase					     =		model(lowerCamelCase				)

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps				)       ,	1				)
      self.parent.assertListEqual(list(result.feature_maps[0].shape				)       ,	[self.batch_size, self.hidden_sizes[-1], 1, 1]				)

      # verify channels
      self.parent.assertEqual(len(model.channels				)       ,	1				)
      self.parent.assertListEqual(model.channels       ,	[config.hidden_sizes[-1]]				)







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.prepare_config_and_inputs()
      _lowerCAmelCase     ,						_lowerCAmelCase     ,						_lowerCAmelCase					     =		config_and_inputs
      _lowerCAmelCase					     =		{"""pixel_values""": pixel_values}
      return config, inputs_dict





@require_torch
class       __lowerCamelCase	(   __lowercase   ,							__lowercase   ,							unittest.TestCase    ):
   __UpperCamelCase									=   (
       (
           ResNetModel,
           ResNetForImageClassification,
           ResNetBackbone,
       )
       if is_torch_available()
       else ()
   )
   __UpperCamelCase									=   (
       {'feature-extraction': ResNetModel, 'image-classification': ResNetForImageClassification}
       if is_torch_available()
       else {}
   )

   __UpperCamelCase									=   True
   __UpperCamelCase									=   False
   __UpperCamelCase									=   False
   __UpperCamelCase									=   False
   __UpperCamelCase									=   False







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		ResNetModelTester(self				)
      _lowerCAmelCase					     =		ConfigTester(self       ,	config_class=lowerCamelCase       ,	has_text_modality=lowerCamelCase				)







   def 							A__						(self				):




      '''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 							A__						(self				):




      '''simple docstring'''




      return







   @unittest.skip(reason="""ResNet does not use inputs_embeds"""				)
   def 							A__						(self				):




      '''simple docstring'''




      pass







   @unittest.skip(reason="""ResNet does not support input and output embeddings"""				)
   def 							A__						(self				):




      '''simple docstring'''




      pass







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase     ,						_lowerCAmelCase					     =		self.model_tester.prepare_config_and_inputs_for_common()

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

         _lowerCAmelCase					     =		["""pixel_values"""]
         self.assertListEqual(arg_names[:1]       ,	lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase     ,						_lowerCAmelCase					     =		self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _lowerCAmelCase					     =		model_class(config=lowerCamelCase				)
         for name, module in model.named_modules():
            if isinstance(lowerCamelCase       ,	(nn.BatchNormad, nn.GroupNorm)				):
               self.assertTrue(
                   torch.all(module.weight == 1				)       ,	msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""       ,	)
               self.assertTrue(
                   torch.all(module.bias == 0				)       ,	msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""       ,	)







   def 							A__						(self				):




      '''simple docstring'''




      def check_hidden_states_output(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				):
         _lowerCAmelCase					     =		model_class(lowerCamelCase				)
         model.to(lowerCamelCase				)
         model.eval()

         with torch.no_grad():
            _lowerCAmelCase					     =		model(**self._prepare_for_class(lowerCamelCase       ,	lowerCamelCase				)				)

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

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

      _lowerCAmelCase     ,						_lowerCAmelCase					     =		self.model_tester.prepare_config_and_inputs_for_common()
      _lowerCAmelCase					     =		["""basic""", """bottleneck"""]
      for model_class in self.all_model_classes:
         for layer_type in layers_type:
            _lowerCAmelCase					     =		layer_type
            _lowerCAmelCase					     =		True
            check_hidden_states_output(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				)

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

            check_hidden_states_output(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				)







   @unittest.skip(reason="""ResNet does not use feedforward chunking"""				)
   def 							A__						(self				):




      '''simple docstring'''




      pass







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCamelCase				)







   @slow
   def 							A__						(self				):




      '''simple docstring'''




      for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowerCAmelCase					     =		ResNetModel.from_pretrained(lowerCamelCase				)
         self.assertIsNotNone(lowerCamelCase				)






def 	__UpperCAmelCase					(       )							->	Optional[int]:






   """simple docstring"""


   _lowerCAmelCase					     =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
   return image


@require_torch
@require_vision
class       __lowerCamelCase	(   unittest.TestCase    ):







   @cached_property
   def 							A__						(self				):




      '''simple docstring'''




      return (
          AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]				)
          if is_vision_available()
          else None
      )







   @slow
   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]				).to(lowerCamelCase				)

      _lowerCAmelCase					     =		self.default_image_processor
      _lowerCAmelCase					     =		prepare_img()
      _lowerCAmelCase					     =		image_processor(images=lowerCamelCase       ,	return_tensors="""pt"""				).to(lowerCamelCase				)

      # forward pass
      with torch.no_grad():
         _lowerCAmelCase					     =		model(**lowerCamelCase				)

      # verify the logits
      _lowerCAmelCase					     =		torch.Size((1, 1_000)				)
      self.assertEqual(outputs.logits.shape       ,	lowerCamelCase				)

      _lowerCAmelCase					     =		torch.tensor([-11.1069, -9.7877, -8.3777]				).to(lowerCamelCase				)

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





@require_torch
class       __lowerCamelCase	(   __lowercase   ,							unittest.TestCase    ):
   __UpperCamelCase									=   (ResNetBackbone,) if is_torch_available() else ()
   __UpperCamelCase									=   False
   __UpperCamelCase									=   ResNetConfig







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		ResNetModelTester(self				)




"""simple docstring"""





import torch

from diffusers import HeunDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest


class       __lowerCamelCase	(   __lowercase    ):
   __UpperCamelCase									=   (HeunDiscreteScheduler,)
   __UpperCamelCase									=   10







   def 							A__						(self       ,	**lowerCamelCase				):




      '''simple docstring'''




      _lowerCAmelCase					     =		{
          """num_train_timesteps""": 1_100,
          """beta_start""": 0.0001,
          """beta_end""": 0.02,
          """beta_schedule""": """linear""",
      }

      config.update(**lowerCamelCase				)
      return config







   def 							A__						(self				):




      '''simple docstring'''




      for timesteps in [10, 50, 100, 1_000]:
         self.check_over_configs(num_train_timesteps=lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      for beta_start, beta_end in zip([0.0_0001, 0.0001, 0.001]       ,	[0.0002, 0.002, 0.02]				):
         self.check_over_configs(beta_start=lowerCamelCase       ,	beta_end=lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      for schedule in ["linear", "scaled_linear", "exp"]:
         self.check_over_configs(beta_schedule=lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      for clip_sample_range in [1.0, 2.0, 3.0]:
         self.check_over_configs(clip_sample_range=lowerCamelCase       ,	clip_sample=lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




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







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.scheduler_classes[0]
      _lowerCAmelCase					     =		self.get_scheduler_config()
      _lowerCAmelCase					     =		scheduler_class(**lowerCamelCase				)

      scheduler.set_timesteps(self.num_inference_steps				)

      _lowerCAmelCase					     =		self.dummy_model()
      _lowerCAmelCase					     =		self.dummy_sample_deter * scheduler.init_noise_sigma
      _lowerCAmelCase					     =		sample.to(lowerCamelCase				)

      for i, t in enumerate(scheduler.timesteps				):
         _lowerCAmelCase					     =		scheduler.scale_model_input(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		model(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		scheduler.step(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				)
         _lowerCAmelCase					     =		output.prev_sample

      _lowerCAmelCase					     =		torch.sum(torch.abs(lowerCamelCase				)				)
      _lowerCAmelCase					     =		torch.mean(torch.abs(lowerCamelCase				)				)

      if torch_device in ["cpu", "mps"]:
         assert abs(result_sum.item() - 0.1233				) < 1e-2
         assert abs(result_mean.item() - 0.0002				) < 1e-3
      else:
         # CUDA
         assert abs(result_sum.item() - 0.1233				) < 1e-2
         assert abs(result_mean.item() - 0.0002				) < 1e-3







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.scheduler_classes[0]
      _lowerCAmelCase					     =		self.get_scheduler_config(prediction_type="""v_prediction"""				)
      _lowerCAmelCase					     =		scheduler_class(**lowerCamelCase				)

      scheduler.set_timesteps(self.num_inference_steps				)

      _lowerCAmelCase					     =		self.dummy_model()
      _lowerCAmelCase					     =		self.dummy_sample_deter * scheduler.init_noise_sigma
      _lowerCAmelCase					     =		sample.to(lowerCamelCase				)

      for i, t in enumerate(scheduler.timesteps				):
         _lowerCAmelCase					     =		scheduler.scale_model_input(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		model(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		scheduler.step(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				)
         _lowerCAmelCase					     =		output.prev_sample

      _lowerCAmelCase					     =		torch.sum(torch.abs(lowerCamelCase				)				)
      _lowerCAmelCase					     =		torch.mean(torch.abs(lowerCamelCase				)				)

      if torch_device in ["cpu", "mps"]:
         assert abs(result_sum.item() - 4.6934e-07				) < 1e-2
         assert abs(result_mean.item() - 6.1112e-10				) < 1e-3
      else:
         # CUDA
         assert abs(result_sum.item() - 4.693428650170972e-07				) < 1e-2
         assert abs(result_mean.item() - 0.0002				) < 1e-3







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.scheduler_classes[0]
      _lowerCAmelCase					     =		self.get_scheduler_config()
      _lowerCAmelCase					     =		scheduler_class(**lowerCamelCase				)

      scheduler.set_timesteps(self.num_inference_steps       ,	device=lowerCamelCase				)

      _lowerCAmelCase					     =		self.dummy_model()
      _lowerCAmelCase					     =		self.dummy_sample_deter.to(lowerCamelCase				) * scheduler.init_noise_sigma

      for t in scheduler.timesteps:
         _lowerCAmelCase					     =		scheduler.scale_model_input(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		model(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		scheduler.step(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				)
         _lowerCAmelCase					     =		output.prev_sample

      _lowerCAmelCase					     =		torch.sum(torch.abs(lowerCamelCase				)				)
      _lowerCAmelCase					     =		torch.mean(torch.abs(lowerCamelCase				)				)

      if str(lowerCamelCase				).startswith("""cpu"""				):
         # The following sum varies between 148 and 156 on mps. Why?
         assert abs(result_sum.item() - 0.1233				) < 1e-2
         assert abs(result_mean.item() - 0.0002				) < 1e-3
      elif str(lowerCamelCase				).startswith("""mps"""				):
         # Larger tolerance on mps
         assert abs(result_mean.item() - 0.0002				) < 1e-2
      else:
         # CUDA
         assert abs(result_sum.item() - 0.1233				) < 1e-2
         assert abs(result_mean.item() - 0.0002				) < 1e-3







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.scheduler_classes[0]
      _lowerCAmelCase					     =		self.get_scheduler_config()
      _lowerCAmelCase					     =		scheduler_class(**lowerCamelCase       ,	use_karras_sigmas=lowerCamelCase				)

      scheduler.set_timesteps(self.num_inference_steps       ,	device=lowerCamelCase				)

      _lowerCAmelCase					     =		self.dummy_model()
      _lowerCAmelCase					     =		self.dummy_sample_deter.to(lowerCamelCase				) * scheduler.init_noise_sigma
      _lowerCAmelCase					     =		sample.to(lowerCamelCase				)

      for t in scheduler.timesteps:
         _lowerCAmelCase					     =		scheduler.scale_model_input(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		model(lowerCamelCase       ,	lowerCamelCase				)

         _lowerCAmelCase					     =		scheduler.step(lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				)
         _lowerCAmelCase					     =		output.prev_sample

      _lowerCAmelCase					     =		torch.sum(torch.abs(lowerCamelCase				)				)
      _lowerCAmelCase					     =		torch.mean(torch.abs(lowerCamelCase				)				)

      assert abs(result_sum.item() - 0.0_0015				) < 1e-2
      assert abs(result_mean.item() - 1.9869554535034695e-07				) < 1e-2