同步操作将从 OpenDocCN/pytorch-doc-zh 强制同步,此操作会覆盖自 Fork 仓库以来所做的任何修改,且无法恢复!!!
确定后同步将在后台操作,完成时将刷新页面,请耐心等待。
torch.Tensor
是一种包含单一数据类型元素的多维矩阵。
Torch 定义了七种 CPU 张量类型和八种 GPU 张量类型:
Data tyoe | CPU tensor | GPU tensor |
---|---|---|
32-bit floating point | torch.FloatTensor |
torch.cuda.FloatTensor |
64-bit floating point | torch.DoubleTensor |
torch.cuda.DoubleTensor |
16-bit floating point | N/A | torch.cuda.HalfTensor |
8-bit integer (unsigned) | torch.ByteTensor |
torch.cuda.ByteTensor |
8-bit integer (signed) | torch.CharTensor |
torch.cuda.CharTensor |
16-bit integer (signed) | torch.ShortTensor |
torch.cuda.ShortTensor |
32-bit integer (signed) | torch.IntTensor |
torch.cuda.IntTensor |
64-bit integer (signed) | torch.LongTensor |
torch.cuda.LongTensor |
torch.Tensor
是默认的 tensor 类型(torch.FlaotTensor
)的简称。
张量可以从 Python 的list
或序列构成:
>>> torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
1 2 3
4 5 6
[torch.FloatTensor of size 2x3]
可以通过指定它的大小来构建一个空的张量:
>>> torch.IntTensor(2, 4).zero_()
0 0 0 0
0 0 0 0
[torch.IntTensor of size 2x4]
可以使用 Python 的索引和切片符号来访问和修改张量的内容:
>>> x = torch.FloatTensor([[1, 2, 3], [4, 5, 6]])
>>> print(x[1][2])
6.0
>>> x[0][1] = 8
>>> print(x)
1 8 3
4 5 6
[torch.FloatTensor of size 2x3]
每一个张量 tensor 都有一个相应的torch.Storage
保存其数据。张量类提供了一个多维的、横向视图的存储,并定义了数字操作。
注意: 改变张量的方法可以用一个下划线后缀来标示。比如,
torch.FloatTensor.abs_()
会在原地计算绝对值并返回修改的张量,而tensor.FloatTensor.abs()
将会在新张量中计算结果。
class torch.Tensor
class torch.Tensor(*sizes)
class torch.Tensor(size)
class torch.Tensor(sequence)
class torch.Tensor(ndarray)
class torch.Tensor(tensor)
class torch.Tensor(storage)
从可选的大小或数据创建新的张量。 如果没有给出参数,则返回空的零维张量。如果提供了numpy.ndarray
,torch.Tensor
或torch.Storage
,将会返回一个相同数据的新张量.如果提供了 python 序列,则从序列的副本创建一个新的张量。
参考torch.abs()
,矩阵数组绝对值
abs()
的直接运算形式
参考torch.acos()
acos()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.add()
add()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.addbmm()
addbmm()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.addcdiv()
addcdiv()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.addcmul()
addcmul()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.addmm()
addmm()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.addmv()
addmv()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.addr()
addr()
的直接运算形式,即直接执行并且返回修改后的张量
将函数callable
作用于 tensor 中每一个元素,并替换每个元素用callable
函数返回的值。
注意: 该函数只能在 CPU tensor 中使用,并且不应该用在有较高性能要求的代码块。
参考torch.asin()
asin()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.atan()
参考torch.atan2()
atan2()
的直接运算形式,即直接执行并且返回修改后的张量
atan()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.baddbmm()
baddbmm()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.bernoulli()
bernoulli()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.bmm()
将 tensor 改为 byte 类型
将 tensor 中元素用柯西分布得到的数值填充: P(x)=1/π * σ/(x−median)2+σ2
参考torch.ceil()
ceil()
的直接运算形式,即直接执行并且返回修改后的张量
将 tensor 元素改为 char 类型
将 tensor 分割为 tensor 元组. 参考torch.chunk()
参考torch.clamp()
clamp()
的直接运算形式,即直接执行并且返回修改后的张量
返回与原 tensor 有相同大小和数据类型的 tensor
返回一个内存连续的有相同数据的 tensor,如果原 tensor 内存连续则返回原 tensor
将src
中的元素复制到 tensor 中并返回这个 tensor。 如果 broadcast 是 True,则源张量必须可以使用该张量广播。否则两个 tensor 应该有相同数目的元素,可以是不同的数据类型或存储在不同的设备上。
参数:
参考torch.cos()
cos()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.cosh()
cosh()
的直接运算形式,即直接执行并且返回修改后的张量
如果在 CPU 上没有该 tensor,则会返回一个 CPU 的副本
参考torch.cross()
返回此对象在 CPU 内存中的一个副本 如果该对象已经在 CUDA 内存中,并且在正确的设备上,则不会执行任何副本,并返回原始对象。
参数:
参考torch.cumprod()
参考torch.cumsum()
返回 tensor 第一个元素的地址
参考torch.diag()
返回 tensor 的维数
参考torch.dist()
参考torch.div()
div()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.dot()
将该 tensor 投射为 double 类型
参考torch.eig()
返回单个元素的字节大小。 例:
>>> torch.FloatTensor().element_size()
4
>>> torch.ByteTensor().element_size()
1
参考torch.eq()
eq()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.equal()
参考torch.exp()
exp()
的直接运算形式,即直接执行并且返回修改后的张量
返回 tensor 的一个新视图,单个维度扩大为更大的尺寸。 tensor 也可以扩大为更高维,新增加的维度将附在前面。 扩大 tensor 不需要分配新内存,只是仅仅新建一个 tensor 的视图,其中通过将stride
设为 0,一维将会扩展位更高维。任何一个一维的在不分配新内存情况下可扩展为任意的数值。
参数:
例:
>>> x = torch.Tensor([[1], [2], [3]])
>>> x.size()
torch.Size([3, 1])
>>> x.expand(3, 4)
1 1
1 1
2 2 2 2
3 3 3 3
[torch.FloatTensor of size 3x4]
将 tensor 扩展为参数 tensor 的大小。 该操作等效与:
self.expand(tensor.size())
将该 tensor 用指数分布得到的元素填充: $$ P(x)= \lambda e^{- \lambda x} $$
将该 tensor 用指定的数值填充
将 tensor 投射为 float 类型
参考torch.floor()
floor()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.fmod()
fmod()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.frac()
frac()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.gather()
参考torch.ge()
ge()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.gels()
将该 tensor 用几何分布得到的元素填充: $$ P(X=k)= (1-p)^{k-1}p $$
参考torch.geqrf()
参考torch.ger()
参考torch.gesv()
参考torch.gt()
gt()
的直接运算形式,即直接执行并且返回修改后的张量
将 tensor 投射为半精度浮点类型
参考torch.histc()
用一个二进制的掩码或沿着一个给定的维度从 tensor 中选取元素。tensor.index(m)
与tensor[m]
完全相同。
参数:
m(int or Byte Tensor or slice)-用来选取元素的维度或掩码
按参数 index 中的索引数确定的顺序,将参数 tensor 中的元素加到原来的 tensor 中。参数 tensor 的尺寸必须严格地与原 tensor 匹配,否则会发生错误。
参数:
例:
>>> x = torch.Tensor([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
>>> t = torch.Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> index = torch.LongTensor([0, 2, 1])
>>> x.index_add_(0, index, t)
>>> x
2 3 4
8 9 10
5 6 7
[torch.FloatTensor of size 3x3]
按参数 index 中的索引数确定的顺序,将参数 tensor 中的元素复制到原来的 tensor 中。参数 tensor 的尺寸必须严格地与原 tensor 匹配,否则会发生错误。
参数:
例:
>>> x = torch.Tensor(3, 3)
>>> t = torch.Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> index = torch.LongTensor([0, 2, 1])
>>> x.index_copy_(0, index, t)
>>> x
1 2 3
7 8 9
4 5 6
[torch.FloatTensor of size 3x3]
按参数 index 中的索引数确定的顺序,将原 tensor 用参数val
值填充。
参数:
例:
>>> x = torch.Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> index = torch.LongTensor([0, 2])
>>> x.index_fill_(0, index, -1)
>>> x
-1 2 -1
-1 5 -1
-1 8 -1
[torch.FloatTensor of size 3x3]
参考torch.index_select()
将该 tensor 投射为 int 类型
参考torch.inverse()
如果该 tensor 在内存中是连续的则返回 True。
如果该 tensor 在固定内内存中则返回 True
如果此对象引用与 Torch C API 相同的THTensor
对象作为给定的张量,则返回 True。
参考torch.kthvalue()
参考torch.le()
le()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.lerp()
lerp()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.log()
参考torch.loglp()
loglp()
的直接运算形式,即直接执行并且返回修改后的张量
log()
的直接运算形式,即直接执行并且返回修改后的张量
将该 tensor 用均值为$\mu$,标准差为$\sigma$的对数正态分布得到的元素填充。要注意mean
和stdv
是基本正态分布的均值和标准差,不是返回的分布: $$ P(X)= \frac {1} {x \sigma \sqrt {2 \pi}}e^{- \frac {(lnx- \mu)^2} {2 \sigma^2}} $$
将 tensor 投射为 long 类型
参考torch.lt()
lt()
的直接运算形式,即直接执行并且返回修改后的张量
将callable
作用于本 tensor 和参数 tensor 中的每一个元素,并将结果存放在本 tensor 中。callable
应该有下列标志:
def callable(a, b) -> number
将mask
中值为 1 元素对应的source
中位置的元素复制到本 tensor 中。mask
应该有和本 tensor 相同数目的元素。source
中元素的个数最少为mask
中值为 1 的元素的个数。
参数:
注意:
mask
作用于self
自身的 tensor,而不是参数中的source
。maskedfill(mask, value)
在
mask
值为 1 的位置处用value
填充。mask
的元素个数需和本 tensor 相同,但尺寸可以不同。形状 mask 必须 与下面的张量的形状一起广播。
参数:
参考torch.masked_select()
参考torch.max()
参考torch.mean()
参考torch.median()
参考torch.min()
参考torch.mm()
参考torch.mode()
参考torch.mul()
mul()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.multinomial()
参考torch.mv()
返回这个张量的缩小版本的新张量。维度dim
缩小范围是start
到start+length
。返回的张量和该张量共享相同的底层存储。
参数:
例:
>>> x = torch.Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> x.narrow(0, 0, 2)
1 2 3
4 5 6
[torch.FloatTensor of size 2x3]
>>> x.narrow(1, 1, 2)
2 3
5 6
8 9
[torch.FloatTensor of size 3x2]
dim()
的另一种表示。
参考torch.ne()
ne()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.neg()
neg()
的直接运算形式,即直接执行并且返回修改后的张量
numel()
的另一种表示
构建一个有相同数据类型的 tensor
参考`torch.nonezero()
参考`torch.norm()
将 tensor 用均值为mean
和标准差为std
的正态分布填充。
参考numel()
将该 tensor 以 NumPy 的形式返回ndarray
,两者共享相同的底层内存。原 tensor 改变后会相应的在ndarray
有反映,反之亦然。
参考torch.orgqr()
参考torch.ormqr()
将 tensor 的维度换位。
参数:
例:
>>> x = torch.randn(2, 3, 5)
>>> x.size()
torch.Size([2, 3, 5])
>>> x.permute(2, 0, 1).size()
torch.Size([5, 2, 3])
将张量复制到固定内存(如果尚未固定)。
参考torch.potrf()
参考torch.potri()
参考torch.potrs()
参考torch.pow()
pow()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.prod()
参考torch.pstrf()
参考torch.qr()
将 tensor 用从在[from, to-1]上的正态分布或离散正态分布取样值进行填充。如果未指定,则该值仅由该张量数据类型限定。
参考torch.reciprocal()
reciprocal()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.remainder()
remainder()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.renorm()
renorm()
的直接运算形式,即直接执行并且返回修改后的张量
沿指定维度重复此张量。 与expand()
功能不同,此功能可复制张量中的数据。
参数:
例:
>>> x = torch.Tensor([1, 2, 3])
>>> x.repeat(4, 2)
1 2 3 1 2 3
1 2 3 1 2 3
1 2 3 1 2 3
1 2 3 1 2 3
[torch.FloatTensor of size 4x6]
>>> x.repeat(4, 2, 1).size()
torch.Size([4, 2, 3])
将 tensor 的大小调整为指定的大小。如果元素个数比当前的内存大小大,就将底层存储大小调整为与新元素数目一致的大小。如果元素个数比当前内存小,则底层存储不会被改变。原来 tensor 中被保存下来的元素将保持不变,但新内存将不会被初始化。
参数:
例:
>>> x = torch.Tensor([[1, 2], [3, 4], [5, 6]])
>>> x.resize_(2, 2)
>>> x
1 2
3 4
[torch.FloatTensor of size 2x2]
将当前张量调整为与指定张量相同的大小。这相当于:
self.resize_(tensor.size())
参考torch.round()
round()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.rsqrt()
rsqrt()
的直接运算形式,即直接执行并且返回修改后的张量
将src
中的所有值按照index
确定的索引写入本 tensor 中。其中索引是根据给定的 dimension,dim 按照gather()
描述的规则来确定。
请注意,对于 collect,index 的值必须在 0 和(self.size(dim)-1)之间,包括所有值,并且指定维中的一行中的所有值必须是唯一的。
参数:
例子:
>>> x = torch.rand(2, 5)
>>> x
0.4319 0.6500 0.4080 0.8760 0.2355
0.2609 0.4711 0.8486 0.8573 0.1029
[torch.FloatTensor of size 2x5]
>>> torch.zeros(3, 5).scatter_(0, torch.LongTensor([[0, 1, 2, 0, 0], [2, 0, 0, 1, 2]]), x)
0.4319 0.4711 0.8486 0.8760 0.2355
0.0000 0.6500 0.0000 0.8573 0.0000
0.2609 0.0000 0.4080 0.0000 0.1029
[torch.FloatTensor of size 3x5]
>>> z = torch.zeros(2, 4).scatter_(1, torch.LongTensor([[2], [3]]), 1.23)
>>> z
0.0000 0.0000 1.2300 0.0000
0.0000 0.0000 0.0000 1.2300
[torch.FloatTensor of size 2x4]
按照 index 中选定的维度将 tensor 切片。如果 tensor 是一维的,则返回一个数字。否则,返回给定维度已经被移除的 tensor。
参数:
注意:
select()
等效于切片。例如:tensor.select(0, index)
等效于tensor[index]
,tensor.select(2, index)
等效于tensor[:,:,index]
设置底层内存,大小和步长。如果 source 是张量,则该张量将共享相同的存储空间,并且具有与给定张量相同的大小和步长。另一个则反映在一个张量内的元素变化。
参数:
将底层存储器移动到共享内存。 如果底层存储已经在共享内存和 CUDA 张量中,不进行任何操作。共享内存中的 Tensors 无法调整大小。
将 tensor 投射为 short 类型。
参考torch.sigmoid()
sidmoid()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.sign()
sign()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.sin()
sin()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.sinh()
sinh()
的直接运算形式,即直接执行并且返回修改后的张量
返回 tensor 的大小。返回的值是tuple
的子类。
例:
>>> torch.Tensor(3, 4, 5).size()
torch.Size([3, 4, 5])
参考torhc.sort()
将 tensor 分割成 tensor 数组。 参考torhc.split()
参考torch.sqrt()
sqrt()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.squeeze()
squeeze()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.std()
返回底层内存。
以储存元素的个数的形式返回 tensor 在地城内存中的偏移量。 例:
>>> x = torch.Tensor([1, 2, 3, 4, 5])
>>> x.storage_offset()
0
>>> x[3:].storage_offset()
3
返回 tesnor 的步长。
从该张量中排除一个标量或张量。如果value
和other
都是给定的,则在使用之前other
的每一个元素都会被value
缩放。 当other
是一个张量,other
的形状必须可以与下面的张量的形状一起广播。
sub()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.sum()
参考torch.svd()
参考torch.symeig()
参考torch.t()
t()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.tan()
tan()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.tanh()
tanh()
的直接运算形式,即直接执行并且返回修改后的张量
返回一个 tensor 的嵌套列表表示。
参考torch.topk()
参考torch.trace()
参考torch.transpose()
transpose()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.tril()
tril()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.triu()
triu()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.trtrs()
参考torch.trunc()
trunc()
的直接运算形式,即直接执行并且返回修改后的张量
如果未提供 new_type,则返回类型,否则将此对象转换为指定的类型。 如果已经是正确的类型,则不会执行且返回原对象。
参数:
将此张量转换为给定类型的张量。 如果张量已经是正确的类型,则不会执行操作。等效于:
self.type(tensor.type())
参数:
返回一个张量,其中包含尺寸 size 中所有尺寸的维度。 如果sizedim是 dim 维度的原始大小,则返回张量中的维度是(sizedim-size)/step+1
维度大小的附加维度将附加在返回的张量中。
参数:
例子:
>>> x = torch.arange(1, 8)
>>> x
1
2
3
4
5
6
7
[torch.FloatTensor of size 7]
>>> x.unfold(0, 2, 1)
1 2
2 3
3 4
4 5
5 6
6 7
[torch.FloatTensor of size 6x2]
>>> x.unfold(0, 2, 2)
1 2
3 4
5 6
[torch.FloatTensor of size 3x2]
用均匀分布采样的数字填充该张量:
参考torch.unsqueeze()
unsqueeze()
的直接运算形式,即直接执行并且返回修改后的张量
参考torch.var()
返回具有相同数据但大小不同的新张量。 返回的张量必须有与原张量相同的数据和相同数量的元素,但可以有不同的大小。一个张量必须是连续contiguous()
的才能被查看。
例子:
>>> x = torch.randn(4, 4)
>>> x.size()
torch.Size([4, 4])
>>> y = x.view(16)
>>> y.size()
torch.Size([16])
>>> z = x.view(-1, 8) # the size -1 is inferred from other dimensions
>>> z.size()
torch.Size([2, 8])
返回被视作与给定的 tensor 相同大小的原 tensor。 等效于:
self.view(tensor.size())
用 0 填充这个张量。
用户名 | 头像 | 职能 | 签名 |
---|---|---|---|
Song | 翻译 | 人生总要追求点什么 |
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。