





'''simple docstring'''




import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()


class 					SCREAMING_SNAKE_CASE       (a__   ,						a__   ,						a__   ,						unittest.TestCase				):
     lowerCAmelCase						     =			StableUnCLIPImgaImgPipeline
     lowerCAmelCase						     =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS
     lowerCAmelCase						     =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     lowerCAmelCase						     =			frozenset(
         []				)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
     lowerCAmelCase						     =			frozenset([]				)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Dict						=			32
          __A		:					List[str]						=			embedder_hidden_size

          # image encoding components

          __A		:					List[Any]						=			CLIPImageProcessor(crop_size=32		,      size=32)

          torch.manual_seed(0)
          __A		:					Optional[int]						=			CLIPVisionModelWithProjection(
              CLIPVisionConfig(
                  hidden_size=_UpperCAmelCase		,      projection_dim=_UpperCAmelCase		,      num_hidden_layers=5		,      num_attention_heads=4		,      image_size=32		,      intermediate_size=37		,      patch_size=1		,      ))

          # regular denoising components

          torch.manual_seed(0)
          __A		:					Union[str, Any]						=			StableUnCLIPImageNormalizer(embedding_dim=_UpperCAmelCase)
          __A		:					Dict						=			DDPMScheduler(beta_schedule='squaredcos_cap_v2')

          torch.manual_seed(0)
          __A		:					List[Any]						=			CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

          torch.manual_seed(0)
          __A		:					Union[str, Any]						=			CLIPTextModel(
              CLIPTextConfig(
                  bos_token_id=0		,      eos_token_id=2		,      hidden_size=_UpperCAmelCase		,      projection_dim=32		,      intermediate_size=37		,      layer_norm_eps=1e-0_5		,      num_attention_heads=4		,      num_hidden_layers=5		,      pad_token_id=1		,      vocab_size=1000		,      ))

          torch.manual_seed(0)
          __A		:					Dict						=			UNetaDConditionModel(
              sample_size=32		,      in_channels=4		,      out_channels=4		,      down_block_types=('CrossAttnDownBlock2D', 'DownBlock2D')		,      up_block_types=('UpBlock2D', 'CrossAttnUpBlock2D')		,      block_out_channels=(32, 64)		,      attention_head_dim=(2, 4)		,      class_embed_type='projection'		,      projection_class_embeddings_input_dim=embedder_projection_dim * 2		,      cross_attention_dim=_UpperCAmelCase		,      layers_per_block=1		,      upcast_attention=_UpperCAmelCase		,      use_linear_projection=_UpperCAmelCase		,      )

          torch.manual_seed(0)
          __A		:					Union[str, Any]						=			DDIMScheduler(
              beta_schedule='scaled_linear'		,      beta_start=0.00085		,      beta_end=0.012		,      prediction_type='v_prediction'		,      set_alpha_to_one=_UpperCAmelCase		,      steps_offset=1		,      )

          torch.manual_seed(0)
          __A		:					Any						=			AutoencoderKL()

          __A		:					List[str]						=			{
              # image encoding components
              'feature_extractor': feature_extractor,
              'image_encoder': image_encoder.eval(),
              # image noising components
              'image_normalizer': image_normalizer.eval(),
              'image_noising_scheduler': image_noising_scheduler,
              # regular denoising components
              'tokenizer': tokenizer,
              'text_encoder': text_encoder.eval(),
              'unet': unet.eval(),
              'scheduler': scheduler,
              'vae': vae.eval(),
          }

          return components


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase=0		,      _UpperCAmelCase=True):

          '''simple docstring'''






          if str(_UpperCAmelCase).startswith('mps'):
               __A		:					Tuple						=			torch.manual_seed(_UpperCAmelCase)
          else:
               __A		:					Any						=			torch.Generator(device=_UpperCAmelCase).manual_seed(_UpperCAmelCase)

          __A		:					str						=			floats_tensor((1, 3, 32, 32)		,      rng=random.Random(_UpperCAmelCase)).to(_UpperCAmelCase)

          if pil_image:
               __A		:					List[Any]						=			input_image * 0.5 + 0.5
               __A		:					Dict						=			input_image.clamp(0		,      1)
               __A		:					Optional[int]						=			input_image.cpu().permute(0		,      2		,      3		,      1).float().numpy()
               __A		:					Tuple						=			DiffusionPipeline.numpy_to_pil(_UpperCAmelCase)[0]

          return {
              "prompt": "An anime racoon running a marathon",
              "image": input_image,
              "generator": generator,
              "num_inference_steps": 2,
              "output_type": "np",
          }


     @skip_mps
     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Union[str, Any]						=			'cpu'  # ensure determinism for the device-dependent torch.Generator
          __A		:					Union[str, Any]						=			self.get_dummy_components()
          __A		:					Dict						=			StableUnCLIPImgaImgPipeline(**_UpperCAmelCase)
          __A		:					Dict						=			sd_pipe.to(_UpperCAmelCase)
          sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase)

          __A		:					Dict						=			self.get_dummy_inputs(_UpperCAmelCase)
          inputs.update({'image_embeds': None})
          __A		:					Any						=			sd_pipe(**_UpperCAmelCase).images
          __A		:					Optional[Any]						=			image[0, -3:, -3:, -1]

          assert image.shape == (1, 32, 32, 3)
          __A		:					List[Any]						=			np.array([0.3872, 0.7224, 0.5601, 0.4741, 0.6872, 0.5814, 0.4636, 0.3867, 0.5078])

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					List[Any]						=			torch_device in ['cpu', 'mps']

          self._test_attention_slicing_forward_pass(test_max_difference=_UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					List[str]						=			torch_device in ['cpu', 'mps']

          self._test_inference_batch_single_identical(test_max_difference=_UpperCAmelCase)


     @unittest.skipIf(
         torch_device != 'cuda' or not is_xformers_available()		,      reason='XFormers attention is only available with CUDA and `xformers` installed'		,      )
     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          self._test_xformers_attention_forwardGenerator_pass(test_max_difference=_UpperCAmelCase)




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


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






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


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Tuple						=			load_image(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png')

          __A		:					Optional[int]						=			load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy')

          __A		:					Any						=			StableUnCLIPImgaImgPipeline.from_pretrained(
              'fusing/stable-unclip-2-1-l-img2img'		,      torch_dtype=torch.floataa)
          pipe.to(_UpperCAmelCase)
          pipe.set_progress_bar_config(disable=_UpperCAmelCase)
          # stable unclip will oom when integration tests are run on a V100,
          # so turn on memory savings
          pipe.enable_attention_slicing()
          pipe.enable_sequential_cpu_offload()

          __A		:					Optional[Any]						=			torch.Generator(device='cpu').manual_seed(0)
          __A		:					Dict						=			pipe(_UpperCAmelCase		,      'anime turle'		,      generator=_UpperCAmelCase		,      output_type='np')

          __A		:					Dict						=			output.images[0]

          assert image.shape == (768, 768, 3)

          assert_mean_pixel_difference(_UpperCAmelCase		,      _UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[int]						=			load_image(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png')

          __A		:					List[Any]						=			load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy')

          __A		:					Optional[Any]						=			StableUnCLIPImgaImgPipeline.from_pretrained(
              'fusing/stable-unclip-2-1-h-img2img'		,      torch_dtype=torch.floataa)
          pipe.to(_UpperCAmelCase)
          pipe.set_progress_bar_config(disable=_UpperCAmelCase)
          # stable unclip will oom when integration tests are run on a V100,
          # so turn on memory savings
          pipe.enable_attention_slicing()
          pipe.enable_sequential_cpu_offload()

          __A		:					str						=			torch.Generator(device='cpu').manual_seed(0)
          __A		:					Any						=			pipe(_UpperCAmelCase		,      'anime turle'		,      generator=_UpperCAmelCase		,      output_type='np')

          __A		:					List[str]						=			output.images[0]

          assert image.shape == (768, 768, 3)

          assert_mean_pixel_difference(_UpperCAmelCase		,      _UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Any						=			load_image(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png')

          torch.cuda.empty_cache()
          torch.cuda.reset_max_memory_allocated()
          torch.cuda.reset_peak_memory_stats()

          __A		:					Optional[Any]						=			StableUnCLIPImgaImgPipeline.from_pretrained(
              'fusing/stable-unclip-2-1-h-img2img'		,      torch_dtype=torch.floataa)
          __A		:					int						=			pipe.to(_UpperCAmelCase)
          pipe.set_progress_bar_config(disable=_UpperCAmelCase)
          pipe.enable_attention_slicing()
          pipe.enable_sequential_cpu_offload()

          __A		:					Optional[int]						=			pipe(
              _UpperCAmelCase		,      'anime turtle'		,      num_inference_steps=2		,      output_type='np'		,      )

          __A		:					Optional[int]						=			torch.cuda.max_memory_allocated()
          # make sure that less than 7 GB is allocated
          assert mem_bytes < 7 * 10**9







"""simple docstring"""
from __future__ import annotations

from decimal import Decimal
from math import *  # noqa: F403

from sympy import diff






def       __UpperCamelCase						(		snake_case__ , snake_case__ , snake_case__ = 10**-10       ):
	A_		:    Tuple						     = a
	while True:
		A_		:    List[str]						     = Decimal(snake_case__       ) - (
		    Decimal(eval(snake_case__       )       ) / Decimal(eval(str(diff(snake_case__       )       )       )       )  # noqa: S307
		)
		# This number dictates the accuracy of the answer
		if abs(eval(snake_case__       )       ) < precision:  # noqa: S307
			return float(snake_case__       )


# Let's Execute
if __name__ == "__main__":
							# Find root of trigonometric function
							# Find value of pi
							print(F'The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}')
							# Find root of polynomial
							print(F'The root of x**2 - 5*x + 2 = 0 is {newton_raphson("x**2 - 5*x + 2", 0.4)}')
							# Find Square Root of 5
							print(F'The root of log(x) - 1 = 0 is {newton_raphson("log(x) - 1", 2)}')
							# Exponential Roots
							print(F'The root of exp(x) - 1 = 0 is {newton_raphson("exp(x) - 1", 0)}')

