code: 
  
  
  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'''],
                  )	,      )
style_context: 
  
  
  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