






import copy
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


UpperCamelCase        =				logging.get_logger(__name__)

UpperCamelCase        =				{
    "microsoft/conditional-detr-resnet-50": (
        "https://huggingface.co/microsoft/conditional-detr-resnet-50/resolve/main/config.json"
    ),
}

class        lowerCAmelCase_				(      lowercase	):







				"""simple docstring"""




				_snake_case				:   Tuple        =			"""conditional_detr"""
				_snake_case				:   List[Any]        =			["""past_key_values"""]
				_snake_case				:   str        =			{
				    """hidden_size""": """d_model""",
				    """num_attention_heads""": """encoder_attention_heads""",
				}







				def __init__( self     :Dict  ,     lowerCamelCase__     :Optional[Any]=True  ,     lowerCamelCase__     :Any=None  ,     lowerCamelCase__     :Dict=3  ,     lowerCamelCase__     :Dict=3_00  ,     lowerCamelCase__     :Union[str, Any]=6  ,     lowerCamelCase__     :List[Any]=20_48  ,     lowerCamelCase__     :List[str]=8  ,     lowerCamelCase__     :Any=6  ,     lowerCamelCase__     :Optional[int]=20_48  ,     lowerCamelCase__     :Tuple=8  ,     lowerCamelCase__     :Optional[int]=0.0  ,     lowerCamelCase__     :Optional[int]=0.0  ,     lowerCamelCase__     :Optional[Any]=True  ,     lowerCamelCase__     :List[str]="relu"  ,     lowerCamelCase__     :List[Any]=2_56  ,     lowerCamelCase__     :Optional[Any]=0.1  ,     lowerCamelCase__     :Dict=0.0  ,     lowerCamelCase__     :Optional[Any]=0.0  ,     lowerCamelCase__     :Tuple=0.02  ,     lowerCamelCase__     :Any=1.0  ,     lowerCamelCase__     :Dict=False  ,     lowerCamelCase__     :str="sine"  ,     lowerCamelCase__     :Dict="resnet50"  ,     lowerCamelCase__     :str=True  ,     lowerCamelCase__     :Optional[int]=False  ,     lowerCamelCase__     :str=2  ,     lowerCamelCase__     :List[str]=5  ,     lowerCamelCase__     :List[Any]=2  ,     lowerCamelCase__     :str=1  ,     lowerCamelCase__     :Any=1  ,     lowerCamelCase__     :Optional[int]=2  ,     lowerCamelCase__     :Union[str, Any]=5  ,     lowerCamelCase__     :Optional[Any]=2  ,     lowerCamelCase__     :Union[str, Any]=0.25  ,     **lowerCamelCase__     :Dict  ,     ):
					if backbone_config is not None and use_timm_backbone:
						raise ValueError("""You can't specify both `backbone_config` and `use_timm_backbone`."""     )

					if not use_timm_backbone:
						if backbone_config is None:
							logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."""     )
							UpperCamelCase__ :Tuple						=      CONFIG_MAPPING["""resnet"""](out_features=["""stage4"""]     )
						elif isinstance(lowerCamelCase__  ,     lowerCamelCase__     ):
							UpperCamelCase__ :int						=      backbone_config.get("""model_type"""     )
							UpperCamelCase__ :Optional[int]						=      CONFIG_MAPPING[backbone_model_type]
							UpperCamelCase__ :List[Any]						=      config_class.from_dict(lowerCamelCase__     )

					UpperCamelCase__ :str						=      use_timm_backbone
					UpperCamelCase__ :Dict						=      backbone_config
					UpperCamelCase__ :Union[str, Any]						=      num_channels
					UpperCamelCase__ :Optional[Any]						=      num_queries
					UpperCamelCase__ :Any						=      d_model
					UpperCamelCase__ :str						=      encoder_ffn_dim
					UpperCamelCase__ :Union[str, Any]						=      encoder_layers
					UpperCamelCase__ :Tuple						=      encoder_attention_heads
					UpperCamelCase__ :Optional[Any]						=      decoder_ffn_dim
					UpperCamelCase__ :Optional[int]						=      decoder_layers
					UpperCamelCase__ :Optional[Any]						=      decoder_attention_heads
					UpperCamelCase__ :Any						=      dropout
					UpperCamelCase__ :Union[str, Any]						=      attention_dropout
					UpperCamelCase__ :List[Any]						=      activation_dropout
					UpperCamelCase__ :int						=      activation_function
					UpperCamelCase__ :Tuple						=      init_std
					UpperCamelCase__ :Any						=      init_xavier_std
					UpperCamelCase__ :Any						=      encoder_layerdrop
					UpperCamelCase__ :Optional[int]						=      decoder_layerdrop
					UpperCamelCase__ :Optional[int]						=      encoder_layers
					UpperCamelCase__ :Optional[Any]						=      auxiliary_loss
					UpperCamelCase__ :List[Any]						=      position_embedding_type
					UpperCamelCase__ :Any						=      backbone
					UpperCamelCase__ :Dict						=      use_pretrained_backbone
					UpperCamelCase__ :Tuple						=      dilation
					# Hungarian matcher
					UpperCamelCase__ :Optional[Any]						=      class_cost
					UpperCamelCase__ :str						=      bbox_cost
					UpperCamelCase__ :int						=      giou_cost
					# Loss coefficients
					UpperCamelCase__ :Dict						=      mask_loss_coefficient
					UpperCamelCase__ :str						=      dice_loss_coefficient
					UpperCamelCase__ :Union[str, Any]						=      cls_loss_coefficient
					UpperCamelCase__ :List[Any]						=      bbox_loss_coefficient
					UpperCamelCase__ :List[Any]						=      giou_loss_coefficient
					UpperCamelCase__ :Dict						=      focal_alpha
					super().__init__(is_encoder_decoder=lowerCamelCase__  ,     **lowerCamelCase__     )







				@property
				def 				__a   ( self     :Union[str, Any]     ):
					return self.encoder_attention_heads







				@property
				def 				__a   ( self     :int     ):
					return self.d_model







				def 				__a   ( self     :Any     ):
					UpperCamelCase__ :str						=      copy.deepcopy(self.__dict__     )
					if self.backbone_config is not None:
						UpperCamelCase__ :str						=      self.backbone_config.to_dict()
					UpperCamelCase__ :Dict						=      self.__class__.model_type
					return output

class        lowerCAmelCase_				(      lowercase	):







				"""simple docstring"""




				_snake_case				:   Union[str, Any]        =			version.parse("""1.11"""	)







				@property
				def 				__a   ( self     :int     ):
					return OrderedDict(
					    [
					        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
					        ("""pixel_mask""", {0: """batch"""}),
					    ]     )







				@property
				def 				__a   ( self     :List[Any]     ):
					return 1e-5







				@property
				def 				__a   ( self     :Optional[int]     ):
					return 12







import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
			from PIL import Image

			from transformers import OwlViTImageProcessor, OwlViTProcessor




@require_vision
class 							snake_case_       (    unittest.TestCase      ):

						"""simple docstring"""



						def        UpperCAmelCase__					(self:					int   )    ->     str:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					tempfile.mkdtemp()

											# fmt: off
											__a					:						Dict      =					["", "l", "o", "w", "e", "r", "s", "t", "i", "d", "n", "lo", "l</w>", "w</w>", "r</w>", "t</w>", "low</w>", "er</w>", "lowest</w>", "newer</w>", "wider", "<unk>", "<|startoftext|>", "<|endoftext|>"]
											# fmt: on
											__a					:						str      =					dict(zip(__UpperCAmelCase ,					range(len(__UpperCAmelCase   )   )   )   )
											__a					:						Union[str, Any]      =					["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""]
											__a					:						Union[str, Any]      =					{"unk_token": "<unk>"}

											__a					:						Dict      =					os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES["vocab_file"]   )
											__a					:						int      =					os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES["merges_file"]   )
											with open(self.vocab_file ,					"w" ,					encoding="utf-8"   ) as fp:
																fp.write(json.dumps(__UpperCAmelCase   ) + "\n"   )
											with open(self.merges_file ,					"w" ,					encoding="utf-8"   ) as fp:
																fp.write("\n".join(__UpperCAmelCase   )   )

											__a					:						str      =					{
											    "do_resize": True,
											    "size": 20,
											    "do_center_crop": True,
											    "crop_size": 18,
											    "do_normalize": True,
											    "image_mean": [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],
											    "image_std": [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],
											}
											__a					:						Any      =					os.path.join(self.tmpdirname ,					__UpperCAmelCase   )
											with open(self.image_processor_file ,					"w" ,					encoding="utf-8"   ) as fp:
																json.dump(__UpperCAmelCase ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Tuple ,					**__UpperCAmelCase:					Dict   )    ->     List[str]:




											'''simple docstring'''



											return CLIPTokenizer.from_pretrained(self.tmpdirname ,					pad_token="!" ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Optional[Any] ,					**__UpperCAmelCase:					int   )    ->     Any:




											'''simple docstring'''



											return CLIPTokenizerFast.from_pretrained(self.tmpdirname ,					pad_token="!" ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					List[Any] ,					**__UpperCAmelCase:					Dict   )    ->     Optional[int]:




											'''simple docstring'''



											return OwlViTImageProcessor.from_pretrained(self.tmpdirname ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					str   )    ->     int:




											'''simple docstring'''



											shutil.rmtree(self.tmpdirname   )



						def        UpperCAmelCase__					(self:					Dict   )    ->     Union[str, Any]:




											'''simple docstring'''



											__a					:						Dict      =					[np.random.randint(255 ,					size=(3, 30, 400) ,					dtype=np.uinta   )]

											__a					:						Any      =					[Image.fromarray(np.moveaxis(__UpperCAmelCase ,					0 ,					-1   )   ) for x in image_inputs]

											return image_inputs



						def        UpperCAmelCase__					(self:					Tuple   )    ->     Optional[Any]:




											'''simple docstring'''



											__a					:						Dict      =					self.get_tokenizer()
											__a					:						Dict      =					self.get_rust_tokenizer()
											__a					:						List[str]      =					self.get_image_processor()

											__a					:						Any      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )
											processor_slow.save_pretrained(self.tmpdirname   )
											__a					:						str      =					OwlViTProcessor.from_pretrained(self.tmpdirname ,					use_fast=__UpperCAmelCase   )

											__a					:						Union[str, Any]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )
											processor_fast.save_pretrained(self.tmpdirname   )
											__a					:						List[Any]      =					OwlViTProcessor.from_pretrained(self.tmpdirname   )

											self.assertEqual(processor_slow.tokenizer.get_vocab() ,					tokenizer_slow.get_vocab()   )
											self.assertEqual(processor_fast.tokenizer.get_vocab() ,					tokenizer_fast.get_vocab()   )
											self.assertEqual(tokenizer_slow.get_vocab() ,					tokenizer_fast.get_vocab()   )
											self.assertIsInstance(processor_slow.tokenizer ,					__UpperCAmelCase   )
											self.assertIsInstance(processor_fast.tokenizer ,					__UpperCAmelCase   )

											self.assertEqual(processor_slow.image_processor.to_json_string() ,					image_processor.to_json_string()   )
											self.assertEqual(processor_fast.image_processor.to_json_string() ,					image_processor.to_json_string()   )
											self.assertIsInstance(processor_slow.image_processor ,					__UpperCAmelCase   )
											self.assertIsInstance(processor_fast.image_processor ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					str   )    ->     Dict:




											'''simple docstring'''



											__a					:						Tuple      =					OwlViTProcessor(tokenizer=self.get_tokenizer() ,					image_processor=self.get_image_processor()   )
											processor.save_pretrained(self.tmpdirname   )

											__a					:						Optional[Any]      =					self.get_tokenizer(bos_token="(BOS)" ,					eos_token="(EOS)"   )
											__a					:						str      =					self.get_image_processor(do_normalize=__UpperCAmelCase   )

											__a					:						str      =					OwlViTProcessor.from_pretrained(
											    self.tmpdirname ,					bos_token="(BOS)" ,					eos_token="(EOS)" ,					do_normalize=__UpperCAmelCase   )

											self.assertEqual(processor.tokenizer.get_vocab() ,					tokenizer_add_kwargs.get_vocab()   )
											self.assertIsInstance(processor.tokenizer ,					__UpperCAmelCase   )

											self.assertEqual(processor.image_processor.to_json_string() ,					image_processor_add_kwargs.to_json_string()   )
											self.assertIsInstance(processor.image_processor ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     Dict:




											'''simple docstring'''



											__a					:						Optional[Any]      =					self.get_image_processor()
											__a					:						str      =					self.get_tokenizer()

											__a					:						List[str]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						List[str]      =					self.prepare_image_inputs()

											__a					:						Optional[Any]      =					image_processor(__UpperCAmelCase ,					return_tensors="np"   )
											__a					:						int      =					processor(images=__UpperCAmelCase ,					return_tensors="np"   )

											for key in input_image_proc.keys():
																self.assertAlmostEqual(input_image_proc[key].sum() ,					input_processor[key].sum() ,					delta=1E-2   )



						def        UpperCAmelCase__					(self:					Dict   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						int      =					self.get_image_processor()
											__a					:						Tuple      =					self.get_tokenizer()

											__a					:						Optional[int]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						Dict      =					"lower newer"

											__a					:						Any      =					processor(text=__UpperCAmelCase ,					return_tensors="np"   )

											__a					:						List[str]      =					tokenizer(__UpperCAmelCase ,					return_tensors="np"   )

											for key in encoded_tok.keys():
																self.assertListEqual(encoded_tok[key][0].tolist() ,					encoded_processor[key][0].tolist()   )



						def        UpperCAmelCase__					(self:					List[Any]   )    ->     Dict:




											'''simple docstring'''



											__a					:						Dict      =					self.get_image_processor()
											__a					:						List[str]      =					self.get_tokenizer()

											__a					:						Optional[Any]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						Optional[int]      =					"lower newer"
											__a					:						int      =					self.prepare_image_inputs()

											__a					:						Optional[int]      =					processor(text=__UpperCAmelCase ,					images=__UpperCAmelCase   )

											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask", "pixel_values"]   )

											# test if it raises when no input is passed
											with pytest.raises(__UpperCAmelCase   ):
																processor()



						def        UpperCAmelCase__					(self:					int   )    ->     Union[str, Any]:




											'''simple docstring'''



											__a					:						Dict      =					"google/owlvit-base-patch32"
											__a					:						Dict      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						List[str]      =					["cat", "nasa badge"]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						Any      =					16
											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(2, seq_length)   )

											# test if it raises when no input is passed
											with pytest.raises(__UpperCAmelCase   ):
																processor()



						def        UpperCAmelCase__					(self:					Any   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						Optional[int]      =					"google/owlvit-base-patch32"
											__a					:						Optional[int]      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						Tuple      =					[["cat", "nasa badge"], ["person"]]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						Tuple      =					16
											__a					:						Optional[Any]      =					len(__UpperCAmelCase   )
											__a					:						Optional[Any]      =					max([len(__UpperCAmelCase   ) for texts in input_texts]   )

											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(batch_size * num_max_text_queries, seq_length)   )

											# test if it raises when no input is passed
											with pytest.raises(__UpperCAmelCase   ):
																processor()



						def        UpperCAmelCase__					(self:					Tuple   )    ->     Dict:




											'''simple docstring'''



											__a					:						int      =					"google/owlvit-base-patch32"
											__a					:						Dict      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						List[str]      =					["cat", "nasa badge"]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						int      =					16
											__a					:						Union[str, Any]      =					inputs["input_ids"]
											__a					:						Optional[int]      =					[
											    [49406, 2368, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
											    [49406, 6841, 11301, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
											]

											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(2, seq_length)   )
											self.assertListEqual(list(input_ids[0]   ) ,					predicted_ids[0]   )
											self.assertListEqual(list(input_ids[1]   ) ,					predicted_ids[1]   )



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     List[Any]:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					self.get_image_processor()
											__a					:						List[str]      =					self.get_tokenizer()

											__a					:						Tuple      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						str      =					self.prepare_image_inputs()
											__a					:						Any      =					self.prepare_image_inputs()

											__a					:						str      =					processor(images=__UpperCAmelCase ,					query_images=__UpperCAmelCase   )

											self.assertListEqual(list(inputs.keys()   ) ,					["query_pixel_values", "pixel_values"]   )

											# test if it raises when no input is passed
											with pytest.raises(__UpperCAmelCase   ):
																processor()



						def        UpperCAmelCase__					(self:					Any   )    ->     Tuple:




											'''simple docstring'''



											__a					:						int      =					self.get_image_processor()
											__a					:						Tuple      =					self.get_tokenizer()

											__a					:						Optional[int]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						List[str]      =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

											__a					:						Tuple      =					processor.batch_decode(__UpperCAmelCase   )
											__a					:						str      =					tokenizer.batch_decode(__UpperCAmelCase   )

											self.assertListEqual(__UpperCAmelCase ,					__UpperCAmelCase   )





