




"""simple docstring"""


import gzip
import hashlib
import json
import multiprocessing
import os
import re
import shutil
import time
from pathlib import Path

import numpy as np
from arguments import PreprocessingArguments
from datasets import load_dataset
from minhash_deduplication import deduplicate_dataset

from transformers import AutoTokenizer, HfArgumentParser


_A													=      re.compile(r"""\s+""")



def 	lowercase_				(			__UpperCAmelCase				)						->    Union[str, Any]:






      """simple docstring"""




      return {"hash": hashlib.mda(re.sub(a__    ,		""""""    ,		example["""content"""]				).encode("""utf-8"""				)				).hexdigest()}



def 	lowercase_				(			__UpperCAmelCase				)						->    Union[str, Any]:






      """simple docstring"""




      lowerCAmelCase__      :			int   =	[len(a__				) for line in example["""content"""].splitlines()]
      return {"line_mean": np.mean(a__				), "line_max": max(a__				)}



def 	lowercase_				(			__UpperCAmelCase				)						->    Tuple:






      """simple docstring"""




      lowerCAmelCase__      :			Any   =	np.mean([c.isalnum() for c in example["""content"""]]				)
      return {"alpha_frac": alpha_frac}



def 	lowercase_				(			__UpperCAmelCase    ,		__UpperCAmelCase				)						->    int:






      """simple docstring"""




      if example["hash"] in uniques:
            uniques.remove(example["""hash"""]				)
            return True
      else:
            return False



def 	lowercase_				(			__UpperCAmelCase    ,		__UpperCAmelCase=5				)						->    Dict:






      """simple docstring"""




      lowerCAmelCase__      :			Tuple   =	["""auto-generated""", """autogenerated""", """automatically generated"""]
      lowerCAmelCase__      :			List[str]   =	example["""content"""].splitlines()
      for _, line in zip(range(a__				)    ,		a__				):
            for keyword in keywords:
                  if keyword in line.lower():
                        return {"autogenerated": True}
      else:
            return {"autogenerated": False}



def 	lowercase_				(			__UpperCAmelCase    ,		__UpperCAmelCase=5    ,		__UpperCAmelCase=0.05				)						->    str:






      """simple docstring"""




      lowerCAmelCase__      :			Union[str, Any]   =	["""unit tests""", """test file""", """configuration file"""]
      lowerCAmelCase__      :			Tuple   =	example["""content"""].splitlines()
      lowerCAmelCase__      :			List[str]   =	0
      lowerCAmelCase__      :			str   =	0
      # first test
      for _, line in zip(range(a__				)    ,		a__				):
            for keyword in keywords:
                  if keyword in line.lower():
                        return {"config_or_test": True}
    # second test
      lowerCAmelCase__      :			Optional[Any]   =	example["""content"""].count("""\n"""				)
      lowerCAmelCase__      :			Dict   =	int(coeff * nlines				)
      for line in lines:
            count_config += line.lower().count("""config"""				)
            count_test += line.lower().count("""test"""				)
            if count_config > threshold or count_test > threshold:
                  return {"config_or_test": True}
      return {"config_or_test": False}



def 	lowercase_				(			__UpperCAmelCase				)						->    int:






      """simple docstring"""




      lowerCAmelCase__      :			Dict   =	["""def """, """class """, """for """, """while """]
      lowerCAmelCase__      :			List[str]   =	example["""content"""].splitlines()
      for line in lines:
            for keyword in keywords:
                  if keyword in line.lower():
                        return {"has_no_keywords": False}
      return {"has_no_keywords": True}



def 	lowercase_				(			__UpperCAmelCase    ,		__UpperCAmelCase=4				)						->    Dict:






      """simple docstring"""




      lowerCAmelCase__      :			List[str]   =	example["""content"""].splitlines()
      lowerCAmelCase__      :			Optional[Any]   =	0
      for line in lines:
            counter += line.lower().count("""="""				)
            if counter > minimum:
                  return {"has_few_assignments": False}
      return {"has_few_assignments": True}



def 	lowercase_				(			__UpperCAmelCase				)						->    Tuple:






      """simple docstring"""




      lowerCAmelCase__      :			Optional[Any]   =	tokenizer(example["""content"""]    ,		truncation=a__				)["""input_ids"""]
      lowerCAmelCase__      :			Optional[int]   =	len(example["""content"""]				) / len(a__				)
      return {"ratio": ratio}



def 	lowercase_				(			__UpperCAmelCase				)						->    Union[str, Any]:






      """simple docstring"""




      lowerCAmelCase__      :			str   =	{}
      results.update(get_hash(a__				)				)
      results.update(line_stats(a__				)				)
      results.update(alpha_stats(a__				)				)
      results.update(char_token_ratio(a__				)				)
      results.update(is_autogenerated(a__				)				)
      results.update(is_config_or_test(a__				)				)
      results.update(has_no_keywords(a__				)				)
      results.update(has_few_assignments(a__				)				)
      return results



def 	lowercase_				(			__UpperCAmelCase    ,		__UpperCAmelCase    ,		__UpperCAmelCase				)						->    List[str]:






      """simple docstring"""




      if not check_uniques(a__    ,		a__				):
            return False
      elif example["autogenerated"]:
            return False
      elif example["line_max"] > args.line_max:
            return False
      elif example["line_mean"] > args.line_mean:
            return False
      elif example["alpha_frac"] < args.alpha_frac:
            return False
      elif example["ratio"] < args.min_token_ratio:
            return False
      elif example["config_or_test"] and np.random.rand() <= args.filter_proba:
            return False
      elif example["has_no_keywords"] and np.random.rand() <= args.filter_proba:
            return False
      elif example["has_few_assignments"]:
            return False
      else:
            return True



def 	lowercase_				(			__UpperCAmelCase				)						->    int:






      """simple docstring"""




      with open(a__    ,		"""rb"""				) as f_in:
            with gzip.open(str(a__				) + """.gz"""    ,		"""wb"""    ,		compresslevel=6				) as f_out:
                  shutil.copyfileobj(a__    ,		a__				)
      os.unlink(a__				)


# Settings
_A													=      HfArgumentParser(PreprocessingArguments)
_A													=      parser.parse_args()
if args.num_workers is None:
  _A													=      multiprocessing.cpu_count()
_A													=      AutoTokenizer.from_pretrained(args.tokenizer_dir)

# Load dataset
_A													=      time.time()
_A													=      load_dataset(args.dataset_name, split="""train""")
print(f"""Time to load dataset: {time.time()-t_start:.2f}""")

# Run preprocessing
_A													=      time.time()
_A													=      ds.map(preprocess, num_proc=args.num_workers)
print(f"""Time to preprocess dataset: {time.time()-t_start:.2f}""")

# Deduplicate hashes
_A													=      set(ds.unique("""hash"""))
_A													=      len(uniques) / len(ds)
print(f"""Fraction of duplicates: {1-frac:.2%}""")

# Deduplicate data and apply heuristics
_A													=      time.time()
_A													=      ds.filter(filter, fn_kwargs={"""uniques""": uniques, """args""": args})
print(f"""Time to filter dataset: {time.time()-t_start:.2f}""")
print(f"""Size of filtered dataset: {len(ds_filter)}""")

# Deduplicate with minhash and jaccard similarity
if args.near_deduplication:
  _A													=      time.time()
  _A						,	_A													=      deduplicate_dataset(ds_filter, args.jaccard_threshold)
  print(f"""Time to deduplicate dataset: {time.time()-t_start:.2f}""")
  print(f"""Size of deduplicate dataset: {len(ds_filter)}""")

# Save data in batches of samples_per_file
_A													=      Path(args.output_dir)
output_dir.mkdir(exist_ok=True)

# save duplicate_clusters in the output_dir as artifacts
# not sure it is the right place the save it
if args.near_deduplication:
  with open(output_dir / """duplicate_clusters.json""", """w""") as f:
    json.dump(duplicate_clusters, f)

_A													=      output_dir / """data"""
data_dir.mkdir(exist_ok=True)

_A													=      time.time()
for file_number, index in enumerate(range(0, len(ds_filter), args.samples_per_file)):
  _A													=      str(data_dir / f"""file-{file_number+1:012}.json""")
  _A													=      min(len(ds_filter), index + args.samples_per_file)
  ds_filter.select(list(range(index, end_index))).to_json(file_path)
  compress_file(file_path)

print(f"""Time to save dataset: {time.time()-t_start:.2f}""")











"""simple docstring"""


from __future__ import annotations

import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import is_tf_available, is_vision_available

from ...test_modeling_tf_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_tf_bert import TFBertModelTester
from ..clip.test_modeling_tf_clip import TFCLIPVisionModelTester
from ..deit.test_modeling_tf_deit import TFDeiTModelTester
from ..roberta.test_modeling_tf_roberta import TFRobertaModelTester
from ..vit.test_modeling_tf_vit import TFViTModelTester


if is_tf_available():
  from transformers import (
      TFBertModel,
      TFCLIPVisionModel,
      TFDeiTModel,
      TFRobertaModel,
      TFVisionTextDualEncoderModel,
      TFViTModel,
      VisionTextDualEncoderConfig,
  )

if is_vision_available():
  from PIL import Image

  from transformers import VisionTextDualEncoderProcessor



def 	lowercase_				(			__UpperCAmelCase				)						->    str:
      if isinstance(__UpperCAmelCase    ,		collections.abc.Iterable				):
            return x
      return (x, x)


@require_tf
class _lowerCamelCase    :






   def 	_lowerCAmelCase   (		self       :		Dict   ,     UpperCamelCase       :		List[Any]   ,     UpperCamelCase       :		int   )			->						int:

         """simple docstring"""
         pass






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

         """simple docstring"""
         pass






   def 	_lowerCAmelCase   (		self       :		Tuple   )			->						List[Any]:

         """simple docstring"""
         pass






   def 	_lowerCAmelCase   (		self       :		str   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		List[Any]   ,     UpperCamelCase       :		Dict   ,     UpperCamelCase       :		Any=None   ,     **UpperCamelCase       :		Optional[Any]   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase   ,     UpperCamelCase   )

         lowerCAmelCase__      :			Dict   =	TFVisionTextDualEncoderModel(UpperCamelCase   )

         lowerCAmelCase__      :			List[Any]   =	model(input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   )

         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 	_lowerCAmelCase   (		self       :		int   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		Dict   ,     UpperCamelCase       :		Any=None   ,     **UpperCamelCase       :		Union[str, Any]   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			Optional[int]   =	self.get_vision_text_model(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Union[str, Any]   =	TFVisionTextDualEncoderModel(vision_model=UpperCamelCase   ,     text_model=UpperCamelCase   )

         lowerCAmelCase__      :			Optional[int]   =	model(input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   )

         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 	_lowerCAmelCase   (		self       :		Optional[int]   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Tuple   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		List[str]=None   ,     **UpperCamelCase       :		Optional[Any]   )			->						Any:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			int   =	self.get_vision_text_model(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Dict   =	{"""vision_model""": vision_model, """text_model""": text_model}
         lowerCAmelCase__      :			Optional[int]   =	TFVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase   )

         lowerCAmelCase__      :			Union[str, Any]   =	model(input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   )

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

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			Optional[int]   =	self.get_vision_text_model(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Optional[Any]   =	TFVisionTextDualEncoderModel(vision_model=UpperCamelCase   ,     text_model=UpperCamelCase   )

         lowerCAmelCase__      :			List[Any]   =	model(input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   )
         lowerCAmelCase__      :			Union[str, Any]   =	output[0].numpy()

         with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_pretrained(UpperCamelCase   )
               lowerCAmelCase__      :			str   =	TFVisionTextDualEncoderModel.from_pretrained(UpperCamelCase   )

               lowerCAmelCase__      :			Optional[Any]   =	model(input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   )
               lowerCAmelCase__      :			int   =	after_output[0].numpy()
               lowerCAmelCase__      :			Tuple   =	np.amax(np.abs(out_a - out_a   )   )
               self.assertLessEqual(UpperCamelCase   ,     1E-5   )






   def 	_lowerCAmelCase   (		self       :		int   ,     UpperCamelCase       :		Dict   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Optional[int]   ,     UpperCamelCase       :		List[str]   ,     UpperCamelCase       :		List[Any]=None   ,     **UpperCamelCase       :		Optional[int]   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			str   =	self.get_vision_text_model(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			int   =	TFVisionTextDualEncoderModel(vision_model=UpperCamelCase   ,     text_model=UpperCamelCase   )

         lowerCAmelCase__      :			Dict   =	model(
             input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   ,     output_attentions=UpperCamelCase   )

         lowerCAmelCase__      :			Optional[int]   =	output.vision_model_output.attentions
         self.assertEqual(len(UpperCamelCase   )   ,     vision_config.num_hidden_layers   )

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

         lowerCAmelCase__      :			List[str]   =	output.text_model_output.attentions
         self.assertEqual(len(UpperCamelCase   )   ,     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 	_lowerCAmelCase   (		self       :		Union[str, Any]   ,     UpperCamelCase       :		np.ndarray   ,     UpperCamelCase       :		np.ndarray   ,     UpperCamelCase       :		float   )			->						Optional[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	np.abs((a - b)   ).max()
         self.assertLessEqual(UpperCamelCase   ,     UpperCamelCase   ,     f"""Difference between torch and flax is {diff} (>= {tol})."""   )






   def 	_lowerCAmelCase   (		self       :		str   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	self.prepare_config_and_inputs()
         self.check_vision_text_dual_encoder_model(**UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Dict   )			->						int:

         """simple docstring"""
         lowerCAmelCase__      :			Any   =	self.prepare_config_and_inputs()
         self.check_model_from_pretrained_configs(**UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						Tuple:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	self.prepare_config_and_inputs()
         self.check_vision_text_dual_encoder_from_pretrained(**UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Any   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[Any]   =	self.prepare_config_and_inputs()
         self.check_save_load(**UpperCamelCase   )






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

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	self.prepare_config_and_inputs()
         self.check_vision_text_output_attention(**UpperCamelCase   )






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

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			List[str]   =	self.get_pretrained_model_and_inputs()

         lowerCAmelCase__      :			Union[str, Any]   =	model_a(**UpperCamelCase   )
         lowerCAmelCase__      :			Any   =	outputs[0].numpy()

         with tempfile.TemporaryDirectory() as tmp_dirname:
               model_a.save_pretrained(UpperCamelCase   )
               lowerCAmelCase__      :			int   =	TFVisionTextDualEncoderModel.from_pretrained(UpperCamelCase   )

               lowerCAmelCase__      :			List[str]   =	model_a(**UpperCamelCase   )
               lowerCAmelCase__      :			Dict   =	after_outputs[0].numpy()
               lowerCAmelCase__      :			List[str]   =	np.amax(np.abs(out_a - out_a   )   )
               self.assertLessEqual(UpperCamelCase   ,     1E-5   )






@require_tf
class _lowerCamelCase    (					a_       ,	unittest.TestCase						):






   def 	_lowerCAmelCase   (		self       :		int   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	TFVisionTextDualEncoderModel.from_vision_text_pretrained(
             """hf-internal-testing/tiny-random-vit"""   ,     """hf-internal-testing/tiny-random-bert"""   )
         lowerCAmelCase__      :			Optional[Any]   =	13
         lowerCAmelCase__      :			List[str]   =	floats_tensor(
             [
                 batch_size,
                 model.vision_model.config.num_channels,
                 model.vision_model.config.image_size,
                 model.vision_model.config.image_size,
             ]   )
         lowerCAmelCase__      :			Dict   =	ids_tensor([batch_size, 4]   ,     model.text_model.config.vocab_size   )
         lowerCAmelCase__      :			Optional[Any]   =	random_attention_mask([batch_size, 4]   )
         lowerCAmelCase__      :			Dict   =	{"""pixel_values""": pixel_values, """input_ids""": input_ids, """attention_mask""": attention_mask}

         return model, inputs






   def 	_lowerCAmelCase   (		self       :		Any   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		int   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	TFViTModel(UpperCamelCase   ,     name="""vision_model"""   )
         lowerCAmelCase__      :			Any   =	TFBertModel(UpperCamelCase   ,     name="""text_model"""   )
         return vision_model, text_model






   def 	_lowerCAmelCase   (		self       :		int   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	TFViTModelTester(self   )
         lowerCAmelCase__      :			str   =	TFBertModelTester(self   )
         lowerCAmelCase__      :			Optional[int]   =	vit_model_tester.prepare_config_and_inputs()
         lowerCAmelCase__      :			List[Any]   =	bert_model_tester.prepare_config_and_inputs()

         lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__      :			Dict   =	vision_config_and_inputs

         (
             (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   
         )      :			List[Any]   =	text_config_and_inputs

         return {
             "text_config": text_config,
             "vision_config": vision_config,
             "pixel_values": pixel_values,
             "attention_mask": input_mask,
             "input_ids": input_ids,
             "text_token_type_ids": token_type_ids,
             "text_sequence_labels": sequence_labels,
             "text_token_labels": token_labels,
             "text_choice_labels": choice_labels,
         }






@require_tf
class _lowerCamelCase    (					a_       ,	unittest.TestCase						):






   def 	_lowerCAmelCase   (		self       :		int   )			->						str:

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

         return model, inputs






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		Optional[Any]   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		str=None   ,     **UpperCamelCase       :		Optional[Any]   )			->						int:

         """simple docstring"""
         lowerCAmelCase__ ,   lowerCAmelCase__      :			List[Any]   =	self.get_vision_text_model(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Optional[Any]   =	TFVisionTextDualEncoderModel(vision_model=UpperCamelCase   ,     text_model=UpperCamelCase   )

         lowerCAmelCase__      :			Optional[Any]   =	model(
             input_ids=UpperCamelCase   ,     pixel_values=UpperCamelCase   ,     attention_mask=UpperCamelCase   ,     output_attentions=UpperCamelCase   )

         lowerCAmelCase__      :			Optional[int]   =	output.vision_model_output.attentions
         self.assertEqual(len(UpperCamelCase   )   ,     vision_config.num_hidden_layers   )

         # in DEiT, the seq_len equals the number of patches + 2 (we add 2 for the [CLS] and distillation tokens)
         lowerCAmelCase__      :			Dict   =	to_atuple(vision_model.config.image_size   )
         lowerCAmelCase__      :			Any   =	to_atuple(vision_model.config.patch_size   )
         lowerCAmelCase__      :			Dict   =	(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
         lowerCAmelCase__      :			Optional[Any]   =	num_patches + 2
         self.assertEqual(vision_attentions[0].shape[-3:]   ,     (vision_config.num_attention_heads, seq_len, seq_len)   )

         lowerCAmelCase__      :			Union[str, Any]   =	output.text_model_output.attentions
         self.assertEqual(len(UpperCamelCase   )   ,     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 	_lowerCAmelCase   (		self       :		int   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		str   )			->						List[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Any   =	TFDeiTModel(UpperCamelCase   ,     name="""vision_model"""   )
         lowerCAmelCase__      :			str   =	TFRobertaModel(UpperCamelCase   ,     name="""text_model"""   )
         return vision_model, text_model






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

         """simple docstring"""
         lowerCAmelCase__      :			Optional[Any]   =	TFDeiTModelTester(self   )
         lowerCAmelCase__      :			Union[str, Any]   =	TFRobertaModelTester(self   )
         lowerCAmelCase__      :			Optional[int]   =	vit_model_tester.prepare_config_and_inputs()
         lowerCAmelCase__      :			Any   =	bert_model_tester.prepare_config_and_inputs()

         lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__      :			Optional[Any]   =	vision_config_and_inputs

         (
             (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   
         )      :			str   =	text_config_and_inputs

         return {
             "text_config": text_config,
             "vision_config": vision_config,
             "pixel_values": pixel_values,
             "attention_mask": input_mask,
             "input_ids": input_ids,
             "text_token_type_ids": token_type_ids,
             "text_sequence_labels": sequence_labels,
             "text_token_labels": token_labels,
             "text_choice_labels": choice_labels,
         }






@require_tf
class _lowerCamelCase    (					a_       ,	unittest.TestCase						):






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

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	TFVisionTextDualEncoderModel.from_vision_text_pretrained(
             """Rocketknight1/tiny-random-clip-tf"""   ,     """hf-internal-testing/tiny-random-bert"""   )
         lowerCAmelCase__      :			Any   =	13
         lowerCAmelCase__      :			List[str]   =	floats_tensor(
             [
                 batch_size,
                 model.vision_model.config.num_channels,
                 model.vision_model.config.image_size,
                 model.vision_model.config.image_size,
             ]   )
         lowerCAmelCase__      :			Optional[Any]   =	ids_tensor([batch_size, 4]   ,     model.text_model.config.vocab_size   )
         lowerCAmelCase__      :			str   =	random_attention_mask([batch_size, 4]   )
         lowerCAmelCase__      :			List[str]   =	{"""pixel_values""": pixel_values, """input_ids""": input_ids, """attention_mask""": attention_mask}

         return model, inputs






   def 	_lowerCAmelCase   (		self       :		str   ,     UpperCamelCase       :		str   ,     UpperCamelCase       :		Optional[Any]   )			->						Any:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	TFCLIPVisionModel(UpperCamelCase   ,     name="""vision_model"""   )
         lowerCAmelCase__      :			List[str]   =	TFBertModel(UpperCamelCase   ,     name="""text_model"""   )
         return vision_model, text_model






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

         """simple docstring"""
         lowerCAmelCase__      :			str   =	TFCLIPVisionModelTester(self   )
         lowerCAmelCase__      :			int   =	TFBertModelTester(self   )
         lowerCAmelCase__      :			str   =	clip_model_tester.prepare_config_and_inputs()
         lowerCAmelCase__      :			Optional[int]   =	bert_model_tester.prepare_config_and_inputs()

         lowerCAmelCase__ ,   lowerCAmelCase__      :			Dict   =	vision_config_and_inputs

         (
             (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   (
             lowerCAmelCase__
         ) ,   
         )      :			str   =	text_config_and_inputs

         return {
             "text_config": text_config,
             "vision_config": vision_config,
             "pixel_values": pixel_values,
             "attention_mask": input_mask,
             "input_ids": input_ids,
             "text_token_type_ids": token_type_ids,
             "text_sequence_labels": sequence_labels,
             "text_token_labels": token_labels,
             "text_choice_labels": choice_labels,
         }






@require_vision
@require_tf
class _lowerCamelCase    (					unittest.TestCase						):






   @slow
   def 	_lowerCAmelCase   (		self       :		Optional[int]   )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	TFVisionTextDualEncoderModel.from_pretrained(
             """clip-italian/clip-italian"""   ,     logit_scale_init_value=1.0   ,     from_pt=UpperCamelCase   )
         lowerCAmelCase__      :			Any   =	VisionTextDualEncoderProcessor.from_pretrained("""clip-italian/clip-italian"""   )

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

         lowerCAmelCase__      :			Tuple   =	model(**UpperCamelCase   )

         # verify the logits
         self.assertEqual(outputs.logits_per_image.shape   ,     (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])   )
         self.assertEqual(
             outputs.logits_per_text.shape   ,     (inputs.input_ids.shape[0], inputs.pixel_values.shape[0])   ,     )

         lowerCAmelCase__      :			List[Any]   =	np.array([[1.228_4727, 0.310_4122]]   )

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





