深度学习驱动的控制方法详解（九）：神经网络自适应控制

系列导读：本篇讲解神经网络自适应控制，结合神经网络的逼近能力与自适应控制的稳定性保证。

---

1. 引言：稳定性优先的学习控制

前面章节介绍的深度强化学习方法强大但存在关键问题：无法保证闭环稳定性。

对于安全攸关系统（航空航天、医疗机器人等），这是不可接受的。

神经网络自适应控制（NN-based Adaptive Control）提供了一条融合学习与稳定性的路径：

$$\underset{\text{逼近未知动力学}}{\underbrace{\text{神经网络}}}+\underset{\text{保证稳定性}}{\underbrace{\text{Lyapunov设计}}}=\text{可靠的学习控制}$$

---

2. 自适应控制基础

2.1 问题设定

考虑非线性系统：

$$\dot{x}=f(x)+g(x)u+\Delta (x)$$

其中：

• $f(x),g(x)$：已知的标称动力学
• $\Delta (x)$：未知的不确定性/扰动
• $u$：控制输入

目标：设计控制器使系统输出跟踪参考信号 $y_d(t)$。

2.2 模型参考自适应控制（MRAC）

经典MRAC设计参考模型：

$${\dot{x}}_m=A_m{x}_m+B_{m}r$$

控制律：

$$u={\hat{\theta }}^T\varphi (x)+kr$$

自适应律：

$$\dot{\hat{\theta }}=-\Gamma \varphi (x)e^{T}PB$$

问题：$\varphi (x)$ 需要人工选择，且线性参数化假设可能不成立。

2.3 神经网络的角色

用神经网络逼近未知函数 $\Delta (x)$：

$$\Delta (x)=W^{\ast T}\varphi (x)+ϵ(x)$$

其中：

• $W^{\ast }$：理想权重（未知）
• $\varphi (x)$：神经网络基函数（自动学习的特征）
• $ϵ(x)$：逼近误差（有界）

---

3. 神经网络自适应控制设计

3.1 基本架构

3.2 控制律设计

总控制律由两部分组成：

$$u=u_{bl}(x,x_d)+u_{ad}(x,\hat{W})$$

基线控制器（假设无不确定性）：

$$u_{bl}=g(x{)}^{-1}\left(-f(x)+{\dot{x}}_d-Ke\right)$$

其中 $K>0$ 是反馈增益。

自适应补偿（神经网络）：

$$u_{ad}=-g(x{)}^{-1}{\hat{W}}^T\varphi (x)$$

3.3 自适应律推导

基于Lyapunov稳定性理论设计自适应律。

选择Lyapunov函数：

$$V=\frac{1}{2}{e}^{T}Pe+\frac{1}{2}\text{tr}({\tilde{W}}^T{\Gamma }^{-1}\tilde{W})$$

其中 $\tilde{W}=W^{\ast }-\hat{W}$ 是权重估计误差，$\Gamma >0$ 是自适应增益矩阵。

求导：

$$\dot{V}=e^{T}P\dot{e}-\text{tr}({\tilde{W}}^T{\Gamma }^{-1}\dot{\hat{W}})$$

代入闭环动力学后，选择：

$$\dot{\hat{W}}=\Gamma \varphi (x)e^{T}PB$$

可使 $\dot{V}\le 0$，保证稳定性。

---

4. Lyapunov稳定性分析

4.1 稳定性定理

定理：对于系统

$$\dot{x}=f(x)+g(x)u+W^{\ast T}\varphi (x)+ϵ(x)$$

采用控制律 $u=u_{bl}+u_{ad}$ 和自适应律 $\dot{\hat{W}}=\Gamma \varphi (x)e^{T}PB$，则：

1. 误差 $e(t)$ 一致最终有界（UUB）
2. 权重估计 $\hat{W}$ 有界
3. 如果 $ϵ(x)$ 充分小，误差可任意小

4.2 证明要点

Lyapunov函数导数：

$$\dot{V}=-e^{T}Qe+e^{T}PBϵ(x)$$

其中 $Q=-PA-A^{T}P>0$。

利用Young不等式：

$$e^{T}PBϵ\le \frac{1}{2}{e}^{T}PB{B}^{T}Pe+\frac{1}{2}{\overline{ϵ}}^2$$

最终得到：

$$\dot{V}\le -{\lambda }_{min}(Q)\Vert e{\Vert }^2+\frac{1}{2}{\overline{ϵ}}^2$$

当 $\Vert e\Vert >\frac{\overline{ϵ}}{\sqrt{2{\lambda }_{min}(Q)}}$ 时，$\dot{V}<0$。

4.3 σ-修正与e-修正

防止参数漂移的修正技术：

σ-修正：

$$\dot{\hat{W}}=\Gamma \varphi (x)e^{T}PB-\sigma \hat{W}$$

e-修正（死区）：

$$\dot{\hat{W}}=\{\begin{array}{ll}\Gamma \varphi (x)e^{T}PB& \text{if }\Vert e\Vert >e_0\\ 0& \text{otherwise}\end{array}$$

---

5. 径向基函数网络（RBFNN）

5.1 为什么用RBF？

RBF网络在自适应控制中特别流行：

优点	说明
局部逼近	激活函数有紧支撑
结构简单	单隐层即可
理论成熟	逼近误差分析完善
计算高效	参数更新简单

5.2 RBF网络结构

$$\hat{\Delta }(x)=\sum _{i=1}^N{w}_i{\varphi }_i(x)=W^T\Phi (x)$$

高斯基函数：

$${\varphi }_i(x)=\exp \left(-\frac{\Vert x-c_i{\Vert }^2}{2{\sigma }_i^2}\right)$$

5.3 PyTorch实现

import torch
import torch.nn as nn

class RBFNetwork(nn.Module):
    """径向基函数网络"""
    def __init__(self, input_dim, num_centers, output_dim):
        super().__init__()
        self.num_centers = num_centers

        # RBF中心（可学习或固定）
        self.centers = nn.Parameter(
            torch.randn(num_centers, input_dim) * 0.5
        )

        # 宽度参数
        self.log_sigmas = nn.Parameter(
            torch.zeros(num_centers)
        )

        # 输出权重
        self.weights = nn.Parameter(
            torch.zeros(num_centers, output_dim)
        )

    def rbf(self, x):
        """计算RBF激活"""
        # x: [B, D], centers: [N, D]
        # 计算距离
        diff = x.unsqueeze(1) - self.centers.unsqueeze(0)  # [B, N, D]
        dist_sq = (diff ** 2).sum(dim=-1)  # [B, N]

        # 高斯激活
        sigmas = torch.exp(self.log_sigmas)
        phi = torch.exp(-dist_sq / (2 * sigmas ** 2))  # [B, N]
        return phi

    def forward(self, x):
        phi = self.rbf(x)
        output = phi @ self.weights  # [B, O]
        return output

    def get_phi(self, x):
        """返回基函数值（用于自适应律）"""
        return self.rbf(x)

class NNAdaptiveController:
    """神经网络自适应控制器"""
    def __init__(self, state_dim, control_dim, num_centers=50,
                 gamma=1.0, sigma=0.01):
        self.nn = RBFNetwork(state_dim, num_centers, control_dim)
        self.gamma = gamma  # 自适应增益
        self.sigma = sigma  # σ-修正系数

        # 控制增益
        self.K = torch.eye(state_dim) * 5.0

    def compute_control(self, x, x_d, x_d_dot, f_x, g_x):
        """计算控制输入"""
        # 跟踪误差
        e = x - x_d

        # 基线控制（反馈线性化）
        g_inv = torch.inverse(g_x)
        u_bl = g_inv @ (-f_x + x_d_dot - self.K @ e)

        # 自适应补偿
        delta_hat = self.nn(x.unsqueeze(0)).squeeze(0)
        u_ad = -g_inv @ delta_hat

        return u_bl + u_ad, e

    def update_weights(self, x, e, P, B):
        """更新神经网络权重（自适应律）"""
        phi = self.nn.get_phi(x.unsqueeze(0)).squeeze(0)  # [N]

        # 梯度方向
        grad = torch.outer(phi, e @ P @ B)  # [N, O]

        # σ-修正
        with torch.no_grad():
            self.nn.weights.data += self.gamma * grad
            self.nn.weights.data -= self.sigma * self.nn.weights.data

---

6. 深度神经网络自适应控制

6.1 深度网络的挑战

使用深度网络代替RBF带来新挑战：

1. 非凸优化：权重更新不能用简单自适应律
2. 稳定性分析：Lyapunov分析更复杂
3. 在线学习：需要防止灾难性遗忘

6.2 分层方法

方法1：仅更新输出层

固定特征提取层，仅在线更新最后一层：

class DeepAdaptiveController:
    """深度自适应控制器（输出层自适应）"""
    def __init__(self, state_dim, control_dim):
        # 预训练的特征提取器（固定）
        self.feature_extractor = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU()
        )
        for param in self.feature_extractor.parameters():
            param.requires_grad = False

        # 自适应输出层
        self.output_weights = torch.zeros(64, control_dim)
        self.gamma = 1.0

    def forward(self, x):
        with torch.no_grad():
            features = self.feature_extractor(x)
        return features @ self.output_weights

    def adapt(self, x, e, P, B):
        with torch.no_grad():
            features = self.feature_extractor(x)

        # 类似RBF的自适应律
        grad = torch.outer(features.squeeze(), e @ P @ B)
        self.output_weights += self.gamma * grad

6.3 复合学习

复合学习结合跟踪误差和预测误差：

$$\dot{\hat{W}}=\Gamma \left(\varphi e^{T}PB+k_p\varphi {\tilde{\Delta }}^T\right)$$

其中 $\tilde{\Delta }=\Delta -\hat{\Delta }$ 是预测误差。

---

7. 神经网络反步控制

7.1 反步法（Backstepping）

反步法是处理严格反馈系统的经典方法：

$$\begin{array}{rl}{\dot{x}}_1& =x_2+f_1(x_1)\\ {\dot{x}}_2& =x_3+f_2(x_1,x_2)\\ & ⋮\\ {\dot{x}}_n& =u+f_n(x)\end{array}$$

7.2 神经网络增强反步

用神经网络逼近未知函数 $f_i$：

class NNBacksteppingController:
    """神经网络反步控制器"""
    def __init__(self, n_states):
        self.n = n_states
        self.nns = [RBFNetwork(i+1, 30, 1) for i in range(n_states)]
        self.K = [2.0] * n_states  # 控制增益

    def compute_control(self, x, x_d, dt):
        """反步控制律计算"""
        alpha = []  # 虚拟控制
        z = []      # 误差变量

        # 第一步
        z.append(x[0] - x_d)
        f1_hat = self.nns[0](x[0:1].unsqueeze(0)).squeeze()
        alpha.append(-self.K[0] * z[0] - f1_hat)

        # 递推步骤
        for i in range(1, self.n):
            z.append(x[i] - alpha[i-1])

            # 神经网络估计
            fi_hat = self.nns[i](x[:i+1].unsqueeze(0)).squeeze()

            # 虚拟控制
            alpha_dot_prev = self._compute_alpha_dot(alpha[i-1], x, i-1, dt)
            alpha.append(-self.K[i] * z[i] - z[i-1] - fi_hat + alpha_dot_prev)

        # 最终控制
        u = alpha[-1]
        return u, z

---

8. 稳定性保证的强化学习

8.1 Lyapunov约束强化学习

将Lyapunov稳定性作为约束嵌入RL：

$$\underset{\pi }{\max }J(\pi )\text{s.t.}\dot{V}(x,\pi (x))\le -\alpha V(x),\forall x$$

8.2 神经Lyapunov函数

学习Lyapunov函数本身：

class NeuralLyapunov(nn.Module):
    """神经Lyapunov函数"""
    def __init__(self, state_dim, hidden_dim=64):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(state_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, 1)
        )

    def forward(self, x):
        # 确保正定：V(0) = 0, V(x) > 0 for x ≠ 0
        phi = self.net(x)
        V = phi ** 2 + 1e-6 * (x ** 2).sum(dim=-1, keepdim=True)
        return V

    def gradient(self, x):
        """计算梯度 ∇V"""
        x.requires_grad_(True)
        V = self.forward(x)
        grad = torch.autograd.grad(V.sum(), x, create_graph=True)[0]
        return grad

def lyapunov_loss(lyap_net, dynamics, policy, states):
    """Lyapunov稳定性损失"""
    V = lyap_net(states)
    grad_V = lyap_net.gradient(states)

    # 闭环动力学
    actions = policy(states)
    x_dot = dynamics(states, actions)

    # Lyapunov导数
    V_dot = (grad_V * x_dot).sum(dim=-1, keepdim=True)

    # 损失：希望 V_dot < 0
    loss = torch.relu(V_dot + 0.1 * V).mean()

    return loss

---

9. 实际应用案例

9.1 机械臂轨迹跟踪

class RobotArmAdaptiveControl:
    """机械臂自适应控制"""
    def __init__(self, n_joints=2):
        self.n = n_joints
        self.nn = RBFNetwork(2*n_joints, 100, n_joints)

        # 已知的惯性矩阵和科氏矩阵（标称值）
        self.M_nominal = np.eye(n_joints)
        self.C_nominal = np.zeros((n_joints, n_joints))

        # 控制增益
        self.Kp = np.diag([100, 100])
        self.Kd = np.diag([20, 20])

    def control(self, q, q_dot, q_d, q_d_dot, q_d_ddot):
        """计算关节力矩"""
        # 跟踪误差
        e = q_d - q
        e_dot = q_d_dot - q_dot

        # PD控制（基线）
        tau_pd = self.Kp @ e + self.Kd @ e_dot

        # 标称前馈
        tau_ff = self.M_nominal @ q_d_ddot + self.C_nominal @ q_d_dot

        # 神经网络补偿
        state = np.concatenate([q, q_dot])
        delta_hat = self.nn(torch.FloatTensor(state)).detach().numpy()

        # 总控制
        tau = tau_pd + tau_ff + delta_hat
        return tau

9.2 四旋翼姿态控制

class QuadrotorAdaptiveAttitude:
    """四旋翼自适应姿态控制"""
    def __init__(self):
        # 标称惯量
        self.J_nominal = np.diag([0.01, 0.01, 0.02])

        # 自适应神经网络（补偿气动干扰等）
        self.nn = RBFNetwork(input_dim=6, num_centers=50, output_dim=3)

        # 控制增益
        self.K_att = np.diag([5, 5, 2])
        self.K_rate = np.diag([1, 1, 0.5])

    def control(self, attitude, angular_rate, att_d, rate_d):
        """计算力矩指令"""
        # 姿态误差（四元数或欧拉角）
        e_att = att_d - attitude
        e_rate = rate_d - angular_rate

        # PD控制
        tau_pd = self.K_att @ e_att + self.K_rate @ e_rate

        # 自适应补偿
        state = np.concatenate([attitude, angular_rate])
        tau_ad = self.nn(torch.FloatTensor(state)).detach().numpy()

        return tau_pd + tau_ad

---

10. 总结

本篇系统介绍了神经网络自适应控制：

核心要点：

1. 问题本质：用NN逼近未知不确定性
2. 稳定性保证：Lyapunov设计自适应律
3. RBF网络：自适应控制的经典选择
4. 深度网络：分层适应或复合学习
5. 应用场景：机械臂、飞行器等精确控制

关键公式：

控制律：
$$u=u_{bl}+u_{ad}=g^{-1}(-f+{\dot{x}}_d-Ke)-g^{-1}{\hat{W}}^T\varphi (x)$$

自适应律：
$$\dot{\hat{W}}=\Gamma \varphi (x)e^{T}PB-\sigma \hat{W}$$

Lyapunov函数：
$$V=\frac{1}{2}{e}^{T}Pe+\frac{1}{2}\text{tr}({\tilde{W}}^T{\Gamma }^{-1}\tilde{W})$$

选择建议：

• 需要稳定性保证 → NN自适应控制
• 样本效率不是主要问题 → 深度RL
• 两者结合 → Lyapunov约束RL

---

参考文献

1. Lewis, F. L., et al. (1999). Neural Network Control of Robot Manipulators and Nonlinear Systems. Taylor & Francis.
2. Ge, S. S., & Wang, C. (2002). Adaptive NN control of uncertain nonlinear pure-feedback systems. Automatica.
3. Berkenkamp, F., et al. (2017). Safe Model-based Reinforcement Learning with Stability Guarantees. NeurIPS.
4. Chang, Y. C., et al. (2019). Neural Lyapunov Control. NeurIPS.

---

下一篇预告：深度学习驱动的控制方法详解（十）：Physics-Informed Neural Networks控制

我们将学习如何将物理约束嵌入神经网络，实现物理一致的学习控制。

---

如果觉得本文有帮助，欢迎点赞收藏，关注本系列后续更新！