code: def set_standard_convnet(
      self,
      data_provider: DataProvider,
      conv_blocks_config,
      fc_block_config,
      weight_decay,
      drop_scheme,
      bn_epsilon,
      bn_decay,
      print_info=True,
      **kwargs,
  ):
      self.net_config = {
          "weight_decay": weight_decay,
          "bn_epsilon": bn_epsilon,
          "bn_decay": bn_decay,
          "drop_scheme": drop_scheme,
      }
  
      image_size = data_provider.data_shape[0]
  
      layers = []
      conv_id = 0
      for _i, block_config in enumerate(conv_blocks_config):
          num_layers, kernel_size, filter_num = block_config
          for _j in range(num_layers):
              keep_prob = 1.0
              if "conv" in drop_scheme["type"]:
                  keep_prob = (
                      1.0
                      if _i + _j == 0
                      else drop_scheme.get("conv_drop", 1.0)
                  )
              conv_layer = ConvLayer(
                  "conv_%d" % conv_id,
                  filter_num,
                  kernel_size=kernel_size,
                  keep_prob=keep_prob,
                  pre_activation=False,
              )
              conv_id += 1
              layers.append(conv_layer)
          if _i < len(conv_blocks_config) - 1:
              keep_prob = 1.0
              if "pool" in drop_scheme["type"]:
                  keep_prob = drop_scheme.get("pool_drop", 1.0)
              pool_layer = PoolLayer(
                  "pool_%d" % _i,
                  "max",
                  keep_prob=keep_prob,
                  pre_activation=False,
              )
              layers.append(pool_layer)
              image_size = image_size // 2
      global_avg_pool = PoolLayer(
          "pool_%d" % len(conv_blocks_config),
          "avg",
          kernel_size=image_size,
          strides=image_size,
          pre_activation=False,
      )
      layers.append(global_avg_pool)
      for _i, units in enumerate(fc_block_config):
          keep_prob = 1.0
          if "fc" in drop_scheme["type"]:
              keep_prob = drop_scheme.get("fc_drop", 1.0)
          fc_layer = FCLayer("fc_%d" % _i, units, keep_prob=keep_prob)
          layers.append(fc_layer)
      final_fc_layer = FCLayer(
          "fc_%d" % len(fc_block_config),
          data_provider.n_classes,
          use_bn=False,
          use_bias=True,
          activation=None,
      )
      layers.append(final_fc_layer)
      self.layer_cascade = LayerCascade("SimpleConvNet", layers)
  
      if print_info:
          pass
      return self
  
imports: from models.basic_model import BasicModel
  from data_providers.base_provider import DataProvider
  from models.layers import ConvLayer, PoolLayer, FCLayer
  from models.layer_cascade import LayerCascade
  import tensorflow
  import numpy
label_desc: Use image node_id 10 for calling the SimpleConvnetConfig obj's underlying member method code with example usage: obj.set_standard_convnet(data_provider, conv_blocks_config, fc_block_config, weight_decay, drop_scheme, bn_epsilon, bn_decay, print_info) and returns: self