18.train

训练的大致步骤可以分为：

dataset下载数据集

dataloader加载数据集

创建神经网络

定义损失函数和损失函数及其参数

创建tensorboard

设置一些训练使用的参数

开始训练：[训练],[验证]，保存训练后的模型

训练时，包含：[][][计算损失], [梯度清零], [反向传播], [参数更新]

验证时，我们需要计算正确率。

  1.         for data in test_dataloader:
  2.             imgs,targets = data
  3.             output = demo(imgs)
  4.             loss = loss_fn(output, targets)
  5.             total_test_loss = total_test_loss + loss
  6.             pre = output.argmax(1)
  7.             acc = ((pre == targets).sum())
  8.             total_acc = total_acc + acc
  9.     print("total_test_loss = {}".format(total_test_loss))
  10.     print("total_acc = {}".format(total_acc))
  11.     writer.add_scalar("test_loss",total_test_loss,i)
  12.     writer.add_scalar("total_acc",total_acc,i)

每次for循环都有64个图片被使用

output = [0.1, 0.2, 0.3, 0.4 ,0.5, 0.6, 0.7, 0.8, 0.9, 0.1]

  1.             ……共64个
  3.             [0.1, 0.2, 0.3, 0.4 ,0.5, 0.6, 0.7, 0.8, 0.9, 0.1]
  5.             每位及代表类别class 0 - 9 类

targets = [1]

  1.              ……共64个
  3.              [3]

使用argmax将output变为和targets一样的形式作对比

output.argmax(1) = [9]

  1.                                 ……共64个
  3.                                 [9]

(output.argmax(1) == targets) = (F,F,T……F,T) = (0,0,1….,0,1) 相等为T 不等为F,共64个

(output.argmax(1) == targets).sum() = 将 (0,0,1….,0,1)中元素相加，即等于当前batch_size中判断正确的数量，每次for循环累加一次，跑完整个数据集后可以算出当前epoch验证出的精确度。

argmax(1) >>tensor([1,1])

argmax(0) >>tensor([1,1])

  1. # argmax and accuracy
  2. import torch
  4. outputs = torch.tensor([[0.1,0.2],
  5.                         [0.3,0.4]])
  7. print(outputs.argmax(1))
  8. pre = outputs.argmax(1)
  9. targets = torch.tensor([0,1])
  11. print(pre == targets)
  12. print((pre == targets).sum())
  14. # whne input = 2 , output = 2
  15. # accuracy = ((pre = targets).sum()) / 2

code：

  1. import torch
  2. import torchvision
  3. from torch.utils.data import DataLoader
  4. from torch.utils.tensorboard import SummaryWriter
  6. from models import *
  8. # 准备数据集
  9. train_data = torchvision.datasets.CIFAR10(root="./dataset",train=True,transform=torchvision.transforms.ToTensor(),
  10.                                           download=True)
  11. test_data = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=torchvision.transforms.ToTensor(),
  12.                                           download=True)
  14. train_data_size = len(train_data)
  15. test_data_size = len(test_data)
  16. print("训练数据长度为：{}".format(train_data_size))
  17. print("测试数据长度为：{}".format(test_data_size))
  19. # 加载数据集
  20. train_dataloader = DataLoader(train_data,batch_size=64)
  21. test_dataloader = DataLoader(test_data,batch_size=64)
  23. # 创建神经网络
  24. demo = DEMO()
  26. # 定义损失函数
  27. loss_fn = nn.CrossEntropyLoss()
  29. # 定义优化器
  30. #learing_rate = 1e-2 = 1 × (10) ^ (-2)
  31. learning_rate = 0.01
  32. optimizer = torch.optim.SGD(demo.parameters(),lr=learning_rate)
  34. # tensorboard
  35. writer = SummaryWriter("./train_logs")
  37. # 训练
  38. # 设置一些参数
  39. total_train_step = 0
  40. total_test_step = 0
  41. epoch = 5
  44. for i in range(epoch):
  45.     print("--------------epoch:{}----------------".format(i+1))
  46.     # 训练
  47.     demo.train() # 在使用一些特殊层时要调用，不适用时也可以调用，实践中很常用 同 demo.eval()
  48.     for data in train_dataloader:
  49.         imgs, targets = data
  50.         output = demo(imgs)
  51.         loss = loss_fn(output,targets)
  53.         optimizer.zero_grad()
  54.         loss.backward()
  55.         optimizer.step()
  56.         total_train_step += 1
  57.         if total_train_step % 100 == 0:
  58.             print("训练次数：{}，train_Loss = {}".format(total_train_step,loss.item()))
  59.             writer.add_scalar("train_loss",loss.item(),total_train_step)
  61.     # 验证
  62.     demo.eval()
  63.     total_test_loss = 0
  64.     # 梯度为零，不优化参数
  65.     total_acc = 0
  66.     with torch.no_grad():
  67.         for data in test_dataloader:
  68.             imgs,targets = data
  69.             output = demo(imgs)
  70.             loss = loss_fn(output, targets)
  71.             total_test_loss = total_test_loss + loss
  72.             pre = output.argmax(1)
  73.             acc = ((pre == targets).sum())
  74.             total_acc = total_acc + acc
  75.     accuracy = total_acc / test_data_size
  76.     print("total_test_loss = {}".format(total_test_loss))
  77.     print("total_acc = {}".format(accuracy))
  78.     writer.add_scalar("test_loss",total_test_loss,i+1)
  79.     writer.add_scalar("accuracy",accuracy,i+1)
  81.     torch.save(demo,"pretrained_demo_{}.pth".format(i+1))
  82.     print("pretrained_demo已保存")
  84. writer.close()