

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 						__UpperCamelCase    :




	def __init__(		self	:						Any		,	lowerCAmelCase	:						str		,	lowerCAmelCase	:						Optional[Any]=2		,	lowerCAmelCase	:						int=True		,	lowerCAmelCase	:						Union[str, Any]=False		,	lowerCAmelCase	:						Any=10		,	lowerCAmelCase	:						Optional[int]=3		,	lowerCAmelCase	:						List[Any]=32 * 8		,	lowerCAmelCase	:						str=32 * 8		,	lowerCAmelCase	:						List[Any]=4		,	lowerCAmelCase	:						str=64		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			parent
		UpperCAmelCase_       				=			batch_size
		UpperCAmelCase_       				=			is_training
		UpperCAmelCase_       				=			use_auxiliary_loss
		UpperCAmelCase_       				=			num_queries
		UpperCAmelCase_       				=			num_channels
		UpperCAmelCase_       				=			min_size
		UpperCAmelCase_       				=			max_size
		UpperCAmelCase_       				=			num_labels
		UpperCAmelCase_       				=			hidden_dim
		UpperCAmelCase_       				=			hidden_dim




	def       __A					(		self	:						Any							):


		'''simple docstring'''







		UpperCAmelCase_       				=			floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]							).to(
		    lowerCAmelCase							)

		UpperCAmelCase_       				=			torch.ones([self.batch_size, self.min_size, self.max_size]		,	device=lowerCAmelCase							)

		UpperCAmelCase_       				=			(
		    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]		,	device=lowerCAmelCase							) > 0.5
		).float()
		UpperCAmelCase_       				=			(torch.rand((self.batch_size, self.num_labels)		,	device=lowerCAmelCase							) > 0.5).long()

		UpperCAmelCase_       				=			self.get_config()
		return config, pixel_values, pixel_mask, mask_labels, class_labels




	def       __A					(		self	:						Dict							):


		'''simple docstring'''







		UpperCAmelCase_       				=			MaskaFormerConfig(
		    hidden_size=self.hidden_dim		,	)
		UpperCAmelCase_       				=			self.num_queries
		UpperCAmelCase_       				=			self.num_labels

		UpperCAmelCase_       				=			[1, 1, 1, 1]
		UpperCAmelCase_       				=			self.num_channels

		UpperCAmelCase_       				=			64
		UpperCAmelCase_       				=			128
		UpperCAmelCase_       				=			self.hidden_dim
		UpperCAmelCase_       				=			self.hidden_dim
		UpperCAmelCase_       				=			self.hidden_dim
		return config




	def       __A					(		self	:						Optional[Any]							):


		'''simple docstring'''







		UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_       				=			self.prepare_config_and_inputs()
		UpperCAmelCase_       				=			{"pixel_values": pixel_values, "pixel_mask": pixel_mask}
		return config, inputs_dict




	def       __A					(		self	:						Optional[Any]		,	lowerCAmelCase	:						List[str]		,	lowerCAmelCase	:						Dict							):


		'''simple docstring'''







		UpperCAmelCase_       				=			output.encoder_hidden_states
		UpperCAmelCase_       				=			output.pixel_decoder_hidden_states
		UpperCAmelCase_       				=			output.transformer_decoder_hidden_states

		self.parent.assertTrue(len(lowerCAmelCase							)		,	len(config.backbone_config.depths							)							)
		self.parent.assertTrue(len(lowerCAmelCase							)		,	len(config.backbone_config.depths							)							)
		self.parent.assertTrue(len(lowerCAmelCase							)		,	config.decoder_layers							)




	def       __A					(		self	:						Dict		,	lowerCAmelCase	:						List[str]		,	lowerCAmelCase	:						List[str]		,	lowerCAmelCase	:						Tuple		,	lowerCAmelCase	:						Union[str, Any]=False							):


		'''simple docstring'''







		with torch.no_grad():
			UpperCAmelCase_       				=			MaskaFormerModel(config=lowerCAmelCase							)
			model.to(lowerCAmelCase							)
			model.eval()

			UpperCAmelCase_       				=			model(pixel_values=lowerCAmelCase		,	pixel_mask=lowerCAmelCase							)
			UpperCAmelCase_       				=			model(lowerCAmelCase		,	output_hidden_states=lowerCAmelCase							)

		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(lowerCAmelCase		,	lowerCAmelCase							)




	def       __A					(		self	:						int		,	lowerCAmelCase	:						Optional[Any]		,	lowerCAmelCase	:						Optional[int]		,	lowerCAmelCase	:						Tuple		,	lowerCAmelCase	:						str		,	lowerCAmelCase	:						List[Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			MaskaFormerForUniversalSegmentation(config=lowerCAmelCase							)
		model.to(lowerCAmelCase							)
		model.eval()

		def comm_check_on_output(lowerCAmelCase	:						int							):
			# 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_       				=			model(pixel_values=lowerCAmelCase		,	pixel_mask=lowerCAmelCase							)
			UpperCAmelCase_       				=			model(lowerCAmelCase							)

			comm_check_on_output(lowerCAmelCase							)

			UpperCAmelCase_       				=			model(
			    pixel_values=lowerCAmelCase		,	pixel_mask=lowerCAmelCase		,	mask_labels=lowerCAmelCase		,	class_labels=lowerCAmelCase							)

		comm_check_on_output(lowerCAmelCase							)

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


@require_torch
class 						__UpperCamelCase    (					lowercase     ,     lowercase     ,     unittest.TestCase						):
	SCREAMING_SNAKE_CASE__    				=     (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
	SCREAMING_SNAKE_CASE__    				=     {'feature-extraction': MaskaFormerModel} if is_torch_available() else {}

	SCREAMING_SNAKE_CASE__    				=     False
	SCREAMING_SNAKE_CASE__    				=     False
	SCREAMING_SNAKE_CASE__    				=     False
	SCREAMING_SNAKE_CASE__    				=     False




	def       __A					(		self	:						List[str]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			MaskaFormerModelTester(self							)
		UpperCAmelCase_       				=			ConfigTester(self		,	config_class=lowerCAmelCase		,	has_text_modality=lowerCAmelCase							)




	def       __A					(		self	:						Union[str, Any]							):


		'''simple docstring'''







		self.config_tester.run_common_tests()




	def       __A					(		self	:						str							):


		'''simple docstring'''







		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()
		self.model_tester.create_and_check_maskaformer_model(lowerCAmelCase		,	**lowerCAmelCase		,	output_hidden_states=lowerCAmelCase							)




	def       __A					(		self	:						Tuple							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*lowerCAmelCase							)




	@unittest.skip(reason="Mask2Former does not use inputs_embeds"							)
	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		pass




	@unittest.skip(reason="Mask2Former does not have a get_input_embeddings method"							)
	def       __A					(		self	:						Any							):


		'''simple docstring'''







		pass




	@unittest.skip(reason="Mask2Former is not a generative model"							)
	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		pass




	@unittest.skip(reason="Mask2Former does not use token embeddings"							)
	def       __A					(		self	:						Tuple							):


		'''simple docstring'''







		pass




	@require_torch_multi_gpu
	@unittest.skip(
	    reason="Mask2Former has some layers using `add_module` which doesn't work well with `nn.DataParallel`"							)
	def       __A					(		self	:						str							):


		'''simple docstring'''







		pass




	@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."							)
	def       __A					(		self	:						Dict							):


		'''simple docstring'''







		pass




	def       __A					(		self	:						Any							):


		'''simple docstring'''







		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()

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

			UpperCAmelCase_       				=			["pixel_values"]
			self.assertListEqual(arg_names[:1]		,	lowerCAmelCase							)




	@slow
	def       __A					(		self	:						int							):


		'''simple docstring'''







		for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
			UpperCAmelCase_       				=			MaskaFormerModel.from_pretrained(lowerCAmelCase							)
			self.assertIsNotNone(lowerCAmelCase							)




	def       __A					(		self	:						Any							):


		'''simple docstring'''







		UpperCAmelCase_       				=			(self.model_tester.min_size,) * 2
		UpperCAmelCase_       				=			{
		    "pixel_values": torch.randn((2, 3, *size)		,	device=lowerCAmelCase							),
		    "mask_labels": torch.randn((2, 10, *size)		,	device=lowerCAmelCase							),
		    "class_labels": torch.zeros(2		,	10		,	device=lowerCAmelCase							).long(),
		}
		UpperCAmelCase_       				=			self.model_tester.get_config()

		UpperCAmelCase_       				=			MaskaFormerForUniversalSegmentation(lowerCAmelCase							).to(lowerCAmelCase							)
		UpperCAmelCase_       				=			model(**lowerCAmelCase							)
		self.assertTrue(outputs.loss is not None							)




	def       __A					(		self	:						Any							):


		'''simple docstring'''







		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()
		self.model_tester.create_and_check_maskaformer_model(lowerCAmelCase		,	**lowerCAmelCase		,	output_hidden_states=lowerCAmelCase							)




	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes:
			UpperCAmelCase_       				=			model_class(lowerCAmelCase							).to(lowerCAmelCase							)
			UpperCAmelCase_       				=			model(**lowerCAmelCase		,	output_attentions=lowerCAmelCase							)
			self.assertTrue(outputs.attentions is not None							)




	def       __A					(		self	:						List[str]							):


		'''simple docstring'''







		if not self.model_tester.is_training:
			return

		UpperCAmelCase_       				=			self.all_model_classes[1]
		UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs()

		UpperCAmelCase_       				=			model_class(lowerCAmelCase							)
		model.to(lowerCAmelCase							)
		model.train()

		UpperCAmelCase_       				=			model(lowerCAmelCase		,	mask_labels=lowerCAmelCase		,	class_labels=lowerCAmelCase							).loss
		loss.backward()




	def       __A					(		self	:						Dict							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.all_model_classes[1]
		UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs()
		UpperCAmelCase_       				=			True
		UpperCAmelCase_       				=			True

		UpperCAmelCase_       				=			model_class(lowerCAmelCase							).to(lowerCAmelCase							)
		model.train()

		UpperCAmelCase_       				=			model(lowerCAmelCase		,	mask_labels=lowerCAmelCase		,	class_labels=lowerCAmelCase							)

		UpperCAmelCase_       				=			outputs.encoder_hidden_states[0]
		encoder_hidden_states.retain_grad()

		UpperCAmelCase_       				=			outputs.pixel_decoder_hidden_states[0]
		pixel_decoder_hidden_states.retain_grad()

		UpperCAmelCase_       				=			outputs.transformer_decoder_hidden_states[0]
		transformer_decoder_hidden_states.retain_grad()

		UpperCAmelCase_       				=			outputs.attentions[0]
		attentions.retain_grad()

		outputs.loss.backward(retain_graph=lowerCAmelCase							)

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


_a:    Tuple 							=			1e-4



def       __lowerCAmelCase      (						):
	UpperCAmelCase_       				=			Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
	return image




@require_vision
@slow
class 						__UpperCamelCase    (					unittest.TestCase						):




	@cached_property
	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		return "facebook/mask2former-swin-small-coco-instance"




	@cached_property
	def       __A					(		self	:						Any							):


		'''simple docstring'''







		return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints							) if is_vision_available() else None




	def       __A					(		self	:						Union[str, Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			MaskaFormerModel.from_pretrained(self.model_checkpoints							).to(lowerCAmelCase							)
		UpperCAmelCase_       				=			self.default_image_processor
		UpperCAmelCase_       				=			prepare_img()
		UpperCAmelCase_       				=			image_processor(lowerCAmelCase		,	return_tensors="pt"							).to(lowerCAmelCase							)
		UpperCAmelCase_       				=			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(lowerCAmelCase		,	(1, 3, 384, 384)							)

		with torch.no_grad():
			UpperCAmelCase_       				=			model(**lowerCAmelCase							)

		UpperCAmelCase_       				=			torch.tensor(
		    [[-0.2_790, -1.0_717, -1.1_668], [-0.5_128, -0.3_128, -0.4_987], [-0.5_832, 0.1_971, -0.0_197]]							).to(lowerCAmelCase							)
		self.assertTrue(
		    torch.allclose(
		        outputs.encoder_last_hidden_state[0, 0, :3, :3]		,	lowerCAmelCase		,	atol=lowerCAmelCase							)							)

		UpperCAmelCase_       				=			torch.tensor(
		    [[0.8_973, 1.1_847, 1.1_776], [1.1_934, 1.5_040, 1.5_128], [1.1_153, 1.4_486, 1.4_951]]							).to(lowerCAmelCase							)
		self.assertTrue(
		    torch.allclose(
		        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]		,	lowerCAmelCase		,	atol=lowerCAmelCase							)							)

		UpperCAmelCase_       				=			torch.tensor(
		    [[2.1_152, 1.7_000, -0.8_603], [1.5_808, 1.8_004, -0.9_353], [1.6_043, 1.7_495, -0.5_999]]							).to(lowerCAmelCase							)
		self.assertTrue(
		    torch.allclose(
		        outputs.transformer_decoder_last_hidden_state[0, :3, :3]		,	lowerCAmelCase		,	atol=lowerCAmelCase							)							)




	def       __A					(		self	:						Any							):


		'''simple docstring'''







		UpperCAmelCase_       				=			MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints							).to(lowerCAmelCase							).eval()
		UpperCAmelCase_       				=			self.default_image_processor
		UpperCAmelCase_       				=			prepare_img()
		UpperCAmelCase_       				=			image_processor(lowerCAmelCase		,	return_tensors="pt"							).to(lowerCAmelCase							)
		UpperCAmelCase_       				=			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(lowerCAmelCase		,	(1, 3, 384, 384)							)

		with torch.no_grad():
			UpperCAmelCase_       				=			model(**lowerCAmelCase							)
		# masks_queries_logits
		UpperCAmelCase_       				=			outputs.masks_queries_logits
		self.assertEqual(
		    masks_queries_logits.shape		,	(1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)							)
		UpperCAmelCase_       				=			[
		    [-8.7_839, -9.0_056, -8.8_121],
		    [-7.4_104, -7.0_313, -6.5_401],
		    [-6.6_105, -6.3_427, -6.4_675],
		]
		UpperCAmelCase_       				=			torch.tensor(lowerCAmelCase							).to(lowerCAmelCase							)
		self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]		,	lowerCAmelCase		,	atol=lowerCAmelCase							)							)
		# class_queries_logits
		UpperCAmelCase_       				=			outputs.class_queries_logits
		self.assertEqual(class_queries_logits.shape		,	(1, model.config.num_queries, model.config.num_labels + 1)							)
		UpperCAmelCase_       				=			torch.tensor(
		    [
		        [1.8_324, -8.0_835, -4.1_922],
		        [0.8_450, -9.0_050, -3.6_053],
		        [0.3_045, -7.7_293, -3.0_275],
		    ]							).to(lowerCAmelCase							)
		self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]		,	lowerCAmelCase		,	atol=lowerCAmelCase							)							)




	def       __A					(		self	:						Optional[Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints							).to(lowerCAmelCase							).eval()
		UpperCAmelCase_       				=			self.default_image_processor

		UpperCAmelCase_       				=			image_processor(
		    [np.zeros((3, 800, 1_333)							), np.zeros((3, 800, 1_333)							)]		,	segmentation_maps=[np.zeros((384, 384)							).astype(np.floataa							), np.zeros((384, 384)							).astype(np.floataa							)]		,	return_tensors="pt"		,	)

		UpperCAmelCase_       				=			inputs["pixel_values"].to(lowerCAmelCase							)
		UpperCAmelCase_       				=			[el.to(lowerCAmelCase							) for el in inputs["mask_labels"]]
		UpperCAmelCase_       				=			[el.to(lowerCAmelCase							) for el in inputs["class_labels"]]

		with torch.no_grad():
			UpperCAmelCase_       				=			model(**lowerCAmelCase							)

		self.assertTrue(outputs.loss is not None							)









from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
				import PIL

_a:    Optional[Any] 							=			logging.get_logger(__name__)



def       __lowerCAmelCase      (						A    ):
	if isinstance(A       ,     (list, tuple)    ) and isinstance(videos[0]       ,     (list, tuple)    ) and is_valid_image(videos[0][0]    ):
		return videos

	elif isinstance(A       ,     (list, tuple)    ) and is_valid_image(videos[0]    ):
		return [videos]

	elif is_valid_image(A    ):
		return [[videos]]

	raise ValueError(F"Could not make batched video from {videos}"    )




class 						__UpperCamelCase    (					lowercase						):
	SCREAMING_SNAKE_CASE__    				=     ['pixel_values']




	def __init__(		self	:						int		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						PILImageResampling = PILImageResampling.BILINEAR		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Union[int, float] = 1 / 255		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	**lowerCAmelCase	:						List[Any]		,	):


		'''simple docstring'''







		super().__init__(**lowerCAmelCase							)
		UpperCAmelCase_       				=			size if size is not None else {"shortest_edge": 256}
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	default_to_square=lowerCAmelCase							)
		UpperCAmelCase_       				=			crop_size if crop_size is not None else {"height": 224, "width": 224}
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	param_name="crop_size"							)

		UpperCAmelCase_       				=			do_resize
		UpperCAmelCase_       				=			size
		UpperCAmelCase_       				=			do_center_crop
		UpperCAmelCase_       				=			crop_size
		UpperCAmelCase_       				=			resample
		UpperCAmelCase_       				=			do_rescale
		UpperCAmelCase_       				=			rescale_factor
		UpperCAmelCase_       				=			offset
		UpperCAmelCase_       				=			do_normalize
		UpperCAmelCase_       				=			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
		UpperCAmelCase_       				=			image_std if image_std is not None else IMAGENET_STANDARD_STD




	def       __A					(		self	:						List[Any]		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Dict[str, int]		,	lowerCAmelCase	:						PILImageResampling = PILImageResampling.BILINEAR		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						List[str]		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	default_to_square=lowerCAmelCase							)
		if "shortest_edge" in size:
			UpperCAmelCase_       				=			get_resize_output_image_size(lowerCAmelCase		,	size["shortest_edge"]		,	default_to_square=lowerCAmelCase							)
		elif "height" in size and "width" in size:
			UpperCAmelCase_       				=			(size["height"], size["width"])
		else:
			raise ValueError(F"Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"							)
		return resize(lowerCAmelCase		,	size=lowerCAmelCase		,	resample=lowerCAmelCase		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						List[str]		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Dict[str, int]		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						Dict		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase							)
		if "height" not in size or "width" not in size:
			raise ValueError(F"Size must have 'height' and 'width' as keys. Got {size.keys()}"							)
		return center_crop(lowerCAmelCase		,	size=(size["height"], size["width"])		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						List[Any]		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Union[int, float]		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						List[str]		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			image.astype(np.floataa							)
		if offset:
			UpperCAmelCase_       				=			image - (scale / 2)
		return rescale(lowerCAmelCase		,	scale=lowerCAmelCase		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						Tuple		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Union[float, List[float]]		,	lowerCAmelCase	:						Union[float, List[float]]		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						int		,	):


		'''simple docstring'''







		return normalize(lowerCAmelCase		,	mean=lowerCAmelCase		,	std=lowerCAmelCase		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						Union[str, Any]		,	lowerCAmelCase	:						ImageInput		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						PILImageResampling = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						float = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[ChannelDimension] = ChannelDimension.FIRST		,	):


		'''simple docstring'''







		if do_resize and size is None or resample is None:
			raise ValueError("Size and resample must be specified if do_resize is True."							)

		if do_center_crop and crop_size is None:
			raise ValueError("Crop size must be specified if do_center_crop is True."							)

		if do_rescale and rescale_factor is None:
			raise ValueError("Rescale factor must be specified if do_rescale is True."							)

		if do_normalize and (image_mean is None or image_std is None):
			raise ValueError("Image mean and std must be specified if do_normalize is True."							)

		if offset and not do_rescale:
			raise ValueError("For offset, do_rescale must also be set to True."							)

		# All transformations expect numpy arrays.
		UpperCAmelCase_       				=			to_numpy_array(lowerCAmelCase							)

		if do_resize:
			UpperCAmelCase_       				=			self.resize(image=lowerCAmelCase		,	size=lowerCAmelCase		,	resample=lowerCAmelCase							)

		if do_center_crop:
			UpperCAmelCase_       				=			self.center_crop(lowerCAmelCase		,	size=lowerCAmelCase							)

		if do_rescale:
			UpperCAmelCase_       				=			self.rescale(image=lowerCAmelCase		,	scale=lowerCAmelCase		,	offset=lowerCAmelCase							)

		if do_normalize:
			UpperCAmelCase_       				=			self.normalize(image=lowerCAmelCase		,	mean=lowerCAmelCase		,	std=lowerCAmelCase							)

		UpperCAmelCase_       				=			to_channel_dimension_format(lowerCAmelCase		,	lowerCAmelCase							)
		return image




	def       __A					(		self	:						Optional[int]		,	lowerCAmelCase	:						ImageInput		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						PILImageResampling = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						float = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[str, TensorType]] = None		,	lowerCAmelCase	:						ChannelDimension = ChannelDimension.FIRST		,	**lowerCAmelCase	:						Dict		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			do_resize if do_resize is not None else self.do_resize
		UpperCAmelCase_       				=			resample if resample is not None else self.resample
		UpperCAmelCase_       				=			do_center_crop if do_center_crop is not None else self.do_center_crop
		UpperCAmelCase_       				=			do_rescale if do_rescale is not None else self.do_rescale
		UpperCAmelCase_       				=			rescale_factor if rescale_factor is not None else self.rescale_factor
		UpperCAmelCase_       				=			offset if offset is not None else self.offset
		UpperCAmelCase_       				=			do_normalize if do_normalize is not None else self.do_normalize
		UpperCAmelCase_       				=			image_mean if image_mean is not None else self.image_mean
		UpperCAmelCase_       				=			image_std if image_std is not None else self.image_std

		UpperCAmelCase_       				=			size if size is not None else self.size
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	default_to_square=lowerCAmelCase							)
		UpperCAmelCase_       				=			crop_size if crop_size is not None else self.crop_size
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	param_name="crop_size"							)

		if not valid_images(lowerCAmelCase							):
			raise ValueError(
			    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
			    "torch.Tensor, tf.Tensor or jax.ndarray."							)

		UpperCAmelCase_       				=			make_batched(lowerCAmelCase							)

		UpperCAmelCase_       				=			[
		    [
		        self._preprocess_image(
		            image=lowerCAmelCase		,	do_resize=lowerCAmelCase		,	size=lowerCAmelCase		,	resample=lowerCAmelCase		,	do_center_crop=lowerCAmelCase		,	crop_size=lowerCAmelCase		,	do_rescale=lowerCAmelCase		,	rescale_factor=lowerCAmelCase		,	offset=lowerCAmelCase		,	do_normalize=lowerCAmelCase		,	image_mean=lowerCAmelCase		,	image_std=lowerCAmelCase		,	data_format=lowerCAmelCase		,	)
		        for img in video
		    ]
		    for video in videos
		]

		UpperCAmelCase_       				=			{"pixel_values": videos}
		return BatchFeature(data=lowerCAmelCase		,	tensor_type=lowerCAmelCase							)