




'''simple docstring'''






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, 1088, 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        lowercase_      (						nn.Module							):





     def __init__(     self     :					str     ,							__lowerCamelCase     :					Optional[Any]     ,							__lowerCamelCase     :					Tuple     ,							__lowerCamelCase     :					Tuple = 3     ,							__lowerCamelCase     :					Tuple = 1     ,							__lowerCamelCase     :					int = 1     ,							__lowerCamelCase     :					Optional[Any] = "relu"     ,							):
           super().__init__()
           snake_case__       :   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     ,							)
           snake_case__       :   List[str]	      =    nn.BatchNormad(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Any	      =    ACTaFN[activation] if activation is not None else nn.Identity()





     def 			_lowerCAmelCase      (     self     :					str     ,							__lowerCamelCase     :					Optional[Any]			):
           snake_case__       :   List[str]	      =    self.convolution(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Union[str, Any]	      =    self.normalization(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   str	      =    self.activation(_SCREAMING_SNAKE_CASE			)
           return hidden_state






class        lowercase_      (						nn.Module							):





     def __init__(     self     :					Any     ,							__lowerCamelCase     :					Any			):
           super().__init__()
           snake_case__       :   Optional[int]	      =    RegNetConvLayer(
               config.num_channels     ,							config.embedding_size     ,							kernel_size=3     ,							stride=2     ,							activation=config.hidden_act			)
           snake_case__       :   Optional[int]	      =    config.num_channels





     def 			_lowerCAmelCase      (     self     :					Union[str, Any]     ,							__lowerCamelCase     :					str			):
           snake_case__       :   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.'			)
           snake_case__       :   Union[str, Any]	      =    self.embedder(_SCREAMING_SNAKE_CASE			)
           return hidden_state






class        lowercase_      (						nn.Module							):





     def __init__(     self     :					Optional[int]     ,							__lowerCamelCase     :					Dict     ,							__lowerCamelCase     :					int     ,							__lowerCamelCase     :					List[str] = 2			):
           super().__init__()
           snake_case__       :   int	      =    nn.Convad(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE     ,							kernel_size=1     ,							stride=_SCREAMING_SNAKE_CASE     ,							bias=_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Any	      =    nn.BatchNormad(_SCREAMING_SNAKE_CASE			)





     def 			_lowerCAmelCase      (     self     :					Dict     ,							__lowerCamelCase     :					Optional[Any]			):
           snake_case__       :   List[str]	      =    self.convolution(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Union[str, Any]	      =    self.normalization(_SCREAMING_SNAKE_CASE			)
           return hidden_state






class        lowercase_      (						nn.Module							):





     def __init__(     self     :					Any     ,							__lowerCamelCase     :					Optional[int]     ,							__lowerCamelCase     :					List[Any]			):
           super().__init__()

           snake_case__       :   str	      =    nn.AdaptiveAvgPoolad((1, 1)			)
           snake_case__       :   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 			_lowerCAmelCase      (     self     :					Optional[Any]     ,							__lowerCamelCase     :					Any			):
           # b c h w -> b c 1 1
           snake_case__       :   int	      =    self.pooler(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Union[str, Any]	      =    self.attention(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Union[str, Any]	      =    hidden_state * attention
           return hidden_state






class        lowercase_      (						nn.Module							):





     def __init__(     self     :					Dict     ,							__lowerCamelCase     :					str     ,							__lowerCamelCase     :					int     ,							__lowerCamelCase     :					int     ,							__lowerCamelCase     :					str = 1			):
           super().__init__()
           snake_case__       :   str	      =    in_channels != out_channels or stride != 1
           snake_case__       :   Optional[int]	      =    max(1     ,							out_channels // config.groups_width			)
           snake_case__       :   int	      =    (
               RegNetShortCut(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE     ,							stride=_SCREAMING_SNAKE_CASE			) if should_apply_shortcut else nn.Identity()
           )
           snake_case__       :   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			)     ,							)
           snake_case__       :   List[str]	      =    ACTaFN[config.hidden_act]





     def 			_lowerCAmelCase      (     self     :					Dict     ,							__lowerCamelCase     :					int			):
           snake_case__       :   int	      =    hidden_state
           snake_case__       :   Optional[Any]	      =    self.layer(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   int	      =    self.shortcut(_SCREAMING_SNAKE_CASE			)
           hidden_state += residual
           snake_case__       :   Optional[int]	      =    self.activation(_SCREAMING_SNAKE_CASE			)
           return hidden_state






class        lowercase_      (						nn.Module							):





     def __init__(     self     :					Any     ,							__lowerCamelCase     :					List[Any]     ,							__lowerCamelCase     :					Any     ,							__lowerCamelCase     :					int     ,							__lowerCamelCase     :					Union[str, Any] = 1			):
           super().__init__()
           snake_case__       :   Optional[int]	      =    in_channels != out_channels or stride != 1
           snake_case__       :   Dict	      =    max(1     ,							out_channels // config.groups_width			)
           snake_case__       :   List[Any]	      =    (
               RegNetShortCut(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE     ,							stride=_SCREAMING_SNAKE_CASE			) if should_apply_shortcut else nn.Identity()
           )
           snake_case__       :   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			)     ,							)
           snake_case__       :   List[str]	      =    ACTaFN[config.hidden_act]





     def 			_lowerCAmelCase      (     self     :					Dict     ,							__lowerCamelCase     :					str			):
           snake_case__       :   Dict	      =    hidden_state
           snake_case__       :   Union[str, Any]	      =    self.layer(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   int	      =    self.shortcut(_SCREAMING_SNAKE_CASE			)
           hidden_state += residual
           snake_case__       :   Optional[int]	      =    self.activation(_SCREAMING_SNAKE_CASE			)
           return hidden_state






class        lowercase_      (						nn.Module							):





     def __init__(     self     :					str     ,							__lowerCamelCase     :					str     ,							__lowerCamelCase     :					Union[str, Any]     ,							__lowerCamelCase     :					Optional[Any]     ,							__lowerCamelCase     :					int = 2     ,							__lowerCamelCase     :					List[Any] = 2     ,							):
           super().__init__()

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

           snake_case__       :   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 			_lowerCAmelCase      (     self     :					List[str]     ,							__lowerCamelCase     :					Tuple			):
           snake_case__       :   int	      =    self.layers(_SCREAMING_SNAKE_CASE			)
           return hidden_state






class        lowercase_      (						nn.Module							):





     def __init__(     self     :					List[str]     ,							__lowerCamelCase     :					List[str]			):
           super().__init__()
           snake_case__       :   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]     ,							)			)
           snake_case__       :   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 			_lowerCAmelCase      (     self     :					str     ,							__lowerCamelCase     :					Any     ,							__lowerCamelCase     :					Optional[Any] = False     ,							__lowerCamelCase     :					Optional[int] = True			):
           snake_case__       :   Union[str, Any]	      =    () if output_hidden_states else None

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

                 snake_case__       :   Dict	      =    stage_module(_SCREAMING_SNAKE_CASE			)

           if output_hidden_states:
                 snake_case__       :   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        lowercase_      (						_a							):
     A_											=			RegNetConfig
     A_											=			"regnet"
     A_											=			"pixel_values"
     A_											=			True





     def 			_lowerCAmelCase      (     self     :					Tuple     ,							__lowerCamelCase     :					Union[str, Any]			):
           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 			_lowerCAmelCase      (     self     :					Dict     ,							__lowerCamelCase     :					Tuple     ,							__lowerCamelCase     :					int=False			):
           if isinstance(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE			):
                 snake_case__       :   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        lowercase_      (						_a							):





     def __init__(     self     :					Optional[int]     ,							__lowerCamelCase     :					Optional[int]			):
           super().__init__(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Tuple	      =    config
           snake_case__       :   List[Any]	      =    RegNetEmbeddings(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Optional[Any]	      =    RegNetEncoder(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   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 			_lowerCAmelCase      (     self     :					str     ,							__lowerCamelCase     :					str     ,							__lowerCamelCase     :					str = None     ,							__lowerCamelCase     :					Dict = None			):
           snake_case__       :   Optional[Any]	      =    (
               output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
           )
           snake_case__       :   Any	      =    return_dict if return_dict is not None else self.config.use_return_dict

           snake_case__       :   int	      =    self.embedder(_SCREAMING_SNAKE_CASE			)

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

           snake_case__       :   str	      =    encoder_outputs[0]

           snake_case__       :   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(
    "\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "						,       _a						,       )
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class        lowercase_      (						_a							):





     def __init__(     self     :					int     ,							__lowerCamelCase     :					Optional[int]			):
           super().__init__(_SCREAMING_SNAKE_CASE			)
           snake_case__       :   Optional[Any]	      =    config.num_labels
           snake_case__       :   Optional[int]	      =    RegNetModel(_SCREAMING_SNAKE_CASE			)
           # classification head
           snake_case__       :   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 			_lowerCAmelCase      (     self     :					Dict     ,							__lowerCamelCase     :					List[Any] = None     ,							__lowerCamelCase     :					str = None     ,							__lowerCamelCase     :					int = None     ,							__lowerCamelCase     :					int = None     ,							):
           snake_case__       :   Optional[Any]	      =    return_dict if return_dict is not None else self.config.use_return_dict

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

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

           snake_case__       :   int	      =    self.classifier(_SCREAMING_SNAKE_CASE			)

           snake_case__       :   Optional[int]	      =    None

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

           if not return_dict:
                 snake_case__       :   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