numpy基础用法-学习笔记-task09

最新推荐文章于 2024-07-23 14:36:35 发布
最新推荐文章于 2024-07-23 14:36:35 发布
阅读量246 收藏
点赞数
文章标签： python numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42225861/article/details/110305135
版权

线性代数

Numpy 定义了 matrix 类型，使用该 matrix 类型创建的是矩阵对象，它们的加减乘除运算缺省采用矩阵方式计算，因此用法和Matlab十分类似。但是由于 NumPy 中同时存在 ndarray 和 matrix对象，因此用户很容易将两者弄混。这有违 Python 的“显式优于隐式”的原则，因此官方并不推荐在程序中使用 matrix 。在这里，我们仍然用 ndarray 来介绍。
  1. 矩阵和向量积
    矩阵的定义、矩阵的加法、矩阵的数乘、矩阵的转置与二维数组完全一致，不再进行说明，但矩阵的乘法有不同的表示。
    numpy.dot(a, b[, out]) 计算两个矩阵的乘积，如果是一维数组则是它们的内积。

【例1】

import numpy as np
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 3, 4, 5, 6])
z = np.dot(x, y)
print(z) # 70=2+6+12+20+30
x = np.array([[1, 2, 3], [3, 4, 5], [6, 7, 8]])
print(x)
# [[1 2 3]
# [3 4 5]
# [6 7 8]]
y = np.array([[5, 4, 2], [1, 7, 9], [0, 4, 5]])
print(y)
# [[5 4 2]
# [1 7 9]
# [0 4 5]]
z = np.dot(x, y)
print(z)
# [[ 7 30 35]
# [ 19 60 67]
# [ 37 105 115]]
z = np.dot(y, x)
print(z)
# [[ 29 40 51]
# [ 76 93 110]
# [ 42 51 60]]

注意：在线性代数里面讲的维数和数组的维数不同，如线代中提到的n维行向量在 Numpy 中是一维数组，而线性代数中的n维列向量在 Numpy 中是一个shape为(n, 1)的二维数组。
  1. 矩阵特征值与特征向量
    numpy.linalg.eig(a) 计算方阵的特征值和特征向量。
    numpy.linalg.eigvals(a) 计算方阵的特征值。
    【例1】求方阵的特征值特征向量
import numpy as np
# 创建一个对角矩阵！
x = np.diag((1, 2, 3))
print(x)
# [[1 0 0]
# [0 2 0]
# [0 0 3]]
print(np.linalg.eigvals(x))
# [1. 2. 3.]
a, b = np.linalg.eig(x)
# 特征值保存在a中，特征向量保存在b中
print(a)
# [1. 2. 3.]
print(b)
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]

# 检验特征值与特征向量是否正确
for i in range(3):
    if np.allclose(a[i] * b[:, i], np.dot(x, b[:, i])):
        print('Right')
    else:
        print('Error')
# Right
# Right
# Right

【例2】判断对称阵是否为正定阵（特征值是否全部为正）。

import numpy as np
A = np.arange(16).reshape(4, 4)
print(A)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]
# [12 13 14 15]]
A = A + A.T # 将方阵转换成对称阵
print(A)
# [[ 0 5 10 15]
# [ 5 10 15 20]
# [10 15 20 25]
# [15 20 25 30]]
B = np.linalg.eigvals(A) # 求A的特征值
print(B)
# [ 6.74165739e+01 ‐7.41657387e+00 1.82694656e‐15 ‐1.72637110e‐15]
# 判断是不是所有的特征值都大于0，用到了all函数，显然对称阵A不是正定的
if np.all(B > 0):
    print('Yes')
else:
    print('No')
# No
  1. 奇异值分解
    u, s, v = numpy.linalg.svd(a, full_matrices=True, compute_uv=True, hermitian=False) 奇异值分解
    参数：
    a 是一个形如(M,N)矩阵
    full_matrices 的取值是为False或者True，默认值为True，这时 u 的大小为(M,M)， v 的大小为(N,N)。否则 u 的大小为(M,K)， v 的大小为(K,N) ，K=min(M,N)。
    compute_uv 的取值是为False或者True，默认值为True，表示计算 u,s,v 。为False的时候只计算 s 。
    总共有三个返回值 u,s,v ， u 大小为(M,M)， s 大小为(M,N)， v 大小为(N,N)， a =usv 。
    其中 s 是对矩阵 a 的奇异值分解。 s 除了对角元素不为 0 ，其他元素都为 0 ，并且对角元素从大到小排列。 s 中有 n 个奇异值，一般排在后面的比较接近0，所以仅保留比较大的 r个奇异值。
    注：Numpy中返回的 v 是通常所谓奇异值分解 a=usv’ 中 v 的转置。
    【例1】
import numpy as np
A = np.array([[4, 11, 14], [8, 7, -2]])
print(A)
# [[ 4 11 14]
# [ 8 7 ‐2]]
u, s, vh = np.linalg.svd(A, full_matrices=False)
print(u.shape) # (2, 2)
print(u)
# [[‐0.9486833 ‐0.31622777]
# [‐0.31622777 0.9486833 ]]
print(s.shape) # (2,)
print(np.diag(s))
# [[18.97366596 0. ]
# [ 0. 9.48683298]]
print(vh.shape) # (2, 3)
print(vh)
# [[‐0.33333333 ‐0.66666667 ‐0.66666667]
# [ 0.66666667 0.33333333 ‐0.66666667]]
a = np.dot(u, np.diag(s))
a = np.dot(a, vh)
print(a)
# [[ 4. 11. 14.]
# [ 8. 7. ‐2.]]

【例2】

import numpy as np
A = np.array([[1, 1], [1, -2], [2, 1]])
print(A)
# [[ 1 1]
# [ 1 ‐2]
# [ 2 1]]
u, s, vh = np.linalg.svd(A, full_matrices=False)
print(u.shape) # (3, 2)
print(u)
# [[‐5.34522484e‐01 ‐1.11022302e‐16]
# [ 2.67261242e‐01 ‐9.48683298e‐01]
# [‐8.01783726e‐01 ‐3.16227766e‐01]]
print(s.shape) # (2,)
print(np.diag(s))
# [[2.64575131 0. ]
# [0. 2.23606798]]
print(vh.shape) # (2, 2)
print(vh)
# [[‐0.70710678 ‐0.70710678]
# [‐0.70710678 0.70710678]]
a = np.dot(u, np.diag(s))
a = np.dot(a, vh)
print(a)
# [[ 1. 1.]
# [ 1. ‐2.]
# [ 2. 1.]]
  1. QR分解
    q,r = numpy.linalg.qr(a, mode=‘reduced’) 计算矩阵 a 的QR分解。
    参数：
    a 是一个(M, N)的待分解矩阵。
    mode = reduced ：返回(M, N)的列向量两两正交的矩阵 q ，和(N, N)的三角阵r （Reduced QR分解）。
    mode = complete ：返回(M, M)的正交矩阵 q ，和(M, N)的三角阵 r （Full QR分解）。
    【例1】
import numpy as np
A = np.array([[2, -2, 3], [1, 1, 1], [1, 3, -1]])
print(A)
# [[ 2 ‐2 3]
# [ 1 1 1]
# [ 1 3 ‐1]]
q, r = np.linalg.qr(A)
print(q.shape) # (3, 3)
print(q)
# [[‐0.81649658 0.53452248 0.21821789]
# [‐0.40824829 ‐0.26726124 ‐0.87287156]
# [‐0.40824829 ‐0.80178373 0.43643578]]
print(r.shape) # (3, 3)
print(r)
# [[‐2.44948974 0. ‐2.44948974]
# [ 0. ‐3.74165739 2.13808994]
# [ 0. 0. ‐0.65465367]]
print(np.dot(q, r))
# [[ 2. ‐2. 3.]
# [ 1. 1. 1.]
# [ 1. 3. ‐1.]]
a = np.allclose(np.dot(q.T, q), np.eye(3))
print(a) # True

【例2】

import numpy as np
A = np.array([[1, 1], [1, -2], [2, 1]])
print(A)
# [[ 1 1]
# [ 1 ‐2]
# [ 2 1]]
q, r = np.linalg.qr(A, mode='complete')
print(q.shape) # (3, 3)
print(q)
# [[‐0.40824829 0.34503278 ‐0.84515425]
# [‐0.40824829 ‐0.89708523 ‐0.16903085]
# [‐0.81649658 0.27602622 0.50709255]]
print(r.shape) # (3, 2)
print(r)
# [[‐2.44948974 ‐0.40824829]
# [ 0. 2.41522946]
# [ 0. 0. ]]
print(np.dot(q, r))
# [[ 1. 1.]
# [ 1. ‐2.]
# [ 2. 1.]]
a = np.allclose(np.dot(q, q.T), np.eye(3))
print(a) # True

【例3】

import numpy as np
A = np.array([[1, 1], [1, -2], [2, 1]])
print(A)
# [[ 1 1]
# [ 1 ‐2]
# [ 2 1]]
q, r = np.linalg.qr(A)
print(q.shape) # (3, 2)
print(q)
# [[‐0.40824829 0.34503278]
# [‐0.40824829 ‐0.89708523]
# [‐0.81649658 0.27602622]]
print(r.shape) # (2, 2)
print(r)
# [[‐2.44948974 ‐0.40824829]
# [ 0. 2.41522946]]
print(np.dot(q, r))
# [[ 1. 1.]
# [ 1. ‐2.]
# [ 2. 1.]]
a = np.allclose(np.dot(q.T, q), np.eye(2))
print(a) # True （说明q为正交矩阵）
  1. Cholesky分解
    L = numpy.linalg.cholesky(a) 返回正定矩阵 a 的 Cholesky 分解 a = L*L.T ，其中 L 是下三角。
    【例1】
import numpy as np
A = np.array([[1, 1, 1, 1], [1, 3, 3, 3],
[1, 3, 5, 5], [1, 3, 5, 7]])
print(A)
# [[1 1 1 1]
# [1 3 3 3]
# [1 3 5 5]
# [1 3 5 7]]
print(np.linalg.eigvals(A))
# [13.13707118 1.6199144 0.51978306 0.72323135]
L = np.linalg.cholesky(A)
print(L)
# [[1. 0. 0. 0. ]
# [1. 1.41421356 0. 0. ]
# [1. 1.41421356 1.41421356 0. ]
# [1. 1.41421356 1.41421356 1.41421356]]
print(np.dot(L, L.T))
# [[1. 1. 1. 1.]
# [1. 3. 3. 3.]
# [1. 3. 5. 5.]
# [1. 3. 5. 7.]]
  1. 矩阵的范数
    numpy.linalg.norm(x, ord=None, axis=None, keepdims=False) 计算向量或者矩阵的范数。根据 ord 参数的不同，计算不同的范数：
    范数
    【例1】求向量的范数。
import numpy as np
x = np.array([1, 2, 3, 4])
print(np.linalg.norm(x, ord=1))
# 10.0
print(np.sum(np.abs(x)))
# 10
print(np.linalg.norm(x, ord=2))
# 5.477225575051661
print(np.sum(np.abs(x) ** 2) ** 0.5)
# 5.477225575051661
print(np.linalg.norm(x, ord=-np.inf))
# 1.0
print(np.min(np.abs(x)))
# 1
print(np.linalg.norm(x, ord=np.inf))
# 4.0
print(np.max(np.abs(x)))
# 4

【例2】求矩阵的范数

import numpy as np
A = np.array([[1, 2, 3, 4], [2, 3, 5, 8],
[1, 3, 5, 7], [3, 4, 7, 11]])
print(A)
# [[ 1 2 3 4]
# [ 2 3 5 8]
# [ 1 3 5 7]
# [ 3 4 7 11]]
print(np.linalg.norm(A, ord=1)) # 30.0
print(np.max(np.sum(A, axis=0))) # 30
print(np.linalg.norm(A, ord=2))
# 20.24345358700576
print(np.max(np.linalg.svd(A, compute_uv=False)))
# 20.24345358700576
print(np.linalg.norm(A, ord=np.inf)) # 25.0
print(np.max(np.sum(A, axis=1))) # 25
print(np.linalg.norm(A, ord='fro'))
# 20.273134932713294
print(np.sqrt(np.trace(np.dot(A.T, A))))
# 20.273134932713294
  1. 方阵的行列式
    numpy.linalg.det(a) 计算行列式。
    【例】计算行列式。
import numpy as np
x = np.array([[1, 2], [3, 4]])
print(x)
# [[1 2]
# [3 4]]
print(np.linalg.det(x))
# ‐2.0000000000000004
  1. 矩阵的秩
    numpy.linalg.matrix_rank(M, tol=None, hermitian=False) 返回矩阵的秩。
    【例】计算矩阵的秩。
import numpy as np
I = np.eye(3) # 先创建一个单位阵
print(I)
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]
r = np.linalg.matrix_rank(I)
print(r) # 3
I[1, 1] = 0 # 将该元素置为0
print(I)
# [[1. 0. 0.]
# [0. 0. 0.]
# [0. 0. 1.]]
r = np.linalg.matrix_rank(I) # 此时秩变成2
print(r) # 2
  1. 矩阵的迹
    numpy.trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None) 方阵的迹就是主对角元素之和。
    【例】计算方阵的迹。
import numpy as np
x = np.array([[1, 2, 3], [3, 4, 5], [6, 7, 8]])
print(x)
# [[1 2 3]
# [3 4 5]
# [6 7 8]]
y = np.array([[5, 4, 2], [1, 7, 9], [0, 4, 5]])
print(y)
# [[5 4 2]
# [1 7 9]
# [0 4 5]]
print(sum(np.linalg.eigvals(x)))#12.99999999999999
print(sum(np.linalg.eigvals(y)))#16.999999999999996
print(np.trace(x)) # A的迹等于A.T的迹
# 13
print(np.trace(np.transpose(x)))
# 13
print(np.trace(x + y)) # 和的迹 等于 迹的和
# 30
print(np.trace(x) + np.trace(y))
# 30
  1. 逆矩阵（inverse matrix）
    设 A 是数域上的一个 n 阶矩阵，若在相同数域上存在另一个 n 阶矩阵 B，使得： AB=BA=E （E 为单位矩阵），则我们称 B 是 A 的逆矩阵，而 A 则被称为可逆矩阵。
    numpy.linalg.inv(a) 计算矩阵 a 的逆矩阵（矩阵可逆的充要条件： det(a) != 0 ，或者 a 满秩）。
    【例】计算矩阵的逆矩阵。
import numpy as np
A = np.array([[1, -2, 1], [0, 2, -1], [1, 1, -2]])
print(A)
# [[ 1 ‐2 1]
# [ 0 2 ‐1]
# [ 1 1 ‐2]]
# 求A的行列式，不为零则存在逆矩阵
A_det = np.linalg.det(A)
print(A_det)
# ‐2.9999999999999996
A_inverse = np.linalg.inv(A) # 求A的逆矩阵
print(A_inverse)
# [[ 1.00000000e+00 1.00000000e+00 ‐1.11022302e‐16]
# [ 3.33333333e‐01 1.00000000e+00 ‐3.33333333e‐01]
# [ 6.66666667e‐01 1.00000000e+00 ‐6.66666667e‐01]]
x = np.allclose(np.dot(A, A_inverse), np.eye(3))
print(x) # True
x = np.allclose(np.dot(A_inverse, A), np.eye(3))
print(x) # True
A_companion = A_inverse * A_det # 求A的伴随矩阵
print(A_companion)
# [[‐3.00000000e+00 ‐3.00000000e+00 3.33066907e‐16]
# [‐1.00000000e+00 ‐3.00000000e+00 1.00000000e+00]
# [‐2.00000000e+00 ‐3.00000000e+00 2.00000000e+00]]
  1. 求解线性方程组
    numpy.linalg.solve(a, b) 求解线性方程组或矩阵方程。
    【例】求解线性矩阵方程
# x + 2y + z = 7
# 2x ‐ y + 3z = 7
# 3x + y + 2z =18
import numpy as np
A = np.array([[1, 2, 1], [2, ‐1, 3], [3, 1, 2]])
b = np.array([7, 7, 18])
x = np.linalg.solve(A, b)
print(x) # [ 7. 1. ‐2.]
x = np.linalg.inv(A).dot(b)
print(x) # [ 7. 1. ‐2.]
y = np.allclose(np.dot(A, x), b)
print(y) # True
llittle_zhuo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python Numpy 线性代数操作总结(随时更新)
ATAIMENG的博客
11-14 1520
Python Numpy 线性代数操作总结(随时更新)本博客主要是总结一些自己在学习AI时遇到的一些问题，本着从实践出发，非教科书式的陈列，解决一些网上暂无可用的问题，也希望能和大家一同交流学习。1.矩阵的主对角线diag(v, k=0) # v为矩阵类型，k为偏移量当为二维或多维数据时，其实现等价于diagonal(a, offset=0, axis1=0, axis2=1) # a为矩阵类型，o
判断矩阵对称以及计算矩阵稀疏度
Leslie Lee's blog includes programming in math, physics, and engineering.
09-01 1824
# -*- coding: utf-8 -*- """ @time: 2021-09-01 上午 09:38 @author: leslie lee """ import numpy as np from scipy import sparse # 生成随机矩阵 A = np.random.randint(-10,10,(5,5)) # 生成对称矩阵 B = np.random.randint(-10,10,(5,5)) B_upper_tri = np.triu(B) B = B_upper_tri +
python numpy 判断对称矩阵
Planck Chang' blog
01-18 479
上来直接一点，我真的，python就是要代码简单一点。
Numpy入门教程：12. 线性代数
老马的程序人生
08-18 874
背景 什么是 NumPy 呢？ NumPy 这个词来源于两个单词 – Numerical和Python。其是一个功能强大的 Python 库，可以帮助程序员轻松地进行数值计算，通常应用于以下场景： 执行各种数学任务，如：数值积分、微分、内插、外推等。因此，当涉及到数学任务时，它形成了一种基于 Python 的 MATLAB 的快速替代。 计算机中的图像表示为多维数字数组。NumPy 提供了一些优秀的库函数来快速处理图像。例如，镜像图像、按特定角度旋转图像等。 在编写机器学习算法时，需要对矩阵进行各种数值
Python Numpy线性代数操作
weixin_34146805的博客
01-04 199
Python Numpy线性代数函数操作 1、使用dot计算矩阵乘法 import numpy as np from numpy import ones from __builtin__ import int print 'Matrix multiplication' mat23 = np.arange(1,7).reshape(2,3) mat32 = np.arange(...
Python之Numpy入门实战教程（2）：进阶篇之线性代数
10点43的博客
01-25 1109
Numpy、Pandas、Matplotlib是Python的三个重要科学计算库，今天整理了Numpy的入门实战教程。NumPy是使用Python进行科学计算的基础库。 NumPy以强大的N维数组对象为中心，它还包含有用的线性代数，傅里叶变换和随机数函数。 本文主要介绍Numpy库的重要应用：线性代数，线性代数在机器学习和深度学习中有着广泛的应用。 强烈建议大家将本文中的程序运行一遍。这样能...
NumPy线性代数
ccc369639963的博客
04-15 987
NumPy线性代数 NumPy 提供了 numpy.linalg 模块，该模块中包含了一些常用的线性代数计算方法，下面对常用函数做简单介绍： NumPy线性代数函数 函数名称 描述说明 dot 两个数组的点积。 vdot 两个向量的点积。 inner 两个数组的内积。 matmul 两个数组的矩阵积。 det 计算输入矩阵的行列式。 solve 求解线性矩阵方程。 inv 计算矩阵的逆矩阵，逆矩阵与原始矩阵相乘，会得到单位矩阵。 numpy.dot() 按照矩阵的
numpy-1.26.1-cp312-cp312-win-amd64.whl
10-30
该资源为numpy-1.26.1-cp312-cp312-win_amd64.whl，欢迎下载使用哦！
numpy-1.26.1-cp310-cp310-win-amd64.whl
10-30
该资源为numpy-1.26.1-cp310-cp310-win_amd64.whl，欢迎下载使用哦！
numpy-1.26.1-cp311-cp311-win-amd64.whl
10-30
该资源为numpy-1.26.1-cp311-cp311-win_amd64.whl，欢迎下载使用哦！
numpy-1.26.1-cp39-cp39-win-amd64.whl
10-29
该资源为numpy-1.26.1-cp39-cp39-win_amd64.whl，欢迎下载使用哦！
numpy-2.0.0-cp39-cp39-win_amd64.whl
06-29
该资源为numpy-2.0.0-cp39-cp39-win_amd64.whl，欢迎下载使用哦！
Numpy的矩阵、线性代数运算
m0_68492606的博客
07-12 1052
Numpy的矩阵和线性代数基础运算。
线性代数的相关计算(numpy)
深度学习领域优质创作者，CSDN博客专家
04-15 1767
np.linalg等线性代数的一些用法，求逆矩阵、特征值，特征向量、线性方程等
Numpy学习——线性代数
crowgrey的博客
11-29 138
1. 计算欧式距离 import numpy as np a = np.array([1, 2, 3, 4, 5]) b = np.array([4, 5, 6, 7, 8]) dist_ab = np.sqrt(sum((b-a)**2)) print(dist_ab) 6.708203932499369 2. 计算行列式的值和矩阵的逆 A = np.diag([5, 5, 5, 5, 5]) np.linalg.det(A) 3124.999999999999 浮点运算会损失精度，可用以下两
Numpy入门（3）—线性代数
文盲青年的博客
08-21 816
线性代数（如矩阵乘法、矩阵分解、行列式以及其他方阵数学等）是任何数组库的重要组成部分，NumPy中实现了线性代数中常用的各种操作，并形成了numpy.linalg线性代数相关的模块。diagdottracedeteiginv矩阵：有多行多列元素组成的一个集合，一个m*n的矩阵，有m行n列个元素向量：如果一个矩阵只有一列，那么就是一个列向量；
Numpy之线性代数
陨星落云的博客
10-07 682
文章目录矩阵1. 矩阵初始化2. 矩阵元素运算3. 矩阵的乘法4. 矩阵的转置5. 矩阵对应列行的最大值，最小值，和6. 矩阵的其他操作：行列数、切片、复制、比较7. 矩阵的行列式8. 矩阵的逆和伪逆9. 矩阵的对称10. 矩阵的秩11. 可逆矩阵的求解12. 矩阵的特征值与特征向量（EVD）13. 奇异值分解（SVD） 矩阵 1. 矩阵初始化 Numpy函数库中存在两种不同的数据类型（矩阵mat...
NumPy实现线性代数常见操作
小白学视觉
05-20 489
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达机器学习和深度学习模型需要大量的数据。它们的性能在很大程度上取决于数据量。因此，我们倾向于收集尽可能多的数据，以建立一个稳健和准确的模型。数据以多种不同的格式收集，从数字到图像，从文本到声波。然而，我们需要将数据转换为数字以便对其进行分析和建模。仅仅将数据转换为标量（单个数字）是不够的。随着数据量的增加...
随机数种子的作用
最新发布
帆的博客
07-23 1074
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
torch.tensor和numpy
08-17
- *2* *3* [【深度学习笔记】彻底理解torch中的tensor与numpy中array区别及用法](https://blog.csdn.net/DeepLearning_/article/details/127677006)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值