torch.Tensor-CSDN博客

Data type	dtype	CPU tensor	GPU tensor
32-bit floating point	`torch.float32` or `torch.float`	`torch.FloatTensor`	`torch.cuda.FloatTensor`
64-bit floating point	`torch.float64` or `torch.double`	`torch.DoubleTensor`	`torch.cuda.DoubleTensor`
16-bit floating point	`torch.float16` or `torch.half`	`torch.HalfTensor`	`torch.cuda.HalfTensor`
8-bit integer (unsigned)	`torch.uint8`	`torch.ByteTensor`	`torch.cuda.ByteTensor`
8-bit integer (signed)	`torch.int8`	`torch.CharTensor`	`torch.cuda.CharTensor`
16-bit integer (signed)	`torch.int16` or `torch.short`	`torch.ShortTensor`	`torch.cuda.ShortTensor`
32-bit integer (signed)	`torch.int32` or `torch.int`	`torch.IntTensor`	`torch.cuda.IntTensor`
64-bit integer (signed)	`torch.int64` or `torch.long`	`torch.LongTensor`	`torch.cuda.LongTensor`
Boolean	`torch.bool`	torch.BoolTensor	`torch.cuda.BoolTensor`

torch.Tensor是默认张量类型的别名(torch.FloatTensor)。张量可以使用torch.tensor()构造函数从Python列表或序列中构造：

>>> torch.tensor([[1., -1.], [1., -1.]])
tensor([[ 1.0000, -1.0000],
        [ 1.0000, -1.0000]])
>>> torch.tensor(np.array([[1, 2, 3], [4, 5, 6]]))
tensor([[ 1,  2,  3],
        [ 4,  5,  6]])

警告：

通常复制数据，如果你有一个张量数据并且仅仅想改变它的requires_grad标记，使用requires_grad_()或 detach()来避免复制。如果你有一个numpy数组并且想避免复制，使用 torch.as_tensor()。指定数据类型的张量可以通过 torch.dtype或者 torch.device来构建或者张量创建op来构建。

>>> torch.zeros([2, 4], dtype=torch.int32)
tensor([[ 0,  0,  0,  0],
        [ 0,  0,  0,  0]], dtype=torch.int32)
>>> cuda0 = torch.device('cuda:0')
>>> torch.ones([2, 4], dtype=torch.float64, device=cuda0)
tensor([[ 1.0000,  1.0000,  1.0000,  1.0000],
        [ 1.0000,  1.0000,  1.0000,  1.0000]], dtype=torch.float64, device='cuda:0')

张量的内容可以通过Python的检索或者切片符号来访问和构建：

>>> x = torch.tensor([[1, 2, 3], [4, 5, 6]])
>>> print(x[1][2])
tensor(6)
>>> x[0][1] = 8
>>> print(x)
tensor([[ 1,  8,  3],
        [ 4,  5,  6]])

使用torch.Tensor.item()从包含单个值的张量中获得Python数值：

>>> x = torch.tensor([[1]])
>>> x
tensor([[ 1]])
>>> x.item()
1
>>> x = torch.tensor(2.5)
>>> x
tensor(2.5000)
>>> x.item()
2.5

张量可以用requires_grad=True来创建，这样torch.autograd记录对它们的操作，以便自动微分。

>>> x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True)
>>> out = x.pow(2).sum()
>>> out.backward()
>>> x.grad
tensor([[ 2.0000, -2.0000],
        [ 2.0000,  2.0000]])

每个张量都和torch.Storage相关，这保持了一个数据。张量类提供了一个多维，存储的条带视图，并定义其上的数值操作。

注意：

改变张量的方法用下划线后缀标记。例如，torch.FloatTensor.abs_()计算当前的绝对值并返回修改后的张量，而torch.FloatTensor.abs()计算结果得到一个新的张量。

注意：

为了改变已经存在的torch.device或者 torch.dtype，考虑使用张量上的 to()方法。

警告：

目前实施的torch.Tensor引入了内存开销，因此在有很多小张量的应用中可能会导致意外的高内存使用量。如果是这样，可以考虑使用一个大型结构。

class `torch.Tensor`

There are a few main ways to create a tensor, depending on your use case.

有几种主要的方式来创建一个张量，取决于你使用的情况：

创建一个提前存在数据的张量，使用torch.tensor()。
创建一个指定大小的张量，使用torch.* 张量创建op。
创建一个和其他张量具有相同尺寸的张量(相似的类型)，使用torch.*_like张量创建op(Creation Ops)。
创建一个和其他张量具有相同类型但是尺寸不同的张量，使用tensor.new_*操作ops。

`new_tensor`(data, dtype=None, device=None, requires_grad=False) → Tensor

以数据作为张量数据返回一个新的张量。默认情况下，返回的张量数据和这个张量的torch.dtype和 torch.device相同。

警告：

new_tensor()通常复制这个数据。如果你有一个张量数据并且想避免复制，使用torch.Tensor.requires_grad_()或 torch.Tensor.detach()。如果你有numpy数据并且想避免复制，使用 torch.from_numpy()。

警告：

当数据是一个张量x，new_tensor()从它所传递的内容中读出“数据”，并且构造叶变量。因此，tensor.new_tensor(x)和x.clone()相等，并且tensor.new_tensor(x, requires_grad=True)和x.clone().detach().requires_grad_(True)相等。同推荐使用clone()和detach()。

参数：

data (array_like) – The returned Tensor copies data. 返回的张量复制数据data。
dtype (torch.dtype, optional) – 返回数期望的类型。默认情况下：和这个张量的torch.dtype相同。
device (torch.device, optional) – 返回张量期望的设备。默认：如果没有的话，和这个张量相同。
requires_grad (bool, optional) – 在返回的张量上如果autograd是推荐的，默认：Fasle

例：

>>> tensor = torch.ones((2,), dtype=torch.int8)
>>> data = [[0, 1], [2, 3]]
>>> tensor.new_tensor(data)
tensor([[ 0,  1],
        [ 2,  3]], dtype=torch.int8)

**`new_full`(size, fill_value, dtype=None, device=None, requires_grad=False) → Tensor**

返回一个size的张量，size用fill_value填充。默认情况下，返回张量和这个张量的torch.dtype和 torch.device相等。

参数：

fill_value (scalar) – 填充输出张量的数。
dtype (torch.dtype, optional) – 返回张量的期望type。默认：如果没有的话，和这个张量的torch.dtype相同。
device (torch.device, optional) – 返回张量的期望设备，默认：如果没有的话，和这个张量的torch.device相同。
requires_grad (bool, optional) – 在返回张量上autograd是否应该推荐操作。默认：False。

例：

>>> tensor = torch.ones((2,), dtype=torch.float64)
>>> tensor.new_full((3, 4), 3.141592)
tensor([[ 3.1416,  3.1416,  3.1416,  3.1416],
        [ 3.1416,  3.1416,  3.1416,  3.1416],
        [ 3.1416,  3.1416,  3.1416,  3.1416]], dtype=torch.float64)

**`new_empty`(size, dtype=None, device=None, requires_grad=False) → Tensor**

返回一个size的张量，size用未初始化的数据填充。默认情况下，返回的张量和这个张量具有相同的torch.dtype和 torch.device。

参数：

dtype (torch.dtype, optional) – 返回张量的期望类型。默认：如果没有的话，和这个张量的torch.dtype相同。
device (torch.device, optional) – 返回张量期望的设备。默认：和这个张量的torch.device相同。
requires_grad (bool, optional) – 再返回的张量上autograd是否应该记录操作，默认：False。

例：

>>> tensor = torch.ones(())
>>> tensor.new_empty((2, 3))
tensor([[ 5.8182e-18,  4.5765e-41, -1.0545e+30],
        [ 3.0949e-41,  4.4842e-44,  0.0000e+00]])

`new_ones`(size, dtype=None, device=None, requires_grad=False) → Tensor

返回size的张量，size用1填充。默认情况下，返回的张量和这个张量具有相同的torch.dtype和 torch.device。

参数：

fill_value (scalar) – 填充输出张量的数。
dtype (torch.dtype, optional) – 返回张量的期望type。默认：如果没有的话，和这个张量的torch.dtype相同。
device (torch.device, optional) – 返回张量的期望设备，默认：如果没有的话，和这个张量的torch.device相同。
requires_grad (bool, optional) – 在返回张量上autograd是否应该推荐操作。默认：False。

例：

>>> tensor = torch.tensor((), dtype=torch.int32)
>>> tensor.new_ones((2, 3))
tensor([[ 1,  1,  1],
        [ 1,  1,  1]], dtype=torch.int32)

`new_zeros`(size, dtype=None, device=None, requires_grad=False) → Tensor

返回size的张量，size用0填充。默认情况下，返回的张量和这个张量具有相同的torch.dtype和 torch.device。

参数：

fill_value (scalar) – 填充输出张量的数。
dtype (torch.dtype, optional) – 返回张量的期望type。默认：如果没有的话，和这个张量的torch.dtype相同。
device (torch.device, optional) – 返回张量的期望设备，默认：如果没有的话，和这个张量的torch.device相同。
requires_grad (bool, optional) – 在返回张量上autograd是否应该推荐操作。默认：False。

Example:

>>> tensor = torch.tensor((), dtype=torch.float64)
>>> tensor.new_zeros((2, 3))
tensor([[ 0.,  0.,  0.],
        [ 0.,  0.,  0.]], dtype=torch.float64)

`is_cuda`

如果张量存储在GPU上的话就为真，否则为假。

`device`

torch.devic来表示张量在哪。

`grad`

默认情况下，属性为none，在第一次调用backward()为self计算梯度时成为一个张量。然后，该属性将包含计算得到的梯度，对backward()的未来调用将在其中累积(添加)梯度。

`ndim`

dim()的别名。

`T`

维度转置后的张量。

如果n是x中的维度数，x.T等于x.permute(n-1, n-2, ..., 0)

`acos_`() → Tensor

acos()的原地版本

`add`(value) → Tensor

add(value=1, other) -> Tensor

查看torch.add()

`add_`(value) → Tensor

add_(value=1, other) -> Tensor

add()的原地版本

`addbmm`(beta=1, alpha=1, batch1, batch2) → Tensor

查看torch.addbmm()

`addbmm_`(beta=1, alpha=1, batch1, batch2) → Tensor

addbmm()的原地版本

`addcdiv`(value=1, tensor1, tensor2) → Tensor

查看torch.addcdiv()

`addcdiv_`(value=1, tensor1, tensor2) → Tensor

addcdiv()的原地版本

`addcmul`(value=1, tensor1, tensor2) → Tensor

查看torch.addcmul()

`addcmul_`(value=1, tensor1, tensor2) → Tensor

addcmul()的原地版本

`addmm`(beta=1, alpha=1, mat1, mat2) → Tensor

查看torch.addmm()

`addmm_`(beta=1, alpha=1, mat1, mat2) → Tensor

addmm()的原地版本

`addmv`(beta=1, alpha=1, mat, vec) → Tensor

查看torch.addmv()

`addmv_`(beta=1, alpha=1, mat, vec) → Tensor

addmv()的原地版本

`addr`(beta=1, alpha=1, vec1, vec2) → Tensor

查看torch.addr()

`addr_`(beta=1, alpha=1, vec1, vec2) → Tensor

addr()的原地版本

`allclose`(other, rtol=1e-05, atol=1e-08, equal_nan=False) → Tensor

查看torch.allclose()

`apply_`(callable) → Tensor

在张量中对每个元素使用函数callable()，用callable返回的值替换每个元素。

注意：

这个函数仅仅在CPU中使用，并且不应该在需要高性能的代码章节中使用。

`argmax`(dim=None, keepdim=False) → LongTensor

查看torch.argmax()

`argmin`(dim=None, keepdim=False) → LongTensor

查看torch.argmin()

`argsort`(dim=-1, descending=False) → LongTensor

查看函数torch.argsort

`asin`() → Tensor

查看torch.asin()

`asin_`() → Tensor

asin()的原地版本

`as_strided`(size, stride, storage_offset=0) → Tensor

查看torch.as_strided()

`atan`() → Tensor

查看torch.atan()

`atan2`(other) → Tensor

查看torch.atan2()

`atan2_`(other) → Tensor

atan2()的原地版本

`atan_`() → Tensor

atan()的原地版本

`backward`(gradient=None, retain_graph=None, create_graph=False)[source]

计算当前张量关于图等级的梯度。图用链式法则求导。如果张量是一个非标量(例如，它的数据超过了一个)并且需要梯度，函数需要额外指定梯度。应该是一个匹配类型和位置的张量，包含关于self的微分函数的梯度。函数在叶中累积梯度-你也许需要在调用它之间置零。

参数：

gradient (Tensor or None) – 关于张量的梯度。如果它是一个张量，它将自动转换成不需要梯度的张量，除非create_graph为真。对标量张量不能指定任何值或者不需要梯度的张量。如果需要接受空值，这个参数是可选的。
retain_graph (bool, optional) – 如果为假，用来计算梯度的的图将被释放。请注意，在几乎所有情况下，不需要将此选项设置为True，而且通常可以以一种更有效的方式进行处理。默认值为create_graph。
create_graph (bool, optional) – 如果为真，则构造导数图，允许计算高阶导数。默认值为False。

`baddbmm`(beta=1, alpha=1, batch1, batch2) → Tensor

查看torch.baddbmm()

`baddbmm_`(beta=1, alpha=1, batch1, batch2) → Tensor

baddbmm()的原地版本

`bernoulli`(, generator=None*) → Tensor

返回一个张量，其中每个result[i]从Bernoulli(self[i])。self必须为浮点数类型，结果具有相同的dtype。查看torch.bernoulli()

`bernoulli_`(p=0.5, , generator=None*) → Tensor

将self的每个位置用Bernoulli(p)独立的采样填充。self可以是积分的dtype。

`bernoulli_`(p_tensor, , generator=None*) → Tensor

p_tensor应该是一个包含概率的张量，用来产生二进制的随机数。self的 $i^{th}$ 个元素必须设置成Bernoulli(p_tensor[i])的采样值。self可以有dtype, 但是p_tensor必须有浮点数的dtype。也看bernoulli() 看torch.bernoulli()。