






import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)
class 		SCREAMING_SNAKE_CASE__	(  unittest.TestCase     ):

  '''simple docstring'''







  def  lowerCamelCase       (      self		:			Union[str, Any]							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 2, 3]							)
         self.assertEqual(x.component(0							)       ,				1							)
         self.assertEqual(x.component(2							)       ,				3							)
         _UpperCAmelCase							=    Vector()


  def  lowerCamelCase       (      self		:			Tuple							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([0, 0, 0, 0, 0, 1]							)
         self.assertEqual(str(lowerCamelCase							)       ,				"""(0,0,0,0,0,1)"""							)


  def  lowerCamelCase       (      self		:			Optional[int]							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 2, 3, 4]							)
         self.assertEqual(len(lowerCamelCase							)       ,				4							)


  def  lowerCamelCase       (      self		:			Tuple							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 2]							)
         _UpperCAmelCase							=    Vector([1, 2, 3, 4, 5]							)
         _UpperCAmelCase							=    Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]							)
         _UpperCAmelCase							=    Vector([1, -1, 1, -1, 2, -3, 4, -5]							)
         self.assertAlmostEqual(x.euclidean_length()       ,				2.236       ,				3							)
         self.assertAlmostEqual(y.euclidean_length()       ,				7.416       ,				3							)
         self.assertEqual(z.euclidean_length()       ,				0							)
         self.assertAlmostEqual(w.euclidean_length()       ,				7.616       ,				3							)


  def  lowerCamelCase       (      self		:			Dict							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 2, 3]							)
         _UpperCAmelCase							=    Vector([1, 1, 1]							)
         self.assertEqual((x + y).component(0							)       ,				2							)
         self.assertEqual((x + y).component(1							)       ,				3							)
         self.assertEqual((x + y).component(2							)       ,				4							)


  def  lowerCamelCase       (      self		:			Dict							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 2, 3]							)
         _UpperCAmelCase							=    Vector([1, 1, 1]							)
         self.assertEqual((x - y).component(0							)       ,				0							)
         self.assertEqual((x - y).component(1							)       ,				1							)
         self.assertEqual((x - y).component(2							)       ,				2							)


  def  lowerCamelCase       (      self		:			int							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 2, 3]							)
         _UpperCAmelCase							=    Vector([2, -1, 4]							)  # for test of dot product
         _UpperCAmelCase							=    Vector([1, -2, -1]							)
         self.assertEqual(str(x * 3.0							)       ,				"""(3.0,6.0,9.0)"""							)
         self.assertEqual((a * b)       ,				0							)


  def  lowerCamelCase       (      self		:			Optional[int]							)						->	None:


         """simple docstring"""
         self.assertEqual(str(zero_vector(10							)							).count("""0"""							)       ,				10							)


  def  lowerCamelCase       (      self		:			Optional[Any]							)						->	None:


         """simple docstring"""
         self.assertEqual(str(unit_basis_vector(3       ,				1							)							)       ,				"""(0,1,0)"""							)


  def  lowerCamelCase       (      self		:			Any							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 2, 3]							)
         _UpperCAmelCase							=    Vector([1, 0, 1]							)
         self.assertEqual(str(axpy(2       ,				lowerCamelCase       ,				lowerCamelCase							)							)       ,				"""(3,4,7)"""							)


  def  lowerCamelCase       (      self		:			Union[str, Any]							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 0, 0, 0, 0, 0]							)
         _UpperCAmelCase							=    x.copy()
         self.assertEqual(str(lowerCamelCase							)       ,				str(lowerCamelCase							)							)


  def  lowerCamelCase       (      self		:			Tuple							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 0, 0]							)
         x.change_component(0       ,				0							)
         x.change_component(1       ,				1							)
         self.assertEqual(str(lowerCamelCase							)       ,				"""(0,1,0)"""							)


  def  lowerCamelCase       (      self		:			Union[str, Any]							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,				3       ,				3							)
         self.assertEqual("""|1,2,3|\n|2,4,5|\n|6,7,8|\n"""       ,				str(lowerCamelCase							)							)


  def  lowerCamelCase       (      self		:			str							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,				3       ,				3							)
         _UpperCAmelCase							=    [[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
         for x in range(a.height()							):
                for y in range(a.width()							):
                       self.assertEqual(minors[x][y]       ,				a.minor(lowerCamelCase       ,				lowerCamelCase							)							)


  def  lowerCamelCase       (      self		:			str							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,				3       ,				3							)
         _UpperCAmelCase							=    [[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
         for x in range(a.height()							):
                for y in range(a.width()							):
                       self.assertEqual(cofactors[x][y]       ,				a.cofactor(lowerCamelCase       ,				lowerCamelCase							)							)


  def  lowerCamelCase       (      self		:			List[str]							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,				3       ,				3							)
         self.assertEqual(-5       ,				a.determinant()							)


  def  lowerCamelCase       (      self		:			List[str]							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]       ,				3       ,				3							)
         _UpperCAmelCase							=    Vector([1, 2, 3]							)
         self.assertEqual("""(14,32,50)"""       ,				str(a * x							)							)
         self.assertEqual("""|2,4,6|\n|8,10,12|\n|14,16,18|\n"""       ,				str(a * 2							)							)


  def  lowerCamelCase       (      self		:			Any							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,				3       ,				3							)
         a.change_component(0       ,				2       ,				5							)
         self.assertEqual("""|1,2,5|\n|2,4,5|\n|6,7,8|\n"""       ,				str(lowerCamelCase							)							)


  def  lowerCamelCase       (      self		:			int							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,				3       ,				3							)
         self.assertEqual(7       ,				a.component(2       ,				1							)       ,				0.01							)


  def  lowerCamelCase       (      self		:			Optional[Any]							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,				3       ,				3							)
         _UpperCAmelCase							=    Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]       ,				3       ,				3							)
         self.assertEqual("""|2,4,10|\n|4,8,10|\n|12,14,18|\n"""       ,				str(a + b							)							)


  def  lowerCamelCase       (      self		:			Tuple							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,				3       ,				3							)
         _UpperCAmelCase							=    Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]       ,				3       ,				3							)
         self.assertEqual("""|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"""       ,				str(a - b							)							)





  def  lowerCamelCase       (      self		:			List[str]							)						->	None:


         """simple docstring"""
         self.assertEqual(
             """|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"""       ,				str(square_zero_matrix(5							)							)       ,				)


if __name__ == "__main__":
  unittest.main()


'''simple docstring'''





import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
							from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor





class 		__SCREAMING_SNAKE_CASE							:







				def __init__(       self     :		str		,					UpperCAmelCase__     :		Optional[Any]		,					UpperCAmelCase__     :		List[str]=13		,					UpperCAmelCase__     :		Any=32		,					UpperCAmelCase__     :		List[str]=3		,					UpperCAmelCase__     :		Any=4		,					UpperCAmelCase__     :		List[str]=[10, 20, 30, 40]		,					UpperCAmelCase__     :		Any=[2, 2, 3, 2]		,					UpperCAmelCase__     :		Optional[Any]=True		,					UpperCAmelCase__     :		Tuple=True		,					UpperCAmelCase__     :		Optional[Any]=37		,					UpperCAmelCase__     :		Union[str, Any]="gelu"		,					UpperCAmelCase__     :		Optional[Any]=10		,					UpperCAmelCase__     :		Any=0.02		,					UpperCAmelCase__     :		Optional[int]=["stage2", "stage3", "stage4"]		,					UpperCAmelCase__     :		Dict=[2, 3, 4]		,					UpperCAmelCase__     :		Optional[int]=None		,					):
										'''simple docstring'''
										lowercase :							List[Any]    		=parent
										lowercase :							Tuple    		=batch_size
										lowercase :							List[str]    		=image_size
										lowercase :							List[Any]    		=num_channels
										lowercase :							Union[str, Any]    		=num_stages
										lowercase :							int    		=hidden_sizes
										lowercase :							Any    		=depths
										lowercase :							Tuple    		=is_training
										lowercase :							str    		=use_labels
										lowercase :							List[Any]    		=intermediate_size
										lowercase :							int    		=hidden_act
										lowercase :							Union[str, Any]    		=num_labels
										lowercase :							Optional[int]    		=initializer_range
										lowercase :							int    		=out_features
										lowercase :							List[str]    		=out_indices
										lowercase :							str    		=scope







				def  lowerCamelCase_	(       self     :		int   ):
										'''simple docstring'''
										lowercase :							str    		=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

										lowercase :							Dict    		=None
										if self.use_labels:
																lowercase :							List[Any]    		=ids_tensor([self.batch_size]		,					self.num_labels   )

										lowercase :							Dict    		=self.get_config()

										return config, pixel_values, labels







				def  lowerCamelCase_	(       self     :		Any   ):
										'''simple docstring'''
										return ConvNextVaConfig(
										    num_channels=self.num_channels		,					hidden_sizes=self.hidden_sizes		,					depths=self.depths		,					num_stages=self.num_stages		,					hidden_act=self.hidden_act		,					is_decoder=UpperCAmelCase__		,					initializer_range=self.initializer_range		,					out_features=self.out_features		,					out_indices=self.out_indices		,					num_labels=self.num_labels		,					)







				def  lowerCamelCase_	(       self     :		List[Any]		,					UpperCAmelCase__     :		Union[str, Any]		,					UpperCAmelCase__     :		Optional[Any]		,					UpperCAmelCase__     :		Optional[Any]   ):
										'''simple docstring'''
										lowercase :							Dict    		=ConvNextVaModel(config=UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							Optional[Any]    		=model(UpperCAmelCase__   )
										# expected last hidden states: B, C, H // 32, W // 32
										self.parent.assertEqual(
										    result.last_hidden_state.shape		,					(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)		,					)







				def  lowerCamelCase_	(       self     :		Any		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		int   ):
										'''simple docstring'''
										lowercase :							Dict    		=ConvNextVaForImageClassification(UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							str    		=model(UpperCAmelCase__		,					labels=UpperCAmelCase__   )
										self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_labels)   )







				def  lowerCamelCase_	(       self     :		Dict		,					UpperCAmelCase__     :		Union[str, Any]		,					UpperCAmelCase__     :		List[Any]		,					UpperCAmelCase__     :		int   ):
										'''simple docstring'''
										lowercase :							Union[str, Any]    		=ConvNextVaBackbone(config=UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							Optional[int]    		=model(UpperCAmelCase__   )

										# verify hidden states
										self.parent.assertEqual(len(result.feature_maps   )		,					len(config.out_features   )   )
										self.parent.assertListEqual(list(result.feature_maps[0].shape   )		,					[self.batch_size, self.hidden_sizes[1], 4, 4]   )

										# verify channels
										self.parent.assertEqual(len(model.channels   )		,					len(config.out_features   )   )
										self.parent.assertListEqual(model.channels		,					config.hidden_sizes[1:]   )

										# verify backbone works with out_features=None
										lowercase :							Optional[Any]    		=None
										lowercase :							str    		=ConvNextVaBackbone(config=UpperCAmelCase__   )
										model.to(UpperCAmelCase__   )
										model.eval()
										lowercase :							Optional[Any]    		=model(UpperCAmelCase__   )

										# verify feature maps
										self.parent.assertEqual(len(result.feature_maps   )		,					1   )
										self.parent.assertListEqual(list(result.feature_maps[0].shape   )		,					[self.batch_size, self.hidden_sizes[-1], 1, 1]   )

										# verify channels
										self.parent.assertEqual(len(model.channels   )		,					1   )
										self.parent.assertListEqual(model.channels		,					[config.hidden_sizes[-1]]   )







				def  lowerCamelCase_	(       self     :		List[Any]   ):
										'''simple docstring'''
										lowercase :							Any    		=self.prepare_config_and_inputs()
										lowercase		,	lowercase		,	lowercase :							str    		=config_and_inputs
										lowercase :							Any    		={'''pixel_values''': pixel_values}
										return config, inputs_dict







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										lowercase :							str    		=self.prepare_config_and_inputs()
										lowercase		,	lowercase		,	lowercase :							List[str]    		=config_and_inputs
										lowercase :							Optional[Any]    		={'''pixel_values''': pixel_values, '''labels''': labels}
										return config, inputs_dict





@require_torch
class 		__SCREAMING_SNAKE_CASE							(			lowercase__						,							lowercase__						,							unittest.TestCase      ):
				lowerCamelCase_		       =    (
				    (
				        ConvNextVaModel,
				        ConvNextVaForImageClassification,
				        ConvNextVaBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				lowerCamelCase_		       =    (
				    {'feature-extraction': ConvNextVaModel, 'image-classification': ConvNextVaForImageClassification}
				    if is_torch_available()
				    else {}
				)

				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False
				lowerCamelCase_		       =    False







				def  lowerCamelCase_	(       self     :		Optional[int]   ):
										'''simple docstring'''
										lowercase :							Dict    		=ConvNextVaModelTester(self   )
										lowercase :							str    		=ConfigTester(self		,					config_class=UpperCAmelCase__		,					has_text_modality=UpperCAmelCase__		,					hidden_size=37   )







				def  lowerCamelCase_	(       self     :		Optional[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  lowerCamelCase_	(       self     :		Any   ):
										'''simple docstring'''
										return







				@unittest.skip(reason='''ConvNextV2 does not use inputs_embeds'''   )
				def  lowerCamelCase_	(       self     :		Optional[int]   ):
										'''simple docstring'''
										pass







				@unittest.skip(reason='''ConvNextV2 does not support input and output embeddings'''   )
				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										pass







				@unittest.skip(reason='''ConvNextV2 does not use feedforward chunking'''   )
				def  lowerCamelCase_	(       self     :		Tuple   ):
										'''simple docstring'''
										pass







				def  lowerCamelCase_	(       self     :		List[Any]   ):
										'''simple docstring'''
										if not self.model_tester.is_training:
																return

										for model_class in self.all_model_classes:
																lowercase		,	lowercase :							Union[str, Any]    		=self.model_tester.prepare_config_and_inputs_with_labels()
																lowercase :							Optional[int]    		=True

																if model_class.__name__ in [
																    *get_values(UpperCAmelCase__   ),
																    *get_values(UpperCAmelCase__   ),
																]:
																						continue

																lowercase :							Dict    		=model_class(UpperCAmelCase__   )
																model.to(UpperCAmelCase__   )
																model.train()
																lowercase :							Optional[Any]    		=self._prepare_for_class(UpperCAmelCase__		,					UpperCAmelCase__		,					return_labels=UpperCAmelCase__   )
																lowercase :							List[Any]    		=model(**UpperCAmelCase__   ).loss
																loss.backward()







				def  lowerCamelCase_	(       self     :		Union[str, Any]   ):
										'''simple docstring'''
										if not self.model_tester.is_training:
																return

										for model_class in self.all_model_classes:
																lowercase		,	lowercase :							Any    		=self.model_tester.prepare_config_and_inputs_with_labels()
																lowercase :							List[Any]    		=False
																lowercase :							Any    		=True

																if (
																    model_class.__name__
																    in [*get_values(UpperCAmelCase__   ), *get_values(UpperCAmelCase__   )]
																    or not model_class.supports_gradient_checkpointing
																):
																						continue

																lowercase :							Any    		=model_class(UpperCAmelCase__   )
																model.to(UpperCAmelCase__   )
																model.gradient_checkpointing_enable()
																model.train()
																lowercase :							Optional[Any]    		=self._prepare_for_class(UpperCAmelCase__		,					UpperCAmelCase__		,					return_labels=UpperCAmelCase__   )
																lowercase :							int    		=model(**UpperCAmelCase__   ).loss
																loss.backward()







				def  lowerCamelCase_	(       self     :		Tuple   ):
										'''simple docstring'''
										lowercase		,	lowercase :							int    		=self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																lowercase :							Dict    		=model_class(UpperCAmelCase__   )
																lowercase :							Union[str, Any]    		=inspect.signature(model.forward   )
																# signature.parameters is an OrderedDict => so arg_names order is deterministic
																lowercase :							int    		=[*signature.parameters.keys()]

																lowercase :							Optional[Any]    		=['''pixel_values''']
																self.assertListEqual(arg_names[:1]		,					UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		Optional[Any]   ):
										'''simple docstring'''
										lowercase :							Tuple    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		int   ):
										'''simple docstring'''
										def check_hidden_states_output(UpperCAmelCase__     :		List[str]		,					UpperCAmelCase__     :		int		,					UpperCAmelCase__     :		Tuple   ):
																lowercase :							int    		=model_class(UpperCAmelCase__   )
																model.to(UpperCAmelCase__   )
																model.eval()

																with torch.no_grad():
																						lowercase :							Any    		=model(**self._prepare_for_class(UpperCAmelCase__		,					UpperCAmelCase__   )   )

																lowercase :							Dict    		=outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																lowercase :							List[Any]    		=self.model_tester.num_stages
																self.assertEqual(len(UpperCAmelCase__   )		,					expected_num_stages + 1   )

																# ConvNextV2's feature maps are of shape (batch_size, num_channels, height, width)
																self.assertListEqual(
																    list(hidden_states[0].shape[-2:]   )		,					[self.model_tester.image_size // 4, self.model_tester.image_size // 4]		,					)

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

										for model_class in self.all_model_classes:
																lowercase :							List[str]    		=True
																check_hidden_states_output(UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__   )

																# check that output_hidden_states also work using config
																del inputs_dict["output_hidden_states"]
																lowercase :							Tuple    		=True

																check_hidden_states_output(UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__   )







				def  lowerCamelCase_	(       self     :		Dict   ):
										'''simple docstring'''
										lowercase :							str    		=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__   )







				@slow
				def  lowerCamelCase_	(       self     :		Optional[int]   ):
										'''simple docstring'''
										for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowercase :							List[Any]    		=ConvNextVaModel.from_pretrained(UpperCAmelCase__   )
																self.assertIsNotNone(UpperCAmelCase__   )






def 				_lowerCAmelCase			(   )				->  List[Any]:
						lowercase :							Union[str, Any]    		=Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
						return image







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







				@cached_property
				def  lowerCamelCase_	(       self     :		List[str]   ):
										'''simple docstring'''
										return AutoImageProcessor.from_pretrained('''facebook/convnextv2-tiny-1k-224'''   ) if is_vision_available() else None







				@slow
				def  lowerCamelCase_	(       self     :		Optional[Any]   ):
										'''simple docstring'''
										lowercase :							Tuple    		=ConvNextVaForImageClassification.from_pretrained('''facebook/convnextv2-tiny-1k-224'''   ).to(UpperCAmelCase__   )

										lowercase :							int    		=self.default_image_processor
										lowercase :							List[str]    		=prepare_img()
										lowercase :							List[Any]    		=preprocessor(images=UpperCAmelCase__		,					return_tensors='''pt'''   ).to(UpperCAmelCase__   )

										# forward pass
										with torch.no_grad():
																lowercase :							Dict    		=model(**UpperCAmelCase__   )

										# verify the logits
										lowercase :							Optional[Any]    		=torch.Size((1, 1000)   )
										self.assertEqual(outputs.logits.shape		,					UpperCAmelCase__   )

										lowercase :							Tuple    		=torch.tensor([0.99_96, 0.19_66, -0.43_86]   ).to(UpperCAmelCase__   )
										self.assertTrue(torch.allclose(outputs.logits[0, :3]		,					UpperCAmelCase__		,					atol=1E-4   )   )





