




import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


lowercase_             =     1e-4

if is_torch_available():
  import torch

  from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
  from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder





@require_torch
class 				__lowerCAmelCase  :




  def __init__(       self							,     lowerCAmelCase							,     lowerCAmelCase=16							,     lowerCAmelCase=13							,     lowerCAmelCase=7							,     lowerCAmelCase=14							,     lowerCAmelCase=10							,     lowerCAmelCase=19							,     lowerCAmelCase=5							,     lowerCAmelCase=4							,     lowerCAmelCase=True							,     lowerCAmelCase=16							,     lowerCAmelCase=2							,     lowerCAmelCase=4							,     lowerCAmelCase=4							,     lowerCAmelCase="gelu"							,     lowerCAmelCase=0.1							,     lowerCAmelCase=0.1							,     lowerCAmelCase=[1, 2, 3, 4, 5]							,     lowerCAmelCase=25							,     lowerCAmelCase=5							,     )						->				Dict:
        '''simple docstring'''






        _lowercase			 =d_model
        _lowercase			 =parent
        _lowercase			 =batch_size
        _lowercase			 =prediction_length
        _lowercase			 =context_length
        _lowercase			 =cardinality
        _lowercase			 =num_time_features
        _lowercase			 =lags_sequence
        _lowercase			 =embedding_dimension
        _lowercase			 =is_training
        _lowercase			 =hidden_size
        _lowercase			 =num_hidden_layers
        _lowercase			 =num_attention_heads
        _lowercase			 =intermediate_size
        _lowercase			 =hidden_act
        _lowercase			 =hidden_dropout_prob
        _lowercase			 =attention_probs_dropout_prob

        _lowercase			 =context_length
        _lowercase			 =prediction_length + label_length
        _lowercase			 =label_length

        _lowercase			 =moving_average
        _lowercase			 =autocorrelation_factor




  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        return AutoformerConfig(
            d_model=self.d_model							,     encoder_layers=self.num_hidden_layers							,     decoder_layers=self.num_hidden_layers							,     encoder_attention_heads=self.num_attention_heads							,     decoder_attention_heads=self.num_attention_heads							,     encoder_ffn_dim=self.intermediate_size							,     decoder_ffn_dim=self.intermediate_size							,     dropout=self.hidden_dropout_prob							,     attention_dropout=self.attention_probs_dropout_prob							,     prediction_length=self.prediction_length							,     context_length=self.context_length							,     label_length=self.label_length							,     lags_sequence=self.lags_sequence							,     num_time_features=self.num_time_features							,     num_static_categorical_features=1							,     cardinality=[self.cardinality]							,     embedding_dimension=[self.embedding_dimension]							,     moving_average=self.moving_average							,     )




  def 						A__  (       self							,     lowerCAmelCase      )						->				Optional[Any]:
        '''simple docstring'''






        _lowercase			 =config.context_length + max(config.lags_sequence      )

        _lowercase			 =ids_tensor([self.batch_size, 1]							,     config.cardinality[0]      )
        _lowercase			 =floats_tensor([self.batch_size, _past_length, config.num_time_features]      )
        _lowercase			 =floats_tensor([self.batch_size, _past_length]      )
        _lowercase			 =floats_tensor([self.batch_size, _past_length]      ) > 0.5

        # decoder inputs
        _lowercase			 =floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]      )
        _lowercase			 =floats_tensor([self.batch_size, config.prediction_length]      )

        _lowercase			 ={
            """past_values""": past_values,
            """static_categorical_features""": static_categorical_features,
            """past_time_features""": past_time_features,
            """past_observed_mask""": past_observed_mask,
            """future_time_features""": future_time_features,
            """future_values""": future_values,
        }
        return inputs_dict




  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






        _lowercase			 =self.get_config()
        _lowercase			 =self.prepare_autoformer_inputs_dict(_lowercase      )
        return config, inputs_dict




  def 						A__  (       self      )						->				int:
        '''simple docstring'''






        _lowercase			 =self.prepare_config_and_inputs()
        return config, inputs_dict




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase      )						->				int:
        '''simple docstring'''






        _lowercase			 =AutoformerModel(config=_lowercase      ).to(_lowercase      ).eval()
        _lowercase			 =model(**_lowercase      )

        _lowercase			 =outputs.encoder_last_hidden_state
        _lowercase			 =outputs.last_hidden_state

        with tempfile.TemporaryDirectory() as tmpdirname:
              _lowercase			 =model.get_encoder()
              encoder.save_pretrained(_lowercase      )
              _lowercase			 =AutoformerEncoder.from_pretrained(_lowercase      ).to(_lowercase      )

        _lowercase			 =model.create_network_inputs(**_lowercase      )
        _lowercase			 =model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]      )

        _lowercase			 =torch.cat(
            (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])							,     dim=-1							,     )
        _lowercase			 =encoder(inputs_embeds=_lowercase      )[0]
        self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3      )

        _lowercase			 =(
            torch.mean(transformer_inputs[:, : config.context_length, ...]							,     dim=1      )
            .unsqueeze(1      )
            .repeat(1							,     config.prediction_length							,     1      )
        )
        _lowercase			 =torch.zeros(
            [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]							,     device=enc_input.device							,     )

        _lowercase			 =torch.cat(
            (
                torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)							,     dim=1      ),
                feature[:, config.context_length - config.label_length :, ...],
            )							,     dim=-1							,     )
        _lowercase			 =torch.cat(
            (
                torch.cat((trend_input[:, -config.label_length :, ...], mean)							,     dim=1      ),
                feature[:, config.context_length - config.label_length :, ...],
            )							,     dim=-1							,     )

        with tempfile.TemporaryDirectory() as tmpdirname:
              _lowercase			 =model.get_decoder()
              decoder.save_pretrained(_lowercase      )
              _lowercase			 =AutoformerDecoder.from_pretrained(_lowercase      ).to(_lowercase      )

        _lowercase			 =decoder(
            trend=_lowercase							,     inputs_embeds=_lowercase							,     encoder_hidden_states=_lowercase							,     )[0]

        self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3      )





@require_torch
class 				__lowerCAmelCase  (      __snake_case    ,    __snake_case    ,    unittest.TestCase							):
  _a		    =						(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
  _a		    =						(AutoformerForPrediction,) if is_torch_available() else ()
  _a		    =						{"""feature-extraction""": AutoformerModel} if is_torch_available() else {}
  _a		    =						False
  _a		    =						False
  _a		    =						False
  _a		    =						False
  _a		    =						False
  _a		    =						False




  def 						A__  (       self      )						->				List[str]:
        '''simple docstring'''






        _lowercase			 =AutoformerModelTester(self      )
        _lowercase			 =ConfigTester(self							,     config_class=_lowercase							,     has_text_modality=_lowercase      )




  def 						A__  (       self      )						->				Dict:
        '''simple docstring'''






        self.config_tester.run_common_tests()




  def 						A__  (       self      )						->				Any:
        '''simple docstring'''






        _lowercase			 =self.model_tester.prepare_config_and_inputs()
        for model_class in self.all_model_classes:
              _lowercase			 =model_class(_lowercase      )

              with tempfile.TemporaryDirectory() as tmpdirname:
                    model.save_pretrained(_lowercase      )
                    _lowercase			 =model_class.from_pretrained(_lowercase							,     output_loading_info=_lowercase      )
              self.assertEqual(info['missing_keys']							,     []      )




  def 						A__  (       self      )						->				List[str]:
        '''simple docstring'''






        _lowercase			 =self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.check_encoder_decoder_model_standalone(*_lowercase      )




  @unittest.skip(reason='Model has no tokens embeddings'      )
  def 						A__  (       self      )						->				Any:
        '''simple docstring'''






        pass




  def 						A__  (       self      )						->				int:
        '''simple docstring'''






        _lowercase			 =inspect.signature(getattr(_lowercase							,     'forward'      )      )
        # The main input is the name of the argument after `self`
        _lowercase			 =list(model_signature.parameters.keys()      )[1]
        self.assertEqual(AutoformerModel.main_input_name							,     _lowercase      )




  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






        _lowercase			 =self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              _lowercase			 =model_class(_lowercase      )
              _lowercase			 =inspect.signature(model.forward      )
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              _lowercase			 =[*signature.parameters.keys()]

              _lowercase			 =[
                  """past_values""",
                  """past_time_features""",
                  """past_observed_mask""",
                  """static_categorical_features""",
                  """static_real_features""",
                  """future_values""",
                  """future_time_features""",
              ]

              if model.__class__.__name__ in ["AutoformerForPrediction"]:
                    expected_arg_names.append('future_observed_mask'      )

              expected_arg_names.extend(
                  [
                      'decoder_attention_mask',
                      'head_mask',
                      'decoder_head_mask',
                      'cross_attn_head_mask',
                      'encoder_outputs',
                      'past_key_values',
                      'output_hidden_states',
                      'output_attentions',
                      'use_cache',
                      'return_dict',
                  ]      )

              self.assertListEqual(arg_names[: len(_lowercase      )]							,     _lowercase      )




  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






        _lowercase			 =self.model_tester.prepare_config_and_inputs_for_common()
        _lowercase			 =True

        _lowercase			 =getattr(self.model_tester							,     'seq_length'							,     _lowercase      )
        _lowercase			 =getattr(self.model_tester							,     'decoder_seq_length'							,     _lowercase      )
        _lowercase			 =getattr(self.model_tester							,     'encoder_seq_length'							,     _lowercase      )
        _lowercase			 =getattr(self.model_tester							,     'd_model'							,     _lowercase      )
        _lowercase			 =getattr(self.model_tester							,     'num_attention_heads'							,     _lowercase      )
        _lowercase			 =d_model // num_attention_heads

        for model_class in self.all_model_classes:
              _lowercase			 =True
              _lowercase			 =False
              _lowercase			 =True
              _lowercase			 =model_class(_lowercase      )
              model.to(_lowercase      )
              model.eval()
              with torch.no_grad():
                    _lowercase			 =model(**self._prepare_for_class(_lowercase							,     _lowercase      )      )
              _lowercase			 =outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
              self.assertEqual(len(_lowercase      )							,     self.model_tester.num_hidden_layers      )

              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              _lowercase			 =True
              _lowercase			 =model_class(_lowercase      )
              model.to(_lowercase      )
              model.eval()
              with torch.no_grad():
                    _lowercase			 =model(**self._prepare_for_class(_lowercase							,     _lowercase      )      )
              _lowercase			 =outputs.encoder_attentions
              self.assertEqual(len(_lowercase      )							,     self.model_tester.num_hidden_layers      )

              self.assertListEqual(
                  list(attentions[0].shape[-3:]      )							,     [self.model_tester.num_attention_heads, encoder_seq_length, dim]							,     )
              _lowercase			 =len(_lowercase      )

              _lowercase			 =7

              if "last_hidden_state" in outputs:
                    correct_outlen += 1

              if "trend" in outputs:
                    correct_outlen += 1

              if "past_key_values" in outputs:
                    correct_outlen += 1  # past_key_values have been returned

              if "loss" in outputs:
                    correct_outlen += 1

              if "params" in outputs:
                    correct_outlen += 1

              self.assertEqual(_lowercase							,     _lowercase      )

              # decoder attentions
              _lowercase			 =outputs.decoder_attentions
              self.assertIsInstance(_lowercase							,     (list, tuple)      )
              self.assertEqual(len(_lowercase      )							,     self.model_tester.num_hidden_layers      )
              self.assertListEqual(
                  list(decoder_attentions[0].shape[-3:]      )							,     [self.model_tester.num_attention_heads, decoder_seq_length, dim]							,     )

              # cross attentions
              _lowercase			 =outputs.cross_attentions
              self.assertIsInstance(_lowercase							,     (list, tuple)      )
              self.assertEqual(len(_lowercase      )							,     self.model_tester.num_hidden_layers      )
              self.assertListEqual(
                  list(cross_attentions[0].shape[-3:]      )							,     [self.model_tester.num_attention_heads, decoder_seq_length, dim]							,     )

        # Check attention is always last and order is fine
        _lowercase			 =True
        _lowercase			 =True
        _lowercase			 =model_class(_lowercase      )
        model.to(_lowercase      )
        model.eval()
        with torch.no_grad():
              _lowercase			 =model(**self._prepare_for_class(_lowercase							,     _lowercase      )      )

        self.assertEqual(out_len + 2							,     len(_lowercase      )      )

        _lowercase			 =outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

        self.assertEqual(len(_lowercase      )							,     self.model_tester.num_hidden_layers      )
        self.assertListEqual(
            list(self_attentions[0].shape[-3:]      )							,     [self.model_tester.num_attention_heads, encoder_seq_length, dim]							,     )




  @is_flaky()
  def 						A__  (       self      )						->				Union[str, Any]:
        '''simple docstring'''






        super().test_retain_grad_hidden_states_attentions()
def   a   (    A__			:     Tuple="train-batch.pt"  )					->   Optional[int]:





      """simple docstring"""



      _lowercase			 =hf_hub_download(repo_id='hf-internal-testing/tourism-monthly-batch'   ,     filename=_lowerCamelCase   ,     repo_type='dataset'  )
      _lowercase			 =torch.load(_lowerCamelCase   ,     map_location=_lowerCamelCase  )
      return batch







@require_torch
@slow
class 				__lowerCAmelCase  (      unittest.TestCase							):




  def 						A__  (       self      )						->				Tuple:
        '''simple docstring'''






        _lowercase			 =AutoformerModel.from_pretrained('huggingface/autoformer-tourism-monthly'      ).to(_lowercase      )
        _lowercase			 =prepare_batch()

        with torch.no_grad():
              _lowercase			 =model(
                  past_values=batch['past_values']							,     past_time_features=batch['past_time_features']							,     past_observed_mask=batch['past_observed_mask']							,     static_categorical_features=batch['static_categorical_features']							,     future_values=batch['future_values']							,     future_time_features=batch['future_time_features']							,     )[0]

        _lowercase			 =torch.Size(
            (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)      )
        self.assertEqual(output.shape							,     _lowercase      )

        _lowercase			 =torch.tensor(
            [[0.3593, -1.3398, 0.6330], [0.2279, 1.5396, -0.1792], [0.0450, 1.3225, -0.2335]]							,     device=_lowercase      )
        self.assertTrue(torch.allclose(output[0, :3, :3]							,     _lowercase							,     atol=_lowercase      )      )




  def 						A__  (       self      )						->				Tuple:
        '''simple docstring'''






        _lowercase			 =AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly'      ).to(_lowercase      )
        _lowercase			 =prepare_batch('val-batch.pt'      )
        with torch.no_grad():
              _lowercase			 =model(
                  past_values=batch['past_values']							,     past_time_features=batch['past_time_features']							,     past_observed_mask=batch['past_observed_mask']							,     static_categorical_features=batch['static_categorical_features']							,     ).encoder_last_hidden_state
        _lowercase			 =torch.Size((64, model.config.context_length, model.config.d_model)      )
        self.assertEqual(output.shape							,     _lowercase      )

        _lowercase			 =torch.tensor(
            [[-0.0734, -0.9036, 0.8358], [4.7186, 2.4113, 1.9581], [1.7953, 2.3558, 1.2970]]							,     device=_lowercase      )
        self.assertTrue(torch.allclose(output[0, :3, :3]							,     _lowercase							,     atol=_lowercase      )      )




  def 						A__  (       self      )						->				List[str]:
        '''simple docstring'''






        _lowercase			 =AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly'      ).to(_lowercase      )
        _lowercase			 =prepare_batch('val-batch.pt'      )
        with torch.no_grad():
              _lowercase			 =model.generate(
                  static_categorical_features=batch['static_categorical_features']							,     past_time_features=batch['past_time_features']							,     past_values=batch['past_values']							,     future_time_features=batch['future_time_features']							,     past_observed_mask=batch['past_observed_mask']							,     )
        _lowercase			 =torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)      )
        self.assertEqual(outputs.sequences.shape							,     _lowercase      )

        _lowercase			 =torch.tensor([3130.6763, 4056.5293, 7053.0786]							,     device=_lowercase      )
        _lowercase			 =outputs.sequences.mean(dim=1      )
        self.assertTrue(torch.allclose(mean_prediction[0, -3:]							,     _lowercase							,     rtol=1e-1      )      )





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   a   (    A__			:     List[Any]  )					->   Union[str, Any]:





      """simple docstring"""



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





@require_tf
class 				__lowerCAmelCase  :




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase      )						->				List[Any]:
        '''simple docstring'''






        pass




  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        pass




  def 						A__  (       self      )						->				Optional[Any]:
        '''simple docstring'''






        pass




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase=None							,     **lowerCAmelCase      )						->				Optional[Any]:
        '''simple docstring'''






        _lowercase			 =VisionTextDualEncoderConfig.from_vision_text_configs(lowerCAmelCase							,     lowerCAmelCase      )

        _lowercase			 =TFVisionTextDualEncoderModel(lowerCAmelCase      )

        _lowercase			 =model(input_ids=lowerCAmelCase							,     pixel_values=lowerCAmelCase							,     attention_mask=lowerCAmelCase      )

        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 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase=None							,     **lowerCAmelCase      )						->				int:
        '''simple docstring'''






        _lowercase , _lowercase			 =self.get_vision_text_model(lowerCAmelCase							,     lowerCAmelCase      )
        _lowercase			 =TFVisionTextDualEncoderModel(vision_model=lowerCAmelCase							,     text_model=lowerCAmelCase      )

        _lowercase			 =model(input_ids=lowerCAmelCase							,     pixel_values=lowerCAmelCase							,     attention_mask=lowerCAmelCase      )

        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 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase=None							,     **lowerCAmelCase      )						->				Union[str, Any]:
        '''simple docstring'''






        _lowercase , _lowercase			 =self.get_vision_text_model(lowerCAmelCase							,     lowerCAmelCase      )
        _lowercase			 ={'vision_model': vision_model, 'text_model': text_model}
        _lowercase			 =TFVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCAmelCase      )

        _lowercase			 =model(input_ids=lowerCAmelCase							,     pixel_values=lowerCAmelCase							,     attention_mask=lowerCAmelCase      )

        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 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase=None							,     **lowerCAmelCase      )						->				int:
        '''simple docstring'''






        _lowercase , _lowercase			 =self.get_vision_text_model(lowerCAmelCase							,     lowerCAmelCase      )
        _lowercase			 =TFVisionTextDualEncoderModel(vision_model=lowerCAmelCase							,     text_model=lowerCAmelCase      )

        _lowercase			 =model(input_ids=lowerCAmelCase							,     pixel_values=lowerCAmelCase							,     attention_mask=lowerCAmelCase      )
        _lowercase			 =output[0].numpy()

        with tempfile.TemporaryDirectory() as tmpdirname:
              model.save_pretrained(lowerCAmelCase      )
              _lowercase			 =TFVisionTextDualEncoderModel.from_pretrained(lowerCAmelCase      )

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




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase=None							,     **lowerCAmelCase      )						->				Optional[int]:
        '''simple docstring'''






        _lowercase , _lowercase			 =self.get_vision_text_model(lowerCAmelCase							,     lowerCAmelCase      )
        _lowercase			 =TFVisionTextDualEncoderModel(vision_model=lowerCAmelCase							,     text_model=lowerCAmelCase      )

        _lowercase			 =model(
            input_ids=lowerCAmelCase							,     pixel_values=lowerCAmelCase							,     attention_mask=lowerCAmelCase							,     output_attentions=lowerCAmelCase      )

        _lowercase			 =output.vision_model_output.attentions
        self.assertEqual(len(lowerCAmelCase      )							,     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(lowerCAmelCase      )							,     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 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase      )						->				Optional[Any]:
        '''simple docstring'''






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




  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        _lowercase			 =self.prepare_config_and_inputs()
        self.check_vision_text_dual_encoder_model(**lowerCAmelCase      )




  def 						A__  (       self      )						->				int:
        '''simple docstring'''






        _lowercase			 =self.prepare_config_and_inputs()
        self.check_model_from_pretrained_configs(**lowerCAmelCase      )




  def 						A__  (       self      )						->				Union[str, Any]:
        '''simple docstring'''






        _lowercase			 =self.prepare_config_and_inputs()
        self.check_vision_text_dual_encoder_from_pretrained(**lowerCAmelCase      )




  def 						A__  (       self      )						->				List[Any]:
        '''simple docstring'''






        _lowercase			 =self.prepare_config_and_inputs()
        self.check_save_load(**lowerCAmelCase      )




  def 						A__  (       self      )						->				Tuple:
        '''simple docstring'''






        _lowercase			 =self.prepare_config_and_inputs()
        self.check_vision_text_output_attention(**lowerCAmelCase      )




  @slow
  def 						A__  (       self      )						->				Union[str, Any]:
        '''simple docstring'''






        _lowercase , _lowercase			 =self.get_pretrained_model_and_inputs()

        _lowercase			 =model_a(**lowerCAmelCase      )
        _lowercase			 =outputs[0].numpy()

        with tempfile.TemporaryDirectory() as tmp_dirname:
              model_a.save_pretrained(lowerCAmelCase      )
              _lowercase			 =TFVisionTextDualEncoderModel.from_pretrained(lowerCAmelCase      )

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





@require_tf
class 				__lowerCAmelCase  (      SCREAMING_SNAKE_CASE    ,    unittest.TestCase							):




  def 						A__  (       self      )						->				List[Any]:
        '''simple docstring'''






        _lowercase			 =TFVisionTextDualEncoderModel.from_vision_text_pretrained(
            'hf-internal-testing/tiny-random-vit'							,     'hf-internal-testing/tiny-random-bert'      )
        _lowercase			 =13
        _lowercase			 =floats_tensor(
            [
                batch_size,
                model.vision_model.config.num_channels,
                model.vision_model.config.image_size,
                model.vision_model.config.image_size,
            ]      )
        _lowercase			 =ids_tensor([batch_size, 4]							,     model.text_model.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 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase      )						->				List[Any]:
        '''simple docstring'''






        _lowercase			 =TFViTModel(lowerCAmelCase							,     name='vision_model'      )
        _lowercase			 =TFBertModel(lowerCAmelCase							,     name='text_model'      )
        return vision_model, text_model




  def 						A__  (       self      )						->				Any:
        '''simple docstring'''






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

        _lowercase , _lowercase , _lowercase			 =vision_config_and_inputs

        (
            (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , 
        )			 =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 				__lowerCAmelCase  (      SCREAMING_SNAKE_CASE    ,    unittest.TestCase							):




  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        _lowercase			 =TFVisionTextDualEncoderModel.from_vision_text_pretrained(
            'Rocketknight1/tiny-random-deit-tf'							,     'hf-internal-testing/tiny-random-roberta'      )
        _lowercase			 =13
        _lowercase			 =floats_tensor(
            [
                batch_size,
                model.vision_model.config.num_channels,
                model.vision_model.config.image_size,
                model.vision_model.config.image_size,
            ]      )
        _lowercase			 =ids_tensor([batch_size, 4]							,     model.text_model.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 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase=None							,     **lowerCAmelCase      )						->				List[str]:
        '''simple docstring'''






        _lowercase , _lowercase			 =self.get_vision_text_model(lowerCAmelCase							,     lowerCAmelCase      )
        _lowercase			 =TFVisionTextDualEncoderModel(vision_model=lowerCAmelCase							,     text_model=lowerCAmelCase      )

        _lowercase			 =model(
            input_ids=lowerCAmelCase							,     pixel_values=lowerCAmelCase							,     attention_mask=lowerCAmelCase							,     output_attentions=lowerCAmelCase      )

        _lowercase			 =output.vision_model_output.attentions
        self.assertEqual(len(lowerCAmelCase      )							,     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)
        _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 + 2
        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(lowerCAmelCase      )							,     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 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase      )						->				Tuple:
        '''simple docstring'''






        _lowercase			 =TFDeiTModel(lowerCAmelCase							,     name='vision_model'      )
        _lowercase			 =TFRobertaModel(lowerCAmelCase							,     name='text_model'      )
        return vision_model, text_model




  def 						A__  (       self      )						->				Any:
        '''simple docstring'''






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

        _lowercase , _lowercase , _lowercase			 =vision_config_and_inputs

        (
            (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , 
        )			 =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 				__lowerCAmelCase  (      SCREAMING_SNAKE_CASE    ,    unittest.TestCase							):




  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        _lowercase			 =TFVisionTextDualEncoderModel.from_vision_text_pretrained(
            'Rocketknight1/tiny-random-clip-tf'							,     'hf-internal-testing/tiny-random-bert'      )
        _lowercase			 =13
        _lowercase			 =floats_tensor(
            [
                batch_size,
                model.vision_model.config.num_channels,
                model.vision_model.config.image_size,
                model.vision_model.config.image_size,
            ]      )
        _lowercase			 =ids_tensor([batch_size, 4]							,     model.text_model.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 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase      )						->				Tuple:
        '''simple docstring'''






        _lowercase			 =TFCLIPVisionModel(lowerCAmelCase							,     name='vision_model'      )
        _lowercase			 =TFBertModel(lowerCAmelCase							,     name='text_model'      )
        return vision_model, text_model




  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        _lowercase			 =TFCLIPVisionModelTester(self      )
        _lowercase			 =TFBertModelTester(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
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , (
            _lowercase
        ) , 
        )			 =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 				__lowerCAmelCase  (      unittest.TestCase							):




  @slow
  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






        _lowercase			 =TFVisionTextDualEncoderModel.from_pretrained(
            'clip-italian/clip-italian'							,     logit_scale_init_value=1.0							,     from_pt=lowerCAmelCase      )
        _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=lowerCAmelCase							,     padding=lowerCAmelCase							,     return_tensors='np'      )

        _lowercase			 =model(**lowerCAmelCase      )

        # 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.numpy()							,     lowerCAmelCase							,     atol=1e-3      )      )


