code: 
  
  
  
  
  
  
  import inspect
  import warnings
  
  import torch
  
  from .state import AcceleratorState, GradientState
  from .utils import DistributedType, honor_type, is_tpu_available
  
  
  if is_tpu_available(check_device=False):
        import torch_xla.core.xla_model as xm
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> Optional[int]:
  
       '''simple docstring'''
       if isinstance(snake_case__   ,       (list, tuple)					):
            return honor_type(snake_case__   ,       (move_to_device(snake_case__   ,       snake_case__					) for t in state)					)
       elif isinstance(snake_case__   ,       snake_case__					):
            return type(snake_case__					)({k: move_to_device(snake_case__   ,       snake_case__					) for k, v in state.items()}					)
       elif isinstance(snake_case__   ,       torch.Tensor					):
            return state.to(snake_case__					)
       return state
  
  
  
  
  
  
  
  class 							UpperCAmelCase_     (		torch.optim.Optimizer		):
  
  
  
  
       def __init__(							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase=True  ,	_lowerCAmelCase=None		):
            UpperCAmelCase__			:     Optional[Any]										= optimizer
            UpperCAmelCase__			:     int										= scaler
            UpperCAmelCase__			:     Union[str, Any]										= AcceleratorState()
            UpperCAmelCase__			:     List[Any]										= GradientState()
            UpperCAmelCase__			:     Optional[Any]										= device_placement
            UpperCAmelCase__			:     Union[str, Any]										= False
            UpperCAmelCase__			:     Union[str, Any]										= None
  
            # Handle device placement
            if device_placement:
                 UpperCAmelCase__			:     Optional[Any]										= self.optimizer.state_dict()
                 if self.accelerator_state.distributed_type == DistributedType.TPU:
                      xm.send_cpu_data_to_device(SCREAMING_SNAKE_CASE_  ,	self.accelerator_state.device		)
                 else:
                      UpperCAmelCase__			:     Dict										= move_to_device(SCREAMING_SNAKE_CASE_  ,	self.accelerator_state.device		)
                 self.optimizer.load_state_dict(SCREAMING_SNAKE_CASE_		)
  
  
  
  
       @property
       def      __UpperCAmelCase     (							self		):
            return self.optimizer.state
  
  
  
  
       @state.setter
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase		):
            UpperCAmelCase__			:     Optional[int]										= state
  
  
  
  
       @property
       def      __UpperCAmelCase     (							self		):
            return self.optimizer.param_groups
  
  
  
  
       @param_groups.setter
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase		):
            UpperCAmelCase__			:     Any										= param_groups
  
  
  
  
       @property
       def      __UpperCAmelCase     (							self		):
            return self.optimizer.defaults
  
  
  
  
       @defaults.setter
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase		):
            UpperCAmelCase__			:     str										= defaults
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase		):
            self.optimizer.add_param_group(SCREAMING_SNAKE_CASE_		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase		):
            if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:
                 xm.send_cpu_data_to_device(SCREAMING_SNAKE_CASE_  ,	self.accelerator_state.device		)
            self.optimizer.load_state_dict(SCREAMING_SNAKE_CASE_		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            return self.optimizer.state_dict()
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase=None		):
            if self.gradient_state.sync_gradients:
                 UpperCAmelCase__			:     str										= 'set_to_none' in inspect.signature(self.optimizer.zero_grad		).parameters
                 if accept_arg:
                      if set_to_none is None:
                           UpperCAmelCase__			:     List[Any]										= False
                      self.optimizer.zero_grad(set_to_none=SCREAMING_SNAKE_CASE_		)
                 else:
                      if set_to_none is not None:
                           raise ValueError("""`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer."""		)
                      self.optimizer.zero_grad()
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase=None		):
            if self.gradient_state.sync_gradients:
                 if self.accelerator_state.distributed_type == DistributedType.TPU:
                      UpperCAmelCase__			:     Tuple										= {'closure': closure} if closure is not None else {}
                      xm.optimizer_step(self.optimizer  ,	optimizer_args=SCREAMING_SNAKE_CASE_		)
                 elif self.scaler is not None:
                      UpperCAmelCase__			:     Any										= False
                      if self._last_scale is None:
                           # `get_scale` is an async operation requiring full synchronization
                           # on CPU and GPUs before finishing. As a result, we store away
                           # the prior one to reduce the call overhead
                           UpperCAmelCase__			:     List[str]										= self.scaler.get_scale()
                           UpperCAmelCase__			:     Optional[Any]										= True
                      self.scaler.step(self.optimizer  ,	SCREAMING_SNAKE_CASE_		)
                      self.scaler.update()
                      UpperCAmelCase__			:     List[Any]										= self.scaler.get_scale()
                      if not new_scale:
                           # If we reduced the loss scale, it means the optimizer step was skipped because of gradient overflow.
                           UpperCAmelCase__			:     List[str]										= scale_after < self._last_scale
                      UpperCAmelCase__			:     Optional[int]										= scale_after
  
                 else:
                      self.optimizer.step(SCREAMING_SNAKE_CASE_		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase		):
            for param_group in self.optimizer.param_groups:
                 UpperCAmelCase__			:     Any										= [parameters_map.get(SCREAMING_SNAKE_CASE_  ,	SCREAMING_SNAKE_CASE_		) for p in param_group['params']]
  
  
  
  
       @property
       def      __UpperCAmelCase     (							self		):
            warnings.warn(
                """The `is_overflow` property is deprecated and will be removed in version 1.0 of Accelerate use """
                """`optimizer.step_was_skipped` instead."""  ,	SCREAMING_SNAKE_CASE_  ,	)
            return self._is_overflow
  
  
  
  
       @property
       def      __UpperCAmelCase     (							self		):
            return self._is_overflow
  
  
  
  
       def __getstate__(							self		):
            return self.__dict__.copy()
  
  
  
  
       def __setstate__(							self  ,	_lowerCAmelCase		):
            self.__dict__.update(SCREAMING_SNAKE_CASE_		)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  import math
  import os
  
  import cva
  import numpy as np
  
  SCREAMING_SNAKE_CASE__		:       Optional[Any]   							=							255.0
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> float:
  
       '''simple docstring'''
       UpperCAmelCase__			:     List[Any]										= np.mean((original - contrast) ** 2					)
       if mse == 0:
            return 100
  
       return 20 * math.logaa(PIXEL_MAX / math.sqrt(__lowerCamelCase					)					)
  
  
  
  
  
  def    _lowerCamelCase	(	)   -> None:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Union[str, Any]										= os.path.dirname(os.path.realpath(__lowerCamelCase					)					)
       # Loading images (original image and compressed image)
       UpperCAmelCase__			:     List[Any]										= cva.imread(os.path.join(__lowerCamelCase   ,       """image_data/original_image.png"""					)					)
       UpperCAmelCase__			:     Dict										= cva.imread(os.path.join(__lowerCamelCase   ,       """image_data/compressed_image.png"""					)   ,       1					)
  
       UpperCAmelCase__			:     Tuple										= cva.imread(os.path.join(__lowerCamelCase   ,       """image_data/PSNR-example-base.png"""					)					)
       UpperCAmelCase__			:     int										= cva.imread(
           os.path.join(__lowerCamelCase   ,       """image_data/PSNR-example-comp-10.jpg"""					)   ,       1					)
  
       # Value expected: 29.73dB
       print("""-- First Test --"""					)
       print(F"PSNR value is {peak_signal_to_noise_ratio(__lowerCamelCase   ,       __lowerCamelCase					)} dB"					)
  
       # # Value expected: 31.53dB (Wikipedia Example)
       print("""\n-- Second Test --"""					)
       print(F"PSNR value is {peak_signal_to_noise_ratio(__lowerCamelCase   ,       __lowerCamelCase					)} dB"					)
  
  
  if __name__ == "__main__":
        main()
  
  
  
  
  
  
  