





from dataclasses import dataclass
from typing import Dict, Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .attention_processor import AttentionProcessor, AttnProcessor
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, DiagonalGaussianDistribution, Encoder



@dataclass
class 							_UpperCamelCase					(	__a     ):
       _UpperCamelCase				:					"DiagonalGaussianDistribution"



class 							_UpperCamelCase					(	__a  ,						__a     ):
       _UpperCamelCase				:					List[str]         =   True

       @register_to_config
       def __init__(		self: str					,   _SCREAMING_SNAKE_CASE: Optional[int] = 3					,   _SCREAMING_SNAKE_CASE: Optional[Any] = 3					,   _SCREAMING_SNAKE_CASE: str = ("DownEncoderBlock2D",)					,   _SCREAMING_SNAKE_CASE: Union[str, Any] = ("UpDecoderBlock2D",)					,   _SCREAMING_SNAKE_CASE: Any = (64,)					,   _SCREAMING_SNAKE_CASE: int = 1					,   _SCREAMING_SNAKE_CASE: Any = "silu"					,   _SCREAMING_SNAKE_CASE: Optional[Any] = 4					,   _SCREAMING_SNAKE_CASE: List[Any] = 32					,   _SCREAMING_SNAKE_CASE: str = 32					,   _SCREAMING_SNAKE_CASE: Any = 0.1_82_15					,   )       -> str:




              """simple docstring"""


              super().__init__()

              # pass init params to Encoder
              UpperCamelCase_          =  Encoder(
                  in_channels=lowerCAmelCase_					,   out_channels=lowerCAmelCase_					,   down_block_types=lowerCAmelCase_					,   block_out_channels=lowerCAmelCase_					,   layers_per_block=lowerCAmelCase_					,   act_fn=lowerCAmelCase_					,   norm_num_groups=lowerCAmelCase_					,   double_z=lowerCAmelCase_					,   )

              # pass init params to Decoder
              UpperCamelCase_          =  Decoder(
                  in_channels=lowerCAmelCase_					,   out_channels=lowerCAmelCase_					,   up_block_types=lowerCAmelCase_					,   block_out_channels=lowerCAmelCase_					,   layers_per_block=lowerCAmelCase_					,   norm_num_groups=lowerCAmelCase_					,   act_fn=lowerCAmelCase_					,   )

              UpperCamelCase_          =  nn.Convad(2 * latent_channels					,   2 * latent_channels					,   1		)
              UpperCamelCase_          =  nn.Convad(lowerCAmelCase_					,   lowerCAmelCase_					,   1		)

              UpperCamelCase_          =  False
              UpperCamelCase_          =  False

              # only relevant if vae tiling is enabled
              UpperCamelCase_          =  self.config.sample_size
              UpperCamelCase_          =  (
                  self.config.sample_size[0]
                  if isinstance(self.config.sample_size					,   (list, tuple)		)
                  else self.config.sample_size
              )
              UpperCamelCase_          =  int(sample_size / (2 ** (len(self.config.block_out_channels		) - 1))		)
              UpperCamelCase_          =  0.25

       def lowercase (		self: List[str]					,   _SCREAMING_SNAKE_CASE: Union[str, Any]					,   _SCREAMING_SNAKE_CASE: List[str]=False		)       -> Tuple:




              """simple docstring"""


              if isinstance(lowerCAmelCase_					,   (Encoder, Decoder)		):
                     UpperCamelCase_          =  value

       def lowercase (		self: Optional[int]					,   _SCREAMING_SNAKE_CASE: Tuple = True		)       -> Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_          =  use_tiling

       def lowercase (		self: Optional[Any]		)       -> str:




              """simple docstring"""


              self.enable_tiling(lowerCAmelCase_		)

       def lowercase (		self: Optional[int]		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  True

       def lowercase (		self: List[str]		)       -> Dict:




              """simple docstring"""


              UpperCamelCase_          =  False

       @property
       # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
       def lowercase (		self: Optional[Any]		)       -> Dict[str, AttentionProcessor]:




              """simple docstring"""


              UpperCamelCase_          =  {}

              def fn_recursive_add_processors(_SCREAMING_SNAKE_CASE: str					,   _SCREAMING_SNAKE_CASE: Tuple					,   _SCREAMING_SNAKE_CASE: List[str]		):
                     if hasattr(lowerCAmelCase_					,   "set_processor"		):
                            UpperCamelCase_          =  module.processor

                     for sub_name, child in module.named_children():
                            fn_recursive_add_processors(f'''{name}.{sub_name}'''					,   lowerCAmelCase_					,   lowerCAmelCase_		)

                     return processors

              for name, module in self.named_children():
                     fn_recursive_add_processors(lowerCAmelCase_					,   lowerCAmelCase_					,   lowerCAmelCase_		)

              return processors

       def lowercase (		self: List[Any]					,   _SCREAMING_SNAKE_CASE: Optional[Any]		)       -> int:




              """simple docstring"""


              UpperCamelCase_          =  len(self.attn_processors.keys()		)

              if isinstance(lowerCAmelCase_					,   lowerCAmelCase_		) and len(lowerCAmelCase_		) != count:
                     raise ValueError(
                         f'''A dict of processors was passed, but the number of processors {len(lowerCAmelCase_		)} does not match the'''
                         f''' number of attention layers: {count}. Please make sure to pass {count} processor classes.'''		)

              def fn_recursive_attn_processor(_SCREAMING_SNAKE_CASE: Tuple					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Optional[Any]		):
                     if hasattr(lowerCAmelCase_					,   "set_processor"		):
                            if not isinstance(lowerCAmelCase_					,   lowerCAmelCase_		):
                                   module.set_processor(lowerCAmelCase_		)
                            else:
                                   module.set_processor(processor.pop(f'''{name}.processor'''		)		)

                     for sub_name, child in module.named_children():
                            fn_recursive_attn_processor(f'''{name}.{sub_name}'''					,   lowerCAmelCase_					,   lowerCAmelCase_		)

              for name, module in self.named_children():
                     fn_recursive_attn_processor(lowerCAmelCase_					,   lowerCAmelCase_					,   lowerCAmelCase_		)

       def lowercase (		self: int		)       -> int:




              """simple docstring"""


              self.set_attn_processor(AttnProcessor()		)

       @apply_forward_hook
       def lowercase (		self: List[Any]					,   _SCREAMING_SNAKE_CASE: str					,   _SCREAMING_SNAKE_CASE: List[Any] = True		)       -> AutoencoderKLOutput:




              """simple docstring"""


              if self.use_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size):
                     return self.tiled_encode(lowerCAmelCase_					,   return_dict=lowerCAmelCase_		)

              if self.use_slicing and x.shape[0] > 1:
                     UpperCamelCase_          =  [self.encoder(lowerCAmelCase_		) for x_slice in x.split(1		)]
                     UpperCamelCase_          =  torch.cat(lowerCAmelCase_		)
              else:
                     UpperCamelCase_          =  self.encoder(lowerCAmelCase_		)

              UpperCamelCase_          =  self.quant_conv(lowerCAmelCase_		)
              UpperCamelCase_          =  DiagonalGaussianDistribution(lowerCAmelCase_		)

              if not return_dict:
                     return (posterior,)

              return AutoencoderKLOutput(latent_dist=lowerCAmelCase_		)

       def lowercase (		self: int					,   _SCREAMING_SNAKE_CASE: Optional[int]					,   _SCREAMING_SNAKE_CASE: int = True		)       -> Union[DecoderOutput, torch.FloatTensor]:




              """simple docstring"""


              if self.use_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size):
                     return self.tiled_decode(lowerCAmelCase_					,   return_dict=lowerCAmelCase_		)

              UpperCamelCase_          =  self.post_quant_conv(lowerCAmelCase_		)
              UpperCamelCase_          =  self.decoder(lowerCAmelCase_		)

              if not return_dict:
                     return (dec,)

              return DecoderOutput(sample=lowerCAmelCase_		)

       @apply_forward_hook
       def lowercase (		self: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: int = True		)       -> Union[DecoderOutput, torch.FloatTensor]:




              """simple docstring"""


              if self.use_slicing and z.shape[0] > 1:
                     UpperCamelCase_          =  [self._decode(lowerCAmelCase_		).sample for z_slice in z.split(1		)]
                     UpperCamelCase_          =  torch.cat(lowerCAmelCase_		)
              else:
                     UpperCamelCase_          =  self._decode(lowerCAmelCase_		).sample

              if not return_dict:
                     return (decoded,)

              return DecoderOutput(sample=lowerCAmelCase_		)

       def lowercase (		self: Tuple					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Optional[int]					,   _SCREAMING_SNAKE_CASE: Tuple		)       -> int:




              """simple docstring"""


              UpperCamelCase_          =  min(a.shape[2]					,   b.shape[2]					,   lowerCAmelCase_		)
              for y in range(lowerCAmelCase_		):
                     UpperCamelCase_          =  a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent)
              return b

       def lowercase (		self: Optional[int]					,   _SCREAMING_SNAKE_CASE: Optional[int]					,   _SCREAMING_SNAKE_CASE: Tuple					,   _SCREAMING_SNAKE_CASE: Any		)       -> Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_          =  min(a.shape[3]					,   b.shape[3]					,   lowerCAmelCase_		)
              for x in range(lowerCAmelCase_		):
                     UpperCamelCase_          =  a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent)
              return b

       def lowercase (		self: List[Any]					,   _SCREAMING_SNAKE_CASE: Any					,   _SCREAMING_SNAKE_CASE: List[str] = True		)       -> AutoencoderKLOutput:




              """simple docstring"""


              UpperCamelCase_          =  int(self.tile_sample_min_size * (1 - self.tile_overlap_factor)		)
              UpperCamelCase_          =  int(self.tile_latent_min_size * self.tile_overlap_factor		)
              UpperCamelCase_          =  self.tile_latent_min_size - blend_extent

              # Split the image into 512x512 tiles and encode them separately.
              UpperCamelCase_          =  []
              for i in range(0					,   x.shape[2]					,   lowerCAmelCase_		):
                     UpperCamelCase_          =  []
                     for j in range(0					,   x.shape[3]					,   lowerCAmelCase_		):
                            UpperCamelCase_          =  x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size]
                            UpperCamelCase_          =  self.encoder(lowerCAmelCase_		)
                            UpperCamelCase_          =  self.quant_conv(lowerCAmelCase_		)
                            row.append(lowerCAmelCase_		)
                     rows.append(lowerCAmelCase_		)
              UpperCamelCase_          =  []
              for i, row in enumerate(lowerCAmelCase_		):
                     UpperCamelCase_          =  []
                     for j, tile in enumerate(lowerCAmelCase_		):
                            # blend the above tile and the left tile
                            # to the current tile and add the current tile to the result row
                            if i > 0:
                                   UpperCamelCase_          =  self.blend_v(rows[i - 1][j]					,   lowerCAmelCase_					,   lowerCAmelCase_		)
                            if j > 0:
                                   UpperCamelCase_          =  self.blend_h(row[j - 1]					,   lowerCAmelCase_					,   lowerCAmelCase_		)
                            result_row.append(tile[:, :, :row_limit, :row_limit]		)
                     result_rows.append(torch.cat(lowerCAmelCase_					,   dim=3		)		)

              UpperCamelCase_          =  torch.cat(lowerCAmelCase_					,   dim=2		)
              UpperCamelCase_          =  DiagonalGaussianDistribution(lowerCAmelCase_		)

              if not return_dict:
                     return (posterior,)

              return AutoencoderKLOutput(latent_dist=lowerCAmelCase_		)

       def lowercase (		self: Optional[int]					,   _SCREAMING_SNAKE_CASE: Union[str, Any]					,   _SCREAMING_SNAKE_CASE: Tuple = True		)       -> Union[DecoderOutput, torch.FloatTensor]:




              """simple docstring"""


              UpperCamelCase_          =  int(self.tile_latent_min_size * (1 - self.tile_overlap_factor)		)
              UpperCamelCase_          =  int(self.tile_sample_min_size * self.tile_overlap_factor		)
              UpperCamelCase_          =  self.tile_sample_min_size - blend_extent

              # Split z into overlapping 64x64 tiles and decode them separately.
              # The tiles have an overlap to avoid seams between tiles.
              UpperCamelCase_          =  []
              for i in range(0					,   z.shape[2]					,   lowerCAmelCase_		):
                     UpperCamelCase_          =  []
                     for j in range(0					,   z.shape[3]					,   lowerCAmelCase_		):
                            UpperCamelCase_          =  z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size]
                            UpperCamelCase_          =  self.post_quant_conv(lowerCAmelCase_		)
                            UpperCamelCase_          =  self.decoder(lowerCAmelCase_		)
                            row.append(lowerCAmelCase_		)
                     rows.append(lowerCAmelCase_		)
              UpperCamelCase_          =  []
              for i, row in enumerate(lowerCAmelCase_		):
                     UpperCamelCase_          =  []
                     for j, tile in enumerate(lowerCAmelCase_		):
                            # blend the above tile and the left tile
                            # to the current tile and add the current tile to the result row
                            if i > 0:
                                   UpperCamelCase_          =  self.blend_v(rows[i - 1][j]					,   lowerCAmelCase_					,   lowerCAmelCase_		)
                            if j > 0:
                                   UpperCamelCase_          =  self.blend_h(row[j - 1]					,   lowerCAmelCase_					,   lowerCAmelCase_		)
                            result_row.append(tile[:, :, :row_limit, :row_limit]		)
                     result_rows.append(torch.cat(lowerCAmelCase_					,   dim=3		)		)

              UpperCamelCase_          =  torch.cat(lowerCAmelCase_					,   dim=2		)
              if not return_dict:
                     return (dec,)

              return DecoderOutput(sample=lowerCAmelCase_		)



       def lowercase (		self: int					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Optional[Any] = False					,   _SCREAMING_SNAKE_CASE: int = True					,   _SCREAMING_SNAKE_CASE: List[str] = None					,   )       -> Union[DecoderOutput, torch.FloatTensor]:




              """simple docstring"""


              UpperCamelCase_          =  sample
              UpperCamelCase_          =  self.encode(lowerCAmelCase_		).latent_dist
              if sample_posterior:
                     UpperCamelCase_          =  posterior.sample(generator=lowerCAmelCase_		)
              else:
                     UpperCamelCase_          =  posterior.mode()
              UpperCamelCase_          =  self.decode(lowerCAmelCase_		).sample

              if not return_dict:
                     return (dec,)

              return DecoderOutput(sample=lowerCAmelCase_		)








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 lowercase (		*_SCREAMING_SNAKE_CASE: Optional[int]					,   **_SCREAMING_SNAKE_CASE: Dict		)       -> Union[str, Any]:




                   """simple docstring"""


                   pass



@is_pipeline_test
@require_vision
@require_torch
class 							_UpperCamelCase					(	unittest.TestCase     ):
       _UpperCamelCase				:					str         =   MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

       def lowercase (		self: int					,   _SCREAMING_SNAKE_CASE: str					,   _SCREAMING_SNAKE_CASE: int					,   _SCREAMING_SNAKE_CASE: Optional[Any]		)       -> Any:




              """simple docstring"""


              UpperCamelCase_          =  pipeline(
                  "zero-shot-object-detection"					,   model="hf-internal-testing/tiny-random-owlvit-object-detection"		)

              UpperCamelCase_          =  [
                  {
                      "image": "./tests/fixtures/tests_samples/COCO/000000039769.png",
                      "candidate_labels": ["cat", "remote", "couch"],
                  }
              ]
              return object_detector, examples

       def lowercase (		self: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Tuple					,   _SCREAMING_SNAKE_CASE: Tuple		)       -> Optional[int]:




              """simple docstring"""


              UpperCamelCase_          =  object_detector(examples[0]					,   threshold=0.0		)

              UpperCamelCase_          =  len(_SCREAMING_SNAKE_CASE		)
              self.assertGreater(_SCREAMING_SNAKE_CASE					,   0		)
              self.assertEqual(
                  _SCREAMING_SNAKE_CASE					,   [
                      {
                          "score": ANY(_SCREAMING_SNAKE_CASE		),
                          "label": ANY(_SCREAMING_SNAKE_CASE		),
                          "box": {"xmin": ANY(_SCREAMING_SNAKE_CASE		), "ymin": ANY(_SCREAMING_SNAKE_CASE		), "xmax": ANY(_SCREAMING_SNAKE_CASE		), "ymax": ANY(_SCREAMING_SNAKE_CASE		)},
                      }
                      for i in range(_SCREAMING_SNAKE_CASE		)
                  ]					,   )

       @require_tf
       @unittest.skip("Zero Shot Object Detection not implemented in TF"		)
       def lowercase (		self: Tuple		)       -> List[str]:




              """simple docstring"""


              pass

       @require_torch
       def lowercase (		self: Union[str, Any]		)       -> str:




              """simple docstring"""


              UpperCamelCase_          =  pipeline(
                  "zero-shot-object-detection"					,   model="hf-internal-testing/tiny-random-owlvit-object-detection"		)

              UpperCamelCase_          =  object_detector(
                  "./tests/fixtures/tests_samples/COCO/000000039769.png"					,   candidate_labels=["cat", "remote", "couch"]					,   threshold=0.64					,   )

              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      {"score": 0.72_35, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                      {"score": 0.72_18, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                      {"score": 0.71_84, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                      {"score": 0.67_48, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                      {"score": 0.66_56, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                      {"score": 0.66_14, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                      {"score": 0.64_56, "label": "remote", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                      {"score": 0.6_42, "label": "remote", "box": {"xmin": 67, "ymin": 274, "xmax": 93, "ymax": 297}},
                      {"score": 0.64_19, "label": "cat", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                  ]					,   )

              UpperCamelCase_          =  object_detector(
                  [
                      {
                          "image": "./tests/fixtures/tests_samples/COCO/000000039769.png",
                          "candidate_labels": ["cat", "remote", "couch"],
                      }
                  ]					,   threshold=0.64					,   )

              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      [
                          {"score": 0.72_35, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                          {"score": 0.72_18, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                          {"score": 0.71_84, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                          {"score": 0.67_48, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                          {"score": 0.66_56, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                          {"score": 0.66_14, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                          {"score": 0.64_56, "label": "remote", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                          {"score": 0.6_42, "label": "remote", "box": {"xmin": 67, "ymin": 274, "xmax": 93, "ymax": 297}},
                          {"score": 0.64_19, "label": "cat", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                      ]
                  ]					,   )

       @require_torch
       @slow
       def lowercase (		self: List[str]		)       -> List[str]:




              """simple docstring"""


              UpperCamelCase_          =  pipeline("zero-shot-object-detection"		)

              UpperCamelCase_          =  object_detector(
                  "http://images.cocodataset.org/val2017/000000039769.jpg"					,   candidate_labels=["cat", "remote", "couch"]					,   )
              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      {"score": 0.28_68, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                      {"score": 0.2_77, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                      {"score": 0.25_37, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                      {"score": 0.14_74, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                      {"score": 0.12_08, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                  ]					,   )

              UpperCamelCase_          =  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(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      [
                          {"score": 0.28_68, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                          {"score": 0.2_77, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                          {"score": 0.25_37, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                          {"score": 0.14_74, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                          {"score": 0.12_08, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                      ],
                      [
                          {"score": 0.28_68, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                          {"score": 0.2_77, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                          {"score": 0.25_37, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                          {"score": 0.14_74, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                          {"score": 0.12_08, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                      ],
                  ]					,   )

       @require_tf
       @unittest.skip("Zero Shot Object Detection not implemented in TF"		)
       def lowercase (		self: List[Any]		)       -> str:




              """simple docstring"""


              pass

       @require_torch
       @slow
       def lowercase (		self: Any		)       -> int:




              """simple docstring"""


              UpperCamelCase_          =  0.2
              UpperCamelCase_          =  pipeline("zero-shot-object-detection"		)

              UpperCamelCase_          =  object_detector(
                  "http://images.cocodataset.org/val2017/000000039769.jpg"					,   candidate_labels=["cat", "remote", "couch"]					,   threshold=_SCREAMING_SNAKE_CASE					,   )
              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      {"score": 0.28_68, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                      {"score": 0.2_77, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                      {"score": 0.25_37, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                  ]					,   )



       @require_torch
       @slow
       def lowercase (		self: Dict		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  2
              UpperCamelCase_          =  pipeline("zero-shot-object-detection"		)

              UpperCamelCase_          =  object_detector(
                  "http://images.cocodataset.org/val2017/000000039769.jpg"					,   candidate_labels=["cat", "remote", "couch"]					,   top_k=_SCREAMING_SNAKE_CASE					,   )
              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE					,   decimals=4		)					,   [
                      {"score": 0.28_68, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                      {"score": 0.2_77, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                  ]					,   )

