Pytorch常用函数手册

最新推荐文章于 2024-05-16 16:56:07 发布

AI耽误的大厨

最新推荐文章于 2024-05-16 16:56:07 发布

阅读量709

点赞数 12

文章标签： pytorch 人工智能 python

本文链接：https://blog.csdn.net/weixin_46556352/article/details/136531241

版权

第一章torch

包torch包含了多维张量的数据结构以及基于其上的多种数学操作。另外，它也提供了多种工具，

其中一些可以更有效地对张量和任意类型进行序列化。

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

张量 Tensors

torch.is_tensor

torch.is_tensor(obj)

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

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

torch.is_storage

torch.is_storage(obj)

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

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

torch.__set_default_tensor_type__

torch.set_default_tensor_type(t)

torch.numel

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)

torch.set_printoptions

torch.set_printoptions(precision=None, threshold=None,

edgeitems=None, linewidth=None, profile=None)

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

参数:

 precision – 浮点数输出的精度位数 (默认为8 )

 threshold – 阈值，触发汇总显示而不是完全显示(repr)的数组元素的总数（默认为1000）

 edgeitems – 汇总显示中，每维（轴）两端显示的项数（默认值为3）

 linewidth – 用于插入行间隔的每行字符数（默认为80）。Thresholded matricies will ignore

this parameter.

 profile – pretty 打印的完全默认值。可以覆盖上述所有选项 (默认为short, full)

创建操作 Creation Ops

torch.eye

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

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

参数:

 n (int ) – 行数

m (int, optional) – 列数.如果为None,则默认为n

 out (Tensor, optinal) - Output tensor

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

返回值类型: Tensor

例子:

>>> torch.eye(3)

1 0 0

0 1 0

0 0 1

[torch.FloatTensor of size 3x3]

from_numpy

torch.from_numpy(ndarray) → Tensor

Numpy 桥，将numpy.ndarray 转换为pytorch 的 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

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

返回一个1 维张量，包含在区间start 和 end 上均匀间隔的step 个点。输出1 维张量

的长度为

steps。

参数:

 start (float) – 序列的起始点

 end (float) – 序列的最终值

 steps (int) – 在start 和 end 间生成的样本数

 out (Tensor, optional) – 结果张量

例子:

>>> torch.linspace(3, 10, steps=5)

3.0000

4.7500

6.5000

8.2500

10.0000

[torch.FloatTensor of size 5]

>>> torch.linspace(-10, 10, steps=5)

-10

-5

[torch.FloatTensor of size 5]

>>> torch.linspace(start=-10, end=10, steps=5)

-10

-5

[torch.FloatTensor of size 5]

torch.logspace

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

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

1 维张

量的长度为steps。

参数:

 start (float) – 序列的起始点

 end (float) – 序列的最终值

 steps (int) – 在start 和 end 间生成的样本数

 out (Tensor, optional) – 结果张量

例子:

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

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

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

参数:

 sizes (int...) – 整数序列，定义了输出形状

 out (Tensor, optional) – 结果张量例子:

>>> torch.ones(2, 3)

1 1 1

[torch.FloatTensor of size 2x3]

>>> torch.ones(5)

[torch.FloatTensor of size 5]

torch.rand

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

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

sizes 定义。

参数:

 sizes (int...) – 整数序列，定义了输出形状

 out (Tensor, optinal) - 结果张量例子：

>>> torch.rand(4)

0.9193

0.3347

0.3232

0.7715

[torch.FloatTensor of size 4]

>>> torch.rand(2, 3)

0.5010 0.5140 0.0719

0.1435 0.5636 0.0538

[torch.FloatTensor of size 2x3]

torch.randn

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

返回一个张量，包含了从标准正态分布(均值为0，方差为 1，即高斯白噪声)中抽取一组随

机数，形

状由可变参数sizes 定义。参数:

 sizes (int...) – 整数序列，定义了输出形状

 out (Tensor, optinal) - 结果张量

例子：:

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

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

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

参数:

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

例子：

>>> torch.randperm(4)

[torch.LongTensor of size 4]

torch.arange

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

返回一个1 维张量，长度为 floor((end−start)/step)。包含从start 到end，以step 为步长

的一组

序列值(默认步长为1)。

参数:

 start (float) – 序列的起始点

 end (float) – 序列的终止点

 step (float) – 相邻点的间隔大小

 out (Tensor, optional) – 结果张量

例子：

>>> torch.arange(1, 4)

[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

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

返回一个1 维张量，有 floor((end−start)/step)+1 个元素。包含在半开区间[start, end）

从start

开始，以step 为步长的一组值。 step 是两个值之间的间隔，即 xi+1=xi+step

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

参数:

 start (float) – 序列的起始点

 end (float) – 序列的最终值

 step (int) – 相邻点的间隔大小

 out (Tensor, optional) – 结果张量

例子：

>>> torch.range(1, 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

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

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

参数:

 sizes (int...) – 整数序列，定义了输出形状

 out (Tensor, optional) – 结果张量

例子：

>>> torch.zeros(2, 3)

0 0 0

[torch.FloatTensor of size 2x3]

>>> torch.zeros(5)

[torch.FloatTensor of size 5]

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

torch.cat

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

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

torch.cat()可以看做 torch.split() 和 torch.chunk()的反操作。 cat() 函数

可以通过下

面例子更好的理解。

参数:

 inputs (sequence of Tensors) – 可以是任意相同Tensor 类型的python 序列

 dimension (int, optional) – 沿着此维连接张量序列。

例子：

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

torch.chunk

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

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

参数:

 tensor (Tensor) – 待分块的输入张量

 chunks (int) – 分块的个数

 dim (int) – 沿着此维度进行分块

torch.gather

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

例子：

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

参数:

 input (Tensor) – 源张量

 dim (int) – 索引的轴

 index (LongTensor) – 聚合元素的下标

 out (Tensor, optional) – 目标张量

torch.index_select

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

沿着指定维度对输入进行切片，取index 中指定的相应项(index 为一个LongTensor)，然后返

回到

一个新的张量，返回的张量与原始张量_Tensor_有相同的维度(在指定轴上)。

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

参数:

 input (Tensor) – 输入张量

 dim (int) – 索引的轴

 index (LongTensor) – 包含索引下标的一维张量

 out (Tensor, optional) – 目标张量

例子：

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

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

根据掩码张量mask 中的二元值，取输入张量中的指定项( mask 为一个 ByteTensor)，将取

值返回到

一个新的1D 张量，

张量 mask 须跟input 张量有相同数量的元素数目，但形状或维度不需要相同。注意：返

回的张量

不与原始张量共享内存空间。

参数:

 input (Tensor) – 输入张量

mask (ByteTensor) – 掩码张量，包含了二元索引值

 out (Tensor, optional) – 目标张量

例子：

>>> 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, optional) – 包含索引值的结果张量

例子：

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

[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°¡1°¡B°¡1°¡C°¡1°¡D)，那么输出形状就

为：

(A°¡B°¡C°¡D)

当给定dim 时，那么挤压操作只在给定维度上。例如，输入形状

为: (A°¡1°¡B), squeeze(input, 0) 将

会保持张量不变，只有用 squeeze(input, 1)，形状会变成 (A°¡B)。

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

参数:

 input (Tensor) – 输入张量

 dim (int, optional) – 如果给定，则input 只会在给定维度挤压

 out (Tensor, optional) – 输出张量

例子：

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

torch.stack[source]

torch.stack(sequence, dim=0)

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

参数:

 sqequence (Sequence) – 待连接的张量序列

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

torch.t

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

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

的简写

函数。

参数:

 input (Tensor) – 输入张量

 out (Tensor, optional) – 结果张量

>>> x = torch.randn(2, 3)

>>> x

0.4834 0.6907 1.3417

-0.1300 0.5295 0.2321

[torch.FloatTensor of size 2x3]

>>> torch.t(x)

0.4834 -0.1300

0.6907 0.5295

1.3417 0.2321

[torch.FloatTensor of size 3x2]

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, optional) – 结果张量

>>> x = torch.Tensor([1, 2, 3, 4])

>>> torch.unsqueeze(x, 0)

1 2 3 4

[torch.FloatTensor of size 1x4]

>>> torch.unsqueeze(x, 1)

[torch.FloatTensor of size 4x1]

随机抽样 Random sampling

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<=inputi<=1

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

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

 input (Tensor) – 输入为伯努利分布的概率值

 out (Tensor, optional) – 输出张量(可选)

例子：

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

[torch.FloatTensor of size 3x3]

>>> a = torch.zeros(3, 3) # probability of drawing "1" is 0

>>> torch.bernoulli(a)

0 0 0

[torch.FloatTensor of size 3x3]

torch.multinomial

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

LongTensor

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

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

能为0。

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

如果输入input 是一个向量，输出out 也是一个相同长度num_samples 的向量。如果输入input

是有 m 行的矩阵，输出out 是形如m°¡n 的矩阵。

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

取。

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

参数:

 input (Tensor) – 包含概率值的张量

 num_samples (int) – 抽取的样本数

 replacement (bool, optional) – 布尔值，决定是否能重复抽取

 out (Tensor, optional) – 结果张量

例子：

>>> weights = torch.Tensor([0, 10, 3, 0]) # create a Tensor of weights

>>> torch.multinomial(weights, 4)

[torch.LongTensor of size 4]

>>> torch.multinomial(weights, 4, replacement=True)

[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,optional) – 所有分布均值

 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, optional) – 所有分布的标准差

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

例子:

>>> torch.normal(means=torch.arange(1, 6))

1.1681

2.8884

3.7718

2.5616

4.2500

[torch.FloatTensor of size 5]

序列化 Serialization

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'})

并行化 Parallelism

torch.get_num_threads

torch.get_num_threads() → int

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

torch.set_num_threads

torch.set_num_threads(int)

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

数学操作Math operations

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

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

 input (Tensor) – 输入张量

 out (Tensor, optional) – 结果张量

例子：

>>> 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，

AI耽误的大厨

关注

12
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
Pytorch常用函数手册

第六章torch.nn.init .............................................................................................................. 144。第十四章torch.utils.model_zoo .......................................................................................... 168。
复制链接

扫一扫