Python案例如何用Scikit-learn做特征聚合

wen python案例 2026-07-16 205

本文目录导读：

特征聚合的常见方法
特征聚合的实际应用
最佳实践建议

我来详细介绍如何使用Scikit-learn进行特征聚合的Python案例。

特征聚合的常见方法

主成分分析（PCA）

import numpy as np
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
# 创建示例数据
np.random.seed(42)
n_samples = 100
n_features = 10
# 生成具有相关性的特征数据
X = np.random.randn(n_samples, n_features)
# 添加一些相关性
X[:, 5:] = X[:, :5] + np.random.randn(n_samples, 5) * 0.1
# 标准化数据
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# PCA特征聚合
pca = PCA(n_components=3)  # 聚合到3个主成分
X_pca = pca.fit_transform(X_scaled)
print("原始特征维度:", X_scaled.shape)
print("PCA后特征维度:", X_pca.shape)
print("\n各主成分解释方差比:", pca.explained_variance_ratio_)
print("累计解释方差比:", np.cumsum(pca.explained_variance_ratio_))
# 可视化
plt.figure(figsize=(12, 4))
# 子图1：解释方差
plt.subplot(1, 2, 1)
plt.bar(range(1, 4), pca.explained_variance_ratio_)
plt.plot(range(1, 4), np.cumsum(pca.explained_variance_ratio_), 'ro-')
plt.xlabel('主成分')
plt.ylabel('解释方差比')'PCA解释方差')
# 子图2：特征投影
plt.subplot(1, 2, 2)
plt.scatter(X_pca[:, 0], X_pca[:, 1], alpha=0.6)
plt.xlabel('第一主成分')
plt.ylabel('第二主成分')'PCA特征聚合结果')
plt.tight_layout()
plt.show()

线性判别分析（LDA）

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
# 创建带标签的数据
y = np.random.randint(0, 3, n_samples)  # 3个类别
# LDA特征聚合
lda = LinearDiscriminantAnalysis(n_components=2)
X_lda = lda.fit_transform(X_scaled, y)
print("原始特征维度:", X_scaled.shape)
print("LDA后特征维度:", X_lda.shape)
print("\nLDA特征重要性:", lda.explained_variance_ratio_)
# 可视化LDA结果
plt.figure(figsize=(10, 5))
# 子图1：LDA投影
plt.subplot(1, 2, 1)
for i in range(3):
    mask = y == i
    plt.scatter(X_lda[mask, 0], X_lda[mask, 1], 
                label=f'类别{i}', alpha=0.6)
plt.xlabel('LD1')
plt.ylabel('LD2')'LDA特征聚合结果')
plt.legend()
# 子图2：与PCA对比
plt.subplot(1, 2, 2)
for i in range(3):
    mask = y == i
    plt.scatter(X_pca[mask, 0], X_pca[mask, 1], 
                label=f'类别{i}', alpha=0.6)
plt.xlabel('PC1')
plt.ylabel('PC2')'PCA结果（对比）')
plt.legend()
plt.tight_layout()
plt.show()

特征聚类聚合

from sklearn.cluster import FeatureAgglomeration
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif
# 特征聚合聚类
feature_agg = FeatureAgglomeration(n_clusters=4)  # 聚合到4个簇
X_agg = feature_agg.fit_transform(X_scaled)
print("特征聚合聚类:")
print("原始特征维度:", X_scaled.shape)
print("聚合后特征维度:", X_agg.shape)
print("特征簇标签:", feature_agg.labels_)
# 使用SelectKBest选择特征
selector = SelectKBest(score_func=f_classif, k=5)
X_selected = selector.fit_transform(X_scaled, y)
print("\n特征选择:")
print("原始特征维度:", X_scaled.shape)
print("选择后特征维度:", X_selected.shape)
print("选择的特征索引:", selector.get_support(indices=True))
print("特征评分:", selector.scores_)

综合案例 - 特征聚合流程

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
# 创建一个完整的特征聚合流程
def feature_aggregation_pipeline(X, y):
    """
    完整的特征聚合流程
    """
    results = {}
    # 1. 原始数据
    print("="*50)
    print("特征聚合完整流程")
    print("="*50)
    # 2. PCA聚合
    pca_pipeline = Pipeline([
        ('scaler', StandardScaler()),
        ('pca', PCA(n_components=0.95))  # 保留95%方差
    ])
    X_pca = pca_pipeline.fit_transform(X)
    print(f"\nPCA聚合:")
    print(f"- 原始特征数: {X.shape[1]}")
    print(f"- 聚合后特征数: {X_pca.shape[1]}")
    # 3. 性能对比
    print("\n分类性能对比（随机森林）：")
    models = {
        '原始特征': X,
        'PCA特征': X_pca
    }
    for name, data in models.items():
        if data.shape[1] > 0:
            rf = RandomForestClassifier(n_estimators=50, random_state=42)
            scores = cross_val_score(rf, data, y, cv=5, scoring='accuracy')
            print(f"{name}: {scores.mean():.3f} (+/- {scores.std()*2:.3f})")
    return {
        'X_original': X,
        'X_pca': X_pca,
        'pca_pipeline': pca_pipeline
    }
# 生成更真实的数据
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=200, n_features=20, 
                           n_informative=10, n_redundant=5, 
                           n_classes=3, random_state=42)
results = feature_aggregation_pipeline(X, y)

特征聚合在图像数据中的应用

from sklearn.decomposition import NMF  # 非负矩阵分解
from sklearn.manifold import TSNE
# 生成图像特征数据
n_images = 100
n_pixels = 64  # 8x8的图片
X_images = np.random.rand(n_images, n_pixels)
# 添加一些结构
for i in range(n_images):
    X_images[i, i%64] = 1.0
    X_images[i, (i+10)%64] = 1.0
print("图像特征聚合示例：")
# NMF聚合
nmf = NMF(n_components=10, random_state=42)
X_nmf = nmf.fit_transform(X_images)
print(f"NMF聚合:")
print(f"- 原始特征数: {X_images.shape[1]}")
print(f"- 聚合后特征数: {X_nmf.shape[1]}")
print(f"- 重构误差: {nmf.reconstruction_err_:.4f}")
# t-SNE可视化
tsne = TSNE(n_components=2, random_state=42)
X_tsne = tsne.fit_transform(X_images)
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.imshow(nmf.components_[0].reshape(8, 8), cmap='viridis')
plt.colorbar()'NMF基础组件')
plt.subplot(1, 2, 2)
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=X_images[:, 0], 
            cmap='coolwarm', alpha=0.6)
plt.colorbar()'t-SNE特征可视化')
plt.tight_layout()
plt.show()

特征聚合的实际应用

class FeatureAggregator:
    """
    特征聚合器类
    """
    def __init__(self):
        self.methods = {}
        self.results = {}
    def add_method(self, name, method):
        """添加聚合方法"""
        self.methods[name] = method
    def aggregate(self, X, y=None):
        """执行所有注册的聚合方法"""
        for name, method in self.methods.items():
            print(f"\n执行聚合方法: {name}")
            if y is not None and hasattr(method, 'fit_transform'):
                result = method.fit_transform(X, y)
            else:
                result = method.fit_transform(X)
            self.results[name] = result
            print(f"- 输出维度: {result.shape}")
        return self.results
    def compare_performance(self, X, y):
        """比较不同聚合方法的性能"""
        from sklearn.neighbors import KNeighborsClassifier
        print("\n" + "="*50)
        print("不同聚合方法性能比较")
        print("="*50)
        for name, result in self.results.items():
            knn = KNeighborsClassifier(n_neighbors=5)
            scores = cross_val_score(knn, result, y, cv=5)
            print(f"{name}: 准确率 {scores.mean():.3f} (+/- {scores.std()*2:.3f})")
# 使用示例
aggregator = FeatureAggregator()
# 添加不同的聚合方法
aggregator.add_method('PCA', PCA(n_components=0.9))
aggregator.add_method('LDA', LinearDiscriminantAnalysis(n_components=2))
aggregator.add_method('SelectKBest', SelectKBest(k=5))
# 执行聚合
results = aggregator.aggregate(X, y)
# 比较性能
aggregator.compare_performance(X, y)

最佳实践建议

def feature_aggregation_best_practices():
    """
    特征聚合的最佳实践
    """
    tips = """
    特征聚合最佳实践：
    1. **选择合适的方法**
       - PCA：无监督，适合去除冗余特征
       - LDA：有监督，适合分类任务
       - 特征聚类：适合高维稀疏数据
    2. **预处理重要**
       - 标准化/归一化（PCA和LDA需要）
       - 处理缺失值
       - 处理异常值
    3. **确定聚合数量**
       - 使用肘部法则（PCA）
       - 使用交叉验证
       - 保留足够的信息（80-95%方差）
    4. **验证效果**
       - 保持原始特征作为baseline
       - 使用多种评估指标
       - 检查过拟合风险
    5. **常见陷阱**
       - 信息丢失过多
       - 可解释性降低
       - 计算成本增加
    """
    print(tips)
feature_aggregation_best_practices()

这些案例涵盖了Scikit-learn中常用的特征聚合方法，包括PCA、LDA、特征聚类等，以及它们在实际应用中的完整流程，选择合适的特征聚合方法可以有效降低维数、减少计算开销,同时保持模型的性能。

本文地址： https://www.bmjup.com/post/22500.html