
'''simple docstring'''







import argparse

import fairseq
import torch
from torch import nn

from transformers import (
    MBartaaTokenizer,
    MBartConfig,
    MBartForCausalLM,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
lowercase					:							Any   =      logging.get_logger(__name__)

lowercase					:							Union[str, Any]   =      {
    "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",
    "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",
}
lowercase					:							Tuple   =      [
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
]







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A    ,       __A    ,       __A    ,       __A			) ->			List[str]:
	for attribute in key.split('.'			):
		_snake_case     		=	getattr(__A    ,       __A			)

	if weight_type is not None:
		_snake_case     		=	getattr(__A    ,       __A			).shape
	else:
		_snake_case     		=	hf_pointer.shape

	assert hf_shape == value.shape, (
	    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":
		_snake_case     		=	value
	elif weight_type == "weight_g":
		_snake_case     		=	value
	elif weight_type == "weight_v":
		_snake_case     		=	value
	elif weight_type == "bias":
		_snake_case     		=	value
	else:
		_snake_case     		=	value

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







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A			) ->			Dict:
	_snake_case     		=	[]
	_snake_case     		=	fairseq_model.state_dict()

	_snake_case     		=	hf_model.feature_extractor
	_snake_case     		=	hf_model.adapter

	for name, value in fairseq_dict.items():
		_snake_case     		=	False
		if "conv_layers" in name:
			load_conv_layer(
			    __A    ,       __A    ,       __A    ,       __A    ,       hf_model.config.feat_extract_norm == 'group'    ,       )
			_snake_case     		=	True
		elif any(x in name for x in ['adaptor', 'w2v_encoder.proj.', 'w2v_proj_ln.']			):
			load_adapter(__A    ,       __A    ,       __A    ,       __A			)
			_snake_case     		=	True
		else:
			for key, mapped_key in MAPPING.items():
				if key in name or key.split('w2v_model.'			)[-1] == name.split('.'			)[0]:
					_snake_case     		=	True
					if "*" in mapped_key:
						_snake_case     		=	name.split(__A			)[0].split('.'			)[-2]
						_snake_case     		=	mapped_key.replace('*'    ,       __A			)
					if "weight_g" in name:
						_snake_case     		=	'weight_g'
					elif "weight_v" in name:
						_snake_case     		=	'weight_v'
					elif "bias" in name:
						_snake_case     		=	'bias'
					elif "weight" in name:
						_snake_case     		=	'weight'
					else:
						_snake_case     		=	None
					set_recursively(__A    ,       __A    ,       __A    ,       __A    ,       __A			)
				continue
		if not is_used:
			unused_weights.append(__A			)

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







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A    ,       __A    ,       __A    ,       __A			) ->			Dict:
	_snake_case     		=	full_name.split('conv_layers.'			)[-1]
	_snake_case     		=	name.split('.'			)
	_snake_case     		=	int(items[0]			)
	_snake_case     		=	int(items[1]			)

	if type_id == 0:
		if "bias" in name:
			assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
			    F'{full_name} has size {value.shape}, but'
			    F' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'
			)
			_snake_case     		=	value
			logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'			)
		elif "weight" in name:
			assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
			    F'{full_name} has size {value.shape}, but'
			    F' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'
			)
			_snake_case     		=	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:
			assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
			    F'{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was'
			    " found."
			)
			_snake_case     		=	value
			logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'			)
		elif "weight" in name:
			assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
			    F'{full_name} has size {value.shape}, but'
			    F' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.'
			)
			_snake_case     		=	value
			logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'			)
	else:
		unused_weights.append(__A			)







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A    ,       __A    ,       __A			) ->			Optional[Any]:
	_snake_case     		=	full_name.split('adaptor.'			)[-1]
	_snake_case     		=	name.split('.'			)

	if items[1].isdigit():
		_snake_case     		=	int(items[1]			)
	else:
		_snake_case     		=	None

	if "adaptor" not in full_name:
		if "proj_ln" in full_name:
			# has to be layer norm
			if "bias" in name:
				assert (
				    value.shape == adapter.proj_layer_norm.bias.data.shape
				), F'{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found.'
				_snake_case     		=	value
				logger.info(F'Adapter proj layer norm bias was initialized from {full_name}.'			)
			if "weight" in name:
				assert (
				    value.shape == adapter.proj_layer_norm.weight.data.shape
				), F'{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found.'
				_snake_case     		=	value
		else:
			# has to be projection layer
			if "bias" in name:
				assert (
				    value.shape == adapter.proj.bias.data.shape
				), F'{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found.'
				_snake_case     		=	value
				logger.info(F'Adapter proj layer bias was initialized from {full_name}.'			)
			if "weight" in name:
				assert (
				    value.shape == adapter.proj.weight.data.shape
				), F'{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found.'
				_snake_case     		=	value
				logger.info(F'Adapter proj layer weight was initialized from {full_name}.'			)
	elif isinstance(__A    ,       __A			):
		if "bias" in name:
			assert (
			    value.shape == adapter.layers[layer_id].conv.bias.data.shape
			), F'{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found.'
			_snake_case     		=	value
			logger.info(F'Adapter layer {layer_id} bias was initialized from {full_name}.'			)
		elif "weight" in name:
			assert (
			    value.shape == adapter.layers[layer_id].conv.weight.data.shape
			), F'{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found.'
			_snake_case     		=	value
			logger.info(F'Adapter layer {layer_id} bias was initialized from {full_name}.'			)
	else:
		unused_weights.append(__A			)







def        SCREAMING_SNAKE_CASE__			(     __A			) ->			int:
	_snake_case		,				_snake_case     		=	emb.weight.shape
	_snake_case     		=	nn.Linear(__A    ,       __A    ,       bias=__A			)
	_snake_case     		=	emb.weight.data
	return lin_layer







@torch.no_grad()
def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A    ,       __A    ,       __A    ,       __A    ,       __A    ,       __A    ,       __A    ,       __A    ,       __A    ,       __A    ,       ) ->			Any:
	_snake_case     		=	WavaVecaConfig.from_pretrained(
	    __A    ,       add_adapter=__A    ,       adapter_stride=__A    ,       adapter_kernel_size=__A    ,       use_auth_token=__A    ,       output_hidden_size=__A    ,       )
	_snake_case     		=	MBartConfig.from_pretrained(__A			)

	# load model
	_snake_case		,				_snake_case		,				_snake_case     		=	fairseq.checkpoint_utils.load_model_ensemble_and_task(
	    [checkpoint_path]    ,       arg_overrides={
	        'config_yaml': config_yaml_path,
	        'data': '/'.join(dict_path.split('/'			)[:-1]			),
	        'w2v_path': checkpoint_path,
	        'load_pretrained_decoder_from': None,
	    }    ,       )
	_snake_case     		=	model[0].eval()

	# load feature extractor
	_snake_case     		=	WavaVecaFeatureExtractor.from_pretrained(__A    ,       use_auth_token=__A			)

	# set weights for wav2vec2 encoder
	_snake_case     		=	WavaVecaModel(__A			)

	recursively_load_weights_wavaveca(model.encoder    ,       __A			)

	# load decoder weights
	_snake_case     		=	MBartForCausalLM(__A			)
	_snake_case		,				_snake_case     		=	hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()    ,       strict=__A			)
	logger.warning(F'The following keys are missing when loading the decoder weights: {missing_keys}'			)
	logger.warning(F'The following keys are unexpected when loading the decoder weights: {unexpected_keys}'			)

	_snake_case     		=	SpeechEncoderDecoderModel(encoder=__A    ,       decoder=__A			)
	_snake_case     		=	False

	_snake_case     		=	MBartaaTokenizer(__A			)
	tokenizer.save_pretrained(__A			)

	_snake_case     		=	hf_wavavec.config.to_dict()
	_snake_case     		=	tokenizer.pad_token_id
	_snake_case     		=	tokenizer.bos_token_id
	_snake_case     		=	tokenizer.eos_token_id
	_snake_case     		=	'mbart50'
	_snake_case     		=	'wav2vec2'

	_snake_case     		=	tokenizer.eos_token_id
	_snake_case     		=	250_004
	_snake_case     		=	tokenizer.eos_token_id

	_snake_case     		=	SpeechEncoderDecoderConfig.from_dict(__A			)

	hf_wavavec.save_pretrained(__A			)
	feature_extractor.save_pretrained(__A			)


if __name__ == "__main__":
					lowercase					:							Optional[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_yaml_path", default=None, type=str, help="Path to yaml file of fine-tuned model")
					parser.add_argument(
					    "--encoder_config_path",
					    default="facebook/wav2vec2-xls-r-1b",
					    type=str,
					    help="Path to hf encoder wav2vec2 checkpoint config",
					)
					parser.add_argument(
					    "--decoder_config_path",
					    default="facebook/mbart-large-50-one-to-many-mmt",
					    type=str,
					    help="Path to hf decoder checkpoint config",
					)
					parser.add_argument("--add_adapter", default=True, type=bool, help="whethere to add model adapter layers")
					parser.add_argument("--adapter_stride", default=2, type=int, help="stride of adapter layers")
					parser.add_argument("--adapter_kernel_size", default=3, type=int, help="kernel size of adapter layers")
					parser.add_argument("--encoder_output_dim", default=1024, type=int, help="encoder output dim")
					parser.add_argument("--start_token_id", default=25_0004, type=int, help="`decoder_start_token_id` of model config")

					lowercase					:							List[str]   =      parser.parse_args()
					convert_wavaveca_checkpoint(
					    args.checkpoint_path,
					    args.pytorch_dump_folder_path,
					    args.dict_path,
					    args.config_yaml_path,
					    encoder_config_path=args.encoder_config_path,
					    decoder_config_path=args.decoder_config_path,
					    add_adapter=args.add_adapter,
					    adapter_kernel_size=args.adapter_kernel_size,
					    adapter_stride=args.adapter_stride,
					    decoder_start_token_id=args.start_token_id,
					    encoder_output_dim=args.encoder_output_dim,
					)



'''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 				lowerCamelCase       ( *lowerCAmelCase_					,     **lowerCAmelCase_						):





													"""simple docstring"""






													pass


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


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






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

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


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






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

								_snake_case     		=	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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass


							@require_torch
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






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

								_snake_case     		=	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.7235, 'label': 'cat', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								        {'score': 0.7218, 'label': 'remote', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								        {'score': 0.7184, 'label': 'couch', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								        {'score': 0.6748, 'label': 'remote', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								        {'score': 0.6656, 'label': 'cat', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								        {'score': 0.6614, 'label': 'couch', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								        {'score': 0.6456, 'label': 'remote', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								        {'score': 0.642, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 2_74, 'xmax': 93, 'ymax': 2_97}},
								        {'score': 0.6419, 'label': 'cat', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								    ]					,     )

								_snake_case     		=	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.7235, 'label': 'cat', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								            {'score': 0.7218, 'label': 'remote', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								            {'score': 0.7184, 'label': 'couch', 'box': {'xmin': 2_04, 'ymin': 1_67, 'xmax': 2_32, 'ymax': 1_90}},
								            {'score': 0.6748, 'label': 'remote', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								            {'score': 0.6656, 'label': 'cat', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								            {'score': 0.6614, 'label': 'couch', 'box': {'xmin': 5_71, 'ymin': 83, 'xmax': 5_98, 'ymax': 1_03}},
								            {'score': 0.6456, 'label': 'remote', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								            {'score': 0.642, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 2_74, 'xmax': 93, 'ymax': 2_97}},
								            {'score': 0.6419, 'label': 'cat', 'box': {'xmin': 4_94, 'ymin': 1_05, 'xmax': 5_21, 'ymax': 1_27}},
								        ]
								    ]					,     )


							@require_torch
							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	pipeline('zero-shot-object-detection'						)

								_snake_case     		=	object_detector(
								    'http://images.cocodataset.org/val2017/000000039769.jpg'					,     candidate_labels=['cat', 'remote', 'couch']					,     )
								self.assertEqual(
								    nested_simplify(lowerCAmelCase_					,     decimals=4						)					,     [
								        {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								        {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								        {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 3_35, 'ymin': 74, 'xmax': 3_71, 'ymax': 1_87}},
								        {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_42, 'ymax': 4_76}},
								    ]					,     )

								_snake_case     		=	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.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								            {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								            {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								            {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 3_35, 'ymin': 74, 'xmax': 3_71, 'ymax': 1_87}},
								            {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_42, 'ymax': 4_76}},
								        ],
								        [
								            {'score': 0.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								            {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								            {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								            {'score': 0.1474, 'label': 'remote', 'box': {'xmin': 3_35, 'ymin': 74, 'xmax': 3_71, 'ymax': 1_87}},
								            {'score': 0.1208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_42, 'ymax': 4_76}},
								        ],
								    ]					,     )


							@require_tf
							@unittest.skip('Zero Shot Object Detection not implemented in TF'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass


							@require_torch
							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	0.2
								_snake_case     		=	pipeline('zero-shot-object-detection'						)

								_snake_case     		=	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.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								        {'score': 0.2537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 3_15, 'ymax': 4_72}},
								    ]					,     )




							@require_torch
							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	2
								_snake_case     		=	pipeline('zero-shot-object-detection'						)

								_snake_case     		=	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.2868, 'label': 'cat', 'box': {'xmin': 3_24, 'ymin': 20, 'xmax': 6_40, 'ymax': 3_73}},
								        {'score': 0.277, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 1_77, 'ymax': 1_15}},
								    ]					,     )

