Pytorch

发表于 | 更新于: | 分类于 | 热度: ℃
字数统计: 4,460 | 阅读时长 ≈ 21

Torch

torch包含了多维的数据结构以及基于其上的数学运算。它提供了多种实用工具，具有CUDA对应的实现

张量 Tensors

1
torch.is_tensor(obj)
1
2
3
4
5
6
a = torch.randn(3,4)
b = np.random.randn(3,4)
torch.is_tensor(a)
Out[1]: True
torch.is_tensor(b)
Out[2]: False

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

1
torch.is_storage(obj)
1
2
3
4
5
6
7
a = torch.randn(3,4)
x = torch.FloatTensor(a)
y = x.storage()
torch.is_storage(x)
Out[1]: False
torch.is_storage(y)
Out[2]: True

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

1
torch.numel(input)->int
1
2
3
a = torch.randn(3,4)
torch.numel(a)
Out[1]: 12

返回input 张量中的元素个数　　参数: input (Tensor) – 输入张量

创建操作 Creation Ops

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

参数:

  • n (int) – 行数
  • m (int, 可选) – 列数.如果为None,则默认为n
  • out (Tensor,可选) - 输出张量
1
2
3
4
5
6
7
8
9
10
11
12
13
torch.eye(3)
Out[1]: [torch.FloatTensor of size 3x3]
    
torch.eye(3, m=4)
torch.eye(3,4)
Out[2]:
1  0  0  0
0  1  0  0
0  0  1  0
[torch.FloatTensor of size 3x4]
torch.eye(3,3,out=torch.LongTensor())
Out[3]:[torch.LongTensor of size 3x4]

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

1
torch.from_numpy(ndarray) → Tensor
1
2
3
4
5
x = np.array([1,2,3])
torch.from_numpy(x)
Out[1]: [torch.LongTensor of size 3]
x
Out[13]: array([1, 2, 3])

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

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

参数:

  • start (float) – 点集的开始值
  • end (float) – 点集的最终值
  • steps (int) - 在start和end之间的采样数
  • out (Tensor, 可选的) – 结果张量
1
2
3
4
5
6
7
torch.linspace(1, 10, 4)
Out[1]: 
  1
  4
  7
 10
[torch.FloatTensor of size 4]

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

1
torch.ones(*sizes, out=None) → Tensor
1
2
3
4
5
a = torch.randn(3,4)
m = a.size()
torch.ones(*m)
Out[1]:
[torch.FloatTensor of size 3x4]

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

1
torch.randperm(n, out=None) → LongTensor
1
2
3
4
5
6
torch.randperm(3)
Out[25]: 
 1
 2
 0
[torch.LongTensor of size 3]

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

1
torch.arange(start, end, step=1, out=None) → Tensor
1
2
3
4
5
6
torch.arange(1, 10, step=4)
Out[27]: 
 1
 5
 9
[torch.FloatTensor of size 3]

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

1
torch.zeros(*sizes, out=None) → Tensor
1
2
3
4
5
a = torch.randn(3,4)
m = a.size()
torch.zeros(*m)
Out[1]:
[torch.FloatTensor of size 3x4]

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

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

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

参数:

  • seq（Tensors的序列） - 可以是相同类型的Tensor的任何python序列。
  • dim（int，可选） - 张量连接的尺寸
  • out（Tensor，可选） - 输出参数
1
2
3
4
5
6
7
8
a = torch.randn(3,4)
torch.cat((a, a, a),0)
Out[1]: 
[torch.FloatTensor of size 9x4]
torch.cat((a, a, a),1) & torch.cat((a, a, a),-1)
Out[2]: 
[torch.FloatTensor of size 3x12]

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

1
torch.chunk(tensor, chunks, dim=0)

参数:

  • tensor (Tensor) – 待分块的输入张量
  • chunks (int) – 分块的个数
  • dim(int) – 沿着此维度进行分块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
b = torch.randn(3,6)
torch.chunk(b, 3, 0)
Out[46]: 
(
 -1.2120  0.0617  0.2106 -0.3776 -2.2615  1.2279
 [torch.FloatTensor of size 1x6], 
  0.1425  1.3961 -0.6864  0.7581  0.5757 -0.7915
 [torch.FloatTensor of size 1x6], 
  0.5075 -1.8589 -0.5447 -0.6180  0.2896  0.1451
 [torch.FloatTensor of size 1x6])
torch.chunk(b, 3, 1)
Out[47]: 
(
 -1.2120  0.0617
  0.1425  1.3961
  0.5075 -1.8589
 [torch.FloatTensor of size 3x2], 
  0.2106 -0.3776
 -0.6864  0.7581
 -0.5447 -0.6180
 [torch.FloatTensor of size 3x2], 
 -2.2615  1.2279
  0.5757 -0.7915
  0.2896  0.1451
 [torch.FloatTensor of size 3x2])

将张量沿着给定维度分解成的多个块。

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

参数：

  • input(Tensor) - 源张量
  • dim(int) - 要索引的轴
  • index(LongTensor) - 要收集的元素的索引
  • out(Tensor，可选) - 目的张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
x = torch.FloatTensor([[1,2,3],[4,5,6],[7,8,9]])
Out[50]: 
 1  2  3
 4  5  6
 7  8  9
[torch.FloatTensor of size 3x3]
torch.gather(x, 0, torch.LongTensor([[0,0,0],[0,0,0],[0,0,0]]))
Out[58]: 
 1  2  3
 1  2  3
 1  2  3
[torch.FloatTensor of size 3x3]
torch.gather(x, 1, torch.LongTensor([[0,0,0],[0,0,0],[0,0,0]]))
Out[60]: 
 1  1  1
 4  4  4
 7  7  7
[torch.FloatTensor of size 3x3]
torch.gather(x, 0, torch.LongTensor([[0,0,0],[1,0,1],[0,0,0]]))
Out[59]: 
 1  2  3
 4  2  6
 1  2  3
[torch.FloatTensor of size 3x3]

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

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

参数:

  • input (Tensor) – 输入张量
  • dim (int) – 索引的轴
  • index (LongTensor) – 包含索引下标的一维张量
  • out (Tensor, 可选的) – 目标张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
a = torch.randn(3,4)
index = torch.LongTensor([0,1])
torch.index_select(a, 0, index)
Out[66]: 
 0.6552  1.2615 -1.8676 -1.3015
-0.6448 -0.0267  0.6535 -0.2193
[torch.FloatTensor of size 2x4]
torch.index_select(a, 1, index)
Out[67]: 
 0.6552  1.2615
-0.6448 -0.0267
-0.0179 -0.2577
[torch.FloatTensor of size 3x2]

返回一个新的张量，其索引input 张量沿尺寸 dim使用的条目中index这是一个LongTensor。

返回的Tensor具有与原始Tensor相同数量的尺寸。注意： 返回的张量不与原始张量共享内存空间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
a = torch.randn(3,4)
Out[1]: 
 0.6552  1.2615 -1.8676 -1.3015
-0.6448 -0.0267  0.6535 -0.2193
-0.0179 -0.2577  0.0076  0.2455
[torch.FloatTensor of size 3x4]
mask = a.ge(0.5)
a.ge(0.5)
Out[2]: 
 1  1  0  0
 0  0  1  0
 0  0  0  0
[torch.ByteTensor of size 3x4]
torch.masked_select(a, mask)
Out[3]: 
 0.6552
 1.2615
 0.6535
[torch.FloatTensor of size 3]

根据掩码张量mask中的二元值，取输入张量中的指定项( mask为一个 ByteTensor)，将取值返回到一个新的1D张量，张量 mask须跟input张量有相同数量的元素数目，但形状或维度不需要相同。注意： 返回的张量不与原始张量共享内存空间。

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

参数:

  • input (Tensor) – 源张量
  • out (LongTensor, 可选的) – 包含索引值的结果张量
1
2
3
4
5
6
7
b = torch.Tensor([1,0,1,1,0])
torch.nonzero(b)
Out[1]: 
 0
 2
 3
[torch.LongTensor of size 3x1]

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

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

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

参数:

  • tensor (Tensor) – 待分割张量
  • split_size (int) – 单个分块的形状大小
  • dim (int) – 沿着此维进行分割
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
a = torch.randn(3,4)
torch.split(a,1,0)
Out[1]: 
(
  0.6552  1.2615 -1.8676 -1.3015
 [torch.FloatTensor of size 1x4], 
 -0.6448 -0.0267  0.6535 -0.2193
 [torch.FloatTensor of size 1x4], 
 -0.0179 -0.2577  0.0076  0.2455
 [torch.FloatTensor of size 1x4])
torch.split(a,1,1)
Out[101]: 
(
  0.6552
 -0.6448
 -0.0179
 [torch.FloatTensor of size 3x1], 
  1.2615
 -0.0267
 -0.2577
 [torch.FloatTensor of size 3x1], 
 -1.8676
  0.6535
  0.0076
 [torch.FloatTensor of size 3x1], 
 -1.3015
 -0.2193
  0.2455
 [torch.FloatTensor of size 3x1])

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

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

参数:

  • input (Tensor) – 输入张量
  • dim (int, 可选的) – 如果给定，则input只会在给定维度挤压
  • out (Tensor, 可选的) – 输出张量
1
2
3
4
5
6
7
8
9
10
11
12
x = torch.zeros(2, 1, 2, 1, 2)
torch.squeeze(x)
Out[1]: 
[torch.FloatTensor of size 2x2x2]
torch.squeeze(x, 0)
Out[2]: 
[torch.FloatTensor of size 2x1x2x1x2]
torch.squeeze(x,1)
Out[3]:
[torch.FloatTensor of size 2x2x1x2]

将输入张量形状中的1 去除并返回。

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

参数:

  • tensor (Tensor) – 输入张量
  • dim (int) – 插入维度的索引
  • out (Tensor, 可选的) – 结果张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
x = torch.FloatTensor([1,2,3],[4,5,6])
torch.unsqueeze(x, 0)
Out[1]: 
(0 ,.,.) = 
  1  2  3
  4  5  6
[torch.FloatTensor of size 1x2x3]
torch.unsqueeze(x, 1)
Out[2]: 
(0 ,.,.) = 
  1  2  3
(1 ,.,.) = 
  4  5  6
[torch.FloatTensor of size 2x1x3]
torch.unsqueeze(x, 2)
Out[3]: 
(0 ,.,.) = 
  1
  2
  3
(1 ,.,.) = 
  4
  5
  6
[torch.FloatTensor of size 2x3x1]

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

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

1
torch.stack(sequence, dim=0)

参数:

  • sequence (Sequence) – 待连接的张量序列
  • dim (int) – 插入的维度。必须介于 0 与 待连接的张量序列数之间。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
x = torch.FloatTensor([1,2,3],[4,5,6])
torch.stack((x, x), 0)
Out[115]: 
(0 ,.,.) = 
  1  2  3
  4  5  6
(1 ,.,.) = 
  1  2  3
  4  5  6
[torch.FloatTensor of size 2x2x3]
torch.stack((x, x), 2)
Out[117]: 
(0 ,.,.) = 
  1  1
  2  2
  3  3
(1 ,.,.) = 
  4  4
  5  5
  6  6
[torch.FloatTensor of size 2x3x2]

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

1
torch.take(input, indices) → Tensor

参数:

  • input (Tensor) – 输入张量
  • indices(LongTensor) – 索引到张量
1
2
3
4
5
6
7
x = torch.FloatTensor([1,2,3],[4,5,6])
torch.take(x, torch.LongTensor([0,2,5]))
Out[1]: 
 1
 3
 6
[torch.FloatTensor of size 3]

用给定索引处的输入元素返回一个新的张量， 输入张量被看作是一维张量。 结果与指数具有相同形状。

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

参数:

  • input (Tensor) – 输入张量
  • dim0 (int) – 转置的第一维
  • dim1 (int) – 转置的第二维 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
a = torch.randn(3,4)
Out[1]: 
 0.6552  1.2615 -1.8676 -1.3015
-0.6448 -0.0267  0.6535 -0.2193
-0.0179 -0.2577  0.0076  0.2455
[torch.FloatTensor of size 3x4]
torch.transpose(a, 0, 1)
Out[2]: 
 0.6552 -0.6448 -0.0179
 1.2615 -0.0267 -0.2577
-1.8676  0.6535  0.0076
-1.3015 -0.2193  0.2455
[torch.FloatTensor of size 4x3]

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

1
torch.unbind(tensor, dim=0)

参数:

  • tensor (Tensor) – 输入张量
  • dim (int) – 删除的维度
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
a = torch.randn(3,4)
torch.unbind(a, 1)
Out[1]: 
(
  0.6552
 -0.6448
 -0.0179
 [torch.FloatTensor of size 3], 
  1.2615
 -0.0267
 -0.2577
 [torch.FloatTensor of size 3], 
 -1.8676
  0.6535
  0.0076
 [torch.FloatTensor of size 3], 
 -1.3015
 -0.2193
  0.2455
 [torch.FloatTensor of size 3])
torch.unbind(a, 0)
Out[2]: 
(
  0.6552
  1.2615
 -1.8676
 -1.3015
 [torch.FloatTensor of size 4], 
 -0.6448
 -0.0267
  0.6535
 -0.2193
 [torch.FloatTensor of size 4], 
 -0.0179
 -0.2577
  0.0076
  0.2455
 [torch.FloatTensor of size 4])

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

随机抽样 Random sampling

1
torch.manual_seed(seed)

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

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

1
torch.initial_seed()
1
2
3
4
5
torch.manual_seed(2)
Out[1]: <torch._C.Generator at 0x7fa4860b2370>
    
torch.initial_seed()
Out[2]: 2L

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

1
torch.get_rng_state()
1
2
3
4
5
6
7
8
9
10
torch.get_rng_state()
Out[1]: 
   2
   0
   0
 ⋮  
   0
   0
   0
[torch.ByteTensor of size 5048]

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

1
torch.set_rng_state(new_state)

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

1
torch.bernoulli(input, out=None) → Tensor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
b = torch.Tensor(3,4).uniform_(0,1)
b
Out[1]: 
 0.5596  0.5591  0.0915  0.2100
 0.0072  0.0390  0.9929  0.9131
 0.6186  0.9744  0.3189  0.2148
[torch.FloatTensor of size 3x4]
torch.bernoulli(b)
Out[2]: 
 1  0  0  0
 0  0  1  1
 1  1  0  0
[torch.FloatTensor of size 3x4]

从伯努利分布中抽取二元随机数(0 或者 1)。输入张量须包含用于抽取上述二元随机值的概率。 因此，输入中的所有值都必须在［0,1］区间，即 ( 0<=input_i<=1 )输出张量的第i个元素值， 将会以输入张量的第i个概率值等于1。返回值将会是与输入相同大小的张量，每个值为0或者1。

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

参数:

  • input (Tensor) – 包含概率值的张量
  • num_samples (int) – 抽取的样本数
  • replacement (bool, 可选的) – 布尔值，决定是否能重复抽取
  • out (Tensor, 可选的) – 结果张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
weights = torch.Tensor([0, 10, 3, 1])
torch.multinomial(weights, 4)
Out[1]: 
 1
 2
 3
 0
[torch.LongTensor of size 4]
torch.multinomial(weights, 4, replacement=True)
Out[2]: 
 1
 1
 1
 1
[torch.LongTensor of size 4]

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

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

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

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

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

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

参数:

  • means (Tensor) – 均值
  • std (Tensor) – 标准差
  • out (Tensor) – 可选的输出张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
torch.normal(means=torch.arange(0, 11), std=torch.arange(1, 0, -0.1))
Out[1]: 
  0.3889
 -0.1244
  1.4945
  3.0249
  3.4251
  4.1258
  6.5222
  7.0321
  7.9798
  8.9608
 10.0000
[torch.FloatTensor of size 11]
1
torch.normal(mean=0.0, std, out=None)
1
2
3
4
5
6
7
8
torch.normal(mean=0.5, std=torch.arange(1,6))
Out[1]: 
-0.4879
-0.2523
-0.3742
-1.0413
 2.2176
[torch.FloatTensor of size 5]
1
torch.normal(means, std=1.0, out=None)
1
2
3
4
5
6
7
8
torch.normal(means=torch.arange(1,6))
Out[171]: 
 1.9339
 1.5494
 1.9340
 3.5107
 3.8822
[torch.FloatTensor of size 5]

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

序列化 Serialization

1
torch.save(obj, f, pickle_module=<module 'pickle' from '/usr/bin/python2.7/pickle.py'>, pickle_protocol=2)

参数：

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

保存一个对象到一个硬盘文件上。参见 Recommended approach for saving a model

1
torch.load(f, map_location=None, pickle_module=<module 'pickle' from '/usr/bin/python2.7/pickle.py'>)

参数:

  • f – 类文件对象 (返回文件描述符)或一个保存文件名的字符串
  • map_location – 一个函数或字典规定如何remap存储位置
  • pickle_module – 用于unpickling元数据和对象的模块 (必须匹配序列化文件时的pickle_module )
1
2
3
4
5
>>> 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.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进行扩展，使用自己定义的标记和反序列化方法。

数学操作Math operations

1
torch.abs(input, out=None) → Tensor
1
2
3
4
5
6
torch.abs(torch.FloatTensor([-1, 2, -3]))
Out[8]: 
 1
 2
 3
[torch.FloatTensor of size 3]

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

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

参数:

  • input (Tensor) – 输入张量
  • value (Number) – 添加到输入每个元素的数
  • out (Tensor, 可选的) – 结果张量
1
2
3
4
5
6
7
8
9
10
11
12
13
a = torch.randn(3, 4)
Out[1]: 
-0.5815 -1.6031  1.9077  0.0478
 2.6821  1.0581  0.0966 -0.8499
-0.7623  1.3194  1.4320 -0.0202
[torch.FloatTensor of size 3x4]
torch.add(a, 10)
Out[2]: 
  9.4185   8.3969  11.9077  10.0478
 12.6821  11.0581  10.0966   9.1501
  9.2377  11.3194  11.4320   9.9798
[torch.FloatTensor of size 3x4]

对输入张量input逐元素加上标量值value，并返回结果到一个新的张量out，即 ( out = tensor + value )。如果输入input是FloatTensor or DoubleTensor类型，则value 必须为实数，否则须为整数。

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

参数：

  • tensor (Tensor) – 张量，对 tensor1 ./ tensor 进行相加
  • value (Number, 可选的) – 标量，对 tensor1 ./ tensor2 进行相乘
  • tensor1 (Tensor) – 张量，作为被除数(分子)
  • tensor2 (Tensor) –张量，作为除数(分母)
  • out (Tensor, 可选的) – 输出张量
1
2
3
4
a = torch.randn(3, 4)
a1 = torch.randn(2, 6)
a2 = torch.randn(6, 2)
torch.addcdiv(a, 0.1, a1, a2)

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

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

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

1
torch.ceil(input, out=None) → Tensor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
b = torch.randn(4)
Out[1]: 
-0.4149
 1.1449
-1.3121
 1.4417
[torch.FloatTensor of size 4]
torch.ceil(b)
Out[20]: 
-0
 2
-1
 2
[torch.FloatTensor of size 4]

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

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

操作定义如下：

1
2
3
      | 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, 可选的) – 输出张量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
b = torch.randn(4)
Out[1]: 
-0.4149
 1.1449
-1.3121
 1.4417
[torch.FloatTensor of size 4]
torch.clamp(b, -1, 1)
Out[22]: 
-0.4149
 1.0000
-1.0000
 1.0000
[torch.FloatTensor of size 4]

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

1
torch.floor(input, out=None) → Tensor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
b = torch.randn(4)
Out[1]: 
-0.4149
 1.1449
-1.3121
 1.4417
[torch.FloatTensor of size 4]
torch.floor(b)
Out[24]: 
-1
 1
-2
 1
[torch.FloatTensor of size 4]

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

-------------本文结束感谢您的阅读-------------
很有帮助，打赏感谢！
分享到： QQ好友 微信 新浪微博 有道云笔记 豆瓣 收藏夹 复制网址 一键分享 更多
0%