

"""simple docstring"""





import collections
import inspect
import unittest

from transformers import NatConfig
from transformers.testing_utils import require_natten, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
       import torch
       from torch import nn

       from transformers import NatBackbone, NatForImageClassification, NatModel
       from transformers.models.nat.modeling_nat import NAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
       from PIL import Image

       from transformers import AutoImageProcessor







class        SCREAMING_SNAKE_CASE      :






     """simple docstring"""



     def __init__( self    :       Optional[int]     ,lowercase_    :       str     ,lowercase_    :       List[Any]=1_3     ,lowercase_    :       str=6_4     ,lowercase_    :       Any=4     ,lowercase_    :       str=3     ,lowercase_    :       List[Any]=1_6     ,lowercase_    :       Union[str, Any]=[1, 2, 1]     ,lowercase_    :       Optional[Any]=[2, 4, 8]     ,lowercase_    :       Optional[int]=3     ,lowercase_    :       Tuple=2.0     ,lowercase_    :       int=True     ,lowercase_    :       Union[str, Any]=0.0     ,lowercase_    :       Dict=0.0     ,lowercase_    :       Tuple=0.1     ,lowercase_    :       Any="gelu"     ,lowercase_    :       Optional[int]=True     ,lowercase_    :       int=0.02     ,lowercase_    :       Tuple=1E-5     ,lowercase_    :       List[str]=True     ,lowercase_    :       Dict=None     ,lowercase_    :       Union[str, Any]=True     ,lowercase_    :       Tuple=1_0     ,lowercase_    :       Tuple=["stage1", "stage2"]     ,lowercase_    :       Optional[Any]=[1, 2]     ,):
      lowerCAmelCase__			:		Any						       =			parent
      lowerCAmelCase__			:		Tuple						       =			batch_size
      lowerCAmelCase__			:		Tuple						       =			image_size
      lowerCAmelCase__			:		List[str]						       =			patch_size
      lowerCAmelCase__			:		str						       =			num_channels
      lowerCAmelCase__			:		Optional[Any]						       =			embed_dim
      lowerCAmelCase__			:		Dict						       =			depths
      lowerCAmelCase__			:		List[str]						       =			num_heads
      lowerCAmelCase__			:		List[Any]						       =			kernel_size
      lowerCAmelCase__			:		Tuple						       =			mlp_ratio
      lowerCAmelCase__			:		List[Any]						       =			qkv_bias
      lowerCAmelCase__			:		List[str]						       =			hidden_dropout_prob
      lowerCAmelCase__			:		Tuple						       =			attention_probs_dropout_prob
      lowerCAmelCase__			:		List[Any]						       =			drop_path_rate
      lowerCAmelCase__			:		Union[str, Any]						       =			hidden_act
      lowerCAmelCase__			:		Dict						       =			patch_norm
      lowerCAmelCase__			:		str						       =			layer_norm_eps
      lowerCAmelCase__			:		List[str]						       =			initializer_range
      lowerCAmelCase__			:		Tuple						       =			is_training
      lowerCAmelCase__			:		Union[str, Any]						       =			scope
      lowerCAmelCase__			:		List[str]						       =			use_labels
      lowerCAmelCase__			:		Tuple						       =			num_labels
      lowerCAmelCase__			:		Dict						       =			out_features
      lowerCAmelCase__			:		Tuple						       =			out_indices







     def  __lowerCAmelCase				( self    :       Optional[Any]	):
      lowerCAmelCase__			:		str						       =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

      lowerCAmelCase__			:		Union[str, Any]						       =			None
      if self.use_labels:
       lowerCAmelCase__			:		Union[str, Any]						       =			ids_tensor([self.batch_size]     ,self.num_labels	)

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

      return config, pixel_values, labels







     def  __lowerCAmelCase				( self    :       List[Any]	):
      return NatConfig(
          num_labels=self.num_labels     ,image_size=self.image_size     ,patch_size=self.patch_size     ,num_channels=self.num_channels     ,embed_dim=self.embed_dim     ,depths=self.depths     ,num_heads=self.num_heads     ,kernel_size=self.kernel_size     ,mlp_ratio=self.mlp_ratio     ,qkv_bias=self.qkv_bias     ,hidden_dropout_prob=self.hidden_dropout_prob     ,attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,drop_path_rate=self.drop_path_rate     ,hidden_act=self.hidden_act     ,patch_norm=self.patch_norm     ,layer_norm_eps=self.layer_norm_eps     ,initializer_range=self.initializer_range     ,out_features=self.out_features     ,out_indices=self.out_indices     ,)







     def  __lowerCAmelCase				( self    :       Any     ,lowercase_    :       List[str]     ,lowercase_    :       List[str]     ,lowercase_    :       Any	):
      lowerCAmelCase__			:		List[Any]						       =			NatModel(config=lowercase_	)
      model.to(lowercase_	)
      model.eval()
      lowerCAmelCase__			:		int						       =			model(lowercase_	)

      lowerCAmelCase__			:		Optional[int]						       =			(config.image_size // config.patch_size) // (2 ** (len(config.depths	) - 1))
      lowerCAmelCase__			:		Union[str, Any]						       =			int(config.embed_dim * 2 ** (len(config.depths	) - 1)	)

      self.parent.assertEqual(
          result.last_hidden_state.shape     ,(self.batch_size, expected_height, expected_width, expected_dim)	)







     def  __lowerCAmelCase				( self    :       Any     ,lowercase_    :       List[Any]     ,lowercase_    :       Optional[Any]     ,lowercase_    :       Dict	):
      lowerCAmelCase__			:		Union[str, Any]						       =			NatForImageClassification(lowercase_	)
      model.to(lowercase_	)
      model.eval()
      lowerCAmelCase__			:		Dict						       =			model(lowercase_     ,labels=lowercase_	)
      self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_labels)	)

      # test greyscale images
      lowerCAmelCase__			:		Optional[int]						       =			1
      lowerCAmelCase__			:		Any						       =			NatForImageClassification(lowercase_	)
      model.to(lowercase_	)
      model.eval()

      lowerCAmelCase__			:		Optional[Any]						       =			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
      lowerCAmelCase__			:		int						       =			model(lowercase_	)
      self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_labels)	)







     def  __lowerCAmelCase				( self    :       int     ,lowercase_    :       List[Any]     ,lowercase_    :       Optional[int]     ,lowercase_    :       Dict	):
      lowerCAmelCase__			:		str						       =			NatBackbone(config=lowercase_	)
      model.to(lowercase_	)
      model.eval()
      lowerCAmelCase__			:		Optional[int]						       =			model(lowercase_	)

      # 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, model.channels[0], 1_6, 1_6]	)

      # verify channels
      self.parent.assertEqual(len(model.channels	)     ,len(config.out_features	)	)

      # verify backbone works with out_features=None
      lowerCAmelCase__			:		List[str]						       =			None
      lowerCAmelCase__			:		List[Any]						       =			NatBackbone(config=lowercase_	)
      model.to(lowercase_	)
      model.eval()
      lowerCAmelCase__			:		List[str]						       =			model(lowercase_	)

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

      # verify channels
      self.parent.assertEqual(len(model.channels	)     ,1	)







     def  __lowerCAmelCase				( self    :       str	):
      lowerCAmelCase__			:		int						       =			self.prepare_config_and_inputs()
      lowerCAmelCase__			:		Optional[int]						       =			config_and_inputs
      lowerCAmelCase__			:		str						       =			{'''pixel_values''': pixel_values}
      return config, inputs_dict







@require_natten
@require_torch
class        SCREAMING_SNAKE_CASE      (	a_					,							a_					,							unittest.TestCase ):






     """simple docstring"""



     lowercase__       				= (
         (
             NatModel,
             NatForImageClassification,
             NatBackbone,
         )
         if is_torch_available()
         else ()
     )
     lowercase__       				= (
         {"feature-extraction": NatModel, "image-classification": NatForImageClassification}
         if is_torch_available()
         else {}
     )
     lowercase__       				= False

     lowercase__       				= False
     lowercase__       				= False
     lowercase__       				= False
     lowercase__       				= False







     def  __lowerCAmelCase				( self    :       List[Any]	):
      lowerCAmelCase__			:		Optional[int]						       =			NatModelTester(self	)
      lowerCAmelCase__			:		Union[str, Any]						       =			ConfigTester(self     ,config_class=lowercase_     ,embed_dim=3_7	)







     def  __lowerCAmelCase				( self    :       Dict	):
      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    :       Optional[Any]	):
      return







     def  __lowerCAmelCase				( self    :       List[Any]	):
      lowerCAmelCase__			:		Optional[Any]						       =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowercase_	)







     def  __lowerCAmelCase				( self    :       Tuple	):
      lowerCAmelCase__			:		Dict						       =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowercase_	)







     def  __lowerCAmelCase				( self    :       Union[str, Any]	):
      lowerCAmelCase__			:		str						       =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*lowercase_	)







     @unittest.skip(reason='''Nat does not use inputs_embeds'''	)
     def  __lowerCAmelCase				( self    :       Union[str, Any]	):
      pass







     @unittest.skip(reason='''Nat does not use feedforward chunking'''	)
     def  __lowerCAmelCase				( self    :       Tuple	):
      pass







     def  __lowerCAmelCase				( self    :       Union[str, Any]	):
      lowerCAmelCase__			:		str						       =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       lowerCAmelCase__			:		Tuple						       =			model_class(lowercase_	)
       self.assertIsInstance(model.get_input_embeddings()     ,(nn.Module)	)
       lowerCAmelCase__			:		Dict						       =			model.get_output_embeddings()
       self.assertTrue(x is None or isinstance(lowercase_     ,nn.Linear	)	)







     def  __lowerCAmelCase				( self    :       Dict	):
      lowerCAmelCase__			:		int						       =			self.model_tester.prepare_config_and_inputs_for_common()

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

       lowerCAmelCase__			:		str						       =			['''pixel_values''']
       self.assertListEqual(arg_names[:1]     ,lowercase_	)







     def  __lowerCAmelCase				( self    :       Any	):
      self.skipTest('''Nat\'s attention operation is handled entirely by NATTEN.'''	)







     def  __lowerCAmelCase				( self    :       Optional[int]     ,lowercase_    :       List[str]     ,lowercase_    :       Any     ,lowercase_    :       Optional[int]     ,lowercase_    :       str	):
      lowerCAmelCase__			:		List[Any]						       =			model_class(lowercase_	)
      model.to(lowercase_	)
      model.eval()

      with torch.no_grad():
       lowerCAmelCase__			:		int						       =			model(**self._prepare_for_class(lowercase_     ,lowercase_	)	)

      lowerCAmelCase__			:		Optional[int]						       =			outputs.hidden_states

      lowerCAmelCase__			:		Dict						       =			getattr(
          self.model_tester     ,'''expected_num_hidden_layers'''     ,len(self.model_tester.depths	) + 1	)
      self.assertEqual(len(lowercase_	)     ,lowercase_	)

      # Nat has a different seq_length
      lowerCAmelCase__			:		Optional[Any]						       =			(
          config.patch_size
          if isinstance(config.patch_size     ,collections.abc.Iterable	)
          else (config.patch_size, config.patch_size)
      )

      lowerCAmelCase__			:		Dict						       =			image_size[0] // patch_size[0]
      lowerCAmelCase__			:		List[str]						       =			image_size[1] // patch_size[1]

      self.assertListEqual(
          list(hidden_states[0].shape[-3:]	)     ,[height, width, self.model_tester.embed_dim]     ,)

      if model_class.__name__ != "NatBackbone":
       lowerCAmelCase__			:		Optional[Any]						       =			outputs.reshaped_hidden_states
       self.assertEqual(len(lowercase_	)     ,lowercase_	)

       lowerCAmelCase__			:		Optional[int]						       =			reshaped_hidden_states[0].shape
       lowerCAmelCase__			:		Any						       =			(
           reshaped_hidden_states[0].view(lowercase_     ,lowercase_     ,lowercase_     ,lowercase_	).permute(0     ,2     ,3     ,1	)
       )
       self.assertListEqual(
           list(reshaped_hidden_states.shape[-3:]	)     ,[height, width, self.model_tester.embed_dim]     ,)







     def  __lowerCAmelCase				( self    :       List[Any]	):
      lowerCAmelCase__			:		Tuple						       =			self.model_tester.prepare_config_and_inputs_for_common()

      lowerCAmelCase__			:		Dict						       =			(
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size     ,collections.abc.Iterable	)
          else (self.model_tester.image_size, self.model_tester.image_size)
      )

      for model_class in self.all_model_classes:
       lowerCAmelCase__			:		Tuple						       =			True
       self.check_hidden_states_output(lowercase_     ,lowercase_     ,lowercase_     ,lowercase_	)

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

       self.check_hidden_states_output(lowercase_     ,lowercase_     ,lowercase_     ,lowercase_	)







     @slow
     def  __lowerCAmelCase				( self    :       List[str]	):
      for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       lowerCAmelCase__			:		Union[str, Any]						       =			NatModel.from_pretrained(lowercase_	)
       self.assertIsNotNone(lowercase_	)







     def  __lowerCAmelCase				( self    :       List[str]	):
      lowerCAmelCase__			:		Dict						       =			self.model_tester.prepare_config_and_inputs_for_common()

      lowerCAmelCase__			:		List[Any]						       =			_config_zero_init(lowercase_	)
      for model_class in self.all_model_classes:
       lowerCAmelCase__			:		List[Any]						       =			model_class(config=lowercase_	)
       for name, param in model.named_parameters():
        if "embeddings" not in name and param.requires_grad:
         self.assertIn(
             ((param.data.mean() * 1E9).round() / 1E9).item()     ,[0.0, 1.0]     ,msg=F'Parameter {name} of model {model_class} seems not properly initialized'     ,)







@require_natten
@require_vision
@require_torch
class        SCREAMING_SNAKE_CASE      (	unittest.TestCase ):






     """simple docstring"""



     @cached_property
     def  __lowerCAmelCase				( self    :       int	):
      return AutoImageProcessor.from_pretrained('''shi-labs/nat-mini-in1k-224'''	) if is_vision_available() else None







     @slow
     def  __lowerCAmelCase				( self    :       Optional[int]	):
      lowerCAmelCase__			:		str						       =			NatForImageClassification.from_pretrained('''shi-labs/nat-mini-in1k-224'''	).to(lowercase_	)
      lowerCAmelCase__			:		List[Any]						       =			self.default_image_processor

      lowerCAmelCase__			:		Optional[Any]						       =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
      lowerCAmelCase__			:		Any						       =			image_processor(images=lowercase_     ,return_tensors='''pt'''	).to(lowercase_	)

      # forward pass
      with torch.no_grad():
       lowerCAmelCase__			:		Union[str, Any]						       =			model(**lowercase_	)

      # verify the logits
      lowerCAmelCase__			:		Optional[Any]						       =			torch.Size((1, 1_0_0_0)	)
      self.assertEqual(outputs.logits.shape     ,lowercase_	)
      lowerCAmelCase__			:		Union[str, Any]						       =			torch.tensor([0.3805, -0.8676, -0.3912]	).to(lowercase_	)
      self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,lowercase_     ,atol=1E-4	)	)







@require_torch
@require_natten
class        SCREAMING_SNAKE_CASE      (	unittest.TestCase					,							a_ ):






     """simple docstring"""



     lowercase__       				= (NatBackbone,) if is_torch_available() else ()
     lowercase__       				= NatConfig







     def  __lowerCAmelCase				( self    :       Optional[int]	):
      lowerCAmelCase__			:		List[Any]						       =			NatModelTester(self	)







"""simple docstring"""





import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import SwinaSRImageProcessor
							from transformers.image_transforms import get_image_size







class        SCREAMING_SNAKE_CASE      (	unittest.TestCase ):






					"""simple docstring"""



					def __init__( self    :       Dict     ,lowercase_    :       List[str]     ,lowercase_    :       List[str]=7     ,lowercase_    :       List[Any]=3     ,lowercase_    :       str=1_8     ,lowercase_    :       Any=3_0     ,lowercase_    :       int=4_0_0     ,lowercase_    :       Tuple=True     ,lowercase_    :       Optional[int]=1 / 2_5_5     ,lowercase_    :       int=True     ,lowercase_    :       Union[str, Any]=8     ,):
						lowerCAmelCase__			:		Tuple						       =			parent
						lowerCAmelCase__			:		Optional[Any]						       =			batch_size
						lowerCAmelCase__			:		int						       =			num_channels
						lowerCAmelCase__			:		Union[str, Any]						       =			image_size
						lowerCAmelCase__			:		Optional[Any]						       =			min_resolution
						lowerCAmelCase__			:		Union[str, Any]						       =			max_resolution
						lowerCAmelCase__			:		int						       =			do_rescale
						lowerCAmelCase__			:		Tuple						       =			rescale_factor
						lowerCAmelCase__			:		Dict						       =			do_pad
						lowerCAmelCase__			:		str						       =			pad_size







					def  __lowerCAmelCase				( self    :       int	):
						return {
						    "do_rescale": self.do_rescale,
						    "rescale_factor": self.rescale_factor,
						    "do_pad": self.do_pad,
						    "pad_size": self.pad_size,
						}







					def  __lowerCAmelCase				( self    :       Union[str, Any]     ,lowercase_    :       List[str]=False     ,lowercase_    :       Any=False     ,lowercase_    :       Dict=False	):
						assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

						if equal_resolution:
							lowerCAmelCase__			:		int						       =			[]
							for i in range(self.batch_size	):
								image_inputs.append(
								    np.random.randint(
								        2_5_5     ,size=(self.num_channels, self.max_resolution, self.max_resolution)     ,dtype=np.uinta	)	)
						else:
							lowerCAmelCase__			:		str						       =			[]
							for i in range(self.batch_size	):
								lowerCAmelCase__       ,lowerCAmelCase__			:		Any						       =			np.random.choice(np.arange(self.min_resolution     ,self.max_resolution	)     ,2	)
								image_inputs.append(np.random.randint(2_5_5     ,size=(self.num_channels, width, height)     ,dtype=np.uinta	)	)

						if not numpify and not torchify:
							# PIL expects the channel dimension as last dimension
							lowerCAmelCase__			:		Optional[int]						       =			[Image.fromarray(np.moveaxis(lowercase_     ,0     ,-1	)	) for x in image_inputs]

						if torchify:
							lowerCAmelCase__			:		int						       =			[torch.from_numpy(lowercase_	) for x in image_inputs]

						return image_inputs







@require_torch
@require_vision
class        SCREAMING_SNAKE_CASE      (	a_					,							unittest.TestCase ):






					"""simple docstring"""



					lowercase__       				= SwinaSRImageProcessor if is_vision_available() else None







					def  __lowerCAmelCase				( self    :       Dict	):
						lowerCAmelCase__			:		Dict						       =			SwinaSRImageProcessingTester(self	)







					@property
					def  __lowerCAmelCase				( self    :       str	):
						return self.image_processor_tester.prepare_image_processor_dict()







					def  __lowerCAmelCase				( self    :       List[str]	):
						lowerCAmelCase__			:		Any						       =			self.image_processing_class(**self.image_processor_dict	)
						self.assertTrue(hasattr(lowercase_     ,'''do_rescale'''	)	)
						self.assertTrue(hasattr(lowercase_     ,'''rescale_factor'''	)	)
						self.assertTrue(hasattr(lowercase_     ,'''do_pad'''	)	)
						self.assertTrue(hasattr(lowercase_     ,'''pad_size'''	)	)







					def  __lowerCAmelCase				( self    :       Dict	):
						pass







					def  __lowerCAmelCase				( self    :       List[str]     ,lowercase_    :       Optional[Any]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Tuple						       =			get_image_size(lowercase_	)
						lowerCAmelCase__			:		Dict						       =			self.image_processor_tester.pad_size

						lowerCAmelCase__			:		List[Any]						       =			(old_height // size + 1) * size - old_height
						lowerCAmelCase__			:		Union[str, Any]						       =			(old_width // size + 1) * size - old_width
						return old_height + pad_height, old_width + pad_width







					def  __lowerCAmelCase				( self    :       List[Any]	):
						# Initialize image_processor
						lowerCAmelCase__			:		str						       =			self.image_processing_class(**self.image_processor_dict	)
						# create random PIL images
						lowerCAmelCase__			:		int						       =			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase_	)
						for image in image_inputs:
							self.assertIsInstance(lowercase_     ,Image.Image	)

						# Test not batched input
						lowerCAmelCase__			:		List[str]						       =			image_processor(image_inputs[0]     ,return_tensors='''pt'''	).pixel_values
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[Any]						       =			self.calculate_expected_size(np.array(image_inputs[0]	)	)
						self.assertEqual(
						    encoded_images.shape     ,(
						        1,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )     ,)







					def  __lowerCAmelCase				( self    :       int	):
						# Initialize image_processor
						lowerCAmelCase__			:		str						       =			self.image_processing_class(**self.image_processor_dict	)
						# create random numpy tensors
						lowerCAmelCase__			:		Tuple						       =			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase_     ,numpify=lowercase_	)
						for image in image_inputs:
							self.assertIsInstance(lowercase_     ,np.ndarray	)

						# Test not batched input
						lowerCAmelCase__			:		Optional[Any]						       =			image_processor(image_inputs[0]     ,return_tensors='''pt'''	).pixel_values
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[Any]						       =			self.calculate_expected_size(image_inputs[0]	)
						self.assertEqual(
						    encoded_images.shape     ,(
						        1,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )     ,)







					def  __lowerCAmelCase				( self    :       Dict	):
						# Initialize image_processor
						lowerCAmelCase__			:		Tuple						       =			self.image_processing_class(**self.image_processor_dict	)
						# create random PyTorch tensors
						lowerCAmelCase__			:		Union[str, Any]						       =			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase_     ,torchify=lowercase_	)
						for image in image_inputs:
							self.assertIsInstance(lowercase_     ,torch.Tensor	)

						# Test not batched input
						lowerCAmelCase__			:		Tuple						       =			image_processor(image_inputs[0]     ,return_tensors='''pt'''	).pixel_values
						lowerCAmelCase__       ,lowerCAmelCase__			:		int						       =			self.calculate_expected_size(image_inputs[0]	)
						self.assertEqual(
						    encoded_images.shape     ,(
						        1,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )     ,)




