=2.0) ..." />福建体彩25选5开奖结果
碼迷,mamicode.com
首頁 > 其他好文 > 詳細

PyTorch官方中文文檔:torch

時間:2018-03-10 14:04:28      閱讀:39142      評論:0      收藏:0      [點我收藏+]

標簽:python3.5   end   連接   不包含   dev   tuple   long   判斷   情況   

torch

包 torch 包含了多維張量的數據結構以及基于其上的多種數學操作。另外,它也提供了多種工具,其中一些可以更有效地對張量和任意類型進行序列化。

它有CUDA 的對應實現,可以在NVIDIA GPU上進行張量運算(計算能力>=2.0)。

http://www.aibbt.com/a/pytorch/

張量 Tensors

torch.is_tensor[source]

torch.is_tensor(obj)

如果obj 是一個pytorch張量,則返回True

  • 參數: obj (Object) – 判斷對象

torch.is_storage [source]

torch.is_storage(obj)

如何obj 是一個pytorch storage對象,則返回True

  • 參數: input (Object) – 判斷對象

torch.__set_default_tensor_type__[source]

torch.set_default_tensor_type(t)

torch.numel

torch.numel(input)->int

返回input 張量中的元素個數

  • 參數: input (Tensor) – 輸入張量

例子:

>>> a = torch.randn(1,2,3,4,5)
>>> torch.numel(a)
120
>>> a = torch.zeros(4,4)
>>> torch.numel(a)
16

torch.set_printoptions[source]

torch.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None)

設置打印選項。 完全參考自 Numpy

參數:

  • precision – 浮點數輸出的精度位數 (默認為8 )
  • threshold – 閾值,觸發匯總顯示而不是完全顯示(repr)的數組元素的總數 (默認為1000)
  • edgeitems – 匯總顯示中,每維(軸)兩端顯示的項數(默認值為3)
  • linewidth – 用于插入行間隔的每行字符數(默認為80)。Thresholded matricies will ignore this parameter.
  • profile – pretty打印的完全默認值。 可以覆蓋上述所有選項 (默認為short, full)

創建操作 Creation Ops

torch.eye

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

返回一個2維張量,對角線位置全1,其它位置全0

參數:

  • n (int ) – 行數
  • m (intoptional) – 列數.如果為None,則默認為n
  • out (Tensoroptinal) - Output tensor

返回值: 對角線位置全1,其它位置全0的2維張量

返回值類型: Tensor

例子:

>>> torch.eye(3)
 1  0  0
 0  1  0
 0  0  1
[torch.FloatTensor of size 3x3]

from_numpy

torch.from_numpy(ndarray) → Tensor

Numpy橋,將numpy.ndarray 轉換為pytorch的 Tensor
返回的張量tensor和numpy的ndarray共享同一內存空間。修改一個會導致另外一個也被修改。返回的張量不能改變大小。

例子:

>>> a = numpy.array([1, 2, 3])
>>> t = torch.from_numpy(a)
>>> t
torch.LongTensor([1, 2, 3])
>>> t[0] = -1
>>> a
array([-1,  2,  3])

torch.linspace

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

返回一個1維張量,包含在區間start 和 end 上均勻間隔的steps個點。
輸出1維張量的長度為steps

參數:

  • start (float) – 序列的起始點
  • end (float) – 序列的最終值
  • steps (int) – 在start 和 end間生成的樣本數
  • out (Tensor, optional) – 結果張量

例子:

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

  3.0000
  4.7500
  6.5000
  8.2500
 10.0000
[torch.FloatTensor of size 5]

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

-10
 -5
  0
  5
 10
[torch.FloatTensor of size 5]

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

-10
 -5
  0
  5
 10
[torch.FloatTensor of size 5]

torch.logspace

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

返回一個1維張量,包含在區間 \(10^{start}\) 和 \( 10^{end} \)上以對數刻度均勻間隔的steps個點。
輸出1維張量的長度為steps

參數:

  • start (float) – 序列的起始點
  • end (float) – 序列的最終值
  • steps (int) – 在start 和 end間生成的樣本數
  • out (Tensor, optional) – 結果張量

例子:

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

 1.0000e-10
 1.0000e-05
 1.0000e+00
 1.0000e+05
 1.0000e+10
[torch.FloatTensor of size 5]

>>> torch.logspace(start=0.1, end=1.0, steps=5)

  1.2589
  2.1135
  3.5481
  5.9566
 10.0000
[torch.FloatTensor of size 5]

torch.ones

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

返回一個全為1 的張量,形狀由可變參數sizes定義。

參數:

  • sizes (int...) – 整數序列,定義了輸出形狀
  • out (Tensor, optional) – 結果張量
    例子:
>>> torch.ones(2, 3)

 1  1  1
 1  1  1
[torch.FloatTensor of size 2x3]

>>> torch.ones(5)

 1
 1
 1
 1
 1
[torch.FloatTensor of size 5]

torch.rand

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

返回一個張量,包含了從區間[0,1)的均勻分布中抽取的一組隨機數,形狀由可變參數sizes 定義。

參數:

  • sizes (int...) – 整數序列,定義了輸出形狀
  • out (Tensoroptinal) - 結果張量
    例子:
>>> torch.rand(4)

 0.9193
 0.3347
 0.3232
 0.7715
[torch.FloatTensor of size 4]

>>> torch.rand(2, 3)

 0.5010  0.5140  0.0719
 0.1435  0.5636  0.0538
[torch.FloatTensor of size 2x3]

torch.randn

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

返回一個張量,包含了從標準正態分布(均值為0,方差為 1,即高斯白噪聲)中抽取一組隨機數,形狀由可變參數sizes定義。
參數:

  • sizes (int...) – 整數序列,定義了輸出形狀
  • out (Tensoroptinal) - 結果張量

例子::

>>> torch.randn(4)

-0.1145
 0.0094
-1.1717
 0.9846
[torch.FloatTensor of size 4]

>>> torch.randn(2, 3)

 1.4339  0.3351 -1.0999
 1.5458 -0.9643 -0.3558
[torch.FloatTensor of size 2x3]

torch.randperm

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

給定參數n,返回一個從0 到n -1 的隨機整數排列。

參數:

  • n (int) – 上邊界(不包含)

例子:

>>> torch.randperm(4)

 2
 1
 3
 0
[torch.LongTensor of size 4]

torch.arange

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

返回一個1維張量,長度為 \( floor((end?start)/step) \)。包含從startend,以step為步長的一組序列值(默認步長為1)。

參數:

  • start (float) – 序列的起始點
  • end (float) – 序列的終止點
  • step (float) – 相鄰點的間隔大小
  • out (Tensor, optional) – 結果張量

例子:

>>> torch.arange(1, 4)

 1
 2
 3
[torch.FloatTensor of size 3]

>>> torch.arange(1, 2.5, 0.5)

 1.0000
 1.5000
 2.0000
[torch.FloatTensor of size 3]

torch.range

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

返回一個1維張量,有 \( floor((end?start)/step)+1 \) 個元素。包含在半開區間[start, end)start開始,以step為步長的一組值。 step 是兩個值之間的間隔,即 \( x_{i+1}=x_i+step \)

警告:建議使用函數 torch.arange()

參數:

  • start (float) – 序列的起始點
  • end (float) – 序列的最終值
  • step (int) – 相鄰點的間隔大小
  • out (Tensor, optional) – 結果張量

例子:

>>> torch.range(1, 4)

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> torch.range(1, 4, 0.5)

 1.0000
 1.5000
 2.0000
 2.5000
 3.0000
 3.5000
 4.0000
[torch.FloatTensor of size 7]

torch.zeros

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

返回一個全為標量 0 的張量,形狀由可變參數sizes 定義。

參數:

  • sizes (int...) – 整數序列,定義了輸出形狀
  • out (Tensoroptional) – 結果張量

例子:

>>> torch.zeros(2, 3)

 0  0  0
 0  0  0
[torch.FloatTensor of size 2x3]

>>> torch.zeros(5)

 0
 0
 0
 0
 0
[torch.FloatTensor of size 5]

索引,切片,連接,換位Indexing, Slicing, Joining, Mutating Ops

torch.cat

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

在給定維度上對輸入的張量序列seq 進行連接操作。

torch.cat()可以看做 torch.split() 和 torch.chunk()的反操作。
cat() 函數可以通過下面例子更好的理解。

參數:

  • inputs (sequence of Tensors) – 可以是任意相同Tensor 類型的python 序列
  • dimension (intoptional) – 沿著此維連接張量序列。

例子:

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

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

>>> torch.cat((x, x, x), 0)

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 6x3]

>>> torch.cat((x, x, x), 1)

 0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x9]

torch.chunk

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

在給定維度(軸)上將輸入張量進行分塊兒。

參數:

  • tensor (Tensor) – 待分塊的輸入張量
  • chunks (int) – 分塊的個數
  • dim (int) – 沿著此維度進行分塊

torch.gather

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

沿給定軸dim,將輸入索引張量index指定位置的值進行聚合。

對一個3維張量,輸出可以定義為:

out[i][j][k] = tensor[index[i][j][k]][j][k]  # dim=0
out[i][j][k] = tensor[i][index[i][j][k]][k]  # dim=1
out[i][j][k] = tensor[i][j][index[i][j][k]]  # dim=3

例子:

>>> t = torch.Tensor([[1,2],[3,4]])
>>> torch.gather(t, 1, torch.LongTensor([[0,0],[1,0]]))
 1  1
 4  3
[torch.FloatTensor of size 2x2]

參數:

  • input (Tensor) – 源張量
  • dim (int) – 索引的軸
  • index (LongTensor) – 聚合元素的下標
  • out (Tensor, optional) – 目標張量

torch.index_select

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

沿著指定維度對輸入進行切片,取index中指定的相應項(index為一個LongTensor),然后返回到一個新的張量,
返回的張量與原始張量_Tensor_有相同的維度(在指定軸上)。

注意: 返回的張量不與原始張量共享內存空間。

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – 索引的軸
  • index (LongTensor) – 包含索引下標的一維張量
  • out (Tensor, optional) – 目標張量

例子:

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

 1.2045  2.4084  0.4001  1.1372
 0.5596  1.5677  0.6219 -0.7954
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 3x4]

>>> indices = torch.LongTensor([0, 2])
>>> torch.index_select(x, 0, indices)

 1.2045  2.4084  0.4001  1.1372
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 2x4]

>>> torch.index_select(x, 1, indices)

 1.2045  0.4001
 0.5596  0.6219
 1.3635 -0.5414
[torch.FloatTensor of size 3x2]

torch.masked_select

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

根據掩碼張量mask中的二元值,取輸入張量中的指定項( mask為一個 ByteTensor),將取值返回到一個新的1D張量,

張量 mask須跟input張量有相同數量的元素數目,但形狀或維度不需要相同。
注意: 返回的張量不與原始張量共享內存空間。

參數:

  • input (Tensor) – 輸入張量
  • mask (ByteTensor) – 掩碼張量,包含了二元索引值
  • out (Tensor, optional) – 目標張量

例子:

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

 1.2045  2.4084  0.4001  1.1372
 0.5596  1.5677  0.6219 -0.7954
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 3x4]

>>> indices = torch.LongTensor([0, 2])
>>> torch.index_select(x, 0, indices)

 1.2045  2.4084  0.4001  1.1372
 1.3635 -1.2313 -0.5414 -1.8478
[torch.FloatTensor of size 2x4]

>>> torch.index_select(x, 1, indices)

 1.2045  0.4001
 0.5596  0.6219
 1.3635 -0.5414
[torch.FloatTensor of size 3x2]

torch.nonzero

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

返回一個包含輸入input中非零元素索引的張量。輸出張量中的每行包含輸入中非零元素的索引。

如果輸入inputn維,則輸出的索引張量output的形狀為 z x n, 這里 z 是輸入張量input中所有非零元素的個數。

參數:

  • input (Tensor) – 源張量
  • out (LongTensor, optional) – 包含索引值的結果張量

例子:

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

 0
 1
 2
 4
[torch.LongTensor of size 4x1]

>>> torch.nonzero(torch.Tensor([[0.6, 0.0, 0.0, 0.0],
...                             [0.0, 0.4, 0.0, 0.0],
...                             [0.0, 0.0, 1.2, 0.0],
...                             [0.0, 0.0, 0.0,-0.4]]))

 0  0
 1  1
 2  2
 3  3
[torch.LongTensor of size 4x2]

torch.split

torch.split(tensor, split_size, dim=0)

將輸入張量分割成相等形狀的chunks(如果可分)。 如果沿指定維的張量形狀大小不能被split_size整分, 則最后一個分塊會小于其它分塊。

參數:

  • tensor (Tensor) – 待分割張量
  • split_size (int) – 單個分塊的形狀大小
  • dim (int) – 沿著此維進行分割

torch.squeeze

torch.squeeze(input, dim=None, out=None)

將輸入張量形狀中的1 去除并返回。
如果輸入是形如\((A \times 1\times B \times 1 \times C \times 1 \times D) \),那么輸出形狀就為: \((A \times B \times C \times D) \)

當給定dim時,那么擠壓操作只在給定維度上。例如,輸入形狀為: \((A \times 1 \times B) \), squeeze(input, 0) 將會保持張量不變,只有用 squeeze(input, 1),形狀會變成 \( (A \times B )\)。

注意: 返回張量與輸入張量共享內存,所以改變其中一個的內容會改變另一個。

參數:

  • input (Tensor) – 輸入張量
  • dim (int, optional) – 如果給定,則input只會在給定維度擠壓
  • out (Tensor, optional) – 輸出張量

例子:

>>> x = torch.zeros(2,1,2,1,2)
>>> x.size()
(2L, 1L, 2L, 1L, 2L)
>>> y = torch.squeeze(x)
>>> y.size()
(2L, 2L, 2L)
>>> y = torch.squeeze(x, 0)
>>> y.size()
(2L, 1L, 2L, 1L, 2L)
>>> y = torch.squeeze(x, 1)
>>> y.size()
(2L, 2L, 1L, 2L)

torch.stack[source]

torch.stack(sequence, dim=0)

沿著一個新維度對輸入張量序列進行連接。
序列中所有的張量都應該為相同形狀。

參數:

  • sqequence (Sequence) – 待連接的張量序列
  • dim (int) – 插入的維度。必須介于 0 與 待連接的張量序列數之間。

torch.t

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

輸入一個矩陣(2維張量),并轉置0, 1維。
可以被視為函數transpose(input, 0, 1)的簡寫函數。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 結果張量
>>> x = torch.randn(2, 3)
>>> x

 0.4834  0.6907  1.3417
-0.1300  0.5295  0.2321
[torch.FloatTensor of size 2x3]

>>> torch.t(x)

 0.4834 -0.1300
 0.6907  0.5295
 1.3417  0.2321
[torch.FloatTensor of size 3x2]

torch.transpose

torch.transpose(input, dim0, dim1, out=None) → Tensor

返回輸入矩陣input的轉置。交換維度dim0dim1
輸出張量與輸入張量共享內存,所以改變其中一個會導致另外一個也被修改。

參數:

  • input (Tensor) – 輸入張量
  • dim0 (int) – 轉置的第一維
  • dim1 (int) – 轉置的第二維
>>> x = torch.randn(2, 3)
>>> x

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

>>> torch.transpose(x, 0, 1)

 0.5983  1.5981
-0.0341 -0.5265
 2.4918 -0.8735
[torch.FloatTensor of size 3x2]

torch.unbind

torch.unbind(tensor, dim=0)[source]

移除指定維后,返回一個元組,包含了沿著指定維切片后的各個切片

參數:

  • tensor (Tensor) – 輸入張量
  • dim (int) – 刪除的維度

torch.unsqueeze

torch.unsqueeze(input, dim, out=None)

返回一個新的張量,對輸入的制定位置插入維度 1

注意: 返回張量與輸入張量共享內存,所以改變其中一個的內容會改變另一個。

如果dim為負,則將會被轉化\( dim+input.dim()+1 \)

參數:

  • tensor (Tensor) – 輸入張量
  • dim (int) – 插入維度的索引
  • out (Tensor, optional) – 結果張量
>>> x = torch.Tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
 1  2  3  4
[torch.FloatTensor of size 1x4]
>>> torch.unsqueeze(x, 1)
 1
 2
 3
 4
[torch.FloatTensor of size 4x1]

隨機抽樣 Random sampling

torch.manual_seed

torch.manual_seed(seed)

設定生成隨機數的種子,并返回一個 torch._C.Generator 對象.

參數: seed (int or long) – 種子.

torch.initial_seed

torch.initial_seed()

返回生成隨機數的原始種子值(python long)。

torch.get_rng_state

torch.get_rng_state()[source]

返回隨機生成器狀態(ByteTensor)

torch.set_rng_state

torch.set_rng_state(new_state)[source]

設定隨機生成器狀態
參數: new_state (torch.ByteTensor) – 期望的狀態

torch.default_generator

torch.default_generator = <torch._C.Generator object>

torch.bernoulli

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

從伯努利分布中抽取二元隨機數(0 或者 1)。

輸入張量須包含用于抽取上述二元隨機值的概率。 因此,輸入中的所有值都必須在[0,1]區間,即 \( 0<=input_i<=1 \)

輸出張量的第i個元素值, 將會以輸入張量的第i個概率值等于1

返回值將會是與輸入相同大小的張量,每個值為0或者1
參數:

  • input (Tensor) – 輸入為伯努利分布的概率值
  • out (Tensor, optional) – 輸出張量(可選)

例子:

>>> a = torch.Tensor(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
>>> a

 0.7544  0.8140  0.9842
 0.5282  0.0595  0.6445
 0.1925  0.9553  0.9732
[torch.FloatTensor of size 3x3]

>>> torch.bernoulli(a)

 1  1  1
 0  0  1
 0  1  1
[torch.FloatTensor of size 3x3]

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

 1  1  1
 1  1  1
 1  1  1
[torch.FloatTensor of size 3x3]

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

 0  0  0
 0  0  0
 0  0  0
[torch.FloatTensor of size 3x3]

torch.multinomial

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

返回一個張量,每行包含從input相應行中定義的多項分布中抽取的num_samples個樣本。

[注意]:輸入input每行的值不需要總和為1 (這里我們用來做權重),但是必須非負且總和不能為0。

當抽取樣本時,依次從左到右排列(第一個樣本對應第一列)。

如果輸入input是一個向量,輸出out也是一個相同長度num_samples的向量。如果輸入input是有 \(m \)行的矩陣,輸出out是形如\( m \times n \)的矩陣。

如果參數replacement 為 True, 則樣本抽取可以重復。否則,一個樣本在每行不能被重復抽取。

參數num_samples必須小于input長度(即,input的列數,如果是input是一個矩陣)。

參數:

  • input (Tensor) – 包含概率值的張量
  • num_samples (int) – 抽取的樣本數
  • replacement (bool, optional) – 布爾值,決定是否能重復抽取
  • out (Tensor, optional) – 結果張量

例子:

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

 1
 2
 0
 0
[torch.LongTensor of size 4]

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

 1
 2
 1
 2
[torch.LongTensor of size 4]

torch.normal()

torch.normal(means, std, out=None)

返回一個張量,包含從給定參數means,std的離散正態分布中抽取隨機數。
均值means是一個張量,包含每個輸出元素相關的正態分布的均值。
std是一個張量,包含每個輸出元素相關的正態分布的標準差。
均值和標準差的形狀不須匹配,但每個張量的元素個數須相同。

參數:

  • means (Tensor) – 均值
  • std (Tensor) – 標準差
  • out (Tensor) – 可選的輸出張量
torch.normal(means=torch.arange(1, 11), std=torch.arange(1, 0, -0.1))

 1.5104
 1.6955
 2.4895
 4.9185
 4.9895
 6.9155
 7.3683
 8.1836
 8.7164
 9.8916
[torch.FloatTensor of size 10]
torch.normal(mean=0.0, std, out=None)

與上面函數類似,所有抽取的樣本共享均值。

參數:

  • means (Tensor,optional) – 所有分布均值
  • std (Tensor) – 每個元素的標準差
  • out (Tensor) – 可選的輸出張量

例子:

>>> torch.normal(mean=0.5, std=torch.arange(1, 6))

  0.5723
  0.0871
 -0.3783
 -2.5689
 10.7893
[torch.FloatTensor of size 5]

torch.normal(means, std=1.0, out=None)

與上面函數類似,所有抽取的樣本共享標準差。

參數:

  • means (Tensor) – 每個元素的均值
  • std (float, optional) – 所有分布的標準差
  • out (Tensor) – 可選的輸出張量

例子:

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

 1.1681
 2.8884
 3.7718
 2.5616
 4.2500
[torch.FloatTensor of size 5]

序列化 Serialization

torch.saves[source]

torch.save(obj, f, pickle_module=<module ‘pickle‘ from ‘/home/jenkins/miniconda/lib/python3.5/pickle.py‘>, pickle_protocol=2)

保存一個對象到一個硬盤文件上
參考: Recommended approach for saving a model
參數:

  • obj – 保存對象
  • f - 類文件對象 (返回文件描述符)或一個保存文件名的字符串
  • pickle_module – 用于pickling元數據和對象的模塊
  • pickle_protocol – 指定pickle protocal 可以覆蓋默認參數

torch.load[source]

torch.load(f, map_location=None, pickle_module=<module ‘pickle‘ from ‘/home/jenkins/miniconda/lib/python3.5/pickle.py‘>)

從磁盤文件中讀取一個通過torch.save()保存的對象。
torch.load() 可通過參數map_location 動態地進行內存重映射,使其能從不動設備中讀取文件。一般調用時,需兩個參數: storage 和 location tag. 返回不同地址中的storage,或著返回None (此時地址可以通過默認方法進行解析). 如果這個參數是字典的話,意味著其是從文件的地址標記到當前系統的地址標記的映射。
默認情況下, location tags中 "cpu"對應host tensors,‘cuda:device_id’ (e.g. ‘cuda:2’) 對應cuda tensors。
用戶可以通過register_package進行擴展,使用自己定義的標記和反序列化方法。

參數:

  • f – 類文件對象 (返回文件描述符)或一個保存文件名的字符串
  • map_location – 一個函數或字典規定如何remap存儲位置
  • pickle_module – 用于unpickling元數據和對象的模塊 (必須匹配序列化文件時的pickle_module )

例子:

>>> torch.load(‘tensors.pt‘)
# Load all tensors onto the CPU
>>> torch.load(‘tensors.pt‘, map_location=lambda storage, loc: storage)
# Map tensors from GPU 1 to GPU 0
>>> torch.load(‘tensors.pt‘, map_location={‘cuda:1‘:‘cuda:0‘})

并行化 Parallelism

torch.get_num_threads

torch.get_num_threads() → int

獲得用于并行化CPU操作的OpenMP線程數


torch.set_num_threads

torch.set_num_threads(int)

設定用于并行化CPU操作的OpenMP線程數

數學操作Math operations

Pointwise Ops

torch.abs

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

計算輸入張量的每個元素絕對值

例子:

>>> torch.abs(torch.FloatTensor([-1, -2, 3]))
FloatTensor([1, 2, 3])

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

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

返回一個新張量,包含輸入張量每個元素的反余弦。
參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(4)
>>> a

-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.acos(a)
 2.2608
 1.2956
 1.1075
    nan
[torch.FloatTensor of size 4]

torch.add()

torch.add(input, value, out=None)

對輸入張量input逐元素加上標量值value,并返回結果到一個新的張量out,即 \( out = tensor + value \)。

如果輸入input是FloatTensor or DoubleTensor類型,則value 必須為實數,否則須為整數。【譯注:似乎并非如此,無關輸入類型,value取整數、實數皆可。】

  • input (Tensor) – 輸入張量
  • value (Number) – 添加到輸入每個元素的數
  • out (Tensor, optional) – 結果張量
>>> a = torch.randn(4)
>>> a

 0.4050
-1.2227
 1.8688
-0.4185
[torch.FloatTensor of size 4]

>>> torch.add(a, 20)

 20.4050
 18.7773
 21.8688
 19.5815
[torch.FloatTensor of size 4]
torch.add(input, value=1, other, out=None)

other 張量的每個元素乘以一個標量值value,并加到iput 張量上。返回結果到輸出張量out。即,\( out=input+(other?value ) \)

兩個張量 input and other的尺寸不需要匹配,但元素總數必須一樣。

注意 :當兩個張量形狀不匹配時,輸入張量的形狀會作為輸出張量的尺寸。

如果other是FloatTensor or DoubleTensor類型,則value 必須為實數,否則須為整數。【譯注:似乎并非如此,無關輸入類型,value取整數、實數皆可。】

參數:

  • input (Tensor) – 第一個輸入張量
  • value (Number) – 用于第二個張量的尺寸因子
  • other (Tensor) – 第二個輸入張量
  • out (Tensor, optional) – 結果張量

例子:

>>> import torch
>>> a = torch.randn(4)
>>> a

-0.9310
 2.0330
 0.0852
-0.2941
[torch.FloatTensor of size 4]

>>> b = torch.randn(2, 2)
>>> b

 1.0663  0.2544
-0.1513  0.0749
[torch.FloatTensor of size 2x2]

>>> torch.add(a, 10, b)
 9.7322
 4.5770
-1.4279
 0.4552
[torch.FloatTensor of size 4]

torch.addcdiv

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

tensor2tensor1逐元素相除,然后乘以標量值value 并加到tensor

張量的形狀不需要匹配,但元素數量必須一致。

如果輸入是FloatTensor or DoubleTensor類型,則value 必須為實數,否則須為整數。

參數:

  • tensor (Tensor) – 張量,對 tensor1 ./ tensor 進行相加
  • value (Number, optional) – 標量,對 tensor1 ./ tensor2 進行相乘
  • tensor1 (Tensor) – 張量,作為被除數(分子)
  • tensor2 (Tensor) –張量,作為除數(分母)
  • out (Tensor, optional) – 輸出張量

例子:

>>> t = torch.randn(2, 3)
>>> t1 = torch.randn(1, 6)
>>> t2 = torch.randn(6, 1)
>>> torch.addcdiv(t, 0.1, t1, t2)

 0.0122 -0.0188 -0.2354
 0.7396 -1.5721  1.2878
[torch.FloatTensor of size 2x3]

torch.addcmul

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

tensor2tensor1逐元素相乘,并對結果乘以標量值value然后加到tensor
張量的形狀不需要匹配,但元素數量必須一致。
如果輸入是FloatTensor or DoubleTensor類型,則value 必須為實數,否則須為整數。

參數:

  • tensor (Tensor) – 張量,對tensor1 ./ tensor 進行相加
  • value (Number, optional) – 標量,對 tensor1 . tensor2 進行相乘
  • tensor1 (Tensor) – 張量,作為乘子1
  • tensor2 (Tensor) –張量,作為乘子2
  • out (Tensor, optional) – 輸出張量

例子:

>>> t = torch.randn(2, 3)
>>> t1 = torch.randn(1, 6)
>>> t2 = torch.randn(6, 1)
>>> torch.addcmul(t, 0.1, t1, t2)

 0.0122 -0.0188 -0.2354
 0.7396 -1.5721  1.2878
[torch.FloatTensor of size 2x3]

torch.asin

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

返回一個新張量,包含輸入input張量每個元素的反正弦函數

參數:

  • tensor (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.asin(a)
-0.6900
 0.2752
 0.4633
    nan
[torch.FloatTensor of size 4]

torch.atan

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

返回一個新張量,包含輸入input張量每個元素的反正切函數

參數:

  • tensor (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.atan(a)
-0.5669
 0.2653
 0.4203
 0.9196
[torch.FloatTensor of size 4]

torch.atan2

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

返回一個新張量,包含兩個輸入張量input1input2的反正切函數

參數:

  • input1 (Tensor) – 第一個輸入張量
  • input2 (Tensor) – 第二個輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.atan2(a, torch.randn(4))
-2.4167
 2.9755
 0.9363
 1.6613
[torch.FloatTensor of size 4]

torch.ceil

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

天井函數,對輸入input張量每個元素向上取整, 即取不小于每個元素的最小整數,并返回結果到輸出。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.ceil(a)

 2
 1
-0
-0
[torch.FloatTensor of size 4]

torch.clamp

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

將輸入input張量每個元素的夾緊到區間 \([min, max] \),并返回結果到一個新張量。

操作定義如下:

      | min, if x_i < min
y_i = | x_i, if min <= x_i <= max
      | max, if x_i > max

如果輸入是FloatTensor or DoubleTensor類型,則參數min max 必須為實數,否則須為整數。【譯注:似乎并非如此,無關輸入類型,min, max取整數、實數皆可。】

參數:

  • input (Tensor) – 輸入張量
  • min (Number) – 限制范圍下限
  • max (Number) – 限制范圍上限
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.clamp(a, min=-0.5, max=0.5)

 0.5000
 0.3912
-0.5000
-0.5000
[torch.FloatTensor of size 4]
torch.clamp(input, *, min, out=None) → Tensor

將輸入input張量每個元素的限制到不小于min ,并返回結果到一個新張量。

如果輸入是FloatTensor or DoubleTensor類型,則參數 min 必須為實數,否則須為整數。【譯注:似乎并非如此,無關輸入類型,min取整數、實數皆可。】

參數:

  • input (Tensor) – 輸入張量
  • value (Number) – 限制范圍下限
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.clamp(a, min=0.5)

 1.3869
 0.5000
 0.5000
 0.5000
[torch.FloatTensor of size 4]
torch.clamp(input, *, max, out=None) → Tensor

將輸入input張量每個元素的限制到不大于max ,并返回結果到一個新張量。

如果輸入是FloatTensor or DoubleTensor類型,則參數 max 必須為實數,否則須為整數。【譯注:似乎并非如此,無關輸入類型,max取整數、實數皆可。】

參數:

  • input (Tensor) – 輸入張量
  • value (Number) – 限制范圍上限
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.clamp(a, max=0.5)

 0.5000
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

torch.cos

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

返回一個新張量,包含輸入input張量每個元素的余弦。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.cos(a)
 0.8041
 0.9633
 0.9018
 0.2557
[torch.FloatTensor of size 4]

torch.cosh

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

返回一個新張量,包含輸入input張量每個元素的雙曲余弦。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.cosh(a)
 1.2095
 1.0372
 1.1015
 1.9917
[torch.FloatTensor of size 4]

torch.div()

torch.div(input, value, out=None)

input逐元素除以標量值value,并返回結果到輸出張量out
即 \( out=tensor/value \)

如果輸入是FloatTensor or DoubleTensor類型,則參數 value 必須為實數,否則須為整數。【譯注:似乎并非如此,無關輸入類型,value取整數、實數皆可。】

參數:

  • input (Tensor) – 輸入張量
  • value (Number) – 除數
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(5)
>>> a

-0.6147
-1.1237
-0.1604
-0.6853
 0.1063
[torch.FloatTensor of size 5]

>>> torch.div(a, 0.5)

-1.2294
-2.2474
-0.3208
-1.3706
 0.2126
[torch.FloatTensor of size 5]
torch.div(input, other, out=None)

兩張量inputother逐元素相除,并將結果返回到輸出。即, \( out_i= input_i / other_i \)

兩張量形狀不須匹配,但元素數須一致。

注意:當形狀不匹配時,input的形狀作為輸出張量的形狀。

參數:

  • input (Tensor) – 張量(分子)
  • other (Tensor) – 張量(分母)
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4,4)
>>> a

-0.1810  0.4017  0.2863 -0.1013
 0.6183  2.0696  0.9012 -1.5933
 0.5679  0.4743 -0.0117 -0.1266
-0.1213  0.9629  0.2682  1.5968
[torch.FloatTensor of size 4x4]

>>> b = torch.randn(8, 2)
>>> b

 0.8774  0.7650
 0.8866  1.4805
-0.6490  1.1172
 1.4259 -0.8146
 1.4633 -0.1228
 0.4643 -0.6029
 0.3492  1.5270
 1.6103 -0.6291
[torch.FloatTensor of size 8x2]

>>> torch.div(a, b)

-0.2062  0.5251  0.3229 -0.0684
-0.9528  1.8525  0.6320  1.9559
 0.3881 -3.8625 -0.0253  0.2099
-0.3473  0.6306  0.1666 -2.5381
[torch.FloatTensor of size 4x4]

torch.exp

torch.exp(tensor, out=None) → Tensor

返回一個新張量,包含輸入input張量每個元素的指數。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量
>>> torch.exp(torch.Tensor([0, math.log(2)]))
torch.FloatTensor([1, 2])

torch.floor

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

床函數: 返回一個新張量,包含輸入input張量每個元素的floor,即不小于元素的最大整數。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.floor(a)

 1
 0
-1
-1
[torch.FloatTensor of size 4]

torch.fmod

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

計算除法余數。
除數與被除數可能同時含有整數和浮點數。此時,余數的正負與被除數相同。

參數:
- input (Tensor) – 被除數
- divisor (Tensor or float) – 除數,一個數或與被除數相同類型的張量
- out (Tensor, optional) – 輸出張量

例子:

>>> torch.fmod(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
torch.FloatTensor([-1, -0, -1, 1, 0, 1])
>>> torch.fmod(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])

參考: torch.remainder(), 計算逐元素余數, 相當于python 中的 % 操作符。

torch.frac

torch.frac(tensor, out=None) → Tensor

返回每個元素的分數部分。

例子:

>>> torch.frac(torch.Tensor([1, 2.5, -3.2])
torch.FloatTensor([0, 0.5, -0.2])

torch.lerp

torch.lerp(start, end, weight, out=None)

對兩個張量以startend做線性插值, 將結果返回到輸出張量。

即,\( out_i=start_i+weight?(end_i?start_i) \)

參數:

  • start (Tensor) – 起始點張量
  • end (Tensor) – 終止點張量
  • weight (float) – 插值公式的weight
  • out (Tensor, optional) – 結果張量

例子:

>>> start = torch.arange(1, 5)
>>> end = torch.Tensor(4).fill_(10)
>>> start

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> end

 10
 10
 10
 10
[torch.FloatTensor of size 4]

>>> torch.lerp(start, end, 0.5)

 5.5000
 6.0000
 6.5000
 7.0000
[torch.FloatTensor of size 4]

torch.log

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

計算input 的自然對數

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(5)
>>> a

-0.4183
 0.3722
-0.3091
 0.4149
 0.5857
[torch.FloatTensor of size 5]

>>> torch.log(a)

    nan
-0.9883
    nan
-0.8797
-0.5349
[torch.FloatTensor of size 5]

torch.log1p

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

計算 \( input +1 \)的自然對數
\( y_i=log(x_i+1) \)

注意:對值比較小的輸入,此函數比torch.log()更準確。

如果輸入是FloatTensor or DoubleTensor類型,則value 必須為實數,否則須為整數。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(5)
>>> a

-0.4183
 0.3722
-0.3091
 0.4149
 0.5857
[torch.FloatTensor of size 5]

>>> torch.log1p(a)

-0.5418
 0.3164
-0.3697
 0.3471
 0.4611
[torch.FloatTensor of size 5]

torch.mul

torch.mul(input, value, out=None)

用標量值value乘以輸入input的每個元素,并返回一個新的結果張量。
\( out=tensor ? value \)

如果輸入是FloatTensor or DoubleTensor類型,則value 必須為實數,否則須為整數。【譯注:似乎并非如此,無關輸入類型,value取整數、實數皆可。】

參數:

  • input (Tensor) – 輸入張量
  • value (Number) – 乘到每個元素的數
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(3)
>>> a

-0.9374
-0.5254
-0.6069
[torch.FloatTensor of size 3]

>>> torch.mul(a, 100)

-93.7411
-52.5374
-60.6908
[torch.FloatTensor of size 3]
torch.mul(input, other, out=None)

兩個張量input,other按元素進行相乘,并返回到輸出張量。即計算\( out_i=input_i ? other_i \)

兩計算張量形狀不須匹配,但總元素數須一致。
注意:當形狀不匹配時,input的形狀作為輸入張量的形狀。

參數:

  • input (Tensor) – 第一個相乘張量
  • other (Tensor) – 第二個相乘張量
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(4,4)
>>> a

-0.7280  0.0598 -1.4327 -0.5825
-0.1427 -0.0690  0.0821 -0.3270
-0.9241  0.5110  0.4070 -1.1188
-0.8308  0.7426 -0.6240 -1.1582
[torch.FloatTensor of size 4x4]

>>> b = torch.randn(2, 8)
>>> b

 0.0430 -1.0775  0.6015  1.1647 -0.6549  0.0308 -0.1670  1.0742
-1.2593  0.0292 -0.0849  0.4530  1.2404 -0.4659 -0.1840  0.5974
[torch.FloatTensor of size 2x8]

>>> torch.mul(a, b)

-0.0313 -0.0645 -0.8618 -0.6784
 0.0934 -0.0021 -0.0137 -0.3513
 1.1638  0.0149 -0.0346 -0.5068
-1.0304 -0.3460  0.1148 -0.6919
[torch.FloatTensor of size 4x4]

torch.neg

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

返回一個新張量,包含輸入input 張量按元素取負。
即, \( out=?1?input \)

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(5)
>>> a

-0.4430
 1.1690
-0.8836
-0.4565
 0.2968
[torch.FloatTensor of size 5]

>>> torch.neg(a)

 0.4430
-1.1690
 0.8836
 0.4565
-0.2968
[torch.FloatTensor of size 5]

torch.pow

torch.pow(input, exponent, out=None)

對輸入input的按元素求exponent次冪值,并返回結果張量。
冪值exponent 可以為單一 float 數或者與input相同元素數的張量。

當冪值為標量時,執行操作:
$$ out_i=x^{exponent} $$

當冪值為張量時,執行操作:
$$ out_i=x^{exponent_i} $$

參數:

  • input (Tensor) – 輸入張量
  • exponent (float or Tensor) – 冪值
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

-0.5274
-0.8232
-2.1128
 1.7558
[torch.FloatTensor of size 4]

>>> torch.pow(a, 2)

 0.2781
 0.6776
 4.4640
 3.0829
[torch.FloatTensor of size 4]

>>> exp = torch.arange(1, 5)
>>> a = torch.arange(1, 5)
>>> a

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> exp

 1
 2
 3
 4
[torch.FloatTensor of size 4]

>>> torch.pow(a, exp)

   1
   4
  27
 256
[torch.FloatTensor of size 4]
torch.pow(base, input, out=None)

base 為標量浮點值,input為張量, 返回的輸出張量 out 與輸入張量相同形狀。

執行操作為:
$$ out_i=base^{input_i} $$

參數:

  • base (float) – 標量值,指數的底
  • input ( Tensor) – 冪值
  • out (Tensor, optional) – 輸出張量

例子:

>>> exp = torch.arange(1, 5)
>>> base = 2
>>> torch.pow(base, exp)

  2
  4
  8
 16
[torch.FloatTensor of size 4]

torch.reciprocal

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

返回一個新張量,包含輸入input張量每個元素的倒數,即 1.0/x。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> torch.reciprocal(a)

 0.7210
 2.5565
-1.1583
-1.8289
[torch.FloatTensor of size 4]

torch.remainder

torch.remainder(input, divisor, out=None) → Tensor

返回一個新張量,包含輸入input張量每個元素的除法余數。
除數與被除數可能同時包含整數或浮點數。余數與除數有相同的符號。

參數:

  • input (Tensor) – 被除數
  • divisor (Tensor or float) – 除數,一個數或者與除數相同大小的張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> torch.remainder(torch.Tensor([-3, -2, -1, 1, 2, 3]), 2)
torch.FloatTensor([1, 0, 1, 1, 0, 1])
>>> torch.remainder(torch.Tensor([1, 2, 3, 4, 5]), 1.5)
torch.FloatTensor([1.0, 0.5, 0.0, 1.0, 0.5])

參考: 函數torch.fmod() 同樣可以計算除法余數,相當于 C 的 庫函數fmod()

torch.round

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

返回一個新張量,將輸入input張量每個元素舍入到最近的整數。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.round(a)

 1
 1
-1
-0
[torch.FloatTensor of size 4]

torch.rsqrt

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

返回一個新張量,包含輸入input張量每個元素的平方根倒數。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.rsqrt(a)

 0.9020
 0.8636
    nan
    nan
[torch.FloatTensor of size 4]

torch.sigmoid

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

返回一個新張量,包含輸入input張量每個元素的sigmoid值。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

-0.4972
 1.3512
 0.1056
-0.2650
[torch.FloatTensor of size 4]

>>> torch.sigmoid(a)

 0.3782
 0.7943
 0.5264
 0.4341
[torch.FloatTensor of size 4]

torch.sign

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

符號函數:返回一個新張量,包含輸入input張量每個元素的正負。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.sign(a)

-1
 1
 1
 1
[torch.FloatTensor of size 4]

torch.sin

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

返回一個新張量,包含輸入input張量每個元素的正弦。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.sin(a)
-0.5944
 0.2684
 0.4322
 0.9667
[torch.FloatTensor of size 4]

torch.sinh

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

返回一個新張量,包含輸入input張量每個元素的雙曲正弦。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.sinh(a)
-0.6804
 0.2751
 0.4619
 1.7225
[torch.FloatTensor of size 4]

torch.sqrt

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

返回一個新張量,包含輸入input張量每個元素的平方根。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

 1.2290
 1.3409
-0.5662
-0.0899
[torch.FloatTensor of size 4]

>>> torch.sqrt(a)

 1.1086
 1.1580
    nan
    nan
[torch.FloatTensor of size 4]

torch.tan

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

返回一個新張量,包含輸入input張量每個元素的正切。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.tan(a)
-0.7392
 0.2786
 0.4792
 3.7801
[torch.FloatTensor of size 4]

torch.tanh

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

返回一個新張量,包含輸入input張量每個元素的雙曲正切。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a
-0.6366
 0.2718
 0.4469
 1.3122
[torch.FloatTensor of size 4]

>>> torch.tanh(a)
-0.5625
 0.2653
 0.4193
 0.8648
[torch.FloatTensor of size 4]

torch.trunc

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

返回一個新張量,包含輸入input張量每個元素的截斷值(標量x的截斷值是最接近其的整數,其比x更接近零。簡而言之,有符號數的小數部分被舍棄)。

參數:

  • input (Tensor) – 輸入張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(4)
>>> a

-0.4972
 1.3512
 0.1056
-0.2650
[torch.FloatTensor of size 4]

>>> torch.trunc(a)

-0
 1
 0
-0
[torch.FloatTensor of size 4]

Reduction Ops

torch.cumprod

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

返回輸入沿指定維度的累積積。例如,如果輸入是一個N 元向量,則結果也是一個N 元向量,第i 個輸出元素值為\( yi=x1?x2?x3?...?xi \)

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – 累積積操作的維度
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(10)
>>> a

 1.1148
 1.8423
 1.4143
-0.4403
 1.2859
-1.2514
-0.4748
 1.1735
-1.6332
-0.4272
[torch.FloatTensor of size 10]

>>> torch.cumprod(a, dim=0)

 1.1148
 2.0537
 2.9045
-1.2788
-1.6444
 2.0578
-0.9770
-1.1466
 1.8726
-0.8000
[torch.FloatTensor of size 10]

>>> a[5] = 0.0
>>> torch.cumprod(a, dim=0)

 1.1148
 2.0537
 2.9045
-1.2788
-1.6444
-0.0000
 0.0000
 0.0000
-0.0000
 0.0000
[torch.FloatTensor of size 10]

torch.cumsum

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

返回輸入沿指定維度的累積和。例如,如果輸入是一個N元向量,則結果也是一個N元向量,第i 個輸出元素值為 \( yi=x1+x2+x3+...+xi\)

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – 累積和操作的維度
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(10)
>>> a

-0.6039
-0.2214
-0.3705
-0.0169
 1.3415
-0.1230
 0.9719
 0.6081
-0.1286
 1.0947
[torch.FloatTensor of size 10]

>>> torch.cumsum(a, dim=0)

-0.6039
-0.8253
-1.1958
-1.2127
 0.1288
 0.0058
 0.9777
 1.5858
 1.4572
 2.5519
[torch.FloatTensor of size 10]

torch.dist

torch.dist(input, other, p=2, out=None) → Tensor

返回 (input - other) 的 p范數 。

參數:

  • input (Tensor) – 輸入張量
  • other (Tensor) – 右側輸入張量
  • p (float, optional) – 所計算的范數
  • out (Tensor, optional) – 結果張量

例子:

>>> x = torch.randn(4)
>>> x

 0.2505
-0.4571
-0.3733
 0.7807
[torch.FloatTensor of size 4]

>>> y = torch.randn(4)
>>> y

 0.7782
-0.5185
 1.4106
-2.4063
[torch.FloatTensor of size 4]

>>> torch.dist(x, y, 3.5)
3.302832063224223
>>> torch.dist(x, y, 3)
3.3677282206393286
>>> torch.dist(x, y, 0)
inf
>>> torch.dist(x, y, 1)
5.560028076171875

torch.mean

torch.mean(input) → float

返回輸入張量所有元素的均值。

參數: input (Tensor) – 輸入張量

例子:

>>> a = torch.randn(1, 3)
>>> a

-0.2946 -0.9143  2.1809
[torch.FloatTensor of size 1x3]

>>> torch.mean(a)
0.32398951053619385
torch.mean(input, dim, out=None) → Tensor

返回輸入張量給定維度dim上每行的均值。

輸出形狀與輸入相同,除了給定維度上為1.

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – the dimension to reduce
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(4, 4)
>>> a

-1.2738 -0.3058  0.1230 -1.9615
 0.8771 -0.5430 -0.9233  0.9879
 1.4107  0.0317 -0.6823  0.2255
-1.3854  0.4953 -0.2160  0.2435
[torch.FloatTensor of size 4x4]

>>> torch.mean(a, 1)

-0.8545
 0.0997
 0.2464
-0.2157
[torch.FloatTensor of size 4x1]

torch.median

torch.median(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

返回輸入張量給定維度每行的中位數,同時返回一個包含中位數的索引的LongTensor

dim值默認為輸入張量的最后一維。
輸出形狀與輸入相同,除了給定維度上為1.

注意: 這個函數還沒有在torch.cuda.Tensor中定義

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – 縮減的維度
  • values (Tensor, optional) – 結果張量
  • indices (Tensor, optional) – 返回的索引結果張量
>>> a

 -0.6891 -0.6662
 0.2697  0.7412
 0.5254 -0.7402
 0.5528 -0.2399
[torch.FloatTensor of size 4x2]

>>> a = torch.randn(4, 5)
>>> a

 0.4056 -0.3372  1.0973 -2.4884  0.4334
 2.1336  0.3841  0.1404 -0.1821 -0.7646
-0.2403  1.3975 -2.0068  0.1298  0.0212
-1.5371 -0.7257 -0.4871 -0.2359 -1.1724
[torch.FloatTensor of size 4x5]

>>> torch.median(a, 1)
(
 0.4056
 0.1404
 0.0212
-0.7257
[torch.FloatTensor of size 4x1]
,
 0
 2
 4
 1
[torch.LongTensor of size 4x1]
)

torch.mode

torch.mode(input, dim=-1, values=None, indices=None) -> (Tensor, LongTensor)

返回給定維dim上,每行的眾數值。 同時返回一個LongTensor,包含眾數職的索引。dim值默認為輸入張量的最后一維。

輸出形狀與輸入相同,除了給定維度上為1.

注意: 這個函數還沒有在torch.cuda.Tensor中定義

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – 縮減的維度
  • values (Tensor, optional) – 結果張量
  • indices (Tensor, optional) – 返回的索引張量

例子:

>>> a

 -0.6891 -0.6662
 0.2697  0.7412
 0.5254 -0.7402
 0.5528 -0.2399
[torch.FloatTensor of size 4x2]

>>> a = torch.randn(4, 5)
>>> a

 0.4056 -0.3372  1.0973 -2.4884  0.4334
 2.1336  0.3841  0.1404 -0.1821 -0.7646
-0.2403  1.3975 -2.0068  0.1298  0.0212
-1.5371 -0.7257 -0.4871 -0.2359 -1.1724
[torch.FloatTensor of size 4x5]

>>> torch.mode(a, 1)
(
-2.4884
-0.7646
-2.0068
-1.5371
[torch.FloatTensor of size 4x1]
,
 3
 4
 2
 0
[torch.LongTensor of size 4x1]
)

torch.norm

torch.norm(input, p=2) → float

返回輸入張量input 的p 范數。

參數:

  • input (Tensor) – 輸入張量
  • p (float,optional) – 范數計算中的冪指數值

例子:

>>> a = torch.randn(1, 3)
>>> a

-0.4376 -0.5328  0.9547
[torch.FloatTensor of size 1x3]

>>> torch.norm(a, 3)
1.0338925067372466
torch.norm(input, p, dim, out=None) → Tensor

返回輸入張量給定維dim 上每行的p 范數。
輸出形狀與輸入相同,除了給定維度上為1.

參數:

  • input (Tensor) – 輸入張量
  • p (float) – 范數計算中的冪指數值
  • dim (int) – 縮減的維度
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(4, 2)
>>> a

-0.6891 -0.6662
 0.2697  0.7412
 0.5254 -0.7402
 0.5528 -0.2399
[torch.FloatTensor of size 4x2]

>>> torch.norm(a, 2, 1)

 0.9585
 0.7888
 0.9077
 0.6026
[torch.FloatTensor of size 4x1]

>>> torch.norm(a, 0, 1)

 2
 2
 2
 2
[torch.FloatTensor of size 4x1]

torch.prod

torch.prod(input) → float

返回輸入張量input 所有元素的積。

參數:input (Tensor) – 輸入張量

例子:

>>> a = torch.randn(1, 3)
>>> a

 0.6170  0.3546  0.0253
[torch.FloatTensor of size 1x3]

>>> torch.prod(a)
0.005537458061418483
torch.prod(input, dim, out=None) → Tensor

返回輸入張量給定維度上每行的積。
輸出形狀與輸入相同,除了給定維度上為1.

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – 縮減的維度
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(4, 2)
>>> a

 0.1598 -0.6884
-0.1831 -0.4412
-0.9925 -0.6244
-0.2416 -0.8080
[torch.FloatTensor of size 4x2]

>>> torch.prod(a, 1)

-0.1100
 0.0808
 0.6197
 0.1952
[torch.FloatTensor of size 4x1]

torch.std

torch.std(input) → float

返回輸入張量input 所有元素的標準差。

參數:- input (Tensor) – 輸入張量

例子:

>>> a = torch.randn(1, 3)
>>> a

-1.3063  1.4182 -0.3061
[torch.FloatTensor of size 1x3]

>>> torch.std(a)
1.3782334731508061
torch.std(input, dim, out=None) → Tensor

返回輸入張量給定維度上每行的標準差。
輸出形狀與輸入相同,除了給定維度上為1.

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – 縮減的維度
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(4, 4)
>>> a

 0.1889 -2.4856  0.0043  1.8169
-0.7701 -0.4682 -2.2410  0.4098
 0.1919 -1.1856 -1.0361  0.9085
 0.0173  1.0662  0.2143 -0.5576
[torch.FloatTensor of size 4x4]

>>> torch.std(a, dim=1)

 1.7756
 1.1025
 1.0045
 0.6725
[torch.FloatTensor of size 4x1]

torch.sum

torch.sum(input) → float

返回輸入張量input 所有元素的和。

輸出形狀與輸入相同,除了給定維度上為1.

參數:

  • input (Tensor) – 輸入張量

例子:

>>> a = torch.randn(1, 3)
>>> a

 0.6170  0.3546  0.0253
[torch.FloatTensor of size 1x3]

>>> torch.sum(a)
0.9969287421554327
torch.sum(input, dim, out=None) → Tensor

返回輸入張量給定維度上每行的和。
輸出形狀與輸入相同,除了給定維度上為1.

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – 縮減的維度
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(4, 4)
>>> a

-0.4640  0.0609  0.1122  0.4784
-1.3063  1.6443  0.4714 -0.7396
-1.3561 -0.1959  1.0609 -1.9855
 2.6833  0.5746 -0.5709 -0.4430
[torch.FloatTensor of size 4x4]

>>> torch.sum(a, 1)

 0.1874
 0.0698
-2.4767
 2.2440
[torch.FloatTensor of size 4x1]

torch.var

torch.var(input) → float

返回輸入張量所有元素的方差

輸出形狀與輸入相同,除了給定維度上為1.

參數:

  • input (Tensor) – 輸入張量

例子:

>>> a = torch.randn(1, 3)
>>> a

-1.3063  1.4182 -0.3061
[torch.FloatTensor of size 1x3]

>>> torch.var(a)
1.899527506513334
torch.var(input, dim, out=None) → Tensor

返回輸入張量給定維度上每行的方差。
輸出形狀與輸入相同,除了給定維度上為1.

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – the dimension to reduce
  • out (Tensor, optional) – 結果張量
    例子:
>>> a = torch.randn(4, 4)
>>> a

-1.2738 -0.3058  0.1230 -1.9615
 0.8771 -0.5430 -0.9233  0.9879
 1.4107  0.0317 -0.6823  0.2255
-1.3854  0.4953 -0.2160  0.2435
[torch.FloatTensor of size 4x4]

>>> torch.var(a, 1)

 0.8859
 0.9509
 0.7548
 0.6949
[torch.FloatTensor of size 4x1]

比較操作 Comparison Ops

torch.eq

torch.eq(input, other, out=None) → Tensor

比較元素相等性。第二個參數可為一個數或與第一個參數同類型形狀的張量。

參數:

  • input (Tensor) – 待比較張量
  • other (Tensor or float) – 比較張量或數
  • out (Tensor, optional) – 輸出張量,須為 ByteTensor類型 or 與input同類型

返回值: 一個 torch.ByteTensor 張量,包含了每個位置的比較結果(相等為1,不等為0 )

返回類型: Tensor

例子:

>>> torch.eq(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
1  0
0  1
[torch.ByteTensor of size 2x2]

torch.equal

torch.equal(tensor1, tensor2) → bool

如果兩個張量有相同的形狀和元素值,則返回True ,否則 False

例子:

>>> torch.equal(torch.Tensor([1, 2]), torch.Tensor([1, 2]))
True

torch.ge

torch.ge(input, other, out=None) → Tensor

逐元素比較inputother,即是否 \( input >= other \)。

如果兩個張量有相同的形狀和元素值,則返回True ,否則 False
第二個參數可以為一個數或與第一個參數相同形狀和類型的張量

參數:

  • input (Tensor) – 待對比的張量
  • other (Tensor or float) – 對比的張量或float
  • out (Tensor, optional) – 輸出張量。必須為ByteTensor或者與第一個參數tensor相同類型。

返回值: 一個 torch.ByteTensor 張量,包含了每個位置的比較結果(是否 input >= other )。
返回類型: Tensor

例子:

>>> torch.ge(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
 1  1
 0  1
[torch.ByteTensor of size 2x2]

torch.gt

torch.gt(input, other, out=None) → Tensor

逐元素比較inputother , 即是否\( input > other \)
如果兩個張量有相同的形狀和元素值,則返回True ,否則 False
第二個參數可以為一個數或與第一個參數相同形狀和類型的張量

參數:

  • input (Tensor) – 要對比的張量
  • other (Tensor or float) – 要對比的張量或float
  • out (Tensor, optional) – 輸出張量。必須為ByteTensor或者與第一個參數tensor相同類型。

返回值: 一個 torch.ByteTensor 張量,包含了每個位置的比較結果(是否 input >= other )。
返回類型: Tensor

例子:

>>> torch.gt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
 0  1
 0  0
[torch.ByteTensor of size 2x2]

torch.kthvalue

torch.kthvalue(input, k, dim=None, out=None) -> (Tensor, LongTensor)

取輸入張量input指定維上第k 個最小值。如果不指定dim,則默認為input的最后一維。

返回一個元組 (values,indices),其中indices是原始輸入張量input中沿dim維的第 k 個最小值下標。

參數:

  • input (Tensor) – 要對比的張量
  • k (int) – 第 k 個最小值
  • dim (int, optional) – 沿著此維進行排序
  • out (tuple, optional) – 輸出元組 (Tensor, LongTensor) 可選地給定作為 輸出 buffers

例子:

>>> x = torch.arange(1, 6)
>>> x

 1
 2
 3
 4
 5
[torch.FloatTensor of size 5]

>>> torch.kthvalue(x, 4)
(
 4
[torch.FloatTensor of size 1]
,
 3
[torch.LongTensor of size 1]
)

torch.le

torch.le(input, other, out=None) → Tensor

逐元素比較inputother , 即是否\( input <= other \)
第二個參數可以為一個數或與第一個參數相同形狀和類型的張量

參數:

  • input (Tensor) – 要對比的張量
  • other (Tensor or float ) – 對比的張量或float
  • out (Tensor, optional) – 輸出張量。必須為ByteTensor或者與第一個參數tensor相同類型。

返回值: 一個 torch.ByteTensor 張量,包含了每個位置的比較結果(是否 input >= other )。
返回類型: Tensor

例子:

>>> torch.le(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
 1  0
 1  1
[torch.ByteTensor of size 2x2]

torch.lt

torch.lt(input, other, out=None) → Tensor

逐元素比較inputother , 即是否 \( input < other \)

第二個參數可以為一個數或與第一個參數相同形狀和類型的張量

參數:

  • input (Tensor) – 要對比的張量
  • other (Tensor or float ) – 對比的張量或float
  • out (Tensor, optional) – 輸出張量。必須為ByteTensor或者與第一個參數tensor相同類型。

input: 一個 torch.ByteTensor 張量,包含了每個位置的比較結果(是否 tensor >= other )。
返回類型: Tensor

例子:

>>> torch.lt(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
 0  0
 1  0
[torch.ByteTensor of size 2x2]

torch.max

torch.max()

返回輸入張量所有元素的最大值。

參數:

  • input (Tensor) – 輸入張量

例子:

>>> a = torch.randn(1, 3)
>>> a

 0.4729 -0.2266 -0.2085
[torch.FloatTensor of size 1x3]

>>> torch.max(a)
0.4729
torch.max(input, dim, max=None, max_indices=None) -> (Tensor, LongTensor)

返回輸入張量給定維度上每行的最大值,并同時返回每個最大值的位置索引。

輸出形狀中,將dim維設定為1,其它與輸入形狀保持一致。

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – 指定的維度
  • max (Tensor, optional) – 結果張量,包含給定維度上的最大值
  • max_indices (LongTensor, optional) – 結果張量,包含給定維度上每個最大值的位置索引

例子:

>> a = torch.randn(4, 4)
>> a

0.0692  0.3142  1.2513 -0.5428
0.9288  0.8552 -0.2073  0.6409
1.0695 -0.0101 -2.4507 -1.2230
0.7426 -0.7666  0.4862 -0.6628
torch.FloatTensor of size 4x4]

>>> torch.max(a, 1)
(
 1.2513
 0.9288
 1.0695
 0.7426
[torch.FloatTensor of size 4x1]
,
 2
 0
 0
 0
[torch.LongTensor of size 4x1]
)
torch.max(input, other, out=None) → Tensor

返回輸入張量給定維度上每行的最大值,并同時返回每個最大值的位置索引。
即,\( out_i=max(input_i,other_i) \)

輸出形狀中,將dim維設定為1,其它與輸入形狀保持一致。

參數:

  • input (Tensor) – 輸入張量
  • other (Tensor) – 輸出張量
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> b = torch.randn(4)
>>> b

 1.0067
-0.8010
 0.6258
 0.3627
[torch.FloatTensor of size 4]

>>> torch.max(a, b)

 1.3869
 0.3912
 0.6258
 0.3627
[torch.FloatTensor of size 4]

torch.min

torch.min(input) → float

返回輸入張量所有元素的最小值。

參數: input (Tensor) – 輸入張量

例子:

>>> a = torch.randn(1, 3)
>>> a

 0.4729 -0.2266 -0.2085
[torch.FloatTensor of size 1x3]

>>> torch.min(a)
-0.22663167119026184
torch.min(input, dim, min=None, min_indices=None) -> (Tensor, LongTensor)

返回輸入張量給定維度上每行的最小值,并同時返回每個最小值的位置索引。

輸出形狀中,將dim維設定為1,其它與輸入形狀保持一致。

參數:

  • input (Tensor) – 輸入張量
  • dim (int) – 指定的維度
  • min (Tensor, optional) – 結果張量,包含給定維度上的最小值
  • min_indices (LongTensor, optional) – 結果張量,包含給定維度上每個最小值的位置索引

例子:

>> a = torch.randn(4, 4)
>> a

0.0692  0.3142  1.2513 -0.5428
0.9288  0.8552 -0.2073  0.6409
1.0695 -0.0101 -2.4507 -1.2230
0.7426 -0.7666  0.4862 -0.6628
torch.FloatTensor of size 4x4]

>> torch.min(a, 1)

0.5428
0.2073
2.4507
0.7666
torch.FloatTensor of size 4x1]

3
2
2
1
torch.LongTensor of size 4x1]
torch.min(input, other, out=None) → Tensor

input中逐元素與other相應位置的元素對比,返回最小值到輸出張量。即,\( out_i = min(tensor_i, other_i)\)

兩張量形狀不需匹配,但元素數須相同。

注意:當形狀不匹配時,input的形狀作為返回張量的形狀。

參數:

  • input (Tensor) – 輸入張量
  • other (Tensor) – 第二個輸入張量
  • out (Tensor, optional) – 結果張量

例子:

>>> a = torch.randn(4)
>>> a

 1.3869
 0.3912
-0.8634
-0.5468
[torch.FloatTensor of size 4]

>>> b = torch.randn(4)
>>> b

 1.0067
-0.8010
 0.6258
 0.3627
[torch.FloatTensor of size 4]

>>> torch.min(a, b)

 1.0067
-0.8010
-0.8634
-0.5468
[torch.FloatTensor of size 4]

torch.ne

torch.ne(input, other, out=None) → Tensor

逐元素比較inputother , 即是否 \( input != other \)。
第二個參數可以為一個數或與第一個參數相同形狀和類型的張量

參數:

  • input (Tensor) – 待對比的張量
  • other (Tensor or float) – 對比的張量或float
  • out (Tensor, optional) – 輸出張量。必須為ByteTensor或者與input相同類型。

返回值: 一個 torch.ByteTensor 張量,包含了每個位置的比較結果 (如果 tensor != other 為True ,返回1)。

返回類型: Tensor

例子:

>>> torch.ne(torch.Tensor([[1, 2], [3, 4]]), torch.Tensor([[1, 1], [4, 4]]))
 0  1
 1  0
[torch.ByteTensor of size 2x2]

torch.sort

torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, LongTensor)

對輸入張量input沿著指定維按升序排序。如果不給定dim,則默認為輸入的最后一維。如果指定參數descendingTrue,則按降序排序

返回元組 (sorted_tensor, sorted_indices) , sorted_indices 為原始輸入中的下標。

參數:

  • input (Tensor) – 要對比的張量
  • dim (int, optional) – 沿著此維排序
  • descending (bool, optional) – 布爾值,控制升降排序
  • out (tuple, optional) – 輸出張量。必須為ByteTensor或者與第一個參數tensor相同類型。

例子:

>>> x = torch.randn(3, 4)
>>> sorted, indices = torch.sort(x)
>>> sorted

-1.6747  0.0610  0.1190  1.4137
-1.4782  0.7159  1.0341  1.3678
-0.3324 -0.0782  0.3518  0.4763
[torch.FloatTensor of size 3x4]

>>> indices

 0  1  3  2
 2  1  0  3
 3  1  0  2
[torch.LongTensor of size 3x4]

>>> sorted, indices = torch.sort(x, 0)
>>> sorted

-1.6747 -0.0782 -1.4782 -0.3324
 0.3518  0.0610  0.4763  0.1190
 1.0341  0.7159  1.4137  1.3678
[torch.FloatTensor of size 3x4]

>>> indices

 0  2  1  2
 2  0  2  0
 1  1  0  1
[torch.LongTensor of size 3x4]

torch.topk

torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor)

沿給定dim維度返回輸入張量input中 k 個最大值。
如果不指定dim,則默認為input的最后一維。
如果為largest為 False ,則返回最小的 k 個值。

返回一個元組 (values,indices),其中indices是原始輸入張量input中測元素下標。
如果設定布爾值sorted 為_True_,將會確保返回的 k 個值被排序。

參數:

  • input (Tensor) – 輸入張量
  • k (int) – “top-k”中的k
  • dim (int, optional) – 排序的維
  • largest (bool, optional) – 布爾值,控制返回最大或最小值
  • sorted (bool, optional) – 布爾值,控制返回值是否排序
  • out (tuple, optional) – 可選輸出張量 (Tensor, LongTensor) output buffers
>>> x = torch.arange(1, 6)
>>> x

 1
 2
 3
 4
 5
[torch.FloatTensor of size 5]

>>> torch.topk(x, 3)
(
 5
 4
 3
[torch.FloatTensor of size 3]
,
 4
 3
 2
[torch.LongTensor of size 3]
)
>>> torch.topk(x, 3, 0, largest=False)
(
 1
 2
 3
[torch.FloatTensor of size 3]
,
 0
 1
 2
[torch.LongTensor of size 3]
)

其它操作 Other Operations

torch.cross

torch.cross(input, other, dim=-1, out=None) → Tensor

返回沿著維度dim上,兩個張量inputother的向量積(叉積)。
inputother 必須有相同的形狀,且指定的dim維上size必須為3

如果不指定dim,則默認為第一個尺度為3的維。

參數:

  • input (Tensor) – 輸入張量
  • other (Tensor) – 第二個輸入張量
  • dim (int, optional) – 沿著此維進行叉積操作
  • out (Tensor,optional) – 結果張量

例子:

>>> a = torch.randn(4, 3)
>>> a

-0.6652 -1.0116 -0.6857
 0.2286  0.4446 -0.5272
 0.0476  0.2321  1.9991
 0.6199  1.1924 -0.9397
[torch.FloatTensor of size 4x3]

>>> b = torch.randn(4, 3)
>>> b

-0.1042 -1.1156  0.1947
 0.9947  0.1149  0.4701
-1.0108  0.8319 -0.0750
 0.9045 -1.3754  1.0976
[torch.FloatTensor of size 4x3]

>>> torch.cross(a, b, dim=1)

-0.9619  0.2009  0.6367
 0.2696 -0.6318 -0.4160
-1.6805 -2.0171  0.2741
 0.0163 -1.5304 -1.9311
[torch.FloatTensor of size 4x3]

>>> torch.cross(a, b)

-0.9619  0.2009  0.6367
 0.2696 -0.6318 -0.4160
-1.6805 -2.0171  0.2741
 0.0163 -1.5304 -1.9311
[torch.FloatTensor of size 4x3]

torch.diag

torch.diag(input, diagonal=0, out=None) → Tensor
  • 如果輸入是一個向量(1D 張量),則返回一個以input為對角線元素的2D方陣
  • 如果輸入是一個矩陣(2D 張量),則返回一個包含input對角線元素的1D張量

參數diagonal指定對角線:

  • diagonal = 0, 主對角線
  • diagonal > 0, 主對角線之上
  • diagonal < 0, 主對角線之下

參數:

  • input (Tensor) – 輸入張量
  • diagonal (int, optional) – 指定對角線
  • out (Tensor, optional) – 輸出張量

例子:

  • 取得以input為對角線的方陣:
>>> a = torch.randn(3)
>>> a

 1.0480
-2.3405
-1.1138
[torch.FloatTensor of size 3]

>>> torch.diag(a)

 1.0480  0.0000  0.0000
 0.0000 -2.3405  0.0000
 0.0000  0.0000 -1.1138
[torch.FloatTensor of size 3x3]

>>> torch.diag(a, 1)

 0.0000  1.0480  0.0000  0.0000
 0.0000  0.0000 -2.3405  0.0000
 0.0000  0.0000  0.0000 -1.1138
 0.0000  0.0000  0.0000  0.0000
[torch.FloatTensor of size 4x4]
  • 取得給定矩陣第k個對角線:
>>> a = torch.randn(3, 3)
>>> a

-1.5328 -1.3210 -1.5204
 0.8596  0.0471 -0.2239
-0.6617  0.0146 -1.0817
[torch.FloatTensor of size 3x3]

>>> torch.diag(a, 0)

-1.5328
 0.0471
-1.0817
[torch.FloatTensor of size 3]

>>> torch.diag(a, 1)

-1.3210
-0.2239
[torch.FloatTensor of size 2]

torch.histc

torch.histc(input, bins=100, min=0, max=0, out=None) → Tensor

計算輸入張量的直方圖。以minmax為range邊界,將其均分成bins個直條,然后將排序好的數據劃分到各個直條(bins)中。如果minmax都為0, 則利用數據中的最大最小值作為邊界。

參數:

  • input (Tensor) – 輸入張量
  • bins (int) – 直方圖 bins(直條)的個數(默認100個)
  • min (int) – range的下邊界(包含)
  • max (int) – range的上邊界(包含)
  • out (Tensor, optional) – 結果張量

返回: 直方圖
返回類型:張量

例子:

>>> torch.histc(torch.FloatTensor([1, 2, 1]), bins=4, min=0, max=3)
FloatTensor([0, 2, 1, 0])

torch.renorm

torch.renorm(input, p, dim, maxnorm, out=None) → Tensor

返回一個張量,包含規范化后的各個子張量,使得沿著dim維劃分的各子張量的p范數小于maxnorm

注意 如果p范數的值小于maxnorm,則當前子張量不需要修改。

注意: 更詳細解釋參考torch7 以及Hinton et al. 2012, p. 2

參數:

  • input (Tensor) – 輸入張量
  • p (float) – 范數的p
  • dim (int) – 沿著此維切片,得到張量子集
  • maxnorm (float) – 每個子張量的范數的最大值
  • out (Tensor, optional) – 結果張量

例子:

>>> x = torch.ones(3, 3)
>>> x[1].fill_(2)
>>> x[2].fill_(3)
>>> x

 1  1  1
 2  2  2
 3  3  3
[torch.FloatTensor of size 3x3]

>>> torch.renorm(x, 1, 0, 5)

 1.0000  1.0000  1.0000
 1.6667  1.6667  1.6667
 1.6667  1.6667  1.6667
[torch.FloatTensor of size 3x3]

torch.trace

torch.trace(input) → float

返回輸入2維矩陣對角線元素的和(跡)

例子:

>>> x = torch.arange(1, 10).view(3, 3)
>>> x

 1  2  3
 4  5  6
 7  8  9
[torch.FloatTensor of size 3x3]

>>> torch.trace(x)
15.0

torch.tril

torch.tril(input, k=0, out=None) → Tensor

返回一個張量out,包含輸入矩陣(2D張量)的下三角部分,out其余部分被設為0。這里所說的下三角部分為矩陣指定對角線diagonal之上的元素。

參數k控制對角線:
k = 0, 主對角線
k > 0, 主對角線之上
k < 0, 主對角線之下

參數:

  • input (Tensor) – 輸入張量
  • k (int, optional) – 指定對角線
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(3,3)
>>> a

 1.3225  1.7304  1.4573
-0.3052 -0.3111 -0.1809
 1.2469  0.0064 -1.6250
[torch.FloatTensor of size 3x3]

>>> torch.tril(a)

 1.3225  0.0000  0.0000
-0.3052 -0.3111  0.0000
 1.2469  0.0064 -1.6250
[torch.FloatTensor of size 3x3]

>>> torch.tril(a, k=1)

 1.3225  1.7304  0.0000
-0.3052 -0.3111 -0.1809
 1.2469  0.0064 -1.6250
[torch.FloatTensor of size 3x3]

>>> torch.tril(a, k=-1)

 0.0000  0.0000  0.0000
-0.3052  0.0000  0.0000
 1.2469  0.0064  0.0000
[torch.FloatTensor of size 3x3]

torch.triu

torch.triu(input, k=0, out=None) → Tensor

返回一個張量,包含輸入矩陣(2D張量)的上三角部分,其余部分被設為0。這里所說的上三角部分為矩陣指定對角線diagonal之上的元素。

參數k控制對角線:
k = 0, 主對角線
k > 0, 主對角線之上
k < 0, 主對角線之下

參數:

  • input (Tensor) – 輸入張量
  • k (int, optional) – 指定對角線
  • out (Tensor, optional) – 輸出張量

例子:

>>> a = torch.randn(3,3)
>>> a

 1.3225  1.7304  1.4573
-0.3052 -0.3111 -0.1809
 1.2469  0.0064 -1.6250
[torch.FloatTensor of size 3x3]

>>> torch.triu(a)

 1.3225  1.7304  1.4573
 0.0000 -0.3111 -0.1809
 0.0000  0.0000 -1.6250
[torch.FloatTensor of size 3x3]

>>> torch.triu(a, k=1)

 0.0000  1.7304  1.4573
 0.0000  0.0000 -0.1809
 0.0000  0.0000  0.0000
[torch.FloatTensor of size 3x3]

>>> torch.triu(a, k=-1)

 1.3225  1.7304  1.4573
-0.3052 -0.3111 -0.1809
 0.0000  0.0064 -1.6250
[torch.FloatTensor of size 3x3]

BLAS and LAPACK Operations

torch.addbmm

torch.addbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor

對兩個批batch1batch2內存儲的矩陣進行批矩陣乘操作,附帶reduced add 步驟( 所有矩陣乘結果沿著第一維相加)。矩陣mat加到最終結果。
batch1和 batch2都為包含相同數量矩陣的3維張量。
如果batch1是形為\(b\times n \times m \)的張量,batch1是形為\(b\times m \times p \)的張量,則outmat的形狀都是\(n \times p \),即 \( res=(beta?M)+(alpha?sum([email protected]_i,i=0,b)) \)

對類型為 FloatTensor 或 DoubleTensor 的輸入,alphaand beta必須為實數,否則兩個參數須為整數。

參數:

  • beta (Number, optional) – 用于mat的乘子
  • mat (Tensor) – 相加矩陣
  • alpha (Number, optional) – 用于\(batch1 @ batch2 \)的乘子
  • batch1 (Tensor) – 第一批相乘矩陣
  • batch2 (Tensor) – 第二批相乘矩陣
  • out (Tensor, optional) – 輸出張量

例子:

>>> M = torch.randn(3, 5)
>>> batch1 = torch.randn(10, 3, 4)
>>> batch2 = torch.randn(10, 4, 5)
>>> torch.addbmm(M, batch1, batch2)

 -3.1162  11.0071   7.3102   0.1824  -7.6892
  1.8265   6.0739   0.4589  -0.5641  -5.4283
 -9.3387  -0.1794  -1.2318  -6.8841  -4.7239
[torch.FloatTensor of size 3x5]

torch.addmm

torch.addmm(beta=1, mat, alpha=1, mat1, mat2, out=None) → Tensor

對矩陣mat1mat2進行矩陣乘操作。矩陣mat加到最終結果。如果mat1 是一個 \(n \times m \)張量,mat2 是一個 \(m \times p \)張量,那么outmat的形狀為\(n \times p \)。
alpha 和 beta 分別是兩個矩陣 \(mat1 @ mat2 \)和\(mat \)的比例因子,即, \(out=(beta?M)+([email protected]) \)

對類型為 FloatTensor 或 DoubleTensor 的輸入,betaand alpha必須為實數,否則兩個參數須為整數。

參數 :

  • beta (Number, optional) – 用于mat的乘子
  • mat (Tensor) – 相加矩陣
  • alpha (Number, optional) – 用于\(mat1 @ mat2 \)的乘子
  • mat1 (Tensor) – 第一個相乘矩陣
  • mat2 (Tensor) – 第二個相乘矩陣
  • out (Tensor, optional) – 輸出張量
>>> M = torch.randn(2, 3)
>>> mat1 = torch.randn(2, 3)
>>> mat2 = torch.randn(3, 3)
>>> torch.addmm(M, mat1, mat2)

-0.4095 -1.9703  1.3561
 5.7674 -4.9760  2.7378
[torch.FloatTensor of size 2x3]

torch.addmv

torch.addmv(beta=1, tensor, alpha=1, mat, vec, out=None) → Tensor

對矩陣mat和向量vec對進行相乘操作。向量tensor加到最終結果。如果mat 是一個 \(n \times m \)維矩陣,vec 是一個 \(m \)維向量,那么outmat的為\(n \)元向量。
可選參數_alpha_ 和 beta 分別是 \(mat * vec \)和\(mat \)的比例因子,即, \( out=(beta?tensor)+(alpha?([email protected])) \)

對類型為_FloatTensor_或_DoubleTensor_的輸入,alphaand beta必須為實數,否則兩個參數須為整數。

參數 :

  • beta (Number, optional) – 用于mat的乘子
  • mat (Tensor) – 相加矩陣
  • alpha (Number, optional) – 用于\(mat1 @ vec \)的乘子
  • mat (Tensor) – 相乘矩陣
  • vec (Tensor) – 相乘向量
  • out (Tensor, optional) – 輸出張量
>>> M = torch.randn(2)
>>> mat = torch.randn(2, 3)
>>> vec = torch.randn(3)
>>> torch.addmv(M, mat, vec)

-2.0939
-2.2950
[torch.FloatTensor of size 2]

torch.addr

torch.addr(beta=1, mat, alpha=1, vec1, vec2, out=None) → Tensor

對向量vec1vec2對進行張量積操作。矩陣mat加到最終結果。如果vec1 是一個 \(n \)維向量,vec2 是一個 \(m \)維向量,那么矩陣mat的形狀須為\(n \times m \)。
可選參數_beta_ 和 alpha 分別是兩個矩陣 \(mat \)和 \(vec1 @ vec2 \)的比例因子,即,\( resi=(beta?Mi)+(alpha?batch1i×batch2i)\)

對類型為_FloatTensor_或_DoubleTensor_的輸入,alphaand beta必須為實數,否則兩個參數須為整數。

參數 :

  • beta (Number, optional) – 用于mat的乘子
  • mat (Tensor) – 相加矩陣
  • alpha (Number, optional) – 用于兩向量\(vec1, vec2 \)外積的乘子
  • vec1 (Tensor) – 第一個相乘向量
  • vec2 (Tensor) – 第二個相乘向量
  • out (Tensor, optional) – 輸出張量
>>> vec1 = torch.arange(1, 4)
>>> vec2 = torch.arange(1, 3)
>>> M = torch.zeros(3, 2)
>>> torch.addr(M, vec1, vec2)
 1  2
 2  4
 3  6
[torch.FloatTensor of size 3x2]

torch.baddbmm

torch.baddbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor

對兩個批batch1batch2內存儲的矩陣進行批矩陣乘操作,矩陣mat加到最終結果。
batch1和 batch2都為包含相同數量矩陣的3維張量。
如果batch1是形為\(b\times n \times m \)的張量,batch1是形為\(b\times m \times p \)的張量,則outmat的形狀都是\(n \times p \),即 \( resi=(beta?M_i)+(alpha?batch1_i×batch2_i) \)

對類型為_FloatTensor_或_DoubleTensor_的輸入,alphaand beta必須為實數,否則兩個參數須為整數。

參數:

  • beta (Number, optional) – 用于mat的乘子
  • mat (Tensor) – 相加矩陣
  • alpha (Number, optional) – 用于\(batch1 @ batch2 \)的乘子
  • batch1 (Tensor) – 第一批相乘矩陣
  • batch2 (Tensor) – 第二批相乘矩陣
  • out (Tensor, optional) – 輸出張量
>>> M = torch.randn(10, 3, 5)
>>> batch1 = torch.randn(10, 3, 4)
>>> batch2 = torch.randn(10, 4, 5)
>>> torch.baddbmm(M, batch1, batch2).size()
torch.Size([10, 3, 5])

torch.bmm

torch.bmm(batch1, batch2, out=None) → Tensor

對存儲在兩個批batch1batch2內的矩陣進行批矩陣乘操作。batch1和 batch2都為包含相同數量矩陣的3維張量。
如果batch1是形為\(b\times n \times m \)的張量,batch1是形為\(b\times m \times p \)的張量,則outmat的形狀都是\(n \times p \),即 \( res=(beta?M)+(alpha?sum([email protected]_i,i=0,b)) \)

對類型為 FloatTensor 或 DoubleTensor 的輸入,alphaand beta必須為實數,否則兩個參數須為整數。

參數:

  • batch1 (Tensor) – 第一批相乘矩陣
  • batch2 (Tensor) – 第二批相乘矩陣
  • out (Tensor, optional) – 輸出張量
>>> batch1 = torch.randn(10, 3, 4)
>>> batch2 = torch.randn(10, 4, 5)
>>> res = torch.bmm(batch1, batch2)
>>> res.size()
torch.Size([10, 3, 5])

torch.btrifact

torch.btrifact(A, info=None) → Tensor, IntTensor

返回一個元組,包含LU 分解和pivots 。 可選參數info決定是否對每個minibatch樣本進行分解。info are from dgetrf and a non-zero value indicates an error occurred. 如果用CUDA的話,這個值來自于CUBLAS,否則來自LAPACK。

參數: A (Tensor) – 待分解張量

>>> A = torch.randn(2, 3, 3)
>>> A_LU = A.btrifact()

torch.btrisolve

torch.btrisolve(b, LU_data, LU_pivots) → Tensor

返回線性方程組\( Ax = b \)的LU解。

參數:

  • b (Tensor) – RHS 張量.
  • LU_data (Tensor) – Pivoted LU factorization of A from btrifact.
  • LU_pivots (IntTensor) – LU 分解的Pivots.

例子:

>>> A = torch.randn(2, 3, 3)
>>> b = torch.randn(2, 3)
>>> A_LU = torch.btrifact(A)
>>> x = b.btrisolve(*A_LU)
>>> torch.norm(A.bmm(x.unsqueeze(2)) - b)
6.664001874625056e-08

torch.dot

torch.dot(tensor1, tensor2) → float

計算兩個張量的點乘(內乘),兩個張量都為1-D 向量.

例子:

>>> torch.dot(torch.Tensor([2, 3]), torch.Tensor([2, 1]))
7.0

torch.eig

torch.eig(a, eigenvectors=False, out=None) -> (Tensor, Tensor)

計算實方陣a 的特征值和特征向量

參數:

  • a (Tensor) – 方陣,待計算其特征值和特征向量
  • eigenvectors (bool) – 布爾值,如果True,則同時計算特征值和特征向量,否則只計算特征值。
  • out (tuple, optional) – 輸出元組

返回值: 元組,包括:

  • e (Tensor): a 的右特征向量
  • v (Tensor): 如果eigenvectorsTrue,則為包含特征向量的張量; 否則為空張量

返回值類型: (Tensor, Tensor)

torch.gels

torch.gels(B, A, out=None) → Tensor

對形如\( m \times n \)的滿秩矩陣a計算其最小二乘和最小范數問題的解。
如果\( m >= n \),gels對最小二乘問題進行求解,即:
$$minimize \qquad ‖AX - B‖_F $$

如果\( m < n \),gels求解最小范數問題,即:
$$minimize \qquad ‖ X ‖_F \qquad subject \ to \quad a \quad b AX=B $$

返回矩陣\(X \)的前\(n \) 行包含解。余下的行包含以下殘差信息: 相應列從第n 行開始計算的每列的歐式距離。

注意: 返回矩陣總是被轉置,無論輸入矩陣的原始布局如何,總會被轉置;即,總是有 stride (1, m) 而不是 (m, 1).

參數:

  • B (Tensor) – 矩陣B
  • A (Tensor) – \( m \times n \)矩陣
  • out (tuple, optional) – 輸出元組

返回值: 元組,包括:

  • X (Tensor): 最小二乘解
  • qr (Tensor): QR 分解的細節

返回值類型: (Tensor, Tensor)

例子:

>>> A = torch.Tensor([[1, 1, 1],
...                   [2, 3, 4],
...                   [3, 5, 2],
...                   [4, 2, 5],
...                   [5, 4, 3]])
>>> B = torch.Tensor([[-10, -3],
                      [ 12, 14],
                      [ 14, 12],
                      [ 16, 16],
                      [ 18, 16]])
>>> X, _ = torch.gels(B, A)
>>> X
2.0000  1.0000
1.0000  1.0000
1.0000  2.0000
[torch.FloatTensor of size 3x2]

torch.geqrf

torch.geqrf(input, out=None) -> (Tensor, Tensor)

這是一個直接調用LAPACK的底層函數。
一般使用torch.qr()

計算輸入的QR 分解,但是并不會分別創建Q,R兩個矩陣,而是直接調用LAPACK 函數
Rather, this directly calls the underlying LAPACK function ?geqrf which produces a sequence of ‘elementary reflectors’.

參考 LAPACK文檔獲取更詳細信息。

參數:

  • input (Tensor) – 輸入矩陣
  • out (tuple, optional) – 元組,包含輸出張量 (Tensor, Tensor)

torch.ger

torch.ger(vec1, vec2, out=None) → Tensor

計算兩向量vec1,vec2的張量積。如果vec1的長度為n,vec2長度為m,則輸出out應為形如n x m的矩陣。

參數:

  • vec1 (Tensor) – 1D 輸入向量
  • vec2 (Tensor) – 1D 輸入向量
  • out (tuple, optional) – 輸出張量

例子:

>>> v1 = torch.arange(1, 5)
>>> v2 = torch.arange(1, 4)
>>> torch.ger(v1, v2)

  1   2   3
  2   4   6
  3   6   9
  4   8  12
[torch.FloatTensor of size 4x3]

torch.gesv

torch.gesv(B, A, out=None) -> (Tensor, Tensor)

\( X, LU = torch.gesv(B, A) \),返回線性方程組\(AX=B \)的解。

LU 包含兩個矩陣L,U。A須為非奇異方陣,如果A是一個\( m \times m \)矩陣,B 是\( m \times k \)矩陣,則LU 是\( m \times m \)矩陣, X為\( m \times k \)矩陣

參數:

  • B (Tensor) – \( m \times k \)矩陣
  • A (Tensor) – \( m \times m \)矩陣
  • out (Tensor, optional) – 可選地輸出矩陣\( X \)

例子:

>>> A = torch.Tensor([[6.80, -2.11,  5.66,  5.97,  8.23],
...                   [-6.05, -3.30,  5.36, -4.44,  1.08],
...                   [-0.45,  2.58, -2.70,  0.27,  9.04],
...                   [8.32,  2.71,  4.35,  -7.17,  2.14],
...                   [-9.67, -5.14, -7.26,  6.08, -6.87]]).t()
>>> B = torch.Tensor([[4.02,  6.19, -8.22, -7.57, -3.03],
...                   [-1.56,  4.00, -8.67,  1.75,  2.86],
...                   [9.81, -4.09, -4.57, -8.61,  8.99]]).t()
>>> X, LU = torch.gesv(B, A)
>>> torch.dist(B, torch.mm(A, X))
9.250057093890353e-06

torch.inverse

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

對方陣輸入input 取逆。

注意 : Irrespective of the original strides, the returned matrix will be transposed, i.e. with strides (1, m) instead of (m, 1)

參數 :

  • input (Tensor) – 輸入2維張量
  • out (Tensor, optional) – 輸出張量

例子:

>>> x = torch.rand(10, 10)
>>> x

 0.7800  0.2267  0.7855  0.9479  0.5914  0.7119  0.4437  0.9131  0.1289  0.1982
 0.0045  0.0425  0.2229  0.4626  0.6210  0.0207  0.6338  0.7067  0.6381  0.8196
 0.8350  0.7810  0.8526  0.9364  0.7504  0.2737  0.0694  0.5899  0.8516  0.3883
 0.6280  0.6016  0.5357  0.2936  0.7827  0.2772  0.0744  0.2627  0.6326  0.9153
 0.7897  0.0226  0.3102  0.0198  0.9415  0.9896  0.3528  0.9397  0.2074  0.6980
 0.5235  0.6119  0.6522  0.3399  0.3205  0.5555  0.8454  0.3792  0.4927  0.6086
 0.1048  0.0328  0.5734  0.6318  0.9802  0.4458  0.0979  0.3320  0.3701  0.0909
 0.2616  0.3485  0.4370  0.5620  0.5291  0.8295  0.7693  0.1807  0.0650  0.8497
 0.1655  0.2192  0.6913  0.0093  0.0178  0.3064  0.6715  0.5101  0.2561  0.3396
 0.4370  0.4695  0.8333  0.1180  0.4266  0.4161  0.0699  0.4263  0.8865  0.2578
[torch.FloatTensor of size 10x10]

>>> x = torch.rand(10, 10)
>>> y = torch.inverse(x)
>>> z = torch.mm(x, y)
>>> z

 1.0000  0.0000  0.0000 -0.0000  0.0000  0.0000  0.0000  0.0000 -0.0000 -0.0000
 0.0000  1.0000 -0.0000  0.0000  0.0000  0.0000 -0.0000 -0.0000 -0.0000 -0.0000
 0.0000  0.0000  1.0000 -0.0000 -0.0000  0.0000  0.0000  0.0000 -0.0000 -0.0000
 0.0000  0.0000  0.0000  1.0000  0.0000  0.0000  0.0000 -0.0000 -0.0000  0.0000
 0.0000  0.0000 -0.0000 -0.0000  1.0000  0.0000  0.0000 -0.0000 -0.0000 -0.0000
 0.0000  0.0000  0.0000 -0.0000  0.0000  1.0000 -0.0000 -0.0000 -0.0000 -0.0000
 0.0000  0.0000  0.0000 -0.0000  0.0000  0.0000  1.0000  0.0000 -0.0000  0.0000
 0.0000  0.0000 -0.0000 -0.0000  0.0000  0.0000 -0.0000  1.0000 -0.0000  0.0000
-0.0000  0.0000 -0.0000 -0.0000  0.0000  0.0000 -0.0000 -0.0000  1.0000 -0.0000
-0.0000  0.0000 -0.0000 -0.0000 -0.0000  0.0000 -0.0000 -0.0000  0.0000  1.0000
[torch.FloatTensor of size 10x10]

>>> torch.max(torch.abs(z - torch.eye(10))) # Max nonzero
5.096662789583206e-07

torch.mm

torch.mm(mat1, mat2, out=None) → Tensor

對矩陣mat1mat2進行相乘。 如果mat1 是一個\( n \times m \) 張量,mat2 是一個 \( m \times p \) 張量,將會輸出一個 \( n \times p \) 張量out

參數 :

  • mat1 (Tensor) – 第一個相乘矩陣
  • mat2 (Tensor) – 第二個相乘矩陣
  • out (Tensor, optional) – 輸出張量

例子:

>>> mat1 = torch.randn(2, 3)
>>> mat2 = torch.randn(3, 3)
>>> torch.mm(mat1, mat2)
 0.0519 -0.3304  1.2232
 4.3910 -5.1498  2.7571
[torch.FloatTensor of size 2x3]

torch.mv

torch.mv(mat, vec, out=None) → Tensor

對矩陣mat和向量vec進行相乘。 如果mat 是一個\( n \times m \)張量,vec 是一個\( m \)元 1維張量,將會輸出一個\( n \) 元 1維張量。

參數 :

  • mat (Tensor) – 相乘矩陣
  • vec (Tensor) – 相乘向量
  • out (Tensor, optional) – 輸出張量

例子:

>>> mat = torch.randn(2, 3)
>>> vec = torch.randn(3)
>>> torch.mv(mat, vec)
-2.0939
-2.2950
[torch.FloatTensor of size 2]

torch.orgqr

torch.orgqr()

torch.ormqr

torch.ormqr()

torch.potrf

torch.potrf()

torch.potri

torch.potri()

torch.potrs

torch.potrs()

torch.pstrf

torch.pstrf()

torch.qr

torch.qr(input, out=None) -> (Tensor, Tensor)

計算輸入矩陣的QR分解:返回兩個矩陣\( q \) ,\( r \), 使得 \( x=q?r \) ,這里\( q \) 是一個半正交矩陣與 \( r \) 是一個上三角矩陣

本函數返回一個thin(reduced)QR分解。

注意 如果輸入很大,可能可能會丟失精度。

注意 本函數依賴于你的LAPACK實現,雖然總能返回一個合法的分解,但不同平臺可能得到不同的結果。

Irrespective of the original strides, the returned matrix q will be transposed, i.e. with strides (1, m) instead of (m, 1).

參數:

  • input (Tensor) – 輸入的2維張量
  • out (tuple, optional) – 輸出元組tuple,包含Q和R

例子:

>>> a = torch.Tensor([[12, -51, 4], [6, 167, -68], [-4, 24, -41]])
>>> q, r = torch.qr(a)
>>> q

-0.8571  0.3943  0.3314
-0.4286 -0.9029 -0.0343
 0.2857 -0.1714  0.9429
[torch.FloatTensor of size 3x3]

>>> r

 -14.0000  -21.0000   14.0000
   0.0000 -175.0000   70.0000
   0.0000    0.0000  -35.0000
[torch.FloatTensor of size 3x3]

>>> torch.mm(q, r).round()

  12  -51    4
   6  167  -68
  -4   24  -41
[torch.FloatTensor of size 3x3]

>>> torch.mm(q.t(), q).round()

 1 -0  0
-0  1  0
 0  0  1
[torch.FloatTensor of size 3x3]

torch.svd

torch.svd(input, some=True, out=None) -> (Tensor, Tensor, Tensor)

\(U, S, V = torch.svd(A) \)。 返回對形如 \(n \times m \)的實矩陣 A 進行奇異值分解的結果,使得 \(A=USV′? \)。
\(U \) 形狀為 \(n \times n \),\(S \) 形狀為 \(n \times m \) ,\(V \) 形狀為 \(m \times m \)

some 代表了需要計算的奇異值數目。如果 some=True, it computes some and some=False computes all.

Irrespective of the original strides, the returned matrix U will be transposed, i.e. with strides (1, n) instead of (n, 1).

參數:

  • input (Tensor) – 輸入的2維張量
  • some (bool, optional) – 布爾值,控制需計算的奇異值數目
  • out (tuple, optional) – 結果tuple

例子:

>>> a = torch.Tensor([[8.79,  6.11, -9.15,  9.57, -3.49,  9.84],
...                   [9.93,  6.91, -7.93,  1.64,  4.02,  0.15],
...                   [9.83,  5.04,  4.86,  8.83,  9.80, -8.99],
...                   [5.45, -0.27,  4.85,  0.74, 10.00, -6.02],
...                   [3.16,  7.98,  3.01,  5.80,  4.27, -5.31]]).t()
>>> a

  8.7900   9.9300   9.8300   5.4500   3.1600
  6.1100   6.9100   5.0400  -0.2700   7.9800
 -9.1500  -7.9300   4.8600   4.8500   3.0100
  9.5700   1.6400   8.8300   0.7400   5.8000
 -3.4900   4.0200   9.8000  10.0000   4.2700
  9.8400   0.1500  -8.9900  -6.0200  -5.3100
[torch.FloatTensor of size 6x5]

>>> u, s, v = torch.svd(a)
>>> u

-0.5911  0.2632  0.3554  0.3143  0.2299
-0.3976  0.2438 -0.2224 -0.7535 -0.3636
-0.0335 -0.6003 -0.4508  0.2334 -0.3055
-0.4297  0.2362 -0.6859  0.3319  0.1649
-0.4697 -0.3509  0.3874  0.1587 -0.5183
 0.2934  0.5763 -0.0209  0.3791 -0.6526
[torch.FloatTensor of size 6x5]

>>> s

 27.4687
 22.6432
  8.5584
  5.9857
  2.0149
[torch.FloatTensor of size 5]

>>> v

-0.2514  0.8148 -0.2606  0.3967 -0.2180
-0.3968  0.3587  0.7008 -0.4507  0.1402
-0.6922 -0.2489 -0.2208  0.2513  0.5891
-0.3662 -0.3686  0.3859  0.4342 -0.6265
-0.4076 -0.0980 -0.4932 -0.6227 -0.4396
[torch.FloatTensor of size 5x5]

>>> torch.dist(a, torch.mm(torch.mm(u, torch.diag(s)), v.t()))
8.934150226306685e-06

torch.symeig

torch.symeig(input, eigenvectors=False, upper=True, out=None) -> (Tensor, Tensor)

\(e, V = torch.symeig(input)\) 返回實對稱矩陣input的特征值和特征向量。

\(input\) 和 \(V\) 為 \(m \times m\) 矩陣,\(e \) 是一個\(m\) 維向量。
此函數計算intput的所有特征值(和特征向量),使得 \(input = V diag(e) V’\)
布爾值參數eigenvectors 規定是否只計算特征向量。如果為False,則只計算特征值;若設為True,則兩者都會計算。
因為輸入矩陣 \( input\) 是對稱的,所以默認只需要上三角矩陣。如果參數upper為 False,下三角矩陣部分也被利用。

注意: 不管原來Irrespective of the original strides, the returned matrix V will be transposed, i.e. with strides (1, m) instead of (m, 1)

參數:

  • input (Tensor) – 輸入對稱矩陣
  • eigenvectors (boolean, optional) – 布爾值(可選),控制是否計算特征向量
  • upper (boolean, optional) – 布爾值(可選),控制是否考慮上三角或下三角區域
  • out (tuple, optional) – 輸出元組(Tensor, Tensor)

例子:

>>> a = torch.Tensor([[ 1.96,  0.00,  0.00,  0.00,  0.00],
...                   [-6.49,  3.80,  0.00,  0.00,  0.00],
...                   [-0.47, -6.39,  4.17,  0.00,  0.00],
...                   [-7.20,  1.50, -1.51,  5.70,  0.00],
...                   [-0.65, -6.34,  2.67,  1.80, -7.10]]).t()

>>> e, v = torch.symeig(a, eigenvectors=True)
>>> e

-11.0656
 -6.2287
  0.8640
  8.8655
 16.0948
[torch.FloatTensor of size 5]

>>> v

-0.2981 -0.6075  0.4026 -0.3745  0.4896
-0.5078 -0.2880 -0.4066 -0.3572 -0.6053
-0.0816 -0.3843 -0.6600  0.5008  0.3991
-0.0036 -0.4467  0.4553  0.6204 -0.4564
-0.8041  0.4480  0.1725  0.3108  0.1622
[torch.FloatTensor of size 5x5]

torch.trtrs

 torch.trtrs()

艾伯特(http://www.aibbt.com/)國內第一家人工智能門戶

PyTorch官方中文文檔:torch

標簽:python3.5   end   連接   不包含   dev   tuple   long   判斷   情況   

原文地址:https://www.cnblogs.com/aibbt/p/8538661.html

(0)
(2)
   
舉報
評論 一句話評論(0
0條  
登錄后才能評論!
? 2014 mamicode.com 版權所有 京ICP備13008772號-2
迷上了代碼!
25选5历史开奖结果百度