05 其他基础监督学习方法

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl

# Set professional plot style
mpl.rcParams.update({
    'font.size': 14,
    'axes.labelsize': 16,
    'axes.titlesize': 18,
    'xtick.labelsize': 12,
    'ytick.labelsize': 12,
    'legend.fontsize': 14,
    'figure.figsize': [10, 5.5],
    'font.family': 'sans-serif',
    'axes.spines.top': False,
    'axes.spines.right': False,
    'axes.grid': True,
    'grid.linestyle': '--',
    'grid.alpha': 0.6
})

def calculate_post_tax_income(pre_tax_income):
    # 2023 US Federal Tax Brackets for a single filer (simplified)
    brackets = [(0, 0.10), (11000, 0.12), (44725, 0.22), (95375, 0.24), (182100, 0.32), (231250, 0.35)]
    tax = 0
    income_left = pre_tax_income
    
    if income_left > brackets[-1][0]:
        tax += (income_left - brackets[-1][0]) * 0.37
        income_left = brackets[-1][0]
        
    for i in range(5, 0, -1):
        if income_left > brackets[i-1][0]:
            taxable_in_bracket = income_left - brackets[i-1][0]
            tax += taxable_in_bracket * brackets[i][1]
            income_left = brackets[i-1][0]
    
    tax += income_left * brackets[0][1]
    return pre_tax_income - tax

pre_tax_incomes = np.linspace(0, 250000, 500)
post_tax_incomes = np.array([calculate_post_tax_income(income) for income in pre_tax_incomes])
knots = [11000, 44725, 95375, 182100, 231250]  # Tax bracket boundaries
knot_post_tax = [calculate_post_tax_income(k) for k in knots]

fig, ax = plt.subplots()
ax.plot(pre_tax_incomes / 1000, post_tax_incomes / 1000, label='税后收入 (Post-Tax Income)', linewidth=2.5, color='#2980b9')
ax.plot(pre_tax_incomes / 1000, pre_tax_incomes / 1000, label='无税情况 (Pre-Tax Income)', linestyle='--', color='#7f8c8d', alpha=0.8)
ax.scatter(np.array(knots) / 1000, np.array(knot_post_tax) / 1000, color='#c0392b', zorder=5, label='税率变化点 (结点)')

ax.set_xlabel('税前收入 (千美元)')
ax.set_ylabel('收入 (千美元)')
ax.set_title('税前与税后收入关系：一个天然的样条函数')
ax.legend()
ax.set_xlim(0, 250)
ax.set_ylim(0, 250)
plt.show()

import numpy as np
from scipy.stats import norm
from scipy.interpolate import UnivariateSpline
import matplotlib.pyplot as plt
import matplotlib as mpl

# Set professional plot style for all subsequent plots
mpl.rcParams.update({
    'font.size': 14, 'axes.labelsize': 16, 'axes.titlesize': 18,
    'xtick.labelsize': 12, 'ytick.labelsize': 12, 'legend.fontsize': 14,
    'figure.figsize': [10, 5.5], 'font.family': 'sans-serif',
    'axes.spines.top': False, 'axes.spines.right': False,
    'axes.grid': True, 'grid.linestyle': '--', 'grid.alpha': 0.6
})

# 设置随机种子以保证结果可复现
np.random.seed(42)

# 生成x和y数据
x_synthetic = np.linspace(0, 10, 100)
y_synthetic = np.sin(x_synthetic) + norm.rvs(0, 0.2, size=x_synthetic.size)

# s参数控制平滑度，s越大越平滑
spline_synthetic = UnivariateSpline(x_synthetic, y_synthetic, s=0.5)

fig, ax = plt.subplots()
ax.scatter(x_synthetic, y_synthetic, label='原始数据点 (Synthetic Data)', color='navy', s=20, alpha=0.6)
ax.plot(x_synthetic, spline_synthetic(x_synthetic), label='平滑样条拟合 (Smoothing Spline)', color='orange', linewidth=3)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('平滑样条拟合合成数据')
ax.legend()
plt.show()

spline_overfit = UnivariateSpline(x_synthetic, y_synthetic, s=0.1)
spline_good = UnivariateSpline(x_synthetic, y_synthetic, s=1)
spline_underfit = UnivariateSpline(x_synthetic, y_synthetic, s=10)

fig, ax = plt.subplots()
ax.scatter(x_synthetic, y_synthetic, label='原始数据点', color='black', s=15, alpha=0.4)
ax.plot(x_synthetic, spline_overfit(x_synthetic), label='欠平滑 (s=0.1, 过拟合)', color='red', linestyle='--')
ax.plot(x_synthetic, spline_good(x_synthetic), label='适中平滑 (s=1)', color='green', linewidth=3)
ax.plot(x_synthetic, spline_underfit(x_synthetic), label='过度平滑 (s=10, 欠拟合)', color='blue', linestyle='-.')
ax.set_title('平滑参数 s 的影响')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.legend()
plt.show()

def hinge_loss(z): return np.maximum(0, 1 - z)
def log_loss(z): return np.log(1 + np.exp(-z))

z = np.linspace(-2, 3, 200)

fig, ax = plt.subplots(figsize=(8.5, 5))
ax.plot(z, hinge_loss(z), label='合页损失 (Hinge Loss)', color='#2980b9', linewidth=3)
ax.plot(z, log_loss(z), label='逻辑损失 (Log Loss)', color='#c0392b', linewidth=2, linestyle='--')
ax.axhline(0, color='black', linewidth=0.8)
ax.axvline(0, color='black', linewidth=0.8)
ax.axvline(1, color='grey', linewidth=1, linestyle=':')
ax.text(1, -0.2, '1', ha='center', fontsize=12)
ax.set_xlabel('$y \cdot f(x)$ (分类正确性得分)')
ax.set_ylabel('损失 (Loss)')
ax.set_title('损失函数对比')
ax.legend()
ax.set_ylim(-0.2, 3)
ax.set_xlim(-2, 3)
plt.show()

np.random.seed(0)
X_1d = np.sort(np.random.normal(0, 1, 100))
y_1d = (X_1d > -0.8) & (X_1d < 0.8)

fig, ax = plt.subplots(figsize=(10, 2))
ax.scatter(X_1d[y_1d == 0], np.zeros(np.sum(y_1d==0)), c='#c0392b', marker='x', s=60, label='类别 0', linewidth=1.5)
ax.scatter(X_1d[y_1d == 1], np.zeros(np.sum(y_1d==1)), c='#2980b9', marker='o', s=50, label='类别 1', alpha=0.8)
ax.set_yticks([])
ax.set_xlabel('x')
ax.set_title('一维空间中线性不可分的数据')
ax.legend(loc='center right')
ax.spines['left'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.grid(False)
plt.show()

X_2d = np.c_[X_1d, X_1d**2]

fig, ax = plt.subplots()
ax.scatter(X_2d[y_1d == 0, 0], X_2d[y_1d == 0, 1], c='#c0392b', marker='x', s=60, label='类别 0', linewidth=1.5)
ax.scatter(X_2d[y_1d == 1, 0], X_2d[y_1d == 1, 1], c='#2980b9', marker='o', s=50, label='类别 1', alpha=0.8)
x_line = np.linspace(-2.5, 2.5, 100)
y_line = np.full_like(x_line, 0.6)
ax.plot(x_line, y_line, color='#27ae60', label='决策边界', linewidth=3)
ax.set_xlabel('x')
ax.set_ylabel('$x^2$')
ax.set_title('映射到二维空间后数据变为线性可分')
ax.legend()
plt.show()

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_breast_cancer

# 加载数据
cancer = load_breast_cancer()
X = pd.DataFrame(cancer.data, columns=cancer.feature_names)
y = pd.Series(cancer.target)

# 为保持与原始幻灯片的一致性，我们只选择4个特征
fea_cols = ['mean radius', 'mean texture', 'mean perimeter', 'mean area']
X = X[fea_cols]

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
print('训练数据维度:', X_train.shape)

# 创建StandardScaler对象
scaler = StandardScaler()

# 在训练数据上拟合scaler并转换训练数据
X_train_scaled = scaler.fit_transform(X_train)

# 使用同一个scaler转换测试数据 (重要!)
X_test_scaled = scaler.transform(X_test)

# 为了方便查看，转换为DataFrame
X_train_scaled_df = pd.DataFrame(X_train_scaled, columns=fea_cols)
print('标准化后的训练数据（前5行）:')
print(X_train_scaled_df.head().round(4))

# 创建一个线性核的SVM分类器
clf_svm = SVC(kernel='linear', random_state=42)

# 在标准化的训练数据上训练模型
clf_svm.fit(X_train_scaled, y_train)

# 在测试集上进行预测
y_pred_svm = clf_svm.predict(X_test_scaled)

# 计算并打印准确率
accuracy_svm = accuracy_score(y_test, y_pred_svm)
print(f'线性SVM分类器的准确率: {accuracy_svm:.4f}')

# 创建一个K=5的KNN分类器
clf_knn = KNeighborsClassifier(n_neighbors=5)

# 在标准化的训练数据上训练模型
clf_knn.fit(X_train_scaled, y_train)

# 在测试集上进行预测
y_pred_knn = clf_knn.predict(X_test_scaled)

# 计算并打印准确率
accuracy_knn = accuracy_score(y_test, y_pred_knn)
print(f'KNN (K=5) 分类器的准确率: {accuracy_knn:.4f}')

gamma_values = [0.01, 0.1, 1, 5, 10, 20]
results = []

for g in gamma_values:
    clf_svm_rbf = SVC(kernel='rbf', gamma=g, random_state=42)
    clf_svm_rbf.fit(X_train_scaled, y_train)
    y_pred_rbf = clf_svm_rbf.predict(X_test_scaled)
    acc = accuracy_score(y_test, y_pred_rbf)
    results.append({'gamma': g, 'accuracy': f'{acc:.4f}'})

print(pd.DataFrame(results).to_string(index=False))

k_values = [1, 3, 6, 10, 20]
results_knn = []

for k in k_values:
    clf_knn_k = KNeighborsClassifier(n_neighbors=k)
    clf_knn_k.fit(X_train_scaled, y_train)
    y_pred_k = clf_knn_k.predict(X_test_scaled)
    acc_k = accuracy_score(y_test, y_pred_k)
    results_knn.append({'K (n_neighbors)': k, 'accuracy': f'{acc_k:.4f}'})

print(pd.DataFrame(results_knn).to_string(index=False))

# 欧几里得距离 (默认)
knn_euclidean = KNeighborsClassifier(n_neighbors=6, metric='euclidean')
knn_euclidean.fit(X_train_scaled, y_train)
y_pred_euc = knn_euclidean.predict(X_test_scaled)
acc_euc = accuracy_score(y_test, y_pred_euc)
print(f'KNN (K=6, 欧几里得距离) 准确率: {acc_euc:.4f}')

# 曼哈顿距离
knn_manhattan = KNeighborsClassifier(n_neighbors=6, metric='cityblock')
knn_manhattan.fit(X_train_scaled, y_train)
y_pred_man = knn_manhattan.predict(X_test_scaled)
acc_man = accuracy_score(y_test, y_pred_man)
print(f'KNN (K=6, 曼哈顿距离) 准确率: {acc_man:.4f}')