python - 使用 Pytorch 进行与门

Question

我对 PyTorch 和深度学习总体来说还是个新手。
我写的代码可以往下看更长。我正在尝试学习简单的“与”问题，该问题是线性可分离的。
问题是，我的结果很差。只有大约 2/10 次才能得出正确答案。
有时，loss.item() 值会停留在 0.250。

只是为了清理

• 为什么它只能发挥 2/10 次？

.

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.autograd as autog

data_x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
data_y = np.array([[0, 0, 0, 1]]).T
data_x = autog.Variable(torch.FloatTensor(data_x))
data_y = autog.Variable(torch.FloatTensor(data_y), requires_grad=False)

in_dim = 2
out_dim = 1
epochs = 15000
epoch_print = epochs / 5
l_rate = 0.001

class NeuralNet(nn.Module):
    def __init__(self, input_size, output_size):
        super(NeuralNet, self).__init__()
        self.lin1 = nn.Linear(input_size, output_size)
        self.relu = nn.ReLU()

    def forward(self, x):
        out = x
        out = self.lin1(out)
        out = self.relu(out)
        return out

model = NeuralNet(in_dim, out_dim)
criterion = nn.L1Loss()
optimizer = optim.Adam(model.parameters(), lr=l_rate)

for epoch in range(epochs):
    pred = model(data_x)
    loss = criterion(pred, data_y)
    loss.backward()
    optimizer.step()
    if (epoch + 1) % epoch_print == 0:
        print("Epoch %d  Loss %.3f" %(epoch + 1, loss.item()))


for x, y in zip(data_x, data_y):
    pred = model(x)
    print("Input", list(map(int, x)), "Pred", int(pred), "Output", int(y))

Answer 1

1。将 Zero_grad 与优化器结合使用

您没有使用optimizer.zero_grad()来清除渐变。您的学习循环应该如下所示:

for epoch in range(epochs):
    optimizer.zero_grad()
    pred = model(data_x)
    loss = criterion(pred, data_y)
    loss.backward()
    optimizer.step()
    if (epoch + 1) % epoch_print == 0:
        print("Epoch %d  Loss %.3f" %(epoch + 1, loss.item()))

在这种特殊情况下，它不会产生任何有害影响，梯度正在累积，但是由于您一遍又一遍地循环使用相同的数据集，因此几乎没有任何区别(不过您应该养成这种习惯，因为您将使用它贯穿您的深度学习之旅)。

2。成本函数

您使用的是平均绝对误差，这是回归损失函数，而不是分类函数(您所做的是二元分类)。

因此，您应该使用 BCELoss 和 sigmoid 激活，或者(我更喜欢这种方式)，从网络返回 logits 并使用 BCEWithLogitsLoss ，两者都计算二元交叉熵(交叉熵的简化版)。

见下文:

class NeuralNet(nn.Module):
    def __init__(self, input_size, output_size):
        super(NeuralNet, self).__init__()
        self.lin1 = nn.Linear(input_size, output_size)

    def forward(self, x):
        # You may want to use torch.nn.functional.sigmoid activation
        return self.lin1(x)

...
# Change your criterion to nn.BCELoss() if using sigmoid
criterion = nn.BCEWithLogitsLoss()
...

3。预测

如果您使用 logits 版本，分类器会学习将负值分配给 0 标签，将正值分配给 1。您的显示函数必须修改以纳入这些知识:

for x, y in zip(data_x, data_y):
    pred = model(x)
    # See int(pred > 0), that's the only change
    print("Input", list(map(int, x)), "Pred", int(pred > 0), "Output", int(y))

如果您的转发将 sigmoid 应用于输出，则此步骤不适用。哦，最好使用 torch.round 而不是转换为 int。