



"""simple docstring"""
import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizer

from diffusers import (
    AltDiffusionImgaImgPipeline,
    AutoencoderKL,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()


class    SCREAMING_SNAKE_CASE__ (							unittest.TestCase   ):

    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()

    @property
    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      lowercase_								= 1
      lowercase_								= 3
      lowercase_								= (3_2, 3_2)

      lowercase_								= floats_tensor((batch_size, num_channels) + sizes ,  rng=random.Random(0)).to(lowerCAmelCase_)
      return image

    @property
    def 					_UpperCAmelCase	(				self			:				Dict):







      """simple docstring"""







      torch.manual_seed(0)
      lowercase_								= UNetaDConditionModel(
          block_out_channels=(3_2, 6_4) ,  layers_per_block=2 ,  sample_size=3_2 ,  in_channels=4 ,  out_channels=4 ,  down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") ,  up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") ,  cross_attention_dim=3_2 ,  )
      return model

    @property
    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







      torch.manual_seed(0)
      lowercase_								= AutoencoderKL(
          block_out_channels=[3_2, 6_4] ,  in_channels=3 ,  out_channels=3 ,  down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] ,  up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] ,  latent_channels=4 ,  )
      return model

    @property
    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







      torch.manual_seed(0)
      lowercase_								= RobertaSeriesConfig(
          hidden_size=3_2 ,  project_dim=3_2 ,  intermediate_size=3_7 ,  layer_norm_eps=1E-05 ,  num_attention_heads=4 ,  num_hidden_layers=5 ,  pad_token_id=1 ,  vocab_size=5_0_0_6 ,  )
      return RobertaSeriesModelWithTransformation(lowerCAmelCase_)

    @property
    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







      def extract(*lowerCAmelCase_			:				Dict ,  **lowerCAmelCase_			:				str):


        class    SCREAMING_SNAKE_CASE__ :

            def __init__(				self			:				Tuple):







              """simple docstring"""







              lowercase_								= torch.ones([0])




            def 					_UpperCAmelCase	(				self			:				int ,  lowerCAmelCase_			:				Optional[int]):







              """simple docstring"""







              self.pixel_values.to(lowerCAmelCase_)
              return self







        return Out()

      return extract

    def 					_UpperCAmelCase	(				self			:				Dict):







      """simple docstring"""







      lowercase_								= """cpu"""  # ensure determinism for the device-dependent torch.Generator
      lowercase_								= self.dummy_cond_unet
      lowercase_								= PNDMScheduler(skip_prk_steps=lowerCAmelCase_)
      lowercase_								= self.dummy_vae
      lowercase_								= self.dummy_text_encoder
      lowercase_								= XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta""")
      lowercase_								= 7_7

      lowercase_								= self.dummy_image.to(lowerCAmelCase_)
      lowercase_								= init_image / 2 + 0.5

      # make sure here that pndm scheduler skips prk
      lowercase_								= AltDiffusionImgaImgPipeline(
          unet=lowerCAmelCase_ ,  scheduler=lowerCAmelCase_ ,  vae=lowerCAmelCase_ ,  text_encoder=lowerCAmelCase_ ,  tokenizer=lowerCAmelCase_ ,  safety_checker=lowerCAmelCase_ ,  feature_extractor=self.dummy_extractor ,  )
      lowercase_								= VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor ,  do_normalize=lowerCAmelCase_)
      lowercase_								= alt_pipe.to(lowerCAmelCase_)
      alt_pipe.set_progress_bar_config(disable=lowerCAmelCase_)

      lowercase_								= """A painting of a squirrel eating a burger"""
      lowercase_								= torch.Generator(device=lowerCAmelCase_).manual_seed(0)
      lowercase_								= alt_pipe(
          [prompt] ,  generator=lowerCAmelCase_ ,  guidance_scale=6.0 ,  num_inference_steps=2 ,  output_type="""np""" ,  image=lowerCAmelCase_ ,  )

      lowercase_								= output.images

      lowercase_								= torch.Generator(device=lowerCAmelCase_).manual_seed(0)
      lowercase_								= alt_pipe(
          [prompt] ,  generator=lowerCAmelCase_ ,  guidance_scale=6.0 ,  num_inference_steps=2 ,  output_type="""np""" ,  image=lowerCAmelCase_ ,  return_dict=lowerCAmelCase_ ,  )[0]

      lowercase_								= image[0, -3:, -3:, -1]
      lowercase_								= image_from_tuple[0, -3:, -3:, -1]

      assert image.shape == (1, 3_2, 3_2, 3)
      lowercase_								= np.array([0.4_427, 0.3_731, 0.4_249, 0.4_941, 0.4_546, 0.4_148, 0.4_193, 0.4_666, 0.4_499])

      assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3
      assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3

    @unittest.skipIf(torch_device != """cuda""" ,  """This test requires a GPU""")
    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      lowercase_								= self.dummy_cond_unet
      lowercase_								= PNDMScheduler(skip_prk_steps=lowerCAmelCase_)
      lowercase_								= self.dummy_vae
      lowercase_								= self.dummy_text_encoder
      lowercase_								= XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta""")
      lowercase_								= 7_7

      lowercase_								= self.dummy_image.to(lowerCAmelCase_)

      # put models in fp16
      lowercase_								= unet.half()
      lowercase_								= vae.half()
      lowercase_								= bert.half()

      # make sure here that pndm scheduler skips prk
      lowercase_								= AltDiffusionImgaImgPipeline(
          unet=lowerCAmelCase_ ,  scheduler=lowerCAmelCase_ ,  vae=lowerCAmelCase_ ,  text_encoder=lowerCAmelCase_ ,  tokenizer=lowerCAmelCase_ ,  safety_checker=lowerCAmelCase_ ,  feature_extractor=self.dummy_extractor ,  )
      lowercase_								= VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor ,  do_normalize=lowerCAmelCase_)
      lowercase_								= alt_pipe.to(lowerCAmelCase_)
      alt_pipe.set_progress_bar_config(disable=lowerCAmelCase_)

      lowercase_								= """A painting of a squirrel eating a burger"""
      lowercase_								= torch.manual_seed(0)
      lowercase_								= alt_pipe(
          [prompt] ,  generator=lowerCAmelCase_ ,  num_inference_steps=2 ,  output_type="""np""" ,  image=lowerCAmelCase_ ,  ).images

      assert image.shape == (1, 3_2, 3_2, 3)




    @unittest.skipIf(torch_device != """cuda""" ,  """This test requires a GPU""")
    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      lowercase_								= load_image(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
          """/img2img/sketch-mountains-input.jpg""")
      # resize to resolution that is divisible by 8 but not 16 or 32
      lowercase_								= init_image.resize((7_6_0, 5_0_4))

      lowercase_								= """BAAI/AltDiffusion"""
      lowercase_								= AltDiffusionImgaImgPipeline.from_pretrained(
          lowerCAmelCase_ ,  safety_checker=lowerCAmelCase_ ,  )
      pipe.to(lowerCAmelCase_)
      pipe.set_progress_bar_config(disable=lowerCAmelCase_)
      pipe.enable_attention_slicing()

      lowercase_								= """A fantasy landscape, trending on artstation"""

      lowercase_								= torch.manual_seed(0)
      lowercase_								= pipe(
          prompt=lowerCAmelCase_ ,  image=lowerCAmelCase_ ,  strength=0.75 ,  guidance_scale=7.5 ,  generator=lowerCAmelCase_ ,  output_type="""np""" ,  )
      lowercase_								= output.images[0]

      lowercase_								= image[2_5_5:2_5_8, 3_8_3:3_8_6, -1]

      assert image.shape == (5_0_4, 7_6_0, 3)
      lowercase_								= np.array([0.9_358, 0.9_397, 0.9_599, 0.9_901, 1.0_000, 1.0_000, 0.9_882, 1.0_000, 1.0_000])

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







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

    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()




    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      lowercase_								= load_image(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
          """/img2img/sketch-mountains-input.jpg""")
      lowercase_								= init_image.resize((7_6_8, 5_1_2))
      lowercase_								= load_numpy(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy""")

      lowercase_								= """BAAI/AltDiffusion"""
      lowercase_								= AltDiffusionImgaImgPipeline.from_pretrained(
          lowerCAmelCase_ ,  safety_checker=lowerCAmelCase_ ,  )
      pipe.to(lowerCAmelCase_)
      pipe.set_progress_bar_config(disable=lowerCAmelCase_)
      pipe.enable_attention_slicing()

      lowercase_								= """A fantasy landscape, trending on artstation"""

      lowercase_								= torch.manual_seed(0)
      lowercase_								= pipe(
          prompt=lowerCAmelCase_ ,  image=lowerCAmelCase_ ,  strength=0.75 ,  guidance_scale=7.5 ,  generator=lowerCAmelCase_ ,  output_type="""np""" ,  )
      lowercase_								= output.images[0]

      assert image.shape == (5_1_2, 7_6_8, 3)
      # img2img is flaky across GPUs even in fp32, so using MAE here
      assert np.abs(expected_image - image).max() < 1E-2






"""simple docstring"""
def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase=2_81_23							) ->						Optional[Any]:







  '''simple docstring'''


  lowercase_								= [1] * (limit + 1)

  for i in range(2 ,  int(limit**0.5							) + 1							):
    sum_divs[i * i] += i
    for k in range(i + 1 ,  limit // i + 1							):
      sum_divs[k * i] += k + i

  lowercase_								= set()
  lowercase_								= 0

  for n in range(1 ,  limit + 1							):
    if sum_divs[n] > n:
      abundants.add(__lowerCAmelCase							)

    if not any((n - a in abundants) for a in abundants							):
      res += n

  return res


if __name__ == "__main__":
       print(solution())

