




import inspect
import unittest

from transformers import DPTConfig
from transformers.file_utils import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel
		from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import DPTImageProcessor




class     snake_case__							:
				"""simple docstring"""



				def __init__(      self				:     Tuple					,      __lowerCamelCase				:     Optional[int]					,      __lowerCamelCase				:     Dict=2					,      __lowerCamelCase				:     Dict=32					,      __lowerCamelCase				:     Tuple=16					,      __lowerCamelCase				:     Tuple=3					,      __lowerCamelCase				:     int=True					,      __lowerCamelCase				:     int=True					,      __lowerCamelCase				:     Any=32					,      __lowerCamelCase				:     List[Any]=4					,      __lowerCamelCase				:     Tuple=[0, 1, 2, 3]					,      __lowerCamelCase				:     Union[str, Any]=4					,      __lowerCamelCase				:     Union[str, Any]=37					,      __lowerCamelCase				:     Optional[int]="gelu"					,      __lowerCamelCase				:     str=0.1					,      __lowerCamelCase				:     List[str]=0.1					,      __lowerCamelCase				:     Optional[Any]=0.02					,      __lowerCamelCase				:     Optional[int]=3					,      __lowerCamelCase				:     List[Any]=[1, 3_84, 24, 24]					,      __lowerCamelCase				:     List[Any]=True					,      __lowerCamelCase				:     Optional[int]=None					,      )					->     Optional[int]:
							a    =			parent
							a    =			batch_size
							a    =			image_size
							a    =			patch_size
							a    =			num_channels
							a    =			is_training
							a    =			use_labels
							a    =			hidden_size
							a    =			num_hidden_layers
							a    =			backbone_out_indices
							a    =			num_attention_heads
							a    =			intermediate_size
							a    =			hidden_act
							a    =			hidden_dropout_prob
							a    =			attention_probs_dropout_prob
							a    =			initializer_range
							a    =			num_labels
							a    =			backbone_featmap_shape
							a    =			scope
							a    =			is_hybrid
							# sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
							a    =			(image_size // patch_size) ** 2
							a    =			num_patches + 1





				def 							__UpperCAmelCase							(      self				:     Union[str, Any]							)					->     str:
							a    =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

							a    =			None
							if self.use_labels:
										a    =			ids_tensor([self.batch_size, self.image_size, self.image_size]					,      self.num_labels							)

							a    =			self.get_config()

							return config, pixel_values, labels





				def 							__UpperCAmelCase							(      self				:     List[str]							)					->     Union[str, Any]:
							a    =			{
							    "global_padding": "same",
							    "layer_type": "bottleneck",
							    "depths": [3, 4, 9],
							    "out_features": ["stage1", "stage2", "stage3"],
							    "embedding_dynamic_padding": True,
							    "hidden_sizes": [96, 1_92, 3_84, 7_68],
							    "num_groups": 2,
							}

							return DPTConfig(
							    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					,      backbone_out_indices=self.backbone_out_indices					,      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					,      is_hybrid=self.is_hybrid					,      backbone_config=__lowerCamelCase					,      backbone_featmap_shape=self.backbone_featmap_shape					,      )





				def 							__UpperCAmelCase							(      self				:     Union[str, Any]					,      __lowerCamelCase				:     Any					,      __lowerCamelCase				:     Optional[int]					,      __lowerCamelCase				:     Optional[Any]							)					->     Optional[Any]:
							a    =			DPTModel(config=__lowerCamelCase							)
							model.to(__lowerCamelCase							)
							model.eval()
							a    =			model(__lowerCamelCase							)
							self.parent.assertEqual(result.last_hidden_state.shape					,      (self.batch_size, self.seq_length, self.hidden_size)							)





				def 							__UpperCAmelCase							(      self				:     List[str]					,      __lowerCamelCase				:     List[str]					,      __lowerCamelCase				:     List[str]					,      __lowerCamelCase				:     Any							)					->     str:
							a    =			self.num_labels
							a    =			DPTForDepthEstimation(__lowerCamelCase							)
							model.to(__lowerCamelCase							)
							model.eval()
							a    =			model(__lowerCamelCase							)
							self.parent.assertEqual(result.predicted_depth.shape					,      (self.batch_size, self.image_size, self.image_size)							)





				def 							__UpperCAmelCase							(      self				:     str					,      __lowerCamelCase				:     List[Any]					,      __lowerCamelCase				:     str					,      __lowerCamelCase				:     Tuple							)					->     Any:
							a    =			self.num_labels
							a    =			DPTForSemanticSegmentation(__lowerCamelCase							)
							model.to(__lowerCamelCase							)
							model.eval()
							a    =			model(__lowerCamelCase					,      labels=__lowerCamelCase							)
							self.parent.assertEqual(
							    result.logits.shape					,      (self.batch_size, self.num_labels, self.image_size, self.image_size)							)





				def 							__UpperCAmelCase							(      self				:     str							)					->     str:
							a    =			self.prepare_config_and_inputs()
							a    ,		a    ,		a    =			config_and_inputs
							a    =			{"pixel_values": pixel_values}
							return config, inputs_dict




@require_torch
class     snake_case__							(_UpperCamelCase    ,       _UpperCamelCase    ,       unittest.TestCase   ):
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_       :							Union[str, Any]							 =					(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
				SCREAMING_SNAKE_CASE_       :							Union[str, Any]							 =					(
				    {
				        """depth-estimation""": DPTForDepthEstimation,
				        """feature-extraction""": DPTModel,
				        """image-segmentation""": DPTForSemanticSegmentation,
				    }
				    if is_torch_available()
				    else {}
				)

				SCREAMING_SNAKE_CASE_       :							Optional[int]							 =					False
				SCREAMING_SNAKE_CASE_       :							str							 =					False
				SCREAMING_SNAKE_CASE_       :							str							 =					False





				def 							__UpperCAmelCase							(      self				:     int							)					->     List[str]:
							a    =			DPTModelTester(self							)
							a    =			ConfigTester(self					,      config_class=__lowerCamelCase					,      has_text_modality=__lowerCamelCase					,      hidden_size=37							)





				def 							__UpperCAmelCase							(      self				:     int							)					->     List[str]:
							self.config_tester.run_common_tests()





				@unittest.skip(reason="DPT does not use inputs_embeds"							)
				def 							__UpperCAmelCase							(      self				:     Optional[Any]							)					->     List[str]:
							pass





				def 							__UpperCAmelCase							(      self				:     List[str]							)					->     Optional[Any]:
							a    ,		a    =			self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
										a    =			model_class(__lowerCamelCase							)
										self.assertIsInstance(model.get_input_embeddings()					,      (nn.Module)							)
										a    =			model.get_output_embeddings()
										self.assertTrue(x is None or isinstance(__lowerCamelCase					,      nn.Linear							)							)





				def 							__UpperCAmelCase							(      self				:     Tuple							)					->     List[str]:
							a    ,		a    =			self.model_tester.prepare_config_and_inputs_for_common()

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

										a    =			["pixel_values"]
										self.assertListEqual(arg_names[:1]					,      __lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     Any							)					->     Union[str, Any]:
							a    =			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     Any							)					->     Dict:
							a    =			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_depth_estimation(*__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     List[str]							)					->     Optional[int]:
							a    =			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_semantic_segmentation(*__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     List[str]							)					->     Optional[Any]:
							for model_class in self.all_model_classes:
										if model_class.__name__ == "DPTForDepthEstimation":
													continue

										a    ,		a    =			self.model_tester.prepare_config_and_inputs_for_common()
										a    =			True

										if model_class in get_values(__lowerCamelCase							):
													continue

										a    =			model_class(__lowerCamelCase							)
										model.to(__lowerCamelCase							)
										model.train()
										a    =			self._prepare_for_class(__lowerCamelCase					,      __lowerCamelCase					,      return_labels=__lowerCamelCase							)
										a    =			model(**__lowerCamelCase							).loss
										loss.backward()





				def 							__UpperCAmelCase							(      self				:     Dict							)					->     List[str]:
							for model_class in self.all_model_classes:
										if model_class.__name__ == "DPTForDepthEstimation":
													continue

										a    ,		a    =			self.model_tester.prepare_config_and_inputs_for_common()
										a    =			False
										a    =			True

										if model_class in get_values(__lowerCamelCase							) or not model_class.supports_gradient_checkpointing:
													continue
										a    =			model_class(__lowerCamelCase							)
										model.to(__lowerCamelCase							)
										model.gradient_checkpointing_enable()
										model.train()
										a    =			self._prepare_for_class(__lowerCamelCase					,      __lowerCamelCase					,      return_labels=__lowerCamelCase							)
										a    =			model(**__lowerCamelCase							).loss
										loss.backward()





				def 							__UpperCAmelCase							(      self				:     Tuple							)					->     Union[str, Any]:
							a    ,		a    =			self.model_tester.prepare_config_and_inputs_for_common()

							a    =			_config_zero_init(__lowerCamelCase							)
							for model_class in self.all_model_classes:
										a    =			model_class(config=__lowerCamelCase							)
										# Skip the check for the backbone
										a    =			[]
										for name, module in model.named_modules():
													if module.__class__.__name__ == "DPTViTHybridEmbeddings":
																a    =			[f"""{name}.{key}""" for key in module.state_dict().keys()]
																break

										for name, param in model.named_parameters():
													if param.requires_grad:
																if name in backbone_params:
																			continue
																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("Will be fixed soon by reducing the size of the model used for common tests."							)
				def 							__UpperCAmelCase							(      self				:     int							)					->     Any:
							pass





				@slow
				def 							__UpperCAmelCase							(      self				:     str							)					->     Optional[int]:
							for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
										a    =			DPTModel.from_pretrained(__lowerCamelCase							)
										self.assertIsNotNone(__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     Tuple							)					->     Dict:
							# We do this test only for DPTForDepthEstimation since it is the only model that uses readout_type
							a    ,		a    =			self.model_tester.prepare_config_and_inputs_for_common()
							a    =			"add"
							with self.assertRaises(__lowerCamelCase							):
										a    =			DPTForDepthEstimation(__lowerCamelCase							)




def 			__magic_name__				( ):






			'''simple docstring'''







			a    =			Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"   )
			return image






@require_torch
@require_vision
@slow
class     snake_case__							(unittest.TestCase   ):
				"""simple docstring"""



				def 							__UpperCAmelCase							(      self				:     List[str]							)					->     Optional[Any]:
							a    =			DPTImageProcessor.from_pretrained("Intel/dpt-hybrid-midas"							)
							a    =			DPTForDepthEstimation.from_pretrained("Intel/dpt-hybrid-midas"							).to(__lowerCamelCase							)

							a    =			prepare_img()
							a    =			image_processor(images=__lowerCamelCase					,      return_tensors="pt"							).to(__lowerCamelCase							)

							# forward pass
							with torch.no_grad():
										a    =			model(**__lowerCamelCase							)
										a    =			outputs.predicted_depth

							# verify the predicted depth
							a    =			torch.Size((1, 3_84, 3_84)							)
							self.assertEqual(predicted_depth.shape					,      __lowerCamelCase							)

							a    =			torch.tensor(
							    [[[5.6_437, 5.6_146, 5.6_511], [5.4_371, 5.5_649, 5.5_958], [5.5_215, 5.5_184, 5.5_293]]]							).to(__lowerCamelCase							)

							self.assertTrue(torch.allclose(outputs.predicted_depth[:3, :3, :3] / 1_00					,      __lowerCamelCase					,      atol=1e-4							)							)












import unittest

from transformers import GPTSwaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__lowerCAmelCase		:				List[Any]       			=		get_tests_dir('fixtures/test_sentencepiece_with_bytefallback.model')




@require_sentencepiece
@require_tokenizers
class     snake_case__							(_UpperCamelCase    ,       unittest.TestCase   ):
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_       :							Any							 =					GPTSwaTokenizer
				SCREAMING_SNAKE_CASE_       :							int							 =					False
				SCREAMING_SNAKE_CASE_       :							Union[str, Any]							 =					True
				SCREAMING_SNAKE_CASE_       :							Any							 =					False





				def 							__UpperCAmelCase							(      self				:     Tuple							)					->     Any:
							super().setUp()

							# We have a SentencePiece fixture for testing
							a    =			GPTSwaTokenizer(__lowerCamelCase					,      eos_token="<unk>"					,      bos_token="<unk>"					,      pad_token="<unk>"							)

							tokenizer.save_pretrained(self.tmpdirname							)





				def 							__UpperCAmelCase							(      self				:     Union[str, Any]					,      __lowerCamelCase				:     Optional[Any]							)					->     Any:
							a    =			"This is a test"
							a    =			"This is a test"
							return input_text, output_text





				def 							__UpperCAmelCase							(      self				:     List[Any]							)					->     List[str]:
							a    =			"<s>"
							a    =			1

							self.assertEqual(self.get_tokenizer()._convert_token_to_id(__lowerCamelCase							)					,      __lowerCamelCase							)
							self.assertEqual(self.get_tokenizer()._convert_id_to_token(__lowerCamelCase							)					,      __lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     List[Any]							)					->     int:
							a    =			list(self.get_tokenizer().get_vocab().keys()							)

							self.assertEqual(vocab_keys[0]					,      "<unk>"							)
							self.assertEqual(vocab_keys[1]					,      "<s>"							)
							self.assertEqual(vocab_keys[-1]					,      "j"							)
							self.assertEqual(len(__lowerCamelCase							)					,      20_00							)





				def 							__UpperCAmelCase							(      self				:     Optional[int]							)					->     Dict:
							self.assertEqual(self.get_tokenizer().vocab_size					,      20_00							)





				def 							__UpperCAmelCase							(      self				:     Optional[int]							)					->     Union[str, Any]:
							a    =			GPTSwaTokenizer(__lowerCamelCase							)

							a    =			tokenizer.tokenize("This is a test"							)
							self.assertListEqual(__lowerCamelCase					,      ["▁This", "▁is", "▁a", "▁t", "est"]							)

							self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCamelCase							)					,      [4_65, 2_87, 2_65, 6_31, 8_42]							)

							a    =			tokenizer.tokenize("I was born in 92000, and this is falsé."							)
							# fmt: off
							self.assertListEqual(
							    __lowerCamelCase					,      ["▁I", "▁was", "▁bor", "n", "▁in", "▁", "<0x39>", "2", "0", "0", "0", ",", "▁and", "▁this", "▁is", "▁f", "al", "s", "<0xC3>", "<0xA9>", "."]					,      )
							# fmt: on

							a    =			tokenizer.convert_tokens_to_ids(__lowerCamelCase							)
							self.assertListEqual(
							    __lowerCamelCase					,      [2_62, 2_72, 15_25, 2_86, 2_71, 2_68, 60, 9_16, 6_33, 6_33, 6_33, 2_59, 2_66, 3_01, 2_87, 3_84, 3_67, 2_63, 1_98, 1_72, 2_60]					,      )

							a    =			tokenizer.convert_ids_to_tokens(__lowerCamelCase							)
							# fmt: off
							self.assertListEqual(
							    __lowerCamelCase					,      ["▁I", "▁was", "▁bor", "n", "▁in", "▁", "<0x39>", "2", "0", "0", "0", ",", "▁and", "▁this", "▁is", "▁f", "al", "s", "<0xC3>", "<0xA9>", "."]							)
							# fmt: on





				def 							__UpperCAmelCase							(      self				:     List[Any]							)					->     str:
							a    =			GPTSwaTokenizer(__lowerCamelCase							)
							a    =			["This is a test", "I was born in 92000, and this is falsé."]
							a    =			[
							    [4_65, 2_87, 2_65, 6_31, 8_42],
							    [2_62, 2_72, 15_25, 2_86, 2_71, 2_68, 60, 9_16, 6_33, 6_33, 6_33, 2_59, 2_66, 3_01, 2_87, 3_84, 3_67, 2_63, 1_98, 1_72, 2_60],
							]

							# Test that encode_fast returns the same as tokenize + convert_tokens_to_ids
							for text, expected_ids in zip(__lowerCamelCase					,      __lowerCamelCase							):
										self.assertListEqual(tokenizer.encode_fast(__lowerCamelCase							)					,      __lowerCamelCase							)

							# Test that decode_fast returns the input text
							for text, token_ids in zip(__lowerCamelCase					,      __lowerCamelCase							):
										self.assertEqual(tokenizer.decode_fast(__lowerCamelCase							)					,      __lowerCamelCase							)





				@slow
				def 							__UpperCAmelCase							(      self				:     Optional[int]							)					->     List[Any]:
							a    =			[
							    "<|python|>def fibonacci(n)\n    if n < 0:\n        print('Incorrect input')",
							    "Hey there, how are you doing this fine day?",
							    "This is a text with a trailing spaces followed by a dot     .",
							    "Häj sväjs lillebrör! =)",
							    "Det är inget fel på Mr. Cool",
							]

							# fmt: off
							a    =			{"input_ids": [[6_34_23, 5, 68_11, 1_49_54, 2_82, 8_16, 38_21, 6_34_66, 6_34_25, 6_34_62, 18, 6_39_78, 6_78, 3_01, 13_20, 6_34_23, 6_34_55, 6_34_58, 18, 6_39_82, 42_46, 39_40, 19_01, 4_77_89, 55_47, 1_89_94], [1_96_30, 11_00, 6_34_46, 13_42, 6_33, 5_44, 44_88, 5_93, 51_02, 24_16, 6_34_95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [16_52, 4_28, 2_68, 19_36, 5_15, 2_68, 5_85_93, 2_24_13, 91_06, 5_46, 2_68, 3_32_13, 6_39_79, 6_98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_51_30, 6_34_50, 9_24, 6_34_49, 22_49, 40_62, 15_58, 3_18, 6_35_04, 2_14_98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_09, 3_77, 28_27, 25_59, 3_32, 65_75, 6_34_43, 2_68_01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "token_type_ids": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
							# fmt: on
							self.tokenizer_integration_test_util(
							    expected_encoding=__lowerCamelCase					,      model_name="AI-Sweden/gpt-sw3-126m"					,      sequences=__lowerCamelCase					,      )






