特征重要性分析的常见误区

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.feature_selection import SelectFromModel, permutation_importance
import shap

# 加载数据集
data = load_breast_cancer()
X = data.data
y = data.target
feature_names = data.feature_names

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练多个模型用于特征重要性评估
models = {
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
    'Logistic Regression': LogisticRegression(max_iter=10000, random_state=42)
}

# 训练模型并存储
for name, model in models.items():
    model.fit(X_train, y_train)
    print(f"{name} 准确率: {model.score(X_test, y_test):.4f}")

# 特征重要性评估类
class RobustFeatureImportance:
    def __init__(self, models, X_train, X_test, y_train, y_test, feature_names):
        self.models = models
        self.X_train = X_train
        self.X_test = X_test
        self.y_train = y_train
        self.y_test = y_test
        self.feature_names = feature_names
        self.importance_results = {}
    
    def compute_permutation_importance(self, model_name, n_repeats=10):
        """计算置换重要性"""
        model = self.models[model_name]
        result = permutation_importance(
            model, self.X_test, self.y_test, 
            n_repeats=n_repeats, random_state=42
        )
        
        perm_importance = pd.DataFrame({
            'Feature': self.feature_names,
            'Importance': result.importances_mean,
            'Std': result.importances_std,
            'Method': 'Permutation',
            'Model': model_name
        })
        
        return perm_importance
    
    def compute_model_importance(self, model_name):
        """计算模型内置的特征重要性"""
        model = self.models[model_name]
        
        if hasattr(model, 'feature_importances_'):
            # 树模型等有feature_importances_属性的模型
            importance = model.feature_importances_
            importance_type = 'Feature Importance'
        elif hasattr(model, 'coef_'):
            # 线性模型等有coef_属性的模型
            importance = np.abs(model.coef_[0])
            importance_type = 'Coefficient Magnitude'
        else:
            raise ValueError(f"Model {model_name} does not have feature_importances_ or coef_ attribute")
        
        model_importance = pd.DataFrame({
            'Feature': self.feature_names,
            'Importance': importance,
            'Std': np.zeros(len(importance)),  # 模型内置重要性通常没有标准差
            'Method': importance_type,
            'Model': model_name
        })
        
        return model_importance
    
    def compute_shap_importance(self, model_name):
        """计算SHAP重要性"""
        model = self.models[model_name]
        
        # 创建SHAP解释器
        if model_name == 'Random Forest':
            explainer = shap.TreeExplainer(model)
        else:
            explainer = shap.LinearExplainer(model, self.X_train)
        
        # 计算SHAP值
        shap_values = explainer.shap_values(self.X_test)
        
        # 计算平均绝对SHAP值作为特征重要性
        if len(shap_values.shape) == 2:
            # 多类分类问题
            shap_importance = np.mean(np.abs(shap_values), axis=0)
        else:
            # 二分类或回归问题
            shap_importance = np.mean(np.abs(shap_values), axis=0)
        
        shap_importance_df = pd.DataFrame({
            'Feature': self.feature_names,
            'Importance': shap_importance,
            'Std': np.std(np.abs(shap_values), axis=0),
            'Method': 'SHAP',
            'Model': model_name
        })
        
        return shap_importance_df
    
    def compute_all_importances(self):
        """计算所有特征重要性"""
        all_importances = []
        
        for model_name in self.models:
            # 计算模型内置重要性
            model_importance = self.compute_model_importance(model_name)
            all_importances.append(model_importance)
            
            # 计算置换重要性
            perm_importance = self.compute_permutation_importance(model_name)
            all_importances.append(perm_importance)
            
            # 计算SHAP重要性
            shap_importance = self.compute_shap_importance(model_name)
            all_importances.append(shap_importance)
        
        # 合并所有结果
        self.importance_results = pd.concat(all_importances, ignore_index=True)
        return self.importance_results
    
    def get_robust_importance(self, method='mean'):
        """获取稳健的特征重要性（综合所有方法）"""
        if len(self.importance_results) == 0:
            self.compute_all_importances()
        
        # 按特征分组，计算平均重要性
        robust_importance = self.importance_results.groupby('Feature')['Importance'].agg([method, 'std']).reset_index()
        robust_importance.columns = ['Feature', 'Robust_Importance', 'Robust_Std']
        
        # 归一化重要性
        robust_importance['Robust_Importance_Norm'] = robust_importance['Robust_Importance'] / robust_importance['Robust_Importance'].sum()
        
        # 按重要性排序
        robust_importance = robust_importance.sort_values(by='Robust_Importance', ascending=False)
        
        return robust_importance
    
    def plot_importance_comparison(self):
        """绘制不同方法的特征重要性比较"""
        if len(self.importance_results) == 0:
            self.compute_all_importances()
        
        # 选择前10个重要特征
        top_features = self.get_robust_importance()['Feature'].head(10)
        
        # 筛选前10个特征的数据
        top_importance = self.importance_results[self.importance_results['Feature'].isin(top_features)]
        
        # 绘制比较图
        plt.figure(figsize=(15, 10))
        for i, feature in enumerate(top_features):
            feature_data = top_importance[top_importance['Feature'] == feature]
            plt.subplot(5, 2, i+1)
            plt.bar(
                [f"{row['Model']}-{row['Method']}" for _, row in feature_data.iterrows()],
                feature_data['Importance'],
                yerr=feature_data['Std']
            )
            plt.title(f"{feature} 重要性比较")
            plt.xticks(rotation=45, ha='right')
        
        plt.tight_layout()
        plt.savefig('feature_importance_comparison.png')
        print("特征重要性比较图已保存为 feature_importance_comparison.png")
    
    def plot_robust_importance(self):
        """绘制稳健的特征重要性"""
        robust_importance = self.get_robust_importance()
        
        plt.figure(figsize=(12, 8))
        plt.barh(robust_importance['Feature'][:15], robust_importance['Robust_Importance'][:15])
        plt.xlabel('稳健特征重要性')
        plt.ylabel('特征')
        plt.title('稳健特征重要性（Top 15）')
        plt.tight_layout()
        plt.savefig('robust_feature_importance.png')
        print("稳健特征重要性图已保存为 robust_feature_importance.png")

# 创建稳健特征重要性评估实例
robust_importance = RobustFeatureImportance(
    models, X_train, X_test, y_train, y_test, feature_names
)

# 计算所有特征重要性
all_importances = robust_importance.compute_all_importances()
print("所有特征重要性评估结果示例：")
print(all_importances.head())

# 获取稳健的特征重要性
robust_results = robust_importance.get_robust_importance()
print("\n稳健特征重要性结果（Top 10）：")
print(robust_results.head(10))

# 绘制特征重要性比较图
robust_importance.plot_importance_comparison()

# 绘制稳健特征重要性图
robust_importance.plot_robust_importance()

# 比较不同模型和方法的特征重要性排名
print("\n=== 不同模型和方法的特征重要性排名比较 ===")

for model_name in models:
    print(f"\n--- {model_name} ---")
    
    # 模型内置重要性排名
    model_importance = robust_importance.compute_model_importance(model_name)
    model_importance = model_importance.sort_values(by='Importance', ascending=False)
    print(f"模型内置重要性 Top 5：{', '.join(model_importance['Feature'].head(5))}")
    
    # 置换重要性排名
    perm_importance = robust_importance.compute_permutation_importance(model_name)
    perm_importance = perm_importance.sort_values(by='Importance', ascending=False)
    print(f"置换重要性 Top 5：{', '.join(perm_importance['Feature'].head(5))}")
    
    # SHAP重要性排名
    shap_importance = robust_importance.compute_shap_importance(model_name)
    shap_importance = shap_importance.sort_values(by='Importance', ascending=False)
    print(f"SHAP重要性 Top 5：{', '.join(shap_importance['Feature'].head(5))}")

# 稳健排名
print(f"\n--- 稳健特征重要性排名 ---")
print(f"稳健重要性 Top 5：{', '.join(robust_results['Feature'].head(5))}")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import dowhy
from dowhy import CausalModel
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 生成具有因果关系的模拟数据
def generate_causal_data(n_samples=1000, seed=42):
    np.random.seed(seed)
    
    # 外生变量（没有父节点的变量）
    age = np.random.normal(40, 10, n_samples)  # 年龄
    income = np.random.normal(50000, 15000, n_samples)  # 收入
    education = np.random.choice(['高中', '本科', '硕士', '博士'], n_samples, p=[0.3, 0.4, 0.2, 0.1])  # 教育程度
    
    # 将教育程度转换为数值
    education_map = {'高中': 0, '本科': 1, '硕士': 2, '博士': 3}
    education_num = np.array([education_map[edu] for edu in education])
    
    # 内生变量（有父节点的变量）
    # 信用评分：受年龄、收入、教育程度影响
    credit_score = 300 + 0.5 * age + 0.001 * income + 50 * education_num + np.random.normal(0, 50, n_samples)
    credit_score = np.clip(credit_score, 300, 850)  # 限制在300-850之间
    
    # 债务收入比：受收入和信用评分影响
    dti = 0.1 + 0.00001 * (100000 - income) + 0.0005 * credit_score + np.random.normal(0, 0.1, n_samples)
    dti = np.clip(dti, 0, 1)  # 限制在0-1之间
    
    # 申请金额：受收入、信用评分、债务收入比影响
    loan_amount = 5000 + 0.1 * income + 10 * credit_score - 10000 * dti + np.random.normal(0, 1000, n_samples)
    loan_amount = np.clip(loan_amount, 1000, 100000)  # 限制在1000-100000之间
    
    # 违约概率：受信用评分、债务收入比、申请金额影响（真正的因果关系）
    # 注意：年龄、收入、教育程度通过影响信用评分等间接影响违约概率
    default_prob = 0.5 - 0.001 * credit_score + 2 * dti + 0.00005 * loan_amount + np.random.normal(0, 0.1, n_samples)
    default_prob = np.clip(default_prob, 0.01, 0.99)  # 限制在0.01-0.99之间
    
    # 违约标签：基于违约概率生成
    default = np.random.binomial(1, default_prob, n_samples)
    
    # 创建数据框
    data = pd.DataFrame({
        'age': age,
        'income': income,
        'education': education_num,
        'credit_score': credit_score,
        'dti': dti,
        'loan_amount': loan_amount,
        'default': default
    })
    
    return data

# 生成数据
data = generate_causal_data()
print("生成的数据示例：")
print(data.head())

# 划分特征和标签
X = data.drop('default', axis=1)
y = data['default']
feature_names = X.columns.tolist()

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练模型
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 模型准确率
accuracy = accuracy_score(y_test, model.predict(X_test))
print(f"模型准确率: {accuracy:.4f}")

# 传统特征重要性（基于相关性）
print("\n=== 传统特征重要性（基于模型） ===")
traditional_importance = pd.DataFrame({
    'Feature': feature_names,
    'Importance': model.feature_importances_
})
traditional_importance = traditional_importance.sort_values(by='Importance', ascending=False)
print(traditional_importance)

# 因果特征重要性分析
print("\n=== 因果特征重要性分析 ===")

# 步骤1：构建因果图
# 根据我们的生成模型，构建因果图
causal_graph = """
digraph {
    age -> credit_score;
    income -> credit_score;
    income -> dti;
    education -> credit_score;
    credit_score -> default;
    credit_score -> dti;
    credit_score -> loan_amount;
    dti -> default;
    dti -> loan_amount;
    loan_amount -> default;
}
"""

# 步骤2：创建因果模型
causal_model = CausalModel(
    data=data,
    treatment=None,  # 这里我们分析所有特征的因果重要性，所以不指定特定处理变量
    outcome='default',
    graph=causal_graph
)

# 步骤3：识别因果效应
identified_estimand = causal_model.identify_effect()

# 步骤4：计算每个特征的因果重要性
# 对于每个特征，我们将其视为处理变量，计算其对结果的因果效应
causal_importance_results = []

for feature in feature_names:
    print(f"\n分析特征: {feature}")
    
    # 设置当前特征为处理变量
    causal_model.treatment = feature
    
    # 识别因果效应
    identified_estimand = causal_model.identify_effect()
    
    # 估计平均因果效应（ATE）
    try:
        estimate = causal_model.estimate_effect(
            identified_estimand,
            method_name="backdoor.linear_regression"
        )
        
        causal_importance_results.append({
            'Feature': feature,
            'ATE': estimate.value,
            'ATE_Std': estimate.get_standard_error() if hasattr(estimate, 'get_standard_error') else 0,
            'Method': 'Linear Regression ATE'
        })
        
        print(f"ATE: {estimate.value:.4f}")
    except Exception as e:
        print(f"估计ATE失败: {e}")
        continue

# 创建因果重要性数据框
causal_importance = pd.DataFrame(causal_importance_results)

# 计算因果重要性绝对值（不考虑方向）
causal_importance['Causal_Importance'] = np.abs(causal_importance['ATE'])

# 按因果重要性排序
causal_importance = causal_importance.sort_values(by='Causal_Importance', ascending=False)

print("\n=== 因果特征重要性结果 ===")
print(causal_importance[['Feature', 'Causal_Importance', 'ATE']])

# 比较传统特征重要性和因果特征重要性
print("\n=== 传统特征重要性 vs 因果特征重要性 ===")

comparison = pd.merge(
    traditional_importance[['Feature', 'Importance']],
    causal_importance[['Feature', 'Causal_Importance']],
    on='Feature',
    how='left'
)

# 归一化两种重要性以便比较
comparison['Traditional_Norm'] = comparison['Importance'] / comparison['Importance'].sum()
comparison['Causal_Norm'] = comparison['Causal_Importance'] / comparison['Causal_Importance'].sum()

# 按传统重要性排序
comparison = comparison.sort_values(by='Traditional_Norm', ascending=False)
print(comparison[['Feature', 'Traditional_Norm', 'Causal_Norm']])

# 可视化比较
plt.figure(figsize=(12, 8))

# 传统特征重要性
plt.subplot(2, 1, 1)
plt.barh(comparison['Feature'], comparison['Traditional_Norm'])
plt.xlabel('归一化传统重要性')
plt.title('传统特征重要性')

# 因果特征重要性
plt.subplot(2, 1, 2)
plt.barh(comparison['Feature'], comparison['Causal_Norm'])
plt.xlabel('归一化因果重要性')
plt.title('因果特征重要性')

plt.tight_layout()
plt.savefig('traditional_vs_causal_importance.png')
print("传统vs因果特征重要性比较图已保存为 traditional_vs_causal_importance.png")

# 分析差异
print("\n=== 重要性差异分析 ===")

# 计算差异
comparison['Difference'] = comparison['Traditional_Norm'] - comparison['Causal_Norm']

# 找出差异最大的特征
max_diff_feature = comparison.loc[comparison['Difference'].abs().idxmax()]
print(f"差异最大的特征: {max_diff_feature['Feature']}")
print(f"传统重要性: {max_diff_feature['Traditional_Norm']:.4f}")
print(f"因果重要性: {max_diff_feature['Causal_Norm']:.4f}")
print(f"差异: {max_diff_feature['Difference']:.4f}")

# 解释差异
if max_diff_feature['Difference'] > 0:
    print(f"解释: {max_diff_feature['Feature']} 在传统重要性中被高估，因为它与结果高度相关，但实际上通过其他特征间接影响结果。")
else:
    print(f"解释: {max_diff_feature['Feature']} 在传统重要性中被低估，因为它直接影响结果，但与其他特征相关性较低。")

# 基于因果重要性的特征选择
print("\n=== 基于因果重要性的特征选择 ===")

# 选择因果重要性大于0.1的特征（示例阈值）
causal_threshold = causal_importance['Causal_Importance'].quantile(0.5)  # 中位数作为阈值
print(f"因果重要性阈值: {causal_threshold:.4f}")

selected_features = causal_importance[causal_importance['Causal_Importance'] >= causal_threshold]['Feature'].tolist()
print(f"基于因果重要性选择的特征: {selected_features}")

# 使用选择的特征重新训练模型
X_train_selected = X_train[selected_features]
X_test_selected = X_test[selected_features]

model_selected = RandomForestClassifier(n_estimators=100, random_state=42)
model_selected.fit(X_train_selected, y_train)

# 模型准确率
accuracy_selected = accuracy_score(y_test, model_selected.predict(X_test_selected))
print(f"使用选择特征的模型准确率: {accuracy_selected:.4f}")
print(f"与原模型准确率对比: {accuracy:.4f}")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import torch
import torch.nn as nn
import torch.optim as optim
from art.attacks.evasion import FastGradientMethod
from art.estimators.classification import PyTorchClassifier

# 加载数据集
data = load_breast_cancer()
X = data.data
y = data.target
feature_names = data.feature_names

# 数据预处理：归一化到[0, 1]范围
X = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义简单的神经网络模型
class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.softmax = nn.Softmax(dim=1)
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        x = self.softmax(x)
        return x

# 初始化模型
input_size = X.shape[1]
hidden_size = 32
output_size = 2
model = SimpleNN(input_size, hidden_size, output_size)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 转换数据为张量
X_train_tensor = torch.FloatTensor(X_train)
y_train_tensor = torch.LongTensor(y_train)
X_test_tensor = torch.FloatTensor(X_test)
y_test_tensor = torch.LongTensor(y_test)

# 训练模型
epochs = 50
train_losses = []
test_losses = []

for epoch in range(epochs):
    # 训练模式
    model.train()
    optimizer.zero_grad()
    outputs = model(X_train_tensor)
    loss = criterion(outputs, y_train_tensor)
    loss.backward()
    optimizer.step()
    train_losses.append(loss.item())
    
    # 评估模式
    model.eval()
    with torch.no_grad():
        test_outputs = model(X_test_tensor)
        test_loss = criterion(test_outputs, y_test_tensor)
        test_losses.append(test_loss.item())
    
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{epochs}], Train Loss: {loss.item():.4f}, Test Loss: {test_loss.item():.4f}')

# 模型准确率
model.eval()
with torch.no_grad():
    outputs = model(X_test_tensor)
    _, predicted = torch.max(outputs, 1)
    accuracy = accuracy_score(y_test, predicted)
    print(f"模型准确率: {accuracy:.4f}")

# 创建ART分类器
art_classifier = PyTorchClassifier(
    model=model,
    loss=criterion,
    input_shape=(input_size,),
    nb_classes=output_size,
    optimizer=optimizer
)

# FGSM攻击
print("\n=== FGSM攻击 ===")
epsilon = 0.1  # 扰动大小
attack = FastGradientMethod(estimator=art_classifier, eps=epsilon)

# 生成对抗样本
X_test_adv = attack.generate(x=X_test)

# 对抗样本准确率
model.eval()
with torch.no_grad():
    adv_outputs = model(torch.FloatTensor(X_test_adv))
    _, adv_predicted = torch.max(adv_outputs, 1)
    adv_accuracy = accuracy_score(y_test, adv_predicted)
    print(f"对抗样本准确率: {adv_accuracy:.4f}")
    print(f"准确率下降: {accuracy - adv_accuracy:.4f}")

# 安全特定特征重要性分析类
class SecurityFeatureImportance:
    def __init__(self, model, X_train, X_test, X_test_adv, y_train, y_test, feature_names):
        self.model = model
        self.X_train = X_train
        self.X_test = X_test
        self.X_test_adv = X_test_adv
        self.y_train = y_train
        self.y_test = y_test
        self.feature_names = feature_names
    
    def compute_normal_importance(self):
        """计算正常样本上的特征重要性"""
        # 使用置换重要性
        from sklearn.inspection import permutation_importance
        
        result = permutation_importance(
            lambda x: self.model(torch.FloatTensor(x)).detach().numpy(),
            self.X_test, self.y_test, 
            n_repeats=10, random_state=42
        )
        
        normal_importance = pd.DataFrame({
            'Feature': self.feature_names,
            'Importance': result.importances_mean,
            'Std': result.importances_std,
            'Type': 'Normal'
        })
        
        return normal_importance.sort_values(by='Importance', ascending=False)
    
    def compute_adversarial_importance(self):
        """计算对抗样本上的特征重要性"""
        from sklearn.inspection import permutation_importance
        
        result = permutation_importance(
            lambda x: self.model(torch.FloatTensor(x)).detach().numpy(),
            self.X_test_adv, self.y_test, 
            n_repeats=10, random_state=42
        )
        
        adversarial_importance = pd.DataFrame({
            'Feature': self.feature_names,
            'Importance': result.importances_mean,
            'Std': result.importances_std,
            'Type': 'Adversarial'
        })
        
        return adversarial_importance.sort_values(by='Importance', ascending=False)
    
    def compute_vulnerability_score(self):
        """计算特征脆弱性分数"""
        # 计算正常和对抗重要性
        normal_importance = self.compute_normal_importance()
        adversarial_importance = self.compute_adversarial_importance()
        
        # 合并结果
        combined = pd.merge(
            normal_importance[['Feature', 'Importance']],
            adversarial_importance[['Feature', 'Importance']],
            on='Feature',
            suffixes=('_normal', '_adversarial')
        )
        
        # 计算脆弱性分数：重要性变化率
        combined['Vulnerability_Score'] = abs(combined['Importance_adversarial'] - combined['Importance_normal']) / (combined['Importance_normal'] + 1e-8)
        
        # 计算鲁棒性分数：对抗重要性与正常重要性的比值
        combined['Robustness_Score'] = combined['Importance_adversarial'] / (combined['Importance_normal'] + 1e-8)
        
        return combined.sort_values(by='Vulnerability_Score', ascending=False)
    
    def compute_feature_sensitivity(self, epsilon=0.1):
        """计算特征对扰动的敏感性"""
        sensitivity_scores = []
        
        for i, feature in enumerate(self.feature_names):
            # 复制测试集
            X_test_perturbed = self.X_test.copy()
            
            # 对当前特征添加扰动
            X_test_perturbed[:, i] += np.random.normal(0, epsilon, size=X_test_perturbed.shape[0])
            
            # 限制在[0, 1]范围内
            X_test_perturbed[:, i] = np.clip(X_test_perturbed[:, i], 0, 1)
            
            # 预测原始和扰动样本
            with torch.no_grad():
                original_pred = self.model(torch.FloatTensor(self.X_test)).detach().numpy()
                perturbed_pred = self.model(torch.FloatTensor(X_test_perturbed)).detach().numpy()
            
            # 计算预测变化
            pred_change = np.mean(np.abs(perturbed_pred - original_pred))
            
            sensitivity_scores.append({
                'Feature': feature,
                'Sensitivity': pred_change
            })
        
        sensitivity_df = pd.DataFrame(sensitivity_scores)
        return sensitivity_df.sort_values(by='Sensitivity', ascending=False)
    
    def get_security_importance(self):
        """获取安全特定特征重要性"""
        # 计算各种重要性
        normal_importance = self.compute_normal_importance()
        adversarial_importance = self.compute_adversarial_importance()
        vulnerability = self.compute_vulnerability_score()
        sensitivity = self.compute_feature_sensitivity()
        
        # 合并所有重要性
        security_importance = pd.merge(
            vulnerability[['Feature', 'Vulnerability_Score', 'Robustness_Score']],
            sensitivity[['Feature', 'Sensitivity']],
            on='Feature'
        )
        
        # 归一化各项指标
        security_importance['Vulnerability_Norm'] = security_importance['Vulnerability_Score'] / security_importance['Vulnerability_Score'].sum()
        security_importance['Robustness_Norm'] = security_importance['Robustness_Score'] / security_importance['Robustness_Score'].sum()
        security_importance['Sensitivity_Norm'] = security_importance['Sensitivity'] / security_importance['Sensitivity'].sum()
        
        # 计算综合安全重要性（示例权重：脆弱性0.4，鲁棒性0.3，敏感性0.3）
        security_importance['Security_Importance'] = (
            0.4 * security_importance['Vulnerability_Norm'] +
            0.3 * security_importance['Robustness_Norm'] +
            0.3 * security_importance['Sensitivity_Norm']
        )
        
        return security_importance.sort_values(by='Security_Importance', ascending=False)
    
    def plot_security_importance(self):
        """绘制安全特定特征重要性"""
        security_importance = self.get_security_importance()
        
        # 绘制前10个重要特征
        top_features = security_importance.head(10)
        
        plt.figure(figsize=(15, 12))
        
        # 1. 脆弱性分数
        plt.subplot(2, 2, 1)
        plt.barh(top_features['Feature'], top_features['Vulnerability_Score'])
        plt.xlabel('脆弱性分数')
        plt.title('特征脆弱性（越高越脆弱）')
        plt.gca().invert_yaxis()
        
        # 2. 鲁棒性分数
        plt.subplot(2, 2, 2)
        plt.barh(top_features['Feature'], top_features['Robustness_Score'])
        plt.xlabel('鲁棒性分数')
        plt.title('特征鲁棒性（越高越鲁棒）')
        plt.gca().invert_yaxis()
        
        # 3. 敏感性分数
        plt.subplot(2, 2, 3)
        plt.barh(top_features['Feature'], top_features['Sensitivity'])
        plt.xlabel('敏感性分数')
        plt.title('特征敏感性（越高越敏感）')
        plt.gca().invert_yaxis()
        
        # 4. 综合安全重要性
        plt.subplot(2, 2, 4)
        plt.barh(top_features['Feature'], top_features['Security_Importance'])
        plt.xlabel('综合安全重要性')
        plt.title('综合安全特征重要性（Top 10）')
        plt.gca().invert_yaxis()
        
        plt.tight_layout()
        plt.savefig('security_feature_importance.png')
        print("安全特征重要性图已保存为 security_feature_importance.png")

# 创建安全特征重要性分析实例
security_importance = SecurityFeatureImportance(
    model, X_train, X_test, X_test_adv, y_train, y_test, feature_names
)

# 计算正常样本上的特征重要性
normal_importance = security_importance.compute_normal_importance()
print("\n=== 正常样本特征重要性（Top 10） ===")
print(normal_importance.head(10))

# 计算对抗样本上的特征重要性
adversarial_importance = security_importance.compute_adversarial_importance()
print("\n=== 对抗样本特征重要性（Top 10） ===")
print(adversarial_importance.head(10))

# 计算特征脆弱性
vulnerability = security_importance.compute_vulnerability_score()
print("\n=== 特征脆弱性分数（Top 10） ===")
print(vulnerability.head(10))

# 计算特征敏感性
feature_sensitivity = security_importance.compute_feature_sensitivity()
print("\n=== 特征敏感性分数（Top 10） ===")
print(feature_sensitivity.head(10))

# 获取综合安全重要性
security_imp = security_importance.get_security_importance()
print("\n=== 综合安全特征重要性（Top 10） ===")
print(security_imp.head(10))

# 绘制安全特征重要性图
security_importance.plot_security_importance()

# 基于安全重要性的特征选择
print("\n=== 基于安全重要性的特征选择 ===")

# 选择安全重要性高且鲁棒性强的特征
# 例如：选择安全重要性前10且鲁棒性分数>0.5的特征
selected_features = security_imp[
    (security_imp['Security_Importance'] >= security_imp['Security_Importance'].quantile(0.5)) &
    (security_imp['Robustness_Score'] > 0.5)
]['Feature'].tolist()

print(f"基于安全重要性选择的特征: {selected_features}")
print(f"选择的特征数量: {len(selected_features)}")

# 使用选择的特征重新训练模型
if len(selected_features) > 0:
    # 获取特征索引
    feature_indices = [feature_names.index(f) for f in selected_features]
    
    # 选择特征
    X_train_selected = X_train[:, feature_indices]
    X_test_selected = X_test[:, feature_indices]
    X_test_adv_selected = X_test_adv[:, feature_indices]
    
    # 重新定义模型
    input_size_selected = len(selected_features)
    model_selected = SimpleNN(input_size_selected, hidden_size, output_size)
    
    # 重新初始化优化器
    optimizer_selected = optim.Adam(model_selected.parameters(), lr=0.001)
    
    # 转换数据
    X_train_selected_tensor = torch.FloatTensor(X_train_selected)
    X_test_selected_tensor = torch.FloatTensor(X_test_selected)
    X_test_adv_selected_tensor = torch.FloatTensor(X_test_adv_selected)
    
    # 重新训练模型
    print("\n重新训练模型...")
    for epoch in range(epochs):
        model_selected.train()
        optimizer_selected.zero_grad()
        outputs = model_selected(X_train_selected_tensor)
        loss = criterion(outputs, y_train_tensor)
        loss.backward()
        optimizer_selected.step()
    
    # 评估模型
    model_selected.eval()
    with torch.no_grad():
        # 正常样本准确率
        selected_outputs = model_selected(X_test_selected_tensor)
        _, selected_predicted = torch.max(selected_outputs, 1)
        selected_accuracy = accuracy_score(y_test, selected_predicted)
        
        # 对抗样本准确率
        selected_adv_outputs = model_selected(X_test_adv_selected_tensor)
        _, selected_adv_predicted = torch.max(selected_adv_outputs, 1)
        selected_adv_accuracy = accuracy_score(y_test, selected_adv_predicted)
    
    print(f"\n选择特征后的模型性能：")
    print(f"正常样本准确率: {selected_accuracy:.4f}")
    print(f"对抗样本准确率: {selected_adv_accuracy:.4f}")
    print(f"准确率下降: {selected_accuracy - selected_adv_accuracy:.4f}")
    
    print(f"\n与原模型对比：")
    print(f"原模型正常准确率: {accuracy:.4f}")
    print(f"原模型对抗准确率: {adv_accuracy:.4f}")
    print(f"原模型准确率下降: {accuracy - adv_accuracy:.4f}")

# 安装基本依赖
pip install numpy pandas scikit-learn matplotlib seaborn

# 安装特征重要性评估库
pip install shap lime interpret captum alibi

# 安装因果推断库
pip install dowhy causality causalnex

# 安装对抗攻击库
pip install adversarial-robustness-toolbox

# 安装深度学习框架
pip install torch tensorflow