




"""simple docstring"""





import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format



class      a__				:
			lowercase_    =	None


			def       a_     (      self      :    List[Any]):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[Any]		=					self.feature_extraction_class(**self.feat_extract_dict)
						__UpperCAmelCase	: Any		=					json.loads(feat_extract.to_json_string())
						for key, value in self.feat_extract_dict.items():
									self.assertEqual(obj[key]      ,  UpperCamelCase_)


			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[Any]		=					self.feature_extraction_class(**self.feat_extract_dict)

						with tempfile.TemporaryDirectory() as tmpdirname:
									__UpperCAmelCase	: Dict		=					os.path.join(UpperCamelCase_      ,  "feat_extract.json")
									feat_extract_first.to_json_file(UpperCamelCase_)
									__UpperCAmelCase	: Optional[Any]		=					self.feature_extraction_class.from_json_file(UpperCamelCase_)

						self.assertEqual(feat_extract_second.to_dict()      ,  feat_extract_first.to_dict())


			def       a_     (      self      :    List[str]):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[Any]		=					self.feature_extraction_class(**self.feat_extract_dict)

						with tempfile.TemporaryDirectory() as tmpdirname:
									__UpperCAmelCase	: Tuple		=					feat_extract_first.save_pretrained(UpperCamelCase_)[0]
									check_json_file_has_correct_format(UpperCamelCase_)
									__UpperCAmelCase	: List[Any]		=					self.feature_extraction_class.from_pretrained(UpperCamelCase_)

						self.assertEqual(feat_extract_second.to_dict()      ,  feat_extract_first.to_dict())


			def       a_     (      self      :    Union[str, Any]):


						"""simple docstring"""




						__UpperCAmelCase	: Union[str, Any]		=					self.feature_extraction_class()
						self.assertIsNotNone(UpperCamelCase_)








"""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__				(	__magic_name__   ):


			def       a_     (      self      :    Union[str, Any]):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[int]		=					self.config_class(**self.inputs_dict)
						self.parent.assertTrue(hasattr(UpperCamelCase_      ,  "hidden_sizes"))
						self.parent.assertTrue(hasattr(UpperCamelCase_      ,  "num_attention_heads"))
						self.parent.assertTrue(hasattr(UpperCamelCase_      ,  "num_encoder_blocks"))






class      a__				:


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


						"""simple docstring"""




						__UpperCAmelCase	: str		=					parent
						__UpperCAmelCase	: Dict		=					batch_size
						__UpperCAmelCase	: str		=					image_size
						__UpperCAmelCase	: str		=					num_channels
						__UpperCAmelCase	: Any		=					num_encoder_blocks
						__UpperCAmelCase	: List[Any]		=					sr_ratios
						__UpperCAmelCase	: Optional[int]		=					depths
						__UpperCAmelCase	: Union[str, Any]		=					hidden_sizes
						__UpperCAmelCase	: Union[str, Any]		=					downsampling_rates
						__UpperCAmelCase	: Union[str, Any]		=					num_attention_heads
						__UpperCAmelCase	: Any		=					is_training
						__UpperCAmelCase	: Optional[Any]		=					use_labels
						__UpperCAmelCase	: List[Any]		=					hidden_act
						__UpperCAmelCase	: str		=					hidden_dropout_prob
						__UpperCAmelCase	: str		=					attention_probs_dropout_prob
						__UpperCAmelCase	: Dict		=					initializer_range
						__UpperCAmelCase	: List[str]		=					num_labels
						__UpperCAmelCase	: Union[str, Any]		=					scope


			def       a_     (      self      :    int):


						"""simple docstring"""




						__UpperCAmelCase	: str		=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

						__UpperCAmelCase	: List[Any]		=					None
						if self.use_labels:
									__UpperCAmelCase	: int		=					ids_tensor([self.batch_size, self.image_size, self.image_size]      ,  self.num_labels)

						__UpperCAmelCase	: Optional[Any]		=					self.get_config()
						return config, pixel_values, labels


			def       a_     (      self      :    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       a_     (      self      :    Dict      ,  UpperCamelCase_      :    Optional[Any]      ,  UpperCamelCase_      :    Dict      ,  UpperCamelCase_      :    Dict):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[int]		=					SegformerModel(config=UpperCamelCase_)
						model.to(UpperCamelCase_)
						model.eval()
						__UpperCAmelCase	: List[Any]		=					model(UpperCamelCase_)
						__UpperCAmelCase	: Optional[int]		=					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       a_     (      self      :    Optional[Any]      ,  UpperCamelCase_      :    List[str]      ,  UpperCamelCase_      :    Tuple      ,  UpperCamelCase_      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: Tuple		=					self.num_labels
						__UpperCAmelCase	: Union[str, Any]		=					SegformerForSemanticSegmentation(UpperCamelCase_)
						model.to(UpperCamelCase_)
						model.eval()
						__UpperCAmelCase	: Tuple		=					model(UpperCamelCase_)
						self.parent.assertEqual(
						    result.logits.shape      ,  (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4))
						__UpperCAmelCase	: int		=					model(UpperCamelCase_      ,  labels=UpperCamelCase_)
						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       a_     (      self      :    Dict      ,  UpperCamelCase_      :    Tuple      ,  UpperCamelCase_      :    Optional[Any]      ,  UpperCamelCase_      :    List[Any]):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[int]		=					1
						__UpperCAmelCase	: Dict		=					SegformerForSemanticSegmentation(config=UpperCamelCase_)
						model.to(UpperCamelCase_)
						model.eval()
						__UpperCAmelCase	: List[str]		=					torch.randint(0      ,  1      ,  (self.batch_size, self.image_size, self.image_size)).to(UpperCamelCase_)
						__UpperCAmelCase	: Dict		=					model(UpperCamelCase_      ,  labels=UpperCamelCase_)
						self.parent.assertGreater(result.loss      ,  0.0)


			def       a_     (      self      :    List[Any]):


						"""simple docstring"""




						__UpperCAmelCase	: Union[str, Any]		=					self.prepare_config_and_inputs()
						__UpperCAmelCase	,     __UpperCAmelCase	,     __UpperCAmelCase	: Any		=					config_and_inputs
						__UpperCAmelCase	: Optional[Any]		=					{"pixel_values": pixel_values}
						return config, inputs_dict






@require_torch
class      a__				(	__magic_name__							,    __magic_name__							,    unittest.TestCase   ):
			lowercase_    =	(
			    (
			        SegformerModel,
			        SegformerForSemanticSegmentation,
			        SegformerForImageClassification,
			    )
			    if is_torch_available()
			    else ()
			)
			lowercase_    =	(
			    {
			        "feature-extraction": SegformerModel,
			        "image-classification": SegformerForImageClassification,
			        "image-segmentation": SegformerForSemanticSegmentation,
			    }
			    if is_torch_available()
			    else {}
			)

			lowercase_    =	True
			lowercase_    =	False
			lowercase_    =	False
			lowercase_    =	False


			def       a_     (      self      :    Any):


						"""simple docstring"""




						__UpperCAmelCase	: Dict		=					SegformerModelTester(self)
						__UpperCAmelCase	: Any		=					SegformerConfigTester(self      ,  config_class=UpperCamelCase_)


			def       a_     (      self      :    Dict):


						"""simple docstring"""




						self.config_tester.run_common_tests()


			def       a_     (      self      :    List[str]):


						"""simple docstring"""




						__UpperCAmelCase	: Dict		=					self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCamelCase_)


			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: List[str]		=					self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_binary_image_segmentation(*UpperCamelCase_)


			def       a_     (      self      :    Optional[Any]):


						"""simple docstring"""




						__UpperCAmelCase	: Union[str, Any]		=					self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_segmentation(*UpperCamelCase_)


			@unittest.skip("SegFormer does not use inputs_embeds")
			def       a_     (      self      :    Dict):


						"""simple docstring"""




						pass


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


						"""simple docstring"""




						pass


			def       a_     (      self      :    Dict):


						"""simple docstring"""




						__UpperCAmelCase	,     __UpperCAmelCase	: Union[str, Any]		=					self.model_tester.prepare_config_and_inputs_for_common()

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

									__UpperCAmelCase	: List[Any]		=					["pixel_values"]
									self.assertListEqual(arg_names[:1]      ,  UpperCamelCase_)


			def       a_     (      self      :    Dict):


						"""simple docstring"""




						__UpperCAmelCase	,     __UpperCAmelCase	: int		=					self.model_tester.prepare_config_and_inputs_for_common()
						__UpperCAmelCase	: Any		=					True

						for model_class in self.all_model_classes:
									__UpperCAmelCase	: List[Any]		=					True
									__UpperCAmelCase	: Dict		=					False
									__UpperCAmelCase	: Optional[Any]		=					True
									__UpperCAmelCase	: int		=					model_class(UpperCamelCase_)
									model.to(UpperCamelCase_)
									model.eval()
									with torch.no_grad():
												__UpperCAmelCase	: Optional[Any]		=					model(**self._prepare_for_class(UpperCamelCase_      ,  UpperCamelCase_))
									__UpperCAmelCase	: Union[str, Any]		=					outputs.attentions

									__UpperCAmelCase	: Optional[Any]		=					sum(self.model_tester.depths)
									self.assertEqual(len(UpperCamelCase_)      ,  UpperCamelCase_)

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

									self.assertEqual(len(UpperCamelCase_)      ,  UpperCamelCase_)

									# verify the first attentions (first block, first layer)
									__UpperCAmelCase	: Any		=					(self.model_tester.image_size // 4) ** 2
									__UpperCAmelCase	: Optional[int]		=					(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)
									__UpperCAmelCase	: int		=					(self.model_tester.image_size // 32) ** 2
									__UpperCAmelCase	: List[Any]		=					(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]      ,  )
									__UpperCAmelCase	: Optional[int]		=					len(UpperCamelCase_)

									# Check attention is always last and order is fine
									__UpperCAmelCase	: str		=					True
									__UpperCAmelCase	: Union[str, Any]		=					True
									__UpperCAmelCase	: List[str]		=					model_class(UpperCamelCase_)
									model.to(UpperCamelCase_)
									model.eval()
									with torch.no_grad():
												__UpperCAmelCase	: List[Any]		=					model(**self._prepare_for_class(UpperCamelCase_      ,  UpperCamelCase_))

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

									__UpperCAmelCase	: str		=					outputs.attentions

									self.assertEqual(len(UpperCamelCase_)      ,  UpperCamelCase_)
									# verify the first attentions (first block, first layer)
									__UpperCAmelCase	: Union[str, Any]		=					(self.model_tester.image_size // 4) ** 2
									__UpperCAmelCase	: List[Any]		=					(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       a_     (      self      :    Union[str, Any]):


						"""simple docstring"""




						def check_hidden_states_output(UpperCamelCase_      :    List[str]      ,  UpperCamelCase_      :    str      ,  UpperCamelCase_      :    Union[str, Any]):
									__UpperCAmelCase	: Tuple		=					model_class(UpperCamelCase_)
									model.to(UpperCamelCase_)
									model.eval()

									with torch.no_grad():
												__UpperCAmelCase	: Tuple		=					model(**self._prepare_for_class(UpperCamelCase_      ,  UpperCamelCase_))

									__UpperCAmelCase	: int		=					outputs.hidden_states

									__UpperCAmelCase	: Any		=					self.model_tester.num_encoder_blocks
									self.assertEqual(len(UpperCamelCase_)      ,  UpperCamelCase_)

									# 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,
									    ]      ,  )

						__UpperCAmelCase	,     __UpperCAmelCase	: Optional[int]		=					self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									__UpperCAmelCase	: Any		=					True
									check_hidden_states_output(UpperCamelCase_      ,  UpperCamelCase_      ,  UpperCamelCase_)

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									__UpperCAmelCase	: List[Any]		=					True

									check_hidden_states_output(UpperCamelCase_      ,  UpperCamelCase_      ,  UpperCamelCase_)


			def       a_     (      self      :    Any):


						"""simple docstring"""




						if not self.model_tester.is_training:
									return

						__UpperCAmelCase	,     __UpperCAmelCase	: Dict		=					self.model_tester.prepare_config_and_inputs_for_common()
						__UpperCAmelCase	: Optional[Any]		=					True

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

									__UpperCAmelCase	: List[Any]		=					model_class(UpperCamelCase_)
									model.to(UpperCamelCase_)
									model.train()
									__UpperCAmelCase	: Optional[int]		=					self._prepare_for_class(UpperCamelCase_      ,  UpperCamelCase_      ,  return_labels=UpperCamelCase_)
									__UpperCAmelCase	: Tuple		=					model(**UpperCamelCase_).loss
									loss.backward()


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


						"""simple docstring"""




						pass


			@slow
			def       a_     (      self      :    int):


						"""simple docstring"""




						for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__UpperCAmelCase	: Optional[Any]		=					SegformerModel.from_pretrained(UpperCamelCase_)
									self.assertIsNotNone(UpperCamelCase_)






def 					_UpperCamelCase    (			)			->			Dict:


			"""simple docstring"""
			__UpperCAmelCase	: List[str]		=					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"							)
			return image





@require_torch
class      a__				(	unittest.TestCase   ):


			@slow
			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[int]		=					SegformerImageProcessor(
						    image_scale=(512, 512)      ,  keep_ratio=UpperCamelCase_      ,  align=UpperCamelCase_      ,  do_random_crop=UpperCamelCase_)
						__UpperCAmelCase	: List[str]		=					SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512").to(
						    UpperCamelCase_)

						__UpperCAmelCase	: Dict		=					prepare_img()
						__UpperCAmelCase	: List[Any]		=					image_processor(images=UpperCamelCase_      ,  return_tensors="pt")
						__UpperCAmelCase	: Optional[int]		=					encoded_inputs.pixel_values.to(UpperCamelCase_)

						with torch.no_grad():
									__UpperCAmelCase	: Tuple		=					model(UpperCamelCase_)

						__UpperCAmelCase	: Optional[int]		=					torch.Size((1, model.config.num_labels, 128, 128))
						self.assertEqual(outputs.logits.shape      ,  UpperCamelCase_)

						__UpperCAmelCase	: List[str]		=					torch.tensor(
						    [
						        [[-4.6310, -5.5232, -6.2356], [-5.1921, -6.1444, -6.5996], [-5.4424, -6.2790, -6.7574]],
						        [[-12.1391, -13.3122, -13.9554], [-12.8732, -13.9352, -14.3563], [-12.9438, -13.8226, -14.2513]],
						        [[-12.5134, -13.4686, -14.4915], [-12.8669, -14.4343, -14.7758], [-13.2523, -14.5819, -15.0694]],
						    ]).to(UpperCamelCase_)
						self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]      ,  UpperCamelCase_      ,  atol=1e-4))


			@slow
			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: Any		=					SegformerImageProcessor(
						    image_scale=(512, 512)      ,  keep_ratio=UpperCamelCase_      ,  align=UpperCamelCase_      ,  do_random_crop=UpperCamelCase_)
						__UpperCAmelCase	: Dict		=					SegformerForSemanticSegmentation.from_pretrained(
						    "nvidia/segformer-b1-finetuned-cityscapes-1024-1024").to(UpperCamelCase_)

						__UpperCAmelCase	: Union[str, Any]		=					prepare_img()
						__UpperCAmelCase	: Optional[Any]		=					image_processor(images=UpperCamelCase_      ,  return_tensors="pt")
						__UpperCAmelCase	: int		=					encoded_inputs.pixel_values.to(UpperCamelCase_)

						with torch.no_grad():
									__UpperCAmelCase	: Tuple		=					model(UpperCamelCase_)

						__UpperCAmelCase	: str		=					torch.Size((1, model.config.num_labels, 128, 128))
						self.assertEqual(outputs.logits.shape      ,  UpperCamelCase_)

						__UpperCAmelCase	: Optional[int]		=					torch.tensor(
						    [
						        [[-13.5748, -13.9111, -12.6500], [-14.3500, -15.3683, -14.2328], [-14.7532, -16.0424, -15.6087]],
						        [[-17.1651, -15.8725, -12.9653], [-17.2580, -17.3718, -14.8223], [-16.6058, -16.8783, -16.7452]],
						        [[-3.6456, -3.0209, -1.4203], [-3.0797, -3.1959, -2.0000], [-1.8757, -1.9217, -1.6997]],
						    ]).to(UpperCamelCase_)
						self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]      ,  UpperCamelCase_      ,  atol=1e-1))


			@slow
			def       a_     (      self      :    Tuple):


						"""simple docstring"""




						__UpperCAmelCase	: Optional[int]		=					SegformerImageProcessor(
						    image_scale=(512, 512)      ,  keep_ratio=UpperCamelCase_      ,  align=UpperCamelCase_      ,  do_random_crop=UpperCamelCase_)
						__UpperCAmelCase	: Union[str, Any]		=					SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512").to(
						    UpperCamelCase_)

						__UpperCAmelCase	: Dict		=					prepare_img()
						__UpperCAmelCase	: Any		=					image_processor(images=UpperCamelCase_      ,  return_tensors="pt")
						__UpperCAmelCase	: List[str]		=					encoded_inputs.pixel_values.to(UpperCamelCase_)

						with torch.no_grad():
									__UpperCAmelCase	: Tuple		=					model(UpperCamelCase_)

						__UpperCAmelCase	: Any		=					outputs.logits.detach().cpu()

						__UpperCAmelCase	: Optional[int]		=					image_processor.post_process_semantic_segmentation(outputs=UpperCamelCase_      ,  target_sizes=[(500, 300)])
						__UpperCAmelCase	: Tuple		=					torch.Size((500, 300))
						self.assertEqual(segmentation[0].shape      ,  UpperCamelCase_)

						__UpperCAmelCase	: List[Any]		=					image_processor.post_process_semantic_segmentation(outputs=UpperCamelCase_)
						__UpperCAmelCase	: str		=					torch.Size((128, 128))
						self.assertEqual(segmentation[0].shape      ,  UpperCamelCase_)


