



"""simple docstring"""
import argparse
import json
from collections import OrderedDict
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
__SCREAMING_SNAKE_CASE     :  str										=					logging.get_logger(__name__)

# here we list all keys to be renamed (original name on the left, our name on the right)
__SCREAMING_SNAKE_CASE     :  List[str]										=					[]
for i in range(6):
			# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
			rename_keys.append(
			    (F"""transformer.encoder.layers.{i}.self_attn.out_proj.weight""", F"""encoder.layers.{i}.self_attn.out_proj.weight""")
			)
			rename_keys.append(
			    (F"""transformer.encoder.layers.{i}.self_attn.out_proj.bias""", F"""encoder.layers.{i}.self_attn.out_proj.bias""")
			)
			rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.weight""", F"""encoder.layers.{i}.fc1.weight"""))
			rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.bias""", F"""encoder.layers.{i}.fc1.bias"""))
			rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.weight""", F"""encoder.layers.{i}.fc2.weight"""))
			rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.bias""", F"""encoder.layers.{i}.fc2.bias"""))
			rename_keys.append(
			    (F"""transformer.encoder.layers.{i}.norm1.weight""", F"""encoder.layers.{i}.self_attn_layer_norm.weight""")
			)
			rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.bias""", F"""encoder.layers.{i}.self_attn_layer_norm.bias"""))
			rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.weight""", F"""encoder.layers.{i}.final_layer_norm.weight"""))
			rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.bias""", F"""encoder.layers.{i}.final_layer_norm.bias"""))
			# decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
			rename_keys.append(
			    (F"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", F"""decoder.layers.{i}.self_attn.out_proj.weight""")
			)
			rename_keys.append(
			    (F"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", F"""decoder.layers.{i}.self_attn.out_proj.bias""")
			)
			rename_keys.append(
			    (
			        F"""transformer.decoder.layers.{i}.multihead_attn.out_proj.weight""",
			        F"""decoder.layers.{i}.encoder_attn.out_proj.weight""",
			    )
			)
			rename_keys.append(
			    (
			        F"""transformer.decoder.layers.{i}.multihead_attn.out_proj.bias""",
			        F"""decoder.layers.{i}.encoder_attn.out_proj.bias""",
			    )
			)
			rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.weight""", F"""decoder.layers.{i}.fc1.weight"""))
			rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.bias""", F"""decoder.layers.{i}.fc1.bias"""))
			rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.weight""", F"""decoder.layers.{i}.fc2.weight"""))
			rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.bias""", F"""decoder.layers.{i}.fc2.bias"""))
			rename_keys.append(
			    (F"""transformer.decoder.layers.{i}.norm1.weight""", F"""decoder.layers.{i}.self_attn_layer_norm.weight""")
			)
			rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.bias""", F"""decoder.layers.{i}.self_attn_layer_norm.bias"""))
			rename_keys.append(
			    (F"""transformer.decoder.layers.{i}.norm2.weight""", F"""decoder.layers.{i}.encoder_attn_layer_norm.weight""")
			)
			rename_keys.append(
			    (F"""transformer.decoder.layers.{i}.norm2.bias""", F"""decoder.layers.{i}.encoder_attn_layer_norm.bias""")
			)
			rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.weight""", F"""decoder.layers.{i}.final_layer_norm.weight"""))
			rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.bias""", F"""decoder.layers.{i}.final_layer_norm.bias"""))

# convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
rename_keys.extend(
    [
        ('''input_proj.weight''', '''input_projection.weight'''),
        ('''input_proj.bias''', '''input_projection.bias'''),
        ('''query_embed.weight''', '''query_position_embeddings.weight'''),
        ('''transformer.decoder.norm.weight''', '''decoder.layernorm.weight'''),
        ('''transformer.decoder.norm.bias''', '''decoder.layernorm.bias'''),
        ('''class_embed.weight''', '''class_labels_classifier.weight'''),
        ('''class_embed.bias''', '''class_labels_classifier.bias'''),
        ('''bbox_embed.layers.0.weight''', '''bbox_predictor.layers.0.weight'''),
        ('''bbox_embed.layers.0.bias''', '''bbox_predictor.layers.0.bias'''),
        ('''bbox_embed.layers.1.weight''', '''bbox_predictor.layers.1.weight'''),
        ('''bbox_embed.layers.1.bias''', '''bbox_predictor.layers.1.bias'''),
        ('''bbox_embed.layers.2.weight''', '''bbox_predictor.layers.2.weight'''),
        ('''bbox_embed.layers.2.bias''', '''bbox_predictor.layers.2.bias'''),
    ]
)



def 				lowerCAmelCase_(      lowercase_   :							List[Any]  ,      lowercase_   :							List[Any]  ,      lowercase_   :							Any							)		->				Dict:
				_lowerCamelCase					     = state_dict.pop(lowercase_							)
				_lowerCamelCase					     = val



def 				lowerCAmelCase_(      lowercase_   :							Tuple							)		->				Optional[int]:
				_lowerCamelCase					     = OrderedDict()
				for key, value in state_dict.items():
								if "backbone.0.body" in key:
												_lowerCamelCase					     = key.replace('''backbone.0.body'''  ,      '''backbone.conv_encoder.model'''							)
												_lowerCamelCase					     = value
								else:
												_lowerCamelCase					     = value

				return new_state_dict



def 				lowerCAmelCase_(      lowercase_   :							List[str]  ,      lowercase_   :							Union[str, Any]=False							)		->				int:
				_lowerCamelCase					     = ''''''
				if is_panoptic:
								_lowerCamelCase					     = '''detr.'''

				# first: transformer encoder
				for i in range(6							):
								# read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
								_lowerCamelCase					     = state_dict.pop(F"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight"""							)
								_lowerCamelCase					     = state_dict.pop(F"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias"""							)
								# next, add query, keys and values (in that order) to the state dict
								_lowerCamelCase					     = in_proj_weight[:2_56, :]
								_lowerCamelCase					     = in_proj_bias[:2_56]
								_lowerCamelCase					     = in_proj_weight[2_56:5_12, :]
								_lowerCamelCase					     = in_proj_bias[2_56:5_12]
								_lowerCamelCase					     = in_proj_weight[-2_56:, :]
								_lowerCamelCase					     = in_proj_bias[-2_56:]
				# next: transformer decoder (which is a bit more complex because it also includes cross-attention)
				for i in range(6							):
								# read in weights + bias of input projection layer of self-attention
								_lowerCamelCase					     = state_dict.pop(F"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight"""							)
								_lowerCamelCase					     = state_dict.pop(F"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias"""							)
								# next, add query, keys and values (in that order) to the state dict
								_lowerCamelCase					     = in_proj_weight[:2_56, :]
								_lowerCamelCase					     = in_proj_bias[:2_56]
								_lowerCamelCase					     = in_proj_weight[2_56:5_12, :]
								_lowerCamelCase					     = in_proj_bias[2_56:5_12]
								_lowerCamelCase					     = in_proj_weight[-2_56:, :]
								_lowerCamelCase					     = in_proj_bias[-2_56:]
								# read in weights + bias of input projection layer of cross-attention
								_lowerCamelCase					     = state_dict.pop(
								    F"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight"""							)
								_lowerCamelCase					     = state_dict.pop(F"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias"""							)
								# next, add query, keys and values (in that order) of cross-attention to the state dict
								_lowerCamelCase					     = in_proj_weight_cross_attn[:2_56, :]
								_lowerCamelCase					     = in_proj_bias_cross_attn[:2_56]
								_lowerCamelCase					     = in_proj_weight_cross_attn[2_56:5_12, :]
								_lowerCamelCase					     = in_proj_bias_cross_attn[2_56:5_12]
								_lowerCamelCase					     = in_proj_weight_cross_attn[-2_56:, :]
								_lowerCamelCase					     = in_proj_bias_cross_attn[-2_56:]



def 				lowerCAmelCase_(      )		->				List[Any]:
				_lowerCamelCase					     = '''http://images.cocodataset.org/val2017/000000039769.jpg'''
				_lowerCamelCase					     = Image.open(requests.get(lowercase_  ,      stream=lowercase_							).raw							)

				return im



@torch.no_grad()
def 				lowerCAmelCase_(      lowercase_   :							Optional[int]  ,      lowercase_   :							Any							)		->				Any:
				_lowerCamelCase					     = DetrConfig()
				# set backbone and dilation attributes
				if "resnet101" in model_name:
								_lowerCamelCase					     = '''resnet101'''
				if "dc5" in model_name:
								_lowerCamelCase					     = True
				_lowerCamelCase					     = '''panoptic''' in model_name
				if is_panoptic:
								_lowerCamelCase					     = 2_50
				else:
								_lowerCamelCase					     = 91
								_lowerCamelCase					     = '''huggingface/label-files'''
								_lowerCamelCase					     = '''coco-detection-id2label.json'''
								_lowerCamelCase					     = json.load(open(hf_hub_download(lowercase_  ,      lowercase_  ,      repo_type='''dataset'''							)  ,      '''r'''							)							)
								_lowerCamelCase					     = {int(lowercase_							): v for k, v in idalabel.items()}
								_lowerCamelCase					     = idalabel
								_lowerCamelCase					     = {v: k for k, v in idalabel.items()}

				# load image processor
				_lowerCamelCase					     = '''coco_panoptic''' if is_panoptic else '''coco_detection'''
				_lowerCamelCase					     = DetrImageProcessor(format=lowercase_							)

				# prepare image
				_lowerCamelCase					     = prepare_img()
				_lowerCamelCase					     = image_processor(images=lowercase_  ,      return_tensors='''pt'''							)
				_lowerCamelCase					     = encoding['''pixel_values''']

				logger.info(F"""Converting model {model_name}..."""							)

				# load original model from torch hub
				_lowerCamelCase					     = torch.hub.load('''facebookresearch/detr'''  ,      lowercase_  ,      pretrained=lowercase_							).eval()
				_lowerCamelCase					     = detr.state_dict()
				# rename keys
				for src, dest in rename_keys:
								if is_panoptic:
												_lowerCamelCase					     = '''detr.''' + src
								rename_key(lowercase_  ,      lowercase_  ,      lowercase_							)
				_lowerCamelCase					     = rename_backbone_keys(lowercase_							)
				# query, key and value matrices need special treatment
				read_in_q_k_v(lowercase_  ,      is_panoptic=lowercase_							)
				# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
				_lowerCamelCase					     = '''detr.model.''' if is_panoptic else '''model.'''
				for key in state_dict.copy().keys():
								if is_panoptic:
												if (
												    key.startswith('''detr'''							)
												    and not key.startswith('''class_labels_classifier'''							)
												    and not key.startswith('''bbox_predictor'''							)
												):
																_lowerCamelCase					     = state_dict.pop(lowercase_							)
																_lowerCamelCase					     = val
												elif "class_labels_classifier" in key or "bbox_predictor" in key:
																_lowerCamelCase					     = state_dict.pop(lowercase_							)
																_lowerCamelCase					     = val
												elif key.startswith('''bbox_attention'''							) or key.startswith('''mask_head'''							):
																continue
												else:
																_lowerCamelCase					     = state_dict.pop(lowercase_							)
																_lowerCamelCase					     = val
								else:
												if not key.startswith('''class_labels_classifier'''							) and not key.startswith('''bbox_predictor'''							):
																_lowerCamelCase					     = state_dict.pop(lowercase_							)
																_lowerCamelCase					     = val
    # finally, create HuggingFace model and load state dict
				_lowerCamelCase					     = DetrForSegmentation(lowercase_							) if is_panoptic else DetrForObjectDetection(lowercase_							)
				model.load_state_dict(lowercase_							)
				model.eval()
				# verify our conversion
				_lowerCamelCase					     = detr(lowercase_							)
				_lowerCamelCase					     = model(lowercase_							)
				assert torch.allclose(outputs.logits  ,      original_outputs['''pred_logits''']  ,      atol=1e-4							)
				assert torch.allclose(outputs.pred_boxes  ,      original_outputs['''pred_boxes''']  ,      atol=1e-4							)
				if is_panoptic:
								assert torch.allclose(outputs.pred_masks  ,      original_outputs['''pred_masks''']  ,      atol=1e-4							)

				# Save model and image processor
				logger.info(F"""Saving PyTorch model and image processor to {pytorch_dump_folder_path}..."""							)
				Path(lowercase_							).mkdir(exist_ok=lowercase_							)
				model.save_pretrained(lowercase_							)
				image_processor.save_pretrained(lowercase_							)


if __name__ == "__main__":
			__SCREAMING_SNAKE_CASE     :  List[Any]										=					argparse.ArgumentParser()

			parser.add_argument(
			    '''--model_name''', default='''detr_resnet50''', type=str, help='''Name of the DETR model you\'d like to convert.'''
			)
			parser.add_argument(
			    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the folder to output PyTorch model.'''
			)
			__SCREAMING_SNAKE_CASE     :  Any										=					parser.parse_args()
			convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path)





"""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 BlipImageProcessor


class 							lowerCamelCase_(      unittest.TestCase			):





					'''simple docstring'''



					def __init__(			self ,				lowerCamelCase__ ,				lowerCamelCase__=7 ,				lowerCamelCase__=3 ,				lowerCamelCase__=1_8 ,				lowerCamelCase__=3_0 ,				lowerCamelCase__=4_0_0 ,				lowerCamelCase__=True ,				lowerCamelCase__=None ,				lowerCamelCase__=True ,				lowerCamelCase__=False ,				lowerCamelCase__=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3] ,				lowerCamelCase__=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1] ,				lowerCamelCase__=True ,				):
									_lowerCamelCase					     = size if size is not None else {'''height''': 2_0, '''width''': 2_0}
									_lowerCamelCase					     = parent
									_lowerCamelCase					     = batch_size
									_lowerCamelCase					     = num_channels
									_lowerCamelCase					     = image_size
									_lowerCamelCase					     = min_resolution
									_lowerCamelCase					     = max_resolution
									_lowerCamelCase					     = do_resize
									_lowerCamelCase					     = size
									_lowerCamelCase					     = do_normalize
									_lowerCamelCase					     = image_mean
									_lowerCamelCase					     = image_std
									_lowerCamelCase					     = do_pad
									_lowerCamelCase					     = do_convert_rgb

					def 	snake_case__					(			self      ):
									return {
									    "do_resize": self.do_resize,
									    "size": self.size,
									    "do_normalize": self.do_normalize,
									    "image_mean": self.image_mean,
									    "image_std": self.image_std,
									    "do_convert_rgb": self.do_convert_rgb,
									    "do_pad": self.do_pad,
									}





					def 	snake_case__					(			self ,				lowerCamelCase__=False ,				lowerCamelCase__=False ,				lowerCamelCase__=False      ):
									assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

									if equal_resolution:
													_lowerCamelCase					     = []
													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					     = []
													for i in range(self.batch_size      ):
																	_lowerCamelCase     ,   _lowerCamelCase					     = 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					     = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,				0 ,				-1      )      ) for x in image_inputs]

									if torchify:
													_lowerCamelCase					     = [torch.from_numpy(lowerCamelCase__      ) for x in image_inputs]

									return image_inputs


@require_torch
@require_vision
class 							lowerCamelCase_(      A__, unittest.TestCase			):





					'''simple docstring'''



					lowercase__      :				Any        =       BlipImageProcessor if is_vision_available() else None

					def 	snake_case__					(			self      ):
									_lowerCamelCase					     = BlipImageProcessingTester(self      )

					@property
					def 	snake_case__					(			self      ):
									return self.image_processor_tester.prepare_image_processor_dict()

					def 	snake_case__					(			self      ):
									_lowerCamelCase					     = self.image_processing_class(**self.image_processor_dict      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''do_resize'''      )      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''size'''      )      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''do_normalize'''      )      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''image_mean'''      )      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''image_std'''      )      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''do_convert_rgb'''      )      )

					def 	snake_case__					(			self      ):
									pass

					def 	snake_case__					(			self      ):
									# Initialize image_processor
									_lowerCamelCase					     = self.image_processing_class(**self.image_processor_dict      )
									# create random PIL images
									_lowerCamelCase					     = self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__      )
									for image in image_inputs:
													self.assertIsInstance(lowerCamelCase__ ,				Image.Image      )

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

									# Test batched
									_lowerCamelCase					     = image_processor(lowerCamelCase__ ,				return_tensors='''pt'''      ).pixel_values
									self.assertEqual(
									    encoded_images.shape ,				(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    ) ,				)

					def 	snake_case__					(			self      ):
									# Initialize image_processor
									_lowerCamelCase					     = self.image_processing_class(**self.image_processor_dict      )
									# create random numpy tensors
									_lowerCamelCase					     = self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__ ,				numpify=lowerCamelCase__      )
									for image in image_inputs:
													self.assertIsInstance(lowerCamelCase__ ,				np.ndarray      )

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

									# Test batched
									_lowerCamelCase					     = image_processor(lowerCamelCase__ ,				return_tensors='''pt'''      ).pixel_values
									self.assertEqual(
									    encoded_images.shape ,				(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    ) ,				)





					def 	snake_case__					(			self      ):
									# Initialize image_processor
									_lowerCamelCase					     = self.image_processing_class(**self.image_processor_dict      )
									# create random PyTorch tensors
									_lowerCamelCase					     = self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__ ,				torchify=lowerCamelCase__      )
									for image in image_inputs:
													self.assertIsInstance(lowerCamelCase__ ,				torch.Tensor      )

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

									# Test batched
									_lowerCamelCase					     = image_processor(lowerCamelCase__ ,				return_tensors='''pt'''      ).pixel_values
									self.assertEqual(
									    encoded_images.shape ,				(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    ) ,				)


@require_torch
@require_vision
class 							lowerCamelCase_(      A__, unittest.TestCase			):





					'''simple docstring'''



					lowercase__      :				Tuple        =       BlipImageProcessor if is_vision_available() else None

					def 	snake_case__					(			self      ):
									_lowerCamelCase					     = BlipImageProcessingTester(self ,				num_channels=4      )
									_lowerCamelCase					     = 3

					@property
					def 	snake_case__					(			self      ):
									return self.image_processor_tester.prepare_image_processor_dict()

					def 	snake_case__					(			self      ):
									_lowerCamelCase					     = self.image_processing_class(**self.image_processor_dict      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''do_resize'''      )      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''size'''      )      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''do_normalize'''      )      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''image_mean'''      )      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''image_std'''      )      )
									self.assertTrue(hasattr(lowerCamelCase__ ,				'''do_convert_rgb'''      )      )

					def 	snake_case__					(			self      ):
									pass





					def 	snake_case__					(			self      ):
									# Initialize image_processor
									_lowerCamelCase					     = self.image_processing_class(**self.image_processor_dict      )
									# create random PIL images
									_lowerCamelCase					     = self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__      )
									for image in image_inputs:
													self.assertIsInstance(lowerCamelCase__ ,				Image.Image      )

									# Test not batched input
									_lowerCamelCase					     = image_processor(image_inputs[0] ,				return_tensors='''pt'''      ).pixel_values
									self.assertEqual(
									    encoded_images.shape ,				(
									        1,
									        self.expected_encoded_image_num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    ) ,				)

									# Test batched
									_lowerCamelCase					     = image_processor(lowerCamelCase__ ,				return_tensors='''pt'''      ).pixel_values
									self.assertEqual(
									    encoded_images.shape ,				(
									        self.image_processor_tester.batch_size,
									        self.expected_encoded_image_num_channels,
									        self.image_processor_tester.size['''height'''],
									        self.image_processor_tester.size['''width'''],
									    ) ,				)
