雷鋒網(wǎng)按：本文由圖普科技編譯自《Design by Evolution: How to evolve your neural network with AutoML》，雷鋒網(wǎng)獨家首發(fā)。

對大多數(shù)從事機器學(xué)習(xí)工作的人來說，設(shè)計一個神經(jīng)網(wǎng)絡(luò)無異于制作一項藝術(shù)作品。神經(jīng)網(wǎng)絡(luò)通常始于一個常見的架構(gòu)，然后我們需要對參數(shù)不斷地進行調(diào)整和優(yōu)化，直到找到一個好的組合層、激活函數(shù)、正則化器和優(yōu)化參數(shù)。在一些知名的神經(jīng)網(wǎng)絡(luò)架構(gòu)，如VGG、Inception、ResNets、DenseNets等的指導(dǎo)下，我們需要對網(wǎng)絡(luò)的變量進行重復(fù)的操作，直到網(wǎng)絡(luò)達到我們期望的速度與準確度。隨著網(wǎng)絡(luò)處理能力的不斷提高，將網(wǎng)絡(luò)優(yōu)化處理程序自動化變得越來越可行。

在像Random Forests和SVMs這樣的淺模型中，我們已經(jīng)能夠使超參數(shù)優(yōu)化的操作自動化進行了。一些常用的工具包，比如sk-learn，向我們提供了搜索超參數(shù)空間的方法。在其最簡單的、最基礎(chǔ)的格式中，“超參數(shù)”是我們在所有可能的參數(shù)中搜索得到的，或者是通過從參數(shù)分布中任意采樣得到的。（詳情請點擊此鏈接查看。）這兩種方法都面臨著兩個問題：第一，在錯誤參數(shù)區(qū)域進行搜索時會造成資源浪費；第二，處理大量的動態(tài)特征參數(shù)集將導(dǎo)致效率過低。因此，改變處理器的架構(gòu)變得相當困難。雖然現(xiàn)在有很多看似高效的方法，比如Bayesian優(yōu)化方法。但Bayesian優(yōu)化法雖然能夠解決了第一個問題，卻對第二個問題無能為力；另外，在Bayesian優(yōu)化設(shè)置中也很難進行探索模型。

自動識別最佳模型的想法就現(xiàn)在來說已經(jīng)不算新鮮了，再加上最近大幅度提升的處理能力，實現(xiàn)這一想法比以往任何時候都要容易。

問題設(shè)定

考慮超參數(shù)優(yōu)化的方式之一，就是將它看做一個“元學(xué)習(xí)問題”。

我們究竟能否打造出一個可以用于判斷網(wǎng)絡(luò)性能好壞的算法呢？

注意：接下來我將繼續(xù)使用“元學(xué)習(xí)”這個術(shù)語，即使將這個問題描述為“元學(xué)習(xí)”有點混淆視聽，但我們千萬不能把它與“學(xué)習(xí)”相關(guān)的一些方法弄混了。

我們的目標是定義網(wǎng)絡(luò)隱含層（綠色）的數(shù)量以及每個隱含層的參數(shù)。

具體而言，就是探究模型架構(gòu)和模型的參數(shù)空間，從而在給定的數(shù)據(jù)集上優(yōu)化其性能。這個問題復(fù)雜難解，而回報稀薄。之所以說它回報稀薄，是因為我們需要對網(wǎng)絡(luò)進行足夠的訓(xùn)練，還要對它進行評估；而在訓(xùn)練、評估完成后，我們得到回報的僅僅是一些得分。這些得分反映了整個系統(tǒng)的性能表現(xiàn)，而這種類型的回報并不是可導(dǎo)函數(shù)！說到這，是不是讓你想起了什么呢？沒錯，這就是一個典型的“強化學(xué)習(xí)”情境！

維基百科對“強化學(xué)習(xí)”的定義：

“強化學(xué)習(xí)”（RL）是一種重要的機器學(xué)習(xí)方法，它的靈感來自于心理學(xué)的行為主義理論。具體來說，“強化學(xué)習(xí)”是關(guān)于有機體（agent）如何在環(huán)境（environment）的刺激下，將累計獎勵最大化的方法。

“強化學(xué)習(xí)”與標準的監(jiān)督式學(xué)習(xí)之間的區(qū)別在于它不需要出現(xiàn)正確的輸入或輸出對，也不需要精準校正其次優(yōu)化行為。另外，“在線性能”也是“強化學(xué)習(xí)”關(guān)注的焦點，即在未知領(lǐng)域的探索與現(xiàn)有知識的開發(fā)之間找到平衡。

上圖情境中的有機體（agent）是一個模型，環(huán)境（environment）就是我們用于訓(xùn)練和評估的數(shù)據(jù)集。解釋器（interpreter）是對每一行為進行分析以及設(shè)置有機體狀態(tài)（在我們這個情境中，解釋器設(shè)置的是網(wǎng)絡(luò)參數(shù)）的過程。

通常情況下，“強化學(xué)習(xí)”問題都被定義為一個Markov決策過程。其目的就是優(yōu)化有機體的總回報。每一步，你需要對優(yōu)化模型輸出作出決策，或者是探索出一個新的行為。在環(huán)境的刺激下，有機體將根據(jù)得到的反饋，形成一個調(diào)整政策，不斷改進其行為。

注意：這個話題超出了本文討論的范圍，R.Sutton和A. Barto的《強化學(xué)習(xí)介紹》可能是關(guān)于這個主題的最佳入門指導(dǎo)書。

進化算法

解決“強化學(xué)習(xí)”問題的另一種方法是“進化算法”。在生物進化的啟發(fā)下，進化算法通過創(chuàng)建一個解決方案的集合，尋找解決方案的空間；然后，它會對每一解決方案進行評估，并根據(jù)評估得分不斷調(diào)整這個方案集合。生物進化論中所講的“進化”涉及到一個種群中最佳成員的選擇和變異。因此，我們的解決方案集合也會不斷進化發(fā)展，以提高其整體適應(yīng)性，并為問題找到提供可行的解決方案。

進化算法中的“進化”

上圖的左邊介紹了進化的過程，設(shè)計一個“進化算法”涉及到兩個部分——“選擇”，以及需要遵循的“跨界”或“變異”策略。

“選擇”：對于“選擇”，我們通常的做法是挑選最佳的個體和一些任意的個體，以達到多樣性。更先進的選擇方法是在種群下設(shè)立不同的“次群”，即“物種”；然后在物種中選擇最佳的個體，以保護其多樣性。另一種比較受歡迎的做法是“競賽選擇”，即任意選擇一些個體參與競賽，挑選出勝者（基因優(yōu)勝的個體）。

“跨界”：“跨界”也稱“交叉跨界”，指的是兩組或兩組以上親本交叉混合，產(chǎn)生后代?！敖徊婵缃纭备叨纫蕾囉趩栴}結(jié)構(gòu)的方式。常見的方法是用一個項目列表（一般是數(shù)值）對親本進行描述，然后從親本中挑選任意部分來生成新的基因組合。

“變異”：“變異”或“突變”指的是任意改變基因組的過程。這是主要的開發(fā)因素，有助于保持種群的多樣性。

實施啟用

“進化算法”的實施啟用使用了PyTorch來建立代理，這個代理將會探索用于完成簡單分類任務(wù)的DNNs。這個實驗使用的是MNIST，因為它小且快，即使在CPU上也能完成訓(xùn)練。我們將建立一組DNN模型，并將其發(fā)展進化為N個步驟。

我們所講的“進化”主題實際上就是“物競天擇”的實施，完整的高水平“進化算法”如下所示：

  new_population = []
  while size(new_population) < population_size:
  choose k(tournament) individuals from the population at random
  choose the best from pool/tournament with probability p1
  choose the second best individual with probability p2
  choose the third best individual with probability p3
  mutate and append selected to the new_population

附注：當涉及到架構(gòu)合并時，跨界問題就變得相當復(fù)雜了。究竟該如何將兩個親本的架構(gòu)合并呢？缺陷圖樣及環(huán)境整合訓(xùn)練將對此產(chǎn)生什么影響呢？近期的一篇來自Miikkulainen等人的論文提出了一種被稱為CoDeepNEAT的解決方案?；贓volino進化理論，一個架構(gòu)由部分單元模塊組成，其中的每一單元模塊都是服從于進化理論的。這個架構(gòu)是一個合并了所有組成成分的理想藍圖。在這樣的情境下，將親本的組成成分混合是十分合理的，因為其成分是一個完整的微型網(wǎng)絡(luò)。為了使文章更簡潔易懂，我在這個算法實施過程中避開了跨界交叉的問題，而是簡單介紹了類似NEAT（或CoDeepNEAT）這樣的解決方案。（我打算在下一篇文章中詳細介紹這些解決方案。）

基本的構(gòu)件

我們需要定義的第一件事情就是每一模型的解決方案空間，每一個個體都代表著一個架構(gòu)。簡潔起見，我們堆疊了n層，每一層都包含三個參數(shù)：a)隱藏單元的數(shù)量；b)激活類型；c)丟失率。對于通用參數(shù)，我們在不同的優(yōu)化器、學(xué)習(xí)率、權(quán)重衰減和層數(shù)量中進行選擇。

# definition of a space
# lower bound - upper bound, type param, mutation rate
LAYER_SPACE = dict()
LAYER_SPACE['nb_units'] = (128, 1024, 'int', 0.15)
LAYER_SPACE['dropout_rate'] = (0.0, 0.7, 'float', 0.2)
LAYER_SPACE['activation'] =\
   (0,  ['linear', 'tanh', 'relu', 'sigmoid', 'elu'], 'list', 0.2)

NET_SPACE = dict()
NET_SPACE['nb_layers'] = (1, 3, 'int', 0.15)
NET_SPACE['lr'] = (0.0001, 0.1, 'float', 0.15)
NET_SPACE['weight_decay'] = (0.00001, 0.0004, 'float', 0.2)
NET_SPACE['optimizer'] =\
   (0, ['sgd', 'adam', 'adadelta', 'rmsprop'], 'list', 0.2)
   

完成以上操作以后，我們已經(jīng)定義了模型的空間。接著我們還需要建立三個基本功能：

隨機選擇一個網(wǎng)絡(luò)

def random_value(space):
   """Sample  random value from the given space."""
   val = None
   if space[2] == 'int':
       val = random.randint(space[0], space[1])
   if space[2] == 'list':
       val = random.sample(space[1], 1)[0]
   if space[2] == 'float':
       val = ((space[1] - space[0]) * random.random()) + space[0]
   return {'val': val, 'id': random.randint(0, 2**10)}


def randomize_network(bounded=True):
   """Create a random network."""
   global NET_SPACE, LAYER_SPACE
   net = dict()
   for k in NET_SPACE.keys():
       net[k] = random_value(NET_SPACE[k])
   
   if bounded:
       net['nb_layers']['val'] = min(net['nb_layers']['val'], 1)
   
   layers = []
   for i in range(net['nb_layers']['val']):
       layer = dict()
       for k in LAYER_SPACE.keys():
           layer[k] = random_value(LAYER_SPACE[k])
       layers.append(layer)
   net['layers'] = layers
   return net

首先，我們?nèi)我獾貙訑?shù)量和每一層的參數(shù)進行采樣，樣本值會在預(yù)先定義好的范圍邊緣內(nèi)出現(xiàn)下降。在初始化一個參數(shù)的同時，我們還會產(chǎn)生一個任意的參數(shù)id。現(xiàn)在它還不能使用，但我們可以追蹤所有的層。當一個新的模型發(fā)生突變時，舊的層會進行微調(diào)，同時僅對發(fā)生突變的層進行初始化。這樣的做法應(yīng)該能夠顯著地加快速度，并穩(wěn)定解決方案。

注意：根據(jù)問題性質(zhì)的不同，我們可能需要不同的限制條件，比如參數(shù)的總量或?qū)拥目倲?shù)量。

使網(wǎng)絡(luò)發(fā)生變異

def mutate_net(net):
   """Mutate a network."""
   global NET_SPACE, LAYER_SPACE

   # mutate optimizer
   for k in ['lr', 'weight_decay', 'optimizer']:
       
       if random.random() < NET_SPACE[k][-1]:
           net[k] = random_value(NET_SPACE[k])
           
   # mutate layers
   for layer in net['layers']:
       for k in LAYER_SPACE.keys():
           if random.random() < LAYER_SPACE[k][-1]:
               layer[k] = random_value(LAYER_SPACE[k])
   # mutate number of layers -- RANDOMLY ADD
   if random.random() < NET_SPACE['nb_layers'][-1]:
       if net['nb_layers']['val'] < NET_SPACE['nb_layers'][1]:
           if random.random()< 0.5:
               layer = dict()
               for k in LAYER_SPACE.keys():
                   layer[k] = random_value(LAYER_SPACE[k])
               net['layers'].append(layer)
               # value & id update
               net['nb_layers']['val'] = len(net['layers'])
               net['nb_layers']['id'] +=1
           else:
               if net['nb_layers']['val'] > 1:
                   net['layers'].pop()
                   net['nb_layers']['val'] = len(net['layers'])
                   net['nb_layers']['id'] -=1
   return net

每一個網(wǎng)絡(luò)元素都存在變異的可能性，每一次變異都將重新采樣參數(shù)空間，進而使參數(shù)發(fā)生變化。

建立網(wǎng)絡(luò)

class CustomModel():

   def __init__(self, build_info, CUDA=True):

       previous_units = 28 * 28
       self.model = nn.Sequential()
       self.model.add_module('flatten', Flatten())
       for i, layer_info in enumerate(build_info['layers']):
           i = str(i)
           self.model.add_module(
               'fc_' + i,
               nn.Linear(previous_units, layer_info['nb_units']['val'])
               )
           self.model.add_module(
               'dropout_' + i,
               nn.Dropout(p=layer_info['dropout_rate']['val'])
               )
           if layer_info['activation']['val'] == 'tanh':
               self.model.add_module(
                   'tanh_'+i,
                   nn.Tanh()
               )
           if layer_info['activation']['val'] == 'relu':
               self.model.add_module(
                   'relu_'+i,
                   nn.ReLU()
               )
           if layer_info['activation']['val'] == 'sigmoid':
               self.model.add_module(
                   'sigm_'+i,
                   nn.Sigmoid()
               )
           if layer_info['activation']['val'] == 'elu':
               self.model.add_module(
                   'elu_'+i,
                   nn.ELU()
               )
           previous_units = layer_info['nb_units']['val']

       self.model.add_module(
           'classification_layer',
           nn.Linear(previous_units, 10)
           )
       self.model.add_module('sofmax', nn.LogSoftmax())
       self.model.cpu()
       
       if build_info['optimizer']['val'] == 'adam':
           optimizer = optim.Adam(self.model.parameters(),
                               lr=build_info['weight_decay']['val'],
                               weight_decay=build_info['weight_decay']['val'])

       elif build_info['optimizer']['val'] == 'adadelta':
           optimizer = optim.Adadelta(self.model.parameters(),
                                   lr=build_info['weight_decay']['val'],
                                   weight_decay=build_info['weight_decay']['val'])

       elif build_info['optimizer']['val'] == 'rmsprop':
           optimizer = optim.RMSprop(self.model.parameters(),
                                   lr=build_info['weight_decay']['val'],
                                   weight_decay=build_info['weight_decay']['val'])
       else:
           optimizer = optim.SGD(self.model.parameters(),
                               lr=build_info['weight_decay']['val'],
                               weight_decay=build_info['weight_decay']['val'],
                               momentum=0.9)
       self.optimizer = optimizer
       self.cuda = False
       if CUDA:
           self.model.cuda()
           self.cuda = True

上面的類別將會實例化模型的“基因組”。

現(xiàn)在，我們已經(jīng)具備了建立一個任意網(wǎng)絡(luò)、變更其架構(gòu)并對其進行訓(xùn)練的基本構(gòu)件，那么接下來的步驟就是建立“遺傳算法”，“遺傳算法”將會對最佳個體進行選擇和變異。每個模型的訓(xùn)練都是獨立進行的，不需要其他有機體的任何信息。這就使得優(yōu)化過程可以隨著可用的處理節(jié)點進行線性擴展。

GP優(yōu)化器的編碼

"""Genetic programming algorithms."""
from __future__ import absolute_import

import random
import numpy as np
from operator import itemgetter
import torch.multiprocessing as mp
from net_builder import randomize_network
import copy
from worker import CustomWorker, Scheduler
       

class TournamentOptimizer:
   """Define a tournament play selection process."""

   def __init__(self, population_sz, init_fn, mutate_fn, nb_workers=2, use_cuda=True):
       """
       Initialize optimizer.

           params::
               
               init_fn: initialize a model
               mutate_fn: mutate function - mutates a model
               nb_workers: number of workers
       """
       
       self.init_fn = init_fn
       self.mutate_fn = mutate_fn
       self.nb_workers = nb_workers
       self.use_cuda = use_cuda
       
       # population
       self.population_sz = population_sz
       self.population = [init_fn() for i in range(population_sz)]        
       self.evaluations = np.zeros(population_sz)
       
       # book keeping
       self.elite = []
       self.stats = []
       self.history = []

   def step(self):
       """Tournament evolution step."""
       print('\nPopulation sample:')
       for i in range(0,self.population_sz,2):
           print(self.population[i]['nb_layers'],
                 self.population[i]['layers'][0]['nb_units'])
       self.evaluate()
       children = []
       print('\nPopulation mean:{} max:{}'.format(
           np.mean(self.evaluations), np.max(self.evaluations)))
       n_elite = 2
       sorted_pop = np.argsort(self.evaluations)[::-1]
       elite = sorted_pop[:n_elite]
       
       # print top@n_elite scores
       # elites always included in the next population
       self.elite = []
       print('\nTop performers:')
       for i,e in enumerate(elite):
           self.elite.append((self.evaluations[e], self.population[e]))    
           print("{}-score:{}".format( str(i), self.evaluations[e]))  
           children.append(self.population[e])
       # tournament probabilities:
       # first p
       # second p*(1-p)
       # third p*((1-p)^2)
       # etc...
       p = 0.85 # winner probability
       tournament_size = 3
       probs = [p*((1-p)**i) for i in range(tournament_size-1)]
       # a little trick to certify that probs is adding up to 1.0
       probs.append(1-np.sum(probs))
       
       while len(children) < self.population_sz:
           pop = range(len(self.population))
           sel_k = random.sample(pop, k=tournament_size)
           fitness_k = list(np.array(self.evaluations)[sel_k])
           selected = zip(sel_k, fitness_k)
           rank = sorted(selected, key=itemgetter(1), reverse=True)
           pick = np.random.choice(tournament_size, size=1, p=probs)[0]
           best = rank[pick][0]
           model = self.mutate_fn(self.population[best])
           children.append(model)

       self.population = children
       
       # if we want to do a completely completely random search per epoch
       # self.population = [randomize_network(bounded=False) for i in range(self.population_sz) ]

   def evaluate(self):
       """evaluate the models."""
       
       workerids = range(self.nb_workers)
       workerpool = Scheduler(workerids, self.use_cuda )
       self.population, returns = workerpool.start(self.population)

       self.evaluations = returns
       self.stats.append(copy.deepcopy(returns))
       self.history.append(copy.deepcopy(self.population))

“進化算法”看起來非常簡單，對嗎？沒錯！這個算法可以非常成功，尤其是當你為個體定義了好的變異或跨界功能時。

存儲庫中還包含了一些額外的使用類別，比如工作器類和調(diào)度器類，使GP優(yōu)化器能夠獨立平行地完成模型訓(xùn)練和評估。

運行代碼

按照上述步驟操作運行。

"""Tournament play experiment."""
from __future__ import absolute_import
import net_builder
import gp
import cPickle
# Use cuda ?
CUDA_ = True

if __name__=='__main__':
   # setup a tournament!
   nb_evolution_steps = 10
   tournament = \
       gp.TournamentOptimizer(
           population_sz=50,
           init_fn=net_builder.randomize_network,
           mutate_fn=net_builder.mutate_net,
           nb_workers=3,
           use_cuda=True)

   for i in range(nb_evolution_steps):
       print('\nEvolution step:{}'.format(i))
       print('================')
       tournament.step()
       # keep track of the experiment results & corresponding architectures
       name = "tourney_{}".format(i)
       cPickle.dump(tournament.stats, open(name + '.stats','wb'))
       cPickle.dump(tournament.history, open(name +'.pop','wb'))

接下來，讓我們一起來看看運行的結(jié)果！

這是50個解決方案的得分結(jié)果，比賽規(guī)模為3。這些模型僅接受了10000個樣本的訓(xùn)練，然后就被評估了。乍一看，進化算法似乎并沒有起到太大的作用，因為解決方案在第一次進化中就已經(jīng)接近最佳狀態(tài)了；而在第七階段，解決方案達到了它的最佳表現(xiàn)。在下圖中，我們用了一個盒式圖來依次描述這些解決方案的四分之一。我們發(fā)現(xiàn)，大多數(shù)方案都表現(xiàn)的很好，但在方案進化的同時，這個盒式圖也隨之緊縮了。

 

左邊：方案的分布；右邊：每一階段方案的盒式圖。

圖中的這個盒子展示了方案的四分之一，而其盒須則延伸展示了剩余四分之三的方案分布。其中的黑點代表著方案的平均值，從圖中我們會發(fā)現(xiàn)平均值的上升趨勢。

 

不同的進化運行方式

為了進一步理解這一方法的性能和表現(xiàn)，我們最好將其與一個完全隨機的種群搜做相比較。每個階段之間都不需要進化，每個解決方案都要被重新設(shè)置為一個隨機的狀態(tài)。

 

上邊：方案的分布；下邊：每一步隨機生成的的方案盒式圖

在一個相對較小的（93.66% vs 93.22%）里進化算法的性能較好。而隨機種群搜索似乎生成了一些好的解決方案，但模型的方差卻大大增加了。這就意味著在搜索次優(yōu)架構(gòu)的時候出現(xiàn)了資源浪費。將這個與進化圖相比較，我們會發(fā)現(xiàn)進化確實生成了更多有用的解決方案，它成功地使那些結(jié)構(gòu)進化了，進而使之達到了更好的性能表現(xiàn)。

• MNIST是一個相當簡單的數(shù)據(jù)集，即使是單層網(wǎng)絡(luò)也能達到很高的準確度。

• 像ADAM這樣的優(yōu)化器對學(xué)習(xí)率的敏感度比較低，只有在它們的網(wǎng)絡(luò)具備足夠的參數(shù)時，它們才能找到比較好的解決方案。

• 在訓(xùn)練過程中，模型只會查看10000個（訓(xùn)練總數(shù)據(jù)的1/5）樣本示例。如果我們訓(xùn)練得時間再長一些，好的架構(gòu)可能會達到更高的準確度。

• 限制樣本數(shù)量對于我們學(xué)習(xí)的層的數(shù)量同樣非常重要，越深層的模型需要越多樣本。為了解決這個問題，我們還增加了一個移除突變層，使種群調(diào)節(jié)層的數(shù)量。

這個實驗的規(guī)模還不足以突出這種方法的優(yōu)勢，這些文章中使用的實驗規(guī)模更大，數(shù)據(jù)集也更復(fù)雜。

我們剛剛完成了一個簡單的進化算法，這個算法很好地詮釋了“物競天擇”的主題。我們的算法只會選擇最終勝利的解決方案，然后將其變異來產(chǎn)生更多的后代。接下來，我們需要做的就是使用更先進的方法，生成和發(fā)展方案群。以下是一些改進的建議：

• 為通用層重新使用親本的權(quán)重

• 將來自兩個潛在親本的層合并

• 架構(gòu)不一定要連續(xù)的，你可以探索層與層之間更多不一樣的聯(lián)系（分散或合并等）

• 在頂部增加額外的層，然后進行微調(diào)整。

以上內(nèi)容都是人工智能研究領(lǐng)域的一個課題。其中一個比較受歡迎的方法就是NEAT及其擴展。EAT變量使用進化算法在開發(fā)網(wǎng)絡(luò)的同時，還對網(wǎng)絡(luò)的權(quán)重進行了設(shè)置。在一個典型的強化學(xué)習(xí)場景下，代理權(quán)重的進化是非常有可能實現(xiàn)的。但是，當(x,y)輸入對可用時，梯度下降的方法則表現(xiàn)得更好。

相關(guān)文章

Evolino: Hybrid Neuroevolution / Optimal Linear Search for Sequence Learning 

Evolving Deep Neural Networks —?This is a very interesting approach of co-evolving whole networks and blocks within the network, it’s very similar to the Evolino method but for CNNs.

Large-Scale Evolution of Image Classifiers 

Convolution by Evolution

雷峰網(wǎng)特約稿件，未經(jīng)授權(quán)禁止轉(zhuǎn)載。詳情見轉(zhuǎn)載須知。