【动手学深度学习】李沐——线性神经网络

图像分类数据集

import torch
import torchvision
from matplotlib import pyplot as plt
from torch.utils import data
from torchvision import transforms
from d2l import torch as d2l




# 在数字标签索引以及文本名称之间转换
def get_fashion_mnist_labels(labels):  #@save
    text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
                   'sandal', 'shirt', 'sneaker', 'bag', 'ankel boot']
    return [text_labels[int(i)] for i in labels]  # 将索引与标签一一对应


# 可视化样本
def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5):  #@save
    figsize = (num_cols * scale, num_rows * scale)
    _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
    axes = axes.flatten()  # 展开，方便索引
    for i, (ax, img) in enumerate(zip(axes, imgs)):
        if torch.is_tensor(img):
            ax.imshow(img.numpy())
        else:
            ax.imshow(img)
        ax.axes.get_xaxis().set_visible(False)  # 隐藏坐标轴
        ax.axes.get_yaxis().set_visible(False)
        if titles:
            ax.set_title(titles[i])
    return axes

"""
d2l.use_svg_display()  # 使用svg显示图片，清晰度更高

# 读取数据集
trans = transforms.ToTensor()
mnist_train = torchvision.datasets.FashionMNIST(root="dataset/FashionMNIST",
                                                train=True, transform=trans,
                                                download=True)
mnist_test = torchvision.datasets.FashionMNIST(root="dataset/FashionMNIST",
                                               train=False, transform=trans,
                                               download=True)
X, y = next(iter(data.DataLoader(mnist_train, batch_size=18)))
show_images(X.reshape(18, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y))
plt.show()
"""

def get_dataloader_workers():  #@save
    return 4  # 使用4个进程来读取数据

# 定义函数用于获取和读取该数据集，返回训练集和验证集的迭代器
def load_data_fashion_mnist(batch_size, resize = None):  #@save
    trans = [transforms.ToTensor()]
    if resize:  # 如果需要更改尺寸
        trans.insert(0,transforms.Resize(resize))
    trans = transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(root="dataset/FashionMNIST",
                                                    train=True, transform=trans,
                                                    download=False)
    mnist_test = torchvision.datasets.FashionMNIST(root="dataset/FashionMNIST",
                                                   train=False, transform=trans,
                                                   download=False)
    return (data.DataLoader(mnist_train,batch_size,shuffle=True,
                            num_workers=get_dataloader_workers()),
            data.DataLoader(mnist_test, batch_size, shuffle=True,
                            num_workers=get_dataloader_workers()))

softmax回归的从零开始实现

import torch
from IPython import display
from d2l import torch as d2l
from matplotlib import pyplot as plt

btach_size = 256
# 调用之间的函数获取两个迭代器
train_iter,test_iter = d2l.load_data_fashion_mnist(batch_size=btach_size)

num_inputs = 784  # 将每个28和28的图片展开成就是784，输入大小
num_outputs = 10  # 输入要预测十个类别
# 使用正态分布来初始化权重，第三个参数是为了待会要计算梯度
W = torch.normal(0,0.01, size=(num_inputs,num_outputs),requires_grad=True)
b = torch.zeros(num_outputs,requires_grad=True)

def softmax(X):
    X_exp = torch.exp(X)
    partition = X_exp.sum(1,keepdim = True)  # 求和仍然保持维度不变
    return X_exp / partition

# 定义模型
def net(X):
    return softmax(torch.matmul(X.reshape((-1,W.shape[0])),W)+b)

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

# 计算分类精度
def accuracy(y_hat,y):  #@save
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis = 1)  # 取出预测概率最大的下标
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())

# 定义一个用来计算变量累加的类
class Accumulator: #@save
    def __init__(self,n):
        self.data = [0.0] * n
    def add(self,*args):  # 不限制输入数目
        self.data = [ a + float(b) for a,b in zip(self.data,args)]
    def reset(self):
        self.data = [0.0] * len(self.data)  # 重置为0
    def __getitem__(self, idx):
        return self.data[idx]


# 评估在模型上的精度
def evaluate_accuracy(net,data_iter):  #@save
    if isinstance(net,torch.nn.Module):  # 如果是当前已有的模块
        net.eval()  # 转为评估模式，常在计算测试集精度时使用，该模式下不可以计算梯度
    metric = Accumulator(2)
    with torch.no_grad():  # 不计算精度
        for X,y in data_iter:
            metric.add(accuracy(net(X),y),y.numel())  # 第二个参数是统计tensor的个数
    return metric[0] / metric[1]

# 训练
def train_epoch_ch3(net,train_iter,loss,updater):  #@save
    # 将模型设置为训练模式
    if isinstance(net,torch.nn.Module):
        net.train()
    # 训练损失总和，训练精确度总和，样本数
    metric = Accumulator(3)
    for X,y in train_iter:
        y_hat = net(X)  # 计算网络的输出
        l = loss(y_hat,y)
        if isinstance(updater,torch.optim.Optimizer):
            # 使用内置的优化器和损失函数
            updater.zero_grad()
            l.mean().backward()
            updater.step()
        else:
            # 使用定制的优化器和损失函数
            l.sum().backward()
            updater(X.shape[0])
        metric.add(float(l.sum()),accuracy(y_hat,y),y.numel())
    return metric[0]/metric[2],metric[1]/metric[2]  # 返回训练损失和训练准确度

class Animator:  #@save
    def __init__(self,xlabel=None, ylabel = None, legend=None, xlim = None,ylim=None,xscale='linear',
                 yscale='linear',fmts=('-','m--','g-','r:'),nrows=1,ncols=1, figsize=(3.5,2.5)):
        # 增量地绘制多条线
        if legend is None:
            legend=[]
        d2l.use_svg_display()
        self.fig,self.axes = d2l.plt.subplots(nrows,ncols,figsize=figsize)  # 创建绘图窗口
        if nrows * ncols == 1:
            self.axes = [self.axes,]
        # 使用lambda函数捕获参数
        self.config_axes = lambda : d2l.set_axes(self.axes[0],xlabel,ylabel,xlim,ylim,xscale,yscale,legend)
        self.X,self.Y,self.fmts = None,None,fmts

    def add(self,x,y):
        # 向图表中添加多个数据点
        if not hasattr(y,"__len__"):  # 判断实例对象y是否包含某个属性或方法
            y = [y]
        n = len(y)
        if not hasattr(x,"__len__"):
            x = [x] * n
        if not self.X:
            self.X = [[] for _ in range(n)]
        if not self.Y:
            self.Y = [[] for _ in range(n)]
        for i,(a,b) in enumerate(zip(x,y)):
            if a is not None and b is not None:
                self.X[i].append(a)
                self.Y[i].append(b)
        self.axes[0].cla()
        for x,y,fmt in zip(self.X,self.Y,self.fmts):
            self.axes[0].plot(x,y,fmt)
        self.config_axes()
        display.display(self.fig)
        display.clear_output(wait=True)

# 实现一个训练函数，它会在训练数据集上训练模型，并每轮会在测试集上计算误差
def train_ch3(net,train_iter, test_iter, loss, num_epochs, updater):  #@sace
    animator = Animator(xlabel='epoch',xlim=[1,num_epochs],ylim = [0.3,0.9],
                        legend=['train loss','train acc','test acc'])
    for epoch in range(num_epochs):
        train_metrics = train_epoch_ch3(net,train_iter,loss,updater)  # 每一轮的已写过，返回误差和精度
        test_acc = evaluate_accuracy(net, test_iter)  # 计算在测试集上的精度
        animator.add(epoch+1, train_metrics+(test_acc,))
    train_loss, train_acc = train_metrics  # 遍历了单次数据集当前的误差和精度
    assert train_loss < 0.5, train_loss  # 如果不小于0.5就发生异常
    assert train_acc <=1 and train_acc > 0.7, train_acc
    assert test_acc <=1 and test_acc > 0.7, test_acc

lr = 0.1
def updater(batch_size):
    return d2l.sgd([W,b],lr,batch_size)

num_epochs = 10
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)  # 训练模型
plt.show()  # 在pycharm中最终使用这一句才会显示出图像

# 预测测试集
def predict_ch3(net,test_iter, n=6):  #@save
    for X,y in test_iter:
        break  # 这里只为了展示因此只取出第一份
    trues = d2l.get_fashion_mnist_labels(y)
    preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
    titles = [true + '\n' + pred for true,pred in zip(trues,preds)]  # 训练取出真实和预测标签
    d2l.show_images(X[0:n].reshape((n,28,28)),1,n,titles = titles[0:n])
    plt.show()

predict_ch3(net,test_iter)

softmax回归的简洁实现

import torch
from torch import nn
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

# 初始化模型参数
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))


def init_weight(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)  # 给tensor初始化，一般是给网络中参数weight初始化，初始化参数值符合正态分布


net.apply(init_weight)  # 将初始化权重的操作应用于该父模块和各个子模块

loss = nn.CrossEntropyLoss(reduction='none')  # 不对输出执行均值或者求和的操作

optimer = torch.optim.SGD(net.parameters(),lr = 0.01)

num_epoch = 10
d2l.train_ch3(net,train_iter,test_iter, loss, num_epoch, optimer)