from collections import deque
from math import floor
from random import random
from time import time
class     a_			:






 '''simple docstring'''






 def __init__(      self :  List[Any]):







        '''simple docstring'''



        lowerCAmelCase__					     = {}




 def 		__snake_case						(      self :  Any      ,   lowercase__ :  Dict      ,   lowercase__ :  Any      ,   lowercase__ :  Dict=1):







        '''simple docstring'''



        if self.graph.get(lowercase__):
               if self.graph[u].count([w, v]) == 0:
                      self.graph[u].append([w, v])
        else:
               lowerCAmelCase__					     = [[w, v]]
        if not self.graph.get(lowercase__):
               lowerCAmelCase__					     = []




 def 		__snake_case						(      self :  List[str]):







        '''simple docstring'''



        return list(self.graph)




 def 		__snake_case						(      self :  Tuple      ,   lowercase__ :  List[Any]      ,   lowercase__ :  str):







        '''simple docstring'''



        if self.graph.get(lowercase__):
               for _ in self.graph[u]:
                      if _[1] == v:
                             self.graph[u].remove(lowercase__)




 def 		__snake_case						(      self :  Optional[Any]      ,   lowercase__ :  Optional[int]=-2      ,   lowercase__ :  int=-1):







        '''simple docstring'''



        if s == d:
               return []
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = []
        if s == -2:
               lowerCAmelCase__					     = list(self.graph)[0]
        stack.append(lowercase__)
        visited.append(lowercase__)
        lowerCAmelCase__					     = s

        while True:
               # check if there is any non isolated nodes
               if len(self.graph[s]) != 0:
                      lowerCAmelCase__					     = s
                      for node in self.graph[s]:
                             if visited.count(node[1]) < 1:
                                    if node[1] == d:
                                           visited.append(lowercase__)
                                           return visited
                                    else:
                                           stack.append(node[1])
                                           visited.append(node[1])
                                           lowerCAmelCase__					     = node[1]
                                           break

            # check if all the children are visited
               if s == ss:
                      stack.pop()
                      if len(lowercase__) != 0:
                             lowerCAmelCase__					     = stack[len(lowercase__) - 1]
               else:
                      lowerCAmelCase__					     = ss

               # check if se have reached the starting point
               if len(lowercase__) == 0:
                      return visited




 def 		__snake_case						(      self :  Optional[Any]      ,   lowercase__ :  Optional[Any]=-1):







        '''simple docstring'''



        if c == -1:
               lowerCAmelCase__					     = floor(random() * 10_000) + 10
        for i in range(lowercase__):
               # every vertex has max 100 edges
               for _ in range(floor(random() * 102) + 1):
                      lowerCAmelCase__					     = floor(random() * c) + 1
                      if n != i:
                             self.add_pair(lowercase__      ,   lowercase__      ,   1)




 def 		__snake_case						(      self :  Dict      ,   lowercase__ :  Tuple=-2):







        '''simple docstring'''



        lowerCAmelCase__					     = deque()
        lowerCAmelCase__					     = []
        if s == -2:
               lowerCAmelCase__					     = list(self.graph)[0]
        d.append(lowercase__)
        visited.append(lowercase__)
        while d:
               lowerCAmelCase__					     = d.popleft()
               if len(self.graph[s]) != 0:
                      for node in self.graph[s]:
                             if visited.count(node[1]) < 1:
                                    d.append(node[1])
                                    visited.append(node[1])
        return visited




 def 		__snake_case						(      self :  Any      ,   lowercase__ :  List[str]):







        '''simple docstring'''



        lowerCAmelCase__					     = 0
        for x in self.graph:
               for y in self.graph[x]:
                      if y[1] == u:
                             count += 1
        return count




 def 		__snake_case						(      self :  Optional[int]      ,   lowercase__ :  Union[str, Any]):







        '''simple docstring'''



        return len(self.graph[u])




 def 		__snake_case						(      self :  Tuple      ,   lowercase__ :  str=-2):







        '''simple docstring'''



        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = []
        if s == -2:
               lowerCAmelCase__					     = list(self.graph)[0]
        stack.append(lowercase__)
        visited.append(lowercase__)
        lowerCAmelCase__					     = s
        lowerCAmelCase__					     = []

        while True:
               # check if there is any non isolated nodes
               if len(self.graph[s]) != 0:
                      lowerCAmelCase__					     = s
                      for node in self.graph[s]:
                             if visited.count(node[1]) < 1:
                                    stack.append(node[1])
                                    visited.append(node[1])
                                    lowerCAmelCase__					     = node[1]
                                    break

            # check if all the children are visited
               if s == ss:
                      sorted_nodes.append(stack.pop())
                      if len(lowercase__) != 0:
                             lowerCAmelCase__					     = stack[len(lowercase__) - 1]
               else:
                      lowerCAmelCase__					     = ss

               # check if se have reached the starting point
               if len(lowercase__) == 0:
                      return sorted_nodes




 def 		__snake_case						(      self :  str):







        '''simple docstring'''



        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = list(self.graph)[0]
        stack.append(lowercase__)
        visited.append(lowercase__)
        lowerCAmelCase__					     = -2
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = s
        lowerCAmelCase__					     = False
        lowerCAmelCase__					     = set()

        while True:
               # check if there is any non isolated nodes
               if len(self.graph[s]) != 0:
                      lowerCAmelCase__					     = s
                      for node in self.graph[s]:
                             if (
                                 visited.count(node[1]) > 0
                                 and node[1] != parent
                                 and indirect_parents.count(node[1]) > 0
                                 and not on_the_way_back
                             ):
                                    lowerCAmelCase__					     = len(lowercase__) - 1
                                    while len_stack >= 0:
                                           if stack[len_stack] == node[1]:
                                                  anticipating_nodes.add(node[1])
                                                  break
                                           else:
                                                  anticipating_nodes.add(stack[len_stack])
                                                  len_stack -= 1
                             if visited.count(node[1]) < 1:
                                    stack.append(node[1])
                                    visited.append(node[1])
                                    lowerCAmelCase__					     = node[1]
                                    break

            # check if all the children are visited
               if s == ss:
                      stack.pop()
                      lowerCAmelCase__					     = True
                      if len(lowercase__) != 0:
                             lowerCAmelCase__					     = stack[len(lowercase__) - 1]
               else:
                      lowerCAmelCase__					     = False
                      indirect_parents.append(lowercase__)
                      lowerCAmelCase__					     = s
                      lowerCAmelCase__					     = ss

               # check if se have reached the starting point
               if len(lowercase__) == 0:
                      return list(lowercase__)




 def 		__snake_case						(      self :  List[Any]):







        '''simple docstring'''



        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = list(self.graph)[0]
        stack.append(lowercase__)
        visited.append(lowercase__)
        lowerCAmelCase__					     = -2
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = s
        lowerCAmelCase__					     = False
        lowerCAmelCase__					     = set()

        while True:
               # check if there is any non isolated nodes
               if len(self.graph[s]) != 0:
                      lowerCAmelCase__					     = s
                      for node in self.graph[s]:
                             if (
                                 visited.count(node[1]) > 0
                                 and node[1] != parent
                                 and indirect_parents.count(node[1]) > 0
                                 and not on_the_way_back
                             ):
                                    lowerCAmelCase__					     = len(lowercase__) - 1
                                    while len_stack_minus_one >= 0:
                                           if stack[len_stack_minus_one] == node[1]:
                                                  anticipating_nodes.add(node[1])
                                                  break
                                           else:
                                                  return True
                             if visited.count(node[1]) < 1:
                                    stack.append(node[1])
                                    visited.append(node[1])
                                    lowerCAmelCase__					     = node[1]
                                    break

            # check if all the children are visited
               if s == ss:
                      stack.pop()
                      lowerCAmelCase__					     = True
                      if len(lowercase__) != 0:
                             lowerCAmelCase__					     = stack[len(lowercase__) - 1]
               else:
                      lowerCAmelCase__					     = False
                      indirect_parents.append(lowercase__)
                      lowerCAmelCase__					     = s
                      lowerCAmelCase__					     = ss

               # check if se have reached the starting point
               if len(lowercase__) == 0:
                      return False




 def 		__snake_case						(      self :  Union[str, Any]      ,   lowercase__ :  Optional[Any]=-2      ,   lowercase__ :  Any=-1):







        '''simple docstring'''



        lowerCAmelCase__					     = time()
        self.dfs(lowercase__      ,   lowercase__)
        lowerCAmelCase__					     = time()
        return end - begin




 def 		__snake_case						(      self :  Dict      ,   lowercase__ :  Dict=-2):







        '''simple docstring'''



        lowerCAmelCase__					     = time()
        self.bfs(lowercase__)
        lowerCAmelCase__					     = time()
        return end - begin






class     a_			:






 '''simple docstring'''






 def __init__(      self :  Dict):







        '''simple docstring'''



        lowerCAmelCase__					     = {}




 def 		__snake_case						(      self :  Any      ,   lowercase__ :  List[str]      ,   lowercase__ :  Tuple      ,   lowercase__ :  List[str]=1):







        '''simple docstring'''



        if self.graph.get(lowercase__):
               # if there already is a edge
               if self.graph[u].count([w, v]) == 0:
                      self.graph[u].append([w, v])
        else:
               # if u does not exist
               lowerCAmelCase__					     = [[w, v]]
        # add the other way
        if self.graph.get(lowercase__):
               # if there already is a edge
               if self.graph[v].count([w, u]) == 0:
                      self.graph[v].append([w, u])
        else:
               # if u does not exist
               lowerCAmelCase__					     = [[w, u]]




 def 		__snake_case						(      self :  Dict      ,   lowercase__ :  Optional[int]      ,   lowercase__ :  int):







        '''simple docstring'''



        if self.graph.get(lowercase__):
               for _ in self.graph[u]:
                      if _[1] == v:
                             self.graph[u].remove(lowercase__)
        # the other way round
        if self.graph.get(lowercase__):
               for _ in self.graph[v]:
                      if _[1] == u:
                             self.graph[v].remove(lowercase__)




 def 		__snake_case						(      self :  Optional[int]      ,   lowercase__ :  Optional[int]=-2      ,   lowercase__ :  Dict=-1):







        '''simple docstring'''



        if s == d:
               return []
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = []
        if s == -2:
               lowerCAmelCase__					     = list(self.graph)[0]
        stack.append(lowercase__)
        visited.append(lowercase__)
        lowerCAmelCase__					     = s

        while True:
               # check if there is any non isolated nodes
               if len(self.graph[s]) != 0:
                      lowerCAmelCase__					     = s
                      for node in self.graph[s]:
                             if visited.count(node[1]) < 1:
                                    if node[1] == d:
                                           visited.append(lowercase__)
                                           return visited
                                    else:
                                           stack.append(node[1])
                                           visited.append(node[1])
                                           lowerCAmelCase__					     = node[1]
                                           break

            # check if all the children are visited
               if s == ss:
                      stack.pop()
                      if len(lowercase__) != 0:
                             lowerCAmelCase__					     = stack[len(lowercase__) - 1]
               else:
                      lowerCAmelCase__					     = ss

               # check if se have reached the starting point
               if len(lowercase__) == 0:
                      return visited




 def 		__snake_case						(      self :  Tuple      ,   lowercase__ :  Dict=-1):







        '''simple docstring'''



        if c == -1:
               lowerCAmelCase__					     = floor(random() * 10_000) + 10
        for i in range(lowercase__):
               # every vertex has max 100 edges
               for _ in range(floor(random() * 102) + 1):
                      lowerCAmelCase__					     = floor(random() * c) + 1
                      if n != i:
                             self.add_pair(lowercase__      ,   lowercase__      ,   1)




 def 		__snake_case						(      self :  int      ,   lowercase__ :  Optional[int]=-2):







        '''simple docstring'''



        lowerCAmelCase__					     = deque()
        lowerCAmelCase__					     = []
        if s == -2:
               lowerCAmelCase__					     = list(self.graph)[0]
        d.append(lowercase__)
        visited.append(lowercase__)
        while d:
               lowerCAmelCase__					     = d.popleft()
               if len(self.graph[s]) != 0:
                      for node in self.graph[s]:
                             if visited.count(node[1]) < 1:
                                    d.append(node[1])
                                    visited.append(node[1])
        return visited




 def 		__snake_case						(      self :  Dict      ,   lowercase__ :  Optional[Any]):







        '''simple docstring'''



        return len(self.graph[u])




 def 		__snake_case						(      self :  str):







        '''simple docstring'''



        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = list(self.graph)[0]
        stack.append(lowercase__)
        visited.append(lowercase__)
        lowerCAmelCase__					     = -2
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = s
        lowerCAmelCase__					     = False
        lowerCAmelCase__					     = set()

        while True:
               # check if there is any non isolated nodes
               if len(self.graph[s]) != 0:
                      lowerCAmelCase__					     = s
                      for node in self.graph[s]:
                             if (
                                 visited.count(node[1]) > 0
                                 and node[1] != parent
                                 and indirect_parents.count(node[1]) > 0
                                 and not on_the_way_back
                             ):
                                    lowerCAmelCase__					     = len(lowercase__) - 1
                                    while len_stack >= 0:
                                           if stack[len_stack] == node[1]:
                                                  anticipating_nodes.add(node[1])
                                                  break
                                           else:
                                                  anticipating_nodes.add(stack[len_stack])
                                                  len_stack -= 1
                             if visited.count(node[1]) < 1:
                                    stack.append(node[1])
                                    visited.append(node[1])
                                    lowerCAmelCase__					     = node[1]
                                    break

            # check if all the children are visited
               if s == ss:
                      stack.pop()
                      lowerCAmelCase__					     = True
                      if len(lowercase__) != 0:
                             lowerCAmelCase__					     = stack[len(lowercase__) - 1]
               else:
                      lowerCAmelCase__					     = False
                      indirect_parents.append(lowercase__)
                      lowerCAmelCase__					     = s
                      lowerCAmelCase__					     = ss

               # check if se have reached the starting point
               if len(lowercase__) == 0:
                      return list(lowercase__)




 def 		__snake_case						(      self :  Any):







        '''simple docstring'''



        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = list(self.graph)[0]
        stack.append(lowercase__)
        visited.append(lowercase__)
        lowerCAmelCase__					     = -2
        lowerCAmelCase__					     = []
        lowerCAmelCase__					     = s
        lowerCAmelCase__					     = False
        lowerCAmelCase__					     = set()

        while True:
               # check if there is any non isolated nodes
               if len(self.graph[s]) != 0:
                      lowerCAmelCase__					     = s
                      for node in self.graph[s]:
                             if (
                                 visited.count(node[1]) > 0
                                 and node[1] != parent
                                 and indirect_parents.count(node[1]) > 0
                                 and not on_the_way_back
                             ):
                                    lowerCAmelCase__					     = len(lowercase__) - 1
                                    while len_stack_minus_one >= 0:
                                           if stack[len_stack_minus_one] == node[1]:
                                                  anticipating_nodes.add(node[1])
                                                  break
                                           else:
                                                  return True
                             if visited.count(node[1]) < 1:
                                    stack.append(node[1])
                                    visited.append(node[1])
                                    lowerCAmelCase__					     = node[1]
                                    break

            # check if all the children are visited
               if s == ss:
                      stack.pop()
                      lowerCAmelCase__					     = True
                      if len(lowercase__) != 0:
                             lowerCAmelCase__					     = stack[len(lowercase__) - 1]
               else:
                      lowerCAmelCase__					     = False
                      indirect_parents.append(lowercase__)
                      lowerCAmelCase__					     = s
                      lowerCAmelCase__					     = ss

               # check if se have reached the starting point
               if len(lowercase__) == 0:
                      return False




 def 		__snake_case						(      self :  List[str]):







        '''simple docstring'''



        return list(self.graph)




 def 		__snake_case						(      self :  List[str]      ,   lowercase__ :  str=-2      ,   lowercase__ :  List[Any]=-1):







        '''simple docstring'''



        lowerCAmelCase__					     = time()
        self.dfs(lowercase__      ,   lowercase__)
        lowerCAmelCase__					     = time()
        return end - begin




 def 		__snake_case						(      self :  Any      ,   lowercase__ :  Union[str, Any]=-2):







        '''simple docstring'''



        lowerCAmelCase__					     = time()
        self.bfs(lowercase__)
        lowerCAmelCase__					     = time()
        return end - begin


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__     						=			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     a_			(						SCREAMING_SNAKE_CASE						):






 '''simple docstring'''






 def __init__(      self :  int      ,   *lowercase__ :  Dict      ,   lowercase__ :  List[Any]=None      ,   lowercase__ :  Optional[Any]=None      ,   lowercase__ :  Dict=None      ,   **lowercase__ :  Optional[int]):







        '''simple docstring'''



        super().__init__(*lowercase__      ,   **lowercase__)
        lowerCAmelCase__					     = eval_examples
        lowerCAmelCase__					     = post_process_function
        lowerCAmelCase__					     = quant_trainer_args
        lowerCAmelCase__					     = 128  # default number of calibration samples




 def 		__snake_case						(      self :  Tuple      ,   lowercase__ :  Any=None):







        '''simple docstring'''



        if calib_dataset is None and self.calib_dataset is None:
               raise ValueError('Trainer: calibration requires an calib_dataset.')
        lowerCAmelCase__					     = calib_dataset if calib_dataset is not None else self.calib_dataset

        lowerCAmelCase__					     = self._remove_unused_columns(lowercase__      ,   description='Calibration')

        return DataLoader(
            lowercase__      ,   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=lowercase__      ,   )




 def 		__snake_case						(      self :  List[Any]      ,   lowercase__ :  Union[str, Any]=None):







        '''simple docstring'''



        lowerCAmelCase__					     = self.train_dataset if calib_dataset is None else calib_dataset
        lowerCAmelCase__					     = self.get_calib_dataloader(lowercase__)

        lowerCAmelCase__					     = self.model
        quant_trainer.configure_model(lowercase__      ,   self.quant_trainer_args      ,   calib=lowercase__)
        model.eval()
        quant_trainer.enable_calibration(lowercase__)

        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(lowercase__):
               # Prediction step
               lowerCAmelCase__     , lowerCAmelCase__     , lowerCAmelCase__					     = self.prediction_step(lowercase__      ,   lowercase__      ,   prediction_loss_only=lowercase__)
               if (step + 1) * calib_dataloader.batch_size >= self.calib_num:
                      break

        quant_trainer.finish_calibration(lowercase__      ,   self.quant_trainer_args)
        lowerCAmelCase__					     = model




 def 		__snake_case						(      self :  Optional[Any]      ,   lowercase__ :  List[Any]=None      ,   lowercase__ :  Optional[Any]=None      ,   lowercase__ :  List[Any]=None      ,   lowercase__ :  str = "eval"):







        '''simple docstring'''



        lowerCAmelCase__					     = self.eval_dataset if eval_dataset is None else eval_dataset
        lowerCAmelCase__					     = self.get_eval_dataloader(lowercase__)
        lowerCAmelCase__					     = self.eval_examples if eval_examples is None else eval_examples

        # Temporarily disable metric computation, we will do it in the loop here.
        lowerCAmelCase__					     = self.compute_metrics
        lowerCAmelCase__					     = None
        lowerCAmelCase__					     = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
        try:
               lowerCAmelCase__					     = eval_loop(
                   lowercase__      ,   description='Evaluation'      ,   prediction_loss_only=True if compute_metrics is None else None      ,   ignore_keys=lowercase__      ,   )
        finally:
               lowerCAmelCase__					     = compute_metrics

        if self.post_process_function is not None and self.compute_metrics is not None:
               lowerCAmelCase__					     = self.post_process_function(lowercase__      ,   lowercase__      ,   output.predictions)
               lowerCAmelCase__					     = self.compute_metrics(lowercase__)

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

               self.log(lowercase__)
        else:
               lowerCAmelCase__					     = {}

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

        lowerCAmelCase__					     = self.callback_handler.on_evaluate(self.args      ,   self.state      ,   self.control      ,   lowercase__)
        return metrics




 def 		__snake_case						(      self :  Optional[int]      ,   lowercase__ :  str      ,   lowercase__ :  Any      ,   lowercase__ :  List[str]=None      ,   lowercase__ :  str = "test"):







        '''simple docstring'''



        lowerCAmelCase__					     = self.get_test_dataloader(lowercase__)

        # Temporarily disable metric computation, we will do it in the loop here.
        lowerCAmelCase__					     = self.compute_metrics
        lowerCAmelCase__					     = None
        lowerCAmelCase__					     = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
        try:
               lowerCAmelCase__					     = eval_loop(
                   lowercase__      ,   description='Prediction'      ,   prediction_loss_only=True if compute_metrics is None else None      ,   ignore_keys=lowercase__      ,   )
        finally:
               lowerCAmelCase__					     = compute_metrics

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

        lowerCAmelCase__					     = self.post_process_function(lowercase__      ,   lowercase__      ,   output.predictions      ,   'predict')
        lowerCAmelCase__					     = self.compute_metrics(lowercase__)

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

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




 def 		__snake_case						(      self :  List[str]      ,   lowercase__ :  List[str]="./"):







        '''simple docstring'''



        lowerCAmelCase__					     = self.eval_dataset
        lowerCAmelCase__					     = self.get_eval_dataloader(lowercase__)

        lowerCAmelCase__					     = next(iter(lowercase__))

        # saving device - to make it consistent
        lowerCAmelCase__					     = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

        # convert to tuple
        lowerCAmelCase__					     = tuple(v.to(lowercase__) for k, v in batch.items())

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

        lowerCAmelCase__					     = True

        lowerCAmelCase__					     = self.model.to(lowercase__)

        model.eval()
        model.float()

        lowerCAmelCase__					     = model.module if hasattr(lowercase__      ,   'module') else model
        quant_trainer.configure_model(lowercase__      ,   self.quant_trainer_args)

        lowerCAmelCase__					     = os.path.join(lowercase__      ,   'model.onnx')
        logger.info(F"""exporting model to {output_model_file}""")

        lowerCAmelCase__					     = {0: 'batch_size', 1: 'seq_len'}

        torch.onnx.export(
            lowercase__      ,   lowercase__      ,   lowercase__      ,   export_params=lowercase__      ,   opset_version=13      ,   do_constant_folding=lowercase__      ,   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=lowercase__      ,   )
        logger.info('onnx export finished')
