pytorch 中的张量 [:] 和张量有什么区别?

Question

import numpy as np
import time
features, labels = d2l.get_data_ch7()
def init_adam_states():
v_w, v_b = torch.zeros((features.shape[1], 1),dtype=torch.float32), torch.zeros(1, dtype=torch.float32)
s_w, s_b = torch.zeros((features.shape[1], 1),dtype=torch.float32), torch.zeros(1, dtype=torch.float32)
return ((v_w, s_w), (v_b, s_b))
def adam(params, states, hyperparams):
beta1, beta2, eps = 0.9, 0.999, 1e-6
for p, (v, s) in zip(params, states):
v[:] = beta1 * v + (1 - beta1) * p.grad.data
s = beta2 * s + (1 - beta2) * p.grad.data**2
v_bias_corr = v / (1 - beta1 ** hyperparams['t'])
s_bias_corr = s / (1 - beta2 ** hyperparams['t'])
p.data -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)
hyperparams['t'] += 1
def train_ch7(optimizer_fn, states, hyperparams, features, labels, batch_size=10, num_epochs=2):
# 初始化模型
net, loss = d2l.linreg, d2l.squared_loss
w = torch.nn.Parameter(torch.tensor(np.random.normal(0, 0.01, size=(features.shape[1], 1)), dtype=torch.float32),
requires_grad=True)
b = torch.nn.Parameter(torch.zeros(1, dtype=torch.float32), requires_grad=True)
def eval_loss():
return loss(net(features, w, b), labels).mean().item()
ls = [eval_loss()]
data_iter = torch.utils.data.DataLoader(torch.utils.data.TensorDataset(features, labels), batch_size, shuffle=True)
for _ in range(num_epochs):
start = time.time()
print(w)
print(b)
for batch_i, (X, y) in enumerate(data_iter):
l = loss(net(X, w, b), y).mean()  # 使⽤平均损失
# 梯度清零
if w.grad is not None:
w.grad.data.zero_()
b.grad.data.zero_()
l.backward()
optimizer_fn([w, b], states, hyperparams)  # 迭代模型参数
if (batch_i + 1) * batch_size % 100 == 0:
ls.append(eval_loss())  # 每100个样本记录下当前训练误差
# 打印结果和作图
print('loss: %f, %f sec per epoch' % (ls[-1], time.time() - start))
d2l.set_figsize()
d2l.plt.plot(np.linspace(0, num_epochs, len(ls)), ls)
d2l.plt.xlabel('epoch')
d2l.plt.ylabel('loss')
train_ch7(adam, init_adam_states(), {'lr': 0.01, 't': 1}, features, labels)

我想在下面的代码中实现 Adam 算法，我对名为 Adam 的函数感到困惑。

v = beta1 * v + (1 - beta1) * p.grad.data
s = beta2 * s + (1 - beta2) * p.grad.data**2

当我使用以下代码时，损失函数曲线如图 1 所示。 图1

v[:] = beta1 * v + (1 - beta1) * p.grad.data
s = beta2 * s + (1 - beta2) * p.grad.data**2
or
v = beta1 * v + (1 - beta1) * p.grad.data
s[:] = beta2 * s + (1 - beta2) * p.grad.data**2

当我使用以下代码时，损失函数曲线如图 2 所示。 图2

v[:] = beta1 * v + (1 - beta1) * p.grad.data
s[:] = beta2 * s + (1 - beta2) * p.grad.data**2

当我使用以下代码时，损失函数曲线如图 3 所示。 图3

案例

• 3 中的损失函数曲线始终比案例 1 中的曲线更平滑。

• 情况 2 中的损失函数曲线有时无法收敛。

为什么不同？

Answer 1

回答第一个问题，

v = beta1 * v + (1 - beta1) * p.grad.data

是一个不合适的操作。请记住，python变量是对对象的引用。通过给变量v赋值一个新值，在赋值之前v引用的基础对象不会改变。相反，表达式beta1 * v + (1 - beta1) * p.grad.data产生一个新的张量，然后由v引用。

另一方面

v[:] = beta1 * v + (1 - beta1) * p.grad.data

是就地操作。在此操作之后，v仍然引用相同的底层对象，并且该张量的元素被修改并替换为新张量beta1 * v + (1 - beta1) * p.grad.data的值。

---

看看以下 3 行，看看为什么这很重要

for p, (v, s) in zip(params, states):
v[:] = beta1 * v + (1 - beta1) * p.grad.data
s[:] = beta2 * s + (1 - beta2) * p.grad.data**2

v和s实际上指的是存储在states中的张量。如果我们执行就地操作，则状态中的值将更改以反映分配给v[:]和s[:]的值。

如果使用错位操作，则states中的值保持不变。