

'''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,						lowercase_,						lowercase_=3,						lowercase_=32,						lowercase_=3,						lowercase_=10,						lowercase_=[10, 20, 30, 40],						lowercase_=[1, 1, 2, 1],						lowercase_=True,						lowercase_=True,						lowercase_="relu",						lowercase_=3,						lowercase_=None,						lowercase_=["stage2", "stage3", "stage4"],						lowercase_=[2, 3, 4],						)    ->							Any:
					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(lowercase_ )
					snake_case							=					out_features
					snake_case							=					out_indices

				def 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					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 					_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,						out_features=self.out_features,						out_indices=self.out_indices,						)

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							Optional[Any]:
					snake_case							=					ResNetModel(config=lowercase_ )
					model.to(lowercase_ )
					model.eval()
					snake_case							=					model(lowercase_ )
					# 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,						lowercase_,						lowercase_,						lowercase_ )    ->							Dict:
					snake_case							=					self.num_labels
					snake_case							=					ResNetForImageClassification(lowercase_ )
					model.to(lowercase_ )
					model.eval()
					snake_case							=					model(lowercase_,						labels=lowercase_ )
					self.parent.assertEqual(result.logits.shape,						(self.batch_size, self.num_labels) )

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							List[Any]:
					snake_case							=					ResNetBackbone(config=lowercase_ )
					model.to(lowercase_ )
					model.eval()
					snake_case							=					model(lowercase_ )

					# 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=lowercase_ )
					model.to(lowercase_ )
					model.eval()
					snake_case							=					model(lowercase_ )

					# 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 					_lowerCamelCase    (       self )    ->							Optional[int]:
					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 lowerCamelCase   (    __lowerCAmelCase				,				__lowerCAmelCase				,				unittest.TestCase				):
				snake_case_							     = (
				    (
				        ResNetModel,
				        ResNetForImageClassification,
				        ResNetBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				snake_case_							     = (
				    {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
				    if is_torch_available()
				    else {}
				)

				snake_case_							     = True
				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False

				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					snake_case							=					ResNetModelTester(self )
					snake_case							=					ConfigTester(self,						config_class=lowercase_,						has_text_modality=lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Dict:
					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 )    ->							Union[str, Any]:
					return

				@unittest.skip(reason='ResNet does not use inputs_embeds' )
				def 					_lowerCamelCase    (       self )    ->							List[str]:
					pass

				@unittest.skip(reason='ResNet does not support input and output embeddings' )
				def 					_lowerCamelCase    (       self )    ->							str:
					pass

				def 					_lowerCamelCase    (       self )    ->							str:
					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(lowercase_ )
						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],						lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Tuple:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							int:
					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=lowercase_ )
						for name, module in model.named_modules():
							if isinstance(lowercase_,						(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 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					def check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ ):
						snake_case							=					model_class(lowercase_ )
						model.to(lowercase_ )
						model.eval()

						with torch.no_grad():
							snake_case							=					model(**self._prepare_for_class(lowercase_,						lowercase_ ) )

						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(lowercase_ ),						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(lowercase_,						lowercase_,						lowercase_ )

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

							check_hidden_states_output(lowercase_,						lowercase_,						lowercase_ )

				@unittest.skip(reason='ResNet does not use feedforward chunking' )
				def 					_lowerCamelCase    (       self )    ->							Any:
					pass

				def 					_lowerCamelCase    (       self )    ->							Dict:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*lowercase_ )






				@slow
				def 					_lowerCamelCase    (       self )    ->							List[str]:
					for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						snake_case							=					ResNetModel.from_pretrained(lowercase_ )
						self.assertIsNotNone(lowercase_ )

def      __magic_name__							(			)      ->		Dict:
	snake_case							=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
	return image







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

				@cached_property
				def 					_lowerCamelCase    (       self )    ->							Optional[Any]:
					return (
					    AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] )
					    if is_vision_available()
					    else None
					)






				@slow
				def 					_lowerCamelCase    (       self )    ->							int:
					snake_case							=					ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(lowercase_ )

					snake_case							=					self.default_image_processor
					snake_case							=					prepare_img()
					snake_case							=					image_processor(images=lowercase_,						return_tensors='pt' ).to(lowercase_ )

					# forward pass
					with torch.no_grad():
						snake_case							=					model(**lowercase_ )

					# verify the logits
					snake_case							=					torch.Size((1, 1000) )
					self.assertEqual(outputs.logits.shape,						lowercase_ )

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

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







@require_torch
class lowerCamelCase   (    __lowerCAmelCase				,				unittest.TestCase				):
				snake_case_							     = (ResNetBackbone,) if is_torch_available() else ()
				snake_case_							     = False
				snake_case_							     = ResNetConfig

				def 					_lowerCamelCase    (       self )    ->							Tuple:
					snake_case							=					ResNetModelTester(self )








'''simple docstring'''

from typing import List, Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase_     =      logging.get_logger(__name__)

lowerCAmelCase_     =      {
    "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/config.json",
    # See all LED models at https://huggingface.co/models?filter=led
}







class lowerCamelCase   (    __lowerCAmelCase				):
				snake_case_							     = '''led'''
				snake_case_							     = {
				    '''num_attention_heads''': '''encoder_attention_heads''',
				    '''hidden_size''': '''d_model''',
				    '''attention_probs_dropout_prob''': '''attention_dropout''',
				    '''initializer_range''': '''init_std''',
				}

				def __init__(       self,						lowercase_=50265,						lowercase_=16384,						lowercase_=1024,						lowercase_=12,						lowercase_=4096,						lowercase_=16,						lowercase_=12,						lowercase_=4096,						lowercase_=16,						lowercase_=0.0,						lowercase_=0.0,						lowercase_=True,						lowercase_=True,						lowercase_="gelu",						lowercase_=1024,						lowercase_=0.1,						lowercase_=0.0,						lowercase_=0.0,						lowercase_=0.02,						lowercase_=2,						lowercase_=0.0,						lowercase_=1,						lowercase_=0,						lowercase_=2,						lowercase_ = 512,						**lowercase_,						)    ->							Union[str, Any]:
					snake_case							=					vocab_size
					snake_case							=					max_encoder_position_embeddings
					snake_case							=					max_decoder_position_embeddings
					snake_case							=					d_model
					snake_case							=					encoder_ffn_dim
					snake_case							=					encoder_layers
					snake_case							=					encoder_attention_heads
					snake_case							=					decoder_ffn_dim
					snake_case							=					decoder_layers
					snake_case							=					decoder_attention_heads
					snake_case							=					dropout
					snake_case							=					attention_dropout
					snake_case							=					activation_dropout
					snake_case							=					activation_function
					snake_case							=					init_std
					snake_case							=					encoder_layerdrop
					snake_case							=					decoder_layerdrop
					snake_case							=					classifier_dropout
					snake_case							=					use_cache
					snake_case							=					encoder_layers
					snake_case							=					attention_window

					super().__init__(
					    pad_token_id=lowercase_,						bos_token_id=lowercase_,						eos_token_id=lowercase_,						is_encoder_decoder=lowercase_,						decoder_start_token_id=lowercase_,						**lowercase_,						)





