
import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding





class   UpperCamelCase_      (      UpperCAmelCase_		):







						'''simple docstring'''



						UpperCamelCase      :  Union[str, Any]				   =					['image_processor', 'tokenizer']
						UpperCamelCase      :  Union[str, Any]				   =					'CLIPImageProcessor'
						UpperCamelCase      :  Optional[int]				   =					('CLIPTokenizer', 'CLIPTokenizerFast')





						def __init__(			self							:Union[str, Any]		,    lowerCAmelCase__							:List[str]=None		,    lowerCAmelCase__							:Tuple=None		,    **lowerCAmelCase__							:Union[str, Any]     )  ->int:
										lowercase         =      None
										if "feature_extractor" in kwargs:
														warnings.warn(
														    "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
														    " instead."		,    SCREAMING_SNAKE_CASE_		,    )
														lowercase         =      kwargs.pop("feature_extractor"     )

										lowercase         =      image_processor if image_processor is not None else feature_extractor
										if image_processor is None:
														raise ValueError("You need to specify an `image_processor`."     )
										if tokenizer is None:
														raise ValueError("You need to specify a `tokenizer`."     )

										super().__init__(SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_     )





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




										if text is None and images is None:
														raise ValueError("You have to specify either text or images. Both cannot be none."     )

										if text is not None:
														lowercase         =      self.tokenizer(SCREAMING_SNAKE_CASE_		,    return_tensors=SCREAMING_SNAKE_CASE_		,    **SCREAMING_SNAKE_CASE_     )

										if images is not None:
														lowercase         =      self.image_processor(SCREAMING_SNAKE_CASE_		,    return_tensors=SCREAMING_SNAKE_CASE_		,    **SCREAMING_SNAKE_CASE_     )

										if text is not None and images is not None:
														lowercase         =      image_features.pixel_values
														return encoding
										elif text is not None:
														return encoding
										else:
														return BatchEncoding(data=dict(**SCREAMING_SNAKE_CASE_     )		,    tensor_type=SCREAMING_SNAKE_CASE_     )





						def        SCREAMING_SNAKE_CASE(			self							:Tuple		,    *lowerCAmelCase__							:str		,    **lowerCAmelCase__							:Tuple     )  ->List[Any]:
										return self.tokenizer.batch_decode(*SCREAMING_SNAKE_CASE_		,    **SCREAMING_SNAKE_CASE_     )





						def        SCREAMING_SNAKE_CASE(			self							:Any		,    *lowerCAmelCase__							:Union[str, Any]		,    **lowerCAmelCase__							:List[str]     )  ->int:
										return self.tokenizer.decode(*SCREAMING_SNAKE_CASE_		,    **SCREAMING_SNAKE_CASE_     )





						@property
						def        SCREAMING_SNAKE_CASE(			self							:List[Any]     )  ->Optional[int]:
										lowercase         =      self.tokenizer.model_input_names
										lowercase         =      self.image_processor.model_input_names
										return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names     )     )





						@property
						def        SCREAMING_SNAKE_CASE(			self							:Dict     )  ->Tuple:
										warnings.warn(
										    "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."		,    SCREAMING_SNAKE_CASE_		,    )
										return self.image_processor_class





						@property
						def        SCREAMING_SNAKE_CASE(			self							:Dict     )  ->List[Any]:
										warnings.warn(
										    "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."		,    SCREAMING_SNAKE_CASE_		,    )
										return self.image_processor


from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCamelCase__     :		List[Any]        = logging.get_logger(__name__)

lowerCamelCase__     :		Union[str, Any]        = {
    """YituTech/conv-bert-base""": """https://huggingface.co/YituTech/conv-bert-base/resolve/main/config.json""",
    """YituTech/conv-bert-medium-small""": (
        """https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/config.json"""
    ),
    """YituTech/conv-bert-small""": """https://huggingface.co/YituTech/conv-bert-small/resolve/main/config.json""",
    # See all ConvBERT models at https://huggingface.co/models?filter=convbert
}



class    _snake_case (						UpperCAmelCase_				):
 __lowerCAmelCase	:  Union[str, Any]	   =      'convbert'


 def __init__(       self       ,	SCREAMING_SNAKE_CASE_=3_05_22       ,	SCREAMING_SNAKE_CASE_=7_68       ,	SCREAMING_SNAKE_CASE_=12       ,	SCREAMING_SNAKE_CASE_=12       ,	SCREAMING_SNAKE_CASE_=30_72       ,	SCREAMING_SNAKE_CASE_="gelu"       ,	SCREAMING_SNAKE_CASE_=0.1       ,	SCREAMING_SNAKE_CASE_=0.1       ,	SCREAMING_SNAKE_CASE_=5_12       ,	SCREAMING_SNAKE_CASE_=2       ,	SCREAMING_SNAKE_CASE_=0.0_2       ,	SCREAMING_SNAKE_CASE_=1E-12       ,	SCREAMING_SNAKE_CASE_=1       ,	SCREAMING_SNAKE_CASE_=0       ,	SCREAMING_SNAKE_CASE_=2       ,	SCREAMING_SNAKE_CASE_=7_68       ,	SCREAMING_SNAKE_CASE_=2       ,	SCREAMING_SNAKE_CASE_=9       ,	SCREAMING_SNAKE_CASE_=1       ,	SCREAMING_SNAKE_CASE_=None       ,	**SCREAMING_SNAKE_CASE_       ,	):


   '''simple docstring'''




   super().__init__(
       pad_token_id=SCREAMING_SNAKE_CASE_       ,	bos_token_id=SCREAMING_SNAKE_CASE_       ,	eos_token_id=SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_       ,	)

   lowercase__	: Dict     		=   vocab_size
   lowercase__	: List[Any]     		=   hidden_size
   lowercase__	: Optional[Any]     		=   num_hidden_layers
   lowercase__	: Union[str, Any]     		=   num_attention_heads
   lowercase__	: List[str]     		=   intermediate_size
   lowercase__	: Optional[int]     		=   hidden_act
   lowercase__	: Tuple     		=   hidden_dropout_prob
   lowercase__	: List[str]     		=   attention_probs_dropout_prob
   lowercase__	: Tuple     		=   max_position_embeddings
   lowercase__	: Dict     		=   type_vocab_size
   lowercase__	: Union[str, Any]     		=   initializer_range
   lowercase__	: Dict     		=   layer_norm_eps
   lowercase__	: Tuple     		=   embedding_size
   lowercase__	: List[str]     		=   head_ratio
   lowercase__	: Dict     		=   conv_kernel_size
   lowercase__	: Dict     		=   num_groups
   lowercase__	: int     		=   classifier_dropout



class    _snake_case (						UpperCAmelCase_				):


 @property
 def   lowercase__  (       self):


   '''simple docstring'''




   if self.task == "multiple-choice":
     lowercase__	: Union[str, Any]     		=   {0: """batch""", 1: """choice""", 2: """sequence"""}
   else:
     lowercase__	: str     		=   {0: """batch""", 1: """sequence"""}
   return OrderedDict(
       [
           ("""input_ids""", dynamic_axis),
           ("""attention_mask""", dynamic_axis),
           ("""token_type_ids""", dynamic_axis),
       ])






