


"""simple docstring"""




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


lowercase_			     =  logging.get_logger(__name__)


# General docstring
lowercase_			     =  "MobileNetV1Config"

# Base docstring
lowercase_			     =  "google/mobilenet_v1_1.0_224"
lowercase_			     =  [1, 1_0_2_4, 7, 7]

# Image classification docstring
lowercase_			     =  "google/mobilenet_v1_1.0_224"
lowercase_			     =  "tabby, tabby cat"


lowercase_			     =  [
    "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        lowercase							(		lowerCAmelCase__ :     List[str]    ,					lowerCAmelCase__ :     int    ,					lowerCAmelCase__ :     Optional[int]=None			) ->      int:
		__a           =			{}

		if isinstance(lowerCAmelCase__    ,					lowerCAmelCase__			):
				__a           =			model.mobilenet_va
		else:
				__a           =			model

		__a           =			'''MobilenetV1/Conv2d_0/'''
		__a           =			backbone.conv_stem.convolution.weight
		__a           =			backbone.conv_stem.normalization.bias
		__a           =			backbone.conv_stem.normalization.weight
		__a           =			backbone.conv_stem.normalization.running_mean
		__a           =			backbone.conv_stem.normalization.running_var

		for i in range(13			):
				__a           =			i + 1
				__a           =			i * 2

				__a           =			backbone.layer[pt_index]
				__a           =			f'''MobilenetV1/Conv2d_{tf_index}_depthwise/'''
				__a           =			pointer.convolution.weight
				__a           =			pointer.normalization.bias
				__a           =			pointer.normalization.weight
				__a           =			pointer.normalization.running_mean
				__a           =			pointer.normalization.running_var

				__a           =			backbone.layer[pt_index + 1]
				__a           =			f'''MobilenetV1/Conv2d_{tf_index}_pointwise/'''
				__a           =			pointer.convolution.weight
				__a           =			pointer.normalization.bias
				__a           =			pointer.normalization.weight
				__a           =			pointer.normalization.running_mean
				__a           =			pointer.normalization.running_var

		if isinstance(lowerCAmelCase__    ,					lowerCAmelCase__			):
				__a           =			'''MobilenetV1/Logits/Conv2d_1c_1x1/'''
				__a           =			model.classifier.weight
				__a           =			model.classifier.bias

		return tf_to_pt_map

def        lowercase							(		lowerCAmelCase__ :     Union[str, Any]    ,					lowerCAmelCase__ :     List[str]    ,					lowerCAmelCase__ :     int			) ->      Tuple:
		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
		__a           =			tf.train.list_variables(lowerCAmelCase__			)
		__a           =			{}
		for name, shape in init_vars:
				logger.info(f'''Loading TF weight {name} with shape {shape}'''			)
				__a           =			tf.train.load_variable(lowerCAmelCase__    ,					lowerCAmelCase__			)
				__a           =			array

		# Build TF to PyTorch weights loading map
		__a           =			_build_tf_to_pytorch_map(lowerCAmelCase__    ,					lowerCAmelCase__    ,					lowerCAmelCase__			)

		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

				__a           =			tf_weights[name]

				if "depthwise_weights" in name:
						logger.info('''Transposing depthwise'''			)
						__a           =			np.transpose(lowerCAmelCase__    ,					(2, 3, 0, 1)			)
				elif "weights" in name:
						logger.info('''Transposing'''			)
						if len(pointer.shape			) == 2:  # copying into linear layer
								__a           =			array.squeeze().transpose()
						else:
								__a           =			np.transpose(lowerCAmelCase__    ,					(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}'''			)
				__a           =			torch.from_numpy(lowerCAmelCase__			)

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

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

def        lowercase							(		lowerCAmelCase__ :     torch.Tensor    ,					lowerCAmelCase__ :     nn.Convad			) ->      torch.Tensor:
		__a      ,     __a           =			features.shape[-2:]
		__a      ,     __a           =			conv_layer.stride
		__a      ,     __a           =			conv_layer.kernel_size

		if in_height % stride_height == 0:
				__a           =			max(kernel_height - stride_height    ,					0			)
		else:
				__a           =			max(kernel_height - (in_height % stride_height)    ,					0			)

		if in_width % stride_width == 0:
				__a           =			max(kernel_width - stride_width    ,					0			)
		else:
				__a           =			max(kernel_width - (in_width % stride_width)    ,					0			)

		__a           =			pad_along_width // 2
		__a           =			pad_along_width - pad_left
		__a           =			pad_along_height // 2
		__a           =			pad_along_height - pad_top

		__a           =			(pad_left, pad_right, pad_top, pad_bottom)
		return nn.functional.pad(lowerCAmelCase__    ,					lowerCAmelCase__    ,					'''constant'''    ,					0.0			)
class 					__lowerCAmelCase					(   nn.Module       ):


		'''simple docstring'''



		def __init__(  self							, _a							, _a							, _a							, _a							, _a = 1							, _a = 1							, _a = False							, _a = True							, _a = True							, ):
				super().__init__()
				__a           =			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.'''      )

				__a           =			0 if config.tf_padding else int((kernel_size - 1) / 2      )

				__a           =			nn.Convad(
				    in_channels=_a							, out_channels=_a							, kernel_size=_a							, stride=_a							, padding=_a							, groups=_a							, bias=_a							, padding_mode='''zeros'''							, )

				if use_normalization:
						__a           =			nn.BatchNormad(
						    num_features=_a							, eps=config.layer_norm_eps							, momentum=0.9997							, affine=_a							, track_running_stats=_a							, )
				else:
						__a           =			None

				if use_activation:
						if isinstance(_a							, _a      ):
								__a           =			ACTaFN[use_activation]
						elif isinstance(config.hidden_act							, _a      ):
								__a           =			ACTaFN[config.hidden_act]
						else:
								__a           =			config.hidden_act
				else:
						__a           =			None





		def 			__UpperCAmelCase       (  self							, _a      ):
				if self.config.tf_padding:
						__a           =			apply_tf_padding(_a							, self.convolution      )
				__a           =			self.convolution(_a      )
				if self.normalization is not None:
						__a           =			self.normalization(_a      )
				if self.activation is not None:
						__a           =			self.activation(_a      )
				return features







class 					__lowerCAmelCase					(   __SCREAMING_SNAKE_CASE       ):


		'''simple docstring'''



		__UpperCAmelCase		:			str										=				MobileNetVaConfig
		__UpperCAmelCase		:			Optional[int]										=				load_tf_weights_in_mobilenet_va
		__UpperCAmelCase		:			Optional[Any]										=				'mobilenet_v1'
		__UpperCAmelCase		:			Tuple										=				'pixel_values'
		__UpperCAmelCase		:			int										=				False

		def 			__UpperCAmelCase       (  self							, _a      ):
				if isinstance(_a							, (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(_a							, nn.BatchNormad      ):
						module.bias.data.zero_()
						module.weight.data.fill_(1.0      )







lowercase_			     =  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"

lowercase_			     =  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 					__lowerCAmelCase					(   __SCREAMING_SNAKE_CASE       ):


		'''simple docstring'''



		def __init__(  self							, _a							, _a = True      ):
				super().__init__(_a      )
				__a           =			config

				__a           =			32
				__a           =			max(int(depth * config.depth_multiplier      )							, config.min_depth      )

				__a           =			MobileNetVaConvLayer(
				    _a							, in_channels=config.num_channels							, out_channels=_a							, kernel_size=3							, stride=2							, )

				__a           =			[1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1]

				__a           =			nn.ModuleList()
				for i in range(13      ):
						__a           =			out_channels

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

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

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

				__a           =			nn.AdaptiveAvgPoolad((1, 1)      ) if add_pooling_layer else None

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

		def 			__UpperCAmelCase       (  self							, _a      ):
				raise NotImplementedError





		@add_start_docstrings_to_model_forward(_a      )
		@add_code_sample_docstrings(
		    checkpoint=_CHECKPOINT_FOR_DOC							, output_type=_a							, config_class=_CONFIG_FOR_DOC							, modality='''vision'''							, expected_output=_EXPECTED_OUTPUT_SHAPE							, )
		def 			__UpperCAmelCase       (  self							, _a = None							, _a = None							, _a = None							, ):
				__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

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

				__a           =			self.conv_stem(_a      )

				__a           =			() if output_hidden_states else None

				for i, layer_module in enumerate(self.layer      ):
						__a           =			layer_module(_a      )

						if output_hidden_states:
								__a           =			all_hidden_states + (hidden_states,)

				__a           =			hidden_states

				if self.pooler is not None:
						__a           =			torch.flatten(self.pooler(_a      )							, start_dim=1      )
				else:
						__a           =			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=_a							, pooler_output=_a							, hidden_states=_a							, )







@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 					__lowerCAmelCase					(   __SCREAMING_SNAKE_CASE       ):


		'''simple docstring'''



		def __init__(  self							, _a      ):
				super().__init__(_a      )

				__a           =			config.num_labels
				__a           =			MobileNetVaModel(_a      )

				__a           =			self.mobilenet_va.layer[-1].convolution.out_channels

				# Classifier head
				__a           =			nn.Dropout(config.classifier_dropout_prob							, inplace=_a      )
				__a           =			nn.Linear(_a							, 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(_a      )
		@add_code_sample_docstrings(
		    checkpoint=_IMAGE_CLASS_CHECKPOINT							, output_type=_a							, config_class=_CONFIG_FOR_DOC							, expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT							, )
		def 			__UpperCAmelCase       (  self							, _a = None							, _a = None							, _a = None							, _a = None							, ):
				__a           =			return_dict if return_dict is not None else self.config.use_return_dict

				__a           =			self.mobilenet_va(_a							, output_hidden_states=_a							, return_dict=_a      )

				__a           =			outputs.pooler_output if return_dict else outputs[1]

				__a           =			self.classifier(self.dropout(_a      )      )

				__a           =			None
				if labels is not None:
						if self.config.problem_type is None:
								if self.num_labels == 1:
										__a           =			'''regression'''
								elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
										__a           =			'''single_label_classification'''
								else:
										__a           =			'''multi_label_classification'''

						if self.config.problem_type == "regression":
								__a           =			MSELoss()
								if self.num_labels == 1:
										__a           =			loss_fct(logits.squeeze()							, labels.squeeze()      )
								else:
										__a           =			loss_fct(_a							, _a      )
						elif self.config.problem_type == "single_label_classification":
								__a           =			CrossEntropyLoss()
								__a           =			loss_fct(logits.view(-1							, self.num_labels      )							, labels.view(-1      )      )
						elif self.config.problem_type == "multi_label_classification":
								__a           =			BCEWithLogitsLoss()
								__a           =			loss_fct(_a							, _a      )

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

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









import warnings

from ...utils import logging
from .image_processing_flava import FlavaImageProcessor


snake_case_			  = logging.get_logger(__name__)


class       SCREAMING_SNAKE_CASE__					(__snake_case     ):





    def __init__(      self						,   *a						,   **a):
         warnings.warn(
             'The class FlavaFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'
             ' use FlavaImageProcessor instead.'						,   a						,   )
         super().__init__(*a						,   **a)

