国产乱婬AV片免费右手影院,国产免费mv大全视频网站

原文：PyTorch torch張量

torch.Tensor 是包含單個數(shù)據(jù)類型元素的多維矩陣。

Torch 定義了 9 種 CPU 張量類型和 9 種 GPU 張量類型：

數(shù)據(jù)類型	dtype	CPU 張量	GPU 張量
32 位浮點	`torch.float32`或`torch.float`	`torch.FloatTensor`	`torch.cuda.FloatTensor`
64 位浮點	`torch.float64`或`torch.double`	`torch.DoubleTensor`	`torch.cuda.DoubleTensor`
16 位浮點	`torch.float16`或`torch.half`	`torch.HalfTensor`	`torch.cuda.HalfTensor`
8 位整數(shù)(無符號）	`torch.uint8`	`torch.ByteTensor`	`torch.cuda.ByteTensor`
8 位整數(shù)(有符號）	`torch.int8`	`torch.CharTensor`	`torch.cuda.CharTensor`
16 位整數(shù)(有符號）	`torch.int16`或`torch.short`	`torch.ShortTensor`	`torch.cuda.ShortTensor`
32 位整數(shù)(有符號）	`torch.int32`或`torch.int`	`torch.IntTensor`	`torch.cuda.IntTensor`
64 位整數(shù)(有符號）	`torch.int64`或`torch.long`	`torch.LongTensor`	`torch.cuda.LongTensor`
布爾型	`torch.bool`	`torch.BoolTensor`	`torch.cuda.BoolTensor`

torch.Tensor 是默認(rèn)張量類型(torch.FloatTensor）的別名。

可以使用 torch.tensor() 構(gòu)造函數(shù)從 Python list或序列構(gòu)造張量：

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

警告

torch.tensor() 始終復(fù)制data。如果您具有張量data，而只想更改其requires_grad標(biāo)志，請使用 requires_grad_() 或 detach() 以避免復(fù)制。如果您有一個 numpy 數(shù)組并且想要避免復(fù)制，請使用 torch.as_tensor() 。

可以通過將 torch.dtype 和/或 torch.device 傳遞給構(gòu)造函數(shù)或張量創(chuàng)建操作來構(gòu)造特定數(shù)據(jù)類型的張量：

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

張量的內(nèi)容可以使用 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 數(shù)字：

>>> 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創(chuàng)建一個張量，以便 torch.autograd 對其進(jìn)行記錄操作以進(jìn)行自動微分。

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

每個張量都有一個關(guān)聯(lián)的torch.Storage，它保存其數(shù)據(jù)。張量類提供了存儲的多維跨度視圖，并定義了數(shù)字運算。

注意

有關(guān) torch.Tensor 的 torch.dtype ， torch.device 和 torch.layout 屬性的更多信息，請參閱。

注意

改變張量的方法用下劃線后綴標(biāo)記。例如，torch.FloatTensor.abs_()在原位計算絕對值并返回修改后的張量，而torch.FloatTensor.abs()在新張量中計算結(jié)果。

注意

要更改現(xiàn)有張量的 torch.device 和/或 torch.dtype ，請考慮在張量上使用 to() 方法。

警告

torch.Tensor 的當(dāng)前實現(xiàn)引入了內(nèi)存開銷，因此，在具有許多微小張量的應(yīng)用程序中，它可能導(dǎo)致意外的高內(nèi)存使用率。如果是這種情況，請考慮使用一種大型結(jié)構(gòu)。

class torch.Tensor

根據(jù)您的用例，創(chuàng)建張量的主要方法有幾種。

要使用現(xiàn)有數(shù)據(jù)創(chuàng)建張量，請使用 torch.tensor() 。
要創(chuàng)建具有特定大小的張量，請使用torch.*張量創(chuàng)建操作。
要創(chuàng)建與另一個張量具有相同大小(和相似類型）的張量，請使用torch.*_like張量創(chuàng)建操作(請參見創(chuàng)建操作）。
要創(chuàng)建與其他張量具有相似類型但大小不同的張量，請使用tensor.new_*創(chuàng)建操作。

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

返回以data作為張量數(shù)據(jù)的新張量。默認(rèn)情況下，返回的張量與此張量具有相同的 torch.dtype 和 torch.device 。

警告

new_tensor() 始終復(fù)制data。如果您有張量data并希望避免復(fù)制，請使用 torch.Tensor.requires_grad_() 或 torch.Tensor.detach() 。如果您有一個 numpy 數(shù)組并且想要避免復(fù)制，請使用 torch.from_numpy() 。

警告

當(dāng)數(shù)據(jù)是張量 x 時， new_tensor() 從傳遞的任何數(shù)據(jù)中讀出“數(shù)據(jù)”，并構(gòu)造一個葉子變量。因此，tensor.new_tensor(x)等同于x.clone().detach()，tensor.new_tensor(x, requires_grad=True)等同于x.clone().detach().requires_grad_(True)。建議使用clone()和detach()的等效項。

參數(shù)

data (array_like )–返回的張量副本data。
dtype (torch.dtype ，可選）– 返回張量的所需類型。默認(rèn)值：如果為 None，則與此張量相同的 torch.dtype 。
device (torch.device ，可選）– 返回張量的所需設(shè)備。默認(rèn)值：如果為 None，則與此張量相同的 torch.device 。
require_grad (bool ，可選）– 返回的張量是否需要自動求導(dǎo)。默認(rèn)值：False。

例：

>>> 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 的張量，并用fill_value填充。默認(rèn)情況下，返回的張量與此張量具有相同的 torch.dtype 和 torch.device 。

參數(shù)

fill_value (標(biāo)量）–用來填充輸出張量的數(shù)字。
dtype (torch.dtype, optional) – 返回張量的所需類型。默認(rèn)值：如果為 None，則與此張量相同的 torch.dtype 。
device (torch.device, optional) – 返回張量的所需設(shè)備。默認(rèn)值：如果為 None，則與此張量相同的 torch.device 。
requires_grad (bool__, optional) – 返回的張量是否需要自動求導(dǎo)。默認(rèn)值：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 的張量，其中填充了未初始化的數(shù)據(jù)。默認(rèn)情況下，返回的張量具有與此張量相同的 torch.dtype 和 torch.device 。

參數(shù)

dtype (torch.dtype, optional) –
device (torch.device, optional) – 返回張量的所需設(shè)備。默認(rèn)值：如果為 None，則與此張量相同的 torch.device 。
requires_grad (bool__, optional) – 返回的張量是否需要自動求導(dǎo)。默認(rèn)值：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 的張量，并用1填充。默認(rèn)情況下，返回的張量與此張量具有相同的 torch.dtype 和 torch.device 。

參數(shù)

大小 (python：int ... )–定義輸出張量形狀的整數(shù)列表，元組或torch.Size。
dtype (torch.dtype, optional) – 返回張量的所需類型。默認(rèn): 如果是 None, 和 torch.dtype 一樣
device (torch.device, optional) – 返回張量所在的設(shè)備。默認(rèn): 如果是 None, 和 torch.device 一樣
requires_grad (bool__, optional) – 返回的張量是否需要自動求導(dǎo)。默認(rèn)值：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 的張量，并用0填充。默認(rèn)情況下，返回的張量與此張量具有相同的 torch.dtype 和 torch.device 。

參數(shù)

size (python:int...) – a list, tuple, or torch.Size of integers defining the shape of the output tensor.
dtype (torch.dtype, optional) – 返回張量的所需類型。默認(rèn)值：如果為 None，則與此張量相同的 torch.dtype 。
device (torch.device, optional) – 返回張量的所需設(shè)備。默認(rèn)值：如果為 None，則與此張量相同的 torch.device 。
requires_grad (bool__, optional) – 返回的張量是否需要自動求導(dǎo)。默認(rèn)值：False。

例：

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

如果張量存儲在 GPU 上，則為True，否則為False。

device

張量所在的 torch.device 。

grad

此屬性默認(rèn)為None，并在首次調(diào)用 backward() 計算self的梯度時成為張量。然后，該屬性將包含計算出的梯度以及 backward()返回的梯度值，然后進(jìn)行梯度累加。

ndim

dim() 的別名

這個張量的尺寸是否顛倒了嗎？

如果n是x中的尺寸數(shù)，則x.T等效于x.permute(n-1, n-2, ..., 0)。

abs() → Tensor

torch.abs()

abs_() → Tensor

就地版本的 abs()

acos() → Tensor

torch.acos()

acos_() → Tensor

就地版本的 acos()

add(value) → Tensor

add(value = 1，other）->張量

torch.add()

add_(value) → Tensor

add_(value = 1，other）->張量

就地版本的 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()

angle() → Tensor

torch.angle()

apply_(callable) → Tensor

將函數(shù)callable應(yīng)用于張量中的每個元素，并用callable返回的值替換每個元素。

注意

此功能僅適用于 CPU 張量，不應(yīng)在需要高性能的代碼段中使用。

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

torch.argmax()

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

torch.argmin()

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

參見：func： <cite>torch.argsort</cite>

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)

計算當(dāng)前張量的梯度 w.r.t. 圖葉。

該圖使用鏈?zhǔn)椒▌t進(jìn)行區(qū)分。如果張量是非標(biāo)量的(即其數(shù)據(jù)具有多個元素）并且需要梯度，則該函數(shù)還需要指定gradient。它應(yīng)該是匹配類型和位置的張量，其中包含微分函數(shù) w.r.t 的梯度。 self。

此函數(shù)是葉子梯度累加-調(diào)用它之前可能需要將它們歸零。

參數(shù)

gradient (tensor Tensor None）– 梯度 w.r.t. 張量。如果它是張量，除非create_graph為 True，否則它將自動轉(zhuǎn)換為不需要 grad 的張量。無法為標(biāo)量張量或不需要等級的張量指定任何值。如果 None 值可以接受，那么此參數(shù)是可選的。
retian_graph (bool ，可選）– 如果False，則用于計算等級的圖形將被釋放。請注意，幾乎在所有情況下都不需要將此選項設(shè)置為 True，并且通?？梢砸愿行У姆绞浇鉀Q它。默認(rèn)為create_graph的值。
create_graph (bool ，可選）– 如果True，則將構(gòu)造導(dǎo)數(shù)圖，從而允許計算高階導(dǎo)數(shù)產(chǎn)品。默認(rèn)為False。

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

torch.baddbmm()

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

就地版本的 baddbmm()

bernoulli(*, generator=None) → Tensor

返回結(jié)果張量，其中每個$result[i]$從$Bernoulli(self[i])$中獨立采樣。 self必須具有浮點dtype，結(jié)果將具有相同的dtype。

torch.bernoulli()

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

用$Bernoulli(p)$的獨立樣本填充self的每個位置。 self可以具有整數(shù)dtype。

bfloat16() → Tensor

self.bfloat16()等效于self.to(torch.bfloat16)。 to() 。

bincount(weights=None, minlength=0) → Tensor

torch.bincount()

bitwise_not() → Tensor

torch.bitwise_not()

bitwise_not_() → Tensor

就地版本的 bitwise_not()

bitwise_xor() → Tensor

torch.bitwise_xor()

bitwise_xor_() → Tensor

就地版本的 bitwise_xor()

bmm(batch2) → Tensor

torch.bmm()

bool() → Tensor

self.bool()等效于self.to(torch.bool)。 to() 。

byte() → Tensor

self.byte()等效于self.to(torch.uint8)。 to() 。

cauchy_(median=0, sigma=1, *, generator=None) → Tensor

用從柯西分布中得出的數(shù)字填充張量：

f(x)=\frac {1}{\pi}\frac {\sigma}{(x-median)^2+\sigma^2}f(x)=π1(x?*media*n)2+σ2σ

ceil() → Tensor

torch.ceil()

ceil_() → Tensor

就地版本的 ceil()

char() → Tensor

self.char()等效于self.to(torch.int8)。 to() 。

cholesky(upper=False) → Tensor

torch.cholesky()

cholesky_inverse(upper=False) → Tensor

torch.cholesky_inverse()

cholesky_solve(input2, upper=False) → Tensor

torch.cholesky_solve()

chunk(chunks, dim=0) → List of Tensors

torch.chunk()

clamp(min, max) → Tensor

torch.clamp()

clamp_(min, max) → Tensor

就地版本的 clamp()

clone() → Tensor

返回self張量的副本。該副本的大小和數(shù)據(jù)類型與self相同。

注意

與 copy_()不同，此功能記錄在計算圖中。傳播到克隆張量的漸變將傳播到原始張量。

contiguous() → Tensor

返回包含與self張量相同的數(shù)據(jù)的連續(xù)張量。如果self張量是連續(xù)的，則此函數(shù)返回self張量。

copy_(src, non_blocking=False) → Tensor

將元素從src復(fù)制到self張量并返回self。

src張量必須與self張量一起廣播。它可以具有不同的數(shù)據(jù)類型，也可以位于不同的設(shè)備上。

參數(shù)

src (tensor)–要從中復(fù)制的源張量
non_blocking (bool )–如果True并且此副本位于 CPU 和 GPU 之間，則該副本可能相對于主機異步發(fā)生。在其他情況下，此參數(shù)無效。

conj() → Tensor

torch.conj()

cos() → Tensor

torch.cos()

cos_() → Tensor

就地版本的 cos()

cosh() → Tensor

torch.cosh()

cosh_() → Tensor

就地版本的 cosh()

cpu() → Tensor

返回此對象在 CPU 內(nèi)存中的副本。

如果該對象已經(jīng)在 CPU 內(nèi)存中并且在正確的設(shè)備上，則不執(zhí)行任何復(fù)制操作并返回原始對象。

cross(other, dim=-1) → Tensor

torch.cross()

cuda(device=None, non_blocking=False) → Tensor

返回此對象在 CUDA 內(nèi)存中的副本。

如果此對象已經(jīng)在 CUDA 內(nèi)存中并且在正確的設(shè)備上，則不執(zhí)行任何復(fù)制，并返回原始對象。

參數(shù)

device (torch.device) – 目標(biāo) GPU 設(shè)備。默認(rèn)為當(dāng)前 CUDA 設(shè)備。
non_blocking (bool ) – 如果True并且源位于固定內(nèi)存中，則副本將相對于主機是異步的。否則，該參數(shù)無效。默認(rèn)值：False。

cumprod(dim, dtype=None) → Tensor

參見 torch.cumprod()

cumsum(dim, dtype=None) → Tensor

參見 torch.cumsum()

data_ptr() → int

返回self張量的第一個元素的地址。

dequantize() → Tensor

給定量化的張量，對其進(jìn)行反量化，然后返回反量化后的浮點張量。

det() → Tensor

參見 torch.det()

dense_dim() → int

如果self是稀疏的 COO 張量(即torch.sparse_coo布局），則返回密集尺寸的數(shù)量。否則，將引發(fā)錯誤

detach()

返回與當(dāng)前圖形分離的新 Tensor。

結(jié)果將永遠(yuǎn)不需要梯度。

注意

返回的 Tensor 與原始 Tensor 共享相同的存儲。可以看到對它們中的任何一個的就地修改，并且可能觸發(fā)正確性檢查中的錯誤。重要說明：以前，就地大小/步幅/存儲更改(例如 resize/_resize_as/*set/_transpose) 返回的張量也會更新原始張量。現(xiàn)在，這些就地更改將不再更新原始張量，而將觸發(fā)錯誤。對于稀疏張量：原位索引 / 值更改(例如 *zero\_/_copy/_add)將不會再更新原始張量，而是觸發(fā)錯誤。

detach_()

從創(chuàng)建它的圖形中分離張量，使其成為一片葉子。視圖不能就地分離。

diag(diagonal=0) → Tensor

torch.diag()

diag_embed(offset=0, dim1=-2, dim2=-1) → Tensor

torch.diag_embed()

diagflat(offset=0) → Tensor

torch.diagflat()

diagonal(offset=0, dim1=0, dim2=1) → Tensor

torch.diagonal()

fill_diagonal_(fill_value, wrap=False) → Tensor

填充具有至少 2 維的張量的主對角線。當(dāng)> 2 變暗時，所有輸入尺寸必須相等。此函數(shù)就地修改輸入張量，并返回輸入張量。

參數(shù)

fill_value (標(biāo)量）– 填充值
wrap (bool ) – 對角線“包裹”在高列的 N 列之后。

例:

>>> a = torch.zeros(3, 3)
>>> a.fill_diagonal_(5)
tensor([[5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.]])
>>> b = torch.zeros(7, 3)
>>> b.fill_diagonal_(5)
tensor([[5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])
>>> c = torch.zeros(7, 3)
>>> c.fill_diagonal_(5, wrap=True)
tensor([[5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.],
        [0., 0., 0.],
        [5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.]])

digamma() → Tensor

torch.digamma()

digamma_() → Tensor

就地版本的 digamma()

dim() → int

返回self張量的維數(shù)。

dist(other, p=2) → Tensor

torch.dist()

div(value) → Tensor

torch.div()

div_(value) → Tensor

就地版本的 div()

dot(tensor2) → Tensor

torch.dot()

double() → Tensor

self.double()等效于self.to(torch.float64)。 to() 。

eig(eigenvectors=False) -> (Tensor, Tensor)

torch.eig()

element_size() → int

返回單個元素的大小(以字節(jié)為單位）。

例:

>>> torch.tensor([]).element_size()
4
>>> torch.tensor([], dtype=torch.uint8).element_size()
1

eq(other) → Tensor

torch.eq()

eq_(other) → Tensor

就地版本的 eq()

equal(other) → bool

torch.equal()

erf() → Tensor

torch.erf()

erf_() → Tensor

就地版本的 erf()

erfc() → Tensor

torch.erfc()

erfc_() → Tensor

就地版本的 erfc()

erfinv() → Tensor

torch.erfinv()

erfinv_() → Tensor

就地版本的 erfinv()

exp() → Tensor

torch.exp()

exp_() → Tensor

就地版本的 exp()

expm1() → Tensor

torch.expm1()

expm1_() → Tensor

就地版本的 expm1()

expand(*sizes) → Tensor

返回self張量的新視圖，其中單例尺寸擴展為更大的尺寸。

將-1 傳遞為尺寸的大小表示不更改該尺寸的大小。

Tensor 也可以擴展到更大的尺寸，并且新尺寸將附加在前面。對于新尺寸，尺寸不能設(shè)置為-1。

擴展張量不會分配新的內(nèi)存，而只會在現(xiàn)有張量上創(chuàng)建一個新視圖，其中通過將stride設(shè)置為 0，將尺寸為 1 的維擴展為更大的尺寸。尺寸為 1 的任何維都可以擴展為不分配新內(nèi)存的任意值。

參數(shù)

大小(torch大小或 python：int ...* )–所需的擴展大小

警告

擴展張量的一個以上元素可以引用單個存儲位置。結(jié)果，就地操作(尤其是矢量化的操作）可能會導(dǎo)致錯誤的行為。如果需要寫張量，請先克隆它們。

例:

>>> x = torch.tensor([[1], [2], [3]])
>>> x.size()
torch.Size([3, 1])
>>> x.expand(3, 4)
tensor([[ 1,  1,  1,  1],
        [ 2,  2,  2,  2],
        [ 3,  3,  3,  3]])
>>> x.expand(-1, 4)   # -1 means not changing the size of that dimension
tensor([[ 1,  1,  1,  1],
        [ 2,  2,  2,  2],
        [ 3,  3,  3,  3]])

expand_as(other) → Tensor

將該張量擴展為與other相同的大小。 self.expand_as(other)等效于self.expand(other.size())。

有關(guān)expand的更多信息， expand() 。

參數(shù)

其他 (torch.Tensor)–結(jié)果張量的大小與other相同。

exponential_(lambd=1, *, generator=None) → Tensor

用從指數(shù)分布中繪制的元素填充self張量：

f(x)=\lambda e^{-\lambda x}f(x)=*λe?λx*

fft(signal_ndim, normalized=False) → Tensor

torch.fft()

fill_(value) → Tensor

用指定值填充self張量。

flatten(input, start_dim=0, end_dim=-1) → Tensor

torch.flatten()

flip(dims) → Tensor

torch.flip()

float() → Tensor

self.float()等效于self.to(torch.float32)。 to() 。

floor() → Tensor

torch.floor()

floor_() → Tensor

就地版本的 floor()

fmod(divisor) → Tensor

torch.fmod()

fmod_(divisor) → Tensor

就地版本的 fmod()

frac() → Tensor

torch.frac()

frac_() → Tensor

就地版本的 frac()

gather(dim, index) → Tensor

torch.gather()

ge(other) → Tensor

torch.ge()

ge_(other) → Tensor

就地版本的 ge()

geometric_(p, *, generator=None) → Tensor

用從幾何分布中繪制的元素填充self張量：

f(X=k)=p^{k-1}(1-p)f(X=k)=*p*k?1(1?p)

geqrf() -> (Tensor, Tensor)

torch.geqrf()

ger(vec2) → Tensor

torch.ger()

get_device() -> Device ordinal (Integer)

對于 CUDA 張量，此函數(shù)返回張量所在的 GPU 的設(shè)備序號。對于 CPU 張量，將引發(fā)錯誤。

例：

>>> x = torch.randn(3, 4, 5, device='cuda:0')
>>> x.get_device()
0
>>> x.cpu().get_device()  # RuntimeError: get_device is not implemented for type torch.FloatTensor

gt(other) → Tensor

torch.gt()

gt_(other) → Tensor

就地版本的 gt()

half() → Tensor

self.half()等效于self.to(torch.float16)。 to() 。

hardshrink(lambd=0.5) → Tensor

torch.nn.functional.hardshrink()

histc(bins=100, min=0, max=0) → Tensor

torch.histc()

ifft(signal_ndim, normalized=False) → Tensor

torch.ifft()

imag() → Tensor

torch.imag()

index_add_(dim, index, tensor) → Tensor

通過按index中給定的順序添加索引，將 tensor 的元素累積到self張量中。例如，如果dim == 0和index[i] == j，則將的第i行tensor 添加到self的第j行。

tensor 的 dim 尺寸必須與index的長度(必須為矢量）的尺寸相同，并且所有其他尺寸必須與self ]，否則將引發(fā)錯誤。

注意

使用 CUDA 后端時，此操作可能會導(dǎo)致不確定的行為，不容易關(guān)閉。有關(guān)背景，請參見重現(xiàn)性的注釋。

參數(shù)

dim (python：int )–索引所沿的維度
索引 (LongTensor )– tensor 的索引
張量 (tensor)–張量包含要添加的值

例：

>>> x = torch.ones(5, 3)
>>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
>>> index = torch.tensor([0, 4, 2])
>>> x.index_add_(0, index, t)
tensor([[  2.,   3.,   4.],
        [  1.,   1.,   1.],
        [  8.,   9.,  10.],
        [  1.,   1.,   1.],
        [  5.,   6.,   7.]])

index_add(dim, index, tensor) → Tensor

torch.Tensor.index_add_() 的替代版本

index_copy_(dim, index, tensor) → Tensor

通過按index中給定的順序選擇索引，將 tensor 的元素復(fù)制到self張量中。例如，如果dim == 0和index[i] == j，則將 []()tensor 的第i行復(fù)制到self的第j行。

The dimth dimension of tensor must have the same size as the length of index (which must be a vector), and all other dimensions must match self, or an error will be raised.

參數(shù)

dim (python:int) – dimension along which to index
index (LongTensor) – indices of tensor to select from
張量 (tensor)–張量包含要復(fù)制的值

例：

>>> x = torch.zeros(5, 3)
>>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
>>> index = torch.tensor([0, 4, 2])
>>> x.index_copy_(0, index, t)
tensor([[ 1.,  2.,  3.],
        [ 0.,  0.,  0.],
        [ 7.,  8.,  9.],
        [ 0.,  0.,  0.],
        [ 4.,  5.,  6.]])

index_copy(dim, index, tensor) → Tensor

torch.Tensor.index_copy_() 的替代版本

index_fill_(dim, index, val) → Tensor

通過按index中給定的順序選擇索引，用值val填充self張量的元素。

參數(shù)

dim (python:int) – dimension along which to index
索引 (LongTensor )–填寫的self張量索引
val (python：float )–要填充的值

例：:
Copy
>>> x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
>>> index = torch.tensor([0, 2])
>>> x.index_fill_(1, index, -1)
tensor([[-1.,  2., -1.],
        [-1.,  5., -1.],
        [-1.,  8., -1.]])

index_fill(dim, index, value) → Tensor

torch.Tensor.index_fill_() 的替代版本

index_put_(indices, value, accumulate=False) → Tensor

使用在 indices 中指定的索引(張量的元組）將張量value的值放入張量self。表達(dá)式tensor.index_put_(indices, value)等效于tensor[indices] = value。返回self。

如果accumulate為True，則將 tensor 中的元素添加到self中。如果 accumulate 為False，則在索引包含重復(fù)元素的情況下行為未定義。

參數(shù)

索引(LongTensor 的元組）–用于索引<cite>自身</cite>的張量。
值 (tensor)–與<cite>自身</cite>相同類型的張量。
累積 (bool )–是否累積

index_put(indices, value, accumulate=False) → Tensor

index_put_() 的替代版本

index_select(dim, index) → Tensor

torch.index_select()

indices() → Tensor

如果self是稀疏的 COO 張量(即torch.sparse_coo布局），則返回包含的索引張量的視圖。否則，將引發(fā)錯誤。

注意

只能在合并的稀疏張量上調(diào)用此方法。有關(guān)詳細(xì)信息，請參見Tensor.coalesce()。

int() → Tensor

self.int()等效于self.to(torch.int32)。 to() 。

int_repr() → Tensor

給定量化的 Tensor，self.int_repr()返回以 uint8_t 作為數(shù)據(jù)類型的 CPU Tensor，該數(shù)據(jù)類型存儲給定 Tensor 的基礎(chǔ) uint8_t 值。

inverse() → Tensor

torch.inverse()

irfft(signal_ndim, normalized=False, onesided=True, signal_sizes=None) → Tensor

torch.irfft()

is_contiguous() → bool

如果self張量在內(nèi)存中以 C 順序連續(xù)，則返回 True。

is_floating_point() → bool

如果self的數(shù)據(jù)類型是浮點數(shù)據(jù)類型，則返回 True。

is_leaf

按照慣例，所有具有 requires_grad 即False的張量將是葉張量。

對于具有 requires_grad (即True）的張量，如果它們是由用戶創(chuàng)建的，則它們將是葉張量。這意味著它們不是運算的結(jié)果，因此grad_fn為“無”。

在調(diào)用 backward() 期間，僅葉子張量會填充其 grad 。要為非葉張量填充 grad ，可以使用 retain_grad() 。

例：

>>> a = torch.rand(10, requires_grad=True)
>>> a.is_leaf
True
>>> b = torch.rand(10, requires_grad=True).cuda()
>>> b.is_leaf
False
## b was created by the operation that cast a cpu Tensor into a cuda Tensor
>>> c = torch.rand(10, requires_grad=True) + 2
>>> c.is_leaf
False
## c was created by the addition operation
>>> d = torch.rand(10).cuda()
>>> d.is_leaf
True
## d does not require gradients and so has no operation creating it (that is tracked by the autograd engine)
>>> e = torch.rand(10).cuda().requires_grad_()
>>> e.is_leaf
True
## e requires gradients and has no operations creating it
>>> f = torch.rand(10, requires_grad=True, device="cuda")
>>> f.is_leaf
True
## f requires grad, has no operation creating it

is_pinned()

如果該張量駐留在固定的內(nèi)存中，則返回 true。

is_set_to(tensor) → bool

如果此對象引用與 Torch C API 中相同的THTensor對象作為給定張量，則返回 True。

is_shared()

檢查張量是否在共享內(nèi)存中。

CUDA 張量始終為True。

is_signed() → bool

如果self的數(shù)據(jù)類型是帶符號的數(shù)據(jù)類型，則返回 True。

is_sparse

item() → number

返回此張量的值作為標(biāo)準(zhǔn) Python 數(shù)。這僅適用于具有一個元素的張量。對于其他情況， tolist() 。

此操作不可區(qū)分。

例：

>>> x = torch.tensor([1.0])
>>> x.item()
1.0

kthvalue(k, dim=None, keepdim=False) -> (Tensor, LongTensor)

torch.kthvalue()

le(other) → Tensor

torch.le()

le_(other) → Tensor

就地版本的 le()

lerp(end, weight) → Tensor

torch.lerp()

lerp_(end, weight) → Tensor

就地版本的 lerp()

lgamma() → Tensor

torch.lgamma()

lgamma_() → Tensor

就地版本的 lgamma()

log() → Tensor

torch.log()

log_() → Tensor

就地版本的 log()

logdet() → Tensor

torch.logdet()

log10() → Tensor

torch.log10()

log10_() → Tensor

就地版本的 log10()

log1p() → Tensor

torch.log1p()

log1p_() → Tensor

就地版本的 log1p()

log2() → Tensor

torch.log2()

log2_() → Tensor

就地版本的 log2()

log_normal_(mean=1, std=2, *, generator=None)

用對數(shù)正態(tài)分布中由給定平均值和標(biāo)準(zhǔn)偏差參數(shù)化的數(shù)字樣本填充self張量。請注意， mean 和 std 是基礎(chǔ)正態(tài)分布的均值和標(biāo)準(zhǔn)偏差，而不是返回的正態(tài)分布：

f(x)=\frac {1}{x\sigma \sqrt {2\pi}}e^{-\frac {(lnx - \mu)^2}{2\sigma^2}}f(x)=*xσ√2π1e?2σ2(ln*x?μ)2

logsumexp(dim, keepdim=False) → Tensor

torch.logsumexp()

logical_not() → Tensor

torch.logical_not()

logical_not_() → Tensor

就地版本的 logical_not()

logical_xor() → Tensor

torch.logical_xor()

logical_xor_() → Tensor

就地版本的 logical_xor()

long() → Tensor

self.long()等效于self.to(torch.int64)。 to() 。

lstsq(A) -> (Tensor, Tensor)

torch.lstsq()

lt(other) → Tensor

torch.lt()

lt_(other) → Tensor

就地版本的 lt()

lu(pivot=True, get_infos=False)

torch.lu()

lu_solve(LU_data, LU_pivots) → Tensor

torch.lu_solve()

map_(tensor, callable)

對self張量中的每個元素和給定的 tensor 應(yīng)用callable，并將結(jié)果存儲在self張量中。 self張量和給定的 tensor 必須是可廣播的。

callable應(yīng)具有簽名：

def callable(a, b) -> number

masked_scatter_(mask, source)

在mask為 True 的位置將元素從source復(fù)制到self張量。 mask的形狀必須是可廣播的，并具有基礎(chǔ)張量的形狀。 source中的元素數(shù)量至少應(yīng)與mask中的元素數(shù)量一樣多。

參數(shù)

掩碼 (BoolTensor)–布爾掩碼
源 (tensor)–要從中復(fù)制的張量

注意

mask在self張量上運行，而不是在給定的source張量上運行。

masked_scatter(mask, tensor) → Tensor

torch.Tensor.masked_scatter_() 的替代版本

masked_fill_(mask, value)

用value填充self張量的元素，其中mask為 True。 mask的形狀必須是可廣播的，并具有基礎(chǔ)張量的形狀。

參數(shù)

mask (BoolTensor) – the boolean mask
值 (python：float )–要填寫的值

masked_fill(mask, value) → Tensor

torch.Tensor.masked_fill_() 的替代版本

masked_select(mask) → Tensor

torch.masked_select()

matmul(tensor2) → Tensor

torch.matmul()

matrix_power(n) → Tensor

torch.matrix_power()

max(dim=None, keepdim=False) -> Tensor or (Tensor, Tensor)

torch.max()

mean(dim=None, keepdim=False) -> Tensor or (Tensor, Tensor)

torch.mean()

median(dim=None, keepdim=False) -> (Tensor, LongTensor)

torch.median()

min(dim=None, keepdim=False) -> Tensor or (Tensor, Tensor)

torch.min()

mm(mat2) → Tensor

torch.mm()

mode(dim=None, keepdim=False) -> (Tensor, LongTensor)

torch.mode()

mul(value) → Tensor

torch.mul()

mul_(value)

就地版本的 mul()

multinomial(num_samples, replacement=False, *, generator=None) → Tensor

torch.multinomial()

mv(vec) → Tensor

torch.mv()

mvlgamma(p) → Tensor

torch.mvlgamma()

mvlgamma_(p) → Tensor

就地版本的 mvlgamma()

narrow(dimension, start, length) → Tensor

torch.narrow()

例：

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

narrow_copy(dimension, start, length) → Tensor

與 Tensor.narrow() 相同，只是返回副本而不是共享存儲。這主要用于稀疏張量，它們沒有共享存儲的窄方法。用dimemsion > self.sparse_dim()調(diào)用narrow_copy將返回縮小了相關(guān)密集尺寸的副本，并相應(yīng)地更新了`self.shape``。

ndimension() → int

Alias for dim()

ne(other) → Tensor

torch.ne()

ne_(other) → Tensor

就地版本的 ne()

neg() → Tensor

torch.neg()

neg_() → Tensor

就地版本的 neg()

nelement() → int

numel() 的別名

nonzero() → LongTensor

torch.nonzero()

norm(p='fro', dim=None, keepdim=False, dtype=None)

torch.norm()

normal_(mean=0, std=1, *, generator=None) → Tensor

用由 mean 和 []()std 參數(shù)化的正態(tài)分布的元素樣本填充self張量。

numel() → int

torch.numel()

numpy() → numpy.ndarray

以 NumPy ndarray的形式返回self張量。該張量和返回的ndarray共享相同的基礎(chǔ)存儲。對self張量的更改將反映在ndarray中，反之亦然。

orgqr(input2) → Tensor

torch.orgqr()

ormqr(input2, input3, left=True, transpose=False) → Tensor

torch.ormqr()

permute(*dims) → Tensor

置換此張量的尺寸。

參數(shù)

dims (python：int ...* ) – 所需的維度順序

例:

>>> x = torch.randn(2, 3, 5)
>>> x.size()
torch.Size([2, 3, 5])
>>> x.permute(2, 0, 1).size()
torch.Size([5, 2, 3])

pin_memory() → Tensor

將張量復(fù)制到固定的內(nèi)存(如果尚未固定）。

pinverse() → Tensor

torch.pinverse()

polygamma(n) → Tensor

torch.polygamma()

polygamma_(n) → Tensor

就地版本的 polygamma()

pow(exponent) → Tensor

torch.pow()

pow_(exponent) → Tensor

就地版本的 pow()

prod(dim=None, keepdim=False, dtype=None) → Tensor

torch.prod()

put_(indices, tensor, accumulate=False) → Tensor

將 tensor 中的元素復(fù)制到索引指定的位置。為了建立索引，將self張量視為一維張量。

If accumulate is True, the elements in tensor are added to self. If accumulate is False, the behavior is undefined if indices contain duplicate elements.[]()

參數(shù)

索引 (LongTensor )–自身索引
張量 (tensor)–張量包含要復(fù)制的值
accumulate (bool) – whether to accumulate into self

例：

>>> src = torch.tensor([[4, 3, 5],
                        [6, 7, 8]])
>>> src.put_(torch.tensor([1, 3]), torch.tensor([9, 10]))
tensor([[  4,   9,   5],
        [ 10,   7,   8]])

qr(some=True) -> (Tensor, Tensor)

torch.qr()

qscheme() → torch.qscheme

返回給定 QTensor 的量化方案。

q_scale() → float

給定一個通過線性(仿射）量化量化的張量，返回基礎(chǔ)量化器(）的比例尺。

q_zero_point() → int

給定一個通過線性(仿射）量化量化的張量，返回基礎(chǔ)量化器(）的 zero_point。

q_per_channel_scales() → Tensor

給定通過線性(仿射）每通道量化進(jìn)行量化的張量，返回基礎(chǔ)量化器的比例的張量。它具有與張量的相應(yīng)尺寸(來自 q_per_channel_axis）匹配的元素數(shù)量。

q_per_channel_zero_points() → Tensor

給定一個通過線性(仿射）每通道量化量化的張量，返回基礎(chǔ)量化器的 zero_points 張量。它具有與張量的相應(yīng)尺寸(來自 q_per_channel_axis）匹配的元素數(shù)量。

q_per_channel_axis() → int

給定通過線性(仿射）每通道量化量化的張量，返回在其上應(yīng)用每通道量化的尺寸索引。

random_(from=0, to=None, *, generator=None) → Tensor

用從[from, to - 1]上的離散均勻分布采樣的數(shù)字填充self張量。如果未指定，則這些值通常僅受self張量的數(shù)據(jù)類型限制。但是，對于浮點類型，如果未指定，范圍將為[0, 2^mantissa]以確保每個值都是可表示的。例如， <cite>torch.tensor(1，dtype = torch.double）.random_(）</cite>在[0, 2^53]中將是統(tǒng)一的。

reciprocal() → Tensor

參見 torch.reciprocal()

reciprocal_() → Tensor

就地版本的 reciprocal()

record_stream(stream)

確保在stream上排隊的所有當(dāng)前工作完成之前，張量存儲器不會被其他張量重用。

注意

緩存分配器僅知道分配張量的流。由于有了這種認(rèn)識，它已經(jīng)可以僅在一個流上正確管理張量的生命周期。但是，如果在與原始流不同的流上使用張量，則分配器可能會意外地重用內(nèi)存。調(diào)用此方法可讓分配器知道哪些流使用了張量。

register_hook(hook)

注冊一個倒鉤。

每當(dāng)計算相對于張量的梯度時，都會調(diào)用該掛鉤。掛鉤應(yīng)具有以下簽名：

hook(grad) -> Tensor or None

掛鉤不應(yīng)修改其自變量，但可以選擇返回一個新的漸變，該漸變將代替 grad 使用。

此函數(shù)返回帶有方法handle.remove()的句柄，該方法可將鉤子從模塊中移除。

例：

>>> v = torch.tensor([0., 0., 0.], requires_grad=True)
>>> h = v.register_hook(lambda grad: grad * 2)  # double the gradient
>>> v.backward(torch.tensor([1., 2., 3.]))
>>> v.grad


 2
 4
 6
[torch.FloatTensor of size (3,)]


>>> h.remove()  # removes the hook

remainder(divisor) → Tensor

參見 torch.remainder()

remainder_(divisor) → Tensor

就地版本的 remainder()

real() → Tensor

torch.real()

renorm(p, dim, maxnorm) → Tensor

torch.renorm()

renorm_(p, dim, maxnorm) → Tensor

就地版本的 renorm()

repeat(*sizes) → Tensor

沿指定尺寸重復(fù)此張量。

與 expand() 不同，此功能復(fù)制張量的數(shù)據(jù)。

警告

torch.repeat()的行為與 numpy.repeat 不同，但更類似于 numpy.tile 。對于類似于 <cite>numpy.repeat</cite> 的運算符， torch.repeat_interleave() 。

參數(shù)

大小(torch大小 或 python：int ... )–在每個維度上重復(fù)此張量的次數(shù)

例：

>>> x = torch.tensor([1, 2, 3])
>>> x.repeat(4, 2)
tensor([[ 1,  2,  3,  1,  2,  3],
        [ 1,  2,  3,  1,  2,  3],
        [ 1,  2,  3,  1,  2,  3],
        [ 1,  2,  3,  1,  2,  3]])
>>> x.repeat(4, 2, 1).size()
torch.Size([4, 2, 3])

repeat_interleave(repeats, dim=None) → Tensor

torch.repeat_interleave() 。

requires_grad

如果需要為此張量計算梯度，則為True，否則為False。

注意

需要為張量計算梯度的事實并不意味著將填充 grad 屬性，有關(guān)更多詳細(xì)信息， is_leaf 。

requires_grad_(requires_grad=True) → Tensor

更改 autograd 是否應(yīng)記錄該張量上的操作：適當(dāng)?shù)卦O(shè)置此張量的 requires_grad 屬性。返回此張量。

requires_grad_() 的主要用例是告訴 autograd 在 Tensor tensor上開始記錄操作。如果tensor具有requires_grad=False(因為它是通過 DataLoader 獲得的，或者需要進(jìn)行預(yù)處理或初始化），則tensor.requires_grad_()將其設(shè)置為使 autograd 將開始在tensor上記錄操作。

參數(shù)

require_grad (bool )–如果 autograd 應(yīng)該在該張量上記錄操作。默認(rèn)值：True。

例：

>>> # Let's say we want to preprocess some saved weights and use
>>> # the result as new weights.
>>> saved_weights = [0.1, 0.2, 0.3, 0.25]
>>> loaded_weights = torch.tensor(saved_weights)
>>> weights = preprocess(loaded_weights)  # some function
>>> weights
tensor([-0.5503,  0.4926, -2.1158, -0.8303])


>>> # Now, start to record operations done to weights
>>> weights.requires_grad_()
>>> out = weights.pow(2).sum()
>>> out.backward()
>>> weights.grad
tensor([-1.1007,  0.9853, -4.2316, -1.6606])

reshape(*shape) → Tensor

返回具有與self相同的數(shù)據(jù)和元素數(shù)量但具有指定形狀的張量。如果shape與當(dāng)前形狀兼容，則此方法返回一個視圖。當(dāng)可以返回視圖時， torch.Tensor.view() 。

torch.reshape()

參數(shù)

形狀 (python：ints 的元組 或 python：int ... )–所需的形狀

reshape_as(other) → Tensor

以與other相同的形狀返回此張量。 self.reshape_as(other)等效于self.reshape(other.sizes())。如果other.sizes()與當(dāng)前形狀兼容，則此方法返回視圖。何時可以返回視圖， torch.Tensor.view() 。

有關(guān)reshape的更多信息。

參數(shù)

其他 (torch.Tensor)–結(jié)果張量具有與other相同的形狀。

resize_(*sizes) → Tensor

將self張量調(diào)整為指定大小。如果元素數(shù)量大于當(dāng)前存儲大小，那么將調(diào)整基礎(chǔ)存儲的大小以適合新的元素數(shù)量。如果元素數(shù)較小，則基礎(chǔ)存儲不會更改。現(xiàn)有元素將保留，但任何新內(nèi)存均未初始化。

警告

這是一種底層方法。將存儲重新解釋為 C 連續(xù)的，而忽略當(dāng)前步幅(除非目標(biāo)大小等于當(dāng)前大小，在這種情況下，張量保持不變）。對于大多數(shù)目的，您將改為使用 view() (檢查連續(xù)性），或使用 reshape() (如果需要，可復(fù)制數(shù)據(jù)）。要使用自定義步幅就地更改大小。

參數(shù)

大小(torch大小 或 python：int ... )–所需大小

例：

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

resize_as_(tensor) → Tensor

將self張量調(diào)整為與指定的 tensor 相同的大小。這等效于self.resize_(tensor.size())。

retain_grad()

為非葉張量啟用.grad 屬性。

rfft(signal_ndim, normalized=False, onesided=True) → Tensor

torch.rfft()

roll(shifts, dims) → Tensor

torch.roll()

rot90(k, dims) → Tensor

torch.rot90()

round() → Tensor

torch.round()

round_() → Tensor

就地版本的 round()

rsqrt() → Tensor

torch.rsqrt()

rsqrt_() → Tensor

就地版本的 rsqrt()

scatter(dim, index, source) → Tensor

torch.Tensor.scatter_() 的替代版本

scatter_(dim, index, src) → Tensor

將張量src中的所有值寫入index張量中指定的索引處的self中。對于src中的每個值，其輸出索引由dimension != dim的src中的索引以及dimension = dim的index中的相應(yīng)值指定。

對于 3-D 張量，self更新為：

self[index[i][j][k]][j][k] = src[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] = src[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] = src[i][j][k]  # if dim == 2

這是 gather() 中描述的方式的相反操作。

self，index和src(如果是張量）應(yīng)具有相同數(shù)量的尺寸。還要求對于所有尺寸d均為index.size(d) <= src.size(d)，并且對于所有尺寸d != dim均要求index.size(d) <= self.size(d)。

此外，對于 gather() ，index的值必須介于0和self.size(dim) - 1之間，且沿指定尺寸 dim 必須是唯一的。

參數(shù)

dim (python：int ) – 沿其索引的軸
index (LongTensor ) – 要散布的元素的索引可以為空或 src 的大小相同。如果為空，則操作返回標(biāo)識
src (tensor) – 要散布的源元素，如果未指定值
value (python：float ) – 要分散的源元素，如果未指定src

例：

>>> x = torch.rand(2, 5)
>>> x
tensor([[ 0.3992,  0.2908,  0.9044,  0.4850,  0.6004],
        [ 0.5735,  0.9006,  0.6797,  0.4152,  0.1732]])
>>> torch.zeros(3, 5).scatter_(0, torch.tensor([[0, 1, 2, 0, 0], [2, 0, 0, 1, 2]]), x)
tensor([[ 0.3992,  0.9006,  0.6797,  0.4850,  0.6004],
        [ 0.0000,  0.2908,  0.0000,  0.4152,  0.0000],
        [ 0.5735,  0.0000,  0.9044,  0.0000,  0.1732]])


>>> z = torch.zeros(2, 4).scatter_(1, torch.tensor([[2], [3]]), 1.23)
>>> z
tensor([[ 0.0000,  0.0000,  1.2300,  0.0000],
        [ 0.0000,  0.0000,  0.0000,  1.2300]])

scatter_add_(dim, index, other) → Tensor

將張量other中的所有值添加到index張量中指定的索引處的self中，其方式與 scatter_() 相似。對于other中的每個值，將其添加到self中的索引，該索引由dimension != dim中的other中的索引和dimension = dim中的index中的對應(yīng)值指定。

For a 3-D tensor, self is updated as:

self[index[i][j][k]][j][k] += other[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] += other[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] += other[i][j][k]  # if dim == 2

self，index和other應(yīng)具有相同的尺寸數(shù)。還要求對于所有尺寸d均為index.size(d) <= other.size(d)，并且對于所有尺寸d != dim均要求index.size(d) <= self.size(d)。

注意

When using the CUDA backend, this operation may induce nondeterministic behaviour that is not easily switched off. Please see the 注意s on Reproducibility for background.

參數(shù)

dim (python:int) – the axis along which to index
index (LongTensor ) – 分散和添加元素的索引，可以為空或 src 大小相同。為空時，該操作將返回標(biāo)識。
other (tensor) – 分散和添加的源元素

例：

>>> x = torch.rand(2, 5)
>>> x
tensor([[0.7404, 0.0427, 0.6480, 0.3806, 0.8328],
        [0.7953, 0.2009, 0.9154, 0.6782, 0.9620]])
>>> torch.ones(3, 5).scatter_add_(0, torch.tensor([[0, 1, 2, 0, 0], [2, 0, 0, 1, 2]]), x)
tensor([[1.7404, 1.2009, 1.9154, 1.3806, 1.8328],
        [1.0000, 1.0427, 1.0000, 1.6782, 1.0000],
        [1.7953, 1.0000, 1.6480, 1.0000, 1.9620]])

scatter_add(dim, index, source) → Tensor

torch.Tensor.scatter_add_() 的替代版本

select(dim, index) → Tensor

沿選定維度在給定索引處切片self張量。該函數(shù)返回一個張量，其中給定尺寸被移除。

參數(shù)

dim (python：int )–切片的尺寸
索引 (python：int )–要選擇的索引

注意

select() 相當(dāng)于切片。例如，tensor.select(0, index)等效于tensor[index]，tensor.select(2, index)等效于tensor[:,:,index]。

set_(source=None, storage_offset=0, size=None, stride=None) → Tensor

設(shè)置基礎(chǔ)存儲空間，大小和跨度。如果source是張量，則self張量將與source共享相同的存儲空間并具有相同的大小和跨度。一個張量中元素的變化將反映在另一個張量中。

如果source是Storage，則該方法設(shè)置基礎(chǔ)存儲，偏移，大小和跨度。

參數(shù)

源 (tensor 或 存儲器）–使用的張量或存儲器
storage_offset (python：int ，可選）–存儲中的偏移量
大小(torch大小 ，可選）–所需大小。默認(rèn)為源大小。
步幅(元組 ， 可選）–所需的步幅。默認(rèn)為 C 連續(xù)跨步。

share_memory_()

將基礎(chǔ)存儲移動到共享內(nèi)存。

如果基礎(chǔ)存儲已經(jīng)在共享內(nèi)存中并且用于 CUDA 張量，則此操作不可操作。共享內(nèi)存中的張量無法調(diào)整大小。

short() → Tensor

self.short()等效于self.to(torch.int16)。

sigmoid() → Tensor

torch.sigmoid()

sigmoid_() → Tensor

sigmoid()

sign() → Tensor

torch.sign()

sign_() → Tensor

sign()

sin() → Tensor

torch.sin()

sin_() → Tensor

sin()

sinh() → Tensor

torch.sinh()

sinh_() → Tensor

sinh()

size() → torch.Size

返回self張量的大小。返回的值是tuple的子類。

例：

>>> torch.empty(3, 4, 5).size()
torch.Size([3, 4, 5])

slogdet() -> (Tensor, Tensor)

torch.slogdet()

solve(A) → Tensor, Tensor

torch.solve()

sort(dim=-1, descending=False) -> (Tensor, LongTensor)

torch.sort()

split(split_size, dim=0)

torch.split()

sparse_mask(input, mask) → Tensor

返回一個新的 SparseTensor，其 Tensor input中的值被mask的索引過濾，并且值被忽略。 input和mask必須具有相同的形狀。

參數(shù)

input (tensor)–輸入張量
mask (SparseTensor )–我們根據(jù)其索引過濾input的 SparseTensor

例：

>>> nnz = 5
>>> dims = [5, 5, 2, 2]
>>> I = torch.cat([torch.randint(0, dims[0], size=(nnz,)),
                   torch.randint(0, dims[1], size=(nnz,))], 0).reshape(2, nnz)
>>> V = torch.randn(nnz, dims[2], dims[3])
>>> size = torch.Size(dims)
>>> S = torch.sparse_coo_tensor(I, V, size).coalesce()
>>> D = torch.randn(dims)
>>> D.sparse_mask(S)
tensor(indices=tensor([[0, 0, 0, 2],
                       [0, 1, 4, 3]]),
       values=tensor([[[ 1.6550,  0.2397],
                       [-0.1611, -0.0779]],


                      [[ 0.2326, -1.0558],
                       [ 1.4711,  1.9678]],


                      [[-0.5138, -0.0411],
                       [ 1.9417,  0.5158]],


                      [[ 0.0793,  0.0036],
                       [-0.2569, -0.1055]]]),
       size=(5, 5, 2, 2), nnz=4, layout=torch.sparse_coo)

sparse_dim() → int

如果self是稀疏的 COO 張量(即torch.sparse_coo布局），則返回稀疏維度的數(shù)量。否則，將引發(fā)錯誤。

Tensor.dense_dim() 。

sqrt() → Tensor

torch.sqrt()

sqrt_() → Tensor

sqrt()

squeeze(dim=None) → Tensor

torch.squeeze()

squeeze_(dim=None) → Tensor

squeeze()

std(dim=None, unbiased=True, keepdim=False) → Tensor

torch.std()

stft(n_fft, hop_length=None, win_length=None, window=None, center=True, pad_mode='reflect', normalized=False, onesided=True)

torch.stft()

警告

此功能在版本 0.4.1 更改了簽名。使用前一個簽名進(jìn)行調(diào)用可能會導(dǎo)致錯誤或返回錯誤的結(jié)果。

storage() → torch.Storage

返回基礎(chǔ)存儲。

storage_offset() → int

根據(jù)存儲元素的數(shù)量(不是字節(jié)），返回基礎(chǔ)存儲中的self張量偏移量。

例：

>>> x = torch.tensor([1, 2, 3, 4, 5])
>>> x.storage_offset()
0
>>> x[3:].storage_offset()

storage_type() → type

返回基礎(chǔ)存儲的類型。

stride(dim) → tuple or int

返回self張量的步幅。

跨度是在指定尺寸 dim 中從一個元素跳至下一元素所需的跳躍。當(dāng)未傳遞任何參數(shù)時，將返回所有跨度的元組。否則，將返回整數(shù)值作為特定維度 dim 中的跨度。

參數(shù)

dim (python：int ， 可選）– 需要跨度的所需尺寸

例：

>>> x = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
>>> x.stride()
(5, 1)
>>>x.stride(0)
5
>>> x.stride(-1)
1

sub(value, other) → Tensor

從self張量中減去標(biāo)量或張量。如果同時指定了value和other，則在使用前other的每個元素都會按value縮放。

當(dāng)other是張量時，other的形狀必須是可廣播的，并具有基礎(chǔ)張量的形狀。

sub_(x) → Tensor

sub()

sum(dim=None, keepdim=False, dtype=None) → Tensor

torch.sum()

sum_to_size(*size) → Tensor

將this張量與 size 相加。 size 必須可廣播到this張量大小。

參數(shù)

大小 (python：int ... )–定義輸出張量形狀的整數(shù)序列。

svd(some=True, compute_uv=True) -> (Tensor, Tensor, Tensor)

torch.svd()

symeig(eigenvectors=False, upper=True) -> (Tensor, Tensor)

torch.symeig()

t() → Tensor

torch.t()

t_() → Tensor

t()

to(*args, **kwargs) → Tensor

執(zhí)行 Tensor dtype 和/或設(shè)備轉(zhuǎn)換。 torch.dtype 和 torch.device 是從self.to(*args, **kwargs)的論點推論出來的。

注意

如果self張量已經(jīng)具有正確的 torch.dtype 和 torch.device ，則返回self。否則，返回的張量是self與所需 torch.dtype 和 torch.device 的副本。

以下是調(diào)用to的方法：

to(dtype, non_blocking=False, copy=False) → Tensor

返回具有指定dtype的張量

to(device=None, dtype=None, non_blocking=False, copy=False) → Tensor

返回具有指定 device 和(可選）dtype的張量。如果dtype為None，則推斷為self.dtype。當(dāng)non_blocking時，如果可能，嘗試相對于主機進(jìn)行異步轉(zhuǎn)換，例如，將具有固定內(nèi)存的 CPU 張量轉(zhuǎn)換為 CUDA 張量。設(shè)置copy時，即使張量已經(jīng)匹配所需的轉(zhuǎn)換，也會創(chuàng)建新的張量。

to(other, non_blocking=False, copy=False) → Tensor

返回與張量other相同的 torch.dtype 和 torch.device 的張量。當(dāng)non_blocking時，如果可能，嘗試相對于主機進(jìn)行異步轉(zhuǎn)換，例如，將具有固定內(nèi)存的 CPU 張量轉(zhuǎn)換為 CUDA 張量。設(shè)置copy時，即使張量已經(jīng)與所需的轉(zhuǎn)換匹配，也會創(chuàng)建新的張量。

例：

>>> tensor = torch.randn(2, 2)  # Initially dtype=float32, device=cpu
>>> tensor.to(torch.float64)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64)


>>> cuda0 = torch.device('cuda:0')
>>> tensor.to(cuda0)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], device='cuda:0')


>>> tensor.to(cuda0, dtype=torch.float64)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')


>>> other = torch.randn((), dtype=torch.float64, device=cuda0)
>>> tensor.to(other, non_blocking=True)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')

to_mkldnn() → Tensor

返回torch.mkldnn布局中的張量的副本。

take(indices) → Tensor

torch.take()

tan() → Tensor

torch.tan()

tan_() → Tensor

tan()

tanh() → Tensor

torch.tanh()

tanh_() → Tensor

tanh()

tolist()

” tolist(）->列表或編號

將張量作為(嵌套的）列表返回。對于標(biāo)量，將返回標(biāo)準(zhǔn) Python 編號，就像 item() 一樣。如有必要，張量會先自動移至 CPU。

This operation is not differentiable.

例子：

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803

topk(k, dim=None, largest=True, sorted=True) -> (Tensor, LongTensor)

torch.topk()

to_sparse(sparseDims) → Tensor

返回張量的稀疏副本。 PyTorch 支持坐標(biāo)格式的稀疏張量。

參數(shù)

sparseDims (python：int ， 可選）– 新稀疏張量中包含的稀疏維數(shù)

例：

>>> d = torch.tensor([[0, 0, 0], [9, 0, 10], [0, 0, 0]])
>>> d
tensor([[ 0,  0,  0],
        [ 9,  0, 10],
        [ 0,  0,  0]])
>>> d.to_sparse()
tensor(indices=tensor([[1, 1],
                       [0, 2]]),
       values=tensor([ 9, 10]),
       size=(3, 3), nnz=2, layout=torch.sparse_coo)
>>> d.to_sparse(1)
tensor(indices=tensor([[1]]),
       values=tensor([[ 9,  0, 10]]),
       size=(3, 3), nnz=1, layout=torch.sparse_coo)

trace() → Tensor

torch.trace()

transpose(dim0, dim1) → Tensor

torch.transpose()

transpose_(dim0, dim1) → Tensor

transpose()

triangular_solve(A, upper=True, transpose=False, unitriangular=False) -> (Tensor, Tensor)

torch.triangular_solve()

tril(k=0) → Tensor

torch.tril()

tril_(k=0) → Tensor

tril()

triu(k=0) → Tensor

torch.triu()

triu_(k=0) → Tensor

triu()

trunc() → Tensor

torch.trunc()

trunc_() → Tensor

trunc()

type(dtype=None, non_blocking=False, **kwargs) → str or Tensor

如果未提供dtype; ，則返回類型，否則將該對象強制轉(zhuǎn)換為指定的類型。

如果它已經(jīng)是正確的類型，則不執(zhí)行任何復(fù)制，并返回原始對象。

參數(shù)

dtype (python：type 或 字符串）– 所需類型
non_blocking (bool ) – 如果True，并且源位于固定內(nèi)存中，而目標(biāo)位于 GPU 上，反之亦然，則相對于主機異步執(zhí)行復(fù)制。否則，該參數(shù)無效。
\kwargs – 為兼容起見，可以包含鍵async來代替non_blocking參數(shù)。不推薦使用async arg。

type_as(tensor) → Tensor

將此張量轉(zhuǎn)換為給定張量的類型。

如果張量已經(jīng)是正確的類型，則這是無操作的。相當(dāng)于self.type(tensor.type())

參數(shù)

張量 (tensor)–具有所需類型的張量

unbind(dim=0) → seq

torch.unbind()

unfold(dimension, size, step) → Tensor

返回一個張量，該張量包含self張量中尺寸為dimension的所有大小為 size 的切片。

兩個切片之間的步長由step給出。

如果 sizedim 是self的尺寸dimension的大小，則返回張量中dimension的尺寸將是(sizeim-size）/step+ 1 。

在返回的張量中附加了尺寸為 size 的附加尺寸。

參數(shù)

dimension (python：int )–發(fā)生展開的尺寸
size (python：int )–展開的每個切片的大小
step (python：int )–每個切片之間的步驟

例：

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

uniform_(from=0, to=1) → Tensor

用從連續(xù)均勻分布中采樣的數(shù)字填充self張量：

unique(sorted=True, return_inverse=False, return_counts=False, dim=None)

返回輸入張量的唯一元素。

torch.unique()

unique_consecutive(return_inverse=False, return_counts=False, dim=None)

從每個連續(xù)的等效元素組中除去除第一個元素外的所有元素。

torch.unique_consecutive()

unsqueeze(dim) → Tensor

torch.unsqueeze()

unsqueeze_(dim) → Tensor

unsqueeze()

values() → Tensor

如果self是稀疏的 COO 張量(即torch.sparse_coo布局），則返回包含值張量的視圖。否則，將引發(fā)錯誤。

Tensor.indices() 。

注意

This method can only be called on a coalesced sparse tensor. See Tensor.coalesce() for details.

var(dim=None, unbiased=True, keepdim=False) → Tensor

torch.var()

view(*shape) → Tensor

返回具有與self張量相同的數(shù)據(jù)但具有不同shape的新張量。

返回的張量共享相同的數(shù)據(jù)，并且必須具有相同數(shù)量的元素，但可能具有不同的大小。要查看張量，新視圖尺寸必須與其原始尺寸和步幅兼容，即每個新視圖尺寸必須是原始尺寸的子空間，或者僅跨越滿足以下條件的原始尺寸的連續(xù)性狀

否則，需要先調(diào)用 contiguous() 才能查看張量。如果形狀兼容則返回一個視圖，否則復(fù)制(相當(dāng)于調(diào)用 contiguous())。

參數(shù)

形狀(torch大小 或 python：int ... )–所需大小

例：

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


>>> a = torch.randn(1, 2, 3, 4)
>>> a.size()
torch.Size([1, 2, 3, 4])
>>> b = a.transpose(1, 2)  # Swaps 2nd and 3rd dimension
>>> b.size()
torch.Size([1, 3, 2, 4])
>>> c = a.view(1, 3, 2, 4)  # Does not change tensor layout in memory
>>> c.size()
torch.Size([1, 3, 2, 4])
>>> torch.equal(b, c)
False

view_as(other) → Tensor

將此張量查看為與other相同的大小。 self.view_as(other)等效于self.view(other.size())。

參數(shù)

other (torch.Tensor) – The result tensor has the same size as other.

where(condition, y) → Tensor

self.where(condition, y)等效于torch.where(condition, self, y)。

zero_() → Tensor

用零填充self張量。

class torch.BoolTensor

以下方法是 torch.BoolTensor 獨有的。

all()

all() → bool

如果張量中的所有元素均為 True，則返回 True，否則返回 False。

例：

>>> a = torch.rand(1, 2).bool()
>>> a
tensor([[False, True]], dtype=torch.bool)
>>> a.all()
tensor(False, dtype=torch.bool)

all(dim, keepdim=False, out=None) → Tensor

如果張量的每一行中給定維度dim中的所有元素均為 True，則返回 True，否則返回 False。

如果keepdim為True，則輸出張量的大小與input相同，但尺寸為dim的大小為 1。否則，將壓縮dim( torch.squeeze())，導(dǎo)致輸出張量的尺寸比input小 1。

參數(shù)

dim (python：int ) – 縮小的尺寸
keepdim (bool ) – 輸出張量是否保留dim
out (tensor ， 可選）– 輸出的張量

例：

>>> a = torch.rand(4, 2).bool()
>>> a
tensor([[True, True],
        [True, False],
        [True, True],
        [True, True]], dtype=torch.bool)
>>> a.all(dim=1)
tensor([ True, False,  True,  True], dtype=torch.bool)
>>> a.all(dim=0)
tensor([ True, False], dtype=torch.bool)

any()

any() → bool

如果張量中的任何元素為 True，則返回 True，否則為 False。

例：

>>> a = torch.rand(1, 2).bool()
>>> a
tensor([[False, True]], dtype=torch.bool)
>>> a.any()
tensor(True, dtype=torch.bool)

any(dim, keepdim=False, out=None) → Tensor

如果張量的每一行中給定維度dim中的任何元素為 True，則返回 True，否則為 False。

參數(shù)

dim (python:int) – 縮小的尺寸
keepdim (bool) – 輸出張量是否保留dim
out (*Tensor*, optional) – 輸出的張量

例：

>>> a = torch.randn(4, 2) < 0
>>> a
tensor([[ True,  True],
        [False,  True],
        [ True,  True],
        [False, False]])
>>> a.any(1)
tensor([ True,  True,  True, False])
>>> a.any(0)
tensor([True, True])