
'''simple docstring'''
import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_flax_cross_test,
    require_flax,
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import is_flax_available, is_torch_available, is_vision_available

from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_flax_bert import FlaxBertModelTester
from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester
from ..vit.test_modeling_flax_vit import FlaxViTModelTester


if is_flax_available():
						from transformers import (
						    FlaxBertModel,
						    FlaxCLIPVisionModel,
						    FlaxVisionTextDualEncoderModel,
						    FlaxViTModel,
						    VisionTextDualEncoderConfig,
						    VisionTextDualEncoderProcessor,
						)
						from transformers.modeling_flax_pytorch_utils import (
						    convert_pytorch_state_dict_to_flax,
						    load_flax_weights_in_pytorch_model,
						)


if is_torch_available():
						import torch

						from transformers import VisionTextDualEncoderModel

if is_vision_available():
						from PIL import Image







def 		A_(     A						:		List[Any]):
							if isinstance(A		,     collections.abc.Iterable):
														return x
							return (x, x)


@require_flax
class 			SCREAMING_SNAKE_CASE__      :







				def 						UpperCAmelCase_    (       self						,				A_						,				A_     )->		Dict:







											'''simple docstring'''






											pass







				def 						UpperCAmelCase_    (       self     )->		str:







											'''simple docstring'''






											pass







				def 						UpperCAmelCase_    (       self     )->		int:







											'''simple docstring'''






											pass







				def 						UpperCAmelCase_    (       self						,				A_						,				A_						,				A_     )->		List[Any]:







											'''simple docstring'''






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







				def 						UpperCAmelCase_    (       self						,				A_						,				A_						,				A_						,				A_						,				A_=None						,				**A_     )->		Dict:







											'''simple docstring'''






											UpperCamelCase   			=     VisionTextDualEncoderConfig.from_vision_text_configs(A_						,				A_     )

											UpperCamelCase   			=     FlaxVisionTextDualEncoderModel(A_     )

											UpperCamelCase   			=     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 						UpperCAmelCase_    (       self						,				A_						,				A_						,				A_						,				A_						,				A_=None						,				**A_     )->		Dict:







											'''simple docstring'''






											UpperCamelCase			,	UpperCamelCase   			=     self.get_vision_text_model(A_						,				A_     )
											UpperCamelCase   			=     {'vision_model': vision_model, 'text_model': text_model}
											UpperCamelCase   			=     FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**A_     )

											UpperCamelCase   			=     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 						UpperCAmelCase_    (       self						,				A_						,				A_						,				A_						,				A_						,				A_=None						,				**A_     )->		Dict:







											'''simple docstring'''






											UpperCamelCase			,	UpperCamelCase   			=     self.get_vision_text_model(A_						,				A_     )
											UpperCamelCase   			=     {'vision_model': vision_model, 'text_model': text_model}
											UpperCamelCase   			=     FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**A_     )

											UpperCamelCase   			=     model(input_ids=A_						,				pixel_values=A_						,				attention_mask=A_     )
											UpperCamelCase   			=     output[0]

											with tempfile.TemporaryDirectory() as tmpdirname:
																		model.save_pretrained(A_     )
																		UpperCamelCase   			=     FlaxVisionTextDualEncoderModel.from_pretrained(A_     )

																		UpperCamelCase   			=     model(input_ids=A_						,				pixel_values=A_						,				attention_mask=A_     )
																		UpperCamelCase   			=     after_output[0]
																		UpperCamelCase   			=     np.amax(np.abs(out_a - out_a     )     )
																		self.assertLessEqual(A_						,				1e-3     )







				def 						UpperCAmelCase_    (       self						,				A_						,				A_						,				A_						,				A_						,				A_=None						,				**A_     )->		Union[str, Any]:







											'''simple docstring'''






											UpperCamelCase			,	UpperCamelCase   			=     self.get_vision_text_model(A_						,				A_     )
											UpperCamelCase   			=     {'vision_model': vision_model, 'text_model': text_model}
											UpperCamelCase   			=     FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**A_     )

											UpperCamelCase   			=     model(
											    input_ids=A_						,				pixel_values=A_						,				attention_mask=A_						,				output_attentions=A_     )

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

											UpperCamelCase   			=     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 						UpperCAmelCase_    (       self						,				A_						,				A_						,				A_     )->		str:







											'''simple docstring'''






											pt_model.to(A_     )
											pt_model.eval()

											# prepare inputs
											UpperCamelCase   			=     inputs_dict
											UpperCamelCase   			=     {k: torch.tensor(v.tolist()     ) for k, v in flax_inputs.items()}

											with torch.no_grad():
																		UpperCamelCase   			=     pt_model(**A_     ).to_tuple()

											UpperCamelCase   			=     fx_model(**A_     ).to_tuple()
											self.assertEqual(len(A_     )						,				len(A_     )						,				'Output lengths differ between Flax and PyTorch'     )
											for fx_output, pt_output in zip(fx_outputs[:4]						,				pt_outputs[:4]     ):
																		self.assert_almost_equals(A_						,				pt_output.numpy()						,				4e-2     )

											# PT -> Flax
											with tempfile.TemporaryDirectory() as tmpdirname:
																		pt_model.save_pretrained(A_     )
																		UpperCamelCase   			=     FlaxVisionTextDualEncoderModel.from_pretrained(A_						,				from_pt=A_     )

											UpperCamelCase   			=     fx_model_loaded(**A_     ).to_tuple()
											self.assertEqual(len(A_     )						,				len(A_     )						,				'Output lengths differ between Flax and PyTorch'     )
											for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4]						,				pt_outputs[:4]     ):
																		self.assert_almost_equals(A_						,				pt_output.numpy()						,				4e-2     )

											# Flax -> PT
											with tempfile.TemporaryDirectory() as tmpdirname:
																		fx_model.save_pretrained(A_     )
																		UpperCamelCase   			=     VisionTextDualEncoderModel.from_pretrained(A_						,				from_flax=A_     )

											pt_model_loaded.to(A_     )
											pt_model_loaded.eval()

											with torch.no_grad():
																		UpperCamelCase   			=     pt_model_loaded(**A_     ).to_tuple()

											self.assertEqual(len(A_     )						,				len(A_     )						,				'Output lengths differ between Flax and PyTorch'     )
											for fx_output, pt_output_loaded in zip(fx_outputs[:4]						,				pt_outputs_loaded[:4]     ):
																		self.assert_almost_equals(A_						,				pt_output_loaded.numpy()						,				4e-2     )







				def 						UpperCAmelCase_    (       self						,				A_						,				A_						,				A_     )->		List[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     VisionTextDualEncoderConfig.from_vision_text_configs(A_						,				A_     )

											UpperCamelCase   			=     VisionTextDualEncoderModel(A_     )
											UpperCamelCase   			=     FlaxVisionTextDualEncoderModel(A_     )

											UpperCamelCase   			=     convert_pytorch_state_dict_to_flax(pt_model.state_dict()						,				A_     )
											UpperCamelCase   			=     fx_state

											self.check_pt_flax_equivalence(A_						,				A_						,				A_     )







				def 						UpperCAmelCase_    (       self						,				A_						,				A_						,				A_     )->		List[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     VisionTextDualEncoderConfig.from_vision_text_configs(A_						,				A_     )

											UpperCamelCase   			=     VisionTextDualEncoderModel(A_     )
											UpperCamelCase   			=     FlaxVisionTextDualEncoderModel(A_     )

											UpperCamelCase   			=     load_flax_weights_in_pytorch_model(A_						,				fx_model.params     )

											self.check_pt_flax_equivalence(A_						,				A_						,				A_     )







				def 						UpperCAmelCase_    (       self     )->		Optional[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     self.prepare_config_and_inputs()
											self.check_model_from_pretrained_configs(**A_     )







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







											'''simple docstring'''






											UpperCamelCase   			=     self.prepare_config_and_inputs()
											self.check_vision_text_dual_encoder_from_pretrained(**A_     )







				def 						UpperCAmelCase_    (       self     )->		Optional[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     self.prepare_config_and_inputs()
											self.check_save_load(**A_     )







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







											'''simple docstring'''






											UpperCamelCase   			=     self.prepare_config_and_inputs()
											self.check_vision_text_output_attention(**A_     )







				@is_pt_flax_cross_test
				def 						UpperCAmelCase_    (       self     )->		Optional[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     self.prepare_config_and_inputs()
											UpperCamelCase   			=     config_inputs_dict.pop('vision_config'     )
											UpperCamelCase   			=     config_inputs_dict.pop('text_config'     )

											UpperCamelCase   			=     config_inputs_dict

											self.check_equivalence_pt_to_flax(A_						,				A_						,				A_     )
											self.check_equivalence_flax_to_pt(A_						,				A_						,				A_     )







				@slow
				def 						UpperCAmelCase_    (       self     )->		List[Any]:







											'''simple docstring'''






											UpperCamelCase			,	UpperCamelCase   			=     self.get_pretrained_model_and_inputs()

											UpperCamelCase   			=     model_a(**A_     )
											UpperCamelCase   			=     outputs[0]

											with tempfile.TemporaryDirectory() as tmp_dirname:
																		model_a.save_pretrained(A_     )
																		UpperCamelCase   			=     FlaxVisionTextDualEncoderModel.from_pretrained(A_     )

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


@require_flax
class 			SCREAMING_SNAKE_CASE__      (     snake_case_							,       unittest.TestCase):







				def 						UpperCAmelCase_    (       self     )->		str:







											'''simple docstring'''






											UpperCamelCase   			=     FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
											    'hf-internal-testing/tiny-random-vit'						,				'hf-internal-testing/tiny-bert'						,				vision_from_pt=A_						,				text_from_pt=A_						,				)
											UpperCamelCase   			=     13
											UpperCamelCase   			=     floats_tensor(
											    [
											        batch_size,
											        model.config.vision_config.num_channels,
											        model.config.vision_config.image_size,
											        model.config.vision_config.image_size,
											    ]     )
											UpperCamelCase   			=     ids_tensor([batch_size, 4]						,				model.config.text_config.vocab_size     )
											UpperCamelCase   			=     random_attention_mask([batch_size, 4]     )
											UpperCamelCase   			=     {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

											return model, inputs







				def 						UpperCAmelCase_    (       self						,				A_						,				A_     )->		Optional[int]:







											'''simple docstring'''






											UpperCamelCase   			=     FlaxViTModel(A_     )
											UpperCamelCase   			=     FlaxBertModel(A_     )
											return vision_model, text_model







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







											'''simple docstring'''






											UpperCamelCase   			=     FlaxViTModelTester(self     )
											UpperCamelCase   			=     FlaxBertModelTester(self     )
											UpperCamelCase   			=     vit_model_tester.prepare_config_and_inputs()
											UpperCamelCase   			=     bert_model_tester.prepare_config_and_inputs()

											UpperCamelCase			,	UpperCamelCase   			=     vision_config_and_inputs

											UpperCamelCase			,	UpperCamelCase			,	UpperCamelCase			,	UpperCamelCase   			=     text_config_and_inputs

											# make sure that cross attention layers are added
											return {
											    "text_config": text_config,
											    "vision_config": vision_config,
											    "pixel_values": pixel_values,
											    "attention_mask": attention_mask,
											    "input_ids": input_ids,
											    "token_type_ids": token_type_ids,
											}


@require_torch
class 			SCREAMING_SNAKE_CASE__      (     snake_case_							,       unittest.TestCase):







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







											'''simple docstring'''






											UpperCamelCase   			=     FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
											    'hf-internal-testing/tiny-random-clip'						,				'hf-internal-testing/tiny-bert'						,				vision_from_pt=A_						,				text_from_pt=A_						,				)
											UpperCamelCase   			=     13
											UpperCamelCase   			=     floats_tensor(
											    [
											        batch_size,
											        model.config.vision_config.num_channels,
											        model.config.vision_config.image_size,
											        model.config.vision_config.image_size,
											    ]     )
											UpperCamelCase   			=     ids_tensor([batch_size, 4]						,				model.config.text_config.vocab_size     )
											UpperCamelCase   			=     random_attention_mask([batch_size, 4]     )
											UpperCamelCase   			=     {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

											return model, inputs







				def 						UpperCAmelCase_    (       self						,				A_						,				A_     )->		List[str]:







											'''simple docstring'''






											UpperCamelCase   			=     FlaxCLIPVisionModel(A_     )
											UpperCamelCase   			=     FlaxBertModel(A_     )
											return vision_model, text_model







				def 						UpperCAmelCase_    (       self     )->		Tuple:







											'''simple docstring'''






											UpperCamelCase   			=     FlaxCLIPVisionModelTester(self     )
											UpperCamelCase   			=     FlaxBertModelTester(self     )
											UpperCamelCase   			=     clip_model_tester.prepare_config_and_inputs()
											UpperCamelCase   			=     bert_model_tester.prepare_config_and_inputs()

											UpperCamelCase			,	UpperCamelCase   			=     vision_config_and_inputs

											UpperCamelCase			,	UpperCamelCase			,	UpperCamelCase			,	UpperCamelCase   			=     text_config_and_inputs

											# make sure that cross attention layers are added
											return {
											    "text_config": text_config,
											    "vision_config": vision_config,
											    "pixel_values": pixel_values,
											    "attention_mask": attention_mask,
											    "input_ids": input_ids,
											    "token_type_ids": token_type_ids,
											}


@require_flax
@require_vision
class 			SCREAMING_SNAKE_CASE__      (     unittest.TestCase):







				@slow
				def 						UpperCAmelCase_    (       self     )->		List[str]:







											'''simple docstring'''






											UpperCamelCase   			=     FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian'						,				logit_scale_init_value=1.0     )
											UpperCamelCase   			=     VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian'     )

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

											UpperCamelCase   			=     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])						,				)

											UpperCamelCase   			=     np.array([[1.2_284_727, 0.3_104_122]]     )

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






'''simple docstring'''

# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool




class    lowerCAmelCase       (     UpperCamelCase_  ):
 A_				:				int	=			"""openai/whisper-base"""
 A_				:				str	=			(
     """This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the """
     """transcribed text."""
 )
 A_				:				Union[str, Any]	=			"""transcriber"""
 A_				:				Tuple	=			WhisperProcessor
 A_				:				Dict	=			WhisperForConditionalGeneration

 A_				:				Tuple	=			["""audio"""]
 A_				:				Optional[int]	=			["""text"""]


 def    _A	(    self  : Optional[int]			,							a__  : Optional[int]    ):
  '''simple docstring'''

  return self.pre_processor(a__			,							return_tensors="pt"    ).input_features


 def    _A	(    self  : List[str]			,							a__  : Union[str, Any]    ):
  '''simple docstring'''

  return self.model.generate(inputs=a__    )


 def    _A	(    self  : Optional[Any]			,							a__  : Dict    ):
  '''simple docstring'''

  return self.pre_processor.batch_decode(a__			,							skip_special_tokens=a__    )[0]





