





"""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      __lowerCamelCase   (							a_     :		Optional[Any]							)			->      Union[str, Any]:
      if isinstance(a_ ,   collections.abc.Iterable							):
            return x
      return (x, x)






@require_flax
class 					_SCREAMING_SNAKE_CASE:




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      int:





             """simple docstring"""






             pass




       def     _UpperCamelCase     (						self							)			->      str:





             """simple docstring"""






             pass




       def     _UpperCamelCase     (						self							)			->      str:





             """simple docstring"""






             pass




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[int]						=  np.abs((a - b)							).max()
             self.assertLessEqual(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,f'''Difference between torch and flax is {diff} (>= {tol}).'''							)




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=None		,**SCREAMING_SNAKE_CASE__							)			->      Tuple:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :str						=  VisionTextDualEncoderConfig.from_vision_text_configs(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :str						=  FlaxVisionTextDualEncoderModel(SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :Optional[int]						=  model(input_ids=SCREAMING_SNAKE_CASE__		,pixel_values=SCREAMING_SNAKE_CASE__		,attention_mask=SCREAMING_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     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=None		,**SCREAMING_SNAKE_CASE__							)			->      List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Any						=  self.get_vision_text_model(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :List[str]						=  {'''vision_model''': vision_model, '''text_model''': text_model}
             __SCREAMING_SNAKE_CASE   :List[Any]						=  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  model(input_ids=SCREAMING_SNAKE_CASE__		,pixel_values=SCREAMING_SNAKE_CASE__		,attention_mask=SCREAMING_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     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=None		,**SCREAMING_SNAKE_CASE__							)			->      Union[str, Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :List[Any]						=  self.get_vision_text_model(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :Optional[int]						=  {'''vision_model''': vision_model, '''text_model''': text_model}
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  model(input_ids=SCREAMING_SNAKE_CASE__		,pixel_values=SCREAMING_SNAKE_CASE__		,attention_mask=SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :Dict						=  output[0]

             with tempfile.TemporaryDirectory() as tmpdirname:
                   model.save_pretrained(SCREAMING_SNAKE_CASE__							)
                   __SCREAMING_SNAKE_CASE   :Optional[int]						=  FlaxVisionTextDualEncoderModel.from_pretrained(SCREAMING_SNAKE_CASE__							)

                   __SCREAMING_SNAKE_CASE   :Optional[int]						=  model(input_ids=SCREAMING_SNAKE_CASE__		,pixel_values=SCREAMING_SNAKE_CASE__		,attention_mask=SCREAMING_SNAKE_CASE__							)
                   __SCREAMING_SNAKE_CASE   :Optional[int]						=  after_output[0]
                   __SCREAMING_SNAKE_CASE   :Tuple						=  np.amax(np.abs(out_a - out_a							)							)
                   self.assertLessEqual(SCREAMING_SNAKE_CASE__		,1E-3							)




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__=None		,**SCREAMING_SNAKE_CASE__							)			->      int:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Optional[int]						=  self.get_vision_text_model(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :str						=  {'''vision_model''': vision_model, '''text_model''': text_model}
             __SCREAMING_SNAKE_CASE   :List[Any]						=  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :Optional[int]						=  model(
                 input_ids=SCREAMING_SNAKE_CASE__		,pixel_values=SCREAMING_SNAKE_CASE__		,attention_mask=SCREAMING_SNAKE_CASE__		,output_attentions=SCREAMING_SNAKE_CASE__							)

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

             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  output.text_model_output.attentions
             self.assertEqual(len(SCREAMING_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     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      Any:





             """simple docstring"""






             pt_model.to(SCREAMING_SNAKE_CASE__							)
             pt_model.eval()

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

             with torch.no_grad():
                   __SCREAMING_SNAKE_CASE   :int						=  pt_model(**SCREAMING_SNAKE_CASE__							).to_tuple()

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

             # PT -> Flax
             with tempfile.TemporaryDirectory() as tmpdirname:
                   pt_model.save_pretrained(SCREAMING_SNAKE_CASE__							)
                   __SCREAMING_SNAKE_CASE   :List[str]						=  FlaxVisionTextDualEncoderModel.from_pretrained(SCREAMING_SNAKE_CASE__		,from_pt=SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :List[str]						=  fx_model_loaded(**SCREAMING_SNAKE_CASE__							).to_tuple()
             self.assertEqual(len(SCREAMING_SNAKE_CASE__							)		,len(SCREAMING_SNAKE_CASE__							)		,'''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(SCREAMING_SNAKE_CASE__		,pt_output.numpy()		,4E-2							)

             # Flax -> PT
             with tempfile.TemporaryDirectory() as tmpdirname:
                   fx_model.save_pretrained(SCREAMING_SNAKE_CASE__							)
                   __SCREAMING_SNAKE_CASE   :Optional[int]						=  VisionTextDualEncoderModel.from_pretrained(SCREAMING_SNAKE_CASE__		,from_flax=SCREAMING_SNAKE_CASE__							)

             pt_model_loaded.to(SCREAMING_SNAKE_CASE__							)
             pt_model_loaded.eval()

             with torch.no_grad():
                   __SCREAMING_SNAKE_CASE   :int						=  pt_model_loaded(**SCREAMING_SNAKE_CASE__							).to_tuple()

             self.assertEqual(len(SCREAMING_SNAKE_CASE__							)		,len(SCREAMING_SNAKE_CASE__							)		,'''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(SCREAMING_SNAKE_CASE__		,pt_output_loaded.numpy()		,4E-2							)




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      Optional[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :str						=  VisionTextDualEncoderConfig.from_vision_text_configs(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :str						=  VisionTextDualEncoderModel(SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :Dict						=  FlaxVisionTextDualEncoderModel(SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :str						=  convert_pytorch_state_dict_to_flax(pt_model.state_dict()		,SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :List[Any]						=  fx_state

             self.check_pt_flax_equivalence(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      int:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[int]						=  VisionTextDualEncoderConfig.from_vision_text_configs(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  VisionTextDualEncoderModel(SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :str						=  FlaxVisionTextDualEncoderModel(SCREAMING_SNAKE_CASE__							)

             __SCREAMING_SNAKE_CASE   :Dict						=  load_flax_weights_in_pytorch_model(SCREAMING_SNAKE_CASE__		,fx_model.params							)

             self.check_pt_flax_equivalence(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)




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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :str						=  self.prepare_config_and_inputs()
             self.check_model_from_pretrained_configs(**SCREAMING_SNAKE_CASE__							)




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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :str						=  self.prepare_config_and_inputs()
             self.check_vision_text_dual_encoder_from_pretrained(**SCREAMING_SNAKE_CASE__							)




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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Tuple						=  self.prepare_config_and_inputs()
             self.check_save_load(**SCREAMING_SNAKE_CASE__							)




       def     _UpperCamelCase     (						self							)			->      Any:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :str						=  self.prepare_config_and_inputs()
             self.check_vision_text_output_attention(**SCREAMING_SNAKE_CASE__							)




       @is_pt_flax_cross_test
       def     _UpperCamelCase     (						self							)			->      Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  self.prepare_config_and_inputs()
             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  config_inputs_dict.pop('''vision_config'''							)
             __SCREAMING_SNAKE_CASE   :List[Any]						=  config_inputs_dict.pop('''text_config'''							)

             __SCREAMING_SNAKE_CASE   :Dict						=  config_inputs_dict

             self.check_equivalence_pt_to_flax(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)
             self.check_equivalence_flax_to_pt(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)




       @slow
       def     _UpperCamelCase     (						self							)			->      Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :List[str]						=  self.get_pretrained_model_and_inputs()

             __SCREAMING_SNAKE_CASE   :int						=  model_a(**SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :Any						=  outputs[0]

             with tempfile.TemporaryDirectory() as tmp_dirname:
                   model_a.save_pretrained(SCREAMING_SNAKE_CASE__							)
                   __SCREAMING_SNAKE_CASE   :List[Any]						=  FlaxVisionTextDualEncoderModel.from_pretrained(SCREAMING_SNAKE_CASE__							)

                   __SCREAMING_SNAKE_CASE   :List[str]						=  model_a(**SCREAMING_SNAKE_CASE__							)
                   __SCREAMING_SNAKE_CASE   :str						=  after_outputs[0]
                   __SCREAMING_SNAKE_CASE   :List[Any]						=  np.amax(np.abs(out_a - out_a							)							)
                   self.assertLessEqual(SCREAMING_SNAKE_CASE__		,1E-5							)






@require_flax
class 					_SCREAMING_SNAKE_CASE(   A    ,	unittest.TestCase  ):




       def     _UpperCamelCase     (						self							)			->      Tuple:





             """simple docstring"""






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

             return model, inputs




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :str						=  FlaxViTModel(SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  FlaxBertModel(SCREAMING_SNAKE_CASE__							)
             return vision_model, text_model




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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  FlaxViTModelTester(self							)
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  FlaxBertModelTester(self							)
             __SCREAMING_SNAKE_CASE   :str						=  vit_model_tester.prepare_config_and_inputs()
             __SCREAMING_SNAKE_CASE   :str						=  bert_model_tester.prepare_config_and_inputs()

             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Dict						=  vision_config_and_inputs

             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Any						=  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(   A    ,	unittest.TestCase  ):




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





             """simple docstring"""






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

             return model, inputs




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      int:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  FlaxCLIPVisionModel(SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :List[Any]						=  FlaxBertModel(SCREAMING_SNAKE_CASE__							)
             return vision_model, text_model




       def     _UpperCamelCase     (						self							)			->      str:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[int]						=  FlaxCLIPVisionModelTester(self							)
             __SCREAMING_SNAKE_CASE   :Tuple						=  FlaxBertModelTester(self							)
             __SCREAMING_SNAKE_CASE   :str						=  clip_model_tester.prepare_config_and_inputs()
             __SCREAMING_SNAKE_CASE   :Tuple						=  bert_model_tester.prepare_config_and_inputs()

             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Dict						=  vision_config_and_inputs

             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :List[str]						=  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							)			->      Tuple:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :str						=  FlaxVisionTextDualEncoderModel.from_pretrained('''clip-italian/clip-italian'''		,logit_scale_init_value=1.0							)
             __SCREAMING_SNAKE_CASE   :Optional[int]						=  VisionTextDualEncoderProcessor.from_pretrained('''clip-italian/clip-italian'''							)

             __SCREAMING_SNAKE_CASE   :List[Any]						=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  processor(
                 text=['''una foto di un gatto''', '''una foto di un cane''']		,images=SCREAMING_SNAKE_CASE__		,padding=SCREAMING_SNAKE_CASE__		,return_tensors='''np'''							)

             __SCREAMING_SNAKE_CASE   :Tuple						=  model(**SCREAMING_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])		,)

             __SCREAMING_SNAKE_CASE   :List[Any]						=  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		,SCREAMING_SNAKE_CASE__		,atol=1E-3							)							)






"""simple docstring"""
import qiskit



def      __lowerCamelCase   (							a_     :		int ,   a_     :		int							)			->      qiskit.result.counts.Counts:
      __SCREAMING_SNAKE_CASE   :Tuple						=  qiskit.Aer.get_backend('''aer_simulator'''							)

      # Create a Quantum Circuit acting on the q register
      __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  qiskit.QuantumCircuit(a_ ,   a_							)

      # Apply X (NOT) Gate to Qubits 0 & 1
      circuit.x(0							)
      circuit.x(1							)

      # Map the quantum measurement to the classical bits
      circuit.measure([0, 1] ,   [0, 1]							)

      # Execute the circuit on the qasm simulator
      __SCREAMING_SNAKE_CASE   :Tuple						=  qiskit.execute(a_ ,   a_ ,   shots=10_00							)

      # Return the histogram data of the results of the experiment.
      return job.result().get_counts(a_							)


if __name__ == "__main__":
  lowerCamelCase_								=		single_qubit_measure(2, 2)
  print(f'Total count for various states are: {counts}')