





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 	UpperCamelCase__				(   lowerCAmelCase_							,   lowerCAmelCase_							,   unittest.TestCase     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    AutoencoderKL
     __snake_case					:			Dict				=    "sample"
     __snake_case					:			Dict				=    1E-2






     @property
     def        SCREAMING_SNAKE_CASE__						(							self		:					Union[str, Any] )  ->	Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		4
           SCREAMING_SNAKE_CASE	=		3
           SCREAMING_SNAKE_CASE	=		(32, 32)

           SCREAMING_SNAKE_CASE	=		floats_tensor((batch_size, num_channels) + sizes ).to(lowerCamelCase__ )

           return {"sample": image}






     @property
     def        SCREAMING_SNAKE_CASE__						(							self		:					Optional[int] )  ->	str:




           '''simple docstring'''


           return (3, 32, 32)






     @property
     def        SCREAMING_SNAKE_CASE__						(							self		:					Tuple )  ->	Optional[int]:




           '''simple docstring'''


           return (3, 32, 32)






     def        SCREAMING_SNAKE_CASE__						(							self		:					List[Any] )  ->	Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		{
               """block_out_channels""": [32, 64],
               """in_channels""": 3,
               """out_channels""": 3,
               """down_block_types""": ["""DownEncoderBlock2D""", """DownEncoderBlock2D"""],
               """up_block_types""": ["""UpDecoderBlock2D""", """UpDecoderBlock2D"""],
               """latent_channels""": 4,
           }
           SCREAMING_SNAKE_CASE	=		self.dummy_input
           return init_dict, inputs_dict






     def        SCREAMING_SNAKE_CASE__						(							self		:					Any )  ->	Dict:




           '''simple docstring'''


           pass






     def        SCREAMING_SNAKE_CASE__						(							self		:					str )  ->	Tuple:




           '''simple docstring'''


           pass






     @unittest.skipIf(torch_device == """mps"""		,"""Gradient checkpointing skipped on MPS""" )
     def        SCREAMING_SNAKE_CASE__						(							self		:					Dict )  ->	Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,      SCREAMING_SNAKE_CASE	=		self.prepare_init_args_and_inputs_for_common()
           SCREAMING_SNAKE_CASE	=		self.model_class(**lowerCamelCase__ )
           model.to(lowerCamelCase__ )

           assert not model.is_gradient_checkpointing and model.training

           SCREAMING_SNAKE_CASE	=		model(**lowerCamelCase__ ).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()

           SCREAMING_SNAKE_CASE	=		torch.randn_like(lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		(out - labels).mean()
           loss.backward()

           # re-instantiate the model now enabling gradient checkpointing
           SCREAMING_SNAKE_CASE	=		self.model_class(**lowerCamelCase__ )
           # clone model
           model_a.load_state_dict(model.state_dict() )
           model_a.to(lowerCamelCase__ )
           model_a.enable_gradient_checkpointing()

           assert model_a.is_gradient_checkpointing and model_a.training

           SCREAMING_SNAKE_CASE	=		model_a(**lowerCamelCase__ ).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()
           SCREAMING_SNAKE_CASE	=		(out_a - labels).mean()
           loss_a.backward()

           # compare the output and parameters gradients
           self.assertTrue((loss - loss_a).abs() < 1e-5 )
           SCREAMING_SNAKE_CASE	=		dict(model.named_parameters() )
           SCREAMING_SNAKE_CASE	=		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		:					str )  ->	Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE,      SCREAMING_SNAKE_CASE	=		AutoencoderKL.from_pretrained("""fusing/autoencoder-kl-dummy"""		,output_loading_info=lowerCamelCase__ )
           self.assertIsNotNone(lowerCamelCase__ )
           self.assertEqual(len(loading_info["""missing_keys"""] )		,0 )

           model.to(lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		model(**self.dummy_input )

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






     def        SCREAMING_SNAKE_CASE__						(							self		:					List[str] )  ->	List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		AutoencoderKL.from_pretrained("""fusing/autoencoder-kl-dummy""" )
           SCREAMING_SNAKE_CASE	=		model.to(lowerCamelCase__ )
           model.eval()

           if torch_device == "mps":
                 SCREAMING_SNAKE_CASE	=		torch.manual_seed(0 )
           else:
                 SCREAMING_SNAKE_CASE	=		torch.Generator(device=lowerCamelCase__ ).manual_seed(0 )

           SCREAMING_SNAKE_CASE	=		torch.randn(
               1		,model.config.in_channels		,model.config.sample_size		,model.config.sample_size		,generator=torch.manual_seed(0 )		,)
           SCREAMING_SNAKE_CASE	=		image.to(lowerCamelCase__ )
           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model(lowerCamelCase__		,sample_posterior=lowerCamelCase__		,generator=lowerCamelCase__ ).sample

           SCREAMING_SNAKE_CASE	=		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":
                 SCREAMING_SNAKE_CASE	=		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":
                 SCREAMING_SNAKE_CASE	=		torch.tensor(
                     [-0.1352, 0.0878, 0.0419, -0.0818, -0.1069, 0.0688, -0.1458, -0.4446, -0.0026] )
           else:
                 SCREAMING_SNAKE_CASE	=		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(lowerCamelCase__		,lowerCamelCase__		,rtol=1e-2 ) )

@slow
class 	UpperCamelCase__				(   unittest.TestCase     ):



     '''simple docstring'''

     def        SCREAMING_SNAKE_CASE__						(							self		:					Tuple		,lowerCamelCase__		:					int		,lowerCamelCase__		:					List[str] )  ->	List[Any]:




           '''simple docstring'''


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






     def        SCREAMING_SNAKE_CASE__						(							self		:					Optional[Any] )  ->	str:




           '''simple docstring'''


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






     def        SCREAMING_SNAKE_CASE__						(							self		:					Tuple		,lowerCamelCase__		:					List[str]=0		,lowerCamelCase__		:					Union[str, Any]=(4, 3, 512, 512)		,lowerCamelCase__		:					Tuple=False )  ->	Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		torch.floataa if fpaa else torch.floataa
           SCREAMING_SNAKE_CASE	=		torch.from_numpy(load_hf_numpy(self.get_file_format(lowerCamelCase__		,lowerCamelCase__ ) ) ).to(lowerCamelCase__ ).to(lowerCamelCase__ )
           return image






     def        SCREAMING_SNAKE_CASE__						(							self		:					Any		,lowerCamelCase__		:					str="CompVis/stable-diffusion-v1-4"		,lowerCamelCase__		:					Union[str, Any]=False )  ->	Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		"""fp16""" if fpaa else None
           SCREAMING_SNAKE_CASE	=		torch.floataa if fpaa else torch.floataa

           SCREAMING_SNAKE_CASE	=		AutoencoderKL.from_pretrained(
               lowerCamelCase__		,subfolder="""vae"""		,torch_dtype=lowerCamelCase__		,revision=lowerCamelCase__		,)
           model.to(lowerCamelCase__ ).eval()

           return model






     def        SCREAMING_SNAKE_CASE__						(							self		:					Optional[Any]		,lowerCamelCase__		:					Union[str, Any]=0 )  ->	Tuple:




           '''simple docstring'''


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






     @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		:					Optional[int]		,lowerCamelCase__		:					List[str]		,lowerCamelCase__		:					List[Any]		,lowerCamelCase__		:					int )  ->	List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		self.get_sd_vae_model()
           SCREAMING_SNAKE_CASE	=		self.get_sd_image(lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		self.get_generator(lowerCamelCase__ )

           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model(lowerCamelCase__		,generator=lowerCamelCase__		,sample_posterior=lowerCamelCase__ ).sample

           assert sample.shape == image.shape

           SCREAMING_SNAKE_CASE	=		sample[-1, -2:, -2:, :2].flatten().float().cpu()
           SCREAMING_SNAKE_CASE	=		torch.tensor(expected_slice_mps if torch_device == """mps""" else expected_slice )

           assert torch_all_close(lowerCamelCase__		,lowerCamelCase__		,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		:					Optional[Any]		,lowerCamelCase__		:					Optional[Any]		,lowerCamelCase__		:					int )  ->	Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		self.get_sd_vae_model(fpaa=lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		self.get_sd_image(lowerCamelCase__		,fpaa=lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		self.get_generator(lowerCamelCase__ )

           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model(lowerCamelCase__		,generator=lowerCamelCase__		,sample_posterior=lowerCamelCase__ ).sample

           assert sample.shape == image.shape

           SCREAMING_SNAKE_CASE	=		sample[-1, -2:, :2, -2:].flatten().float().cpu()
           SCREAMING_SNAKE_CASE	=		torch.tensor(lowerCamelCase__ )

           assert torch_all_close(lowerCamelCase__		,lowerCamelCase__		,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		:					str		,lowerCamelCase__		:					List[str]		,lowerCamelCase__		:					Optional[Any]		,lowerCamelCase__		:					Tuple )  ->	Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		self.get_sd_vae_model()
           SCREAMING_SNAKE_CASE	=		self.get_sd_image(lowerCamelCase__ )

           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model(lowerCamelCase__ ).sample

           assert sample.shape == image.shape

           SCREAMING_SNAKE_CASE	=		sample[-1, -2:, -2:, :2].flatten().float().cpu()
           SCREAMING_SNAKE_CASE	=		torch.tensor(expected_slice_mps if torch_device == """mps""" else expected_slice )

           assert torch_all_close(lowerCamelCase__		,lowerCamelCase__		,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		:					Dict		,lowerCamelCase__		:					Tuple		,lowerCamelCase__		:					List[Any] )  ->	Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		self.get_sd_vae_model()
           SCREAMING_SNAKE_CASE	=		self.get_sd_image(lowerCamelCase__		,shape=(3, 4, 64, 64) )

           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model.decode(lowerCamelCase__ ).sample

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

           SCREAMING_SNAKE_CASE	=		sample[-1, -2:, :2, -2:].flatten().cpu()
           SCREAMING_SNAKE_CASE	=		torch.tensor(lowerCamelCase__ )

           assert torch_all_close(lowerCamelCase__		,lowerCamelCase__		,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		:					List[Any]		,lowerCamelCase__		:					Union[str, Any]		,lowerCamelCase__		:					List[str] )  ->	Union[str, Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		self.get_sd_vae_model(fpaa=lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		self.get_sd_image(lowerCamelCase__		,shape=(3, 4, 64, 64)		,fpaa=lowerCamelCase__ )

           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model.decode(lowerCamelCase__ ).sample

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

           SCREAMING_SNAKE_CASE	=		sample[-1, -2:, :2, -2:].flatten().float().cpu()
           SCREAMING_SNAKE_CASE	=		torch.tensor(lowerCamelCase__ )

           assert torch_all_close(lowerCamelCase__		,lowerCamelCase__		,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		:					List[Any]		,lowerCamelCase__		:					Any )  ->	Union[str, Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		self.get_sd_vae_model(fpaa=lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		self.get_sd_image(lowerCamelCase__		,shape=(3, 4, 64, 64)		,fpaa=lowerCamelCase__ )

           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model.decode(lowerCamelCase__ ).sample

           model.enable_xformers_memory_efficient_attention()
           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model.decode(lowerCamelCase__ ).sample

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

           assert torch_all_close(lowerCamelCase__		,lowerCamelCase__		,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		:					Dict		,lowerCamelCase__		:					str )  ->	Union[str, Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		self.get_sd_vae_model()
           SCREAMING_SNAKE_CASE	=		self.get_sd_image(lowerCamelCase__		,shape=(3, 4, 64, 64) )

           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model.decode(lowerCamelCase__ ).sample

           model.enable_xformers_memory_efficient_attention()
           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model.decode(lowerCamelCase__ ).sample

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

           assert torch_all_close(lowerCamelCase__		,lowerCamelCase__		,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		:					str		,lowerCamelCase__		:					Union[str, Any]		,lowerCamelCase__		:					Dict )  ->	Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		self.get_sd_vae_model()
           SCREAMING_SNAKE_CASE	=		self.get_sd_image(lowerCamelCase__ )
           SCREAMING_SNAKE_CASE	=		self.get_generator(lowerCamelCase__ )

           with torch.no_grad():
                 SCREAMING_SNAKE_CASE	=		model.encode(lowerCamelCase__ ).latent_dist
                 SCREAMING_SNAKE_CASE	=		dist.sample(generator=lowerCamelCase__ )

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

           SCREAMING_SNAKE_CASE	=		sample[0, -1, -3:, -3:].flatten().cpu()
           SCREAMING_SNAKE_CASE	=		torch.tensor(lowerCamelCase__ )

           SCREAMING_SNAKE_CASE	=		3e-3 if torch_device != """mps""" else 1e-2
           assert torch_all_close(lowerCamelCase__		,lowerCamelCase__		,atol=lowerCamelCase__ )









import os
from datetime import datetime as dt

from github import Github


SCREAMING_SNAKE_CASE_		     = [
    """good first issue""",
    """feature request""",
    """wip""",
]



def      __lowercase     (   )				->     Optional[int]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		Github(os.environ["""GITHUB_TOKEN"""]			)
      SCREAMING_SNAKE_CASE	=		g.get_repo("""huggingface/accelerate"""			)
      SCREAMING_SNAKE_CASE	=		repo.get_issues(state="""open"""			)

      for issue in open_issues:
            SCREAMING_SNAKE_CASE	=		sorted([comment for comment in issue.get_comments()]				,		key=lambda _SCREAMING_SNAKE_CASE			: i.created_at				,		reverse=_SCREAMING_SNAKE_CASE			)
            SCREAMING_SNAKE_CASE	=		comments[0] if len(_SCREAMING_SNAKE_CASE			) > 0 else None
            SCREAMING_SNAKE_CASE	=		dt.utcnow()
            SCREAMING_SNAKE_CASE	=		(current_time - issue.updated_at).days
            SCREAMING_SNAKE_CASE	=		(current_time - issue.created_at).days
            if (
                last_comment is not None
                and last_comment.user.login == "github-actions[bot]"
                and days_since_updated > 7
                and days_since_creation >= 30
                and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()			)
            ):
                  # Close issue since it has been 7 days of inactivity since bot mention.
                  issue.edit(state="""closed"""			)
            elif (
                days_since_updated > 23
                and days_since_creation >= 30
                and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()			)
            ):
                  # Add stale comment
                  issue.create_comment(
                      """This issue has been automatically marked as stale because it has not had """
                      """recent activity. If you think this still needs to be addressed """
                      """please comment on this thread.\n\nPlease note that issues that do not follow the """
                      """[contributing guidelines](https://github.com/huggingface/accelerate/blob/main/CONTRIBUTING.md) """
                      """are likely to be ignored."""			)


if __name__ == "__main__":
      main()


