

'''simple docstring'''






import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    PNDMScheduler,
    StableDiffusionLDMaDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS


enable_full_determinism()






class 			lowercase_	(unittest.TestCase      ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE    :  Tuple							=			StableDiffusionLDMaDPipeline
  SCREAMING_SNAKE_CASE    :  Optional[Any]							=			TEXT_TO_IMAGE_PARAMS
  SCREAMING_SNAKE_CASE    :  List[str]							=			TEXT_TO_IMAGE_BATCH_PARAMS
  SCREAMING_SNAKE_CASE    :  Union[str, Any]							=			TEXT_TO_IMAGE_IMAGE_PARAMS






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple			):
   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					,)
   __lowercase							  = DDIMScheduler(
       beta_start=0.0_0_0_8_5					,beta_end=0.0_1_2					,beta_schedule='''scaled_linear'''					,clip_sample=_UpperCamelCase					,set_alpha_to_one=_UpperCamelCase					,)
   torch.manual_seed(0			)
   __lowercase							  = AutoencoderKL(
       block_out_channels=[3_2, 6_4]					,in_channels=6					,out_channels=6					,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']					,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']					,latent_channels=4					,)
   torch.manual_seed(0			)
   __lowercase							  = CLIPTextConfig(
       bos_token_id=0					,eos_token_id=2					,hidden_size=3_2					,intermediate_size=3_7					,layer_norm_eps=1e-0_5					,num_attention_heads=4					,num_hidden_layers=5					,pad_token_id=1					,vocab_size=1_0_0_0					,)
   __lowercase							  = CLIPTextModel(_UpperCamelCase			)
   __lowercase							  = CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			)

   __lowercase							  = {
       '''unet''': unet,
       '''scheduler''': scheduler,
       '''vae''': vae,
       '''text_encoder''': text_encoder,
       '''tokenizer''': tokenizer,
       '''safety_checker''': None,
       '''feature_extractor''': None,
   }
   return components






  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict					,lowercase__   :     Optional[Any]					,lowercase__   :     Tuple=0			):
   if str(_UpperCamelCase			).startswith('''mps'''			):
    __lowercase							  = torch.manual_seed(_UpperCamelCase			)
   else:
    __lowercase							  = torch.Generator(device=_UpperCamelCase			).manual_seed(_UpperCamelCase			)
   __lowercase							  = {
       '''prompt''': '''A painting of a squirrel eating a burger''',
       '''generator''': generator,
       '''num_inference_steps''': 2,
       '''guidance_scale''': 6.0,
       '''output_type''': '''numpy''',
   }
   return inputs






  def 					SCREAMING_SNAKE_CASE      (      self   :     Union[str, Any]			):
   __lowercase							  = '''cpu'''  # ensure determinism for the device-dependent torch.Generator

   __lowercase							  = self.get_dummy_components()
   __lowercase							  = StableDiffusionLDMaDPipeline(**_UpperCamelCase			)
   __lowercase							  = ldmad_pipe.to(_UpperCamelCase			)
   ldmad_pipe.set_progress_bar_config(disable=_UpperCamelCase			)

   __lowercase							  = self.get_dummy_inputs(_UpperCamelCase			)
   __lowercase							  = ldmad_pipe(**_UpperCamelCase			)
   __lowercase  ,	__lowercase							  = output.rgb, output.depth

   __lowercase							  = rgb[0, -3:, -3:, -1]
   __lowercase							  = depth[0, -3:, -1]

   assert rgb.shape == (1, 6_4, 6_4, 3)
   assert depth.shape == (1, 6_4, 6_4)

   __lowercase							  = np.array(
       [0.3_7_3_3_8_1_7_6, 0.7_0_2_4_7, 0.7_4_2_0_3_1_9_3, 0.5_1_6_4_3_6_0_4, 0.5_8_2_5_6_7_9_3, 0.6_0_9_3_2_1_3_6, 0.4_1_8_1_0_9_5, 0.4_8_3_5_5_8_7_7, 0.4_6_5_3_5_2_6_2]			)
   __lowercase							  = np.array([1_0_3.4_6_7_2_7, 8_5.8_1_2_0_0_4, 8_7.8_4_9_2_3_6]			)

   assert np.abs(image_slice_rgb.flatten() - expected_slice_rgb			).max() < 1e-2
   assert np.abs(image_slice_depth.flatten() - expected_slice_depth			).max() < 1e-2






  def 					SCREAMING_SNAKE_CASE      (      self   :     List[Any]			):
   __lowercase							  = self.get_dummy_components()
   __lowercase							  = StableDiffusionLDMaDPipeline(**_UpperCamelCase			)
   __lowercase							  = ldmad_pipe.to(_UpperCamelCase			)
   ldmad_pipe.set_progress_bar_config(disable=_UpperCamelCase			)

   __lowercase							  = self.get_dummy_inputs(_UpperCamelCase			)
   __lowercase							  = 3 * [inputs['''prompt''']]

   # forward
   __lowercase							  = ldmad_pipe(**_UpperCamelCase			)
   __lowercase  ,	__lowercase							  = output.rgb, output.depth
   __lowercase							  = rgb_slice_a[0, -3:, -3:, -1]
   __lowercase							  = depth_slice_a[0, -3:, -1]

   __lowercase							  = self.get_dummy_inputs(_UpperCamelCase			)
   __lowercase							  = 3 * [inputs.pop('''prompt'''			)]

   __lowercase							  = ldmad_pipe.tokenizer(
       _UpperCamelCase					,padding='''max_length'''					,max_length=ldmad_pipe.tokenizer.model_max_length					,truncation=_UpperCamelCase					,return_tensors='''pt'''					,)
   __lowercase							  = text_inputs['''input_ids'''].to(_UpperCamelCase			)

   __lowercase							  = ldmad_pipe.text_encoder(_UpperCamelCase			)[0]

   __lowercase							  = prompt_embeds

   # forward
   __lowercase							  = ldmad_pipe(**_UpperCamelCase			)
   __lowercase  ,	__lowercase							  = output.rgb, output.depth
   __lowercase							  = rgb_slice_a[0, -3:, -3:, -1]
   __lowercase							  = depth_slice_a[0, -3:, -1]

   assert np.abs(rgb_slice_a.flatten() - rgb_slice_a.flatten()			).max() < 1e-4
   assert np.abs(depth_slice_a.flatten() - depth_slice_a.flatten()			).max() < 1e-4






  def 					SCREAMING_SNAKE_CASE      (      self   :     int			):
   __lowercase							  = '''cpu'''  # ensure determinism for the device-dependent torch.Generator
   __lowercase							  = self.get_dummy_components()
   __lowercase							  = PNDMScheduler(skip_prk_steps=_UpperCamelCase			)
   __lowercase							  = StableDiffusionLDMaDPipeline(**_UpperCamelCase			)
   __lowercase							  = ldmad_pipe.to(_UpperCamelCase			)
   ldmad_pipe.set_progress_bar_config(disable=_UpperCamelCase			)

   __lowercase							  = self.get_dummy_inputs(_UpperCamelCase			)
   __lowercase							  = '''french fries'''
   __lowercase							  = ldmad_pipe(**_UpperCamelCase					,negative_prompt=_UpperCamelCase			)

   __lowercase  ,	__lowercase							  = output.rgb, output.depth
   __lowercase							  = rgb[0, -3:, -3:, -1]
   __lowercase							  = depth[0, -3:, -1]

   assert rgb.shape == (1, 6_4, 6_4, 3)
   assert depth.shape == (1, 6_4, 6_4)

   __lowercase							  = np.array(
       [0.3_7_0_4_4, 0.7_1_8_1_1_5_0_3, 0.7_2_2_3_2_5_1, 0.4_8_6_0_3_6_7_5, 0.5_6_3_8_3_9_1, 0.6_3_6_4_9_4_8, 0.4_2_8_3_3_7_0_4, 0.4_9_0_1_3_1_5, 0.4_7_9_2_6_2_1_7]			)
   __lowercase							  = np.array([1_0_7.8_4_7_3_8, 8_4.6_2_8_0_2, 8_9.9_6_2_1_3_5]			)
   assert np.abs(rgb_slice.flatten() - expected_slice_rgb			).max() < 1e-2
   assert np.abs(depth_slice.flatten() - expected_slice_depth			).max() < 1e-2






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




  """simple docstring"""




  def 					SCREAMING_SNAKE_CASE      (      self   :     str			):
   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple					,lowercase__   :     Any					,lowercase__   :     Optional[Any]="cpu"					,lowercase__   :     List[str]=torch.floataa					,lowercase__   :     str=0			):
   __lowercase							  = torch.Generator(device=_UpperCamelCase			).manual_seed(_UpperCamelCase			)
   __lowercase							  = np.random.RandomState(_UpperCamelCase			).standard_normal((1, 4, 6_4, 6_4)			)
   __lowercase							  = torch.from_numpy(_UpperCamelCase			).to(device=_UpperCamelCase					,dtype=_UpperCamelCase			)
   __lowercase							  = {
       '''prompt''': '''a photograph of an astronaut riding a horse''',
       '''latents''': latents,
       '''generator''': generator,
       '''num_inference_steps''': 3,
       '''guidance_scale''': 7.5,
       '''output_type''': '''numpy''',
   }
   return inputs






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple			):
   __lowercase							  = StableDiffusionLDMaDPipeline.from_pretrained('''Intel/ldm3d'''			)
   __lowercase							  = ldmad_pipe.to(_UpperCamelCase			)
   ldmad_pipe.set_progress_bar_config(disable=_UpperCamelCase			)

   __lowercase							  = self.get_inputs(_UpperCamelCase			)
   __lowercase							  = ldmad_pipe(**_UpperCamelCase			)
   __lowercase  ,	__lowercase							  = output.rgb, output.depth
   __lowercase							  = rgb[0, -3:, -3:, -1].flatten()
   __lowercase							  = rgb[0, -3:, -1].flatten()

   assert rgb.shape == (1, 5_1_2, 5_1_2, 3)
   assert depth.shape == (1, 5_1_2, 5_1_2)

   __lowercase							  = np.array(
       [0.5_3_8_0_5_4_6_5, 0.5_6_7_0_7_3_0_5, 0.5_4_8_6_5_1_5, 0.5_7_0_1_2_2_3_6, 0.5_8_1_4_5_1_1, 0.5_6_2_5_3_4_8_7, 0.5_4_8_4_3_0_1_4, 0.5_5_0_9_2_2_6_3, 0.6_4_5_9_7_0_6]			)
   __lowercase							  = np.array(
       [0.9_2_6_3_7_8_1, 0.6_6_7_8_6_7_2, 0.5_4_8_6_5_1_5, 0.9_2_2_0_2_1_4_5, 0.6_7_8_3_1_1_3_5, 0.5_6_2_5_3_4_8_7, 0.9_2_4_1_6_9_4, 0.7_5_5_1_4_7_8, 0.6_4_5_9_7_0_6]			)
   assert np.abs(rgb_slice - expected_slice_rgb			).max() < 3e-3
   assert np.abs(depth_slice - expected_slice_depth			).max() < 3e-3






@nightly
@require_torch_gpu
class 			lowercase_	(unittest.TestCase      ):




  """simple docstring"""




  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict			):
   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple					,lowercase__   :     Tuple					,lowercase__   :     Optional[int]="cpu"					,lowercase__   :     Dict=torch.floataa					,lowercase__   :     List[str]=0			):
   __lowercase							  = torch.Generator(device=_UpperCamelCase			).manual_seed(_UpperCamelCase			)
   __lowercase							  = np.random.RandomState(_UpperCamelCase			).standard_normal((1, 4, 6_4, 6_4)			)
   __lowercase							  = torch.from_numpy(_UpperCamelCase			).to(device=_UpperCamelCase					,dtype=_UpperCamelCase			)
   __lowercase							  = {
       '''prompt''': '''a photograph of an astronaut riding a horse''',
       '''latents''': latents,
       '''generator''': generator,
       '''num_inference_steps''': 5_0,
       '''guidance_scale''': 7.5,
       '''output_type''': '''numpy''',
   }
   return inputs






  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[Any]			):
   __lowercase							  = StableDiffusionLDMaDPipeline.from_pretrained('''Intel/ldm3d'''			).to(_UpperCamelCase			)
   ldmad_pipe.set_progress_bar_config(disable=_UpperCamelCase			)

   __lowercase							  = self.get_inputs(_UpperCamelCase			)
   __lowercase							  = ldmad_pipe(**_UpperCamelCase			)
   __lowercase  ,	__lowercase							  = output.rgb, output.depth

   __lowercase							  = 0.4_9_5_5_8_6
   __lowercase							  = 0.3_3_7_9_5_5_1_5
   __lowercase							  = 1_1_2.4_8_5_1_8
   __lowercase							  = 9_8.4_8_9_7_4_6
   assert np.abs(expected_rgb_mean - rgb.mean()			) < 1e-3
   assert np.abs(expected_rgb_std - rgb.std()			) < 1e-3
   assert np.abs(expected_depth_mean - depth.mean()			) < 1e-3
   assert np.abs(expected_depth_std - depth.std()			) < 1e-3






  def 					SCREAMING_SNAKE_CASE      (      self   :     str			):
   __lowercase							  = StableDiffusionLDMaDPipeline.from_pretrained('''Intel/ldm3d-4c'''			).to(_UpperCamelCase			)
   ldmad_pipe.set_progress_bar_config(disable=_UpperCamelCase			)

   __lowercase							  = self.get_inputs(_UpperCamelCase			)
   __lowercase							  = ldmad_pipe(**_UpperCamelCase			)
   __lowercase  ,	__lowercase							  = output.rgb, output.depth

   __lowercase							  = 0.4_1_9_4_1_2_7
   __lowercase							  = 0.3_5_3_7_5_5_8_6
   __lowercase							  = 0.5_6_3_8_5_0_2
   __lowercase							  = 0.3_4_6_8_6_1_0_3

   assert rgb.shape == (1, 5_1_2, 5_1_2, 3)
   assert depth.shape == (1, 5_1_2, 5_1_2, 1)
   assert np.abs(expected_rgb_mean - rgb.mean()			) < 1e-3
   assert np.abs(expected_rgb_std - rgb.std()			) < 1e-3
   assert np.abs(expected_depth_mean - depth.mean()			) < 1e-3
   assert np.abs(expected_depth_std - depth.std()			) < 1e-3








import argparse
import copy



def _a				(	lowerCamelCase:   List[Any] )	->						List[str]:







      '''simple docstring'''






      __A          =				{}

      with open(lowerCamelCase ) as f:
            for line in f:
                  if line.split()[0] not in dict_of_neighbours:
                        __A          =				[]
                        _list.append([line.split()[1], line.split()[2]] )
                        __A          =				_list
                  else:
                        dict_of_neighbours[line.split()[0]].append(
                            [line.split()[1], line.split()[2]] )
                  if line.split()[1] not in dict_of_neighbours:
                        __A          =				[]
                        _list.append([line.split()[0], line.split()[2]] )
                        __A          =				_list
                  else:
                        dict_of_neighbours[line.split()[1]].append(
                            [line.split()[0], line.split()[2]] )

      return dict_of_neighbours



def _a				(	lowerCamelCase:   Any					,				lowerCamelCase:   Optional[Any] )	->						Dict:







      '''simple docstring'''






      with open(lowerCamelCase ) as f:
            __A          =				f.read(1 )
      __A          =				start_node

      __A          =				[]

      __A          =				start_node

      __A          =				0
      while visiting not in first_solution:
            __A          =				1_00_00
            for k in dict_of_neighbours[visiting]:
                  if int(k[1] ) < int(lowerCamelCase ) and k[0] not in first_solution:
                        __A          =				k[1]
                        __A          =				k[0]

            first_solution.append(lowerCamelCase )
            __A          =				distance_of_first_solution + int(lowerCamelCase )
            __A          =				best_node

      first_solution.append(lowerCamelCase )

      __A          =				0
      for k in dict_of_neighbours[first_solution[-2]]:
            if k[0] == start_node:
                  break
            position += 1

      __A          =				(
          distance_of_first_solution
          + int(dict_of_neighbours[first_solution[-2]][position][1] )
          - 1_00_00
      )
      return first_solution, distance_of_first_solution



def _a				(	lowerCamelCase:   List[str]					,				lowerCamelCase:   Any )	->						Any:







      '''simple docstring'''






      __A          =				[]

      for n in solution[1:-1]:
            __A          =				solution.index(lowerCamelCase )
            for kn in solution[1:-1]:
                  __A          =				solution.index(lowerCamelCase )
                  if n == kn:
                        continue

                  __A          =				copy.deepcopy(lowerCamelCase )
                  __A          =				kn
                  __A          =				n

                  __A          =				0

                  for k in _tmp[:-1]:
                        __A          =				_tmp[_tmp.index(lowerCamelCase ) + 1]
                        for i in dict_of_neighbours[k]:
                              if i[0] == next_node:
                                    __A          =				distance + int(i[1] )
                  _tmp.append(lowerCamelCase )

                  if _tmp not in neighborhood_of_solution:
                        neighborhood_of_solution.append(_tmp )

      __A          =				len(neighborhood_of_solution[0] ) - 1

      neighborhood_of_solution.sort(key=lambda lowerCamelCase : x[index_of_last_item_in_the_list] )
      return neighborhood_of_solution



def _a				(	lowerCamelCase:   Optional[int]					,				lowerCamelCase:   Dict					,				lowerCamelCase:   Any					,				lowerCamelCase:   Optional[int]					,				lowerCamelCase:   Union[str, Any] )	->						Any:







      '''simple docstring'''






      __A          =				1
      __A          =				first_solution
      __A          =				[]
      __A          =				distance_of_first_solution
      __A          =				solution

      while count <= iters:
            __A          =				find_neighborhood(lowerCamelCase					,				lowerCamelCase )
            __A          =				0
            __A          =				neighborhood[index_of_best_solution]
            __A          =				len(lowerCamelCase ) - 1

            __A          =				False
            while not found:
                  __A          =				0
                  while i < len(lowerCamelCase ):
                        if best_solution[i] != solution[i]:
                              __A          =				best_solution[i]
                              __A          =				solution[i]
                              break
                        __A          =				i + 1

                  if [first_exchange_node, second_exchange_node] not in tabu_list and [
                      second_exchange_node,
                      first_exchange_node,
                  ] not in tabu_list:
                        tabu_list.append([first_exchange_node, second_exchange_node] )
                        __A          =				True
                        __A          =				best_solution[:-1]
                        __A          =				neighborhood[index_of_best_solution][best_cost_index]
                        if cost < best_cost:
                              __A          =				cost
                              __A          =				solution
                  else:
                        __A          =				index_of_best_solution + 1
                        __A          =				neighborhood[index_of_best_solution]

            if len(lowerCamelCase ) >= size:
                  tabu_list.pop(0 )

            __A          =				count + 1

      return best_solution_ever, best_cost



def _a				(	lowerCamelCase:   List[str]=None )	->						str:







      '''simple docstring'''






      __A          =				generate_neighbours(args.File )

      __A   ,						__A          =				generate_first_solution(
          args.File					,				lowerCamelCase )

      __A   ,						__A          =				tabu_search(
          lowerCamelCase					,				lowerCamelCase					,				lowerCamelCase					,				args.Iterations					,				args.Size					,				)

      print(F"""Best solution: {best_sol}, with total distance: {best_cost}.""" )


if __name__ == "__main__":
       snake_case__					:							Tuple													=     argparse.ArgumentParser(description='Tabu Search')
       parser.add_argument(
           '-f',
           '--File',
           type=str,
           help='Path to the file containing the data',
           required=True,
       )
       parser.add_argument(
           '-i',
           '--Iterations',
           type=int,
           help='How many iterations the algorithm should perform',
           required=True,
       )
       parser.add_argument(
           '-s', '--Size', type=int, help='Size of the tabu list', required=True
       )

       # Pass the arguments to main method
       main(parser.parse_args())





