




import random

import torch
from huggingface_hub import HfApi

from diffusers import UNetaDModel


a         =      HfApi()

a         =      {}
# fmt: off
a         =      torch.tensor([
    -0.7_5_1_5, -1.6_8_8_3, 0.2_4_2_0, 0.0_3_0_0, 0.6_3_4_7, 1.3_4_3_3, -1.1_7_4_3, -3.7_4_6_7,
    1.2_3_4_2, -2.2_4_8_5, 0.4_6_3_6, 0.8_0_7_6, -0.7_9_9_1, 0.3_9_6_9, 0.8_4_9_8, 0.9_1_8_9,
    -1.8_8_8_7, -3.3_5_2_2, 0.7_6_3_9, 0.2_0_4_0, 0.6_2_7_1, -2.7_1_4_8, -1.6_3_1_6, 3.0_8_3_9,
    0.3_1_8_6, 0.2_7_2_1, -0.9_7_5_9, -1.2_4_6_1, 2.6_2_5_7, 1.3_5_5_7
])
a         =      torch.tensor([
    -2.3_6_3_9, -2.5_3_4_4, 0.0_0_5_4, -0.6_6_7_4, 1.5_9_9_0, 1.0_1_5_8, 0.3_1_2_4, -2.1_4_3_6,
    1.8_7_9_5, -2.5_4_2_9, -0.1_5_6_6, -0.3_9_7_3, 1.2_4_9_0, 2.6_4_4_7, 1.2_2_8_3, -0.5_2_0_8,
    -2.8_1_5_4, -3.5_1_1_9, 2.3_8_3_8, 1.2_0_3_3, 1.7_2_0_1, -2.1_2_5_6, -1.4_5_7_6, 2.7_9_4_8,
    2.4_2_0_4, -0.9_7_5_2, -1.2_5_4_6, 0.8_0_2_7, 3.2_7_5_8, 3.1_3_6_5
])
a         =      torch.tensor([
    -0.6_5_3_1, -0.6_8_9_1, -0.3_1_7_2, -0.5_3_7_5, -0.9_1_4_0, -0.5_3_6_7, -0.1_1_7_5, -0.7_8_6_9,
    -0.3_8_0_8, -0.4_5_1_3, -0.2_0_9_8, -0.0_0_8_3, 0.3_1_8_3, 0.5_1_4_0, 0.2_2_4_7, -0.1_3_0_4,
    -0.1_3_0_2, -0.2_8_0_2, -0.2_0_8_4, -0.2_0_2_5, -0.4_9_6_7, -0.4_8_7_3, -0.0_8_6_1, 0.6_9_2_5,
    0.0_2_5_0, 0.1_2_9_0, -0.1_5_4_3, 0.6_3_1_6, 1.0_4_6_0, 1.4_9_4_3
])
a         =      torch.tensor([
    0.0_9_1_1, 0.1_1_0_7, 0.0_1_8_2, 0.0_4_3_5, -0.0_8_0_5, -0.0_6_0_8, 0.0_3_8_1, 0.2_1_7_2,
    -0.0_2_8_0, 0.1_3_2_7, -0.0_2_9_9, -0.0_2_5_5, -0.0_0_5_0, -0.1_1_7_0, -0.1_0_4_6, 0.0_3_0_9,
    0.1_3_6_7, 0.1_7_2_8, -0.0_5_3_3, -0.0_7_4_8, -0.0_5_3_4, 0.1_6_2_4, 0.0_3_8_4, -0.1_8_0_5,
    -0.0_7_0_7, 0.0_6_4_2, 0.0_2_2_0, -0.0_1_3_4, -0.1_3_3_3, -0.1_5_0_5
])
a         =      torch.tensor([
    0.1_3_2_1, 0.1_3_3_7, 0.0_4_4_0, 0.0_6_2_2, -0.0_5_9_1, -0.0_3_7_0, 0.0_5_0_3, 0.2_1_3_3,
    -0.0_1_7_7, 0.1_4_1_5, -0.0_1_1_6, -0.0_1_1_2, 0.0_0_4_4, -0.0_9_8_0, -0.0_7_8_9, 0.0_3_9_5,
    0.1_5_0_2, 0.1_7_8_5, -0.0_4_8_8, -0.0_5_1_4, -0.0_4_0_4, 0.1_5_3_9, 0.0_4_5_4, -0.1_5_5_9,
    -0.0_6_6_5, 0.0_6_5_9, 0.0_3_8_3, -0.0_0_0_5, -0.1_2_6_6, -0.1_3_8_6
])
a         =      torch.tensor([
    0.1_1_5_4, 0.1_2_1_8, 0.0_3_0_7, 0.0_5_2_6, -0.0_7_1_1, -0.0_5_4_1, 0.0_3_6_6, 0.2_0_7_8,
    -0.0_2_6_7, 0.1_3_1_7, -0.0_2_2_6, -0.0_1_9_3, -0.0_0_1_4, -0.1_0_5_5, -0.0_9_0_2, 0.0_3_3_0,
    0.1_3_9_1, 0.1_7_0_9, -0.0_5_6_2, -0.0_6_9_3, -0.0_5_6_0, 0.1_4_8_2, 0.0_3_8_1, -0.1_6_8_3,
    -0.0_6_8_1, 0.0_6_6_1, 0.0_3_3_1, -0.0_0_4_6, -0.1_2_6_8, -0.1_4_3_1
])
a         =      torch.tensor([
    0.1_1_9_2, 0.1_2_4_0, 0.0_4_1_4, 0.0_6_0_6, -0.0_5_5_7, -0.0_4_1_2, 0.0_4_3_0, 0.2_0_4_2,
    -0.0_2_0_0, 0.1_3_8_5, -0.0_1_1_5, -0.0_1_3_2, 0.0_0_1_7, -0.0_9_6_5, -0.0_8_0_2, 0.0_3_9_8,
    0.1_4_3_3, 0.1_7_4_7, -0.0_4_5_8, -0.0_5_3_3, -0.0_4_0_7, 0.1_5_4_5, 0.0_4_1_9, -0.1_5_7_4,
    -0.0_6_4_5, 0.0_6_2_6, 0.0_3_4_1, -0.0_0_1_0, -0.1_1_9_9, -0.1_3_9_0
])
a         =      torch.tensor([
    0.1_0_7_5, 0.1_0_7_4, 0.0_2_0_5, 0.0_4_3_1, -0.0_7_7_4, -0.0_6_0_7, 0.0_2_9_8, 0.2_0_4_2,
    -0.0_3_2_0, 0.1_2_6_7, -0.0_2_8_1, -0.0_2_5_0, -0.0_0_6_4, -0.1_0_9_1, -0.0_9_4_6, 0.0_2_9_0,
    0.1_3_2_8, 0.1_6_5_0, -0.0_5_8_0, -0.0_7_3_8, -0.0_5_8_6, 0.1_4_4_0, 0.0_3_3_7, -0.1_7_4_6,
    -0.0_7_1_2, 0.0_6_0_5, 0.0_2_5_0, -0.0_0_9_9, -0.1_3_1_6, -0.1_4_7_3
])
a         =      torch.tensor([
    -1.4_5_7_2, -2.0_4_8_1, -0.0_4_1_4, -0.6_0_0_5, 1.4_1_3_6, 0.5_8_4_8, 0.4_0_2_8, -2.7_3_3_0,
    1.2_2_1_2, -2.1_2_2_8, 0.2_1_5_5, 0.4_0_3_9, 0.7_6_6_2, 2.0_5_3_5, 0.7_4_7_7, -0.3_2_4_3,
    -2.1_7_5_8, -2.7_6_4_8, 1.6_9_4_7, 0.7_0_2_6, 1.2_3_3_8, -1.6_0_7_8, -0.8_6_8_2, 2.2_8_1_0,
    1.8_5_7_4, -0.5_7_1_8, -0.5_5_8_6, -0.0_1_8_6, 2.3_4_1_5, 2.1_2_5_1])
a         =      torch.tensor([
    -1.3_6_9_0, -1.9_7_2_0, -0.4_0_9_0, -0.6_9_6_6, 1.4_6_6_0, 0.9_9_3_8, -0.1_3_8_5, -2.7_3_2_4,
    0.7_7_3_6, -1.8_9_1_7, 0.2_9_2_3, 0.4_2_9_3, 0.1_6_9_3, 1.4_1_1_2, 1.1_8_8_7, -0.3_1_8_1,
    -2.2_1_6_0, -2.6_3_8_1, 1.3_1_7_0, 0.8_1_6_3, 0.9_2_4_0, -1.6_5_4_4, -0.6_0_9_9, 2.5_2_5_9,
    1.6_4_3_0, -0.9_0_9_0, -0.9_3_9_2, -0.0_1_2_6, 2.4_2_6_8, 2.3_2_6_6
])
a         =      torch.tensor([
    -1.3_5_2_5, -1.9_6_2_8, -0.3_9_5_6, -0.6_8_6_0, 1.4_6_6_4, 1.0_0_1_4, -0.1_2_5_9, -2.7_2_1_2,
    0.7_7_7_2, -1.8_8_1_1, 0.2_9_9_6, 0.4_3_8_8, 0.1_7_0_4, 1.4_0_2_9, 1.1_7_0_1, -0.3_0_2_7,
    -2.2_0_5_3, -2.6_2_8_7, 1.3_3_5_0, 0.8_1_3_1, 0.9_2_7_4, -1.6_2_9_2, -0.6_0_9_8, 2.5_1_3_1,
    1.6_5_0_5, -0.8_9_5_8, -0.9_2_9_8, -0.0_1_5_1, 2.4_2_5_7, 2.3_3_5_5
])
a         =      torch.tensor([
    -2.0_5_8_5, -2.7_8_9_7, -0.2_8_5_0, -0.8_9_4_0, 1.9_0_5_2, 0.5_7_0_2, 0.6_3_4_5, -3.8_9_5_9,
    1.5_9_3_2, -3.2_3_1_9, 0.1_9_7_4, 0.0_2_8_7, 1.7_5_6_6, 2.6_5_4_3, 0.8_3_8_7, -0.5_3_5_1,
    -3.2_7_3_6, -4.3_3_7_5, 2.9_0_2_9, 1.6_3_9_0, 1.4_6_4_0, -2.1_7_0_1, -1.9_0_1_3, 2.9_3_4_1,
    3.4_9_8_1, -0.6_2_5_5, -1.1_6_4_4, -0.1_5_9_1, 3.7_0_9_7, 3.2_0_6_6
])
a         =      torch.tensor([
    -2.3_1_3_9, -2.5_5_9_4, -0.0_1_9_7, -0.6_7_8_5, 1.7_0_0_1, 1.1_6_0_6, 0.3_0_7_5, -2.1_7_4_0,
    1.8_0_7_1, -2.5_6_3_0, -0.0_9_2_6, -0.3_8_1_1, 1.2_1_1_6, 2.6_2_4_6, 1.2_7_3_1, -0.5_3_9_8,
    -2.8_1_5_3, -3.6_1_4_0, 2.3_8_9_3, 1.3_2_6_2, 1.6_2_5_8, -2.1_8_5_6, -1.3_2_6_7, 2.8_3_9_5,
    2.3_7_7_9, -1.0_6_2_3, -1.2_4_6_8, 0.8_9_5_9, 3.3_3_6_7, 3.2_2_4_3
])
a         =      torch.tensor([
    -2.0_6_2_8, -2.7_6_6_7, -0.2_0_8_9, -0.8_2_6_3, 2.0_5_3_9, 0.5_9_9_2, 0.6_4_9_5, -3.8_3_3_6,
    1.6_0_2_5, -3.2_8_1_7, 0.1_7_2_1, -0.0_6_3_3, 1.7_5_1_6, 2.7_0_3_9, 0.8_1_0_0, -0.5_9_0_8,
    -3.2_1_1_3, -4.4_3_4_3, 2.9_2_5_7, 1.3_6_3_2, 1.5_5_6_2, -2.1_4_8_9, -1.9_8_9_4, 3.0_5_6_0,
    3.3_3_9_6, -0.7_3_2_8, -1.0_4_1_7, 0.0_3_8_3, 3.7_0_9_3, 3.2_3_4_3
])
a         =      torch.tensor([
    -1.4_5_7_4, -2.0_5_6_9, -0.0_4_7_3, -0.6_1_1_7, 1.4_0_1_8, 0.5_7_6_9, 0.4_1_2_9, -2.7_3_4_4,
    1.2_2_4_1, -2.1_3_9_7, 0.2_0_0_0, 0.3_9_3_7, 0.7_6_1_6, 2.0_4_5_3, 0.7_3_2_4, -0.3_3_9_1,
    -2.1_7_4_6, -2.7_7_4_4, 1.6_9_6_3, 0.6_9_2_1, 1.2_1_8_7, -1.6_1_7_2, -0.8_8_7_7, 2.2_4_3_9,
    1.8_4_7_1, -0.5_8_3_9, -0.5_6_0_5, -0.0_4_6_4, 2.3_2_5_0, 2.1_2_1_9
])
# fmt: on

a         =      api.list_models(filter='''diffusers''')
for mod in models:
       if "google" in mod.author or mod.modelId == "CompVis/ldm-celebahq-256":
              a         =      '''/home/patrick/google_checkpoints/''' + mod.modelId.split('''/''')[-1]

              print(F'''Started running {mod.modelId}!!!''')

              if mod.modelId.startswith('''CompVis'''):
                     a         =      UNetaDModel.from_pretrained(local_checkpoint, subfolder='''unet''')
              else:
                     a         =      UNetaDModel.from_pretrained(local_checkpoint)

              torch.manual_seed(0)
              random.seed(0)

              a         =      torch.randn(1, model.config.in_channels, model.config.sample_size, model.config.sample_size)
              a         =      torch.tensor([10] * noise.shape[0])
              with torch.no_grad():
                     a         =      model(noise, time_step).sample

              assert torch.allclose(
                  logits[0, 0, 0, :30], results['''_'''.join('''_'''.join(mod.modelId.split('''/''')).split('''-'''))], atol=1e-3
              )
              print(F'''{mod.modelId} has passed successfully!!!''')







"""simple docstring"""

from dataclasses import dataclass
from typing import Dict, Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .attention_processor import AttentionProcessor, AttnProcessor
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, DiagonalGaussianDistribution, Encoder





@dataclass
class     lowercase_	(					__lowerCAmelCase							):



 '''simple docstring'''
 UpperCAmelCase   :					"DiagonalGaussianDistribution"





class     lowercase_	(					__lowerCAmelCase      ,     __lowerCAmelCase							):



 '''simple docstring'''
 UpperCAmelCase   :					List[Any]				  =     True

 @register_to_config
 def __init__(			self	:	List[str]   ,							_UpperCAmelCase	:	int = 3   ,							_UpperCAmelCase	:	int = 3   ,							_UpperCAmelCase	:	Tuple[str] = ("DownEncoderBlock2D",)   ,							_UpperCAmelCase	:	Tuple[str] = ("UpDecoderBlock2D",)   ,							_UpperCAmelCase	:	Tuple[int] = (64,)   ,							_UpperCAmelCase	:	int = 1   ,							_UpperCAmelCase	:	str = "silu"   ,							_UpperCAmelCase	:	int = 4   ,							_UpperCAmelCase	:	int = 32   ,							_UpperCAmelCase	:	int = 32   ,							_UpperCAmelCase	:	float = 0.1_8215   ,							):
       super().__init__()

       # pass init params to Encoder
       _A        =       Encoder(
           in_channels=_UpperCAmelCase   ,							out_channels=_UpperCAmelCase   ,							down_block_types=_UpperCAmelCase   ,							block_out_channels=_UpperCAmelCase   ,							layers_per_block=_UpperCAmelCase   ,							act_fn=_UpperCAmelCase   ,							norm_num_groups=_UpperCAmelCase   ,							double_z=_UpperCAmelCase   ,							)

       # pass init params to Decoder
       _A        =       Decoder(
           in_channels=_UpperCAmelCase   ,							out_channels=_UpperCAmelCase   ,							up_block_types=_UpperCAmelCase   ,							block_out_channels=_UpperCAmelCase   ,							layers_per_block=_UpperCAmelCase   ,							norm_num_groups=_UpperCAmelCase   ,							act_fn=_UpperCAmelCase   ,							)

       _A        =       nn.Convad(2 * latent_channels   ,							2 * latent_channels   ,							1		)
       _A        =       nn.Convad(_UpperCAmelCase   ,							_UpperCAmelCase   ,							1		)

       _A        =       False
       _A        =       False

       # only relevant if vae tiling is enabled
       _A        =       self.config.sample_size
       _A        =       (
           self.config.sample_size[0]
           if isinstance(self.config.sample_size   ,							(list, tuple)		)
           else self.config.sample_size
       )
       _A        =       int(sample_size / (2 ** (len(self.config.block_out_channels		) - 1))		)
       _A        =       0.25

 def       lowerCAmelCase_							(			self	:	Union[str, Any]   ,							_UpperCAmelCase	:	int   ,							_UpperCAmelCase	:	Tuple=False		):
       if isinstance(_UpperCAmelCase   ,							(Encoder, Decoder)		):
             _A        =       value

 def       lowerCAmelCase_							(			self	:	List[str]   ,							_UpperCAmelCase	:	bool = True		):
       _A        =       use_tiling

 def       lowerCAmelCase_							(			self	:	Union[str, Any]		):
       self.enable_tiling(_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	Dict		):
       _A        =       True

 def       lowerCAmelCase_							(			self	:	str		):
       _A        =       False

 @property
 # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
 def       lowerCAmelCase_							(			self	:	str		):
       _A        =       {}

       def fn_recursive_add_processors(_UpperCAmelCase	:	str   ,							_UpperCAmelCase	:	torch.nn.Module   ,							_UpperCAmelCase	:	Dict[str, AttentionProcessor]		):
             if hasattr(_UpperCAmelCase   ,							'set_processor'		):
                   _A        =       module.processor

             for sub_name, child in module.named_children():
                   fn_recursive_add_processors(F'''{name}.{sub_name}'''   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)

             return processors

       for name, module in self.named_children():
             fn_recursive_add_processors(_UpperCAmelCase   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)

       return processors

 def       lowerCAmelCase_							(			self	:	str   ,							_UpperCAmelCase	:	Union[AttentionProcessor, Dict[str, AttentionProcessor]]		):
       _A        =       len(self.attn_processors.keys()		)

       if isinstance(_UpperCAmelCase   ,							_UpperCAmelCase		) and len(_UpperCAmelCase		) != count:
             raise ValueError(
                 F'''A dict of processors was passed, but the number of processors {len(_UpperCAmelCase		)} does not match the'''
                 F''' number of attention layers: {count}. Please make sure to pass {count} processor classes.'''		)

       def fn_recursive_attn_processor(_UpperCAmelCase	:	str   ,							_UpperCAmelCase	:	torch.nn.Module   ,							_UpperCAmelCase	:	int		):
             if hasattr(_UpperCAmelCase   ,							'set_processor'		):
                   if not isinstance(_UpperCAmelCase   ,							_UpperCAmelCase		):
                         module.set_processor(_UpperCAmelCase		)
                   else:
                         module.set_processor(processor.pop(F'''{name}.processor'''		)		)

             for sub_name, child in module.named_children():
                   fn_recursive_attn_processor(F'''{name}.{sub_name}'''   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)

       for name, module in self.named_children():
             fn_recursive_attn_processor(_UpperCAmelCase   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	List[str]		):
       self.set_attn_processor(AttnProcessor()		)

 @apply_forward_hook
 def       lowerCAmelCase_							(			self	:	int   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = True		):
       if self.use_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size):
             return self.tiled_encode(_UpperCAmelCase   ,							return_dict=_UpperCAmelCase		)

       if self.use_slicing and x.shape[0] > 1:
             _A        =       [self.encoder(_UpperCAmelCase		) for x_slice in x.split(1		)]
             _A        =       torch.cat(_UpperCAmelCase		)
       else:
             _A        =       self.encoder(_UpperCAmelCase		)

       _A        =       self.quant_conv(_UpperCAmelCase		)
       _A        =       DiagonalGaussianDistribution(_UpperCAmelCase		)

       if not return_dict:
             return (posterior,)

       return AutoencoderKLOutput(latent_dist=_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	Any   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = True		):
       if self.use_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size):
             return self.tiled_decode(_UpperCAmelCase   ,							return_dict=_UpperCAmelCase		)

       _A        =       self.post_quant_conv(_UpperCAmelCase		)
       _A        =       self.decoder(_UpperCAmelCase		)

       if not return_dict:
             return (dec,)

       return DecoderOutput(sample=_UpperCAmelCase		)

 @apply_forward_hook
 def       lowerCAmelCase_							(			self	:	str   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = True		):
       if self.use_slicing and z.shape[0] > 1:
             _A        =       [self._decode(_UpperCAmelCase		).sample for z_slice in z.split(1		)]
             _A        =       torch.cat(_UpperCAmelCase		)
       else:
             _A        =       self._decode(_UpperCAmelCase		).sample

       if not return_dict:
             return (decoded,)

       return DecoderOutput(sample=_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	str   ,							_UpperCAmelCase	:	int   ,							_UpperCAmelCase	:	Dict   ,							_UpperCAmelCase	:	Any		):
       _A        =       min(a.shape[2]   ,							b.shape[2]   ,							_UpperCAmelCase		)
       for y in range(_UpperCAmelCase		):
             _A        =       a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent)
       return b

 def       lowerCAmelCase_							(			self	:	Optional[Any]   ,							_UpperCAmelCase	:	List[str]   ,							_UpperCAmelCase	:	List[Any]   ,							_UpperCAmelCase	:	List[Any]		):
       _A        =       min(a.shape[3]   ,							b.shape[3]   ,							_UpperCAmelCase		)
       for x in range(_UpperCAmelCase		):
             _A        =       a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent)
       return b

 def       lowerCAmelCase_							(			self	:	str   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = True		):
       _A        =       int(self.tile_sample_min_size * (1 - self.tile_overlap_factor)		)
       _A        =       int(self.tile_latent_min_size * self.tile_overlap_factor		)
       _A        =       self.tile_latent_min_size - blend_extent

       # Split the image into 512x512 tiles and encode them separately.
       _A        =       []
       for i in range(0   ,							x.shape[2]   ,							_UpperCAmelCase		):
             _A        =       []
             for j in range(0   ,							x.shape[3]   ,							_UpperCAmelCase		):
                   _A        =       x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size]
                   _A        =       self.encoder(_UpperCAmelCase		)
                   _A        =       self.quant_conv(_UpperCAmelCase		)
                   row.append(_UpperCAmelCase		)
             rows.append(_UpperCAmelCase		)
       _A        =       []
       for i, row in enumerate(_UpperCAmelCase		):
             _A        =       []
             for j, tile in enumerate(_UpperCAmelCase		):
                   # blend the above tile and the left tile
                   # to the current tile and add the current tile to the result row
                   if i > 0:
                         _A        =       self.blend_v(rows[i - 1][j]   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)
                   if j > 0:
                         _A        =       self.blend_h(row[j - 1]   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)
                   result_row.append(tile[:, :, :row_limit, :row_limit]		)
             result_rows.append(torch.cat(_UpperCAmelCase   ,							dim=3		)		)

       _A        =       torch.cat(_UpperCAmelCase   ,							dim=2		)
       _A        =       DiagonalGaussianDistribution(_UpperCAmelCase		)

       if not return_dict:
             return (posterior,)

       return AutoencoderKLOutput(latent_dist=_UpperCAmelCase		)

 def       lowerCAmelCase_							(			self	:	Tuple   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = True		):
       _A        =       int(self.tile_latent_min_size * (1 - self.tile_overlap_factor)		)
       _A        =       int(self.tile_sample_min_size * self.tile_overlap_factor		)
       _A        =       self.tile_sample_min_size - blend_extent

       # Split z into overlapping 64x64 tiles and decode them separately.
       # The tiles have an overlap to avoid seams between tiles.
       _A        =       []
       for i in range(0   ,							z.shape[2]   ,							_UpperCAmelCase		):
             _A        =       []
             for j in range(0   ,							z.shape[3]   ,							_UpperCAmelCase		):
                   _A        =       z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size]
                   _A        =       self.post_quant_conv(_UpperCAmelCase		)
                   _A        =       self.decoder(_UpperCAmelCase		)
                   row.append(_UpperCAmelCase		)
             rows.append(_UpperCAmelCase		)
       _A        =       []
       for i, row in enumerate(_UpperCAmelCase		):
             _A        =       []
             for j, tile in enumerate(_UpperCAmelCase		):
                   # blend the above tile and the left tile
                   # to the current tile and add the current tile to the result row
                   if i > 0:
                         _A        =       self.blend_v(rows[i - 1][j]   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)
                   if j > 0:
                         _A        =       self.blend_h(row[j - 1]   ,							_UpperCAmelCase   ,							_UpperCAmelCase		)
                   result_row.append(tile[:, :, :row_limit, :row_limit]		)
             result_rows.append(torch.cat(_UpperCAmelCase   ,							dim=3		)		)

       _A        =       torch.cat(_UpperCAmelCase   ,							dim=2		)
       if not return_dict:
             return (dec,)

       return DecoderOutput(sample=_UpperCAmelCase		)



 def       lowerCAmelCase_							(			self	:	List[str]   ,							_UpperCAmelCase	:	torch.FloatTensor   ,							_UpperCAmelCase	:	bool = False   ,							_UpperCAmelCase	:	bool = True   ,							_UpperCAmelCase	:	Optional[torch.Generator] = None   ,							):
       _A        =       sample
       _A        =       self.encode(_UpperCAmelCase		).latent_dist
       if sample_posterior:
             _A        =       posterior.sample(generator=_UpperCAmelCase		)
       else:
             _A        =       posterior.mode()
       _A        =       self.decode(_UpperCAmelCase		).sample

       if not return_dict:
             return (dec,)

       return DecoderOutput(sample=_UpperCAmelCase		)

