code: def __init__(self, config):
      super().__init__(config)
      self.start_net_path = "../start_nets/start_net_convnet_small_C10+"
      self.arch_search_folder = (
          "../arch_search/Convnet/C10+/Conv_C10+_rl_small"
      )
      self.net_pool_folder = (
          "../net_pool/Convnet/C10+/Conv_C10+_rl_small"
      )
      self.max_episodes = 3  # changed from 15
      self.random = False
      self.exp_list = []
      self.idx_to_task = {}
      self.episode_batches = 3
      self.nSamples = self.max_episodes * self.episode_batches
      self.finished_tasks = 0
      self.results = {}
  
      self.filter_num_list = [_i for _i in range(4, 44, 4)]
      self.units_num_list = [_i for _i in range(8, 88, 8)]
      # filter_num_list = [16, 32, 64, 96, 128, 192, 256, 320, 384, 448, 512, 576, 640]
      # units_num_list = [64, 128, 256, 384, 512, 640, 768, 896, 1024, 1152, 1280]
      self.kernel_size_list = [1, 3, 5]
  
      # encoder config
      self.layer_token_list = [
          "conv-%d-%d" % (f, k)
          for f in self.filter_num_list
          for k in [1, 3, 5]
      ]
      self.layer_token_list += [
          "fc-%d" % u for u in self.units_num_list
      ] + ["pool"]
      self.encoder_config = {
          "num_steps": 50,
          "vocab": arch_search_convnet_net2net.Vocabulary(
              self.layer_token_list
          ),
          "embedding_dim": 16,
          "rnn_units": 50,
          "rnn_type": "bi_lstm",
          "rnn_layers": 1,
      }
  
      # wider actor config
      self.wider_actor_config = {
          "out_dim": 1,
          "num_steps": self.encoder_config["num_steps"],
          "net_type": "simple",
          "net_config": None,
      }
  
      # deeper actor config
      self.deeper_actor_config = {
          "decision_num": 3,
          "out_dims": [5, 10, len(self.kernel_size_list)],
          "embedding_dim": self.encoder_config["embedding_dim"],
          "cell_type": "lstm",
          "rnn_layers": 1,
          "attention_config": None,
      }
  
      # meta-controller config
      self.entropy_penalty = 1e-5
      self.learning_rate = 2e-3
      self.opt_config = ["adam", {}]
  
      # net2net noise config
      self.noise_config = {
          "wider": {"type": "normal", "ratio": 1e-2},
          "deeper": {"type": "normal", "ratio": 1e-3},
      }
  
      # episode config
      self.episode_config = {
          "batch_size": self.episode_batches,
          "wider_action_num": 4,
          "deeper_action_num": 5,
      }
  
      # arch search run config
      self.arch_search_run_config = {
          "n_epochs": 20,
          "init_lr": 0.02,
          "validation_size": 5000,
          "other_lr_schedule": {"type": "cosine"},
          "batch_size": 64,
          "include_extra": False,
      }
  
      # reward config
      self.reward_config = {
          "func": "tan",
          "decay": 0.95,
      }
  
      self.arch_manager = arch_search_convnet_net2net.ArchManager(
          self.start_net_path,
          self.arch_search_folder,
          self.net_pool_folder,
      )
      _, self.run_config, _ = self.arch_manager.get_start_net()
      self.run_config.update(self.arch_search_run_config)
  
      self.encoder = arch_search_convnet_net2net.EncoderNet(
          **self.encoder_config
      )
      self.wider_actor = arch_search_convnet_net2net.WiderActorNet(
          **self.wider_actor_config
      )
      self.deeper_actor = arch_search_convnet_net2net.DeeperActorNet(
          **self.deeper_actor_config
      )
      self.meta_controller = (
          arch_search_convnet_net2net.ReinforceNet2NetController(
              self.arch_manager.meta_controller_path,
              self.entropy_penalty,
              self.encoder,
              self.wider_actor,
              self.deeper_actor,
              self.opt_config,
          )
      )
      self.meta_controller.load()
  
      self.episode = 0
  
      logger.info("Finishing init")
  
      self.setup()
  
file_path: auptimizer/src/aup/Proposer/EASProposer.py
imports: import re
  import numpy
  import logging
label_desc: Use image node_id 6 to create a new EASProposer object from inherited base classes: AbstractProposer with example: obj = EASProposer(config)