



"""simple docstring"""
import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)



class       SCREAMING_SNAKE_CASE__  (					unittest.TestCase ):

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Union[str, Any]	=	["""a""", """b""", """c"""]

    # Defaults to last layer if both are None
    UpperCAmelCase	,		UpperCAmelCase	:					Optional[int]	=	get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     ["""c"""]						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     [2]						)

    # Out indices set to match out features
    UpperCAmelCase	,		UpperCAmelCase	:					str	=	get_aligned_output_features_output_indices(["""a""", """c"""]      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     ["""a""", """c"""]						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     [0, 2]						)

    # Out features set to match out indices
    UpperCAmelCase	,		UpperCAmelCase	:					Optional[Any]	=	get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,     [0, 2]      ,     _SCREAMING_SNAKE_CASE						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     ["""a""", """c"""]						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     [0, 2]						)

    # Out features selected from negative indices
    UpperCAmelCase	,		UpperCAmelCase	:					Optional[int]	=	get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,     [-3, -1]      ,     _SCREAMING_SNAKE_CASE						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     ["""a""", """c"""]						)
    self.assertEqual(_SCREAMING_SNAKE_CASE      ,     [-3, -1]						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[str]:





    '''simple docstring'''




    with self.assertRaises(_SCREAMING_SNAKE_CASE						):
     verify_out_features_out_indices(["""a""", """b"""]      ,     (0, 1)      ,     _SCREAMING_SNAKE_CASE						)

    # Out features must be a list
    with self.assertRaises(_SCREAMING_SNAKE_CASE						):
     verify_out_features_out_indices(("""a""", """b""")      ,     (0, 1)      ,     ["""a""", """b"""]						)

    # Out features must be a subset of stage names
    with self.assertRaises(_SCREAMING_SNAKE_CASE						):
     verify_out_features_out_indices(["""a""", """b"""]      ,     (0, 1)      ,     ["""a"""]						)

    # Out indices must be a list or tuple
    with self.assertRaises(_SCREAMING_SNAKE_CASE						):
     verify_out_features_out_indices(_SCREAMING_SNAKE_CASE      ,     0      ,     ["""a""", """b"""]						)

    # Out indices must be a subset of stage names
    with self.assertRaises(_SCREAMING_SNAKE_CASE						):
     verify_out_features_out_indices(_SCREAMING_SNAKE_CASE      ,     (0, 1)      ,     ["""a"""]						)

    # Out features and out indices must be the same length
    with self.assertRaises(_SCREAMING_SNAKE_CASE						):
     verify_out_features_out_indices(["""a""", """b"""]      ,     (0,)      ,     ["""a""", """b""", """c"""]						)

    # Out features should match out indices
    with self.assertRaises(_SCREAMING_SNAKE_CASE						):
     verify_out_features_out_indices(["""a""", """b"""]      ,     (0, 2)      ,     ["""a""", """b""", """c"""]						)

    # Out features and out indices should be in order
    with self.assertRaises(_SCREAMING_SNAKE_CASE						):
     verify_out_features_out_indices(["""b""", """a"""]      ,     (0, 1)      ,     ["""a""", """b"""]						)

    # Check passes with valid inputs
    verify_out_features_out_indices(["""a""", """b""", """d"""]      ,     (0, 1, -1)      ,     ["""a""", """b""", """c""", """d"""]						)




   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	BackboneMixin()

    UpperCAmelCase	:					int	=	["""a""", """b""", """c"""]
    UpperCAmelCase	:					Dict	=	["""a""", """c"""]
    UpperCAmelCase	:					Tuple	=	[0, 2]

    # Check that the output features and indices are set correctly
    self.assertEqual(backbone.out_features      ,     ["""a""", """c"""]						)
    self.assertEqual(backbone.out_indices      ,     [0, 2]						)

    # Check out features and indices are updated correctly
    UpperCAmelCase	:					Tuple	=	["""a""", """b"""]
    self.assertEqual(backbone.out_features      ,     ["""a""", """b"""]						)
    self.assertEqual(backbone.out_indices      ,     [0, 1]						)

    UpperCAmelCase	:					List[Any]	=	[-3, -1]
    self.assertEqual(backbone.out_features      ,     ["""a""", """c"""]						)
    self.assertEqual(backbone.out_indices      ,     [-3, -1]						)


"""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 lowercase_  (   _snake_case						):
							# 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 lowercase_  (   _snake_case   ,_snake_case						):
							SCREAMING_SNAKE_CASE__						:       Any           =   {}

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

														SCREAMING_SNAKE_CASE__						:       Optional[int]           =   key.replace("""heads.cmd.mim_head.cls.predictions"""   ,"""mmm_image_head"""						)
														SCREAMING_SNAKE_CASE__						:       Dict           =   key.replace("""heads.cmd.mlm_head.cls.predictions"""   ,"""mmm_text_head"""						)
														SCREAMING_SNAKE_CASE__						:       List[Any]           =   key.replace("""heads.cmd.itm_head.cls"""   ,"""itm_head"""						)
														SCREAMING_SNAKE_CASE__						:       Tuple           =   key.replace("""heads.cmd.itm_head.pooler"""   ,"""itm_head.pooler"""						)
														SCREAMING_SNAKE_CASE__						:       int           =   key.replace("""heads.cmd.clip_head.logit_scale"""   ,"""flava.logit_scale"""						)
														SCREAMING_SNAKE_CASE__						:       Tuple           =   key.replace("""heads.fairseq_mlm.cls.predictions"""   ,"""mlm_head"""						)
														SCREAMING_SNAKE_CASE__						:       str           =   key.replace("""heads.imagenet.mim_head.cls.predictions"""   ,"""mim_head"""						)
														SCREAMING_SNAKE_CASE__						:       List[str]           =   key.replace("""mm_text_projection"""   ,"""flava.text_to_mm_projection"""						)
														SCREAMING_SNAKE_CASE__						:       Dict           =   key.replace("""mm_image_projection"""   ,"""flava.image_to_mm_projection"""						)
														SCREAMING_SNAKE_CASE__						:       str           =   key.replace("""image_encoder.module"""   ,"""flava.image_model"""						)
														SCREAMING_SNAKE_CASE__						:       Tuple           =   key.replace("""text_encoder.module"""   ,"""flava.text_model"""						)
														SCREAMING_SNAKE_CASE__						:       int           =   key.replace("""mm_encoder.module.encoder.cls_token"""   ,"""flava.multimodal_model.cls_token"""						)
														SCREAMING_SNAKE_CASE__						:       Dict           =   key.replace("""mm_encoder.module"""   ,"""flava.multimodal_model"""						)
														SCREAMING_SNAKE_CASE__						:       Any           =   key.replace("""text_projection"""   ,"""flava.text_projection"""						)
														SCREAMING_SNAKE_CASE__						:       List[Any]           =   key.replace("""image_projection"""   ,"""flava.image_projection"""						)

														SCREAMING_SNAKE_CASE__						:       Tuple           =   value.float()

							for key, value in codebook_state_dict.items():
														SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   value

							return upgrade

@torch.no_grad()
def lowercase_  (   _snake_case   ,_snake_case   ,_snake_case   ,_snake_case=None						):
							if config_path is not None:
														SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   FlavaConfig.from_pretrained(_snake_case						)
							else:
														SCREAMING_SNAKE_CASE__						:       List[str]           =   FlavaConfig()

							SCREAMING_SNAKE_CASE__						:       Optional[int]           =   FlavaForPreTraining(_snake_case						).eval()

							SCREAMING_SNAKE_CASE__						:       List[Any]           =   convert_dalle_checkpoint(_snake_case   ,_snake_case   ,save_checkpoint=_snake_case						)

							if os.path.exists(_snake_case						):
														SCREAMING_SNAKE_CASE__						:       List[str]           =   torch.load(_snake_case   ,map_location="""cpu"""						)
							else:
														SCREAMING_SNAKE_CASE__						:       Tuple           =   torch.hub.load_state_dict_from_url(_snake_case   ,map_location="""cpu"""						)

							SCREAMING_SNAKE_CASE__						:       Dict           =   upgrade_state_dict(_snake_case   ,_snake_case						)
							hf_model.load_state_dict(_snake_case						)
							SCREAMING_SNAKE_CASE__						:       Any           =   hf_model.state_dict()
							SCREAMING_SNAKE_CASE__						:       Any           =   count_parameters(_snake_case						)
							SCREAMING_SNAKE_CASE__						:       str           =   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__      :    List[Any]    							= 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__      :    Optional[int]    							= parser.parse_args()

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




