数据分析 ——— 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”即可获取代码

数据分析 ——— numpy基础（二）

猜你喜欢