认知神经科学研究报告【20260048】

逻辑君

304人浏览 · 2026-05-11 21:53:20

逻辑君 · 2026-05-11 21:53:20 发布

文章目录

酶促神经网络（Enzymatic Neural Network）设计文档

酶促神经网络（Enzymatic Neural Network）设计文档

版本：Final 1.0
最后更新：2026-05-11
作者：基于多轮交互开发的酶促计算仿真系统

写在前面的话

晚上把ForeSight 5.88的系统的元意识组件升级成Ｌ３＋＋＋级别，然后同时开启了５项测试，因为电脑配置并不高，所以很慢，优化后还是慢，在等测试结果出来前，无聊做了一个这样的生物神经网络，回归是肯定没问是，代码和结果在后面。
但是很遗憾，这个组件ForeSight 5.88用不上，因为它是Ｌ１＋级的，有很多参数需要调整，ForeSight 5.88已经不需要调参了，全靠元意识系统完成。
但是，我觉得有可能对滤波有用，就献给大家了，不要小看它了，自适应滤波，很强的，可能还有其它更好的用处，没时间发掘了，大家如果发现它还有什么其它用，请在本文后留言。

1. 系统概述

1.1 项目背景

本系统实现了一类基于酶促反应动力学的神经网络模型，模拟生物酶在代谢通路中的三种典型调节机制（变构、磷酸化、转录），并引入化学场与交叉耦合，构建了一个多时间尺度的非线性自适应滤波器。系统能够在线处理一维时间序列信号，实现滤波、跟踪、预测等功能，参数可随误差实时自调节。

1.2 核心功能

三通道并行处理：快、中、慢三个酶神经元，时间常数覆盖毫秒～分钟。
自适应调节：变构（Km）、磷酸化（激酶/磷酸酶）、转录（酶浓度）均受误差驱动。
化学场：全局调制因子，由输入低通滤波、误差和振荡阵列共同驱动，实现增益自适应。
交叉耦合：快→中、中→慢前馈连接，模拟生物信号串扰。
纯在线学习：每个时间步计算误差，立即更新所有内部参数，无需离线训练集。

1.3 适用任务

时间序列回归与预测
实时信号去噪、基线漂移消除
多频段自适应滤波
连续控制中的非线性跟踪

2. 系统架构

2.1 整体框图

输入信号 ──┬──> 快神经元 ──┬─> 加权求和 ──> 输出
           ├──> 中神经元 ──┤
           └──> 慢神经元 ──┘
                ↑         ↑
          ┌─────┴─────┐   │
          │ 化学场    │   │
          │ (全局增益)│   │
          └───────────┘   │
                    交叉耦合

2.2 数据流

每个时间步输入归一化信号 ( u(t) \in [0,1] )。
三个神经元并行计算输出 ( f(t), m(t), s(t) )（均受化学场调制）。
加权求和得 ( y(t) = w_f f + w_m m + w_s s )。
计算误差 ( e(t) = y_{target}(t) - y(t) )。
误差同时驱动：
- 快神经元：调节变构参数 Km。
- 中神经元：调节激酶与磷酸酶活性 → 改变磷酸化水平。
- 慢神经元：调节转录速率 → 改变酶浓度。
- 化学场：更新场值 C。
交叉耦合：快输出影响中神经元的激酶；中输出影响慢神经元的合成速率。

2.3 模块划分

模块	职责	关键参数
`FastNeuron`	高频成分捕获，变构可调	Vmax, Km, tau
`MediumNeuron`	中频成分跟踪，磷酸化可调	Vmax, Km, phos, kinase, phosphatase
`SlowNeuron`	低频趋势，酶量可调	Vmax_per_mol, Km, enz, synth, deg
`ChemicalField`	全局增益调制，自适应	C, tau, alpha, beta, gamma
`AdaptiveOscillator`	提供扰动，辅助化学场自适应	三个耦合振荡器
`EnzymeNet`	整合以上，提供 forward/backward 接口	输出权重

3. 模块详细设计

3.1 快神经元

动力学方程：
[
\frac{df}{dt} = \frac{ V_{max}^{eff} \cdot u }{ K_m + u } - f \Big/ \tau_f
]
其中 ( V_{max}^{eff} = \text{field.modulate}(V_{max0}) )。

自适应规则：

正向调节：根据输入导数调整学习率 ( lr = 0.05 + 0.45\cdot |du/dt|/2 )。
反向调节：( \Delta K_m = -lr \cdot \text{clamp}(e, -0.3, 0.3) \cdot dt )。
Km 边界 ( [0.10, 0.6] )。

3.2 中神经元

磷酸化动力学：
$\frac{dp}{dt} = k_{kin}(1-p) - k_{phos}\, p$
其中 $k_{kin}$ 由激酶活性决定， $k_{phos}$ 由磷酸酶活性决定。

效应：磷酸化水平 p 按线性方式影响 Vmax：
$V_{max} = V_{max0} \cdot (0.6 + 0.4p)$

自适应规则：

正向调节：根据输入1秒窗口斜率调整激酶和磷酸酶的学习率。
反向调节：误差积分 → 目标激酶活性；误差本身 → 目标磷酸酶活性。
交叉耦合（快→中）：( k_{kin} \text{增加} 0.12 \cdot f )。

3.3 慢神经元

酶浓度动力学：
$\frac{dE}{dt} = \sigma - \delta \cdot E$
其中 σ 为合成速率，δ 为降解速率。

效应： $V_{max} = V_{max,per\_mol} \cdot E$ 。

自适应规则：

正向调节：根据输入5秒均值调整误差累积阈值。
反向调节：累积误差超过阈值时，σ 乘 1.006/0.994。
交叉耦合（中→慢）：( \sigma \text{增加} 0.08 \cdot m )。

3.4 化学场

场动力学：
$\tau_C \frac{dC}{dt} = \alpha (\bar{u} - C) + \beta e + \gamma (O - 0.5)$
其中 $\bar{u}$ 为输入低通滤波（τ=0.5s），O 为振荡阵列输出。

调制作用：
$V_{max}^{eff} = V_{max}^{base} \cdot (0.6 + C)$
C 范围 [0.2, 1.0]。

3.5 振荡阵列（自适应 Kuramoto 模型）

三个耦合相位振荡器：
$\dot{\theta}_i = \omega_i + \frac{K}{3}\sum_{j\neq i}\sin(\theta_j-\theta_i) + \eta e + \text{noise}$
输出取相位平均的正弦： $0.3\sin(\bar{\theta})$ 。

自适应：根据误差积分调整频率 ω_i 和耦合强度 K，因子 $\cdot \text{clamp}(\int e, -2,2)$ 。

4. 训练与参数更新流程

4.1 在线伪代码

Initialize net
for each time step t:
    u = input(t)
    target = desired_output(t)
    y = net.forward(u, dt)
    e = target - y
    net.backward(e, dt)
    log(t, target, y, e, internal_states)

4.2 参数更新一览

参数	更新方程	驱动信号
Km (fast)	( K_m \leftarrow K_m - lr\cdot e\cdot dt )	瞬时误差
kinase	低通滤波 + 误差积分	积分误差
phosphatase	低通滤波 + 误差	瞬时误差
synth (slow)	乘性更新	累积误差超阈值
C (field)	一阶动力学	输入、误差、振荡信号
振荡器频率/耦合	乘性调整	误差积分

5. 关键参数表（最终稳定版）

模块	参数	值	说明
Fast	Vmax0	0.6	最大速率
Fast	Km0	0.25	基础米氏常数
Fast	τ	10 ms	时间常数
Medium	Vmax0	0.5	基础最大速率
Medium	Km	0.3	米氏常数
Medium	τ	0.6 s	时间常数
Slow	Vmax_per_mol	0.65	每酶分子速率
Slow	Km	0.35	米氏常数
Slow	τ	6.0 s	时间常数
Slow	max enzyme	2.5	酶浓度上限
Field	τ	3.0 s	场时间常数
Field	α	0.2	输入驱动强度
Field	β	1.2	误差驱动强度
Field	γ	0.2	振荡驱动强度
交叉	fast→medium	0.12	系数
交叉	medium→slow	0.08	系数
输出权重	w_f, w_m, w_s	0.2, 0.3, 0.5	–

6. 使用指南

6.1 编译与运行（Linux）

g++ -O2 -std=c++11 -o enzyme_net enzyme_net.cpp
./enzyme_net

输出文件：training_stable_final.csv。

6.2 修改目标信号

编辑 targetFunction(double t) 函数，返回期望的目标值。
例如替换为外部传感器数据读取。

6.3 调整自适应强度

收敛过慢 → 增大 beta (field) 或增大 backwardRegulation 中的系数。
过冲 → 减小慢酶的 Vmax_base_per_mol 或减小 beta。

6.4 重置网络状态

调用 net.reset() 即可将所有内部状态恢复初始。

7. 性能评估（三段式目标跟踪）

指标	初期误差	稳态误差（30s）	改善率
均值绝对误差	0.23	0.05	78%
最大绝对误差	0.25	0.08	68%
输出范围	0.05–0.35	0.35–0.75	有效覆盖

化学场在全程自适应变化，慢酶浓度在80秒内达到上限2.5。

8. 局限性与未来扩展

8.1 局限性

仅适合一维时间序列，对高维静态输入（如图像）不友好。
无梯度计算，无法做深层反传。
参数手动调校较多，尚未实现自动超参优化。

8.2 未来扩展

将输入改为高维（并行酶阵列），保留储备池计算思路，输出层改用线性回归——可处理MNIST。
引入STDP（脉冲时序依赖可塑性）实现无监督学习。
硬件化：用微流控芯片实现真实的酶反应网络。

9. 参考文献（概念）

Hodgkin-Huxley 模型（神经元）
Kuramoto 模型（振荡同步）
米氏方程（酶动力学）
液体状态机（LSM）与储备池计算

附录 A：代码文件结构

enzyme_final.cpp         // 主程序，包含所有类定义
training_stable_final.csv // 运行后生成的日志

依赖：仅标准库 + C++11。

附录Ｂ：代码

#include <iostream>
#include <cmath>
#include <random>
#include <fstream>
#include <deque>

using namespace std;

template<typename T> T clamp(T val, T min, T max) {
    return (val < min) ? min : (val > max) ? max : val;
}

// ========== 自适应振荡阵列（辅助扰动，不强驱动） ==========
class AdaptiveOscillator {
private:
    double theta[3];
    double omega0[3], omega[3];
    double K0, K;
    double noise_amp;
    mt19937 rng;
    uniform_real_distribution<> dis;
public:
    AdaptiveOscillator() : K0(0.8), K(0.8), noise_amp(0.03), rng(42), dis(-0.05, 0.05) {
        theta[0] = 0.0; theta[1] = 2.0; theta[2] = 4.0;
        omega0[0] = 0.3; omega0[1] = 0.7; omega0[2] = 1.2;
        for (int i=0; i<3; ++i) omega[i] = omega0[i];
    }
    
    void adapt(double error_integral) {
        double factor = 1.0 + 0.15 * clamp(error_integral, -2.0, 2.0);
        factor = clamp(factor, 0.6, 1.5);
        K = clamp(K0 * factor, 0.3, 1.2);
        for (int i=0; i<3; ++i) omega[i] = clamp(omega0[i] * factor, 0.2, 1.8);
    }
    
    void update(double dt, double external_drive) {
        for (int i = 0; i < 3; ++i) {
            double coupling = 0.0;
            for (int j = 0; j < 3; ++j) if (j != i) coupling += sin(theta[j] - theta[i]);
            double dTheta = omega[i] + (K/3.0) * coupling + 0.1 * external_drive + noise_amp * dis(rng);
            theta[i] += dTheta * dt;
        }
    }
    
    double getOutput() const {
        double x=0, y=0;
        for (int i=0; i<3; ++i) { x += cos(theta[i]); y += sin(theta[i]); }
        double mean_phase = atan2(y/3.0, x/3.0);
        return 0.5 + 0.3 * sin(mean_phase);  // 范围 0.2~0.8，扰动幅度降低
    }
    
    void reset() {
        theta[0] = 0.0; theta[1] = 2.0; theta[2] = 4.0;
        K = K0;
        for (int i=0; i<3; ++i) omega[i] = omega0[i];
    }
};

// ========== 化学场（误差主导负反馈） ==========
class ChemicalField {
private:
    double C;                 // 范围 0.2~1.0
    double tau;               // 3 秒，快速响应
    double alpha, beta, gamma;
    double I_filtered;
    AdaptiveOscillator osc;
    double error_integral;
public:
    ChemicalField() : C(0.5), tau(3.0), alpha(0.2), beta(1.2), gamma(0.2),
                      I_filtered(0.5), error_integral(0) {}
    
    void update(double input, double target_error, double dt) {
        I_filtered += (input - I_filtered) * dt / 0.5;
        error_integral += target_error * dt;
        error_integral = clamp(error_integral, -2.0, 2.0);
        osc.adapt(error_integral);
        osc.update(dt, clamp(target_error, -0.5, 0.5));
        double osc_signal = osc.getOutput();  // 0.2~0.8
        
        // 误差主导（beta=1.2），振荡辅助（gamma=0.2），输入趋同弱化
        double drive = alpha * (I_filtered - C) + beta * target_error + gamma * (osc_signal - 0.5);
        C += drive * dt / tau;
        C = clamp(C, 0.2, 1.0);
    }
    
    double modulate(double base_Vmax) const {
        // C=0.5 -> 1.1倍；C=1.0 -> 1.6倍；C=0.2 -> 0.8倍
        return base_Vmax * (0.6 + C);
    }
    double getC() const { return C; }
    void reset() { C = 0.5; I_filtered = 0.5; error_integral = 0; osc.reset(); }
};

// ========== 1. 快神经元 ==========
class FastNeuron {
private:
    double Vmax_base, Km0, Km_delta, state, tau;
    double last_input;
    double lr;
public:
    FastNeuron(double vmax_base, double km0, double tau_ms)
        : Vmax_base(vmax_base), Km0(km0), Km_delta(0), state(0), tau(tau_ms/1000.0), last_input(0), lr(0.1) {}
    
    void forwardRegulation(double input, double dt) {
        double dI = (input - last_input) / dt;
        last_input = input;
        double abs_dI = clamp(fabs(dI), 0.0, 2.0);
        lr = 0.05 + 0.45 * (abs_dI / 2.0);
    }
    
    void backwardRegulation(double error, double dt) {
        double delta = -lr * clamp(error, -0.3, 0.3);
        Km_delta += delta * dt;
        Km_delta = clamp(Km_delta, -Km0*0.7, Km0*2.0);
    }
    
    double Km() const { return clamp(Km0 + Km_delta, 0.10, 0.6); }
    double output() const { return state; }
    
    double forward(double input, double dt, const ChemicalField& field) {
        forwardRegulation(input, dt);
        double in = clamp(input, 0.0, 1.0);
        double km = Km();
        double Vmax_eff = field.modulate(Vmax_base);
        double rate = Vmax_eff * in / (km + in);
        state += (rate - state) / tau * dt;
        state = clamp(state, 0.0, Vmax_eff);
        return state;
    }
    
    void reset() { state = 0; Km_delta = 0; last_input = 0; lr = 0.1; }
};

// ========== 2. 中神经元（快→中交叉） ==========
class MediumNeuron {
private:
    double Vmax_base, Km, phos, state, tau;
    double kinase, phosphatase;
    double lr_kinase, lr_phos;
    deque<double> input_buffer;
    double buffer_time;
public:
    MediumNeuron(double vmax_base, double km, double tau_s)
        : Vmax_base(vmax_base), Km(km), phos(0.5), state(0), tau(tau_s),
          kinase(0.2), phosphatase(0.1), lr_kinase(0.2), lr_phos(0.1), buffer_time(0) {}
    
    void forwardRegulation(double input, double dt, double fast_output) {
        input_buffer.push_back(input);
        buffer_time += dt;
        while (buffer_time > 1.0 && input_buffer.size() > 1) {
            input_buffer.pop_front();
            buffer_time -= dt;
        }
        if (input_buffer.size() >= 2) {
            double slope = (input_buffer.back() - input_buffer.front()) / buffer_time;
            double trend = clamp(slope, -0.5, 0.5);
            lr_kinase = 0.1 + 0.6 * fabs(trend);
            lr_phos = 0.05 + 0.2 * clamp(trend, 0.0, 0.5);
        }
        double cross = 0.12 * fast_output;   // 强度降低
        kinase = clamp(kinase + cross * dt, 0.05, 0.7);
    }
    
    void backwardRegulation(double error, double dt, double &integral_error) {
        integral_error = integral_error * 0.98 + error * dt;
        double ki_target = 0.2 + 0.8 * clamp(integral_error, -0.4, 0.4);
        kinase += lr_kinase * (ki_target - kinase) * dt;
        kinase = clamp(kinase, 0.05, 0.7);
        
        double phos_target = 0.1 + 0.3 * clamp(error, 0.0, 0.5);
        phosphatase += lr_phos * (phos_target - phosphatase) * dt;
        phosphatase = clamp(phosphatase, 0.05, 0.4);
    }
    
    void updatePhos(double dt) {
        double delta = (kinase*(1-phos) - phosphatase*phos) * dt;
        phos += delta;
        phos = clamp(phos, 0.3, 0.85);
    }
    
    double Vmax_eff(const ChemicalField& field) const {
        double base = Vmax_base * (0.6 + 0.4*phos);
        return field.modulate(base);
    }
    double output() const { return state; }
    double getPhos() const { return phos; }
    
    double forward(double input, double dt, const ChemicalField& field, double fast_output) {
        forwardRegulation(input, dt, fast_output);
        updatePhos(dt);
        double in = clamp(input, 0.0, 1.0);
        double Vmax_eff = this->Vmax_eff(field);
        double rate = Vmax_eff * in / (Km + in);
        state += (rate - state) / tau * dt;
        state = clamp(state, 0.0, Vmax_eff);
        return state;
    }
    
    void reset() { state = 0; phos = 0.6; kinase = 0.2; phosphatase = 0.1;
                   input_buffer.clear(); buffer_time = 0; }
};

// ========== 3. 慢神经元（中→慢交叉，酶浓度上限2.5） ==========
class SlowNeuron {
private:
    double Vmax_base_per_mol, Km, enz, state, tau;
    double synth, deg;
    double cum_error;
    double threshold;
public:
    SlowNeuron(double vmax_base_per_mol, double km, double tau_s, double init_enz)
        : Vmax_base_per_mol(vmax_base_per_mol), Km(km), enz(init_enz), state(0), tau(tau_s),
          synth(0.015), deg(0.003), cum_error(0), threshold(2.0) {}
    
    void forwardRegulation(double input, double dt, double medium_output) {
        static double input_integral = 0, integral_time = 0;
        input_integral += input * dt;
        integral_time += dt;
        if (integral_time > 5.0) {
            double avg_input = input_integral / integral_time;
            threshold = 1.0 + 2.0 * (1.0 - avg_input);
            threshold = clamp(threshold, 1.0, 3.0);
            input_integral = 0;
            integral_time = 0;
        }
        double cross = 0.08 * medium_output;   // 交叉强度降低
        synth += cross * dt;
        synth = clamp(synth, 0.008, 0.08);
    }
    
    void backwardRegulation(double error, double dt) {
        cum_error += error * dt;
        cum_error = clamp(cum_error, -4.0, 4.0);
        if (cum_error > threshold) {
            synth *= 1.006;
            cum_error -= 0.2;
        } else if (cum_error < -threshold) {
            synth *= 0.994;
            cum_error += 0.2;
        }
        synth = clamp(synth, 0.008, 0.08);
    }
    
    void updateEnz(double dt) {
        double dE = (synth - deg * enz) * dt;
        enz += dE;
        enz = clamp(enz, 0.5, 2.5);   // 上限从3.5降到2.5
    }
    
    double Vmax_eff(const ChemicalField& field) const {
        double base = Vmax_base_per_mol * enz;
        return field.modulate(base);
    }
    double output() const { return state; }
    double getEnz() const { return enz; }
    
    double forward(double input, double dt, const ChemicalField& field, double medium_output) {
        forwardRegulation(input, dt, medium_output);
        updateEnz(dt);
        double in = clamp(input, 0.0, 1.0);
        double Vmax_eff = this->Vmax_eff(field);
        double rate = Vmax_eff * in / (Km + in);
        state += (rate - state) / tau * dt;
        state = clamp(state, 0.0, Vmax_eff);
        return state;
    }
    
    void reset() { state = 0; enz = 1.0; synth = 0.015; cum_error = 0; threshold = 2.0; }
};

// ========== 网络类 ==========
class EnzymeNet {
private:
    FastNeuron fast;
    MediumNeuron medium;
    SlowNeuron slow;
    ChemicalField field;
    double w_f, w_m, w_s;
    mt19937 rng;
    normal_distribution<> noise{0, 0.003};
    double integral_error_medium;
    
public:
    EnzymeNet()
        : fast(0.6, 0.25, 10),
          medium(0.5, 0.3, 0.6),
          slow(0.65, 0.35, 6.0, 1.0),
          w_f(0.2), w_m(0.3), w_s(0.5),
          rng(42),
          integral_error_medium(0) {}
    
    double forward(double input, double dt) {
        double in = clamp(input, 0.0, 1.0);
        double f = fast.forward(in, dt, field);
        double m = medium.forward(in, dt, field, f);
        double s = slow.forward(in, dt, field, m);
        double out = w_f*f + w_m*m + w_s*s;
        out = clamp(out, 0.0, 1.0);
        return out + noise(rng);
    }
    
    void backward(double error, double dt) {
        double avg_act = (fast.output() + medium.output() + slow.output()) / 3.0;
        field.update(avg_act, error, dt);
        fast.backwardRegulation(error, dt);
        medium.backwardRegulation(error, dt, integral_error_medium);
        slow.backwardRegulation(error, dt);
    }
    
    void getState(double &fk, double &mp, double &se, double &cfield) {
        fk = fast.Km();
        mp = medium.getPhos();
        se = slow.getEnz();
        cfield = field.getC();
    }
    
    void reset() {
        fast.reset();
        medium.reset();
        slow.reset();
        field.reset();
        integral_error_medium = 0;
    }
};

// ========== 目标函数 ==========
double targetFunction(double t) {
    if (t < 1.0) return 0.3 + 0.2 * sin(20 * M_PI * t);
    else if (t < 6.0) return 0.4 + 0.2 * sin(2 * M_PI * (t-1));
    else if (t < 26.0) return 0.3 + 0.4 * (t-6) / 20.0;
    else return 0.7;
}

int main() {
    ofstream out("training_stable_final.csv");
    out << "t,target,output,error,fast_Km,medium_phos,slow_enz,chemical_field\n";
    
    EnzymeNet net;
    double t = 0, dt = 0.01, T = 30.0;
    
    cout << "=== 最终稳定版：误差主导化学场 + 弱交叉耦合 ===\n";
    for (int step = 0; step <= T/dt; ++step) {
        t = step * dt;
        double target = targetFunction(t);
        double input = target + 0.03 * sin(10*M_PI*t);
        double output = net.forward(input, dt);
        double error = target - output;
        net.backward(error, dt);
        
        if (step % 100 == 0) {
            double fk, mp, se, cf;
            net.getState(fk, mp, se, cf);
            printf("t=%.1f  target=%.3f  out=%.3f  err=%.4f  |  Km=%.2f  phos=%.2f  enz=%.2f  field=%.2f\n",
                   t, target, output, error, fk, mp, se, cf);
            out << t << "," << target << "," << output << "," << error << ","
                << fk << "," << mp << "," << se << "," << cf << "\n";
        } else {
            double fk, mp, se, cf;
            net.getState(fk, mp, se, cf);
            out << t << "," << target << "," << output << "," << error << ","
                << fk << "," << mp << "," << se << "," << cf << "\n";
        }
    }
    out.close();
    cout << "\n训练完成，日志保存至 training_stable_final.csv\n";
    return 0;
}

sengseng@fedora:~/fs587$ g++ -O2 -std=c++11 -o enzyme_net enzyme_net.cpp
sengseng@fedora:~/fs587$ ./enzyme_net
=== 最终稳定版：误差主导化学场 + 弱交叉耦合 ===
t=0.0  target=0.300  out=0.072  err=0.2283  |  Km=0.25  phos=0.50  enz=1.00  field=0.50
t=1.0  target=0.400  out=0.173  err=0.2272  |  Km=0.17  phos=0.55  enz=1.02  field=0.55
t=2.0  target=0.400  out=0.235  err=0.1652  |  Km=0.13  phos=0.61  enz=1.05  field=0.61
t=3.0  target=0.400  out=0.277  err=0.1225  |  Km=0.10  phos=0.66  enz=1.10  field=0.66
t=4.0  target=0.400  out=0.319  err=0.0810  |  Km=0.10  phos=0.71  enz=1.17  field=0.69
t=5.0  target=0.400  out=0.341  err=0.0590  |  Km=0.10  phos=0.75  enz=1.24  field=0.68
t=6.0  target=0.300  out=0.348  err=-0.0482  |  Km=0.10  phos=0.78  enz=1.32  field=0.66
t=7.0  target=0.320  out=0.365  err=-0.0450  |  Km=0.10  phos=0.80  enz=1.40  field=0.61
t=8.0  target=0.340  out=0.379  err=-0.0392  |  Km=0.10  phos=0.81  enz=1.47  field=0.57
t=9.0  target=0.360  out=0.395  err=-0.0351  |  Km=0.11  phos=0.82  enz=1.55  field=0.56
t=10.0  target=0.380  out=0.410  err=-0.0300  |  Km=0.11  phos=0.83  enz=1.62  field=0.55
t=11.0  target=0.400  out=0.424  err=-0.0242  |  Km=0.12  phos=0.84  enz=1.70  field=0.55
t=12.0  target=0.420  out=0.448  err=-0.0284  |  Km=0.12  phos=0.84  enz=1.77  field=0.54
t=13.0  target=0.440  out=0.463  err=-0.0231  |  Km=0.13  phos=0.85  enz=1.85  field=0.51
t=14.0  target=0.460  out=0.480  err=-0.0197  |  Km=0.13  phos=0.85  enz=1.92  field=0.48
t=15.0  target=0.480  out=0.494  err=-0.0141  |  Km=0.14  phos=0.85  enz=2.00  field=0.46
t=16.0  target=0.500  out=0.509  err=-0.0091  |  Km=0.14  phos=0.85  enz=2.07  field=0.45
t=17.0  target=0.520  out=0.525  err=-0.0054  |  Km=0.14  phos=0.85  enz=2.14  field=0.46
t=18.0  target=0.540  out=0.548  err=-0.0084  |  Km=0.14  phos=0.85  enz=2.22  field=0.47
t=19.0  target=0.560  out=0.576  err=-0.0157  |  Km=0.14  phos=0.85  enz=2.29  field=0.49
t=20.0  target=0.580  out=0.603  err=-0.0226  |  Km=0.15  phos=0.85  enz=2.36  field=0.49
t=21.0  target=0.600  out=0.622  err=-0.0221  |  Km=0.15  phos=0.85  enz=2.44  field=0.48
t=22.0  target=0.620  out=0.638  err=-0.0184  |  Km=0.15  phos=0.85  enz=2.50  field=0.46
t=23.0  target=0.640  out=0.652  err=-0.0119  |  Km=0.16  phos=0.85  enz=2.50  field=0.44
t=24.0  target=0.660  out=0.669  err=-0.0088  |  Km=0.16  phos=0.85  enz=2.50  field=0.44
t=25.0  target=0.680  out=0.688  err=-0.0080  |  Km=0.16  phos=0.85  enz=2.50  field=0.45
t=26.0  target=0.700  out=0.705  err=-0.0050  |  Km=0.16  phos=0.85  enz=2.50  field=0.48
t=27.0  target=0.700  out=0.726  err=-0.0258  |  Km=0.16  phos=0.85  enz=2.50  field=0.50
t=28.0  target=0.700  out=0.738  err=-0.0376  |  Km=0.17  phos=0.85  enz=2.50  field=0.50
t=29.0  target=0.700  out=0.746  err=-0.0463  |  Km=0.18  phos=0.85  enz=2.50  field=0.49
t=30.0  target=0.700  out=0.751  err=-0.0512  |  Km=0.19  phos=0.85  enz=2.50  field=0.47

训练完成，日志保存至 training_stable_final.csv