进化算法NAS：物竞天择选架构

可视化演示

通过种群进化选择、变异交叉操作、适应度收敛曲线三个模式，展示进化算法如何通过物竞天择机制搜索最优神经网络架构。

进化算法原理

三十年前老陈的果园里长着上百棵野苹果树，果子又小又涩。他没有一棵棵去嫁接改良，而是定下一条祖训：每年把最甜的几棵留下做母树，其余砍掉当柴火，来年只种这些母树的后代。几年过去，果园整体甜度明显提升——甜味就是选育的信号，满园果树就是候选的种群。

进化算法做神经架构搜索（NAS），把老陈的苹果园搬进了计算机：一个「种群」里放着若干候选网络结构，每个结构就是一棵果树；「适应度函数」负责给结构打分，相当于老陈尝一口苹果判断甜度；每一轮「进化」都按分数选父母、生后代、加变异，生成新的种群，如此代代相传。

相比随机搜索或网格搜索，进化算法的核心优势是有选择压力：好结构被选作父母的概率更高，后代在好结构附近探索，搜索逐步聚焦到高分区。适应度函数通常同时看精度和代价，比如：

$$\displaystyle F(a_i) = \text{Acc}(a_i) - \lambda \cdot C(a_i)$$

1. 候选结构 \(a_i\)：种群里的第 \(i\) 个网络结构，类比第 \(i\) 棵果树的全部性状。

$$\displaystyle a_i \in \mathcal{P}_{t}$$

2. 验证准确率 \(\text{Acc}(a_i)\)：该结构在验证集上训练后的正确率，类比果实甜度评分。

$$\displaystyle \text{Acc}(a_i) = \frac{\text{预测正确的样本数}}{\text{总样本数}}$$

3. 代价项 \(C(a_i)\)：参数量或推理耗时，类比果树占用的土地和肥料。

$$\displaystyle C(a_i) = \text{Params}(a_i) \ \text{或} \ \text{Latency}(a_i)$$

4. 权衡系数 \(\lambda\)：控制「精度」和「代价」的权重，\(\lambda\) 越大越偏爱轻量结构。

$$\displaystyle F(a_i) = \text{Acc}(a_i) - \lambda \cdot C(a_i)$$

老陈的果园证明了「简单规则 + 迭代」的威力。进化 NAS 同样不预设最优答案，只设好打分标准和变异翻新机制，剩下的交给一代代「物竞天择」。理解了种群与适应度，你就拿到了通往后续所有环节的钥匙。

搜索空间设计

老陈每年播种前要做一个决定：果园里可以出现哪些品种？他圈定一份「候选菜单」——红富士、嘎啦、青苹果，砧木用矮化或乔化，树形用开心形或纺锤形。菜单之外的新品种，老陈再喜欢也种不出来，因为种子库里没有。这个「菜单」决定了他能在多大范围内改良果园。

NAS 里的「菜单」叫搜索空间。它定义了进化算法能搜索哪些网络结构：网络分成若干层或单元（cell），每个位置从候选算子集合 \(\mathcal{O}\) 里选一个算子（如 3×3 卷积、5×5 卷积、跳跃连接、池化），再决定层间连接方式。你圈定的算子越多、层数越多，搜索空间指数膨胀，但同时也给进化留出更多可能性。

搜索空间太大，进化会找不到北；太小，则可能装不下高性能结构。工程上常用单元式搜索：只搜索一个基础单元的结构，再堆叠若干次组成完整网络，把指数级空间压缩到可管理的规模。编码方式随之产生：

$$\displaystyle A = \left(o^{(1)}, o^{(2)}, \ldots, o^{(L)}\right), \quad o^{(i)} \in \mathcal{O}$$

1. 长度 \(L\) 的编码 \(A\)：一个候选网络被表示为 \(L\) 个位置的序列，类比一株果树的「性状清单」。

$$\displaystyle A = \left(o^{(1)}, o^{(2)}, \ldots, o^{(L)}\right)$$

2. 候选算子集合 \(\mathcal{O}\)：每个位置可选的算子类型，类比候选品种菜单。

$$\displaystyle \mathcal{O} = \{\text{conv3×3},\ \text{conv5×5},\ \text{pool},\ \text{skip}\}$$

3. 第 \(i\) 层算子 \(o^{(i)}\)：编码第 \(i\) 个位置的选择，决定该层做什么运算。

$$\displaystyle o^{(i)} \in \mathcal{O}, \quad i = 1, 2, \ldots, L$$

4. 搜索空间规模 \(|\mathcal{S}|\)：\(L\) 层每层有 \(|\mathcal{O}|\) 种选择，总量为 \(|\mathcal{O}|^L\)。

$$\displaystyle |\mathcal{S}| = |\mathcal{O}|^{L}$$

老陈的菜单越丰富，果园的「天花板」越高，但管理成本也越高。NAS 同理：搜索空间设计是进化搜索的边界，编码的好坏直接决定变异和交叉能不能产生有效的后代。先问自己「允许出现什么样的网络」，再问「如何找到最好的那个」。

变异与交叉

老陈的果园能不断变甜，靠两个动作：一是把「耐寒砧木」和「高糖接穗」嫁接，让一棵树同时拥有两家优点——这是「交叉」；二是有时一场倒春寒后，某个枝条的芽突然变异，结出带玫瑰香气的果子——这是「变异」。老陈从不觉得怪芽是麻烦，反而把它当成免费的品种试验。

NAS 里的交叉，是把两个父本结构的编码按某个位置切开再拼接：前半段取自父本 A，后半段取自母本 B，生成一个同时继承两段特征的新结构。变异则是随机改动编码的某一位——把某层的卷积换成池化，或把 3×3 换成 5×5——从而在局部引入全新变量。交叉负责「组合已有优点」，变异负责「探索未知区域」。

单点交叉是最简单的形式，设交叉点为 \(k\)，子代 \(C\) 的前 \(k\) 位来自父本 A、后 \(L-k\) 位来自母本 B：

$$\displaystyle C = \left(A_1, \ldots, A_k, B_{k+1}, \ldots, B_L\right)$$

1. 父本 \(A\) 与母本 \(B\)：从父代种群中选出的两个优秀个体。

$$\displaystyle A = (A_1, \ldots, A_L), \quad B = (B_1, \ldots, B_L)$$

2. 交叉点 \(k\)：随机选一个位置，把编码切成两段。

$$\displaystyle 1 \le k \le L - 1$$

3. 子代编码 \(C\)：前 \(k\) 位来自 \(A\)，后 \(L-k\) 位来自 \(B\)。

$$\displaystyle C = \left(A_1, \ldots, A_k, B_{k+1}, \ldots, B_L\right)$$

4. 变异运算：对 \(C\) 的每一位，以概率 \(p_m\) 从 \(\mathcal{O}\) 中重新选择算子，得到最终子代 \(C'\)。

$$\displaystyle C'_i = \begin{cases} o \sim \mathcal{O}, & \text{若} \ r < p_m \\ C_i, & \text{否则} \end{cases}$$

嫁接和变异，一个守成、一个拓新，正是进化搜索中「探索与利用」的平衡。老陈从不只嫁接（否则果园会千篇一律），也不只等变异（否则找不到稳定方向）。设计进化算法时，同样要拿捏交叉与变异的配比——它们是驱动种群前进的两个轮子。

选择策略

果园最关键的环节，是决定「让谁生孩子」。老陈年轻时用轮盘赌：把每个品种的甜度画成转盘上的扇形面积，甜度越高扇区越大，指针停下指向谁就选谁——甜树被选中的次数自然多，但酸树偶尔也能入选，保住多样性。后来他嫌转盘太随机，改用锦标赛：随手拉出三棵树，当场比甜，最甜的那棵胜出。

选择策略决定了进化方向与多样性的平衡。NAS 中常见两类：轮盘赌选择（适应度比例选择）按适应度占比给出被选概率；锦标赛选择随机抽 \(k\) 个个体、留下其中适应度最高者，实现简单且不受适应度尺度影响。如果只留最好的，种群会迅速单一化，容易困在局部最优；如果完全不筛，进化就退化成随机搜索。

轮盘赌选择概率：

$$\displaystyle P(a_i) = \frac{F(a_i)}{\sum_{j=1}^{N} F(a_j)}$$

1. 个体 \(a_i\) 的适应度 \(F(a_i)\)：打分环节给出的分数，类比甜度值。

$$\displaystyle F(a_i)$$

2. 分母总适应度：把当代所有 \(N\) 个个体的分数相加，作为归一化基准。

$$\displaystyle \sum_{j=1}^{N} F(a_j)$$

3. 选中概率 \(P(a_i)\)：分数占比越高，被选为父母的概率越大，所有个体概率之和为 1。

$$\displaystyle P(a_i) \in [0, 1], \quad \sum_{i=1}^{N} P(a_i) = 1$$

4. 精英保留：将分数最高的 \(E\) 个个体直接带入下一代，保证不退化。

$$\displaystyle \mathcal{P}_{t+1} \supseteq \{ a \in \mathcal{P}_t \mid \text{rank}(a) \le E \}$$

老陈后来把两招组合用：先用锦标赛快速选出好父母，再额外留几棵「镇园母树」——这就是精英保留。选择不是简单「杀掉差的」，而是一套分配生育权的策略，它决定种群往哪个方向演化、又保住多少多样性。

适应度评估

老陈最头疼的不是选种，而是试吃。一棵树要长四五年才结果，等尝完这一批，种苗商的新品都换代了。于是他发明了「小苗试尝」：把候选苗种在小花盆里，施速效肥，45 天就让它们结出小球果，榨汁试个大概方向；对于那些去年试过同款砧木的，他干脆查旧账本推算。评估慢了，果园就追不上市场。

NAS 里每评估一个候选结构，都要从头训练一个神经网络，动辄数小时乃至数天，成为进化搜索最大的算力瓶颈。对应「小苗试尝」的思路有三招：一是减少训练轮次（早停），用少量轮次的学习趋势外推最终精度；二是用代理模型拟合已评测样本，预测未知结构的得分；三是权值共享（One-Shot/超网），所有候选共享同一套超网权重，评估时只微调几轮。

权值共享下的代理评估可以写成：

$$\displaystyle \hat{F}(a) = -\,\mathcal{L}_{\text{val}}\left(a;\, \theta_{\text{shared}}\right)$$

1. 共享权重 \(\theta_{\text{shared}}\)：一个包含所有算子的超网，训练后各候选结构复用同一套参数。

$$\displaystyle \theta_{\text{shared}} = \text{SuperNet}(\cdot)$$

2. 验证损失 \(\mathcal{L}_{\text{val}}\)：候选结构在验证集上算出的损失，越小说明结构越好。

$$\displaystyle \mathcal{L}_{\text{val}}\left(a;\, \theta_{\text{shared}}\right)$$

3. 取负号：损失负值越大代表损失越小，对应的适应度越高。

$$\displaystyle \hat{F}(a) = -\,\mathcal{L}_{\text{val}}\left(a;\, \theta_{\text{shared}}\right)$$

4. 代理评估 \(\hat{F}\)：用廉价近似替代完整训练，显著提升每代可评估的个体数量。

$$\displaystyle \hat{F}(a) \approx F(a), \quad \text{成本} \ll \text{全量训练}$$

「小苗试尝」让老陈每年能试几百个新组合，果园迭代速度快了一倍。评估成本直接决定进化算法「每代能跑多少个体、能跑多少代」——把每一口尝果的钱省下来，才能让物竞天择在可控预算内真正跑起来。

流程控制参数

老陈不会让果园永远进化下去。他每年在账本上记下当年最甜果实的评分，若连续三年几乎没有提升，就把全园主力品种定下来，专心卖果。他还发现种群规模不能太小——只有十几棵树时近亲授粉，果子越种越小；也不能太大——上千棵树的试吃成本他根本付不起。

进化 NAS 的流程控制，就是回答三个问题：种群多大？进化多少代？何时收手？种群规模 \(N\) 决定每代的探索广度与评估成本；进化代数 \(G_{\max}\) 是总预算上限；更聪明的是动态收敛判定——当最优适应度多代几乎不变时提前终止，把省下的算力留给下一轮搜索或正式训练。

常见的收敛判据是相对提升阈值：

$$\displaystyle \frac{\left| f_{\text{best}}^{(t)} - f_{\text{best}}^{(t-\tau)} \right|}{f_{\text{best}}^{(t-\tau)}} < \epsilon$$

1. 最优适应度 \(f_{\text{best}}^{(t)}\)：第 \(t\) 代适应度最高的个体得分，类比当年果园最甜果实的评分。

$$\displaystyle f_{\text{best}}^{(t)} = \max_{a \in \mathcal{P}_t} F(a)$$

2. 观察窗口 \(\tau\)：向前回看多少代，通常取 5~10 代。

$$\displaystyle t - \tau \quad (\text{如} \ \tau = 5)$$

3. 相对提升量：窗口首尾最优分数的差再除以窗口起点分数，消除量纲影响。

$$\displaystyle \frac{\left| f_{\text{best}}^{(t)} - f_{\text{best}}^{(t-\tau)} \right|}{f_{\text{best}}^{(t-\tau)}}$$

4. 阈值判定：相对提升小于 \(\epsilon\)（如 0.01）即触发提前终止。

$$\displaystyle < \epsilon \quad \Longrightarrow \quad \text{stop}$$

老陈的账本让他知道「该收手时就收手」。进化 NAS 同理：种群规模、代数上限、收敛阈值三者构成搜索的「预算表」。定得太松，烧光 GPU 预算还收不到好结构；定得太紧，还没进化几代就被迫停止。预算意识，是走向工程落地的必修课。

工程应用落地

果园成熟后，老陈开始对接不同客户：果汁厂要高糖低酸的品种，家庭庭院要矮化省地且结得快的品种，出口商要耐储存的硬果。同一套选育方法，换一套筛选标准，就能定向培育出不同市场的「最优品种」。老陈感慨：不是苹果变厉害了，而是我学会了按目标调评分标准。

进化 NAS 在工程中同样「按目标调标准」。在移动端，开发者把推理时延和模型体积写进适应度函数，进化出的网络既准又轻，可直接部署；在模型压缩场景，用进化搜索为大模型寻找紧凑结构，替换冗余层；在自动化平台，进化 NAS 被封装成「架构自动设计」服务，非专家用户只需提交数据集和约束，系统就自动交付候选模型。多目标适应度是落地的关键：

$$\displaystyle F(a) = \text{Acc}(a) - \lambda_1 \cdot \text{FLOPs}(a) - \lambda_2 \cdot \text{Latency}(a)$$

1. 精度项 \(\text{Acc}(a)\)：模型在验证集上的准确率，任何场景都不可放弃的底线指标。

$$\displaystyle \text{Acc}(a)$$

2. 算力项 \(\text{FLOPs}(a)\)：浮点运算量，衡量模型计算的绝对规模。

$$\displaystyle \text{FLOPs}(a)$$

3. 时延项 \(\text{Latency}(a)\)：端侧推理一次所需的毫秒数，直接决定用户体感。

$$\displaystyle \text{Latency}(a)$$

4. 权重 \(\lambda_1, \lambda_2\)：按部署场景调节，轻量优先时调大，精度优先时调小。

$$\displaystyle F(a) = \text{Acc}(a) - \lambda_1 \cdot \text{FLOPs}(a) - \lambda_2 \cdot \text{Latency}(a)$$

从山脚野林到按需供果的果园，老陈验证的不仅是一种选育法，更是一套「先定目标、再让种群自己找出路」的工程哲学。进化 NAS 的落地，本质就是为不同场景定制合适的适应度函数和搜索预算，然后放心地把「找结构」这件事交给进化——这正是自动化设计时代的典型工作方式。

AI 应用场景

Python 演示

import randomimport math  def simulated_fitness(arch, noise=0.01):    """演示用代理评分：模拟训练后得到的验证准确率。"""    depth, width, kernel = arch    score = 0.92 * math.exp(-((depth - 3) ** 2 + (width - 4) ** 2) / 12.0)    score += 0.03 * math.sin(kernel)    return max(0.0, min(1.0, score + random.uniform(-noise, noise)))  def crossover(a, b):    """单点交叉：前段取父本 a，后段取母本 b。"""    return (a[0], b[1], a[2])  def mutate(arch, p=0.3, max_depth=5, max_width=6):    """以概率 p 随机改动一个维度，模拟变异。"""    depth, width, kernel = list(arch)    if random.random() < p:        depth = max(1, min(max_depth, depth + random.choice([-1, 1])))    if random.random() < p:        width = max(1, min(max_width, width + random.choice([-1, 1])))    if random.random() < p:        kernel = random.choice([1, 3, 5])    return (depth, width, kernel)  def evolution_search(pop_size=16, generations=50, top_k=4):    """进化循环：评估 -> 选择精英 -> 交叉 -> 变异。"""    pop = [(random.randint(1, 5), random.randint(1, 6), random.choice([1, 3, 5]))           for _ in range(pop_size)]    best = None    for gen in range(generations):        scored = sorted(((simulated_fitness(p), p) for p in pop),                        key=lambda x: x[0], reverse=True)        best = scored[0]        elites = [p for _, p in scored[:top_k]]        pool = [p for _, p in scored[:pop_size // 2]]        pop = list(elites)        while len(pop) < pop_size:            a = random.choice(pool)            b = random.choice(pool)            child = mutate(crossover(a, b))            pop.append(child)        if (gen + 1) % 10 == 0:            print("Generation %d best: %s  fitness=%.4f" % (gen + 1, best[1], best[0]))    return best  if __name__ == "__main__":    best_arch = evolution_search()    print("Final best architecture:", best_arch[1], " fitness:", round(best_arch[0], 4))

1. scored = sorted(((simulated_fitness(p), p) for p in pop), key=lambda x: x[0], reverse=True)给每个个体打分并按分数降序排列，适应度高的排前面。
2. best = scored[0]记录当代最优个体，供最后输出和对比。
3. elites = [p for _, p in scored[:top_k]]精英保留：排名前 top_k 的个体直接进入下一代，防止最优解丢失。
4. pool = [p for _, p in scored[:pop_size // 2]]从排名前一半的个体里随机抽父母，模拟锦标赛的轻量版。
5. child = mutate(crossover(a, b))先用交叉组合两个父母的编码片段，再用变异加入随机扰动，生成子代。
6. while len(pop) < pop_size:用子代逐个填充种群，直到恢复设定的种群规模，完成一代更新。

常见误区

面试题