






import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision import transforms

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling






def 							lowerCamelCase__ (       __lowerCamelCase     :	Tuple						):
  __UpperCAmelCase				:      str	 =    [2, 2, 6, 2] if """tiny""" in model_name else [2, 2, 18, 2]
  __UpperCAmelCase				:      Any	 =    True if """large""" in model_name or """huge""" in model_name else False
  __UpperCAmelCase				:      int	 =    True if """large""" in model_name or """huge""" in model_name else False
  __UpperCAmelCase				:      Optional[int]	 =    True if """large""" in model_name or """huge""" in model_name else False

  if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
    if "fl3" in model_name:
      __UpperCAmelCase				:      Union[str, Any]	 =    [3, 3, 3, 3]
      __UpperCAmelCase				:      Union[str, Any]	 =    [5, 5, 5, 5]
    elif "fl4" in model_name:
      __UpperCAmelCase				:      str	 =    [4, 4, 4, 4]
      __UpperCAmelCase				:      Optional[Any]	 =    [3, 3, 3, 3]

  if "tiny" in model_name or "small" in model_name or "base" in model_name:
    __UpperCAmelCase				:      Dict	 =    [3, 3, 3, 3]
    if "lrf" in model_name:
      __UpperCAmelCase				:      Optional[Any]	 =    [3, 3, 3, 3]
    else:
      __UpperCAmelCase				:      Optional[int]	 =    [2, 2, 2, 2]

  if "tiny" in model_name:
    __UpperCAmelCase				:      List[str]	 =    96
  elif "small" in model_name:
    __UpperCAmelCase				:      Dict	 =    96
  elif "base" in model_name:
    __UpperCAmelCase				:      List[Any]	 =    128
  elif "large" in model_name:
    __UpperCAmelCase				:      Any	 =    192
  elif "xlarge" in model_name:
    __UpperCAmelCase				:      Tuple	 =    256
  elif "huge" in model_name:
    __UpperCAmelCase				:      int	 =    352

  # set label information
  __UpperCAmelCase				:      Tuple	 =    """huggingface/label-files"""
  if "large" in model_name or "huge" in model_name:
    __UpperCAmelCase				:      Any	 =    """imagenet-22k-id2label.json"""
  else:
    __UpperCAmelCase				:      Dict	 =    """imagenet-1k-id2label.json"""

  __UpperCAmelCase				:      str	 =    json.load(open(hf_hub_download(__lowerCamelCase    ,						__lowerCamelCase    ,						repo_type="""dataset"""						)    ,						"""r"""						)						)
  __UpperCAmelCase				:      Optional[int]	 =    {int(__lowerCamelCase						): v for k, v in idalabel.items()}
  __UpperCAmelCase				:      Union[str, Any]	 =    {v: k for k, v in idalabel.items()}

  __UpperCAmelCase				:      List[str]	 =    FocalNetConfig(
      embed_dim=__lowerCamelCase    ,						depths=__lowerCamelCase    ,						focal_levels=__lowerCamelCase    ,						focal_windows=__lowerCamelCase    ,						use_conv_embed=__lowerCamelCase    ,						idalabel=__lowerCamelCase    ,						labelaid=__lowerCamelCase    ,						use_post_layernorm=__lowerCamelCase    ,						use_layerscale=__lowerCamelCase    ,						)

  return config






def 							lowerCamelCase__ (       __lowerCamelCase     :	Tuple						):
  if "patch_embed.proj" in name:
    __UpperCAmelCase				:      List[Any]	 =    name.replace("""patch_embed.proj"""    ,						"""embeddings.patch_embeddings.projection"""						)
  if "patch_embed.norm" in name:
    __UpperCAmelCase				:      Dict	 =    name.replace("""patch_embed.norm"""    ,						"""embeddings.norm"""						)
  if "layers" in name:
    __UpperCAmelCase				:      int	 =    """encoder.""" + name
  if "encoder.layers" in name:
    __UpperCAmelCase				:      Optional[int]	 =    name.replace("""encoder.layers"""    ,						"""encoder.stages"""						)
  if "downsample.proj" in name:
    __UpperCAmelCase				:      Optional[Any]	 =    name.replace("""downsample.proj"""    ,						"""downsample.projection"""						)
  if "blocks" in name:
    __UpperCAmelCase				:      Union[str, Any]	 =    name.replace("""blocks"""    ,						"""layers"""						)
  if "modulation.f.weight" in name or "modulation.f.bias" in name:
    __UpperCAmelCase				:      List[str]	 =    name.replace("""modulation.f"""    ,						"""modulation.projection_in"""						)
  if "modulation.h.weight" in name or "modulation.h.bias" in name:
    __UpperCAmelCase				:      List[Any]	 =    name.replace("""modulation.h"""    ,						"""modulation.projection_context"""						)
  if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
    __UpperCAmelCase				:      str	 =    name.replace("""modulation.proj"""    ,						"""modulation.projection_out"""						)

  if name == "norm.weight":
    __UpperCAmelCase				:      Optional[Any]	 =    """layernorm.weight"""
  if name == "norm.bias":
    __UpperCAmelCase				:      Dict	 =    """layernorm.bias"""

  if "head" in name:
    __UpperCAmelCase				:      Tuple	 =    name.replace("""head"""    ,						"""classifier"""						)
  else:
    __UpperCAmelCase				:      int	 =    """focalnet.""" + name

  return name






def 							lowerCamelCase__ (       __lowerCamelCase     :	Optional[int]    ,						__lowerCamelCase     :	Optional[Any]    ,						__lowerCamelCase     :	List[str]=False						):
  # fmt: off
  __UpperCAmelCase				:      Dict	 =    {
      """focalnet-tiny""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth""",
      """focalnet-tiny-lrf""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth""",
      """focalnet-small""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth""",
      """focalnet-small-lrf""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth""",
      """focalnet-base""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth""",
      """focalnet-base-lrf""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth""",
      """focalnet-large-lrf-fl3""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth""",
      """focalnet-large-lrf-fl4""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth""",
      """focalnet-xlarge-lrf-fl3""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth""",
      """focalnet-xlarge-lrf-fl4""": """https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth""",
  }
  # fmt: on

  __UpperCAmelCase				:      int	 =    model_name_to_url[model_name]
  print("""Checkpoint URL: """    ,						__lowerCamelCase						)
  __UpperCAmelCase				:      Dict	 =    torch.hub.load_state_dict_from_url(__lowerCamelCase    ,						map_location="""cpu"""						)["""model"""]

  # rename keys
  for key in state_dict.copy().keys():
    __UpperCAmelCase				:      Tuple	 =    state_dict.pop(__lowerCamelCase						)
    __UpperCAmelCase				:      Optional[Any]	 =    val

  __UpperCAmelCase				:      Optional[Any]	 =    get_focalnet_config(__lowerCamelCase						)
  __UpperCAmelCase				:      Any	 =    FocalNetForImageClassification(__lowerCamelCase						)
  model.eval()

  # load state dict
  model.load_state_dict(__lowerCamelCase						)

  # verify conversion
  __UpperCAmelCase				:      Optional[int]	 =    """http://images.cocodataset.org/val2017/000000039769.jpg"""

  __UpperCAmelCase				:      Union[str, Any]	 =    BitImageProcessor(
      do_resize=__lowerCamelCase    ,						size={"""shortest_edge""": 256}    ,						resample=PILImageResampling.BILINEAR    ,						do_center_crop=__lowerCamelCase    ,						crop_size=224    ,						do_normalize=__lowerCamelCase    ,						image_mean=__lowerCamelCase    ,						image_std=__lowerCamelCase    ,						)
  __UpperCAmelCase				:      Optional[Any]	 =    Image.open(requests.get(__lowerCamelCase    ,						stream=__lowerCamelCase						).raw						)
  __UpperCAmelCase				:      List[Any]	 =    processor(images=__lowerCamelCase    ,						return_tensors="""pt"""						)

  __UpperCAmelCase				:      str	 =    transforms.Compose(
      [
          transforms.Resize(256						),
          transforms.CenterCrop(224						),
          transforms.ToTensor(),
          transforms.Normalize(mean=[0.4_8_5, 0.4_5_6, 0.4_0_6]    ,						std=[0.2_2_9, 0.2_2_4, 0.2_2_5]						),
      ]						)

  __UpperCAmelCase				:      List[Any]	 =    image_transforms(__lowerCamelCase						).unsqueeze(0						)

  # verify pixel_values
  assert torch.allclose(inputs.pixel_values    ,						__lowerCamelCase    ,						atol=1E-4						)

  __UpperCAmelCase				:      Dict	 =    model(**__lowerCamelCase						)

  __UpperCAmelCase				:      Any	 =    outputs.logits.argmax(-1						).item()
  print("""Predicted class:"""    ,						model.config.idalabel[predicted_class_idx]						)

  print("""First values of logits:"""    ,						outputs.logits[0, :3]						)

  if model_name == "focalnet-tiny":
    __UpperCAmelCase				:      Union[str, Any]	 =    torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]						)
  elif model_name == "focalnet-tiny-lrf":
    __UpperCAmelCase				:      Dict	 =    torch.tensor([1.1_6_6_9, 0.0_1_2_5, -0.1_6_9_5]						)
  elif model_name == "focalnet-small":
    __UpperCAmelCase				:      int	 =    torch.tensor([0.4_9_1_7, -0.0_4_3_0, 0.1_3_4_1]						)
  elif model_name == "focalnet-small-lrf":
    __UpperCAmelCase				:      int	 =    torch.tensor([-0.2_5_8_8, -0.5_3_4_2, -0.2_3_3_1]						)
  elif model_name == "focalnet-base":
    __UpperCAmelCase				:      Optional[int]	 =    torch.tensor([-0.1_6_5_5, -0.4_0_9_0, -0.1_7_3_0]						)
  elif model_name == "focalnet-base-lrf":
    __UpperCAmelCase				:      Optional[Any]	 =    torch.tensor([0.5_3_0_6, -0.0_4_8_3, -0.3_9_2_8]						)
  assert torch.allclose(outputs.logits[0, :3]    ,						__lowerCamelCase    ,						atol=1E-4						)
  print("""Looks ok!"""						)

  if pytorch_dump_folder_path is not None:
    print(f"""Saving model and processor of {model_name} to {pytorch_dump_folder_path}"""						)
    model.save_pretrained(__lowerCamelCase						)
    processor.save_pretrained(__lowerCamelCase						)

  if push_to_hub:
    print(f"""Pushing model and processor of {model_name} to the hub..."""						)
    model.push_to_hub(f"""{model_name}"""						)
    processor.push_to_hub(f"""{model_name}"""						)


if __name__ == "__main__":
       a						:			Union[str, Any]     	=					argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           "--model_name",
           default="focalnet-tiny",
           type=str,
           help="Name of the FocalNet model you'd like to convert.",
       )
       parser.add_argument(
           "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
       )
       parser.add_argument(
           "--push_to_hub",
           action="store_true",
           help="Whether to push the model and processor to the hub.",
       )

       a						:			Any     	=					parser.parse_args()
       convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)



'''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 							a__(   lowerCAmelCase__      ):


			'''simple docstring'''






			UpperCAmelCase_     :	"DiagonalGaussianDistribution"







class 							a__(   lowerCAmelCase__					,		lowerCAmelCase__      ):


			'''simple docstring'''






			UpperCAmelCase_     :	List[Any]						=			True



			@register_to_config
			def __init__(  self			,       __lowerCAmelCase = 3			,       __lowerCAmelCase = 3			,       __lowerCAmelCase = ("DownEncoderBlock2D",)			,       __lowerCAmelCase = ("UpDecoderBlock2D",)			,       __lowerCAmelCase = (64,)			,       __lowerCAmelCase = 1			,       __lowerCAmelCase = "silu"			,       __lowerCAmelCase = 4			,       __lowerCAmelCase = 32			,       __lowerCAmelCase = 32			,       __lowerCAmelCase = 0.18215			,       ):




					"""simple docstring"""


					super().__init__()

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

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

					lowerCAmelCase     =    nn.Convad(2 * latent_channels			,       2 * latent_channels			,       1)
					lowerCAmelCase     =    nn.Convad(__lowerCAmelCase			,       __lowerCAmelCase			,       1)

					lowerCAmelCase     =    False
					lowerCAmelCase     =    False

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



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase=False):




					"""simple docstring"""


					if isinstance(__lowerCAmelCase			,       (Encoder, Decoder)):
							lowerCAmelCase     =    value



			def 				a_			(  self			,       __lowerCAmelCase = True):




					"""simple docstring"""


					lowerCAmelCase     =    use_tiling



			def 				a_			(  self):




					"""simple docstring"""


					self.enable_tiling(__lowerCAmelCase)



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    True



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    False



			@property
			# Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    {}

					def fn_recursive_add_processors(__lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase):
							if hasattr(__lowerCAmelCase			,       """set_processor"""):
									lowerCAmelCase     =    module.processor

							for sub_name, child in module.named_children():
									fn_recursive_add_processors(f"{name}.{sub_name}"			,       __lowerCAmelCase			,       __lowerCAmelCase)

							return processors

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

					return processors



			def 				a_			(  self			,       __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase     =    len(self.attn_processors.keys())

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

					def fn_recursive_attn_processor(__lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase):
							if hasattr(__lowerCAmelCase			,       """set_processor"""):
									if not isinstance(__lowerCAmelCase			,       __lowerCAmelCase):
											module.set_processor(__lowerCAmelCase)
									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}"			,       __lowerCAmelCase			,       __lowerCAmelCase)

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



			def 				a_			(  self):




					"""simple docstring"""


					self.set_attn_processor(AttnProcessor())



			@apply_forward_hook
			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = True):




					"""simple docstring"""


					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(__lowerCAmelCase			,       return_dict=__lowerCAmelCase)

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

					lowerCAmelCase     =    self.quant_conv(__lowerCAmelCase)
					lowerCAmelCase     =    DiagonalGaussianDistribution(__lowerCAmelCase)

					if not return_dict:
							return (posterior,)

					return AutoencoderKLOutput(latent_dist=__lowerCAmelCase)



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = True):




					"""simple docstring"""


					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(__lowerCAmelCase			,       return_dict=__lowerCAmelCase)

					lowerCAmelCase     =    self.post_quant_conv(__lowerCAmelCase)
					lowerCAmelCase     =    self.decoder(__lowerCAmelCase)

					if not return_dict:
							return (dec,)

					return DecoderOutput(sample=__lowerCAmelCase)



			@apply_forward_hook
			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = True):




					"""simple docstring"""


					if self.use_slicing and z.shape[0] > 1:
							lowerCAmelCase     =    [self._decode(__lowerCAmelCase).sample for z_slice in z.split(1)]
							lowerCAmelCase     =    torch.cat(__lowerCAmelCase)
					else:
							lowerCAmelCase     =    self._decode(__lowerCAmelCase).sample

					if not return_dict:
							return (decoded,)

					return DecoderOutput(sample=__lowerCAmelCase)



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase     =    min(a.shape[2]			,       b.shape[2]			,       __lowerCAmelCase)
					for y in range(__lowerCAmelCase):
							lowerCAmelCase     =    a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent)
					return b



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase     =    min(a.shape[3]			,       b.shape[3]			,       __lowerCAmelCase)
					for x in range(__lowerCAmelCase):
							lowerCAmelCase     =    a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent)
					return b



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = True):




					"""simple docstring"""


					lowerCAmelCase     =    int(self.tile_sample_min_size * (1 - self.tile_overlap_factor))
					lowerCAmelCase     =    int(self.tile_latent_min_size * self.tile_overlap_factor)
					lowerCAmelCase     =    self.tile_latent_min_size - blend_extent

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

					lowerCAmelCase     =    torch.cat(__lowerCAmelCase			,       dim=2)
					lowerCAmelCase     =    DiagonalGaussianDistribution(__lowerCAmelCase)

					if not return_dict:
							return (posterior,)

					return AutoencoderKLOutput(latent_dist=__lowerCAmelCase)



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = True):




					"""simple docstring"""


					lowerCAmelCase     =    int(self.tile_latent_min_size * (1 - self.tile_overlap_factor))
					lowerCAmelCase     =    int(self.tile_sample_min_size * self.tile_overlap_factor)
					lowerCAmelCase     =    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.
					lowerCAmelCase     =    []
					for i in range(0			,       z.shape[2]			,       __lowerCAmelCase):
							lowerCAmelCase     =    []
							for j in range(0			,       z.shape[3]			,       __lowerCAmelCase):
									lowerCAmelCase     =    z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size]
									lowerCAmelCase     =    self.post_quant_conv(__lowerCAmelCase)
									lowerCAmelCase     =    self.decoder(__lowerCAmelCase)
									row.append(__lowerCAmelCase)
							rows.append(__lowerCAmelCase)
					lowerCAmelCase     =    []
					for i, row in enumerate(__lowerCAmelCase):
							lowerCAmelCase     =    []
							for j, tile in enumerate(__lowerCAmelCase):
									# blend the above tile and the left tile
									# to the current tile and add the current tile to the result row
									if i > 0:
											lowerCAmelCase     =    self.blend_v(rows[i - 1][j]			,       __lowerCAmelCase			,       __lowerCAmelCase)
									if j > 0:
											lowerCAmelCase     =    self.blend_h(row[j - 1]			,       __lowerCAmelCase			,       __lowerCAmelCase)
									result_row.append(tile[:, :, :row_limit, :row_limit])
							result_rows.append(torch.cat(__lowerCAmelCase			,       dim=3))

					lowerCAmelCase     =    torch.cat(__lowerCAmelCase			,       dim=2)
					if not return_dict:
							return (dec,)

					return DecoderOutput(sample=__lowerCAmelCase)







			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = False			,       __lowerCAmelCase = True			,       __lowerCAmelCase = None			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    sample
					lowerCAmelCase     =    self.encode(__lowerCAmelCase).latent_dist
					if sample_posterior:
							lowerCAmelCase     =    posterior.sample(generator=__lowerCAmelCase)
					else:
							lowerCAmelCase     =    posterior.mode()
					lowerCAmelCase     =    self.decode(__lowerCAmelCase).sample

					if not return_dict:
							return (dec,)

					return DecoderOutput(sample=__lowerCAmelCase)




