


'''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 :  Optional[Any]    							=				logging.get_logger(__name__)

# General docstring
__A :  str    							=				"RegNetConfig"

# Base docstring
__A :  List[str]    							=				"facebook/regnet-y-040"
__A :  List[str]    							=				[1, 1088, 7, 7]

# Image classification docstring
__A :  Optional[Any]    							=				"facebook/regnet-y-040"
__A :  Optional[int]    							=				"tabby, tabby cat"

__A :  List[Any]    							=				[
    "facebook/regnet-y-040",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]






class        __snake_case	(       nn.Module):







    """simple docstring"""



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





    def __lowercase       (       self   :  int   ,						lowerCamelCase   :  Union[str, Any]		)       ->  Any:
      lowerCAmelCase_      :				int      =       self.convolution(lowerCamelCase		)
      lowerCAmelCase_      :				str      =       self.normalization(lowerCamelCase		)
      lowerCAmelCase_      :				int      =       self.activation(lowerCamelCase		)
      return hidden_state







class        __snake_case	(       nn.Module):







    """simple docstring"""



    def __init__(       self   :  List[Any]   ,						lowerCamelCase   :  RegNetConfig		)       ->  List[Any]:
      super().__init__()
      lowerCAmelCase_      :				Union[str, Any]      =       RegNetConvLayer(
          config.num_channels   ,						config.embedding_size   ,						kernel_size=3   ,						stride=2   ,						activation=config.hidden_act		)
      lowerCAmelCase_      :				str      =       config.num_channels





    def __lowercase       (       self   :  Optional[Any]   ,						lowerCamelCase   :  Optional[int]		)       ->  List[Any]:
      lowerCAmelCase_      :				Union[str, Any]      =       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."""		)
      lowerCAmelCase_      :				Dict      =       self.embedder(lowerCamelCase		)
      return hidden_state







class        __snake_case	(       nn.Module):







    """simple docstring"""



    def __init__(       self   :  Union[str, Any]   ,						lowerCamelCase   :  int   ,						lowerCamelCase   :  int   ,						lowerCamelCase   :  int = 2		)       ->  Optional[Any]:
      super().__init__()
      lowerCAmelCase_      :				int      =       nn.Convad(lowerCamelCase   ,						lowerCamelCase   ,						kernel_size=1   ,						stride=lowerCamelCase   ,						bias=lowerCamelCase		)
      lowerCAmelCase_      :				List[Any]      =       nn.BatchNormad(lowerCamelCase		)





    def __lowercase       (       self   :  str   ,						lowerCamelCase   :  Tensor		)       ->  Tensor:
      lowerCAmelCase_      :				int      =       self.convolution(lowerCamelCase		)
      lowerCAmelCase_      :				Any      =       self.normalization(lowerCamelCase		)
      return hidden_state







class        __snake_case	(       nn.Module):







    """simple docstring"""



    def __init__(       self   :  Dict   ,						lowerCamelCase   :  int   ,						lowerCamelCase   :  int		)       ->  List[str]:
      super().__init__()

      lowerCAmelCase_      :				List[Any]      =       nn.AdaptiveAvgPoolad((1, 1)		)
      lowerCAmelCase_      :				Dict      =       nn.Sequential(
          nn.Convad(lowerCamelCase   ,						lowerCamelCase   ,						kernel_size=1		)   ,						nn.ReLU()   ,						nn.Convad(lowerCamelCase   ,						lowerCamelCase   ,						kernel_size=1		)   ,						nn.Sigmoid()   ,						)





    def __lowercase       (       self   :  str   ,						lowerCamelCase   :  int		)       ->  List[str]:
      # b c h w -> b c 1 1
      lowerCAmelCase_      :				str      =       self.pooler(lowerCamelCase		)
      lowerCAmelCase_      :				int      =       self.attention(lowerCamelCase		)
      lowerCAmelCase_      :				Optional[int]      =       hidden_state * attention
      return hidden_state







class        __snake_case	(       nn.Module):







    """simple docstring"""



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





    def __lowercase       (       self   :  Optional[int]   ,						lowerCamelCase   :  Any		)       ->  Any:
      lowerCAmelCase_      :				str      =       hidden_state
      lowerCAmelCase_      :				List[Any]      =       self.layer(lowerCamelCase		)
      lowerCAmelCase_      :				Optional[int]      =       self.shortcut(lowerCamelCase		)
      hidden_state += residual
      lowerCAmelCase_      :				Optional[Any]      =       self.activation(lowerCamelCase		)
      return hidden_state







class        __snake_case	(       nn.Module):







    """simple docstring"""



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





    def __lowercase       (       self   :  Tuple   ,						lowerCamelCase   :  Dict		)       ->  int:
      lowerCAmelCase_      :				Optional[int]      =       hidden_state
      lowerCAmelCase_      :				Optional[Any]      =       self.layer(lowerCamelCase		)
      lowerCAmelCase_      :				int      =       self.shortcut(lowerCamelCase		)
      hidden_state += residual
      lowerCAmelCase_      :				Tuple      =       self.activation(lowerCamelCase		)
      return hidden_state







class        __snake_case	(       nn.Module):







    """simple docstring"""



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

      lowerCAmelCase_      :				Tuple      =       RegNetXLayer if config.layer_type == """x""" else RegNetYLayer

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





    def __lowercase       (       self   :  Optional[int]   ,						lowerCamelCase   :  str		)       ->  Union[str, Any]:
      lowerCAmelCase_      :				List[Any]      =       self.layers(lowerCamelCase		)
      return hidden_state







class        __snake_case	(       nn.Module):







    """simple docstring"""



    def __init__(       self   :  Union[str, Any]   ,						lowerCamelCase   :  RegNetConfig		)       ->  Optional[int]:
      super().__init__()
      lowerCAmelCase_      :				Optional[Any]      =       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(
              lowerCamelCase   ,						config.embedding_size   ,						config.hidden_sizes[0]   ,						stride=2 if config.downsample_in_first_stage else 1   ,						depth=config.depths[0]   ,						)		)
      lowerCAmelCase_      :				Tuple      =       zip(config.hidden_sizes   ,						config.hidden_sizes[1:]		)
      for (in_channels, out_channels), depth in zip(lowerCamelCase   ,						config.depths[1:]		):
        self.stages.append(RegNetStage(lowerCamelCase   ,						lowerCamelCase   ,						lowerCamelCase   ,						depth=lowerCamelCase		)		)





    def __lowercase       (       self   :  str   ,						lowerCamelCase   :  Tensor   ,						lowerCamelCase   :  bool = False   ,						lowerCamelCase   :  bool = True		)       ->  BaseModelOutputWithNoAttention:
      lowerCAmelCase_      :				Optional[int]      =       () if output_hidden_states else None

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

        lowerCAmelCase_      :				List[str]      =       stage_module(lowerCamelCase		)

      if output_hidden_states:
        lowerCAmelCase_      :				List[str]      =       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=lowerCamelCase   ,						hidden_states=lowerCamelCase		)







class        __snake_case	(       _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    lowercase       			= RegNetConfig
    lowercase       			= 'regnet'
    lowercase       			= 'pixel_values'
    lowercase       			= True

    def __lowercase       (       self   :  Union[str, Any]   ,						lowerCamelCase   :  Union[str, Any]		)       ->  Any:
      if isinstance(lowerCamelCase   ,						nn.Convad		):
        nn.init.kaiming_normal_(module.weight   ,						mode="""fan_out"""   ,						nonlinearity="""relu"""		)
      elif isinstance(lowerCamelCase   ,						(nn.BatchNormad, nn.GroupNorm)		):
        nn.init.constant_(module.weight   ,						1		)
        nn.init.constant_(module.bias   ,						0		)





    def __lowercase       (       self   :  Dict   ,						lowerCamelCase   :  str   ,						lowerCamelCase   :  Union[str, Any]=False		)       ->  Tuple:
      if isinstance(lowerCamelCase   ,						lowerCamelCase		):
        lowerCAmelCase_      :				List[Any]      =       value







__A :  str    							=				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 :  int    							=				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.'     ,_SCREAMING_SNAKE_CASE     ,)
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class        __snake_case	(       _SCREAMING_SNAKE_CASE):







    """simple docstring"""



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





    @add_start_docstrings_to_model_forward(lowerCamelCase		)
    @add_code_sample_docstrings(
        checkpoint=_CHECKPOINT_FOR_DOC   ,						output_type=lowerCamelCase   ,						config_class=_CONFIG_FOR_DOC   ,						modality="""vision"""   ,						expected_output=_EXPECTED_OUTPUT_SHAPE   ,						)
    def __lowercase       (       self   :  int   ,						lowerCamelCase   :  Tensor   ,						lowerCamelCase   :  Optional[bool] = None   ,						lowerCamelCase   :  Optional[bool] = None		)       ->  BaseModelOutputWithPoolingAndNoAttention:
      lowerCAmelCase_      :				str      =       (
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )
      lowerCAmelCase_      :				Optional[int]      =       return_dict if return_dict is not None else self.config.use_return_dict

      lowerCAmelCase_      :				Union[str, Any]      =       self.embedder(lowerCamelCase		)

      lowerCAmelCase_      :				Optional[int]      =       self.encoder(
          lowerCamelCase   ,						output_hidden_states=lowerCamelCase   ,						return_dict=lowerCamelCase		)

      lowerCAmelCase_      :				Dict      =       encoder_outputs[0]

      lowerCAmelCase_      :				Tuple      =       self.pooler(lowerCamelCase		)

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

      return BaseModelOutputWithPoolingAndNoAttention(
          last_hidden_state=lowerCamelCase   ,						pooler_output=lowerCamelCase   ,						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    '     ,_SCREAMING_SNAKE_CASE     ,)
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class        __snake_case	(       _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    def __init__(       self   :  Dict   ,						lowerCamelCase   :  Any		)       ->  Dict:
      super().__init__(lowerCamelCase		)
      lowerCAmelCase_      :				Any      =       config.num_labels
      lowerCAmelCase_      :				Tuple      =       RegNetModel(lowerCamelCase		)
      # classification head
      lowerCAmelCase_      :				Union[str, 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(lowerCamelCase		)
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT   ,						output_type=lowerCamelCase   ,						config_class=_CONFIG_FOR_DOC   ,						expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT   ,						)
    def __lowercase       (       self   :  Optional[int]   ,						lowerCamelCase   :  Optional[torch.FloatTensor] = None   ,						lowerCamelCase   :  Optional[torch.LongTensor] = None   ,						lowerCamelCase   :  Optional[bool] = None   ,						lowerCamelCase   :  Optional[bool] = None   ,						)       ->  ImageClassifierOutputWithNoAttention:
      lowerCAmelCase_      :				Any      =       return_dict if return_dict is not None else self.config.use_return_dict

      lowerCAmelCase_      :				str      =       self.regnet(lowerCamelCase   ,						output_hidden_states=lowerCamelCase   ,						return_dict=lowerCamelCase		)

      lowerCAmelCase_      :				int      =       outputs.pooler_output if return_dict else outputs[1]

      lowerCAmelCase_      :				Dict      =       self.classifier(lowerCamelCase		)

      lowerCAmelCase_      :				Union[str, Any]      =       None

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

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

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







'''simple docstring'''






from typing import List

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__A :  Dict    							=				logging.get_logger(__name__)

__A :  int    							=				{
    "snap-research/efficientformer-l1-300": (
        "https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json"
    ),
}






class        __snake_case	(       _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    lowercase       			= 'efficientformer'

    def __init__(       self   :  Any   ,						lowerCamelCase   :  List[int] = [3, 2, 6, 4]   ,						lowerCamelCase   :  List[int] = [48, 96, 2_24, 4_48]   ,						lowerCamelCase   :  List[bool] = [True, True, True, True]   ,						lowerCamelCase   :  int = 4_48   ,						lowerCamelCase   :  int = 32   ,						lowerCamelCase   :  int = 4   ,						lowerCamelCase   :  int = 7   ,						lowerCamelCase   :  int = 5   ,						lowerCamelCase   :  int = 8   ,						lowerCamelCase   :  int = 4   ,						lowerCamelCase   :  float = 0.0   ,						lowerCamelCase   :  int = 16   ,						lowerCamelCase   :  int = 3   ,						lowerCamelCase   :  int = 3   ,						lowerCamelCase   :  int = 3   ,						lowerCamelCase   :  int = 2   ,						lowerCamelCase   :  int = 1   ,						lowerCamelCase   :  float = 0.0   ,						lowerCamelCase   :  int = 1   ,						lowerCamelCase   :  bool = True   ,						lowerCamelCase   :  bool = True   ,						lowerCamelCase   :  float = 1E-5   ,						lowerCamelCase   :  str = "gelu"   ,						lowerCamelCase   :  float = 0.02   ,						lowerCamelCase   :  float = 1E-12   ,						lowerCamelCase   :  int = 2_24   ,						lowerCamelCase   :  float = 1E-05   ,						**lowerCamelCase   :  int   ,						)       ->  None:
      super().__init__(**lowerCamelCase		)

      lowerCAmelCase_      :				List[str]      =       hidden_act
      lowerCAmelCase_      :				List[Any]      =       hidden_dropout_prob
      lowerCAmelCase_      :				Any      =       hidden_sizes
      lowerCAmelCase_      :				List[Any]      =       num_hidden_layers
      lowerCAmelCase_      :				Union[str, Any]      =       num_attention_heads
      lowerCAmelCase_      :				Tuple      =       initializer_range
      lowerCAmelCase_      :				Union[str, Any]      =       layer_norm_eps
      lowerCAmelCase_      :				int      =       patch_size
      lowerCAmelCase_      :				List[str]      =       num_channels
      lowerCAmelCase_      :				Dict      =       depths
      lowerCAmelCase_      :				int      =       mlp_expansion_ratio
      lowerCAmelCase_      :				Optional[Any]      =       downsamples
      lowerCAmelCase_      :				Union[str, Any]      =       dim
      lowerCAmelCase_      :				Union[str, Any]      =       key_dim
      lowerCAmelCase_      :				str      =       attention_ratio
      lowerCAmelCase_      :				Tuple      =       resolution
      lowerCAmelCase_      :				Optional[Any]      =       pool_size
      lowerCAmelCase_      :				str      =       downsample_patch_size
      lowerCAmelCase_      :				Dict      =       downsample_stride
      lowerCAmelCase_      :				str      =       downsample_pad
      lowerCAmelCase_      :				str      =       drop_path_rate
      lowerCAmelCase_      :				List[Any]      =       num_metaad_blocks
      lowerCAmelCase_      :				Tuple      =       distillation
      lowerCAmelCase_      :				Optional[Any]      =       use_layer_scale
      lowerCAmelCase_      :				Dict      =       layer_scale_init_value
      lowerCAmelCase_      :				Optional[Any]      =       image_size
      lowerCAmelCase_      :				Optional[Any]      =       batch_norm_eps



