

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







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

      '''simple docstring'''





      __magic_name__							=    parent
      __magic_name__							=    batch_size
      __magic_name__							=    image_size
      __magic_name__							=    num_channels
      __magic_name__							=    embeddings_size
      __magic_name__							=    hidden_sizes
      __magic_name__							=    depths
      __magic_name__							=    is_training
      __magic_name__							=    use_labels
      __magic_name__							=    hidden_act
      __magic_name__							=    num_labels
      __magic_name__							=    scope
      __magic_name__							=    len(__UpperCamelCase      )







 def 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]      ):

      '''simple docstring'''





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

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

      __magic_name__							=    self.get_config()

      return config, pixel_values, labels







 def 	_SCREAMING_SNAKE_CASE							(   self: Union[str, 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 	_SCREAMING_SNAKE_CASE							(   self: Any  , __UpperCamelCase: int  , __UpperCamelCase: Union[str, Any]  , __UpperCamelCase: Tuple      ):

      '''simple docstring'''





      __magic_name__							=    TFResNetModel(config=__UpperCamelCase      )
      __magic_name__							=    model(__UpperCamelCase      )
      # 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: List[str]  , __UpperCamelCase: Optional[int]  , __UpperCamelCase: Tuple  , __UpperCamelCase: str      ):

      '''simple docstring'''





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







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

      '''simple docstring'''





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




@require_tf
class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
 _lowercase  :   List[Any]       				=  (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
 _lowercase  :   Tuple       				=  (
     {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
     if is_tf_available()
     else {}
 )

 _lowercase  :   Optional[Any]       				=  False
 _lowercase  :   Union[str, Any]       				=  False
 _lowercase  :   Dict       				=  False
 _lowercase  :   Union[str, Any]       				=  False
 _lowercase  :   Optional[Any]       				=  False







 def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

      '''simple docstring'''





      __magic_name__							=    TFResNetModelTester(self      )
      __magic_name__							=    ConfigTester(self  , config_class=__UpperCamelCase  , has_text_modality=__UpperCamelCase      )







 def 	_SCREAMING_SNAKE_CASE							(   self: List[str]      ):

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

      '''simple docstring'''





      return







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

      '''simple docstring'''





      pass







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

      '''simple docstring'''





      pass







 def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]      ):

      '''simple docstring'''





      __magic_name__,	__magic_name__							=    self.model_tester.prepare_config_and_inputs_for_common()

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

           __magic_name__							=    ['pixel_values']
           self.assertListEqual(arg_names[:1]  , __UpperCamelCase      )







 def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

      '''simple docstring'''





      __magic_name__							=    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__UpperCamelCase      )







 def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

      '''simple docstring'''





      def check_hidden_states_output(__UpperCamelCase: Any  , __UpperCamelCase: List[Any]  , __UpperCamelCase: Optional[int]      ):
           __magic_name__							=    model_class(__UpperCamelCase      )
           __magic_name__							=    model(**self._prepare_for_class(__UpperCamelCase  , __UpperCamelCase      )      )

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

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

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

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

                check_hidden_states_output(__UpperCamelCase  , __UpperCamelCase  , __UpperCamelCase      )







 def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

      '''simple docstring'''





      __magic_name__							=    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase      )







 @slow
 def 	_SCREAMING_SNAKE_CASE							(   self: int      ):

      '''simple docstring'''





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




def 					_lowercase     (				)				->	Optional[int]:




     '''simple docstring'''







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


@require_tf
@require_vision
class 				__UpperCamelCase				(					unittest.TestCase			):







 @cached_property
 def 	_SCREAMING_SNAKE_CASE							(   self: List[str]      ):

      '''simple docstring'''





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







 @slow
 def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

      '''simple docstring'''





      __magic_name__							=    TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )

      __magic_name__							=    self.default_image_processor
      __magic_name__							=    prepare_img()
      __magic_name__							=    image_processor(images=__UpperCamelCase  , return_tensors='tf'      )

      # forward pass
      __magic_name__							=    model(**__UpperCamelCase      )

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

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

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







from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional

from packaging import version

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


if TYPE_CHECKING:
						from ...processing_utils import ProcessorMixin
						from ...utils import TensorType


A__						=							logging.get_logger(__name__)

A__						=							{
    "microsoft/layoutlmv3-base": "https://huggingface.co/microsoft/layoutlmv3-base/resolve/main/config.json",
}

class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE			):
	_lowercase  :   Optional[Any]       				=  "layoutlmv3"







	def __init__(   self: Tuple  , __UpperCamelCase: List[Any]=5_02_65  , __UpperCamelCase: Union[str, Any]=7_68  , __UpperCamelCase: Optional[int]=12  , __UpperCamelCase: List[str]=12  , __UpperCamelCase: List[Any]=30_72  , __UpperCamelCase: Union[str, Any]="gelu"  , __UpperCamelCase: Union[str, Any]=0.1  , __UpperCamelCase: Union[str, Any]=0.1  , __UpperCamelCase: List[Any]=5_12  , __UpperCamelCase: int=2  , __UpperCamelCase: Union[str, Any]=0.02  , __UpperCamelCase: Dict=1E-5  , __UpperCamelCase: int=1  , __UpperCamelCase: Dict=0  , __UpperCamelCase: Tuple=2  , __UpperCamelCase: Any=10_24  , __UpperCamelCase: Union[str, Any]=1_28  , __UpperCamelCase: Dict=1_28  , __UpperCamelCase: Any=True  , __UpperCamelCase: Any=32  , __UpperCamelCase: int=1_28  , __UpperCamelCase: List[str]=64  , __UpperCamelCase: Union[str, Any]=2_56  , __UpperCamelCase: int=True  , __UpperCamelCase: Optional[int]=True  , __UpperCamelCase: Union[str, Any]=True  , __UpperCamelCase: Union[str, Any]=2_24  , __UpperCamelCase: Tuple=3  , __UpperCamelCase: Any=16  , __UpperCamelCase: List[Any]=None  , **__UpperCamelCase: str  , ):

						'''simple docstring'''





						super().__init__(
						    vocab_size=__UpperCamelCase  , hidden_size=__UpperCamelCase  , num_hidden_layers=__UpperCamelCase  , num_attention_heads=__UpperCamelCase  , intermediate_size=__UpperCamelCase  , hidden_act=__UpperCamelCase  , hidden_dropout_prob=__UpperCamelCase  , attention_probs_dropout_prob=__UpperCamelCase  , max_position_embeddings=__UpperCamelCase  , type_vocab_size=__UpperCamelCase  , initializer_range=__UpperCamelCase  , layer_norm_eps=__UpperCamelCase  , pad_token_id=__UpperCamelCase  , bos_token_id=__UpperCamelCase  , eos_token_id=__UpperCamelCase  , **__UpperCamelCase  , )
						__magic_name__							=    max_ad_position_embeddings
						__magic_name__							=    coordinate_size
						__magic_name__							=    shape_size
						__magic_name__							=    has_relative_attention_bias
						__magic_name__							=    rel_pos_bins
						__magic_name__							=    max_rel_pos
						__magic_name__							=    has_spatial_attention_bias
						__magic_name__							=    rel_ad_pos_bins
						__magic_name__							=    max_rel_ad_pos
						__magic_name__							=    text_embed
						__magic_name__							=    visual_embed
						__magic_name__							=    input_size
						__magic_name__							=    num_channels
						__magic_name__							=    patch_size
						__magic_name__							=    classifier_dropout




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE			):
	_lowercase  :   Any       				=  version.parse("1.12"			)







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

						'''simple docstring'''





						if self.task in ["question-answering", "sequence-classification"]:
											return OrderedDict(
											    [
											        ('input_ids', {0: 'batch', 1: 'sequence'}),
											        ('attention_mask', {0: 'batch', 1: 'sequence'}),
											        ('bbox', {0: 'batch', 1: 'sequence'}),
											        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
											    ]      )
						else:
											return OrderedDict(
											    [
											        ('input_ids', {0: 'batch', 1: 'sequence'}),
											        ('bbox', {0: 'batch', 1: 'sequence'}),
											        ('attention_mask', {0: 'batch', 1: 'sequence'}),
											        ('pixel_values', {0: 'batch', 1: 'num_channels'}),
											    ]      )







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: int      ):

						'''simple docstring'''





						return 1E-5







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

						'''simple docstring'''





						return 12







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple  , __UpperCamelCase: "ProcessorMixin"  , __UpperCamelCase: int = -1  , __UpperCamelCase: int = -1  , __UpperCamelCase: bool = False  , __UpperCamelCase: Optional["TensorType"] = None  , __UpperCamelCase: int = 3  , __UpperCamelCase: int = 40  , __UpperCamelCase: int = 40  , ):

						'''simple docstring'''





						setattr(processor.image_processor  , 'apply_ocr'  , __UpperCamelCase      )

						# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
						__magic_name__							=    compute_effective_axis_dimension(
						    __UpperCamelCase  , fixed_dimension=OnnxConfig.default_fixed_batch  , num_token_to_add=0      )
						# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
						__magic_name__							=    processor.tokenizer.num_special_tokens_to_add(__UpperCamelCase      )
						__magic_name__							=    compute_effective_axis_dimension(
						    __UpperCamelCase  , fixed_dimension=OnnxConfig.default_fixed_sequence  , num_token_to_add=__UpperCamelCase      )
						# Generate dummy inputs according to compute batch and sequence
						__magic_name__							=    [[' '.join([processor.tokenizer.unk_token]      ) * seq_length]] * batch_size

						# Generate dummy bounding boxes
						__magic_name__							=    [[[48, 84, 73, 1_28]]] * batch_size

						# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
						# batch_size = compute_effective_axis_dimension(batch_size, fixed_dimension=OnnxConfig.default_fixed_batch)
						__magic_name__							=    self._generate_dummy_images(__UpperCamelCase  , __UpperCamelCase  , __UpperCamelCase  , __UpperCamelCase      )

						__magic_name__							=    dict(
						    processor(
						        __UpperCamelCase  , text=__UpperCamelCase  , boxes=__UpperCamelCase  , return_tensors=__UpperCamelCase  , )      )

						return inputs




