




'''simple docstring'''






import unittest

import numpy as np
import torch

from diffusers import DDPMPipeline, DDPMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow, torch_device


enable_full_determinism()



class  A		(			unittest.TestCase		):




				'''simple docstring'''





				@property
				def 	a_	(self      )     ->	str:
							torch.manual_seed(0      )
							__UpperCamelCase				:      Union[str, Any]									=       UNetaDModel(
							    block_out_channels=(3_2, 6_4)			,  layers_per_block=2			,  sample_size=3_2			,  in_channels=3			,  out_channels=3			,  down_block_types=("DownBlock2D", "AttnDownBlock2D")			,  up_block_types=("AttnUpBlock2D", "UpBlock2D")			,  )
							return model
				def 	a_	(self      )     ->	Dict:
							__UpperCamelCase				:      List[str]									=       "cpu"
							__UpperCamelCase				:      Any									=       self.dummy_uncond_unet
							__UpperCamelCase				:      int									=       DDPMScheduler()

							__UpperCamelCase				:      List[Any]									=       DDPMPipeline(unet=_UpperCAmelCase			,  scheduler=_UpperCAmelCase      )
							ddpm.to(_UpperCAmelCase      )
							ddpm.set_progress_bar_config(disable=_UpperCAmelCase      )

							__UpperCamelCase				:      Any									=       torch.Generator(device=_UpperCAmelCase      ).manual_seed(0      )
							__UpperCamelCase				:      Union[str, Any]									=       ddpm(generator=_UpperCAmelCase			,  num_inference_steps=2			,  output_type="numpy"      ).images

							__UpperCamelCase				:      Tuple									=       torch.Generator(device=_UpperCAmelCase      ).manual_seed(0      )
							__UpperCamelCase				:      Optional[int]									=       ddpm(generator=_UpperCAmelCase			,  num_inference_steps=2			,  output_type="numpy"			,  return_dict=_UpperCAmelCase      )[0]

							__UpperCamelCase				:      Optional[Any]									=       image[0, -3:, -3:, -1]
							__UpperCamelCase				:      str									=       image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 3_2, 3_2, 3)
							__UpperCamelCase				:      Any									=       np.array(
							    [9.956E-01, 5.785E-01, 4.675E-01, 9.930E-01, 0.0, 1.000, 1.199E-03, 2.648E-04, 5.101E-04]      )

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





				def 	a_	(self      )     ->	Union[str, Any]:
							__UpperCamelCase				:      Optional[int]									=       self.dummy_uncond_unet
							__UpperCamelCase				:      List[str]									=       DDPMScheduler(prediction_type="sample"      )

							__UpperCamelCase				:      int									=       DDPMPipeline(unet=_UpperCAmelCase			,  scheduler=_UpperCAmelCase      )
							ddpm.to(_UpperCAmelCase      )
							ddpm.set_progress_bar_config(disable=_UpperCAmelCase      )

							__UpperCamelCase				:      List[Any]									=       torch.manual_seed(0      )
							__UpperCamelCase				:      Dict									=       ddpm(generator=_UpperCAmelCase			,  num_inference_steps=2			,  output_type="numpy"      ).images

							__UpperCamelCase				:      Optional[Any]									=       torch.manual_seed(0      )
							__UpperCamelCase				:      Any									=       ddpm(generator=_UpperCAmelCase			,  num_inference_steps=2			,  output_type="numpy"      )[0]

							__UpperCamelCase				:      Union[str, Any]									=       image[0, -3:, -3:, -1]
							__UpperCamelCase				:      List[Any]									=       image_eps[0, -3:, -3:, -1]

							assert image.shape == (1, 3_2, 3_2, 3)
							__UpperCamelCase				:      Optional[Any]									=       1E-2 if torch_device != "mps" else 3E-2
							assert np.abs(image_slice.flatten() - image_eps_slice.flatten()      ).max() < tolerance







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




				'''simple docstring'''





				def 	a_	(self      )     ->	str:
							__UpperCamelCase				:      Dict									=       "google/ddpm-cifar10-32"

							__UpperCamelCase				:      int									=       UNetaDModel.from_pretrained(_UpperCAmelCase      )
							__UpperCamelCase				:      int									=       DDPMScheduler.from_pretrained(_UpperCAmelCase      )

							__UpperCamelCase				:      Any									=       DDPMPipeline(unet=_UpperCAmelCase			,  scheduler=_UpperCAmelCase      )
							ddpm.to(_UpperCAmelCase      )
							ddpm.set_progress_bar_config(disable=_UpperCAmelCase      )

							__UpperCamelCase				:      Tuple									=       torch.manual_seed(0      )
							__UpperCamelCase				:      Optional[int]									=       ddpm(generator=_UpperCAmelCase			,  output_type="numpy"      ).images

							__UpperCamelCase				:      List[str]									=       image[0, -3:, -3:, -1]

							assert image.shape == (1, 3_2, 3_2, 3)
							__UpperCamelCase				:      Any									=       np.array([0.4_200, 0.3_588, 0.1_939, 0.3_847, 0.3_382, 0.2_647, 0.4_155, 0.3_582, 0.3_385]      )
							assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2









'''simple docstring'''






from doctest import testmod
from math import sqrt

def       __lowerCAmelCase (   snake_case__						):
			__UpperCamelCase				:      list[int]									=       []
			if num < 1:
						return facs
			facs.append(1						)
			if num == 1:
						return facs
			facs.append(snake_case__						)
			for i in range(2 ,				int(sqrt(snake_case__						)						) + 1						):
						if num % i == 0:  # If i is a factor of num
									facs.append(snake_case__						)
									__UpperCamelCase				:      List[str]									=       num // i  # num//i is the other factor of num
									if d != i:  # If d and i are distinct
												facs.append(snake_case__						)  # we have found another factor
			facs.sort()
			return facs


if __name__ == "__main__":
				testmod(name='''factors_of_a_number''', verbose=True)



