【李沐深度学习笔记】数据操作实现

课程地址

数据操作实现p2

数据操作

首先导入PyTorch包（import torch)，虽然叫PyTorch，但实际上要导入torch。

import torch

张量

张量表示的是一个数值组成的数组，这个数组可以有很多个维度。

# 生成0-11的顺序序列构成的一维数组张量（12那里是开区间，取不到）
x = torch.arange(12)
print(x)

输出结果：tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

张量的形状和元素个数

# 访问张量的形状（一维显示长度）
print(x.shape)
# 张量中元素的个数
print(x.numel())

输出结果：
torch.Size([12])
12

改变张量的形状

将上面的张量变为3X4的矩阵形式

print(x.reshape(3,4))

输出结果：

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

全0和全1张量

# 定义1个3X4的张量，元素全为0
x = torch.zeros((3,4))
print(x)
# 定义1个2X3X4的张量，元素全为1
x = torch.ones((2,3,4))
print(x)

输出结果：
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.]],

    [[1., 1., 1., 1.],[1., 1., 1., 1.],[1., 1., 1., 1.]]])

用Python的列表创建张量

# 用Python的列表创建张量（此处为2阶方阵）
x = torch.tensor([[1,2],[3,4]])
print(x)
# 打印其形状（维度）
print(x.shape)

输出结果：
tensor([[1, 2],
[3, 4]])
torch.Size([2, 2])

张量的常见运算

x1 = torch.tensor([1,1,1,3]) # 注意，张量的元素类型必须是相同的，假如这里面有浮点数，则所有元素都是浮点数
x2 = torch.tensor([0,2,0,6])
# 加法
x3 = x1 + x2
print(x3)
# 减法
x3 = x1 - x2
print(x3)
# 乘法
x3 = x1 * x2
print(x3)
# 除法
x3 = x2 / x1 # 0不能做分母
print(x3)
# 幂运算
x3 = x2 ** 2
print(x3)
# 指数函数e^x
x3 = torch.exp(x1)
print(x3)
# 开根号
x3 = torch.sqrt(x1)
print(x3)

运行结果：
tensor([1, 3, 1, 9])
tensor([ 1, -1, 1, -3])
tensor([ 0, 2, 0, 18])
tensor([0., 2., 0., 2.])
tensor([ 0, 4, 0, 36])
tensor([ 2.7183, 2.7183, 2.7183, 20.0855])
tensor([1.0000, 1.0000, 1.0000, 1.7321])

连结张量

# 按1到11的序列，并转换为3X4的矩阵，指定元素类型是32位浮点数
X = torch.arange(12, dtype=torch.float32).reshape(3,4)
Y = torch.tensor([[9,2,1,0],[3,1,0,2],[1,1,1,1]])
print("X=")
print(X)
print("Y=")
print(Y)
# 按行合并，dim参数设置为0
X1 = torch.cat((X,Y),dim=0)
print("dim=0:")
print(X1)
# 按列合并，dim参数设置为1
X1 = torch.cat((X,Y),dim=1)
print("dim=1:")
print(X1)

运行结果：
X=
tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
Y=
tensor([[9, 2, 1, 0],
[3, 1, 0, 2],
[1, 1, 1, 1]])
dim=0:
tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[ 9., 2., 1., 0.],
[ 3., 1., 0., 2.],
[ 1., 1., 1., 1.]])
dim=1:
tensor([[ 0., 1., 2., 3., 9., 2., 1., 0.],
[ 4., 5., 6., 7., 3., 1., 0., 2.],
[ 8., 9., 10., 11., 1., 1., 1., 1.]])

通过逻辑运算符构建二维张量

判断两个维度和形状一致的张量是否相等，将对应位置元素是否相等的布尔值构建成一个元素全为布尔值的二维张量

a = torch.tensor([[1,2],[3,4]])
b = torch.tensor([[1,3],[2,4]])
print(a==b)

运行结果：
tensor([[ True, False],
[False, True]])

求和

# 对张量中所有元素求和，生成的是一个元素的张量（不是数字类型）
a = torch.tensor([[1,2],[3,4],[5,6]])
print(a.sum())

运行结果：
tensor(21)

广播机制

【问】什么是PyTorch的广播机制？
【chatGPT回答】在PyTorch中，广播机制是指在进行张量（Tensor）操作时，自动调整不同形状的张量，使它们能够按照一定规则进行元素级别的运算。
广播机制的主要目的是为了简化张量操作的代码编写过程，减少不必要的复制和内存消耗，并且增加代码的可读性。
当我们对两个形状不同的张量进行元素级别的运算时，广播机制会自动调整其中一个形状，使其与另一个张量的形状相匹配，从而使两个张量能够进行元素级别的运算。
具体来说，广播机制遵循以下规则：

如果两个张量的维度数不同，将较低维度的张量进行扩展，直到维度匹配。这通常是通过在维度较小的张量前面添加大小为1的维度来实现的。
如果两个张量在某个维度上的大小不一致，但其中一个张量的大小为1，那么可以通过复制该张量的数据来扩展其大小以匹配另一个张量。
如果两个张量在某个维度上的大小都不一致，并且都不为1，则不能进行广播，会引发形状不匹配的错误。

通过广播机制，我们可以方便地对不同形状的张量进行元素级别的运算，而不需要手动调整张量的形状。这种灵活性使得我们可以更加高效地进行各种张量操作，如加法、减法、乘法等，而无需显式地复制和扩展张量。
总之，PyTorch中的广播机制允许我们在处理不同形状的张量时，自动调整其形状，使其能够进行元素级别的运算，从而简化了张量操作的编写过程。

# 广播机制测试
a = torch.tensor([[1],[1],[0]])
b = torch.tensor([[1,2]])
print(a+b)

运行结果：
tensor([[2, 3],
[2, 3],
[1, 2]])
这里解释一下，由于a的列数与b的行数相等，所以可以将a的列数扩展复制成b的列数，将b的行数扩展复制成a的行数
$\begin{bmatrix}1 \\1 \\0 \end{bmatrix},b=[1,2]$ ，则按照广播机制，则将其扩展成：
$a_{*}=\begin{bmatrix} 1&1 \\ 1&1 \\0 &0 \end{bmatrix},b_{*}=\begin{bmatrix} 1&2 \\ 1&2 \\ 1&2 \end{bmatrix}，\therefore a_{*}+b_{*}=\begin{bmatrix} 2&3 \\ 2&3 \\ 1&2 \end{bmatrix}$
倘若二者的行维度和列维度根本没有一个是相等的，则报错：

# 报错
a = torch.tensor([[1,2],[3,4]]) # 2*2
b = torch.tensor([[1,2,3],[4,5,6],[7,8,9]]) # 3*3
print(a+b)

报错结果：

元素访问

X = torch.tensor([[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15],[16,17,18],[19,20,0]])
print(X)
# 访问最后一个元素（也就是[7,8,9]这个嵌套在里面的向量）
print(X[-1])
# 访问第2个到第4个元素（二维张量，每个元素是一个一维张量），左闭右开区间
print(X[1:4])

运行结果：
tensor([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12],
[13, 14, 15],
[16, 17, 18],
[19, 20, 0]])
tensor([19, 20, 0])
tensor([[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])

写入张量

X = torch.tensor([[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15],[16,17,18],[19,20,0]])
print(X)
# 访问第3行第2列（下标从0开始）
print(X[2,1])
# 修改第1行第3列元素的值
X[0,2] = 100
print(X)

运行结果：
tensor([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12],
[13, 14, 15],
[16, 17, 18],
[19, 20, 0]])
tensor(8)
tensor([[ 1, 2, 100],
[ 4, 5, 6],
[ 7, 8, 9],
[ 10, 11, 12],
[ 13, 14, 15],
[ 16, 17, 18],
[ 19, 20, 0]])

为多个元素赋相同的值

X = torch.tensor([[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15],[16,17,18],[19,20,0]])
print(X)
# 给第2行到第5行中的第2列到第3列赋值（注意左闭右开）
X[1:6,1:3]=-1
print(X)
# 给第2行到第5行全赋值为-2，不管列，直接写成" : "，不管行也是同理
X[1:6,:]=-2
print(X)

运行结果：
tensor([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12],
[13, 14, 15],
[16, 17, 18],
[19, 20, 0]])
tensor([[ 1, 2, 3],
[ 4, -1, -1],
[ 7, -1, -1],
[10, -1, -1],
[13, -1, -1],
[16, -1, -1],
[19, 20, 0]])
tensor([[ 1, 2, 3],
[-2, -2, -2],
[-2, -2, -2],
[-2, -2, -2],
[-2, -2, -2],
[-2, -2, -2],
[19, 20, 0]])

运行一些操作可能会导致为新结果分配内存

Python中id类似C语言中的指针，通过id的变化可以窥探内存是否分配

# 运行一些操作可能会导致为新结果分配内存
X = torch.ones(3,3)
Y = torch.zeros(3,3)
before = id(Y)
Y = X + Y
print(before == id(Y))

运行结果：
False
视频课答疑区还有这样一个例子

可以看到，b只是对a的一个浅拷贝，修改b也等同于修改a

执行原地操作

直接用[:]赋值不会增加内存，是原地操作

X = torch.ones(3,3)
Y = torch.zeros(3,3)
print("id(X)="+str(id(X)))
X[:]=Y
print("id(X)="+str(id(X)))

运行结果：
id(X)=2411897114928
id(X)=2411897114928
可以看到id是一样的（虽然每个人运行的id可能不同）
说明变量X所占的内存区域是一样的

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

X = torch.ones(3,3)
Y = torch.zeros(3,3)
before = id(X)
X[:] = X + Y
print(before == id(X))

运行结果：
True

转换为NumPy张量

# 将tensor转为numpy张量，再转回来
X = torch.ones(3,3)
A = X.numpy()
B = torch.tensor(A)
print(type(A))
print(type(B))

运行结果：

将大小为1的张量转换为Python标量

# a是PyTorch中的张量
# a.item()对应的是numpy浮点数
# float(a)对应Python中的浮点数
# int(a)对应Python中的整数
a = torch.tensor([3.5])
print(a,a.item(),float(a),int(a))

运行结果：
tensor([3.5000]) 3.5 3.5 3