
import os
from glob import glob

import imageio
import torch
import torchvision
import wandb
from img_processing import custom_to_pil, loop_post_process, preprocess, preprocess_vqgan
from loaders import load_vqgan
from PIL import Image
from torch import nn

from transformers import CLIPModel, CLIPTokenizerFast
from utils import get_device, get_timestamp, show_pil






class   UpperCAmelCase		:



   def __init__(self		:					List[str]    ,						snake_case__		:					str = "cpu"    ,						snake_case__		:					str = "openai/clip-vit-large-patch14" )		->	None:


          '''simple docstring'''


          snake_case       :   int							=      device
          snake_case       :   str							=      CLIPTokenizerFast.from_pretrained(snake_case__ )
          snake_case       :   List[Any]							=      [0.48145466, 0.4578275, 0.40821073]
          snake_case       :   Optional[int]							=      [0.26862954, 0.26130258, 0.27577711]
          snake_case       :   List[Any]							=      torchvision.transforms.Normalize(self.image_mean    ,						self.image_std )
          snake_case       :   List[str]							=      torchvision.transforms.Resize(2_24 )
          snake_case       :   List[Any]							=      torchvision.transforms.CenterCrop(2_24 )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int]    ,						snake_case__		:					Union[str, Any] )		->	Optional[Any]:


          '''simple docstring'''


          snake_case       :   List[str]							=      self.resize(snake_case__ )
          snake_case       :   Union[str, Any]							=      self.center_crop(snake_case__ )
          snake_case       :   str							=      self.normalize(snake_case__ )
          return images



   def __call__(self		:					Optional[int]    ,						snake_case__		:					Optional[int]=None    ,						snake_case__		:					List[Any]=None    ,						**snake_case__		:					int )		->	List[Any]:


          '''simple docstring'''


          snake_case       :   Dict							=      self.tokenizer(text=snake_case__    ,						**snake_case__ )
          snake_case       :   str							=      self.preprocess_img(snake_case__ )
          snake_case       :   Any							=      {key: value.to(self.device ) for (key, value) in encoding.items()}
          return encoding






class   UpperCAmelCase		(						nn.Module ):



   def __init__(self		:					int    ,						snake_case__		:					Tuple=10    ,						snake_case__		:					List[str]=0.01    ,						snake_case__		:					Dict=None    ,						snake_case__		:					List[str]=None    ,						snake_case__		:					Dict=None    ,						snake_case__		:					Optional[Any]=None    ,						snake_case__		:					Union[str, Any]=None    ,						snake_case__		:					Dict=None    ,						snake_case__		:					Any=False    ,						snake_case__		:					Optional[Any]=True    ,						snake_case__		:					Any="image"    ,						snake_case__		:					str=True    ,						snake_case__		:					Any=False    ,						snake_case__		:					List[str]=False    ,						snake_case__		:					Optional[Any]=False    ,						)		->	None:


          '''simple docstring'''


          super().__init__()
          snake_case       :   List[str]							=      None
          snake_case       :   Optional[int]							=      device if device else get_device()
          if vqgan:
                 snake_case       :   List[Any]							=      vqgan
          else:
                 snake_case       :   Tuple							=      load_vqgan(self.device    ,						conf_path=snake_case__    ,						ckpt_path=snake_case__ )
          self.vqgan.eval()
          if clip:
                 snake_case       :   Any							=      clip
          else:
                 snake_case       :   Optional[Any]							=      CLIPModel.from_pretrained("openai/clip-vit-base-patch32" )
          self.clip.to(self.device )
          snake_case       :   Optional[Any]							=      ProcessorGradientFlow(device=self.device )

          snake_case       :   Optional[int]							=      iterations
          snake_case       :   str							=      lr
          snake_case       :   List[Any]							=      log
          snake_case       :   Optional[int]							=      make_grid
          snake_case       :   str							=      return_val
          snake_case       :   List[Any]							=      quantize
          snake_case       :   List[str]							=      self.vqgan.decoder.z_shape



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int]    ,						snake_case__		:					Dict=None    ,						snake_case__		:					Tuple=None    ,						snake_case__		:					Any=5    ,						snake_case__		:					Optional[Any]=True )		->	Any:


          '''simple docstring'''


          snake_case       :   List[Any]							=      []
          if output_path is None:
                 snake_case       :   List[Any]							=      "./animation.gif"
          if input_path is None:
                 snake_case       :   Any							=      self.save_path
          snake_case       :   int							=      sorted(glob(input_path + "/*" ) )
          if not len(snake_case__ ):
                 raise ValueError(
                     "No images found in save path, aborting (did you pass save_intermediate=True to the generate"
                     " function?)" )
          if len(snake_case__ ) == 1:
                 print("Only one image found in save path, (did you pass save_intermediate=True to the generate function?)" )
          snake_case       :   List[Any]							=      total_duration / len(snake_case__ )
          snake_case       :   Union[str, Any]							=      [frame_duration] * len(snake_case__ )
          if extend_frames:
                 snake_case       :   Union[str, Any]							=      1.5
                 snake_case       :   int							=      3
          for file_name in paths:
                 if file_name.endswith(".png" ):
                        images.append(imageio.imread(snake_case__ ) )
          imageio.mimsave(snake_case__    ,						snake_case__    ,						duration=snake_case__ )
          print(f"""gif saved to {output_path}""" )



   def 				_SCREAMING_SNAKE_CASE   (self		:					str    ,						snake_case__		:					str=None    ,						snake_case__		:					List[Any]=None )		->	Union[str, Any]:


          '''simple docstring'''


          if not (path or img):
                 raise ValueError("Input either path or tensor" )
          if img is not None:
                 raise NotImplementedError
          snake_case       :   Optional[Any]							=      preprocess(Image.open(snake_case__ )    ,						target_image_size=2_56 ).to(self.device )
          snake_case       :   Any							=      preprocess_vqgan(snake_case__ )
          snake_case				,					*snake_case       :   str							=      self.vqgan.encode(snake_case__ )
          return z



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str]    ,						snake_case__		:					Tuple )		->	Optional[Any]:


          '''simple docstring'''


          snake_case       :   Dict							=      self.latent.detach().requires_grad_()
          snake_case       :   Optional[int]							=      base_latent + transform_vector
          if self.quantize:
                 snake_case				,					*snake_case       :   Any							=      self.vqgan.quantize(snake_case__ )
          else:
                 snake_case       :   Union[str, Any]							=      trans_latent
          return self.vqgan.decode(snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict    ,						snake_case__		:					str    ,						snake_case__		:					Optional[int]    ,						snake_case__		:					Optional[int]=None )		->	str:


          '''simple docstring'''


          snake_case       :   Any							=      self.clip_preprocessor(text=snake_case__    ,						images=snake_case__    ,						return_tensors="pt"    ,						padding=snake_case__ )
          snake_case       :   Optional[int]							=      self.clip(**snake_case__ )
          snake_case       :   List[Any]							=      clip_outputs.logits_per_image
          if weights is not None:
                 snake_case       :   Any							=      similarity_logits * weights
          return similarity_logits.sum()



   def 				_SCREAMING_SNAKE_CASE   (self		:					Union[str, Any]    ,						snake_case__		:					Optional[Any]    ,						snake_case__		:					Optional[Any]    ,						snake_case__		:					Dict )		->	Optional[Any]:


          '''simple docstring'''


          snake_case       :   Any							=      self._get_clip_similarity(pos_prompts["prompts"]    ,						snake_case__    ,						weights=(1 / pos_prompts["weights"]) )
          if neg_prompts:
                 snake_case       :   Union[str, Any]							=      self._get_clip_similarity(neg_prompts["prompts"]    ,						snake_case__    ,						weights=neg_prompts["weights"] )
          else:
                 snake_case       :   Union[str, Any]							=      torch.tensor([1]    ,						device=self.device )
          snake_case       :   List[Any]							=      -torch.log(snake_case__ ) + torch.log(snake_case__ )
          return loss



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any]    ,						snake_case__		:					Union[str, Any]    ,						snake_case__		:					str    ,						snake_case__		:					Optional[Any] )		->	str:


          '''simple docstring'''


          snake_case       :   Union[str, Any]							=      torch.randn_like(self.latent    ,						requires_grad=snake_case__    ,						device=self.device )
          snake_case       :   Optional[int]							=      torch.optim.Adam([vector]    ,						lr=self.lr )

          for i in range(self.iterations ):
                 optim.zero_grad()
                 snake_case       :   Dict							=      self._add_vector(snake_case__ )
                 snake_case       :   Union[str, Any]							=      loop_post_process(snake_case__ )
                 snake_case       :   List[str]							=      self._get_CLIP_loss(snake_case__    ,						snake_case__    ,						snake_case__ )
                 print("CLIP loss"    ,						snake_case__ )
                 if self.log:
                        wandb.log({"CLIP Loss": clip_loss} )
                 clip_loss.backward(retain_graph=snake_case__ )
                 optim.step()
                 if self.return_val == "image":
                        yield custom_to_pil(transformed_img[0] )
                 else:
                        yield vector



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int]    ,						snake_case__		:					str    ,						snake_case__		:					Union[str, Any]    ,						snake_case__		:					Optional[int] )		->	List[Any]:


          '''simple docstring'''


          wandb.init(reinit=snake_case__    ,						project="face-editor" )
          wandb.config.update({"Positive Prompts": positive_prompts} )
          wandb.config.update({"Negative Prompts": negative_prompts} )
          wandb.config.update({"lr": self.lr, "iterations": self.iterations} )
          if image_path:
                 snake_case       :   Optional[Any]							=      Image.open(snake_case__ )
                 snake_case       :   Dict							=      image.resize((2_56, 2_56) )
                 wandb.log("Original Image"    ,						wandb.Image(snake_case__ ) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict    ,						snake_case__		:					Union[str, Any] )		->	Optional[int]:


          '''simple docstring'''


          if not prompts:
                 return []
          snake_case       :   Tuple							=      []
          snake_case       :   List[str]							=      []
          if isinstance(snake_case__    ,						snake_case__ ):
                 snake_case       :   Union[str, Any]							=      [prompt.strip() for prompt in prompts.split("|" )]
          for prompt in prompts:
                 if isinstance(snake_case__    ,						(tuple, list) ):
                        snake_case       :   Tuple							=      prompt[0]
                        snake_case       :   Optional[int]							=      float(prompt[1] )
                 elif ":" in prompt:
                        snake_case				,					snake_case       :   Optional[int]							=      prompt.split(":" )
                        snake_case       :   List[str]							=      float(snake_case__ )
                 else:
                        snake_case       :   Optional[Any]							=      prompt
                        snake_case       :   Tuple							=      1.0
                 processed_prompts.append(snake_case__ )
                 weights.append(snake_case__ )
          return {
              "prompts": processed_prompts,
              "weights": torch.tensor(snake_case__    ,						device=self.device ),
          }



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict    ,						snake_case__		:					Dict    ,						snake_case__		:					Union[str, Any]=None    ,						snake_case__		:					str=None    ,						snake_case__		:					Union[str, Any]=True    ,						snake_case__		:					Any=False    ,						snake_case__		:					List[Any]=True    ,						snake_case__		:					List[Any]=True    ,						snake_case__		:					Dict=None    ,						)		->	Any:


          '''simple docstring'''


          if image_path:
                 snake_case       :   List[Any]							=      self._get_latent(snake_case__ )
          else:
                 snake_case       :   Optional[int]							=      torch.randn(self.latent_dim    ,						device=self.device )
          if self.log:
                 self._init_logging(snake_case__    ,						snake_case__    ,						snake_case__ )

          assert pos_prompts, "You must provide at least one positive prompt."
          snake_case       :   Optional[Any]							=      self.process_prompts(snake_case__ )
          snake_case       :   List[Any]							=      self.process_prompts(snake_case__ )
          if save_final and save_path is None:
                 snake_case       :   Tuple							=      os.path.join("./outputs/"    ,						"_".join(pos_prompts["prompts"] ) )
          if not os.path.exists(snake_case__ ):
                 os.makedirs(snake_case__ )
          else:
                 snake_case       :   int							=      save_path + "_" + get_timestamp()
                 os.makedirs(snake_case__ )
          snake_case       :   Tuple							=      save_path

          snake_case       :   str							=      self.vqgan.decode(self.latent )[0]
          if show_intermediate:
                 print("Original Image" )
                 show_pil(custom_to_pil(snake_case__ ) )

          snake_case       :   List[str]							=      loop_post_process(snake_case__ )
          for iter, transformed_img in enumerate(self._optimize_CLIP(snake_case__    ,						snake_case__    ,						snake_case__ ) ):
                 if show_intermediate:
                        show_pil(snake_case__ )
                 if save_intermediate:
                        transformed_img.save(os.path.join(self.save_path    ,						f"""iter_{iter:03d}.png""" ) )
                 if self.log:
                        wandb.log({"Image": wandb.Image(snake_case__ )} )
          if show_final:
                 show_pil(snake_case__ )
          if save_final:
                 transformed_img.save(os.path.join(self.save_path    ,						f"""iter_{iter:03d}_final.png""" ) )







from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxCrossAttnUpBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
    FlaxUpBlockaD,
)






@flax.struct.dataclass
class   UpperCAmelCase		(						A_ ):
   A__					:		jnp.ndarray






@flax_register_to_config
class   UpperCAmelCase		(						nn.Module       ,A_       ,A_ ):
   A__					:		int						     =     32
   A__					:		int						     =     4
   A__					:		int						     =     4
   A__					:		Tuple[str]						     =     (
       "CrossAttnDownBlock2D",
       "CrossAttnDownBlock2D",
       "CrossAttnDownBlock2D",
       "DownBlock2D",
   )
   A__					:		Tuple[str]						     =     ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")
   A__					:		Union[bool, Tuple[bool]]						     =     False
   A__					:		Tuple[int]						     =     (3_20, 6_40, 12_80, 12_80)
   A__					:		int						     =     2
   A__					:		Union[int, Tuple[int]]						     =     8
   A__					:		Optional[Union[int, Tuple[int]]]						     =     None
   A__					:		int						     =     12_80
   A__					:		float						     =     0.0
   A__					:		bool						     =     False
   A__					:		jnp.dtype						     =     jnp.floataa
   A__					:		bool						     =     True
   A__					:		int						     =     0
   A__					:		bool						     =     False



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int]    ,						snake_case__		:					jax.random.KeyArray )		->	FrozenDict:


          '''simple docstring'''


          snake_case       :   Dict							=      (1, self.in_channels, self.sample_size, self.sample_size)
          snake_case       :   Any							=      jnp.zeros(snake_case__    ,						dtype=jnp.floataa )
          snake_case       :   List[str]							=      jnp.ones((1,)    ,						dtype=jnp.intaa )
          snake_case       :   str							=      jnp.zeros((1, 1, self.cross_attention_dim)    ,						dtype=jnp.floataa )

          snake_case				,					snake_case       :   Optional[int]							=      jax.random.split(snake_case__ )
          snake_case       :   Union[str, Any]							=      {"params": params_rng, "dropout": dropout_rng}

          return self.init(snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__ )["params"]



   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	Tuple:


          '''simple docstring'''


          snake_case       :   str							=      self.block_out_channels
          snake_case       :   Optional[Any]							=      block_out_channels[0] * 4

          if self.num_attention_heads is not None:
                 raise ValueError(
                     "At the moment it is not possible to define the number of attention heads via `num_attention_heads` because of a naming issue as described in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131. Passing `num_attention_heads` will only be supported in diffusers v0.19." )

          # If `num_attention_heads` is not defined (which is the case for most models)
          # it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
          # The reason for this behavior is to correct for incorrectly named variables that were introduced
          # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
          # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
          # which is why we correct for the naming here.
          snake_case       :   Tuple							=      self.num_attention_heads or self.attention_head_dim

          # input
          snake_case       :   Tuple							=      nn.Conv(
              block_out_channels[0]    ,						kernel_size=(3, 3)    ,						strides=(1, 1)    ,						padding=((1, 1), (1, 1))    ,						dtype=self.dtype    ,						)

          # time
          snake_case       :   Union[str, Any]							=      FlaxTimesteps(
              block_out_channels[0]    ,						flip_sin_to_cos=self.flip_sin_to_cos    ,						freq_shift=self.config.freq_shift )
          snake_case       :   Dict							=      FlaxTimestepEmbedding(snake_case__    ,						dtype=self.dtype )

          snake_case       :   List[str]							=      self.only_cross_attention
          if isinstance(snake_case__    ,						snake_case__ ):
                 snake_case       :   List[Any]							=      (only_cross_attention,) * len(self.down_block_types )

          if isinstance(snake_case__    ,						snake_case__ ):
                 snake_case       :   List[Any]							=      (num_attention_heads,) * len(self.down_block_types )

          # down
          snake_case       :   List[Any]							=      []
          snake_case       :   Optional[int]							=      block_out_channels[0]
          for i, down_block_type in enumerate(self.down_block_types ):
                 snake_case       :   List[Any]							=      output_channel
                 snake_case       :   Dict							=      block_out_channels[i]
                 snake_case       :   Optional[Any]							=      i == len(snake_case__ ) - 1

                 if down_block_type == "CrossAttnDownBlock2D":
                        snake_case       :   List[Any]							=      FlaxCrossAttnDownBlockaD(
                            in_channels=snake_case__    ,						out_channels=snake_case__    ,						dropout=self.dropout    ,						num_layers=self.layers_per_block    ,						num_attention_heads=num_attention_heads[i]    ,						add_downsample=not is_final_block    ,						use_linear_projection=self.use_linear_projection    ,						only_cross_attention=only_cross_attention[i]    ,						use_memory_efficient_attention=self.use_memory_efficient_attention    ,						dtype=self.dtype    ,						)
                 else:
                        snake_case       :   Union[str, Any]							=      FlaxDownBlockaD(
                            in_channels=snake_case__    ,						out_channels=snake_case__    ,						dropout=self.dropout    ,						num_layers=self.layers_per_block    ,						add_downsample=not is_final_block    ,						dtype=self.dtype    ,						)

                 down_blocks.append(snake_case__ )
          snake_case       :   Dict							=      down_blocks

          # mid
          snake_case       :   Optional[int]							=      FlaxUNetMidBlockaDCrossAttn(
              in_channels=block_out_channels[-1]    ,						dropout=self.dropout    ,						num_attention_heads=num_attention_heads[-1]    ,						use_linear_projection=self.use_linear_projection    ,						use_memory_efficient_attention=self.use_memory_efficient_attention    ,						dtype=self.dtype    ,						)

          # up
          snake_case       :   Optional[Any]							=      []
          snake_case       :   Optional[int]							=      list(reversed(snake_case__ ) )
          snake_case       :   Dict							=      list(reversed(snake_case__ ) )
          snake_case       :   Tuple							=      list(reversed(snake_case__ ) )
          snake_case       :   Optional[Any]							=      reversed_block_out_channels[0]
          for i, up_block_type in enumerate(self.up_block_types ):
                 snake_case       :   Optional[int]							=      output_channel
                 snake_case       :   List[Any]							=      reversed_block_out_channels[i]
                 snake_case       :   Union[str, Any]							=      reversed_block_out_channels[min(i + 1    ,						len(snake_case__ ) - 1 )]

                 snake_case       :   int							=      i == len(snake_case__ ) - 1

                 if up_block_type == "CrossAttnUpBlock2D":
                        snake_case       :   Any							=      FlaxCrossAttnUpBlockaD(
                            in_channels=snake_case__    ,						out_channels=snake_case__    ,						prev_output_channel=snake_case__    ,						num_layers=self.layers_per_block + 1    ,						num_attention_heads=reversed_num_attention_heads[i]    ,						add_upsample=not is_final_block    ,						dropout=self.dropout    ,						use_linear_projection=self.use_linear_projection    ,						only_cross_attention=only_cross_attention[i]    ,						use_memory_efficient_attention=self.use_memory_efficient_attention    ,						dtype=self.dtype    ,						)
                 else:
                        snake_case       :   Optional[int]							=      FlaxUpBlockaD(
                            in_channels=snake_case__    ,						out_channels=snake_case__    ,						prev_output_channel=snake_case__    ,						num_layers=self.layers_per_block + 1    ,						add_upsample=not is_final_block    ,						dropout=self.dropout    ,						dtype=self.dtype    ,						)

                 up_blocks.append(snake_case__ )
                 snake_case       :   Optional[int]							=      output_channel
          snake_case       :   Tuple							=      up_blocks

          # out
          snake_case       :   Optional[int]							=      nn.GroupNorm(num_groups=32    ,						epsilon=1e-5 )
          snake_case       :   List[str]							=      nn.Conv(
              self.out_channels    ,						kernel_size=(3, 3)    ,						strides=(1, 1)    ,						padding=((1, 1), (1, 1))    ,						dtype=self.dtype    ,						)



   def __call__(self		:					Dict    ,						snake_case__		:					Dict    ,						snake_case__		:					Dict    ,						snake_case__		:					Optional[int]    ,						snake_case__		:					Tuple=None    ,						snake_case__		:					Union[str, Any]=None    ,						snake_case__		:					bool = True    ,						snake_case__		:					bool = False    ,						)		->	Union[FlaxUNetaDConditionOutput, Tuple]:


          '''simple docstring'''


          if not isinstance(snake_case__    ,						jnp.ndarray ):
                 snake_case       :   List[Any]							=      jnp.array([timesteps]    ,						dtype=jnp.intaa )
          elif isinstance(snake_case__    ,						jnp.ndarray ) and len(timesteps.shape ) == 0:
                 snake_case       :   Any							=      timesteps.astype(dtype=jnp.floataa )
                 snake_case       :   int							=      jnp.expand_dims(snake_case__    ,						0 )

          snake_case       :   str							=      self.time_proj(snake_case__ )
          snake_case       :   str							=      self.time_embedding(snake_case__ )

          # 2. pre-process
          snake_case       :   int							=      jnp.transpose(snake_case__    ,						(0, 2, 3, 1) )
          snake_case       :   List[Any]							=      self.conv_in(snake_case__ )

          # 3. down
          snake_case       :   Optional[int]							=      (sample,)
          for down_block in self.down_blocks:
                 if isinstance(snake_case__    ,						snake_case__ ):
                        snake_case				,					snake_case       :   List[Any]							=      down_block(snake_case__    ,						snake_case__    ,						snake_case__    ,						deterministic=not train )
                 else:
                        snake_case				,					snake_case       :   str							=      down_block(snake_case__    ,						snake_case__    ,						deterministic=not train )
                 down_block_res_samples += res_samples

          if down_block_additional_residuals is not None:
                 snake_case       :   Tuple							=      ()

                 for down_block_res_sample, down_block_additional_residual in zip(
                     snake_case__    ,						snake_case__ ):
                        down_block_res_sample += down_block_additional_residual
                        new_down_block_res_samples += (down_block_res_sample,)

                 snake_case       :   Optional[int]							=      new_down_block_res_samples

          # 4. mid
          snake_case       :   Optional[int]							=      self.mid_block(snake_case__    ,						snake_case__    ,						snake_case__    ,						deterministic=not train )

          if mid_block_additional_residual is not None:
                 sample += mid_block_additional_residual

          # 5. up
          for up_block in self.up_blocks:
                 snake_case       :   int							=      down_block_res_samples[-(self.layers_per_block + 1) :]
                 snake_case       :   Optional[Any]							=      down_block_res_samples[: -(self.layers_per_block + 1)]
                 if isinstance(snake_case__    ,						snake_case__ ):
                        snake_case       :   Optional[Any]							=      up_block(
                            snake_case__    ,						temb=snake_case__    ,						encoder_hidden_states=snake_case__    ,						res_hidden_states_tuple=snake_case__    ,						deterministic=not train    ,						)
                 else:
                        snake_case       :   Dict							=      up_block(snake_case__    ,						temb=snake_case__    ,						res_hidden_states_tuple=snake_case__    ,						deterministic=not train )

        # 6. post-process
          snake_case       :   List[str]							=      self.conv_norm_out(snake_case__ )
          snake_case       :   Any							=      nn.silu(snake_case__ )
          snake_case       :   Optional[int]							=      self.conv_out(snake_case__ )
          snake_case       :   Union[str, Any]							=      jnp.transpose(snake_case__    ,						(0, 3, 1, 2) )

          if not return_dict:
                 return (sample,)

          return FlaxUNetaDConditionOutput(sample=snake_case__ )





