torch · PyTorch中文文檔

# torch **torch** 包 `torch` 包含了多維張量的數據結構以及基于其上的多種數學操作。另外，它也提供了多種工具，其中一些可以更有效地對張量和任意類型進行序列化。它有CUDA 的對應實現，可以在NVIDIA GPU上進行張量運算(計算能力>=2.0)。 # 張量 Tensors **torch.is\_tensor**[\[source\]](http://pytorch.org/docs/_modules/torch.html#is_tensor) ``` torch.is_tensor(obj) ``` 如果*obj* 是一個pytorch張量，則返回True - 參數： obj (Object) – 判斷對象 - - - - - - **torch.is\_storage** [\[source\]](http://pytorch.org/docs/_modules/torch.html#is_storage) ``` torch.is_storage(obj) ``` 如何*obj* 是一個pytorch storage對象，則返回True - 參數： input (Object) – 判斷對象 - - - - - - **torch.**set\_default\_tensor\_type****[\[source\]](http://pytorch.org/docs/_modules/torch.html#set_default_tensor_type) ``` torch.set_default_tensor_type(t) ``` - - - - - - **torch.numel** ``` torch.numel(input)->int ``` 返回`input` 張量中的元素個數 - 參數: input ([*Tensor*](http://pytorch.org/docs/tensors.html#torch.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\]](http://pytorch.org/docs/_modules/torch/_tensor_str.html#set_printoptions) ``` torch.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None) ``` 設置打印選項。完全參考自[Numpy](https://docs.scipy.org/doc/numpy/reference/generated/numpy.set_printoptions.html)。參數: - 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](https://docs.python.org/2/library/functions.html#int) ) – 行數 - m ([int](https://docs.python.org/2/library/functions.html#int), *optional*) – 列數.如果為None,則默認為*n* - out ([*Tensor*](http://pytorch.org/docs/tensors.html#torch.Tensor), *optinal*) - Output tensor 返回值: 對角線位置全1，其它位置全0的2維張量返回值類型: [Tensor](http://pytorch.org/docs/tensors.html#torch.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) – 結果張量例子: ```python > > > 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** ```python torch.rand(*sizes, out=None) → Tensor ``` 返回一個張量，包含了從區間\[0,1)的均勻分布中抽取的一組隨機數，形狀由可變參數`sizes` 定義。參數: - sizes (int...) – 整數序列，定義了輸出形狀 - out ([*Tensor*](http://pytorch.org/docs/tensors.html#torch.Tensor), *optinal*) - 結果張量例子： ```python > > > 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** ```python torch.randn(*sizes, out=None) → Tensor ``` 返回一個張量，包含了從標準正態分布(均值為0，方差為 1，即高斯白噪聲)中抽取一組隨機數，形狀由可變參數`sizes`定義。參數: - sizes (int...) – 整數序列，定義了輸出形狀 - out ([*Tensor*](http://pytorch.org/docs/tensors.html#torch.Tensor), *optinal*) - 結果張量例子：: ``` >>> 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) \$。包含從`start`到`end`，以`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 ([Tensor](http://pytorch.org/docs/tensors.html#torch.Tensor), *optional*) – 結果張量例子： ``` >>> 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 (*int*, *optional*) – 沿著此維連接張量序列。例子： ```python > > > 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 ```python 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`中非零元素索引的張量。輸出張量中的每行包含輸入中非零元素的索引。如果輸入`input`有`n`維，則輸出的索引張量`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\]](http://pytorch.org/docs/_modules/torch/functional.html#stack) ``` 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) – 結果張量 ```python > > > 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 ```python torch.transpose(input, dim0, dim1, out=None) → Tensor ``` 返回輸入矩陣`input`的轉置。交換維度`dim0`和`dim1`。輸出張量與輸入張量共享內存，所以改變其中一個會導致另外一個也被修改。參數: - 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\]](http://pytorch.org/docs/_modules/torch/serialization.html#save) ``` 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](http://pytorch.org/docs/notes/serialization.html#recommend-saving-models)參數： - obj – 保存對象 - f －類文件對象 (返回文件描述符)或一個保存文件名的字符串 - pickle\_module – 用于pickling元數據和對象的模塊 - pickle\_protocol – 指定pickle protocal 可以覆蓋默認參數 ### torch.load[\[source\]](http://pytorch.org/docs/_modules/torch/serialization.html#load) ``` 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](http://pytorch.org/docs/tensors.html#torch.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 ``` 用`tensor2`對`tensor1`逐元素相除，然后乘以標量值`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 ``` 用`tensor2`對`tensor1`逐元素相乘，并對結果乘以標量值`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 ``` 返回一個新張量，包含兩個輸入張量`input1`和`input2`的反正切函數參數： - 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) ``` 兩張量`input`和`other`逐元素相除，并將結果返回到輸出。即， \$ 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()`](http://pytorch.org/docs/torch.html#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) ``` 對兩個張量以`start`，`end`做線性插值，將結果返回到輸出張量。即，\$ 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] ```