





'''simple docstring'''




import gc
import unittest

import torch
from parameterized import parameterized

from diffusers import AutoencoderKL
from diffusers.utils import floats_tensor, load_hf_numpy, require_torch_gpu, slow, torch_all_close, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()


class 			SCREAMING_SNAKE_CASE   (a__ ,		a__ ,		unittest.TestCase							):
     lowerCAmelCase		      =	AutoencoderKL
     lowerCAmelCase		      =	'''sample'''
     lowerCAmelCase		      =	1E-2


     @property
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						:			Any								=	4
          __A						:			Any								=	3
          __A						:			Tuple								=	(32, 32)

          __A						:			Optional[Any]								=	floats_tensor((batch_size, num_channels) + sizes).to(_UpperCAmelCase)

          return {"sample": image}


     @property
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          return (3, 32, 32)


     @property
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          return (3, 32, 32)


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						:			Optional[int]								=	{
              'block_out_channels': [32, 64],
              'in_channels': 3,
              'out_channels': 3,
              'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
              'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'],
              'latent_channels': 4,
          }
          __A						:			Any								=	self.dummy_input
          return init_dict, inputs_dict


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          pass


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          pass


     @unittest.skipIf(torch_device == 'mps'						,     'Gradient checkpointing skipped on MPS')
     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						:			List[Any]								=	self.prepare_init_args_and_inputs_for_common()
          __A						:			Any								=	self.model_class(**_UpperCAmelCase)
          model.to(_UpperCAmelCase)

          assert not model.is_gradient_checkpointing and model.training

          __A						:			List[str]								=	model(**_UpperCAmelCase).sample
          # run the backwards pass on the model. For backwards pass, for simplicity purpose,
          # we won't calculate the loss and rather backprop on out.sum()
          model.zero_grad()

          __A						:			Dict								=	torch.randn_like(_UpperCAmelCase)
          __A						:			List[Any]								=	(out - labels).mean()
          loss.backward()

          # re-instantiate the model now enabling gradient checkpointing
          __A						:			Optional[int]								=	self.model_class(**_UpperCAmelCase)
          # clone model
          model_a.load_state_dict(model.state_dict())
          model_a.to(_UpperCAmelCase)
          model_a.enable_gradient_checkpointing()

          assert model_a.is_gradient_checkpointing and model_a.training

          __A						:			Dict								=	model_a(**_UpperCAmelCase).sample
          # run the backwards pass on the model. For backwards pass, for simplicity purpose,
          # we won't calculate the loss and rather backprop on out.sum()
          model_a.zero_grad()
          __A						:			Any								=	(out_a - labels).mean()
          loss_a.backward()

          # compare the output and parameters gradients
          self.assertTrue((loss - loss_a).abs() < 1e-5)
          __A						:			Any								=	dict(model.named_parameters())
          __A						:			Union[str, Any]								=	dict(model_a.named_parameters())
          for name, param in named_params.items():
               self.assertTrue(torch_all_close(param.grad.data						,     named_params_a[name].grad.data						,     atol=5e-5))


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						:			Optional[int]								=	AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'						,     output_loading_info=_UpperCAmelCase)
          self.assertIsNotNone(_UpperCAmelCase)
          self.assertEqual(len(loading_info['missing_keys'])						,     0)

          model.to(_UpperCAmelCase)
          __A						:			int								=	model(**self.dummy_input)

          assert image is not None, "Make sure output is not None"


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						:			List[Any]								=	AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy')
          __A						:			Any								=	model.to(_UpperCAmelCase)
          model.eval()

          if torch_device == "mps":
               __A						:			Dict								=	torch.manual_seed(0)
          else:
               __A						:			List[str]								=	torch.Generator(device=_UpperCAmelCase).manual_seed(0)

          __A						:			Any								=	torch.randn(
              1						,     model.config.in_channels						,     model.config.sample_size						,     model.config.sample_size						,     generator=torch.manual_seed(0)						,     )
          __A						:			Union[str, Any]								=	image.to(_UpperCAmelCase)
          with torch.no_grad():
               __A						:			Any								=	model(_UpperCAmelCase						,     sample_posterior=_UpperCAmelCase						,     generator=_UpperCAmelCase).sample

          __A						:			List[Any]								=	output[0, -1, -3:, -3:].flatten().cpu()

          # Since the VAE Gaussian prior's generator is seeded on the appropriate device,
          # the expected output slices are not the same for CPU and GPU.
          if torch_device == "mps":
               __A						:			Optional[int]								=	torch.tensor(
                   [
                       -4.0_0_7_8e-0_1,
                       -3.8_3_2_3e-0_4,
                       -1.2_6_8_1e-0_1,
                       -1.1_4_6_2e-0_1,
                       2.0_0_9_5e-0_1,
                       1.0_8_9_3e-0_1,
                       -8.8_2_4_7e-0_2,
                       -3.0_3_6_1e-0_1,
                       -9.8_6_4_4e-0_3,
                   ])
          elif torch_device == "cpu":
               __A						:			str								=	torch.tensor(
                   [-0.1352, 0.0878, 0.0419, -0.0818, -0.1069, 0.0688, -0.1458, -0.4446, -0.0026])
          else:
               __A						:			str								=	torch.tensor(
                   [-0.2421, 0.4642, 0.2507, -0.0438, 0.0682, 0.3160, -0.2018, -0.0727, 0.2485])

          self.assertTrue(torch_all_close(_UpperCAmelCase						,     _UpperCAmelCase						,     rtol=1e-2))




@slow
class 			SCREAMING_SNAKE_CASE   (unittest.TestCase							):


     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase						,     _UpperCAmelCase):

          '''simple docstring'''






          return F'gaussian_noise_s={seed}_shape={"_".join([str(_UpperCAmelCase) for s in shape])}.npy'


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






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


     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase=0						,     _UpperCAmelCase=(4, 3, 512, 512)						,     _UpperCAmelCase=False):

          '''simple docstring'''






          __A						:			List[Any]								=	torch.floataa if fpaa else torch.floataa
          __A						:			str								=	torch.from_numpy(load_hf_numpy(self.get_file_format(_UpperCAmelCase						,     _UpperCAmelCase))).to(_UpperCAmelCase).to(_UpperCAmelCase)
          return image


     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase="CompVis/stable-diffusion-v1-4"						,     _UpperCAmelCase=False):

          '''simple docstring'''






          __A						:			Tuple								=	'fp16' if fpaa else None
          __A						:			int								=	torch.floataa if fpaa else torch.floataa

          __A						:			int								=	AutoencoderKL.from_pretrained(
              _UpperCAmelCase						,     subfolder='vae'						,     torch_dtype=_UpperCAmelCase						,     revision=_UpperCAmelCase						,     )
          model.to(_UpperCAmelCase).eval()

          return model


     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase=0):

          '''simple docstring'''






          if torch_device == "mps":
               return torch.manual_seed(_UpperCAmelCase)
          return torch.Generator(device=_UpperCAmelCase).manual_seed(_UpperCAmelCase)


     @parameterized.expand(
         [
             # fmt: off
             [33, [-0.1603, 0.9878, -0.0495, -0.0790, -0.2709, 0.8375, -0.2060, -0.0824], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
             [47, [-0.2376, 0.1168, 0.1332, -0.4840, -0.2508, -0.0791, -0.0493, -0.4089], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
             # fmt: on
         ])
     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase						,     _UpperCAmelCase						,     _UpperCAmelCase):

          '''simple docstring'''






          __A						:			Dict								=	self.get_sd_vae_model()
          __A						:			Tuple								=	self.get_sd_image(_UpperCAmelCase)
          __A						:			Optional[Any]								=	self.get_generator(_UpperCAmelCase)

          with torch.no_grad():
               __A						:			List[str]								=	model(_UpperCAmelCase						,     generator=_UpperCAmelCase						,     sample_posterior=_UpperCAmelCase).sample

          assert sample.shape == image.shape

          __A						:			List[str]								=	sample[-1, -2:, -2:, :2].flatten().float().cpu()
          __A						:			Optional[int]								=	torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice)

          assert torch_all_close(_UpperCAmelCase						,     _UpperCAmelCase						,     atol=3e-3)


     @parameterized.expand(
         [
             # fmt: off
             [33, [-0.0513, 0.0289, 1.3799, 0.2166, -0.2573, -0.0871, 0.5103, -0.0999]],
             [47, [-0.4128, -0.1320, -0.3704, 0.1965, -0.4116, -0.2332, -0.3340, 0.2247]],
             # fmt: on
         ])
     @require_torch_gpu
     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase						,     _UpperCAmelCase):

          '''simple docstring'''






          __A						:			Any								=	self.get_sd_vae_model(fpaa=_UpperCAmelCase)
          __A						:			int								=	self.get_sd_image(_UpperCAmelCase						,     fpaa=_UpperCAmelCase)
          __A						:			List[Any]								=	self.get_generator(_UpperCAmelCase)

          with torch.no_grad():
               __A						:			Union[str, Any]								=	model(_UpperCAmelCase						,     generator=_UpperCAmelCase						,     sample_posterior=_UpperCAmelCase).sample

          assert sample.shape == image.shape

          __A						:			int								=	sample[-1, -2:, :2, -2:].flatten().float().cpu()
          __A						:			List[str]								=	torch.tensor(_UpperCAmelCase)

          assert torch_all_close(_UpperCAmelCase						,     _UpperCAmelCase						,     atol=1e-2)


     @parameterized.expand(
         [
             # fmt: off
             [33, [-0.1609, 0.9866, -0.0487, -0.0777, -0.2716, 0.8368, -0.2055, -0.0814], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
             [47, [-0.2377, 0.1147, 0.1333, -0.4841, -0.2506, -0.0805, -0.0491, -0.4085], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
             # fmt: on
         ])
     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase						,     _UpperCAmelCase						,     _UpperCAmelCase):

          '''simple docstring'''






          __A						:			Optional[Any]								=	self.get_sd_vae_model()
          __A						:			Tuple								=	self.get_sd_image(_UpperCAmelCase)

          with torch.no_grad():
               __A						:			Union[str, Any]								=	model(_UpperCAmelCase).sample

          assert sample.shape == image.shape

          __A						:			List[str]								=	sample[-1, -2:, -2:, :2].flatten().float().cpu()
          __A						:			Dict								=	torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice)

          assert torch_all_close(_UpperCAmelCase						,     _UpperCAmelCase						,     atol=3e-3)


     @parameterized.expand(
         [
             # fmt: off
             [13, [-0.2051, -0.1803, -0.2311, -0.2114, -0.3292, -0.3574, -0.2953, -0.3323]],
             [37, [-0.2632, -0.2625, -0.2199, -0.2741, -0.4539, -0.4990, -0.3720, -0.4925]],
             # fmt: on
         ])
     @require_torch_gpu
     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase						,     _UpperCAmelCase):

          '''simple docstring'''






          __A						:			List[str]								=	self.get_sd_vae_model()
          __A						:			Dict								=	self.get_sd_image(_UpperCAmelCase						,     shape=(3, 4, 64, 64))

          with torch.no_grad():
               __A						:			Optional[Any]								=	model.decode(_UpperCAmelCase).sample

          assert list(sample.shape) == [3, 3, 512, 512]

          __A						:			Union[str, Any]								=	sample[-1, -2:, :2, -2:].flatten().cpu()
          __A						:			Optional[int]								=	torch.tensor(_UpperCAmelCase)

          assert torch_all_close(_UpperCAmelCase						,     _UpperCAmelCase						,     atol=1e-3)


     @parameterized.expand(
         [
             # fmt: off
             [27, [-0.0369, 0.0207, -0.0776, -0.0682, -0.1747, -0.1930, -0.1465, -0.2039]],
             [16, [-0.1628, -0.2134, -0.2747, -0.2642, -0.3774, -0.4404, -0.3687, -0.4277]],
             # fmt: on
         ])
     @require_torch_gpu
     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase						,     _UpperCAmelCase):

          '''simple docstring'''






          __A						:			Optional[int]								=	self.get_sd_vae_model(fpaa=_UpperCAmelCase)
          __A						:			List[str]								=	self.get_sd_image(_UpperCAmelCase						,     shape=(3, 4, 64, 64)						,     fpaa=_UpperCAmelCase)

          with torch.no_grad():
               __A						:			Any								=	model.decode(_UpperCAmelCase).sample

          assert list(sample.shape) == [3, 3, 512, 512]

          __A						:			Dict								=	sample[-1, -2:, :2, -2:].flatten().float().cpu()
          __A						:			Optional[int]								=	torch.tensor(_UpperCAmelCase)

          assert torch_all_close(_UpperCAmelCase						,     _UpperCAmelCase						,     atol=5e-3)


     @parameterized.expand([(13,), (16,), (27,)])
     @require_torch_gpu
     @unittest.skipIf(not is_xformers_available()						,     reason='xformers is not required when using PyTorch 2.0.')
     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase):

          '''simple docstring'''






          __A						:			Tuple								=	self.get_sd_vae_model(fpaa=_UpperCAmelCase)
          __A						:			Optional[Any]								=	self.get_sd_image(_UpperCAmelCase						,     shape=(3, 4, 64, 64)						,     fpaa=_UpperCAmelCase)

          with torch.no_grad():
               __A						:			List[Any]								=	model.decode(_UpperCAmelCase).sample

          model.enable_xformers_memory_efficient_attention()
          with torch.no_grad():
               __A						:			Tuple								=	model.decode(_UpperCAmelCase).sample

          assert list(sample.shape) == [3, 3, 512, 512]

          assert torch_all_close(_UpperCAmelCase						,     _UpperCAmelCase						,     atol=1e-1)


     @parameterized.expand([(13,), (16,), (37,)])
     @require_torch_gpu
     @unittest.skipIf(not is_xformers_available()						,     reason='xformers is not required when using PyTorch 2.0.')
     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase):

          '''simple docstring'''






          __A						:			Any								=	self.get_sd_vae_model()
          __A						:			Tuple								=	self.get_sd_image(_UpperCAmelCase						,     shape=(3, 4, 64, 64))

          with torch.no_grad():
               __A						:			Union[str, Any]								=	model.decode(_UpperCAmelCase).sample

          model.enable_xformers_memory_efficient_attention()
          with torch.no_grad():
               __A						:			List[str]								=	model.decode(_UpperCAmelCase).sample

          assert list(sample.shape) == [3, 3, 512, 512]

          assert torch_all_close(_UpperCAmelCase						,     _UpperCAmelCase						,     atol=1e-2)


     @parameterized.expand(
         [
             # fmt: off
             [33, [-0.3001, 0.0918, -2.6984, -3.9720, -3.2099, -5.0353, 1.7338, -0.2065, 3.4267]],
             [47, [-1.5030, -4.3871, -6.0355, -9.1157, -1.6661, -2.7853, 2.1607, -5.0823, 2.5633]],
             # fmt: on
         ])
     def 							SCREAMING_SNAKE_CASE  (						self						,     _UpperCAmelCase						,     _UpperCAmelCase):

          '''simple docstring'''






          __A						:			Dict								=	self.get_sd_vae_model()
          __A						:			Dict								=	self.get_sd_image(_UpperCAmelCase)
          __A						:			Tuple								=	self.get_generator(_UpperCAmelCase)

          with torch.no_grad():
               __A						:			str								=	model.encode(_UpperCAmelCase).latent_dist
               __A						:			Optional[int]								=	dist.sample(generator=_UpperCAmelCase)

          assert list(sample.shape) == [image.shape[0], 4] + [i // 8 for i in image.shape[2:]]

          __A						:			List[Any]								=	sample[0, -1, -3:, -3:].flatten().cpu()
          __A						:			List[Any]								=	torch.tensor(_UpperCAmelCase)

          __A						:			Union[str, Any]								=	3e-3 if torch_device != 'mps' else 1e-2
          assert torch_all_close(_UpperCAmelCase						,     _UpperCAmelCase						,     atol=_UpperCAmelCase)






'''simple docstring'''




def 	_lowerCAmelCase      (  __snake_case  :			str      )					->					str:
     __A						:			Optional[Any]								=	[0] * len(__snake_case      )
     __A						:			Dict								=	[]
     __A						:			Optional[int]								=	[1] * len(__snake_case      )

     for values in graph.values():
          for i in values:
               indegree[i] += 1

     for i in range(len(__snake_case      )      ):
          if indegree[i] == 0:
               queue.append(__snake_case      )

     while queue:
          __A						:			int								=	queue.pop(0      )
          for x in graph[vertex]:
               indegree[x] -= 1

               if long_dist[vertex] + 1 > long_dist[x]:
                    __A						:			str								=	long_dist[vertex] + 1

               if indegree[x] == 0:
                    queue.append(__snake_case      )

     print(max(__snake_case      )      )


# Adjacency list of Graph
lowercase__   :				Dict      =   {0: [2, 3, 4], 1: [2, 7], 2: [5], 3: [5, 7], 4: [7], 5: [6], 6: [7], 7: []}







longest_distance(graph)