class_docstr: SwinIR
      A PyTorch impl of : `SwinIR: Image Restoration Using Swin Transformer`, based on Swin Transformer.
  Args:
      img_size (int | tuple(int)): Input image size. Default 64
      patch_size (int | tuple(int)): Patch size. Default: 1
      in_chans (int): Number of input image channels. Default: 3
      embed_dim (int): Patch embedding dimension. Default: 96
      depths (tuple(int)): Depth of each Swin Transformer layer.
      num_heads (tuple(int)): Number of attention heads in different layers.
      window_size (int): Window size. Default: 7
      mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4
      qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
      qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None
      drop_rate (float): Dropout rate. Default: 0
      attn_drop_rate (float): Attention dropout rate. Default: 0
      drop_path_rate (float): Stochastic depth rate. Default: 0.1
      norm_layer (nn.Layer): Normalization layer. Default: nn.LayerNorm.
      ape (bool): If True, add absolute position embedding to the patch embedding. Default: False
      patch_norm (bool): If True, add normalization after patch embedding. Default: True
      use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False
      upscale: Upscale factor. 2/3/4/8 for image SR, 1 for denoising and compress artifact reduction
      img_range: Image range. 1. or 255.
      upsampler: The reconstruction reconstruction module. 'pixelshuffle'/'pixelshuffledirect'/'nearest+conv'/None
      resi_connection: The convolutional block before residual connection. '1conv'/'3conv'
class_docstr_tok: ["SwinIR","A","PyTorch","impl","of",":","`","SwinIR",":","Image","Restoration","Using","Swin","Transformer","`",",","based","on","Swin","Transformer",".","Args",":","img_size","(","int","|","tuple","(","int",")",")",":","Input","image","size",".","Default","64","patch_size","(","int","|","tuple","(","int",")",")",":","Patch","size",".","Default",":","1","in_chans","(","int",")",":","Number","of","input","image","channels",".","Default",":","3","embed_dim","(","int",")",":","Patch","embedding","dimension",".","Default",":","96","depths","(","tuple","(","int",")",")",":","Depth","of","each","Swin","Transformer","layer",".","num_heads","(","tuple","(","int",")",")",":","Number","of","attention","heads","in","different","layers",".","window_size","(","int",")",":","Window","size",".","Default",":","7","mlp_ratio","(","float",")",":","Ratio","of","mlp","hidden","dim","to","embedding","dim",".","Default",":","4","qkv_bias","(","bool",")",":","If","True",",","add","a","learnable","bias","to","query",",","key",",","value",".","Default",":","True","qk_scale","(","float",")",":","Override","default","qk","scale","of","head_dim","*","*","-0.5","if","set",".","Default",":","None","drop_rate","(","float",")",":","Dropout","rate",".","Default",":","0","attn_drop_rate","(","float",")",":","Attention","dropout","rate",".","Default",":","0","drop_path_rate","(","float",")",":","Stochastic","depth","rate",".","Default",":","0.1","norm_layer","(","nn.Layer",")",":","Normalization","layer",".","Default",":","nn.LayerNorm",".","ape","(","bool",")",":","If","True",",","add","absolute","position","embedding","to","the","patch","embedding",".","Default",":","False","patch_norm","(","bool",")",":","If","True",",","add","normalization","after","patch","embedding",".","Default",":","True","use_checkpoint","(","bool",")",":","Whether","to","use","checkpointing","to","save","memory",".","Default",":","False","upscale",":","Upscale","factor",".","2\/3\/4\/8","for","image","SR",",","1","for","denoising","and","compress","artifact","reduction","img_range",":","Image","range",".","1.","or","255.","upsampler",":","The","reconstruction","reconstruction","module",".","'pixelshuffle'\/'pixelshuffledirect'\/'nearest+conv'\/None","resi_connection",":","The","convolutional","block","before","residual","connection",".","'1conv'\/'3conv","'"]
code: def __init__(
      self,
      img_size=64,
      patch_size=1,
      in_chans=3,
      embed_dim=96,
      depths=[6, 6, 6, 6],
      num_heads=[6, 6, 6, 6],
      window_size=7,
      mlp_ratio=4.0,
      qkv_bias=True,
      qk_scale=None,
      drop_rate=0.0,
      attn_drop_rate=0.0,
      drop_path_rate=0.1,
      norm_layer=nn.LayerNorm,
      ape=False,
      patch_norm=True,
      use_checkpoint=False,
      upscale=2,
      img_range=1.0,
      upsampler="",
      resi_connection="1conv",
      **kwargs,
  ):
      super(SwinIR, self).__init__()
      num_in_ch = in_chans
      num_out_ch = in_chans
      num_feat = 64
      self.img_range = img_range
      if in_chans == 3:
          rgb_mean = (0.4488, 0.4371, 0.4040)
          self.mean = paddle.to_tensor(rgb_mean).reshape((1, 3, 1, 1))
      else:
          self.mean = paddle.zeros((1, 1, 1, 1))
      self.upscale = upscale
      self.upsampler = upsampler
      self.window_size = window_size
  
      #####################################################################################################
      ################################### 1, shallow feature extraction ###################################
      self.conv_first = nn.Conv2D(num_in_ch, embed_dim, 3, 1, 1)
  
      #####################################################################################################
      ################################### 2, deep feature extraction ######################################
      self.num_layers = len(depths)
      self.embed_dim = embed_dim
      self.ape = ape
      self.patch_norm = patch_norm
      self.num_features = embed_dim
      self.mlp_ratio = mlp_ratio
  
      # split image into non-overlapping patches
      self.patch_embed = PatchEmbed(
          img_size=img_size,
          patch_size=patch_size,
          in_chans=embed_dim,
          embed_dim=embed_dim,
          norm_layer=norm_layer if self.patch_norm else None,
      )
      num_patches = self.patch_embed.num_patches
      patches_resolution = self.patch_embed.patches_resolution
      self.patches_resolution = patches_resolution
  
      # merge non-overlapping patches into image
      self.patch_unembed = PatchUnEmbed(
          img_size=img_size,
          patch_size=patch_size,
          in_chans=embed_dim,
          embed_dim=embed_dim,
          norm_layer=norm_layer if self.patch_norm else None,
      )
  
      # absolute position embedding
      if self.ape:
          # self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))
          self.absolute_pos_embed = self.create_parameter(
              shape=(1, num_patches, embed_dim),
              default_initializer=nn.initializer.Constant(0.0),
          )
  
      self.pos_drop = nn.Dropout(p=drop_rate)
  
      # stochastic depth
      dpr = [
          x.item()
          for x in paddle.linspace(0, drop_path_rate, sum(depths))
      ]  # stochastic depth decay rule
  
      # build Residual Swin Transformer blocks (RSTB)
      self.layers = nn.LayerList()
      for i_layer in range(self.num_layers):
          layer = RSTB(
              dim=embed_dim,
              input_resolution=(
                  patches_resolution[0],
                  patches_resolution[1],
              ),
              depth=depths[i_layer],
              num_heads=num_heads[i_layer],
              window_size=window_size,
              mlp_ratio=self.mlp_ratio,
              qkv_bias=qkv_bias,
              qk_scale=qk_scale,
              drop=drop_rate,
              attn_drop=attn_drop_rate,
              drop_path=dpr[
                  sum(depths[:i_layer]) : sum(depths[: i_layer + 1])
              ],  # no impact on SR results
              norm_layer=norm_layer,
              downsample=None,
              use_checkpoint=use_checkpoint,
              img_size=img_size,
              patch_size=patch_size,
              resi_connection=resi_connection,
          )
          self.layers.append(layer)
      self.norm = norm_layer(self.num_features)
  
      # build the last conv layer in deep feature extraction
      if resi_connection == "1conv":
          self.conv_after_body = nn.Conv2D(
              embed_dim, embed_dim, 3, 1, 1
          )
      elif resi_connection == "3conv":
          # to save parameters and memory
          self.conv_after_body = nn.Sequential(
              nn.Conv2D(embed_dim, embed_dim // 4, 3, 1, 1),
              nn.LeakyReLU(negative_slope=0.2),
              nn.Conv2D(embed_dim // 4, embed_dim // 4, 1, 1, 0),
              nn.LeakyReLU(negative_slope=0.2),
              nn.Conv2D(embed_dim // 4, embed_dim, 3, 1, 1),
          )
  
      #####################################################################################################
      ################################ 3, high quality image reconstruction ################################
      if self.upsampler == "pixelshuffle":
          # for classical SR
          self.conv_before_upsample = nn.Sequential(
              nn.Conv2D(embed_dim, num_feat, 3, 1, 1), nn.LeakyReLU()
          )
          self.upsample = Upsample(upscale, num_feat)
          self.conv_last = nn.Conv2D(num_feat, num_out_ch, 3, 1, 1)
      elif self.upsampler == "pixelshuffledirect":
          # for lightweight SR (to save parameters)
          self.upsample = UpsampleOneStep(
              upscale,
              embed_dim,
              num_out_ch,
              (patches_resolution[0], patches_resolution[1]),
          )
      elif self.upsampler == "nearest+conv":
          # for real-world SR (less artifacts)
          self.conv_before_upsample = nn.Sequential(
              nn.Conv2D(embed_dim, num_feat, 3, 1, 1), nn.LeakyReLU()
          )
          self.conv_up1 = nn.Conv2D(num_feat, num_feat, 3, 1, 1)
          if self.upscale == 4:
              self.conv_up2 = nn.Conv2D(num_feat, num_feat, 3, 1, 1)
          self.conv_hr = nn.Conv2D(num_feat, num_feat, 3, 1, 1)
          self.conv_last = nn.Conv2D(num_feat, num_out_ch, 3, 1, 1)
          self.lrelu = nn.LeakyReLU(negative_slope=0.2)
      else:
          # for image denoising and JPEG compression artifact reduction
          self.conv_last = nn.Conv2D(embed_dim, num_out_ch, 3, 1, 1)
  
      self.apply(self._init_weights)
  
imports: import math
  import paddle
  import paddle.nn
  import paddle.nn.functional
label_desc: Use image node_id 1 to create a new SwinIR object from inherited base classes: nn with example: obj = SwinIR(img_size, patch_size, in_chans, embed_dim, depths, num_heads, window_size, mlp_ratio, qkv_bias, qk_scale, drop_rate, attn_drop_rate, drop_path_rate, norm_layer, ape, patch_norm, use_checkpoint, upscale, img_range, upsampler, resi_connection)