



"""simple docstring"""




import argparse
import json

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    VideoMAEConfig,
    VideoMAEForPreTraining,
    VideoMAEForVideoClassification,
    VideoMAEImageProcessor,
)

def 		__snake_case		( SCREAMING_SNAKE_CASE__      :		Dict							)    ->  Any:





     '''simple docstring'''

     _UpperCAmelCase     :      Tuple														=       VideoMAEConfig()

     set_architecture_configs(SCREAMING_SNAKE_CASE__		,    SCREAMING_SNAKE_CASE__							)

     if "finetuned" not in model_name:
          _UpperCAmelCase     :      Optional[Any]														=       False

     if "finetuned" in model_name:
          _UpperCAmelCase     :      Optional[int]														=       "huggingface/label-files"
          if "kinetics" in model_name:
               _UpperCAmelCase     :      Any														=       400
               _UpperCAmelCase     :      str														=       "kinetics400-id2label.json"
          elif "ssv2" in model_name:
               _UpperCAmelCase     :      int														=       174
               _UpperCAmelCase     :      List[Any]														=       "something-something-v2-id2label.json"
          else:
               raise ValueError("Model name should either contain 'kinetics' or 'ssv2' in case it's fine-tuned."							)
          _UpperCAmelCase     :      Dict														=       json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE__		,    SCREAMING_SNAKE_CASE__		,    repo_type="dataset"							)		,    "r"							)							)
          _UpperCAmelCase     :      Optional[Any]														=       {int(SCREAMING_SNAKE_CASE__							): v for k, v in idalabel.items()}
          _UpperCAmelCase     :      str														=       idalabel
          _UpperCAmelCase     :      int														=       {v: k for k, v in idalabel.items()}

     return config

def 		__snake_case		( SCREAMING_SNAKE_CASE__      :		Tuple		,    SCREAMING_SNAKE_CASE__      :		Optional[Any]							)    ->  Optional[int]:





     '''simple docstring'''

     if "small" in model_name:
          _UpperCAmelCase     :      str														=       384
          _UpperCAmelCase     :      Dict														=       1_536
          _UpperCAmelCase     :      Optional[Any]														=       12
          _UpperCAmelCase     :      Any														=       16
          _UpperCAmelCase     :      Optional[Any]														=       12
          _UpperCAmelCase     :      int														=       3
          _UpperCAmelCase     :      Union[str, Any]														=       192
          _UpperCAmelCase     :      List[Any]														=       768
     elif "large" in model_name:
          _UpperCAmelCase     :      Dict														=       1_024
          _UpperCAmelCase     :      Any														=       4_096
          _UpperCAmelCase     :      Optional[Any]														=       24
          _UpperCAmelCase     :      str														=       16
          _UpperCAmelCase     :      Optional[Any]														=       12
          _UpperCAmelCase     :      Dict														=       8
          _UpperCAmelCase     :      Optional[int]														=       512
          _UpperCAmelCase     :      Optional[Any]														=       2_048
     elif "huge" in model_name:
          _UpperCAmelCase     :      Optional[int]														=       1_280
          _UpperCAmelCase     :      str														=       5_120
          _UpperCAmelCase     :      int														=       32
          _UpperCAmelCase     :      Union[str, Any]														=       16
          _UpperCAmelCase     :      Union[str, Any]														=       12
          _UpperCAmelCase     :      str														=       8
          _UpperCAmelCase     :      Dict														=       640
          _UpperCAmelCase     :      List[Any]														=       2_560
     elif "base" not in model_name:
          raise ValueError("Model name should include either \"small\", \"base\", \"large\", or \"huge\""							)

def 		__snake_case		( SCREAMING_SNAKE_CASE__      :		List[Any]							)    ->  Any:





     '''simple docstring'''

     if "encoder." in name:
          _UpperCAmelCase     :      Optional[Any]														=       name.replace("encoder."		,    ""							)
     if "cls_token" in name:
          _UpperCAmelCase     :      Tuple														=       name.replace("cls_token"		,    "videomae.embeddings.cls_token"							)
     if "decoder_pos_embed" in name:
          _UpperCAmelCase     :      Optional[int]														=       name.replace("decoder_pos_embed"		,    "decoder.decoder_pos_embed"							)
     if "pos_embed" in name and "decoder" not in name:
          _UpperCAmelCase     :      Optional[int]														=       name.replace("pos_embed"		,    "videomae.embeddings.position_embeddings"							)
     if "patch_embed.proj" in name:
          _UpperCAmelCase     :      Optional[Any]														=       name.replace("patch_embed.proj"		,    "videomae.embeddings.patch_embeddings.projection"							)
     if "patch_embed.norm" in name:
          _UpperCAmelCase     :      Tuple														=       name.replace("patch_embed.norm"		,    "videomae.embeddings.norm"							)
     if "decoder.blocks" in name:
          _UpperCAmelCase     :      List[Any]														=       name.replace("decoder.blocks"		,    "decoder.decoder_layers"							)
     if "blocks" in name:
          _UpperCAmelCase     :      Optional[int]														=       name.replace("blocks"		,    "videomae.encoder.layer"							)
     if "attn.proj" in name:
          _UpperCAmelCase     :      int														=       name.replace("attn.proj"		,    "attention.output.dense"							)
     if "attn" in name and "bias" not in name:
          _UpperCAmelCase     :      Optional[Any]														=       name.replace("attn"		,    "attention.self"							)
     if "attn" in name:
          _UpperCAmelCase     :      List[str]														=       name.replace("attn"		,    "attention.attention"							)
     if "norm1" in name:
          _UpperCAmelCase     :      List[Any]														=       name.replace("norm1"		,    "layernorm_before"							)
     if "norm2" in name:
          _UpperCAmelCase     :      Any														=       name.replace("norm2"		,    "layernorm_after"							)
     if "mlp.fc1" in name:
          _UpperCAmelCase     :      List[str]														=       name.replace("mlp.fc1"		,    "intermediate.dense"							)
     if "mlp.fc2" in name:
          _UpperCAmelCase     :      str														=       name.replace("mlp.fc2"		,    "output.dense"							)
     if "decoder_embed" in name:
          _UpperCAmelCase     :      List[Any]														=       name.replace("decoder_embed"		,    "decoder.decoder_embed"							)
     if "decoder_norm" in name:
          _UpperCAmelCase     :      Dict														=       name.replace("decoder_norm"		,    "decoder.decoder_norm"							)
     if "decoder_pred" in name:
          _UpperCAmelCase     :      List[str]														=       name.replace("decoder_pred"		,    "decoder.decoder_pred"							)
     if "norm.weight" in name and "decoder" not in name and "fc" not in name:
          _UpperCAmelCase     :      Dict														=       name.replace("norm.weight"		,    "videomae.layernorm.weight"							)
     if "norm.bias" in name and "decoder" not in name and "fc" not in name:
          _UpperCAmelCase     :      Optional[Any]														=       name.replace("norm.bias"		,    "videomae.layernorm.bias"							)
     if "head" in name and "decoder" not in name:
          _UpperCAmelCase     :      Any														=       name.replace("head"		,    "classifier"							)

     return name

def 		__snake_case		( SCREAMING_SNAKE_CASE__      :		Optional[Any]		,    SCREAMING_SNAKE_CASE__      :		Optional[Any]							)    ->  Any:





     '''simple docstring'''

     for key in orig_state_dict.copy().keys():
          _UpperCAmelCase     :      Tuple														=       orig_state_dict.pop(SCREAMING_SNAKE_CASE__							)

          if key.startswith("encoder."							):
               _UpperCAmelCase     :      List[str]														=       key.replace("encoder."		,    ""							)

          if "qkv" in key:
               _UpperCAmelCase     :      List[Any]														=       key.split("."							)
               if key.startswith("decoder.blocks"							):
                    _UpperCAmelCase     :      List[Any]														=       config.decoder_hidden_size
                    _UpperCAmelCase     :      List[Any]														=       int(key_split[2]							)
                    _UpperCAmelCase     :      int														=       "decoder.decoder_layers."
                    if "weight" in key:
                         _UpperCAmelCase     :      Any														=       val[:dim, :]
                         _UpperCAmelCase     :      Dict														=       val[dim : dim * 2, :]
                         _UpperCAmelCase     :      Any														=       val[-dim:, :]
               else:
                    _UpperCAmelCase     :      str														=       config.hidden_size
                    _UpperCAmelCase     :      Tuple														=       int(key_split[1]							)
                    _UpperCAmelCase     :      Optional[int]														=       "videomae.encoder.layer."
                    if "weight" in key:
                         _UpperCAmelCase     :      Optional[int]														=       val[:dim, :]
                         _UpperCAmelCase     :      Tuple														=       val[dim : dim * 2, :]
                         _UpperCAmelCase     :      Any														=       val[-dim:, :]
          else:
               _UpperCAmelCase     :      Dict														=       val

     return orig_state_dict

def 		__snake_case		( )    ->  List[Any]:





     '''simple docstring'''

     _UpperCAmelCase     :      Optional[int]														=       hf_hub_download(
         repo_id="hf-internal-testing/spaghetti-video"		,    filename="eating_spaghetti.npy"		,    repo_type="dataset"							)
     _UpperCAmelCase     :      Optional[Any]														=       np.load(SCREAMING_SNAKE_CASE__							)
     return list(SCREAMING_SNAKE_CASE__							)

def 		__snake_case		( SCREAMING_SNAKE_CASE__      :		Any		,    SCREAMING_SNAKE_CASE__      :		Union[str, Any]		,    SCREAMING_SNAKE_CASE__      :		Optional[int]		,    SCREAMING_SNAKE_CASE__      :		Any							)    ->  Any:





     '''simple docstring'''

     _UpperCAmelCase     :      int														=       get_videomae_config(SCREAMING_SNAKE_CASE__							)

     if "finetuned" in model_name:
          _UpperCAmelCase     :      Union[str, Any]														=       VideoMAEForVideoClassification(SCREAMING_SNAKE_CASE__							)
     else:
          _UpperCAmelCase     :      List[str]														=       VideoMAEForPreTraining(SCREAMING_SNAKE_CASE__							)

     # download original checkpoint, hosted on Google Drive
     _UpperCAmelCase     :      Optional[Any]														=       "pytorch_model.bin"
     gdown.cached_download(SCREAMING_SNAKE_CASE__		,    SCREAMING_SNAKE_CASE__		,    quiet=SCREAMING_SNAKE_CASE__							)
     _UpperCAmelCase     :      Optional[int]														=       torch.load(SCREAMING_SNAKE_CASE__		,    map_location="cpu"							)
     if "model" in files:
          _UpperCAmelCase     :      Optional[Any]														=       files["model"]
     else:
          _UpperCAmelCase     :      int														=       files["module"]
     _UpperCAmelCase     :      Union[str, Any]														=       convert_state_dict(SCREAMING_SNAKE_CASE__		,    SCREAMING_SNAKE_CASE__							)

     model.load_state_dict(SCREAMING_SNAKE_CASE__							)
     model.eval()

     # verify model on basic input
     _UpperCAmelCase     :      Tuple														=       VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]		,    image_std=[0.5, 0.5, 0.5]							)
     _UpperCAmelCase     :      Optional[int]														=       prepare_video()
     _UpperCAmelCase     :      Dict														=       image_processor(SCREAMING_SNAKE_CASE__		,    return_tensors="pt"							)

     if "finetuned" not in model_name:
          _UpperCAmelCase     :      Optional[int]														=       hf_hub_download(repo_id="hf-internal-testing/bool-masked-pos"		,    filename="bool_masked_pos.pt"							)
          _UpperCAmelCase     :      List[str]														=       torch.load(SCREAMING_SNAKE_CASE__							)

     _UpperCAmelCase     :      List[Any]														=       model(**SCREAMING_SNAKE_CASE__							)
     _UpperCAmelCase     :      Any														=       outputs.logits

     _UpperCAmelCase     :      Optional[int]														=       [
         "videomae-small-finetuned-kinetics",
         "videomae-small-finetuned-ssv2",
         # Kinetics-400 checkpoints (short = pretrained only for 800 epochs instead of 1600)
         "videomae-base-short",
         "videomae-base-short-finetuned-kinetics",
         "videomae-base",
         "videomae-base-finetuned-kinetics",
         "videomae-large",
         "videomae-large-finetuned-kinetics",
         "videomae-huge-finetuned-kinetics",
         # Something-Something-v2 checkpoints (short = pretrained only for 800 epochs instead of 2400)
         "videomae-base-short-ssv2",
         "videomae-base-short-finetuned-ssv2",
         "videomae-base-ssv2",
         "videomae-base-finetuned-ssv2",
     ]

     # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
     if model_name == "videomae-small-finetuned-kinetics":
          _UpperCAmelCase     :      str														=       torch.Size([1, 400]							)
          _UpperCAmelCase     :      int														=       torch.tensor([-0.9_291, -0.4_061, -0.9_307]							)
     elif model_name == "videomae-small-finetuned-ssv2":
          _UpperCAmelCase     :      Optional[int]														=       torch.Size([1, 174]							)
          _UpperCAmelCase     :      Dict														=       torch.tensor([0.2_671, -0.4_689, -0.8_235]							)
     elif model_name == "videomae-base":
          _UpperCAmelCase     :      List[Any]														=       torch.Size([1, 1_408, 1_536]							)
          _UpperCAmelCase     :      int														=       torch.tensor([[0.7_739, 0.7_968, 0.7_089], [0.6_701, 0.7_487, 0.6_209], [0.4_287, 0.5_158, 0.4_773]]							)
     elif model_name == "videomae-base-short":
          _UpperCAmelCase     :      int														=       torch.Size([1, 1_408, 1_536]							)
          _UpperCAmelCase     :      int														=       torch.tensor([[0.7_994, 0.9_612, 0.8_508], [0.7_401, 0.8_958, 0.8_302], [0.5_862, 0.7_468, 0.7_325]]							)
          # we verified the loss both for normalized and unnormalized targets for this one
          _UpperCAmelCase     :      List[Any]														=       torch.tensor([0.5_142]							) if config.norm_pix_loss else torch.tensor([0.6_469]							)
     elif model_name == "videomae-large":
          _UpperCAmelCase     :      str														=       torch.Size([1, 1_408, 1_536]							)
          _UpperCAmelCase     :      Any														=       torch.tensor([[0.7_149, 0.7_997, 0.6_966], [0.6_768, 0.7_869, 0.6_948], [0.5_139, 0.6_221, 0.5_605]]							)
     elif model_name == "videomae-large-finetuned-kinetics":
          _UpperCAmelCase     :      Optional[Any]														=       torch.Size([1, 400]							)
          _UpperCAmelCase     :      List[str]														=       torch.tensor([0.0_771, 0.0_011, -0.3_625]							)
     elif model_name == "videomae-huge-finetuned-kinetics":
          _UpperCAmelCase     :      Optional[int]														=       torch.Size([1, 400]							)
          _UpperCAmelCase     :      List[str]														=       torch.tensor([0.2_433, 0.1_632, -0.4_894]							)
     elif model_name == "videomae-base-short-finetuned-kinetics":
          _UpperCAmelCase     :      Any														=       torch.Size([1, 400]							)
          _UpperCAmelCase     :      Optional[Any]														=       torch.tensor([0.6_588, 0.0_990, -0.2_493]							)
     elif model_name == "videomae-base-finetuned-kinetics":
          _UpperCAmelCase     :      List[Any]														=       torch.Size([1, 400]							)
          _UpperCAmelCase     :      Any														=       torch.tensor([0.3_669, -0.0_688, -0.2_421]							)
     elif model_name == "videomae-base-short-ssv2":
          _UpperCAmelCase     :      Any														=       torch.Size([1, 1_408, 1_536]							)
          _UpperCAmelCase     :      List[str]														=       torch.tensor([[0.4_712, 0.5_296, 0.5_786], [0.2_278, 0.2_729, 0.4_026], [0.0_352, 0.0_730, 0.2_506]]							)
     elif model_name == "videomae-base-short-finetuned-ssv2":
          _UpperCAmelCase     :      Optional[Any]														=       torch.Size([1, 174]							)
          _UpperCAmelCase     :      str														=       torch.tensor([-0.0_537, -0.1_539, -0.3_266]							)
     elif model_name == "videomae-base-ssv2":
          _UpperCAmelCase     :      List[str]														=       torch.Size([1, 1_408, 1_536]							)
          _UpperCAmelCase     :      str														=       torch.tensor([[0.8_131, 0.8_727, 0.8_546], [0.7_366, 0.9_377, 0.8_870], [0.5_935, 0.8_874, 0.8_564]]							)
     elif model_name == "videomae-base-finetuned-ssv2":
          _UpperCAmelCase     :      Union[str, Any]														=       torch.Size([1, 174]							)
          _UpperCAmelCase     :      Optional[Any]														=       torch.tensor([0.1_961, -0.8_337, -0.6_389]							)
     else:
          raise ValueError(f'Model name not supported. Should be one of {model_names}'							)

     # verify logits
     assert logits.shape == expected_shape
     if "finetuned" in model_name:
          assert torch.allclose(logits[0, :3]		,    SCREAMING_SNAKE_CASE__		,    atol=1E-4							)
     else:
          print("Logits:"		,    logits[0, :3, :3]							)
          assert torch.allclose(logits[0, :3, :3]		,    SCREAMING_SNAKE_CASE__		,    atol=1E-4							)
     print("Logits ok!"							)

     # verify loss, if applicable
     if model_name == "videomae-base-short":
          _UpperCAmelCase     :      Union[str, Any]														=       outputs.loss
          assert torch.allclose(SCREAMING_SNAKE_CASE__		,    SCREAMING_SNAKE_CASE__		,    atol=1E-4							)
          print("Loss ok!"							)

     if pytorch_dump_folder_path is not None:
          print(f'Saving model and image processor to {pytorch_dump_folder_path}'							)
          image_processor.save_pretrained(SCREAMING_SNAKE_CASE__							)
          model.save_pretrained(SCREAMING_SNAKE_CASE__							)

     if push_to_hub:
          print("Pushing to the hub..."							)
          model.push_to_hub(SCREAMING_SNAKE_CASE__		,    organization="nielsr"							)


if __name__ == "__main__":
 _lowerCAmelCase							:   Any				=				argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     "--checkpoint_url",
     default="https://drive.google.com/u/1/uc?id=1tEhLyskjb755TJ65ptsrafUG2llSwQE1&amp;export=download&amp;confirm=t&amp;uuid=aa3276eb-fb7e-482a-adec-dc7171df14c4",
     type=str,
     help=(
         "URL of the original PyTorch checkpoint (on Google Drive) you'd like to convert. Should be a direct"
         " download link."
     ),
 )
 parser.add_argument(
     "--pytorch_dump_folder_path",
     default="/Users/nielsrogge/Documents/VideoMAE/Test",
     type=str,
     help="Path to the output PyTorch model directory.",
 )
 parser.add_argument("--model_name", default="videomae-base", type=str, help="Name of the model.")
 parser.add_argument(
     "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
 )

 _lowerCAmelCase							:   str				=				parser.parse_args()
 convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)





"""simple docstring"""




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 		__snake_case		( SCREAMING_SNAKE_CASE__      :		Any		,    SCREAMING_SNAKE_CASE__      :		Union[str, Any]		,    SCREAMING_SNAKE_CASE__      :		int		,    SCREAMING_SNAKE_CASE__      :		Optional[int]		,    SCREAMING_SNAKE_CASE__      :		Any							)    ->  Any:





     '''simple docstring'''

     _UpperCAmelCase     :      Any														=       TapasConfig.from_json_file(SCREAMING_SNAKE_CASE__							)
     # 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     :      Optional[int]														=       TapasForQuestionAnswering(config=SCREAMING_SNAKE_CASE__							)
     elif task == "WTQ":
          # run_task_main.py hparams
          _UpperCAmelCase     :      List[str]														=       4
          _UpperCAmelCase     :      int														=       True
          # hparam_utils.py hparams
          _UpperCAmelCase     :      Optional[int]														=       0.664_694
          _UpperCAmelCase     :      Any														=       0.207_951
          _UpperCAmelCase     :      Any														=       0.121_194
          _UpperCAmelCase     :      List[Any]														=       True
          _UpperCAmelCase     :      Dict														=       True
          _UpperCAmelCase     :      Tuple														=       False
          _UpperCAmelCase     :      List[Any]														=       0.0_352_513

          _UpperCAmelCase     :      Union[str, Any]														=       TapasForQuestionAnswering(config=SCREAMING_SNAKE_CASE__							)
     elif task == "WIKISQL_SUPERVISED":
          # run_task_main.py hparams
          _UpperCAmelCase     :      List[str]														=       4
          _UpperCAmelCase     :      Optional[int]														=       False
          # hparam_utils.py hparams
          _UpperCAmelCase     :      List[Any]														=       36.4_519
          _UpperCAmelCase     :      Union[str, Any]														=       0.903_421
          _UpperCAmelCase     :      List[Any]														=       222.088
          _UpperCAmelCase     :      Optional[Any]														=       True
          _UpperCAmelCase     :      str														=       True
          _UpperCAmelCase     :      Union[str, Any]														=       True
          _UpperCAmelCase     :      str														=       0.763_141

          _UpperCAmelCase     :      Optional[Any]														=       TapasForQuestionAnswering(config=SCREAMING_SNAKE_CASE__							)
     elif task == "TABFACT":
          _UpperCAmelCase     :      int														=       TapasForSequenceClassification(config=SCREAMING_SNAKE_CASE__							)
     elif task == "MLM":
          _UpperCAmelCase     :      List[str]														=       TapasForMaskedLM(config=SCREAMING_SNAKE_CASE__							)
     elif task == "INTERMEDIATE_PRETRAINING":
          _UpperCAmelCase     :      Optional[Any]														=       TapasModel(config=SCREAMING_SNAKE_CASE__							)
     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(SCREAMING_SNAKE_CASE__		,    SCREAMING_SNAKE_CASE__		,    SCREAMING_SNAKE_CASE__							)

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

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

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


if __name__ == "__main__":
 _lowerCAmelCase							:   Union[str, Any]				=				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."
 )
 _lowerCAmelCase							:   Tuple				=				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,
 )
