建立网络，对pytorch学习

最新推荐文章于 2024-02-09 23:37:29 发布

zhaohuan_1996

最新推荐文章于 2024-02-09 23:37:29 发布

阅读量930

点赞数 2

分类专栏：目标检测 python语法文章标签： pytorch 网络深度学习

本文链接：https://blog.csdn.net/qq_37199669/article/details/111868396

版权

目标检测同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

python语法

1 篇文章 0 订阅

订阅专栏

文章目录

1、torch.max
2、为什么每计算一个batch，就需要调用一次optimizer.zero_grad() ？
3、torch.no_grad()
4、val_label.size(0) 等价val_label.size()[0]
5、zip==python内置函数
6、nn.ReLU(inplace=True)
7、net.train()与net.eval()
8、item() → number
9、json.dumps()与json.loads()
10、json.dumps(indent=4,sort_keys,encoding)
11、enumerate(train_loader, start=0)
12、Python可迭代对象和迭代器：Iterable and Iterator
13、torch.flatten(x,1)
14、torch.cat([a,b,c],1)
15、取出批量数据的红、绿、蓝通道，进行数值处理，然后又组合成原来的样子
16、BatchNormalization
17、生成进度条
18、labels = [label for _, label in class_indict.items()]
19、pytorch .detach() 和 .data
20、os.path.join()函数
21、pycharm导入自定义模块运行正常但是有红线提示，并且不能使用代码补全功能
22、collections.defaultdict()
23、draw.rectangle()
24、draw.text()
25、ImageFont
26、tensor.unbind()
27、torch.nn.functional.interpolate
28、view和reshape
29、unsqueeze和None
30、broadcastable广播机制
31、bbox[:, [0, 2]] = width - bbox[:, [2, 0]]
32、torch.meshgrid(torch.tensor(),torch.tensor())
33、构建矩阵及矩阵的秩
34、sum() 针对一维向量，针对二维矩阵

1、torch.max

情况1：返回最大值
情况2：返回torch.return_types.max，这里有两个维度，第一个维度是该向量的最大值，第二个维度是该向量最大值所在索引。假设有mxn的矩阵，则得到m个最大值和对应索引。==这样的好处，既可以找到最大值，又可以找到最大值所在索引。
例子：
outputs = net(im) # [1,10]
predict = torch.max(outputs, dim=1) # 返回torch.return_types.max，这里有两个维度，第一个维度是该向量的最大值，第二个维度是该向量最大值所在索引。假设有mxn的矩阵，则得到m个最大值和对应索引
predict1 = torch.max(outputs, dim=1)[1].data.numpy() # 取第2维，即最大值的索引，再转为numpy
predict2 = torch.softmax(outputs,dim=1) # [1,10]
predict3 = torch.max(torch.softmax(outputs,dim=1)) # 得到最大概率值
predict3 = torch.max(torch.softmax(outputs,dim=1),dim=1)[1].data.numpy() # 得到最大概率值所在索引
综上，predict1=predict3，得到索引。

2、为什么每计算一个batch，就需要调用一次optimizer.zero_grad() ？

<==>把loss关于weight的导数变成0.
如果不清除历史梯度，就会对计算的历史梯度进行累加（通过这个特性你能够变相实现一个很大batch数值的训练）。
https://zhuanlan.zhihu.com/p/114435156
https://www.zhihu.com/question/303070254
神经网络一次梯度更新包含三个步骤：
1、前向运算
2、后向梯度计算；调用loss.backward(), 在pytorch里梯度会累加
3、可训练参数更新；调用optimizer.step, 更新权重
如果多次执行 loss.backward(), 而只执行一次optimizer.step(), 由于梯度累加，参数更新时用了前面多次loss.backward()的所有梯度信息。再执行一次optimizer.zero_grad(), 表示参数更新完毕，重置梯度。
其中真正的batch_size,又loss.backward()执行的次数有关， N越大，真正起作用的batch_size 越大。可以利用这个特点，在一些显存有限的机器上增大batch_size。比如将文章开头的代码修改如下，可以在不增加显存消耗的情况下，使batch_size增大N倍：

for i, minibatch in enumerate(tr_dataloader):
    features, labels = minibatch
    loss = model(features, labels)
    loss.backward()
    if 0 == i % N:
        optimizer.step()
        optimizer.zero_grad()

3、torch.no_grad()

不能进行梯度计算的上下文管理器
https://pytorch.org/docs/stable/generated/torch.no_grad.html?highlight=torch%20no_grad#torch.no_grad
https://blog.csdn.net/weixin_36670529/article/details/106643242
当确定这部分代码没有后向传播即tensor.backward时，就使用这个上下文管理，以便于这部分代码的计算不会进行梯度累加，也就不会改变权重参数。

4、val_label.size(0) 等价val_label.size()[0]

在pytorch中，得到的是1维张量，然后访问第一个维度的值。

5、zip==python内置函数

可以将两个列表组合成一个二维矩阵，常用于生成混淆矩阵
https://www.runoob.com/python/python-func-zip.html

6、nn.ReLU(inplace=True)

inpalce的作用：对从上层网络Conv2d中传递下来的tensor直接进行修改，不用多存储其他变量，这样能够节省运算内存。举个例子：

x = x +1 """对原值进行操作，然后将得到的值又直接复制到该值中"""

y = x + 1
x = y  """需要花费内存去多存储一个变量y"""

7、net.train()与net.eval()

区别在于，测试时，说一声net.eval()，让网络不要在测试的时候进行随机节点消失，我们只希望在训练的时候使用dropout功能。

8、item() → number

Returns the value of this tensor as a standard Python number. This only works for tensors with one element. For other cases, see tolist().

>>> x = torch.tensor([1.0])
>>> x.item()
1.0

9、json.dumps()与json.loads()

json.dumps()用于将字典形式的数据转化为字符串；json.loads()用于将字符串形式的数据转化为字典。
如果直接将dict类型的数据写入json文件中会发生报错，因此在将数据写入时需要用到json.dump(),
json.load()用于从json文件中读取数据。
https://www.cnblogs.com/ConnorShip/p/9744223.html

10、json.dumps(indent=4,sort_keys,encoding)

indent：是缩进的意思，代表缩进4个空格。
sort_keys：将数据根据keys的值进行排序,encoding。
encoding：默认是UTF-8，设置json数据的编码方式。

11、enumerate(train_loader, start=0)

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
https://www.runoob.com/python/python-func-enumerate.html

12、Python可迭代对象和迭代器：Iterable and Iterator

可以直接作用于for循环的对象统称为可迭代对象:Iterable。但是可迭代对象不一定是迭代器:Iterator。
https://www.codelieche.com/article/150838

13、torch.flatten(x,1)

按张量x的第1个维度channel展平<==>[batch,channel,width,height]–>[batch,channel x width x height]。

import torch
a = torch.rand(2,3,3,3)
b = torch.flatten(a,1)
print(a)
print(b)
print(b.shape)

tensor([[[[0.3714, 0.7201, 0.1523],
          [0.5787, 0.2984, 0.4183],
          [0.1336, 0.2137, 0.9645]],

         [[0.2047, 0.9564, 0.3041],
          [0.1583, 0.3178, 0.6886],
          [0.9450, 0.7538, 0.8273]],

         [[0.5657, 0.8606, 0.9621],
          [0.9550, 0.0812, 0.1741],
          [0.5380, 0.7102, 0.2316]]],


        [[[0.2770, 0.3454, 0.7485],
          [0.2184, 0.0026, 0.9648],
          [0.6479, 0.3042, 0.9185]],

         [[0.1725, 0.0306, 0.5920],
          [0.1914, 0.8542, 0.0542],
          [0.0632, 0.1499, 0.8916]],

         [[0.7393, 0.4802, 0.3842],
          [0.5616, 0.3373, 0.5888],
          [0.2011, 0.7998, 0.0677]]]])
tensor([[0.3714, 0.7201, 0.1523, 0.5787, 0.2984, 0.4183, 0.1336, 0.2137, 0.9645,
         0.2047, 0.9564, 0.3041, 0.1583, 0.3178, 0.6886, 0.9450, 0.7538, 0.8273,
         0.5657, 0.8606, 0.9621, 0.9550, 0.0812, 0.1741, 0.5380, 0.7102, 0.2316],
        [0.2770, 0.3454, 0.7485, 0.2184, 0.0026, 0.9648, 0.6479, 0.3042, 0.9185,
         0.1725, 0.0306, 0.5920, 0.1914, 0.8542, 0.0542, 0.0632, 0.1499, 0.8916,
         0.7393, 0.4802, 0.3842, 0.5616, 0.3373, 0.5888, 0.2011, 0.7998, 0.0677]])
torch.Size([2, 27])

14、torch.cat([a,b,c],1)

按列表的第1个维度channel叠加<==>[[batch,chan1,width,height],[batch,chan2,width,height],[batch,chan3,width,height]]–>[batch,chan1+chan2+chan3, width, height]。

import torch
a,b,c,d = torch.rand(2,3,3,3),torch.rand(2,3,3,3),torch.rand(2,3,3,3),torch.rand(2,3,3,3)
outputs = [a,b,c,d]
e = torch.cat(outputs,1)
print(len(outputs)) # list里面有4个torch
# print(e)
print(e.shape) # 按通道数叠加

15、取出批量数据的红、绿、蓝通道，进行数值处理，然后又组合成原来的样子

    def _transform_input(self, x): # x [2,3,3,3]
        # type: (Tensor) -> Tensor
        if self.transform_input:
            # 红通道x[:, 0] [2,3,3]; 绿通道x[:, 1] [2,3,3]; 蓝通道x[:, 2] [2,3,3]
            x_ch0 = torch.unsqueeze(x[:, 0], 1) * (0.229 / 0.5) + (0.485 - 0.5) / 0.5 # [2,1,3,3]
            x_ch1 = torch.unsqueeze(x[:, 1], 1) * (0.224 / 0.5) + (0.456 - 0.5) / 0.5 # [2,1,3,3]
            x_ch2 = torch.unsqueeze(x[:, 2], 1) * (0.225 / 0.5) + (0.406 - 0.5) / 0.5 # [2,1,3,3]
            x = torch.cat((x_ch0, x_ch1, x_ch2), 1) # [2,3,3,3]
        return x # [2,3,3,3]
 # 其中，x[:,0]等价x[:,0,:,:]

16、BatchNormalization

李宏毅深度学习batchNormalization
对每层的featuremap都进行处理（求每个batch的均值和方差），这样得到的loss接近圆形，在线性优化时，这样的图更容易下降到极点，这样在梯度下降的时候更快（比调整学习率还快）。
在这里插入图片描述
注意：当batch的很小时，就达不到batchNormalization的效果。

17、生成进度条

scale = torch.rand(2000,3,3,3)
start = time.perf_counter()
for epoch in range(50):
    for step,data in enumerate(scale,start=0):
        rate = (step + 1) / len(scale)
        a = '*' * int(rate * 50)
        b = '.' * int((1- rate)*50)
        c = rate * 100
        dur = time.perf_counter() - start
        print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, dur), end='')
    print()
    print('[epoch %d] ' %(epoch + 1))
    time.sleep(0.05)


```python
scale = torch.rand(20,3,3,3)
start = time.perf_counter()
for epoch in range(50):
    for step,data in enumerate(scale,start=0):
        a = '*' * step
        b = '.' * (len(scale)- step)
        c = (step+1)/len(scale) * 100
        dur = time.perf_counter() - start
        print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, dur), end='')
        # time.sleep(0.05)
    print()
    print('[epoch %d] ' % (epoch + 1))

18、labels = [label for _, label in class_indict.items()]

class_indict是字典类型，我们只要value，不要key，所以这样取出。将value传入ConfusionMatrix中，在构建table列名时使用。

19、pytorch .detach() 和 .data

用于切断反向传播

20、os.path.join()函数

https://www.cnblogs.com/an-ning0920/p/10037790.html
os.path.join()函数：连接两个或更多的路径名组件
1.如果各组件名首字母不包含’/’，则函数会自动加上
2.如果有一个组件是一个绝对路径，则在它之前的所有组件均会被舍弃
3.如果最后一个组件为空，则生成的路径以一个’/’分隔符结尾

21、pycharm导入自定义模块运行正常但是有红线提示，并且不能使用代码补全功能

https://www.zhihu.com/question/63028700

22、collections.defaultdict()

定义默认字典，其中value可以缺失。
https://blog.csdn.net/yangsong95/article/details/82319675

23、draw.rectangle()

矩形绘制，第一个参数指定矩形的对角线顶点（左上和右下），形式为（x0, y0, x1, y1），第二个指定填充颜色，第三个参数指定边界颜色；

24、draw.text()

文字的绘制，第一个参数指定绘制的起始点（文本的左上角所在位置），第二个参数指定文本内容，第三个参数指定文本的颜色，第四个参数指定字体（通过ImageFont类来定义）

25、ImageFont

1、 Getsize

定义：font.getsize(text)⇒ (width, height)

含义：返回给定文本的宽度和高度，返回值为2元组。

26、tensor.unbind()

https://pytorch.org/docs/stable/generated/torch.unbind.html#torch.unbind
在这里插入图片描述
将tensor的shape拆解，1 按行拆开，0 按列拆开

27、torch.nn.functional.interpolate

https://pytorch.org/docs/stable/nn.functional.html?highlight=interpolate#torch.nn.functional.interpolate
interpolate利用插值的方法缩放图片；该方法就是将原图放到一个更大的图之中，多余的地方用0填充。bilinear只支持4D Tensor。

28、view和reshape

view和reshape功能是一样的，先展平所有元素在按照给定shape排列。view函数只能用于内存中连续存储的tensor，permute（调换tensor顺序）等操作会使tensor在内存中变得不再连续，此时就不能再调用view函数。reshape则不需要依赖目标tensor是否在内存中是连续的。

29、unsqueeze和None

在tensor中的制定列加上None，则多一个维度，且值为1。这和unsqueese有类似功能，但是区别在于None可以在指定位置增加一个维度，而unsqueeze只能在首–添加维度；squeeze只能在首–去掉值为1的维度，例如：

import torch
anchor_sizes = ((32,), (64,), (128,), (256,), (512,))
aspect_ratios = ((0.5, 1.0, 2.0),) * len(anchor_sizes)
aspect_ratios = torch.as_tensor(aspect_ratios)
w = aspect_ratios[:,None] # torch.Size([5, 1, 3])
w = aspect_ratios[:,None,:] # torch.Size([5, 1, 3])
anchor_sizes=torch.as_tensor(anchor_sizes)
scale = anchor_sizes[None,:] # torch.Size([1, 5, 1])
ws = w * scale # torch.Size([5, 5, 3])

30、broadcastable广播机制

https://pytorch.org/docs/stable/notes/broadcasting.html#broadcasting-semantics
参考博客：https://blog.csdn.net/qq_36704378/article/details/108173371
a与b做*乘法，原则是如果a与b的size不同，则以某种方式将a或b进行复制，使得复制后的a和b的size相同，然后再将a和b做element-wise的乘法。

>>> a = torch.tensor([[1, 2], [2, 3]])
>>> b = torch.tensor([[[1,2],[2,3]],[[-1,-2],[-2,-3]]])
>>> a * b
tensor([[[ 1,  4],
         [ 4,  9]],

        [[-1, -4],
         [-4, -9]]])
>>> b * a
tensor([[[ 1,  4],
         [ 4,  9]],

        [[-1, -4],
         [-4, -9]]])

如果两个张量x，y是“broadcastable”，所得到的张量大小的计算方法如下：

如果维数x和y不相等，在前面加上1用更少的尺寸张量的尺寸以使它们相等的长度。
然后，对于每个尺寸大小，最终的尺寸大小就是该尺寸的最大值， x并y沿着该尺寸。

# can line up trailing dimensions to make reading easier
>>> x=torch.empty(5,1,4,1)
>>> y=torch.empty(  3,1,1)
>>> (x+y).size()
torch.Size([5, 3, 4, 1])

# but not necessary:
>>> x=torch.empty(1)
>>> y=torch.empty(3,1,7)
>>> (x+y).size()
torch.Size([3, 1, 7])

>>> x=torch.empty(5,2,4,1)
>>> y=torch.empty(3,1,1)
>>> (x+y).size()
RuntimeError: The size of tensor a (2) must match the size of tensor b (3) at non-singleton dimension 1

31、bbox[:, [0, 2]] = width - bbox[:, [2, 0]]

翻转对应bbox坐标信息；
与分类不同，同时使图片和bboxes都随机水平翻转。
在这里插入图片描述

32、torch.meshgrid(torch.tensor(),torch.tensor())

分别传入行坐标和列坐标，生成网格行坐标矩阵和网格列坐标矩阵

>>> x = torch.tensor([1, 2, 3])
>>> y = torch.tensor([4, 5, 6])
>>> grid_x, grid_y = torch.meshgrid(x, y)
>>> grid_x
tensor([[1, 1, 1],
        [2, 2, 2],
        [3, 3, 3]])
>>> grid_y
tensor([[4, 5, 6],
        [4, 5, 6],
        [4, 5, 6]])

33、构建矩阵及矩阵的秩

https://www.haomeiwen.com/subject/qkwwyhtx.html

34、sum() 针对一维向量，针对二维矩阵

针对二维矩阵

"""understand the function sum in python： """
import numpy as np
import scipy.sparse as sp
adj_mat_list = []
row  = np.array([0, 2, 3, 2, 4])
col  = np.array([0, 2, 3, 4, 2])
data = np.array([0, 4, 5, 7, 9])
a_adj = sp.coo_matrix((data, (row, col)), shape=(5, 5)).toarray()
b_adj = sp.coo_matrix((data, (col, row)), shape=(5, 5)).toarray()

row1  = np.array([0, 0, 1, 1, 0])
col1  = np.array([0, 2, 3, 0, 1])
data1 = np.array([1, 4, 5, 7, 9])
a_adj1 = sp.coo_matrix((data1, (row1, col1)), shape=(5, 5)).toarray()
b_adj1 = sp.coo_matrix((data1, (col1, row1)), shape=(5, 5)).toarray()

print(a_adj)
print(b_adj)
print(a_adj1)
print(b_adj1)
adj_mat_list.append(a_adj)
adj_mat_list.append(b_adj)
adj_mat_list.append(a_adj1)
adj_mat_list.append(b_adj1)
print(adj_mat_list)
adj_mat_list = sum(adj_mat_list)
print(type(adj_mat_list))
"""
[[0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 4 0 7]
 [0 0 0 5 0]
 [0 0 9 0 0]]
[[0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 4 0 9]
 [0 0 0 5 0]
 [0 0 7 0 0]]
[[1 9 4 0 0]
 [7 0 0 5 0]
 [0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]]
[[1 7 0 0 0]
 [9 0 0 0 0]
 [4 0 0 0 0]
 [0 5 0 0 0]
 [0 0 0 0 0]]
[array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 4, 0, 7],
       [0, 0, 0, 5, 0],
       [0, 0, 9, 0, 0]]), 
array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 4, 0, 9],
       [0, 0, 0, 5, 0],
       [0, 0, 7, 0, 0]]), 
array([[1, 9, 4, 0, 0],
       [7, 0, 0, 5, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0]]), 
array([[1, 7, 0, 0, 0],
       [9, 0, 0, 0, 0],
       [4, 0, 0, 0, 0],
       [0, 5, 0, 0, 0],
       [0, 0, 0, 0, 0]])]
[[ 2 16  4  0  0]
 [16  0  0  5  0]
 [ 4  0  8  0 16]
 [ 0  5  0 10  0]
 [ 0  0 16  0  0]]
"""

针对一维数组

import numpy as np
a = np.array([[1,2],[3,4]])
"""按行相加，并且保持其二维特性"""
print(np.sum(a, axis=1, keepdims=True))
"""按行相加，不保持其二维特性"""
print(np.sum(a, axis=1))
"""
array([[3], [7]])
array([3, 7])
"""

zhaohuan_1996

关注

2
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
建立网络，对pytorch学习

torch.max情况1：返回最大值情况2：返回torch.return_types.max，这里有两个维度，第一个维度是该向量的最大值，第二个维度是该向量最大值所在索引。假设有mxn的矩阵，则得到m个最大值和对应索引。==这样的好处，既可以找到最大值，又可以找到最大值所在索引。例子：outputs = net(im) # [1,10]predict = torch.max(outputs, dim=1) # 返回torch.return_types.max，这里有两个维度，第一个维度是该向量的.
复制链接

扫一扫