原理
模型
相比线性回归，Softmax只多一个分类的操作，即预测结果由连续值变为离散值，为了实现这样的结果，我们可以使最后一层具有多个神经元，而输入不变，其结构如图所示：
为了实现分类，我们使用一个Softmax操作，Softmax函数能够将未规范化的预测变换为非负数并且总和为1，同时让模型保持可导的性质。 为了完成这一目标，我们首先对每个未规范化的预测求幂，这样可以确保输出非负。 为了确保最终输出的概率值总和为1，我们再让每个求幂后的结果除以它们的总和。
那么对于y的结果，可以采用如下的方式表示：
由于softmax操作只改变大小的值，不改变大小次序，因此对输出使用Softmax操作后，仍然有
损失函数
在分类问题中一般使用交叉熵损失函数，这样可以更好的使模型辨别正确的label，而不是每一个label都使用同样的权重判断损失。
结果的可视化
通过构建Animator图像化类和Accumulator累加类完成数据的可视化实现。
Animator类
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, fmtsAccumulator类
class Accumulator:
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]读取数据集
为实现Softmax回归，我们首先引入相关的库并读取数据集。这里使用mnist数据集进行测试。
import tensorflow as tf
batch_size = 256
def load_data_fashion_mnist(batch_size, resize=None):
mnist_train, mnist_test = tf.keras.datasets.fashion_mnist.load_data()
process = lambda X, y: (tf.expand_dims(X, axis=3) / 255,tf.cast(y, dtype='int32'))
resize_fn = lambda X, y: (
tf.image.resize_with_pad(X, resize, resize) if resize else X, y)
return (tf.data.Dataset.from_tensor_slices(process(*mnist_train)).batch(batch_size).shuffle(len(mnist_train[0])).map(resize_fn),tf.data.Dataset.from_tensor_slices(process(*mnist_test)).batch(batch_size).map(resize_fn))
train_iter, test_iter = load_data_fashion_mnist(batch_size)初始化模型参数
首先用Sequential构建一个模型容器，然后添加一个Flatten层将28x28的输入展平，然后添加一个全连接层获得输出。
net = tf.keras.models.Sequential()
net.add(tf.keras.layers.Flatten(input_shape=(28, 28)))
weight_initializer = tf.keras.initializers.RandomNormal(mean=0.0, stddev=0.01)
net.add(tf.keras.layers.Dense(10, kernel_initializer=weight_initializer))模型训练
首先定义一个损失函数，这里使用稀疏类别交叉熵损失函数，适应标签是整数而不是独热编码的情况，然后定义训练模型，采用小批量随机梯度下降（SGD）算法进行训练。
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
trainer = tf.keras.optimizers.SGD(learning_rate=.1)
num_epochs = 10接下来定义模型的训练具体方式，对每一轮采用随机梯度下降的后向计算方式，进行具体的训练。其中train_epoch_ch3是在一轮中进行训练，train_ch3是整体的训练过程。
def train_epoch_ch3(net, train_iter, loss, updater):
metric = Accumulator(3)
for X, y in train_iter:
with tf.GradientTape() as tape:
y_hat = net(X)
if isinstance(loss, tf.keras.losses.Loss):
l = loss(y, y_hat)
else:
l = loss(y_hat, y)
if isinstance(updater, tf.keras.optimizers.Optimizer):
params = net.trainable_variables
grads = tape.gradient(l, params)
updater.apply_gradients(zip(grads, params))
else:
updater(X.shape[0], tape.gradient(l, updater.params))
l_sum = l * float(tf.size(y)) if isinstance(
loss, tf.keras.losses.Loss) else tf.reduce_sum(l)
metric.add(l_sum, accuracy(y_hat, y), tf.size(y))
return metric[0] / metric[2], metric[1] / metric[2]
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
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
assert train_acc <= 1 and train_acc > 0.7, train_acc
assert test_acc <= 1 and test_acc > 0.7, test_acc最后调用函数直接进行训练，需要注意的是，不必调用train_epoch_ch3函数，他在训练过程中是自动调用的。
train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)训练结果
在刚刚的训练过程中我们使用了animator和accumulator来可视化训练结果，因此训练结果较为直观，如图所示：
