code: def test_patch_embed():
      B = 2
      H = 3
      W = 4
      C = 3
      embed_dims = 10
      kernel_size = 3
      stride = 1
      dummy_input = torch.rand(B, C, H, W)
      patch_merge_1 = PatchEmbed(
          in_channels=C,
          embed_dims=embed_dims,
          kernel_size=kernel_size,
          stride=stride,
          padding=0,
          dilation=1,
          norm_cfg=None,
      )
  
      x1, shape = patch_merge_1(dummy_input)
      # test out shape
      assert x1.shape == (2, 2, 10)
      # test outsize is correct
      assert shape == (1, 2)
      # test L = out_h * out_w
      assert shape[0] * shape[1] == x1.shape[1]
  
      B = 2
      H = 10
      W = 10
      C = 3
      embed_dims = 10
      kernel_size = 5
      stride = 2
      dummy_input = torch.rand(B, C, H, W)
      # test dilation
      patch_merge_2 = PatchEmbed(
          in_channels=C,
          embed_dims=embed_dims,
          kernel_size=kernel_size,
          stride=stride,
          padding=0,
          dilation=2,
          norm_cfg=None,
      )
  
      x2, shape = patch_merge_2(dummy_input)
      # test out shape
      assert x2.shape == (2, 1, 10)
      # test outsize is correct
      assert shape == (1, 1)
      # test L = out_h * out_w
      assert shape[0] * shape[1] == x2.shape[1]
  
      stride = 2
      input_size = (10, 10)
  
      dummy_input = torch.rand(B, C, H, W)
      # test stride and norm
      patch_merge_3 = PatchEmbed(
          in_channels=C,
          embed_dims=embed_dims,
          kernel_size=kernel_size,
          stride=stride,
          padding=0,
          dilation=2,
          norm_cfg=dict(type="LN"),
          input_size=input_size,
      )
  
      x3, shape = patch_merge_3(dummy_input)
      # test out shape
      assert x3.shape == (2, 1, 10)
      # test outsize is correct
      assert shape == (1, 1)
      # test L = out_h * out_w
      assert shape[0] * shape[1] == x3.shape[1]
  
      # test the init_out_size with nn.Unfold
      assert (
          patch_merge_3.init_out_size[1]
          == (input_size[0] - 2 * 4 - 1) // 2 + 1
      )
      assert (
          patch_merge_3.init_out_size[0]
          == (input_size[0] - 2 * 4 - 1) // 2 + 1
      )
      H = 11
      W = 12
      input_size = (H, W)
      dummy_input = torch.rand(B, C, H, W)
      # test stride and norm
      patch_merge_3 = PatchEmbed(
          in_channels=C,
          embed_dims=embed_dims,
          kernel_size=kernel_size,
          stride=stride,
          padding=0,
          dilation=2,
          norm_cfg=dict(type="LN"),
          input_size=input_size,
      )
  
      _, shape = patch_merge_3(dummy_input)
      # when input_size equal to real input
      # the out_size should be equal to `init_out_size`
      assert shape == patch_merge_3.init_out_size
  
      input_size = (H, W)
      dummy_input = torch.rand(B, C, H, W)
      # test stride and norm
      patch_merge_3 = PatchEmbed(
          in_channels=C,
          embed_dims=embed_dims,
          kernel_size=kernel_size,
          stride=stride,
          padding=0,
          dilation=2,
          norm_cfg=dict(type="LN"),
          input_size=input_size,
      )
  
      _, shape = patch_merge_3(dummy_input)
      # when input_size equal to real input
      # the out_size should be equal to `init_out_size`
      assert shape == patch_merge_3.init_out_size
  
      # test adap padding
      for padding in ("same", "corner"):
          in_c = 2
          embed_dims = 3
          B = 2
  
          # test stride is 1
          input_size = (5, 5)
          kernel_size = (5, 5)
          stride = (1, 1)
          dilation = 1
          bias = False
  
          x = torch.rand(B, in_c, *input_size)
          patch_embed = PatchEmbed(
              in_channels=in_c,
              embed_dims=embed_dims,
              kernel_size=kernel_size,
              stride=stride,
              padding=padding,
              dilation=dilation,
              bias=bias,
          )
  
          x_out, out_size = patch_embed(x)
          assert x_out.size() == (B, 25, 3)
          assert out_size == (5, 5)
          assert x_out.size(1) == out_size[0] * out_size[1]
  
          # test kernel_size == stride
          input_size = (5, 5)
          kernel_size = (5, 5)
          stride = (5, 5)
          dilation = 1
          bias = False
  
          x = torch.rand(B, in_c, *input_size)
          patch_embed = PatchEmbed(
              in_channels=in_c,
              embed_dims=embed_dims,
              kernel_size=kernel_size,
              stride=stride,
              padding=padding,
              dilation=dilation,
              bias=bias,
          )
  
          x_out, out_size = patch_embed(x)
          assert x_out.size() == (B, 1, 3)
          assert out_size == (1, 1)
          assert x_out.size(1) == out_size[0] * out_size[1]
  
          # test kernel_size == stride
          input_size = (6, 5)
          kernel_size = (5, 5)
          stride = (5, 5)
          dilation = 1
          bias = False
  
          x = torch.rand(B, in_c, *input_size)
          patch_embed = PatchEmbed(
              in_channels=in_c,
              embed_dims=embed_dims,
              kernel_size=kernel_size,
              stride=stride,
              padding=padding,
              dilation=dilation,
              bias=bias,
          )
  
          x_out, out_size = patch_embed(x)
          assert x_out.size() == (B, 2, 3)
          assert out_size == (2, 1)
          assert x_out.size(1) == out_size[0] * out_size[1]
  
          # test different kernel_size with different stride
          input_size = (6, 5)
          kernel_size = (6, 2)
          stride = (6, 2)
          dilation = 1
          bias = False
  
          x = torch.rand(B, in_c, *input_size)
          patch_embed = PatchEmbed(
              in_channels=in_c,
              embed_dims=embed_dims,
              kernel_size=kernel_size,
              stride=stride,
              padding=padding,
              dilation=dilation,
              bias=bias,
          )
  
          x_out, out_size = patch_embed(x)
          assert x_out.size() == (B, 3, 3)
          assert out_size == (1, 3)
          assert x_out.size(1) == out_size[0] * out_size[1]
  
file_path: mmdetection/tests/test_models/test_layers/test_transformer.py
imports: import pytest
  import torch
  from mmengine.config import ConfigDict
  from mmdet.models.layers.transformer import AdaptivePadding, DDQTransformerDecoder, DetrTransformerDecoder, DetrTransformerEncoder, PatchEmbed, PatchMerging
label_desc: Use image node_id 2 for calling a global function with example usage: test_patch_embed() without return types