Pytorch Note

1. 总的来说，大部分情况下，设置这个 flag 可以让内置的 cuDNN 的 auto-tuner 自动寻找最适合当前配置的高效算法，来达到优化运行效率的问题。
   一般来讲，应该遵循以下准则：如果网络的输入数据维度或类型上变化不大，设置 torch.backends.cudnn.benchmark = true 可以增加运行效率；如果网络的输入数据维度或类型上变化不大，设置 torch.backends.cudnn.benchmark = true 可以增加运行效率；
   如果网络的输入数据在每次 iteration 都变化的话，会导致 cnDNN 每次都会去寻找一遍最优配置，这样反而会降低运行效率。
2. data.Dataset用来当作数据集，并进行loader。方法如下：

from torch.utils import data
class CelebA(data.Dataset):
    """Dataset class for the CelebA dataset."""
    def __getitem__(self, index):
	    """写自己的东西"""

    def __len__(self):
        """写自己的东西"""
        
data_loader = data.DataLoader(dataset=dataset, batch_size=batch_size,
                              shuffle=(mode == 'train'), num_workers=num_workers)

3. torch.randperm 随机排列 如：

>>> torch.randperm(4)
tensor([ 2,  1,  0,  3])

4. 移动到GPU：
   G.to(self.device)
   其中 G是nn.Module

5. 多个交叉熵损失
   F.binary_cross_entropy_with_logits

6. 求梯度，反向传播，优化

self.g_optimizer = torch.optim.Adam(self.G.parameters(), self.g_lr, [self.beta1, self.beta2])

...

self.g_optimizer.zero_grad()
g_loss.backward()
self.g_optimizer.step()

7. 不需要反向传播，用于测试或者显示阶段性结果

with torch.no_grad():
    x_fake_list = [x_fixed]
    for c_fixed in c_fixed_list:
        x_fake_list.append(self.G(x_fixed, c_fixed))
    x_concat = torch.cat(x_fake_list, dim=3)
    sample_path = os.path.join(self.sample_dir, '{}-images.jpg'.format(i + 1))
    save_image(self.denorm(x_concat.data.cpu()), sample_path, nrow=1, padding=0)
    print('Saved real and fake images into {}...'.format(sample_path))

8. 更新学习率

for param_group in self.g_optimizer.param_groups:
    param_group['lr'] = g_lr
for param_group in self.d_optimizer.param_groups:
    param_group['lr'] = d_lr

9. 存模型，读模型

torch.save(self.G.state_dict(), G_path)
...
self.G.load_state_dict(torch.load(G_path, map_location=lambda storage, loc: storage))

一篇更详细的文章：https://blog.csdn.net/hungryof/article/details/81364487

10. nn.ModuleList
    nn.ModuleList is just like a Python list. It was designed to store any desired number of nn.Module’s. It may be useful, for instance, if you want to design a neural network whose number of layers is passed as input:

11. nn.ReflectionPad2d(3)
    Pads the input tensor using the reflection of the input boundary.

input = torch.randn(64, 3, 220, 220) # input size
 
# 4-tuple
pad = nn.ReflectionPad2d((3, 3, 5, 5)) # laft, right, top, bottom
output = pad(input) # size(64, 3, 230, 226)
 
# int
pad = nn.ReflectionPad2d(3)
output = pad(input) # size(64, 3, 226, 226)

ReflectionPad2d 是paddingLayer，padding的方式多种，可以是指定一个值，也可以是不规则方式，即给出一个四元组，

输出大小的计算方式如下：

Ho = Hi + paddingTop + paddingBottom， Wo = Wi + paddingLeft + paddingRight
原文：https://blog.csdn.net/LemonTree_Summer/article/details/81433638

nn.Conv2d(nf_prev, nf, 3, stride=1, dilation=dilate_rate, padding=dilate_rate)

dilation为感受野，可参见https://blog.csdn.net/cai13160674275/article/details/71155295

13. 限制元素大小

torch.clamp(input, min, max, out=None)

14. 从Numpy数组进行初始化

Variable(torch.from_numpy(weights).cuda(), requires_grad=False)

15. 放到多块GPU上跑

model = nn.DataParallel(model, device_ids=opt.gpu_ids)

16. 为学习速率设置定时器，用于调整

from torch.optim import lr_scheduler
d_scheduler = lr_scheduler.LambdaLR(optimizer_D, lambda epoch: 0.2 ** (epoch // 20))

d_scheduler.step(epoch)

17. eval() 时，pytorch会自动把BN和DropOut固定住，不会取平均，而是用训练好的值。

18. Given an input and a flow-field grid, computes the output using input pixel locations from the grid. 可以参见GeoGAN networks.py warp_image_with_flow函数

F.grid_sample(image, grid)

class Decoder(nn.Module):
	def __init__(self):
		...
		for m in self.modules():  # 查看decoder的所有modules，重复的modules只返回一次
		...

20. Parameter
    when they’re assigned as Module attributes they are automatically added to the list of its parameters, and will appear e.g. in ~Module.parameters iterator. Assigning a Tensor doesn’t have such effect.

21. expand

tensor.expand

把tensor复制成一堆

22. register_buffer
    Adds a persistent buffer to the module.
    This is typically used to register a buffer that should not to be considered a model parameter. For example, BatchNorm’s running_mean is not a parameter, but is part of the persistent state.
    Buffers can be accessed as attributes using given names.

class AdaptiveInstanceNorm2d(nn.Module):
	def __init__(self, num_features, eps=1e-5, momentum=0.1):
		...
		self.register_buffer('running_mean', torch.zeros(num_features))
		...

tensor.new(..)

Constructs a new tensor of the same data type as self tensor.

• 创建变量时，torch.zeros((N)).type(dtype) 中的 .type(dtype) 很重要！不然默认在CPU，往后写的时候会出现类型不匹配的问题
• tensor.device 查看在cpu还是gpu
• tensor.type(torch.cuda.FloatTensor) 改变到GPU
• tensor.cuda() 和tensor.cpu()分别变为gpu和cpu
• 反向传播的非叶子节点似乎没有tensor.grad？？？
• fake_images = G(g_fake_seed).detach() # 梯度截断 防止往下传播

25. input_label.scatter_(1, label_map, 2.0) 取label_map为第一维的index，填充2.0. 该方法用于semantic spatial adaptive norm中的mask one_hot
    codes[i].masked_select(segmap.bool()[i, j]) 基于mask做选择

26. Pytorch中.cuda(non_blocking=True)的作用
    .cuda()是为了将模型放在GPU上进行训练。
    为何要设置参数non_blocking=True呢？
    non_blocking默认值为False, 通常我们会在加载数据时，将DataLoader的参数pin_memory设置为True, DataLoader中参数pin_memory的作用是：将生成的Tensor数据存放在哪里，值为True时，意味着生成的Tensor数据存放在锁页内存中，这样内存中的Tensor转义到GPU的显存会更快。
    主机中的内存，有两种存在方式，一是锁页，二是不锁页，锁页内存存放的内容在任何情况下都不会与主机的虚拟内存进行交换（注：虚拟内存就是硬盘），而不锁页内存在主机内存不足时，数据会存放在虚拟内存中。显卡中的显存全部是锁页内存,当计算机的内存充足的时候，可以设置pin_memory=True。当系统卡住，或者交换内存使用过多的时候，设置pin_memory=False。（参考：链接）
    如果pin_memory=True的话，将数据放入GPU的时候，也应该把non_blocking打开，这样就只把数据放入GPU而不取出，访问时间会大大减少。
    ————————————————
    版权声明：本文为CSDN博主「TEn%」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    原文链接：https://blog.csdn.net/qq_37297763/article/details/116670668

27. 取消梯度

for param in self.parameters():
	param.requires_grad = False