






'''simple docstring'''





from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


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

__A				:				Tuple					=		{
    """facebook/convnext-tiny-224""": """https://huggingface.co/facebook/convnext-tiny-224/resolve/main/config.json""",
    # See all ConvNeXT models at https://huggingface.co/models?filter=convnext
}
class 					lowercase							(				_lowerCamelCase			,							_lowerCamelCase   ):


    '''simple docstring'''

    lowerCAmelCase__   					=				"convnext"

    def __init__(       self  :  Any					,  __lowerCamelCase  :  Dict=3					,  __lowerCamelCase  :  int=4					,  __lowerCamelCase  :  Any=4					,  __lowerCamelCase  :  Dict=None					,  __lowerCamelCase  :  str=None					,  __lowerCamelCase  :  Optional[int]="gelu"					,  __lowerCamelCase  :  List[str]=0.0_2					,  __lowerCamelCase  :  int=1E-12					,  __lowerCamelCase  :  Optional[Any]=1E-6					,  __lowerCamelCase  :  Any=0.0					,  __lowerCamelCase  :  Union[str, Any]=224					,  __lowerCamelCase  :  Dict=None					,  __lowerCamelCase  :  List[str]=None					,  **__lowerCamelCase  :  Tuple					,  )				->				Dict:

     '''simple docstring'''




     super().__init__(**__lowerCamelCase  )

     lowerCamelCase__	=  num_channels
     lowerCamelCase__	=  patch_size
     lowerCamelCase__	=  num_stages
     lowerCamelCase__	=  [96, 192, 384, 768] if hidden_sizes is None else hidden_sizes
     lowerCamelCase__	=  [3, 3, 9, 3] if depths is None else depths
     lowerCamelCase__	=  hidden_act
     lowerCamelCase__	=  initializer_range
     lowerCamelCase__	=  layer_norm_eps
     lowerCamelCase__	=  layer_scale_init_value
     lowerCamelCase__	=  drop_path_rate
     lowerCamelCase__	=  image_size
     lowerCamelCase__	=  ["stem"] + [f'''stage{idx}''' for idx in range(1					,  len(self.depths  ) + 1  )]
     lowerCamelCase__	,						lowerCamelCase__	=  get_aligned_output_features_output_indices(
         out_features=__lowerCamelCase					,  out_indices=__lowerCamelCase					,  stage_names=self.stage_names  )
class 					lowercase							(				_lowerCamelCase   ):


    '''simple docstring'''

    lowerCAmelCase__   					=				version.parse("1.11"   )

    @property
    def  a__					(       self  :  List[Any]  )				->				Mapping[str, Mapping[int, str]]:

     '''simple docstring'''




     return OrderedDict(
         [
             ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
         ]  )




    @property
    def  a__					(       self  :  Tuple  )				->				float:

     '''simple docstring'''




     return 1E-5









'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_keras_nlp_available,
    is_tensorflow_text_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__A				:				Union[str, Any]					=		{
    """configuration_gpt2""": ["""GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPT2Config""", """GPT2OnnxConfig"""],
    """tokenization_gpt2""": ["""GPT2Tokenizer"""],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A				:				Tuple					=		["""GPT2TokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A				:				Optional[int]					=		[
     """GPT2_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """GPT2DoubleHeadsModel""",
     """GPT2ForQuestionAnswering""",
     """GPT2ForSequenceClassification""",
     """GPT2ForTokenClassification""",
     """GPT2LMHeadModel""",
     """GPT2Model""",
     """GPT2PreTrainedModel""",
     """load_tf_weights_in_gpt2""",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A				:				Optional[Any]					=		[
     """TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """TFGPT2DoubleHeadsModel""",
     """TFGPT2ForSequenceClassification""",
     """TFGPT2LMHeadModel""",
     """TFGPT2MainLayer""",
     """TFGPT2Model""",
     """TFGPT2PreTrainedModel""",
 ]

try:
 if not is_keras_nlp_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A				:				Any					=		["""TFGPT2Tokenizer"""]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A				:				Tuple					=		["""FlaxGPT2LMHeadModel""", """FlaxGPT2Model""", """FlaxGPT2PreTrainedModel"""]

if TYPE_CHECKING:
 from .configuration_gpta import GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTaConfig, GPTaOnnxConfig
 from .tokenization_gpta import GPTaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_gpta_fast import GPTaTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_gpta import (
      GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
      GPTaDoubleHeadsModel,
      GPTaForQuestionAnswering,
      GPTaForSequenceClassification,
      GPTaForTokenClassification,
      GPTaLMHeadModel,
      GPTaModel,
      GPTaPreTrainedModel,
      load_tf_weights_in_gpta,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_gpta import (
      TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFGPTaDoubleHeadsModel,
      TFGPTaForSequenceClassification,
      TFGPTaLMHeadModel,
      TFGPTaMainLayer,
      TFGPTaModel,
      TFGPTaPreTrainedModel,
  )

 try:
  if not is_keras_nlp_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_gpta_tf import TFGPTaTokenizer

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel, FlaxGPTaPreTrainedModel

else:
 import sys

 __A				:				Tuple					=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

