code: import torch
  
  from diffusers import DDIMScheduler
  
  from .test_schedulers import SchedulerCommonTest
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							_a    ):
      UpperCAmelCase_			:       List[str]						 =							(DDIMScheduler,)
      UpperCAmelCase_			:       Union[str, Any]						 =							(('eta', 0.0), ('num_inference_steps', 50))
  
  
  
  
      def 						__lowerCamelCase (					self  :   Dict      ,      **lowerCAmelCase  :   Optional[int]   )	-> Optional[int]:
        a__     		=     {
            "num_train_timesteps": 1000,
            "beta_start": 0.0_001,
            "beta_end": 0.02,
            "beta_schedule": "linear",
            "clip_sample": True,
        }
  
        config.update(**lowerCAmelCase   )
        return config
  
  
  
  
      def 						__lowerCamelCase (					self  :   Tuple      ,      **lowerCAmelCase  :   List[str]   )	-> List[str]:
        a__     		=     self.scheduler_classes[0]
        a__     		=     self.get_scheduler_config(**lowerCAmelCase   )
        a__     		=     scheduler_class(**lowerCAmelCase   )
  
        a__		,a__     		=     10, 0.0
  
        a__     		=     self.dummy_model()
        a__     		=     self.dummy_sample_deter
  
        scheduler.set_timesteps(lowerCAmelCase   )
  
        for t in scheduler.timesteps:
          a__     		=     model(lowerCAmelCase      ,      lowerCAmelCase   )
          a__     		=     scheduler.step(lowerCAmelCase      ,      lowerCAmelCase      ,      lowerCAmelCase      ,      lowerCAmelCase   ).prev_sample
  
        return sample
  
  
  
  
      def 						__lowerCamelCase (					self  :   List[str]   )	-> List[str]:
        for timesteps in [100, 500, 1000]:
          self.check_over_configs(num_train_timesteps=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   List[str]   )	-> Any:
        for steps_offset in [0, 1]:
          self.check_over_configs(steps_offset=lowerCAmelCase   )
  
        a__     		=     self.scheduler_classes[0]
        a__     		=     self.get_scheduler_config(steps_offset=1   )
        a__     		=     scheduler_class(**lowerCAmelCase   )
        scheduler.set_timesteps(5   )
        assert torch.equal(scheduler.timesteps      ,      torch.LongTensor([801, 601, 401, 201, 1]   )   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   Tuple   )	-> str:
        for beta_start, beta_end in zip([0.0_001, 0.001, 0.01, 0.1]      ,      [0.002, 0.02, 0.2, 2]   ):
          self.check_over_configs(beta_start=lowerCAmelCase      ,      beta_end=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   Optional[int]   )	-> Any:
        for schedule in ["linear", "squaredcos_cap_v2"]:
          self.check_over_configs(beta_schedule=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   List[Any]   )	-> str:
        for prediction_type in ["epsilon", "v_prediction"]:
          self.check_over_configs(prediction_type=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   List[Any]   )	-> Optional[int]:
        for clip_sample in [True, False]:
          self.check_over_configs(clip_sample=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   Tuple   )	-> Optional[int]:
        for timestep_spacing in ["trailing", "leading"]:
          self.check_over_configs(timestep_spacing=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   Any   )	-> Optional[int]:
        for rescale_betas_zero_snr in [True, False]:
          self.check_over_configs(rescale_betas_zero_snr=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   str   )	-> List[str]:
        self.check_over_configs(thresholding=lowerCAmelCase   )
        for threshold in [0.5, 1.0, 2.0]:
          for prediction_type in ["epsilon", "v_prediction"]:
            self.check_over_configs(
                thresholding=lowerCAmelCase      ,      prediction_type=lowerCAmelCase      ,      sample_max_value=lowerCAmelCase      ,      )
  
  
  
  
      def 						__lowerCamelCase (					self  :   str   )	-> Tuple:
        for t in [1, 10, 49]:
          self.check_over_forward(time_step=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   int   )	-> Optional[Any]:
        for t, num_inference_steps in zip([1, 10, 50]      ,      [10, 50, 500]   ):
          self.check_over_forward(time_step=lowerCAmelCase      ,      num_inference_steps=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   str   )	-> Union[str, Any]:
        for t, eta in zip([1, 10, 49]      ,      [0.0, 0.5, 1.0]   ):
          self.check_over_forward(time_step=lowerCAmelCase      ,      eta=lowerCAmelCase   )
  
  
  
  
      def 						__lowerCamelCase (					self  :   int   )	-> List[str]:
        a__     		=     self.scheduler_classes[0]
        a__     		=     self.get_scheduler_config()
        a__     		=     scheduler_class(**lowerCAmelCase   )
  
        assert torch.sum(torch.abs(scheduler._get_variance(0      ,      0   ) - 0.0   )   ) < 1e-5
        assert torch.sum(torch.abs(scheduler._get_variance(420      ,      400   ) - 0.14_771   )   ) < 1e-5
        assert torch.sum(torch.abs(scheduler._get_variance(980      ,      960   ) - 0.32_460   )   ) < 1e-5
        assert torch.sum(torch.abs(scheduler._get_variance(0      ,      0   ) - 0.0   )   ) < 1e-5
        assert torch.sum(torch.abs(scheduler._get_variance(487      ,      486   ) - 0.00_979   )   ) < 1e-5
        assert torch.sum(torch.abs(scheduler._get_variance(999      ,      998   ) - 0.02   )   ) < 1e-5
  
  
  
  
      def 						__lowerCamelCase (					self  :   Tuple   )	-> str:
        a__     		=     self.full_loop()
  
        a__     		=     torch.sum(torch.abs(lowerCAmelCase   )   )
        a__     		=     torch.mean(torch.abs(lowerCAmelCase   )   )
  
        assert abs(result_sum.item() - 172.0_067   ) < 1e-2
        assert abs(result_mean.item() - 0.223_967   ) < 1e-3
  
  
  
  
      def 						__lowerCamelCase (					self  :   int   )	-> Union[str, Any]:
        a__     		=     self.full_loop(prediction_type="v_prediction"   )
  
        a__     		=     torch.sum(torch.abs(lowerCAmelCase   )   )
        a__     		=     torch.mean(torch.abs(lowerCAmelCase   )   )
  
        assert abs(result_sum.item() - 52.5_302   ) < 1e-2
        assert abs(result_mean.item() - 0.0_684   ) < 1e-3
  
  
  
  
      def 						__lowerCamelCase (					self  :   Tuple   )	-> Dict:
        # We specify different beta, so that the first alpha is 0.99
        a__     		=     self.full_loop(set_alpha_to_one=lowerCAmelCase      ,      beta_start=0.01   )
        a__     		=     torch.sum(torch.abs(lowerCAmelCase   )   )
        a__     		=     torch.mean(torch.abs(lowerCAmelCase   )   )
  
        assert abs(result_sum.item() - 149.8_295   ) < 1e-2
        assert abs(result_mean.item() - 0.1_951   ) < 1e-3
  
  
  
  
      def 						__lowerCamelCase (					self  :   str   )	-> List[Any]:
        # We specify different beta, so that the first alpha is 0.99
        a__     		=     self.full_loop(set_alpha_to_one=lowerCAmelCase      ,      beta_start=0.01   )
        a__     		=     torch.sum(torch.abs(lowerCAmelCase   )   )
        a__     		=     torch.mean(torch.abs(lowerCAmelCase   )   )
  
        assert abs(result_sum.item() - 149.0_784   ) < 1e-2
        assert abs(result_mean.item() - 0.1_941   ) < 1e-3
  
  
style_context: import copy
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  _SCREAMING_SNAKE_CASE   						=    logging.get_logger(__name__)
  
  _SCREAMING_SNAKE_CASE   						=    {
      """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    ):
  
  
  
  
      def __init__(					self  :   List[str]      ,      lowerCAmelCase  :   str=256      ,      lowerCAmelCase  :   Any=1024      ,      lowerCAmelCase  :   List[str]=16      ,      lowerCAmelCase  :   Union[str, Any]=16      ,      lowerCAmelCase  :   int=4      ,      lowerCAmelCase  :   List[Any]="gelu"      ,      lowerCAmelCase  :   str=1e-6      ,      **lowerCAmelCase  :   Union[str, Any]      ,      )	-> Union[str, Any]:
        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 					UpperCAmelCase_				(							_a    ):
  
  
  
  
      def __init__(					self  :   Dict      ,      lowerCAmelCase  :   str=256      ,      lowerCAmelCase  :   Union[str, Any]="relu"      ,      lowerCAmelCase  :   Optional[int]=2048      ,      lowerCAmelCase  :   Any=2      ,      lowerCAmelCase  :   Any=8      ,      lowerCAmelCase  :   Optional[Any]=2      ,      lowerCAmelCase  :   Optional[Any]=3      ,      lowerCAmelCase  :   Union[str, Any]=3      ,      lowerCAmelCase  :   List[str]=256      ,      lowerCAmelCase  :   Optional[Any]=1e-6      ,      **lowerCAmelCase  :   Any      ,      )	-> int:
        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 					UpperCAmelCase_				(							_a    ):
  
  
  
  
      def __init__(					self  :   Optional[Any]      ,      lowerCAmelCase  :   Optional[Any]=768      ,      lowerCAmelCase  :   int=256      ,      lowerCAmelCase  :   Tuple=12      ,      lowerCAmelCase  :   List[str]=12      ,      lowerCAmelCase  :   Tuple=3      ,      lowerCAmelCase  :   Any=1024      ,      lowerCAmelCase  :   Dict=16      ,      lowerCAmelCase  :   Dict="gelu"      ,      lowerCAmelCase  :   List[Any]=1e-0_6      ,      lowerCAmelCase  :   Any=0.0      ,      lowerCAmelCase  :   Optional[Any]=1e-1_0      ,      lowerCAmelCase  :   Tuple=True      ,      lowerCAmelCase  :   Tuple=4.0      ,      lowerCAmelCase  :   Optional[Any]=True      ,      lowerCAmelCase  :   List[str]=True      ,      lowerCAmelCase  :   Dict=14      ,      lowerCAmelCase  :   Optional[int]=[2, 5, 8, 11]      ,      lowerCAmelCase  :   List[str]=128      ,      lowerCAmelCase  :   List[str]=None      ,      **lowerCAmelCase  :   str      ,      )	-> Optional[int]:
        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 					UpperCAmelCase_				(							_a    ):
      UpperCAmelCase_			:       Optional[Any]						 =							'sam'
      UpperCAmelCase_			:       List[Any]						 =							True
  
  
  
  
      def __init__(					self  :   Dict      ,      lowerCAmelCase  :   Any=None      ,      lowerCAmelCase  :   Optional[Any]=None      ,      lowerCAmelCase  :   Optional[Any]=None      ,      lowerCAmelCase  :   str=0.02      ,      **lowerCAmelCase  :   int      ,      )	-> Dict:
        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 						__lowerCamelCase (					self  :   Optional[Any]   )	-> Union[str, Any]:
        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
  
  