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






		"""simple docstring"""







		def __init__(			self    :				Optional[int]  ,					__SCREAMING_SNAKE_CASE    :				Tuple  ,					__SCREAMING_SNAKE_CASE    :				Union[str, Any]=3  ,					__SCREAMING_SNAKE_CASE    :				Optional[Any]=32  ,					__SCREAMING_SNAKE_CASE    :				Dict=3  ,					__SCREAMING_SNAKE_CASE    :				List[Any]=10  ,					__SCREAMING_SNAKE_CASE    :				Optional[int]=[10, 20, 30, 40]  ,					__SCREAMING_SNAKE_CASE    :				Any=[1, 1, 2, 1]  ,					__SCREAMING_SNAKE_CASE    :				List[str]=True  ,					__SCREAMING_SNAKE_CASE    :				str=True  ,					__SCREAMING_SNAKE_CASE    :				Union[str, Any]="relu"  ,					__SCREAMING_SNAKE_CASE    :				str=3  ,					__SCREAMING_SNAKE_CASE    :				Optional[int]=None  ,					__SCREAMING_SNAKE_CASE    :				Optional[int]=["stage2", "stage3", "stage4"]  ,					__SCREAMING_SNAKE_CASE    :				str=[2, 3, 4]  ,					):






					"""simple docstring"""
					_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(__SCREAMING_SNAKE_CASE   )
					_snake_case              =      out_features
					_snake_case              =      out_indices



		def 				_a				(			self    :				Optional[Any]   ):






					"""simple docstring"""
					_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 				_a				(			self    :				Dict   ):






					"""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    :				Any  ,					__SCREAMING_SNAKE_CASE    :				Optional[Any]  ,					__SCREAMING_SNAKE_CASE    :				str  ,					__SCREAMING_SNAKE_CASE    :				Optional[Any]   ):






					"""simple docstring"""
					_snake_case              =      ResNetModel(config=__SCREAMING_SNAKE_CASE   )
					model.to(__SCREAMING_SNAKE_CASE   )
					model.eval()
					_snake_case              =      model(__SCREAMING_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 				_a				(			self    :				Dict  ,					__SCREAMING_SNAKE_CASE    :				Any  ,					__SCREAMING_SNAKE_CASE    :				Optional[Any]  ,					__SCREAMING_SNAKE_CASE    :				List[str]   ):






					"""simple docstring"""
					_snake_case              =      self.num_labels
					_snake_case              =      ResNetForImageClassification(__SCREAMING_SNAKE_CASE   )
					model.to(__SCREAMING_SNAKE_CASE   )
					model.eval()
					_snake_case              =      model(__SCREAMING_SNAKE_CASE  ,					labels=__SCREAMING_SNAKE_CASE   )
					self.parent.assertEqual(result.logits.shape  ,					(self.batch_size, self.num_labels)   )



		def 				_a				(			self    :				int  ,					__SCREAMING_SNAKE_CASE    :				int  ,					__SCREAMING_SNAKE_CASE    :				Union[str, Any]  ,					__SCREAMING_SNAKE_CASE    :				Optional[Any]   ):






					"""simple docstring"""
					_snake_case              =      ResNetBackbone(config=__SCREAMING_SNAKE_CASE   )
					model.to(__SCREAMING_SNAKE_CASE   )
					model.eval()
					_snake_case              =      model(__SCREAMING_SNAKE_CASE   )

					# 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
					_snake_case              =      None
					_snake_case              =      ResNetBackbone(config=__SCREAMING_SNAKE_CASE   )
					model.to(__SCREAMING_SNAKE_CASE   )
					model.eval()
					_snake_case              =      model(__SCREAMING_SNAKE_CASE   )

					# 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    :				str   ):






					"""simple docstring"""
					_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_torch
class 	_SCREAMING_SNAKE_CASE							(     _lowercase      ,     _lowercase      ,     unittest.TestCase							):






		"""simple docstring"""







		A_						 =      (
		    (
		        ResNetModel,
		        ResNetForImageClassification,
		        ResNetBackbone,
		    )
		    if is_torch_available()
		    else ()
		)
		A_						 =      (
		    {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
		    if is_torch_available()
		    else {}
		)

		A_						 =      True
		A_						 =      False
		A_						 =      False
		A_						 =      False
		A_						 =      False



		def 				_a				(			self    :				Optional[int]   ):






					"""simple docstring"""
					_snake_case              =      ResNetModelTester(self   )
					_snake_case              =      ConfigTester(self  ,					config_class=__SCREAMING_SNAKE_CASE  ,					has_text_modality=__SCREAMING_SNAKE_CASE   )



		def 				_a				(			self    :				Optional[int]   ):






					"""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    :				Optional[Any]   ):






					"""simple docstring"""
					return



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






					"""simple docstring"""
					pass



		@unittest.skip(reason="ResNet does not support input and output embeddings"   )
		def 				_a				(			self    :				Union[str, Any]   ):






					"""simple docstring"""
					pass



		def 				_a				(			self    :				Union[str, Any]   ):






					"""simple docstring"""
					_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(__SCREAMING_SNAKE_CASE   )
								_snake_case              =      inspect.signature(model.forward   )
								# 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]  ,					__SCREAMING_SNAKE_CASE   )



		def 				_a				(			self    :				List[Any]   ):






					"""simple docstring"""
					_snake_case              =      self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE   )



		def 				_a				(			self    :				Tuple   ):






					"""simple docstring"""
					_snake_case              =      self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE   )



		def 				_a				(			self    :				str   ):






					"""simple docstring"""
					_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(config=__SCREAMING_SNAKE_CASE   )
								for name, module in model.named_modules():
											if isinstance(__SCREAMING_SNAKE_CASE  ,					(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    :				List[str]   ):






					"""simple docstring"""
					def check_hidden_states_output(__SCREAMING_SNAKE_CASE    :				Tuple  ,					__SCREAMING_SNAKE_CASE    :				Optional[int]  ,					__SCREAMING_SNAKE_CASE    :				Tuple   ):
								_snake_case              =      model_class(__SCREAMING_SNAKE_CASE   )
								model.to(__SCREAMING_SNAKE_CASE   )
								model.eval()

								with torch.no_grad():
											_snake_case              =      model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE   )   )

								_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(__SCREAMING_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]  ,					)

					_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(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE   )

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

											check_hidden_states_output(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE   )



		@unittest.skip(reason="ResNet does not use feedforward chunking"   )
		def 				_a				(			self    :				List[Any]   ):






					"""simple docstring"""
					pass



		def 				_a				(			self    :				Dict   ):






					"""simple docstring"""
					_snake_case              =      self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE   )







		@slow
		def 				_a				(			self    :				str   ):






					"""simple docstring"""
					for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								_snake_case              =      ResNetModel.from_pretrained(__SCREAMING_SNAKE_CASE   )
								self.assertIsNotNone(__SCREAMING_SNAKE_CASE   )






def    UpperCAmelCase__(						):



			"""simple docstring"""





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

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






		"""simple docstring"""







		@cached_property
		def 				_a				(			self    :				Optional[Any]   ):






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







		@slow
		def 				_a				(			self    :				str   ):






					"""simple docstring"""
					_snake_case              =      ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   ).to(__SCREAMING_SNAKE_CASE   )

					_snake_case              =      self.default_image_processor
					_snake_case              =      prepare_img()
					_snake_case              =      image_processor(images=__SCREAMING_SNAKE_CASE  ,					return_tensors="pt"   ).to(__SCREAMING_SNAKE_CASE   )

					# forward pass
					with torch.no_grad():
								_snake_case              =      model(**__SCREAMING_SNAKE_CASE   )

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

					_snake_case              =      torch.tensor([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]   ).to(__SCREAMING_SNAKE_CASE   )

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

@require_torch
class 	_SCREAMING_SNAKE_CASE							(     _lowercase      ,     unittest.TestCase							):






		"""simple docstring"""







		A_						 =      (ResNetBackbone,) if is_torch_available() else ()
		A_						 =      False
		A_						 =      ResNetConfig



		def 				_a				(			self    :				Optional[Any]   ):






					"""simple docstring"""
					_snake_case              =      ResNetModelTester(self   )


import unittest

from transformers import BlenderbotTokenizer, BlenderbotTokenizerFast
from transformers.utils import cached_property

class 	_SCREAMING_SNAKE_CASE							(     unittest.TestCase							):






		"""simple docstring"""







		@cached_property
		def 				_a				(			self    :				Tuple   ):






					"""simple docstring"""
					return BlenderbotTokenizer.from_pretrained("facebook/blenderbot-3B"   )



		@cached_property
		def 				_a				(			self    :				Tuple   ):






					"""simple docstring"""
					return BlenderbotTokenizerFast.from_pretrained("facebook/blenderbot-3B"   )



		def 				_a				(			self    :				Optional[Any]   ):






					"""simple docstring"""
					_snake_case              =      self.tokenizer_ab
					_snake_case              =      " I am a small frog."
					_snake_case              =      tok([src_text]  ,					padding=__SCREAMING_SNAKE_CASE  ,					truncation=__SCREAMING_SNAKE_CASE   )["input_ids"]
					_snake_case              =      tok.batch_decode(__SCREAMING_SNAKE_CASE  ,					skip_special_tokens=__SCREAMING_SNAKE_CASE  ,					clean_up_tokenization_spaces=__SCREAMING_SNAKE_CASE   )[0]
					assert src_text == decoded



		def 				_a				(			self    :				str   ):






					"""simple docstring"""
					_snake_case              =      self.rust_tokenizer_ab
					_snake_case              =      " I am a small frog."
					_snake_case              =      tok([src_text]  ,					padding=__SCREAMING_SNAKE_CASE  ,					truncation=__SCREAMING_SNAKE_CASE   )["input_ids"]
					_snake_case              =      tok.batch_decode(__SCREAMING_SNAKE_CASE  ,					skip_special_tokens=__SCREAMING_SNAKE_CASE  ,					clean_up_tokenization_spaces=__SCREAMING_SNAKE_CASE   )[0]
					assert src_text == decoded



		def 				_a				(			self    :				Optional[Any]   ):






					"""simple docstring"""
					assert self.tokenizer_ab.add_prefix_space
					assert self.tokenizer_ab([" Sam", "Sam"]   ).input_ids == [[5_502, 2], [5_502, 2]]







		def 				_a				(			self    :				str   ):






					"""simple docstring"""
					assert self.rust_tokenizer_ab.add_prefix_space
					assert self.rust_tokenizer_ab([" Sam", "Sam"]   ).input_ids == [[5_502, 2], [5_502, 2]]

