


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()

_lowercase       :      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",
]

_lowercase       :      List[Any]	=	[
    "mlp.dense_4h_to_h.weight",
    "self_attention.dense.weight",
]





def   _lowerCAmelCase				(   UpperCamelCase__:     Union[str, Any]							,					UpperCamelCase__:     Dict						) ->   List[Any]:





	"""simple docstring"""







	A								=				{
	    """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
	A								=				int(re.match(r""".*layer_(\d*).*"""							,					UpperCamelCase__						)[1]						)
	layer_number -= 3
	return f'h.{layer_number}.' + key





def   _lowerCAmelCase				(   UpperCamelCase__:     List[Any]						) ->   Tuple:





	"""simple docstring"""







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





def   _lowerCAmelCase				(   UpperCamelCase__:     str							,					UpperCamelCase__:     Optional[int]							,					UpperCamelCase__:     int							,					UpperCamelCase__:     int							,					UpperCamelCase__:     Union[str, Any]						) ->   int:





	"""simple docstring"""







	if bloom_config_file == "":
		A								=				BloomConfig()
	else:
		A								=				BloomConfig.from_json_file(UpperCamelCase__						)

	if shard_model:
		A								=				os.listdir(UpperCamelCase__						)
		A								=				sorted(filter(lambda UpperCamelCase__						: s.startswith("""layer"""						) and "model_00" in s							,					UpperCamelCase__						)						)

		A								=				{"""weight_map""": {}, """metadata""": {}}
		A								=				0

		A								=				None

		A								=				BloomConfig()

		for j, file in enumerate(UpperCamelCase__						):
			print("""Processing file: {}""".format(UpperCamelCase__						)						)
			A								=				None

			for i in range(UpperCamelCase__						):
				# load all TP files
				A								=				file.replace("""model_00"""							,					f'model_0{i}'						)
				A								=				torch.load(os.path.join(UpperCamelCase__							,					UpperCamelCase__						)							,					map_location="""cpu"""						)

				# Rename keys in the transformers names
				A								=				list(temp.keys()						)
				for key in keys:
					A								=				temp.pop(UpperCamelCase__						)

				if tensors is None:
					A								=				temp
				else:
					for key in tensors.keys():
						if any(key.endswith(UpperCamelCase__						) 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
							A								=				1 if any(text in key for text in WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN						) else 0
							# We concatenate these weights accross TP ranks
							A								=				torch.cat([tensors[key], temp[key]]							,					dim=UpperCamelCase__						)

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

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

		A								=				BloomConfig()
		A								=				pytorch_dump_folder_path + """/""" + CONFIG_NAME
		A								=				total_size
		with open(UpperCamelCase__							,					"""w"""							,					encoding="""utf-8"""						) as f:
			f.write(config.to_json_string()						)
		with open(os.path.join(UpperCamelCase__							,					WEIGHTS_NAME + """.index.json"""						)							,					"""w"""							,					encoding="""utf-8"""						) as f:
			A								=				json.dumps(UpperCamelCase__							,					indent=2							,					sort_keys=UpperCamelCase__						) + """\n"""
			f.write(UpperCamelCase__						)
	else:
		A								=				BloomModel(UpperCamelCase__						)

		A								=				os.listdir(UpperCamelCase__						)
		A								=				sorted(filter(lambda UpperCamelCase__						: s.startswith("""layer"""						) and "model_00" in s							,					UpperCamelCase__						)						)

		A								=				None
		for i, file in enumerate(UpperCamelCase__						):
			A								=				None
			for i in range(UpperCamelCase__						):
				# load all TP files
				A								=				file.replace("""model_00"""							,					f'model_0{i}'						)
				A								=				torch.load(os.path.join(UpperCamelCase__							,					UpperCamelCase__						)							,					map_location="""cpu"""						)

				# Rename keys in the transformers names
				A								=				list(temp.keys()						)
				for key in keys:
					A								=				temp.pop(UpperCamelCase__						)

				if tensors is None:
					A								=				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(UpperCamelCase__						) for end in WEIGHTS_TO_AVERAGE_ENDSWITH						):
							tensors[key] += temp[key]
						else:
							# Some weights are RowParallelLinear in Megatron-Deepspeed, others are ColumnParallel
							A								=				1 if any(text in key for text in WEIGHTS_WITH_ROW_PARALLELISM_CONTAIN						) else 0
							# We concatenate these weights accross TP ranks
							A								=				torch.cat([tensors[key], temp[key]]							,					dim=UpperCamelCase__						)

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

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

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

		# Save pytorch-model
		os.makedirs(UpperCamelCase__							,					exist_ok=UpperCamelCase__						)
		A								=				pytorch_dump_folder_path + """/""" + WEIGHTS_NAME
		A								=				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:
			A								=				model.to(config.torch_dtype						)
		torch.save(model.state_dict()							,					UpperCamelCase__						)
		print(f'Save configuration file to {pytorch_config_dump_path}'						)
		with open(UpperCamelCase__							,					"""w"""							,					encoding="""utf-8"""						) as f:
			f.write(config.to_json_string()						)


if __name__ == "__main__":
			_lowercase       :      Optional[int]	=	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",
			)
			_lowercase       :      str	=	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,
			)







import sys
from collections import defaultdict






class       _UpperCamelCase    :

				"""simple docstring"""







				def __init__(						self   )	->				Any:
					A								=				[]

				def      _UpperCAmelCase					(						self				,   a__   )	->				List[str]:
					return self.node_position[vertex]

				def      _UpperCAmelCase					(						self				,   a__				,   a__   )	->				Optional[int]:
					A								=				pos

				def      _UpperCAmelCase					(						self				,   a__				,   a__				,   a__				,   a__   )	->				Any:
					if start > size // 2 - 1:
						return
					else:
						if 2 * start + 2 >= size:
							A								=				2 * start + 1
						else:
							if heap[2 * start + 1] < heap[2 * start + 2]:
								A								=				2 * start + 1
							else:
								A								=				2 * start + 2
						if heap[smallest_child] < heap[start]:
							A					,			A								=				heap[smallest_child], positions[smallest_child]
							A					,			A								=				(
							    heap[start],
							    positions[start],
							)
							A					,			A								=				temp, tempa

							A								=				self.get_position(positions[smallest_child]   )
							self.set_position(
							    positions[smallest_child]				,   self.get_position(positions[start]   )   )
							self.set_position(positions[start]				,   a__   )

							self.top_to_bottom(a__				,   a__				,   a__				,   a__   )

				def      _UpperCAmelCase					(						self				,   a__				,   a__				,   a__				,   a__   )	->				Dict:
					A								=				position[index]

					while index != 0:
						A								=				int((index - 2) / 2   ) if index % 2 == 0 else int((index - 1) / 2   )

						if val < heap[parent]:
							A								=				heap[parent]
							A								=				position[parent]
							self.set_position(position[parent]				,   a__   )
						else:
							A								=				val
							A								=				temp
							self.set_position(a__				,   a__   )
							break
						A								=				parent
					else:
						A								=				val
						A								=				temp
						self.set_position(a__				,   0   )

				def      _UpperCAmelCase					(						self				,   a__				,   a__   )	->				Optional[int]:
					A								=				len(a__   ) // 2 - 1
					for i in range(a__				,   -1				,   -1   ):
						self.top_to_bottom(a__				,   a__				,   len(a__   )				,   a__   )

				def      _UpperCAmelCase					(						self				,   a__				,   a__   )	->				Any:
					A								=				positions[0]
					A								=				sys.maxsize
					self.top_to_bottom(a__				,   0				,   len(a__   )				,   a__   )
					return temp





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





	"""simple docstring"""







	A								=				Heap()

	A								=				[0] * len(UpperCamelCase__						)
	A								=				[-1] * len(UpperCamelCase__						)  # Neighboring Tree Vertex of selected vertex
	# Minimum Distance of explored vertex with neighboring vertex of partial tree
	# formed in graph
	A								=				[]  # Heap of Distance of vertices from their neighboring vertex
	A								=				[]

	for vertex in range(len(UpperCamelCase__						)						):
		distance_tv.append(sys.maxsize						)
		positions.append(UpperCamelCase__						)
		heap.node_position.append(UpperCamelCase__						)

	A								=				[]
	A								=				1
	A								=				sys.maxsize
	for neighbor, distance in adjacency_list[0]:
		A								=				0
		A								=				distance
	heap.heapify(UpperCamelCase__							,					UpperCamelCase__						)

	for _ in range(1							,					len(UpperCamelCase__						)						):
		A								=				heap.delete_minimum(UpperCamelCase__							,					UpperCamelCase__						)
		if visited[vertex] == 0:
			tree_edges.append((nbr_tv[vertex], vertex)						)
			A								=				1
			for neighbor, distance in adjacency_list[vertex]:
				if (
				    visited[neighbor] == 0
				    and distance < distance_tv[heap.get_position(UpperCamelCase__						)]
				):
					A								=				distance
					heap.bottom_to_top(
					    UpperCamelCase__							,					heap.get_position(UpperCamelCase__						)							,					UpperCamelCase__							,					UpperCamelCase__						)
					A								=				vertex
	return tree_edges


if __name__ == "__main__":  # pragma: no cover
				# < --------- Prims Algorithm --------- >
				_lowercase       :      Tuple	=	int(input("Enter number of edges: ").strip())
				_lowercase       :      int	=	defaultdict(list)
				for _ in range(edges_number):
								_lowercase       :      Optional[Any]	=	[int(x) for x in input().strip().split()]
								adjacency_list[edge[0]].append([edge[1], edge[2]])
								adjacency_list[edge[1]].append([edge[0], edge[2]])
				print(prisms_algorithm(adjacency_list))



