构建AI智能体：集成学习：从三个臭皮匠到AI集体智慧的深度解析

# 示例：展示集成学习的优势
import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_moons, make_circles
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

def improved_ensemble_demo():
    
    # 创建更复杂的非线性数据集
    print(" 生成复杂数据集...")
    X, y = make_moons(n_samples=300, noise=0.3, random_state=42)
    
    # 分割数据
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
    
    # 单个深度决策树（容易过拟合）
    single_tree = DecisionTreeClassifier(max_depth=15, random_state=42)
    # 随机森林（集成方法）
    random_forest = RandomForestClassifier(n_estimators=50, max_depth=5, random_state=42)
    
    # 训练模型
    print(" 训练模型...")
    single_tree.fit(X_train, y_train)
    random_forest.fit(X_train, y_train)
    
    # 计算准确率
    single_train_acc = accuracy_score(y_train, single_tree.predict(X_train))
    single_test_acc = accuracy_score(y_test, single_tree.predict(X_test))
    rf_train_acc = accuracy_score(y_train, random_forest.predict(X_train))
    rf_test_acc = accuracy_score(y_test, random_forest.predict(X_test))
    
    print(f"\n 性能对比:")
    print(f"单个决策树 - 训练准确率: {single_train_acc:.3f}, 测试准确率: {single_test_acc:.3f}")
    print(f"随机森林   - 训练准确率: {rf_train_acc:.3f}, 测试准确率: {rf_test_acc:.3f}")
    
    # 创建更密集的网格来可视化决策边界
    x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
    y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                         np.arange(y_min, y_max, 0.02))
    
    # 创建图形
    plt.figure(figsize=(15, 5))
    
    # 子图1：原始数据
    plt.subplot(1, 3, 1)
    scatter = plt.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=plt.cm.RdYlBu, edgecolors='k')
    plt.xlabel('特征 1')
    plt.ylabel('特征 2')
    plt.title('原始数据分布\n(月亮数据集)')
    plt.colorbar(scatter)
    plt.grid(True, alpha=0.3)
    
    # 子图2：单个决策树的决策边界
    plt.subplot(1, 3, 2)
    Z_single = single_tree.predict(np.c_[xx.ravel(), yy.ravel()])
    Z_single = Z_single.reshape(xx.shape)
    plt.contourf(xx, yy, Z_single, alpha=0.8, cmap=plt.cm.RdYlBu)
    plt.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=plt.cm.RdYlBu, edgecolors='k')
    plt.xlabel('特征 1')
    plt.ylabel('特征 2')
    plt.title(f'单个决策树 (深度=15)\n训练准确率: {single_train_acc:.3f}, 测试准确率: {single_test_acc:.3f}')
    plt.grid(True, alpha=0.3)
    
    # 子图3：随机森林的决策边界
    plt.subplot(1, 3, 3)
    Z_ensemble = random_forest.predict(np.c_[xx.ravel(), yy.ravel()])
    Z_ensemble = Z_ensemble.reshape(xx.shape)
    plt.contourf(xx, yy, Z_ensemble, alpha=0.8, cmap=plt.cm.RdYlBu)
    plt.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=plt.cm.RdYlBu, edgecolors='k')
    plt.xlabel('特征 1')
    plt.ylabel('特征 2')
    plt.title(f'随机森林 (50棵树)\n训练准确率: {rf_train_acc:.3f}, 测试准确率: {rf_test_acc:.3f}')
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()
    
    # 添加过拟合分析
    print(f"\n 过拟合分析:")
    overfitting_single = single_train_acc - single_test_acc
    overfitting_rf = rf_train_acc - rf_test_acc
    print(f"单个决策树过拟合程度: {overfitting_single:.3f}")
    print(f"随机森林过拟合程度: {overfitting_rf:.3f}")
    
    if overfitting_single > overfitting_rf:
        print(" 随机森林有效减少了过拟合！")
    else:
        print(" 在这个例子中过拟合改善不明显")

improved_ensemble_demo()

# 示例：圆形数据集展示集成学习的优势
import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_moons, make_circles
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False


def circles_ensemble_demo():
    """使用圆形数据集展示集成学习的优势"""
    
    # 创建圆形数据集（更难分类）
    print(" 生成圆形数据集...")
    X, y = make_circles(n_samples=400, noise=0.2, factor=0.5, random_state=42)
    
    # 分割数据
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
    
    # 创建不同复杂度的模型
    models = {
        '简单决策树': DecisionTreeClassifier(max_depth=3, random_state=42),
        '复杂决策树': DecisionTreeClassifier(max_depth=20, random_state=42),
        '随机森林': RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
    }
    
    # 训练并评估所有模型
    results = {}
    
    print(" 训练和评估模型...")
    for name, model in models.items():
        model.fit(X_train, y_train)
        train_acc = accuracy_score(y_train, model.predict(X_train))
        test_acc = accuracy_score(y_test, model.predict(X_test))
        results[name] = {'model': model, 'train_acc': train_acc, 'test_acc': test_acc}
        print(f"{name:12} - 训练: {train_acc:.3f}, 测试: {test_acc:.3f}")
    
    # 创建可视化网格
    x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
    y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                         np.arange(y_min, y_max, 0.02))
    
    # 创建对比图
    plt.figure(figsize=(18, 5))
    
    # 原始数据
    plt.subplot(1, 4, 1)
    scatter = plt.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=plt.cm.RdYlBu, edgecolors='k')
    plt.xlabel('特征 1')
    plt.ylabel('特征 2')
    plt.title('原始数据分布\n(圆形数据集)')
    plt.colorbar(scatter)
    plt.grid(True, alpha=0.3)
    
    # 三个模型的决策边界
    for i, (name, result) in enumerate(results.items()):
        plt.subplot(1, 4, i+2)
        Z = result['model'].predict(np.c_[xx.ravel(), yy.ravel()])
        Z = Z.reshape(xx.shape)
        plt.contourf(xx, yy, Z, alpha=0.8, cmap=plt.cm.RdYlBu)
        plt.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=plt.cm.RdYlBu, edgecolors='k', alpha=0.6)
        plt.xlabel('特征 1')
        plt.ylabel('特征 2')
        
        overfitting = result['train_acc'] - result['test_acc']
        plt.title(f'{name}\n训练: {result["train_acc"]:.3f}, 测试: {result["test_acc"]:.3f}\n过拟合: {overfitting:.3f}')
        plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()
    
    # 性能总结
    print(f"\n 性能总结:")
    best_model = max(results.items(), key=lambda x: x[1]['test_acc'])
    print(f"最佳模型: {best_model[0]} (测试准确率: {best_model[1]['test_acc']:.3f})")

# 运行圆形数据集示例
circles_ensemble_demo()

# 示例：投票机制演示展示集成学习的优势
import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_moons, make_circles
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

def voting_mechanism_demo_improved():
    """投票机制演示"""
    
    # 创建简单的二分类问题
    np.random.seed(42)
    X = np.random.randn(200, 2)
    y = (X[:, 0] ** 2 + X[:, 1] ** 2 > 1.5).astype(int)
    
    # 创建5个不同的弱分类器
    from sklearn.linear_model import LogisticRegression
    from sklearn.svm import SVC
    from sklearn.neighbors import KNeighborsClassifier
    
    classifiers = [
        ('决策树1', DecisionTreeClassifier(max_depth=2, random_state=1)),
        ('决策树2', DecisionTreeClassifier(max_depth=2, random_state=2)),
        ('决策树3', DecisionTreeClassifier(max_depth=2, random_state=3)),
        ('逻辑回归', LogisticRegression(random_state=42)),
        ('K近邻', KNeighborsClassifier(n_neighbors=3))
    ]
    
    # 训练所有分类器
    individual_predictions = []
    individual_accuracies = []
    
    print(" 集成学习的投票机制演示")
    print("=" * 40)
    
    for name, clf in classifiers:
        clf.fit(X, y)
        y_pred = clf.predict(X)
        acc = accuracy_score(y, y_pred)
        individual_predictions.append(y_pred)
        individual_accuracies.append(acc)
        print(f"{name:10} - 准确率: {acc:.3f}")
    
    # 集成预测：多数投票
    individual_predictions = np.array(individual_predictions)
    ensemble_pred = (np.sum(individual_predictions, axis=0) > len(classifiers) / 2).astype(int)
    ensemble_acc = accuracy_score(y, ensemble_pred)
    
    print(f"{'集成投票':10} - 准确率: {ensemble_acc:.3f}")
    print(f" 集成相比平均提升: {ensemble_acc - np.mean(individual_accuracies):.3f}")
    
    # 创建上3下3的布局
    plt.figure(figsize=(18, 12))
    
    # 第一行：原始数据 + 两个分类器
    # 子图1：原始数据
    plt.subplot(2, 3, 1)
    scatter = plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.RdYlBu, edgecolors='k', alpha=0.8)
    plt.title('原始数据分布\n(真实标签)', fontsize=14, fontweight='bold')
    plt.xlabel('特征1', fontsize=12)
    plt.ylabel('特征2', fontsize=12)
    plt.grid(True, alpha=0.3)
    
    # 子图2：决策树1
    plt.subplot(2, 3, 2)
    plt.scatter(X[:, 0], X[:, 1], c=individual_predictions[0], s=50, cmap=plt.cm.RdYlBu, edgecolors='k', alpha=0.8)
    plt.title(f'决策树1预测\n准确率: {individual_accuracies[0]:.3f}', fontsize=14)
    plt.xlabel('特征1', fontsize=12)
    plt.ylabel('特征2', fontsize=12)
    plt.grid(True, alpha=0.3)
    
    # 子图3：决策树2
    plt.subplot(2, 3, 3)
    plt.scatter(X[:, 0], X[:, 1], c=individual_predictions[1], s=50, cmap=plt.cm.RdYlBu, edgecolors='k', alpha=0.8)
    plt.title(f'决策树2预测\n准确率: {individual_accuracies[1]:.3f}', fontsize=14)
    plt.xlabel('特征1', fontsize=12)
    plt.ylabel('特征2', fontsize=12)
    plt.grid(True, alpha=0.3)
    
    # 第二行：另外两个分类器 + 集成结果
    # 子图4：决策树3
    plt.subplot(2, 3, 4)
    plt.scatter(X[:, 0], X[:, 1], c=individual_predictions[2], s=50, cmap=plt.cm.RdYlBu, edgecolors='k', alpha=0.8)
    plt.title(f'决策树3预测\n准确率: {individual_accuracies[2]:.3f}', fontsize=14)
    plt.xlabel('特征1', fontsize=12)
    plt.ylabel('特征2', fontsize=12)
    plt.grid(True, alpha=0.3)
    
    # 子图5：逻辑回归
    plt.subplot(2, 3, 5)
    plt.scatter(X[:, 0], X[:, 1], c=individual_predictions[3], s=50, cmap=plt.cm.RdYlBu, edgecolors='k', alpha=0.8)
    plt.title(f'逻辑回归预测\n准确率: {individual_accuracies[3]:.3f}', fontsize=14)
    plt.xlabel('特征1', fontsize=12)
    plt.ylabel('特征2', fontsize=12)
    plt.grid(True, alpha=0.3)
    
    # 子图6：K近邻
    plt.subplot(2, 3, 6)
    plt.scatter(X[:, 0], X[:, 1], c=individual_predictions[4], s=50, cmap=plt.cm.RdYlBu, edgecolors='k', alpha=0.8)
    plt.title(f'K近邻预测\n准确率: {individual_accuracies[4]:.3f}', fontsize=14)
    plt.xlabel('特征1', fontsize=12)
    plt.ylabel('特征2', fontsize=12)
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()
    
    # 单独显示集成结果
    plt.figure(figsize=(8, 6))
    plt.scatter(X[:, 0], X[:, 1], c=ensemble_pred, s=50, cmap=plt.cm.RdYlBu, edgecolors='k', alpha=0.8)
    plt.title(f'集成投票结果\n准确率: {ensemble_acc:.3f} (相比平均提升: {ensemble_acc - np.mean(individual_accuracies):.3f})', 
              fontsize=16, fontweight='bold', pad=20)
    plt.xlabel('特征1', fontsize=14)
    plt.ylabel('特征2', fontsize=14)
    plt.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.show()
    
    # 展示投票过程
    print(f"\n 投票过程示例 (前10个样本):")
    print("样本 |", " | ".join([name for name, _ in classifiers]), "| 集成结果 | 真实标签 | 是否正确")
    print("-" * 85)
    
    correct_count = 0
    for i in range(10):
        votes = individual_predictions[:, i]
        vote_counts = np.sum(votes)
        result = 1 if vote_counts > len(classifiers) / 2 else 0
        is_correct = "" if result == y[i] else "❌"
        if result == y[i]:
            correct_count += 1
        
        print(f"{i:4} |", " | ".join([f"{vote:8}" for vote in votes]), 
              f"| {result:8} | {y[i]:8} | {is_correct}")
    
    print(f"\n 前10个样本集成准确率: {correct_count}/10 = {correct_count/10:.1%}")
    
    # 添加性能分析
    print(f"\n 详细性能分析:")
    print(f"单个模型平均准确率: {np.mean(individual_accuracies):.3f}")
    print(f"集成模型准确率: {ensemble_acc:.3f}")
    print(f"相对提升: {(ensemble_acc - np.mean(individual_accuracies)) / np.mean(individual_accuracies) * 100:.1f}%")
    
    # 计算多样性指标
    diversity_scores = []
    for i in range(len(classifiers)):
        for j in range(i+1, len(classifiers)):
            # 计算两个分类器预测不同的比例
            disagreement = np.mean(individual_predictions[i] != individual_predictions[j])
            diversity_scores.append(disagreement)
            print(f"{classifiers[i][0]} vs {classifiers[j][0]} 差异度: {disagreement:.3f}")
    
    print(f"平均模型差异度: {np.mean(diversity_scores):.3f}")
    print(" 关键洞察: 模型差异度越高，集成效果通常越好！")

# 运行改进的投票机制演示
voting_mechanism_demo_improved()