在 Pytorch 中使用逻辑回归的预测返回无穷大

Question

我开始观看有关 PyTorch 的教程，并且正在学习逻辑回归的概念。

我使用我拥有的一些股票数据进行了尝试。我有inputs，里面有两个参数trade_quantity和trade_value，还有targets，里面有对应的股价。

inputs = torch.tensor([[182723838.00, 2375432.00],
                       [185968153.00, 2415558.00],
                       [181970093.00, 2369140.00],
                       [221676832.00, 2811589.00],
                       [339785916.00, 4291782.00],
                       [225855390.00, 2821301.00],
                       [151430199.00, 1889032.00],
                       [122645372.00, 1552998.00],
                       [129015052.00, 1617158.00],
                       [121207837.00, 1532166.00],
                       [139554705.00, 1789392.00]])

targets = torch.tensor([[76.90],
                        [76.90],
                        [76.90],
                        [80.70],
                        [78.95],
                        [79.60],
                        [80.05],
                        [78.90],
                        [79.40],
                        [78.95],
                        [77.80]])

我将模型函数、损失定义为均方误差，并尝试运行几次以获得一些预测。代码如下：

def model(x):
    return x @ w.t() + b

def mse(t1, t2):
    diff = t1 - t2
    return torch.sum(diff * diff) / diff.numel()

preds = model(inputs)
loss = mse(preds, targets)
loss.backward()
with torch.no_grad():
    w -= w.grad * 1e-5
    b -= b.grad * 1e-5
    w.grad.zero_()
    b.grad.zero_()

我为此使用 Jupyter，并运行了代码的最后部分几次，之后预测如下：

tensor([[inf],
        [inf],
        [inf],
        [inf],
        [inf],
        [inf],
        [inf],
        [inf],
        [inf],
        [inf],
        [inf]], grad_fn=<AddBackward0>)

如果我再运行几次，预测就会变成nan。你能告诉我为什么会这样吗？

Answer 1

对我来说，这看起来更像是线性回归而不是逻辑回归。您正在尝试将线性模型拟合到您的数据中。它不同于二进制分类任务，您需要使用一种特殊类型的激活函数（例如sigmoid），以便输出为0 或1。

在这个特定的例子中，你想解决一个二维线性问题给定输入x，形状为(batch, x1, x2)（其中x1是trade_quantity，x2是trade_value）和目标(batch, y)（@ 987654333@ 是stock_price)。

所以目标是找到最好的w 和b 矩阵（权重矩阵和偏差列），以便x@w + b 尽可能接近y，根据您的标准，均方误差。

---

我建议对您的数据进行规范化，使其保持在[0, 1] 范围内。您可以通过测量inputs 和targets 的均值 和标准差 来做到这一点。

inputs_min, inputs_max = inputs.min(axis=0).values, inputs.max(axis=0).values
targets_min, targets_max = targets.min(axis=0).values, targets.max(axis=0).values

然后应用转换：

x = (inputs - inputs_min)/(inputs_max - inputs_min)
y = (targets - targets_min)/(targets_max - targets_min)

尝试改变你的学习率并让它运行多个 epoch。

lr = 1e-2
for epochs in range(100):
    preds = model(x)
    loss = mse(preds, y)
    loss.backward()
    with torch.no_grad():
        w -= lr*w.grad
        b -= lr*b.grad
        w.grad.zero_()
        b.grad.zero_()

我对@9​​87654346@ 使用(1, 2) 随机初始化的矩阵（对b 使用(1,) 矩阵）：

w = torch.rand(1, 2)
w.requires_grad = True
b = torch.rand(1)
b.requires_grad = True

在 100 个 epoch 上得到以下火车损失：

要找到正确的超参数，最好有一个验证集。该集合将使用训练集中的 mean 和 std 进行归一化。它将用于在每个 epoch 结束时评估模型“未知”的数据的性能。你的测试集也是如此，如果你有的话。