from sklearn.tree import export_graphviz, plot_tree

# 方式1：plot_tree（推荐，直接在 matplotlib 中显示）
plot_tree(model, feature_names=feature_names, class_names=class_names,
          filled=True, rounded=True)

# 方式2：导出为 Graphviz 格式（更美观，但需要安装 graphviz）
export_graphviz(model, out_file='tree.dot', feature_names=feature_names,
                class_names=class_names, filled=True, rounded=True)

from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(
    n_estimators=100,       # 树的数量（越多越好，但有收益递减）
    max_depth=None,         # 树的最大深度（None=不限制）
    min_samples_split=2,    # 分裂所需最小样本数
    min_samples_leaf=1,     # 叶节点最小样本数
    max_features='sqrt',    # 每次分裂考虑的特征数（分类默认 √p）
    bootstrap=True,         # 是否使用 Bootstrap 抽样
    oob_score=False,        # 是否计算 OOB 评分
    random_state=42,        # 随机种子
    n_jobs=-1,              # 并行训练的 CPU 核数
)

rf = RandomForestClassifier(oob_score=True, random_state=42)
rf.fit(X_train, y_train)
print(f"OOB 评分: {rf.oob_score_:.4f}")
# OOB 评分 ≈ 交叉验证评分，无需额外划分验证集

importances = rf.feature_importances_
for name, imp in sorted(zip(feature_names, importances), key=lambda x: -x[1]):
    print(f"{name}: {imp:.4f}")

from sklearn.inspection import permutation_importance

result = permutation_importance(rf, X_test, y_test, n_repeats=10, random_state=42)
for name, imp in sorted(zip(feature_names, result.importances_mean), key=lambda x: -x[1]):
    print(f"{name}: {imp:.4f}")

"""
Day 109 实战：信用风险评估
使用决策树和随机森林构建信用风险评估模型
"""

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.preprocessing import LabelEncoder
import matplotlib.pyplot as plt

# ========== 1. 生成模拟数据 ==========
np.random.seed(42)
n_samples = 1000

data = pd.DataFrame({
    'age': np.random.randint(22, 65, n_samples),
    'income': np.random.lognormal(mean=3, sigma=0.6, size=n_samples).round(2),
    'debt_ratio': np.random.beta(2, 5, n_samples).round(3),
    'credit_score': np.random.randint(300, 850, n_samples),
    'employment_years': np.random.poisson(5, n_samples),
    'loan_amount': np.random.lognormal(mean=2, sigma=0.8, size=n_samples).round(2),
    'has_mortgage': np.random.choice(['yes', 'no'], n_samples, p=[0.3, 0.7]),
    'education': np.random.choice(['high_school', 'bachelor', 'master', 'phd'],
                                   n_samples, p=[0.3, 0.4, 0.2, 0.1]),
})

# 生成标签（基于业务逻辑 + 噪声）
risk_score = (
    -0.3 * (data['income'] / data['income'].max())
    + 0.4 * data['debt_ratio']
    - 0.2 * (data['credit_score'] / data['credit_score'].max())
    - 0.1 * (data['employment_years'] / data['employment_years'].max())
    + 0.2 * (data['loan_amount'] / data['loan_amount'].max())
    + np.random.normal(0, 0.15, n_samples)
)
data['default'] = (risk_score > np.percentile(risk_score, 70)).astype(int)

print("=" * 60)
print("📊 信用风险评估数据集")
print("=" * 60)
print(f"样本数: {len(data)}")
print(f"违约率: {data['default'].mean():.2%}")
print(f"\n特征统计:")
print(data.describe().round(2))

# ========== 2. 特征工程 ==========
# 编码类别特征
le_mortgage = LabelEncoder()
data['has_mortgage_encoded'] = le_mortgage.fit_transform(data['has_mortgage'])

le_education = LabelEncoder()
data['education_encoded'] = le_education.fit_transform(data['education'])

feature_names = ['age', 'income', 'debt_ratio', 'credit_score',
                 'employment_years', 'loan_amount', 'has_mortgage', 'education']
X = data[['age', 'income', 'debt_ratio', 'credit_score',
          'employment_years', 'loan_amount', 'has_mortgage_encoded', 'education_encoded']]
y = data['default']

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)} 样本")

# ========== 3. 单棵决策树 ==========
print("\n" + "=" * 60)
print("🌳 单棵决策树")
print("=" * 60)

dt = DecisionTreeClassifier(max_depth=5, min_samples_split=20, random_state=42)
dt.fit(X_train, y_train)

train_score = dt.score(X_train, y_train)
test_score = dt.score(X_test, y_test)
print(f"训练集准确率: {train_score:.4f}")
print(f"测试集准确率: {test_score:.4f}")
print(f"过拟合差距: {train_score - test_score:.4f}")

print("\n分类报告:")
y_pred_dt = dt.predict(X_test)
print(classification_report(y_test, y_pred_dt, target_names=['正常', '违约']))

# ========== 4. 随机森林 ==========
print("=" * 60)
print("🌲 随机森林")
print("=" * 60)

rf = RandomForestClassifier(
    n_estimators=100,
    max_depth=None,
    min_samples_split=5,
    min_samples_leaf=2,
    max_features='sqrt',
    random_state=42,
    n_jobs=-1,
    oob_score=True
)
rf.fit(X_train, y_train)

train_score_rf = rf.score(X_train, X_train)
test_score_rf = rf.score(X_test, y_test)
print(f"训练集准确率: {train_score_rf:.4f}")
print(f"测试集准确率: {test_score_rf:.4f}")
print(f"OOB 评分: {rf.oob_score_:.4f}")

print("\n分类报告:")
y_pred_rf = rf.predict(X_test)
print(classification_report(y_test, y_pred_rf, target_names=['正常', '违约']))

# ========== 5. 交叉验证对比 ==========
print("=" * 60)
print("📊 交叉验证对比")
print("=" * 60)

cv_scores_dt = cross_val_score(dt, X, y, cv=5, scoring='f1')
cv_scores_rf = cross_val_score(rf, X, y, cv=5, scoring='f1')

print(f"决策树 F1: {cv_scores_dt.mean():.4f} ± {cv_scores_dt.std():.4f}")
print(f"随机森林 F1: {cv_scores_rf.mean():.4f} ± {cv_scores_rf.std():.4f}")

# ========== 6. 特征重要性 ==========
print("\n" + "=" * 60)
print("🔍 特征重要性 (随机森林)")
print("=" * 60)

importances = rf.feature_importances_
indices = np.argsort(importances)[::-1]

for i, idx in enumerate(indices):
    bar = "█" * int(importances[idx] * 50)
    print(f"{i+1}. {feature_names[idx]:20s} {importances[idx]:.4f} {bar}")

# ========== 7. 可视化 ==========
fig, axes = plt.subplots(1, 2, figsize=(16, 8))

# 决策树可视化
plot_tree(dt, feature_names=feature_names, class_names=['正常', '违约'],
          filled=True, rounded=True, ax=axes[0], max_depth=3, fontsize=8)
axes[0].set_title('决策树 (前3层)', fontsize=14)

# 特征重要性
axes[1].barh(range(len(feature_names)),
             importances[indices[::-1]], align='center')
axes[1].set_yticks(range(len(feature_names)))
axes[1].set_yticklabels([feature_names[i] for i in indices[::-1]])
axes[1].set_xlabel('重要性')
axes[1].set_title('特征重要性 (随机森林)', fontsize=14)

plt.tight_layout()
plt.savefig('day-109-visualization.png', dpi=150, bbox_inches='tight')
print("\n✅ 可视化已保存至 day-109-visualization.png")

# ========== 8. 混淆矩阵 ==========
from sklearn.metrics import ConfusionMatrixDisplay

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

ConfusionMatrixDisplay.from_estimator(dt, X_test, y_test,
    display_labels=['正常', '违约'], ax=axes[0], cmap='Blues')
axes[0].set_title('决策树 混淆矩阵')

ConfusionMatrixDisplay.from_estimator(rf, X_test, y_test,
    display_labels=['正常', '违约'], ax=axes[1], cmap='Greens')
axes[1].set_title('随机森林 混淆矩阵')

plt.tight_layout()
plt.savefig('day-109-confusion.png', dpi=150, bbox_inches='tight')
print("✅ 混淆矩阵已保存至 day-109-confusion.png")

print("\n🎉 信用风险评估实战完成!")