
"""simple docstring"""





import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
_a								=						logging.get_logger(__name__)

_a								=						{
    """b0""": efficientnet.EfficientNetBa,
    """b1""": efficientnet.EfficientNetBa,
    """b2""": efficientnet.EfficientNetBa,
    """b3""": efficientnet.EfficientNetBa,
    """b4""": efficientnet.EfficientNetBa,
    """b5""": efficientnet.EfficientNetBa,
    """b6""": efficientnet.EfficientNetBa,
    """b7""": efficientnet.EfficientNetBa,
}

_a								=						{
    """b0""": {
        """hidden_dim""": 1280,
        """width_coef""": 1.0,
        """depth_coef""": 1.0,
        """image_size""": 224,
        """dropout_rate""": 0.2,
        """dw_padding""": [],
    },
    """b1""": {
        """hidden_dim""": 1280,
        """width_coef""": 1.0,
        """depth_coef""": 1.1,
        """image_size""": 240,
        """dropout_rate""": 0.2,
        """dw_padding""": [16],
    },
    """b2""": {
        """hidden_dim""": 1408,
        """width_coef""": 1.1,
        """depth_coef""": 1.2,
        """image_size""": 260,
        """dropout_rate""": 0.3,
        """dw_padding""": [5, 8, 16],
    },
    """b3""": {
        """hidden_dim""": 1536,
        """width_coef""": 1.2,
        """depth_coef""": 1.4,
        """image_size""": 300,
        """dropout_rate""": 0.3,
        """dw_padding""": [5, 18],
    },
    """b4""": {
        """hidden_dim""": 1792,
        """width_coef""": 1.4,
        """depth_coef""": 1.8,
        """image_size""": 380,
        """dropout_rate""": 0.4,
        """dw_padding""": [6],
    },
    """b5""": {
        """hidden_dim""": 2048,
        """width_coef""": 1.6,
        """depth_coef""": 2.2,
        """image_size""": 456,
        """dropout_rate""": 0.4,
        """dw_padding""": [13, 27],
    },
    """b6""": {
        """hidden_dim""": 2304,
        """width_coef""": 1.8,
        """depth_coef""": 2.6,
        """image_size""": 528,
        """dropout_rate""": 0.5,
        """dw_padding""": [31],
    },
    """b7""": {
        """hidden_dim""": 2560,
        """width_coef""": 2.0,
        """depth_coef""": 3.1,
        """image_size""": 600,
        """dropout_rate""": 0.5,
        """dw_padding""": [18],
    },
}



def  lowerCamelCase__						(     __snake_case      )				->						Union[str, Any]:


					"""simple docstring"""





					_UpperCamelCase									=    EfficientNetConfig()
					_UpperCamelCase									=    CONFIG_MAP[model_name]['''hidden_dim''']
					_UpperCamelCase									=    CONFIG_MAP[model_name]['''width_coef''']
					_UpperCamelCase									=    CONFIG_MAP[model_name]['''depth_coef''']
					_UpperCamelCase									=    CONFIG_MAP[model_name]['''image_size''']
					_UpperCamelCase									=    CONFIG_MAP[model_name]['''dropout_rate''']
					_UpperCamelCase									=    CONFIG_MAP[model_name]['''dw_padding''']

					_UpperCamelCase									=    '''huggingface/label-files'''
					_UpperCamelCase									=    '''imagenet-1k-id2label.json'''
					_UpperCamelCase									=    10_00
					_UpperCamelCase									=    json.load(open(hf_hub_download(__snake_case,	__snake_case,	repo_type='''dataset'''      ),	'''r'''      )      )
					_UpperCamelCase									=    {int(__snake_case      ): v for k, v in idalabel.items()}

					_UpperCamelCase									=    idalabel
					_UpperCamelCase									=    {v: k for k, v in idalabel.items()}
					return config



def  lowerCamelCase__						(     )				->						str:


					"""simple docstring"""





					_UpperCamelCase									=    '''http://images.cocodataset.org/val2017/000000039769.jpg'''
					_UpperCamelCase									=    Image.open(requests.get(__snake_case,	stream=__snake_case      ).raw      )
					return im



def  lowerCamelCase__						(     __snake_case      )				->						List[Any]:


					"""simple docstring"""





					_UpperCamelCase									=    CONFIG_MAP[model_name]['''image_size''']
					_UpperCamelCase									=    EfficientNetImageProcessor(
					    size={'''height''': size, '''width''': size},	image_mean=[0.485, 0.456, 0.406],	image_std=[0.47853944, 0.4732864, 0.47434163],	do_center_crop=__snake_case,	)
					return preprocessor



def  lowerCamelCase__						(     __snake_case      )				->						Union[str, Any]:


					"""simple docstring"""





					_UpperCamelCase									=    [v.split('''_'''      )[0].split('''block'''      )[1] for v in original_param_names if v.startswith('''block'''      )]
					_UpperCamelCase									=    sorted(set(__snake_case      )      )
					_UpperCamelCase									=    len(__snake_case      )
					_UpperCamelCase									=    {b: str(__snake_case      ) for b, i in zip(__snake_case,	range(__snake_case      )      )}

					_UpperCamelCase									=    []
					rename_keys.append(('''stem_conv/kernel:0''', '''embeddings.convolution.weight''')      )
					rename_keys.append(('''stem_bn/gamma:0''', '''embeddings.batchnorm.weight''')      )
					rename_keys.append(('''stem_bn/beta:0''', '''embeddings.batchnorm.bias''')      )
					rename_keys.append(('''stem_bn/moving_mean:0''', '''embeddings.batchnorm.running_mean''')      )
					rename_keys.append(('''stem_bn/moving_variance:0''', '''embeddings.batchnorm.running_var''')      )

					for b in block_names:
										_UpperCamelCase									=    block_name_mapping[b]
										rename_keys.append((F'''block{b}_expand_conv/kernel:0''', F'''encoder.blocks.{hf_b}.expansion.expand_conv.weight''')      )
										rename_keys.append((F'''block{b}_expand_bn/gamma:0''', F'''encoder.blocks.{hf_b}.expansion.expand_bn.weight''')      )
										rename_keys.append((F'''block{b}_expand_bn/beta:0''', F'''encoder.blocks.{hf_b}.expansion.expand_bn.bias''')      )
										rename_keys.append(
										    (F'''block{b}_expand_bn/moving_mean:0''', F'''encoder.blocks.{hf_b}.expansion.expand_bn.running_mean''')      )
										rename_keys.append(
										    (F'''block{b}_expand_bn/moving_variance:0''', F'''encoder.blocks.{hf_b}.expansion.expand_bn.running_var''')      )
										rename_keys.append(
										    (F'''block{b}_dwconv/depthwise_kernel:0''', F'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight''')      )
										rename_keys.append((F'''block{b}_bn/gamma:0''', F'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight''')      )
										rename_keys.append((F'''block{b}_bn/beta:0''', F'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias''')      )
										rename_keys.append(
										    (F'''block{b}_bn/moving_mean:0''', F'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean''')      )
										rename_keys.append(
										    (F'''block{b}_bn/moving_variance:0''', F'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var''')      )

										rename_keys.append((F'''block{b}_se_reduce/kernel:0''', F'''encoder.blocks.{hf_b}.squeeze_excite.reduce.weight''')      )
										rename_keys.append((F'''block{b}_se_reduce/bias:0''', F'''encoder.blocks.{hf_b}.squeeze_excite.reduce.bias''')      )
										rename_keys.append((F'''block{b}_se_expand/kernel:0''', F'''encoder.blocks.{hf_b}.squeeze_excite.expand.weight''')      )
										rename_keys.append((F'''block{b}_se_expand/bias:0''', F'''encoder.blocks.{hf_b}.squeeze_excite.expand.bias''')      )
										rename_keys.append(
										    (F'''block{b}_project_conv/kernel:0''', F'''encoder.blocks.{hf_b}.projection.project_conv.weight''')      )
										rename_keys.append((F'''block{b}_project_bn/gamma:0''', F'''encoder.blocks.{hf_b}.projection.project_bn.weight''')      )
										rename_keys.append((F'''block{b}_project_bn/beta:0''', F'''encoder.blocks.{hf_b}.projection.project_bn.bias''')      )
										rename_keys.append(
										    (F'''block{b}_project_bn/moving_mean:0''', F'''encoder.blocks.{hf_b}.projection.project_bn.running_mean''')      )
										rename_keys.append(
										    (F'''block{b}_project_bn/moving_variance:0''', F'''encoder.blocks.{hf_b}.projection.project_bn.running_var''')      )

					rename_keys.append(('''top_conv/kernel:0''', '''encoder.top_conv.weight''')      )
					rename_keys.append(('''top_bn/gamma:0''', '''encoder.top_bn.weight''')      )
					rename_keys.append(('''top_bn/beta:0''', '''encoder.top_bn.bias''')      )
					rename_keys.append(('''top_bn/moving_mean:0''', '''encoder.top_bn.running_mean''')      )
					rename_keys.append(('''top_bn/moving_variance:0''', '''encoder.top_bn.running_var''')      )

					_UpperCamelCase									=    {}
					for item in rename_keys:
										if item[0] in original_param_names:
															_UpperCamelCase									=    '''efficientnet.''' + item[1]

					_UpperCamelCase									=    '''classifier.weight'''
					_UpperCamelCase									=    '''classifier.bias'''
					return key_mapping



def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case      )				->						str:


					"""simple docstring"""





					for key, value in tf_params.items():
										if "normalization" in key:
															continue

										_UpperCamelCase									=    key_mapping[key]
										if "_conv" in key and "kernel" in key:
															_UpperCamelCase									=    torch.from_numpy(__snake_case      ).permute(3,	2,	0,	1      )
										elif "depthwise_kernel" in key:
															_UpperCamelCase									=    torch.from_numpy(__snake_case      ).permute(2,	3,	0,	1      )
										elif "kernel" in key:
															_UpperCamelCase									=    torch.from_numpy(np.transpose(__snake_case      )      )
										else:
															_UpperCamelCase									=    torch.from_numpy(__snake_case      )

										# Replace HF parameters with original TF model parameters
										assert hf_params[hf_key].shape == new_hf_value.shape
										hf_params[hf_key].copy_(__snake_case      )



@torch.no_grad()
def  lowerCamelCase__						(     __snake_case,	__snake_case,	__snake_case,	__snake_case      )				->						int:


					"""simple docstring"""





					_UpperCamelCase									=    model_classes[model_name](
					    include_top=__snake_case,	weights='''imagenet''',	input_tensor=__snake_case,	input_shape=__snake_case,	pooling=__snake_case,	classes=10_00,	classifier_activation='''softmax''',	)

					_UpperCamelCase									=    original_model.trainable_variables
					_UpperCamelCase									=    original_model.non_trainable_variables
					_UpperCamelCase									=    {param.name: param.numpy() for param in tf_params}
					for param in tf_non_train_params:
										_UpperCamelCase									=    param.numpy()
					_UpperCamelCase									=    list(tf_params.keys()      )

					# Load HuggingFace model
					_UpperCamelCase									=    get_efficientnet_config(__snake_case      )
					_UpperCamelCase									=    EfficientNetForImageClassification(__snake_case      ).eval()
					_UpperCamelCase									=    hf_model.state_dict()

					# Create src-to-dst parameter name mapping dictionary
					print('''Converting parameters...'''      )
					_UpperCamelCase									=    rename_keys(__snake_case      )
					replace_params(__snake_case,	__snake_case,	__snake_case      )

					# Initialize preprocessor and preprocess input image
					_UpperCamelCase									=    convert_image_processor(__snake_case      )
					_UpperCamelCase									=    preprocessor(images=prepare_img(),	return_tensors='''pt'''      )

					# HF model inference
					hf_model.eval()
					with torch.no_grad():
										_UpperCamelCase									=    hf_model(**__snake_case      )
					_UpperCamelCase									=    outputs.logits.detach().numpy()

					# Original model inference
					_UpperCamelCase									=    False
					_UpperCamelCase									=    CONFIG_MAP[model_name]['''image_size''']
					_UpperCamelCase									=    prepare_img().resize((image_size, image_size),	resample=PIL.Image.NEAREST      )
					_UpperCamelCase									=    image.img_to_array(__snake_case      )
					_UpperCamelCase									=    np.expand_dims(__snake_case,	axis=0      )
					_UpperCamelCase									=    original_model.predict(__snake_case      )

					# Check whether original and HF model outputs match  -> np.allclose
					assert np.allclose(__snake_case,	__snake_case,	atol=1e-3      ), "The predicted logits are not the same."
					print('''Model outputs match!'''      )

					if save_model:
										# Create folder to save model
										if not os.path.isdir(__snake_case      ):
															os.mkdir(__snake_case      )
										# Save converted model and image processor
										hf_model.save_pretrained(__snake_case      )
										preprocessor.save_pretrained(__snake_case      )

					if push_to_hub:
										# Push model and image processor to hub
										print(F'''Pushing converted {model_name} to the hub...'''      )
										_UpperCamelCase									=    F'''efficientnet-{model_name}'''
										preprocessor.push_to_hub(__snake_case      )
										hf_model.push_to_hub(__snake_case      )


if __name__ == "__main__":
				_a								=						argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    """--model_name""",
				    default="""b0""",
				    type=str,
				    help="""Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].""",
				)
				parser.add_argument(
				    """--pytorch_dump_folder_path""",
				    default="""hf_model""",
				    type=str,
				    help="""Path to the output PyTorch model directory.""",
				)
				parser.add_argument("""--save_model""", action="""store_true""", help="""Save model to local""")
				parser.add_argument("""--push_to_hub""", action="""store_true""", help="""Push model and image processor to the hub""")

				_a								=						parser.parse_args()
				convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)







import sys
from collections import defaultdict
class     lowerCAmelCase_     :







							def __init__(   self      :     Optional[int]		):
												_UpperCamelCase			     =     []







							def  UpperCamelCase_						(   self      :     Any ,			_A      :     str		):
												return self.node_position[vertex]







							def  UpperCamelCase_						(   self      :     Optional[Any] ,			_A      :     List[str] ,			_A      :     Union[str, Any]		):
												_UpperCamelCase			     =     pos







							def  UpperCamelCase_						(   self      :     Any ,			_A      :     List[str] ,			_A      :     int ,			_A      :     Optional[Any] ,			_A      :     Union[str, Any]		):
												if start > size // 2 - 1:
																	return
												else:
																	if 2 * start + 2 >= size:
																						_UpperCamelCase			     =     2 * start + 1
																	else:
																						if heap[2 * start + 1] < heap[2 * start + 2]:
																											_UpperCamelCase			     =     2 * start + 1
																						else:
																											_UpperCamelCase			     =     2 * start + 2
																	if heap[smallest_child] < heap[start]:
																						_UpperCamelCase     ,    _UpperCamelCase			     =     heap[smallest_child], positions[smallest_child]
																						_UpperCamelCase     ,    _UpperCamelCase			     =     (
																						    heap[start],
																						    positions[start],
																						)
																						_UpperCamelCase     ,    _UpperCamelCase			     =     temp, tempa

																						_UpperCamelCase			     =     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      :     List[str] ,			_A      :     Tuple ,			_A      :     Optional[Any] ,			_A      :     int ,			_A      :     Optional[int]		):
												_UpperCamelCase			     =     position[index]

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

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







							def  UpperCamelCase_						(   self      :     int ,			_A      :     Tuple ,			_A      :     int		):
												_UpperCamelCase			     =     len(_A		) // 2 - 1
												for i in range(_A ,			-1 ,			-1		):
																	self.top_to_bottom(_A ,			_A ,			len(_A		) ,			_A		)







							def  UpperCamelCase_						(   self      :     Any ,			_A      :     int ,			_A      :     List[str]		):
												_UpperCamelCase			     =     positions[0]
												_UpperCamelCase			     =     sys.maxsize
												self.top_to_bottom(_A ,			0 ,			len(_A		) ,			_A		)
												return temp




def 					_snake_case	(  __snake_case						):
					_UpperCamelCase			     =     Heap()

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

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

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

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


if __name__ == "__main__":  # pragma: no cover
					# < --------- Prims Algorithm --------- >
					_lowerCAmelCase       =		int(input("Enter number of edges: ").strip())
					_lowerCAmelCase       =		defaultdict(list)
					for _ in range(edges_number):
										_lowerCAmelCase       =		[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))
