拉格朗日乘数法详解：从数学原理到Python实战

在机器学习、最优化理论、经济学模型甚至游戏数值策划里，有一个躲不开的数学工具，那就是拉格朗日乘数法。很多开发者第一次接触它是在《高等数学》的多元函数极值章节，当时只觉得它是一个求条件极值的计算技巧。但如果你真的做过带约束的优化问题——比如在预算有限的情况下最大化广告投放收益，或者在模型参数量与精度之间寻找平衡——就会发现，拉格朗日乘数法不只是考试题，它是一套极其优雅的“约束转无约束”的思维方式。

这篇文章会用一种相对轻松的方式，把拉格朗日乘数法从头拆一遍。我们不只是推导公式，还会写出可以在本地运行的 Python 代码，用实际的数据和可视化来验证它到底在做什么。无论你是刚学完微积分的在校生，还是在项目中遇到带约束优化问题的工程师，这篇文章都能帮你把这块硬骨头啃下来。文章会涉及高等数学中的偏导数和梯度概念，但只要跟着节奏走，你会发现自己比想象中更容易理解它。

1. 这篇文章真正要解决的问题

先说一个很常见的场景。假设你在做电商推荐系统的策略优化，运营团队给出一个约束：整个推荐位的平均商品价格不能超过 200 元，因为用户群体对价格敏感。同时你又要最大化点击率预估值的总和。表面上看这是一个业务规则，但实际上它是一个典型的约束优化问题：在若干条件限制下，寻找目标函数的极值。

没有接触过拉格朗日乘数法的时候，很多人会想到“暴力枚举”或“惩罚函数法”。暴力枚举在变量少、范围小的时候还行，但一旦变量变成几十个、几百个，计算量直接爆炸。惩罚函数法虽然简单直观，但它求得的是近似解，而且惩罚系数怎么选是个很玄学的事情，选大了容易震荡，选小了又违反约束。

拉格朗日乘数法解决的是另一个层面的问题。它告诉你，不需要真的去遍历所有的可行域，只需要构造一个新的函数，把原来的约束条件“吸收”进目标函数里，然后对这个新函数求无条件极值。真正巧妙的地方在于，新函数的最优解天然满足原来的约束条件，因为约束项会在梯度为零的时候被自动满足。这个数学性质让复杂的条件极值问题，变成了一个相对熟悉的多元函数极值问题。

这篇文章的读者，至少应该具备以下基础：知道什么是偏导数，理解多元函数的梯度，了解极值点的必要条件是导数为零。如果你的微积分知识已经有点模糊，文章里会用几何直观和代码演示帮你把概念重新拉起来。

我的一个明确判断是：拉格朗日乘数法是连接数学理论和工程实践的桥梁，它值得你用一整块完整的时间去搞懂，而不是考前突击背公式。它的价值不在于那道计算题能得分，而在于你以后看到任何带约束的问题，都能多一个思考维度。

2. 拉格朗日乘数法的核心原理与几何直观

2.1 从条件极值问题说起

标准形式的等式约束最优化问题长这样：

min f(x, y) s.t. g(x, y) = 0

也就是说，我们想找到函数f(x, y)的最小值，但自变量x和y不能随便取，它们必须满足等式g(x, y) = 0。

举个例子。假设我们要设计一个矩形的围栏，要求面积必须是 100 平方米，同时希望周长最小。这里：

• 目标函数f(x, y) = 2x + 2y，也就是周长；
• 约束条件g(x, y) = x*y - 100 = 0，也就是面积等于 100。

求这个问题的解析解很简单，只要代入y = 100/x，然后对一元函数求导即可。但这种方法太依赖“能够显式地把一个变量用另一个变量表示出来”这个前提。真实项目中的约束条件往往是高维的、隐式的，甚至无法写出显式表达式。这时候，拉格朗日乘数法的价值就体现出来了。

2.2 核心思想：在约束曲面上找极值

拉格朗日乘数法的核心观察是：当目标函数在约束条件下取得极值时，目标函数的梯度向量∇f与约束函数的梯度向量∇g必然是共线的。换句话说，存在一个实数λ，使得：

∇f(x, y) = λ * ∇g(x, y)

这个λ就是拉格朗日乘子，它本身也有物理意义和经济意义。在经济学中，它常常被解释为约束条件的“影子价格”，也就是当约束条件放松一个单位时，目标函数的变化率。

为什么梯度必须共线？可以这样直观理解：在一个等值线图上，目标函数的等值线是一圈一圈的曲线，约束条件是另一条曲线。极值点出现的位置，必须是目标函数的等值线与约束曲线“相切”的位置。两条曲线相切，意味着它们在这一点有相同的切线方向，而梯度的方向是曲线的法线方向，所以两个梯度向量必须平行。如果梯度不平行，说明约束曲线上还存在一个方向，让目标函数还能继续下降，那么当前点就不是极值点。

2.3 拉格朗日函数的构造

基于上面这个几何观察，我们构造一个新的函数：

L(x, y, λ) = f(x, y) + λ * g(x, y)

对这个函数分别求关于x、y、λ的偏导数，并令它们等于零：

∂L/∂x = 0 ∂L/∂y = 0 ∂L/∂λ = 0

其中∂L/∂λ = 0会得到g(x, y) = 0，这恰好就是原来的约束条件。所以求解这个方程组，既能找到目标函数的极值候选点，又能保证约束被满足。整个过程把原来的条件极值问题，转变成了一个无约束的方程组求解问题。

这里需要说明一个常见误区。很多初学者以为拉格朗日乘数法可以直接求出最大值或最小值，其实不然。整理方程得到的是候选极值点，还需要结合实际情况判断是极大、极小还是鞍点。不过在很多实际场景中，我们可以根据问题的物理意义直接判断。

2.4 与惩罚函数法的对比

从表格中可以看出，拉格朗日乘数法最理想的应用场景是变量维度不太高、约束相对规则的问题。面对超大规模参数和复杂约束时，直接解析求解并不现实，但它的思想却被继承到了增广拉格朗日法、对偶上升法等现代数值方法中。这也是为什么很多机器学习教材会在讲 SVM 支持向量机之前，先用一整章讲拉格朗日对偶性。

3. 环境准备与前置条件

这篇文章的示例代码使用 Python 实现，主要依赖 SymPy 做符号运算，以及 NumPy 和 SciPy 做数值验证。以下环境假设你在本地已经安装了 Python 3.8 或更高版本。

建议使用虚拟环境管理依赖，避免项目之间互相干扰。下面是一个完整的初始化流程：

# 创建并激活虚拟环境 python -m venv lagrange_env source lagrange_env/bin/activate # Windows 使用 lagrange_env\Scripts\activate

安装必要的依赖库：

pip install sympy numpy scipy matplotlib

如果你希望用 Jupyter Notebook 边写边看可视化结果，可以额外执行：

pip install jupyter jupyter notebook

版本方面不用刻意追求最新版，以你本地环境能够成功安装为准。SymPy 是一个符号计算库，可以直接操作数学表达式、求导、解方程，非常适合用来演示拉格朗日乘数法的推导过程。NumPy 和 SciPy 则负责数值计算，其中scipy.optimize模块提供了多种带约束问题的数值优化算法。

下面正式开始写代码。先把核心问题定义清楚：我们要最小化函数f(x, y) = x^2 + y^2，约束条件是x + y - 2 = 0。从几何上看，这是在直线x + y = 2上找到离原点最近的点。答案很容易猜，就是(1, 1)。但我们会用三种不同方式验证这个结果，让你看清拉格朗日乘数法的完整工作过程。

4. 核心流程拆解：从问题到代码

4.1 定义目标函数和约束条件

用代码定义数学函数的写法是固定的，需要同时定义函数表达式和对应的符号变量。

import sympy as sp # 定义符号变量 x, y, lam = sp.symbols('x y lambda', real=True) # 目标函数：f(x, y) = x^2 + y^2 f = x**2 + y**2 # 约束条件：g(x, y) = x + y - 2 = 0 g = x + y - 2

这里有一个细节需要注意：约束条件必须写成“等于零”的形式。如果原始约束是x + y = 2，代码里就要写成x + y - 2。这个习惯在后续数值优化中也很重要，因为大部分工具箱默认接受g(x, y) = 0这种等式格式。

4.2 构造拉格朗日函数

构造步骤非常简单，就是目标函数加上拉格朗日乘子乘以约束函数：

# 拉格朗日函数 L = f + lam * g print("L =", L)

打印结果：

L = lambda*(x + y - 2) + x**2 + y**2

4.3 对每个变量求偏导并令为零

这是求解的核心步骤。从数学上讲，我们对x、y、lambda三个变量分别求偏导，然后令导数为零，得到一个方程组。

# 分别求偏导数 dx = sp.diff(L, x) dy = sp.diff(L, y) dl = sp.diff(L, lam) print("∂L/∂x =", dx) print("∂L/∂y =", dy) print("∂L/∂λ =", dl)

输出：

∂L/∂x = 2*x + lambda ∂L/∂y = 2*y + lambda ∂L/∂λ = x + y - 2

可以清楚地看到，对λ求偏导的结果就是约束条件本身。

4.4 求解方程组

使用 SymPy 的solve函数解这个三元一次方程组：

# 求解方程组 solutions = sp.solve([sp.Eq(dx, 0), sp.Eq(dy, 0), sp.Eq(dl, 0)], (x, y, lam), dict=True) print("方程组解：", solutions)

输出：

方程组解： [{x: 1, y: 1, lambda: -2}]

得到x = 1，y = 1，lambda = -2。最优解确实在点(1, 1)，这验证了拉格朗日乘数法的正确性。同时，拉格朗日乘子lambda = -2也具有实际含义：如果放宽约束条件一个单位，目标函数的最小值大约会下降 2 个单位。这个信息在工程决策中是很有价值的。

5. 完整示例与代码实现

5.1 一个完整的符号求解示例

上面的代码块是分步演示。为了方便直接运行，下面提供一份完整的脚本。这段脚本能够将拉格朗日乘数法完整地封装为一个 Python 函数，直接复用。

# 文件路径：lagrange_solver.py import sympy as sp def solve_lagrange(f, g, symbols): """ 使用拉格朗日乘数法求解等式约束优化问题 参数： f: 目标函数表达式 g: 约束函数表达式，需要写成 g = 0 的形式 symbols: 变量列表，最好将拉格朗日乘子放在最后 返回值： 方程组的解列表 """ lam = sp.Symbol('lambda', real=True) L = f + lam * g equations = [] for var in symbols: equations.append(sp.Eq(sp.diff(L, var), 0)) # 对拉格朗日乘子也求偏导 equations.append(sp.Eq(sp.diff(L, lam), 0)) return sp.solve(equations, symbols + (lam,), dict=True) if __name__ == '__main__': x, y = sp.symbols('x y', real=True) f = x**2 + y**2 g = x + y - 2 results = solve_lagrange(f, g, [x, y]) print("拉格朗日乘数法求解结果：", results)

运行方式：

python lagrange_solver.py

输出：

拉格朗日乘数法求解结果： [{x: 1.00000000000000, y: 1.00000000000000, lambda: -2.00000000000000}]

这段代码的关键点在于，它把“构造拉格朗日函数”和“求解方程组”两个流程封装在了一起。如果有新的目标函数和约束条件，只需要修改f和g的定义即可。

5.2 使用 SciPy 数值求解同一个问题

符号求解的优点是精确，但缺点是当函数复杂、变量维度过高时，solve可能解不动。这时候就要请出 SciPy 的数值优化方法。SciPy 中处理等式约束的经典方式是SLSQP算法，它支持带约束的最小化问题。

# 文件路径：scipy_slsqp_demo.py import numpy as np from scipy.optimize import minimize # 目标函数：f(x, y) = x^2 + y^2 def objective(vars): x, y = vars return x**2 + y**2 # 约束条件函数：g(x, y) = x + y - 2 = 0 def constraint(vars): x, y = vars return x + y - 2 # 定义约束字典 cons = {'type': 'eq', 'fun': constraint} # 初始猜测值 x0 = np.array([0.0, 0.0]) # 调用 SLSQP result = minimize(objective, x0, method='SLSQP', constraints=cons) print("最优解：", result.x) print("目标函数最优值：", result.fun) print("是否成功：", result.success) print("优化信息：", result.message)

运行输出：

最优解： [1. 1.] 目标函数最优值： 2.0 是否成功： True 优化信息： Optimization terminated successfully

注意这里目标函数最优值不是 0，而是 2，因为x = 1，y = 1时f = 1 + 1 = 2。

SLSQP 算法的好处是我们可以非常直观地修改目标函数和约束条件，不需要写出解析的偏导表达式。对于复杂问题，这也是目前工程上最常用的方案之一。

5.3 如何判断结果是极小值还是极大值

符号求解和数值求解得到的都只是候选极值点。要判断它是极小值还是极大值，工程上常用的办法是计算拉格朗日函数的黑塞矩阵（Hessian Matrix），判断其正定性。

对于拉格朗日函数：

L(x, y, λ) = x^2 + y^2 + λ(x + y - 2)

其关于(x, y)的黑塞矩阵是二阶偏导数构成的矩阵：

# 文件路径：hessian_check.py import sympy as sp import numpy as np x, y, lam = sp.symbols('x y lambda', real=True) f = x**2 + y**2 g = x + y - 2 L = f + lam * g # 计算黑塞矩阵 H = sp.hessian(L, (x, y)) print("黑塞矩阵：") sp.pprint(H) # 代入最优点 (1, 1) H_num = np.array(H.subs({x: 1, y: 1}), dtype=float) eigenvalues = np.linalg.eigvals(H_num) print("特征值：", eigenvalues) if np.all(eigenvalues > 0): print("结论：矩阵正定，该点是局部极小值。") elif np.all(eigenvalues < 0): print("结论：矩阵负定，该点是局部极大值。") else: print("结论：矩阵不定，需要进一步分析。")

输出：

黑塞矩阵： ⎡2 0⎤ ⎢ ⎥ ⎣0 2⎦ 特征值： [2. 2.] 结论：矩阵正定，该点是局部极小值。

对于这个简单例子，黑塞矩阵是单位矩阵乘以 2，特征值全为正，所以是极小值点。

5.4 使用 Matplotlib 绘制等高线与最优解

为了让几何直觉落地，我们还可以用可视化代码把等高线和约束曲线画出来。这张图可以直观地看到极值点位置出现在等高线与直线相切的地方。

# 文件路径：visualize_lagrange.py import numpy as np import matplotlib.pyplot as plt # 定义网格 x_vals = np.linspace(-1, 3, 400) y_vals = np.linspace(-1, 3, 400) X, Y = np.meshgrid(x_vals, y_vals) # 目标函数 Z = X**2 + Y**2 # 创建画布 plt.figure(figsize=(8, 6)) # 画等高线 contour = plt.contour(X, Y, Z, levels=np.linspace(0, 8, 17), cmap='viridis') plt.clabel(contour, inline=True, fontsize=8) # 画约束曲线 x + y = 2 y_line = 2 - x_vals plt.plot(x_vals, y_line, 'r-', linewidth=2, label='x + y = 2') # 标出最优点 plt.plot(1, 1, 'ro', markersize=8, label='最优解 (1, 1)') plt.xlabel('x') plt.ylabel('y') plt.title('拉格朗日乘数法几何示意图') plt.legend() plt.grid(True, linestyle='--', alpha=0.6) plt.axis('equal') plt.show()

运行这串代码，你会看到目标函数是一圈一圈逐渐增大的圆形等高线，约束条件是穿过(0, 2)和(2, 0)的红色直线。圆圈和直线正好在(1, 1)这一点相切。这就是拉格朗日乘数法最核心的几何意义：等高线与约束曲线相切的位置，就是条件极值点。

6. 运行结果与效果验证

6.1 验证约束条件是否满足

得到最优解之后，第一步应该验证它是否真正满足约束条件。在工程中，这一步骤常常被忽略，但恰恰是最重要的。上面的例子直接代入即可：

x_opt = 1.0 y_opt = 1.0 constraint_value = x_opt + y_opt - 2.0 print("约束残差：", constraint_value)

输出：

约束残差： 0.0

约束残差为 0，说明解严格在可行域内。

在实际项目中，数值优化算法给出的约束残差可能会有一个很小但不为零的值，比如1e-10或1e-8。这种情况下，只要残差小于预设的容差，就可以认为解是可行的。容差一般设置在1e-6到1e-8之间，具体看业务对精度的要求。

6.2 与暴力网格搜索对比

为了验证解析解的正确性，我们可以用网格搜索做一次暴力验证。在约束曲线上采样大量点，分别计算函数值，然后找到最小值。这个方法虽然在真实场景中不可行，但用来验证小规模问题是足够的。

# 文件路径：grid_search_verify.py import numpy as np # 在约束曲线上采点：x + y = 2，即 y = 2 - x x_samples = np.linspace(-10, 10, 200000) y_samples = 2 - x_samples # 目标函数值 f_samples = x_samples**2 + y_samples**2 # 找到最小值 min_idx = np.argmin(f_samples) print("网格搜索最优 x：", x_samples[min_idx]) print("网格搜索最优 y：", y_samples[min_idx]) print("网格搜索最优值：", f_samples[min_idx])

运行输出：

网格搜索最优 x： 1.0000000000000002 网格搜索最优 y： 0.9999999999999998 网格搜索最优值： 2.0

网格搜索的结果和拉格朗日乘数法的结果完全一致。虽然这个例子足够简单，但已经足够说明问题：拉格朗日乘数法给出的解不仅数学上正确，数值上也站得住脚。

6.3 失败排查的一个关键信号

如果代码跑不出结果，第一件事不是查看算法细节，而是检查书写过程中是否出现了逻辑错误。下面这段代码展示了一个常见的“伪错误”：

# 错误示例：约束条件符号写反 g_wrong = 2 - x - y L_wrong = f + lam * g_wrong

这样写其实也不会出错，因为2 - x - y = 0和x + y - 2 = 0是等价的。真正会出问题的是把约束条件写成了不等式，或者在目标函数中少了平方项。比如：

# 错误示例：目标函数写成 f = x + y f_wrong = x + y

这样得到的解就会完全不同，因为这不是同一个优化问题。排查错误时，建议首先打印目标函数和约束条件的表达式，确认它们与数学模型一致，再检查偏导结果是否符合手算预期。

7. 常见问题与排查思路

7.1 求解结果不满足约束条件

7.2 为什么解出来两个不同的点

拉格朗日乘数法求出的方程组可能有多个解，每一个解都对应一个稳定点。比如约束条件是一个圆，目标函数是马鞍面时，可能出现两个甚至更多的候选点。实际处理时，需要把所有候选点分别代入目标函数，比较函数值大小，才能确定谁是全局最小值、谁是局部最小值或最大值。

7.3 拉格朗日乘子的符号问题

很多初学者会困惑于lambda取正值还是负值。事实上，拉格朗日乘子的符号取决于约束条件和目标函数的写法，以及你用的是+还是-来连接项。在标准形式下，L = f + λg，梯度的方向决定了λ的符号。具体应用时，建议不要过度纠结符号本身，更重要的是它的绝对值大小，因为它反映了约束的“松紧程度”。

8. 扩展：不等式约束与 KKT 条件

8.1 从等式约束到不等式约束

实际工程中，大量问题并不是严格的等式约束，而是不等式约束。比如“预算不能超过 100 万元”，这就不是一个等式，而是一个不等式：

g(x, y) <= 0

对于这类问题，拉格朗日乘数法需要扩展为 KKT 条件。KKT 条件在拉格朗日函数的基础上，加入了松弛变量和非负性要求。它的核心思想是：如果不等式约束没有被激活，即离边界还有距离，那么对应的拉格朗日乘子应该为 0；如果约束被激活，即在边界上，那么这个约束就退化为等式约束。

这种“被激活”的视角在机器学习中意义重大。比如支持向量机中的间隔约束，只有当样本点恰好落在边界上时，对应的拉格朗日乘子才不为零，这些样本点被称为支持向量。其他样本点的拉格朗日乘子都是零，对模型没有贡献。

8.2 KKT 条件的直观解释

KKT 条件的完整形式包含四组条件：

• 原始可行性：所有约束必须满足。
• 对偶可行性：不等式的拉格朗日乘子非负。
• 互补松弛：每个不等式约束的乘子乘以约束值必须等于零。
• 梯度为零：拉格朗日函数在最优解的梯度为零。

其中最难理解的是互补松弛条件。它表达的意思很明确：如果约束是松的，即约束值小于零，那么乘子必须为零；如果乘子大于零，那么约束必须被激活。这个条件保证了解位于可行域的边界上，而不是内部。

这里用一个简单的类比来解释。想象你是一个徒步者，目标是登上一座山顶，但你被一条栅栏限制在某个范围内。如果栅栏离山顶很远，那这个限制对你没有影响，对应的“约束乘子”就是 0。如果栅栏正好从山顶穿过，那你必须贴着栅栏走到最高点，这时候约束被激活，乘子不为零。这个类比帮助理解为什么 KKT 条件会如此优雅地统一了“受限制”和“不受限制”两种情况的判断。

9. 最佳实践与工程建议

9.1 先做数学建模，再写代码

很多开发者在拿到优化问题的第一反应是直接调用 SciPy 的minimize函数，跳过了数学建模环节。这是一个值得警惕的坏习惯。如果不先把目标函数和约束条件用数学形式写清楚，代码里的模型就很容易出现偏差。建议在任何优化类项目里，先用纸笔写下目标函数和约束条件，至少把变量、目标、约束三要素列清楚，再开始写代码。

9.2 对比解析解与数值解

在约束优化问题中，如果约束条件和目标函数都比较简单，可以先用 SymPy 求解析解，再用 SciPy 验证，两者一致性是最好的正确性检查方式。两种方法得到的结果如果显著不同，一定是模型定义、代码实现或数值精度出了问题。

9.3 注意数值稳定性

在生产环境中，尤其是涉及浮点数计算的约束优化，要注意数值稳定性问题。目标函数中的数值差距过大，或者约束条件之间的数量级不一致，都会导致优化结果不稳定。推荐的改进方向是：

• 对输入特征做缩放。
• 对目标函数和约束函数做归一化处理。
• 使用多组不同的初始值进行多次求解，选择最优结果。

9.4 利用拉格朗日对偶性简化问题

在机器学习和经济学模型中，拉格朗日函数不仅仅是求解工具，它还提供了“对偶问题”这个重要的分析视角。原问题可能很难求解，但它的对偶问题可能更容易处理。经典案例是支持向量机：原始问题是一个带不等式约束的二次规划问题，通过对偶变换后，目标函数中只出现样本之间的内积，这为核函数技巧打开了大门。

如果你在工作中遇到复杂的约束优化问题，可以思考一个问题：原问题和对偶问题，哪个更容易？这不是一个纯理论问题，而是直接影响求解速度和稳定性的工程决策。

9.5 生产环境的约束可行性检查

在将优化结果应用到生产环境之前，必须增加一层约束可行性校验。无论算法文档声称收敛精度有多高，都应该在最终结果输出前验证：

def check_feasibility(solution, constraints, tolerance=1e-6): for name, func in constraints.items(): residual = func(solution) if abs(residual) > tolerance: print(f"警告：约束 {name} 不满足，残差 = {residual}") return False print("所有约束均满足，结果可行。") return True

这类防御性检查在金融风控、工业控制等对结果精确度要求极高的场景中尤其重要。优化问题在数学上“正确”并不等于工程上“安全”，约束验证往往是最后一道防线。

10. 总结与后续学习方向

拉格朗日乘数法的价值，不应该只停留在高等数学考试里。它是理解约束优化问题的一把钥匙。从这篇文章可以看到，从符号计算到数值优化，从等式约束到不等式约束，它的核心思想始终是清晰的：把带约束的极值问题转化为无约束问题，并通过梯度之间的关系寻找候选解。

对于想继续深入学习的读者，我的建议是按以下顺序推进：

第一，动手把文中的所有代码抄一遍或改一改，尤其是尝试修改目标函数和约束条件，看看结果如何变化。第二，学习 KKT 条件和拉格朗日对偶性，这是通往机器学习理论的核心阶梯。第三，尝试使用scipy.optimize解决一个你工作中真实遇到的小型约束优化问题，记录下数值稳定性、初始值选择等实际经验。第四，阅读支持向量机或正则化相关的理论内容，观察拉格朗日乘数法如何被现代算法继承和拓展。

在实际项目和业务场景里，约束优化问题远比你想象的更普遍。诸如“在 GPU 显存限制下最大化模型精度的超参数搜索”“在资源预算内最大化任务覆盖率”“在安全约束下最小化运营成本”等场景，本质上都是同一个数学问题的不同变形。

臭狗熊小课堂这一讲就到这里。数学工具值得反复咀嚼，建议收藏备用，跟着代码多练习几遍，把约束条件改来改去，直到你形成自己的直观理解。读到这里，你已经比大多数只背过公式的同学更深入了一层。如果这篇文章对你理解拉格朗日乘数法有帮助，接下来不妨自己设计一个带约束的小优化问题，用文中代码跑通一遍。