



import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.testing_utils import require_tensorflow_text, require_tf, slow


if is_tf_available():
    import tensorflow as tf

if is_tensorflow_text_available():
    from transformers.models.bert import TFBertTokenizer


__UpperCAmelCase			  =			['''bert-base-uncased''', '''bert-base-cased''']
__UpperCAmelCase			  =			'''hf-internal-testing/tiny-bert-tf-only'''

if is_tf_available():



    class 							lowerCAmelCase_						(    tf.keras.Model				):
           def __init__(     self,     SCREAMING_SNAKE_CASE_			)	->						List[str]:
              super().__init__()
              UpperCamelCase       :    Optional[int]		      =      tokenizer
              UpperCamelCase       :    List[str]		      =      AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE_			)
              UpperCamelCase       :    List[str]		      =      TFAutoModel.from_config(SCREAMING_SNAKE_CASE_			)






           def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_			)	->						List[Any]:
              UpperCamelCase       :    Optional[Any]		      =      self.tokenizer(SCREAMING_SNAKE_CASE_			)
              UpperCamelCase       :    Tuple		      =      self.bert(**SCREAMING_SNAKE_CASE_			)
              return out["pooler_output"]



@require_tf
@require_tensorflow_text
class 							lowerCAmelCase_						(    unittest.TestCase				):
       def    snake_case_			(     self			)	->						Dict:
          super().setUp()

          UpperCamelCase       :    Optional[Any]		      =      [
              BertTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_			) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
          ]  # repeat for when fast_bert_tokenizer=false
          UpperCamelCase       :    Optional[Any]		      =      [TFBertTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_			) for checkpoint in TOKENIZER_CHECKPOINTS] + [
              TFBertTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_,     use_fast_bert_tokenizer=SCREAMING_SNAKE_CASE_			)
              for checkpoint in TOKENIZER_CHECKPOINTS
          ]
          assert len(self.tokenizers			) == len(self.tf_tokenizers			)

          UpperCamelCase       :    str		      =      [
              'This is a straightforward English test sentence.',
              'This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.',
              'Now we\'re going to add some Chinese: 一 二 三 一二三',
              'And some much more rare Chinese: 齉 堃 齉堃',
              'Je vais aussi écrire en français pour tester les accents',
              'Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ',
          ]
          UpperCamelCase       :    Optional[int]		      =      list(zip(self.test_sentences,     self.test_sentences[::-1]			)			)
       def    snake_case_			(     self			)	->						Optional[Any]:
          for tokenizer, tf_tokenizer in zip(self.tokenizers,     self.tf_tokenizers			):
             for test_inputs in (self.test_sentences, self.paired_sentences):
                UpperCamelCase       :    Optional[Any]		      =      tokenizer(SCREAMING_SNAKE_CASE_,     return_tensors='tf',     padding='longest'			)
                UpperCamelCase       :    int		      =      tf_tokenizer(SCREAMING_SNAKE_CASE_			)

                for key in python_outputs.keys():
                   self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape			)			)
                   self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key],     tf.intaa			) == tf_outputs[key]			)			)
       @slow
       def    snake_case_			(     self			)	->						int:
          for tf_tokenizer in self.tf_tokenizers:
             UpperCamelCase       :    Tuple		      =      tf_tokenizer(self.paired_sentences			)
             UpperCamelCase       :    Union[str, Any]		      =      tf_tokenizer(
                 text=[sentence[0] for sentence in self.paired_sentences],     text_pair=[sentence[1] for sentence in self.paired_sentences],     )
             for key in merged_outputs.keys():
                self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key],     tf.intaa			) == separated_outputs[key]			)			)
       @slow
       def    snake_case_			(     self			)	->						Union[str, Any]:
          for tf_tokenizer in self.tf_tokenizers:
             UpperCamelCase       :    Optional[Any]		      =      tf.function(SCREAMING_SNAKE_CASE_			)
             for test_inputs in (self.test_sentences, self.paired_sentences):
                UpperCamelCase       :    Dict		      =      tf.constant(SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    Union[str, Any]		      =      compiled_tokenizer(SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    Union[str, Any]		      =      tf_tokenizer(SCREAMING_SNAKE_CASE_			)

                for key in eager_outputs.keys():
                   self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key]			)			)






       @slow
       def    snake_case_			(     self			)	->						Tuple:
          for tf_tokenizer in self.tf_tokenizers:
             UpperCamelCase       :    Any		      =      ModelToSave(tokenizer=SCREAMING_SNAKE_CASE_			)
             UpperCamelCase       :    Any		      =      tf.convert_to_tensor(self.test_sentences			)
             UpperCamelCase       :    Optional[Any]		      =      model(SCREAMING_SNAKE_CASE_			)  # Build model with some sample inputs
             with TemporaryDirectory() as tempdir:
                UpperCamelCase       :    Dict		      =      Path(SCREAMING_SNAKE_CASE_			) / 'saved.model'
                model.save(SCREAMING_SNAKE_CASE_			)
                UpperCamelCase       :    Optional[Any]		      =      tf.keras.models.load_model(SCREAMING_SNAKE_CASE_			)
             UpperCamelCase       :    Optional[int]		      =      loaded_model(SCREAMING_SNAKE_CASE_			)
             # We may see small differences because the loaded model is compiled, so we need an epsilon for the test
             self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output			)			),     1e-5			)






'''simple docstring'''

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


UpperCAmelCase					 =	logging.get_logger(__name__)

UpperCAmelCase					 =	{
    '''shi-labs/dinat-mini-in1k-224''': '''https://huggingface.co/shi-labs/dinat-mini-in1k-224/resolve/main/config.json''',
    # See all Dinat models at https://huggingface.co/models?filter=dinat
}


class 	lowerCAmelCase  (   A ,      A ):
       lowerCAmelCase_												=			"dinat"

       lowerCAmelCase_												=			{
           "num_attention_heads": "num_heads",
           "num_hidden_layers": "num_layers",
       }







       def __init__(				self      :			int    ,   __lowercase      :			str=4    ,   __lowercase      :			str=3    ,   __lowercase      :			int=64    ,   __lowercase      :			int=[3, 4, 6, 5]    ,   __lowercase      :			Union[str, Any]=[2, 4, 8, 16]    ,   __lowercase      :			Optional[int]=7    ,   __lowercase      :			str=[[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]]    ,   __lowercase      :			Any=3.0    ,   __lowercase      :			Optional[Any]=True    ,   __lowercase      :			List[Any]=0.0    ,   __lowercase      :			Optional[Any]=0.0    ,   __lowercase      :			int=0.1    ,   __lowercase      :			Union[str, Any]="gelu"    ,   __lowercase      :			Any=0.0_2    ,   __lowercase      :			int=1E-5    ,   __lowercase      :			Optional[int]=0.0    ,   __lowercase      :			Optional[int]=None    ,   __lowercase      :			str=None    ,   **__lowercase      :			Any    ,   ):







            """simple docstring"""







            super().__init__(**__lowercase   )

            __lowercase      		=patch_size
            __lowercase      		=num_channels
            __lowercase      		=embed_dim
            __lowercase      		=depths
            __lowercase      		=len(__lowercase   )
            __lowercase      		=num_heads
            __lowercase      		=kernel_size
            __lowercase      		=dilations
            __lowercase      		=mlp_ratio
            __lowercase      		=qkv_bias
            __lowercase      		=hidden_dropout_prob
            __lowercase      		=attention_probs_dropout_prob
            __lowercase      		=drop_path_rate
            __lowercase      		=hidden_act
            __lowercase      		=layer_norm_eps
            __lowercase      		=initializer_range
            # we set the hidden_size attribute in order to make Dinat work with VisionEncoderDecoderModel
            # this indicates the channel dimension after the last stage of the model
            __lowercase      		=int(embed_dim * 2 ** (len(__lowercase   ) - 1)   )
            __lowercase      		=layer_scale_init_value
            __lowercase      		=['stem'] + [f'''stage{idx}''' for idx in range(1    ,   len(__lowercase   ) + 1   )]
            __lowercase		,  __lowercase      		=get_aligned_output_features_output_indices(
                out_features=__lowercase    ,   out_indices=__lowercase    ,   stage_names=self.stage_names   )


