python - Pytorch 中的批量学习是如何进行的？

Question

当您查看网络架构在 pytorch 代码中是如何构建的时，我们需要扩展 torch.nn.Module 并在 __init__ 中，我们定义了模块networks 和 pytorch 将跟踪这些模块的参数梯度。然后在 forward 函数中，我们定义了如何为我们的网络完成前向传播。

我在这里不明白的是批量学习将如何发生。在上面的定义中，包括 forward 函数，我们都不关心网络输入的批处理维度。我们唯一需要设置以执行批量学习的是为输入添加一个额外的维度，该维度对应于批量大小，但如果我们使用批量学习，网络定义中的任何内容都不会改变。至少，这是我在代码中看到的 here .

因此，如果到目前为止我所解释的所有事情都是正确的(如果您让我知道我是否误解了什么，我将不胜感激)，如果在我们的网络类(继承torch.nn.Module的类)？具体来说，我很想知道当我们只将 nn.MSELoss 设置为批量维度时，批量梯度下降算法是如何在 pytorch 中实现的。

Answer 1

检查这个:

import torch
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super().__init__()         

    def forward(self, x):
        print("Hi ma")        
        print(x)
        x = F.relu(x)
        return x

n = Net()
r = n(torch.tensor(-1))
print(r)
r = n.forward(torch.tensor(1)) #not planned to call directly
print(r)

输出:

Hi ma
tensor(-1)
tensor(0)
Hi ma
tensor(1)
tensor(1)

要记住的是 forward 不应该被直接调用。PyTorch 使此模块对象 n 可调用。他们实现了可调用，例如:

 def __call__(self, *input, **kwargs):
    for hook in self._forward_pre_hooks.values():
        hook(self, input)
    if torch._C._get_tracing_state():
        result = self._slow_forward(*input, **kwargs)
    else:
        result = self.forward(*input, **kwargs)
    for hook in self._forward_hooks.values():
        hook_result = hook(self, input, result)
        if hook_result is not None:
            raise RuntimeError(
                "forward hooks should never return any values, but '{}'"
                "didn't return None".format(hook))
    if len(self._backward_hooks) > 0:
        var = result
        while not isinstance(var, torch.Tensor):
            if isinstance(var, dict):
                var = next((v for v in var.values() if isinstance(v, torch.Tensor)))
            else:
                var = var[0]
        grad_fn = var.grad_fn
        if grad_fn is not None:
            for hook in self._backward_hooks.values():
                wrapper = functools.partial(hook, self)
                functools.update_wrapper(wrapper, hook)
                grad_fn.register_hook(wrapper)
    return result

只有 n() 会自动调用 forward。

通常，__init__ 定义模块结构，forward() 定义单个批处理的操作。

如果某些结构元素需要，该操作可能会重复，或者您可以像我们x = F.relu(x) 那样直接在张量上调用函数。

你做得很好，PyTorch 中的所有内容都将分批(小批量)执行，因为 PyTorch 针对这种方式进行了优化。

这意味着当您读取图像时，您将不会读取单个图像，而是读取 bs 批图像。