


'''simple docstring'''




import sys
from collections import defaultdict







class 					a			:
 '''simple docstring'''




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




 def   __UpperCamelCase   (    self		,      lowerCamelCase_      )      ->    Any:
    return self.node_position[vertex]




 def   __UpperCamelCase   (    self		,      lowerCamelCase_		,      lowerCamelCase_      )      ->    str:
    _a					:  Optional[int]						=  pos




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

          _a					:  List[Any]						=  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		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_		,      lowerCamelCase_      )      ->    Union[str, Any]:
    _a					:  Optional[int]						=  position[index]

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

       if val < heap[parent]:
          _a					:  List[str]						=  heap[parent]
          _a					:  Any						=  position[parent]
          self.set_position(position[parent]		,      a_      )
       else:
          _a					:  Optional[Any]						=  val
          _a					:  Optional[Any]						=  temp
          self.set_position(a_		,      a_      )
          break
       _a					:  List[str]						=  parent
    else:
       _a					:  List[str]						=  val
       _a					:  Optional[Any]						=  temp
       self.set_position(a_		,      0      )




 def   __UpperCamelCase   (    self		,      lowerCamelCase_		,      lowerCamelCase_      )      ->    Union[str, Any]:
    _a					:  str						=  len(a_      ) // 2 - 1
    for i in range(a_		,      -1		,      -1      ):
       self.top_to_bottom(a_		,      a_		,      len(a_      )		,      a_      )




 def   __UpperCamelCase   (    self		,      lowerCamelCase_		,      lowerCamelCase_      )      ->    List[str]:
    _a					:  str						=  positions[0]
    _a					:  List[str]						=  sys.maxsize
    self.top_to_bottom(a_		,      0		,      len(a_      )		,      a_      )
    return temp





def    UpperCAmelCase_  (       A      ):
   '''simple docstring'''





   _a					:  Union[str, Any]						=  Heap()

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

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

   _a					:  Dict						=  []
   _a					:  Any						=  1
   _a					:  Any						=  sys.maxsize
   for neighbor, distance in adjacency_list[0]:
      _a					:  str						=  0
      _a					:  List[str]						=  distance
   heap.heapify(A		,	A      )

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


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






'''simple docstring'''
import logging
import os

import quant_trainer
import torch
from torch.utils.data import DataLoader

from transformers import Trainer, is_torch_tpu_available
from transformers.trainer_utils import PredictionOutput


lowerCAmelCase   : Dict             =				logging.getLogger(__name__)

if is_torch_tpu_available(check_device=False):
					import torch_xla.core.xla_model as xm
					import torch_xla.debug.metrics as met




class        _UpperCamelCase	(    SCREAMING_SNAKE_CASE):


				'''simple docstring'''


				def __init__(     self							,      *a_							,      a_=None							,      a_=None							,      a_=None							,      **a_							)    ->  Any:
					super().__init__(*a_							,      **a_							)
					lowercase						:		Optional[Any]   					=		eval_examples
					lowercase						:		Any   					=		post_process_function
					lowercase						:		Dict   					=		quant_trainer_args
					lowercase						:		List[Any]   					=		1_2_8  # default number of calibration samples

				def 	a__		(     self							,      a_=None							)    ->  List[str]:
					if calib_dataset is None and self.calib_dataset is None:
						raise ValueError("Trainer: calibration requires an calib_dataset."							)
					lowercase						:		Dict   					=		calib_dataset if calib_dataset is not None else self.calib_dataset

					lowercase						:		Optional[int]   					=		self._remove_unused_columns(a_							,      description="Calibration"							)

					return DataLoader(
					    a_							,      batch_size=self.args.eval_batch_size							,      collate_fn=self.data_collator							,      drop_last=self.args.dataloader_drop_last							,      num_workers=self.args.dataloader_num_workers							,      pin_memory=self.args.dataloader_pin_memory							,      shuffle=a_							,      )

				def 	a__		(     self							,      a_=None							)    ->  str:
					lowercase						:		Optional[Any]   					=		self.train_dataset if calib_dataset is None else calib_dataset
					lowercase						:		Optional[Any]   					=		self.get_calib_dataloader(a_							)

					lowercase						:		Union[str, Any]   					=		self.model
					quant_trainer.configure_model(a_							,      self.quant_trainer_args							,      calib=a_							)
					model.eval()
					quant_trainer.enable_calibration(a_							)

					logger.info("***** Running calibration *****"							)
					logger.info(F'''  Num examples = {self.calib_num}'''							)
					logger.info(F'''  Batch size = {calib_dataloader.batch_size}'''							)

					for step, inputs in enumerate(a_							):
						# Prediction step
						lowercase					,		lowercase					,		lowercase						:		Union[str, Any]   					=		self.prediction_step(a_							,      a_							,      prediction_loss_only=a_							)
						if (step + 1) * calib_dataloader.batch_size >= self.calib_num:
							break

					quant_trainer.finish_calibration(a_							,      self.quant_trainer_args							)
					lowercase						:		List[Any]   					=		model

				def 	a__		(     self							,      a_=None							,      a_=None							,      a_=None							,      a_ = "eval"							)    ->  int:
					lowercase						:		List[str]   					=		self.eval_dataset if eval_dataset is None else eval_dataset
					lowercase						:		Union[str, Any]   					=		self.get_eval_dataloader(a_							)
					lowercase						:		Tuple   					=		self.eval_examples if eval_examples is None else eval_examples

					# Temporarily disable metric computation, we will do it in the loop here.
					lowercase						:		List[str]   					=		self.compute_metrics
					lowercase						:		Dict   					=		None
					lowercase						:		int   					=		self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
					try:
						lowercase						:		Tuple   					=		eval_loop(
						    a_							,      description="Evaluation"							,      prediction_loss_only=True if compute_metrics is None else None							,      ignore_keys=a_							,      )
					finally:
						lowercase						:		List[Any]   					=		compute_metrics

					if self.post_process_function is not None and self.compute_metrics is not None:
						lowercase						:		Union[str, Any]   					=		self.post_process_function(a_							,      a_							,      output.predictions							)
						lowercase						:		Union[str, Any]   					=		self.compute_metrics(a_							)

						# Prefix all keys with metric_key_prefix + '_'
						for key in list(metrics.keys()							):
							if not key.startswith(F'''{metric_key_prefix}_'''							):
								lowercase						:		Dict   					=		metrics.pop(a_							)

						self.log(a_							)
					else:
						lowercase						:		Tuple   					=		{}

					if self.args.tpu_metrics_debug or self.args.debug:
						# tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.)
						xm.master_print(met.metrics_report()							)

					lowercase						:		int   					=		self.callback_handler.on_evaluate(self.args							,      self.state							,      self.control							,      a_							)
					return metrics

				def 	a__		(     self							,      a_							,      a_							,      a_=None							,      a_ = "test"							)    ->  Optional[int]:
					lowercase						:		Dict   					=		self.get_test_dataloader(a_							)

					# Temporarily disable metric computation, we will do it in the loop here.
					lowercase						:		List[str]   					=		self.compute_metrics
					lowercase						:		List[str]   					=		None
					lowercase						:		int   					=		self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
					try:
						lowercase						:		Optional[Any]   					=		eval_loop(
						    a_							,      description="Prediction"							,      prediction_loss_only=True if compute_metrics is None else None							,      ignore_keys=a_							,      )
					finally:
						lowercase						:		int   					=		compute_metrics

					if self.post_process_function is None or self.compute_metrics is None:
						return output

					lowercase						:		List[str]   					=		self.post_process_function(a_							,      a_							,      output.predictions							,      "predict"							)
					lowercase						:		Dict   					=		self.compute_metrics(a_							)

					# Prefix all keys with metric_key_prefix + '_'
					for key in list(metrics.keys()							):
						if not key.startswith(F'''{metric_key_prefix}_'''							):
							lowercase						:		Union[str, Any]   					=		metrics.pop(a_							)

					return PredictionOutput(predictions=predictions.predictions							,      label_ids=predictions.label_ids							,      metrics=a_							)


				def 	a__		(     self							,      a_="./"							)    ->  Optional[Any]:
					lowercase						:		str   					=		self.eval_dataset
					lowercase						:		Dict   					=		self.get_eval_dataloader(a_							)

					lowercase						:		Any   					=		next(iter(a_							)							)

					# saving device - to make it consistent
					lowercase						:		List[Any]   					=		torch.device("cuda" if torch.cuda.is_available() else "cpu"							)

					# convert to tuple
					lowercase						:		Tuple   					=		tuple(v.to(a_							) for k, v in batch.items()							)

					logger.info("Converting model to be onnx compatible"							)
					from pytorch_quantization.nn import TensorQuantizer

					lowercase						:		Optional[Any]   					=		True

					lowercase						:		int   					=		self.model.to(a_							)

					model.eval()
					model.float()

					lowercase						:		Union[str, Any]   					=		model.module if hasattr(a_							,      "module"							) else model
					quant_trainer.configure_model(a_							,      self.quant_trainer_args							)

					lowercase						:		List[str]   					=		os.path.join(a_							,      "model.onnx"							)
					logger.info(F'''exporting model to {output_model_file}'''							)

					lowercase						:		Any   					=		{0: "batch_size", 1: "seq_len"}

					torch.onnx.export(
					    a_							,      a_							,      a_							,      export_params=a_							,      opset_version=1_3							,      do_constant_folding=a_							,      input_names=["input_ids", "attention_mask", "token_type_ids"]							,      output_names=["output_start_logits", "output_end_logits"]							,      dynamic_axes={
					        "input_ids": axes,
					        "attention_mask": axes,
					        "token_type_ids": axes,
					        "output_start_logits": axes,
					        "output_end_logits": axes,
					    }							,      verbose=a_							,      )
					logger.info("onnx export finished"							)


