



"""simple docstring"""

import tempfile
import unittest

import numpy as np

from diffusers import (
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionPipeline,
    PNDMScheduler,
)
from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
				import onnxruntime as ort







class    __lowercase     (					_UpperCAmelCase					,    unittest.TestCase):







						"""simple docstring"""







						_A		:							List[str]							       =		"""hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"""







						def 						__UpperCamelCase							(self   ,		lowercase__=0       ):
											snake_case_					:		List[str] 					=					np.random.RandomState(lowercase__       )
											snake_case_					:		List[str] 					=					{
											    """prompt""": """A painting of a squirrel eating a burger""",
											    """generator""": generator,
											    """num_inference_steps""": 2,
											    """guidance_scale""": 7.5,
											    """output_type""": """numpy""",
											}
											return inputs







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Dict 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Optional[Any] 					=					self.get_dummy_inputs()
											snake_case_					:		Dict 					=					pipe(**lowercase__       ).images
											snake_case_					:		Tuple 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		Union[str, Any] 					=					np.array([0.65072, 0.58492, 0.48219, 0.55521, 0.53180, 0.55939, 0.50697, 0.39800, 0.46455]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											snake_case_					:		Union[str, Any] 					=					PNDMScheduler.from_config(pipe.scheduler.config   ,		skip_prk_steps=lowercase__       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Optional[Any] 					=					self.get_dummy_inputs()
											snake_case_					:		str 					=					pipe(**lowercase__       ).images
											snake_case_					:		Optional[int] 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		Tuple 					=					np.array([0.65863, 0.59425, 0.49326, 0.56313, 0.53875, 0.56627, 0.51065, 0.39777, 0.46330]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											snake_case_					:		Any 					=					LMSDiscreteScheduler.from_config(pipe.scheduler.config       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		int 					=					self.get_dummy_inputs()
											snake_case_					:		Any 					=					pipe(**lowercase__       ).images
											snake_case_					:		List[str] 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		Dict 					=					np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		List[Any] 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											snake_case_					:		Optional[int] 					=					EulerDiscreteScheduler.from_config(pipe.scheduler.config       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Optional[Any] 					=					self.get_dummy_inputs()
											snake_case_					:		Optional[Any] 					=					pipe(**lowercase__       ).images
											snake_case_					:		Dict 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		Tuple 					=					np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		int 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											snake_case_					:		Optional[int] 					=					EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Union[str, Any] 					=					self.get_dummy_inputs()
											snake_case_					:		Optional[Any] 					=					pipe(**lowercase__       ).images
											snake_case_					:		Dict 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		str 					=					np.array([0.53817, 0.60812, 0.47384, 0.49530, 0.51894, 0.49814, 0.47984, 0.38958, 0.44271]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Any 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											snake_case_					:		Union[str, Any] 					=					DPMSolverMultistepScheduler.from_config(pipe.scheduler.config       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		int 					=					self.get_dummy_inputs()
											snake_case_					:		Optional[int] 					=					pipe(**lowercase__       ).images
											snake_case_					:		List[Any] 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		Tuple 					=					np.array([0.53895, 0.60808, 0.47933, 0.49608, 0.51886, 0.49950, 0.48053, 0.38957, 0.44200]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Dict 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Tuple 					=					self.get_dummy_inputs()
											snake_case_					:		List[Any] 					=					3 * [inputs["""prompt"""]]

											# forward
											snake_case_					:		Optional[Any] 					=					pipe(**lowercase__       )
											snake_case_					:		Optional[Any] 					=					output.images[0, -3:, -3:, -1]

											snake_case_					:		Optional[int] 					=					self.get_dummy_inputs()
											snake_case_					:		Optional[int] 					=					3 * [inputs.pop("""prompt"""       )]

											snake_case_					:		str 					=					pipe.tokenizer(
											    lowercase__   ,		padding="""max_length"""   ,		max_length=pipe.tokenizer.model_max_length   ,		truncation=lowercase__   ,		return_tensors="""np"""   ,		)
											snake_case_					:		Any 					=					text_inputs["""input_ids"""]

											snake_case_					:		Dict 					=					pipe.text_encoder(input_ids=text_inputs.astype(np.intaa       )       )[0]

											snake_case_					:		Optional[int] 					=					prompt_embeds

											# forward
											snake_case_					:		Optional[int] 					=					pipe(**lowercase__       )
											snake_case_					:		int 					=					output.images[0, -3:, -3:, -1]

											assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()       ).max() < 1e-4







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Tuple 					=					self.get_dummy_inputs()
											snake_case_					:		List[Any] 					=					3 * ["""this is a negative prompt"""]
											snake_case_					:		Any 					=					negative_prompt
											snake_case_					:		Dict 					=					3 * [inputs["""prompt"""]]

											# forward
											snake_case_					:		Optional[int] 					=					pipe(**lowercase__       )
											snake_case_					:		List[Any] 					=					output.images[0, -3:, -3:, -1]

											snake_case_					:		Optional[int] 					=					self.get_dummy_inputs()
											snake_case_					:		List[Any] 					=					3 * [inputs.pop("""prompt"""       )]

											snake_case_					:		List[Any] 					=					[]
											for p in [prompt, negative_prompt]:
																snake_case_					:		str 					=					pipe.tokenizer(
																    lowercase__   ,		padding="""max_length"""   ,		max_length=pipe.tokenizer.model_max_length   ,		truncation=lowercase__   ,		return_tensors="""np"""   ,		)
																snake_case_					:		Any 					=					text_inputs["""input_ids"""]

																embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.intaa       )       )[0]       )

											snake_case_					:		str 					=					embeds

											# forward
											snake_case_					:		str 					=					pipe(**lowercase__       )
											snake_case_					:		int 					=					output.images[0, -3:, -3:, -1]

											assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()       ).max() < 1e-4







@nightly
@require_onnxruntime
@require_torch_gpu
class    __lowercase     (					unittest.TestCase):







						"""simple docstring"""







						@property
						def 						__UpperCamelCase							(self       ):
											return (
											    "CUDAExecutionProvider",
											    {
											        "gpu_mem_limit": "15000000000",  # 15GB
											        "arena_extend_strategy": "kSameAsRequested",
											    },
											)







						@property
						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					ort.SessionOptions()
											snake_case_					:		Any 					=					False
											return options







						def 						__UpperCamelCase							(self       ):
											# using the PNDM scheduler by default
											snake_case_					:		List[Any] 					=					OnnxStableDiffusionPipeline.from_pretrained(
											    """CompVis/stable-diffusion-v1-4"""   ,		revision="""onnx"""   ,		safety_checker=lowercase__   ,		feature_extractor=lowercase__   ,		provider=self.gpu_provider   ,		sess_options=self.gpu_options   ,		)
											sd_pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Any 					=					"""A painting of a squirrel eating a burger"""
											np.random.seed(0       )
											snake_case_					:		Dict 					=					sd_pipe([prompt]   ,		guidance_scale=6.0   ,		num_inference_steps=10   ,		output_type="""np"""       )
											snake_case_					:		List[Any] 					=					output.images

											snake_case_					:		Optional[Any] 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 5_12, 5_12, 3)
											snake_case_					:		Dict 					=					np.array([0.0452, 0.0390, 0.0087, 0.0350, 0.0617, 0.0364, 0.0544, 0.0523, 0.0720]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-3







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					DDIMScheduler.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		subfolder="""scheduler"""   ,		revision="""onnx"""       )
											snake_case_					:		List[str] 					=					OnnxStableDiffusionPipeline.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		revision="""onnx"""   ,		scheduler=lowercase__   ,		safety_checker=lowercase__   ,		feature_extractor=lowercase__   ,		provider=self.gpu_provider   ,		sess_options=self.gpu_options   ,		)
											sd_pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		List[Any] 					=					"""open neural network exchange"""
											snake_case_					:		str 					=					np.random.RandomState(0       )
											snake_case_					:		Dict 					=					sd_pipe([prompt]   ,		guidance_scale=7.5   ,		num_inference_steps=10   ,		generator=lowercase__   ,		output_type="""np"""       )
											snake_case_					:		int 					=					output.images
											snake_case_					:		Optional[Any] 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 5_12, 5_12, 3)
											snake_case_					:		str 					=					np.array([0.2867, 0.1974, 0.1481, 0.7294, 0.7251, 0.6667, 0.4194, 0.5642, 0.6486]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-3







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Optional[Any] 					=					LMSDiscreteScheduler.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		subfolder="""scheduler"""   ,		revision="""onnx"""       )
											snake_case_					:		List[Any] 					=					OnnxStableDiffusionPipeline.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		revision="""onnx"""   ,		scheduler=lowercase__   ,		safety_checker=lowercase__   ,		feature_extractor=lowercase__   ,		provider=self.gpu_provider   ,		sess_options=self.gpu_options   ,		)
											sd_pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Dict 					=					"""open neural network exchange"""
											snake_case_					:		Any 					=					np.random.RandomState(0       )
											snake_case_					:		str 					=					sd_pipe([prompt]   ,		guidance_scale=7.5   ,		num_inference_steps=10   ,		generator=lowercase__   ,		output_type="""np"""       )
											snake_case_					:		Union[str, Any] 					=					output.images
											snake_case_					:		str 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 5_12, 5_12, 3)
											snake_case_					:		Optional[int] 					=					np.array([0.2306, 0.1959, 0.1593, 0.6549, 0.6394, 0.5408, 0.5065, 0.6010, 0.6161]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-3







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					0

											def test_callback_fn(lowercase__   ,		lowercase__   ,		lowercase__       ) -> None:
																snake_case_					:		Optional[int] 					=					True
																nonlocal number_of_steps
																number_of_steps += 1
																if step == 0:
																					assert latents.shape == (1, 4, 64, 64)
																					snake_case_					:		str 					=					latents[0, -3:, -3:, -1]
																					snake_case_					:		str 					=					np.array(
																					    [-0.6772, -0.3835, -1.2456, 0.1905, -1.0974, 0.6967, -1.9353, 0.0178, 1.0167]       )

																					assert np.abs(latents_slice.flatten() - expected_slice       ).max() < 1e-3
																elif step == 5:
																					assert latents.shape == (1, 4, 64, 64)
																					snake_case_					:		Union[str, Any] 					=					latents[0, -3:, -3:, -1]
																					snake_case_					:		Optional[Any] 					=					np.array(
																					    [-0.3351, 0.2241, -0.1837, -0.2325, -0.6577, 0.3393, -0.0241, 0.5899, 1.3875]       )

																					assert np.abs(latents_slice.flatten() - expected_slice       ).max() < 1e-3

											snake_case_					:		Union[str, Any] 					=					False

											snake_case_					:		Any 					=					OnnxStableDiffusionPipeline.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		revision="""onnx"""   ,		safety_checker=lowercase__   ,		feature_extractor=lowercase__   ,		provider=self.gpu_provider   ,		sess_options=self.gpu_options   ,		)
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Optional[int] 					=					"""Andromeda galaxy in a bottle"""

											snake_case_					:		Union[str, Any] 					=					np.random.RandomState(0       )
											pipe(
											    prompt=lowercase__   ,		num_inference_steps=5   ,		guidance_scale=7.5   ,		generator=lowercase__   ,		callback=lowercase__   ,		callback_steps=1   ,		)
											assert test_callback_fn.has_been_called
											assert number_of_steps == 6







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Optional[int] 					=					OnnxStableDiffusionPipeline.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		revision="""onnx"""   ,		safety_checker=lowercase__   ,		feature_extractor=lowercase__   ,		provider=self.gpu_provider   ,		sess_options=self.gpu_options   ,		)
											assert isinstance(lowercase__   ,		lowercase__       )
											assert pipe.safety_checker is None

											snake_case_					:		int 					=					pipe("""example prompt"""   ,		num_inference_steps=2       ).images[0]
											assert image is not None

											# check that there's no error when saving a pipeline with one of the models being None
											with tempfile.TemporaryDirectory() as tmpdirname:
																pipe.save_pretrained(lowercase__       )
																snake_case_					:		int 					=					OnnxStableDiffusionPipeline.from_pretrained(lowercase__       )

											# sanity check that the pipeline still works
											assert pipe.safety_checker is None
											snake_case_					:		Optional[Any] 					=					pipe("""example prompt"""   ,		num_inference_steps=2       ).images[0]
											assert image is not None









"""simple docstring"""

from typing import Dict, List, Optional, Union

import numpy as np

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_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
			import PIL


a_			   =					logging.get_logger(__name__)







class    __lowercase     (					_UpperCAmelCase):







						"""simple docstring"""







						_A		:							int							       =		["""pixel_values"""]







						def __init__(self   ,		lowercase__ = True   ,		lowercase__ = None   ,		lowercase__ = 0.9   ,		lowercase__ = PILImageResampling.BICUBIC   ,		lowercase__ = True   ,		lowercase__ = None   ,		lowercase__ = 1 / 2_55   ,		lowercase__ = True   ,		lowercase__ = True   ,		lowercase__ = None   ,		lowercase__ = None   ,		**lowercase__   ,		):
											super().__init__(**lowercase__       )
											snake_case_					:		Tuple 					=					size if size is not None else {"""shortest_edge""": 2_24}
											snake_case_					:		Union[str, Any] 					=					get_size_dict(lowercase__   ,		default_to_square=lowercase__       )
											snake_case_					:		str 					=					crop_size if crop_size is not None else {"""height""": 2_24, """width""": 2_24}
											snake_case_					:		Dict 					=					get_size_dict(lowercase__   ,		param_name="""crop_size"""       )

											snake_case_					:		Union[str, Any] 					=					do_resize
											snake_case_					:		List[str] 					=					size
											snake_case_					:		str 					=					crop_pct
											snake_case_					:		str 					=					resample
											snake_case_					:		Optional[Any] 					=					do_center_crop
											snake_case_					:		Dict 					=					crop_size
											snake_case_					:		int 					=					do_rescale
											snake_case_					:		Optional[int] 					=					rescale_factor
											snake_case_					:		str 					=					do_normalize
											snake_case_					:		str 					=					image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
											snake_case_					:		List[str] 					=					image_std if image_std is not None else IMAGENET_DEFAULT_STD







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__   ,		lowercase__ = None   ,		lowercase__ = PILImageResampling.BICUBIC   ,		lowercase__ = None   ,		**lowercase__   ,		):
											snake_case_					:		Tuple 					=					get_size_dict(lowercase__   ,		default_to_square=lowercase__       )
											if "shortest_edge" not in size and ("height" not in size or "width" not in size):
																raise ValueError(f'size must contain \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}'       )
											if crop_pct is not None:
																if "shortest_edge" in size:
																					snake_case_					:		Optional[int] 					=					int(size["""shortest_edge"""] / crop_pct       )
																elif "height" in size and "width" in size:
																					if size["height"] == size["width"]:
																										snake_case_					:		Dict 					=					int(size["""height"""] / crop_pct       )
																					else:
																										snake_case_					:		List[str] 					=					(int(size["""height"""] / crop_pct       ), int(size["""width"""] / crop_pct       ))
																else:
																					raise ValueError("""Invalid size for resize: {}""".format(lowercase__       )       )

																snake_case_					:		List[Any] 					=					get_resize_output_image_size(lowercase__   ,		size=lowercase__   ,		default_to_square=lowercase__       )
											else:
																if "shortest_edge" in size:
																					snake_case_					:		Optional[int] 					=					get_resize_output_image_size(lowercase__   ,		size=size["""shortest_edge"""]   ,		default_to_square=lowercase__       )
																elif "height" in size and "width" in size:
																					snake_case_					:		int 					=					(size["""height"""], size["""width"""])
																else:
																					raise ValueError("""Invalid size for resize: {}""".format(lowercase__       )       )

											return resize(lowercase__   ,		size=lowercase__   ,		resample=lowercase__   ,		data_format=lowercase__   ,		**lowercase__       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__   ,		lowercase__ = None   ,		**lowercase__   ,		):
											snake_case_					:		int 					=					get_size_dict(lowercase__       )
											if "height" not in size or "width" not in size:
																raise ValueError(f'size must contain \'height\' and \'width\' as keys. Got {size.keys()}'       )
											return center_crop(lowercase__   ,		size=(size["""height"""], size["""width"""])   ,		data_format=lowercase__   ,		**lowercase__       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__   ,		lowercase__ = None   ,		**lowercase__   ,		):
											return rescale(lowercase__   ,		scale=lowercase__   ,		data_format=lowercase__   ,		**lowercase__       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__   ,		lowercase__   ,		lowercase__ = None   ,		**lowercase__   ,		):
											return normalize(lowercase__   ,		mean=lowercase__   ,		std=lowercase__   ,		data_format=lowercase__   ,		**lowercase__       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = None   ,		lowercase__ = ChannelDimension.FIRST   ,		**lowercase__   ,		):
											snake_case_					:		str 					=					do_resize if do_resize is not None else self.do_resize
											snake_case_					:		Any 					=					crop_pct if crop_pct is not None else self.crop_pct
											snake_case_					:		List[Any] 					=					resample if resample is not None else self.resample
											snake_case_					:		str 					=					do_center_crop if do_center_crop is not None else self.do_center_crop
											snake_case_					:		str 					=					do_rescale if do_rescale is not None else self.do_rescale
											snake_case_					:		Any 					=					rescale_factor if rescale_factor is not None else self.rescale_factor
											snake_case_					:		str 					=					do_normalize if do_normalize is not None else self.do_normalize
											snake_case_					:		List[Any] 					=					image_mean if image_mean is not None else self.image_mean
											snake_case_					:		int 					=					image_std if image_std is not None else self.image_std

											snake_case_					:		List[Any] 					=					size if size is not None else self.size
											snake_case_					:		Optional[Any] 					=					get_size_dict(lowercase__   ,		default_to_square=lowercase__       )
											snake_case_					:		List[Any] 					=					crop_size if crop_size is not None else self.crop_size
											snake_case_					:		int 					=					get_size_dict(lowercase__   ,		param_name="""crop_size"""       )

											snake_case_					:		List[str] 					=					make_list_of_images(lowercase__       )

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

											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_pct is None:
																raise ValueError("""Crop_pct 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."""       )

											# All transformations expect numpy arrays.
											snake_case_					:		int 					=					[to_numpy_array(lowercase__       ) for image in images]

											if do_resize:
																snake_case_					:		str 					=					[self.resize(image=lowercase__   ,		size=lowercase__   ,		crop_pct=lowercase__   ,		resample=lowercase__       ) for image in images]

											if do_center_crop:
																snake_case_					:		Optional[int] 					=					[self.center_crop(image=lowercase__   ,		size=lowercase__       ) for image in images]

											if do_rescale:
																snake_case_					:		List[Any] 					=					[self.rescale(image=lowercase__   ,		scale=lowercase__       ) for image in images]

											if do_normalize:
																snake_case_					:		Optional[Any] 					=					[self.normalize(image=lowercase__   ,		mean=lowercase__   ,		std=lowercase__       ) for image in images]

											snake_case_					:		List[Any] 					=					[to_channel_dimension_format(lowercase__   ,		lowercase__       ) for image in images]

											snake_case_					:		Dict 					=					{"""pixel_values""": images}
											return BatchFeature(data=lowercase__   ,		tensor_type=lowercase__       )




