



import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel

    if is_vision_available():
        from transformers import MaskaFormerImageProcessor

if is_vision_available():
    from PIL import Image



class     lowerCAmelCase_		:
       def __init__(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=2,      SCREAMING_SNAKE_CASE_=True,      SCREAMING_SNAKE_CASE_=False,      SCREAMING_SNAKE_CASE_=10,      SCREAMING_SNAKE_CASE_=3,      SCREAMING_SNAKE_CASE_=32 * 8,      SCREAMING_SNAKE_CASE_=32 * 8,      SCREAMING_SNAKE_CASE_=4,      SCREAMING_SNAKE_CASE_=64,      )					->		List[Any]:
          UpperCamelCase   :  List[Any]						     =     parent
          UpperCamelCase   :  Tuple						     =     batch_size
          UpperCamelCase   :  Tuple						     =     is_training
          UpperCamelCase   :  Optional[int]						     =     use_auxiliary_loss
          UpperCamelCase   :  Optional[int]						     =     num_queries
          UpperCamelCase   :  Any						     =     num_channels
          UpperCamelCase   :  List[Any]						     =     min_size
          UpperCamelCase   :  str						     =     max_size
          UpperCamelCase   :  str						     =     num_labels
          UpperCamelCase   :  Optional[int]						     =     hidden_dim
          UpperCamelCase   :  Tuple						     =     hidden_dim
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  List[Any]						     =     floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]	).to(
              SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Optional[Any]						     =     torch.ones([self.batch_size, self.min_size, self.max_size],      device=SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  str						     =     (
              torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size],      device=SCREAMING_SNAKE_CASE_	) > 0.5
          ).float()
          UpperCamelCase   :  Optional[Any]						     =     (torch.rand((self.batch_size, self.num_labels),      device=SCREAMING_SNAKE_CASE_	) > 0.5).long()

          UpperCamelCase   :  List[Any]						     =     self.get_config()
          return config, pixel_values, pixel_mask, mask_labels, class_labels
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  Optional[int]						     =     MaskaFormerConfig(
              hidden_size=self.hidden_dim,      )
          UpperCamelCase   :  Optional[Any]						     =     self.num_queries
          UpperCamelCase   :  int						     =     self.num_labels

          UpperCamelCase   :  Optional[int]						     =     [1, 1, 1, 1]
          UpperCamelCase   :  Union[str, Any]						     =     self.num_channels

          UpperCamelCase   :  Union[str, Any]						     =     64
          UpperCamelCase   :  List[Any]						     =     128
          UpperCamelCase   :  Union[str, Any]						     =     self.hidden_dim
          UpperCamelCase   :  List[Any]						     =     self.hidden_dim
          UpperCamelCase   :  List[Any]						     =     self.hidden_dim
          return config
       def  snake_case_	(      self	)					->		List[str]:
          UpperCamelCase     ,					UpperCamelCase     ,					UpperCamelCase     ,					UpperCamelCase     ,					UpperCamelCase   :  List[str]						     =     self.prepare_config_and_inputs()
          UpperCamelCase   :  str						     =     {'pixel_values': pixel_values, 'pixel_mask': pixel_mask}
          return config, inputs_dict
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Tuple:
          UpperCamelCase   :  Optional[int]						     =     output.encoder_hidden_states
          UpperCamelCase   :  Optional[Any]						     =     output.pixel_decoder_hidden_states
          UpperCamelCase   :  Tuple						     =     output.transformer_decoder_hidden_states

          self.parent.assertTrue(len(SCREAMING_SNAKE_CASE_	),      len(config.backbone_config.depths	)	)
          self.parent.assertTrue(len(SCREAMING_SNAKE_CASE_	),      len(config.backbone_config.depths	)	)
          self.parent.assertTrue(len(SCREAMING_SNAKE_CASE_	),      config.decoder_layers	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=False	)					->		List[str]:
          with torch.no_grad():
             UpperCamelCase   :  Tuple						     =     MaskaFormerModel(config=SCREAMING_SNAKE_CASE_	)
             model.to(SCREAMING_SNAKE_CASE_	)
             model.eval()

             UpperCamelCase   :  Optional[int]						     =     model(pixel_values=SCREAMING_SNAKE_CASE_,      pixel_mask=SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  Union[str, Any]						     =     model(SCREAMING_SNAKE_CASE_,      output_hidden_states=SCREAMING_SNAKE_CASE_	)

          self.parent.assertEqual(
              output.transformer_decoder_last_hidden_state.shape,      (self.batch_size, self.num_queries, self.hidden_dim),      )
          # let's ensure the other two hidden state exists
          self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None	)
          self.parent.assertTrue(output.encoder_last_hidden_state is not None	)

          if output_hidden_states:
             self.check_output_hidden_state(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)






       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		str:
          UpperCamelCase   :  List[str]						     =     MaskaFormerForUniversalSegmentation(config=SCREAMING_SNAKE_CASE_	)
          model.to(SCREAMING_SNAKE_CASE_	)
          model.eval()

          def comm_check_on_output(SCREAMING_SNAKE_CASE_	):
             # let's still check that all the required stuff is there
             self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None	)
             self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None	)
             self.parent.assertTrue(result.encoder_last_hidden_state is not None	)
             # okay, now we need to check the logits shape
             # due to the encoder compression, masks have a //4 spatial size
             self.parent.assertEqual(
                 result.masks_queries_logits.shape,      (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4),      )
             # + 1 for null class
             self.parent.assertEqual(
                 result.class_queries_logits.shape,      (self.batch_size, self.num_queries, self.num_labels + 1)	)

          with torch.no_grad():
             UpperCamelCase   :  List[Any]						     =     model(pixel_values=SCREAMING_SNAKE_CASE_,      pixel_mask=SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  str						     =     model(SCREAMING_SNAKE_CASE_	)

             comm_check_on_output(SCREAMING_SNAKE_CASE_	)

             UpperCamelCase   :  Optional[int]						     =     model(
                 pixel_values=SCREAMING_SNAKE_CASE_,      pixel_mask=SCREAMING_SNAKE_CASE_,      mask_labels=SCREAMING_SNAKE_CASE_,      class_labels=SCREAMING_SNAKE_CASE_	)

          comm_check_on_output(SCREAMING_SNAKE_CASE_	)

          self.parent.assertTrue(result.loss is not None	)
          self.parent.assertEqual(result.loss.shape,      torch.Size([1]	)	)






@require_torch
class     lowerCAmelCase_		(  a__	,   a__	,   unittest.TestCase							):
       UpperCAmelCase__    : Optional[Any]       					=  (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
       UpperCAmelCase__    : Any       					=  {"feature-extraction": MaskaFormerModel} if is_torch_available() else {}

       UpperCAmelCase__    : Optional[int]       					=  False
       UpperCAmelCase__    : str       					=  False
       UpperCAmelCase__    : Dict       					=  False
       UpperCAmelCase__    : Dict       					=  False
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  List[str]						     =     MaskaFormerModelTester(self	)
          UpperCamelCase   :  Dict						     =     ConfigTester(self,      config_class=SCREAMING_SNAKE_CASE_,      has_text_modality=SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		int:
          self.config_tester.run_common_tests()
       def  snake_case_	(      self	)					->		List[Any]:
          UpperCamelCase     ,					UpperCamelCase   :  List[Any]						     =     self.model_tester.prepare_config_and_inputs_for_common()
          self.model_tester.create_and_check_maskaformer_model(SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_,      output_hidden_states=SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		Dict:
          UpperCamelCase   :  Union[str, Any]						     =     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*SCREAMING_SNAKE_CASE_	)
       @unittest.skip(reason='Mask2Former does not use inputs_embeds'	)
       def  snake_case_	(      self	)					->		Optional[int]:
          pass
       @unittest.skip(reason='Mask2Former does not have a get_input_embeddings method'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip(reason='Mask2Former is not a generative model'	)
       def  snake_case_	(      self	)					->		int:
          pass
       @unittest.skip(reason='Mask2Former does not use token embeddings'	)
       def  snake_case_	(      self	)					->		List[str]:
          pass
       @require_torch_multi_gpu
       @unittest.skip(
           reason='Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'	)
       def  snake_case_	(      self	)					->		List[str]:
          pass
       @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'	)
       def  snake_case_	(      self	)					->		Tuple:
          pass
       def  snake_case_	(      self	)					->		Dict:
          UpperCamelCase     ,					UpperCamelCase   :  Optional[int]						     =     self.model_tester.prepare_config_and_inputs_for_common()

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

             UpperCamelCase   :  List[Any]						     =     ['pixel_values']
             self.assertListEqual(arg_names[:1],      SCREAMING_SNAKE_CASE_	)
       @slow
       def  snake_case_	(      self	)					->		Union[str, Any]:
          for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
             UpperCamelCase   :  int						     =     MaskaFormerModel.from_pretrained(SCREAMING_SNAKE_CASE_	)
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		Dict:
          UpperCamelCase   :  Optional[Any]						     =     (self.model_tester.min_size,) * 2
          UpperCamelCase   :  str						     =     {
              'pixel_values': torch.randn((2, 3, *size),      device=SCREAMING_SNAKE_CASE_	),
              'mask_labels': torch.randn((2, 10, *size),      device=SCREAMING_SNAKE_CASE_	),
              'class_labels': torch.zeros(2,      10,      device=SCREAMING_SNAKE_CASE_	).long(),
          }
          UpperCamelCase   :  List[str]						     =     self.model_tester.get_config()

          UpperCamelCase   :  Optional[int]						     =     MaskaFormerForUniversalSegmentation(SCREAMING_SNAKE_CASE_	).to(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  int						     =     model(**SCREAMING_SNAKE_CASE_	)
          self.assertTrue(outputs.loss is not None	)
       def  snake_case_	(      self	)					->		Tuple:
          UpperCamelCase     ,					UpperCamelCase   :  Optional[Any]						     =     self.model_tester.prepare_config_and_inputs_for_common()
          self.model_tester.create_and_check_maskaformer_model(SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_,      output_hidden_states=SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase     ,					UpperCamelCase   :  Optional[Any]						     =     self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
             UpperCamelCase   :  Tuple						     =     model_class(SCREAMING_SNAKE_CASE_	).to(SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  List[str]						     =     model(**SCREAMING_SNAKE_CASE_,      output_attentions=SCREAMING_SNAKE_CASE_	)
             self.assertTrue(outputs.attentions is not None	)
       def  snake_case_	(      self	)					->		Optional[Any]:
          if not self.model_tester.is_training:
             return

          UpperCamelCase   :  Tuple						     =     self.all_model_classes[1]
          UpperCamelCase     ,					UpperCamelCase     ,					UpperCamelCase     ,					UpperCamelCase     ,					UpperCamelCase   :  List[Any]						     =     self.model_tester.prepare_config_and_inputs()

          UpperCamelCase   :  int						     =     model_class(SCREAMING_SNAKE_CASE_	)
          model.to(SCREAMING_SNAKE_CASE_	)
          model.train()

          UpperCamelCase   :  List[Any]						     =     model(SCREAMING_SNAKE_CASE_,      mask_labels=SCREAMING_SNAKE_CASE_,      class_labels=SCREAMING_SNAKE_CASE_	).loss
          loss.backward()






       def  snake_case_	(      self	)					->		Optional[Any]:
          UpperCamelCase   :  int						     =     self.all_model_classes[1]
          UpperCamelCase     ,					UpperCamelCase     ,					UpperCamelCase     ,					UpperCamelCase     ,					UpperCamelCase   :  int						     =     self.model_tester.prepare_config_and_inputs()
          UpperCamelCase   :  str						     =     True
          UpperCamelCase   :  Union[str, Any]						     =     True

          UpperCamelCase   :  List[Any]						     =     model_class(SCREAMING_SNAKE_CASE_	).to(SCREAMING_SNAKE_CASE_	)
          model.train()

          UpperCamelCase   :  Union[str, Any]						     =     model(SCREAMING_SNAKE_CASE_,      mask_labels=SCREAMING_SNAKE_CASE_,      class_labels=SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  str						     =     outputs.encoder_hidden_states[0]
          encoder_hidden_states.retain_grad()

          UpperCamelCase   :  Union[str, Any]						     =     outputs.pixel_decoder_hidden_states[0]
          pixel_decoder_hidden_states.retain_grad()

          UpperCamelCase   :  Optional[Any]						     =     outputs.transformer_decoder_hidden_states[0]
          transformer_decoder_hidden_states.retain_grad()

          UpperCamelCase   :  Dict						     =     outputs.attentions[0]
          attentions.retain_grad()

          outputs.loss.backward(retain_graph=SCREAMING_SNAKE_CASE_	)

          self.assertIsNotNone(encoder_hidden_states.grad	)
          self.assertIsNotNone(pixel_decoder_hidden_states.grad	)
          self.assertIsNotNone(transformer_decoder_hidden_states.grad	)
          self.assertIsNotNone(attentions.grad	)






__UpperCAmelCase	       =	1e-4
def 		UpperCamelCase     (       )     ->					str:
   UpperCamelCase   :  Union[str, Any]						     =     Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'     )
   return image



@require_vision
@slow
class     lowerCAmelCase_		(  unittest.TestCase							):
       @cached_property
       def  snake_case_	(      self	)					->		List[Any]:
          return "facebook/mask2former-swin-small-coco-instance"
       @cached_property
       def  snake_case_	(      self	)					->		Optional[int]:
          return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints	) if is_vision_available() else None
       def  snake_case_	(      self	)					->		Dict:
          UpperCamelCase   :  str						     =     MaskaFormerModel.from_pretrained(self.model_checkpoints	).to(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Optional[Any]						     =     self.default_image_processor
          UpperCamelCase   :  Any						     =     prepare_img()
          UpperCamelCase   :  Union[str, Any]						     =     image_processor(SCREAMING_SNAKE_CASE_,      return_tensors='pt'	).to(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Tuple						     =     inputs['pixel_values'].shape
          # check size is divisible by 32
          self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0	)
          # check size
          self.assertEqual(SCREAMING_SNAKE_CASE_,      (1, 3, 384, 384)	)

          with torch.no_grad():
             UpperCamelCase   :  Tuple						     =     model(**SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Tuple						     =     torch.tensor(
              [[-0.27_90, -1.07_17, -1.16_68], [-0.51_28, -0.31_28, -0.49_87], [-0.58_32, 0.19_71, -0.01_97]]	).to(SCREAMING_SNAKE_CASE_	)
          self.assertTrue(
              torch.allclose(
                  outputs.encoder_last_hidden_state[0, 0, :3, :3],      SCREAMING_SNAKE_CASE_,      atol=SCREAMING_SNAKE_CASE_	)	)

          UpperCamelCase   :  Tuple						     =     torch.tensor(
              [[0.89_73, 1.18_47, 1.17_76], [1.19_34, 1.50_40, 1.51_28], [1.11_53, 1.44_86, 1.49_51]]	).to(SCREAMING_SNAKE_CASE_	)
          self.assertTrue(
              torch.allclose(
                  outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3],      SCREAMING_SNAKE_CASE_,      atol=SCREAMING_SNAKE_CASE_	)	)

          UpperCamelCase   :  int						     =     torch.tensor(
              [[2.11_52, 1.70_00, -0.86_03], [1.58_08, 1.80_04, -0.93_53], [1.60_43, 1.74_95, -0.59_99]]	).to(SCREAMING_SNAKE_CASE_	)
          self.assertTrue(
              torch.allclose(
                  outputs.transformer_decoder_last_hidden_state[0, :3, :3],      SCREAMING_SNAKE_CASE_,      atol=SCREAMING_SNAKE_CASE_	)	)
       def  snake_case_	(      self	)					->		Optional[Any]:
          UpperCamelCase   :  Optional[int]						     =     MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints	).to(SCREAMING_SNAKE_CASE_	).eval()
          UpperCamelCase   :  List[str]						     =     self.default_image_processor
          UpperCamelCase   :  Any						     =     prepare_img()
          UpperCamelCase   :  List[Any]						     =     image_processor(SCREAMING_SNAKE_CASE_,      return_tensors='pt'	).to(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[Any]						     =     inputs['pixel_values'].shape
          # check size is divisible by 32
          self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0	)
          # check size
          self.assertEqual(SCREAMING_SNAKE_CASE_,      (1, 3, 384, 384)	)

          with torch.no_grad():
             UpperCamelCase   :  str						     =     model(**SCREAMING_SNAKE_CASE_	)
          # masks_queries_logits
          UpperCamelCase   :  Dict						     =     outputs.masks_queries_logits
          self.assertEqual(
              masks_queries_logits.shape,      (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)	)
          UpperCamelCase   :  Any						     =     [
              [-8.78_39, -9.00_56, -8.81_21],
              [-7.41_04, -7.03_13, -6.54_01],
              [-6.61_05, -6.34_27, -6.46_75],
          ]
          UpperCamelCase   :  int						     =     torch.tensor(SCREAMING_SNAKE_CASE_	).to(SCREAMING_SNAKE_CASE_	)
          self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3],      SCREAMING_SNAKE_CASE_,      atol=SCREAMING_SNAKE_CASE_	)	)
          # class_queries_logits
          UpperCamelCase   :  Tuple						     =     outputs.class_queries_logits
          self.assertEqual(class_queries_logits.shape,      (1, model.config.num_queries, model.config.num_labels + 1)	)
          UpperCamelCase   :  Tuple						     =     torch.tensor(
              [
                  [1.83_24, -8.08_35, -4.19_22],
                  [0.84_50, -9.00_50, -3.60_53],
                  [0.30_45, -7.72_93, -3.02_75],
              ]	).to(SCREAMING_SNAKE_CASE_	)
          self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3],      SCREAMING_SNAKE_CASE_,      atol=SCREAMING_SNAKE_CASE_	)	)






       def  snake_case_	(      self	)					->		Any:
          UpperCamelCase   :  Any						     =     MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints	).to(SCREAMING_SNAKE_CASE_	).eval()
          UpperCamelCase   :  Optional[int]						     =     self.default_image_processor

          UpperCamelCase   :  Any						     =     image_processor(
              [np.zeros((3, 800, 1333)	), np.zeros((3, 800, 1333)	)],      segmentation_maps=[np.zeros((384, 384)	).astype(np.floataa	), np.zeros((384, 384)	).astype(np.floataa	)],      return_tensors='pt',      )

          UpperCamelCase   :  Dict						     =     inputs['pixel_values'].to(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  str						     =     [el.to(SCREAMING_SNAKE_CASE_	) for el in inputs['mask_labels']]
          UpperCamelCase   :  Optional[Any]						     =     [el.to(SCREAMING_SNAKE_CASE_	) for el in inputs['class_labels']]

          with torch.no_grad():
             UpperCamelCase   :  Any						     =     model(**SCREAMING_SNAKE_CASE_	)

          self.assertTrue(outputs.loss is not None	)








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, prepare_image_inputs


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import ViTImageProcessor



class     lowerCAmelCase_		(  unittest.TestCase							):
       def __init__(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=13,      SCREAMING_SNAKE_CASE_=3,      SCREAMING_SNAKE_CASE_=224,      SCREAMING_SNAKE_CASE_=30,      SCREAMING_SNAKE_CASE_=400,      SCREAMING_SNAKE_CASE_=True,      SCREAMING_SNAKE_CASE_=None,      SCREAMING_SNAKE_CASE_=True,      SCREAMING_SNAKE_CASE_=[0.5, 0.5, 0.5],      SCREAMING_SNAKE_CASE_=[0.5, 0.5, 0.5],      )					->		List[str]:
          UpperCamelCase   :  Optional[int]						     =     size if size is not None else {'height': 18, 'width': 18}
          UpperCamelCase   :  List[Any]						     =     parent
          UpperCamelCase   :  List[Any]						     =     batch_size
          UpperCamelCase   :  int						     =     num_channels
          UpperCamelCase   :  int						     =     image_size
          UpperCamelCase   :  List[Any]						     =     min_resolution
          UpperCamelCase   :  int						     =     max_resolution
          UpperCamelCase   :  Any						     =     do_resize
          UpperCamelCase   :  Optional[int]						     =     size
          UpperCamelCase   :  List[str]						     =     do_normalize
          UpperCamelCase   :  Optional[Any]						     =     image_mean
          UpperCamelCase   :  Tuple						     =     image_std






       def  snake_case_	(      self	)					->		List[Any]:
          return {
              "image_mean": self.image_mean,
              "image_std": self.image_std,
              "do_normalize": self.do_normalize,
              "do_resize": self.do_resize,
              "size": self.size,
          }






@require_torch
@require_vision
class     lowerCAmelCase_		(  a__	,   unittest.TestCase							):
       UpperCAmelCase__    : Optional[Any]       					=  ViTImageProcessor if is_vision_available() else None
       def  snake_case_	(      self	)					->		Any:
          UpperCamelCase   :  Dict						     =     EfficientFormerImageProcessorTester(self	)
       @property
       def  snake_case_	(      self	)					->		List[Any]:
          return self.image_proc_tester.prepare_image_processor_dict()
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  Optional[int]						     =     self.image_processing_class(**self.image_processor_dict	)
          self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,      'image_mean'	)	)
          self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,      'image_std'	)	)
          self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,      'do_normalize'	)	)
          self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,      'do_resize'	)	)
          self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,      'size'	)	)
       def  snake_case_	(      self	)					->		Any:
          pass
       def  snake_case_	(      self	)					->		int:
          # Initialize image_processor
          UpperCamelCase   :  Union[str, Any]						     =     self.image_processing_class(**self.image_processor_dict	)
          # create random PIL images
          UpperCamelCase   :  List[str]						     =     prepare_image_inputs(self.image_proc_tester,      equal_resolution=SCREAMING_SNAKE_CASE_	)
          for image in image_inputs:
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,      Image.Image	)

          # Test not batched input
          UpperCamelCase   :  str						     =     image_processor(image_inputs[0],      return_tensors='pt'	).pixel_values
          self.assertEqual(
              encoded_images.shape,      (
                  1,
                  self.image_proc_tester.num_channels,
                  self.image_proc_tester.size['height'],
                  self.image_proc_tester.size['width'],
              ),      )

          # Test batched
          UpperCamelCase   :  Optional[Any]						     =     image_processor(SCREAMING_SNAKE_CASE_,      return_tensors='pt'	).pixel_values
          self.assertEqual(
              encoded_images.shape,      (
                  self.image_proc_tester.batch_size,
                  self.image_proc_tester.num_channels,
                  self.image_proc_tester.size['height'],
                  self.image_proc_tester.size['width'],
              ),      )
       def  snake_case_	(      self	)					->		str:
          # Initialize image_processor
          UpperCamelCase   :  List[str]						     =     self.image_processing_class(**self.image_processor_dict	)
          # create random numpy tensors
          UpperCamelCase   :  Union[str, Any]						     =     prepare_image_inputs(self.image_proc_tester,      equal_resolution=SCREAMING_SNAKE_CASE_,      numpify=SCREAMING_SNAKE_CASE_	)
          for image in image_inputs:
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,      np.ndarray	)

          # Test not batched input
          UpperCamelCase   :  Dict						     =     image_processor(image_inputs[0],      return_tensors='pt'	).pixel_values
          self.assertEqual(
              encoded_images.shape,      (
                  1,
                  self.image_proc_tester.num_channels,
                  self.image_proc_tester.size['height'],
                  self.image_proc_tester.size['width'],
              ),      )

          # Test batched
          UpperCamelCase   :  Dict						     =     image_processor(SCREAMING_SNAKE_CASE_,      return_tensors='pt'	).pixel_values
          self.assertEqual(
              encoded_images.shape,      (
                  self.image_proc_tester.batch_size,
                  self.image_proc_tester.num_channels,
                  self.image_proc_tester.size['height'],
                  self.image_proc_tester.size['width'],
              ),      )






       def  snake_case_	(      self	)					->		Tuple:
          # Initialize image_processor
          UpperCamelCase   :  Any						     =     self.image_processing_class(**self.image_processor_dict	)
          # create random PyTorch tensors
          UpperCamelCase   :  int						     =     prepare_image_inputs(self.image_proc_tester,      equal_resolution=SCREAMING_SNAKE_CASE_,      torchify=SCREAMING_SNAKE_CASE_	)
          for image in image_inputs:
             self.assertIsInstance(SCREAMING_SNAKE_CASE_,      torch.Tensor	)

          # Test not batched input
          UpperCamelCase   :  Optional[int]						     =     image_processor(image_inputs[0],      return_tensors='pt'	).pixel_values
          self.assertEqual(
              encoded_images.shape,      (
                  1,
                  self.image_proc_tester.num_channels,
                  self.image_proc_tester.size['height'],
                  self.image_proc_tester.size['width'],
              ),      )

          # Test batched
          UpperCamelCase   :  int						     =     image_processor(SCREAMING_SNAKE_CASE_,      return_tensors='pt'	).pixel_values
          self.assertEqual(
              encoded_images.shape,      (
                  self.image_proc_tester.batch_size,
                  self.image_proc_tester.num_channels,
                  self.image_proc_tester.size['height'],
                  self.image_proc_tester.size['width'],
              ),      )



