





'''simple docstring'''


import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
		    MODEL_MAPPING,
		    LevitForImageClassification,
		    LevitForImageClassificationWithTeacher,
		    LevitModel,
		)
		from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import LevitImageProcessor






class       UpperCamelCase__  (		__lowerCAmelCase     ):







	def 						__a   (				self			:   Optional[Any]		):




				'''simple docstring'''
				a__     = self.config_class(**self.inputs_dict		)
				self.parent.assertTrue(hasattr(lowerCamelCase , "hidden_sizes"		)		)
				self.parent.assertTrue(hasattr(lowerCamelCase , "num_attention_heads"		)		)






class       UpperCamelCase__  :







	def __init__(				self			:   Dict , lowerCamelCase			:   Union[str, Any] , lowerCamelCase			:   Tuple=1_3 , lowerCamelCase			:   List[str]=6_4 , lowerCamelCase			:   Tuple=3 , lowerCamelCase			:   Optional[Any]=3 , lowerCamelCase			:   Dict=2 , lowerCamelCase			:   str=1 , lowerCamelCase			:   List[str]=1_6 , lowerCamelCase			:   str=[1_2_8, 2_5_6, 3_8_4] , lowerCamelCase			:   Tuple=[4, 6, 8] , lowerCamelCase			:   Dict=[2, 3, 4] , lowerCamelCase			:   List[Any]=[1_6, 1_6, 1_6] , lowerCamelCase			:   List[str]=0 , lowerCamelCase			:   Dict=[2, 2, 2] , lowerCamelCase			:   Optional[int]=[2, 2, 2] , lowerCamelCase			:   Tuple=0.02 , lowerCamelCase			:   Optional[int]=True , lowerCamelCase			:   List[Any]=True , lowerCamelCase			:   List[Any]=2 , ):




				'''simple docstring'''
				a__     = parent
				a__     = batch_size
				a__     = image_size
				a__     = num_channels
				a__     = kernel_size
				a__     = stride
				a__     = padding
				a__     = hidden_sizes
				a__     = num_attention_heads
				a__     = depths
				a__     = key_dim
				a__     = drop_path_rate
				a__     = patch_size
				a__     = attention_ratio
				a__     = mlp_ratio
				a__     = initializer_range
				a__     = [
				    ["Subsample", key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
				    ["Subsample", key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
				]
				a__     = is_training
				a__     = use_labels
				a__     = num_labels
				a__     = initializer_range







	def 						__a   (				self			:   Optional[Any]		):




				'''simple docstring'''
				a__     = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

				a__     = None
				if self.use_labels:
							a__     = ids_tensor([self.batch_size] , self.num_labels		)

				a__     = self.get_config()
				return config, pixel_values, labels







	def 						__a   (				self			:   Optional[int]		):




				'''simple docstring'''
				return LevitConfig(
				    image_size=self.image_size , num_channels=self.num_channels , kernel_size=self.kernel_size , stride=self.stride , padding=self.padding , patch_size=self.patch_size , hidden_sizes=self.hidden_sizes , num_attention_heads=self.num_attention_heads , depths=self.depths , key_dim=self.key_dim , drop_path_rate=self.drop_path_rate , mlp_ratio=self.mlp_ratio , attention_ratio=self.attention_ratio , initializer_range=self.initializer_range , down_ops=self.down_ops , )







	def 						__a   (				self			:   Dict , lowerCamelCase			:   Optional[Any] , lowerCamelCase			:   str , lowerCamelCase			:   int		):




				'''simple docstring'''
				a__     = LevitModel(config=lowerCamelCase		)
				model.to(lowerCamelCase		)
				model.eval()
				a__     = model(lowerCamelCase		)
				a__     = (self.image_size, self.image_size)
				a__   ,				a__     = image_size[0], image_size[1]
				for _ in range(4		):
							a__     = floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1		)
							a__     = floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1		)
				self.parent.assertEqual(
				    result.last_hidden_state.shape , (self.batch_size, ceil(height / 4		) * ceil(width / 4		), self.hidden_sizes[-1]) , )







	def 						__a   (				self			:   List[Any] , lowerCamelCase			:   Dict , lowerCamelCase			:   Dict , lowerCamelCase			:   Dict		):




				'''simple docstring'''
				a__     = self.num_labels
				a__     = LevitForImageClassification(lowerCamelCase		)
				model.to(lowerCamelCase		)
				model.eval()
				a__     = model(lowerCamelCase , labels=lowerCamelCase		)
				self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels)		)







	def 						__a   (				self			:   int		):




				'''simple docstring'''
				a__     = self.prepare_config_and_inputs()
				a__   ,				a__   ,				a__     = config_and_inputs
				a__     = {"pixel_values": pixel_values}
				return config, inputs_dict






@require_torch
class       UpperCamelCase__  (		__lowerCAmelCase	,__lowerCAmelCase	,unittest.TestCase     ):
	lowerCAmelCase__					:			int								=						(
	    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
	    if is_torch_available()
	    else ()
	)
	lowerCAmelCase__					:			int								=						(
	    {
	        "feature-extraction": LevitModel,
	        "image-classification": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
	    }
	    if is_torch_available()
	    else {}
	)

	lowerCAmelCase__					:			int								=						False
	lowerCAmelCase__					:			int								=						False
	lowerCAmelCase__					:			Tuple								=						False
	lowerCAmelCase__					:			str								=						False
	lowerCAmelCase__					:			Dict								=						False







	def 						__a   (				self			:   List[Any]		):




				'''simple docstring'''
				a__     = LevitModelTester(self		)
				a__     = ConfigTester(self , config_class=lowerCamelCase , has_text_modality=lowerCamelCase , hidden_size=3_7		)







	def 						__a   (				self			:   Union[str, Any]		):




				'''simple docstring'''
				self.create_and_test_config_common_properties()
				self.config_tester.create_and_test_config_to_json_string()
				self.config_tester.create_and_test_config_to_json_file()
				self.config_tester.create_and_test_config_from_and_save_pretrained()
				self.config_tester.create_and_test_config_with_num_labels()
				self.config_tester.check_config_can_be_init_without_params()
				self.config_tester.check_config_arguments_init()







	def 						__a   (				self			:   Any		):




				'''simple docstring'''
				return







	@unittest.skip(reason="Levit does not use inputs_embeds"		)
	def 						__a   (				self			:   List[str]		):




				'''simple docstring'''
				pass







	@unittest.skip(reason="Levit does not support input and output embeddings"		)
	def 						__a   (				self			:   Any		):




				'''simple docstring'''
				pass







	@unittest.skip(reason="Levit does not output attentions"		)
	def 						__a   (				self			:   List[Any]		):




				'''simple docstring'''
				pass







	def 						__a   (				self			:   Union[str, Any]		):




				'''simple docstring'''
				a__   ,				a__     = self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							a__     = model_class(lowerCamelCase		)
							a__     = inspect.signature(model.forward		)
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							a__     = [*signature.parameters.keys()]

							a__     = ["pixel_values"]
							self.assertListEqual(arg_names[:1] , lowerCamelCase		)







	def 						__a   (				self			:   List[Any]		):




				'''simple docstring'''
				def check_hidden_states_output(lowerCamelCase			:   Dict , lowerCamelCase			:   Optional[Any] , lowerCamelCase			:   Dict		):
							a__     = model_class(lowerCamelCase		)
							model.to(lowerCamelCase		)
							model.eval()

							with torch.no_grad():
										a__     = model(**self._prepare_for_class(lowerCamelCase , lowerCamelCase		)		)

							a__     = outputs.hidden_states

							a__     = len(self.model_tester.depths		) + 1
							self.assertEqual(len(lowerCamelCase		) , lowerCamelCase		)

							a__     = (self.model_tester.image_size, self.model_tester.image_size)
							a__   ,				a__     = image_size[0], image_size[1]
							for _ in range(4		):
										a__     = floor(
										    (
										        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
										        / self.model_tester.stride
										    )
										    + 1		)
										a__     = floor(
										    (
										        (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
										        / self.model_tester.stride
										    )
										    + 1		)
							# verify the first hidden states (first block)
							self.assertListEqual(
							    list(hidden_states[0].shape[-2:]		) , [
							        height * width,
							        self.model_tester.hidden_sizes[0],
							    ] , )

				a__   ,				a__     = self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							a__     = True
							check_hidden_states_output(lowerCamelCase , lowerCamelCase , lowerCamelCase		)

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							a__     = True

							check_hidden_states_output(lowerCamelCase , lowerCamelCase , lowerCamelCase		)







	@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."		)
	def 						__a   (				self			:   Tuple		):




				'''simple docstring'''
				pass







	def 						__a   (				self			:   str , lowerCamelCase			:   Tuple , lowerCamelCase			:   List[str] , lowerCamelCase			:   int=False		):




				'''simple docstring'''
				a__     = super()._prepare_for_class(lowerCamelCase , lowerCamelCase , return_labels=lowerCamelCase		)

				if return_labels:
							if model_class.__name__ == "LevitForImageClassificationWithTeacher":
										del inputs_dict["labels"]

				return inputs_dict







	def 						__a   (				self			:   Tuple		):




				'''simple docstring'''
				a__     = self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowerCamelCase		)







	def 						__a   (				self			:   Optional[int]		):




				'''simple docstring'''
				a__     = self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*lowerCamelCase		)







	def 						__a   (				self			:   List[Any]		):




				'''simple docstring'''
				if not self.model_tester.is_training:
							return

				a__   ,				a__     = self.model_tester.prepare_config_and_inputs_for_common()
				a__     = True

				for model_class in self.all_model_classes:
							# LevitForImageClassificationWithTeacher supports inference-only
							if (
							    model_class in get_values(lowerCamelCase		)
							    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
							):
										continue
							a__     = model_class(lowerCamelCase		)
							model.to(lowerCamelCase		)
							model.train()
							a__     = self._prepare_for_class(lowerCamelCase , lowerCamelCase , return_labels=lowerCamelCase		)
							a__     = model(**lowerCamelCase		).loss
							loss.backward()







	def 						__a   (				self			:   Optional[Any]		):




				'''simple docstring'''
				a__   ,				a__     = self.model_tester.prepare_config_and_inputs_for_common()
				if not self.model_tester.is_training:
							return

				a__     = False
				a__     = True

				for model_class in self.all_model_classes:
							if model_class in get_values(lowerCamelCase		) or not model_class.supports_gradient_checkpointing:
										continue
							# LevitForImageClassificationWithTeacher supports inference-only
							if model_class.__name__ == "LevitForImageClassificationWithTeacher":
										continue
							a__     = model_class(lowerCamelCase		)
							model.gradient_checkpointing_enable()
							model.to(lowerCamelCase		)
							model.train()
							a__     = self._prepare_for_class(lowerCamelCase , lowerCamelCase , return_labels=lowerCamelCase		)
							a__     = model(**lowerCamelCase		).loss
							loss.backward()







	def 						__a   (				self			:   Optional[Any]		):




				'''simple docstring'''
				a__   ,				a__     = self.model_tester.prepare_config_and_inputs_for_common()

				a__     = [
				    {"title": "multi_label_classification", "num_labels": 2, "dtype": torch.float},
				    {"title": "single_label_classification", "num_labels": 1, "dtype": torch.long},
				    {"title": "regression", "num_labels": 1, "dtype": torch.float},
				]

				for model_class in self.all_model_classes:
							if (
							    model_class
							    not in [
							        *get_values(lowerCamelCase		),
							    ]
							    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
							):
										continue

							for problem_type in problem_types:
										with self.subTest(msg=F'''Testing {model_class} with {problem_type["title"]}'''		):
													a__     = problem_type["title"]
													a__     = problem_type["num_labels"]

													a__     = model_class(lowerCamelCase		)
													model.to(lowerCamelCase		)
													model.train()

													a__     = self._prepare_for_class(lowerCamelCase , lowerCamelCase , return_labels=lowerCamelCase		)

													if problem_type["num_labels"] > 1:
																a__     = inputs["labels"].unsqueeze(1		).repeat(1 , problem_type["num_labels"]		)

													a__     = inputs["labels"].to(problem_type["dtype"]		)

													# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
													# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
													# they have the same size." which is a symptom something in wrong for the regression problem.
													# See https://github.com/huggingface/transformers/issues/11780
													with warnings.catch_warnings(record=lowerCamelCase		) as warning_list:
																a__     = model(**lowerCamelCase		).loss
													for w in warning_list:
																if "Using a target size that is different to the input size" in str(w.message		):
																			raise ValueError(
																			    F'''Something is going wrong in the regression problem: intercepted {w.message}'''		)

													loss.backward()







	@slow
	def 						__a   (				self			:   Dict		):




				'''simple docstring'''
				for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							a__     = LevitModel.from_pretrained(lowerCamelCase		)
							self.assertIsNotNone(lowerCamelCase		)







def    _lowerCamelCase  ()   ->    Any:
			a__     = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"     )
			return image






@require_torch
@require_vision
class       UpperCamelCase__  (		unittest.TestCase     ):







	@cached_property
	def 						__a   (				self			:   int		):




				'''simple docstring'''
				return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)







	@slow
	def 						__a   (				self			:   List[str]		):




				'''simple docstring'''
				a__     = LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(
				    lowerCamelCase		)

				a__     = self.default_image_processor
				a__     = prepare_img()
				a__     = image_processor(images=lowerCamelCase , return_tensors="pt"		).to(lowerCamelCase		)

				# forward pass
				with torch.no_grad():
							a__     = model(**lowerCamelCase		)

				# verify the logits
				a__     = torch.Size((1, 1_0_0_0)		)
				self.assertEqual(outputs.logits.shape , lowerCamelCase		)

				a__     = torch.tensor([1.0448, -0.3745, -1.8317]		).to(lowerCamelCase		)

				self.assertTrue(torch.allclose(outputs.logits[0, :3] , lowerCamelCase , atol=1e-4		)		)










'''simple docstring'''


import os
import time

import numpy as np
import onnxruntime as ort


lowerCAmelCase_   :   Optional[int]       =					"1"
lowerCAmelCase_   :   List[str]       =					"0"
lowerCAmelCase_   :   Tuple       =					"1"

lowerCAmelCase_   :   str       =					ort.SessionOptions()
lowerCAmelCase_   :   Tuple       =					ort.GraphOptimizationLevel.ORT_DISABLE_ALL
print("Create inference session...")
lowerCAmelCase_   :   Any       =					["TensorrtExecutionProvider", "CUDAExecutionProvider"]
lowerCAmelCase_   :   str       =					ort.InferenceSession("model.onnx", sess_options=sess_opt, providers=execution_provider)
lowerCAmelCase_   :   Tuple       =					ort.RunOptions()

lowerCAmelCase_   :   Optional[int]       =					128
lowerCAmelCase_   :   Union[str, Any]       =					1
lowerCAmelCase_   :   List[str]       =					np.ones((batch, sequence), dtype=np.intaa)
lowerCAmelCase_   :   Optional[Any]       =					np.ones((batch, sequence), dtype=np.intaa)
lowerCAmelCase_   :   str       =					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...")
lowerCAmelCase_   :   Tuple       =					time.time()
lowerCAmelCase_   :   int       =					2000
lowerCAmelCase_   :   Optional[Any]       =					{}
for iter in range(max_iters):
		lowerCAmelCase_   :   List[str]       =					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))



