numpy下 线性代数

最新推荐文章于 2023-04-27 22:04:01 发布
最新推荐文章于 2023-04-27 22:04:01 发布
阅读量361 收藏
点赞数
文章标签： numpy 线性代数 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nnxxx/article/details/110305875
版权

线性代数

矩阵和向量积

numpy.dot(a, b[, out])

计算两个矩阵乘积或两个向量内积

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

x = np.array([[1, 2, 3], [3, 4, 5], [6, 7, 8]])
y = np.array([[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]]

注：线性代数和numpy数组中维数的含义不同

线性代数numpy
n维行向量一维数组
n维列向量n×1的二维数组

矩阵特征值与特征向量

计算方阵的特征值

numpy.linalg.eigvals(a)

计算方阵的特征值和特征向量

numpy.linalg.eig(a)

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):
    # np.allclose():比较两个array是不是每一元素都相等，默认在1e-05的误差范围内
    if np.allclose(a[i] * b[:, i], np.dot(x, b[:, i])): 
        print('Right')
    else:
        print('Error')
# Right
# Right
# Right

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
if np.all(B > 0):
    print('Yes')
else:
    print('No')
# No

矩阵分解

奇异值分解

奇异值分解的相关原理：奇异值分解（SVD）及其应用
在这里插入图片描述
我们可以用最大的k个奇异值的矩阵和相乘来近似描述矩阵，从而实现了降维、减少数据存储、提升计算性能等效果。

u, s, v = numpy.linalg.svd(a, full_matrices=True, compute_uv=True, hermitian=False)

s为A的奇异值分解，只有对角线元素不为零，且按元素从小到大排序。s中有n个奇异值，一般仅保留较大的r个奇异值。

import numpy as np

# 奇异值分解 A=u*s*vh，vh为v的转置

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) # full_matrices=False:u为M×K，v为K×N，K=min(M,N)
print(u.shape) # (2, 2)
print(u)
# [[‐0.9486833 ‐0.31622777]
# [‐0.31622777 0.9486833 ]]

print(s.shape) # (2,) 一维
print(np.diag(s)) # 一维数组时，np.diag()返回一个以一维数组为对角线元素的矩阵
# [[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.]]

import numpy as np

# 奇异值分解2

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.]]

QR分解

QR（正交三角）分解法是求一般矩阵全部特征值的最有效并广泛应用的方法，一般矩阵先经过正交相似变化成为Hessenberg矩阵，然后再应用QR方法求特征值和特征向量。

A=QR
A为M×N的待分解矩阵，Q为正交矩阵，R为上三角形矩阵。

q,r = numpy.linalg.qr(a, mode=‘reduced’)

mode = reduced ：返回(M, N)的列向量两两正交的矩阵q，和(N, N)的三角阵r （Reduced QR分解）。
mode = complete ：返回(M, M)的正交矩阵q ，和(M, N)的三角阵r （Full QR分解）。

import numpy as np

# QR分解

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) # QR分解
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)) # 检验q是否为正交阵
print(a) # True

import numpy as np

# QR分解

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') # q为正交阵，Full QR分解
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

print('****************************')
qq, r = np.linalg.qr(A) # mode='reduced' qq的列向量两两正交，Reduced QR分解
print(qq.shape) # (3, 2)
print(qq)
# [[-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(qq, r))
# [[ 1. 1.]
# [ 1. ‐2.]
# [ 2. 1.]]

a = np.allclose(np.dot(qq.T,qq), np.eye(2))
print(a) # True

Cholesky分解

Cholesky 分解是把一个对称正定的矩阵表示成一个下三角矩阵L和其转置的乘积的分解。它要求矩阵的所有特征值必须大于零，故分解的下三角的对角元也是大于零的。
A=LL’

L = numpy.linalg.cholesky(a)

import numpy as np

# Cholesky分解

A = np.array([[1, 1, 1, 1],
              [1, 3, 3, 3],
              [1, 3, 5, 5],
              [1, 3, 5, 7]])
print(A)

print(np.linalg.eigvals(A)) # A的特征值
# [13.13707118 1.6199144 0.51978306 0.72323135]

L = np.linalg.cholesky(A) # Cholesky分解
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.]]

范数和其他数字

矩阵的范数

numpy.linalg.norm(x, ord=None, axis=None, keepdims=False)

计算向量和矩阵的范数（函数详情）
ord参数决定不同的范数：
在这里插入图片描述
常用ord参数及计算方法：
在这里插入图片描述

import numpy as np

# 向量的范数

x = np.array([1, 2, 3, 4])

print(np.linalg.norm(x, ord=1)) # ord=1：一范数
# 10.0
print(np.sum(np.abs(x)))
# 10

print(np.linalg.norm(x, ord=2)) # 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

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)

print(np.linalg.norm(A, ord=1)) # 30.0 1-范数：列和的最大值
print(np.max(np.sum(A, axis=0))) # 30

print(np.linalg.norm(A, ord=2)) # 2-范数：矩阵A'A的最大特征值开平方根
# 20.24345358700576
print(np.max(np.linalg.svd(A, compute_uv=False))) # compute_uv=False：只计算s，A的奇异值是A'A的特征值的平方根
# 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')) # F-范数：矩阵各元素平方和开根号
# 20.273134932713294
print(np.sqrt(np.trace(np.dot(A.T, A)))) # A'A主对角元素开根号
# 20.273134932713294

方阵的行列式

numpy.linalg.det(a)

返回方阵的行列式

import numpy as np

# 方阵的行列式

x = np.array([[1, 2], [3, 4]])
print(x)

print(np.linalg.det(x))
# ‐2.0000000000000004

矩阵的秩

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 
print(I)
# [[1. 0. 0.]
# [0. 0. 0.]
# [0. 0. 1.]]

r = np.linalg.matrix_rank(I)
print(r) # 2

方阵的迹

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)

y = np.array([[5, 4, 2], [1, 7, 9], [0, 4, 5]])
print(y)

print(np.trace(x)) # A的迹等于A.T的迹
# 13
print(np.trace(np.transpose(x)))
# 13

print(np.trace(y))

print(np.trace(x + y)) # 和的迹等于迹的和
# 30
print(np.trace(x) + np.trace(y))
# 30

解方程和逆矩阵

逆矩阵

AB=BA=E 则称B为A的逆矩阵
矩阵可逆的充要条件：det(A) != 0 ，或者A 满秩

numpy.linalg.inv(a)

返回矩阵A的逆矩阵

import numpy as np

# 计算矩阵的逆矩阵

A = np.array([[1, -2, 1], [0, 2, -1], [1, 1, -2]])
print(A)

# 求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]]

求解线性方程组

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
zzsn
关注
【机器学习必备知识】NumPy线性代数详解
风口IT猪的成长录
12-10 677
NumPy 线性代数前言numpy.dot()numpy.vdot()numpy.inner()numpy.matmulnumpy.linalg.det()numpy.linalg.solve()numpy.linalg.inv() 前言 机器学习里面用到许多线性代数的知识，因此NumPy的线性代数相关操作，你一定要懂点儿哦！ NumPy 提供了线性代数函数库 linalg，该库包含了线性代数所需的所有功能，可以看看下面的说明： 函数 描述 dot 两个数组的点积，即元素对应相乘。 vdo
Python系列--最全numpy的线性代数函数功能及用法
weixin_45665432的博客
04-24 1762
Python最全numpy的线性代数函数功能及用法Python系列numpy的线性代数函数（1）dia（2）dot（3）trace（4）det（5）eig（6）inv（7）qr（8）svd（9）solve（10）lstsq感谢浏览，别忘了点个赞鼓励一下哦(^^)~~ Python系列 作为初学者，自己整理的numpy线性代数函数用法与功能，与大家分享！有帮助到您的，希望点个赞再走呗！整理不易，一...
numpy入门4：线性代数
weixin_46462735的博客
11-29 763
文章目录矩阵和向量积矩阵乘积矩阵特征值与特征向量矩阵分解奇异值（SVD）分解QR分解Cholesky分解范数和其他数字矩阵的范数方阵的行列式矩阵的秩矩阵的迹解方程和逆矩阵逆矩阵（inverse matrix）求解线性方程组 矩阵和向量积 矩阵乘积 定义 内积 矩阵乘法相关知识 矩阵的本质就是线性方程式，两者是一一对应关系。 矩阵的最初目的，只是为线性方程组提供一个简写形式。 矩阵乘法证明 有三组未知数 x、y 和 t，其中 x 和 y 的关系如下。 有了这两组方程式，就可以求 y 和 t 的关系。从
Numpy之线性代数
陨星落云的博客
10-07 690
文章目录矩阵1. 矩阵初始化2. 矩阵元素运算3. 矩阵的乘法4. 矩阵的转置5. 矩阵对应列行的最大值，最小值，和6. 矩阵的其他操作：行列数、切片、复制、比较7. 矩阵的行列式8. 矩阵的逆和伪逆9. 矩阵的对称10. 矩阵的秩11. 可逆矩阵的求解12. 矩阵的特征值与特征向量（EVD）13. 奇异值分解（SVD） 矩阵 1. 矩阵初始化 Numpy函数库中存在两种不同的数据类型（矩阵mat...
Numpy学习——线性代数
crowgrey的博客
11-29 151
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之线性代数+练习题
qq_45396577的博客
05-07 445
线性代数 Numpy 定义了 matrix 类型，使用该 matrix 类型创建的是矩阵对象，它们的加减乘除运算缺省采用矩阵方式计算，因此用法和Matlab十分类似。但是由于 NumPy 中同时存在 ndarray 和 matrix 对象，因此用户很容易将两者弄混。这有违 Python 的“显式优于隐式”的原则，因此官方并不推荐在程序中使用 matrix。在这里，我们仍然用 ndarray 来介绍。 矩阵和向量积 矩阵的定义、矩阵的加法、矩阵的数乘、矩阵的转置与二维数组完全一致，不再进行说明，但矩阵的乘法有
NumPy学习笔记3-线性代数
u013930163的博客
07-06 1509
线性代数（如矩阵乘法、行列式等）是数学运算中的一个重要工具，在图像信号处理，音频信号处理中起到非常重要的作用。NumPy与MATLAB不同的是，通过*得到的是二维数组的元素级的积，而不是一个矩阵点积。 numpy.linalg中有一组标准的矩阵分解运算以及诸如逆和行列式之类的东西。下面以矩阵相乘和矩阵求逆作为例子a=[1,5,7,9,4,3,1,7,3] b=[4,46,456,748,54,2,
Python系列–最全numpy的线性代数函数功能及用法
12-21
在Python的科学计算领域，NumPy库扮演着至关重要的角色，尤其在处理线性代数问题时。NumPy提供了一系列的线性代数函数，使得矩阵运算和数据分析变得简单高效。以下将详细介绍这些函数的功能及用法： 1. **diag**： ...
NumPy解释线性代数
TensorFlowNews
09-27 474
作者|Soner Yıldırım 编译|VK 来源|Towards Data Science 机器学习和深度学习模型需要大量的数据。它们的性能在很大程度上取决于数据量。因此，我们倾向于收集尽可能多的数据，以建立一个稳健和准确的模型。数据以多种不同的格式收集，从数字到图像，从文本到声波。然而，我们需要将数据转换为数字以便对其进行分析和建模。 仅仅将数据转换为标量（单个数字）是不够的。随着数据量的增加，使用标量的操作开始变得低效。我们需要向量化或矩阵运算来有效地进行计算。这就是线性代数发挥作用的地方。 线性
NumPy入门之线性代数
weixin_46097969的博客
11-26 922
@[云好晕啊]学习笔记 线性代数  线性代数是数学的一个分支，它的研究对象是向量，向量空间（或称线性空间），线性变换和有限维的线性方程组。向量空间是现代数学的一个重要课题；因而，线性代数被广泛地应用于抽象代数和泛函分析中。  在NumPy中也有有关于线性代数计算的模块，也就是linalg模块，可以实现强大的线性代数计算，包括特征值、特征向量、矩阵分解等等。Numpy 定义了 matrix 类型，使用该 matrix 类型创建的是矩阵对象，它们的加减乘除运算缺省采 用矩阵方式计算，因此用法和Mat
euclidean-distance:计算两个数组之间的欧几里得距离
06-06
欧几里得距离 计算两个数组之间的。 是欧氏空间中两点之间的直线距离。 安装 $ npm install compute-euclidean-distance 要在浏览器中使用，请使用 。 用法 var euclidean = require ( 'compute-euclidean-distance' ) ; 欧几里得( x, y[, accessor] ) 计算两个数组之间的。 var x = [ 2 , 4 , 5 , 3 , 8 , 2 ] , y = [ 3 , 1 , 5 , - 3 , 7 , 2 ] ; var d = euclidean ( x , y ) ; // returns ~6.86 对于对象arrays ，提供访问numeric的访问器function 。 var x , y , d ; x = [ [ 1 , 2 ] , [ 2 ,
Python NumPy计算欧氏距离（Euclidean Distance）
热门推荐
云中寻雾的博客
02-18 7万+
欧氏距离定义： 欧氏距离（ Euclidean distance）是一个通常采用的距离定义，它是在m维空间中两个点之间的真实距离。 在二维和三维空间中的欧式距离的就是两点之间的距离，二维的公式是： begin{equation} d = sqrt{(X_1 – Y_1)^2 + (X_2 – Y_2)^2}end{equation} 三维的公式是： begin{equation} d = sq...
奇异值分解（numpy.linalg.svd二维和三维数据的压缩和还原）
yhwangk的博客
04-30 6650
奇异值分解 SVD（Singular Value Decomposition，奇异值分解） numpy.linalg模块中的svd函数可以对矩阵进行奇异值分解。 分解的目标： 是一种因子分解运算，将一个矩阵分解为3个矩阵的乘积 3个矩阵: U, Σ\SigmaΣ 和 V，其中U和V是正交矩阵，分别称为左奇异值、右奇异值，Σ\SigmaΣ为奇异值。 numpy的实现：numpy.linalg.svd(A,full_matrices=1,compute_uv=1) 参数： A是一个形如(m,n)矩阵 fu
矩阵论
金溪的博客
08-26 8837
线性空间与线性变换   1. 线性空间     1）集合与映射         a）集合：数域         b）映射：定义；变换；运算     2）线性空间及其性质         a）线性空间是某类事物从量的方面的一个抽象         b）线性空间（向量空间）定义：             定义内容；线性运算；             实线性空间、复线性空间；矩阵空间...
NumPy之矩阵、向量、线性代数等的操作
积跬步，至千里。
04-27 1545
在NumPy中，矩阵被表示为二维的ndarray对象，而向量可以用一维的ndarray对象表示。NumPy的线性代数模块提供了许多矩阵运算函数，如矩阵乘法、求逆、行列式、特征值等。
z = np.maximum(x, y)
weixin_35754676的博客
12-17 43
z = np.maximum(x, y) 表示将数组 x 和 y 中对应位置的元素作比较，取出较大的元素放到新数组 z 中，即： 如果 x[i] > y[i]，则 z[i] = x[i] 如果 x[i] ≤ y[i]，则 z[i] = y[i] 例如： x = [1, 2, 3] y = [4, 5, 6] z = np.maximum(x, y) 则 z 的值为 [4, 5, 6]。 ...
numpy中计算数组之间的欧式距离
baidu_41797613的博客
11-22 1万+
如何利用python计算两个数组之间的距离呢？ 我们可以有以下两种计算方式： 第一种方式 vec1和vec2是两个numpy向量，欧式距离计算如下： import numpy as np dist = np.sqrt(np.sum(np.square(vec1 - vec2))) 其中 np.sqrt()：计算平方根 np.square()：返回一个新数组，该数组的元素值为源数组元素的平方，源阵列保持不变。 第二种方式 dist = np.linalg.norm(vec1 - vec2) np.lin
两个数组对象使用cdist计算欧式距离
snowplum86的博客
09-19 4775
import numpy as np from scipy.spatial.distance import cdist X=np.array([[9,3,7],[5,7,9]]) #即便是X中只有一组数据跟Y的两组数据分别求欧氏距离，也需要写成二#维数组的形式，如X=np.array([[5,3,6]]) Y=np.array([[4,6,5],[4,2,3]]) a=cdist(X, Y, metric='euclidean') print(a) 结果说明： 6.164414 为[9,3,..
如何使用NumPy计算欧几里得距离？
asdfgh0077的博客
01-22 9329
我在3D中有两点： (xa, ya, za) (xb, yb, zb) 我想计算距离： dist = sqrt((xa-xb)^2 + (ya-yb)^2 + (za-zb)^2)
numpy的线性代数和随机数函数
最新发布
05-18
NumPy是一个基于Python的科学计算库，包含了大量的数学函数和工具，其中包括线性代数和随机数函数。 线性代数函数： 1. numpy.dot(a, b)：矩阵乘法。 2. numpy.linalg.det(a)：矩阵的行列式。 3. numpy.linalg.eig...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值