




from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_outputs import (
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import logging
from .configuration_regnet import RegNetConfig


__a							     =					logging.get_logger(__name__)

# General docstring
__a							     =					'RegNetConfig'

# Base docstring
__a							     =					'facebook/regnet-y-040'
__a							     =					[1, 1_088, 7, 7]

# Image classification docstring
__a							     =					'facebook/regnet-y-040'
__a							     =					'tabby, tabby cat'

__a							     =					[
    'facebook/regnet-y-040',
    # See all regnet models at https://huggingface.co/models?filter=regnet
]

class     __a(	nn.Module  ):






    """simple docstring"""





    def __init__( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE = 3  ,_SCREAMING_SNAKE_CASE = 1  ,_SCREAMING_SNAKE_CASE = 1  ,_SCREAMING_SNAKE_CASE = "relu"  ,)					->						Dict:
         super().__init__()
         UpperCAmelCase_     :				List[Any]  =     nn.Convad(
             _SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,kernel_size=_SCREAMING_SNAKE_CASE  ,stride=_SCREAMING_SNAKE_CASE  ,padding=kernel_size // 2  ,groups=_SCREAMING_SNAKE_CASE  ,bias=_SCREAMING_SNAKE_CASE  ,)
         UpperCAmelCase_     :				List[str]  =     nn.BatchNormad(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				Any  =     ACTaFN[activation] if activation is not None else nn.Identity()





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE    )					->						Tuple:
         UpperCAmelCase_     :				List[str]  =     self.convolution(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				Union[str, Any]  =     self.normalization(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				str  =     self.activation(_SCREAMING_SNAKE_CASE    )
         return hidden_state


class     __a(	nn.Module  ):






    """simple docstring"""





    def __init__( self  ,_SCREAMING_SNAKE_CASE    )					->						int:
         super().__init__()
         UpperCAmelCase_     :				Optional[int]  =     RegNetConvLayer(
             config.num_channels  ,config.embedding_size  ,kernel_size=3  ,stride=2  ,activation=config.hidden_act    )
         UpperCAmelCase_     :				Optional[int]  =     config.num_channels





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE    )					->						str:
         UpperCAmelCase_     :				Dict  =     pixel_values.shape[1]
         if num_channels != self.num_channels:
              raise ValueError(
                  '''Make sure that the channel dimension of the pixel values match with the one set in the configuration.'''    )
         UpperCAmelCase_     :				Union[str, Any]  =     self.embedder(_SCREAMING_SNAKE_CASE    )
         return hidden_state


class     __a(	nn.Module  ):






    """simple docstring"""





    def __init__( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE = 2    )					->						List[Any]:
         super().__init__()
         UpperCAmelCase_     :				int  =     nn.Convad(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,kernel_size=1  ,stride=_SCREAMING_SNAKE_CASE  ,bias=_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				Any  =     nn.BatchNormad(_SCREAMING_SNAKE_CASE    )





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE    )					->						Tensor:
         UpperCAmelCase_     :				List[str]  =     self.convolution(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				Union[str, Any]  =     self.normalization(_SCREAMING_SNAKE_CASE    )
         return hidden_state


class     __a(	nn.Module  ):






    """simple docstring"""





    def __init__( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE    )					->						List[Any]:
         super().__init__()

         UpperCAmelCase_     :				str  =     nn.AdaptiveAvgPoolad((1, 1)    )
         UpperCAmelCase_     :				int  =     nn.Sequential(
             nn.Convad(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,kernel_size=1    )  ,nn.ReLU()  ,nn.Convad(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,kernel_size=1    )  ,nn.Sigmoid()  ,)





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE    )					->						Optional[Any]:
         # b c h w -> b c 1 1
         UpperCAmelCase_     :				int  =     self.pooler(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				Union[str, Any]  =     self.attention(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				Union[str, Any]  =     hidden_state * attention
         return hidden_state


class     __a(	nn.Module  ):






    """simple docstring"""





    def __init__( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE = 1    )					->						Union[str, Any]:
         super().__init__()
         UpperCAmelCase_     :				str  =     in_channels != out_channels or stride != 1
         UpperCAmelCase_     :				Optional[int]  =     max(1  ,out_channels // config.groups_width    )
         UpperCAmelCase_     :				int  =     (
             RegNetShortCut(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,stride=_SCREAMING_SNAKE_CASE    ) if should_apply_shortcut else nn.Identity()
         )
         UpperCAmelCase_     :				Dict  =     nn.Sequential(
             RegNetConvLayer(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,kernel_size=1  ,activation=config.hidden_act    )  ,RegNetConvLayer(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,stride=_SCREAMING_SNAKE_CASE  ,groups=_SCREAMING_SNAKE_CASE  ,activation=config.hidden_act    )  ,RegNetConvLayer(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,kernel_size=1  ,activation=_SCREAMING_SNAKE_CASE    )  ,)
         UpperCAmelCase_     :				List[str]  =     ACTaFN[config.hidden_act]





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE    )					->						Union[str, Any]:
         UpperCAmelCase_     :				int  =     hidden_state
         UpperCAmelCase_     :				Optional[Any]  =     self.layer(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				int  =     self.shortcut(_SCREAMING_SNAKE_CASE    )
         hidden_state += residual
         UpperCAmelCase_     :				Optional[int]  =     self.activation(_SCREAMING_SNAKE_CASE    )
         return hidden_state


class     __a(	nn.Module  ):






    """simple docstring"""





    def __init__( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE = 1    )					->						Any:
         super().__init__()
         UpperCAmelCase_     :				Optional[int]  =     in_channels != out_channels or stride != 1
         UpperCAmelCase_     :				Dict  =     max(1  ,out_channels // config.groups_width    )
         UpperCAmelCase_     :				List[Any]  =     (
             RegNetShortCut(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,stride=_SCREAMING_SNAKE_CASE    ) if should_apply_shortcut else nn.Identity()
         )
         UpperCAmelCase_     :				List[str]  =     nn.Sequential(
             RegNetConvLayer(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,kernel_size=1  ,activation=config.hidden_act    )  ,RegNetConvLayer(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,stride=_SCREAMING_SNAKE_CASE  ,groups=_SCREAMING_SNAKE_CASE  ,activation=config.hidden_act    )  ,RegNetSELayer(_SCREAMING_SNAKE_CASE  ,reduced_channels=int(round(in_channels / 4    )    )    )  ,RegNetConvLayer(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,kernel_size=1  ,activation=_SCREAMING_SNAKE_CASE    )  ,)
         UpperCAmelCase_     :				List[str]  =     ACTaFN[config.hidden_act]





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE    )					->						Union[str, Any]:
         UpperCAmelCase_     :				Dict  =     hidden_state
         UpperCAmelCase_     :				Union[str, Any]  =     self.layer(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				int  =     self.shortcut(_SCREAMING_SNAKE_CASE    )
         hidden_state += residual
         UpperCAmelCase_     :				Optional[int]  =     self.activation(_SCREAMING_SNAKE_CASE    )
         return hidden_state


class     __a(	nn.Module  ):






    """simple docstring"""





    def __init__( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE = 2  ,_SCREAMING_SNAKE_CASE = 2  ,)					->						Optional[int]:
         super().__init__()

         UpperCAmelCase_     :				Dict  =     RegNetXLayer if config.layer_type == '''x''' else RegNetYLayer

         UpperCAmelCase_     :				Dict  =     nn.Sequential(
             # downsampling is done in the first layer with stride of 2
             layer(
                 _SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,stride=_SCREAMING_SNAKE_CASE  ,)  ,*[layer(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE    ) for _ in range(depth - 1    )]  ,)





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE    )					->						str:
         UpperCAmelCase_     :				int  =     self.layers(_SCREAMING_SNAKE_CASE    )
         return hidden_state


class     __a(	nn.Module  ):






    """simple docstring"""





    def __init__( self  ,_SCREAMING_SNAKE_CASE    )					->						Union[str, Any]:
         super().__init__()
         UpperCAmelCase_     :				Tuple  =     nn.ModuleList([]    )
         # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
         self.stages.append(
             RegNetStage(
                 _SCREAMING_SNAKE_CASE  ,config.embedding_size  ,config.hidden_sizes[0]  ,stride=2 if config.downsample_in_first_stage else 1  ,depth=config.depths[0]  ,)    )
         UpperCAmelCase_     :				Optional[int]  =     zip(config.hidden_sizes  ,config.hidden_sizes[1:]    )
         for (in_channels, out_channels), depth in zip(_SCREAMING_SNAKE_CASE  ,config.depths[1:]    ):
              self.stages.append(RegNetStage(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,depth=_SCREAMING_SNAKE_CASE    )    )





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE = False  ,_SCREAMING_SNAKE_CASE = True    )					->						BaseModelOutputWithNoAttention:
         UpperCAmelCase_     :				Union[str, Any]  =     () if output_hidden_states else None

         for stage_module in self.stages:
              if output_hidden_states:
                   UpperCAmelCase_     :				Any  =     hidden_states + (hidden_state,)

              UpperCAmelCase_     :				Dict  =     stage_module(_SCREAMING_SNAKE_CASE    )

         if output_hidden_states:
              UpperCAmelCase_     :				Dict  =     hidden_states + (hidden_state,)

         if not return_dict:
              return tuple(v for v in [hidden_state, hidden_states] if v is not None    )

         return BaseModelOutputWithNoAttention(last_hidden_state=_SCREAMING_SNAKE_CASE  ,hidden_states=_SCREAMING_SNAKE_CASE    )


class     __a(	_a  ):






    """simple docstring"""





    lowerCAmelCase         = RegNetConfig
    lowerCAmelCase         = '''regnet'''
    lowerCAmelCase         = '''pixel_values'''
    lowerCAmelCase         = True





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE    )					->						str:
         if isinstance(_SCREAMING_SNAKE_CASE  ,nn.Convad    ):
              nn.init.kaiming_normal_(module.weight  ,mode='''fan_out'''  ,nonlinearity='''relu'''    )
         elif isinstance(_SCREAMING_SNAKE_CASE  ,(nn.BatchNormad, nn.GroupNorm)    ):
              nn.init.constant_(module.weight  ,1    )
              nn.init.constant_(module.bias  ,0    )





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE=False    )					->						Dict:
         if isinstance(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE    ):
              UpperCAmelCase_     :				List[Any]  =     value


__a							     =					R'\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n'

__a							     =					R'\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.\n'

@add_start_docstrings(
    '''The bare RegNet model outputting raw features without any specific head on top.'''							,		_a							,		)
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class     __a(	_a  ):






    """simple docstring"""





    def __init__( self  ,_SCREAMING_SNAKE_CASE    )					->						Union[str, Any]:
         super().__init__(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				Tuple  =     config
         UpperCAmelCase_     :				List[Any]  =     RegNetEmbeddings(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				Optional[Any]  =     RegNetEncoder(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				str  =     nn.AdaptiveAvgPoolad((1, 1)    )
         # Initialize weights and apply final processing
         self.post_init()





    @add_start_docstrings_to_model_forward(_SCREAMING_SNAKE_CASE    )
    @add_code_sample_docstrings(
        checkpoint=_CHECKPOINT_FOR_DOC  ,output_type=_SCREAMING_SNAKE_CASE  ,config_class=_CONFIG_FOR_DOC  ,modality='''vision'''  ,expected_output=_EXPECTED_OUTPUT_SHAPE  ,)
    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE = None  ,_SCREAMING_SNAKE_CASE = None    )					->						BaseModelOutputWithPoolingAndNoAttention:
         UpperCAmelCase_     :				Optional[Any]  =     (
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         UpperCAmelCase_     :				Any  =     return_dict if return_dict is not None else self.config.use_return_dict

         UpperCAmelCase_     :				int  =     self.embedder(_SCREAMING_SNAKE_CASE    )

         UpperCAmelCase_     :				int  =     self.encoder(
             _SCREAMING_SNAKE_CASE  ,output_hidden_states=_SCREAMING_SNAKE_CASE  ,return_dict=_SCREAMING_SNAKE_CASE    )

         UpperCAmelCase_     :				str  =     encoder_outputs[0]

         UpperCAmelCase_     :				Optional[int]  =     self.pooler(_SCREAMING_SNAKE_CASE    )

         if not return_dict:
              return (last_hidden_state, pooled_output) + encoder_outputs[1:]

         return BaseModelOutputWithPoolingAndNoAttention(
             last_hidden_state=_SCREAMING_SNAKE_CASE  ,pooler_output=_SCREAMING_SNAKE_CASE  ,hidden_states=encoder_outputs.hidden_states  ,)


@add_start_docstrings(
    '''
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''							,		_a							,		)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class     __a(	_a  ):






    """simple docstring"""





    def __init__( self  ,_SCREAMING_SNAKE_CASE    )					->						str:
         super().__init__(_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				Optional[Any]  =     config.num_labels
         UpperCAmelCase_     :				Optional[int]  =     RegNetModel(_SCREAMING_SNAKE_CASE    )
         # classification head
         UpperCAmelCase_     :				Any  =     nn.Sequential(
             nn.Flatten()  ,nn.Linear(config.hidden_sizes[-1]  ,config.num_labels    ) if config.num_labels > 0 else nn.Identity()  ,)
         # initialize weights and apply final processing
         self.post_init()





    @add_start_docstrings_to_model_forward(_SCREAMING_SNAKE_CASE    )
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT  ,output_type=_SCREAMING_SNAKE_CASE  ,config_class=_CONFIG_FOR_DOC  ,expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT  ,)
    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE = None  ,_SCREAMING_SNAKE_CASE = None  ,_SCREAMING_SNAKE_CASE = None  ,_SCREAMING_SNAKE_CASE = None  ,)					->						ImageClassifierOutputWithNoAttention:
         UpperCAmelCase_     :				Optional[Any]  =     return_dict if return_dict is not None else self.config.use_return_dict

         UpperCAmelCase_     :				Optional[Any]  =     self.regnet(_SCREAMING_SNAKE_CASE  ,output_hidden_states=_SCREAMING_SNAKE_CASE  ,return_dict=_SCREAMING_SNAKE_CASE    )

         UpperCAmelCase_     :				Optional[Any]  =     outputs.pooler_output if return_dict else outputs[1]

         UpperCAmelCase_     :				int  =     self.classifier(_SCREAMING_SNAKE_CASE    )

         UpperCAmelCase_     :				Optional[int]  =     None

         if labels is not None:
              if self.config.problem_type is None:
                   if self.num_labels == 1:
                        UpperCAmelCase_     :				Optional[int]  =     '''regression'''
                   elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
                        UpperCAmelCase_     :				List[str]  =     '''single_label_classification'''
                   else:
                        UpperCAmelCase_     :				Union[str, Any]  =     '''multi_label_classification'''
              if self.config.problem_type == "regression":
                   UpperCAmelCase_     :				str  =     MSELoss()
                   if self.num_labels == 1:
                        UpperCAmelCase_     :				str  =     loss_fct(logits.squeeze()  ,labels.squeeze()    )
                   else:
                        UpperCAmelCase_     :				Optional[Any]  =     loss_fct(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE    )
              elif self.config.problem_type == "single_label_classification":
                   UpperCAmelCase_     :				str  =     CrossEntropyLoss()
                   UpperCAmelCase_     :				int  =     loss_fct(logits.view(-1  ,self.num_labels    )  ,labels.view(-1    )    )
              elif self.config.problem_type == "multi_label_classification":
                   UpperCAmelCase_     :				List[Any]  =     BCEWithLogitsLoss()
                   UpperCAmelCase_     :				Any  =     loss_fct(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE    )

         if not return_dict:
              UpperCAmelCase_     :				int  =     (logits,) + outputs[2:]
              return (loss,) + output if loss is not None else output

         return ImageClassifierOutputWithNoAttention(loss=_SCREAMING_SNAKE_CASE  ,logits=_SCREAMING_SNAKE_CASE  ,hidden_states=outputs.hidden_states    )





from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional

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


if TYPE_CHECKING:
     from ... import FeatureExtractionMixin, TensorType

__a							     =					logging.get_logger(__name__)

__a							     =					{
    'openai/imagegpt-small': '',
    'openai/imagegpt-medium': '',
    'openai/imagegpt-large': '',
}

class     __a(	_a  ):






    """simple docstring"""





    lowerCAmelCase         = '''imagegpt'''
    lowerCAmelCase         = ['''past_key_values''']
    lowerCAmelCase         = {
        '''hidden_size''': '''n_embd''',
        '''max_position_embeddings''': '''n_positions''',
        '''num_attention_heads''': '''n_head''',
        '''num_hidden_layers''': '''n_layer''',
    }





    def __init__( self  ,_SCREAMING_SNAKE_CASE=512 + 1  ,_SCREAMING_SNAKE_CASE=32 * 32  ,_SCREAMING_SNAKE_CASE=512  ,_SCREAMING_SNAKE_CASE=24  ,_SCREAMING_SNAKE_CASE=8  ,_SCREAMING_SNAKE_CASE=None  ,_SCREAMING_SNAKE_CASE="quick_gelu"  ,_SCREAMING_SNAKE_CASE=0.1  ,_SCREAMING_SNAKE_CASE=0.1  ,_SCREAMING_SNAKE_CASE=0.1  ,_SCREAMING_SNAKE_CASE=1e-5  ,_SCREAMING_SNAKE_CASE=0.02  ,_SCREAMING_SNAKE_CASE=True  ,_SCREAMING_SNAKE_CASE=True  ,_SCREAMING_SNAKE_CASE=False  ,_SCREAMING_SNAKE_CASE=False  ,_SCREAMING_SNAKE_CASE=False  ,**_SCREAMING_SNAKE_CASE  ,)					->						Optional[int]:
         UpperCAmelCase_     :				Optional[int]  =     vocab_size
         UpperCAmelCase_     :				Union[str, Any]  =     n_positions
         UpperCAmelCase_     :				Union[str, Any]  =     n_embd
         UpperCAmelCase_     :				Any  =     n_layer
         UpperCAmelCase_     :				Optional[Any]  =     n_head
         UpperCAmelCase_     :				Union[str, Any]  =     n_inner
         UpperCAmelCase_     :				List[Any]  =     activation_function
         UpperCAmelCase_     :				List[str]  =     resid_pdrop
         UpperCAmelCase_     :				str  =     embd_pdrop
         UpperCAmelCase_     :				Optional[Any]  =     attn_pdrop
         UpperCAmelCase_     :				Dict  =     layer_norm_epsilon
         UpperCAmelCase_     :				Union[str, Any]  =     initializer_range
         UpperCAmelCase_     :				Dict  =     scale_attn_weights
         UpperCAmelCase_     :				Any  =     use_cache
         UpperCAmelCase_     :				List[str]  =     scale_attn_by_inverse_layer_idx
         UpperCAmelCase_     :				Tuple  =     reorder_and_upcast_attn
         UpperCAmelCase_     :				int  =     tie_word_embeddings

         super().__init__(tie_word_embeddings=_SCREAMING_SNAKE_CASE  ,**_SCREAMING_SNAKE_CASE    )


class     __a(	_a  ):






    """simple docstring"""





    @property
    def 				a__ ( self    )					->						Mapping[str, Mapping[int, str]]:
         return OrderedDict(
             [
                 ('''input_ids''', {0: '''batch''', 1: '''sequence'''}),
             ]    )





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE = 1  ,_SCREAMING_SNAKE_CASE = -1  ,_SCREAMING_SNAKE_CASE = False  ,_SCREAMING_SNAKE_CASE = None  ,_SCREAMING_SNAKE_CASE = 3  ,_SCREAMING_SNAKE_CASE = 32  ,_SCREAMING_SNAKE_CASE = 32  ,)					->						Mapping[str, Any]:
         UpperCAmelCase_     :				Any  =     self._generate_dummy_images(_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE    )
         UpperCAmelCase_     :				Optional[int]  =     dict(preprocessor(images=_SCREAMING_SNAKE_CASE  ,return_tensors=_SCREAMING_SNAKE_CASE    )    )

         return inputs