softmax分类器训练和测式自己的数据集

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable
import torch.optim
import torch.utils.data
import torch.utils.data.distributed


# Training settings
batch_size = 20
transform = transforms.ToTensor()
torch.manual_seed(seed=2021)


dataset = datasets.ImageFolder('E:\\pythonwork\\LPDdetection\\Chinese-license-plate-recognition-system\\Train\\plate', transform)
n_dataset = len(dataset)
per = 0.9
n_train = int(n_dataset*per)
n_test = n_dataset - n_train
print("n_train ",n_train )
print("n_test ",n_test )
print(len(dataset))
train_dataset, test_dataset = torch.utils.data.random_split(
    dataset,
    [n_train, n_test],
)
# print("train_dataset",len(train_dataset))
# 对应文件夹的label
# print(train_dataset.class_to_idx)
# test_dataset = datasets.ImageFolder('E:\\pythonwork\\LPDdetection\\Chinese-license-plate-recognition-system\\Train\plate', transform)
# 对应文件夹的label

# print(test_dataset.class_to_idx)



# Data Loader (Input Pipeline)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=False)


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.l1 = nn.Linear(14688, 520)
        self.l2 = nn.Linear(520, 320)
        self.l3 = nn.Linear(320, 240)
        self.l4 = nn.Linear(240, 120)
        self.l5 = nn.Linear(120, 2)

    def forward(self, x):

        # Flatten the data (n, 1, 28, 28) --> (n, 784)
        x = x.view(-1, 14688)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return F.log_softmax(self.l5(x), dim=1)
        #return self.l5(x)

model = Net()

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

def train(epoch):
    # 每次输入barch_idx个数据
    # print("epoch",epoch)
    for batch_idx, (data, target) in enumerate(train_loader):
        # print("batch_idx",batch_idx)
        data, target = Variable(data), Variable(target)
        # print("data, target ", len(data), len(target))
        # print("data, target ", type(data), type(target))
        optimizer.zero_grad()
        output = model(data)
        # loss
        loss = F.nll_loss(output, target)
        loss.backward()
        # update
        optimizer.step()
        if batch_idx % 200 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.data))

def val():
    test_loss = 0
    correct = 0
    # 测试集
    with torch.no_grad():
        for data, target in test_loader:
            data, target = Variable(data), Variable(target)
            output = model(data)
            # sum up batch loss
            test_loss += F.nll_loss(output, target)
            # get the index of the max
            pred = output.data.max(1, keepdim=True)[1]
            correct += pred.eq(target.data.view_as(pred)).cpu().sum()

        test_loss /= len(test_loader.dataset)
        print("\ntest_loss",test_loss)
        print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            test_loss, correct, len(test_loader.dataset),
            100. * correct / len(test_loader.dataset)))

for epoch in range(1,6):
    train(epoch)
    val()