






'''simple docstring'''

import argparse
import json
import os
import re

import torch

from transformers import BloomConfig, BloomModel
from transformers.file_utils import CONFIG_NAME, WEIGHTS_NAME
from transformers.utils import logging


logging.set_verbosity_info()

lowerCAmelCase				:Optional[int]        =      [
    '''word_embeddings_layernorm.weight''',
    '''word_embeddings_layernorm.bias''',
    '''input_layernorm.weight''',
    '''input_layernorm.bias''',
    '''post_attention_layernorm.weight''',
    '''post_attention_layernorm.bias''',
    '''self_attention.dense.bias''',
    '''mlp.dense_4h_to_h.bias''',
    '''ln_f.weight''',
    '''ln_f.bias''',
]

lowerCAmelCase				:Any        =      [
    '''mlp.dense_4h_to_h.weight''',
    '''self_attention.dense.weight''',
]





def lowerCamelCase      (      lowerCAmelCase    :     Tuple		,		lowerCAmelCase    :     List[str]		):





	"""simple docstring"""







	__magic_name__	:   Tuple					     =					{
	    'word_embeddings.weight': 'word_embeddings.weight',
	    'word_embeddings.norm.weight': 'word_embeddings_layernorm.weight',
	    'word_embeddings.norm.bias': 'word_embeddings_layernorm.bias',
	    'weight': 'ln_f.weight',
	    'bias': 'ln_f.bias',
	}

	if key in layer_rename_map:
		return layer_rename_map[key]

	# Handle transformer blocks
	__magic_name__	:   List[str]					     =					int(re.match(R'.*layer_(\d*).*'		,		lowerCAmelCase		)[1]		)
	layer_number -= 3
	return f'h.{layer_number}.' + key





def lowerCamelCase      (      lowerCAmelCase    :     Optional[int]		):





	"""simple docstring"""







	if dtype == torch.bool:
		return 1 / 8
	__magic_name__	:   Optional[Any]					     =					re.search(R'[^\d](\d+)$'		,		str(lowerCAmelCase		)		)
	if bit_search is None:
		raise ValueError(f'`dtype` is not a valid dtype: {dtype}.'		)
	__magic_name__	:   Optional[Any]					     =					int(bit_search.groups()[0]		)
	return bit_size // 8





def lowerCamelCase      (      lowerCAmelCase    :     str		,		lowerCAmelCase    :     int		,		lowerCAmelCase    :     List[Any]		,		lowerCAmelCase    :     Tuple		,		lowerCAmelCase    :     Tuple		):





	"""simple docstring"""







	if bloom_config_file == "":
		__magic_name__	:   str					     =					BloomConfig()
	else:
		__magic_name__	:   Optional[int]					     =					BloomConfig.from_json_file(lowerCAmelCase		)

	if shard_model:
		__magic_name__	:   Dict					     =					os.listdir(lowerCAmelCase		)
		__magic_name__	:   Tuple					     =					sorted(filter(lambda lowerCAmelCase		: s.startswith('layer'		) and "model_00" in s		,		lowerCAmelCase		)		)

		__magic_name__	:   int					     =					{'weight_map': {}, 'metadata': {}}
		__magic_name__	:   Tuple					     =					0

		__magic_name__	:   Optional[Any]					     =					None

		__magic_name__	:   Tuple					     =					BloomConfig()

		for j, file in enumerate(lowerCAmelCase		):
			print('Processing file: {}'.format(lowerCAmelCase		)		)
			__magic_name__	:   int					     =					None

			for i in range(lowerCAmelCase		):
				# load all TP files
				__magic_name__	:   List[Any]					     =					file.replace('model_00'		,		f'model_0{i}'		)
				__magic_name__	:   Optional[int]					     =					torch.load(os.path.join(lowerCAmelCase		,		lowerCAmelCase		)		,		map_location='cpu'		)

				# Rename keys in the transformers names
				__magic_name__	:   List[str]					     =					list(temp.keys()		)
				for key in keys:
					__magic_name__	:   Dict					     =					temp.pop(lowerCAmelCase		)

				if tensors is None:
					__magic_name__	:   Union[str, Any]					     =					temp
				else:
					for key in tensors.keys():
						if any(key.endswith(lowerCAmelCase		) for end in WEIGHTS_TO_AVERAGE_ENDSWITH		):
							# We average (sum and then divide) some weights accross TP ranks (see https://github.com/bigscience-workshop/Megatron-DeepSpeed/blob/olruwase/sync_layer_norms/megatron/training.py#L425)
							tensors[key] += temp[key]
						else:
							# Some weights are RowParallelLinear in Megatron-Deepspeed, others are ColumnParallel
							__magic_name__	:   Tuple					     =					1 if any(text in key for text in WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN		) else 0
							# We concatenate these weights accross TP ranks
							__magic_name__	:   Optional[Any]					     =					torch.cat([tensors[key], temp[key]]		,		dim=lowerCAmelCase		)

            # Divide by the number of TP the weights we want to average
			for key in tensors.keys():
				if any(key.endswith(lowerCAmelCase		) for end in WEIGHTS_TO_AVERAGE_ENDSWITH		):
					__magic_name__	:   Dict					     =					tensors[key] / pretraining_tp
			torch.save(
			    lowerCAmelCase		,		os.path.join(
			        lowerCAmelCase		,		'pytorch_model_{}-of-{}.bin'.format(str(j + 1		).zfill(5		)		,		str(len(lowerCAmelCase		)		).zfill(5		)		)		,		)		,		)

			for key in tensors.keys():
				__magic_name__	:   Optional[Any]					     =					tensors[key]
				total_size += value.numel() * get_dtype_size(value.dtype		)
				if key not in index_dict["weight_map"]:
					__magic_name__	:   int					     =					'pytorch_model_{}-of-{}.bin'.format(
					    str(j + 1		).zfill(5		)		,		str(len(lowerCAmelCase		)		).zfill(5		)		)

		__magic_name__	:   List[Any]					     =					BloomConfig()
		__magic_name__	:   str					     =					pytorch_dump_folder_path + '/' + CONFIG_NAME
		__magic_name__	:   int					     =					total_size
		with open(lowerCAmelCase		,		'w'		,		encoding='utf-8'		) as f:
			f.write(config.to_json_string()		)
		with open(os.path.join(lowerCAmelCase		,		WEIGHTS_NAME + '.index.json'		)		,		'w'		,		encoding='utf-8'		) as f:
			__magic_name__	:   Dict					     =					json.dumps(lowerCAmelCase		,		indent=2		,		sort_keys=lowerCAmelCase		) + '\n'
			f.write(lowerCAmelCase		)
	else:
		__magic_name__	:   Any					     =					BloomModel(lowerCAmelCase		)

		__magic_name__	:   Any					     =					os.listdir(lowerCAmelCase		)
		__magic_name__	:   Dict					     =					sorted(filter(lambda lowerCAmelCase		: s.startswith('layer'		) and "model_00" in s		,		lowerCAmelCase		)		)

		__magic_name__	:   List[str]					     =					None
		for i, file in enumerate(lowerCAmelCase		):
			__magic_name__	:   Optional[int]					     =					None
			for i in range(lowerCAmelCase		):
				# load all TP files
				__magic_name__	:   Optional[int]					     =					file.replace('model_00'		,		f'model_0{i}'		)
				__magic_name__	:   Union[str, Any]					     =					torch.load(os.path.join(lowerCAmelCase		,		lowerCAmelCase		)		,		map_location='cpu'		)

				# Rename keys in the transformers names
				__magic_name__	:   List[Any]					     =					list(temp.keys()		)
				for key in keys:
					__magic_name__	:   Tuple					     =					temp.pop(lowerCAmelCase		)

				if tensors is None:
					__magic_name__	:   Optional[Any]					     =					temp
				else:
					for key in tensors.keys():
						# We average (sum and then divide) some weights accross TP ranks (see https://github.com/bigscience-workshop/Megatron-DeepSpeed/blob/olruwase/sync_layer_norms/megatron/training.py#L425)
						if any(key.endswith(lowerCAmelCase		) for end in WEIGHTS_TO_AVERAGE_ENDSWITH		):
							tensors[key] += temp[key]
						else:
							# Some weights are RowParallelLinear in Megatron-Deepspeed, others are ColumnParallel
							__magic_name__	:   Union[str, Any]					     =					1 if any(text in key for text in WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN		) else 0
							# We concatenate these weights accross TP ranks
							__magic_name__	:   Tuple					     =					torch.cat([tensors[key], temp[key]]		,		dim=lowerCAmelCase		)

            # Divide by the number of TP the weights we want to average
			for key in tensors.keys():
				if any(key.endswith(lowerCAmelCase		) for end in WEIGHTS_TO_AVERAGE_ENDSWITH		):
					__magic_name__	:   Any					     =					tensors[key] / pretraining_tp

			__magic_name__	:   str					     =					model.load_state_dict(lowerCAmelCase		,		strict=lowerCAmelCase		)
			assert not other_keys.unexpected_keys, f'The keys {other_keys.unexpected_keys} are unexpected'
			if missing_keys is None:
				__magic_name__	:   str					     =					set(other_keys.missing_keys		)
			else:
				__magic_name__	:   Any					     =					missing_keys.intersection(set(other_keys.missing_keys		)		)

		assert not missing_keys, f'The keys {missing_keys} are missing'

		# Save pytorch-model
		os.makedirs(lowerCAmelCase		,		exist_ok=lowerCAmelCase		)
		__magic_name__	:   str					     =					pytorch_dump_folder_path + '/' + WEIGHTS_NAME
		__magic_name__	:   Optional[Any]					     =					pytorch_dump_folder_path + '/' + CONFIG_NAME
		print(f'Save PyTorch model to {pytorch_weights_dump_path} with dtype {config.torch_dtype}'		)
		if config.torch_dtype is not None:
			__magic_name__	:   List[str]					     =					model.to(config.torch_dtype		)
		torch.save(model.state_dict()		,		lowerCAmelCase		)
		print(f'Save configuration file to {pytorch_config_dump_path}'		)
		with open(lowerCAmelCase		,		'w'		,		encoding='utf-8'		) as f:
			f.write(config.to_json_string()		)


if __name__ == "__main__":
							lowerCAmelCase				:Union[str, Any]        =      argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    '''--bloom_checkpoint_path''',
							    default=None,
							    type=str,
							    required=True,
							    help='''Path to the Megatron-LM checkpoint path.''',
							)
							parser.add_argument(
							    '''--pytorch_dump_folder_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
							)
							parser.add_argument(
							    '''--bloom_config_file''',
							    default='''''',
							    type=str,
							    help=(
							        '''An optional config json file corresponding to the pre-trained model. \n'''
							        '''This specifies the model architecture.'''
							    ),
							)
							parser.add_argument(
							    '''--shard_model''',
							    action='''store_true''',
							    help='''An optional setting to shard the output model \nThis enables sharding the converted checkpoint''',
							)
							parser.add_argument(
							    '''--pretraining_tp''',
							    default=4,
							    type=int,
							    help='''Pretraining TP rank that has been used when training the model in Megatron-LM \n''',
							)
							lowerCAmelCase				:Tuple        =      parser.parse_args()
							convert_bloom_checkpoint_to_pytorch(
							    args.bloom_checkpoint_path,
							    args.bloom_config_file,
							    args.pytorch_dump_folder_path,
							    args.shard_model,
							    args.pretraining_tp,
							)



'''simple docstring'''

def lowerCamelCase      (      lowerCAmelCase    :     int		):





	"""simple docstring"""







	__magic_name__	:   Optional[int]					     =					1
	for i in range(1		,		num + 1		):
		fact *= i
	return fact





def lowerCamelCase      (      lowerCAmelCase    :     int		):





	"""simple docstring"""







	__magic_name__	:   List[str]					     =					0
	while number > 0:
		__magic_name__	:   str					     =					number % 10
		sum_of_digits += last_digit
		__magic_name__	:   Optional[int]					     =					number // 10  # Removing the last_digit from the given number
	return sum_of_digits





def lowerCamelCase      (      lowerCAmelCase    :     int = 100		):





	"""simple docstring"""







	__magic_name__	:   int					     =					factorial(lowerCAmelCase		)
	__magic_name__	:   Any					     =					split_and_add(lowerCAmelCase		)
	return result


if __name__ == "__main__":
							print(solution(int(input('''Enter the Number: ''').strip())))