






def   SCREAMING_SNAKE_CASE__						(   snake_case_  )   ->  list:


	"""simple docstring"""



	a		=			len(snake_case_  )

	# Set the gap value to be decreased by a factor of 1.3
	# after each iteration
	a		=			1.3

	# Continue sorting until the gap is 1
	while gap > 1:
		# Decrease the gap value
		a		=			int(gap / shrink  )

		# Sort the elements using insertion sort
		for i in range(snake_case_,  len(snake_case_  )  ):
			a		=			collection[i]
			a		=			i
			while j >= gap and collection[j - gap] > temp:
				a		=			collection[j - gap]
				j -= gap
			a		=			temp

	return collection


if __name__ == "__main__":
				import doctest

				doctest.testmod()













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		:					str							,__lowerCamelCase		:					Dict							,__lowerCamelCase		:					List[Any]=3							,__lowerCamelCase		:					Tuple=32							,__lowerCamelCase		:					List[str]=3							,__lowerCamelCase		:					Optional[Any]=10							,__lowerCamelCase		:					str=[10, 20, 30, 40]							,__lowerCamelCase		:					int=[1, 1, 2, 1]							,__lowerCamelCase		:					Any=True							,__lowerCamelCase		:					List[str]=True							,__lowerCamelCase		:					Union[str, Any]="relu"							,__lowerCamelCase		:					Optional[int]=3							,__lowerCamelCase		:					int=None							,__lowerCamelCase		:					List[Any]=["stage2", "stage3", "stage4"]							,__lowerCamelCase		:					int=[2, 3, 4]							,):





								'''simple docstring'''



								a		=			parent
								a		=			batch_size
								a		=			image_size
								a		=			num_channels
								a		=			embeddings_size
								a		=			hidden_sizes
								a		=			depths
								a		=			is_training
								a		=			use_labels
								a		=			hidden_act
								a		=			num_labels
								a		=			scope
								a		=			len(__lowerCamelCase					)
								a		=			out_features
								a		=			out_indices
							def  SCREAMING_SNAKE_CASE_ (						self		:					Tuple					):





								'''simple docstring'''



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

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

								a		=			self.get_config()

								return config, pixel_values, labels
							def  SCREAMING_SNAKE_CASE_ (						self		:					Any					):





								'''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  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]							,__lowerCamelCase		:					Optional[int]							,__lowerCamelCase		:					Dict							,__lowerCamelCase		:					Optional[int]					):





								'''simple docstring'''



								a		=			ResNetModel(config=__lowerCamelCase					)
								model.to(__lowerCamelCase					)
								model.eval()
								a		=			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  SCREAMING_SNAKE_CASE_ (						self		:					Any							,__lowerCamelCase		:					Optional[Any]							,__lowerCamelCase		:					Any							,__lowerCamelCase		:					List[str]					):





								'''simple docstring'''



								a		=			self.num_labels
								a		=			ResNetForImageClassification(__lowerCamelCase					)
								model.to(__lowerCamelCase					)
								model.eval()
								a		=			model(__lowerCamelCase							,labels=__lowerCamelCase					)
								self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.num_labels)					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					Dict							,__lowerCamelCase		:					Optional[Any]							,__lowerCamelCase		:					int							,__lowerCamelCase		:					List[str]					):





								'''simple docstring'''



								a		=			ResNetBackbone(config=__lowerCamelCase					)
								model.to(__lowerCamelCase					)
								model.eval()
								a		=			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
								a		=			None
								a		=			ResNetBackbone(config=__lowerCamelCase					)
								model.to(__lowerCamelCase					)
								model.eval()
								a		=			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  SCREAMING_SNAKE_CASE_ (						self		:					str					):





								'''simple docstring'''



								a		=			self.prepare_config_and_inputs()
								a	, a	, a		=			config_and_inputs
								a		=			{'''pixel_values''': pixel_values}
								return config, inputs_dict







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

							SCREAMING_SNAKE_CASE_						     =			True
							SCREAMING_SNAKE_CASE_						     =			False
							SCREAMING_SNAKE_CASE_						     =			False
							SCREAMING_SNAKE_CASE_						     =			False
							SCREAMING_SNAKE_CASE_						     =			False
							def  SCREAMING_SNAKE_CASE_ (						self		:					Optional[int]					):





								'''simple docstring'''



								a		=			ResNetModelTester(self					)
								a		=			ConfigTester(self							,config_class=__lowerCamelCase							,has_text_modality=__lowerCamelCase					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]					):





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





								'''simple docstring'''



								return
							@unittest.skip(reason='''ResNet does not use inputs_embeds'''					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					Optional[int]					):





								'''simple docstring'''



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





								'''simple docstring'''



								pass
							def  SCREAMING_SNAKE_CASE_ (						self		:					Dict					):





								'''simple docstring'''



								a	, a		=			self.model_tester.prepare_config_and_inputs_for_common()

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

									a		=			['''pixel_values''']
									self.assertListEqual(arg_names[:1]							,__lowerCamelCase					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					List[str]					):





								'''simple docstring'''



								a		=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__lowerCamelCase					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					Tuple					):





								'''simple docstring'''



								a		=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_backbone(*__lowerCamelCase					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]					):





								'''simple docstring'''



								a	, a		=			self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
									a		=			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  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]					):





								'''simple docstring'''



								def check_hidden_states_output(__lowerCamelCase		:					List[str]							,__lowerCamelCase		:					str							,__lowerCamelCase		:					Any					):
									a		=			model_class(__lowerCamelCase					)
									model.to(__lowerCamelCase					)
									model.eval()

									with torch.no_grad():
										a		=			model(**self._prepare_for_class(__lowerCamelCase							,__lowerCamelCase					)					)

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

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

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

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

										check_hidden_states_output(__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase					)
							@unittest.skip(reason='''ResNet does not use feedforward chunking'''					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					int					):





								'''simple docstring'''



								pass
							def  SCREAMING_SNAKE_CASE_ (						self		:					int					):





								'''simple docstring'''



								a		=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase					)




							@slow
							def  SCREAMING_SNAKE_CASE_ (						self		:					int					):





								'''simple docstring'''



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





def   SCREAMING_SNAKE_CASE__						(   )   ->  Optional[int]:


	"""simple docstring"""



	a		=			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''  )
	return image







@require_torch
@require_vision
class 				lowerCamelCase_     (	unittest.TestCase     ):
							@cached_property
							def  SCREAMING_SNAKE_CASE_ (						self		:					List[str]					):





								'''simple docstring'''



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




							@slow
							def  SCREAMING_SNAKE_CASE_ (						self		:					Dict					):





								'''simple docstring'''



								a		=			ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					).to(__lowerCamelCase					)

								a		=			self.default_image_processor
								a		=			prepare_img()
								a		=			image_processor(images=__lowerCamelCase							,return_tensors='''pt'''					).to(__lowerCamelCase					)

								# forward pass
								with torch.no_grad():
									a		=			model(**__lowerCamelCase					)

								# verify the logits
								a		=			torch.Size((1, 10_00)					)
								self.assertEqual(outputs.logits.shape							,__lowerCamelCase					)

								a		=			torch.tensor([-11.1_069, -9.7_877, -8.3_777]					).to(__lowerCamelCase					)

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







@require_torch
class 				lowerCamelCase_     (	a_ ,						unittest.TestCase     ):
							SCREAMING_SNAKE_CASE_						     =			(ResNetBackbone,) if is_torch_available() else ()
							SCREAMING_SNAKE_CASE_						     =			False
							SCREAMING_SNAKE_CASE_						     =			ResNetConfig
							def  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]					):





								'''simple docstring'''



								a		=			ResNetModelTester(self					)





