数据操作

1、入门

x = torch.arange(12)
print(x)
print(x.shape)
print(x.numel())
X = x.reshape(3, 4)  #改变张量的形状
print(X)
print(X.shape)
X = x.reshape(-1, 4)  #可以通过-1来调用自动计算形状变为3 * 4的矩阵
print(X)
X = x.reshape(3, -1)
print(X)
a = torch.zeros(3, 4)  #初始化矩阵为全0
print(a)
b = torch.ones(3, 4)
print(b)  #初始化矩阵为全1
c = torch.randn(3, 4)  #随机初始化,每个元素从均值为0、标准化为1的标准高斯分布(正态分布)中随机采样
print(c)
d = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  #用列表的方式来为所需张量中每个元素赋予确定值
print(d)

Output

tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
torch.Size([12])
12
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
torch.Size([3, 4])
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])
tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
tensor([[ 3.8151e-01, -1.3260e-01,  1.6986e+00, -1.9250e-03],
        [-1.5357e+00, -1.2644e+00, -1.5128e-01, -2.4781e+00],
        [ 8.2790e-01,  2.4841e-01, -4.3096e-02, -3.5934e-01]])
tensor([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])

2、运算符

1、按元素运算

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
print(x + y) #按元素加法
print(x - y) #按元素减法
print(x * y) #按元素乘法
print(x / y) #按元素除法
print(x ** y) #按元素幂
print(torch.exp(x)) #指数运算,每个元素计算e^x

Output

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.])
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

2、张量连接与一些特殊运算
张量连接，即把他们端对端地叠起来形成一个更大的张量。我们只需要提供张量列表，并给出沿哪个轴连接。下面例子分别演示了当我们按行(轴0，形状的第一个元素)和按列(轴1，形状的第二个元素)连接两个矩阵时，会发生什么情况

X = torch.arange(12, dtype=torch.float32).reshape(3, 4) #这里的dtype用来设置元素的类别
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
print(torch.cat((X, Y), dim=0))
print(torch.cat((X, Y), dim=1))
Z = X == Y #逻辑运算符构建二元张量,判断每个元素是否相等
print(Z)
print(X.sum()) #对张量中的所有元素求和，会产生一个单元素张量

Output

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.]])
tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])
tensor(66.)

3、广播机制
对于形状不同的张量，按元素操作的时候会发生广播机制，这种机制工作的方式如下：

• 通过适当复制元素来扩展一个或两个数组，以便在转换后，两个张量具有相同的形状
• 对生成的数组执行按元素操作

a = torch.arange(3).reshape(3, 1)
b = torch.arange(2).reshape(1, 2)
print(a)
print(b)
print(a + b)

Output

tensor([[0],
        [1],
        [2]])
tensor([[0, 1]])
tensor([[0, 1],
        [1, 2],
        [2, 3]])

PS:感觉这样记笔记效率太低了，下次就不这么记笔记了，以后会分享一些重要模型代码实现~