pytorch那些事(2)

笔记小汇总，详情参照：https://pytorch-cn.readthedocs.io/zh/latest/package_references/torch/

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()