
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__     (   __lowerCAmelCase				):
    # encoder.embeddings are double copied in original FLAVA
    return sum(param.float().sum() if "encoder.embeddings" not in key else 0 for key, param in state_dict.items()				)





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase     ,		__lowerCAmelCase				):
    snake_case__    =					{}

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

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

        snake_case__    =					value.float()

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

    return upgrade





@torch.no_grad()
def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase     ,		__lowerCAmelCase     ,		__lowerCAmelCase     ,		__lowerCAmelCase=None				):
    if config_path is not None:
        snake_case__    =					FlavaConfig.from_pretrained(__lowerCAmelCase				)
    else:
        snake_case__    =					FlavaConfig()

    snake_case__    =					FlavaForPreTraining(__lowerCAmelCase				).eval()

    snake_case__    =					convert_dalle_checkpoint(__lowerCAmelCase     ,		__lowerCAmelCase     ,		save_checkpoint=__lowerCAmelCase				)

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

    snake_case__    =					upgrade_state_dict(__lowerCAmelCase     ,		__lowerCAmelCase				)
    hf_model.load_state_dict(__lowerCAmelCase				)
    snake_case__    =					hf_model.state_dict()
    snake_case__    =					count_parameters(__lowerCAmelCase				)
    snake_case__    =					count_parameters(__lowerCAmelCase				) + count_parameters(__lowerCAmelCase				)

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

    hf_model.save_pretrained(__lowerCAmelCase				)


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

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





from math import loga





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    if a < 0:
        raise ValueError("Input value must be a positive integer"				)
    elif isinstance(__lowerCAmelCase     ,		__lowerCAmelCase				):
        raise TypeError("Input value must be a 'int' type"				)
    return 0 if (a == 0) else int(loga(a & -a				)				)


if __name__ == "__main__":
     import doctest

     doctest.testmod()



