Scipy

本文集文档发布于灏天文库

2.3 `scipy.optimize`：优化与根查找

文档摘要

2.3 ：优化与根查找 2.3 : 优化与根查找 模块提供了多种数值优化算法，用于寻找函数的最小值或最大值，以及方程的根。它包含了无约束和约束优化、全局和局部优化、线性和非线性规划、根查找等功能，是科学计算中不可或缺的工具。 2.3.1 优化 (Optimization) 优化问题通常是指找到一个函数 的最小值或最大值，其中 是一个向量。 提供了多种算法来解决这类问题。 2.3.1.1 无约束优化 无约束优化是指在没有约束条件的情况下寻找函数的最小值或最大值。 提供了以下常用的无约束优化算法： 函数： 这是一个通用的优化函数，可以根据不同的 参数选择不同的优化算法。常用的方法包括： : Nelder-Mead单纯形算法，适用于低维度问题，不需要梯度信息。

2.3 scipy.optimize：优化与根查找

2.3 scipy.optimize: 优化与根查找

scipy.optimize 模块提供了多种数值优化算法，用于寻找函数的最小值或最大值，以及方程的根。它包含了无约束和约束优化、全局和局部优化、线性和非线性规划、根查找等功能，是科学计算中不可或缺的工具。

2.3.1 优化 (Optimization)

优化问题通常是指找到一个函数 f(x) 的最小值或最大值，其中 x 是一个向量。scipy.optimize 提供了多种算法来解决这类问题。

2.3.1.1 无约束优化

无约束优化是指在没有约束条件的情况下寻找函数的最小值或最大值。scipy.optimize 提供了以下常用的无约束优化算法：

  • minimize 函数： 这是一个通用的优化函数，可以根据不同的 method 参数选择不同的优化算法。常用的方法包括：

    • 'Nelder-Mead': Nelder-Mead单纯形算法，适用于低维度问题，不需要梯度信息。

    • 'Powell': Powell算法，不需要梯度信息。

    • 'BFGS': Broyden-Fletcher-Goldfarb-Shanno算法，一种拟牛顿法，需要梯度信息。

    • 'CG': 共轭梯度法，需要梯度信息。

    • 'Newton-CG': 牛顿共轭梯度法，需要Hessian矩阵信息。

    • 'L-BFGS-B': 限制BFGS算法，可以处理边界约束。

    • 'TNC': 截断牛顿算法，可以处理边界约束。

    • 'COBYLA': 约束优化通过线性逼近算法，可以处理非线性约束。

    • 'SLSQP': 序列最小二乘规划算法，可以处理等式和不等式约束。

  • fmin 函数： minimize 函数的早期版本，已经不推荐使用，建议使用 minimize 函数。

  • fmin_bfgs 函数： 使用BFGS算法进行优化，已经不推荐使用，建议使用 minimize 函数。

代码实践：使用 minimize 函数进行无约束优化

import numpy as np
from scipy.optimize import minimize
# 定义目标函数
def objective_function(x):
  return x[0]**2 + x[1]**2
# 定义初始猜测值
x0 = np.array([1, 1])
# 使用 BFGS 算法进行优化
result = minimize(objective_function, x0, method='BFGS')
# 打印结果
print(result)
print("Optimal solution:", result.x)
print("Optimal value:", result.fun)
​

代码解释：

  1. 定义了目标函数 objective_function(x)，这里是一个简单的二次函数。

  2. 定义了初始猜测值 x0，优化算法会从这个点开始寻找最小值。

  3. 使用 minimize 函数，指定目标函数、初始猜测值和优化算法（method='BFGS'）。

  4. result 对象包含了优化结果，包括最优解 result.x 和最优值 result.fun。

2.3.1.2 约束优化

约束优化是指在满足某些约束条件的情况下寻找函数的最小值或最大值。scipy.optimize 提供了以下常用的约束优化算法：

  • minimize 函数 (带约束): 可以使用 constraints 和 bounds 参数来定义约束条件。

    • constraints: 定义约束条件，可以是等式约束或不等式约束。

    • bounds: 定义变量的上下界。

  • linprog 函数： 线性规划，用于求解线性目标函数在满足线性等式和不等式约束下的最小值或最大值。

代码实践：使用 minimize 函数进行约束优化

import numpy as np
from scipy.optimize import minimize
# 定义目标函数
def objective_function(x):
  return x[0]**2 + x[1]**2
# 定义约束条件 (x[0] + x[1] = 1)
def constraint(x):
  return x[0] + x[1] - 1
# 定义约束字典
constraints = {'type': 'eq', 'fun': constraint}
# 定义变量的上下界
bounds = ((0, None), (0, None))  # x[0] 和 x[1] 必须大于等于 0
# 定义初始猜测值
x0 = np.array([0.5, 0.5])
# 使用 SLSQP 算法进行优化
result = minimize(objective_function, x0, method='SLSQP', constraints=constraints, bounds=bounds)
# 打印结果
print(result)
print("Optimal solution:", result.x)
print("Optimal value:", result.fun)
​

代码解释：

  1. 定义了目标函数 objective_function(x)。

  2. 定义了约束函数 constraint(x)，这里是一个等式约束 x[0] + x[1] = 1。

  3. 创建了约束字典 constraints，指定约束类型为 'eq' (等式约束) 和约束函数。

  4. 定义了变量的上下界 bounds，这里限制 x[0] 和 x[1] 都必须大于等于 0。

  5. 使用 minimize 函数，指定目标函数、初始猜测值、优化算法（method='SLSQP'）、约束条件和变量上下界。

代码实践：使用 linprog 函数进行线性规划

import numpy as np
from scipy.optimize import linprog
# 定义目标函数系数 (最小化 -c.T @ x)
c = [-1, -2]  # 最小化 -x[0] - 2x[1]
# 定义不等式约束系数 (A_ub @ x <= b_ub)
A_ub = [[2, 1], [-1, 1]]
b_ub = [20, 10]
# 定义等式约束系数 (A_eq @ x == b_eq)
A_eq = [[1, 1]]
b_eq = [12]
# 定义变量的上下界
x0_bounds = (0, None)
x1_bounds = (0, None)
# 使用 linprog 函数进行优化
result = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq,
                  bounds=[x0_bounds, x1_bounds],
                  method="highs") # 默认方法是"highs"
# 打印结果
print(result)
print("Optimal solution:", result.x)
print("Optimal value:", result.fun)
​

代码解释：

  1. 定义了目标函数系数 c，线性规划问题是最小化 -c.T @ x。

  2. 定义了不等式约束系数 A_ub 和 b_ub，表示 A_ub @ x <= b_ub。

  3. 定义了等式约束系数 A_eq 和 b_eq，表示 A_eq @ x == b_eq。

  4. 定义了变量的上下界 x0_bounds 和 x1_bounds。

  5. 使用 linprog 函数，指定目标函数系数、不等式约束、等式约束和变量上下界。

2.3.1.3 全局优化

全局优化是指寻找函数在整个定义域内的最小值或最大值，而不是仅仅找到局部最小值或最大值。scipy.optimize 提供了以下常用的全局优化算法：

  • differential_evolution 函数： 差分进化算法，一种基于种群的全局优化算法，适用于非凸函数。

  • dual_annealing 函数： 双退火算法，结合了全局搜索和局部搜索，适用于非凸函数。

  • shgo 函数： Simplicial Homology Global Optimization，基于单纯形同源的全局优化算法，适用于约束优化问题。

  • basinhopping 函数： Basinhopping算法，通过随机扰动和局部优化来寻找全局最小值。

代码实践：使用 differential_evolution 函数进行全局优化

import numpy as np
from scipy.optimize import differential_evolution
# 定义目标函数
def objective_function(x):
  return x[0]**2 + x[1]**2 - 10*np.cos(2*np.pi*x[0]) - 10*np.cos(2*np.pi*x[1]) + 20  # Rastrigin 函数
# 定义变量的上下界
bounds = [(-5, 5), (-5, 5)]
# 使用 differential_evolution 算法进行优化
result = differential_evolution(objective_function, bounds)
# 打印结果
print(result)
print("Optimal solution:", result.x)
print("Optimal value:", result.fun)
​

代码解释：

  1. 定义了目标函数 objective_function(x)，这里是一个Rastrigin函数，是一个多峰函数，具有多个局部最小值。

  2. 定义了变量的上下界 bounds。

  3. 使用 differential_evolution 函数，指定目标函数和变量上下界。

2.3.2 根查找 (Root Finding)

根查找是指找到一个方程 f(x) = 0 的解，即找到使函数值为零的 x 值。scipy.optimize 提供了多种算法来解决这类问题。

2.3.2.1 一维根查找

一维根查找是指寻找单变量函数的根。scipy.optimize 提供了以下常用的算法：

  • brentq 函数： Brent算法，结合了二分法、割线法和逆二次插值法，是一种稳健且高效的算法，需要指定根的搜索区间。

  • bisect 函数： 二分法，需要指定根的搜索区间。

  • newton 函数： 牛顿法，需要提供函数的导数。

  • fsolve 函数： root 函数的早期版本，已经不推荐使用，建议使用 root 函数。

代码实践：使用 brentq 函数进行一维根查找

import numpy as np
from scipy.optimize import brentq
# 定义目标函数
def objective_function(x):
  return x**2 - 2
# 使用 brentq 算法进行根查找
root = brentq(objective_function, 1, 2)  # 在区间 [1, 2] 之间寻找根
# 打印结果
print("Root:", root)
​

代码解释：

  1. 定义了目标函数 objective_function(x)。

  2. 使用 brentq 函数，指定目标函数和根的搜索区间 [1, 2]。

2.3.2.2 多维根查找

多维根查找是指寻找多变量方程组 f(x) = 0 的解。scipy.optimize 提供了以下常用的算法：

  • root 函数： 这是一个通用的根查找函数，可以根据不同的 method 参数选择不同的算法。常用的方法包括：

    • 'hybr': Powell's hybrid method，一种修改过的最小二乘法。

    • 'lm': Levenberg-Marquardt算法，一种最小二乘法。

    • 'broyden1': Broyden's first method，一种拟牛顿法。

    • 'broyden2': Broyden's second method，一种拟牛顿法。

    • 'anderson': Anderson加速法。

    • 'linearmixing': 线性混合法。

    • 'diagbroyden': 简化Broyden法。

    • 'excitingmixing': 激发混合法。

    • 'krylov': Krylov近似法。

  • fsolve 函数： root 函数的早期版本，已经不推荐使用，建议使用 root 函数。

代码实践：使用 root 函数进行多维根查找

import numpy as np
from scipy.optimize import root
# 定义目标函数
def objective_function(x):
  return [x[0]**2 + x[1]**2 - 2, x[0] - x[1]]
# 定义初始猜测值
x0 = np.array([1, 1])
# 使用 hybr 算法进行根查找
result = root(objective_function, x0, method='hybr')
# 打印结果
print(result)
print("Root:", result.x)
​

代码解释：

  1. 定义了目标函数 objective_function(x)，这里是一个包含两个方程的方程组。

  2. 定义了初始猜测值 x0。

  3. 使用 root 函数，指定目标函数、初始猜测值和根查找算法（method='hybr'）。

2.3.3 总结

scipy.optimize 模块提供了丰富的优化和根查找算法，可以解决各种科学计算问题。选择合适的算法取决于问题的性质，例如目标函数的凸性、是否需要约束条件、是否需要全局最优解等。理解不同算法的优缺点，并结合实际问题进行选择，是使用 scipy.optimize 模块的关键。

流程图 (使用 Mermaid):

这个流程图展示了如何根据问题类型选择合适的算法。 希望这篇文章能够帮助你更好地理解和使用 scipy.optimize 模块。

发布者: 作者: 转发
评论区 (0)
U
0/500