text: # coding=utf-8
  # Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
  # Copyright (c) 2018, NVIDIA CORPORATION.  All rights reserved.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  """ BERT model configuration """
  
  import copy
  import json
  import os,sys
  from typing import Any, Dict, Tuple
  
  WEIGHTS_NAME = "pytorch_model.bin"
  CONFIG_NAME = "config.json"
  #sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
  from .log import logging
  logger = logging.getLogger(__name__)
  
  class PretrainedConfig(object):
      model_type: str = ""
  
      def __init__(self, **kwargs):
          # Attributes with defaults
          self.return_dict = kwargs.pop("return_dict", False)
          self.output_hidden_states = kwargs.pop("output_hidden_states", False)
          self.output_attentions = kwargs.pop("output_attentions", False)
          self.use_cache = kwargs.pop("use_cache", True)  # Not used by all models
          self.torchscript = kwargs.pop("torchscript", False)  # Only used by PyTorch models
          self.use_bfloat16 = kwargs.pop("use_bfloat16", False)
          self.pruned_heads = kwargs.pop("pruned_heads", {})
          self.tie_word_embeddings = kwargs.pop(
              "tie_word_embeddings", True
          )  # Whether input and output word embeddings should be tied for all MLM, LM and Seq2Seq models.
  
          # Is decoder is used in encoder-decoder models to differentiate encoder from decoder
          self.is_encoder_decoder = kwargs.pop("is_encoder_decoder", False)
          self.is_decoder = kwargs.pop("is_decoder", False)
          self.add_cross_attention = kwargs.pop("add_cross_attention", False)
          self.tie_encoder_decoder = kwargs.pop("tie_encoder_decoder", False)
  
          # Parameters for sequence generation
          self.max_length = kwargs.pop("max_length", 20)
          self.min_length = kwargs.pop("min_length", 0)
          self.do_sample = kwargs.pop("do_sample", False)
          self.early_stopping = kwargs.pop("early_stopping", False)
          self.num_beams = kwargs.pop("num_beams", 1)
          self.temperature = kwargs.pop("temperature", 1.0)
          self.top_k = kwargs.pop("top_k", 50)
          self.top_p = kwargs.pop("top_p", 1.0)
          self.repetition_penalty = kwargs.pop("repetition_penalty", 1.0)
          self.length_penalty = kwargs.pop("length_penalty", 1.0)
          self.no_repeat_ngram_size = kwargs.pop("no_repeat_ngram_size", 0)
          self.bad_words_ids = kwargs.pop("bad_words_ids", None)
          self.num_return_sequences = kwargs.pop("num_return_sequences", 1)
          self.chunk_size_feed_forward = kwargs.pop("chunk_size_feed_forward", 0)
  
          # Fine-tuning task arguments
          self.architectures = kwargs.pop("architectures", None)
          self.finetuning_task = kwargs.pop("finetuning_task", None)
          self.id2label = kwargs.pop("id2label", None)
          self.label2id = kwargs.pop("label2id", None)
          if self.id2label is not None:
              kwargs.pop("num_labels", None)
              self.id2label = dict((int(key), value) for key, value in self.id2label.items())
              # Keys are always strings in JSON so convert ids to int here.
          else:
              self.num_labels = kwargs.pop("num_labels", 2)
  
          # Tokenizer arguments TODO: eventually tokenizer and models should share the same config
          self.tokenizer_class = kwargs.pop("tokenizer_class", None)
          self.prefix = kwargs.pop("prefix", None)
          self.bos_token_id = kwargs.pop("bos_token_id", None)
          self.pad_token_id = kwargs.pop("pad_token_id", None)
          self.eos_token_id = kwargs.pop("eos_token_id", None)
          self.sep_token_id = kwargs.pop("sep_token_id", None)
  
          self.decoder_start_token_id = kwargs.pop("decoder_start_token_id", None)
  
          # task specific arguments
          self.task_specific_params = kwargs.pop("task_specific_params", None)
  
          # TPU arguments
          self.xla_device = kwargs.pop("xla_device", None)
  
          # Name or path to the pretrained checkpoint
          self._name_or_path = str(kwargs.pop("name_or_path", ""))
  
          # Additional attributes without default values
          for key, value in kwargs.items():
              try:
                  setattr(self, key, value)
              except AttributeError as err:
                  logger.error("Can't set {} with value {} for {}".format(key, value, self))
                  raise err
  
      @property
      def name_or_path(self) -> str:
          return self._name_or_path
  
      @name_or_path.setter
      def name_or_path(self, value):
          self._name_or_path = str(value)  # Make sure that name_or_path is a string (for JSON encoding)
  
      @property
      def use_return_dict(self) -> bool:
          """
          :obj:`bool`: Whether or not return :class:`~transformers.file_utils.ModelOutput` instead of tuples.
          """
          # If torchscript is set, force `return_dict=False` to avoid jit errors
          return self.return_dict and not self.torchscript
  
      @property
      def num_labels(self) -> int:
          """
          :obj:`int`: The number of labels for classification models.
          """
          return len(self.id2label)
  
      @num_labels.setter
      def num_labels(self, num_labels: int):
          self.id2label = {i: "LABEL_{}".format(i) for i in range(num_labels)}
          self.label2id = dict(zip(self.id2label.values(), self.id2label.keys()))
  
      def save_pretrained(self, save_directory: str):
          """
          Save a configuration object to the directory ``save_directory``, so that it can be re-loaded using the
          :func:`~transformers.PretrainedConfig.from_pretrained` class method.
  
          Args:
              save_directory (:obj:`str`):
                  Directory where the configuration JSON file will be saved (will be created if it does not exist).
          """
          if os.path.isfile(save_directory):
              raise AssertionError("Provided path ({}) should be a directory, not a file".format(save_directory))
          os.makedirs(save_directory, exist_ok=True)
          # If we save using the predefined names, we can load using `from_pretrained`
          output_config_file = os.path.join(save_directory, CONFIG_NAME)
  
          self.to_json_file(output_config_file, use_diff=True)
          logger.info("Configuration saved in {}".format(output_config_file))
  
      @classmethod
      def from_pretrained(cls, pretrained_model_name_or_path: str, **kwargs):
          config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
          return cls.from_dict(config_dict, **kwargs)
  
      @classmethod
      def get_config_dict(cls, pretrained_model_name_or_path: str, **kwargs) -> Tuple[Dict[str, Any], Dict[str, Any]]:
          assert os.path.isdir(pretrained_model_name_or_path)
          config_file = os.path.join(pretrained_model_name_or_path, CONFIG_NAME)
          try:
              config_dict = cls._dict_from_json_file(config_file)
          except EnvironmentError:
              msg = (
                  f"Can't load config for '{pretrained_model_name_or_path}'. Make sure that:\n\n"
                  f"- '{pretrained_model_name_or_path}' is a correct model identifier listed on 'https://huggingface.co/models'\n\n"
                  f"- or '{pretrained_model_name_or_path}' is the correct path to a directory containing a {CONFIG_NAME} file\n\n"
              )
              raise EnvironmentError(msg)
          except json.JSONDecodeError:
              msg = (
                  "Couldn't reach server at '{}' to download configuration file or "
                  "configuration file is not a valid JSON file. "
                  "Please check network or file content here: {}.".format(config_file, config_file)
              )
              raise EnvironmentError(msg)
          logger.info("loading configuration file {}".format(config_file))
          return config_dict, kwargs
  
      @classmethod
      def from_dict(cls, config_dict: Dict[str, Any], **kwargs):
          return_unused_kwargs = kwargs.pop("return_unused_kwargs", False)
  
          config = cls(**config_dict)
  
          if hasattr(config, "pruned_heads"):
              config.pruned_heads = dict((int(key), value) for key, value in config.pruned_heads.items())
  
          # Update config with kwargs if needed
          to_remove = []
          for key, value in kwargs.items():
              if hasattr(config, key):
                  setattr(config, key, value)
                  to_remove.append(key)
          for key in to_remove:
              kwargs.pop(key, None)
  
          #logger.info("Model config %s", str(config))
          if return_unused_kwargs:
              return config, kwargs
          else:
              return config
  
      @classmethod
      def from_json_file(cls, json_file: str) -> "PretrainedConfig":
          """
          Instantiates a :class:`~transformers.PretrainedConfig` from the path to a JSON file of parameters.
  
          Args:
              json_file (:obj:`str`):
                  Path to the JSON file containing the parameters.
  
          Returns:
              :class:`PretrainedConfig`: The configuration object instantiated from that JSON file.
  
          """
          config_dict = cls._dict_from_json_file(json_file)
          return cls(**config_dict)
  
      @classmethod
      def _dict_from_json_file(cls, json_file: str):
          with open(json_file, "r", encoding="utf-8") as reader:
              text = reader.read()
          return json.loads(text)
  
      def __eq__(self, other):
          return self.__dict__ == other.__dict__
  
      def __repr__(self):
          return "{} {}".format(self.__class__.__name__, self.to_json_string())
  
      def to_diff_dict(self) -> Dict[str, Any]:
          """
          Removes all attributes from config which correspond to the default
          config attributes for better readability and serializes to a Python
          dictionary.
  
          Returns:
              :obj:`Dict[str, Any]`: Dictionary of all the attributes that make up this configuration instance,
          """
          config_dict = self.to_dict()
  
          # get the default config dict
          default_config_dict = PretrainedConfig().to_dict()
  
          serializable_config_dict = {}
  
          # only serialize values that differ from the default config
          for key, value in config_dict.items():
              if key not in default_config_dict or value != default_config_dict[key]:
                  serializable_config_dict[key] = value
  
          return serializable_config_dict
  
      def to_dict(self) -> Dict[str, Any]:
          """
          Serializes this instance to a Python dictionary.
  
          Returns:
              :obj:`Dict[str, Any]`: Dictionary of all the attributes that make up this configuration instance.
          """
          output = copy.deepcopy(self.__dict__)
          if hasattr(self.__class__, "model_type"):
              output["model_type"] = self.__class__.model_type
          return output
  
      def to_json_string(self, use_diff: bool = True) -> str:
          """
          Serializes this instance to a JSON string.
  
          Args:
              use_diff (:obj:`bool`, `optional`, defaults to :obj:`True`):
                  If set to ``True``, only the difference between the config instance and the default
                  ``PretrainedConfig()`` is serialized to JSON string.
  
          Returns:
              :obj:`str`: String containing all the attributes that make up this configuration instance in JSON format.
          """
          if use_diff is True:
              config_dict = self.to_diff_dict()
          else:
              config_dict = self.to_dict()
          return json.dumps(config_dict, indent=2, sort_keys=True) + "\n"
  
      def to_json_file(self, json_file_path: str, use_diff: bool = True):
          """
          Save this instance to a JSON file.
  
          Args:
              json_file_path (:obj:`str`):
                  Path to the JSON file in which this configuration instance's parameters will be saved.
              use_diff (:obj:`bool`, `optional`, defaults to :obj:`True`):
                  If set to ``True``, only the difference between the config instance and the default
                  ``PretrainedConfig()`` is serialized to JSON file.
          """
          with open(json_file_path, "w", encoding="utf-8") as writer:
              writer.write(self.to_json_string(use_diff=use_diff))
  
      def update(self, config_dict: Dict[str, Any]):
          """
          Updates attributes of this class with attributes from ``config_dict``.
  
          Args:
              config_dict (:obj:`Dict[str, Any]`): Dictionary of attributes that shall be updated for this class.
          """
          for key, value in config_dict.items():
              setattr(self, key, value)
  
  class BertConfig(PretrainedConfig):
      r"""
      This is the configuration class to store the configuration of a :class:`~transformers.BertModel` or a
      :class:`~transformers.TFBertModel`. It is used to instantiate a BERT model according to the specified
      arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar
      configuration to that of the BERT `bert-base-uncased <https://huggingface.co/bert-base-uncased>`__ architecture.
  
      Configuration objects inherit from  :class:`~transformers.PretrainedConfig` and can be used
      to control the model outputs. Read the documentation from  :class:`~transformers.PretrainedConfig`
      for more information.
  
  
      Args:
          vocab_size (:obj:`int`, `optional`, defaults to 30522):
              Vocabulary size of the BERT model. Defines the number of different tokens that can be represented by the
              :obj:`inputs_ids` passed when calling :class:`~transformers.BertModel` or
              :class:`~transformers.TFBertModel`.
          hidden_size (:obj:`int`, `optional`, defaults to 768):
              Dimensionality of the encoder layers and the pooler layer.
          num_hidden_layers (:obj:`int`, `optional`, defaults to 12):
              Number of hidden layers in the Transformer encoder.
          num_attention_heads (:obj:`int`, `optional`, defaults to 12):
              Number of attention heads for each attention layer in the Transformer encoder.
          intermediate_size (:obj:`int`, `optional`, defaults to 3072):
              Dimensionality of the "intermediate" (often named feed-forward) layer in the Transformer encoder.
          hidden_act (:obj:`str` or :obj:`Callable`, `optional`, defaults to :obj:`"gelu"`):
              The non-linear activation function (function or string) in the encoder and pooler.
              If string, :obj:`"gelu"`, :obj:`"relu"`, :obj:`"swish"` and :obj:`"gelu_new"` are supported.
          hidden_dropout_prob (:obj:`float`, `optional`, defaults to 0.1):
              The dropout probabilitiy for all fully connected layers in the embeddings, encoder, and pooler.
          attention_probs_dropout_prob (:obj:`float`, `optional`, defaults to 0.1):
              The dropout ratio for the attention probabilities.
          max_position_embeddings (:obj:`int`, `optional`, defaults to 512):
              The maximum sequence length that this model might ever be used with.
              Typically set this to something large just in case (e.g., 512 or 1024 or 2048).
          type_vocab_size (:obj:`int`, `optional`, defaults to 2):
              The vocabulary size of the :obj:`token_type_ids` passed when calling :class:`~transformers.BertModel` or
              :class:`~transformers.TFBertModel`.
          initializer_range (:obj:`float`, `optional`, defaults to 0.02):
              The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
          layer_norm_eps (:obj:`float`, `optional`, defaults to 1e-12):
              The epsilon used by the layer normalization layers.
          gradient_checkpointing (:obj:`bool`, `optional`, defaults to :obj:`False`):
              If True, use gradient checkpointing to save memory at the expense of slower backward pass.
  
      Examples::
  
          >>> from transformers import BertModel, BertConfig
  
          >>> # Initializing a BERT bert-base-uncased style configuration
          >>> configuration = BertConfig()
  
          >>> # Initializing a model from the bert-base-uncased style configuration
          >>> model = BertModel(configuration)
  
          >>> # Accessing the model configuration
          >>> configuration = model.config
      """
      model_type = "bert"
  
      def __init__(
          self,
          vocab_size=30522,
          hidden_size=768,
          num_hidden_layers=12,
          num_attention_heads=12,
          intermediate_size=3072,
          hidden_act="gelu",
          hidden_dropout_prob=0.1,
          attention_probs_dropout_prob=0.1,
          max_position_embeddings=512,
          type_vocab_size=2,
          initializer_range=0.02,
          layer_norm_eps=1e-12,
          pad_token_id=0,
          gradient_checkpointing=False,
          **kwargs
      ):
          super().__init__(pad_token_id=pad_token_id, **kwargs)
  
          self.vocab_size = vocab_size
          self.hidden_size = hidden_size
          self.num_hidden_layers = num_hidden_layers
          self.num_attention_heads = num_attention_heads
          self.hidden_act = hidden_act
          self.intermediate_size = intermediate_size
          self.hidden_dropout_prob = hidden_dropout_prob
          self.attention_probs_dropout_prob = attention_probs_dropout_prob
          self.max_position_embeddings = max_position_embeddings
          self.type_vocab_size = type_vocab_size
          self.initializer_range = initializer_range
          self.layer_norm_eps = layer_norm_eps
          self.gradient_checkpointing = gradient_checkpointing
  