【动手学深度】softmax回归实现

首先导入相关包

import torch
import torchvision
import numpy as np
import sys
sys.path.append("E:\ANaconda\envs\pytroch_env\Lib\site-packages")
import d2lzh_pytorch as d2l

获取数据，下载fashion_mnist数据集，每次随机抓取256个数据，分为训练集和测试集，知道抓取数达到总数。

#获取数据
batch_size=256
train_iter,test_iter=d2l.load_data_fashion_mnist(batch_size,root='-Datasets/FashionMNIST')
a=0
for x,y in test_iter:
    a+=y.shape[0]
print(a)

初始化参数模型，输入的是图片1*28*28,通道*高*宽，因为softmax接受的向量形式，所以需要将其展成向量，可能会损失少量空间信息，这里暂时不讨论，输出是分为10类。

并设置权重和偏差分别是784*10 和10*1的矩阵

#初始化参数模型
input_nums=784   #展成向量形式
out_nums=10

w=torch.normal(0,0.01,(input_nums,out_nums),requires_grad=True)
b=torch.zeros(out_nums,requires_grad=True)

先实现softmax运算，将每层的特征转换成小数，且相加为1

#实现softmax运算
def softmax(x):
    x_exp=torch.exp(x)
    partition=x_exp.sum(dim=1,keepdim=True)   #把一层相加，维度保持不变
    return x_exp/partition   #这里应用了广播机制

#定义模型
def net(x):
    return softmax(torch.matmul(x.reshape(-1,input_nums),w)+b)

 y_hat为256*10的矩阵，谁的概率最大，及预测其为那一类

定义损失函数,用来优化w，b。

#定义损失函数
def cross_entropy(y_hat,y):
   return -torch.log(y_hat[range(len(y_hat)),y])
   # return -torch.log(y_hat.gather(1,y.view(-1,1)))

正确类别预测的概率 

 计算预测精度，如果预测正确返回1，失败返回0。y_hat

#评价net在数据集data_iter上的准确率
def evaluate_accuracy(data_iter,net):
    acc_sum,n=0.0,0
    for x,y in data_iter:
        acc_sum+=(net(x).argmax(dim=1)==y).float().sum().item()    #预测正确为1，否则为0
        n+=y.shape[0]           #每次抓256个
    return acc_sum/n

print(evaluate_accuracy(test_iter,net))       

定义好所有内容开始训练模型

'''训练模型'''
num_epochs,lr=5,0.1
def train_ch3(net,train_iter,test_iter,loss,num_epochs,batch_size,params=None,lr=None,optimizer=None):
    for epoch in range(num_epochs):
        train_l_sum,train_acc_sum,n=0.0,0.0,0
        for x,y in train_iter:
            y_hat=net(x)
            l=loss(y_hat,y).sum()

            #梯度清零
            if optimizer is not None:
                optimizer.zero_grad()
            elif params is not None and params[0].grad is not None:
                for param in params:
                    param.grad.data.zero_()

            l.backward()
            if optimizer is None:
                d2l.sgd(params, lr, batch_size)  # 优化参数
            else:
                optimizer.step()

            train_l_sum += l.item()     #每次的损失函数，计算损失的大小
            train_acc_sum += (y_hat.argmax(dim=1) == y).float().sum().item()
            n += y.shape[0]
        test_acc=evaluate_accuracy(test_iter,net)
        print('epoch %d,loss %.3f,train_acc %.3f,test_acc %.3f,'
              %(epoch+1,train_l_sum/n,train_acc_sum/n,test_acc)
              )


train_ch3(net,train_iter,test_iter,cross_entropy,num_epochs,batch_size,[w,b],lr)

最后显示10张预测的结果

x,y=iter(test_iter).next()

true_labels=d2l.get_fashion_mnist_labels(y.numpy())
pred_labels=d2l.get_fashion_mnist_labels(net(x).argmax(dim=1).numpy())
titles=[true+'\n'+pred for true,pred in zip(true_labels,pred_labels)]

d2l.show_fashion_mnist(x[0:9],titles[0:9])

绝大多数的深度学习模型训练的步骤基本都是获取并读取数据、定义初始化参数、定义模型和损失函数，并使用优化算法进行模型训练。