



from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__snake_case     :Dict			       ={'configuration_van': ['VAN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VanConfig']}


try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__snake_case     :List[Any]			       =[
				    'VAN_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'VanForImageClassification',
				    'VanModel',
				    'VanPreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_van import VAN_PRETRAINED_CONFIG_ARCHIVE_MAP, VanConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_van import (
								    VAN_PRETRAINED_MODEL_ARCHIVE_LIST,
								    VanForImageClassification,
								    VanModel,
								    VanPreTrainedModel,
								)

else:
				import sys

				__snake_case     :str			       =_LazyModule(__name__, globals()['__file__'], _import_structure)




import os
import time

import numpy as np
import onnxruntime as ort


__snake_case     :Any			       ='1'
__snake_case     :List[str]			       ='0'
__snake_case     :Union[str, Any]			       ='1'

__snake_case     :Optional[Any]			       =ort.SessionOptions()
__snake_case     :List[str]			       =ort.GraphOptimizationLevel.ORT_DISABLE_ALL
print('Create inference session...')
__snake_case     :int			       =['TensorrtExecutionProvider', 'CUDAExecutionProvider']
__snake_case     :Optional[Any]			       =ort.InferenceSession('model.onnx', sess_options=sess_opt, providers=execution_provider)
__snake_case     :int			       =ort.RunOptions()

__snake_case     :Tuple			       =128
__snake_case     :List[Any]			       =1
__snake_case     :Union[str, Any]			       =np.ones((batch, sequence), dtype=np.intaa)
__snake_case     :Optional[Any]			       =np.ones((batch, sequence), dtype=np.intaa)
__snake_case     :Optional[int]			       =np.ones((batch, sequence), dtype=np.intaa)

print('Warm up phase...')
sess.run(
    None,
    {
        sess.get_inputs()[0].name: input_ids,
        sess.get_inputs()[1].name: attention_mask,
        sess.get_inputs()[2].name: token_type_ids,
    },
    run_options=run_opt,
)

print('Start inference...')
__snake_case     :Union[str, Any]			       =time.time()
__snake_case     :int			       =2000
__snake_case     :Optional[int]			       ={}
for iter in range(max_iters):
				__snake_case     :Optional[Any]			       =sess.run(
				    None,
				    {
				        sess.get_inputs()[0].name: input_ids,
				        sess.get_inputs()[1].name: attention_mask,
				        sess.get_inputs()[2].name: token_type_ids,
				    },
				    run_options=run_opt,
				)
print('Average Inference Time = {:.3f} ms'.format((time.time() - start_time) * 1000 / max_iters))