code: 
  
  from typing import Optional, Tuple, Union
  
  import tensorflow as tf
  
  from ...activations_tf import ACTaFN
  from ...modeling_tf_outputs import (
      TFBaseModelOutputWithNoAttention,
      TFBaseModelOutputWithPoolingAndNoAttention,
      TFImageClassifierOutputWithNoAttention,
  )
  from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
  from ...tf_utils import shape_list
  from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
  from .configuration_resnet import ResNetConfig
  
  
  lowerCamelCase         =      logging.get_logger(__name__)
  
  # General docstring
  lowerCamelCase         =      '''ResNetConfig'''
  
  # Base docstring
  lowerCamelCase         =      '''microsoft/resnet-50'''
  lowerCamelCase         =      [1, 2048, 7, 7]
  
  # Image classification docstring
  lowerCamelCase         =      '''microsoft/resnet-50'''
  lowerCamelCase         =      '''tiger cat'''
  
  lowerCamelCase         =      [
      '''microsoft/resnet-50''',
      # See all resnet models at https://huggingface.co/models?filter=resnet
  ]
  
  
  
  
  
  
  
  class 		__magic_name__    (							tf.keras.layers.Layer							):
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					lowercase_ = 3,					lowercase_ = 1,					lowercase_ = "relu",					**lowercase_ )							->					None:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(**__lowerCamelCase )
       a__						=kernel_size // 2
       a__						=tf.keras.layers.ConvaD(
           __lowerCamelCase,					kernel_size=__lowerCamelCase,					strides=__lowerCamelCase,					padding='''valid''',					use_bias=__lowerCamelCase,					name='''convolution''' )
       # Use same default momentum and epsilon as PyTorch equivalent
       a__						=tf.keras.layers.BatchNormalization(epsilon=1E-5,					momentum=0.9,					name='''normalization''' )
       a__						=ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('''linear''' )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					tf.Tensor:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=(self.pad_value, self.pad_value)
       a__						=tf.pad(__lowerCamelCase,					[(0, 0), height_pad, width_pad, (0, 0)] )
       a__						=self.conv(__lowerCamelCase )
       return hidden_state
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.convolution(__lowerCamelCase )
       a__						=self.normalization(__lowerCamelCase,					training=__lowerCamelCase )
       a__						=self.activation(__lowerCamelCase )
       return hidden_state
  
  
  
  
  
  
  
  class 		__magic_name__    (							tf.keras.layers.Layer							):
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					**lowercase_ )							->					None:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(**__lowerCamelCase )
       a__						=TFResNetConvLayer(
           config.embedding_size,					kernel_size=7,					stride=2,					activation=config.hidden_act,					name='''embedder''',					)
       a__						=tf.keras.layers.MaxPoolaD(pool_size=3,					strides=2,					padding='''valid''',					name='''pooler''' )
       a__						=config.num_channels
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=shape_list(__lowerCamelCase )
       if tf.executing_eagerly() and 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.''' )
       a__						=pixel_values
       a__						=self.embedder(__lowerCamelCase )
       a__						=tf.pad(__lowerCamelCase,					[[0, 0], [1, 1], [1, 1], [0, 0]] )
       a__						=self.pooler(__lowerCamelCase )
       return hidden_state
  
  
  
  
  
  
  
  class 		__magic_name__    (							tf.keras.layers.Layer							):
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					lowercase_ = 2,					**lowercase_ )							->					None:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(**__lowerCamelCase )
       a__						=tf.keras.layers.ConvaD(
           __lowerCamelCase,					kernel_size=1,					strides=__lowerCamelCase,					use_bias=__lowerCamelCase,					name='''convolution''' )
       # Use same default momentum and epsilon as PyTorch equivalent
       a__						=tf.keras.layers.BatchNormalization(epsilon=1E-5,					momentum=0.9,					name='''normalization''' )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=x
       a__						=self.convolution(__lowerCamelCase )
       a__						=self.normalization(__lowerCamelCase,					training=__lowerCamelCase )
       return hidden_state
  
  
  
  
  
  
  
  class 		__magic_name__    (							tf.keras.layers.Layer							):
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					lowercase_,					lowercase_ = 1,					lowercase_ = "relu",					**lowercase_ )							->					None:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(**__lowerCamelCase )
       a__						=in_channels != out_channels or stride != 1
       a__						=TFResNetConvLayer(__lowerCamelCase,					stride=__lowerCamelCase,					name='''layer.0''' )
       a__						=TFResNetConvLayer(__lowerCamelCase,					activation=__lowerCamelCase,					name='''layer.1''' )
       a__						=(
           TFResNetShortCut(__lowerCamelCase,					stride=__lowerCamelCase,					name='''shortcut''' )
           if should_apply_shortcut
           else tf.keras.layers.Activation('''linear''',					name='''shortcut''' )
       )
       a__						=ACTaFN[activation]
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=hidden_state
       a__						=self.conva(__lowerCamelCase,					training=__lowerCamelCase )
       a__						=self.conva(__lowerCamelCase,					training=__lowerCamelCase )
       a__						=self.shortcut(__lowerCamelCase,					training=__lowerCamelCase )
       hidden_state += residual
       a__						=self.activation(__lowerCamelCase )
       return hidden_state
  
  
  
  
  
  
  
  class 		__magic_name__    (							tf.keras.layers.Layer							):
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					lowercase_,					lowercase_ = 1,					lowercase_ = "relu",					lowercase_ = 4,					**lowercase_,					)							->					None:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(**__lowerCamelCase )
       a__						=in_channels != out_channels or stride != 1
       a__						=out_channels // reduction
       a__						=TFResNetConvLayer(__lowerCamelCase,					kernel_size=1,					name='''layer.0''' )
       a__						=TFResNetConvLayer(__lowerCamelCase,					stride=__lowerCamelCase,					name='''layer.1''' )
       a__						=TFResNetConvLayer(__lowerCamelCase,					kernel_size=1,					activation=__lowerCamelCase,					name='''layer.2''' )
       a__						=(
           TFResNetShortCut(__lowerCamelCase,					stride=__lowerCamelCase,					name='''shortcut''' )
           if should_apply_shortcut
           else tf.keras.layers.Activation('''linear''',					name='''shortcut''' )
       )
       a__						=ACTaFN[activation]
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=hidden_state
       a__						=self.conva(__lowerCamelCase,					training=__lowerCamelCase )
       a__						=self.conva(__lowerCamelCase,					training=__lowerCamelCase )
       a__						=self.conva(__lowerCamelCase,					training=__lowerCamelCase )
       a__						=self.shortcut(__lowerCamelCase,					training=__lowerCamelCase )
       hidden_state += residual
       a__						=self.activation(__lowerCamelCase )
       return hidden_state
  
  
  
  
  
  
  
  class 		__magic_name__    (							tf.keras.layers.Layer							):
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_ = 2,					lowercase_ = 2,					**lowercase_ )							->					None:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(**__lowerCamelCase )
  
       a__						=TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer
  
       a__						=[layer(__lowerCamelCase,					__lowerCamelCase,					stride=__lowerCamelCase,					activation=config.hidden_act,					name='''layers.0''' )]
       layers += [
           layer(__lowerCamelCase,					__lowerCamelCase,					activation=config.hidden_act,					name=F"""layers.{i + 1}""" )
           for i in range(depth - 1 )
       ]
       a__						=layers
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       for layer in self.stage_layers:
         a__						=layer(__lowerCamelCase,					training=__lowerCamelCase )
       return hidden_state
  
  
  
  
  
  
  
  class 		__magic_name__    (							tf.keras.layers.Layer							):
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					**lowercase_ )							->					None:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(**__lowerCamelCase )
       # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
       a__						=[
           TFResNetStage(
               __lowerCamelCase,					config.embedding_size,					config.hidden_sizes[0],					stride=2 if config.downsample_in_first_stage else 1,					depth=config.depths[0],					name='''stages.0''',					)
       ]
       for i, (in_channels, out_channels, depth) in enumerate(
           zip(config.hidden_sizes,					config.hidden_sizes[1:],					config.depths[1:] ) ):
         self.stages.append(TFResNetStage(__lowerCamelCase,					__lowerCamelCase,					__lowerCamelCase,					depth=__lowerCamelCase,					name=F"""stages.{i + 1}""" ) )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False,					lowercase_ = True,					lowercase_ = False,					)							->					TFBaseModelOutputWithNoAttention:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=() if output_hidden_states else None
  
       for stage_module in self.stages:
         if output_hidden_states:
           a__						=hidden_states + (hidden_state,)
  
         a__						=stage_module(__lowerCamelCase,					training=__lowerCamelCase )
  
       if output_hidden_states:
         a__						=hidden_states + (hidden_state,)
  
       if not return_dict:
         return tuple(v for v in [hidden_state, hidden_states] if v is not None )
  
       return TFBaseModelOutputWithNoAttention(last_hidden_state=__lowerCamelCase,					hidden_states=__lowerCamelCase )
  
  
  
  
  
  
  
  class 		__magic_name__    (							lowerCamelCase__							):
  
     '''simple docstring'''
  
  
  
  
     lowerCamelCase__				:			Optional[Any]												=     ResNetConfig
     lowerCamelCase__				:			Dict												=     'resnet'
     lowerCamelCase__				:			Dict												=     'pixel_values'
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					int:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224),					dtype=tf.floataa )}
  
  
  
  
  
  lowerCamelCase         =      r'''\n    This model is a TensorFlow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): 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 [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n'''
  
  
  lowerCamelCase         =      r'''\n    Args:\n        pixel_values (`tf.Tensor` 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 [`~utils.ModelOutput`] instead of a plain tuple.\n'''
  
  
  
  
  
  
  
  @keras_serializable
  class 		__magic_name__    (							tf.keras.layers.Layer							):
  
     '''simple docstring'''
  
  
  
  
     lowerCamelCase__				:			Union[str, Any]												=     ResNetConfig
  
  
  
     def __init__(       self,					lowercase_,					**lowercase_ )							->					None:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(**__lowerCamelCase )
       a__						=config
       a__						=TFResNetEmbeddings(__lowerCamelCase,					name='''embedder''' )
       a__						=TFResNetEncoder(__lowerCamelCase,					name='''encoder''' )
       a__						=tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase )
  
  
  
     @unpack_inputs
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = None,					lowercase_ = None,					lowercase_ = False,					)							->					Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=(
           output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
       )
       a__						=return_dict if return_dict is not None else self.config.use_return_dict
  
       # TF 2.0 image layers can't use NCHW format when running on CPU.
       # We transpose to NHWC format and then transpose back after the full forward pass.
       # (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
       a__						=tf.transpose(__lowerCamelCase,					perm=[0, 2, 3, 1] )
       a__						=self.embedder(__lowerCamelCase,					training=__lowerCamelCase )
  
       a__						=self.encoder(
           __lowerCamelCase,					output_hidden_states=__lowerCamelCase,					return_dict=__lowerCamelCase,					training=__lowerCamelCase )
  
       a__						=encoder_outputs[0]
  
       a__						=self.pooler(__lowerCamelCase )
  
       # Transpose all the outputs to the NCHW format
       # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
       a__						=tf.transpose(__lowerCamelCase,					(0, 3, 1, 2) )
       a__						=tf.transpose(__lowerCamelCase,					(0, 3, 1, 2) )
       a__						=()
       for hidden_state in encoder_outputs[1:]:
         a__						=hidden_states + tuple(tf.transpose(__lowerCamelCase,					(0, 3, 1, 2) ) for h in hidden_state )
  
       if not return_dict:
         return (last_hidden_state, pooled_output) + hidden_states
  
       a__						=hidden_states if output_hidden_states else None
  
       return TFBaseModelOutputWithPoolingAndNoAttention(
           last_hidden_state=__lowerCamelCase,					pooler_output=__lowerCamelCase,					hidden_states=__lowerCamelCase,					)
  
  
  
  
  
  
  
  @add_start_docstrings(
      'The bare ResNet model outputting raw features without any specific head on top.'	, lowerCamelCase__	, )
  class 		__magic_name__    (							lowerCamelCase__							):
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					**lowercase_ )							->					None:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(__lowerCamelCase,					**__lowerCamelCase )
       a__						=TFResNetMainLayer(config=__lowerCamelCase,					name='''resnet''' )
  
  
  
     @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,					)
     @unpack_inputs
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = None,					lowercase_ = None,					lowercase_ = False,					)							->					Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=(
           output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
       )
       a__						=return_dict if return_dict is not None else self.config.use_return_dict
  
       a__						=self.resnet(
           pixel_values=__lowerCamelCase,					output_hidden_states=__lowerCamelCase,					return_dict=__lowerCamelCase,					training=__lowerCamelCase,					)
       return resnet_outputs
  
  
  
  
  
  
  
  @add_start_docstrings(
      '\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    '	, lowerCamelCase__	, )
  class 		__magic_name__    (							lowerCamelCase__	, lowerCamelCase__							):
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					**lowercase_ )							->					None:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(__lowerCamelCase,					**__lowerCamelCase )
       a__						=config.num_labels
       a__						=TFResNetMainLayer(__lowerCamelCase,					name='''resnet''' )
       # classification head
       a__						=(
           tf.keras.layers.Dense(config.num_labels,					name='''classifier.1''' )
           if config.num_labels > 0
           else tf.keras.layers.Activation('''linear''',					name='''classifier.1''' )
       )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					tf.Tensor:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=tf.keras.layers.Flatten()(__lowerCamelCase )
       a__						=self.classifier_layer(__lowerCamelCase )
       return logits
  
  
  
     @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,					)
     @unpack_inputs
     def 				_UpperCAmelCase				(       self,					lowercase_ = None,					lowercase_ = None,					lowercase_ = None,					lowercase_ = None,					lowercase_ = False,					)							->					Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=return_dict if return_dict is not None else self.config.use_return_dict
  
       a__						=self.resnet(
           __lowerCamelCase,					output_hidden_states=__lowerCamelCase,					return_dict=__lowerCamelCase,					training=__lowerCamelCase )
  
       a__						=outputs.pooler_output if return_dict else outputs[1]
  
       a__						=self.classifier(__lowerCamelCase )
  
       a__						=None if labels is None else self.hf_compute_loss(__lowerCamelCase,					__lowerCamelCase )
  
       if not return_dict:
         a__						=(logits,) + outputs[2:]
         return (loss,) + output if loss is not None else output
  
       return TFImageClassifierOutputWithNoAttention(loss=__lowerCamelCase,					logits=__lowerCamelCase,					hidden_states=outputs.hidden_states )
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_tf_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  lowerCamelCase     =      {
      '''configuration_deberta_v2''': ['''DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DebertaV2Config''', '''DebertaV2OnnxConfig'''],
      '''tokenization_deberta_v2''': ['''DebertaV2Tokenizer'''],
  }
  
  try:
         if not is_tokenizers_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         lowerCamelCase     =      ['''DebertaV2TokenizerFast''']
  
  try:
         if not is_tf_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         lowerCamelCase     =      [
             '''TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST''',
             '''TFDebertaV2ForMaskedLM''',
             '''TFDebertaV2ForQuestionAnswering''',
             '''TFDebertaV2ForSequenceClassification''',
             '''TFDebertaV2ForTokenClassification''',
             '''TFDebertaV2Model''',
             '''TFDebertaV2PreTrainedModel''',
         ]
  
  try:
         if not is_torch_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         lowerCamelCase     =      [
             '''DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST''',
             '''DebertaV2ForMaskedLM''',
             '''DebertaV2ForMultipleChoice''',
             '''DebertaV2ForQuestionAnswering''',
             '''DebertaV2ForSequenceClassification''',
             '''DebertaV2ForTokenClassification''',
             '''DebertaV2Model''',
             '''DebertaV2PreTrainedModel''',
         ]
  
  
  if TYPE_CHECKING:
         from .configuration_deberta_va import (
             DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP,
             DebertaVaConfig,
             DebertaVaOnnxConfig,
         )
         from .tokenization_deberta_va import DebertaVaTokenizer
  
         try:
                if not is_tokenizers_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .tokenization_deberta_va_fast import DebertaVaTokenizerFast
  
         try:
                if not is_tf_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_tf_deberta_va import (
                    TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
                    TFDebertaVaForMaskedLM,
                    TFDebertaVaForQuestionAnswering,
                    TFDebertaVaForSequenceClassification,
                    TFDebertaVaForTokenClassification,
                    TFDebertaVaModel,
                    TFDebertaVaPreTrainedModel,
                )
  
         try:
                if not is_torch_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_deberta_va import (
                    DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
                    DebertaVaForMaskedLM,
                    DebertaVaForMultipleChoice,
                    DebertaVaForQuestionAnswering,
                    DebertaVaForSequenceClassification,
                    DebertaVaForTokenClassification,
                    DebertaVaModel,
                    DebertaVaPreTrainedModel,
                )
  
  else:
         import sys
  
         lowerCamelCase     =      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  