import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionInstructPixaPixPipeline,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.utils import floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class        lowercase_   (					__snake_case						,			__snake_case						,			__snake_case						,			unittest.TestCase		):
							_lowerCamelCase						=		StableDiffusionInstructPixaPixPipeline
							_lowerCamelCase						=		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width', 'cross_attention_kwargs'}
							_lowerCamelCase						=		TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
							_lowerCamelCase						=		IMAGE_TO_IMAGE_IMAGE_PARAMS
							_lowerCamelCase						=		IMAGE_TO_IMAGE_IMAGE_PARAMS



							def 	UpperCamelCase	(						self    ):
													torch.manual_seed(0    )
													_snake_case						:					int    =   UNetaDConditionModel(
													    block_out_channels=(32, 64)				,    layers_per_block=2				,    sample_size=32				,    in_channels=8				,    out_channels=4				,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")				,    up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")				,    cross_attention_dim=32				,    )
													_snake_case						:					Optional[Any]    =   PNDMScheduler(skip_prk_steps=lowercase_    )
													torch.manual_seed(0    )
													_snake_case						:					Dict    =   AutoencoderKL(
													    block_out_channels=[32, 64]				,    in_channels=3				,    out_channels=3				,    down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]				,    up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]				,    latent_channels=4				,    )
													torch.manual_seed(0    )
													_snake_case						:					Union[str, Any]    =   CLIPTextConfig(
													    bos_token_id=0				,    eos_token_id=2				,    hidden_size=32				,    intermediate_size=37				,    layer_norm_eps=1e-05				,    num_attention_heads=4				,    num_hidden_layers=5				,    pad_token_id=1				,    vocab_size=1_000				,    )
													_snake_case						:					Any    =   CLIPTextModel(lowercase_    )
													_snake_case						:					Optional[int]    =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"    )

													_snake_case						:					List[Any]    =   {
													    "unet": unet,
													    "scheduler": scheduler,
													    "vae": vae,
													    "text_encoder": text_encoder,
													    "tokenizer": tokenizer,
													    "safety_checker": None,
													    "feature_extractor": None,
													}
													return components



							def 	UpperCamelCase	(						self				,    lowercase_				,    lowercase_=0    ):
													_snake_case						:					str    =   floats_tensor((1, 3, 32, 32)				,    rng=random.Random(lowercase_    )    ).to(lowercase_    )
													_snake_case						:					Optional[int]    =   image.cpu().permute(0				,    2				,    3				,    1    )[0]
													_snake_case						:					int    =   Image.fromarray(np.uinta(lowercase_    )    ).convert("RGB"    )
													if str(lowercase_    ).startswith("mps"    ):
																			_snake_case						:					List[Any]    =   torch.manual_seed(lowercase_    )
													else:
																			_snake_case						:					Tuple    =   torch.Generator(device=lowercase_    ).manual_seed(lowercase_    )
													_snake_case						:					Optional[int]    =   {
													    "prompt": "A painting of a squirrel eating a burger",
													    "image": image,
													    "generator": generator,
													    "num_inference_steps": 2,
													    "guidance_scale": 6.0,
													    "image_guidance_scale": 1,
													    "output_type": "numpy",
													}
													return inputs



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Union[str, Any]    =   "cpu"  # ensure determinism for the device-dependent torch.Generator
													_snake_case						:					List[Any]    =   self.get_dummy_components()
													_snake_case						:					Optional[Any]    =   StableDiffusionInstructPixaPixPipeline(**lowercase_    )
													_snake_case						:					int    =   sd_pipe.to(lowercase_    )
													sd_pipe.set_progress_bar_config(disable=lowercase_    )

													_snake_case						:					Dict    =   self.get_dummy_inputs(lowercase_    )
													_snake_case						:					Any    =   sd_pipe(**lowercase_    ).images
													_snake_case						:					str    =   image[0, -3:, -3:, -1]
													assert image.shape == (1, 32, 32, 3)
													_snake_case						:					Tuple    =   np.array([0.7_526, 0.3_750, 0.4_547, 0.6_117, 0.5_866, 0.5_016, 0.4_327, 0.5_642, 0.4_815]    )

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



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					str    =   "cpu"  # ensure determinism for the device-dependent torch.Generator
													_snake_case						:					Tuple    =   self.get_dummy_components()
													_snake_case						:					List[Any]    =   StableDiffusionInstructPixaPixPipeline(**lowercase_    )
													_snake_case						:					Any    =   sd_pipe.to(lowercase_    )
													sd_pipe.set_progress_bar_config(disable=lowercase_    )

													_snake_case						:					List[str]    =   self.get_dummy_inputs(lowercase_    )
													_snake_case						:					str    =   "french fries"
													_snake_case						:					List[Any]    =   sd_pipe(**lowercase_				,    negative_prompt=lowercase_    )
													_snake_case						:					str    =   output.images
													_snake_case						:					Any    =   image[0, -3:, -3:, -1]

													assert image.shape == (1, 32, 32, 3)
													_snake_case						:					Any    =   np.array([0.7_511, 0.3_642, 0.4_553, 0.6_236, 0.5_797, 0.5_013, 0.4_343, 0.5_611, 0.4_831]    )

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



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Union[str, Any]    =   "cpu"  # ensure determinism for the device-dependent torch.Generator
													_snake_case						:					Any    =   self.get_dummy_components()
													_snake_case						:					Dict    =   StableDiffusionInstructPixaPixPipeline(**lowercase_    )
													_snake_case						:					Optional[Any]    =   sd_pipe.to(lowercase_    )
													sd_pipe.set_progress_bar_config(disable=lowercase_    )

													_snake_case						:					int    =   self.get_dummy_inputs(lowercase_    )
													_snake_case						:					Dict    =   [inputs["prompt"]] * 2

													_snake_case						:					str    =   np.array(inputs["image"]    ).astype(np.floataa    ) / 255.0
													_snake_case						:					Dict    =   torch.from_numpy(lowercase_    ).unsqueeze(0    ).to(lowercase_    )
													_snake_case						:					Union[str, Any]    =   image / 2 + 0.5
													_snake_case						:					int    =   image.permute(0				,    3				,    1				,    2    )
													_snake_case						:					Optional[int]    =   image.repeat(2				,    1				,    1				,    1    )

													_snake_case						:					Dict    =   sd_pipe(**lowercase_    ).images
													_snake_case						:					Optional[Any]    =   image[-1, -3:, -3:, -1]

													assert image.shape == (2, 32, 32, 3)
													_snake_case						:					Union[str, Any]    =   np.array([0.5_812, 0.5_748, 0.5_222, 0.5_908, 0.5_695, 0.7_174, 0.6_804, 0.5_523, 0.5_579]    )

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



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					List[Any]    =   "cpu"  # ensure determinism for the device-dependent torch.Generator
													_snake_case						:					Union[str, Any]    =   self.get_dummy_components()
													_snake_case						:					Dict    =   EulerAncestralDiscreteScheduler(
													    beta_start=0.00_085				,    beta_end=0.012				,    beta_schedule="scaled_linear"    )
													_snake_case						:					Optional[Any]    =   StableDiffusionInstructPixaPixPipeline(**lowercase_    )
													_snake_case						:					List[str]    =   sd_pipe.to(lowercase_    )
													sd_pipe.set_progress_bar_config(disable=lowercase_    )

													_snake_case						:					Optional[Any]    =   self.get_dummy_inputs(lowercase_    )
													_snake_case						:					Optional[Any]    =   sd_pipe(**lowercase_    ).images
													_snake_case						:					List[Any]    =   image[0, -3:, -3:, -1]

													_snake_case						:					Optional[int]    =   [round(lowercase_				,    4    ) for x in image_slice.flatten().tolist()]
													print(",".join([str(lowercase_    ) for x in slice]    )    )

													assert image.shape == (1, 32, 32, 3)
													_snake_case						:					str    =   np.array([0.7_417, 0.3_842, 0.4_732, 0.5_776, 0.5_891, 0.5_139, 0.4_052, 0.5_673, 0.4_986]    )

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



							def 	UpperCamelCase	(						self    ):
													super().test_inference_batch_single_identical(expected_max_diff=3e-3    )



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					List[str]    =   self.get_dummy_components()
													_snake_case						:					List[str]    =   StableDiffusionInstructPixaPixPipeline(**lowercase_    )
													_snake_case						:					Tuple    =   VaeImageProcessor(do_resize=lowercase_				,    do_normalize=lowercase_    )
													_snake_case						:					List[str]    =   pipe.to(lowercase_    )
													pipe.set_progress_bar_config(disable=lowercase_    )

													_snake_case						:					List[Any]    =   pipe(**self.get_dummy_inputs_by_type(lowercase_				,    input_image_type="pt"    )    )[0]

													_snake_case						:					Optional[int]    =   components["vae"]
													_snake_case						:					Union[str, Any]    =   self.get_dummy_inputs_by_type(lowercase_				,    input_image_type="pt"    )

													for image_param in self.image_latents_params:
																			if image_param in inputs.keys():
																									_snake_case						:					Optional[Any]    =   vae.encode(inputs[image_param]    ).latent_dist.mode()

													_snake_case						:					Optional[Any]    =   pipe(**lowercase_    )[0]

													_snake_case						:					List[Any]    =   np.abs(out - out_latents_inputs    ).max()
													self.assertLess(lowercase_				,    1e-4				,    "passing latents as image input generate different result from passing image"    )




@slow
@require_torch_gpu
class        lowercase_   (					unittest.TestCase		):



							def 	UpperCamelCase	(						self    ):
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()



							def 	UpperCamelCase	(						self				,    lowercase_=0    ):
													_snake_case						:					Dict    =   torch.manual_seed(lowercase_    )
													_snake_case						:					Optional[int]    =   load_image(
													    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_pix2pix/example.jpg"    )
													_snake_case						:					int    =   {
													    "prompt": "turn him into a cyborg",
													    "image": image,
													    "generator": generator,
													    "num_inference_steps": 3,
													    "guidance_scale": 7.5,
													    "image_guidance_scale": 1.0,
													    "output_type": "numpy",
													}
													return inputs



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Dict    =   StableDiffusionInstructPixaPixPipeline.from_pretrained(
													    "timbrooks/instruct-pix2pix"				,    safety_checker=lowercase_    )
													pipe.to(lowercase_    )
													pipe.set_progress_bar_config(disable=lowercase_    )
													pipe.enable_attention_slicing()

													_snake_case						:					Tuple    =   self.get_inputs()
													_snake_case						:					Dict    =   pipe(**lowercase_    ).images
													_snake_case						:					int    =   image[0, -3:, -3:, -1].flatten()

													assert image.shape == (1, 512, 512, 3)
													_snake_case						:					str    =   np.array([0.5_902, 0.6_015, 0.6_027, 0.5_983, 0.6_092, 0.6_061, 0.5_765, 0.5_785, 0.5_555]    )

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



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					List[Any]    =   StableDiffusionInstructPixaPixPipeline.from_pretrained(
													    "timbrooks/instruct-pix2pix"				,    safety_checker=lowercase_    )
													_snake_case						:					Optional[int]    =   LMSDiscreteScheduler.from_config(pipe.scheduler.config    )
													pipe.to(lowercase_    )
													pipe.set_progress_bar_config(disable=lowercase_    )
													pipe.enable_attention_slicing()

													_snake_case						:					Optional[Any]    =   self.get_inputs()
													_snake_case						:					Union[str, Any]    =   pipe(**lowercase_    ).images
													_snake_case						:					Dict    =   image[0, -3:, -3:, -1].flatten()

													assert image.shape == (1, 512, 512, 3)
													_snake_case						:					Tuple    =   np.array([0.6_578, 0.6_817, 0.6_972, 0.6_761, 0.6_856, 0.6_916, 0.6_428, 0.6_516, 0.6_301]    )

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



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Dict    =   StableDiffusionInstructPixaPixPipeline.from_pretrained(
													    "timbrooks/instruct-pix2pix"				,    safety_checker=lowercase_    )
													_snake_case						:					Optional[Any]    =   DDIMScheduler.from_config(pipe.scheduler.config    )
													pipe.to(lowercase_    )
													pipe.set_progress_bar_config(disable=lowercase_    )
													pipe.enable_attention_slicing()

													_snake_case						:					List[Any]    =   self.get_inputs()
													_snake_case						:					List[str]    =   pipe(**lowercase_    ).images
													_snake_case						:					List[str]    =   image[0, -3:, -3:, -1].flatten()

													assert image.shape == (1, 512, 512, 3)
													_snake_case						:					Optional[Any]    =   np.array([0.3_828, 0.3_834, 0.3_818, 0.3_792, 0.3_865, 0.3_752, 0.3_792, 0.3_847, 0.3_753]    )

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



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Union[str, Any]    =   0

													def callback_fn(lowercase_				,    lowercase_				,    lowercase_    ) -> None:
																			_snake_case						:					int    =   True
																			nonlocal number_of_steps
																			number_of_steps += 1
																			if step == 1:
																									_snake_case						:					Union[str, Any]    =   latents.detach().cpu().numpy()
																									assert latents.shape == (1, 4, 64, 64)
																									_snake_case						:					Optional[Any]    =   latents[0, -3:, -3:, -1]
																									_snake_case						:					List[Any]    =   np.array([-0.2_463, -0.4_644, -0.9_756, 1.5_176, 1.4_414, 0.7_866, 0.9_897, 0.8_521, 0.7_983]    )

																									assert np.abs(latents_slice.flatten() - expected_slice    ).max() < 5e-2
																			elif step == 2:
																									_snake_case						:					Tuple    =   latents.detach().cpu().numpy()
																									assert latents.shape == (1, 4, 64, 64)
																									_snake_case						:					Optional[int]    =   latents[0, -3:, -3:, -1]
																									_snake_case						:					int    =   np.array([-0.2_644, -0.4_626, -0.9_653, 1.5_176, 1.4_551, 0.7_686, 0.9_805, 0.8_452, 0.8_115]    )

																									assert np.abs(latents_slice.flatten() - expected_slice    ).max() < 5e-2

													_snake_case						:					Any    =   False

													_snake_case						:					Union[str, Any]    =   StableDiffusionInstructPixaPixPipeline.from_pretrained(
													    "timbrooks/instruct-pix2pix"				,    safety_checker=lowercase_				,    torch_dtype=torch.floataa    )
													_snake_case						:					Optional[int]    =   pipe.to(lowercase_    )
													pipe.set_progress_bar_config(disable=lowercase_    )
													pipe.enable_attention_slicing()

													_snake_case						:					Optional[Any]    =   self.get_inputs()
													pipe(**lowercase_				,    callback=lowercase_				,    callback_steps=1    )
													assert callback_fn.has_been_called
													assert number_of_steps == 3



							def 	UpperCamelCase	(						self    ):
													torch.cuda.empty_cache()
													torch.cuda.reset_max_memory_allocated()
													torch.cuda.reset_peak_memory_stats()

													_snake_case						:					Dict    =   StableDiffusionInstructPixaPixPipeline.from_pretrained(
													    "timbrooks/instruct-pix2pix"				,    safety_checker=lowercase_				,    torch_dtype=torch.floataa    )
													_snake_case						:					List[str]    =   pipe.to(lowercase_    )
													pipe.set_progress_bar_config(disable=lowercase_    )
													pipe.enable_attention_slicing(1    )
													pipe.enable_sequential_cpu_offload()

													_snake_case						:					str    =   self.get_inputs()
													_snake_case						:					Optional[Any]    =   pipe(**lowercase_    )

													_snake_case						:					int    =   torch.cuda.max_memory_allocated()
													# make sure that less than 2.2 GB is allocated
													assert mem_bytes < 2.2 * 10**9



							def 	UpperCamelCase	(						self    ):
													_snake_case						:					Dict    =   self.get_inputs()
													# resize to resolution that is divisible by 8 but not 16 or 32
													_snake_case						:					List[str]    =   inputs["image"].resize((504, 504)    )

													_snake_case						:					Any    =   "timbrooks/instruct-pix2pix"
													_snake_case						:					Union[str, Any]    =   StableDiffusionInstructPixaPixPipeline.from_pretrained(
													    lowercase_				,    safety_checker=lowercase_				,    )
													pipe.to(lowercase_    )
													pipe.set_progress_bar_config(disable=lowercase_    )
													pipe.enable_attention_slicing()

													_snake_case						:					int    =   pipe(**lowercase_    )
													_snake_case						:					List[Any]    =   output.images[0]

													_snake_case						:					List[Any]    =   image[255:258, 383:386, -1]

													assert image.shape == (504, 504, 3)
													_snake_case						:					List[str]    =   np.array([0.2_726, 0.2_529, 0.2_664, 0.2_655, 0.2_641, 0.2_642, 0.2_591, 0.2_649, 0.2_590]    )

													assert np.abs(image_slice.flatten() - expected_slice    ).max() < 5e-3
from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    flip_channel_order,
    get_resize_output_image_size,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging


if is_vision_available():
				import PIL

if is_torch_available():
				import torch


__SCREAMING_SNAKE_CASE						:   Optional[int]         =			logging.get_logger(__name__)



class        lowercase_   (					__snake_case		):
							_lowerCamelCase						=		['pixel_values']



							def __init__(						self				,    lowercase_ = True				,    lowercase_ = None				,    lowercase_ = PILImageResampling.BILINEAR				,    lowercase_ = True				,    lowercase_ = 1 / 255				,    lowercase_ = True				,    lowercase_ = None				,    lowercase_ = True				,    **lowercase_				,    ):
													super().__init__(**lowercase_    )
													_snake_case						:					Dict    =   size if size is not None else {"shortest_edge": 224}
													_snake_case						:					Optional[int]    =   get_size_dict(lowercase_				,    default_to_square=lowercase_    )
													_snake_case						:					Any    =   crop_size if crop_size is not None else {"height": 256, "width": 256}
													_snake_case						:					str    =   get_size_dict(lowercase_				,    param_name="crop_size"    )

													_snake_case						:					List[Any]    =   do_resize
													_snake_case						:					Tuple    =   size
													_snake_case						:					Union[str, Any]    =   resample
													_snake_case						:					str    =   do_rescale
													_snake_case						:					Dict    =   rescale_factor
													_snake_case						:					int    =   do_center_crop
													_snake_case						:					int    =   crop_size
													_snake_case						:					List[Any]    =   do_flip_channel_order



							def 	UpperCamelCase	(						self				,    lowercase_				,    lowercase_				,    lowercase_ = PIL.Image.BILINEAR				,    lowercase_ = None				,    **lowercase_				,    ):
													_snake_case						:					Optional[Any]    =   get_size_dict(lowercase_				,    default_to_square=lowercase_    )
													if "shortest_edge" not in size:
																			raise ValueError(f"""The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}"""    )
													_snake_case						:					int    =   get_resize_output_image_size(lowercase_				,    size=size["shortest_edge"]				,    default_to_square=lowercase_    )
													return resize(lowercase_				,    size=lowercase_				,    resample=lowercase_				,    data_format=lowercase_				,    **lowercase_    )



							def 	UpperCamelCase	(						self				,    lowercase_				,    lowercase_				,    lowercase_ = None				,    **lowercase_				,    ):
													_snake_case						:					List[str]    =   get_size_dict(lowercase_    )
													if "height" not in size or "width" not in size:
																			raise ValueError(f"""The `size` dictionary must contain the keys `height` and `width`. 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_ = None    ):
													return flip_channel_order(lowercase_				,    data_format=lowercase_    )



							def 	UpperCamelCase	(						self				,    lowercase_				,    lowercase_ = None				,    lowercase_ = None				,    lowercase_ = None				,    lowercase_ = None				,    lowercase_ = None				,    lowercase_ = None				,    lowercase_ = None				,    lowercase_ = None				,    lowercase_ = None				,    lowercase_ = ChannelDimension.FIRST				,    **lowercase_				,    ):
													_snake_case						:					Dict    =   do_resize if do_resize is not None else self.do_resize
													_snake_case						:					Union[str, Any]    =   resample if resample is not None else self.resample
													_snake_case						:					Dict    =   do_rescale if do_rescale is not None else self.do_rescale
													_snake_case						:					str    =   rescale_factor if rescale_factor is not None else self.rescale_factor
													_snake_case						:					Optional[int]    =   do_center_crop if do_center_crop is not None else self.do_center_crop
													_snake_case						:					List[str]    =   (
													    do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
													)

													_snake_case						:					Optional[int]    =   size if size is not None else self.size
													_snake_case						:					Optional[int]    =   get_size_dict(lowercase_				,    default_to_square=lowercase_    )
													_snake_case						:					Optional[int]    =   crop_size if crop_size is not None else self.crop_size
													_snake_case						:					Union[str, Any]    =   get_size_dict(lowercase_				,    param_name="crop_size"    )

													_snake_case						:					Tuple    =   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:
																			raise ValueError("Size must be specified if do_resize is True."    )

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

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

													# All transformations expect numpy arrays.
													_snake_case						:					Tuple    =   [to_numpy_array(lowercase_    ) for image in images]

													if do_resize:
																			_snake_case						:					int    =   [self.resize(image=lowercase_				,    size=lowercase_				,    resample=lowercase_    ) for image in images]

													if do_center_crop:
																			_snake_case						:					List[Any]    =   [self.center_crop(image=lowercase_				,    size=lowercase_    ) for image in images]

													if do_rescale:
																			_snake_case						:					Optional[int]    =   [self.rescale(image=lowercase_				,    scale=lowercase_    ) for image in images]

													# the pretrained checkpoints assume images are BGR, not RGB
													if do_flip_channel_order:
																			_snake_case						:					int    =   [self.flip_channel_order(image=lowercase_    ) for image in images]

													_snake_case						:					str    =   [to_channel_dimension_format(lowercase_				,    lowercase_    ) for image in images]

													_snake_case						:					List[Any]    =   {"pixel_values": images}
													return BatchFeature(data=lowercase_				,    tensor_type=lowercase_    )



							def 	UpperCamelCase	(						self				,    lowercase_				,    lowercase_ = None    ):
													_snake_case						:					int    =   outputs.logits

													# Resize logits and compute semantic segmentation maps
													if target_sizes is not None:
																			if len(lowercase_    ) != len(lowercase_    ):
																									raise ValueError(
																									    "Make sure that you pass in as many target sizes as the batch dimension of the logits"    )

																			if is_torch_tensor(lowercase_    ):
																									_snake_case						:					Union[str, Any]    =   target_sizes.numpy()

																			_snake_case						:					int    =   []

																			for idx in range(len(lowercase_    )    ):
																									_snake_case						:					Optional[Any]    =   torch.nn.functional.interpolate(
																									    logits[idx].unsqueeze(dim=0    )				,    size=target_sizes[idx]				,    mode="bilinear"				,    align_corners=lowercase_    )
																									_snake_case						:					List[str]    =   resized_logits[0].argmax(dim=0    )
																									semantic_segmentation.append(lowercase_    )
													else:
																			_snake_case						:					List[Any]    =   logits.argmax(dim=1    )
																			_snake_case						:					Optional[Any]    =   [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]    )]

													return semantic_segmentation