用Python可视化凹函数:5个经济学案例带你理解边际效用递减
最近在整理一些经济学模型的代码时,我又一次被凹函数那种“先快后慢”的增长曲线所吸引。无论是分析消费者多喝一杯奶茶带来的满足感变化,还是评估一个项目追加投资所能获得的额外回报,背后都离不开凹函数这个数学模型。对于有数据分析和经济学背景的朋友来说,理解凹函数不仅仅是掌握一个数学概念,更是打开一扇观察现实世界规律的门窗。它用一种直观的几何形态,精准刻画了经济学中那个经典原理——边际效用递减。
今天,我们不打算从枯燥的数学定义开始。我想直接带你动手,用Python的Matplotlib和Seaborn库,画几个活生生的凹函数曲线。我们会把对数函数、平方根函数这些抽象的数学式子,放进五个具体的经济学场景里:从个人的消费选择到企业的生产决策,再到金融领域的投资组合。你会发现,这些曲线的“凹”下去的弧度,恰恰就是现实决策中“收益递减”现象最优雅的数学表达。文章附带的代码都是完整的、可运行的Jupyter Notebook单元,你可以直接复制粘贴,边看边动手,让理解从图表中自然生长出来。
1. 凹函数:不只是数学,更是经济直觉的几何化
在深入案例之前,我们得先统一一下语言。凹函数在数学上的严格定义是:对于定义域内任意两点,连接这两点的线段总位于函数图像的下方或之上。但对我们而言,一个更直观的理解是:它的增长是“减速”的。随着你投入的变量(比如金钱、时间、资源)不断增加,产出或效用的增加量却在逐渐减少。
想象一下你吃第一块巧克力时的巨大幸福感,和吃到第五块时可能已经感到腻味的对比。这种体验的变化,用凹函数来建模再合适不过。
从数学性质上看,凹函数有几个关键特征,这些特征直接对应了它在优化问题中的价值:
- 一阶导数单调递减:这意味着函数的斜率(即边际变化率)随着输入增加而变小。在经济学里,这个斜率就是“边际量”(如边际效用、边际产出)。
- 二阶导数非正:这从曲率上确认了函数的“凹性”。一个负的二阶导数意味着曲线是“向下弯曲”的。
- 局部最大值即全局最大值:这是凹函数在优化问题中最宝贵的性质。当你为一个凹函数寻找最大值时,不必担心陷入局部最优的陷阱,找到的山顶就是唯一的最高峰。这为许多经济模型的求解提供了理论保障。
注意:在数学和优化理论中,对“凸”(Convex)和“凹”(Concave)的定义有时会因上下文而异(如上凸、下凸)。本文遵循经济学和主流机器学习文献中的常见用法:凹函数(Concave Function) 指函数图像像一座倒扣的山丘(∩形),其二次导数为负或零。
下面这个简单的Python代码,可以快速生成并对比一个典型的凹函数(自然对数)和一个线性函数的图像,感受一下“减速增长”的视觉差异。
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# 设置绘图风格
sns.set_style("whitegrid")
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
# 定义x轴范围
x = np.linspace(0.1, 10, 400) # 对数函数定义域需大于0
y_concave = np.log(x) # 凹函数:自然对数
y_linear = 0.5 * x # 线性函数作为对比
# 绘制图像
fig, ax = plt.subplots(figsize=(10, 6))
ax.plot(x, y_concave, 'b-', linewidth=3, label='凹函数: $y = \ln(x)$')
ax.plot(x, y_linear, 'r--', linewidth=2, label='线性函数: $y = 0.5x$')
ax.fill_between(x, y_concave, y_linear, where=(y_concave <= y_linear), color='red', alpha=0.3, interpolate=True)
ax.fill_between(x, y_concave, y_linear, where=(y_concave > y_linear), color='blue', alpha=0.3, interpolate=True)
# 添加标注和美化
ax.set_xlabel('投入 (x)', fontsize=12)
ax.set_ylabel('产出/效用 (y)', fontsize=12)
ax.set_title('凹函数 vs. 线性函数:减速增长与匀速增长', fontsize=14, fontweight='bold')
ax.legend()
ax.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()
运行这段代码,你会看到蓝色实线代表的凹函数 ln(x),在初期增长迅猛,迅速超过红色的虚线(线性增长)。但随着x增大,其增长速度放缓,红色填充区域表示线性函数最终会反超。这个“先超后缓”的过程,正是边际递减的视觉体现。
2. 案例一:消费者效用与边际效用递减
这是经济学入门必讲的概念。假设一个消费者的效用(满足感)来自于消费某种商品的数量。我们常用凹函数来建模效用函数,例如 U(x) = √x 或 U(x) = ln(1+x)。这里,x 代表消费量,U(x) 代表总效用。
为什么是凹函数?因为第一单位商品带来的满足感(边际效用)最大,第二单位次之,以此类推。吃第一个苹果很解渴,第二个也不错,但吃到第十个时,可能已经不想再吃了,甚至产生负效用(此时函数可能就不再是简单的凹函数了)。
让我们用 U(x) = 10 * √x 这个效用函数来模拟,并计算其边际效用 MU(x) = dU/dx。
import numpy as np
import matplotlib.pyplot as plt
from scipy.misc import derivative
# 定义效用函数 U(x) = 10 * sqrt(x)
def utility(x):
return 10 * np.sqrt(x)
# 计算边际效用 (导数)
def marginal_utility(x):
# 使用数值微分,对于sqrt(x),解析导数为 5/sqrt(x)
return derivative(utility, x, dx=1e-6)
# 生成数据
x_vals = np.linspace(1, 100, 100)
u_vals = utility(x_vals)
mu_vals = marginal_utility(x_vals)
# 创建双轴图
fig, ax1 = plt.subplots(figsize=(12, 7))
color = 'tab:blue'
ax1.set_xlabel('消费数量 (x)', fontsize=12)
ax1.set_ylabel('总效用 U(x)', color=color, fontsize=12)
ax1.plot(x_vals, u_vals, color=color, linewidth=3, label='总效用曲线')
ax1.tick_params(axis='y', labelcolor=color)
ax1.grid(True, alpha=0.3)
# 实例化第二个y轴
ax2 = ax1.twinx()
color = 'tab:red'
ax2.set_ylabel('边际效用 MU(x)', color=color, fontsize=12)
ax2.plot(x_vals, mu_vals, color=color, linestyle='--', linewidth=2.5, label='边际效用曲线')
ax2.tick_params(axis='y', labelcolor=color)
# 添加标题和图例
fig.suptitle('消费者效用分析:总效用凹增长与边际效用递减', fontsize=15, fontweight='bold')
# 合并图例
lines_1, labels_1 = ax1.get_legend_handles_labels()
lines_2, labels_2 = ax2.get_legend_handles_labels()
ax2.legend(lines_1 + lines_2, labels_1 + labels_2, loc='center right')
plt.tight_layout()
plt.show()
# 输出特定消费量下的边际效用
consumption_points = [1, 4, 9, 16, 25]
print("不同消费量下的边际效用:")
for cp in consumption_points:
print(f" 当消费 {cp} 个单位时,边际效用约为 {marginal_utility(cp):.4f}")
这张图会清晰地展示:蓝色的总效用曲线是凹的——它在增加,但增加得越来越慢。红色的边际效用曲线则是一条向右下方倾斜的直线(对于 √x 函数而言),直观地展示了“递减”的过程。从打印的数据中,你也能看到,消费量从1增加到4时,边际效用下降很快,而从16到25时,下降幅度已经很小了。
3. 案例二:生产函数与边际产出递减
现在我们转向生产者一方。假设一个企业的产出 Q 依赖于单一可变投入 L(比如劳动力),生产函数 Q = f(L) 也常常具有凹性。经典的例子是 Q = A * √L 或 Q = A * ln(L),其中 A 代表技术水平。
这反映了生产中的边际报酬递减规律:在技术和其他投入不变的情况下,连续增加某一可变要素的投入,其带来的产出增量最终会减少。比如,在固定的办公空间里,不断增加程序员,初期效率提升明显,但人数过多后,沟通成本激增,每个人新增的代码产出反而会下降。
我们来模拟一个更通用的柯布-道格拉斯生产函数的简化版:Q = L^0.7。这里指数小于1,保证了函数的凹性。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# 定义生产函数 Q = L^alpha, alpha < 1 时为凹函数
def production(L, alpha=0.7):
return np.power(L, alpha)
# 计算平均产出(APL)和边际产出(MPL)
def analyze_production(L_vals, alpha=0.7):
Q_vals = production(L_vals, alpha)
APL_vals = Q_vals / L_vals # 平均产出 = Q / L
# 边际产出 MPL = dQ/dL = alpha * L^(alpha-1)
MPL_vals = alpha * np.power(L_vals, alpha - 1)
return pd.DataFrame({
'劳动力(L)': L_vals,
'总产出(Q)': Q_vals,
'平均产出(APL)': APL_vals,
'边际产出(MPL)': MPL_vals
})
# 生成数据
L_range = np.linspace(1, 50, 50)
df_production = analyze_production(L_range)
# 绘制生产函数家族曲线
fig, axes = plt.subplots(1, 3, figsize=(18, 5))
# 子图1:总产出曲线
axes[0].plot(df_production['劳动力(L)'], df_production['总产出(Q)'], 'darkgreen', linewidth=3)
axes[0].set_title('总产出曲线 Q(L)', fontsize=13, fontweight='bold')
axes[0].set_xlabel('劳动力投入 (L)')
axes[0].set_ylabel('总产出 (Q)')
axes[0].fill_between(df_production['劳动力(L)'], 0, df_production['总产出(Q)'], alpha=0.2, color='green')
axes[0].grid(True, linestyle=':', alpha=0.5)
# 子图2:平均产出与边际产出曲线
axes[1].plot(df_production['劳动力(L)'], df_production['平均产出(APL)'], 'orange', linewidth=2.5, label='平均产出 APL')
axes[1].plot(df_production['劳动力(L)'], df_production['边际产出(MPL)'], 'purple', linestyle='--', linewidth=2.5, label='边际产出 MPL')
axes[1].set_title('平均产出与边际产出曲线', fontsize=13, fontweight='bold')
axes[1].set_xlabel('劳动力投入 (L)')
axes[1].set_ylabel('产出率')
axes[1].legend()
axes[1].grid(True, linestyle=':', alpha=0.5)
# 子图3:边际产出递减的增量演示
# 选取几个点,计算增加1单位劳动带来的产出增量
L_sample = np.array([5, 15, 30])
Q_sample = production(L_sample)
Q_sample_plus1 = production(L_sample + 1)
increments = Q_sample_plus1 - Q_sample
axes[2].bar([f'L={int(l)}' for l in L_sample], increments, color=['skyblue', 'lightcoral', 'lightgreen'])
axes[2].set_title('边际产出递减:增加1单位劳动的产出增量', fontsize=13, fontweight='bold')
axes[2].set_ylabel('产出增量 ΔQ')
for i, v in enumerate(increments):
axes[2].text(i, v + 0.01, f'{v:.3f}', ha='center', va='bottom')
plt.suptitle('生产函数中的凹性与边际报酬递减', fontsize=16, fontweight='bold')
plt.tight_layout()
plt.show()
# 展示关键数据点
print("生产分析关键数据点:")
print(df_production.iloc[[0, 4, 9, 19, 29]]) # 展示第1,5,10,20,30个数据点
通过这三个子图,你可以全面观察到凹性生产函数的特点:总产出曲线上升但趋于平缓;边际产出曲线始终在平均产出曲线上方并向下倾斜(这是凹函数的性质决定的);柱状图则赤裸裸地显示,从5个劳动力增加到6个,带来的产出增量远大于从30个增加到31个。
4. 案例三:风险厌恶与效用函数的凹性
在金融和决策理论中,凹函数扮演着核心角色,用于描述风险厌恶。一个风险厌恶者的效用函数 U(W) 关于财富 W 是凹的。这意味着,失去一定量财富带来的痛苦,大于获得等量财富带来的快乐。
经典模型是对数效用函数 U(W) = ln(W)。假设有两个投资选择:A是确定获得50元;B是50%概率获得100元,50%概率获得0元。两者的期望收益都是50元。一个风险厌恶者会怎么选?
import numpy as np
import matplotlib.pyplot as plt
# 定义对数效用函数
def log_utility(wealth):
return np.log(wealth)
# 定义两个投资方案
wealth_A = 50 # 确定收益
wealth_B = np.array([100, 0]) # 风险收益
prob_B = np.array([0.5, 0.5])
# 计算期望财富和期望效用
expected_wealth_A = wealth_A
expected_utility_A = log_utility(wealth_A)
expected_wealth_B = np.sum(prob_B * wealth_B)
expected_utility_B = np.sum(prob_B * log_utility(wealth_B))
# 计算确定性等值(CE):带来与风险选择相同效用的确定财富量
# U(CE) = E[U(W)] => CE = exp(E[U(W)])
certainty_equivalent = np.exp(expected_utility_B)
# 可视化
W = np.linspace(1, 150, 300)
U = log_utility(W)
fig, ax = plt.subplots(figsize=(11, 7))
ax.plot(W, U, 'b-', linewidth=3, label='效用函数: $U(W) = \ln(W)$')
# 标记点A:确定收益
ax.scatter([wealth_A], [expected_utility_A], color='green', s=150, zorder=5, label=f'选择A: 确定获得{wealth_A}')
ax.text(wealth_A+2, expected_utility_A-0.1, f'A({wealth_A}, {expected_utility_A:.2f})', fontsize=11)
# 标记点B的两种可能结果
for w, p in zip(wealth_B, prob_B):
u = log_utility(w)
ax.scatter([w], [u], color='red' if w==0 else 'orange', s=100, alpha=0.7, zorder=5)
ax.text(w+2, u-0.15, f'B可能: ({w}, {u:.2f})', fontsize=10, color='red' if w==0 else 'orange')
# 标记期望点E[B]
ax.scatter([expected_wealth_B], [expected_utility_B], color='purple', s=200, marker='D', zorder=5, label=f'选择B的期望: E[W]={expected_wealth_B}, E[U]={expected_utility_B:.2f}')
ax.text(expected_wealth_B+2, expected_utility_B+0.05, f'E[B]({expected_wealth_B}, {expected_utility_B:.2f})', fontsize=11, color='purple')
# 标记确定性等值点(CE)
ax.scatter([certainty_equivalent], [expected_utility_B], color='darkred', s=200, marker='s', zorder=5, label=f'确定性等值(CE): {certainty_equivalent:.2f}')
ax.text(certainty_equivalent-15, expected_utility_B-0.25, f'CE({certainty_equivalent:.2f}, {expected_utility_B:.2f})', fontsize=11, color='darkred')
# 添加连接线,展示凹性的影响:弦在函数下方
# 连接风险结果两点,形成一条弦
B_points_x = wealth_B
B_points_y = log_utility(wealth_B)
ax.plot(B_points_x, B_points_y, 'r--', alpha=0.6, linewidth=1.5, label='风险结果的连线(弦)')
# 在期望财富点画垂线,显示弦上的效用(线性期望)高于函数上的效用(凹函数期望)
ax.plot([expected_wealth_B, expected_wealth_B], [0, np.mean(B_points_y)], 'gray', linestyle=':', alpha=0.8)
ax.set_xlabel('财富 (W)', fontsize=12)
ax.set_ylabel('效用 U(W)', fontsize=12)
ax.set_title('风险厌恶的凹函数诠释:确定性等值 < 期望财富', fontsize=14, fontweight='bold')
ax.legend(loc='lower right')
ax.grid(True, alpha=0.4)
plt.tight_layout()
plt.show()
# 输出决策分析
print("\n--- 投资决策分析 ---")
print(f"选择A(确定收益): 获得 {wealth_A} 元,效用为 {expected_utility_A:.4f}")
print(f"选择B(风险收益): 期望财富为 {expected_wealth_B} 元,期望效用为 {expected_utility_B:.4f}")
print(f"确定性等值(CE): {certainty_equivalent:.2f} 元")
print(f"\n结论:由于 CE ({certainty_equivalent:.2f}) < 期望财富 ({expected_wealth_B}),")
print(" 且 U(A) > E[U(B)],因此风险厌恶者会选择确定性的方案A。")
print(" 图形上,风险结果的连线(弦)位于效用函数曲线的下方,这是凹函数的直观特征。")
这段代码和生成的图表,生动地展示了凹函数如何刻画风险厌恶。你会发现,风险选项B的期望效用点 E[B] 位于连接两个可能结果的红色虚线上,而这条虚线(弦)完全位于蓝色的效用函数曲线之下。这正是凹函数的定义:任意两点间的线段位于函数图像下方。由此计算出的“确定性等值”小于期望财富,解释了为什么人们愿意接受比期望收益更低但确定的回报,以避免风险——这就是保险和许多稳健投资策略背后的数学原理。
5. 案例四:投资组合回报与风险分散的凹性收益
现代投资组合理论告诉我们,分散投资可以在不降低预期回报的情况下减少风险(波动性)。这种“风险降低”带来的好处,本质上也是一种凹函数关系。假设你有两种资产,预期回报率相同,但风险(标准差)不同。将资金分散投资于两者,整个组合的风险并不是两者风险的简单平均,而是低于这个平均值(假设资产不完全正相关)。组合风险关于投资权重的函数通常是凹的(在风险-回报坐标系中,有效前沿是凸的,但风险关于权重的函数是凹的)。
我们来模拟一个简化场景:资产A(高风险高波动)和资产B(低风险低波动),构建一个投资组合,并观察其风险(标准差)如何随权重变化。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# 设定两种资产的参数
# 预期年化收益率
r_A, r_B = 0.15, 0.08
# 年化波动率(标准差)
sigma_A, sigma_B = 0.25, 0.12
# 相关系数
rho = 0.3 # 假设两者正相关,但非完全相关
# 定义计算组合预期回报和风险的函数
def portfolio_performance(w_A):
"""w_A是投资于资产A的权重,则投资于B的权重为1-w_A"""
w_B = 1 - w_A
# 组合预期收益
r_p = w_A * r_A + w_B * r_B
# 组合风险(标准差)
sigma_p = np.sqrt((w_A**2)*(sigma_A**2) + (w_B**2)*(sigma_B**2) + 2*w_A*w_B*rho*sigma_A*sigma_B)
return r_p, sigma_p
# 生成从全仓A到全仓B的一系列权重
weights_A = np.linspace(0, 1, 101)
results = [portfolio_performance(w) for w in weights_A]
returns, risks = zip(*results) # 拆分成两个列表
# 找到最小方差组合(风险最小点)
min_risk_idx = np.argmin(risks)
w_A_min_risk = weights_A[min_risk_idx]
min_risk = risks[min_risk_idx]
return_at_min_risk = returns[min_risk_idx]
# 创建数据表格展示关键点
df_portfolio = pd.DataFrame({
'权重_A': weights_A,
'权重_B': 1 - weights_A,
'组合预期收益': returns,
'组合风险(标准差)': risks
})
# 绘制有效前沿和风险-权重关系图
fig, axes = plt.subplots(1, 2, figsize=(16, 6))
# 子图1:风险-收益图(有效前沿)
axes[0].plot(risks, returns, 'b-', linewidth=2.5, label='投资组合有效前沿')
axes[0].scatter([sigma_A, sigma_B], [r_A, r_B], color=['red', 'green'], s=150, zorder=5, label=['资产 A', '资产 B'])
axes[0].scatter([min_risk], [return_at_min_risk], color='purple', s=200, marker='*', zorder=5, label=f'最小风险组合 (A:{w_A_min_risk:.1%})')
axes[0].set_xlabel('组合风险 (标准差)', fontsize=12)
axes[0].set_ylabel('组合预期收益', fontsize=12)
axes[0].set_title('投资组合的有效前沿', fontsize=13, fontweight='bold')
axes[0].legend()
axes[0].grid(True, alpha=0.3)
# 子图2:组合风险 vs 资产A权重(凹函数演示)
axes[1].plot(weights_A, risks, 'darkorange', linewidth=3, label='组合风险 σ(w_A)')
axes[1].axvline(x=w_A_min_risk, color='purple', linestyle='--', alpha=0.7, label=f'最小风险点 w_A={w_A_min_risk:.1%}')
axes[1].scatter([0, 1, w_A_min_risk], [sigma_B, sigma_A, min_risk], color=['green', 'red', 'purple'], s=100, zorder=5)
axes[1].set_xlabel('投资于资产A的权重 (w_A)', fontsize=12)
axes[1].set_ylabel('组合风险 (标准差)', fontsize=12)
axes[1].set_title('组合风险是权重的凹函数', fontsize=13, fontweight='bold')
axes[1].legend()
axes[1].grid(True, alpha=0.3)
# 在风险曲线上方填充区域,突出其凹性
axes[1].fill_between(weights_A, risks, np.max(risks), alpha=0.1, color='orange')
plt.suptitle('投资组合分散化:凹函数如何降低风险', fontsize=16, fontweight='bold')
plt.tight_layout()
plt.show()
# 输出关键组合数据
print("关键投资组合配置示例:")
key_weights = [0.0, 0.3, w_A_min_risk, 0.7, 1.0]
for w in key_weights:
r, s = portfolio_performance(w)
print(f" 权重(A, B)=({w:.1%}, {1-w:.1%}) -> 预期收益={r:.2%}, 风险={s:.2%}")
print(f"\n分散化收益:全仓A的风险为{sigma_A:.2%},全仓B的风险为{sigma_B:.2%}。")
print(f"通过最优分散({w_A_min_risk:.1%} A, {1-w_A_min_risk:.1%} B),组合风险可降至{min_risk:.2%}。")
print("这证明了风险函数关于权重的凹性:加权平均风险({:.2%}) > 实际组合风险({:.2%})。".format(
w_A_min_risk*sigma_A + (1-w_A_min_risk)*sigma_B, min_risk))
右图清晰地展示了组合风险曲线是一条凹曲线。连接全仓A点和全仓B点的直线(未画出,但可以想象)会位于实际风险曲线的上方。这意味着,通过分散投资,你实际承担的风险,低于两种资产风险的加权平均值。这种“风险降低”的收益,就是凹函数带来的好处。表格数据也显示,最小风险组合的风险水平显著低于任一单一资产的风险。
6. 案例五:凹函数在优化算法中的角色与可视化
最后,我们回到“优化算法”这个热词。许多机器学习、深度学习的核心问题,就是寻找一个函数的最小值(或最大值)。如果目标函数是凹的(求最大值)或凸的(求最小值),那么优化问题会变得友好得多,因为局部最优就是全局最优。
梯度下降法是最基础的优化算法。对于凹函数最大化问题,我们可以使用梯度上升法。让我们可视化梯度上升法在寻找一个简单凹函数 f(x) = - (x-5)^2 + 10 最大值点的过程。这个函数是一个开口向下的抛物线,最大值在 x=5 处。
import numpy as np
import matplotlib.pyplot as plt
# 定义目标凹函数(我们要求其最大值)
def f(x):
return - (x - 5)**2 + 10 # 最大值10在x=5处
# 定义梯度(导数)
def grad_f(x):
return -2 * (x - 5) # f'(x) = -2(x-5)
# 梯度上升算法
def gradient_ascent(start_x, learning_rate, n_iters):
x = start_x
history = {'x': [x], 'f(x)': [f(x)]}
for i in range(n_iters):
# 梯度上升:向梯度方向移动
x = x + learning_rate * grad_f(x)
history['x'].append(x)
history['f(x)'].append(f(x))
return history
# 参数设置
start_x = 9.0 # 起始点,远离最优点
learning_rate = 0.1
n_iters = 15
# 运行梯度上升
history = gradient_ascent(start_x, learning_rate, n_iters)
# 可视化
x_vals = np.linspace(0, 10, 400)
y_vals = f(x_vals)
fig, axes = plt.subplots(1, 2, figsize=(16, 6))
# 子图1:函数曲线与优化路径
axes[0].plot(x_vals, y_vals, 'b-', linewidth=3, label='目标凹函数: $f(x) = -(x-5)^2+10$')
axes[0].scatter(history['x'], history['f(x)'], c='red', s=80, zorder=5, label='梯度上升迭代点')
axes[0].plot(history['x'], history['f(x)'], 'r--', alpha=0.7, linewidth=1.5, label='优化路径')
axes[0].axvline(x=5, color='green', linestyle=':', alpha=0.7, label='全局最大值点 x=5')
axes[0].set_xlabel('x', fontsize=12)
axes[0].set_ylabel('f(x)', fontsize=12)
axes[0].set_title('梯度上升法寻找凹函数最大值', fontsize=13, fontweight='bold')
axes[0].legend()
axes[0].grid(True, alpha=0.3)
# 为每个迭代点添加编号
for i, (x, y) in enumerate(zip(history['x'], history['f(x)'])):
axes[0].text(x, y-0.5, str(i), fontsize=9, ha='center', color='darkred')
# 子图2:迭代过程中函数值的变化
axes[1].plot(range(len(history['f(x)'])), history['f(x)'], 'o-', color='darkorange', linewidth=2.5, markersize=8)
axes[1].axhline(y=10, color='green', linestyle='--', alpha=0.7, label='全局最大值 f(x)=10')
axes[1].set_xlabel('迭代次数', fontsize=12)
axes[1].set_ylabel('函数值 f(x)', fontsize=12)
axes[1].set_title('优化过程收敛性:函数值向最大值逼近', fontsize=13, fontweight='bold')
axes[1].legend()
axes[1].grid(True, alpha=0.3)
axes[1].set_xticks(range(len(history['f(x)'])))
plt.suptitle('优化算法实战:梯度上升求解凹函数最大值', fontsize=16, fontweight='bold')
plt.tight_layout()
plt.show()
# 输出迭代过程
print("梯度上升迭代过程:")
print(f"初始点: x = {start_x}, f(x) = {f(start_x):.4f}")
for i in range(min(5, len(history['x']))): # 打印前5次迭代
print(f" 迭代 {i}: x = {history['x'][i]:.4f}, f(x) = {history['f(x)'][i]:.4f}, 梯度 = {grad_f(history['x'][i]):.4f}")
print(" ...")
print(f" 最终 (迭代 {n_iters}): x = {history['x'][-1]:.4f}, f(x) = {history['f(x)'][-1]:.4f}")
print(f"\n结论:从任意起点开始,梯度上升法都能稳定地收敛到唯一的全局最大值点x=5。")
print(" 这正是凹函数在优化中的核心优势:没有局部最优陷阱。")
左图展示了算法如何从起点x=9开始,沿着梯度方向(函数上升最快的方向)一步步“爬升”到山顶(最大值点)。右图显示了函数值随着迭代稳步增加并逼近理论最大值10。对于非凹函数,梯度上升可能会被困在局部极大值点,但对于这个凹函数,无论从哪里开始,它都能找到唯一的最优解。
为了更全面地理解优化算法,下表对比了几种常用于凹函数(或通过取负转化为凸函数)优化的算法及其特点:
| 算法名称 | 核心思想 | 优点 | 缺点/适用场景 |
|---|---|---|---|
| 梯度下降/上升法 | 沿目标函数梯度反方向/方向迭代更新参数。 | 实现简单,概念直观,适用于大规模数据(随机版本)。 | 收敛速度可能较慢,需要选择合适的学习率。 |
| 牛顿法 | 利用二阶导数(Hessian矩阵)信息,考虑曲率,实现更快的局部收敛。 | 在最优解附近收敛速度非常快(二次收敛)。 | 需要计算并存储Hessian矩阵或其逆,计算和存储成本高,可能不稳定。 |
| 拟牛顿法 (如BFGS, L-BFGS) | 通过迭代近似Hessian矩阵,避免直接计算二阶导数。 | 比梯度法快,比牛顿法计算成本低,适用于中等规模问题。 | 近似可能引入误差,对于非常高维问题,存储近似矩阵仍可能成为瓶颈。 |
| 共轭梯度法 | 在梯度方向的基础上,选择共轭方向进行搜索,加速收敛。 | 内存需求小,适用于大规模稀疏线性系统或二次函数优化。 | 对于非二次函数,效果可能下降,实现相对复杂。 |
提示:在实际的机器学习项目中,面对复杂的非凸非凹函数(如神经网络损失函数),我们仍然广泛使用基于梯度的算法(如SGD、Adam)。虽然无法保证找到全局最优,但它们在实践中往往能找到足够好的解。而对于那些能明确构建为凹函数最大化或凸函数最小化的问题(如逻辑回归、支持向量机对偶问题),上述算法的理论保证就非常有价值了。
通过这五个从微观到宏观、从理论到实操的案例,我们用Python可视化了一条条凹函数曲线,也看到了它们背后鲜活的经済学含义和工程应用。下次当你再看到一条“减速增长”的曲线时,或许就能立刻联想到边际效用递减、风险厌恶或是分散化带来的好处。这些图形不仅是数学对象,更是理解复杂世界运行规律的简洁透镜。
361



被折叠的 条评论
为什么被折叠?



