pytorch李沐动手学深度学习（二.MLP和NN）

---

一、线性神经网络

读取数据集

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    # 这些样本是随机读取的，没有特定的顺序
    random.shuffle(indices)
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(
            indices[i: min(i + batch_size, num_examples)])
        yield features[batch_indices], labels[batch_indices]

定义模型块

def linreg(X, w, b):  #@save
    """线性回归模型"""
    return torch.matmul(X, w) + b
def squared_loss(y_hat, y):  #@save
    """均方损失"""
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2
def sgd(params, lr, batch_size):  #@save
    """小批量随机梯度下降"""
    with torch.no_grad():#里面不求梯度
        for param in params:
            param -= lr * param.grad / batch_size
            param.grad.zero_()

训练

lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss

for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y)  # X和y的小批量损失
        # 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起，
        # 并以此计算关于[w,b]的梯度
        l.sum().backward()
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
    with torch.no_grad():
        train_l = loss(net(features, w, b), labels)
        print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')
#求loss，反向传播，梯度下降算一个批度，一个epoch完了之后输出一个loss

二、线性回归的简洁实现

def load_array(data_arrays,batch_size,is_train=True):
    dataset=data.TensorDataset(*data_arrays)#打包数据
    return data.DataLoader(dataset,batch_size,shuffle=is_train)#分批输出去数据
net=nn.Sequential(nn.Linear(2,1))
net[0].weight.data.normal_(0,0.01)
net[0].bias.fill_(0)
loss=nn.MSELoss()
trainer=torch.optim.SGD(nn.parameter(),lr=0.03)
for epoch in range(num_epochs):
    for X,y in data_iter:
        l=loss(net(X),y)
        trainer.zero_grad()
        l.backward()
        trainer.step()
    l=loss(net(features),labels)
'''
训练步骤
1.loss
2.optim梯度清零
3.反向传播
4.optim更新参数
'''

三、图像分类数据集

d2l相关库

d2l.show_images(imgs, num_rows, num_cols, titles=None, scale=1.5)
d2l.get_dataloader_workers()#读取四个进程
d2l.load_data_fashion_mnist(batch_size, resize=None)

torchvision.transforms.Compose()类。这个类的主要作用是串联多个图片变换
insert() 函数用于将指定对象插入列表的指定位置。
trans.insert(0, transforms.Resize(resize))#在0位置插入 transforms.Resize(resize)

读取图像

import torchvision
from torch.utils import data
from torchvision import transforms
# 通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式，
# 并除以255使得所有像素的数值均在0到1之间
trans = transforms.ToTensor()
mnist_train = torchvision.datasets.FashionMNIST(
    root="../data", train=True, transform=trans, download=True)
mnist_test = torchvision.datasets.FashionMNIST(
root="../data", train=False, transform=trans, download=True)
show_images(X.reshape(18, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y))

sofemax

d2l.accuracy(y_hat, y)#计算正确数
net.eval() # 将模型设置为评估模式
d2l.evaluate_accuracy(net, data_iter)# 计算在指定数据集上模型的精度
#add() 方法向集合添加元素。
# PyTorch不会隐式地调整输入的形状。因此，
# 我们在线性层前定义了展平层（flatten），来调整网络输入的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights)#权重应用上去
loss = nn.CrossEntropyLoss(reduction='none')#reduction一般选sum mean
trainer = torch.optim.SGD(net.parameters(), lr=0.1)

多层感知机

W1 = nn.Parameter(torch.randn(
num_inputs, num_hiddens, requires_grad=True) * 0.01)
#将一个固定不可训练的tensor转换成可以训练的类型parameter

for param in net.parameters():
        param.data.normal_()

net = nn.Sequential(nn.Flatten(),
                    nn.Linear(784, 256),
                    nn.ReLU(),
                    nn.Linear(256, 10))
def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)
net.apply(init_weights)
animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',xlim=[5, num_epochs], legend=['train', 'test'])

Dropout

def dropout_layer(X, dropout):
    assert 0 <= dropout <= 1
    # 在本情况中，所有元素都被丢弃
    if dropout == 1:
        return torch.zeros_like(X)
    # 在本情况中，所有元素都被保留
    if dropout == 0:
        return X
    mask = (torch.rand(X.shape) > dropout).float()
return mask * X / (1.0 - dropout)

Dropout（简洁）

net = nn.Sequential(nn.Flatten(),
        nn.Linear(784, 256),
        nn.ReLU(),
        # 在第一个全连接层之后添加一个dropout层
        nn.Dropout(dropout1),
        nn.Linear(256, 256),
        nn.ReLU(),
        # 在第二个全连接层之后添加一个dropout层
        nn.Dropout(dropout2),
        nn.Linear(256, 10))
def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights)

---