


'''simple docstring'''







import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import 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  lowerCAmelCase_						(       snake_case__		,    unittest.TestCase      ):





		"""simple docstring"""



		a_       :Any												=ShapEPipeline
		a_       :Union[str, Any]												=["""prompt"""]
		a_       :Union[str, Any]												=["""prompt"""]
		a_       :Dict												=[
		    """num_images_per_prompt""",
		    """num_inference_steps""",
		    """generator""",
		    """latents""",
		    """guidance_scale""",
		    """frame_size""",
		    """output_type""",
		    """return_dict""",
		]
		a_       :Optional[int]												=False

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





							'''simple docstring'''

							return 3_2

		@property
		def __a						(					self     :							Tuple						):





							'''simple docstring'''

							return 3_2

		@property
		def __a						(					self     :							List[Any]						):





							'''simple docstring'''

							return self.time_input_dim * 4

		@property
		def __a						(					self     :							Any						):





							'''simple docstring'''

							return 8

		@property
		def __a						(					self     :							List[Any]						):





							'''simple docstring'''

							__a       =   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)
							return tokenizer

		@property
		def __a						(					self     :							Optional[int]						):





							'''simple docstring'''

							torch.manual_seed(0						)
							__a       =   CLIPTextConfig(
							    bos_token_id=0				,							eos_token_id=2				,							hidden_size=self.text_embedder_hidden_size				,							projection_dim=self.text_embedder_hidden_size				,							intermediate_size=3_7				,							layer_norm_eps=1E-05				,							num_attention_heads=4				,							num_hidden_layers=5				,							pad_token_id=1				,							vocab_size=1_0_0_0				,							)
							return CLIPTextModelWithProjection(SCREAMING_SNAKE_CASE__						)

		@property
		def __a						(					self     :							Any						):





							'''simple docstring'''

							torch.manual_seed(0						)

							__a       =   {
							    """num_attention_heads""": 2,
							    """attention_head_dim""": 1_6,
							    """embedding_dim""": self.time_input_dim,
							    """num_embeddings""": 3_2,
							    """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""",
							    """encoder_hid_proj_type""": None,
							    """added_emb_type""": None,
							}

							__a       =   PriorTransformer(**SCREAMING_SNAKE_CASE__						)
							return model

		@property
		def __a						(					self     :							int						):





							'''simple docstring'''

							torch.manual_seed(0						)

							__a       =   {
							    """param_shapes""": (
							        (self.renderer_dim, 9_3),
							        (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""": 1_2,
							    """background""": (
							        0.1,
							        0.1,
							        0.1,
							    ),
							}
							__a       =   ShapERenderer(**SCREAMING_SNAKE_CASE__						)
							return model

		def __a						(					self     :							Dict						):





							'''simple docstring'''

							__a       =   self.dummy_prior
							__a       =   self.dummy_text_encoder
							__a       =   self.dummy_tokenizer
							__a       =   self.dummy_renderer

							__a       =   HeunDiscreteScheduler(
							    beta_schedule="""exp"""				,							num_train_timesteps=1_0_2_4				,							prediction_type="""sample"""				,							use_karras_sigmas=SCREAMING_SNAKE_CASE__				,							clip_sample=SCREAMING_SNAKE_CASE__				,							clip_sample_range=1.0				,							)
							__a       =   {
							    """prior""": prior,
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							    """renderer""": renderer,
							    """scheduler""": scheduler,
							}

							return components

		def __a						(					self     :							Optional[Any]				,							SCREAMING_SNAKE_CASE__     :							Optional[Any]				,							SCREAMING_SNAKE_CASE__     :							int=0						):





							'''simple docstring'''

							if str(SCREAMING_SNAKE_CASE__						).startswith("""mps"""						):
												__a       =   torch.manual_seed(SCREAMING_SNAKE_CASE__						)
							else:
												__a       =   torch.Generator(device=SCREAMING_SNAKE_CASE__						).manual_seed(SCREAMING_SNAKE_CASE__						)
							__a       =   {
							    """prompt""": """horse""",
							    """generator""": generator,
							    """num_inference_steps""": 1,
							    """frame_size""": 3_2,
							    """output_type""": """np""",
							}
							return inputs

		def __a						(					self     :							Dict						):





							'''simple docstring'''

							__a       =   """cpu"""

							__a       =   self.get_dummy_components()

							__a       =   self.pipeline_class(**SCREAMING_SNAKE_CASE__						)
							__a       =   pipe.to(SCREAMING_SNAKE_CASE__						)

							pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__						)

							__a       =   pipe(**self.get_dummy_inputs(SCREAMING_SNAKE_CASE__						)						)
							__a       =   output.images[0]
							__a       =   image[0, -3:, -3:, -1]

							assert image.shape == (2_0, 3_2, 3_2, 3)

							__a       =   np.array(
							    [
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							        0.0_0_0_3_9_2_1_6,
							    ]						)

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

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





							'''simple docstring'''

							self._test_inference_batch_consistent(batch_sizes=[1, 2]						)

		def __a						(					self     :							Dict						):





							'''simple docstring'''

							__a       =   torch_device == """cpu"""
							__a       =   True

							self._test_inference_batch_single_identical(
							    batch_size=2				,							test_max_difference=SCREAMING_SNAKE_CASE__				,							relax_max_difference=SCREAMING_SNAKE_CASE__				,							)


		def __a						(					self     :							List[Any]						):





							'''simple docstring'''

							__a       =   self.get_dummy_components()
							__a       =   self.pipeline_class(**SCREAMING_SNAKE_CASE__						)
							__a       =   pipe.to(SCREAMING_SNAKE_CASE__						)
							pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__						)

							__a       =   1
							__a       =   2

							__a       =   self.get_dummy_inputs(SCREAMING_SNAKE_CASE__						)

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

							__a       =   pipe(**SCREAMING_SNAKE_CASE__				,							num_images_per_prompt=SCREAMING_SNAKE_CASE__						)[0]

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


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





		"""simple docstring"""



		def __a						(					self     :							List[Any]						):





							'''simple docstring'''

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


		def __a						(					self     :							Optional[int]						):





							'''simple docstring'''

							__a       =   load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
							    """/shap_e/test_shap_e_np_out.npy"""						)
							__a       =   ShapEPipeline.from_pretrained("""openai/shap-e"""						)
							__a       =   pipe.to(SCREAMING_SNAKE_CASE__						)
							pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__						)

							__a       =   torch.Generator(device=SCREAMING_SNAKE_CASE__						).manual_seed(0						)

							__a       =   pipe(
							    """a shark"""				,							generator=SCREAMING_SNAKE_CASE__				,							guidance_scale=1_5.0				,							num_inference_steps=6_4				,							frame_size=6_4				,							output_type="""np"""				,							).images[0]

							assert images.shape == (2_0, 6_4, 6_4, 3)

							assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__						)










'''simple docstring'''







import math
import random
from typing import Any

from .hill_climbing import SearchProblem




def        __lowercase						(      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE = True				,  __SCREAMING_SNAKE_CASE = math.inf				,  __SCREAMING_SNAKE_CASE = -math.inf				,  __SCREAMING_SNAKE_CASE = math.inf				,  __SCREAMING_SNAKE_CASE = -math.inf				,  __SCREAMING_SNAKE_CASE = False				,  __SCREAMING_SNAKE_CASE = 100				,  __SCREAMING_SNAKE_CASE = 0.01				,  __SCREAMING_SNAKE_CASE = 1				,  )				->					Any:
     """simple docstring"""




     __a       =   False
     __a       =   search_prob
     __a       =   start_temperate
     __a       =   []
     __a       =   0
     __a       =   None

     while not search_end:
          __a       =   current_state.score()
          if best_state is None or current_score > best_state.score():
               __a       =   current_state
          scores.append(__SCREAMING_SNAKE_CASE		)
          iterations += 1
          __a       =   None
          __a       =   current_state.get_neighbors()
          while (
              next_state is None and neighbors
          ):  # till we do not find a neighbor that we can move to
               __a       =   random.randint(0				,  len(__SCREAMING_SNAKE_CASE		) - 1		)  # picking a random neighbor
               __a       =   neighbors.pop(__SCREAMING_SNAKE_CASE		)
               __a       =   picked_neighbor.score() - current_score

               if (
                   picked_neighbor.x > max_x
                   or picked_neighbor.x < min_x
                   or picked_neighbor.y > max_y
                   or picked_neighbor.y < min_y
               ):
                    continue  # neighbor outside our bounds

               if not find_max:
                    __a       =   change * -1  # in case we are finding minimum
               if change > 0:  # improves the solution
                    __a       =   picked_neighbor
               else:
                    __a       =   (math.e) ** (
                        change / current_temp
                    )  # probability generation function
                    if random.random() < probability:  # random number within probability
                         __a       =   picked_neighbor
          __a       =   current_temp - (current_temp * rate_of_decrease)

          if current_temp < threshold_temp or next_state is None:
               # temperature below threshold, or could not find a suitable neighbor
               __a       =   True
          else:
               __a       =   next_state

     if visualization:
          from matplotlib import pyplot as plt

          plt.plot(range(__SCREAMING_SNAKE_CASE		)				,  __SCREAMING_SNAKE_CASE		)
          plt.xlabel("""Iterations"""		)
          plt.ylabel("""Function values"""		)
          plt.show()
     return best_state


if __name__ == "__main__":




 def        __lowercase						(      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE		)				->					int:
      """simple docstring"""




      return (x**2) + (y**2)

 # starting the problem with initial coordinates (12, 47)
 SCREAMING_SNAKE_CASE_      =			SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa)
 SCREAMING_SNAKE_CASE_      =			simulated_annealing(
     prob, find_max=False, max_x=1_00, min_x=5, max_y=50, min_y=-5, visualization=True
 )
 print(
     'The minimum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 '
     f"""and 50 > y > - 5 found via hill climbing: {local_min.score()}"""
 )

 # starting the problem with initial coordinates (12, 47)
 SCREAMING_SNAKE_CASE_      =			SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa)
 SCREAMING_SNAKE_CASE_      =			simulated_annealing(
     prob, find_max=True, max_x=1_00, min_x=5, max_y=50, min_y=-5, visualization=True
 )
 print(
     'The maximum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 '
     f"""and 50 > y > - 5 found via hill climbing: {local_min.score()}"""
 )




 def        __lowercase						(      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE		)				->					int:
      """simple docstring"""




      return (3 * x**2) - (6 * y)

 SCREAMING_SNAKE_CASE_      =			SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
 SCREAMING_SNAKE_CASE_      =			simulated_annealing(prob, find_max=False, visualization=True)
 print(
     'The minimum score for f(x, y) = 3*x^2 - 6*y found via hill climbing: '
     f"""{local_min.score()}"""
 )

 SCREAMING_SNAKE_CASE_      =			SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
 SCREAMING_SNAKE_CASE_      =			simulated_annealing(prob, find_max=True, visualization=True)



 print(
     'The maximum score for f(x, y) = 3*x^2 - 6*y found via hill climbing: '
     f"""{local_min.score()}"""
 )






