


"""simple docstring"""






import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel



def 			A__		(					_UpperCAmelCase    :      List[Any]				,    _UpperCAmelCase    :      Optional[int]	)							->	Optional[Any]:

	'''simple docstring'''


	snake_case__,					snake_case__,					snake_case__  :						Tuple		=      pt_attn_layer.in_proj_weight.chunk(3				,    dim=0	)
	snake_case__,					snake_case__,					snake_case__  :						Any		=      pt_attn_layer.in_proj_bias.chunk(3				,    dim=0	)

	snake_case__  :						List[str]		=      pt_attn_layer.out_proj.weight
	snake_case__  :						Optional[int]		=      pt_attn_layer.out_proj.bias

	snake_case__  :						Optional[Any]		=      q_proj
	snake_case__  :						Optional[int]		=      q_proj_bias

	snake_case__  :						Tuple		=      k_proj
	snake_case__  :						List[str]		=      k_proj_bias

	snake_case__  :						Dict		=      v_proj
	snake_case__  :						Optional[int]		=      v_proj_bias

	snake_case__  :						List[Any]		=      out_proj_weights
	snake_case__  :						Dict		=      out_proj_bias



def 			A__		(					_UpperCAmelCase    :      Tuple				,    _UpperCAmelCase    :      List[Any]	)							->	Tuple:

	'''simple docstring'''


	copy_linear(hf_mlp.fca				,    pt_mlp.c_fc	)
	copy_linear(hf_mlp.fca				,    pt_mlp.c_proj	)



def 			A__		(					_UpperCAmelCase    :      Union[str, Any]				,    _UpperCAmelCase    :      Optional[Any]	)							->	Union[str, Any]:

	'''simple docstring'''


	snake_case__  :						Optional[int]		=      pt_linear.weight
	snake_case__  :						str		=      pt_linear.bias



def 			A__		(					_UpperCAmelCase    :      Optional[int]				,    _UpperCAmelCase    :      Optional[Any]	)							->	List[Any]:

	'''simple docstring'''


	copy_linear(hf_layer.layer_norma				,    pt_layer.ln_a	)
	copy_linear(hf_layer.layer_norma				,    pt_layer.ln_a	)

	# copy MLP
	copy_mlp(hf_layer.mlp				,    pt_layer.mlp	)

	# copy attn
	copy_attn_layer(hf_layer.self_attn				,    pt_layer.attn	)



def 			A__		(					_UpperCAmelCase    :      List[Any]				,    _UpperCAmelCase    :      str	)							->	str:

	'''simple docstring'''


	for hf_layer, pt_layer in zip(_UpperCAmelCase				,    _UpperCAmelCase	):
		copy_layer(_UpperCAmelCase				,    _UpperCAmelCase	)



def 			A__		(					_UpperCAmelCase    :      List[Any]				,    _UpperCAmelCase    :      Optional[Any]	)							->	Tuple:

	'''simple docstring'''


	snake_case__  :						Tuple		=      pt_model.token_embedding.weight
	snake_case__  :						Dict		=      pt_model.positional_embedding

	# copy layer norm
	copy_linear(hf_encoder.final_layer_norm				,    pt_model.ln_final	)

	# copy hidden layers
	copy_layers(hf_encoder.encoder.layers				,    pt_model.transformer.resblocks	)



def 			A__		(					_UpperCAmelCase    :      List[str]				,    _UpperCAmelCase    :      Any	)							->	List[Any]:

	'''simple docstring'''


	snake_case__  :						Dict		=      pt_model.text_projection.data.T

	# copy text encoder
	copy_encoder(hf_model.text_model				,    _UpperCAmelCase	)



def 			A__		(					_UpperCAmelCase    :      Dict				,    _UpperCAmelCase    :      Optional[int]	)							->	Tuple:

	'''simple docstring'''


	snake_case__  :						Tuple		=      pt_model.visual.proj.data.T

	# copy layer norms
	copy_linear(hf_model.vision_model.pre_layrnorm				,    pt_model.visual.ln_pre	)
	copy_linear(hf_model.vision_model.post_layernorm				,    pt_model.visual.ln_post	)

	# copy embeds
	snake_case__  :						Optional[Any]		=      pt_model.visual.conva.weight.data
	snake_case__  :						str		=      pt_model.visual.class_embedding
	snake_case__  :						int		=      pt_model.visual.positional_embedding.data

	# copy encoder
	copy_layers(hf_model.vision_model.encoder.layers				,    pt_model.visual.transformer.resblocks	)



@torch.no_grad()
def 			A__		(					_UpperCAmelCase    :      str				,    _UpperCAmelCase    :      Dict				,    _UpperCAmelCase    :      Union[str, Any]=None	)							->	Union[str, Any]:

	'''simple docstring'''


	if config_path is not None:
		snake_case__  :						List[str]		=      CLIPConfig.from_pretrained(_UpperCAmelCase	)
	else:
		snake_case__  :						List[str]		=      CLIPConfig(projection_dim=5_12				,    text_config={}				,    vision_config={}	)

	snake_case__  :						Dict		=      CLIPModel(_UpperCAmelCase	).eval()

	snake_case__,					snake_case__  :						Any		=      load(_UpperCAmelCase				,    device="cpu"				,    jit=_UpperCAmelCase	)
	snake_case__  :						int		=      pt_model.eval()

	copy_text_model_and_projection(_UpperCAmelCase				,    _UpperCAmelCase	)
	copy_vison_model_and_projection(_UpperCAmelCase				,    _UpperCAmelCase	)
	snake_case__  :						Optional[int]		=      pt_model.logit_scale

	snake_case__  :						List[str]		=      torch.arange(0				,    77	).unsqueeze(0	)
	snake_case__  :						str		=      torch.randn(1				,    3				,    2_24				,    2_24	)

	snake_case__  :						List[Any]		=      hf_model(input_ids=_UpperCAmelCase				,    pixel_values=_UpperCAmelCase				,    return_dict=_UpperCAmelCase	)
	snake_case__  :						Optional[int]		=      hf_outputs.logits_per_image
	snake_case__  :						Dict		=      hf_outputs.logits_per_text
	snake_case__,					snake_case__  :						Tuple		=      pt_model(_UpperCAmelCase				,    _UpperCAmelCase	)

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

	hf_model.save_pretrained(_UpperCAmelCase	)


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 fairseq 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_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)






"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__A       			=      {
    """configuration_realm""": ["""REALM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """RealmConfig"""],
    """tokenization_realm""": ["""RealmTokenizer"""],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A       			=      ["""RealmTokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A       			=      [
     """REALM_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """RealmEmbedder""",
     """RealmForOpenQA""",
     """RealmKnowledgeAugEncoder""",
     """RealmPreTrainedModel""",
     """RealmReader""",
     """RealmScorer""",
     """load_tf_weights_in_realm""",
 ]
 __A       			=      ["""RealmRetriever"""]


if TYPE_CHECKING:
 from .configuration_realm import REALM_PRETRAINED_CONFIG_ARCHIVE_MAP, RealmConfig
 from .tokenization_realm import RealmTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_realm import RealmTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_realm import (
      REALM_PRETRAINED_MODEL_ARCHIVE_LIST,
      RealmEmbedder,
      RealmForOpenQA,
      RealmKnowledgeAugEncoder,
      RealmPreTrainedModel,
      RealmReader,
      RealmScorer,
      load_tf_weights_in_realm,
  )
  from .retrieval_realm import RealmRetriever


else:
 import sys

 __A       			=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
