Torch

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

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

张量 Tensors

torch.is_tensor(obj)

判断是否为张量，如果是 pytorch 张量，则返回 True

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

torch.is_storage(obj)

判断是否为 pytorch Storage，如何是，则返回 True

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

torch.set_default_tensor_type(t)

torch.numel(input)->int

返回input 张量中的元素个数

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

例子:

>>> a = torch.randn(1,2,3,4,5)
>>> torch.numel(a)
120
>>> a = torch.zeros(4,4)
>>> torch.numel(a)
16

torch.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None)

设置打印选项。 完全参考自 Numpy。

参数:

• precision – 浮点数输出的精度位数 (默认为 8 )
• threshold – 阈值，触发汇总显示而不是完全显示(repr)的数组元素的总数 （默认为 1000）
• edgeitems – 每个维度的开头和结尾的摘要中的数组项目数（默认为 3）。
• linewidth – 用于插入行间隔的每行字符数（默认为 80）。阈值矩阵将忽略此参数。
• profile – pretty 打印的完全默认值。 可以覆盖上述所有选项 (默认为 short, full)

创建操作 Creation Ops

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

返回一个 2 维张量，对角线数字为 1，其它位置为 0

参数:

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

返回值: 2 维张量，对角线为 1，其它为 0

返回类型： Tensor

例子:

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

torch.from_numpy(ndarray) → Tensor

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

例子:

>>> a = numpy.array([1, 2, 3])
>>> t = torch.from_numpy(a)
>>> t
torch.LongTensor([1, 2, 3])
>>> t[0] = -1
>>> a
array([-1,  2,  3])

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

返回 start 和 end 之间长度为steps的一维张量 参数:

• start (float) – 点集的起始值
• end (float) – 点集的最终值
• steps (int) – 在start 和 end间的采样数,即返回多少个数
• out (Tensor, 可选的) – 结果张量

例子:

>>> torch.linspace(1.0,10.0,steps=5,out=None)
  1.0000
  3.2500
  5.5000
  7.7500
 10.0000
[torch.FloatTensor of size 5]
>>> torch.linspace(-10, 10, steps=5)
-10
 -5
  0
  5
 10
[torch.FloatTensor of size 5]
>>> torch.linspace(start=-10, end=10, steps=5)
-10
 -5
  0
  5
 10
[torch.FloatTensor of size 5]

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

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

参数:

• start (float) – 该点集的起始点
• end (float) – 该点集的最终值
• steps (int) – 在start 和 end间生成的样本数
• out (Tensor, 可选) – 结果张量

例子:

>>> torch.logspace(start=-10, end=10, steps=5)
 1.0000e-10
 1.0000e-05
 1.0000e+00
 1.0000e+05
 1.0000e+10
[torch.FloatTensor of size 5]
>>> torch.logspace(start=0.1, end=1.0, steps=5)
  1.2589
  2.1135
  3.5481
  5.9566
 10.0000
[torch.FloatTensor of size 5]

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

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

参数:

• sizes (int...) – 整数序列，定义了输出形状,如：(5,5)，(2)
• out (Tensor, 可选) – 结果张量

例子:

>>> torch.ones(2, 3)
 1  1  1
 1  1  1
[torch.FloatTensor of size 2x3]
>>> torch.ones(5)
 1
 1
 1
 1
 1
[torch.FloatTensor of size 5]

torch.rand(*sizes, out=None) → Tensor

返回一个张量，填充在[0,1]区间的一组均匀分布随机数。 Tensor 的形状由变量sizes定义。

参数:

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

例子：

>>> torch.rand(4)
 0.9193
 0.3347
 0.3232
 0.7715
[torch.FloatTensor of size 4]
>>> torch.rand(2, 3,out=None)
 0.5010  0.5140  0.0719
 0.1435  0.5636  0.0538
[torch.FloatTensor of size 2x3]

torch.randn(*sizes, out=None) → Tensor

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

参数:

• sizes (int...) – 整数序列，定义了输出形状
• `out (Tensor, 可选) - 结果张量

例子：:

>>> torch.randn(4)
-0.1145
 0.0094
-1.1717
 0.9846
[torch.FloatTensor of size 4]
>>> torch.randn(2, 3)
 1.4339  0.3351 -1.0999
 1.5458 -0.9643 -0.3558
[torch.FloatTensor of size 2x3]

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

输入参数n，返回一个从0 到n -1的随机整数排列。

参数:

• n(int) – 上限(独占),即最大值

例子：

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

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

返回一个 1 维张量，长度为 floor((end−start)/step),floor 代表向下取整。包含从start到end，以step为步长的一组序列值(默认步长为 1)。

参数:

• start (float) – 该点集的起始点
• end (float) – 该点集的终止点
• step (float) – 相邻点的间隔大小
• out (Tensor, 可选的) – 结果张量

例子：

>>> torch.arange(1, 4)
 1
 2
 3
[torch.FloatTensor of size 3]
>>> torch.arange(1, 2.5, 0.5)
 1.0000
 1.5000
 2.0000
[torch.FloatTensor of size 3]

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

返回一个 1 维张量，长度为 floor((end−start)/step)+1，其中 floor 代表向下取整数。从start开始，end为结尾，以step为步长的一组值。 step 是两个值之间的间隔，即 Xi+1=Xi+step

参数:

• start (float) – 该点集的起始点
• end (float) – 该点集的最终值
• step (int) – 相邻点之间的间隔大小
• out (Tensor, 可选的) – 结果张量

例子：

>>> torch.range(1, 4)
 1
 2
 3
 4
[torch.FloatTensor of size 4]
>>> torch.range(1, 4, 0.5)
 1.0000
 1.5000
 2.0000
 2.5000
 3.0000
 3.5000
 4.0000
[torch.FloatTensor of size 7]

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

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

参数:

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

例子：

>>> torch.zeros(2, 3)
 0  0  0
 0  0  0
[torch.FloatTensor of size 2x3]
>>> torch.zeros(5)
 0
 0
 0
 0
 0
[torch.FloatTensor of size 5]

索引,切片,连接,变异操作

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

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

torch.cat()可以看做 torch.split() 和 torch.chunk()的逆运算。

cat()函数可以通过下面例子很好的的理解。

参数:

• seq（Tensors 的序列） - 可以是相同类型的 Tensor 的任何 python 序列。
• dim（int，可选） - 张量连接的尺寸

• out（Tensor，可选） - 输出参数

  例子：

   >>> x = torch.randn(2, 3)
  >>> x
  0.5983 -0.0341  2.4918
  1.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]

 ```python
torch.chunk(tensor, chunks, dim=0)
```pypy
将张量沿着给定维度分解成的多个块。
参数:
*   tensor (Tensor) – 待分块的输入张量
*   chunks (int) – 分块的个数
*   dim (int) – 沿着此维度进行分块

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

 沿给定轴`dim`，将输入索引张量`index`指定位置的值进行聚合。
对一个 3 维张量，输出可以定义为：

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

 如果输入是一个 n 维张量（(x0,x1...,xi−1,xi,xi+1,...,xn−1)和暗=我，然后指数必须是一个 n 维张量的大小(x0,x1,...,xi−1,y,xi+1,...,xn−1)其中 y > = 1 和有同样大小的指标。
参数：
*   input(Tensor) - 源张量
*   dim(int) - 要索引的轴
*   index(LongTensor) - 要收集的元素的索引
*   out(Tensor，可选) - 目的张量
例子：

t = torch.Tensor([[1,2],[3,4]]) torch.gather(t, 1, torch.LongTensor([[0,0],[1,0]])) 1 1 4 3 [torch.FloatTensor of size 2x2] ```pypy

torch.index_select(input, dim, index, out=None) → Tensor
```pypy
返回一个新的张量，其索引 input 张量沿尺寸 dim 使用的条目中 index 这是一个 LongTensor。
返回的 Tensor 具有与原始 Tensor 相同数量的尺寸。
注意： 返回的张量不与原始张量共享内存空间。
参数:
*   input (Tensor) – 输入张量
*   dim (int) – 索引的轴
*   index (LongTensor) – 包含索引下标的一维张量
*   out (Tensor, 可选的) – 目标张量
例子：

x = torch.randn(3, 4) x

1.2045 2.4084 0.4001 1.1372 0.5596 1.5677 0.6219 -0.7954 1.3635 -1.2313 -0.5414 -1.8478 [torch.FloatTensor of size 3x4]

indices = torch.LongTensor([0, 2]) torch.index_select(x, 0, indices)

1.2045 2.4084 0.4001 1.1372 1.3635 -1.2313 -0.5414 -1.8478 [torch.FloatTensor of size 2x4]

torch.index_select(x, 1, indices)

1.2045 0.4001 0.5596 0.6219 1.3635 -0.5414 [torch.FloatTensor of size 3x2]

 * * *

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

 根据掩码张量`mask`中的二元值，取输入张量中的指定项( `mask`为一个 _ByteTensor_)，将取值返回到一个新的 1D 张量，
张量 `mask`须跟`input`张量有相同数量的元素数目，但形状或维度不需要相同。 注意： 返回的张量不与原始张量共享内存空间。
参数:
*   input (Tensor) – 输入张量
*   mask (ByteTensor) – 掩码张量，包含了二元索引值
*   out (Tensor, 可选的) – 目标张量
例子：

x = torch.randn(3, 4) x

1.2045 2.4084 0.4001 1.1372 0.5596 1.5677 0.6219 -0.7954 1.3635 -1.2313 -0.5414 -1.8478 [torch.FloatTensor of size 3x4]

indices = torch.LongTensor([0, 2]) torch.index_select(x, 0, indices)

1.2045 2.4084 0.4001 1.1372 1.3635 -1.2313 -0.5414 -1.8478 [torch.FloatTensor of size 2x4]

torch.index_select(x, 1, indices)

1.2045 0.4001 0.5596 0.6219 1.3635 -0.5414 [torch.FloatTensor of size 3x2]

 ### torch.nonzero

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

 返回一个包含输入`input`中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。
如果输入`input`有`n`维，则输出的索引张量`output`的形状为 z x n, 这里 z 是输入张量`input`中所有非零元素的个数。
参数:
*   input (Tensor) – 源张量
*   out (LongTensor, 可选的) – 包含索引值的结果张量
例子：

torch.nonzero(torch.Tensor([1, 1, 1, 0, 1]))

0 1 2 4 [torch.LongTensor of size 4x1]

torch.nonzero(torch.Tensor([[0.6, 0.0, 0.0, 0.0], … [0.0, 0.4, 0.0, 0.0], … [0.0, 0.0, 1.2, 0.0], … [0.0, 0.0, 0.0,-0.4]]))

0 0 1 1 2 2 3 3 [torch.LongTensor of size 4x2]

 ### torch.split

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

 将输入张量分割成相等形状的 chunks（如果可分）。 如果沿指定维的张量形状大小不能被`split_size` 整分， 则最后一个分块会小于其它分块。
参数:
*   tensor (Tensor) – 待分割张量
*   split_size (int) – 单个分块的形状大小
*   dim (int) – 沿着此维进行分割
### torch.squeeze

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, 可选的) – 如果给定，则`input`只会在给定维度挤压
*   out (Tensor, 可选的) – 输出张量
例子：

x = torch.zeros(2,1,2,1,2) x.size() (2L, 1L, 2L, 1L, 2L) y = torch.squeeze(x) y.size() (2L, 2L, 2L) y = torch.squeeze(x, 0) y.size() (2L, 1L, 2L, 1L, 2L) y = torch.squeeze(x, 1) y.size() (2L, 2L, 1L, 2L) ```pypy

torch.stack[source]

torch.stack(sequence, dim=0)
```pypy
沿着一个新维度对输入张量序列进行连接。 序列中所有的张量都应该为相同形状。
参数:
*   sqequence (Sequence) – 待连接的张量序列
*   dim (int) – 插入的维度。必须介于 0 与 待连接的张量序列数之间。
### torch.t

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

 输入一个矩阵（2 维张量），并转置 0, 1 维。 可以被视为函数`transpose(input, 0, 1)`的简写函数。
参数:
*   input (Tensor) – 输入张量
*   out (Tensor, 可选的) – 结果张量

 >>> x = torch.randn(2, 3)
>>> x
0.4834  0.6907  1.3417
-0.1300  0.5295  0.2321
[torch.FloatTensor of size 2x3]
```py 
```py
> > > torch.t(x)
0.4834 -0.1300 0.6907 0.5295 1.3417 0.2321 [torch.FloatTensor of size 3x2]

torch.transpose

torch.transpose(input, dim0, dim1, out=None) → Tensor

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

参数:

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

>>> x = torch.randn(2, 3)
>>> x
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]
>>> torch.transpose(x, 0, 1)
 0.5983  1.5981
-0.0341 -0.5265
 2.4918 -0.8735
[torch.FloatTensor of size 3x2]

torch.unbind

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

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

参数:

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

torch.unsqueeze

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

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

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

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

参数:

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

>>> x = torch.Tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
 1  2  3  4
[torch.FloatTensor of size 1x4]
>>> torch.unsqueeze(x, 1)
 1
 2
 3
 4
[torch.FloatTensor of size 4x1]

torch.manual_seed

torch.manual_seed(seed)

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

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

torch.initial_seed

torch.initial_seed()

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

torch.get_rng_state

torch.get_rng_state()[source]

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

torch.set_rng_state

torch.set_rng_state(new_state)[source]

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

torch.default_generator

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

torch.bernoulli

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

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

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

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

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

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

例子：

>>> a = torch.Tensor(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
>>> a
 0.7544  0.8140  0.9842
 0.5282  0.0595  0.6445
 0.1925  0.9553  0.9732
[torch.FloatTensor of size 3x3]
>>> torch.bernoulli(a)
 1  1  1
 0  0  1
 0  1  1
[torch.FloatTensor of size 3x3]
>>> a = torch.ones(3, 3) # probability of drawing "1" is 1
>>> torch.bernoulli(a)
 1  1  1
 1  1  1
 1  1  1
[torch.FloatTensor of size 3x3]
>>> a = torch.zeros(3, 3) # probability of drawing "1" is 0
>>> torch.bernoulli(a)
 0  0  0
 0  0  0
 0  0  0
[torch.FloatTensor of size 3x3]

torch.multinomial

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

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

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

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

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

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

参数:

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

例子：

>>> weights = torch.Tensor([0, 10, 3, 0]) # create a Tensor of weights
>>> torch.multinomial(weights, 4)
 1
 2
 0
 0
[torch.LongTensor of size 4]
>>> torch.multinomial(weights, 4, replacement=True)
 1
 2
 1
 2
[torch.LongTensor of size 4]

torch.normal()

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

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

参数:

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

torch.normal(means=torch.arange(1, 11), std=torch.arange(1, 0, -0.1))
 1.5104
 1.6955
 2.4895
 4.9185
 4.9895
 6.9155
 7.3683
 8.1836
 8.7164
 9.8916
[torch.FloatTensor of size 10]

torch.normal(mean=0.0, std, out=None)

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

参数:

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

例子:

>>> torch.normal(mean=0.5, std=torch.arange(1, 6))
  0.5723
  0.0871
 -0.3783
 -2.5689
 10.7893
[torch.FloatTensor of size 5]

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

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

参数:

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

例子:

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

torch.saves[source]

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]

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 )

例子:

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

torch.get_num_threads

torch.get_num_threads() → int

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

torch.set_num_threads

torch.set_num_threads(int)

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

Pointwise Ops

torch.abs

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

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

例子：

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

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

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

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

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

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]
>>> torch.acos(a)
 2.2608
 1.2956
 1.1075
    nan
[torch.FloatTensor of size 4]

torch.add()

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

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

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

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

>>> a = torch.randn(4)
>>> a
 0.4050
-1.2227
 1.8688
-0.4185
[torch.FloatTensor of size 4]
>>> torch.add(a, 20)
 20.4050
 18.7773
 21.8688
 19.5815
[torch.FloatTensor of size 4]

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

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

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

如果other是 FloatTensor or DoubleTensor 类型，则value 必须为实数，否则须为整数。

参数:

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

例子：

>>> import torch
>>> a = torch.randn(4)
>>> a
-0.9310
 2.0330
 0.0852
-0.2941
[torch.FloatTensor of size 4]
>>> b = torch.randn(2, 2)
>>> b
 1.0663  0.2544
-0.1513  0.0749
[torch.FloatTensor of size 2x2]
>>> torch.add(a, 10, b)
 9.7322
 4.5770
-1.4279
 0.4552
[torch.FloatTensor of size 4]

torch.addcdiv

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

对tensor2对tensor1逐元素相除，然后乘以标量值value 并加到tensor。

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

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

参数：

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

例子：

>>> t = torch.randn(2, 3)
>>> t1 = torch.randn(1, 6)
>>> t2 = torch.randn(6, 1)
>>> torch.addcdiv(t, 0.1, t1, t2)
 0.0122 -0.0188 -0.2354
 0.7396 -1.5721  1.2878
[torch.FloatTensor of size 2x3]

torch.addcmul

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

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

参数：

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

例子：

>>> t = torch.randn(2, 3)
>>> t1 = torch.randn(1, 6)
>>> t2 = torch.randn(6, 1)
>>> torch.addcmul(t, 0.1, t1, t2)
 0.0122 -0.0188 -0.2354
 0.7396 -1.5721  1.2878
[torch.FloatTensor of size 2x3]

torch.asin

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

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

参数：

• tensor (Tensor) – 输入张量
• out (Tensor, 可选的) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]
>>> torch.asin(a)
-0.6900
 0.2752
 0.4633
    nan
[torch.FloatTensor of size 4]

torch.atan

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

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

参数：

• tensor (Tensor) – 输入张量
• out (Tensor, 可选的) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]
>>> torch.atan(a)
-0.5669
 0.2653
 0.4203
 0.9196
[torch.FloatTensor of size 4]

torch.atan2

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

返回一个新张量，包含两个输入张量input1和input2的反正切函数

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]
>>> torch.atan2(a, torch.randn(4))
-2.4167
 2.9755
 0.9363
 1.6613
[torch.FloatTensor of size 4]

torch.ceil

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

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

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]
>>> torch.ceil(a)
 2
 1
-0
-0
[torch.FloatTensor of size 4]

torch.clamp

torch.clamp(input, min, max, out=None) → Tensor

将输入input张量每个元素的夹紧到区间 ([min, max] )，并返回结果到一个新张量。

操作定义如下：

 | min, if x_i < min
y_i = | x_i, if min <= x_i <= max
      | max, if x_i > max

如果输入是 FloatTensor or DoubleTensor 类型，则参数min max 必须为实数，否则须为整数。

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]
>>> torch.clamp(a, min=-0.5, max=0.5)
 0.5000
 0.3912
-0.5000
-0.5000
[torch.FloatTensor of size 4]

torch.clamp(input, *, min, out=None) → Tensor

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

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

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]
>>> torch.clamp(a, min=0.5)
 1.3869
 0.5000
 0.5000
 0.5000
[torch.FloatTensor of size 4]

torch.clamp(input, *, max, out=None) → Tensor

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

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

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]
>>> torch.clamp(a, max=0.5)
 0.5000
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

torch.cos

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

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

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]
>>> torch.cos(a)
 0.8041
 0.9633
 0.9018
 0.2557
[torch.FloatTensor of size 4]

torch.cosh

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

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

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]
>>> torch.cosh(a)
 1.2095
 1.0372
 1.1015
 1.9917
[torch.FloatTensor of size 4]

torch.div()

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

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

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

参数：

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

例子：

>>> a = torch.randn(5)
>>> a
-0.6147
-1.1237
-0.1604
-0.6853
 0.1063
[torch.FloatTensor of size 5]
>>> torch.div(a, 0.5)
-1.2294
-2.2474
-0.3208
-1.3706
 0.2126
[torch.FloatTensor of size 5]

torch.div(input, other, out=None)

两张量input和other逐元素相除，并将结果返回到输出。即， ( out_i= input_i / other_i )

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

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

参数：

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

例子：

>>> a = torch.randn(4,4)
>>> a
-0.1810  0.4017  0.2863 -0.1013
 0.6183  2.0696  0.9012 -1.5933
 0.5679  0.4743 -0.0117 -0.1266
-0.1213  0.9629  0.2682  1.5968
[torch.FloatTensor of size 4x4]
>>> b = torch.randn(8, 2)
>>> b
 0.8774  0.7650
 0.8866  1.4805
-0.6490  1.1172
 1.4259 -0.8146
 1.4633 -0.1228
 0.4643 -0.6029
 0.3492  1.5270
 1.6103 -0.6291
[torch.FloatTensor of size 8x2]
>>> torch.div(a, b)
-0.2062  0.5251  0.3229 -0.0684
-0.9528  1.8525  0.6320  1.9559
 0.3881 -3.8625 -0.0253  0.2099
-0.3473  0.6306  0.1666 -2.5381
[torch.FloatTensor of size 4x4]

torch.exp

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

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

参数：

• input (Tensor) – 输入张量

• out (Tensor, 可选的) – 输出张量

  >>> torch.exp(torch.Tensor([0, math.log(2)]))
  torch.FloatTensor([1, 2])

  torch.floor

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

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

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]
>>> torch.floor(a)
 1
 0
-1
-1
[torch.FloatTensor of size 4]

torch.fmod

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

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

参数：

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

例子：

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

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

torch.frac

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

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

例子：

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

torch.lerp

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

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

即，( out_i=start_i+weight∗(end_i−start_i) )

参数：

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

例子：

>>> start = torch.arange(1, 5)
>>> end = torch.Tensor(4).fill_(10)
>>> start
 1
 2
 3
 4
[torch.FloatTensor of size 4]
>>> end
 10
 10
 10
 10
[torch.FloatTensor of size 4]
>>> torch.lerp(start, end, 0.5)
 5.5000
 6.0000
 6.5000
 7.0000
[torch.FloatTensor of size 4]

torch.log

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

计算input 的自然对数

参数：

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

例子：

>>> a = torch.randn(5)
>>> a
-0.4183
 0.3722
-0.3091
 0.4149
 0.5857
[torch.FloatTensor of size 5]
>>> torch.log(a)
    nan
-0.9883
    nan
-0.8797
-0.5349
[torch.FloatTensor of size 5]

torch.log1p

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

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

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

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

参数：

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

例子：

>>> a = torch.randn(5)
>>> a
-0.4183
 0.3722
-0.3091
 0.4149
 0.5857
[torch.FloatTensor of size 5]
>>> torch.log1p(a)
-0.5418
 0.3164
-0.3697
 0.3471
 0.4611
[torch.FloatTensor of size 5]

torch.mul

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

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

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

参数：

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

例子：

>>> a = torch.randn(3)
>>> a
-0.9374
-0.5254
-0.6069
[torch.FloatTensor of size 3]
>>> torch.mul(a, 100)
-93.7411
-52.5374
-60.6908
[torch.FloatTensor of size 3]

torch.mul(input, other, out=None)

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

两计算张量形状不须匹配，但总元素数须一致。

参数：

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

例子：

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

torch.neg

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

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

参数：

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

例子：

>>> a = torch.randn(5)
>>> a
-0.4430
 1.1690
-0.8836
-0.4565
 0.2968
[torch.FloatTensor of size 5]
>>> torch.neg(a)
 0.4430
-1.1690
 0.8836
 0.4565
-0.2968
[torch.FloatTensor of size 5]

torch.pow

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, 可选的) – 输出张量

例子：

>>> a = torch.randn(4)
>>> a
-0.5274
-0.8232
-2.1128
 1.7558
[torch.FloatTensor of size 4]
>>> torch.pow(a, 2)
 0.2781
 0.6776
 4.4640
 3.0829
[torch.FloatTensor of size 4]
>>> exp = torch.arange(1, 5)
>>> a = torch.arange(1, 5)
>>> a
 1
 2
 3
 4
[torch.FloatTensor of size 4]
>>> exp
 1
 2
 3
 4
[torch.FloatTensor of size 4]
>>> torch.pow(a, exp)
   1
   4
  27
 256
[torch.FloatTensor of size 4]

torch.pow(base, input, out=None)

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

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

参数：

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

例子：

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

torch.reciprocal

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

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

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]
>>> torch.reciprocal(a)
 0.7210
 2.5565
-1.1583
-1.8289
[torch.FloatTensor of size 4]

torch.remainder

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

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

参数：

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

例子：

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

torch.round

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

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

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]
>>> torch.round(a)
 1
 1
-1
-0
[torch.FloatTensor of size 4]

torch.rsqrt

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

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

参数：

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

例子：

>>> a = torch.randn(4)
>>> a
 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]
>>> torch.rsqrt(a)
 0.9020
 0.8636
    nan
    nan
[torch.FloatTensor of size 4]