| Pytorch中Torch 工具包的数学操作汇总速查 torch package 包含了多维张量的数据结构, 以及基于其上的多种数学操作. 此外, 它还提供了许多用于高效序列化 Tensor 和任意类型的实用工具包, 以及一起其它有用的实用工具包. | |
|---|---|
| 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 中采集数据 |
| torch.set_flush_denormal(mode) | 为了防止一些不正常的元素产生，比如特别小的数，pytorch支持如下设置 |
| Creation Ops (创建操作) | |
| torch.from_numpy(ndarray) → Tensor | 从 numpy.ndarray 类 创建一个 Tensor 类 |
| torch.as_tensor(data, dtype=None, device=None) | |
| torch.eye(n, m=None, out=None) | 返回对角线位置全为1, 其它位置全为0的二维 tensor |
| torch.zeros(*sizes, out=None) → Tensor | 返回填充了标量值为 0 的 Tensor, 其形状由可变参量 sizes 定义 |
| torch.zeros_like(input, out=None) → Tensor | 返回一个用标量值 0 填充的 Tensor, 其大小与 input 相同. |
| torch.ones(*sizes, out=None) → Tensor | 返回填充了标量值 1 的 Tensor, 其形状由可变参数 sizes 定义 |
| torch.ones_like(input, out=None) → Tensor | 返回一个用标量值 1 填充的张量, 大小与 input 相同 |
| torch.empty() | |
| torch.empty_like() | |
| torch.full(size, fill_value, …) | 返回大小为sizes,单位值为fill_value的矩阵 |
| torch.full_like(input, fill_value, …) | 返回与input相同size，单位值为fill_value的矩阵 |
| 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.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. |
| 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.where(condition, x, y) | 按照条件从x和y中选出满足条件的元素组成新的tensor。 |
| 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.reshape(input, shape) | |
| torch.view | |
| 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 的整数的随机排列 |
| torch.rand(*sizes, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) | 生成[0，1）的随机数 |
| torch.rand_like(input, dtype=None, layout=None, device=None, requires_grad=False) | 按照输入的tensor的尺寸生成 |
| torch.randint(low=0, high, size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) | 在一个范围内生成整型的随机 |
| torch.randint_like(input, low=0, high, dtype=None, layout=torch.strided, device=None, requires_grad=False) | 不解释 |
| torch.randn(*sizes, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) | 返回01正太分布 |
| torch.randn_like(input, dtype=None, layout=None, device=None, requires_grad=False) | 不解释 |
| torch.randperm(n, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False) | 返回0到输入n的之间整数随机排列不含n |
| 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= | 将一个对象保存到一个磁盘文件中. |
| torch.load(f, map_location=None, pickle_module= | 从磁盘文件中加载一个用 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.unique(input, sorted=False, return_inverse=False) | 以1D向量保存张量中不同的元素。剔除tensor中的重复元素，如果设置return_inverse=True，会得到一个元素在在原tensor中的映射表 |
| 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 |
| torch.argmax(input, dim=None, keepdim=False) | 按指定的维度返回最大元素的坐标 |
| torch.argmin(input, dim=None, keepdim=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 个值被排序. |
| torch.isfinite(tensor) / torch.isinf(tensor) / torch.isnan(tensor) | 返回一个标记元素是否为 finite/inf/nan 的mask 张量。 |
| Other Operations (其它操作) | |
| torch.bincount(self, weights=None, minlength=0) | 返回每个值得频数。 |
| 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.flip(input, dims) | 按照给定维度翻转张量 |
| torch.histc(input, bins=100, min=0, max=0, out=None) → Tensor | 计算输入张量的直方图 |
| torch.meshgrid(seq) | 生成网格（可以生成坐标）。 |
| 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.det(A) | 返回矩阵A的行列式 |
| 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 的特征值和特征向量. |
文章知识点与官方知识档案匹配，可进一步学习相关知识
Python入门技能树人工智能深度学习416632 人正在系统学习中
评论记录：
回复评论：