code: def apply_deeper_decision(
      deeper_decision, net_configs, kernel_size_list, noise
  ):
      if len(net_configs) == 1:
          decision = deeper_decision[0]
          net_config = net_configs[0]
  
          block_decision, layer_idx_decision, ks_decision = decision
          decision_mask = [1.0, 1.0]
          block_idx, _pt = 0, 0
          to_set_layers = []
          for _i, layer in enumerate(
              net_config.layer_cascade.layers[:-1]
          ):
              if _pt == block_decision:
                  real_layer_idx = _i + layer_idx_decision
                  prev_layer = net_config.layer_cascade.layers[
                      real_layer_idx
                  ]
                  if isinstance(prev_layer, ConvLayer):
                      if "conv" in net_config.drop_scheme["type"]:
                          keep_prob = net_config.drop_scheme.get(
                              "conv_drop", 1.0
                          )
                      else:
                          keep_prob = 1.0
                      decision_mask.append(1.0)
                      ks = kernel_size_list[ks_decision]
                      new_layer, prev_layer = net_config.deepen(
                          layer_idx=real_layer_idx,
                          new_layer_config={
                              "name": "conv",
                              "kernel_size": ks,
                              "pre_activation": False,
                              "keep_prob": keep_prob,
                          },
                      )
                      to_set_layers.append([new_layer, prev_layer])
                  elif isinstance(prev_layer, FCLayer):
                      if "fc" in net_config.drop_scheme["type"]:
                          keep_prob = net_config.drop_scheme.get(
                              "fc_drop", 1.0
                          )
                      else:
                          keep_prob = 1.0
                      decision_mask.append(0.0)
                      new_layer, prev_layer = net_config.deepen(
                          layer_idx=real_layer_idx,
                          new_layer_config={
                              "name": "fc",
                              "keep_prob": keep_prob,
                          },
                      )
                      to_set_layers.append([new_layer, prev_layer])
                  else:
                      raise ValueError
                  break
              if isinstance(layer, PoolLayer):
                  _pt += 1
          return np.array([decision_mask]), to_set_layers
      else:
          decision_mask = []
          to_set_layers = []
          for _i, net_config in enumerate(net_configs):
              decision = deeper_decision[_i]
              mask, to_set = apply_deeper_decision(
                  [decision], [net_config], kernel_size_list, noise
              )
              decision_mask.append(mask)
              to_set_layers.append(to_set)
          return np.concatenate(decision_mask, axis=0), to_set_layers
  
file_path: auptimizer/src/aup/Proposer/eas/arch_search/arch_search_convnet_net2net.py
imports: from ..expdir_monitor.arch_manager import ArchManager
  from ..meta_controller.base_controller import Vocabulary, EncoderNet, WiderActorNet, DeeperActorNet
  from ..meta_controller.rl_controller import ReinforceNet2NetController
  from time import gmtime, strftime, time
  from datetime import timedelta
  from ..models.layers import ConvLayer, FCLayer, PoolLayer
  import re
  import numpy
label_desc: Use image node_id 5 for calling a global function with example usage: apply_deeper_decision(deeper_decision, net_configs, kernel_size_list, noise) and returns: np,  to_set_layers, np,  to_set_layers