





'''simple docstring'''






from typing import TYPE_CHECKING

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


__UpperCamelCase										=  {
    'configuration_donut_swin': ['DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DonutSwinConfig'],
    'processing_donut': ['DonutProcessor'],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __UpperCamelCase										=  [
     'DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST',
     'DonutSwinModel',
     'DonutSwinPreTrainedModel',
 ]

try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __UpperCamelCase										=  ['DonutFeatureExtractor']
 __UpperCamelCase										=  ['DonutImageProcessor']


if TYPE_CHECKING:
 from .configuration_donut_swin import DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, DonutSwinConfig
 from .processing_donut import DonutProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_donut_swin import (
      DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
      DonutSwinModel,
      DonutSwinPreTrainedModel,
  )

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_donut import DonutFeatureExtractor
  from .image_processing_donut import DonutImageProcessor

else:
 import sys

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









'''simple docstring'''






import torch
from torch import autograd




class    _A   (				autograd.Function		):

		@staticmethod
		def   lowercase__    (      __magic_name__				:      List[Any]     ,			__magic_name__				:      torch.tensor     ,			__magic_name__				:      float     ,			__magic_name__				:      bool )				->						Optional[int]:


					"""simple docstring"""

					__snake_case				:			List[Any]       			=    inputs.numel()
					__snake_case				:			List[Any]       			=    int(0.005 * nb_elems ) + 1
					if sigmoid:
								__snake_case				:			Dict       			=    (torch.sigmoid(__magic_name__ ) > threshold).type(inputs.type() )
					else:
								__snake_case				:			Tuple       			=    (inputs > threshold).type(inputs.type() )
					if mask.sum() < nb_min:
								# We limit the pruning so that at least 0.5% (half a percent) of the weights are remaining
								__snake_case				:			Tuple       			=    inputs.flatten().kthvalue(max(nb_elems - nb_min     ,			1 ) ).values
								__snake_case				:			Union[str, Any]       			=    (inputs > k_threshold).type(inputs.type() )
					return mask

		@staticmethod
		def   lowercase__    (      __magic_name__				:      int     ,			__magic_name__				:      Any )				->						Tuple:


					"""simple docstring"""

					return gradOutput, None, None





class    _A   (				autograd.Function		):

		@staticmethod
		def   lowercase__    (      __magic_name__				:      Tuple     ,			__magic_name__				:      torch.tensor     ,			__magic_name__				:      float )				->						int:


					"""simple docstring"""

					__snake_case				:			Tuple       			=    inputs.clone()
					__snake_case			,    __snake_case				:			Dict       			=    inputs.flatten().sort(descending=__magic_name__ )
					__snake_case				:			List[Any]       			=    int(threshold * inputs.numel() )

					# flat_out and mask access the same memory.
					__snake_case				:			Optional[Any]       			=    mask.flatten()
					__snake_case				:			List[str]       			=    0
					__snake_case				:			Any       			=    1
					return mask

		@staticmethod
		def   lowercase__    (      __magic_name__				:      List[str]     ,			__magic_name__				:      Any )				->						Optional[Any]:


					"""simple docstring"""

					return gradOutput, None





class    _A   (				__lowercase		):

		@staticmethod
		def   lowercase__    (      __magic_name__				:      torch.tensor     ,			__magic_name__				:      float )				->						List[str]:


					"""simple docstring"""

					__snake_case				:			List[str]       			=    inputs.clone()
					__snake_case			,    __snake_case				:			Tuple       			=    inputs.abs().flatten().sort(descending=__magic_name__ )
					__snake_case				:			Any       			=    int(threshold * inputs.numel() )

					# flat_out and mask access the same memory.
					__snake_case				:			Union[str, Any]       			=    mask.flatten()
					__snake_case				:			Tuple       			=    0
					__snake_case				:			int       			=    1
					return mask


