视频：https://www.bilibili.com/video/BV1Y7411d7Ys?p=9
博客：https://blog.csdn.net/bit452/article/details/109686936

说明：
1、softmax的输入不需要再做非线性变换，也就是说softmax之前不再需要激活函数(relu)，交叉熵损失已经囊括了
softmax两个作用

  • 如果在进行softmax前的input有负数，通过指数变换，得到正数。
  • 所有类的概率求和为1。

2、y的标签编码方式是one-hot。我对one-hot的理解是只有一位是1，其他位为0
3、多分类问题，标签y的类型是LongTensor。比如说0-9分类问题，如果y = torch.LongTensor([3])，对应的one-hot是[0,0,0,1,0,0,0,0,0,0].
4、交叉熵损失CrossEntropyLoss <==> LogSoftmax + NLLLoss
两个区别
https://pytorch.org/docs/stable/nn.html#crossentropyloss
https://pytorch.org/docs/stable/nn.html#nllloss
image.png
image.png
image.png

image.png image.png

代码说明：

1、第8讲 from torch.utils.data import Dataset，第9讲 from torchvision import datasets。该datasets里面init，getitem,len魔法函数已实现。
2、torch.max的返回值有两个，第一个是每一行的最大值是多少，第二个是每一行最大值的下标(索引)是多少。
3、全连接神经网络

1 Prepare dataset

transform将PIL Image转化为Tensor

  • 通道转换： wxhxc → cxwxh
  • 单通道变成多通道

image.pngimage.png

2 Design model using Class

  • inherit from nn.Module 计算y^hat
  • 注意：最后一层，不做激活


image.png
image.png**

3 Construct loss and optimizer

  • using PyTorch API 计算loss和optimizer

image.png

4 Training cycle

loss.items
image.png
test测试 测试（不需要反向传播，主需要算正向的）
image.png

全部代码

  1. '''
  2. Description: 多分类问题(softmax)
  3. 视频：https://www.bilibili.com/video/BV1Y7411d7Ys?p=9
  4. 博客：https://blog.csdn.net/bit452/article/details/109686936
  5. Author: HCQ
  6. Company(School): UCAS
  7. Email: 1756260160@qq.com
  8. Date: 2020-12-06 20:05:38
  9. LastEditTime: 2020-12-06 21:34:51
  10. FilePath: /pytorch/PyTorch深度学习实践/09多分类问题softmax.py
  11. '''
  12. import torch
  13. from torchvision import transforms # 针对图像处理
  14. from torchvision import datasets
  15. from torch.utils.data import DataLoader
  16. import torch.nn.functional as F # 为了使用激活函数relu()
  17. import torch.optim as optim # optim.SGD
  19. # 1 prepare dataset
  21. batch_size = 64
  22. #  归一化,均值和标准差  将PIL Image转化为Tensor  # 0.1307,), (0.3081,) 分别对应均值和标准差
  23. transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]) 
  25. train_dataset = datasets.MNIST(root='./data/mnist/', train=True, download=True, transform=transform)
  26. train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
  27. test_dataset = datasets.MNIST(root='./data/mnist/', train=False, download=True, transform=transform)
  28. test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)
  30. # 2 design model using class
  33. class Net(torch.nn.Module):
  34.     def __init__(self):
  35.         super(Net, self).__init__()
  36.         self.l1 = torch.nn.Linear(784, 512)
  37.         self.l2 = torch.nn.Linear(512, 256)
  38.         self.l3 = torch.nn.Linear(256, 128)
  39.         self.l4 = torch.nn.Linear(128, 64)
  40.         self.l5 = torch.nn.Linear(64, 10)
  42.     def forward(self, x):
  43.         x = x.view(-1, 784)  # -1其实就是自动获取mini_batch，即N，mini样本数
  44.         x = F.relu(self.l1(x)) # 激活函数relu
  45.         x = F.relu(self.l2(x))
  46.         x = F.relu(self.l3(x))
  47.         x = F.relu(self.l4(x))
  48.         return self.l5(x)  # 最后一层不做激活，不进行非线性变换
  51. model = Net()
  53. # 3 construct loss and optimizer
  54. criterion = torch.nn.CrossEntropyLoss()
  55. optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
  57. # 4 training cycle forward, backward, update
  60. def train(epoch):
  61.     running_loss = 0.0
  62.     for batch_idx, data in enumerate(train_loader, 0):
  63.         inputs, target = data
  64.         optimizer.zero_grad() # 优化器清零
  66.         outputs = model(inputs) # 计算y hat
  67.         loss = criterion(outputs, target) # 计算loss
  68.         loss.backward()
  69.         optimizer.step()
  71.         running_loss += loss.item() # items()
  72.         if batch_idx % 300 == 299: # 训练300次输出一次
  73.             print('[%d, %5d] loss: %.3f' % (epoch+1, batch_idx+1, running_loss/300))
  74.             running_loss = 0.0
  76.  # 测试（不需要反向传播，主需要算正向的）
  77. def test():
  78.     correct = 0
  79.     total = 0
  80.     with torch.no_grad(): # 来阻止autograd跟踪设置了 .requires_grad=True 的张量的历史记录。
  81.         for data in test_loader: # test_loader 测试集
  82.             images, labels = data
  83.             outputs = model(images)  # torch.Size([64, 10])
  84.             _, predicted = torch.max(outputs.data, dim=1) # dim = 1 列是第0个维度，行是第1个维度  求每一行最大下标  （64，1） ||    _,对应最大值，predicted对应最大值索引
  85.             total += labels.size(0) #  labels.size(0) = N  ,   (N, 1)  
  86.             correct += (predicted == labels).sum().item() # 张量之间的比较运算  预测值和label值
  87.     print('accuracy on test set: %d %% ' % (100*correct/total))
  90. if __name__ == '__main__':
  91.     for epoch in range(10):
  92.         train(epoch)
  93.         #  if epoch % 10 == 9: # 可以设置10轮测试一次
  94.         test()

结果

image.png

97% ,没有考虑局部特征，为了更好优化
人为特征：FFT，小波
auto： CNN，RNN

Exercise 9-2: Classifier Implementation

https://www.kaggle.com/c/otto-group-product-classification-challenge/data
image.png