





"""simple docstring"""





import numpy

# List of input, output pairs
_UpperCamelCase							=      (
    ((5, 2, 3), 15),
    ((6, 5, 9), 25),
    ((11, 12, 13), 41),
    ((1, 1, 1), 8),
    ((11, 12, 13), 41),
)
_UpperCamelCase							=      (((515, 22, 13), 555), ((61, 35, 49), 150))
_UpperCamelCase							=      [2, 4, 1, 5]
_UpperCamelCase							=      len(train_data)
_UpperCamelCase							=      0.009



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Dict    ,						SCREAMING_SNAKE_CASE       :							Optional[int]="train"   ):


							'''simple docstring'''







							return calculate_hypothesis_value(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   ) - output(
							    SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   )



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							str   ):


							'''simple docstring'''







							__lowerCamelCase      :      Tuple         =0
							for i in range(len(SCREAMING_SNAKE_CASE   ) - 1   ):
														hyp_val += data_input_tuple[i] * parameter_vector[i + 1]
							hyp_val += parameter_vector[0]
							return hyp_val



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Tuple    ,						SCREAMING_SNAKE_CASE       :							Dict   ):


							'''simple docstring'''







							if data_set == "train":
														return train_data[example_no][1]
							elif data_set == "test":
														return test_data[example_no][1]
							return None



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Optional[int]    ,						SCREAMING_SNAKE_CASE       :							List[str]   ):


							'''simple docstring'''







							if data_set == "train":
														return _hypothesis_value(train_data[example_no][0]   )
							elif data_set == "test":
														return _hypothesis_value(test_data[example_no][0]   )
							return None



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Union[str, Any]    ,						SCREAMING_SNAKE_CASE       :							Union[str, Any]=m   ):


							'''simple docstring'''







							__lowerCamelCase      :      Union[str, Any]         =0
							for i in range(SCREAMING_SNAKE_CASE   ):
														if index == -1:
																					summation_value += _error(SCREAMING_SNAKE_CASE   )
														else:
																					summation_value += _error(SCREAMING_SNAKE_CASE   ) * train_data[i][0][index]
							return summation_value



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Union[str, Any]   ):


							'''simple docstring'''







							__lowerCamelCase      :      Optional[int]         =summation_of_cost_derivative(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   ) / m
							return cost_derivative_value



def 				lowerCAmelCase_			(      ):


							'''simple docstring'''







							global parameter_vector
							# Tune these values to set a tolerance value for predicted output
							__lowerCamelCase      :      str         =0.000_002
							__lowerCamelCase      :      Tuple         =0
							__lowerCamelCase      :      str         =0
							while True:
														j += 1
														__lowerCamelCase      :      List[str]         =[0, 0, 0, 0]
														for i in range(0    ,						len(SCREAMING_SNAKE_CASE   )   ):
																					__lowerCamelCase      :      Dict         =get_cost_derivative(i - 1   )
																					__lowerCamelCase      :      List[Any]         =(
																					    parameter_vector[i] - LEARNING_RATE * cost_derivative
																					)
														if numpy.allclose(
														    SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE    ,						atol=SCREAMING_SNAKE_CASE    ,						rtol=SCREAMING_SNAKE_CASE    ,						):
																					break
														__lowerCamelCase      :      Optional[Any]         =temp_parameter_vector
							print(('''Number of iterations:''', j)   )



def 				lowerCAmelCase_			(      ):


							'''simple docstring'''







							for i in range(len(SCREAMING_SNAKE_CASE   )   ):
														print(('''Actual output value:''', output(SCREAMING_SNAKE_CASE    ,						'''test'''   ))   )
														print(('''Hypothesis output:''', calculate_hypothesis_value(SCREAMING_SNAKE_CASE    ,						'''test'''   ))   )


if __name__ == "__main__":
							run_gradient_descent()
							print('\nTesting gradient descent for a linear hypothesis function.\n')
							test_gradient_descent()











"""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 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Optional[int]   ):


							'''simple docstring'''







							if isinstance(SCREAMING_SNAKE_CASE    ,						collections.abc.Iterable   ):
														return x
							return (x, x)
@require_tf
class 		SCREAMING_SNAKE_CASE_							:
				"""simple docstring"""




				def 					__lowercase  (     self  :Optional[int]						,    __lowercase  :Union[str, Any]						,    __lowercase  :List[Any]			):
											pass




				def 					__lowercase  (     self  :Any			):
											pass




				def 					__lowercase  (     self  :str			):
											pass




				def 					__lowercase  (     self  :str						,    __lowercase  :Dict						,    __lowercase  :List[Any]						,    __lowercase  :Union[str, Any]						,    __lowercase  :Union[str, Any]						,    __lowercase  :Any=None						,    **__lowercase  :Tuple			):
											__lowerCamelCase      :      Optional[Any]         =VisionTextDualEncoderConfig.from_vision_text_configs(__lowercase						,    __lowercase			)

											__lowerCamelCase      :      Dict         =TFVisionTextDualEncoderModel(__lowercase			)

											__lowerCamelCase      :      List[Any]         =model(input_ids=__lowercase						,    pixel_values=__lowercase						,    attention_mask=__lowercase			)

											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 					__lowercase  (     self  :str						,    __lowercase  :Any						,    __lowercase  :Dict						,    __lowercase  :Any						,    __lowercase  :int						,    __lowercase  :str=None						,    **__lowercase  :List[str]			):
											__lowerCamelCase    ,						__lowerCamelCase      :      Any         =self.get_vision_text_model(__lowercase						,    __lowercase			)
											__lowerCamelCase      :      List[str]         =TFVisionTextDualEncoderModel(vision_model=__lowercase						,    text_model=__lowercase			)

											__lowerCamelCase      :      Optional[int]         =model(input_ids=__lowercase						,    pixel_values=__lowercase						,    attention_mask=__lowercase			)

											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 					__lowercase  (     self  :int						,    __lowercase  :Dict						,    __lowercase  :List[Any]						,    __lowercase  :Any						,    __lowercase  :Optional[Any]						,    __lowercase  :Tuple=None						,    **__lowercase  :List[Any]			):
											__lowerCamelCase    ,						__lowerCamelCase      :      int         =self.get_vision_text_model(__lowercase						,    __lowercase			)
											__lowerCamelCase      :      Dict         ={'''vision_model''': vision_model, '''text_model''': text_model}
											__lowerCamelCase      :      List[Any]         =TFVisionTextDualEncoderModel.from_vision_text_pretrained(**__lowercase			)

											__lowerCamelCase      :      Optional[Any]         =model(input_ids=__lowercase						,    pixel_values=__lowercase						,    attention_mask=__lowercase			)

											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 					__lowercase  (     self  :Optional[Any]						,    __lowercase  :Dict						,    __lowercase  :int						,    __lowercase  :Dict						,    __lowercase  :List[Any]						,    __lowercase  :Tuple=None						,    **__lowercase  :Optional[Any]			):
											__lowerCamelCase    ,						__lowerCamelCase      :      Tuple         =self.get_vision_text_model(__lowercase						,    __lowercase			)
											__lowerCamelCase      :      List[Any]         =TFVisionTextDualEncoderModel(vision_model=__lowercase						,    text_model=__lowercase			)

											__lowerCamelCase      :      Any         =model(input_ids=__lowercase						,    pixel_values=__lowercase						,    attention_mask=__lowercase			)
											__lowerCamelCase      :      Optional[Any]         =output[0].numpy()

											with tempfile.TemporaryDirectory() as tmpdirname:
																		model.save_pretrained(__lowercase			)
																		__lowerCamelCase      :      Dict         =TFVisionTextDualEncoderModel.from_pretrained(__lowercase			)

																		__lowerCamelCase      :      Optional[Any]         =model(input_ids=__lowercase						,    pixel_values=__lowercase						,    attention_mask=__lowercase			)
																		__lowerCamelCase      :      Any         =after_output[0].numpy()
																		__lowerCamelCase      :      Tuple         =np.amax(np.abs(out_a - out_a			)			)
																		self.assertLessEqual(__lowercase						,    1e-5			)




				def 					__lowercase  (     self  :int						,    __lowercase  :Any						,    __lowercase  :List[Any]						,    __lowercase  :Any						,    __lowercase  :str						,    __lowercase  :int=None						,    **__lowercase  :List[Any]			):
											__lowerCamelCase    ,						__lowerCamelCase      :      Any         =self.get_vision_text_model(__lowercase						,    __lowercase			)
											__lowerCamelCase      :      Union[str, Any]         =TFVisionTextDualEncoderModel(vision_model=__lowercase						,    text_model=__lowercase			)

											__lowerCamelCase      :      Any         =model(
											    input_ids=__lowercase						,    pixel_values=__lowercase						,    attention_mask=__lowercase						,    output_attentions=__lowercase			)

											__lowerCamelCase      :      Optional[Any]         =output.vision_model_output.attentions
											self.assertEqual(len(__lowercase			)						,    vision_config.num_hidden_layers			)

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

											__lowerCamelCase      :      List[Any]         =output.text_model_output.attentions
											self.assertEqual(len(__lowercase			)						,    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 					__lowercase  (     self  :List[Any]						,    __lowercase  :np.ndarray						,    __lowercase  :np.ndarray						,    __lowercase  :float			):
											__lowerCamelCase      :      Dict         =np.abs((a - b)			).max()
											self.assertLessEqual(__lowercase						,    __lowercase						,    f'Difference between torch and flax is {diff} (>= {tol}).'			)




				def 					__lowercase  (     self  :List[str]			):
											__lowerCamelCase      :      Any         =self.prepare_config_and_inputs()
											self.check_vision_text_dual_encoder_model(**__lowercase			)




				def 					__lowercase  (     self  :Tuple			):
											__lowerCamelCase      :      List[Any]         =self.prepare_config_and_inputs()
											self.check_model_from_pretrained_configs(**__lowercase			)




				def 					__lowercase  (     self  :Union[str, Any]			):
											__lowerCamelCase      :      Dict         =self.prepare_config_and_inputs()
											self.check_vision_text_dual_encoder_from_pretrained(**__lowercase			)




				def 					__lowercase  (     self  :Any			):
											__lowerCamelCase      :      List[Any]         =self.prepare_config_and_inputs()
											self.check_save_load(**__lowercase			)




				def 					__lowercase  (     self  :List[str]			):
											__lowerCamelCase      :      Any         =self.prepare_config_and_inputs()
											self.check_vision_text_output_attention(**__lowercase			)




				@slow
				def 					__lowercase  (     self  :Tuple			):
											__lowerCamelCase    ,						__lowerCamelCase      :      Optional[Any]         =self.get_pretrained_model_and_inputs()

											__lowerCamelCase      :      Optional[Any]         =model_a(**__lowercase			)
											__lowerCamelCase      :      int         =outputs[0].numpy()

											with tempfile.TemporaryDirectory() as tmp_dirname:
																		model_a.save_pretrained(__lowercase			)
																		__lowerCamelCase      :      List[Any]         =TFVisionTextDualEncoderModel.from_pretrained(__lowercase			)

																		__lowerCamelCase      :      Tuple         =model_a(**__lowercase			)
																		__lowerCamelCase      :      Optional[int]         =after_outputs[0].numpy()
																		__lowerCamelCase      :      Optional[Any]         =np.amax(np.abs(out_a - out_a			)			)
																		self.assertLessEqual(__lowercase						,    1e-5			)

@require_tf
class 		SCREAMING_SNAKE_CASE_							(    snake_case__       ,  unittest.TestCase   ):
				"""simple docstring"""




				def 					__lowercase  (     self  :List[Any]			):
											__lowerCamelCase      :      Union[str, Any]         =TFVisionTextDualEncoderModel.from_vision_text_pretrained(
											    '''hf-internal-testing/tiny-random-vit'''						,    '''hf-internal-testing/tiny-random-bert'''			)
											__lowerCamelCase      :      Any         =13
											__lowerCamelCase      :      Optional[int]         =floats_tensor(
											    [
											        batch_size,
											        model.vision_model.config.num_channels,
											        model.vision_model.config.image_size,
											        model.vision_model.config.image_size,
											    ]			)
											__lowerCamelCase      :      Dict         =ids_tensor([batch_size, 4]						,    model.text_model.config.vocab_size			)
											__lowerCamelCase      :      Optional[Any]         =random_attention_mask([batch_size, 4]			)
											__lowerCamelCase      :      Dict         ={'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask}

											return model, inputs




				def 					__lowercase  (     self  :Optional[Any]						,    __lowercase  :List[Any]						,    __lowercase  :List[str]			):
											__lowerCamelCase      :      Optional[Any]         =TFViTModel(__lowercase						,    name='''vision_model'''			)
											__lowerCamelCase      :      Union[str, Any]         =TFBertModel(__lowercase						,    name='''text_model'''			)
											return vision_model, text_model




				def 					__lowercase  (     self  :Union[str, Any]			):
											__lowerCamelCase      :      str         =TFViTModelTester(self			)
											__lowerCamelCase      :      Any         =TFBertModelTester(self			)
											__lowerCamelCase      :      Optional[Any]         =vit_model_tester.prepare_config_and_inputs()
											__lowerCamelCase      :      Tuple         =bert_model_tester.prepare_config_and_inputs()

											__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase      :      Dict         =vision_config_and_inputs

											(
											    (
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						
											)      :      int         =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 		SCREAMING_SNAKE_CASE_							(    snake_case__       ,  unittest.TestCase   ):
				"""simple docstring"""




				def 					__lowercase  (     self  :Optional[Any]			):
											# DeiT repo doesn't have TF weights, but we don't actually use the weights at all so let's
											# just reinitialize it.
											__lowerCamelCase      :      List[Any]         =TFVisionTextDualEncoderModel.from_vision_text_pretrained(
											    '''Rocketknight1/tiny-random-deit-tf'''						,    '''hf-internal-testing/tiny-random-roberta'''			)
											__lowerCamelCase      :      Tuple         =13
											__lowerCamelCase      :      str         =floats_tensor(
											    [
											        batch_size,
											        model.vision_model.config.num_channels,
											        model.vision_model.config.image_size,
											        model.vision_model.config.image_size,
											    ]			)
											__lowerCamelCase      :      Any         =ids_tensor([batch_size, 4]						,    model.text_model.config.vocab_size			)
											__lowerCamelCase      :      Optional[int]         =random_attention_mask([batch_size, 4]			)
											__lowerCamelCase      :      Optional[Any]         ={'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask}

											return model, inputs




				def 					__lowercase  (     self  :Any						,    __lowercase  :Tuple						,    __lowercase  :List[Any]						,    __lowercase  :Union[str, Any]						,    __lowercase  :Any						,    __lowercase  :int=None						,    **__lowercase  :List[str]			):
											__lowerCamelCase    ,						__lowerCamelCase      :      Union[str, Any]         =self.get_vision_text_model(__lowercase						,    __lowercase			)
											__lowerCamelCase      :      Optional[int]         =TFVisionTextDualEncoderModel(vision_model=__lowercase						,    text_model=__lowercase			)

											__lowerCamelCase      :      Any         =model(
											    input_ids=__lowercase						,    pixel_values=__lowercase						,    attention_mask=__lowercase						,    output_attentions=__lowercase			)

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

											__lowerCamelCase      :      Any         =output.text_model_output.attentions
											self.assertEqual(len(__lowercase			)						,    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 					__lowercase  (     self  :Any						,    __lowercase  :Any						,    __lowercase  :Optional[Any]			):
											__lowerCamelCase      :      str         =TFDeiTModel(__lowercase						,    name='''vision_model'''			)
											__lowerCamelCase      :      List[str]         =TFRobertaModel(__lowercase						,    name='''text_model'''			)
											return vision_model, text_model




				def 					__lowercase  (     self  :Dict			):
											__lowerCamelCase      :      Optional[int]         =TFDeiTModelTester(self			)
											__lowerCamelCase      :      Any         =TFRobertaModelTester(self			)
											__lowerCamelCase      :      Dict         =vit_model_tester.prepare_config_and_inputs()
											__lowerCamelCase      :      Optional[int]         =bert_model_tester.prepare_config_and_inputs()

											__lowerCamelCase    ,						__lowerCamelCase    ,						__lowerCamelCase      :      Optional[int]         =vision_config_and_inputs

											(
											    (
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						
											)      :      List[Any]         =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 		SCREAMING_SNAKE_CASE_							(    snake_case__       ,  unittest.TestCase   ):
				"""simple docstring"""




				def 					__lowercase  (     self  :Tuple			):
											__lowerCamelCase      :      str         =TFVisionTextDualEncoderModel.from_vision_text_pretrained(
											    '''Rocketknight1/tiny-random-clip-tf'''						,    '''hf-internal-testing/tiny-random-bert'''			)
											__lowerCamelCase      :      str         =13
											__lowerCamelCase      :      int         =floats_tensor(
											    [
											        batch_size,
											        model.vision_model.config.num_channels,
											        model.vision_model.config.image_size,
											        model.vision_model.config.image_size,
											    ]			)
											__lowerCamelCase      :      int         =ids_tensor([batch_size, 4]						,    model.text_model.config.vocab_size			)
											__lowerCamelCase      :      str         =random_attention_mask([batch_size, 4]			)
											__lowerCamelCase      :      Optional[Any]         ={'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask}

											return model, inputs




				def 					__lowercase  (     self  :List[Any]						,    __lowercase  :str						,    __lowercase  :Tuple			):
											__lowerCamelCase      :      int         =TFCLIPVisionModel(__lowercase						,    name='''vision_model'''			)
											__lowerCamelCase      :      Optional[Any]         =TFBertModel(__lowercase						,    name='''text_model'''			)
											return vision_model, text_model




				def 					__lowercase  (     self  :Tuple			):
											__lowerCamelCase      :      List[str]         =TFCLIPVisionModelTester(self			)
											__lowerCamelCase      :      Union[str, Any]         =TFBertModelTester(self			)
											__lowerCamelCase      :      str         =clip_model_tester.prepare_config_and_inputs()
											__lowerCamelCase      :      Tuple         =bert_model_tester.prepare_config_and_inputs()

											__lowerCamelCase    ,						__lowerCamelCase      :      Any         =vision_config_and_inputs

											(
											    (
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						(
											    __lowerCamelCase
											)    ,						
											)      :      str         =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 		SCREAMING_SNAKE_CASE_							(    unittest.TestCase   ):
				"""simple docstring"""




				@slow
				def 					__lowercase  (     self  :List[Any]			):
											__lowerCamelCase      :      Union[str, Any]         =TFVisionTextDualEncoderModel.from_pretrained(
											    '''clip-italian/clip-italian'''						,    logit_scale_init_value=1.0						,    from_pt=__lowercase			)
											__lowerCamelCase      :      str         =VisionTextDualEncoderProcessor.from_pretrained('''clip-italian/clip-italian'''			)

											__lowerCamelCase      :      Optional[Any]         =Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
											__lowerCamelCase      :      int         =processor(
											    text=['''una foto di un gatto''', '''una foto di un cane''']						,    images=__lowercase						,    padding=__lowercase						,    return_tensors='''np'''			)

											__lowerCamelCase      :      str         =model(**__lowercase			)

											# 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      :      int         =np.array([[1.2284727, 0.3104122]]			)

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




