一、张量
概念：张量表示一个数值组成的数组，这个数组可能有多个维度
具有一个轴的张量对应数学上的向量（vector）
具有两个轴的张量对应数学上的矩阵（matrix）
二、数据操作
1、使用arange创建一个行向量。创建的行向量包含从0开始的前12个整数，默认创建为浮点数。张量中的每个值都称为张量的元素（element）
#第一步，导入pytorch包 import torch #第二步，创建行向量 # 新的张量存储在内存中，并采用基于CPU的计算 x = torch.arange(12) print(x,type(x)) x.shape
#输出结果
2、可以使用张量shape属性来访问张量的形状，对向量来说可以理解为求张量中元素的总数，对矩阵来说，可以理解为沿每个轴的长度
print(x.shape)
x.numel()
y=torch.tensor([[1,2,3],[4,5,6]])
print(y.shape)
print(y)
#输出结果
#可以看见，因为x是向量，可以直接查看元素个数
torch.Size([12])
#因为y是矩阵，shape便显示在每个方向上的大小，也就是元素个数
torch.Size([2, 3])
tensor([[1, 2, 3],
[4, 5, 6]])
3、改变一个张量的形状而不改变元素数量和元素值，可以调用 reshape 函数，同时注意的是，reshape函数只改变他的形状不改变元素值。
我们可以用x.reshape(-1,4)或x.reshape(3,-1)来取代x.reshape(3,4)，-1表示缺省值，由系统自动计算出
# x是一个向量，也就是一个12*1的矩阵
print(x)
print(type(x))
# 使用reshape函数把它变为一个三行四列的矩阵
# 只是形状发生了变化，但是值的大小没有变化
X = x.reshape(3, 4)
print(X)
print(type(X))
#输出
tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
<class 'torch.Tensor'>
tensor([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
<class 'torch.Tensor'>
4、使用全0、全1、其他常量或者从特定分布中随机采样的数字来初始化矩阵
设置全0：zeros
# zeros将所有元素设为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.]]])
设置全1：ones
# ones将所有元素设为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.]]])
随机设置：randn
# randn创建一个形状为（3，4）的张量，每个元素都从均值为0、标准差为1的正态分布中随机采样
torch.randn(3, 4)
#输出结果
tensor([[-0.1957, -0.0284, 1.0563, 0.2526],
[-0.4205, 0.2026, 0.2376, -0.3273],
[-0.6187, 0.3032, -0.0050, -0.6948]])
5、直接赋值创建tensor
通过提供包含数值的python列表来为所需张量中的每个元素赋予确定值。在这里，最外层的列表对应于轴0，内层的列表对应于轴1
y=torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
x=torch.tensor([[1,2,3],[4,5,6]])
print(x)
print(y)
#输出结果
tensor([[1, 2, 3],
[4, 5, 6]])
tensor([[2, 1, 4, 3],
[1, 2, 3, 4],
[4, 3, 2, 1]])
6、数据运算——加减乘除
x = torch.tensor([1.0, 2, 4, 8]) y = torch.tensor([2, 2, 2, 2]) # size()不能看一个张量的个数，可以看arange向量的个数 # numel()可以查看一个张量中元素的个数 print(x) print(x.numel()) print(y) print(y.numel()) x + y, x - y, x * y, x / y, x**y # **运算符是求幂运算 #输出结果 tensor([1., 2., 4., 8.]) 4 tensor([2, 2, 2, 2]) 4 (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.]))
7、指数运算，就e的次方
# 求e的多少次方 import math print(math.exp(1))
# 可以直接按元素顺序进行计算 torch.exp(x) #输出结果 2.718281828459045 tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])
8、张量连接
把多个张量 连结（concatenate） 在一起，把它们端对端地叠起来形成一个更大的张量。
X = torch.arange(12, dtype=torch.float32).reshape((3, 4))
print(X,type(X))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
print(Y,type(Y))
# cat函数用于连接两个tensor
# dim=0 表示按行连接
print(torch.cat((X, Y), dim=0))
# dim=1 表示按列连接
print(torch.cat((X, Y), dim=1))
#输出结果
tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]]) <class 'torch.Tensor'>
tensor([[2., 1., 4., 3.],
[1., 2., 3., 4.],
[4., 3., 2., 1.]]) <class 'torch.Tensor'>
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.]])
9、逻辑运算符构建二元张量
以 X == Y 为例。 对于每个位置，如果 X 和 Y 在该位置相等，则新张量中相应项的值为1，这意味着逻辑语句 X == Y 在该位置处为真，否则该位置为 0
# 通过逻辑运算符构建二元张量
# 如果X、Y在该位置相等，则新张量中相应项的值为1
X == Y
#输出结果
tensor([[False, False, False, False],
[False, False, False, False],
[False, False, False, False]])
10、张量中所有元素求和会产生一个只有一个元素的张量
# 对所有元素求和，产生了一个只有一个元素的张量 X.sum() #输出结果 tensor(66.)