



'''simple docstring'''






import io
import os
import unicodedata
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


lowerCAmelCase: Union[str, Any]							=						logging.get_logger(__name__)

lowerCAmelCase: Dict							=						'▁'

lowerCAmelCase: Optional[int]							=						{'vocab_file': 'vocab.txt', 'sentencepiece_model_ckpt': 'sentencepiece.bpe.model'}

lowerCAmelCase: List[str]							=						{
    'sentencepiece_model_file': 'sentencepiece.bpe.model',
    'vocab_file': 'vocab.txt',
}

lowerCAmelCase: Union[str, Any]							=						{
    'vocab_file': {
        'ernie-m-base': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt',
        'ernie-m-large': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt',
    },
    'sentencepiece_model_file': {
        'ernie-m-base': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model',
        'ernie-m-large': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model',
    },
}

lowerCAmelCase: str							=						{
    'ernie-m-base': 5_1_4,
    'ernie-m-large': 5_1_4,
}

lowerCAmelCase: List[Any]							=						{
    'ernie-m-base': {'do_lower_case': False},
    'ernie-m-large': {'do_lower_case': False},
}

class 							a__( __UpperCamelCase     ):
    lowercase__			=   ["input_ids"]

    lowercase__			=   VOCAB_FILES_NAMES
    lowercase__			=   PRETRAINED_INIT_CONFIGURATION
    lowercase__			=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    lowercase__			=   PRETRAINED_VOCAB_FILES_MAP
    lowercase__			=   RESOURCE_FILES_NAMES







    def __init__(				self			:  List[Any]						,      __snake_case			:  Union[str, Any]						,      __snake_case			:  Optional[int]=None						,      __snake_case			:  List[str]=False						,      __snake_case			:  str="utf8"						,      __snake_case			:  str="[UNK]"						,      __snake_case			:  str="[SEP]"						,      __snake_case			:  int="[PAD]"						,      __snake_case			:  Optional[Any]="[CLS]"						,      __snake_case			:  Optional[Any]="[MASK]"						,      __snake_case			:  Optional[Dict[str, Any]] = None						,      **__snake_case			:  str						,      ):
      # Mask token behave like a normal word, i.e. include the space before it and
      # is included in the raw text, there should be a match in a non-normalized sentence.

      a						: Any					       =					{} if sp_model_kwargs is None else sp_model_kwargs
      super().__init__(
          do_lower_case=__snake_case						,      unk_token=__snake_case						,      sep_token=__snake_case						,      pad_token=__snake_case						,      cls_token=__snake_case						,      mask_token=__snake_case						,      vocab_file=__snake_case						,      encoding=__snake_case						,      sp_model_kwargs=self.sp_model_kwargs						,      **__snake_case						,      )
      a						: List[Any]					       =					do_lower_case
      a						: Union[str, Any]					       =					sentencepiece_model_ckpt
      a						: Union[str, Any]					       =					spm.SentencePieceProcessor(**self.sp_model_kwargs     )
      self.sp_model.Load(__snake_case     )

      # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning
      if vocab_file is not None:
        a						: Tuple					       =					self.load_vocab(filepath=__snake_case     )
      else:
        a						: int					       =					{self.sp_model.id_to_piece(__snake_case     ): id for id in range(self.sp_model.get_piece_size()     )}
      a						: Dict					       =					{v: k for k, v in self.vocab.items()}







    def       lowercase_	(				self			:  Dict						,      __snake_case			:  Optional[int]     ):
      if text is None:
        return None

      a						: List[str]					       =					self.tokenize(__snake_case     )
      a						: List[Any]					       =					"""""", []

      for i, ch in enumerate(__snake_case     ):
        if ch in self.SP_CHAR_MAPPING:
          a						: Union[str, Any]					       =					self.SP_CHAR_MAPPING.get(__snake_case     )
        else:
          a						: Optional[int]					       =					unicodedata.normalize('NFKC'						,      __snake_case     )
        if self.is_whitespace(__snake_case     ):
          continue
        normalized_text += ch
        char_mapping.extend([i] * len(__snake_case     )     )

      a						: str					       =					normalized_text, [], 0

      if self.do_lower_case:
        a						: str					       =					text.lower()

      for token in split_tokens:
        if token[:1] == "▁":
          a						: str					       =					token[1:]
        a						: Dict					       =					text[offset:].index(__snake_case     ) + offset
        a						: List[str]					       =					start + len(__snake_case     )

        token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1)     )
        a						: Optional[Any]					       =					end
      return token_mapping







    @property
    def       lowercase_	(				self			:  Union[str, Any]     ):
      return len(self.vocab     )







    def       lowercase_	(				self			:  Dict     ):
      return dict(self.vocab						,      **self.added_tokens_encoder     )







    def __getstate__(				self			:  List[str]     ):
      a						: Tuple					       =					self.__dict__.copy()
      a						: Optional[int]					       =					None
      return state







    def __setstate__(				self			:  Optional[Any]						,      __snake_case			:  int     ):
      a						: Tuple					       =					d

      # for backward compatibility
      if not hasattr(self						,      'sp_model_kwargs'     ):
        a						: int					       =					{}

      a						: Union[str, Any]					       =					spm.SentencePieceProcessor(**self.sp_model_kwargs     )
      self.sp_model.Load(self.sentencepiece_model_ckpt     )







    def       lowercase_	(				self			:  Tuple						,      __snake_case			:  str     ):
      return "".join((self.SP_CHAR_MAPPING.get(__snake_case						,      __snake_case     ) for c in text)     )







    def       lowercase_	(				self			:  Optional[Any]						,      __snake_case			:  Tuple						,      __snake_case			:  int=False						,      __snake_case			:  Union[str, Any]=64						,      __snake_case			:  Dict=0.1     ):

      if self.sp_model_kwargs.get('enable_sampling'     ) is True:
        a						: Optional[Any]					       =					True
      if self.sp_model_kwargs.get('alpha'     ) is not None:
        a						: Dict					       =					self.sp_model_kwargs.get('alpha'     )
      if self.sp_model_kwargs.get('nbest_size'     ) is not None:
        a						: int					       =					self.sp_model_kwargs.get('nbest_size'     )

      if not enable_sampling:
        a						: Optional[int]					       =					self.sp_model.EncodeAsPieces(__snake_case     )
      else:
        a						: List[Any]					       =					self.sp_model.SampleEncodeAsPieces(__snake_case						,      __snake_case						,      __snake_case     )
      a						: Optional[int]					       =					[]
      for pi, piece in enumerate(__snake_case     ):
        if piece == SPIECE_UNDERLINE:
          if not pieces[pi + 1].startswith(__snake_case     ) and pi != 0:
            new_pieces.append(__snake_case     )
            continue
          else:
            continue
        a						: str					       =					0
        for i, chunk in enumerate(__snake_case     ):
          if chunk == SPIECE_UNDERLINE:
            continue
          if self.is_ch_char(__snake_case     ) or self.is_punct(__snake_case     ):
            if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
              new_pieces.append(piece[lst_i:i]     )
            new_pieces.append(__snake_case     )
            a						: List[str]					       =					i + 1
          elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit():
            if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
              new_pieces.append(piece[lst_i:i]     )
            a						: List[str]					       =					i
          elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit():
            if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
              new_pieces.append(piece[lst_i:i]     )
            a						: Union[str, Any]					       =					i
        if len(__snake_case     ) > lst_i:
          new_pieces.append(piece[lst_i:]     )
      return new_pieces







    def       lowercase_	(				self			:  str						,      __snake_case			:  Union[str, Any]     ):
      a						: Any					       =					"""""".join(__snake_case     ).replace(__snake_case						,      ' '     ).strip()
      return out_string







    def       lowercase_	(				self			:  Any						,      __snake_case			:  int     ):
      a						: str					       =					self.convert_ids_to_tokens(__snake_case     )
      a						: Any					       =					"""""".join(__snake_case     ).replace(__snake_case						,      ' '     ).strip()
      return out_string







    def       lowercase_	(				self			:  List[str]						,      __snake_case			:  int     ):
      return self.vocab.get(__snake_case						,      self.vocab.get(self.unk_token     )     )







    def       lowercase_	(				self			:  List[Any]						,      __snake_case			:  Tuple     ):
      return self.reverse_vocab.get(__snake_case						,      self.unk_token     )







    def       lowercase_	(				self			:  str						,      __snake_case			:  Tuple						,      __snake_case			:  Union[str, Any]=None     ):
      if token_ids_a is None:
        return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
      a						: Optional[int]					       =					[self.cls_token_id]
      a						: Tuple					       =					[self.sep_token_id]
      return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep







    def       lowercase_	(				self			:  Any						,      __snake_case			:  Optional[Any]						,      __snake_case			:  Any=None     ):
      if offset_mapping_a is None:
        return [(0, 0)] + offset_mapping_a + [(0, 0)]

      return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)]







    def       lowercase_	(				self			:  Optional[Any]						,      __snake_case			:  Any						,      __snake_case			:  Dict=None						,      __snake_case			:  Optional[int]=False     ):

      if already_has_special_tokens:
        if token_ids_a is not None:
          raise ValueError(
              'You should not supply a second sequence if the provided sequence of '
              'ids is already formatted with special tokens for the model.'     )
        return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

      if token_ids_a is not None:
        return [1] + ([0] * len(__snake_case     )) + [1, 1] + ([0] * len(__snake_case     )) + [1]
      return [1] + ([0] * len(__snake_case     )) + [1]







    def       lowercase_	(				self			:  List[Any]						,      __snake_case			:  List[int]						,      __snake_case			:  Optional[List[int]] = None     ):
      # called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method
      if token_ids_a is None:
        # [CLS] X [SEP]
        return (len(__snake_case     ) + 2) * [0]

      # [CLS] A [SEP] [SEP] B [SEP]
      return [0] * (len(__snake_case     ) + 1) + [1] * (len(__snake_case     ) + 3)







    def       lowercase_	(				self			:  Union[str, Any]						,      __snake_case			:  str     ):
      if "\u4e00" <= char <= "\u9fff":
        return True
      return False







    def       lowercase_	(				self			:  Union[str, Any]						,      __snake_case			:  Any     ):
      if ("a" <= char <= "z") or ("A" <= char <= "Z"):
        return True
      return False







    def       lowercase_	(				self			:  Any						,      __snake_case			:  List[str]     ):
      if char in ",;:.?!~，；：。？！《》【】":
        return True
      return False







    def       lowercase_	(				self			:  str						,      __snake_case			:  List[str]     ):
      if char == " " or char == "\t" or char == "\n" or char == "\r":
        return True
      if len(__snake_case     ) == 1:
        a						: Union[str, Any]					       =					unicodedata.category(__snake_case     )
        if cat == "Zs":
          return True
      return False







    def       lowercase_	(				self			:  Dict						,      __snake_case			:  Dict     ):
      a						: List[Any]					       =					{}
      with io.open(__snake_case						,      'r'						,      encoding='utf-8'     ) as f:
        for index, line in enumerate(__snake_case     ):
          a						: Union[str, Any]					       =					line.rstrip('\n'     )
          a						: str					       =					int(__snake_case     )

      return token_to_idx







    def       lowercase_	(				self			:  Any						,      __snake_case			:  str						,      __snake_case			:  Optional[str] = None     ):
      a						: Dict					       =					0
      if os.path.isdir(__snake_case     ):
        a						: List[Any]					       =					os.path.join(
            __snake_case						,      (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']     )
      else:
        a						: List[str]					       =					(filename_prefix + """-""" if filename_prefix else """""") + save_directory
      with open(__snake_case						,      'w'						,      encoding='utf-8'     ) as writer:
        for token, token_index in sorted(self.vocab.items()						,      key=lambda __snake_case     : kv[1]     ):
          if index != token_index:
            logger.warning(
                F"""Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive."""
                ' Please check that the vocabulary is not corrupted!'     )
            a						: List[str]					       =					token_index
          writer.write(token + '\n'     )
          index += 1

      a						: Optional[Any]					       =					os.path.join(__snake_case						,      'sentencepiece.bpe.model'     )
      with open(__snake_case						,      'wb'     ) as fi:
        a						: int					       =					self.sp_model.serialized_model_proto()
        fi.write(__snake_case     )

      return (vocab_file,)




'''simple docstring'''






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 							a__( lowerCamelCase__     ):
    lowercase__			=   42

@flax_register_to_config
class 							a__( nn.Module		,			lowerCamelCase__		,			lowerCamelCase__     ):
    lowercase__			=   32
    lowercase__			=   4
    lowercase__			=   4
    lowercase__			=   (
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "DownBlock2D",
    )
    lowercase__			=   ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")
    lowercase__			=   False
    lowercase__			=   (3_20, 6_40, 12_80, 12_80)
    lowercase__			=   2
    lowercase__			=   8
    lowercase__			=   None
    lowercase__			=   12_80
    lowercase__			=   0.0
    lowercase__			=   False
    lowercase__			=   jnp.floataa
    lowercase__			=   True
    lowercase__			=   0
    lowercase__			=   False







    def       lowercase_	(				self			:  List[Any]						,      __snake_case			:  jax.random.KeyArray     ):
      # init input tensors
      a						: Dict					       =					(1, self.in_channels, self.sample_size, self.sample_size)
      a						: str					       =					jnp.zeros(__snake_case						,      dtype=jnp.floataa     )
      a						: Union[str, Any]					       =					jnp.ones((1,)						,      dtype=jnp.intaa     )
      a						: List[Any]					       =					jnp.zeros((1, 1, self.cross_attention_dim)						,      dtype=jnp.floataa     )

      a       ,     a						: Optional[int]					       =					jax.random.split(__snake_case     )
      a						: Any					       =					{'params': params_rng, 'dropout': dropout_rng}

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







    def       lowercase_	(				self			:  Union[str, Any]     ):
      a						: int					       =					self.block_out_channels
      a						: Tuple					       =					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.
      a						: str					       =					self.num_attention_heads or self.attention_head_dim

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

      # time
      a						: List[str]					       =					FlaxTimesteps(
          block_out_channels[0]						,      flip_sin_to_cos=self.flip_sin_to_cos						,      freq_shift=self.config.freq_shift     )
      a						: Optional[int]					       =					FlaxTimestepEmbedding(__snake_case						,      dtype=self.dtype     )

      a						: Optional[Any]					       =					self.only_cross_attention
      if isinstance(__snake_case						,      __snake_case     ):
        a						: int					       =					(only_cross_attention,) * len(self.down_block_types     )

      if isinstance(__snake_case						,      __snake_case     ):
        a						: str					       =					(num_attention_heads,) * len(self.down_block_types     )

      # down
      a						: int					       =					[]
      a						: Dict					       =					block_out_channels[0]
      for i, down_block_type in enumerate(self.down_block_types     ):
        a						: List[Any]					       =					output_channel
        a						: Dict					       =					block_out_channels[i]
        a						: Union[str, Any]					       =					i == len(__snake_case     ) - 1

        if down_block_type == "CrossAttnDownBlock2D":
          a						: Dict					       =					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:
          a						: List[str]					       =					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     )
      a						: Dict					       =					down_blocks

      # mid
      a						: Union[str, Any]					       =					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
      a						: List[Any]					       =					[]
      a						: Dict					       =					list(reversed(__snake_case     )     )
      a						: List[str]					       =					list(reversed(__snake_case     )     )
      a						: List[str]					       =					list(reversed(__snake_case     )     )
      a						: Optional[int]					       =					reversed_block_out_channels[0]
      for i, up_block_type in enumerate(self.up_block_types     ):
        a						: Dict					       =					output_channel
        a						: Dict					       =					reversed_block_out_channels[i]
        a						: Dict					       =					reversed_block_out_channels[min(i + 1						,      len(__snake_case     ) - 1     )]

        a						: List[Any]					       =					i == len(__snake_case     ) - 1

        if up_block_type == "CrossAttnUpBlock2D":
          a						: List[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:
          a						: Dict					       =					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     )
        a						: Dict					       =					output_channel
      a						: int					       =					up_blocks

      # out
      a						: int					       =					nn.GroupNorm(num_groups=32						,      epsilon=1e-5     )
      a						: Any					       =					nn.Conv(
          self.out_channels						,      kernel_size=(3, 3)						,      strides=(1, 1)						,      padding=((1, 1), (1, 1))						,      dtype=self.dtype						,      )







    def __call__(				self			:  Optional[Any]						,      __snake_case			:  Dict						,      __snake_case			:  List[str]						,      __snake_case			:  Tuple						,      __snake_case			:  Dict=None						,      __snake_case			:  Any=None						,      __snake_case			:  bool = True						,      __snake_case			:  bool = False						,      ):
      # 1. time
      if not isinstance(__snake_case						,      jnp.ndarray     ):
        a						: Tuple					       =					jnp.array([timesteps]						,      dtype=jnp.intaa     )
      elif isinstance(__snake_case						,      jnp.ndarray     ) and len(timesteps.shape     ) == 0:
        a						: Tuple					       =					timesteps.astype(dtype=jnp.floataa     )
        a						: Optional[int]					       =					jnp.expand_dims(__snake_case						,      0     )

      a						: Optional[Any]					       =					self.time_proj(__snake_case     )
      a						: Optional[int]					       =					self.time_embedding(__snake_case     )

      # 2. pre-process
      a						: str					       =					jnp.transpose(__snake_case						,      (0, 2, 3, 1)     )
      a						: Optional[int]					       =					self.conv_in(__snake_case     )

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

      if down_block_additional_residuals is not None:
        a						: 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,)

        a						: Tuple					       =					new_down_block_res_samples

      # 4. mid
      a						: 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:
        a						: int					       =					down_block_res_samples[-(self.layers_per_block + 1) :]
        a						: List[Any]					       =					down_block_res_samples[: -(self.layers_per_block + 1)]
        if isinstance(__snake_case						,      __snake_case     ):
          a						: Optional[int]					       =					up_block(
              __snake_case						,      temb=__snake_case						,      encoder_hidden_states=__snake_case						,      res_hidden_states_tuple=__snake_case						,      deterministic=not train						,      )
        else:
          a						: Optional[Any]					       =					up_block(__snake_case						,      temb=__snake_case						,      res_hidden_states_tuple=__snake_case						,      deterministic=not train     )

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

      if not return_dict:
        return (sample,)

      return FlaxUNetaDConditionOutput(sample=__snake_case     )