添加第6章python代码

Author: ZhangXinNan

.gitignore

@@ -9,5 +9,7 @@ __pycache__/
 Thumbs.db
 
 
+.vscode/
+.idea/
 
-
+*.pth

pytorch-06/.gitignore

@@ -0,0 +1 @@
+data/

pytorch-06/README.md

@@ -0,0 +1,117 @@
+
+
+## 1 使用net.py
+```bash
+Accuracy of the network on the 10000 test images : 59 %
+[10,  2000] loss: 0.801
+Accuracy of the network on the 10000 test images : 61 %
+[10,  4000] loss: 0.845
+Accuracy of the network on the 10000 test images : 62 %
+[10,  6000] loss: 0.859
+Accuracy of the network on the 10000 test images : 60 %
+[10,  8000] loss: 0.876
+Accuracy of the network on the 10000 test images : 61 %
+[10, 10000] loss: 0.885
+Accuracy of the network on the 10000 test images : 61 %
+[10, 12000] loss: 0.881
+Accuracy of the network on the 10000 test images : 62 %
+Finished Training
+GroundTruth:    cat  ship  ship plane
+Accuracy of plane : 73 %
+Accuracy of   car : 78 %
+Accuracy of  bird : 47 %
+Accuracy of   cat : 47 %
+Accuracy of  deer : 55 %
+Accuracy of   dog : 52 %
+Accuracy of  frog : 74 %
+Accuracy of horse : 67 %
+Accuracy of  ship : 66 %
+Accuracy of truck : 61 %
+```
+
+
+
+## 2 使用cnn_net.py
+```bash
+[10,  2000] loss: 0.291
+Accuracy of the network on the 10000 test images : 68 %
+[10,  4000] loss: 0.321
+Accuracy of the network on the 10000 test images : 69 %
+[10,  6000] loss: 0.353
+Accuracy of the network on the 10000 test images : 68 %
+[10,  8000] loss: 0.398
+Accuracy of the network on the 10000 test images : 67 %
+[10, 10000] loss: 0.445
+Accuracy of the network on the 10000 test images : 67 %
+[10, 12000] loss: 0.438
+Accuracy of the network on the 10000 test images : 68 %
+Finished Training
+GroundTruth:    cat  ship  ship plane
+Accuracy of plane : 62 %
+Accuracy of   car : 77 %
+Accuracy of  bird : 58 %
+Accuracy of   cat : 51 %
+Accuracy of  deer : 65 %
+Accuracy of   dog : 61 %
+Accuracy of  frog : 80 %
+Accuracy of horse : 70 %
+Accuracy of  ship : 80 %
+Accuracy of truck : 80 %
+```
+
+## 3 使用net_gap.py
+```bash
+[10,  2000] loss: 1.008
+Accuracy of the network on the 10000 test images : 62 %
+[10,  4000] loss: 0.990
+Accuracy of the network on the 10000 test images : 64 %
+[10,  6000] loss: 0.993
+Accuracy of the network on the 10000 test images : 63 %
+[10,  8000] loss: 0.978
+Accuracy of the network on the 10000 test images : 64 %
+[10, 10000] loss: 0.991
+Accuracy of the network on the 10000 test images : 63 %
+[10, 12000] loss: 0.998
+Accuracy of the network on the 10000 test images : 64 %
+Finished Training
+Accuracy of plane : 76 %
+Accuracy of   car : 84 %
+Accuracy of  bird : 42 %
+Accuracy of   cat : 25 %
+Accuracy of  deer : 41 %
+Accuracy of   dog : 65 %
+Accuracy of  frog : 84 %
+Accuracy of horse : 56 %
+Accuracy of  ship : 74 %
+Accuracy of truck : 72 %
+```
+
+
+## 4 vgg.py
+```bash
+Accuracy of the network on the 10000 test images : 82 %
+[10,  2000] loss: 0.190
+Accuracy of the network on the 10000 test images : 81 %
+[10,  4000] loss: 0.201
+Accuracy of the network on the 10000 test images : 82 %
+[10,  6000] loss: 0.214
+Accuracy of the network on the 10000 test images : 82 %
+[10,  8000] loss: 0.210
+Accuracy of the network on the 10000 test images : 82 %
+[10, 10000] loss: 0.215
+Accuracy of the network on the 10000 test images : 81 %
+[10, 12000] loss: 0.229
+Accuracy of the network on the 10000 test images : 81 %
+Finished Training
+Accuracy of plane : 77 %
+Accuracy of   car : 94 %
+Accuracy of  bird : 74 %
+Accuracy of   cat : 58 %
+Accuracy of  deer : 86 %
+Accuracy of   dog : 78 %
+Accuracy of  frog : 89 %
+Accuracy of horse : 87 %
+Accuracy of  ship : 90 %
+Accuracy of truck : 87 %
+```
+

pytorch-06/cifar.py

@@ -0,0 +1,90 @@
+
+import torch.nn as nn
+
+from load_data import *
+# from net import *
+# from cnn_net import *
+from net_gap import *
+net = Net()
+# from vgg import VGG
+# net = VGG('VGG16')
+
+
+def val():
+    correct = 0
+    total = 0
+    with torch.no_grad():
+        for data in testloader:
+            images, labels = data
+            outputs = net(images)
+            _, predicted = torch.max(outputs.data, 1)
+            # print(images.size(), labels.size(), predicted.size())
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+    print('Accuracy of the network on the 10000 test images : %d %%' %(100 * correct/total))
+
+import torch.optim as optim
+
+
+def train():
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
+
+    for epoch in range(10):  # loop over the dataset multiple times
+        running_loss = 0.0
+        for i, data in enumerate(trainloader, 0):
+            # get the inputs; data is a list of [inputs, labels]
+            inputs, labels = data
+
+            # zero the parameter gradients
+            optimizer.zero_grad()
+
+            # forward + backward + optimize
+            outputs = net(inputs)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+
+            # print statistics
+            running_loss += loss.item()
+            if i % 2000 == 1999:    # print every 2000 mini-batches
+                print('[%d, %5d] loss: %.3f' %
+                    (epoch + 1, i + 1, running_loss / 2000))
+                running_loss = 0.0
+
+                val()
+    print('Finished Training')
+
+train()
+
+PATH = './cifar_net.pth'
+torch.save(net.state_dict(), PATH)
+
+
+
+
+# dataiter = iter(testloader)
+# images, labels = dataiter.next()
+
+# # print images
+# imshow(torchvision.utils.make_grid(images))
+# print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
+
+class_correct = list(0. for i in range(10))
+class_total = list(0. for i in range(10))
+with torch.no_grad():
+    for data in testloader:
+        images, labels = data
+        outputs = net(images)
+        _, predicted = torch.max(outputs, 1)
+        c = (predicted == labels).squeeze()
+        for i in range(4):
+            label = labels[i]
+            class_correct[label] += c[i].item()
+            class_total[label] += 1
+
+
+for i in range(10):
+    print('Accuracy of %5s : %2d %%' % (
+        classes[i], 100 * class_correct[i] / class_total[i]))
+

pytorch-06/cnn_net.py

@@ -0,0 +1,45 @@
+
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        self.conv1 = nn.Conv2d(3, 16, 5)
+        self.pool = nn.MaxPool2d(2, 2)
+        self.conv2 = nn.Conv2d(16, 36, 3)
+        self.fc1 = nn.Linear(1296, 128) # 1296 = 6 * 6 * 36
+        self.fc2 = nn.Linear(128, 10)
+
+    def forward(self, x):
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = x.view(-1, 36 * 6 * 6)
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        return x
+
+
+def init_weigths(net):
+    for m in net.modules():
+        if isinstance(m, nn.Conv2d):
+            nn.init.normal_(m.weight)
+            nn.init.xavier_normal_(m.weight)
+            nn.init.kaiming_normal_(m.weight)
+            nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.Linear):
+            nn.init.normal_(m.weight)
+
+
+def main():
+    net = Net()
+    print("查看网络结构：")
+    print(net)
+
+    print("查看网络前几层：")
+    print(nn.Sequential(*list(net.children()))[:4])
+
+
+if __name__ == '__main__':
+    main()

pytorch-06/load_data.py

@@ -0,0 +1,51 @@
+
+
+import torch
+import torchvision
+import torchvision.transforms as transforms
+
+transform = transforms.Compose(
+    [transforms.ToTensor(),
+     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
+
+trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
+                                        download=True, transform=transform)
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
+                                          shuffle=True, num_workers=2)
+
+testset = torchvision.datasets.CIFAR10(root='./data', train=False,
+                                       download=True, transform=transform)
+testloader = torch.utils.data.DataLoader(testset, batch_size=4,
+                                         shuffle=False, num_workers=2)
+
+classes = ('plane', 'car', 'bird', 'cat',
+           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# functions to show an image
+
+
+def imshow(img):
+    img = img / 2 + 0.5     # unnormalize
+    npimg = img.numpy()
+    plt.imshow(np.transpose(npimg, (1, 2, 0)))
+    plt.show()
+
+
+def main():
+    # get some random training images
+    dataiter = iter(trainloader)
+    images, labels = dataiter.next()
+
+    # show images
+    imshow(torchvision.utils.make_grid(images))
+    # print labels
+    print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
+
+
+
+if __name__ == '__main__':
+    main()

pytorch-06/net.py

@@ -0,0 +1,47 @@
+
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        self.conv1 = nn.Conv2d(3, 6, 5)
+        self.pool = nn.MaxPool2d(2, 2)
+        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 = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = x.view(-1, 16 * 5 * 5)
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+
+def init_weigths(net):
+    for m in net.modules():
+        if isinstance(m, nn.Conv2d):
+            nn.init.normal_(m.weight)
+            nn.init.xavier_normal_(m.weight)
+            nn.init.kaiming_normal_(m.weight)
+            nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.Linear):
+            nn.init.normal_(m.weight)
+
+
+def main():
+    net = Net()
+    print("查看网络结构：")
+    print(net)
+
+    print("查看网络前几层：")
+    print(nn.Sequential(*list(net.children()))[:4])
+
+
+if __name__ == '__main__':
+    main()