pytorch方法介绍汇总

短命女 2022-04-25 04:18 384阅读 0赞

1.从后向中排除子图

每个变量有requires\_grad和volatile两个标志，允许从梯度计算中精细地排除子图

如果所有变量都不需要梯度，后向计算不在子图中执行，requires\_grad可以冻结部分模型；volatile决定requires\_grad为false，不需要更改模型的任何设置来用于inference，不会保存中间状态

2.自动求导编码历史信息

每个变量有一个.creator属性，指向把它作为输出的函数；每执行一个操作，一个表示它的新Function被实例化，forward()函数被调用，输出的Variable的创建者被设置为这个Function，通过跟踪从任何变量到叶节点的路径重建创建数据的操作序列并自动计算梯度；整个图在每次迭代时从头开始重新创建，故每次迭代时可改变图的整体形状和大小

3.Variable上In-place操作

限制原因：覆盖梯度计算所需的值；需要实现重写计算图，当许多变量引用相同存储且被修改输入的存储被其他Variable引用时，函数会抛出错误

4.In-place正确性检查

每个变量保留有version counter，每次递增；Function保存任何用于后向的tensor时会保存其包含变量的version counter；访问self.saved\_tensors时被检查如果大于保存的值会引起错误

5.CUDA语义

torch.cuda记录当前选择的GPU，并分配所有CUDA张量在上面创建，使用torch.cuda.device更改所选设备

一旦张量被分配直接对其操作不考虑所选设备，默认不支持跨GPU操作，copy\_()例外

例子：with torch.cuda.device(1)        torch.randn(2).cuda(2)

6.最佳实践

使用固定内存缓冲区——当副本来自固定内存时主机到GPU的复制速度快很多；CPU张量和存储开放了pin\_memory()方法，返回对象副本，数据放在固定区域；可使用异步GPU副本，只传递额外的async=True参数到cuda()调用；pin\_memory=True传递给构造参数可使DataLoader将batch返回到固定内存

使用nn.DataParallel替代multiprocessing——多数涉及批量输入和多个GPU的情况默认使用DataParallel来使用多个GPU

7.扩展PyTorch（如何扩展torch.nn, torch.autograd和使用C库编写自定义的C扩展）

添加新的Operation到autograd，Operation继承class Function；autograd使用Function计算结果和梯度，并编码operation的历史；【每个operation(function)需实现三个方法：(1)\_\_init\_\_(optional)——如果operation包含非Variable参数，将其作为\_\_init\_\_的参数传入operation中；(2)forward()——写执行此operation的代码，可有任意数量参数，参数只能是Variable，返回值既可以是Variable也可以是Variables的tuple；(3)backward()——梯度计算公式，参数个数和forward返回值个数一样，每个返回值对应输入值的梯度，如果operation的输入不需要梯度或不可导可返回None】

8.扩展torch.nn

nn包含两种接口——modules和它们的functional版本，建议扩展layer时使用modules，modules保存着参数和buffer；不需要参数则使用functional(激活函数，pooling，这些都不需要参数)；增加一个module，因nn重度使用autograd，添加一个新module需实现一个用来执行计算和计算梯度的Function

例子：实现一个Linear module，之前已经实现一个Linear Function；需实现两个方法\_\_init\_\_(optional)和forward()用来实例化一个执行operation的Function，使用它执行operation

9.多进程最佳实践

torch.multiprocessing替代python的multiprocessing，支持完全相同操作但扩展了，以便通过multiprocessing.Queue发送的所有张量将其数据移动到共享内存中，且只会向其他进程发送一个句柄；当Variable发送到另一个进程时，Variable.data和Variable.grad.data都将被共享

10.共享CUDA张量

仅python3使用spawn或forkserver启动方法才支持在进程间共享CUDA张量，python2中multiprocessing只能使用fork创建子进程，且不被CUDA运行时所支持

避免和抵制死锁——死锁可能原因：后台线程；multiprocessing.Queue用于序列化，发送和接收对象的多个线程；可使用multiprocessing.queues.SimpleQueue

重用经过队列的缓冲区——每次将Tensor放入multiprocessing.Queue时，需将其移动到共享内存；如果已经被共享则为无效操作

异步多进程训练——torch.multiprocessing，可异步训练模型，参数可一直共享，也可以定期同步；建议使用multiprocessing.Queue来在进程间传递各种PyTorch对象

11.序列化语义

保存模型的方法——序列化和恢复模型（第一种只保存和加载模型参数torch.save：.state\_dict()，torch.load：.load\_state\_dict；第二种保存和加载整个模型）

\----------------------------------------------------------------------------------------------------------------------------------------------------------------

1.torch包：有多维张量的数据结构及基于其上的多种数学操作；提供多种工具，更有效对张量和任意类型序列化；有CUDA的对应实现，可在NVIDIA GPU上进行张量运算

2.张量Tensors

torch.is\_tensor(obj)：判断对象是否是一个pytorch张量；

torch.is\_storage(obj)：判断对象是否是一个pytorch storage对象；

torch.\_set\_default\_tensor\_type\_(t)：

torch.numel(input)：返回input张量中的元素个数；

torch.set\_printoptions(precision=None, threshold=None, linewidth=None, profile=None)：设置打印选项；

3.创建操作Creation Ops

torch.eye(n, m=None, out=None)：返回一个2维张量，对角线位置全1，其它位置全0；n为行数，m为列数；

torch.from\_numpy(ndarray)：numpy桥，将numpy.ndarray转换为pytorch的Tensor；返回的张量tensor和numpy的ndarray共享同一内存空间；修改一个另一个也被修改；返回的张量不能改变大小；

torch.linspace(start, end, steps=100, out=None)：返回一个1维张量，包含在区间start和end上均匀间隔的steps个点；输出1维张量的长度为steps；

torch.logspace(start, end, steps=100, out=None)：返回一个1维张量，包含在区间10的start次方和10的end次方上以对数刻度均匀间隔的steps个点；

torch.ones(\*sizes, out=None)：返回一个全为1的张量，形状由可变参数sizes定义；

torch.rand(\*sizes, out=None)：返回一个张量，包含从区间\[0,1)的均匀分布中抽取的一组随机数，形状由可变参数sizes定义；

torch.randn(\*sizes, out=None)：返回一个张量，包含从标准正态分布(均值为0，方差为1)中抽取一组随机数；

torch.randperm(n, out=None)：给定参数n，返回一个从0到n-1的随机整数排列(n为上边界，不包含)；

torch.arange(start, end, step=1, out=None)：返回一个1维张量，长度为floor((end-start)/step)，包含start到end，以step为步长的一组序列值(步长默认为1)；

torch.range(start, end, step=1, out=None)：返回一个1维张量，有floor((end-start)/step)+1个元素，包含在半开区间\[start, end)的一组值，step为两个值之间的间隔，建议使用torch.arrange()；

torch.zeros(\*sizes, out=None)

4.索引，切片，连接，换位 Indexing, Slicing, Joining, Mutating Ops

torch.cat(inputs, dimension=0)：在给定维度上对输入的张量序列seq进行连接操作；看作torch.split()和torch.chunk()的反操作；

torch.chunk(tensor, chunks, dim=0)：在给定维度(轴)上将输入张量进行分块，chunks为分块个数

torch.gather(input, dim, index, out=None)：沿给定轴dim，将输入索引张量index指定位置的值进行聚合；dim为索引的轴，index为聚合元素的下标；

torch.index\_select(input, dim, index, out=None)：沿指定维度对输入进行切片，取index中指定的相应项(index为一个LongTensor)，然后返回一个新张量与原始张量有相同的维度；

torch.masked\_select(input, mask, out=None)：根据掩码张量mask中二元值，取输入张量中指定项(mask为一个ByteTensor)，将取值返回到一个新的1D张量，mask应跟input张量有相同数量的元素数目，但形状或维度不需要相同，返回张量不与原始张量共享内存空间；

torch.nonzero(input, out=None)：返回一个包含输入input中非零元素索引的张量；输出张量中每行包括输入中非零元素的索引；

torch.split(tensor, split\_size, dim=0)：将输入张量分割成相等形状的chunks(如果可分)，如果不能被整分，最后一个分块小于其它分块；

torch.squeeze(input, dim=None, out=None)：将输入张量形状中的1去除并返回，如果dim给定，挤压操作只在给定维度上；返回张量与输入张量共享内存；

torch.stack(sequence, dim=0)：沿一个新维度对输入张量序列进行连接，序列中所有张量应为相同形状；

torch.t(input, out=None)：输入一个矩阵(2维张量)，并装置0，1维；等同于transpose(input, 0, 1)；

torch.transpose(input, dim0, dim1, out=None)：返回输入矩阵input的转置，交换维度dim0和dim1；输出张量和输入张量共享内存；

torch.unbind(tensor, dim=0)：移除指定维后，返回一个元组，包含沿指定维切片后的各个切片；

torch.unsqueeze(input, dim, out=None)：返回一个新张量，对输入指定位置插入维度1，返回张量与输入张量共享内存；如果dim为负，则被转化为dim+input.dim()+1

5.随机抽样 Random sampling

torch.manual\_seed(seed)：设定生成随机数的种子，并返回一个torch.\_C.Generator对象；

torch.initial\_seed()：返回生成随机数的原始种子值；

torch.get\_rng\_state()：返回随机生成器状态(ByteTensor)；

torch.set\_rng\_state(new state)：设定随机生成器状态，参数new\_state；

torch.default\_generator = <torch.\_C.Generator object>

torch.bernoulli(input, out=None)：从伯努利分布中抽取二元随机数(0或者1)，输入张量须包含用于抽取上述二元随机值的概率；返回值是与输入相同大小的张量，每个值为0或1；

torch.multinomial(input, num\_samples, replacement=False, out=None)：返回一个张量，每行包含从input相应行中定义的多项分布中抽取的num\_samples个样本；replacement决定样本抽取是否可以重复；

torch.normal(means, std, out=None)：返回一个张量，包含从给定参数means，std的离散正态分布中抽取随机数；均值means是一个张量，包含每个输出元素相关的正态分布的均值；std是一个张量，包含每个输出元素相关的正态分布的标准差；

6.序列化 Serialization

torch.save(obj, f, pickle\_module=<module 'pickle' from '...'>, pickle\_protocol=2)：保存一个对象到一个硬盘文件上；

torch.load(f, map\_location=None, pickle\_module=<module 'pickle' from '...'>)：从磁盘文件读取一个通过torch.save()保存的对象，可通过map\_location动态地进行内存重映射，使其能从不动设备中读取文件；

7.并行化 Parallelism

torch.get\_num\_threads()：获得用于并行化CPU操作的OpenMP线程数；

torch.set\_num\_threads(int)：设定用于并行化CPU操作的OpenMP线程数；

8.数学操作Math operations

(1) Pointwise Ops

torch.abs(input, out=None)：计算输入张量的每个元素绝对值；

torch.acos(input, out=None)：返回一个新张量，包含输入张量每个元素的反余弦；

torch.add(input, value, out=None)：对输入张量input逐元素加上标量值value，并返回结果到一个新的张量；

torch.add(input, value=1, other, out=None)：other张量的每个元素乘以一个标量值value，并加到input张量上；两个张量input和other的尺寸不需要匹配，但元素总数必须一样；当两个张量形状不匹配时，输入张量形状会作为输出张量的尺寸；

torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None)：用tensor2对tensor1逐元素相除，然后乘以标量值value并加到tensor；张量形状不需要匹配，但元素数量须一致，输入FloatTensor或DoubleTensor类型则value必须为实数，否则须为整数；

torch.addcmul(tensor, value=1, tensor1, tensor2, out=None)：用tensor2对tensor1逐元素相乘，然后乘以标量值value并加到tensor；张量形状不需要匹配，但元素数量须一致，输入FloatTensor或DoubleTensor类型则value必须为实数，否则须为整数；

torch.asin(input, out=None)：返回一个新张量，包含输入input张量每个元素的反正弦函数；

torch.atan(input, out=None)：返回一个新张量，包含输入input张量每个元素的反正切函数；

torch.atan2(input1, input2, out=None)：返回一个新张量，包含两个输入张量input1和input2的反正切函数；

torch.ceil(input, out=None)：对输入input张量每个元素向上取整，即取不小于每个元素的最小整数并返回结果到输出；

torch.clamp(input, min, max, out=None)：将输入input张量每个元素转化到\[min, max\]区间，并返回结果到一个新张量；

torch.clamp(input, \*, min, out=None)：将输入input张量每个元素限制到不小于min，并返回结果到一个新张量；

torch.clamp(input, \*, max, out=None)：将输入input张量每个元素限制到不大于max，并返回结果到一个新张量；

torch.cos(input, out=None)：返回一个新张量，包含输入input张量每个元素的余弦；

torch.cosh(input, out=None)：返回一个新张量，包含输入input张量每个元素的双曲余弦；

torch.div(input, value, out=None)：将input逐元素除以标量值value，并返回结果到输出张量out；

torch.exp(tensor, out=None)：返回一个新张量，包含输入input张量每个元素的指数；

torch.floor(input, out=None)：返回一个新张量，包含输入input张量每个元素的floor，即不小于元素的最大整数；

torch.fmod(input, divisor, out=None)：计算除法余数，除数和被除数可能同时含整数和浮点数，余数正负和被除数相同；

torch.frac(tensor, out=None)：返回每个元素的分数部分；

torch.lerp(start, end, weight, out=None)：对两个张量以start，end做线性插值，将结果返回到输出张量；out=start+weight\*(end-start)；

torch.log(input, out=None)：计算input的自然对数；

torch.log1p(input, out=None)：计算input+1的自然对数，y=log(x+1)；

torch.mul(input, value, out=None)：用标量值value乘以输入input的每个元素，并返回一个新的结果向量，out=tensor\*value；

torch.mul(input, other, out=None)：两个张量input，other按元素进行相乘，并返回到输出张量，out=input\*other;

torch.neg(input, out=None)：返回一个新张量，包含输入input张量按元素取负；

torch.pow(input, exponent, out=None)：对输入input按元素求exponent次幂值，并返回结果张量；幂值exponent可以为单一float数或与input相同元素数的张量；

torch.pow(base, input, out=None)：base为标量浮点值，input为张量，返回输出张量out与输入张量相同形状；

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.sin(input, out=None)：返回一个新张量，包含输入input张量每个元素的正弦；

torch.sinh(input, out=None)：返回一个新张量，包含输入input张量每个元素的双曲正弦；

torch.sqrt(input, out=None)：返回一个新张量，包含输入input张量每个元素的平方根；

torch.tan(input, out=None)：返回一个新张量，包含输入input张量每个元素的正切；

torch.tanh(input, out=None)：返回一个新张量，包含输入input张量每个元素的双曲正切；

torch.trunc(input, out=None)：返回一个新张量，包含输入input张量每个元素的额截断值(标量x的截断值是最接近其的整数，其比x更接近零，有符号数的小数部分被舍弃)；

(2)Reduction Ops

torch.cumprod(input, dim, out=None)：返回输入沿指定维度的累积积，如果输入是一个N元向量，第i个输出元素值为yi=x1\*x2\*...xi；

torch.cumsum(input, dim, out=None)：返回输入沿指定维度的累积和，dim为累积和操作的维度；

torch.dist(input, other, p=2, out=None)：返回(input-other)的p范数；

torch.mean(input)：返回输入张量所有元素的均值；

torch.mean(input, dim, out=None)：返回输入张量给定维度dim上每行的均值；

torch.median(input, dim=-1, values=None, indices=None)：返回输入张量给定维度每行的中位数，同时返回一个包含中位数的索引的LongTensor；dim默认为输入张量的最后一维，indices返回的索引结果张量；函数还未在torch.cuda.Tensor中定义；

torch.mode(input, dim=-1, values=None, indices=None)：返回给定维dim上每行的众数值；同时返回一个LongTensor，包含众数值的索引；

torch.norm(input, p=2)：返回输入张量input的p范数；

torch.norm(input, p, dim, out=None)：返回输入张量给定维dim上每行的p范数，dim表示缩减的维度；

torch.prod(input)：返回输入张量input所有元素的积；

torch.prod(input, dim, out=None)：返回输入张量给定维度上每行的积；

torch.std(input)：返回输入张量input所有元素的标准差；

torch.std(input, dim, out=None)：返回输入张量给定维度上每行的标准差；

torch.sum(input)：返回输入张量input所有元素的和；

torch.sum(input, dim, out=None)：返回输入张量给定维度上每行的和，输出形状与输入相同，除了给定维度上为1；

torch.var(input)：返回输入张量所有元素的方差；

torch.var(input, dim, out=None)：返回输入张量给定维度上每行的方差，输出形状与输入相同，除了给定维度上为1；

9.比较操作 Comparison Ops

torch.eq(input, other, out=None)：比较元素相等性，第二个参数可为一个数或第一个参数同类型形状的张量，返回值为一个torch.ByteTensor张量；

torch.equal(tensor1, tensor2)：如果两个张量有相同形状和元素值，则返回True；

torch.ge(input, other, out=None)：逐元素比较input和other，即是否input>=other；

torch.gt(input, other, out=None)：逐元素比较input和other，即是否input>other，第二个参数可为一个数或与第一个参数相同形状和类型的张量；

torch.kthvalue(input, k, dim=None, out=None)：取输入张量input指定维上第k个最小值，默认为input的最后一维；返回一个元组(values, indices)，indices是原始输入张量input中沿dim维的第k个最小值下标；

torch.le(input, other, out=None)：逐元素比较input和other，即是否input<=other；

torch.lt(input, other, out=None)：逐元素比较input和other，即是否input<other；

torch.max(input)：返回输入张量所有元素的最大值；

torch.max(input, dim, max=None, max\_indices=None)：返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引；输出形状中，将dim维设定为1，其它与输入形状保持一致；

torch.max(input, other, out=None)：返回输入张量给定维度上每行的最大值，并同时返回每个最大值的位置索引，out=max(input, other)；

torch.min(input)：返回输入张量所有元素的最小值；

torch.min(input, dim, min=None, min\_indices=None)：返回输入张量给定维度上每行的最小值，并同时返回每个最小值的位置索引；

torch.min(input, other, out=None)：input中逐元素与other相应位置的元素对比，返回最小值到输出张量，out=min(tensor, other)；两张量形状不需匹配，但元素数须相同，形状不匹配时，input形状作为返回张量的形状；

torch.ne(input, other, out=None)：逐元素比较input和other，即是否input!=other；

torch.sort(input, dim=None, descending=False, out=None)：对输入张量input沿指定维按升序排列；如果不给定dim，默认为输入的最后一维；如果指定参数descending为True，则按降序排序；

torch.topk(input, k, dim=None, largest=True, sorted=True, out=None)：沿给定dim维度返回输入张量input中k个最大值，如果largest为False，则返回最小的k个值；返回一个元组(values, indices)；如果设定sorted为\_\_True\_\_，将会确保返回的k个值被排序；

10.其它操作 Other Operations

torch.cross(input, other, dim=-1, out=None)：返回沿维度dim上，两个张量input和other的向量积(叉积)；input和other必须有相同形状，且指定dim维上size必须为3；

torch.diag(input, diagonal=0, out=None)：如果输入是一个向量，则返回一个以input为对角线元素的2D方阵；如果输入是一个矩阵，则返回一个包含input对角线元素的1D张量；diagonal指定对角线，=0主对角线，>0主对角线之上，<0主对角线之下；取得以input为对角线的方阵，取得给定矩阵第k个对角线；

torch.histc(input, bins=100, min=0, max=0, out=None)：计算输入张量的直方图，以min和max为range边界，将其均分成bins个直条，然后将排序好的数据划分到各个直条中；如果min和max都为0，利用数据中最大最小值为边界；

torch.renorm(input, p, dim, maxnorm, out=None)：返回一个张量，包含规范化后的各个子张量，使沿dim维划分的各子张量的p范数小于maxnorm；

torch.trace(input)：返回输入2维矩阵对角线元素的和(迹)；

torch.tril(input, k=0, out=None)：返回一个张量out，包含输入矩阵的下三角部分，其余部分被设为0；参数k控制对角线-k=0,主对角线-k>0,主对角线之上-k<0,主对角线之下；

torch.triu(input, k=0, out=None)：返回一个张量，包含输入矩阵的上三角部分；

11.BLAS and LAPACK Operations

torch.addbmm(beta=1, mat, alpha=1, batch1, batch2, out=None)：对batch1和batch2内存储的矩阵进行批矩阵乘操作，附带reduced add步骤，所有矩阵乘结果沿第一维相加；mat加到最终结果，batch1和batch2都为包含相同数量矩阵的3维张量；

torch.addmm(beta=1, mat, alpha=1, mat1, mat2, out=None)：对矩阵mat1和mat2进行矩阵乘操作，矩阵mat加到最终结果，alpha和beta分别为比例因子；

torch.addmv(beta=1, tensor, alpha=1, mat, vector, out=None)：对矩阵mat和向量vec进行相乘操作，向量tensor加到最终结果；

torch.addr(beta=1, mat, alpha=1, vec1, vec2, out=None)：对向量vec1和vec2进行张量积操作，矩阵mat加到最终结果；

torch.baddbmm(beta=1, mat, alpha=1, batch1, batch2, out=None)

torch.bmm(batch1, batch2, out=None)

torch.btrifact(A, info=None)：返回一个元组，包含LU分解和pivots，info决定是否对每个minibatch样本进行分解；

torch.btrisolve(b, LU\_data, LU\_pivots)：返回线性方程组Ax=b的LU解；

torch.dot(tensor1, tensor2)：计算两个张量的点乘(内乘)，两个张量都为1-D向量；

torch.eig(a, eigenvectors=False, out=None)：计算实方阵a的特征值和特征向量；

torch.gels(B, A, out=None)：对形如m\*n的满秩矩阵a计算其最小二乘和最小范数问题的解；如果m>=n, gels对最小二乘问题求解，minimize||AX-B||F；如果m<n，gels求解最小范数问题，minimize ||X||F subject to a bAX=B；

torch.geqrf(input, out=None)：直接调用LAPACK的底层函数，一般使用torch.qr()；计算输入的QR分解，但并不分别创建Q,R两个矩阵；

torch.ger(vec1, vec2, out=None)：计算两向量vec1, vec2的张量积，如果vec1长度为n，vec2长度为m，则输出out为形如n\*m的矩阵；

torch.gesv(B, A, out=None)：X, LU=torch.gesv(B, A)，返回线性方程组AX=B的解；

torch.inverse(input, out=None)：对方阵输入input取逆；

torch.mm(mat1, mat2, out=None)：对矩阵mat1和mat2进行相乘；

torch.mv(mat, vec, out=None)：对矩阵mat和向量vec进行相乘；

torch.orgqr()

torch.ormqr()

torch.potrf()

torch.potri()

torch.potrs()

torch.pstrf()

torch.qr(input, out=None)：计算输入矩阵的QR分解，返回两个矩阵q,r，使得x=q\*r，q是一个半正交矩阵，r是一个上三角矩阵；

torch.svd(input, some=True, out=None)：U,S,V=torch.svd(A)，返回对形如n\*m的实矩阵A进行奇异值分解的结果；some为布尔值控制需计算的奇异值数目；结果为tuple；

torch.symeig(input, eigenvectors=False, upper=True, out=None)：返回是对称矩阵input的特征值和特征向量；如果eigenvectors为False，只计算特征值，否则都计算；如果upper为False，下三角矩阵部分也被利用；

torch.trtrs()  
\---------------------   
作者：summer\_rain18   
来源：CSDN   
原文：https://blog.csdn.net/summer\_rain18/article/details/79887148   
版权声明：本文为博主原创文章，转载请附上博文链接！

\---------------------   
作者：summer\_rain18   
来源：CSDN   
原文：https://blog.csdn.net/summer\_rain18/article/details/79881844