Ciffa10分类（LeNet）

import torchvision as tv
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
import torch as t
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)) 
])


trainset = tv.datasets.CIFAR10(
    root="./data",
    train=True,
    download=True,
    transform=transform
)
trainloader = t.utils.data.DataLoader(
    dataset=trainset,
    batch_size=100,
    shuffle=True
)

testset = tv.datasets.CIFAR10(
    root="./data",
    train=False,
    download=True,
    transform=transform
)
testloader = t.utils.data.DataLoader(
    dataset=testset,
    batch_size=100,
    shuffle=False
)


class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1 = nn.Conv2d(3,6,5)
        self.conv2 = nn.Conv2d(6,16,5)
        self.fc1 = nn.Linear(16*5*5,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)
        
    def forward(self,x):
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))
        x = F.max_pool2d(F.relu(self.conv2(x)),2)
        x = x.view(x.size()[0], -1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        
        return x
        
net = Net()
print(net)
device = t.device("cuda")
net.to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.003,momentum=0.9)

for epoch in range(200):
    running_loss = 0.0
    for i,(inputs,labels) in enumerate(trainloader):
        inputs,labels = inputs.to(device),labels.to(device)
        inputs,labels = Variable(inputs),Variable(labels)
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        running_loss += loss.data.item()
        if (i+1) % 100 == 0:
            print(‘[Epoch:%d/%d],[Batch:%d/%d] loss: %.3f‘ % (epoch+1, 200, i+1,len(trainloader), running_loss/100))
            running_loss = 0.0
print("Finished Training!")

correct = 0
total = 0
for images,labels in testloader:
    images,labels = images.to(device),labels.to(device)
    outputs = net(Variable(images).cuda())
    _,predicted = t.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()
print("Accuracy of 10000 test images: %d %%" % (100 * correct / total))