线性代数

线性代数（如矩阵乘法、矩阵分解、行列式以及其他方阵数学等）是任何数组库的重要组成部分，Numpy中实现了线性代数中常用的各种操作，并形成了numpy.linalg线性代数相关的模块。本节主要介绍如下函数：

  • diag：以一维数组的形式返回方阵的对角线（或非对角线）元素，或将一维数组转换为方阵（非对角线元素为0）。
  • dot：矩阵乘法。
  • trace：计算对角线元素的和。
  • det：计算矩阵行列式。
  • eig：计算方阵的特征值和特征向量。
  • inv：计算方阵的逆。 
  1. # 矩阵相乘
  2. a = np.arange(12)
  3. b = a.reshape([3, 4])
  4. c = a.reshape([4, 3])
  5. # 矩阵b的第二维大小，必须等于矩阵c的第一维大小
  6. d = b.dot(c) # 等价于 np.dot(b, c)
  7. print('a: \n{}'.format(a))
  8. print('b: \n{}'.format(b))
  9. print('c: \n{}'.format(c))
  10. print('d: \n{}'.format(d))
  1. a: 
  2. [ 0  1  2  3  4  5  6  7  8  9 10 11]
  3. b: 
  4. [[ 0  1  2  3]
  5.  [ 4  5  6  7]
  6.  [ 8  9 10 11]]
  7. c: 
  8. [[ 0  1  2]
  9.  [ 3  4  5]
  10.  [ 6  7  8]
  11.  [ 9 10 11]]
  12. d: 
  13. [[ 42  48  54]
  14.  [114 136 158]
  15.  [186 224 262]]
  1. # numpy.linalg  中有一组标准的矩阵分解运算以及诸如求逆和行列式之类的东西
  2. # np.linalg.diag 以一维数组的形式返回方阵的对角线（或非对角线）元素，
  3. # 或将一维数组转换为方阵（非对角线元素为0）
  4. e = np.diag(d)
  5. f = np.diag(e)
  6. print('d: \n{}'.format(d))
  7. print('e: \n{}'.format(e))
  8. print('f: \n{}'.format(f))
  1. d: 
  2. [[ 42  48  54]
  3.  [114 136 158]
  4.  [186 224 262]]
  5. e: 
  6. [ 42 136 262]
  7. f: 
  8. [[ 42   0   0]
  9.  [  0 136   0]
  10.  [  0   0 262]]
  1. # trace, 计算对角线元素的和
  2. g = np.trace(d)
  3. g
  1. 440
  1. # det，计算行列式
  2. h = np.linalg.det(d)
  3. h
  1. 1.3642420526593978e-11
  1. # eig，计算特征值和特征向量
  2. i = np.linalg.eig(d)
  3. i
  1. (array([4.36702561e+02, 3.29743887e+00, 3.13152204e-14]),
  2.  array([[ 0.17716392,  0.77712552,  0.40824829],
  3.         [ 0.5095763 ,  0.07620532, -0.81649658],
  4.         [ 0.84198868, -0.62471488,  0.40824829]]))
  1. # inv，计算方阵的逆
  2. tmp = np.random.rand(3, 3)
  3. j = np.linalg.inv(tmp)
  4. j
  1. array([[-0.59449952,  1.39735912, -0.06654123],
  2.        [ 1.56034184, -0.40734618, -0.48055062],
  3.        [ 0.10659811, -0.62164179,  1.30437759]])