


"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE :    Any									=				logging.get_logger(__name__)

SCREAMING_SNAKE_CASE :    str									=				{
    """sayakpaul/vit-msn-base""": """https://huggingface.co/sayakpaul/vit-msn-base/resolve/main/config.json""",
    # See all ViT MSN models at https://huggingface.co/models?filter=vit_msn
}



class 			_UpperCAmelCase (							__snake_case				):






		'''simple docstring'''

		lowerCamelCase__				='vit_msn'



		def __init__(self				,       a_=7_68				,       a_=12				,       a_=12				,       a_=30_72				,       a_="gelu"				,       a_=0.0				,       a_=0.0				,       a_=0.02				,       a_=1E-06				,       a_=2_24				,       a_=16				,       a_=3				,       a_=True				,       **a_				,       ):





			'''simple docstring'''

			super().__init__(**a_					)

			__snake_case	:						Any						=				hidden_size
			__snake_case	:						Optional[Any]						=				num_hidden_layers
			__snake_case	:						int						=				num_attention_heads
			__snake_case	:						Dict						=				intermediate_size
			__snake_case	:						Tuple						=				hidden_act
			__snake_case	:						Optional[int]						=				hidden_dropout_prob
			__snake_case	:						List[Any]						=				attention_probs_dropout_prob
			__snake_case	:						int						=				initializer_range
			__snake_case	:						int						=				layer_norm_eps
			__snake_case	:						Any						=				image_size
			__snake_case	:						Any						=				patch_size
			__snake_case	:						int						=				num_channels
			__snake_case	:						str						=				qkv_bias








from typing import Dict

from .base import GenericTensor, Pipeline


class  A						(							_UpperCAmelCase ):







    """simple docstring"""





    def 						snake_case__     (      self :       int,lowercase_ :       Dict=None,lowercase_ :       Tuple=None,lowercase_ :       List[Any]=None,**lowercase_ :       Any		)->    Optional[Any]:





        '''simple docstring'''







        if tokenize_kwargs is None:
            A__          =   {}

        if truncation is not None:
            if "truncation" in tokenize_kwargs:
                raise ValueError(
                    'truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)'		)
            A__          =   truncation

        A__          =   tokenize_kwargs

        A__          =   {}
        if return_tensors is not None:
            A__          =   return_tensors

        return preprocess_params, {}, postprocess_params


    def 						snake_case__     (      self :       Dict,lowercase_ :       List[Any],**lowercase_ :       Tuple		)->    Dict[str, GenericTensor]:





        '''simple docstring'''







        A__          =   self.framework
        A__          =   self.tokenizer(lowercase_,return_tensors=lowercase_,**lowercase_		)
        return model_inputs


    def 						snake_case__     (      self :       Tuple,lowercase_ :       int		)->    Optional[Any]:





        '''simple docstring'''







        A__          =   self.model(**lowercase_		)
        return model_outputs


    def 						snake_case__     (      self :       Tuple,lowercase_ :       Tuple,lowercase_ :       List[str]=False		)->    Any:





        '''simple docstring'''







        if return_tensors:
            return model_outputs[0]
        if self.framework == "pt":
            return model_outputs[0].tolist()
        elif self.framework == "tf":
            return model_outputs[0].numpy().tolist()


    def __call__(      self :       List[Any],*lowercase_ :       int,**lowercase_ :       Optional[Any]		)->    int:





        '''simple docstring'''







        return super().__call__(*lowercase_,**lowercase_		)

