Pytorch模型实例-MNIST dataset

  • A+
所属分类:深度学习
摘要这里给出一个使用动态改变网络结构的例子,来实现在MNIST dataset中的分类实验。这个目的是为了之后可以帮助我们测试dropout,BN等的性能。

文章目录(Table of Contents)

介绍

由于最近经常会调试网络的不同参数,不同结构对结果的不同,于是就想有一个比较方便修改的范例,于是想使用MNIST dataset实现一个分类,之后在测试dropout, Batch Normal等性能的之后,方便自己的直接修改。

下面就把详细的代码贴在这里。

详细代码

详细的注释写在了上面,代码的主体是根据feedforward_neural_network修改得到的。

  1. # 参考资料 : https://discuss.pytorch.org/t/dynamically-add-or-delete-layers/10447
  2. import torch
  3. import torch.nn as nn
  4. import torchvision
  5. import torchvision.transforms as transforms
  6. # Device configuration
  7. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  8. # Hyper-parameters 
  9. input_size = 784
  10. hidden_size = 500
  11. num_classes = 10
  12. n_layers = 2
  13. num_epochs = 5
  14. batch_size = 100
  15. learning_rate = 0.001
  16. # MNIST dataset
  17. train_dataset = torchvision.datasets.MNIST(root='./data',
  18.                                            train=True,
  19.                                            transform=transforms.ToTensor(),
  20.                                            download=True)
  21. test_dataset = torchvision.datasets.MNIST(root='./data',
  22.                                           train=False,
  23.                                           transform=transforms.ToTensor())
  24. # Data loader
  25. train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
  26.                                            batch_size=batch_size,
  27.                                            shuffle=True)
  28. test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
  29.                                           batch_size=batch_size,
  30.                                           shuffle=False)
  31. # Fully connected neural network with one hidden layer
  32. class NeuralNet(nn.Module):
  33.     def __init__(self, input_size, hidden_size, num_classes, n_layers):
  34.         super(NeuralNet, self).__init__()
  35.         layers = []
  36.         for i in range(n_layers):
  37.             layers.append(nn.Linear(hidden_size, hidden_size))
  38.             layers.append(nn.ReLU())
  39.             layers.append(nn.BatchNorm1d(hidden_size))
  40.             # layers.append(nn.Dropout(0.5))
  41.         self.inLayer = nn.Linear(input_size, hidden_size)
  42.         self.relu = nn.ReLU()
  43.         self.hiddenLayer = nn.Sequential(*layers)
  44.         self.outLayer = nn.Linear(hidden_size, num_classes)
  45.         self.softmax = nn.Softmax(dim=1)
  46.     def forward(self, x):
  47.         out = self.inLayer(x)
  48.         out = self.relu(out)
  49.         out = self.hiddenLayer(out)
  50.         out = self.outLayer(out)
  51.         out = self.softmax(out)
  52.         return out
  53. model = NeuralNet(input_size, hidden_size, num_classes, n_layers).to(device)
  54. # 打印模型结构
  55. print(model)
  56. # Loss and optimizer
  57. criterion = nn.CrossEntropyLoss()
  58. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
  59. # Train the model
  60. model.train()
  61. total_step = len(train_loader)
  62. for epoch in range(num_epochs):
  63.     for i, (images, labels) in enumerate(train_loader):
  64.         # Move tensors to the configured device
  65.         images = images.reshape(-1, 28*28).to(device)
  66.         labels = labels.to(device)
  67.         # Forward pass
  68.         outputs = model(images)
  69.         loss = criterion(outputs, labels)
  70.         # Backward and optimize
  71.         optimizer.zero_grad()
  72.         loss.backward()
  73.         optimizer.step()
  74.         if (i+1) % 100 == 0:
  75.             # 计算每个batch的准确率
  76.             correct = 0
  77.             total = 0
  78.             _, predicted = torch.max(outputs.data, 1)
  79.             total += labels.size(0)
  80.             correct += (predicted == labels).sum().item()
  81.             acc = 100*correct/total
  82.             # 打印结果
  83.             print ('Epoch [{}/{}], Step [{}/{}], Accuracy: {}, Loss: {:.4f}'
  84.                    .format(epoch+1, num_epochs, i+1, total_step, acc, loss.item()))
  85. # Test the model
  86. # In test phase, we don't need to compute gradients (for memory efficiency)
  87. model.eval()
  88. with torch.no_grad():
  89.     correct = 0
  90.     total = 0
  91.     for images, labels in test_loader:
  92.         images = images.reshape(-1, 28*28).to(device)
  93.         labels = labels.to(device)
  94.         outputs = model(images)
  95.         _, predicted = torch.max(outputs.data, 1)
  96.         total += labels.size(0)
  97.         correct += (predicted == labels).sum().item()
  98.     print('Accuracy of the network on the 10000 test images: {} %'.format(100 * correct / total))
  99. # Save the model checkpoint
  100. # torch.save(model.state_dict(), 'model.ckpt')

我们可以通过调整n_layers很方便的调整网络hidden layer的层数,便于之后自己的测试。

详细代码

关于详细的代码,可以查看如下地址:Dynamically_add_or_delete_layers

  • 微信公众号
  • 关注微信公众号
  • weinxin
  • QQ群
  • 我们的QQ群号
  • weinxin
王 茂南

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: