本文主要记录分类问题的学习，以手写数字识别为例

理论

图片表示

  以经典的MNIST数据集为例，里面每一张图片都是一个28*28的灰度矩阵,矩阵中的每个值的是灰度，范围是0~1,可以用flatten方法打平之后方便处理。

                x[28,28] -> x[1,784]
```   
#### 模型构建
  这里用三个线性函数的嵌套构造线性模型（第一节中只有单一的y=wx+b足矣），绿字说明了各参数的维度（主要原因是满足矩阵计算）
![线性模型](https://e.im5i.com/2021/11/16/UnsBXf.png)    
#### loss表示  
  考虑到输出```Y```应该是一个```[0/1/.../9]```的矩阵，这里以```H3（维度是[1,d3]）```为输出的话，后面```d3```也应该是一个```0~9```的数，```label```的编码这里采用```one-hot（独热码？）```

例：1 => {0,1,0,0,0,0,0,0,0,0,0}
3 => {0,0,0,1,0,0,0,0,0,0,0}
比如 H3 得到是 [0.1, 0.8 ,…0]^T
那 loss 就可以表示为 两个矩阵之差的平方和
([0.1, 0.8, …, 0]^T - [0, 1, …, 0]^T)^2

#### 非线性因子（ReLU）  
  现实生活中的问题大多不是线性问题，不是简单的一个输入一个输出，如图的 ReLU 是一个典型的非线性处理，当输入小于一个阈值后全部统一忽略，我们可以在每一个线性函数上面都叠加一个ReLU函数
![线性模型](https://e.im5i.com/2021/11/16/UnndyF.png)  
H1 = ReLU(XW1+B1)
H2 = ReLU(H1W1+B2)
H3 = ReLU(H2W1+B3)

#### 梯度下降  
  通过求出三组，w,b的值完成预测
![线性模型](https://e.im5i.com/2021/11/16/Unnimd.png)  
#### 推理  
  对于一个新的图片，即一个新的X，我们通过上面得到的已知参数（w,b）的公式，最终会得到一个一列十行的矩阵，矩阵中的每一个值，代表着他是对应数字的概率，我们对于得到的矩阵```pred```用```argmax```函数可以输出其中最大值所在的索引号，从而可以得到他到底更接近哪个数字
### 实践  
#### 训练过程
1. 加载数据集
    ``` python
    batch_size = 512
    # 加载数据集
    train_loader = torch.utils.data.DataLoader(
        torchvision.datasets.MNIST('mnist_data', train=True, download=True,
                                transform=torchvision.transforms.Compose([
                                    torchvision.transforms.ToTensor(),
                                    #正则化把0右侧的数据使之分布在0的左右
                                    torchvision.transforms.Normalize(
                                        (0.1307,), (0.3081,))
                                ])),
        batch_size=batch_size, shuffle=True)

    test_loader = torch.utils.data.DataLoader(
        torchvision.datasets.MNIST('mnist_data/', train=False, download=True,
                                transform=torchvision.transforms.Compose([
                                    torchvision.transforms.ToTensor(),
                                    torchvision.transforms.Normalize(
                                        (0.1307,), (0.3081,))
                                ])),
        batch_size=batch_size, shuffle=False)
  1. 建立模型 
    class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()

        # wx+b
        self.fc1 = nn.Linear(28*28, 256)
        self.fc2 = nn.Linear(256, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        # x: [b, 1, 28, 28]
        # h1 = relu(w1x+b1)
        x = F.relu(self.fc1(x))
        # h2 = relu(h1w2+b2)
        x = F.relu(self.fc2(x))
        # h3 = h2w3+b3
        x = self.fc3(x)
        return x
net = Net()
  2. 训练 
    # [w1, b1, w2, b2, w3, b3]
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

train_loss = []

for epoch in range(3):
    for batch_idx, (x, y) in enumerate(train_loader):
        # x: [b, 1, 28, 28]
        # [b, 1, 28, 28] => [b, feature]
        x = x.view(x.size(0), 28*28)
        # => [b ,10]
        out = net(x)
        # [b, 10]
        y_onehot = one_hot(y)
        # loss = mse(out, y_onehot)
        loss = F.mse_loss(out, y_onehot)
        # 清零梯度
        optimizer.zero_grad()
        # 计算梯度
        loss.backward()
        # 更新梯度 w' = w - lr*grad
        optimizer.step()

        train_loss.append(loss.item())
        # if batch_idx%10 == 0:
        #     print(epoch, batch_idx, loss.item())

plot_curve(train_loss)
# we get optimal [w1, b1, w2, b2, w3, b3]
  3. 测试
    total_correct = 0
for x,y in test_loader:
    x = x.view(x.size(0), 28*28)
    out = net(x)
    # out: [b, 10] => pred: [b]
    pred = out.argmax(dim=1)
    correct = pred.eq(y).sum().float().item()
    total_correct = correct + total_correct

total_number = len(test_loader.dataset)
acc = total_correct/total_number
print('test_acc', acc)

x, y = next(iter(test_loader))
out = net(x.view(x.size(0), 28*28))
pred = out.argmax(dim=1)
plot_image(x, pred, 'test')
      下面是数字识别的结果：
    线性模型