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

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

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

問題設(shè)定

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

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

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

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

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

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

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

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

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

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

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

進(jìn)化算法

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

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

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

“跨界”：“跨界”也稱“交叉跨界”，指的是兩組或兩組以上親本交叉混合，產(chǎn)生后代。“交叉跨界”高度依賴于問題結(jié)構(gòu)的方式。常見的方法是用一個(gè)項(xiàng)目列表（一般是數(shù)值）對(duì)親本進(jìn)行描述，然后從親本中挑選任意部分來生成新的基因組合。

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

實(shí)施啟用

“進(jìn)化算法”的實(shí)施啟用使用了PyTorch來建立代理，這個(gè)代理將會(huì)探索用于完成簡(jiǎn)單分類任務(wù)的DNNs。這個(gè)實(shí)驗(yàn)使用的是MNIST，因?yàn)樗∏铱?，即使在CPU上也能完成訓(xùn)練。我們將建立一組DNN模型，并將其發(fā)展進(jìn)化為N個(gè)步驟。

我們所講的“進(jìn)化”主題實(shí)際上就是“物競(jìng)天擇”的實(shí)施，完整的高水平“進(jì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 

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

基本的構(gòu)件

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

# 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)定義了模型的空間。接著我們還需要建立三個(gè)基本功能：

隨機(jī)選擇一個(gè)網(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)我獾貙?duì)層數(shù)量和每一層的參數(shù)進(jìn)行采樣，樣本值會(huì)在預(yù)先定義好的范圍邊緣內(nèi)出現(xiàn)下降。在初始化一個(gè)參數(shù)的同時(shí)，我們還會(huì)產(chǎn)生一個(gè)任意的參數(shù)id。現(xiàn)在它還不能使用，但我們可以追蹤所有的層。當(dāng)一個(gè)新的模型發(fā)生突變時(shí)，舊的層會(huì)進(jìn)行微調(diào)，同時(shí)僅對(duì)發(fā)生突變的層進(jìn)行初始化。這樣的做法應(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 

每一個(gè)網(wǎng)絡(luò)元素都存在變異的可能性，每一次變異都將重新采樣參數(shù)空間，進(jìn)而使參數(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 

上面的類別將會(huì)實(shí)例化模型的“基因組”。

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

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))  

“進(jìn)化算法”看起來非常簡(jiǎn)單，對(duì)嗎？沒錯(cuò)！這個(gè)算法可以非常成功，尤其是當(dāng)你為個(gè)體定義了好的變異或跨界功能時(shí)。

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

運(yùn)行代碼

按照上述步驟操作運(yù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')) 

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

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

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

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

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

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

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

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

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

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

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

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

• 將來自兩個(gè)潛在親本的層合并

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

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

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

本文轉(zhuǎn)自雷鋒網(wǎng)，如需轉(zhuǎn)載請(qǐng)至雷鋒網(wǎng)官網(wǎng)申請(qǐng)授權(quán)。