





from cva import destroyAllWindows, imread, imshow, waitKey






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






				"""simple docstring"""


				snake_case_						:   Tuple           =  img.shape[0], img.shape[1]

				# converting each pixel's color to its negative
				for i in range(_UpperCamelCase			):
								for j in range(_UpperCamelCase			):
												snake_case_						:   List[str]           =  [255, 255, 255] - img[i][j]

				return img


if __name__ == "__main__":
	# read original image
	lowerCAmelCase_    =    imread('''image_data/lena.jpg''', 1)

	# convert to its negative
	lowerCAmelCase_    =    convert_to_negative(img)

	# show result image
	imshow('''negative of original image''', img)
	waitKey(0)
	destroyAllWindows()







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_    =    None
lowerCAmelCase_    =    {
    '''7B''': 1_1_0_0_8,
    '''13B''': 1_3_8_2_4,
    '''30B''': 1_7_9_2_0,
    '''65B''': 2_2_0_1_6,
    '''70B''': 2_8_6_7_2,
}
lowerCAmelCase_    =    {
    '''7B''': 1,
    '''7Bf''': 1,
    '''13B''': 2,
    '''13Bf''': 2,
    '''30B''': 4,
    '''65B''': 8,
    '''70B''': 8,
    '''70Bf''': 8,
}






def 					lowerCamelCase_						(    _UpperCamelCase			,    _UpperCamelCase=1			,    _UpperCamelCase=256			)		->						Optional[int]:






				"""simple docstring"""


				return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3			)			) + multiple_of - 1) // multiple_of)






def 					lowerCamelCase_						(    _UpperCamelCase			)		->						Optional[Any]:






				"""simple docstring"""


				with open(_UpperCamelCase			,    '''r'''			) as f:
								return json.load(_UpperCamelCase			)






def 					lowerCamelCase_						(    _UpperCamelCase			,    _UpperCamelCase			)		->						int:






				"""simple docstring"""


				with open(_UpperCamelCase			,    '''w'''			) as f:
								json.dump(_UpperCamelCase			,    _UpperCamelCase			)






def 					lowerCamelCase_						(    _UpperCamelCase			,    _UpperCamelCase			,    _UpperCamelCase			,    _UpperCamelCase=True			)		->						Optional[Any]:






				"""simple docstring"""


				os.makedirs(_UpperCamelCase			,    exist_ok=_UpperCamelCase			)
				snake_case_						:   int           =  os.path.join(_UpperCamelCase			,    '''tmp'''			)
				os.makedirs(_UpperCamelCase			,    exist_ok=_UpperCamelCase			)

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

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

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

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

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

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

								snake_case_						:   str           =  inv_freq
								for k, v in state_dict.items():
												snake_case_						:   Dict           =  filename
												param_count += v.numel()
								torch.save(_UpperCamelCase			,    os.path.join(_UpperCamelCase			,    _UpperCamelCase			)			)

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

				for k, v in state_dict.items():
								snake_case_						:   List[str]           =  filename
								param_count += v.numel()
				torch.save(_UpperCamelCase			,    os.path.join(_UpperCamelCase			,    _UpperCamelCase			)			)

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

				# 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.'''			)
				snake_case_						:   Union[str, Any]           =  LlamaForCausalLM.from_pretrained(_UpperCamelCase			,    torch_dtype=torch.floataa			,    low_cpu_mem_usage=_UpperCamelCase			)
				# Avoid saving this as part of the config.
				del model.config._name_or_path

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






def 					lowerCamelCase_						(    _UpperCamelCase			,    _UpperCamelCase			)		->						List[str]:






				"""simple docstring"""


				snake_case_						:   Union[str, Any]           =  LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
				print(f'''Saving a {tokenizer_class.__name__} to {tokenizer_path}.'''			)
				snake_case_						:   Union[str, Any]           =  tokenizer_class(_UpperCamelCase			)
				tokenizer.save_pretrained(_UpperCamelCase			)






def 					lowerCamelCase_						(    )		->						int:






				"""simple docstring"""


				snake_case_						:   Union[str, 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=_UpperCamelCase			,    help='''Whether or not to save using `safetensors`.'''			)
				snake_case_						:   Dict           =  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			,    )
				snake_case_						:   Dict           =  os.path.join(args.input_dir			,    '''tokenizer.model'''			)
				write_tokenizer(args.output_dir			,    _UpperCamelCase			)


if __name__ == "__main__":
	main()
