






'''simple docstring'''







def       __UpperCamelCase					(      lowercase_       :  int = 100   ):
       """simple docstring"""




       a_						     =			0
       a_						     =			0
       for i in range(1   ,       n + 1   ):
              sum_of_squares += i**2
              sum_of_ints += i
       return sum_of_ints**2 - sum_of_squares


if __name__ == "__main__":
  print(f"""{solution() = }""")












'''simple docstring'''







import argparse
from collections import OrderedDict
from pathlib import Path

import torch

from transformers import (
    VisualBertConfig,
    VisualBertForMultipleChoice,
    VisualBertForPreTraining,
    VisualBertForQuestionAnswering,
    VisualBertForVisualReasoning,
)
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCAmelCase        =							logging.get_logger(__name__)

__lowerCAmelCase        =							[
    ("bert.bert", "visual_bert"),
    ("bert.cls", "cls"),
    ("bert.classifier", "cls"),
    ("token_type_embeddings_visual", "visual_token_type_embeddings"),
    ("position_embeddings_visual", "visual_position_embeddings"),
    ("projection", "visual_projection"),
]

__lowerCAmelCase        =							[
    "nlvr2_coco_pre_trained.th",
    "nlvr2_fine_tuned.th",
    "nlvr2_pre_trained.th",
    "vcr_coco_pre_train.th",
    "vcr_fine_tune.th",
    "vcr_pre_train.th",
    "vqa_coco_pre_trained.th",
    "vqa_fine_tuned.th",
    "vqa_pre_trained.th",
]


def       __UpperCamelCase					(      lowercase_       :  int   ):
       """simple docstring"""




       a_						     =			torch.load(lowercase_   ,       map_location='cpu'   )
       return sd


def       __UpperCamelCase					(      lowercase_       :  List[str]   ,       lowercase_       :  Tuple   ,       lowercase_       :  Union[str, Any]=rename_keys_prefix   ):
       """simple docstring"""




       a_						     =			OrderedDict()
       a_						     =			torch.arange(config.max_position_embeddings   ).expand((1, -1)   )
       # detector_d = OrderedDict()
       for key in d:
              if "detector" in key:
                     # detector_d[key.replace('detector.','')] = d[key]
                     continue
              a_						     =			key
              for name_pair in rename_keys_prefix:
                     a_						     =			new_key.replace(name_pair[0]   ,       name_pair[1]   )
              a_						     =			d[key]
              if key == "bert.cls.predictions.decoder.weight":
                     # Old bert code didn't have `decoder.bias`, but was added separately
                     a_						     =			new_d['cls.predictions.bias']
       return new_d


@torch.no_grad()
def       __UpperCamelCase					(      lowercase_       :  Union[str, Any]   ,       lowercase_       :  Union[str, Any]   ):
       """simple docstring"""




       assert (
           checkpoint_path.split('/'   )[-1] in ACCEPTABLE_CHECKPOINTS
       ), F'The checkpoint provided must be in {ACCEPTABLE_CHECKPOINTS}.'

       # Get Config
       if "pre" in checkpoint_path:
              a_						     =			'pretraining'
              if "vcr" in checkpoint_path:
                     a_						     =			{'visual_embedding_dim': 512}
              elif "vqa_advanced" in checkpoint_path:
                     a_						     =			{'visual_embedding_dim': 2_048}
              elif "vqa" in checkpoint_path:
                     a_						     =			{'visual_embedding_dim': 2_048}
              elif "nlvr" in checkpoint_path:
                     a_						     =			{'visual_embedding_dim': 1_024}
              else:
                     raise NotImplementedError(F'No implementation found for `{checkpoint_path}`.'   )
       else:
              if "vcr" in checkpoint_path:
                     a_						     =			{'visual_embedding_dim': 512}
                     a_						     =			'multichoice'
              elif "vqa_advanced" in checkpoint_path:
                     a_						     =			{'visual_embedding_dim': 2_048}
                     a_						     =			'vqa_advanced'
              elif "vqa" in checkpoint_path:
                     a_						     =			{'visual_embedding_dim': 2_048, 'num_labels': 3_129}
                     a_						     =			'vqa'
              elif "nlvr" in checkpoint_path:
                     a_						     =			{
                         'visual_embedding_dim': 1_024,
                         'num_labels': 2,
                     }
                     a_						     =			'nlvr'

       a_						     =			VisualBertConfig(**lowercase_   )

       # Load State Dict
       a_						     =			load_state_dict(lowercase_   )

       a_						     =			get_new_dict(lowercase_   ,       lowercase_   )

       if model_type == "pretraining":
              a_						     =			VisualBertForPreTraining(lowercase_   )
       elif model_type == "vqa":
              a_						     =			VisualBertForQuestionAnswering(lowercase_   )
       elif model_type == "nlvr":
              a_						     =			VisualBertForVisualReasoning(lowercase_   )
       elif model_type == "multichoice":
              a_						     =			VisualBertForMultipleChoice(lowercase_   )

       model.load_state_dict(lowercase_   )
       # Save Checkpoints
       Path(lowercase_   ).mkdir(exist_ok=lowercase_   )
       model.save_pretrained(lowercase_   )


if __name__ == "__main__":
  __lowerCAmelCase        =							argparse.ArgumentParser()
  # Required parameters
  parser.add_argument("orig_checkpoint_path", type=str, help="A path to .th on local filesystem.")
  parser.add_argument("pytorch_dump_folder_path", type=str, help="Path to the output PyTorch model.")
  __lowerCAmelCase        =							parser.parse_args()
  convert_visual_bert_checkpoint(args.orig_checkpoint_path, args.pytorch_dump_folder_path)




