
"""simple docstring"""

from typing import Dict, List, Optional, Tuple, Union

import torch

from ...models import AutoencoderKL, TransformeraDModel
from ...schedulers import KarrasDiffusionSchedulers
from ...utils import randn_tensor
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput

class __lowerCAmelCase		(				__lowerCamelCase      ):






     """simple docstring"""




     def __init__(     self     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase = None     ,					):

      '''simple docstring'''




      super().__init__()
      self.register_modules(transformer=__lowercase     ,					vae=__lowercase     ,					scheduler=__lowercase				)

      # create a imagenet -> id dictionary for easier use
      __UpperCamelCase      =	{}
      if idalabel is not None:
       for key, value in idalabel.items():
        for label in value.split(','				):
         __UpperCamelCase      =	int(__lowercase				)
       __UpperCamelCase      =	dict(sorted(self.labels.items()				)				)





     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase				):

      '''simple docstring'''




      if not isinstance(__lowercase     ,					__lowercase				):
       __UpperCamelCase      =	list(__lowercase				)

      for l in label:
       if l not in self.labels:
        raise ValueError(
            F'{l} does not exist. Please make sure to select one of the following labels: \n {self.labels}.'				)

      return [self.labels[l] for l in label]







     @torch.no_grad()
     def __call__(     self     ,					__UpperCAmelCase     ,					__UpperCAmelCase = 4.0     ,					__UpperCAmelCase = None     ,					__UpperCAmelCase = 50     ,					__UpperCAmelCase = "pil"     ,					__UpperCAmelCase = True     ,					):

      '''simple docstring'''




      __UpperCamelCase      =	len(__lowercase				)
      __UpperCamelCase      =	self.transformer.config.sample_size
      __UpperCamelCase      =	self.transformer.config.in_channels

      __UpperCamelCase      =	randn_tensor(
          shape=(batch_size, latent_channels, latent_size, latent_size)     ,					generator=__lowercase     ,					device=self.device     ,					dtype=self.transformer.dtype     ,					)
      __UpperCamelCase      =	torch.cat([latents] * 2				) if guidance_scale > 1 else latents

      __UpperCamelCase      =	torch.tensor(__lowercase     ,					device=self.device				).reshape(-1				)
      __UpperCamelCase      =	torch.tensor([1000] * batch_size     ,					device=self.device				)
      __UpperCamelCase      =	torch.cat([class_labels, class_null]     ,					0				) if guidance_scale > 1 else class_labels

      # set step values
      self.scheduler.set_timesteps(__lowercase				)

      for t in self.progress_bar(self.scheduler.timesteps				):
       if guidance_scale > 1:
        __UpperCamelCase      =	latent_model_input[: len(__lowercase				) // 2]
        __UpperCamelCase      =	torch.cat([half, half]     ,					dim=0				)
       __UpperCamelCase      =	self.scheduler.scale_model_input(__lowercase     ,					__lowercase				)

       __UpperCamelCase      =	t
       if not torch.is_tensor(__lowercase				):
        # TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can
        # This would be a good case for the `match` statement (Python 3.10+)
        __UpperCamelCase      =	latent_model_input.device.type == '''mps'''
        if isinstance(__lowercase     ,					__lowercase				):
         __UpperCamelCase      =	torch.floataa if is_mps else torch.floataa
        else:
         __UpperCamelCase      =	torch.intaa if is_mps else torch.intaa
        __UpperCamelCase      =	torch.tensor([timesteps]     ,					dtype=__lowercase     ,					device=latent_model_input.device				)
       elif len(timesteps.shape				) == 0:
        __UpperCamelCase      =	timesteps[None].to(latent_model_input.device				)
       # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
       __UpperCamelCase      =	timesteps.expand(latent_model_input.shape[0]				)
       # predict noise model_output
       __UpperCamelCase      =	self.transformer(
           __lowercase     ,					timestep=__lowercase     ,					class_labels=__lowercase				).sample

       # perform guidance
       if guidance_scale > 1:
        __UpperCamelCase      =	noise_pred[:, :latent_channels], noise_pred[:, latent_channels:]
        __UpperCamelCase      =	torch.split(__lowercase     ,					len(__lowercase				) // 2     ,					dim=0				)

        __UpperCamelCase      =	uncond_eps + guidance_scale * (cond_eps - uncond_eps)
        __UpperCamelCase      =	torch.cat([half_eps, half_eps]     ,					dim=0				)

        __UpperCamelCase      =	torch.cat([eps, rest]     ,					dim=1				)

       # learned sigma
       if self.transformer.config.out_channels // 2 == latent_channels:
        __UpperCamelCase      =	torch.split(__lowercase     ,					__lowercase     ,					dim=1				)
       else:
        __UpperCamelCase      =	noise_pred

       # compute previous image: x_t -> x_t-1
       __UpperCamelCase      =	self.scheduler.step(__lowercase     ,					__lowercase     ,					__lowercase				).prev_sample

      if guidance_scale > 1:
       __UpperCamelCase      =	latent_model_input.chunk(2     ,					dim=0				)
      else:
       __UpperCamelCase      =	latent_model_input

      __UpperCamelCase      =	1 / self.vae.config.scaling_factor * latents
      __UpperCamelCase      =	self.vae.decode(__lowercase				).sample

      __UpperCamelCase      =	(samples / 2 + 0.5).clamp(0     ,					1				)

      # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
      __UpperCamelCase      =	samples.cpu().permute(0     ,					2     ,					3     ,					1				).float().numpy()

      if output_type == "pil":
       __UpperCamelCase      =	self.numpy_to_pil(__lowercase				)

      if not return_dict:
       return (samples,)

      return ImagePipelineOutput(images=__lowercase				)





"""simple docstring"""

def 							A						(    snake_case				:int		)				->     bool:
 return sum(i for i in range(1    , number // 2 + 1		) if number % i == 0		) == number


if __name__ == "__main__":
      print("Program to check whether a number is a Perfect number or not...")
      UpperCamelCase     :    Union[str, Any]       =			int(input("Enter number: ").strip())
      print(f'''{number} is {"" if perfect(number) else "not "}a Perfect Number.''')



