






"""simple docstring"""



import argparse
import os

import torch

from transformers import FlavaConfig, FlavaForPreTraining
from transformers.models.flava.convert_dalle_to_flava_codebook import convert_dalle_checkpoint
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  Dict    ):





  '''simple docstring'''





  return sum(param.float().sum() if 'encoder.embeddings' not in key else 0 for key, param in state_dict.items()    )
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  Optional[Any]		,					__snake_case			:  int    ):





  '''simple docstring'''





  lowercase							    =       {}

  for key, value in state_dict.items():
    if "text_encoder.embeddings" in key or "image_encoder.embeddings" in key:
      continue

    lowercase							    =       key.replace('heads.cmd.mim_head.cls.predictions'		,					'mmm_image_head'    )
    lowercase							    =       key.replace('heads.cmd.mlm_head.cls.predictions'		,					'mmm_text_head'    )
    lowercase							    =       key.replace('heads.cmd.itm_head.cls'		,					'itm_head'    )
    lowercase							    =       key.replace('heads.cmd.itm_head.pooler'		,					'itm_head.pooler'    )
    lowercase							    =       key.replace('heads.cmd.clip_head.logit_scale'		,					'flava.logit_scale'    )
    lowercase							    =       key.replace('heads.fairseq_mlm.cls.predictions'		,					'mlm_head'    )
    lowercase							    =       key.replace('heads.imagenet.mim_head.cls.predictions'		,					'mim_head'    )
    lowercase							    =       key.replace('mm_text_projection'		,					'flava.text_to_mm_projection'    )
    lowercase							    =       key.replace('mm_image_projection'		,					'flava.image_to_mm_projection'    )
    lowercase							    =       key.replace('image_encoder.module'		,					'flava.image_model'    )
    lowercase							    =       key.replace('text_encoder.module'		,					'flava.text_model'    )
    lowercase							    =       key.replace('mm_encoder.module.encoder.cls_token'		,					'flava.multimodal_model.cls_token'    )
    lowercase							    =       key.replace('mm_encoder.module'		,					'flava.multimodal_model'    )
    lowercase							    =       key.replace('text_projection'		,					'flava.text_projection'    )
    lowercase							    =       key.replace('image_projection'		,					'flava.image_projection'    )

    lowercase							    =       value.float()

  for key, value in codebook_state_dict.items():
    lowercase							    =       value

  return upgrade
@torch.no_grad()
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  Union[str, Any]		,					__snake_case			:  int		,					__snake_case			:  Optional[int]		,					__snake_case			:  List[Any]=None    ):





  '''simple docstring'''





  if config_path is not None:
    lowercase							    =       FlavaConfig.from_pretrained(__snake_case    )
  else:
    lowercase							    =       FlavaConfig()

  lowercase							    =       FlavaForPreTraining(__snake_case    ).eval()

  lowercase							    =       convert_dalle_checkpoint(__snake_case		,					__snake_case		,					save_checkpoint=__snake_case    )

  if os.path.exists(__snake_case    ):
    lowercase							    =       torch.load(__snake_case		,					map_location='cpu'    )
  else:
    lowercase							    =       torch.hub.load_state_dict_from_url(__snake_case		,					map_location='cpu'    )

  lowercase							    =       upgrade_state_dict(__snake_case		,					__snake_case    )
  hf_model.load_state_dict(__snake_case    )
  lowercase							    =       hf_model.state_dict()
  lowercase							    =       count_parameters(__snake_case    )
  lowercase							    =       count_parameters(__snake_case    ) + count_parameters(__snake_case    )

  assert torch.allclose(__snake_case		,					__snake_case		,					atol=1e-3    )

  hf_model.save_pretrained(__snake_case    )


if __name__ == "__main__":
    _UpperCamelCase		:  Optional[int]						=		argparse.ArgumentParser()
    parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
    parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to flava checkpoint')
    parser.add_argument('--codebook_path', default=None, type=str, help='Path to flava codebook checkpoint')
    parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
    _UpperCamelCase		:  Union[str, Any]						=		parser.parse_args()

    convert_flava_checkpoint(args.checkpoint_path, args.codebook_path, args.pytorch_dump_folder_path, args.config_path)










"""simple docstring"""



def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  int    ):





  '''simple docstring'''





  return sum(i for i in range(1		,					number // 2 + 1    ) if number % i == 0    ) == number


if __name__ == "__main__":
    print('Program to check whether a number is a Perfect number or not...')
    _UpperCamelCase		:  Tuple						=		int(input('Enter number: ').strip())
    print(F'''{number} is {'' if perfect(number) else 'not '}a Perfect Number.''')


