第一次作业：深度学习基础
2.1数据操作
首先安装实验所需的d2l库
!pip install git+https://github.com/d2l-ai/d2l-zh@release
2.1.1关于张量的数据操作
首先导入torch
torch.arrange(n)作用是生成一个0到n-1的行向量
通过张量的shape属性来访问张量的形状
x.numel()可以输出张量的元素个数
输入：
import torch x = torch.arange(12) print(x) print(x.shape) print(x.numel())
输出：
tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) torch.Size([12]) 12
要改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数。reshape函数通过改变张量的形状，但张量的大小不会改变。
X = x.reshape(3, 4)
X
tensor([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
torch.zeros(),torch.ones()生成一个指定大小的全0或全1的张量。
torch.zeros((2, 3, 4))
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.]]])
torch.tensor()函数生成一个指定数值的张量。
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.randn()创建一个张量。其中的每个元素都从均值为0、标准差为1的标准高斯（正态）分布中随机采样。
torch.randn(3, 4)
tensor([[-0.0256, -0.1554, -0.7813, -1.6794], [-0.7172, 0.4402, -0.3877, 1.4351], [ 0.8585, 1.7536, -1.4469, 0.9900]])
2.1.2运算
张量的基本运算，其中x**y是对x求y次方。
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.]))
张量可以按轴连接，轴0是第一维，轴1是第二维，也就是按行列。
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来判断两个张量是否相等。
X == Y
tensor([[False, True, False, True],
[False, False, False, False],
[False, False, False, False]])
X.sum()
tensor(66.)
2.1.3. 广播机制
当张量形状不同时可以调用广播机制来来执行按元素操作。
通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状，然后对生成的数组执行按元素操作。
在大多数情况下，我们将沿着数组中长度为1的轴进行广播。
a = torch.arange(3).reshape((3, 1)) b = torch.arange(2).reshape((1, 2)) print(a) print(b) print(a+b)
tensor([[0], [1], [2]]) tensor([[0, 1]]) tensor([[0, 1], [1, 2], [2, 3]])
2.1.4. 索引和切片
可以用[-1]选择最后一个元素，可以用[1:3]选择第二个和第三个元素。
X[-1], X[1:3]
(tensor([ 8., 9., 10., 11.]), tensor([[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]]))
如果想为多个元素赋值相同的值，我们只需要索引所有元素，然后为它们赋值。
X[0:2, :] = 12
X
tensor([[12., 12., 12., 12.], [12., 12., 12., 12.], [ 8., 9., 10., 11.]])
2.1.5. 节省内存
运行一些操作可能会导致为新结果分配内存。例如，如果我们用Y=X+Y，我们将取消引用Y指向的张量，而是指向新分配的内存处的张量。
id函数演示了这一点，它给我们提供了内存中引用对象的确切地址。
before = id(Y) Y = Y + X id(Y) == before
False
可以使用切片表示法将操作的结果分配给先前分配的数组（该张量不参与运算时）该张量的地址不会发生改变
torch.zeros_like(y)分配一个全0的块。
Z = torch.zeros_like(Y) print('id(Z):', id(Z)) Z[:] = X + Y print('id(Z):', id(Z))
id(Z): 140272150341696
id(Z): 140272150341696
如果在后续计算中没有重复使用X，我们也可以使用X[:]=X+Y或X+=Y来减少操作的内存开销。
before = id(X) X += Y id(X) == before
True
2.1.6. 转换为其他 Python 对象
使用torch.tensor()将numpy转换为张量，反之可以通过.numpy()函数转换。
A = X.numpy() B = torch.tensor(A) type(A), type(B)
(numpy.ndarray, torch.Tensor)
要将大小为1的张量转换为Python标量，我们可以调用item函数或Python的内置函数。 item()返回的是一个浮点型数据，所以使用item（）时取得的精度更高。
a = torch.tensor([3.5])
a, a.item(), float(a), int(a)
(tensor([3.5000]), 3.5, 3.5, 3)
2.2. 数据预处理
2.2.1. 读取数据集
创建一个人工数据集，并存储在csv（逗号分隔值）文件，导入pandas包并调用read_csv函数从创建的csv文件中加载原始数据集。
import os os.makedirs(os.path.join('..', 'data'), exist_ok=True) data_file = os.path.join('..', 'data', 'house_tiny.csv') with open(data_file, 'w') as f: f.write('NumRooms,Alley,Price\n') # 列名 f.write('NA,Pave,127500\n') f.write('2,NA,106000\n') f.write('4,NA,178100\n') f.write('NA,NA,140000\n') import pandas as pd data = pd.read_csv(data_file) print(data)
NumRooms Alley Price
0 NaN Pave 127500
1 2.0 NaN 106000
2 4.0 NaN 178100
3 NaN NaN 140000
2.2.2. 处理缺失值
为了处理确实的数值，典型的方法是插入和删除，其中插值用替代值代替缺失值，而删除则忽略缺失值。这里选择插入处理。
inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2] inputs = inputs.fillna(inputs.mean()) print(inputs) inputs = pd.get_dummies(inputs, dummy_na=True) print(inputs)
get_dummies（）函数对数据进行分类标记，当dummy_na=ture时，将保留分类变量中的缺失值，将其单独作为一列。
使用.iloc()函数取excel数据中特定列数据。
NumRooms Alley 0 3.0 Pave 1 2.0 NaN 2 4.0 NaN 3 3.0 NaN NumRooms Alley_Pave Alley_nan 0 3.0 1 0 1 2.0 0 1 2 4.0 0 1 3 3.0 0 1
2.2.3. 转换为张量格式
现在inputs和outputs中的所有条目都是数值类型，它们可以转换为张量格式。
import torch X, y = torch.tensor(inputs.values), torch.tensor(outputs.values) X, y
(tensor([[3., 1., 0.], [2., 0., 1.], [4., 0., 1.], [3., 0., 1.]], dtype=torch.float64), tensor([127500, 106000, 178100, 140000]))
2.3. 线性代数
2.3.1.矩阵
对称矩阵的转置矩阵与原矩阵相等
B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
B == B.T
tensor([[True, True, True],
[True, True, True],
[True, True, True]])
2.3.2.张量
给定具有相同形状的任意两个张量，任何按元素二元运算的结果都将是相同形状的张量。
A = torch.arange(20, dtype=torch.float32).reshape(5, 4) B = A.clone() # 通过分配新内存，将A的一个副本分配给B A, A + B
(tensor([[ 0., 1., 2., 3.], [ 4., 5., 6., 7.], [ 8., 9., 10., 11.], [12., 13., 14., 15.], [16., 17., 18., 19.]]), tensor([[ 0., 2., 4., 6.], [ 8., 10., 12., 14.], [16., 18., 20., 22.], [24., 26., 28., 30.], [32., 34., 36., 38.]]))
2.3.3.降维
调用求和函数会沿所有的轴降低张量的维度，使它变为一个标量。 还可以指定张量沿哪一个轴来通过求和降低维度。
A = torch.arange(20, dtype=torch.float32).reshape(5, 4) A_sum_axis0 = A.sum(axis=0) A_sum_axis0, A_sum_axis0.shape
输入矩阵沿0轴降维以生成输出向量，因此输入的轴0的维数在输出形状中丢失。
(tensor([40., 45., 50., 55.]), torch.Size([4]))
沿着行和列对矩阵求和，等价于对矩阵的所有元素进行求和。
A.sum(axis=[0, 1]) # Same as `A.sum()`
tensor(190.)
计算平均值的函数也可以沿指定轴降低张量的维度。
A.mean(axis=0), A.sum(axis=0) / A.shape[0]
(tensor([ 8., 9., 10., 11.]), tensor([ 8., 9., 10., 11.]))
2.3.4.非降维求和
利用广播机制进行求平均等运算保持轴数不变
sum_A = A.sum(axis=1, keepdims=True) print(sum_A) A / sum_A
tensor([[ 6.], [22.], [38.], [54.], [70.]]) tensor([[0.0000, 0.1667, 0.3333, 0.5000], [0.1818, 0.2273, 0.2727, 0.3182], [0.2105, 0.2368, 0.2632, 0.2895], [0.2222, 0.2407, 0.2593, 0.2778], [0.2286, 0.2429, 0.2571, 0.2714]])
想沿某个轴计算A元素的累积总和，比如axis=0（按行计算），我们可以调用cumsum函数。此函数不会沿任何轴降低输入张量的维度。
A.cumsum(axis=0)
tensor([[ 0., 1., 2., 3.], [ 4., 6., 8., 10.], [12., 15., 18., 21.], [24., 28., 32., 36.], [40., 45., 50., 55.]])
2.3.5.点积
点积是相同位置的按元素乘积的和，可以通过.dot()函数求矩阵点积
y = torch.ones(4, dtype = torch.float32) x = torch.arange(4, dtype=torch.float32) x, y, torch.dot(x, y)
(tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.))
也可以通过执行按元素乘法，然后进行求和来表示两个向量的点积
torch.sum(x * y)
tensor(6.)
2.3.6.矩阵-向量积
就是线性代数的知识的代码实现。
A.shape, x.shape, torch.mv(A, x)
(torch.Size([5, 4]), torch.Size([4]), tensor([ 14., 38., 62., 86., 110.]))
2.3.7.矩阵-矩阵乘法
我们可以将矩阵-矩阵乘法AB看作是简单地执行m次矩阵-向量积，并将结果拼接在一起，形成一个n×m矩阵。
B = torch.ones(4, 3)
torch.mm(A, B)
tensor([[ 6., 6., 6.], [22., 22., 22.], [38., 38., 38.], [54., 54., 54.], [70., 70., 70.]])
2.3.8.范数
L2范数是向量元素平方和的平方根
u = torch.tensor([3.0, -4.0])
torch.norm(u)
tensor(5.)
L1范数是所有元素绝对值的和
torch.abs(u).sum()
tensor(7.)
矩阵的弗罗贝尼乌斯范数（Frobenius norm）是矩阵元素平方和的平方根
torch.norm(torch.ones((4, 9)))
tensor(6.)
2.4自动求导
2.4.1反向传播
该代码是对y=2xTx函数关于列向量x求导。
requires_grad用于说明当前量是否需要在计算中保留对应的梯度信息,默认值为False
通过调用反向传播函数backward()来自动计算y关于x每个分量的梯度。
import torch x = torch.arange(4.0) x.requires_grad_(True) # 等价于 `x = torch.arange(4.0, requires_grad=True)` print(x.grad) # 默认值是None y = 2 * torch.dot(x, x) y.backward() print(x.grad) x.grad == 4 * x
None tensor([ 0., 4., 8., 12.]) tensor([True, True, True, True])
x.grad默认的初始值为None
默认情况下，PyTorch会累积梯度，我们需要使用.grad.zero_()清除之前的值
x.grad.zero_() y = x.sum() y.backward() x.grad
tensor([1., 1., 1., 1.])
2.4.2. 非标量变量的反向传播
当y不是标量时，向量y关于向量x的导数的最自然解释是一个矩阵。对于高阶和高维的y和x，求导的结果可以是一个高阶张量。
# 对非标量调用`backward`需要传入一个`gradient`参数，该参数指定微分函数关于`self`的梯度。在我们的例子中，我们只想求偏导数的和，所以传递一个1的梯度是合适的 x.grad.zero_() y = x * x # 等价于y.backward(torch.ones(len(x))) y.sum().backward() x.grad
tensor([0., 2., 4., 6.])
2.4.3. 分离计算
有时，我们希望将某些计算移动到记录的计算图之外。 例如，假设y是作为x的函数计算的，而z则是作为y和x的函数计算的。 现在，想象一下，我们想计算z关于x的梯度，但由于某种原因，我们希望将y视为一个常数，并且只考虑到x在y被计算后发挥的作用。
在这里，我们可以分离y来返回一个新变量u，该变量与y具有相同的值，但丢弃计算图中如何计算y的任何信息。换句话说，梯度不会向后流经u到x。因此，下面的反向传播函数计算z=u*x关于x的偏导数，同时将u作为常数处理，而不是z=x*x*x关于x的偏导数。
x.grad.zero_() y = x * x u = y.detach() z = u * x z.sum().backward() x.grad == u
tensor([True, True, True, True])
2.4.4. 控制流的梯度计算
使用自动求导的一个好处是，即使构建函数的计算图需要通过Python控制流（例如，条件、循环或任意函数调用），我们仍然可以计算得到的变量的梯度。在下面的代码中，while循环的迭代次数和if语句的结果都取决于输入a的值。
f函数在其输入a中是分段线性的。换言之，对于任何a，存在某个常量标量k，使得f(a)=k*a，其中k的值取决于输入a。因此，d/a允许我们验证梯度是否正确。
def f(a): b=a*2 while b.norm()<1000: b=b*2 if b.sum()>0: c=b else: c=100*b return c a=torch.randn(size=(),requires_grad=True) print(a) d=f(a) d.backward() a.grad==d/a
tensor(-0.5575, requires_grad=True) tensor(True)
疑问
1.为什么X[:]=x+y会比Y=X+Y减少内存分配（上文标绿处）
2.利用广播机制进行求平均等运算保持轴数不变
sum_A = A.sum(axis=1, keepdims=True)
keepdims=true执行完后，生成的是5行一列，也是两个轴啊，那最后一行代码A / sum_A意义是什么？（不是很理解）
tensor([[ 6.],
[22.],
[38.],
[54.],
[70.]])
3.对降维再求导有点难理解
感想
经过一周的学习感觉自己在理解一些数学推导上有点困难，得再加把劲。李沐老师的动手学深度学习从很基础讲起，听课感觉没之前想的困难，所以要更努力得学习了。
浙公网安备 33010602011771号