帮我每一句都写上注释，解释这段代码的用法

好的，下面是对这段代码逐行的详细注释：

import tensorflow as tf  # 导入 TensorFlow 库，它是深度学习的主要框架
import matplotlib.pyplot as plt  # 导入 Matplotlib 库，用于数据可视化
import numpy as np  # 导入 Numpy 库，用于数学运算和数组操作

# 加载 MNIST 数据集
mnist = tf.keras.datasets.mnist  # 获取预处理的 MNIST 手写数字数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()  # 分割训练集和测试集

# 归一化输入数据，将像素值从 [0, 255] 范围缩放到 [0, 1]
x_train, x_test = x_train / 255.0, x_test / 255.0

# 创建一个简单的卷积神经网络模型
model = tf.keras.models.Sequential([  # Sequential 模型表示顺序结构
    tf.keras.layers.Flatten(input_shape=(28, 28)),  # 输入层，将图像展平成一维
    tf.keras.layers.Dense(128, activation='relu'),  # 第一层全连接层，128个神经元，ReLU激活
    tf.keras.layers.Dense(64, activation='relu'),  # 第二层全连接层，64个神经元，ReLU激活
    tf.keras.layers.Dense(10, activation='softmax')])  # 输出层，10个神经元（对应10个数字类别），softmax激活用于概率分布预测

# 设置模型的优化器、损失函数和评价指标
model.compile(optimizer='adam',  # 使用 Adam 优化算法
              loss='sparse_categorical_crossentropy',  # 交叉熵损失适用于多分类问题
              metrics=['accuracy'])  # 评价指标选择精度

# 使用 Dataset API 对数据进行批处理并进行随机洗牌
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)) \
    .shuffle(len(x_train)) \
    .batch(16)  # 将训练数据分批大小为16，增强数据随机性

test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test)) \
    .batch(16)  # 同样的操作应用于测试集

# 定义一个训练循环，用于多个 epochs 的迭代
epochs = 10  # 总共训练10轮
train_losses = []  # 记录每次训练的损失
train_accuracies = []  # 记录每次训练的精度
val_losses = []  # 记录每次验证的损失
val_accuracies = []  # 记录每次验证的精度

for epoch in range(epochs):  # 对于每个训练轮次
    # 训练阶段
    batch_loss = 0  # 初始化每批次损失
    batch_acc = 0  # 初始化每批次精度
    total_batches = 0  # 初始化总批次数

    # 遍历训练集的所有批次
    for images, labels in train_dataset:  # images 是当前批次的图像，labels 是对应的标签
        total_batches += 1  # 更新总批次数
        
        # 使用 GradientTape 计算梯度并更新模型参数
        with tf.GradientTape() as tape:  # 开启自动微分模式
            predictions = model(images)  # 预测模型输出
            loss = tf.keras.losses.sparse_categorical_crossentropy(labels, predictions)  # 计算损失
            
        gradients = tape.gradient(loss, model.trainable_variables)  # 计算梯度
        model.optimizer.apply_gradients(zip(gradients, model.trainable_variables))  # 更新权重
        
        batch_loss += loss.numpy().mean()  # 累加当前批次损失平均值
        batch_acc += np.mean(np.argmax(predictions, axis=-1) == labels)  # 累加当前批次精度

    # 结束训练批次后，计算整个训练轮次的平均值
    train_loss = batch_loss / total_batches  # 训练损失
    train_acc = batch_acc / total_batches  # 训练精度
    train_losses.append(train_loss)  # 添加到列表
    train_accuracies.append(train_acc)  # 添加到列表
    
    # 验证阶段
    val_batch_loss = 0  # 初始化验证批次损失
    val_batch_acc = 0  # 初始化验证批次精度
    total_val_batches = 0  # 初始化验证总批次数

    # 类似地，在验证集上运行同样的计算
    for val_images, val_labels in test_dataset:
        total_val_batches += 1
        val_predictions = model(val_images)
        val_loss = tf.keras.losses.sparse_categorical_crossentropy(val_labels, val_predictions)
        val_batch_loss += val_loss.numpy().mean()
        val_batch_acc += np.mean(np.argmax(val_predictions, axis=-1) == val_labels)

    # 计算验证集平均值
    val_loss = val_batch_loss / total_val_batches
    val_acc = val_batch_acc / total_val_batches
    val_losses.append(val_loss)
    val_accuracies.append(val_acc)

    # 打印训练和验证信息
    print(f"Epoch {epoch + 1}, Train Loss: {train_loss:.4f}, Train Accuracy: {train_acc:.4f}, Val Loss: {val_loss:.4f}, Val Accuracy: {val_acc:.4f}")

# 测试集上评估模型性能
test_loss, test_acc = model.evaluate(x_test, y_test)  # 在测试集上计算损失和精度
print('Test accuracy:', test_acc)  # 打印测试精度

# 绘制训练和验证的损失和精度变化趋势
plt.plot(train_accuracies, label='Train Acc')  # 绘制训练精度曲线
plt.plot(val_accuracies, label='Val Acc')  # 绘制验证精度曲线
plt.title('Model accuracy')  # 图像标题
plt.ylabel('Accuracy')  # y轴标签
plt.xlabel('Epochs')  # x轴标签
plt.legend(loc='upper left')  # 显示图例
plt.show()  # 显示图表

plt.plot(train_losses, label='Train Loss')  # 绘制训练损失曲线
plt.plot(val_losses, label='Val Loss')  # 绘制验证损失曲线
plt.title('Model loss')  # 图像标题
plt.ylabel('Loss')  # y轴标签
plt.xlabel('Epochs')  # x轴标签
plt.legend(loc='upper left')
plt.show()  # 显示图表

这段代码主要用于训练一个卷积神经网络模型，对MNIST数据集进行手写数字识别。它包含了数据预处理、模型构建、训练和验证、以及性能评估和结果可视化的过程。