Pytorch深度学习基础之Tensor

<>简介

Tensor对象是一个任意维度的矩阵，但是一个Tensor中所有元素的数据类型必须一致。torch包含的数据类型和普遍编程语言的数据类型相似，包含浮点型，有符号整型和无符号整型，这些类型既可以定义在cpu上，也可以定义在Gpu上

<>Tensor执行算数运算

* 逐个元素自己相乘
* 矩阵乘法
tensor执行算数运算符的运算，是两个矩阵对应元素的运算。torch.mm执行矩阵乘法的运算
import torch a=torch.tensor([[1,2],[3,4]]) b=torch.tensor([[1,2],[3,4]]) c=a*b
print("逐个元素相乘",c) #逐个元素相乘 #tensor([[ 1, 4], # [ 9, 16]]) c=torch.mm(a,b) print(
"矩阵乘法",c) #矩阵乘法 tensor([[ 7, 10], # [15, 22]])
<>pytorch直接创建数据的内置函数

* torch.arange()
* torch.eye()
* torch.linspace()
* torch,zeros()
* torch.rand()
* torch.randn()
* torch.randint()
* torch.from_numpy()
torch.arange和python内置的range的使用方法基本相同，其中第三个参数是步长
torch.eye(3,3)创建斜对角线为1的矩阵
torch.linspace的第三个参数指定返回的个数
torch.zeros返回全0矩阵
import torch print(torch.arange(5)) #tensor([0, 1, 2, 3, 4]) print(torch.arange
(1,5,2)) #tensor([1, 3]) print(torch.linspace(0,5,10)) #ensor([0.0000, 0.5556,
1.1111, 1.6667, 2.2222, 2.7778, 3.3333, 3.8889, 4.4444,5.0000]) print(torch.ones
(3,3)) #tensor([[1., 1., 1.], # [1., 1., 1.], # [1., 1., 1.]]) print(torch.zeros
(3,3)) #tensor([[0., 0., 0.], # [0., 0., 0.], # [0., 0., 0.]])
torch.rand返回范围为[0,1]的均匀分布采样的元素所组成的矩阵
torch.randn返回从正态分布采样的元素所组成的矩阵
torch.randint返回指定区间的均匀分布采样的随机整数所生成的矩阵
print(torch.rand(3,3)) #0-1之间的三行三列 #tensor([[0.9195, 0.1319, 0.4128],
#[0.0908, 0.6542, 0.5087], # [0.6761, 0.0876, 0.0532]]) print(torch.randint(0,9,
(3,3))) #tensor([[2, 0, 2], # [7, 1, 7], # [4, 0, 1]])
从numpy中获得数据
a=numpy.array([1,2,3,4,5]) print(torch.from_numpy(a)) #tensor([1, 2, 3, 4, 5],
dtype=torch.int32) t=torch.from_numpy(a) print(t[0]) #tensor(1,
dtype=torch.int32)
<>Tensor的索引和切片

* torch.nonzero()
* torch.where(condition,x,y)
*
torch.nonzero用于返回非零值的索引矩阵
a=torch.arange(9).view(3,3) index=torch.nonzero(a>=8) print(index)
#tensor([[2, 2]]) a=torch.randint(0,2,(3,3)) print(a) #tensor([[1, 1, 0], # [1,
1, 1], # [0, 1, 0]]) index=torch.nonzero(a) print(index) #tensor([[0, 0], # [0,
1], # [1, 0], # [1, 1], # [2, 0], # [2, 2]])

torch.where(condition,x,y)判断conditon的条件是否满足，当某个元素满足条件时，则返回对应矩阵x相同矩阵的元素，否则返回矩阵y的元素
x=torch.randn(3,2) print(x) #tensor([[ 0.0686, 0.9833], # [ 0.4247, -0.1751],
# [ 1.3361, -0.5646]]) y=torch.ones(3,2) print(y) #tensor([[1., 1.], # [1., 1.],
# [1., 1.]]) print(torch.where(x>0,x,y)) #tensor([[0.6920, 1.0000], # [0.2726,
1.0000], # [1.0000, 0.4488]])
<>Tensor的变换，拼接和拆分

* torch.cat()
* torch.stack()
* torch.split()
* torch.chunk()
Tensor.nelement,Tensor.ndimension,ndimension.size可分别用来查看矩阵元素个数，轴的个数以及维度
属性Tensor.shape也可以查看Tensor的维度 a=torch.rand(1,2,3,4,5) #五维的 个数为1*2*3*4*5 print(
"元素个数",a.nelement()) #元素个数 120 print("轴的个数",a.ndimension()) #轴的个数 5 print("矩阵维度"
,a.size(),a.shape) #矩阵维度 torch.Size([1, 2, 3, 4, 5]) torch.Size([1, 2, 3, 4, 5])

Tensor.view和Tensor.reshape都能被用来更改Tensor的维度，它们的区别在于，Tensor.view要求Tensor的物理存储必须是连续的否则将报错，而Tensor.reshape没有这种要求。Tensor.view返回的是一个索引，更改返回值，则原始值也会被改变。Tensor,reshape返回的是引用还是复制是不确定的。它们的相同之处在于都要接收输出的维度作为参数。可以在维度中输出-1,PyTorch会自动推断它的数值
b=a.view(2*3,4*5) print(b.shape) #torch.Size([6, 20]) c=a.reshape(-1) print(c.
shape) #torch.Size([120]) d=a.reshape(2*3,-1) print(d.shape) #torch.Size([6,
20])

PyTorch提供了torch,cat和torch.stack用于拼接矩阵，不同之处是torch.cat在已有的轴dim上拼接矩阵，给定轴的维度可以不同，而其他轴的维度必须相同。torch,stack在新的轴上拼接，它要求被拼接的矩阵所有维度都要相同
a=torch.randn(2,3) print(a) #tensor([[-0.6382, -0.2846, -0.4478], # [ 0.5261,
0.1390, -1.2212]]) b=torch.randn(3,3) print(b) #tensor([[ 0.4052, -1.1623,
1.0163], #[ 0.6644, 1.1510, -0.4528], #[ 0.4046, -0.1125, 1.1805]]) #默认维度为dim=0
c=torch.cat((a,b)) print(c) #tensor([[ 0.6781, 0.3404, -1.0138], # [-0.0582,
0.2744, 0.4065], # [ 2.0596, 0.8160, 0.6391], # [ 1.6246, 0.1964, 1.8078], # [
1.0482, 0.6085, -0.6127]]) d=torch.cat((b,b,b),dim=1) #维度为1是按列拼接 print(d)
#tensor([[-0.3286, 1.9219, -0.9029, -0.3286, 1.9219, -0.9029, -0.3286, 1.9219,
# -0.9029] # [ 0.3017, -0.4240, -0.0260, 0.3017, -0.4240, -0.0260, 0.3017,
-0.4240, # -0.0260], # [-0.0038, -1.1274, -0.4668, -0.0038, -1.1274, -0.4668,
-0.0038, -1.1274, # -0.4668]]) c=torch.stack((b,b),dim=1) print(c) #tensor([[[
0.1392, 2.2047, -0.2022], # [ 0.1392, 2.2047, -0.2022]], # [[ 0.6079, -0.0103,
1.3908], # [ 0.6079, -0.0103, 1.3908]], # [[-2.0081, 0.3080, 0.2132], #
[-2.0081, 0.3080, 0.2132]]]) d=torch.stack((b,b),dim=0) print(d) #tensor([[[
0.1392, 2.2047, -0.2022], # [ 0.6079, -0.0103, 1.3908], # [-2.0081, 0.3080,
0.2132]], # # [[ 0.1392, 2.2047, -0.2022], # [ 0.6079, -0.0103, 1.3908], #
[-2.0081, 0.3080, 0.2132]]])

除了拼接矩阵，PyTorch还提供了torch.split和torch.chunk用于拆分矩阵，它们的不同之处在于torch.split传入的是拆分后的每个矩阵的大小，可以传入list
,也可以传入整数
a=torch.randn(10,3) for x in torch.split(a,[1,2,3,4],dim=0):
#按照10这个维度去分块，每大块分为1，2，3，4 print(x.shape) #torch.Size([1, 3]) #torch.Size([2, 3])
#torch.Size([3, 3]) #torch.Size([4, 3]) for x in torch.split(a,4,dim=0):
#按照10这个维度去分，每块包含四个小块，最后一块只能凑到两个小块 print(x.shape) #torch.Size([4, 3])
#torch.Size([4, 3]) #torch.Size([2, 3]) for x in torch.chunk(a,4,dim=0): print(x
.shape) #torch.Size([3, 3]) #torch.Size([3, 3]) #torch.Size([3, 3])
#torch.Size([1, 3]) #拆分的矩阵个数为4
<>Pytorch的Reduction操作

* 求全局的最大值及其索引
* 沿横轴计算每一列的累加
* 沿纵轴计算每一列的累乘
* 计算矩阵的均值，中值，协方差
a.mean(),a.median(),a.std()
* torch.unique用来找出矩阵中出现了哪些元素 a=torch.tensor([[1,2],[3,4]]) print("全局最大值:",
torch.max(a)) #全局最大值: tensor(4) #沿着横轴计算每一列的叠加 print(torch.max(a,dim=0))
#返回最大值以及索引 #tensor([[1, 2], # [4, 6]]) #沿着纵轴计算每一行的叠加 print(torch.cumsum(a,dim=1)
) #tensor([[1, 3], # [3, 7]]) print(torch.cumprod(a,dim=0)) #tensor([[1, 2], #
[3, 8]]) #沿着纵轴计算每一行的累乘 print(torch.cumprod(a,dim=1)) #tensor([[ 1, 2], # [ 3,
12]]) #torch.unique用来找出矩阵中出现了哪些元素 a=torch.randint(0,3,(3,3)) print(a)
#tensor([[0, 2, 2], # [1, 0, 1], # [0, 1, 0]]) print(torch.unique(a))
#tensor([0, 1, 2])

• « 上一篇：【dataX推送数据之mysql到mysql】
• » 下一篇：链式栈（c)