共轭梯度法python

共轭梯度法是一种用于解决大规模线性方程组的迭代方法。在Python中，可以使用SciPy库中的`scipy.sparse.linalg.cg`函数实现共轭梯度法。该函数接受以下参数：

- `A`：线性方程组的系数矩阵，可以使用`scipy.sparse.csr_matrix`函数创建稀疏矩阵。
- `b`：线性方程组的右侧向量。
- `x0`：迭代初值，通常为全零向量。
- `tol`：迭代终止的误差容限。
- `maxiter`：迭代的最大次数。

下面是一个示例代码：

import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.linalg import cg

# 创建系数矩阵
A = csr_matrix([[4, -1, 0, -1], [-1, 4, -1, 0], [0, -1, 4, -1], [-1, 0, -1, 4]])

# 创建右侧向量
b = np.array([0, 5, 0, 5])

# 初值为全零向量
x0 = np.zeros(4)

# 调用共轭梯度法求解
x, info = cg(A, b, x0=x0, tol=1e-6, maxiter=1000)

print("解向量：", x)

在上面的示例中，我们创建了一个4x4的系数矩阵和一个长度为4的右侧向量，并将其作为参数传递给`cg`函数。函数返回两个值：解向量和迭代信息。最终输出解向量。

相关问题

共轭梯度法python代码

以下是共轭梯度法的Python代码示例：

import numpy as np

# 构造函数 f(x) = x^2 + y^2 - 2x - 4y + 4
def f(x):
    return x[0]**2 + x[1]**2 - 2*x[0] - 4*x[1] + 4

# 梯度函数 grad_f(x) = [2x - 2, 2y - 4]
def grad_f(x):
    return np.array([2*x[0] - 2, 2*x[1] - 4])

# 共轭梯度法
def conjugate_gradient(f, grad_f, x0, max_iterations=1000, tol=1e-6):
    x = x0
    g = -grad_f(x)
    d = g
    for i in range(max_iterations):
        alpha = np.dot(g, g) / np.dot(d, np.dot(H, d))
        x = x + alpha*d
        g_new = -grad_f(x)
        beta = np.dot(g_new, g_new) / np.dot(g,g)
        d = g_new + beta*d
        g = g_new
        if np.linalg.norm(g) < tol:
            break
    return x

# 测试共轭梯度法
x0 = np.array([0, 0])
result = conjugate_gradient(f, grad_f, x0)
print(result)

这段代码是一个简单的共轭梯度法的实现，用于求解一个二次函数的最小值。如果您有其他问题或需要更多解释，请随时问我！

牛顿共轭梯度法python

牛顿共轭梯度法是一种求解无约束优化问题的方法，它结合了牛顿法和共轭梯度法的优点，可以收敛速度更快。下面给出Python实现的代码：

import numpy as np

def newton_cg(f, df, d2f, x0, max_iter=1000, tol=1e-8):
    """
    Newton-CG algorithm for unconstrained optimization.
    
    Parameters:
    f: callable, objective function.
    df: callable, gradient of the objective function.
    d2f: callable, Hessian of the objective function.
    x0: numpy.ndarray, initial point.
    max_iter: int, maximum number of iterations.
    tol: float, tolerance for stopping criterion.
    
    Returns:
    x: numpy.ndarray, the optimal point.
    """
    
    x = x0
    g = df(x)
    d = -g
    k = 0
    
    while k < max_iter and np.linalg.norm(g) > tol:
        alpha = np.dot(d, g) / np.dot(d, np.dot(d2f(x), d))
        x = x + alpha * d
        g_new = df(x)
        beta = np.dot(g_new, np.dot(d2f(x), d)) / np.dot(d, np.dot(d2f(x), d))
        d = -g_new + beta * d
        g = g_new
        k += 1
    
    return x

其中，`f`、`df`、`d2f`分别是目标函数、目标函数的梯度和目标函数的海森矩阵。`x0`是初始点，`max_iter`是最大迭代次数，`tol`是收敛精度。函数返回最优点`x`。

使用时，需要先定义目标函数、目标函数的梯度和海森矩阵，然后调用`newton_cg`函数即可。例如：

def f(x):
    return x[0]**2 + x[1]**2

def df(x):
    return np.array([2*x[0], 2*x[1]])

def d2f(x):
    return np.array([[2, 0], [0, 2]])

x0 = np.array([1, 1])

x_opt = newton_cg(f, df, d2f, x0)

print(x_opt) # 输出 [0. 0.]

以上代码演示了如何使用Newton-CG算法求解二次函数的最小值。