动手学深度学习——数据操作笔记

1. 张量概念

 张量本质上是一个n维数组，它在numpy中为ndarray,  在pytorch中称为tensor ， 两者的区别在于：

• numpy仅支持CPU计算
• tensor能支持GPU运算，并且支持自动微分，更适合深度学习

2. 张量的访问

一个二维矩阵a，可以使用切片的方式灵活访问：

• 访问指定元素：a [1,2]
• 访问一整行元素：a [1,:]
• 访问一整列元素：a[:,1]
• 访问1到3行之间、第1列以后的矩形区域：a[1:3, 1:]，切片统一是左闭右开
• 跳跃访问：a[::3, ::2] 表示每3行取一行（0，3，6……）、每2列取一列（0，2，4……）的方式访问

3. 张量的初始化

• x = torch.arrange(12) : 初始化元素数量为12的一维张量（tensor), 元素值分别为从0开始的前12个整数。
• x.shape：张量的形状，即张量的维度信息，例如：1维12列。
• x.numel：元素数量，类似于数组的len函数。
• y = x.reshape(3,4)： 修改张量的形状为3行4列，元素数量及值不变，y只是x的一个view。
• torch.zeros((2,3,4)) 和torch.ones((2,3,4))，torch.randn(2,3,4): 创建指定形状的张量，并初始化为全0或全1或全随机数。
• torch.tensor([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) : 创建一个张量并为每个元素赋确定值。

4. 运算

标准运算：直接使用算术运算符+、-、*、/对具有相同形状的张量进行操作，它将对每个位置的元素分别使用运算符进行操作。

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

 多个张量连接：

# dtype可以指定初始元素值的类型为float，而不是默认的整数。
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]])
# X
(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]),
# Y
(tensor([[ 2.,  1.,  4.,  3.],
         [ 1.,  2.,  3.,  4.],
         [ 4.,  3.,  2.,  1.]]),


# dim=0表示按照第1维（即行）进行数据连接，将Y矩阵每一行连接到X矩阵每一行的后面，
# dim=1则表示按照第二维（即列）进行数据列表
torch.cat((X, Y), dim=0), 
# 输出
 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()

5. 广播机制

用于对形状不同的矩阵执行按元素操作，工作机制为：

• 通过复制元素来扩展矩阵，以便两个张量具有相同的形状。
• 对扩展后相同形状的矩阵执行上述操作。

两个张量：a 为3行1列，b为1行2列

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

6. 切片赋值

• 指定元素赋值

X[1, 2] = 9

• 多个元素赋相同的值

# 矩阵前两行的每个元素都赋值12
X[0:2, :] = 12 

# 输出X
tensor([[12., 12., 12., 12.],
        [12., 12., 12., 12.],
        [ 8.,  9., 10., 11.]])

7. 原地操作

  有些操作会引起新分配内存，例如：

before = id(Y)
# 这一步运算后，Y已经指向了另一个地址
Y = Y + X
id(Y) == before

# 输出
False

这会带来的问题是：在机器学习中，我们可能有数百兆的参数，并且在一秒内多次更新所有参数。通常情况下，我们希望原地执行这些更新。

 原地操作的方法：

# 原地操作写法-1
Y[:] = X + Y
# 原地操作写法-2
X += Y

8. 张量与numpy的转换

• A = X.numpy()     # 张量转换为numpy数组
• B = torch.tensor(A)   # numpy数组转换为张量
• a.item()           # 将只有一个元素的张量转换为普通的python变量