code: def __init__(
      self,
      sample_size=None,
      in_channels=3,
      out_channels=3,
      center_input_sample=False,
      time_embedding_type="positional",
      freq_shift=0,
      flip_sin_to_cos=True,
      down_block_types=(
          "DownBlock2D",
          "AttnDownBlock2D",
          "AttnDownBlock2D",
          "AttnDownBlock2D",
      ),
      up_block_types=(
          "AttnUpBlock2D",
          "AttnUpBlock2D",
          "AttnUpBlock2D",
          "UpBlock2D",
      ),
      block_out_channels=(224, 448, 672, 896),
      layers_per_block=2,
      mid_block_scale_factor=1,
      downsample_padding=1,
      act_fn="silu",
      attention_head_dim=8,
      norm_num_groups=32,
      norm_eps=1e-5,
  ):
      super().__init__()
  
      self.sample_size = sample_size
      time_embed_dim = block_out_channels[0] * 4
  
      # input
      self.conv_in = nn.Conv2D(
          in_channels,
          block_out_channels[0],
          kernel_size=3,
          padding=(1, 1),
      )
  
      # time
      if time_embedding_type == "fourier":
          self.time_proj = GaussianFourierProjection(
              embedding_size=block_out_channels[0], scale=16
          )
          timestep_input_dim = 2 * block_out_channels[0]
      elif time_embedding_type == "positional":
          self.time_proj = Timesteps(
              block_out_channels[0], flip_sin_to_cos, freq_shift
          )
          timestep_input_dim = block_out_channels[0]
  
      self.time_embedding = TimestepEmbedding(
          timestep_input_dim, time_embed_dim
      )
  
      self.down_blocks = nn.LayerList([])
      self.mid_block = None
      self.up_blocks = nn.LayerList([])
  
      # down
      output_channel = block_out_channels[0]
      for i, down_block_type in enumerate(down_block_types):
          input_channel = output_channel
          output_channel = block_out_channels[i]
          is_final_block = i == len(block_out_channels) - 1
  
          down_block = get_down_block(
              down_block_type,
              num_layers=layers_per_block,
              in_channels=input_channel,
              out_channels=output_channel,
              temb_channels=time_embed_dim,
              add_downsample=not is_final_block,
              resnet_eps=norm_eps,
              resnet_act_fn=act_fn,
              attn_num_head_channels=attention_head_dim,
              downsample_padding=downsample_padding,
          )
          self.down_blocks.append(down_block)
  
      # mid
      self.mid_block = UNetMidBlock2D(
          in_channels=block_out_channels[-1],
          temb_channels=time_embed_dim,
          resnet_eps=norm_eps,
          resnet_act_fn=act_fn,
          output_scale_factor=mid_block_scale_factor,
          resnet_time_scale_shift="default",
          attn_num_head_channels=attention_head_dim,
          resnet_groups=norm_num_groups,
      )
  
      # up
      reversed_block_out_channels = list(reversed(block_out_channels))
      output_channel = reversed_block_out_channels[0]
      for i, up_block_type in enumerate(up_block_types):
          prev_output_channel = output_channel
          output_channel = reversed_block_out_channels[i]
          input_channel = reversed_block_out_channels[
              min(i + 1, len(block_out_channels) - 1)
          ]
  
          is_final_block = i == len(block_out_channels) - 1
  
          up_block = get_up_block(
              up_block_type,
              num_layers=layers_per_block + 1,
              in_channels=input_channel,
              out_channels=output_channel,
              prev_output_channel=prev_output_channel,
              temb_channels=time_embed_dim,
              add_upsample=not is_final_block,
              resnet_eps=norm_eps,
              resnet_act_fn=act_fn,
              attn_num_head_channels=attention_head_dim,
          )
          self.up_blocks.append(up_block)
          prev_output_channel = output_channel
  
      # out
      num_groups_out = (
          norm_num_groups
          if norm_num_groups is not None
          else min(block_out_channels[0] // 4, 32)
      )
      self.conv_norm_out = nn.GroupNorm(
          num_channels=block_out_channels[0],
          num_groups=num_groups_out,
          epsilon=norm_eps,
      )
      self.conv_act = nn.Silu()
      self.conv_out = nn.Conv2D(
          block_out_channels[0], out_channels, 3, padding=1
      )
  
file_path: PaddleHub/modules/image/text_to_image/stable_diffusion/diffusers/models/unet_2d.py
imports: from typing import Dict
  from typing import Union
  import paddle
  import paddle.nn
  from ..configuration_utils import ConfigMixin
  from ..configuration_utils import register_to_config
  from .embeddings import GaussianFourierProjection
  from .embeddings import TimestepEmbedding
  from .embeddings import Timesteps
  from .unet_blocks import get_down_block
  from .unet_blocks import get_up_block
  from .unet_blocks import UNetMidBlock2D
label_desc: Use image node_id 1 to create a new UNet2DModel object from inherited base classes: nn, ConfigMixin with example: obj = UNet2DModel(sample_size, in_channels, out_channels, center_input_sample, time_embedding_type, freq_shift, flip_sin_to_cos, down_block_types, up_block_types, block_out_channels, layers_per_block, mid_block_scale_factor, downsample_padding, act_fn, attention_head_dim, norm_num_groups, norm_eps)