torch

译者：@那伊抹微笑、@yudong、@小瑶、@片刻、@李雨龙、@K @devin、@张假飞、@rickllyxu

校对者：@张假飞、@飞龙

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

它有一个 CUDA 的对应实现, 它使您能够在计算能力 >=0.3 的 NVIDIA GPU 上进行张量运算.

Tensors (张量)

  1. torch.is_tensor(obj)

如果 obj 是一个 pytorch tensor, 则返回True.

参数：obj (Object) – 用于测试的对象

  1. torch.is_storage(obj)

如果 obj 是一个 pytorch storage object, 则返回True.

参数：obj (Object) – 用于测试的对象

  1. torch.set_default_tensor_type(t)
  1. torch.numel(input) → int

返回 input Tensor 中的元素总数.

参数：input (Tensor) – 输入的 Tensor

示例：

  1. >>> a = torch.randn(1,2,3,4,5)
  2. >>> torch.numel(a)
  3. 120
  4. >>> a = torch.zeros(4,4)
  5. >>> torch.numel(a)
  6. 16
  1. torch.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None)

设置打印选项. 从 Numpy 中采集数据

参数：

  • precision – 浮点输出精度的位数 (默认值为 8).
  • threshold – 触发汇总显示而不是完全显示(repr)的数组元素的总数 (默认值为 1000).
  • edgeitems – 每个维度开始和结束时总结的数组项数 (默认值为 3).
  • linewidth – 插入换行符的每行字符数 (默认值为 80). Thresholded matricies(阈值矩阵) 将忽略这个参数.
  • profile – 用于漂亮格式的打印. 可以用以下任何选项来进行覆盖 (default, short, full)

Creation Ops (创建操作)

  1. torch.eye(n, m=None, out=None)

返回对角线位置全为1, 其它位置全为0的二维 tensor.

参数：

  • n (int) – 行数
  • m (int, 可选) – 列数. 如果为 None,则默认为 n
  • out (Tensor, 可选) – 输出 tensor

返回值：一个对角线位置全为1, 其它位置全为0的二维 tensor.

返回类型：Tensor

示例：

  1. >>> torch.eye(3)
  2.  1  0  0
  3.  0  1  0
  4.  0  0  1
  5. [torch.FloatTensor of size 3x3]
  1. torch.from_numpy(ndarray) → Tensor

从 numpy.ndarray 类 创建一个 Tensor 类.

返回 tensor 和 ndarray 共享相同的内存. 对 tensor 的修改将反映在 ndarray 中, 反之亦然. 返回 tensor 不可调整大小.

示例：

  1. >>> a = numpy.array([1, 2, 3])
  2. >>> t = torch.from_numpy(a)
  3. >>> t
  4. torch.LongTensor([1, 2, 3])
  5. >>> t[0] = -1
  6. >>> a
  7. array([-1,  2,  3])
  1. torch.linspace(start, end, steps=100, out=None) → Tensor

返回 start 和 end 之间等间隔 steps 点的一维 Tensor.

输出 是尺寸 steps 为一维 tensor

参数：

  • start (float) – 点集合的起始值
  • end (float) – 点集合的结束值
  • steps (int) – 在 start 和 end 之间的样本数
  • out (Tensor, 可选) – 输出结果的 Tensor

示例：

  1. >>> torch.linspace(3, 10, steps=5)
  3.  3.0000
  4.  4.7500
  5.  6.5000
  6.  8.2500
  7.  10.0000
  8. [torch.FloatTensor of size 5]
  10. >>> torch.linspace(-10, 10, steps=5)
  12. -10
  13.  -5
  14.  0
  15.  5
  16.  10
  17. [torch.FloatTensor of size 5]
  19. >>> torch.linspace(start=-10, end=10, steps=5)
  21. -10
  22.  -5
  23.  0
  24.  5
  25.  10
  26. [torch.FloatTensor of size 5]
  1. torch.logspace(start, end, steps=100, out=None) → Tensor

返回一个在 10^{start} 和 10^{end} 之间的对数间隔 steps 点的一维 Tensor

输出是长度为 steps 的一维 tensor

参数：

  • start (float) – 点集合的起始值
  • end (float) – 点集合的结束值
  • steps (int) – 在 start 和 end 之间的样本数
  • out (Tensor, 可选) – 输出结果Tensor

示例：

  1. >>> torch.logspace(start=-10, end=10, steps=5)
  3.  1.0000e-10
  4.  1.0000e-05
  5.  1.0000e+00
  6.  1.0000e+05
  7.  1.0000e+10
  8. [torch.FloatTensor of size 5]
  10. >>> torch.logspace(start=0.1, end=1.0, steps=5)
  12.  1.2589
  13.  2.1135
  14.  3.5481
  15.  5.9566
  16.  10.0000
  17. [torch.FloatTensor of size 5]
  1. torch.ones(*sizes, out=None) → Tensor

返回填充了标量值 1 的 Tensor, 其形状由可变参数 sizes 定义.

参数：

  • sizes (int...) – 一组定义输出 Tensor 形状的整数
  • out (Tensor, 可选) – 输出结果 Tensor

示例：

  1. >>> torch.ones(2, 3)
  3.  1  1  1
  4.  1  1  1
  5. [torch.FloatTensor of size 2x3]
  7. >>> torch.ones(5)
  9.  1
  10.  1
  11.  1
  12.  1
  13.  1
  14. [torch.FloatTensor of size 5]
  1. torch.ones_like(input, out=None) → Tensor

返回一个用标量值 1 填充的张量, 大小与 input 相同.

参数：

  • input (Tensor) – 输入的大小将决定输出的大小.
  • out (Tensor, 可选) – 输出结果 Tensor

示例：

  1. >>> input = torch.FloatTensor(2, 3)
  2. >>> torch.ones_like(input)
  4.  1  1  1
  5.  1  1  1
  6. [torch.FloatTensor of size 2x3]
  1. torch.arange(start=0, end, step=1, out=None) → Tensor

从 start 用步长为 step 开始, 间隔在 [start, end) 中的值返回大小层次为 floor((end - start) / step) 的一维 Tensor.

参数：

  • start (float) – 点集合的起始值
  • end (float) – 点集合的结束值
  • step (float) – 每对相邻点之间的间隔
  • out (Tensor, 可选) – 输出结果 Tensor

示例：

  1. >>> torch.arange(5)
  3.  0
  4.  1
  5.  2
  6.  3
  7.  4
  8. [torch.FloatTensor of size 5]
  10. >>> torch.arange(1, 4)
  12.  1
  13.  2
  14.  3
  15. [torch.FloatTensor of size 3]
  17. >>> torch.arange(1, 2.5, 0.5)
  19.  1.0000
  20.  1.5000
  21.  2.0000
  22. [torch.FloatTensor of size 3]
  1. torch.range(start, end, step=1, out=None) → Tensor

返回一个在 start 到 end 并且步长为 step 的区间内, 大小为 floor((end - start) / step) + 1 为一维 Tensor. step 是 tensor 中两个值之间的差距. x_{i+1} = x_i + step

警告：

此功能已被弃用, 以支持 torch.arange().

参数：

  • start (float) – 点集合的起始值
  • end (float) – 点集合的结束值
  • step (float) – 每对相邻点之间的间隔
  • out (Tensor, 可选) – 输出结果 Tensor

示例：

  1. >>> torch.range(1, 4)
  3.  1
  4.  2
  5.  3
  6.  4
  7. [torch.FloatTensor of size 4]
  9. >>> torch.range(1, 4, 0.5)
  11.  1.0000
  12.  1.5000
  13.  2.0000
  14.  2.5000
  15.  3.0000
  16.  3.5000
  17.  4.0000
  18. [torch.FloatTensor of size 7]
  1. torch.zeros(*sizes, out=None) → Tensor

返回填充了标量值为 0 的 Tensor, 其形状由可变参数 sizes 定义.

参数：

  • sizes (int...) – 定义输出 Tensor 形状的一组整数.
  • out (Tensor, 可选) – 输出结果 Tensor

示例：

  1. >>> torch.zeros(2, 3)
  3.  0  0  0
  4.  0  0  0
  5. [torch.FloatTensor of size 2x3]
  7. >>> torch.zeros(5)
  9.  0
  10.  0
  11.  0
  12.  0
  13.  0
  14. [torch.FloatTensor of size 5]
  1. torch.zeros_like(input, out=None) → Tensor

返回一个用标量值 0 填充的 Tensor, 其大小与 input 相同.

参数：

  • input (Tensor) – 输入的大小将决定输出的大小.
  • out (Tensor, 可选) – 输出结果 Tensor

示例：

  1. >>> input = torch.FloatTensor(2, 3)
  2. >>> torch.zeros_like(input)
  4.  0  0  0
  5.  0  0  0
  6. [torch.FloatTensor of size 2x3]

Indexing, Slicing, Joining, Mutating Ops (索引, 切片, 连接, 换位) 操作

  1. torch.cat(seq, dim=0, out=None) → Tensor

在给定维度上对输入的张量序列 seq 进行连接操作. 所有张量必须具有相同的形状(在 cat 维度中除外) 或为空.

torch.cat() 可以看做是 torch.split() 和 torch.chunk() 的逆操作.

cat() 可以通过下面的例子更好地理解.

参数：

  • seq (_sequence of Tensors_) – 可以是任何相同类型的 Tensor 的 Python 序列.
  • dim (int, 可选) – tensors 级联的维数
  • out (Tensor, 可选) – 输出参数

示例：

  1. >>> x = torch.randn(2, 3)
  2. >>> x
  4.  0.5983 -0.0341  2.4918
  5.  1.5981 -0.5265 -0.8735
  6. [torch.FloatTensor of size 2x3]
  8. >>> torch.cat((x, x, x), 0)
  10.  0.5983 -0.0341  2.4918
  11.  1.5981 -0.5265 -0.8735
  12.  0.5983 -0.0341  2.4918
  13.  1.5981 -0.5265 -0.8735
  14.  0.5983 -0.0341  2.4918
  15.  1.5981 -0.5265 -0.8735
  16. [torch.FloatTensor of size 6x3]
  18. >>> torch.cat((x, x, x), 1)
  20.  0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918
  21.  1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735
  22. [torch.FloatTensor of size 2x9]
  1. torch.chunk(tensor, chunks, dim=0)

在给定维度(轴)上将输入张量进行分块处理.

参数：

  • tensor (Tensor) – 待分块的输入张量.
  • chunks (int) – 要返回的分块的个数.
  • dim (int) – 切分张量所需要沿着的维度.
  1. torch.gather(input, dim, index, out=None) → Tensor

沿给定轴 dim ,将输入索引张量 index 指定位置的值进行聚合.

对一个 3 维张量,输出可以定义为:

  1. out[i][j][k] = input[index[i][j][k]][j][k]  # if dim == 0
  2. out[i][j][k] = input[i][index[i][j][k]][k]  # if dim == 1
  3. out[i][j][k] = input[i][j][index[i][j][k]]  # if dim == 2

如果 input 是 size 为 (x_0, x_1..., x_{i-1}, x_i, x_{i+1}, ..., x_{n-1}) 且 dim = i 的 n 维张量,则 index 必须是具有 size 为 (x_0, x_1, ..., x_{i-1}, y, x_{i+1}, ..., x_{n-1}) 的 n 维张量,其中 y >= 1 ,并且 out 将与 index 的 size 相同.

参数：

  • input (Tensor) – 源张量
  • dim (int) – 索引的轴
  • index (LongTensor) – 聚合元素的下标
  • out (Tensor, 可选) – 目标张量

示例：

  1. >>> t = torch.Tensor([[1,2],[3,4]])
  2. >>> torch.gather(t, 1, torch.LongTensor([[0,0],[1,0]]))
  3.  1  1
  4.  4  3
  5. [torch.FloatTensor of size 2x2]
  1. torch.index_select(input, dim, index, out=None) → Tensor

沿着指定维度 dim 对输入进行切片,取 index 中指定的相应项 ( index 为一个 LongTensor ),然后返回到一个新的张量.

返回的张量与原始张量 Tensor 有相同的维度(在指定轴上).

注解：

返回的张量不与原始张量共享内存空间.

参数：

  • input (Tensor) – 输入张量
  • dim (int) – 索引的轴
  • index (LongTensor) – 包含索引下标的一维张量
  • out (Tensor, 可选) – 输出参数/目标张量

示例：

  1. >>> x = torch.randn(3, 4)
  2. >>> x
  4.  1.2045  2.4084  0.4001  1.1372
  5.  0.5596  1.5677  0.6219 -0.7954
  6.  1.3635 -1.2313 -0.5414 -1.8478
  7. [torch.FloatTensor of size 3x4]
  9. >>> indices = torch.LongTensor([0, 2])
  10. >>> torch.index_select(x, 0, indices)
  12.  1.2045  2.4084  0.4001  1.1372
  13.  1.3635 -1.2313 -0.5414 -1.8478
  14. [torch.FloatTensor of size 2x4]
  16. >>> torch.index_select(x, 1, indices)
  18.  1.2045  0.4001
  19.  0.5596  0.6219
  20.  1.3635 -0.5414
  21. [torch.FloatTensor of size 3x2]
  1. torch.masked_select(input, mask, out=None) → Tensor

根据掩码张量 mask 中的二元值,取输入张量中的指定项 ( mask 为一个 ByteTensor ),将取值返回到一个新的一维张量.

张量 mask 与 input 的 shape 或维度不需要相同,但是他们必须是 broadcastable .

注解：

返回的张量不与原始张量共享内存空间.

参数：

  • input (Tensor) – 输入张量
  • mask (ByteTensor) – 掩码张量,包含了二元索引值
  • out (Tensor, 可选) – 输出参数/目标张量

示例：

  1. >>> x = torch.randn(3, 4)
  2. >>> x
  4.  1.2045  2.4084  0.4001  1.1372
  5.  0.5596  1.5677  0.6219 -0.7954
  6.  1.3635 -1.2313 -0.5414 -1.8478
  7. [torch.FloatTensor of size 3x4]
  9. >>> mask = x.ge(0.5)
  10. >>> mask
  12.  1  1  0  1
  13.  1  1  1  0
  14.  1  0  0  0
  15. [torch.ByteTensor of size 3x4]
  17. >>> torch.masked_select(x, mask)
  19.  1.2045
  20.  2.4084
  21.  1.1372
  22.  0.5596
  23.  1.5677
  24.  0.6219
  25.  1.3635
  26. [torch.FloatTensor of size 7]
  1. torch.nonzero(input, out=None) → LongTensor

返回一个包含输入 input 中非零元素索引的张量. 输出张量中的每行包含 input 中非零元素的索引.

如果输入张量 input 有 n 维,则输出的索引张量 out 的 size 为 z x n , 这里 z 是输入张量 input 中所有非零元素的个数.

参数：

  • input (Tensor) – 输入张量/源张量
  • out (LongTensor, 可选) – 包含索引值的输出张量

示例：

  1. >>> torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))
  3.  0
  4.  1
  5.  2
  6.  4
  7. [torch.LongTensor of size 4x1]
  9. >>> torch.nonzero(torch.Tensor([[0.6, 0.0, 0.0, 0.0],
  10. ...                             [0.0, 0.4, 0.0, 0.0],
  11. ...                             [0.0, 0.0, 1.2, 0.0],
  12. ...                             [0.0, 0.0, 0.0,-0.4]]))
  14.  0  0
  15.  1  1
  16.  2  2
  17.  3  3
  18. [torch.LongTensor of size 4x2]
  1. torch.split(tensor, split_size, dim=0)

将输入张量分割成相等 size 的 chunks (如果可分).

如果沿指定维的张量形状大小不能被 split_size 整分, 则最后一个分块会小于其它分块.

参数：

  • tensor (Tensor) – 待分割张量.
  • split_size (int) – 单个分块的 size 大小.
  • dim (int) – 沿着此维进行分割.
  1. torch.squeeze(input, dim=None, out=None)

将 input 张量 size 中的 1 去除并返回.

如果 input 的 shape 如 (A x 1 x B x C x 1 x D) ,那么输出 shape 就为: (A x B x C x D)

当给定 dim 时,那么挤压操作只在给定维度上.例如, input 的 shape 为: (A x 1 x B) , squeeze(input, 0) 将会保持张量不变,只有用 squeeze(input, 1) , shape 会变成 (A x B) .

注解：

作为上述的一个例外,size 为 1 的一维张量不会改变维度.

注解：

返回张量与输入张量共享内存,所以改变其中一个的内容会改变另一个.

参数：

  • input (Tensor) – 输入张量
  • dim (int, 可选) – 如果给定 dim 时,则 input 只会在给定维度执行挤压
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> x = torch.zeros(2,1,2,1,2)
  2. >>> x.size()
  3. (2L, 1L, 2L, 1L, 2L)
  4. >>> y = torch.squeeze(x)
  5. >>> y.size()
  6. (2L, 2L, 2L)
  7. >>> y = torch.squeeze(x, 0)
  8. >>> y.size()
  9. (2L, 1L, 2L, 1L, 2L)
  10. >>> y = torch.squeeze(x, 1)
  11. >>> y.size()
  12. (2L, 2L, 1L, 2L)
  1. torch.stack(sequence, dim=0, out=None)

沿着一个新维度对输入张量序列进行连接.

序列中所有的张量都应该为相同 size .

参数：

  • sequence (_Sequence_) – 待连接的张量序列.
  • dim (int) – 插入的维度.必须介于 0 与待连接的张量序列数(包含）之间.
  1. torch.t(input, out=None) → Tensor

预期 input 为一个矩阵 (2 维张量), 并转置 0, 1 维.

可以被视为函数 transpose(input, 0, 1) 的简写函数.

参数：

  • input (Tensor) – 输入张量
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> x = torch.randn(2, 3)
  2. >>> x
  4.  0.4834  0.6907  1.3417
  5. -0.1300  0.5295  0.2321
  6. [torch.FloatTensor of size 2x3]
  8. >>> torch.t(x)
  10.  0.4834 -0.1300
  11.  0.6907  0.5295
  12.  1.3417  0.2321
  13. [torch.FloatTensor of size 3x2]
  1. torch.take(input, indices) → Tensor

在给定的索引处返回一个新的 Tensor ,其元素为 input . 输入张量被看作是一维张量.结果与索引具有相同的 shape .

参数：

  • input (Tensor) – 输入张量
  • indices (LongTensor) – 进入 Tensor 的索引

示例：

  1. >>> src = torch.Tensor([[4, 3, 5],
  2. ...                     [6, 7, 8]])
  3. >>> torch.take(src, torch.LongTensor([0, 2, 5]))
  4.  4
  5.  5
  6.  8
  7. [torch.FloatTensor of size 3]
  1. torch.transpose(input, dim0, dim1, out=None) → Tensor

返回输入矩阵 input 的转置.交换给定维度 dim0 和 dim1 .

out 张量与 input 张量共享内存,所以改变其中一个会导致另外一个也被修改.

参数：

  • input (Tensor) – 输入张量
  • dim0 (int) – 转置的第一个维度
  • dim1 (int) – 转置的第二个维度

示例：

  1. >>> x = torch.randn(2, 3)
  2. >>> x
  4.  0.5983 -0.0341  2.4918
  5.  1.5981 -0.5265 -0.8735
  6. [torch.FloatTensor of size 2x3]
  8. >>> torch.transpose(x, 0, 1)
  10.  0.5983  1.5981
  11. -0.0341 -0.5265
  12.  2.4918 -0.8735
  13. [torch.FloatTensor of size 3x2]
  1. torch.unbind(tensor, dim=0)

移除一个张量的维度.

移除指定维后,返回一个元组,包含了沿着指定维切片后的各个切片 (已经没有了移除的维度).

参数：

  • tensor (Tensor) – 要执行 unbind 的张量/输入张量.
  • dim (int) – 要移除的维度.
  1. torch.unsqueeze(input, dim, out=None)

返回在指定位置插入维度 size 为 1 的新张量.

返回张量与输入张量共享内存,所以改变其中一个的内容会改变另一个.

如果 dim 为负,则将会被转化 dim + input.dim() + 1 .

参数：

  • input (Tensor) – 输入张量
  • dim (int) – 插入维度的索引
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> x = torch.Tensor([1, 2, 3, 4])
  2. >>> torch.unsqueeze(x, 0)
  3.  1  2  3  4
  4. [torch.FloatTensor of size 1x4]
  5. >>> torch.unsqueeze(x, 1)
  6.  1
  7.  2
  8.  3
  9.  4
  10. [torch.FloatTensor of size 4x1]

Random sampling (随机采样)

  1. torch.manual_seed(seed)

设置生成随机数的种子,并返回一个 torch._C.Generator 对象.

参数：seed (int 或 long) – 种子.

  1. torch.initial_seed()

返回用于生成随机数字的初始种子 (python long) .

  1. torch.get_rng_state()

以ByteTensor的形式返回随机数发生器的状态.

  1. torch.set_rng_state(new_state)

设置随机数发生器的参数.

参数：new_state (torch.ByteTensor) – 理想状态

torch.default_generator = <torch._C.Generator object at 0x28bcc10>

  1. torch.bernoulli(input, out=None) → Tensor

从伯努利分布中抽取二进制随机数 (0 或 1).

The input 张量包含用于抽取二进制随机数的概率. 因此, input 中的所有值必须在这个范围内: 0 <= input_i <= 1

根据 input 张量第 i 个概率值, 输出张量的第 i 个元素将取值为1.

返回的 out 张量的值只有 0 或者 1 并且大小与 input 张量相同.

参数：

  • input (Tensor) – 伯努利分布的概率值
  • out (Tensor, 可选) – 输出张量

示例：

  1. >>> a = torch.Tensor(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
  2. >>> a
  4.  0.7544  0.8140  0.9842
  5.  0.5282  0.0595  0.6445
  6.  0.1925  0.9553  0.9732
  7. [torch.FloatTensor of size 3x3]
  9. >>> torch.bernoulli(a)
  11.  1  1  1
  12.  0  0  1
  13.  0  1  1
  14. [torch.FloatTensor of size 3x3]
  16. >>> a = torch.ones(3, 3) # probability of drawing "1" is 1
  17. >>> torch.bernoulli(a)
  19.  1  1  1
  20.  1  1  1
  21.  1  1  1
  22. [torch.FloatTensor of size 3x3]
  24. >>> a = torch.zeros(3, 3) # probability of drawing "1" is 0
  25. >>> torch.bernoulli(a)
  27.  0  0  0
  28.  0  0  0
  29.  0  0  0
  30. [torch.FloatTensor of size 3x3]
  1. torch.multinomial(input, num_samples, replacement=False, out=None) → LongTensor

返回一个张量, 其中每一行包含在 input 张量对应行中多项式分布取样的 num_samples 索引.

注解：

input 的每行值不需要总和为 1 (我们只使用这些值作为权重), 但必须是非负且非零和的.

取样时从左向右排列(第一个样本在第一列).

如果 input 是一个向量, 则 out 是一个大小为 num_samples 的向量.

如果 input 是一个 m 行的矩阵, 则 out 是一个 m × n 的矩阵.

如果参数 replacement 是 True, 则可重复取样. 否则, 样本在每行不能被重复取样.

参数 num_samples 必须小于 input 长度 (如果是一个矩阵, 则是 input 的列数).

参数：

  • input (Tensor) – 包含概率值的张量
  • num_samples (int) – 抽取的样本数
  • replacement (bool, 可选) – 是否重复抽取样本
  • out (Tensor, 可选) – 输出 Tensor

示例：

  1. >>> weights = torch.Tensor([0, 10, 3, 0]) # create a Tensor of weights
  2. >>> torch.multinomial(weights, 4)
  4.  1
  5.  2
  6.  0
  7.  0
  8. [torch.LongTensor of size 4]
  10. >>> torch.multinomial(weights, 4, replacement=True)
  12.  1
  13.  2
  14.  1
  15.  2
  16. [torch.LongTensor of size 4]
  1. torch.normal()
  1. torch.normal(means, std, out=None)

返回一个随机数张量, 随机数从给定平均值和标准差的离散正态分布中抽取.

参数 means 是一个包含每个输出元素的正态分布均值的张量.

参数 std 是一个包含每个输出元素的正态分布标准差的张量.

其中 means 和 std 的形状不需要匹配, 但是每个张量中的元素总数需要相同.

注解：

当形状不匹配时, means 的形状将作为返回输出张量的形状.

参数：

  • means (Tensor) – 均值
  • std (Tensor) – 标准差
  • out (Tensor, 可选) – 输出张量

示例：

  1. torch.normal(means=torch.arange(1, 11), std=torch.arange(1, 0, -0.1))
  3.  1.5104
  4.  1.6955
  5.  2.4895
  6.  4.9185
  7.  4.9895
  8.  6.9155
  9.  7.3683
  10.  8.1836
  11.  8.7164
  12.  9.8916
  13. [torch.FloatTensor of size 10]
  1. torch.normal(mean=0.0, std, out=None)

功能与上面函数类似, 但所有被抽取的元素共享均值.

参数：

  • means (float, 可选) – 所有分布的均值
  • std (Tensor) – 每个元素标准差的张量
  • out (Tensor, 可选) – 输出张量

示例：

  1. >>> torch.normal(mean=0.5, std=torch.arange(1, 6))
  3.  0.5723
  4.  0.0871
  5.  -0.3783
  6.  -2.5689
  7.  10.7893
  8. [torch.FloatTensor of size 5]
  1. torch.normal(means, std=1.0, out=None)

功能与上面函数类似, 但所有被抽取的元素共享标准差.

参数：

  • means (Tensor) – 每个元素均值的张量
  • std (float, 可选) – 所有分布的标准差
  • out (Tensor, 可选) – 输出张量

示例：

  1. >>> torch.normal(means=torch.arange(1, 6))
  3.  1.1681
  4.  2.8884
  5.  3.7718
  6.  2.5616
  7.  4.2500
  8. [torch.FloatTensor of size 5]
  1. torch.rand(*sizes, out=None) → Tensor

在区间 ![0, 1) 中, 返回一个填充了均匀分布的随机数的张量.

这个张量的形状由可变参数 sizes 来定义.

参数：

  • sizes (int...) – 定义输出张量形状的整数集.
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> torch.rand(4)
  3.  0.9193
  4.  0.3347
  5.  0.3232
  6.  0.7715
  7. [torch.FloatTensor of size 4]
  9. >>> torch.rand(2, 3)
  11.  0.5010  0.5140  0.0719
  12.  0.1435  0.5636  0.0538
  13. [torch.FloatTensor of size 2x3]
  1. torch.randn(*sizes, out=None) → Tensor

返回一个从正态分布中填充随机数的张量, 其均值为 0 , 方差为 1 .

这个张量的形状被可变参数 sizes 定义.

参数：

  • sizes (int...) – 定义输出张量形状的整数集.
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> torch.randn(4)
  3. -0.1145
  4.  0.0094
  5. -1.1717
  6.  0.9846
  7. [torch.FloatTensor of size 4]
  9. >>> torch.randn(2, 3)
  11.  1.4339  0.3351 -1.0999
  12.  1.5458 -0.9643 -0.3558
  13. [torch.FloatTensor of size 2x3]
  1. torch.randperm(n, out=None) → LongTensor

返回一个从 0 to n - 1 的整数的随机排列.

参数：n (int) – 上限 (唯一的)

示例：

  1. >>> torch.randperm(4)
  3.  2
  4.  1
  5.  3
  6.  0
  7. [torch.LongTensor of size 4]

In-place random sampling (直接随机采样)

在Tensors模块上还定义了许多 in-place 随机采样函数,可以点击参考它们的文档:

Serialization (序列化)

  1. torch.save(obj, f, pickle_module=<module 'cPickle' from '/usr/lib64/python2.7/lib-dynload/cPickle.so'>, pickle_protocol=2)

将一个对象保存到一个磁盘文件中.

另见: 保存模型的推荐方法

参数: obj: 要保存的对象 f: 类文件对象 (必须实现返回文件描述符的 fileno 方法) 或包含文件名的字符串 pickle_module: 用于 pickling 元数据和对象的模块 pickle_protocol: 可以指定来覆盖默认协议

  1. torch.load(f, map_location=None, pickle_module=<module 'cPickle' from '/usr/lib64/python2.7/lib-dynload/cPickle.so'>)

从磁盘文件中加载一个用 torch.save() 保存的对象.

Func: torch.load 使用 Python 的解封 (unpickling) 设施, 但特殊对待张量下的存储 (storages).

它们首先在 CPU 上反序列化, 然后移动到所保存的设备上. 如果这个过程失败了 (例如, 因为运行时的系统没有确定的设备), 将会抛出异常. 然而, 使用 map_location 参数, 存储可以被动态地重新映射到另一组设备上.

如果 map_location 是可调用对象, 则对于每个序列化存储, 它都将以两个参数调用一次: storage 和 location. 参数 storage 是驻留在 CPU 上的存储的初始反序列化. 每个序列化后的存储都有一个与之关联的位置标签, 它标识了保存它的设备, 而此标签是传递给 map_location 的第二个参数. 对于 CPU 张量, 内建的位置标签是 ‘cpu’, 对于 CUDA 张量, 内建的位置标签是 ‘cuda:device_id’ (例如 ‘cuda:2’). map_location 要么返回 None , 要么返回一个存储. 如果 map_location 返回存储, 它将用作已移动到正确设备上的, 最终反序列化的对象. 否则, 如果没有指明 map_location, 即返回 None, torch.load 会回落到默认的行为.

如果 map_location 是一个字典, 它用于将出现在文件 (键) 中的位置标签, 重新映射到另一个位置标签, 它出现在值中并指明在哪里存放存储.

用户扩展可以使用 register_package 来注册他们自己的位置标签, 以及标记和反序列化方法.

参数: f: 一个类文件对象 (必须实现返回文件描述符的 fileno, 以及 seek 方法), 或者包含文件名的字符串. map_location: 一个函数或者一个指明如何重新映射存储位置的字典 pickle_module: 用于解封 (unpickling) 元数据和对象的模块 (必须匹配用于序列化文件的 pickle_module) 示例:

  1. >>> torch.load('tensors.pt')
  2. # Load all tensors onto the CPU
  3. >>> torch.load('tensors.pt', map_location=lambda storage, loc: storage)
  4. # Load all tensors onto GPU 1
  5. >>> torch.load('tensors.pt', map_location=lambda storage, loc: storage.cuda(1))
  6. # Map tensors from GPU 1 to GPU 0
  7. >>> torch.load('tensors.pt', map_location={'cuda:1':'cuda:0'})

Parallelism (并行化)

  1. torch.get_num_threads() → int

获得 OpenMP 并行化操作的线程数目

  1. torch.set_num_threads(int)

设置 OpenMP 并行化操作的线程数目

Math operations (数学操作)

Pointwise Ops (逐点操作)

  1. torch.abs(input, out=None) → Tensor

计算给定 input 张量的元素的绝对值.

示例：

  1. >>> torch.abs(torch.FloatTensor([-1, -2, 3]))
  2. FloatTensor([1, 2, 3])
  1. torch.acos(input, out=None) → Tensor

用 input 元素的反余弦返回一个新的张量.

参数：

  • input (Tensor) – the input Tensor
  • out (Tensor, 可选) – The result Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4. -0.6366
  5.  0.2718
  6.  0.4469
  7.  1.3122
  8. [torch.FloatTensor of size 4]
  10. >>> torch.acos(a)
  11.  2.2608
  12.  1.2956
  13.  1.1075
  14.  nan
  15. [torch.FloatTensor of size 4]
  1. torch.add()
  1. torch.add(input, value, out=None)

将标量值 value 添加到输入张量 attr:input 的每个元素并返回一个新的结果张量.

out = tensor + value

如果输入张量 input 是 FloatTensor 或者 DoubleTensor 类型, 则 value 必须为实数, 否则为整数.

参数：

  • input (Tensor) – 输入 Tensor
  • value (Number) – 要添加到 input 每个元素的数
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  0.4050
  5. -1.2227
  6.  1.8688
  7. -0.4185
  8. [torch.FloatTensor of size 4]
  10. >>> torch.add(a, 20)
  12.  20.4050
  13.  18.7773
  14.  21.8688
  15.  19.5815
  16. [torch.FloatTensor of size 4]
  1. torch.add(input, value=1, other, out=None)

张量 other 的每个元素乘以标量值 value 并加到张量 input 上, 返回生成的张量 out .

张量 input 的形状与张量 other 的形状必须 broadcastable.

out = input + (other * value)

如果张量 other 是 FloatTensor 或者 DoubleTensor 类型, 则 value 必须为实数, 否则为整数.

参数：

  • input (Tensor) – 第一个输入 Tensor
  • value (Number) – 张量 other 的标量乘数
  • other (Tensor) – 第二个输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> import torch
  2. >>> a = torch.randn(4)
  3. >>> a
  5. -0.9310
  6.  2.0330
  7.  0.0852
  8. -0.2941
  9. [torch.FloatTensor of size 4]
  11. >>> b = torch.randn(2, 2)
  12. >>> b
  14.  1.0663  0.2544
  15. -0.1513  0.0749
  16. [torch.FloatTensor of size 2x2]
  18. >>> torch.add(a, 10, b)
  19.  9.7322
  20.  4.5770
  21. -1.4279
  22.  0.4552
  23. [torch.FloatTensor of size 4]
  1. torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) → Tensor

将张量 tensor1 逐元素除以张量 tensor2, 然后乘以标量值 value 并加到张量 tensor 上.

张量 tensor, 张量 tensor1, 张量 tensor2 的形状必须 broadcastable.

对于类型为 FloatTensor 或者 DoubleTensor 的张量输入, value 必须为实数, 否则为整数.

参数：

  • tensor (Tensor) – 张量, 对 tensor1 ./ tensor2 进行相加
  • value (Number, 可选) – 标量, 对 tensor1 ./ tensor2 进行相乘
  • tensor1 (Tensor) – 分子张量, 即作为被除数
  • tensor2 (Tensor) – 分母张量, 即作为除数
  • out (Tensor, 可选) – 输出张量

示例：

  1. >>> t = torch.randn(2, 3)
  2. >>> t1 = torch.randn(1, 6)
  3. >>> t2 = torch.randn(6, 1)
  4. >>> torch.addcdiv(t, 0.1, t1, t2)
  6.  0.0122 -0.0188 -0.2354
  7.  0.7396 -1.5721  1.2878
  8. [torch.FloatTensor of size 2x3]
  1. torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) → Tensor

将张量 tensor1 逐元素与张量 tensor2 相乘, 然后乘以标量值 value 并加到张量 tensor 上.

张量 tensor, 张量 tensor1, 张量 tensor2 的形状必须 broadcastable.

对于类型为 FloatTensor 或者 DoubleTensor 的张量输入, value 必须为实数, 否则为整数. :param tensor: 张量, 对 tensor1 .* tensor2 进行相加 :type tensor: Tensor :param value: 标量, 对 tensor1 .* tensor2 进行相乘 :type value: Number, 可选 :param tensor1: 张量, 作为乘子1 :type tensor1: Tensor :param tensor2: 张量, 作为乘子2 :type tensor2: Tensor :param out: 输出张量 :type out: Tensor, 可选

示例：

  1. >>> t = torch.randn(2, 3)
  2. >>> t1 = torch.randn(1, 6)
  3. >>> t2 = torch.randn(6, 1)
  4. >>> torch.addcmul(t, 0.1, t1, t2)
  6.  0.0122 -0.0188 -0.2354
  7.  0.7396 -1.5721  1.2878
  8. [torch.FloatTensor of size 2x3]
  1. torch.asin(input, out=None) → Tensor

返回一个新的 Tensor , 其元素为张量 input 的每个元素的反正弦.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.6366
  4.  0.2718
  5.  0.4469
  6.  1.3122
  7. [torch.FloatTensor of size 4]
  9. >>> torch.asin(a)
  10. -0.6900
  11.  0.2752
  12.  0.4633
  13.  nan
  14. [torch.FloatTensor of size 4]
  1. torch.atan(input, out=None) → Tensor

返回一个新的 Tensor , 其元素为张量 input 的每个元素的反正切.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.6366
  4.  0.2718
  5.  0.4469
  6.  1.3122
  7. [torch.FloatTensor of size 4]
  9. >>> torch.atan(a)
  10. -0.5669
  11.  0.2653
  12.  0.4203
  13.  0.9196
  14. [torch.FloatTensor of size 4]
  1. torch.atan2(input1, input2, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是输入张量 input1 和输入张量 input2 元素的反正切.

输入张量 input1 的形状和输入张量 input2 的形状必须可 broadcastable.

参数：

  • input1 (Tensor) – 第一个输入 Tensor
  • input2 (Tensor) – 第二个输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.6366
  4.  0.2718
  5.  0.4469
  6.  1.3122
  7. [torch.FloatTensor of size 4]
  9. >>> torch.atan2(a, torch.randn(4))
  10. -2.4167
  11.  2.9755
  12.  0.9363
  13.  1.6613
  14. [torch.FloatTensor of size 4]
  1. torch.ceil(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 的元素向上取整(取不小于每个元素的最小整数).

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.3869
  5.  0.3912
  6. -0.8634
  7. -0.5468
  8. [torch.FloatTensor of size 4]
  10. >>> torch.ceil(a)
  12.  2
  13.  1
  14. -0
  15. -0
  16. [torch.FloatTensor of size 4]
  1. torch.clamp(input, min, max, out=None) → Tensor

将输入张量 input 所有元素限制在区间 [min, max] 中并返回一个结果张量.

  1.       | min, if x_i < min
  2. y_i = | x_i, if min <= x_i <= max
  3.       | max, if x_i > max

如果输入张量 input 的类型 FloatTensor 或者 DoubleTensor, 那么参数 min 和 max 必须为实数, 否则为整数.

参数：

  • input (Tensor) – 输入 Tensor
  • min (Number) – 限制范围下限
  • max (Number) – 限制范围上限
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.3869
  5.  0.3912
  6. -0.8634
  7. -0.5468
  8. [torch.FloatTensor of size 4]
  10. >>> torch.clamp(a, min=-0.5, max=0.5)
  12.  0.5000
  13.  0.3912
  14. -0.5000
  15. -0.5000
  16. [torch.FloatTensor of size 4]
  1. torch.clamp(input, *, min, out=None) → Tensor

张量 input 的所有元素值大于或者等于 min.

如果张量 input 的类型是 FloatTensor 或者 DoubleTensor, 则 value 必须是实数, 否则应该是整数.

参数：

  • input (Tensor) – 输入 Tensor
  • value (Number) – 输出中每个元素的最小值
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.3869
  5.  0.3912
  6. -0.8634
  7. -0.5468
  8. [torch.FloatTensor of size 4]
  10. >>> torch.clamp(a, min=0.5)
  12.  1.3869
  13.  0.5000
  14.  0.5000
  15.  0.5000
  16. [torch.FloatTensor of size 4]
  1. torch.clamp(input, *, max, out=None) → Tensor

张量 input 的所有元素值小于或者等于 max.

如果张量 input 的类型是 FloatTensor 或者 DoubleTensor, 则 value 必须是实数, 否则应该是整数.

参数：

  • input (Tensor) – 输入 Tensor
  • value (Number) – 输出中每个元素的最大值
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.3869
  5.  0.3912
  6. -0.8634
  7. -0.5468
  8. [torch.FloatTensor of size 4]
  10. >>> torch.clamp(a, max=0.5)
  12.  0.5000
  13.  0.3912
  14. -0.8634
  15. -0.5468
  16. [torch.FloatTensor of size 4]
  1. torch.cos(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 每个元素的余弦.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.6366
  4.  0.2718
  5.  0.4469
  6.  1.3122
  7. [torch.FloatTensor of size 4]
  9. >>> torch.cos(a)
  10.  0.8041
  11.  0.9633
  12.  0.9018
  13.  0.2557
  14. [torch.FloatTensor of size 4]
  1. torch.cosh(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 每个元素的双曲余弦.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.6366
  4.  0.2718
  5.  0.4469
  6.  1.3122
  7. [torch.FloatTensor of size 4]
  9. >>> torch.cosh(a)
  10.  1.2095
  11.  1.0372
  12.  1.1015
  13.  1.9917
  14. [torch.FloatTensor of size 4]
  1. torch.div()
  1. torch.div(input, value, out=None)

将张量 input 的元素逐一除以标量值 value , 其结果作为一个新的张量返回.

out = tensor / value

如果张量 input 的类型是 FloatTensor 或者 DoubleTensor, 则标量值 value 必须是实数, 否则应该是整数.

参数：

  • input (Tensor) – 输入 Tensor
  • value (Number) – 除数, 被张量 input 的元素除
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(5)
  2. >>> a
  4. -0.6147
  5. -1.1237
  6. -0.1604
  7. -0.6853
  8.  0.1063
  9. [torch.FloatTensor of size 5]
  11. >>> torch.div(a, 0.5)
  13. -1.2294
  14. -2.2474
  15. -0.3208
  16. -1.3706
  17.  0.2126
  18. [torch.FloatTensor of size 5]
  1. torch.div(input, other, out=None)

张量 input 的元素与张量 other 的元素逐一相除. 返回一个新的结果张量 out . 张量 input 与张量 other 的形状必须可 broadcastable.

out_i = input_i / other_i

参数：

  • input (Tensor) – 分子 Tensor (被除数)
  • other (Tensor) – 分母 Tensor (除数)
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4,4)
  2. >>> a
  4. -0.1810  0.4017  0.2863 -0.1013
  5.  0.6183  2.0696  0.9012 -1.5933
  6.  0.5679  0.4743 -0.0117 -0.1266
  7. -0.1213  0.9629  0.2682  1.5968
  8. [torch.FloatTensor of size 4x4]
  10. >>> b = torch.randn(8, 2)
  11. >>> b
  13.  0.8774  0.7650
  14.  0.8866  1.4805
  15. -0.6490  1.1172
  16.  1.4259 -0.8146
  17.  1.4633 -0.1228
  18.  0.4643 -0.6029
  19.  0.3492  1.5270
  20.  1.6103 -0.6291
  21. [torch.FloatTensor of size 8x2]
  23. >>> torch.div(a, b)
  25. -0.2062  0.5251  0.3229 -0.0684
  26. -0.9528  1.8525  0.6320  1.9559
  27.  0.3881 -3.8625 -0.0253  0.2099
  28. -0.3473  0.6306  0.1666 -2.5381
  29. [torch.FloatTensor of size 4x4]
  1. torch.erf(tensor, out=None) → Tensor

计算每个元素的误差函数.

示例：

  1. >>> torch.erf(torch.Tensor([0, -1., 10.]))
  2. torch.FloatTensor([0., -0.8427, 1.])
  1. torch.erfinv(tensor, out=None) → Tensor

计算每个元素的反向误差函数.

示例：

  1. >>> torch.erfinv(torch.Tensor([0, 0.5., -1.]))
  2. torch.FloatTensor([0., 0.4769, -inf])
  1. torch.exp(tensor, out=None) → Tensor

计算每个元素的指数.

示例：

  1. >>> torch.exp(torch.Tensor([0, math.log(2)]))
  2. torch.FloatTensor([1, 2])
  1. torch.floor(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 的元素向下取整(取不大于每个元素的最大整数).

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.3869
  5.  0.3912
  6. -0.8634
  7. -0.5468
  8. [torch.FloatTensor of size 4]
  10. >>> torch.floor(a)
  12.  1
  13.  0
  14. -1
  15. -1
  16. [torch.FloatTensor of size 4]
  1. torch.fmod(input, divisor, out=None) → Tensor

计算除法余数.

被除数和除数可能同时含有整数和浮点数. 这时余数的正负与被除数 tensor 相同.

当除数 divisor 是一个张量时r, 张量 input 和张量 divisor 的形状必须可 broadcastable.

参数：

  • input (Tensor) – 被除数
  • divisor (Tensor 或 float) – 除数. 可能是一个数或者是一个与被除数相同形状的张量.
  • out (Tensor, 可选) – 输出张量

示例：

  1. >>> torch.fmod(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
  2. torch.FloatTensor([-1, -0, -1, 1, 0, 1])
  3. >>> torch.fmod(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
  4. torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])

See also

torch.remainder(), 其计算等价于 Python’s % 操作符的元素余数

  1. torch.frac(tensor, out=None) → Tensor

计算张量 tensor 每个元素的分数部分.

示例：

  1. >>> torch.frac(torch.Tensor([1, 2.5, -3.2])
  2. torch.FloatTensor([0, 0.5, -0.2])
  1. torch.lerp(start, end, weight, out=None)

基于标量值 weight: , 在张量 start 与张量 end 之间做线性插值 并返回结果张量 out .

out_i = start_i + weight * (end_i - start_i)

张量 start 和张量 end 的形状必须可 broadcastable.

参数：

  • start (Tensor) – 起始点 Tensor
  • end (Tensor) – 终点 Tensor
  • weight (float) – 插值公式的权重
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> start = torch.arange(1, 5)
  2. >>> end = torch.Tensor(4).fill_(10)
  3. >>> start
  5.  1
  6.  2
  7.  3
  8.  4
  9. [torch.FloatTensor of size 4]
  11. >>> end
  13.  10
  14.  10
  15.  10
  16.  10
  17. [torch.FloatTensor of size 4]
  19. >>> torch.lerp(start, end, 0.5)
  21.  5.5000
  22.  6.0000
  23.  6.5000
  24.  7.0000
  25. [torch.FloatTensor of size 4]
  1. torch.log(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 所有元素的自然对数.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(5)
  2. >>> a
  4. -0.4183
  5.  0.3722
  6. -0.3091
  7.  0.4149
  8.  0.5857
  9. [torch.FloatTensor of size 5]
  11. >>> torch.log(a)
  13.  nan
  14. -0.9883
  15.  nan
  16. -0.8797
  17. -0.5349
  18. [torch.FloatTensor of size 5]
  1. torch.log1p(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是(1 + input) 的自然对数.

y_i = log(x_i + 1)

注解：

对于较小的张量 input 的值, 此函数比 torch.log() 更精确.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(5)
  2. >>> a
  4. -0.4183
  5.  0.3722
  6. -0.3091
  7.  0.4149
  8.  0.5857
  9. [torch.FloatTensor of size 5]
  11. >>> torch.log1p(a)
  13. -0.5418
  14.  0.3164
  15. -0.3697
  16.  0.3471
  17.  0.4611
  18. [torch.FloatTensor of size 5]
  1. torch.mul()
  1. torch.mul(input, value, out=None)

将输入张量 input 的每个元素与标量值 value 相乘并返回一个新的结果张量.

out = tensor * value

如果张量 input 的类型为 FloatTensor or DoubleTensor, 则 value 应该是实数, 否则为整数.

参数：

  • input (Tensor) – 输入 Tensor
  • value (Number) – 与张量 input 每个元素相乘的数
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(3)
  2. >>> a
  4. -0.9374
  5. -0.5254
  6. -0.6069
  7. [torch.FloatTensor of size 3]
  9. >>> torch.mul(a, 100)
  11. -93.7411
  12. -52.5374
  13. -60.6908
  14. [torch.FloatTensor of size 3]
  1. torch.mul(input, other, out=None)

张量 input 的元素与张量 other 的元素逐一相乘. 其结果作为一个新的张量返回.

张量 input 和张量 other 的形状必须可 broadcastable.

out_i = input_i * other_i

参数：

  • input (Tensor) – 第一个乘数 Tensor
  • other (Tensor) – 第二个乘数 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4,4)
  2. >>> a
  4. -0.7280  0.0598 -1.4327 -0.5825
  5. -0.1427 -0.0690  0.0821 -0.3270
  6. -0.9241  0.5110  0.4070 -1.1188
  7. -0.8308  0.7426 -0.6240 -1.1582
  8. [torch.FloatTensor of size 4x4]
  10. >>> b = torch.randn(2, 8)
  11. >>> b
  13.  0.0430 -1.0775  0.6015  1.1647 -0.6549  0.0308 -0.1670  1.0742
  14. -1.2593  0.0292 -0.0849  0.4530  1.2404 -0.4659 -0.1840  0.5974
  15. [torch.FloatTensor of size 2x8]
  17. >>> torch.mul(a, b)
  19. -0.0313 -0.0645 -0.8618 -0.6784
  20.  0.0934 -0.0021 -0.0137 -0.3513
  21.  1.1638  0.0149 -0.0346 -0.5068
  22. -1.0304 -0.3460  0.1148 -0.6919
  23. [torch.FloatTensor of size 4x4]
  1. torch.neg(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 的元素的负值.

out = -1 * input

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(5)
  2. >>> a
  4. -0.4430
  5.  1.1690
  6. -0.8836
  7. -0.4565
  8.  0.2968
  9. [torch.FloatTensor of size 5]
  11. >>> torch.neg(a)
  13.  0.4430
  14. -1.1690
  15.  0.8836
  16.  0.4565
  17. -0.2968
  18. [torch.FloatTensor of size 5]
  1. torch.pow()
  1. torch.pow(input, exponent, out=None)

对输入张量 input 按元素求 exponent 次幂值并返回结果张量(其值作为结果张量的元素).

幂值 exponent 可以是一个单一的浮点数 float 或者是一个与张量 input 有相同元素数的张量 Tensor .

当指数 exponent 是一个标量时, 执行操作:

out_i = x_i ^ {exponent}

当指数 exponent 是一个张量, 执行操作:

out_i = x_i ^ {exponent_i}

当幂值 exponent 是一个张量, 张量 input 和张量 exponent 的形状必须可 broadcastable.

参数：

  • input (Tensor) – 输入 Tensor
  • exponent (float 或 Tensor) – 指数
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4. -0.5274
  5. -0.8232
  6. -2.1128
  7.  1.7558
  8. [torch.FloatTensor of size 4]
  10. >>> torch.pow(a, 2)
  12.  0.2781
  13.  0.6776
  14.  4.4640
  15.  3.0829
  16. [torch.FloatTensor of size 4]
  18. >>> exp = torch.arange(1, 5)
  19. >>> a = torch.arange(1, 5)
  20. >>> a
  22.  1
  23.  2
  24.  3
  25.  4
  26. [torch.FloatTensor of size 4]
  28. >>> exp
  30.  1
  31.  2
  32.  3
  33.  4
  34. [torch.FloatTensor of size 4]
  36. >>> torch.pow(a, exp)
  38.  1
  39.  4
  40.  27
  41.  256
  42. [torch.FloatTensor of size 4]
  1. torch.pow(base, input, out=None)

base 是一个标量浮点值, input 是一个张量. 返回的张量 out 的形状与张量 input 的形状相同.

执行操作:

out_i = base ^ {input_i}

参数：

  • base (float) – 幂运算的底数
  • input (Tensor) – 指数
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> exp = torch.arange(1, 5)
  2. >>> base = 2
  3. >>> torch.pow(base, exp)
  5.  2
  6.  4
  7.  8
  8.  16
  9. [torch.FloatTensor of size 4]
  1. torch.reciprocal(input, out=None) → Tensor

返回一个新的 Tensor , 其元素是张量 input 元素的倒数, i.e. 1.0 / x

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.3869
  5.  0.3912
  6. -0.8634
  7. -0.5468
  8. [torch.FloatTensor of size 4]
  10. >>> torch.reciprocal(a)
  12.  0.7210
  13.  2.5565
  14. -1.1583
  15. -1.8289
  16. [torch.FloatTensor of size 4]
  1. torch.remainder(input, divisor, out=None) → Tensor

计算元素的除法的余数.

除数与被除数可能同时包含整数或浮点数. 余数与除数有相同的符号.

当除数 divisor 是一个张量, 张量 input 的形状和张量 divisor 得形状必须可 broadcastable.

参数：

  • input (Tensor) – 被除数
  • divisor (Tensor 或 float) – 除数. 可能是一个数或者可能是一个与被除数大小相同的张量
  • out (Tensor, 可选) – 输出张量

示例：

  1. >>> torch.remainder(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
  2. torch.FloatTensor([1, 0, 1, 1, 0, 1])
  3. >>> torch.remainder(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
  4. torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])

See also

torch.fmod() 同样计算除法余数, 等效于C库函数中的 fmod()

  1. torch.round(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是输入张量的元素四舍五入到最近的整数.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.2290
  5.  1.3409
  6. -0.5662
  7. -0.0899
  8. [torch.FloatTensor of size 4]
  10. >>> torch.round(a)
  12.  1
  13.  1
  14. -1
  15. -0
  16. [torch.FloatTensor of size 4]
  1. torch.rsqrt(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 元素的平方根的倒数.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.2290
  5.  1.3409
  6. -0.5662
  7. -0.0899
  8. [torch.FloatTensor of size 4]
  10. >>> torch.rsqrt(a)
  12.  0.9020
  13.  0.8636
  14.  nan
  15.  nan
  16. [torch.FloatTensor of size 4]
  1. torch.sigmoid(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 元素的sigmoid值.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4. -0.4972
  5.  1.3512
  6.  0.1056
  7. -0.2650
  8. [torch.FloatTensor of size 4]
  10. >>> torch.sigmoid(a)
  12.  0.3782
  13.  0.7943
  14.  0.5264
  15.  0.4341
  16. [torch.FloatTensor of size 4]
  1. torch.sign(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 元素的符号.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.6366
  4.  0.2718
  5.  0.4469
  6.  1.3122
  7. [torch.FloatTensor of size 4]
  9. >>> torch.sign(a)
  11. -1
  12.  1
  13.  1
  14.  1
  15. [torch.FloatTensor of size 4]
  1. torch.sin(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 元素的正弦.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.6366
  4.  0.2718
  5.  0.4469
  6.  1.3122
  7. [torch.FloatTensor of size 4]
  9. >>> torch.sin(a)
  10. -0.5944
  11.  0.2684
  12.  0.4322
  13.  0.9667
  14. [torch.FloatTensor of size 4]
  1. torch.sinh(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 元素的双曲正弦.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.6366
  4.  0.2718
  5.  0.4469
  6.  1.3122
  7. [torch.FloatTensor of size 4]
  9. >>> torch.sinh(a)
  10. -0.6804
  11.  0.2751
  12.  0.4619
  13.  1.7225
  14. [torch.FloatTensor of size 4]
  1. torch.sqrt(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 元素的平方根.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.2290
  5.  1.3409
  6. -0.5662
  7. -0.0899
  8. [torch.FloatTensor of size 4]
  10. >>> torch.sqrt(a)
  12.  1.1086
  13.  1.1580
  14.  nan
  15.  nan
  16. [torch.FloatTensor of size 4]
  1. torch.tan(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 元素的正切.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.6366
  4.  0.2718
  5.  0.4469
  6.  1.3122
  7. [torch.FloatTensor of size 4]
  9. >>> torch.tan(a)
  10. -0.7392
  11.  0.2786
  12.  0.4792
  13.  3.7801
  14. [torch.FloatTensor of size 4]
  1. torch.tanh(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 元素的双曲正切.

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.6366
  4.  0.2718
  5.  0.4469
  6.  1.3122
  7. [torch.FloatTensor of size 4]
  9. >>> torch.tanh(a)
  10. -0.5625
  11.  0.2653
  12.  0.4193
  13.  0.8648
  14. [torch.FloatTensor of size 4]
  1. torch.trunc(input, out=None) → Tensor

返回一个新的张量 Tensor , 其元素是张量 input 元素的截断整数值 (直接去除小数部分) .

参数：

  • input (Tensor) – 输入 Tensor
  • out (Tensor, 可选) – 输出 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4. -0.4972
  5.  1.3512
  6.  0.1056
  7. -0.2650
  8. [torch.FloatTensor of size 4]
  10. >>> torch.trunc(a)
  12. -0
  13.  1
  14.  0
  15. -0
  16. [torch.FloatTensor of size 4]

Reduction Ops (归约操作)

  1. torch.cumprod(input, dim, out=None) → Tensor

返回元素 input 在给定维度 dim 下的累积积.

例如, 如果 input 是一个N元张量, 结果也是一个N元张量, 元素为: y_i = x_1 * x_2 * x_3 * ... * x_i

参数：

  • input (Tensor) – 输入 Tensor
  • dim (int) – 进行操作的维度
  • out (Tensor, 可选) – 输出 Tensor

示例：

  1. >>> a = torch.randn(10)
  2. >>> a
  4.  1.1148
  5.  1.8423
  6.  1.4143
  7. -0.4403
  8.  1.2859
  9. -1.2514
  10. -0.4748
  11.  1.1735
  12. -1.6332
  13. -0.4272
  14. [torch.FloatTensor of size 10]
  16. >>> torch.cumprod(a, dim=0)
  18.  1.1148
  19.  2.0537
  20.  2.9045
  21. -1.2788
  22. -1.6444
  23.  2.0578
  24. -0.9770
  25. -1.1466
  26.  1.8726
  27. -0.8000
  28. [torch.FloatTensor of size 10]
  30. >>> a[5] = 0.0
  31. >>> torch.cumprod(a, dim=0)
  33.  1.1148
  34.  2.0537
  35.  2.9045
  36. -1.2788
  37. -1.6444
  38. -0.0000
  39.  0.0000
  40.  0.0000
  41. -0.0000
  42.  0.0000
  43. [torch.FloatTensor of size 10]
  1. torch.cumsum(input, dim, out=None) → Tensor

返回元素 input 在给定维度 dim 下的累积和.

例如, 如果 input 是一个N元张量, 结果将也是一个N元张量, 元素为: y_i = x_1 + x_2 + x_3 + ... + x_i

参数：

  • input (Tensor) – 输入 Tensor
  • dim (int) – 进行操作的维度
  • out (Tensor, 可选) – 输出 Tensor

示例：

  1. >>> a = torch.randn(10)
  2. >>> a
  4. -0.6039
  5. -0.2214
  6. -0.3705
  7. -0.0169
  8.  1.3415
  9. -0.1230
  10.  0.9719
  11.  0.6081
  12. -0.1286
  13.  1.0947
  14. [torch.FloatTensor of size 10]
  16. >>> torch.cumsum(a, dim=0)
  18. -0.6039
  19. -0.8253
  20. -1.1958
  21. -1.2127
  22.  0.1288
  23.  0.0058
  24.  0.9777
  25.  1.5858
  26.  1.4572
  27.  2.5519
  28. [torch.FloatTensor of size 10]
  1. torch.dist(input, other, p=2) → float

返回(input - other)的p-范数 input 和 other 的形状必须满足 broadcastable.

参数：

  • input (Tensor) – 输入 Tensor
  • other (Tensor) – 右侧输入 Tensor
  • p (float, 可选) – 所计算的范数.

示例：

  1. >>> x = torch.randn(4)
  2. >>> x
  4.  0.2505
  5. -0.4571
  6. -0.3733
  7.  0.7807
  8. [torch.FloatTensor of size 4]
  10. >>> y = torch.randn(4)
  11. >>> y
  13.  0.7782
  14. -0.5185
  15.  1.4106
  16. -2.4063
  17. [torch.FloatTensor of size 4]
  19. >>> torch.dist(x, y, 3.5)
  20. 3.302832063224223
  21. >>> torch.dist(x, y, 3)
  22. 3.3677282206393286
  23. >>> torch.dist(x, y, 0)
  24. inf
  25. >>> torch.dist(x, y, 1)
  26. 5.560028076171875
  1. torch.mean()
  1. torch.mean(input) → float

返回张量 input 所有元素的均值.

参数：input (Tensor) – 输入 Tensor

示例：

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  4. -0.2946 -0.9143  2.1809
  5. [torch.FloatTensor of size 1x3]
  7. >>> torch.mean(a)
  8. 0.32398951053619385
  1. torch.mean(input, dim, keepdim=False, out=None) → Tensor

返回张量 input 在给定维度 dim 上每行的均值.

如果 keepdim 是 True, 输出张量的大小与输入张量 input 相同, 除了维度 dim 是1. 另外, dim 被挤压 (参看 torch.squeeze() ), 导致输出张量减少一维.

参数：

  • input (Tensor) – 输入 Tensor
  • dim (int) – 要减少的维度
  • keepdim (bool, 可选) – 输出张量的维度 dim 保持与否
  • out (Tensor) – 输出张量

示例：

  1. >>> a = torch.randn(4, 4)
  2. >>> a
  4. -1.2738 -0.3058  0.1230 -1.9615
  5.  0.8771 -0.5430 -0.9233  0.9879
  6.  1.4107  0.0317 -0.6823  0.2255
  7. -1.3854  0.4953 -0.2160  0.2435
  8. [torch.FloatTensor of size 4x4]
  10. >>> torch.mean(a, 1)
  12. -0.8545
  13.  0.0997
  14.  0.2464
  15. -0.2157
  16. [torch.FloatTensor of size 4]
  18. >>> torch.mean(a, 1, True)
  20. -0.8545
  21.  0.0997
  22.  0.2464
  23. -0.2157
  24. [torch.FloatTensor of size 4x1]
  1. torch.median()
  1. torch.median(input) → float

返回输出张量 input 所有元素的中位数.

参数：input (Tensor) – the input Tensor

示例：

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  4.  0.4729 -0.2266 -0.2085
  5. [torch.FloatTensor of size 1x3]
  7. >>> torch.median(a)
  8. -0.2085
  1. torch.median(input, dim=-1, keepdim=False, values=None, indices=None) -> (Tensor, LongTensor)

返回输出张量 input 在给定维度 dim 下每行的中位数. 同时返回一个包含中位数的索引 LongTensor.

dim 的缺省值为输入张量 input 的最后一维.

如果 keepdim 是 True, 输出张量与输入张量 input 形状相同, 除了维数 dim 是1. 另外, dim 被挤压 (参看 torch.squeeze() ), 导致输出张量比输入张量 input 少一维.

参数：

  • input (Tensor) – 输入张量 Tensor
  • dim (int) – 要减少的维度
  • keepdim (bool) – 输出张量的维度 dim 保留与否
  • values (Tensor, 可选) – 结果张量
  • indices (Tensor, 可选) – 结果张量索引

示例：

  1. >>> a
  3.  -0.6891 -0.6662
  4.  0.2697  0.7412
  5.  0.5254 -0.7402
  6.  0.5528 -0.2399
  7. [torch.FloatTensor of size 4x2]
  9. >>> a = torch.randn(4, 5)
  10. >>> a
  12.  0.4056 -0.3372  1.0973 -2.4884  0.4334
  13.  2.1336  0.3841  0.1404 -0.1821 -0.7646
  14. -0.2403  1.3975 -2.0068  0.1298  0.0212
  15. -1.5371 -0.7257 -0.4871 -0.2359 -1.1724
  16. [torch.FloatTensor of size 4x5]
  18. >>> torch.median(a, 1)
  19. (
  20.  0.4056
  21.  0.1404
  22.  0.0212
  23. -0.7257
  24. [torch.FloatTensor of size 4]
  25. ,
  26.  0
  27.  2
  28.  4
  29.  1
  30. [torch.LongTensor of size 4]
  31. )
  1. torch.mode(input, dim=-1, keepdim=False, values=None, indices=None) -> (Tensor, LongTensor)

返回输入张量 input 在给定维数 dim 下每行元素的众数值. 同时也返回众数值的索引 LongTensor.

维度 dim 的缺省值是输入张量 input 的最后一维. .

如果 keepdim 是 True, 输出张量的大小与输入张量 input 相同, 除了维度 dim 是1. 另外, dim 被挤压 (参看 torch.squeeze() ), 导致输出张量减少一维.

注解：

这个函数至今没有为 torch.cuda.Tensor 定义.

参数：

  • input (Tensor) – 输入张量 Tensor
  • dim (int) – 要减少的维度
  • keepdim (bool) – 输出张量的维度 dim 保持与否
  • values (Tensor, 可选) – 结果张量
  • indices (Tensor, 可选) – 结果索引张量

示例：

  1. >>> a
  3.  -0.6891 -0.6662
  4.  0.2697  0.7412
  5.  0.5254 -0.7402
  6.  0.5528 -0.2399
  7. [torch.FloatTensor of size 4x2]
  9. >>> a = torch.randn(4, 5)
  10. >>> a
  12.  0.4056 -0.3372  1.0973 -2.4884  0.4334
  13.  2.1336  0.3841  0.1404 -0.1821 -0.7646
  14. -0.2403  1.3975 -2.0068  0.1298  0.0212
  15. -1.5371 -0.7257 -0.4871 -0.2359 -1.1724
  16. [torch.FloatTensor of size 4x5]
  18. >>> torch.mode(a, 1)
  19. (
  20. -2.4884
  21. -0.7646
  22. -2.0068
  23. -1.5371
  24. [torch.FloatTensor of size 4]
  25. ,
  26.  3
  27.  4
  28.  2
  29.  0
  30. [torch.LongTensor of size 4]
  31. )
  1. torch.norm()
  1. torch.norm(input, p=2) → float

返回输入张量 input 的p-范数

参数：

  • input (Tensor) – 输入张量 Tensor
  • p (float, 可选) – 范数计算中的幂指数值

示例：

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  4. -0.4376 -0.5328  0.9547
  5. [torch.FloatTensor of size 1x3]
  7. >>> torch.norm(a, 3)
  8. 1.0338925067372466
  1. torch.norm(input, p, dim, keepdim=False, out=None) → Tensor

返回输入张量 input 在给定维度 dim 下每行元素的p-范数.

如果 keepdim 是 True, 输出张量的大小与输入张量 input 相同, 除非维度 dim 是1. 另外, dim 被挤压 (参看 torch.squeeze() ), 导致输出张量减少一维.

参数：

  • input (Tensor) – 输入张量 Tensor
  • p (float) – 范数计算中的幂指数值
  • dim (int) – 要减少的维度
  • keepdim (bool) – 输出张量的维度 dim 保持与否
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> a = torch.randn(4, 2)
  2. >>> a
  4. -0.6891 -0.6662
  5.  0.2697  0.7412
  6.  0.5254 -0.7402
  7.  0.5528 -0.2399
  8. [torch.FloatTensor of size 4x2]
  10. >>> torch.norm(a, 2, 1)
  12.  0.9585
  13.  0.7888
  14.  0.9077
  15.  0.6026
  16. [torch.FloatTensor of size 4]
  18. >>> torch.norm(a, 0, 1, True)
  20.  2
  21.  2
  22.  2
  23.  2
  24. [torch.FloatTensor of size 4x1]
  1. torch.prod()
  1. torch.prod(input) → float

返回输入张量 input 所有元素的乘积.

参数：input (Tensor) – 输入张量 Tensor

示例：

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  4.  0.6170  0.3546  0.0253
  5. [torch.FloatTensor of size 1x3]
  7. >>> torch.prod(a)
  8. 0.005537458061418483
  1. torch.prod(input, dim, keepdim=False, out=None) → Tensor

返回输入张量 input 在给定维度 dim 下每行元素的积.

如果 keepdim 是 True, 输出张量的大小与输入张量 input 相同, 除了维度 dim 是1. 另外, dim 被挤压 (参看 torch.squeeze() ), 导致输出张量减少一维.

参数：

  • input (Tensor) – 输入张量 Tensor
  • dim (int) – 要减少的维度
  • keepdim (bool) – 输出张量的维度 dim 保持与否
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> a = torch.randn(4, 2)
  2. >>> a
  4.  0.1598 -0.6884
  5. -0.1831 -0.4412
  6. -0.9925 -0.6244
  7. -0.2416 -0.8080
  8. [torch.FloatTensor of size 4x2]
  10. >>> torch.prod(a, 1)
  12. -0.1100
  13.  0.0808
  14.  0.6197
  15.  0.1952
  16. [torch.FloatTensor of size 4]
  1. torch.std()
  1. torch.std(input, unbiased=True) → float

返回输入张量 input 所有元素的标准差.

如果 unbiased 是 False , 那么标准差将通过有偏估计计算.否则, Bessel’s correction 将被使用.

参数：

  • input (Tensor) – 输入 Tensor
  • unbiased (bool) – 是否使用无偏估计

示例：

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  4. -1.3063  1.4182 -0.3061
  5. [torch.FloatTensor of size 1x3]
  7. >>> torch.std(a)
  8. 1.3782334731508061
  1. torch.std(input, dim, keepdim=False, unbiased=True, out=None) → Tensor

返回输入张量 input 在给定维度 dim 下每行元素的标准差.

如果 keepdim 是 True, 输出张量的大小与输入张量 input 相同, 除了维度 dim 是 1. 另外, dim 被挤压 (参看 torch.squeeze() ), 导致输出张量减少一维.

如果 unbiased 是 False , 那么标准差将通过有偏估计来计算. 否则, Bessel’s correction 将被使用.

参数：

  • input (Tensor) – 输入 Tensor
  • dim (int) – 要减少的维度
  • keepdim (bool) – 输出张量的维度 dim 保持与否
  • unbiased (bool) – 是否使用无偏估计
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> a = torch.randn(4, 4)
  2. >>> a
  4.  0.1889 -2.4856  0.0043  1.8169
  5. -0.7701 -0.4682 -2.2410  0.4098
  6.  0.1919 -1.1856 -1.0361  0.9085
  7.  0.0173  1.0662  0.2143 -0.5576
  8. [torch.FloatTensor of size 4x4]
  10. >>> torch.std(a, dim=1)
  12.  1.7756
  13.  1.1025
  14.  1.0045
  15.  0.6725
  16. [torch.FloatTensor of size 4]
  1. torch.sum()
  1. torch.sum(input) → float

返回输入张量 input 所有元素的和.

参数：input (Tensor) – 输入张量 Tensor

示例：

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  4.  0.6170  0.3546  0.0253
  5. [torch.FloatTensor of size 1x3]
  7. >>> torch.sum(a)
  8. 0.9969287421554327
  1. torch.sum(input, dim, keepdim=False, out=None) → Tensor

返回输入张量 input 在给定维度 dim 下每行元素的和.

如果 keepdim 是 True, 输出张量的大小与输入张量 input 相同, 除了维度 dim 是 1. 另外, dim 被挤压 (参看 torch.squeeze() ), 导致输出张量减少一维.

参数：

  • input (Tensor) – 输入张量 Tensor
  • dim (int) – 要减少的维度
  • keepdim (bool) – 输出张量的维度 dim 保持与否
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> a = torch.randn(4, 4)
  2. >>> a
  4. -0.4640  0.0609  0.1122  0.4784
  5. -1.3063  1.6443  0.4714 -0.7396
  6. -1.3561 -0.1959  1.0609 -1.9855
  7.  2.6833  0.5746 -0.5709 -0.4430
  8. [torch.FloatTensor of size 4x4]
  10. >>> torch.sum(a, 1)
  12.  0.1874
  13.  0.0698
  14. -2.4767
  15.  2.2440
  16. [torch.FloatTensor of size 4]
  1. torch.var()
  1. torch.var(input, unbiased=True) → float

返回输入张量 input 的方差.

如果 unbiased 是 False , 方差的计算将通过有偏估计计算. 否则, Bessel’s correction 将会被使用.

参数：

  • input (Tensor) – 输入张量 Tensor
  • unbiased (bool) – 是否使用无偏估计

示例：

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  4. -1.3063  1.4182 -0.3061
  5. [torch.FloatTensor of size 1x3]
  7. >>> torch.var(a)
  8. 1.899527506513334
  1. torch.var(input, dim, keepdim=False, unbiased=True, out=None) → Tensor

返回输入张量 input 在给定维度 dim 下每行的方差.

如果 keepdim 是 True, 输出张量的大小与输入张量 input 相同, 除了维度 dim 是 1. 另外, dim 被挤压 (参看 torch.squeeze()), 导致输出张量减少一维.

如果 unbiased 是False, 方差的计算将通过有偏估计计算. 否则, Bessel’s correction 将会被使用.

参数：

  • input (Tensor) – 输入张量 Tensor
  • dim (int) – 要减少的维度
  • keepdim (bool) – 输出张量的维度 dim 保留与否
  • unbiased (bool) – 是否使用无偏估计
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> a = torch.randn(4, 4)
  2. >>> a
  4. -1.2738 -0.3058  0.1230 -1.9615
  5.  0.8771 -0.5430 -0.9233  0.9879
  6.  1.4107  0.0317 -0.6823  0.2255
  7. -1.3854  0.4953 -0.2160  0.2435
  8. [torch.FloatTensor of size 4x4]
  10. >>> torch.var(a, 1)
  12.  0.8859
  13.  0.9509
  14.  0.7548
  15.  0.6949
  16. [torch.FloatTensor of size 4]

Comparison Ops (比较操作)

  1. torch.eq(input, other, out=None) → Tensor

比较元素是否相等

第二个元素可以是一个数字或 broadcastable 为与第一个参数形状相同的张量.

参数：

  • input (Tensor) – 待比较张量
  • other (Tensor 或 float) – 比较张量或数
  • out (Tensor, 可选) – 输出张量, 须为 ByteTensor 类型或与 input (Tensor) 同类型

返回值：一个 torch.ByteTensor 张量, 待比较和要比较张量逐位置比较, 相等为 1 , 不等为 0

示例：

  1. >>> torch.eq(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
  2. 1  0
  3. 0  1
  4. [torch.ByteTensor of size 2x2]
  1. torch.equal(tensor1, tensor2) → bool

如果两个张量有相同的形状和元素值, 则返回 True , 否则 False .

示例：

  1. >>> torch.equal(torch.Tensor([1, 2]), torch.Tensor([1, 2]))
  2. True
  1. torch.ge(input, other, out=None) → Tensor

逐元素比较 input 和 other , 即是否 input>=other .

第二个参数可以为一个数或形状可 broadcastable 为和第一个参数相同类型的张量.

参数：

  • input (Tensor) – 待对比的张量
  • other (Tensor 或 float) – 对比的张量或 float 值
  • out (Tensor, 可选) – 输出张量. 必须为 ByteTensor 或者与第一个参数 tensor 相同类型.

返回值：一个 torch.ByteTensor 张量, 包含了每个位置的比较结果(是否 input >= other ).

返回类型：Tensor

示例：

  1. >>> torch.ge(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
  2.  1  1
  3.  0  1
  4. [torch.ByteTensor of size 2x2]
  1. torch.gt(input, other, out=None) → Tensor

逐元素比较 input 和 other , 即是否 input>other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False.

第二个参数可以为一个数或形状可 broadcastable 为和第一个参数相同类型的张量.

参数：

  • input (Tensor) – 待对比的张量
  • other (Tensor 或 float) – 对比的张量或 float 值
  • out (Tensor, 可选) – 输出张量. 必须为 ByteTensor 或者与第一个参数 tensor 相同类型.

返回值：一个 torch.ByteTensor 张量, 包含了每个位置的比较结果(是否 input > other ).

返回类型：Tensor

示例：

  1. >>> torch.gt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
  2.  0  1
  3.  0  0
  4. [torch.ByteTensor of size 2x2]
  1. torch.kthvalue(input, k, dim=None, keepdim=False, out=None) -> (Tensor, LongTensor)

取输入张量 input 指定维上第 k 个最小值. 如果不指定 dim , 则默认为 input 的最后一维.

返回一个元组 (values,indices) ,其中 indices 是原始输入张量 input 中沿 dim 维的第 k 个最小值下标.

如果 keepdim 为 True , values 和 indices 张量都和 input 大小相同, 除了在所有值都为1的 dim 维度上. 如果 keepdim 为 False , dim 被压缩. (参见 torch.squeeze() ), 使 values 和 indices 两个张量比 input 张量小一个的维度.

参数：

  • input (Tensor) – 输入 Tensor
  • k (int) – 第 k 个最小值
  • dim (int, 可选) – 沿着此维进行排序
  • keepdim (bool) – 输出张量是否保持维度 dim 不变
  • out (tuple, 可选) – 输出元组 ( Tensor, LongTensor ) 可选参数(作为输出 buffers )

示例：

  1. >>> x = torch.arange(1, 6)
  2. >>> x
  4.  1
  5.  2
  6.  3
  7.  4
  8.  5
  9. [torch.FloatTensor of size 5]
  11. >>> torch.kthvalue(x, 4)
  12. (
  13.  4
  14. [torch.FloatTensor of size 1]
  15. ,
  16.  3
  17. [torch.LongTensor of size 1]
  18. )
  20. >>> x=torch.arange(1,7).resize_(2,3)
  21. >>> x
  23. 1  2  3
  24. 4  5  6
  25. [torch.FloatTensor of size 2x3]
  27. >>> torch.kthvalue(x,2,0,True)
  28. (
  29. 4  5  6
  30. [torch.FloatTensor of size 1x3]
  31.  ,
  32. 1  1  1
  33. [torch.LongTensor of size 1x3]
  34. )
  1. torch.le(input, other, out=None) → Tensor

逐元素比较 input 和 other , 即是否 input<=other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False .

第二个参数可以为一个数或形状可 broadcastable 为和第一个参数相同类型的张量.

参数：

  • input (Tensor) – 待对比的张量
  • other (Tensor 或 float) – 对比的张量或 float 值
  • out (Tensor, 可选) – 输出张量. 必须为 ByteTensor 或者与第一个参数 tensor 相同类型.

返回值：一个 torch.ByteTensor 张量, 包含了每个位置的比较结果(是否 input <= other ).

返回类型：Tensor

示例：

  1. >>> torch.le(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
  2.  1  0
  3.  1  1
  4. [torch.ByteTensor of size 2x2]
  1. torch.lt(input, other, out=None) → Tensor

逐元素比较 input 和 other , 即是否 input<other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False .

第二个参数可以为一个数或形状可 broadcastable 为和第一个参数相同类型的张量.

参数：

  • input (Tensor) – 待对比的张量
  • other (Tensor 或 float) – 对比的张量或 float 值
  • out (Tensor, 可选) – 输出张量. 必须为 ByteTensor 或者与第一个参数 tensor 相同类型.

返回值：一个 torch.ByteTensor 张量, 包含了每个位置的比较结果(是否 input < other ).

返回类型：Tensor

示例：

  1. >>> torch.lt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
  2.  0  0
  3.  1  0
  4. [torch.ByteTensor of size 2x2]
  1. torch.max()
  1. torch.max(input) → float

返回输入 input 张量所有元素的最大值.

参数：input (Tensor) – 输入 Tensor

示例：

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  4.  0.4729 -0.2266 -0.2085
  5. [torch.FloatTensor of size 1x3]
  7. >>> torch.max(a)
  8. 0.4729
  1. torch.max(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)

返回输入张量 input 在给定维度 dim 上每行的最大值, 并同时返回每个最大值的位置索引.

如果 keepdim 为 True , values 和 indices 张量都和 input 尺寸相同, 除了在所有值都为 1 的 dim 维度上. 如果 keepdim 为 False , dim 被压缩. (参见 torch.squeeze() ), 使 values 和 indices 两个张量比 input 张量小一个的维度.

参数：

  • input (Tensor) – 输入 Tensor
  • k (int) – 第 k 个最小值
  • dim (int, 可选) – 沿着此维进行排序
  • keepdim (bool) – 输出张量是否保持维度 dim 不变
  • out (tuple, 可选) – 输出元组 (max, max_indices)

示例：

  1. >> a = torch.randn(4, 4)
  2. >> a
  4. 0.0692  0.3142  1.2513 -0.5428
  5. 0.9288  0.8552 -0.2073  0.6409
  6. 1.0695 -0.0101 -2.4507 -1.2230
  7. 0.7426 -0.7666  0.4862 -0.6628
  8. torch.FloatTensor of size 4x4]
  10. >>> torch.max(a, 1)
  11. (
  12.  1.2513
  13.  0.9288
  14.  1.0695
  15.  0.7426
  16. [torch.FloatTensor of size 4]
  17. ,
  18.  2
  19.  0
  20.  0
  21.  0
  22. [torch.LongTensor of size 4]
  23. )
  1. torch.max(input, other, out=None) → Tensor

输入 input 每一个元素和对应的比较张量 other 进行比较, 留下较大的元素 max.

要比较的张量 input 与比较张量 other 不必大小一致, 但它们一定要能 broadcastable .

参数：

  • input (Tensor) – 要比较张量 Tensor
  • other (Tensor) – 比较张量 Tensor
  • out (Tensor, 可选) – 输出张量 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.3869
  5.  0.3912
  6. -0.8634
  7. -0.5468
  8. [torch.FloatTensor of size 4]
  10. >>> b = torch.randn(4)
  11. >>> b
  13.  1.0067
  14. -0.8010
  15.  0.6258
  16.  0.3627
  17. [torch.FloatTensor of size 4]
  19. >>> torch.max(a, b)
  21.  1.3869
  22.  0.3912
  23.  0.6258
  24.  0.3627
  25. [torch.FloatTensor of size 4]
  1. torch.min()
  1. torch.min(input) → float

返回输入张量 input 所有元素的最小值.

参数：input (Tensor) – 输入 Tensor

示例：

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  4.  0.4729 -0.2266 -0.2085
  5. [torch.FloatTensor of size 1x3]
  7. >>> torch.min(a)
  8. -0.22663167119026184
  1. torch.min(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor)

返回输入张量 input 在给定维度 dim 下每行元素的最小值. 其中第二个返回值是每个被找出的最小值的索引位置 ( argmin ) .

如果 keepdim 是 True, 输出张量的大小与输入张量 input 相同, 除了维数 dim 是 1 . 另外, dim 被挤压 (参看 torch.squeeze() ), 导致输出张量比输入张量 input 少一维.

参数：

  • input (Tensor) – 输入张量 Tensor
  • dim (int) – 要减少的维度
  • keepdim (bool) – 输出张量的维度 dim 保持与否
  • out (tuple, 可选) – 两个输出张量的结果元组 (min, min_indices)

示例：

  1. >> a = torch.randn(4, 4)
  2. >> a
  4. 0.0692  0.3142  1.2513 -0.5428
  5. 0.9288  0.8552 -0.2073  0.6409
  6. 1.0695 -0.0101 -2.4507 -1.2230
  7. 0.7426 -0.7666  0.4862 -0.6628
  8. torch.FloatTensor of size 4x4]
  10. >> torch.min(a, 1)
  12. 0.5428
  13. 0.2073
  14. 2.4507
  15. 0.7666
  16. torch.FloatTensor of size 4]
  18. 3
  19. 2
  20. 2
  21. 1
  22. torch.LongTensor of size 4]
  1. torch.min(input, other, out=None) → Tensor

输入 input 每一个元素和对应的比较张量 other 进行比较, 留下较小的元素 min .

要比较的张量 input 与比较张量 other 不必尺寸一致, 但它们一定要能广播 broadcastable .

参数：

  • input (Tensor) – 第一个张量 Tensor
  • other (Tensor) – 第二个张量 Tensor
  • out (Tensor, 可选) – 输出的张量 Tensor

示例：

  1. >>> a = torch.randn(4)
  2. >>> a
  4.  1.3869
  5.  0.3912
  6. -0.8634
  7. -0.5468
  8. [torch.FloatTensor of size 4]
  10. >>> b = torch.randn(4)
  11. >>> b
  13.  1.0067
  14. -0.8010
  15.  0.6258
  16.  0.3627
  17. [torch.FloatTensor of size 4]
  19. >>> torch.min(a, b)
  21.  1.0067
  22. -0.8010
  23. -0.8634
  24. -0.5468
  25. [torch.FloatTensor of size 4]
  1. torch.ne(input, other, out=None) → Tensor

逐元素比较 input 和 other , 即是否 tensor != other 如果两个张量有相同的形状和元素值, 则返回 True , 否则 False .

第二个参数可以为一个数或形状广播 broadcastable 为和第一个参数相同类型的张量.

参数：

  • input (Tensor) – 待对比的张量
  • other (Tensor 或 float) – 对比的张量或 float 值
  • out (Tensor, 可选) – 输出张量. 必须为 ByteTensor 或者与第一个参数 tensor 相同类型.

返回值：一个 torch.ByteTensor 张量, 包含了每个位置的比较结果 (是否 input != other ) .

返回类型：Tensor

示例：

  1. >>> torch.ne(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
  2.  0  1
  3.  1  0
  4. [torch.ByteTensor of size 2x2]
  1. torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor)

对输入张量 input 沿着指定维按升序排序.

如果不给定 dim ,则默认为输入的最后一维.

如果指定参数 descending 为 True , 则按降序排序.

返回元组 (sorted_tensor, sorted_indices) , sorted_indices 为原始输入中的下标.

参数：

  • input (Tensor) – 要对比的张量
  • dim (int, 可选) – 沿着此维排序
  • descending (bool, 可选) – 布尔值, 控制升降排序
  • out (tuple, 可选) – 输出张量. 必须为 ByteTensor 或者与第一个参数 tensor 相同类型.

示例：

  1. >>> x = torch.randn(3, 4)
  2. >>> sorted, indices = torch.sort(x)
  3. >>> sorted
  5. -1.6747  0.0610  0.1190  1.4137
  6. -1.4782  0.7159  1.0341  1.3678
  7. -0.3324 -0.0782  0.3518  0.4763
  8. [torch.FloatTensor of size 3x4]
  10. >>> indices
  12.  0  1  3  2
  13.  2  1  0  3
  14.  3  1  0  2
  15. [torch.LongTensor of size 3x4]
  17. >>> sorted, indices = torch.sort(x, 0)
  18. >>> sorted
  20. -1.6747 -0.0782 -1.4782 -0.3324
  21.  0.3518  0.0610  0.4763  0.1190
  22.  1.0341  0.7159  1.4137  1.3678
  23. [torch.FloatTensor of size 3x4]
  25. >>> indices
  27.  0  2  1  2
  28.  2  0  2  0
  29.  1  1  0  1
  30. [torch.LongTensor of size 3x4]
  1. 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 个值被排序.

参数：

  • input (Tensor) – 输入张量
  • k (int) – “top-k” 中的 k
  • dim (int, 可选) – 排序的维
  • largest (bool, 可选) – 布尔值, 控制返回最大或最小值
  • sorted (bool, 可选) – 布尔值, 控制返回值是否排序
  • out (tuple, 可选) – 可选输出张量 (Tensor, LongTensor) output buffers

示例：

  1. >>> x = torch.arange(1, 6)
  2. >>> x
  4.  1
  5.  2
  6.  3
  7.  4
  8.  5
  9. [torch.FloatTensor of size 5]
  11. >>> torch.topk(x, 3)
  12. (
  13.  5
  14.  4
  15.  3
  16. [torch.FloatTensor of size 3]
  17. ,
  18.  4
  19.  3
  20.  2
  21. [torch.LongTensor of size 3]
  22. )
  23. >>> torch.topk(x, 3, 0, largest=False)
  24. (
  25.  1
  26.  2
  27.  3
  28. [torch.FloatTensor of size 3]
  29. ,
  30.  0
  31.  1
  32.  2
  33. [torch.LongTensor of size 3]
  34. )

Other Operations (其它操作)

  1. torch.cross(input, other, dim=-1, out=None) → Tensor

返回沿着维度 dim 上, 两个张量 input 和 other 的向量积 (叉积), input 和 other 必须有相同的形状, 且指定的 dim 维上 size 必须为 3.

如果不指定 dim, 则默认为第一个尺度为 3 的维.

参数：

  • input (Tensor) – 输入 Tensor
  • other (Tensor) – 第二个输入 Tensor
  • dim (int, 可选) – 沿着此维进行叉积操作.
  • out (Tensor, 可选) – 结果 Tensor

示例：

  1. >>> a = torch.randn(4, 3)
  2. >>> a
  4. -0.6652 -1.0116 -0.6857
  5.  0.2286  0.4446 -0.5272
  6.  0.0476  0.2321  1.9991
  7.  0.6199  1.1924 -0.9397
  8. [torch.FloatTensor of size 4x3]
  10. >>> b = torch.randn(4, 3)
  11. >>> b
  13. -0.1042 -1.1156  0.1947
  14.  0.9947  0.1149  0.4701
  15. -1.0108  0.8319 -0.0750
  16.  0.9045 -1.3754  1.0976
  17. [torch.FloatTensor of size 4x3]
  19. >>> torch.cross(a, b, dim=1)
  21. -0.9619  0.2009  0.6367
  22.  0.2696 -0.6318 -0.4160
  23. -1.6805 -2.0171  0.2741
  24.  0.0163 -1.5304 -1.9311
  25. [torch.FloatTensor of size 4x3]
  27. >>> torch.cross(a, b)
  29. -0.9619  0.2009  0.6367
  30.  0.2696 -0.6318 -0.4160
  31. -1.6805 -2.0171  0.2741
  32.  0.0163 -1.5304 -1.9311
  33. [torch.FloatTensor of size 4x3]
  1. torch.diag(input, diagonal=0, out=None) → Tensor
  • 如果输入是一个向量( 1D 张量), 则返回一个以 input 为对角线元素的 2D 方阵.
  • 如果输入是一个矩阵( 2D 张量), 则返回一个包含 input 对角线元素的1D张量.

参数 diagonal 指定对角线:

  • diagonal = 0, 主对角线.
  • diagonal > 0, 主对角线之上.
  • diagonal < 0, 主对角线之下.

参数：

  • input (Tensor) – 输入 Tensor
  • diagonal (int, 可选) – 指定对角线
  • out (Tensor, 可选) – 输出 Tensor

示例：

获得以 input 为对角线的方阵:

  1. >>> a = torch.randn(3)
  2. >>> a
  4.  1.0480
  5. -2.3405
  6. -1.1138
  7. [torch.FloatTensor of size 3]
  9. >>> torch.diag(a)
  11.  1.0480  0.0000  0.0000
  12.  0.0000 -2.3405  0.0000
  13.  0.0000  0.0000 -1.1138
  14. [torch.FloatTensor of size 3x3]
  16. >>> torch.diag(a, 1)
  18.  0.0000  1.0480  0.0000  0.0000
  19.  0.0000  0.0000 -2.3405  0.0000
  20.  0.0000  0.0000  0.0000 -1.1138
  21.  0.0000  0.0000  0.0000  0.0000
  22. [torch.FloatTensor of size 4x4]

获得给定矩阵的第k条对角线:

  1. >>> a = torch.randn(3, 3)
  2. >>> a
  4. -1.5328 -1.3210 -1.5204
  5.  0.8596  0.0471 -0.2239
  6. -0.6617  0.0146 -1.0817
  7. [torch.FloatTensor of size 3x3]
  9. >>> torch.diag(a, 0)
  11. -1.5328
  12.  0.0471
  13. -1.0817
  14. [torch.FloatTensor of size 3]
  16. >>> torch.diag(a, 1)
  18. -1.3210
  19. -0.2239
  20. [torch.FloatTensor of size 2]
  1. torch.histc(input, bins=100, min=0, max=0, out=None) → Tensor

计算输入张量的直方图.

以 min 和 max 为 range 边界, 将其均分成 bins 个直条, 然后将排序好的数据划分到各个直条 (bins) 中. 如果 min 和 max 都为 0, 则利用数据中的最大最小值作为边界.

参数：

  • input (Tensor) – 输入张量
  • bins (int) – 直方图 bins (直条)的个数(默认100个)
  • min (int) – range 的下边界(包含)
  • max (int) – range 的上边界(包含)
  • out (Tensor, 可选) – 结果张量

返回值：直方图

返回类型：Tensor

示例：

  1. >>> torch.histc(torch.FloatTensor([1, 2, 1]), bins=4, min=0, max=3)
  2. FloatTensor([0, 2, 1, 0])
  1. torch.renorm(input, p, dim, maxnorm, out=None) → Tensor

返回一个张量, 包含规范化后的各个子张量, 使得沿着 dim 维划分的各子张量的 p 范数小于 maxnorm

注解：

如果 p 范数的值小于 maxnorm, 则当前子张量不需要修改.

参数：

  • input (Tensor) – 输入 Tensor
  • p (float) – 范数的 p
  • dim (int) – 沿着此维切片, 得到张量子集
  • maxnorm (float) – 每个子张量的范数的最大值
  • out (Tensor, 可选) – 结果张量

示例：

  1. >>> x = torch.ones(3, 3)
  2. >>> x[1].fill_(2)
  3. >>> x[2].fill_(3)
  4. >>> x
  6.  1  1  1
  7.  2  2  2
  8.  3  3  3
  9. [torch.FloatTensor of size 3x3]
  11. >>> torch.renorm(x, 1, 0, 5)
  13.  1.0000  1.0000  1.0000
  14.  1.6667  1.6667  1.6667
  15.  1.6667  1.6667  1.6667
  16. [torch.FloatTensor of size 3x3]
  1. torch.trace(input) → float

返回输入 2 维矩阵对角线元素的和(迹).

示例：

  1. >>> x = torch.arange(1, 10).view(3, 3)
  2. >>> x
  4.  1  2  3
  5.  4  5  6
  6.  7  8  9
  7. [torch.FloatTensor of size 3x3]
  9. >>> torch.trace(x)
  10. 15.0
  1. torch.tril(input, diagonal=0, out=None) → Tensor

返回一个张量, 包含输入矩阵 ( 2D 张量)的下三角部分, 其余部分被设为 0.

这里所说的下三角部分为矩阵指定对角线 diagonal 在线里的和下面的元素.

参数 diagonal 控制对角线.

  • diagonal = 0, 主对角线.
  • diagonal > 0, 主对角线之上.
  • diagonal < 0, 主对角线之下.

参数：

  • input (Tensor) – 输入 Tensor
  • diagonal (int, 可选) – 指定对角线
  • out (Tensor, 可选) – 输出 Tensor

示例：

  1. >>> a = torch.randn(3,3)
  2. >>> a
  4.  1.3225  1.7304  1.4573
  5. -0.3052 -0.3111 -0.1809
  6.  1.2469  0.0064 -1.6250
  7. [torch.FloatTensor of size 3x3]
  9. >>> torch.tril(a)
  11.  1.3225  0.0000  0.0000
  12. -0.3052 -0.3111  0.0000
  13.  1.2469  0.0064 -1.6250
  14. [torch.FloatTensor of size 3x3]
  16. >>> torch.tril(a, diagonal=1)
  18.  1.3225  1.7304  0.0000
  19. -0.3052 -0.3111 -0.1809
  20.  1.2469  0.0064 -1.6250
  21. [torch.FloatTensor of size 3x3]
  23. >>> torch.tril(a, diagonal=-1)
  25.  0.0000  0.0000  0.0000
  26. -0.3052  0.0000  0.0000
  27.  1.2469  0.0064  0.0000
  28. [torch.FloatTensor of size 3x3]
  1. torch.triu(input, diagonal=0, out=None) → Tensor

返回一个张量, 包含输入矩阵 ( 2D 张量)的上三角部分, 其余部分被设为 0.

这里所说的下三角部分为矩阵指定对角线 diagonal 在线里的和上面的元素.

参数 diagonal 控制对角线.

  • diagonal = 0, 主对角线.
  • diagonal > 0, 主对角线之上.
  • diagonal < 0, 主对角线之下.

参数：

  • input (Tensor) – 输入 Tensor
  • diagonal (int, 可选) – 指定对角线
  • out (Tensor, 可选) – 输出 Tensor

示例：

  1. >>> a = torch.randn(3,3)
  2. >>> a
  4.  1.3225  1.7304  1.4573
  5. -0.3052 -0.3111 -0.1809
  6.  1.2469  0.0064 -1.6250
  7. [torch.FloatTensor of size 3x3]
  9. >>> torch.triu(a)
  11.  1.3225  1.7304  1.4573
  12.  0.0000 -0.3111 -0.1809
  13.  0.0000  0.0000 -1.6250
  14. [torch.FloatTensor of size 3x3]
  16. >>> torch.triu(a, diagonal=1)
  18.  0.0000  1.7304  1.4573
  19.  0.0000  0.0000 -0.1809
  20.  0.0000  0.0000  0.0000
  21. [torch.FloatTensor of size 3x3]
  23. >>> torch.triu(a, diagonal=-1)
  25.  1.3225  1.7304  1.4573
  26. -0.3052 -0.3111 -0.1809
  27.  0.0000  0.0064 -1.6250
  28. [torch.FloatTensor of size 3x3]

BLAS and LAPACK Operations (BLAS和LAPACK操作)

  1. torch.addbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor

执行保存在 batch1 和 batch2 中的矩阵的批量点乘, 伴随着一个减少的相加步骤 (所有的矩阵乘法沿第一维累加). mat 被相加到最终的结果中.

batch1 和 batch2 必须是三维的张量, 且每个包含相同数量的矩阵.

如果 batch1 是一个 b x n x m 的张量, batch2 是一个 b x m x p的张量, 那么 mat 必须是 broadcastable 且是一个 n x p 的张量, 同时 attr:out 将是一个 n x p 的张量.

换句话说, res = (beta * M) + (alpha * sum(batch1_i @ batch2_i, i = 0, b))

对于 FloatTensor 或者 DoubleTensor 类型的输入, 参数 beta 和 alpha 必须是实数, 否则他们应该是整数.

参数：

  • beta (Number, 可选) – 作用于 mat 的乘子 (系数)
  • mat (Tensor) – 要被相加的矩阵
  • alpha (Number, 可选) – 作用于 batch1 @ batch2 的乘子
  • batch1 (Tensor) – 要相乘的第一批矩阵
  • batch2 (Tensor) – 要相乘的第二批矩阵
  • out (Tensor, 可选) – 输出的张量结果

示例：

  1. >>> M = torch.randn(3, 5)
  2. >>> batch1 = torch.randn(10, 3, 4)
  3. >>> batch2 = torch.randn(10, 4, 5)
  4. >>> torch.addbmm(M, batch1, batch2)
  6.  -3.1162  11.0071   7.3102   0.1824  -7.6892
  7.  1.8265   6.0739   0.4589  -0.5641  -5.4283
  8.  -9.3387  -0.1794  -1.2318  -6.8841  -4.7239
  9. [torch.FloatTensor of size 3x5]
  1. torch.addmm(beta=1, mat, alpha=1, mat1, mat2, out=None) → Tensor

执行矩阵 mat1 和 mat2 的相乘. 矩阵 mat 将与相乘的最终计算结果相加.

如果 mat1 是一个 n x m 的张量, mat2 是一个 m x p的张量, 那么 mat 必须是 broadcastable 且是一个 n x p 的张量, 同时 attr:out 将是一个 n x p 的张量.

换句话说, out = (beta * M) + (alpha * mat1 @ mat2)

对于 FloatTensor 或者 DoubleTensor 类型的输入, 参数 beta 和 alpha 必须是实数, 否则他们应该是整数.

参数：

  • beta (Number, 可选) – 作用于mat的乘子
  • mat (Tensor) – 要被相加的矩阵
  • alpha (Number, 可选) – 作用于mat1 @ mat2的乘子
  • mat1 (Tensor) – 要相乘的第一个矩阵
  • mat2 (Tensor) – 要相乘的第二个矩阵
  • out (Tensor, 可选) – 输出结果

示例：

  1. >>> M = torch.randn(2, 3)
  2. >>> mat1 = torch.randn(2, 3)
  3. >>> mat2 = torch.randn(3, 3)
  4. >>> torch.addmm(M, mat1, mat2)
  6. -0.4095 -1.9703  1.3561
  7.  5.7674 -4.9760  2.7378
  8. [torch.FloatTensor of size 2x3]
  1. torch.addmv(beta=1, tensor, alpha=1, mat, vec, out=None) → Tensor

执行矩阵 mat 和向量 vec 的相乘. 矩阵 tensor 将与相乘的最终计算结果相加.

如果 mat 是一个 n x m 的张量, vec 是一个长度为 m 的一维张量, 那么 :tensor 必须是 broadcastable 且是一个长度为 n 的一维张量, 同时 attr:out 将是一个长度为 n 的一维张量.

alpha 和 beta 分别是 mat * vec 和 tensor 的缩放因子.

换句话说, out = (beta * tensor) + (alpha * (mat @ vec2))

对于 FloatTensor 或者 DoubleTensor 类型的输入, 参数 beta 和 alpha 必须是实数, 否则他们应该是整数.

参数：

  • beta (Number, 可选) – 作用于 tensor 的乘子
  • tensor (Tensor) – 要被相加的向量
  • alpha (Number, 可选) – 作用于 mat @ vec 的乘子
  • mat (Tensor) – 要被相乘的矩阵
  • vec (Tensor) – 要被要乘的向量
  • out (Tensor, 可选) – 输出结果

示例：

  1. >>> M = torch.randn(2)
  2. >>> mat = torch.randn(2, 3)
  3. >>> vec = torch.randn(3)
  4. >>> torch.addmv(M, mat, vec)
  6. -2.0939
  7. -2.2950
  8. [torch.FloatTensor of size 2]
  1. torch.addr(beta=1, mat, alpha=1, vec1, vec2, out=None) → Tensor

执行向量 vec1 和 vec2 的外积, 并把外积计算结果与矩阵 mat 相加.

可选值 beta 和 alpha 是标量, 分别与 mat 和 (vec1 \otimes vec2) 相乘.

换句话说, out = (beta * mat) + (alpha * vec1 \otimes vec2)

如果 vec1 是一个长度为 n 的向量, vec2 是一个长度为 m 的向量, 那么 mat 必须是 broadcastable 且是一个大小为 n x m 的矩阵, 同时 out 将是一个大小为 n x m 的矩阵.

对于 FloatTensor 或者 DoubleTensor 类型的输入, 参数 beta 和 alpha 必须是实数, 否则他们应该是整数.

参数：

  • beta (Number, 可选) – 作用于 mat 的乘子
  • mat (Tensor) – 要被相加的矩阵
  • alpha (Number, 可选) – 作用于 vec1 和 vec2 外积计算结果的乘子
  • vec1 (Tensor) – 外积计算的第一个向量
  • vec2 (Tensor) – 外积计算的第二个向量
  • out (Tensor, 可选) – 输出结果

示例：

  1. >>> vec1 = torch.arange(1, 4)
  2. >>> vec2 = torch.arange(1, 3)
  3. >>> M = torch.zeros(3, 2)
  4. >>> torch.addr(M, vec1, vec2)
  5.  1  2
  6.  2  4
  7.  3  6
  8. [torch.FloatTensor of size 3x2]
  1. torch.baddbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor

执行保存在 batch1 和 batch2 中的矩阵的批量点乘. mat 被相加到最终的结果中.

batch1 和 batch2 必须是三维的张量, 且每个包含相同数量的矩阵.

如果 batch1 是一个 b x n x m 的张量, batch2 是一个 b x m x p的张量, 那么 mat 必须是 broadcastable 且是一个 b x n x p 的张量, 同时 attr:out 将是一个 b x n x p 的张量.

换句话说, res_i = (beta * M_i) + (alpha * batch1_i \times batch2_i)

对于 FloatTensor 或者 DoubleTensor 类型的输入, 参数 beta 和 alpha 必须是实数, 否则他们应该是整数.

参数：

  • beta (Number, 可选) – 作用于 mat 的乘子 (系数)
  • mat (Tensor) – 要被相加的张量
  • alpha (Number, 可选) – 作用于 batch1 @ batch2 的乘子
  • batch1 (Tensor) – 要相乘的第一批矩阵
  • batch2 (Tensor) – 要相乘的第二批矩阵
  • out (Tensor, 可选) – 输出的张量结果

示例：

  1. >>> M = torch.randn(10, 3, 5)
  2. >>> batch1 = torch.randn(10, 3, 4)
  3. >>> batch2 = torch.randn(10, 4, 5)
  4. >>> torch.baddbmm(M, batch1, batch2).size()
  5. torch.Size([10, 3, 5])
  1. torch.bmm(batch1, batch2, out=None) → Tensor

执行保存在 batch1 和 batch2 中的矩阵的批量点乘.

batch1 和 batch2 必须是三维的张量, 且每个包含相同数量的矩阵.

如果 batch1 是一个 b x n x m 的张量, batch2 是一个 b x m x p 的张量, out 将是一个 b x n x p 的张量.

注解：

这个函数不能参考 broadcast]($notes-broadcasting.html#broadcasting-semantics). 对于广播矩阵相乘, 参见 [torch.matmul().

参数：

  • batch1 (Tensor) – 要相乘的第一批矩阵
  • batch2 (Tensor) – 要相乘的第二批矩阵
  • out (Tensor, 可选) – 输出结果

示例：

  1. >>> batch1 = torch.randn(10, 3, 4)
  2. >>> batch2 = torch.randn(10, 4, 5)
  3. >>> res = torch.bmm(batch1, batch2)
  4. >>> res.size()
  5. torch.Size([10, 3, 5])
  1. torch.btrifact(A, info=None, pivot=True) → Tensor, IntTensor

批量 LU 分解.

返回一个包含 LU 分解和枢轴的元组. 对于每个 minibatch 示例, 如果分解成功, 可选参数 info 将提供分解信息. info 的值来自 dgetrf, 若是非零值, 则表示有错误发生. 如果 cuda 被使用的话, 具体的值来自 cublas, 否则来自 LAPACK. 如果设置了 pivot, 那么旋转操作将被执行.

参数：A (Tensor) – 要分解的张量.

示例：

  1. >>> A = torch.randn(2, 3, 3)
  2. >>> A_LU = A.btrifact()
  1. torch.btrisolve(b, LU_data, LU_pivots) → Tensor

批量 LU 解.

返回线性系统 Ax = b 的 LU 解.

参数：

  • b (Tensor) – RHS tensor.
  • LU_data (Tensor) – Pivoted LU factorization of A from btrifact.
  • LU_pivots (IntTensor) – Pivots of the LU factorization.

示例：

  1. >>> A = torch.randn(2, 3, 3)
  2. >>> b = torch.randn(2, 3)
  3. >>> A_LU = torch.btrifact(A)
  4. >>> x = b.btrisolve(*A_LU)
  5. >>> torch.norm(A.bmm(x.unsqueeze(2)) - b)
  6. 6.664001874625056e-08
  1. torch.dot(tensor1, tensor2) → float

计算两个张量的点乘 (内积).

注解：

这个函数不支持 broadcast.

示例：

  1. >>> torch.dot(torch.Tensor([2, 3]), torch.Tensor([2, 1]))
  2. 7.0
  1. torch.eig(a, eigenvectors=False, out=None) -> (Tensor, Tensor)

计算实数方阵的特征值和特征向量.

参数：

  • a (Tensor) – 一个要被计算特征值与特征向量的方阵
  • eigenvectors (bool) – 若为 True, 表示特征值与特征向量都被计算. 否则, 仅计算特征值.
  • out (tuple, 可选) – 输出张量

返回值：包含以下的元组：

  • e (Tensor): a 的左特征值
  • v (Tensor): 如果 eigenvectors 为 True, 表示 a 的特征向量; 否则是一个空的张量

返回类型：返回一个元组, (Tensor, Tensor)

  1. torch.gels(B, A, out=None) → Tensor

计算秩为 m 的， 大小为 m x n 的矩阵 A 最小二乘和最小范数问题的解

如果 !m >= n](img/tex-67ab86856a95fdd869cf2a0fff67d8be.gif), [gels() 求解最小二乘问题:

\begin{array}{ll} \mbox{minimize} & \|AX-B\|_F. \end{array}

如果 !m < n](img/tex-ad3a40ab7b4c9be133873408eb36bcc1.gif), [gels() 求解最小范数问题:

\begin{array}{ll} \mbox{minimize} & \|X\|_F & \mbox{subject to} & AX = B. \end{array}

返回的矩阵 X 的头 n 行包含解信息. 其余行包含剩余信息: 从第 n 行开始的每列的 euclidean 范数, 是对应列的剩余.

参数：

  • B (Tensor) – The matrix B
  • A (Tensor) – The m by n matrix A
  • out (tuple, 可选) – Optional destination tensor

返回值：包含以下的元组：

  • X (Tensor): 最小二乘解
  • qr (Tensor): QR 分解的详细信息

返回类型：(Tensor, Tensor)

注解：

不管输入矩阵的步长如何, 返回来的矩阵将总是被转置. 也就是, 他们的步长是 (1, m) 而不是 (m, 1).

示例：

  1. >>> A = torch.Tensor([[1, 1, 1],
  2. ...                   [2, 3, 4],
  3. ...                   [3, 5, 2],
  4. ...                   [4, 2, 5],
  5. ...                   [5, 4, 3]])
  6. >>> B = torch.Tensor([[-10, -3],
  7.  [ 12, 14],
  8.  [ 14, 12],
  9.  [ 16, 16],
  10.  [ 18, 16]])
  11. >>> X, _ = torch.gels(B, A)
  12. >>> X
  13. 2.0000  1.0000
  14. 1.0000  1.0000
  15. 1.0000  2.0000
  16. [torch.FloatTensor of size 3x2]
  1. torch.geqrf(input, out=None) -> (Tensor, Tensor)

这是直接调用 LAPACK 的低层函数.

通常您应该使用 torch.qr() 来代替之.

计算 input 的 QR 分解, 但不构造 Q 和 R 作为显示分开的矩阵.

然而, 这样直接调用 LAPACK 的底层函数 ?geqrf, 会产生一连串的 ‘elementary reflectors’.

更多信息请参见 LAPACK documentation .

参数：

  • input (Tensor) – the input matrix
  • out (tuple, 可选) – The result tuple of (Tensor, Tensor)
  1. torch.ger(vec1, vec2, out=None) → Tensor

计算 vec1 和 vec2 的外积. 如果 vec1 是一个长度为 n 的向量, vec2 是一个长度为 m 的向量, 那么 out 必须是一个 n x m 的矩阵.

注解：

这个函数不支持 broadcast.

参数：

  • vec1 (Tensor) – 1D input vector
  • vec2 (Tensor) – 1D input vector
  • out (Tensor, 可选) – optional output matrix

示例：

  1. >>> v1 = torch.arange(1, 5)
  2. >>> v2 = torch.arange(1, 4)
  3. >>> torch.ger(v1, v2)
  5.  1   2   3
  6.  2   4   6
  7.  3   6   9
  8.  4   8  12
  9. [torch.FloatTensor of size 4x3]
  1. torch.gesv(B, A, out=None) -> (Tensor, Tensor)

X, LU = torch.gesv(B, A) , 该函数返回线性系统 AX = B 的解.

LU 包含 A 的 LU 分解因子 L 和 U.

A 必须是方阵, 且是非奇异的 (2维可逆张量).

如果 A 是一个 m x m 矩阵, B 是一个 m x k 的矩阵, 那么结果 LU 的大小为 m x m, X 的大小为 m x k .

注解：

Irrespective of the original strides, the returned matrices X and LU will be transposed, i.e. with strides (1, m) instead of (m, 1).

参数：

  • B (Tensor) – input matrix of m x k dimensions
  • A (Tensor) – input square matrix of m x m dimensions
  • out (Tensor, 可选) – optional output matrix

示例：

  1. >>> A = torch.Tensor([[6.80, -2.11,  5.66,  5.97,  8.23],
  2. ...                   [-6.05, -3.30,  5.36, -4.44,  1.08],
  3. ...                   [-0.45,  2.58, -2.70,  0.27,  9.04],
  4. ...                   [8.32,  2.71,  4.35,  -7.17,  2.14],
  5. ...                   [-9.67, -5.14, -7.26,  6.08, -6.87]]).t()
  6. >>> B = torch.Tensor([[4.02,  6.19, -8.22, -7.57, -3.03],
  7. ...                   [-1.56,  4.00, -8.67,  1.75,  2.86],
  8. ...                   [9.81, -4.09, -4.57, -8.61,  8.99]]).t()
  9. >>> X, LU = torch.gesv(B, A)
  10. >>> torch.dist(B, torch.mm(A, X))
  11. 9.250057093890353e-06
  1. torch.inverse(input, out=None) → Tensor

计算方阵 input 的逆.

注解：

Irrespective of the original strides, the returned matrix will be transposed, i.e. with strides (1, m) instead of (m, 1)

参数：

  • input (Tensor) – the input 2D square Tensor
  • out (Tensor, 可选) – the optional output Tensor

示例：

  1. >>> x = torch.rand(10, 10)
  2. >>> x
  4.  0.7800  0.2267  0.7855  0.9479  0.5914  0.7119  0.4437  0.9131  0.1289  0.1982
  5.  0.0045  0.0425  0.2229  0.4626  0.6210  0.0207  0.6338  0.7067  0.6381  0.8196
  6.  0.8350  0.7810  0.8526  0.9364  0.7504  0.2737  0.0694  0.5899  0.8516  0.3883
  7.  0.6280  0.6016  0.5357  0.2936  0.7827  0.2772  0.0744  0.2627  0.6326  0.9153
  8.  0.7897  0.0226  0.3102  0.0198  0.9415  0.9896  0.3528  0.9397  0.2074  0.6980
  9.  0.5235  0.6119  0.6522  0.3399  0.3205  0.5555  0.8454  0.3792  0.4927  0.6086
  10.  0.1048  0.0328  0.5734  0.6318  0.9802  0.4458  0.0979  0.3320  0.3701  0.0909
  11.  0.2616  0.3485  0.4370  0.5620  0.5291  0.8295  0.7693  0.1807  0.0650  0.8497
  12.  0.1655  0.2192  0.6913  0.0093  0.0178  0.3064  0.6715  0.5101  0.2561  0.3396
  13.  0.4370  0.4695  0.8333  0.1180  0.4266  0.4161  0.0699  0.4263  0.8865  0.2578
  14. [torch.FloatTensor of size 10x10]
  16. >>> x = torch.rand(10, 10)
  17. >>> y = torch.inverse(x)
  18. >>> z = torch.mm(x, y)
  19. >>> z
  21.  1.0000  0.0000  0.0000 -0.0000  0.0000  0.0000  0.0000  0.0000 -0.0000 -0.0000
  22.  0.0000  1.0000 -0.0000  0.0000  0.0000  0.0000 -0.0000 -0.0000 -0.0000 -0.0000
  23.  0.0000  0.0000  1.0000 -0.0000 -0.0000  0.0000  0.0000  0.0000 -0.0000 -0.0000
  24.  0.0000  0.0000  0.0000  1.0000  0.0000  0.0000  0.0000 -0.0000 -0.0000  0.0000
  25.  0.0000  0.0000 -0.0000 -0.0000  1.0000  0.0000  0.0000 -0.0000 -0.0000 -0.0000
  26.  0.0000  0.0000  0.0000 -0.0000  0.0000  1.0000 -0.0000 -0.0000 -0.0000 -0.0000
  27.  0.0000  0.0000  0.0000 -0.0000  0.0000  0.0000  1.0000  0.0000 -0.0000  0.0000
  28.  0.0000  0.0000 -0.0000 -0.0000  0.0000  0.0000 -0.0000  1.0000 -0.0000  0.0000
  29. -0.0000  0.0000 -0.0000 -0.0000  0.0000  0.0000 -0.0000 -0.0000  1.0000 -0.0000
  30. -0.0000  0.0000 -0.0000 -0.0000 -0.0000  0.0000 -0.0000 -0.0000  0.0000  1.0000
  31. [torch.FloatTensor of size 10x10]
  33. >>> torch.max(torch.abs(z - torch.eye(10))) # Max nonzero
  34. 5.096662789583206e-07
  1. torch.matmul(tensor1, tensor2, out=None)

Matrix product of two tensors.

The behavior depends on the dimensionality of the tensors as follows:

  • If both tensors are 1-dimensional, the dot product (scalar) is returned.
  • If both arguments are 2-dimensional, the matrix-matrix product is returned.
  • If the first argument is 1-dimensional and the second argument is 2-dimensional, a 1 is prepended to its dimension for the purpose of the matrix multiply. After the matrix multiply, the prepended dimension is removed.
  • If the first argument is 2-dimensional and the second argument is 1-dimensional, the matrix-vector product is returned.
  • If both arguments are at least 1-dimensional and at least one argument is N-dimensional (where N > 2), then a batched matrix multiply is returned. If the first argument is 1-dimensional, a 1 is prepended to its dimension for the purpose of the batched matrix multiply and removed after. If the second argument is 1-dimensional, a 1 is appended to its dimension for the purpose of the batched matrix multiple and removed after. The non-matrix (i.e. batch) dimensions are broadcasted (and thus must be broadcastable). For example, if tensor1 is a j x 1 x n x m Tensor and tensor2 is a k x m x p Tensor, out will be an j x k x n x p Tensor.

注解：

The 1-dimensional dot product version of this function does not support an out parameter.

参数：

  • tensor1 (Tensor) – First tensor to be multiplied
  • tensor2 (Tensor) – Second tensor to be multiplied
  • out (Tensor, 可选) – Output tensor
  1. torch.mm(mat1, mat2, out=None) → Tensor

执行 mat1 和 mat2 的矩阵乘法.

如果 mat1 是一个 n x m 张量, mat2 是一个 m x p 张量, out 将是一个 n x p 张量.

注解：

这个函数不支持 broadcast]($notes-broadcasting.html#broadcasting-semantics). 要使用支持广播矩阵乘法, 参见 [torch.matmul().

参数：

  • mat1 (Tensor) – First matrix to be multiplied
  • mat2 (Tensor) – Second matrix to be multiplied
  • out (Tensor, 可选) – Output tensor

示例：

  1. >>> mat1 = torch.randn(2, 3)
  2. >>> mat2 = torch.randn(3, 3)
  3. >>> torch.mm(mat1, mat2)
  4.  0.0519 -0.3304  1.2232
  5.  4.3910 -5.1498  2.7571
  6. [torch.FloatTensor of size 2x3]
  1. torch.mv(mat, vec, out=None) → Tensor

执行矩阵 mat 与向量 vec 的乘法操作.

如果 mat 是一个 n x m 张量, vec 是一个大小为 m 的一维张量, out 将是一个大小为 n 的张量.

注解：

这个函数不支持 broadcast.

参数：

  • mat (Tensor) – matrix to be multiplied
  • vec (Tensor) – vector to be multiplied
  • out (Tensor, 可选) – Output tensor

示例：

  1. >>> mat = torch.randn(2, 3)
  2. >>> vec = torch.randn(3)
  3. >>> torch.mv(mat, vec)
  4. -2.0939
  5. -2.2950
  6. [torch.FloatTensor of size 2]
  1. torch.orgqr()
  1. torch.ormqr()
  1. torch.potrf(a, out=None)

potrf(a, upper, out=None)

计算半正定矩阵 a: 的 Cholesky 分解. 返回结果 u, 若 upper 设为 True 或未提供时, u 是一个上三角矩阵, 使得 a = u^T u 成立; 若 upper 设为 False, u 是一个下三角矩阵, 使得 a = u u^T 成立.

参数：

  • a (Tensor) – the input 2D Tensor, a symmetric positive semidefinite matrix
  • upper (bool, 可选) – Return upper (default) or lower triangular matrix
  • out (Tensor, 可选) – A Tensor for u

示例：

  1. >>> a = torch.randn(3,3)
  2. >>> a = torch.mm(a, a.t()) # make symmetric positive definite
  3. >>> u = torch.potrf(a)
  4. >>> a
  6.  2.3563  3.2318 -0.9406
  7.  3.2318  4.9557 -2.1618
  8. -0.9406 -2.1618  2.2443
  9. [torch.FloatTensor of size 3x3]
  11. >>> u
  13.  1.5350  2.1054 -0.6127
  14.  0.0000  0.7233 -1.2053
  15.  0.0000  0.0000  0.6451
  16. [torch.FloatTensor of size 3x3]
  18. >>> torch.mm(u.t(),u)
  20.  2.3563  3.2318 -0.9406
  21.  3.2318  4.9557 -2.1618
  22. -0.9406 -2.1618  2.2443
  23. [torch.FloatTensor of size 3x3]
  1. torch.potri(u, out=None)

potri(u, upper, out=None)

给定一个半正定矩阵的 Cholesky 分解因子 u, 计算该半正定矩阵的逆. 返回矩阵 inv, 若 upper 设为 True 或为提供, u 是一个上三角矩阵, 使得 inv = (u^T u)^{-1} 成立; 若 upper 设为 False, u 是一个下三角矩阵, 使得 inv = (u u^T)^{-1} 成立.

参数：

  • u (Tensor) – the input 2D Tensor, a upper or lower triangular Cholesky factor
  • upper (bool, 可选) – Flag if upper (default) or lower triangular matrix
  • out (Tensor, 可选) – A Tensor for inv

示例：

  1. >>> a = torch.randn(3,3)
  2. >>> a = torch.mm(a, a.t()) # make symmetric positive definite
  3. >>> u = torch.potrf(a)
  4. >>> a
  6.  2.3563  3.2318 -0.9406
  7.  3.2318  4.9557 -2.1618
  8. -0.9406 -2.1618  2.2443
  9. [torch.FloatTensor of size 3x3]
  11. >>> torch.potri(u)
  13.  12.5724 -10.1765  -4.5333
  14. -10.1765   8.5852   4.0047
  15.  -4.5333   4.0047   2.4031
  16. [torch.FloatTensor of size 3x3]
  18. >>> a.inverse()
  20.  12.5723 -10.1765  -4.5333
  21. -10.1765   8.5852   4.0047
  22.  -4.5333   4.0047   2.4031
  23. [torch.FloatTensor of size 3x3]
  1. torch.potrs(b, u, out=None)

potrs(b, u, upper, out=None)

Solves a linear system of equations with a positive semidefinite matrix to be inverted given its given a Cholesky factor matrix u: returns matrix c If upper is True or not provided, u is and upper triangular such that c = (u^T u)^{-1} b. If upper is False, u is and lower triangular such that c = (u u^T)^{-1} b.

注解：

b is always a 2D Tensor, use b.unsqueeze(1) to convert a vector.

参数：

  • b (Tensor) – the right hand side 2D Tensor
  • u (Tensor) – the input 2D Tensor, a upper or lower triangular Cholesky factor
  • upper (bool, 可选) – Return upper (default) or lower triangular matrix
  • out (Tensor, 可选) – A Tensor for c

示例：

  1. >>> a = torch.randn(3,3)
  2. >>> a = torch.mm(a, a.t()) # make symmetric positive definite
  3. >>> u = torch.potrf(a)
  4. >>> a
  6.  2.3563  3.2318 -0.9406
  7.  3.2318  4.9557 -2.1618
  8. -0.9406 -2.1618  2.2443
  9. [torch.FloatTensor of size 3x3]
  11. >>> b = torch.randn(3,2)
  12. >>> b
  14. -0.3119 -1.8224
  15. -0.2798  0.1789
  16. -0.3735  1.7451
  17. [torch.FloatTensor of size 3x2]
  19. >>> torch.potrs(b,u)
  21.  0.6187 -32.6438
  22. -0.7234  27.0703
  23. -0.6039  13.1717
  24. [torch.FloatTensor of size 3x2]
  26. >>> torch.mm(a.inverse(),b)
  28.  0.6187 -32.6436
  29. -0.7234  27.0702
  30. -0.6039  13.1717
  31. [torch.FloatTensor of size 3x2]
  1. torch.pstrf(a, out=None)

pstrf(a, upper, out=None)

Computes the pivoted Cholesky decomposition of a positive semidefinite matrix a: returns matrices u and piv. If upper is True or not provided, u is and upper triangular such that a = p^T u^T u p, with p the permutation given by piv. If upper is False, u is and lower triangular such that a = p^T u u^T p.

参数：

  • a (Tensor) – the input 2D Tensor
  • upper (bool, 可选) – Return upper (default) or lower triangular matrix
  • out (tuple, 可选) – A tuple of u and piv Tensors

示例：

  1. >>> a = torch.randn(3,3)
  2. >>> a = torch.mm(a, a.t()) # make symmetric positive definite
  3. >>> a
  5.  5.4417 -2.5280  1.3643
  6. -2.5280  2.9689 -2.1368
  7.  1.3643 -2.1368  4.6116
  8. [torch.FloatTensor of size 3x3]
  10. >>> u,piv = torch.pstrf(a)
  11. >>> u
  13.  2.3328  0.5848 -1.0837
  14.  0.0000  2.0663 -0.7274
  15.  0.0000  0.0000  1.1249
  16. [torch.FloatTensor of size 3x3]
  18. >>> piv
  20.  0
  21.  2
  22.  1
  23. [torch.IntTensor of size 3]
  25. >>> p = torch.eye(3).index_select(0,piv.long()).index_select(0,piv.long()).t() # make pivot permutation
  26. >>> torch.mm(torch.mm(p.t(),torch.mm(u.t(),u)),p) # reconstruct
  28.  5.4417  1.3643 -2.5280
  29.  1.3643  4.6116 -2.1368
  30. -2.5280 -2.1368  2.9689
  31. [torch.FloatTensor of size 3x3]
  1. torch.qr(input, out=None) -> (Tensor, Tensor)

计算矩阵 input 的 QR 分解. 返回矩阵 q 和 r 使得 x = q * r, 且 q 是一个 正交矩阵, r 是一个上三角矩阵.

This returns the thin (reduced) QR factorization.

注解：

如果矩阵 input 中的元素太大, 那么精度可能会丢失.

注解：

尽管该函数总是能给您一个有效的分解, 但在不同平台上结果可能不同 - 取决于该平台上 LAPACK 的实现.

注解：

Irrespective of the original strides, the returned matrix q will be transposed, i.e. with strides (1, m) instead of (m, 1).

参数：

  • input (Tensor) – the input 2D Tensor
  • out (tuple, 可选) – A tuple of Q and R Tensors

示例：

  1. >>> a = torch.Tensor([[12, -51, 4], [6, 167, -68], [-4, 24, -41]])
  2. >>> q, r = torch.qr(a)
  3. >>> q
  5. -0.8571  0.3943  0.3314
  6. -0.4286 -0.9029 -0.0343
  7.  0.2857 -0.1714  0.9429
  8. [torch.FloatTensor of size 3x3]
  10. >>> r
  12.  -14.0000  -21.0000   14.0000
  13.  0.0000 -175.0000   70.0000
  14.  0.0000    0.0000  -35.0000
  15. [torch.FloatTensor of size 3x3]
  17. >>> torch.mm(q, r).round()
  19.  12  -51    4
  20.  6  167  -68
  21.  -4   24  -41
  22. [torch.FloatTensor of size 3x3]
  24. >>> torch.mm(q.t(), q).round()
  26.  1 -0  0
  27. -0  1  0
  28.  0  0  1
  29. [torch.FloatTensor of size 3x3]
  1. torch.svd(input, some=True, out=None) -> (Tensor, Tensor, Tensor)

U, S, V = torch.svd(A) 返回大小为 (n x m) 的实矩阵 A 的奇异值分解, 使得 A = USV'*.

U 的大小为 n x n

S 的大小为n x m

V 的大小为 m x m.

some 表示将被计算的奇异值的总数. 如果 some=True, 它将计算指定的 some 数量个奇异值, 如果 some=False, 则计算所有奇异值.

注解：

Irrespective of the original strides, the returned matrix U will be transposed, i.e. with strides (1, n) instead of (n, 1).

参数：

  • input (Tensor) – the input 2D Tensor
  • some (bool, 可选) – controls the number of singular values to be computed
  • out (tuple, 可选) – the result tuple

示例：

  1. >>> a = torch.Tensor([[8.79,  6.11, -9.15,  9.57, -3.49,  9.84],
  2. ...                   [9.93,  6.91, -7.93,  1.64,  4.02,  0.15],
  3. ...                   [9.83,  5.04,  4.86,  8.83,  9.80, -8.99],
  4. ...                   [5.45, -0.27,  4.85,  0.74, 10.00, -6.02],
  5. ...                   [3.16,  7.98,  3.01,  5.80,  4.27, -5.31]]).t()
  6. >>> a
  8.  8.7900   9.9300   9.8300   5.4500   3.1600
  9.  6.1100   6.9100   5.0400  -0.2700   7.9800
  10.  -9.1500  -7.9300   4.8600   4.8500   3.0100
  11.  9.5700   1.6400   8.8300   0.7400   5.8000
  12.  -3.4900   4.0200   9.8000  10.0000   4.2700
  13.  9.8400   0.1500  -8.9900  -6.0200  -5.3100
  14. [torch.FloatTensor of size 6x5]
  16. >>> u, s, v = torch.svd(a)
  17. >>> u
  19. -0.5911  0.2632  0.3554  0.3143  0.2299
  20. -0.3976  0.2438 -0.2224 -0.7535 -0.3636
  21. -0.0335 -0.6003 -0.4508  0.2334 -0.3055
  22. -0.4297  0.2362 -0.6859  0.3319  0.1649
  23. -0.4697 -0.3509  0.3874  0.1587 -0.5183
  24.  0.2934  0.5763 -0.0209  0.3791 -0.6526
  25. [torch.FloatTensor of size 6x5]
  27. >>> s
  29.  27.4687
  30.  22.6432
  31.  8.5584
  32.  5.9857
  33.  2.0149
  34. [torch.FloatTensor of size 5]
  36. >>> v
  38. -0.2514  0.8148 -0.2606  0.3967 -0.2180
  39. -0.3968  0.3587  0.7008 -0.4507  0.1402
  40. -0.6922 -0.2489 -0.2208  0.2513  0.5891
  41. -0.3662 -0.3686  0.3859  0.4342 -0.6265
  42. -0.4076 -0.0980 -0.4932 -0.6227 -0.4396
  43. [torch.FloatTensor of size 5x5]
  45. >>> torch.dist(a, torch.mm(torch.mm(u, torch.diag(s)), v.t()))
  46. 8.934150226306685e-06
  1. torch.symeig(input, eigenvectors=False, upper=True, out=None) -> (Tensor, Tensor)

e, V = torch.symeig(input) 返回实对称矩阵 input 的特征值和特征向量.

input 和 V 是 m x m 矩阵, e 是一个 m 维的向量.

这个函数计算矩阵 input 的所有特征值 (和向量), 使得 input = V diag(e) V’.

布尔参数 eigenvectors 定义了是否计算特征向量. 如果它为 False, 那么只有特征值会被计算. 如果它为 True, 特征值和特征向量都会被计算.

由于输入矩阵 input 被假定是对称的, 因此默认地只有它的上三角部分会被使用.

如果 upper 是 False, 那么它的下三角部分会被使用.

Note: Irrespective of the original strides, the returned matrix V will be transposed, i.e. with strides (1, m) instead of (m, 1).

参数：

  • input (Tensor) – the input symmetric matrix
  • eigenvectors (boolean, 可选) – controls whether eigenvectors have to be computed
  • upper (boolean, 可选) – controls whether to consider upper-triangular or lower-triangular region
  • out (tuple, 可选) – The result tuple of (Tensor, Tensor)

Examples:

  1. >>> a = torch.Tensor([[ 1.96,  0.00,  0.00,  0.00,  0.00],
  2. ...                   [-6.49,  3.80,  0.00,  0.00,  0.00],
  3. ...                   [-0.47, -6.39,  4.17,  0.00,  0.00],
  4. ...                   [-7.20,  1.50, -1.51,  5.70,  0.00],
  5. ...                   [-0.65, -6.34,  2.67,  1.80, -7.10]]).t()
  7. >>> e, v = torch.symeig(a, eigenvectors=True)
  8. >>> e
  10. -11.0656
  11.  -6.2287
  12.  0.8640
  13.  8.8655
  14.  16.0948
  15. [torch.FloatTensor of size 5]
  17. >>> v
  19. -0.2981 -0.6075  0.4026 -0.3745  0.4896
  20. -0.5078 -0.2880 -0.4066 -0.3572 -0.6053
  21. -0.0816 -0.3843 -0.6600  0.5008  0.3991
  22. -0.0036 -0.4467  0.4553  0.6204 -0.4564
  23. -0.8041  0.4480  0.1725  0.3108  0.1622
  24. [torch.FloatTensor of size 5x5]
  1. torch.trtrs()