'''simple docstring'''

from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     TFConvBertForMaskedLM,
     TFConvBertForMultipleChoice,
     TFConvBertForQuestionAnswering,
     TFConvBertForSequenceClassification,
     TFConvBertForTokenClassification,
     TFConvBertModel,
 )







class 				_lowercase     :


 '''simple docstring'''






 def __init__(      self   :	Tuple      ,       SCREAMING_SNAKE_CASE__   :	Any      ,       SCREAMING_SNAKE_CASE__   :	List[Any]=13      ,       SCREAMING_SNAKE_CASE__   :	str=7      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]=True      ,       SCREAMING_SNAKE_CASE__   :	List[str]=True      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]=True      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]=True      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]=99      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]=32      ,       SCREAMING_SNAKE_CASE__   :	str=2      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]=4      ,       SCREAMING_SNAKE_CASE__   :	int=37      ,       SCREAMING_SNAKE_CASE__   :	List[str]="gelu"      ,       SCREAMING_SNAKE_CASE__   :	Any=0.1      ,       SCREAMING_SNAKE_CASE__   :	Tuple=0.1      ,       SCREAMING_SNAKE_CASE__   :	int=5_12      ,       SCREAMING_SNAKE_CASE__   :	Dict=16      ,       SCREAMING_SNAKE_CASE__   :	Tuple=2      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]=0.0_2      ,       SCREAMING_SNAKE_CASE__   :	str=3      ,       SCREAMING_SNAKE_CASE__   :	List[str]=4      ,       SCREAMING_SNAKE_CASE__   :	List[Any]=None      ,       )  ->    Dict:
  __lowerCAmelCase											=						parent
  __lowerCAmelCase											=						13
  __lowerCAmelCase											=						7
  __lowerCAmelCase											=						True
  __lowerCAmelCase											=						True
  __lowerCAmelCase											=						True
  __lowerCAmelCase											=						True
  __lowerCAmelCase											=						99
  __lowerCAmelCase											=						3_84
  __lowerCAmelCase											=						2
  __lowerCAmelCase											=						4
  __lowerCAmelCase											=						37
  __lowerCAmelCase											=						"""gelu"""
  __lowerCAmelCase											=						0.1
  __lowerCAmelCase											=						0.1
  __lowerCAmelCase											=						5_12
  __lowerCAmelCase											=						16
  __lowerCAmelCase											=						2
  __lowerCAmelCase											=						0.0_2
  __lowerCAmelCase											=						3
  __lowerCAmelCase											=						4
  __lowerCAmelCase											=						1_28
  __lowerCAmelCase											=						2
  __lowerCAmelCase											=						9
  __lowerCAmelCase											=						1
  __lowerCAmelCase											=						None
 def a					(      self   :	List[Any]							)  ->    Any:
  __lowerCAmelCase											=						ids_tensor([self.batch_size, self.seq_length]      ,       self.vocab_size							)

  __lowerCAmelCase											=						None
  if self.use_input_mask:
   __lowerCAmelCase											=						random_attention_mask([self.batch_size, self.seq_length]							)

  __lowerCAmelCase											=						None
  if self.use_token_type_ids:
   __lowerCAmelCase											=						ids_tensor([self.batch_size, self.seq_length]      ,       self.type_vocab_size							)

  __lowerCAmelCase											=						None
  __lowerCAmelCase											=						None
  __lowerCAmelCase											=						None
  if self.use_labels:
   __lowerCAmelCase											=						ids_tensor([self.batch_size]      ,       self.type_sequence_label_size							)
   __lowerCAmelCase											=						ids_tensor([self.batch_size, self.seq_length]      ,       self.num_labels							)
   __lowerCAmelCase											=						ids_tensor([self.batch_size]      ,       self.num_choices							)

  __lowerCAmelCase											=						ConvBertConfig(
      vocab_size=self.vocab_size      ,       hidden_size=self.hidden_size      ,       num_hidden_layers=self.num_hidden_layers      ,       num_attention_heads=self.num_attention_heads      ,       intermediate_size=self.intermediate_size      ,       hidden_act=self.hidden_act      ,       hidden_dropout_prob=self.hidden_dropout_prob      ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,       max_position_embeddings=self.max_position_embeddings      ,       type_vocab_size=self.type_vocab_size      ,       initializer_range=self.initializer_range      ,       return_dict=SCREAMING_SNAKE_CASE__      ,       )

  return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
 def a					(      self   :	Dict      ,       SCREAMING_SNAKE_CASE__   :	str      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	int      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	Tuple      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]							)  ->    Optional[int]:
  __lowerCAmelCase											=						TFConvBertModel(config=SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

  __lowerCAmelCase											=						[input_ids, input_mask]
  __lowerCAmelCase											=						model(SCREAMING_SNAKE_CASE__							)

  __lowerCAmelCase											=						model(SCREAMING_SNAKE_CASE__							)

  self.parent.assertEqual(result.last_hidden_state.shape      ,       (self.batch_size, self.seq_length, self.hidden_size)							)
 def a					(      self   :	Dict      ,       SCREAMING_SNAKE_CASE__   :	Tuple      ,       SCREAMING_SNAKE_CASE__   :	Any      ,       SCREAMING_SNAKE_CASE__   :	int      ,       SCREAMING_SNAKE_CASE__   :	Optional[int]      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	Dict      ,       SCREAMING_SNAKE_CASE__   :	Any							)  ->    int:
  __lowerCAmelCase											=						TFConvBertForMaskedLM(config=SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						{
      """input_ids""": input_ids,
      """attention_mask""": input_mask,
      """token_type_ids""": token_type_ids,
  }
  __lowerCAmelCase											=						model(SCREAMING_SNAKE_CASE__							)
  self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.seq_length, self.vocab_size)							)
 def a					(      self   :	int      ,       SCREAMING_SNAKE_CASE__   :	Tuple      ,       SCREAMING_SNAKE_CASE__   :	List[Any]      ,       SCREAMING_SNAKE_CASE__   :	str      ,       SCREAMING_SNAKE_CASE__   :	Any      ,       SCREAMING_SNAKE_CASE__   :	int      ,       SCREAMING_SNAKE_CASE__   :	List[Any]      ,       SCREAMING_SNAKE_CASE__   :	str							)  ->    Union[str, Any]:
  __lowerCAmelCase											=						self.num_labels
  __lowerCAmelCase											=						TFConvBertForSequenceClassification(config=SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						{
      """input_ids""": input_ids,
      """attention_mask""": input_mask,
      """token_type_ids""": token_type_ids,
  }

  __lowerCAmelCase											=						model(SCREAMING_SNAKE_CASE__							)
  self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.num_labels)							)
 def a					(      self   :	Optional[Any]      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	Dict      ,       SCREAMING_SNAKE_CASE__   :	Optional[int]      ,       SCREAMING_SNAKE_CASE__   :	List[str]      ,       SCREAMING_SNAKE_CASE__   :	Tuple      ,       SCREAMING_SNAKE_CASE__   :	List[str]      ,       SCREAMING_SNAKE_CASE__   :	str							)  ->    int:
  __lowerCAmelCase											=						self.num_choices
  __lowerCAmelCase											=						TFConvBertForMultipleChoice(config=SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE__      ,       1							)      ,       (1, self.num_choices, 1)							)
  __lowerCAmelCase											=						tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE__      ,       1							)      ,       (1, self.num_choices, 1)							)
  __lowerCAmelCase											=						tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE__      ,       1							)      ,       (1, self.num_choices, 1)							)
  __lowerCAmelCase											=						{
      """input_ids""": multiple_choice_inputs_ids,
      """attention_mask""": multiple_choice_input_mask,
      """token_type_ids""": multiple_choice_token_type_ids,
  }
  __lowerCAmelCase											=						model(SCREAMING_SNAKE_CASE__							)
  self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.num_choices)							)
 def a					(      self   :	int      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]      ,       SCREAMING_SNAKE_CASE__   :	str      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]      ,       SCREAMING_SNAKE_CASE__   :	Optional[int]							)  ->    str:
  __lowerCAmelCase											=						self.num_labels
  __lowerCAmelCase											=						TFConvBertForTokenClassification(config=SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						{
      """input_ids""": input_ids,
      """attention_mask""": input_mask,
      """token_type_ids""": token_type_ids,
  }
  __lowerCAmelCase											=						model(SCREAMING_SNAKE_CASE__							)
  self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.seq_length, self.num_labels)							)
 def a					(      self   :	int      ,       SCREAMING_SNAKE_CASE__   :	Optional[int]      ,       SCREAMING_SNAKE_CASE__   :	List[str]      ,       SCREAMING_SNAKE_CASE__   :	List[Any]      ,       SCREAMING_SNAKE_CASE__   :	int      ,       SCREAMING_SNAKE_CASE__   :	List[Any]      ,       SCREAMING_SNAKE_CASE__   :	Tuple      ,       SCREAMING_SNAKE_CASE__   :	Union[str, Any]							)  ->    List[Any]:
  __lowerCAmelCase											=						TFConvBertForQuestionAnswering(config=SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						{
      """input_ids""": input_ids,
      """attention_mask""": input_mask,
      """token_type_ids""": token_type_ids,
  }

  __lowerCAmelCase											=						model(SCREAMING_SNAKE_CASE__							)
  self.parent.assertEqual(result.start_logits.shape      ,       (self.batch_size, self.seq_length)							)
  self.parent.assertEqual(result.end_logits.shape      ,       (self.batch_size, self.seq_length)							)





 def a					(      self   :	Union[str, Any]							)  ->    Any:
  __lowerCAmelCase											=						self.prepare_config_and_inputs()
  (
      (
      __lowerCAmelCase
  )							,       (
      __lowerCAmelCase
  )							,       (
      __lowerCAmelCase
  )							,       (
      __lowerCAmelCase
  )							,       (
      __lowerCAmelCase
  )							,       (
      __lowerCAmelCase
  )							,       (
      __lowerCAmelCase
  )							,       
  )											=						config_and_inputs
  __lowerCAmelCase											=						{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
  return config, inputs_dict







@require_tf
class 				_lowercase     (				UpperCAmelCase__  ,							UpperCAmelCase__  ,							unittest.TestCase			):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE     :       List[Any]      	=					(
     (
         TFConvBertModel,
         TFConvBertForMaskedLM,
         TFConvBertForQuestionAnswering,
         TFConvBertForSequenceClassification,
         TFConvBertForTokenClassification,
         TFConvBertForMultipleChoice,
     )
     if is_tf_available()
     else ()
 )
 _SCREAMING_SNAKE_CASE     :       Optional[int]      	=					(
     {
         """feature-extraction""": TFConvBertModel,
         """fill-mask""": TFConvBertForMaskedLM,
         """question-answering""": TFConvBertForQuestionAnswering,
         """text-classification""": TFConvBertForSequenceClassification,
         """token-classification""": TFConvBertForTokenClassification,
         """zero-shot""": TFConvBertForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 _SCREAMING_SNAKE_CASE     :       int      	=					False
 _SCREAMING_SNAKE_CASE     :       int      	=					False
 _SCREAMING_SNAKE_CASE     :       Dict      	=					False
 def a					(      self   :	Tuple							)  ->    str:
  __lowerCAmelCase											=						TFConvBertModelTester(self							)
  __lowerCAmelCase											=						ConfigTester(self      ,       config_class=SCREAMING_SNAKE_CASE__      ,       hidden_size=37							)
 def a					(      self   :	Dict							)  ->    Any:
  self.config_tester.run_common_tests()
 def a					(      self   :	List[Any]							)  ->    Union[str, Any]:
  __lowerCAmelCase											=						self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__							)
 def a					(      self   :	str							)  ->    int:
  __lowerCAmelCase											=						self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE__							)
 def a					(      self   :	Any							)  ->    Union[str, Any]:
  __lowerCAmelCase											=						self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE__							)
 def a					(      self   :	Optional[int]							)  ->    Dict:
  __lowerCAmelCase											=						self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE__							)
 def a					(      self   :	int							)  ->    str:
  __lowerCAmelCase											=						self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE__							)
 def a					(      self   :	Dict							)  ->    List[str]:
  __lowerCAmelCase											=						self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE__							)
 @slow
 def a					(      self   :	Tuple							)  ->    List[str]:
  __lowerCAmelCase							,       __lowerCAmelCase											=						self.model_tester.prepare_config_and_inputs_for_common()
  __lowerCAmelCase											=						True
  __lowerCAmelCase											=						True

  if hasattr(SCREAMING_SNAKE_CASE__      ,       """use_cache"""							):
   __lowerCAmelCase											=						True

  __lowerCAmelCase											=						getattr(self.model_tester      ,       """encoder_seq_length"""      ,       self.model_tester.seq_length							)
  __lowerCAmelCase											=						getattr(self.model_tester      ,       """key_length"""      ,       SCREAMING_SNAKE_CASE__							)

  for model_class in self.all_model_classes:
   __lowerCAmelCase											=						self._prepare_for_class(SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__							)
   __lowerCAmelCase											=						model_class(SCREAMING_SNAKE_CASE__							)
   __lowerCAmelCase											=						len(model(SCREAMING_SNAKE_CASE__							)							)

   with tempfile.TemporaryDirectory() as tmpdirname:
    model.save_pretrained(SCREAMING_SNAKE_CASE__      ,       saved_model=SCREAMING_SNAKE_CASE__							)
    __lowerCAmelCase											=						os.path.join(SCREAMING_SNAKE_CASE__      ,       """saved_model"""      ,       """1"""							)
    __lowerCAmelCase											=						tf.keras.models.load_model(SCREAMING_SNAKE_CASE__							)
    __lowerCAmelCase											=						model(SCREAMING_SNAKE_CASE__							)

    if self.is_encoder_decoder:
     __lowerCAmelCase											=						outputs["""encoder_hidden_states"""]
     __lowerCAmelCase											=						outputs["""encoder_attentions"""]
    else:
     __lowerCAmelCase											=						outputs["""hidden_states"""]
     __lowerCAmelCase											=						outputs["""attentions"""]

    self.assertEqual(len(SCREAMING_SNAKE_CASE__							)      ,       SCREAMING_SNAKE_CASE__							)

    __lowerCAmelCase											=						getattr(
        self.model_tester      ,       """expected_num_hidden_layers"""      ,       self.model_tester.num_hidden_layers + 1							)

    self.assertEqual(len(SCREAMING_SNAKE_CASE__							)      ,       SCREAMING_SNAKE_CASE__							)
    self.assertListEqual(
        list(output_hidden_states[0].shape[-2:]							)      ,       [self.model_tester.seq_length, self.model_tester.hidden_size]      ,       )

    self.assertEqual(len(SCREAMING_SNAKE_CASE__							)      ,       self.model_tester.num_hidden_layers							)
    self.assertListEqual(
        list(output_attentions[0].shape[-3:]							)      ,       [self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]      ,       )
 @slow
 def a					(      self   :	Optional[Any]							)  ->    Union[str, Any]:
  __lowerCAmelCase											=						TFConvBertModel.from_pretrained("""YituTech/conv-bert-base"""							)
  self.assertIsNotNone(SCREAMING_SNAKE_CASE__							)





 def a					(      self   :	List[str]							)  ->    List[Any]:
  __lowerCAmelCase							,       __lowerCAmelCase											=						self.model_tester.prepare_config_and_inputs_for_common()
  __lowerCAmelCase											=						True
  __lowerCAmelCase											=						getattr(self.model_tester      ,       """decoder_seq_length"""      ,       self.model_tester.seq_length							)
  __lowerCAmelCase											=						getattr(self.model_tester      ,       """encoder_seq_length"""      ,       self.model_tester.seq_length							)
  __lowerCAmelCase											=						getattr(self.model_tester      ,       """key_length"""      ,       SCREAMING_SNAKE_CASE__							)
  __lowerCAmelCase											=						getattr(self.model_tester      ,       """key_length"""      ,       SCREAMING_SNAKE_CASE__							)

  def check_decoder_attentions_output(SCREAMING_SNAKE_CASE__   :	int							):
   __lowerCAmelCase											=						len(SCREAMING_SNAKE_CASE__							)
   self.assertEqual(out_len % 2      ,       0							)
   __lowerCAmelCase											=						outputs.decoder_attentions
   self.assertEqual(len(SCREAMING_SNAKE_CASE__							)      ,       self.model_tester.num_hidden_layers							)
   self.assertListEqual(
       list(decoder_attentions[0].shape[-3:]							)      ,       [self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length]      ,       )

  def check_encoder_attentions_output(SCREAMING_SNAKE_CASE__   :	Tuple							):
   __lowerCAmelCase											=						[
       t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
   ]
   self.assertEqual(len(SCREAMING_SNAKE_CASE__							)      ,       self.model_tester.num_hidden_layers							)
   self.assertListEqual(
       list(attentions[0].shape[-3:]							)      ,       [self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]      ,       )

  for model_class in self.all_model_classes:
   __lowerCAmelCase											=						True
   __lowerCAmelCase											=						False
   __lowerCAmelCase											=						model_class(SCREAMING_SNAKE_CASE__							)
   __lowerCAmelCase											=						model(self._prepare_for_class(SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__							)							)
   __lowerCAmelCase											=						len(SCREAMING_SNAKE_CASE__							)
   self.assertEqual(config.output_hidden_states      ,       SCREAMING_SNAKE_CASE__							)
   check_encoder_attentions_output(SCREAMING_SNAKE_CASE__							)

   if self.is_encoder_decoder:
    __lowerCAmelCase											=						model_class(SCREAMING_SNAKE_CASE__							)
    __lowerCAmelCase											=						model(self._prepare_for_class(SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__							)							)
    self.assertEqual(config.output_hidden_states      ,       SCREAMING_SNAKE_CASE__							)
    check_decoder_attentions_output(SCREAMING_SNAKE_CASE__							)

   # Check that output attentions can also be changed via the config
   del inputs_dict["output_attentions"]
   __lowerCAmelCase											=						True
   __lowerCAmelCase											=						model_class(SCREAMING_SNAKE_CASE__							)
   __lowerCAmelCase											=						model(self._prepare_for_class(SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__							)							)
   self.assertEqual(config.output_hidden_states      ,       SCREAMING_SNAKE_CASE__							)
   check_encoder_attentions_output(SCREAMING_SNAKE_CASE__							)

   # Check attention is always last and order is fine
   __lowerCAmelCase											=						True
   __lowerCAmelCase											=						True
   __lowerCAmelCase											=						model_class(SCREAMING_SNAKE_CASE__							)
   __lowerCAmelCase											=						model(self._prepare_for_class(SCREAMING_SNAKE_CASE__      ,       SCREAMING_SNAKE_CASE__							)							)

   self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)      ,       len(SCREAMING_SNAKE_CASE__							)							)
   self.assertEqual(model.config.output_hidden_states      ,       SCREAMING_SNAKE_CASE__							)
   check_encoder_attentions_output(SCREAMING_SNAKE_CASE__							)







@require_tf
class 				_lowercase     (				unittest.TestCase			):


 '''simple docstring'''






 @slow
 def a					(      self   :	str							)  ->    Dict:
  __lowerCAmelCase											=						TFConvBertModel.from_pretrained("""YituTech/conv-bert-base"""							)
  __lowerCAmelCase											=						tf.constant([[0, 1, 2, 3, 4, 5]]							)
  __lowerCAmelCase											=						model(SCREAMING_SNAKE_CASE__							)[0]

  __lowerCAmelCase											=						[1, 6, 7_68]
  self.assertEqual(output.shape      ,       SCREAMING_SNAKE_CASE__							)

  __lowerCAmelCase											=						tf.constant(
      [
          [
              [-0.0_3_4_7_5_4_9_3, -0.4_6_8_6_0_3_4, -0.3_0_6_3_8_8_3_2],
              [0.2_2_6_3_7_2_4_8, -0.2_6_9_8_8_6_4_6, -0.7_4_2_3_4_2_4],
              [0.1_0_3_2_4_8_6_8, -0.4_5_0_1_3_5_0_8, -0.5_8_2_8_0_7_8_4],
          ]
      ]							)
  tf.debugging.assert_near(output[:, :3, :3]      ,       SCREAMING_SNAKE_CASE__      ,       atol=1e-4							)







'''simple docstring'''

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


_A			:      int					      =				logging.get_logger(__name__)

_A			:      Any					      =				{'''ctrl''': '''https://huggingface.co/ctrl/resolve/main/config.json'''}







class 				_lowercase     (				UpperCAmelCase__			):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE     :       Any      	=					"""ctrl"""
 _SCREAMING_SNAKE_CASE     :       Optional[Any]      	=					["""past_key_values"""]
 _SCREAMING_SNAKE_CASE     :       Union[str, Any]      	=					{
     """max_position_embeddings""": """n_positions""",
     """hidden_size""": """n_embd""",
     """num_attention_heads""": """n_head""",
     """num_hidden_layers""": """n_layer""",
 }
 def __init__(      self   :	Any      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]=24_65_34      ,       SCREAMING_SNAKE_CASE__   :	Optional[int]=2_56      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]=12_80      ,       SCREAMING_SNAKE_CASE__   :	str=81_92      ,       SCREAMING_SNAKE_CASE__   :	List[str]=48      ,       SCREAMING_SNAKE_CASE__   :	Tuple=16      ,       SCREAMING_SNAKE_CASE__   :	str=0.1      ,       SCREAMING_SNAKE_CASE__   :	Dict=0.1      ,       SCREAMING_SNAKE_CASE__   :	Dict=1e-6      ,       SCREAMING_SNAKE_CASE__   :	Any=0.0_2      ,       SCREAMING_SNAKE_CASE__   :	Tuple=True      ,       **SCREAMING_SNAKE_CASE__   :	Optional[int]      ,       )  ->    Tuple:
  __lowerCAmelCase											=						vocab_size
  __lowerCAmelCase											=						n_positions
  __lowerCAmelCase											=						n_embd
  __lowerCAmelCase											=						n_layer
  __lowerCAmelCase											=						n_head
  __lowerCAmelCase											=						dff
  __lowerCAmelCase											=						resid_pdrop
  __lowerCAmelCase											=						embd_pdrop
  __lowerCAmelCase											=						layer_norm_epsilon
  __lowerCAmelCase											=						initializer_range

  __lowerCAmelCase											=						use_cache

  super().__init__(**SCREAMING_SNAKE_CASE__							)






