






"""simple docstring"""


import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase_								=	logging.get_logger(__name__)

lowercase_								=	{
    'facebook/sam-vit-huge': 'https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json',
    'facebook/sam-vit-large': 'https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json',
    'facebook/sam-vit-base': 'https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json',
}


class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   def __init__(      self					:	int,			_lowerCamelCase					:	Any=2_56,			_lowerCamelCase					:	str=10_24,			_lowerCamelCase					:	Any=16,			_lowerCamelCase					:	Any=16,			_lowerCamelCase					:	Tuple=4,			_lowerCamelCase					:	str="gelu",			_lowerCamelCase					:	int=1e-6,			**_lowerCamelCase					:	Tuple,			):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					hidden_size
     __A		     =					image_size
     __A		     =					patch_size
     __A		     =					image_size // patch_size
     __A		     =					mask_input_channels
     __A		     =					num_point_embeddings
     __A		     =					hidden_act
     __A		     =					layer_norm_eps





class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   def __init__(      self					:	int,			_lowerCamelCase					:	str=2_56,			_lowerCamelCase					:	Tuple="relu",			_lowerCamelCase					:	Optional[Any]=20_48,			_lowerCamelCase					:	int=2,			_lowerCamelCase					:	List[Any]=8,			_lowerCamelCase					:	List[Any]=2,			_lowerCamelCase					:	str=3,			_lowerCamelCase					:	Dict=3,			_lowerCamelCase					:	List[str]=2_56,			_lowerCamelCase					:	str=1e-6,			**_lowerCamelCase					:	Union[str, Any],			):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					hidden_size
     __A		     =					hidden_act
     __A		     =					mlp_dim
     __A		     =					num_hidden_layers
     __A		     =					num_attention_heads
     __A		     =					attention_downsample_rate
     __A		     =					num_multimask_outputs
     __A		     =					iou_head_depth
     __A		     =					iou_head_hidden_dim
     __A		     =					layer_norm_eps





class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   def __init__(      self					:	int,			_lowerCamelCase					:	Union[str, Any]=7_68,			_lowerCamelCase					:	List[Any]=2_56,			_lowerCamelCase					:	Optional[int]=12,			_lowerCamelCase					:	Tuple=12,			_lowerCamelCase					:	Optional[Any]=3,			_lowerCamelCase					:	Any=10_24,			_lowerCamelCase					:	Dict=16,			_lowerCamelCase					:	List[str]="gelu",			_lowerCamelCase					:	Optional[int]=1e-06,			_lowerCamelCase					:	Optional[Any]=0.0,			_lowerCamelCase					:	Any=1e-10,			_lowerCamelCase					:	Tuple=True,			_lowerCamelCase					:	int=4.0,			_lowerCamelCase					:	str=True,			_lowerCamelCase					:	List[Any]=True,			_lowerCamelCase					:	List[str]=14,			_lowerCamelCase					:	Optional[int]=[2, 5, 8, 11],			_lowerCamelCase					:	List[str]=1_28,			_lowerCamelCase					:	Union[str, Any]=None,			**_lowerCamelCase					:	int,			):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )

     __A		     =					hidden_size
     __A		     =					output_channels
     __A		     =					num_hidden_layers
     __A		     =					num_attention_heads
     __A		     =					num_channels
     __A		     =					image_size
     __A		     =					patch_size
     __A		     =					hidden_act
     __A		     =					layer_norm_eps
     __A		     =					attention_dropout
     __A		     =					initializer_range
     __A		     =					qkv_bias
     __A		     =					mlp_ratio
     __A		     =					use_abs_pos
     __A		     =					use_rel_pos
     __A		     =					window_size
     __A		     =					global_attn_indexes
     __A		     =					num_pos_feats
     __A		     =					int(hidden_size * mlp_ratio    ) if mlp_dim is None else mlp_dim





class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   A_		:      Any							=					"sam"
   A_		:      Optional[Any]							=					True


   def __init__(      self					:	Tuple,			_lowerCamelCase					:	Optional[int]=None,			_lowerCamelCase					:	Dict=None,			_lowerCamelCase					:	int=None,			_lowerCamelCase					:	str=0.02,			**_lowerCamelCase					:	List[str],			):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					vision_config if vision_config is not None else {}
     __A		     =					prompt_encoder_config if prompt_encoder_config is not None else {}
     __A		     =					mask_decoder_config if mask_decoder_config is not None else {}

     if isinstance(_lowerCamelCase,			_lowerCamelCase    ):
       __A		     =					vision_config.to_dict()
     if isinstance(_lowerCamelCase,			_lowerCamelCase    ):
       __A		     =					prompt_encoder_config.to_dict()
     if isinstance(_lowerCamelCase,			_lowerCamelCase    ):
       __A		     =					mask_decoder_config.to_dict()

     __A		     =					SamVisionConfig(**_lowerCamelCase    )
     __A		     =					SamPromptEncoderConfig(**_lowerCamelCase    )
     __A		     =					SamMaskDecoderConfig(**_lowerCamelCase    )
     __A		     =					initializer_range






   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[int]    ):

     '''simple docstring'''
     __A		     =					copy.deepcopy(self.__dict__    )
     __A		     =					self.vision_config.to_dict()
     __A		     =					self.prompt_encoder_config.to_dict()
     __A		     =					self.mask_decoder_config.to_dict()
     __A		     =					self.__class__.model_type
     return output












"""simple docstring"""


import os
import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device


if is_torch_available():
       import torch

       from transformers import GPTaLMHeadModel


@require_torch
@require_sentencepiece
@require_tokenizers
class    snake_case						(				unittest.TestCase		):


   '''simple docstring'''

   @slow
   @unittest.skip('''Model is not available.'''    )
   def 							_SCREAMING_SNAKE_CASE							(      self					:	int    ):

     '''simple docstring'''
     __A		     =					'''nvidia/megatron-gpt2-345m/'''
     if "MYDIR" in os.environ:
       __A		     =					os.path.join(os.environ['''MYDIR'''],			_lowerCamelCase    )
     __A		     =					GPTaLMHeadModel.from_pretrained(_lowerCamelCase    )
     model.to(_lowerCamelCase    )
     model.half()

     __A		     =					torch.tensor(
         [[1_01, 71_10, 10_05, 10_56, 20_23, 1_13_33, 1_74_13, 10_29, 1_02]],			device=_lowerCamelCase,			dtype=torch.long,			)

     with torch.no_grad():
       __A		     =					model(_lowerCamelCase    ).logits

     __A		     =					torch.Size((1, 9, 5_02_57)    )
     self.assertEqual(output.shape,			_lowerCamelCase    )

     __A		     =					torch.tensor(
         [
             4.94_14,
             -0.29_20,
             -1.21_48,
             -4.02_73,
             -0.51_61,
             -5.21_09,
             -1.24_12,
             -1.83_01,
             -1.77_34,
             -4.71_48,
             -0.23_17,
             -1.08_11,
             -2.17_77,
             0.41_41,
             -3.79_69,
             -4.05_86,
             -2.53_32,
             -3.38_09,
             4.38_67,
         ],			device=_lowerCamelCase,			dtype=torch.half,			)

     for i in range(19    ):
       __A     ,       __A		     =					8 * i // 17, 27_92 * i  # along the diagonal
       __A     ,       __A		     =					output[0, r, c], expected_diag[i]
       __A		     =					f'row={r} col={c} computed={computed} expected={expected}'
       self.assertAlmostEqual(_lowerCamelCase,			_lowerCamelCase,			delta=1e-4,			msg=_lowerCamelCase    )




