



from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import TFResNetForImageClassification, TFResNetModel
							from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor


class      __lowerCAmelCase     :
					"""simple docstring"""






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






								"""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(_snake_case					)



					def     _a							(     self					:       List[str]					):






								"""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     _a							(     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				,					image_size=self.image_size				,					)



					def     _a							(     self					:       Any				,					_snake_case					:       List[str]				,					_snake_case					:       List[str]				,					_snake_case					:       List[str]					):






								"""simple docstring"""


								A__       =    TFResNetModel(config=_snake_case					)
								A__       =    model(_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					:       Any				,					_snake_case					:       Optional[int]				,					_snake_case					:       Tuple				,					_snake_case					:       List[Any]					):






								"""simple docstring"""


								A__       =    self.num_labels
								A__       =    TFResNetForImageClassification(_snake_case					)
								A__       =    model(_snake_case				,					labels=_snake_case					)
								self.parent.assertEqual(result.logits.shape				,					(self.batch_size, self.num_labels)					)



					def     _a							(     self					:       Dict					):






								"""simple docstring"""


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







@require_tf
class      __lowerCAmelCase     (		UpperCAmelCase_							,     UpperCAmelCase_							,     unittest.TestCase      ):
					"""simple docstring"""






					A__				:		Dict			       =    (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
					A__				:		List[str]			       =    (
					    {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
					    if is_tf_available()
					    else {}
					)

					A__				:		Any			       =    False
					A__				:		Dict			       =    False
					A__				:		Optional[Any]			       =    False
					A__				:		str			       =    False
					A__				:		str			       =    False



					def     _a							(     self					:       Optional[int]					):






								"""simple docstring"""


								A__       =    TFResNetModelTester(self					)
								A__       =    ConfigTester(self				,					config_class=_snake_case				,					has_text_modality=_snake_case					)



					def     _a							(     self					:       Dict					):






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






								"""simple docstring"""


								return



					@unittest.skip(reason='ResNet does not use inputs_embeds'					)
					def     _a							(     self					:       Union[str, Any]					):






								"""simple docstring"""


								pass



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






								"""simple docstring"""


								pass



					def     _a							(     self					:       str					):






								"""simple docstring"""


								A__     , A__       =    self.model_tester.prepare_config_and_inputs_for_common()

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

											A__       =    ['pixel_values']
											self.assertListEqual(arg_names[:1]				,					_snake_case					)



					def     _a							(     self					:       Dict					):






								"""simple docstring"""


								A__       =    self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case					)



					def     _a							(     self					:       str					):






								"""simple docstring"""


								def check_hidden_states_output(_snake_case					:       Tuple				,					_snake_case					:       int				,					_snake_case					:       Optional[Any]					):
											A__       =    model_class(_snake_case					)
											A__       =    model(**self._prepare_for_class(_snake_case				,					_snake_case					)					)

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

											A__       =    self.model_tester.num_stages
											self.assertEqual(len(_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]				,					)

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

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

														check_hidden_states_output(_snake_case				,					_snake_case				,					_snake_case					)



					def     _a							(     self					:       List[str]					):






								"""simple docstring"""


								A__       =    self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_snake_case					)



					@slow
					def     _a							(     self					:       int					):






								"""simple docstring"""


								for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A__       =    TFResNetModel.from_pretrained(_snake_case					)
											self.assertIsNotNone(_snake_case					)







def A						(       )						->      Optional[int]:
			A__       =    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
			return image






@require_tf
@require_vision
class      __lowerCAmelCase     (		unittest.TestCase      ):
					"""simple docstring"""






					@cached_property
					def     _a							(     self					:       Dict					):






								"""simple docstring"""


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



					@slow
					def     _a							(     self					:       int					):






								"""simple docstring"""


								A__       =    TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)

								A__       =    self.default_image_processor
								A__       =    prepare_img()
								A__       =    image_processor(images=_snake_case				,					return_tensors='tf'					)

								# forward pass
								A__       =    model(**_snake_case					)

								# verify the logits
								A__       =    tf.TensorShape((1, 10_00)					)
								self.assertEqual(outputs.logits.shape				,					_snake_case					)

								A__       =    tf.constant([-11.1069, -9.7877, -8.3777]					)

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









from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__       =      logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__       =      {
    '''roberta-base''': '''https://huggingface.co/roberta-base/resolve/main/config.json''',
    '''roberta-large''': '''https://huggingface.co/roberta-large/resolve/main/config.json''',
    '''roberta-large-mnli''': '''https://huggingface.co/roberta-large-mnli/resolve/main/config.json''',
    '''distilroberta-base''': '''https://huggingface.co/distilroberta-base/resolve/main/config.json''',
    '''roberta-base-openai-detector''': '''https://huggingface.co/roberta-base-openai-detector/resolve/main/config.json''',
    '''roberta-large-openai-detector''': '''https://huggingface.co/roberta-large-openai-detector/resolve/main/config.json''',
}


class      __lowerCAmelCase     (		UpperCAmelCase_      ):
					"""simple docstring"""






					A__				:		List[str]			       =    "roberta"



					def __init__(     self					:       List[str]				,					_snake_case					:       Union[str, Any]=5_02_65				,					_snake_case					:       List[Any]=7_68				,					_snake_case					:       List[str]=12				,					_snake_case					:       List[str]=12				,					_snake_case					:       Any=30_72				,					_snake_case					:       Union[str, Any]="gelu"				,					_snake_case					:       int=0.1				,					_snake_case					:       Union[str, Any]=0.1				,					_snake_case					:       Tuple=5_12				,					_snake_case					:       Union[str, Any]=2				,					_snake_case					:       Any=0.02				,					_snake_case					:       Any=1E-12				,					_snake_case					:       List[Any]=1				,					_snake_case					:       int=0				,					_snake_case					:       Any=2				,					_snake_case					:       Optional[Any]="absolute"				,					_snake_case					:       int=True				,					_snake_case					:       Any=None				,					**_snake_case					:       Any				,					):






								"""simple docstring"""


								super().__init__(pad_token_id=_snake_case				,					bos_token_id=_snake_case				,					eos_token_id=_snake_case				,					**_snake_case					)

								A__       =    vocab_size
								A__       =    hidden_size
								A__       =    num_hidden_layers
								A__       =    num_attention_heads
								A__       =    hidden_act
								A__       =    intermediate_size
								A__       =    hidden_dropout_prob
								A__       =    attention_probs_dropout_prob
								A__       =    max_position_embeddings
								A__       =    type_vocab_size
								A__       =    initializer_range
								A__       =    layer_norm_eps
								A__       =    position_embedding_type
								A__       =    use_cache
								A__       =    classifier_dropout







class      __lowerCAmelCase     (		UpperCAmelCase_      ):
					"""simple docstring"""






					@property
					def     _a							(     self					:       Dict					):






								"""simple docstring"""


								if self.task == "multiple-choice":
											A__       =    {0: 'batch', 1: 'choice', 2: 'sequence'}
								else:
											A__       =    {0: 'batch', 1: 'sequence'}
								return OrderedDict(
								    [
								        ('input_ids', dynamic_axis),
								        ('attention_mask', dynamic_axis),
								    ]					)




