# Copyright 2022 The HuggingFace Team and The OpenBMB Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


UpperCamelCase__											=					{
    'configuration_cpmant': ['CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'CpmAntConfig'],
    'tokenization_cpmant': ['CpmAntTokenizer'],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase__											=					[
          'CPMANT_PRETRAINED_MODEL_ARCHIVE_LIST',
          'CpmAntForCausalLM',
          'CpmAntModel',
          'CpmAntPreTrainedModel',
      ]


if TYPE_CHECKING:
      from .configuration_cpmant import CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP, CpmAntConfig
      from .tokenization_cpmant import CpmAntTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_cpmant import (
                CPMANT_PRETRAINED_MODEL_ARCHIVE_LIST,
                CpmAntForCausalLM,
                CpmAntModel,
                CpmAntPreTrainedModel,
            )


else:
      import sys

      UpperCamelCase__											=					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





"""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)




