code: 
  
  
  
  
  
  import torch
  
  from diffusers import HeunDiscreteScheduler
  from diffusers.utils import torch_device
  
  from .test_schedulers import SchedulerCommonTest
  
  class      A    (__UpperCAmelCase				):
        _SCREAMING_SNAKE_CASE					=							(HeunDiscreteScheduler,)
        _SCREAMING_SNAKE_CASE					=							10
  
  
  
        def    __a (					self     ,  **lowercase_					)      ->   Dict:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Any     				=						{
                   '''num_train_timesteps''': 1100,
                   '''beta_start''': 0.0001,
                   '''beta_end''': 0.02,
                   '''beta_schedule''': '''linear''',
               }
  
               config.update(**lowercase_					)
               return config
  
  
  
        def    __a (					self					)      ->   Optional[int]:
  
  
  
               '''simple docstring'''
  
               for timesteps in [10, 50, 100, 1000]:
                      self.check_over_configs(num_train_timesteps=lowercase_					)
  
  
  
        def    __a (					self					)      ->   Any:
  
  
  
               '''simple docstring'''
  
               for beta_start, beta_end in zip([0.0_0001, 0.0001, 0.001]     ,  [0.0002, 0.002, 0.02]					):
                      self.check_over_configs(beta_start=lowercase_     ,  beta_end=lowercase_					)
  
  
  
        def    __a (					self					)      ->   Optional[Any]:
  
  
  
               '''simple docstring'''
  
               for schedule in ["linear", "scaled_linear", "exp"]:
                      self.check_over_configs(beta_schedule=lowercase_					)
  
  
  
        def    __a (					self					)      ->   List[str]:
  
  
  
               '''simple docstring'''
  
               for clip_sample_range in [1.0, 2.0, 3.0]:
                      self.check_over_configs(clip_sample_range=lowercase_     ,  clip_sample=lowercase_					)
  
  
  
        def    __a (					self					)      ->   Optional[int]:
  
  
  
               '''simple docstring'''
  
               for prediction_type in ["epsilon", "v_prediction", "sample"]:
                      self.check_over_configs(prediction_type=lowercase_					)
  
  
  
        def    __a (					self					)      ->   Tuple:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							str     				=						self.scheduler_classes[0]
               _snake_case      :							List[Any]     				=						self.get_scheduler_config()
               _snake_case      :							Optional[Any]     				=						scheduler_class(**lowercase_					)
  
               scheduler.set_timesteps(self.num_inference_steps					)
  
               _snake_case      :							Any     				=						self.dummy_model()
               _snake_case      :							List[str]     				=						self.dummy_sample_deter * scheduler.init_noise_sigma
               _snake_case      :							str     				=						sample.to(lowercase_					)
  
               for i, t in enumerate(scheduler.timesteps					):
                      _snake_case      :							Any     				=						scheduler.scale_model_input(lowercase_     ,  lowercase_					)
  
                      _snake_case      :							Dict     				=						model(lowercase_     ,  lowercase_					)
  
                      _snake_case      :							Optional[Any]     				=						scheduler.step(lowercase_     ,  lowercase_     ,  lowercase_					)
                      _snake_case      :							Any     				=						output.prev_sample
  
               _snake_case      :							List[str]     				=						torch.sum(torch.abs(lowercase_					)					)
               _snake_case      :							List[Any]     				=						torch.mean(torch.abs(lowercase_					)					)
  
               if torch_device in ["cpu", "mps"]:
                      assert abs(result_sum.item() - 0.1233					) < 1E-2
                      assert abs(result_mean.item() - 0.0002					) < 1E-3
               else:
                      # CUDA
                      assert abs(result_sum.item() - 0.1233					) < 1E-2
                      assert abs(result_mean.item() - 0.0002					) < 1E-3
  
  
  
        def    __a (					self					)      ->   int:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Any     				=						self.scheduler_classes[0]
               _snake_case      :							Any     				=						self.get_scheduler_config(prediction_type='''v_prediction'''					)
               _snake_case      :							Optional[Any]     				=						scheduler_class(**lowercase_					)
  
               scheduler.set_timesteps(self.num_inference_steps					)
  
               _snake_case      :							List[Any]     				=						self.dummy_model()
               _snake_case      :							int     				=						self.dummy_sample_deter * scheduler.init_noise_sigma
               _snake_case      :							Dict     				=						sample.to(lowercase_					)
  
               for i, t in enumerate(scheduler.timesteps					):
                      _snake_case      :							Tuple     				=						scheduler.scale_model_input(lowercase_     ,  lowercase_					)
  
                      _snake_case      :							Optional[int]     				=						model(lowercase_     ,  lowercase_					)
  
                      _snake_case      :							Any     				=						scheduler.step(lowercase_     ,  lowercase_     ,  lowercase_					)
                      _snake_case      :							Union[str, Any]     				=						output.prev_sample
  
               _snake_case      :							str     				=						torch.sum(torch.abs(lowercase_					)					)
               _snake_case      :							Any     				=						torch.mean(torch.abs(lowercase_					)					)
  
               if torch_device in ["cpu", "mps"]:
                      assert abs(result_sum.item() - 4.6934E-07					) < 1E-2
                      assert abs(result_mean.item() - 6.1112E-10					) < 1E-3
               else:
                      # CUDA
                      assert abs(result_sum.item() - 4.693_4286_5017_0972E-07					) < 1E-2
                      assert abs(result_mean.item() - 0.0002					) < 1E-3
  
  
  
        def    __a (					self					)      ->   List[str]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Dict     				=						self.scheduler_classes[0]
               _snake_case      :							Optional[int]     				=						self.get_scheduler_config()
               _snake_case      :							int     				=						scheduler_class(**lowercase_					)
  
               scheduler.set_timesteps(self.num_inference_steps     ,  device=lowercase_					)
  
               _snake_case      :							Tuple     				=						self.dummy_model()
               _snake_case      :							List[str]     				=						self.dummy_sample_deter.to(lowercase_					) * scheduler.init_noise_sigma
  
               for t in scheduler.timesteps:
                      _snake_case      :							List[str]     				=						scheduler.scale_model_input(lowercase_     ,  lowercase_					)
  
                      _snake_case      :							Union[str, Any]     				=						model(lowercase_     ,  lowercase_					)
  
                      _snake_case      :							Optional[int]     				=						scheduler.step(lowercase_     ,  lowercase_     ,  lowercase_					)
                      _snake_case      :							Tuple     				=						output.prev_sample
  
               _snake_case      :							List[str]     				=						torch.sum(torch.abs(lowercase_					)					)
               _snake_case      :							Any     				=						torch.mean(torch.abs(lowercase_					)					)
  
               if str(lowercase_					).startswith('''cpu'''					):
                      # The following sum varies between 148 and 156 on mps. Why?
                      assert abs(result_sum.item() - 0.1233					) < 1E-2
                      assert abs(result_mean.item() - 0.0002					) < 1E-3
               elif str(lowercase_					).startswith('''mps'''					):
                      # Larger tolerance on mps
                      assert abs(result_mean.item() - 0.0002					) < 1E-2
               else:
                      # CUDA
                      assert abs(result_sum.item() - 0.1233					) < 1E-2
                      assert abs(result_mean.item() - 0.0002					) < 1E-3
  
  
  
        def    __a (					self					)      ->   Optional[Any]:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Tuple     				=						self.scheduler_classes[0]
               _snake_case      :							Optional[Any]     				=						self.get_scheduler_config()
               _snake_case      :							List[Any]     				=						scheduler_class(**lowercase_     ,  use_karras_sigmas=lowercase_					)
  
               scheduler.set_timesteps(self.num_inference_steps     ,  device=lowercase_					)
  
               _snake_case      :							Tuple     				=						self.dummy_model()
               _snake_case      :							Any     				=						self.dummy_sample_deter.to(lowercase_					) * scheduler.init_noise_sigma
               _snake_case      :							Any     				=						sample.to(lowercase_					)
  
               for t in scheduler.timesteps:
                      _snake_case      :							int     				=						scheduler.scale_model_input(lowercase_     ,  lowercase_					)
  
                      _snake_case      :							int     				=						model(lowercase_     ,  lowercase_					)
  
                      _snake_case      :							Optional[int]     				=						scheduler.step(lowercase_     ,  lowercase_     ,  lowercase_					)
                      _snake_case      :							Optional[Any]     				=						output.prev_sample
  
               _snake_case      :							List[str]     				=						torch.sum(torch.abs(lowercase_					)					)
               _snake_case      :							List[str]     				=						torch.mean(torch.abs(lowercase_					)					)
  
               assert abs(result_sum.item() - 0.0_0015					) < 1E-2
               assert abs(result_mean.item() - 1.9869_5545_3503_4695E-07					) < 1E-2
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  import numpy as np
  
  
  
  
  def 						A_			(  lowercase_  )			->						Optional[Any]:
         _snake_case      :							Union[str, Any]     				=						np.exp(lowercase_  )
  
         # Add up the all the exponentials
         _snake_case      :							List[str]     				=						np.sum(lowercase_  )
  
         # Divide every exponent by the sum of all exponents
         _snake_case      :							Optional[int]     				=						exponent_vector / sum_of_exponents
  
         return softmax_vector
  
  
  if __name__ == "__main__":
     print(softmax((0,)))
  
  
  
  
  
  
  