


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







    """simple docstring"""

    def __init__(	self      , __snake_case      , __snake_case=2      , __snake_case=3_2      , __snake_case=1_6      , __snake_case=3      , __snake_case=True      , __snake_case=True      , __snake_case=3_2      , __snake_case=4      , __snake_case=[0, 1, 2, 3]      , __snake_case=4      , __snake_case=3_7      , __snake_case="gelu"      , __snake_case=0.1      , __snake_case=0.1      , __snake_case=0.02      , __snake_case=3      , __snake_case=[1, 3_8_4, 2_4, 2_4]      , __snake_case=True      , __snake_case=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 		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.image_size, self.image_size]      , self.num_labels   )

         snake_case					=    self.get_config()

         return config, pixel_values, labels
    def 		a_      (	self   ):
         snake_case					=    {
             '''global_padding''': '''same''',
             '''layer_type''': '''bottleneck''',
             '''depths''': [3, 4, 9],
             '''out_features''': ['''stage1''', '''stage2''', '''stage3'''],
             '''embedding_dynamic_padding''': True,
             '''hidden_sizes''': [9_6, 1_9_2, 3_8_4, 7_6_8],
             '''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=__snake_case      , initializer_range=self.initializer_range      , is_hybrid=self.is_hybrid      , backbone_config=__snake_case      , backbone_featmap_shape=self.backbone_featmap_shape      , )
    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         snake_case					=    DPTModel(config=__snake_case   )
         model.to(__snake_case   )
         model.eval()
         snake_case					=    model(__snake_case   )
         self.parent.assertEqual(result.last_hidden_state.shape      , (self.batch_size, self.seq_length, self.hidden_size)   )
    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         snake_case					=    self.num_labels
         snake_case					=    DPTForDepthEstimation(__snake_case   )
         model.to(__snake_case   )
         model.eval()
         snake_case					=    model(__snake_case   )
         self.parent.assertEqual(result.predicted_depth.shape      , (self.batch_size, self.image_size, self.image_size)   )
    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         snake_case					=    self.num_labels
         snake_case					=    DPTForSemanticSegmentation(__snake_case   )
         model.to(__snake_case   )
         model.eval()
         snake_case					=    model(__snake_case      , labels=__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   A__ (   snake_case__	, snake_case__	, unittest.TestCase     ):







    """simple docstring"""

    __magic_name__        =		(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
    __magic_name__        =		(
        {
            'depth-estimation': DPTForDepthEstimation,
            'feature-extraction': DPTModel,
            'image-segmentation': DPTForSemanticSegmentation,
        }
        if is_torch_available()
        else {}
    )

    __magic_name__        =		False
    __magic_name__        =		False
    __magic_name__        =		False
    def 		a_      (	self   ):
         snake_case					=    DPTModelTester(self   )
         snake_case					=    ConfigTester(self      , config_class=__snake_case      , has_text_modality=__snake_case      , hidden_size=3_7   )
    def 		a_      (	self   ):
         self.config_tester.run_common_tests()
    @unittest.skip(reason='''DPT does not use inputs_embeds'''   )
    def 		a_      (	self   ):
         pass
    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   )
              self.assertIsInstance(model.get_input_embeddings()      , (nn.Module)   )
              snake_case					=    model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(__snake_case      , nn.Linear   )   )
    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_model(*__snake_case   )
    def 		a_      (	self   ):
         snake_case					=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_depth_estimation(*__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   )
    def 		a_      (	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(__snake_case   ):
                   continue

              snake_case					=    model_class(__snake_case   )
              model.to(__snake_case   )
              model.train()
              snake_case					=    self._prepare_for_class(__snake_case      , __snake_case      , return_labels=__snake_case   )
              snake_case					=    model(**__snake_case   ).loss
              loss.backward()
    def 		a_      (	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(__snake_case   ) or not model_class.supports_gradient_checkpointing:
                   continue
              snake_case					=    model_class(__snake_case   )
              model.to(__snake_case   )
              model.gradient_checkpointing_enable()
              model.train()
              snake_case					=    self._prepare_for_class(__snake_case      , __snake_case      , return_labels=__snake_case   )
              snake_case					=    model(**__snake_case   ).loss
              loss.backward()
    def 		a_      (	self   ):
         snake_case			,  snake_case					=    self.model_tester.prepare_config_and_inputs_for_common()

         snake_case					=    _config_zero_init(__snake_case   )
         for model_class in self.all_model_classes:
              snake_case					=    model_class(config=__snake_case   )
              # 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 		a_      (	self   ):
         pass
    @slow
    def 		a_      (	self   ):
         for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
              snake_case					=    DPTModel.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )




    def 		a_      (	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(__snake_case   ):
              snake_case					=    DPTForDepthEstimation(__snake_case   )






def       UpperCAmelCase__						():



     """simple docstring"""






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

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







    """simple docstring"""

    def 		a_      (	self   ):
         snake_case					=    DPTImageProcessor.from_pretrained('''Intel/dpt-hybrid-midas'''   )
         snake_case					=    DPTForDepthEstimation.from_pretrained('''Intel/dpt-hybrid-midas'''   ).to(__snake_case   )

         snake_case					=    prepare_img()
         snake_case					=    image_processor(images=__snake_case      , return_tensors='''pt'''   ).to(__snake_case   )

         # forward pass
         with torch.no_grad():
              snake_case					=    model(**__snake_case   )
              snake_case					=    outputs.predicted_depth

         # verify the predicted depth
         snake_case					=    torch.Size((1, 3_8_4, 3_8_4)   )
         self.assertEqual(predicted_depth.shape      , __snake_case   )

         snake_case					=    torch.tensor(
             [[[5.6437, 5.6146, 5.6511], [5.4371, 5.5649, 5.5958], [5.5215, 5.5184, 5.5293]]]   ).to(__snake_case   )

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








import enum
import warnings

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
 import tensorflow as tf

 from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

if is_torch_available():
 from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

_SCREAMING_SNAKE_CASE      :			Tuple      				=   logging.get_logger(__name__)

class   A__ (   enum.Enum     ):







    """simple docstring"""

    __magic_name__        =		0
    __magic_name__        =		1






@add_end_docstrings(snake_case__     )
class   A__ (   snake_case__     ):







    """simple docstring"""

    __magic_name__        =		'generated'
    def __init__(	self      , *__snake_case      , **__snake_case   ):
         super().__init__(*__snake_case      , **__snake_case   )

         self.check_model_type(
             TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
             if self.framework == '''tf'''
             else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING   )
    def 		a_      (	self      , __snake_case=None      , __snake_case=None      , __snake_case=None      , __snake_case=None      , __snake_case=None      , __snake_case=None      , **__snake_case      , ):
         snake_case					=    {}
         if truncation is not None:
              snake_case					=    truncation

         snake_case					=    generate_kwargs

         snake_case					=    {}
         if return_tensors is not None and return_type is None:
              snake_case					=    ReturnType.TENSORS if return_tensors else ReturnType.TEXT
         if return_type is not None:
              snake_case					=    return_type

         if clean_up_tokenization_spaces is not None:
              snake_case					=    clean_up_tokenization_spaces

         if stop_sequence is not None:
              snake_case					=    self.tokenizer.encode(__snake_case      , add_special_tokens=__snake_case   )
              if len(__snake_case   ) > 1:
                   warnings.warn(
                       '''Stopping on a multiple token sequence is not yet supported on transformers. The first token of'''
                       ''' the stop sequence will be used as the stop sequence string in the interim.'''   )
              snake_case					=    stop_sequence_ids[0]

         return preprocess_params, forward_params, postprocess_params
    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         return True
    def 		a_      (	self      , *__snake_case      , __snake_case   ):
         snake_case					=    self.model.config.prefix if self.model.config.prefix is not None else ''''''
         if isinstance(args[0]      , __snake_case   ):
              if self.tokenizer.pad_token_id is None:
                   raise ValueError('''Please make sure that the tokenizer has a pad_token_id when using a batch input'''   )
              snake_case					=    ([prefix + arg for arg in args[0]],)
              snake_case					=    True

         elif isinstance(args[0]      , __snake_case   ):
              snake_case					=    (prefix + args[0],)
              snake_case					=    False
         else:
              raise ValueError(
                  F''' `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`'''   )
         snake_case					=    self.tokenizer(*__snake_case      , padding=__snake_case      , truncation=__snake_case      , return_tensors=self.framework   )
         # This is produced by tokenizers but is an invalid generate kwargs
         if "token_type_ids" in inputs:
              del inputs["token_type_ids"]
         return inputs
    def __call__(	self      , *__snake_case      , **__snake_case   ):
         snake_case					=    super().__call__(*__snake_case      , **__snake_case   )
         if (
             isinstance(args[0]      , __snake_case   )
             and all(isinstance(__snake_case      , __snake_case   ) for el in args[0]   )
             and all(len(__snake_case   ) == 1 for res in result   )
         ):
              return [res[0] for res in result]
         return result
    def 		a_      (	self      , __snake_case      , __snake_case=TruncationStrategy.DO_NOT_TRUNCATE      , **__snake_case   ):
         snake_case					=    self._parse_and_tokenize(__snake_case      , truncation=__snake_case      , **__snake_case   )
         return inputs
    def 		a_      (	self      , __snake_case      , **__snake_case   ):
         if self.framework == "pt":
              snake_case			,  snake_case					=    model_inputs['''input_ids'''].shape
         elif self.framework == "tf":
              snake_case			,  snake_case					=    tf.shape(model_inputs['''input_ids''']   ).numpy()

         snake_case					=    generate_kwargs.get('''min_length'''      , self.model.config.min_length   )
         snake_case					=    generate_kwargs.get('''max_length'''      , self.model.config.max_length   )
         self.check_inputs(__snake_case      , generate_kwargs['''min_length''']      , generate_kwargs['''max_length''']   )
         snake_case					=    self.model.generate(**__snake_case      , **__snake_case   )
         snake_case					=    output_ids.shape[0]
         if self.framework == "pt":
              snake_case					=    output_ids.reshape(__snake_case      , out_b // in_b      , *output_ids.shape[1:]   )
         elif self.framework == "tf":
              snake_case					=    tf.reshape(__snake_case      , (in_b, out_b // in_b, *output_ids.shape[1:])   )
         return {"output_ids": output_ids}




    def 		a_      (	self      , __snake_case      , __snake_case=ReturnType.TEXT      , __snake_case=False   ):
         snake_case					=    []
         for output_ids in model_outputs["output_ids"][0]:
              if return_type == ReturnType.TENSORS:
                   snake_case					=    {F'''{self.return_name}_token_ids''': output_ids}
              elif return_type == ReturnType.TEXT:
                   snake_case					=    {
                       F'''{self.return_name}_text''': self.tokenizer.decode(
                           __snake_case      , skip_special_tokens=__snake_case      , clean_up_tokenization_spaces=__snake_case      , )
                   }
              records.append(__snake_case   )
         return records






@add_end_docstrings(snake_case__     )
class   A__ (   snake_case__     ):







    """simple docstring"""

    __magic_name__        =		'summary'
    def __call__(	self      , *__snake_case      , **__snake_case   ):
         return super().__call__(*__snake_case      , **__snake_case   )




    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         if max_length < min_length:
              logger.warning(F'''Your min_length={min_length} must be inferior than your max_length={max_length}.'''   )

         if input_length < max_length:
              logger.warning(
                  F'''Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is '''
                  '''a summarization task, where outputs shorter than the input are typically wanted, you might '''
                  F'''consider decreasing max_length manually, e.g. summarizer(\'...\', max_length={input_length//2})'''   )






@add_end_docstrings(snake_case__     )
class   A__ (   snake_case__     ):







    """simple docstring"""

    __magic_name__        =		'translation'
    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         if input_length > 0.9 * max_length:
              logger.warning(
                  F'''Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider '''
                  '''increasing your max_length manually, e.g. translator(\'...\', max_length=400)'''   )
         return True
    def 		a_      (	self      , *__snake_case      , __snake_case=TruncationStrategy.DO_NOT_TRUNCATE      , __snake_case=None      , __snake_case=None   ):
         if getattr(self.tokenizer      , '''_build_translation_inputs'''      , __snake_case   ):
              return self.tokenizer._build_translation_inputs(
                  *__snake_case      , return_tensors=self.framework      , truncation=__snake_case      , src_lang=__snake_case      , tgt_lang=__snake_case   )
         else:
              return super()._parse_and_tokenize(*__snake_case      , truncation=__snake_case   )
    def 		a_      (	self      , __snake_case=None      , __snake_case=None      , **__snake_case   ):
         snake_case			,  snake_case			,  snake_case					=    super()._sanitize_parameters(**__snake_case   )
         if src_lang is not None:
              snake_case					=    src_lang
         if tgt_lang is not None:
              snake_case					=    tgt_lang
         if src_lang is None and tgt_lang is None:
              # Backward compatibility, direct arguments use is preferred.
              snake_case					=    kwargs.get('''task'''      , self.task   )
              snake_case					=    task.split('''_'''   )
              if task and len(__snake_case   ) == 4:
                   # translation, XX, to YY
                   snake_case					=    items[1]
                   snake_case					=    items[3]
         return preprocess_params, forward_params, postprocess_params




    def __call__(	self      , *__snake_case      , **__snake_case   ):
         return super().__call__(*__snake_case      , **__snake_case   )




