A = [[1, 2, 3], [0, 1, 0]],B = [[1, 0], [0, 1], [1, 1]]。C[0][1] 是多少?
数字 A = [[1, 2, 3], [0, 1, 0]],B = [[1, 0], [0, 1], [1, 1]]。C[0][1] 是多少?
(3, 4) @ (4, 2) 的形状是什么?
A 是 (3, 2),B 是 (3, 2)。A @ B 会怎样?
选择A 是 (3, 2),B 是 (3, 2)。A @ B 会怎样?
用三层循环写出矩阵乘法,不用 @,也不用 np.dot(a 和 b 是列表的列表)。分别遍历输出的行、输出的列和内侧的大小,每一轮把一个乘积加到某个输出格上。需要写好几行。
代码用三层循环写出矩阵乘法,不用 @,也不用 np.dot(a 和 b 是列表的列表)。分别遍历输出的行、输出的列和内侧的大小,每一轮把一个乘积加到某个输出格上。需要写好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
X 是 (2, 5, 4):2 个句子,每句 5 个词,每个词 4 个数。W 是 (4, 8)。X @ W 是什么形状?
一列形状 (4, 1) 加一行形状 (1, 5)。结果是什么形状?
a = [[1], [2], [3], [4]] 的形状是 (4, 1)。b = [[10, 20, 30, 40, 50]] 的形状是 (1, 5)。(a + b)[2][3] 是多少?
这里只关心形状。一个批的注意力分数形状是 (2, 4, 4):2 个句子,每句 4 个词。填充掩码的形状是 (2, 1, 4)。把掩码用到分数上时,两者广播成什么形状?
X 的形状是 (4, 3)。X.sum(axis=0) 的形状是什么?
从 X 里减去每一列的均值,让每一列的均值都是 0。用 .mean(axis=0) 和广播。
代码从 X 里减去每一列的均值,让每一列的均值都是 0。用 .mean(axis=0) 和广播。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
从 w = 0.5,b = 0 出发。预测值是 0.5、1、1.5,目标值是 2、4、6。均方误差损失是多少?
用直线 ŷ = w·x + b 拟合点 (1, 2)、(2, 4)、(3, 6),损失是 L = mean((w·x + b − y)²)。在 w = 0.5,b = 0 处,∂L/∂w 是多少?
w = 0.5,它的梯度是 −14。学习率为 0.05 时,走一步之后 w 是多少?
用直线 ŷ = w·x + b 拟合点 (1, 2)、(2, 4)、(3, 6)。在 w = 0.5,b = 0 处,损失是 10.5,∂L/∂w = −14,∂L/∂b = −6。最好的直线是 w = 2,b = 0。现在你把学习率从 0.05 换成 0.2,对 w 和 b 各走一步。损失会怎样?
选择用直线 ŷ = w·x + b 拟合点 (1, 2)、(2, 4)、(3, 6)。在 w = 0.5,b = 0 处,损失是 10.5,∂L/∂w = −14,∂L/∂b = −6。最好的直线是 w = 2,b = 0。现在你把学习率从 0.05 换成 0.2,对 w 和 b 各走一步。损失会怎样?
写出 w 的梯度。
代码写出 w 的梯度。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出训练循环的循环体:对 w 和 b 做一步梯度下降。要写好几行。
代码写出训练循环的循环体:对 w 和 b 做一步梯度下降。要写好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
现在的点是 (1, 3)、(2, 5)、(3, 7)。从 w = 0.5,b = 0 出发,学习率 0.05,做一步梯度下降(手算,或者用代码框里的 descend)。走完这一步,b 是多少?
x = [2, 1],W1 = [[1, 2], [0, 1]],W2 = [[1], [1]]。先算 h = x @ W1,再算 out = h @ W2。out 是多少?
W1 = [[1, 2], [0, 1]],W2 = [[1], [1]]。W1 @ W2 的形状是 (2, 1)。它上面那个元素是多少?
σ(0) = 0.5。用 f′(x) = σ(x)·(1 − σ(x)),sigmoid 在 x = 0 处的斜率是多少?
ReLU(x) = max(0, x)。它在 x = −2 处的斜率是多少?
梯度反向穿过 10 层 sigmoid。每一层都把它乘上那一层的 σ′,而 σ′ 最大是 0.25。从梯度 1 开始,不算权重。到达第一层的最多是多少?
选择梯度反向穿过 10 层 sigmoid。每一层都把它乘上那一层的 σ′,而 σ′ 最大是 0.25。从梯度 1 开始,不算权重。到达第一层的最多是多少?
五层 sigmoid,不算权重,最好的情况:梯度被乘了五次 0.25。0.25⁵ = 1 / N。N 是多少?
GELU(x) = x · Φ(x),Φ(−1) = 0.1587。GELU(−1) 是多少?(保留四位小数。)
对数组 x 的每个元素写出 ReLU 的斜率(x > 0 的地方是 1,否则是 0)。
代码对数组 x 的每个元素写出 ReLU 的斜率(x > 0 的地方是 1,否则是 0)。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
对数组 x 的每个元素写出 sigmoid 的斜率:先算 σ(x),再算 σ(x)·(1 − σ(x))。两行。
代码对数组 x 的每个元素写出 sigmoid 的斜率:先算 σ(x),再算 σ(x)·(1 − σ(x))。两行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
x = [2, 1],W1 = [[1, −1], [0, 1]],b1 = [0, 0],激活函数是 ReLU。隐藏层是 h = ReLU(x @ W1 + b1)。第二个隐藏值 h[1] 是多少?
h = [2, 0],W2 = [[2], [−1]],b2 = 0.5。送进输出 sigmoid 的数 z = h @ W2 + b2 是多少?
X 存着 50 个样本,每个 2 个数,形状 (50, 2)。W1 是 (2, 16)。H = tanh(X @ W1 + b1) 是什么形状?
一个 2 → 8 → 1 的网络:2 个输入,一个 8 个单元的隐藏层,1 个输出。它一共有多少个权重和偏置?
一个 2 → 8 → 8 → 1 的网络:2 个输入,两个各 8 个单元的隐藏层,1 个输出。有多少个权重和偏置?
写出隐藏层:X @ W1 加 b1,再取 tanh。
代码写出隐藏层:X @ W1 加 b1,再取 tanh。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出有两个 ReLU 隐藏层的网络的前向传播,然后返回最后一层的输出(W3 和 b3,没有 sigmoid)。好几行。
代码写出有两个 ReLU 隐藏层的网络的前向传播,然后返回最后一层的输出(W3 和 b3,没有 sigmoid)。好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
a = 0.5,y = 1。局部梯度 ∂L/∂a = 2(a − y) 是多少?
一个神经元算 a = sigmoid(z),损失是 L = (a − y)²。往回走时,∂L/∂a = −1,∂a/∂z = a(1 − a) = 0.5 × 0.5 = 0.25。用链式法则:∂L/∂z 是多少?
一个神经元算 z = w·x + b,其中 x = 2。往回走时,∂L/∂z = −0.25,局部梯度是 ∂z/∂w = x = 2。∂L/∂w 是多少?
在一个简单的函数上检验:L(w) = w²。在 w = 3、ε = 0.1 时,(L(w + ε) − L(w − ε)) / (2ε) 是多少?
两个样本:X = [[1, 2], [3, 1]],dz = [[0.5], [−1]]。X.T @ dz 的第一个元素 dW[0][0] 是多少?
X 是 (4, 2)。隐藏层的梯度 dz1 是 (4, 6)。dW1 = X.T @ dz1 是什么形状?
XOR 网络上的规则 3:dz2 是 (4, 1),每个样本一个数,W2 是 (6, 1)。dz2 @ W2.T 是什么形状?
一个样本,一个有 2 个 tanh 神经元的隐藏层,一个输出。dz2 = [[0.5]],W2 = [[2], [−1]](所以 W2.T = [[2, −1]]),隐藏层输出是 a1 = [[0.5, 0]]。tanh 在一个神经元处的斜率是 1 − a²,其中 a 是那个神经元的输出。用第 3 节的规则 3。dz1 的第一个数是多少?
写出整个反向传播:训练一步需要的每个梯度,从输出层的 dz2 一直到 dW1 和 db1。好几行。
代码写出整个反向传播:训练一步需要的每个梯度,从输出层的 dz2 一直到 dW1 和 db1。好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出更新这一步,然后在 XOR 上跑 1000 步梯度下降。
代码写出更新这一步,然后在 XOR 上跑 1000 步梯度下降。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
两个样本的 dz = [[0.5], [−1]]。这一层有一个输出神经元,一个偏置。db = dz.sum(axis=0) 是多少?
一个形状 (3, 5) 的数组是内存连续的,所以它的步长是 (5, 1),起点是内存位置 0。元素 [2, 3] 在哪个内存位置?
一个形状 (2, 3, 4) 的数组是内存连续的。按元素算,它的步长是多少?像形状那样输入,比如 (1, 2, 3)。
写出 `contiguous_strides`(shape):内存连续的数组的步长,按元素算。从右往左走一遍形状。
代码写出 contiguous_strides(shape):内存连续的数组的步长,按元素算。从右往左走一遍形状。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
x = np.arange(12.0).reshape(3, 4) 的形状是 (3, 4),步长按元素算是 (4, 1)。x.T 的步长是多少?像形状那样输入。
x = np.arange(12.0).reshape(3, 4),所以 x[1, 0] 是 4。然后 y = x.T,再执行 y[0, 1] = 100。现在 x[1, 0] 是多少?
选择x = np.arange(12.0).reshape(3, 4),所以 x[1, 0] 是 4。然后 y = x.T,再执行 y[0, 1] = 100。现在 x[1, 0] 是多少?
t 的形状是 (2, 3, 4),步长是 (12, 4, 1)。np.swapaxes(t, 1, 2) 的形状是 (2, 4, 3),它的步长是多少?像形状那样输入。
small = np.arange(6.0).reshape(2, 3) 是 [[0, 1, 2], [3, 4, 5]]。small.T.reshape(6)[1] 是多少?
x = np.arange(12.0).reshape(3, 4)。下面哪一个一定是副本,有自己的内存?
选择x = np.arange(12.0).reshape(3, 4)。下面哪一个一定是副本,有自己的内存?
注意力头的输出 out 形状是 (2, 4, 10, 16) = (B, h, L, dₖ),步长是 (640, 160, 16, 1)。out.transpose(1, 2) 的形状是 (2, 10, 4, 16),它的步长是多少?像形状那样输入。
形状 注意力头的输出 out 形状是 (2, 4, 10, 16) = (B, h, L, dₖ),步长是 (640, 160, 16, 1)。out.transpose(1, 2) 的形状是 (2, 10, 4, 16),它的步长是多少?像形状那样输入。
v 是一个形状 (4,) 的 float32 向量,每个 float32 数占 4 个字节。`np.broadcast_to(v, (1000, 4))` 存了多少字节的内存?
写出那一行代码:给定步长和起点偏移,从内存 buf 里读出元素 [i, j]。测试会用到转置、隔列取、切片和广播。
代码写出那一行代码:给定步长和起点偏移,从内存 buf 里读出元素 [i, j]。测试会用到转置、隔列取、切片和广播。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一个 float16 数的比特是 0 10001 1000000000:符号位 0,指数位 10001(也就是 17),尾数 1000000000(也就是 512)。float16 有 10 个尾数位,指数偏移是 15。这个数是多少?
bfloat16 有 7 个尾数位。从 1 到 2(包括 1,不包括 2),一共有多少个不同的 bfloat16 数?
bfloat16 从 1 到 2 有 128 个数,所以相邻两个数相差 1/128。从 256 到 512 的数用的是同样的 128 种尾数组合,只是放大了 256 倍。那里相邻两个数相差多少?
在 bfloat16 里,从 256 到 512 的相邻两个数相差 2。256 + 0.75 存进 bfloat16 后是多少?
选择在 bfloat16 里,从 256 到 512 的相邻两个数相差 2。256 + 0.75 存进 bfloat16 后是多少?
float16 最大的数是 65504。np.float16(300) * np.float16(300) 是多少?
选择float16 最大的数是 65504。np.float16(300) * np.float16(300) 是多少?
e¹¹ ≈ 59 874,e¹² ≈ 162 755。float16 最大的数是 65504。让 np.exp(np.float16(z)) 不是 inf 的最大整数 z 是多少?
分数 z = [1000, 1001],用 float32,而在 float32 里 e⁸⁹ 就已经是 inf 了。直接用公式 e^z / sum(e^z) 会得到什么?
选择分数 z = [1000, 1001],用 float32,而在 float32 里 e⁸⁹ 就已经是 inf 了。直接用公式 e^z / sum(e^z) 会得到什么?
分数 z = [1000, 1001]。先减去最大的分数:[−1, 0]。用 e⁻¹ ≈ 0.37 和 e⁰ = 1。第 1 个分数(1001 那个)的 softmax 概率是多少?保留两位小数。
用 ln 2 ≈ 0.69。ln(e¹⁰⁰⁰ + e¹⁰⁰⁰) 是多少?保留两位小数。(计算机直接算会得到 inf,但你可以手算。)
写出让 softmax 对很大的分数也安全的那一行:在 exp 之前,减去每一行最大的分数。
代码写出让 softmax 对很大的分数也安全的那一行:在 exp 之前,减去每一行最大的分数。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
权重 w = 1 存在 bfloat16 里,那里 1 上面的下一个数是 1 + 1/128 ≈ 1.0078。一次更新加上 0.001。更新后存进 bfloat16 的 w 是多少?
用 log-sum-exp 从原始分数写出 `cross_entropy`,让它永远碰不到 inf。z 的形状是 (B, V);t 存的是每一行的目标下标。算出 lse:每行一个 log-sum-exp,形状 (B,)。
代码用 log-sum-exp 从原始分数写出 cross_entropy,让它永远碰不到 inf。z 的形状是 (B, V);t 存的是每一行的目标下标。算出 lse:每行一个 log-sum-exp,形状 (B,)。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
w = [0.5, nan, −1],x = [1, 2, 3]。w @ x 是多少?
选择w = [0.5, nan, −1],x = [1, 2, 3]。w @ x 是多少?
U4喂数据基础 · 深入底层
一个数据集有 10 个样本。批大小是 4,最后一批拿走剩下的所有样本。一轮里有几批?
10 个样本,批大小 4。最后一批有几个样本?
10 个样本,批大小 4,保留最后那个不满的批。你训练 3 轮。一共是多少步(权重更新)?
10 个样本按类别排好序存放:样本 0–4 是类别 0,5–9 是类别 1。不打乱,批大小 5。每一步训练看到的是什么?
选择10 个样本按类别排好序存放:样本 0–4 是类别 0,5–9 是类别 1。不打乱,批大小 5。每一步训练看到的是什么?
把一个随机顺序切成批。写出从 i 开始、取出一批下标的那个切片。
代码把一个随机顺序切成批。写出从 i 开始、取出一批下标的那个切片。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
50 个样本。你留出其中的 20%,只划分一次,用剩下的训练,批大小 8。一轮里有多少步训练?
代码不是只划分一次,而是在每一轮开始时重新随机划分一次训练集和留出集。会出什么问题?
选择代码不是只划分一次,而是在每一轮开始时重新随机划分一次训练集和留出集。会出什么问题?
一个脚本在开头设了种子。你用种子 0 跑一次,再用种子 0 跑一次,然后用种子 1 跑一次。同样的代码,同一台电脑。哪几次运行打印出同样的损失曲线?
选择一个脚本在开头设了种子。你用种子 0 跑一次,再用种子 0 跑一次,然后用种子 1 跑一次。同样的代码,同一台电脑。哪几次运行打印出同样的损失曲线?
三个序列 [5, 3, 8]、[2, 9] 和 [7],在末尾用 PAD = 0 填充成一个批。这个批的形状是什么?
[5, 3, 8]、[2, 9] 和 [7] 填充成一个 (3, 3) 的批。有几格是 PAD?
长度分别为 2、3、6 和 1 的四个序列放进同一个批,填充到最长的长度。这个批里有几格是 PAD?
写出整理函数里的循环:把每个序列复制到 X 中它的那一行,并在掩码里把它的真实格子标成不挡住(False)。把 ____ 换成你需要的若干行。
代码写出整理函数里的循环:把每个序列复制到 X 中它的那一行,并在掩码里把它的真实格子标成不挡住(False)。把 ____ 换成你需要的若干行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
U5调试模型基础 · 深入底层
pred 的形状是 (4, 1),y 的形状是 (4,)。pred − y 的形状是什么?
在 4 个点上拟合直线,有一个形状 bug:pred − y 的形状是 (4, 4),所以损失把每一个预测值都和每一个目标值 3、3、7、7 比较。模型能做到的最好结果,是在每个地方都预测同一个数:和 3、3、7、7 的均方距离最小的那个数。它是哪个数?
你只用 4 个样本反复训练一个小 MLP。500 步之后,损失仍然是 0.69,和一开始一样。这说明了什么?
选择你只用 4 个样本反复训练一个小 MLP。500 步之后,损失仍然是 0.69,和一开始一样。这说明了什么?
f(w) = w²,w = 3,h = 0.01。f(w + h) = 9.0601,f(w − h) = 8.9401。数值斜率 (f(w + h) − f(w − h)) / (2h) 是多少?
在 w = 0.5、b = 0 处用 y = w·x + b 拟合 (1, 3)、(2, 3)、(3, 7)、(4, 7)。数值梯度是 dw = −21.5,db = −7.5。某人的公式给出 dw = −10.75,db = −3.75。最可能的 bug 是什么?
选择在 w = 0.5、b = 0 处用 y = w·x + b 拟合 (1, 3)、(2, 3)、(3, 7)、(4, 7)。数值梯度是 dw = −21.5,db = −7.5。某人的公式给出 dw = −10.75,db = −3.75。最可能的 bug 是什么?
写出循环体:w 第 i 项的数值斜率。把 w[i] 增加 h,再减少 h,然后放回原处。把 ____ 换成你需要的若干行。
代码写出循环体:w 第 i 项的数值斜率。把 w[i] 增加 h,再减少 h,然后放回原处。把 ____ 换成你需要的若干行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
f(w) = w²,所以梯度是 2w。从 w = 1 开始,用 lr = 1.5 走梯度下降的步子 w ← w − lr · 2w。3 步之后 w 是多少?
损失依次是 16、86、466、2550……然后是 inf,再过几十步变成 NaN。如果每个数一开始都正常,NaN 能从哪里来?
选择损失依次是 16、86、466、2550……然后是 inf,再过几十步变成 NaN。如果每个数一开始都正常,NaN 能从哪里来?
一个循环忘了 `opt.zero_grad()`。对某一个权重,backward() 在前 3 步每一步都给出梯度 2。第 3 步运行 opt.step() 时,这个权重的 .grad 是多少?
一个下一个 token 模型在 [<bos>, a, b, c] 上训练。bug 是:目标值就是输入本身 [<bos>, a, b],而不是 [a, b, c]。训练损失几步之内就降到接近 0。它写文本时会怎样?
选择一个下一个 token 模型在 [<bos>, a, b, c] 上训练。bug 是:目标值就是输入本身 [<bos>, a, b],而不是 [a, b, c]。训练损失几步之内就降到接近 0。它写文本时会怎样?
Boss,A 部分。注释里队友的版本有三个 bug。在 ____ 处为 `train_line` 写出能正常工作的函数体。行数不限。
代码Boss,A 部分。注释里队友的版本有三个 bug。在 ____ 处为 train_line 写出能正常工作的函数体。行数不限。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
Boss,B 部分。`lm_batch` 构造一个下一个 token 的批:输入 X、目标值 Y,以及 keep(损失应该计入的地方为 True)。注释里队友的版本有两个 bug。在 ____ 处写出能正常工作的函数体。
代码Boss,B 部分。lm_batch 构造一个下一个 token 的批:输入 X、目标值 Y,以及 keep(损失应该计入的地方为 True)。注释里队友的版本有两个 bug。在 ____ 处写出能正常工作的函数体。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
Boss,C 部分。把 python check.py `my_train.py` 打印的最后一行粘贴到引号之间。如果还有检查没通过,可以粘贴它的 FAIL 那一行,获得关于第一项没通过的检查的提示。
代码Boss,C 部分。把 python check.py my_train.py 打印的最后一行粘贴到引号之间。如果还有检查没通过,可以粘贴它的 FAIL 那一行,获得关于第一项没通过的检查的提示。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
softmax 给出 p = [0.5, 0.25, 0.25]。它的雅可比矩阵是 J = diag(p) − pᵀp,所以 J[i][i] = pᵢ(1 − pᵢ)。J[1][1] 是多少?
softmax 给出 p = [0.5, 0.25, 0.25]。在对角线外,雅可比矩阵 J = diag(p) − pᵀp 的元素是 J[i][j] = −pᵢ·pⱼ。J[0][1] 是多少?
对 p = [0.5, 0.25, 0.25],J = diag(p) − pᵀp,J[i][j] 表示 zⱼ 变动时 pᵢ 变得有多快。给每个分数都加上同一个数 c,p 不变。J 的每一行加起来是多少?
选择对 p = [0.5, 0.25, 0.25],J = diag(p) − pᵀp,J[i][j] 表示 zⱼ 变动时 pᵢ 变得有多快。给每个分数都加上同一个数 c,p 不变。J 的每一行加起来是多少?
softmax 给出 p = [0.5, 0.25, 0.25],传到 p 的梯度是 dp = [1, 0, 2]。用上面 dz 的简短形式,不要建出 J。dz[2] 是多少?
写出一个沿每一行做的 softmax 的反向传播:返回 dz = p ⊙ (dp − dp·p),其中 dp·p 逐行计算。
代码写出一个沿每一行做的 softmax 的反向传播:返回 dz = p ⊙ (dp − dp·p),其中 dp·p 逐行计算。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一个注意力头,2 个 token:权重是 A = [[0.5, 0.5], [0.5, 0.5]],传到输出 O = A @ V 的梯度是 dO = [[1, 0], [0, 2]]。用上面列表里的矩阵乘积规则。dV[0][1] 是多少?
两个 token。权重是 A = [[0.5, 0.5], [0.5, 0.5]],传到它们的梯度是 dA = [[2, 1], [0, 2]]。softmax 逐行反向传播:dS = A ⊙ (dA − 这一行的 dA·A)。dS[1][0] 是多少?
两个 token,dₖ = 4。分数梯度是 dS = [[0.25, −0.25], [−0.5, 0.5]],键是 K = [[1, −1, 0, 0], [0, 0, 1, −1]]。分数是 S = Q @ K.T / √dₖ。dQ[1][0] 是多少?
数字 两个 token,dₖ = 4。分数梯度是 dS = [[0.25, −0.25], [−0.5, 0.5]],键是 K = [[1, −1, 0, 0], [0, 0, 1, −1]]。分数是 S = Q @ K.T / √dₖ。dQ[1][0] 是多少?
还是同一个例子:Q = [[1, 1, 0, 0], [0, 0, 1, 1]],dₖ = 4,分数梯度是 dS = [[0.25, −0.25], [−0.5, 0.5]]。dK[0][2],也就是键 0 第 2 个元素处的梯度,是多少?
数字 还是同一个例子:Q = [[1, 1, 0, 0], [0, 0, 1, 1]],dₖ = 4,分数梯度是 dS = [[0.25, −0.25], [−0.5, 0.5]]。dK[0][2],也就是键 0 第 2 个元素处的梯度,是多少?
一个注意力头:L = 5 个 token,dₖ = 3,dᵥ = 6。Q 和 K 是 (5, 3),V 是 (5, 6)。dK 的形状是什么?
写出一个注意力头的反向传播:从 dO 出发,算出 dV 和 dA,然后算 dS(softmax 逐行反向传播),再算 dQ 和 dK。要写好几行,缩进都一样。
代码写出一个注意力头的反向传播:从 dO 出发,算出 dV 和 dA,然后算 dS(softmax 逐行反向传播),再算 dQ 和 dK。要写好几行,缩进都一样。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
softmax 的反向传播计算 dz = p ⊙ (dp − dp·p)。要对 A = softmax(S) 做这一步,训练必须保存前向传播的哪个值?
选择softmax 的反向传播计算 dz = p ⊙ (dp − dp·p)。要对 A = softmax(S) 做这一步,训练必须保存前向传播的哪个值?
用混合精度和 Adam 训练时,每个参数要保存:bf16 的权重(2 字节)、bf16 的梯度(2 字节)、一份 fp32 的主副本(4 字节),还有 fp32 的 Adam 的 m 和 v(各 4 字节)。一个有 70 亿参数的模型,光这些就需要多少 GB?(1 GB = 10⁹ 字节)
一个注意力层为反向传播保存它的权重 A,形状是 (B, h, L, L)。B = 4 个序列,h = 8 个头,L = 1000 个 token,每个数 2 字节。这是多少 MB?(1 MB = 10⁶ 字节)
一个 pre-norm 块为反向传播保存上表里的张量。以一个 (B, L, `d_model`) 张量为单位来数:宽度为 4 × `d_model` 的张量算 4 个单位。一共多少个单位?
每一层训练都要保存形状为 (B, L, 宽度) 的激活值和形状为 (B, h, L, L) 的注意力权重。你把 L 从 1000 翻倍到 2000,B、h 和宽度不变。激活值翻倍。保存的注意力权重会怎样?
选择每一层训练都要保存形状为 (B, L, 宽度) 的激活值和形状为 (B, h, L, L) 的注意力权重。你把 L 从 1000 翻倍到 2000,B、h 和宽度不变。激活值翻倍。保存的注意力权重会怎样?
第 2 节的例子:输出是 O = [[1.5, 0.5], [1.5, 0.5]],传到它们的梯度是 dO = [[1, 0], [0, 2]]。融合算子需要每一行的 dA·A,但不保存 A,所以它改用 dO·O。第 1 行的 dO·O 是多少?
点 (1, 3)、(2, 3)、(3, 7)、(4, 7);w = 0.5,b = 0,所以误差是 −2.5、−2、−5.5、−5。用全部四个点,dL/dw = 2·error·x 的平均是多少?
直线 ŷ = w·x + b,w = 0.5,b = 0。用一个只有一个点 (3, 7) 的批。它的误差是 −5.5。这一批的 dL/dw = 2·error·x 是多少?
一个训练集有 1,000 个样本,你用大小为 50 的小批量。一轮是多少步?
f(w1, w2) = 0.5·(w1² + 25·w2²),从 (−4, 1) 出发,梯度是 (−4, 25)。用 lr = 0.03 走一步 SGD:新的 w2 是多少?
损失是 f(w1, w2) = 0.5·(w1² + 25·w2²),梯度是 (w1, 25·w2)。从 (−4, 1) 出发。为了让 w1 走得快些,SGD 的 lr 从 0.03 换成 0.09。w2 会怎样?
选择损失是 f(w1, w2) = 0.5·(w1² + 25·w2²),梯度是 (w1, 25·w2)。从 (−4, 1) 出发。为了让 w1 走得快些,SGD 的 lr 从 0.03 换成 0.09。w2 会怎样?
Adam 用 lr = 0.3,从 (−4, 1) 出发,梯度是 (−4, 25)。在第 1 步,m̂ = g,v̂ = g²,所以这一步是 0.3·g/√(g²)。w1 变化了多少?(给出移动的大小,不是新位置。)
写出动量的一步:先用新的梯度 g 更新速度 u,再把 w 移动 lr 乘以 u。两个都返回。
代码写出动量的一步:先用新的梯度 g 更新速度 u,再把 w 移动 lr 乘以 u。两个都返回。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出 Adam 的更新。mₕₐₜ 和 vₕₐₜ 已经算好了。
代码写出 Adam 的更新。mₕₐₜ 和 vₕₐₜ 已经算好了。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一层有 100 个输入(扇入 n = 100)。按规则 s = 1/√n,它的权重应该取多大的标准差?
输入的标准差是 1。它们穿过 10 层,没有激活函数,宽度 100,权重标准差 0.2。每一层把标准差乘以 √100 · 0.2。10 层之后标准差是多少?
一个网络有 10 层,宽度 100,每层之后都接 tanh。权重的标准差是 0.01,输入的标准差是 1。没有 tanh 的话,每层会把标准差乘以 √100 · 0.01。10 层之后,输出……
选择一个网络有 10 层,宽度 100,每层之后都接 tanh。权重的标准差是 0.01,输入的标准差是 1。没有 tanh 的话,每层会把标准差乘以 √100 · 0.01。10 层之后,输出……
一个调度:peak = 0.004,warmup = 100,total = 1000。第 25 步还在预热期,所以 lr = peak · t / warmup。第 25 步的 lr 是多少?
一个调度:peak = 0.004,warmup = 100,total = 1000。第 550 步已过预热期,所以 lr = peak · (total − t) / (total − warmup)。第 550 步的 lr 是多少?
为损失 (w − 3)² 写出训练循环的循环体,带动量和学习率调度:每一步都从 `lr_at` 拿到自己的学习率。要写好几行。
代码为损失 (w − 3)² 写出训练循环的循环体,带动量和学习率调度:每一步都从 lr_at 拿到自己的学习率。要写好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
model = nn.Sequential(nn.Linear(2, 6), nn.Tanh(), nn.Linear(6, 1))。一个 Linear 层对每一对输入和输出有一个权重,每个输出有一个偏置。这个模型一共要学多少个数?
在 NumPy 里,W1 的形状是 (2, 6):2 个输入,6 个输出。nn.Linear(2, 6).weight 的形状是什么?
你的训练循环里有 loss.backward() 和 opt.step(),但你忘了 `opt.zero_grad()`。会怎样?
选择你的训练循环里有 loss.backward() 和 opt.step(),但你忘了 opt.zero_grad()。会怎样?
w = 1,x = 2,y = 6,损失 = (w·x − y)²,所以每次 backward 算出的梯度是 −16。你连续调用两次 loss.backward(),中间没有 `zero_grad`。现在 w.grad 是多少?
backward 往 w.grad 里加,和 PyTorch 一样。写出 `zero_grad`,让 train(…, clear=True) 走到 w = 3。
代码backward 往 w.grad 里加,和 PyTorch 一样。写出 zero_grad,让 train(…, clear=True) 走到 w = 3。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
pred 的形状是 (4, 1),y 的形状是 (4,)。pred − y 的形状是什么?
写出最后一层权重的梯度。它必须和上面 PyTorch 给出的 W2 梯度一致。
代码写出最后一层权重的梯度。它必须和上面 PyTorch 给出的 W2 梯度一致。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
在 forward 里写出隐藏层 h。用盒子自己的权重(self.W1、self.b1)和 tanh。
代码在 forward 里写出隐藏层 h。用盒子自己的权重(self.W1、self.b1)和 tanh。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
在你的电脑上运行 `first_run.py`(第 8 节的代码)。100 步之后它打印出的损失是多少?
写出内层循环的循环体:训练一步的三个调用,按正确的顺序。
代码写出内层循环的循环体:训练一步的三个调用,按正确的顺序。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
分数是:垫子 2.0、沙发 1.0、屋顶 0.5、月亮 −1.0。四舍五入后,e^score 分别是 7.4、2.7、1.6 和 0.4,加起来是 12.1。“垫子”的概率是多少?(保留 2 位小数)
分数 [2, 0],e² ≈ 7.39,e⁰ = 1。第一个词的概率是多少?(保留 2 位小数)
分数 [2, 0] 给出概率 0.88 和 0.12。给两个分数都加 10:[12, 10]。概率会怎样?
选择分数 [2, 0] 给出概率 0.88 和 0.12。给两个分数都加 10:[12, 10]。概率会怎样?
分数是:垫子 2.0、沙发 1.0、屋顶 0.5、月亮 −1.0。T = 1 时,采样 1000 个词大约得到 600 个垫子。温度会把每个分数除以 T。温度是 0.1 时,采样 1000 个词会得到什么?
选择分数是:垫子 2.0、沙发 1.0、屋顶 0.5、月亮 −1.0。T = 1 时,采样 1000 个词大约得到 600 个垫子。温度会把每个分数除以 T。温度是 0.1 时,采样 1000 个词会得到什么?
分数 [2, 0],温度 T = 2,e¹ ≈ 2.72。第一个词的概率是多少?(保留 2 位小数)
写出应用温度的那一行。scores 传进来时是一个 Python 列表,而列表不能除以一个数,所以要先把它变成浮点数组。
代码写出应用温度的那一行。scores 传进来时是一个 Python 列表,而列表不能除以一个数,所以要先把它变成浮点数组。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
模型给正确的词 p = 0.1。损失 −ln p 是多少?用 ln 10 ≈ 2.30。(保留 2 位小数)
模型给正确的词 p = 0.5。损失是多少?用 ln 2 ≈ 0.69。(保留 2 位小数)
返回交叉熵损失:对分数做 softmax,取出正确的那个,再取 −log。
代码返回交叉熵损失:对分数做 softmax,取出正确的那个,再取 −log。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
猫、狗、车的 p = [0.7, 0.2, 0.1],正确的词是狗,所以 y = [0, 1, 0]。狗的 ∂L/∂s,也就是 p − y,是多少?
梯度下降让每个分数逆着它的梯度移动:s ← s − lr × (p − y)。猫、狗、车的 p − y = [0.7, −0.8, 0.1],哪个分数会升高?
选择梯度下降让每个分数逆着它的梯度移动:s ← s − lr × (p − y)。猫、狗、车的 p − y = [0.7, −0.8, 0.1],哪个分数会升高?
返回损失对分数的梯度:p 减去独热目标。
代码返回损失对分数的梯度:p 减去独热目标。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一个模型总是把它的猜测平均分给 4 个词,每个 p = 0.25,而正确的词总在它们当中。它的困惑度是多少?
十个词。模型 A 有九次给正确词 p = 0.9,有一次给 p = 0.001。模型 B 每次都给 p = 0.5。哪个的困惑度更低?
选择十个词。模型 A 有九次给正确词 p = 0.9,有一次给 p = 0.001。模型 B 每次都给 p = 0.5。哪个的困惑度更低?
对“那只猫坐在垫子上”,模型给正确的下一个词的 p 是 0.5、0.25、0.125、0.25、0.25。惊讶度 −ln p 加起来是 6.93,ln 4 ≈ 1.386。它的困惑度是多少?
返回一列概率(模型给每个正确词的 p)的困惑度。
代码返回一列概率(模型给每个正确词的 p)的困惑度。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一个带噪声的数是 x = mean + std × z,其中 z 来自标准正态分布。mean = 3,std = 2,z = −1.5。x 是多少?
`rng.standard_normal((1000, 2))` * 2 + 3 的形状是什么?
分数 [2, 0]。softmax 给出 [0.88, 0.12]。如果你把这些概率当作分数传给 `F.cross_entropy`,它会再做一次 softmax。训练会怎样?
选择分数 [2, 0]。softmax 给出 [0.88, 0.12]。如果你把这些概率当作分数传给 F.cross_entropy,它会再做一次 softmax。训练会怎样?
为一个批写出 `mean_loss`:对每一行分数,除以 T,做安全的 softmax(在 np.exp 之前减去最大值),再对这一行正确词的概率取 −ln。返回这些损失在各行上的均值。需要写好几行。
代码为一个批写出 mean_loss:对每一行分数,除以 T,做安全的 softmax(在 np.exp 之前减去最大值),再对这一行正确词的概率取 −ln。返回这些损失在各行上的均值。需要写好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
N1卷积基础 · 经典网络
图片是 5×5,第 2 列是 1,其余都是 0。卷积核是 [[−1, 0, 1], [−1, 0, 1], [−1, 0, 1]]。out[0][0],也就是左上角那个 3×3 窗口的输出,是多少?
图片是 5×5,第 1 列是 1,其余都是 0。卷积核是 [[−1, 0, 1], [−1, 0, 1], [−1, 0, 1]],不填充,步幅 1。out[0][1] 是多少?
一张 5×5 的图片第 2 列是 1,其余都是 0。用水平边缘卷积核 [[−1, −1, −1], [0, 0, 0], [1, 1, 1]],不填充,步幅 1,3×3 的输出是什么样?
选择一张 5×5 的图片第 2 列是 1,其余都是 0。用水平边缘卷积核 [[−1, −1, −1], [0, 0, 0], [1, 1, 1]],不填充,步幅 1,3×3 的输出是什么样?
一张 28×28 的图片,一个 5×5 卷积核,不填充,步幅 1。输出有多少个像素宽?
一张 32×32 的图片,一个 3×3 卷积核,填充 1,步幅 2。输出有多少个像素宽?
一张 6×6 的图片和一个 3×3 卷积核给出 4×4 的输出。一个给出同样 4×4 输出的全连接层,把 36 个像素中的每一个都连到 16 个输出格中的每一个。它有多少个权重(不算偏置)?
一个 3×3 卷积层读 8 个输入通道,生成 16 个输出通道。它要学多少个数,权重加偏置?
两个 3×3 层叠在一起,步幅 1,没有池化。第二层的一个输出像素取决于图片上一块正方形区域。这一块有多少个像素宽?
对 [[1, 3, 0, 2], [4, 2, 1, 1], [0, 0, 5, 6], [1, 2, 7, 0]] 做 2×2 最大池化,得到 2×2 的结果。它右下角的数是多少?
数字 对 [[1, 3, 0, 2], [4, 2, 1, 1], [0, 0, 5, 6], [1, 2, 7, 0]] 做 2×2 最大池化,得到 2×2 的结果。它右下角的数是多少?
一层一层地跟踪这一块的宽度和间距。一个 k×k 卷积让宽度增加 (k − 1) × 间距。一个 2×2 池化让宽度增加 1 × 间距,然后间距翻倍。经过一个 3×3 卷积和一个 2×2 池化后,宽度是 4,间距是 2。再加第二个 3×3 卷积,然后第二个 2×2 池化。最后的一个输出能看到多少个像素宽的一块?
写一行:(i, j) 处的输出,是从 (i, j) 开始的 3×3 窗口乘以卷积核,再求和。
代码写一行:(i, j) 处的输出,是从 (i, j) 开始的 3×3 窗口乘以卷积核,再求和。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写一个适用于任意正方形卷积核、任意步幅、不填充的卷积。算出输出边长 m,建好 out,再填满每个 out[i, j]。把 ____ 换成你需要的任意多行。
代码写一个适用于任意正方形卷积核、任意步幅、不填充的卷积。算出输出边长 m,建好 out,再填满每个 out[i, j]。把 ____ 换成你需要的任意多行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一个普通堆叠有 4 层。往下传时,每一层都把梯度乘上它的斜率 0.5。顶部的梯度是 1。传到底部的是多少?
30 个普通 tanh 层。往下传时,每一层把梯度缩到原来的大约四分之三。顶部的梯度标准差是 1。传到第 0 层时,它大约有多大?
选择30 个普通 tanh 层。往下传时,每一层把梯度缩到原来的大约四分之三。顶部的梯度标准差是 1。传到第 0 层时,它大约有多大?
一个残差层计算 y = x + f(x),其中 f(x) = 0.5 · x。斜率 dy/dx 是多少?
x 的形状是 (64, 8, 8):64 个通道,每个 8×8。层这一侧的两个卷积都是 3×3、填充 1、64 个卷积核。F(x) 是什么形状?
特征 0(第 0 列)是 [1, 1, 5, 5],均值是 3。求它的标准差,再求 X[2][0] 的 BatchNorm 值 = (5 − 均值) ÷ 标准差。忽略那个很小的 ε。
BatchNorm 某个特征的滑动平均是 2。下一批这个特征的均值是 4。更新时保留旧值的 0.9,加上新值的 0.1。现在滑动平均是多少?
用只有 1 个样本的批训练,x = [3, 7, 1]。BatchNorm 减去每个特征在整批上的均值。输出是什么?
选择用只有 1 个样本的批训练,x = [3, 7, 1]。BatchNorm 减去每个特征在整批上的均值。输出是什么?
LayerNorm 用每一行自己的均值和标准差。样本 2(第 2 行)是 [5, 1, 5, 1]。X[2][1] 的 LayerNorm 值是多少?忽略 ε。
一批有 32 个样本,每个 64 个特征:形状 (32, 64)。LayerNorm 算 32 个均值,每个样本一个。BatchNorm 算多少个均值?
一个模型一次写一个 token,所以每一步它的输入只有一个序列。哪种归一化在这里仍然管用?
选择一个模型一次写一个 token,所以每一步它的输入只有一个序列。哪种归一化在这里仍然管用?
写出 `layer_norm`:用每一行(一个样本)自己的均值和方差对它做归一化,开平方根之前给方差加上 ε,就像 `batch_norm` 对列做的那样。
代码写出 layer_norm:用每一行(一个样本)自己的均值和方差对它做归一化,开平方根之前给方差加上 ε,就像 batch_norm 对列做的那样。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
wₓ = 1,wₕ = 0.5,b = 0,h₀ = 0,x₁ = 1。取 tanh(1) ≈ 0.76。h₁ = tanh(wₓ·x₁ + wₕ·h₀ + b) 是多少?(保留 2 位小数)
wₓ = 1,wₕ = 0.5,b = 0。h₁ = 0.76,x₂ = 0。取 tanh(0.38) ≈ 0.36。h₂ = tanh(wₓ·x₂ + wₕ·h₁ + b) 是多少?(保留 2 位小数)
这个 RNN 的隐藏状态只有一个数:hₜ = tanh(wₓ·xₜ + wₕ·hₜ₋₁ + b)。它读一个有 1,000 个输入的序列。它有多少个要学的数(权重和偏置)?
wₕ = 0.5。往回走一步,梯度乘上 wₕ·(1 − h²)。如果不管 tanh,往回三步会得到 0.5³ = 0.125。加上 tanh 后,∂h₄/∂h₁ 是……
选择wₕ = 0.5。往回走一步,梯度乘上 wₕ·(1 − h²)。如果不管 tanh,往回三步会得到 0.5³ = 0.125。加上 tanh 后,∂h₄/∂h₁ 是……
没有激活函数,wₕ = 1.5。30 步之后,梯度是 29 个 1.5 的乘积。它大约有多大?
选择没有激活函数,wₕ = 1.5。30 步之后,梯度是 29 个 1.5 的乘积。它大约有多大?
一个隐藏状态有 32 个数的 RNN,在 k = 20 时能完美学会“记住第一个符号”。现在 k = 40:规则一样,训练 1,500 步。它能达到多少准确率?
选择一个隐藏状态有 32 个数的 RNN,在 k = 20 时能完美学会“记住第一个符号”。现在 k = 40:规则一样,训练 1,500 步。它能达到多少准确率?
写出循环里的更新:h 变成 tanh(x 乘 Wₓ,加 h 乘 Wₕ,再加 b)。
代码写出循环里的更新:h 变成 tanh(x 乘 Wₓ,加 h 乘 Wₕ,再加 b)。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出 `rnn_all`:运行同样的循环,但保留每一个隐藏状态,让结果每一步一行,形状 (L, H)。把 ____ 换成你需要的任意多行。
代码写出 rnn_all:运行同样的循环,但保留每一个隐藏状态,让结果每一步一行,形状 (L, H)。把 ____ 换成你需要的任意多行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
cₚᵣₑᵥ = 1.0,f = 0.9,i = 0.5,g = 0.8。c = f·cₚᵣₑᵥ + i·g 是多少?
c = 1.3,输出门 o = 0.6。用 tanh(1.3) ≈ 0.86。h = o·tanh(c) 是多少?(保留 2 位小数)
遗忘门是 f = sigmoid(`w_f`·x + `u_f`·hₚᵣₑᵥ + `b_f`)。`w_f` = 2,x = 1,`u_f` = 0,hₚᵣₑᵥ = 0,`b_f` = 1,f 是多少?用 e⁻³ ≈ 0.05。(保留 2 位小数)
不加入新东西(i = 0),每一步 f = 0.9。c 从 1 开始。用 0.9⁵ ≈ 0.59。10 步之后 c 是多少?(保留 2 位小数)
不加入新东西。要在 50 步之后还保留一半的 c,遗忘门 f 大约要是……
选择不加入新东西。要在 50 步之后还保留一半的 c,遗忘门 f 大约要是……
两个 LSTM 只有遗忘门的初始偏置不同:0 或 2。任务是“记住第一个符号”,k = 80,训练 1,500 步,状态有 32 个数。普通 RNN 只能瞎猜(大约 50%)。哪个 LSTM 能达到大约 100%?
选择两个 LSTM 只有遗忘门的初始偏置不同:0 或 2。任务是“记住第一个符号”,k = 80,训练 1,500 步,状态有 32 个数。普通 RNN 只能瞎猜(大约 50%)。哪个 LSTM 能达到大约 100%?
有 6 种颜色。如果一个模型语法全对,但第二个颜色是随机挑的,它写的句子有多大比例符合所有规则?(百分数,保留 1 位小数)
写出细胞的更新:保留旧 c 的 f 那么多,再加上 i 乘候选值 g。
代码写出细胞的更新:保留旧 c 的 f 那么多,再加上 i 乘候选值 g。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
GRU 的一步:hₚᵣₑᵥ = 0.6,更新门 z = 0.25,候选值 h̃ = −0.2。新的 h = (1 − z)·hₚᵣₑᵥ + z·h̃ 是多少?
输入有 D = 10 个数,状态有 H = 20 个数。循环层的每一块有一个 (D, H) 的输入矩阵、一个 (H, H) 的状态矩阵和 H 个偏置:10×20 + 20×20 + 20 = 620 个数。LSTM 有 4 块。GRU 有多少个数?
句子是 “he sat by the bank of the river”(8 个词,从 0 开始数,“bank” 是第 4 个词)。反向 RNN 从 “river” 开始。它读到 “bank” 时,算上 “bank”,一共读了几个词?
每个方向的 H = 32。对一个 8 个词的句子,输出是每个词一行,每行是正向和反向的状态并排放在一起。它是什么形状?
两项任务。(1) 给一个已经写完的句子的每个词标上名词、动词等。(2) 一次一个词地写一个句子。双向 RNN 能做哪项?
选择两项任务。(1) 给一个已经写完的句子的每个词标上名词、动词等。(2) 一次一个词地写一个句子。双向 RNN 能做哪项?
Boss 第 1 部分。写出 GRU 的一步:更新门 z、重置门 r、候选值 h̃ 和新的 h,公式都在第 3 节。把 ____ 换成你需要的若干行。
代码Boss 第 1 部分。写出 GRU 的一步:更新门 z、重置门 r、候选值 h̃ 和新的 h,公式都在第 3 节。把 ____ 换成你需要的若干行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
Boss 第 2 部分。把 boss.py 为你自己的 LSTM 单元打印的 PASS 那一行粘贴到引号之间。
代码Boss 第 2 部分。把 boss.py 为你自己的 LSTM 单元打印的 PASS 那一行粘贴到引号之间。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
H = 32 的 LSTM 编码器读入一个 24 位的数字串。解码器只拿到编码器最后的 h 和 c。这一共是多少个数?
E = [[1, 0], [0, 1], [0, −1]](各行是 h₀、h₁、h₂),解码器状态 s = [2, 0]。h₀ 的分数,也就是 h₀ · s,是多少?
分数是 [2, 0, 0]。用 e² ≈ 7.39 和 e⁰ = 1。做完 softmax 后,h₀ 的权重是多少?(保留 2 位小数)
权重是 [0.79, 0.11, 0.11],E = [[1, 0], [0, 1], [0, −1]]。context = weights @ E 的第二个数是多少?
选择权重是 [0.79, 0.11, 0.11],E = [[1, 0], [0, 1], [0, −1]]。context = weights @ E 的第二个数是多少?
E 存着 8 个编码器状态,每个 32 个数:E 是 (8, 32)。解码器状态 s 是 (32,)。context = weights @ E 是什么形状?(写一个数,比如 (5)。)
补完注意力的一步:上下文是编码器状态的加权平均。
代码补完注意力的一步:上下文是编码器状态的加权平均。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
同样的倒转任务,同样 H = 32 的 LSTM,现在加上注意力。在 20 位上普通模型答对 0%。注意力模型能比 0% 好吗?
选择同样的倒转任务,同样 H = 32 的 LSTM,现在加上注意力。在 20 位上普通模型答对 0%。注意力模型能比 0% 好吗?
模型读入 427015,写出 “four hundred twenty seven thousand fifteen”。它写 “seven” 时,哪个数字应该得到最大的权重?
选择模型读入 427015,写出 “four hundred twenty seven thousand fifteen”。它写 “seven” 时,哪个数字应该得到最大的权重?
Boss 第 1 部分。一次算出解码器每一步的注意力:每个解码器状态一行权重,每行是对编码器状态做的 softmax;每个解码器状态一行上下文。softmax 要你自己写。把 ____ 换成你需要的若干行。
代码Boss 第 1 部分。一次算出解码器每一步的注意力:每个解码器状态一行权重,每行是对编码器状态做的 softmax;每个解码器状态一行上下文。softmax 要你自己写。把 ____ 换成你需要的若干行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
Boss 第 2 部分。把 boss.py 为你自己的 `attend_all()` 打印的 PASS 那一行粘贴到引号之间。
代码Boss 第 2 部分。把 boss.py 为你自己的 attend_all() 打印的 PASS 那一行粘贴到引号之间。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
N6自编码器基础 · 经典网络
一张 28×28 的图片有 784 个数。编码有 2 个数。编码的数少了多少倍?
一批 32 张图片的形状是 (32, 784)。编码器把每张图片变成一个 2 个数的编码。这批编码是什么形状?
一张 4 像素的图片 x = [1, 0, 1, 1] 被重建成 x̂ = [0.5, 0, 1, 0.5]。均方误差是多少?
写出图片 x 和它的重建 xₕₐₜ 之间的均方误差(两者都是形状相同的 NumPy 数组)。
代码写出图片 x 和它的重建 xₕₐₜ 之间的均方误差(两者都是形状相同的 NumPy 数组)。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
VAE 的编码器对某一个编码数给出 μ = 1 和 σ = 0.5。随机抽到的是 ε = −2。编码 z = μ + σ·ε 是多少?
用 KL = ½(μ² + σ² − 1 − ln σ²)。对一个编码数,μ = 2,σ = 1(所以 ln σ² = ln 1 = 0)。KL 项是多少?
在 demo.py 里,普通自编码器的随机编码有 11% 落在离所有真实编码都很远的地方(在实验台里大约三分之一,因为它保留的编码更少)。VAE 从 N(0, 1) 抽随机编码。它们有多大比例落在离所有真实编码都很远的地方?
选择在 demo.py 里,普通自编码器的随机编码有 11% 落在离所有真实编码都很远的地方(在实验台里大约三分之一,因为它保留的编码更少)。VAE 从 N(0, 1) 抽随机编码。它们有多大比例落在离所有真实编码都很远的地方?
有人把 VAE 的损失写成:重建误差对 784 个像素取平均(而不是求和),再加上 KL 项。训练时会发生什么?
选择有人把 VAE 的损失写成:重建误差对 784 个像素取平均(而不是求和),再加上 KL 项。训练时会发生什么?
写出 VAE 的采样步骤:给定数组 mu、sigma 和一个标准正态分布的抽样 eps(形状都一样),返回编码。
代码写出 VAE 的采样步骤:给定数组 mu、sigma 和一个标准正态分布的抽样 eps(形状都一样),返回编码。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出一张图的 VAE 损失:每个像素的二元交叉熵求和,加上每个编码数的 KL 项求和。
代码写出一张图的 VAE 损失:每个像素的二元交叉熵求和,加上每个编码数的 KL 项求和。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
在解码器的交叉注意力里,K 和 V 从哪里来?
选择在解码器的交叉注意力里,K 和 V 从哪里来?
批大小为 2。解码器输入有 3 个 token(<bos> 加 2 个目标词),源序列有 6 个词。一个头的交叉注意力权重是什么形状?
一个解码器 token 读一个有 2 个源 token 的 memory,dₖ = 2。它的查询是 q = [√2 · ln 3, 0],约为 [1.55, 0]。来自 memory 的键是 k₀ = [1, 0] 和 k₁ = [0, 1],值是 v₀ = [4, 0] 和 v₁ = [0, 8]。输出是一个有 2 个数的向量。它的第一个数是多少?
一个模型把数读出来,`d_model` = 64。一批有 32 个数。源序列的数字填充到 3 个 token,解码器输入有 5 个 token。memory(编码器的输出)是什么形状?
默认大小下,一个解码器层有 49,856 个参数,一个编码器层有 33,280 个。相差 16,576,正好等于一个 FFN。解码器层有什么是编码器层没有的?
选择默认大小下,一个解码器层有 49,856 个参数,一个编码器层有 33,280 个。相差 16,576,正好等于一个 FFN。解码器层有什么是编码器层没有的?
一个模型把数读出来。一批有 64 个数,源数字填充到 3 个 token,解码器输入有 5 个 token(词),有 4 个头。交叉注意力分数是什么形状?
正在读 742。模型已经写出了“seven hundred forty”。这一步有多少行进入解码器?
一个 2 层的解码器读 742:4 个词,每步一个。模型把步与步之间不会变的结果都存起来(缓存),重复使用。在一个解码器层里,整个答案写完,memory 一共乘以 `W_K` 几次?
源序列有 5 个 token。解码器输入是 <bos> 加 5 个目标词。解码器自注意力里的因果掩码是什么形状(一个句子)?
读 42,所在的批里较长的答案需要 5 个词。解码器输入是 <bos> forty two PAD PAD:5 个位置。如果因果掩码挡住某一格,或者这一格所在的列是 PAD 词,解码器自注意力的掩码就挡住它。25 格里有多少格被挡住?
为一个例子构造三种掩码。src 存的是数字的 id,`tgt_in` 是解码器输入的 id,pad 是 PAD 的 id。返回 (enc, dec, cross),被挡住的格为 True:enc 是 (Ls, Ls),dec 是 (Lt, Lt),cross 是 (Lt, Ls)。需要写好几行。
代码为一个例子构造三种掩码。src 存的是数字的 id,tgt_in 是解码器输入的 id,pad 是 PAD 的 id。返回 (enc, dec, cross),被挡住的格为 True:enc 是 (Ls, Ls),dec 是 (Lt, Lt),cross 是 (Lt, Ls)。需要写好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写一个交叉注意力头。y 是解码器的行,memory 是编码器的输出;src_pad 在源 token 是 PAD 时为 True。返回 (out, A):输出和权重。需要写好几行。
代码写一个交叉注意力头。y 是解码器的行,memory 是编码器的输出;src_pad 在源 token 是 PAD 时为 True。返回 (out, A):输出和权重。需要写好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
在“the cat sat . the dog sat . a cat ran .”里,“sat”后面紧跟着“.”有几次?
在“the cat sat . the dog sat . a cat ran .”里,“cat”出现了两次:一次在“sat”前面,一次在“ran”前面。P(sat | cat) 是多少?
一个计数模型往回看一个词。它只数过文本“the cat sat . the dog sat . a cat ran .”。它给句子“a dog sat .”的概率是多少?
选择一个计数模型往回看一个词。它只数过文本“the cat sat . the dog sat . a cat ran .”。它给句子“a dog sat .”的概率是多少?
一个计数模型往回看一个词。它的训练故事里多次出现“… on the mat .”,但没有哪个故事里出现过前面不带“on”的“the mat .”。这个模型能写出“the mat .”吗?
选择一个计数模型往回看一个词。它的训练故事里多次出现“… on the mat .”,但没有哪个故事里出现过前面不带“on”的“the mat .”。这个模型能写出“the mat .”吗?
在一个“.”之后,一个模型读到“the cat ran”,它给每个下一个词的概率是 P(the | .) = 0.5,P(cat | the) = 0.5,P(ran | cat) = 0.5。困惑度是多少?
这些故事的词表有 10 个词。W 为每个前一个词存一行分数,每个可能的下一个词一个分数。W 是什么形状?
计数模型在 40 个留出故事上的困惑度是 2.016。神经网络版本的 W 一开始全是 0(困惑度 10),在同样的 160 个故事上训练。训练之后它的困惑度大约是多少?
选择计数模型在 40 个留出故事上的困惑度是 2.016。神经网络版本的 W 一开始全是 0(困惑度 10),在同样的 160 个故事上训练。训练之后它的困惑度大约是多少?
算出真实下一个词的平均交叉熵。W 是 (2, 2),prev 和 nxt 是词 id 组成的数组。
代码算出真实下一个词的平均交叉熵。W 是 (2, 2),prev 和 nxt 是词 id 组成的数组。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
词表有 10 个词时,往回看 2 个词的计数表需要多少行(每一对可能的前两个词一行)?
真实的词表有 50,000 个 token。往回看 3 个 token 的计数表需要 50,000³ = 125,000,000,000,000 行。会出什么问题?
选择真实的词表有 50,000 个 token。往回看 3 个 token 的计数表需要 50,000³ = 125,000,000,000,000 行。会出什么问题?
C 是“the cat sat . the dog sat . a cat ran .”的计数表(行 = 这个词,列 = 下一个词)。写出 probs:用加一平滑得到下一个词的概率,让每一行加起来都是 1。需要写几行。
代码C 是“the cat sat . the dog sat . a cat ran .”的计数表(行 = 这个词,列 = 下一个词)。写出 probs:用加一平滑得到下一个词的概率,让每一行加起来都是 1。需要写几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
构造 stoi:一个从每个字符到它的 id(它在 chars 里的位置)的字典。
代码构造 stoi:一个从每个字符到它的 id(它在 chars 里的位置)的字典。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出 encode:把一个字符串变成一列 id。
代码写出 encode:把一个字符串变成一列 id。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一个按词切分的分词器只认识:the、a、cat、dog、sat、ran、on、mat、rug、“.”。它怎样编码“the cats sat .”?
选择一个按词切分的分词器只认识:the、a、cat、dog、sat、ran、on、mat、rug、“.”。它怎样编码“the cats sat .”?
词:cat ×4、cats ×2、hat ×3、hats ×1。切成字符后,a + t 这一对一共出现几次(每个词按它出现的次数算)?
合并 a + t 之后,这些词是 c·at ×4、c·at·s ×2、h·at ×3、h·at·s ×1。现在 c + at 这一对出现几次?
按顺序的合并是:1) a + t → at,2) c + at → cat,3) h + at → hat。“cats”是几个 token?
同样的三次合并(a + t → at,c + at → cat,h + at → hat)。“that”从没出现在单词列表里。它是几个 token?
补全 merge:把 seg 里每一处相邻的 (a, b) 换成一个 token a + b。
代码补全 merge:把 seg 里每一处相邻的 (a, b) 换成一个 token a + b。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
BPE 在一个 40 个词的列表上运行,你一直合并下去。每次合并给词表加一个 token。所有词的 token 总数会怎样?
选择BPE 在一个 40 个词的列表上运行,你一直合并下去。每次合并给词表加一个 token。所有词的 token 总数会怎样?
一个有 50,000 个 token 的词表,嵌入表里每个 token 512 个数。这张表一共存了多少个数,以百万为单位?
写出循环的内部:对一个出现 n 次的词 seg,给它的每个相邻对的计数加 n。这些词是 cat ×4、cats ×2、hat ×3、hats ×1。两行。
代码写出循环的内部:对一个出现 n 次的词 seg,给它的每个相邻对的计数加 n。这些词是 cat ×4、cats ×2、hat ×3、hats ×1。两行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
表 E 的形状是 (4, 2):4 个 id,每个 2 个数。你查找“hello”的 5 个 id,[1, 0, 2, 2, 3]。结果是什么形状?
“hello”有两个 l,在位置 2 和 3(从 0 开始数)。查表之后,它们的两个向量一样吗?
选择“hello”有两个 l,在位置 2 和 3(从 0 开始数)。查表之后,它们的两个向量一样吗?
用独热行乘以嵌入表来做嵌入。
代码用独热行乘以嵌入表来做嵌入。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
cat = [2, 1]。你把 car 转到和 cat 方向相反。cat·car 会怎样?
选择cat = [2, 1]。你把 car 转到和 cat 方向相反。cat·car 会怎样?
两句话里,“apple”都是在同一张表里查的。它在“sweet apple”和“apple releases phone”里的向量一样吗?
选择两句话里,“apple”都是在同一张表里查的。它在“sweet apple”和“apple releases phone”里的向量一样吗?
把“apple releases phone”的三个向量平均(apple [1, 1, 0, 0],releases [0, 1, 0, 1],phone [0, 1, 0, 0])。结果的水果那个数,也就是第一项,是多少?(保留 3 位小数)
句子:“cat eats fish”、“dog eats meat”、“cat drinks milk”、“car needs fuel”。eats、drinks、needs 一共有几次紧挨着“cat”(在它前面或后面一个词)?
按 (eats, drinks, needs):cat = [1, 1, 0],dog = [1, 0, 0],car = [0, 0, 1]。cat · dog 是多少?
拿成千上万个像“cat eats fish”、“dog eats meat”、“car needs fuel”这样的句子。cat 和 dog 总是出现在相同的位置,car 出现在别的位置。最后谁的计数向量离 cat 的最近?
选择拿成千上万个像“cat eats fish”、“dog eats meat”、“car needs fuel”这样的句子。cat 和 dog 总是出现在相同的位置,car 出现在别的位置。最后谁的计数向量离 cat 的最近?
数邻居:对每个词,它前面紧挨的词和后面紧挨的词各加 1。
代码数邻居:对每个词,它前面紧挨的词和后面紧挨的词各加 1。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出 mix:在表 E 里查出 ids 对应的行,再用权重 w(每个 id 一个权重,加起来等于 1)把它们混合成一个 4 个数的向量。比如 ids [1, 0] 配 w = [0.75, 0.25],就是 0.75 × sweet + 0.25 × apple。写两行。
代码写出 mix:在表 E 里查出 ids 对应的行,再用权重 w(每个 id 一个权重,加起来等于 1)把它们混合成一个 4 个数的向量。比如 ids [1, 0] 配 w = [0.75, 0.25],就是 0.75 × sweet + 0.25 × apple。写两行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
在 w = 0.5 的 RNN 里,忽略 tanh,后面每来一个词,词 1 对隐藏状态的影响就乘上 0.5。再过 3 个词,词 1 的影响一共乘上了多少?
除以 √2 之前,cat 看 dog 的分数是多少?(cat = [2, 0],dog = [1, 1])
cat = [2, 0],dog = [1, 1],car = [0, 2]。cat 在 (cat, dog, car) 上的注意力权重是 [0.768, 0.187, 0.045]。cat 的输出的第一个数(x)是多少?(保留 2 位小数)
在词 cat、dog、car(按这个顺序)的注意力权重表里,行是词,列也是词。weights[0][2] = 0.045。这个数说的是什么?
选择在词 cat、dog、car(按这个顺序)的注意力权重表里,行是词,列也是词。weights[0][2] = 0.045。这个数说的是什么?
三个词互相做注意力,scores = X @ X.T / √2,然后做 softmax:cat = [2, 0],dog = [1, 1],car = [0, 2]。如果 car 变成 [5, 5](cat 和 dog 不变),car 那一行权重会怎样?
选择三个词互相做注意力,scores = X @ X.T / √2,然后做 softmax:cat = [2, 0],dog = [1, 1],car = [0, 2]。如果 car 变成 [5, 5](cat 和 dog 不变),car 那一行权重会怎样?
写出 attention 里算分数的那一行。
代码写出 attention 里算分数的那一行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
看“单向的键”这个例子:`W_Q` 是单位矩阵,`W_K` = [[0, 0], [1, 0]],所以 K = X @ `W_K` 把每个词 [x, y] 变成键 [y, 0]。cat = [2, 0],car = [0, 2]。car 看 cat 的分数,也就是 car 的查询 · cat 的键,是多少?
一句话有 5 个词。Q 和 K 都是 (5, 4)。Q @ K.T 是什么形状?
c = 0 时,sweet 的查询是 [0, 0]。键是 apple = [1, 0] 和 sweet = [0, 1]。sweet 放在 apple 上的权重是多少?
模型训练好并保存了。用户输入了一句新话。和上次运行模型时相比,哪些数不一样了?
选择模型训练好并保存了。用户输入了一句新话。和上次运行模型时相比,哪些数不一样了?
不除以 √2 时,cat 的分数 cat·cat、cat·dog、cat·car = [4, 2, 0]。用 e⁴ ≈ 54.6,e² ≈ 7.4,e⁰ = 1。softmax 之后,cat 放在自己身上的权重是多少?(保留 2 位小数)
从头到尾写一个注意力头:三个投影、缩放后的分数、softmax、加权平均。需要写好几行。
代码从头到尾写一个注意力头:三个投影、缩放后的分数、softmax、加权平均。需要写好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
cat 的分数是 [0.34, 0.05, 挡住];第三个词是 PAD token。如果被挡住的分数设成 0 而不是 −∞ 会怎样?用 e^0.34 ≈ 1.40,e^0.05 ≈ 1.05,e^0 = 1。PAD token 会拿到……
选择cat 的分数是 [0.34, 0.05, 挡住];第三个词是 PAD token。如果被挡住的分数设成 0 而不是 −∞ 会怎样?用 e^0.34 ≈ 1.40,e^0.05 ≈ 1.05,e^0 = 1。PAD token 会拿到……
一句话有 6 个 token。它的因果掩码是什么形状?
只用因果掩码,4 个 token。16 个权重里有几个可以不为零?
一个批里有 2 个句子,每句 5 个 token。填充掩码是 (2, 1, 5),分数是 (2, 5, 5)。广播之后掩码是什么形状?
构造因果掩码:在词会往后看的地方(列 > 行)是 True(或 1),其余地方是 False(或 0)。
代码构造因果掩码:在词会往后看的地方(列 > 行)是 True(或 1),其余地方是 False(或 0)。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
3 个词,2 个头,每个头给每个词输出 2 个数。各个头的输出合成一张叫 concat 的表,每个词一行。concat 是什么形状?
2 个头,每个给每个词输出 2 个数。它们的输出并排放进一张表 concat,头 0 在最前面。头和列都从 0 开始数。头 1 的输出从 concat 的第几列开始?
一个模型的 `d_model` = 512,有 8 个头。每个头分到几个数(dₖ)?
写一个带因果掩码的注意力头,从 X 和三个权重矩阵一直算到输出 out。需要写好几行。
代码写一个带因果掩码的注意力头,从 X 和三个权重矩阵一直算到输出 out。需要写好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
不带任何位置信息的自注意力先在“cat dog car”上运行,再在“car dog cat”上运行。cat 的输出会不同吗?
选择不带任何位置信息的自注意力先在“cat dog car”上运行,再在“car dog cat”上运行。cat 的输出会不同吗?
每个词有 2 个数时,位置 pos 得到 [sin(pos), cos(pos)]。PE[0][1],也就是位置 0 的向量的第二个数,是多少?
一个模型的 `d_model` = 64。加上位置向量之前,每个词向量要乘以 √`d_model`。乘以多少?
一个句子有 10 个 token,`d_model` = 8。它的位置编码是什么形状?
X 是 (3, 2),W1 是 (2, 4)。隐藏层是什么形状?
cat = [2, 0],W1 = [[1, −1, 0, 1], [0, 1, −1, 1]],b1 = [0, 0, 1, −2]。ReLU 之前,cat 的 4 个隐藏单元是 cat @ W1 + b1。ReLU 之后有几个是开的(大于 0)?
数字 cat = [2, 0],W1 = [[1, −1, 0, 1], [0, 1, −1, 1]],b1 = [0, 0, 1, −2]。ReLU 之前,cat 的 4 个隐藏单元是 cat @ W1 + b1。ReLU 之后有几个是开的(大于 0)?
FFN 计算的是 ReLU(X @ W1 + b1) @ W2 + b2。先让 X 装三个词:cat、dog 和 car。再只对 cat 单独运行。和三个词一起处理时 cat 那一行相比,结果……
选择FFN 计算的是 ReLU(X @ W1 + b1) @ W2 + b2。先让 X 装三个词:cat、dog 和 car。再只对 cat 单独运行。和三个词一起处理时 cat 那一行相比,结果……
30 层,每层都乘一个会让数变小一点的随机矩阵(增益 0.5)。没有残差,没有 LayerNorm。30 层之后,这些数……
选择30 层,每层都乘一个会让数变小一点的随机矩阵(增益 0.5)。没有残差,没有 LayerNorm。30 层之后,这些数……
对词 [1, 1, 5, 5] 做 LayerNorm。它的均值是 3,标准差是 2。每个 5 会变成多少?
X 是 (2, 5, 8):2 个句子,每句 5 个词,每个词 8 个数。LayerNorm 一共算出多少个各自独立的均值?
补全对最后一个轴做的 LayerNorm。
代码补全对最后一个轴做的 LayerNorm。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出带残差的 FFN 子层 X + ffn(X):用 W1 和 b1 变宽,ReLU,用 W2 和 b2 变窄回来,再加上输入 X。两行。
代码写出带残差的 FFN 子层 X + ffn(X):用 W1 和 b1 变宽,ReLU,用 W2 和 b2 变窄回来,再加上输入 X。两行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一个 pre-norm 块运行 x = x + ffn(`layer_norm`(x)) 这一行。对一个 token,x = [3, 1],FFN 的输出是 [0, 0]。运行这一行之后 x 是多少?
选择一个 pre-norm 块运行 x = x + ffn(layer_norm(x)) 这一行。对一个 token,x = [3, 1],FFN 的输出是 [0, 0]。运行这一行之后 x 是多少?
一个模型有 3 个 pre-norm 解码器块,每个块在注意力前有一个 LayerNorm,在 FFN 前有一个,输出层之前还有一个最终的 LayerNorm。它一共有多少个 LayerNorm?
写出解码器堆叠:`n_blocks` 个 pre-norm 解码器块,然后是最终的 LayerNorm。在每个块里,带掩码的自注意力和随后的 FFN 都读 x 的 LayerNorm,各自的结果都加到 x 上。
代码写出解码器堆叠:n_blocks 个 pre-norm 解码器块,然后是最终的 LayerNorm。在每个块里,带掩码的自注意力和随后的 FFN 都读 x 的 LayerNorm,各自的结果都加到 x 上。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
第 17 关的模型把 905 读成一个序列:先是数字,然后是 =,然后是单词,最后是 <eos>。每个数字一个 token,每个单词一个 token。一共多少个 token?
一批里有 64 个数。模型的输入 x 是 (64, 8):每个数 8 个 token,不够的补齐。词表里有 42 个 token,`d_model` = 64。logits 是什么形状?
`d_model` 保持 64,把头的数量从 4 改成 8。参数的数量……
选择d_model 保持 64,把头的数量从 4 改成 8。参数的数量……
`d_model` = 64,`d_ff` = 128。一个 FFN 有多少个参数?它是 Linear(64 → 128)、ReLU、Linear(128 → 64)。权重和偏置都要算。
同一批:x 是 (64, 8),模型有 4 个头。一个块的注意力分数是什么形状?
一个训练好的模型在把一个数读出来(推理)。运行过程中,下面哪一个会变?
选择一个训练好的模型在把一个数读出来(推理)。运行过程中,下面哪一个会变?
正在读 742。模型已经写出了“seven hundred forty”。这一步送进模型的有多少行?
写出贪心解码的一步。h 是模型输出的最后一行(在最终的 LayerNorm 之后),W 和 b 是输出层。返回下一个词的 id。
代码写出贪心解码的一步。h 是模型输出的最后一行(在最终的 LayerNorm 之后),W 和 b 是输出层。返回下一个词的 id。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出完整的贪心循环。从提示词(数字和 =)开始。每一步都在目前为止的所有内容上运行模型,取分数的最后一行,追加分数最高的 id,模型选出 eos 后就停(eos 要留在列表里)。即使没有 eos,也在 `max_new` 个新 token 之后停下。
代码写出完整的贪心循环。从提示词(数字和 =)开始。每一步都在目前为止的所有内容上运行模型,取分数的最后一行,追加分数最高的 id,模型选出 eos 后就停(eos 要留在列表里)。即使没有 eos,也在 max_new 个新 token 之后停下。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
对 427,x = 4 2 7 = four hundred twenty seven,y = 2 7 = four hundred twenty seven <eos>:8 个目标。损失只计入属于答案的目标(单词和 <eos>)。8 个里有几个计入?
算损失时,把 (64, 5, 42) 的 logits 展平,让每个位置成为一行。它变成什么形状?
你删掉因果掩码,重新训练。会发生什么?
选择你删掉因果掩码,重新训练。会发生什么?
你为一个新任务搭了一个新模型。训练 10 轮后它一个都答不对,训练损失也早就不降了。你先试什么?
选择你为一个新任务搭了一个新模型。训练 10 轮后它一个都答不对,训练损失也早就不降了。你先试什么?
从分数开始,写出跳过 PAD 的完整损失。logits 是 (N, V),targets 是 (N,),参数 pad 是 PAD 的 id(默认是 0)。返回目标不是 PAD 的那些行的平均损失。需要写好几行。
代码从分数开始,写出跳过 PAD 的完整损失。logits 是 (N, V),targets 是 (N,),参数 pad 是 PAD 的 id(默认是 0)。返回目标不是 PAD 的那些行的平均损失。需要写好几行。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
分数:mat 2.0,sofa 1.5,rug 1.0,roof 0.0,moon −1.0。T = 1 时,贪心挑 mat。用 e² ≈ 7.4,e^1.5 ≈ 4.5,e¹ ≈ 2.7,e⁰ = 1,e^−1 ≈ 0.4。softmax 给 mat 的概率是多少?(保留 2 位小数)
你采样(不是贪心),T = 0.01,所以每个分数都乘以 100。现在采样会怎样?
选择你采样(不是贪心),T = 0.01,所以每个分数都乘以 100。现在采样会怎样?
概率:mat 0.46,sofa 0.28,rug 0.17,roof 0.06,moon 0.03。k = 2 的 top-k 保留 mat 和 sofa,再除以它们的总和。sofa 新的概率是多少?(保留 2 位小数)
排好序的概率:0.4631,0.2809,0.1704,0.0627,0.0231。p = 0.9 的 top-p 从最大的开始保留词,直到累计和达到 0.9。它保留几个词?
补全 `top_p`:`keep_sorted` 必须按排好的顺序,对每个要保留的词都是 True。
代码补全 top_p:keep_sorted 必须按排好的顺序,对每个要保留的词都是 True。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
第一个词:a 0.5,the 0.4,one 0.1。a 之后:dog 0.4,cat 0.3,fox 0.3。the 之后:dog 0.9,cat 0.05,fox 0.05。one 之后:dog 0.5,cat 0.25,fox 0.25。贪心在每一步取最好的词。贪心写出的两词句子,概率是多少?(保留 2 位小数)
第一个词:a 0.5,the 0.4,one 0.1。a 之后:dog 0.4,cat 0.3,fox 0.3。the 之后:dog 0.9,cat 0.05,fox 0.05。one 之后:dog 0.5,cat 0.25,fox 0.25。贪心写出“a dog”,概率 0.20。宽度为 2 的束搜索保留最好的两个第一个词(a 和 the),再看它们后面所有的第二个词。它能找到比贪心的 0.20 更好的句子吗?
选择第一个词:a 0.5,the 0.4,one 0.1。a 之后:dog 0.4,cat 0.3,fox 0.3。the 之后:dog 0.9,cat 0.05,fox 0.05。one 之后:dog 0.5,cat 0.25,fox 0.25。贪心写出“a dog”,概率 0.20。宽度为 2 的束搜索保留最好的两个第一个词(a 和 the),再看它们后面所有的第二个词。它能找到比贪心的 0.20 更好的句子吗?
第一个词:a 0.5,the 0.4,one 0.1。a 之后:dog 0.4,cat 0.3,fox 0.3。the 之后:dog 0.9,cat 0.05,fox 0.05。one 之后:dog 0.5,cat 0.25,fox 0.25。宽度为 2 的束搜索找到的最好句子,概率是多少?(保留 2 位小数)
一个计数模型看最后两个词。它见过“the cat sat on the mat .”的次数远多于其他任何句子。贪心从“the”开始写 14 个词。你预计会怎样?
选择一个计数模型看最后两个词。它见过“the cat sat on the mat .”的次数远多于其他任何句子。贪心从“the”开始写 14 个词。你预计会怎样?
在“. the”之后,ln p(cat) = −0.7752,ln p(dog) = −1.1852。“cat”已经写过一次,“dog”一次也没写过。惩罚为 1.0,分数 = ln p − 1.0 × (写过的次数)。cat 的分数是多少?(保留 4 位小数)
在“on the”之后,模型给出 mat 0.3445,rug 0.2451,park 0.1984,roof 0.1835,其他 10 个词每个 0.0029。p = 0.9 的 top-p 保留几个词?
模型已经处理过 token 0 到 98,它们的 k 和 v 都在 KV 缓存里。模型刚刚挑出了 token 99。为了预测 token 100,它把 token 99 交给模型。现在要为几个 token 计算 k 和 v?
有 KV 缓存:token 0、1、2 在缓存里,token 3 交给模型。这一步 Q 有几行?
没有缓存。一个一个地写出 token 0 到 99,第一步算 1 个 token 的 k,第二步算 2 个,……,最后一步算 100 个。总共算了多少次 k?
写出采样器的过滤部分:把分数除以 T(已经写好),只保留最大的 k 个,返回加起来等于 1 的概率,被去掉的词为 0。
代码写出采样器的过滤部分:把分数除以 T(已经写好),只保留最大的 k 个,返回加起来等于 1 的概率,被去掉的词为 0。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
对一个通用模型来说,为什么一个堆叠会比编码器加解码器更好?
选择对一个通用模型来说,为什么一个堆叠会比编码器加解码器更好?
一个 post-norm 堆叠有 12 层,每层是 x = LayerNorm(x + f(x))。从输入到输出的那条直通的残差通路上,有几个 LayerNorm?
x = [1, 1, 3, 5]。均方根是 √((1² + 1² + 3² + 5²) / 4)。它是多少?
x = [1, 1, 3, 5],它的均方根是 3。RMSNorm(x) 的最后一个数是多少?(保留 2 位小数)
沿最后一个轴写出 RMSNorm(x 全是 0 时,eps 保证它不出错)。
代码沿最后一个轴写出 RMSNorm(x 全是 0 时,eps 保证它不出错)。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
θ = 每个位置 0.5 弧度。q 在位置 2。q 被旋转了多少弧度?
q 在位置 2,k 在位置 0,它们的分数是某个数 s。现在把两者都往后移 10 个位置(12 和 10)。分数……
选择q 在位置 2,k 在位置 0,它们的分数是某个数 s。现在把两者都往后移 10 个位置(12 和 10)。分数……
q = [1, 0] 在位置 2,k = [0, 1] 在位置 0,θ = 0.5。旋转之后,q = [cos 1, sin 1] ≈ [0.54, 0.84],k 还是 [0, 1]。分数 q·k 是多少?(保留 2 位小数)
把一对数 v 旋转 pos × theta 弧度(逆时针)。
代码把一对数 v 旋转 pos × theta 弧度(逆时针)。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
SiLU(z) = z × sigmoid(z) = z / (1 + e^−z)。用 e^−1 ≈ 0.37。SiLU(1) 是多少?(保留 2 位小数)
普通 FFN 有 2 个 `d_model` × `d_ff` 的矩阵。SwiGLU FFN 有 3 个 `d_model` × `d_ff`′ 的矩阵。要让权重一样多,`d_ff`′ / `d_ff` 是多少?(保留 2 位小数)
为一批形状为 (L, `d_model`) 的词行 x 写出第 5 节的 SwiGLU FFN,权重是 `W_gate`、`W_up` 和 `W_down`。每个词返回一行 `d_model` 个数。
代码为一批形状为 (L, d_model) 的词行 x 写出第 5 节的 SwiGLU FFN,权重是 W_gate、W_up 和 W_down。每个词返回一行 d_model 个数。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一个模型有 32 层、32 个注意力头,dₖ = 128,每个头都有自己的 K 和 V。每个数占 2 字节。一个 token 需要多少 KiB 的 KV 缓存?(1 KiB = 1,024 字节)
一个模型有 32 个查询头和 8 个 K/V 头,都从 0 开始编号;相邻的查询头共用一个 K/V 头。查询头 13 用的是哪个 K/V 头?
一块 GPU 有 24 GiB 显存,模型的权重占了其中 16 GiB。剩下的放 KV 缓存。模型用分组查询注意力,有 4 个 K/V 头,dₖ = 128,32 层,每个数存成 2 字节。能放下多少个 token 的 KV 缓存?(1 KiB = 1,024 字节,1 GiB = 1,024 × 1,024 KiB)
一个模型有 70 亿个权重。一块 GPU 每秒做 10¹⁴ 个 FLOPs(100 万亿)。用前向传播的 2N 规则,只算算术的话,它每秒最多能产生多少个 token?
一个块的模型宽度 d = 64,FFN 宽度 256。一个新 token 关注 L = 128 个 token。它的注意力需要两个乘积:分数 (1, 64) @ (64, 128),和加权和 (1, 128) @ (128, 64)。这个 token 在整个块里花多少 FLOPs,权重和注意力合起来?
一个块的模型宽度 64,FFN 宽度 256,所以它的权重部分是每个 token 98,304 个 FLOPs。它的注意力部分是 4 × L × 64 个 FLOPs。上下文长度 L 是多少时,两部分相等?
一个模型有 70 亿个权重,每个 2 字节。GPU 每秒从显存读 10¹² 字节,每个新 token 都必须把每个权重读一遍。对一个用户,它每秒最多能写多少个 token?(保留 1 位小数)
一个模型有 70 亿个权重,每个 2 字节。一步解码以每秒 10¹² 字节的速度读 1.4 × 10¹⁰ 字节的权重。每个用户的 token 花 1.4 × 10¹⁰ 个 FLOPs,速度是每秒 10¹⁴ 个 FLOPs。一步同时服务 B 个用户,只读一遍权重。B 是多少时,算术和读取花的时间一样长?
把 70 亿个权重每个存成 1 字节,而不是 2 字节。GPU 仍然每秒读 10¹² 字节,每个用户的 token 仍然花 1.4 × 10¹⁰ 个 FLOPs,速度是每秒 10¹⁴ 个 FLOPs。现在 B 是多少时,算术和读取花的时间一样长?
一个模型有 70 亿个权重,每个 2 字节。GPU 每秒读 10¹² 字节,每秒做 10¹⁴ 个 FLOPs。它用一次前向传播读一个 2,000 个 token 的提示词。权重读一遍(14 ms),每个 token 花 1.4 × 10¹⁰ 个 FLOPs。这一次前向传播要多少 ms?
同样的模型和 GPU:70 亿个权重,每个 2 字节,每秒读 10¹² 字节,每秒 10¹⁴ 个 FLOPs。现在提示词只有 50 个 token。预填充这一次要多少 ms?
一块 GPU 有 80 GB 显存。里面放着那个 70 亿权重模型的 14 GB 权重,以及每个用户的 KV 缓存。每个用户有 4,000 个 token 的缓存,每个 token 128 KiB。最多能放下多少个用户?(1 GB = 10⁹ 字节,1 KiB = 1,024 字节)
写出一步解码的 serve。B 个用户每人有一份 KV 缓存,长度是给定的 token 数。这一步把权重读一遍,再读每个用户的缓存。它还为每个用户的 token 做 2N 个 FLOPs。`bytes_per` 是每个存储的数的字节数:权重和 KV 缓存都用它。这一步花的是读取和算术中较长的那个。返回一步的时间(ms)、每个用户每秒的 token 数,以及每秒的 token 总数。
代码写出一步解码的 serve。B 个用户每人有一份 KV 缓存,长度是给定的 token 数。这一步把权重读一遍,再读每个用户的缓存。它还为每个用户的 token 做 2N 个 FLOPs。bytes_per 是每个存储的数的字节数:权重和 KV 缓存都用它。这一步花的是读取和算术中较长的那个。返回一步的时间(ms)、每个用户每秒的 token 数,以及每秒的 token 总数。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
<bos>23+58=81<eos> 里有多少个 token?
一批里的序列长度必须都相同。最长的题是 99 + 99。<bos>99+99=198<eos> 里有多少个 token?
位置从 0 开始数:x = <bos> 2 3 + 5 8 = 8 1 … 模型在哪个位置 t 猜答案的第一个数字?
23 + 58 的 y 是 2 3 + 5 8 = 8 1 <eos> <pad>。损失只算答案数字时,答案之前的每个目标值和每个 <pad> 都变成 IGNORE。还有几个目标值算数?
把一个 id 序列拆成输入 x 和目标 y。
代码把一个 id 序列拆成输入 x 和目标 y。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一批 64 个样本,每个补齐到 11 个 token,所以每个 x 有 10 个。词表有 15 个 token。logit 是什么形状?
q 的形状是 (32, 10, 64):批 32,长度 10,`d_model` 64。用 4 个头时,dₖ = 16。做完 view(32, 10, 4, 16) 和 transpose(1, 2) 之后,q 是什么形状?
把最后一个轴拆成 h 个头,再把头挪到长度前面:(B, L, d) → (B, h, L, d // h)。
代码把最后一个轴拆成 h 个头,再把头挪到长度前面:(B, L, d) → (B, h, L, d // h)。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
注意力算完以后,out 的形状是 (32, 4, 10, 16):批 32,4 个头,长度 10,dₖ 16。out.transpose(1, 2).contiguous().view(32, 10, -1) 是什么形状?
补完带掩码的多头注意力。q、k、v 已经拆成了多个头,形状是 (B, h, L, dₖ)。
代码补完带掩码的多头注意力。q、k、v 已经拆成了多个头,形状是 (B, h, L, dₖ)。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
损失算每个位置时,训练损失一直停在 1.0 左右,而答案几乎全对了。为什么它降不下去?
选择损失算每个位置时,训练损失一直停在 1.0 左右,而答案几乎全对了。为什么它降不下去?
词表有 15 个 token,ln 15 ≈ 2.71。你没训练过的模型在一批数据上的第一个损失是 9.4。这说明什么?
选择词表有 15 个 token,ln 15 ≈ 2.71。你没训练过的模型在一批数据上的第一个损失是 9.4。这说明什么?
返回模型答错的每一道题,写成 ‘2+7=1’ 这样。problems 是 (a, b) 对的列表,answers 是模型给出的字符串答案,顺序相同。
代码返回模型答错的每一道题,写成 ‘2+7=1’ 这样。problems 是 (a, b) 对的列表,answers 是模型给出的字符串答案,顺序相同。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
python check.py `my_gpt.py` 打印了一行类似 forward = “0a1b2c3d4e5f” 的内容。把这一整行粘贴过来覆盖下面的第一行,或者只把那 12 个字母和数字填进 ____。
代码python check.py my_gpt.py 打印了一行类似 forward = “0a1b2c3d4e5f” 的内容。把这一整行粘贴过来覆盖下面的第一行,或者只把那 12 个字母和数字填进 ____。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
粘贴 python check.py `my_gpt.py` model.pt 打印的报告那一行:“report =”后面的全部内容。
代码粘贴 python check.py my_gpt.py model.pt 打印的报告那一行:“report =”后面的全部内容。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
D1加噪与去噪原理 · 扩散模型
β = 0.1、0.2、0.5 时,走完 3 步后 alpha-bar 是多少?
信号乘以 0.6,噪声乘以 0.8。0.6² + 0.8² 是多少?
x0 = [1, 2],eps = [0.5, −1],alpha-bar = 0.36。x₃ 的第一个数是多少?
用 xₜ = √ᾱₜ x0 + √(1 − ᾱₜ) eps 往一团螺旋形的二维点里混入噪声。在 50 步的调度里,t = 50 时 alpha-bar 是 0.0045。这时螺旋是什么样子?
选择用 xₜ = √ᾱₜ x0 + √(1 − ᾱₜ) eps 往一团螺旋形的二维点里混入噪声。在 50 步的调度里,t = 50 时 alpha-bar 是 0.0045。这时螺旋是什么样子?
写出 `add_noise`。ab 是 alpha-bar。它应该对一个点或一个点数组都能用。
代码写出 add_noise。ab 是 alpha-bar。它应该对一个点或一个点数组都能用。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出 `noisy_at`:给定干净点 x0、噪声 eps、一列 beta 和步数 t(从 1 开始数),先算出第 t 步的 alpha-bar,再返回加噪点 xₜ。
代码写出 noisy_at:给定干净点 x0、噪声 eps、一列 beta 和步数 t(从 1 开始数),先算出第 t 步的 alpha-bar,再返回加噪点 xₜ。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
在 t = 3(alpha-bar 为 0.36)时,x₃ = [0.7, 1.0],真实噪声是 eps = [0.5, 0.5]。x0 的第二个数是多少?
最简单的网络永远猜噪声是 [0, 0]。某个点的真实噪声是 [0.5, −1]。损失 mean((guess − eps)²) 是多少?
一个训练批有 128 个加噪点。每一行输入是这个点的 x 和 y,再加上编码步数 t 的 12 个数。送进网络的形状是什么?
写出 `guess_clean`:给定一个加噪点、网络的噪声猜测和 alpha-bar,返回对 x0 的猜测。
代码写出 guess_clean:给定一个加噪点、网络的噪声猜测和 alpha-bar,返回对 x0 的猜测。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
把一张 6 × 6 的图片切成大小为 2 的图块(每个图块 2 × 2 像素)。token 矩阵(token 数,每个 token 的数的个数)的形状是什么?
把一张 28 × 28 的数字图片切成大小为 7 的图块(每个图块 7 × 7 像素)。一共有多少个 token?
在 28 × 28 的图片上,把图块大小从 4 改成 2。每一层的注意力分数个数会怎样?
选择在 28 × 28 的图片上,把图块大小从 4 改成 2。每一层的注意力分数个数会怎样?
图块大小为 p 时,把 (H, W) 图片的每个轴拆成(哪一块,块里的哪个像素)。
代码图块大小为 p 时,把 (H, W) 图片的每个轴拆成(哪一块,块里的哪个像素)。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
写出 patchify:(H, W) 的图片 → (图块数, p·p),图块从左到右、再从上到下排列。
代码写出 patchify:(H, W) 的图片 → (图块数, p·p),图块从左到右、再从上到下排列。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
在 28 × 28 的数字图片上用大小为 4 的图块,得到 49 个 token,每个 16 个数。Wᵢₙ 是 (16, 96)。tokens @ Wᵢₙ 的形状是什么?
有 49 个 token 时,一个头在一层里要算多少个注意力分数?
自编码器把 784 个像素压成 16 个数。扩散要处理的数少了多少倍?
这 16 个编码数的标准差大约是 4。支线 D1 的公式要求干净数据的方差为 1,也就是标准差为 1。你先把每个编码数都除以同一个数。是哪个数?
一个自编码器把每张 28 × 28 的数字图片变成 16 个数的编码,它的解码器再把编码变回图片。取一个 3 和一个 7,从一个走到另一个,走到一半。混合像素得到的结果,和混合两个编码再解码得到的结果相比,是怎样的?
选择一个自编码器把每张 28 × 28 的数字图片变成 16 个数的编码,它的解码器再把编码变回图片。取一个 3 和一个 7,从一个走到另一个,走到一半。混合像素得到的结果,和混合两个编码再解码得到的结果相比,是怎样的?
写出采样循环。`eps_exact` 是这个 8 点圆环的完美噪声猜测。每个样本都必须落在 8 个点中的某一个上,而且 8 个点都要出现。
代码写出采样循环。eps_exact 是这个 8 点圆环的完美噪声猜测。每个样本都必须落在 8 个点中的某一个上,而且 8 个点都要出现。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
Boss 关第 2 部分。把 boss.py 针对你自己写的 `add_noise`、guide 和 `step_back` 打印出的 PASS 那一行,粘贴到引号之间。
代码Boss 关第 2 部分。把 boss.py 针对你自己写的 add_noise、guide 和 step_back 打印出的 PASS 那一行,粘贴到引号之间。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行