引言：當進化論遇見深度學習——自動化的黎明

在深度學習的蠻荒時代，我們是“手工匠人”。我們依靠直覺、前輩的經驗（ResNet 為什么是152層而不是153層？）、大量的試錯以及那么一點點玄學，在架構的黑暗森林中摸索前行。設計一個高性能的神經網絡（Neural Network, NN），如同在中世紀手工鍛造一把名劍，極度依賴鐵匠（研究者/工程師）的個人技藝與運氣。這個過程被戲稱為“梯度下降煉丹術”，調的是超參數，煉的是時間和GPU資源。

但隨著問題日益復雜，數據維度不斷攀升，神經網絡架構搜索（Neural Architecture Search, NAS）?應運而生，它預示著深度學習“工業革命”的到來。NAS的核心思想是：讓算法自動地發現最優的網絡架構，將人類從繁重重復的試錯中解放出來。

在眾多NAS方法中，基于進化計算（Evolutionary Computation），特別是遺傳算法（Genetic Algorithm, GA）?的方法，因其強大的全局搜索能力、對問題域假設少以及天然的可并行性，占據了重要一席。它模擬了達爾文的自然選擇理論：物競天擇，適者生存。讓網絡架構在代碼的世界里“交配”、“變異”、“競爭”，一步步進化出最適應特定任務的“強者”。

本篇，我們將深入這場自動模型設計的進化之旅。我們將使用強大的進化算法庫DEAP（Distributed Evolutionary Algorithms in Python），從零開始，構建一個屬于我們自己的NAS系統，讓遺傳算法為我們自動設計卷積神經網絡（CNN），并在經典數據集上驗證其威力。

---

第一章：遺傳算法（GA）—— 進化思想的數字涅槃

理論：生命游戲的代碼鏡像

遺傳算法并非精確的數學求解器，而是一種受生物進化啟發的元啟發式（Meta-heuristic）優化算法。它的美妙之處在于，你不需要知道“最優解”長什么樣，只需要定義一個方法來判斷一個解（個體）的好壞（適應度），剩下的，交給進化。

其核心流程是一個精妙的循環，如下圖所示，它完美復刻了自然選擇的過程：

關鍵概念剖析：

• 個體（Individual）與種群（Population）：單個解稱為一個個體（如：一個特定的網絡架構配置）。所有個體的集合稱為種群。在NAS中，一個個體就是一套完整的架構描述。

• 基因（Gene）與染色體（Chromosome）：描述個體特征的編碼串稱為染色體，其中的每一個單元稱為基因。在NAS中，這可以是層類型、濾波器數量、連接方式等。

• 適應度（Fitness）：衡量個體優劣的數值。這是驅動整個進化過程的“上帝之手”。在NAS中，它通常是模型在驗證集上的準確率（或準確率的函數）。

• 選擇（Selection）：根據適應度概率性地選擇優秀的個體作為父代，以產生后代。適應度越高，被選中的概率越大。常用策略有錦標賽選擇（Tournament Selection）、輪盤賭選擇（Roulette Wheel Selection）。

• 交叉（Crossover）：模仿有性繁殖的基因重組。隨機選擇兩個父代個體，交換它們的一部分染色體，生成新的子代個體。這是探索解空間新區域的關鍵操作。

• 變異（Mutation）：以較低的概率隨機改變個體中某個基因的值。它為種群注入新的多樣性，避免算法過早陷入局部最優解。

實戰：用DEAP實現一個簡單的遺傳算法

讓我們先拋開神經網絡，用DEAP解決一個經典問題：最大化一元函數?f(x) = x * sin(10π * x) + 1.0，其中?x?在區間?[-1, 2]。我們的目標是找到使得?f(x)?最大的?x。

步驟1：安裝DEAP

pip install deap

步驟2：搭建進化流程

# 導入必要的庫
import random  # 用于生成隨機數
import numpy as np  # 用于數學計算
from deap import base, creator, tools, algorithms  # DEAP框架的主要模塊# 定義問題類型：創建一個適應度類FitnessMax，用于最大化問題
# weights=(1.0,)表示單目標最大化問題，如果是多目標可以設置多個權重
creator.create("FitnessMax", base.Fitness, weights=(1.0,))# 創建個體類Individual，繼承自list類型，并添加fitness屬性
# 這樣每個個體都是一個列表，同時具有適應度屬性
creator.create("Individual", list, fitness=creator.FitnessMax)# 初始化工具箱，用于注冊各種遺傳算法操作
toolbox = base.Toolbox()# 注冊基因生成器：定義一個名為attr_float的函數
# 該函數使用random.uniform生成[-1, 2)范圍內的隨機浮點數
toolbox.register("attr_float", random.uniform, -1, 2)# 注冊個體生成器：定義一個名為individual的函數
# 使用initRepeat方法重復調用attr_float函數n次來創建個體
# 這里n=1表示每個個體只有一個基因（即x值）
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, n=1)# 注冊種群生成器：定義一個名為population的函數
# 使用initRepeat方法重復調用individual函數來創建包含多個個體的種群
toolbox.register("population", tools.initRepeat, list, toolbox.individual)# 定義適應度函數（目標函數），用于評估個體的適應度
def eval_function(individual):# 從個體中提取x值（個體只有一個基因）x = individual[0]# 計算目標函數值：f(x) = x * sin(10π * x) + 1.0# 使用np.sin計算正弦值，10*np.pi*x是正弦函數的參數# 返回一個元組（因為DEAP要求適應度值以元組形式返回）return (x * np.sin(10 * np.pi * x) + 1.0),# 在工具箱中注冊適應度評估函數
toolbox.register("evaluate", eval_function)# 注冊交叉操作：使用混合交叉（模擬二進制交叉）
# alpha參數控制交叉的程度，0.5表示等比例混合
toolbox.register("mate", tools.cxBlend, alpha=0.5)# 注冊變異操作：使用高斯變異
# mu=0表示變異的均值為0，sigma=0.2表示標準差為0.2
# indpb=0.2表示每個基因有20%的概率發生變異
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=0.2, indpb=0.2)# 注冊選擇操作：使用錦標賽選擇
# tournsize=3表示每次錦標賽選擇中隨機選擇3個個體進行比較
toolbox.register("select", tools.selTournament, tournsize=3)# 創建初始種群：生成包含50個個體的種群
pop = toolbox.population(n=50)# 定義統計指標，用于記錄進化過程
# 使用Statistics對象收集進化過程中的統計信息
stats = tools.Statistics(lambda ind: ind.fitness.values)  # 提取個體的適應度值# 注冊統計函數：計算適應度的平均值
stats.register("avg", np.mean)# 注冊統計函數：計算適應度的標準差
stats.register("std", np.std)# 注冊統計函數：找到適應度的最小值
stats.register("min", np.min)# 注冊統計函數：找到適應度的最大值
stats.register("max", np.max)# 運行進化算法：使用eaSimple算法執行進化過程
# pop: 初始種群
# toolbox: 包含所有注冊操作的工具箱
# cxpb=0.5: 交叉概率為50%
# mutpb=0.2: 變異概率為20%
# ngen=40: 進化40代
# stats: 統計對象，用于記錄進化過程
# halloffame=None: 不保留名人堂（最優個體歷史記錄）
# verbose=True: 打印進化過程信息
pop, logbook = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=40,stats=stats, halloffame=None, verbose=True)# 從最終種群中找到最佳個體：使用selBest函數選擇適應度最高的個體
# k=1表示只選擇最好的一個個體，[0]獲取這個個體
best_individual = tools.selBest(pop, k=1)[0]# 獲取最佳個體的適應度值
best_fitness = best_individual.fitness.values[0]# 打印最優解：格式化輸出x值和對應的函數值
# :.6f表示保留6位小數
print(f"\n最優解: x = {best_individual[0]:.6f}, f(x) = {best_fitness:.6f}")

示例輸出與解析：

gen     nevals  avg     std     min     max    
0       50      1.20518 0.511133 0.130204 1.85027
1       31      1.40997 0.305915 0.545786 1.85027
...
40      36      2.84977 0.012657 2.81321 2.85027最優解: x = 1.850547, f(x) = 2.850270

這個簡單的例子展示了GA的核心框架。eaSimple?函數實現了完整的進化循環。我們可以看到，經過40代進化，種群的平均適應度和最大適應度都在穩步提升，最終找到了一個非常接近全局最優解（理論最大值在x≈1.85處）的結果。

---

第二章：神經網絡架構的編碼藝術——基因如何描述網絡？

理論：從架構到染色體的映射

要讓遺傳算法為我們設計網絡，首要任務是將抽象的神經網絡架構（表現型, Phenotype）編碼成一串數字（基因型, Genotype）。這是NAS中最關鍵也最具挑戰性的一步。

常見的編碼方式有：

1. 直接編碼（Direct Encoding）：顯式地定義每一層的類型和參數。

   • 示例基因：[('conv', 32, 3, 1), ('pool', 'max', 2), ('conv', 64, 3, 1), ...]

   • 優點：直觀，易于解碼和理解。

   • 缺點：染色體長度固定，限制了搜索空間的靈活性。

2. 基于細胞的編碼（Cell-based Encoding）：目前主流方法。先搜索一個或幾種最優的細胞（Cell）?結構，然后通過堆疊重復的細胞來構建最終網絡（如ResNet中的殘差塊，NASNet中的Normal Cell/Reduction Cell）。

   • 優點：大大縮小了搜索空間，泛化能力強，易于遷移到不同規模的數據集。

   • 缺點：編碼和解碼過程更復雜。

本節策略：為了清晰演示，我們采用一種簡化的直接編碼。我們固定網絡的層數，但允許每一層的類型（卷積/全連接）?和超參數（濾波器數量/神經元數量）?變化。

我們的染色體將是一個列表，假設我們限定網絡最多5層，每層有兩種可能：

• 如果是卷積層（C），基因表示為?('C', filters)

• 如果是全連接層（F），基因表示為?('F', units)

例如，一個染色體?[('C', 64), ('C', 128), ('F', 256)]?代表一個3層網絡：64濾波器的卷積層 -> 128濾波器的卷積層 -> 256個神經元的全連接層。

實戰：定義架構的基因型與表現型轉換

python

# 導入必要的庫
import tensorflow as tf  # 導入TensorFlow深度學習框架
from tensorflow.keras.models import Sequential  # 導入Sequential模型類，用于按順序堆疊層
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout  # 導入各種神經網絡層
from tensorflow.keras.optimizers import Adam  # 導入Adam優化器# 定義函數：將基因型（個體）解碼為Keras模型（表現型）
# individual: 遺傳算法中的個體，表示網絡架構的基因編碼
# input_shape: 輸入數據的形狀，例如(28, 28, 1)表示MNIST圖像的尺寸
def create_network(individual, input_shape):"""將基因型（個體）解碼為Keras模型（表現型）個體格式: [('C', 32), ('C', 64), ('F', 128), ...]其中'C'表示卷積層，后面的數字表示濾波器數量'F'表示全連接層，后面的數字表示神經元數量"""# 創建一個Sequential模型，這是一種按順序堆疊層的線性模型model = Sequential()# 添加第一個卷積層：使用個體中的第一個基因來定義# individual[0][1]獲取第一個元組的第二個元素，即濾波器數量# (3, 3)表示卷積核大小# activation='relu'使用ReLU激活函數# padding='same'表示使用相同填充，保持空間維度不變# input_shape指定輸入數據的形狀model.add(Conv2D(individual[0][1], (3, 3), activation='relu', padding='same', input_shape=input_shape))# 添加最大池化層，池化窗口大小為(2, 2)，用于降低特征圖的空間維度model.add(MaxPooling2D((2, 2)))# 遍歷個體中剩余的基因（從第二個開始）for layer_type, param in individual[1:]:# 如果基因類型是'C'（卷積層）if layer_type == 'C':# 添加卷積層，使用指定數量的濾波器和3x3卷積核model.add(Conv2D(param, (3, 3), activation='relu', padding='same'))# 添加最大池化層，進一步降低特征圖維度model.add(MaxPooling2D((2, 2)))# 如果基因類型是'F'（全連接層）elif layer_type == 'F':# 在添加第一個全連接層之前，檢查是否已經存在展平層# 使用any和isinstance檢查模型中是否有Flatten層if not any(isinstance(layer, Flatten) for layer in model.layers):# 如果沒有展平層，則添加一個展平層，將多維特征圖轉換為一維向量model.add(Flatten())# 添加全連接層，使用指定數量的神經元和ReLU激活函數model.add(Dense(param, activation='relu'))# 添加Dropout層，丟棄率為0.5，用于防止過擬合# Dropout在訓練過程中隨機丟棄一部分神經元，增強模型泛化能力model.add(Dropout(0.5))# 確保在輸出層之前有展平層# 再次檢查模型中是否有展平層，防止遺漏if not any(isinstance(layer, Flatten) for layer in model.layers):# 如果沒有展平層，則添加一個model.add(Flatten())# 添加輸出層：使用10個神經元，對應10個類別（假設是十分類任務）# 使用softmax激活函數，輸出每個類別的概率分布model.add(Dense(10, activation='softmax'))# 返回構建好的模型return model# 示例：創建一個個體并解碼為模型
# 定義一個示例個體，表示網絡架構的基因編碼
# [('C', 32)表示一個具有32個濾波器的卷積層
# ('C', 64)表示一個具有64個濾波器的卷積層
# ('F', 100)表示一個具有100個神經元的全連接層
example_individual = [('C', 32), ('C', 64), ('F', 100)]# 定義輸入數據的形狀，這里使用MNIST數據集的圖像尺寸
# 28x28像素，1個顏色通道（灰度圖像）
input_shape = (28, 28, 1)# 調用create_network函數，將基因型轉換為表現型（Keras模型）
example_model = create_network(example_individual, input_shape)# 編譯模型：配置模型的學習過程
# 使用Adam優化器，學習率設為0.001
# 使用稀疏分類交叉熵作為損失函數，適用于整數標簽的分類問題
# 設置評估指標為準確率
example_model.compile(optimizer=Adam(learning_rate=0.001),loss='sparse_categorical_crossentropy',metrics=['accuracy'])# 打印模型的結構信息，包括每層的類型、輸出形狀和參數數量
example_model.summary()# 注意：在實際使用中，還需要準備訓練數據和標簽
# 例如：使用MNIST數據集
# (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
# 然后對數據進行預處理（歸一化、重塑形狀等）
# 最后使用model.fit()方法訓練模型

這個?create_network?函數就是我們連接遺傳算法世界和深度學習世界的橋梁。它將一個編碼好的染色體，實例化成了一個可以編譯、訓練、評估的Keras模型。

---

第三章：定義進化之力——適應度、交叉與變異

理論：NAS中的進化算子設計

在NAS的語境下，我們需要重新定義GA中的三個核心算子：

1. 適應度函數（Fitness Function）：

   • 任務：量化一個神經網絡架構的好壞。

   • 實現：通常是在一個驗證集（Validation Set）?上計算準確率、F1分數等指標。為了節省計算資源，有時會使用低保真度評估（Low-Fidelity Evaluation），如在子數據集上訓練、訓練更少的輪數（Epoch）、使用權重共享等。

   • 挑戰：計算成本極高！評估一個個體可能需要幾分鐘到幾小時。

2. 交叉（Crossover）：

   • 任務：交換兩個父代架構（個體）的“優秀部件”以產生子代。

   • 實現：對于直接編碼，可以隨機選擇切點進行交換。例如，父代A?[A1, A2, A3, A4]?和父代B?[B1, B2, B3, B4]?在位置2交叉，產生子代?[A1, A2, B3, B4]?和?[B1, B2, A3, A4]。

3. 變異（Mutation）：

   • 任務：隨機微調架構，引入多樣性。

   • 實現：以一定概率隨機改變基因。例如：

     • 改變一層濾波器的數量（如從64變為128）。

     • 改變層的類型（如將卷積層變為全連接層，需注意維度兼容）。

     • 添加或刪除一層（如果編碼支持可變長度）。

實戰：實現NAS的進化算子

# 導入必要的庫
import random  # 用于生成隨機數和隨機選擇
from deap import tools  # 導入DEAP框架的工具模塊
import tensorflow as tf  # 導入TensorFlow深度學習框架
from tensorflow.keras.optimizers import Adam  # 導入Adam優化器
import gc  # 導入垃圾回收模塊，用于釋放內存# 假設已經定義了create_network函數和加載了MNIST數據
# 這里我們假設x_train, y_train, x_val, y_val已經定義# 1. 注冊個體和種群創建方法（基于我們的編碼）
# 定義網絡層數，固定搜索5層網絡
NUM_LAYERS = 5# 定義函數：隨機生成一層網絡結構
def random_layer():"""隨機生成一層網絡結構"""# 隨機選擇層類型：卷積層('C')或全連接層('F')layer_type = random.choice(['C', 'F'])# 根據層類型選擇不同的參數范圍if layer_type == 'C':# 卷積層的濾波器數量在[16, 32, 64, 128]中選擇param = random.choice([16, 32, 64, 128])else:# 全連接層的神經元數量在[64, 128, 256, 512]中選擇param = random.choice([64, 128, 256, 512])# 返回層類型和參數的元組return (layer_type, param)# 在工具箱中注冊層生成器
# attr_layer函數使用random_layer生成隨機層
toolbox.register("attr_layer", random_layer)# 注冊個體生成器：使用initRepeat方法重復調用attr_layer函數NUM_LAYERS次
# 創建一個包含NUM_LAYERS個層的個體
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_layer, n=NUM_LAYERS)# 注冊種群生成器：使用initRepeat方法重復調用individual函數創建多個個體
toolbox.register("population", tools.initRepeat, list, toolbox.individual)# 2. 定義適應度評估函數（這是最耗時的部分）
def evaluate_individual(individual):"""評估一個個體（網絡架構）的適應度返回: (準確率, )"""# 設置訓練參數以減少計算時間EPOCHS = 5  # 訓練輪數，減少以加速搜索BATCH_SIZE = 256  # 批處理大小# 解碼個體為Keras模型# 使用之前定義的create_network函數將基因型轉換為表現型model = create_network(individual, (28, 28, 1))# 編譯模型：配置優化器、損失函數和評估指標model.compile(optimizer=Adam(learning_rate=0.001),loss='sparse_categorical_crossentropy',metrics=['accuracy'])# 訓練模型# 使用訓練數據進行訓練，驗證集用于計算適應度# verbose=0表示不輸出訓練過程信息，減少輸出干擾history = model.fit(x_train, y_train,batch_size=BATCH_SIZE,epochs=EPOCHS,validation_data=(x_val, y_val),verbose=0  # 不輸出訓練過程)# 取最后一個epoch的驗證準確率作為適應度值# 使用驗證集準確率而不是訓練集準確率，以避免過擬合accuracy = history.history['val_accuracy'][-1]# 非常重要！清理模型和釋放GPU內存# 刪除模型引用del model# 清除Keras會話，釋放GPU內存tf.keras.backend.clear_session()# 調用垃圾回收，確保內存被釋放gc.collect()# 返回適應度值（準確率），注意返回元組格式return (accuracy, )# 在工具箱中注冊評估函數
toolbox.register("evaluate", evaluate_individual)# 3. 定義交叉算子（單點交叉）
def crossover_individuals(ind1, ind2):"""對兩個個體進行單點交叉"""# 確保個體長度相同，取較小長度size = min(len(ind1), len(ind2))# 隨機選擇交叉點（從1到size-1，確保不是端點）cxpoint = random.randint(1, size - 1)# 交換兩個個體從交叉點到末尾的部分ind1[cxpoint:], ind2[cxpoint:] = ind2[cxpoint:], ind1[cxpoint:]# 返回交叉后的兩個個體return ind1, ind2# 在工具箱中注冊交叉操作
toolbox.register("mate", crossover_individuals)# 4. 定義變異算子
def mutate_individual(individual, indpb=0.2):"""以概率indpb變異個體的每一個基因"""# 遍歷個體的每一個基因（層）for i in range(len(individual)):# 以indpb概率決定是否變異該基因if random.random() < indpb:# 如果決定變異，則用random_layer生成新的層替換原有層individual[i] = random_layer()# 返回變異后的個體（注意返回元組）return individual,# 在工具箱中注冊變異操作，設置默認變異概率為0.2
toolbox.register("mutate", mutate_individual, indpb=0.2)# 5. 選擇算子（沿用錦標賽選擇）
# 注冊選擇操作：使用錦標賽選擇， tournament大小為3
toolbox.register("select", tools.selTournament, tournsize=3)# 注意：在實際應用中，還需要定義進化算法的主循環
# 通常包括以下步驟：
# 1. 創建初始種群
# 2. 評估初始種群
# 3. 進行多代進化：
#     a. 選擇父代
#     b. 應用交叉和變異產生子代
#     c. 評估子代
#     d. 選擇下一代種群
# 4. 輸出最優個體和其性能# 示例：創建和評估一個隨機個體
if __name__ == "__main__":# 創建一個隨機個體ind = toolbox.individual()print("隨機個體:", ind)# 評估個體（需要確保MNIST數據已加載）# 注意：在實際運行前，需要先加載MNIST數據# (x_train, y_train), (x_val, y_val) = load_mnist_data()# fitness = evaluate_individual(ind)# print("個體適應度:", fitness)

關鍵點說明：

• evaluate_individual?是性能瓶頸。這里我們只訓練5個Epoch來粗略估計架構潛力，這是一種常見的加速策略。

• 每次評估后清理內存至關重要，否則長時間運行后內存/顯存會耗盡。

• 交叉和變異操作要確保產生的個體是有效的（例如，全連接層之后可能不適合再接卷積層，我們的簡單編碼暫未處理此問題，更復雜的編碼需要設計約束）。

---

第四章：運行進化NAS——釋放算力，孕育架構

理論：并行進化與資源管理

現在，所有部件都已就位。但在按下“開始”按鈕前，必須考慮兩個現實問題：

1. 并行計算（Parallelism）：評估成百上千個個體是令人尷尬的并行（Embarrassingly Parallel）?任務，因為每個個體的評估是獨立的。DEAP支持多種并行后端（如multiprocessing）。

2. 早停（Early Stopping）：如果某個架構在訓練初期表現就極其糟糕，可以提前終止訓練以節省資源。

實戰：啟動最終的架構搜索

我們將使用multiprocessing來并行評估個體，并運行完整進化流程。

# 導入必要的庫
import multiprocessing  # 用于并行計算，加速適應度評估
import numpy as np  # 用于數學計算和統計
from deap import algorithms  # 導入DEAP的進化算法實現
import random  # 用于隨機數生成
import tensorflow as tf  # 導入TensorFlow深度學習框架
from tensorflow.keras.optimizers import Adam  # 導入Adam優化器# 假設前面的代碼已經定義了toolbox、create_network函數
# 以及加載了MNIST數據 (x_train, y_train, x_val, y_val, x_test, y_test)# 定義主函數，包含完整的神經架構搜索流程
def main():# 設置隨機種子保證實驗可重復性# 使用相同的種子可以復現實驗結果random.seed(42)np.random.seed(42)# 設置TensorFlow的隨機種子tf.random.set_seed(42)# 創建初始種群pop_size = 20  # 種群大小，即每代包含的個體數量pop = toolbox.population(n=pop_size)  # 使用工具箱創建初始種群# 設置并行評估，加速適應度計算# 使用多進程池，進程數為CPU核心數減1（保留一個核心給系統）pool = multiprocessing.Pool(processes=multiprocessing.cpu_count()-1)# 注冊映射函數，使工具箱可以使用多進程并行評估個體toolbox.register("map", pool.map)# 定義統計和日志記錄# 創建名人堂(HallOfFame)，保存歷代最好的3個個體hof = tools.HallOfFame(3)# 創建統計對象，用于記錄進化過程中的統計信息stats = tools.Statistics(lambda ind: ind.fitness.values)  # 提取個體的適應度值# 注冊統計函數：計算適應度的平均值stats.register("avg", np.mean)# 注冊統計函數：計算適應度的標準差stats.register("std", np.std)# 注冊統計函數：找到適應度的最小值stats.register("min", np.min)# 注冊統計函數：找到適應度的最大值stats.register("max", np.max)# 運行進化算法 (代數=10)# 使用eaSimple算法執行進化過程# pop: 初始種群# toolbox: 包含所有注冊操作的工具箱# cxpb=0.7: 交叉概率為70%# mutpb=0.3: 變異概率為30%# ngen=10: 進化10代# stats: 統計對象，用于記錄進化過程# halloffame: 名人堂對象，保存歷代最優個體# verbose=True: 打印進化過程信息pop, logbook = algorithms.eaSimple(pop, toolbox, cxpb=0.7, mutpb=0.3, ngen=10,stats=stats, halloffame=hof, verbose=True)# 關閉并行池，釋放資源pool.close()  # 阻止任何更多任務被提交到池pool.join()   # 等待所有工作進程退出# 輸出最終結果print("\n=== 進化結束 ===")print("歷代最佳個體 (Hall of Fame):")# 遍歷名人堂中的所有個體for i, ind in enumerate(hof):# 打印每個個體的排名、基因型和適應度（驗證準確率）print(f"Rank {i+1}: {ind}, Fitness (Val Accuracy): {ind.fitness.values[0]:.4f}")# 找到絕對最好的個體（名人堂中的第一個個體）best_individual = hof[0]print(f"\n*** 找到的最佳架構: {best_individual} ***")print(f"*** 其驗證準確率: {best_individual.fitness.values[0]:.4f} ***")# 完整訓練這個最佳架構并評估在測試集上的性能print("\n--- 開始完整訓練最佳架構 ---")# 將最佳個體解碼為Keras模型best_model = create_network(best_individual, (28, 28, 1))# 編譯模型best_model.compile(optimizer=Adam(learning_rate=0.001),loss='sparse_categorical_crossentropy',metrics=['accuracy'])# 使用更多輪次（50輪）完整訓練模型# 使用訓練數據和驗證數據，verbose=1顯示訓練進度history = best_model.fit(x_train, y_train,batch_size=256,epochs=50,validation_data=(x_val, y_val),verbose=1)# 在測試集上評估模型性能test_loss, test_acc = best_model.evaluate(x_test, y_test, verbose=0)print(f"\n!!! 最佳架構在測試集上的最終性能: {test_acc:.4f} !!!")# 返回種群、日志和名人堂，便于后續分析return pop, logbook, hof# 主程序入口
if __name__ == "__main__":# 確保在Windows下使用multiprocessing的正確方式# 在Windows上，多進程需要這個保護語句multiprocessing.freeze_support()# 調用主函數main()# 注意：在實際運行前，需要確保以下內容已定義或加載：
# 1. 工具箱(toolbox)的注冊，包括個體創建、評估、交叉、變異和選擇操作
# 2. create_network函數，用于將基因型轉換為神經網絡模型
# 3. MNIST數據集已加載并預處理為(x_train, y_train), (x_val, y_val), (x_test, y_test)
# 4. 可能需要調整一些參數，如種群大小、進化代數、訓練輪數等，以適應具體硬件和時間限制# 運行過程解析：
# 程序會輸出每一代的統計信息，包括最大適應度、平均適應度等
# 隨著代數增加，通常會看到適應度逐漸提升的趨勢
# 名人堂(HallOfFame)會保存歷史上最好的3個架構
# 最終，程序會選出冠軍架構，并用更多的訓練輪次重新訓練它
# 最后在測試集上評估性能，這是衡量NAS成功與否的最終標準

運行過程解析：
程序會輸出每一代的統計信息。你會看到max（最佳適應度）和avg（平均適應度）隨著代數增加而逐漸上升的趨勢。HallOfFame對象會一直保存歷史上最好的3個架構。最終，我們會選出冠軍架構，并用更多的訓練輪次（如50輪）重新訓練它，并在從未見過的測試集上報告其最終性能。這才是衡量NAS成功與否的黃金標準。

---

第五章：超越與展望——NAS的前沿與挑戰

我們的簡單實驗只是NAS世界的驚鴻一瞥。真正的工業級和研究級NAS要復雜得多：

• 更高效的搜索策略：

  • 權重共享（Weight Sharing）：如ENAS。所有架構子模型在一個超網（Supernet）中共享權重，評估個體只需前向傳播一次，極大加速適應度評估。

  • 基于性能預測器（Performance Predictor）：訓練一個回歸模型，根據架構編碼直接預測其性能，避免實際訓練。

  • 多目標優化：不僅優化精度，還同時優化參數量、FLOPs、延遲等（weights=(-1.0, 0.5)?表示最小化參數量，最大化精度）。

• 更復雜的搜索空間：

  • 微分架構搜索（DARTS）：將離散的架構選擇松弛為連續可微的優化問題，可用梯度下降高效求解。

  • 層次化空間：同時搜索微觀細胞結構和宏觀網絡骨架。

• 挑戰：

  • 計算成本：盡管有各種加速技術，搜索一個好的架構仍然需要巨大的算力。

  • 可復現性：隨機性的影響很大，兩次搜索可能得到不同的結果。

  • 泛化能力：在一個數據集上搜到的最優架構，能否很好地遷移到其他數據集？

盡管挑戰重重，自動化機器學習（AutoML）和NAS無疑是未來的重要方向，它們正在降低深度學習應用的門檻，并將專家的精力從繁瑣的調參中解放出來，投入到更富創造性的工作中。

---

結論：從手工鍛造到蒸汽時代

我們完成了一次奇妙的旅程：從遺傳算法的基本概念出發，親手將神經網絡的架構編碼成染色體，定義了進化所需的選擇、交叉、變異算子，最終利用DEAP庫和并行計算，成功地在架構的海洋中自動搜尋到了 promising 的設計。

這就像是從手工鍛造冷兵器時代，邁入了利用蒸汽機（進化算法）進行機械化生產的工業時代萌芽。雖然我們的系統還很簡單，但它清晰地展示了自動化設計的核心思想與巨大潛力。

現在，你擁有了這把鑰匙。你可以嘗試改進它：設計更靈活的編碼方式、加入更復雜的進化算子、嘗試不同的搜索空間、或者將其應用到你自己領域的實際問題中。進化的大門已經敞開，無限的架構可能正等待你的算法去發現。