基于TensorFlow与CNN的猫狗识别实战：从环境搭建到模型部署

猫狗识别，可能是过去几年里中国高校计算机相关专业毕业设计中出现频率最高的项目之一。如果你正在为毕设选题发愁，或者已经被导师一句“做个深度学习相关的吧”逼到墙角，那么这个项目确实值得认真做一遍。原因很简单：它不依赖昂贵的设备，普通笔记本的 CPU 也能跑，数据集公开易获取，模型结构有足够的讲解空间，而且从数据处理、模型构建到训练评估，完整覆盖了深度学习项目的主要环节。换句话说，这是一个“麻雀虽小，五脏俱全”的典型项目。

但这里必须先给你一个判断：这个项目最大的坑，不是 CNN 原理看不懂，也不是代码复杂，而是版本环境问题。TensorFlow 2.x 版本迭代很快，Keras 2 和 Keras 3 的 API 变化导致大量老教程代码直接跑不起来。你从 GitHub 上随便拉下来的项目，大概率会报“keras.optimizers找不到”或者“ImageDataGenerator已经被移出核心”之类的错误。

这篇文章会手把手带你基于 TensorFlow + CNN 实现一个完整的猫狗二分类项目。全文按照“环境准备 → 数据集处理 → 模型搭建 → 训练评估 → 预测展示”的顺序推进，代码全部基于 TensorFlow 2.10 及以上版本编写，并兼顾新版 Keras 3 的兼容性写法。你只要能照着复制代码、按顺序运行，就能跑通整个流程。更重要的是，我会在每一步告诉你“为什么这样做”，这样你写毕业论文时，也能讲清楚设计思路。

1. 这篇文章真正要解决的问题

先聊一个比较现实的问题：为什么猫狗识别这种看起来“烂大街”的项目，仍然值得在 2026 年的毕设里继续使用？

因为真正的问题从来不是“有没有人做过”，而是“你能不能独立做出来，并且能把原理讲明白”。很多同学在毕设答辩时最大的尴尬是：代码是从 GitHub 上克隆的，训练过程是 Colab 上跑的，当老师问“为什么卷积核选 3×3”“为什么池化层放在这里”“为什么过拟合了你怎么办”时，现场失语。

猫狗识别这个项目好就好在，它的复杂度刚好卡在“能跑通”和“需要动脑”之间。数据量适中，类别只有两类，模型结构不用太深就能达到 70% 以上的准确率，但如果你想提升到 90% 以上，又必须去思考数据增强、模型结构、正则化、迁移学习这些真实问题。这种“跳一跳够得着”的难度，最适合作为深度学习入门的完整实践项目。

另一个问题是工程层面的。TensorFlow 生态在 2024 年之后进入了一个分水岭：Keras 3 全面拥抱多后端，PyTorch 在学术界占据了绝对主力地位。很多初学者一上来就在 TensorFlow 和 PyTorch 之间反复横跳，最后什么都没学会。这里给你一个务实的建议：如果你想快速完成毕设并且把原理搞清楚，TensorFlow + Keras 的顺序式 API（Sequential）是最低门槛的路径。它的 API 设计高度抽象，数据管道、模型构建、训练过程都封装得足够友好，适合把精力集中在模型设计本身。如果你后续想从事算法研究，再切 PyTorch 会顺畅得多。

这篇文章默认你已经具备 Python 基础语法知识，但不要求你有深度学习理论储备。所有关键概念，比如卷积、池化、全连接、Dropout、数据增强，我都会在相应位置给出通俗解释。

2. CNN 核心概念与猫狗识别任务性质

在写代码之前，先花一点时间把 CNN 最核心的机制讲清楚。如果你已经学过 Chen 老师讲的知识点，这部分可以快速浏览；如果你是零基础，这一节请认真读两遍。

2.1 为什么图像分类需要卷积神经网络

传统机器学习做图像分类的思路是把图片拉平成一个一维向量，然后喂给支持向量机或者全连接网络。这种做法有一个致命的问题：一张 128×128 的彩色图片有 128×128×3 = 49152 个像素值，如果第一层全连接有 1024 个神经元，那这一层的参数量就是 49152×1024 ≈ 5000 万。这还没算后面的层，算力需求直接爆炸，而且因为图像是二维结构，拉平成一维会丢失像素之间的空间位置关系。

CNN 解决这个问题靠两个关键设计：局部连接和权值共享。卷积核（也叫滤波器）每次只盖住图片上的一小块区域，例如 3×3 大小的窗口，通过滑动窗口的方式扫描整张图片。同一个卷积核在整个图片上重复使用，这就是权值共享。这样做的直接效果是：参数量大幅下降，同时模型能自动提取边缘、纹理、形状等层次化特征。

2.2 理解卷积层、池化层和全连接层

我们把 CNN 的典型结构拆成组件来看：

卷积层（Convolution Layer）是特征提取器。每一个卷积核可以理解为一个特征模板，它在图片上滑动时，计算局部像素和模板的匹配程度，最终输出一张特征图。浅层卷积核通常会学到边缘、颜色、角度等低层特征，深层卷积核会组合低层特征，学到眼睛、耳朵、毛发纹理等高层语义特征。这就是 CNN“层次化特征学习”的本质。

池化层（Pooling Layer）起到“压缩”的作用。最常用的是最大池化（Max Pooling），它在一个小窗口内取最大值作为代表，其他值直接丢弃。这样做的意义有两个：一是降低分辨率，减少后续层的计算量；二是让模型对微小位移更不敏感，通俗讲就是“猫在图片里稍微偏了几个像素，模型仍然能认出它是猫”。

全连接层（Fully Connected Layer）位于网络末尾，负责把卷积层提取到的特征图“展平”成一维向量，然后做分类决策。二分类问题的输出层只需要 1 个神经元，配合 Sigmoid 激活函数，输出值在 0 到 1 之间，可以看成预测样本属于“猫”的概率。

2.3 为什么激活函数这么重要

如果神经网络各层之间全部是线性变换，那无论堆多少层，本质上还是一个线性模型，无法学习复杂的分类边界。激活函数引入非线性，让神经网络具备拟合复杂函数的能力。

卷积层中常用 ReLU 激活函数，公式是f(x) = max(0, x)，计算非常简单，但能有效缓解梯度消失问题。输出层使用 Sigmoid，因为二分类最终输出概率，Sigmoid 天然把实数映射到（0,1）区间。

2.4 从特征图到分类结果的全过程

我们可以把整个流程串起来理解：输入一张猫的图片 → 卷积层逐层提取特征，从边缘到纹理再到语义部件 → 池化层逐步降低分辨率，保留最显著的特征 → 展平后经过全连接层整合特征 → 输出层经 Sigmoid 输出一个概率值。概率大于 0.5 判为猫，小于 0.5 判为狗。

看到这里，你应该能理解为什么 CNN 特别适合图像任务了。它不需要人工设计特征，而是用数据驱动的方式自动学习特征。这正是深度学习相对传统方法的最大优势。

3. TensorFlow 环境搭建与基础概念

3.1 选择合适的环境

关于 TensorFlow 版本，有一个很重要的背景信息：从 2024 年开始，TensorFlow 2.18 发布，安装体验优化了不少，后续版本也在持续迭代。但这里必须提醒你，不要盲目追求最新版本，因为 Linux 和 Windows 上预编译的 CUDA 版本和 cuDNN 版本兼容情况不完全一致，如果盲目装最新版，很可能会因为 CUDA 版本不对导致“找不到 libcudart”的错误。

稳妥的方案是：建议安装 TensorFlow 2.10 及以上版本，或者直接装新版的 TensorFlow 2.18 系列。2.10 是一个兼容性很好的版本，后面引入 Keras 3 之后，部分 API 发生变化，网上老教程的代码可能失效。你在参考老教程时要特别注意它写的是from tensorflow.keras还是from keras，这两者在 Keras 3 时代行为可能不一样。

3.2 创建虚拟环境

不做无谓的冒险，不管你是 Windows、Linux 还是 macOS，都建议用虚拟环境隔离项目依赖。这里以 Anaconda 为例：

conda create -n catdog python=3.9 conda activate catdog

Python 3.9 和 3.10 是 TensorFlow 生态兼容性最好的两个版本，不建议用 Python 3.13 尝鲜，防止科学计算库编译不兼容。

3.3 安装 TensorFlow

CPU 版本安装命令：

pip install tensorflow

如果你的电脑有 NVIDIA 显卡，想用 GPU 加速，可以安装带 GPU 支持的版本。注意，TensorFlow 2.10 之后的 Windows 原生版本不再默认支持 GPU，更稳妥的方式是用 WSL2 或者使用 Linux 环境：

pip install tensorflow[and-cuda]

安装完之后，验证环境是否正常：

import tensorflow as tf print(tf.__version__) print(tf.config.list_physical_devices('GPU'))

如果第一行能正常输出版本号，说明 TensorFlow 安装成功。第二行如果能看到 GPU 设备列表，说明 GPU 可用；如果只是一个空列表，说明当前环境是 CPU 运行，对于猫狗识别这种小数据集，CPU 也完全可以跑，只是时间稍长。

3.4 理解数据集基本概念

猫狗识别用到的经典数据集通常被称为 Dogs vs Cats，由 Kaggle 在 2013 年发布，包含训练集 25000 张猫狗图片，测试集 12500 张。这个数据集在学术和教学领域使用非常广泛。

需要注意一个版权和数据来源问题：Kaggle 数据集由微软研究院提供，可用于学习和研究目的。如果你打算在论文中公开实验结果，建议按照 Kaggle 的数据使用条款来操作。另外，毕设场景下不要用爬虫去网上抓取猫狗图片，因为图片版权归属复杂，容易惹来麻烦。

4. 数据集准备与预处理

4.1 数据集目录结构

从 Kaggle 下载数据集后，你会得到一个train.zip文件。解压之后，里面是 25000 张图片，文件名形如cat.0.jpg、dog.0.jpg。如果你的毕设要求不高，用全量数据训练当然可以；但如果你需要快速迭代验证代码正确性，强烈建议先建一个小的子集。

推荐的目录结构如下：

catdog_data/ ├── train/ │ ├── cats/ │ └── dogs/ ├── validation/ │ ├── cats/ │ └── dogs/ └── test/ ├── cats/ └── dogs/

训练集用于模型学习参数，验证集用于在训练过程中评估模型表现、调整超参数，测试集则用于最终评估模型泛化能力。三者互不重叠，这是机器学习的基本准则。

4.2 制作子集脚本

这里给你一个实用的脚本，从原始train文件夹中随机抽取部分图片，生成训练子集。它本质上就是读取原文件路径，复制到新的目录结构里。

import os import shutil import random source_dir = "原始数据集路径/train" target_dir = "catdog_data" # 每个类别的图片数量 train_count = 1000 val_count = 200 test_count = 200 for split, count in [("train", train_count), ("validation", val_count), ("test", test_count)]: for class_name in ["cat", "dog"]: class_dir = os.path.join(source_dir, class_name) if not os.path.exists(class_dir): continue save_dir = os.path.join(target_dir, split, class_name + "s") os.makedirs(save_dir, exist_ok=True) files = [f for f in os.listdir(class_dir) if f.endswith(".jpg")] random.shuffle(files) selected = files[:count] for f in selected: src = os.path.join(class_dir, f) dst = os.path.join(save_dir, f) shutil.copy(src, dst) print(f"{split}/{class_name}: 复制 {len(selected)} 张")

注意，上面代码假设你已经把原始数据整理成了原始数据集路径/train/cat和原始数据集路径/train/dog这种按类别分文件夹的格式。如果你下载的是文件名带前缀的形式，也可以先写一个重命名脚本，按照类别.序号.jpg的规则移动文件，这一步在毕设报告中可以写成“数据预处理模块”。

4.3 图片预处理的关键操作

深度学习模型一般不能直接接受原始图片，需要做几步标准化操作：

• 统一尺寸。不同图片大小不一样，需要缩放到固定尺寸，比如 128×128 或 150×150。这里选择 128×128，因为计算量适中，训练速度更快。
• 归一化。像素值范围是 0 到 255，神经网络一般希望输入数据范围在 0 到 1 之间。最简单的方式是直接除以 255。
• 数据增强。训练集图片太少时，模型容易过拟合，数据增强的作用就是通过随机翻转、旋转、缩放等方式，创造“看起来不一样但实际上还是那只猫”的新样本，相当于免费扩充数据集。

TensorFlow 的tf.keras.preprocessing.image.ImageDataGenerator在旧版本中常用来做数据增强，但在 Keras 3 中官方推荐用tf.keras.layers.Rescaling、RandomFlip、RandomRotation等预处理层，集成在模型内部。这样更简洁，也避免了老 API 的兼容性问题。下面代码会采用这种新写法。

5. 完整示例代码实现

这一节是文章的核心。我会分模块给出完整代码，从模型构建到训练再到评估预测，全部基于 TensorFlow 2.10+ 新版写法。

5.1 导入依赖

import os import matplotlib.pyplot as plt import tensorflow as tf from tensorflow.keras import layers, models, optimizers from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau

• layers提供卷积层、池化层、全连接层等基础组件。
• models提供顺序模型容器。
• optimizers提供优化器，如 Adam。
• 回调函数用于在训练过程中动态调整学习率或提前停止。

5.2 准备训练数据

新版写法鼓励用tf.keras.utils.image_dataset_from_directory直接读取文件夹图片，它会自动处理标签映射。这里把训练集、验证集和测试集一次加载：

train_dir = "catdog_data/train" val_dir = "catdog_data/validation" test_dir = "catdog_data/test" img_height = 128 img_width = 128 batch_size = 32 train_ds = tf.keras.utils.image_dataset_from_directory( train_dir, validation_split=0.0, seed=123, image_size=(img_height, img_width), batch_size=batch_size, label_mode="binary" ) val_ds = tf.keras.utils.image_dataset_from_directory( val_dir, validation_split=0.0, seed=123, image_size=(img_height, img_width), batch_size=batch_size, label_mode="binary" ) test_ds = tf.keras.utils.image_dataset_from_directory( test_dir, validation_split=0.0, seed=123, image_size=(img_height, img_width), batch_size=batch_size, label_mode="binary" )

关键参数说明：

• validation_split这里设为 0.0，因为我们已经有独立的验证集目录，不需要再从训练集里切分。
• label_mode="binary"表示输出标签是 0 或 1，与 Sigmoid 输出层配合。
• image_size统一图片尺寸。

为了性能优化，建议在数据集管道上调用prefetch，让数据加载和模型训练并行执行：

train_ds = train_ds.prefetch(tf.data.AUTOTUNE) val_ds = val_ds.prefetch(tf.data.AUTOTUNE) test_ds = test_ds.prefetch(tf.data.AUTOTUNE)

5.3 构建 CNN 模型

这里的模型结构以 VGG 风格为基础进行简化，核心思路是“卷积 + 池化”反复堆叠，特征图尺寸逐层减半，通道数逐层增加。

model = models.Sequential([ # 数据增强层，只在训练时生效 layers.Rescaling(1.0 / 255, input_shape=(img_height, img_width, 3)), layers.RandomFlip("horizontal"), layers.RandomRotation(0.05), layers.RandomZoom(0.05), # 第一个卷积块 layers.Conv2D(32, (3, 3), activation="relu", padding="same"), layers.MaxPooling2D(2, 2), # 第二个卷积块 layers.Conv2D(64, (3, 3), activation="relu", padding="same"), layers.MaxPooling2D(2, 2), # 第三个卷积块 layers.Conv2D(128, (3, 3), activation="relu", padding="same"), layers.Conv2D(128, (3, 3), activation="relu", padding="same"), layers.MaxPooling2D(2, 2), # 第四个卷积块 layers.Conv2D(256, (3, 3), activation="relu", padding="same"), layers.MaxPooling2D(2, 2), # 分类头 layers.Flatten(), layers.Dropout(0.5), layers.Dense(512, activation="relu"), layers.Dense(1, activation="sigmoid") ]) model.summary()

这段代码有几个关键设计：

• Rescaling层放在模型的第一层，将像素归一化到 0 到 1。输入形状在第一次全连接计算前自动推断。
• RandomFlip、RandomRotation、RandomZoom是数据增强层，它们只在训练过程中生效，推理时自动关闭，不会影响预测结果。
• 第三个卷积块使用了两层连续的卷积，这样可以在保持分辨率的同时增加非线性表达力，是 VGG 网络的典型设计思路。
• Dropout(0.5)在全连接层之前使用，训练时随机丢弃一半的神经元，强制模型不过度依赖某一个特征，是缓解过拟合的常用手段。

5.4 编译模型

model.compile( optimizer=optimizers.Adam(learning_rate=0.001), loss="binary_crossentropy", metrics=["accuracy"] )

• Adam是自适应学习率优化器，对于大多数图像分类任务，默认学习率 0.001 就是很好的起点。
• binary_crossentropy是二分类问题的标准损失函数，它衡量预测概率与真实标签之间的差距，数值越小说明预测越好。
• 指标选择accuracy，可以直接看到分类准确率。

5.5 训练模型

early_stop = EarlyStopping( monitor="val_loss", patience=10, restore_best_weights=True ) reduce_lr = ReduceLROnPlateau( monitor="val_loss", factor=0.5, patience=3, min_lr=1e-6 ) history = model.fit( train_ds, validation_data=val_ds, epochs=50, callbacks=[early_stop, reduce_lr] )

• EarlyStopping是训练保护机制。当验证集损失连续patience个轮次不再下降时，自动终止训练，并恢复验证集上表现最好的权重。这能防止训练耗时长且过拟合。
• ReduceLROnPlateau也很关键。训练后期损失下降变慢，如果学习率一直不变，模型很容易在局部最优附近震荡。这个回调会在损失停滞时自动把学习率减半，让训练继续震荡收敛。
• epochs=50是最大训练轮次，实际训练可能提前终止，这正常。

5.6 运行与验证

直接运行训练脚本，终端输出会逐行打印每个 epoch 的训练损失、训练准确率、验证损失和验证准确率。例如：

Epoch 1/50 125/125 [==============================] - 12s 88ms/step - loss: 0.6723 - accuracy: 0.5581 - val_loss: 0.6305 - val_accuracy: 0.6225 Epoch 2/50 125/125 [==============================] - 11s 88ms/step - loss: 0.5908 - accuracy: 0.6827 - val_loss: 0.5689 - val_accuracy: 0.6980 ... Epoch 25/50 125/125 [==============================] - 11s 88ms/step - loss: 0.3021 - accuracy: 0.8731 - val_loss: 0.2542 - val_accuracy: 0.8925

判断训练是否成功，要看两个指标：

• 训练准确率是否持续上升。
• 训练损失和验证损失的差距是否可控。如果训练准确率很高但验证准确率明显落后很多，说明出现了过拟合。

model.fit返回的history对象里记录了每个 epoch 的指标，后面可以画曲线。

6. 运行结果与效果可视化

训练完之后，绘制训练曲线是毕设报告里非常有价值的一张图。它可以直观展示模型收敛过程，也是答辩时回答“你怎么确定模型训练没问题”的重要依据。

def plot_training_history(history): fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) ax1.plot(history.history["loss"], label="train_loss") ax1.plot(history.history["val_loss"], label="val_loss") ax1.set_xlabel("Epoch") ax1.set_ylabel("Loss") ax1.set_title("Training and Validation Loss") ax1.legend() ax2.plot(history.history["accuracy"], label="train_acc") ax2.plot(history.history["val_accuracy"], label="val_acc") ax2.set_xlabel("Epoch") ax2.set_ylabel("Accuracy") ax2.set_title("Training and Validation Accuracy") ax2.legend() plt.tight_layout() plt.savefig("training_history.png", dpi=150) plt.show() plot_training_history(history)

这个函数将训练损失与验证损失画在左图，训练准确率与验证准确率画在右图。如果两条曲线最终缠绕在一起缓慢上升，说明模型训练良好；如果训练曲线飙升而验证曲线停滞甚至下降，说明过拟合了。

接着在测试集上评估模型最终的泛化能力：

test_loss, test_acc = model.evaluate(test_ds) print(f"测试集损失: {test_loss:.4f}") print(f"测试集准确率: {test_acc:.4f}")

这里值得注意：测试集应该是模型训练过程中从未见过的数据，才能真实反映模型的泛化能力。如果测试集准确率显著低于验证集准确率，说明模型过拟合了训练集，需要加强正则化或扩充训练数据。

7. 模型预测与可视化示例

模型训练好了，不能总是用 TensorFlow 的数据集封装来预测。写一个通用的预测函数，传入任意图片路径，输出猫狗类别和置信度。这一步在毕设演示环节非常出效果。

import numpy as np from PIL import Image class_names = ["狗", "猫"] # 文件夹顺序是 dogs, cats def predict_image(model, img_path): img = Image.open(img_path) img = img.resize((img_height, img_width)) img_array = np.array(img) / 255.0 img_array = np.expand_dims(img_array, axis=0) prob = model.predict(img_array, verbose=0)[0][0] pred_class = int(prob < 0.5) # 0.5以上为猫，反之为狗 print(f"图片路径: {img_path}") print(f"猫的概率: {1 - prob:.4f}, 狗的概率: {prob:.4f}") print(f"预测类别: {class_names[pred_class]}") plt.imshow(img) plt.axis("off") plt.title(f"Prediction: {class_names[pred_class]} ({1 - prob if pred_class == 0 else prob:.2%})") plt.show()

这里的判断逻辑是：Sigmoid 输出值prob表示“属于狗”的概率，所以prob大于 0.5 判为狗，小于 0.5 判为猫。如果你的数据集目录顺序不同，要注意class_names的索引对应关系。

接着随便找几张图片测试一下：

test_image_paths = [ "catdog_data/test/cats/cat.1.jpg", "catdog_data/test/dogs/dog.2.jpg" ] for path in test_image_paths: predict_image(model, path)

从材料看，这类预测演示很适合在毕设答辩现场进行，可以自己准备几张网上找的图片或者在测试集里挑几张贴图展示。

8. 常见问题与排查方法

TensorFlow 环境问题是最让人头疼的，这里把你大概率会遇到的坑提前列出来。

这里需要特别强调的是，不要把报错信息只看第一行。TensorFlow 的报错通常有很长的调用堆栈，最底部的“Caused by”或“Original error”才是真正的原因。如果看到“pip 安装依赖冲突”的提示，每次运行都耐心读完，通常它会告诉你具体是哪个包版本不对。

9. 最佳实践与工程建议

9.1 项目代码结构规划

不要把所有代码堆在一个文件里。毕设代码建议按模块划分，这样答辩时展示项目结构也更有说服力：

catdog_project/ ├── data/ ├── scripts/ │ ├── prepare_data.py # 数据整理与划分 │ ├── train.py # 模型训练 │ ├── evaluate.py # 模型评估 │ └── predict.py # 单张图片预测 ├── models/ │ └── catdog_model.h5 # 训练好的模型文件 ├── notebooks/ │ └── exploration.ipynb # 探索性数据分析 └── requirements.txt

9.2 保存和加载模型

训练完成后，把模型保存下来，方便后面重新加载预测，不用再重新训练：

model.save("models/catdog_model.h5")

加载模型：

loaded_model = tf.keras.models.load_model("models/catdog_model.h5")

如果使用老代码保存的模型在 Keras 3 中加载报错，可以尝试保存为.keras格式，这是新版推荐的模型保存格式。

9.3 想要更高准确率的进阶方向

如果你把基础版本跑通了，还有余力，下面几个方向可以进一步提升准确率，也是毕设加分的常见策略：

• 数据增强增强。除了随机翻转和旋转，还可以加入RandomBrightness、RandomContrast、RandomTranslation等操作，增加数据多样性。
• 迁移学习。使用预训练的MobileNetV2或ResNet50作为特征提取器，冻结基础网络，只训练最后的分类层。这样即使训练数据不足，也能达到 95% 以上的准确率。
• 学习率调度。除了ReduceLROnPlateau，还可以尝试CosineAnnealingLR等更平滑的调度策略。
• 模型集成。训练多个不同初始化条件的模型，预测时取平均值，可以稳定提升准确率和泛化能力。

9.4 关于 TensorFlow 与 PyTorch 的选择

如果你看到这里，想了解为什么网上越来越多的人推荐 PyTorch，这里简单说一下：TensorFlow 2.x 在工业部署领域仍有优势，尤其在 TensorFlow Serving、TensorFlow Lite 等生产链路中非常成熟；而 PyTorch 在学术研究和动态图调试上更灵活，目前论文复现基本以 PyTorch 为主。但回到你的毕设场景，最重要的不是“哪个框架更流行”，而是“哪个框架能让你更快跑通并彻底理解”。TensorFlow + Keras 的顺序式 API 无疑是最短路径。等你掌握了 CNN 原理和训练流程，未来切 PyTorch 最多一两周就能上手。

9.5 论文写作建议

如果项目最终要体现在毕业论文里，建议你重点补充这几块：

• 数据来源与预处理方法。说明你用了什么数据集、怎么划分训练验证测试集、为什么选择这些数据增强策略。
• 模型结构图。用绘图工具把网络的每一层输入输出维度画出来，能让导师一眼看出你的模型设计能力。
• 实验对比。至少做两组对比实验，比如“无数据增强 vs 有数据增强”“原始模型 vs 迁移学习模型”，用准确率和损失曲线说明改进效果。
• 失败案例分析。挑几张预测错的图片，分析可能原因，例如图片模糊、目标过小、类别相似等。这类分析能让答辩老师觉得你真的思考了问题，而不是只会跑代码。

9.6 防止过拟合的通用策略

很多同学在毕设答辩的时候最害怕被问“你的模型过拟合怎么办”。这里给你一个快捷的心智模型：过拟合的本质是模型容量大于数据信息的有效支撑，所以要么增加数据（通过数据增强或收集更多图片），要么降低模型容量（减少卷积核数量、加深 Dropout、增加 L2 正则化），要么借用外部知识（迁移学习）。实际项目中，数据增强 + Dropout 是最容易实现、效果最明显的组合。