PyTorch張量

import torch
# print(torch.tensor([1.2,3.4]).dtype)
# torch.set_default_tensor_type(torch.DoubleTensor)
# a =torch.tensor([1.2,3.4])

# #1、將浮點型轉化為其他資料型別
# print("a.dtype:",a.dtype)
# print("a.long() method:",a.long().dtype)
# print("a.int() method:",a.int().dtype)
# print("a.float() method:",a.float().dtype)
# torch.set_default_tensor_type(torch.FloatTensor)
# print(torch.tensor([1.2,3.4]).dtype)
# print(torch.get_default_dtype())#獲取預設資料型別

#2、生成張量 python中的 列表或者序列可以通過torch.tensor（）函式來構造張量
# A=torch.tensor([[1.0,1.0],[2,2]])
# print(A)
# print(A.shape)#獲取張量的維度
# print(A.size())#獲取張量形狀的大小
# print(A.numel())#獲取張量中包含元素的數量


#3、生成張量時指定張量的資料型別和是否需要計算梯度，只有計算了梯度的張量才能在深度網路優化時根據梯度大小進行更新
# B=torch.tensor((1,2,3),dtype=torch.float32,requires_grad=True)
# print(B)
# y=B.pow(2).sum()
# y.backward()
# print(B.grad)#注：只有浮點型資料才能計算梯度，其他型別資料是不能計算張量的梯度的
# C=torch.Tensor([1,2,3,4])
# print(C)
# #根據指定形狀引數生成特定尺寸的張量
# D=torch.Tensor(2,3)
# print(D)
# #針對已經生成的張量可以使用torch.**_like（）系列函式生成與指定張量維度相同、性質相似的張量
# #如 使用torch.ones_like（）函式生成與D維度相同的全1張量
# print(torch.ones_like(D))
# #如 使用torch.zeros_like（）函式生成與D維度相同的全0張量
# print(torch.zeros_like(D))
# #如 使用torch.rand_like（）函式生成與D維度相同的隨機張量
# print(torch.rand_like(D))
# E=[[1,2],[3,4]]
# E=D.new_tensor(E)
# #針對一個建立好的張量D，可以使用D.new_**（）系列函式建立出新的張量，
# print("D.dtype:",D.dtype)
# print("E.dtype:",E.dtype)
# F=D.new_full((2,2),fill_value=1)
# print(F)
# F=D.new_zeros((2,2))
# print(F)
# M=D.new_empty((2,2))
# print(M)
# F=D.new_ones((2,2))
# print(F)

#4、numpy和張量的相互轉化 numpy->rensor 使用torch.as_tensor(F)，或torch.from_numpy（）
# import numpy as np
# F=np.ones((3,3))
# Ftensor=torch.as_tensor(F)
# print(Ftensor)
# Ftensor=torch.from_numpy(F)
# print(Ftensor)
# #tensor->numpy torch.numpy()
# print(Ftensor.numpy())

# #5、隨機生成張量
# #指定生成隨機數的種子，生成服從正態分佈的隨機數  通過指定均值和標準差生成隨機數
# torch.manual_seed(123)
# A=torch.normal(mean=0.0,std=torch.tensor(1.0))
# print(A)
# B=torch.rand(3,4)#使用torch.rand(3,4)在區間【0，1】上生成服從均勻分佈的張量
# print(B)
# #torch.randn()和torch.rand_like（）生成服從標準正態分佈的隨機數張量
# C=torch.randn(3,3)
# print(C)
# #使用torch.randperm(n)函式，則可將0~n（左閉右開區間）之間的整數進行隨機排序後輸出
# print(torch.randperm(10))

# #6、其他生成張量的函式 torch.arange() （左閉右開區間） 步長為2
# print(torch.arange(start=0,end=10,step=2))
# #可使用torch.linspace()函式在範圍內生成固定數量的等間隔張量 steps為固定數量 左右都是閉區間
# print(torch.linspace(start=1,end=10,steps=5))
# #torch.logspace()生成以對數為間隔的張量
# print(torch.logspace(start=0.1,end=1.0,steps=5))


#1、張量操作--改變張量的形狀
#使用tensor.reshape()方法可以重置張量的形狀大小
# a=torch.arange(12.0).reshape(3,4)
# print(a)
# a=torch.reshape(input=a,shape=(2,-1))
# print(a)
# #改變張量的形狀使用tensor.resize_()方法，針對輸入的形狀大小對張量形狀進行修改
# a.resize_(2,6)
# print(a)
# #a.resize_as_(b)方法，可以將張量a的形狀大小設定為跟b相同的形狀大小
# b=torch.arange(10.0,19.0).reshape(3,3)
# a.resize_as_(b)
# print(b)
# print(a)
#torch.unsqueeze()函式可以在張量的指定維度插入新的維度得到維度提升的張量
# a=torch.arange(12.0).reshape(2,6)
# print(a)
# b=torch.unsqueeze(a,dim=0)
# print(b)
# c =b.unsqueeze(dim=3)
# print("c shape:",c.shape)
# #d=torch.squeeze(c) 移除所有維度為1 的維度  ，
# d=torch.squeeze(c)
# print("d.shape:",d.shape)
# #移除指定維度為1 的維度
# e=torch.squeeze(c,dim=0)
# print("e.shape:",e.shape)
#使用.expand()方法對張量的維度進行擴充套件，從而對張量的形狀大小進行修改
# a=torch.arange(3)
# b=a.expand(3,-1)
# print(a)
# print(b)
# c=torch.arange(6).reshape(2,3)
# b=a.expand_as(c)#將張量a根據c的形狀大小進行擴充得到新的張量
# print(b)
# print(b.shape)
# #使用張量的.repeat()方法，可以將張量看作一個整體，然後根據指定的形狀進行重複填充，得到新的張量
# d=b.repeat(1,2,2)
# print(d)
# print(d.shape)

#2、獲取張量中的元素:從張量中利用切片和索引提取元素的方法，和numpy中的使用方法一樣
# a=torch.arange(12).reshape(1,3,4)
# print(a)
# print(a[0])
# print(a[0,0:2,:])
# print(a[0,-1,-4:-1])
# #也可以按需將索引設定為相應的布林值
# b=-a
# c=torch.where(a>5,a,b)
# print(c)
# print(a[a>5])
# #torch.tril()獲取張量下三角元素的值，把上三角部分的元素設定為0 diagonal引數控制要考慮的對角線
# #torch.triu()獲取張量上三角元素的值，把下三角部分的元素設定為0
# #torch.diag()獲取矩陣張量對角線元素 或者提供一個向量生成一個矩陣張量
# print(torch.tril(a,diagonal=0,))
# print(torch.tril(a,diagonal=1,))
# print(torch.triu(a,diagonal=0,))
# print(torch.triu(a,diagonal=1,))
# c=a.reshape(3,4)
# print(c)
# print(torch.diag(c,diagonal=0))
# print(torch.diag(c,diagonal=1))
'''
def diag(input: Tensor,
         diagonal: int = 0,
         *,
         out: Optional[Tensor] = None)
         input需要是一個二維張量
'''
#可以通過diagonal引數來控制獲取的對角線元素，相當於對角線的位移
#提供對角線元素生成張量
# print(torch.diag(torch.tensor([1,2,3])))

#3、拼接和拆分
#torch.cat()函式可以將多個張量在指定維度上進行拼接,得到新的張量
# a=torch.arange(6.0).reshape(2,3)
# b=torch.linspace(0,10,6).reshape(2,3)
# print(a)
# print(b)
# c=torch.cat((a,b),dim=0)
# print(c)
# print(c.shape)
# print(torch.cat((a,b),dim=1))
# print(torch.cat((a[:,0:2],a,b),dim=1))
# print(torch.cat((a[:,1:2],a,b),dim=1))

#torch.stack()函式，可以將多個張量按照指定的維度進行拼接
# f=torch.stack((a ,b),dim=0)
# print(f)
# print(f.shape)
'''
c=torch.cat((a,b),dim=0)
tensor([[ 0.,  1.,  2.],
        [ 3.,  4.,  5.],
        [ 0.,  2.,  4.],
        [ 6.,  8., 10.]])
torch.Size([4, 3])
f=torch.stack((a ,b),dim=0)
tensor([[[ 0.,  1.,  2.],
         [ 3.,  4.,  5.]],

        [[ 0.,  2.,  4.],
         [ 6.,  8., 10.]]])
torch.Size([2, 2, 3])
'''
# f=torch.stack((a ,b),dim=1)
# print(f)
# print(f.shape)
# f=torch.stack((a ,b),dim=2)
# print(f)
# print(f.shape)
'''
tensor([[[ 0.,  1.,  2.],
         [ 3.,  4.,  5.]],

        [[ 0.,  2.,  4.],
         [ 6.,  8., 10.]]])
torch.Size([2, 2, 3])
tensor([[[ 0.,  1.,  2.],
         [ 0.,  2.,  4.]],

        [[ 3.,  4.,  5.],
         [ 6.,  8., 10.]]])
torch.Size([2, 2, 3])
tensor([[[ 0.,  0.],
         [ 1.,  2.],
         [ 2.,  4.]],

        [[ 3.,  6.],
         [ 4.,  8.],
         [ 5., 10.]]])
torch.Size([2, 3, 2])
'''
# print(a)
# #torch.chunk（）可以將張量分割 成特定數量的塊 torch.split()函式再將張量分割為特定數量的塊時可以指定每個塊的大小
# print(torch.chunk(a,2,dim=0))
# d1,d2=torch.chunk(a,2,dim=1)
# print(d1)
# print(d2)#如果沿給定維度dim的張量大小不能被塊整除，則最後一個塊將最小
# #將張量分割成塊指定每個塊的大小
# d1,d2,d3=torch.split(a,[1,1,1],dim=1)
# print(d1)
# print(d2)
# print(d3)



#2.2.4張量的計算
#1、比較大小
'''
def allclose(input: Tensor,
             other: Tensor,
             rtol: float = 1e-05,
             atol: float = 1e-08,
             equal_nan: bool = False) -> bool
             比較兩個數是否接近 |a-b|<=atol+rtol*|b|
             如果equal_nan=True那麼缺失值可以判斷接近
'''
# l1=torch.tensor([10.0])
# l2=torch.tensor([10.1])
# print(torch.allclose(l1,l2,rtol=1e-05,atol=1e-08,equal_nan=False))
# print(torch.allclose(l1,l2,rtol=0.1,atol=0.01,equal_nan=False))
# a=torch.tensor(float("nan"))
# print(torch.allclose(a,a,equal_nan=False))
# print(torch.allclose(a,a,equal_nan=True))
'''
False
True
False
True
'''
'''
def eq(input: Tensor,
       other: Tensor,
       *,
       out: Optional[Tensor] = None) -> Tensor
def equal(input: Tensor,
          other: Tensor) -> bool
'''
# l1=torch.tensor([1,2,3,4,5,6])
# l2=torch.arange(1,7)
# l3=torch.unsqueeze(l2,dim=0)#擴充套件一維
# print(l1)
# print(l2)
# print(l3)
# print(torch.eq(l1,l2))#判斷兩個張量是否相等 逐個元素比較
# print(torch.eq(l1,l3))
# print(torch.equal(l1,l2))
# print(torch.equal(l1,l3))#判斷兩個張量是否具有相同的形狀和元素
'''
tensor([1, 2, 3, 4, 5, 6])
tensor([1, 2, 3, 4, 5, 6])
tensor([[1, 2, 3, 4, 5, 6]])
tensor([True, True, True, True, True, True])
tensor([[True, True, True, True, True, True]])
True
False
'''
# print(torch.ge(l1,l2))#>=逐元素比較大於等於
# print(torch.ge(l1,l3))
# print(torch.gt(l1,l2))#>逐元素比較大於
# print(torch.gt(l1,l3))
# print(torch.le(l1,l2))#逐元素比較小於等於
# print(torch.le(l1,l3))
# print(torch.lt(l1,l2))#逐元素比較小於
# print(torch.lt(l1,l3))
# print(torch.ne(l1,l2))
# print(torch.ne(l1,l3))#逐元素比較不等於
# #判斷是否為缺失值
# print(torch.isnan(torch.tensor([0,1,float("nan"),2])))

#2、基本運算
#四則運算
# l1=torch.arange(6.0).reshape(2,3)
# l2=torch.linspace(10,20,steps=6).reshape(2,3)
# print(l1)
# print(l2)
# print(l1*l2)#逐元素相乘
# print(l1/l2)#逐元素相除
# print(l1+l2)#逐元素相加
# print(l1-l2)#逐元素相減
# print(l2//l1)#逐元素整除
# #冪運算
# print(torch.pow(l1,3))
# print(l1**3)
# #指數
# print(torch.exp(l1))
# #對數
# print(torch.log(l1))
# #平方根
# print(torch.sqrt(l1))
# print(l1**0.5)
# print(torch.rsqrt(l1))#平方根倒數
# print(1/(l1**0.5))
#裁剪 最大值裁剪 最小值裁剪 範圍裁剪
# print(torch.clamp_max(l1,4))
# print(torch.clamp_min(l1,3))
# print(torch.clamp(l1,2.5,4))
# #矩陣運算  轉置 矩陣相乘 逆
# l3=torch.t(l1)轉置
# print(l3)
# print(l1.matmul(l3))
# l1=torch.arange(12.0).reshape(2,2,3)
# l2=torch.arange(12.0).reshape(2,3,2)
# print(l1)
# print(l2)
# print(torch.matmul(l1,l2))
# #矩陣相乘只計算最後面兩個維度的乘法 矩陣相乘
# print(torch.matmul(l1[0],l2[0]))
# print(torch.matmul(l1[1],l2[1]))
#逆 矩陣相乘為單位陣 則這兩個矩陣互為逆矩陣 計算矩陣的逆矩陣可以使用torch.inverse()函式，
#在一個方陣中，對角線元素的和成為矩陣的跡 可以使用torch.trace()計算得到
# l1=torch.rand(3,3)
# l2=torch.inverse(l1)
# print(l1)
# print(l2)
# print(torch.matmul(l1,l2))
# print(torch.mm(l1,l2))
# print(torch.arange(12.0).reshape(3,4))
# print(torch.trace(torch.arange(12.0).reshape(3,4)))



#3、統計相關的計算
'''
torch.max()計算張量中的最大值
torch.argmax()計算張量中最大值所在的位置
torch.min()計算張量中最小值
torch.argmin()計算張量中最小值所在位置

'''
# l1=torch.tensor([12,34,25,11,67,32,29,30,99,55,23,44])
# print("max:",l1.max())
# print("max index:",l1.argmax())
# print("min:",l1.min())
# print("min index:",l1.argmin())
# l2=l1.reshape(3,4)
# print(l2)
# print("max:",l2.max(dim=1))
# print("min :",l2.min(dim=0))
'''
torch.sort()可以對一維張量排序 或者對高維張量在指定的維度進行排序 在輸出排序結果的同時，還會輸出對應的值在原始位置的索引
torch.topk()根據指定的k值，計算出張量中取值大小為前k大的數值和數值所在的位置
torch.kthvalue()根據指定的k值，計算出張量中取值大小為第k小的數值和數值所在的位置
torch.mean()根據指定的維度計算均值
torch.sum()根據指定的維度求和
torch.cumsum()根據指定的維度計算累加和
torch.median()根據指定的維度計算中位數
torch.prod()根據指定的維度計算乘積
torch.cumprod()根據指定的維度計算累乘積
torch.std()計算張量的標準差
'''
# l1=torch.tensor([12.0,34,25,11,67,32,29,30,99,55,23,44])
# print(torch.sort(l1))
# print(torch.sort(l1,descending=True))
# l2=l1.reshape(3,4)
# print("l2:",l2)
# print(torch.sort(l2))
# print(torch.argsort(l2))
# print(torch.topk(l1,4))
# print(torch.topk(l2,2,dim=0))
#
# print(torch.kthvalue(l1,3))
# print(torch.kthvalue(l2,3,dim=1))
# print(torch.mean(l2,dim=1,keepdim=True))#行均值
# print(torch.mean(l2,dim=0,keepdim=True))#列均值
# print(torch.sum(l2,dim=1,keepdim=True))
# print(torch.sum(l2,dim=0,keepdim=True))
# print(torch.cumsum(l2,dim=1))
# print(torch.cumsum(l2,dim=0))
# print(torch.median(l2,dim=1,keepdim=True))
# print(torch.median(l2,dim=0,keepdim=True))
# print(torch.prod(l2,dim=1,keepdim=True))
# print(torch.prod(l2,dim=0,keepdim=True))
# print(torch.cumprod(l2,dim=1))
# print(torch.cumprod(l2,dim=0))
# print(torch.std(l2))

#自動微分
# x=torch.tensor([[1.0,2.0],[3.0,4.0]],requires_grad=True)
# y=torch.sum(x**2+2*x+1)
# print("x.requires_grad:",x.requires_grad)
# print("y.requires_grad:",y.requires_grad)
# print("x:",x)
# print("y:",y)
# #通過torch.backward()來計算y在x的每個元素上的導數
# y.backward()
# print(x.grad)