


import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 RegNetForImageClassification, RegNetModel
				from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor






class    _UpperCamelCase     :

				"""simple docstring"""







				def __init__(    self					, a__					, a__=3					, a__=32					, a__=3					, a__=10					, a__=[10, 20, 30, 40]					, a__=[1, 1, 2, 1]					, a__=True					, a__=True					, a__="relu"					, a__=3					, a__=None					, )						->					int:
					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(a__ )

				def   _UpperCAmelCase       (    self )						->					Dict:
					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   _UpperCAmelCase       (    self )						->					Optional[Any]:
					return RegNetConfig(
					    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					, )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__ )						->					List[str]:
					A             =					RegNetModel(config=a__ )
					model.to(a__ )
					model.eval()
					A             =					model(a__ )
					# 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   _UpperCAmelCase       (    self					, a__					, a__					, a__ )						->					Union[str, Any]:
					A             =					self.num_labels
					A             =					RegNetForImageClassification(a__ )
					model.to(a__ )
					model.eval()
					A             =					model(a__					, labels=a__ )
					self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.num_labels) )

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					A             =					self.prepare_config_and_inputs()
					A       ,      A       ,      A             =					config_and_inputs
					A             =					{"""pixel_values""": pixel_values}
					return config, inputs_dict






@require_torch
class    _UpperCamelCase     (       __snake_case     ,		__snake_case     ,		unittest.TestCase					):

				"""simple docstring"""







				lowerCAmelCase					=			(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
				lowerCAmelCase					=			(
				    {'feature-extraction': RegNetModel, 'image-classification': RegNetForImageClassification}
				    if is_torch_available()
				    else {}
				)

				lowerCAmelCase					=			False
				lowerCAmelCase					=			False
				lowerCAmelCase					=			False
				lowerCAmelCase					=			False

				def   _UpperCAmelCase       (    self )						->					List[Any]:
					A             =					RegNetModelTester(self )
					A             =					ConfigTester(self					, config_class=a__					, has_text_modality=a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[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   _UpperCAmelCase       (    self )						->					str:
					return

				@unittest.skip(reason="""RegNet does not use inputs_embeds""" )
				def   _UpperCAmelCase       (    self )						->					Any:
					pass

				@unittest.skip(reason="""RegNet does not support input and output embeddings""" )
				def   _UpperCAmelCase       (    self )						->					str:
					pass

				def   _UpperCAmelCase       (    self )						->					Any:
					A       ,      A             =					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						A             =					model_class(a__ )
						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]					, a__ )

				def   _UpperCAmelCase       (    self )						->					List[Any]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					A       ,      A             =					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						A             =					model_class(config=a__ )
						for name, module in model.named_modules():
							if isinstance(a__					, (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   _UpperCAmelCase       (    self )						->					Any:
					def check_hidden_states_output(a__					, a__					, a__ ):
						A             =					model_class(a__ )
						model.to(a__ )
						model.eval()

						with torch.no_grad():
							A             =					model(**self._prepare_for_class(a__					, a__ ) )

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

						A             =					self.model_tester.num_stages
						self.assertEqual(len(a__ )					, expected_num_stages + 1 )

						# RegNet'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 // 2, self.model_tester.image_size // 2]					, )

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

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

							check_hidden_states_output(a__					, a__					, a__ )

				def   _UpperCAmelCase       (    self )						->					int:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*a__ )

				@slow
				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						A             =					RegNetModel.from_pretrained(a__ )
						self.assertIsNotNone(a__ )





def 	_lowerCAmelCase					( )			-> Optional[Any]:





	"""simple docstring"""







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






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

				"""simple docstring"""







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

				@slow
				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					A             =					RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(a__ )

					A             =					self.default_image_processor
					A             =					prepare_img()
					A             =					image_processor(images=a__					, return_tensors="""pt""" ).to(a__ )

					# forward pass
					with torch.no_grad():
						A             =					model(**a__ )

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

					A             =					torch.tensor([-0.41_80, -1.50_51, -3.48_36] ).to(a__ )

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







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


_lowercase							:   List[Any]						=						logging.get_logger(__name__)

_lowercase							:   List[str]						=						{
    "speechbrain/m-ctc-t-large": "https://huggingface.co/speechbrain/m-ctc-t-large/resolve/main/config.json",
    # See all M-CTC-T models at https://huggingface.co/models?filter=mctct
}






class    _UpperCamelCase     (       __snake_case					):

				"""simple docstring"""







				lowerCAmelCase					=			'mctct'

				def __init__(    self					, a__=8065					, a__=1536					, a__=36					, a__=6144					, a__=4					, a__=384					, a__=920					, a__=1e-5					, a__=0.3					, a__="relu"					, a__=0.02					, a__=0.3					, a__=0.3					, a__=1					, a__=0					, a__=2					, a__=1					, a__=0.3					, a__=1					, a__=(7,)					, a__=(3,)					, a__=80					, a__=1					, a__=None					, a__="sum"					, a__=False					, **a__					, )						->					Optional[Any]:
					super().__init__(**a__					, pad_token_id=a__					, bos_token_id=a__					, eos_token_id=a__ )
					A             =					vocab_size
					A             =					hidden_size
					A             =					num_hidden_layers
					A             =					intermediate_size
					A             =					num_attention_heads
					A             =					attention_head_dim
					A             =					max_position_embeddings
					A             =					layer_norm_eps
					A             =					layerdrop
					A             =					hidden_act
					A             =					initializer_range
					A             =					hidden_dropout_prob
					A             =					attention_probs_dropout_prob
					A             =					pad_token_id
					A             =					bos_token_id
					A             =					eos_token_id
					A             =					conv_glu_dim
					A             =					conv_dropout
					A             =					num_conv_layers
					A             =					input_feat_per_channel
					A             =					input_channels
					A             =					conv_channels
					A             =					ctc_loss_reduction
					A             =					ctc_zero_infinity

					# prevents config testing fail with exporting to json
					A             =					list(a__ )
					A             =					list(a__ )

					if len(self.conv_kernel ) != self.num_conv_layers:
						raise ValueError(
						    """Configuration for convolutional module is incorrect. """
						    """It is required that `len(config.conv_kernel)` == `config.num_conv_layers` """
						    f'but is `len(config.conv_kernel) = {len(self.conv_kernel )}`, '
						    f'`config.num_conv_layers = {self.num_conv_layers}`.' )



