






"""simple docstring"""
import argparse
import json
from collections import OrderedDict
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    ConditionalDetrConfig,
    ConditionalDetrForObjectDetection,
    ConditionalDetrForSegmentation,
    ConditionalDetrImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase_							      = logging.get_logger(__name__)

# here we list all keys to be renamed (original name on the left, our name on the right)
lowerCamelCase_							      = []
for i in range(6):
			# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
			rename_keys.append(
			    (f'transformer.encoder.layers.{i}.self_attn.out_proj.weight', f'encoder.layers.{i}.self_attn.out_proj.weight')
			)
			rename_keys.append(
			    (f'transformer.encoder.layers.{i}.self_attn.out_proj.bias', f'encoder.layers.{i}.self_attn.out_proj.bias')
			)
			rename_keys.append((f'transformer.encoder.layers.{i}.linear1.weight', f'encoder.layers.{i}.fc1.weight'))
			rename_keys.append((f'transformer.encoder.layers.{i}.linear1.bias', f'encoder.layers.{i}.fc1.bias'))
			rename_keys.append((f'transformer.encoder.layers.{i}.linear2.weight', f'encoder.layers.{i}.fc2.weight'))
			rename_keys.append((f'transformer.encoder.layers.{i}.linear2.bias', f'encoder.layers.{i}.fc2.bias'))
			rename_keys.append(
			    (f'transformer.encoder.layers.{i}.norm1.weight', f'encoder.layers.{i}.self_attn_layer_norm.weight')
			)
			rename_keys.append((f'transformer.encoder.layers.{i}.norm1.bias', f'encoder.layers.{i}.self_attn_layer_norm.bias'))
			rename_keys.append((f'transformer.encoder.layers.{i}.norm2.weight', f'encoder.layers.{i}.final_layer_norm.weight'))
			rename_keys.append((f'transformer.encoder.layers.{i}.norm2.bias', f'encoder.layers.{i}.final_layer_norm.bias'))
			# decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.self_attn.out_proj.weight', f'decoder.layers.{i}.self_attn.out_proj.weight')
			)
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.self_attn.out_proj.bias', f'decoder.layers.{i}.self_attn.out_proj.bias')
			)
			rename_keys.append(
			    (
			        f'transformer.decoder.layers.{i}.cross_attn.out_proj.weight',
			        f'decoder.layers.{i}.encoder_attn.out_proj.weight',
			    )
			)
			rename_keys.append(
			    (
			        f'transformer.decoder.layers.{i}.cross_attn.out_proj.bias',
			        f'decoder.layers.{i}.encoder_attn.out_proj.bias',
			    )
			)
			rename_keys.append((f'transformer.decoder.layers.{i}.linear1.weight', f'decoder.layers.{i}.fc1.weight'))
			rename_keys.append((f'transformer.decoder.layers.{i}.linear1.bias', f'decoder.layers.{i}.fc1.bias'))
			rename_keys.append((f'transformer.decoder.layers.{i}.linear2.weight', f'decoder.layers.{i}.fc2.weight'))
			rename_keys.append((f'transformer.decoder.layers.{i}.linear2.bias', f'decoder.layers.{i}.fc2.bias'))
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.norm1.weight', f'decoder.layers.{i}.self_attn_layer_norm.weight')
			)
			rename_keys.append((f'transformer.decoder.layers.{i}.norm1.bias', f'decoder.layers.{i}.self_attn_layer_norm.bias'))
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.norm2.weight', f'decoder.layers.{i}.encoder_attn_layer_norm.weight')
			)
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.norm2.bias', f'decoder.layers.{i}.encoder_attn_layer_norm.bias')
			)
			rename_keys.append((f'transformer.decoder.layers.{i}.norm3.weight', f'decoder.layers.{i}.final_layer_norm.weight'))
			rename_keys.append((f'transformer.decoder.layers.{i}.norm3.bias', f'decoder.layers.{i}.final_layer_norm.bias'))

			# q, k, v projections in self/cross-attention in decoder for conditional DETR
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.sa_qcontent_proj.weight', f'decoder.layers.{i}.sa_qcontent_proj.weight')
			)
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.sa_kcontent_proj.weight', f'decoder.layers.{i}.sa_kcontent_proj.weight')
			)
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.sa_qpos_proj.weight', f'decoder.layers.{i}.sa_qpos_proj.weight')
			)
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.sa_kpos_proj.weight', f'decoder.layers.{i}.sa_kpos_proj.weight')
			)
			rename_keys.append((f'transformer.decoder.layers.{i}.sa_v_proj.weight', f'decoder.layers.{i}.sa_v_proj.weight'))
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.ca_qcontent_proj.weight', f'decoder.layers.{i}.ca_qcontent_proj.weight')
			)
			# rename_keys.append((f"transformer.decoder.layers.{i}.ca_qpos_proj.weight", f"decoder.layers.{i}.ca_qpos_proj.weight"))
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.ca_kcontent_proj.weight', f'decoder.layers.{i}.ca_kcontent_proj.weight')
			)
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.ca_kpos_proj.weight', f'decoder.layers.{i}.ca_kpos_proj.weight')
			)
			rename_keys.append((f'transformer.decoder.layers.{i}.ca_v_proj.weight', f'decoder.layers.{i}.ca_v_proj.weight'))
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.ca_qpos_sine_proj.weight', f'decoder.layers.{i}.ca_qpos_sine_proj.weight')
			)

			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.sa_qcontent_proj.bias', f'decoder.layers.{i}.sa_qcontent_proj.bias')
			)
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.sa_kcontent_proj.bias', f'decoder.layers.{i}.sa_kcontent_proj.bias')
			)
			rename_keys.append((f'transformer.decoder.layers.{i}.sa_qpos_proj.bias', f'decoder.layers.{i}.sa_qpos_proj.bias'))
			rename_keys.append((f'transformer.decoder.layers.{i}.sa_kpos_proj.bias', f'decoder.layers.{i}.sa_kpos_proj.bias'))
			rename_keys.append((f'transformer.decoder.layers.{i}.sa_v_proj.bias', f'decoder.layers.{i}.sa_v_proj.bias'))
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.ca_qcontent_proj.bias', f'decoder.layers.{i}.ca_qcontent_proj.bias')
			)
			# rename_keys.append((f"transformer.decoder.layers.{i}.ca_qpos_proj.bias", f"decoder.layers.{i}.ca_qpos_proj.bias"))
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.ca_kcontent_proj.bias', f'decoder.layers.{i}.ca_kcontent_proj.bias')
			)
			rename_keys.append((f'transformer.decoder.layers.{i}.ca_kpos_proj.bias', f'decoder.layers.{i}.ca_kpos_proj.bias'))
			rename_keys.append((f'transformer.decoder.layers.{i}.ca_v_proj.bias', f'decoder.layers.{i}.ca_v_proj.bias'))
			rename_keys.append(
			    (f'transformer.decoder.layers.{i}.ca_qpos_sine_proj.bias', f'decoder.layers.{i}.ca_qpos_sine_proj.bias')
			)

# convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
# for conditional DETR, also convert reference point head and query scale MLP
rename_keys.extend(
    [
        ('''input_proj.weight''', '''input_projection.weight'''),
        ('''input_proj.bias''', '''input_projection.bias'''),
        ('''query_embed.weight''', '''query_position_embeddings.weight'''),
        ('''transformer.decoder.norm.weight''', '''decoder.layernorm.weight'''),
        ('''transformer.decoder.norm.bias''', '''decoder.layernorm.bias'''),
        ('''class_embed.weight''', '''class_labels_classifier.weight'''),
        ('''class_embed.bias''', '''class_labels_classifier.bias'''),
        ('''bbox_embed.layers.0.weight''', '''bbox_predictor.layers.0.weight'''),
        ('''bbox_embed.layers.0.bias''', '''bbox_predictor.layers.0.bias'''),
        ('''bbox_embed.layers.1.weight''', '''bbox_predictor.layers.1.weight'''),
        ('''bbox_embed.layers.1.bias''', '''bbox_predictor.layers.1.bias'''),
        ('''bbox_embed.layers.2.weight''', '''bbox_predictor.layers.2.weight'''),
        ('''bbox_embed.layers.2.bias''', '''bbox_predictor.layers.2.bias'''),
        ('''transformer.decoder.ref_point_head.layers.0.weight''', '''decoder.ref_point_head.layers.0.weight'''),
        ('''transformer.decoder.ref_point_head.layers.0.bias''', '''decoder.ref_point_head.layers.0.bias'''),
        ('''transformer.decoder.ref_point_head.layers.1.weight''', '''decoder.ref_point_head.layers.1.weight'''),
        ('''transformer.decoder.ref_point_head.layers.1.bias''', '''decoder.ref_point_head.layers.1.bias'''),
        ('''transformer.decoder.query_scale.layers.0.weight''', '''decoder.query_scale.layers.0.weight'''),
        ('''transformer.decoder.query_scale.layers.0.bias''', '''decoder.query_scale.layers.0.bias'''),
        ('''transformer.decoder.query_scale.layers.1.weight''', '''decoder.query_scale.layers.1.weight'''),
        ('''transformer.decoder.query_scale.layers.1.bias''', '''decoder.query_scale.layers.1.bias'''),
        ('''transformer.decoder.layers.0.ca_qpos_proj.weight''', '''decoder.layers.0.ca_qpos_proj.weight'''),
        ('''transformer.decoder.layers.0.ca_qpos_proj.bias''', '''decoder.layers.0.ca_qpos_proj.bias'''),
    ]
)

def 							snake_case (  A__      ,A__      ,A__		):
			UpperCAmelCase_	:					List[str]     	=   state_dict.pop(A__		)
			UpperCAmelCase_	:					Dict     	=   val

def 							snake_case (  A__		):
			UpperCAmelCase_	:					int     	=   OrderedDict()
			for key, value in state_dict.items():
						if "backbone.0.body" in key:
									UpperCAmelCase_	:					Optional[int]     	=   key.replace("backbone.0.body"      ,"backbone.conv_encoder.model"		)
									UpperCAmelCase_	:					List[Any]     	=   value
						else:
									UpperCAmelCase_	:					List[str]     	=   value

			return new_state_dict

def 							snake_case (  A__      ,A__=False		):
			UpperCAmelCase_	:					Tuple     	=   ""
			if is_panoptic:
						UpperCAmelCase_	:					Tuple     	=   "conditional_detr."

			# first: transformer encoder
			for i in range(6		):
						# read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
						UpperCAmelCase_	:					Optional[Any]     	=   state_dict.pop(F"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight"""		)
						UpperCAmelCase_	:					Optional[int]     	=   state_dict.pop(F"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias"""		)
						# next, add query, keys and values (in that order) to the state dict
						UpperCAmelCase_	:					Dict     	=   in_proj_weight[:2_56, :]
						UpperCAmelCase_	:					Tuple     	=   in_proj_bias[:2_56]
						UpperCAmelCase_	:					Any     	=   in_proj_weight[2_56:5_12, :]
						UpperCAmelCase_	:					Dict     	=   in_proj_bias[2_56:5_12]
						UpperCAmelCase_	:					List[str]     	=   in_proj_weight[-2_56:, :]
						UpperCAmelCase_	:					Any     	=   in_proj_bias[-2_56:]

def 							snake_case (  ):
			UpperCAmelCase_	:					Optional[int]     	=   "http://images.cocodataset.org/val2017/000000039769.jpg"
			UpperCAmelCase_	:					int     	=   Image.open(requests.get(A__      ,stream=A__		).raw		)

			return im

@torch.no_grad()
def 							snake_case (  A__      ,A__		):
			UpperCAmelCase_	:					str     	=   ConditionalDetrConfig()
			# set backbone and dilation attributes
			if "resnet101" in model_name:
						UpperCAmelCase_	:					List[Any]     	=   "resnet101"
			if "dc5" in model_name:
						UpperCAmelCase_	:					int     	=   True
			UpperCAmelCase_	:					str     	=   "panoptic" in model_name
			if is_panoptic:
						UpperCAmelCase_	:					Union[str, Any]     	=   2_50
			else:
						UpperCAmelCase_	:					List[str]     	=   91
						UpperCAmelCase_	:					Tuple     	=   "huggingface/label-files"
						UpperCAmelCase_	:					Optional[int]     	=   "coco-detection-id2label.json"
						UpperCAmelCase_	:					Any     	=   json.load(open(hf_hub_download(A__      ,A__      ,repo_type="dataset"		)      ,"r"		)		)
						UpperCAmelCase_	:					List[Any]     	=   {int(A__		): v for k, v in idalabel.items()}
						UpperCAmelCase_	:					Optional[int]     	=   idalabel
						UpperCAmelCase_	:					Dict     	=   {v: k for k, v in idalabel.items()}

			# load image processor
			UpperCAmelCase_	:					List[str]     	=   "coco_panoptic" if is_panoptic else "coco_detection"
			UpperCAmelCase_	:					List[str]     	=   ConditionalDetrImageProcessor(format=A__		)

			# prepare image
			UpperCAmelCase_	:					List[str]     	=   prepare_img()
			UpperCAmelCase_	:					str     	=   image_processor(images=A__      ,return_tensors="pt"		)
			UpperCAmelCase_	:					List[str]     	=   encoding["pixel_values"]

			logger.info(F"""Converting model {model_name}..."""		)

			# load original model from torch hub
			UpperCAmelCase_	:					Any     	=   torch.hub.load("DeppMeng/ConditionalDETR"      ,A__      ,pretrained=A__		).eval()
			UpperCAmelCase_	:					Union[str, Any]     	=   conditional_detr.state_dict()
			# rename keys
			for src, dest in rename_keys:
						if is_panoptic:
									UpperCAmelCase_	:					str     	=   "conditional_detr." + src
						rename_key(A__      ,A__      ,A__		)
			UpperCAmelCase_	:					Any     	=   rename_backbone_keys(A__		)
			# query, key and value matrices need special treatment
			read_in_q_k_v(A__      ,is_panoptic=A__		)
			# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
			UpperCAmelCase_	:					Dict     	=   "conditional_detr.model." if is_panoptic else "model."
			for key in state_dict.copy().keys():
						if is_panoptic:
									if (
									    key.startswith("conditional_detr"		)
									    and not key.startswith("class_labels_classifier"		)
									    and not key.startswith("bbox_predictor"		)
									):
												UpperCAmelCase_	:					Optional[Any]     	=   state_dict.pop(A__		)
												UpperCAmelCase_	:					str     	=   val
									elif "class_labels_classifier" in key or "bbox_predictor" in key:
												UpperCAmelCase_	:					Optional[Any]     	=   state_dict.pop(A__		)
												UpperCAmelCase_	:					Dict     	=   val
									elif key.startswith("bbox_attention"		) or key.startswith("mask_head"		):
												continue
									else:
												UpperCAmelCase_	:					Union[str, Any]     	=   state_dict.pop(A__		)
												UpperCAmelCase_	:					Optional[int]     	=   val
						else:
									if not key.startswith("class_labels_classifier"		) and not key.startswith("bbox_predictor"		):
												UpperCAmelCase_	:					Tuple     	=   state_dict.pop(A__		)
												UpperCAmelCase_	:					Union[str, Any]     	=   val
    # finally, create HuggingFace model and load state dict
			UpperCAmelCase_	:					Optional[int]     	=   ConditionalDetrForSegmentation(A__		) if is_panoptic else ConditionalDetrForObjectDetection(A__		)
			model.load_state_dict(A__		)
			model.eval()
			model.push_to_hub(repo_id=A__      ,organization="DepuMeng"      ,commit_message="Add model"		)
			# verify our conversion
			UpperCAmelCase_	:					Union[str, Any]     	=   conditional_detr(A__		)
			UpperCAmelCase_	:					str     	=   model(A__		)
			assert torch.allclose(outputs.logits      ,original_outputs["pred_logits"]      ,atol=1e-4		)
			assert torch.allclose(outputs.pred_boxes      ,original_outputs["pred_boxes"]      ,atol=1e-4		)
			if is_panoptic:
						assert torch.allclose(outputs.pred_masks      ,original_outputs["pred_masks"]      ,atol=1e-4		)

			# Save model and image processor
			logger.info(F"""Saving PyTorch model and image processor to {pytorch_dump_folder_path}..."""		)
			Path(A__		).mkdir(exist_ok=A__		)
			model.save_pretrained(A__		)
			image_processor.save_pretrained(A__		)


if __name__ == "__main__":
			lowerCamelCase_							      = argparse.ArgumentParser()

			parser.add_argument(
			    '''--model_name''',
			    default='''conditional_detr_resnet50''',
			    type=str,
			    help='''Name of the CONDITIONAL_DETR model you\'d like to convert.''',
			)
			parser.add_argument(
			    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the folder to output PyTorch model.'''
			)
			lowerCamelCase_							      = parser.parse_args()
			convert_conditional_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path)







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





											"""simple docstring"""







											@staticmethod
											def 					UpperCamelCase__     (      *lowerCAmelCase__			,						**lowerCAmelCase__       ):





														"""simple docstring"""




														pass







@is_pipeline_test
@require_vision
@require_torch
class 	__lowercase    (unittest.TestCase  ):





							"""simple docstring"""







							_UpperCAmelCase      =						MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__       ):





										"""simple docstring"""




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

										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					[
										    {
										        'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
										        'candidate_labels': ['cat', 'remote', 'couch'],
										    }
										]
										return object_detector, examples






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__			,						lowerCAmelCase__       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					object_detector(examples[0]			,						threshold=0.0       )

										SCREAMING_SNAKE_CASE_		:     int					=					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       ):





										"""simple docstring"""




										pass






							@require_torch
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




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

										SCREAMING_SNAKE_CASE_		:     str					=					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}},
										    ]			,						)

										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					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       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[str]					=					pipeline('zero-shot-object-detection'       )

										SCREAMING_SNAKE_CASE_		:     List[str]					=					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}},
										    ]			,						)

										SCREAMING_SNAKE_CASE_		:     List[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(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       ):





										"""simple docstring"""




										pass






							@require_torch
							@slow
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     str					=					0.2
										SCREAMING_SNAKE_CASE_		:     str					=					pipeline('zero-shot-object-detection'       )

										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					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       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Dict					=					2
										SCREAMING_SNAKE_CASE_		:     int					=					pipeline('zero-shot-object-detection'       )

										SCREAMING_SNAKE_CASE_		:     Tuple					=					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}},
										    ]			,						)





