动手从0实现 softmax 回归

动手从0实现 softmax 回归：

（1）引入相关包

1. import torch  
2. import torchvision  
3. import torchvision.transforms as transforms  
4. import numpy as np  

（2）下载并装载Fashion MNIST 数据集

1. mnist_train = torchvision.datasets.FashionMNIST(root='~/Datasets/FashionMNIST', train=True,   
2. download=False, transform=transforms.ToTensor())  
3. mnist_test = torchvision.datasets.FashionMNIST(root='~/Datasets/FashionMNIST', train=False,   
4. download=False, transform=transforms.ToTensor())  

（3）构建迭代器

1. batch_size = 256  
2. train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True)  
3. test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False) 

（4）初始化学习参数

1. #初始化学习参数  
2. num_inputs = 784  
3. num_outputs = 10  
4. w = torch.tensor(np.random.normal(0, 0.01, (num_inputs, num_outputs)), dtype=torch.float)  
5. b = torch.zeros(num_outputs, dtype=torch.float)  
6. w.requires_grad_(requires_grad=True)  
7. b.requires_grad_(requires_grad=True) 

（5）定义相关函数

1. #定义Softmax决策函数  
2. def softmax(x,w,b):  
3.     y = torch.mm(x.view(-1, num_inputs), w) + b  
4.     y_exp = y.exp()  
5.     y_sum = y_exp.sum(dim=1, keepdim=True)  
6.     return y_exp / y_sum  
7. #定义交叉熵损失函数  
8. def cross_entropy(y_hat, y):  
9.     #其中gather()就相当于是维度级高级的矩阵索引；并且真实值向量y中其他类别都为0所以不用考虑  
10.     return - torch.log(y_hat.gather(1, y.view(-1, 1)))  
11. #定义梯度下降优化函数  
12. def sgd(params, lr, batch_size):  
13.     for param in params:  
14.         param.data -= lr * param.grad / batch_size  
15. #定义分类准确率  
16. def accuracy(y_hat, y):  
17.     return (y_hat.argmax(dim=1) == y).float().mean().item()  
18. #模型未训练前的准确率  
19. def evaluate_accuracy(data_iter, net):  
20.     acc_sum, n = 0.0, 0  
21.     for X, y in data_iter:  
22.         acc_sum += (net(X , w ,b).argmax(dim=1) == y).float().sum().item()  
23.         n += y.shape[0]  
24.     return acc_sum / n  

（6）开始训练并计算每轮损失

1. #开始训练并计算每轮损失  
2. lr = 0.01  
3. num_epochs = 20  
4. net = softmax  
5. loss = cross_entropy  
6. for epoch in range(num_epochs):  
7.     train_l_sum, train_acc_sum, n = 0.0, 0.0, 0  
8.     for X, Y in train_iter:  
9.         l = loss(net(X, w, b), Y).sum()  
10.         l.backward()  
11.         sgd([w, b], lr, batch_size)  
12.         w.grad.data.zero_()  
13.         b.grad.data.zero_()  
14.         train_l_sum += l.item()  
15.         train_acc_sum += (net(X, w, b).argmax(dim=1) == Y).sum().item()  
16.         n += Y.shape[0]  
17.     test_acc = evaluate_accuracy(test_iter, net)  
18.     print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f'  
19.               % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))