





'''simple docstring'''


import argparse
import collections
import json
from pathlib import Path

import requests
import torch
import yaml
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    MobileViTImageProcessor,
    MobileViTVaConfig,
    MobileViTVaForImageClassification,
    MobileViTVaForSemanticSegmentation,
)
from transformers.utils import logging


logging.set_verbosity_info()
a__			:					Tuple       						=						logging.get_logger(__name__)
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			List[Any] )							->     Optional[int]:

       """simple docstring"""


       print('''Loading config file...''' )

       def flatten_yaml_as_dict(SCREAMING_SNAKE_CASE_ :			Union[str, Any]			,	SCREAMING_SNAKE_CASE_ :			Optional[int]=""			,	SCREAMING_SNAKE_CASE_ :			Dict="." ):
              UpperCAmelCase  =						[]
              for k, v in d.items():
                     UpperCAmelCase  =						parent_key + sep + k if parent_key else k
                     if isinstance(SCREAMING_SNAKE_CASE_			,	collections.abc.MutableMapping ):
                            items.extend(flatten_yaml_as_dict(SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_			,	sep=SCREAMING_SNAKE_CASE_ ).items() )
                     else:
                            items.append((new_key, v) )
              return dict(SCREAMING_SNAKE_CASE_ )

       UpperCAmelCase  =						argparse.Namespace()
       with open(SCREAMING_SNAKE_CASE_			,	'''r''' ) as yaml_file:
              try:
                     UpperCAmelCase  =						yaml.load(SCREAMING_SNAKE_CASE_			,	Loader=yaml.FullLoader )

                     UpperCAmelCase  =						flatten_yaml_as_dict(SCREAMING_SNAKE_CASE_ )
                     for k, v in flat_cfg.items():
                            setattr(SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_ )
              except yaml.YAMLError as exc:
                     logger.error('''Error while loading config file: {}. Error message: {}'''.format(SCREAMING_SNAKE_CASE_			,	str(SCREAMING_SNAKE_CASE_ ) ) )
       return config
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			str			,	SCREAMING_SNAKE_CASE_ :			Optional[int] )							->     int:

       """simple docstring"""


       UpperCAmelCase  =						MobileViTVaConfig()

       UpperCAmelCase  =						False

       # dataset
       if task_name.startswith('''imagenet1k_''' ):
              UpperCAmelCase  =						1_000
              if int(task_name.strip().split('''_''' )[-1] ) == 384:
                     UpperCAmelCase  =						384
              else:
                     UpperCAmelCase  =						256
              UpperCAmelCase  =						'''imagenet-1k-id2label.json'''
       elif task_name.startswith('''imagenet21k_to_1k_''' ):
              UpperCAmelCase  =						21_000
              if int(task_name.strip().split('''_''' )[-1] ) == 384:
                     UpperCAmelCase  =						384
              else:
                     UpperCAmelCase  =						256
              UpperCAmelCase  =						'''imagenet-22k-id2label.json'''
       elif task_name.startswith('''ade20k_''' ):
              UpperCAmelCase  =						151
              UpperCAmelCase  =						512
              UpperCAmelCase  =						'''ade20k-id2label.json'''
              UpperCAmelCase  =						True
       elif task_name.startswith('''voc_''' ):
              UpperCAmelCase  =						21
              UpperCAmelCase  =						512
              UpperCAmelCase  =						'''pascal-voc-id2label.json'''
              UpperCAmelCase  =						True

       # orig_config
       UpperCAmelCase  =						load_orig_config_file(SCREAMING_SNAKE_CASE_ )
       assert getattr(SCREAMING_SNAKE_CASE_			,	'''model.classification.name'''			,	-1 ) == "mobilevit_v2", "Invalid model"
       UpperCAmelCase  =						getattr(SCREAMING_SNAKE_CASE_			,	'''model.classification.mitv2.width_multiplier'''			,	1.0 )
       assert (
           getattr(SCREAMING_SNAKE_CASE_			,	'''model.classification.mitv2.attn_norm_layer'''			,	-1 ) == "layer_norm_2d"
       ), "Norm layers other than layer_norm_2d is not supported"
       UpperCAmelCase  =						getattr(SCREAMING_SNAKE_CASE_			,	'''model.classification.activation.name'''			,	'''swish''' )
       # config.image_size == getattr(orig_config,  'sampler.bs.crop_size_width', 256)

       if is_segmentation_model:
              UpperCAmelCase  =						getattr(SCREAMING_SNAKE_CASE_			,	'''model.segmentation.output_stride'''			,	16 )
              if "_deeplabv3" in task_name:
                     UpperCAmelCase  =						getattr(SCREAMING_SNAKE_CASE_			,	'''model.segmentation.deeplabv3.aspp_rates'''			,	[12, 24, 36] )
                     UpperCAmelCase  =						getattr(SCREAMING_SNAKE_CASE_			,	'''model.segmentation.deeplabv3.aspp_out_channels'''			,	512 )
                     UpperCAmelCase  =						getattr(SCREAMING_SNAKE_CASE_			,	'''model.segmentation.deeplabv3.aspp_dropout'''			,	0.1 )

    # id2label
       UpperCAmelCase  =						'''huggingface/label-files'''
       UpperCAmelCase  =						json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_			,	repo_type='''dataset''' )			,	'''r''' ) )
       UpperCAmelCase  =						{int(SCREAMING_SNAKE_CASE_ ): v for k, v in idalabel.items()}
       UpperCAmelCase  =						idalabel
       UpperCAmelCase  =						{v: k for k, v in idalabel.items()}

       return config
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			Any			,	SCREAMING_SNAKE_CASE_ :			int			,	SCREAMING_SNAKE_CASE_ :			List[str] )							->     str:

       """simple docstring"""


       UpperCAmelCase  =						dct.pop(SCREAMING_SNAKE_CASE_ )
       UpperCAmelCase  =						val
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			Union[str, Any]			,	SCREAMING_SNAKE_CASE_ :			str=False )							->     int:

       """simple docstring"""


       if base_model:
              UpperCAmelCase  =						''''''
       else:
              UpperCAmelCase  =						'''mobilevitv2.'''

       UpperCAmelCase  =						[]
       for k in state_dict.keys():
              if k[:8] == "encoder.":
                     UpperCAmelCase  =						k[8:]
              else:
                     UpperCAmelCase  =						k

              if ".block." in k:
                     UpperCAmelCase  =						k_new.replace('''.block.'''			,	'''.''' )
              if ".conv." in k:
                     UpperCAmelCase  =						k_new.replace('''.conv.'''			,	'''.convolution.''' )
              if ".norm." in k:
                     UpperCAmelCase  =						k_new.replace('''.norm.'''			,	'''.normalization.''' )

              if "conv_1." in k:
                     UpperCAmelCase  =						k_new.replace('''conv_1.'''			,	f"{model_prefix}conv_stem." )
              for i in [1, 2]:
                     if f"layer_{i}." in k:
                            UpperCAmelCase  =						k_new.replace(f"layer_{i}."			,	f"{model_prefix}encoder.layer.{i-1}.layer." )
              if ".exp_1x1." in k:
                     UpperCAmelCase  =						k_new.replace('''.exp_1x1.'''			,	'''.expand_1x1.''' )
              if ".red_1x1." in k:
                     UpperCAmelCase  =						k_new.replace('''.red_1x1.'''			,	'''.reduce_1x1.''' )

              for i in [3, 4, 5]:
                     if f"layer_{i}.0." in k:
                            UpperCAmelCase  =						k_new.replace(f"layer_{i}.0."			,	f"{model_prefix}encoder.layer.{i-1}.downsampling_layer." )
                     if f"layer_{i}.1.local_rep.0." in k:
                            UpperCAmelCase  =						k_new.replace(f"layer_{i}.1.local_rep.0."			,	f"{model_prefix}encoder.layer.{i-1}.conv_kxk." )
                     if f"layer_{i}.1.local_rep.1." in k:
                            UpperCAmelCase  =						k_new.replace(f"layer_{i}.1.local_rep.1."			,	f"{model_prefix}encoder.layer.{i-1}.conv_1x1." )

              for i in [3, 4, 5]:
                     if i == 3:
                            UpperCAmelCase  =						[0, 1]
                     elif i == 4:
                            UpperCAmelCase  =						[0, 1, 2, 3]
                     elif i == 5:
                            UpperCAmelCase  =						[0, 1, 2]

                     for j in j_in:
                            if f"layer_{i}.1.global_rep.{j}." in k:
                                   UpperCAmelCase  =						k_new.replace(
                                       f"layer_{i}.1.global_rep.{j}."			,	f"{model_prefix}encoder.layer.{i-1}.transformer.layer.{j}." )
                     if f"layer_{i}.1.global_rep.{j+1}." in k:
                            UpperCAmelCase  =						k_new.replace(
                                f"layer_{i}.1.global_rep.{j+1}."			,	f"{model_prefix}encoder.layer.{i-1}.layernorm." )

                     if f"layer_{i}.1.conv_proj." in k:
                            UpperCAmelCase  =						k_new.replace(f"layer_{i}.1.conv_proj."			,	f"{model_prefix}encoder.layer.{i-1}.conv_projection." )

              if "pre_norm_attn.0." in k:
                     UpperCAmelCase  =						k_new.replace('''pre_norm_attn.0.'''			,	'''layernorm_before.''' )
              if "pre_norm_attn.1." in k:
                     UpperCAmelCase  =						k_new.replace('''pre_norm_attn.1.'''			,	'''attention.''' )
              if "pre_norm_ffn.0." in k:
                     UpperCAmelCase  =						k_new.replace('''pre_norm_ffn.0.'''			,	'''layernorm_after.''' )
              if "pre_norm_ffn.1." in k:
                     UpperCAmelCase  =						k_new.replace('''pre_norm_ffn.1.'''			,	'''ffn.conv1.''' )
              if "pre_norm_ffn.3." in k:
                     UpperCAmelCase  =						k_new.replace('''pre_norm_ffn.3.'''			,	'''ffn.conv2.''' )

              if "classifier.1." in k:
                     UpperCAmelCase  =						k_new.replace('''classifier.1.'''			,	'''classifier.''' )

              if "seg_head." in k:
                     UpperCAmelCase  =						k_new.replace('''seg_head.'''			,	'''segmentation_head.''' )
              if ".aspp_layer." in k:
                     UpperCAmelCase  =						k_new.replace('''.aspp_layer.'''			,	'''.''' )
              if ".aspp_pool." in k:
                     UpperCAmelCase  =						k_new.replace('''.aspp_pool.'''			,	'''.''' )

              rename_keys.append((k, k_new) )
       return rename_keys
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			Tuple )							->     int:

       """simple docstring"""


       UpperCAmelCase  =						[]
       for k in state_dict.keys():
              if k.startswith('''seg_head.aux_head.''' ):
                     keys_to_ignore.append(SCREAMING_SNAKE_CASE_ )
       for k in keys_to_ignore:
              state_dict.pop(SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_ )
def       __snake_case		( )							->     List[Any]:

       """simple docstring"""


       UpperCAmelCase  =						'''http://images.cocodataset.org/val2017/000000039769.jpg'''
       # url = "https://cdn.britannica.com/86/141086-050-9D7C75EE/Gulfstream-G450-business-jet-passengers.jpg"
       UpperCAmelCase  =						Image.open(requests.get(SCREAMING_SNAKE_CASE_			,	stream=SCREAMING_SNAKE_CASE_ ).raw )
       return im
@torch.no_grad()
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			int			,	SCREAMING_SNAKE_CASE_ :			List[str]			,	SCREAMING_SNAKE_CASE_ :			str			,	SCREAMING_SNAKE_CASE_ :			Optional[Any] )							->     Tuple:

       """simple docstring"""


       UpperCAmelCase  =						get_mobilevitva_config(SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_ )

       # load original state_dict
       UpperCAmelCase  =						torch.load(SCREAMING_SNAKE_CASE_			,	map_location='''cpu''' )

       # load huggingface model
       if task_name.startswith('''ade20k_''' ) or task_name.startswith('''voc_''' ):
              UpperCAmelCase  =						MobileViTVaForSemanticSegmentation(SCREAMING_SNAKE_CASE_ ).eval()
              UpperCAmelCase  =						False
       else:
              UpperCAmelCase  =						MobileViTVaForImageClassification(SCREAMING_SNAKE_CASE_ ).eval()
              UpperCAmelCase  =						False

       # remove and rename some keys of load the original model
       UpperCAmelCase  =						checkpoint
       remove_unused_keys(SCREAMING_SNAKE_CASE_ )
       UpperCAmelCase  =						create_rename_keys(SCREAMING_SNAKE_CASE_			,	base_model=SCREAMING_SNAKE_CASE_ )
       for rename_key_src, rename_key_dest in rename_keys:
              rename_key(SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_ )

       # load modified state_dict
       model.load_state_dict(SCREAMING_SNAKE_CASE_ )

       # Check outputs on an image, prepared by MobileViTImageProcessor
       UpperCAmelCase  =						MobileViTImageProcessor(crop_size=config.image_size			,	size=config.image_size + 32 )
       UpperCAmelCase  =						image_processor(images=prepare_img()			,	return_tensors='''pt''' )
       UpperCAmelCase  =						model(**SCREAMING_SNAKE_CASE_ )

       # verify classification model
       if task_name.startswith('''imagenet''' ):
              UpperCAmelCase  =						outputs.logits
              UpperCAmelCase  =						logits.argmax(-1 ).item()
              print('''Predicted class:'''			,	model.config.idalabel[predicted_class_idx] )
              if task_name.startswith('''imagenet1k_256''' ) and config.width_multiplier == 1.0:
                     # expected_logits for base variant
                     UpperCAmelCase  =						torch.tensor([-1.6_336e00, -7.3_204e-02, -5.1_883e-01] )
                     assert torch.allclose(logits[0, :3]			,	SCREAMING_SNAKE_CASE_			,	atol=1e-4 )

       Path(SCREAMING_SNAKE_CASE_ ).mkdir(exist_ok=SCREAMING_SNAKE_CASE_ )
       print(f"Saving model {task_name} to {pytorch_dump_folder_path}" )
       model.save_pretrained(SCREAMING_SNAKE_CASE_ )
       print(f"Saving image processor to {pytorch_dump_folder_path}" )
       image_processor.save_pretrained(SCREAMING_SNAKE_CASE_ )


if __name__ == "__main__":
    a__			:					Optional[int]       						=						argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '--task',
        default='imagenet1k_256',
        type=str,
        help=(
            'Name of the task for which the MobileViTV2 model you\'d like to convert is trained on . '
            '\n                Classification (ImageNet-1k)\n                    - MobileViTV2 (256x256) : imagenet1k_256\n                    - MobileViTV2 (Trained on 256x256 and Finetuned on 384x384) : imagenet1k_384\n                    - MobileViTV2 (Trained on ImageNet-21k and Finetuned on ImageNet-1k 256x256) :\n                      imagenet21k_to_1k_256\n                    - MobileViTV2 (Trained on ImageNet-21k, Finetuned on ImageNet-1k 256x256, and Finetuned on\n                      ImageNet-1k 384x384) : imagenet21k_to_1k_384\n                Segmentation\n                    - ADE20K Dataset : ade20k_deeplabv3\n                    - Pascal VOC 2012 Dataset: voc_deeplabv3\n            '
        ),
        choices=[
            'imagenet1k_256',
            'imagenet1k_384',
            'imagenet21k_to_1k_256',
            'imagenet21k_to_1k_384',
            'ade20k_deeplabv3',
            'voc_deeplabv3',
        ],
    )

    parser.add_argument(
        '--orig_checkpoint_path', required=True, type=str, help='Path to the original state dict (.pt file).'
    )
    parser.add_argument('--orig_config_path', required=True, type=str, help='Path to the original config file.')
    parser.add_argument(
        '--pytorch_dump_folder_path', required=True, type=str, help='Path to the output PyTorch model directory.'
    )

    a__			:					str       						=						parser.parse_args()
    convert_mobilevitva_checkpoint(
        args.task, args.orig_checkpoint_path, args.orig_config_path, args.pytorch_dump_folder_path
    )



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

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .embeddings import GaussianFourierProjection, TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin
from .unet_ad_blocks import get_down_block, get_mid_block, get_out_block, get_up_block

@dataclass
class 					_lowercase    (     UpperCAmelCase__			):






    '''simple docstring'''
    SCREAMING_SNAKE_CASE:				torch.FloatTensor





class 					_lowercase    (     UpperCAmelCase__ ,  UpperCAmelCase__			):






    '''simple docstring'''




    @register_to_config
    def __init__(    self       ,						lowerCamelCase__ = 65_536       ,						lowerCamelCase__ = None       ,						lowerCamelCase__ = 2       ,						lowerCamelCase__ = 2       ,						lowerCamelCase__ = 0       ,						lowerCamelCase__ = "fourier"       ,						lowerCamelCase__ = True       ,						lowerCamelCase__ = False       ,						lowerCamelCase__ = 0.0       ,						lowerCamelCase__ = ("DownBlock1DNoSkip", "DownBlock1D", "AttnDownBlock1D")       ,						lowerCamelCase__ = ("AttnUpBlock1D", "UpBlock1D", "UpBlock1DNoSkip")       ,						lowerCamelCase__ = "UNetMidBlock1D"       ,						lowerCamelCase__ = None       ,						lowerCamelCase__ = (32, 32, 64)       ,						lowerCamelCase__ = None       ,						lowerCamelCase__ = 8       ,						lowerCamelCase__ = 1       ,						lowerCamelCase__ = False       ,						):
       super().__init__()
       lowerCAmelCase_:							Optional[Any]       =	sample_size

       # time
       if time_embedding_type == "fourier":
          lowerCAmelCase_:							Dict       =	GaussianFourierProjection(
              embedding_size=8       ,						set_W_to_weight=lowerCamelCase__       ,						log=lowerCamelCase__       ,						flip_sin_to_cos=lowerCamelCase__ )
          lowerCAmelCase_:							List[str]       =	2 * block_out_channels[0]
       elif time_embedding_type == "positional":
          lowerCAmelCase_:							Tuple       =	Timesteps(
              block_out_channels[0]       ,						flip_sin_to_cos=lowerCamelCase__       ,						downscale_freq_shift=lowerCamelCase__ )
          lowerCAmelCase_:							Dict       =	block_out_channels[0]

       if use_timestep_embedding:
          lowerCAmelCase_:							Tuple       =	block_out_channels[0] * 4
          lowerCAmelCase_:							Any       =	TimestepEmbedding(
              in_channels=lowerCamelCase__       ,						time_embed_dim=lowerCamelCase__       ,						act_fn=lowerCamelCase__       ,						out_dim=block_out_channels[0]       ,						)

       lowerCAmelCase_:							str       =	nn.ModuleList([] )
       lowerCAmelCase_:							Dict       =	None
       lowerCAmelCase_:							Optional[Any]       =	nn.ModuleList([] )
       lowerCAmelCase_:							int       =	None

       # down
       lowerCAmelCase_:							List[str]       =	in_channels
       for i, down_block_type in enumerate(lowerCamelCase__ ):
          lowerCAmelCase_:							Optional[int]       =	output_channel
          lowerCAmelCase_:							Optional[Any]       =	block_out_channels[i]

          if i == 0:
             input_channel += extra_in_channels

          lowerCAmelCase_:							List[str]       =	i == len(lowerCamelCase__ ) - 1

          lowerCAmelCase_:							List[str]       =	get_down_block(
              lowerCamelCase__       ,						num_layers=lowerCamelCase__       ,						in_channels=lowerCamelCase__       ,						out_channels=lowerCamelCase__       ,						temb_channels=block_out_channels[0]       ,						add_downsample=not is_final_block or downsample_each_block       ,						)
          self.down_blocks.append(lowerCamelCase__ )

       # mid
       lowerCAmelCase_:							Optional[int]       =	get_mid_block(
           lowerCamelCase__       ,						in_channels=block_out_channels[-1]       ,						mid_channels=block_out_channels[-1]       ,						out_channels=block_out_channels[-1]       ,						embed_dim=block_out_channels[0]       ,						num_layers=lowerCamelCase__       ,						add_downsample=lowerCamelCase__       ,						)

       # up
       lowerCAmelCase_:							Dict       =	list(reversed(lowerCamelCase__ ) )
       lowerCAmelCase_:							Any       =	reversed_block_out_channels[0]
       if out_block_type is None:
          lowerCAmelCase_:							str       =	out_channels
       else:
          lowerCAmelCase_:							Any       =	block_out_channels[0]

       for i, up_block_type in enumerate(lowerCamelCase__ ):
          lowerCAmelCase_:							Dict       =	output_channel
          lowerCAmelCase_:							int       =	(
              reversed_block_out_channels[i + 1] if i < len(lowerCamelCase__ ) - 1 else final_upsample_channels
          )

          lowerCAmelCase_:							Optional[int]       =	i == len(lowerCamelCase__ ) - 1

          lowerCAmelCase_:							Union[str, Any]       =	get_up_block(
              lowerCamelCase__       ,						num_layers=lowerCamelCase__       ,						in_channels=lowerCamelCase__       ,						out_channels=lowerCamelCase__       ,						temb_channels=block_out_channels[0]       ,						add_upsample=not is_final_block       ,						)
          self.up_blocks.append(lowerCamelCase__ )
          lowerCAmelCase_:							str       =	output_channel

       # out
       lowerCAmelCase_:							List[str]       =	norm_num_groups if norm_num_groups is not None else min(block_out_channels[0] // 4       ,						32 )
       lowerCAmelCase_:							int       =	get_out_block(
           out_block_type=lowerCamelCase__       ,						num_groups_out=lowerCamelCase__       ,						embed_dim=block_out_channels[0]       ,						out_channels=lowerCamelCase__       ,						act_fn=lowerCamelCase__       ,						fc_dim=block_out_channels[-1] // 4       ,						)




    def      _a    (    self       ,						lowerCamelCase__       ,						lowerCamelCase__       ,						lowerCamelCase__ = True       ,						):
       lowerCAmelCase_:							Any       =	timestep
       if not torch.is_tensor(lowerCamelCase__ ):
          lowerCAmelCase_:							Optional[Any]       =	torch.tensor([timesteps]       ,						dtype=torch.long       ,						device=sample.device )
       elif torch.is_tensor(lowerCamelCase__ ) and len(timesteps.shape ) == 0:
          lowerCAmelCase_:							List[Any]       =	timesteps[None].to(sample.device )

       lowerCAmelCase_:							Union[str, Any]       =	self.time_proj(lowerCamelCase__ )
       if self.config.use_timestep_embedding:
          lowerCAmelCase_:							Any       =	self.time_mlp(lowerCamelCase__ )
       else:
          lowerCAmelCase_:							Any       =	timestep_embed[..., None]
          lowerCAmelCase_:							str       =	timestep_embed.repeat([1, 1, sample.shape[2]] ).to(sample.dtype )
          lowerCAmelCase_:							Dict       =	timestep_embed.broadcast_to((sample.shape[:1] + timestep_embed.shape[1:]) )

       # 2. down
       lowerCAmelCase_:							Dict       =	()
       for downsample_block in self.down_blocks:
          lowerCAmelCase_  ,	lowerCAmelCase_:							Optional[int]       =	downsample_block(hidden_states=lowerCamelCase__       ,						temb=lowerCamelCase__ )
          down_block_res_samples += res_samples

       # 3. mid
       if self.mid_block:
          lowerCAmelCase_:							int       =	self.mid_block(lowerCamelCase__       ,						lowerCamelCase__ )

       # 4. up
       for i, upsample_block in enumerate(self.up_blocks ):
          lowerCAmelCase_:							Any       =	down_block_res_samples[-1:]
          lowerCAmelCase_:							str       =	down_block_res_samples[:-1]
          lowerCAmelCase_:							List[str]       =	upsample_block(lowerCamelCase__       ,						res_hidden_states_tuple=lowerCamelCase__       ,						temb=lowerCamelCase__ )

       # 5. post-process
       if self.out_block:
          lowerCAmelCase_:							Any       =	self.out_block(lowerCamelCase__       ,						lowerCamelCase__ )

       if not return_dict:
          return (sample,)

       return UNetaDOutput(sample=lowerCamelCase__ )