





"""simple docstring"""





import argparse

import torch

from transformers import ChineseCLIPConfig, ChineseCLIPModel


def    a__       (       _SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE     ):




		"""simple docstring"""


		UpperCamelCase ,					UpperCamelCase ,					UpperCamelCase =						pt_weights[F"{prefix}.in_proj_weight"].chunk(3	,						dim=0     )
		UpperCamelCase ,					UpperCamelCase ,					UpperCamelCase =						pt_weights[F"{prefix}.in_proj_bias"].chunk(3	,						dim=0     )

		UpperCamelCase =						pt_weights[F"{prefix}.out_proj.weight"]
		UpperCamelCase =						pt_weights[F"{prefix}.out_proj.bias"]

		UpperCamelCase =						q_proj
		UpperCamelCase =						q_proj_bias

		UpperCamelCase =						k_proj
		UpperCamelCase =						k_proj_bias

		UpperCamelCase =						v_proj
		UpperCamelCase =						v_proj_bias

		UpperCamelCase =						out_proj_weights
		UpperCamelCase =						out_proj_bias


def    a__       (       _SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE     ):




		"""simple docstring"""


		copy_linear(hf_mlp.fca	,						_SCREAMING_SNAKE_CASE	,						F"{prefix}.c_fc"     )
		copy_linear(hf_mlp.fca	,						_SCREAMING_SNAKE_CASE	,						F"{prefix}.c_proj"     )


def    a__       (       _SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE     ):




		"""simple docstring"""


		UpperCamelCase =						pt_weights[F"{prefix}.weight"].data
		UpperCamelCase =						pt_weights[F"{prefix}.bias"].data


def    a__       (       _SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE     ):




		"""simple docstring"""


		copy_linear(hf_layer.layer_norma	,						_SCREAMING_SNAKE_CASE	,						F"{prefix}.ln_1"     )
		copy_linear(hf_layer.layer_norma	,						_SCREAMING_SNAKE_CASE	,						F"{prefix}.ln_2"     )

		# copy MLP
		copy_mlp(hf_layer.mlp	,						_SCREAMING_SNAKE_CASE	,						F"{prefix}.mlp"     )

		# copy attn
		copy_attn_layer(hf_layer.self_attn	,						_SCREAMING_SNAKE_CASE	,						F"{prefix}.attn"     )


def    a__       (       _SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE     ):




		"""simple docstring"""


		for layer_id, hf_layer in enumerate(_SCREAMING_SNAKE_CASE     ):
				copy_layer(_SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE	,						F"{prefix}.{layer_id}"     )


def    a__       (       _SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE     ):




		"""simple docstring"""


		UpperCamelCase =						pt_weights["text_projection"].data.T

		# copy text encoder
		for name, param in hf_model.text_model.named_parameters():
				UpperCamelCase =						pt_weights[F"bert.{name}"].data


def    a__       (       _SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE     ):




		"""simple docstring"""


		UpperCamelCase =						pt_weights["visual.proj"].data.T

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

		# copy embeddings
		UpperCamelCase =						pt_weights["visual.conv1.weight"].data
		UpperCamelCase =						pt_weights["visual.class_embedding"].data
		UpperCamelCase =						pt_weights["visual.positional_embedding"].data

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


@torch.no_grad()
def    a__       (       _SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE=None     ):




		"""simple docstring"""


		assert config_path is not None, "Please specify the ChineseCLIP model config of the corresponding model size."
		UpperCamelCase =						ChineseCLIPConfig.from_pretrained(_SCREAMING_SNAKE_CASE     )

		UpperCamelCase =						ChineseCLIPModel(_SCREAMING_SNAKE_CASE     ).eval()

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

		copy_text_model_and_projection(_SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE     )
		copy_vision_model_and_projection(_SCREAMING_SNAKE_CASE	,						_SCREAMING_SNAKE_CASE     )
		UpperCamelCase =						pt_weights["logit_scale"].data

		hf_model.save_pretrained(_SCREAMING_SNAKE_CASE     )


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

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













"""simple docstring"""





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


lowerCAmelCase__        =      logging.get_logger(__name__)





class 							_lowerCamelCase   (							_lowercase			):


						def __init__(self ,				__a = None ,				__a = None ,				__a = None ,				__a = None ,				__a = None ,				__a = None ,				__a = None ,				__a = None ,				__a = None ,				__a = (None, None) ,				__a = None ,				)			-> List[Any]:
								super().__init__(
								    model=__a ,				args=__a ,				data_collator=__a ,				train_dataset=__a ,				eval_dataset=__a ,				tokenizer=__a ,				model_init=__a ,				compute_metrics=__a ,				callbacks=__a ,				optimizers=__a ,				preprocess_logits_for_metrics=__a ,				)

								# 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:
										UpperCamelCase =						self.load_generation_config(self.args.generation_config		)
										UpperCamelCase =						gen_config


						@staticmethod
						def      snake_case_ (__a		)			-> GenerationConfig:

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

								# str or Path
								UpperCamelCase =						Path(__a		) if isinstance(__a ,				__a		) else gen_config_arg
								UpperCamelCase =						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():
										UpperCamelCase =						pretrained_model_name.name
										UpperCamelCase =						pretrained_model_name.parent
								# dir path
								elif pretrained_model_name.is_dir():
										pass
								# model id or URL
								else:
										UpperCamelCase =						gen_config_arg

								UpperCamelCase =						GenerationConfig.from_pretrained(__a ,				__a		)
								return gen_config


						def      snake_case_ (self ,				__a = None ,				__a = None ,				__a = "eval" ,				**__a ,				)			-> Dict[str, float]:
								UpperCamelCase =						gen_kwargs.copy()
								if gen_kwargs.get("max_length"		) is None and gen_kwargs.get("max_new_tokens"		) is None:
										UpperCamelCase =						self.args.generation_max_length
								UpperCamelCase =						(
								    gen_kwargs["num_beams"] if gen_kwargs.get("num_beams"		) is not None else self.args.generation_num_beams
								)
								UpperCamelCase =						gen_kwargs

								return super().evaluate(__a ,				ignore_keys=__a ,				metric_key_prefix=__a		)


						def      snake_case_ (self ,				__a ,				__a = None ,				__a = "test" ,				**__a ,				)			-> "PredictionOutput":
								UpperCamelCase =						gen_kwargs.copy()
								if gen_kwargs.get("max_length"		) is None and gen_kwargs.get("max_new_tokens"		) is None:
										UpperCamelCase =						self.args.generation_max_length
								UpperCamelCase =						(
								    gen_kwargs["num_beams"] if gen_kwargs.get("num_beams"		) is not None else self.args.generation_num_beams
								)
								UpperCamelCase =						gen_kwargs

								return super().predict(__a ,				ignore_keys=__a ,				metric_key_prefix=__a		)


						def      snake_case_ (self ,				__a ,				__a ,				__a ,				__a = None ,				**__a ,				)			-> Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:

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

								UpperCamelCase =						"labels" in inputs
								UpperCamelCase =						self._prepare_inputs(__a		)

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

								if len(__a		) == 0 and hasattr(self ,				"_gen_kwargs"		):
										UpperCamelCase =						self._gen_kwargs.copy()

								if gen_kwargs.get("max_length"		) is None and gen_kwargs.get("max_new_tokens"		) is None:
										UpperCamelCase =						self.model.config.max_length
								UpperCamelCase =						(
								    gen_kwargs["num_beams"] if gen_kwargs.get("num_beams"		) is not None else self.model.config.num_beams
								)
								UpperCamelCase =						True if is_deepspeed_zeroa_enabled() else False
								UpperCamelCase =						(
								    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
								):
										UpperCamelCase =						{k: v for k, v in inputs.items() if k != "decoder_input_ids"}
								UpperCamelCase =						self.model.generate(**__a ,				**__a		)

								# 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:
										UpperCamelCase =						False

								# Retrieves GenerationConfig from model.generation_config
								UpperCamelCase =						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:
										UpperCamelCase =						self._pad_tensors_to_max_len(__a ,				gen_config.max_length		)
								elif gen_config.max_new_tokens is not None and generated_tokens.shape[-1] < gen_config.max_new_tokens + 1:
										UpperCamelCase =						self._pad_tensors_to_max_len(__a ,				gen_config.max_new_tokens + 1		)

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

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

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

								return loss, generated_tokens, labels




						def      snake_case_ (self ,				__a ,				__a		)			-> 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
										UpperCamelCase =						(
										    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:
												UpperCamelCase =						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"		)

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






