


"""simple docstring"""




import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
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, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch
	from torch import nn

	from transformers import (
	    MODEL_MAPPING,
	    BeitForImageClassification,
	    BeitForMaskedImageModeling,
	    BeitForSemanticSegmentation,
	    BeitModel,
	)
	from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	import PIL
	from PIL import Image

	from transformers import BeitImageProcessor
class 					lowerCAmelCase	:




		'''simple docstring'''







		def __init__(	self						,       lowerCAmelCase__						,       lowerCAmelCase__=100						,       lowerCAmelCase__=13						,       lowerCAmelCase__=30						,       lowerCAmelCase__=2						,       lowerCAmelCase__=3						,       lowerCAmelCase__=True						,       lowerCAmelCase__=True						,       lowerCAmelCase__=32						,       lowerCAmelCase__=4						,       lowerCAmelCase__=4						,       lowerCAmelCase__=37						,       lowerCAmelCase__="gelu"						,       lowerCAmelCase__=0.1						,       lowerCAmelCase__=0.1						,       lowerCAmelCase__=10						,       lowerCAmelCase__=0.02						,       lowerCAmelCase__=3						,       lowerCAmelCase__=None						,       lowerCAmelCase__=[0, 1, 2, 3]						,       )     ->							List[Any]:
								SCREAMING_SNAKE_CASE													=					parent
								SCREAMING_SNAKE_CASE													=					100
								SCREAMING_SNAKE_CASE													=					batch_size
								SCREAMING_SNAKE_CASE													=					image_size
								SCREAMING_SNAKE_CASE													=					patch_size
								SCREAMING_SNAKE_CASE													=					num_channels
								SCREAMING_SNAKE_CASE													=					is_training
								SCREAMING_SNAKE_CASE													=					use_labels
								SCREAMING_SNAKE_CASE													=					hidden_size
								SCREAMING_SNAKE_CASE													=					num_hidden_layers
								SCREAMING_SNAKE_CASE													=					num_attention_heads
								SCREAMING_SNAKE_CASE													=					intermediate_size
								SCREAMING_SNAKE_CASE													=					hidden_act
								SCREAMING_SNAKE_CASE													=					hidden_dropout_prob
								SCREAMING_SNAKE_CASE													=					attention_probs_dropout_prob
								SCREAMING_SNAKE_CASE													=					type_sequence_label_size
								SCREAMING_SNAKE_CASE													=					initializer_range
								SCREAMING_SNAKE_CASE													=					scope
								SCREAMING_SNAKE_CASE													=					out_indices
								SCREAMING_SNAKE_CASE													=					num_labels

								# in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
								SCREAMING_SNAKE_CASE													=					(image_size // patch_size) ** 2
								SCREAMING_SNAKE_CASE													=					num_patches + 1







		def 							__A						(	self				)     ->							Any:
								SCREAMING_SNAKE_CASE													=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

								SCREAMING_SNAKE_CASE													=					None
								SCREAMING_SNAKE_CASE													=					None
								if self.use_labels:
														SCREAMING_SNAKE_CASE													=					ids_tensor([self.batch_size]						,       self.type_sequence_label_size				)
														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, pixel_labels







		def 							__A						(	self				)     ->							Tuple:
								return BeitConfig(
								    vocab_size=self.vocab_size						,       image_size=self.image_size						,       patch_size=self.patch_size						,       num_channels=self.num_channels						,       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						,       is_decoder=lowerCAmelCase__						,       initializer_range=self.initializer_range						,       out_indices=self.out_indices						,       )







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)     ->							Tuple:
								SCREAMING_SNAKE_CASE													=					BeitModel(config=lowerCAmelCase__				)
								model.to(lowerCAmelCase__				)
								model.eval()
								SCREAMING_SNAKE_CASE													=					model(lowerCAmelCase__				)
								self.parent.assertEqual(result.last_hidden_state.shape						,       (self.batch_size, self.seq_length, self.hidden_size)				)







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)     ->							int:
								SCREAMING_SNAKE_CASE													=					BeitForMaskedImageModeling(config=lowerCAmelCase__				)
								model.to(lowerCAmelCase__				)
								model.eval()
								SCREAMING_SNAKE_CASE													=					model(lowerCAmelCase__				)
								self.parent.assertEqual(result.logits.shape						,       (self.batch_size, self.seq_length - 1, self.vocab_size)				)







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)     ->							Any:
								SCREAMING_SNAKE_CASE													=					self.type_sequence_label_size
								SCREAMING_SNAKE_CASE													=					BeitForImageClassification(lowerCAmelCase__				)
								model.to(lowerCAmelCase__				)
								model.eval()
								SCREAMING_SNAKE_CASE													=					model(lowerCAmelCase__						,       labels=lowerCAmelCase__				)
								self.parent.assertEqual(result.logits.shape						,       (self.batch_size, self.type_sequence_label_size)				)

								# test greyscale images
								SCREAMING_SNAKE_CASE													=					1
								SCREAMING_SNAKE_CASE													=					BeitForImageClassification(lowerCAmelCase__				)
								model.to(lowerCAmelCase__				)
								model.eval()

								SCREAMING_SNAKE_CASE													=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
								SCREAMING_SNAKE_CASE													=					model(lowerCAmelCase__						,       labels=lowerCAmelCase__				)
								self.parent.assertEqual(result.logits.shape						,       (self.batch_size, self.type_sequence_label_size)				)







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__				)     ->							Any:
								SCREAMING_SNAKE_CASE													=					self.num_labels
								SCREAMING_SNAKE_CASE													=					BeitForSemanticSegmentation(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 * 2, self.image_size * 2)				)
								SCREAMING_SNAKE_CASE													=					model(lowerCAmelCase__						,       labels=lowerCAmelCase__				)
								self.parent.assertEqual(
								    result.logits.shape						,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)				)







		def 							__A						(	self				)     ->							Any:
								SCREAMING_SNAKE_CASE													=					self.prepare_config_and_inputs()
								SCREAMING_SNAKE_CASE							,				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 					lowerCAmelCase	(					lowerCamelCase_	,    lowerCamelCase_	,    unittest.TestCase    ):




		'''simple docstring'''







		SCREAMING_SNAKE_CASE_						:     Any								=     (
		    (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
		    if is_torch_available()
		    else ()
		)
		SCREAMING_SNAKE_CASE_						:     str								=     (
		    {
		        """feature-extraction""": BeitModel,
		        """image-classification""": BeitForImageClassification,
		        """image-segmentation""": BeitForSemanticSegmentation,
		    }
		    if is_torch_available()
		    else {}
		)

		SCREAMING_SNAKE_CASE_						:     Optional[Any]								=     False
		SCREAMING_SNAKE_CASE_						:     str								=     False
		SCREAMING_SNAKE_CASE_						:     List[str]								=     False







		def 							__A						(	self				)     ->							List[str]:
								SCREAMING_SNAKE_CASE													=					BeitModelTester(self				)
								SCREAMING_SNAKE_CASE													=					ConfigTester(self						,       config_class=lowerCAmelCase__						,       has_text_modality=lowerCAmelCase__						,       hidden_size=37				)







		def 							__A						(	self				)     ->							Optional[Any]:
								self.config_tester.run_common_tests()







		@unittest.skip(reason='BEiT does not use inputs_embeds'				)
		def 							__A						(	self				)     ->							Optional[int]:
								pass







		@require_torch_multi_gpu
		@unittest.skip(reason='BEiT has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'				)
		def 							__A						(	self				)     ->							Any:
								pass







		def 							__A						(	self				)     ->							int:
								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__				)
														self.assertIsInstance(model.get_input_embeddings()						,       (nn.Module)				)
														SCREAMING_SNAKE_CASE													=					model.get_output_embeddings()
														self.assertTrue(x is None or isinstance(lowerCAmelCase__						,       nn.Linear				)				)







		def 							__A						(	self				)     ->							Dict:
								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 							__A						(	self				)     ->							str:
								SCREAMING_SNAKE_CASE													=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCAmelCase__				)







		def 							__A						(	self				)     ->							Any:
								SCREAMING_SNAKE_CASE													=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase__				)







		def 							__A						(	self				)     ->							Optional[int]:
								SCREAMING_SNAKE_CASE													=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__				)







		def 							__A						(	self				)     ->							Tuple:
								SCREAMING_SNAKE_CASE													=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase__				)







		def 							__A						(	self				)     ->							Optional[int]:
								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:
														# we don't test BeitForMaskedImageModeling
														if model_class in [*get_values(lowerCAmelCase__				), BeitForMaskedImageModeling]:
																				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()







		def 							__A						(	self				)     ->							str:
								SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					self.model_tester.prepare_config_and_inputs_for_common()
								if not self.model_tester.is_training:
														return

								SCREAMING_SNAKE_CASE													=					False
								SCREAMING_SNAKE_CASE													=					True

								for model_class in self.all_model_classes:
														# we don't test BeitForMaskedImageModeling
														if (
														    model_class in [*get_values(lowerCAmelCase__				), BeitForMaskedImageModeling]
														    or not model_class.supports_gradient_checkpointing
														):
																				continue

														SCREAMING_SNAKE_CASE													=					model_class(lowerCAmelCase__				)
														model.gradient_checkpointing_enable()
														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()







		def 							__A						(	self				)     ->							Union[str, Any]:
								SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					self.model_tester.prepare_config_and_inputs_for_common()

								SCREAMING_SNAKE_CASE													=					_config_zero_init(lowerCAmelCase__				)
								for model_class in self.all_model_classes:
														SCREAMING_SNAKE_CASE													=					model_class(config=lowerCAmelCase__				)
														for name, param in model.named_parameters():
																				# we skip lambda parameters as these require special initial values
																				# determined by config.layer_scale_init_value
																				if "lambda" in name:
																										continue
																				if param.requires_grad:
																										self.assertIn(
																										    ((param.data.mean() * 1e9).round() / 1e9).item()						,       [0.0, 1.0]						,       msg=F'Parameter {name} of model {model_class} seems not properly initialized'						,       )







		@slow
		def 							__A						(	self				)     ->							Any:
								for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														SCREAMING_SNAKE_CASE													=					BeitModel.from_pretrained(lowerCAmelCase__				)
														self.assertIsNotNone(lowerCAmelCase__				)





def     lowercase			()   ->						Union[str, Any]:
						SCREAMING_SNAKE_CASE													=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
						return image


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




		'''simple docstring'''







		@cached_property
		def 							__A						(	self				)     ->							int:
								return BeitImageProcessor.from_pretrained('microsoft/beit-base-patch16-224'				) if is_vision_available() else None







		@slow
		def 							__A						(	self				)     ->							Optional[Any]:
								SCREAMING_SNAKE_CASE													=					BeitForMaskedImageModeling.from_pretrained('microsoft/beit-base-patch16-224-pt22k'				).to(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					self.default_image_processor
								SCREAMING_SNAKE_CASE													=					prepare_img()
								SCREAMING_SNAKE_CASE													=					image_processor(images=lowerCAmelCase__						,       return_tensors='pt'				).pixel_values.to(lowerCAmelCase__				)

								# prepare bool_masked_pos
								SCREAMING_SNAKE_CASE													=					torch.ones((1, 196)						,       dtype=torch.bool				).to(lowerCAmelCase__				)

								# forward pass
								with torch.no_grad():
														SCREAMING_SNAKE_CASE													=					model(pixel_values=lowerCAmelCase__						,       bool_masked_pos=lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					outputs.logits

								# verify the logits
								SCREAMING_SNAKE_CASE													=					torch.Size((1, 196, 8_192)				)
								self.assertEqual(logits.shape						,       lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					torch.tensor(
								    [[-3.24_37, 0.50_72, -13.91_74], [-3.24_56, 0.49_48, -13.94_01], [-3.20_33, 0.51_21, -13.85_50]]				).to(lowerCAmelCase__				)

								self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]						,       lowerCAmelCase__						,       atol=1e-2				)				)







		@slow
		def 							__A						(	self				)     ->							List[str]:
								SCREAMING_SNAKE_CASE													=					BeitForImageClassification.from_pretrained('microsoft/beit-base-patch16-224'				).to(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					self.default_image_processor
								SCREAMING_SNAKE_CASE													=					prepare_img()
								SCREAMING_SNAKE_CASE													=					image_processor(images=lowerCAmelCase__						,       return_tensors='pt'				).to(lowerCAmelCase__				)

								# forward pass
								with torch.no_grad():
														SCREAMING_SNAKE_CASE													=					model(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					outputs.logits

								# verify the logits
								SCREAMING_SNAKE_CASE													=					torch.Size((1, 1_000)				)
								self.assertEqual(logits.shape						,       lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					torch.tensor([-1.23_85, -1.09_87, -1.01_08]				).to(lowerCAmelCase__				)

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

								SCREAMING_SNAKE_CASE													=					281
								self.assertEqual(logits.argmax(-1				).item()						,       lowerCAmelCase__				)







		@slow
		def 							__A						(	self				)     ->							Optional[Any]:
								SCREAMING_SNAKE_CASE													=					BeitForImageClassification.from_pretrained('microsoft/beit-large-patch16-224-pt22k-ft22k'				).to(
								    lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					self.default_image_processor
								SCREAMING_SNAKE_CASE													=					prepare_img()
								SCREAMING_SNAKE_CASE													=					image_processor(images=lowerCAmelCase__						,       return_tensors='pt'				).to(lowerCAmelCase__				)

								# forward pass
								with torch.no_grad():
														SCREAMING_SNAKE_CASE													=					model(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					outputs.logits

								# verify the logits
								SCREAMING_SNAKE_CASE													=					torch.Size((1, 21_841)				)
								self.assertEqual(logits.shape						,       lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					torch.tensor([1.68_81, -0.27_87, 0.59_01]				).to(lowerCAmelCase__				)

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

								SCREAMING_SNAKE_CASE													=					2_396
								self.assertEqual(logits.argmax(-1				).item()						,       lowerCAmelCase__				)







		@slow
		def 							__A						(	self				)     ->							Optional[int]:
								SCREAMING_SNAKE_CASE													=					BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640'				)
								SCREAMING_SNAKE_CASE													=					model.to(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					BeitImageProcessor(do_resize=lowerCAmelCase__						,       size=640						,       do_center_crop=lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					load_dataset('hf-internal-testing/fixtures_ade20k'						,       split='test'				)
								SCREAMING_SNAKE_CASE													=					Image.open(ds[0]['file']				)
								SCREAMING_SNAKE_CASE													=					image_processor(images=lowerCAmelCase__						,       return_tensors='pt'				).to(lowerCAmelCase__				)

								# forward pass
								with torch.no_grad():
														SCREAMING_SNAKE_CASE													=					model(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					outputs.logits

								# verify the logits
								SCREAMING_SNAKE_CASE													=					torch.Size((1, 150, 160, 160)				)
								self.assertEqual(logits.shape						,       lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					version.parse(PIL.__version__				) < version.parse('9.0.0'				)

								if is_pillow_less_than_a:
														SCREAMING_SNAKE_CASE													=					torch.tensor(
														    [
														        [[-4.92_25, -2.39_54, -3.05_22], [-2.88_22, -1.00_46, -1.75_61], [-2.95_49, -1.32_28, -2.13_47]],
														        [[-5.81_68, -3.41_29, -4.07_78], [-3.86_51, -2.22_14, -3.02_77], [-3.83_56, -2.46_43, -3.35_35]],
														        [[-0.00_78, 3.99_52, 4.07_54], [2.98_56, 4.69_44, 5.00_35], [3.24_13, 4.78_13, 4.99_69]],
														    ]						,       device=lowerCAmelCase__						,       )
								else:
														SCREAMING_SNAKE_CASE													=					torch.tensor(
														    [
														        [[-4.89_60, -2.36_88, -3.03_55], [-2.84_78, -0.98_36, -1.74_18], [-2.94_49, -1.33_32, -2.14_56]],
														        [[-5.80_81, -3.41_24, -4.10_06], [-3.85_61, -2.20_81, -3.03_23], [-3.83_65, -2.46_01, -3.36_69]],
														        [[-0.03_09, 3.98_68, 4.05_40], [2.96_40, 4.68_77, 4.99_76], [3.20_81, 4.76_90, 4.99_42]],
														    ]						,       device=lowerCAmelCase__						,       )

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







		@slow
		def 							__A						(	self				)     ->							str:
								SCREAMING_SNAKE_CASE													=					BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640'				)
								SCREAMING_SNAKE_CASE													=					model.to(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					BeitImageProcessor(do_resize=lowerCAmelCase__						,       size=640						,       do_center_crop=lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					load_dataset('hf-internal-testing/fixtures_ade20k'						,       split='test'				)
								SCREAMING_SNAKE_CASE													=					Image.open(ds[0]['file']				)
								SCREAMING_SNAKE_CASE													=					image_processor(images=lowerCAmelCase__						,       return_tensors='pt'				).to(lowerCAmelCase__				)

								# forward pass
								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((160, 160)				)
								self.assertEqual(segmentation[0].shape						,       lowerCAmelCase__				)






"""simple docstring"""




def     lowercase			(SCREAMING_SNAKE_CASE_		:				int = 10_00  )   ->						int:
						SCREAMING_SNAKE_CASE													=					2**power
						SCREAMING_SNAKE_CASE													=					0
						while n:
												SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					r + n % 10, n // 10
						return r


if __name__ == "__main__":
	print(solution(int(str(input()).strip())))


