





'''simple docstring'''



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



     '''simple docstring'''






     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						,   ):
       _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 	UpperCamelCase(					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.image_size, self.image_size]						,   self.num_labels	)

       _snake_case     		=				self.get_config()

       return config, pixel_values, labels

     def 	UpperCamelCase(					self	):
       _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 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase	):
       _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 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase	):
       _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 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase	):
       _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 	UpperCamelCase(					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       __SCREAMING_SNAKE_CASE	(						__UpperCamelCase					,    __UpperCamelCase					,    unittest.TestCase			):



     '''simple docstring'''






     UpperCAmelCase__       :						List[Any]      =   (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
     UpperCAmelCase__       :						Any      =   (
         {
             '''depth-estimation''': DPTForDepthEstimation,
             '''feature-extraction''': DPTModel,
             '''image-segmentation''': DPTForSemanticSegmentation,
         }
         if is_torch_available()
         else {}
     )

     UpperCAmelCase__       :						List[Any]      =   False
     UpperCAmelCase__       :						str      =   False
     UpperCAmelCase__       :						Union[str, Any]      =   False

     def 	UpperCamelCase(					self	):
       _snake_case     		=				DPTModelTester(self	)
       _snake_case     		=				ConfigTester(self						,   config_class=lowerCamelCase						,   has_text_modality=lowerCamelCase						,   hidden_size=37	)

     def 	UpperCamelCase(					self	):
       self.config_tester.run_common_tests()

     @unittest.skip(reason="DPT does not use inputs_embeds"	)
     def 	UpperCamelCase(					self	):
       pass

     def 	UpperCamelCase(					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(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 	UpperCamelCase(					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(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 	UpperCamelCase(					self	):
       _snake_case     		=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*lowerCamelCase	)

     def 	UpperCamelCase(					self	):
       _snake_case     		=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_depth_estimation(*lowerCamelCase	)

     def 	UpperCamelCase(					self	):
       _snake_case     		=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase	)

     def 	UpperCamelCase(					self	):
       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 	UpperCamelCase(					self	):
       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 	UpperCamelCase(					self	):
       _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 	UpperCamelCase(					self	):
       pass

     @slow
     def 	UpperCamelCase(					self	):
       for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
         _snake_case     		=				DPTModel.from_pretrained(lowerCamelCase	)
         self.assertIsNotNone(lowerCamelCase	)






     def 	UpperCamelCase(					self	):
       # 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 				snake_case_      (		):







  '''simple docstring'''



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




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



     '''simple docstring'''






     def 	UpperCamelCase(					self	):
       _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.6437, 5.6146, 5.6511], [5.4371, 5.5649, 5.5958], [5.5215, 5.5184, 5.5293]]]	).to(lowerCamelCase	)

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









'''simple docstring'''



from typing import TYPE_CHECKING

from ...file_utils import _LazyModule, is_torch_available
from ...utils import OptionalDependencyNotAvailable


__magic_name__   :						Any    =			{
    """configuration_gpt_neox_japanese""": ["""GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTNeoXJapaneseConfig"""],
    """tokenization_gpt_neox_japanese""": ["""GPTNeoXJapaneseTokenizer"""],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __magic_name__   :						List[Any]    =			[
     """GPT_NEOX_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """GPTNeoXJapaneseForCausalLM""",
     """GPTNeoXJapaneseLayer""",
     """GPTNeoXJapaneseModel""",
     """GPTNeoXJapanesePreTrainedModel""",
 ]


if TYPE_CHECKING:
 from .configuration_gpt_neox_japanese import GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoXJapaneseConfig
 from .tokenization_gpt_neox_japanese import GPTNeoXJapaneseTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_gpt_neox_japanese import (
      GPT_NEOX_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
      GPTNeoXJapaneseForCausalLM,
      GPTNeoXJapaneseLayer,
      GPTNeoXJapaneseModel,
      GPTNeoXJapanesePreTrainedModel,
  )


else:
 import sys

 __magic_name__   :						Union[str, Any]    =			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


