随笔 - 70 文章 - 0 评论 - 0 阅读 - 1944

深度学习与图像识别（numpy2）

获取numpy属性

首先，我们通过Numpy中的一个方法 arange(n)，生成0到n-1的数组。

np.arange(15)
返回的结果是array([ 0， 1， 2，3，4，5， 6，7， 8，9，10，11，12，13，14)

然后，再通过Numpy 中的reshape(row,column)方法，自动构架一个多行多列的array对象。

a = np.arange(15) .reshape(3,5) #代表3行5列 
 array([[ 0, I, 2, 3, 41，
 [ 5， 6， 7， 8， 91，
[10， 11，12，13，1411)

通过Numpy提供的shape属性获取Numpy数组的行数与列数

print(a.shape)

可以看到返回的结果是一个元组(tuple)，第一个3代表的是3行，第二个5代表的是5列:(3,5)

我们可以通过.ndim来获取Numpy数组的维度

 import numpy as np
 x= np.arange(15)
 print(x.ndim)*输出x向量的维度，这时能看到的维度是1维
 x=x.reshape(3,5) #将x向量转为三行五列的二维矩阵
 Print(X.ndim) #输出x矩阵的维度，这时能看到的维度是2维

reshape 方法的特别用法
如果只关心需要多少行或者多少列，其他由计算机自己来算，那么这个时候我们可以使用如下方法:

x.reshape(15,-1)#我关心的是我只要15行，列由计算机自己来算 
x.reshape(-1,15)#我关心的是我只要15列，行由计算机自己来算

2.3.4 Numpy 数组索引
Numpy 支持类似 list的定位操作，

import numpy as np
matrix = np.array([1,2,3],[20,30,4011)
print(matrix[0,11)
得到的结果是 2。

上述代码中的 matrix[0,1],0代表的是行，在Numpy中,0代表起始的第一个，所以取的是第1行，之后的1代表的是列，所以取的是第2列。那么，最后的输出结果是取第一行第二列，也就是2。
2.3.5 切片
Numpy 支持类似 list的切片操作，示例代码如下:

import numpy as np
 matrix = np.array([15，10，151，
                            [20，25，30]，
                            [35，40，45])
print(matrix[:,1]) 
print(matrix[:,0:2])
 print(matrix[1:3,:])
 print(matrix[1:3,0:2])
print(matrix[:,1])语法代表选择所有的行，而且列的索引是1的数据，因此返的结果是 10，25，40。
print(matrix[:,0:2]) 代表的是选取所有的行，而且列的索引是0和1的数据。

print(matrix[1:3,:]) 代表的是选取所有的列，而且行的索引值是1和2的数据。 
print(matrix[1:3,0:2])代表的是选取行的索引是1和2，而且列的索引是0和1的所有数据

Numpy 中的矩阵运算
矩阵运算(加、减、乘、除)即两个的基本运算必须具有相同的行数与列数。

import numpy as np 
myones = np.ones([3,3])  
myeye =np.eye(3)           #生成一个对角线的值为1,其余值都为0的三行三列矩阵
print(myeye) print (myones-myeye)

[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
[[0. 1. 1.]
[1. 0. 1.]
[1. 1. 0.]]

numpy.eye(N,M=None,k=0,dtype=<type ‘ float’>)中第一个参数输出矩阵(行数=列数)，第三个参数默认情况下输出的是对角线的值全为1，其余值全为0。

矩阵函数说明
np.sin(a) 对矩阵a中的每个元素取正弦，sin(x)
np.cos(a) 对矩阵a中的每个元素取余弦，cos(x)
np.tan(a) 对矩阵=中的每个元素取正切，tan(x)
np.sqrt(a) 对矩阵a中的每个元素开根号√x
np.abs(a) 对矩阵a中的每个元素取绝对值
(1)矩阵之间的点乘
矩阵真正的乘法必须满足第一个矩阵的列数等于第二个矩阵的行数，矩阵乘法的函数为 dot。示例代码如下:

import numpy as np
mymatrix = np.array([1,2,3],[4,5,6]])
a=np.array([1,2],[3,4],[5,6]])
print (mymatrix.shape[1]== a.shapet[0])
print (mymatrix.dot(a))


[[22 28]
 [49 64]]

将mymatrix的第一行[1,2,3]与n矩阵的第一列(1,3,5)相乘然后相加，接着将mymatrix 的第一行[1,2,3]与a矩阵的第二列(2,4,6)相乘然后相加，以此类推。

(2)矩阵的转置
矩阵的转置是指将原来矩阵中的行变为列

import numpy as np
a=np.array([[1,2,3],[4,5.6]])
print(a.T)
输出结果如下:
[[1 4]
[2 5]
[3 6]]

(3)矩阵的逆

import numpy as np
import numpy.linalg as lg
A = np.array([[0,1]，[2,3]])
invA = lg.inv(A) print(invA)
print(A.dot(invA))
输出结果如下:
[[-1.5 0.5]
 [ 1.  0.0]] 逆矩阵就是，原矩阵A.dot(invA)以及逆矩阵invA.dot(A)的结果都为单位矩阵。并不是所有的矩阵都有逆矩阵。

数据类型转换
Numpy ndarray数据类型可以通过参数 dtype进行设定，而且还可以使用参数astype来转换类型。astype调用会返回一个新的数组，也就是原始数据的备份。

比如，将String(String代表字符串) 转换成 float。

vector=numpy.arrary(["1","2","3"])
vector=vector.astype(float)

Numpy的统计计算方法
NumPy内置了很多计算方法，其中最重要的统计方法大概有
sum():计算矩阵元素的和:矩阵的计算结果为一个一维数组，需要指定行或者列,
mean():计算矩阵元素的平均值;矩阵的计算结果为一个一维数组，需要指定行或者列
max():计算矩阵元素的最大值;矩阵的计算结果为一个一维数组，需要指定行或者列
median():计算矩阵元素的中位数。
需要注意的是，用于这些统计方法的数值类型必须是int或者 float。

vector = numpy.array([5，10，15，20])
vector.sum()
50

矩阵示例代码如下:

matrix=
array([[ 5， 10，15]，
          [20，10，30]，
          [35，40，45]])
matrix.sum(axia=1)
array(l[30, 60， 120])
matrix.sum(axis=0) 
array([60，60，90])

axis=1计算的是行的和，结果以列的形式展示。axis =0计算的是列的和，结果以行的形式展示。
官方推荐教程(https://docs.scipy.org/doc/numpy-dev/user/quickstart.html)

Numpy 中的 arg 运算
argmax函数就是用来求一个array中最大值的下标。简单来说,就是最大的数所对应的索引(位置)是多少。

index2 = np.argmax([1,2,6,3,2])      
返回的是2

argmin函数可用于求一个array中最小值的下标，用法与argmax类似。

index = np.argmin([1.2,6,3,2])
返回的是0

Numpy矩阵的排序和如何使用索引

import numpy as np 
x = np,arange(15)
print(x)   #" array([0，1, 2，3，4，5，6，7，8，9........14])
np.random.shuffle(x) #随机打乱
print(x)   #array(l 8. 13，12, 3， 9，2，10，0，11.........])
sx = np.argsort(x) #从小到大排序，返回索引值
print(sx)   #[7.12. 5. 3. 13. 9 .14. 11 .0 .4. 6 .8. 2. 1. 10]

Fancylndexing
要索引向量中的一个值是比较容易的，比如通过x[0]来取值。但是，如果想要更复杂地取数，比如，需要返回第3个、第5个以及第8个元素时，应该怎么办?

import numpy as np
x = np.arange(15) 
ind = [3,5,8]
print(x[ind])

我们也可以从一维向量中构成新的二维矩阵

import numpy as np 
x =np.arange(15)
np.random.shuffle(X)
ind = np.array([[0,2],[1,3]])# 第一行需要取x向量中索引为0的元素，以及索引为2的元素，第二行需要取x向量中索引为1的元素以及索引为3的元素 
print (x)
print(x[ind])

[3 2 7 12 9 13 11 14 10 5 4 1 6 8 0]
[[3  7]
[2 12]]

对于二维矩阵的fancyindexing

import numpy as np
x=mp.arange(16)
x=x.reshape(4,-1)
row = np.array([0,1.2]) 
col=np,array([1,2,3])
print(x[row,col)) #相当于取三个点，分别是(0,1),(1,2),(2,3)
print(x[1:3,co1])#相当于取第2、3行，以及需要的列

Numpy数组比较(数据比较之后会产生boolean值 )

import numpy as np
matrix = np.array([
                  [5, 10，15]，
                  [20, 25, 30],
                  [35，40，45]
])
                          
m= (matrix ==25) 
print (m) 
[False False Falsel[False True Falsel[False False False]

import numpy as np 
matrix = np.array([[15，10，15]，
[20，25，30]，
[35，40，45]
])

second_column_25 =(matrix[:,1]== 25)
print (second_column_25)matrix[:,1]   #代表的是所有的行，以及索引为1的列，即[10,25,40]
print(matrix[second_column_25,:])#代表的是返回true值的那一行数据

matrix[second_column_25,:]


[False,True False]
 [20,25,30]。

拼接多个条件，“&”代表的是“且”，“|”代表的是“或”。

vector=np.array([5,10,11,12]),

equal_to_five_and_ten = (vector = =5) & (vector ==10)返回的都是false，

equal_ to_five_or_ten = (vector ==5) | (vector==10)，则返回的是[True,True,False,False]。
通过np.count_nonzero(x<=3)来计算小于等于3的元素个数，1代表 True,0代表 False。

import numpy as np  
  
# 创建一个一维数组  
arr_1d = np.array([0, 1, 2, 0, 3, 0, 4])  
# 计算非零元素的数量  
nonzero_count_1d = np.count_nonzero(arr_1d)  
print(nonzero_count_1d)  # 输出: 4  
  
# 创建一个二维数组  
arr_2d = np.array([[0, 1, 0], [2, 0, 3], [0, 4, 0]])  
# 计算整个二维数组中非零元素的数量  
nonzero_count_2d = np.count_nonzero(arr_2d)  
print(nonzero_count_2d)  # 输出: 4 
  
# 沿着第一个轴（行）计算非零元素的数量  
nonzero_per_row = np.count_nonzero(arr_2d, axis=0)  
print(nonzero_per_row)  # 输出: [1 2 1] 表示每行分别有1,2，3个非零元素  
  
# 沿着第二个轴（列）计算非零元素的数量  
nonzero_per_col = np.count_nonzero(arr_2d, axis=1)  
print(nonzero_per_col)  # 输出: [1 2 1] 表示每列分别有1, 2, 1个非零元素