


'''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 __UpperCamelCase   (			__lowerCamelCase		: Optional[int]				)      ->     Dict:







     '''simple docstring'''






     return sum(param.float().sum() if "encoder.embeddings" not in key else 0 for key, param in state_dict.items()				)






def __UpperCamelCase   (			__lowerCamelCase		: str      ,  __lowerCamelCase		: Union[str, Any]				)      ->     Union[str, Any]:







     '''simple docstring'''






     _a						=		{}

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

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

          _a						=		value.float()

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

     return upgrade






@torch.no_grad()
def __UpperCamelCase   (			__lowerCamelCase		: List[Any]      ,  __lowerCamelCase		: str      ,  __lowerCamelCase		: Any      ,  __lowerCamelCase		: int=None				)      ->     Any:







     '''simple docstring'''






     if config_path is not None:
          _a						=		FlavaConfig.from_pretrained(__lowerCamelCase				)
     else:
          _a						=		FlavaConfig()

     _a						=		FlavaForPreTraining(__lowerCamelCase				).eval()

     _a						=		convert_dalle_checkpoint(__lowerCamelCase      ,  __lowerCamelCase      ,  save_checkpoint=__lowerCamelCase				)

     if os.path.exists(__lowerCamelCase				):
          _a						=		torch.load(__lowerCamelCase      ,  map_location="cpu"				)
     else:
          _a						=		torch.hub.load_state_dict_from_url(__lowerCamelCase      ,  map_location="cpu"				)

     _a						=		upgrade_state_dict(__lowerCamelCase      ,  __lowerCamelCase				)
     hf_model.load_state_dict(__lowerCamelCase				)
     _a						=		hf_model.state_dict()
     _a						=		count_parameters(__lowerCamelCase				)
     _a						=		count_parameters(__lowerCamelCase				) + count_parameters(__lowerCamelCase				)

     assert torch.allclose(__lowerCamelCase      ,  __lowerCamelCase      ,  atol=1E-3				)

     hf_model.save_pretrained(__lowerCamelCase				)


if __name__ == "__main__":
   lowercase__				     =		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")
   lowercase__				     =		parser.parse_args()

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





'''simple docstring'''

lowercase__				     =		65_521






def __UpperCamelCase   (			__lowerCamelCase		: str				)      ->     int:







     '''simple docstring'''






     _a						=		1
     _a						=		0
     for plain_chr in plain_text:
          _a						=		(a + ord(__lowerCamelCase				)) % MOD_ADLER
          _a						=		(b + a) % MOD_ADLER
     return (b << 16) | a

