




import inspect
import unittest

from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
   import jax
   import jax.numpy as jnp

   from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel

if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor





class        lowerCamelCase_							(      unittest.TestCase					):


 '''simple docstring'''







 def __init__(							self  :		str				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		Tuple=3				,				_lowerCAmelCase  :		Optional[Any]=32				,				_lowerCAmelCase  :		Optional[int]=3				,				_lowerCAmelCase  :		Optional[Any]=10				,				_lowerCAmelCase  :		List[str]=[10, 20, 30, 40]				,				_lowerCAmelCase  :		Optional[int]=[1, 1, 2, 1]				,				_lowerCAmelCase  :		Optional[Any]=True				,				_lowerCAmelCase  :		Dict=True				,				_lowerCAmelCase  :		Optional[int]="relu"				,				_lowerCAmelCase  :		List[Any]=3				,				_lowerCAmelCase  :		Optional[Any]=None				,				):
       SCREAMING_SNAKE_CASE_							=			parent
       SCREAMING_SNAKE_CASE_							=			batch_size
       SCREAMING_SNAKE_CASE_							=			image_size
       SCREAMING_SNAKE_CASE_							=			num_channels
       SCREAMING_SNAKE_CASE_							=			embeddings_size
       SCREAMING_SNAKE_CASE_							=			hidden_sizes
       SCREAMING_SNAKE_CASE_							=			depths
       SCREAMING_SNAKE_CASE_							=			is_training
       SCREAMING_SNAKE_CASE_							=			use_labels
       SCREAMING_SNAKE_CASE_							=			hidden_act
       SCREAMING_SNAKE_CASE_							=			num_labels
       SCREAMING_SNAKE_CASE_							=			scope
       SCREAMING_SNAKE_CASE_							=			len(_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_							=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

       SCREAMING_SNAKE_CASE_							=			self.get_config()

       return config, pixel_values



 def       lowerCAmelCase_  (							self  :		List[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				,				image_size=self.image_size				,				)



 def       lowerCAmelCase_  (							self  :		int				,				_lowerCAmelCase  :		str				,				_lowerCAmelCase  :		List[str]						):
       SCREAMING_SNAKE_CASE_							=			FlaxRegNetModel(config=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			model(_lowerCAmelCase						)

       # Output shape (b, c, h, w)
       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  :		Optional[Any]				,				_lowerCAmelCase  :		Optional[int]				,				_lowerCAmelCase  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_							=			self.num_labels
       SCREAMING_SNAKE_CASE_							=			FlaxRegNetForImageClassification(config=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			model(_lowerCAmelCase						)
       self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_labels)						)




 def       lowerCAmelCase_  (							self  :		List[str]						):
       SCREAMING_SNAKE_CASE_							=			self.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			config_and_inputs
       SCREAMING_SNAKE_CASE_							=			{'pixel_values': pixel_values}
       return config, inputs_dict





@require_flax
class        lowerCamelCase_							(      _SCREAMING_SNAKE_CASE       ,   unittest.TestCase					):


 '''simple docstring'''







 lowercase_				    =    (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

 lowercase_				    =    False
 lowercase_				    =    False
 lowercase_				    =    False



 def       lowerCAmelCase_  (							self  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_							=			FlaxRegNetModelTester(self						)
       SCREAMING_SNAKE_CASE_							=			ConfigTester(self				,				config_class=_lowerCAmelCase				,				has_text_modality=_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		str						):
       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  :		Any						):
       return



 def       lowerCAmelCase_  (							self  :		Any						):
       SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		str						):
       SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase						)



 @unittest.skip(reason='RegNet does not use inputs_embeds'						)
 def       lowerCAmelCase_  (							self  :		List[str]						):
       pass



 @unittest.skip(reason='RegNet does not support input and output embeddings'						)
 def       lowerCAmelCase_  (							self  :		Optional[int]						):
       pass



 def       lowerCAmelCase_  (							self  :		Tuple						):
       SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs_for_common()

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

             SCREAMING_SNAKE_CASE_							=			['pixel_values']
             self.assertListEqual(arg_names[:1]				,				_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		Tuple						):
       def check_hidden_states_output(_lowerCAmelCase  :		Union[str, Any]				,				_lowerCAmelCase  :		Any				,				_lowerCAmelCase  :		int						):
             SCREAMING_SNAKE_CASE_							=			model_class(_lowerCAmelCase						)

             SCREAMING_SNAKE_CASE_							=			model(**self._prepare_for_class(_lowerCAmelCase				,				_lowerCAmelCase						)						)

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

             SCREAMING_SNAKE_CASE_							=			self.model_tester.num_stages
             self.assertEqual(len(_lowerCAmelCase						)				,				expected_num_stages + 1						)

       SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             SCREAMING_SNAKE_CASE_							=			True
             check_hidden_states_output(_lowerCAmelCase				,				_lowerCAmelCase				,				_lowerCAmelCase						)

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

             check_hidden_states_output(_lowerCAmelCase				,				_lowerCAmelCase				,				_lowerCAmelCase						)




 def       lowerCAmelCase_  (							self  :		Dict						):
       SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             with self.subTest(model_class.__name__						):
                   SCREAMING_SNAKE_CASE_							=			self._prepare_for_class(_lowerCAmelCase				,				_lowerCAmelCase						)
                   SCREAMING_SNAKE_CASE_							=			model_class(_lowerCAmelCase						)

                   @jax.jit
                   def model_jitted(_lowerCAmelCase  :		Optional[Any]				,				**_lowerCAmelCase  :		Tuple						):
                         return model(pixel_values=_lowerCAmelCase				,				**_lowerCAmelCase						)

                   with self.subTest('JIT Enabled'						):
                         SCREAMING_SNAKE_CASE_							=			model_jitted(**_lowerCAmelCase						).to_tuple()

                   with self.subTest('JIT Disabled'						):
                         with jax.disable_jit():
                               SCREAMING_SNAKE_CASE_							=			model_jitted(**_lowerCAmelCase						).to_tuple()

                   self.assertEqual(len(_lowerCAmelCase						)				,				len(_lowerCAmelCase						)						)
                   for jitted_output, output in zip(_lowerCAmelCase				,				_lowerCAmelCase						):
                         self.assertEqual(jitted_output.shape				,				output.shape						)


def 					UpperCAmelCase_							(      )					-> str:
      SCREAMING_SNAKE_CASE_							=			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
      return image





@require_flax
class        lowerCamelCase_							(      unittest.TestCase					):


 '''simple docstring'''







 @cached_property
 def       lowerCAmelCase_  (							self  :		int						):
       return AutoImageProcessor.from_pretrained('facebook/regnet-y-040'						) if is_vision_available() else None




 @slow
 def       lowerCAmelCase_  (							self  :		Union[str, Any]						):
       SCREAMING_SNAKE_CASE_							=			FlaxRegNetForImageClassification.from_pretrained('facebook/regnet-y-040'						)

       SCREAMING_SNAKE_CASE_							=			self.default_image_processor
       SCREAMING_SNAKE_CASE_							=			prepare_img()
       SCREAMING_SNAKE_CASE_							=			image_processor(images=_lowerCAmelCase				,				return_tensors='np'						)

       SCREAMING_SNAKE_CASE_							=			model(**_lowerCAmelCase						)

       # verify the logits
       SCREAMING_SNAKE_CASE_							=			(1, 1_000)
       self.assertEqual(outputs.logits.shape				,				_lowerCAmelCase						)

       SCREAMING_SNAKE_CASE_							=			jnp.array([-0.4180, -1.5051, -3.4836]						)

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





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


lowerCamelCase__ :   Union[str, Any]					=							{
    'configuration_layoutlmv2': ['LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LayoutLMv2Config'],
    'processing_layoutlmv2': ['LayoutLMv2Processor'],
    'tokenization_layoutlmv2': ['LayoutLMv2Tokenizer'],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__ :   Any					=							['LayoutLMv2TokenizerFast']

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__ :   Dict					=							['LayoutLMv2FeatureExtractor']
   lowerCamelCase__ :   Dict					=							['LayoutLMv2ImageProcessor']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__ :   Union[str, Any]					=							[
       'LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST',
       'LayoutLMv2ForQuestionAnswering',
       'LayoutLMv2ForSequenceClassification',
       'LayoutLMv2ForTokenClassification',
       'LayoutLMv2Layer',
       'LayoutLMv2Model',
       'LayoutLMv2PreTrainedModel',
   ]

if TYPE_CHECKING:
   from .configuration_layoutlmva import LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMvaConfig
   from .processing_layoutlmva import LayoutLMvaProcessor
   from .tokenization_layoutlmva import LayoutLMvaTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor, LayoutLMvaImageProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_layoutlmva import (
          LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST,
          LayoutLMvaForQuestionAnswering,
          LayoutLMvaForSequenceClassification,
          LayoutLMvaForTokenClassification,
          LayoutLMvaLayer,
          LayoutLMvaModel,
          LayoutLMvaPreTrainedModel,
      )
else:
   import sys

   lowerCamelCase__ :   Any					=							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)