


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'
				)
				lowerCAmelCase__			:      Dict								=None
lowerCAmelCase__			:      Optional[int]								={
    '7B': 1_10_08,
    '13B': 1_38_24,
    '30B': 1_79_20,
    '65B': 2_20_16,
    '70B': 2_86_72,
}
lowerCAmelCase__			:      List[str]								={
    '7B': 1,
    '7Bf': 1,
    '13B': 2,
    '13Bf': 2,
    '30B': 4,
    '65B': 8,
    '70B': 8,
    '70Bf': 8,
}






def 						a__			(				A__,      A__=1,      A__=2_5_6				):
			return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3				)				) + multiple_of - 1) // multiple_of)






def 						a__			(				A__				):
			with open(__lowerCamelCase,      'r'				) as f:
						return json.load(__lowerCamelCase				)






def 						a__			(				A__,      A__				):
			with open(__lowerCamelCase,      'w'				) as f:
						json.dump(__lowerCamelCase,      __lowerCamelCase				)






def 						a__			(				A__,      A__,      A__,      A__=True				):
			os.makedirs(__lowerCamelCase,      exist_ok=__lowerCamelCase				)
			SCREAMING_SNAKE_CASE_		:     Dict					=					os.path.join(__lowerCamelCase,      'tmp'				)
			os.makedirs(__lowerCamelCase,      exist_ok=__lowerCamelCase				)

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

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

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

			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.)
						SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					torch.load(os.path.join(__lowerCamelCase,      'consolidated.00.pth'				),      map_location='cpu'				)
			else:
						# Sharded
						SCREAMING_SNAKE_CASE_		:     List[str]					=					[
						    torch.load(os.path.join(__lowerCamelCase,      F'''consolidated.{i:02d}.pth'''				),      map_location='cpu'				)
						    for i in range(__lowerCamelCase				)
						]
			SCREAMING_SNAKE_CASE_		:     Any					=					0
			SCREAMING_SNAKE_CASE_		:     Optional[int]					=					{'weight_map': {}}
			for layer_i in range(__lowerCamelCase				):
						SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					F'''pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin'''
						if model_size == "7B":
									# Unsharded
									SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					{
									    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.

									SCREAMING_SNAKE_CASE_		:     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(),
									}
									SCREAMING_SNAKE_CASE_		:     str					=					permute(
									    torch.cat(
									        [
									            loaded[i][F'''layers.{layer_i}.attention.wq.weight'''].view(__lowerCamelCase,      __lowerCamelCase,      __lowerCamelCase				)
									            for i in range(__lowerCamelCase				)
									        ],      dim=0,      ).reshape(__lowerCamelCase,      __lowerCamelCase				)				)
									SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					permute(
									    torch.cat(
									        [
									            loaded[i][F'''layers.{layer_i}.attention.wk.weight'''].view(
									                __lowerCamelCase,      __lowerCamelCase,      __lowerCamelCase				)
									            for i in range(__lowerCamelCase				)
									        ],      dim=0,      ).reshape(__lowerCamelCase,      __lowerCamelCase				),      __lowerCamelCase,      __lowerCamelCase,      __lowerCamelCase,      )
									SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					torch.cat(
									    [
									        loaded[i][F'''layers.{layer_i}.attention.wv.weight'''].view(
									            __lowerCamelCase,      __lowerCamelCase,      __lowerCamelCase				)
									        for i in range(__lowerCamelCase				)
									    ],      dim=0,      ).reshape(__lowerCamelCase,      __lowerCamelCase				)

									SCREAMING_SNAKE_CASE_		:     Any					=					torch.cat(
									    [loaded[i][F'''layers.{layer_i}.attention.wo.weight'''] for i in range(__lowerCamelCase				)],      dim=1				)
									SCREAMING_SNAKE_CASE_		:     Tuple					=					torch.cat(
									    [loaded[i][F'''layers.{layer_i}.feed_forward.w1.weight'''] for i in range(__lowerCamelCase				)],      dim=0				)
									SCREAMING_SNAKE_CASE_		:     str					=					torch.cat(
									    [loaded[i][F'''layers.{layer_i}.feed_forward.w2.weight'''] for i in range(__lowerCamelCase				)],      dim=1				)
									SCREAMING_SNAKE_CASE_		:     int					=					torch.cat(
									    [loaded[i][F'''layers.{layer_i}.feed_forward.w3.weight'''] for i in range(__lowerCamelCase				)],      dim=0				)

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

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

			for k, v in state_dict.items():
						SCREAMING_SNAKE_CASE_		:     int					=					filename
						param_count += v.numel()
			torch.save(__lowerCamelCase,      os.path.join(__lowerCamelCase,      __lowerCamelCase				)				)

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

			# 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.'				)
			SCREAMING_SNAKE_CASE_		:     int					=					LlamaForCausalLM.from_pretrained(__lowerCamelCase,      torch_dtype=torch.floataa,      low_cpu_mem_usage=__lowerCamelCase				)
			# Avoid saving this as part of the config.
			del model.config._name_or_path

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






def 						a__			(				A__,      A__				):
			# Initialize the tokenizer based on the `spm` model
			SCREAMING_SNAKE_CASE_		:     Optional[int]					=					LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
			print(F'''Saving a {tokenizer_class.__name__} to {tokenizer_path}.'''				)
			SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					tokenizer_class(__lowerCamelCase				)
			tokenizer.save_pretrained(__lowerCamelCase				)






def 						a__			(				):
			SCREAMING_SNAKE_CASE_		:     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=__lowerCamelCase,      help='Whether or not to save using `safetensors`.'				)
			SCREAMING_SNAKE_CASE_		:     Any					=					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,      )
			SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					os.path.join(args.input_dir,      'tokenizer.model'				)
			write_tokenizer(args.output_dir,      __lowerCamelCase				)


if __name__ == "__main__":
				main()







'''simple docstring'''



from manim import *




class     UpperCAmelCase_	(						_SCREAMING_SNAKE_CASE					):






						'''simple docstring'''






						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					Rectangle(height=0.5       ,  width=0.5 )
												_lowerCAmelCase    		=					Rectangle(height=0.46       ,  width=0.46 ).set_stroke(width=0 )

												_lowerCAmelCase    		=					[mem.copy() for i in range(6 )]
												_lowerCAmelCase    		=					[mem.copy() for i in range(6 )]
												_lowerCAmelCase    		=					VGroup(*_lowercase ).arrange(_lowercase       ,  buff=0 )
												_lowerCAmelCase    		=					VGroup(*_lowercase ).arrange(_lowercase       ,  buff=0 )
												_lowerCAmelCase    		=					VGroup(_lowercase       ,  _lowercase ).arrange(_lowercase       ,  buff=0 )
												_lowerCAmelCase    		=					Text("""CPU"""       ,  font_size=24 )
												_lowerCAmelCase    		=					Group(_lowercase       ,  _lowercase ).arrange(_lowercase       ,  buff=0.5       ,  aligned_edge=_lowercase )
												cpu.move_to([-2.5, -0.5, 0] )
												self.add(_lowercase )

												_lowerCAmelCase    		=					[mem.copy() for i in range(1 )]
												_lowerCAmelCase    		=					VGroup(*_lowercase ).arrange(_lowercase       ,  buff=0 )
												_lowerCAmelCase    		=					Text("""GPU"""       ,  font_size=24 )
												_lowerCAmelCase    		=					Group(_lowercase       ,  _lowercase ).arrange(_lowercase       ,  buff=0.5       ,  aligned_edge=_lowercase )
												gpu.align_to(_lowercase       ,  _lowercase )
												gpu.set_x(gpu.get_x() - 1 )

												self.add(_lowercase )

												_lowerCAmelCase    		=					[mem.copy() for i in range(6 )]
												_lowerCAmelCase    		=					VGroup(*_lowercase ).arrange(_lowercase       ,  buff=0 )

												_lowerCAmelCase    		=					Text("""Model"""       ,  font_size=24 )
												_lowerCAmelCase    		=					Group(_lowercase       ,  _lowercase ).arrange(_lowercase       ,  buff=0.5       ,  aligned_edge=_lowercase )
												model.move_to([3, -1.0, 0] )

												self.play(
												    Create(_lowercase       ,  run_time=1 )       ,  Create(_lowercase       ,  run_time=1 )       ,  Create(_lowercase       ,  run_time=1 )       ,  )

												_lowerCAmelCase    		=					MarkupText(
												    F'First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.'       ,  font_size=24       ,  )

												_lowerCAmelCase    		=					Square(side_length=2.2 )
												key.move_to([-5, 2, 0] )

												_lowerCAmelCase    		=					MarkupText(
												    F'<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'       ,  font_size=18       ,  )

												key_text.move_to([-5, 2.4, 0] )

												step_a.move_to([2, 2, 0] )
												self.play(Write(_lowercase       ,  run_time=2.5 )       ,  Write(_lowercase )       ,  Write(_lowercase ) )

												self.add(_lowercase )

												_lowerCAmelCase    		=					[]
												_lowerCAmelCase    		=					[]
												_lowerCAmelCase    		=					[]
												for i, rect in enumerate(_lowercase ):
																		_lowerCAmelCase    		=					Rectangle(height=0.46       ,  width=0.46 ).set_stroke(width=0.0 ).set_fill(_lowercase       ,  opacity=0.7 )
																		cpu_target.move_to(_lowercase )
																		cpu_target.generate_target()
																		_lowerCAmelCase    		=					0.46 / 4
																		_lowerCAmelCase    		=					0.46 / 3

																		if i == 0:
																								cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT )       ,  buff=0.02       ,  direction=_lowercase )
																								cpu_target.target.set_x(cpu_target.target.get_x() + 0.1 )
																		elif i == 3:
																								cpu_target.target.next_to(cpu_targs[0].target       ,  direction=_lowercase       ,  buff=0.0 )
																		else:
																								cpu_target.target.next_to(cpu_targs[i - 1].target       ,  direction=_lowercase       ,  buff=0.0 )
																		cpu_targs.append(_lowercase )

																		first_animations.append(rect.animate(run_time=0.5 ).set_stroke(_lowercase ) )
																		second_animations.append(MoveToTarget(_lowercase       ,  run_time=1.5 ) )

												self.play(*_lowercase )
												self.play(*_lowercase )

												self.wait()
