
"""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 		a__						:
   def __init__(			self	,    _a	,    _a=2	,    _a=32	,    _a=16	,    _a=3	,    _a=True	,    _a=True	,    _a=32	,    _a=4	,    _a=[0, 1, 2, 3]	,    _a=4	,    _a=37	,    _a="gelu"	,    _a=0.1	,    _a=0.1	,    _a=0.0_2	,    _a=3	,    _a=[1, 384, 24, 24]	,    _a=True	,    _a=None	,    ):
          lowercase    :				Optional[Any]       		=							parent
          lowercase    :				List[Any]       		=							batch_size
          lowercase    :				Optional[Any]       		=							image_size
          lowercase    :				Optional[Any]       		=							patch_size
          lowercase    :				int       		=							num_channels
          lowercase    :				Optional[Any]       		=							is_training
          lowercase    :				Optional[int]       		=							use_labels
          lowercase    :				Dict       		=							hidden_size
          lowercase    :				Tuple       		=							num_hidden_layers
          lowercase    :				Tuple       		=							backbone_out_indices
          lowercase    :				Any       		=							num_attention_heads
          lowercase    :				List[str]       		=							intermediate_size
          lowercase    :				List[str]       		=							hidden_act
          lowercase    :				Union[str, Any]       		=							hidden_dropout_prob
          lowercase    :				Union[str, Any]       		=							attention_probs_dropout_prob
          lowercase    :				int       		=							initializer_range
          lowercase    :				Union[str, Any]       		=							num_labels
          lowercase    :				Optional[Any]       		=							backbone_featmap_shape
          lowercase    :				List[Any]       		=							scope
          lowercase    :				Union[str, Any]       		=							is_hybrid
          # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
          lowercase    :				Optional[Any]       		=							(image_size // patch_size) ** 2
          lowercase    :				Optional[int]       		=							num_patches + 1
   def 			__magic_name__			(			self				):
          lowercase    :				Optional[Any]       		=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

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

          lowercase    :				str       		=							self.get_config()

          return config, pixel_values, labels
   def 			__magic_name__			(			self				):
          lowercase    :				Optional[int]       		=							{
              '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=__UpperCamelCase	,    initializer_range=self.initializer_range	,    is_hybrid=self.is_hybrid	,    backbone_config=__UpperCamelCase	,    backbone_featmap_shape=self.backbone_featmap_shape	,    )
   def 			__magic_name__			(			self	,    _a	,    _a	,    _a				):
          lowercase    :				List[Any]       		=							DPTModel(config=__UpperCamelCase				)
          model.to(__UpperCamelCase				)
          model.eval()
          lowercase    :				str       		=							model(__UpperCamelCase				)
          self.parent.assertEqual(result.last_hidden_state.shape	,    (self.batch_size, self.seq_length, self.hidden_size)				)
   def 			__magic_name__			(			self	,    _a	,    _a	,    _a				):
          lowercase    :				List[str]       		=							self.num_labels
          lowercase    :				Any       		=							DPTForDepthEstimation(__UpperCamelCase				)
          model.to(__UpperCamelCase				)
          model.eval()
          lowercase    :				Any       		=							model(__UpperCamelCase				)
          self.parent.assertEqual(result.predicted_depth.shape	,    (self.batch_size, self.image_size, self.image_size)				)
   def 			__magic_name__			(			self	,    _a	,    _a	,    _a				):
          lowercase    :				Optional[int]       		=							self.num_labels
          lowercase    :				Dict       		=							DPTForSemanticSegmentation(__UpperCamelCase				)
          model.to(__UpperCamelCase				)
          model.eval()
          lowercase    :				Any       		=							model(__UpperCamelCase	,    labels=__UpperCamelCase				)
          self.parent.assertEqual(
              result.logits.shape	,    (self.batch_size, self.num_labels, self.image_size, self.image_size)				)

   def 			__magic_name__			(			self				):
          lowercase    :				Dict       		=							self.prepare_config_and_inputs()
          lowercase    :				Optional[Any]       		=							config_and_inputs
          lowercase    :				Any       		=							{'pixel_values': pixel_values}
          return config, inputs_dict


@require_torch
class 		a__						(      lowercase_,			lowercase_,			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 			__magic_name__			(			self				):
          lowercase    :				Optional[Any]       		=							DPTModelTester(self				)
          lowercase    :				Tuple       		=							ConfigTester(self	,    config_class=__UpperCamelCase	,    has_text_modality=__UpperCamelCase	,    hidden_size=37				)
   def 			__magic_name__			(			self				):
          self.config_tester.run_common_tests()
   @unittest.skip(reason="DPT does not use inputs_embeds"				)
   def 			__magic_name__			(			self				):
          pass
   def 			__magic_name__			(			self				):
          lowercase    :				str       		=							self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                 lowercase    :				Dict       		=							model_class(__UpperCamelCase				)
                 self.assertIsInstance(model.get_input_embeddings()	,    (nn.Module)				)
                 lowercase    :				Any       		=							model.get_output_embeddings()
                 self.assertTrue(x is None or isinstance(__UpperCamelCase	,    nn.Linear				)				)
   def 			__magic_name__			(			self				):
          lowercase    :				int       		=							self.model_tester.prepare_config_and_inputs_for_common()

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

                 lowercase    :				List[Any]       		=							['pixel_values']
                 self.assertListEqual(arg_names[:1]	,    __UpperCamelCase				)
   def 			__magic_name__			(			self				):
          lowercase    :				Tuple       		=							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*__UpperCamelCase				)
   def 			__magic_name__			(			self				):
          lowercase    :				Any       		=							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_depth_estimation(*__UpperCamelCase				)
   def 			__magic_name__			(			self				):
          lowercase    :				Optional[Any]       		=							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCamelCase				)
   def 			__magic_name__			(			self				):


          for model_class in self.all_model_classes:
                 if model_class.__name__ == "DPTForDepthEstimation":
                        continue

                 lowercase    :				List[Any]       		=							self.model_tester.prepare_config_and_inputs_for_common()
                 lowercase    :				str       		=							True

                 if model_class in get_values(__UpperCamelCase				):
                        continue

                 lowercase    :				Union[str, Any]       		=							model_class(__UpperCamelCase				)
                 model.to(__UpperCamelCase				)
                 model.train()
                 lowercase    :				Any       		=							self._prepare_for_class(__UpperCamelCase	,    __UpperCamelCase	,    return_labels=__UpperCamelCase				)
                 lowercase    :				Dict       		=							model(**__UpperCamelCase				).loss
                 loss.backward()
   def 			__magic_name__			(			self				):


          for model_class in self.all_model_classes:
                 if model_class.__name__ == "DPTForDepthEstimation":
                        continue

                 lowercase    :				int       		=							self.model_tester.prepare_config_and_inputs_for_common()
                 lowercase    :				Optional[Any]       		=							False
                 lowercase    :				List[Any]       		=							True

                 if model_class in get_values(__UpperCamelCase				) or not model_class.supports_gradient_checkpointing:
                        continue
                 lowercase    :				List[str]       		=							model_class(__UpperCamelCase				)
                 model.to(__UpperCamelCase				)
                 model.gradient_checkpointing_enable()
                 model.train()
                 lowercase    :				Any       		=							self._prepare_for_class(__UpperCamelCase	,    __UpperCamelCase	,    return_labels=__UpperCamelCase				)
                 lowercase    :				str       		=							model(**__UpperCamelCase				).loss
                 loss.backward()
   def 			__magic_name__			(			self				):
          lowercase    :				Optional[int]       		=							self.model_tester.prepare_config_and_inputs_for_common()

          lowercase    :				Tuple       		=							_config_zero_init(__UpperCamelCase				)
          for model_class in self.all_model_classes:
                 lowercase    :				List[str]       		=							model_class(config=__UpperCamelCase				)
                 # Skip the check for the backbone
                 lowercase    :				List[Any]       		=							[]
                 for name, module in model.named_modules():
                        if module.__class__.__name__ == "DPTViTHybridEmbeddings":
                               lowercase    :				Any       		=							[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 			__magic_name__			(			self				):
          pass
   @slow
   def 			__magic_name__			(			self				):


          for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
                 lowercase    :				int       		=							DPTModel.from_pretrained(__UpperCamelCase				)
                 self.assertIsNotNone(__UpperCamelCase				)

   def 			__magic_name__			(			self				):
          lowercase    :				int       		=							self.model_tester.prepare_config_and_inputs_for_common()
          lowercase    :				Dict       		=							'add'
          with self.assertRaises(__UpperCamelCase				):
                 lowercase    :				List[Any]       		=							DPTForDepthEstimation(__UpperCamelCase				)


def   __magic_name__	(      ) ->				Dict:
       lowercase    :				Dict       		=							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
       return image

@require_torch
@require_vision
@slow
class 		a__						(      unittest.TestCase						):
   def 			__magic_name__			(			self				):
          lowercase    :				Optional[int]       		=							DPTImageProcessor.from_pretrained("Intel/dpt-hybrid-midas"				)
          lowercase    :				int       		=							DPTForDepthEstimation.from_pretrained("Intel/dpt-hybrid-midas"				).to(__UpperCamelCase				)

          lowercase    :				Union[str, Any]       		=							prepare_img()
          lowercase    :				Optional[Any]       		=							image_processor(images=__UpperCamelCase	,    return_tensors="pt"				).to(__UpperCamelCase				)

          # forward pass
          with torch.no_grad():
                 lowercase    :				Union[str, Any]       		=							model(**__UpperCamelCase				)
                 lowercase    :				Any       		=							outputs.predicted_depth

          # verify the predicted depth
          lowercase    :				Any       		=							torch.Size((1, 384, 384)				)
          self.assertEqual(predicted_depth.shape	,    __UpperCamelCase				)

          lowercase    :				Tuple       		=							torch.tensor(
              [[[5.6_4_3_7, 5.6_1_4_6, 5.6_5_1_1], [5.4_3_7_1, 5.5_6_4_9, 5.5_9_5_8], [5.5_2_1_5, 5.5_1_8_4, 5.5_2_9_3]]]				).to(__UpperCamelCase				)

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



"""simple docstring"""







import unittest

from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
       from PIL import Image
else:







       class        UpperCamelCase		:
          @staticmethod
          def 			_UpperCAmelCase   (			*__UpperCamelCase     ,**__UpperCamelCase			)	->      Union[str, Any]:


               '''simple docstring'''


               pass







@is_pipeline_test
@require_vision
@require_torch
class        UpperCamelCase		(			unittest.TestCase  ):
   lowercase							=  MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)	->      Tuple:


        '''simple docstring'''


        lowercase_	:				int													=	pipeline(
            'zero-shot-object-detection'     ,model='hf-internal-testing/tiny-random-owlvit-object-detection'			)

        lowercase_	:				Optional[int]													=	[
            {
                'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
                'candidate_labels': ['cat', 'remote', 'couch'],
            }
        ]
        return object_detector, examples
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase			)	->      str:


        '''simple docstring'''


        lowercase_	:				Tuple													=	object_detector(examples[0]     ,threshold=0.0			)

        lowercase_	:				Any													=	len(__UpperCamelCase			)
        self.assertGreater(__UpperCamelCase     ,0			)
        self.assertEqual(
            __UpperCamelCase     ,[
                {
                    'score': ANY(__UpperCamelCase			),
                    'label': ANY(__UpperCamelCase			),
                    'box': {'xmin': ANY(__UpperCamelCase			), 'ymin': ANY(__UpperCamelCase			), 'xmax': ANY(__UpperCamelCase			), 'ymax': ANY(__UpperCamelCase			)},
                }
                for i in range(__UpperCamelCase			)
            ]     ,)
   @require_tf
   @unittest.skip('Zero Shot Object Detection not implemented in TF'			)
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        pass
   @require_torch
   def 			_UpperCAmelCase   (			self			)	->      int:


        '''simple docstring'''


        lowercase_	:				List[Any]													=	pipeline(
            'zero-shot-object-detection'     ,model='hf-internal-testing/tiny-random-owlvit-object-detection'			)

        lowercase_	:				Optional[int]													=	object_detector(
            './tests/fixtures/tests_samples/COCO/000000039769.png'     ,candidate_labels=['cat', 'remote', 'couch']     ,threshold=0.64     ,)

        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,decimals=4			)     ,[
                {'score': 0.7235, 'label': 'cat', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
                {'score': 0.7218, 'label': 'remote', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
                {'score': 0.7184, 'label': 'couch', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
                {'score': 0.6748, 'label': 'remote', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
                {'score': 0.6656, 'label': 'cat', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
                {'score': 0.6614, 'label': 'couch', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
                {'score': 0.6456, 'label': 'remote', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
                {'score': 0.642, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 274, 'xmax': 93, 'ymax': 297}},
                {'score': 0.6419, 'label': 'cat', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
            ]     ,)

        lowercase_	:				Union[str, Any]													=	object_detector(
            [
                {
                    'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
                    'candidate_labels': ['cat', 'remote', 'couch'],
                }
            ]     ,threshold=0.64     ,)

        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,decimals=4			)     ,[
                [
                    {'score': 0.7235, 'label': 'cat', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
                    {'score': 0.7218, 'label': 'remote', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
                    {'score': 0.7184, 'label': 'couch', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
                    {'score': 0.6748, 'label': 'remote', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
                    {'score': 0.6656, 'label': 'cat', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
                    {'score': 0.6614, 'label': 'couch', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
                    {'score': 0.6456, 'label': 'remote', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
                    {'score': 0.642, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 274, 'xmax': 93, 'ymax': 297}},
                    {'score': 0.6419, 'label': 'cat', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
                ]
            ]     ,)
   @require_torch
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        lowercase_	:				Any													=	pipeline('zero-shot-object-detection'			)

        lowercase_	:				List[str]													=	object_detector(
            'http://images.cocodataset.org/val2017/000000039769.jpg'     ,candidate_labels=['cat', 'remote', 'couch']     ,)
        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,decimals=4			)     ,[
                {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
                {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
                {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
                {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
                {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
            ]     ,)

        lowercase_	:				Union[str, Any]													=	object_detector(
            [
                {
                    'image': 'http://images.cocodataset.org/val2017/000000039769.jpg',
                    'candidate_labels': ['cat', 'remote', 'couch'],
                },
                {
                    'image': 'http://images.cocodataset.org/val2017/000000039769.jpg',
                    'candidate_labels': ['cat', 'remote', 'couch'],
                },
            ]     ,)
        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,decimals=4			)     ,[
                [
                    {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
                    {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
                    {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
                    {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
                    {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
                ],
                [
                    {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
                    {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
                    {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
                    {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
                    {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
                ],
            ]     ,)
   @require_tf
   @unittest.skip('Zero Shot Object Detection not implemented in TF'			)
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


        pass
   @require_torch
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	0.2
        lowercase_	:				Any													=	pipeline('zero-shot-object-detection'			)

        lowercase_	:				str													=	object_detector(
            'http://images.cocodataset.org/val2017/000000039769.jpg'     ,candidate_labels=['cat', 'remote', 'couch']     ,threshold=__UpperCamelCase     ,)
        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,decimals=4			)     ,[
                {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
                {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
                {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
            ]     ,)







   @require_torch
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        lowercase_	:				Tuple													=	2
        lowercase_	:				Optional[Any]													=	pipeline('zero-shot-object-detection'			)

        lowercase_	:				List[Any]													=	object_detector(
            'http://images.cocodataset.org/val2017/000000039769.jpg'     ,candidate_labels=['cat', 'remote', 'couch']     ,top_k=__UpperCamelCase     ,)
        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,decimals=4			)     ,[
                {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
                {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
            ]     ,)

