





'''simple docstring'''



import math
from typing import Optional

import numpy as np
import torch
from torch import nn

from .activations import get_activation



def  lowercase__(		_UpperCamelCase  : torch.Tensor ,   _UpperCamelCase  : int ,   _UpperCamelCase  : bool = False ,   _UpperCamelCase  : float = 1 ,   _UpperCamelCase  : float = 1 ,   _UpperCamelCase  : int = 10000 ,   )->   Optional[Any]:






					"""simple docstring"""

					assert len(timesteps.shape				) == 1, "Timesteps should be a 1d-array"

					_UpperCamelCase											=   embedding_dim // 2
					_UpperCamelCase											=   -math.log(_UpperCamelCase				) * torch.arange(
					    start=0 ,   end=_UpperCamelCase ,   dtype=torch.floataa ,   device=timesteps.device				)
					_UpperCamelCase											=   exponent / (half_dim - downscale_freq_shift)

					_UpperCamelCase											=   torch.exp(_UpperCamelCase				)
					_UpperCamelCase											=   timesteps[:, None].float() * emb[None, :]

					# scale embeddings
					_UpperCamelCase											=   scale * emb

					# concat sine and cosine embeddings
					_UpperCamelCase											=   torch.cat([torch.sin(_UpperCamelCase				), torch.cos(_UpperCamelCase				)] ,   dim=-1				)

					# flip sine and cosine embeddings
					if flip_sin_to_cos:
										_UpperCamelCase											=   torch.cat([emb[:, half_dim:], emb[:, :half_dim]] ,   dim=-1				)

					# zero pad
					if embedding_dim % 2 == 1:
										_UpperCamelCase											=   torch.nn.functional.pad(_UpperCamelCase ,   (0, 1, 0, 0)				)
					return emb



def  lowercase__(		_UpperCamelCase  : List[Any] ,   _UpperCamelCase  : Dict ,   _UpperCamelCase  : Any=False ,   _UpperCamelCase  : Optional[Any]=0				)->   Tuple:






					"""simple docstring"""

					_UpperCamelCase											=   np.arange(_UpperCamelCase ,   dtype=np.floataa				)
					_UpperCamelCase											=   np.arange(_UpperCamelCase ,   dtype=np.floataa				)
					_UpperCamelCase											=   np.meshgrid(_UpperCamelCase ,   _UpperCamelCase				)  # here w goes first
					_UpperCamelCase											=   np.stack(_UpperCamelCase ,   axis=0				)

					_UpperCamelCase											=   grid.reshape([2, 1, grid_size, grid_size]				)
					_UpperCamelCase											=   get_ad_sincos_pos_embed_from_grid(_UpperCamelCase ,   _UpperCamelCase				)
					if cls_token and extra_tokens > 0:
										_UpperCamelCase											=   np.concatenate([np.zeros([extra_tokens, embed_dim]				), pos_embed] ,   axis=0				)
					return pos_embed



def  lowercase__(		_UpperCamelCase  : Union[str, Any] ,   _UpperCamelCase  : Any				)->   List[Any]:






					"""simple docstring"""

					if embed_dim % 2 != 0:
										raise ValueError("embed_dim must be divisible by 2"				)

					# use half of dimensions to encode grid_h
					_UpperCamelCase											=   get_ad_sincos_pos_embed_from_grid(embed_dim // 2 ,   grid[0]				)  # (H*W, D/2)
					_UpperCamelCase											=   get_ad_sincos_pos_embed_from_grid(embed_dim // 2 ,   grid[1]				)  # (H*W, D/2)

					_UpperCamelCase											=   np.concatenate([emb_h, emb_w] ,   axis=1				)  # (H*W, D)
					return emb



def  lowercase__(		_UpperCamelCase  : Tuple ,   _UpperCamelCase  : Any				)->   Dict:






					"""simple docstring"""

					if embed_dim % 2 != 0:
										raise ValueError("embed_dim must be divisible by 2"				)

					_UpperCamelCase											=   np.arange(embed_dim // 2 ,   dtype=np.floataa				)
					omega /= embed_dim / 2.0
					_UpperCamelCase											=   1.0 / 10000**omega  # (D/2,)

					_UpperCamelCase											=   pos.reshape(-1				)  # (M,)
					_UpperCamelCase											=   np.einsum("m,d->md" ,   _UpperCamelCase ,   _UpperCamelCase				)  # (M, D/2), outer product

					_UpperCamelCase											=   np.sin(_UpperCamelCase				)  # (M, D/2)
					_UpperCamelCase											=   np.cos(_UpperCamelCase				)  # (M, D/2)

					_UpperCamelCase											=   np.concatenate([emb_sin, emb_cos] ,   axis=1				)  # (M, D)
					return emb

class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_=2_24			,     A_=2_24			,     A_=16			,     A_=3			,     A_=7_68			,     A_=False			,     A_=True			,     A_=True			,     ):
								super().__init__()

								_UpperCamelCase											=   (height // patch_size) * (width // patch_size)
								_UpperCamelCase											=   flatten
								_UpperCamelCase											=   layer_norm

								_UpperCamelCase											=   nn.Convad(
								    A_			,     A_			,     kernel_size=(patch_size, patch_size)			,     stride=A_			,     bias=A_   )
								if layer_norm:
													_UpperCamelCase											=   nn.LayerNorm(A_			,     elementwise_affine=A_			,     eps=1e-6   )
								else:
													_UpperCamelCase											=   None

								_UpperCamelCase											=   get_ad_sincos_pos_embed(A_			,     int(num_patches**0.5   )   )
								self.register_buffer("pos_embed"			,     torch.from_numpy(A_   ).float().unsqueeze(0   )			,     persistent=A_   )




			def       a	(					self			,     A_   ):
								_UpperCamelCase											=   self.proj(A_   )
								if self.flatten:
													_UpperCamelCase											=   latent.flatten(2   ).transpose(1			,     2   )  # BCHW -> BNC
								if self.layer_norm:
													_UpperCamelCase											=   self.norm(A_   )
								return latent + self.pos_embed




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_			,     A_ = "silu"			,     A_ = None			,     A_ = None			,     A_=None			,     ):
								super().__init__()

								_UpperCamelCase											=   nn.Linear(A_			,     A_   )

								if cond_proj_dim is not None:
													_UpperCamelCase											=   nn.Linear(A_			,     A_			,     bias=A_   )
								else:
													_UpperCamelCase											=   None

								_UpperCamelCase											=   get_activation(A_   )

								if out_dim is not None:
													_UpperCamelCase											=   out_dim
								else:
													_UpperCamelCase											=   time_embed_dim
								_UpperCamelCase											=   nn.Linear(A_			,     A_   )

								if post_act_fn is None:
													_UpperCamelCase											=   None
								else:
													_UpperCamelCase											=   get_activation(A_   )




			def       a	(					self			,     A_			,     A_=None   ):
								if condition is not None:
													_UpperCamelCase											=   sample + self.cond_proj(A_   )
								_UpperCamelCase											=   self.linear_a(A_   )

								if self.act is not None:
													_UpperCamelCase											=   self.act(A_   )

								_UpperCamelCase											=   self.linear_a(A_   )

								if self.post_act is not None:
													_UpperCamelCase											=   self.post_act(A_   )
								return sample




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_			,     A_   ):
								super().__init__()
								_UpperCamelCase											=   num_channels
								_UpperCamelCase											=   flip_sin_to_cos
								_UpperCamelCase											=   downscale_freq_shift




			def       a	(					self			,     A_   ):
								_UpperCamelCase											=   get_timestep_embedding(
								    A_			,     self.num_channels			,     flip_sin_to_cos=self.flip_sin_to_cos			,     downscale_freq_shift=self.downscale_freq_shift			,     )
								return t_emb




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_ = 2_56			,     A_ = 1.0			,     A_=True			,     A_=True			,     A_=False   ):
								super().__init__()
								_UpperCamelCase											=   nn.Parameter(torch.randn(A_   ) * scale			,     requires_grad=A_   )
								_UpperCamelCase											=   log
								_UpperCamelCase											=   flip_sin_to_cos

								if set_W_to_weight:
													# to delete later
													_UpperCamelCase											=   nn.Parameter(torch.randn(A_   ) * scale			,     requires_grad=A_   )

													_UpperCamelCase											=   self.W




			def       a	(					self			,     A_   ):
								if self.log:
													_UpperCamelCase											=   torch.log(A_   )

								_UpperCamelCase											=   x[:, None] * self.weight[None, :] * 2 * np.pi

								if self.flip_sin_to_cos:
													_UpperCamelCase											=   torch.cat([torch.cos(A_   ), torch.sin(A_   )]			,     dim=-1   )
								else:
													_UpperCamelCase											=   torch.cat([torch.sin(A_   ), torch.cos(A_   )]			,     dim=-1   )
								return out




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_			,     A_			,     A_			,     ):
								super().__init__()

								_UpperCamelCase											=   height
								_UpperCamelCase											=   width
								_UpperCamelCase											=   num_embed
								_UpperCamelCase											=   embed_dim

								_UpperCamelCase											=   nn.Embedding(self.num_embed			,     A_   )
								_UpperCamelCase											=   nn.Embedding(self.height			,     A_   )
								_UpperCamelCase											=   nn.Embedding(self.width			,     A_   )




			def       a	(					self			,     A_   ):
								_UpperCamelCase											=   self.emb(A_   )

								_UpperCamelCase											=   self.height_emb(torch.arange(self.height			,     device=index.device   ).view(1			,     self.height   )   )

								# 1 x H x D -> 1 x H x 1 x D
								_UpperCamelCase											=   height_emb.unsqueeze(2   )

								_UpperCamelCase											=   self.width_emb(torch.arange(self.width			,     device=index.device   ).view(1			,     self.width   )   )

								# 1 x W x D -> 1 x 1 x W x D
								_UpperCamelCase											=   width_emb.unsqueeze(1   )

								_UpperCamelCase											=   height_emb + width_emb

								# 1 x H x W x D -> 1 x L xD
								_UpperCamelCase											=   pos_emb.view(1			,     self.height * self.width			,     -1   )

								_UpperCamelCase											=   emb + pos_emb[:, : emb.shape[1], :]

								return emb




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_			,     A_   ):
								super().__init__()
								_UpperCamelCase											=   dropout_prob > 0
								_UpperCamelCase											=   nn.Embedding(num_classes + use_cfg_embedding			,     A_   )
								_UpperCamelCase											=   num_classes
								_UpperCamelCase											=   dropout_prob




			def       a	(					self			,     A_			,     A_=None   ):
								if force_drop_ids is None:
													_UpperCamelCase											=   torch.rand(labels.shape[0]			,     device=labels.device   ) < self.dropout_prob
								else:
													_UpperCamelCase											=   torch.tensor(force_drop_ids == 1   )
								_UpperCamelCase											=   torch.where(A_			,     self.num_classes			,     A_   )
								return labels




			def       a	(					self			,     A_			,     A_=None   ):
								_UpperCamelCase											=   self.dropout_prob > 0
								if (self.training and use_dropout) or (force_drop_ids is not None):
													_UpperCamelCase											=   self.token_drop(A_			,     A_   )
								_UpperCamelCase											=   self.embedding_table(A_   )
								return embeddings




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_ = 10_24			,     A_ = 7_68			,     A_ = 7_68			,     A_ = 10			,     ):
								super().__init__()

								_UpperCamelCase											=   num_image_text_embeds
								_UpperCamelCase											=   nn.Linear(A_			,     self.num_image_text_embeds * cross_attention_dim   )
								_UpperCamelCase											=   nn.Linear(A_			,     A_   )




			def       a	(					self			,     A_			,     A_   ):
								_UpperCamelCase											=   text_embeds.shape[0]

								# image
								_UpperCamelCase											=   self.image_embeds(A_   )
								_UpperCamelCase											=   image_text_embeds.reshape(A_			,     self.num_image_text_embeds			,     -1   )

								# text
								_UpperCamelCase											=   self.text_proj(A_   )

								return torch.cat([image_text_embeds, text_embeds]			,     dim=1   )




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_ = 7_68			,     A_ = 7_68			,     A_ = 32			,     ):
								super().__init__()

								_UpperCamelCase											=   num_image_text_embeds
								_UpperCamelCase											=   nn.Linear(A_			,     self.num_image_text_embeds * cross_attention_dim   )
								_UpperCamelCase											=   nn.LayerNorm(A_   )




			def       a	(					self			,     A_   ):
								_UpperCamelCase											=   image_embeds.shape[0]

								# image
								_UpperCamelCase											=   self.image_embeds(A_   )
								_UpperCamelCase											=   image_embeds.reshape(A_			,     self.num_image_text_embeds			,     -1   )
								_UpperCamelCase											=   self.norm(A_   )
								return image_embeds




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_			,     A_=0.1   ):
								super().__init__()

								_UpperCamelCase											=   Timesteps(num_channels=2_56			,     flip_sin_to_cos=A_			,     downscale_freq_shift=1   )
								_UpperCamelCase											=   TimestepEmbedding(in_channels=2_56			,     time_embed_dim=A_   )
								_UpperCamelCase											=   LabelEmbedding(A_			,     A_			,     A_   )




			def       a	(					self			,     A_			,     A_			,     A_=None   ):
								_UpperCamelCase											=   self.time_proj(A_   )
								_UpperCamelCase											=   self.timestep_embedder(timesteps_proj.to(dtype=A_   )   )  # (N, D)

								_UpperCamelCase											=   self.class_embedder(A_   )  # (N, D)

								_UpperCamelCase											=   timesteps_emb + class_labels  # (N, D)

								return conditioning




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_			,     A_ = 64   ):
								super().__init__()
								_UpperCamelCase											=   nn.LayerNorm(A_   )
								_UpperCamelCase											=   AttentionPooling(A_			,     A_   )
								_UpperCamelCase											=   nn.Linear(A_			,     A_   )
								_UpperCamelCase											=   nn.LayerNorm(A_   )




			def       a	(					self			,     A_   ):
								_UpperCamelCase											=   self.norma(A_   )
								_UpperCamelCase											=   self.pool(A_   )
								_UpperCamelCase											=   self.proj(A_   )
								_UpperCamelCase											=   self.norma(A_   )
								return hidden_states




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_ = 7_68			,     A_ = 7_68			,     A_ = 15_36   ):
								super().__init__()
								_UpperCamelCase											=   nn.Linear(A_			,     A_   )
								_UpperCamelCase											=   nn.LayerNorm(A_   )
								_UpperCamelCase											=   nn.Linear(A_			,     A_   )




			def       a	(					self			,     A_			,     A_   ):
								# text
								_UpperCamelCase											=   self.text_proj(A_   )
								_UpperCamelCase											=   self.text_norm(A_   )

								# image
								_UpperCamelCase											=   self.image_proj(A_   )

								return time_image_embeds + time_text_embeds




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_ = 7_68			,     A_ = 15_36   ):
								super().__init__()
								_UpperCamelCase											=   nn.Linear(A_			,     A_   )
								_UpperCamelCase											=   nn.LayerNorm(A_   )




			def       a	(					self			,     A_   ):
								# image
								_UpperCamelCase											=   self.image_proj(A_   )
								_UpperCamelCase											=   self.image_norm(A_   )
								return time_image_embeds




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_ = 7_68			,     A_ = 15_36   ):
								super().__init__()
								_UpperCamelCase											=   nn.Linear(A_			,     A_   )
								_UpperCamelCase											=   nn.LayerNorm(A_   )
								_UpperCamelCase											=   nn.Sequential(
								    nn.Convad(3			,     16			,     3			,     padding=1   )			,     nn.SiLU()			,     nn.Convad(16			,     16			,     3			,     padding=1   )			,     nn.SiLU()			,     nn.Convad(16			,     32			,     3			,     padding=1			,     stride=2   )			,     nn.SiLU()			,     nn.Convad(32			,     32			,     3			,     padding=1   )			,     nn.SiLU()			,     nn.Convad(32			,     96			,     3			,     padding=1			,     stride=2   )			,     nn.SiLU()			,     nn.Convad(96			,     96			,     3			,     padding=1   )			,     nn.SiLU()			,     nn.Convad(96			,     2_56			,     3			,     padding=1			,     stride=2   )			,     nn.SiLU()			,     nn.Convad(2_56			,     4			,     3			,     padding=1   )			,     )




			def       a	(					self			,     A_			,     A_   ):
								# image
								_UpperCamelCase											=   self.image_proj(A_   )
								_UpperCamelCase											=   self.image_norm(A_   )
								_UpperCamelCase											=   self.input_hint_block(A_   )
								return time_image_embeds, hint




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_			,     A_=None   ):
								super().__init__()
								_UpperCamelCase											=   dtype
								_UpperCamelCase											=   nn.Parameter(torch.randn(1			,     A_   ) / embed_dim**0.5   )
								_UpperCamelCase											=   nn.Linear(A_			,     A_			,     dtype=self.dtype   )
								_UpperCamelCase											=   nn.Linear(A_			,     A_			,     dtype=self.dtype   )
								_UpperCamelCase											=   nn.Linear(A_			,     A_			,     dtype=self.dtype   )
								_UpperCamelCase											=   num_heads
								_UpperCamelCase											=   embed_dim // self.num_heads




			def       a	(					self			,     A_   ):
								_UpperCamelCase				,	_UpperCamelCase				,	_UpperCamelCase											=   x.size()

								def shape(A_   ):
													# (bs, length, width) --> (bs, length, n_heads, dim_per_head)
													_UpperCamelCase											=   x.view(A_			,     -1			,     self.num_heads			,     self.dim_per_head   )
													# (bs, length, n_heads, dim_per_head) --> (bs, n_heads, length, dim_per_head)
													_UpperCamelCase											=   x.transpose(1			,     2   )
													# (bs, n_heads, length, dim_per_head) --> (bs*n_heads, length, dim_per_head)
													_UpperCamelCase											=   x.reshape(bs * self.num_heads			,     -1			,     self.dim_per_head   )
													# (bs*n_heads, length, dim_per_head) --> (bs*n_heads, dim_per_head, length)
													_UpperCamelCase											=   x.transpose(1			,     2   )
													return x

								_UpperCamelCase											=   x.mean(dim=1			,     keepdim=A_   ) + self.positional_embedding.to(x.dtype   )
								_UpperCamelCase											=   torch.cat([class_token, x]			,     dim=1   )  # (bs, length+1, width)

								# (bs*n_heads, class_token_length, dim_per_head)
								_UpperCamelCase											=   shape(self.q_proj(A_   )   )
								# (bs*n_heads, length+class_token_length, dim_per_head)
								_UpperCamelCase											=   shape(self.k_proj(A_   )   )
								_UpperCamelCase											=   shape(self.v_proj(A_   )   )

								# (bs*n_heads, class_token_length, length+class_token_length):
								_UpperCamelCase											=   1 / math.sqrt(math.sqrt(self.dim_per_head   )   )
								_UpperCamelCase											=   torch.einsum("bct,bcs->bts"			,     q * scale			,     k * scale   )  # More stable with f16 than dividing afterwards
								_UpperCamelCase											=   torch.softmax(weight.float()			,     dim=-1   ).type(weight.dtype   )

								# (bs*n_heads, dim_per_head, class_token_length)
								_UpperCamelCase											=   torch.einsum("bts,bcs->bct"			,     A_			,     A_   )

								# (bs, length+1, width)
								_UpperCamelCase											=   a.reshape(A_			,     -1			,     1   ).transpose(1			,     2   )

								return a[:, 0, :]  # cls_token










'''simple docstring'''



import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
			import torch

if is_vision_available():
			from PIL import Image

			from transformers import SegformerImageProcessor

class     A_ (  unittest.TestCase  ):

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_=7			,     A_=3			,     A_=30			,     A_=4_00			,     A_=True			,     A_=None			,     A_=True			,     A_=[0.5, 0.5, 0.5]			,     A_=[0.5, 0.5, 0.5]			,     A_=False			,     ):
								_UpperCamelCase											=   size if size is not None else {"height": 30, "width": 30}
								_UpperCamelCase											=   parent
								_UpperCamelCase											=   batch_size
								_UpperCamelCase											=   num_channels
								_UpperCamelCase											=   min_resolution
								_UpperCamelCase											=   max_resolution
								_UpperCamelCase											=   do_resize
								_UpperCamelCase											=   size
								_UpperCamelCase											=   do_normalize
								_UpperCamelCase											=   image_mean
								_UpperCamelCase											=   image_std
								_UpperCamelCase											=   do_reduce_labels




			def       a	(					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_reduce_labels": self.do_reduce_labels,
								}




def  lowercase__(		)->   Dict:






					"""simple docstring"""

					_UpperCamelCase											=   load_dataset("hf-internal-testing/fixtures_ade20k" ,   split="test"				)

					_UpperCamelCase											=   Image.open(dataset[0]["file"]				)
					_UpperCamelCase											=   Image.open(dataset[1]["file"]				)

					return image, map



def  lowercase__(		)->   Dict:






					"""simple docstring"""

					_UpperCamelCase											=   load_dataset("hf-internal-testing/fixtures_ade20k" ,   split="test"				)

					_UpperCamelCase											=   Image.open(dataset[0]["file"]				)
					_UpperCamelCase											=   Image.open(dataset[1]["file"]				)
					_UpperCamelCase											=   Image.open(dataset[2]["file"]				)
					_UpperCamelCase											=   Image.open(dataset[3]["file"]				)

					return [imagea, imagea], [mapa, mapa]

@require_torch
@require_vision
class     A_ (  lowerCAmelCase_    ,			unittest.TestCase  ):

			'''simple docstring'''





			_lowerCAmelCase						=    SegformerImageProcessor if is_vision_available() else None




			def       a	(					self   ):
								_UpperCamelCase											=   SegformerImageProcessingTester(self   )




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




			def       a	(					self   ):
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )
								self.assertTrue(hasattr(A_			,     "do_resize"   )   )
								self.assertTrue(hasattr(A_			,     "size"   )   )
								self.assertTrue(hasattr(A_			,     "do_normalize"   )   )
								self.assertTrue(hasattr(A_			,     "image_mean"   )   )
								self.assertTrue(hasattr(A_			,     "image_std"   )   )
								self.assertTrue(hasattr(A_			,     "do_reduce_labels"   )   )




			def       a	(					self   ):
								_UpperCamelCase											=   self.image_processing_class.from_dict(self.image_processor_dict   )
								self.assertEqual(image_processor.size			,     {"height": 30, "width": 30}   )
								self.assertEqual(image_processor.do_reduce_labels			,     A_   )

								_UpperCamelCase											=   self.image_processing_class.from_dict(self.image_processor_dict			,     size=42			,     reduce_labels=A_   )
								self.assertEqual(image_processor.size			,     {"height": 42, "width": 42}   )
								self.assertEqual(image_processor.do_reduce_labels			,     A_   )




			def       a	(					self   ):
								pass




			def       a	(					self   ):
								# Initialize image_processing
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )
								# create random PIL images
								_UpperCamelCase											=   prepare_image_inputs(self.image_processor_tester			,     equal_resolution=A_   )
								for image in image_inputs:
													self.assertIsInstance(A_			,     Image.Image   )

								# Test not batched input
								_UpperCamelCase											=   image_processing(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
								_UpperCamelCase											=   image_processing(A_			,     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       a	(					self   ):
								# Initialize image_processing
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )
								# create random numpy tensors
								_UpperCamelCase											=   prepare_image_inputs(self.image_processor_tester			,     equal_resolution=A_			,     numpify=A_   )
								for image in image_inputs:
													self.assertIsInstance(A_			,     np.ndarray   )

								# Test not batched input
								_UpperCamelCase											=   image_processing(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
								_UpperCamelCase											=   image_processing(A_			,     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       a	(					self   ):
								# Initialize image_processing
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )
								# create random PyTorch tensors
								_UpperCamelCase											=   prepare_image_inputs(self.image_processor_tester			,     equal_resolution=A_			,     torchify=A_   )
								for image in image_inputs:
													self.assertIsInstance(A_			,     torch.Tensor   )

								# Test not batched input
								_UpperCamelCase											=   image_processing(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
								_UpperCamelCase											=   image_processing(A_			,     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       a	(					self   ):
								# Initialize image_processing
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )
								# create random PyTorch tensors
								_UpperCamelCase											=   prepare_image_inputs(self.image_processor_tester			,     equal_resolution=A_			,     torchify=A_   )
								_UpperCamelCase											=   []
								for image in image_inputs:
													self.assertIsInstance(A_			,     torch.Tensor   )
													maps.append(torch.zeros(image.shape[-2:]   ).long()   )

								# Test not batched input
								_UpperCamelCase											=   image_processing(image_inputs[0]			,     maps[0]			,     return_tensors="pt"   )
								self.assertEqual(
								    encoding["pixel_values"].shape			,     (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(
								    encoding["labels"].shape			,     (
								        1,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(encoding["labels"].dtype			,     torch.long   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 2_55   )

								# Test batched
								_UpperCamelCase											=   image_processing(A_			,     A_			,     return_tensors="pt"   )
								self.assertEqual(
								    encoding["pixel_values"].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"],
								    )			,     )
								self.assertEqual(
								    encoding["labels"].shape			,     (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(encoding["labels"].dtype			,     torch.long   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 2_55   )

								# Test not batched input (PIL images)
								_UpperCamelCase				,	_UpperCamelCase											=   prepare_semantic_single_inputs()

								_UpperCamelCase											=   image_processing(A_			,     A_			,     return_tensors="pt"   )
								self.assertEqual(
								    encoding["pixel_values"].shape			,     (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(
								    encoding["labels"].shape			,     (
								        1,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(encoding["labels"].dtype			,     torch.long   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 2_55   )

								# Test batched input (PIL images)
								_UpperCamelCase				,	_UpperCamelCase											=   prepare_semantic_batch_inputs()

								_UpperCamelCase											=   image_processing(A_			,     A_			,     return_tensors="pt"   )
								self.assertEqual(
								    encoding["pixel_values"].shape			,     (
								        2,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(
								    encoding["labels"].shape			,     (
								        2,
								        self.image_processor_tester.size["height"],
								        self.image_processor_tester.size["width"],
								    )			,     )
								self.assertEqual(encoding["labels"].dtype			,     torch.long   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 2_55   )




			def       a	(					self   ):
								# Initialize image_processing
								_UpperCamelCase											=   self.image_processing_class(**self.image_processor_dict   )

								# ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
								_UpperCamelCase				,	_UpperCamelCase											=   prepare_semantic_single_inputs()
								_UpperCamelCase											=   image_processing(A_			,     A_			,     return_tensors="pt"   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 1_50   )

								_UpperCamelCase											=   True
								_UpperCamelCase											=   image_processing(A_			,     A_			,     return_tensors="pt"   )
								self.assertTrue(encoding["labels"].min().item() >= 0   )
								self.assertTrue(encoding["labels"].max().item() <= 2_55   )



