Computer vision 从头开始训练网络时，精确度极低

我正在尝试使用类似于ImageNet的数据集从头开始重新训练resnet50。我编写了以下训练循环：

def列车网络（历元、列车加载器、车辆加载器、优化器、网络）：
因为=time.time（）
列车加速历史=[]
val_acc_history=[]
最佳模型权重=copy.deepcopy（network.state\u dict（））
最佳精度=0.0
对于范围内的历元（历元）：
正确的列车=0
正确值=0
对于x、t列装载机：
x=x.to（设备）
t=t.to（装置）
optimizer.zero_grad（）
z=网络（x）
J=损失（z，t）
J.向后（）
optimizer.step（）
_，y=火炬最大值（z，1）
正确的\u序列+=torch.sum（y==t.data）
带火炬。无梯度（）：
network.eval（）
对于x_val，t_val in val_loader：
x_val=x_val.to（设备）
t_val=t_val.to（设备）
z_val=网络（x_val）
_，y_val=torch.max（z_val，1）
正确的_val+=torch.sum（y_val==t_val.data）
network.train（）
train\u accurity=correct\u train.float（）/len（train\u loader.dataset）
val\u accurity=correct\u val.float（）/len（val\u loader.dataset）
印刷品(
F“历元：{Epoch+1}训练精度：{（训练精度.item（）*100）：.3f}%val\u精度：{（val\u精度.item（）*100）：.3f}%”，
刷新=真）
#时间\u经过\u历元=时间。时间（）-自
#打印（{}历元所用的时间为{.0f}m{.0f}s'。格式（历元+1，经过的时间\u历元//60，经过的时间\u历元%60））
如果val\u精度>最佳精度：
最佳精度=数值精度
最佳模型权重=copy.deepcopy（network.state\u dict（））
列车加速历史附加（列车精度）
val_acc_history.append（val_精度）
打印（）
已用时间=time.time（）-自
打印（{.0f}m{.0f}s.格式的培训完成（已用时间//60，已用时间%60））
打印（'最佳验证精度：{:3f}'。格式（最佳精度*100））
网络负载状态（最佳模型权重）
返回网络、列车加速历史记录、车辆加速历史记录

但我的培训和验证准确率极低，如下所示：

>历元：1列精度：3.573%数值精度：3.481%
>历元：2列精度：3.414%数值精度：3.273%
>历元：3列精度：3.515%数值精度：4.039%
>历元：4列精度：3.567%数值精度：4.195%

通过谷歌搜索，我发现从头开始训练的准确率通常并不差（事实上，他们开始时的准确率约为40%-50%）。我发现很难理解故障可能在哪里。如果有人能帮我找出哪里出了问题，那就太好了

---

谢谢

我在没有体重检查点的情况下尝试了你的训练循环，并使用我自己的ResNet在FashionList数据集上获得了90%以上的准确率。因此，如果您使用的是一个好的丢失/优化器，我建议您查看网络架构或创建数据加载器

def train_network(epochs , train_loader , val_loader , optimizer , network):
    #since = time.time ( )
    train_acc_history = []
    val_acc_history = []
    loss = nn.CrossEntropyLoss()

    #best_model_weights = copy.deepcopy (network.state_dict ( ))
    #best_accuracy = 0.0

    for epoch in range (epochs):
        correct_train = 0
        correct_val = 0
        network.train ( )
        for x , t in train_loader:
            x = x.to (device)
            t = t.to (device)
            optimizer.zero_grad ( )
            z = network (x)
            J = loss (z , t)
            J.backward ( )
            optimizer.step ( )
            _ , y = torch.max (z , 1)
            correct_train += torch.sum (y == t.data)

        with torch.no_grad ( ):
            network.eval ( )
            for x_val , t_val in val_loader:
                x_val = x_val.to (device)
                t_val = t_val.to (device)
                z_val = network (x_val)
                _ , y_val = torch.max (z_val , 1)
                correct_val += torch.sum (y_val == t_val.data)

        network.train ( )
        train_accuracy = correct_train.float ( ) / len (train_loader.dataset)
        val_accuracy = correct_val.float ( ) / len (val_loader.dataset)
        print (
            F"Epoch: {epoch + 1} train_accuracy: {(train_accuracy.item ( ) * 100):.3f}% val_accuracy: {(val_accuracy.item ( ) * 100):.3f}%" ,
            flush = True)
    '''
        if val_accuracy > best_accuracy:
            best_accuracy = val_accuracy
            best_model_weights = copy.deepcopy (network.state_dict ( ))
        train_acc_history.append (train_accuracy)
        val_acc_history.append (val_accuracy)


    #time_elapsed = time.time ( ) - since
    #print ('Training complete in {:.0f}m {:.0f}s'.format (time_elapsed // 60 , time_elapsed % 60))
    print ('Best Validation Accuracy: {:3f}'.format (best_accuracy * 100))

    #network.load_state_dict (best_model_weights)
    '''
    return network , train_acc_history , val_acc_history

optimizer = optim.Adam(net.parameters(), lr = 0.01)
train_network(10,trainloader, testloader, optimizer, net)

---

因此，如果您使用我使用的训练循环（您使用的是小型mods）进行了测试，但仍然不起作用，我会检查数据加载程序并尝试使用网络体系结构。

这有一个清单，可以帮助您进行调试。感谢您的回复。我发现这个模型一开始在我的数据集上的精确度很低，但经过几个时代之后，最终获得了很好的精确度。我使用了pretrained=False，所以我认为不同的权重初始化和不同的数据集具有不同的精度。我也用不同的数据集尝试了这个循环，从第一个历元就获得了很好的精度。

Epoch: 1 train_accuracy: 83.703% val_accuracy: 86.820%
Epoch: 2 train_accuracy: 88.893% val_accuracy: 89.400%
Epoch: 3 train_accuracy: 90.297% val_accuracy: 89.700%
Epoch: 4 train_accuracy: 91.272% val_accuracy: 90.640%
Epoch: 5 train_accuracy: 91.948% val_accuracy: 91.250%
...