





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       __UpperCamelCase  (_SCREAMING_SNAKE_CASE		)    ->       Optional[Any]:
  if isinstance(_SCREAMING_SNAKE_CASE		,						collections.abc.Iterable		):
    return x
  return (x, x)
@require_flax
class     SCREAMING_SNAKE_CASE       :


   def 	SCREAMING_SNAKE_CASE_							(   self      :    int      ,					a      :    Dict      ,					a      :    Any	)->       Union[str, Any]:





     """simple docstring"""







     pass


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





     """simple docstring"""







     pass


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Any	)->       Any:





     """simple docstring"""







     pass


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Union[str, Any]      ,					a      :    np.ndarray      ,					a      :    np.ndarray      ,					a      :    float	)->       Optional[Any]:





     """simple docstring"""







     lowercase__           =  np.abs((a - b)	).max()
     self.assertLessEqual(a      ,					a      ,					f"""Difference between torch and flax is {diff} (>= {tol})."""	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[str]      ,					a      :    int      ,					a      :    List[Any]      ,					a      :    Optional[Any]      ,					a      :    List[Any]      ,					a      :    Optional[Any]=None      ,					**a      :    Tuple	)->       Dict:





     """simple docstring"""







     lowercase__           =  VisionTextDualEncoderConfig.from_vision_text_configs(a      ,					a	)

     lowercase__           =  FlaxVisionTextDualEncoderModel(a	)

     lowercase__           =  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 	SCREAMING_SNAKE_CASE_							(   self      :    Dict      ,					a      :    int      ,					a      :    List[Any]      ,					a      :    Dict      ,					a      :    List[str]      ,					a      :    Tuple=None      ,					**a      :    List[str]	)->       Optional[int]:





     """simple docstring"""







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

     lowercase__           =  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 	SCREAMING_SNAKE_CASE_							(   self      :    int      ,					a      :    int      ,					a      :    Dict      ,					a      :    Optional[int]      ,					a      :    int      ,					a      :    int=None      ,					**a      :    List[str]	)->       Optional[Any]:





     """simple docstring"""







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

     lowercase__           =  model(input_ids=a      ,					pixel_values=a      ,					attention_mask=a	)
     lowercase__           =  output[0]

     with tempfile.TemporaryDirectory() as tmpdirname:
       model.save_pretrained(a	)
       lowercase__           =  FlaxVisionTextDualEncoderModel.from_pretrained(a	)

       lowercase__           =  model(input_ids=a      ,					pixel_values=a      ,					attention_mask=a	)
       lowercase__           =  after_output[0]
       lowercase__           =  np.amax(np.abs(out_a - out_a	)	)
       self.assertLessEqual(a      ,					1E-3	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    int      ,					a      :    List[Any]      ,					a      :    Dict      ,					a      :    List[Any]      ,					a      :    Union[str, Any]      ,					a      :    Union[str, Any]=None      ,					**a      :    str	)->       List[Any]:





     """simple docstring"""







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

     lowercase__           =  model(
         input_ids=a      ,					pixel_values=a      ,					attention_mask=a      ,					output_attentions=a	)

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

     lowercase__           =  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 	SCREAMING_SNAKE_CASE_							(   self      :    Dict      ,					a      :    Tuple      ,					a      :    Tuple      ,					a      :    int	)->       Any:





     """simple docstring"""







     pt_model.to(a	)
     pt_model.eval()

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

     with torch.no_grad():
       lowercase__           =  pt_model(**a	).to_tuple()

     lowercase__           =  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	)
       lowercase__           =  FlaxVisionTextDualEncoderModel.from_pretrained(a      ,					from_pt=a	)

     lowercase__           =  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	)
       lowercase__           =  VisionTextDualEncoderModel.from_pretrained(a      ,					from_flax=a	)

     pt_model_loaded.to(a	)
     pt_model_loaded.eval()

     with torch.no_grad():
       lowercase__           =  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 	SCREAMING_SNAKE_CASE_							(   self      :    List[Any]      ,					a      :    int      ,					a      :    int      ,					a      :    List[Any]	)->       int:





     """simple docstring"""







     lowercase__           =  VisionTextDualEncoderConfig.from_vision_text_configs(a      ,					a	)

     lowercase__           =  VisionTextDualEncoderModel(a	)
     lowercase__           =  FlaxVisionTextDualEncoderModel(a	)

     lowercase__           =  convert_pytorch_state_dict_to_flax(pt_model.state_dict()      ,					a	)
     lowercase__           =  fx_state

     self.check_pt_flax_equivalence(a      ,					a      ,					a	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    str      ,					a      :    Union[str, Any]      ,					a      :    List[str]      ,					a      :    int	)->       int:





     """simple docstring"""







     lowercase__           =  VisionTextDualEncoderConfig.from_vision_text_configs(a      ,					a	)

     lowercase__           =  VisionTextDualEncoderModel(a	)
     lowercase__           =  FlaxVisionTextDualEncoderModel(a	)

     lowercase__           =  load_flax_weights_in_pytorch_model(a      ,					fx_model.params	)

     self.check_pt_flax_equivalence(a      ,					a      ,					a	)


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





     """simple docstring"""







     lowercase__           =  self.prepare_config_and_inputs()
     self.check_model_from_pretrained_configs(**a	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    str	)->       List[Any]:





     """simple docstring"""







     lowercase__           =  self.prepare_config_and_inputs()
     self.check_vision_text_dual_encoder_from_pretrained(**a	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Optional[Any]	)->       Dict:





     """simple docstring"""







     lowercase__           =  self.prepare_config_and_inputs()
     self.check_save_load(**a	)


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[str]	)->       Optional[Any]:





     """simple docstring"""







     lowercase__           =  self.prepare_config_and_inputs()
     self.check_vision_text_output_attention(**a	)


   @is_pt_flax_cross_test
   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[Any]	)->       Any:





     """simple docstring"""







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

     lowercase__           =  config_inputs_dict

     self.check_equivalence_pt_to_flax(a      ,					a      ,					a	)
     self.check_equivalence_flax_to_pt(a      ,					a      ,					a	)


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





     """simple docstring"""







     lowercase__      ,   lowercase__           =  self.get_pretrained_model_and_inputs()

     lowercase__           =  model_a(**a	)
     lowercase__           =  outputs[0]

     with tempfile.TemporaryDirectory() as tmp_dirname:
       model_a.save_pretrained(a	)
       lowercase__           =  FlaxVisionTextDualEncoderModel.from_pretrained(a	)

       lowercase__           =  model_a(**a	)
       lowercase__           =  after_outputs[0]
       lowercase__           =  np.amax(np.abs(out_a - out_a	)	)
       self.assertLessEqual(a      ,					1E-5	)






@require_flax
class     SCREAMING_SNAKE_CASE       (UpperCAmelCase      ,     unittest.TestCase				):


   def 	SCREAMING_SNAKE_CASE_							(   self      :    str	)->       Dict:





     """simple docstring"""







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

     return model, inputs


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Union[str, Any]      ,					a      :    Union[str, Any]      ,					a      :    Tuple	)->       Optional[Any]:





     """simple docstring"""







     lowercase__           =  FlaxViTModel(a	)
     lowercase__           =  FlaxBertModel(a	)
     return vision_model, text_model


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Tuple	)->       List[str]:





     """simple docstring"""







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

     lowercase__      ,   lowercase__           =  vision_config_and_inputs

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


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





     """simple docstring"""







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

     return model, inputs


   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[Any]      ,					a      :    List[Any]      ,					a      :    Any	)->       Tuple:





     """simple docstring"""







     lowercase__           =  FlaxCLIPVisionModel(a	)
     lowercase__           =  FlaxBertModel(a	)
     return vision_model, text_model


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Any	)->       str:





     """simple docstring"""







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

     lowercase__      ,   lowercase__           =  vision_config_and_inputs

     lowercase__      ,   lowercase__      ,   lowercase__      ,   lowercase__           =  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 	SCREAMING_SNAKE_CASE_							(   self      :    Any	)->       List[Any]:





     """simple docstring"""







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

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

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

     lowercase__           =  np.array([[1.2284727, 0.3104122]]	)

     self.assertTrue(np.allclose(outputs.logits_per_image      ,					a      ,					atol=1E-3	)	)









import sys

lowercase_          =		(
    """73167176531330624919225119674426574742355349194934"""
    """96983520312774506326239578318016984801869478851843"""
    """85861560789112949495459501737958331952853208805511"""
    """12540698747158523863050715693290963295227443043557"""
    """66896648950445244523161731856403098711121722383113"""
    """62229893423380308135336276614282806444486645238749"""
    """30358907296290491560440772390713810515859307960866"""
    """70172427121883998797908792274921901699720888093776"""
    """65727333001053367881220235421809751254540594752243"""
    """52584907711670556013604839586446706324415722155397"""
    """53697817977846174064955149290862569321978468622482"""
    """83972241375657056057490261407972968652414535100474"""
    """82166370484403199890008895243450658541227588666881"""
    """16427171479924442928230863465674813919123162824586"""
    """17866458359124566529476545682848912883142607690042"""
    """24219022671055626321111109370544217506941658960408"""
    """07198403850962455444362981230987879927244284909188"""
    """84580156166097919133875499200524063689912560717606"""
    """05886116467109405077541002256983155200055935729725"""
    """71636269561882670428252483600823257530420752963450"""
)




def       __UpperCamelCase  (_SCREAMING_SNAKE_CASE = N		)    ->       int:
  lowercase__           =  -sys.maxsize - 1
  for i in range(len(_SCREAMING_SNAKE_CASE		) - 12		):
    lowercase__           =  1
    for j in range(13		):
      product *= int(n[i + j]		)
    if product > largest_product:
      lowercase__           =  product
  return largest_product


if __name__ == "__main__":
      print(f'''{solution() = }''')


