




'''simple docstring'''



from __future__ import annotations

import copy
import tempfile
import unittest

from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available
from transformers.testing_utils import (
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tensorflow_probability,
    require_tf,
    slow,
)

from ..bert.test_modeling_bert import BertModelTester


if is_tf_available():
      from transformers import (
          TFAutoModel,
          TFAutoModelForCausalLM,
          TFAutoModelForMaskedLM,
          TFAutoModelForPreTraining,
          TFAutoModelForQuestionAnswering,
          TFAutoModelForSeqaSeqLM,
          TFAutoModelForSequenceClassification,
          TFAutoModelForTableQuestionAnswering,
          TFAutoModelForTokenClassification,
          TFAutoModelWithLMHead,
          TFBertForMaskedLM,
          TFBertForPreTraining,
          TFBertForQuestionAnswering,
          TFBertForSequenceClassification,
          TFBertModel,
          TFFunnelBaseModel,
          TFFunnelModel,
          TFGPTaLMHeadModel,
          TFRobertaForMaskedLM,
          TFTaForConditionalGeneration,
          TFTapasForQuestionAnswering,
      )
      from transformers.models.auto.modeling_tf_auto import (
          TF_MODEL_FOR_CAUSAL_LM_MAPPING,
          TF_MODEL_FOR_MASKED_LM_MAPPING,
          TF_MODEL_FOR_PRETRAINING_MAPPING,
          TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
          TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
          TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
          TF_MODEL_MAPPING,
      )
      from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
      from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
      from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST
      from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST






class 				_a							(       SCREAMING_SNAKE_CASE__      ):





       '''simple docstring'''






       A		:							Dict								=		'''new-model'''


if is_tf_available():






      class 				_a							(       SCREAMING_SNAKE_CASE__      ):





             '''simple docstring'''






             A		:							List[str]								=		NewModelConfig






@require_tf
class 				_a							(       unittest.TestCase      ):





       '''simple docstring'''






       @slow
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Optional[int]   =		'bert-base-cased'
             SCREAMING_SNAKE_CASE					:	Optional[Any]   =		AutoConfig.from_pretrained(A   )
             self.assertIsNotNone(A   )
             self.assertIsInstance(A,				A   )

             SCREAMING_SNAKE_CASE					:	Tuple   =		TFAutoModel.from_pretrained(A   )
             self.assertIsNotNone(A   )
             self.assertIsInstance(A,				A   )







       @slow
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Optional[Any]   =		'bert-base-cased'
             SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		AutoConfig.from_pretrained(A   )
             self.assertIsNotNone(A   )
             self.assertIsInstance(A,				A   )

             SCREAMING_SNAKE_CASE					:	List[Any]   =		TFAutoModelForPreTraining.from_pretrained(A   )
             self.assertIsNotNone(A   )
             self.assertIsInstance(A,				A   )







       @slow
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   SCREAMING_SNAKE_CASE					:	List[str]   =		AutoConfig.from_pretrained(A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )

                   SCREAMING_SNAKE_CASE					:	int   =		TFAutoModelForCausalLM.from_pretrained(A   )
                   SCREAMING_SNAKE_CASE ,  SCREAMING_SNAKE_CASE					:	int   =		TFAutoModelForCausalLM.from_pretrained(A,				output_loading_info=A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )







       @slow
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   SCREAMING_SNAKE_CASE					:	Optional[int]   =		AutoConfig.from_pretrained(A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )

                   SCREAMING_SNAKE_CASE					:	int   =		TFAutoModelWithLMHead.from_pretrained(A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )







       @slow
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   SCREAMING_SNAKE_CASE					:	Optional[Any]   =		AutoConfig.from_pretrained(A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )

                   SCREAMING_SNAKE_CASE					:	Tuple   =		TFAutoModelForMaskedLM.from_pretrained(A   )
                   SCREAMING_SNAKE_CASE ,  SCREAMING_SNAKE_CASE					:	str   =		TFAutoModelForMaskedLM.from_pretrained(A,				output_loading_info=A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )







       @slow
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   SCREAMING_SNAKE_CASE					:	str   =		AutoConfig.from_pretrained(A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )

                   SCREAMING_SNAKE_CASE					:	Tuple   =		TFAutoModelForSeqaSeqLM.from_pretrained(A   )
                   SCREAMING_SNAKE_CASE ,  SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		TFAutoModelForSeqaSeqLM.from_pretrained(A,				output_loading_info=A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )







       @slow
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             for model_name in ["bert-base-uncased"]:
                   SCREAMING_SNAKE_CASE					:	int   =		AutoConfig.from_pretrained(A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )

                   SCREAMING_SNAKE_CASE					:	int   =		TFAutoModelForSequenceClassification.from_pretrained(A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )







       @slow
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             for model_name in ["bert-base-uncased"]:
                   SCREAMING_SNAKE_CASE					:	List[str]   =		AutoConfig.from_pretrained(A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )

                   SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		TFAutoModelForQuestionAnswering.from_pretrained(A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )







       @slow
       @require_tensorflow_probability
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
                   SCREAMING_SNAKE_CASE					:	int   =		AutoConfig.from_pretrained(A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )

                   SCREAMING_SNAKE_CASE					:	Optional[int]   =		TFAutoModelForTableQuestionAnswering.from_pretrained(A   )
                   SCREAMING_SNAKE_CASE ,  SCREAMING_SNAKE_CASE					:	Tuple   =		TFAutoModelForTableQuestionAnswering.from_pretrained(
                       A,				output_loading_info=A   )
                   self.assertIsNotNone(A   )
                   self.assertIsInstance(A,				A   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	int   =		TFAutoModelWithLMHead.from_pretrained(A   )
             self.assertIsInstance(A,				A   )
             self.assertEqual(model.num_parameters(),				14_410   )
             self.assertEqual(model.num_parameters(only_trainable=A   ),				14_410   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	int   =		TFAutoModelWithLMHead.from_pretrained(A   )
             self.assertIsInstance(A,				A   )
             self.assertEqual(model.num_parameters(),				14_410   )
             self.assertEqual(model.num_parameters(only_trainable=A   ),				14_410   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	List[Any]   =		TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'   )
             self.assertIsInstance(A,				A   )

             SCREAMING_SNAKE_CASE					:	Tuple   =		copy.deepcopy(model.config   )
             SCREAMING_SNAKE_CASE					:	List[str]   =		['FunnelBaseModel']
             SCREAMING_SNAKE_CASE					:	int   =		TFAutoModel.from_config(A   )
             self.assertIsInstance(A,				A   )

             with tempfile.TemporaryDirectory() as tmp_dir:
                   model.save_pretrained(A   )
                   SCREAMING_SNAKE_CASE					:	str   =		TFAutoModel.from_pretrained(A   )
                   self.assertIsInstance(A,				A   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             try:
                   AutoConfig.register('new-model',				A   )

                   SCREAMING_SNAKE_CASE					:	Any   =		[
                       TFAutoModel,
                       TFAutoModelForCausalLM,
                       TFAutoModelForMaskedLM,
                       TFAutoModelForPreTraining,
                       TFAutoModelForQuestionAnswering,
                       TFAutoModelForSequenceClassification,
                       TFAutoModelForTokenClassification,
                   ]

                   for auto_class in auto_classes:
                         with self.subTest(auto_class.__name__   ):
                               # Wrong config class will raise an error
                               with self.assertRaises(A   ):
                                     auto_class.register(A,				A   )
                               auto_class.register(A,				A   )
                               # Trying to register something existing in the Transformers library will raise an error
                               with self.assertRaises(A   ):
                                     auto_class.register(A,				A   )

                               # Now that the config is registered, it can be used as any other config with the auto-API
                               SCREAMING_SNAKE_CASE					:	Dict   =		BertModelTester(self   ).get_config()
                               SCREAMING_SNAKE_CASE					:	Dict   =		NewModelConfig(**tiny_config.to_dict()   )
                               SCREAMING_SNAKE_CASE					:	str   =		auto_class.from_config(A   )
                               self.assertIsInstance(A,				A   )

                               with tempfile.TemporaryDirectory() as tmp_dir:
                                     model.save_pretrained(A   )
                                     SCREAMING_SNAKE_CASE					:	Tuple   =		auto_class.from_pretrained(A   )
                                     self.assertIsInstance(A,				A   )

             finally:
                   if "new-model" in CONFIG_MAPPING._extra_content:
                         del CONFIG_MAPPING._extra_content["new-model"]
                   for mapping in (
                       TF_MODEL_MAPPING,
                       TF_MODEL_FOR_PRETRAINING_MAPPING,
                       TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                       TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                       TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                       TF_MODEL_FOR_CAUSAL_LM_MAPPING,
                       TF_MODEL_FOR_MASKED_LM_MAPPING,
                   ):
                         if NewModelConfig in mapping._extra_content:
                               del mapping._extra_content[NewModelConfig]







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             with self.assertRaisesRegex(
                 A,				'bert-base is not a local folder and is not a valid model identifier'   ):
                   SCREAMING_SNAKE_CASE					:	Any   =		TFAutoModel.from_pretrained('bert-base'   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             with self.assertRaisesRegex(
                 A,				r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'   ):
                   SCREAMING_SNAKE_CASE					:	Tuple   =		TFAutoModel.from_pretrained(A,				revision='aaaaaa'   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             with self.assertRaisesRegex(
                 A,				'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin',				):
                   SCREAMING_SNAKE_CASE					:	Tuple   =		TFAutoModel.from_pretrained('hf-internal-testing/config-no-model'   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             with self.assertRaisesRegex(A,				'Use `from_pt=True` to load this model'   ):
                   SCREAMING_SNAKE_CASE					:	Tuple   =		TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'   )







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	str   =		TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'   )
             with RequestCounter() as counter:
                   SCREAMING_SNAKE_CASE					:	Any   =		TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'   )
                   self.assertEqual(counter.get_request_count,				0   )
                   self.assertEqual(counter.head_request_count,				1   )
                   self.assertEqual(counter.other_request_count,				0   )

             # With a sharded checkpoint
             SCREAMING_SNAKE_CASE					:	Any   =		TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'   )
             with RequestCounter() as counter:
                   SCREAMING_SNAKE_CASE					:	Any   =		TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'   )
                   self.assertEqual(counter.get_request_count,				0   )
                   self.assertEqual(counter.head_request_count,				1   )
                   self.assertEqual(counter.other_request_count,				0   )



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


A   :     str       =				logging.get_logger(__name__)

# TODO: upload to AWS
A   :     Dict       =				{
    "yjernite/retribert-base-uncased": (
        "https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/config.json"
    ),
}


class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
  """simple docstring"""







  lowerCamelCase__   =  '''retribert'''







  def __init__(							self       :				Optional[int]     ,   __magic_name__       :				Optional[Any]=30_522     ,   __magic_name__       :				int=768     ,   __magic_name__       :				Dict=8     ,   __magic_name__       :				List[Any]=12     ,   __magic_name__       :				Tuple=3_072     ,   __magic_name__       :				List[Any]="gelu"     ,   __magic_name__       :				Any=0.1     ,   __magic_name__       :				Any=0.1     ,   __magic_name__       :				Tuple=512     ,   __magic_name__       :				Dict=2     ,   __magic_name__       :				int=0.02     ,   __magic_name__       :				List[Any]=1e-12     ,   __magic_name__       :				List[str]=True     ,   __magic_name__       :				Dict=128     ,   __magic_name__       :				Union[str, Any]=0     ,   **__magic_name__       :				List[Any]     ,   )     ->		Dict:
        super().__init__(pad_token_id=__magic_name__     ,   **__magic_name__      )

        SCREAMING_SNAKE_CASE_      =     vocab_size
        SCREAMING_SNAKE_CASE_      =     hidden_size
        SCREAMING_SNAKE_CASE_      =     num_hidden_layers
        SCREAMING_SNAKE_CASE_      =     num_attention_heads
        SCREAMING_SNAKE_CASE_      =     hidden_act
        SCREAMING_SNAKE_CASE_      =     intermediate_size
        SCREAMING_SNAKE_CASE_      =     hidden_dropout_prob
        SCREAMING_SNAKE_CASE_      =     attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE_      =     max_position_embeddings
        SCREAMING_SNAKE_CASE_      =     type_vocab_size
        SCREAMING_SNAKE_CASE_      =     initializer_range
        SCREAMING_SNAKE_CASE_      =     layer_norm_eps
        SCREAMING_SNAKE_CASE_      =     share_encoders
        SCREAMING_SNAKE_CASE_      =     projection_dim


