Pytorch深度学习框架简明手册
1 Pytorch简介
Pytorch是Facebook人工智能研究院基于Torch开发的一个开源的Python机器学习库，它提供了两项强大的功能：1、强大的GPU加速的张量计算（NumPy)。2、自动求导系统的深度神经网络。
Tensorflow是纯符号式编程，运行效率高，但实现复杂；Pytorch是命令式编程，实现方便，但运行效率低。
2 Pytorch总览
3 Pytorch详解
3.1 torch
- 张量
| 函数 | 函数功能 |
|---|---|
| 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=<module 'pickle' from '/home/pickle.py'>,pickle_protoco1=2) | 保存一个对象到一个硬盘文件上 |
| torch.load(f,map_location=None,pickle_module=<module 'pickle' from '/home/pickle.py'>) | 从磁盘文件中读取一个通过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
- 参数设置
| 函数 | 函数功能 |
|---|---|
| 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)
转载自：一文总结深度学习框架-Pytorch - 简书 (jianshu.com)
