

import inspect
import unittest

from huggingface_hub import hf_hub_download

from transformers import ConvNextConfig, UperNetConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import 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 transformers import UperNetForSemanticSegmentation
					from transformers.models.upernet.modeling_upernet import UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor







class 				lowercase       :




				def __init__(      self   ,     snake_case   ,     snake_case=13   ,     snake_case=32   ,     snake_case=3   ,     snake_case=4   ,     snake_case=[10, 20, 30, 40]   ,     snake_case=[2, 2, 3, 2]   ,     snake_case=True   ,     snake_case=True   ,     snake_case=37   ,     snake_case="gelu"   ,     snake_case=10   ,     snake_case=0.02   ,     snake_case=["stage2", "stage3", "stage4"]   ,     snake_case=3   ,     snake_case=None   ,     ):
											snake_case_           =					parent
											snake_case_           =					batch_size
											snake_case_           =					image_size
											snake_case_           =					num_channels
											snake_case_           =					num_stages
											snake_case_           =					hidden_sizes
											snake_case_           =					depths
											snake_case_           =					is_training
											snake_case_           =					use_labels
											snake_case_           =					intermediate_size
											snake_case_           =					hidden_act
											snake_case_           =					type_sequence_label_size
											snake_case_           =					initializer_range
											snake_case_           =					out_features
											snake_case_           =					num_labels
											snake_case_           =					scope
											snake_case_           =					num_stages




				def 					a							(      self ):
											snake_case_           =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

											snake_case_           =					None
											if self.use_labels:
																		snake_case_           =					ids_tensor([self.batch_size]   ,     self.type_sequence_label_size )

											snake_case_           =					self.get_config()

											return config, pixel_values, labels




				def 					a							(      self ):
											return ConvNextConfig(
											    num_channels=self.num_channels   ,     num_stages=self.num_stages   ,     hidden_sizes=self.hidden_sizes   ,     depths=self.depths   ,     is_training=self.is_training   ,     intermediate_size=self.intermediate_size   ,     hidden_act=self.hidden_act   ,     out_features=self.out_features   ,     )




				def 					a							(      self ):
											return UperNetConfig(
											    backbone_config=self.get_backbone_config()   ,     hidden_size=512   ,     pool_scales=[1, 2, 3, 6]   ,     use_auxiliary_head=snake_case   ,     auxiliary_loss_weight=0.4   ,     auxiliary_in_channels=40   ,     auxiliary_channels=256   ,     auxiliary_num_convs=1   ,     auxiliary_concat_input=snake_case   ,     loss_ignore_index=255   ,     num_labels=self.num_labels   ,     )




				def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case ):
											snake_case_           =					UperNetForSemanticSegmentation(config=snake_case )
											model.to(snake_case )
											model.eval()
											snake_case_           =					model(snake_case )
											self.parent.assertEqual(
											    result.logits.shape   ,     (self.batch_size, self.num_labels, self.image_size, self.image_size) )




				def 					a							(      self ):
											snake_case_           =					self.prepare_config_and_inputs()
											(
											    (
											    snake_case_
											)       ,					(
											    snake_case_
											)       ,					(
											    snake_case_
											)       ,					
											)           =					config_and_inputs
											snake_case_           =					{'pixel_values': pixel_values}
											return config, inputs_dict







@require_torch
class 				lowercase       ( lowercase_			,						lowercase_			,						unittest.TestCase    ):
				__SCREAMING_SNAKE_CASE      :				int     =    (UperNetForSemanticSegmentation,) if is_torch_available() else ()
				__SCREAMING_SNAKE_CASE      :				List[str]     =    {'''image-segmentation''': UperNetForSemanticSegmentation} if is_torch_available() else {}
				__SCREAMING_SNAKE_CASE      :				List[Any]     =    False
				__SCREAMING_SNAKE_CASE      :				Tuple     =    False
				__SCREAMING_SNAKE_CASE      :				Any     =    False
				__SCREAMING_SNAKE_CASE      :				Optional[Any]     =    False
				__SCREAMING_SNAKE_CASE      :				Any     =    False
				__SCREAMING_SNAKE_CASE      :				Optional[Any]     =    False




				def 					a							(      self ):
											snake_case_           =					UperNetModelTester(self )
											snake_case_           =					ConfigTester(self   ,     config_class=snake_case   ,     has_text_modality=snake_case   ,     hidden_size=37 )




				def 					a							(      self ):
											self.create_and_test_config_common_properties()
											self.config_tester.create_and_test_config_to_json_string()
											self.config_tester.create_and_test_config_to_json_file()
											self.config_tester.create_and_test_config_from_and_save_pretrained()
											self.config_tester.create_and_test_config_with_num_labels()
											self.config_tester.check_config_can_be_init_without_params()
											self.config_tester.check_config_arguments_init()




				def 					a							(      self ):
											return




				def 					a							(      self ):
											snake_case_       ,					snake_case_           =					self.model_tester.prepare_config_and_inputs_for_common()

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

																		snake_case_           =					['pixel_values']
																		self.assertListEqual(arg_names[:1]   ,     snake_case )




				def 					a							(      self ):
											snake_case_           =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_semantic_segmentation(*snake_case )




				@unittest.skip(reason='UperNet does not use inputs_embeds' )
				def 					a							(      self ):
											pass




				@unittest.skip(reason='UperNet does not support input and output embeddings' )
				def 					a							(      self ):
											pass




				@unittest.skip(reason='UperNet does not have a base model' )
				def 					a							(      self ):
											pass




				@unittest.skip(reason='UperNet does not have a base model' )
				def 					a							(      self ):
											pass




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




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




				def 					a							(      self ):
											def check_hidden_states_output(snake_case   ,     snake_case   ,     snake_case ):
																		snake_case_           =					model_class(snake_case )
																		model.to(snake_case )
																		model.eval()

																		with torch.no_grad():
																									snake_case_           =					model(**self._prepare_for_class(snake_case   ,     snake_case ) )

																		snake_case_           =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																		snake_case_           =					self.model_tester.num_stages
																		self.assertEqual(len(snake_case )   ,     expected_num_stages + 1 )

																		# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
																		self.assertListEqual(
																		    list(hidden_states[0].shape[-2:] )   ,     [self.model_tester.image_size // 4, self.model_tester.image_size // 4]   ,     )

											snake_case_       ,					snake_case_           =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		snake_case_           =					True
																		check_hidden_states_output(snake_case   ,     snake_case   ,     snake_case )

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

																		check_hidden_states_output(snake_case   ,     snake_case   ,     snake_case )




				def 					a							(      self ):
											snake_case_       ,					snake_case_           =					self.model_tester.prepare_config_and_inputs_for_common()

											snake_case_           =					_config_zero_init(snake_case )
											snake_case_           =					_config_zero_init(configs_no_init.backbone_config )
											for model_class in self.all_model_classes:
																		snake_case_           =					model_class(config=snake_case )
																		for name, param in model.named_parameters():
																									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'''   ,     )




				@unittest.skip(reason='UperNet does not have tied weights' )
				def 					a							(      self ):
											pass




				@slow
				def 					a							(      self ):
											for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		snake_case_           =					UperNetForSemanticSegmentation.from_pretrained(snake_case )
																		self.assertIsNotNone(snake_case )





def       __lowerCamelCase			(				):







							'''simple docstring'''






							snake_case_           =					hf_hub_download(
							    repo_id='hf-internal-testing/fixtures_ade20k'     ,							repo_type='dataset'     ,							filename='ADE_val_00000001.jpg'   )
							snake_case_           =					Image.open(UpperCamelCase__   ).convert('RGB'   )
							return image







@require_torch
@require_vision
@slow
class 				lowercase       ( unittest.TestCase    ):




				def 					a							(      self ):
											snake_case_           =					AutoImageProcessor.from_pretrained('openmmlab/upernet-swin-tiny' )
											snake_case_           =					UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-swin-tiny' ).to(snake_case )

											snake_case_           =					prepare_img()
											snake_case_           =					processor(images=snake_case   ,     return_tensors='pt' ).to(snake_case )

											with torch.no_grad():
																		snake_case_           =					model(**snake_case )

											snake_case_           =					torch.Size((1, model.config.num_labels, 512, 512) )
											self.assertEqual(outputs.logits.shape   ,     snake_case )

											snake_case_           =					torch.tensor(
											    [[-7.59_58, -7.59_58, -7.43_02], [-7.59_58, -7.59_58, -7.43_02], [-7.47_97, -7.47_97, -7.30_68]] ).to(snake_case )
											self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]   ,     snake_case   ,     atol=1e-4 ) )




				def 					a							(      self ):
											snake_case_           =					AutoImageProcessor.from_pretrained('openmmlab/upernet-convnext-tiny' )
											snake_case_           =					UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-convnext-tiny' ).to(snake_case )

											snake_case_           =					prepare_img()
											snake_case_           =					processor(images=snake_case   ,     return_tensors='pt' ).to(snake_case )

											with torch.no_grad():
																		snake_case_           =					model(**snake_case )

											snake_case_           =					torch.Size((1, model.config.num_labels, 512, 512) )
											self.assertEqual(outputs.logits.shape   ,     snake_case )

											snake_case_           =					torch.tensor(
											    [[-8.81_10, -8.81_10, -8.65_21], [-8.81_10, -8.81_10, -8.65_21], [-8.77_46, -8.77_46, -8.61_30]] ).to(snake_case )
											self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]   ,     snake_case   ,     atol=1e-4 ) )







def       __lowerCamelCase			(				UpperCamelCase__ = 50000000   ):







							'''simple docstring'''






							snake_case_           =					set()
							snake_case_           =					int((limit - 24) ** (1 / 2)   )

							snake_case_           =					set(range(3     ,							prime_square_limit + 1     ,							2   )   )
							primes.add(2   )
							for p in range(3     ,							prime_square_limit + 1     ,							2   ):
														if p not in primes:
																					continue
														primes.difference_update(set(range(p * p     ,							prime_square_limit + 1     ,							UpperCamelCase__   )   )   )

							for primea in primes:
														snake_case_           =					primea * primea
														for primea in primes:
																					snake_case_           =					primea * primea * primea
																					if square + cube >= limit - 16:
																												break
																					for primea in primes:
																												snake_case_           =					primea * primea * primea * primea
																												snake_case_           =					square + cube + tetr
																												if total >= limit:
																																			break
																												ret.add(UpperCamelCase__   )

							return len(UpperCamelCase__   )


if __name__ == "__main__":
					print(F'''{solution() = }''')




