Torch

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

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

张量 Tensors

  1. torch.is_tensor(obj)

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

  • 参数: obj (Object) – 判断对象
  1. torch.is_storage(obj)

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

  • 参数: input (Object) – 判断对象
  1. torch.set_default_tensor_type(t)
  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
  1. 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

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

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

参数:

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

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

返回类型: Tensor

例子:

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

numpy.ndarray转换为Tensor。 返回的张量tensor和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])
  1. torch.linspace(start, end, steps=100, out=None) Tensor

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

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

例子:

  1. >>> torch.linspace(1.0,10.0,steps=5,out=None)
  2. 1.0000
  3. 3.2500
  4. 5.5000
  5. 7.7500
  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]
  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, 可选) – 结果张量

例子:

  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]
  1. torch.ones(*sizes, out=None) Tensor

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

参数:

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

例子:

  1. >>> torch.ones(2, 3)
  2. 1 1 1
  3. 1 1 1
  4. [torch.FloatTensor of size 2x3]
  5. >>> torch.ones(5)
  6. 1
  7. 1
  8. 1
  9. 1
  10. 1
  11. [torch.FloatTensor of size 5]
  1. torch.rand(*sizes, out=None) Tensor

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

参数:

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

例子:

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

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

参数:

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

例子::

  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]
  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]
  1. torch.arange(start, end, step=1, out=None) Tensor

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

参数:

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

例子:

  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]
  1. 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, 可选的) – 结果张量

例子:

  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]
  1. torch.zeros(*sizes, out=None) Tensor

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

参数:

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

例子:

  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]

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

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

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

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

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

参数:

  • seq(Tensors的序列) - 可以是相同类型的Tensor的任何python序列。
  • dim(int,可选) - 张量连接的尺寸
  • out(Tensor,可选) - 输出参数

    例子:

    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]

> > 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. ```python
  2. torch.chunk(tensor, chunks, dim=0)
  3. ```py
  4. 将张量沿着给定维度分解成的多个块。
  5. 参数:
  6. * tensor (Tensor) 待分块的输入张量
  7. * chunks (int) 分块的个数
  8. * dim (int) 沿着此维度进行分块

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

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

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

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

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]```py

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

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]

  1. * * *

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

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

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]

  1. ### torch.nonzero

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

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

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]

  1. ### torch.split

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

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

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

  1. 将输入张量形状中的`1` 去除并返回。 如果输入是形如\((A \times 1\times B \times 1 \times C \times 1 \times D) \),那么输出形状就为: \((A \times B \times C \times D) \)
  2. 当给定`dim`时,那么挤压操作只在给定维度上。例如,输入形状为: \((A \times 1 \times B) \), `squeeze(input, 0)` 将会保持张量不变,只有用 `squeeze(input, 1)`,形状会变成 \( (A \times B )\)
  3. 注意: 返回张量与输入张量共享内存,所以改变其中一个的内容会改变另一个。
  4. 参数:
  5. * input (Tensor) 输入张量
  6. * dim (int, 可选的) 如果给定,则`input`只会在给定维度挤压
  7. * out (Tensor, 可选的) 输出张量
  8. 例子:

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)```py

torch.stack[source]

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

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

  1. 输入一个矩阵(2维张量),并转置0, 1维。 可以被视为函数`transpose(input, 0, 1)`的简写函数。
  2. 参数:
  3. * input (Tensor) 输入张量
  4. * out (Tensor, 可选的) 结果张量
  1. >>> x = torch.randn(2, 3)
  2. >>> x
  3. 0.4834 0.6907 1.3417
  4. -0.1300 0.5295 0.2321
  5. [torch.FloatTensor of size 2x3]
  6. ```py

> > torch.t(x)

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

  1. ### torch.transpose
  2. ```pypython
  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, 可选的) – 结果张量
  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, 可选的) – 输出张量(可选)

例子:

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

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

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

参数:

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

例子:

  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,可选的) – 所有分布均值
  • 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, 可选的) – 所有分布的标准差
  • 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, 可选的) – 结果张量

例子:

  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 必须为实数,否则须为整数。

  • input (Tensor) – 输入张量
  • value (Number) – 添加到输入每个元素的数
  • out (Tensor, 可选的) – 结果张量
  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 必须为实数,否则须为整数。

参数:

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

例子:

  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, 可选的) – 标量,对 tensor1 ./ tensor2 进行相乘
  • tensor1 (Tensor) – 张量,作为被除数(分子)
  • tensor2 (Tensor) –张量,作为除数(分母)
  • out (Tensor, 可选的) – 输出张量

例子:

  1. >>> t = torch.randn(2, 3)
  2. >>> t1 = torch.randn(1, 6)
  3. >>> t2 = torch.randn(6, 1)
  4. >>> torch.addcdiv(t, 0.1, t1, t2)
  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, 可选的) – 标量,对 tensor1 . tensor2 进行相乘
  • tensor1 (Tensor) – 张量,作为乘子1
  • tensor2 (Tensor) –张量,作为乘子2
  • out (Tensor, 可选的) – 输出张量

例子:

  1. >>> t = torch.randn(2, 3)
  2. >>> t1 = torch.randn(1, 6)
  3. >>> t2 = torch.randn(6, 1)
  4. >>> torch.addcmul(t, 0.1, t1, t2)
  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, 可选的) – 输出张量

例子:

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

例子:

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

例子:

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

例子:

  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 必须为实数,否则须为整数。

参数:

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

例子:

  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类型,则参数 value 必须为实数,否则须为整数。

参数:

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

例子:

  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类型,则参数 value 必须为实数,否则须为整数。

参数:

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

例子:

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

例子:

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

例子:

  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 必须为实数,否则须为整数。

参数:

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

例子:

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

例子:

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

    1. &gt;&gt;&gt; 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, 可选的) – 输出张量

例子:

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

例子:

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

例子:

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

例子:

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

例子:

  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 必须为实数,否则须为整数。

参数:

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

例子:

  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 (Tensor) – 第一个相乘张量
  • other (Tensor) – 第二个相乘张量
  • out (Tensor, 可选的) – 结果张量

例子:

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

例子:

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

例子:

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

例子:

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

例子:

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

例子:

  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.round

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

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

参数:

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

例子:

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

例子:

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

例子:

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

例子:

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

例子:

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

例子:

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

例子:

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

例子:

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

例子:

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

例子:

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

例子:

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

例子:

  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, 可选的) – 所计算的范数
  • out (Tensor, 可选的) – 结果张量

例子:

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

例子:

  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, 可选的) – 结果张量
  • indices (Tensor, 可选的) – 返回的索引结果张量
  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, 可选的) – 结果张量
  • indices (Tensor, 可选的) – 返回的索引张量

例子:

  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,可选的) – 范数计算中的幂指数值

例子:

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

例子:

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

例子:

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

例子:

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

例子:

  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, 可选的) – 结果张量 例子:

    1. &gt;&gt;&gt; a = torch.randn(4, 4)
    2. &gt;&gt;&gt; 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
  5. ```py
  6. 比较元素相等性。第二个参数可为一个数或与第一个参数同类型形状的张量。
  7. 参数:
  8. * input (Tensor) 待比较张量
  9. * other (Tensor or float) 比较张量或数
  10. * out (Tensor, 可选的) 输出张量,须为 ByteTensor类型 or 与`input`同类型
  11. 返回值: 一个 `torch.ByteTensor` 张量,包含了每个位置的比较结果(相等为1,不等为0 )
  12. 返回类型: Tensor
  13. 例子:

torch.eq(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))1 00 1[torch.ByteTensor of size 2x2]```py

torch.equal

  1. torch.equal(tensor1, tensor2) bool
  2. ```py
  3. 如果两个张量有相同的形状和元素值,则返回`True` ,否则 `False`。
  4. 例子:

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

torch.ge

  1. torch.ge(input, other, out=None) Tensor
  2. ```py
  3. 逐元素比较`input`和`other`,即是否 \( input &gt;= other \)。
  4. 如果两个张量有相同的形状和元素值,则返回`True` ,否则 `False`。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量
  5. 参数:
  6. * input (Tensor) – 待对比的张量
  7. * other (Tensor or float) – 对比的张量或`float`值
  8. * out (Tensor, 可选的) – 输出张量。必须为`ByteTensor`或者与第一个参数`tensor`相同类型。
  9. 返回值: 一个 `torch.ByteTensor` 张量,包含了每个位置的比较结果(是否 input &gt;= other )。 返回类型: Tensor
  10. 例子:

torch.ge(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]])) 1 1 0 1[torch.ByteTensor of size 2x2]```py

torch.gt

  1. torch.gt(input, other, out=None) Tensor
  2. ```py
  3. 逐元素比较`input`和`other` , 即是否\( input &gt; other \) 如果两个张量有相同的形状和元素值,则返回`True` ,否则 `False`。 第二个参数可以为一个数或与第一个参数相同形状和类型的张量
  4. 参数:
  5. * input (Tensor) – 要对比的张量
  6. * other (Tensor or float) – 要对比的张量或`float`值
  7. * out (Tensor, 可选的) – 输出张量。必须为`ByteTensor`或者与第一个参数`tensor`相同类型。
  8. 返回值: 一个 `torch.ByteTensor` 张量,包含了每个位置的比较结果(是否 input &gt;= other )。 返回类型: Tensor
  9. 例子:

torch.gt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]])) 0 1 0 0[torch.ByteTensor of size 2x2]```py

torch.kthvalue

  1. torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor)
  2. ```py
  3. 取输入张量`input`指定维上第k 个最小值。如果不指定`dim`,则默认为`input`的最后一维。
  4. 返回一个元组 _(values,indices)_,其中`indices`是原始输入张量`input`中沿`dim`维的第 `k` 个最小值下标。
  5. 参数:
  6. * input (Tensor) – 要对比的张量
  7. * k (int) – 第 `k` 个最小值
  8. * dim (int, 可选的) – 沿着此维进行排序
  9. * out (tuple, 可选的) – 输出元组 (Tensor, LongTensor) 可选地给定作为 输出 buffers
  10. 例子:

x = torch.arange(1, 6)x

1 2 3 4 5[torch.FloatTensor of size 5]

torch.kthvalue(x, 4)( 4[torch.FloatTensor of size 1], 3[torch.LongTensor of size 1])```py

torch.le

  1. torch.le(input, other, out=None) Tensor
  2. ```py
  3. 逐元素比较`input`和`other` , 即是否\( input &lt;= other \) 第二个参数可以为一个数或与第一个参数相同形状和类型的张量
  4. 参数:
  5. * input (Tensor) – 要对比的张量
  6. * other (Tensor or float ) – 对比的张量或`float`值
  7. * out (Tensor, 可选的) – 输出张量。必须为`ByteTensor`或者与第一个参数`tensor`相同类型。
  8. 返回值: 一个 `torch.ByteTensor` 张量,包含了每个位置的比较结果(是否 input &gt;= other )。 返回类型: Tensor
  9. 例子:

torch.le(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]])) 1 0 1 1[torch.ByteTensor of size 2x2]```py

torch.lt

  1. torch.lt(input, other, out=None) Tensor
  2. ```py
  3. 逐元素比较`input`和`other` , 即是否 \( input &lt; other \)
  4. 第二个参数可以为一个数或与第一个参数相同形状和类型的张量
  5. 参数:
  6. * input (Tensor) – 要对比的张量
  7. * other (Tensor or float ) – 对比的张量或`float`值
  8. * out (Tensor, 可选的) – 输出张量。必须为`ByteTensor`或者与第一个参数`tensor`相同类型。
  9. input: 一个 `torch.ByteTensor` 张量,包含了每个位置的比较结果(是否 tensor &gt;= other )。 返回类型: Tensor
  10. 例子:

torch.lt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]])) 0 0 1 0[torch.ByteTensor of size 2x2]```py

torch.max

  1. torch.max()
  2. ```py
  3. 返回输入张量所有元素的最大值。
  4. 参数:
  5. * input (Tensor) – 输入张量
  6. 例子:

a = torch.randn(1, 3)a

0.4729 -0.2266 -0.2085[torch.FloatTensor of size 1x3]

torch.max(a)0.4729```py

  1. torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)
  2. ```py
  3. 返回输入张量给定维度上每行的最大值,并同时返回每个最大值的位置索引。
  4. 输出形状中,将`dim`维设定为1,其它与输入形状保持一致。
  5. 参数:
  6. * input (Tensor) – 输入张量
  7. * dim (int) – 指定的维度
  8. * max (Tensor, 可选的) – 结果张量,包含给定维度上的最大值
  9. * max_indices (LongTensor, 可选的) – 结果张量,包含给定维度上每个最大值的位置索引
  10. 例子:

a = torch.randn(4, 4)a

0.0692 0.3142 1.2513 -0.54280.9288 0.8552 -0.2073 0.64091.0695 -0.0101 -2.4507 -1.22300.7426 -0.7666 0.4862 -0.6628torch.FloatTensor of size 4x4]

torch.max(a, 1)( 1.2513 0.9288 1.0695 0.7426[torch.FloatTensor of size 4x1], 2 0 0 0[torch.LongTensor of size 4x1])```py

  1. torch.max(input, other, out=None) Tensor
  2. ```py
  3. 返回输入张量给定维度上每行的最大值,并同时返回每个最大值的位置索引。 即,\( out_i=max(input_i,other_i) \)
  4. 输出形状中,将`dim`维设定为1,其它与输入形状保持一致。
  5. 参数:
  6. * input (Tensor) – 输入张量
  7. * other (Tensor) – 输出张量
  8. * out (Tensor, 可选的) – 结果张量
  9. 例子:

a = torch.randn(4)a

1.3869 0.3912-0.8634-0.5468[torch.FloatTensor of size 4]

b = torch.randn(4)b

1.0067-0.8010 0.6258 0.3627[torch.FloatTensor of size 4]

torch.max(a, b)

1.3869 0.3912 0.6258 0.3627[torch.FloatTensor of size 4]

  1. ### torch.min

torch.min(input) → float

  1. 返回输入张量所有元素的最小值。
  2. 参数: input (Tensor) 输入张量
  3. 例子:

a = torch.randn(1, 3)a

0.4729 -0.2266 -0.2085[torch.FloatTensor of size 1x3]

torch.min(a)-0.22663167119026184```py

  1. torch.min(input, dim, min=None, min_indices=None) -> (Tensor, LongTensor)
  2. ```py
  3. 返回输入张量给定维度上每行的最小值,并同时返回每个最小值的位置索引。
  4. 输出形状中,将`dim`维设定为1,其它与输入形状保持一致。
  5. 参数:
  6. * input (Tensor) – 输入张量
  7. * dim (int) – 指定的维度
  8. * min (Tensor, 可选的) – 结果张量,包含给定维度上的最小值
  9. * min_indices (LongTensor, 可选的) – 结果张量,包含给定维度上每个最小值的位置索引
  10. 例子:

a = torch.randn(4, 4)a

0.0692 0.3142 1.2513 -0.54280.9288 0.8552 -0.2073 0.64091.0695 -0.0101 -2.4507 -1.22300.7426 -0.7666 0.4862 -0.6628torch.FloatTensor of size 4x4]

torch.min(a, 1)

0.54

译者署名

用户名 头像 职能 签名
Song Torch - 图1 翻译 人生总要追求点什么

```