1
    1
    1
    1

    1. import torch
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4. import torch.optim as optim
    6. class Net(nn.Module):
    7.     def __init__(self):
    8.         super(Net, self).__init__()
    9.         # 输入图像channel: 1; 输出channel: 6; 5*5卷积核     # 计算公式 W - d + 1
    10.         self.conv1 = nn.Conv2d(1, 6, 5)     # Conv2d 接收4个参数, (batch_size, channel, height, width)
    11.         self.conv2 = nn.Conv2d(6, 16, 5)
    12.         # 线性映射关系: y = Wx + b
    13.         self.fc1 = nn.Linear(16*5*5, 120)
    14.         self.fc2 = nn.Linear(120, 84)
    15.         self.fc3 = nn.Linear(84, 10)
    17.     # backward 函数在使用 autograd 时自动定义
    18.     def forward(self, x):
    19.         # 2*2 pooling
    20.         x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))   # pool 的默认 stride 为池化矩阵的宽度   # 32 -> 28 -> 14
    21.         # pool方阵可以用一个数指定大小
    22.         x = F.max_pool2d(F.relu(self.conv2(x)), 2)    # 14 -> 10 -> 5, 16*5*5
    23.         x = x.view(-1, self.num_flat_features(x))   # 计算了x的维数之后, 展开成一维的
    24.         x = F.relu(self.fc1(x))
    25.         x = F.relu(self.fc2(x))
    26.         x = self.fc3(x)
    27.         return x
    29.     def num_flat_features(self, x):
    30.         size = x.size()[1:]  # 出去批处理维度的其他所有维度
    31.         num_features = 1
    32.         for s in size:
    33.             num_features *= s
    34.         return num_features
    37. net = Net()
    39. params = list(net.parameters())     # len(params) = 10
    41. input = torch.randn(1, 1, 32, 32)
    42. out = net(input)
    44. '''
    45. 损失函数
    46. '''
    47. target = torch.randn(10)
    48. target = target.view(1, -1)     # 使目标值与数据值尺寸一致
    49. criterion = nn.MSELoss()
    50. loss = criterion(out, target)
    52. '''
    53. 反向传播
    54. '''
    55. # print("conv1.bias.grad before zero\n", net.conv1.bias.grad)   # None
    56. net.zero_grad()            # 清除所有参数的梯度缓存。
    57. # print("conv1.bias.grad before backward\n", net.conv1.bias.grad)   # None
    58. loss.backward()   # 随机梯度的反向传播
    59. # print("conv1.bias.grad after backward\n", net.conv1.bias.grad)   # Tensor 1*6
    61. '''
    62. 反向传播过程
    63. input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
    64.       -> view -> linear -> relu -> linear -> relu -> linear
    65.       -> MSELoss
    66.       -> loss
    67. '''
    69. '''
    70. 更新权重
    71. weight = weight - learning_rate * gradient
    72. '''
    73. learning_rate = 0.01
    74. optimizer = optim.SGD(net.parameters(), lr=learning_rate)
    75. optimizer.zero_grad()
    76. optimizer.step()   # 更新参数
    78. # print("after update conv1's .weight---\n", params[0])   # 没变

    过程框架：
    导入数据集 —>> 编写模型 —>> 定义损失函数、优化函数 —>> 进行训练，得到损失值，进行优化，更新参数，再训练 —>> 测试 （每个epoch 训练一次、测试一次？？）

    1. import torch
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4. import torch.optim as optim
    5. import torchvision
    6. import torchvision.transforms as transforms
    7. import matplotlib.pyplot as plt
    8. import numpy as np
    10. transform = transforms.Compose(
    11.     [transforms.ToTensor(),
    12.      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])   # 均值, 标准差。使图像在(-1, 1)范围内归一化
    14. trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=False, transform=transform)
    15. trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=0)
    17. testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform)
    18. testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=0)
    20. classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    22. def imshow(img):
    23.     img = img / 2 + 0.5
    24.     npimg = img.numpy()
    25.     plt.imshow(np.transpose(npimg, (1, 2, 0)))
    26.     plt.show()
    28. class Net(nn.Module):
    29.     def __init__(self):
    30.         super(Net, self).__init__()
    31.         self.conv1 = nn.Conv2d(3, 6, 5)
    32.         self.pool = nn.MaxPool2d(2, 2)
    33.         self.conv2 = nn.Conv2d(6, 16, 5)
    34.         self.fc1 = nn.Linear(16*5*5, 120)
    35.         self.fc2 = nn.Linear(120, 84)
    36.         self.fc3 = nn.Linear(84, 10)
    38.     def forward(self, x):
    39.         x = self.pool(F.relu(self.conv1(x)))
    40.         x = self.pool(F.relu(self.conv2(x)))
    41.         x = x.view(-1, 16*5*5)
    42.         x = F.relu(self.fc1(x))
    43.         x = F.relu(self.fc2(x))
    44.         x = self.fc3(x)
    45.         return x
    47. net = Net()
    48. criterion = nn.CrossEntropyLoss()
    49. optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)    # momentum ?
    50. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    51. net.to(device)
    53. def train():
    54.     for epoch in range(4):
    55.         running_loss = 0.0
    56.         for i, data in enumerate(trainloader, 0):
    57.             inputs, labels = data
    58.             inputs, labels = inputs.to(device), labels.to(device)
    59.             optimizer.zero_grad()    # 将参数的梯度清零。
    60.                                      # 因为训练的过程通常使用mini-batch方法，所以如果不将梯度清零的话，梯度会与上一个batch的数据相关
    61.             # 前向传播 + 反向传播 + 优化
    62.             outputs = net(inputs)
    63.             loss = criterion(outputs, labels)
    64.             loss.backward()      # 通过 autograd 包，自动运算 tensor 的梯度
    65.             optimizer.step()     # 得到前一步的梯度，再通过梯度下降 更新参数(step() 执行一次优化步骤)
    67.             running_loss += loss.item()
    68.             if i % 2000 == 1999:
    69.                 print('[%d, %5d] loss: %.3f' % (epoch + 1, i+1, running_loss / 2000))
    70.                 running_loss = 0.0
    72.         correct = 0
    73.         total = 0
    74.         # 不用梯度来更新参数，提高运算性能
    75.         with torch.no_grad():
    76.             for data in testloader:
    77.                 # images.size() = [4, 3, 32, 32]; labels.size() = [4]
    78.                 images, labels = data
    79.                 images, labels = images.to(device), labels.to(device)
    80.                 outputs = net(images)
    81.                 # outputs.data 是一个4*10的tensor
    82.                 _, predicted = torch.max(outputs.data, 1)  # 获得最大值的(具体值, 下标)
    83.                 total += labels.size(0)
    84.                 # predicted 和 labels 为什么是一个四维向量?  <= batch_size = 4
    85.                 # predicted == labels 为 tensor([ True,  True, False, False], device='cuda:0')等
    86.                 correct += (predicted == labels).sum().item()  # .sum() 计算出为真的个数
    88.         print("Accuracy of the network on the 10000 test images: %d  %%" % (100 * correct / total))
    90.     print("Finished training")
    93. if __name__ == '__main__':
    94.     train()