



from __future__ import annotations

import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import is_tf_available, is_vision_available

from ...test_modeling_tf_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_tf_bert import TFBertModelTester
from ..clip.test_modeling_tf_clip import TFCLIPVisionModelTester
from ..deit.test_modeling_tf_deit import TFDeiTModelTester
from ..roberta.test_modeling_tf_roberta import TFRobertaModelTester
from ..vit.test_modeling_tf_vit import TFViTModelTester


if is_tf_available():
	from transformers import (
	    TFBertModel,
	    TFCLIPVisionModel,
	    TFDeiTModel,
	    TFRobertaModel,
	    TFVisionTextDualEncoderModel,
	    TFViTModel,
	    VisionTextDualEncoderConfig,
	)

if is_vision_available():
	from PIL import Image

	from transformers import VisionTextDualEncoderProcessor


def 		_UpperCAmelCase				(      snake_case			):





					"""simple docstring"""

					if isinstance(snake_case	,						collections.abc.Iterable			):
										return x
					return (x, x)





@require_tf
class 					__lowerCAmelCase :




				def 							snake_case   (							self						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									pass




				def 							snake_case   (							self		):



									"""simple docstring"""





									pass




				def 							snake_case   (							self		):



									"""simple docstring"""





									pass




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case=None						,				**_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    VisionTextDualEncoderConfig.from_vision_text_configs(_snake_case						,				_snake_case		)

									_lowerCAmelCase						=    TFVisionTextDualEncoderModel(_snake_case		)

									_lowerCAmelCase						=    model(input_ids=_snake_case						,				pixel_values=_snake_case						,				attention_mask=_snake_case		)

									self.assertEqual(output["""text_embeds"""].shape						,				(input_ids.shape[0], config.projection_dim)		)
									self.assertEqual(output["""image_embeds"""].shape						,				(pixel_values.shape[0], config.projection_dim)		)




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case=None						,				**_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase	,	_lowerCAmelCase						=    self.get_vision_text_model(_snake_case						,				_snake_case		)
									_lowerCAmelCase						=    TFVisionTextDualEncoderModel(vision_model=_snake_case						,				text_model=_snake_case		)

									_lowerCAmelCase						=    model(input_ids=_snake_case						,				pixel_values=_snake_case						,				attention_mask=_snake_case		)

									self.assertEqual(output["""text_embeds"""].shape						,				(input_ids.shape[0], model.config.projection_dim)		)
									self.assertEqual(output["""image_embeds"""].shape						,				(pixel_values.shape[0], model.config.projection_dim)		)




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case=None						,				**_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase	,	_lowerCAmelCase						=    self.get_vision_text_model(_snake_case						,				_snake_case		)
									_lowerCAmelCase						=    {"""vision_model""": vision_model, """text_model""": text_model}
									_lowerCAmelCase						=    TFVisionTextDualEncoderModel.from_vision_text_pretrained(**_snake_case		)

									_lowerCAmelCase						=    model(input_ids=_snake_case						,				pixel_values=_snake_case						,				attention_mask=_snake_case		)

									self.assertEqual(output["""text_embeds"""].shape						,				(input_ids.shape[0], model.config.projection_dim)		)
									self.assertEqual(output["""image_embeds"""].shape						,				(pixel_values.shape[0], model.config.projection_dim)		)




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case=None						,				**_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase	,	_lowerCAmelCase						=    self.get_vision_text_model(_snake_case						,				_snake_case		)
									_lowerCAmelCase						=    TFVisionTextDualEncoderModel(vision_model=_snake_case						,				text_model=_snake_case		)

									_lowerCAmelCase						=    model(input_ids=_snake_case						,				pixel_values=_snake_case						,				attention_mask=_snake_case		)
									_lowerCAmelCase						=    output[0].numpy()

									with tempfile.TemporaryDirectory() as tmpdirname:
														model.save_pretrained(_snake_case		)
														_lowerCAmelCase						=    TFVisionTextDualEncoderModel.from_pretrained(_snake_case		)

														_lowerCAmelCase						=    model(input_ids=_snake_case						,				pixel_values=_snake_case						,				attention_mask=_snake_case		)
														_lowerCAmelCase						=    after_output[0].numpy()
														_lowerCAmelCase						=    np.amax(np.abs(out_a - out_a		)		)
														self.assertLessEqual(_snake_case						,				1e-5		)




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case=None						,				**_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase	,	_lowerCAmelCase						=    self.get_vision_text_model(_snake_case						,				_snake_case		)
									_lowerCAmelCase						=    TFVisionTextDualEncoderModel(vision_model=_snake_case						,				text_model=_snake_case		)

									_lowerCAmelCase						=    model(
									    input_ids=_snake_case						,				pixel_values=_snake_case						,				attention_mask=_snake_case						,				output_attentions=_snake_case		)

									_lowerCAmelCase						=    output.vision_model_output.attentions
									self.assertEqual(len(_snake_case		)						,				vision_config.num_hidden_layers		)

									# in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
									_lowerCAmelCase						=    to_atuple(vision_model.config.image_size		)
									_lowerCAmelCase						=    to_atuple(vision_model.config.patch_size		)
									_lowerCAmelCase						=    (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
									_lowerCAmelCase						=    num_patches + 1
									self.assertEqual(vision_attentions[0].shape[-3:]						,				(vision_config.num_attention_heads, seq_len, seq_len)		)

									_lowerCAmelCase						=    output.text_model_output.attentions
									self.assertEqual(len(_snake_case		)						,				text_config.num_hidden_layers		)

									self.assertEqual(
									    text_attentions[0].shape[-3:]						,				(text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])						,				)




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    np.abs((a - b)		).max()
									self.assertLessEqual(_snake_case						,				_snake_case						,				F'Difference between torch and flax is {diff} (>= {tol}).'		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.prepare_config_and_inputs()
									self.check_vision_text_dual_encoder_model(**_snake_case		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.prepare_config_and_inputs()
									self.check_model_from_pretrained_configs(**_snake_case		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.prepare_config_and_inputs()
									self.check_vision_text_dual_encoder_from_pretrained(**_snake_case		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.prepare_config_and_inputs()
									self.check_save_load(**_snake_case		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.prepare_config_and_inputs()
									self.check_vision_text_output_attention(**_snake_case		)




				@slow
				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase	,	_lowerCAmelCase						=    self.get_pretrained_model_and_inputs()

									_lowerCAmelCase						=    model_a(**_snake_case		)
									_lowerCAmelCase						=    outputs[0].numpy()

									with tempfile.TemporaryDirectory() as tmp_dirname:
														model_a.save_pretrained(_snake_case		)
														_lowerCAmelCase						=    TFVisionTextDualEncoderModel.from_pretrained(_snake_case		)

														_lowerCAmelCase						=    model_a(**_snake_case		)
														_lowerCAmelCase						=    after_outputs[0].numpy()
														_lowerCAmelCase						=    np.amax(np.abs(out_a - out_a		)		)
														self.assertLessEqual(_snake_case						,				1e-5		)





@require_tf
class 					__lowerCAmelCase (     lowerCamelCase__       ,						unittest.TestCase       ):




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFVisionTextDualEncoderModel.from_vision_text_pretrained(
									    """hf-internal-testing/tiny-random-vit"""						,				"""hf-internal-testing/tiny-random-bert"""		)
									_lowerCAmelCase						=    13
									_lowerCAmelCase						=    floats_tensor(
									    [
									        batch_size,
									        model.vision_model.config.num_channels,
									        model.vision_model.config.image_size,
									        model.vision_model.config.image_size,
									    ]		)
									_lowerCAmelCase						=    ids_tensor([batch_size, 4]						,				model.text_model.config.vocab_size		)
									_lowerCAmelCase						=    random_attention_mask([batch_size, 4]		)
									_lowerCAmelCase						=    {"""pixel_values""": pixel_values, """input_ids""": input_ids, """attention_mask""": attention_mask}

									return model, inputs




				def 							snake_case   (							self						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFViTModel(_snake_case						,				name="""vision_model"""		)
									_lowerCAmelCase						=    TFBertModel(_snake_case						,				name="""text_model"""		)
									return vision_model, text_model




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFViTModelTester(self		)
									_lowerCAmelCase						=    TFBertModelTester(self		)
									_lowerCAmelCase						=    vit_model_tester.prepare_config_and_inputs()
									_lowerCAmelCase						=    bert_model_tester.prepare_config_and_inputs()

									_lowerCAmelCase	,	_lowerCAmelCase	,	_lowerCAmelCase						=    vision_config_and_inputs

									(
									    (
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	
									)						=    text_config_and_inputs

									return {
									    "text_config": text_config,
									    "vision_config": vision_config,
									    "pixel_values": pixel_values,
									    "attention_mask": input_mask,
									    "input_ids": input_ids,
									    "text_token_type_ids": token_type_ids,
									    "text_sequence_labels": sequence_labels,
									    "text_token_labels": token_labels,
									    "text_choice_labels": choice_labels,
									}





@require_tf
class 					__lowerCAmelCase (     lowerCamelCase__       ,						unittest.TestCase       ):




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFVisionTextDualEncoderModel.from_vision_text_pretrained(
									    """Rocketknight1/tiny-random-deit-tf"""						,				"""hf-internal-testing/tiny-random-roberta"""		)
									_lowerCAmelCase						=    13
									_lowerCAmelCase						=    floats_tensor(
									    [
									        batch_size,
									        model.vision_model.config.num_channels,
									        model.vision_model.config.image_size,
									        model.vision_model.config.image_size,
									    ]		)
									_lowerCAmelCase						=    ids_tensor([batch_size, 4]						,				model.text_model.config.vocab_size		)
									_lowerCAmelCase						=    random_attention_mask([batch_size, 4]		)
									_lowerCAmelCase						=    {"""pixel_values""": pixel_values, """input_ids""": input_ids, """attention_mask""": attention_mask}

									return model, inputs




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case=None						,				**_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase	,	_lowerCAmelCase						=    self.get_vision_text_model(_snake_case						,				_snake_case		)
									_lowerCAmelCase						=    TFVisionTextDualEncoderModel(vision_model=_snake_case						,				text_model=_snake_case		)

									_lowerCAmelCase						=    model(
									    input_ids=_snake_case						,				pixel_values=_snake_case						,				attention_mask=_snake_case						,				output_attentions=_snake_case		)

									_lowerCAmelCase						=    output.vision_model_output.attentions
									self.assertEqual(len(_snake_case		)						,				vision_config.num_hidden_layers		)

									# in DEiT, the seq_len equals the number of patches + 2 (we add 2 for the [CLS] and distillation tokens)
									_lowerCAmelCase						=    to_atuple(vision_model.config.image_size		)
									_lowerCAmelCase						=    to_atuple(vision_model.config.patch_size		)
									_lowerCAmelCase						=    (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
									_lowerCAmelCase						=    num_patches + 2
									self.assertEqual(vision_attentions[0].shape[-3:]						,				(vision_config.num_attention_heads, seq_len, seq_len)		)

									_lowerCAmelCase						=    output.text_model_output.attentions
									self.assertEqual(len(_snake_case		)						,				text_config.num_hidden_layers		)

									self.assertEqual(
									    text_attentions[0].shape[-3:]						,				(text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])						,				)




				def 							snake_case   (							self						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFDeiTModel(_snake_case						,				name="""vision_model"""		)
									_lowerCAmelCase						=    TFRobertaModel(_snake_case						,				name="""text_model"""		)
									return vision_model, text_model




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFDeiTModelTester(self		)
									_lowerCAmelCase						=    TFRobertaModelTester(self		)
									_lowerCAmelCase						=    vit_model_tester.prepare_config_and_inputs()
									_lowerCAmelCase						=    bert_model_tester.prepare_config_and_inputs()

									_lowerCAmelCase	,	_lowerCAmelCase	,	_lowerCAmelCase						=    vision_config_and_inputs

									(
									    (
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	
									)						=    text_config_and_inputs

									return {
									    "text_config": text_config,
									    "vision_config": vision_config,
									    "pixel_values": pixel_values,
									    "attention_mask": input_mask,
									    "input_ids": input_ids,
									    "text_token_type_ids": token_type_ids,
									    "text_sequence_labels": sequence_labels,
									    "text_token_labels": token_labels,
									    "text_choice_labels": choice_labels,
									}





@require_tf
class 					__lowerCAmelCase (     lowerCamelCase__       ,						unittest.TestCase       ):




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFVisionTextDualEncoderModel.from_vision_text_pretrained(
									    """Rocketknight1/tiny-random-clip-tf"""						,				"""hf-internal-testing/tiny-random-bert"""		)
									_lowerCAmelCase						=    13
									_lowerCAmelCase						=    floats_tensor(
									    [
									        batch_size,
									        model.vision_model.config.num_channels,
									        model.vision_model.config.image_size,
									        model.vision_model.config.image_size,
									    ]		)
									_lowerCAmelCase						=    ids_tensor([batch_size, 4]						,				model.text_model.config.vocab_size		)
									_lowerCAmelCase						=    random_attention_mask([batch_size, 4]		)
									_lowerCAmelCase						=    {"""pixel_values""": pixel_values, """input_ids""": input_ids, """attention_mask""": attention_mask}

									return model, inputs




				def 							snake_case   (							self						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFCLIPVisionModel(_snake_case						,				name="""vision_model"""		)
									_lowerCAmelCase						=    TFBertModel(_snake_case						,				name="""text_model"""		)
									return vision_model, text_model




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFCLIPVisionModelTester(self		)
									_lowerCAmelCase						=    TFBertModelTester(self		)
									_lowerCAmelCase						=    clip_model_tester.prepare_config_and_inputs()
									_lowerCAmelCase						=    bert_model_tester.prepare_config_and_inputs()

									_lowerCAmelCase	,	_lowerCAmelCase						=    vision_config_and_inputs

									(
									    (
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	(
									    _lowerCAmelCase
									)	,	
									)						=    text_config_and_inputs

									return {
									    "text_config": text_config,
									    "vision_config": vision_config,
									    "pixel_values": pixel_values,
									    "attention_mask": input_mask,
									    "input_ids": input_ids,
									    "text_token_type_ids": token_type_ids,
									    "text_sequence_labels": sequence_labels,
									    "text_token_labels": token_labels,
									    "text_choice_labels": choice_labels,
									}





@require_vision
@require_tf
class 					__lowerCAmelCase (     unittest.TestCase       ):




				@slow
				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    TFVisionTextDualEncoderModel.from_pretrained(
									    """clip-italian/clip-italian"""						,				logit_scale_init_value=1.0						,				from_pt=_snake_case		)
									_lowerCAmelCase						=    VisionTextDualEncoderProcessor.from_pretrained("""clip-italian/clip-italian"""		)

									_lowerCAmelCase						=    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		)
									_lowerCAmelCase						=    processor(
									    text=["""una foto di un gatto""", """una foto di un cane"""]						,				images=_snake_case						,				padding=_snake_case						,				return_tensors="""np"""		)

									_lowerCAmelCase						=    model(**_snake_case		)

									# verify the logits
									self.assertEqual(outputs.logits_per_image.shape						,				(inputs.pixel_values.shape[0], inputs.input_ids.shape[0])		)
									self.assertEqual(
									    outputs.logits_per_text.shape						,				(inputs.input_ids.shape[0], inputs.pixel_values.shape[0])						,				)

									_lowerCAmelCase						=    np.array([[1.228_4727, 0.310_4122]]		)

									self.assertTrue(np.allclose(outputs.logits_per_image.numpy()						,				_snake_case						,				atol=1e-3		)		)





"""simple docstring"""




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


UpperCAmelCase__      :    str    							= logging.get_logger(__name__)

UpperCAmelCase__      :    Optional[int]    							= {
    'hustvl/yolos-small': 'https://huggingface.co/hustvl/yolos-small/resolve/main/config.json',
    # See all YOLOS models at https://huggingface.co/models?filter=yolos
}



class 	lowerCAmelCase_						(a__  ):


				"""simple docstring"""



				__UpperCamelCase      :						int					       =   '''yolos'''



				def __init__(self   ,       SCREAMING_SNAKE_CASE__=7_68   ,       SCREAMING_SNAKE_CASE__=12   ,       SCREAMING_SNAKE_CASE__=12   ,       SCREAMING_SNAKE_CASE__=30_72   ,       SCREAMING_SNAKE_CASE__="gelu"   ,       SCREAMING_SNAKE_CASE__=0.0   ,       SCREAMING_SNAKE_CASE__=0.0   ,       SCREAMING_SNAKE_CASE__=0.02   ,       SCREAMING_SNAKE_CASE__=1E-12   ,       SCREAMING_SNAKE_CASE__=[5_12, 8_64]   ,       SCREAMING_SNAKE_CASE__=16   ,       SCREAMING_SNAKE_CASE__=3   ,       SCREAMING_SNAKE_CASE__=True   ,       SCREAMING_SNAKE_CASE__=1_00   ,       SCREAMING_SNAKE_CASE__=True   ,       SCREAMING_SNAKE_CASE__=False   ,       SCREAMING_SNAKE_CASE__=1   ,       SCREAMING_SNAKE_CASE__=5   ,       SCREAMING_SNAKE_CASE__=2   ,       SCREAMING_SNAKE_CASE__=5   ,       SCREAMING_SNAKE_CASE__=2   ,       SCREAMING_SNAKE_CASE__=0.1   ,       **SCREAMING_SNAKE_CASE__   ,       )					->		Optional[Any]:



											"""simple docstring"""




											super().__init__(**SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   hidden_size
											SCREAMING_SNAKE_CASE__						:       int           =   num_hidden_layers
											SCREAMING_SNAKE_CASE__						:       str           =   num_attention_heads
											SCREAMING_SNAKE_CASE__						:       List[str]           =   intermediate_size
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   hidden_act
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   hidden_dropout_prob
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   attention_probs_dropout_prob
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   initializer_range
											SCREAMING_SNAKE_CASE__						:       Dict           =   layer_norm_eps
											SCREAMING_SNAKE_CASE__						:       List[str]           =   image_size
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   patch_size
											SCREAMING_SNAKE_CASE__						:       List[str]           =   num_channels
											SCREAMING_SNAKE_CASE__						:       List[str]           =   qkv_bias
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   num_detection_tokens
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   use_mid_position_embeddings
											SCREAMING_SNAKE_CASE__						:       List[str]           =   auxiliary_loss
											# Hungarian matcher
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   class_cost
											SCREAMING_SNAKE_CASE__						:       List[str]           =   bbox_cost
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   giou_cost
											# Loss coefficients
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   bbox_loss_coefficient
											SCREAMING_SNAKE_CASE__						:       List[str]           =   giou_loss_coefficient
											SCREAMING_SNAKE_CASE__						:       int           =   eos_coefficient






class 	lowerCAmelCase_						(a__  ):


				"""simple docstring"""



				__UpperCamelCase      :						Dict					       =   version.parse('''1.11'''  )



				@property
				def 	__magic_name__    (self    )					->		Mapping[str, Mapping[int, str]]:



											"""simple docstring"""




											return OrderedDict(
											    [
											        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
											    ]    )



				@property
				def 	__magic_name__    (self    )					->		float:



											"""simple docstring"""




											return 1E-4



				@property
				def 	__magic_name__    (self    )					->		int:



											"""simple docstring"""




											return 12




