





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 			UpperCamelCase_		:




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




					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_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.image_size, self.image_size]				,						self.num_labels  )

										_snake_case									=				self.get_config()

										return config, pixel_values, labels




					def 	lowerCAmelCase			(		self  )		->							int:
										_snake_case									=				{
										    'global_padding': 'same',
										    'layer_type': 'bottleneck',
										    'depths': [3, 4, 9],
										    'out_features': ['stage1', 'stage2', 'stage3'],
										    'embedding_dynamic_padding': True,
										    'hidden_sizes': [96, 192, 384, 768],
										    '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 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							List[Any]:
										_snake_case									=				DPTModel(config=lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_snake_case									=				model(lowerCAmelCase_  )
										self.parent.assertEqual(result.last_hidden_state.shape				,						(self.batch_size, self.seq_length, self.hidden_size)  )




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							Tuple:
										_snake_case									=				self.num_labels
										_snake_case									=				DPTForDepthEstimation(lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_snake_case									=				model(lowerCAmelCase_  )
										self.parent.assertEqual(result.predicted_depth.shape				,						(self.batch_size, self.image_size, self.image_size)  )




					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_				,						lowerCAmelCase_				,						lowerCAmelCase_  )		->							Tuple:
										_snake_case									=				self.num_labels
										_snake_case									=				DPTForSemanticSegmentation(lowerCAmelCase_  )
										model.to(lowerCAmelCase_  )
										model.eval()
										_snake_case									=				model(lowerCAmelCase_				,						labels=lowerCAmelCase_  )
										self.parent.assertEqual(
										    result.logits.shape				,						(self.batch_size, self.num_labels, self.image_size, self.image_size)  )






					def 	lowerCAmelCase			(		self  )		->							Optional[Any]:
										_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 			UpperCamelCase_		(  _lowerCamelCase							,  _lowerCamelCase							,  unittest.TestCase					):
					lowerCAmelCase_							=	(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
					lowerCAmelCase_							=	(
					    {
					        '''depth-estimation''': DPTForDepthEstimation,
					        '''feature-extraction''': DPTModel,
					        '''image-segmentation''': DPTForSemanticSegmentation,
					    }
					    if is_torch_available()
					    else {}
					)

					lowerCAmelCase_							=	False
					lowerCAmelCase_							=	False
					lowerCAmelCase_							=	False




					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case									=				DPTModelTester(self  )
										_snake_case									=				ConfigTester(self				,						config_class=lowerCAmelCase_				,						has_text_modality=lowerCAmelCase_				,						hidden_size=37  )




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




					@unittest.skip(reason='DPT does not use inputs_embeds'  )
					def 	lowerCAmelCase			(		self  )		->							Tuple:
										pass




					def 	lowerCAmelCase			(		self  )		->							Union[str, Any]:
										_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(lowerCAmelCase_  )
															self.assertIsInstance(model.get_input_embeddings()				,						(nn.Module)  )
															_snake_case									=				model.get_output_embeddings()
															self.assertTrue(x is None or isinstance(lowerCAmelCase_				,						nn.Linear  )  )




					def 	lowerCAmelCase			(		self  )		->							Tuple:
										_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(lowerCAmelCase_  )
															_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]				,						lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self  )		->							Union[str, Any]:
										_snake_case									=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self  )		->							Tuple:
										_snake_case									=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_depth_estimation(*lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self  )		->							Union[str, Any]:
										_snake_case									=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase_  )




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

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

															if model_class in get_values(lowerCAmelCase_  ):
																				continue

															_snake_case									=				model_class(lowerCAmelCase_  )
															model.to(lowerCAmelCase_  )
															model.train()
															_snake_case									=				self._prepare_for_class(lowerCAmelCase_				,						lowerCAmelCase_				,						return_labels=lowerCAmelCase_  )
															_snake_case									=				model(**lowerCAmelCase_  ).loss
															loss.backward()




					def 	lowerCAmelCase			(		self  )		->							int:
										for model_class in self.all_model_classes:
															if model_class.__name__ == "DPTForDepthEstimation":
																				continue

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

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




					def 	lowerCAmelCase			(		self  )		->							Any:
										_snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()

										_snake_case									=				_config_zero_init(lowerCAmelCase_  )
										for model_class in self.all_model_classes:
															_snake_case									=				model_class(config=lowerCAmelCase_  )
															# Skip the check for the backbone
															_snake_case									=				[]
															for name, module in model.named_modules():
																				if module.__class__.__name__ == "DPTViTHybridEmbeddings":
																									_snake_case									=				[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 	lowerCAmelCase			(		self  )		->							Optional[Any]:
										pass




					@slow
					def 	lowerCAmelCase			(		self  )		->							int:
										for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
															_snake_case									=				DPTModel.from_pretrained(lowerCAmelCase_  )
															self.assertIsNotNone(lowerCAmelCase_  )






					def 	lowerCAmelCase			(		self  )		->							Dict:
										# We do this test only for DPTForDepthEstimation since it is the only model that uses readout_type
										_snake_case							,     _snake_case									=				self.model_tester.prepare_config_and_inputs_for_common()
										_snake_case									=				'add'
										with self.assertRaises(lowerCAmelCase_  ):
															_snake_case									=				DPTForDepthEstimation(lowerCAmelCase_  )





def 						lowerCamelCase__     (     )			-> Tuple:



					'''simple docstring'''




					_snake_case									=				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
					return image




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




					def 	lowerCAmelCase			(		self  )		->							List[Any]:
										_snake_case									=				DPTImageProcessor.from_pretrained('Intel/dpt-hybrid-midas'  )
										_snake_case									=				DPTForDepthEstimation.from_pretrained('Intel/dpt-hybrid-midas'  ).to(lowerCAmelCase_  )

										_snake_case									=				prepare_img()
										_snake_case									=				image_processor(images=lowerCAmelCase_				,						return_tensors='pt'  ).to(lowerCAmelCase_  )

										# forward pass
										with torch.no_grad():
															_snake_case									=				model(**lowerCAmelCase_  )
															_snake_case									=				outputs.predicted_depth

										# verify the predicted depth
										_snake_case									=				torch.Size((1, 384, 384)  )
										self.assertEqual(predicted_depth.shape				,						lowerCAmelCase_  )

										_snake_case									=				torch.tensor(
										    [[[5.64_37, 5.61_46, 5.65_11], [5.43_71, 5.56_49, 5.59_58], [5.52_15, 5.51_84, 5.52_93]]]  ).to(lowerCAmelCase_  )

										self.assertTrue(torch.allclose(outputs.predicted_depth[:3, :3, :3] / 100				,						lowerCAmelCase_				,						atol=1E-4  )  )










import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test
class 			UpperCamelCase_		(  unittest.TestCase					):




					@parameterized.expand([(None,), ('foo.json',)]  )
					def 	lowerCAmelCase			(		self				,						lowerCAmelCase_  )		->							str:
										_snake_case									=				GenerationConfig(
										    do_sample=lowerCAmelCase_				,						temperature=0.7				,						length_penalty=1.0				,						bad_words_ids=[[1, 2, 3], [4, 5]]				,						)
										with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(lowerCAmelCase_				,						config_name=lowerCAmelCase_  )
															_snake_case									=				GenerationConfig.from_pretrained(lowerCAmelCase_				,						config_name=lowerCAmelCase_  )

										# Checks parameters that were specified
										self.assertEqual(loaded_config.do_sample				,						lowerCAmelCase_  )
										self.assertEqual(loaded_config.temperature				,						0.7  )
										self.assertEqual(loaded_config.length_penalty				,						1.0  )
										self.assertEqual(loaded_config.bad_words_ids				,						[[1, 2, 3], [4, 5]]  )

										# Checks parameters that were not specified (defaults)
										self.assertEqual(loaded_config.top_k				,						50  )
										self.assertEqual(loaded_config.max_length				,						20  )
										self.assertEqual(loaded_config.max_time				,						lowerCAmelCase_  )




					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case									=				AutoConfig.from_pretrained('gpt2'  )
										_snake_case									=				GenerationConfig.from_model_config(lowerCAmelCase_  )
										_snake_case									=				GenerationConfig()

										# The generation config has loaded a few non-default parameters from the model config
										self.assertNotEqual(lowerCAmelCase_				,						lowerCAmelCase_  )

										# One of those parameters is eos_token_id -- check if it matches
										self.assertNotEqual(generation_config_from_model.eos_token_id				,						default_generation_config.eos_token_id  )
										self.assertEqual(generation_config_from_model.eos_token_id				,						model_config.eos_token_id  )




					def 	lowerCAmelCase			(		self  )		->							Tuple:
										_snake_case									=				GenerationConfig()
										_snake_case									=				{
										    'max_new_tokens': 1024,
										    'foo': 'bar',
										}
										_snake_case									=				copy.deepcopy(lowerCAmelCase_  )
										_snake_case									=				generation_config.update(**lowerCAmelCase_  )

										# update_kwargs was not modified (no side effects)
										self.assertEqual(lowerCAmelCase_				,						lowerCAmelCase_  )

										# update_kwargs was used to update the config on valid attributes
										self.assertEqual(generation_config.max_new_tokens				,						1024  )

										# `.update()` returns a dictionary of unused kwargs
										self.assertEqual(lowerCAmelCase_				,						{'foo': 'bar'}  )




					def 	lowerCAmelCase			(		self  )		->							Optional[int]:
										_snake_case									=				GenerationConfig()
										_snake_case									=				'bar'

										with tempfile.TemporaryDirectory('test-generation-config'  ) as tmp_dir:
															generation_config.save_pretrained(lowerCAmelCase_  )

															_snake_case									=				GenerationConfig.from_pretrained(lowerCAmelCase_  )
										# update_kwargs was used to update the config on valid attributes
										self.assertEqual(new_config.foo				,						'bar'  )

										_snake_case									=				GenerationConfig.from_model_config(lowerCAmelCase_  )
										assert not hasattr(lowerCAmelCase_				,						'foo'  )  # no new kwargs should be initialized if from config






					def 	lowerCAmelCase			(		self  )		->							List[Any]:
										_snake_case									=				GenerationConfig()
										self.assertEqual(default_config.temperature				,						1.0  )
										self.assertEqual(default_config.do_sample				,						lowerCAmelCase_  )
										self.assertEqual(default_config.num_beams				,						1  )

										_snake_case									=				GenerationConfig(
										    do_sample=lowerCAmelCase_				,						temperature=0.7				,						length_penalty=1.0				,						bad_words_ids=[[1, 2, 3], [4, 5]]				,						)
										self.assertEqual(config.temperature				,						0.7  )
										self.assertEqual(config.do_sample				,						lowerCAmelCase_  )
										self.assertEqual(config.num_beams				,						1  )

										with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(lowerCAmelCase_  )
															_snake_case									=				GenerationConfig.from_pretrained(lowerCAmelCase_				,						temperature=1.0  )

										self.assertEqual(loaded_config.temperature				,						1.0  )
										self.assertEqual(loaded_config.do_sample				,						lowerCAmelCase_  )
										self.assertEqual(loaded_config.num_beams				,						1  )  # default value





@is_staging_test
class 			UpperCamelCase_		(  unittest.TestCase					):




					@classmethod
					def 	lowerCAmelCase			(		cls  )		->							List[str]:
										_snake_case									=				TOKEN
										HfFolder.save_token(lowerCAmelCase_  )




					@classmethod
					def 	lowerCAmelCase			(		cls  )		->							Union[str, Any]:
										try:
															delete_repo(token=cls._token				,						repo_id='test-generation-config'  )
										except HTTPError:
															pass

										try:
															delete_repo(token=cls._token				,						repo_id='valid_org/test-generation-config-org'  )
										except HTTPError:
															pass




					def 	lowerCAmelCase			(		self  )		->							int:
										_snake_case									=				GenerationConfig(
										    do_sample=lowerCAmelCase_				,						temperature=0.7				,						length_penalty=1.0				,						)
										config.push_to_hub('test-generation-config'				,						use_auth_token=self._token  )

										_snake_case									=				GenerationConfig.from_pretrained(F'''{USER}/test-generation-config'''  )
										for k, v in config.to_dict().items():
															if k != "transformers_version":
																				self.assertEqual(lowerCAmelCase_				,						getattr(lowerCAmelCase_				,						lowerCAmelCase_  )  )

        # Reset repo
										delete_repo(token=self._token				,						repo_id='test-generation-config'  )

										# Push to hub via save_pretrained
										with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(
															    lowerCAmelCase_				,						repo_id='test-generation-config'				,						push_to_hub=lowerCAmelCase_				,						use_auth_token=self._token  )

										_snake_case									=				GenerationConfig.from_pretrained(F'''{USER}/test-generation-config'''  )
										for k, v in config.to_dict().items():
															if k != "transformers_version":
																				self.assertEqual(lowerCAmelCase_				,						getattr(lowerCAmelCase_				,						lowerCAmelCase_  )  )






					def 	lowerCAmelCase			(		self  )		->							List[str]:
										_snake_case									=				GenerationConfig(
										    do_sample=lowerCAmelCase_				,						temperature=0.7				,						length_penalty=1.0				,						)
										config.push_to_hub('valid_org/test-generation-config-org'				,						use_auth_token=self._token  )

										_snake_case									=				GenerationConfig.from_pretrained('valid_org/test-generation-config-org'  )
										for k, v in config.to_dict().items():
															if k != "transformers_version":
																				self.assertEqual(lowerCAmelCase_				,						getattr(lowerCAmelCase_				,						lowerCAmelCase_  )  )

        # Reset repo
										delete_repo(token=self._token				,						repo_id='valid_org/test-generation-config-org'  )

										# Push to hub via save_pretrained
										with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(
															    lowerCAmelCase_				,						repo_id='valid_org/test-generation-config-org'				,						push_to_hub=lowerCAmelCase_				,						use_auth_token=self._token  )

										_snake_case									=				GenerationConfig.from_pretrained('valid_org/test-generation-config-org'  )
										for k, v in config.to_dict().items():
															if k != "transformers_version":
																				self.assertEqual(lowerCAmelCase_				,						getattr(lowerCAmelCase_				,						lowerCAmelCase_  )  )



