1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
| import torch from torchvision import transforms from torchvision import datasets from torch.utils.data import DataLoader import torch.nn.functional as F import torch.optim as optim
batch_size = 64
transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ),(0.3081, )) ])
train_dataset = datasets.MNIST(root='./dataset/mnist/',train=True,download=True,transform=transform) train_loader = DataLoader(train_dataset,shuffle=True,batch_size=batch_size)
test_dataset = datasets.MNIST(root='./dataset/mnist/',train=False,download=True,transform=transform) test_loader = DataLoader(test_dataset,shuffle=False,batch_size=batch_size)
class ResidualBlock(torch.nn.Module): def __init__(self,channels): super(ResidualBlock,self).__init__() self.channels = channels self.conv1 = torch.nn.Conv2d(channels,channels,kernel_size=3,padding=1) self.conv2 = torch.nn.Conv2d(channels,channels,kernel_size=3,padding=1) def forward(self,x): y = F.relu(self.conv1(x)) y = self.conv2(y) return F.relu(x + y)
class ResNet(torch.nn.Module): def __init__(self): super(ResNet,self).__init__() self.conv1 = torch.nn.Conv2d(1,16,kernel_size = 5) self.conv2 = torch.nn.Conv2d(16,32,kernel_size = 5) self.mp = torch.nn.MaxPool2d(2) self.rblock1 = ResidualBlock(16) self.rblock2 = ResidualBlock(32) self.fc = torch.nn.Linear(512,10) def forward(self,x): in_size = x.size(0) x = self.mp(F.relu(self.conv1(x))) x = self.rblock1(x) x = self.mp(F.relu(self.conv2(x))) x = self.rblock2(x) x = x.view(in_size,-1) return self.fc(x)
model = ResNet()
criterion = torch.nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(),lr=0.01,momentum=0.5)
e_list = [] l_list = [] running_loss = 0.0
def train(epoch): running_loss = 0.0 Loss = 0.0 for batch_idx, data in enumerate(train_loader,0): inputs, target = data optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs,target) loss.backward() optimizer.step() running_loss += loss.item() Loss += loss.item() if batch_idx % 300 == 299: print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300)) running_loss = 0.0 e_list.append(epoch) l_list.append(running_loss/300) def test(): correct = 0 total = 0 with torch.no_grad(): for data in test_loader: images, labels = data outputs = model(images) _, predicted = torch.max(outputs.data, dim=1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy on test set: %d %%' % (100 * correct / total))
if __name__ == '__main__': for epoch in range(10): train(epoch) test() import matplotlib.pyplot as plt
plt.figure(figsize=(8,5))
plt.xlabel('epoch') plt.ylabel('loss')
plt.plot(e_list,l_list,color='green')
plt.show()
|