pytorch常⽤整理，以及代码⽰例
⽂章⽬录
device
device = torch.device("cuda"if torch.cuda.is_available()el"cpu")
model = del_def).to(device)
variable
Varibale包含三个属性：
data：存储了Tensor，是本体的数据
grad：保存了data的梯度，本事是个Variable⽽⾮Tensor，与data形状⼀致
grad_fn：指向Function对象，⽤于反向传播的梯度计算之⽤
# torch.autograd.Variable是Autograd的核⼼类，它封装了Tensor，并整合了反向传播的相关实现(tensor
变成variable之后才能进⾏反向传播求梯度?⽤变量.ba ckward()进⾏反向传播之后,ad中保存了var的梯度)
x = Variable(tensor, requires_grad =True)
#demo
import torch
from torch.autograd import Variable
only love 歌词x = (2,2), requires_grad =True)
print(x)#其实查询的是x.data，是个tensor
save load
# save
torch.save(model.state_dict(), PATH)
# load
model = MyModel(*args,**kwargs)
model.load_state_dict(torch.load(PATH))
model.eval()
torch.clampwith a spirit
industrial是什么意思#将输⼊input张量每个元素的夹紧到区间 [min,max][min,max]，并返回结果到⼀个新张量。
# (n1, n2, 2)
interction_dims = torch.clamp(upper_bounds - lower_bounds,min=0)
torch.clamp(input,min,max, out=None)→ Tensor
torch.cuda.is_available
#cuda是否可⽤；
torch.cuda.is_available()
# 返回gpu数量；
torch.cuda.device_count()
# 返回gpu名字，设备索引默认从0开始；
_device_name(0)
# 返回当前设备索引
torch.cuda.current_device()
model.apply
# demo1
def init_weights(m):
print(m)
if type(m)== nn.Linear:
m.weight.data.fill_(1.0)
print(m.weight)
net = nn.Sequential(nn.Linear(2,2), nn.Linear(2,2)) net.apply(init_weights)
#output
Linear(in_features=2, out_features=2, bias=True) Parameter containing:
tensor([[1.,1.],
[1.,1.]])
Linear(in_features=2, out_features=2, bias=True) Parameter containing:
tensor([[1.,1.],
[1.,1.]])
Sequential(
(0): Linear(in_features=2, out_features=2, bias=True)
(1): Linear(in_features=2, out_features=2, bias=True) )
Sequential(
(0): Linear(in_features=2, out_features=2, bias=True)
(1): Linear(in_features=2, out_features=2, bias=True) )
# yolov3
def weights_init_normal(m):
classname = m.__class__.__name__
if classname.find("Conv")!=-1:
elif classname.find("BatchNorm2d")!=-1:
# model_def 为yolov3每个层的⼀些设置: [convolutional]
batch_normalize=1
filters=32
size=1
stride=1
pad=1
activation=leaky
model = del_def).to(device)
model.apply(weights_init_normal)cesar
torch.numel
torch.numel()返回⼀个tensor变量内所有元素个数，可以理解为矩阵内元素的个数
torch.squeeze &unsqueeze
torch.squeeze()对于tensor变量进⾏维度压缩，去除维数为1的的维度。例如⼀矩阵维度为A*1*B*C*1*D，通过squeeze()返回向量的维度为A*B*C*D。squeeze (a)，表⽰将a的维数位1的维度删掉，squeeze(a,N)表⽰，如果第N维维数为1，则压缩去掉，否则a矩阵不变
torch.unsqueeze()是squeeze()的反向操作，增加⼀个维度，该维度维数为1，可以指定添加的维度。例如unsqueeze(a,1)表⽰在1这个维度进⾏添加
torch.stack
torch.stack(quence, dim=0, out=None)，做tensor的拼接。quence表⽰Tensor列表，dim表⽰拼接的维度，注意这个函数和concatenate是不同的，torch 的concatenate函数是torch.cat，是在已有的维度上拼接，⽽stack是建⽴⼀个新的维度，然后再在该纬度上进⾏拼接。
expand_as(a)这是tensor变量的⼀个内置⽅法，如果使⽤b.expand_as(a)就是将b进⾏扩充，扩充到a的维度，需要说明的是a的低维度需要⽐b⼤，例如b的sha pe是3*1，如果a的shape是3*2不会出错，但是是2*2就会报错了
torch.view_as
返回被视作与给定的tensor相同⼤⼩的原tensor。等效于：
lf.view(tensor.size())
# demo
a = torch.Tensor(2,4)
b = a.view_as(torch.Tensor(4,2))
Datat -> dataloader
datat from torch.utils.data import Datat
class TensorDatat(Datat):
r"""Datat wrapping tensors.
Each sample will be retrieved by indexing tensors along the first dimension.
Arguments:
*tensors (Tensor): tensors that have the same size of the first dimension.
"""
def__init__(lf,*tensors):
asrt all(tensors[0].size(0)== tensor.size(0)for tensor in tensors)
"""
⼀般我们输⼊的tensors包含有 data和labels，这⾥的getitem
把每⼀条数据和label对应起来，并且形成tuple返回，然后我们
energy profile
就可以在dataloader之后这样做):
打分数for data in train_loader:
images, labels = data
函数中tensor[index]的index是由于data不⽌⼀个，这⾥留下
index⽅便后⾯在dataloader中进⾏随机批量等操作。
"""
def__getitem__(lf, index):
return tuple(tensor[index]for tensor sors)
def__len__(lf):
sors[0].size(0)
DataLoader from torch.utils.data DataLoader
dataloaer：部分流程上有⽤的参数及其代码。
查看流程
这部分代码⾸先要看shuffle，这⾥假设它是true，即跳转到处理shuffle，并⽣成sampler的那⼀⾏
BatchSamper那⼀⾏
iter，_SingleProcessDataLoaderIter的代码附在后⾯，
class DataLoader(object):
r"""
Arguments:
# datat (Datat): ⼀般从上⾯的tensordatat load进来
# batch_size (int, optional): 每⼀次训练有多少个样本，默认是1
# shuffle (bool, optional): 是否打乱，默认Fal
# sampler (Sampler, optional):
# 当sample不为none的时候，是不可以使⽤shuffle的，
mmds如果batch_sampler没有定义的话且batch_size有定义，
会根据sampler, batch_size, drop_last⽣成⼀个batch_sampler，
# 当sample为none的时候，函数会根据shuffle是否为true⽣成⼀个
乱序或者⾮乱序的sampler，后⾯的代码中观察出，sampler是数据的索引数组。
batch_sampler (Sampler, optional):
# batch_sampler就是返回batch个sampler中的值，这些值是datat的索引。
所⽤当shuffle为true由于我们的限制，是不能直接传sampler进来的。因为当
shuffle为true的时候，需要⽣成⼀个乱序的sampler。
#num_workers (int, optional): 多线程，但是windows系统只能⽤0
"""
torch.flip
torch.flip(input, dims)→ Tensor
沿给定轴反转nD张量的顺序，以暗淡表⽰.
>>> x = torch.arange(8).view(2,2,2)jetway
>>> x
tensor([[[0,1],
[2,3]],
[[4,5],
[6,7]]])
>>> torch.flip(x,[0,1])
tensor([[[6,7],
[4,5]],
[[2,3],
[0,1]]])
www 900game net函数返回张量在某⼀个维度扩展之后的张量，就是将张量⼴播到新形状。函数对返回的张量不会分配新内存，即在原始张量上返回只读视图，返回的张量内存是不连续的。类似于numpy中的broadcast_to函数的作⽤。如果希望张量内存连续，可以调⽤contiguous函数。
import torch
x = sor([1,2,3,4])
xnew = x.expand(2,4)
print(xnew)
# output
tensor([[1,2,3,4],
[1,2,3,4]])
# 横向
import torch
x = sor([1,2,3])
goagainstxnew = x.repeat(1,3)
print(xnew)
# tensor([[1, 2, 3, 1, 2, 3, 1, 2, 3]])
# 纵向
import torch
x = sor([1,2,3])
xnew = x.repeat(3,1)
print(xnew)
# out
tensor([[1,2,3],
[1,2,3],
[1,2,3]])
F.interpolate
input (Tensor) – 输⼊张量
size (int or Tuple[int] or Tuple[int, int] or Tuple[int, int, int]) – 输出⼤⼩.
scale_factor (float or Tuple[float]) – 指定输出为输⼊的多少倍数。如果输⼊为tuple，其也要制定为tuple类型
mode (str) – 可使⽤的上采样算法，有’nearest’, ‘linear’, ‘bilinear’, ‘bicubic’ , ‘trilinear’和’area’. 默认使⽤’nearest’
# 实现插值和上采样
def interpolate(input, size=None, scale_factor=None, mode='nearest', align_corners=None):
pad
<
conv init
