PyTorch基础

PyTorch文档：https://pytorch.org/docs/stable/index.html

PyTorch常用代码段合集：https://zhuanlan.zhihu.com/p/205407928

一、基础知识

Pytorch和Tensorflow的数据格式

Pytorch: N * Channels * Height * Width, NCHW

Tensorflow: N * Height * Width * Channels, NHWC

---

自动求导(autograd)机制

注：只有对标量才能进行求梯度的操作

---

logits

logits指网络最后一层位于激活函数之前的向量。

nn.BCELoss: 输入值必须在0～1区间里，因此需要对logits进行Softmax处理

nn.BCEWithLogitsLoss: 不需要对logits进行Softmax处理

二、基本配置

版本信息

方法描述torch.__version__查询torch版本torch.version.cuda查询cuda版本torch.backends.cudnn.version()查询cudnn版本

显卡设置

方法描述torch.cuda.device_count()查询显卡数量torch.cuda.get_device_name()查询显卡版本torch.cuda.is_available()cuda是否可用

torch.device('cuda:0')

<=> torch.device('cuda', 0)

<=> torch.device(0)

torch.device('cuda', if torch.cuda.

is_available else 'cpu')

指定显卡

os.environ['CUDA_VISIBLE_

DEVICES']='0, 1'

指定可见的显卡，‘-1’表示显卡不可见

可复现性

方法描述np.random.seed(0)numpy随机数种子torch.manual_seed(0)cpu随机数种子torch.cuda.manual_seed(0)给当前gpu设置随机数种子torch.cuda.manual_seed_all(0)给所有gpu设置随机数种子

三、张量处理

张量数据类型                              

数据类型CPU张量torch.float() / torch.float32()torch.FloatTensor()torch.long() / torch.float64()torch.LongTensor()torch.half() / torch.float16()torch.HalfTensor()torch.uint8()torch.ByteTensor()torch.int8()torch.CharTensor()torch.int16()torch.ShortTensor()torch.int32()torch.IntTensor()torch.int64()torch.LongTensor()torch.bool()torch.BoolTensor()

张量性质

方法描述tensor.size() <=> tensor.shape张量形状tensor.dtype()张量数据类型tensor.dim()张量维度数量

数组和张量的相互转换

方法描述torch.from_numpy(ndarray)数组转张量torch.Tensor(ndarray)数组转张量tensor.numpy()CPU张量转数组tensor.cpu().numpy()GPU张量转数组tensor.detach().numpy()有梯度的张量转数组

生成随机张量

方法描述torch.rand(*size)生成在区间[0, 1)内均匀分布的张量torch.randn(*size)生成服从标准正态分布的张量torch.normal(mean, std, size)生成服从离散正态分布的张量

张量操作

方法描述

tensor.cuda(device) <=> tensor.to(device)

将CPU张量转换为GPU张量tensor.view(size)改变连续存储的张量的形状，返回视图tensor.reshape(size)改变张量的形状，张量可以不是连续存储的（经过tanspose、permute、narrow、expand等操作得到的张量与原张量共享内存，但原来在内存中相邻的元素在执行这样的操作后，在内存中不相邻了，即不连续了)tensor.clone()复制张量，开辟一段新的内存，返回值仍在计算图中tensor.detach()将张量从当前计算图中分离，返回一个新的张量，仍指向原张量的存储位置，requires_grad为false，得到的这个张量永远不需要计算其梯度，不具有grad，即使之后将requires_grad设为true，也不会具有gradtensor.detach().clone()将张量从当前计算图中分离并复制tensor.max(dim)计算张量的最大值，tensor.max()[0]返回计算结果，tensor.max()[1]返回最大值的索引tensor.clamp(min, max)将张量的值限制在[min, max]之间tensor.clamp_(min, max)将张量的值限制在[min, max]之间，将返回值赋值给原tensor

四、常用API

torch.nn

containers

 

类型类名描述Containersnn.Module(object)所有neural network modules的基类nn.Sequential(nn.Module)nn.Sequential(*args)，不需要重写forward方法，按照传入参数的顺序进行forwardnn.ModueList(nn.Module)nn.ModuleList(iterable)，需要重写forward方法Convolutional Layersnn.Conv2d nn.ConvTranspose2d Pooling Layersnn.MaxPool2d nn.AvgPool2d Non-linear Activationsnn.ReLu nn.Sigmoid nn.Tanh Normalization Layersnn.BatchNorm2d Linear Layersnn.Linear Dropout Layersnn.Dropout nn.Dropout2d Loss Functionsnn.L1Loss nn.MSELoss nn.CrossEntropyLoss nn.BCELoss nn.BCEWithLogitsLoss nn.SmoothL1Lloss Vision Layersnn.UpsamplingNearest2d nn.UpsamplingBilinear2d DataParallel Layersnn.DataParallel <=> nn.parallel.DataParallelmodel = nn.DataParallel(model)，返回的model已经不是原始的model了，而是一个DataParallel对象，原始的model保存在DataParallel的module变量里。nn.parallel.DistributedDataParallel 

torch.nn.functional

torch.nn和torch.nn.functional：大写的是类，小写的是函数，类可以放入container中

torch.optim

 

torch.utils.data

torch.utils.data.Dataset

class MyDataset(Dataset): def __int__(self, *args): def __len__ (self): def __getitem__(self, idx): dataset = MyDataset(*args)

torch.utils.data.Dataloader

DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False) 参数描述shuffle sampler batch_sampler num_workers collate_fn pin_memory

pin_memory: 读取速度快，但对内存要求较高

https://blog.csdn.net/tfcy694/article/details/83270701

drop_last 

torch数值运算

 

 

tensor.backward()

tensor.backward(retain_graph=True)，retain_graph用于保留计算图。由于Pytorch默认一个计算图（一次前向传播）只计算一次反向传播，计算完成后计算图就会被释放，因此如果后续还要用到计算图的话需要设retain_graph为true

---

net.state_dict(), net.parameters(), net.named_parameters()

for param in net.parameters():     print(param) for name, param in net.named_parameters():     print(f'{name}, {param}') # state_dict是一个有序字典，items返回了可遍历的(k, v)元组数组 for name, param in net.state_dict().items():     print(f'{name}, {param}')

注：net.state_dict().items() 中parameters的requires_grad属性都为False，且无法改变，要想改变requires_grad的属性只能通过前两种方式

---

torch.save()、torch.load()

一般保存为.pkl或者.pth文件

只保存参数、加载参数：

torch.save(net.state_dict, 'net_parameters.pkl') net.load_state_dict(torch.load( 'net_parameters.pkl'))

保存整个网络、加载网络：

torch.save(net, 'net.pkl') net = torch.load('net.pkl')

保存、加载更多的信息：

torch.save({'epoch': epoch, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict()}, PATH)

checkpoint = torch.load(PATH) net.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) epoch = checkpoint['epoch']

加载预训练模型中的部分参数，并固定:

# 加载预训练模型中的部分参数 model=resnet() model_dict = model.state_dict() pretrained_dict = torch.load(PATH) new_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict} model_dict.update(new_dict) model.load_state_dict(model_dict)

# 固定参数 for name, param in self.named_parameters():     # print(name)     if 'conv.3' in name:         params.requires_grad = False

# 过滤掉不需要训练的参数 optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=0.0001)

---

net.train()、net.eval()、with torch.no_grad()

Dropout层和BN层在train模式和eval模式下有不同的表现：

1.Dropout层在train模式下会丢失一部分连接，在eval模式下则不会；

2.BN层在train模式下用当前batch的mean、var和历史batch的mean、var做加权平均，在eval模式下只使用训练好的mean、var值，不使用当前batch的mean、var，否则batch_size过小，BN层很容易导致图片失真。

eval模式同样也会计算gradient，但是并不回传。

with torch.no_grad()用于停止gradient的计算，从而节省GPU，但是并不会影响dropout和batchnorm层的行为。