






import argparse

import torch

from transformers import ChineseCLIPConfig, ChineseCLIPModel
def        a_	( _A ,				_A ,				_A					)     ->     Dict:







				"""simple docstring"""
				snake_case__							,  snake_case__							,  snake_case__													=       pt_weights[f'''{prefix}.in_proj_weight'''].chunk(3 ,				dim=0					)
				snake_case__							,  snake_case__							,  snake_case__													=       pt_weights[f'''{prefix}.in_proj_bias'''].chunk(3 ,				dim=0					)

				snake_case__													=       pt_weights[f'''{prefix}.out_proj.weight''']
				snake_case__													=       pt_weights[f'''{prefix}.out_proj.bias''']

				snake_case__													=       q_proj
				snake_case__													=       q_proj_bias

				snake_case__													=       k_proj
				snake_case__													=       k_proj_bias

				snake_case__													=       v_proj
				snake_case__													=       v_proj_bias

				snake_case__													=       out_proj_weights
				snake_case__													=       out_proj_bias
def        a_	( _A ,				_A ,				_A					)     ->     Optional[int]:







				"""simple docstring"""
				copy_linear(hf_mlp.fca ,				_A ,				f'''{prefix}.c_fc'''					)
				copy_linear(hf_mlp.fca ,				_A ,				f'''{prefix}.c_proj'''					)
def        a_	( _A ,				_A ,				_A					)     ->     int:







				"""simple docstring"""
				snake_case__													=       pt_weights[f'''{prefix}.weight'''].data
				snake_case__													=       pt_weights[f'''{prefix}.bias'''].data
def        a_	( _A ,				_A ,				_A					)     ->     Optional[Any]:







				"""simple docstring"""
				copy_linear(hf_layer.layer_norma ,				_A ,				f'''{prefix}.ln_1'''					)
				copy_linear(hf_layer.layer_norma ,				_A ,				f'''{prefix}.ln_2'''					)

				# copy MLP
				copy_mlp(hf_layer.mlp ,				_A ,				f'''{prefix}.mlp'''					)

				# copy attn
				copy_attn_layer(hf_layer.self_attn ,				_A ,				f'''{prefix}.attn'''					)
def        a_	( _A ,				_A ,				_A					)     ->     str:







				"""simple docstring"""
				for layer_id, hf_layer in enumerate(_A					):
								copy_layer(_A ,				_A ,				f'''{prefix}.{layer_id}'''					)
def        a_	( _A ,				_A					)     ->     int:







				"""simple docstring"""
				snake_case__													=       pt_weights['text_projection'].data.T

				# copy text encoder
				for name, param in hf_model.text_model.named_parameters():
								snake_case__													=       pt_weights[f'''bert.{name}'''].data
def        a_	( _A ,				_A					)     ->     Dict:







				"""simple docstring"""
				snake_case__													=       pt_weights['visual.proj'].data.T

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

				# copy embeddings
				snake_case__													=       pt_weights['visual.conv1.weight'].data
				snake_case__													=       pt_weights['visual.class_embedding'].data
				snake_case__													=       pt_weights['visual.positional_embedding'].data

				# copy encoder
				copy_layers(hf_model.vision_model.encoder.layers ,				_A ,				'visual.transformer.resblocks'					)
@torch.no_grad()
def        a_	( _A ,				_A ,				_A=None					)     ->     Union[str, Any]:







				"""simple docstring"""
				assert config_path is not None, "Please specify the ChineseCLIP model config of the corresponding model size."
				snake_case__													=       ChineseCLIPConfig.from_pretrained(_A					)

				snake_case__													=       ChineseCLIPModel(_A					).eval()

				snake_case__													=       torch.load(_A ,				map_location='cpu'					)['state_dict']
				snake_case__													=       {(name[7:] if name.startswith('module.'					) else name): value for name, value in pt_weights.items()}

				copy_text_model_and_projection(_A ,				_A					)
				copy_vision_model_and_projection(_A ,				_A					)
				snake_case__													=       pt_weights['logit_scale'].data

				hf_model.save_pretrained(_A					)


if __name__ == "__main__":
							__UpperCamelCase   :						str							=  argparse.ArgumentParser()
							parser.add_argument(
							    """--pytorch_dump_folder_path""",
							    default=None,
							    type=str,
							    help="""Path to the output folder storing converted hf PyTorch model.""",
							)
							parser.add_argument(
							    """--checkpoint_path""", default=None, type=str, help="""Path to original github format ChineseCLIP checkpoint."""
							)
							parser.add_argument(
							    """--config_path""", default=None, required=True, type=str, help="""Path to hf config.json of model to convert."""
							)
							__UpperCamelCase   :						Dict							=  parser.parse_args()

							convert_chinese_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
							print("""The conversion is finished!""")












from copy import deepcopy
from pathlib import Path
from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union

import torch
from torch import nn
from torch.utils.data import Dataset

from .deepspeed import is_deepspeed_zeroa_enabled
from .generation.configuration_utils import GenerationConfig
from .trainer import Trainer
from .utils import logging


if TYPE_CHECKING:
							from .data.data_collator import DataCollator
							from .modeling_utils import PreTrainedModel
							from .tokenization_utils_base import PreTrainedTokenizerBase
							from .trainer_callback import TrainerCallback
							from .trainer_utils import EvalPrediction, PredictionOutput
							from .training_args import TrainingArguments


__UpperCamelCase   :						Tuple							=  logging.get_logger(__name__)


class 					__SCREAMING_SNAKE_CASE(		a_		):
							def __init__(       self: Dict    ,		UpperCamelCase: Union["PreTrainedModel", nn.Module] = None    ,		UpperCamelCase: "TrainingArguments" = None    ,		UpperCamelCase: Optional["DataCollator"] = None    ,		UpperCamelCase: Optional[Dataset] = None    ,		UpperCamelCase: Optional[Union[Dataset, Dict[str, Dataset]]] = None    ,		UpperCamelCase: Optional["PreTrainedTokenizerBase"] = None    ,		UpperCamelCase: Optional[Callable[[], "PreTrainedModel"]] = None    ,		UpperCamelCase: Optional[Callable[["EvalPrediction"], Dict]] = None    ,		UpperCamelCase: Optional[List["TrainerCallback"]] = None    ,		UpperCamelCase: Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None)    ,		UpperCamelCase: Optional[Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None    ,		)						->						Tuple:
											super().__init__(
											    model=UpperCamelCase    ,		args=UpperCamelCase    ,		data_collator=UpperCamelCase    ,		train_dataset=UpperCamelCase    ,		eval_dataset=UpperCamelCase    ,		tokenizer=UpperCamelCase    ,		model_init=UpperCamelCase    ,		compute_metrics=UpperCamelCase    ,		callbacks=UpperCamelCase    ,		optimizers=UpperCamelCase    ,		preprocess_logits_for_metrics=UpperCamelCase    ,		)

											# Override self.model.generation_config if a GenerationConfig is specified in args.
											# Priority: args.generation_config > model.generation_config > default GenerationConfig.
											if self.args.generation_config is not None:
															snake_case__													=       self.load_generation_config(self.args.generation_config  )
															snake_case__													=       gen_config
							@staticmethod
							def lowerCAmelCase_	(       UpperCamelCase: Union[str, GenerationConfig]  )						->						GenerationConfig:

											# GenerationConfig provided, nothing to do
											if isinstance(UpperCamelCase    ,		UpperCamelCase  ):
															return deepcopy(UpperCamelCase  )

											# str or Path
											snake_case__													=       Path(UpperCamelCase  ) if isinstance(UpperCamelCase    ,		UpperCamelCase  ) else gen_config_arg
											snake_case__													=       None

											# Figuring if it is path pointing to a file, pointing to a directory or else a model id or URL
											# This step is required in order to determine config_file_name
											if pretrained_model_name.is_file():
															snake_case__													=       pretrained_model_name.name
															snake_case__													=       pretrained_model_name.parent
											# dir path
											elif pretrained_model_name.is_dir():
															pass
											# model id or URL
											else:
															snake_case__													=       gen_config_arg

											snake_case__													=       GenerationConfig.from_pretrained(UpperCamelCase    ,		UpperCamelCase  )
											return gen_config
							def lowerCAmelCase_	(       self: Optional[int]    ,		UpperCamelCase: Optional[Dataset] = None    ,		UpperCamelCase: Optional[List[str]] = None    ,		UpperCamelCase: str = "eval"    ,		**UpperCamelCase: Dict    ,		)						->						Dict[str, float]:
											snake_case__													=       gen_kwargs.copy()
											if gen_kwargs.get('max_length'  ) is None and gen_kwargs.get('max_new_tokens'  ) is None:
															snake_case__													=       self.args.generation_max_length
											snake_case__													=       (
											    gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'  ) is not None else self.args.generation_num_beams
											)
											snake_case__													=       gen_kwargs

											return super().evaluate(UpperCamelCase    ,		ignore_keys=UpperCamelCase    ,		metric_key_prefix=UpperCamelCase  )
							def lowerCAmelCase_	(       self: Tuple    ,		UpperCamelCase: Dataset    ,		UpperCamelCase: Optional[List[str]] = None    ,		UpperCamelCase: str = "test"    ,		**UpperCamelCase: Dict    ,		)						->						"PredictionOutput":
											snake_case__													=       gen_kwargs.copy()
											if gen_kwargs.get('max_length'  ) is None and gen_kwargs.get('max_new_tokens'  ) is None:
															snake_case__													=       self.args.generation_max_length
											snake_case__													=       (
											    gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'  ) is not None else self.args.generation_num_beams
											)
											snake_case__													=       gen_kwargs

											return super().predict(UpperCamelCase    ,		ignore_keys=UpperCamelCase    ,		metric_key_prefix=UpperCamelCase  )
							def lowerCAmelCase_	(       self: Tuple    ,		UpperCamelCase: nn.Module    ,		UpperCamelCase: Dict[str, Union[torch.Tensor, Any]]    ,		UpperCamelCase: bool    ,		UpperCamelCase: Optional[List[str]] = None    ,		**UpperCamelCase: List[Any]    ,		)						->						Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:

											if not self.args.predict_with_generate or prediction_loss_only:
															return super().prediction_step(
															    UpperCamelCase    ,		UpperCamelCase    ,		prediction_loss_only=UpperCamelCase    ,		ignore_keys=UpperCamelCase  )

											snake_case__													=       'labels' in inputs
											snake_case__													=       self._prepare_inputs(UpperCamelCase  )

											# XXX: adapt synced_gpus for fairscale as well
											# Priority (handled in generate):
											# gen_kwargs > model.generation_config > default GenerationConfig()

											if len(UpperCamelCase  ) == 0 and hasattr(self    ,		'_gen_kwargs'  ):
															snake_case__													=       self._gen_kwargs.copy()

											if gen_kwargs.get('max_length'  ) is None and gen_kwargs.get('max_new_tokens'  ) is None:
															snake_case__													=       self.model.config.max_length
											snake_case__													=       (
											    gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'  ) is not None else self.model.config.num_beams
											)
											snake_case__													=       True if is_deepspeed_zeroa_enabled() else False
											snake_case__													=       (
											    gen_kwargs['synced_gpus'] if gen_kwargs.get('synced_gpus'  ) is not None else default_synced_gpus
											)

											# If the `decoder_input_ids` was created from `labels`, evict the former, so that the model can freely generate
											# (otherwise, it would continue generating from the padded `decoder_input_ids`)
											if (
											    "labels" in inputs
											    and "decoder_input_ids" in inputs
											    and inputs["labels"].shape == inputs["decoder_input_ids"].shape
											):
															snake_case__													=       {k: v for k, v in inputs.items() if k != 'decoder_input_ids'}
											snake_case__													=       self.model.generate(**UpperCamelCase    ,		**UpperCamelCase  )

											# Temporary hack to ensure the generation config is not initialized for each iteration of the evaluation loop
											# TODO: remove this hack when the legacy code that initializes generation_config from a model config is
											# removed in https://github.com/huggingface/transformers/blob/98d88b23f54e5a23e741833f1e973fdf600cc2c5/src/transformers/generation/utils.py#L1183
											if self.model.generation_config._from_model_config:
															snake_case__													=       False

											# Retrieves GenerationConfig from model.generation_config
											snake_case__													=       self.model.generation_config
											# in case the batch is shorter than max length, the output should be padded
											if generated_tokens.shape[-1] < gen_config.max_length:
															snake_case__													=       self._pad_tensors_to_max_len(UpperCamelCase    ,		gen_config.max_length  )
											elif gen_config.max_new_tokens is not None and generated_tokens.shape[-1] < gen_config.max_new_tokens + 1:
															snake_case__													=       self._pad_tensors_to_max_len(UpperCamelCase    ,		gen_config.max_new_tokens + 1  )

											with torch.no_grad():
															if has_labels:
																			with self.compute_loss_context_manager():
																							snake_case__													=       model(**UpperCamelCase  )
																			if self.label_smoother is not None:
																							snake_case__													=       self.label_smoother(UpperCamelCase    ,		inputs['labels']  ).mean().detach()
																			else:
																							snake_case__													=       (outputs['loss'] if isinstance(UpperCamelCase    ,		UpperCamelCase  ) else outputs[0]).mean().detach()
															else:
																			snake_case__													=       None

											if self.args.prediction_loss_only:
															return loss, None, None

											if has_labels:
															snake_case__													=       inputs['labels']
															if labels.shape[-1] < gen_config.max_length:
																			snake_case__													=       self._pad_tensors_to_max_len(UpperCamelCase    ,		gen_config.max_length  )
															elif gen_config.max_new_tokens is not None and labels.shape[-1] < gen_config.max_new_tokens + 1:
																			snake_case__													=       self._pad_tensors_to_max_len(UpperCamelCase    ,		gen_config.max_new_tokens + 1  )
											else:
															snake_case__													=       None

											return loss, generated_tokens, labels


							def lowerCAmelCase_	(       self: List[Any]    ,		UpperCamelCase: Tuple    ,		UpperCamelCase: Tuple  )						->						List[str]:
											if self.tokenizer is not None and hasattr(self.tokenizer    ,		'pad_token_id'  ):
															# If PAD token is not defined at least EOS token has to be defined
															snake_case__													=       (
															    self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else self.tokenizer.eos_token_id
															)
											else:
															if self.model.config.pad_token_id is not None:
																			snake_case__													=       self.model.config.pad_token_id
															else:
																			raise ValueError('Pad_token_id must be set in the configuration of the model, in order to pad tensors'  )

											snake_case__													=       pad_token_id * torch.ones(
											    (tensor.shape[0], max_length)    ,		dtype=tensor.dtype    ,		device=tensor.device  )
											snake_case__													=       tensor
											return padded_tensor




