机器学习之分类

分类任务和回归任务的不同之处在于，分类任务需要做出离散的预测。对于多分类任务的神经网络模型，其输出目标通常会用one-hot编码来表示，在输出层中使用softmax函数，同时使用分类交叉熵损失函数进行训练。在本博客中，我们将使用TensorFlow的底层API实现一个基于全连接层的神经网络来进行MNIST数字图像分类。下面是涉及到的相关概念：

深度学习是一种机器学习方法，它通过多层神经网络层次化地提取特征，以解决各种复杂的分类和回归问题。

神经网络是深度学习的基本组成部分，由多个层次化的神经元组成。输入层接受数据，中间的隐藏层通过权重和激活函数处理数据，最终输出层产生分类结果。在这个示例中，我们将手动实现神经网络的核心组件。

前向传播是神经网络中的信息传递过程，从输入层到输出层，每一层的神经元根据权重和激活函数计算输出。这个过程将输入数据映射到预测输出。

反向传播是训练神经网络的关键步骤，它通过计算预测与真实标签之间的误差，并将误差反向传播到网络中的每一层来更新权重，以最小化误差。

内容大纲

1. 神经网络核心组件的实现
2. 数据加载处理
3. 构建训练模型
4. 总结

神经网络核心组件的实现

以下代码分别实现了密集层DenseLayer，网络模型SequentialModel，批次生成器BatchGenerator，批次权重更新one_training_step 以及 训练函数fit。

from keras.datasets import mnist
import math
import tensorflow as tf
import numpy as np

class DenseLayer:  # 简单的Dense类
    def __init__(self, input_size, output_size, activation):
        self.activation = activation

        w_shape = (input_size, output_size)  # 创建一个形状为(input_size, output_size)的矩阵W，并将其随机初始化
        w_initial_value = tf.random.uniform(w_shape, minval=0, maxval=1e-1)
        self.W = tf.Variable(w_initial_value)

        b_shape = (output_size,)  # 创建一个形状为(output_size,)的零向量b
        b_initial_value = tf.zeros(b_shape)
        self.b = tf.Variable(b_initial_value)

    def __call__(self, inputs):  # 前向传播
        return self.activation(tf.matmul(inputs, self.W) + self.b)

    @property
    def weights(self):  # 获取该层权重
        return [self.W, self.b]


class SequentialModel:  # 简单的Sequential类
    def __init__(self, layers):
        self.layers = layers

    def __call__(self, inputs):
        x = inputs
        for layer in self.layers:
            x = layer(x)
        return x

    @property
    def weights(self):
        weights = []
        for layer in self.layers:
            weights += layer.weights
        return weights



class BatchGenerator:  # 批量生成器
    def __init__(self, images, labels, batch_size=128):
        assert len(images) == len(labels)
        self.index = 0
        self.images = images
        self.labels = labels
        self.batch_size = batch_size
        self.num_batches = math.ceil(len(images) / batch_size)

    def next(self):
        images = self.images[self.index: self.index + self.batch_size]
        labels = self.labels[self.index: self.index + self.batch_size]
        self.index += self.batch_size
        return images, labels


# 更新参数
learning_rate = 1e-3 # 学习率
def update_weights(gradients, weights):
    for g, w in zip(gradients, weights):
        w.assign_sub(g * learning_rate)  # assign_sub相当于TensorFlow变量的-=

# 计算梯度，并更新权重
def one_training_step(model, images_batch, labels_batch):
    with tf.GradientTape() as tape:  # 运行前向传播，即在GradientTape作用域内计算模型预测值
        predictions = model(images_batch)
        # 标签编码为整数，使用sparse_categorical_crossentropy损失函数
        per_sample_losses = tf.keras.losses.sparse_categorical_crossentropy(labels_batch, predictions)
        average_loss = tf.reduce_mean(per_sample_losses)
    gradients = tape.gradient(average_loss, model.weights)  # 计算损失相对于权重的梯度。输出gradients是一个列表，每个元素对应model.weights列表中的权重
    update_weights(gradients, model.weights)  # 利用梯度来更新权重
    return average_loss


# 完整的训练循环
def fit(model, images, labels, epochs, batch_size=128):
    for epoch_counter in range(epochs):
        print(f"Epoch {epoch_counter}")
        batch_generator = BatchGenerator(images, labels)
        for batch_counter in range(batch_generator.num_batches):
            images_batch, labels_batch = batch_generator.next()
            loss = one_training_step(model, images_batch, labels_batch)
            if batch_counter % 100 == 0:
                print(f"loss at batch {batch_counter}: {loss:.2f}")

数据加载处理

首先，我们需要准备数据。MNIST数据集包含手写数字图像，每个图像是28x28像素的灰度图像，总共有10个类别（0到9）。

# 加载MNIST数据集
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# 归一化像素值到0到1之间
train_images = train_images.reshape((60000, 28 * 28)).astype("float32") / 255
test_images = test_images.reshape((10000, 28 * 28)).astype("float32") / 255

构建训练模型

接下来，我们将使用DenseLayer 和 SequentialModel 类构建一个两层的全连接神经网络模型。

# 利用这个DenseLayer类和SequentialModel类，创建一个与Keras类似的模型
model = SequentialModel([
    DenseLayer(input_size=28 * 28, output_size=512, activation=tf.nn.relu),# 全连接层，512个单元，ReLU激活函数
    DenseLayer(input_size=512, output_size=10, activation=tf.nn.softmax) # 输出层，10个输出单元对应0-9的数字，使用softmax激活函数
])

现在，我们将使用手动实现的神经网络模型来进行训练。

# 开始训练
fit(model, train_images, train_labels, epochs=10, batch_size=128)

# 预测结果准确率
predictions = model(test_images).numpy()
predicted_labels = np.argmax(predictions, axis=1)
matches = predicted_labels == test_labels
print(f"accuracy: {matches.mean():.2f}")

总结

在本博客中，我们使用TensorFlow的底层API手动实现了一个基于全连接层的神经网络模型，并将其应用于MNIST数字图像分类。我们涵盖了深度学习分类的基本原理，包括神经网络、前向传播和反向传播。通过适当的数据处理、模型构建、训练和预测，我们成功地分类了手写数字图像，这是深度学习在计算机视觉中的一个典型应用。希望本文能帮助你了解深度学习分类的基本流程和实现细节。通过底层API的实现，你可以更深入地理解深度学习模型的内部工作原理。