





import os
import re
import shutil
import sys
import tempfile
import unittest

import black


UpperCAmelCase_  							=				os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, 'utils'))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If BertLMPredictionHead is changed in modeling_bert.py, this code needs to be manually updated.
UpperCAmelCase_  							=				'    def __init__(self, config):\n        super().__init__()\n        self.transform = BertPredictionHeadTransform(config)\n\n        # The output weights are the same as the input embeddings, but there is\n        # an output-only bias for each token.\n        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)\n\n        self.bias = nn.Parameter(torch.zeros(config.vocab_size))\n\n        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`\n        self.decoder.bias = self.bias\n\n    def forward(self, hidden_states):\n        hidden_states = self.transform(hidden_states)\n        hidden_states = self.decoder(hidden_states)\n        return hidden_states\n'






class 					lowercase__ (			unittest.TestCase       ):

   '''simple docstring'''


   def    UpperCamelCase__						(					self							)				->   Optional[Any]:






       """simple docstring"""
       UpperCamelCase__							:       Optional[Any]      =   tempfile.mkdtemp()
       os.makedirs(os.path.join(self.transformer_dir,	'''models/bert/'''							)							)
       UpperCamelCase__							:       Optional[Any]      =   self.transformer_dir
       shutil.copy(
           os.path.join(__magic_name__,	'''src/transformers/models/bert/modeling_bert.py'''							),	os.path.join(self.transformer_dir,	'''models/bert/modeling_bert.py'''							),	)




   def    UpperCamelCase__						(					self							)				->   List[Any]:






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   '''src/transformers'''
       shutil.rmtree(self.transformer_dir							)




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__,	__magic_name__=None							)				->   Tuple:






       """simple docstring"""
       UpperCamelCase__							:       int      =   comment + f"\nclass {class_name}(nn.Module):\n" + class_code
       if overwrite_result is not None:
           UpperCamelCase__							:       str      =   comment + f"\nclass {class_name}(nn.Module):\n" + overwrite_result
       UpperCamelCase__							:       int      =   black.Mode(target_versions={black.TargetVersion.PYaa},	line_length=119							)
       UpperCamelCase__							:       str      =   black.format_str(__magic_name__,	mode=__magic_name__							)
       UpperCamelCase__							:       Any      =   os.path.join(self.transformer_dir,	'''new_code.py'''							)
       with open(__magic_name__,	'''w''',	newline='''\n'''							) as f:
           f.write(__magic_name__							)
       if overwrite_result is None:
           self.assertTrue(len(check_copies.is_copy_consistent(__magic_name__							)							) == 0							)
       else:
           check_copies.is_copy_consistent(f.name,	overwrite=__magic_name__							)
           with open(__magic_name__,	'''r'''							) as f:
               self.assertTrue(f.read(),	__magic_name__							)




   def    UpperCamelCase__						(					self							)				->   List[Any]:






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   check_copies.find_code_in_transformers('''models.bert.modeling_bert.BertLMPredictionHead'''							)
       self.assertEqual(__magic_name__,	__magic_name__							)




   def    UpperCamelCase__						(					self							)				->   str:






       """simple docstring"""
       # Base copy consistency
       self.check_copy_consistency(
           '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead''',	'''BertLMPredictionHead''',	REFERENCE_CODE + '''\n''',	)

       # With no empty line at the end
       self.check_copy_consistency(
           '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead''',	'''BertLMPredictionHead''',	__magic_name__,	)

       # Copy consistency with rename
       self.check_copy_consistency(
           '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel''',	'''TestModelLMPredictionHead''',	re.sub('''Bert''',	'''TestModel''',	__magic_name__							),	)

       # Copy consistency with a really long name
       UpperCamelCase__							:       List[str]      =   '''TestModelWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason'''
       self.check_copy_consistency(
           f"# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->{long_class_name}",	f"{long_class_name}LMPredictionHead",	re.sub('''Bert''',	__magic_name__,	__magic_name__							),	)

       # Copy consistency with overwrite
       self.check_copy_consistency(
           '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel''',	'''TestModelLMPredictionHead''',	__magic_name__,	overwrite_result=re.sub('''Bert''',	'''TestModel''',	__magic_name__							),	)




   def    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   check_copies.LOCALIZED_READMES['''README_zh-hans.md''']

       UpperCamelCase__							:       Optional[int]      =   (
           '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the'''
           ''' Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for'''
           ''' Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong'''
           ''' Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.\n1.'''
           ''' **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (from HuggingFace),'''
           ''' released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and'''
           ''' lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same'''
           ''' method has been applied to compress GPT2 into'''
           ''' [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into'''
           ''' [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),'''
           ''' Multilingual BERT into'''
           ''' [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German'''
           ''' version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)**'''
           ''' (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders'''
           ''' as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang'''
           ''' Luong, Quoc V. Le, Christopher D. Manning.'''
       )
       UpperCamelCase__							:       Optional[Any]      =   (
           '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'''
           ''' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
           ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
           ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'''
       )
       UpperCamelCase__							:       List[str]      =   (
           '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'''
           ''' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
           ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
           ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n1.'''
           ''' **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (来自 HuggingFace) 伴随论文'''
           ''' [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and'''
           ''' lighter](https://arxiv.org/abs/1910.01108) 由 Victor Sanh, Lysandre Debut and Thomas Wolf 发布。 The same'''
           ''' method has been applied to compress GPT2 into'''
           ''' [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into'''
           ''' [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),'''
           ''' Multilingual BERT into'''
           ''' [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German'''
           ''' version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)** (来自'''
           ''' Google Research/Stanford University) 伴随论文 [ELECTRA: Pre-training text encoders as discriminators rather'''
           ''' than generators](https://arxiv.org/abs/2003.10555) 由 Kevin Clark, Minh-Thang Luong, Quoc V. Le,'''
           ''' Christopher D. Manning 发布。\n'''
       )

       UpperCamelCase__     ,UpperCamelCase__							:       Any      =   check_copies.convert_to_localized_md(
           __magic_name__,	__magic_name__,	localized_readme['''format_model_list''']							)

       self.assertFalse(__magic_name__							)
       self.assertEqual(__magic_name__,	__magic_name__							)

       UpperCamelCase__     ,UpperCamelCase__							:       Any      =   check_copies.convert_to_localized_md(
           __magic_name__,	__magic_name__,	localized_readme['''format_model_list''']							)

       # Check whether the number of models is equal to README.md after conversion.
       self.assertTrue(__magic_name__							)

       UpperCamelCase__							:       Any      =   (
           '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the'''
           ''' Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for'''
           ''' Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong'''
           ''' Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.'''
       )
       UpperCamelCase__							:       List[str]      =   (
           '''1. **[ALBERT](https://huggingface.co/transformers/main/model_doc/albert.html)** (来自 Google Research and'''
           ''' the Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
           ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
           ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'''
       )
       UpperCamelCase__							:       List[str]      =   (
           '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'''
           ''' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
           ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
           ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'''
       )

       UpperCamelCase__     ,UpperCamelCase__							:       Any      =   check_copies.convert_to_localized_md(
           __magic_name__,	__magic_name__,	localized_readme['''format_model_list''']							)

       # Check if the model link is synchronized.
       self.assertEqual(__magic_name__,	__magic_name__							)








import argparse

from transformers import (
    TapasConfig,
    TapasForMaskedLM,
    TapasForQuestionAnswering,
    TapasForSequenceClassification,
    TapasModel,
    TapasTokenizer,
    load_tf_weights_in_tapas,
)
from transformers.utils import logging


logging.set_verbosity_info()




def 	lowerCAmelCase_					(						__UpperCAmelCase:    Optional[Any]	,     __UpperCAmelCase:    List[str]	,     __UpperCAmelCase:    Dict	,     __UpperCAmelCase:    Tuple	,     __UpperCAmelCase:    str   )   ->			Optional[int]:
    # Initialise PyTorch model.
    # If you want to convert a checkpoint that uses absolute position embeddings, make sure to set reset_position_index_per_cell of
    # TapasConfig to False.

    # initialize configuration from json file
    UpperCamelCase__							:       Any      =   TapasConfig.from_json_file(__UpperCAmelCase   )
    # set absolute/relative position embeddings parameter
    UpperCamelCase__							:       Optional[Any]      =   reset_position_index_per_cell

    # set remaining parameters of TapasConfig as well as the model based on the task
    if task == "SQA":
        UpperCamelCase__							:       List[Any]      =   TapasForQuestionAnswering(config=__UpperCAmelCase   )
    elif task == "WTQ":
        # run_task_main.py hparams
        UpperCamelCase__							:       Any      =   4
        UpperCamelCase__							:       List[str]      =   True
        # hparam_utils.py hparams
        UpperCamelCase__							:       int      =   0.664694
        UpperCamelCase__							:       Union[str, Any]      =   0.207951
        UpperCamelCase__							:       Any      =   0.121194
        UpperCamelCase__							:       int      =   True
        UpperCamelCase__							:       Any      =   True
        UpperCamelCase__							:       str      =   False
        UpperCamelCase__							:       int      =   0.0352513

        UpperCamelCase__							:       Dict      =   TapasForQuestionAnswering(config=__UpperCAmelCase   )
    elif task == "WIKISQL_SUPERVISED":
        # run_task_main.py hparams
        UpperCamelCase__							:       Any      =   4
        UpperCamelCase__							:       List[str]      =   False
        # hparam_utils.py hparams
        UpperCamelCase__							:       int      =   36.4519
        UpperCamelCase__							:       int      =   0.903421
        UpperCamelCase__							:       List[str]      =   222.088
        UpperCamelCase__							:       Dict      =   True
        UpperCamelCase__							:       List[str]      =   True
        UpperCamelCase__							:       Any      =   True
        UpperCamelCase__							:       int      =   0.763141

        UpperCamelCase__							:       Union[str, Any]      =   TapasForQuestionAnswering(config=__UpperCAmelCase   )
    elif task == "TABFACT":
        UpperCamelCase__							:       List[Any]      =   TapasForSequenceClassification(config=__UpperCAmelCase   )
    elif task == "MLM":
        UpperCamelCase__							:       Optional[Any]      =   TapasForMaskedLM(config=__UpperCAmelCase   )
    elif task == "INTERMEDIATE_PRETRAINING":
        UpperCamelCase__							:       str      =   TapasModel(config=__UpperCAmelCase   )
    else:
        raise ValueError(f"Task {task} not supported."   )

    print(f"Building PyTorch model from configuration: {config}"   )
    # Load weights from tf checkpoint
    load_tf_weights_in_tapas(__UpperCAmelCase	,     __UpperCAmelCase	,     __UpperCAmelCase   )

    # Save pytorch-model (weights and configuration)
    print(f"Save PyTorch model to {pytorch_dump_path}"   )
    model.save_pretrained(__UpperCAmelCase   )

    # Save tokenizer files
    print(f"Save tokenizer files to {pytorch_dump_path}"   )
    UpperCamelCase__							:       str      =   TapasTokenizer(vocab_file=tf_checkpoint_path[:-10] + '''vocab.txt'''	,     model_max_length=512   )
    tokenizer.save_pretrained(__UpperCAmelCase   )

    print('''Used relative position embeddings:'''	,     model.config.reset_position_index_per_cell   )


if __name__ == "__main__":
  UpperCAmelCase_  							=				argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '--task', default='SQA', type=str, help='Model task for which to convert a checkpoint. Defaults to SQA.'
  )
  parser.add_argument(
      '--reset_position_index_per_cell',
      default=False,
      action='store_true',
      help='Whether to use relative position embeddings or not. Defaults to True.',
  )
  parser.add_argument(
      '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
  )
  parser.add_argument(
      '--tapas_config_file',
      default=None,
      type=str,
      required=True,
      help=(
          'The config json file corresponding to the pre-trained TAPAS model. \n'
          'This specifies the model architecture.'
      ),
  )
  parser.add_argument(
      '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
  )
  UpperCAmelCase_  							=				parser.parse_args()
  convert_tf_checkpoint_to_pytorch(
      args.task,
      args.reset_position_index_per_cell,
      args.tf_checkpoint_path,
      args.tapas_config_file,
      args.pytorch_dump_path,
  )

