


import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import ConvNextImageProcessor

class 						UpperCAmelCase__   (      unittest.TestCase		):



     '''simple docstring'''
     def __init__( self       :       Tuple	,      UpperCamelCase       :       str	,      UpperCamelCase       :       Dict=7	,      UpperCamelCase       :       List[Any]=3	,      UpperCamelCase       :       Any=18	,      UpperCamelCase       :       List[str]=30	,      UpperCamelCase       :       Dict=4_00	,      UpperCamelCase       :       Optional[int]=True	,      UpperCamelCase       :       Tuple=None	,      UpperCamelCase       :       Any=0.875	,      UpperCamelCase       :       Union[str, Any]=True	,      UpperCamelCase       :       Union[str, Any]=[0.5, 0.5, 0.5]	,      UpperCamelCase       :       Any=[0.5, 0.5, 0.5]	,      ):





            """simple docstring"""



            _lowercase					:				Union[str, Any]           =			size if size is not None else {'''shortest_edge''': 20}
            _lowercase					:				str           =			parent
            _lowercase					:				Dict           =			batch_size
            _lowercase					:				Union[str, Any]           =			num_channels
            _lowercase					:				int           =			image_size
            _lowercase					:				Optional[int]           =			min_resolution
            _lowercase					:				Tuple           =			max_resolution
            _lowercase					:				List[str]           =			do_resize
            _lowercase					:				Optional[int]           =			size
            _lowercase					:				Any           =			crop_pct
            _lowercase					:				Tuple           =			do_normalize
            _lowercase					:				Union[str, Any]           =			image_mean
            _lowercase					:				Optional[int]           =			image_std


     def   lowerCAmelCase_   ( self       :       Optional[Any]		):





            """simple docstring"""



            return {
                "image_mean": self.image_mean,
                "image_std": self.image_std,
                "do_normalize": self.do_normalize,
                "do_resize": self.do_resize,
                "size": self.size,
                "crop_pct": self.crop_pct,
            }




@require_torch
@require_vision
class 						UpperCAmelCase__   (      A_      ,						unittest.TestCase		):



     '''simple docstring'''
     UpperCAmelCase_         =  ConvNextImageProcessor if is_vision_available() else None
     def   lowerCAmelCase_   ( self       :       Tuple		):





            """simple docstring"""



            _lowercase					:				Optional[int]           =			ConvNextImageProcessingTester(self		)
     @property
     def   lowerCAmelCase_   ( self       :       Optional[Any]		):





            """simple docstring"""



            return self.image_processor_tester.prepare_image_processor_dict()
     def   lowerCAmelCase_   ( self       :       Tuple		):





            """simple docstring"""



            _lowercase					:				int           =			self.image_processing_class(**self.image_processor_dict		)
            self.assertTrue(hasattr(UpperCamelCase	,      '''do_resize'''		)		)
            self.assertTrue(hasattr(UpperCamelCase	,      '''size'''		)		)
            self.assertTrue(hasattr(UpperCamelCase	,      '''crop_pct'''		)		)
            self.assertTrue(hasattr(UpperCamelCase	,      '''do_normalize'''		)		)
            self.assertTrue(hasattr(UpperCamelCase	,      '''image_mean'''		)		)
            self.assertTrue(hasattr(UpperCamelCase	,      '''image_std'''		)		)
     def   lowerCAmelCase_   ( self       :       str		):





            """simple docstring"""



            _lowercase					:				Optional[Any]           =			self.image_processing_class.from_dict(self.image_processor_dict		)
            self.assertEqual(image_processor.size	,      {'''shortest_edge''': 20}		)

            _lowercase					:				List[Any]           =			self.image_processing_class.from_dict(self.image_processor_dict	,      size=42		)
            self.assertEqual(image_processor.size	,      {'''shortest_edge''': 42}		)
     def   lowerCAmelCase_   ( self       :       str		):





            """simple docstring"""



            pass
     def   lowerCAmelCase_   ( self       :       Optional[int]		):





            """simple docstring"""



            _lowercase					:				Optional[Any]           =			self.image_processing_class(**self.image_processor_dict		)
            # create random PIL images
            _lowercase					:				Union[str, Any]           =			prepare_image_inputs(self.image_processor_tester	,      equal_resolution=UpperCamelCase		)
            for image in image_inputs:
                   self.assertIsInstance(UpperCamelCase	,      Image.Image		)

            # Test not batched input
            _lowercase					:				Any           =			image_processing(image_inputs[0]	,      return_tensors='''pt'''		).pixel_values
            self.assertEqual(
                encoded_images.shape	,      (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''shortest_edge'''],
                    self.image_processor_tester.size['''shortest_edge'''],
                )	,      )

            # Test batched
            _lowercase					:				Union[str, Any]           =			image_processing(UpperCamelCase	,      return_tensors='''pt'''		).pixel_values
            self.assertEqual(
                encoded_images.shape	,      (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''shortest_edge'''],
                    self.image_processor_tester.size['''shortest_edge'''],
                )	,      )
     def   lowerCAmelCase_   ( self       :       str		):





            """simple docstring"""



            _lowercase					:				Optional[int]           =			self.image_processing_class(**self.image_processor_dict		)
            # create random numpy tensors
            _lowercase					:				Any           =			prepare_image_inputs(self.image_processor_tester	,      equal_resolution=UpperCamelCase	,      numpify=UpperCamelCase		)
            for image in image_inputs:
                   self.assertIsInstance(UpperCamelCase	,      np.ndarray		)

            # Test not batched input
            _lowercase					:				Tuple           =			image_processing(image_inputs[0]	,      return_tensors='''pt'''		).pixel_values
            self.assertEqual(
                encoded_images.shape	,      (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''shortest_edge'''],
                    self.image_processor_tester.size['''shortest_edge'''],
                )	,      )

            # Test batched
            _lowercase					:				Optional[Any]           =			image_processing(UpperCamelCase	,      return_tensors='''pt'''		).pixel_values
            self.assertEqual(
                encoded_images.shape	,      (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''shortest_edge'''],
                    self.image_processor_tester.size['''shortest_edge'''],
                )	,      )


     def   lowerCAmelCase_   ( self       :       Tuple		):





            """simple docstring"""



            _lowercase					:				Dict           =			self.image_processing_class(**self.image_processor_dict		)
            # create random PyTorch tensors
            _lowercase					:				Tuple           =			prepare_image_inputs(self.image_processor_tester	,      equal_resolution=UpperCamelCase	,      torchify=UpperCamelCase		)
            for image in image_inputs:
                   self.assertIsInstance(UpperCamelCase	,      torch.Tensor		)

            # Test not batched input
            _lowercase					:				Optional[int]           =			image_processing(image_inputs[0]	,      return_tensors='''pt'''		).pixel_values
            self.assertEqual(
                encoded_images.shape	,      (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''shortest_edge'''],
                    self.image_processor_tester.size['''shortest_edge'''],
                )	,      )

            # Test batched
            _lowercase					:				Union[str, Any]           =			image_processing(UpperCamelCase	,      return_tensors='''pt'''		).pixel_values
            self.assertEqual(
                encoded_images.shape	,      (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''shortest_edge'''],
                    self.image_processor_tester.size['''shortest_edge'''],
                )	,      )



import copy

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


UpperCamelCase__				       =			logging.get_logger(__name__)

UpperCamelCase__				       =			{
    '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 						UpperCAmelCase__   (      A_		):



     '''simple docstring'''




     def __init__( self       :       List[Any]	,      UpperCamelCase       :       Optional[Any]=2_56	,      UpperCamelCase       :       str=10_24	,      UpperCamelCase       :       Any=16	,      UpperCamelCase       :       Optional[Any]=16	,      UpperCamelCase       :       Union[str, Any]=4	,      UpperCamelCase       :       str="gelu"	,      UpperCamelCase       :       Dict=1E-6	,      **UpperCamelCase       :       Tuple	,      ):





            """simple docstring"""



            super().__init__(**UpperCamelCase		)
            _lowercase					:				Union[str, Any]           =			hidden_size
            _lowercase					:				Optional[Any]           =			image_size
            _lowercase					:				Tuple           =			patch_size
            _lowercase					:				List[str]           =			image_size // patch_size
            _lowercase					:				Optional[Any]           =			mask_input_channels
            _lowercase					:				str           =			num_point_embeddings
            _lowercase					:				List[Any]           =			hidden_act
            _lowercase					:				Union[str, Any]           =			layer_norm_eps




class 						UpperCAmelCase__   (      A_		):



     '''simple docstring'''




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





            """simple docstring"""



            super().__init__(**UpperCamelCase		)
            _lowercase					:				List[Any]           =			hidden_size
            _lowercase					:				Optional[int]           =			hidden_act
            _lowercase					:				Union[str, Any]           =			mlp_dim
            _lowercase					:				Optional[int]           =			num_hidden_layers
            _lowercase					:				List[str]           =			num_attention_heads
            _lowercase					:				Dict           =			attention_downsample_rate
            _lowercase					:				Optional[Any]           =			num_multimask_outputs
            _lowercase					:				Optional[Any]           =			iou_head_depth
            _lowercase					:				Dict           =			iou_head_hidden_dim
            _lowercase					:				List[str]           =			layer_norm_eps




class 						UpperCAmelCase__   (      A_		):



     '''simple docstring'''




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





            """simple docstring"""



            super().__init__(**UpperCamelCase		)

            _lowercase					:				Union[str, Any]           =			hidden_size
            _lowercase					:				Optional[int]           =			output_channels
            _lowercase					:				Dict           =			num_hidden_layers
            _lowercase					:				str           =			num_attention_heads
            _lowercase					:				Dict           =			num_channels
            _lowercase					:				List[Any]           =			image_size
            _lowercase					:				int           =			patch_size
            _lowercase					:				Optional[Any]           =			hidden_act
            _lowercase					:				Any           =			layer_norm_eps
            _lowercase					:				Any           =			attention_dropout
            _lowercase					:				Optional[int]           =			initializer_range
            _lowercase					:				List[str]           =			qkv_bias
            _lowercase					:				Optional[Any]           =			mlp_ratio
            _lowercase					:				Optional[Any]           =			use_abs_pos
            _lowercase					:				List[Any]           =			use_rel_pos
            _lowercase					:				str           =			window_size
            _lowercase					:				Tuple           =			global_attn_indexes
            _lowercase					:				List[Any]           =			num_pos_feats
            _lowercase					:				int           =			int(hidden_size * mlp_ratio		) if mlp_dim is None else mlp_dim




class 						UpperCAmelCase__   (      A_		):



     '''simple docstring'''
     UpperCAmelCase_         =  '''sam'''
     UpperCAmelCase_         =  True




     def __init__( self       :       Tuple	,      UpperCamelCase       :       Tuple=None	,      UpperCamelCase       :       Any=None	,      UpperCamelCase       :       Tuple=None	,      UpperCamelCase       :       Dict=0.02	,      **UpperCamelCase       :       Union[str, Any]	,      ):





            """simple docstring"""



            super().__init__(**UpperCamelCase		)
            _lowercase					:				Optional[int]           =			vision_config if vision_config is not None else {}
            _lowercase					:				Any           =			prompt_encoder_config if prompt_encoder_config is not None else {}
            _lowercase					:				Optional[Any]           =			mask_decoder_config if mask_decoder_config is not None else {}

            if isinstance(UpperCamelCase	,      UpperCamelCase		):
                   _lowercase					:				Dict           =			vision_config.to_dict()
            if isinstance(UpperCamelCase	,      UpperCamelCase		):
                   _lowercase					:				List[str]           =			prompt_encoder_config.to_dict()
            if isinstance(UpperCamelCase	,      UpperCamelCase		):
                   _lowercase					:				Optional[int]           =			mask_decoder_config.to_dict()

            _lowercase					:				Union[str, Any]           =			SamVisionConfig(**UpperCamelCase		)
            _lowercase					:				Optional[Any]           =			SamPromptEncoderConfig(**UpperCamelCase		)
            _lowercase					:				List[Any]           =			SamMaskDecoderConfig(**UpperCamelCase		)
            _lowercase					:				Union[str, Any]           =			initializer_range




     def   lowerCAmelCase_   ( self       :       Union[str, Any]		):





            """simple docstring"""



            _lowercase					:				List[Any]           =			copy.deepcopy(self.__dict__		)
            _lowercase					:				int           =			self.vision_config.to_dict()
            _lowercase					:				Optional[int]           =			self.prompt_encoder_config.to_dict()
            _lowercase					:				List[Any]           =			self.mask_decoder_config.to_dict()
            _lowercase					:				List[Any]           =			self.__class__.model_type
            return output