Tensor的創(chuàng)建除了構(gòu)造器，還提供了工廠模式的創(chuàng)建方式：函數(shù)镇眷，同時(shí)提供了基本運(yùn)算函數(shù)的封裝。本主題就專門數(shù)理這些函數(shù)。
??1. 創(chuàng)建張量的快捷函數(shù)
??2. 張量全局操作與設(shè)置函數(shù)
??3. Tensor隨機(jī)函數(shù)
??4. 全局設(shè)置與判別函數(shù)

創(chuàng)建張量的快捷函數(shù)

• 除了使用Tensor構(gòu)造器創(chuàng)建Tensor對(duì)象外音同，PyTorch還提供了更加方便快捷的工廠函數(shù)方式。
  • 這些函數(shù)都是根據(jù)Tensor構(gòu)造器封裝的秃嗜，并設(shè)置個(gè)性化的屬性权均，比如：requires_grad屬性顿膨；

tensor函數(shù)

• 使用數(shù)據(jù)data直接構(gòu)造張量，可以指定類型dtype與設(shè)備device叽赊，是否進(jìn)行求導(dǎo)運(yùn)算requires_grad恋沃，指定內(nèi)存方式pin_memory；

    tensor(data, dtype=None, device=None, requires_grad=False, pin_memory=False) -> Tensor

• 參數(shù)：
  • data：Python的數(shù)據(jù)類型與Numpy的數(shù)據(jù)類型必指；類似數(shù)組的格式囊咏，可以多維。
  • dtype：在Tensor文檔中指定的類型塔橡；
  • device：后面專門說明梅割，只要指定存放設(shè)別是GPU還是CPU，由torch.device類描述葛家；
  • requires_grad：邏輯類型户辞，指定是否求導(dǎo)；
  • pin_memory：邏輯類型癞谒，專門用于GPU底燎，是否使用專門的固定內(nèi)存；

import torch

t = torch.tensor([1,2,3], dtype=torch.half, device=torch.device("cpu:0"), requires_grad=True, pin_memory=False)
print(t)

tensor([1., 2., 3.], dtype=torch.float16, requires_grad=True)

sparse_coo_tensor函數(shù)

• 使用索引與指定值構(gòu)建一個(gè)COO格式的非0的稀疏張量弹砚。
  • COO：就是坐標(biāo)在索引中是可以重復(fù)的书蚪。索引的值就是重復(fù)次數(shù)。

    torch.sparse_coo_tensor(indices, values, size=None, dtype=None, device=None, requires_grad=False) → Tensor

• 參數(shù)：

  • indices：python或者numpy的數(shù)組格式迅栅，用來指定索引殊校；
  • values：python或者numpy的數(shù)組格式，用來指定值读存；
  • size：list, tuple, 或者torch.Size格式为流，用來指定稀疏張量的大小让簿；如果沒有提供敬察，那么大小將被推斷為足以容納所有非零元素的最小大小。
  • dtype尔当，device莲祸，requires_grad：與tensor函數(shù)一樣；

• 注意：

  • uncoalesced的稀疏矩陣可以重復(fù)坐標(biāo)椭迎，坐標(biāo)最后的值是所有值的和
  • 上面構(gòu)建的矩陣就是uncoalesced矩陣锐帜。

• 稀疏矩陣構(gòu)建示意圖

  • 稀疏矩陣構(gòu)建示意圖

import torch
i = torch.tensor([[0, 1, 1, 4, 3],
                      [2, 0, 2, 1, 4]])
v = torch.tensor([3, 4, 5, 7, 8], dtype=torch.float32)
t = torch.sparse_coo_tensor(i, v, [5, 5])
print(t)
print(t.is_coalesced())     # uncoalesced的稀疏矩陣可以重復(fù)坐標(biāo)，坐標(biāo)最后的值是所有值的和畜号。

tensor(indices=tensor([[0, 1, 1, 4, 3],
                       [2, 0, 2, 1, 4]]),
       values=tensor([3., 4., 5., 7., 8.]),
       size=(5, 5), nnz=5, layout=torch.sparse_coo)
False

import torch
i = torch.tensor([[0, 1, 1, 4, 3],
                       [2, 0, 0, 1, 4]])
v = torch.tensor([3, 4, 5, 7, 8], dtype=torch.float32)
t = torch.sparse_coo_tensor(i, v, [5, 5])

print(t.coalesce().values())    # 聚集才能打印值缴阎，不調(diào)用coalesce函數(shù)無法調(diào)用
print(t.coalesce().indices())    # 聚集才能打印值

tensor([3., 9., 8., 7.])
tensor([[0, 1, 3, 4],
        [2, 0, 4, 1]])

as_tensor函數(shù)

• 這個(gè)函數(shù)構(gòu)是轉(zhuǎn)換為Tensor類型，如下情況简软，輸入不會(huì)被拷貝:
  • data是Tensor蛮拔，dtype與device不同述暂；
  • data是ndarray，且device是CPU

    torch.as_tensor(data, dtype=None, device=None) → Tensor

• 參數(shù)：
  • data：類似數(shù)組的數(shù)據(jù)建炫，包含Tensor

import torch

i = torch.tensor([[0, 1, 1, 4, 3],
                       [2, 0, 0, 1, 4]])
v = torch.tensor([3, 4, 5, 7, 8], dtype=torch.float32)
t = torch.sparse_coo_tensor(i, v, [5, 5])

t2 = torch.as_tensor(t) 
print(t2)

lt = [1, 2, 3, 4]
t3 =  torch.as_tensor(lt) 
print(t3)
t3[1] = 88
print(lt)    # 不受tensor影響
lt[2] = 99
print(t3)     # 不受list影響

tensor(indices=tensor([[0, 1, 1, 4, 3],
                       [2, 0, 0, 1, 4]]),
       values=tensor([3., 4., 5., 7., 8.]),
       size=(5, 5), nnz=5, layout=torch.sparse_coo)
tensor([1, 2, 3, 4])
[1, 2, 3, 4]
tensor([ 1, 88,  3,  4])

import torch
import numpy as np

lt = np.array([1, 2, 3, 4])
t3 =  torch.as_tensor(lt) 
print(t3)
t3[1] = 88
print(lt)    # 受tensor影響
lt[2] = 99
print(t3)     # 受numpy影響

tensor([1, 2, 3, 4])
[ 1 88  3  4]
tensor([ 1, 88, 99,  4])

as_strided函數(shù)

• 對(duì)已有的張量畦韭，重新按照其Storage重構(gòu)張量。

    torch.as_strided(input, size, stride, storage_offset=0) → Tensor

• 參數(shù)：
  • input (Tensor) – 輸入張量
  • size (tuple or ints) – 輸出張量的形狀
  • stride (tuple or ints) – 輸出張量非步長(zhǎng)
  • storage_offset (int, optional) – 輸出張量的數(shù)據(jù)開始的位置肛跌。
• 注意：
  • input要求必須是Tensor艺配，而且不能是稀疏Tensor
  • 這個(gè)函數(shù)僅僅是view的別名函數(shù)而已，原理相同惋砂。

import torch

i = torch.tensor([[0, 1, 1, 4, 3],
                       [2, 0, 0, 1, 4]])
v = torch.tensor([3, 4, 5, 7, 8], dtype=torch.float32)
t = torch.sparse_coo_tensor(i, v, [5, 5])

t2 = torch.as_strided(t, (5, 5),  (5, 1)) 
# print(t2)

---------------------------------------------------------------------------

RuntimeError                              Traceback (most recent call last)

<ipython-input-185-74574b844848> in <module>()
      6 t = torch.sparse_coo_tensor(i, v, [5, 5])
      7 
----> 8 t2 = torch.as_strided(t, (5, 5),  (5, 1))
      9 # print(t2)


RuntimeError: No function is registered for schema aten::as_strided(Tensor(a) self, int[] size, int[] stride, int? storage_offset=None) -> Tensor(a) on backend SparseCPU

import torch

t = torch.Tensor([1,2,3,4,5,6,7,8, 9, 0])

t2 = torch.as_strided(t, (2, 3),  (3, 1)) 
print(t2)

tensor([[1., 2., 3.],
        [4., 5., 6.]])

from_numpy函數(shù)

• 這是一個(gè)專門為numpy數(shù)據(jù)轉(zhuǎn)換為Tensor打造的函數(shù)；

    torch.from_numpy(ndarray) → Tensor

• 說明：
  • 按照numpy的格式轉(zhuǎn)換的Tensor绳锅，共享有相同的內(nèi)存西饵，兩邊的修改都會(huì)產(chǎn)生影響
  • 可以接受的類型的是：
    • numpy.float64,
    • numpy.float32,
    • numpy.float16,
    • numpy.int64,
    • numpy.int32,
    • numpy.int16,
    • numpy.int8,
    • numpy.uint8
    • numpy.bool.
  • 返回的Tensor不可改變大小（resizable） 鳞芙。

import numpy as np
import torch

arr = np.array(
    [
        [1, 2, 3, 4],
        [5, 6, 7, 8]
    ],
    dtype=np.float32
)

t = torch.from_numpy(arr)

print(t)
print(t.requires_grad)  
t.requires_grad=True     # 這個(gè)屬性只爭(zhēng)對(duì)FloatTensor
print(t.requires_grad)

tensor([[1., 2., 3., 4.],
        [5., 6., 7., 8.]])
False
True

zeros函數(shù)

• 構(gòu)造0張量

    torch.zeros(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

• 參數(shù)：

  • size (int...) – 變長(zhǎng)參數(shù)眷柔，指定張量的大小，a collection like a list or tuple.
  • out (Tensor, optional) – 輸出張量原朝；
  • dtype (torch.dtype, optional) – 張量類型驯嘱，使用系統(tǒng)默認(rèn)類型，如果是None喳坠，則使用全局缺省類型鞠评；
    • 全局缺省設(shè)置：torch.set_default_tensor_type()
  • layout (torch.layout, optional) – 數(shù)據(jù)布局，默認(rèn)是torch.strided.
  • device (torch.device, optional) – 缺省設(shè)備壕鹉，如果為None剃幌，則使用全局缺省設(shè)備
    • 全局設(shè)備設(shè)置：torch.set_default_tensor_type()).
  • requires_grad (bool, optional) – 如果自動(dòng)求導(dǎo)會(huì)記錄操作在返回的張量上。

• 注意：

  • requires_grad=True的情況只對(duì)torch.float有效晾浴，其他不允許使用负乡。

import torch

t = torch.zeros(2,3, dtype=torch.float, requires_grad=True)   
# t = torch.zeros(2,3, dtype=torch.int32, requires_grad=True)      # 會(huì)拋出異常。
print(t)
print(t.requires_grad)  
t.requires_grad=True     # 這個(gè)屬性只爭(zhēng)對(duì)FloatTensor
print(t.requires_grad)

tensor([[0., 0., 0.],
        [0., 0., 0.]], requires_grad=True)
True
True

zeros_like函數(shù)

• 構(gòu)造同型0張量

    torch.zeros_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor

• 構(gòu)造一個(gè)同型0張量脊凰。
  • 僅僅借用輸入的shape抖棘，其他沒有任何聯(lián)系。

import torch


t = torch.tensor([1, 2, 3, 4])

z = torch.zeros_like(t, dtype=torch.float, requires_grad=True)   
print(z)

tensor([0., 0., 0., 0.], requires_grad=True)

ones函數(shù)

• 構(gòu)造1張量
  • 與zeros函數(shù)相同用法

    torch.ones(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

import torch

t = torch.ones(2,3, dtype=torch.float, requires_grad=True)   
# t = torch.ones(2,3, dtype=torch.int32, requires_grad=True)      # 會(huì)拋出異常狸涌。
print(t)
print(t.requires_grad)  
t.requires_grad=True     # 這個(gè)屬性只爭(zhēng)對(duì)FloatTensor
print(t.requires_grad)

tensor([[1., 1., 1.],
        [1., 1., 1.]], requires_grad=True)
True
True

ones_like函數(shù)

• 構(gòu)造同型 1 張量

    torch.ones_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor

import torch


t = torch.tensor([1, 2, 3, 4])

z = torch.ones_like(t, dtype=torch.float, requires_grad=True)   
print(z)

tensor([1., 1., 1., 1.], requires_grad=True)

arange函數(shù)

• 連續(xù)值張量構(gòu)造切省。
  • 構(gòu)造的張量只能是1-D的。
  • 與python的內(nèi)置函數(shù)range類似

    torch.arange(start=0, end, step=1, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

• 參數(shù)
  • start=0, end是半開半閉區(qū)間[ start, end )
  • 返回的1-D數(shù)組的長(zhǎng)度為:
  • 默認(rèn)返回int63或者long類型

import torch

t = torch.arange(1, 100, 2)
print(t)
print(t.dtype)

tensor([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35,
        37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71,
        73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99])
torch.int64

import torch

o_t = torch.Tensor(5,5)
print(id(o_t))
t = torch.arange(100, out=o_t)    # 原來的形狀被改變帕胆，同一個(gè)對(duì)象
print(t)
print(o_t)
print(id(o_t))

4619477784
tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12., 13.,
        14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.,
        28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41.,
        42., 43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55.,
        56., 57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67., 68., 69.,
        70., 71., 72., 73., 74., 75., 76., 77., 78., 79., 80., 81., 82., 83.,
        84., 85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95., 96., 97.,
        98., 99.])
tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12., 13.,
        14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25., 26., 27.,
        28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41.,
        42., 43., 44., 45., 46., 47., 48., 49., 50., 51., 52., 53., 54., 55.,
        56., 57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67., 68., 69.,
        70., 71., 72., 73., 74., 75., 76., 77., 78., 79., 80., 81., 82., 83.,
        84., 85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95., 96., 97.,
        98., 99.])
4619477784

range函數(shù)

• 構(gòu)造連續(xù)值張量
  • 與python的內(nèi)置函數(shù)range類似
  • 該函數(shù)已經(jīng)不推薦使用数尿，在torch0.5后會(huì)取消惶楼。被arange替代右蹦。

    torch.range(start=0, end, step=1, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

• 說明：
  • 返回默認(rèn)是float诊杆；
  • 使用的閉區(qū)間:[ start, end ]

import torch

t = torch.range(1, 100, 1)
print(t)

tensor([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.,  12.,
         13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,
         25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
         37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,
         49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
         61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
         73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
         85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
         97.,  98.,  99., 100.])


/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/ipykernel_launcher.py:3: UserWarning: torch.range is deprecated in favor of torch.arange and will be removed in 0.5. Note that arange generates values in [start; end), not [start; end].
  This is separate from the ipykernel package so we can avoid doing imports until

linspace函數(shù)

• 構(gòu)建連續(xù)值張量，與arange使用方式一樣
  • 但是區(qū)別是linespace是指定取樣總數(shù)何陆，而不是步長(zhǎng)晨汹。
  • 返回的默認(rèn)類型是：float

    torch.linspace(start, end, steps=100, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

import torch
t = torch.linspace(0,100, 200)
print(t.shape, t.dtype)

torch.Size([200]) torch.float32

# 應(yīng)用下可視化
%matplotlib inline
import torch
import matplotlib.pyplot  as plt

x = torch.linspace(-10,10, 100, ) 
y = x.sigmoid()

plt.plot(x, y, color=(1,0,0,1))
plt.show()

sigmoid函數(shù)與linspace函數(shù)

logspace函數(shù)

• 構(gòu)造連續(xù)對(duì)數(shù)張量
  • 該張量主要在可視化坐標(biāo)表達(dá)有比較直觀的作用。
  • 構(gòu)造的公式區(qū)間是（采用的是指數(shù)）：
    • []

    torch.logspace(start, end, steps=100, base=10.0, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

# 應(yīng)用下可視化
%matplotlib inline
import torch
import matplotlib.pyplot  as plt

x = torch.logspace(-10, 10, 100) 
print(x[[0, 99]])   # 輸出第一個(gè)與最后一個(gè)贷盲。
y_e = x.log()      # 自然對(duì)數(shù)
y_10 = x.log10()    # 常用對(duì)數(shù)

plt.plot(x, y_e, color=(1,0,0,1))   
plt.plot(x, y_10, color=(0,0,1,1))
print(y_10[0] , y_10[99])
plt.show()

tensor([1.0000e-10, 1.0000e+10])
tensor(-10.) tensor(10.)

logspace函數(shù)

eye函數(shù)

• 構(gòu)造單位張量
  • 單位矩陣

    torch.eye(n, m=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

import torch
t = torch.eye(4, 4)
print(t)
print(t.dtype)
print(t.device)

tensor([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]])
torch.float32
cpu

empty函數(shù)

• 構(gòu)造空矩陣張量
  • 所謂空張量淘这，就是Storage是原生態(tài)沒有初始化的內(nèi)存塊，數(shù)據(jù)是原內(nèi)存遺留的數(shù)據(jù)巩剖，看起來是隨機(jī)的铝穷。

    torch.empty(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False) → Tensor

import torch
t = torch.empty(4, 4)
print(t)
print(t.dtype)

tensor([[ 0.0000e+00, -2.0000e+00,  0.0000e+00, -2.0000e+00],
        [ 1.1210e-44,  0.0000e+00,  0.0000e+00,  0.0000e+00],
        [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00],
        [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  0.0000e+00]])
torch.float32

empty_like函數(shù)

• 構(gòu)造同型空張量
  • 借用其他張量的shape。

    torch.empty_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor

import torch
t = torch.empty(4, 4)
print(t)
print(t.dtype)

tensor([[1.4013e-44, 1.6255e-43, 4.4842e-44, 1.6255e-43],
        [1.5554e-43, 1.5975e-43, 1.3873e-43, 1.4574e-43],
        [1.4013e-44, 1.6255e-43, 4.4842e-44, 8.5479e-44],
        [4.4842e-44, 1.6255e-43, 1.5554e-43, 1.5975e-43]])
torch.float32

empty_strided函數(shù)

• 按照步長(zhǎng)構(gòu)造的張量
  • 使用stride參數(shù)指定步長(zhǎng)佳魔；

    torch.empty_strided(size, stride, dtype=None, layout=None, device=None, requires_grad=False, pin_memory=False) → Tensor

• 參數(shù)：

  • size (tuple of python:ints) – 使用元組格式的張量大小
  • stride (tuple of python:ints) – 元組格式的步長(zhǎng)
  • dtype (torch.dtype, optional) – 指定張量類型曙聂，默認(rèn)使用全局設(shè)置的類型（torch.set_default_tensor_type()）.
  • layout (torch.layout, optional) – 張量的內(nèi)存布局方式：torch.strided.
  • device (torch.device, optional) – 設(shè)備
  • requires_grad (bool, optional) – 是否可求導(dǎo)，默認(rèn)是False
  • pin_memory (bool, optional) – 固定內(nèi)存鞠鲜，只作用于GPU宁脊。

• 注意：

  • 使用stride可能產(chǎn)生中間沒有使用的內(nèi)存空間，見下面例子贤姆。

import torch
t = torch.empty_strided(size=(4, 4), stride=[8, 1])
print(t)
print(t.dtype)

print(t.storage().size())

tensor([[0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00],
        [0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00],
        [0.0000e+00, 1.3593e-43, 1.4714e-43, 1.5134e-43],
        [5.6052e-45, 1.3107e-08, 5.1126e+22, 2.6663e-09]])
torch.float32
28

full函數(shù)

• 使用指定值創(chuàng)建的張量
  • 張量所有元素一樣榆苞。

    torch.full(size, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

• 參數(shù)：
  • size (int...) – a list, tuple, or torch.Size：指定張量shape；
  • fill_value – the number to fill the output tensor with：填充值霞捡；必須是標(biāo)量的數(shù)值型數(shù)據(jù)坐漏。
  • 其他參數(shù)與上面類似

import torch
t = torch.full(size=(4, 4), fill_value=88)
print(t)
print(t.dtype)

print(t.storage().size())

tensor([[88., 88., 88., 88.],
        [88., 88., 88., 88.],
        [88., 88., 88., 88.],
        [88., 88., 88., 88.]])
torch.float32
16

full_like函數(shù)

• 借助已知張量形狀構(gòu)建填充指定值的張量

    torch.full_like(input, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

import torch

o = torch.Tensor([1,2,3])

t = torch.full_like(o, fill_value=88)
print(t)
print(t.dtype)

print(t.storage().size())

tensor([88., 88., 88.])
torch.float32
3

張量全局操作與設(shè)置函數(shù)

cat函數(shù)

• 合并兩個(gè)張量

    torch.cat(tensors, dim=0, out=None) → Tensor

• 參數(shù)

  • tensors (sequence of Tensors) ：被鏈接的張量，是張量序列
  • dim (int, optional)：合并的維度碧信，按照那個(gè)維度合并仙畦，比如按照行合并，或者按照列合并
  • out：可以使用參數(shù)返回（這是典型的C實(shí)現(xiàn)的后遺癥）

• 注意：

  • 要求合并的張量都不需要有一樣的shape音婶。
  • 這個(gè)函數(shù)是torch.split() 與torch.chunk()函數(shù)的逆操作慨畸。
  • 這個(gè)函數(shù)于stack的區(qū)別在于，這個(gè)函數(shù)不改變維度衣式。

import torch
t_1 = torch.full(size=(2, 4), fill_value=1)
t_2 = torch.full(size=(2, 4), fill_value=2)
t_3 = torch.full(size=(2, 4), fill_value=3)
t_4 = torch.full(size=(2, 4), fill_value=4)

y_row = torch.cat(tensors=(t_1, t_2, t_3, t_4), dim=0)
y_col = torch.cat(tensors=(t_1, t_2, t_3, t_4), dim=1)
print(y_row)
print(y_col)

tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [2., 2., 2., 2.],
        [2., 2., 2., 2.],
        [3., 3., 3., 3.],
        [3., 3., 3., 3.],
        [4., 4., 4., 4.],
        [4., 4., 4., 4.]])
tensor([[1., 1., 1., 1., 2., 2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 4.],
        [1., 1., 1., 1., 2., 2., 2., 2., 3., 3., 3., 3., 4., 4., 4., 4.]])

stack函數(shù)

• 按照新的維度合并張量
  • 這個(gè)函數(shù)與cat函數(shù)類似寸士，但是在合并的方向，會(huì)增加維度碴卧。

    torch.stack(tensors, dim=0, out=None) → Tensor

import torch
t_1 = torch.full(size=(2, 4), fill_value=1)
t_2 = torch.full(size=(2, 4), fill_value=2)
t_3 = torch.full(size=(2, 4), fill_value=3)
t_4 = torch.full(size=(2, 4), fill_value=4)

y_row = torch.stack(tensors=(t_1, t_2, t_3, t_4), dim=0)
y_col = torch.stack(tensors=(t_1, t_2, t_3, t_4), dim=1)
print(y_row)
print(y_col)

tensor([[[1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[2., 2., 2., 2.],
         [2., 2., 2., 2.]],

        [[3., 3., 3., 3.],
         [3., 3., 3., 3.]],

        [[4., 4., 4., 4.],
         [4., 4., 4., 4.]]])
tensor([[[1., 1., 1., 1.],
         [2., 2., 2., 2.],
         [3., 3., 3., 3.],
         [4., 4., 4., 4.]],

        [[1., 1., 1., 1.],
         [2., 2., 2., 2.],
         [3., 3., 3., 3.],
         [4., 4., 4., 4.]]])

narrow函數(shù)

• 縮小張量：按照指定的維度弱卡，取部分張量的數(shù)據(jù)構(gòu)成新的張量。

    torch.narrow(input, dim, start, length) → Tensor

• 參數(shù)：
  • iput：需要縮小的張量住册；
  • dim：縮小操作所在的維度婶博；
  • start：指定維度開始的數(shù)據(jù)；
  • length：需要取得數(shù)據(jù)長(zhǎng)度荧飞；

import torch
t_1 = torch.full(size=(2, 4), fill_value=1)
t_2 = torch.full(size=(2, 4), fill_value=2)
t_3 = torch.full(size=(2, 4), fill_value=3)
t_4 = torch.full(size=(2, 4), fill_value=4)

y_row = torch.stack(tensors=(t_1, t_2, t_3, t_4), dim=0)
# print(y_row)
print(y_row.shape)    # 4, 2, 4
y = torch.narrow(input=y_row, dim=2, start=1,length=2)
print(y)

torch.Size([4, 2, 4])
tensor([[[1., 1.],
         [1., 1.]],

        [[2., 2.],
         [2., 2.]],

        [[3., 3.],
         [3., 3.]],

        [[4., 4.],
         [4., 4.]]])

nonzero函數(shù)

• 返回指定張量中所有非0元素的索引
  • 參數(shù)as_tuple=True表示返回的是坐標(biāo)凡人，坐標(biāo)由返回的元組的對(duì)應(yīng)值構(gòu)成坐標(biāo)名党，元組長(zhǎng)度根據(jù)Tensor的維度決定。
  • 參數(shù)as_tuple=False返回的是列表的列表挠轴。

    torch.nonzero(input, *, out=None, as_tuple=False) → LongTensor or tuple of LongTensors

import torch

t = torch.LongTensor(
    [
            [0, 88, 88],
            [88, 0, 0]
    ]
)

list_index = torch.nonzero(t, as_tuple=False)
print(list_index)
index_x, index_y =  torch.nonzero(t, as_tuple=True)
print(index_x, index_y)

tensor([[0, 1],
        [0, 2],
        [1, 0]])
tensor([0, 0, 1]) tensor([1, 2, 0])

reshape函數(shù)

• 等價(jià)于view传睹，如果張量的storge是連續(xù)于stride的。否則可能是數(shù)據(jù)拷貝岸晦。

    torch.reshape(input, shape) → Tensor

• 參數(shù)：

  • input (Tensor) – the tensor to be reshaped
  • shape (tuple of python:ints) – the new shape

• reshape前后的元素個(gè)數(shù)相等欧啤。形狀的維度隨意。

import torch

t = torch.LongTensor(
    [
            [0, 88, 88, 99],
            [88, 0, 0, 77],
            [88, 0, 0, 77],
    ]
)

print(torch.reshape(t, shape=(2, 2, 3)))

tensor([[[ 0, 88, 88],
         [99, 88,  0]],

        [[ 0, 77, 88],
         [ 0,  0, 77]]])

split函數(shù)

• 切分張量為多個(gè)部分启上，與chunck函數(shù)類似邢隧。

    torch.split(tensor, split_size_or_sections, dim=0)    # 按照指定維度切分

• 參數(shù)

  • tensor (Tensor) – tensor to split.
  • split_size_or_sections (int) or (list(int)) – 切分的方案
    • 如果是整數(shù)，就按照整數(shù)作為長(zhǎng)度切分冈在，剩余的不足就作為一個(gè)切分倒慧。
    • 如果是列表，就按照列表指定的長(zhǎng)度切分讥邻，但是列表長(zhǎng)度的和必須等于原來維度的長(zhǎng)度迫靖。
  • dim：切分的維度

• chunck是指定等分的份數(shù)院峡，不是指定切分的長(zhǎng)度兴使。

import torch

t = torch.ones(10, 3)
# print(t)
chunks = torch.split(t, split_size_or_sections=3, dim=0)     
print(chunks)
chunks = torch.split(t, split_size_or_sections=(3, 2, 3, 2), dim=0)     
print(chunks)

(tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]]), tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]]), tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]]), tensor([[1., 1., 1.]]))
(tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]]), tensor([[1., 1., 1.],
        [1., 1., 1.]]), tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]]), tensor([[1., 1., 1.],
        [1., 1., 1.]]))

其他在Tensor中也有的函數(shù)

1. where 函數(shù)
2. unsqueeze 函數(shù)
3. squeeze 函數(shù)
4. unbind 函數(shù)
5. transpose 函數(shù)：維度交換
6. t 函數(shù)：矩陣轉(zhuǎn)置,只爭(zhēng)對(duì)1-2維的情況
7. take 函數(shù)
8. masked_select 函數(shù)
9. index_select 函數(shù)
10. gather 函數(shù)
11. chunk 函數(shù)

import  torch

t = torch.Tensor(3)
print(t.t().shape)

t = torch.Tensor(3, 2)
print(t.t().shape)

t = torch.Tensor(2, 3, 4)
# print(t.t().shape)    # 錯(cuò)誤的，超過2維了

torch.Size([3])
torch.Size([2, 3])

隨機(jī)創(chuàng)建Tensor函數(shù)

Tensor的成員中的隨機(jī)元素生成函數(shù)

1. torch.Tensor.bernoulli_() - 伯努利分布隨機(jī)照激；
2. torch.Tensor.cauchy_() - 柯西分布隨機(jī)发魄；
3. torch.Tensor.exponential_() - 指數(shù)分布隨機(jī)；
4. torch.Tensor.geometric_() - 幾何分布隨機(jī)俩垃；
5. torch.Tensor.log_normal_() - log-normal分布隨機(jī)励幼；
6. torch.Tensor.normal_() - 正態(tài)分布隨機(jī)；
7. torch.Tensor.random_() - 理算統(tǒng)一分布隨機(jī)口柳；
8. torch.Tensor.uniform_() - 連續(xù)統(tǒng)一分布隨機(jī)苹粟；

創(chuàng)建Tensor的全局靜態(tài)函數(shù)

隨機(jī)種子函數(shù)

• 用來管理（偽）隨機(jī)數(shù)產(chǎn)生的狀態(tài)。
  • 隨機(jī)數(shù)的產(chǎn)生也是使用算法來產(chǎn)生的跃闹，影響這些算法結(jié)果的參數(shù)就是隨機(jī)種子產(chǎn)生器嵌削。
  • 這不講原理，主要是使用望艺。
  • 下面幾個(gè)函數(shù)否會(huì)影響到隨機(jī)數(shù)的生成苛秕，設(shè)置隨機(jī)種子函數(shù)是
    • seed函數(shù)
    • torch.manual_seed(seed)函數(shù)

1. seed函數(shù)

   • 設(shè)置缺省的隨機(jī)種子（64位），將用于生成隨機(jī)數(shù)的種子設(shè)置為非確定性隨機(jī)數(shù)（有的采用的是當(dāng)前系統(tǒng)時(shí)間）找默。
   • torch.seed()

2. manual_seed函數(shù)

   • torch.manual_seed(seed)

3. initial_seed函數(shù)

   • torch.initial_seed()

4. get_rng_state函數(shù)

   • torch.get_rng_state()

5. set_rng_state函數(shù)

   • torch.set_rng_state

6. default_generator屬性

   • torch.default_generator

import torch
import time

# 1. seed
print(torch.seed())   # 設(shè)置隨機(jī)種艇劫，并返回種子，不確定性種子

# 2. 手工設(shè)置隨機(jī)種
gen = torch.manual_seed(1000)    # 設(shè)置并返回
print(gen)   # 返回一個(gè)生成器：返回的是系統(tǒng)生成器惩激，不過隨機(jī)種是用戶手工設(shè)置

# 6. 缺省的生成器
print(torch.default_generator)

# 3. initial_seed函數(shù)
print(torch.initial_seed())   # 返回當(dāng)前初始化的隨機(jī)種子店煞，不設(shè)置

# 得到隨機(jī)狀態(tài)
print(torch.get_rng_state())

6489190845875486582
<torch._C.Generator object at 0x11191ca50>
<torch._C.Generator object at 0x11191ca50>
1000
tensor([232,   3,   0,  ...,   0,   0,   0], dtype=torch.uint8)

隨機(jī)種子類

• 上面的函數(shù)都是操作一個(gè)全局的隨機(jī)生成器對(duì)象蟹演，該對(duì)象的類型是：
  • torch._C.Generator(device='cpu') → Generator
  • 這個(gè)對(duì)象的成員函數(shù)，都是上面全局函數(shù)浅缸。
  • 隨機(jī)生成對(duì)象轨帜，一般應(yīng)用需要一個(gè)即可，所以衩椒，torch自動(dòng)創(chuàng)建蚌父，并通過全局函數(shù)控制隨機(jī)生成器對(duì)象，從而影響所有使用隨機(jī)生成器對(duì)象的函數(shù)的輸出毛萌。

bernoulli伯努利隨機(jī)分布

• torch.bernoulli(input, *, generator=None, out=None) → Tensor
  • 參數(shù)：
    • input (Tensor) –計(jì)算概率的輸入張量值
    • 返回值是0或者1苟弛，輸出服從伯努利分布（0-1分布）
    • 

# 應(yīng)用下可視化
%matplotlib inline
import torch
import matplotlib.pyplot  as plt

x = torch.linspace(0, 1, 20)     # 數(shù)據(jù)只能在0-1之間概率

y = torch.bernoulli(x)   # 使用默認(rèn)隨機(jī)種子生成器

plt.scatter(x, y, color=(1,0,0,1), s=2**1 )   
plt.show()

伯努利隨機(jī)分布函數(shù)可視化

multinomial多項(xiàng)式隨機(jī)分布

• 多項(xiàng)式分布式是伯努利分布的推廣

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

  • 參數(shù)：
    • input (Tensor) – 等于權(quán)重
    • num_samples (int) – 采樣數(shù)（伯努利0-1分布，多次0-1的結(jié)果概率統(tǒng)計(jì)就是多項(xiàng)式分布）
    • replacement (bool, optional) – 放回還是不放回取樣
    • out (Tensor, optional) –輸出

import torch
import matplotlib.pyplot  as plt

x = torch.linspace(0, 1, 30)     # 數(shù)據(jù)只能在0-1之間概率
print(x)
y = torch.multinomial(x, num_samples=10, replacement=True)   # 使用默認(rèn)隨機(jī)種子生成器

# plt.scatter(x, y, color=(1,0,0,1), s=2**1 )     
# plt.show()
print(y.shape, y)    # 10次阁将，每次30個(gè)中出現(xiàn)1 的次數(shù)

# torch.Size([10]) tensor([23, 21,  8, 19, 27, 20, 26, 29, 18, 14])
# 第1次出現(xiàn)23個(gè)1膏秫，第2次21個(gè)1，第3詞8個(gè)1做盅，一次類推

tensor([0.0000, 0.0345, 0.0690, 0.1034, 0.1379, 0.1724, 0.2069, 0.2414, 0.2759,
        0.3103, 0.3448, 0.3793, 0.4138, 0.4483, 0.4828, 0.5172, 0.5517, 0.5862,
        0.6207, 0.6552, 0.6897, 0.7241, 0.7586, 0.7931, 0.8276, 0.8621, 0.8966,
        0.9310, 0.9655, 1.0000])
torch.Size([10]) tensor([10, 22, 11, 15, 26, 21, 12,  4, 29, 26])

高斯分布

• torch.normal(mean, std, out=None) → Tensor
  • 參數(shù)：
    • mean：均值
    • std：方差
• 因?yàn)閰?shù)可以是標(biāo)量與向量缤削，其表示的含義也有差異，所以normal函數(shù)有多種使用方式：

  • 方式一：

    • mean（Tensor）：每個(gè)輸出的均值
    • std（Tensor）：每個(gè)輸出的方差

  • 方式二：

    • mean (float, optional) ：所有輸出的均值
    • std (Tensor) ：每個(gè)元素的方法

  • 方式三：

    • mean (Tensor) – 每個(gè)輸出的均值
    • std (float, optional) – 所有輸出的方差

  • 方式四：

    • mean (float) – 所以輸出的均值
    • std (float) – 所有輸出的方差
    • size (int...) – 輸出張量的shape吹榴，類型是序列

import torch

t = torch.normal(0, 1.0, size=(4, 4))
print(t)

tensor([[-0.6619, -0.0582,  1.0059,  0.5642],
        [ 1.9159, -0.0919, -0.0955,  0.1474],
        [-0.8056,  0.0583, -0.0816, -2.7257],
        [-1.4878, -1.3920,  2.2023,  0.2243]])

0-1統(tǒng)一分布

• torch.rand(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
• torch.rand_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor

import torch

t = torch.rand(size=(4, 4))
print(t)
t = torch.rand(4, 4)
print(t)

tensor([[0.0148, 0.6573, 0.8463, 0.8787],
        [0.5838, 0.3050, 0.4746, 0.0229],
        [0.6680, 0.5553, 0.0865, 0.4258],
        [0.6251, 0.5168, 0.1260, 0.4440]])
tensor([[0.6688, 0.5381, 0.9404, 0.8110],
        [0.0793, 0.6212, 0.3379, 0.6475],
        [0.7198, 0.1503, 0.6447, 0.8081],
        [0.0081, 0.3580, 0.2408, 0.8467]])

指定范圍的隨機(jī)整數(shù)

• torch.randint(low=0, high, size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
• torch.randint_like(input, low=0, high, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

import torch

t = torch.randint(low=0, high=10, size=(3,4))   # 不包含high
print(t)

tensor([[3, 5, 5, 8],
        [8, 6, 9, 9],
        [0, 5, 9, 8]])

標(biāo)準(zhǔn)正態(tài)分布

• torch.randn(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
• torch.randn_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor

import torch

t = torch.randn(3,4)   # 均值為0亭敢，方差為1
print(t)

tensor([[-0.4149,  0.8210, -0.3328, -0.1037],
        [ 0.3303,  0.4522, -1.5808, -0.1078],
        [-0.2900,  0.4803,  0.0373,  0.0158]])

隨機(jī)排列組合

• torch.randperm(n, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False) → LongTensor

import torch

t = torch.randperm(10)   # 不包含10
print(t)

tensor([9, 1, 3, 8, 6, 2, 0, 7, 5, 4])

全局設(shè)置與判別函數(shù)

判別函數(shù)

張量判別與存儲(chǔ)

• torch.is_tensor(obj)
• torch.is_storage(obj)

判別類型是否是浮點(diǎn)數(shù)

• torch.is_floating_point(input) -> (bool)

返回元素個(gè)數(shù)

• torch.numel(input) → int

設(shè)置函數(shù)

設(shè)置或者獲取缺省數(shù)據(jù)類型

• torch.set_default_dtype(d)

  • 設(shè)置的是torch.tensor()的缺省類型。

• torch.get_default_dtype() → torch.dtype

設(shè)置Tensor的缺省類型

• torch.set_default_tensor_type(t)
  • 設(shè)置Tensor的默認(rèn)類型图筹；
  • 也對(duì)tensor函數(shù)有效帅刀。

設(shè)置打印選項(xiàng)

• torch.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, profile=None, sci_mode=None)
  • 參數(shù)：
    • precision –：浮點(diǎn)數(shù)輸出精度；缺省4远剩；
    • threshold –：Tensor輸出省略號(hào)的元素最大閾值扣溺；缺省1000；
    • edgeitems –：省略輸出的個(gè)數(shù)瓜晤；缺省3锥余；
    • linewidth –：每行的字符寬度；缺省80痢掠；如果有threshold參數(shù)驱犹，該參數(shù)被忽略；
    • profile –：輸出選項(xiàng)設(shè)置志群，符號(hào)上面任何設(shè)置着绷，取值為default, short, full
    • sci_mode –：開始科學(xué)記數(shù)法；取值True與False锌云，缺省為None荠医；None的格式由 _Formatter設(shè)置。

import torch

t = torch.randn(100,100)
# 默認(rèn)輸出
print(t)

tensor([[ 1.0104,  0.5672, -0.3641,  ...,  0.7242,  0.7394, -1.4221],
        [-1.1162, -0.6423,  0.5711,  ...,  0.6867, -0.6276, -0.1440],
        [ 0.0079,  0.9556, -1.1738,  ..., -2.0242,  1.0075,  0.8763],
        ...,
        [-1.8785,  0.6135,  0.9522,  ...,  0.2765, -1.3314,  2.3584],
        [ 0.1544,  0.5971,  0.7356,  ...,  0.4711,  0.2345, -0.4296],
        [-0.5048, -1.3926, -0.0838,  ..., -0.5157,  1.1167, -0.5052]])

import torch

t = torch.randn(100,100)
# 格式輸出
torch.set_printoptions(
    precision=2,
    threshold=1000,   # 設(shè)置為10000就全部打印了
    edgeitems=5,    # 每行，前后5個(gè)彬向，每列器安后個(gè)
    linewidth=80   # 每行的寬度
)
print(t)

tensor([[ 1.19, -0.52,  0.27, -0.87,  0.55,  ..., -0.77,  0.34, -0.77, -0.54,
         -2.60],
        [-0.77,  0.32, -0.82,  1.16, -0.80,  ...,  0.67, -0.79, -0.96, -0.84,
         -2.17],
        [ 1.13,  0.20, -0.86,  0.50,  0.01,  ..., -1.07,  0.45, -2.37, -0.11,
         -1.01],
        [ 1.17,  0.45,  0.39, -0.21, -1.98,  ...,  0.28, -0.53, -0.38, -0.11,
          0.15],
        [ 0.25,  1.07,  1.00, -0.25,  1.64,  ...,  0.14,  0.71,  0.11, -1.51,
         -0.09],
        ...,
        [ 1.89,  1.55, -1.16,  1.69,  0.65,  ..., -0.47, -0.12,  1.48, -0.66,
         -0.27],
        [ 0.09,  0.31,  0.68, -0.64,  1.15,  ..., -0.27, -0.12,  0.05,  1.78,
          0.12],
        [-0.74,  0.90,  1.65,  0.47,  0.74,  ...,  0.21, -0.79,  0.63,  0.40,
         -0.20],
        [ 0.86,  0.77,  1.87, -0.49, -1.19,  ..., -1.95, -0.70,  1.73,  0.32,
         -0.22],
        [ 0.76, -0.66, -0.66,  0.57,  0.07,  ...,  0.88, -0.99,  0.11, -1.47,
          0.08]])

import torch

t = torch.randn(100,100)
# short與輸出
torch.set_printoptions(
    precision=2,
    profile='short'    # full default, short三個(gè)值
)
print(t)

tensor([[-0.72,  2.27,  ...,  0.03, -0.40],
        [-0.12, -0.29,  ..., -0.33, -0.72],
        ...,
        [ 0.10,  1.56,  ...,  0.83, -0.26],
        [ 0.88,  0.35,  ...,  1.03, -0.08]])

非規(guī)范浮點(diǎn)數(shù)使用設(shè)置

• torch.set_flush_denormal(mode) → bool
  • 設(shè)置成功（表示支持）兼贡，返回True，否則返回False娃胆。
  • 僅僅在x86結(jié)構(gòu)的CPU上支持遍希；

import torch
print(torch.set_flush_denormal(True))
print(torch.set_flush_denormal(False))

True
True