动漫角色识别是计算机视觉的典型应用场景，可用于周边商品分类、动画制作辅助等。
这个案例是一个经典的深度学习应用，用于图像分类任务，它使用了一个自定义的VGG-16模型来对《海贼王》中的七个角色进行分类，演示如何将经典CNN模型应用于小规模自定义数据集。
1. 数据集准备
数据集包含7个类别的图片，每个类别对应一个《海贼王》的角色：
- 路飞（lufei）
- 罗宾（luobin）
- 娜美（namei）
- 乔巴（qiaoba）
- 山治（shanzhi）
- 索隆（suolong）
- 乌索普（wusuopu）
每个角色有不同数量的图片，总共621张图片。
（1）导入必要的库和设置随机种子
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models
import pathlib
import matplotlib.pyplot as plt
import os, PIL
np.random.seed(1)
tf.random.set_seed(1)
#导入所需的Python库，并设置随机种子以确保实验的可重复性。（2）设置数据目录和参数
data_dir = r"D:\hzw_photos"
data_dir = pathlib.Path(data_dir)
image_count = len(list(data_dir.glob('*/*.png')))
print("图片总数为：", image_count)
batch_size = 32
img_height = 224
img_width = 224
#作用：指定数据集路径、统计图片总数，并定义批量大小和图片尺寸。
#运行结果：输出图片总数（621张）。（3）加载训练集和验证集
train_ds = tf.keras.preprocessing.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="training",
seed=123,
image_size=(img_height, img_width),
batch_size=batch_size
)
val_ds = tf.keras.preprocessing.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="validation",
seed=123,
image_size=(img_height, img_width),
batch_size=batch_size
)
#作用：从指定目录加载图像数据集，并将其分为训练集和验证集。validation_split=0.2表示20%的数据用于验证，其余80%用于训练。
#运行结果：打印出找到的文件数量和类别信息。（4）获取类别名称
class_names = train_ds.class_names
print(class_names)
#作用：获取并打印数据集中所有类别的名称。
#运行结果：输出类别名称列表：['lufei', 'luobin', 'namei', 'qiaoba', 'shanzhi', 'suolong', 'wusuopu']。（5）可视化数据
plt.figure(figsize=(10, 5))
for images, labels in train_ds.take(1):
for i in range(8):
ax = plt.subplot(2, 4, i + 1)
plt.imshow(images[i].numpy().astype("uint8"))
plt.title(class_names[labels[i]])
plt.axis("off")
plt.show()
#作用：从训练集中随机选取一批图像进行可视化展示。
#运行结果：显示8张随机选择的图像及其对应的标签。
2. 数据预处理
（1）配置数据集
AUTOTUNE = tf.data.AUTOTUNE
train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
#作用：对数据集进行缓存、打乱和预取操作，以提高数据读取效率。
#运行结果：无直接输出，但优化了数据加载过程。（2）归一化处理
normalization_layer = tf.keras.layers.Rescaling(1. / 255)
train_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
val_ds = val_ds.map(lambda x, y: (normalization_layer(x), y))
image_batch, labels_batch = next(iter(val_ds))
first_image = image_batch[0]
print("归一化后数据范围：", np.min(first_image), np.max(first_image))
#作用：将图像像素值归一化到[0, 1]区间内。
#运行结果：输出归一化后的数据范围（0.0到0.9928046），表明归一化操作成功。3. 模型构建
VGG-16 是一种经典的卷积神经网络（CNN）架构，通过堆叠多个卷积层和池化层来提取图像特征，最后通过全连接层进行分类。以其简单的结构和深度而闻名，尤其在图像分类任务中表现出色。
定义VGG-16模型
def VGG16(nb_classes, input_shape):
# 构建VGG-16模型...
return model
#作用：定义一个自定义的VGG-16模型，包括多个卷积层和全连接层。
#运行结果：无直接输出，但生成了一个可以使用的模型结构。（1） 输入层
input_tensor = layers.Input(shape=input_shape)
#input_shape 输入图像的形状，通常为 (height, width, channels)，例如 (224, 224, 3) 表示 224x224 像素的 RGB 图像
#Input 层定义了模型的输入张量。
（2）卷积块 1
x = layers.Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(input_tensor)
x = layers.Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
#两个 Conv2D 层，每个层使用 64 个 3x3 的卷积核，激活函数为 ReLU，padding='same' 表示输出特征图的大小与输入相同。
#MaxPooling2D 层使用 2x2 的池化窗口，步幅为 2，将特征图的大小减半。
#输入图像（224×224×3）
#→ 经过64个3×3卷积核提取特征（输出224×224×64）
#→ 再次卷积增强特征（保持尺寸）
#→ 2×2最大池化（输出112×112×64）（3）卷积块 2
x = layers.Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x)
x = layers.Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
#与第一个卷积块类似，但卷积核数量增加到 128。（4） 卷积块 3
x = layers.Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x)
x = layers.Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x)
x = layers.Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
#卷积核数量增加到 256，并且有三个卷积层。（5）卷积块 4
x = layers.Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x)
x = layers.Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x)
x = layers.Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
#卷积核数量增加到 512，同样有三个卷积层。（6）卷积块 5
x = layers.Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x)
x = layers.Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x)
x = layers.Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)
#与卷积块 4 相同，卷积核数量保持为 512。
| 块编号 | CONV层数量 | 输出尺寸 | 通道数 | 作用 |
|---|---|---|---|---|
| 1 | 2 | 112×112 | 64 | 提取边缘/颜色等低级特征 |
| 2 | 2 | 56×56 | 128 | 捕获纹理/简单形状 |
| 3 | 3 | 28×28 | 256 | 识别复杂图案（如草帽轮廓） |
| 4 | 3 | 14×14 | 512 | 检测角色局部特征（娜美的头发等） |
| 5 | 3 | 7×7 | 512 | 整合全局语义信息 |
（7） 全连接层
x = layers.Flatten()(x)
x = layers.Dense(4096, activation='relu', name='fc1')(x)
x = layers.Dense(4096, activation='relu', name='fc2')(x)
output_tensor = layers.Dense(nb_classes, activation='softmax', name='predictions')(x)
#Flatten 层将多维特征图展平为一维向量。
#两个 Dense 层，每个层有 4096 个神经元，激活函数为 ReLU。
#最后的 Dense 层输出类别概率，使用 softmax 激活函数，nb_classes 是类别数量。（8）构建模型
model = models.Model(input_tensor, output_tensor)
#使用 Model 类将输入张量和输出张量组合成模型。（9）初始化模型
model = VGG16(nb_classes=7, input_shape=(img_width, img_height, 3))
model.summary()
#作用：初始化VGG-16模型，并打印模型结构摘要。
#运行结果：输出模型各层的详细信息，包括层名、输出形状和参数数量等。输入图像 → [CONV→POOL]×5 → 展平 → FC×2 → 分类输出
(特征提取) (决策)
4. 模型编译与训练
编译模型
opt = tf.keras.optimizers.Adam(learning_rate=1e-4)
model.compile(
optimizer=opt,
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
metrics=['accuracy']
)
#作用：配置模型的优化器、损失函数和评估指标。训练模型
history = model.fit(
train_ds,
validation_data=val_ds,
epochs=epochs
)
#作用：在训练集上训练模型，并在每个epoch结束后评估验证集上的性能。
#运行结果：输出每个epoch的训练准确率、训练损失、验证准确率和验证损失。5. 结果分析
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(range(epochs), acc, label='Training Accuracy')
plt.plot(range(epochs), val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(range(epochs), loss, label='Training Loss')
plt.plot(range(epochs), val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
#作用：绘制训练和验证过程中的准确率及损失变化曲线。
#运行结果：显示两个子图，分别表示准确率和损失的变化趋势。
- 训练准确率和验证准确率都随着训练轮数的增加而上升，表明模型逐渐学习到了数据的特征。
- 训练损失和验证损失则逐渐下降，说明模型的预测误差在减小。
图片总数为： 621
Found 621 files belonging to 7 classes.
Using 497 files for training.
Found 621 files belonging to 7 classes.
Using 124 files for validation.
['lufei', 'luobin', 'namei', 'qiaoba', 'shanzhi', 'suolong', 'wusuopu']
归一化后数据范围： 0.0 0.9928046
Model: "functional"
┌─────────────────────────────────┬────────────────────────┬───────────────┐
│ Layer (type) │ Output Shape │ Param # │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ input_layer (InputLayer) │ (None, 224, 224, 3) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block1_conv1 (Conv2D) │ (None, 224, 224, 64) │ 1,792 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block1_conv2 (Conv2D) │ (None, 224, 224, 64) │ 36,928 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block1_pool (MaxPooling2D) │ (None, 112, 112, 64) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block2_conv1 (Conv2D) │ (None, 112, 112, 128) │ 73,856 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block2_conv2 (Conv2D) │ (None, 112, 112, 128) │ 147,584 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block2_pool (MaxPooling2D) │ (None, 56, 56, 128) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_conv1 (Conv2D) │ (None, 56, 56, 256) │ 295,168 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_conv2 (Conv2D) │ (None, 56, 56, 256) │ 590,080 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_conv3 (Conv2D) │ (None, 56, 56, 256) │ 590,080 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_pool (MaxPooling2D) │ (None, 28, 28, 256) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_conv1 (Conv2D) │ (None, 28, 28, 512) │ 1,180,160 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_conv2 (Conv2D) │ (None, 28, 28, 512) │ 2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_conv3 (Conv2D) │ (None, 28, 28, 512) │ 2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_pool (MaxPooling2D) │ (None, 14, 14, 512) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_conv1 (Conv2D) │ (None, 14, 14, 512) │ 2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_conv2 (Conv2D) │ (None, 14, 14, 512) │ 2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_conv3 (Conv2D) │ (None, 14, 14, 512) │ 2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_pool (MaxPooling2D) │ (None, 7, 7, 512) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ flatten (Flatten) │ (None, 25088) │ 0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ fc1 (Dense) │ (None, 4096) │ 102,764,544 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ fc2 (Dense) │ (None, 4096) │ 16,781,312 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ predictions (Dense) │ (None, 7) │ 28,679 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
Total params: 134,289,223 (512.27 MB)
Trainable params: 134,289,223 (512.27 MB)
Non-trainable params: 0 (0.00 B)
Epoch 1/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 207s 13s/step - accuracy: 0.1736 - loss: 1.9444 - val_accuracy: 0.1935 - val_loss: 1.9390
Epoch 2/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 216s 14s/step - accuracy: 0.1594 - loss: 1.9357 - val_accuracy: 0.1935 - val_loss: 1.9355
Epoch 3/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 195s 12s/step - accuracy: 0.1656 - loss: 1.9362 - val_accuracy: 0.1935 - val_loss: 1.9293
Epoch 4/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 208s 13s/step - accuracy: 0.1749 - loss: 1.9240 - val_accuracy: 0.1452 - val_loss: 1.9054
Epoch 5/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 214s 13s/step - accuracy: 0.1787 - loss: 1.8650 - val_accuracy: 0.2419 - val_loss: 1.6483
Epoch 6/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 202s 13s/step - accuracy: 0.3046 - loss: 1.5703 - val_accuracy: 0.3306 - val_loss: 1.6471
Epoch 7/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 198s 13s/step - accuracy: 0.4451 - loss: 1.4282 - val_accuracy: 0.5403 - val_loss: 1.1161
Epoch 8/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 179s 11s/step - accuracy: 0.6045 - loss: 1.0102 - val_accuracy: 0.5081 - val_loss: 1.0964
Epoch 9/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 166s 11s/step - accuracy: 0.6386 - loss: 0.9255 - val_accuracy: 0.6935 - val_loss: 0.8652
Epoch 10/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 162s 10s/step - accuracy: 0.7404 - loss: 0.6550 - val_accuracy: 0.6290 - val_loss: 0.9989
Epoch 11/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 185s 11s/step - accuracy: 0.8052 - loss: 0.5281 - val_accuracy: 0.6855 - val_loss: 0.9217
Epoch 12/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 185s 12s/step - accuracy: 0.8136 - loss: 0.4523 - val_accuracy: 0.6613 - val_loss: 1.0901
Epoch 13/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 193s 12s/step - accuracy: 0.8089 - loss: 0.4674 - val_accuracy: 0.6935 - val_loss: 0.7750
Epoch 14/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 192s 12s/step - accuracy: 0.8577 - loss: 0.3848 - val_accuracy: 0.7339 - val_loss: 0.8414
Epoch 15/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 185s 12s/step - accuracy: 0.9164 - loss: 0.2603 - val_accuracy: 0.7419 - val_loss: 1.2181
Epoch 16/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 223s 14s/step - accuracy: 0.8789 - loss: 0.4077 - val_accuracy: 0.7258 - val_loss: 0.9584
Epoch 17/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 236s 15s/step - accuracy: 0.9123 - loss: 0.2405 - val_accuracy: 0.7419 - val_loss: 1.2041
Epoch 18/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 236s 15s/step - accuracy: 0.9637 - loss: 0.1224 - val_accuracy: 0.7339 - val_loss: 1.9659
Epoch 19/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 226s 14s/step - accuracy: 0.9677 - loss: 0.0793 - val_accuracy: 0.7339 - val_loss: 1.4271
Epoch 20/20
16/16 ━━━━━━━━━━━━━━━━━━━━ 224s 14s/step - accuracy: 0.9548 - loss: 0.1205 - val_accuracy: 0.7581 - val_loss: 1.4689
#指标 训练集变化 验证集变化 结论
#准确率 17.4% → 95.5% (↑78.1%) 19.4% → 75.8% (↑56.4%) 模型学习有效，但存在明显过拟合
#损失值 1.94 → 0.12 (↓93.8%) 1.94 → 1.47 (↓24.2%) 训练损失下降过快，验证损失震荡
进程已结束，退出代码为 0
6.从深度学习展开分析
（1）特征学习的革命性突破
传统方法 vs 深度学习
-
传统CV方案：
草帽、发型等特征难以用数学公式描述 不同姿势/角度下特征稳定性差
需要手工设计特征（如HOG描述子、颜色直方图），但对于动漫人物： -
深度学习方案：
VGG-16通过卷积层自动学习层次化特征：
底层特征（前几层）：边缘/颜色 → 识别路飞的草帽红色边缘
中层特征：纹理/部件 → 组合出索隆的三把刀轮廓
高层特征：全局语义 → 理解"娜美的橘色头发+身体比例"这种复合特征
（2）处理图像数据的先天优势
-
空间不变性：
-
通过卷积核共享机制，无论路飞出现在图像左上角还是右下角都能被识别
-
池化层使模型对小幅位移/旋转具有鲁棒性（适合动漫截图角度多变的特点）
-
-
通道维度理解：
-
RGB三通道自动提取色彩特征（如乔巴的粉色帽子、山治的金发）
-
相比灰度图，保留关键颜色线索
-
-
感受野递进：
-
从3×3小窗口逐步扩大到全图感知（最终7×7的特征图对应原图约200×200像素区域）
-
这种机制天然适配"从局部到整体"的认知逻辑
-
（3）端到端训练的便捷性
传统流程：
图像预处理 → 特征工程 → 分类器设计 → 结果优化（需分步调试）
深度学习流程：
原始图片输入 → VGG网络 → 分类结果
所有优化自动完成
（4）针对动漫数据的特殊适配能力
-
风格化特征处理：
-
动漫人物线条鲜明、用色大胆，与真实照片差异大
-
CNN通过多层非线性变换，能更好捕捉这种艺术化表达
-
-
跨角色泛化：
-
即使训练集没有"戴草帽的罗宾"这类异常组合，模型也能通过：
-
低层学到的"草帽特征"
-
高层学到的"罗宾面部特征"
-
-
组合推理出未知变体（比传统方法更具泛化潜力）
-
（5）延伸应用场景
这套技术方案稍加调整即可用于：
-
动漫产业：自动标注动画分镜中的人物出场
-
游戏开发：玩家上传截图自动识别角色阵容
-
周边电商：拍照搜索手办/服饰对应的
七、总结
在本案例中，深度学习的作用本质是：
通过多层非线性变换，自动从像素中学习到海贼王角色的抽象特征表达，并建立这些特征与人物类别的映射关系。其价值不在于替代人类认知，而是将人类难以显式描述的视觉模式（比如"如何定义乔巴的可爱感"）编码成可优化的数学表示。未来结合注意力机制等新技术，还可进一步接近人类的分辨能力。
