Python SciPy linalg.eigh用法及代码示例

本文简要介绍 python 语言中 scipy.linalg.eigh 的用法。

用法:

scipy.linalg.eigh(a, b=None, *, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=<object object>, eigvals=<object object>, type=1, check_finite=True, subset_by_index=None, subset_by_value=None, driver=None)#

求解复 Hermitian 或实对称矩阵的标准或广义特征值问题。

查找特征值数组 w 和可选的特征向量数组 v 的数组 a ，其中 b 是正定的，使得对于每个特征值 λ (w 的i-th 条目)及其特征向量 vi (i-th v 的列)满足：

a @ vi = λ * b @ vi
vi.conj().T @ a @ vi = λ
vi.conj().T @ b @ vi = 1

在标准问题中，b 被假定为单位矩阵。

参数 ：：

a： (M, M) 数组

将计算其特征值和特征向量的复 Hermitian 或实对称矩阵。

b： (M, M) 数组，可选

中的复数 Hermitian 或实对称定正矩阵。如果省略，则假定为单位矩阵。

lower： 布尔型，可选

相关数组数据是否取自 a 的下三角形或上三角形，以及 b(如果适用)。 (默认值：较低)

eigvals_only： 布尔型，可选

是否只计算特征值而不计算特征向量。 (默认：两者都计算)

subset_by_index： 可迭代的，可选的

如果提供，此二元素迭代定义所需特征值的开始和结束索引(升序和 0 索引)。要仅返回第二小到第五小的特征值，请使用[1, 4]。 [n-3, n-1] 返回最大的三个。仅适用于 “evr”, “evx” 和 “gvx” 驱动程序。这些条目通过 int() 直接转换为整数。

subset_by_value： 可迭代的，可选的

如果提供，此二元素迭代定义半开区间 (a, b]，如果有的话，仅返回这些值之间的特征值。仅适用于 “evr”, “evx” 和 “gvx” 驱动程序。对于不受约束的末端使用np.inf。

driver： str，可选

定义应该使用哪个 LAPACK 驱动程序。标准问题的有效选项是 “ev”, “evd”, “evr”, “evx”，广义(其中 b 不是无)问题的有效选项是 “gv”, “gvd”, “gvx”。请参阅注释部分。标准问题的默认值为“evr”。对于广义问题，“gvd” 用于完整集，“gvx” 用于子集请求案例。

type： 整数，可选

对于广义问题，此关键字指定w和v要解决的问题类型(仅将1、2、3作为可能的输入)：

1 =>     a @ v = w @ b @ v
2 => a @ b @ v = w @ v
3 => b @ a @ v = w @ v

对于标准问题，此关键字将被忽略。

overwrite_a： 布尔型，可选

是否覆盖a中的数据(可能会提高性能)。默认为假。

overwrite_b： 布尔型，可选

是否覆盖b中的数据(可能会提高性能)。默认为假。

check_finite： 布尔型，可选

是否检查输入矩阵是否仅包含有限数。禁用可能会提高性能，但如果输入确实包含无穷大或 NaN，则可能会导致问题(崩溃、非终止)。

turbo： 布尔值，可选，已弃用

eigvals： 元组 (lo, hi)，可选，已弃用

返回 ：：

w： (N,) 数组

N (N<=M) 个选定的特征值按升序排列，每个特征值根据其重数重复。

v： (M, N) ndarray

与特征值w[i]对应的归一化特征向量是列v[:,i]。仅在 eigvals_only=False 时返回。

抛出 ：：

LinAlgError

如果特征值计算不收敛，则发生错误，或者 b 矩阵不是确定的正数。请注意，如果输入矩阵不是对称的或 Hermitian 矩阵，则不会报告错误但结果会错误。

注意：

此函数不检查输入数组是否为 Hermitian/对称，以便允许仅使用其上/下三角形部分来表示数组。另外请注意，即使没有考虑在内，有限性检查也适用于整个数组并且不受“lower” 关键字的影响。

此函数使用 LAPACK 驱动程序在所有可能的关键字组合中进行计算，如果数组是实数，则以 sy 为前缀，如果是复数，则以 he 为前缀，例如，带有 “evr” 驱动程序的浮点数组通过 “syevr” 求解，复数数组带有 “gvx”驱动问题通过“hegvx”等解决。

作为一个简短的总结，最慢和最强大的驱动程序是使用对称 QR 的经典 <sy/he>ev。 <sy/he>evr 被视为最一般情况下的最佳选择。但是，在某些情况下，<sy/he>evd 计算速度更快，但会消耗更多内存。 <sy/he>evx 虽然仍然比 <sy/he>ev 快，但性能通常比其他的差，除非大型数组需要很少的特征值，但仍然没有性能保证。

对于广义问题，关于给定类型参数的规范化：

type 1 and 3 :      v.conj().T @ a @ v = w
type 2       : inv(v).conj().T @ a @ inv(v) = w

type 1 or 2  :      v.conj().T @ b @ v  = I
type 3       : v.conj().T @ inv(b) @ v  = I

例子：

>>> import numpy as np
>>> from scipy.linalg import eigh
>>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
>>> w, v = eigh(A)
>>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
True

仅请求特征值

>>> w = eigh(A, eigvals_only=True)

请求小于 10 的特征值。

>>> A = np.array([[34, -4, -10, -7, 2],
...               [-4, 7, 2, 12, 0],
...               [-10, 2, 44, 2, -19],
...               [-7, 12, 2, 79, -34],
...               [2, 0, -19, -34, 29]])
>>> eigh(A, eigvals_only=True, subset_by_value=[-np.inf, 10])
array([6.69199443e-07, 9.11938152e+00])

求第二小的特征值及其特征向量

>>> w, v = eigh(A, subset_by_index=[1, 1])
>>> w
array([9.11938152])
>>> v.shape  # only a single column is returned
(5, 1)