


import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import (
			    LiltForQuestionAnswering,
			    LiltForSequenceClassification,
			    LiltForTokenClassification,
			    LiltModel,
			)
			from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST

class        a	:




							"""simple docstring"""


							def __init__(							self :						Optional[Any]					,			lowerCamelCase :						Optional[Any]					,			lowerCamelCase :						List[str]=13					,			lowerCamelCase :						Tuple=7					,			lowerCamelCase :						int=True					,			lowerCamelCase :						Any=True					,			lowerCamelCase :						Optional[int]=True					,			lowerCamelCase :						Union[str, Any]=True					,			lowerCamelCase :						Optional[Any]=99					,			lowerCamelCase :						Optional[int]=24					,			lowerCamelCase :						Union[str, Any]=2					,			lowerCamelCase :						Any=6					,			lowerCamelCase :						Optional[int]=37					,			lowerCamelCase :						Union[str, Any]="gelu"					,			lowerCamelCase :						Dict=0.1					,			lowerCamelCase :						Optional[Any]=0.1					,			lowerCamelCase :						Dict=512					,			lowerCamelCase :						List[str]=16					,			lowerCamelCase :						Optional[int]=2					,			lowerCamelCase :						Union[str, Any]=0.02					,			lowerCamelCase :						Any=3					,			lowerCamelCase :						Optional[Any]=None					,			lowerCamelCase :						Optional[Any]=1000					,			)			->					Dict:
														__snake_case	:    Optional[Any]											=     parent
														__snake_case	:    Tuple											=     batch_size
														__snake_case	:    int											=     seq_length
														__snake_case	:    List[str]											=     is_training
														__snake_case	:    Tuple											=     use_input_mask
														__snake_case	:    Union[str, Any]											=     use_token_type_ids
														__snake_case	:    List[Any]											=     use_labels
														__snake_case	:    Union[str, Any]											=     vocab_size
														__snake_case	:    Tuple											=     hidden_size
														__snake_case	:    Tuple											=     num_hidden_layers
														__snake_case	:    Optional[int]											=     num_attention_heads
														__snake_case	:    Tuple											=     intermediate_size
														__snake_case	:    Tuple											=     hidden_act
														__snake_case	:    Optional[Any]											=     hidden_dropout_prob
														__snake_case	:    Optional[Any]											=     attention_probs_dropout_prob
														__snake_case	:    Any											=     max_position_embeddings
														__snake_case	:    Optional[int]											=     type_vocab_size
														__snake_case	:    List[Any]											=     type_sequence_label_size
														__snake_case	:    int											=     initializer_range
														__snake_case	:    str											=     num_labels
														__snake_case	:    List[Any]											=     scope
														__snake_case	:    str											=     range_bbox

							def 					__snake_case      (							self :						Optional[Any]       )			->					Optional[int]:
														__snake_case	:    int											=     ids_tensor([self.batch_size, self.seq_length]					,			self.vocab_size       )

														__snake_case	:    Union[str, Any]											=     ids_tensor([self.batch_size, self.seq_length, 4]					,			self.range_bbox       )
														# Ensure that bbox is legal
														for i in range(bbox.shape[0]       ):
																					for j in range(bbox.shape[1]       ):
																												if bbox[i, j, 3] < bbox[i, j, 1]:
																																			__snake_case	:    Optional[Any]											=     bbox[i, j, 3]
																																			__snake_case	:    str											=     bbox[i, j, 1]
																																			__snake_case	:    int											=     t
																												if bbox[i, j, 2] < bbox[i, j, 0]:
																																			__snake_case	:    Dict											=     bbox[i, j, 2]
																																			__snake_case	:    Union[str, Any]											=     bbox[i, j, 0]
																																			__snake_case	:    Optional[Any]											=     t

														__snake_case	:    Union[str, Any]											=     None
														if self.use_input_mask:
																					__snake_case	:    Optional[int]											=     ids_tensor([self.batch_size, self.seq_length]					,			vocab_size=2       )

														__snake_case	:    Union[str, Any]											=     None
														if self.use_token_type_ids:
																					__snake_case	:    Optional[int]											=     ids_tensor([self.batch_size, self.seq_length]					,			self.type_vocab_size       )

														__snake_case	:    List[Any]											=     None
														__snake_case	:    Optional[Any]											=     None
														if self.use_labels:
																					__snake_case	:    Optional[Any]											=     ids_tensor([self.batch_size]					,			self.type_sequence_label_size       )
																					__snake_case	:    List[Any]											=     ids_tensor([self.batch_size, self.seq_length]					,			self.num_labels       )

														__snake_case	:    List[str]											=     self.get_config()

														return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels

							def 					__snake_case      (							self :						Union[str, Any]       )			->					str:
														return LiltConfig(
														    vocab_size=self.vocab_size					,			hidden_size=self.hidden_size					,			num_hidden_layers=self.num_hidden_layers					,			num_attention_heads=self.num_attention_heads					,			intermediate_size=self.intermediate_size					,			hidden_act=self.hidden_act					,			hidden_dropout_prob=self.hidden_dropout_prob					,			attention_probs_dropout_prob=self.attention_probs_dropout_prob					,			max_position_embeddings=self.max_position_embeddings					,			type_vocab_size=self.type_vocab_size					,			initializer_range=self.initializer_range					,			)

							def 					__snake_case      (							self :						List[str]					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Dict					,			lowerCamelCase :						List[str]					,			lowerCamelCase :						Optional[Any]					,			lowerCamelCase :						Dict					,			lowerCamelCase :						List[str]					,			lowerCamelCase :						Dict					,			)			->					List[str]:
														__snake_case	:    Dict											=     LiltModel(config=lowerCamelCase       )
														model.to(lowerCamelCase       )
														model.eval()
														__snake_case	:    Optional[Any]											=     model(lowerCamelCase					,			bbox=lowerCamelCase					,			attention_mask=lowerCamelCase					,			token_type_ids=lowerCamelCase       )
														__snake_case	:    int											=     model(lowerCamelCase					,			bbox=lowerCamelCase					,			token_type_ids=lowerCamelCase       )
														__snake_case	:    Dict											=     model(lowerCamelCase					,			bbox=lowerCamelCase       )

														self.parent.assertEqual(result.last_hidden_state.shape					,			(self.batch_size, self.seq_length, self.hidden_size)       )
														self.parent.assertEqual(result.pooler_output.shape					,			(self.batch_size, self.hidden_size)       )

							def 					__snake_case      (							self :						Union[str, Any]					,			lowerCamelCase :						str					,			lowerCamelCase :						Optional[Any]					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Tuple					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Dict					,			)			->					str:
														__snake_case	:    List[Any]											=     self.num_labels
														__snake_case	:    List[str]											=     LiltForTokenClassification(config=lowerCamelCase       )
														model.to(lowerCamelCase       )
														model.eval()
														__snake_case	:    Optional[Any]											=     model(
														    lowerCamelCase					,			bbox=lowerCamelCase					,			attention_mask=lowerCamelCase					,			token_type_ids=lowerCamelCase					,			labels=lowerCamelCase       )
														self.parent.assertEqual(result.logits.shape					,			(self.batch_size, self.seq_length, self.num_labels)       )

							def 					__snake_case      (							self :						str					,			lowerCamelCase :						Dict					,			lowerCamelCase :						List[Any]					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Tuple					,			lowerCamelCase :						List[str]					,			lowerCamelCase :						Any					,			)			->					Any:
														__snake_case	:    Optional[int]											=     LiltForQuestionAnswering(config=lowerCamelCase       )
														model.to(lowerCamelCase       )
														model.eval()
														__snake_case	:    Optional[int]											=     model(
														    lowerCamelCase					,			bbox=lowerCamelCase					,			attention_mask=lowerCamelCase					,			token_type_ids=lowerCamelCase					,			start_positions=lowerCamelCase					,			end_positions=lowerCamelCase					,			)
														self.parent.assertEqual(result.start_logits.shape					,			(self.batch_size, self.seq_length)       )
														self.parent.assertEqual(result.end_logits.shape					,			(self.batch_size, self.seq_length)       )






							def 					__snake_case      (							self :						str       )			->					Union[str, Any]:
														__snake_case	:    List[str]											=     self.prepare_config_and_inputs()
														(
														    (
														    __snake_case
														)				,    (
														    __snake_case
														)				,    (
														    __snake_case
														)				,    (
														    __snake_case
														)				,    (
														    __snake_case
														)				,    (
														    __snake_case
														)				,    (
														    __snake_case
														)				,    
														)	:    Optional[Any]											=     config_and_inputs
														__snake_case	:    Optional[Any]											=     {
														    "input_ids": input_ids,
														    "bbox": bbox,
														    "token_type_ids": token_type_ids,
														    "attention_mask": input_mask,
														}
														return config, inputs_dict

@require_torch
class        a	(_lowerCAmelCase  ,       _lowerCAmelCase  ,       _lowerCAmelCase  ,       unittest.TestCase   ):




							"""simple docstring"""


							__UpperCAmelCase					:							Tuple  						=						(
							    (
							        LiltModel,
							        LiltForSequenceClassification,
							        LiltForTokenClassification,
							        LiltForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							__UpperCAmelCase					:							List[str]  						=						(
							    {
							        "feature-extraction": LiltModel,
							        "question-answering": LiltForQuestionAnswering,
							        "text-classification": LiltForSequenceClassification,
							        "token-classification": LiltForTokenClassification,
							        "zero-shot": LiltForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							__UpperCAmelCase					:							int  						=						False
							__UpperCAmelCase					:							str  						=						False

							def 					__snake_case      (							self :						List[str]					,			lowerCamelCase :						Optional[int]					,			lowerCamelCase :						List[Any]					,			lowerCamelCase :						List[Any]					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Optional[int]       )			->					List[Any]:
														return True

							def 					__snake_case      (							self :						str       )			->					List[str]:
														__snake_case	:    str											=     LiltModelTester(self       )
														__snake_case	:    int											=     ConfigTester(self					,			config_class=lowerCamelCase					,			hidden_size=37       )

							def 					__snake_case      (							self :						List[Any]       )			->					Any:
														self.config_tester.run_common_tests()

							def 					__snake_case      (							self :						str       )			->					Tuple:
														__snake_case	:    Any											=     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*lowerCamelCase       )

							def 					__snake_case      (							self :						List[str]       )			->					str:
														__snake_case	:    List[str]											=     self.model_tester.prepare_config_and_inputs()
														for type in ["absolute", "relative_key", "relative_key_query"]:
																					__snake_case	:    Dict											=     type
																					self.model_tester.create_and_check_model(*lowerCamelCase       )

							def 					__snake_case      (							self :						Union[str, Any]       )			->					Optional[Any]:
														__snake_case	:    Dict											=     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_token_classification(*lowerCamelCase       )

							def 					__snake_case      (							self :						Any       )			->					int:
														__snake_case	:    List[Any]											=     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_question_answering(*lowerCamelCase       )






							@slow
							def 					__snake_case      (							self :						Dict       )			->					int:
														for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					__snake_case	:    List[Any]											=     LiltModel.from_pretrained(lowerCamelCase       )
																					self.assertIsNotNone(lowerCamelCase       )

@require_torch
@slow
class        a	(unittest.TestCase   ):




							"""simple docstring"""


							def 					__snake_case      (							self :						Tuple       )			->					List[str]:
														__snake_case	:    Optional[int]											=     LiltModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base"       ).to(lowerCamelCase       )

														__snake_case	:    List[str]											=     torch.tensor([[1, 2]]					,			device=lowerCamelCase       )
														__snake_case	:    List[str]											=     torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]					,			device=lowerCamelCase       )

														# forward pass
														with torch.no_grad():
																					__snake_case	:    List[str]											=     model(input_ids=lowerCamelCase					,			bbox=lowerCamelCase       )

														__snake_case	:    List[str]											=     torch.Size([1, 2, 768]       )
														__snake_case	:    str											=     torch.tensor(
														    [[-0.06_53, 0.09_50, -0.00_61], [-0.05_45, 0.09_26, -0.03_24]]					,			device=lowerCamelCase					,			)

														self.assertTrue(outputs.last_hidden_state.shape					,			lowerCamelCase       )
														self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3]					,			lowerCamelCase					,			atol=1E-3       )       )





import inspect
import unittest
from math import floor

from transformers import CvtConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
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 CvtForImageClassification, CvtModel
			from transformers.models.cvt.modeling_cvt import CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import AutoImageProcessor

class        a	(_lowerCAmelCase   ):




							"""simple docstring"""


							def 					__snake_case      (							self :						str       )			->					Dict:
														__snake_case	:    Any											=     self.config_class(**self.inputs_dict       )
														self.parent.assertTrue(hasattr(lowerCamelCase					,			"embed_dim"       )       )
														self.parent.assertTrue(hasattr(lowerCamelCase					,			"num_heads"       )       )

class        a	:




							"""simple docstring"""


							def __init__(							self :						str					,			lowerCamelCase :						Union[str, Any]					,			lowerCamelCase :						Any=13					,			lowerCamelCase :						Any=64					,			lowerCamelCase :						int=3					,			lowerCamelCase :						Tuple=[16, 48, 96]					,			lowerCamelCase :						Optional[int]=[1, 3, 6]					,			lowerCamelCase :						List[str]=[1, 2, 10]					,			lowerCamelCase :						Any=[7, 3, 3]					,			lowerCamelCase :						Any=[4, 2, 2]					,			lowerCamelCase :						Optional[Any]=[2, 1, 1]					,			lowerCamelCase :						str=[2, 2, 2]					,			lowerCamelCase :						Dict=[False, False, True]					,			lowerCamelCase :						Dict=[0.0, 0.0, 0.0]					,			lowerCamelCase :						Optional[Any]=0.02					,			lowerCamelCase :						Tuple=1E-12					,			lowerCamelCase :						Union[str, Any]=True					,			lowerCamelCase :						Union[str, Any]=True					,			lowerCamelCase :						List[str]=2					,			)			->					Optional[int]:
														__snake_case	:    Tuple											=     parent
														__snake_case	:    List[str]											=     batch_size
														__snake_case	:    Optional[int]											=     image_size
														__snake_case	:    Optional[int]											=     patch_sizes
														__snake_case	:    Union[str, Any]											=     patch_stride
														__snake_case	:    int											=     patch_padding
														__snake_case	:    Optional[Any]											=     is_training
														__snake_case	:    Optional[Any]											=     use_labels
														__snake_case	:    Tuple											=     num_labels
														__snake_case	:    Union[str, Any]											=     num_channels
														__snake_case	:    Tuple											=     embed_dim
														__snake_case	:    List[str]											=     num_heads
														__snake_case	:    Dict											=     stride_kv
														__snake_case	:    Optional[int]											=     depth
														__snake_case	:    List[Any]											=     cls_token
														__snake_case	:    List[Any]											=     attention_drop_rate
														__snake_case	:    Any											=     initializer_range
														__snake_case	:    str											=     layer_norm_eps

							def 					__snake_case      (							self :						List[str]       )			->					str:
														__snake_case	:    str											=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

														__snake_case	:    Optional[Any]											=     self.get_config()
														return config, pixel_values, labels

							def 					__snake_case      (							self :						Tuple       )			->					Optional[Any]:
														return CvtConfig(
														    image_size=self.image_size					,			num_labels=self.num_labels					,			num_channels=self.num_channels					,			embed_dim=self.embed_dim					,			num_heads=self.num_heads					,			patch_sizes=self.patch_sizes					,			patch_padding=self.patch_padding					,			patch_stride=self.patch_stride					,			stride_kv=self.stride_kv					,			depth=self.depth					,			cls_token=self.cls_token					,			attention_drop_rate=self.attention_drop_rate					,			initializer_range=self.initializer_range					,			)

							def 					__snake_case      (							self :						Optional[int]					,			lowerCamelCase :						Union[str, Any]					,			lowerCamelCase :						str					,			lowerCamelCase :						str       )			->					Tuple:
														__snake_case	:    int											=     CvtModel(config=lowerCamelCase       )
														model.to(lowerCamelCase       )
														model.eval()
														__snake_case	:    List[str]											=     model(lowerCamelCase       )
														__snake_case	:    List[Any]											=     (self.image_size, self.image_size)
														__snake_case				,    __snake_case	:    List[str]											=     image_size[0], image_size[1]
														for i in range(len(self.depth       )       ):
																					__snake_case	:    int											=     floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1       )
																					__snake_case	:    Union[str, Any]											=     floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1       )
														self.parent.assertEqual(result.last_hidden_state.shape					,			(self.batch_size, self.embed_dim[-1], height, width)       )

							def 					__snake_case      (							self :						List[str]					,			lowerCamelCase :						Optional[int]					,			lowerCamelCase :						Dict					,			lowerCamelCase :						int       )			->					Optional[Any]:
														__snake_case	:    str											=     self.num_labels
														__snake_case	:    Any											=     CvtForImageClassification(lowerCamelCase       )
														model.to(lowerCamelCase       )
														model.eval()
														__snake_case	:    List[Any]											=     model(lowerCamelCase					,			labels=lowerCamelCase       )
														self.parent.assertEqual(result.logits.shape					,			(self.batch_size, self.num_labels)       )






							def 					__snake_case      (							self :						Union[str, Any]       )			->					List[Any]:
														__snake_case	:    List[Any]											=     self.prepare_config_and_inputs()
														__snake_case				,    __snake_case				,    __snake_case	:    str											=     config_and_inputs
														__snake_case	:    List[str]											=     {"pixel_values": pixel_values}
														return config, inputs_dict

@require_torch
class        a	(_lowerCAmelCase  ,       _lowerCAmelCase  ,       unittest.TestCase   ):




							"""simple docstring"""


							__UpperCAmelCase					:							List[str]  						=						(CvtModel, CvtForImageClassification) if is_torch_available() else ()
							__UpperCAmelCase					:							List[str]  						=						(
							    {"feature-extraction": CvtModel, "image-classification": CvtForImageClassification}
							    if is_torch_available()
							    else {}
							)

							__UpperCAmelCase					:							List[str]  						=						False
							__UpperCAmelCase					:							Tuple  						=						False
							__UpperCAmelCase					:							List[Any]  						=						False
							__UpperCAmelCase					:							Optional[int]  						=						False
							__UpperCAmelCase					:							List[Any]  						=						False

							def 					__snake_case      (							self :						str       )			->					List[str]:
														__snake_case	:    Tuple											=     CvtModelTester(self       )
														__snake_case	:    Tuple											=     ConfigTester(self					,			config_class=lowerCamelCase					,			has_text_modality=lowerCamelCase					,			hidden_size=37       )

							def 					__snake_case      (							self :						Union[str, Any]       )			->					Union[str, Any]:
														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 					__snake_case      (							self :						Tuple       )			->					Union[str, Any]:
														return

							@unittest.skip(reason="Cvt does not output attentions"       )
							def 					__snake_case      (							self :						Optional[int]       )			->					List[str]:
														pass

							@unittest.skip(reason="Cvt does not use inputs_embeds"       )
							def 					__snake_case      (							self :						List[str]       )			->					Any:
														pass

							@unittest.skip(reason="Cvt does not support input and output embeddings"       )
							def 					__snake_case      (							self :						int       )			->					List[Any]:
														pass

							def 					__snake_case      (							self :						int       )			->					int:
														__snake_case				,    __snake_case	:    Optional[int]											=     self.model_tester.prepare_config_and_inputs_for_common()

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

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

							def 					__snake_case      (							self :						str       )			->					Dict:
														__snake_case	:    List[str]											=     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*lowerCamelCase       )

							def 					__snake_case      (							self :						int       )			->					Optional[Any]:
														def check_hidden_states_output(lowerCamelCase :						Dict					,			lowerCamelCase :						Dict					,			lowerCamelCase :						Optional[Any]       ):
																					__snake_case	:    Any											=     model_class(lowerCamelCase       )
																					model.to(lowerCamelCase       )
																					model.eval()

																					with torch.no_grad():
																												__snake_case	:    List[str]											=     model(**self._prepare_for_class(lowerCamelCase					,			lowerCamelCase       )       )

																					__snake_case	:    List[Any]											=     outputs.hidden_states

																					__snake_case	:    Optional[int]											=     len(self.model_tester.depth       )
																					self.assertEqual(len(lowerCamelCase       )					,			lowerCamelCase       )

																					# verify the first hidden states (first block)
																					self.assertListEqual(
																					    list(hidden_states[0].shape[-3:]       )					,			[
																					        self.model_tester.embed_dim[0],
																					        self.model_tester.image_size // 4,
																					        self.model_tester.image_size // 4,
																					    ]					,			)

														__snake_case				,    __snake_case	:    List[str]											=     self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					__snake_case	:    Union[str, Any]											=     True
																					check_hidden_states_output(lowerCamelCase					,			lowerCamelCase					,			lowerCamelCase       )

																					# check that output_hidden_states also work using config
																					del inputs_dict["output_hidden_states"]
																					__snake_case	:    List[str]											=     True

																					check_hidden_states_output(lowerCamelCase					,			lowerCamelCase					,			lowerCamelCase       )

							def 					__snake_case      (							self :						Optional[int]       )			->					Optional[Any]:
														__snake_case	:    Any											=     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_image_classification(*lowerCamelCase       )

							@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."       )
							def 					__snake_case      (							self :						List[str]       )			->					Optional[int]:
														pass






							@slow
							def 					__snake_case      (							self :						Tuple       )			->					List[str]:
														for model_name in CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					__snake_case	:    int											=     CvtModel.from_pretrained(lowerCamelCase       )
																					self.assertIsNotNone(lowerCamelCase       )







def        lowerCAmelCase_  (      ):
							__snake_case	:    Any											=     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
							return image

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




							"""simple docstring"""


							@cached_property
							def 					__snake_case      (							self :						Optional[Any]       )			->					Union[str, Any]:
														return AutoImageProcessor.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )






							@slow
							def 					__snake_case      (							self :						int       )			->					Tuple:
														__snake_case	:    Optional[Any]											=     CvtForImageClassification.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       ).to(lowerCamelCase       )

														__snake_case	:    Optional[int]											=     self.default_image_processor
														__snake_case	:    Union[str, Any]											=     prepare_img()
														__snake_case	:    Dict											=     image_processor(images=lowerCamelCase					,			return_tensors="pt"       ).to(lowerCamelCase       )

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

														# verify the logits
														__snake_case	:    Any											=     torch.Size((1, 1000)       )
														self.assertEqual(outputs.logits.shape					,			lowerCamelCase       )

														__snake_case	:    Optional[Any]											=     torch.tensor([0.92_85, 0.90_15, -0.31_50]       ).to(lowerCamelCase       )

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

