数据分析 ——— numpy基础（二）
接上篇文章，继续更新一些numpy下的一些常用函数的使用, 在这里多为矩阵的操作，创建矩阵，单位矩阵，求解逆矩阵等并进行one-hot编码，线性矩阵的特征向量，特征值，奇异值，行列式的计算。
1、np.eye()
np.eye(): 用于返回一个二维的对角数组,创建单位矩阵
numpy.eye(N,M=None,k=0,dtype=<class 'float'>,order='C)
- N: int型，表示的是输出的行数
- M：int型，可选项，输出的列数，如果没有就默认为N
- k：int型，可选项，对角线的下标，默认为0表示的是主对角线，负数表示的是低对角，正数表示的是高对角。
- dtype：数据的类型，可选项，返回的数据的数据类型
- order：{‘C’，‘F'}，可选项，也就是输出的数组的形式是按照C语言的行优先’C'，还是按照Fortran形式的列优先‘F'存储在内存中
普通用法：
# 创建单位矩阵
A = np.eye(2)
print("A:",A)
A1 = np.eye(3, k=1)
print("A1:",A1)
A2 = np.eye(3, k=-1)
print("A2:",A2)
A3 = np.eye(3, k=-3)
print("A3",A3)
"""
A: [[1. 0.]
[0. 1.]]
A1: [[0. 1. 0.]
[0. 0. 1.]
[0. 0. 0.]]
A2: [[0. 0. 0.]
[1. 0. 0.]
[0. 1. 0.]]
A3: [[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
"""在深度学习中的用法：
One-hot编码：
在构建分类算法的时候，标签通常都要求是one_hot编码，实际上标签可能都是整数，所以我们都需要将整数转成one_hot编码。
One-Hot编码，又称为一位有效编码，主要是采用N位状态寄存器来对N个状态进行编码，每个状态都由他独立的寄存器位，并且在任意时候只有一位有效。
One-Hot编码是分类变量作为二进制向量的表示。这首先要求将分类值映射到整数值。然后，每个整数值被表示为二进制向量，除了整数的索引之外，它都是零值，它被标记为1。
例1：
#设置类别的数量
num_classes = 10
#需要转换的整数
arr = [1,3,4,5,9]
#将整数转为一个10位的one hot编码
print(np.eye(10)[arr])
"""
运行结果：
[[0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]]
"""例2：
labels=np.array([[1],[2],[0],[1]])
print("labels的大小：",labels.shape,"\n")
#因为我们的类别是从0-2，所以这里是3个类
a=np.eye(3)[1]
print("如果对应的类别号是1，那么转成one-hot的形式",a,"\n")
a=np.eye(3)[2]
print("如果对应的类别号是2，那么转成one-hot的形式",a,"\n")
a=np.eye(3)[1,0]
print("1转成one-hot的数组的第一个数字是：",a,"\n")
#这里和上面的结果的区别，注意!!!
a=np.eye(3)[[1,2,0,1]]
print("如果对应的类别号是1,2,0,1，那么转成one-hot的形式\n",a)
res=np.eye(3)[labels.reshape(-1)]
print("labels转成one-hot形式的结果：\n",res,"\n")
print("labels转化成one-hot后的大小：",res.shape)
"""
运行结果：
labels的大小： (4, 1)
如果对应的类别号是1，那么转成one-hot的形式 [0. 1. 0.]
如果对应的类别号是2，那么转成one-hot的形式 [0. 0. 1.]
1转成one-hot的数组的第一个数字是： 0.0
如果对应的类别号是1,2,0,1，那么转成one-hot的形式
[[0. 1. 0.][0. 0. 1.][1. 0. 0.][0. 1. 0.]]
labels转成one-hot形式的结果：
[[0. 1. 0.][0. 0. 1.] [1. 0. 0.] [0. 1. 0.]]
labels转化成one-hot后的大小：(4, 3)
"""2、np.identity()
np.identity()： 用于创建n*n的方阵
np.identity(n,dtype=None)
- n: int型表示的是输出的矩阵的行数和列数都是n
- dtype: 表示的是输出的类型，默认是float
- 返回值：是n*n的主对角线为1，其余都为0的数组
该函数和np.eye()函数的区别在于，该函数只能创建方阵， 也就是N=M
a=np.identity(3)
print(a)
"""
运行结果：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
"""3、np.mat()
np.mat()： 用于创建矩阵，其必须是二维的。
np.mat(data, dtype=None)
- data: 数组
- dtype: 表示输出的类型
# 创建矩阵
A = np.mat('1 2 3; 4 5 6; 7 8 9')
B=np.mat([[1,9,7], [3,9,4]])
print('A:',A)
print('B:',B)
print('A的转置:',A.T) # 矩阵的转置
print('B逆矩阵：',B.I) # 逆矩阵
"""
运行结果：
A: [[1 2 3] [4 5 6] [7 8 9]]
B: [[1 9 7] [3 9 4]]
A的转置: [[1 4 7] [2 5 8] [3 6 9]]
B逆矩阵：[[-0.17138599 0.20938897]
[-0.04023845 0.12742176]
[ 0.21907601 -0.19374069]]
"""4. np.linalg.inv()
np.linalg.inv(): 计算逆矩阵
np.linalg.inv(A): 其中A为矩阵形式
# 创建A矩阵
A = np.mat("0 1 2; 1 0 3; 4 -3 8")
print("A:", A)
# 计算逆矩阵
inverse = np.linalg.inv(A)
print("inverse of A:", inverse)
"""
运行结果：
A: [[ 0 1 2] [ 1 0 3] [ 4 -3 8]]
inverse of A: [[-4.5 7. -1.5]
[-2. 4. -1. ] [ 1.5 -2. 0.5]]
"""5. np.linalg.solve（）
np.linalg.solve(): 求解线性矩阵方程或线性标量方程组
np.linalg.solve(a, b)
- a: 系数矩阵
- b: 纵坐标或“因变量”值
例1：求解线性方程组 3 * x0 + x1 = 9 和 x0 + 2 x1 = 8的解：
# 求解方程系统3 * x0 + x1 = 9和x0 + 2 x1 = 8
a = np.array([[3,1], [1,2]])
b = np.array([9,8])
x = np.linalg.solve(a, b)
print("solution",x)
# 使用dot函数检查是否正确
np.allclose(np.dot(a, x), b)
"""
运行结果：
solution [2. 3.]
True
"""例2：求解 x0 - 2*x1+x2=0，2*x1-8*x2=8, -4*x0+5*x1+9*x2=-9的解
# 求解线性方程组
# x0 - 2*x1+x2=0，2*x1-8*x2=8, -4*x0+5*x1+9*x2=-9
A = np.mat("1 -2 1;0 2 -8; -4 5 9")
print("A:",A)
b = np.array([0, 8, -9])
print("b:",b)
# 调用solve函数求解线性方程组
x = np.linalg.solve(A, b)
print("solution", x)
# 使用dot函数检查是否正确
print("check:", np.dot(A, x))
"""
运行结果：
A: [[ 1 -2 1] [ 0 2 -8] [-4 5 9]]
b: [ 0 8 -9]
solution [29. 16. 3.]
check: [[ 0. 8. -9.]]
"""6. np.linalg.eig()
numpy.linalg.eig(A)：计算矩阵的特征值和右特征向量， A为复数或实值矩阵
np.linalg.eigvals(A): 计算一般矩阵的特征值
# 求解特征值和特征向量
A = np.mat("3 -2;1 0")
print(A)
# 求解特征值
print("eigenvalues",np.linalg.eigvals(A))
# 求解特征向量和特征值
# eig函数返回一个元组， 按列排放着特征值和特征向量
eig_values, eig_vectors = np.linalg.eig(A)
print("eig_values:", eig_values)
print("eig_vectors:", eig_vectors)
# 使用dot函数验证是否正确计算 Ax = ax
for i in range(len(eig_values)):
print("left:", np.dot(A, eig_vectors[:,i]))
print("right:", eig_values[i] * eig_vectors[:,i])
"""
运行结果：
[[ 3 -2][ 1 0]]
eigenvalues [2. 1.]
eig_values: [2. 1.]
eig_vectors: [[0.89442719 0.70710678][0.4472136 0.70710678]]
left: [[1.78885438][0.89442719]]
right: [[1.78885438][0.89442719]]
left: [[0.70710678][0.70710678]]
right: [[0.70710678][0.70710678]]
"
7. np.linalg.svd()
np.linalg.svd(): 奇异值分解, 返回值为s, u ,v
numpy.linalg.svd(a, full_matrices=1, compute_uv=1)
- a: 是一个形如(M,N)矩阵
- full_matrices：取值是为0或者1，默认值为1，这时u的大小为(M,M)，v的大小为(N,N) 。否则u的大小为(M,K)，v的大小为(K,N) ，K=min(M,N)。
- compute_uv：取值是为0或者1，默认值为1，表示计算u,s,v。为0的时候只计算s.
# 奇异值分解
A = np.mat("4 11 14;8 7 -2")
# 使用svd函数分解矩阵
U, Sigma, V = np.linalg.svd(A, full_matrices=False)
print(U.shape, V.shape, Sigma.shape)
print("svd: ",U * np.diag(Sigma) *V)
"""
运行结果：
(2, 2) (2, 3) (2,)
svd: [[ 4. 11. 14.][ 8. 7. -2.]]
"""8. np.linalg.det()
np.linalg.det(A): 计算数组的行列式
# 计算矩阵的行列式
A = np.mat("3 4;5 6")
print("行列式：", np.linalg.det(A))
"""
运行结果：
行列式：-1.9999999999999971
"""代码获取：微信扫一扫下方二维码，后台回复“numpy”即可获取代码
win10下安装GPU版本的TensorFlow（cuda + cudnn）
本文分享自 Python爬虫scrapy 微信公众号，前往查看
如有侵权，请联系 cloudcommunity@tencent.com 删除。
本文参与 腾讯云自媒体同步曝光计划 ，欢迎热爱写作的你一起参与！
腾讯云开发者
