无监督结果如何评估：安全攻防中的无监督模型评价体系

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans, DBSCAN
from sklearn.metrics import silhouette_score, calinski_harabasz_score, davies_bouldin_score, adjusted_rand_score, normalized_mutual_info_score

# 生成示例聚类数据
X, y_true = make_blobs(n_samples=500, centers=3, n_features=10, random_state=42)

# 1. 使用KMeans进行聚类
kmeans = KMeans(n_clusters=3, random_state=42)
y_pred_kmeans = kmeans.fit_predict(X)

# 2. 使用DBSCAN进行聚类
dbscan = DBSCAN(eps=1.5, min_samples=5)
y_pred_dbscan = dbscan.fit_predict(X)

# 3. 计算内部评估指标
def evaluate_clustering(X, y_pred, algorithm_name):
    print(f"\n{algorithm_name} 聚类评估结果:")
    
    # 计算轮廓系数
    if len(set(y_pred)) > 1:  # 至少需要2个簇才能计算轮廓系数
        silhouette = silhouette_score(X, y_pred)
        print(f"轮廓系数: {silhouette:.4f}")
    
    # 计算Calinski-Harabasz指数
    ch_score = calinski_harabasz_score(X, y_pred)
    print(f"Calinski-Harabasz指数: {ch_score:.4f}")
    
    # 计算Davies-Bouldin指数
    db_score = davies_bouldin_score(X, y_pred)
    print(f"Davies-Bouldin指数: {db_score:.4f}")
    
    return {
        'algorithm': algorithm_name,
        'silhouette': silhouette if len(set(y_pred)) > 1 else None,
        'ch_score': ch_score,
        'db_score': db_score
    }

# 评估KMeans和DBSCAN的聚类结果
kmeans_results = evaluate_clustering(X, y_pred_kmeans, "KMeans")
dbscan_results = evaluate_clustering(X, y_pred_dbscan, "DBSCAN")

# 4. 计算外部评估指标（使用真实标签）
print(f"\n外部评估指标（与真实标签对比）:")

# 调整兰德指数
ari_kmeans = adjusted_rand_score(y_true, y_pred_kmeans)
ari_dbscan = adjusted_rand_score(y_true, y_pred_dbscan)
print(f"KMeans 调整兰德指数: {ari_kmeans:.4f}")
print(f"DBSCAN 调整兰德指数: {ari_dbscan:.4f}")

# 归一化互信息
nmi_kmeans = normalized_mutual_info_score(y_true, y_pred_kmeans)
nmi_dbscan = normalized_mutual_info_score(y_true, y_pred_dbscan)
print(f"KMeans 归一化互信息: {nmi_kmeans:.4f}")
print(f"DBSCAN 归一化互信息: {nmi_dbscan:.4f}")

# 5. 可视化评估结果
results = [kmeans_results, dbscan_results]
algorithms = [result['algorithm'] for result in results]
silhouette_scores = [result['silhouette'] for result in results]
ch_scores = [result['ch_score'] for result in results]
db_scores = [result['db_score'] for result in results]

plt.figure(figsize=(15, 5))

# 轮廓系数对比
plt.subplot(1, 3, 1)
plt.bar(algorithms, silhouette_scores, color=['#FF4500', '#32CD32'])
plt.title('轮廓系数对比')
plt.ylabel('轮廓系数')
plt.ylim(0, 1)

# Calinski-Harabasz指数对比
plt.subplot(1, 3, 2)
plt.bar(algorithms, ch_scores, color=['#FF4500', '#32CD32'])
plt.title('Calinski-Harabasz指数对比')
plt.ylabel('Calinski-Harabasz指数')

# Davies-Bouldin指数对比
plt.subplot(1, 3, 3)
plt.bar(algorithms, db_scores, color=['#FF4500', '#32CD32'])
plt.title('Davies-Bouldin指数对比')
plt.ylabel('Davies-Bouldin指数')

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.ensemble import IsolationForest
from sklearn.neighbors import LocalOutlierFactor
from sklearn.metrics import roc_auc_score, precision_recall_curve, auc, accuracy_score, f1_score

# 生成示例异常检测数据
# 生成正常样本
X_normal, _ = make_blobs(n_samples=1000, centers=3, n_features=10, random_state=42)
# 生成异常样本
X_anomaly = np.random.randn(100, 10) * 3 + 10  # 远离正常样本的异常点

# 合并正常样本和异常样本
test_data = np.vstack([X_normal, X_anomaly])
y_true = np.array([0] * 1000 + [1] * 100)  # 0: 正常, 1: 异常

# 1. 使用Isolation Forest进行异常检测
iso = IsolationForest(contamination=0.09, random_state=42)
iso.fit(X_normal)
# 获取异常分数（需要转换为正数，数值越大越可能是异常）
iso_scores = -iso.decision_function(test_data)
y_pred_iso = (iso.predict(test_data) == -1).astype(int)

# 2. 使用Local Outlier Factor进行异常检测
lof = LocalOutlierFactor(n_neighbors=20, contamination=0.09)
# LOF直接提供异常分数（正数表示异常）
lof_scores = -lof._decision_function(test_data)
y_pred_lof = (lof.fit_predict(test_data) == -1).astype(int)

# 3. 评估异常检测结果
def evaluate_anomaly_detection(y_true, y_pred, scores, algorithm_name):
    print(f"\n{algorithm_name} 异常检测评估结果:")
    
    # 计算准确率
    accuracy = accuracy_score(y_true, y_pred)
    print(f"准确率: {accuracy:.4f}")
    
    # 计算F1分数
    f1 = f1_score(y_true, y_pred)
    print(f"F1分数: {f1:.4f}")
    
    # 计算AUROC
    auroc = roc_auc_score(y_true, scores)
    print(f"AUROC: {auroc:.4f}")
    
    # 计算AUPRC
    precision, recall, _ = precision_recall_curve(y_true, scores)
    auprc = auc(recall, precision)
    print(f"AUPRC: {auprc:.4f}")
    
    # 计算误报率和漏报率
    false_positive = np.sum((y_pred == 1) & (y_true == 0))
    false_negative = np.sum((y_pred == 0) & (y_true == 1))
    total_normal = np.sum(y_true == 0)
    total_anomaly = np.sum(y_true == 1)
    
    false_positive_rate = false_positive / total_normal
    false_negative_rate = false_negative / total_anomaly
    
    print(f"误报率: {false_positive_rate:.4f}")
    print(f"漏报率: {false_negative_rate:.4f}")
    
    return {
        'algorithm': algorithm_name,
        'accuracy': accuracy,
        'f1': f1,
        'auroc': auroc,
        'auprc': auprc,
        'false_positive_rate': false_positive_rate,
        'false_negative_rate': false_negative_rate
    }

# 评估Isolation Forest和LOF的异常检测结果
iso_results = evaluate_anomaly_detection(y_true, y_pred_iso, iso_scores, "Isolation Forest")
lof_results = evaluate_anomaly_detection(y_true, y_pred_lof, lof_scores, "Local Outlier Factor")

# 4. 可视化评估结果
results = [iso_results, lof_results]
algorithms = [result['algorithm'] for result in results]
auroc_scores = [result['auroc'] for result in results]
auprc_scores = [result['auprc'] for result in results]
fpr_scores = [result['false_positive_rate'] for result in results]
fnr_scores = [result['false_negative_rate'] for result in results]

plt.figure(figsize=(15, 10))

# AUROC和AUPRC对比
plt.subplot(2, 2, 1)
bar_width = 0.35
index = np.arange(len(algorithms))

bar1 = plt.bar(index, auroc_scores, bar_width, label='AUROC', color='#FF4500')
bar2 = plt.bar(index + bar_width, auprc_scores, bar_width, label='AUPRC', color='#32CD32')

plt.xlabel('算法')
plt.ylabel('分数')
plt.title('AUROC和AUPRC对比')
plt.xticks(index + bar_width / 2, algorithms)
plt.legend()

# 误报率对比
plt.subplot(2, 2, 2)
plt.bar(algorithms, fpr_scores, color=['#FF4500', '#32CD32'])
plt.title('误报率对比')
plt.ylabel('误报率')
plt.ylim(0, 0.5)

# 漏报率对比
plt.subplot(2, 2, 3)
plt.bar(algorithms, fnr_scores, color=['#FF4500', '#32CD32'])
plt.title('漏报率对比')
plt.ylabel('漏报率')
plt.ylim(0, 0.5)

# F1分数对比
plt.subplot(2, 2, 4)
plt.bar(algorithms, [result['f1'] for result in results], color=['#FF4500', '#32CD32'])
plt.title('F1分数对比')
plt.ylabel('F1分数')
plt.ylim(0, 1)

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.decomposition import PCA, KernelPCA
from sklearn.manifold import TSNE, UMAP
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 生成示例分类数据
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_redundant=10, random_state=42)

# 数据划分
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 1. 无监督表示学习方法
# PCA
pca = PCA(n_components=10, random_state=42)
pca.fit(X_train)
X_train_pca = pca.transform(X_train)
X_test_pca = pca.transform(X_test)

# Kernel PCA
kernel_pca = KernelPCA(n_components=10, kernel='rbf', random_state=42)
kernel_pca.fit(X_train)
X_train_kpca = kernel_pca.transform(X_train)
X_test_kpca = kernel_pca.transform(X_test)

# UMAP
umap = UMAP(n_components=10, random_state=42)
umap.fit(X_train)
X_train_umap = umap.transform(X_train)
X_test_umap = umap.transform(X_test)

# 2. 评估表示学习的质量：通过分类任务
# 在原始特征上训练分类器
lr_original = LogisticRegression(random_state=42)
lr_original.fit(X_train, y_train)
y_pred_original = lr_original.predict(X_test)
accuracy_original = accuracy_score(y_test, y_pred_original)

# 在PCA表示上训练分类器
lr_pca = LogisticRegression(random_state=42)
lr_pca.fit(X_train_pca, y_train)
y_pred_pca = lr_pca.predict(X_test_pca)
accuracy_pca = accuracy_score(y_test, y_pred_pca)

# 在Kernel PCA表示上训练分类器
lr_kpca = LogisticRegression(random_state=42)
lr_kpca.fit(X_train_kpca, y_train)
y_pred_kpca = lr_kpca.predict(X_test_kpca)
accuracy_kpca = accuracy_score(y_test, y_pred_kpca)

# 在UMAP表示上训练分类器
lr_umap = LogisticRegression(random_state=42)
lr_umap.fit(X_train_umap, y_train)
y_pred_umap = lr_umap.predict(X_test_umap)
accuracy_umap = accuracy_score(y_test, y_pred_umap)

# 3. 评估表示学习的质量：通过重构误差
# PCA重构误差
def compute_reconstruction_error(X, X_reconstructed):
    return np.mean(np.sum((X - X_reconstructed) ** 2, axis=1))

X_train_reconstructed_pca = pca.inverse_transform(X_train_pca)
reconstruction_error_pca = compute_reconstruction_error(X_train, X_train_reconstructed_pca)

# 4. 打印评估结果
print("表示学习评估结果:")
print(f"原始特征分类准确率: {accuracy_original:.4f}")
print(f"PCA表示分类准确率: {accuracy_pca:.4f}")
print(f"Kernel PCA表示分类准确率: {accuracy_kpca:.4f}")
print(f"UMAP表示分类准确率: {accuracy_umap:.4f}")
print(f"PCA重构误差: {reconstruction_error_pca:.4f}")

# 5. 可视化评估结果
methods = ['原始特征', 'PCA', 'Kernel PCA', 'UMAP']
accuracies = [accuracy_original, accuracy_pca, accuracy_kpca, accuracy_umap]

plt.figure(figsize=(12, 5))

# 分类准确率对比
plt.subplot(1, 2, 1)
plt.bar(methods, accuracies, color=['#FF4500', '#32CD32', '#4169E1', '#DA70D6'])
plt.title('不同表示的分类准确率对比')
plt.xlabel('表示方法')
plt.ylabel('分类准确率')
plt.ylim(0.8, 1.0)

# 添加数值标签
for i, v in enumerate(accuracies):
    plt.text(i, v + 0.005, f"{v:.4f}", ha='center', va='bottom')

# 可视化UMAP降维到2D的效果
umap_2d = UMAP(n_components=2, random_state=42)
umap_2d.fit(X_train)
X_train_umap_2d = umap_2d.transform(X_train)
X_test_umap_2d = umap_2d.transform(X_test)

plt.subplot(1, 2, 2)
plt.scatter(X_test_umap_2d[:, 0], X_test_umap_2d[:, 1], c=y_test, cmap='viridis', alpha=0.8)
plt.title('UMAP降维到2D的可视化效果')
plt.xlabel('UMAP维度1')
plt.ylabel('UMAP维度2')

plt.tight_layout()
plt.show()

# 安装必要的Python库
pip install numpy pandas scikit-learn matplotlib seaborn umap-learn