




'''simple docstring'''







import inspect
from typing import Callable, List, Optional, Set, Tuple, Union

import torch
from packaging import version
from safetensors.torch import storage_ptr, storage_size
from torch import nn

from .utils import logging


_lowerCamelCase							:						Optional[int]							     =  [nn.LayerNorm]

_lowerCamelCase							:						Optional[Any]							     =  logging.get_logger(__name__)

_lowerCamelCase							:						Dict							     =  version.parse(version.parse(torch.__version__).base_version)

_lowerCamelCase							:						Optional[int]							     =  parsed_torch_version_base >= version.parse('2.0')
_lowerCamelCase							:						Optional[Any]							     =  parsed_torch_version_base >= version.parse('1.12')
_lowerCamelCase							:						Optional[int]							     =  parsed_torch_version_base >= version.parse('1.11')
_lowerCamelCase							:						Tuple							     =  parsed_torch_version_base < version.parse('1.11')






def 		_lowercase		(     lowercase_						,							lowercase_						,							lowercase_						,							lowercase_						,							self  ):



		'''simple docstring'''







		from torch import _softmax_backward_data

		if is_torch_less_than_1_11:
				return _softmax_backward_data(lowercase_						,							lowercase_						,							parent.dim						,							self  )
		else:
				return _softmax_backward_data(lowercase_						,							lowercase_						,							parent.dim						,							self.dtype  )






def 		_lowercase		(     lowercase_						,							lowercase_						,							lowercase_ = 0  ):



		'''simple docstring'''







		_snake_case     	=	index.to(layer.weight.device  )
		_snake_case     	=	layer.weight.index_select(lowercase_						,							lowercase_  ).clone().detach()
		if layer.bias is not None:
				if dim == 1:
						_snake_case     	=	layer.bias.clone().detach()
				else:
						_snake_case     	=	layer.bias[index].clone().detach()
		_snake_case     	=	list(layer.weight.size()  )
		_snake_case     	=	len(lowercase_  )
		_snake_case     	=	nn.Linear(new_size[1]						,							new_size[0]						,							bias=layer.bias is not None  ).to(layer.weight.device  )
		_snake_case     	=	False
		new_layer.weight.copy_(W.contiguous()  )
		_snake_case     	=	True
		if layer.bias is not None:
				_snake_case     	=	False
				new_layer.bias.copy_(b.contiguous()  )
				_snake_case     	=	True
		return new_layer





class 					lowerCamelCase_							(	nn.Module							):




					'''simple docstring'''






					def __init__(   self,  __UpperCamelCase,  __UpperCamelCase			):
							super().__init__()
							_snake_case     	=	nf
							_snake_case     	=	nn.Parameter(torch.empty(__UpperCamelCase,  __UpperCamelCase			)			)
							_snake_case     	=	nn.Parameter(torch.zeros(__UpperCamelCase			)			)
							nn.init.normal_(self.weight,  std=0.02			)






					def     __SCREAMING_SNAKE_CASE     (   self,  __UpperCamelCase			):
							_snake_case     	=	x.size()[:-1] + (self.nf,)
							_snake_case     	=	torch.addmm(self.bias,  x.view(-1,  x.size(-1			)			),  self.weight			)
							_snake_case     	=	x.view(__UpperCamelCase			)
							return x






def 		_lowercase		(     lowercase_						,							lowercase_						,							lowercase_ = 1  ):



		'''simple docstring'''







		_snake_case     	=	index.to(layer.weight.device  )
		_snake_case     	=	layer.weight.index_select(lowercase_						,							lowercase_  ).clone().detach()
		if dim == 0:
				_snake_case     	=	layer.bias.clone().detach()
		else:
				_snake_case     	=	layer.bias[index].clone().detach()
		_snake_case     	=	list(layer.weight.size()  )
		_snake_case     	=	len(lowercase_  )
		_snake_case     	=	ConvaD(new_size[1]						,							new_size[0]  ).to(layer.weight.device  )
		_snake_case     	=	False
		new_layer.weight.copy_(W.contiguous()  )
		_snake_case     	=	True
		_snake_case     	=	False
		new_layer.bias.copy_(b.contiguous()  )
		_snake_case     	=	True
		return new_layer






def 		_lowercase		(     lowercase_						,							lowercase_						,							lowercase_ = None  ):



		'''simple docstring'''







		if isinstance(lowercase_						,							nn.Linear  ):
				return prune_linear_layer(lowercase_						,							lowercase_						,							dim=0 if dim is None else dim  )
		elif isinstance(lowercase_						,							lowercase_  ):
				return prune_convad_layer(lowercase_						,							lowercase_						,							dim=1 if dim is None else dim  )
		else:
				raise ValueError(f'''Can\'t prune layer of class {layer.__class__}'''  )






def 		_lowercase		(     lowercase_						,							lowercase_						,							lowercase_						,							*lowercase_  ):



		'''simple docstring'''







		assert len(lowercase_  ) > 0, f'''{input_tensors} has to be a tuple/list of tensors'''

		# inspect.signature exist since python 3.5 and is a python method -> no problem with backward compatibility
		_snake_case     	=	len(inspect.signature(lowercase_  ).parameters  )
		if num_args_in_forward_chunk_fn != len(lowercase_  ):
				raise ValueError(
				    f'''forward_chunk_fn expects {num_args_in_forward_chunk_fn} arguments, but only {len(lowercase_  )} input '''
				    "tensors are given"  )

		if chunk_size > 0:
				_snake_case     	=	input_tensors[0].shape[chunk_dim]
				for input_tensor in input_tensors:
						if input_tensor.shape[chunk_dim] != tensor_shape:
								raise ValueError(
								    f'''All input tenors have to be of the same shape: {tensor_shape}, '''
								    f'''found shape {input_tensor.shape[chunk_dim]}'''  )

				if input_tensors[0].shape[chunk_dim] % chunk_size != 0:
						raise ValueError(
						    f'''The dimension to be chunked {input_tensors[0].shape[chunk_dim]} has to be a multiple of the chunk '''
						    f'''size {chunk_size}'''  )

				_snake_case     	=	input_tensors[0].shape[chunk_dim] // chunk_size

				# chunk input tensor into tuples
				_snake_case     	=	tuple(input_tensor.chunk(lowercase_						,							dim=lowercase_  ) for input_tensor in input_tensors  )
				# apply forward fn to every tuple
				_snake_case     	=	tuple(forward_fn(*lowercase_  ) for input_tensors_chunk in zip(*lowercase_  )  )
				# concatenate output at same dimension
				return torch.cat(lowercase_						,							dim=lowercase_  )

		return forward_fn(*lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_						,							lowercase_						,							lowercase_  ):



		'''simple docstring'''







		_snake_case     	=	torch.ones(lowercase_						,							lowercase_  )
		_snake_case     	=	set(lowercase_  ) - already_pruned_heads  # Convert to set and remove already pruned heads
		for head in heads:
				# Compute how many pruned heads are before the head and move the index accordingly
				_snake_case     	=	head - sum(1 if h < head else 0 for h in already_pruned_heads  )
				_snake_case     	=	0
		_snake_case     	=	mask.view(-1  ).contiguous().eq(1  )
		_snake_case     	=	torch.arange(len(lowercase_  )  )[mask].long()
		return heads, index






def 		_lowercase		(     *lowercase_						,							lowercase_ = None  ):



		'''simple docstring'''







		return torch.meshgrid(*lowercase_						,							indexing=lowercase_  )






def 		_lowercase		(     lowercase_  ):



		'''simple docstring'''







		return tensor.device, storage_ptr(lowercase_  ), storage_size(lowercase_  )











'''simple docstring'''







from typing import TYPE_CHECKING

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


_lowerCamelCase							:						List[Any]							     =  {
    'configuration_mobilenet_v1': [
        'MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'MobileNetV1Config',
        'MobileNetV1OnnxConfig',
    ],
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCamelCase							:						str							     =  ['MobileNetV1FeatureExtractor']
						_lowerCamelCase							:						Tuple							     =  ['MobileNetV1ImageProcessor']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCamelCase							:						List[Any]							     =  [
						    '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

						_lowerCamelCase							:						Union[str, Any]							     =  _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





