



"""simple docstring"""
import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    WavaVecaConfig,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaForCTC,
    WavaVecaForPreTraining,
    WavaVecaProcessor,
    logging,
)
from transformers.models.wavaveca.modeling_wavaveca import WavaVecaForSequenceClassification


logging.set_verbosity_info()
UpperCAmelCase						:		List[Any]			= logging.get_logger(__name__)

UpperCAmelCase						:		Dict			= {
    "post_extract_proj": "feature_projection.projection",
    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
    "fc2": "encoder.layers.*.feed_forward.output_dense",
    "final_layer_norm": "encoder.layers.*.final_layer_norm",
    "encoder.layer_norm": "encoder.layer_norm",
    "adapter_layer": "encoder.layers.*.adapter_layer",
    "w2v_model.layer_norm": "feature_projection.layer_norm",
    "quantizer.weight_proj": "quantizer.weight_proj",
    "quantizer.vars": "quantizer.codevectors",
    "project_q": "project_q",
    "final_proj": "project_hid",
    "w2v_encoder.proj": "lm_head",
    "mask_emb": "masked_spec_embed",
    "pooling_layer.linear": "projector",
    "pooling_layer.projection": "classifier",
}
UpperCAmelCase						:		Any			= [
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
    "projector",
    "classifier",
]


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase							) ->						Optional[int]:







  '''simple docstring'''


  lowercase_								= {}
  with open(__lowerCAmelCase ,  """r"""							) as file:
    for line_number, line in enumerate(__lowerCAmelCase							):
      lowercase_								= line.strip()
      if line:
        lowercase_								= line.split()
        lowercase_								= line_number
        lowercase_								= words[0]
        lowercase_								= value
  return result


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							) ->						Union[str, Any]:







  '''simple docstring'''


  for attribute in key.split("""."""							):
    lowercase_								= getattr(__lowerCAmelCase ,  __lowerCAmelCase							)

  lowercase_								= None
  for param_key in PARAM_MAPPING.keys():
    if full_name.endswith(__lowerCAmelCase							):
      lowercase_								= PARAM_MAPPING[full_name.split("""."""							)[-1]]
      lowercase_								= """param"""

  if weight_type is not None and weight_type != "param":
    lowercase_								= getattr(__lowerCAmelCase ,  __lowerCAmelCase							).shape
  elif weight_type is not None and weight_type == "param":
    lowercase_								= hf_pointer
    for attribute in hf_param_name.split("""."""							):
      lowercase_								= getattr(__lowerCAmelCase ,  __lowerCAmelCase							)
    lowercase_								= shape_pointer.shape

    # let's reduce dimension
    lowercase_								= value[0]
  else:
    lowercase_								= hf_pointer.shape

  if hf_shape != value.shape:
    raise ValueError(
        F'''Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'''
        F''' {value.shape} for {full_name}'''							)

  if weight_type == "weight":
    lowercase_								= value
  elif weight_type == "weight_g":
    lowercase_								= value
  elif weight_type == "weight_v":
    lowercase_								= value
  elif weight_type == "bias":
    lowercase_								= value
  elif weight_type == "param":
    for attribute in hf_param_name.split("""."""							):
      lowercase_								= getattr(__lowerCAmelCase ,  __lowerCAmelCase							)
    lowercase_								= value
  else:
    lowercase_								= value

  logger.info(F'''{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'''							)


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							) ->						Any:







  '''simple docstring'''


  lowercase_								= None
  for param_key in PARAM_MAPPING.keys():
    if full_name.endswith(__lowerCAmelCase							):
      lowercase_								= PARAM_MAPPING[full_name.split("""."""							)[-1]]
      lowercase_								= """param"""

  if weight_type is not None and weight_type != "param":
    lowercase_								= """.""".join([key, weight_type]							)
  elif weight_type is not None and weight_type == "param":
    lowercase_								= """.""".join([key, hf_param_name]							)
  else:
    lowercase_								= key

  lowercase_								= value if """lm_head""" in full_key else value[0]


UpperCAmelCase						:		int			= {
    "W_a": "linear_1.weight",
    "W_b": "linear_2.weight",
    "b_a": "linear_1.bias",
    "b_b": "linear_2.bias",
    "ln_W": "norm.weight",
    "ln_b": "norm.bias",
}


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase=None ,  __lowerCAmelCase=None							) ->						Optional[Any]:







  '''simple docstring'''


  lowercase_								= False
  for key, mapped_key in MAPPING.items():
    lowercase_								= """wav2vec2.""" + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
    if key in name or key.split("""w2v_model."""							)[-1] == name.split("""."""							)[0]:
      lowercase_								= True
      if "*" in mapped_key:
        lowercase_								= name.split(__lowerCAmelCase							)[0].split("""."""							)[-2]
        lowercase_								= mapped_key.replace("""*""" ,  __lowerCAmelCase							)
      if "weight_g" in name:
        lowercase_								= """weight_g"""
      elif "weight_v" in name:
        lowercase_								= """weight_v"""
      elif "bias" in name:
        lowercase_								= """bias"""
      elif "weight" in name:
        # TODO: don't match quantizer.weight_proj
        lowercase_								= """weight"""
      else:
        lowercase_								= None
      if hf_dict is not None:
        rename_dict(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							)
      else:
        set_recursively(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							)
      return is_used
  return is_used


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							) ->						int:







  '''simple docstring'''


  lowercase_								= []
  lowercase_								= fairseq_model.state_dict()

  lowercase_								= hf_model.wavaveca.feature_extractor

  for name, value in fairseq_dict.items():
    lowercase_								= False
    if "conv_layers" in name:
      load_conv_layer(
          __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  hf_model.config.feat_extract_norm == """group""" ,  )
      lowercase_								= True
    else:
      lowercase_								= load_wavaveca_layer(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							)
    if not is_used:
      unused_weights.append(__lowerCAmelCase							)

  logger.warning(F'''Unused weights: {unused_weights}'''							)


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							) ->						Dict:







  '''simple docstring'''


  lowercase_								= full_name.split("""conv_layers."""							)[-1]
  lowercase_								= name.split("""."""							)
  lowercase_								= int(items[0]							)
  lowercase_								= int(items[1]							)

  if type_id == 0:
    if "bias" in name:
      if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
        raise ValueError(
            F'''{full_name} has size {value.shape}, but'''
            F''' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'''							)
      lowercase_								= value
      logger.info(F'''Feat extract conv layer {layer_id} was initialized from {full_name}.'''							)
    elif "weight" in name:
      if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
        raise ValueError(
            F'''{full_name} has size {value.shape}, but'''
            F''' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'''							)
      lowercase_								= value
      logger.info(F'''Feat extract conv layer {layer_id} was initialized from {full_name}.'''							)
  elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
    if "bias" in name:
      if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
        raise ValueError(
            F'''{full_name} has size {value.shape}, but'''
            F''' {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found.'''							)
      lowercase_								= value
      logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''							)
    elif "weight" in name:
      if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
        raise ValueError(
            F'''{full_name} has size {value.shape}, but'''
            F''' {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found.'''							)
      lowercase_								= value
      logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'''							)
  else:
    unused_weights.append(__lowerCAmelCase							)


@torch.no_grad()
def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase=None ,  __lowerCAmelCase=None ,  __lowerCAmelCase=True ,  __lowerCAmelCase=False							) ->						Dict:







  '''simple docstring'''


  if config_path is not None:
    lowercase_								= WavaVecaConfig.from_pretrained(__lowerCAmelCase							)
  else:
    lowercase_								= WavaVecaConfig()

  if is_seq_class:
    lowercase_								= read_txt_into_dict(__lowerCAmelCase							)
    lowercase_								= idalabel
    lowercase_								= WavaVecaForSequenceClassification(__lowerCAmelCase							)
    lowercase_								= WavaVecaFeatureExtractor(
        feature_size=1 ,  sampling_rate=1_60_00 ,  padding_value=0 ,  do_normalize=__lowerCAmelCase ,  return_attention_mask=__lowerCAmelCase ,  )
    feature_extractor.save_pretrained(__lowerCAmelCase							)

  elif is_finetuned:
    if dict_path:
      lowercase_								= Dictionary.load(__lowerCAmelCase							)

      # important change bos & pad token id since CTC symbol is <pad> and
      # not <s> as in fairseq
      lowercase_								= target_dict.pad_index
      lowercase_								= target_dict.bos_index
      lowercase_								= target_dict.eos_index
      lowercase_								= len(target_dict.symbols							)
      lowercase_								= os.path.join(__lowerCAmelCase ,  """vocab.json"""							)
      if not os.path.isdir(__lowerCAmelCase							):
        logger.error("""--pytorch_dump_folder_path ({}) should be a directory""".format(__lowerCAmelCase							)							)
        return
      os.makedirs(__lowerCAmelCase ,  exist_ok=__lowerCAmelCase							)
      lowercase_								= target_dict.indices

      # fairseq has the <pad> and <s> switched
      lowercase_								= 0
      lowercase_								= 1
      with open(__lowerCAmelCase ,  """w""" ,  encoding="""utf-8"""							) as vocab_handle:
        json.dump(__lowerCAmelCase ,  __lowerCAmelCase							)
      lowercase_								= WavaVecaCTCTokenizer(
          __lowerCAmelCase ,  unk_token=target_dict.unk_word ,  pad_token=target_dict.pad_word ,  bos_token=target_dict.bos_word ,  eos_token=target_dict.eos_word ,  word_delimiter_token="""|""" ,  do_lower_case=__lowerCAmelCase ,  )
      lowercase_								= True if config.feat_extract_norm == """layer""" else False
      lowercase_								= WavaVecaFeatureExtractor(
          feature_size=1 ,  sampling_rate=1_60_00 ,  padding_value=0 ,  do_normalize=__lowerCAmelCase ,  return_attention_mask=__lowerCAmelCase ,  )
      lowercase_								= WavaVecaProcessor(feature_extractor=__lowerCAmelCase ,  tokenizer=__lowerCAmelCase							)
      processor.save_pretrained(__lowerCAmelCase							)

    lowercase_								= WavaVecaForCTC(__lowerCAmelCase							)
  else:
    lowercase_								= WavaVecaForPreTraining(__lowerCAmelCase							)

  if is_finetuned or is_seq_class:
    lowercase_					,    lowercase_					,    lowercase_								= fairseq.checkpoint_utils.load_model_ensemble_and_task(
        [checkpoint_path] ,  arg_overrides={"""data""": """/""".join(dict_path.split("""/"""							)[:-1]							)}							)
  else:
    lowercase_								= argparse.Namespace(task="""audio_pretraining"""							)
    lowercase_								= fairseq.tasks.setup_task(__lowerCAmelCase							)

    lowercase_					,    lowercase_					,    lowercase_								= fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] ,  task=__lowerCAmelCase							)

  lowercase_								= model[0].eval()

  recursively_load_weights(__lowerCAmelCase ,  __lowerCAmelCase ,  not is_finetuned							)

  hf_wavavec.save_pretrained(__lowerCAmelCase							)


if __name__ == "__main__":
       UpperCAmelCase						:		int			= argparse.ArgumentParser()
       parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
       parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
       parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
       parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
       parser.add_argument(
           "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
       )
       parser.add_argument(
           "--is_seq_class",
           action="store_true",
           help="Whether the model to convert is a fine-tuned sequence classification model or not",
       )
       UpperCAmelCase						:		Optional[Any]			= parser.parse_args()

       UpperCAmelCase						:		Dict			= not args.not_finetuned and not args.is_seq_class
       convert_wavaveca_checkpoint(
           args.checkpoint_path,
           args.pytorch_dump_folder_path,
           args.config_path,
           args.dict_path,
           is_finetuned,
           args.is_seq_class,
       )










"""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    SCREAMING_SNAKE_CASE__ :

           @staticmethod
           def 					_UpperCAmelCase	(				*lowerCAmelCase_			:				Tuple ,  **lowerCAmelCase_			:				Tuple):







             """simple docstring"""







             pass


@is_pipeline_test
@require_vision
@require_torch
class    SCREAMING_SNAKE_CASE__ (							unittest.TestCase   ):
    lowercase__      =   MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

    def 					_UpperCAmelCase	(				self			:				Optional[Any] ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				List[Any]):







      """simple docstring"""







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

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

    def 					_UpperCAmelCase	(				self			:				Optional[Any] ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Optional[Any]):







      """simple docstring"""







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

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

    @require_tf
    @unittest.skip("""Zero Shot Object Detection not implemented in TF""")
    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      pass

    @require_torch
    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







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

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

      self.assertEqual(
          nested_simplify(lowerCAmelCase_ ,  decimals=4) ,  [
              {"""score""": 0.7_235, """label""": """cat""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
              {"""score""": 0.7_218, """label""": """remote""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
              {"""score""": 0.7_184, """label""": """couch""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
              {"""score""": 0.6_748, """label""": """remote""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
              {"""score""": 0.6_656, """label""": """cat""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
              {"""score""": 0.6_614, """label""": """couch""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
              {"""score""": 0.6_456, """label""": """remote""", """box""": {"""xmin""": 4_9_4, """ymin""": 1_0_5, """xmax""": 5_2_1, """ymax""": 1_2_7}},
              {"""score""": 0.642, """label""": """remote""", """box""": {"""xmin""": 6_7, """ymin""": 2_7_4, """xmax""": 9_3, """ymax""": 2_9_7}},
              {"""score""": 0.6_419, """label""": """cat""", """box""": {"""xmin""": 4_9_4, """ymin""": 1_0_5, """xmax""": 5_2_1, """ymax""": 1_2_7}},
          ] ,  )

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

      self.assertEqual(
          nested_simplify(lowerCAmelCase_ ,  decimals=4) ,  [
              [
                  {"""score""": 0.7_235, """label""": """cat""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
                  {"""score""": 0.7_218, """label""": """remote""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
                  {"""score""": 0.7_184, """label""": """couch""", """box""": {"""xmin""": 2_0_4, """ymin""": 1_6_7, """xmax""": 2_3_2, """ymax""": 1_9_0}},
                  {"""score""": 0.6_748, """label""": """remote""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
                  {"""score""": 0.6_656, """label""": """cat""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
                  {"""score""": 0.6_614, """label""": """couch""", """box""": {"""xmin""": 5_7_1, """ymin""": 8_3, """xmax""": 5_9_8, """ymax""": 1_0_3}},
                  {"""score""": 0.6_456, """label""": """remote""", """box""": {"""xmin""": 4_9_4, """ymin""": 1_0_5, """xmax""": 5_2_1, """ymax""": 1_2_7}},
                  {"""score""": 0.642, """label""": """remote""", """box""": {"""xmin""": 6_7, """ymin""": 2_7_4, """xmax""": 9_3, """ymax""": 2_9_7}},
                  {"""score""": 0.6_419, """label""": """cat""", """box""": {"""xmin""": 4_9_4, """ymin""": 1_0_5, """xmax""": 5_2_1, """ymax""": 1_2_7}},
              ]
          ] ,  )

    @require_torch
    @slow
    def 					_UpperCAmelCase	(				self			:				Dict):







      """simple docstring"""







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

      lowercase_								= object_detector(
          """http://images.cocodataset.org/val2017/000000039769.jpg""" ,  candidate_labels=["""cat""", """remote""", """couch"""] ,  )
      self.assertEqual(
          nested_simplify(lowerCAmelCase_ ,  decimals=4) ,  [
              {"""score""": 0.2_868, """label""": """cat""", """box""": {"""xmin""": 3_2_4, """ymin""": 2_0, """xmax""": 6_4_0, """ymax""": 3_7_3}},
              {"""score""": 0.277, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_2, """xmax""": 1_7_7, """ymax""": 1_1_5}},
              {"""score""": 0.2_537, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 5_5, """xmax""": 3_1_5, """ymax""": 4_7_2}},
              {"""score""": 0.1_474, """label""": """remote""", """box""": {"""xmin""": 3_3_5, """ymin""": 7_4, """xmax""": 3_7_1, """ymax""": 1_8_7}},
              {"""score""": 0.1_208, """label""": """couch""", """box""": {"""xmin""": 4, """ymin""": 0, """xmax""": 6_4_2, """ymax""": 4_7_6}},
          ] ,  )

      lowercase_								= 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(lowerCAmelCase_ ,  decimals=4) ,  [
              [
                  {"""score""": 0.2_868, """label""": """cat""", """box""": {"""xmin""": 3_2_4, """ymin""": 2_0, """xmax""": 6_4_0, """ymax""": 3_7_3}},
                  {"""score""": 0.277, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_2, """xmax""": 1_7_7, """ymax""": 1_1_5}},
                  {"""score""": 0.2_537, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 5_5, """xmax""": 3_1_5, """ymax""": 4_7_2}},
                  {"""score""": 0.1_474, """label""": """remote""", """box""": {"""xmin""": 3_3_5, """ymin""": 7_4, """xmax""": 3_7_1, """ymax""": 1_8_7}},
                  {"""score""": 0.1_208, """label""": """couch""", """box""": {"""xmin""": 4, """ymin""": 0, """xmax""": 6_4_2, """ymax""": 4_7_6}},
              ],
              [
                  {"""score""": 0.2_868, """label""": """cat""", """box""": {"""xmin""": 3_2_4, """ymin""": 2_0, """xmax""": 6_4_0, """ymax""": 3_7_3}},
                  {"""score""": 0.277, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_2, """xmax""": 1_7_7, """ymax""": 1_1_5}},
                  {"""score""": 0.2_537, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 5_5, """xmax""": 3_1_5, """ymax""": 4_7_2}},
                  {"""score""": 0.1_474, """label""": """remote""", """box""": {"""xmin""": 3_3_5, """ymin""": 7_4, """xmax""": 3_7_1, """ymax""": 1_8_7}},
                  {"""score""": 0.1_208, """label""": """couch""", """box""": {"""xmin""": 4, """ymin""": 0, """xmax""": 6_4_2, """ymax""": 4_7_6}},
              ],
          ] ,  )

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







      """simple docstring"""







      pass

    @require_torch
    @slow
    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







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

      lowercase_								= object_detector(
          """http://images.cocodataset.org/val2017/000000039769.jpg""" ,  candidate_labels=["""cat""", """remote""", """couch"""] ,  threshold=lowerCAmelCase_ ,  )
      self.assertEqual(
          nested_simplify(lowerCAmelCase_ ,  decimals=4) ,  [
              {"""score""": 0.2_868, """label""": """cat""", """box""": {"""xmin""": 3_2_4, """ymin""": 2_0, """xmax""": 6_4_0, """ymax""": 3_7_3}},
              {"""score""": 0.277, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_2, """xmax""": 1_7_7, """ymax""": 1_1_5}},
              {"""score""": 0.2_537, """label""": """cat""", """box""": {"""xmin""": 1, """ymin""": 5_5, """xmax""": 3_1_5, """ymax""": 4_7_2}},
          ] ,  )




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







      """simple docstring"""







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

      lowercase_								= object_detector(
          """http://images.cocodataset.org/val2017/000000039769.jpg""" ,  candidate_labels=["""cat""", """remote""", """couch"""] ,  top_k=lowerCAmelCase_ ,  )
      self.assertEqual(
          nested_simplify(lowerCAmelCase_ ,  decimals=4) ,  [
              {"""score""": 0.2_868, """label""": """cat""", """box""": {"""xmin""": 3_2_4, """ymin""": 2_0, """xmax""": 6_4_0, """ymax""": 3_7_3}},
              {"""score""": 0.277, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_2, """xmax""": 1_7_7, """ymax""": 1_1_5}},
          ] ,  )

