

"""simple docstring"""





import argparse
import gc
import json
import os
import shutil
import warnings

import torch

from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer


try:
							from transformers import LlamaTokenizerFast
except ImportError as e:
							warnings.warn(e)
							warnings.warn(
							    '''The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion'''
							)
							__UpperCamelCase    : List[Any]				 =						None
__UpperCamelCase    : Union[str, Any]				 =						{
    '''7B''': 1_1_0_0_8,
    '''13B''': 1_3_8_2_4,
    '''30B''': 1_7_9_2_0,
    '''65B''': 2_2_0_1_6,
    '''70B''': 2_8_6_7_2,
}
__UpperCamelCase    : Dict				 =						{
    '''7B''': 1,
    '''7Bf''': 1,
    '''13B''': 2,
    '''13Bf''': 2,
    '''30B''': 4,
    '''65B''': 8,
    '''70B''': 8,
    '''70Bf''': 8,
}

def     __SCREAMING_SNAKE_CASE    ( A_		,	A_=1		,	A_=2_56					):
	return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3					)					) + multiple_of - 1) // multiple_of)

def     __SCREAMING_SNAKE_CASE    ( A_					):
	with open(A_		,	'''r'''					) as f:
		return json.load(A_					)

def     __SCREAMING_SNAKE_CASE    ( A_		,	A_					):
	with open(A_		,	'''w'''					) as f:
		json.dump(A_		,	A_					)

def     __SCREAMING_SNAKE_CASE    ( A_		,	A_		,	A_		,	A_=True					):
	os.makedirs(A_		,	exist_ok=A_					)
	lowerCAmelCase__      :		Tuple    							=      os.path.join(A_		,	'''tmp'''					)
	os.makedirs(A_		,	exist_ok=A_					)

	lowerCAmelCase__      :		Dict    							=      read_json(os.path.join(A_		,	'''params.json'''					)					)
	lowerCAmelCase__      :		List[str]    							=      NUM_SHARDS[model_size]
	lowerCAmelCase__      :		Dict    							=      params['''n_layers''']
	lowerCAmelCase__      :		int    							=      params['''n_heads''']
	lowerCAmelCase__      :		List[Any]    							=      n_heads // num_shards
	lowerCAmelCase__      :		int    							=      params['''dim''']
	lowerCAmelCase__      :		str    							=      dim // n_heads
	lowerCAmelCase__      :		int    							=      10_000.0
	lowerCAmelCase__      :		int    							=      1.0 / (base ** (torch.arange(0		,	A_		,	2					).float() / dims_per_head))

	if "n_kv_heads" in params:
		lowerCAmelCase__      :		Tuple    							=      params['''n_kv_heads''']  # for GQA / MQA
		lowerCAmelCase__      :		Union[str, Any]    							=      n_heads_per_shard // num_key_value_heads
		lowerCAmelCase__      :		str    							=      dim // num_key_value_heads
	else:  # compatibility with other checkpoints
		lowerCAmelCase__      :		Tuple    							=      n_heads
		lowerCAmelCase__      :		Union[str, Any]    							=      n_heads_per_shard
		lowerCAmelCase__      :		Dict    							=      dim

	# permute for sliced rotary
	def permute(A_		,	A_=n_heads		,	A_=dim		,	A_=dim					):
		return w.view(A_		,	dima // n_heads // 2		,	2		,	A_					).transpose(1		,	2					).reshape(A_		,	A_					)

	print(f'Fetching all parameters from the checkpoint at {input_base_path}.'					)
	# Load weights
	if model_size == "7B":
		# Not sharded
		# (The sharded implementation would also work, but this is simpler.)
		lowerCAmelCase__      :		str    							=      torch.load(os.path.join(A_		,	'''consolidated.00.pth'''					)		,	map_location='''cpu'''					)
	else:
		# Sharded
		lowerCAmelCase__      :		List[str]    							=      [
		    torch.load(os.path.join(A_		,	f'consolidated.{i:02d}.pth'					)		,	map_location='''cpu'''					)
		    for i in range(A_					)
		]
	lowerCAmelCase__      :		List[Any]    							=      0
	lowerCAmelCase__      :		str    							=      {'''weight_map''': {}}
	for layer_i in range(A_					):
		lowerCAmelCase__      :		Tuple    							=      f'pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin'
		if model_size == "7B":
			# Unsharded
			lowerCAmelCase__      :		List[str]    							=      {
			    f'model.layers.{layer_i}.self_attn.q_proj.weight': permute(
			        loaded[f'layers.{layer_i}.attention.wq.weight']					),
			    f'model.layers.{layer_i}.self_attn.k_proj.weight': permute(
			        loaded[f'layers.{layer_i}.attention.wk.weight']					),
			    f'model.layers.{layer_i}.self_attn.v_proj.weight': loaded[f'layers.{layer_i}.attention.wv.weight'],
			    f'model.layers.{layer_i}.self_attn.o_proj.weight': loaded[f'layers.{layer_i}.attention.wo.weight'],
			    f'model.layers.{layer_i}.mlp.gate_proj.weight': loaded[f'layers.{layer_i}.feed_forward.w1.weight'],
			    f'model.layers.{layer_i}.mlp.down_proj.weight': loaded[f'layers.{layer_i}.feed_forward.w2.weight'],
			    f'model.layers.{layer_i}.mlp.up_proj.weight': loaded[f'layers.{layer_i}.feed_forward.w3.weight'],
			    f'model.layers.{layer_i}.input_layernorm.weight': loaded[f'layers.{layer_i}.attention_norm.weight'],
			    f'model.layers.{layer_i}.post_attention_layernorm.weight': loaded[f'layers.{layer_i}.ffn_norm.weight'],
			}
		else:
			# Sharded
			# Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
			# the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
			# redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.

			lowerCAmelCase__      :		List[str]    							=      {
			    f'model.layers.{layer_i}.input_layernorm.weight': loaded[0][
			        f'layers.{layer_i}.attention_norm.weight'
			    ].clone(),
			    f'model.layers.{layer_i}.post_attention_layernorm.weight': loaded[0][
			        f'layers.{layer_i}.ffn_norm.weight'
			    ].clone(),
			}
			lowerCAmelCase__      :		Union[str, Any]    							=      permute(
			    torch.cat(
			        [
			            loaded[i][f'layers.{layer_i}.attention.wq.weight'].view(A_		,	A_		,	A_					)
			            for i in range(A_					)
			        ]		,	dim=0		,	).reshape(A_		,	A_					)					)
			lowerCAmelCase__      :		List[str]    							=      permute(
			    torch.cat(
			        [
			            loaded[i][f'layers.{layer_i}.attention.wk.weight'].view(
			                A_		,	A_		,	A_					)
			            for i in range(A_					)
			        ]		,	dim=0		,	).reshape(A_		,	A_					)		,	A_		,	A_		,	A_		,	)
			lowerCAmelCase__      :		Optional[int]    							=      torch.cat(
			    [
			        loaded[i][f'layers.{layer_i}.attention.wv.weight'].view(
			            A_		,	A_		,	A_					)
			        for i in range(A_					)
			    ]		,	dim=0		,	).reshape(A_		,	A_					)

			lowerCAmelCase__      :		Tuple    							=      torch.cat(
			    [loaded[i][f'layers.{layer_i}.attention.wo.weight'] for i in range(A_					)]		,	dim=1					)
			lowerCAmelCase__      :		Optional[Any]    							=      torch.cat(
			    [loaded[i][f'layers.{layer_i}.feed_forward.w1.weight'] for i in range(A_					)]		,	dim=0					)
			lowerCAmelCase__      :		List[str]    							=      torch.cat(
			    [loaded[i][f'layers.{layer_i}.feed_forward.w2.weight'] for i in range(A_					)]		,	dim=1					)
			lowerCAmelCase__      :		Optional[int]    							=      torch.cat(
			    [loaded[i][f'layers.{layer_i}.feed_forward.w3.weight'] for i in range(A_					)]		,	dim=0					)

		lowerCAmelCase__      :		Dict    							=      inv_freq
		for k, v in state_dict.items():
			lowerCAmelCase__      :		List[str]    							=      filename
			param_count += v.numel()
		torch.save(A_		,	os.path.join(A_		,	A_					)					)

	lowerCAmelCase__      :		str    							=      f'pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin'
	if model_size == "7B":
		# Unsharded
		lowerCAmelCase__      :		Tuple    							=      {
		    '''model.embed_tokens.weight''': loaded['''tok_embeddings.weight'''],
		    '''model.norm.weight''': loaded['''norm.weight'''],
		    '''lm_head.weight''': loaded['''output.weight'''],
		}
	else:
		lowerCAmelCase__      :		Any    							=      {
		    '''model.norm.weight''': loaded[0]['''norm.weight'''],
		    '''model.embed_tokens.weight''': torch.cat(
		        [loaded[i]['''tok_embeddings.weight'''] for i in range(A_					)]		,	dim=1					),
		    '''lm_head.weight''': torch.cat([loaded[i]['''output.weight'''] for i in range(A_					)]		,	dim=0					),
		}

	for k, v in state_dict.items():
		lowerCAmelCase__      :		str    							=      filename
		param_count += v.numel()
	torch.save(A_		,	os.path.join(A_		,	A_					)					)

	# Write configs
	lowerCAmelCase__      :		Union[str, Any]    							=      {'''total_size''': param_count * 2}
	write_json(A_		,	os.path.join(A_		,	'''pytorch_model.bin.index.json'''					)					)
	lowerCAmelCase__      :		Union[str, Any]    							=      params['''ffn_dim_multiplier'''] if '''ffn_dim_multiplier''' in params else 1
	lowerCAmelCase__      :		Any    							=      params['''multiple_of'''] if '''multiple_of''' in params else 2_56
	lowerCAmelCase__      :		List[str]    							=      LlamaConfig(
	    hidden_size=A_		,	intermediate_size=compute_intermediate_size(A_		,	A_		,	A_					)		,	num_attention_heads=params['''n_heads''']		,	num_hidden_layers=params['''n_layers''']		,	rms_norm_eps=params['''norm_eps''']		,	num_key_value_heads=A_		,	)
	config.save_pretrained(A_					)

	# Make space so we can load the model properly now.
	del state_dict
	del loaded
	gc.collect()

	print('''Loading the checkpoint in a Llama model.'''					)
	lowerCAmelCase__      :		Optional[int]    							=      LlamaForCausalLM.from_pretrained(A_		,	torch_dtype=torch.floataa		,	low_cpu_mem_usage=A_					)
	# Avoid saving this as part of the config.
	del model.config._name_or_path

	print('''Saving in the Transformers format.'''					)
	model.save_pretrained(A_		,	safe_serialization=A_					)
	shutil.rmtree(A_					)

def     __SCREAMING_SNAKE_CASE    ( A_		,	A_					):
	# Initialize the tokenizer based on the `spm` model
	lowerCAmelCase__      :		List[str]    							=      LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
	print(f'Saving a {tokenizer_class.__name__} to {tokenizer_path}.'					)
	lowerCAmelCase__      :		Union[str, Any]    							=      tokenizer_class(A_					)
	tokenizer.save_pretrained(A_					)

def     __SCREAMING_SNAKE_CASE    ( ):
	lowerCAmelCase__      :		Any    							=      argparse.ArgumentParser()
	parser.add_argument(
	    '''--input_dir'''		,	help='''Location of LLaMA weights, which contains tokenizer.model and model folders'''		,	)
	parser.add_argument(
	    '''--model_size'''		,	choices=['''7B''', '''7Bf''', '''13B''', '''13Bf''', '''30B''', '''65B''', '''70B''', '''70Bf''', '''tokenizer_only''']		,	)
	parser.add_argument(
	    '''--output_dir'''		,	help='''Location to write HF model and tokenizer'''		,	)
	parser.add_argument('''--safe_serialization'''		,	type=A_		,	help='''Whether or not to save using `safetensors`.'''					)
	lowerCAmelCase__      :		str    							=      parser.parse_args()
	if args.model_size != "tokenizer_only":
		write_model(
		    model_path=args.output_dir		,	input_base_path=os.path.join(args.input_dir		,	args.model_size					)		,	model_size=args.model_size		,	safe_serialization=args.safe_serialization		,	)
	lowerCAmelCase__      :		Any    							=      os.path.join(args.input_dir		,	'''tokenizer.model'''					)
	write_tokenizer(args.output_dir		,	A_					)


if __name__ == "__main__":
							main()







"""simple docstring"""





import unittest

from transformers import (
    MODEL_FOR_OBJECT_DETECTION_MAPPING,
    AutoFeatureExtractor,
    AutoModelForObjectDetection,
    ObjectDetectionPipeline,
    is_vision_available,
    pipeline,
)
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_pytesseract,
    require_tf,
    require_timm,
    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					(			*lowercase_     :							Dict  ,**lowercase_     :							str						):
													pass







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






					"""simple docstring"""



					lowercase__												=			MODEL_FOR_OBJECT_DETECTION_MAPPING







					def 			__lowerCAmelCase					(			self     :							str  ,lowercase_     :							int  ,lowercase_     :							str  ,lowercase_     :							List[str]						):
						lowerCAmelCase__      :		int    							=      ObjectDetectionPipeline(model=lowercase_  ,image_processor=lowercase_						)
						return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"]







					def 			__lowerCAmelCase					(			self     :							int  ,lowercase_     :							str  ,lowercase_     :							str						):
						lowerCAmelCase__      :		List[str]    							=      object_detector('''./tests/fixtures/tests_samples/COCO/000000039769.png'''  ,threshold=0.0						)

						self.assertGreater(len(lowercase_						)  ,0						)
						for detected_object in outputs:
							self.assertEqual(
							    lowercase_  ,{
							        '''score''': ANY(lowercase_						),
							        '''label''': ANY(lowercase_						),
							        '''box''': {'''xmin''': ANY(lowercase_						), '''ymin''': ANY(lowercase_						), '''xmax''': ANY(lowercase_						), '''ymax''': ANY(lowercase_						)},
							    }  ,)

						import datasets

						lowerCAmelCase__      :		str    							=      datasets.load_dataset('''hf-internal-testing/fixtures_image_utils'''  ,'''image'''  ,split='''test'''						)

						lowerCAmelCase__      :		Dict    							=      [
						    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						),
						    '''http://images.cocodataset.org/val2017/000000039769.jpg''',
						    # RGBA
						    dataset[0]['''file'''],
						    # LA
						    dataset[1]['''file'''],
						    # L
						    dataset[2]['''file'''],
						]
						lowerCAmelCase__      :		Optional[Any]    							=      object_detector(lowercase_  ,threshold=0.0						)

						self.assertEqual(len(lowercase_						)  ,len(lowercase_						)						)
						for outputs in batch_outputs:
							self.assertGreater(len(lowercase_						)  ,0						)
							for detected_object in outputs:
								self.assertEqual(
								    lowercase_  ,{
								        '''score''': ANY(lowercase_						),
								        '''label''': ANY(lowercase_						),
								        '''box''': {'''xmin''': ANY(lowercase_						), '''ymin''': ANY(lowercase_						), '''xmax''': ANY(lowercase_						), '''ymax''': ANY(lowercase_						)},
								    }  ,)







					@require_tf
					@unittest.skip('''Object detection not implemented in TF'''						)
					def 			__lowerCAmelCase					(			self     :							Optional[int]						):
						pass







					@require_torch
					def 			__lowerCAmelCase					(			self     :							Optional[int]						):
						lowerCAmelCase__      :		Optional[Any]    							=      '''hf-internal-testing/tiny-detr-mobilenetsv3'''

						lowerCAmelCase__      :		Union[str, Any]    							=      AutoModelForObjectDetection.from_pretrained(lowercase_						)
						lowerCAmelCase__      :		Any    							=      AutoFeatureExtractor.from_pretrained(lowercase_						)
						lowerCAmelCase__      :		Optional[int]    							=      ObjectDetectionPipeline(model=lowercase_  ,feature_extractor=lowercase_						)

						lowerCAmelCase__      :		Any    							=      object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''  ,threshold=0.0						)

						self.assertEqual(
						    nested_simplify(lowercase_  ,decimals=4						)  ,[
						        {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 1_5_9, '''ymin''': 1_2_0, '''xmax''': 4_8_0, '''ymax''': 3_5_9}},
						        {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 1_5_9, '''ymin''': 1_2_0, '''xmax''': 4_8_0, '''ymax''': 3_5_9}},
						    ]  ,)

						lowerCAmelCase__      :		List[Any]    							=      object_detector(
						    [
						        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
						        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
						    ]  ,threshold=0.0  ,)

						self.assertEqual(
						    nested_simplify(lowercase_  ,decimals=4						)  ,[
						        [
						            {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 1_5_9, '''ymin''': 1_2_0, '''xmax''': 4_8_0, '''ymax''': 3_5_9}},
						            {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 1_5_9, '''ymin''': 1_2_0, '''xmax''': 4_8_0, '''ymax''': 3_5_9}},
						        ],
						        [
						            {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 1_5_9, '''ymin''': 1_2_0, '''xmax''': 4_8_0, '''ymax''': 3_5_9}},
						            {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 1_5_9, '''ymin''': 1_2_0, '''xmax''': 4_8_0, '''ymax''': 3_5_9}},
						        ],
						    ]  ,)







					@require_torch
					@slow
					def 			__lowerCAmelCase					(			self     :							Any						):
						lowerCAmelCase__      :		List[Any]    							=      '''facebook/detr-resnet-50'''

						lowerCAmelCase__      :		Any    							=      AutoModelForObjectDetection.from_pretrained(lowercase_						)
						lowerCAmelCase__      :		Dict    							=      AutoFeatureExtractor.from_pretrained(lowercase_						)
						lowerCAmelCase__      :		Any    							=      ObjectDetectionPipeline(model=lowercase_  ,feature_extractor=lowercase_						)

						lowerCAmelCase__      :		Tuple    							=      object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''						)
						self.assertEqual(
						    nested_simplify(lowercase_  ,decimals=4						)  ,[
						        {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 4_0, '''ymin''': 7_0, '''xmax''': 1_7_5, '''ymax''': 1_1_7}},
						        {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 3_3_3, '''ymin''': 7_2, '''xmax''': 3_6_8, '''ymax''': 1_8_7}},
						        {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 6_3_9, '''ymax''': 4_7_3}},
						        {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 1_3, '''ymin''': 5_2, '''xmax''': 3_1_4, '''ymax''': 4_7_0}},
						        {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 3_4_5, '''ymin''': 2_3, '''xmax''': 6_4_0, '''ymax''': 3_6_8}},
						    ]  ,)

						lowerCAmelCase__      :		List[Any]    							=      object_detector(
						    [
						        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
						        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
						    ]						)
						self.assertEqual(
						    nested_simplify(lowercase_  ,decimals=4						)  ,[
						        [
						            {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 4_0, '''ymin''': 7_0, '''xmax''': 1_7_5, '''ymax''': 1_1_7}},
						            {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 3_3_3, '''ymin''': 7_2, '''xmax''': 3_6_8, '''ymax''': 1_8_7}},
						            {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 6_3_9, '''ymax''': 4_7_3}},
						            {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 1_3, '''ymin''': 5_2, '''xmax''': 3_1_4, '''ymax''': 4_7_0}},
						            {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 3_4_5, '''ymin''': 2_3, '''xmax''': 6_4_0, '''ymax''': 3_6_8}},
						        ],
						        [
						            {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 4_0, '''ymin''': 7_0, '''xmax''': 1_7_5, '''ymax''': 1_1_7}},
						            {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 3_3_3, '''ymin''': 7_2, '''xmax''': 3_6_8, '''ymax''': 1_8_7}},
						            {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 6_3_9, '''ymax''': 4_7_3}},
						            {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 1_3, '''ymin''': 5_2, '''xmax''': 3_1_4, '''ymax''': 4_7_0}},
						            {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 3_4_5, '''ymin''': 2_3, '''xmax''': 6_4_0, '''ymax''': 3_6_8}},
						        ],
						    ]  ,)







					@require_torch
					@slow
					def 			__lowerCAmelCase					(			self     :							Tuple						):
						lowerCAmelCase__      :		Tuple    							=      '''facebook/detr-resnet-50'''

						lowerCAmelCase__      :		Tuple    							=      pipeline('''object-detection'''  ,model=lowercase_						)

						lowerCAmelCase__      :		Optional[int]    							=      object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''						)
						self.assertEqual(
						    nested_simplify(lowercase_  ,decimals=4						)  ,[
						        {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 4_0, '''ymin''': 7_0, '''xmax''': 1_7_5, '''ymax''': 1_1_7}},
						        {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 3_3_3, '''ymin''': 7_2, '''xmax''': 3_6_8, '''ymax''': 1_8_7}},
						        {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 6_3_9, '''ymax''': 4_7_3}},
						        {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 1_3, '''ymin''': 5_2, '''xmax''': 3_1_4, '''ymax''': 4_7_0}},
						        {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 3_4_5, '''ymin''': 2_3, '''xmax''': 6_4_0, '''ymax''': 3_6_8}},
						    ]  ,)

						lowerCAmelCase__      :		Any    							=      object_detector(
						    [
						        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
						        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
						    ]						)
						self.assertEqual(
						    nested_simplify(lowercase_  ,decimals=4						)  ,[
						        [
						            {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 4_0, '''ymin''': 7_0, '''xmax''': 1_7_5, '''ymax''': 1_1_7}},
						            {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 3_3_3, '''ymin''': 7_2, '''xmax''': 3_6_8, '''ymax''': 1_8_7}},
						            {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 6_3_9, '''ymax''': 4_7_3}},
						            {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 1_3, '''ymin''': 5_2, '''xmax''': 3_1_4, '''ymax''': 4_7_0}},
						            {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 3_4_5, '''ymin''': 2_3, '''xmax''': 6_4_0, '''ymax''': 3_6_8}},
						        ],
						        [
						            {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 4_0, '''ymin''': 7_0, '''xmax''': 1_7_5, '''ymax''': 1_1_7}},
						            {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 3_3_3, '''ymin''': 7_2, '''xmax''': 3_6_8, '''ymax''': 1_8_7}},
						            {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 6_3_9, '''ymax''': 4_7_3}},
						            {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 1_3, '''ymin''': 5_2, '''xmax''': 3_1_4, '''ymax''': 4_7_0}},
						            {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 3_4_5, '''ymin''': 2_3, '''xmax''': 6_4_0, '''ymax''': 3_6_8}},
						        ],
						    ]  ,)







					@require_torch
					@slow
					def 			__lowerCAmelCase					(			self     :							Any						):
						lowerCAmelCase__      :		List[Any]    							=      0.9985
						lowerCAmelCase__      :		Dict    							=      '''facebook/detr-resnet-50'''

						lowerCAmelCase__      :		List[Any]    							=      pipeline('''object-detection'''  ,model=lowercase_						)

						lowerCAmelCase__      :		int    							=      object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''  ,threshold=lowercase_						)
						self.assertEqual(
						    nested_simplify(lowercase_  ,decimals=4						)  ,[
						        {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 1_3, '''ymin''': 5_2, '''xmax''': 3_1_4, '''ymax''': 4_7_0}},
						        {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 3_4_5, '''ymin''': 2_3, '''xmax''': 6_4_0, '''ymax''': 3_6_8}},
						    ]  ,)







					@require_torch
					@require_pytesseract
					@slow
					def 			__lowerCAmelCase					(			self     :							str						):
						lowerCAmelCase__      :		Optional[Any]    							=      '''Narsil/layoutlmv3-finetuned-funsd'''
						lowerCAmelCase__      :		List[Any]    							=      0.9993

						lowerCAmelCase__      :		Any    							=      pipeline('''object-detection'''  ,model=lowercase_  ,threshold=lowercase_						)

						lowerCAmelCase__      :		List[str]    							=      object_detector(
						    '''https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png'''						)
						self.assertEqual(
						    nested_simplify(lowercase_  ,decimals=4						)  ,[
						        {'''score''': 0.9993, '''label''': '''I-ANSWER''', '''box''': {'''xmin''': 2_9_4, '''ymin''': 2_5_4, '''xmax''': 3_4_3, '''ymax''': 2_6_4}},
						        {'''score''': 0.9993, '''label''': '''I-ANSWER''', '''box''': {'''xmin''': 2_9_4, '''ymin''': 2_5_4, '''xmax''': 3_4_3, '''ymax''': 2_6_4}},
						    ]  ,)




