1
2
# 用整个数据集的均值和标准差缩放
X_all_scaled = (X_all - X_all.mean()) / X_all.std()

1
2
3
4
# 只用训练集的统计量
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # 学习 μ 和 σ
X_test_scaled = scaler.transform(X_test)        # 用学到的参数缩放测试集

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
import numpy as np
from scipy.special import expit  # sigmoid 函数
from scipy.optimize import minimize
import matplotlib.pyplot as plt

class LogisticRegression:
    """基础逻辑回归实现"""
    
    def __init__(self, learning_rate=0.01, iterations=1000, lambda_reg=0.0):
        """
        初始化逻辑回归模型
        
        参数：
            learning_rate: 学习率
            iterations: 最大迭代次数
            lambda_reg: L2正则化参数
        """
        self.lr = learning_rate
        self.iterations = iterations
        self.lambda_reg = lambda_reg
        self.weights = None
        self.bias = None
        self.losses = []
        
    def sigmoid(self, z):
        """Sigmoid 激活函数"""
        return expit(z)  # 数值稳定的实现
    
    def compute_loss(self, X, y):
        """计算交叉熵损失 + L2正则化"""
        m = X.shape[0]
        z = np.dot(X, self.weights) + self.bias
        p = self.sigmoid(z)
        
        # 避免 log(0)
        epsilon = 1e-15
        p = np.clip(p, epsilon, 1 - epsilon)
        
        # 交叉熵损失
        loss = -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
        
        # 添加 L2 正则化
        reg_loss = (self.lambda_reg / (2 * m)) * np.sum(self.weights ** 2)
        
        return loss + reg_loss
    
    def compute_gradients(self, X, y):
        """计算梯度"""
        m = X.shape[0]
        z = np.dot(X, self.weights) + self.bias
        p = self.sigmoid(z)
        
        # 梯度
        dw = np.dot(X.T, (p - y)) / m + (self.lambda_reg / m) * self.weights
        db = np.sum(p - y) / m
        
        return dw, db
    
    def fit(self, X, y, verbose=True):
        """
        训练模型
        
        参数：
            X: 特征矩阵 (n_samples, n_features)
            y: 标签向量 (n_samples,)
            verbose: 是否打印进度
        """
        m, n = X.shape
        
        # 初始化参数
        self.weights = np.zeros(n)
        self.bias = 0
        self.losses = []
        
        # 梯度下降
        for iteration in range(self.iterations):
            # 计算梯度
            dw, db = self.compute_gradients(X, y)
            
            # 更新参数
            self.weights -= self.lr * dw
            self.bias -= self.lr * db
            
            # 记录损失
            loss = self.compute_loss(X, y)
            self.losses.append(loss)
            
            if verbose and (iteration + 1) % 100 == 0:
                print(f"Iteration {iteration + 1}/{self.iterations}, Loss: {loss:.4f}")
        
        return self
    
    def predict_proba(self, X):
        """预测概率"""
        z = np.dot(X, self.weights) + self.bias
        return self.sigmoid(z)
    
    def predict(self, X, threshold=0.5):
        """预测类别"""
        proba = self.predict_proba(X)
        return (proba >= threshold).astype(int)
    
    def score(self, X, y):
        """计算准确率"""
        y_pred = self.predict(X)
        return np.mean(y_pred == y)


class LogisticRegressionWithOptimize:
    """使用 scipy.optimize 优化的实现"""
    
    def __init__(self, lambda_reg=0.0):
        self.weights = None
        self.bias = None
        self.lambda_reg = lambda_reg
    
    def sigmoid(self, z):
        return expit(z)
    
    def objective(self, params, X, y):
        """目标函数：损失函数"""
        m, n = X.shape
        w = params[:n]
        b = params[n]
        
        z = np.dot(X, w) + b
        p = self.sigmoid(z)
        
        epsilon = 1e-15
        p = np.clip(p, epsilon, 1 - epsilon)
        
        loss = -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
        reg = (self.lambda_reg / (2 * m)) * np.sum(w ** 2)
        
        return loss + reg
    
    def gradient(self, params, X, y):
        """目标函数的梯度"""
        m, n = X.shape
        w = params[:n]
        b = params[n]
        
        z = np.dot(X, w) + b
        p = self.sigmoid(z)
        
        dw = np.dot(X.T, (p - y)) / m + (self.lambda_reg / m) * w
        db = np.sum(p - y) / m
        
        return np.concatenate([dw, [db]])
    
    def fit(self, X, y):
        """使用 L-BFGS 优化器训练"""
        m, n = X.shape
        params0 = np.zeros(n + 1)
        
        result = minimize(
            self.objective,
            params0,
            args=(X, y),
            method='L-BFGS-B',
            jac=self.gradient,
            options={'disp': False}
        )
        
        self.weights = result.x[:n]
        self.bias = result.x[n]
        
        return self
    
    def predict_proba(self, X):
        z = np.dot(X, self.weights) + self.bias
        return self.sigmoid(z)
    
    def predict(self, X, threshold=0.5):
        proba = self.predict_proba(X)
        return (proba >= threshold).astype(int)
    
    def score(self, X, y):
        y_pred = self.predict(X)
        return np.mean(y_pred == y)


# 多分类逻辑回归 (Softmax)
class SoftmaxRegression:
    """多分类逻辑回归"""
    
    def __init__(self, learning_rate=0.01, iterations=1000, lambda_reg=0.0):
        self.lr = learning_rate
        self.iterations = iterations
        self.lambda_reg = lambda_reg
        self.weights = None  # shape: (n_features, n_classes)
        self.bias = None     # shape: (n_classes,)
        self.classes = None
        self.losses = []
    
    def softmax(self, z):
        """Softmax 函数"""
        # 数值稳定：减去最大值
        z_max = np.max(z, axis=1, keepdims=True)
        exp_z = np.exp(z - z_max)
        return exp_z / np.sum(exp_z, axis=1, keepdims=True)
    
    def fit(self, X, y):
        """训练多分类模型"""
        m, n = X.shape
        self.classes = np.unique(y)
        K = len(self.classes)
        
        # 将标签转换为 one-hot 编码
        y_onehot = np.zeros((m, K))
        for i, label in enumerate(self.classes):
            y_onehot[y == label, i] = 1
        
        # 初始化参数
        self.weights = np.random.randn(n, K) * 0.01
        self.bias = np.zeros(K)
        
        # 梯度下降
        for iteration in range(self.iterations):
            z = np.dot(X, self.weights) + self.bias
            p = self.softmax(z)
            
            # 计算梯度
            dw = np.dot(X.T, (p - y_onehot)) / m + (self.lambda_reg / m) * self.weights
            db = np.sum(p - y_onehot, axis=0) / m
            
            # 更新参数
            self.weights -= self.lr * dw
            self.bias -= self.lr * db
            
            # 计算损失
            loss = -np.mean(y_onehot * np.log(np.clip(p, 1e-15, 1)))
            self.losses.append(loss)
            
            if (iteration + 1) % 100 == 0:
                print(f"Iteration {iteration + 1}/{self.iterations}, Loss: {loss:.4f}")
        
        return self
    
    def predict_proba(self, X):
        """预测概率"""
        z = np.dot(X, self.weights) + self.bias
        return self.softmax(z)
    
    def predict(self, X):
        """预测类别"""
        proba = self.predict_proba(X)
        pred_indices = np.argmax(proba, axis=1)
        return self.classes[pred_indices]
    
    def score(self, X, y):
        """计算准确率"""
        y_pred = self.predict(X)
        return np.mean(y_pred == y)

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
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import classification_report, confusion_matrix, roc_curve, auc
import matplotlib.pyplot as plt

# 1. 基础使用
model = LogisticRegression(
    penalty='l2',           # 正则化类型：'l1', 'l2', 'elasticnet'
    C=1.0,                  # 正则化强度的倒数（C越小，正则化越强）
    solver='lbfgs',         # 优化器：'lbfgs', 'liblinear', 'saga', 'newton-cg'
    max_iter=1000,
    random_state=42
)

# 2. 多分类
model_multiclass = LogisticRegression(
    multi_class='multinomial',  # 多分类策略
    solver='lbfgs'
)

# 3. 处理不平衡数据
model_balanced = LogisticRegression(
    class_weight='balanced'  # 自动调整权重
)

# 4. 概率预测
y_proba = model.predict_proba(X_test)  # 返回每个类的概率

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
import pandas as pd
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import seaborn as sns

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

print(f"数据集大小: {X.shape}")
print(f"类别分布: {np.bincount(y)}")
print(f"特征名称:\n{feature_names}")

# 创建 DataFrame
df = pd.DataFrame(X, columns=feature_names)
df['target'] = y

# 基本统计
print("\n数据统计信息:")
print(df.describe())

# 可视化类别分布
plt.figure(figsize=(10, 4))

plt.subplot(1, 2, 1)
sns.countplot(x=df['target'])
plt.xlabel('诊断结果')
plt.ylabel('样本数')
plt.title('样本类别分布')
plt.xticks([0, 1], ['良性', '恶性'])

plt.subplot(1, 2, 2)
# 计算正负样本比例
n_negative = np.sum(y == 0)
n_positive = np.sum(y == 1)
plt.pie([n_negative, n_positive], labels=['良性', '恶性'], autopct='%1.1f%%')
plt.title('类别比例')

plt.tight_layout()
plt.show()

# 特征相关性分析
plt.figure(figsize=(15, 10))
correlation_matrix = df.corr()
sns.heatmap(correlation_matrix, cmap='coolwarm', center=0, annot=False)
plt.title('特征相关性矩阵')
plt.show()

# 前 10 个特征与目标的相关性
plt.figure(figsize=(10, 6))
target_corr = correlation_matrix['target'].drop('target').sort_values(ascending=False)
plt.barh(range(len(target_corr[:10])), target_corr[:10].values)
plt.yticks(range(len(target_corr[:10])), target_corr[:10].index)
plt.xlabel('与诊断结果的相关系数')
plt.title('前 10 个最相关的特征')
plt.tight_layout()
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 特征标准化（重要！）
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, 
    test_size=0.3,        # 70% 训练，30% 测试
    random_state=42,
    stratify=y            # 保持类别比例
)

print(f"训练集大小: {X_train.shape}")
print(f"测试集大小: {X_test.shape}")
print(f"训练集正负比例: {np.bincount(y_train)}")
print(f"测试集正负比例: {np.bincount(y_test)}")

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
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    confusion_matrix, classification_report, roc_curve, auc,
    precision_recall_curve
)

# 训练基础模型
print("="*60)
print("1. 基础逻辑回归模型")
print("="*60)

model_basic = LogisticRegression(
    max_iter=10000,
    random_state=42
)
model_basic.fit(X_train, y_train)

y_pred_basic = model_basic.predict(X_test)
y_proba_basic = model_basic.predict_proba(X_test)[:, 1]

print(f"训练集准确率: {model_basic.score(X_train, y_train):.4f}")
print(f"测试集准确率: {model_basic.score(X_test, y_test):.4f}")

# 详细评估指标
print("\n测试集评估指标:")
print(f"准确率 (Accuracy):  {accuracy_score(y_test, y_pred_basic):.4f}")
print(f"精准率 (Precision): {precision_score(y_test, y_pred_basic):.4f}")
print(f"召回率 (Recall):    {recall_score(y_test, y_pred_basic):.4f}")
print(f"F1 分数:            {f1_score(y_test, y_pred_basic):.4f}")

# 混淆矩阵
cm = confusion_matrix(y_test, y_pred_basic)
print("\n混淆矩阵:")
print(f"[[真负数 {cm[0,0]:3d}  假正数 {cm[0,1]:3d}]")
print(f" [假负数 {cm[1,0]:3d}  真正数 {cm[1,1]:3d}]]")

# 医学意义
tn, fp, fn, tp = cm.ravel()
sensitivity = tp / (tp + fn)  # 召回率（敏感度）
specificity = tn / (tn + fp)  # 特异性
print(f"\n医学指标:")
print(f"敏感度 (Sensitivity): {sensitivity:.4f}  (找到患者的比例)")
print(f"特异性 (Specificity): {specificity:.4f}  (正确识别健康人的比例)")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# ROC 曲线
fpr, tpr, thresholds = roc_curve(y_test, y_proba_basic)
roc_auc = auc(fpr, tpr)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC 曲线 (AUC = {roc_auc:.3f})')
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--', label='随机分类器')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('假正率 (False Positive Rate)')
plt.ylabel('真正率 (True Positive Rate)')
plt.title('ROC 曲线')
plt.legend(loc="lower right")
plt.grid(alpha=0.3)
plt.show()

print(f"AUC 分数: {roc_auc:.4f}")

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
print("\n" + "="*60)
print("2. 不同正则化强度的比较")
print("="*60)

# 不同的正则化参数
C_values = [0.001, 0.01, 0.1, 1, 10, 100]
results = []

for C in C_values:
    model = LogisticRegression(C=C, max_iter=10000, random_state=42)
    model.fit(X_train, y_train)
    
    train_acc = model.score(X_train, y_train)
    test_acc = model.score(X_test, y_test)
    
    results.append({
        'C': C,
        'train_acc': train_acc,
        'test_acc': test_acc
    })
    
    print(f"C={C:8.3f} | 训练准确率: {train_acc:.4f} | 测试准确率: {test_acc:.4f}")

# 可视化
results_df = pd.DataFrame(results)
plt.figure(figsize=(10, 6))
plt.semilogx(results_df['C'], results_df['train_acc'], 'o-', label='训练集', linewidth=2)
plt.semilogx(results_df['C'], results_df['test_acc'], 's-', label='测试集', linewidth=2)
plt.xlabel('正则化参数 C (越小正则化越强)')
plt.ylabel('准确率')
plt.title('正则化强度对模型性能的影响')
plt.legend()
plt.grid(alpha=0.3)
plt.show()

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
print("\n" + "="*60)
print("3. L1 vs L2 正则化对比")
print("="*60)

# L1 正则化
model_l1 = LogisticRegression(penalty='l1', solver='liblinear', C=1.0, max_iter=10000)
model_l1.fit(X_train, y_train)

# L2 正则化
model_l2 = LogisticRegression(penalty='l2', solver='lbfgs', C=1.0, max_iter=10000)
model_l2.fit(X_train, y_train)

print(f"L1 正则化 - 训练准确率: {model_l1.score(X_train, y_train):.4f}, 测试准确率: {model_l1.score(X_test, y_test):.4f}")
print(f"L2 正则化 - 训练准确率: {model_l2.score(X_train, y_train):.4f}, 测试准确率: {model_l2.score(X_test, y_test):.4f}")

# 特征权重稀疏性
n_zero_l1 = np.sum(model_l1.coef_[0] == 0)
n_zero_l2 = np.sum(model_l2.coef_[0] == 0)

print(f"\nL1 正则化 - 零权重特征数: {n_zero_l1}/{len(model_l1.coef_[0])}")
print(f"L2 正则化 - 零权重特征数: {n_zero_l2}/{len(model_l2.coef_[0])}")

# 可视化权重
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# L1
coef_l1_sorted_idx = np.argsort(np.abs(model_l1.coef_[0]))[-15:]
axes[0].barh(range(len(coef_l1_sorted_idx)), model_l1.coef_[0][coef_l1_sorted_idx])
axes[0].set_yticks(range(len(coef_l1_sorted_idx)))
axes[0].set_yticklabels([feature_names[i] for i in coef_l1_sorted_idx])
axes[0].set_xlabel('权重值')
axes[0].set_title('L1 正则化 - 权重最大的 15 个特征')
axes[0].axvline(x=0, color='k', linestyle='--', alpha=0.3)

# L2
coef_l2_sorted_idx = np.argsort(np.abs(model_l2.coef_[0]))[-15:]
axes[1].barh(range(len(coef_l2_sorted_idx)), model_l2.coef_[0][coef_l2_sorted_idx])
axes[1].set_yticks(range(len(coef_l2_sorted_idx)))
axes[1].set_yticklabels([feature_names[i] for i in coef_l2_sorted_idx])
axes[1].set_xlabel('权重值')
axes[1].set_title('L2 正则化 - 权重最大的 15 个特征')
axes[1].axvline(x=0, color='k', linestyle='--', alpha=0.3)

plt.tight_layout()
plt.show()

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
from sklearn.model_selection import cross_validate, cross_val_predict
from sklearn.metrics import make_scorer

# 5 折交叉验证
model_cv = LogisticRegression(max_iter=10000, random_state=42)

scoring = {
    'accuracy': 'accuracy',
    'precision': 'precision',
    'recall': 'recall',
    'f1': 'f1'
}

cv_results = cross_validate(model_cv, X_train, y_train, cv=5, scoring=scoring)

print("="*60)
print("4. 5 折交叉验证结果")
print("="*60)

for metric in ['accuracy', 'precision', 'recall', 'f1']:
    scores = cv_results[f'test_{metric}']
    print(f"{metric:12s}: {scores.mean():.4f} (+/- {scores.std():.4f})")

# 交叉验证预测
y_cv_pred = cross_val_predict(model_cv, X_train, y_train, cv=5)
print("\n交叉验证混淆矩阵:")
print(confusion_matrix(y_train, y_cv_pred))

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
from sklearn.calibration import calibration_curve, CalibratedClassifierCV

# 原始模型的校准曲线
prob_true_raw, prob_pred_raw = calibration_curve(
    y_test, y_proba_basic, n_bins=10
)

# 使用 Platt 缩放进行校准
calibrated_model = CalibratedClassifierCV(
    model_basic, 
    method='sigmoid',  # Platt 缩放
    cv=5
)
calibrated_model.fit(X_train, y_train)
y_proba_calibrated = calibrated_model.predict_proba(X_test)[:, 1]

prob_true_cal, prob_pred_cal = calibration_curve(
    y_test, y_proba_calibrated, n_bins=10
)

# 绘制校准曲线
fig, axes = plt.subplots(1, 2, figsize=(12, 5))

for ax, prob_true, prob_pred, title in [
    (axes[0], prob_true_raw, prob_pred_raw, '原始模型'),
    (axes[1], prob_true_cal, prob_pred_cal, '校准后模型')
]:
    ax.plot([0, 1], [0, 1], 'k--', label='理想校准')
    ax.plot(prob_pred, prob_true, 's-', label='实际校准')
    ax.set_xlabel('预测概率')
    ax.set_ylabel('实际概率')
    ax.set_title(title)
    ax.legend()
    ax.grid(alpha=0.3)
    ax.set_xlim([0, 1])
    ax.set_ylim([0, 1])

plt.tight_layout()
plt.show()

print("校准前后 AUC 对比:")
print(f"原始模型: {auc(fpr, tpr):.4f}")
fpr_cal, tpr_cal, _ = roc_curve(y_test, y_proba_calibrated)
print(f"校准模型: {auc(fpr_cal, tpr_cal):.4f}")

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
from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import RandomUnderSampler
from imblearn.pipeline import Pipeline as ImbPipeline

print("\n" + "="*60)
print("5. 不平衡数据处理")
print("="*60)

# 原始数据不平衡情况
print(f"原始训练集类别分布: {np.bincount(y_train)}")

# 方法 1：类权重
model_weighted = LogisticRegression(
    class_weight='balanced',
    max_iter=10000,
    random_state=42
)
model_weighted.fit(X_train, y_train)

print(f"\n方法 1: 类权重调整")
print(f"训练准确率: {model_weighted.score(X_train, y_train):.4f}")
print(f"测试准确率: {model_weighted.score(X_test, y_test):.4f}")

# 方法 2：SMOTE 过采样
smote = SMOTE(random_state=42)
X_train_smote, y_train_smote = smote.fit_resample(X_train, y_train)

model_smote = LogisticRegression(max_iter=10000, random_state=42)
model_smote.fit(X_train_smote, y_train_smote)

print(f"\n方法 2: SMOTE 过采样")
print(f"采样后训练集类别分布: {np.bincount(y_train_smote)}")
print(f"测试准确率: {model_smote.score(X_test, y_test):.4f}")

# 方法 3：组合过采样和欠采样
pipeline_smote = ImbPipeline([
    ('over', SMOTE(random_state=42)),
    ('under', RandomUnderSampler(random_state=42))
])
X_train_resampled, y_train_resampled = pipeline_smote.fit_resample(X_train, y_train)

model_combined = LogisticRegression(max_iter=10000, random_state=42)
model_combined.fit(X_train_resampled, y_train_resampled)

print(f"\n方法 3: SMOTE + 欠采样")
print(f"采样后训练集类别分布: {np.bincount(y_train_resampled)}")
print(f"测试准确率: {model_combined.score(X_test, y_test):.4f}")

# 对比三种方法
fig, axes = plt.subplots(1, 3, figsize=(15, 4))
models_compare = [
    (model_weighted, "类权重", axes[0]),
    (model_smote, "SMOTE", axes[1]),
    (model_combined, "SMOTE+欠采样", axes[2])
]

for model, title, ax in models_compare:
    y_pred_compare = model.predict(X_test)
    cm_compare = confusion_matrix(y_test, y_pred_compare)
    
    sns.heatmap(cm_compare, annot=True, fmt='d', ax=ax, cmap='Blues')
    ax.set_title(f'{title}\nAcc: {accuracy_score(y_test, y_pred_compare):.3f}')
    ax.set_ylabel('真实标签')
    ax.set_xlabel('预测标签')

plt.tight_layout()
plt.show()

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
# 最终模型权重分析
model_final = LogisticRegression(max_iter=10000, random_state=42)
model_final.fit(X_train, y_train)

# 获取权重
weights = model_final.coef_[0]
feature_importance = np.abs(weights)

# 排序
sorted_idx = np.argsort(feature_importance)[::-1]

# 绘制特征重要性
fig, ax = plt.subplots(figsize=(10, 8))
top_features_idx = sorted_idx[:15]
ax.barh(range(len(top_features_idx)), feature_importance[top_features_idx])
ax.set_yticks(range(len(top_features_idx)))
ax.set_yticklabels([feature_names[i] for i in top_features_idx])
ax.set_xlabel('特征权重绝对值')
ax.set_title('逻辑回归特征重要性（Top 15）')
ax.invert_yaxis()
plt.tight_layout()
plt.show()

print("最重要的 10 个特征:")
for i, idx in enumerate(sorted_idx[:10]):
    print(f"{i+1:2d}. {feature_names[idx]:30s} - 权重: {weights[idx]:7.4f}")

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
# 新患者的检查数据（需要标准化）
new_patient_raw = np.array([[17.99, 10.38, 122.80, 1001.0, 0.1184, 0.2776, 0.3001, 
                              0.1471, 0.2419, 0.07871, 1.095, 1.105, 8.589, 153.4, 
                              0.006399, 0.04904, 0.05373, 0.01587, 0.03003, 0.006193, 
                              25.38, 17.33, 184.6, 2019.0, 0.1622, 0.6656, 0.7119, 
                              0.2654, 0.4601, 0.11890]])

# 标准化
new_patient = scaler.transform(new_patient_raw)

# 预测
pred_class = model_final.predict(new_patient)[0]
pred_prob = model_final.predict_proba(new_patient)[0]

print("="*60)
print("患者诊断结果")
print("="*60)
print(f"预测类别: {'恶性' if pred_class == 1 else '良性'}")
print(f"良性概率: {pred_prob[0]:.1%}")
print(f"恶性概率: {pred_prob[1]:.1%}")

# 临床建议
if pred_prob[1] >= 0.8:
    print("\n临床建议: 强烈建议进一步深入检查和治疗")
elif pred_prob[1] >= 0.5:
    print("\n临床建议: 建议进一步医学检查确认")
else:
    print("\n临床建议: 暂无异常发现，建议定期复查")

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
import pickle
import json

# 保存模型
with open('logistic_regression_cancer_model.pkl', 'wb') as f:
    pickle.dump(model_final, f)

# 保存标准化器
with open('scaler.pkl', 'wb') as f:
    pickle.dump(scaler, f)

# 创建模型卡
model_card = {
    "model_name": "乳腺癌诊断逻辑回归模型",
    "version": "1.0",
    "performance": {
        "accuracy": float(model_final.score(X_test, y_test)),
        "auc": float(roc_auc),
        "sensitivity": float(tp / (tp + fn)),
        "specificity": float(tn / (tn + fp))
    },
    "features_used": len(feature_names),
    "training_data_size": len(X_train),
    "class_labels": ["良性", "恶性"]
}

with open('model_card.json', 'w') as f:
    json.dump(model_card, f, indent=2)

print("模型已保存！")
print(json.dumps(model_card, indent=2, ensure_ascii=False))