






from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


_a    :   int        =			logging.get_logger(__name__)

# General docstring
_a    :   Tuple        =			"""RegNetConfig"""

# Base docstring
_a    :   Tuple        =			"""facebook/regnet-y-040"""
_a    :   Optional[int]        =			[1, 1088, 7, 7]

# Image classification docstring
_a    :   List[str]        =			"""facebook/regnet-y-040"""
_a    :   Any        =			"""tabby, tabby cat"""

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







class 	_UpperCAmelCase  (  tf.keras.layers.Layer		):




      """simple docstring"""



      def __init__(   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase = 3    ,	_lowerCAmelCase = 1    ,	_lowerCAmelCase = 1    ,	_lowerCAmelCase = "relu"    ,	**_lowerCAmelCase    ,	):



          '''simple docstring'''
          super().__init__(**_lowerCAmelCase		)
          # The padding and conv has been verified in
          # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
          lowerCAmelCase__   :str      							=				tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2		)
          lowerCAmelCase__   :List[str]      							=				tf.keras.layers.ConvaD(
              filters=_lowerCAmelCase    ,	kernel_size=_lowerCAmelCase    ,	strides=_lowerCAmelCase    ,	padding="VALID"    ,	groups=_lowerCAmelCase    ,	use_bias=_lowerCAmelCase    ,	name="convolution"    ,	)
          lowerCAmelCase__   :List[Any]      							=				tf.keras.layers.BatchNormalization(epsilon=1e-5    ,	momentum=0.9    ,	name="normalization"		)
          lowerCAmelCase__   :List[str]      							=				ACTaFN[activation] if activation is not None else tf.identity



      def 			snake_case_      (   self    ,	_lowerCAmelCase		):



          '''simple docstring'''
          lowerCAmelCase__   :List[Any]      							=				self.convolution(self.padding(_lowerCAmelCase		)		)
          lowerCAmelCase__   :Any      							=				self.normalization(_lowerCAmelCase		)
          lowerCAmelCase__   :Optional[Any]      							=				self.activation(_lowerCAmelCase		)
          return hidden_state







class 	_UpperCAmelCase  (  tf.keras.layers.Layer		):




      """simple docstring"""



      def __init__(   self    ,	_lowerCAmelCase    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          super().__init__(**_lowerCAmelCase		)
          lowerCAmelCase__   :List[Any]      							=				config.num_channels
          lowerCAmelCase__   :Union[str, Any]      							=				TFRegNetConvLayer(
              out_channels=config.embedding_size    ,	kernel_size=3    ,	stride=2    ,	activation=config.hidden_act    ,	name="embedder"    ,	)



      def 			snake_case_      (   self    ,	_lowerCAmelCase		):



          '''simple docstring'''
          lowerCAmelCase__   :Any      							=				shape_list(_lowerCAmelCase		)[1]
          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."		)

          # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
          # So change the input format from `NCHW` to `NHWC`.
          # shape = (batch_size, in_height, in_width, in_channels=num_channels)
          lowerCAmelCase__   :List[str]      							=				tf.transpose(_lowerCAmelCase    ,	perm=(0, 2, 3, 1)		)
          lowerCAmelCase__   :str      							=				self.embedder(_lowerCAmelCase		)
          return hidden_state







class 	_UpperCAmelCase  (  tf.keras.layers.Layer		):




      """simple docstring"""



      def __init__(   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase = 2    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          super().__init__(**_lowerCAmelCase		)
          lowerCAmelCase__   :List[str]      							=				tf.keras.layers.ConvaD(
              filters=_lowerCAmelCase    ,	kernel_size=1    ,	strides=_lowerCAmelCase    ,	use_bias=_lowerCAmelCase    ,	name="convolution"		)
          lowerCAmelCase__   :Tuple      							=				tf.keras.layers.BatchNormalization(epsilon=1e-5    ,	momentum=0.9    ,	name="normalization"		)



      def 			snake_case_      (   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase = False		):



          '''simple docstring'''
          return self.normalization(self.convolution(_lowerCAmelCase		)    ,	training=_lowerCAmelCase		)







class 	_UpperCAmelCase  (  tf.keras.layers.Layer		):




      """simple docstring"""



      def __init__(   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          super().__init__(**_lowerCAmelCase		)
          lowerCAmelCase__   :List[str]      							=				tf.keras.layers.GlobalAveragePoolingaD(keepdims=_lowerCAmelCase    ,	name="pooler"		)
          lowerCAmelCase__   :Optional[Any]      							=				[
              tf.keras.layers.ConvaD(filters=_lowerCAmelCase    ,	kernel_size=1    ,	activation="relu"    ,	name="attention.0"		),
              tf.keras.layers.ConvaD(filters=_lowerCAmelCase    ,	kernel_size=1    ,	activation="sigmoid"    ,	name="attention.2"		),
          ]



      def 			snake_case_      (   self    ,	_lowerCAmelCase		):



          '''simple docstring'''
          # [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
          lowerCAmelCase__   :Any      							=				self.pooler(_lowerCAmelCase		)
          for layer_module in self.attention:
              lowerCAmelCase__   :str      							=				layer_module(_lowerCAmelCase		)
          lowerCAmelCase__   :str      							=				hidden_state * pooled
          return hidden_state







class 	_UpperCAmelCase  (  tf.keras.layers.Layer		):




      """simple docstring"""



      def __init__(   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase    ,	_lowerCAmelCase    ,	_lowerCAmelCase = 1    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          super().__init__(**_lowerCAmelCase		)
          lowerCAmelCase__   :str      							=				in_channels != out_channels or stride != 1
          lowerCAmelCase__   :Union[str, Any]      							=				max(1    ,	out_channels // config.groups_width		)
          lowerCAmelCase__   :Any      							=				(
              TFRegNetShortCut(_lowerCAmelCase    ,	stride=_lowerCAmelCase    ,	name="shortcut"		)
              if should_apply_shortcut
              else tf.keras.layers.Activation("linear"    ,	name="shortcut"		)
          )
          # `self.layers` instead of `self.layer` because that is a reserved argument.
          lowerCAmelCase__   :Any      							=				[
              TFRegNetConvLayer(_lowerCAmelCase    ,	kernel_size=1    ,	activation=config.hidden_act    ,	name="layer.0"		),
              TFRegNetConvLayer(
                  _lowerCAmelCase    ,	stride=_lowerCAmelCase    ,	groups=_lowerCAmelCase    ,	activation=config.hidden_act    ,	name="layer.1"		),
              TFRegNetConvLayer(_lowerCAmelCase    ,	kernel_size=1    ,	activation=_lowerCAmelCase    ,	name="layer.2"		),
          ]
          lowerCAmelCase__   :Optional[int]      							=				ACTaFN[config.hidden_act]



      def 			snake_case_      (   self    ,	_lowerCAmelCase		):



          '''simple docstring'''
          lowerCAmelCase__   :Union[str, Any]      							=				hidden_state
          for layer_module in self.layers:
              lowerCAmelCase__   :List[str]      							=				layer_module(_lowerCAmelCase		)
          lowerCAmelCase__   :Union[str, Any]      							=				self.shortcut(_lowerCAmelCase		)
          hidden_state += residual
          lowerCAmelCase__   :Dict      							=				self.activation(_lowerCAmelCase		)
          return hidden_state







class 	_UpperCAmelCase  (  tf.keras.layers.Layer		):




      """simple docstring"""



      def __init__(   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase    ,	_lowerCAmelCase    ,	_lowerCAmelCase = 1    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          super().__init__(**_lowerCAmelCase		)
          lowerCAmelCase__   :List[str]      							=				in_channels != out_channels or stride != 1
          lowerCAmelCase__   :List[str]      							=				max(1    ,	out_channels // config.groups_width		)
          lowerCAmelCase__   :str      							=				(
              TFRegNetShortCut(_lowerCAmelCase    ,	stride=_lowerCAmelCase    ,	name="shortcut"		)
              if should_apply_shortcut
              else tf.keras.layers.Activation("linear"    ,	name="shortcut"		)
          )
          lowerCAmelCase__   :int      							=				[
              TFRegNetConvLayer(_lowerCAmelCase    ,	kernel_size=1    ,	activation=config.hidden_act    ,	name="layer.0"		),
              TFRegNetConvLayer(
                  _lowerCAmelCase    ,	stride=_lowerCAmelCase    ,	groups=_lowerCAmelCase    ,	activation=config.hidden_act    ,	name="layer.1"		),
              TFRegNetSELayer(_lowerCAmelCase    ,	reduced_channels=int(round(in_channels / 4		)		)    ,	name="layer.2"		),
              TFRegNetConvLayer(_lowerCAmelCase    ,	kernel_size=1    ,	activation=_lowerCAmelCase    ,	name="layer.3"		),
          ]
          lowerCAmelCase__   :str      							=				ACTaFN[config.hidden_act]



      def 			snake_case_      (   self    ,	_lowerCAmelCase		):



          '''simple docstring'''
          lowerCAmelCase__   :int      							=				hidden_state
          for layer_module in self.layers:
              lowerCAmelCase__   :Optional[Any]      							=				layer_module(_lowerCAmelCase		)
          lowerCAmelCase__   :Any      							=				self.shortcut(_lowerCAmelCase		)
          hidden_state += residual
          lowerCAmelCase__   :Dict      							=				self.activation(_lowerCAmelCase		)
          return hidden_state







class 	_UpperCAmelCase  (  tf.keras.layers.Layer		):




      """simple docstring"""



      def __init__(   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase    ,	_lowerCAmelCase    ,	_lowerCAmelCase = 2    ,	_lowerCAmelCase = 2    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          super().__init__(**_lowerCAmelCase		)

          lowerCAmelCase__   :List[str]      							=				TFRegNetXLayer if config.layer_type == "x" else TFRegNetYLayer
          lowerCAmelCase__   :Any      							=				[
              # downsampling is done in the first layer with stride of 2
              layer(_lowerCAmelCase    ,	_lowerCAmelCase    ,	_lowerCAmelCase    ,	stride=_lowerCAmelCase    ,	name="layers.0"		),
              *[layer(_lowerCAmelCase    ,	_lowerCAmelCase    ,	_lowerCAmelCase    ,	name=f'''layers.{i+1}'''		) for i in range(depth - 1		)],
          ]



      def 			snake_case_      (   self    ,	_lowerCAmelCase		):



          '''simple docstring'''
          for layer_module in self.layers:
              lowerCAmelCase__   :Optional[int]      							=				layer_module(_lowerCAmelCase		)
          return hidden_state







class 	_UpperCAmelCase  (  tf.keras.layers.Layer		):




      """simple docstring"""



      def __init__(   self    ,	_lowerCAmelCase    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          super().__init__(**_lowerCAmelCase		)
          lowerCAmelCase__   :Union[str, Any]      							=				[]
          # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
          self.stages.append(
              TFRegNetStage(
                  _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"    ,	)		)
          lowerCAmelCase__   :int      							=				zip(config.hidden_sizes    ,	config.hidden_sizes[1:]		)
          for i, ((in_channels, out_channels), depth) in enumerate(zip(_lowerCAmelCase    ,	config.depths[1:]		)		):
              self.stages.append(TFRegNetStage(_lowerCAmelCase    ,	_lowerCAmelCase    ,	_lowerCAmelCase    ,	depth=_lowerCAmelCase    ,	name=f'''stages.{i+1}'''		)		)



      def 			snake_case_      (   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase = False    ,	_lowerCAmelCase = True		):



          '''simple docstring'''
          lowerCAmelCase__   :List[str]      							=				() if output_hidden_states else None

          for stage_module in self.stages:
              if output_hidden_states:
                  lowerCAmelCase__   :Optional[int]      							=				hidden_states + (hidden_state,)

              lowerCAmelCase__   :List[str]      							=				stage_module(_lowerCAmelCase		)

          if output_hidden_states:
              lowerCAmelCase__   :Any      							=				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		)







@keras_serializable
class 	_UpperCAmelCase  (  tf.keras.layers.Layer		):




      """simple docstring"""



      A          =    RegNetConfig
      def __init__(   self    ,	_lowerCAmelCase    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          super().__init__(**_lowerCAmelCase		)
          lowerCAmelCase__   :Tuple      							=				config
          lowerCAmelCase__   :int      							=				TFRegNetEmbeddings(_lowerCAmelCase    ,	name="embedder"		)
          lowerCAmelCase__   :Union[str, Any]      							=				TFRegNetEncoder(_lowerCAmelCase    ,	name="encoder"		)
          lowerCAmelCase__   :Optional[int]      							=				tf.keras.layers.GlobalAveragePoolingaD(keepdims=_lowerCAmelCase    ,	name="pooler"		)



      @unpack_inputs
      def 			snake_case_      (   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase = None    ,	_lowerCAmelCase = None    ,	_lowerCAmelCase = False    ,	):



          '''simple docstring'''
          lowerCAmelCase__   :Union[str, Any]      							=				(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          lowerCAmelCase__   :int      							=				return_dict if return_dict is not None else self.config.use_return_dict

          lowerCAmelCase__   :List[str]      							=				self.embedder(_lowerCAmelCase    ,	training=_lowerCAmelCase		)

          lowerCAmelCase__   :Any      							=				self.encoder(
              _lowerCAmelCase    ,	output_hidden_states=_lowerCAmelCase    ,	return_dict=_lowerCAmelCase    ,	training=_lowerCAmelCase		)

          lowerCAmelCase__   :Dict      							=				encoder_outputs[0]
          lowerCAmelCase__   :List[str]      							=				self.pooler(_lowerCAmelCase		)

          # Change to NCHW output format have uniformity in the modules
          lowerCAmelCase__   :Tuple      							=				tf.transpose(_lowerCAmelCase    ,	perm=(0, 3, 1, 2)		)
          lowerCAmelCase__   :int      							=				tf.transpose(_lowerCAmelCase    ,	perm=(0, 3, 1, 2)		)

          # Change the other hidden state outputs to NCHW as well
          if output_hidden_states:
              lowerCAmelCase__   :Optional[Any]      							=				tuple([tf.transpose(_lowerCAmelCase    ,	perm=(0, 3, 1, 2)		) for h in encoder_outputs[1]]		)

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

          return TFBaseModelOutputWithPoolingAndNoAttention(
              last_hidden_state=_lowerCAmelCase    ,	pooler_output=_lowerCAmelCase    ,	hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states    ,	)







class 	_UpperCAmelCase  (  _A		):




      """simple docstring"""



      A          =    RegNetConfig
      A          =    '''regnet'''
      A          =    '''pixel_values'''
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)    ,	dtype=tf.floataa		)}





_a    :   Union[str, Any]        =			R"""
    Parameters:
    This model is a Tensorflow
    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a
    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and
    behavior.
        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.
"""

_a    :   Optional[Any]        =			R"""
    Args:
        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConveNextImageProcessor.__call__`] for details.
        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""







@add_start_docstrings(
    '''The bare RegNet model outputting raw features without any specific head on top.'''				,							_A				,							)
class 	_UpperCAmelCase  (  _A		):




      """simple docstring"""



      def __init__(   self    ,	_lowerCAmelCase    ,	*_lowerCAmelCase    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          super().__init__(_lowerCAmelCase    ,	*_lowerCAmelCase    ,	**_lowerCAmelCase		)
          lowerCAmelCase__   :int      							=				TFRegNetMainLayer(_lowerCAmelCase    ,	name="regnet"		)



      @unpack_inputs
      @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 			snake_case_      (   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase = None    ,	_lowerCAmelCase = None    ,	_lowerCAmelCase=False    ,	):



          '''simple docstring'''
          lowerCAmelCase__   :List[Any]      							=				(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          lowerCAmelCase__   :Tuple      							=				return_dict if return_dict is not None else self.config.use_return_dict

          lowerCAmelCase__   :Any      							=				self.regnet(
              pixel_values=_lowerCAmelCase    ,	output_hidden_states=_lowerCAmelCase    ,	return_dict=_lowerCAmelCase    ,	training=_lowerCAmelCase    ,	)
          if not return_dict:
              return (outputs[0],) + outputs[1:]

          return TFBaseModelOutputWithPoolingAndNoAttention(
              last_hidden_state=outputs.last_hidden_state    ,	pooler_output=outputs.pooler_output    ,	hidden_states=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				,							)
class 	_UpperCAmelCase  (  _A				,							_A		):




      """simple docstring"""



      def __init__(   self    ,	_lowerCAmelCase    ,	*_lowerCAmelCase    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          super().__init__(_lowerCAmelCase    ,	*_lowerCAmelCase    ,	**_lowerCAmelCase		)
          lowerCAmelCase__   :List[Any]      							=				config.num_labels
          lowerCAmelCase__   :Tuple      							=				TFRegNetMainLayer(_lowerCAmelCase    ,	name="regnet"		)
          # classification head
          lowerCAmelCase__   :Dict      							=				[
              tf.keras.layers.Flatten(),
              tf.keras.layers.Dense(config.num_labels    ,	name="classifier.1"		) if config.num_labels > 0 else tf.identity,
          ]



      @unpack_inputs
      @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 			snake_case_      (   self    ,	_lowerCAmelCase = None    ,	_lowerCAmelCase = None    ,	_lowerCAmelCase = None    ,	_lowerCAmelCase = None    ,	_lowerCAmelCase=False    ,	):



          '''simple docstring'''
          lowerCAmelCase__   :Any      							=				(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          lowerCAmelCase__   :Dict      							=				return_dict if return_dict is not None else self.config.use_return_dict

          lowerCAmelCase__   :List[str]      							=				self.regnet(
              _lowerCAmelCase    ,	output_hidden_states=_lowerCAmelCase    ,	return_dict=_lowerCAmelCase    ,	training=_lowerCAmelCase		)

          lowerCAmelCase__   :Dict      							=				outputs.pooler_output if return_dict else outputs[1]

          lowerCAmelCase__   :int      							=				self.classifier[0](_lowerCAmelCase		)
          lowerCAmelCase__   :List[Any]      							=				self.classifier[1](_lowerCAmelCase		)

          lowerCAmelCase__   :List[Any]      							=				None if labels is None else self.hf_compute_loss(labels=_lowerCAmelCase    ,	logits=_lowerCAmelCase		)

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

          return TFSequenceClassifierOutput(loss=_lowerCAmelCase    ,	logits=_lowerCAmelCase    ,	hidden_states=outputs.hidden_states		)











from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_a    :   str        =			{"""configuration_wavlm""": ["""WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """WavLMConfig"""]}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _a    :   Optional[Any]        =			[
     """WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """WavLMForAudioFrameClassification""",
     """WavLMForCTC""",
     """WavLMForSequenceClassification""",
     """WavLMForXVector""",
     """WavLMModel""",
     """WavLMPreTrainedModel""",
 ]

if TYPE_CHECKING:
 from .configuration_wavlm import WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP, WavLMConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_wavlm import (
      WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST,
      WavLMForAudioFrameClassification,
      WavLMForCTC,
      WavLMForSequenceClassification,
      WavLMForXVector,
      WavLMModel,
      WavLMPreTrainedModel,
  )

else:
 import sys

 _a    :   str        =			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



