


"""simple docstring"""






import os
import sys
import unittest


__snake_case		=       os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
__snake_case		=       os.path.join(git_repo_path, '''src''', '''diffusers''')


class     __lowerCamelCase  (					unittest.TestCase				):

     '''simple docstring'''


     def 							_UpperCAmelCase      (      self							)       ->							Any:
          _a    	=				find_backend('''    if not is_torch_available():'''							)
          self.assertEqual(__UpperCAmelCase    ,				'''torch'''							)

          # backend_with_underscore = find_backend("    if not is_tensorflow_text_available():")
          # self.assertEqual(backend_with_underscore, "tensorflow_text")

          _a    	=				find_backend('''    if not (is_torch_available() and is_transformers_available()):'''							)
          self.assertEqual(__UpperCAmelCase    ,				'''torch_and_transformers'''							)

          # double_backend_with_underscore = find_backend(
          #    "    if not (is_sentencepiece_available() and is_tensorflow_text_available()):"
          # )
          # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text")

          _a    	=				find_backend(
              '''    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):'''							)
          self.assertEqual(__UpperCAmelCase    ,				'''torch_and_transformers_and_onnx'''							)


     def 							_UpperCAmelCase      (      self							)       ->							List[Any]:
          _a    	=				read_init()
          # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
          self.assertIn('''torch'''    ,				__UpperCAmelCase							)
          self.assertIn('''torch_and_transformers'''    ,				__UpperCAmelCase							)
          self.assertIn('''flax_and_transformers'''    ,				__UpperCAmelCase							)
          self.assertIn('''torch_and_transformers_and_onnx'''    ,				__UpperCAmelCase							)

          # Likewise, we can't assert on the exact content of a key
          self.assertIn('''UNet2DModel'''    ,				objects['''torch''']							)
          self.assertIn('''FlaxUNet2DConditionModel'''    ,				objects['''flax''']							)
          self.assertIn('''StableDiffusionPipeline'''    ,				objects['''torch_and_transformers''']							)
          self.assertIn('''FlaxStableDiffusionPipeline'''    ,				objects['''flax_and_transformers''']							)
          self.assertIn('''LMSDiscreteScheduler'''    ,				objects['''torch_and_scipy''']							)
          self.assertIn('''OnnxStableDiffusionPipeline'''    ,				objects['''torch_and_transformers_and_onnx''']							)


     def 							_UpperCAmelCase      (      self							)       ->							str:
          _a    	=				create_dummy_object('''CONSTANT'''    ,				'''\'torch\''''							)
          self.assertEqual(__UpperCAmelCase    ,				'''\nCONSTANT = None\n'''							)

          _a    	=				create_dummy_object('''function'''    ,				'''\'torch\''''							)
          self.assertEqual(
              __UpperCAmelCase    ,				'''\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n'''							)

          _a    	=				'''
class FakeClass(metaclass=DummyObject):
    _backends = \'torch\'

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, \'torch\')

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, \'torch\')
'''
          _a    	=				create_dummy_object('''FakeClass'''    ,				'''\'torch\''''							)
          self.assertEqual(__UpperCAmelCase    ,				__UpperCAmelCase							)





     def 							_UpperCAmelCase      (      self							)       ->							int:
          _a    	=				'''# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, ["torch"])


class FakeClass(metaclass=DummyObject):
    _backends = ["torch"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, ["torch"])

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, ["torch"])

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, ["torch"])
'''
          _a    	=				create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']}							)
          self.assertEqual(dummy_files['''torch''']    ,				__UpperCAmelCase							)



"""simple docstring"""






import math
import random
from typing import Any

from .hill_climbing import SearchProblem
def       A_   (   _lowerCAmelCase     :					Dict,     _lowerCAmelCase     :					bool = True,     _lowerCAmelCase     :					float = math.inf,     _lowerCAmelCase     :					float = -math.inf,     _lowerCAmelCase     :					float = math.inf,     _lowerCAmelCase     :					float = -math.inf,     _lowerCAmelCase     :					bool = False,     _lowerCAmelCase     :					float = 1_00,     _lowerCAmelCase     :					float = 0.0_1,     _lowerCAmelCase     :					float = 1,     ):






     """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(_lowerCAmelCase       )
          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(_lowerCAmelCase       ) - 1       )  # picking a random neighbor
               _a    	=				neighbors.pop(_lowerCAmelCase       )
               _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(_lowerCAmelCase       ),     _lowerCAmelCase       )
          plt.xlabel('''Iterations'''       )
          plt.ylabel('''Function values'''       )
          plt.show()
     return best_state


if __name__ == "__main__":
   def       A_   (   _lowerCAmelCase     :					List[str],     _lowerCAmelCase     :					Dict       ):






        """simple docstring"""

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

   # starting the problem with initial coordinates (12, 47)
   __snake_case		=       SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa)
   __snake_case		=       simulated_annealing(
       prob, find_max=False, max_x=100, 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)
   __snake_case		=       SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa)
   __snake_case		=       simulated_annealing(
       prob, find_max=True, max_x=100, 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       A_   (   _lowerCAmelCase     :					Optional[Any],     _lowerCAmelCase     :					Optional[int]       ):






        """simple docstring"""

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

   __snake_case		=       SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
   __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()}'
   )

   __snake_case		=       SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
   __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()}'
   )