1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import xgboost as xgb
from sklearn.metrics import (confusion_matrix, precision_score, recall_score, 
                             f1_score, roc_auc_score, roc_curve, auc)
import matplotlib.pyplot as plt
import seaborn as sns

# 设置随机种子
np.random.seed(42)

# 生成模拟欺诈检测数据集
n_normal = 9970
n_fraud = 30
n_total = n_normal + n_fraud

# 正常交易特征
normal_data = {
    'amount': np.random.lognormal(3.5, 1.5, n_normal),
    'distance': np.random.exponential(100, n_normal),
    'time_diff': np.random.exponential(3600, n_normal),
    'transaction_count_24h': np.random.poisson(3, n_normal),
    'merchant_type': np.random.choice(['retail', 'online', 'atm'], n_normal, p=[0.5, 0.4, 0.1]),
    'device_type': np.random.choice(['mobile', 'card', 'atm'], n_normal, p=[0.3, 0.6, 0.1])
}

# 欺诈交易特征（异常特征）
fraud_data = {
    'amount': np.random.lognormal(4.5, 1.2, n_fraud),  # 更大金额
    'distance': np.random.exponential(500, n_fraud),    # 更大距离
    'time_diff': np.random.exponential(7200, n_fraud),  # 更大时间差
    'transaction_count_24h': np.random.poisson(8, n_fraud),  # 更多交易
    'merchant_type': np.random.choice(['online', 'retail'], n_fraud, p=[0.8, 0.2]),
    'device_type': np.random.choice(['mobile', 'atm'], n_fraud, p=[0.7, 0.3])
}

# 创建数据框
df_normal = pd.DataFrame(normal_data)
df_normal['is_fraud'] = 0

df_fraud = pd.DataFrame(fraud_data)
df_fraud['is_fraud'] = 1

df = pd.concat([df_normal, df_fraud], ignore_index=True)
df = df.sample(frac=1).reset_index(drop=True)

print(f"数据集大小: {len(df)}")
print(f"欺诈比例: {df['is_fraud'].mean():.2%}")
print(f"\n特征统计:\n{df.describe()}")

# 特征编码
df_encoded = df.copy()
df_encoded['merchant_type'] = pd.factorize(df_encoded['merchant_type'])[0]
df_encoded['device_type'] = pd.factorize(df_encoded['device_type'])[0]

# 分离特征和标签
X = df_encoded.drop('is_fraud', axis=1)
y = df_encoded['is_fraud']

# 分割数据集（8:2）
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, 
                                                      random_state=42, stratify=y)

print(f"\n训练集: {len(X_train)} 样本")
print(f"测试集: {len(X_test)} 样本")
print(f"训练集欺诈比例: {y_train.mean():.2%}")
print(f"测试集欺诈比例: {y_test.mean():.2%}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.metrics import classification_report

# 构建单一决策树
dt_model = DecisionTreeClassifier(
    max_depth=5,
    min_samples_split=10,
    min_samples_leaf=5,
    random_state=42
)

dt_model.fit(X_train, y_train)

# 预测
y_pred_dt = dt_model.predict(X_test)
y_pred_proba_dt = dt_model.predict_proba(X_test)[:, 1]

# 评估
print("=== 单一决策树模型 ===")
print("\n混淆矩阵:")
cm = confusion_matrix(y_test, y_pred_dt)
print(cm)

print("\n分类报告:")
print(classification_report(y_test, y_pred_dt, 
                           target_names=['正常', '欺诈']))

auc_dt = roc_auc_score(y_test, y_pred_proba_dt)
print(f"\nROC-AUC: {auc_dt:.4f}")

# 可视化树结构（仅显示前3层）
plt.figure(figsize=(20, 10))
plot_tree(dt_model, max_depth=3, feature_names=X.columns.tolist(),
          class_names=['正常', '欺诈'], filled=True)
plt.title("决策树结构（前3层）", fontsize=16, fontweight='bold')
plt.tight_layout()
plt.savefig('/Users/tov/Library/Mobile Documents/com~apple~CloudDocs/personal website/DoraemonJack.github.io/_posts/python_scripts/decision_tree_structure.png', dpi=150, bbox_inches='tight')
plt.close()

# 特征重要性
feature_importance_dt = pd.DataFrame({
    'feature': X.columns,
    'importance': dt_model.feature_importances_
}).sort_values('importance', ascending=False)

print("\n特征重要性:")
print(feature_importance_dt)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
from sklearn.ensemble import RandomForestClassifier

# 构建随机森林
rf_model = RandomForestClassifier(
    n_estimators=100,
    max_depth=10,
    min_samples_split=5,
    min_samples_leaf=2,
    max_features='sqrt',
    bootstrap=True,
    random_state=42,
    n_jobs=-1
)

rf_model.fit(X_train, y_train)

# 预测
y_pred_rf = rf_model.predict(X_test)
y_pred_proba_rf = rf_model.predict_proba(X_test)[:, 1]

# 评估
print("\n=== 随机森林模型 ===")
print("\n混淆矩阵:")
cm = confusion_matrix(y_test, y_pred_rf)
print(cm)

print("\n分类报告:")
print(classification_report(y_test, y_pred_rf, 
                           target_names=['正常', '欺诈']))

auc_rf = roc_auc_score(y_test, y_pred_proba_rf)
print(f"\nROC-AUC: {auc_rf:.4f}")

# 特征重要性
feature_importance_rf = pd.DataFrame({
    'feature': X.columns,
    'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False)

print("\n特征重要性:")
print(feature_importance_rf)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
import xgboost as xgb
from sklearn.model_selection import GridSearchCV

# 计算正例权重以处理类别不平衡
scale_pos_weight = (y_train == 0).sum() / (y_train == 1).sum()

# XGBoost参数网格（简化版）
param_grid = {
    'max_depth': [4, 5, 6],
    'learning_rate': [0.01, 0.05, 0.1],
    'n_estimators': [100, 200, 300],
    'subsample': [0.7, 0.8, 0.9],
    'colsample_bytree': [0.7, 0.8, 0.9],
}

# 基础XGBoost模型
base_xgb = xgb.XGBClassifier(
    scale_pos_weight=scale_pos_weight,
    eval_metric='auc',
    random_state=42,
    tree_method='hist'
)

# 网格搜索（注意：这会花费较长时间）
print("\n=== XGBoost模型参数调优 ===")
print("进行网格搜索...")

grid_search = GridSearchCV(
    base_xgb,
    param_grid,
    scoring='roc_auc',
    cv=5,
    n_jobs=-1,
    verbose=1
)

# 仅用部分参数进行演示（完整调优需要更长时间）
simplified_param_grid = {
    'max_depth': [5],
    'learning_rate': [0.05],
    'n_estimators': [200],
}

grid_search_simplified = GridSearchCV(
    base_xgb,
    simplified_param_grid,
    scoring='roc_auc',
    cv=3,
    n_jobs=-1,
    verbose=0
)

grid_search_simplified.fit(X_train, y_train)

print(f"最佳参数: {grid_search_simplified.best_params_}")
print(f"最佳CV得分: {grid_search_simplified.best_score_:.4f}")

# 使用最佳模型
xgb_best = grid_search_simplified.best_estimator_

# 预测
y_pred_xgb = xgb_best.predict(X_test)
y_pred_proba_xgb = xgb_best.predict_proba(X_test)[:, 1]

# 评估
print("\n=== XGBoost最优模型结果 ===")
print("\n混淆矩阵:")
cm = confusion_matrix(y_test, y_pred_xgb)
print(cm)
print(f"真正例 (TP): {cm[1,1]}")
print(f"假正例 (FP): {cm[0,1]}")
print(f"真负例 (TN): {cm[0,0]}")
print(f"假负例 (FN): {cm[1,0]}")

print("\n分类报告:")
print(classification_report(y_test, y_pred_xgb, 
                           target_names=['正常', '欺诈']))

auc_xgb = roc_auc_score(y_test, y_pred_proba_xgb)
print(f"\nROC-AUC: {auc_xgb:.4f}")

# 特征重要性
feature_importance_xgb = pd.DataFrame({
    'feature': X.columns,
    'importance': xgb_best.feature_importances_
}).sort_values('importance', ascending=False)

print("\n特征重要性:")
print(feature_importance_xgb)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
# 模型性能对比
models_comparison = pd.DataFrame({
    '模型': ['决策树', '随机森林', 'XGBoost'],
    'ROC-AUC': [auc_dt, auc_rf, auc_xgb],
    '精确率': [
        precision_score(y_test, y_pred_dt),
        precision_score(y_test, y_pred_rf),
        precision_score(y_test, y_pred_xgb)
    ],
    '召回率': [
        recall_score(y_test, y_pred_dt),
        recall_score(y_test, y_pred_rf),
        recall_score(y_test, y_pred_xgb)
    ],
    'F1-Score': [
        f1_score(y_test, y_pred_dt),
        f1_score(y_test, y_pred_rf),
        f1_score(y_test, y_pred_xgb)
    ]
})

print("\n=== 模型性能对比 ===")
print(models_comparison.to_string(index=False))

# ROC曲线绘制
plt.figure(figsize=(12, 8))

# 决策树
fpr_dt, tpr_dt, _ = roc_curve(y_test, y_pred_proba_dt)
plt.plot(fpr_dt, tpr_dt, label=f'决策树 (AUC = {auc_dt:.4f})', linewidth=2)

# 随机森林
fpr_rf, tpr_rf, _ = roc_curve(y_test, y_pred_proba_rf)
plt.plot(fpr_rf, tpr_rf, label=f'随机森林 (AUC = {auc_rf:.4f})', linewidth=2)

# XGBoost
fpr_xgb, tpr_xgb, _ = roc_curve(y_test, y_pred_proba_xgb)
plt.plot(fpr_xgb, tpr_xgb, label=f'XGBoost (AUC = {auc_xgb:.4f})', linewidth=2)

# 随机分类器
plt.plot([0, 1], [0, 1], 'k--', label='随机分类器 (AUC = 0.5000)', linewidth=1)

plt.xlabel('假正例率 (False Positive Rate)', fontsize=12)
plt.ylabel('真正例率 (True Positive Rate)', fontsize=12)
plt.title('模型ROC曲线对比', fontsize=14, fontweight='bold')
plt.legend(loc='lower right', fontsize=11)
plt.grid(alpha=0.3)
plt.tight_layout()
plt.savefig('/Users/tov/Library/Mobile Documents/com~apple~CloudDocs/personal website/DoraemonJack.github.io/_posts/python_scripts/roc_curves_comparison.png', dpi=150, bbox_inches='tight')
plt.close()

print("\nROC曲线已保存")

# 特征重要性对比
fig, axes = plt.subplots(1, 3, figsize=(16, 5))

# 决策树
feature_importance_dt.plot(x='feature', y='importance', kind='barh', ax=axes[0], color='steelblue')
axes[0].set_title('决策树 - 特征重要性', fontsize=12, fontweight='bold')
axes[0].set_xlabel('重要性')

# 随机森林
feature_importance_rf.plot(x='feature', y='importance', kind='barh', ax=axes[1], color='forestgreen')
axes[1].set_title('随机森林 - 特征重要性', fontsize=12, fontweight='bold')
axes[1].set_xlabel('重要性')

# XGBoost
feature_importance_xgb.plot(x='feature', y='importance', kind='barh', ax=axes[2], color='coral')
axes[2].set_title('XGBoost - 特征重要性', fontsize=12, fontweight='bold')
axes[2].set_xlabel('重要性')

plt.tight_layout()
plt.savefig('/Users/tov/Library/Mobile Documents/com~apple~CloudDocs/personal website/DoraemonJack.github.io/_posts/python_scripts/feature_importance_comparison.png', dpi=150, bbox_inches='tight')
plt.close()

print("特征重要性对比图已保存")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 混淆矩阵可视化
fig, axes = plt.subplots(1, 3, figsize=(15, 4))

models = ['决策树', '随机森林', 'XGBoost']
predictions = [y_pred_dt, y_pred_rf, y_pred_xgb]

for idx, (model_name, y_pred) in enumerate(zip(models, predictions)):
    cm = confusion_matrix(y_test, y_pred)
    
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[idx],
                xticklabels=['正常', '欺诈'],
                yticklabels=['正常', '欺诈'])
    
    axes[idx].set_title(f'{model_name}\n混淆矩阵', fontsize=12, fontweight='bold')
    axes[idx].set_ylabel('真实标签')
    axes[idx].set_xlabel('预测标签')

plt.tight_layout()
plt.savefig('/Users/tov/Library/Mobile Documents/com~apple~CloudDocs/personal website/DoraemonJack.github.io/_posts/python_scripts/confusion_matrices.png', dpi=150, bbox_inches='tight')
plt.close()

print("混淆矩阵可视化已保存")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
# 实际预测示例
print("\n=== 实际预测示例 ===")

# 创建示例交易
example_transactions = pd.DataFrame({
    'amount': [50.0, 5000.0],
    'distance': [10.0, 1000.0],
    'time_diff': [3600, 50000],
    'transaction_count_24h': [2, 15],
    'merchant_type': [0, 1],  # retail vs online
    'device_type': [0, 1]     # mobile vs card
})

example_transactions_encoded = example_transactions.copy()

# 预测
proba_dt = dt_model.predict_proba(example_transactions_encoded)[0]
proba_rf = rf_model.predict_proba(example_transactions_encoded)[0]
proba_xgb = xgb_best.predict_proba(example_transactions_encoded)[0]

results = pd.DataFrame({
    '模型': ['决策树', '随机森林', 'XGBoost'],
    '正常概率': [proba_dt[0], proba_rf[0], proba_xgb[0]],
    '欺诈概率': [proba_dt[1], proba_rf[1], proba_xgb[1]],
    '预测': ['正常' if p[1] < 0.5 else '欺诈' for p in [proba_dt, proba_rf, proba_xgb]]
})

print("\n交易 1: 金额$50, 距离10km, 最近24h交易2次 (正常交易)")
print(results)

# 创建可疑交易
example_transactions_fraud = pd.DataFrame({
    'amount': [5000.0],
    'distance': [5000.0],
    'time_diff': [100000],
    'transaction_count_24h': [20],
    'merchant_type': [1],
    'device_type': [1]
})

example_transactions_fraud_encoded = example_transactions_fraud.copy()

proba_dt_fraud = dt_model.predict_proba(example_transactions_fraud_encoded)[0]
proba_rf_fraud = rf_model.predict_proba(example_transactions_fraud_encoded)[0]
proba_xgb_fraud = xgb_best.predict_proba(example_transactions_fraud_encoded)[0]

results_fraud = pd.DataFrame({
    '模型': ['决策树', '随机森林', 'XGBoost'],
    '正常概率': [proba_dt_fraud[0], proba_rf_fraud[0], proba_xgb_fraud[0]],
    '欺诈概率': [proba_dt_fraud[1], proba_rf_fraud[1], proba_xgb_fraud[1]],
    '预测': ['正常' if p[1] < 0.5 else '欺诈' for p in [proba_dt_fraud, proba_rf_fraud, proba_xgb_fraud]]
})

print("\n交易 2: 金额$5000, 距离5000km, 最近24h交易20次 (可疑交易)")
print(results_fraud)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import shap

# 计算SHAP值用于XGBoost模型解释
print("\n=== 模型解释性分析（SHAP）===")

# 创建SHAP Explainer
explainer = shap.TreeExplainer(xgb_best)
shap_values = explainer.shap_values(X_test)

# 绘制SHAP汇总图
plt.figure(figsize=(12, 8))
shap.summary_plot(shap_values, X_test, plot_type="bar", show=False)
plt.title('SHAP特征重要性', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.savefig('/Users/tov/Library/Mobile Documents/com~apple~CloudDocs/personal website/DoraemonJack.github.io/_posts/python_scripts/shap_summary.png', dpi=150, bbox_inches='tight')
plt.close()

print("SHAP汇总图已保存")

# 绘制SHAP依赖图（最重要特征）
plt.figure(figsize=(12, 8))
shap.dependence_plot(0, shap_values, X_test, feature_names=X.columns.tolist(), show=False)
plt.title('SHAP依赖图 - 最重要特征', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.savefig('/Users/tov/Library/Mobile Documents/com~apple~CloudDocs/personal website/DoraemonJack.github.io/_posts/python_scripts/shap_dependence.png', dpi=150, bbox_inches='tight')
plt.close()

print("SHAP依赖图已保存")

# 选择一个欺诈案例进行详细解释
fraud_indices = y_test[y_test == 1].index
if len(fraud_indices) > 0:
    fraud_idx = fraud_indices[0]
    fraud_idx_in_test = list(X_test.index).index(fraud_idx)
    
    plt.figure(figsize=(12, 8))
    shap.force_plot(explainer.expected_value, 
                    shap_values[fraud_idx_in_test], 
                    X_test.iloc[fraud_idx_in_test],
                    feature_names=X.columns.tolist(),
                    matplotlib=True,
                    show=False)
    plt.title('单个欺诈交易的SHAP力图', fontsize=14, fontweight='bold')
    plt.tight_layout()
    plt.savefig('/Users/tov/Library/Mobile Documents/com~apple~CloudDocs/personal website/DoraemonJack.github.io/_posts/python_scripts/shap_force.png', dpi=150, bbox_inches='tight')
    plt.close()
    
    print("SHAP力图已保存")

print("\n分析完成！")