协同进化与整体进化搜索在半监督表格分类中的对比研究

1. 项目概述：当进化算法遇上“半饥半饱”的表格数据

在数据科学和机器学习的日常里，我们最常打交道的，可能就是那一张张规整的表格数据了。从金融风控的客户信息表，到医疗诊断的化验指标单，再到工业生产的传感器日志，表格无处不在。然而，现实往往骨感——我们手头的数据，常常是“半饥半饱”的状态：只有一小部分样本被贴上了标签，大部分数据都是“无主”的未知数。这就是典型的半监督学习场景。传统的监督模型在这里容易“吃不饱”而性能不佳，而纯粹的无监督方法又可能“消化不良”，浪费了宝贵的标签信息。

这时候，进化算法（Evolutionary Algorithms, EAs）这种受自然选择启发的优化“老将”，就展现出了独特的魅力。它不依赖梯度，对问题形式要求宽松，天生适合在复杂的、混合了有标签和无标签数据的高维特征空间里“寻宝”——寻找最优的分类器模型或特征子集。近年来，进化算法社区里有两个方向特别值得玩味：一个是 协同进化 ，它模拟物种间的相互作用，让多个种群（比如特征子集种群和分类器参数种群）在竞争中合作，共同进化；另一个是 整体进化搜索 ，它更倾向于将问题视为一个整体，用一个统一的种群去同时优化所有决策变量。

我这个项目，就是想亲手“解剖”一下这两种策略。当它们被应用到半监督表格分类这个具体任务上时，到底谁更胜一筹？是强调分工协作、动态博弈的协同进化能挖掘出更深层次的数据模式，还是追求全局统一、简洁高效的 整体进化搜索 更能直击要害？这不仅仅是算法性能的比拼，更是对问题本质理解的探讨。对于广大数据从业者，尤其是那些经常处理标注成本高昂的表格数据的朋友来说，这个对比研究的结果，或许能为你下一个项目中的算法选型，提供一个扎实的、基于实验的参考依据。

2. 核心思路与方案设计：为何选择进化算法与对比框架

在深入实验细节之前，我们得先掰扯清楚几个根本问题：为什么在半监督表格分类里要用进化算法？以及，我们到底要比什么、怎么比？

2.1 为什么是进化算法？

首先，表格数据，尤其是现实中的表格，往往充满“陷阱”：特征尺度不一、存在大量无关或冗余特征、类别分布可能极度不平衡，而且标签稀疏。深度学习在处理图像、文本等非结构化数据上风光无限，但对于表格数据，尤其是中小型表格，梯度提升树（如XGBoost, LightGBM）和基于进化算法的自动机器学习（AutoML）工具常常是更稳健的选择。进化算法的优势在这里凸显：

1. 对问题形式不挑剔 ：它不需要可微的损失函数，可以直接优化像分类准确率、F1分数这样的离散指标，这对于评估半监督学习的效果非常直接。
2. 全局搜索能力强 ：通过种群、交叉、变异等操作，进化算法有较强的跳出局部最优的能力，适合在由特征选择、模型参数、甚至半监督策略本身构成的复杂混合搜索空间中进行探索。
3. 天然处理混合变量 ：表格分类的优化可能同时涉及离散变量（如选择哪些特征）和连续变量（如分类器的超参数）。进化算法可以很自然地处理这种混合编码。

而 半监督学习 的核心思想是“用无标签数据辅助有标签数据”。进化算法可以通过设计适应度函数，巧妙地将无标签数据的信息融入进化过程。例如，我们可以让适应度不仅取决于模型在有标签数据上的表现，还取决于其在无标签数据上预测的“一致性”或“置信度”。

2.2 对比框架设计：协同进化 vs. 整体进化搜索

明确了工具的适用性，接下来就是设计擂台，让两位“选手”公平竞技。

• 整体进化搜索 ：这是我们熟悉的“经典”进化算法模式。我们将所有需要优化的东西编码成一个长长的染色体。举个例子，对于一个结合了特征选择和逻辑回归模型的任务，染色体可能前半部分是二进制串，表示每个特征是否被选中；后半部分是浮点数，表示逻辑回归的正则化强度C。一个种群由许多这样的个体组成，它们彼此竞争，通过选择、交叉、变异朝着更好的适应度进化。 其核心思路是“统一优化” ，所有决策变量被平等对待，在同一个评价标准下进化。

• 协同进化 ：这里的思路更有趣，它引入了“生态”的概念。我们通常会维护两个（或多个）相互作用的种群。一个典型的设置是：

  • 种群A（解决方案种群） ：例如，专门进化“分类器”。它的个体是具体的分类模型及其参数。
  • 种群B（测试种群或特征种群） ：例如，专门进化“特征子集”或“用于评估的困难数据子集”。
  • 两个种群的适应度 相互依赖 。种群A（分类器）的适应度，需要通过从种群B中选取一些个体（特征子集）来构建特征空间，并在该子空间上评估性能。反之，种群B（特征子集）的适应度，可以定义为它能够“难倒”或“有效区分”当前种群A中分类器的能力。这样，两个种群在“军备竞赛”中共同进化：分类器努力在所有特征子集上表现良好，而特征子集则努力找出分类器的弱点。 其核心思路是“分而治之，协同促进” 。

我们的对比实验设计 就围绕这两条主线展开：

1. 任务统一 ：在同一批半监督表格数据集上，完成分类任务。
2. 评估标准统一 ：主要使用有标签数据上的分类准确率、F1-macro等指标，同时也可以观察算法在利用无标签数据后，模型鲁棒性的提升。
3. 计算预算统一 ：严格限制两者的总评估次数（适应度函数调用次数），确保比较的公平性。
4. 基础组件对齐 ：使用相同的基分类器（如决策树、SVM）、相同的交叉验证策略、相同的半监督学习框架（例如，采用自训练或伪标签策略与进化搜索结合）。

注意 ：这里的一个关键设计点是，如何将半监督信息融入适应度函数。一个常见的做法是“伪标签”策略：在每一代进化中，用当前种群中较优的个体（模型）对无标签数据进行预测，将高置信度的预测结果作为临时标签，与原始有标签数据合并，用于计算适应度。这相当于在进化过程中动态地、有选择地扩充训练集。

3. 核心细节解析：算法实现的关键与难点

把蓝图变成代码，中间有很多“魔鬼细节”。这里我重点拆解两种算法实现中的核心环节和容易踩坑的地方。

3.1 整体进化搜索的实现要点

对于整体进化搜索，关键在于染色体编码、适应度函数设计和进化操作。

染色体编码 ：如前所述，采用混合编码。假设我们有N个特征，使用一个长度为N的二进制串 feature_mask 表示特征选择。然后连接上基分类器的超参数。例如，对于SVM，我们可能编码 [C, gamma] 两个对数尺度上的浮点数。整个染色体就是 feature_mask + [C, gamma] 。

适应度函数设计 ：这是连接进化算法和半监督学习的桥梁。一个有效的设计如下：

def fitness_function(chromosome, labeled_X, labeled_y, unlabeled_X):
    # 1. 解码染色体
    feature_mask = chromosome[:num_features]
    model_params = chromosome[num_features:]

    # 2. 特征选择
    selected_labeled_X = labeled_X[:, feature_mask]
    selected_unlabeled_X = unlabeled_X[:, feature_mask]

    # 3. 构建并配置模型
    model = SVC(C=10**model_params[0], gamma=10**model_params[1]) # 对数尺度
    model.fit(selected_labeled_X, labeled_y)

    # 4. 半监督核心：生成伪标签
    proba = model.predict_proba(selected_unlabeled_X)
    confidence = np.max(proba, axis=1)
    high_conf_mask = confidence > threshold # 例如 threshold=0.9

    # 5. 合并高置信度伪标签数据
    pseudo_X = selected_unlabeled_X[high_conf_mask]
    pseudo_y = np.argmax(proba[high_conf_mask], axis=1)

    if len(pseudo_y) > 0: # 如果有高置信度样本
        augmented_X = np.vstack([selected_labeled_X, pseudo_X])
        augmented_y = np.concatenate([labeled_y, pseudo_y])
        # 在增强集上重新训练（或直接使用模型，但重训练通常更优）
        model.fit(augmented_X, augmented_y)

    # 6. 计算适应度：在有标签的验证集上评估
    # 使用交叉验证或预留的验证集
    score = cross_val_score(model, selected_labeled_X, labeled_y, cv=5, scoring='accuracy').mean()

    # 7. 可选：加入正则化项，惩罚使用过多特征
    # score = score - alpha * np.sum(feature_mask) / num_features
    return score

进化操作 ：对于二进制部分，使用一点或两点交叉、位翻转变异；对于连续部分，使用模拟二进制交叉（SBX）和高斯变异。选择操作常用锦标赛选择。

实操心得 ：适应度函数的计算成本很高，因为它涉及模型训练和预测。因此， 种群大小和进化代数不宜设置过大 。一个实用的技巧是使用“热启动”：先用整体进化搜索跑一个较小的代数（如50代），找到的优秀个体可以作为后续更精细搜索（或协同进化）的初始种群，加速收敛。

3.2 协同进化的实现要点

协同进化的实现更为复杂，其核心在于两个种群适应度的相互评价机制。

种群定义 ：

• 种群P（模型种群） ：个体是分类器配置。编码可能只包含模型超参数，如 [C, gamma] 。
• 种群Q（特征种群） ：个体是特征子集。编码是长度为N的二进制串 feature_mask 。

相互适应度评估 ： 这是协同进化的精髓。我们需要定义一个评估函数 evaluate(P_ind, Q_ind) 。

1. 评估模型个体（P_ind） ：对于一个模型个体，它的适应度不是固定的。我们需要从种群Q中抽取一批特征个体（例如，当前Q种群中最优的K个，或随机抽取M个），用每个特征子集构建数据，训练并评估该模型。模型个体的最终适应度可以是这K次评估结果的平均值。这模拟了“一个分类器需要在多种不同的特征视角下都表现稳健”。

   def fitness_of_model(model_ind, feature_population):
       scores = []
       for _ in range(K):
           # 从特征种群中选一个个体（如通过竞争选择）
           feature_ind = select_from_population_Q(feature_population)
           feature_mask = decode(feature_ind)
           selected_X = X_labeled[:, feature_mask]
           # 训练并评估模型
           score = train_and_eval(model_ind, selected_X, y_labeled)
           scores.append(score)
       return np.mean(scores)
   

2. 评估特征个体（Q_ind） ：对于一个特征个体，它的适应度是它“区分”当前模型种群的能力。一个直观的想法是，一个好的特征子集应该能让好的模型和差的模型的表现差异最大化。我们可以从种群P中抽取一批模型个体，在该特征子集上评估它们，然后计算这些评估得分的方差或范围。方差越大，说明这个特征子集越能“考验”模型，其适应度越高。

   def fitness_of_feature(feature_ind, model_population):
       feature_mask = decode(feature_ind)
       selected_X = X_labeled[:, feature_mask]
       scores = []
       for model_ind in model_population_sample:
           score = train_and_eval(model_ind, selected_X, y_labeled)
           scores.append(score)
       # 适应度可以是得分的方差，方差大说明区分度高
       return np.var(scores)
   

协同进化流程 ：两个种群交替进化。每一代，先固定种群Q，评估并进化种群P；然后固定新的种群P，评估并进化种群Q。半监督信息的融入，可以在 train_and_eval 函数内部实现，与整体搜索中类似，加入伪标签生成与重训练步骤。

避坑指南 ：协同进化最大的风险是“失去目标”或“陷入循环”。比如，特征种群可能进化出一些非常怪异、对当前任务实际无益但恰好能难倒当前模型种群的子集。为防止这种情况，需要引入 锚定机制 ：定期用一个固定的、在完整特征集上训练的基准模型来评估特征种群，或者将特征种群的适应度部分地与一个全局任务（如在有标签数据上的基准性能）挂钩。此外， 两个种群的进化速度需要平衡 ，避免一方过于强大导致另一方失去进化压力。

4. 实验过程与核心环节实现

理论说得再多，不如一行代码。我选择用Python的 DEAP 框架来实现这两种算法，因为它非常灵活，适合构建自定义的进化流程。实验数据来自UCI仓库的几个经典数据集，并人工将其划分为少量有标签数据和大量无标签数据，以模拟半监督场景。

4.1 实验环境与数据准备

import numpy as np
import pandas as pd
from sklearn.datasets import load_wine, load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
import random
from deap import base, creator, tools, algorithms

# 1. 数据加载与预处理
data = load_breast_cancer()
X, y = data.data, data.target
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 2. 模拟半监督场景：假设只有20%的数据有标签
X_labeled, X_unlabeled, y_labeled, y_unlabeled = train_test_split(
    X_scaled, y, train_size=0.2, stratify=y, random_state=42
)
# 注意：y_unlabeled 在实际中是不可知的，这里仅用于最终测试
X_pool = X_unlabeled.copy() # 无标签数据池
y_pool_true = y_unlabeled.copy() # 保留真实标签用于最终测试，算法过程中不可见

print(f"有标签数据形状: {X_labeled.shape}")
print(f"无标签数据池形状: {X_pool.shape}")

4.2 整体进化搜索核心代码实现

这里展示核心的进化循环设置，适应度函数 evalOneMax 是前面设计的具体实现。

# 定义问题：最大化适应度（准确率）
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)

toolbox = base.Toolbox()

# 基因编码：假设有30个特征，染色体前30位是二进制（特征选择），后2位是浮点数（SVM的logC和logGamma）
num_features = X_scaled.shape[1]

# 注册属性生成函数
toolbox.register("attr_bool", random.randint, 0, 1)
toolbox.register("attr_float", random.uniform, -3, 3) # 假设C和gamma在10^{-3}到10^{3}之间

# 定义个体创建函数
def create_individual():
    # 前num_features个基因是二进制（特征选择）
    part_bool = [toolbox.attr_bool() for _ in range(num_features)]
    # 后2个基因是浮点数（模型参数）
    part_float = [toolbox.attr_float() for _ in range(2)]
    return creator.Individual(part_bool + part_float)

toolbox.register("individual", create_individual)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

# 注册适应度评估函数（这里需要接入前面的fitness_function逻辑）
toolbox.register("evaluate", evalOneMax, labeled_X=X_labeled, labeled_y=y_labeled, unlabeled_X=X_pool)
# 注册遗传算子
toolbox.register("mate", tools.cxTwoPoint) # 交叉
toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) # 对二进制部分变异
# 对于连续部分，需要自定义变异，这里简化处理，后续可细化
def mutate_float(individual, mu=0, sigma=0.5):
    for i in range(num_features, len(individual)):
        if random.random() < 0.1: # 变异概率
            individual[i] += random.gauss(mu, sigma)
            # 边界处理
            individual[i] = max(-3, min(3, individual[i]))
    return individual,
toolbox.register("mutate_float", mutate_float)
# 选择算子
toolbox.register("select", tools.selTournament, tournsize=3)

# 进化主循环
def main():
    pop = toolbox.population(n=50) # 种群大小50
    CXPB, MUTPB = 0.5, 0.2 # 交叉和变异概率

    print("开始整体进化搜索...")
    # 评估初始种群
    fitnesses = list(map(toolbox.evaluate, pop))
    for ind, fit in zip(pop, fitnesses):
        ind.fitness.values = fit

    for gen in range(100): # 进化100代
        # 选择下一代
        offspring = toolbox.select(pop, len(pop))
        offspring = list(map(toolbox.clone, offspring))

        # 对选出的后代进行交叉和变异
        for child1, child2 in zip(offspring[::2], offspring[1::2]):
            if random.random() < CXPB:
                toolbox.mate(child1, child2)
                del child1.fitness.values
                del child2.fitness.values

        for mutant in offspring:
            if random.random() < MUTPB:
                toolbox.mutate(mutant) # 二进制变异
                toolbox.mutate_float(mutant) # 连续部分变异
                del mutant.fitness.values

        # 评估新生成的后代
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        # 用后代完全替换原种群（简单世代更替）
        pop[:] = offspring

        # 收集并打印每一代统计信息
        fits = [ind.fitness.values[0] for ind in pop]
        if gen % 10 == 0:
            print(f"代 {gen}: 最大适应度 {max(fits):.4f}, 平均适应度 {np.mean(fits):.4f}")

    print("--- 进化结束 ---")
    best_ind = tools.selBest(pop, 1)[0]
    print(f"最佳个体: {best_ind}")
    print(f"最佳适应度: {best_ind.fitness.values[0]:.4f}")
    return best_ind

4.3 协同进化核心代码实现

协同进化的实现更复杂，需要管理两个种群和它们之间的交互评估。

# 首先，为两种个体创建不同的类型
# 模型个体（只包含SVM参数）
creator.create("ModelFitnessMax", base.Fitness, weights=(1.0,))
creator.create("ModelIndividual", list, fitness=creator.ModelFitnessMax)
# 特征个体（只包含特征掩码）
creator.create("FeatureFitnessMax", base.Fitness, weights=(1.0,)) # 注意：特征适应度也可能是最大化方差
creator.create("FeatureIndividual", list, fitness=creator.FeatureFitnessMax)

toolbox_co = base.Toolbox()

# 注册模型个体生成
toolbox_co.register("attr_model_float", random.uniform, -3, 3)
toolbox_co.register("model_individual", tools.initRepeat, creator.ModelIndividual, toolbox_co.attr_model_float, n=2) # 两个参数
toolbox_co.register("model_population", tools.initRepeat, list, toolbox_co.model_individual)

# 注册特征个体生成
toolbox_co.register("attr_feature_bool", random.randint, 0, 1)
toolbox_co.register("feature_individual", tools.initRepeat, creator.FeatureIndividual, toolbox_co.attr_feature_bool, n=num_features)
toolbox_co.register("feature_population", tools.initRepeat, list, toolbox_co.feature_individual)

# 定义相互评估函数（这里是简化版，需接入半监督逻辑）
def evaluate_model(ind_model, feature_pop_sample):
    """评估一个模型个体 against 一批特征个体"""
    scores = []
    C, gamma = 10**ind_model[0], 10**ind_model[1]
    for ind_feat in feature_pop_sample:
        mask = np.array(ind_feat, dtype=bool)
        if np.sum(mask) == 0:
            scores.append(0.0) # 没有特征被选中，得分为0
            continue
        X_sub = X_labeled[:, mask]
        # 这里应加入半监督训练和评估逻辑，同整体搜索的fitness_function核心部分
        # 为简化示例，仅用有标签数据训练评估
        clf = SVC(C=C, gamma=gamma, probability=True)
        # 使用交叉验证得分
        from sklearn.model_selection import cross_val_score
        score = cross_val_score(clf, X_sub, y_labeled, cv=3, scoring='accuracy').mean()
        scores.append(score)
    return np.mean(scores), # 返回元组

def evaluate_feature(ind_feature, model_pop_sample):
    """评估一个特征个体 against 一批模型个体"""
    mask = np.array(ind_feature, dtype=bool)
    if np.sum(mask) == 0:
        return 0.0, # 没有特征被选中
    X_sub = X_labeled[:, mask]
    scores = []
    for ind_model in model_pop_sample:
        C, gamma = 10**ind_model[0], 10**ind_model[1]
        clf = SVC(C=C, gamma=gamma)
        score = cross_val_score(clf, X_sub, y_labeled, cv=3, scoring='accuracy').mean()
        scores.append(score)
    # 适应度定义为模型得分的方差，方差大说明该特征子集区分能力强
    return np.var(scores),

toolbox_co.register("evaluate_model", evaluate_model)
toolbox_co.register("evaluate_feature", evaluate_feature)

# 为两个种群分别注册遗传算子
toolbox_co.register("mate_model", tools.cxBlend, alpha=0.5) # 混合交叉，适用于连续变量
toolbox_co.register("mutate_model", tools.mutGaussian, mu=0, sigma=0.5, indpb=0.2)
toolbox_co.register("select_model", tools.selTournament, tournsize=3)

toolbox_co.register("mate_feature", tools.cxTwoPoint)
toolbox_co.register("mutate_feature", tools.mutFlipBit, indpb=0.05)
toolbox_co.register("select_feature", tools.selTournament, tournsize=3)

# 协同进化主循环
def coevolution_main():
    pop_model = toolbox_co.model_population(n=30) # 模型种群
    pop_feature = toolbox_co.feature_population(n=30) # 特征种群
    GEN = 50 # 协同进化代数

    print("开始协同进化...")
    for gen in range(GEN):
        # --- 阶段1: 固定特征种群，进化模型种群 ---
        # 从特征种群中抽样用于评估模型
        feature_sample = tools.selBest(pop_feature, k=5) + random.sample(pop_feature, k=5) # 混合最优和随机样本
        # 评估当前模型种群
        for ind in pop_model:
            ind.fitness.values = toolbox_co.evaluate_model(ind, feature_sample)
        # 进化模型种群
        offspring_model = toolbox_co.select_model(pop_model, len(pop_model))
        offspring_model = list(map(toolbox_co.clone, offspring_model))
        # 交叉与变异
        for child1, child2 in zip(offspring_model[::2], offspring_model[1::2]):
            if random.random() < 0.7:
                toolbox_co.mate_model(child1, child2)
                del child1.fitness.values
                del child2.fitness.values
        for mutant in offspring_model:
            if random.random() < 0.2:
                toolbox_co.mutate_model(mutant)
                del mutant.fitness.values
        # 评估新模型后代
        invalid_model = [ind for ind in offspring_model if not ind.fitness.valid]
        for ind in invalid_model:
            ind.fitness.values = toolbox_co.evaluate_model(ind, feature_sample)
        pop_model[:] = offspring_model

        # --- 阶段2: 固定模型种群，进化特征种群 ---
        # 从模型种群中抽样用于评估特征
        model_sample = tools.selBest(pop_model, k=5) + random.sample(pop_model, k=5)
        # 评估当前特征种群
        for ind in pop_feature:
            ind.fitness.values = toolbox_co.evaluate_feature(ind, model_sample)
        # 进化特征种群
        offspring_feature = toolbox_co.select_feature(pop_feature, len(pop_feature))
        offspring_feature = list(map(toolbox_co.clone, offspring_feature))
        # 交叉与变异
        for child1, child2 in zip(offspring_feature[::2], offspring_feature[1::2]):
            if random.random() < 0.5:
                toolbox_co.mate_feature(child1, child2)
                del child1.fitness.values
                del child2.fitness.values
        for mutant in offspring_feature:
            if random.random() < 0.2:
                toolbox_co.mutate_feature(mutant)
                del mutant.fitness.values
        # 评估新特征后代
        invalid_feature = [ind for ind in offspring_feature if not ind.fitness.valid]
        for ind in invalid_feature:
            ind.fitness.values = toolbox_co.evaluate_feature(ind, model_sample)
        pop_feature[:] = offspring_feature

        if gen % 10 == 0:
            best_model = tools.selBest(pop_model, 1)[0]
            best_feat = tools.selBest(pop_feature, 1)[0]
            print(f"代 {gen}: 最佳模型适应度 {best_model.fitness.values[0]:.4f}, 最佳特征适应度 {best_feat.fitness.values[0]:.6f}")

    print("--- 协同进化结束 ---")
    best_model = tools.selBest(pop_model, 1)[0]
    best_feature = tools.selBest(pop_feature, 1)[0]
    return best_model, best_feature

5. 实验结果分析与典型问题排查

跑完实验，拿到一堆数据，真正的挑战才刚刚开始：如何解读结果？如何判断哪种方法更好？过程中遇到了哪些坑？

5.1 结果对比维度

我们不能只看最终测试集上的一个准确率数字。一个全面的对比应该包括多个维度：

核心发现 ：在这个特定的半监督表格分类任务上， 协同进化 在最终性能和对噪声的鲁棒性上表现出微弱的优势，但其代价是更慢的收敛速度和显著更高的计算成本。 整体进化搜索 则提供了更快的解决方案，且结果更稳定、更易于解释。如果计算资源有限或需要快速原型验证，整体搜索是更务实的选择；如果追求极致的性能且不计较算力，协同进化值得深入调优尝试。

5.2 常见问题与排查实录

在实际编码和调试中，我遇到了不少典型问题，这里分享出来供大家避坑：

1. 问题：协同进化陷入“平庸均衡”

   • 现象 ：两个种群的适应度很早就停止上升，甚至开始震荡或下降，最终结果还不如随机搜索。
   • 排查 ：检查相互评估函数。很可能是因为评估时抽样的对手（来自另一个种群）太“弱”或太“随机”，无法提供有效的进化压力。例如，总是用随机抽取的特征子集评估模型，好的模型得不到奖励，差的特征子集也得不到惩罚。
   • 解决 ：
     • 对手选择策略 ：不要完全随机抽样。采用“精英抽样”策略，即主要从另一个种群中当前适应度最高的部分个体中抽取对手，这样可以保证进化压力。
     • 引入“档案” ：维护一个历史精英个体集合（Archive），评估时不仅从当前种群，也从档案中抽取对手，防止丢失好的进化方向。
     • 调整适应度定义 ：对于特征种群，除了“区分模型”的能力，可以加入一项与最终任务性能（如有标签数据上的基准准确率）正相关的项，将其适应度与全局目标更紧密地绑定。

2. 问题：半监督伪标签引入噪声，导致性能崩溃

   • 现象 ：进化初期性能稳步提升，中后期突然断崖式下跌。
   • 排查 ：检查伪标签生成逻辑。很可能是在进化早期，模型本身还不稳定，就生成了大量错误的高置信度伪标签，这些噪声数据污染了训练集，导致模型在错误的方向上越走越远。
   • 解决 ：
     • 动态置信度阈值 ：初期设置很高的置信度阈值（如0.99），只选择极有把握的样本。随着进化进行，模型逐渐稳定，可以缓慢降低阈值（如到0.8）。
     • 伪标签数量限制 ：每一代只选择置信度最高的前K个无标签样本加入训练，控制噪声的引入速度。
     • 早停机制 ：监控在有标签验证集上的性能，一旦连续多代下降，则回滚到之前的模型，并清空伪标签集。

3. 问题：计算时间无法忍受

   • 现象 ：尤其是协同进化，跑一个数据集就要几个小时。
   • 排查 ：适应度函数中的模型训练（特别是带交叉验证的）是主要瓶颈。
   • 解决 ：
     • 减少评估开销 ：使用更快的基分类器（如线性模型、浅层决策树）进行进化搜索，找到优秀个体后，再用复杂模型（如SVM、GBDT）在最终选出的特征子集上精调。
     • 并行化 ： DEAP 框架支持并行评估。使用 toolbox.register("map", futures.map) 可以轻松利用多核CPU，将种群个体的评估并行化，这是提升速度最有效的手段之一。
     • 缓存机制 ：对于相同的（模型参数，特征子集）组合，其适应度结果是确定的。可以实现一个简单的缓存字典，避免重复计算。

4. 问题：特征子集为空

   • 现象 ：进化过程中，某些个体的特征掩码全为0，导致模型无法训练。
   • 解决 ：在适应度函数中直接处理。如果选中的特征数为0，则直接返回一个极低的适应度（如0或负值），这样选择操作会自然淘汰这些个体。也可以在变异操作后增加一个修复步骤，强制至少保留一个特征。

这个对比研究做下来，我的一个深刻体会是：在机器学习领域，没有绝对的“银弹”。 整体进化搜索 像是一位全能的特种兵，单兵作战效率高，目标明确，在大多数情况下都能可靠地完成任务。而 协同进化 则更像一支分工明确、相互砥砺的特种小队，潜力更大，能处理更复杂、动态的任务，但指挥和协调（算法设计和调参）的成本也高得多。对于半监督表格分类这个问题，如果你的数据质量相对较高，特征维度不是特别离谱，计算资源紧张，那么整体搜索的性价比非常突出。但如果你面对的是一个特征冗余严重、模式复杂、并且你有足够的算力和时间去“精雕细琢”的问题，协同进化所蕴含的“协同”与“博弈”思想，或许能带你找到那片意想不到的更优解空间。最后，无论选择哪种方法， 精心设计的适应度函数 （尤其是如何融入半监督信息）和 对进化过程动态的监控与干预 ，往往是成功与否的关键。