






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

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


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






def 			__UpperCamelCase	(		snake_case__					):
	A_		:						str	    =   SwinConfig(
	    embed_dim=192   ,   depths=(2, 2, 18, 2)   ,   num_heads=(6, 12, 24, 48)   ,   window_size=12   ,   out_features=["""stage2""", """stage3""", """stage4"""]   ,   )

	A_		:						List[str]	    =   DetaConfig(
	    backbone_config=snake_case__   ,   num_queries=900   ,   encoder_ffn_dim=2_048   ,   decoder_ffn_dim=2_048   ,   num_feature_levels=5   ,   assign_first_stage=snake_case__   ,   with_box_refine=snake_case__   ,   two_stage=snake_case__   ,   )

	# set labels
	A_		:						str	    =   """huggingface/label-files"""
	if "o365" in model_name:
		A_		:						Optional[Any]	    =   366
		A_		:						Optional[int]	    =   """object365-id2label.json"""
	else:
		A_		:						List[Any]	    =   91
		A_		:						Optional[Any]	    =   """coco-detection-id2label.json"""

	A_		:						Union[str, Any]	    =   num_labels
	A_		:						List[Any]	    =   json.load(open(cached_download(hf_hub_url(snake_case__   ,   snake_case__   ,   repo_type="""dataset"""					)					)   ,   """r"""					)					)
	A_		:						Union[str, Any]	    =   {int(snake_case__					): v for k, v in idalabel.items()}
	A_		:						Tuple	    =   idalabel
	A_		:						Optional[int]	    =   {v: k for k, v in idalabel.items()}

	return config






def 			__UpperCamelCase	(		snake_case__					):
	A_		:						List[str]	    =   []

	# stem
	# fmt: off
	rename_keys.append(("""backbone.0.body.patch_embed.proj.weight""", """model.backbone.model.embeddings.patch_embeddings.projection.weight""")					)
	rename_keys.append(("""backbone.0.body.patch_embed.proj.bias""", """model.backbone.model.embeddings.patch_embeddings.projection.bias""")					)
	rename_keys.append(("""backbone.0.body.patch_embed.norm.weight""", """model.backbone.model.embeddings.norm.weight""")					)
	rename_keys.append(("""backbone.0.body.patch_embed.norm.bias""", """model.backbone.model.embeddings.norm.bias""")					)
	# stages
	for i in range(len(config.backbone_config.depths					)					):
		for j in range(config.backbone_config.depths[i]					):
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm1.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm1.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm2.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.norm2.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias""", F"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias""")					)

		if i < 3:
			rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.reduction.weight""", F"""model.backbone.model.encoder.layers.{i}.downsample.reduction.weight""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.norm.weight""", F"""model.backbone.model.encoder.layers.{i}.downsample.norm.weight""")					)
			rename_keys.append((F"""backbone.0.body.layers.{i}.downsample.norm.bias""", F"""model.backbone.model.encoder.layers.{i}.downsample.norm.bias""")					)

	rename_keys.append(("""backbone.0.body.norm1.weight""", """model.backbone.model.hidden_states_norms.stage2.weight""")					)
	rename_keys.append(("""backbone.0.body.norm1.bias""", """model.backbone.model.hidden_states_norms.stage2.bias""")					)
	rename_keys.append(("""backbone.0.body.norm2.weight""", """model.backbone.model.hidden_states_norms.stage3.weight""")					)
	rename_keys.append(("""backbone.0.body.norm2.bias""", """model.backbone.model.hidden_states_norms.stage3.bias""")					)
	rename_keys.append(("""backbone.0.body.norm3.weight""", """model.backbone.model.hidden_states_norms.stage4.weight""")					)
	rename_keys.append(("""backbone.0.body.norm3.bias""", """model.backbone.model.hidden_states_norms.stage4.bias""")					)

	# transformer encoder
	for i in range(config.encoder_layers					):
		rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight""", F"""model.encoder.layers.{i}.self_attn.sampling_offsets.weight""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias""", F"""model.encoder.layers.{i}.self_attn.sampling_offsets.bias""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.attention_weights.weight""", F"""model.encoder.layers.{i}.self_attn.attention_weights.weight""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.attention_weights.bias""", F"""model.encoder.layers.{i}.self_attn.attention_weights.bias""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.value_proj.weight""", F"""model.encoder.layers.{i}.self_attn.value_proj.weight""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.value_proj.bias""", F"""model.encoder.layers.{i}.self_attn.value_proj.bias""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.output_proj.weight""", F"""model.encoder.layers.{i}.self_attn.output_proj.weight""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.self_attn.output_proj.bias""", F"""model.encoder.layers.{i}.self_attn.output_proj.bias""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.weight""", F"""model.encoder.layers.{i}.self_attn_layer_norm.weight""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.bias""", F"""model.encoder.layers.{i}.self_attn_layer_norm.bias""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.weight""", F"""model.encoder.layers.{i}.fc1.weight""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.bias""", F"""model.encoder.layers.{i}.fc1.bias""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.weight""", F"""model.encoder.layers.{i}.fc2.weight""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.bias""", F"""model.encoder.layers.{i}.fc2.bias""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.weight""", F"""model.encoder.layers.{i}.final_layer_norm.weight""")					)
		rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.bias""", F"""model.encoder.layers.{i}.final_layer_norm.bias""")					)

	# transformer decoder
	for i in range(config.decoder_layers					):
		rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight""", F"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias""", F"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.attention_weights.weight""", F"""model.decoder.layers.{i}.encoder_attn.attention_weights.weight""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.attention_weights.bias""", F"""model.decoder.layers.{i}.encoder_attn.attention_weights.bias""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.value_proj.weight""", F"""model.decoder.layers.{i}.encoder_attn.value_proj.weight""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.value_proj.bias""", F"""model.decoder.layers.{i}.encoder_attn.value_proj.bias""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.output_proj.weight""", F"""model.decoder.layers.{i}.encoder_attn.output_proj.weight""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.cross_attn.output_proj.bias""", F"""model.decoder.layers.{i}.encoder_attn.output_proj.bias""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.weight""", F"""model.decoder.layers.{i}.encoder_attn_layer_norm.weight""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.bias""", F"""model.decoder.layers.{i}.encoder_attn_layer_norm.bias""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", F"""model.decoder.layers.{i}.self_attn.out_proj.weight""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", F"""model.decoder.layers.{i}.self_attn.out_proj.bias""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.norm2.weight""", F"""model.decoder.layers.{i}.self_attn_layer_norm.weight""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.norm2.bias""", F"""model.decoder.layers.{i}.self_attn_layer_norm.bias""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.weight""", F"""model.decoder.layers.{i}.fc1.weight""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.bias""", F"""model.decoder.layers.{i}.fc1.bias""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.weight""", F"""model.decoder.layers.{i}.fc2.weight""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.bias""", F"""model.decoder.layers.{i}.fc2.bias""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.weight""", F"""model.decoder.layers.{i}.final_layer_norm.weight""")					)
		rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.bias""", F"""model.decoder.layers.{i}.final_layer_norm.bias""")					)

	# fmt: on

	return rename_keys






def 			__UpperCamelCase	(		snake_case__   ,   snake_case__   ,   snake_case__					):
	A_		:						str	    =   dct.pop(snake_case__					)
	A_		:						str	    =   val






def 			__UpperCamelCase	(		snake_case__   ,   snake_case__					):
	A_		:						str	    =   [int(backbone_config.embed_dim * 2**i					) for i in range(len(backbone_config.depths					)					)]
	for i in range(len(backbone_config.depths					)					):
		A_		:						Optional[int]	    =   num_features[i]
		for j in range(backbone_config.depths[i]					):
			# fmt: off
			# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
			A_		:						Tuple	    =   state_dict.pop(F"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight"""					)
			A_		:						Tuple	    =   state_dict.pop(F"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias"""					)
			# next, add query, keys and values (in that order) to the state dict
			A_		:						Optional[Any]	    =   in_proj_weight[:dim, :]
			A_		:						Any	    =   in_proj_bias[: dim]
			A_		:						Optional[Any]	    =   in_proj_weight[
			    dim : dim * 2, :
			]
			A_		:						Union[str, Any]	    =   in_proj_bias[
			    dim : dim * 2
			]
			A_		:						Union[str, Any]	    =   in_proj_weight[
			    -dim :, :
			]
			A_		:						Optional[Any]	    =   in_proj_bias[-dim :]
			# fmt: on






def 			__UpperCamelCase	(		snake_case__   ,   snake_case__					):
	A_		:						int	    =   config.d_model
	for i in range(config.decoder_layers					):
		# read in weights + bias of input projection layer of self-attention
		A_		:						int	    =   state_dict.pop(F"""transformer.decoder.layers.{i}.self_attn.in_proj_weight"""					)
		A_		:						Dict	    =   state_dict.pop(F"""transformer.decoder.layers.{i}.self_attn.in_proj_bias"""					)
		# next, add query, keys and values (in that order) to the state dict
		A_		:						int	    =   in_proj_weight[:hidden_size, :]
		A_		:						List[Any]	    =   in_proj_bias[:hidden_size]
		A_		:						Union[str, Any]	    =   in_proj_weight[
		    hidden_size : hidden_size * 2, :
		]
		A_		:						Union[str, Any]	    =   in_proj_bias[hidden_size : hidden_size * 2]
		A_		:						Optional[Any]	    =   in_proj_weight[-hidden_size:, :]
		A_		:						List[str]	    =   in_proj_bias[-hidden_size:]






def 			__UpperCamelCase	(		):
	A_		:						List[str]	    =   """http://images.cocodataset.org/val2017/000000039769.jpg"""
	A_		:						Union[str, Any]	    =   Image.open(requests.get(snake_case__   ,   stream=snake_case__					).raw					)

	return im






@torch.no_grad()
def 			__UpperCamelCase	(		snake_case__   ,   snake_case__   ,   snake_case__					):
	A_		:						str	    =   get_deta_config(snake_case__					)

	# load original state dict
	if model_name == "deta-swin-large":
		A_		:						Any	    =   hf_hub_download(repo_id="""nielsr/deta-checkpoints"""   ,   filename="""adet_swin_ft.pth"""					)
	elif model_name == "deta-swin-large-o365":
		A_		:						Union[str, Any]	    =   hf_hub_download(repo_id="""jozhang97/deta-swin-l-o365"""   ,   filename="""deta_swin_pt_o365.pth"""					)
	else:
		raise ValueError(F"""Model name {model_name} not supported"""					)

	A_		:						Tuple	    =   torch.load(snake_case__   ,   map_location="""cpu"""					)["""model"""]

	# original state dict
	for name, param in state_dict.items():
		print(snake_case__   ,   param.shape					)

	# rename keys
	A_		:						Optional[Any]	    =   create_rename_keys(snake_case__					)
	for src, dest in rename_keys:
		rename_key(snake_case__   ,   snake_case__   ,   snake_case__					)
	read_in_swin_q_k_v(snake_case__   ,   config.backbone_config					)
	read_in_decoder_q_k_v(snake_case__   ,   snake_case__					)

	# fix some prefixes
	for key in state_dict.copy().keys():
		if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
			A_		:						Union[str, Any]	    =   state_dict.pop(snake_case__					)
			A_		:						Optional[int]	    =   val
		if "input_proj" in key:
			A_		:						Union[str, Any]	    =   state_dict.pop(snake_case__					)
			A_		:						str	    =   val
		if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
			A_		:						Tuple	    =   state_dict.pop(snake_case__					)
			A_		:						Union[str, Any]	    =   val

    # finally, create HuggingFace model and load state dict
	A_		:						Tuple	    =   DetaForObjectDetection(snake_case__					)
	model.load_state_dict(snake_case__					)
	model.eval()

	A_		:						Tuple	    =   """cuda""" if torch.cuda.is_available() else """cpu"""
	model.to(snake_case__					)

	# load image processor
	A_		:						Any	    =   DetaImageProcessor(format="""coco_detection"""					)

	# verify our conversion on image
	A_		:						Optional[Any]	    =   prepare_img()
	A_		:						Optional[Any]	    =   processor(images=snake_case__   ,   return_tensors="""pt"""					)
	A_		:						str	    =   encoding["""pixel_values"""]
	A_		:						int	    =   model(pixel_values.to(snake_case__					)					)

	# verify logits
	print("""Logits:"""   ,   outputs.logits[0, :3, :3]					)
	print("""Boxes:"""   ,   outputs.pred_boxes[0, :3, :3]					)
	if model_name == "deta-swin-large":
		A_		:						Any	    =   torch.tensor(
		    [[-7.6_308, -2.8_485, -5.3_737], [-7.2_037, -4.5_505, -4.8_027], [-7.2_943, -4.2_611, -4.6_617]]					)
		A_		:						Optional[Any]	    =   torch.tensor([[0.4_987, 0.4_969, 0.9_999], [0.2_549, 0.5_498, 0.4_805], [0.5_498, 0.2_757, 0.0_569]]					)
	elif model_name == "deta-swin-large-o365":
		A_		:						str	    =   torch.tensor(
		    [[-8.0_122, -3.5_720, -4.9_717], [-8.1_547, -3.6_886, -4.6_389], [-7.6_610, -3.6_194, -5.0_134]]					)
		A_		:						Optional[Any]	    =   torch.tensor([[0.2_523, 0.5_549, 0.4_881], [0.7_715, 0.4_149, 0.4_601], [0.5_503, 0.2_753, 0.0_575]]					)
	assert torch.allclose(outputs.logits[0, :3, :3]   ,   expected_logits.to(snake_case__					)   ,   atol=1E-4					)
	assert torch.allclose(outputs.pred_boxes[0, :3, :3]   ,   expected_boxes.to(snake_case__					)   ,   atol=1E-4					)
	print("""Everything ok!"""					)

	if pytorch_dump_folder_path:
		# Save model and processor
		logger.info(F"""Saving PyTorch model and processor to {pytorch_dump_folder_path}..."""					)
		Path(snake_case__					).mkdir(exist_ok=snake_case__					)
		model.save_pretrained(snake_case__					)
		processor.save_pretrained(snake_case__					)

	# Push to hub
	if push_to_hub:
		print("""Pushing model and processor to hub..."""					)
		model.push_to_hub(F"""jozhang97/{model_name}"""					)
		processor.push_to_hub(F"""jozhang97/{model_name}"""					)


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

							parser.add_argument(
							    "--model_name",
							    type=str,
							    default="deta-swin-large",
							    choices=["deta-swin-large", "deta-swin-large-o365"],
							    help="Name of the 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.",
							)
							parser.add_argument(
							    "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
							)
							_lowerCAmelCase         =							parser.parse_args()
							convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)









"""simple docstring"""
import unittest

from transformers import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING, is_vision_available
from transformers.pipelines import 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  :





								"""simple docstring"""




								@staticmethod
								def    lowerCamelCase(*lowerCAmelCase_     ,     **lowerCAmelCase_							):
									pass



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





	"""simple docstring"""




	_A       :				List[Any]    =				MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING





	def    lowerCamelCase(self     ,     lowerCAmelCase_     ,     lowerCAmelCase_     ,     lowerCAmelCase_							):
		A_		:						Union[str, Any]	    =   pipeline("""visual-question-answering"""     ,     model="""hf-internal-testing/tiny-vilt-random-vqa"""							)
		A_		:						Union[str, Any]	    =   [
		    {
		        """image""": Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							),
		        """question""": """How many cats are there?""",
		    },
		    {
		        """image""": """./tests/fixtures/tests_samples/COCO/000000039769.png""",
		        """question""": """How many cats are there?""",
		    },
		]
		return vqa_pipeline, examples





	def    lowerCamelCase(self     ,     lowerCAmelCase_     ,     lowerCAmelCase_							):
		A_		:						str	    =   vqa_pipeline(lowerCAmelCase_     ,     top_k=1							)
		self.assertEqual(
		    lowerCAmelCase_     ,     [
		        [{"""score""": ANY(lowerCAmelCase_							), """answer""": ANY(lowerCAmelCase_							)}],
		        [{"""score""": ANY(lowerCAmelCase_							), """answer""": ANY(lowerCAmelCase_							)}],
		    ]     ,     )





	@require_torch
	def    lowerCamelCase(self							):
		A_		:						Tuple	    =   pipeline("""visual-question-answering"""     ,     model="""hf-internal-testing/tiny-vilt-random-vqa"""							)
		A_		:						Any	    =   """./tests/fixtures/tests_samples/COCO/000000039769.png"""
		A_		:						Any	    =   """How many cats are there?"""

		A_		:						Optional[int]	    =   vqa_pipeline(image=lowerCAmelCase_     ,     question="""How many cats are there?"""     ,     top_k=2							)
		self.assertEqual(
		    lowerCAmelCase_     ,     [{"""score""": ANY(lowerCAmelCase_							), """answer""": ANY(lowerCAmelCase_							)}, {"""score""": ANY(lowerCAmelCase_							), """answer""": ANY(lowerCAmelCase_							)}]							)

		A_		:						Any	    =   vqa_pipeline({"""image""": image, """question""": question}     ,     top_k=2							)
		self.assertEqual(
		    lowerCAmelCase_     ,     [{"""score""": ANY(lowerCAmelCase_							), """answer""": ANY(lowerCAmelCase_							)}, {"""score""": ANY(lowerCAmelCase_							), """answer""": ANY(lowerCAmelCase_							)}]							)





	@slow
	@require_torch
	def    lowerCamelCase(self							):
		A_		:						int	    =   pipeline("""visual-question-answering"""     ,     model="""dandelin/vilt-b32-finetuned-vqa"""							)
		A_		:						Tuple	    =   """./tests/fixtures/tests_samples/COCO/000000039769.png"""
		A_		:						int	    =   """How many cats are there?"""

		A_		:						List[Any]	    =   vqa_pipeline(image=lowerCAmelCase_     ,     question=lowerCAmelCase_     ,     top_k=2							)
		self.assertEqual(
		    nested_simplify(lowerCAmelCase_     ,     decimals=4							)     ,     [{"""score""": 0.8799, """answer""": """2"""}, {"""score""": 0.296, """answer""": """1"""}]							)

		A_		:						Any	    =   vqa_pipeline({"""image""": image, """question""": question}     ,     top_k=2							)
		self.assertEqual(
		    nested_simplify(lowerCAmelCase_     ,     decimals=4							)     ,     [{"""score""": 0.8799, """answer""": """2"""}, {"""score""": 0.296, """answer""": """1"""}]							)

		A_		:						Tuple	    =   vqa_pipeline(
		    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}]     ,     top_k=2							)
		self.assertEqual(
		    nested_simplify(lowerCAmelCase_     ,     decimals=4							)     ,     [[{"""score""": 0.8799, """answer""": """2"""}, {"""score""": 0.296, """answer""": """1"""}]] * 2     ,     )





	@require_tf
	@unittest.skip("""Visual question answering not implemented in TF"""							)
	def    lowerCamelCase(self							):
		pass

