


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


snake_case__		:  str     					=					[nn.LayerNorm]

snake_case__		:  Dict     					=					logging.get_logger(__name__)

snake_case__		:  Any     					=					version.parse(version.parse(torch.__version__).base_version)

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


def   _snake_case    (    _snake_case					:      List[Any]			, _snake_case					:      List[str]			, _snake_case					:      Any			, _snake_case					:      Dict			, self					:      int      ):
      from torch import _softmax_backward_data

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


def   _snake_case    (    _snake_case					:      Any			, _snake_case					:      Any			, _snake_case					:      Union[str, Any] = 0      ):
      lowerCAmelCase       :						Dict							= index.to(layer.weight.device      )
      lowerCAmelCase       :						Dict							= layer.weight.index_select(_snake_case			, _snake_case      ).clone().detach()
      if layer.bias is not None:
            if dim == 1:
                  lowerCAmelCase       :						List[str]							= layer.bias.clone().detach()
            else:
                  lowerCAmelCase       :						List[Any]							= layer.bias[index].clone().detach()
      lowerCAmelCase       :						List[str]							= list(layer.weight.size()      )
      lowerCAmelCase       :						Union[str, Any]							= len(_snake_case      )
      lowerCAmelCase       :						str							= nn.Linear(new_size[1]			, new_size[0]			, bias=layer.bias is not None      ).to(layer.weight.device      )
      lowerCAmelCase       :						Optional[int]							= False
      new_layer.weight.copy_(W.contiguous()      )
      lowerCAmelCase       :						Tuple							= True
      if layer.bias is not None:
            lowerCAmelCase       :						Tuple							= False
            new_layer.bias.copy_(b.contiguous()      )
            lowerCAmelCase       :						Union[str, Any]							= True
      return new_layer



class 		snake_case_(							nn.Module      ):






     def __init__(						self	:       Dict       ,					UpperCamelCase_	:       Any       ,					UpperCamelCase_	:       int					):
           super().__init__()
           lowerCAmelCase       :						List[str]							= nf
           lowerCAmelCase       :						Any							= nn.Parameter(torch.empty(__lowercase       ,					__lowercase					)					)
           lowerCAmelCase       :						List[Any]							= nn.Parameter(torch.zeros(__lowercase					)					)
           nn.init.normal_(self.weight       ,					std=0.02					)






     def   lowerCamelCase__  (						self	:       Optional[Any]       ,					UpperCamelCase_	:       List[Any]					):
           lowerCAmelCase       :						int							= x.size()[:-1] + (self.nf,)
           lowerCAmelCase       :						Optional[Any]							= torch.addmm(self.bias       ,					x.view(-1       ,					x.size(-1					)					)       ,					self.weight					)
           lowerCAmelCase       :						int							= x.view(__lowercase					)
           return x



def   _snake_case    (    _snake_case					:      int			, _snake_case					:      int			, _snake_case					:      Union[str, Any] = 1      ):
      lowerCAmelCase       :						Dict							= index.to(layer.weight.device      )
      lowerCAmelCase       :						Dict							= layer.weight.index_select(_snake_case			, _snake_case      ).clone().detach()
      if dim == 0:
            lowerCAmelCase       :						Tuple							= layer.bias.clone().detach()
      else:
            lowerCAmelCase       :						List[str]							= layer.bias[index].clone().detach()
      lowerCAmelCase       :						List[Any]							= list(layer.weight.size()      )
      lowerCAmelCase       :						Dict							= len(_snake_case      )
      lowerCAmelCase       :						Optional[Any]							= ConvaD(new_size[1]			, new_size[0]      ).to(layer.weight.device      )
      lowerCAmelCase       :						Dict							= False
      new_layer.weight.copy_(W.contiguous()      )
      lowerCAmelCase       :						List[str]							= True
      lowerCAmelCase       :						List[str]							= False
      new_layer.bias.copy_(b.contiguous()      )
      lowerCAmelCase       :						Tuple							= True
      return new_layer


def   _snake_case    (    _snake_case					:      Optional[Any]			, _snake_case					:      Dict			, _snake_case					:      str = None      ):


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


def   _snake_case    (    _snake_case					:      Optional[Any]			, _snake_case					:      Optional[int]			, _snake_case					:      List[Any]			, *_snake_case					:      Any      ):
      assert len(_snake_case      ) > 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
      lowerCAmelCase       :						str							= len(inspect.signature(_snake_case      ).parameters      )
      if num_args_in_forward_chunk_fn != len(_snake_case      ):
            raise ValueError(
                f'''forward_chunk_fn expects {num_args_in_forward_chunk_fn} arguments, but only {len(_snake_case      )} input '''
                '''tensors are given'''      )

      if chunk_size > 0:
            lowerCAmelCase       :						List[Any]							= 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}'''      )

            lowerCAmelCase       :						str							= input_tensors[0].shape[chunk_dim] // chunk_size

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

      return forward_fn(*_snake_case      )


def   _snake_case    (    _snake_case					:      str			, _snake_case					:      Dict			, _snake_case					:      List[Any]			, _snake_case					:      Optional[Any]      ):
      lowerCAmelCase       :						List[str]							= torch.ones(_snake_case			, _snake_case      )
      lowerCAmelCase       :						List[Any]							= set(_snake_case      ) - 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
            lowerCAmelCase       :						Tuple							= head - sum(1 if h < head else 0 for h in already_pruned_heads      )
            lowerCAmelCase       :						Optional[Any]							= 0
      lowerCAmelCase       :						Union[str, Any]							= mask.view(-1      ).contiguous().eq(1      )
      lowerCAmelCase       :						torch.LongTensor							= torch.arange(len(_snake_case      )      )[mask].long()
      return heads, index


def   _snake_case    (    *_snake_case					:      Optional[int]			, _snake_case					:      Optional[int] = None      ):
      return torch.meshgrid(*_snake_case			, indexing=_snake_case      )






def   _snake_case    (    _snake_case					:      Tuple      ):
      return tensor.device, storage_ptr(_snake_case      ), storage_size(_snake_case      )








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


UpperCamelCase__						=		{
    'configuration_sam': [
        'SAM_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'SamConfig',
        'SamMaskDecoderConfig',
        'SamPromptEncoderConfig',
        'SamVisionConfig',
    ],
    'processing_sam': ['SamProcessor'],
}


try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase__						=		[
							    'SAM_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'SamModel',
							    'SamPreTrainedModel',
							]
try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase__						=		[
							    'TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'TFSamModel',
							    'TFSamPreTrainedModel',
							]
try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase__						=		['SamImageProcessor']


if TYPE_CHECKING:
							from .configuration_sam import (
							    SAM_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    SamConfig,
							    SamMaskDecoderConfig,
							    SamPromptEncoderConfig,
							    SamVisionConfig,
							)
							from .processing_sam import SamProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_sam import SAM_PRETRAINED_MODEL_ARCHIVE_LIST, SamModel, SamPreTrainedModel

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_sam import TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST, TFSamModel, TFSamPreTrainedModel

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .image_processing_sam import SamImageProcessor

else:
							import sys

							UpperCamelCase__						=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
