一文总结深度学习框架-Pytorch

1 Pytorch简介

Pytorch是Facebook人工智能研究院基于Torch开发的一个开源的Python机器学习库，它提供了两项强大的功能：1、强大的GPU加速的张量计算（NumPy)。2、自动求导系统的深度神经网络。

Tensorflow是纯符号式编程，运行效率高，但实现复杂；Pytorch是命令式编程，实现方便，但运行效率低。

[TOC]

2 Pytorch总览

image.png

3 Pytorch详解

3.1 torch

image.png

• 张量

函数	函数功能
torch.is_tensor(obj)	判断obj是否为tensor数据类型
torch.is_storage(obj)	判断obj是否为storage类型
torch.set_default_tensor_type(type)	设置默认的tensor数据类型
torch.set_printoptions(precision=None,threshold=None,linewidth=None,profile=None)	设置打印格式

• 创建操作

函数	函数功能
torch.eye(n,m=None,out=None)	创建主对角矩阵
torch.from_numpy(ndarray)	将numpy.ndarray转换为Tensor
torch.linspace(start,end,steps=100,out=None)	创建含steps个元素的一维张量
torch.logspace(start,end,steps=100,out=None)	创建位于10start-10end内的一维张量
torch.zeros(*sizes,out=None)	创建全0张量
torch.ones(*sizes,out=None)	创建全1张量
torch.rand(*sizes,out=None)	创建位于0-1的均匀分布的张量
torch.randn(*sizes,out=None)	从标准正态分布中抽取数据创建张量
torch.arange(start,end,step=1,out=None)	创建一维张量

• 索引、切片、连接、换位

函数	函数功能
torch.cat(inputs,dimension=0)	在给定维度上对inputs进行拼接
torch.chunk(tensor,chunks,dim=0)	在给定维度上对tensor进行分块
torch.split(tensor,split_size,dim=0)	在给定维度上对tensor进行分块
torch.squeeze(input,dim=None,out=None)	去除输入张量形状中的1并返回
torch.stack(sequence,dim=0)	沿着新维度对输入张量序列进行拼接
torch.t(input,out=None)	对input矩阵进行装置
torch.transpose(input,dim0,dim1,out=None)	交换input的dim0与dim1
torch.unbind(tensor,dim=0)	移除指定维度，并返回一个包含了沿着指定维度切片后的各个切片
torch.sequence(input,dim,out=None)	返回一个新张量，对输入的位置插入维度1

• 随机抽样

函数	函数功能
torch.normal(means,std,out=None)	返回一个张量，包含从给定参数means,std离散分布中抽取随机数

• 序列化

函数	函数功能
torch.save(obj,f,pickle_moudle=,pickle_protoco1=2)	保存一个对象到一个硬盘文件上
torch.load(f,map_location=None,pickle_module=)	从磁盘文件中读取一个通过torch.save()保存的对象

• 并行化

函数	函数功能
torch.get_num_threads()	获取用于并行化CPU操作的OpenMP线程数
torch.set_num_threads(int)	设定用于并行化CPU操作的OpenMP线程数

• 数学操作

函数	函数功能
torch.div(input,value,out=None)	将input逐元素除以标量value
torch.exp(tensor,out=None)	计算input每个元素的指数
torch.abs(input,out=None)	计算input每个元素的绝对值
torch.sin(input,out=None)	计算每个元素的正弦值
torch.cos(input,out=None)	计算每个元素的余弦值
torch.atan(input,out=None)	计算input每个元素的反正切
torch.asin(input,out=None)	计算每个元素的反正弦
torch.acos(input,out=None)	计算每个元素的反余弦
torch.cosh(input,out=None)	计算input每个元素的双曲余弦
torch.add(input,value,out=None)	对input逐元素加上标量value
torch.addcdiv(tensor,value,tensor1,tensor2,out=None)	用tensor2对tensor1逐元素相除，乘以value并加到tensor
torch.addcmul(tensor,value,tensor1,tensor2,out=None)	用tensor2对tensor1逐元素相乘，乘以value，然后加到tensor
torch.floor(input,out=None)	对input每个元素向下取整
torch.ceil(input,out=None)	对input每个元素向上取整
torch.clamp(input,min,max,out=None)	将input每个元素夹紧至【min,max】内
torch.fmod(input,divisor,out=None)	计算input每个元素的除法余数
torch.frac(tensor,out=None)	返回每个元素的分数部分
torch.log(input,out=None)	计算log的自然对数
torch.mul(input,value,out=None)	将input逐元素乘以标量value
torch.net(input,out=None)	将input逐元素取负
torch.pow(input,exponent,out=None)	将input逐元素求exponent次幂
torch.reciprocal(input,out=None)	计算input每个元素的倒数
torch.remainder(input,divisor,out=None)	计算input每个元素的除法余数
torch.round(input,out=None)	计算input每个元素四舍五入后的值
torch.rsqrt(input,out=None)	计算input每个元素的平方根倒数
torch.sigmoid(input,out=None)	计算input每个元素的sigmoid值
torch.sign(input,out=None)	返回input每个元素的符号
torch.sqrt(input,out=None)	计算input每个元素的平方根
torch.trunc(input,out=None)	将input每个元素的小数部分截断
torch.cumprod(input,dim,out=None)	沿着dim维度计算input累积积
torch.cumsum(input,dim,out=None)	沿dim维度计算input累计和
torch.dist(input,other,p=2,out=None)	返回（input-other）的p范数
torch.mean(input)	计算input所有元素的均值
torch.mean(input,dim,out=None)	计算input指定维度所有元素的均值
torch.median(input,dim=-1,values=None,indices=None)	返回input给定维度所有元素的中位数，同时返回一个包含中位数的索引的LongTensor
torch.mode(input,dim,values=None,indices=None)	返回给定维度所有元素的众数，同时返回一个包含众数索引的LongTensor
torch.norm(input,p，dim,out=None)	返回input的p范数
torch.prod(input,dim)	返回input所有元素的积
torch.std(input,dim)	返回input所有元素的标准差
torch.sum(input,dim)	返回input所有元素的和
torch.var(input,dim)	返回input在给定维度上每个元素的方差

• 比较操作

函数	函数功能
torch.eq(input,other,out=None)	比较input每个元素是否与other相等
torch.equal(tensor1,tensor2)	比较tensor1与tensor2是否完全相等
torch.ge(input,other,out=None)	逐元素比较input和other
torch.gt(input,other,out=None)	逐元素比较input和other
torch.kthvalue(input,k,dim=None,out=None)	取输入张量input指定维度上第K个最小值
torch.le(input,other,out=None)	逐元素比较input和other
torch.lt(input,other,out=None)	逐元素比较input和other
torch.max(input,dim)	返回input给定维度上的最大值
torch.min(input,dim)	返回input给定维度上的最小值
torch.ne(input,other)	逐元素比较input和other
torch.sort(input,dim=None,descending=False,out=None)	对输入张量input沿着指定维度按升序排序
torch.topk(input,k,dim=None,largest=True,out=None)	沿指定维度返回input中K个最大值

• 其他操作

函数	函数功能
torch.cross(input,other,dim,out=None)	沿着指定维度计算input与other的向量积
torch.dot(tensor1,tensor2)	计算两个张量的内积
torch.eig(a,eigenvectors=False,out=None)	计算方阵a的特征值和特征向量
torch.inverse(input,out=None)	对方阵input取逆
torch.mm(mat1,mat2,out=None)	计算mat1与mat2的乘积
torch.mv(mat,vec,out=None)	计算矩阵与向量vec的乘积
torch.abs_(input)	torch.abs(input)的in-place运算形式

3.2 torch.nn

image.png

• 参数设置

函数	函数功能
torch.nn.Parameter(data,requires_grad)	将不可训练的data转换为可训练的类型parameter，并将这个parameter绑定到module内

• torch.nn.Module基类

函数	函数功能
add_module(name,module)	将一个child module添加到当前module，可通过name属性获取module
cuda(device_id=None)	将所有模型参数复制到GPU
cpu(device_id=None)	将所有模型参数复制到CPU
double()	将parameters和buffers的数据类型转换为double
float()	将parameters和buffers的数据类型转换为float
half()	将parameters和buffers的数据类型转换为half
eval()	将模型设置成evaluation模式
forward(*input)	定义了每次执行的计算步骤，在所有子类中都需要重写这个函数
modules()	返回一个包含当前模型所有模块的迭代器
named_modules()	返回包含网络中所有模块的迭代器
children()	返回当前模型子模块的迭代器
named_children()	返回包含模型当前模块的迭代器
load_state_dict(state_dict)	加载模型参数，将state_dict中的parameters和buffers复制到module和他的后代中
parametes(memo=None)	返回一个包含模型所有参数的迭代器
register_backward_hook(hook)	在module上注册一个backward hook,hook(module,grad_input,grad_output)
register_forward_hook(hook)	在module上注册一个forward hook，hook(module,input,output)
register_buffer(name,tensor)	给module添加一个永久buffer
register_parameter(name,param)	向module添加parameter
state_dict()	返回一个保存着module所有状态的字典
train(mode=True)	将module设置为training mode
zero_grad()	将module中所有模型参数的梯度设置为0
torch.nn.Sequential(*args)	一个时序容器，modules会以它们传入的顺序被添加到容器中，也可以传入一个orderedDict
torch.nn.ModuleList(modules=None)	将submodules保存在一个list中
append(module)	等价与list中的append
extend(modules)	等价于list中的extend
torch.nn.ParameterList(parameters=None)	将submodules保存在一个list中

• 卷积层

---

torch.nn.Conv1d(in_channels,out_channels,kernel_size,stride=1,padding=0,dilation=1,groups=1,bias=True)

---

torch.nn.Conv2d(in_channels,out_channels,kernel_size,stride=1,padding=0,dilation=1,groups=1,bias=True)

---

torch.nn.Conv3d(in_channels,out_channels,kernel_size,stride=1,padding=0,dilation=1,groups=1,bias=True)

---

参数	参数意义
in_channels	输入信号的信道
out_channels	卷积产生的通道
kernel_size(int or tuple)	卷积核尺寸
stride(int,tuple,optional)	卷积步长
padding(int or tuple,optional)	输入的每一条边补充0的层数
dilation(int or tuple,optional)	卷积核元素之间的间距
groups(int,optional)	从输入通道到输出通道的阻塞连接数
bias(bool,optional)	是否添加偏置

---

torch.nn.ConvTranspose1d(in_channels,out_channels,kernel_size,stride=1,padding=0,outpu_padding=0,groups=1,bias=True)

---

torch.nn.ConvTranspose2d(in_channels,out_channels,kernel_size,stride=1,padding=0,outpu_padding=0,groups=1,bias=True)

---

torch.nn.ConvTranspose3d(in_channels,out_channels,kernel_size,stride=1,padding=0,outpu_padding=0,groups=1,bias=True)

参数	参数意义
in_channels(int)	输入信号的通道
out_channels(int)	卷积产生的通道
kernel_size(int or tuple)	卷积核尺寸
stride(int,tuple,optional)	卷积步长
padding(int or tuple,optional)	输入的每一条边补充0的层数
output_padding(int or tuple,optional)	输出的每一条边补充0的层数
dilation(int or tuple,optional)	卷积核元素之间的间距
groups(int,optional)	从输入通道到输出通道的阻塞连接数
bias(bool,optional)	是否添加偏置

---

torch.nn.MaxPool1d(kernel_size,stride=None,padding=0,dilation=1,return_indices=False,ceil_mode=False)

---

torch.nn.MaxPool2d(kernel_size,stride=None,padding=0,dilation=1,return_indices=False,ceil_mode=False)

---

torch.nn.MaxPool3d(kernel_size,stride=None,padding=0,dilation=1,return_indices=None,ceil_mode=False)

---

参数	参数意义
kernel_size(int or tuple)	max pooling的窗口大小
stride(int,tuple,optional)	max pooling的窗口移动步长
padding(int or tuple,optional)	输入的每一条边补充0的层数
dilation(int or tuple,optional)	控制窗口中元素的字符
return_indices	为True时，会返回输出最大值的序号
ceil_mode	为True时，计算输出信号的大小时使用向上取整

---

torch.nn.AvgPool1d(kernel_size,stride=None,padding=0,ceil_mode=False,count_include_pad=True)

---

torch.nn.AvgPool2d(kernel_size,stride=None,padding=0,ceil_mode=False,count_include_pad=True)

---

torch.nn.AvgPool3d(kernel_size,stride=None,padding=0,ceil_mode=False,count_include_pad=True)

---

参数	参数意义
kernel_size(int or tuple)	池化层窗口大小
stride(int,tuple,optional)	池化层窗口移动步长
padding(int or tuple,optional)	输入的每一条边补充0的层数
ceil_mode	为True时，计算输出信号大小的时候，会使用向上取整
count_include_pad	为True时，计算平均池化时，将包括padding填充的0

---

torch.nn.AdaptiveMaxPool1d(output_size,return_indices=False)

---

torch.nn.AdaptiveMaxPool2d(output_size,return_indices=False)

---

torch.nn.AdaptiveMaxPool3d(output_size,return_indices=False)

---

参数	参数意义
output_size	输出信号的尺寸
return_indices	为True时，会返回输出的索引，对nn.MaxUnpool有用

---

torch.nn.AdaptiveAvgPool1d(output_size)

---

torch.nn.AdaptiveAvgPool2d(output_size)

---

参数	参数意义
output_size	输出信号的尺寸

---

torch.nn.MaxUnpool1d(kernel_size,stride=None,padding=0)

---

torch.nn.MaxUnpool2d(kernel_size,stride=None,padding=0)

---

torch.nn.MaxUnpool3d(kernel_size,stride=None,padding=0)

---

参数	参数意义
kernel_size(int or tuple)	maxunpooling的窗口的大小
stride(int,tuple,optional)	maxunpooling的窗口移动的步长
padding(int or tuple,optional)	输入的每一条边补充0的层数

---

torch.nn.FractionalMaxPool2d(kernel_size,output_size=None,output_ratio=None,return_indices=False,_random_samples=None)

---

参数	参数意义
kernel_size(int or tuple)	池化层窗口大小
output_size	输出图像的大小
output_ratio	将输入图像大小的百分比指定为输出图像的大小

---

torch.nn.LPPool2d(norm_Type,kernel_size,stride=None,ceil_mode=False)

---

参数	参数意义
kernel_size(int or tuple)	池化层窗口大小

• 非线性激活函数

函数	函数功能
torch.nn.ReLU()
torch.nn.ELU(alpha=1.0,inplace=Flase)
torch.nn.PReLU(num_parameters=1,init=0.25)
torch.nn.LeakyReLU(negative_slope=0.01,inplace=False)
torch.nn.Threshold(threshold,value,inplace=False)
torch.nn.Hardtanh(min_value=-1,max_value=1,inplace=False)
torch.nn.Sigmoid()
torch.nn.Tanh()
torch.nn.LogSigmoid()
torch.nn.Softplus(beta=1,threshold=20)
torch.nn.Softshrink(lambda=0.5)
torch.nn.Softsign()
torch.nn.Softmin()
torch.nn.Softmax()
torch.nn.LogSoftmax()

• 正则化

---

torch.nn.BatchNorm1d(num_features,eps=1e-05,momentum=0.1,affine=True)

---

torch.nn.BatchNorm2d(num_features,eps=1e-05,momentum=0.1,affine=True)

---

torch.nn.BatchNorm3d(num_features,eps=1e-05,momentum=0.1,affine=True)

---

参数	参数意义
num_features	来自期望输入的特征数，该期望输入的大小为batch_size*num_features
eps	为保证数值稳定性，给分布加上的值
momentum	动态均值和动态方差所使用的动量
affine	为True时，给该层添加学习的仿射变换参数

• 循环层

---

torch.nn.RNN(input_size,hidden_size,num_layers=1,nonlinearity=tanh,bias=True,batch_first=False,dropout=0,bidirectional=False)

---

torch.nn.LSTM(input_size,hidden_size,num_layers=1,nonlinearity=tanh,bias=True,batch_first=False,dropout=0,bidirectional=False)

---

torch.nn.GRU(input_size,hidden_size,num_layers=1,nonlinearity=tanh,bias=True,batch_size=False,dropout=0,bidirectional=False)

---

参数	参数意义
input_size	输入特征的维度
hidden_size	隐藏层神经元个数
num_layers	网络的层数
nonlinearity	激活函数
bias	是否使用偏置
batch_first	输入数据的形式
dropout	是否使用dropout
bidirectional	是否使用双向RNN

---

torch.nn.RNNCell(input_size,hidden_size,bias=True,nonlinearity='tanh')

---

torch.nn.LSTMCell(input_size,hidden_size,bias=True,nonlinearity='tanh')

---

torch.GRUCell(input_size,hidden_size,bias=True,nonlinearity='tanh')

---

参数	参数意义
input_size	输入特征的维度
hidden_size	隐藏层神经元个数
nonlinearity	激活函数
bias	是否使用偏置

• 线性层

---

torch.nn.Linear(in_features,out_features,bias=True)

---

参数	参数意义
in_features	每个输入样本的大小
out_features	每个输出样本的大小
bias	为False时，不学习偏置

• 裁剪层

---

torch.nn.Dropout(p,inplace=False)

---

torch.nn.Dropout2d(p,inplace=False)

---

torch.nn.Dropout3d(p,inplace=False)

---

参数	参数意义
p	将元素置0的概率
inplace	为True时，会原地执行操作

• 稀疏层

---

torch.nn.Embedding(num_embeddings,embedding_dim,padding_idx=None,max_norm=None,norm_type=2,scale_grad_by_freq=False,sparse=False)

---

参数	参数意义
num_embeddings(int)	嵌入字典的大小
embedding_dim(int)	每个嵌入向量的大小
padding_idx(int,optional)	如果提供的话，输出遇到此下标时用零填充
max_norm(float,optional)	如果提供的话，会重新归一化词嵌入，使它们的范数小于提供的值
norm_type(float,optional)	对于max_norm选项计算P范数时的p
scale_grad_by_freq(bollean,optional)	如果提供的话，会根据字典中单词频率缩放梯度

• 距离函数

---

torch.nn.PairwiseDistance(p=2,eps=1e-06)

---

参数	参数意义
p	范数次数

• 损失函数

---

torch.nn.L1Loss(size_average=True)|

---

torch.nn.MSELoss(size_average=True)

---

torch.nn.CrossEntropyLoss(weight=None,size_average=True)

---

torch.nn.NLLLoss(weight=None,size_average=True)

---

torch.nn.NLLLoss2d(weight=None,size_average=True)

---

torch.nn.KLDivLoss(weight=None,size_average=Ture)

---

torch.nn.BCELoss(weight=None,size_average=True)

---

torch.nn.MarginRankingLoss(margin=0,size_average=True)

---

torch.nn.HingeEmbeddingLoss(size_average=True)

---

torch.nn.MultiLabelMarginLoss(size_average=True)

---

torch.nn.SmoothL1Loss(size_average=True)

---

torch.nn.SoftMarginLoss(size_average=True)

---

torch.nn.MultiLabelSoftMarginLoss(weight=None,size_average=True)

---

torch.nn.CosineEmbeddingLoss(margin=0,size_average=True)

---

torch.nn.MultiMarginLoss(p=1,margin=1,weight=None,size_average=True)

---

• 视觉层

---

torch.nn.PixelShuffle(upscale_factor)

---

torch.nn.UpsamplingNearest2d(size=None,scale_factor=None)

---

torch.nn.UpsamplingBilnear2d(size=None,scale_factor=None)

---

• 多GPU层

---

torch.nn.DataParallel(module,device_ids=None,output_device=None,dim=0)

---

• 工具函数

---

torch.nn.utils.clip_grad_norm(parameters,max_norm,norm_type=2)

---

torch.nn.utils.rnn.PackedSequence(_cls,data,batch_sizes)

---

torch.nn.utils.rnn.pack_padded_sequence(input,lengths,batch_first=False)

---

torch.nn.utils.rnn.pad_packed_sequence(sequence,batch_first=False)

---

3.3 torch.nn.functional

包含与torch.nn相对的所有实现；只不过torch.nn.functional是以函数形式封装的这些实现。

torch.nn.X	torch.nn.functional
类	函数
结构中包含所需要初始化的参数	需要在函数外定义并初始化相应参数，并作为参数传入
一般情况下放在init中实例化，并在forward中完成操作	一般在init中初始化相应参数，在forward中传入

3.4 torch.nn.autograd

---

torch.autograd.backward(variables,grad_variables,retain_variables=False)

---

参数	参数意义
variables	将计算导数的变量
grad_variables	渐变写入相应变量的每个元素
retain_gradph	若为False，则用于计算grad的图形将被释放
create_grahp	若为True,则构造导数的图形

---

torch.autograd.grad(outputs,inputs,grad_outputs=Noneretain_graph=None,create_graph=None,only_inputs=True)

---

参数	参数意义
outputs	差分函数的输出
inputs	输入将返回梯度的积分
grad_outputs	渐变wrd每个输出
retain_graph	若为False，则用于计算grad的图形被释放
create_graph	若为True，则构造导数的图形
only_inputs	若为True,则渐变wrt离开时图形的一部分，但不显示inputs不会被计算和累积

• torch.autograd.Variable

包裹张量并记录应用的操作

函数	函数意义
backward(gradient=None,retain_variables=False)	当前Variable对leaf variable求偏导
detach()	返回一个新变量与当前图形分离
detach_()	从创建它的图形中分离变量，与当前图形分离
register_hook(hook)	注册一个backward钩子
reinforce(reward)	注册一个奖励，这个奖励是由一个随机过程得到的
retain_grad()	启用非叶变量的.grad属性

• torch.autograd.Function
  记录操作历史并定义用于区分操作的公式

函数	函数意义
backward(*grad_output)	定义用于区分操作的公式
static forward	执行操作

3.5 torch.optim

• torch.optim.Optimizer(params,default)

所有优化器的基类

函数	函数意义
load_state_dict(state_dict)	加载optimizer状态
state_dict()	以dict类型返回optimizer状态
step(closure)	进行单步优化
zero_grad()	清空所有被优化过的Variable的梯度

---

优化器	优化器意义
torch.optim.Adadelta(params,lr=1.0,rho=0.9,eps=1e-06,weight_decay=0)	实现Adadelta算法
torch.optim.Adagrad(params,lr=0.01,lr_decay=0,weight_decay=0)	实现Adagrad算法
torch.optim.Adam(params,lr=0.001,betas=(0.9,0.999),eps=1e-08,weight_decay=0)	实现Adam算法
torch.optim.Adamax(params,lr=0.002,betas=(0.9,0.999),eps=1e-08,weight_decay=0)	实现Adamax算法
torch.optim.ASGD(params,lr=0.01,lambd=0.0001,alpha=0.75,t0=1000000.0,weight_decay=0)	实现平均随机梯度下降算法
torch.optim.LBFGS(params,lr=1,max_iter=20,max_eval=None,tolerance_grad=1e-05,tolerance_change=1e-09,history_size=100,line_search_fn=None)	实现L-BFGS算法
torch.optim.RMSprop(params,lr=0.01,alpha=0.99,eps=1e-08,weight_decay=0,momentum=0,centered=False)	实现RMSprop算法
torch.optim.Rprop(params,lr=0.01,etas=(0.5,1.2),step_sizes=(1e-06,50))	实现弹性反向传播算法
torch.optim.SGD(params,lr,momentum=0,dampening=0,weight_decay=0,nesterov=False)	实现随机梯度下降算法

3.6 torch.nn.init

---

torch.nn.init.calculate_gain(nonlinearity,param=None)

---

torch.nn.init.uniform(tensor,a=0,b=1)

---

torch.nn.init.normal(tensor,mean=0,std=1)

---

torch.nn.init.constant(tensor,val)

---

torch.nn.init.eye(tensor)

---

torch.nn.init.dirac(tensor)

---

torch.nn.init.xavier_uniform(tensor,gain=1)

---

torch.nn.init.xavier_normal(tensor,gain=1)

---

torch.nn.init.kaiming_uniform(tensor,a=0,mode='fan_in')

---

torch.nn.init.kaiming_normal(tensor,a=0,mode='fan_in')

---

torch.nn.init.orthogonal(tensor,gain=1)

---

torch.nn.init.sparse(tensor,sparsity,std=0.01)

---

3.7 torch.multiprocessing

用于在相同数据的不同进程中共享视图

3.8 torch.cuda

实现与CPU张量相同的功能，但使用GPU进行计算

函数	函数意义
torch.cuda.current_blas_handle()	返回cublasHandle_t指针
torch.cuda.current_device()	返回当torch.cuda.current_stream()	返回一个当前所选的stream
torch.cuda.device(idx）	上下文管理器，可以更改所选设备
torch.cuda.device_count()	返回可获得的GPU数量
torch.cuda.device_of(obj)	将当前设备更改为给定对象的上下文管理器
torch.cuda.is_available()	指示CUDA当前是否可用
torch.cuda.set_device(device)	设置当前设备
torch.cuda.stream(stream)	选择给定流的上下文管理器
torch.cuda.synchronize()	等待当前设备上所有流中的所有核心完成
torch.cuda.comm.broadcast(tensor,devices)	向一些GPU广播张量
torch.cuda.comm.reduce_add(inputs,destination=None)	将来自多个GPU的张量相加
torch.cuda.comm.scatter(tensor,devices,chunk_sizes=None,dim=0,streams=None)	打散横跨多个GPU的张量
torch.cuda.comm.gather(tensors,dim=0,destination=None)	从多个GPU收集张量
torch.cuda.Stream	CUDA流的包装
torch.cuda.Event(enable_timing=False,blocking=False,interprocess=False,_handle=None)	CUDA事件的包装

3.9 torch.utils

• torch.utils.data.Dataset

表示Dataset的抽象类，所有子类应该override len和getitem，前者提供了数据集的大小，后者支持整数索引

函数	函数意义
torch.utils.data.TensorDataset(data_tensor,target_tensor)	包装数据和目标张量的数据集
torch.utils.data.DataLoader(dataset,batch_size,shuffle,sampler,num_workers,collate_fn,pin_memory,drop_last)	数据加载器，组合数据集和采集器，并在数据集上提供单进程或多进程迭代器

• torch.utils.data.sampler.Sampler(data_source)

所有采样器的基础类，每个采样器子类必须提供一个iter方法，提供一种迭代数据集元素的索引的方法，以及返回迭代器长度的len方法

函数	函数意义
torch.utils.data.sampler.SequentialSampler(data_source)	样本元素顺序排列，始终以相同的顺序
torch.utils.data.sampler.RandomSampler(data_source)	样本元素随机，没有替换
torch.utils.data.sampler.SubsetRandomSampler(indices)	样本元素从指定的索引列表中随机抽取，没有替换
torch.utils.data.sampler.WeightedRandomSampler(weights,num_samples,replace=True)	样本元素来自于【0，len(weights)-1】，给定概率
torch.utils.model_zoo.load_url(url,model_dir=None)	在给定的URL上加载Torch序列化对象

3.10 torch.torchvision

• 内含数据集

---

torchvision.datasets.MNIST(root,train=True,transform=None,target_transform=None,download=False)

---

torchvision.datasets.CocoCaptions(root='dir where images are',annFile='json annotation file',[transform,target_transform])

---

torchvision.datasets.CocoDetection(root='dir where images are',annFile='json annotation file',[transform,target_transform])

---

torchvision.datasets.LUSN(db_path,classes='train',[transform,target_transform])

---

torchvision.datasets.ImageFolder(root='root_folder path',[transform,target_transform])

---

torchvision.datasets.CIFAR10(root,train=True,transform=None,target_transform=None,download=False)

---

torchvision.datasets.CIFAR100(root,train=True,transform=None,target_transform=None,download=False)

---

torchvision.datasets.STL10(root,split='train',transform=None,target_transform=None,download=False)

---

• 内含模型

---

torchvision.models.alexnet(pretrained=False,**kwargs)

---

torchvision.models.resnet18(pretrained=False,**kwargs)

---

torchvision.models.resnet34(pretrained=False,**kwargs)

---

torchvision.models.resnet50(pretrained=False,**kwargs)

---

torchvision.models.resnet101(pretrained=False,**kwargs)

---

torchvision.models.resnet152(pretrained=False,**kwargs)

---

torchvision.models.vgg11(pretrained=False,**kwargs)

---

torchvision.models.vgg11_bn(**kwargs)

---

torchvision.models.vgg13(pretrained=False,**kwargs)

---

torchvision.models.vgg13_bn(**kwargs)

---

torchvision.models.vgg16(pretrained=False,**kwargs)

---

torchvision.models.vgg16_bn(**kwargs)

---

torchvision.models.vgg19(pretrained=False,**kwargs)

---

torchvision.models.vgg19_bn(**kwargs)

---

• 数据预处理

---

torchvision.transforms.Compose(transforms)

---

torchvision.transforms.CenterCrop(size)

---

torchvision.transforms.RandomCrop(size,padding=0)

---

torchvision.transforms.RandomHorizontalFlip

---

torchvision.transforms.RandomSizedCrop(size,interpolation=2)

---

torchvision.transforms.Pad(padding,fill=0)

---

torchvision.transform.Normalize(mean,std)

---

torchvision.transforms.ToTensor

---

torchvision.transforms.ToPILImage

---

torchvision.transforms.Lambda(lambda)

---

torchvision.utils.make_grid(tensor,nrow=8,padding=2,normalize=False,range=None,scale_each=False)

---

torchvisin.utils.save_image(tensor,filename,nrow=8,padding=2,normalize=False,range=None,scale_each=False)