


'''simple docstring'''



import argparse
import gc
import json
import os
import shutil
import warnings

import torch

from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer


try:
		from transformers import LlamaTokenizerFast
except ImportError as e:
		warnings.warn(e)
		warnings.warn(
		    'The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion'
		)
		__A	=None
__A	={
    '7B': 1_10_08,
    '13B': 1_38_24,
    '30B': 1_79_20,
    '65B': 2_20_16,
    '70B': 2_86_72,
}
__A	={
    '7B': 1,
    '7Bf': 1,
    '13B': 2,
    '13Bf': 2,
    '30B': 4,
    '65B': 8,
    '70B': 8,
    '70Bf': 8,
}







def     _UpperCamelCase      (		UpperCamelCase__ ,      UpperCamelCase__=1 ,      UpperCamelCase__=2_5_6					)     ->   Union[str, Any]:
			return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3					)					) + multiple_of - 1) // multiple_of)







def     _UpperCamelCase      (		UpperCamelCase__					)     ->   List[str]:







			with open(__snake_case ,      """r"""					) as f:
						return json.load(__snake_case					)







def     _UpperCamelCase      (		UpperCamelCase__ ,      UpperCamelCase__					)     ->   int:







			with open(__snake_case ,      """w"""					) as f:
						json.dump(__snake_case ,      __snake_case					)







def     _UpperCamelCase      (		UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__=True					)     ->   List[Any]:
			os.makedirs(__snake_case ,      exist_ok=__snake_case					)
			UpperCAmelCase__  :					Optional[Any]        =     os.path.join(__snake_case ,      """tmp"""					)
			os.makedirs(__snake_case ,      exist_ok=__snake_case					)

			UpperCAmelCase__  :					int        =     read_json(os.path.join(__snake_case ,      """params.json"""					)					)
			UpperCAmelCase__  :					int        =     NUM_SHARDS[model_size]
			UpperCAmelCase__  :					Union[str, Any]        =     params["""n_layers"""]
			UpperCAmelCase__  :					Any        =     params["""n_heads"""]
			UpperCAmelCase__  :					Optional[Any]        =     n_heads // num_shards
			UpperCAmelCase__  :					Optional[int]        =     params["""dim"""]
			UpperCAmelCase__  :					Any        =     dim // n_heads
			UpperCAmelCase__  :					List[str]        =     1_0_0_0_0.0
			UpperCAmelCase__  :					Optional[int]        =     1.0 / (base ** (torch.arange(0 ,      __snake_case ,      2					).float() / dims_per_head))

			if "n_kv_heads" in params:
						UpperCAmelCase__  :					Optional[Any]        =     params["""n_kv_heads"""]  # for GQA / MQA
						UpperCAmelCase__  :					Any        =     n_heads_per_shard // num_key_value_heads
						UpperCAmelCase__  :					Optional[int]        =     dim // num_key_value_heads
			else:  # compatibility with other checkpoints
						UpperCAmelCase__  :					Any        =     n_heads
						UpperCAmelCase__  :					List[str]        =     n_heads_per_shard
						UpperCAmelCase__  :					int        =     dim

			# permute for sliced rotary
			def permute(UpperCamelCase__ ,      UpperCamelCase__=n_heads ,      UpperCamelCase__=dim ,      UpperCamelCase__=dim					):
						return w.view(__snake_case ,      dima // n_heads // 2 ,      2 ,      __snake_case					).transpose(1 ,      2					).reshape(__snake_case ,      __snake_case					)

			print(f'''Fetching all parameters from the checkpoint at {input_base_path}.'''					)
			# Load weights
			if model_size == "7B":
						# Not sharded
						# (The sharded implementation would also work, but this is simpler.)
						UpperCAmelCase__  :					Tuple        =     torch.load(os.path.join(__snake_case ,      """consolidated.00.pth"""					) ,      map_location="""cpu"""					)
			else:
						# Sharded
						UpperCAmelCase__  :					List[str]        =     [
						    torch.load(os.path.join(__snake_case ,      f'''consolidated.{i:02d}.pth'''					) ,      map_location="""cpu"""					)
						    for i in range(__snake_case					)
						]
			UpperCAmelCase__  :					int        =     0
			UpperCAmelCase__  :					Any        =     {"""weight_map""": {}}
			for layer_i in range(__snake_case					):
						UpperCAmelCase__  :					str        =     f'''pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin'''
						if model_size == "7B":
									# Unsharded
									UpperCAmelCase__  :					List[str]        =     {
									    f'''model.layers.{layer_i}.self_attn.q_proj.weight''': permute(
									        loaded[f'''layers.{layer_i}.attention.wq.weight''']					),
									    f'''model.layers.{layer_i}.self_attn.k_proj.weight''': permute(
									        loaded[f'''layers.{layer_i}.attention.wk.weight''']					),
									    f'''model.layers.{layer_i}.self_attn.v_proj.weight''': loaded[f'''layers.{layer_i}.attention.wv.weight'''],
									    f'''model.layers.{layer_i}.self_attn.o_proj.weight''': loaded[f'''layers.{layer_i}.attention.wo.weight'''],
									    f'''model.layers.{layer_i}.mlp.gate_proj.weight''': loaded[f'''layers.{layer_i}.feed_forward.w1.weight'''],
									    f'''model.layers.{layer_i}.mlp.down_proj.weight''': loaded[f'''layers.{layer_i}.feed_forward.w2.weight'''],
									    f'''model.layers.{layer_i}.mlp.up_proj.weight''': loaded[f'''layers.{layer_i}.feed_forward.w3.weight'''],
									    f'''model.layers.{layer_i}.input_layernorm.weight''': loaded[f'''layers.{layer_i}.attention_norm.weight'''],
									    f'''model.layers.{layer_i}.post_attention_layernorm.weight''': loaded[f'''layers.{layer_i}.ffn_norm.weight'''],
									}
						else:
									# Sharded
									# Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
									# the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
									# redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.

									UpperCAmelCase__  :					Tuple        =     {
									    f'''model.layers.{layer_i}.input_layernorm.weight''': loaded[0][
									        f'''layers.{layer_i}.attention_norm.weight'''
									    ].clone(),
									    f'''model.layers.{layer_i}.post_attention_layernorm.weight''': loaded[0][
									        f'''layers.{layer_i}.ffn_norm.weight'''
									    ].clone(),
									}
									UpperCAmelCase__  :					Tuple        =     permute(
									    torch.cat(
									        [
									            loaded[i][f'''layers.{layer_i}.attention.wq.weight'''].view(__snake_case ,      __snake_case ,      __snake_case					)
									            for i in range(__snake_case					)
									        ] ,      dim=0 ,      ).reshape(__snake_case ,      __snake_case					)					)
									UpperCAmelCase__  :					Optional[Any]        =     permute(
									    torch.cat(
									        [
									            loaded[i][f'''layers.{layer_i}.attention.wk.weight'''].view(
									                __snake_case ,      __snake_case ,      __snake_case					)
									            for i in range(__snake_case					)
									        ] ,      dim=0 ,      ).reshape(__snake_case ,      __snake_case					) ,      __snake_case ,      __snake_case ,      __snake_case ,      )
									UpperCAmelCase__  :					str        =     torch.cat(
									    [
									        loaded[i][f'''layers.{layer_i}.attention.wv.weight'''].view(
									            __snake_case ,      __snake_case ,      __snake_case					)
									        for i in range(__snake_case					)
									    ] ,      dim=0 ,      ).reshape(__snake_case ,      __snake_case					)

									UpperCAmelCase__  :					Dict        =     torch.cat(
									    [loaded[i][f'''layers.{layer_i}.attention.wo.weight'''] for i in range(__snake_case					)] ,      dim=1					)
									UpperCAmelCase__  :					List[str]        =     torch.cat(
									    [loaded[i][f'''layers.{layer_i}.feed_forward.w1.weight'''] for i in range(__snake_case					)] ,      dim=0					)
									UpperCAmelCase__  :					Any        =     torch.cat(
									    [loaded[i][f'''layers.{layer_i}.feed_forward.w2.weight'''] for i in range(__snake_case					)] ,      dim=1					)
									UpperCAmelCase__  :					List[Any]        =     torch.cat(
									    [loaded[i][f'''layers.{layer_i}.feed_forward.w3.weight'''] for i in range(__snake_case					)] ,      dim=0					)

						UpperCAmelCase__  :					Dict        =     inv_freq
						for k, v in state_dict.items():
									UpperCAmelCase__  :					Optional[int]        =     filename
									param_count += v.numel()
						torch.save(__snake_case ,      os.path.join(__snake_case ,      __snake_case					)					)

			UpperCAmelCase__  :					Dict        =     f'''pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin'''
			if model_size == "7B":
						# Unsharded
						UpperCAmelCase__  :					Dict        =     {
						    """model.embed_tokens.weight""": loaded["""tok_embeddings.weight"""],
						    """model.norm.weight""": loaded["""norm.weight"""],
						    """lm_head.weight""": loaded["""output.weight"""],
						}
			else:
						UpperCAmelCase__  :					List[Any]        =     {
						    """model.norm.weight""": loaded[0]["""norm.weight"""],
						    """model.embed_tokens.weight""": torch.cat(
						        [loaded[i]["""tok_embeddings.weight"""] for i in range(__snake_case					)] ,      dim=1					),
						    """lm_head.weight""": torch.cat([loaded[i]["""output.weight"""] for i in range(__snake_case					)] ,      dim=0					),
						}

			for k, v in state_dict.items():
						UpperCAmelCase__  :					Optional[Any]        =     filename
						param_count += v.numel()
			torch.save(__snake_case ,      os.path.join(__snake_case ,      __snake_case					)					)

			# Write configs
			UpperCAmelCase__  :					str        =     {"""total_size""": param_count * 2}
			write_json(__snake_case ,      os.path.join(__snake_case ,      """pytorch_model.bin.index.json"""					)					)
			UpperCAmelCase__  :					Dict        =     params["""ffn_dim_multiplier"""] if """ffn_dim_multiplier""" in params else 1
			UpperCAmelCase__  :					Union[str, Any]        =     params["""multiple_of"""] if """multiple_of""" in params else 2_5_6
			UpperCAmelCase__  :					Tuple        =     LlamaConfig(
			    hidden_size=__snake_case ,      intermediate_size=compute_intermediate_size(__snake_case ,      __snake_case ,      __snake_case					) ,      num_attention_heads=params["""n_heads"""] ,      num_hidden_layers=params["""n_layers"""] ,      rms_norm_eps=params["""norm_eps"""] ,      num_key_value_heads=__snake_case ,      )
			config.save_pretrained(__snake_case					)

			# Make space so we can load the model properly now.
			del state_dict
			del loaded
			gc.collect()

			print("""Loading the checkpoint in a Llama model."""					)
			UpperCAmelCase__  :					Union[str, Any]        =     LlamaForCausalLM.from_pretrained(__snake_case ,      torch_dtype=torch.floataa ,      low_cpu_mem_usage=__snake_case					)
			# Avoid saving this as part of the config.
			del model.config._name_or_path

			print("""Saving in the Transformers format."""					)
			model.save_pretrained(__snake_case ,      safe_serialization=__snake_case					)
			shutil.rmtree(__snake_case					)







def     _UpperCamelCase      (		UpperCamelCase__ ,      UpperCamelCase__					)     ->   List[Any]:
			UpperCAmelCase__  :					Optional[int]        =     LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
			print(f'''Saving a {tokenizer_class.__name__} to {tokenizer_path}.'''					)
			UpperCAmelCase__  :					Any        =     tokenizer_class(__snake_case					)
			tokenizer.save_pretrained(__snake_case					)







def     _UpperCamelCase      (		)     ->   Optional[int]:
			UpperCAmelCase__  :					Optional[Any]        =     argparse.ArgumentParser()
			parser.add_argument(
			    """--input_dir""" ,      help="""Location of LLaMA weights, which contains tokenizer.model and model folders""" ,      )
			parser.add_argument(
			    """--model_size""" ,      choices=["""7B""", """7Bf""", """13B""", """13Bf""", """30B""", """65B""", """70B""", """70Bf""", """tokenizer_only"""] ,      )
			parser.add_argument(
			    """--output_dir""" ,      help="""Location to write HF model and tokenizer""" ,      )
			parser.add_argument("""--safe_serialization""" ,      type=__snake_case ,      help="""Whether or not to save using `safetensors`."""					)
			UpperCAmelCase__  :					Optional[int]        =     parser.parse_args()
			if args.model_size != "tokenizer_only":
						write_model(
						    model_path=args.output_dir ,      input_base_path=os.path.join(args.input_dir ,      args.model_size					) ,      model_size=args.model_size ,      safe_serialization=args.safe_serialization ,      )
			UpperCAmelCase__  :					int        =     os.path.join(args.input_dir ,      """tokenizer.model"""					)
			write_tokenizer(args.output_dir ,      __snake_case					)


if __name__ == "__main__":
		main()



'''simple docstring'''



from typing import Any, Dict, List, Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
		from ..image_utils import load_image


if is_torch_available():
		import torch

		from ..models.auto.modeling_auto import MODEL_FOR_OBJECT_DETECTION_MAPPING, MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING

__A	=logging.get_logger(__name__)


__A	=Dict[str, Any]
__A	=List[Prediction]


@add_end_docstrings(a__	)
class 		_snake_case					(     a__	):




					def __init__(      self							,							*_lowerCamelCase							,							**_lowerCamelCase):
								super().__init__(*_lowerCamelCase							,							**_lowerCamelCase)

								if self.framework == "tf":
											raise ValueError(f'''The {self.__class__} is only available in PyTorch.''')

								requires_backends(self							,							"""vision""")
								self.check_model_type(
								    dict(MODEL_FOR_OBJECT_DETECTION_MAPPING.items() + MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING.items()))




					def 				snake_case__						(      self							,							**_lowerCamelCase):
								UpperCAmelCase__  :					int        =     {}
								if "threshold" in kwargs:
											UpperCAmelCase__  :					List[str]        =     kwargs["""threshold"""]
								return {}, {}, postprocess_kwargs




					def __call__(      self							,							*_lowerCamelCase							,							**_lowerCamelCase):
								return super().__call__(*_lowerCamelCase							,							**_lowerCamelCase)




					def 				snake_case__						(      self							,							_lowerCamelCase):
								UpperCAmelCase__  :					List[Any]        =     load_image(_lowerCamelCase)
								UpperCAmelCase__  :					Dict        =     torch.IntTensor([[image.height, image.width]])
								UpperCAmelCase__  :					str        =     self.image_processor(images=[image]							,							return_tensors="""pt""")
								if self.tokenizer is not None:
											UpperCAmelCase__  :					Tuple        =     self.tokenizer(text=inputs["""words"""]							,							boxes=inputs["""boxes"""]							,							return_tensors="""pt""")
								UpperCAmelCase__  :					str        =     target_size
								return inputs




					def 				snake_case__						(      self							,							_lowerCamelCase):
								UpperCAmelCase__  :					Optional[int]        =     model_inputs.pop("""target_size""")
								UpperCAmelCase__  :					Optional[Any]        =     self.model(**_lowerCamelCase)
								UpperCAmelCase__  :					Union[str, Any]        =     outputs.__class__({"""target_size""": target_size, **outputs})
								if self.tokenizer is not None:
											UpperCAmelCase__  :					int        =     model_inputs["""bbox"""]
								return model_outputs




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase=0.9):
								UpperCAmelCase__  :					Optional[Any]        =     model_outputs["""target_size"""]
								if self.tokenizer is not None:
											# This is a LayoutLMForTokenClassification variant.
											# The OCR got the boxes and the model classified the words.
											UpperCAmelCase__   ,       UpperCAmelCase__  :					Optional[int]        =     target_size[0].tolist()

											def unnormalize(_lowerCamelCase):
														return self._get_bounding_box(
														    torch.Tensor(
														        [
														            (width * bbox[0] / 1000),
														            (height * bbox[1] / 1000),
														            (width * bbox[2] / 1000),
														            (height * bbox[3] / 1000),
														        ]))

											UpperCAmelCase__   ,       UpperCAmelCase__  :					Tuple        =     model_outputs["""logits"""].squeeze(0).softmax(dim=-1).max(dim=-1)
											UpperCAmelCase__  :					List[Any]        =     [self.model.config.idalabel[prediction] for prediction in classes.tolist()]
											UpperCAmelCase__  :					Tuple        =     [unnormalize(_lowerCamelCase) for bbox in model_outputs["""bbox"""].squeeze(0)]
											UpperCAmelCase__  :					Tuple        =     ["""score""", """label""", """box"""]
											UpperCAmelCase__  :					Dict        =     [dict(zip(_lowerCamelCase							,							_lowerCamelCase)) for vals in zip(scores.tolist()							,							_lowerCamelCase							,							_lowerCamelCase) if vals[0] > threshold]
								else:
											# This is a regular ForObjectDetectionModel
											UpperCAmelCase__  :					Union[str, Any]        =     self.image_processor.post_process_object_detection(_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase)
											UpperCAmelCase__  :					int        =     raw_annotations[0]
											UpperCAmelCase__  :					Any        =     raw_annotation["""scores"""]
											UpperCAmelCase__  :					List[str]        =     raw_annotation["""labels"""]
											UpperCAmelCase__  :					str        =     raw_annotation["""boxes"""]

											UpperCAmelCase__  :					Tuple        =     scores.tolist()
											UpperCAmelCase__  :					int        =     [self.model.config.idalabel[label.item()] for label in labels]
											UpperCAmelCase__  :					int        =     [self._get_bounding_box(_lowerCamelCase) for box in boxes]

											# {"scores": [...], ...} --> [{"score":x, ...}, ...]
											UpperCAmelCase__  :					Dict        =     ["""score""", """label""", """box"""]
											UpperCAmelCase__  :					Optional[int]        =     [
											    dict(zip(_lowerCamelCase							,							_lowerCamelCase))
											    for vals in zip(raw_annotation["""scores"""]							,							raw_annotation["""labels"""]							,							raw_annotation["""boxes"""])
											]

								return annotation




					def 				snake_case__						(      self							,							_lowerCamelCase):
								if self.framework != "pt":
											raise ValueError("""The ObjectDetectionPipeline is only available in PyTorch.""")
								UpperCAmelCase__   ,       UpperCAmelCase__   ,       UpperCAmelCase__   ,       UpperCAmelCase__  :					Union[str, Any]        =     box.int().tolist()
								UpperCAmelCase__  :					Dict        =     {
								    """xmin""": xmin,
								    """ymin""": ymin,
								    """xmax""": xmax,
								    """ymax""": ymax,
								}
								return bbox