




'''simple docstring'''





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							:	Any					):

							'''simple docstring'''






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




@require_tf
class 			_snake_case		:




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__							)    ->    Optional[Any]:

										'''simple docstring'''




										pass




			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




										pass




			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




										pass




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__=None    ,							**a__							)    ->    str:

										'''simple docstring'''




										snake_case_      =				VisionTextDualEncoderConfig.from_vision_text_configs(a__    ,							a__							)

										snake_case_      =				TFVisionTextDualEncoderModel(a__							)

										snake_case_      =				model(input_ids=a__    ,							pixel_values=a__    ,							attention_mask=a__							)

										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        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__=None    ,							**a__							)    ->    str:

										'''simple docstring'''




										snake_case_ ,				snake_case_      =				self.get_vision_text_model(a__    ,							a__							)
										snake_case_      =				TFVisionTextDualEncoderModel(vision_model=a__    ,							text_model=a__							)

										snake_case_      =				model(input_ids=a__    ,							pixel_values=a__    ,							attention_mask=a__							)

										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        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__=None    ,							**a__							)    ->    int:

										'''simple docstring'''




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

										snake_case_      =				model(input_ids=a__    ,							pixel_values=a__    ,							attention_mask=a__							)

										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        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__=None    ,							**a__							)    ->    Any:

										'''simple docstring'''




										snake_case_ ,				snake_case_      =				self.get_vision_text_model(a__    ,							a__							)
										snake_case_      =				TFVisionTextDualEncoderModel(vision_model=a__    ,							text_model=a__							)

										snake_case_      =				model(input_ids=a__    ,							pixel_values=a__    ,							attention_mask=a__							)
										snake_case_      =				output[0].numpy()

										with tempfile.TemporaryDirectory() as tmpdirname:
																	model.save_pretrained(a__							)
																	snake_case_      =				TFVisionTextDualEncoderModel.from_pretrained(a__							)

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




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__=None    ,							**a__							)    ->    Dict:

										'''simple docstring'''




										snake_case_ ,				snake_case_      =				self.get_vision_text_model(a__    ,							a__							)
										snake_case_      =				TFVisionTextDualEncoderModel(vision_model=a__    ,							text_model=a__							)

										snake_case_      =				model(
										    input_ids=a__    ,							pixel_values=a__    ,							attention_mask=a__    ,							output_attentions=a__							)

										snake_case_      =				output.vision_model_output.attentions
										self.assertEqual(len(a__							)    ,							vision_config.num_hidden_layers							)

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

										snake_case_      =				output.text_model_output.attentions
										self.assertEqual(len(a__							)    ,							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        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__							)    ->    List[str]:

										'''simple docstring'''




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




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

										'''simple docstring'''




										snake_case_      =				self.prepare_config_and_inputs()
										self.check_vision_text_dual_encoder_model(**a__							)




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				self.prepare_config_and_inputs()
										self.check_model_from_pretrained_configs(**a__							)




			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




										snake_case_      =				self.prepare_config_and_inputs()
										self.check_vision_text_dual_encoder_from_pretrained(**a__							)




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				self.prepare_config_and_inputs()
										self.check_save_load(**a__							)




			def        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				self.prepare_config_and_inputs()
										self.check_vision_text_output_attention(**a__							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										snake_case_ ,				snake_case_      =				self.get_pretrained_model_and_inputs()

										snake_case_      =				model_a(**a__							)
										snake_case_      =				outputs[0].numpy()

										with tempfile.TemporaryDirectory() as tmp_dirname:
																	model_a.save_pretrained(a__							)
																	snake_case_      =				TFVisionTextDualEncoderModel.from_pretrained(a__							)

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




@require_tf
class 			_snake_case		(     lowercase_						,						unittest.TestCase							):




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




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

										return model, inputs




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__							)    ->    Optional[Any]:

										'''simple docstring'''




										snake_case_      =				TFViTModel(a__    ,							name="vision_model"							)
										snake_case_      =				TFBertModel(a__    ,							name="text_model"							)
										return vision_model, text_model




			def        lowerCAmelCase__    ( self							)    ->    str:

										'''simple docstring'''




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

										snake_case_ ,				snake_case_ ,				snake_case_      =				vision_config_and_inputs

										(
										    (
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,								
										)      =				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 			_snake_case		(     lowercase_						,						unittest.TestCase							):




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




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

										return model, inputs




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__=None    ,							**a__							)    ->    Dict:

										'''simple docstring'''




										snake_case_ ,				snake_case_      =				self.get_vision_text_model(a__    ,							a__							)
										snake_case_      =				TFVisionTextDualEncoderModel(vision_model=a__    ,							text_model=a__							)

										snake_case_      =				model(
										    input_ids=a__    ,							pixel_values=a__    ,							attention_mask=a__    ,							output_attentions=a__							)

										snake_case_      =				output.vision_model_output.attentions
										self.assertEqual(len(a__							)    ,							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)
										snake_case_      =				to_atuple(vision_model.config.image_size							)
										snake_case_      =				to_atuple(vision_model.config.patch_size							)
										snake_case_      =				(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
										snake_case_      =				num_patches + 2
										self.assertEqual(vision_attentions[0].shape[-3:]    ,							(vision_config.num_attention_heads, seq_len, seq_len)							)

										snake_case_      =				output.text_model_output.attentions
										self.assertEqual(len(a__							)    ,							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        lowerCAmelCase__    ( self    ,							a__    ,							a__							)    ->    List[Any]:

										'''simple docstring'''




										snake_case_      =				TFDeiTModel(a__    ,							name="vision_model"							)
										snake_case_      =				TFRobertaModel(a__    ,							name="text_model"							)
										return vision_model, text_model




			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




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

										snake_case_ ,				snake_case_ ,				snake_case_      =				vision_config_and_inputs

										(
										    (
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,								
										)      =				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 			_snake_case		(     lowercase_						,						unittest.TestCase							):




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




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

										return model, inputs




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				TFCLIPVisionModel(a__    ,							name="vision_model"							)
										snake_case_      =				TFBertModel(a__    ,							name="text_model"							)
										return vision_model, text_model




			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




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

										snake_case_ ,				snake_case_      =				vision_config_and_inputs

										(
										    (
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,				(
										    snake_case_				
										) ,								
										)      =				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 			_snake_case		(     unittest.TestCase							):




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Tuple:

										'''simple docstring'''




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

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

										snake_case_      =				model(**a__							)

										# 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])    ,							)

										snake_case_      =				np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]							)

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










'''simple docstring'''





import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin




class 			_snake_case		(     unittest.TestCase						,						lowercase_							):




			def        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				load_tool("text-classification"							)
										self.tool.setup()
										snake_case_      =				load_tool("text-classification"    ,							remote=a__							)




			def        lowerCAmelCase__    ( self							)    ->    str:

										'''simple docstring'''




										snake_case_      =				self.tool("That's quite cool"    ,							["positive", "negative"]							)
										self.assertEqual(a__    ,							"positive"							)




			def        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				self.remote_tool("That's quite cool"    ,							["positive", "negative"]							)
										self.assertEqual(a__    ,							"positive"							)




			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										snake_case_      =				self.tool(text="That's quite cool"    ,							labels=["positive", "negative"]							)
										self.assertEqual(a__    ,							"positive"							)




			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				self.remote_tool(text="That's quite cool"    ,							labels=["positive", "negative"]							)
										self.assertEqual(a__    ,							"positive"							)




