Torch包函数（施工中止）

最新推荐文章于 2024-02-07 13:50:25 发布

JachinMa

最新推荐文章于 2024-02-07 13:50:25 发布

阅读量991

点赞数

torch包包含了用于多维张量的数据结构，并定义了在它之上的数学运算。除此之外，它提供了许多用于高效序列化Tensor和其它类型的实用程序(utility)，以及其它有用的程序。

它有一个CUDA解释器，让你能够在计算性能不小于3.0的英伟达GPU上运行张量。

Tensors

torch.is_tensor(obj): → bool

若参数为张量，返回True
torch.is_storage(obj): → bool

若参数是storage，返回True。
(注：storage是一个单一数据类型的连续一维数组)
torch.is_floating_point(tensor): → bool

若张量为f浮点类型——无论是哪一种，返回True。
torch.set_default_dtype(d): → torch.dtype

将浮点的默认类型改为d，之后设定的f浮点型张量的类型都为d。

浮点类型初始化为torch.float32。

Example：
torch.get_default_dtype(): → torch.dtype

得到当前float的默认类型。
torch.set_default_tensor_type(t): → void

将默认的torch.Tensor类型设定为浮点张量类型t。这一类型也会被用为torch.tensor()的类型推断的默认浮点类型。

默认浮点类型被初始化为torch.FloatTensor。
(注：尝试了下，这个函数和torch.set_default_dtype(d)的区别在于：前者只能用HalfTensor,FloatTensor和DoubleTensor作参数，而后者只能用float16(或half),float32(float)和float64(double)作参数。)
torch.numel(input): → int

返回输入张量的元素数。

Example:
torch.set_printoptions(precision=None,threshold=None,edgeitems=None,linewidth=None,profile=None,sci_mode=None): → void

设置打印选项。这些元素是无耻地从Numpy那抄过来的。

参数：

precision: 浮点输出的精度(默认为4)。
threshold: 当输出元素大于此参数时，进行缩略输出(默认为1000)。
edgeitems: 每一维度开头和结尾总共显示的元素数目(默认为三)。
(注：)
linewidth: 每行的字符数，用于插入换行符(默认为80)。
(注：
)
profile: 几个默认的好看的搭配，可以覆盖以上几个选项。
(注，profile可选参数如下：
)
sci_mode: 是否允许科学符号输出。若为None(默认值)，则值由_Formatter定义。
(注：
)
torch.set_flush_denormal(bool): → bool

禁用cpu上的非正规浮点数。

如果你的系统支持非正规流动数(flushing denormal numbers)且它成功的配置了非正规流动模型。set_flush_denormal()仅支持支持SSE3的x86架构计算机。

Example:

Creation Ops

Note：
随机抽样创建操作被列在随机抽样下，包含了torch.rand(),torch.rand_like(),torch.randn(),torch.randn_like(),torch.randint(),torch.randint_like()和torch.randperm()。你也可以使用由原地随机采样方法的torch.empty()来创建拥有从更广泛的范围里采样的值的张量。

torch.tensor(data,dtype=None,device=None,requires_grad=False,pin_memory=False): → tensor

用数据来构建一个张量。

Warning:
torch.tensor()总是复制data。如果你有一个张量data，并且想要避免复制，可以使用torch.Tensor.requires_grad_()或torch.Tensor.detach()。如果你有一个NumPy的ndarray并且想要避免复制，使用torch.as_tensor()。

Warning:
当data是张量x时，torch.tensor()从传递的数据中读出data，并构造一个叶子变量。因此torch.tensor(x)和x.clone().detach()等价，而torch.tensor(x,requires_grad=True)和x.clone().detach.requires_grad_(True)相同。建议使用clone()和detach()的等价。

参数：

data(array_like): 张量的初始化数据。可以是列表、元组、NumPy的ndarray、标量或其它类型 (注：比如storage) 。
dtype(torch.dtype,可选): 规定返回张量的数据类型。默认值为None，此时继承data的数据类型。
device(torch.device,可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool,可选): 若自动求导应该记录返回张量的操作，则设为True。默认为False。
pin_memory(bool,可选): 如果设定为真，则返回张量会被分配为固定(pinned)内存中。支队CPU张量有效。默认为False。

Exemples:

(注：cuda后跟的序号试了几个除了0的数字，都报错了，所以不明白这个数字是什么意思。猜测一下，也许是如果串联多个设备或GPU的时候，每个设备都有自己的编号，而0就表示本机。)
torch.sparse_coo_tensor(indicies,values,size=None,dtype=None,device=None,requires_grad=False): → tensor

以COO格式(注：即以三元组(行、列、值)的形式表示稀疏矩阵)，在给定位置处使用给定值的非零元素构造的稀疏张量。稀疏张量可以是未分解的，在这种情况下，索引中会有重复的坐标，在这些地方，其值未所有重复值的总和(注：可见 https://blog.csdn.net/JachinMa/article/details/90730641)。

参数：

indices(array_like): 为张量初始化数据。可以是列表、元组、NumPy的ndarray、标量或其它数据类型。将被内部投入torch.LongTensor。indices是矩阵中非零元素的坐标，因此应该是二维的。其第一维度是张量的维度数，第二维度是非零值的数目。
values(array_like): 为张量初始化值。可以是列表、元组、NumPy的ndarray、标量或其它数据类型。
size(list,tuple,或torch.Size，可选): 稀疏张量的大小。若未给出，则为能够满足给定条件的最小大小。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认值为None，此时类型与values保持一致。
device(torch.dtype，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回的张量上的操作，则应设为True。默认为False。

Example：
torch.as_tensor(data,dtype=None,device=None): → Tensor

将数据转换为张量。若数据已经是具有相同dtype和设备的张量，则不会执行任何复制。否则，若数据张量的requires_grad值为True，则返回一个新的张量并保留其计算图。相似的，如果数据是一个对应的(corresponding)ndarray，且设备为CPU，则不执行任何复制。

参数：

data(array_like): 张量的初始数据。可以是列表、元组、NumPy的ndarray、标量或其它数据类型。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时和data的类型保持一致。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。

Example:

(注：将虽然也有其它函数能够将其他类型的数据转换为张量，但as_tensor()是我目前看到的最好的转换函数了。因为1：它可转换的类型多，比如from_numpy()就只能转换numpy矩阵；2：它还可以转换张量，顺便在转换的时候改变其dtype和设备。不过这样做的坏处在于如果两个张量在同一个设备上，那么就会共享内存，有时候我们可能不希望这样做。)

6.1

torch.from_numpy(ndarray): → Tensor

通过numpy.ndarray创建张量。

返回的张量和ndarray共享内存。对张量的修改也会反映到ndarray上，反过来也一样。返回的张量不能调整大小。

Example:
torch.zeros(*sizes,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False,pin_memory=False): → Tensor
(注：strided是指密集张量，没找到相应的解释和操作，可能类似密集矩阵吧)
返回一个形状被可变参数sizes确定的，值均为标量0的张量。

参数

sizes(int…): 一系列定义输出张量形状的整型变量。可以是数量可变的参数，或者是列表或元组的集合。
out(Tensor，可选): 输出张量(注：该张量必须和sizes的大小相同，只能有一个，且与结果张量共享内存)。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())
layout(torch.layout，可选): 规定返回张量的布局。默认为torch.strided。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example：

6.2

torch.zeros_like(input.dtype=None,layout=None,device=None,requires_grad=False,pin_memory=False): → Tensor

返回一个大小与input相同，而值均为标量0的张量。torch.zeros_like(input)和torch.zeros(input.size(),dtype=input.dtype,layout=input.layout,device=input.device)等价。

在0.4版本中，这个函数并不支持out关键字。作为替代，旧的torch.zeros_like(input,out=output)和torch.zeros(input.size(),out=output)

参数

input(Tensor): input的大小会决定输出张量的大小。
dtype(torch.dtype，可选): 规定了返回张量的数据类型。默认为None，此时和input的数据类型相同。
layout(torch.layout，可选): 规定了返回张量的布局。默认为None，此时和input的布局相同。
device(torch.device，可选): 规定了返回张量的设备。默认为None，此时与input的设备相同。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example：
torch.ones(*sizes,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False,pin_memory=False): → Tensor

返回一个形状被可变参数sizes确定的，值均为标量1的张量。

参数

sizes(int…): 一系列定义输出张量形状的整型变量。可以是数量可变的参数，或者是列表或元组的集合。
out(Tensor，可选): 输出张量(注：该张量必须和sizes的大小相同，只能有一个，且与结果张量共享内存)。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())
layout(torch.layout，可选): 规定返回张量的布局。默认为torch.strided。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example:
torch.ones_like(input.dtype=None,layout=None,device=None,requires_grad=False,pin_memory=False): → Tensor

返回一个大小与input相同，而值均为标量0的张量。torch.ones_like(input)和torch.ones(input.size(),dtype=input.dtype,layout=input.layout,device=input.device)等价。

在0.4版本中，这个函数并不支持out关键字。作为替代，旧的torch.ones_like(input,out=output)和torch.ones(input.size(),out=output)

参数

input(Tensor): input的大小会决定输出张量的大小。
dtype(torch.dtype，可选): 规定了返回张量的数据类型。默认为None，此时和input的数据类型相同。
layout(torch.layout，可选): 规定了返回张量的布局。默认为None，此时和input的布局相同。
device(torch.device，可选): 规定了返回张量的设备。默认为None，此时与input的设备相同。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example:
torch.arange(start=0,end,step=1,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False,pin_memory=False): → Tensor

返回一个大小为

的一维张量，值从间隔为step的[start, end)区间取，从start开始。

注意，当非整型变量step与end做对比时，会受制于浮点舍入误差的影响。为了避免出错，我们建议在这种情况下为end加一个小的epsilon。

参数

start(Number): 序列的起始值，默认为0。
end(Number): 序列的结束值。
step(Number): 每个相邻点的间隔，默认为1.
out(Tensor，可选): 输出张量。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())。若dtype未给，从其它输入参数中推出。若start、end或stop中的任意一个是浮点，则dtype被推断为默认数据类型，见see_default_dtype()。否则，dtype被推断为torch.int64。
layout(torch.layout，可选): 规定返回张量的布局，默认为torch.strided。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example:
torch.range(start=0,end,step=1,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False): → Tensor

返回一个值从start开始，到end结束，间隔为step的一维张量，其d大小为：

step是张量的相邻两个值的间隔。

Warning：
更推荐使用torch.arrange()。

参数

start(Number): 序列的起始值，默认为0。
end(Number): 序列的结束值。
step(Number): 每个相邻点的间隔，默认为1.
out(Tensor，可选): 输出张量。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())。若dtype未给，从其它输入参数中推出。若start、end或stop中的任意一个是浮点，则dtype被推断为默认数据类型，见see_default_dtype()。否则，dtype被推断为torch.int64。
layout(torch.layout，可选): 规定返回张量的布局，默认为torch.strided。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。

Example:
torch.linspace(start,end,steps=100,out=None,dtype,layout=torch.strided,device=None,requires_grad=False,pin_memory=False): → Tensor

返回一个含steps个数据的，以start开始，end结束的一维张量。

输出是大小为steps的一维张量。

参数

start(Number): 序列的起始值，默认为0。
end(Number): 序列的结束值。
step(int): 从start和end间取样的点数，默认为100。
out(Tensor，可选): 输出张量。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())。若dtype未给，从其它输入参数中推出。若start、end或stop中的任意一个是浮点，则dtype被推断为默认数据类型，见see_default_dtype()。否则，dtype被推断为torch.int64。
layout(torch.layout，可选): 规定返回张量的布局，默认为torch.strided。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example:
torch.logspace(start,end,steps=100,base=10.0,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False,pin_memory=False): → Tesnsor

返回一个一维张量，由steps个从

到

且中间每个数都是以base为底，以start到end(包括end)间被steps等分的数为指数。

输出是一个大小为steps的一维张量

参数

start(Number): 序列的起始值，默认为0。
end(Number): 序列的结束值。
step(int): 从start和end间取样的点数，默认为100。
base(float): 对数函数的基数。
out(Tensor，可选): 输出张量。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())。
layout(torch.layout，可选): 规定返回张量的布局，默认为torch.strided。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example:
torch.eye(n,m=None,out=None,dtype=None,layout=None,layout=torch.strided,device=None,requires_grad=False,pin_memory=False): → Tensor

返回一个对角为1，其余地方为0的二维张量。

参数

n(int): 行数
m(int，可选): 列数，默认为n。
out(Tensor，可选): 输出张量。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，使用全局默认值(见torch.set_default_tensor_type())。
layout(torch.layout，可选): 规定返回的张量布局。默认为torch.strided。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example:
torch.empty(*sizes,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False,pin_memory=False) : → Tensor
返回一个形状被可变参数sizes确定的，值均未初始化的张量。

参数

sizes(int…): 一系列定义输出张量形状的整型变量。可以是数量可变的参数，或者是列表或元组的集合。
out(Tensor，可选): 输出张量(注：该张量必须和sizes的大小相同，只能有一个，且与结果张量共享内存)。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())
layout(torch.layout，可选): 规定返回张量的布局。默认为torch.strided。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example:
torch.empty_like(input.dtype=None,layout=None,device=None,requires_grad=False,pin_memory=False): → Tensor

返回一个大小与input相同，而未初始化的张量。torch.empty_like(input)和torch.empty(input.size(),dtype=input.dtype,layout=input.layout,device=input.device)等价。

参数

input(Tensor): input的大小会决定输出张量的大小。
dtype(torch.dtype，可选): 规定了返回张量的数据类型。默认为None，此时和input的数据类型相同。
layout(torch.layout，可选): 规定了返回张量的布局。默认为None，此时和input的布局相同。
device(torch.device，可选): 规定了返回张量的设备。默认为None，此时与input的设备相同。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example:
torch.full(size,fill_value,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False,pin_memory=False): → Tensor

返回一个值均为fill_value，大小为size的张量

参数

size(int…): 列表、元组或整型变量的torch.Size定义了输出张量的形状。
fill_value(Number): 充填张量的值。
out(Tensor，可选): 输出张量。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())
layout(torch.layout，可选): 规定返回张量的布局。默认为torch.strided。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example:
torch.full_like(input,fill_value,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False,pin_memory=False): → Tensor

返回一个值均为fill_value，大小为size的张量

参数

size(int…): 列表、元组或整型变量的torch.Size定义了输出张量的形状。
fill_value(Number): 充填张量的值。
out(Tensor，可选): 输出张量。
dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())
layout(torch.layout，可选): 规定返回张量的布局。默认为torch.strided。
device(torch.device，可选): 规定返回张量的设备。默认值为None，则为默认的张量类型 (见torch.set_default_tensor_type()) 的当前设备。若张量类型是CPU，则device为CPU，若张量类型为CUDA，则device为当前的CUDA设备。
requires_grad(bool，可选): 若自动求导要记录在返回张量上的操作，则应设为True。默认为False。
pin_memory(bool，可选): 若设为True，则返回的张量将被分配到固定内存上。只对CPU有效，默认为False。

Example:

Indexing,Slicing,Joining,Mutating ops

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

在给定维度中连接给定的张量序列。所有张量必须具有相同的形状(除了在连接维度)，或为空。

torch.cat()可被视作torch.split()和torch.chunk()的反操作。

torch.cat()最好通过例子理解。

参数

tensors(sequence of Tensors): 任何形状相同的系列张量。除了在cat维，提供的非空张量必须有相同的形状。

dim(int，可选): 张量的连接维度。

out(Tensor，可选): 输出张量。

Example:
torch.chunk(tensor,chunks,dim=0): → List of Tensors

将张量分为chunks个。

若沿给定维度dim方向的张量大小不能被快整除，则最后一个块将更小。

参数

tensor(Tensor): 被分裂的张量。
chunks(int): 返回的张量数。
dim(int): 分裂张量的维度方向,默认为0。

Example:
torch.gather(input,dim,index,out=None,sparse_grad=False): → Tensor

沿dim方向聚集数值。

对三维张量来说，输出为：

若input是大小为
的n维张量，且dim为i，那么index必须是个大小为

的n维张量，y≥1，且out和index的大小一致。

(注：简单来说，就是input中的每个数据，其dim维的值由input中索引指向的位置的值代替，而索引的坐标与该数据一致。)

参数

input(Tensor): 输入张量。

dim(int): 被更新的维度。

index(LongTensor): 指定更新的方式。

out(Tensor，可选): 结果张量。

sparse_grad(bool，可选): 若为True，input的梯度会是个稀疏张量。

Example:

6.3

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

返回一个新张量，其为input在dim维上的长张量index指向的对应数据(注：可以按照SQL的select语句来理解，index即是相应的行/列号集合)。

返回的张量和原始张量(input)由同样的维度数。在第dim维上长度和index相同；在其它维度上长度和原始张量相同。

Note：
返回的张量不和原始张量使用同一个存储。若out有和预期不同的形状，我们会悄悄地把它改成正确的形状，有必要的话，还会重新分配其底层存储。

参数

input(Tensor): 输入张量。

dim(int): 我们进行索引的维度。

index(Long Tensor): 包含索引的索引的一维张量。

out(Tensor，可选): 输出张量。

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

返回一个新的一维张量，它根据二进制掩码(mask)mask来对输入张量进行索引，该掩码是ByteTensor。

mask张量和input张量的形状不必匹配，但必须broadcastable(注：broadcastable，见https://blog.csdn.net/JachinMa/article/details/90764336)。

Note：
返回的张量不和原始张量使用同一个存储。

参数

input(Tensor): 输入数据。

mask(ByteTensor): 用于索引的包含二维掩码的张量。

out(Tensor，可选): 输出张量。

Example:
torch.narrow(input,dimension,start,length): → Tensor

返回一个input张量的缩减版本张量。在dim维输出start到start+length的数据。返回的张量和imput张量共享存储(注：它和torch.index_select()的区别类似SQL里view和select的区别)。

参数

input(Tensor): 被缩减的张量。

dimension(int): 缩减的维度。

start(int): 开始缩减的维度。

length(int): 开始维度与结束维度的距离。

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

返回一个input中所有非零元素的索引张量。每一行代表了一个input中的非零元素。结果被按字典顺序排列，最后一个索引变换最快(C-style)。

若input有n维，那么作为结果的索引张量out的大小为z×n，其中z是input中非零元素的总数。

参数

input(Tensor): 输入张量。

out(LongTensor，可选): 包含索引的输出张量。

Example:
torch.reshape(input,shape): → Tensor

返回一个数据和元素数目与input完全相同，但形状可能不同的张量。如果可能的话，返回张量会是input的一个视图。换句话说，它会是一个复制。相邻的输入和具有兼容步幅的输入可以不经复制而调整形状，但你不应该依赖复制和视图(viewing)的对抗表现。

想了解何时能够返回视图，参阅https://blog.csdn.net/JachinMa/article/details/90766021的torch.Tensor.view()。

有一个维度的值可为-1，在这种情况下它的值可以从已有的维度数及input的数据数推断出来。

参数

input(Tensor): 要被调整形状的张量。

shape(tuple of python:ints): 新形状。

Example:
torch.split(tensor,split_size_or_sections,dim=0): → void

将张量分解为块。

若split_size_or_section类型是int，那么tensor会被分解为等大小的块(如果可能的话)。如果tensor在给定的维度上不能被split_size_or_section整除的话，最后一块会小一些。

如果split_size_or_section是列表，那么tensor会根据split_size_or_section在dim维上的大小，而被分为len(split_size_or_section)块。

参数

tensor(Tensor): 被分解的张量。

split_size_or_section(int or list(int)): 每一块的大小或每一块各自的大小——若为列表(注：实测tuple也可以)。

dim(int): 张量分解的维度。

Example:
torch.squeeze(input,dim=None,out=None): → Tensor

返回一个删去了原张量某些大小为1的维得到的张量。

例如，若input的形状是：(A×1×B×C×1×D)，且dim为给定，那么out张量的形状为：(A×B×C×D)。

当dim给定时，那就只对给定维度挤压。如果input的形状是:(A×1×B)，squeeze(input,0)并不会改变张量，但是squeeze(input,1)，将会把张量的形状挤压为(A×B)。

Note：
返回张量会和输入张量共享存储，所以改变其中一个的内容，会同时改变另一个。

参数

input(Tensor): 输入张量。

dim(int，可选): 若给定，那么输入张量只会被挤压该维度。

out(Tensor，可选): 输出张量。

Example:
torch.stack(seq,dim=0,out=None): → Tensor

沿新维度连接张量序列(注：连接后会产生新的dim维并堆叠)。

所有的张量需要具有相同的大小。

参数

seq(sequence of Tensors): 用于连接的张量序列。

dim(int): 插入维。必须得在0和被连接的张量维度数间(包括)。

out(Tensor，可选): 输出张量。

Example:
torch.T(input): → Tensor

期望input是小于等于二维的张量，且转换0和1维。

0和1维张量会被原样返回，二维张量(的该函数)可被视为函数transpose(input,0,1)的简写。

参数

input(Tensor): 输入张量。

Example:
torch.take(input,indices): → Tensor

返回由input中被indicies指定的元素组成的张量。输入张量被视为展开为一维张量。结果的形状与索引相同。

参数

input(Tensor): 输入张量。

indices(LongTensor): 张量的索引。

Example:

6.4

torch.transpose(input,dim0,dim1): → Tensor

返回一个input的转置。给定dim0和dim1维交换。

out结果和input张量共享存储，所以改变其中一个的内容会改变另一个的。

参数

input(Tensor): 输入张量。

dim0(int): 被转置的第一个维度。

dim1(int): 被转置的第二个维度。

Example:
torch.unbind(tensor,dim=0): → seq

去除一个张量维度。

返回一个在给定维度上的划分的元组。

参数

tensor(Tensor): 解绑的张量。

dim(int): 去除的张量。

Example:
torch.unsqueeze(input,dim,out=None): → Tensor

返回在指定位置插入的尺寸为1的新张量。

返回的张量和输入张量共享数据。

dim维在[-input.dim()-1,input.dim()+1)范围内的值可用。负的dim对应于在dim=dim + input.dim()+1处应用的unsqueeze()。

参数

input(Tensor): 输入张量。

dim(int): 插入单例维度(singleton dimension)的索引。

out(Tensor，可选): 输出张量。

Example:
torch.where(condition,x,y): → Tensor

返回一个每个元素都由condition决定从x或y中选取的张量。

函数的定义为：

Note:
张量condition,x,y都必须是可广播的(注：见https://blog.csdn.net/JachinMa/article/details/90764336)。

参数

conditon(ByteTensor): 当结果为True时，选择x对应位置的元素，否则选取y对应位置的元素。

x(Tensor): 当condition为True时从这里选取值。

y(Tensor): 当condition为False时从这里选取值。

Example:

Random Sampling

torch.manual_seed(seed): → torch._C.Generator

设置生成随机数的种子。返回torch._C.Generator对象。

参数

seed(int): 设定的种子。
torch.initial_seed(): → Python long

返回一个Python long型的生成随机数的初始化种子。

Example:
torch.get_rng_state(): → torch.ByteTensor

返回随机生成器的状态。
torch.set_rng_state(new_state)

设置随机数字生成器的状态。

参数

new_state(torch.ByteTensor): 规定的状态。
torch.bernoulli(input,*,generator=None,out=None): → Tensor

从伯努利分布中抽取随机数(0或1).

input张量应该是一个包含了用于抽取二元随机数的概率的张量。因此，input中的所有值应当在[0,1]内。

输出张量的第i个元素为1的概率等于input中对应元素的值。

返回的out张量的值只有0和1，并且和input的形状相同。

out可以是整型，但input必须是浮点型。

参数

input(Tensor): 表示伯努利分布概率的输入张量。

out(Tensor，可选): 输出张量。

Example：
multinomial(input,num_samples,replacement=False,out=None): → LongTensor

返回一个张量，它的每一行都对由input的对应行给定的多项式分布进行采样取得。

Note:
input的每一行的和不必是一(这种情况下我们把值视作权重)，但必须非负、有限且和不为零。

每次取样的结果从左到右依次铺开(第一个采样被放在第一行)。

若input为向量，则out是个大小为num_samples的向量。

若input为m行的矩阵，out则是形状为m×num_samples的矩阵。

若replacement为True，则为放回采样。

否则，则为不放回采样。也就是说，当一个样本的索引被某一行采样后，它将不能够再被改行采样。

Note:
当replacement为False时，num_sample的值必须比input中的非零元素数目小(当input为矩阵时，则应比input每一行的非零元素的最小数目还小)。

参数

input(Tensor): 包含概率的输入张量。

num_samples(int): 采样的数量。

replacement(bool，可选): 是否为放回采样采样。

out(Tensor，可选): 输出张量。

Example:
torch.normal(mean,std,out=None): → Tensor

返回一个由对多个独立的给定均值及标准差的正态分布进行采样的结果组成的张量。

mean是由每个输出元素的正态分布的均值构成的张量。

std是由每个输出元素的正态分布的标准差构成的张量。

mean和std的形状不必相同，但是每个张量的全部元素数必须相同。

Note:
当(mean和std的)形状不匹配时，返回张量的形状与mean相同。

参数

mean(Tensor): 由每个输出元素的正态分布的均值构成的张量。

std(Tensor): 由每个输出元素的正态分布的标准差构成的张量。

out(Tensor，可选): 输出张量。

Example:

mean也可以为浮点型数据，此时所有元素的均值相同，返回张量的形状与std相同。
torch.rand(*sizes,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False): → Tensor

返回一个由从[0,1)的均匀分布中随机取的数字组成的张量。

张量的形状由sizes决定。

参数

sizes(int…): 一系列定义输出张量形状的整形数据。可以是可变数量的实参，或像list或tuple这样的集合。

out(Tensor，可选): 输出张量。

dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())。

layout(torch.layout，可选): 规定返回张量的布局。默认为torch.strided。

device(torch.device，可选): 规定返回张量的设备。默认使用当前设备的默认张量类型(见torch.set_default_tensor_type())。当数据类型为CPU张量时，device为CPU；数据类型为CUDA张量时，为当前的CUDA设备。

requires_grad(bool，可选): 若自动求导应该记录在返回张量上的操作时(则为True)。默认为False。

Example:
torch.rand_like(input,dtype=None,layout=None,device=None,requires_grad=False): → Tensor

返回一个大小和input相同，由从[0,1)的均匀分布中随机取的数字组成的张量。torch.rand_like(input)和torch.rand(input.size(),dtype=input.dtype,layout=input.layout,device=input.device)等价。

参数

input(Tensor): input的大小会决定输出张量的大小。

dtype(torch.dtype，可选): 规定返回张量的类型。默认为None，此时(输出张量的)类型与input相同。

layout(torch.layout，可选): 规定返回张量的布局。默认为None，此时(输出张量的)布局与input相同。

device(torch.device，可选): 规定返回张量的设备。默认为None，此时(输出张量的)设备与input相同。

requires_grad(bool，可选): 若自动求导应该记录在返回张量上的操作时(则为True)。默认为False。
torch.randint(low=0,high,size,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False): → Tensor
返回一个由[low,high)区间均匀选取的随机整型数据生成的张量。

张量的形状由实参size定义

参数

low(int，可选): 取样时的左区间，默认为0。

high(int): 取样时的右区间。

size(tuple): 定义输出张量形状的元组。

out(Tensor，可选): 输出张量。

dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())。

layout(torch.layout，可选): 规定返回张量的布局。默认为torch.strided。

device(torch.device，可选): 规定返回张量的设备。默认使用当前设备的默认张量类型(见torch.set_default_tensor_type())。当数据类型为CPU张量时，device为CPU；数据类型为CUDA张量时，为当前的CUDA设备。

requires_grad(bool，可选): 若自动求导应该记录在返回张量上的操作时(则为True)。默认为False。

Example:
torch.randint_like(input,low=0,high,dtype=None,layout=torch.strided,device=None,requires_grad=False): → Tensor

返回一个由[low,high)区间均匀选取的随机整型数据生成的，形状与input相同的张量。

参数

input(Tensor): input的大小决定了输出张量的大小。

low(int，可选): 取样时的左区间，默认为0。

high(int): 取样时的右区间。

dtype(torch.dtype，可选): 规定返回张量的类型。默认为None，此时(输出张量的)类型与input相同。

layout(torch.layout，可选): 规定返回张量的布局。默认为None，此时(输出张量的)布局与input相同。

device(torch.device，可选): 规定返回张量的设备。默认为None，此时(输出张量的)设备与input相同。

requires_grad(bool，可选): 若自动求导应该记录在返回张量上的操作时(则为True)。默认为False。
torch.randn(sizes,out=None,dtype=None,layout=torch.strided,device=None,requires_grad=False): → Tensor

返回一个由从均值为0，方差为1的正态分布(即标准正态分布)中取样的数字构成的张量。

输出张量的形状由sizes定义。

参数

sizes(int…): 一系列定义输出张量形状的整形数据。可以是数字实参，也可以是像list或tuple那样的集合。

out(Tensor，可选): 输出张量。

dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())。

layout(torch.layout，可选): 规定返回张量的布局。默认为torch.strided。

device(torch.device，可选): 规定返回张量的设备。默认使用当前设备的默认张量类型(见torch.set_default_tensor_type())。当数据类型为CPU张量时，device为CPU；数据类型为CUDA张量时，为当前的CUDA设备。

requires_grad(bool，可选): 若自动求导应该记录在返回张量上的操作时(则为True)。默认为False。

Example:
torch.randn_like(input,dtype=None,layout=None,device=None,requires_grad=False): → Tensor

返回一个由从均值为0，方差为1的正态分布(即标准正态分布)中取样的数字构成的大小和input相同的张量。torch.randn_like(input)和torch.randn(input.size(),dtype=input.dtype,layout=input.layout,device=input.device)。

参数

input(Tensor): input的大小定义了输出张量的大小。

dtype(torch.dtype，可选): 规定返回张量的类型。默认为None，此时(输出张量的)类型与input相同。

layout(torch.layout，可选): 规定返回张量的布局。默认为None，此时(输出张量的)布局与input相同。

device(torch.device，可选): 规定返回张量的设备。默认为None，此时(输出张量的)设备与input相同。

requires_grad(bool，可选): 若自动求导应该记录在返回张量上的操作时(则为True)。默认为False。
torch.randperm(n,out=None,dtype=torch.int64,layout=torch.strided,device=None,requires_grad=False): → LongTensor

返回从[0,n-1)的整数随机排列。

参数

n(int): 排列的上界。

out(Tensor，可选): 输出张量。

dtype(torch.dtype，可选): 规定返回张量的数据类型。默认为None，此时使用全局默认值(见torch.set_default_tensor_type())。

layout(torch.layout，可选): 规定返回张量的布局。默认为torch.strided。

device(torch.device，可选): 规定返回张量的设备。默认使用当前设备的默认张量类型(见torch.set_default_tensor_type())。当数据类型为CPU张量时，device为CPU；数据类型为CUDA张量时，为当前的CUDA设备。

requires_grad(bool，可选): 若自动求导应该记录在返回张量上的操作时(则为True)。默认为False。

Example:

In-place Random Sampling

Class:torch.quasirandom.SobolEngine(dimension,scramble=False,seed=None):

torch.quasirandom.SobolEngine是用于生成Sobol序列的引擎。Sobol序列是低差异准随机序列的一个例子。

Sobol引擎的这种实现可以用于对最大1111维度的序列进行采样。它使用方向数来生成这些序列。

参数

dimension(int): 采样的序列的维度数。

scramble(bool，可选): 当该值为True时，将会生成拼凑(scrambled)的Sobol序列。此时能够产生更好的Sobol序列。默认为False。

seed(int，可选): 用于拼凑的种子。若指定的话，那么随机数生成器的种子设置为它。默认为None。

Example:

draw(n=1,out=None,dtype=torch.float32)

显示Sobol序列中的n个数字。注意每个样本和先前的样本相比都是独立的。结果的大小为(n,dimension)

参数

n(int，可选): 抽样的序列长度，默认为1.

out(Tensor，可选): 输出张量。

dtype(torch.dtype，可选): 规定返回张量的类型，默认为torch.float32.
fast_forward(n)

n步快进(fast-forward)SobolEngine的状态，这相当于在不使用样本的情况下绘制n个样本。

参数

n(int): 快进的步数。
reset()

将SobolEngine重设为原始状态。

Serialization

torch.save(obj,f,pickle_module=<module ‘pickle’ from ‘/opt/conda/lib/python3.6/pickle.py’>,pickle_protocol=2)

将一个对象存储至磁盘文件。

见：推荐的存储模型的方法(注：https://blog.csdn.net/JachinMa/article/details/92123226)。

参数

obj: 存储的对象。

f: 文件类对象(必须实现写入和刷新)或包含文件名的字符串。

pickle_module: 用于pickle元数据和对象的模块。

pickle_protocol: 可以通过指定它来覆盖默认协议。

Warining:
如果你使用的是python2版本，那么torch.save不支持将StringIO.StringIO视作有效的文件类对象。这是因为写入方法应该返回写入的比特数，但StringIO.write()却并不这样做。
可以用BytesIO这样的方法代替。

Example:
torch.load(f,map_location=None,pickle_module=<module ‘pickle’ from ‘/opt/conda/lib/python3.6/pickle.py’>,**pickle_load_args)

从torch.save()保存的文件里载入一个对象。

torch.load()使用Python的unpickling功能，但在对处理作为tensor基础的存储器时比较特殊。它们首先在CPU上反序列化，然后移动到它们保存的设备上。如果它操作失败了的话(比如说在运行时系统没有这些设备)，则会引发异常。然而，map_loacation参数可将存储动态地重新映射到另一组设备上。

如果map_location可调用，那每个序列化存储器都会使用storage和location来调用一次。storage参数将是驻留在CPU上的存储的初始反序列化。传递给map_location的第二个参数location是每个序列化存储器都有的，用于标记其存储的设备的参数。CPU张量固有的位置标签为’cpu’，而CUDA张量固有的位置标签则是’cuda:device_id(例如’cuda:2’)’。map_location应当返回None或一个storage。若map_location返回一个storage，它将会被用作最终的反序列化对象，且该storage已经被已经到了正确的设备。否则，torch.load将会回退到默认状态，就像未指定map_location一样。

如果map_location为字符串的话，它应该是一个设备的标签，这个设备应该加载所有的张量。

否则的话，如果map_location为dict，它将被用于将文件(键)中出现的位置标签重新映射到那些指定了storage(值)的放置位置的标记。

用户拓展可以使用register_package注册自己的位置标签、标签和反序列化方法。

参数

f: 一个类似文件的对象(必须支持read,readline,tell和seek)，或包含文件名的字符串。

map_location: 使用torch.device字符串或dict来重新映射存储位置的函数。

pickle_module: 用于unpickling元数据和对象(必须匹配用于序列化文件的pickle_module)的模块。

pickle_load_args: 可选的传递给pickle_module.load和pickle_module.Unpickler的关键字参数，比如encoding=…。

Note:
当你在包含了GPU张量的文件中调用torch.load()时，那些张量将会默认被加载到GPU上。你可以先调用torch.load(…,map_location=‘cpu’)，再调用load_state_dict()以避免在加载模型检查点时GPU的RAM激增。

Note:
在Python3里，当加载被Python2保存的文件时，你可能会遇到UnicodeDecodeError: ‘ascii’ codec can’t decode byte 0x…。这是由Python3和Python2在处理字节字符串时不同导致的。你可以使用额外的encoding关键字参数来指定这些对象应该如何被加载，例如encoding='latin1’能够将使用latin1编码的对象解码为字符串，encoding='bytes’能够将它们保存为此后可被byte_array.decode(…)解码的字节数组。

Example:

Parallelism

torch.get_num_threads(): → int

得到用于CPU并行操作的线程数。
torch.set_num_threads(int)

设置用于CPU并行操作的线程数。

为了保证使用正确数量的线程，在运行eager\JIT或自动求导函数前，必须先调用set_num_threads函数。

Example:

Locally Disabling Gradient Computation

上下文管理器torch.no_grad(),torch.enable_grad()和torch.set_grad_enabled()有助于本地禁止和启用梯度计算。见https://blog.csdn.net/JachinMa/article/details/92397268来获得更多该用法的细节。

Math Operation

Pointwise Ops

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

计算给定input张量逐元素的绝对值。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

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

返回由input的元素的反余弦值构成的张量。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

Example:

torch.add(input,value,other=1,out): → Tensor

当others为数字时，将input中的每个元素都加上value × other的结果；当others为张量时，则将other的每个元素都乘以value，再分别加上每个input的元素。

input和other的形状必须broadcastable。

若other为FloatTensor或DoubleTensor，则value必须是实数，或者是整数。

参数

input(Tensor): 第一个输入张量。

value(Number): other的标乘。

other(Tensor): 第二个输入张量。

out(Tensor，可选): 输出张量。

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

逐元素地计算tensor1和tensor2的商，将结果乘以value并加上tensor作为最终值，组成输出张量。

tensor、tensor1和tensor2的形状必须broadcastable。

当输入的张量的类型为FloatTensor或DoubleTensor时，value必须是实数或是整型。

参数

tensor(Tensor): 被加的张量。

value(Number，可选): tensor1/tensor2的放大倍数。

tensor1(Tensor): 分子张量。

tensor2(Tensor): 分母张量。

out(Tensor，张量): 输出张量。

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

逐元素地计算tensor1和tensor2的乘积，将结果乘以value再加上tensor。

tensor、tensor1和tensor2的形状必须broadcastable。

当输入的张量的类型为FloatTensor或DoubleTensor时，value必须是实数或是整型。

参数

tensor(Tensor): 被加的张量。

value(Number，可选): tensor1/tensor2的放大倍数。

tensor1(Tensor): 分子张量。

tensor2(Tensor): 分母张量。

out(Tensor，张量): 输出张量。

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

返回一个由input的元素的反正弦组成的张量。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

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

返回一个由input的元素的反正切值组成的张量。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

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

返回input1和input2的元素的反正切(注：经过测试，发现计算过程为input1的对应元素除以input2的对应元素然后计算反正切值)。

input1和input2的形状必须broadcastable。

参数

input1(Tensor): 第一个输入张量。

input2(Tensor): 第二个输入张量。

out(Tensor，可选): 输出张量。

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

返回一个由输入张量的元素的ceil函数值——大于或等于输入值的最小整数，构成的新张量

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

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

将input中的所有元素堆入[min,max]。

若input的类型是FloatTensor或DoubleTensor，则参数min和max必须是实数，否则它们应该是整型。

当min和max其中一个未指定时，其值默认为负无穷或正无穷。

参数

input(Tensor): 输入张量。

min(Number): 堆的下界。

max(Number): 堆的上界。

out(Tensor，可选): 输出张量。

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

返回由input的余弦值组成的张量。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

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

返回一个由input的双曲余弦值组成的张量。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

Example:
torch,div(input,value,out=None): → Tensor

当value为数字时，分别用input中的每个元素除以value；当value为张量时，分别用input的每个元素除以value的每个元素，此时input和value的形状必须broadcastable。

参数

input(Tensor): 被除数张量。

value(Number/Tensor): 除数。

out(Tensor): 输出张量。

Example:
torch.digamma(input,out=None): → Tensor

计算输入上伽马函数的对数导数(注：关于伽马函数，有一篇很不错的介绍：http://www.flickering.cn/数学之美/2014/06/神奇的伽玛函数上/)。

参数

input(Tensor): digamma函数的自变量。

Example:
torch.erf(tensor,out=None): → Tensor

计算input中每个元素的误差函数(error function)，其定义如下：

参数

tensor(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

Example:
torch.erfc(input,out=None) → Tensor

计算input中每个元素的互补误差函数(complementary error function)，其定义如下：

参数

tensor(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

Example:
torch.erfinv(input,out=None): → Tensor

计算input中每个函数的误差函数的反函数(inverse error function)，其定义如下：

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

Example:
torch.exp(input,out=None): → Tensor

返回由input的元素的指数值组成的张量。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

Example:
torch.expm1(input,out=None): → Tensor

返回由input中的元素的指数值减一组成的张量。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

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

返回由input的元素的底限组成的张量，底限指不大于该数的数。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

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

计算每个元素对divisor的余数。

被除数和除数可以是整数或浮点数。余数与输入的被除数具有相同的符号。

当divisor为张量时，input和divisor的形状必须broadcastable。

参数

input(Tensor): 被除数。

divisor(Tensor/Number): 除数，它既可以是数字，可以是和被除数形状相同的张量。

out(Tensor): 输出张量。

Example:
torch.frac(input,out=None): → Tensor

计算input中每个元素的小数部分。

Example:
torch.lerp(start,end,weight,out=None): → Tensor

根据标量或张量weight来对start和end两个张量进行线性插值并返回结果张量。

如果weight是张量，那么start和end的形状必须broadcastable。

参数

start(Tensor): 输入的起始张量。

end(Tensor): 输入的结束张量。

weight(float/tensor): 线性差值公式的权重。

out(Tensor，可选): 输出张量。

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

返回由input的元素的自然对数值组成的张量。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

Example:
torch.log10(input,out=None): → Tensor

返回一个由input的元素以10为底的对数值组成的张量。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。
torch.log2(input,out=None): → Tensor

返回一个由input的元素以2为底的对数值组成的张量。

参数

input(Tensor): 输入张量。

out(Tensor，可选): 输出张量。

Example:
torch.mul(input,value,out=None): → Tensor

返回input的每个元素与value的乘积。

若input的类型为FloatTensor或DoubleTensor，则value就必须是实数或整型。

若value为张量，则input和value的形状必须broadcastable。

参数

input(Tensor): 输入张量。

value(Number/Tensor): input的乘积。

out(Tensor，可选): 输出张量。

Example:
mvlgamma(input,p): → Tensor

沿p维度逐元素计算多变量的log-gamma函数，log-gamma函数定义如下：