






import collections
import inspect
import unittest

from transformers import FocalNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch
	from torch import nn

	from transformers import (
	    FocalNetBackbone,
	    FocalNetForImageClassification,
	    FocalNetForMaskedImageModeling,
	    FocalNetModel,
	)
	from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor






class 						UpperCAmelCase__ :







		def __init__(					self       ,A__       ,A__=13       ,A__=32       ,A__=2       ,A__=3       ,A__=16       ,A__=[32, 64, 128]       ,A__=[1, 2, 1]       ,A__=[2, 2, 4]       ,A__=2       ,A__=2.0       ,A__=True       ,A__=0.0       ,A__=0.0       ,A__=0.1       ,A__="gelu"       ,A__=False       ,A__=True       ,A__=0.02       ,A__=1E-5       ,A__=True       ,A__=None       ,A__=True       ,A__=10       ,A__=8       ,A__=["stage1", "stage2"]       ,A__=[1, 2]       ,):
						_A	:				Any   =      parent
						_A	:				str   =      batch_size
						_A	:				Optional[int]   =      image_size
						_A	:				Any   =      patch_size
						_A	:				Optional[int]   =      num_channels
						_A	:				Any   =      embed_dim
						_A	:				Dict   =      hidden_sizes
						_A	:				Tuple   =      depths
						_A	:				Union[str, Any]   =      num_heads
						_A	:				Optional[Any]   =      window_size
						_A	:				Union[str, Any]   =      mlp_ratio
						_A	:				Optional[Any]   =      qkv_bias
						_A	:				int   =      hidden_dropout_prob
						_A	:				List[str]   =      attention_probs_dropout_prob
						_A	:				Tuple   =      drop_path_rate
						_A	:				str   =      hidden_act
						_A	:				Tuple   =      use_absolute_embeddings
						_A	:				Any   =      patch_norm
						_A	:				Dict   =      layer_norm_eps
						_A	:				Tuple   =      initializer_range
						_A	:				Any   =      is_training
						_A	:				Union[str, Any]   =      scope
						_A	:				str   =      use_labels
						_A	:				Union[str, Any]   =      type_sequence_label_size
						_A	:				Optional[Any]   =      encoder_stride
						_A	:				List[Any]   =      out_features
						_A	:				Optional[int]   =      out_indices







		def  A__      (					self		):
						_A	:				List[str]   =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

						_A	:				Dict   =      None
						if self.use_labels:
										_A	:				List[str]   =      ids_tensor([self.batch_size]       ,self.type_sequence_label_size		)

						_A	:				Union[str, Any]   =      self.get_config()

						return config, pixel_values, labels







		def  A__      (					self		):
						return FocalNetConfig(
						    image_size=self.image_size       ,patch_size=self.patch_size       ,num_channels=self.num_channels       ,embed_dim=self.embed_dim       ,hidden_sizes=self.hidden_sizes       ,depths=self.depths       ,num_heads=self.num_heads       ,window_size=self.window_size       ,mlp_ratio=self.mlp_ratio       ,qkv_bias=self.qkv_bias       ,hidden_dropout_prob=self.hidden_dropout_prob       ,attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,drop_path_rate=self.drop_path_rate       ,hidden_act=self.hidden_act       ,use_absolute_embeddings=self.use_absolute_embeddings       ,path_norm=self.patch_norm       ,layer_norm_eps=self.layer_norm_eps       ,initializer_range=self.initializer_range       ,encoder_stride=self.encoder_stride       ,out_features=self.out_features       ,out_indices=self.out_indices       ,)







		def  A__      (					self       ,A__       ,A__       ,A__		):
						_A	:				Optional[int]   =      FocalNetModel(config=__SCREAMING_SNAKE_CASE		)
						model.to(__SCREAMING_SNAKE_CASE		)
						model.eval()
						_A	:				Dict   =      model(__SCREAMING_SNAKE_CASE		)

						_A	:				int   =      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths		) - 1))
						_A	:				Dict   =      int(config.embed_dim * 2 ** (len(config.depths		) - 1)		)

						self.parent.assertEqual(result.last_hidden_state.shape       ,(self.batch_size, expected_seq_len, expected_dim)		)







		def  A__      (					self       ,A__       ,A__       ,A__		):
						_A	:				int   =      FocalNetBackbone(config=__SCREAMING_SNAKE_CASE		)
						model.to(__SCREAMING_SNAKE_CASE		)
						model.eval()
						_A	:				Any   =      model(__SCREAMING_SNAKE_CASE		)

						# verify feature maps
						self.parent.assertEqual(len(result.feature_maps		)       ,len(config.out_features		)		)
						self.parent.assertListEqual(list(result.feature_maps[0].shape		)       ,[self.batch_size, self.image_size, 8, 8]		)

						# verify channels
						self.parent.assertEqual(len(model.channels		)       ,len(config.out_features		)		)
						self.parent.assertListEqual(model.channels       ,config.hidden_sizes[:-1]		)

						# verify backbone works with out_features=None
						_A	:				List[str]   =      None
						_A	:				str   =      FocalNetBackbone(config=__SCREAMING_SNAKE_CASE		)
						model.to(__SCREAMING_SNAKE_CASE		)
						model.eval()
						_A	:				Any   =      model(__SCREAMING_SNAKE_CASE		)

						# verify feature maps
						self.parent.assertEqual(len(result.feature_maps		)       ,1		)
						self.parent.assertListEqual(list(result.feature_maps[0].shape		)       ,[self.batch_size, self.image_size * 2, 4, 4]		)

						# verify channels
						self.parent.assertEqual(len(model.channels		)       ,1		)
						self.parent.assertListEqual(model.channels       ,[config.hidden_sizes[-1]]		)







		def  A__      (					self       ,A__       ,A__       ,A__		):
						_A	:				Union[str, Any]   =      FocalNetForMaskedImageModeling(config=__SCREAMING_SNAKE_CASE		)
						model.to(__SCREAMING_SNAKE_CASE		)
						model.eval()
						_A	:				List[Any]   =      model(__SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(
						    result.reconstruction.shape       ,(self.batch_size, self.num_channels, self.image_size, self.image_size)		)

						# test greyscale images
						_A	:				str   =      1
						_A	:				Any   =      FocalNetForMaskedImageModeling(__SCREAMING_SNAKE_CASE		)
						model.to(__SCREAMING_SNAKE_CASE		)
						model.eval()

						_A	:				List[str]   =      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]		)
						_A	:				Optional[int]   =      model(__SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.reconstruction.shape       ,(self.batch_size, 1, self.image_size, self.image_size)		)







		def  A__      (					self       ,A__       ,A__       ,A__		):
						_A	:				Dict   =      self.type_sequence_label_size
						_A	:				Any   =      FocalNetForImageClassification(__SCREAMING_SNAKE_CASE		)
						model.to(__SCREAMING_SNAKE_CASE		)
						model.eval()
						_A	:				List[Any]   =      model(__SCREAMING_SNAKE_CASE       ,labels=__SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.type_sequence_label_size)		)

						# test greyscale images
						_A	:				Union[str, Any]   =      1
						_A	:				Any   =      FocalNetForImageClassification(__SCREAMING_SNAKE_CASE		)
						model.to(__SCREAMING_SNAKE_CASE		)
						model.eval()

						_A	:				Dict   =      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]		)
						_A	:				Union[str, Any]   =      model(__SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.type_sequence_label_size)		)







		def  A__      (					self		):
						_A	:				Optional[int]   =      self.prepare_config_and_inputs()

						_A	:				List[str]   =      config_and_inputs
						_A	:				Union[str, Any]   =      {'''pixel_values''': pixel_values}
						return config, inputs_dict






@require_torch
class 						UpperCAmelCase__ (							SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_     ,				unittest.TestCase							):
		__snake_case      :       Union[str, Any]     =   (
		    (
		        FocalNetModel,
		        FocalNetForImageClassification,
		        FocalNetForMaskedImageModeling,
		        FocalNetBackbone,
		    )
		    if is_torch_available()
		    else ()
		)
		__snake_case      :       int     =   (
		    {"feature-extraction": FocalNetModel, "image-classification": FocalNetForImageClassification}
		    if is_torch_available()
		    else {}
		)
		__snake_case      :       Tuple     =   False

		__snake_case      :       Optional[int]     =   False
		__snake_case      :       List[str]     =   False
		__snake_case      :       Optional[int]     =   False
		__snake_case      :       Optional[Any]     =   False







		def  A__      (					self		):
						_A	:				Tuple   =      FocalNetModelTester(self		)
						_A	:				int   =      ConfigTester(self       ,config_class=__SCREAMING_SNAKE_CASE       ,embed_dim=37       ,has_text_modality=__SCREAMING_SNAKE_CASE		)







		def  A__      (					self		):
						self.create_and_test_config_common_properties()
						self.config_tester.create_and_test_config_to_json_string()
						self.config_tester.create_and_test_config_to_json_file()
						self.config_tester.create_and_test_config_from_and_save_pretrained()
						self.config_tester.create_and_test_config_with_num_labels()
						self.config_tester.check_config_can_be_init_without_params()
						self.config_tester.check_config_arguments_init()







		def  A__      (					self		):
						return







		def  A__      (					self		):
						_A	:				Dict   =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE		)







		def  A__      (					self		):
						_A	:				Tuple   =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE		)







		def  A__      (					self		):
						_A	:				Any   =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE		)







		def  A__      (					self		):
						_A	:				Union[str, Any]   =      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE		)







		@unittest.skip(reason='''FocalNet does not use inputs_embeds'''		)
		def  A__      (					self		):
						pass







		@unittest.skip(reason='''FocalNet does not use feedforward chunking'''		)
		def  A__      (					self		):
						pass







		def  A__      (					self		):
						_A	:				Any   =      self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes[:-1]:
										_A	:				List[str]   =      model_class(__SCREAMING_SNAKE_CASE		)
										self.assertIsInstance(model.get_input_embeddings()       ,(nn.Module)		)
										_A	:				List[str]   =      model.get_output_embeddings()
										self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE       ,nn.Linear		)		)







		def  A__      (					self		):
						_A	:				int   =      self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes[:-1]:
										_A	:				Optional[Any]   =      model_class(__SCREAMING_SNAKE_CASE		)
										_A	:				Optional[Any]   =      inspect.signature(model.forward		)
										# signature.parameters is an OrderedDict => so arg_names order is deterministic
										_A	:				Union[str, Any]   =      [*signature.parameters.keys()]

										_A	:				Any   =      ['''pixel_values''']
										self.assertListEqual(arg_names[:1]       ,__SCREAMING_SNAKE_CASE		)







		def  A__      (					self       ,A__       ,A__       ,A__       ,A__		):
						_A	:				int   =      model_class(__SCREAMING_SNAKE_CASE		)
						model.to(__SCREAMING_SNAKE_CASE		)
						model.eval()

						with torch.no_grad():
										_A	:				int   =      model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE		)		)

						_A	:				List[Any]   =      outputs.hidden_states

						_A	:				int   =      getattr(
						    self.model_tester       ,'''expected_num_hidden_layers'''       ,len(self.model_tester.depths		) + 1		)
						self.assertEqual(len(__SCREAMING_SNAKE_CASE		)       ,__SCREAMING_SNAKE_CASE		)

						# FocalNet has a different seq_length
						_A	:				Union[str, Any]   =      (
						    config.patch_size
						    if isinstance(config.patch_size       ,collections.abc.Iterable		)
						    else (config.patch_size, config.patch_size)
						)

						_A	:				Tuple   =      (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

						self.assertListEqual(
						    list(hidden_states[0].shape[-2:]		)       ,[num_patches, self.model_tester.embed_dim]       ,)

						_A	:				List[Any]   =      outputs.reshaped_hidden_states
						self.assertEqual(len(__SCREAMING_SNAKE_CASE		)       ,__SCREAMING_SNAKE_CASE		)

						_A	:				Dict   =      reshaped_hidden_states[0].shape
						_A	:				str   =      (
						    reshaped_hidden_states[0].view(__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,height * width		).permute(0       ,2       ,1		)
						)
						self.assertListEqual(
						    list(reshaped_hidden_states.shape[-2:]		)       ,[num_patches, self.model_tester.embed_dim]       ,)







		def  A__      (					self		):
						_A	:				Optional[Any]   =      self.model_tester.prepare_config_and_inputs_for_common()

						_A	:				Any   =      (
						    self.model_tester.image_size
						    if isinstance(self.model_tester.image_size       ,collections.abc.Iterable		)
						    else (self.model_tester.image_size, self.model_tester.image_size)
						)

						for model_class in self.all_model_classes[:-1]:
										_A	:				Optional[int]   =      True
										self.check_hidden_states_output(__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE		)

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										_A	:				Tuple   =      True

										self.check_hidden_states_output(__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE		)







		def  A__      (					self		):
						_A	:				Union[str, Any]   =      self.model_tester.prepare_config_and_inputs_for_common()
						_A	:				Union[str, Any]   =      3

						_A	:				Tuple   =      (
						    self.model_tester.image_size
						    if isinstance(self.model_tester.image_size       ,collections.abc.Iterable		)
						    else (self.model_tester.image_size, self.model_tester.image_size)
						)
						_A	:				Dict   =      (
						    config.patch_size
						    if isinstance(config.patch_size       ,collections.abc.Iterable		)
						    else (config.patch_size, config.patch_size)
						)

						_A	:				Optional[int]   =      image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
						_A	:				Optional[int]   =      image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

						for model_class in self.all_model_classes[:-1]:
										_A	:				Optional[Any]   =      True
										self.check_hidden_states_output(__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,(padded_height, padded_width)		)

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										_A	:				Dict   =      True
										self.check_hidden_states_output(__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,(padded_height, padded_width)		)







		@slow
		def  A__      (					self		):
						for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										_A	:				Optional[Any]   =      FocalNetModel.from_pretrained(__SCREAMING_SNAKE_CASE		)
										self.assertIsNotNone(__SCREAMING_SNAKE_CASE		)







		def  A__      (					self		):
						_A	:				Any   =      self.model_tester.prepare_config_and_inputs_for_common()

						_A	:				Optional[Any]   =      _config_zero_init(__SCREAMING_SNAKE_CASE		)
						for model_class in self.all_model_classes:
										_A	:				Optional[int]   =      model_class(config=__SCREAMING_SNAKE_CASE		)
										for name, param in model.named_parameters():
														if "embeddings" not in name and param.requires_grad:
																		self.assertIn(
																		    ((param.data.mean() * 1E9).round() / 1E9).item()       ,[0.0, 1.0]       ,msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""       ,)






@require_vision
@require_torch
class 						UpperCAmelCase__ (							unittest.TestCase							):







		@cached_property
		def  A__      (					self		):
						# TODO update organization
						return AutoImageProcessor.from_pretrained('''microsoft/focalnet-tiny'''		) if is_vision_available() else None







		@slow
		def  A__      (					self		):
						_A	:				Optional[Any]   =      FocalNetForImageClassification.from_pretrained('''microsoft/focalnet-tiny'''		).to(__SCREAMING_SNAKE_CASE		)
						_A	:				List[str]   =      self.default_image_processor

						_A	:				Union[str, Any]   =      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
						_A	:				int   =      image_processor(images=__SCREAMING_SNAKE_CASE       ,return_tensors='''pt'''		).to(__SCREAMING_SNAKE_CASE		)

						# forward pass
						with torch.no_grad():
										_A	:				Any   =      model(**__SCREAMING_SNAKE_CASE		)

						# verify the logits
						_A	:				Union[str, Any]   =      torch.Size((1, 1000)		)
						self.assertEqual(outputs.logits.shape       ,__SCREAMING_SNAKE_CASE		)
						_A	:				Dict   =      torch.tensor([0.21_66, -0.43_68, 0.21_91]		).to(__SCREAMING_SNAKE_CASE		)
						self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,__SCREAMING_SNAKE_CASE       ,atol=1E-4		)		)
						self.assertTrue(outputs.logits.argmax(dim=-1		).item()       ,281		)






@require_torch
class 						UpperCAmelCase__ (							SCREAMING_SNAKE_CASE_     ,				unittest.TestCase							):
		__snake_case      :       Optional[int]     =   (FocalNetBackbone,) if is_torch_available() else ()
		__snake_case      :       List[Any]     =   FocalNetConfig

		__snake_case      :       Any     =   False







		def  A__      (					self		):
						_A	:				Any   =      FocalNetModelTester(self		)











'''simple docstring'''







import json
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

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 transformers import OneFormerImageProcessor
				from transformers.models.oneformer.image_processing_oneformer import binary_mask_to_rle
				from transformers.models.oneformer.modeling_oneformer import OneFormerForUniversalSegmentationOutput

if is_vision_available():
		from PIL import Image





def 		_UpperCAmelCase (				__A				: int    ,		__A				: Tuple="shi-labs/oneformer_demo"   ):
				with open(hf_hub_download(__A    ,		__A    ,		repo_type='''dataset'''   )    ,		'''r'''   ) as f:
								a_		:	Optional[Any]									=   json.load(__A   )
				a_		:	List[Any]									=   {}
				a_		:	List[Any]									=   []
				a_		:	Tuple									=   []
				for key, info in class_info.items():
								a_		:	Tuple									=   info['''name''']
								class_names.append(info['''name''']   )
								if info["isthing"]:
												thing_ids.append(int(__A   )   )
				a_		:	Optional[Any]									=   thing_ids
				a_		:	str									=   class_names
				return metadata





class 						SCREAMING_SNAKE_CASE       (       unittest.TestCase							):






			def __init__(			self   :      Tuple	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      List[str]=7	,    __SCREAMING_SNAKE_CASE   :      List[Any]=3	,    __SCREAMING_SNAKE_CASE   :      List[Any]=30	,    __SCREAMING_SNAKE_CASE   :      str=400	,    __SCREAMING_SNAKE_CASE   :      List[str]=None	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]=True	,    __SCREAMING_SNAKE_CASE   :      List[Any]=True	,    __SCREAMING_SNAKE_CASE   :      str=[0.5, 0.5, 0.5]	,    __SCREAMING_SNAKE_CASE   :      Optional[int]=[0.5, 0.5, 0.5]	,    __SCREAMING_SNAKE_CASE   :      Optional[int]=10	,    __SCREAMING_SNAKE_CASE   :      int=False	,    __SCREAMING_SNAKE_CASE   :      Optional[int]=255	,    __SCREAMING_SNAKE_CASE   :      List[Any]="shi-labs/oneformer_demo"	,    __SCREAMING_SNAKE_CASE   :      List[str]="ade20k_panoptic.json"	,    __SCREAMING_SNAKE_CASE   :      List[Any]=10	,    )      ->      Dict:
							a_		:	int									=   parent
							a_		:	Optional[Any]									=   batch_size
							a_		:	str									=   num_channels
							a_		:	Tuple									=   min_resolution
							a_		:	List[Any]									=   max_resolution
							a_		:	List[Any]									=   do_resize
							a_		:	Union[str, Any]									=   {'''shortest_edge''': 32, '''longest_edge''': 1333} if size is None else size
							a_		:	Dict									=   do_normalize
							a_		:	Union[str, Any]									=   image_mean
							a_		:	Dict									=   image_std
							a_		:	int									=   class_info_file
							a_		:	List[Any]									=   prepare_metadata(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       )
							a_		:	Optional[int]									=   num_text
							a_		:	Any									=   repo_path

							# for the post_process_functions
							a_		:	List[str]									=   2
							a_		:	Tuple									=   10
							a_		:	Union[str, Any]									=   10
							a_		:	Dict									=   3
							a_		:	int									=   4
							a_		:	Optional[Any]									=   num_labels
							a_		:	Union[str, Any]									=   do_reduce_labels
							a_		:	Tuple									=   ignore_index






			def       SCREAMING_SNAKE_CASE   (			self   :      str       )      ->      int:
							return {
							    "do_resize": self.do_resize,
							    "size": self.size,
							    "do_normalize": self.do_normalize,
							    "image_mean": self.image_mean,
							    "image_std": self.image_std,
							    "num_labels": self.num_labels,
							    "do_reduce_labels": self.do_reduce_labels,
							    "ignore_index": self.ignore_index,
							    "class_info_file": self.class_info_file,
							    "metadata": self.metadata,
							    "num_text": self.num_text,
							}






			def       SCREAMING_SNAKE_CASE   (			self   :      Tuple	,    __SCREAMING_SNAKE_CASE   :      Any	,    __SCREAMING_SNAKE_CASE   :      List[str]=False       )      ->      Optional[Any]:
							if not batched:
											a_		:	List[Any]									=   image_inputs[0]
											if isinstance(__SCREAMING_SNAKE_CASE	,    Image.Image       ):
															a_					,      a_		:	List[str]									=   image.size
											else:
															a_					,      a_		:	Any									=   image.shape[1], image.shape[2]
											if w < h:
															a_		:	int									=   int(self.size['''shortest_edge'''] * h / w       )
															a_		:	Union[str, Any]									=   self.size['''shortest_edge''']
											elif w > h:
															a_		:	Any									=   self.size['''shortest_edge''']
															a_		:	Any									=   int(self.size['''shortest_edge'''] * w / h       )
											else:
															a_		:	Optional[int]									=   self.size['''shortest_edge''']
															a_		:	int									=   self.size['''shortest_edge''']

							else:
											a_		:	int									=   []
											for image in image_inputs:
															a_					,      a_		:	List[str]									=   self.get_expected_values([image]       )
															expected_values.append((expected_height, expected_width)       )
											a_		:	List[str]									=   max(__SCREAMING_SNAKE_CASE	,    key=lambda __SCREAMING_SNAKE_CASE       : item[0]       )[0]
											a_		:	str									=   max(__SCREAMING_SNAKE_CASE	,    key=lambda __SCREAMING_SNAKE_CASE       : item[1]       )[1]

							return expected_height, expected_width







			def       SCREAMING_SNAKE_CASE   (			self   :      Dict       )      ->      List[str]:
							return OneFormerForUniversalSegmentationOutput(
							    # +1 for null class
							    class_queries_logits=torch.randn((self.batch_size, self.num_queries, self.num_classes + 1)       )	,    masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)       )	,    )





@require_torch
@require_vision
class 						SCREAMING_SNAKE_CASE       (       SCREAMING_SNAKE_CASE_						, unittest.TestCase							):
			snake_case__	=					OneFormerImageProcessor if (is_vision_available() and is_torch_available()) else None
			# only for test_image_processing_common.test_image_proc_to_json_string
			snake_case__	=					image_processing_class






			def       SCREAMING_SNAKE_CASE   (			self   :      str       )      ->      List[str]:
							a_		:	Optional[int]									=   OneFormerImageProcessorTester(self       )






			@property
			def       SCREAMING_SNAKE_CASE   (			self   :      Optional[Any]       )      ->      Any:
							return self.image_processing_tester.prepare_image_processor_dict()






			def       SCREAMING_SNAKE_CASE   (			self   :      List[str]       )      ->      Dict:
							a_		:	List[Any]									=   self.image_processing_class(**self.image_processor_dict       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''image_mean'''       )       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''image_std'''       )       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''do_normalize'''       )       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''do_resize'''       )       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''size'''       )       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''ignore_index'''       )       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''class_info_file'''       )       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''num_text'''       )       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''repo_path'''       )       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''metadata'''       )       )
							self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,    '''do_reduce_labels'''       )       )






			def       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]       )      ->      str:
							pass






			def       SCREAMING_SNAKE_CASE   (			self   :      List[Any]       )      ->      Tuple:
							# Initialize image_processor
							a_		:	Union[str, Any]									=   self.image_processing_class(**self.image_processor_dict       )
							# create random PIL images
							a_		:	Optional[int]									=   prepare_image_inputs(self.image_processing_tester	,    equal_resolution=__SCREAMING_SNAKE_CASE       )
							for image in image_inputs:
											self.assertIsInstance(__SCREAMING_SNAKE_CASE	,    Image.Image       )

							# Test not batched input
							a_		:	Dict									=   image_processor(image_inputs[0]	,    ['''semantic''']	,    return_tensors='''pt'''       ).pixel_values

							a_					,      a_		:	Optional[int]									=   self.image_processing_tester.get_expected_values(__SCREAMING_SNAKE_CASE       )

							self.assertEqual(
							    encoded_images.shape	,    (1, self.image_processing_tester.num_channels, expected_height, expected_width)	,    )

							# Test batched
							a_					,      a_		:	Union[str, Any]									=   self.image_processing_tester.get_expected_values(__SCREAMING_SNAKE_CASE	,    batched=__SCREAMING_SNAKE_CASE       )

							a_		:	Any									=   image_processor(
							    __SCREAMING_SNAKE_CASE	,    ['''semantic'''] * len(__SCREAMING_SNAKE_CASE       )	,    return_tensors='''pt'''       ).pixel_values
							self.assertEqual(
							    encoded_images.shape	,    (
							        self.image_processing_tester.batch_size,
							        self.image_processing_tester.num_channels,
							        expected_height,
							        expected_width,
							    )	,    )






			def       SCREAMING_SNAKE_CASE   (			self   :      List[Any]       )      ->      str:
							# Initialize image_processor
							a_		:	Dict									=   self.image_processing_class(**self.image_processor_dict       )
							# create random numpy tensors
							a_		:	Tuple									=   prepare_image_inputs(self.image_processing_tester	,    equal_resolution=__SCREAMING_SNAKE_CASE	,    numpify=__SCREAMING_SNAKE_CASE       )
							for image in image_inputs:
											self.assertIsInstance(__SCREAMING_SNAKE_CASE	,    np.ndarray       )

							# Test not batched input
							a_		:	List[Any]									=   image_processor(image_inputs[0]	,    ['''semantic''']	,    return_tensors='''pt'''       ).pixel_values

							a_					,      a_		:	Union[str, Any]									=   self.image_processing_tester.get_expected_values(__SCREAMING_SNAKE_CASE       )

							self.assertEqual(
							    encoded_images.shape	,    (1, self.image_processing_tester.num_channels, expected_height, expected_width)	,    )

							# Test batched
							a_					,      a_		:	Union[str, Any]									=   self.image_processing_tester.get_expected_values(__SCREAMING_SNAKE_CASE	,    batched=__SCREAMING_SNAKE_CASE       )

							a_		:	Tuple									=   image_processor(
							    __SCREAMING_SNAKE_CASE	,    ['''semantic'''] * len(__SCREAMING_SNAKE_CASE       )	,    return_tensors='''pt'''       ).pixel_values
							self.assertEqual(
							    encoded_images.shape	,    (
							        self.image_processing_tester.batch_size,
							        self.image_processing_tester.num_channels,
							        expected_height,
							        expected_width,
							    )	,    )






			def       SCREAMING_SNAKE_CASE   (			self   :      int       )      ->      int:
							# Initialize image_processor
							a_		:	str									=   self.image_processing_class(**self.image_processor_dict       )
							# create random PyTorch tensors
							a_		:	Tuple									=   prepare_image_inputs(self.image_processing_tester	,    equal_resolution=__SCREAMING_SNAKE_CASE	,    torchify=__SCREAMING_SNAKE_CASE       )
							for image in image_inputs:
											self.assertIsInstance(__SCREAMING_SNAKE_CASE	,    torch.Tensor       )

							# Test not batched input
							a_		:	str									=   image_processor(image_inputs[0]	,    ['''semantic''']	,    return_tensors='''pt'''       ).pixel_values

							a_					,      a_		:	int									=   self.image_processing_tester.get_expected_values(__SCREAMING_SNAKE_CASE       )

							self.assertEqual(
							    encoded_images.shape	,    (1, self.image_processing_tester.num_channels, expected_height, expected_width)	,    )

							# Test batched
							a_					,      a_		:	Tuple									=   self.image_processing_tester.get_expected_values(__SCREAMING_SNAKE_CASE	,    batched=__SCREAMING_SNAKE_CASE       )

							a_		:	int									=   image_processor(
							    __SCREAMING_SNAKE_CASE	,    ['''semantic'''] * len(__SCREAMING_SNAKE_CASE       )	,    return_tensors='''pt'''       ).pixel_values
							self.assertEqual(
							    encoded_images.shape	,    (
							        self.image_processing_tester.batch_size,
							        self.image_processing_tester.num_channels,
							        expected_height,
							        expected_width,
							    )	,    )






			def       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      List[Any]=False	,    __SCREAMING_SNAKE_CASE   :      Optional[int]=False	,    __SCREAMING_SNAKE_CASE   :      str="np"       )      ->      Any:
							a_		:	Dict									=   self.image_processing_class(**self.image_processor_dict       )
							# prepare image and target
							a_		:	Optional[Any]									=   self.image_processing_tester.num_labels
							a_		:	Union[str, Any]									=   None
							a_		:	int									=   None
							a_		:	Dict									=   prepare_image_inputs(self.image_processing_tester	,    equal_resolution=__SCREAMING_SNAKE_CASE       )
							if with_segmentation_maps:
											a_		:	List[str]									=   num_labels
											if is_instance_map:
															a_		:	str									=   list(range(__SCREAMING_SNAKE_CASE       )       ) * 2
															a_		:	str									=   dict(enumerate(__SCREAMING_SNAKE_CASE       )       )
											a_		:	List[str]									=   [
											    np.random.randint(0	,    high * 2	,    (img.size[1], img.size[0])       ).astype(np.uinta       ) for img in image_inputs
											]
											if segmentation_type == "pil":
															a_		:	Any									=   [Image.fromarray(__SCREAMING_SNAKE_CASE       ) for annotation in annotations]

							a_		:	Dict									=   image_processor(
							    __SCREAMING_SNAKE_CASE	,    ['''semantic'''] * len(__SCREAMING_SNAKE_CASE       )	,    __SCREAMING_SNAKE_CASE	,    return_tensors='''pt'''	,    instance_id_to_semantic_id=__SCREAMING_SNAKE_CASE	,    pad_and_return_pixel_mask=__SCREAMING_SNAKE_CASE	,    )

							return inputs






			def       SCREAMING_SNAKE_CASE   (			self   :      List[str]       )      ->      Optional[Any]:
							pass






			def       SCREAMING_SNAKE_CASE   (			self   :      Dict       )      ->      List[str]:
							def common(__SCREAMING_SNAKE_CASE   :      int=False	,    __SCREAMING_SNAKE_CASE   :      List[str]=None       ):
											a_		:	Tuple									=   self.comm_get_image_processor_inputs(
											    with_segmentation_maps=__SCREAMING_SNAKE_CASE	,    is_instance_map=__SCREAMING_SNAKE_CASE	,    segmentation_type=__SCREAMING_SNAKE_CASE       )

											a_		:	List[Any]									=   inputs['''mask_labels''']
											a_		:	Any									=   inputs['''class_labels''']
											a_		:	Any									=   inputs['''pixel_values''']
											a_		:	Optional[Any]									=   inputs['''text_inputs''']

											# check the batch_size
											for mask_label, class_label, text_input in zip(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       ):
															self.assertEqual(mask_label.shape[0]	,    class_label.shape[0]       )
															# this ensure padding has happened
															self.assertEqual(mask_label.shape[1:]	,    pixel_values.shape[2:]       )
															self.assertEqual(len(__SCREAMING_SNAKE_CASE       )	,    self.image_processing_tester.num_text       )

							common()
							common(is_instance_map=__SCREAMING_SNAKE_CASE       )
							common(is_instance_map=__SCREAMING_SNAKE_CASE	,    segmentation_type='''pil'''       )
							common(is_instance_map=__SCREAMING_SNAKE_CASE	,    segmentation_type='''pil'''       )






			def       SCREAMING_SNAKE_CASE   (			self   :      Dict       )      ->      str:
							a_		:	int									=   np.zeros((20, 50)       )
							a_		:	Dict									=   1
							a_		:	Optional[Any]									=   1
							a_		:	Dict									=   1

							a_		:	Tuple									=   binary_mask_to_rle(__SCREAMING_SNAKE_CASE       )
							self.assertEqual(len(__SCREAMING_SNAKE_CASE       )	,    4       )
							self.assertEqual(rle[0]	,    21       )
							self.assertEqual(rle[1]	,    45       )






			def       SCREAMING_SNAKE_CASE   (			self   :      Optional[int]       )      ->      int:
							a_		:	List[str]									=   self.image_processing_class(
							    num_labels=self.image_processing_tester.num_classes	,    max_seq_length=77	,    task_seq_length=77	,    class_info_file='''ade20k_panoptic.json'''	,    num_text=self.image_processing_tester.num_text	,    repo_path='''shi-labs/oneformer_demo'''	,    )
							a_		:	Any									=   self.image_processing_tester.get_fake_oneformer_outputs()

							a_		:	str									=   fature_extractor.post_process_semantic_segmentation(__SCREAMING_SNAKE_CASE       )

							self.assertEqual(len(__SCREAMING_SNAKE_CASE       )	,    self.image_processing_tester.batch_size       )
							self.assertEqual(
							    segmentation[0].shape	,    (
							        self.image_processing_tester.height,
							        self.image_processing_tester.width,
							    )	,    )

							a_		:	Dict									=   [(1, 4) for i in range(self.image_processing_tester.batch_size       )]
							a_		:	List[str]									=   fature_extractor.post_process_semantic_segmentation(__SCREAMING_SNAKE_CASE	,    target_sizes=__SCREAMING_SNAKE_CASE       )

							self.assertEqual(segmentation[0].shape	,    target_sizes[0]       )






			def       SCREAMING_SNAKE_CASE   (			self   :      str       )      ->      Dict:
							a_		:	Optional[Any]									=   self.image_processing_class(
							    num_labels=self.image_processing_tester.num_classes	,    max_seq_length=77	,    task_seq_length=77	,    class_info_file='''ade20k_panoptic.json'''	,    num_text=self.image_processing_tester.num_text	,    repo_path='''shi-labs/oneformer_demo'''	,    )
							a_		:	Optional[int]									=   self.image_processing_tester.get_fake_oneformer_outputs()
							a_		:	Tuple									=   image_processor.post_process_instance_segmentation(__SCREAMING_SNAKE_CASE	,    threshold=0       )

							self.assertTrue(len(__SCREAMING_SNAKE_CASE       ) == self.image_processing_tester.batch_size       )
							for el in segmentation:
											self.assertTrue('''segmentation''' in el       )
											self.assertTrue('''segments_info''' in el       )
											self.assertEqual(type(el['''segments_info''']       )	,    __SCREAMING_SNAKE_CASE       )
											self.assertEqual(
											    el['''segmentation'''].shape	,    (self.image_processing_tester.height, self.image_processing_tester.width)       )







			def       SCREAMING_SNAKE_CASE   (			self   :      int       )      ->      Union[str, Any]:
							a_		:	List[Any]									=   self.image_processing_class(
							    num_labels=self.image_processing_tester.num_classes	,    max_seq_length=77	,    task_seq_length=77	,    class_info_file='''ade20k_panoptic.json'''	,    num_text=self.image_processing_tester.num_text	,    repo_path='''shi-labs/oneformer_demo'''	,    )
							a_		:	int									=   self.image_processing_tester.get_fake_oneformer_outputs()
							a_		:	str									=   image_processor.post_process_panoptic_segmentation(__SCREAMING_SNAKE_CASE	,    threshold=0       )

							self.assertTrue(len(__SCREAMING_SNAKE_CASE       ) == self.image_processing_tester.batch_size       )
							for el in segmentation:
											self.assertTrue('''segmentation''' in el       )
											self.assertTrue('''segments_info''' in el       )
											self.assertEqual(type(el['''segments_info''']       )	,    __SCREAMING_SNAKE_CASE       )
											self.assertEqual(
											    el['''segmentation'''].shape	,    (self.image_processing_tester.height, self.image_processing_tester.width)       )




