




'''simple docstring'''


from __future__ import annotations

import unittest

from transformers import DebertaConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TFDebertaForMaskedLM,
         TFDebertaForQuestionAnswering,
         TFDebertaForSequenceClassification,
         TFDebertaForTokenClassification,
         TFDebertaModel,
     )






class 	lowerCAmelCase_  :







  '''simple docstring'''

  def __init__(   self							:       Optional[int]				,     SCREAMING_SNAKE_CASE_							:       Any				,     SCREAMING_SNAKE_CASE_							:       Optional[int]=13				,     SCREAMING_SNAKE_CASE_							:       List[Any]=7				,     SCREAMING_SNAKE_CASE_							:       List[str]=True				,     SCREAMING_SNAKE_CASE_							:       Dict=True				,     SCREAMING_SNAKE_CASE_							:       Any=True				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]=True				,     SCREAMING_SNAKE_CASE_							:       str=99				,     SCREAMING_SNAKE_CASE_							:       Union[str, Any]=32				,     SCREAMING_SNAKE_CASE_							:       List[Any]=2				,     SCREAMING_SNAKE_CASE_							:       List[Any]=4				,     SCREAMING_SNAKE_CASE_							:       Tuple=37				,     SCREAMING_SNAKE_CASE_							:       Tuple="gelu"				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]=0.1				,     SCREAMING_SNAKE_CASE_							:       Optional[int]=0.1				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]=5_12				,     SCREAMING_SNAKE_CASE_							:       str=16				,     SCREAMING_SNAKE_CASE_							:       str=2				,     SCREAMING_SNAKE_CASE_							:       List[Any]=0.02				,     SCREAMING_SNAKE_CASE_							:       List[str]=3				,     SCREAMING_SNAKE_CASE_							:       List[Any]=4				,     SCREAMING_SNAKE_CASE_							:       Optional[int]=None				,     ) ->		List[str]:







       '''simple docstring'''



       A:		List[Any]        =		parent
       A:		int        =		13
       A:		Union[str, Any]        =		7
       A:		int        =		True
       A:		str        =		True
       A:		Any        =		True
       A:		Optional[Any]        =		True
       A:		Optional[Any]        =		99
       A:		List[Any]        =		32
       A:		Optional[Any]        =		2
       A:		int        =		4
       A:		Union[str, Any]        =		37
       A:		Union[str, Any]        =		'''gelu'''
       A:		Optional[int]        =		0.1
       A:		str        =		0.1
       A:		Union[str, Any]        =		5_12
       A:		int        =		16
       A:		Optional[int]        =		False
       A:		int        =		-1
       A:		List[Any]        =		True
       A:		str        =		2
       A:		Any        =		0.02
       A:		Dict        =		3
       A:		List[Any]        =		4
       A:		Union[str, Any]        =		None



  def 				_snake_case    (   self							:       Dict  ) ->		List[Any]:







       '''simple docstring'''



       A:		str        =		ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size  )

       A:		Any        =		None
       if self.use_input_mask:
            A:		List[Any]        =		random_attention_mask([self.batch_size, self.seq_length]  )

       A:		List[Any]        =		None
       if self.use_token_type_ids:
            A:		Optional[int]        =		ids_tensor([self.batch_size, self.seq_length]				,     self.type_vocab_size  )

       A:		Dict        =		None
       A:		Any        =		None
       A:		Tuple        =		None
       if self.use_labels:
            A:		Optional[Any]        =		ids_tensor([self.batch_size]				,     self.type_sequence_label_size  )
            A:		Any        =		ids_tensor([self.batch_size, self.seq_length]				,     self.num_labels  )

       A:		Tuple        =		DebertaConfig(
           vocab_size=self.vocab_size				,     hidden_size=self.hidden_size				,     num_hidden_layers=self.num_hidden_layers				,     num_attention_heads=self.num_attention_heads				,     intermediate_size=self.intermediate_size				,     hidden_act=self.hidden_act				,     hidden_dropout_prob=self.hidden_dropout_prob				,     attention_probs_dropout_prob=self.attention_probs_dropout_prob				,     max_position_embeddings=self.max_position_embeddings				,     type_vocab_size=self.type_vocab_size				,     relative_attention=self.relative_attention				,     max_relative_positions=self.max_relative_positions				,     position_biased_input=self.position_biased_input				,     initializer_range=self.initializer_range				,     return_dict=SCREAMING_SNAKE_CASE_				,     )

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



  def 				_snake_case    (   self							:       Dict				,     SCREAMING_SNAKE_CASE_							:       str				,     SCREAMING_SNAKE_CASE_							:       Dict				,     SCREAMING_SNAKE_CASE_							:       List[str]				,     SCREAMING_SNAKE_CASE_							:       Tuple				,     SCREAMING_SNAKE_CASE_							:       List[Any]				,     SCREAMING_SNAKE_CASE_							:       Union[str, Any]				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]  ) ->		str:







       '''simple docstring'''



       A:		Optional[Any]        =		TFDebertaModel(config=SCREAMING_SNAKE_CASE_  )
       A:		List[Any]        =		{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

       A:		Union[str, Any]        =		[input_ids, input_mask]
       A:		List[Any]        =		model(SCREAMING_SNAKE_CASE_  )

       A:		List[str]        =		model(SCREAMING_SNAKE_CASE_  )

       self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size)  )



  def 				_snake_case    (   self							:       Dict				,     SCREAMING_SNAKE_CASE_							:       str				,     SCREAMING_SNAKE_CASE_							:       List[Any]				,     SCREAMING_SNAKE_CASE_							:       Tuple				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]				,     SCREAMING_SNAKE_CASE_							:       Union[str, Any]				,     SCREAMING_SNAKE_CASE_							:       str				,     SCREAMING_SNAKE_CASE_							:       Union[str, Any]  ) ->		Dict:







       '''simple docstring'''



       A:		List[Any]        =		TFDebertaForMaskedLM(config=SCREAMING_SNAKE_CASE_  )
       A:		Optional[Any]        =		{
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
           '''token_type_ids''': token_type_ids,
       }
       A:		Union[str, Any]        =		model(SCREAMING_SNAKE_CASE_  )
       self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.vocab_size)  )



  def 				_snake_case    (   self							:       List[str]				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]				,     SCREAMING_SNAKE_CASE_							:       str				,     SCREAMING_SNAKE_CASE_							:       int				,     SCREAMING_SNAKE_CASE_							:       Any				,     SCREAMING_SNAKE_CASE_							:       str				,     SCREAMING_SNAKE_CASE_							:       List[Any]				,     SCREAMING_SNAKE_CASE_							:       Union[str, Any]  ) ->		Optional[int]:







       '''simple docstring'''



       A:		Union[str, Any]        =		self.num_labels
       A:		Optional[Any]        =		TFDebertaForSequenceClassification(config=SCREAMING_SNAKE_CASE_  )
       A:		str        =		{
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
           '''token_type_ids''': token_type_ids,
       }

       A:		Union[str, Any]        =		model(SCREAMING_SNAKE_CASE_  )
       self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)  )



  def 				_snake_case    (   self							:       Optional[Any]				,     SCREAMING_SNAKE_CASE_							:       int				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]				,     SCREAMING_SNAKE_CASE_							:       Dict				,     SCREAMING_SNAKE_CASE_							:       Tuple				,     SCREAMING_SNAKE_CASE_							:       str				,     SCREAMING_SNAKE_CASE_							:       Union[str, Any]  ) ->		Union[str, Any]:







       '''simple docstring'''



       A:		Tuple        =		self.num_labels
       A:		Union[str, Any]        =		TFDebertaForTokenClassification(config=SCREAMING_SNAKE_CASE_  )
       A:		List[Any]        =		{
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
           '''token_type_ids''': token_type_ids,
       }
       A:		List[str]        =		model(SCREAMING_SNAKE_CASE_  )
       self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.num_labels)  )



  def 				_snake_case    (   self							:       Dict				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]				,     SCREAMING_SNAKE_CASE_							:       int				,     SCREAMING_SNAKE_CASE_							:       Union[str, Any]				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]				,     SCREAMING_SNAKE_CASE_							:       Tuple				,     SCREAMING_SNAKE_CASE_							:       Dict  ) ->		int:







       '''simple docstring'''



       A:		Any        =		TFDebertaForQuestionAnswering(config=SCREAMING_SNAKE_CASE_  )
       A:		Tuple        =		{
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
           '''token_type_ids''': token_type_ids,
       }

       A:		Dict        =		model(SCREAMING_SNAKE_CASE_  )
       self.parent.assertEqual(result.start_logits.shape				,     (self.batch_size, self.seq_length)  )
       self.parent.assertEqual(result.end_logits.shape				,     (self.batch_size, self.seq_length)  )




  def 				_snake_case    (   self							:       Dict  ) ->		Dict:







       '''simple docstring'''



       A:		List[Any]        =		self.prepare_config_and_inputs()
       (
           (
           A
       )    ,						(
           A
       )    ,						(
           A
       )    ,						(
           A
       )    ,						(
           A
       )    ,						(
           A
       )    ,						(
           A
       )    ,						
       ):		List[str]        =		config_and_inputs
       A:		Dict        =		{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
       return config, inputs_dict






@require_tf
class 	lowerCAmelCase_  (					UpperCAmelCase_					,				UpperCAmelCase_					,				unittest.TestCase       ):







  '''simple docstring'''

  UpperCamelCase_ :			List[Any]        =							(
      (
          TFDebertaModel,
          TFDebertaForMaskedLM,
          TFDebertaForQuestionAnswering,
          TFDebertaForSequenceClassification,
          TFDebertaForTokenClassification,
      )
      if is_tf_available()
      else ()
  )
  UpperCamelCase_ :			Dict        =							(
      {
          """feature-extraction""": TFDebertaModel,
          """fill-mask""": TFDebertaForMaskedLM,
          """question-answering""": TFDebertaForQuestionAnswering,
          """text-classification""": TFDebertaForSequenceClassification,
          """token-classification""": TFDebertaForTokenClassification,
          """zero-shot""": TFDebertaForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )

  UpperCamelCase_ :			List[Any]        =							False
  UpperCamelCase_ :			Optional[Any]        =							False



  def 				_snake_case    (   self							:       Optional[int]  ) ->		int:







       '''simple docstring'''



       A:		str        =		TFDebertaModelTester(self  )
       A:		int        =		ConfigTester(self				,     config_class=SCREAMING_SNAKE_CASE_				,     hidden_size=37  )



  def 				_snake_case    (   self							:       Optional[int]  ) ->		Union[str, Any]:







       '''simple docstring'''



       self.config_tester.run_common_tests()



  def 				_snake_case    (   self							:       int  ) ->		Tuple:







       '''simple docstring'''



       A:		Optional[Any]        =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_  )



  def 				_snake_case    (   self							:       Any  ) ->		Optional[Any]:







       '''simple docstring'''



       A:		Union[str, Any]        =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE_  )



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







       '''simple docstring'''



       A:		Dict        =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE_  )



  def 				_snake_case    (   self							:       Any  ) ->		Optional[Any]:







       '''simple docstring'''



       A:		Any        =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE_  )



  def 				_snake_case    (   self							:       List[str]  ) ->		List[str]:







       '''simple docstring'''



       A:		Tuple        =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE_  )




  @slow
  def 				_snake_case    (   self							:       Tuple  ) ->		Optional[int]:







       '''simple docstring'''



       A:		Optional[int]        =		TFDebertaModel.from_pretrained('''kamalkraj/deberta-base'''  )
       self.assertIsNotNone(SCREAMING_SNAKE_CASE_  )






@require_tf
class 	lowerCAmelCase_  (					unittest.TestCase       ):







  '''simple docstring'''

  @unittest.skip(reason='''Model not available yet'''  )
  def 				_snake_case    (   self							:       List[Any]  ) ->		Union[str, Any]:







       '''simple docstring'''



       pass




  @slow
  def 				_snake_case    (   self							:       Any  ) ->		Any:







       '''simple docstring'''



       A:		Any        =		TFDebertaModel.from_pretrained('''kamalkraj/deberta-base'''  )
       A:		Dict        =		tf.constant([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]]  )
       A:		List[Any]        =		tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
       A:		Optional[int]        =		model(SCREAMING_SNAKE_CASE_				,     attention_mask=SCREAMING_SNAKE_CASE_  )[0]

       A:		List[str]        =		tf.constant(
           [
               [
                   [-0.5985_5896, -0.8055_2566, -0.846_2135],
                   [1.448_4025, -0.9348_3794, -0.8059_3085],
                   [0.312_2741, 0.0031_6059, -1.413_1377],
               ]
           ]  )
       tf.debugging.assert_near(output[:, 1:4, 1:4]				,     SCREAMING_SNAKE_CASE_				,     atol=1E-4  )












'''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 	lowerCAmelCase_  (					unittest.TestCase       ):







  '''simple docstring'''

  def __init__(   self							:       Dict				,     SCREAMING_SNAKE_CASE_							:       Dict				,     SCREAMING_SNAKE_CASE_							:       Any=7				,     SCREAMING_SNAKE_CASE_							:       Dict=3				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]=30				,     SCREAMING_SNAKE_CASE_							:       List[Any]=4_00				,     SCREAMING_SNAKE_CASE_							:       str=True				,     SCREAMING_SNAKE_CASE_							:       List[Any]=None				,     SCREAMING_SNAKE_CASE_							:       Optional[int]=True				,     SCREAMING_SNAKE_CASE_							:       List[str]=[0.5, 0.5, 0.5]				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]=[0.5, 0.5, 0.5]				,     SCREAMING_SNAKE_CASE_							:       Tuple=False				,     ) ->		str:







       '''simple docstring'''



       A:		Dict        =		size if size is not None else {'''height''': 30, '''width''': 30}
       A:		List[Any]        =		parent
       A:		Tuple        =		batch_size
       A:		List[str]        =		num_channels
       A:		Dict        =		min_resolution
       A:		str        =		max_resolution
       A:		int        =		do_resize
       A:		List[str]        =		size
       A:		int        =		do_normalize
       A:		Optional[int]        =		image_mean
       A:		Optional[int]        =		image_std
       A:		Any        =		do_reduce_labels




  def 				_snake_case    (   self							:       Any  ) ->		List[str]:







       '''simple docstring'''



       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 				SCREAMING_SNAKE_CASE(      ) ->   List[Any]:
     A:		Dict        =		load_dataset('''hf-internal-testing/fixtures_ade20k'''		,							split='''test'''  )

     A:		Any        =		Image.open(dataset[0]['''file''']  )
     A:		Dict        =		Image.open(dataset[1]['''file''']  )

     return image, map
def 				SCREAMING_SNAKE_CASE(      ) ->   List[Any]:
     A:		Optional[Any]        =		load_dataset('''hf-internal-testing/fixtures_ade20k'''		,							split='''test'''  )

     A:		Union[str, Any]        =		Image.open(dataset[0]['''file''']  )
     A:		str        =		Image.open(dataset[1]['''file''']  )
     A:		str        =		Image.open(dataset[2]['''file''']  )
     A:		Any        =		Image.open(dataset[3]['''file''']  )

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






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







  '''simple docstring'''

  UpperCamelCase_ :			int        =							SegformerImageProcessor if is_vision_available() else None



  def 				_snake_case    (   self							:       List[str]  ) ->		str:







       '''simple docstring'''



       A:		Dict        =		SegformerImageProcessingTester(self  )



  @property
  def 				_snake_case    (   self							:       Tuple  ) ->		List[str]:







       '''simple docstring'''



       return self.image_processor_tester.prepare_image_processor_dict()



  def 				_snake_case    (   self							:       Optional[int]  ) ->		Optional[Any]:







       '''simple docstring'''



       A:		Optional[int]        =		self.image_processing_class(**self.image_processor_dict  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''do_resize'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''size'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''do_normalize'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''image_mean'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''image_std'''  )  )
       self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_				,     '''do_reduce_labels'''  )  )



  def 				_snake_case    (   self							:       List[str]  ) ->		Union[str, Any]:







       '''simple docstring'''



       A:		Tuple        =		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				,     SCREAMING_SNAKE_CASE_  )

       A:		str        =		self.image_processing_class.from_dict(self.image_processor_dict				,     size=42				,     reduce_labels=SCREAMING_SNAKE_CASE_  )
       self.assertEqual(image_processor.size				,     {'''height''': 42, '''width''': 42}  )
       self.assertEqual(image_processor.do_reduce_labels				,     SCREAMING_SNAKE_CASE_  )



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







       '''simple docstring'''



       pass



  def 				_snake_case    (   self							:       Any  ) ->		Dict:







       '''simple docstring'''



       A:		Dict        =		self.image_processing_class(**self.image_processor_dict  )
       # create random PIL images
       A:		Optional[Any]        =		prepare_image_inputs(self.image_processor_tester				,     equal_resolution=SCREAMING_SNAKE_CASE_  )
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     Image.Image  )

       # Test not batched input
       A:		List[str]        =		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
       A:		int        =		image_processing(SCREAMING_SNAKE_CASE_				,     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 				_snake_case    (   self							:       str  ) ->		Tuple:







       '''simple docstring'''



       A:		int        =		self.image_processing_class(**self.image_processor_dict  )
       # create random numpy tensors
       A:		Optional[Any]        =		prepare_image_inputs(self.image_processor_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:		Dict        =		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
       A:		Any        =		image_processing(SCREAMING_SNAKE_CASE_				,     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 				_snake_case    (   self							:       str  ) ->		str:







       '''simple docstring'''



       A:		List[Any]        =		self.image_processing_class(**self.image_processor_dict  )
       # create random PyTorch tensors
       A:		str        =		prepare_image_inputs(self.image_processor_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:		Any        =		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
       A:		List[Any]        =		image_processing(SCREAMING_SNAKE_CASE_				,     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 				_snake_case    (   self							:       Dict  ) ->		Optional[Any]:







       '''simple docstring'''



       A:		Optional[int]        =		self.image_processing_class(**self.image_processor_dict  )
       # create random PyTorch tensors
       A:		Optional[int]        =		prepare_image_inputs(self.image_processor_tester				,     equal_resolution=SCREAMING_SNAKE_CASE_				,     torchify=SCREAMING_SNAKE_CASE_  )
       A:		Optional[Any]        =		[]
       for image in image_inputs:
            self.assertIsInstance(SCREAMING_SNAKE_CASE_				,     torch.Tensor  )
            maps.append(torch.zeros(image.shape[-2:]  ).long()  )

       # Test not batched input
       A:		Tuple        =		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
       A:		Union[str, Any]        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     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)
       A    ,						A:		int        =		prepare_semantic_single_inputs()

       A:		Dict        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     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)
       A    ,						A:		int        =		prepare_semantic_batch_inputs()

       A:		int        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     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 				_snake_case    (   self							:       Tuple  ) ->		Union[str, Any]:







       '''simple docstring'''



       A:		Any        =		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
       A    ,						A:		Union[str, Any]        =		prepare_semantic_single_inputs()
       A:		Optional[int]        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  )
       self.assertTrue(encoding['''labels'''].min().item() >= 0  )
       self.assertTrue(encoding['''labels'''].max().item() <= 1_50  )

       A:		Optional[int]        =		True
       A:		str        =		image_processing(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  )
       self.assertTrue(encoding['''labels'''].min().item() >= 0  )
       self.assertTrue(encoding['''labels'''].max().item() <= 2_55  )






