图片详情
—
Skip to content

demo_delaney_mlp.py ​

返回章节 · 配套代码说明

复制以下内容并保存为 demo_delaney_mlp.py,使用方法见配套代码说明。

python
"""案例一:用多层感知机预测有机小分子的水溶解度 log S(Delaney ESOL 数据集)。

比较两个模型:
1. 线性基线 [5, 1]:与第 2 章的线性单元相同;
2. 多层感知机 [5, 16, 8, 1]:Tanh 隐藏层 + 线性输出。
两者使用相同的 5 个描述符、相同的 80/20 随机划分和相同的标准化方式。

数据文件 delaney-processed.csv 来自 MoleculeNet 基准集,
可通过 DeepChem(dc.molnet.load_delaney)或 MoleculeNet 网站获取。
"""

import math
import random
import csv

from nn import MLP

# 绘图配色
COLORS = {
    "blue_dark": "#2878B5",
    "blue_light": "#9AC9DB",
    "orange_light": "#F8AC8C",
    "red_dark": "#C82423",
    "red_light": "#FF8884"
}


class SimpleStandardScaler:
    """纯 Python 特征标准化器(Z-score)。"""
    def __init__(self):
        self.mean = []
        self.std = []

    def fit(self, X):
        n = len(X)
        d = len(X[0])
        self.mean = [sum(X[i][j] for i in range(n)) / n for j in range(d)]
        self.std = [
            math.sqrt(sum((X[i][j] - self.mean[j]) ** 2 for i in range(n)) / n) + 1e-12
            for j in range(d)
        ]
        return self

    def transform(self, X):
        return [
            [(x[j] - self.mean[j]) / self.std[j] for j in range(len(x))]
            for x in X
        ]

    def fit_transform(self, X):
        return self.fit(X).transform(X)


DATA_FILE = "delaney-processed.csv"


def load_delaney_data(path=DATA_FILE):
    """读取 Delaney (ESOL) 水溶解度数据集,返回由字典组成的列表。"""
    with open(path, mode="r", encoding="utf-8") as f:
        return list(csv.DictReader(f))


def r2_score(y_true, y_pred):
    mean_y = sum(y_true) / len(y_true)
    ss_tot = sum((yt - mean_y) ** 2 for yt in y_true)
    ss_res = sum((yt - yp) ** 2 for yt, yp in zip(y_true, y_pred))
    return 1.0 - (ss_res / ss_tot) if ss_tot > 1e-12 else 0.0


def rmse_score(y_true, y_pred):
    return math.sqrt(sum((yt - yp) ** 2 for yt, yp in zip(y_true, y_pred)) / len(y_true))


def mae_score(y_true, y_pred):
    return sum(abs(yt - yp) for yt, yp in zip(y_true, y_pred)) / len(y_true)


def split_train_test(X, Y, test_ratio=0.2, seed=42):
    combined = list(zip(X, Y))
    rng = random.Random(seed)
    rng.shuffle(combined)
    split_idx = int(len(combined) * (1.0 - test_ratio))
    train = combined[:split_idx]
    test = combined[split_idx:]
    X_train, Y_train = [c[0] for c in train], [c[1] for c in train]
    X_test, Y_test = [c[0] for c in test], [c[1] for c in test]
    return X_train, X_test, Y_train, Y_test


def plot_results(y_test, y_pred_lin, y_pred_mlp, save_path):
    """绘制线性模型与 MLP 的测试集拟合散点对比图。"""
    try:
        import matplotlib
        matplotlib.use("Agg")
        import matplotlib.pyplot as plt

        plt.rcParams['font.sans-serif'] = ['DejaVu Sans', 'Arial']
        plt.rcParams['axes.unicode_minus'] = False

        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5.2), dpi=300)

        min_val = min(min(y_test), min(y_pred_lin), min(y_pred_mlp)) - 0.5
        max_val = max(max(y_test), max(y_pred_lin), max(y_pred_mlp)) + 0.5

        # 子图 1:线性单元基线 [5, 1]
        ax1.scatter(y_test, y_pred_lin, color=COLORS["blue_dark"], alpha=0.65, edgecolors='none', s=38, label="Linear Unit [5, 1]")
        ax1.plot([min_val, max_val], [min_val, max_val], color=COLORS["red_dark"], linestyle="--", linewidth=1.8, label="Ideal y = ŷ")
        ax1.set_xlim(min_val, max_val)
        ax1.set_ylim(min_val, max_val)
        ax1.set_xlabel(r"Experimental $\log_{10}[S/(\mathrm{mol\,L^{-1}})]$", fontsize=11, fontweight="bold")
        ax1.set_ylabel(r"Predicted $\log_{10}[S/(\mathrm{mol\,L^{-1}})]$", fontsize=11, fontweight="bold")
        ax1.set_title(f"Linear [5, 1]\nR² = {r2_score(y_test, y_pred_lin):.3f}, RMSE = {rmse_score(y_test, y_pred_lin):.3f}", fontsize=12, pad=10)
        ax1.grid(True, linestyle=":", alpha=0.5)
        ax1.legend(loc="upper left", frameon=True)

        # 子图 2:多层感知机 [5, 16, 8, 1]
        ax2.scatter(y_test, y_pred_mlp, color=COLORS["red_dark"], alpha=0.65, edgecolors='none', s=38, label="MLP [5, 16, 8, 1]")
        ax2.plot([min_val, max_val], [min_val, max_val], color=COLORS["blue_dark"], linestyle="--", linewidth=1.8, label="Ideal y = ŷ")
        ax2.set_xlim(min_val, max_val)
        ax2.set_ylim(min_val, max_val)
        ax2.set_xlabel(r"Experimental $\log_{10}[S/(\mathrm{mol\,L^{-1}})]$", fontsize=11, fontweight="bold")
        ax2.set_ylabel(r"Predicted $\log_{10}[S/(\mathrm{mol\,L^{-1}})]$", fontsize=11, fontweight="bold")
        ax2.set_title(f"MLP [5, 16, 8, 1]\nR² = {r2_score(y_test, y_pred_mlp):.3f}, RMSE = {rmse_score(y_test, y_pred_mlp):.3f}", fontsize=12, pad=10)
        ax2.grid(True, linestyle=":", alpha=0.5)
        ax2.legend(loc="upper left", frameon=True)

        plt.tight_layout()
        plt.savefig(save_path, format="png", dpi=300)
        plt.close()
        print(f"散点对比图已保存:{save_path}")
    except Exception as e:
        print(f"绘图失败(可能未安装 Matplotlib):{e}")


def main():
    print("=" * 72)
    print("Delaney ESOL 水溶解度预测:线性模型 [5, 1] 与 MLP [5, 16, 8, 1]")
    print("=" * 72)

    rows = load_delaney_data()
    print(f"读取分子数:{len(rows)}")

    # 特征字段:分子量 MW, 氢键给体 HBD, 环数 Rings, 旋转键 Rotatable Bonds, 极性表面积 PSA
    feature_keys = [
        "Molecular Weight",
        "Number of H-Bond Donors",
        "Number of Rings",
        "Number of Rotatable Bonds",
        "Polar Surface Area"
    ]
    target_key = "measured log solubility in mols per litre"

    X = [[float(r[k]) for k in feature_keys] for r in rows]
    Y_scalar = [float(r[target_key]) for r in rows]
    Y = [[y] for y in Y_scalar]

    # 1. 划分数据集(80% 训练,20% 测试,固定随机种子 42)
    X_train, X_test, Y_train, Y_test = split_train_test(X, Y, test_ratio=0.2, seed=42)
    y_train_flat = [y[0] for y in Y_train]
    y_test_flat = [y[0] for y in Y_test]
    print(f"训练集 {len(X_train)} 个,测试集 {len(X_test)} 个")

    # 2. 特征标准化:只用训练集的均值和标准差
    scaler = SimpleStandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    X_test_scaled = scaler.transform(X_test)

    # 3. 线性基线:无隐藏层的 [5, 1],与第 2 章的线性单元相同
    print("\n训练线性模型 [5, 1] ...")
    linear_net = MLP(
        [5, 1],
        hidden_activation="linear",
        output_activation="linear",
        loss="mse",
        seed=42
    )
    linear_net.train(
        X_train_scaled, Y_train,
        epochs=300, lr=0.03, batch_size=32, momentum=0.9, seed=42
    )

    # 4. 多层感知机:两个 Tanh 隐藏层 + 线性输出
    print("训练多层感知机 [5, 16, 8, 1] ...")
    mlp_net = MLP(
        [5, 16, 8, 1],
        hidden_activation="tanh",
        output_activation="linear",
        loss="mse",
        seed=42
    )
    mlp_net.train(
        X_train_scaled, Y_train,
        epochs=300, lr=0.02, batch_size=32, momentum=0.9, seed=42
    )

    # 5. 在训练集和测试集上评估
    y_pred_lin_train = [linear_net.predict(x)[0] for x in X_train_scaled]
    y_pred_lin_test = [linear_net.predict(x)[0] for x in X_test_scaled]

    y_pred_mlp_train = [mlp_net.predict(x)[0] for x in X_train_scaled]
    y_pred_mlp_test = [mlp_net.predict(x)[0] for x in X_test_scaled]

    lin_train_r2 = r2_score(y_train_flat, y_pred_lin_train)
    lin_train_rmse = rmse_score(y_train_flat, y_pred_lin_train)
    lin_test_r2 = r2_score(y_test_flat, y_pred_lin_test)
    lin_test_rmse = rmse_score(y_test_flat, y_pred_lin_test)

    mlp_train_r2 = r2_score(y_train_flat, y_pred_mlp_train)
    mlp_train_rmse = rmse_score(y_train_flat, y_pred_mlp_train)
    mlp_test_r2 = r2_score(y_test_flat, y_pred_mlp_test)
    mlp_test_rmse = rmse_score(y_test_flat, y_pred_mlp_test)

    print("\n" + "=" * 72)
    print(f"评估结果(测试集 {len(X_test)} 个分子未参与训练)")
    print("=" * 72)
    print(f"指标             线性模型 [5, 1]              MLP [5, 16, 8, 1]")
    print(f"训练集 R²        {lin_train_r2:18.4f}         {mlp_train_r2:20.4f}")
    print(f"训练集 RMSE      {lin_train_rmse:18.4f}         {mlp_train_rmse:20.4f}")
    print(f"测试集 R²        {lin_test_r2:18.4f}         {mlp_test_r2:20.4f}")
    print(f"测试集 RMSE      {lin_test_rmse:18.4f}         {mlp_test_rmse:20.4f}")
    print("-" * 72)
    delta_r2 = (mlp_test_r2 - lin_test_r2) / lin_test_r2 * 100
    delta_rmse = (lin_test_rmse - mlp_test_rmse) / lin_test_rmse * 100
    print(f"本次划分:测试集 R² 相对增加 {delta_r2:.1f}%,RMSE 降低 {delta_rmse:.1f}%。")
    print("=" * 72)

    # 6. 绘制测试集预测散点图
    plot_results(y_test_flat, y_pred_lin_test, y_pred_mlp_test, "esol_parity.png")


if __name__ == "__main__":
    main()

《原子智能》· 纸质出版预备版 · PolyAI Team 著