





'''simple docstring'''


import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig
from ..clip.configuration_clip import CLIPVisionConfig


A_				     =							logging.get_logger(__name__)


class 		UpperCamelCase__     (       a_							):
      '''simple docstring'''






      _snake_case           =				'''vision-text-dual-encoder'''
      _snake_case           =				True




      def __init__(     self     , SCREAMING_SNAKE_CASE=5_12     , SCREAMING_SNAKE_CASE=2.6_5_9_2     , **SCREAMING_SNAKE_CASE )				->  Optional[int]:
        super().__init__(**snake_case__ )

        if "vision_config" not in kwargs:
          raise ValueError('`vision_config` can not be `None`.' )

        if "text_config" not in kwargs:
          raise ValueError('`text_config` can not be `None`.' )

        __lowerCAmelCase		:    Optional[Any]			     =  kwargs.pop('vision_config' )
        __lowerCAmelCase		:    Optional[Any]			     =  kwargs.pop('text_config' )

        __lowerCAmelCase		:    str			     =  vision_config.pop('model_type' )
        __lowerCAmelCase		:    List[str]			     =  text_config.pop('model_type' )

        if vision_model_type == "clip":
          __lowerCAmelCase		:    List[Any]			     =  AutoConfig.for_model(snake_case__     , **snake_case__ ).vision_config
        elif vision_model_type == "clip_vision_model":
          __lowerCAmelCase		:    Tuple			     =  CLIPVisionConfig(**snake_case__ )
        else:
          __lowerCAmelCase		:    str			     =  AutoConfig.for_model(snake_case__     , **snake_case__ )

        __lowerCAmelCase		:    List[str]			     =  AutoConfig.for_model(snake_case__     , **snake_case__ )

        __lowerCAmelCase		:    List[str]			     =  projection_dim
        __lowerCAmelCase		:    Dict			     =  logit_scale_init_value




      @classmethod
      def 	snake_case  (     cls     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , **SCREAMING_SNAKE_CASE )				->  Dict:
        return cls(vision_config=vision_config.to_dict()     , text_config=text_config.to_dict()     , **snake_case__ )







      def 	snake_case  (     self )				->  Any:
        __lowerCAmelCase		:    Dict			     =  copy.deepcopy(self.__dict__ )
        __lowerCAmelCase		:    int			     =  self.vision_config.to_dict()
        __lowerCAmelCase		:    int			     =  self.text_config.to_dict()
        __lowerCAmelCase		:    str			     =  self.__class__.model_type
        return output










import json
import os
from dataclasses import dataclass

import numpy as np
import pyarrow as pa

import datasets
from utils import get_duration


UpperCAmelCase :				Any							=1000_0000_0000
UpperCAmelCase :				Any							=1_0000

UpperCAmelCase			,			UpperCAmelCase :				Tuple							=os.path.split(__file__)
UpperCAmelCase :				Tuple							=os.path.join(RESULTS_BASEPATH, """results""", RESULTS_FILENAME.replace(""".py""", """.json"""))



def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase):
					UpperCamelCase_			= pa.Table.from_pydict({"col": [0] * chunk_size})
					UpperCamelCase_			= pa.concat_tables([table] * (num_examples // chunk_size))
					return datasets.Dataset(_lowerCAmelCase ,						fingerprint="table_100B")


@dataclass
class    _lowercase :
				'''simple docstring'''







				lowercase__     =    42
				lowercase__     =    42
				lowercase__     =    42
				lowercase__     =    42

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									UpperCamelCase_			= np.random.default_rng(self.seed     )
									UpperCamelCase_			= rng.integers(low=self.low  ,			high=self.high  ,			size=self.size     ).tolist()

				def __iter__(			self     ):

									'''simple docstring'''


									return iter(self._sampled_values     )

				def __len__(			self     ):

									'''simple docstring'''


									return self.size




@get_duration
def  _lowerCAmelCase     (_lowerCAmelCase):
					UpperCamelCase_			= dataset[0]



@get_duration
def  _lowerCAmelCase     (_lowerCAmelCase):
					UpperCamelCase_			= dataset[-1]



@get_duration
def  _lowerCAmelCase     (_lowerCAmelCase):
					UpperCamelCase_			= dataset[range(len(_lowerCAmelCase) // 2 ,						len(_lowerCAmelCase) // 2 + 10_24)]



@get_duration
def  _lowerCAmelCase     (_lowerCAmelCase):
					UpperCamelCase_			= dataset[RandIter(0 ,						len(_lowerCAmelCase) ,						10_24 ,						seed=42)]



def  _lowerCAmelCase     ():
					UpperCamelCase_			= {"num examples": SPEED_TEST_N_EXAMPLES}
					UpperCamelCase_			= (get_first_row, get_last_row, get_batch_of_aaaa_rows, get_batch_of_aaaa_random_rows)
					print("generating dataset")
					UpperCamelCase_			= generate_100B_dataset(num_examples=_lowerCAmelCase ,						chunk_size=_lowerCAmelCase)
					print("Functions")
					for func in functions:
										print(func.__name__)
										UpperCamelCase_			= func(_lowerCAmelCase)

					with open(_lowerCAmelCase ,						"wb") as f:
										f.write(json.dumps(_lowerCAmelCase).encode("utf-8"))


if __name__ == "__main__":  # useful to run the profiler
	benchmark_table_100B()
