





'''simple docstring'''







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


snake_case_  :							Union[str, Any]            =	logging.get_logger(__name__)

# General docstring
snake_case_  :							Any            =	"ResNetConfig"

# Base docstring
snake_case_  :							str            =	"microsoft/resnet-50"
snake_case_  :							Optional[Any]            =	[1, 20_48, 7, 7]

# Image classification docstring
snake_case_  :							Dict            =	"microsoft/resnet-50"
snake_case_  :							List[str]            =	"tiger cat"

snake_case_  :							Optional[int]            =	[
    "microsoft/resnet-50",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]


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

							def __init__(				self				:  List[Any]							,  __magic_name__				:  int							,  __magic_name__				:  int = 3							,  __magic_name__				:  int = 1							,  __magic_name__				:  str = "relu"							,  **__magic_name__				:  Optional[Any] )       ->							None:







													"""simple docstring"""
													super().__init__(**_lowercase )
													UpperCAmelCase_      :   List[Any]      =	kernel_size // 2
													UpperCAmelCase_      :   Optional[Any]      =	tf.keras.layers.ConvaD(
													    _lowercase							,  kernel_size=_lowercase							,  strides=_lowercase							,  padding='''valid'''							,  use_bias=_lowercase							,  name='''convolution''' )
													# Use same default momentum and epsilon as PyTorch equivalent
													UpperCAmelCase_      :   str      =	tf.keras.layers.BatchNormalization(epsilon=1E-5							,  momentum=0.9							,  name='''normalization''' )
													UpperCAmelCase_      :   List[Any]      =	ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('''linear''' )

							def      UpperCAmelCase__						(				self				:  Optional[Any]							,  __magic_name__				:  tf.Tensor )       ->							tf.Tensor:







													"""simple docstring"""
													# Pad to match that done in the PyTorch Conv2D model
													UpperCAmelCase_      :   List[Any]      =	(self.pad_value, self.pad_value)
													UpperCAmelCase_      :   Union[str, Any]      =	tf.pad(_lowercase							,  [(0, 0), height_pad, width_pad, (0, 0)] )
													UpperCAmelCase_      :   str      =	self.conv(_lowercase )
													return hidden_state



							def      UpperCAmelCase__						(				self				:  Tuple							,  __magic_name__				:  tf.Tensor							,  __magic_name__				:  bool = False )       ->							tf.Tensor:







													"""simple docstring"""
													UpperCAmelCase_      :   Any      =	self.convolution(_lowercase )
													UpperCAmelCase_      :   Tuple      =	self.normalization(_lowercase							,  training=_lowercase )
													UpperCAmelCase_      :   Tuple      =	self.activation(_lowercase )
													return hidden_state





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

							def __init__(				self				:  Dict							,  __magic_name__				:  ResNetConfig							,  **__magic_name__				:  Union[str, Any] )       ->							None:







													"""simple docstring"""
													super().__init__(**_lowercase )
													UpperCAmelCase_      :   Union[str, Any]      =	TFResNetConvLayer(
													    config.embedding_size							,  kernel_size=7							,  stride=2							,  activation=config.hidden_act							,  name='''embedder'''							,  )
													UpperCAmelCase_      :   List[Any]      =	tf.keras.layers.MaxPoolaD(pool_size=3							,  strides=2							,  padding='''valid'''							,  name='''pooler''' )
													UpperCAmelCase_      :   int      =	config.num_channels



							def      UpperCAmelCase__						(				self				:  Dict							,  __magic_name__				:  tf.Tensor							,  __magic_name__				:  bool = False )       ->							tf.Tensor:







													"""simple docstring"""
													UpperCAmelCase_    ,							UpperCAmelCase_    ,							UpperCAmelCase_    ,							UpperCAmelCase_      :   Dict      =	shape_list(_lowercase )
													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.''' )
													UpperCAmelCase_      :   List[str]      =	pixel_values
													UpperCAmelCase_      :   Optional[Any]      =	self.embedder(_lowercase )
													UpperCAmelCase_      :   str      =	tf.pad(_lowercase							,  [[0, 0], [1, 1], [1, 1], [0, 0]] )
													UpperCAmelCase_      :   Optional[Any]      =	self.pooler(_lowercase )
													return hidden_state





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

							def __init__(				self				:  Dict							,  __magic_name__				:  int							,  __magic_name__				:  int = 2							,  **__magic_name__				:  str )       ->							None:







													"""simple docstring"""
													super().__init__(**_lowercase )
													UpperCAmelCase_      :   Tuple      =	tf.keras.layers.ConvaD(
													    _lowercase							,  kernel_size=1							,  strides=_lowercase							,  use_bias=_lowercase							,  name='''convolution''' )
													# Use same default momentum and epsilon as PyTorch equivalent
													UpperCAmelCase_      :   Union[str, Any]      =	tf.keras.layers.BatchNormalization(epsilon=1E-5							,  momentum=0.9							,  name='''normalization''' )



							def      UpperCAmelCase__						(				self				:  Union[str, Any]							,  __magic_name__				:  tf.Tensor							,  __magic_name__				:  bool = False )       ->							tf.Tensor:







													"""simple docstring"""
													UpperCAmelCase_      :   int      =	x
													UpperCAmelCase_      :   Tuple      =	self.convolution(_lowercase )
													UpperCAmelCase_      :   Optional[Any]      =	self.normalization(_lowercase							,  training=_lowercase )
													return hidden_state





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

							def __init__(				self				:  Any							,  __magic_name__				:  int							,  __magic_name__				:  int							,  __magic_name__				:  int = 1							,  __magic_name__				:  str = "relu"							,  **__magic_name__				:  Tuple )       ->							None:







													"""simple docstring"""
													super().__init__(**_lowercase )
													UpperCAmelCase_      :   Tuple      =	in_channels != out_channels or stride != 1
													UpperCAmelCase_      :   Union[str, Any]      =	TFResNetConvLayer(_lowercase							,  stride=_lowercase							,  name='''layer.0''' )
													UpperCAmelCase_      :   Optional[Any]      =	TFResNetConvLayer(_lowercase							,  activation=_lowercase							,  name='''layer.1''' )
													UpperCAmelCase_      :   Union[str, Any]      =	(
													    TFResNetShortCut(_lowercase							,  stride=_lowercase							,  name='''shortcut''' )
													    if should_apply_shortcut
													    else tf.keras.layers.Activation('''linear'''							,  name='''shortcut''' )
													)
													UpperCAmelCase_      :   int      =	ACTaFN[activation]



							def      UpperCAmelCase__						(				self				:  Any							,  __magic_name__				:  tf.Tensor							,  __magic_name__				:  bool = False )       ->							tf.Tensor:







													"""simple docstring"""
													UpperCAmelCase_      :   str      =	hidden_state
													UpperCAmelCase_      :   Tuple      =	self.conva(_lowercase							,  training=_lowercase )
													UpperCAmelCase_      :   Optional[Any]      =	self.conva(_lowercase							,  training=_lowercase )
													UpperCAmelCase_      :   Optional[Any]      =	self.shortcut(_lowercase							,  training=_lowercase )
													hidden_state += residual
													UpperCAmelCase_      :   Optional[Any]      =	self.activation(_lowercase )
													return hidden_state





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

							def __init__(				self				:  Optional[Any]							,  __magic_name__				:  int							,  __magic_name__				:  int							,  __magic_name__				:  int = 1							,  __magic_name__				:  str = "relu"							,  __magic_name__				:  int = 4							,  **__magic_name__				:  int							,  )       ->							None:







													"""simple docstring"""
													super().__init__(**_lowercase )
													UpperCAmelCase_      :   Dict      =	in_channels != out_channels or stride != 1
													UpperCAmelCase_      :   Optional[Any]      =	out_channels // reduction
													UpperCAmelCase_      :   Optional[Any]      =	TFResNetConvLayer(_lowercase							,  kernel_size=1							,  name='''layer.0''' )
													UpperCAmelCase_      :   Union[str, Any]      =	TFResNetConvLayer(_lowercase							,  stride=_lowercase							,  name='''layer.1''' )
													UpperCAmelCase_      :   int      =	TFResNetConvLayer(_lowercase							,  kernel_size=1							,  activation=_lowercase							,  name='''layer.2''' )
													UpperCAmelCase_      :   List[str]      =	(
													    TFResNetShortCut(_lowercase							,  stride=_lowercase							,  name='''shortcut''' )
													    if should_apply_shortcut
													    else tf.keras.layers.Activation('''linear'''							,  name='''shortcut''' )
													)
													UpperCAmelCase_      :   Union[str, Any]      =	ACTaFN[activation]



							def      UpperCAmelCase__						(				self				:  List[Any]							,  __magic_name__				:  tf.Tensor							,  __magic_name__				:  bool = False )       ->							tf.Tensor:







													"""simple docstring"""
													UpperCAmelCase_      :   Optional[int]      =	hidden_state
													UpperCAmelCase_      :   List[Any]      =	self.conva(_lowercase							,  training=_lowercase )
													UpperCAmelCase_      :   str      =	self.conva(_lowercase							,  training=_lowercase )
													UpperCAmelCase_      :   str      =	self.conva(_lowercase							,  training=_lowercase )
													UpperCAmelCase_      :   Union[str, Any]      =	self.shortcut(_lowercase							,  training=_lowercase )
													hidden_state += residual
													UpperCAmelCase_      :   str      =	self.activation(_lowercase )
													return hidden_state





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

							def __init__(				self				:  Union[str, Any]							,  __magic_name__				:  ResNetConfig							,  __magic_name__				:  int							,  __magic_name__				:  int							,  __magic_name__				:  int = 2							,  __magic_name__				:  int = 2							,  **__magic_name__				:  Dict )       ->							None:







													"""simple docstring"""
													super().__init__(**_lowercase )

													UpperCAmelCase_      :   int      =	TFResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else TFResNetBasicLayer

													UpperCAmelCase_      :   Optional[int]      =	[layer(_lowercase							,  _lowercase							,  stride=_lowercase							,  activation=config.hidden_act							,  name='''layers.0''' )]
													layers += [
													    layer(_lowercase							,  _lowercase							,  activation=config.hidden_act							,  name=F"""layers.{i + 1}""" )
													    for i in range(depth - 1 )
													]
													UpperCAmelCase_      :   Optional[int]      =	layers



							def      UpperCAmelCase__						(				self				:  str							,  __magic_name__				:  tf.Tensor							,  __magic_name__				:  bool = False )       ->							tf.Tensor:







													"""simple docstring"""
													for layer in self.stage_layers:
																			UpperCAmelCase_      :   str      =	layer(_lowercase							,  training=_lowercase )
													return hidden_state





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

							def __init__(				self				:  Optional[int]							,  __magic_name__				:  ResNetConfig							,  **__magic_name__				:  Optional[int] )       ->							None:







													"""simple docstring"""
													super().__init__(**_lowercase )
													# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
													UpperCAmelCase_      :   Union[str, Any]      =	[
													    TFResNetStage(
													        _lowercase							,  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(_lowercase							,  _lowercase							,  _lowercase							,  depth=_lowercase							,  name=F"""stages.{i + 1}""" ) )



							def      UpperCAmelCase__						(				self				:  str							,  __magic_name__				:  tf.Tensor							,  __magic_name__				:  bool = False							,  __magic_name__				:  bool = True							,  __magic_name__				:  bool = False							,  )       ->							TFBaseModelOutputWithNoAttention:







													"""simple docstring"""
													UpperCAmelCase_      :   Optional[Any]      =	() if output_hidden_states else None

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

																			UpperCAmelCase_      :   int      =	stage_module(_lowercase							,  training=_lowercase )

													if output_hidden_states:
																			UpperCAmelCase_      :   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 TFBaseModelOutputWithNoAttention(last_hidden_state=_lowercase							,  hidden_states=_lowercase )





class        __a   (_snake_case  ):
							__a       : int          =							ResNetConfig
							__a       : Dict          =							"resnet"
							__a       : Any          =							"pixel_values"

							@property
							def      UpperCAmelCase__						(				self				:  Any )       ->							List[str]:







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





snake_case_  :							Optional[Any]            =	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"


snake_case_  :							List[str]            =	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        __a   (tf.keras.layers.Layer  ):
							__a       : Any          =							ResNetConfig

							def __init__(				self				:  Tuple							,  __magic_name__				:  ResNetConfig							,  **__magic_name__				:  str )       ->							None:







													"""simple docstring"""
													super().__init__(**_lowercase )
													UpperCAmelCase_      :   Any      =	config
													UpperCAmelCase_      :   str      =	TFResNetEmbeddings(_lowercase							,  name='''embedder''' )
													UpperCAmelCase_      :   List[Any]      =	TFResNetEncoder(_lowercase							,  name='''encoder''' )
													UpperCAmelCase_      :   Optional[int]      =	tf.keras.layers.GlobalAveragePoolingaD(keepdims=_lowercase )



							@unpack_inputs
							def      UpperCAmelCase__						(				self				:  Union[str, Any]							,  __magic_name__				:  tf.Tensor							,  __magic_name__				:  Optional[bool] = None							,  __magic_name__				:  Optional[bool] = None							,  __magic_name__				:  bool = False							,  )       ->							Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:







													"""simple docstring"""
													UpperCAmelCase_      :   Optional[Any]      =	(
													    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
													)
													UpperCAmelCase_      :   Any      =	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)
													UpperCAmelCase_      :   str      =	tf.transpose(_lowercase							,  perm=[0, 2, 3, 1] )
													UpperCAmelCase_      :   List[Any]      =	self.embedder(_lowercase							,  training=_lowercase )

													UpperCAmelCase_      :   Any      =	self.encoder(
													    _lowercase							,  output_hidden_states=_lowercase							,  return_dict=_lowercase							,  training=_lowercase )

													UpperCAmelCase_      :   List[str]      =	encoder_outputs[0]

													UpperCAmelCase_      :   Dict      =	self.pooler(_lowercase )

													# Transpose all the outputs to the NCHW format
													# (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
													UpperCAmelCase_      :   Optional[int]      =	tf.transpose(_lowercase							,  (0, 3, 1, 2) )
													UpperCAmelCase_      :   List[str]      =	tf.transpose(_lowercase							,  (0, 3, 1, 2) )
													UpperCAmelCase_      :   List[str]      =	()
													for hidden_state in encoder_outputs[1:]:
																			UpperCAmelCase_      :   Tuple      =	hidden_states + tuple(tf.transpose(_lowercase							,  (0, 3, 1, 2) ) for h in hidden_state )

													if not return_dict:
																			return (last_hidden_state, pooled_output) + hidden_states

													UpperCAmelCase_      :   Union[str, Any]      =	hidden_states if output_hidden_states else None

													return TFBaseModelOutputWithPoolingAndNoAttention(
													    last_hidden_state=_lowercase							,  pooler_output=_lowercase							,  hidden_states=_lowercase							,  )





@add_start_docstrings(
    "The bare ResNet model outputting raw features without any specific head on top."							,		_snake_case							,		)
class        __a   (_snake_case  ):

							def __init__(				self				:  Union[str, Any]							,  __magic_name__				:  ResNetConfig							,  **__magic_name__				:  Optional[int] )       ->							None:







													"""simple docstring"""
													super().__init__(_lowercase							,  **_lowercase )
													UpperCAmelCase_      :   Dict      =	TFResNetMainLayer(config=_lowercase							,  name='''resnet''' )



							@add_start_docstrings_to_model_forward(_lowercase )
							@add_code_sample_docstrings(
							    checkpoint=_CHECKPOINT_FOR_DOC							,  output_type=_lowercase							,  config_class=_CONFIG_FOR_DOC							,  modality='''vision'''							,  expected_output=_EXPECTED_OUTPUT_SHAPE							,  )
							@unpack_inputs
							def      UpperCAmelCase__						(				self				:  Dict							,  __magic_name__				:  tf.Tensor							,  __magic_name__				:  Optional[bool] = None							,  __magic_name__				:  Optional[bool] = None							,  __magic_name__				:  bool = False							,  )       ->							Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:







													"""simple docstring"""
													UpperCAmelCase_      :   Optional[int]      =	(
													    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
													)
													UpperCAmelCase_      :   Dict      =	return_dict if return_dict is not None else self.config.use_return_dict

													UpperCAmelCase_      :   Optional[int]      =	self.resnet(
													    pixel_values=_lowercase							,  output_hidden_states=_lowercase							,  return_dict=_lowercase							,  training=_lowercase							,  )
													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    "							,		_snake_case							,		)
class        __a   (_snake_case							,		_snake_case  ):

							def __init__(				self				:  List[str]							,  __magic_name__				:  ResNetConfig							,  **__magic_name__				:  str )       ->							None:







													"""simple docstring"""
													super().__init__(_lowercase							,  **_lowercase )
													UpperCAmelCase_      :   str      =	config.num_labels
													UpperCAmelCase_      :   Union[str, Any]      =	TFResNetMainLayer(_lowercase							,  name='''resnet''' )
													# classification head
													UpperCAmelCase_      :   str      =	(
													    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				:  List[Any]							,  __magic_name__				:  tf.Tensor )       ->							tf.Tensor:







													"""simple docstring"""
													UpperCAmelCase_      :   Dict      =	tf.keras.layers.Flatten()(_lowercase )
													UpperCAmelCase_      :   List[str]      =	self.classifier_layer(_lowercase )
													return logits



							@add_start_docstrings_to_model_forward(_lowercase )
							@add_code_sample_docstrings(
							    checkpoint=_IMAGE_CLASS_CHECKPOINT							,  output_type=_lowercase							,  config_class=_CONFIG_FOR_DOC							,  expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT							,  )
							@unpack_inputs
							def      UpperCAmelCase__						(				self				:  int							,  __magic_name__				:  tf.Tensor = None							,  __magic_name__				:  tf.Tensor = None							,  __magic_name__				:  bool = None							,  __magic_name__				:  bool = None							,  __magic_name__				:  bool = False							,  )       ->							Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:







													"""simple docstring"""
													UpperCAmelCase_      :   Any      =	return_dict if return_dict is not None else self.config.use_return_dict

													UpperCAmelCase_      :   str      =	self.resnet(
													    _lowercase							,  output_hidden_states=_lowercase							,  return_dict=_lowercase							,  training=_lowercase )

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

													UpperCAmelCase_      :   Union[str, Any]      =	self.classifier(_lowercase )

													UpperCAmelCase_      :   Tuple      =	None if labels is None else self.hf_compute_loss(_lowercase							,  _lowercase )

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

													return TFImageClassifierOutputWithNoAttention(loss=_lowercase							,  logits=_lowercase							,  hidden_states=outputs.hidden_states )










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


UpperCamelCase_      			=  {
    "configuration_mobilenet_v1": [
        "MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "MobileNetV1Config",
        "MobileNetV1OnnxConfig",
    ],
}

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_      			=  ["MobileNetV1FeatureExtractor"]
							UpperCamelCase_      			=  ["MobileNetV1ImageProcessor"]

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_      			=  [
							    "MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "MobileNetV1ForImageClassification",
							    "MobileNetV1Model",
							    "MobileNetV1PreTrainedModel",
							    "load_tf_weights_in_mobilenet_v1",
							]


if TYPE_CHECKING:
							from .configuration_mobilenet_va import (
							    MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    MobileNetVaConfig,
							    MobileNetVaOnnxConfig,
							)

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_mobilenet_va import MobileNetVaFeatureExtractor
														from .image_processing_mobilenet_va import MobileNetVaImageProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_mobilenet_va import (
														    MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST,
														    MobileNetVaForImageClassification,
														    MobileNetVaModel,
														    MobileNetVaPreTrainedModel,
														    load_tf_weights_in_mobilenet_va,
														)


else:
							import sys

							UpperCamelCase_      			=  _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





