TensorFlow实现Softmax回归

原理

模型

相比线性回归，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, fmts

Accumulator类 

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来可视化训练结果，因此训练结果较为直观，如图所示：