


from typing import Optional, Union

import torch
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import BaseModelOutputWithPoolingAndNoAttention, ImageClassifierOutputWithNoAttention
from ...modeling_utils import PreTrainedModel
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_mobilenet_va import MobileNetVaConfig


lowerCAmelCase__			:      int								=logging.get_logger(__name__)


# General docstring
lowerCAmelCase__			:      Dict								='MobileNetV1Config'

# Base docstring
lowerCAmelCase__			:      Optional[Any]								='google/mobilenet_v1_1.0_224'
lowerCAmelCase__			:      Union[str, Any]								=[1, 10_24, 7, 7]

# Image classification docstring
lowerCAmelCase__			:      str								='google/mobilenet_v1_1.0_224'
lowerCAmelCase__			:      Union[str, Any]								='tabby, tabby cat'


lowerCAmelCase__			:      Tuple								=[
    'google/mobilenet_v1_1.0_224',
    'google/mobilenet_v1_0.75_192',
    # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
]






def 						a__			(				A__,      A__,      A__=None				):
			SCREAMING_SNAKE_CASE_		:     Dict					=					{}

			if isinstance(_A,      _A				):
						SCREAMING_SNAKE_CASE_		:     List[str]					=					model.mobilenet_va
			else:
						SCREAMING_SNAKE_CASE_		:     Optional[int]					=					model

			SCREAMING_SNAKE_CASE_		:     Any					=					'MobilenetV1/Conv2d_0/'
			SCREAMING_SNAKE_CASE_		:     List[str]					=					backbone.conv_stem.convolution.weight
			SCREAMING_SNAKE_CASE_		:     Tuple					=					backbone.conv_stem.normalization.bias
			SCREAMING_SNAKE_CASE_		:     Any					=					backbone.conv_stem.normalization.weight
			SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					backbone.conv_stem.normalization.running_mean
			SCREAMING_SNAKE_CASE_		:     Optional[int]					=					backbone.conv_stem.normalization.running_var

			for i in range(1_3				):
						SCREAMING_SNAKE_CASE_		:     Optional[int]					=					i + 1
						SCREAMING_SNAKE_CASE_		:     Dict					=					i * 2

						SCREAMING_SNAKE_CASE_		:     List[Any]					=					backbone.layer[pt_index]
						SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					F'''MobilenetV1/Conv2d_{tf_index}_depthwise/'''
						SCREAMING_SNAKE_CASE_		:     Dict					=					pointer.convolution.weight
						SCREAMING_SNAKE_CASE_		:     List[str]					=					pointer.normalization.bias
						SCREAMING_SNAKE_CASE_		:     Any					=					pointer.normalization.weight
						SCREAMING_SNAKE_CASE_		:     Dict					=					pointer.normalization.running_mean
						SCREAMING_SNAKE_CASE_		:     Dict					=					pointer.normalization.running_var

						SCREAMING_SNAKE_CASE_		:     Optional[int]					=					backbone.layer[pt_index + 1]
						SCREAMING_SNAKE_CASE_		:     int					=					F'''MobilenetV1/Conv2d_{tf_index}_pointwise/'''
						SCREAMING_SNAKE_CASE_		:     Dict					=					pointer.convolution.weight
						SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					pointer.normalization.bias
						SCREAMING_SNAKE_CASE_		:     List[Any]					=					pointer.normalization.weight
						SCREAMING_SNAKE_CASE_		:     List[str]					=					pointer.normalization.running_mean
						SCREAMING_SNAKE_CASE_		:     Optional[int]					=					pointer.normalization.running_var

			if isinstance(_A,      _A				):
						SCREAMING_SNAKE_CASE_		:     List[Any]					=					'MobilenetV1/Logits/Conv2d_1c_1x1/'
						SCREAMING_SNAKE_CASE_		:     str					=					model.classifier.weight
						SCREAMING_SNAKE_CASE_		:     Dict					=					model.classifier.bias

			return tf_to_pt_map






def 						a__			(				A__,      A__,      A__				):
			try:
						import numpy as np
						import tensorflow as tf
			except ImportError:
						logger.error(
						    'Loading a TensorFlow models in PyTorch, requires TensorFlow to be installed. Please see '
						    'https://www.tensorflow.org/install/ for installation instructions.'				)
						raise

			# Load weights from TF model
			SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					tf.train.list_variables(_A				)
			SCREAMING_SNAKE_CASE_		:     str					=					{}
			for name, shape in init_vars:
						logger.info(F'''Loading TF weight {name} with shape {shape}'''				)
						SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					tf.train.load_variable(_A,      _A				)
						SCREAMING_SNAKE_CASE_		:     str					=					array

			# Build TF to PyTorch weights loading map
			SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					_build_tf_to_pytorch_map(_A,      _A,      _A				)

			for name, pointer in tf_to_pt_map.items():
						logger.info(F'''Importing {name}'''				)
						if name not in tf_weights:
									logger.info(F'''{name} not in tf pre-trained weights, skipping'''				)
									continue

						SCREAMING_SNAKE_CASE_		:     str					=					tf_weights[name]

						if "depthwise_weights" in name:
									logger.info('Transposing depthwise'				)
									SCREAMING_SNAKE_CASE_		:     Dict					=					np.transpose(_A,      (2, 3, 0, 1)				)
						elif "weights" in name:
									logger.info('Transposing'				)
									if len(pointer.shape				) == 2:  # copying into linear layer
												SCREAMING_SNAKE_CASE_		:     List[Any]					=					array.squeeze().transpose()
									else:
												SCREAMING_SNAKE_CASE_		:     List[str]					=					np.transpose(_A,      (3, 2, 0, 1)				)

						if pointer.shape != array.shape:
									raise ValueError(F'''Pointer shape {pointer.shape} and array shape {array.shape} mismatched'''				)

						logger.info(F'''Initialize PyTorch weight {name} {array.shape}'''				)
						SCREAMING_SNAKE_CASE_		:     str					=					torch.from_numpy(_A				)

						tf_weights.pop(_A,      _A				)
						tf_weights.pop(name + '/RMSProp',      _A				)
						tf_weights.pop(name + '/RMSProp_1',      _A				)
						tf_weights.pop(name + '/ExponentialMovingAverage',      _A				)

			logger.info(F'''Weights not copied to PyTorch model: {', '.join(tf_weights.keys()				)}'''				)
			return model






def 						a__			(				A__,      A__				):
			SCREAMING_SNAKE_CASE_		,      SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					features.shape[-2:]
			SCREAMING_SNAKE_CASE_		,      SCREAMING_SNAKE_CASE_		:     Any					=					conv_layer.stride
			SCREAMING_SNAKE_CASE_		,      SCREAMING_SNAKE_CASE_		:     Dict					=					conv_layer.kernel_size

			if in_height % stride_height == 0:
						SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					max(kernel_height - stride_height,      0				)
			else:
						SCREAMING_SNAKE_CASE_		:     Optional[int]					=					max(kernel_height - (in_height % stride_height),      0				)

			if in_width % stride_width == 0:
						SCREAMING_SNAKE_CASE_		:     Optional[int]					=					max(kernel_width - stride_width,      0				)
			else:
						SCREAMING_SNAKE_CASE_		:     List[str]					=					max(kernel_width - (in_width % stride_width),      0				)

			SCREAMING_SNAKE_CASE_		:     List[str]					=					pad_along_width // 2
			SCREAMING_SNAKE_CASE_		:     Dict					=					pad_along_width - pad_left
			SCREAMING_SNAKE_CASE_		:     Optional[int]					=					pad_along_height // 2
			SCREAMING_SNAKE_CASE_		:     List[str]					=					pad_along_height - pad_top

			SCREAMING_SNAKE_CASE_		:     Optional[int]					=					(pad_left, pad_right, pad_top, pad_bottom)
			return nn.functional.pad(_A,      _A,      'constant',      0.0				)







class 	__lowercase    (nn.Module  ):





							"""simple docstring"""







							def __init__(      self			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__ = 1			,						lowerCAmelCase__ = 1			,						lowerCAmelCase__ = False			,						lowerCAmelCase__ = True			,						lowerCAmelCase__ = True			,						):





										"""simple docstring"""




										super().__init__()
										SCREAMING_SNAKE_CASE_		:     Any					=					config

										if in_channels % groups != 0:
													raise ValueError(F'''Input channels ({in_channels}) are not divisible by {groups} groups.'''       )
										if out_channels % groups != 0:
													raise ValueError(F'''Output channels ({out_channels}) are not divisible by {groups} groups.'''       )

										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					0 if config.tf_padding else int((kernel_size - 1) / 2       )

										SCREAMING_SNAKE_CASE_		:     int					=					nn.Convad(
										    in_channels=lowerCAmelCase__			,						out_channels=lowerCAmelCase__			,						kernel_size=lowerCAmelCase__			,						stride=lowerCAmelCase__			,						padding=lowerCAmelCase__			,						groups=lowerCAmelCase__			,						bias=lowerCAmelCase__			,						padding_mode='zeros'			,						)

										if use_normalization:
													SCREAMING_SNAKE_CASE_		:     List[Any]					=					nn.BatchNormad(
													    num_features=lowerCAmelCase__			,						eps=config.layer_norm_eps			,						momentum=0.9_997			,						affine=lowerCAmelCase__			,						track_running_stats=lowerCAmelCase__			,						)
										else:
													SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					None

										if use_activation:
													if isinstance(lowerCAmelCase__			,						lowerCAmelCase__       ):
																SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					ACTaFN[use_activation]
													elif isinstance(config.hidden_act			,						lowerCAmelCase__       ):
																SCREAMING_SNAKE_CASE_		:     str					=					ACTaFN[config.hidden_act]
													else:
																SCREAMING_SNAKE_CASE_		:     int					=					config.hidden_act
										else:
													SCREAMING_SNAKE_CASE_		:     Dict					=					None






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




										if self.config.tf_padding:
													SCREAMING_SNAKE_CASE_		:     Dict					=					apply_tf_padding(lowerCAmelCase__			,						self.convolution       )
										SCREAMING_SNAKE_CASE_		:     str					=					self.convolution(lowerCAmelCase__       )
										if self.normalization is not None:
													SCREAMING_SNAKE_CASE_		:     Dict					=					self.normalization(lowerCAmelCase__       )
										if self.activation is not None:
													SCREAMING_SNAKE_CASE_		:     Optional[int]					=					self.activation(lowerCAmelCase__       )
										return features







class 	__lowercase    (__SCREAMING_SNAKE_CASE  ):





							"""simple docstring"""







							_UpperCAmelCase      =						MobileNetVaConfig
							_UpperCAmelCase      =						load_tf_weights_in_mobilenet_va
							_UpperCAmelCase      =						'mobilenet_v1'
							_UpperCAmelCase      =						'pixel_values'
							_UpperCAmelCase      =						False






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




										if isinstance(lowerCAmelCase__			,						(nn.Linear, nn.Convad)       ):
													module.weight.data.normal_(mean=0.0			,						std=self.config.initializer_range       )
													if module.bias is not None:
																module.bias.data.zero_()
										elif isinstance(lowerCAmelCase__			,						nn.BatchNormad       ):
													module.bias.data.zero_()
													module.weight.data.fill_(1.0       )







lowerCAmelCase__			:      Tuple								=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 ([`MobileNetV1Config`]): 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'

lowerCAmelCase__			:      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            [`MobileNetV1ImageProcessor.__call__`] for details.\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'







@add_start_docstrings(
    """The bare MobileNetV1 model outputting raw hidden-states without any specific head on top."""	,       __SCREAMING_SNAKE_CASE	,       )
class 	__lowercase    (__SCREAMING_SNAKE_CASE  ):





							"""simple docstring"""







							def __init__(      self			,						lowerCAmelCase__			,						lowerCAmelCase__ = True       ):





										"""simple docstring"""




										super().__init__(lowerCAmelCase__       )
										SCREAMING_SNAKE_CASE_		:     List[Any]					=					config

										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					3_2
										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					max(int(depth * config.depth_multiplier       )			,						config.min_depth       )

										SCREAMING_SNAKE_CASE_		:     List[Any]					=					MobileNetVaConvLayer(
										    lowerCAmelCase__			,						in_channels=config.num_channels			,						out_channels=lowerCAmelCase__			,						kernel_size=3			,						stride=2			,						)

										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					[1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1]

										SCREAMING_SNAKE_CASE_		:     List[Any]					=					nn.ModuleList()
										for i in range(1_3       ):
													SCREAMING_SNAKE_CASE_		:     int					=					out_channels

													if strides[i] == 2 or i == 0:
																depth *= 2
																SCREAMING_SNAKE_CASE_		:     Dict					=					max(int(depth * config.depth_multiplier       )			,						config.min_depth       )

													self.layer.append(
													    MobileNetVaConvLayer(
													        lowerCAmelCase__			,						in_channels=lowerCAmelCase__			,						out_channels=lowerCAmelCase__			,						kernel_size=3			,						stride=strides[i]			,						groups=lowerCAmelCase__			,						)       )

													self.layer.append(
													    MobileNetVaConvLayer(
													        lowerCAmelCase__			,						in_channels=lowerCAmelCase__			,						out_channels=lowerCAmelCase__			,						kernel_size=1			,						)       )

										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					nn.AdaptiveAvgPoolad((1, 1)       ) if add_pooling_layer else None

										# Initialize weights and apply final processing
										self.post_init()






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




										raise NotImplementedError






							@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 					UpperCamelCase__     (      self			,						lowerCAmelCase__ = None			,						lowerCAmelCase__ = None			,						lowerCAmelCase__ = None			,						):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					(
										    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
										)
										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					return_dict if return_dict is not None else self.config.use_return_dict

										if pixel_values is None:
													raise ValueError('You have to specify pixel_values'       )

										SCREAMING_SNAKE_CASE_		:     Tuple					=					self.conv_stem(lowerCAmelCase__       )

										SCREAMING_SNAKE_CASE_		:     int					=					() if output_hidden_states else None

										for i, layer_module in enumerate(self.layer       ):
													SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					layer_module(lowerCAmelCase__       )

													if output_hidden_states:
																SCREAMING_SNAKE_CASE_		:     Any					=					all_hidden_states + (hidden_states,)

										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					hidden_states

										if self.pooler is not None:
													SCREAMING_SNAKE_CASE_		:     List[str]					=					torch.flatten(self.pooler(lowerCAmelCase__       )			,						start_dim=1       )
										else:
													SCREAMING_SNAKE_CASE_		:     str					=					None

										if not return_dict:
													return tuple(v for v in [last_hidden_state, pooled_output, all_hidden_states] if v is not None       )

										return BaseModelOutputWithPoolingAndNoAttention(
										    last_hidden_state=lowerCAmelCase__			,						pooler_output=lowerCAmelCase__			,						hidden_states=lowerCAmelCase__			,						)







@add_start_docstrings(
    """\n    MobileNetV1 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	,       )
class 	__lowercase    (__SCREAMING_SNAKE_CASE  ):





							"""simple docstring"""







							def __init__(      self			,						lowerCAmelCase__       ):





										"""simple docstring"""




										super().__init__(lowerCAmelCase__       )

										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					config.num_labels
										SCREAMING_SNAKE_CASE_		:     List[Any]					=					MobileNetVaModel(lowerCAmelCase__       )

										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					self.mobilenet_va.layer[-1].convolution.out_channels

										# Classifier head
										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					nn.Dropout(config.classifier_dropout_prob			,						inplace=lowerCAmelCase__       )
										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					nn.Linear(lowerCAmelCase__			,						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 					UpperCamelCase__     (      self			,						lowerCAmelCase__ = None			,						lowerCAmelCase__ = None			,						lowerCAmelCase__ = None			,						lowerCAmelCase__ = None			,						):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     str					=					return_dict if return_dict is not None else self.config.use_return_dict

										SCREAMING_SNAKE_CASE_		:     int					=					self.mobilenet_va(lowerCAmelCase__			,						output_hidden_states=lowerCAmelCase__			,						return_dict=lowerCAmelCase__       )

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

										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					self.classifier(self.dropout(lowerCAmelCase__       )       )

										SCREAMING_SNAKE_CASE_		:     Tuple					=					None
										if labels is not None:
													if self.config.problem_type is None:
																if self.num_labels == 1:
																			SCREAMING_SNAKE_CASE_		:     List[Any]					=					'regression'
																elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
																			SCREAMING_SNAKE_CASE_		:     Optional[int]					=					'single_label_classification'
																else:
																			SCREAMING_SNAKE_CASE_		:     Dict					=					'multi_label_classification'

													if self.config.problem_type == "regression":
																SCREAMING_SNAKE_CASE_		:     str					=					MSELoss()
																if self.num_labels == 1:
																			SCREAMING_SNAKE_CASE_		:     Optional[int]					=					loss_fct(logits.squeeze()			,						labels.squeeze()       )
																else:
																			SCREAMING_SNAKE_CASE_		:     Dict					=					loss_fct(lowerCAmelCase__			,						lowerCAmelCase__       )
													elif self.config.problem_type == "single_label_classification":
																SCREAMING_SNAKE_CASE_		:     Optional[int]					=					CrossEntropyLoss()
																SCREAMING_SNAKE_CASE_		:     Optional[int]					=					loss_fct(logits.view(-1			,						self.num_labels       )			,						labels.view(-1       )       )
													elif self.config.problem_type == "multi_label_classification":
																SCREAMING_SNAKE_CASE_		:     str					=					BCEWithLogitsLoss()
																SCREAMING_SNAKE_CASE_		:     Tuple					=					loss_fct(lowerCAmelCase__			,						lowerCAmelCase__       )

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

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









import numpy as np
def 							UpperCamelCase_(					_A :np.array	)->		np.array:
			return 1 / (1 + np.exp(-vector	))


if __name__ == "__main__":
						import doctest

						doctest.testmod()


