Python PyTorch循环遍历历元，然后输出所有历元的最终值

下面的代码计算MSE和MAE值，但我有一个问题，即在每个历元结束后，MAE和MSE的值没有得到store_MAE和store MSE。它似乎只使用上一个历元的值。任何关于我需要在代码中做什么来保存每个历元的值的想法，我希望这是有意义的。谢谢你的帮助

    global_step = 0
best_test_error = 10000
MAE_for_all_epochs = []
MSE_for_all_epochs = []
for epoch in range(4):
    print("Epoch %d" % epoch)
    model.train()
    for images, paths in tqdm(loader_train):
        images = images.to(device)
        targets = torch.tensor([metadata['count'][os.path.split(path)[-1]] for path in paths]) # B
        targets = targets.float().to(device)

        # forward pass:
        output = model(images) # B x 1 x 9 x 9 (analogous to a heatmap)
        preds = output.sum(dim=[1,2,3]) # predicted cell counts (vector of length B)
        
        # backward pass:
        loss = torch.mean((preds - targets)**2)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        # logging:
        count_error = torch.abs(preds - targets).mean()
        writer.add_scalar('train_loss', loss.item(), global_step=global_step)
        writer.add_scalar('train_count_error', count_error.item(), global_step=global_step)

        print("Step %d, loss=%f, count error=%f" % (global_step,loss.item(),count_error.item()))

        global_step += 1
    
    mean_test_error = 0
    model.eval()
    for images, paths in tqdm(loader_test):
        images = images.to(device)
        targets = torch.tensor([metadata['count'][os.path.split(path)[-1]] for path in paths]) # B
        targets = targets.float().to(device)

        # forward pass:
        output = model(images) # B x 1 x 9 x 9 (analogous to a heatmap)
        preds = output.sum(dim=[1,2,3]) # predicted cell counts (vector of length B)

        # logging:
        #error = torch.abs(preds - targets).sum().data
        #squared_error = ((preds - targets)*(preds - targets)).sum().data

        #runnning_mae += error
        #runnning_mse += squared_error

        loss = torch.mean((preds - targets)**2)
        count_error = torch.abs(preds - targets).mean()
        mean_test_error += count_error
        writer.add_scalar('test_loss', loss.item(), global_step=global_step)
        writer.add_scalar('test_count_error', count_error.item(), global_step=global_step)
        
        global_step += 1
        #store_MAE = 0
        #store_MSE = 0

        mean_test_error = mean_test_error / len(loader_test)
        #store_MAE += mean_test_error
        MAE_for_all_epochs = np.append(MAE_for_all_epochs, mean_test_error)

        mse = math.sqrt(loss / len(loader_test))
        #store_MSE +=mse
        MSE_for_all_epochs = np.append(MSE_for_all_epochs, mse)

        print("Test count error: %f" % mean_test_error)
        print("MSE: %f" % mse)

    if mean_test_error < best_test_error:
        best_test_error = mean_test_error
        torch.save({'state_dict':model.state_dict(),
                    'optimizer_state_dict':optimizer.state_dict(),
                    'globalStep':global_step,
                    'train_paths':dataset_train.files,
                    'test_paths':dataset_test.files},checkpoint_path)

print("MAE Total: %f" % store_MAE)
print("MSE Total: %f" % store_MSE)
model_mae= MAE_for_all_epochs / epoch
model_mse= MSE_for_all_epochs / epoch
print("Model MAE: %f" % model_mae)
print("Model MSE: %f" % model_mse)

global\u步骤=0
最佳测试错误=10000
MAE_代表所有时代=[]
所有时代的MSE\u=[]
对于范围（4）中的历元：
打印（“纪元%d”%Epoch）
模型列车（）
对于图像，TQM（装载机列车）中的路径：
images=images.to（设备）
targets=torch.tensor（[metadata['count'][os.path.split（path）[-1]]表示路径中的路径]）#B
targets=targets.float（）.to（设备）
#向前传球：
输出=模型（图像）#B x 1 x 9 x 9（类似于热图）
preds=output.sum（dim=[1,2,3]）#预测的单元计数（长度为B的向量）
#向后传球：
损失=火炬平均值（（preds-目标）**2）
optimizer.zero_grad（）
loss.backward（）
optimizer.step（）
#日志记录：
count_error=torch.abs（preds-targets）.mean（）
writer.add\u scalar（'train\u loss'，loss.item（），global\u step=global\u step）
writer.add\u scalar（'train\u count\u error'，count\u error.item（），global\u step=global\u step）
打印（“步骤%d，丢失=%f，计数错误=%f”%（全局步骤，丢失.item（），计数错误.item（））
全局步数+=1
平均测试误差=0
model.eval（）
对于图像，TQM中的路径（加载程序测试）：
images=images.to（设备）
targets=torch.tensor（[metadata['count'][os.path.split（path）[-1]]表示路径中的路径]）#B
targets=targets.float（）.to（设备）
#向前传球：
输出=模型（图像）#B x 1 x 9 x 9（类似于热图）
preds=output.sum（dim=[1,2,3]）#预测的单元计数（长度为B的向量）
#日志记录：
#错误=torch.abs（preds-targets）.sum（）数据
#平方误差=（（preds-目标）*（preds-目标））.sum（）.data
#Running_mae+=错误
#RUNNING_mse+=平方误差
损失=火炬平均值（（preds-目标）**2）
count_error=torch.abs（preds-targets）.mean（）
平均测试误差+=计数误差
writer.add\u scalar（'test\u loss'，loss.item（），global\u step=global\u step）
writer.add\u scalar（'test\u count\u error'，count\u error.item（），global\u step=global\u step）
全局步数+=1
#store_MAE=0
#存储_MSE=0
平均测试误差=平均测试误差/透镜（装载机测试）
#存储平均误差=平均测试误差
所有历元的平均误差=np.append（所有历元的平均误差，平均误差）
mse=数学sqrt（损失/长度（装载机测试））
#存储_MSE+=MSE
MSE_for_all_epoch=np.append（MSE_for_all_epoch，MSE）
打印（“测试计数错误：%f”%mean\u Test\u error）
打印（“MSE:%f”%MSE）
如果平均测试误差<最佳测试误差：
最佳检验误差=平均检验误差
torch.save（{'state_dict'：model.state_dict（），
“optimizer\u state\u dict”：optimizer.state\u dict（），
“全局步骤”：全局步骤，
“train\u路径”：dataset\u train.files，
“测试路径”：数据集\u test.files}，检查点\u路径）
打印（“MAE总计：%f”%store\u MAE）
打印（“MSE总计：%f”%store\u MSE）
模型_mae=所有时代的mae_/时代
模型_mse=所有历元/历元的均方误差
打印（“型号MAE:%f”%Model\u MAE）
打印（“型号MSE:%f”%Model\u MSE）

np.append（）

将适用于您这样的情况

#outside epochs loop
MAE_for_all_epochs = [] 

#inside loop
#replace this store_MAE with relevant variable

MAE_for_all_epochs = np.append(MAE_for_all_epochs, store_MAE) 

编辑：玩具示例：根据使用情况

import numpy as np
all_var = []

for e in range(1, 10):
    var1 = np.random.random(1)
    all_var = np.append(all_var, var1)
    
print(all_var)
# output : [0.07660848 0.46824825 0.09432051 0.79462902 0.97798061 0.67299183 0.50996432 0.13084029 0.95100381]

---

我已经用你的答案更新了我的代码，但是我收到了一条回溯信息：回溯（最近的一次调用）：文件“train3_Eval.py”，第160行，MAE_for_all_epochs=np。追加（MAE_for_all_epochs，mean_test_error）文件“，第6行，在附录中，您的变量mean_test_error是pytorch变量，而不是numpy。使用

numpy（）

函数将张量转换为numpy作为

mean\u test\u error.numpy（）

将很好地显示以下错误消息：回溯（最后一次调用）：文件“train3\u Eval.py”，第177行，正在打印（“MAE总计：%f”%MAE\u for\u all\u历代）类型错误：必须是实数，而不是列表简单使用

打印（MAE_代表所有历元）

它会打印列表谢谢。这会打印一个张量列表。我想能够将这些数字相加，然后乘以历元数。如何将列表转换为一个数字，即所有数字的总和，谢谢你的帮助