






import math


def 				snake_case__							(							UpperCAmelCase							:  float    ,			UpperCAmelCase							:  float       ):
    return math.pow(UpperCAmelCase    ,			2       ) - a


def 				snake_case__							(							UpperCAmelCase							:  float       ):
    return 2 * x


def 				snake_case__							(							UpperCAmelCase							:  float       ):
    lowerCAmelCase__   :Optional[int]      							=				2.0

    while start <= a:
        lowerCAmelCase__   :Tuple      							=				math.pow(UpperCAmelCase    ,			2       )

    return start


def 				snake_case__							(							UpperCAmelCase							:  float    ,			UpperCAmelCase							:  int = 9_9_9_9    ,			UpperCAmelCase							:  float = 0.00000000000001       ):

    if a < 0:
        raise ValueError("math domain error"       )

    lowerCAmelCase__   :List[str]      							=				get_initial_point(UpperCAmelCase       )

    for _ in range(UpperCAmelCase       ):
        lowerCAmelCase__   :List[str]      							=				value
        lowerCAmelCase__   :List[str]      							=				value - fx(UpperCAmelCase    ,			UpperCAmelCase       ) / fx_derivative(UpperCAmelCase       )
        if abs(prev_value - value       ) < tolerance:
            return value

    return value


if __name__ == "__main__":
 from doctest import testmod

 testmod()











import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference







class 	_UpperCAmelCase  (  _A				,							unittest.TestCase		):




      """simple docstring"""



      A          =    ShapEImgaImgPipeline
      A          =    ['''image''']
      A          =    ['''image''']
      A          =    [
          '''num_images_per_prompt''',
          '''num_inference_steps''',
          '''generator''',
          '''latents''',
          '''guidance_scale''',
          '''frame_size''',
          '''output_type''',
          '''return_dict''',
      ]
      A          =    False
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          return 32
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          return 32
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          return self.time_input_dim * 4
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          return 8
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          torch.manual_seed(0		)
          lowerCAmelCase__   :Any      							=				CLIPVisionConfig(
              hidden_size=self.text_embedder_hidden_size    ,	image_size=64    ,	projection_dim=self.text_embedder_hidden_size    ,	intermediate_size=37    ,	num_attention_heads=4    ,	num_channels=3    ,	num_hidden_layers=5    ,	patch_size=1    ,	)

          lowerCAmelCase__   :int      							=				CLIPVisionModel(_lowerCAmelCase		)
          return model
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          lowerCAmelCase__   :List[str]      							=				CLIPImageProcessor(
              crop_size=224    ,	do_center_crop=_lowerCAmelCase    ,	do_normalize=_lowerCAmelCase    ,	do_resize=_lowerCAmelCase    ,	image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]    ,	image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]    ,	resample=3    ,	size=224    ,	)

          return image_processor
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          torch.manual_seed(0		)

          lowerCAmelCase__   :Any      							=				{
              "num_attention_heads": 2,
              "attention_head_dim": 16,
              "embedding_dim": self.time_input_dim,
              "num_embeddings": 32,
              "embedding_proj_dim": self.text_embedder_hidden_size,
              "time_embed_dim": self.time_embed_dim,
              "num_layers": 1,
              "clip_embed_dim": self.time_input_dim * 2,
              "additional_embeddings": 0,
              "time_embed_act_fn": "gelu",
              "norm_in_type": "layer",
              "embedding_proj_norm_type": "layer",
              "encoder_hid_proj_type": None,
              "added_emb_type": None,
          }

          lowerCAmelCase__   :int      							=				PriorTransformer(**_lowerCAmelCase		)
          return model
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          torch.manual_seed(0		)

          lowerCAmelCase__   :List[Any]      							=				{
              "param_shapes": (
                  (self.renderer_dim, 93),
                  (self.renderer_dim, 8),
                  (self.renderer_dim, 8),
                  (self.renderer_dim, 8),
              ),
              "d_latent": self.time_input_dim,
              "d_hidden": self.renderer_dim,
              "n_output": 12,
              "background": (
                  0.1,
                  0.1,
                  0.1,
              ),
          }
          lowerCAmelCase__   :str      							=				ShapERenderer(**_lowerCAmelCase		)
          return model
      def 			snake_case_      (   self		):



          '''simple docstring'''
          lowerCAmelCase__   :Any      							=				self.dummy_prior
          lowerCAmelCase__   :str      							=				self.dummy_image_encoder
          lowerCAmelCase__   :Optional[Any]      							=				self.dummy_image_processor
          lowerCAmelCase__   :Union[str, Any]      							=				self.dummy_renderer

          lowerCAmelCase__   :str      							=				HeunDiscreteScheduler(
              beta_schedule="exp"    ,	num_train_timesteps=1_024    ,	prediction_type="sample"    ,	use_karras_sigmas=_lowerCAmelCase    ,	clip_sample=_lowerCAmelCase    ,	clip_sample_range=1.0    ,	)
          lowerCAmelCase__   :Any      							=				{
              "prior": prior,
              "image_encoder": image_encoder,
              "image_processor": image_processor,
              "renderer": renderer,
              "scheduler": scheduler,
          }

          return components
      def 			snake_case_      (   self    ,	_lowerCAmelCase    ,	_lowerCAmelCase=0		):



          '''simple docstring'''
          lowerCAmelCase__   :List[Any]      							=				floats_tensor((1, 3, 64, 64)    ,	rng=random.Random(_lowerCAmelCase		)		).to(_lowerCAmelCase		)

          if str(_lowerCAmelCase		).startswith("mps"		):
              lowerCAmelCase__   :Dict      							=				torch.manual_seed(_lowerCAmelCase		)
          else:
              lowerCAmelCase__   :str      							=				torch.Generator(device=_lowerCAmelCase		).manual_seed(_lowerCAmelCase		)
          lowerCAmelCase__   :Tuple      							=				{
              "image": input_image,
              "generator": generator,
              "num_inference_steps": 1,
              "frame_size": 32,
              "output_type": "np",
          }
          return inputs
      def 			snake_case_      (   self		):



          '''simple docstring'''
          lowerCAmelCase__   :Optional[int]      							=				"cpu"

          lowerCAmelCase__   :Union[str, Any]      							=				self.get_dummy_components()

          lowerCAmelCase__   :Union[str, Any]      							=				self.pipeline_class(**_lowerCAmelCase		)
          lowerCAmelCase__   :Optional[int]      							=				pipe.to(_lowerCAmelCase		)

          pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

          lowerCAmelCase__   :int      							=				pipe(**self.get_dummy_inputs(_lowerCAmelCase		)		)
          lowerCAmelCase__   :List[Any]      							=				output.images[0]
          lowerCAmelCase__   :List[Any]      							=				image[0, -3:, -3:, -1]

          assert image.shape == (20, 32, 32, 3)

          lowerCAmelCase__   :str      							=				np.array(
              [
                  0.0003_9216,
                  0.0003_9216,
                  0.0003_9216,
                  0.0003_9216,
                  0.0003_9216,
                  0.0003_9216,
                  0.0003_9216,
                  0.0003_9216,
                  0.0003_9216,
              ]		)

          assert np.abs(image_slice.flatten() - expected_slice		).max() < 1e-2
      def 			snake_case_      (   self		):



          '''simple docstring'''
          # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
          self._test_inference_batch_consistent(batch_sizes=[1, 2]		)
      def 			snake_case_      (   self		):



          '''simple docstring'''
          lowerCAmelCase__   :Any      							=				torch_device == "cpu"
          lowerCAmelCase__   :Tuple      							=				True
          self._test_inference_batch_single_identical(
              batch_size=2    ,	test_max_difference=_lowerCAmelCase    ,	relax_max_difference=_lowerCAmelCase    ,	)



      def 			snake_case_      (   self		):



          '''simple docstring'''
          lowerCAmelCase__   :List[str]      							=				self.get_dummy_components()
          lowerCAmelCase__   :Tuple      							=				self.pipeline_class(**_lowerCAmelCase		)
          lowerCAmelCase__   :Optional[Any]      							=				pipe.to(_lowerCAmelCase		)
          pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

          lowerCAmelCase__   :Tuple      							=				1
          lowerCAmelCase__   :List[Any]      							=				2

          lowerCAmelCase__   :List[str]      							=				self.get_dummy_inputs(_lowerCAmelCase		)

          for key in inputs.keys():
              if key in self.batch_params:
                  lowerCAmelCase__   :Any      							=				batch_size * [inputs[key]]

          lowerCAmelCase__   :Optional[Any]      							=				pipe(**_lowerCAmelCase    ,	num_images_per_prompt=_lowerCAmelCase		)[0]

          assert images.shape[0] == batch_size * num_images_per_prompt







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




      """simple docstring"""



      def 			snake_case_      (   self		):



          '''simple docstring'''
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()



      def 			snake_case_      (   self		):



          '''simple docstring'''
          lowerCAmelCase__   :Optional[Any]      							=				load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/shap_e/corgi.png"		)
          lowerCAmelCase__   :int      							=				load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/shap_e/test_shap_e_img2img_out.npy"		)
          lowerCAmelCase__   :Optional[int]      							=				ShapEImgaImgPipeline.from_pretrained("openai/shap-e-img2img"		)
          lowerCAmelCase__   :Tuple      							=				pipe.to(_lowerCAmelCase		)
          pipe.set_progress_bar_config(disable=_lowerCAmelCase		)

          lowerCAmelCase__   :Any      							=				torch.Generator(device=_lowerCAmelCase		).manual_seed(0		)

          lowerCAmelCase__   :List[Any]      							=				pipe(
              _lowerCAmelCase    ,	generator=_lowerCAmelCase    ,	guidance_scale=3.0    ,	num_inference_steps=64    ,	frame_size=64    ,	output_type="np"    ,	).images[0]

          assert images.shape == (20, 64, 64, 3)

          assert_mean_pixel_difference(_lowerCAmelCase    ,	_lowerCAmelCase		)



