Python 如何使用批次损失计算总损失

我想训练一个神经网络，我想每100个历元检查一次它的总损耗，但我得到错误

RuntimeError:CUDA内存不足。试图在第1行分配…

，有时我会出现这个错误，但这次因为我在隐藏层中尝试了大量神经元，我认为这次这个错误可能是真的，尽管我尝试过

torch.cuda.empty_cache()
import gc
gc.collect()

建议使用哪些代码来修复我刚才提到的错误，所以我的问题不是如何解决错误，因为我这次说它可能是正确的（甚至不想知道3GB gpu容量是否已满），我只是想知道是否有其他方法来计算所有列车数据丢失？即使使用批次损失

我想问这个问题的另一种方式是如何使用批次损失计算总损失

顺便说一句，关于我的隐藏层大小的任何其他建议也是值得考虑的，因为我甚至不能过拟合我的400000个样本序列数据集

input_size = 83
skipcolumns= 3
hidden_size = 640
output_size = 12
num_epochs = 10000
batch_size = 20000
learning_rate = .001
n_total_steps=int(len(trainx)/batch_size)+1
def seperator(i,divide,p):
    return int((p[1]-p[0])/divide*i+p[0]),int((p[1]-p[0])/divide*(i+1)+p[0])
class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(NeuralNet, self).__init__()
        self.input_size = input_size
        self.lin = nn.Linear(input_size, hidden_size)
        self.relu = torch.nn.ReLU()
        self.leakyrelu =nn.LeakyReLU(negative_slope=0.01, inplace=False)
        self.l2 = nn.Linear(hidden_size, hidden_size)
        self.l3 = nn.Linear(hidden_size, hidden_size)
        self.l4 = nn.Linear(hidden_size, hidden_size)
        self.l5 = nn.Linear(hidden_size, hidden_size)
        self.l6 = nn.Linear(hidden_size, hidden_size)
        self.lout = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # out = self.relu(out)
        # out = torch.sigmoid(out)
        out = self.lin(x)
        out = self.leakyrelu(out)
        out = self.l2(out)
        out = self.leakyrelu(out)
        out = self.l3(out)
        out = self.leakyrelu(out)
        # out = self.l4(out)
        # out = self.leakyrelu(out)
        # out = self.l5(out)
        # out = self.leakyrelu(out)
        # out = self.l6(out)
        # out = self.leakyrelu(out)
        out = self.lout(out)
        
        # no activation and no softmax at the end
        return out

# Loss and optimizer
criterion = nn.MSELoss()

model = NeuralNet(input_size, hidden_size, output_size).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
tti=time.time()
for epoch in range(num_epochs):
    for btch in range(n_total_steps):
        stind,endind=seperator(btch,n_total_steps,[0,len(trainx)])
        thisx = trainx[stind:endind].to(device)
        thisy = trainy[stind:endind].to(device)
        outputs = model(thisx)
        loss = criterion(outputs , thisy)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # q(time.time()-tti)
    if keyboard.is_pressed('q'):
        x=1/0
    if epoch%10==0:
        print(time.time()-tti)
        if epoch%100==0:
            thisx = trainx.to(device)
            thisy = trainy.to(device)
            outputs = model(thisx) #1
            loss = criterion(outputs , thisy)
            print(loss.item())

---

虽然您可以尝试以下方法，但减少批量大小应该会产生理想的结果：

导入火炬
torch.cuda.empty_cache（）

要清除未使用的变量，您可以使用：

导入gc
del变量
gc.collect（）

---

您可能仍然会遇到错误，PyTorch会清除对变量使用的内存的引用，正如我提到的，尝试减少批处理大小并重新启动内核，找到一个最佳的批次大小就足够了。

不，不，不，我对培训或批次损失没有问题，但我对计算所有列车数据集的总损失有问题。因此，如何使用批次损失计算总训练数据集。