


"""simple docstring"""






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


UpperCAmelCase    :     Optional[int]   						=		logging.get_logger(__name__)


if is_vision_available():
							import PIL





class      lowerCamelCase__   (     A				):







					"""simple docstring"""


					__a	       =							["""pixel_values"""]






					def __init__(       self    : Any ,       UpperCamelCase    : Dict = True ,       UpperCamelCase    : Dict = None ,       UpperCamelCase    : int = PILImageResampling.BICUBIC ,       UpperCamelCase    : Optional[Any] = True ,       UpperCamelCase    : int = None ,       UpperCamelCase    : Optional[int] = True ,       UpperCamelCase    : List[Any] = 1 / 255 ,       UpperCamelCase    : Optional[int] = True ,       UpperCamelCase    : Optional[int] = None ,       UpperCamelCase    : int = None ,       UpperCamelCase    : Tuple = True ,       **UpperCamelCase    : Optional[int] ,       ):
												'''simple docstring'''






												super().__init__(**_a  )
												__UpperCAmelCase   :						Tuple      							=					size if size is not None else {"shortest_edge": 224}
												__UpperCAmelCase   :						int      							=					get_size_dict(_a ,       default_to_square=_a  )
												__UpperCAmelCase   :						Dict      							=					crop_size if crop_size is not None else {"height": 224, "width": 224}
												__UpperCAmelCase   :						Tuple      							=					get_size_dict(_a ,       default_to_square=_a ,       param_name="""crop_size"""  )

												__UpperCAmelCase   :						Optional[Any]      							=					do_resize
												__UpperCAmelCase   :						str      							=					size
												__UpperCAmelCase   :						str      							=					resample
												__UpperCAmelCase   :						Tuple      							=					do_center_crop
												__UpperCAmelCase   :						Tuple      							=					crop_size
												__UpperCAmelCase   :						List[str]      							=					do_rescale
												__UpperCAmelCase   :						Any      							=					rescale_factor
												__UpperCAmelCase   :						Union[str, Any]      							=					do_normalize
												__UpperCAmelCase   :						Union[str, Any]      							=					image_mean if image_mean is not None else OPENAI_CLIP_MEAN
												__UpperCAmelCase   :						Optional[int]      							=					image_std if image_std is not None else OPENAI_CLIP_STD
												__UpperCAmelCase   :						Optional[Any]      							=					do_convert_rgb






					def lowerCamelCase__							(       self    : Optional[int] ,       UpperCamelCase    : List[Any] ,       UpperCamelCase    : Optional[Any] ,       UpperCamelCase    : Union[str, Any] = PILImageResampling.BICUBIC ,       UpperCamelCase    : Tuple = None ,       **UpperCamelCase    : Dict ,       ):
												'''simple docstring'''






												__UpperCAmelCase   :						List[Any]      							=					get_size_dict(_a ,       default_to_square=_a  )
												if "shortest_edge" not in size:
																			raise ValueError(f'''The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'''  )
												__UpperCAmelCase   :						Dict      							=					get_resize_output_image_size(_a ,       size=size["""shortest_edge"""] ,       default_to_square=_a  )
												return resize(_a ,       size=_a ,       resample=_a ,       data_format=_a ,       **_a  )






					def lowerCamelCase__							(       self    : Dict ,       UpperCamelCase    : Tuple ,       UpperCamelCase    : str ,       UpperCamelCase    : Any = None ,       **UpperCamelCase    : Tuple ,       ):
												'''simple docstring'''






												__UpperCAmelCase   :						Union[str, Any]      							=					get_size_dict(_a  )
												if "height" not in size or "width" not in size:
																			raise ValueError(f'''The `size` parameter must contain the keys (height, width). Got {size.keys()}'''  )
												return center_crop(_a ,       size=(size["""height"""], size["""width"""]) ,       data_format=_a ,       **_a  )






					def lowerCamelCase__							(       self    : int ,       UpperCamelCase    : List[str] ,       UpperCamelCase    : str ,       UpperCamelCase    : Any = None ,       **UpperCamelCase    : Tuple ,       ):
												'''simple docstring'''






												return rescale(_a ,       scale=_a ,       data_format=_a ,       **_a  )






					def lowerCamelCase__							(       self    : Dict ,       UpperCamelCase    : Any ,       UpperCamelCase    : Any ,       UpperCamelCase    : Optional[int] ,       UpperCamelCase    : Union[str, Any] = None ,       **UpperCamelCase    : Dict ,       ):
												'''simple docstring'''






												return normalize(_a ,       mean=_a ,       std=_a ,       data_format=_a ,       **_a  )






					def lowerCamelCase__							(       self    : Union[str, Any] ,       UpperCamelCase    : Union[str, Any] ,       UpperCamelCase    : Optional[Any] = None ,       UpperCamelCase    : Optional[Any] = None ,       UpperCamelCase    : Dict = None ,       UpperCamelCase    : Optional[int] = None ,       UpperCamelCase    : Optional[Any] = None ,       UpperCamelCase    : int = None ,       UpperCamelCase    : Any = None ,       UpperCamelCase    : Optional[int] = None ,       UpperCamelCase    : int = None ,       UpperCamelCase    : List[Any] = None ,       UpperCamelCase    : List[str] = None ,       UpperCamelCase    : int = None ,       UpperCamelCase    : List[str] = ChannelDimension.FIRST ,       **UpperCamelCase    : str ,       ):
												'''simple docstring'''






												__UpperCAmelCase   :						Dict      							=					do_resize if do_resize is not None else self.do_resize
												__UpperCAmelCase   :						str      							=					size if size is not None else self.size
												__UpperCAmelCase   :						Tuple      							=					get_size_dict(_a ,       param_name="""size""" ,       default_to_square=_a  )
												__UpperCAmelCase   :						Optional[Any]      							=					resample if resample is not None else self.resample
												__UpperCAmelCase   :						Union[str, Any]      							=					do_center_crop if do_center_crop is not None else self.do_center_crop
												__UpperCAmelCase   :						Optional[int]      							=					crop_size if crop_size is not None else self.crop_size
												__UpperCAmelCase   :						Dict      							=					get_size_dict(_a ,       param_name="""crop_size""" ,       default_to_square=_a  )
												__UpperCAmelCase   :						Optional[Any]      							=					do_rescale if do_rescale is not None else self.do_rescale
												__UpperCAmelCase   :						Dict      							=					rescale_factor if rescale_factor is not None else self.rescale_factor
												__UpperCAmelCase   :						Optional[int]      							=					do_normalize if do_normalize is not None else self.do_normalize
												__UpperCAmelCase   :						List[Any]      							=					image_mean if image_mean is not None else self.image_mean
												__UpperCAmelCase   :						List[Any]      							=					image_std if image_std is not None else self.image_std
												__UpperCAmelCase   :						List[str]      							=					do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

												__UpperCAmelCase   :						List[Any]      							=					make_list_of_images(_a  )

												if not valid_images(_a  ):
																			raise ValueError(
																			    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
																			    """torch.Tensor, tf.Tensor or jax.ndarray."""  )

												if do_resize and size is None:
																			raise ValueError("""Size must be specified if do_resize is True."""  )

												if do_center_crop and crop_size is None:
																			raise ValueError("""Crop size must be specified if do_center_crop is True."""  )

												if do_rescale and rescale_factor is None:
																			raise ValueError("""Rescale factor must be specified if do_rescale is True."""  )

												if do_normalize and (image_mean is None or image_std is None):
																			raise ValueError("""Image mean and std must be specified if do_normalize is True."""  )

												# PIL RGBA images are converted to RGB
												if do_convert_rgb:
																			__UpperCAmelCase   :						Optional[Any]      							=					[convert_to_rgb(_a  ) for image in images]

												# All transformations expect numpy arrays.
												__UpperCAmelCase   :						Union[str, Any]      							=					[to_numpy_array(_a  ) for image in images]

												if do_resize:
																			__UpperCAmelCase   :						List[Any]      							=					[self.resize(image=_a ,       size=_a ,       resample=_a  ) for image in images]

												if do_center_crop:
																			__UpperCAmelCase   :						Tuple      							=					[self.center_crop(image=_a ,       size=_a  ) for image in images]

												if do_rescale:
																			__UpperCAmelCase   :						Union[str, Any]      							=					[self.rescale(image=_a ,       scale=_a  ) for image in images]

												if do_normalize:
																			__UpperCAmelCase   :						List[str]      							=					[self.normalize(image=_a ,       mean=_a ,       std=_a  ) for image in images]

												__UpperCAmelCase   :						Dict      							=					[to_channel_dimension_format(_a ,       _a  ) for image in images]

												__UpperCAmelCase   :						Any      							=					{"pixel_values": images}
												return BatchFeature(data=_a ,       tensor_type=_a  )


from collections import OrderedDict
from typing import Mapping

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


snake_case :		Dict							      =  logging.get_logger(__name__)

snake_case :		List[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					(     snake_case				):
			UpperCamelCase__          =    'convbert'







			def __init__(				self						,   _a=30_522						,   _a=768						,   _a=12						,   _a=12						,   _a=3_072						,   _a="gelu"						,   _a=0.1						,   _a=0.1						,   _a=512						,   _a=2						,   _a=0.02						,   _a=1e-12						,   _a=1						,   _a=0						,   _a=2						,   _a=768						,   _a=2						,   _a=9						,   _a=1						,   _a=None						,   **_a						,   ):
				super().__init__(
				    pad_token_id=_a						,   bos_token_id=_a						,   eos_token_id=_a						,   **_a						,   )

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







class       _snake_case					(     snake_case				):







			@property
			def 			SCREAMING_SNAKE_CASE    (				self		):
				if self.task == "multiple-choice":
					__magic_name__		:		Dict	   =     {0: "batch", 1: "choice", 2: "sequence"}
				else:
					__magic_name__		:		Dict	   =     {0: "batch", 1: "sequence"}
				return OrderedDict(
				    [
				        ("input_ids", dynamic_axis),
				        ("attention_mask", dynamic_axis),
				        ("token_type_ids", dynamic_axis),
				    ]		)
