深度学习，李沐老师的课程笔记——从零实现Softmax回归
对于深度学习，非常推荐李沐老师的课程，受益匪浅
课程视频09 Softmax 回归 + 损失函数 + 图片分类数据集【动手学深度学习v2】_哔哩哔哩_bilibili
这里对源码做一些注释，希望大家可以更好理解这里面的意思
没有基础不知道软件如何安装的可以看Python深度学习：安装Anaconda、PyTorch（GPU版）库与PyCharm_哔哩哔哩_bilibili
有基础的也可以直接看代码，来加深理解
若有差错，请与我联系探讨pwp
首先先讲讲概念
1.首先是softmax即将数据先作e的指数（即exp（x），这一步是为了防止有负数），然后进行交叉熵
2.交叉熵（cross entropy loss）：
在信息论中，交叉熵是表示两个概率分布p,q，其中p表示真实分布，q表示非真实分布，在相同的一组事件中，其中，用非真实分布q来表示某个事件发生所需要的平均比特数。从这个定义中，我们很难理解交叉熵的定义。下面举个例子来描述一下：
假设现在有一个样本集中两个概率分布p,q，其中p为真实分布，q为非真实分布。假如，按照真实分布p来衡量识别一个样本所需要的编码长度的期望为：
H(p)=
但是，如果采用错误的分布q来表示来自真实分布p的平均编码长度，则应该是：
H(p,q)=
这里的H(p,q)其实很简单，p因为是真实概率，所以只会是0或者1，然后在当p为1的时候来显示
1/q(i)有多大罢了，而我们希望q(i)这个值接近1，也就是预测的完全正确，而这个交叉熵是loss，所以用一个函数让他对1的接近程度转为对0的接近程度，这个时候ln就非常合适了，所以就成为这个样子。
import torch
from IPython import display
from d2l import torch as d2l
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
# softmax需要向量而不是张量，所以先打平为28*28的数据（原本是（1，28，28）的shape）即784的向量，输出为10个维度
num_inputs = 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)
y = torch.tensor([0, 2])
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
y_hat[[0, 1], y]
# 很厉害，这里的y_hat是我们所想的标准的（256，10）然后转变为行数即256（就是一组的数量batch），然后这个y就是一个（256，1）的一个数据
# 只标注了哪一个是正确值，所以就变成了上面的标准形势y_hat[[a, b], y]，这里就是取y_hat的第a行的y（a）列，而这个y（a）正是需要核对的概率
# 即猜测正确的概率（b同理就不写了）
def cross_entropy(y_hat, y):
return -torch.log(y_hat[range(len(y_hat)), y])
cross_entropy(y_hat, y)
# 相关函数操作均在0基础方法笔记中
# 这里的argmax返回下标，所以真实的y图片标号也得从0开始
def accuracy(y_hat, y):
"""计算预测正确的数量。"""
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())
accuracy(y_hat, y) / len(y)
def evaluate_accuracy(net, data_iter):
"""计算在指定数据集上模型的精度。"""
# 如果是torch.nn模式的话，将他转变为eval（）评估模式，就不用计算梯度了
if isinstance(net, torch.nn.Module):
net.eval()
metric = Accumulator(2)
# 这里相当与用完线性回归后，用softmax打磨成概率，然后计算正确率
for X, y in data_iter:
metric.add(accuracy(net(X), y), y.numel())
return metric[0] / metric[1]
y.numel()
class Accumulator:
"""在`n`个变量上累加。"""
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)
def __getitem__(self, idx):
return self.data[idx]
evaluate_accuracy(net, test_iter)
def train_epoch_ch3(net, train_iter, loss, updater):
"""训练模型一个迭代周期（定义见第3章）。"""
if isinstance(net, torch.nn.Module):
net.train()
metric = Accumulator(3)
for X, y in train_iter:
y_hat = net(X)
# loss在上面参数中指定
l = loss(y_hat, y)
if isinstance(updater, torch.optim.Optimizer):
updater.zero_grad()
l.backward()
updater.step()
# 这里的y.size（）.numel（）的numel是为了让size的结果torch.Size([2])转为2,可以直接改为y.numel()
# 这里的float（l）可能是因为loss算的是平均loss，而下面else下面的用的loss则是我们定义的cross_entropy（）
metric.add(
float(l) * len(y), accuracy(y_hat, y),
y.size().numel())
else:
# 这里没有清零可能是updater里面包含了，现在还没看到
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:
"""在动画中绘制数据。"""
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,]
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]
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):
"""训练模型（定义见第3章）。"""
# 先忽略这个animator
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
animator.add(epoch + 1, train_metrics + (test_acc,))
train_loss, train_acc = train_metrics
# 下面这些注释部分是在你loss过大的时候报错来提醒你的
# assert train_loss < 0.5, train_loss
# 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)0基础方法笔记：
1.range（i）
生成一个向量，从0到i，如range（2）就是生成：（0，1）
2.len（y_hat）
len在处理向量时，会将其长度写出来
len在处理张量时，会将其的第一个维度的长度写出来
3.y.numel()
返回y中元素总量
简洁实现中，注意的地方在这里写：
1.关于调用d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)后，图像没有出现loss，那是你的loss = nn.CrossEntropyLoss(reduction='none')里面没有加上reduction='none'，或者是你的loss上天了，太大了，没能达到李沐老师设定的函数图像范围
2.关于报错，找不到d2l_train_ch3这个函数的原因是，你的库太新了，要下载当时的库才行，直接运行pip install d2l==0.17.5下载即可。
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_weights(m):
if type(m) == nn.Linear:
nn.init.normal_(m.weight, std=0.01)
net.apply(init_weights);
loss = nn.CrossEntropyLoss(reduction='none')
trainer = torch.optim.SGD(net.parameters(), lr=0.1)
num_epochs = 10
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)
2737
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
