Python深度学习：TensorFlow 2.0实现卷积神经网络图像识别与迁移学习

Python深度学习速成课走到第四篇，我打算换个节奏，不再铺垫太多基础语法，直接聊一个绕不开的话题：图像识别和卷积神经网络。前三篇我们已经把张量操作、自动求导、全连接分类模型从头到尾过了一遍，如果你一路跟着练习做下来，现在应该已经能用TensorFlow 2.0的Keras接口搭出一个识别手写数字的模型，也能大致看懂loss曲线下降的含义。但一个疑问肯定会浮现出来：把图片里每个像素全部硬塞进全连接层，真的合理吗？答案是不合理。所以这一节我们正式进入卷积神经网络（CNN），这也是深度学习视觉任务的基石。

这一篇我打算按照速成课一贯的节奏，把卷积和池化的原理讲到"脑子里有画面"的程度，给出一段可以直接跑通的手写数字CNN代码，再把带新人时反复遇到的四个训练坑全部摊开讲，最后用一个猫狗图像分类Demo把迁移学习也过一遍。适合的读者定位很明确：会写Python基础语法、已经跑通过一次Keras全连接模型、但还没系统接触过CNN的初学者。有基础的朋友可以直接跳到第三节看代码，但我建议原理部分还是扫一眼，后面调参你会用得上。

1. 第四节的分水岭：为什么图像任务要放弃全连接网络

1.1 一张图片在TensorFlow里到底是什么形状

先解决一个特别容易栽的跟头：图片在TensorFlow里不是"二维数组"，而是四维张量。形状是(batch, height, width, channels)，也就是一次处理多少张图、每张图多高多宽、每个像素有几个通道。MNIST数据集是28×28的灰度图，加载进来的形状是(60000, 28, 28, 1)：60000张训练图片，每张28×28，通道数为1。彩色图片则是3个通道，对应RGB，一张256×256的彩图就是(256, 256, 3)。

很多初学者第一次用x_train.shape查看数据时，发现是四维会觉得奇怪，甚至有人直接把(60000, 28, 28)当成两三张图片来理解，这都是因为没把 batch 维度放在心里。Keras默认使用channels_last的排布方式，也就是通道维度放在最后面；如果你翻到一些老教程看到(1, 28, 28)这种channels_first排布，不用慌，那是另一种约定，现在主流框架默认基本都是通道在后。

像素值本身是0到255的整数，神经网络处理时通常希望输入数值范围小且平滑，所以我们要做归一化：把每个像素除以255，变成0到1之间的小数。这个步骤看起来简单，却是个高频错误点，后面第四节我会专门讲它引起的坑。

1.2 全连接网络面对图像的三个结构性缺陷

全连接层处理图像，有三个绕不开的问题。

第一个是参数爆炸。假设输入是一张256×256的彩色图，拉平后是256×256×3 = 196608个数字。如果第一层全连接有128个神经元，那这一层的参数量就是196608×128 + 128 ≈ 2500万。这个规模在入门机器上根本训不动，更别说图像再大一点了。你会发现自己啥也没干，光第一层就占了几个G的显存。

第二个是空间结构的丢失。图片里相邻像素才有意义：猫的眼睛一定在鼻子附近，车灯一定在车身上方。但全连接层把像素拉成一维向量后，这些相对位置信息在数学上就"抹平"了。网络不知道第200号像素和205号像素挨着，它只能把每个位置都当成独立特征去硬学。

第三个是平移不鲁棒。同一只猫出现在图片左边和右边，对所有像素位置来说是完全不同的两串数字，全连接网络很难把这两种情况归为同一个类别。想让它对位置变化鲁棒，只能靠海量数据去覆盖各种可能的摆放位置，成本极高。

1.3 用参数数量说话：全连接和卷积的差距有多夸张

我列一张表来对比两种情况，同样是第一层，感受会非常直观。

卷积网络之所以能做到这么省参数，核心是两条设计思路：一是局部连接，每个卷积核只看自己周围的一小块区域，而不是整张图；二是权重共享，同一个卷积核会滑过整张图的所有位置，无论特征出现在哪里，用的都是同一组权重。说白了，就是把"识别一个局部模式"这件事复用到了全图，这比让网络为每一个像素单独学一套参数要聪明得多。

2. 卷积与池化的直觉理解：从滑窗计算到特征图尺寸

2.1 卷积核：同一枚"印章"在整张图上反复盖

卷积核可以理解为一枚小印章，常见的尺寸是3×3或5×5。印章在每个像素位置上盖一下，盖的方式是做一次逐元素相乘再求和，得到一个输出值，这个值就代表"当前位置和这个印章的匹配程度"。整张图盖完，得到的二维结果叫特征图。每个卷积核专门负责检测一种模式，比如横向边缘、竖向边缘、圆角、斜纹。

第一层卷积学到的通常是边缘、颜色块这类低级特征；网络越深，后面的层越能组合出复杂概念，比如眼睛、车轮、人脸轮廓。这种"低层特征组合成高层特征"的层级结构，正是CNN最核心的思想。用一个生活化的类比：你在人群中认出一个人，先看到的是轮廓和颜色，再辨认五官组合，最后确认是熟人。卷积网络的学习路径和这个很像。

在Keras里，layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu')的意思是：同时用32个3×3的印章去盖图，每个印章生成一张特征图，输入一张图，输出就是32张特征图叠在一起。

2.2 池化：分辨率减半，但把关键信息留住

池化层通常紧跟在卷积层后面，最常用的是最大池化。2×2的最大池化，就是把这个窗口里4个像素的最大值取出来，窗口以2为步长滑动，28×28的特征图就变成了14×14，分辨率直接减半。

池化有两个作用。一是下采样，减少后续计算量；二是带来小范围的平移容忍：物体如果轻微移动几个像素，最大值大概率还在同一个池化窗口内，特征是否出现这件事没有改变，所以模型对位置变化就没那么敏感。

为什么常用最大池化而不是平均池化？因为卷积网络里我们通常更关心"这个特征出现了没有"，而不是"它平均成什么样了"。最大值更接近"是否出现"这个语义。池化层没有可学习的参数，它就是个固定规则的操作，这一点初学者容易误认为它也有权重，其实完全没有。

2.3 特征图尺寸怎么算：写网络之前先算清楚

动手搭网络之前，把每层输出尺寸算明白，能避免后面Flatten时报维度错误。尺寸计算公式是：

输出尺寸 = (输入尺寸 + 2 × 填充 - 卷积核尺寸) / 步长 + 1

以28×28输入、3×3卷积核、padding='same'、步长1为例：

padding='same'表示必要时在图像边缘补一圈0，让输出尺寸保持和输入一致；padding='valid'则不补，尺寸会缩小。为什么入门网络喜欢"卷积→池化→卷积→池化"这种节奏？因为每次分辨率减半，通道数翻倍，相当于把空间信息逐步浓缩成通道信息，信息量并不明显丢失，计算量却降下来了。

2.4 Keras里的Conv2D与MaxPooling2D参数速查

用TensorFlow 2.0写起来其实非常短：

from tensorflow import keras from tensorflow.keras import layers x = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(x) x = layers.MaxPooling2D((2, 2))(x) x = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)

几个核心参数的含义值得花30秒记住：filters是卷积核个数，也就是输出特征图的通道数；kernel_size是核尺寸，一般用(3, 3)；strides默认是1，也就是每次滑动一个像素；padding决定是否补齐边缘；activation常用的就是relu。MaxPooling2D的pool_size是窗口大小，默认strides等于pool_size，所以2×2窗口会把尺寸除以2。

注意事项：Flatten之前的维度一定要提前算。比如 28×28 → 池化 → 7×7×64，Flatten之后是7×7×64 = 3136个数字。如果网络设计不同，这个数也要跟着变，算错了Keras会在 build 时报错，排查起来略费时间。

3. TensorFlow 2.0搭建CNN的标准五步：一份可直接运行的MNIST代码

3.1 加载数据：形状、类型和归一化

这一节我们直接跑一个完整案例，数据集用经典的手写数字MNIST，它自带在keras.datasets里，不需要额外下载文件。

import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers # 1. 加载数据 (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() # 2. 给灰度图补一个通道维度，并把像素归一化到 0~1 x_train = x_train[..., tf.newaxis].astype('float32') / 255.0 x_test = x_test[..., tf.newaxis].astype('float32') / 255.0 print(x_train.shape, y_train.shape) # (60000, 28, 28, 1) (60000,) print(x_test.shape, y_test.shape) # (10000, 28, 28, 1) (10000,)

解释两个关键点。x_train[..., tf.newaxis]是把(60000, 28, 28)变成(60000, 28, 28, 1)，因为Conv2D要求输入有明确的通道维度。astype('float32')也不能省：原始数据是uint8整数，直接除以255虽然结果也是小数，但某些运算下会引发类型不匹配的报错，提前转一下更稳妥。

3.2 定义模型：为什么是"卷积→池化→卷积→池化→全连接"

模型结构如下，我每一层都写了注释：

model = keras.Sequential([ layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(28, 28, 1)), layers.MaxPooling2D((2, 2)), layers.Conv2D(64, (3, 3), activation='relu', padding='same'), layers.MaxPooling2D((2, 2)), layers.Flatten(), layers.Dense(64, activation='relu'), layers.Dense(10, activation='softmax') ]) model.summary()

通道数先32再64，翻倍处理，这是CNN设计的常见经验：空间分辨率减半时，用更多通道来保留信息。两个卷积层之后，特征图已经是7×7×64，用Flatten拉平成向量，再接一个64维的全连接层做特征整合，最后接10维softmax输出十个数字类别的概率。这个网络总参数量大概22万左右，在今天的硬件条件下训练非常快。

为什么要用padding='same'？因为MNIST的28×28会经历池化变成7×7，如果卷积层用valid，每层都会减少2个像素，到第二次池化之后可能只剩5×5，不是不能用，但初学者容易算错。全程用same可以减少这类烦恼，尺寸变化规律更清晰。

3.3 编译与训练：交叉熵、优化器与训练曲线

model.compile( optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'] ) history = model.fit( x_train, y_train, epochs=5, batch_size=64, validation_split=0.1, verbose=1 )

这里有一个初学者很容易混淆的概念：损失函数sparse_categorical_crossentropy和categorical_crossentropy有什么区别？区别只在标签的形式。如果标签是整数，比如7，就用sparse_categorical_crossentropy；如果标签被转成了one-hot编码，比如[0,0,0,0,0,0,0,1,0,0]，就用categorical_crossentropy。我习惯在入门阶段直接用稀疏版本，省一步转换。

validation_split=0.1表示从训练集里拿出10%做验证集，用来观察模型在没见过的数据上的表现。训练完成后，history里保存了每一轮的loss和accuracy，可以画一下训练曲线，判断收敛情况：

import matplotlib.pyplot as plt plt.plot(history.history['loss'], label='train_loss') plt.plot(history.history['val_loss'], label='val_loss') plt.legend() plt.show()

3.4 评估与预测：从概率到类别

test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0) print(f"测试集准确率: {test_acc:.4f}") prob = model.predict(x_test[:1]) # 得到概率分布 pred_class = tf.argmax(prob[0]).numpy() print("预测类别:", pred_class)

model.predict返回的是每个类别的概率，是一个长度为10的向量，要取argmax才是最终类别。测试集只应该拿来评估一次：如果你反复根据测试集结果去调参，模型其实在"背答案"，最终分数会虚高。调参阶段的决策依据应该是验证集，这一点初学者一定要记牢。

课间练习：把MNIST换成CIFAR-10数据集（32×32彩色小图，10个类别），只需要改input_shape和数据加载逻辑；试着把第一层卷积核个数从32改成16或64，看看参数量变化多少、准确率怎么变；在卷积层之间插入一个layers.BatchNormalization()，看看训练收敛速度有没有变化。

4. 训练CNN必然遇到的四个坑：现象、根因与排查流程

4.1 坑一：loss不降甚至变成NaN

新手训CNN最常问的一句话就是"我的loss怎么不动，或者变nan了？"排查是有固定顺序的。

先看数据：打印x_train.min()、x_train.max()和y_train的取值。如果x_train还是0到255的整数，说明忘了归一化；如果标签出现负数或者超出类别范围，那损失函数直接算不出来。再降低学习率试试，Adam默认的学习率是0.001，有些情况下可以改成0.0001看看收敛是否稳定。最后检查网络输出和损失是否匹配，比如做10分类却用了binary_crossentropy，会出现loss数值异常。

我习惯让新人做一个"冒烟测试"：只取32张图训练3个epoch，如果模型能在这32张图上过拟合到接近100%准确率，说明代码逻辑没问题，问题大概率出在数据量或超参数上；如果32张图都学不进去，那才需要深入查代码。

4.2 坑二：训练集精度虚高，验证集持续掉队

训练到第5轮，训练集准确率已经99%，验证集却卡在90%上下，这是典型的过拟合。原因很直接：模型容量大、数据量小、增强不足。

应对手段按优先级排序，先加数据增强：对训练图片做随机翻转、随机旋转、随机缩放，等于用同一批数据造出更多样的样本。这部分增强层只加在训练阶段，验证和测试时不做。再加Dropout：在全连接层前丢弃一部分神经元输出，强制网络不依赖单个特征。最后配合EarlyStopping：验证集指标连续几个epoch不提升就提前停，并恢复最佳权重。

callbacks = [ keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True), keras.callbacks.ModelCheckpoint( 'best_model.h5', save_best_only=True, monitor='val_accuracy' ) ] history = model.fit( x_train, y_train, validation_split=0.1, epochs=50, batch_size=64, callbacks=callbacks )

ModelCheckpoint会在验证集准确率最高时保存权重，后面想继续训练或者拿去做推理都方便。

4.3 坑三：每次训练结果都不一样，不知道信谁

这是随机性在起作用。随机初始化、数据shuffle的顺序、GPU运算的微小浮点误差，都会让两次完全相同代码的训练结果有一点波动。解决办法是固定随机种子：

tf.random.set_seed(42)

但固定随机种子只能让单次实验可复现，不建议用它来把所有波动都消除。更科学的做法是：同一个模型配置跑3到5次，记录准确率的均值和方差，用它们来判断方案好坏。那种"换了个seed准确率掉了2个点，就认定模型不行"的习惯，在深度学习里会误导你做很多无效调参。

4.4 坑四：训练慢、显存不够，怎么定位瓶颈

算法没问题是好事，但训练不跑起来也是白搭。训练慢的定位思路是从大到小排查：先看是不是batch_size太大，显存满载导致OOM，那就调小batch_size，比如从64调到32或16；再看输入图像尺寸是不是太大，把网络输入从256×256改成128×128会省四倍计算量；最后检查网络层数是否过深，入门阶段先跑通第一版，再去追求更复杂的结构。

断点续训也是省时间的实用技巧。用ModelCheckpoint保存的最佳权重，可以直接model.load_weights('best_model.h5')加载回来继续训练。我通常的策略很简单：先用小数据量、小尺寸跑通整个流程，再开全量训练，避免一上来就排错排到崩溃。

5. 小项目实战：猫狗图像分类Demo与迁移学习进阶

5.1 项目设定：数据集组织与加载方式

到了第四节，光跑通MNIST还不够，建议你手动做一个分类Demo感受真实场景。这里以猫狗图像分类为例子，数据按目录组织：

data/ train/ cat/ # 猫的图片 dog/ # 狗的图片 val/ cat/ dog/

用image_dataset_from_directory直接读取目录结构，TensorFlow会自动根据子文件夹名称生成标签。

from tensorflow.keras.utils import image_dataset_from_directory train_ds = image_dataset_from_directory( 'data/train', image_size=(96, 96), batch_size=32, label_mode='binary' ) val_ds = image_dataset_from_directory( 'data/val', image_size=(96, 96), batch_size=32, label_mode='binary' )

不同版本里这个API的路径略有差异，高版本用tf.keras.utils.image_dataset_from_directory，较早的2.0版本可能是tf.keras.preprocessing.image_dataset_from_directory，如果报导入错误就换一下路径。label_mode='binary'会生成0/1标签，适合二分类。

5.2 从零训练一个小型CNN：先拿一个基线

从零搭建一个小型CNN，中间插入数据增强层：

model = keras.Sequential([ layers.RandomFlip('horizontal'), layers.RandomRotation(0.1), layers.RandomZoom(0.1), layers.Conv2D(32, (3, 3), activation='relu', input_shape=(96, 96, 3)), layers.MaxPooling2D((2, 2)), layers.Conv2D(64, (3, 3), activation='relu'), layers.MaxPooling2D((2, 2)), layers.Conv2D(128, (3, 3), activation='relu'), layers.MaxPooling2D((2, 2)), layers.Flatten(), layers.Dropout(0.3), layers.Dense(1, activation='sigmoid') ]) model.compile( optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'] )

先训3到5轮，拿到一个能用的基线结果。这里提前打个预防针：在少量猫狗图片上从零训练小网络，准确率通常不会太高，别怀疑是自己代码写错了。卷积网络每层能学到的特征有限，数据量又不够，90%以上的精度本来就不该指望它实现。

5.3 迁移学习：把预训练模型变成特征提取器

所谓迁移学习，就是借用别人在海量图片上预先训练好的模型，把它的卷积基当作一个现成的"特征提取器"。预训练模型已经见过大量自然图像，边缘、纹理、形状这类通用特征早就学好了，我们只需要在它输出的特征之上，再加一个简单的分类头。

base_model = tf.keras.applications.MobileNetV2( input_shape=(96, 96, 3), include_top=False, weights='imagenet' ) base_model.trainable = False # 冻结卷积基，这步很关键 model = keras.Sequential([ base_model, layers.GlobalAveragePooling2D(), layers.Dropout(0.2), layers.Dense(1, activation='sigmoid') ]) model.compile( optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'] )

这里有两个关键点。include_top=False表示不要预训练模型自带的分类层，只保留卷积特征提取部分；base_model.trainable = False表示冻结这些层，训练时只更新我们新加的分类头参数。等分类头训得差不多了，再解冻最后几层做微调，效果还能再进一步。

5.4 两次实验的对比：参数、精度与训练成本

从零训练和迁移学习的效果差距，用一个示意结果对比一下：

数字不用当作精确结论，不同数据集会有差异，但趋势是稳定的：迁移学习在小数据集上往往能用更少的轮数换来更高的准确率。这也是为什么我强烈建议初学者做图像分类时，先把迁移学习跑通，再回过头去设计自己的小型网络。先有一幅好用的"瑞士军刀"，再去研究刀是怎么打的，学习路径会顺很多。

我自己在实际操作里的体会是，第四节的练习核心不在记住每个API的拼写，而在于建立起"数据形状先于模型结构"的习惯。我给初学者提供三条简单建议：第一次跑代码时，刻意不复制，亲手敲一遍，报错的每一行都值得读两遍；每次实验结束，把模型权重、训练历史曲线、验证准确率存下来，文件名带上日期，后续对比方案会非常省事；别怕在卷积核个数、层数上"乱试"，记录几个不同配置的结果，远比空想哪一个更优有用。

这个系列走到这里，CNN的基本框架你已经握在手里了。下一节可以顺着这条路线把循环网络、自编码器这些内容慢慢补上，但在这之前，最好还是把今天这份MNIST流程亲手跑通，再跟着猫狗分类Demo改一遍代码。把这两个练习做完，你再看任何一篇图像相关的开源项目，至少能立刻看出它的网络结构在干什么、数据是怎么准备的、坑大概会出现在哪里。