class_docstr: VGG, see https://arxiv.org/abs/1409.1556
  
  Args:
      depth (int): the VGG net depth (16 or 19)
      normalizations (list): params list of init scale in l2 norm, skip init
          scale if param is -1.
      with_extra_blocks (bool): whether or not extra blocks should be added
      extra_block_filters (list): in each extra block, params:
          [in_channel, out_channel, padding_size, stride_size, filter_size]
      class_dim (int): number of class while classification
code: def _vgg_block(self, input):
      nums = self.depth_cfg[self.depth]
      vgg_base = [64, 128, 256, 512, 512]
      conv = input
      res_layer = []
      layers = []
      for k, v in enumerate(vgg_base):
          conv = self._conv_block(
              conv, v, nums[k], name="conv{}_".format(k + 1)
          )
          layers.append(conv)
          if self.with_extra_blocks:
              if k == 4:
                  conv = self._pooling_block(conv, 3, 1, pool_padding=1)
              else:
                  conv = self._pooling_block(conv, 2, 2)
          else:
              conv = self._pooling_block(conv, 2, 2)
      if not self.with_extra_blocks:
          fc_dim = 4096
          fc_name = ["fc6", "fc7", "fc8"]
          fc1 = fluid.layers.fc(
              input=conv,
              size=fc_dim,
              act="relu",
              param_attr=fluid.param_attr.ParamAttr(
                  name=fc_name[0] + "_weights"
              ),
              bias_attr=fluid.param_attr.ParamAttr(
                  name=fc_name[0] + "_offset"
              ),
          )
          fc2 = fluid.layers.fc(
              input=fc1,
              size=fc_dim,
              act="relu",
              param_attr=fluid.param_attr.ParamAttr(
                  name=fc_name[1] + "_weights"
              ),
              bias_attr=fluid.param_attr.ParamAttr(
                  name=fc_name[1] + "_offset"
              ),
          )
          out = fluid.layers.fc(
              input=fc2,
              size=self.class_dim,
              param_attr=fluid.param_attr.ParamAttr(
                  name=fc_name[2] + "_weights"
              ),
              bias_attr=fluid.param_attr.ParamAttr(
                  name=fc_name[2] + "_offset"
              ),
          )
          out = fluid.layers.softmax(out)
          res_layer.append(out)
          return [out]
      else:
          fc6 = self._conv_layer(
              conv, 1024, 3, 1, 6, dilation=6, name="fc6"
          )
          fc7 = self._conv_layer(fc6, 1024, 1, 1, 0, name="fc7")
          return [layers[3], fc7]
  
file_path: PaddleHub/modules/image/classification/vgg16_imagenet/vgg.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from paddle import fluid
  from paddle.fluid.param_attr import ParamAttr
label_desc: Use image node_id 3 for calling the VGG obj's underlying member method code with example usage: obj._vgg_block(input) and returns: list, list