PyTorch ：Torch 工具包的数学操作汇总速查

转载

bug404 2022-09-19 10:10:27 博主文章分类：Linux

文章标签 pytorch数学操作标量随机数正态分布 文章分类 PyTorch 人工智能

torch package 包含了多维张量的数据结构, 以及基于其上的多种数学操作. 此外, 它还提供了许多用于高效序列化 Tensor 和任意类型的实用工具包, 以及一起其它有用的实用工具包.

torch的操作方法汇总如下：

Tensors (张量)
torch.is_tensor(*obj*)	如果 obj 是一个 pytorch tensor, 则返回True.
torch.is_storage(*obj*)	如果 obj 是一个 pytorch storage object, 则返回True
torch.set_default_tensor_type(t)	设置默认类型
torch.numel(**input) → int**	返回 input Tensor 中的元素总数
torch.set_printoptions(*precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None*)	设置打印选项. 从 Numpy 中采集数据


Creation Ops (创建操作)
torch.eye(n, *m=None, out=None*)	返回对角线位置全为1, 其它位置全为0的二维 tensor
torch.from_numpy(**ndarray) → Tensor**	从 numpy.ndarray 类创建一个 Tensor 类
torch.linspace(*start, end, steps=100, *out=None) → Tensor**	返回 start 和 end 之间等间隔 steps 点的一维 Tensor.输出是尺寸 steps 为一维 tensor
torch.logspace(*start, end, steps=100, *out=None) → Tensor**	返回一个在 10^start和 10^end之间的对数间隔 steps 点的一维 Tensor，输出是长度为 steps 的一维 tensor
torch.ones(sizes, *out=None) → Tensor**	返回填充了标量值 1 的 Tensor, 其形状由可变参数 sizes 定义
torch.ones_like(*input, *out=None) → Tensor**	返回一个用标量值 1 填充的张量, 大小与 input 相同
torch.arange(*start=0, end, step=1, *out=None) → Tensor**	从 start 用步长为 step 开始, 间隔在 [start, end) 中的值返回大小层次为 floor((end−start)/step)floor((end−start)/step) 的一维 Tensor.
torch.range(*start, end, step=1, *out=None) → Tensor**	返回一个在 start 到 end 并且步长为 step 的区间内, 大小为 floor((end−start)/step)+1floor((end−start)/step)+1 为一维 Tensor.
torch.zeros(sizes, *out=None) → Tensor**	返回填充了标量值为 0 的 Tensor, 其形状由可变参量 sizes 定义
torch.zeros_like(*input, *out=None) → Tensor**	返回一个用标量值 0 填充的 Tensor, 其大小与 input 相同.



Indexing, Slicing, Joining, Mutating Ops (索引, 切片, 连接, 换位) 操作
*torch.cat(seq, dim=0, out=None) → Tensor*	在给定维度上对输入的张量序列 seq 进行连接操作. 所有张量必须具有相同的形状(在 cat 维度中除外) 或为空.
*torch.chunk(tensor, chunks, dim=0)*	在给定维度(轴)上将输入张量进行分块处理.
*torch.gather(input, dim, index, out=None) → Tensor*	沿给定轴 dim ,将输入索引张量 index 指定位置的值进行聚合.
*torch.index_select(input, dim, index, out=None) → Tensor*	沿着指定维度 dim 对输入进行切片,取 index 中指定的相应项 ( index 为一个 LongTensor ),然后返回到一个新的张量.返回的张量与原始张量 Tensor 有相同的维度(在指定轴上)
*torch.masked_select(input, mask, out=None) → Tensor*	根据掩码张量 mask 中的二元值,取输入张量中的指定项 ( mask 为一个 ByteTensor ),将取值返回到一个新的一维张量.张量 mask 与 input 的 shape 或维度不需要相同,但是他们必须是 broadcastable .
*torch.nonzero(input, out=None) → LongTensor*	返回一个包含输入 input 中非零元素索引的张量. 输出张量中的每行包含 input 中非零元素的索引.如果输入张量 input 有 n 维,则输出的索引张量 out 的 size 为 z x n , 这里 z 是输入张量 input 中所有非零元素的个数.
*torch.split(tensor, split_size, dim=0)*	将输入张量分割成相等 size 的 chunks (如果可分).如果沿指定维的张量形状大小不能被 split_size 整分, 则最后一个分块会小于其它分块
*torch.squeeze(input, dim=None, out=None)*	将 input 张量 size 中的 1 去除并返回.如果 input 的 shape 如 (Ax1xBxCx1xD)(Ax1xBxCx1xD) ,那么输出 shape 就为: (AxBxCxD)
*torch.stack(sequence, dim=0, out=None)*	沿着一个新维度对输入张量序列进行连接.序列中所有的张量都应该为相同 size .
*torch.t(input, out=None) → Tensor*	预期 input 为一个矩阵 (2 维张量), 并转置 0, 1 维.可以被视为函数 transpose(input, 0, 1) 的简写函数
*torch.take(input, indices) → Tensor*	在给定的索引处返回一个新的 Tensor ,其元素为 input . 输入张量被看作是一维张量.结果与索引具有相同的 shape
*torch.transpose(input, dim0, dim1, out=None) → Tensor*	返回输入矩阵 input 的转置.交换给定维度 dim0 和 dim1 .out 张量与 input 张量共享内存,所以改变其中一个会导致另外一个也被修改.
*torch.unbind(tensor, dim=0)*	移除一个张量的维度
*torch.unsqueeze(input, dim, out=None)*	返回在指定位置插入维度 size 为 1 的新张量.返回张量与输入张量共享内存,所以改变其中一个的内容会改变另一个.如果 dim 为负,则将会被转化 dim+input.dim()+1



Random sampling (随机采样)
*torch.manual_seed(seed)*	设置生成随机数的种子,并返回一个 torch._C.Generator 对象
torch.initial_seed()	返回用于生成随机数字的初始种子 (python long)
torch.get_rng_state()	以ByteTensor的形式返回随机数发生器的状态
*torch.set_rng_state(new_state)*	设置随机数发生器的参数
*torch.bernoulli(input, out=None) → Tensor*	从伯努利分布中抽取二进制随机数 (0 或 1)
*torch.multinomial(input, num_samples, replacement=False, out=None)→ LongTensor*	返回一个张量, 其中每一行包含在 input 张量对应行中多项式分布取样的 num_samples 索引
*torch.normal(means, std, out=None)*	返回一个随机数张量, 随机数从给定平均值和标准差的离散正态分布中抽取.
*torch.normal(mean=0.0, std, out=None)*	功能与上面函数类似, 但所有被抽取的元素共享均值
*torch.normal(means, std=1.0, out=None)*	功能与上面函数类似, 但所有被抽取的元素共享标准差
*torch.rand(sizes, out=None) → Tensor**	在区间 [0,1)[0,1) 中, 返回一个填充了均匀分布的随机数的张量.这个张量的形状由可变参数 sizes 来定义
*torch.randn(sizes, out=None) → Tensor**	返回一个从正态分布中填充随机数的张量, 其均值为 0 , 方差为 1 .这个张量的形状被可变参数 sizes 定义
*torch.randperm(n, out=None) → LongTensor*	返回一个从 0 to n - 1 的整数的随机排列
In-place random sampling (直接随机采样)
torch.Tensor.bernoulli_()	torch.bernoulli() 的 in-place 版本
torch.Tensor.cauchy_()	从柯西分布中抽取数字
torch.Tensor.exponential_()	从指数分布中抽取数字
torch.Tensor.geometric_()	从几何分布中抽取元素
torch.Tensor.log_normal_()	对数正态分布中的样本
torch.Tensor.normal_()	是 torch.normal() 的 in-place 版本
torch.Tensor.random_()	离散均匀分布中采样的数字
torch.Tensor.uniform_()	正态分布中采样的数字


Serialization (序列化)
*torch.save(obj, f, pickle_module=<module 'cPickle' from '/usr/lib64/python2.7/lib-dynload/cPickle.so'>, pickle_protocol=2)*	将一个对象保存到一个磁盘文件中.
*torch.load(f, map_location=None, pickle_module=<module 'cPickle' from '/usr/lib64/python2.7/lib-dynload/cPickle.so'>)*	从磁盘文件中加载一个用 torch.save() 保存的对象.


Parallelism (并行化)
torch.get_num_threads() → int	获得 OpenMP 并行化操作的线程数目
*torch.set_num_threads(int)*	设置 OpenMP 并行化操作的线程数目


Math operations (数学操作)
Pointwise Ops (逐点操作)
*torch.abs(input, out=None) → Tensor*	计算给定 input 张量的元素的绝对值
*torch.acos(input, out=None) → Tensor*	用 input 元素的反余弦返回一个新的张量
*torch.add(input, value, out=None)*	将标量值 value 添加到输入张量 attr:input 的每个元素并返回一个新的结果张量
*torch.add(input, value=1, other, out=None)*	张量 other 的每个元素乘以标量值 value 并加到张量 input 上, 返回生成的张量 out
*torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) → Tensor*	将张量 tensor1 逐元素除以张量 tensor2, 然后乘以标量值 value 并加到张量 tensor 上.
*torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) → Tensor*	将张量 tensor1 逐元素与张量 tensor2 相乘, 然后乘以标量值 value 并加到张量 tensor 上.
*torch.asin(input, out=None) → Tensor*	返回一个新的 Tensor , 其元素为张量 input 的每个元素的反正弦
*torch.atan(input, out=None) → Tensor*	返回一个新的 Tensor , 其元素为张量 input 的每个元素的反正切
*torch.atan2(input1, input2, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是输入张量 input1 和输入张量 input2 元素的反正切.
*torch.ceil(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 的元素向上取整(取不小于每个元素的最小整数).
*torch.clamp(input, min, max, out=None) → Tensor*	将输入张量 input 所有元素限制在区间 [min, max] 中并返回一个结果张量
*torch.clamp(input, , min, out=None) → Tensor**	张量 input 的所有元素值大于或者等于 min
*torch.clamp(input, , max, out=None) → Tensor**	张量 input 的所有元素值小于或者等于 max.
*torch.cos(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 每个元素的余弦
*torch.cosh(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 每个元素的双曲余弦
*torch.div(input, value, out=None)*	将张量 input 的元素逐一除以标量值 value , 其结果作为一个新的张量返回.
*torch.div(input, other, out=None)*	张量 input 的元素与张量 other 的元素逐一相除. 返回一个新的结果张量 out . 张量 input 与张量 other 的形状必须可 broadcastable.outi=inputi/otheri
*torch.erf(tensor, out=None) → Tensor*	计算每个元素的误差函数
*torch.erfinv(tensor, out=None) → Tensor*	计算每个元素的反向误差函数
*torch.exp(tensor, out=None) → Tensor*	计算每个元素的指数
*torch.floor(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 的元素向下取整(取不大于每个元素的最大整数).
*torch.fmod(input, divisor, out=None) → Tensor*	计算除法余数.
*torch.frac(tensor, out=None) → Tensor*	计算张量 tensor 每个元素的分数部分.
*torch.lerp(start, end, weight, out=None)*	基于标量值 weight: , 在张量 start 与张量 end 之间做线性插值并返回结果张量 out 。outi=starti+weight∗(endi−starti)
*torch.log(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 所有元素的自然对数.
*torch.log1p(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是(1 + input) 的自然对数.yi=log(xi+1)
*torch.mul(input, value, out=None)*	将输入张量 input 的每个元素与标量值 value 相乘并返回一个新的结果张量.out=tensor∗value
*torch.mul(input, other, out=None)*	张量 input 的元素与张量 other 的元素逐一相乘. 其结果作为一个新的张量返回.
*torch.neg(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 的元素的负值.out=−1∗input
*torch.pow(input, exponent, out=None)*	对输入张量 input 按元素求 exponent 次幂值并返回结果张量(其值作为结果张量的元素).
*torch.pow(base, input, out=None)*	base 是一个标量浮点值, input 是一个张量. 返回的张量 out 的形状与张量 input 的形状相同.
*torch.reciprocal(input, out=None) → Tensor*	返回一个新的 Tensor , 其元素是张量 input 元素的倒数, i.e. 1.0/x
*torch.remainder(input, divisor, out=None) → Tensor*	计算元素的除法的余数.
*torch.round(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是输入张量的元素四舍五入到最近的整数
*torch.rsqrt(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 元素的平方根的倒数.
*torch.sigmoid(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 元素的sigmoid值
*torch.sign(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 元素的符号.
*torch.sin(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 元素的正弦.
*torch.sinh(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 元素的双曲正弦
*torch.sqrt(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 元素的平方根
*torch.tan(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 元素的正切
*torch.tanh(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 元素的双曲正切
*torch.trunc(input, out=None) → Tensor*	返回一个新的张量 Tensor , 其元素是张量 input 元素的截断整数值 (直接去除小数部分) .
Reduction Ops (归约操作)
*torch.cumprod(input, dim, out=None) → Tensor*	返回元素 input 在给定维度 dim 下的累积积
*torch.cumsum(input, dim, out=None) → Tensor*	返回元素 input 在给定维度 dim 下的累积和
*torch.dist(input, other, p=2) → float*	返回(input - other)的p-范数 input 和 other 的形状必须满足 broadcastable.
*torch.mean(input) → float*	返回张量 input 所有元素的均值.
*torch.mean(input, dim, keepdim=False, out=None) → Tensor*	返回张量 input 在给定维度 dim 上每行的均值
*torch.median(input) → float*	返回输出张量 input 所有元素的中位数.
*torch.median(input, dim=-1, keepdim=False, values=None, indices=None) -> (Tensor, LongTensor)*	返回输出张量 input 在给定维度 dim 下每行的中位数. 同时返回一个包含中位数的索引 LongTensor.
*torch.mode(input, dim=-1, keepdim=False, values=None, indices=None) -> (Tensor, LongTensor)*	返回输入张量 input 在给定维数 dim 下每行元素的众数值. 同时也返回众数值的索引 LongTensor.
*torch.norm(input, p=2) → float*	返回输入张量 input 的p-范数
*torch.norm(input, p, dim, keepdim=False, out=None) → Tensor*	返回输入张量 input 在给定维度 dim 下每行元素的p-范数.
*torch.prod(input) → float*	返回输入张量 input 所有元素的乘积.
*torch.prod(input, dim, keepdim=False, out=None) → Tensor*	返回输入张量 input 在给定维度 dim 下每行元素的积.
*torch.std(input, unbiased=True) → float*	返回输入张量 input 所有元素的标准差
*torch.std(input, dim, keepdim=False, unbiased=True, out=None) → Tensor*	返回输入张量 input 在给定维度 dim 下每行元素的标准差
*torch.sum(input) → float*	返回输入张量 input 所有元素的和
*torch.sum(input, dim, keepdim=False, out=None) → Tensor*	返回输入张量 input 在给定维度 dim 下每行元素的和
*torch.var(input, unbiased=True) → float*	返回输入张量 input 的方差.
*torch.var(input, dim, keepdim=False, unbiased=True, out=None) → Tensor*	返回输入张量 input 在给定维度 dim 下每行的方差
Comparison Ops (比较操作)
*torch.eq(input, other, out=None) → Tensor*	比较元素是否相等
*torch.equal(tensor1, tensor2) → bool*	如果两个张量有相同的形状和元素值, 则返回 True , 否则 False .
*torch.ge(input, other, out=None) → Tensor*	逐元素比较 input 和 other , 即是否 input>=other .
*torch.gt(input, other, out=None) → Tensor*	逐元素比较 input 和 other , 即是否 input>other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False
*torch.kthvalue(input, k, dim=None, keepdim=False, out=None) -> (Tensor, LongTensor)*	取输入张量 input 指定维上第 k 个最小值. 如果不指定 dim , 则默认为 input 的最后一维
*torch.le(input, other, out=None) → Tensor*	逐元素比较 input 和 other , 即是否 input<=other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False .
*torch.lt(input, other, out=None) → Tensor*	逐元素比较 input 和 other , 即是否 input<other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False
*torch.max(input) → float*	返回输入 input 张量所有元素的最大值
*torch.max(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)*	返回输入张量 input 在给定维度 dim 上每行的最大值, 并同时返回每个最大值的位置索引.
*torch.max(input, other, out=None) → Tensor*	输入 input 每一个元素和对应的比较张量 other 进行比较, 留下较大的元素 max.
*torch.min(input) → float*	返回输入张量 input 所有元素的最小值
*torch.min(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)*	返回输入张量 input 在给定维度 dim 下每行元素的最小值. 其中第二个返回值是每个被找出的最小值的索引位置 ( argmin )
*torch.min(input, other, out=None) → Tensor*	输入 input 每一个元素和对应的比较张量 other 进行比较, 留下较小的元素 min .
*torch.ne(input, other, out=None) → Tensor*	逐元素比较 input 和 other , 即是否 tensor != other 如果两个张量有相同的形状和元素值, 则返回 True , 否则 False .
*torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor)*	对输入张量 input 沿着指定维按升序排序.
*torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)*	沿给定 dim 维度返回输入张量 input 中 k 个最大值. 如果不指定 dim , 则默认为 input 的最后一维. 如果为 largest 为 False ,则返回最小的 k 个值. 返回一个元组 (values, indices) , 其中 indices 是原始输入张量 input 中测元素下标. 如果设定布尔值 sorted 为 True , 将会确保返回的 k 个值被排序.
Other Operations (其它操作)
*torch.cross(input, other, dim=-1, out=None) → Tensor*	返回沿着维度 dim 上, 两个张量 input 和 other 的向量积 (叉积), input 和 other 必须有相同的形状, 且指定的 dim 维上 size 必须为 3.
*torch.diag(input, diagonal=0, out=None) → Tensor*	如果输入是一个向量( 1D 张量), 则返回一个以 input 为对角线元素的 2D 方阵.如果输入是一个矩阵( 2D 张量), 则返回一个包含 input 对角线元素的1D张量.
*torch.histc(input, bins=100, min=0, max=0, out=None) → Tensor*	计算输入张量的直方图
*torch.renorm(input, p, dim, maxnorm, out=None) → Tensor*	返回一个张量, 包含规范化后的各个子张量, 使得沿着 dim 维划分的各子张量的 p 范数小于 maxnorm
*torch.trace(input) → float*	返回输入 2 维矩阵对角线元素的和(迹).
*torch.tril(input, diagonal=0, out=None) → Tensor*	返回一个张量, 包含输入矩阵 ( 2D 张量)的下三角部分, 其余部分被设为 0.
*torch.triu(input, diagonal=0, out=None) → Tensor*	返回一个张量, 包含输入矩阵 ( 2D 张量)的上三角部分, 其余部分被设为 0.



BLAS and LAPACK Operations (BLAS和LAPACK操作)
*torch.addbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor*	执行保存在 batch1 和 batch2 中的矩阵的批量点乘, 伴随着一个减少的相加步骤 (所有的矩阵乘法沿第一维累加). mat 被相加到最终的结果中.
*torch.addmm(beta=1, mat, alpha=1, mat1, mat2, out=None) → Tensor*	执行矩阵 mat1 和 mat2 的相乘. 矩阵 mat 将与相乘的最终计算结果相加.
*torch.addmv(beta=1, tensor, alpha=1, mat, vec, out=None) → Tensor*	执行矩阵 mat 和向量 vec 的相乘. 矩阵 tensor 将与相乘的最终计算结果相加.
*torch.addr(beta=1, mat, alpha=1, vec1, vec2, out=None) → Tensor*	执行向量:attr:vec1 和 vec2 的外积, 并把外积计算结果与矩阵 mat相加
*torch.baddbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor*	执行保存在 batch1 和 batch2 中的矩阵的批量点乘. mat 被相加到最终的结果中.
*torch.bmm(batch1, batch2, out=None) → Tensor*	执行保存在 batch1 和 batch2 中的矩阵的批量点乘.
*torch.btrifact(A, info=None, pivot=True) → Tensor, IntTensor*	批量 LU 分解.
*torch.btrisolve(b, LU_data, LU_pivots) → Tensor*	批量 LU 解.返回线性系统 Ax = b 的 LU 解
*torch.dot(tensor1, tensor2) → float*	计算两个张量的点乘 (内积).
*torch.eig(a, eigenvectors=False, out=None) -> (Tensor, Tensor)*	计算实数方阵的特征值和特征向量.
*torch.gels(B, A, out=None) → Tensor*	计算秩为 mm 的，大小为 m x n 的矩阵 AA 最小二乘和最小范数问题的解
*torch.geqrf(input, out=None) -> (Tensor, Tensor)*	直接调用 LAPACK 的低层函数
*torch.ger(vec1, vec2, out=None) → Tensor*	计算 vec1 和 vec2 的外积. 如果 vec1 是一个长度为 n 的向量, vec2 是一个长度为 m 的向量, 那么 out 必须是一个 n x m 的矩阵
*torch.gesv(B, A, out=None) -> (Tensor, Tensor)*	X, LU = torch.gesv(B, A) , 该函数返回线性系统 AX=B 的解
*torch.inverse(input, out=None) → Tensor*	计算方阵 input 的逆.
*torch.matmul(tensor1, tensor2, out=None)*	Matrix product of two tensors
*torch.mm(mat1, mat2, out=None) → Tensor*	执行 mat1 和 mat2 的矩阵乘法.
*torch.mv(mat, vec, out=None) → Tensor*	执行矩阵 mat 与向量 vec 的乘法操作.
*torch.potrf(a, out=None)*	计算半正定矩阵 a: 的 Cholesky 分解
*torch.potri(u, out=None)*	给定一个半正定矩阵的 Cholesky 分解因子 u, 计算该半正定矩阵的逆.
*torch.potrs(b, u, out=None)*	Solves a linear system of equations with a positive semidefinite matrix to be inverted given its given a Cholesky factor matrix u
*torch.pstrf(a, out=None)*	Computes the pivoted Cholesky decomposition of a positive semidefinite matrix a: returns matrices u and piv
*torch.qr(input, out=None) -> (Tensor, Tensor)*	计算矩阵 input 的 QR 分解. 返回矩阵 q 和 r 使得 x=q∗rx=q∗r, 且 q 是一个正交矩阵, r 是一个上三角矩阵
*torch.svd(input, some=True, out=None) -> (Tensor, Tensor, Tensor)*	U, S, V = torch.svd(A) 返回大小为 (n x m) 的实矩阵 A 的奇异值分解, 使得 A=USV′∗
*torch.symeig(input, eigenvectors=False, upper=True, out=None) -> (Tensor, Tensor)*	e, V = torch.symeig(input) 返回实对称矩阵 input 的特征值和特征向量.