logo

开发者热搜

TensorFlow与Keras实战：服装图像分类入门指南

作者：搬砖的石头2025.09.18 17:02浏览量：0

简介：本文通过TensorFlow与Keras框架实现服装图像分类的完整教程，涵盖数据加载、模型构建、训练与评估全流程，帮助开发者快速掌握深度学习图像分类技术。

TensorFlow与Keras实战：服装图像分类入门指南

一、深度学习图像分类技术概览

在计算机视觉领域，图像分类是基础且核心的任务之一。传统机器学习方法依赖手工特征提取，而深度学习通过卷积神经网络（CNN）实现了端到端的特征学习与分类。TensorFlow作为Google开发的开源深度学习框架，结合其高级API Keras，大幅降低了深度学习模型的开发门槛。

本教程以Fashion MNIST数据集为例，该数据集包含60,000张训练图像和10,000张测试图像，涵盖10类服装（如T恤、裤子、鞋子等），每张图像尺寸为28×28像素。相较于经典MNIST手写数字数据集，Fashion MNIST的分类难度更高，更适合作为深度学习入门实践案例。

二、环境准备与数据加载

1. 开发环境配置

建议使用Python 3.7+环境，通过pip安装核心依赖库：

  1. pip install tensorflow numpy matplotlib

TensorFlow 2.x版本已内置Keras，无需单独安装。验证环境是否配置成功：

  1. import tensorflow as tf
  2. print(tf.__version__)  # 应输出2.x版本号

2. 数据集加载与预处理

TensorFlow提供了tf.keras.datasets.fashion_mnist模块直接加载数据：

  1. from tensorflow.keras.datasets import fashion_mnist
  3. (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

数据预处理步骤包括：

  • 像素值归一化：将0-255的像素值缩放到0-1区间
    1. train_images = train_images.astype('float32') / 255
    2. test_images = test_images.astype('float32') / 255
  • 标签编码：将类别数字映射为文本标签
    1. class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
    2.              'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

三、Keras模型构建与训练

1. 模型架构设计

采用经典的CNN结构，包含卷积层、池化层和全连接层：

  1. from tensorflow.keras import layers, models
  3. model = models.Sequential([
  4.     # 卷积层1：32个3×3卷积核，ReLU激活
  5.     layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
  6.     # 最大池化层：2×2窗口
  7.     layers.MaxPooling2D((2, 2)),
  8.     # 卷积层2：64个3×3卷积核
  9.     layers.Conv2D(64, (3, 3), activation='relu'),
  10.     layers.MaxPooling2D((2, 2)),
  11.     # 展平层
  12.     layers.Flatten(),
  13.     # 全连接层：64个神经元
  14.     layers.Dense(64, activation='relu'),
  15.     # 输出层：10个类别，Softmax激活
  16.     layers.Dense(10, activation='softmax')
  17. ])

模型结构解析：

  • 输入层：28×28像素灰度图（通道数=1）
  • 卷积层：自动提取图像特征（边缘、纹理等）
  • 池化层：降低特征图维度，增强平移不变性
  • 全连接层：整合特征进行分类

2. 模型编译配置

  1. model.compile(optimizer='adam',
  2.               loss='sparse_categorical_crossentropy',
  3.               metrics=['accuracy'])

关键参数说明：

  • 优化器：Adam自适应学习率算法
  • 损失函数：适用于多分类的交叉熵损失
  • 评估指标：分类准确率

3. 模型训练过程

  1. history = model.fit(train_images.reshape(-1, 28, 28, 1), 
  2.                     train_labels,
  3.                     epochs=10,
  4.                     batch_size=64,
  5.                     validation_split=0.2)

训练参数详解：

  • epochs：完整遍历训练集10次
  • batch_size：每次梯度更新使用64个样本
  • validation_split：从训练集中划分20%作为验证集

训练过程中，Keras会自动记录损失值和准确率的变化，可通过history.history字典获取训练日志。

四、模型评估与可视化

1. 测试集评估

  1. test_loss, test_acc = model.evaluate(test_images.reshape(-1, 28, 28, 1), 
  2.                                     test_labels)
  3. print(f'Test accuracy: {test_acc:.4f}')

典型输出结果：

  1. 313/313 [==============================] - 1s 2ms/step - loss: 0.3123 - accuracy: 0.8872
  2. Test accuracy: 0.8872

2. 训练过程可视化

  1. import matplotlib.pyplot as plt
  3. acc = history.history['accuracy']
  4. val_acc = history.history['val_accuracy']
  5. loss = history.history['loss']
  6. val_loss = history.history['val_loss']
  8. epochs = range(1, len(acc) + 1)
  9. plt.figure(figsize=(12, 4))
  11. plt.subplot(1, 2, 1)
  12. plt.plot(epochs, acc, 'bo', label='Training acc')
  13. plt.plot(epochs, val_acc, 'b', label='Validation acc')
  14. plt.title('Training and validation accuracy')
  15. plt.legend()
  17. plt.subplot(1, 2, 2)
  18. plt.plot(epochs, loss, 'bo', label='Training loss')
  19. plt.plot(epochs, val_loss, 'b', label='Validation loss')
  20. plt.title('Training and validation loss')
  21. plt.legend()
  23. plt.show()

可视化分析要点：

  • 训练集准确率持续上升，验证集准确率在后期趋于平稳
  • 损失值曲线应呈下降趋势，验证损失与训练损失的差值反映过拟合程度

五、模型优化方向

1. 数据增强技术

通过随机变换增加数据多样性：

  1. from tensorflow.keras.preprocessing.image import ImageDataGenerator
  3. datagen = ImageDataGenerator(
  4.     rotation_range=20,
  5.     width_shift_range=0.2,
  6.     height_shift_range=0.2,
  7.     horizontal_flip=True)
  9. # 在fit_generator中使用（TensorFlow 2.x中已集成到fit方法）

2. 模型架构改进

  • 增加卷积层深度（如添加128个滤波器的卷积层）
  • 引入批归一化层加速训练：
    1. layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    2. layers.BatchNormalization(),  # 新增批归一化层
    3. layers.MaxPooling2D((2, 2))
  • 尝试不同的激活函数（如LeakyReLU）

3. 超参数调优

使用Keras Tuner进行自动化超参数搜索：

  1. import keras_tuner as kt
  3. def build_model(hp):
  4.     model = models.Sequential()
  5.     model.add(layers.Conv2D(
  6.         filters=hp.Int('filters', 32, 128, step=32),
  7.         kernel_size=hp.Choice('kernel_size', [3, 5]),
  8.         activation='relu',
  9.         input_shape=(28, 28, 1)))
  10.     # ... 其他层定义
  11.     model.add(layers.Dense(10, activation='softmax'))
  13.     learning_rate = hp.Float('lr', 1e-4, 1e-2, sampling='log')
  14.     model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate),
  15.                   loss='sparse_categorical_crossentropy',
  16.                   metrics=['accuracy'])
  17.     return model
  19. tuner = kt.RandomSearch(build_model,
  20.                         objective='val_accuracy',
  21.                         max_trials=10)
  22. tuner.search(train_images.reshape(-1, 28, 28, 1), train_labels,
  23.              epochs=5, validation_split=0.2)

六、完整代码实现

  1. # 1. 导入库
  2. import tensorflow as tf
  3. from tensorflow.keras import layers, models
  4. import matplotlib.pyplot as plt
  6. # 2. 加载数据
  7. (train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.fashion_mnist.load_data()
  8. class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
  9.                'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
  11. # 3. 数据预处理
  12. train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
  13. test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255
  15. # 4. 构建模型
  16. model = models.Sequential([
  17.     layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
  18.     layers.MaxPooling2D((2, 2)),
  19.     layers.Conv2D(64, (3, 3), activation='relu'),
  20.     layers.MaxPooling2D((2, 2)),
  21.     layers.Flatten(),
  22.     layers.Dense(64, activation='relu'),
  23.     layers.Dense(10, activation='softmax')
  24. ])
  26. # 5. 编译模型
  27. model.compile(optimizer='adam',
  28.               loss='sparse_categorical_crossentropy',
  29.               metrics=['accuracy'])
  31. # 6. 训练模型
  32. history = model.fit(train_images, train_labels, 
  33.                     epochs=10, 
  34.                     batch_size=64,
  35.                     validation_split=0.2)
  37. # 7. 评估模型
  38. test_loss, test_acc = model.evaluate(test_images, test_labels)
  39. print(f'Test accuracy: {test_acc:.4f}')
  41. # 8. 可视化训练过程
  42. acc = history.history['accuracy']
  43. val_acc = history.history['val_accuracy']
  44. loss = history.history['loss']
  45. val_loss = history.history['val_loss']
  47. epochs = range(1, len(acc) + 1)
  48. plt.figure(figsize=(12, 4))
  50. plt.subplot(1, 2, 1)
  51. plt.plot(epochs, acc, 'bo', label='Training acc')
  52. plt.plot(epochs, val_acc, 'b', label='Validation acc')
  53. plt.title('Training and validation accuracy')
  54. plt.legend()
  56. plt.subplot(1, 2, 2)
  57. plt.plot(epochs, loss, 'bo', label='Training loss')
  58. plt.plot(epochs, val_loss, 'b', label='Validation loss')
  59. plt.title('Training and validation loss')
  60. plt.legend()
  62. plt.show()

七、实践建议与进阶方向

  1. 从零实现CNN：尝试不使用Keras内置层，手动实现卷积和池化操作
  2. 迁移学习应用：使用预训练模型（如MobileNet）进行特征提取
  3. 部署实践：将训练好的模型导出为TensorFlow Lite格式，部署到移动端
  4. 多标签分类：修改输出层和损失函数，实现同时识别多个服装类别

本教程完整实现了基于TensorFlow和Keras的服装图像分类系统，覆盖了从数据加载到模型部署的全流程。通过调整模型架构和训练参数，读者可进一步提升分类准确率，为更复杂的计算机视觉任务奠定基础。

相关文章推荐

发表评论

最热文章

关于作者

  • 被阅读数
  • 被赞数
  • 被收藏数