为什么我写的这个VGG16无法收敛

如何解决为什么我写的这个VGG16无法收敛

我尝试对我的dogandcat数据集进行2类训练VGG16。数据包含2个类。但是这个网络无法收敛，我不知道为什么。代码和结构如下所示。这是一个典型的VGG16，它具有13个conv分层器和3个完整连接。损失函数是交叉熵和优化器是adama，学习率0.00015〜0.01

import torchvision
import torch
from torchvision import utils
from torchvision import transforms 
from matplotlib import pyplot as plt
from visdom import Visdom
import torch.nn.functional as F
import torch.nn as nn
import time
import torchvision
from sklearn.metrics import cohen_kappa_score
from sklearn.metrics import classification_report

class VGG16(nn.Module):
    def __init__(self,num_classes=2):
        super(VGG16,self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3,64,kernel_size=3,padding=1),nn.ReLU(inplace=True),nn.Conv2d(64,# nn.BatchNorm2d(64,affine=True),nn.MaxPool2d(kernel_size=2,stride=2),128,nn.Conv2d(128,256,nn.Conv2d(256,512,nn.Conv2d(512,)
        self.classifier = nn.Sequential(
                          nn.Linear(512 * 7 * 7,4096),nn.ReLU(True),nn.Dropout(),nn.Linear(4096,num_classes),)

    def forward(self,x):
        x = self.features(x)
        x = x.view(x.size(0),-1)
        x = self.classifier(x)
        return x
        
        
img_data = torchvision.datasets.ImageFolder(r'E:\Datasets\catanddog/',transform=transforms.Compose([
                                       transforms.Resize(256),transforms.CenterCrop(224),transforms.ToTensor(),transforms.Normalize(mean=[0.485,0.456,0.406],std=[0.229,0.224,0.225])])
                                            )
print('img_data size:',len(img_data),'\n')

train_size = int(0.08 * len(img_data))
test_size = int(0.02 * len(img_data))
valide_size = len(img_data) - train_size - test_size
train_dataset,test_dataset,valide_size = torch.utils.data.random_split(img_data,[train_size,test_size,valide_size])
print('train_dataset size:',len(train_dataset))
print('test_dataset  size:',len(test_dataset),'\n')

batch_size = 30
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,batch_size=batch_size)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,batch_size=batch_size)
print('train_loader  size:',len(train_loader))
print('test_loader  size:',len(test_loader))
##############################################################################


import time

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
net = VGG16()
net.cuda()

criterion = torch.nn.CrossEntropyLoss()

optimizer = torch.optim.Adam(net.parameters(),lr=0.00005)

num_epochs = 300

start_time =time.time()
current_time = time.strftime("%Y-%m-%dT%H:%M",time.localtime())

viz = Visdom() 
viz.line([0.],[0],win='train_loss',opts=dict(title='train_loss'))
viz.line([0.],win='Acc',opts=dict(title='Acc'))

# /0: pass/1:save
if_save = 0

test_intervel = 5


for epoch in range(num_epochs):
    for x,y in train_loader:
        x = x.cuda()
        y = y.cuda()
        optimizer.zero_grad()
        preds = net(x)
        loss = criterion(preds,y)
        loss.backward()
        optimizer.step()
 
    viz.line([loss.detach().cpu().numpy()],[epoch],update='append')
    time.sleep(0.5)
    
    if epoch % test_intervel ==0:
        test_loss = 0
        test_correct = 0
        total = 0
        for batch_num,(data,target) in enumerate(test_loader):
            data,target = data.to(device),target.to(device)
            output = net.eval()(data)
            prediction = torch.max(output,1)
            total += target.size(0)
            test_correct += np.sum(prediction[1].cpu().numpy() == target.cpu().numpy())
        print(100. * test_correct / total)
        print(loss.cpu().detach().numpy())
        ACC = 100. * test_correct / total
        viz.line([ACC],update='append')
    if if_save == 1:
        if epoch == num_epochs-1:
            print('')
            save_path = r'C:\Users\Xavier\Desktop\save_path/Alexnet.pth'
            torch.save(net.state_dict(),save_path)
        
finish_time =time.time()
print('time_comsume:',finish_time-start_time)