"""simple docstring"""







from functools import partial
from typing import Any, Callable, Dict, List, Type, TypeVar, Union, overload

import torch
import torch.nn as nn
import torch.types



def       A__    (	lowercase_     :	torch.Tensor      , lowercase_     :	torch.Tensor      , lowercase_     :	bool						)  ->							torch.Tensor:
   # The first operation in a checkpoint can't be in-place, but it's
   # nice to have in-place addition during inference. Thus...
   if not inplace:
      __lowerCamelCase    		=					ma + ma
   else:
      ma += ma

   return ma



def       A__    (	lowercase_     :	torch.Tensor      , lowercase_     :	List[int]						)  ->							torch.Tensor:
   __lowerCamelCase    		=					-1 * len(lowercase_						)
   __lowerCamelCase    		=					list(range(len(tensor.shape[:zero_index]						)						)						)
   return tensor.permute(first_inds + [zero_index + i for i in inds]						)



def       A__    (	lowercase_     :	torch.Tensor      , lowercase_     :	int						)  ->							torch.Tensor:
   return t.reshape(t.shape[:-no_dims] + (-1,)						)



def       A__    (	lowercase_     :	torch.Tensor      , lowercase_     :	torch.Tensor      , lowercase_     :	int      , lowercase_     :	float = 1e-4						)  ->							torch.Tensor:
   __lowerCamelCase    		=					mask.expand(*value.shape						)
   return torch.sum(mask * value      , dim=lowercase_						) / (eps + torch.sum(lowercase_      , dim=lowercase_						))



def       A__    (	lowercase_     :	torch.Tensor      , lowercase_     :	torch.types.Number = 2.3_1_2_5      , lowercase_     :	torch.types.Number = 2_1.6_8_7_5      , lowercase_     :	int = 64						)  ->							torch.Tensor:
   __lowerCamelCase    		=					torch.linspace(lowercase_      , lowercase_      , no_bins - 1      , device=pts.device						)
   __lowerCamelCase    		=					torch.sqrt(torch.sum((pts.unsqueeze(-2						) - pts.unsqueeze(-3						)) ** 2      , dim=-1						)						)
   return torch.bucketize(lowercase_      , lowercase_						)



def       A__    (	lowercase_     :	Callable[[list], Any]      , lowercase_     :	List[dict]						)  ->							dict:
   __lowerCamelCase    		=					dicts[0]
   __lowerCamelCase    		=					{}
   for k, v in first.items():
      __lowerCamelCase    		=					[d[k] for d in dicts]
      if isinstance(lowercase_      , lowercase_						):
         __lowerCamelCase    		=					dict_multimap(lowercase_      , lowercase_						)
      else:
         __lowerCamelCase    		=					fn(lowercase_						)

   return new_dict



def       A__    (	lowercase_     :	torch.Tensor      , lowercase_     :	torch.Tensor						)  ->							torch.Tensor:
   __lowerCamelCase    		=					v_bins.view(((1,) * len(x.shape						)) + (len(lowercase_						),)						)
   __lowerCamelCase    		=					x[..., None] - reshaped_bins
   __lowerCamelCase    		=					torch.argmin(torch.abs(lowercase_						)      , dim=-1						)
   return nn.functional.one_hot(lowercase_      , num_classes=len(lowercase_						)						).float()



def       A__    (	lowercase_     :	torch.Tensor      , lowercase_     :	torch.Tensor      , lowercase_     :	int = 0      , lowercase_     :	int = 0						)  ->							torch.Tensor:
   __lowerCamelCase    		=					[]
   for i, s in enumerate(data.shape[:no_batch_dims]						):
      __lowerCamelCase    		=					torch.arange(lowercase_						)
      __lowerCamelCase    		=					r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape						) - i - 1)))						)
      ranges.append(lowercase_						)

   __lowerCamelCase    		=					[slice(lowercase_						) for _ in range(len(data.shape						) - no_batch_dims						)]
   __lowerCamelCase    		=					inds
   ranges.extend(lowercase_						)
   # Matt note: Editing this to get around the behaviour of using a list as an array index changing
   # in recent Numpy versions
   return data[tuple(lowercase_						)]


_SCREAMING_SNAKE_CASE	:		Dict   =   TypeVar('''T''')



def       A__    (	lowercase_     :	Callable[[T], Any]      , lowercase_     :	Dict[Any, Union[dict, list, tuple, T]]      , lowercase_     :	Type[T]						)  ->							Dict[Any, Union[dict, list, tuple, Any]]:
   __lowerCamelCase    		=					{}
   for k, v in dic.items():
      if isinstance(lowercase_      , lowercase_						):
         __lowerCamelCase    		=					dict_map(lowercase_      , lowercase_      , lowercase_						)
      else:
         __lowerCamelCase    		=					tree_map(lowercase_      , lowercase_      , lowercase_						)

   return new_dict



@overload
def       A__    (	lowercase_     :	Callable[[T], Any]      , lowercase_     :	T      , lowercase_     :	Type[T]						)  ->							Any:
   ...



@overload
def       A__    (	lowercase_     :	Callable[[T], Any]      , lowercase_     :	dict      , lowercase_     :	Type[T]						)  ->							dict:
   ...



@overload
def       A__    (	lowercase_     :	Callable[[T], Any]      , lowercase_     :	list      , lowercase_     :	Type[T]						)  ->							list:
   ...



@overload
def       A__    (	lowercase_     :	Callable[[T], Any]      , lowercase_     :	tuple      , lowercase_     :	Type[T]						)  ->							tuple:
   ...



def       A__    (	lowercase_     :	Optional[Any]      , lowercase_     :	Optional[int]      , lowercase_     :	List[str]						)  ->							Any:
   if isinstance(lowercase_      , lowercase_						):
      return dict_map(lowercase_      , lowercase_      , lowercase_						)
   elif isinstance(lowercase_      , lowercase_						):
      return [tree_map(lowercase_      , lowercase_      , lowercase_						) for x in tree]
   elif isinstance(lowercase_      , lowercase_						):
      return tuple(tree_map(lowercase_      , lowercase_      , lowercase_						) for x in tree						)
   elif isinstance(lowercase_      , lowercase_						):
      return fn(lowercase_						)
   else:
      print(type(lowercase_						)						)
      raise ValueError('Not supported'						)


_SCREAMING_SNAKE_CASE	:		Union[str, Any]   =   partial(tree_map, leaf_type=torch.Tensor)








"""simple docstring"""






import copy

from transformers.configuration_utils import PretrainedConfig
from transformers.utils import logging


UpperCamelCase_						   =   logging.get_logger(__name__)





class 							snake_case       (     SCREAMING_SNAKE_CASE_		):
   a_					:		Tuple     					=     """hybrid-clip"""
   a_					:		Optional[Any]     					=     True







   def __init__( self       ,							__UpperCAmelCase=5_12       ,							**__UpperCAmelCase)   ->Dict:
      super().__init__(**__UpperCAmelCase)

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

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

      a_						   =     kwargs.pop("text_config")
      a_						   =     kwargs.pop("vision_config")

      a_						   =     text_config.pop("model_type")
      a_						   =     vision_config.pop("model_type")

      from transformers import AutoConfig

      a_						   =     AutoConfig.for_model(__UpperCAmelCase       ,							**__UpperCAmelCase)

      if vision_model_type == "clip":
         a_						   =     AutoConfig.for_model(__UpperCAmelCase       ,							**__UpperCAmelCase).vision_config
      elif vision_model_type == "clip_vision_model":
         from transformers import CLIPVisionConfig

         a_						   =     CLIPVisionConfig(**__UpperCAmelCase)
      else:
         a_						   =     AutoConfig.for_model(__UpperCAmelCase       ,							**__UpperCAmelCase)

      a_						   =     projection_dim
      a_						   =     1.0







   @classmethod
   def    UpperCAmelCase__	( cls       ,							__UpperCAmelCase       ,							__UpperCAmelCase       ,							**__UpperCAmelCase)   ->Optional[int]:
      return cls(text_config=text_config.to_dict()       ,							vision_config=vision_config.to_dict()       ,							**__UpperCAmelCase)







   def    UpperCAmelCase__	( self)   ->str:
      a_						   =     copy.deepcopy(self.__dict__)
      a_						   =     self.text_config.to_dict()
      a_						   =     self.vision_config.to_dict()
      a_						   =     self.__class__.model_type
      return output