torch

torch 包含了多维张量的数据结构以及基于其上的多种数学操作。另外,它也提供了多种工具,其中一些可以更有效地对张量和任意类型进行序列化。

它有CUDA 的对应实现,可以在NVIDIA GPU上进行张量运算(计算能力>=2.0)。

张量 Tensors

torch.is_tensor[source]

  1. torch.is_tensor(obj)

如果obj 是一个pytorch张量,则返回True

  • 参数: obj (Object) – 判断对象

torch.is_storage [source]

  1. torch.is_storage(obj)

如何obj 是一个pytorch storage对象,则返回True

  • 参数: input (Object) – 判断对象

torch.set_default_tensor_type[source]

  1. torch.set_default_tensor_type(t)

torch.numel

  1. torch.numel(input)->int

返回input 张量中的元素个数

  • 参数: input (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

torch.set_printoptions[source]

  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 will ignore this parameter.
  • profile – pretty打印的完全默认值。 可以覆盖上述所有选项 (默认为short, full)

创建操作 Creation Ops

torch.eye

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

返回一个2维张量,对角线位置全1,其它位置全0

参数:

  • n (int) – 行数
  • m (int, optional) – 列数.如果为None,则默认为n
  • out (Tensor, optinal) - Output tensor

返回值: 对角线位置全1,其它位置全0的2维张量

返回值类型: Tensor

例子:

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

from_numpy

  1. torch.from_numpy(ndarray) Tensor

Numpy桥,将numpy.ndarray 转换为pytorch的 Tensor。返回的张量tensor和numpy的ndarray共享同一内存空间。修改一个会导致另外一个也被修改。返回的张量不能改变大小。

例子:

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

torch.linspace

  1. torch.linspace(start, end, steps=100, out=None) Tensor

返回一个1维张量,包含在区间startend 上均匀间隔的steps个点。输出1维张量的长度为steps

参数:

  • start (float) – 序列的起始点
  • end (float) – 序列的最终值
  • steps (int) – 在startend间生成的样本数
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> torch.linspace(3, 10, steps=5)
  2. 3.0000
  3. 4.7500
  4. 6.5000
  5. 8.2500
  6. 10.0000
  7. [torch.FloatTensor of size 5]
  8. >>> torch.linspace(-10, 10, steps=5)
  9. -10
  10. -5
  11. 0
  12. 5
  13. 10
  14. [torch.FloatTensor of size 5]
  15. >>> torch.linspace(start=-10, end=10, steps=5)
  16. -10
  17. -5
  18. 0
  19. 5
  20. 10
  21. [torch.FloatTensor of size 5]

torch.logspace

  1. torch.logspace(start, end, steps=100, out=None) Tensor

返回一个1维张量,包含在区间 \(10^{start}\) 和 \( 10^{end} \)上以对数刻度均匀间隔的steps个点。输出1维张量的长度为steps

参数:

  • start (float) – 序列的起始点
  • end (float) – 序列的最终值
  • steps (int) – 在startend间生成的样本数
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> torch.logspace(start=-10, end=10, steps=5)
  2. 1.0000e-10
  3. 1.0000e-05
  4. 1.0000e+00
  5. 1.0000e+05
  6. 1.0000e+10
  7. [torch.FloatTensor of size 5]
  8. >>> torch.logspace(start=0.1, end=1.0, steps=5)
  9. 1.2589
  10. 2.1135
  11. 3.5481
  12. 5.9566
  13. 10.0000
  14. [torch.FloatTensor of size 5]

torch.ones

  1. torch.ones(*sizes, out=None) Tensor

返回一个全为1 的张量,形状由可变参数sizes定义。

参数:

  • sizes (int…) – 整数序列,定义了输出形状
  • out (Tensor, optional) – 结果张量例子:```python

    torch.ones(2, 3)

    1 1 11 1 1[torch.FloatTensor of size 2x3]

torch.ones(5)

1 1 1 1 1[torch.FloatTensor of size 5]

  1. ***
  2. ** torch.rand**
  3. ```python
  4. torch.rand(*sizes, out=None) → Tensor

返回一个张量,包含了从区间[0,1)的均匀分布中抽取的一组随机数,形状由可变参数sizes 定义。

参数:

  • sizes (int…) – 整数序列,定义了输出形状
  • out (Tensor, optinal) - 结果张量例子:```python

    torch.rand(4)

    0.91930.33470.32320.7715[torch.FloatTensor of size 4]

torch.rand(2, 3)

0.5010 0.5140 0.0719 0.1435 0.5636 0.0538[torch.FloatTensor of size 2x3]

  1. ***
  2. ** torch.randn**
  3. ```python
  4. torch.randn(*sizes, out=None) → Tensor

返回一个张量,包含了从标准正态分布(均值为0,方差为 1,即高斯白噪声)中抽取一组随机数,形状由可变参数sizes定义。参数:

  • sizes (int…) – 整数序列,定义了输出形状
  • out (Tensor, optinal) - 结果张量

例子::

  1. >>> torch.randn(4)
  2. -0.1145
  3. 0.0094
  4. -1.1717
  5. 0.9846
  6. [torch.FloatTensor of size 4]
  7. >>> torch.randn(2, 3)
  8. 1.4339 0.3351 -1.0999
  9. 1.5458 -0.9643 -0.3558
  10. [torch.FloatTensor of size 2x3]

torch.randperm

  1. torch.randperm(n, out=None) LongTensor

给定参数n,返回一个从0n -1 的随机整数排列。

参数:

  • n (int) – 上边界(不包含)

例子:

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

torch.arange

  1. torch.arange(start, end, step=1, out=None) Tensor

返回一个1维张量,长度为 \( floor((end−start)/step) \)。包含从startend,以step为步长的一组序列值(默认步长为1)。

参数:

  • start (float) – 序列的起始点
  • end (float) – 序列的终止点
  • step (float) – 相邻点的间隔大小
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> torch.arange(1, 4)
  2. 1
  3. 2
  4. 3
  5. [torch.FloatTensor of size 3]
  6. >>> torch.arange(1, 2.5, 0.5)
  7. 1.0000
  8. 1.5000
  9. 2.0000
  10. [torch.FloatTensor of size 3]

torch.range

  1. torch.range(start, end, step=1, out=None) Tensor

返回一个1维张量,有 \( floor((end−start)/step)+1 \) 个元素。包含在半开区间[start, end)start开始,以step为步长的一组值。 step 是两个值之间的间隔,即 \( x_{i+1}=x_i+step \)

警告:建议使用函数 torch.arange()

参数:

  • start (float) – 序列的起始点
  • end (float) – 序列的最终值
  • step (int) – 相邻点的间隔大小
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> torch.range(1, 4)
  2. 1
  3. 2
  4. 3
  5. 4
  6. [torch.FloatTensor of size 4]
  7. >>> torch.range(1, 4, 0.5)
  8. 1.0000
  9. 1.5000
  10. 2.0000
  11. 2.5000
  12. 3.0000
  13. 3.5000
  14. 4.0000
  15. [torch.FloatTensor of size 7]

torch.zeros

  1. torch.zeros(*sizes, out=None) Tensor

返回一个全为标量 0 的张量,形状由可变参数sizes 定义。

参数:

  • sizes (int…) – 整数序列,定义了输出形状
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> torch.zeros(2, 3)
  2. 0 0 0
  3. 0 0 0
  4. [torch.FloatTensor of size 2x3]
  5. >>> torch.zeros(5)
  6. 0
  7. 0
  8. 0
  9. 0
  10. 0
  11. [torch.FloatTensor of size 5]

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

torch.cat

  1. torch.cat(inputs, dimension=0) Tensor

在给定维度上对输入的张量序列seq 进行连接操作。

torch.cat()可以看做 torch.split()torch.chunk()的反操作。cat() 函数可以通过下面例子更好的理解。

参数:

  • inputs (sequence of Tensors) – 可以是任意相同Tensor 类型的python 序列
  • dimension (int, optional) – 沿着此维连接张量序列。

    例子:```python

    x = torch.randn(2, 3)x

    0.5983 -0.0341 2.49181.5981 -0.5265 -0.8735[torch.FloatTensor of size 2x3]

torch.cat((x, x, x), 0)

0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735[torch.FloatTensor of size 6x3]

torch.cat((x, x, x), 1)

0.5983 -0.0341 2.4918 0.5983 -0.0341 2.4918 0.5983 -0.0341 2.4918 1.5981 -0.5265 -0.8735 1.5981 -0.5265 -0.8735 1.5981 -0.5265 -0.8735[torch.FloatTensor of size 2x9]

  1. ### torch.chunk
  2. ```python
  3. torch.chunk(tensor, chunks, dim=0)

在给定维度(轴)上将输入张量进行分块儿。

参数:

  • tensor (Tensor) – 待分块的输入张量
  • chunks (int) – 分块的个数
  • dim (int) – 沿着此维度进行分块

torch.gather

  1. torch.gather(input, dim, index, out=None) Tensor

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

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

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

例子:

  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]

参数:

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

torch.index_select

  1. torch.index_select(input, dim, index, out=None) Tensor

沿着指定维度对输入进行切片,取index中指定的相应项(index为一个LongTensor),然后返回到一个新的张量,返回的张量与原始张量Tensor有相同的维度(在指定轴上)。

注意: 返回的张量不与原始张量共享内存空间。

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 索引的轴
  • index (LongTensor) – 包含索引下标的一维张量
  • out (Tensor, optional) – 目标张量

例子:

  1. >>> x = torch.randn(3, 4)
  2. >>> x
  3. 1.2045 2.4084 0.4001 1.1372
  4. 0.5596 1.5677 0.6219 -0.7954
  5. 1.3635 -1.2313 -0.5414 -1.8478
  6. [torch.FloatTensor of size 3x4]
  7. >>> indices = torch.LongTensor([0, 2])
  8. >>> torch.index_select(x, 0, indices)
  9. 1.2045 2.4084 0.4001 1.1372
  10. 1.3635 -1.2313 -0.5414 -1.8478
  11. [torch.FloatTensor of size 2x4]
  12. >>> torch.index_select(x, 1, indices)
  13. 1.2045 0.4001
  14. 0.5596 0.6219
  15. 1.3635 -0.5414
  16. [torch.FloatTensor of size 3x2]

torch.masked_select

  1. torch.masked_select(input, mask, out=None) Tensor

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

张量 mask须跟input张量有相同数量的元素数目,但形状或维度不需要相同。注意: 返回的张量不与原始张量共享内存空间。

参数:

  • input (Tensor) – 输入张量
  • mask (ByteTensor) – 掩码张量,包含了二元索引值
  • out (Tensor, optional) – 目标张量

例子:

  1. >>> x = torch.randn(3, 4)
  2. >>> x
  3. 1.2045 2.4084 0.4001 1.1372
  4. 0.5596 1.5677 0.6219 -0.7954
  5. 1.3635 -1.2313 -0.5414 -1.8478
  6. [torch.FloatTensor of size 3x4]
  7. >>> indices = torch.LongTensor([0, 2])
  8. >>> torch.index_select(x, 0, indices)
  9. 1.2045 2.4084 0.4001 1.1372
  10. 1.3635 -1.2313 -0.5414 -1.8478
  11. [torch.FloatTensor of size 2x4]
  12. >>> torch.index_select(x, 1, indices)
  13. 1.2045 0.4001
  14. 0.5596 0.6219
  15. 1.3635 -0.5414
  16. [torch.FloatTensor of size 3x2]

torch.nonzero

  1. torch.nonzero(input, out=None) LongTensor

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

如果输入inputn维,则输出的索引张量output的形状为 z x n, 这里 z 是输入张量input中所有非零元素的个数。

参数:

  • input (Tensor) – 源张量
  • out (LongTensor, optional) – 包含索引值的结果张量

例子:

  1. >>> torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))
  2. 0
  3. 1
  4. 2
  5. 4
  6. [torch.LongTensor of size 4x1]
  7. >>> torch.nonzero(torch.Tensor([[0.6, 0.0, 0.0, 0.0],
  8. ... [0.0, 0.4, 0.0, 0.0],
  9. ... [0.0, 0.0, 1.2, 0.0],
  10. ... [0.0, 0.0, 0.0,-0.4]]))
  11. 0 0
  12. 1 1
  13. 2 2
  14. 3 3
  15. [torch.LongTensor of size 4x2]

torch.split

  1. torch.split(tensor, split_size, dim=0)

将输入张量分割成相等形状的chunks(如果可分)。 如果沿指定维的张量形状大小不能被split_size 整分, 则最后一个分块会小于其它分块。

参数:

  • tensor (Tensor) – 待分割张量
  • split_size (int) – 单个分块的形状大小
  • dim (int) – 沿着此维进行分割

torch.squeeze

  1. torch.squeeze(input, dim=None, out=None)

将输入张量形状中的1 去除并返回。如果输入是形如\((A \times 1\times B \times 1 \times C \times 1 \times D) \),那么输出形状就为: \((A \times B \times C \times D) \)

当给定dim时,那么挤压操作只在给定维度上。例如,输入形状为: \((A \times 1 \times B) \), squeeze(input, 0) 将会保持张量不变,只有用 squeeze(input, 1),形状会变成 \( (A \times B )\)。

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

参数:

  • input (Tensor) – 输入张量
  • dim (int, optional) – 如果给定,则input只会在给定维度挤压
  • out (Tensor, optional) – 输出张量

例子:

  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)

torch.stack[source]

  1. torch.stack(sequence, dim=0)

沿着一个新维度对输入张量序列进行连接。序列中所有的张量都应该为相同形状。

参数:

  • sqequence (Sequence) – 待连接的张量序列
  • dim (int) – 插入的维度。必须介于 0 与 待连接的张量序列数之间。

torch.t

  1. torch.t(input, out=None) Tensor

输入一个矩阵(2维张量),并转置0, 1维。可以被视为函数transpose(input, 0, 1)的简写函数。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 结果张量```python

    x = torch.randn(2, 3)x

    0.4834 0.6907 1.3417-0.1300 0.5295 0.2321[torch.FloatTensor of size 2x3]

torch.t(x)

0.4834 -0.1300 0.6907 0.5295 1.3417 0.2321[torch.FloatTensor of size 3x2]

  1. ### torch.transpose
  2. ```python
  3. torch.transpose(input, dim0, dim1, out=None) → Tensor

返回输入矩阵input的转置。交换维度dim0dim1。输出张量与输入张量共享内存,所以改变其中一个会导致另外一个也被修改。

参数:

  • input (Tensor) – 输入张量
  • dim0 (int) – 转置的第一维
  • dim1 (int) – 转置的第二维
  1. >>> x = torch.randn(2, 3)
  2. >>> x
  3. 0.5983 -0.0341 2.4918
  4. 1.5981 -0.5265 -0.8735
  5. [torch.FloatTensor of size 2x3]
  6. >>> torch.transpose(x, 0, 1)
  7. 0.5983 1.5981
  8. -0.0341 -0.5265
  9. 2.4918 -0.8735
  10. [torch.FloatTensor of size 3x2]

torch.unbind

  1. torch.unbind(tensor, dim=0)[source]

移除指定维后,返回一个元组,包含了沿着指定维切片后的各个切片

参数:

  • tensor (Tensor) – 输入张量
  • dim (int) – 删除的维度

torch.unsqueeze

  1. torch.unsqueeze(input, dim, out=None)

返回一个新的张量,对输入的制定位置插入维度 1

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

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

参数:

  • tensor (Tensor) – 输入张量
  • dim (int) – 插入维度的索引
  • out (Tensor, optional) – 结果张量
  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

torch.manual_seed

  1. torch.manual_seed(seed)

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

参数: seed (int or long) – 种子.

torch.initial_seed

  1. torch.initial_seed()

返回生成随机数的原始种子值(python long)。

torch.get_rng_state

  1. torch.get_rng_state()[source]

返回随机生成器状态(ByteTensor)

torch.set_rng_state

  1. torch.set_rng_state(new_state)[source]

设定随机生成器状态参数: new_state (torch.ByteTensor) – 期望的状态

torch.default_generator

  1. torch.default_generator = <torch._C.Generator object>

torch.bernoulli

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

从伯努利分布中抽取二元随机数(0 或者 1)。

输入张量须包含用于抽取上述二元随机值的概率。 因此,输入中的所有值都必须在[0,1]区间,即 \( 0<=input_i<=1 \)

输出张量的第i个元素值, 将会以输入张量的第i个概率值等于1

返回值将会是与输入相同大小的张量,每个值为0或者1参数:

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

例子:

  1. >>> a = torch.Tensor(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
  2. >>> a
  3. 0.7544 0.8140 0.9842
  4. 0.5282 0.0595 0.6445
  5. 0.1925 0.9553 0.9732
  6. [torch.FloatTensor of size 3x3]
  7. >>> torch.bernoulli(a)
  8. 1 1 1
  9. 0 0 1
  10. 0 1 1
  11. [torch.FloatTensor of size 3x3]
  12. >>> a = torch.ones(3, 3) # probability of drawing "1" is 1
  13. >>> torch.bernoulli(a)
  14. 1 1 1
  15. 1 1 1
  16. 1 1 1
  17. [torch.FloatTensor of size 3x3]
  18. >>> a = torch.zeros(3, 3) # probability of drawing "1" is 0
  19. >>> torch.bernoulli(a)
  20. 0 0 0
  21. 0 0 0
  22. 0 0 0
  23. [torch.FloatTensor of size 3x3]

torch.multinomial

  1. torch.multinomial(input, num_samples,replacement=False, out=None) LongTensor

返回一个张量,每行包含从input相应行中定义的多项分布中抽取的num_samples个样本。

[注意]:输入input每行的值不需要总和为1 (这里我们用来做权重),但是必须非负且总和不能为0。

当抽取样本时,依次从左到右排列(第一个样本对应第一列)。

如果输入input是一个向量,输出out也是一个相同长度num_samples的向量。如果输入input是有 \(m \)行的矩阵,输出out是形如\( m \times n \)的矩阵。

如果参数replacementTrue, 则样本抽取可以重复。否则,一个样本在每行不能被重复抽取。

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

参数:

  • input (Tensor) – 包含概率值的张量
  • num_samples (int) – 抽取的样本数
  • replacement (bool, optional) – 布尔值,决定是否能重复抽取
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> weights = torch.Tensor([0, 10, 3, 0]) # create a Tensor of weights
  2. >>> torch.multinomial(weights, 4)
  3. 1
  4. 2
  5. 0
  6. 0
  7. [torch.LongTensor of size 4]
  8. >>> torch.multinomial(weights, 4, replacement=True)
  9. 1
  10. 2
  11. 1
  12. 2
  13. [torch.LongTensor of size 4]

torch.normal()

  1. torch.normal(means, std, out=None)

返回一个张量,包含从给定参数means,std的离散正态分布中抽取随机数。均值means是一个张量,包含每个输出元素相关的正态分布的均值。std是一个张量,包含每个输出元素相关的正态分布的标准差。均值和标准差的形状不须匹配,但每个张量的元素个数须相同。

参数:

  • means (Tensor) – 均值
  • std (Tensor) – 标准差
  • out (Tensor) – 可选的输出张量
  1. torch.normal(means=torch.arange(1, 11), std=torch.arange(1, 0, -0.1))
  2. 1.5104
  3. 1.6955
  4. 2.4895
  5. 4.9185
  6. 4.9895
  7. 6.9155
  8. 7.3683
  9. 8.1836
  10. 8.7164
  11. 9.8916
  12. [torch.FloatTensor of size 10]
  1. torch.normal(mean=0.0, std, out=None)

与上面函数类似,所有抽取的样本共享均值。

参数:

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

例子:

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

与上面函数类似,所有抽取的样本共享标准差。

参数:

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

例子:

  1. >>> torch.normal(means=torch.arange(1, 6))
  2. 1.1681
  3. 2.8884
  4. 3.7718
  5. 2.5616
  6. 4.2500
  7. [torch.FloatTensor of size 5]

序列化 Serialization

torch.saves[source]

  1. torch.save(obj, f, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py'>, pickle_protocol=2)

保存一个对象到一个硬盘文件上参考: Recommended approach for saving a model参数:

  • obj – 保存对象
  • f - 类文件对象 (返回文件描述符)或一个保存文件名的字符串
  • pickle_module – 用于pickling元数据和对象的模块
  • pickle_protocol – 指定pickle protocal 可以覆盖默认参数

torch.load[source]

  1. torch.load(f, map_location=None, pickle_module=<module 'pickle' from '/home/jenkins/miniconda/lib/python3.5/pickle.py'>)

从磁盘文件中读取一个通过torch.save()保存的对象。torch.load() 可通过参数map_location 动态地进行内存重映射,使其能从不动设备中读取文件。一般调用时,需两个参数: storage 和 location tag. 返回不同地址中的storage,或着返回None (此时地址可以通过默认方法进行解析). 如果这个参数是字典的话,意味着其是从文件的地址标记到当前系统的地址标记的映射。默认情况下, location tags中 “cpu”对应host tensors,‘cuda:device_id’ (e.g. ‘cuda:2’) 对应cuda tensors。用户可以通过register_package进行扩展,使用自己定义的标记和反序列化方法。

参数:

  • f – 类文件对象 (返回文件描述符)或一个保存文件名的字符串
  • map_location – 一个函数或字典规定如何remap存储位置
  • 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. # Map tensors from GPU 1 to GPU 0
  5. >>> torch.load('tensors.pt', map_location={'cuda:1':'cuda:0'})

并行化 Parallelism

torch.get_num_threads

  1. torch.get_num_threads() int

获得用于并行化CPU操作的OpenMP线程数


torch.set_num_threads

  1. torch.set_num_threads(int)

设定用于并行化CPU操作的OpenMP线程数

数学操作Math operations

Pointwise Ops

torch.abs

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

计算输入张量的每个元素绝对值

例子:

  1. >>> torch.abs(torch.FloatTensor([-1, -2, 3]))
  2. FloatTensor([1, 2, 3])

torch.acos(input, out=None) → Tensor

  1. torch.acos(input, out=None) Tensor

返回一个新张量,包含输入张量每个元素的反余弦。参数:

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

例子:

  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]
  8. >>> torch.acos(a)
  9. 2.2608
  10. 1.2956
  11. 1.1075
  12. nan
  13. [torch.FloatTensor of size 4]

torch.add()

  1. torch.add(input, value, out=None)

对输入张量input逐元素加上标量值value,并返回结果到一个新的张量out,即 \( out = tensor + value \)。

如果输入input是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。【译注:似乎并非如此,无关输入类型,value取整数、实数皆可。】

  • input (Tensor) – 输入张量
  • value (Number) – 添加到输入每个元素的数
  • out (Tensor, optional) – 结果张量
  1. >>> a = torch.randn(4)
  2. >>> a
  3. 0.4050
  4. -1.2227
  5. 1.8688
  6. -0.4185
  7. [torch.FloatTensor of size 4]
  8. >>> torch.add(a, 20)
  9. 20.4050
  10. 18.7773
  11. 21.8688
  12. 19.5815
  13. [torch.FloatTensor of size 4]
  1. torch.add(input, value=1, other, out=None)

other 张量的每个元素乘以一个标量值value,并加到iput 张量上。返回结果到输出张量out。即,\( out=input+(other∗value ) \)

两个张量 input and other的尺寸不需要匹配,但元素总数必须一样。

注意 :当两个张量形状不匹配时,输入张量的形状会作为输出张量的尺寸。

如果other是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。【译注:似乎并非如此,无关输入类型,value取整数、实数皆可。】

参数:

  • input (Tensor) – 第一个输入张量
  • value (Number) – 用于第二个张量的尺寸因子
  • other (Tensor) – 第二个输入张量
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> import torch
  2. >>> a = torch.randn(4)
  3. >>> a
  4. -0.9310
  5. 2.0330
  6. 0.0852
  7. -0.2941
  8. [torch.FloatTensor of size 4]
  9. >>> b = torch.randn(2, 2)
  10. >>> b
  11. 1.0663 0.2544
  12. -0.1513 0.0749
  13. [torch.FloatTensor of size 2x2]
  14. >>> torch.add(a, 10, b)
  15. 9.7322
  16. 4.5770
  17. -1.4279
  18. 0.4552
  19. [torch.FloatTensor of size 4]

torch.addcdiv

  1. torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) Tensor

tensor2tensor1逐元素相除,然后乘以标量值value 并加到tensor

张量的形状不需要匹配,但元素数量必须一致。

如果输入是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。

参数:

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

例子:

  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)
  5. 0.0122 -0.0188 -0.2354
  6. 0.7396 -1.5721 1.2878
  7. [torch.FloatTensor of size 2x3]

torch.addcmul

  1. torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) Tensor

tensor2tensor1逐元素相乘,并对结果乘以标量值value然后加到tensor。张量的形状不需要匹配,但元素数量必须一致。如果输入是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。

参数:

  • tensor (Tensor) – 张量,对tensor1 ./ tensor 进行相加
  • value (Number, optional) – 标量,对 tensor1 . tensor2 进行相乘
  • tensor1 (Tensor) – 张量,作为乘子1
  • tensor2 (Tensor) –张量,作为乘子2
  • out (Tensor, optional) – 输出张量

例子:

  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)
  5. 0.0122 -0.0188 -0.2354
  6. 0.7396 -1.5721 1.2878
  7. [torch.FloatTensor of size 2x3]

torch.asin

  1. torch.asin(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的反正弦函数

参数:

  • tensor (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  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]
  8. >>> torch.asin(a)
  9. -0.6900
  10. 0.2752
  11. 0.4633
  12. nan
  13. [torch.FloatTensor of size 4]

torch.atan

  1. torch.atan(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的反正切函数

参数:

  • tensor (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  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]
  8. >>> torch.atan(a)
  9. -0.5669
  10. 0.2653
  11. 0.4203
  12. 0.9196
  13. [torch.FloatTensor of size 4]

torch.atan2

  1. torch.atan2(input1, input2, out=None) Tensor

返回一个新张量,包含两个输入张量input1input2的反正切函数

参数:

  • input1 (Tensor) – 第一个输入张量
  • input2 (Tensor) – 第二个输入张量
  • out (Tensor, optional) – 输出张量

例子:

  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]
  8. >>> torch.atan2(a, torch.randn(4))
  9. -2.4167
  10. 2.9755
  11. 0.9363
  12. 1.6613
  13. [torch.FloatTensor of size 4]

torch.ceil

  1. torch.ceil(input, out=None) Tensor

天井函数,对输入input张量每个元素向上取整, 即取不小于每个元素的最小整数,并返回结果到输出。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(4)
  2. >>> a
  3. 1.3869
  4. 0.3912
  5. -0.8634
  6. -0.5468
  7. [torch.FloatTensor of size 4]
  8. >>> torch.ceil(a)
  9. 2
  10. 1
  11. -0
  12. -0
  13. [torch.FloatTensor of size 4]

torch.clamp

  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

如果输入是FloatTensor or DoubleTensor类型,则参数min max 必须为实数,否则须为整数。【译注:似乎并非如此,无关输入类型,minmax取整数、实数皆可。】

参数:

  • input (Tensor) – 输入张量
  • min (Number) – 限制范围下限
  • max (Number) – 限制范围上限
  • out (Tensor, optional) – 输出张量

例子:

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

将输入input张量每个元素的限制到不小于min ,并返回结果到一个新张量。

如果输入是FloatTensor or DoubleTensor类型,则参数 min 必须为实数,否则须为整数。【译注:似乎并非如此,无关输入类型,min取整数、实数皆可。】

参数:

  • input (Tensor) – 输入张量
  • value (Number) – 限制范围下限
  • out (Tensor, optional) – 输出张量

例子:

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

将输入input张量每个元素的限制到不大于max ,并返回结果到一个新张量。

如果输入是FloatTensor or DoubleTensor类型,则参数 max 必须为实数,否则须为整数。【译注:似乎并非如此,无关输入类型,max取整数、实数皆可。】

参数:

  • input (Tensor) – 输入张量
  • value (Number) – 限制范围上限
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(4)
  2. >>> a
  3. 1.3869
  4. 0.3912
  5. -0.8634
  6. -0.5468
  7. [torch.FloatTensor of size 4]
  8. >>> torch.clamp(a, max=0.5)
  9. 0.5000
  10. 0.3912
  11. -0.8634
  12. -0.5468
  13. [torch.FloatTensor of size 4]

torch.cos

  1. torch.cos(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的余弦。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  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]
  8. >>> torch.cos(a)
  9. 0.8041
  10. 0.9633
  11. 0.9018
  12. 0.2557
  13. [torch.FloatTensor of size 4]

torch.cosh

  1. torch.cosh(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的双曲余弦。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  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]
  8. >>> torch.cosh(a)
  9. 1.2095
  10. 1.0372
  11. 1.1015
  12. 1.9917
  13. [torch.FloatTensor of size 4]

torch.div()

  1. torch.div(input, value, out=None)

input逐元素除以标量值value,并返回结果到输出张量out。即 \( out=tensor/value \)

如果输入是FloatTensor or DoubleTensor类型,则参数 value 必须为实数,否则须为整数。【译注:似乎并非如此,无关输入类型,value取整数、实数皆可。】

参数:

  • input (Tensor) – 输入张量
  • value (Number) – 除数
  • out (Tensor, optional) – 输出张量

例子:

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

两张量inputother逐元素相除,并将结果返回到输出。即, \( out_i= input_i / other_i \)

两张量形状不须匹配,但元素数须一致。

注意:当形状不匹配时,input的形状作为输出张量的形状。

参数:

  • input (Tensor) – 张量(分子)
  • other (Tensor) – 张量(分母)
  • out (Tensor, optional) – 输出张量

例子:

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

torch.exp

  1. torch.exp(tensor, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的指数。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量
    1. >>> torch.exp(torch.Tensor([0, math.log(2)]))
    2. torch.FloatTensor([1, 2])

    torch.floor

  1. torch.floor(input, out=None) Tensor

床函数: 返回一个新张量,包含输入input张量每个元素的floor,即不小于元素的最大整数。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(4)
  2. >>> a
  3. 1.3869
  4. 0.3912
  5. -0.8634
  6. -0.5468
  7. [torch.FloatTensor of size 4]
  8. >>> torch.floor(a)
  9. 1
  10. 0
  11. -1
  12. -1
  13. [torch.FloatTensor of size 4]

torch.fmod

  1. torch.fmod(input, divisor, out=None) Tensor

计算除法余数。除数与被除数可能同时含有整数和浮点数。此时,余数的正负与被除数相同。

参数:

  • input (Tensor) – 被除数
  • divisor (Tensor or float) – 除数,一个数或与被除数相同类型的张量
  • out (Tensor, optional) – 输出张量

例子:

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

参考: torch.remainder(), 计算逐元素余数, 相当于python 中的 % 操作符。

torch.frac

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

返回每个元素的分数部分。

例子:

  1. >>> torch.frac(torch.Tensor([1, 2.5, -3.2])
  2. torch.FloatTensor([0, 0.5, -0.2])

torch.lerp

  1. torch.lerp(start, end, weight, out=None)

对两个张量以startend做线性插值, 将结果返回到输出张量。

即,\( out_i=start_i+weight∗(end_i−start_i) \)

参数:

  • start (Tensor) – 起始点张量
  • end (Tensor) – 终止点张量
  • weight (float) – 插值公式的weight
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> start = torch.arange(1, 5)
  2. >>> end = torch.Tensor(4).fill_(10)
  3. >>> start
  4. 1
  5. 2
  6. 3
  7. 4
  8. [torch.FloatTensor of size 4]
  9. >>> end
  10. 10
  11. 10
  12. 10
  13. 10
  14. [torch.FloatTensor of size 4]
  15. >>> torch.lerp(start, end, 0.5)
  16. 5.5000
  17. 6.0000
  18. 6.5000
  19. 7.0000
  20. [torch.FloatTensor of size 4]

torch.log

  1. torch.log(input, out=None) Tensor

计算input 的自然对数

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(5)
  2. >>> a
  3. -0.4183
  4. 0.3722
  5. -0.3091
  6. 0.4149
  7. 0.5857
  8. [torch.FloatTensor of size 5]
  9. >>> torch.log(a)
  10. nan
  11. -0.9883
  12. nan
  13. -0.8797
  14. -0.5349
  15. [torch.FloatTensor of size 5]

torch.log1p

  1. torch.log1p(input, out=None) Tensor

计算 \( input +1 \)的自然对数\( y_i=log(x_i+1) \)

注意:对值比较小的输入,此函数比torch.log()更准确。

如果输入是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(5)
  2. >>> a
  3. -0.4183
  4. 0.3722
  5. -0.3091
  6. 0.4149
  7. 0.5857
  8. [torch.FloatTensor of size 5]
  9. >>> torch.log1p(a)
  10. -0.5418
  11. 0.3164
  12. -0.3697
  13. 0.3471
  14. 0.4611
  15. [torch.FloatTensor of size 5]

torch.mul

  1. torch.mul(input, value, out=None)

用标量值value乘以输入input的每个元素,并返回一个新的结果张量。\( out=tensor ∗ value \)

如果输入是FloatTensor or DoubleTensor类型,则value 必须为实数,否则须为整数。【译注:似乎并非如此,无关输入类型,value取整数、实数皆可。】

参数:

  • input (Tensor) – 输入张量
  • value (Number) – 乘到每个元素的数
  • out (Tensor, optional) – 输出张量

例子:

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

两个张量input,other按元素进行相乘,并返回到输出张量。即计算\( out_i=input_i ∗ other_i \)

两计算张量形状不须匹配,但总元素数须一致。注意:当形状不匹配时,input的形状作为输入张量的形状。

参数:

  • input (Tensor) – 第一个相乘张量
  • other (Tensor) – 第二个相乘张量
  • out (Tensor, optional) – 结果张量

例子:

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

torch.neg

  1. torch.neg(input, out=None) Tensor

返回一个新张量,包含输入input 张量按元素取负。即, \( out=−1∗input \)

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(5)
  2. >>> a
  3. -0.4430
  4. 1.1690
  5. -0.8836
  6. -0.4565
  7. 0.2968
  8. [torch.FloatTensor of size 5]
  9. >>> torch.neg(a)
  10. 0.4430
  11. -1.1690
  12. 0.8836
  13. 0.4565
  14. -0.2968
  15. [torch.FloatTensor of size 5]

torch.pow

  1. torch.pow(input, exponent, out=None)

对输入input的按元素求exponent次幂值,并返回结果张量。幂值exponent 可以为单一 float 数或者与input相同元素数的张量。

当幂值为标量时,执行操作: out_i=x^{exponent}

当幂值为张量时,执行操作: out_i=x^{exponent_i}

参数:

  • input (Tensor) – 输入张量
  • exponent (float or Tensor) – 幂值
  • out (Tensor, optional) – 输出张量

例子:

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

base 为标量浮点值,input为张量, 返回的输出张量 out 与输入张量相同形状。

执行操作为: out_i=base^{input_i}

参数:

  • base (float) – 标量值,指数的底
  • input ( Tensor) – 幂值
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> exp = torch.arange(1, 5)
  2. >>> base = 2
  3. >>> torch.pow(base, exp)
  4. 2
  5. 4
  6. 8
  7. 16
  8. [torch.FloatTensor of size 4]

torch.reciprocal

  1. torch.reciprocal(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的倒数,即 1.0/x。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(4)
  2. >>> a
  3. 1.3869
  4. 0.3912
  5. -0.8634
  6. -0.5468
  7. [torch.FloatTensor of size 4]
  8. >>> torch.reciprocal(a)
  9. 0.7210
  10. 2.5565
  11. -1.1583
  12. -1.8289
  13. [torch.FloatTensor of size 4]

torch.remainder

  1. torch.remainder(input, divisor, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的除法余数。除数与被除数可能同时包含整数或浮点数。余数与除数有相同的符号。

参数:

  • input (Tensor) – 被除数
  • divisor (Tensor or float) – 除数,一个数或者与除数相同大小的张量
  • out (Tensor, optional) – 输出张量

例子:

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

参考: 函数torch.fmod() 同样可以计算除法余数,相当于 C 的 库函数fmod()

torch.round

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

返回一个新张量,将输入input张量每个元素舍入到最近的整数。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(4)
  2. >>> a
  3. 1.2290
  4. 1.3409
  5. -0.5662
  6. -0.0899
  7. [torch.FloatTensor of size 4]
  8. >>> torch.round(a)
  9. 1
  10. 1
  11. -1
  12. -0
  13. [torch.FloatTensor of size 4]

torch.rsqrt

  1. torch.rsqrt(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的平方根倒数。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(4)
  2. >>> a
  3. 1.2290
  4. 1.3409
  5. -0.5662
  6. -0.0899
  7. [torch.FloatTensor of size 4]
  8. >>> torch.rsqrt(a)
  9. 0.9020
  10. 0.8636
  11. nan
  12. nan
  13. [torch.FloatTensor of size 4]

torch.sigmoid

  1. torch.sigmoid(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的sigmoid值。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(4)
  2. >>> a
  3. -0.4972
  4. 1.3512
  5. 0.1056
  6. -0.2650
  7. [torch.FloatTensor of size 4]
  8. >>> torch.sigmoid(a)
  9. 0.3782
  10. 0.7943
  11. 0.5264
  12. 0.4341
  13. [torch.FloatTensor of size 4]

torch.sign

  1. torch.sign(input, out=None) Tensor

符号函数:返回一个新张量,包含输入input张量每个元素的正负。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  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]
  8. >>> torch.sign(a)
  9. -1
  10. 1
  11. 1
  12. 1
  13. [torch.FloatTensor of size 4]

torch.sin

  1. torch.sin(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的正弦。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  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]
  8. >>> torch.sin(a)
  9. -0.5944
  10. 0.2684
  11. 0.4322
  12. 0.9667
  13. [torch.FloatTensor of size 4]

torch.sinh

  1. torch.sinh(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的双曲正弦。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  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]
  8. >>> torch.sinh(a)
  9. -0.6804
  10. 0.2751
  11. 0.4619
  12. 1.7225
  13. [torch.FloatTensor of size 4]

torch.sqrt

  1. torch.sqrt(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的平方根。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(4)
  2. >>> a
  3. 1.2290
  4. 1.3409
  5. -0.5662
  6. -0.0899
  7. [torch.FloatTensor of size 4]
  8. >>> torch.sqrt(a)
  9. 1.1086
  10. 1.1580
  11. nan
  12. nan
  13. [torch.FloatTensor of size 4]

torch.tan

  1. torch.tan(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的正切。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  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]
  8. >>> torch.tan(a)
  9. -0.7392
  10. 0.2786
  11. 0.4792
  12. 3.7801
  13. [torch.FloatTensor of size 4]

torch.tanh

  1. torch.tanh(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的双曲正切。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

  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]
  8. >>> torch.tanh(a)
  9. -0.5625
  10. 0.2653
  11. 0.4193
  12. 0.8648
  13. [torch.FloatTensor of size 4]

torch.trunc

  1. torch.trunc(input, out=None) Tensor

返回一个新张量,包含输入input张量每个元素的截断值(标量x的截断值是最接近其的整数,其比x更接近零。简而言之,有符号数的小数部分被舍弃)。

参数:

  • input (Tensor) – 输入张量
  • out (Tensor, optional) – 输出张量

例子:

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

Reduction Ops

torch.cumprod

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

返回输入沿指定维度的累积积。例如,如果输入是一个N 元向量,则结果也是一个N 元向量,第i 个输出元素值为\( yi=x1∗x2∗x3∗…∗xi \)

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 累积积操作的维度
  • out (Tensor, optional) – 结果张量

例子:

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

torch.cumsum

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

返回输入沿指定维度的累积和。例如,如果输入是一个N元向量,则结果也是一个N元向量,第i 个输出元素值为 \( yi=x1+x2+x3+…+xi\)

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 累积和操作的维度
  • out (Tensor, optional) – 结果张量

例子:

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

torch.dist

  1. torch.dist(input, other, p=2, out=None) Tensor

返回 (input - other) 的 p范数 。

参数:

  • input (Tensor) – 输入张量
  • other (Tensor) – 右侧输入张量
  • p (float, optional) – 所计算的范数
  • out (Tensor, optional) – 结果张量

例子:

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

torch.mean

  1. torch.mean(input) float

返回输入张量所有元素的均值。

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

例子:

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

返回输入张量给定维度dim上每行的均值。

输出形状与输入相同,除了给定维度上为1.

参数:

  • input (Tensor) – 输入张量
  • dim (int) – the dimension to reduce
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> a = torch.randn(4, 4)
  2. >>> a
  3. -1.2738 -0.3058 0.1230 -1.9615
  4. 0.8771 -0.5430 -0.9233 0.9879
  5. 1.4107 0.0317 -0.6823 0.2255
  6. -1.3854 0.4953 -0.2160 0.2435
  7. [torch.FloatTensor of size 4x4]
  8. >>> torch.mean(a, 1)
  9. -0.8545
  10. 0.0997
  11. 0.2464
  12. -0.2157
  13. [torch.FloatTensor of size 4x1]

torch.median

  1. torch.median(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

返回输入张量给定维度每行的中位数,同时返回一个包含中位数的索引的LongTensor

dim值默认为输入张量的最后一维。输出形状与输入相同,除了给定维度上为1.

注意: 这个函数还没有在torch.cuda.Tensor中定义

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 缩减的维度
  • values (Tensor, optional) – 结果张量
  • indices (Tensor, optional) – 返回的索引结果张量
  1. >>> a
  2. -0.6891 -0.6662
  3. 0.2697 0.7412
  4. 0.5254 -0.7402
  5. 0.5528 -0.2399
  6. [torch.FloatTensor of size 4x2]
  7. >>> a = torch.randn(4, 5)
  8. >>> a
  9. 0.4056 -0.3372 1.0973 -2.4884 0.4334
  10. 2.1336 0.3841 0.1404 -0.1821 -0.7646
  11. -0.2403 1.3975 -2.0068 0.1298 0.0212
  12. -1.5371 -0.7257 -0.4871 -0.2359 -1.1724
  13. [torch.FloatTensor of size 4x5]
  14. >>> torch.median(a, 1)
  15. (
  16. 0.4056
  17. 0.1404
  18. 0.0212
  19. -0.7257
  20. [torch.FloatTensor of size 4x1]
  21. ,
  22. 0
  23. 2
  24. 4
  25. 1
  26. [torch.LongTensor of size 4x1]
  27. )

torch.mode

  1. torch.mode(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

返回给定维dim上,每行的众数值。 同时返回一个LongTensor,包含众数职的索引。dim值默认为输入张量的最后一维。

输出形状与输入相同,除了给定维度上为1.

注意: 这个函数还没有在torch.cuda.Tensor中定义

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 缩减的维度
  • values (Tensor, optional) – 结果张量
  • indices (Tensor, optional) – 返回的索引张量

例子:

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

torch.norm

  1. torch.norm(input, p=2) float

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

参数:

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

例子:

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

返回输入张量给定维dim 上每行的p 范数。输出形状与输入相同,除了给定维度上为1.

参数:

  • input (Tensor) – 输入张量
  • p (float) – 范数计算中的幂指数值
  • dim (int) – 缩减的维度
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> a = torch.randn(4, 2)
  2. >>> 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]
  8. >>> torch.norm(a, 2, 1)
  9. 0.9585
  10. 0.7888
  11. 0.9077
  12. 0.6026
  13. [torch.FloatTensor of size 4x1]
  14. >>> torch.norm(a, 0, 1)
  15. 2
  16. 2
  17. 2
  18. 2
  19. [torch.FloatTensor of size 4x1]

torch.prod

  1. torch.prod(input) float

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

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

例子:

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

返回输入张量给定维度上每行的积。输出形状与输入相同,除了给定维度上为1.

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 缩减的维度
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> a = torch.randn(4, 2)
  2. >>> a
  3. 0.1598 -0.6884
  4. -0.1831 -0.4412
  5. -0.9925 -0.6244
  6. -0.2416 -0.8080
  7. [torch.FloatTensor of size 4x2]
  8. >>> torch.prod(a, 1)
  9. -0.1100
  10. 0.0808
  11. 0.6197
  12. 0.1952
  13. [torch.FloatTensor of size 4x1]

torch.std

  1. torch.std(input) float

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

参数:- input (Tensor) – 输入张量

例子:

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  3. -1.3063 1.4182 -0.3061
  4. [torch.FloatTensor of size 1x3]
  5. >>> torch.std(a)
  6. 1.3782334731508061
  1. torch.std(input, dim, out=None) Tensor

返回输入张量给定维度上每行的标准差。输出形状与输入相同,除了给定维度上为1.

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 缩减的维度
  • out (Tensor, optional) – 结果张量

例子:

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

torch.sum

  1. torch.sum(input) float

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

输出形状与输入相同,除了给定维度上为1.

参数:

  • input (Tensor) – 输入张量

例子:

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

返回输入张量给定维度上每行的和。输出形状与输入相同,除了给定维度上为1.

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 缩减的维度
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> a = torch.randn(4, 4)
  2. >>> a
  3. -0.4640 0.0609 0.1122 0.4784
  4. -1.3063 1.6443 0.4714 -0.7396
  5. -1.3561 -0.1959 1.0609 -1.9855
  6. 2.6833 0.5746 -0.5709 -0.4430
  7. [torch.FloatTensor of size 4x4]
  8. >>> torch.sum(a, 1)
  9. 0.1874
  10. 0.0698
  11. -2.4767
  12. 2.2440
  13. [torch.FloatTensor of size 4x1]

torch.var

  1. torch.var(input) float

返回输入张量所有元素的方差

输出形状与输入相同,除了给定维度上为1.

参数:

  • input (Tensor) – 输入张量

例子:

  1. >>> a = torch.randn(1, 3)
  2. >>> a
  3. -1.3063 1.4182 -0.3061
  4. [torch.FloatTensor of size 1x3]
  5. >>> torch.var(a)
  6. 1.899527506513334
  1. torch.var(input, dim, out=None) Tensor

返回输入张量给定维度上每行的方差。输出形状与输入相同,除了给定维度上为1.

参数:

  • input (Tensor) – 输入张量
  • dim (int) – the dimension to reduce
  • out (Tensor, optional) – 结果张量例子:```python

    a = torch.randn(4, 4)a

-1.2738 -0.3058 0.1230 -1.9615 0.8771 -0.5430 -0.9233 0.9879 1.4107 0.0317 -0.6823 0.2255-1.3854 0.4953 -0.2160 0.2435[torch.FloatTensor of size 4x4]

torch.var(a, 1)

0.8859 0.9509 0.7548 0.6949[torch.FloatTensor of size 4x1]

  1. ## 比较操作 Comparison Ops
  2. ### torch.eq
  3. ```python
  4. torch.eq(input, other, out=None) → Tensor

比较元素相等性。第二个参数可为一个数或与第一个参数同类型形状的张量。

参数:

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

返回值: 一个 torch.ByteTensor 张量,包含了每个位置的比较结果(相等为1,不等为0 )

返回类型: Tensor

例子:

  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]

torch.equal

  1. torch.equal(tensor1, tensor2) bool

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

例子:

  1. >>> torch.equal(torch.Tensor([1, 2]), torch.Tensor([1, 2]))
  2. True

torch.ge

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

逐元素比较inputother,即是否 \( input >= other \)。

如果两个张量有相同的形状和元素值,则返回True ,否则 False。第二个参数可以为一个数或与第一个参数相同形状和类型的张量

参数:

  • input (Tensor) – 待对比的张量
  • other (Tensor or float) – 对比的张量或float
  • out (Tensor, optional) – 输出张量。必须为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]

torch.gt

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

逐元素比较inputother , 即是否\( input > other \)如果两个张量有相同的形状和元素值,则返回True ,否则 False。第二个参数可以为一个数或与第一个参数相同形状和类型的张量

参数:

  • input (Tensor) – 要对比的张量
  • other (Tensor or float) – 要对比的张量或float
  • out (Tensor, optional) – 输出张量。必须为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]

torch.kthvalue

  1. torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor)

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

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

参数:

  • input (Tensor) – 要对比的张量
  • k (int) – 第 k 个最小值
  • dim (int, optional) – 沿着此维进行排序
  • out (tuple, optional) – 输出元组 (Tensor, LongTensor) 可选地给定作为 输出 buffers

例子:

  1. >>> x = torch.arange(1, 6)
  2. >>> x
  3. 1
  4. 2
  5. 3
  6. 4
  7. 5
  8. [torch.FloatTensor of size 5]
  9. >>> torch.kthvalue(x, 4)
  10. (
  11. 4
  12. [torch.FloatTensor of size 1]
  13. ,
  14. 3
  15. [torch.LongTensor of size 1]
  16. )

torch.le

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

逐元素比较inputother , 即是否\( input <= other \)第二个参数可以为一个数或与第一个参数相同形状和类型的张量

参数:

  • input (Tensor) – 要对比的张量
  • other (Tensor or float ) – 对比的张量或float
  • out (Tensor, optional) – 输出张量。必须为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]

torch.lt

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

逐元素比较inputother , 即是否 \( input < other \)

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

参数:

  • input (Tensor) – 要对比的张量
  • other (Tensor or float ) – 对比的张量或float
  • out (Tensor, optional) – 输出张量。必须为ByteTensor或者与第一个参数tensor相同类型。

input: 一个 torch.ByteTensor 张量,包含了每个位置的比较结果(是否 tensor >= 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]

torch.max

  1. torch.max()

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

参数:

  • input (Tensor) – 输入张量

例子:

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

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

输出形状中,将dim维设定为1,其它与输入形状保持一致。

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 指定的维度
  • max (Tensor, optional) – 结果张量,包含给定维度上的最大值
  • max_indices (LongTensor, optional) – 结果张量,包含给定维度上每个最大值的位置索引

例子:

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

返回输入张量给定维度上每行的最大值,并同时返回每个最大值的位置索引。即,\( out_i=max(input_i,other_i) \)

输出形状中,将dim维设定为1,其它与输入形状保持一致。

参数:

  • input (Tensor) – 输入张量
  • other (Tensor) – 输出张量
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> a = torch.randn(4)
  2. >>> a
  3. 1.3869
  4. 0.3912
  5. -0.8634
  6. -0.5468
  7. [torch.FloatTensor of size 4]
  8. >>> b = torch.randn(4)
  9. >>> b
  10. 1.0067
  11. -0.8010
  12. 0.6258
  13. 0.3627
  14. [torch.FloatTensor of size 4]
  15. >>> torch.max(a, b)
  16. 1.3869
  17. 0.3912
  18. 0.6258
  19. 0.3627
  20. [torch.FloatTensor of size 4]

torch.min

  1. torch.min(input) float

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

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

例子:

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

返回输入张量给定维度上每行的最小值,并同时返回每个最小值的位置索引。

输出形状中,将dim维设定为1,其它与输入形状保持一致。

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 指定的维度
  • min (Tensor, optional) – 结果张量,包含给定维度上的最小值
  • min_indices (LongTensor, optional) – 结果张量,包含给定维度上每个最小值的位置索引

例子:

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

input中逐元素与other相应位置的元素对比,返回最小值到输出张量。即,\( out_i = min(tensor_i, other_i)\)

两张量形状不需匹配,但元素数须相同。

注意:当形状不匹配时,input的形状作为返回张量的形状。

参数:

  • input (Tensor) – 输入张量
  • other (Tensor) – 第二个输入张量
  • out (Tensor, optional) – 结果张量

例子:

  1. >>> a = torch.randn(4)
  2. >>> a
  3. 1.3869
  4. 0.3912
  5. -0.8634
  6. -0.5468
  7. [torch.FloatTensor of size 4]
  8. >>> b = torch.randn(4)
  9. >>> b
  10. 1.0067
  11. -0.8010
  12. 0.6258
  13. 0.3627
  14. [torch.FloatTensor of size 4]
  15. >>> torch.min(a, b)
  16. 1.0067
  17. -0.8010
  18. -0.8634
  19. -0.5468
  20. [torch.FloatTensor of size 4]

torch.ne

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

逐元素比较inputother , 即是否 \( input != other \)。第二个参数可以为一个数或与第一个参数相同形状和类型的张量

参数:

  • input (Tensor) – 待对比的张量
  • other (Tensor or float) – 对比的张量或float
  • out (Tensor, optional) – 输出张量。必须为ByteTensor或者与input相同类型。

返回值: 一个 torch.ByteTensor 张量,包含了每个位置的比较结果 (如果 tensor != other 为True ,返回1)。

返回类型: 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]

torch.sort

  1. torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor)

对输入张量input沿着指定维按升序排序。如果不给定dim,则默认为输入的最后一维。如果指定参数descendingTrue,则按降序排序

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

参数:

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

例子:

  1. >>> x = torch.randn(3, 4)
  2. >>> sorted, indices = torch.sort(x)
  3. >>> sorted
  4. -1.6747 0.0610 0.1190 1.4137
  5. -1.4782 0.7159 1.0341 1.3678
  6. -0.3324 -0.0782 0.3518 0.4763
  7. [torch.FloatTensor of size 3x4]
  8. >>> indices
  9. 0 1 3 2
  10. 2 1 0 3
  11. 3 1 0 2
  12. [torch.LongTensor of size 3x4]
  13. >>> sorted, indices = torch.sort(x, 0)
  14. >>> sorted
  15. -1.6747 -0.0782 -1.4782 -0.3324
  16. 0.3518 0.0610 0.4763 0.1190
  17. 1.0341 0.7159 1.4137 1.3678
  18. [torch.FloatTensor of size 3x4]
  19. >>> indices
  20. 0 2 1 2
  21. 2 0 2 0
  22. 1 1 0 1
  23. [torch.LongTensor of size 3x4]

torch.topk

  1. torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

沿给定dim维度返回输入张量inputk 个最大值。如果不指定dim,则默认为input的最后一维。如果为largestFalse ,则返回最小的 k 个值。

返回一个元组 (values,indices),其中indices是原始输入张量input中测元素下标。如果设定布尔值sortedTrue,将会确保返回的 k 个值被排序。

参数:

  • input (Tensor) – 输入张量
  • k (int) – “top-k”中的k
  • dim (int, optional) – 排序的维
  • largest (bool, optional) – 布尔值,控制返回最大或最小值
  • sorted (bool, optional) – 布尔值,控制返回值是否排序
  • out (tuple, optional) – 可选输出张量 (Tensor, LongTensor) output buffers
  1. >>> x = torch.arange(1, 6)
  2. >>> x
  3. 1
  4. 2
  5. 3
  6. 4
  7. 5
  8. [torch.FloatTensor of size 5]
  9. >>> torch.topk(x, 3)
  10. (
  11. 5
  12. 4
  13. 3
  14. [torch.FloatTensor of size 3]
  15. ,
  16. 4
  17. 3
  18. 2
  19. [torch.LongTensor of size 3]
  20. )
  21. >>> torch.topk(x, 3, 0, largest=False)
  22. (
  23. 1
  24. 2
  25. 3
  26. [torch.FloatTensor of size 3]
  27. ,
  28. 0
  29. 1
  30. 2
  31. [torch.LongTensor of size 3]
  32. )

其它操作 Other Operations

torch.cross

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

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

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

参数:

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

例子:

  1. >>> a = torch.randn(4, 3)
  2. >>> a
  3. -0.6652 -1.0116 -0.6857
  4. 0.2286 0.4446 -0.5272
  5. 0.0476 0.2321 1.9991
  6. 0.6199 1.1924 -0.9397
  7. [torch.FloatTensor of size 4x3]
  8. >>> b = torch.randn(4, 3)
  9. >>> b
  10. -0.1042 -1.1156 0.1947
  11. 0.9947 0.1149 0.4701
  12. -1.0108 0.8319 -0.0750
  13. 0.9045 -1.3754 1.0976
  14. [torch.FloatTensor of size 4x3]
  15. >>> torch.cross(a, b, dim=1)
  16. -0.9619 0.2009 0.6367
  17. 0.2696 -0.6318 -0.4160
  18. -1.6805 -2.0171 0.2741
  19. 0.0163 -1.5304 -1.9311
  20. [torch.FloatTensor of size 4x3]
  21. >>> torch.cross(a, b)
  22. -0.9619 0.2009 0.6367
  23. 0.2696 -0.6318 -0.4160
  24. -1.6805 -2.0171 0.2741
  25. 0.0163 -1.5304 -1.9311
  26. [torch.FloatTensor of size 4x3]

torch.diag

  1. torch.diag(input, diagonal=0, out=None) Tensor
  • 如果输入是一个向量(1D 张量),则返回一个以input为对角线元素的2D方阵
  • 如果输入是一个矩阵(2D 张量),则返回一个包含input对角线元素的1D张量

参数diagonal指定对角线:

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

参数:

  • input (Tensor) – 输入张量
  • diagonal (int, optional) – 指定对角线
  • out (Tensor, optional) – 输出张量

例子:

  • 取得以input为对角线的方阵:```python

    a = torch.randn(3)a

    1.0480-2.3405-1.1138[torch.FloatTensor of size 3]

torch.diag(a)

1.0480 0.0000 0.0000 0.0000 -2.3405 0.0000 0.0000 0.0000 -1.1138[torch.FloatTensor of size 3x3]

torch.diag(a, 1)

0.0000 1.0480 0.0000 0.0000 0.0000 0.0000 -2.3405 0.0000 0.0000 0.0000 0.0000 -1.1138 0.0000 0.0000 0.0000 0.0000[torch.FloatTensor of size 4x4]

  1. - 取得给定矩阵第`k`个对角线:

a = torch.randn(3, 3)a

-1.5328 -1.3210 -1.5204 0.8596 0.0471 -0.2239-0.6617 0.0146 -1.0817[torch.FloatTensor of size 3x3]

torch.diag(a, 0)

-1.5328 0.0471-1.0817[torch.FloatTensor of size 3]

torch.diag(a, 1)

-1.3210-0.2239[torch.FloatTensor of size 2]

  1. ### torch.histc
  2. ```python
  3. torch.histc(input, bins=100, min=0, max=0, out=None) → Tensor

计算输入张量的直方图。以minmax为range边界,将其均分成bins个直条,然后将排序好的数据划分到各个直条(bins)中。如果minmax都为0, 则利用数据中的最大最小值作为边界。

参数:

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

返回: 直方图返回类型:张量

例子:

  1. >>> torch.histc(torch.FloatTensor([1, 2, 1]), bins=4, min=0, max=3)
  2. FloatTensor([0, 2, 1, 0])

torch.renorm

  1. torch.renorm(input, p, dim, maxnorm, out=None) Tensor

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

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

注意: 更详细解释参考torch7 以及Hinton et al. 2012, p. 2

参数:

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

例子:

  1. >>> x = torch.ones(3, 3)
  2. >>> x[1].fill_(2)
  3. >>> x[2].fill_(3)
  4. >>> x
  5. 1 1 1
  6. 2 2 2
  7. 3 3 3
  8. [torch.FloatTensor of size 3x3]
  9. >>> torch.renorm(x, 1, 0, 5)
  10. 1.0000 1.0000 1.0000
  11. 1.6667 1.6667 1.6667
  12. 1.6667 1.6667 1.6667
  13. [torch.FloatTensor of size 3x3]

torch.trace

  1. torch.trace(input) float

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

例子:

  1. >>> x = torch.arange(1, 10).view(3, 3)
  2. >>> x
  3. 1 2 3
  4. 4 5 6
  5. 7 8 9
  6. [torch.FloatTensor of size 3x3]
  7. >>> torch.trace(x)
  8. 15.0

torch.tril

  1. torch.tril(input, k=0, out=None) Tensor

返回一个张量out,包含输入矩阵(2D张量)的下三角部分,out其余部分被设为0。这里所说的下三角部分为矩阵指定对角线diagonal之上的元素。

参数k控制对角线:

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

参数:

  • input (Tensor) – 输入张量
  • k (int, optional) – 指定对角线
  • out (Tensor, optional) – 输出张量

例子:

  1. >>> a = torch.randn(3,3)
  2. >>> a
  3. 1.3225 1.7304 1.4573
  4. -0.3052 -0.3111 -0.1809
  5. 1.2469 0.0064 -1.6250
  6. [torch.FloatTensor of size 3x3]
  7. >>> torch.tril(a)
  8. 1.3225 0.0000 0.0000
  9. -0.3052 -0.3111 0.0000
  10. 1.2469 0.0064 -1.6250
  11. [torch.FloatTensor of size 3x3]
  12. >>> torch.tril(a, k=1)
  13. 1.3225 1.7304 0.0000
  14. -0.3052 -0.3111 -0.1809
  15. 1.2469 0.0064 -1.6250
  16. [torch.FloatTensor of size 3x3]
  17. >>> torch.tril(a, k=-1)
  18. 0.0000 0.0000 0.0000
  19. -0.3052 0.0000 0.0000
  20. 1.2469 0.0064 0.0000
  21. [torch.FloatTensor of size 3x3]

torch.triu

  1. torch.triu(input, k=0, out=None) Tensor

返回一个张量,包含输入矩阵(2D张量)的上三角部分,其余部分被设为0。这里所说的上三角部分为矩阵指定对角线diagonal之上的元素。

参数k控制对角线:

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

参数:

  • input (Tensor) – 输入张量
  • k (int, optional) – 指定对角线
  • out (Tensor, optional) – 输出张量

例子:

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

BLAS and LAPACK Operations

torch.addbmm

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

对两个批batch1batch2内存储的矩阵进行批矩阵乘操作,附带reduced add 步骤( 所有矩阵乘结果沿着第一维相加)。矩阵mat加到最终结果。batch1batch2都为包含相同数量矩阵的3维张量。如果batch1是形为\(b\times n \times m \)的张量,batch1是形为\(b\times m \times p \)的张量,则outmat的形状都是\(n \times p \),即 \( res=(beta∗M)+(alpha∗sum(batch1_i@batch2_i,i=0,b)) \)

对类型为 FloatTensorDoubleTensor 的输入,alphaand beta必须为实数,否则两个参数须为整数。

参数:

  • beta (Number, optional) – 用于mat的乘子
  • mat (Tensor) – 相加矩阵
  • alpha (Number, optional) – 用于\(batch1 @ batch2 \)的乘子
  • batch1 (Tensor) – 第一批相乘矩阵
  • batch2 (Tensor) – 第二批相乘矩阵
  • out (Tensor, optional) – 输出张量

例子:

  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)
  5. -3.1162 11.0071 7.3102 0.1824 -7.6892
  6. 1.8265 6.0739 0.4589 -0.5641 -5.4283
  7. -9.3387 -0.1794 -1.2318 -6.8841 -4.7239
  8. [torch.FloatTensor of size 3x5]

torch.addmm

  1. torch.addmm(beta=1, mat, alpha=1, mat1, mat2, out=None) Tensor

对矩阵mat1mat2进行矩阵乘操作。矩阵mat加到最终结果。如果mat1 是一个 \(n \times m \)张量,mat2 是一个 \(m \times p \)张量,那么outmat的形状为\(n \times p \)。alphabeta 分别是两个矩阵 \(mat1 @ mat2 \)和\(mat \)的比例因子,即, \(out=(beta∗M)+(alpha∗mat1@mat2) \)

对类型为 FloatTensorDoubleTensor 的输入,betaand alpha必须为实数,否则两个参数须为整数。

参数 :

  • beta (Number, optional) – 用于mat的乘子
  • mat (Tensor) – 相加矩阵
  • alpha (Number, optional) – 用于\(mat1 @ mat2 \)的乘子
  • mat1 (Tensor) – 第一个相乘矩阵
  • mat2 (Tensor) – 第二个相乘矩阵
  • out (Tensor, optional) – 输出张量
  1. >>> M = torch.randn(2, 3)
  2. >>> mat1 = torch.randn(2, 3)
  3. >>> mat2 = torch.randn(3, 3)
  4. >>> torch.addmm(M, mat1, mat2)
  5. -0.4095 -1.9703 1.3561
  6. 5.7674 -4.9760 2.7378
  7. [torch.FloatTensor of size 2x3]

torch.addmv

  1. torch.addmv(beta=1, tensor, alpha=1, mat, vec, out=None) Tensor

对矩阵mat和向量vec对进行相乘操作。向量tensor加到最终结果。如果mat 是一个 \(n \times m \)维矩阵,vec 是一个 \(m \)维向量,那么outmat的为\(n \)元向量。可选参数alphabeta 分别是 \(mat * vec \)和\(mat \)的比例因子,即, \( out=(beta∗tensor)+(alpha∗(mat@vec)) \)

对类型为FloatTensorDoubleTensor的输入,alphaand beta必须为实数,否则两个参数须为整数。

参数 :

  • beta (Number, optional) – 用于mat的乘子
  • mat (Tensor) – 相加矩阵
  • alpha (Number, optional) – 用于\(mat1 @ vec \)的乘子
  • mat (Tensor) – 相乘矩阵
  • vec (Tensor) – 相乘向量
  • out (Tensor, optional) – 输出张量
  1. >>> M = torch.randn(2)
  2. >>> mat = torch.randn(2, 3)
  3. >>> vec = torch.randn(3)
  4. >>> torch.addmv(M, mat, vec)
  5. -2.0939
  6. -2.2950
  7. [torch.FloatTensor of size 2]

torch.addr

  1. torch.addr(beta=1, mat, alpha=1, vec1, vec2, out=None) Tensor

对向量vec1vec2对进行张量积操作。矩阵mat加到最终结果。如果vec1 是一个 \(n \)维向量,vec2 是一个 \(m \)维向量,那么矩阵mat的形状须为\(n \times m \)。可选参数betaalpha 分别是两个矩阵 \(mat \)和 \(vec1 @ vec2 \)的比例因子,即,\( resi=(beta∗Mi)+(alpha∗batch1i×batch2i)\)

对类型为FloatTensorDoubleTensor的输入,alphaand beta必须为实数,否则两个参数须为整数。

参数 :

  • beta (Number, optional) – 用于mat的乘子
  • mat (Tensor) – 相加矩阵
  • alpha (Number, optional) – 用于两向量\(vec1, vec2 \)外积的乘子
  • vec1 (Tensor) – 第一个相乘向量
  • vec2 (Tensor) – 第二个相乘向量
  • out (Tensor, optional) – 输出张量
  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]

torch.baddbmm

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

对两个批batch1batch2内存储的矩阵进行批矩阵乘操作,矩阵mat加到最终结果。batch1batch2都为包含相同数量矩阵的3维张量。如果batch1是形为\(b\times n \times m \)的张量,batch1是形为\(b\times m \times p \)的张量,则outmat的形状都是\(n \times p \),即 \( resi=(beta∗M_i)+(alpha∗batch1_i×batch2_i) \)

对类型为FloatTensorDoubleTensor的输入,alphaand beta必须为实数,否则两个参数须为整数。

参数:

  • beta (Number, optional) – 用于mat的乘子
  • mat (Tensor) – 相加矩阵
  • alpha (Number, optional) – 用于\(batch1 @ batch2 \)的乘子
  • batch1 (Tensor) – 第一批相乘矩阵
  • batch2 (Tensor) – 第二批相乘矩阵
  • out (Tensor, optional) – 输出张量
  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])

torch.bmm

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

对存储在两个批batch1batch2内的矩阵进行批矩阵乘操作。batch1batch2都为包含相同数量矩阵的3维张量。如果batch1是形为\(b\times n \times m \)的张量,batch1是形为\(b\times m \times p \)的张量,则outmat的形状都是\(n \times p \),即 \( res=(beta∗M)+(alpha∗sum(batch1_i@batch2_i,i=0,b)) \)

对类型为 FloatTensorDoubleTensor 的输入,alphaand beta必须为实数,否则两个参数须为整数。

参数:

  • batch1 (Tensor) – 第一批相乘矩阵
  • batch2 (Tensor) – 第二批相乘矩阵
  • out (Tensor, optional) – 输出张量
  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])

torch.btrifact

  1. torch.btrifact(A, info=None) Tensor, IntTensor

返回一个元组,包含LU 分解和pivots 。 可选参数info决定是否对每个minibatch样本进行分解。info are from dgetrf and a non-zero value indicates an error occurred. 如果用CUDA的话,这个值来自于CUBLAS,否则来自LAPACK。

参数: A (Tensor) – 待分解张量

  1. >>> A = torch.randn(2, 3, 3)
  2. >>> A_LU = A.btrifact()

torch.btrisolve

  1. torch.btrisolve(b, LU_data, LU_pivots) Tensor

返回线性方程组\( Ax = b \)的LU解。

参数:

  • b (Tensor) – RHS 张量.
  • LU_data (Tensor) – Pivoted LU factorization of A from btrifact.
  • LU_pivots (IntTensor) – LU 分解的Pivots.

例子:

  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

torch.dot

  1. torch.dot(tensor1, tensor2) float

计算两个张量的点乘(内乘),两个张量都为1-D 向量.

例子:

  1. >>> torch.dot(torch.Tensor([2, 3]), torch.Tensor([2, 1]))
  2. 7.0

torch.eig

  1. torch.eig(a, eigenvectors=False, out=None) -> (Tensor, Tensor)

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

参数:

  • a (Tensor) – 方阵,待计算其特征值和特征向量
  • eigenvectors (bool) – 布尔值,如果True,则同时计算特征值和特征向量,否则只计算特征值。
  • out (tuple, optional) – 输出元组

返回值: 元组,包括:

  • e (Tensor): a 的右特征向量
  • v (Tensor): 如果eigenvectorsTrue,则为包含特征向量的张量; 否则为空张量

返回值类型: (Tensor, Tensor)

torch.gels

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

对形如\( m \times n \)的满秩矩阵a计算其最小二乘和最小范数问题的解。如果\( m >= n \),gels对最小二乘问题进行求解,即:minimize \qquad ‖AX - B‖_F

如果\( m < n \),gels求解最小范数问题,即:minimize \qquad ‖ X ‖_F \qquad subject \ to \quad a \quad b AX=B

返回矩阵\(X \)的前\(n \) 行包含解。余下的行包含以下残差信息: 相应列从第n 行开始计算的每列的欧式距离。

注意: 返回矩阵总是被转置,无论输入矩阵的原始布局如何,总会被转置;即,总是有 stride (1, m) 而不是 (m, 1).

参数:

  • B (Tensor) – 矩阵B
  • A (Tensor) – \( m \times n \)矩阵
  • out (tuple, optional) – 输出元组

返回值: 元组,包括:

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

返回值类型: (Tensor, Tensor)

例子:

  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]

torch.geqrf

  1. torch.geqrf(input, out=None) -> (Tensor, Tensor)

这是一个直接调用LAPACK的底层函数。一般使用torch.qr()

计算输入的QR 分解,但是并不会分别创建Q,R两个矩阵,而是直接调用LAPACK 函数Rather, this directly calls the underlying LAPACK function ?geqrf which produces a sequence of ‘elementary reflectors’.

参考 LAPACK文档获取更详细信息。

参数:

  • input (Tensor) – 输入矩阵
  • out (tuple, optional) – 元组,包含输出张量 (Tensor, Tensor)

torch.ger

  1. torch.ger(vec1, vec2, out=None) Tensor

计算两向量vec1,vec2的张量积。如果vec1的长度为n,vec2长度为m,则输出out应为形如n x m的矩阵。

参数:

  • vec1 (Tensor) – 1D 输入向量
  • vec2 (Tensor) – 1D 输入向量
  • out (tuple, optional) – 输出张量

例子:

  1. >>> v1 = torch.arange(1, 5)
  2. >>> v2 = torch.arange(1, 4)
  3. >>> torch.ger(v1, v2)
  4. 1 2 3
  5. 2 4 6
  6. 3 6 9
  7. 4 8 12
  8. [torch.FloatTensor of size 4x3]

torch.gesv

  1. torch.gesv(B, A, out=None) -> (Tensor, Tensor)

\( X, LU = torch.gesv(B, A) \),返回线性方程组\(AX=B \)的解。

LU 包含两个矩阵L,U。A须为非奇异方阵,如果A是一个\( m \times m \)矩阵,B 是\( m \times k \)矩阵,则LU 是\( m \times m \)矩阵, X为\( m \times k \)矩阵

参数:

  • B (Tensor) – \( m \times k \)矩阵
  • A (Tensor) – \( m \times m \)矩阵
  • out (Tensor, optional) – 可选地输出矩阵\( X \)

例子:

  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

torch.inverse

  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) – 输入2维张量
  • out (Tensor, optional) – 输出张量

例子:

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

torch.mm

  1. torch.mm(mat1, mat2, out=None) Tensor

对矩阵mat1mat2进行相乘。 如果mat1 是一个\( n \times m \) 张量,mat2 是一个 \( m \times p \) 张量,将会输出一个 \( n \times p \) 张量out

参数 :

  • mat1 (Tensor) – 第一个相乘矩阵
  • mat2 (Tensor) – 第二个相乘矩阵
  • out (Tensor, optional) – 输出张量

例子:

  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]

torch.mv

  1. torch.mv(mat, vec, out=None) Tensor

对矩阵mat和向量vec进行相乘。 如果mat 是一个\( n \times m \)张量,vec 是一个\( m \)元 1维张量,将会输出一个\( n \) 元 1维张量。

参数 :

  • mat (Tensor) – 相乘矩阵
  • vec (Tensor) – 相乘向量
  • out (Tensor, optional) – 输出张量

例子:

  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]

torch.orgqr

  1. torch.orgqr()

torch.ormqr

  1. torch.ormqr()

torch.potrf

  1. torch.potrf()

torch.potri

  1. torch.potri()

torch.potrs

  1. torch.potrs()

torch.pstrf

  1. torch.pstrf()

torch.qr

  1. torch.qr(input, out=None) -> (Tensor, Tensor)

计算输入矩阵的QR分解:返回两个矩阵\( q \) ,\( r \), 使得 \( x=q∗r \) ,这里\( q \) 是一个半正交矩阵与 \( r \) 是一个上三角矩阵

本函数返回一个thin(reduced)QR分解。

注意 如果输入很大,可能可能会丢失精度。

注意 本函数依赖于你的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) – 输入的2维张量
  • out (tuple, optional) – 输出元组tuple,包含Q和R

例子:

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

torch.svd

  1. torch.svd(input, some=True, out=None) -> (Tensor, Tensor, Tensor)

\(U, S, V = torch.svd(A) \)。 返回对形如 \(n \times m \)的实矩阵 A 进行奇异值分解的结果,使得 \(A=USV′∗ \)。\(U \) 形状为 \(n \times n \),\(S \) 形状为 \(n \times m \) ,\(V \) 形状为 \(m \times m \)

some 代表了需要计算的奇异值数目。如果 some=True, it computes some and some=False computes all.

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

参数:

  • input (Tensor) – 输入的2维张量
  • some (bool, optional) – 布尔值,控制需计算的奇异值数目
  • out (tuple, optional) – 结果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
  7. 8.7900 9.9300 9.8300 5.4500 3.1600
  8. 6.1100 6.9100 5.0400 -0.2700 7.9800
  9. -9.1500 -7.9300 4.8600 4.8500 3.0100
  10. 9.5700 1.6400 8.8300 0.7400 5.8000
  11. -3.4900 4.0200 9.8000 10.0000 4.2700
  12. 9.8400 0.1500 -8.9900 -6.0200 -5.3100
  13. [torch.FloatTensor of size 6x5]
  14. >>> u, s, v = torch.svd(a)
  15. >>> u
  16. -0.5911 0.2632 0.3554 0.3143 0.2299
  17. -0.3976 0.2438 -0.2224 -0.7535 -0.3636
  18. -0.0335 -0.6003 -0.4508 0.2334 -0.3055
  19. -0.4297 0.2362 -0.6859 0.3319 0.1649
  20. -0.4697 -0.3509 0.3874 0.1587 -0.5183
  21. 0.2934 0.5763 -0.0209 0.3791 -0.6526
  22. [torch.FloatTensor of size 6x5]
  23. >>> s
  24. 27.4687
  25. 22.6432
  26. 8.5584
  27. 5.9857
  28. 2.0149
  29. [torch.FloatTensor of size 5]
  30. >>> v
  31. -0.2514 0.8148 -0.2606 0.3967 -0.2180
  32. -0.3968 0.3587 0.7008 -0.4507 0.1402
  33. -0.6922 -0.2489 -0.2208 0.2513 0.5891
  34. -0.3662 -0.3686 0.3859 0.4342 -0.6265
  35. -0.4076 -0.0980 -0.4932 -0.6227 -0.4396
  36. [torch.FloatTensor of size 5x5]
  37. >>> torch.dist(a, torch.mm(torch.mm(u, torch.diag(s)), v.t()))
  38. 8.934150226306685e-06

torch.symeig

  1. torch.symeig(input, eigenvectors=False, upper=True, out=None) -> (Tensor, Tensor)

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

\(input\) 和 \(V\) 为 \(m \times m\) 矩阵,\(e \) 是一个\(m\) 维向量。此函数计算intput的所有特征值(和特征向量),使得 \(input = V diag(e) V’\)布尔值参数eigenvectors 规定是否只计算特征向量。如果为False,则只计算特征值;若设为True,则两者都会计算。因为输入矩阵 \( input\) 是对称的,所以默认只需要上三角矩阵。如果参数upperFalse,下三角矩阵部分也被利用。

注意: 不管原来Irrespective of the original strides, the returned matrix V will be transposed, i.e. with strides (1, m) instead of (m, 1)

参数:

  • input (Tensor) – 输入对称矩阵
  • eigenvectors (boolean, optional) – 布尔值(可选),控制是否计算特征向量
  • upper (boolean, optional) – 布尔值(可选),控制是否考虑上三角或下三角区域
  • out (tuple, optional) – 输出元组(Tensor, Tensor)

例子:

  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()
  6. >>> e, v = torch.symeig(a, eigenvectors=True)
  7. >>> e
  8. -11.0656
  9. -6.2287
  10. 0.8640
  11. 8.8655
  12. 16.0948
  13. [torch.FloatTensor of size 5]
  14. >>> v
  15. -0.2981 -0.6075 0.4026 -0.3745 0.4896
  16. -0.5078 -0.2880 -0.4066 -0.3572 -0.6053
  17. -0.0816 -0.3843 -0.6600 0.5008 0.3991
  18. -0.0036 -0.4467 0.4553 0.6204 -0.4564
  19. -0.8041 0.4480 0.1725 0.3108 0.1622
  20. [torch.FloatTensor of size 5x5]

torch.trtrs

  1. torch.trtrs()