


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 				A       :
					'''simple docstring'''






					def __init__(self       :		Optional[int] ,   _UpperCAmelCase       :		Optional[Any] ,   _UpperCAmelCase       :		int=13 ,   _UpperCAmelCase       :		int=32 ,   _UpperCAmelCase       :		Tuple=3 ,   _UpperCAmelCase       :		Any=4 ,   _UpperCAmelCase       :		Optional[Any]=[10, 20, 30, 40] ,   _UpperCAmelCase       :		List[Any]=[2, 2, 3, 2] ,   _UpperCAmelCase       :		Union[str, Any]=True ,   _UpperCAmelCase       :		Optional[int]=True ,   _UpperCAmelCase       :		str=37 ,   _UpperCAmelCase       :		int="gelu" ,   _UpperCAmelCase       :		str=10 ,   _UpperCAmelCase       :		Optional[int]=0.02 ,   _UpperCAmelCase       :		List[Any]=["stage2", "stage3", "stage4"] ,   _UpperCAmelCase       :		str=3 ,   _UpperCAmelCase       :		List[str]=None ,   )		->  Optional[int]:




							"""simple docstring"""


							lowercase__	     =						parent
							lowercase__	     =						batch_size
							lowercase__	     =						image_size
							lowercase__	     =						num_channels
							lowercase__	     =						num_stages
							lowercase__	     =						hidden_sizes
							lowercase__	     =						depths
							lowercase__	     =						is_training
							lowercase__	     =						use_labels
							lowercase__	     =						intermediate_size
							lowercase__	     =						hidden_act
							lowercase__	     =						type_sequence_label_size
							lowercase__	     =						initializer_range
							lowercase__	     =						out_features
							lowercase__	     =						num_labels
							lowercase__	     =						scope
							lowercase__	     =						num_stages

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




							"""simple docstring"""


							lowercase__	     =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

							lowercase__	     =						self.get_config()

							return config, pixel_values, labels

					def     lowerCamelCase__	(self       :		List[str]						)		->  Tuple:




							"""simple docstring"""


							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     lowerCamelCase__	(self       :		int						)		->  List[Any]:




							"""simple docstring"""


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

					def     lowerCamelCase__	(self       :		str ,   _UpperCAmelCase       :		List[str] ,   _UpperCAmelCase       :		Optional[Any] ,   _UpperCAmelCase       :		Any						)		->  Tuple:




							"""simple docstring"""


							lowercase__	     =						UperNetForSemanticSegmentation(config=_UpperCAmelCase						)
							model.to(_UpperCAmelCase						)
							model.eval()
							lowercase__	     =						model(_UpperCAmelCase						)
							self.parent.assertEqual(
							    result.logits.shape ,   (self.batch_size, self.num_labels, self.image_size, self.image_size)						)


					def     lowerCamelCase__	(self       :		Any						)		->  int:




							"""simple docstring"""


							lowercase__	     =						self.prepare_config_and_inputs()
							(
							    (
							    lowercase__
							)     ,      (
							    lowercase__
							)     ,      (
							    lowercase__
							)     ,      
							)	     =						config_and_inputs
							lowercase__	     =						{"""pixel_values""": pixel_values}
							return config, inputs_dict






@require_torch
class 				A       (			UpperCAmelCase__					,    UpperCAmelCase__					,    unittest.TestCase				):
					'''simple docstring'''






					A__     =					(UperNetForSemanticSegmentation,) if is_torch_available() else ()
					A__     =					{'''image-segmentation''': UperNetForSemanticSegmentation} if is_torch_available() else {}
					A__     =					False
					A__     =					False
					A__     =					False
					A__     =					False
					A__     =					False
					A__     =					False

					def     lowerCamelCase__	(self       :		str						)		->  Tuple:




							"""simple docstring"""


							lowercase__	     =						UperNetModelTester(self						)
							lowercase__	     =						ConfigTester(self ,   config_class=_UpperCAmelCase ,   has_text_modality=_UpperCAmelCase ,   hidden_size=37						)

					def     lowerCamelCase__	(self       :		Tuple						)		->  List[str]:




							"""simple docstring"""


							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     lowerCamelCase__	(self       :		Optional[Any]						)		->  Optional[int]:




							"""simple docstring"""


							return

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




							"""simple docstring"""


							lowercase__     ,      lowercase__	     =						self.model_tester.prepare_config_and_inputs_for_common()

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

									lowercase__	     =						["""pixel_values"""]
									self.assertListEqual(arg_names[:1] ,   _UpperCAmelCase						)

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




							"""simple docstring"""


							lowercase__	     =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_semantic_segmentation(*_UpperCAmelCase						)

					@unittest.skip(reason="""UperNet does not use inputs_embeds"""						)
					def     lowerCamelCase__	(self       :		Tuple						)		->  Optional[Any]:




							"""simple docstring"""


							pass

					@unittest.skip(reason="""UperNet does not support input and output embeddings"""						)
					def     lowerCamelCase__	(self       :		Optional[Any]						)		->  List[str]:




							"""simple docstring"""


							pass

					@unittest.skip(reason="""UperNet does not have a base model"""						)
					def     lowerCamelCase__	(self       :		str						)		->  Union[str, Any]:




							"""simple docstring"""


							pass

					@unittest.skip(reason="""UperNet does not have a base model"""						)
					def     lowerCamelCase__	(self       :		Dict						)		->  Dict:




							"""simple docstring"""


							pass

					@require_torch_multi_gpu
					@unittest.skip(reason="""UperNet has some layers using `add_module` which doesn't work well with `nn.DataParallel`"""						)
					def     lowerCamelCase__	(self       :		Optional[int]						)		->  str:




							"""simple docstring"""


							pass

					@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""						)
					def     lowerCamelCase__	(self       :		Optional[int]						)		->  str:




							"""simple docstring"""


							pass

					def     lowerCamelCase__	(self       :		Dict						)		->  Optional[Any]:




							"""simple docstring"""


							def check_hidden_states_output(_UpperCAmelCase       :		str ,   _UpperCAmelCase       :		Optional[int] ,   _UpperCAmelCase       :		Optional[int]						):
									lowercase__	     =						model_class(_UpperCAmelCase						)
									model.to(_UpperCAmelCase						)
									model.eval()

									with torch.no_grad():
											lowercase__	     =						model(**self._prepare_for_class(_UpperCAmelCase ,   _UpperCAmelCase						)						)

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

									lowercase__	     =						self.model_tester.num_stages
									self.assertEqual(len(_UpperCAmelCase						) ,   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] ,   )

							lowercase__     ,      lowercase__	     =						self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
									lowercase__	     =						True
									check_hidden_states_output(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)

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

									check_hidden_states_output(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)

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




							"""simple docstring"""


							lowercase__     ,      lowercase__	     =						self.model_tester.prepare_config_and_inputs_for_common()

							lowercase__	     =						_config_zero_init(_UpperCAmelCase						)
							lowercase__	     =						_config_zero_init(configs_no_init.backbone_config						)
							for model_class in self.all_model_classes:
									lowercase__	     =						model_class(config=_UpperCAmelCase						)
									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     lowerCamelCase__	(self       :		Optional[int]						)		->  Union[str, Any]:




							"""simple docstring"""


							pass


					@slow
					def     lowerCamelCase__	(self       :		Optional[Any]						)		->  Tuple:




							"""simple docstring"""


							for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowercase__	     =						UperNetForSemanticSegmentation.from_pretrained(_UpperCAmelCase						)
									self.assertIsNotNone(_UpperCAmelCase						)






def 					UpperCamelCase   (      )  ->    Optional[int]:
		"""simple docstring"""




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







@require_torch
@require_vision
@slow
class 				A       (			unittest.TestCase				):
					'''simple docstring'''






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




							"""simple docstring"""


							lowercase__	     =						AutoImageProcessor.from_pretrained("""openmmlab/upernet-swin-tiny"""						)
							lowercase__	     =						UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-swin-tiny"""						).to(_UpperCAmelCase						)

							lowercase__	     =						prepare_img()
							lowercase__	     =						processor(images=_UpperCAmelCase ,   return_tensors="""pt"""						).to(_UpperCAmelCase						)

							with torch.no_grad():
									lowercase__	     =						model(**_UpperCAmelCase						)

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

							lowercase__	     =						torch.tensor(
							    [[-7.5_958, -7.5_958, -7.4_302], [-7.5_958, -7.5_958, -7.4_302], [-7.4_797, -7.4_797, -7.3_068]]						).to(_UpperCAmelCase						)
							self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3] ,   _UpperCAmelCase ,   atol=1E-4						)						)


					def     lowerCamelCase__	(self       :		Tuple						)		->  Optional[int]:




							"""simple docstring"""


							lowercase__	     =						AutoImageProcessor.from_pretrained("""openmmlab/upernet-convnext-tiny"""						)
							lowercase__	     =						UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-convnext-tiny"""						).to(_UpperCAmelCase						)

							lowercase__	     =						prepare_img()
							lowercase__	     =						processor(images=_UpperCAmelCase ,   return_tensors="""pt"""						).to(_UpperCAmelCase						)

							with torch.no_grad():
									lowercase__	     =						model(**_UpperCAmelCase						)

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

							lowercase__	     =						torch.tensor(
							    [[-8.8_110, -8.8_110, -8.6_521], [-8.8_110, -8.8_110, -8.6_521], [-8.7_746, -8.7_746, -8.6_130]]						).to(_UpperCAmelCase						)
							self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3] ,   _UpperCAmelCase ,   atol=1E-4						)						)



import functools
from typing import Any



def 		UpperCamelCase     (       _UpperCAmelCase  :   str ,			_UpperCAmelCase  :   list[str]  )   ->			bool:






						'''simple docstring'''

						if not isinstance(_UpperCAmelCase ,			_UpperCAmelCase  ) or len(_UpperCAmelCase  ) == 0:
												raise ValueError("the string should be not empty string"  )

						if not isinstance(_UpperCAmelCase ,			_UpperCAmelCase  ) or not all(
						    isinstance(_UpperCAmelCase ,			_UpperCAmelCase  ) and len(_UpperCAmelCase  ) > 0 for item in words  ):
												raise ValueError("the words should be a list of non-empty strings"  )

						# Build trie
						_lowercase       :	dict[str, Any]           =   {}
						_lowercase       :	List[Any]           =   "WORD_KEEPER"

						for word in words:
												_lowercase       :	Optional[Any]           =   trie
												for c in word:
																		if c not in trie_node:
																								_lowercase       :	List[Any]           =   {}

																		_lowercase       :	Optional[int]           =   trie_node[c]

												_lowercase       :	str           =   True

						_lowercase       :	int           =   len(_UpperCAmelCase  )

						# Dynamic programming method
						@functools.cache
						def is_breakable(_UpperCAmelCase  :   int  ) -> bool:
												if index == len_string:
																		return True

												_lowercase       :	Union[str, Any]           =   trie
												for i in range(_UpperCAmelCase ,			_UpperCAmelCase  ):
																		_lowercase       :	List[str]           =   trie_node.get(string[i] ,			_UpperCAmelCase  )

																		if trie_node is None:
																								return False

																		if trie_node.get(_UpperCAmelCase ,			_UpperCAmelCase  ) and is_breakable(i + 1  ):
																								return True

												return False

						return is_breakable(0  )


if __name__ == "__main__":
							import doctest

							doctest.testmod()




