






'''simple docstring'''

import inspect
import os
import unittest
from dataclasses import dataclass

import torch

from accelerate import Accelerator, DistributedDataParallelKwargs, GradScalerKwargs
from accelerate.state import AcceleratorState
from accelerate.test_utils import execute_subprocess_async, require_cuda, require_multi_gpu
from accelerate.utils import KwargsHandler




@dataclass
class      A     (   SCREAMING_SNAKE_CASE__    ):






 """simple docstring"""





 __a      :    int			  =    0
 __a      :    bool			  =    False
 __a      :    float			  =    3.0






class      A     (   unittest.TestCase    ):






 """simple docstring"""





 def 	_UpperCAmelCase							(				self			):
       # If no defaults are changed, `to_kwargs` returns an empty dict.
       self.assertDictEqual(MockClass().to_kwargs()      ,  {}			)
       self.assertDictEqual(MockClass(a=2			).to_kwargs()      ,  {"""a""": 2}			)
       self.assertDictEqual(MockClass(a=2      ,  b=__lowerCAmelCase			).to_kwargs()      ,  {"""a""": 2, """b""": True}			)
       self.assertDictEqual(MockClass(a=2      ,  c=2.25			).to_kwargs()      ,  {"""a""": 2, """c""": 2.25}			)
 @require_cuda
 def 	_UpperCAmelCase							(				self			):
       # If no defaults are changed, `to_kwargs` returns an empty dict.
       UpperCamelCase_					: str            =				GradScalerKwargs(init_scale=10_24      ,  growth_factor=2			)
       AcceleratorState._reset_state()
       UpperCamelCase_					: Any            =				Accelerator(mixed_precision="""fp16"""      ,  kwargs_handlers=[scaler_handler]			)
       print(accelerator.use_fpaa			)
       UpperCamelCase_					: Tuple            =				accelerator.scaler

       # Check the kwargs have been applied
       self.assertEqual(scaler._init_scale      ,  10_24.0			)
       self.assertEqual(scaler._growth_factor      ,  2.0			)

       # Check the other values are at the default
       self.assertEqual(scaler._backoff_factor      ,  0.5			)
       self.assertEqual(scaler._growth_interval      ,  20_00			)
       self.assertEqual(scaler._enabled      ,  __lowerCAmelCase			)





 @require_multi_gpu
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Any            =				["""torchrun""", F"--nproc_per_node={torch.cuda.device_count()}", inspect.getfile(self.__class__			)]
       execute_subprocess_async(__lowerCAmelCase      ,  env=os.environ.copy()			)


if __name__ == "__main__":
      UpperCamelCase      					=DistributedDataParallelKwargs(bucket_cap_mb=15, find_unused_parameters=True)
      UpperCamelCase      					=Accelerator(kwargs_handlers=[ddp_scaler])
      UpperCamelCase      					=torch.nn.Linear(100, 200)
      UpperCamelCase      					=accelerator.prepare(model)

      # Check the values changed in kwargs
      UpperCamelCase      					=""
      UpperCamelCase      					=model.bucket_bytes_cap // (1024 * 1024)
      if observed_bucket_cap_map != 15:
            error_msg += f"Kwargs badly passed, should have `15` but found {observed_bucket_cap_map}.\n"
      if model.find_unused_parameters is not True:
            error_msg += f"Kwargs badly passed, should have `True` but found {model.find_unused_parameters}.\n"

      # Check the values of the defaults
      if model.dim != 0:
            error_msg += f"Default value not respected, should have `0` but found {model.dim}.\n"
      if model.broadcast_buffers is not True:
            error_msg += f"Default value not respected, should have `True` but found {model.broadcast_buffers}.\n"
      if model.gradient_as_bucket_view is not False:
            error_msg += f"Default value not respected, should have `False` but found {model.gradient_as_bucket_view}.\n"

      # Raise error at the end to make sure we don't stop at the first failure.
      if len(error_msg) > 0:
            raise ValueError(error_msg)














'''simple docstring'''

import unittest

import numpy as np
import torch

from diffusers import PNDMPipeline, PNDMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()




class      A     (   unittest.TestCase    ):






 """simple docstring"""





 @property
 def 	_UpperCAmelCase							(				self			):
       torch.manual_seed(0			)
       UpperCamelCase_					: int            =				UNetaDModel(
           block_out_channels=(32, 64)      ,  layers_per_block=2      ,  sample_size=32      ,  in_channels=3      ,  out_channels=3      ,  down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")      ,  up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")      ,  )
       return model





 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Union[str, Any]            =				self.dummy_uncond_unet
       UpperCamelCase_					: List[str]            =				PNDMScheduler()

       UpperCamelCase_					: Dict            =				PNDMPipeline(unet=__lowerCAmelCase      ,  scheduler=__lowerCAmelCase			)
       pndm.to(__lowerCAmelCase			)
       pndm.set_progress_bar_config(disable=__lowerCAmelCase			)

       UpperCamelCase_					: Union[str, Any]            =				torch.manual_seed(0			)
       UpperCamelCase_					: Optional[int]            =				pndm(generator=__lowerCAmelCase      ,  num_inference_steps=20      ,  output_type="""numpy"""			).images

       UpperCamelCase_					: Optional[int]            =				torch.manual_seed(0			)
       UpperCamelCase_					: Tuple            =				pndm(generator=__lowerCAmelCase      ,  num_inference_steps=20      ,  output_type="""numpy"""      ,  return_dict=__lowerCAmelCase			)[0]

       UpperCamelCase_					: Union[str, Any]            =				image[0, -3:, -3:, -1]
       UpperCamelCase_					: int            =				image_from_tuple[0, -3:, -3:, -1]

       assert image.shape == (1, 32, 32, 3)
       UpperCamelCase_					: Optional[int]            =				np.array([1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0]			)

       assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
       assert np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1E-2






@slow
@require_torch
class      A     (   unittest.TestCase    ):






 """simple docstring"""





 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Optional[Any]            =				"""google/ddpm-cifar10-32"""

       UpperCamelCase_					: List[str]            =				UNetaDModel.from_pretrained(__lowerCAmelCase			)
       UpperCamelCase_					: int            =				PNDMScheduler()

       UpperCamelCase_					: Any            =				PNDMPipeline(unet=__lowerCAmelCase      ,  scheduler=__lowerCAmelCase			)
       pndm.to(__lowerCAmelCase			)
       pndm.set_progress_bar_config(disable=__lowerCAmelCase			)
       UpperCamelCase_					: Optional[int]            =				torch.manual_seed(0			)
       UpperCamelCase_					: Optional[int]            =				pndm(generator=__lowerCAmelCase      ,  output_type="""numpy"""			).images

       UpperCamelCase_					: Tuple            =				image[0, -3:, -3:, -1]

       assert image.shape == (1, 32, 32, 3)
       UpperCamelCase_					: Union[str, Any]            =				np.array([0.15_64, 0.1_46_45, 0.14_06, 0.1_47_15, 0.1_24_25, 0.1_40_45, 0.1_31_15, 0.1_21_75, 0.1_25]			)

       assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2






