code: def __init__(
      self,
      depth=16,
      normalizations=[20.0, -1, -1, -1, -1, -1],
      extra_block_filters=[
          [256, 512, 1, 2, 3],
          [128, 256, 1, 2, 3],
          [128, 256, 0, 1, 3],
          [128, 256, 0, 1, 3],
      ],
  ):
      super(VGG, self).__init__()
  
      assert depth in [
          16,
          19,
      ], "depth as 16/19 supported currently, but got {}".format(depth)
      self.depth = depth
      self.groups = VGG_cfg[depth]
      self.normalizations = normalizations
      self.extra_block_filters = extra_block_filters
  
      self._out_channels = []
  
      self.conv_block_0 = ConvBlock(
          3, 64, self.groups[0], 2, 2, 0, name="conv1_"
      )
      self.conv_block_1 = ConvBlock(
          64, 128, self.groups[1], 2, 2, 0, name="conv2_"
      )
      self.conv_block_2 = ConvBlock(
          128, 256, self.groups[2], 2, 2, 0, name="conv3_"
      )
      self.conv_block_3 = ConvBlock(
          256, 512, self.groups[3], 2, 2, 0, name="conv4_"
      )
      self.conv_block_4 = ConvBlock(
          512, 512, self.groups[4], 3, 1, 1, name="conv5_"
      )
      self._out_channels.append(512)
  
      self.fc6 = Conv2D(
          in_channels=512,
          out_channels=1024,
          kernel_size=3,
          stride=1,
          padding=6,
          dilation=6,
      )
      self.fc7 = Conv2D(
          in_channels=1024,
          out_channels=1024,
          kernel_size=1,
          stride=1,
          padding=0,
      )
      self._out_channels.append(1024)
  
      # extra block
      self.extra_convs = []
      last_channels = 1024
      for i, v in enumerate(self.extra_block_filters):
          assert len(v) == 5, "extra_block_filters size not fix"
          extra_conv = self.add_sublayer(
              "conv{}".format(6 + i),
              ExtraBlock(last_channels, v[0], v[1], v[2], v[3], v[4]),
          )
          last_channels = v[1]
          self.extra_convs.append(extra_conv)
          self._out_channels.append(last_channels)
  
      self.norms = []
      for i, n in enumerate(self.normalizations):
          if n != -1:
              norm = self.add_sublayer(
                  "norm{}".format(i),
                  L2NormScale(self.extra_block_filters[i][1], n),
              )
          else:
              norm = None
          self.norms.append(norm)
  
imports: from __future__ import division
  import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddle import ParamAttr
  from paddle.nn import Conv2D, MaxPool2D
  from ppdet.core.workspace import register, serializable
  from ..shape_spec import ShapeSpec
label_desc: Use image node_id 1 to create a new VGG object from inherited base classes: nn with example: obj = VGG(depth, normalizations, extra_block_filters)