



import datetime
import platform
import subprocess
from typing import Optional, Tuple, Union

import numpy as np






def      _A				(UpperCamelCase		:      bytes      ,			UpperCamelCase		:      int )  ->np.array:



			'''simple docstring'''







			lowerCamelCase__ :      int								=		f"{sampling_rate}"
			lowerCamelCase__ :      List[Any]								=		"""1"""
			lowerCamelCase__ :      Optional[int]								=		"""f32le"""
			lowerCamelCase__ :      str								=		[
			    """ffmpeg""",
			    """-i""",
			    """pipe:0""",
			    """-ac""",
			    ac,
			    """-ar""",
			    ar,
			    """-f""",
			    format_for_conversion,
			    """-hide_banner""",
			    """-loglevel""",
			    """quiet""",
			    """pipe:1""",
			]

			try:
						with subprocess.Popen(UpperCamelCase      ,			stdin=subprocess.PIPE      ,			stdout=subprocess.PIPE ) as ffmpeg_process:
									lowerCamelCase__ :      Dict								=		ffmpeg_process.communicate(UpperCamelCase )
			except FileNotFoundError as error:
						raise ValueError("""ffmpeg was not found but is required to load audio files from filename""" ) from error
			lowerCamelCase__ :      Any								=		output_stream[0]
			lowerCamelCase__ :      Optional[Any]								=		np.frombuffer(UpperCamelCase      ,			np.floataa )
			if audio.shape[0] == 0:
						raise ValueError("""Malformed soundfile""" )
			return audio






def      _A				(UpperCamelCase		:      int      ,			UpperCamelCase		:      float      ,			UpperCamelCase		:      str = "f32le"      ,			)  ->Union[str, Any]:



			'''simple docstring'''







			lowerCamelCase__ :      int								=		f"{sampling_rate}"
			lowerCamelCase__ :      Dict								=		"""1"""
			if format_for_conversion == "s16le":
						lowerCamelCase__ :      str								=		2
			elif format_for_conversion == "f32le":
						lowerCamelCase__ :      Any								=		4
			else:
						raise ValueError(f"Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`" )

			lowerCamelCase__ :      List[str]								=		platform.system()
			if system == "Linux":
						lowerCamelCase__ :      str								=		"""alsa"""
						lowerCamelCase__ :      Dict								=		"""default"""
			elif system == "Darwin":
						lowerCamelCase__ :      Optional[int]								=		"""avfoundation"""
						lowerCamelCase__ :      Optional[int]								=		""":0"""
			elif system == "Windows":
						lowerCamelCase__ :      str								=		"""dshow"""
						lowerCamelCase__ :      Tuple								=		"""default"""

			lowerCamelCase__ :      Tuple								=		[
			    """ffmpeg""",
			    """-f""",
			    format_,
			    """-i""",
			    input_,
			    """-ac""",
			    ac,
			    """-ar""",
			    ar,
			    """-f""",
			    format_for_conversion,
			    """-fflags""",
			    """nobuffer""",
			    """-hide_banner""",
			    """-loglevel""",
			    """quiet""",
			    """pipe:1""",
			]
			lowerCamelCase__ :      Optional[int]								=		int(round(sampling_rate * chunk_length_s ) ) * size_of_sample
			lowerCamelCase__ :      Dict								=		_ffmpeg_stream(UpperCamelCase      ,			UpperCamelCase )
			for item in iterator:
						yield item






def      _A				(UpperCamelCase		:      int      ,			UpperCamelCase		:      float      ,			UpperCamelCase		:      Optional[int] = None      ,			UpperCamelCase		:      Optional[Union[Tuple[float, float], float]] = None      ,			UpperCamelCase		:      str = "f32le"      ,			)  ->int:



			'''simple docstring'''







			if stream_chunk_s is not None:
						lowerCamelCase__ :      Optional[Any]								=		stream_chunk_s
			else:
						lowerCamelCase__ :      Union[str, Any]								=		chunk_length_s

			lowerCamelCase__ :      Any								=		ffmpeg_microphone(UpperCamelCase      ,			UpperCamelCase      ,			format_for_conversion=UpperCamelCase )
			if format_for_conversion == "s16le":
						lowerCamelCase__ :      Any								=		np.intaa
						lowerCamelCase__ :      List[Any]								=		2
			elif format_for_conversion == "f32le":
						lowerCamelCase__ :      Dict								=		np.floataa
						lowerCamelCase__ :      Tuple								=		4
			else:
						raise ValueError(f"Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`" )

			if stride_length_s is None:
						lowerCamelCase__ :      List[Any]								=		chunk_length_s / 6
			lowerCamelCase__ :      Optional[Any]								=		int(round(sampling_rate * chunk_length_s ) ) * size_of_sample
			if isinstance(UpperCamelCase      ,			(int, float) ):
						lowerCamelCase__ :      List[Any]								=		[stride_length_s, stride_length_s]

			lowerCamelCase__ :      int								=		int(round(sampling_rate * stride_length_s[0] ) ) * size_of_sample
			lowerCamelCase__ :      Optional[Any]								=		int(round(sampling_rate * stride_length_s[1] ) ) * size_of_sample
			lowerCamelCase__ :      int								=		datetime.datetime.now()
			lowerCamelCase__ :      Optional[int]								=		datetime.timedelta(seconds=UpperCamelCase )
			for item in chunk_bytes_iter(UpperCamelCase      ,			UpperCamelCase      ,			stride=(stride_left, stride_right)      ,			stream=UpperCamelCase ):
						# Put everything back in numpy scale
						lowerCamelCase__ :      Optional[int]								=		np.frombuffer(item["""raw"""]      ,			dtype=UpperCamelCase )
						lowerCamelCase__ :      List[str]								=		(
						    item["""stride"""][0] // size_of_sample,
						    item["""stride"""][1] // size_of_sample,
						)
						lowerCamelCase__ :      int								=		sampling_rate
						audio_time += delta
						if datetime.datetime.now() > audio_time + 10 * delta:
									# We're late !! SKIP
									continue
						yield item






def      _A				(UpperCamelCase		:      List[str]      ,			UpperCamelCase		:      int      ,			UpperCamelCase		:      Tuple[int, int]      ,			UpperCamelCase		:      bool = False )  ->Union[str, Any]:



			'''simple docstring'''







			lowerCamelCase__ :      Optional[Any]								=		B""""""
			lowerCamelCase__							,lowerCamelCase__ :      str								=		stride
			if stride_left + stride_right >= chunk_len:
						raise ValueError(
						    f"Stride needs to be strictly smaller than chunk_len: ({stride_left}, {stride_right}) vs {chunk_len}" )
			lowerCamelCase__ :      List[str]								=		0
			for raw in iterator:
						acc += raw
						if stream and len(UpperCamelCase ) < chunk_len:
									lowerCamelCase__ :      Any								=		(_stride_left, 0)
									yield {"raw": acc[:chunk_len], "stride": stride, "partial": True}
						else:
									while len(UpperCamelCase ) >= chunk_len:
												# We are flushing the accumulator
												lowerCamelCase__ :      List[str]								=		(_stride_left, stride_right)
												lowerCamelCase__ :      Optional[int]								=		{"""raw""": acc[:chunk_len], """stride""": stride}
												if stream:
															lowerCamelCase__ :      Any								=		False
												yield item
												lowerCamelCase__ :      str								=		stride_left
												lowerCamelCase__ :      Optional[Any]								=		acc[chunk_len - stride_left - stride_right :]
    # Last chunk
			if len(UpperCamelCase ) > stride_left:
						lowerCamelCase__ :      List[str]								=		{"""raw""": acc, """stride""": (_stride_left, 0)}
						if stream:
									lowerCamelCase__ :      List[str]								=		False
						yield item






def      _A				(UpperCamelCase		:      Dict      ,			UpperCamelCase		:      int )  ->Any:



			'''simple docstring'''







			lowerCamelCase__ :      Optional[Any]								=		2**24  # 16Mo
			try:
						with subprocess.Popen(UpperCamelCase      ,			stdout=subprocess.PIPE      ,			bufsize=UpperCamelCase ) as ffmpeg_process:
									while True:
												lowerCamelCase__ :      List[str]								=		ffmpeg_process.stdout.read(UpperCamelCase )
												if raw == b"":
															break
												yield raw
			except FileNotFoundError as error:
						raise ValueError("""ffmpeg was not found but is required to stream audio files from filename""" ) from error








import inspect
import unittest

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

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 MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
				from transformers.models.mobilevitva.modeling_mobilevitva import (
				    MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
				    make_divisible,
				)


if is_vision_available():
				from PIL import Image

				from transformers import MobileViTImageProcessor
class 				__A					( A_      ):





			def        _snake_case    (self				):
						lowerCamelCase__ :      Dict								=		self.config_class(**self.inputs_dict				)
						self.parent.assertTrue(hasattr(__magic_name__							,    """width_multiplier"""				)				)







class 				__A					:





			def __init__(self							,    __magic_name__							,    __magic_name__=13							,    __magic_name__=64							,    __magic_name__=2							,    __magic_name__=3							,    __magic_name__="swish"							,    __magic_name__=3							,    __magic_name__=32							,    __magic_name__=0.1							,    __magic_name__=0.02							,    __magic_name__=True							,    __magic_name__=True							,    __magic_name__=10							,    __magic_name__=None							,    __magic_name__=0.25							,    __magic_name__=0.0							,    __magic_name__=0.0							,    ):
						lowerCamelCase__ :      Optional[Any]								=		parent
						lowerCamelCase__ :      List[Any]								=		batch_size
						lowerCamelCase__ :      Optional[Any]								=		image_size
						lowerCamelCase__ :      Union[str, Any]								=		patch_size
						lowerCamelCase__ :      Dict								=		num_channels
						lowerCamelCase__ :      Optional[Any]								=		make_divisible(512 * width_multiplier							,    divisor=8				)
						lowerCamelCase__ :      str								=		hidden_act
						lowerCamelCase__ :      Union[str, Any]								=		conv_kernel_size
						lowerCamelCase__ :      int								=		output_stride
						lowerCamelCase__ :      Tuple								=		classifier_dropout_prob
						lowerCamelCase__ :      Optional[Any]								=		use_labels
						lowerCamelCase__ :      Tuple								=		is_training
						lowerCamelCase__ :      List[Any]								=		num_labels
						lowerCamelCase__ :      str								=		initializer_range
						lowerCamelCase__ :      Optional[Any]								=		scope
						lowerCamelCase__ :      Tuple								=		width_multiplier
						lowerCamelCase__ :      List[Any]								=		ffn_dropout
						lowerCamelCase__ :      Union[str, Any]								=		attn_dropout





			def        _snake_case    (self				):
						lowerCamelCase__ :      Optional[int]								=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

						lowerCamelCase__ :      str								=		None
						lowerCamelCase__ :      List[Any]								=		None
						if self.use_labels:
									lowerCamelCase__ :      Tuple								=		ids_tensor([self.batch_size]							,    self.num_labels				)
									lowerCamelCase__ :      List[Any]								=		ids_tensor([self.batch_size, self.image_size, self.image_size]							,    self.num_labels				)

						lowerCamelCase__ :      int								=		self.get_config()

						return config, pixel_values, labels, pixel_labels





			def        _snake_case    (self				):
						return MobileViTVaConfig(
						    image_size=self.image_size							,    patch_size=self.patch_size							,    num_channels=self.num_channels							,    hidden_act=self.hidden_act							,    conv_kernel_size=self.conv_kernel_size							,    output_stride=self.output_stride							,    classifier_dropout_prob=self.classifier_dropout_prob							,    initializer_range=self.initializer_range							,    width_multiplier=self.width_multiplier							,    ffn_dropout=self.ffn_dropout_prob							,    attn_dropout=self.attn_dropout_prob							,    )





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__				):
						lowerCamelCase__ :      Any								=		MobileViTVaModel(config=__magic_name__				)
						model.to(__magic_name__				)
						model.eval()
						lowerCamelCase__ :      Optional[Any]								=		model(__magic_name__				)
						self.parent.assertEqual(
						    result.last_hidden_state.shape							,    (
						        self.batch_size,
						        self.last_hidden_size,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )							,    )





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__				):
						lowerCamelCase__ :      List[str]								=		self.num_labels
						lowerCamelCase__ :      Optional[int]								=		MobileViTVaForImageClassification(__magic_name__				)
						model.to(__magic_name__				)
						model.eval()
						lowerCamelCase__ :      Dict								=		model(__magic_name__							,    labels=__magic_name__				)
						self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_labels)				)





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__				):
						lowerCamelCase__ :      Dict								=		self.num_labels
						lowerCamelCase__ :      Any								=		MobileViTVaForSemanticSegmentation(__magic_name__				)
						model.to(__magic_name__				)
						model.eval()
						lowerCamelCase__ :      Optional[int]								=		model(__magic_name__				)
						self.parent.assertEqual(
						    result.logits.shape							,    (
						        self.batch_size,
						        self.num_labels,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )							,    )
						lowerCamelCase__ :      Dict								=		model(__magic_name__							,    labels=__magic_name__				)
						self.parent.assertEqual(
						    result.logits.shape							,    (
						        self.batch_size,
						        self.num_labels,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )							,    )





			def        _snake_case    (self				):
						lowerCamelCase__ :      Any								=		self.prepare_config_and_inputs()
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      List[str]								=		config_and_inputs
						lowerCamelCase__ :      str								=		{"""pixel_values""": pixel_values}
						return config, inputs_dict







@require_torch
class 				__A					( A_					, A_					, unittest.TestCase      ):
			UpperCamelCase					:Optional[Any]     =			(
			    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
			    if is_torch_available()
			    else ()
			)

			UpperCamelCase					:List[Any]     =			(
			    {
			        '''feature-extraction''': MobileViTVaModel,
			        '''image-classification''': MobileViTVaForImageClassification,
			        '''image-segmentation''': MobileViTVaForSemanticSegmentation,
			    }
			    if is_torch_available()
			    else {}
			)

			UpperCamelCase					:List[Any]     =			False
			UpperCamelCase					:int     =			False
			UpperCamelCase					:Optional[int]     =			False
			UpperCamelCase					:int     =			False





			def        _snake_case    (self				):
						lowerCamelCase__ :      Optional[int]								=		MobileViTVaModelTester(self				)
						lowerCamelCase__ :      Optional[int]								=		MobileViTVaConfigTester(self							,    config_class=__magic_name__							,    has_text_modality=__magic_name__				)





			def        _snake_case    (self				):
						self.config_tester.run_common_tests()





			@unittest.skip(reason="""MobileViTV2 does not use inputs_embeds"""				)
			def        _snake_case    (self				):
						pass





			@unittest.skip(reason="""MobileViTV2 does not support input and output embeddings"""				)
			def        _snake_case    (self				):
						pass





			@unittest.skip(reason="""MobileViTV2 does not output attentions"""				)
			def        _snake_case    (self				):
						pass





			@require_torch_multi_gpu
			@unittest.skip(reason="""Got `CUDA error: misaligned address` for tests after this one being run."""				)
			def        _snake_case    (self				):
						pass





			@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""				)
			def        _snake_case    (self				):
						pass





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__ :      Union[str, Any]								=		self.model_tester.prepare_config_and_inputs_for_common()

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

									lowerCamelCase__ :      Union[str, Any]								=		["""pixel_values"""]
									self.assertListEqual(arg_names[:1]							,    __magic_name__				)





			def        _snake_case    (self				):
						lowerCamelCase__ :      int								=		self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__magic_name__				)





			def        _snake_case    (self				):
						def check_hidden_states_output(__magic_name__							,    __magic_name__							,    __magic_name__				):
									lowerCamelCase__ :      Dict								=		model_class(__magic_name__				)
									model.to(__magic_name__				)
									model.eval()

									with torch.no_grad():
												lowerCamelCase__ :      Optional[int]								=		model(**self._prepare_for_class(__magic_name__							,    __magic_name__				)				)

									lowerCamelCase__ :      str								=		outputs.hidden_states

									lowerCamelCase__ :      Dict								=		5
									self.assertEqual(len(__magic_name__				)							,    __magic_name__				)

									# MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
									# with the width and height being successively divided by 2.
									lowerCamelCase__ :      Dict								=		2
									for i in range(len(__magic_name__				)				):
												self.assertListEqual(
												    list(hidden_states[i].shape[-2:]				)							,    [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]							,    )
												divisor *= 2

									self.assertEqual(self.model_tester.output_stride							,    divisor // 2				)

						lowerCamelCase__							,lowerCamelCase__ :      Optional[Any]								=		self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									lowerCamelCase__ :      Any								=		True
									check_hidden_states_output(__magic_name__							,    __magic_name__							,    __magic_name__				)

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

									check_hidden_states_output(__magic_name__							,    __magic_name__							,    __magic_name__				)





			def        _snake_case    (self				):
						lowerCamelCase__ :      Tuple								=		self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__magic_name__				)





			def        _snake_case    (self				):
						lowerCamelCase__ :      List[Any]								=		self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*__magic_name__				)





			@slow
			def        _snake_case    (self				):
						for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowerCamelCase__ :      int								=		MobileViTVaModel.from_pretrained(__magic_name__				)
									self.assertIsNotNone(__magic_name__				)







def      _A				()  ->List[Any]:



			'''simple docstring'''







			lowerCamelCase__ :      Tuple								=		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
			return image
@require_torch
@require_vision
class 				__A					( unittest.TestCase      ):





			@cached_property
			def        _snake_case    (self				):
						return (
						    MobileViTImageProcessor.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""				)
						    if is_vision_available()
						    else None
						)





			@slow
			def        _snake_case    (self				):
						lowerCamelCase__ :      str								=		MobileViTVaForImageClassification.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""				).to(
						    __magic_name__				)

						lowerCamelCase__ :      Union[str, Any]								=		self.default_image_processor
						lowerCamelCase__ :      Any								=		prepare_img()
						lowerCamelCase__ :      Optional[Any]								=		image_processor(images=__magic_name__							,    return_tensors="""pt"""				).to(__magic_name__				)

						# forward pass
						with torch.no_grad():
									lowerCamelCase__ :      List[str]								=		model(**__magic_name__				)

						# verify the logits
						lowerCamelCase__ :      List[Any]								=		torch.Size((1, 1000)				)
						self.assertEqual(outputs.logits.shape							,    __magic_name__				)

						lowerCamelCase__ :      Optional[Any]								=		torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]				).to(__magic_name__				)

						self.assertTrue(torch.allclose(outputs.logits[0, :3]							,    __magic_name__							,    atol=1E-4				)				)





			@slow
			def        _snake_case    (self				):
						lowerCamelCase__ :      Optional[int]								=		MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""				)
						lowerCamelCase__ :      Dict								=		model.to(__magic_name__				)

						lowerCamelCase__ :      str								=		MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""				)

						lowerCamelCase__ :      str								=		prepare_img()
						lowerCamelCase__ :      str								=		image_processor(images=__magic_name__							,    return_tensors="""pt"""				).to(__magic_name__				)

						# forward pass
						with torch.no_grad():
									lowerCamelCase__ :      Dict								=		model(**__magic_name__				)
						lowerCamelCase__ :      List[str]								=		outputs.logits

						# verify the logits
						lowerCamelCase__ :      Tuple								=		torch.Size((1, 21, 32, 32)				)
						self.assertEqual(logits.shape							,    __magic_name__				)

						lowerCamelCase__ :      Any								=		torch.tensor(
						    [
						        [[7.08_63, 7.15_25, 6.82_01], [6.69_31, 6.87_70, 6.89_33], [6.29_78, 7.03_66, 6.96_36]],
						        [[-3.71_34, -3.67_12, -3.66_75], [-3.58_25, -3.35_49, -3.47_77], [-3.34_35, -3.39_79, -3.28_57]],
						        [[-2.93_29, -2.80_03, -2.73_69], [-3.05_64, -2.47_80, -2.02_07], [-2.68_89, -1.92_98, -1.76_40]],
						    ]							,    device=__magic_name__							,    )

						self.assertTrue(torch.allclose(logits[0, :3, :3, :3]							,    __magic_name__							,    atol=1E-4				)				)





			@slow
			def        _snake_case    (self				):
						lowerCamelCase__ :      Union[str, Any]								=		MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""				)
						lowerCamelCase__ :      List[Any]								=		model.to(__magic_name__				)

						lowerCamelCase__ :      Optional[int]								=		MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""				)

						lowerCamelCase__ :      Union[str, Any]								=		prepare_img()
						lowerCamelCase__ :      Dict								=		image_processor(images=__magic_name__							,    return_tensors="""pt"""				).to(__magic_name__				)

						# forward pass
						with torch.no_grad():
									lowerCamelCase__ :      List[str]								=		model(**__magic_name__				)

						lowerCamelCase__ :      str								=		outputs.logits.detach().cpu()

						lowerCamelCase__ :      Optional[int]								=		image_processor.post_process_semantic_segmentation(outputs=__magic_name__							,    target_sizes=[(50, 60)]				)
						lowerCamelCase__ :      List[Any]								=		torch.Size((50, 60)				)
						self.assertEqual(segmentation[0].shape							,    __magic_name__				)

						lowerCamelCase__ :      List[str]								=		image_processor.post_process_semantic_segmentation(outputs=__magic_name__				)
						lowerCamelCase__ :      int								=		torch.Size((32, 32)				)
						self.assertEqual(segmentation[0].shape							,    __magic_name__				)



