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)