
import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
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 DeformableDetrImageProcessor


class 		__magic_name__ (    unittest.TestCase     ):





		def __init__(				self     :						Optional[int]    ,	lowerCamelCase__     :						int    ,	lowerCamelCase__     :						Dict=7    ,	lowerCamelCase__     :						Optional[Any]=3    ,	lowerCamelCase__     :						int=3_0    ,	lowerCamelCase__     :						Any=4_0_0    ,	lowerCamelCase__     :						Union[str, Any]=True    ,	lowerCamelCase__     :						Optional[int]=None    ,	lowerCamelCase__     :						Any=True    ,	lowerCamelCase__     :						Any=[0.5, 0.5, 0.5]    ,	lowerCamelCase__     :						Dict=[0.5, 0.5, 0.5]    ,	lowerCamelCase__     :						Optional[int]=True    ,	lowerCamelCase__     :						int=1 / 2_5_5    ,	lowerCamelCase__     :						Tuple=True    ,	):
							lowerCAmelCase		:       List[Any]							=  size if size is not None else {'''shortest_edge''': 1_8, '''longest_edge''': 1_3_3_3}
							lowerCAmelCase		:       List[str]							=  parent
							lowerCAmelCase		:       int							=  batch_size
							lowerCAmelCase		:       str							=  num_channels
							lowerCAmelCase		:       int							=  min_resolution
							lowerCAmelCase		:       int							=  max_resolution
							lowerCAmelCase		:       Optional[Any]							=  do_resize
							lowerCAmelCase		:       Tuple							=  size
							lowerCAmelCase		:       Dict							=  do_normalize
							lowerCAmelCase		:       List[Any]							=  image_mean
							lowerCAmelCase		:       Optional[Any]							=  image_std
							lowerCAmelCase		:       Optional[Any]							=  do_rescale
							lowerCAmelCase		:       Dict							=  rescale_factor
							lowerCAmelCase		:       Any							=  do_pad





		def    _A				(				self     :						Tuple					):
							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_rescale": self.do_rescale,
							    "rescale_factor": self.rescale_factor,
							    "do_pad": self.do_pad,
							}





		def    _A				(				self     :						Optional[Any]    ,	lowerCamelCase__     :						Dict    ,	lowerCamelCase__     :						List[Any]=False					):

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

							else:
												lowerCAmelCase		:       Union[str, Any]							=  []
												for image in image_inputs:
																	lowerCAmelCase						,				lowerCAmelCase		:       List[Any]							=  self.get_expected_values([image]					)
																	expected_values.append((expected_height, expected_width)					)
												lowerCAmelCase		:       Optional[int]							=  max(lowerCamelCase__    ,	key=lambda lowerCamelCase__					: item[0]					)[0]
												lowerCAmelCase		:       Tuple							=  max(lowerCamelCase__    ,	key=lambda lowerCamelCase__					: item[1]					)[1]

							return expected_height, expected_width



@require_torch
@require_vision
class 		__magic_name__ (    _snake_case,					unittest.TestCase     ):
		_lowerCAmelCase		=						DeformableDetrImageProcessor if is_vision_available() else None





		def    _A				(				self     :						Any					):
							lowerCAmelCase		:       Dict							=  DeformableDetrImageProcessingTester(self					)





		@property
		def    _A				(				self     :						List[str]					):
							return self.image_processor_tester.prepare_image_processor_dict()





		def    _A				(				self     :						List[Any]					):
							lowerCAmelCase		:       List[str]							=  self.image_processing_class(**self.image_processor_dict					)
							self.assertTrue(hasattr(lowerCamelCase__    ,	'''image_mean'''					)					)
							self.assertTrue(hasattr(lowerCamelCase__    ,	'''image_std'''					)					)
							self.assertTrue(hasattr(lowerCamelCase__    ,	'''do_normalize'''					)					)
							self.assertTrue(hasattr(lowerCamelCase__    ,	'''do_resize'''					)					)
							self.assertTrue(hasattr(lowerCamelCase__    ,	'''do_rescale'''					)					)
							self.assertTrue(hasattr(lowerCamelCase__    ,	'''do_pad'''					)					)
							self.assertTrue(hasattr(lowerCamelCase__    ,	'''size'''					)					)





		def    _A				(				self     :						List[Any]					):
							lowerCAmelCase		:       str							=  self.image_processing_class.from_dict(self.image_processor_dict					)
							self.assertEqual(image_processor.size    ,	{'''shortest_edge''': 1_8, '''longest_edge''': 1_3_3_3}					)
							self.assertEqual(image_processor.do_pad    ,	lowerCamelCase__					)

							lowerCAmelCase		:       List[Any]							=  self.image_processing_class.from_dict(
							    self.image_processor_dict    ,	size=4_2    ,	max_size=8_4    ,	pad_and_return_pixel_mask=lowerCamelCase__					)
							self.assertEqual(image_processor.size    ,	{'''shortest_edge''': 4_2, '''longest_edge''': 8_4}					)
							self.assertEqual(image_processor.do_pad    ,	lowerCamelCase__					)





		def    _A				(				self     :						str					):
							pass





		def    _A				(				self     :						List[Any]					):
							lowerCAmelCase		:       int							=  self.image_processing_class(**self.image_processor_dict					)
							# create random PIL images
							lowerCAmelCase		:       Dict							=  prepare_image_inputs(self.image_processor_tester    ,	equal_resolution=lowerCamelCase__					)
							for image in image_inputs:
												self.assertIsInstance(lowerCamelCase__    ,	Image.Image					)

							# Test not batched input
							lowerCAmelCase		:       Optional[int]							=  image_processing(image_inputs[0]    ,	return_tensors='''pt'''					).pixel_values

							lowerCAmelCase						,				lowerCAmelCase		:       Optional[int]							=  self.image_processor_tester.get_expected_values(lowerCamelCase__					)

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

							# Test batched
							lowerCAmelCase						,				lowerCAmelCase		:       Optional[int]							=  self.image_processor_tester.get_expected_values(lowerCamelCase__    ,	batched=lowerCamelCase__					)

							lowerCAmelCase		:       List[str]							=  image_processing(lowerCamelCase__    ,	return_tensors='''pt'''					).pixel_values
							self.assertEqual(
							    encoded_images.shape    ,	(
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        expected_height,
							        expected_width,
							    )    ,	)





		def    _A				(				self     :						str					):
							lowerCAmelCase		:       Tuple							=  self.image_processing_class(**self.image_processor_dict					)
							# create random numpy tensors
							lowerCAmelCase		:       List[Any]							=  prepare_image_inputs(self.image_processor_tester    ,	equal_resolution=lowerCamelCase__    ,	numpify=lowerCamelCase__					)
							for image in image_inputs:
												self.assertIsInstance(lowerCamelCase__    ,	np.ndarray					)

							# Test not batched input
							lowerCAmelCase		:       Optional[Any]							=  image_processing(image_inputs[0]    ,	return_tensors='''pt'''					).pixel_values

							lowerCAmelCase						,				lowerCAmelCase		:       Tuple							=  self.image_processor_tester.get_expected_values(lowerCamelCase__					)

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

							# Test batched
							lowerCAmelCase		:       Union[str, Any]							=  image_processing(lowerCamelCase__    ,	return_tensors='''pt'''					).pixel_values

							lowerCAmelCase						,				lowerCAmelCase		:       Any							=  self.image_processor_tester.get_expected_values(lowerCamelCase__    ,	batched=lowerCamelCase__					)

							self.assertEqual(
							    encoded_images.shape    ,	(
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        expected_height,
							        expected_width,
							    )    ,	)





		def    _A				(				self     :						List[Any]					):
							lowerCAmelCase		:       Optional[int]							=  self.image_processing_class(**self.image_processor_dict					)
							# create random PyTorch tensors
							lowerCAmelCase		:       Tuple							=  prepare_image_inputs(self.image_processor_tester    ,	equal_resolution=lowerCamelCase__    ,	torchify=lowerCamelCase__					)
							for image in image_inputs:
												self.assertIsInstance(lowerCamelCase__    ,	torch.Tensor					)

							# Test not batched input
							lowerCAmelCase		:       Optional[int]							=  image_processing(image_inputs[0]    ,	return_tensors='''pt'''					).pixel_values

							lowerCAmelCase						,				lowerCAmelCase		:       Dict							=  self.image_processor_tester.get_expected_values(lowerCamelCase__					)

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

							# Test batched
							lowerCAmelCase		:       int							=  image_processing(lowerCamelCase__    ,	return_tensors='''pt'''					).pixel_values

							lowerCAmelCase						,				lowerCAmelCase		:       Optional[int]							=  self.image_processor_tester.get_expected_values(lowerCamelCase__    ,	batched=lowerCamelCase__					)

							self.assertEqual(
							    encoded_images.shape    ,	(
							        self.image_processor_tester.batch_size,
							        self.image_processor_tester.num_channels,
							        expected_height,
							        expected_width,
							    )    ,	)





		@slow
		def    _A				(				self     :						Union[str, Any]					):
							lowerCAmelCase		:       Tuple							=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					)
							with open('''./tests/fixtures/tests_samples/COCO/coco_annotations.txt'''    ,	'''r'''					) as f:
												lowerCAmelCase		:       int							=  json.loads(f.read()					)

							lowerCAmelCase		:       Any							=  {'''image_id''': 3_9_7_6_9, '''annotations''': target}

							# encode them
							lowerCAmelCase		:       List[str]							=  DeformableDetrImageProcessor()
							lowerCAmelCase		:       Optional[Any]							=  image_processing(images=lowerCamelCase__    ,	annotations=lowerCamelCase__    ,	return_tensors='''pt'''					)

							# verify pixel values
							lowerCAmelCase		:       Dict							=  torch.Size([1, 3, 8_0_0, 1_0_6_6]					)
							self.assertEqual(encoding['''pixel_values'''].shape    ,	lowerCamelCase__					)

							lowerCAmelCase		:       int							=  torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]					)
							self.assertTrue(torch.allclose(encoding['''pixel_values'''][0, 0, 0, :3]    ,	lowerCamelCase__    ,	atol=1E-4					)					)

							# verify area
							lowerCAmelCase		:       Optional[Any]							=  torch.tensor([5_8_8_7.9_6_0_0, 1_1_2_5_0.2_0_6_1, 4_8_9_3_5_3.8_4_3_8, 8_3_7_1_2_2.7_5_0_0, 1_4_7_9_6_7.5_1_5_6, 1_6_5_7_3_2.3_4_3_8]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''area''']    ,	lowerCamelCase__					)					)
							# verify boxes
							lowerCAmelCase		:       List[str]							=  torch.Size([6, 4]					)
							self.assertEqual(encoding['''labels'''][0]['''boxes'''].shape    ,	lowerCamelCase__					)
							lowerCAmelCase		:       List[Any]							=  torch.tensor([0.5_5_0_3, 0.2_7_6_5, 0.0_6_0_4, 0.2_2_1_5]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''boxes'''][0]    ,	lowerCamelCase__    ,	atol=1E-3					)					)
							# verify image_id
							lowerCAmelCase		:       List[str]							=  torch.tensor([3_9_7_6_9]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''image_id''']    ,	lowerCamelCase__					)					)
							# verify is_crowd
							lowerCAmelCase		:       int							=  torch.tensor([0, 0, 0, 0, 0, 0]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''iscrowd''']    ,	lowerCamelCase__					)					)
							# verify class_labels
							lowerCAmelCase		:       Any							=  torch.tensor([7_5, 7_5, 6_3, 6_5, 1_7, 1_7]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''class_labels''']    ,	lowerCamelCase__					)					)
							# verify orig_size
							lowerCAmelCase		:       Union[str, Any]							=  torch.tensor([4_8_0, 6_4_0]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''orig_size''']    ,	lowerCamelCase__					)					)
							# verify size
							lowerCAmelCase		:       int							=  torch.tensor([8_0_0, 1_0_6_6]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''size''']    ,	lowerCamelCase__					)					)





		@slow
		def    _A				(				self     :						Union[str, Any]					):
							lowerCAmelCase		:       List[Any]							=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					)
							with open('''./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt'''    ,	'''r'''					) as f:
												lowerCAmelCase		:       List[str]							=  json.loads(f.read()					)

							lowerCAmelCase		:       Optional[Any]							=  {'''file_name''': '''000000039769.png''', '''image_id''': 3_9_7_6_9, '''segments_info''': target}

							lowerCAmelCase		:       Optional[int]							=  pathlib.Path('''./tests/fixtures/tests_samples/COCO/coco_panoptic'''					)

							# encode them
							lowerCAmelCase		:       List[Any]							=  DeformableDetrImageProcessor(format='''coco_panoptic'''					)
							lowerCAmelCase		:       Any							=  image_processing(images=lowerCamelCase__    ,	annotations=lowerCamelCase__    ,	masks_path=lowerCamelCase__    ,	return_tensors='''pt'''					)

							# verify pixel values
							lowerCAmelCase		:       Optional[int]							=  torch.Size([1, 3, 8_0_0, 1_0_6_6]					)
							self.assertEqual(encoding['''pixel_values'''].shape    ,	lowerCamelCase__					)

							lowerCAmelCase		:       Optional[Any]							=  torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]					)
							self.assertTrue(torch.allclose(encoding['''pixel_values'''][0, 0, 0, :3]    ,	lowerCamelCase__    ,	atol=1E-4					)					)

							# verify area
							lowerCAmelCase		:       str							=  torch.tensor([1_4_7_9_7_9.6_8_7_5, 1_6_5_5_2_7.0_4_6_9, 4_8_4_6_3_8.5_9_3_8, 1_1_2_9_2.9_3_7_5, 5_8_7_9.6_5_6_2, 7_6_3_4.1_1_4_7]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''area''']    ,	lowerCamelCase__					)					)
							# verify boxes
							lowerCAmelCase		:       Union[str, Any]							=  torch.Size([6, 4]					)
							self.assertEqual(encoding['''labels'''][0]['''boxes'''].shape    ,	lowerCamelCase__					)
							lowerCAmelCase		:       Dict							=  torch.tensor([0.2_6_2_5, 0.5_4_3_7, 0.4_6_8_8, 0.8_6_2_5]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''boxes'''][0]    ,	lowerCamelCase__    ,	atol=1E-3					)					)
							# verify image_id
							lowerCAmelCase		:       str							=  torch.tensor([3_9_7_6_9]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''image_id''']    ,	lowerCamelCase__					)					)
							# verify is_crowd
							lowerCAmelCase		:       Union[str, Any]							=  torch.tensor([0, 0, 0, 0, 0, 0]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''iscrowd''']    ,	lowerCamelCase__					)					)
							# verify class_labels
							lowerCAmelCase		:       int							=  torch.tensor([1_7, 1_7, 6_3, 7_5, 7_5, 9_3]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''class_labels''']    ,	lowerCamelCase__					)					)
							# verify masks
							lowerCAmelCase		:       Optional[int]							=  8_2_2_8_7_3
							self.assertEqual(encoding['''labels'''][0]['''masks'''].sum().item()    ,	lowerCamelCase__					)
							# verify orig_size
							lowerCAmelCase		:       Any							=  torch.tensor([4_8_0, 6_4_0]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''orig_size''']    ,	lowerCamelCase__					)					)
							# verify size
							lowerCAmelCase		:       Optional[Any]							=  torch.tensor([8_0_0, 1_0_6_6]					)
							self.assertTrue(torch.allclose(encoding['''labels'''][0]['''size''']    ,	lowerCamelCase__					)					)







'''simple docstring'''

import inspect
import unittest

from transformers import SegformerConfig, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
    import torch

    from transformers import (
        MODEL_MAPPING,
        SegformerForImageClassification,
        SegformerForSemanticSegmentation,
        SegformerModel,
    )
    from transformers.models.segformer.modeling_segformer import SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import SegformerImageProcessor







class __a			( _snake_case      ):





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.config_class(**self.inputs_dict     )
      self.parent.assertTrue(hasattr(lowerCamelCase					,"""hidden_sizes"""     )     )
      self.parent.assertTrue(hasattr(lowerCamelCase					,"""num_attention_heads"""     )     )
      self.parent.assertTrue(hasattr(lowerCamelCase					,"""num_encoder_blocks"""     )     )







class __a			:





   def __init__(       self					:      Optional[Any]					,lowerCamelCase					:      List[str]					,lowerCamelCase					:      List[Any]=13					,lowerCamelCase					:      Union[str, Any]=64					,lowerCamelCase					:      Dict=3					,lowerCamelCase					:      Optional[Any]=4					,lowerCamelCase					:      Optional[Any]=[2, 2, 2, 2]					,lowerCamelCase					:      Tuple=[8, 4, 2, 1]					,lowerCamelCase					:      Dict=[16, 32, 64, 128]					,lowerCamelCase					:      Tuple=[1, 4, 8, 16]					,lowerCamelCase					:      str=[1, 2, 4, 8]					,lowerCamelCase					:      str=True					,lowerCamelCase					:      Union[str, Any]=True					,lowerCamelCase					:      Optional[Any]="gelu"					,lowerCamelCase					:      Union[str, Any]=0.1					,lowerCamelCase					:      List[str]=0.1					,lowerCamelCase					:      Optional[Any]=0.02					,lowerCamelCase					:      int=3					,lowerCamelCase					:      List[str]=None					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							parent
      __SCREAMING_SNAKE_CASE   				=							batch_size
      __SCREAMING_SNAKE_CASE   				=							image_size
      __SCREAMING_SNAKE_CASE   				=							num_channels
      __SCREAMING_SNAKE_CASE   				=							num_encoder_blocks
      __SCREAMING_SNAKE_CASE   				=							sr_ratios
      __SCREAMING_SNAKE_CASE   				=							depths
      __SCREAMING_SNAKE_CASE   				=							hidden_sizes
      __SCREAMING_SNAKE_CASE   				=							downsampling_rates
      __SCREAMING_SNAKE_CASE   				=							num_attention_heads
      __SCREAMING_SNAKE_CASE   				=							is_training
      __SCREAMING_SNAKE_CASE   				=							use_labels
      __SCREAMING_SNAKE_CASE   				=							hidden_act
      __SCREAMING_SNAKE_CASE   				=							hidden_dropout_prob
      __SCREAMING_SNAKE_CASE   				=							attention_probs_dropout_prob
      __SCREAMING_SNAKE_CASE   				=							initializer_range
      __SCREAMING_SNAKE_CASE   				=							num_labels
      __SCREAMING_SNAKE_CASE   				=							scope





   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

      __SCREAMING_SNAKE_CASE   				=							None
      if self.use_labels:
         __SCREAMING_SNAKE_CASE   				=							ids_tensor([self.batch_size, self.image_size, self.image_size]					,self.num_labels     )

      __SCREAMING_SNAKE_CASE   				=							self.get_config()
      return config, pixel_values, labels





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      return SegformerConfig(
          image_size=self.image_size					,num_channels=self.num_channels					,num_encoder_blocks=self.num_encoder_blocks					,depths=self.depths					,hidden_sizes=self.hidden_sizes					,num_attention_heads=self.num_attention_heads					,hidden_act=self.hidden_act					,hidden_dropout_prob=self.hidden_dropout_prob					,attention_probs_dropout_prob=self.attention_probs_dropout_prob					,initializer_range=self.initializer_range					,)





   def   UpperCAmelCase__  (       self					:      Any					,lowerCamelCase					:      int					,lowerCamelCase					:      List[str]					,lowerCamelCase					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SegformerModel(config=lowerCamelCase     )
      model.to(lowerCamelCase     )
      model.eval()
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							__SCREAMING_SNAKE_CASE   				=							self.image_size // (self.downsampling_rates[-1] * 2)
      self.parent.assertEqual(
          result.last_hidden_state.shape					,(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)     )





   def   UpperCAmelCase__  (       self					:      Any					,lowerCamelCase					:      int					,lowerCamelCase					:      List[str]					,lowerCamelCase					:      Any     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.num_labels
      __SCREAMING_SNAKE_CASE   				=							SegformerForSemanticSegmentation(lowerCamelCase     )
      model.to(lowerCamelCase     )
      model.eval()
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )
      self.parent.assertEqual(
          result.logits.shape					,(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)     )
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase					,labels=lowerCamelCase     )
      self.parent.assertEqual(
          result.logits.shape					,(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)     )
      self.parent.assertGreater(result.loss					,0.0     )





   def   UpperCAmelCase__  (       self					:      str					,lowerCamelCase					:      Tuple					,lowerCamelCase					:      Optional[Any]					,lowerCamelCase					:      int     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							1
      __SCREAMING_SNAKE_CASE   				=							SegformerForSemanticSegmentation(config=lowerCamelCase     )
      model.to(lowerCamelCase     )
      model.eval()
      __SCREAMING_SNAKE_CASE   				=							torch.randint(0					,1					,(self.batch_size, self.image_size, self.image_size)     ).to(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase					,labels=lowerCamelCase     )
      self.parent.assertGreater(result.loss					,0.0     )





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.prepare_config_and_inputs()
      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							config_and_inputs
      __SCREAMING_SNAKE_CASE   				=							{"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_torch
class __a			( _snake_case, _snake_case, unittest.TestCase      ):
   __UpperCamelCase :			Dict						   =						(
       (
           SegformerModel,
           SegformerForSemanticSegmentation,
           SegformerForImageClassification,
       )
       if is_torch_available()
       else ()
   )
   __UpperCamelCase :			Union[str, Any]						   =						(
       {
           'feature-extraction': SegformerModel,
           'image-classification': SegformerForImageClassification,
           'image-segmentation': SegformerForSemanticSegmentation,
       }
       if is_torch_available()
       else {}
   )

   __UpperCamelCase :			Optional[Any]						   =						True
   __UpperCamelCase :			List[Any]						   =						False
   __UpperCamelCase :			Union[str, Any]						   =						False
   __UpperCamelCase :			Optional[int]						   =						False





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SegformerModelTester(self     )
      __SCREAMING_SNAKE_CASE   				=							SegformerConfigTester(self					,config_class=lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      self.config_tester.run_common_tests()





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_binary_image_segmentation(*lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_segmentation(*lowerCamelCase     )





   @unittest.skip("""SegFormer does not use inputs_embeds"""     )
   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      pass





   @unittest.skip("""SegFormer does not have get_input_embeddings method and get_output_embeddings methods"""     )
   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      pass





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs_for_common()

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

         __SCREAMING_SNAKE_CASE   				=							["""pixel_values"""]
         self.assertListEqual(arg_names[:1]					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs_for_common()
      __SCREAMING_SNAKE_CASE   				=							True

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE   				=							True
         __SCREAMING_SNAKE_CASE   				=							False
         __SCREAMING_SNAKE_CASE   				=							True
         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.eval()
         with torch.no_grad():
            __SCREAMING_SNAKE_CASE   				=							model(**self._prepare_for_class(lowerCamelCase					,lowerCamelCase     )     )
         __SCREAMING_SNAKE_CASE   				=							outputs.attentions

         __SCREAMING_SNAKE_CASE   				=							sum(self.model_tester.depths     )
         self.assertEqual(len(lowerCamelCase     )					,lowerCamelCase     )

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         __SCREAMING_SNAKE_CASE   				=							True
         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.eval()
         with torch.no_grad():
            __SCREAMING_SNAKE_CASE   				=							model(**self._prepare_for_class(lowerCamelCase					,lowerCamelCase     )     )
         __SCREAMING_SNAKE_CASE   				=							outputs.attentions

         self.assertEqual(len(lowerCamelCase     )					,lowerCamelCase     )

         # verify the first attentions (first block, first layer)
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // 4) ** 2
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
         self.assertListEqual(
             list(attentions[0].shape[-3:]     )					,[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]					,)

         # verify the last attentions (last block, last layer)
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // 32) ** 2
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // (32 * self.model_tester.sr_ratios[-1])) ** 2
         self.assertListEqual(
             list(attentions[-1].shape[-3:]     )					,[self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len]					,)
         __SCREAMING_SNAKE_CASE   				=							len(lowerCamelCase     )

         # Check attention is always last and order is fine
         __SCREAMING_SNAKE_CASE   				=							True
         __SCREAMING_SNAKE_CASE   				=							True
         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.eval()
         with torch.no_grad():
            __SCREAMING_SNAKE_CASE   				=							model(**self._prepare_for_class(lowerCamelCase					,lowerCamelCase     )     )

         self.assertEqual(out_len + 1					,len(lowerCamelCase     )     )

         __SCREAMING_SNAKE_CASE   				=							outputs.attentions

         self.assertEqual(len(lowerCamelCase     )					,lowerCamelCase     )
         # verify the first attentions (first block, first layer)
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // 4) ** 2
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
         self.assertListEqual(
             list(self_attentions[0].shape[-3:]     )					,[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]					,)





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      def check_hidden_states_output(lowerCamelCase					:      Tuple					,lowerCamelCase					:      List[Any]					,lowerCamelCase					:      Dict     ):
         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.eval()

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

         __SCREAMING_SNAKE_CASE   				=							outputs.hidden_states

         __SCREAMING_SNAKE_CASE   				=							self.model_tester.num_encoder_blocks
         self.assertEqual(len(lowerCamelCase     )					,lowerCamelCase     )

         # verify the first hidden states (first block)
         self.assertListEqual(
             list(hidden_states[0].shape[-3:]     )					,[
                 self.model_tester.hidden_sizes[0],
                 self.model_tester.image_size // 4,
                 self.model_tester.image_size // 4,
             ]					,)

      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE   				=							True
         check_hidden_states_output(lowerCamelCase					,lowerCamelCase					,lowerCamelCase     )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         __SCREAMING_SNAKE_CASE   				=							True

         check_hidden_states_output(lowerCamelCase					,lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      if not self.model_tester.is_training:
         return

      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs_for_common()
      __SCREAMING_SNAKE_CASE   				=							True

      for model_class in self.all_model_classes:
         if model_class in get_values(lowerCamelCase     ):
            continue

         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.train()
         __SCREAMING_SNAKE_CASE   				=							self._prepare_for_class(lowerCamelCase					,lowerCamelCase					,return_labels=lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							model(**lowerCamelCase     ).loss
         loss.backward()





   @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""     )
   def   UpperCAmelCase__  (       self					:      Union[str, Any]     ):

      '''simple docstring'''

      pass





   @slow
   def   UpperCAmelCase__  (       self					:      Union[str, Any]     ):

      '''simple docstring'''

      for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __SCREAMING_SNAKE_CASE   				=							SegformerModel.from_pretrained(lowerCamelCase     )
         self.assertIsNotNone(lowerCamelCase     )





def     __magic_name__							(				)    ->       List[str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
   return image







@require_torch
class __a			( unittest.TestCase      ):





   @slow
   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SegformerImageProcessor(
          image_scale=(512, 512)					,keep_ratio=lowerCamelCase					,align=lowerCamelCase					,do_random_crop=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							SegformerForSemanticSegmentation.from_pretrained("""nvidia/segformer-b0-finetuned-ade-512-512"""     ).to(
          lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							prepare_img()
      __SCREAMING_SNAKE_CASE   				=							image_processor(images=lowerCamelCase					,return_tensors="""pt"""     )
      __SCREAMING_SNAKE_CASE   				=							encoded_inputs.pixel_values.to(lowerCamelCase     )

      with torch.no_grad():
         __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							torch.Size((1, model.config.num_labels, 128, 128)     )
      self.assertEqual(outputs.logits.shape					,lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							torch.tensor(
          [
              [[-4.6_310, -5.5_232, -6.2_356], [-5.1_921, -6.1_444, -6.5_996], [-5.4_424, -6.2_790, -6.7_574]],
              [[-12.1_391, -13.3_122, -13.9_554], [-12.8_732, -13.9_352, -14.3_563], [-12.9_438, -13.8_226, -14.2_513]],
              [[-12.5_134, -13.4_686, -14.4_915], [-12.8_669, -14.4_343, -14.7_758], [-13.2_523, -14.5_819, -15.0_694]],
          ]     ).to(lowerCamelCase     )
      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]					,lowerCamelCase					,atol=1E-4     )     )





   @slow
   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SegformerImageProcessor(
          image_scale=(512, 512)					,keep_ratio=lowerCamelCase					,align=lowerCamelCase					,do_random_crop=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							SegformerForSemanticSegmentation.from_pretrained(
          """nvidia/segformer-b1-finetuned-cityscapes-1024-1024"""     ).to(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							prepare_img()
      __SCREAMING_SNAKE_CASE   				=							image_processor(images=lowerCamelCase					,return_tensors="""pt"""     )
      __SCREAMING_SNAKE_CASE   				=							encoded_inputs.pixel_values.to(lowerCamelCase     )

      with torch.no_grad():
         __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							torch.Size((1, model.config.num_labels, 128, 128)     )
      self.assertEqual(outputs.logits.shape					,lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							torch.tensor(
          [
              [[-13.5_748, -13.9_111, -12.6_500], [-14.3_500, -15.3_683, -14.2_328], [-14.7_532, -16.0_424, -15.6_087]],
              [[-17.1_651, -15.8_725, -12.9_653], [-17.2_580, -17.3_718, -14.8_223], [-16.6_058, -16.8_783, -16.7_452]],
              [[-3.6_456, -3.0_209, -1.4_203], [-3.0_797, -3.1_959, -2.0_000], [-1.8_757, -1.9_217, -1.6_997]],
          ]     ).to(lowerCamelCase     )
      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]					,lowerCamelCase					,atol=1E-1     )     )





   @slow
   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SegformerImageProcessor(
          image_scale=(512, 512)					,keep_ratio=lowerCamelCase					,align=lowerCamelCase					,do_random_crop=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							SegformerForSemanticSegmentation.from_pretrained("""nvidia/segformer-b0-finetuned-ade-512-512"""     ).to(
          lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							prepare_img()
      __SCREAMING_SNAKE_CASE   				=							image_processor(images=lowerCamelCase					,return_tensors="""pt"""     )
      __SCREAMING_SNAKE_CASE   				=							encoded_inputs.pixel_values.to(lowerCamelCase     )

      with torch.no_grad():
         __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							outputs.logits.detach().cpu()

      __SCREAMING_SNAKE_CASE   				=							image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase					,target_sizes=[(500, 300)]     )
      __SCREAMING_SNAKE_CASE   				=							torch.Size((500, 300)     )
      self.assertEqual(segmentation[0].shape					,lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							torch.Size((128, 128)     )
      self.assertEqual(segmentation[0].shape					,lowerCamelCase     )





