





"""simple docstring"""


from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


lowerCamelCase__				  =   logging.get_logger(__name__)

lowerCamelCase__				  =   {
    "shi-labs/nat-mini-in1k-224": "https://huggingface.co/shi-labs/nat-mini-in1k-224/resolve/main/config.json",
    # See all Nat models at https://huggingface.co/models?filter=nat
}



class      __SCREAMING_SNAKE_CASE    (						_UpperCamelCase		,  _UpperCamelCase   ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__							:Tuple	     =					"nat"

  SCREAMING_SNAKE_CASE__							:Tuple	     =					{
      "num_attention_heads": "num_heads",
      "num_hidden_layers": "num_layers",
  }

  def __init__(		self   :       Dict					,   __a   :       str=4					,   __a   :       Optional[int]=3					,   __a   :       Optional[int]=64					,   __a   :       Any=[3, 4, 6, 5]					,   __a   :       Optional[int]=[2, 4, 8, 16]					,   __a   :       List[Any]=7					,   __a   :       Optional[Any]=3.0					,   __a   :       Any=True					,   __a   :       int=0.0					,   __a   :       Optional[Any]=0.0					,   __a   :       Any=0.1					,   __a   :       Dict="gelu"					,   __a   :       List[str]=0.02					,   __a   :       int=1e-5					,   __a   :       int=0.0					,   __a   :       str=None					,   __a   :       List[Any]=None					,   **__a   :       Dict					,   )		->				List[str]:
        super().__init__(**__a	)

        _UpperCamelCase      :	str						=       patch_size
        _UpperCamelCase      :	Dict						=       num_channels
        _UpperCamelCase      :	List[str]						=       embed_dim
        _UpperCamelCase      :	int						=       depths
        _UpperCamelCase      :	Any						=       len(__a	)
        _UpperCamelCase      :	str						=       num_heads
        _UpperCamelCase      :	str						=       kernel_size
        _UpperCamelCase      :	Any						=       mlp_ratio
        _UpperCamelCase      :	str						=       qkv_bias
        _UpperCamelCase      :	Union[str, Any]						=       hidden_dropout_prob
        _UpperCamelCase      :	Tuple						=       attention_probs_dropout_prob
        _UpperCamelCase      :	Optional[int]						=       drop_path_rate
        _UpperCamelCase      :	Union[str, Any]						=       hidden_act
        _UpperCamelCase      :	Union[str, Any]						=       layer_norm_eps
        _UpperCamelCase      :	Tuple						=       initializer_range
        # we set the hidden_size attribute in order to make Nat work with VisionEncoderDecoderModel
        # this indicates the channel dimension after the last stage of the model
        _UpperCamelCase      :	Tuple						=       int(embed_dim * 2 ** (len(__a	) - 1)	)
        _UpperCamelCase      :	Union[str, Any]						=       layer_scale_init_value
        _UpperCamelCase      :	List[Any]						=       ["stem"] + [F'''stage{idx}''' for idx in range(1					,   len(__a	) + 1	)]
        _UpperCamelCase,  _UpperCamelCase      :	List[Any]						=       get_aligned_output_features_output_indices(
            out_features=__a					,   out_indices=__a					,   stage_names=self.stage_names	)







"""simple docstring"""


from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

lowerCamelCase__				  =   TypeVar("KEY")
lowerCamelCase__				  =   TypeVar("VAL")



@dataclass(frozen=_UpperCamelCase		,  slots=_UpperCamelCase   )
class      __SCREAMING_SNAKE_CASE    (						Generic[KEY, VAL]   ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__							:KEY
  SCREAMING_SNAKE_CASE__							:VAL





class      __SCREAMING_SNAKE_CASE    (						_Item   ):







  '''simple docstring'''


  def __init__(		self   :       List[str]	)		->				None:
        super().__init__(__a					,   __a	)


  def __bool__(		self   :       Dict	)		->				bool:
        return False





lowerCamelCase__				  =   _DeletedItem()



class      __SCREAMING_SNAKE_CASE    (						MutableMapping[KEY, VAL]   ):







  '''simple docstring'''


  def __init__(		self   :       int					,   __a   :       int = 8					,   __a   :       float = 0.75	)		->				None:
        _UpperCamelCase      :	str						=       initial_block_size
        _UpperCamelCase      :	list[_Item | None]						=       [None] * initial_block_size
        assert 0.0 < capacity_factor < 1.0
        _UpperCamelCase      :	List[str]						=       capacity_factor
        _UpperCamelCase      :	Dict						=       0

  def    __SCREAMING_SNAKE_CASE				(		self   :       int					,   __a   :       KEY	)		->				int:
        return hash(__a	) % len(self._buckets	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]					,   __a   :       int	)		->				int:
        return (ind + 1) % len(self._buckets	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Tuple					,   __a   :       int					,   __a   :       KEY					,   __a   :       VAL	)		->				bool:
        _UpperCamelCase      :	List[Any]						=       self._buckets[ind]
        if not stored:
              _UpperCamelCase      :	Tuple						=       _Item(__a					,   __a	)
              self._len += 1
              return True
        elif stored.key == key:
              _UpperCamelCase      :	Union[str, Any]						=       _Item(__a					,   __a	)
              return True
        else:
              return False

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[str]	)		->				bool:
        _UpperCamelCase      :	Any						=       len(self._buckets	) * self._capacity_factor
        return len(self	) >= int(__a	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       str	)		->				bool:
        if len(self._buckets	) <= self._initial_block_size:
              return False
        _UpperCamelCase      :	List[str]						=       len(self._buckets	) * self._capacity_factor / 2
        return len(self	) < limit

  def    __SCREAMING_SNAKE_CASE				(		self   :       Union[str, Any]					,   __a   :       int	)		->				None:
        _UpperCamelCase      :	Any						=       self._buckets
        _UpperCamelCase      :	List[Any]						=       [None] * new_size
        _UpperCamelCase      :	List[str]						=       0
        for item in old_buckets:
              if item:
                    self._add_item(item.key					,   item.val	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				None:
        self._resize(len(self._buckets	) * 2	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Union[str, Any]	)		->				None:
        self._resize(len(self._buckets	) // 2	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]					,   __a   :       KEY	)		->				Iterator[int]:
        _UpperCamelCase      :	str						=       self._get_bucket_index(__a	)
        for _ in range(len(self._buckets	)	):
              yield ind
              _UpperCamelCase      :	Tuple						=       self._get_next_ind(__a	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[int]					,   __a   :       KEY					,   __a   :       VAL	)		->				None:
        for ind in self._iterate_buckets(__a	):
              if self._try_set(__a					,   __a					,   __a	):
                    break

  def __setitem__(		self   :       int					,   __a   :       KEY					,   __a   :       VAL	)		->				None:
        if self._is_full():
              self._size_up()

        self._add_item(__a					,   __a	)

  def __delitem__(		self   :       str					,   __a   :       KEY	)		->				None:
        for ind in self._iterate_buckets(__a	):
              _UpperCamelCase      :	Tuple						=       self._buckets[ind]
              if item is None:
                    raise KeyError(__a	)
              if item is _deleted:
                    continue
              if item.key == key:
                    _UpperCamelCase      :	List[Any]						=       _deleted
                    self._len -= 1
                    break
        if self._is_sparse():
              self._size_down()

  def __getitem__(		self   :       str					,   __a   :       KEY	)		->				VAL:
        for ind in self._iterate_buckets(__a	):
              _UpperCamelCase      :	Tuple						=       self._buckets[ind]
              if item is None:
                    break
              if item is _deleted:
                    continue
              if item.key == key:
                    return item.val
        raise KeyError(__a	)

  def __len__(		self   :       List[Any]	)		->				int:
        return self._len

  def __iter__(		self   :       List[str]	)		->				Iterator[KEY]:
        yield from (item.key for item in self._buckets if item)


  def __repr__(		self   :       List[str]	)		->				str:
        _UpperCamelCase      :	Optional[int]						=       " ,".join(
            F'''{item.key}: {item.val}''' for item in self._buckets if item	)
        return F'''HashMap({val_string})'''
