Pytorch入门基础知识

入门

张量

具有一个轴的张量对应数学上的向量（vector）
具有两个轴的张量对应数学上的矩阵（matrix）
具有两个轴以上的张量没有特殊的数学名称
张量中的每个值都称为张量的元素（element）

import torch
#创建一个行向量，默认创建为整数，也可以指定创建类型为浮点数
x = torch.arange(12)

#输出x为：
#tensor([0,1,2,3,4,5,6,7,8,9,10,11])
#输出x的形状，即可以通过shape属性来访问张量（沿每个轴的长度）的形状
x.shape
#输出为：
# torch.Size([12]) 

如果只想知道张量中元素的总数，即形状的所有元素乘积，可以检查它的大小（size），因为这里在处理的是一个向量，所以它的shape 和它的size 相同。

x.numel()
#输出结果为：
#12

要想改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数。如将张量x从形状为12的行向量转换为形状为（3，4）的矩阵

X = x.reshape(3,4)
X
#输出为：
#tensor([[0,1,2,3],
#				[4,5,6,7],
#				[8,9,10,11]])

不指定高度或宽度时，可以通过-1来调用自动计算维度的功能，即：

x.reshape(-1,4)
x.reshape(3,-1)
x.reshape(3,4)

上述三种表述方式等价

#创建一个形状为（2，3，4）的张量，其中所有元素都设置为0
torch.zeros((2,3,4))
#输出为：
# tensor（[[[0.,0.,0.,0.],
#           [0.,0.,0.,0.],
#           [0.,0.,0.,0.]],
#          [[0.,0.,0.,0.],
#           [0.,0.,0.,0.],
#				   [0.,0.,0.,0.]]]）
#创建一个形状为（2，3，4）的张量，其中所有元素都设置为1
torch.ones((2,3,4))
#输出为：
# tensor（[[[1.,1.,1.,1.],
#           [1.,1.,1.,1.],
#           [1.,1.,1.,1.]],
#          [[1.,1.,1.,1.],
#           [1.,1.,1.,1.],
#				   [1.,1.,1.,1.]]]）
#以下代码创建一个形状为（3,4）的张量。其中的每个元素都从均值为0、标准差为1的标准高斯分布（正态
#分布）中随机采样
torch.randn(3, 4)
#输出为：
#tensor([[-0.0135, 0.0665, 0.0912, 0.3212],
#			 [ 1.4653, 0.1843,-1.6995,-0.3036],
#			 [ 1.7646, 1.0450, 0.2457,-0.7732]])

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y # **运算符是求幂运算
#输出为：
#(tensor([ 3., 4., 6., 10.]),
#tensor([-1., 0., 2., 6.]),
#tensor([ 2., 4., 8., 16.]),
#tensor([0.5000, 1.0000, 2.0000, 4.0000]),
#tensor([ 1., 4., 16., 64.]))
#“按元素”方式可以应用更多的计算，包括像求幂这样的一元运算符。
torch.exp(x)
#输出为：
#tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

可以把多个张量连结（concatenate）在一起，当沿行（轴‐0，形状的第一个元素）和按列（轴‐1，形状的第二个元素）连结两个矩阵时，会发生什么情况。我们可以看到，第一个输出张量的轴‐0长度（6）是两个输入张量轴‐0长度的总和（3 + 3）；第二个输出张量的轴‐1长度（8）是两个输入张量轴‐1长度的总和（4 + 4）。

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)

输出为：

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

有时，我们想通过逻辑运算符构建二元张量。举例：对于每个位置，如果X和Y在该位置相等，则新
张量中相应项的值为1。这意味着逻辑语句X == Y在该位置处为真，否则该位置为0。

X == Y
#tensor([[False, True, False, True],
#				[False, False, False, False],
#				[False, False, False, False]])
#对张量中的所有元素进行求和，会产生一个单元素张量。
X.sum()
#tensor(66.)