深度学习之数据操作

1.入门

将获取到的数据读入计算机后对其进行处理。深度学习框架中的张量类适合深度学习：GPU支持加速计算、支持自动微分。

import torch
x = torch.arange(10)
x

tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
可以看到，使用了arange创建了一维向量x。x向量包含以0开始的前10个整数，默认创建为整数。
此外，也可以指定创建类型为浮点数。（张量中的每个值都称为张量的元素。）

x = torch,arange(10,dtype=torch.float32)
x

tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
`
通过张量的shape属性访问张量的形状：

x.shape

torch.Size([10])

检查张量中元素的总数：

x.numel()

10
改变张量的形状而不改变元素数量和元素值，可以调用reshape函数。注意：虽然张量的形状发生了变化，但元素值没有变。

x=x.reshape(2,5)
x

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

创建一个形状为（2，3，4）的元素都为0的张量：

torch.zeros((2,3,4))

创建所有元素为1的张量：

torch.ones((2, 3, 4))

创建每个元素服从均值为0、标准差为1的正态分布的张量，以便以后随机初始化参数的值：

torch.randn(3, 4)

tensor([[ 1.0792, -0.1108, -0.4236, -0.5596],
[-1.1254, -0.6429, 0.3191, 0.0318],
[ 0.9227, -1.1638, 0.3688, -0.1838]])

还可以具体到为每个元素赋值：

torch.tensor([[1,2,3,4],[4,3,2,1],[2,1,3,4]])

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

2.运算符

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])

将多个张量端对端的连接在一起：

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

tensor([[False, True, False, True],
[False, False, False, False],
[False, False, False, False]])

对张量中的所有元素求和：

X.sum()

tensor(66.)
3.广播

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

(tensor([[0],
[1],
[2]]),
tensor([[0, 1]]))
两个矩阵，形状不相同，如果两者相加呢？

a + b

tensor([[0, 1],
[1, 2],
[2, 3]])
a矩阵赋值列元素，b矩阵赋值行元素，然后按元素相加。

4.索引和切片
索引和在python数组中的索引一样：

X[-1], X[1:3]

(tensor([ 8., 9., 10., 11.]),
tensor([[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]]))

还可以指定索引将元素写入矩阵：

X[1, 2] = 9
X

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

为多个元素赋值相同的值：

X[0:2, :] = 12
X

tensor([[12., 12., 12., 12.],
[12., 12., 12., 12.],
[ 8., 9., 10., 11.]])

5.节省内存
在机器学习中，我们可能有数百兆的参数，并且在一秒内多次更新所有参数。 通常情况下，我们希望原地执行这些更新。 其次，如果我们不原地更新，其他引用仍然会指向旧的内存位置， 这样我们的某些代码可能会无意中引用旧的参数。
使用切片法将操作的结果分配给原来的内存

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

id(Z): 140116336758272
id(Z): 140116336758272
如果在后续计算中没有重复使用X， 我们也可以使用X[:] = X + Y或X += Y来减少操作的内存开销。

before = id(X)
X += Y
id(X) == before

True