在深度学习中常用的torch,np语法

常用torch,np语法

一、torch
1.torch加载和保存模型：
有两种方式，一种是保存的是整个网路加参数，另一种是只保存参数

#1.网络+参数
torch.save(model,'net.pth')#保存  也可以是.pkl
model=torch.load('net.pth') #读取   直接赋值给网络就行了

#2.只保存参数
torch.save(model.state_dict(),"net.pth")
model.load_state_dict(torch.load("net.pth"))

2.查看tensor的尺寸：

x = torch.rand(3,3)
#两个效果是一样的
print(x.shape)
print(x.size())

3.使用 FloatTensor = torch.FloatTensor 对象快速创建一个指定数据类型的tensor：如FloatTensor, LongTensor

DEVICE = torch.device("cuda:3")
x = torch.rand(2,2).to(DEVICE)
#-----------------
#创建FloatTensor数据类型，这样写是放在cpu中
#------------------
FloatTensor =  torch.FloatTensor
y1 = torch.rand(3,3).type(FloatTensor)
#---------------------------------------
#指定cuda的longtensor数据类型，注意的是，这么写会默认设置这个数据是在cuda0位置
#且修改位置时得先存入CUDA0再换到其他位置，如果CUDA0位置是满的，会导致创建失败
#----------------------------------------
LongTensor  = torch.cuda.LongTensor if x.is_cuda else torch.LongTensor
y2 = torch.rand(3,3).type(LongTensor)

#---------------
# 为了避免创建失败，我们一般先创建一个放在cpu，然后转移到GPU，如对于y1
#-------------
y1 = y1.to(DEVICE)#这样y1就被放到了CUDA3上


#---------------------------------------
#  使用FloatTensor 对象创建一个和另一个tensor尺寸一样的tensor 
#   FloatTensor (x.shape)的括号里面一定是torch.size数据类型，如果是列表的话只会将这个列表转换
#    为tensor
#-------------------------------------------
jj = FloatTensor (x.shape) #这里x.shape和x.size（）是一样的作用

4. torch中tensor的[…,]索引方式取值
   这种方式可以用于对高纬tensor的最后维度值进行快速操作。

x = torch.rand(5,3,256,256，75)
first = x[..., 0]#这样得到了一个5,3,256,256大小的tensor,其每一个值都是最后一个75列中的第一个

5.torch中的linspace

x = torch.linspace(0, 25, 26) #得到的是 start-end 取n个点的一维tensor shape为：26

6.torch中的repeat()

#以5中得到的x为例
x = x.repeat(26,1)#repeat中的维度位置数量就代表了生成的tensor对应维度重复的数量，1代表不重复。得到的shape为:26,26  
x = x.repeat(13,1,1)# 得到的为13,26,26

二、np

1.np.concatenate: 作用是将()中多个np.array进行连接

#这一段代码是计算ap的
mrec = np.concatenate(([0.0], rec, [1.0]))
mpre = np.concatenate(([0.0], prec, [0.0]))
#例：
a = np.array([0.1,0.3,0.5])
x = np.concatenate(([[0],a,[0]]))
print(x)
>>>[0.  0.1 0.3 0.5 0. ]

2.np.where(condition)： 作用是返回array中满足条件的下标和数据类型，也就是说返回值有两个。
例：
这个例子中np.where(mrec[1:] != mrec[:-1])可以适用于在连续变化的数组中找到开始变化的位置。

mrec = np.array([0.0666,0.0666,0.1333,0.1333,0.1333,0.1333,0.1333,0.1333,0.1333,0.2,0.2,0.2666,0.3333 ,0.4,0.4,0.4,0.4,0.4,0.4,0.4,0.4,0.4,0.4666,0.4666])
k = np.where(mrec[1:] != mrec[:-1])
print(k)
print(k[0])
>>>(array([ 1,  8, 10, 11, 12, 21], dtype=int64),)
[ 1  8 10 11 12 21]

3.np中的一个重要语法：
当一个np.array使用索引时：如果这个索引时一个可iterable的变量，那么会自动进行一次遍历，如这里的x. print(kk[jj])

mrec=np.array([0.0666,0.0666,0.1333,0.1333,0.1333,0.1333,0.1333,0.1333,0.1333,0.2,0.2,0.2666,0.3333 ,0.4,0.4,0.4,0.4,0.4,0.4,0.4,0.4,0.4,0.4666,0.4666])
mrec = np.concatenate(([0.0], mrec, [1.0]))
k = np.array([ 0,  2  ,9 ,11 ,12, 13, 22 ,24])
x =(mrec[k + 1] - mrec[k]) *0.5
print(x)
>>>[0.0333  0.03335 0.03335 0.0333  0.03335 0.03335 0.0333  0.2667 ]
#简单的例子：
jj = np.array([0,1,2,3,4])
kk = np.array([1,2,3,4,5,6])
print(kk[jj])
>>>[1 2 3 4 5]

4.关于生成mask：
注意：操作基础是np.array()

x = np.array([[1,2,3,4,5],[5,4,6,7,9],[6,0,1,21,22]])
print(x)
mask  = x>3
print(mask)
print(x[mask])
>>>
[[ 1  2  3  4  5]
 [ 5  4  6  7  9]
 [ 6  0  1 21 22]]
[[False False False  True  True]
 [ True  True  True  True  True]
 [ True False False  True  True]]
[ 4  5  5  4  6  7  9  6 21 22]

x = torch.tensor([[1,2,3,4,5],[5,4,6,7,9],[6,0,1,21,22]])
temp = x[:,3]
print(temp)
mask1  = temp>5
print(mask1)
print(x[mask1])
>>>
>tensor([ 4,  7, 21])
tensor([0, 1, 1], dtype=torch.uint8)
tensor([[ 5,  4,  6,  7,  9],
        [ 6,  0,  1, 21, 22]])

5.关于np的排序：
np.argsort(x)默认是对x进行从小到大排序，返回的是x从小到大的下标。后面加[::-1]则是逆序。

x =np.array([2,3,6,4,1])
print(x)
arg_sort = np.argsort(x)[::-1]  
print(arg_sort)
>>>
[2 3 6 4 1]
[2 3 1 0 4]

6.发现了一个np.transpose(）函数特别有意思的地方但是好像没啥用：用于对通过opencv读取的图片进行行列的索引读取。
因为cv读取的图片使用索引进行提取像素值时是按照先行后列的顺序的，[行，列]。当我们要对指定行的所有列进行操作时很简单，直接用
[start:end , :]就可以，对于对指定列的所有行时也可以使用相同的方法，但是需要先进行transpose转换

ih, iw,_ = img.shape
w, h = 412,412
back = np.ones((w,h,3)).astype(np.uint8) * 128
scale = min(w / iw, h / ih)
nw = int(iw * scale)
nh = int(ih * scale)
image = cv.resize(img, (nw, nh))
print(image.shape)

if nw != w:    #这里是对列进行修改，一个多此一举的变化，但是很有意思
    start =  int((w - nw)/2)
    back = np.transpose(back,(1,0,2))
    image = np.transpose(image,(1,0,2))
    back[start:start+nw,:] = image
    back = np.transpose(back,(1,0,2))
else:
    start = int((h - nh) / 2)
    back[start:start+nh,:] = image

7.reshape:

x = [10.0, 13.0, 16.0, 30.0, 33.0, 23.0, 30.0, 61.0, 62.0, 45.0, 59.0, 119.0, 116.0, 90.0, 156.0, 198.0, 373.0, 326.0]
y  = np.array(x).reshape(-1, 2) #这里reshape（dim1,dim2）就是把x重新变成指定的形状，-1表示自适应。最后一个维度就是按照存储顺序以给定的数目一组一组的取数。