"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


SCREAMING_SNAKE_CASE__      						=  logging.get_logger(__name__)

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



class   lowerCAmelCase_    (			lowerCAmelCase     ,    lowerCAmelCase					):



				"""simple docstring"""
				_lowerCAmelCase     :    Tuple			  =						"""dinat"""

				_lowerCAmelCase     :    int			  =						{
				    """num_attention_heads""": """num_heads""",
				    """num_hidden_layers""": """num_layers""",
				}

				def __init__(				self		,    lowerCAmelCase=4		,    lowerCAmelCase=3		,    lowerCAmelCase=64		,    lowerCAmelCase=[3, 4, 6, 5]		,    lowerCAmelCase=[2, 4, 8, 16]		,    lowerCAmelCase=7		,    lowerCAmelCase=[[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]]		,    lowerCAmelCase=3.0		,    lowerCAmelCase=True		,    lowerCAmelCase=0.0		,    lowerCAmelCase=0.0		,    lowerCAmelCase=0.1		,    lowerCAmelCase="gelu"		,    lowerCAmelCase=0.02		,    lowerCAmelCase=1E-5		,    lowerCAmelCase=0.0		,    lowerCAmelCase=None		,    lowerCAmelCase=None		,    **lowerCAmelCase		,    ):






										"""simple docstring"""

										super().__init__(**lowerCAmelCase    )

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



"""simple docstring"""
import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)



class   lowerCAmelCase_    (			unittest.TestCase					):



				"""simple docstring"""

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			['a', 'b', 'c']

										# Defaults to last layer if both are None
										snake_case					,snake_case								=			get_aligned_output_features_output_indices(lowerCAmelCase		,    lowerCAmelCase		,    lowerCAmelCase    )
										self.assertEqual(lowerCAmelCase		,    ['c']    )
										self.assertEqual(lowerCAmelCase		,    [2]    )

										# Out indices set to match out features
										snake_case					,snake_case								=			get_aligned_output_features_output_indices(['a', 'c']		,    lowerCAmelCase		,    lowerCAmelCase    )
										self.assertEqual(lowerCAmelCase		,    ['a', 'c']    )
										self.assertEqual(lowerCAmelCase		,    [0, 2]    )

										# Out features set to match out indices
										snake_case					,snake_case								=			get_aligned_output_features_output_indices(lowerCAmelCase		,    [0, 2]		,    lowerCAmelCase    )
										self.assertEqual(lowerCAmelCase		,    ['a', 'c']    )
										self.assertEqual(lowerCAmelCase		,    [0, 2]    )

										# Out features selected from negative indices
										snake_case					,snake_case								=			get_aligned_output_features_output_indices(lowerCAmelCase		,    [-3, -1]		,    lowerCAmelCase    )
										self.assertEqual(lowerCAmelCase		,    ['a', 'c']    )
										self.assertEqual(lowerCAmelCase		,    [-3, -1]    )

				def 		snake_case (				self    ):






										"""simple docstring"""

										with self.assertRaises(lowerCAmelCase    ):
																verify_out_features_out_indices(['a', 'b']		,    (0, 1)		,    lowerCAmelCase    )

										# Out features must be a list
										with self.assertRaises(lowerCAmelCase    ):
																verify_out_features_out_indices(('a', 'b')		,    (0, 1)		,    ['a', 'b']    )

										# Out features must be a subset of stage names
										with self.assertRaises(lowerCAmelCase    ):
																verify_out_features_out_indices(['a', 'b']		,    (0, 1)		,    ['a']    )

										# Out indices must be a list or tuple
										with self.assertRaises(lowerCAmelCase    ):
																verify_out_features_out_indices(lowerCAmelCase		,    0		,    ['a', 'b']    )

										# Out indices must be a subset of stage names
										with self.assertRaises(lowerCAmelCase    ):
																verify_out_features_out_indices(lowerCAmelCase		,    (0, 1)		,    ['a']    )

										# Out features and out indices must be the same length
										with self.assertRaises(lowerCAmelCase    ):
																verify_out_features_out_indices(['a', 'b']		,    (0,)		,    ['a', 'b', 'c']    )

										# Out features should match out indices
										with self.assertRaises(lowerCAmelCase    ):
																verify_out_features_out_indices(['a', 'b']		,    (0, 2)		,    ['a', 'b', 'c']    )

										# Out features and out indices should be in order
										with self.assertRaises(lowerCAmelCase    ):
																verify_out_features_out_indices(['b', 'a']		,    (0, 1)		,    ['a', 'b']    )

										# Check passes with valid inputs
										verify_out_features_out_indices(['a', 'b', 'd']		,    (0, 1, -1)		,    ['a', 'b', 'c', 'd']    )

				def 		snake_case (				self    ):






										"""simple docstring"""

										snake_case								=			BackboneMixin()

										snake_case								=			['a', 'b', 'c']
										snake_case								=			['a', 'c']
										snake_case								=			[0, 2]

										# Check that the output features and indices are set correctly
										self.assertEqual(backbone.out_features		,    ['a', 'c']    )
										self.assertEqual(backbone.out_indices		,    [0, 2]    )

										# Check out features and indices are updated correctly
										snake_case								=			['a', 'b']
										self.assertEqual(backbone.out_features		,    ['a', 'b']    )
										self.assertEqual(backbone.out_indices		,    [0, 1]    )

										snake_case								=			[-3, -1]
										self.assertEqual(backbone.out_features		,    ['a', 'c']    )
										self.assertEqual(backbone.out_indices		,    [-3, -1]    )


