NumPy - 线性代数

---

---

NumPy 中的线性代数

线性代数是数学的一个分支，它处理向量、矩阵和线性变换。

NumPy 包含 **numpy.linalg** 模块，该模块提供了线性代数所需的所有功能。下表描述了此模块中的一些重要函数。

创建矩阵

在 NumPy 中，我们可以使用数组创建矩阵。矩阵只是二维数组，可以使用 np.array() 函数创建。您可以将矩阵的元素指定为嵌套列表。

示例

以下是一个基本示例，其中我们创建了一个包含两行三列的矩阵：

import numpy as np

# Creating a 2x3 matrix
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print("Matrix:\n", matrix)

获得以下输出：

Matrix:
[[1 2 3]
 [4 5 6]]

矩阵运算

矩阵运算在线性代数中是基础，涉及对矩阵执行算术运算。在 NumPy 中，您可以轻松地执行矩阵的加法、减法、乘法和转置。

矩阵加法和减法

矩阵加法和减法是逐元素执行的。这意味着每个矩阵中对应的元素相加或相减。这两种运算都需要矩阵具有相同的形状。

示例

在下面的示例中，我们使用两个 2x2 NumPy 数组 **A** 和 **B** 执行逐元素矩阵加法和减法：

import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# Matrix Addition
C = A + B
print("Matrix Addition:\n", C)

# Matrix Subtraction
D = A - B
print("Matrix Subtraction:\n", D)

这将产生以下结果：

Matrix Addition:
[[ 6  8]
 [10 12]]
Matrix Subtraction:
[[-4 -4]
 [-4 -4]]

矩阵乘法

矩阵乘法可以使用 **@** 运算符或 **np.dot()** 函数完成。与逐元素乘法不同，矩阵乘法涉及对行和列的乘积求和。

示例

这里，我们使用 **@** 运算符和 **np.dot()** 函数对两个 2x2 NumPy 数组 **A** 和 **B** 执行矩阵乘法：

import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# Matrix Multiplication
C = A @ B
print("Matrix Multiplication with @:\n", C)

D = np.dot(A, B)
print("Matrix Multiplication with np.dot():\n", D)

以下为上述代码的输出：

Matrix Multiplication with @:
[[19 22]
 [43 50]]
Matrix Multiplication with np.dot():
[[19 22]
 [43 50]]

矩阵转置

矩阵的转置是通过沿其对角线翻转获得的，有效地将行与列交换。这可以使用 **.T** 属性实现。

示例

在这里，我们转置一个 2x2 NumPy 数组 **A** 以获得其转置 A_T：

import numpy as np
A = np.array([[1, 2], [3, 4]])

# Transposing the matrix
A_T = A.T
print("Transpose of A:\n", A_T)

获得的输出如下所示：

Transpose of A:
[[1 3]
 [2 4]]

行列式和逆矩阵

行列式指示矩阵是否可逆（非奇异）。如果矩阵的行列式非零，则该矩阵可逆。相反，如果行列式为零，则该矩阵是奇异的，不可逆。它还用于：

• 求解线性方程组。
• 更改积分中的变量。
• 计算面积和体积。
• 定义方阵的特征多项式。

矩阵的 **逆矩阵** 是一个矩阵，当它与原始矩阵相乘时，会得到单位矩阵。

A X A-1 = A-1 = I

NumPy 提供了各种函数来计算矩阵的行列式和逆矩阵。

计算行列式

我们可以使用 **linalg.det()** 函数计算矩阵的行列式。它在内部使用 LAPACK 例程来计算行列式（通过 LU 分解）。

示例

在下面的示例中，我们使用 np.linalg.det() 函数计算 2x2 NumPy 数组 **A** 的行列式：

import numpy as np
A = np.array([[1, 2], [3, 4]])

# Determinant of the matrix
det = np.linalg.det(A)
print("Determinant of A:", det)

执行上述代码后，我们得到以下输出：

Determinant of A: -2.0000000000000004

计算逆矩阵

我们可以使用 **linalg.inv()** 函数计算矩阵的逆矩阵。

示例

这里，我们使用 np.linalg.inv() 函数计算 2x2 NumPy 数组 **A** 的逆矩阵：

import numpy as np
A = np.array([[1, 2], [3, 4]])

# Inverse of the matrix
A_inv = np.linalg.inv(A)
print("Inverse of A:\n", A_inv)

产生的结果如下：

Inverse of A:
 [[-2.   1. ]
 [ 1.5 -0.5]]

特征值和特征向量

特征值和特征向量对于理解线性变换至关重要。可以使用 **np.linalg.eig()** 函数计算它们。

特征值表示变换的大小，而特征向量表示方向。

示例

在下面所示的示例中，我们使用 np.linalg.eig() 函数计算 2x2 NumPy 数组 **A** 的特征值和特征向量：

import numpy as np
A = np.array([[1, 2], [3, 4]])

# Computing eigenvalues and eigenvectors
eigenvalues, eigenvectors = np.linalg.eig(A)
print("Eigenvalues:", eigenvalues)
print("Eigenvectors:\n", eigenvectors)

我们得到如下所示的输出：

Eigenvalues: [-0.37228132  5.37228132]
Eigenvectors:
[[-0.82456484 -0.41597356]
 [ 0.56576746 -0.90937671]]

求解线性系统

在 Numpy 中，可以使用 **np.linalg.solve()** 函数求解线性方程组。此函数查找满足矩阵方程表示的线性方程的变量值：

Ax = b

其中，**A** 表示矩阵，**b** 是一个向量。

示例

在这个示例中，我们正在求解由矩阵方程 **Ax=b** 表示的线性方程组，其中 **A** 是一个 2x2 矩阵，**b** 是一个向量。我们使用 np.linalg.solve() 函数计算满足该方程的 **x** 的值：

import numpy as np
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])

# Solving the linear system Ax = b
x = np.linalg.solve(A, b)
print("Solution of the linear system:", x)

获得以下输出：

Solution of the linear system: [2. 3.]

奇异值分解 (SVD)

SVD 是将矩阵分解为三个矩阵：**U**（左奇异向量）、**S**（奇异值）和 **V**（右奇异向量）。它在各种应用中都很有用，包括信号处理和统计学。

您可以使用 NumPy 中的 **np.linalg.svd()** 函数执行 SVD。

示例

在下面的示例中，我们对 2x2 矩阵 **A** 执行奇异值分解 (SVD)，它将其分解为三个分量：U、S 和 V：

import numpy as np
A = np.array([[1, 2], [3, 4]])

# Performing SVD
U, S, V = np.linalg.svd(A)
print("U matrix:\n", U)
print("Sigma values:", S)
print("V matrix:\n", V)

这将产生以下结果：

U matrix:
[[-0.40455358 -0.9145143 ]
 [-0.9145143   0.40455358]]
Sigma values: [5.4649857  0.36596619]
V matrix:
[[-0.57604844 -0.81741556]
 [ 0.81741556 -0.57604844]]

范数和条件数

**范数** 测量向量和矩阵的大小或长度，有助于量化其大小。**条件数** 指示矩阵的解对其输入变化的敏感程度，表明它在数值上可以解决的程度。

计算范数

范数测量向量和矩阵的大小或长度。我们可以使用 NumPy **linalg.norm()** 函数计算不同类型的范数，例如 Frobenius 范数和欧几里得范数。

示例

在下面的示例中，我们正在计算 2x2 矩阵 **A** 的 Frobenius 范数，它提供了其整体大小的度量，类似于向量的欧几里得范数。

我们还计算了 3D 向量的 L2 范数（欧几里得范数），它量化了其在空间中的长度：

import numpy as np
A = np.array([[1, 2], [3, 4]])

# Frobenius norm
norm = np.linalg.norm(A, 'fro')
print("Frobenius norm of A:", norm)

# L2 norm (Euclidean norm)
vector = np.array([1, 2, 3])
l2_norm = np.linalg.norm(vector)
print("L2 norm of vector:", l2_norm)

以下为上述代码的输出：

Frobenius norm of A: 5.477225575051661
L2 norm of vector: 3.7416573867739413

计算条件数

矩阵的条件数衡量线性系统的解对数据中误差的敏感程度。

它可以使用 NumPy **linalg.cond()** 函数计算。较高的条件数表示矩阵接近奇异，这使得准确求解线性方程组更具挑战性。

示例

这里，我们正在计算 2x2 矩阵 **A** 的条件数：

import numpy as np
A = np.array([[1, 2], [3, 4]])

# Condition number
cond = np.linalg.cond(A)
print("Condition number of A:", cond)

获得的输出如下所示：

Condition number of A: 14.933034373659268