简介：这份Python源码案例围绕TensorFlow框架实现手写文字识别，面向希望入门深度学习与图像识别的开发者，尤其适合具备基础Python语法、想通过完整小项目理解卷积神经网络流程的学习者。压缩包共6个文件，包含4个Python源码、1份PDF文档及1个压缩包，整体约2.32MB，源码覆盖数据读取、Softmax回归与卷积神经网络建模、识别预测等环节，PDF可辅助理解原理与实验背景。已有1584人学习下载，说明案例在入门实践中具有一定参考热度。读者可据此梳理从数据预处理、模型搭建、训练调优到保存与测试的完整链路，对照源码理解TensorFlow中网络层、损失函数、优化器和训练循环的写法，并积累手写字符识别的排错思路与项目组织经验，适合作为课程实验、自学练手或后续图像识别项目的起点。

1. 从一张拍歪的作业纸说起：手写文字识别到底难在哪

在 TensorFlow 框架下做手写文字识别，是很多人拿到 Python 源码案例后遇到的第一个具体问题：把源码跑通只要十分钟，但要让它认得出自己拍的那张照片里的字，往往要折腾一周。难点不在网络有多深，而在输入太脏——光照不均、纸面倾斜、笔画粘连、同一个人写的两个字能差出半个字形。这份源码案例要解决的是「单字符手写体分类」这条最短链路：给定一张裁剪好的手写字符图，输出它属于哪一类。它适合三类人：要交毕设或课设、需要一套能讲清结构的完整实现的学生；要把识别能力嵌进表单、答题卡、单据录入流程的从业者；以及想拿一份干净的 TensorFlow 训练—推理骨架做二次改造的开发者。

2. 需求拆解与技术选型：为什么走卷积网络而不是模板匹配

拿到「手写文字识别」这几个字，第一件事不是打开编辑器，而是把需求切成可测量的形状。手写体识别的核心矛盾是类内差异大、类间差异小：同一个类别里，两个人写的「7」可能一个带横一个不带，一个瘦长一个扁平；而不同类别之间，「1」和「7」、「0」和「O」、「6」和「b」在某些笔迹下几乎重合。传统的模板匹配、投影直方图加 SVM 在规整印刷体上还能撑住，一旦遇到连笔、倾斜、笔画粗细变化就大面积崩盘。

卷积网络能自己从像素里学出局部笔画组合，浅层学到边缘和拐角，深层把这些组合成「这个封闭圆环加一竖」之类的结构特征，这是选它的真实理由，不是「深度学习更先进」这种空话。TensorFlow 在这套链路里的优势也很实际：tf.data把数据读取和增强做成可流水线化的图，tf.keras让模型定义短到能一屏看完，SavedModel格式让训练好的模型可以直接被 Python 服务、移动端或其他语言加载。对一份需要被反复阅读、修改、讲解的源码案例来说，这种「每一段都能单独拿出来解释」的结构，比跑分高两个百分点重要得多。

2.1 输入形态决定模型结构：单字符 28×28 与整行切分的边界

先把方案的能力边界划清楚，这是很多方案书翻车的地方。这份源码案例处理的是已经裁剪好的单字符图像，不是整页 OCR。这两者的工程量差一个数量级：整页识别要先做版面分析、文本行检测、字符切分，再把每个字符块送进分类器，是一条两级流水线；单字符分类只负责最后那一级。

表格里第三行是学生最容易误解的一格。把整张照片直接缩到 28×28 喂进模型，结果一定是玄学——不是模型不行，是输入里塞了几十个字，网络根本不知道该看哪一个。方案里通常的做法是：把「检测」和「识别」拆成两个模块，识别模块就用这套源码，检测模块另找轻量方案，两边用统一的图像坐标系对接。

模型的输入尺寸也是被输入形态倒推出来的。28×28 灰度图是这套方案的默认值，好处是参数量小、训练快、CPU 上推理也够用；代价是笔画细节被压缩掉了，细笔画的手写汉字在这个分辨率下容易糊成一团。如果目标类别是汉字，通常会把输入提到 32×32 或 64×64，第一层卷积的 stride 相应调整，其余结构不动。这个改动在源码里只涉及三四处常量，但要同步改预处理、模型输入层、推理时的 resize，漏改一处就会在加载权重时报形状不匹配。

2.2 四个环节：数据、模型、训练、推理

把整条链路摊开，其实只有四个环节，每个环节都有一个明确的产出物。数据环节的产出是一份带标签索引的数据清单，通常是 CSV 或按类别分目录的结构；模型环节的产出是一个可实例化的网络结构；训练环节的产出是 checkpoint 和最终的 SavedModel；推理环节的产出是预测类别加置信度。方案文档里把这四段的接口写清楚，后面无论谁接手都不会迷路。

数据环节最容易被敷衍。真实项目里，类别不平衡是常态——数字「1」的样本量往往是「8」的两三倍，因为采集时大家更爱写简单的字。如果不做处理，模型会偏向多数类，整体准确率看着不错，少数类召回到惨不忍睹。常规做法是分层抽样划分训练集和验证集，再在训练时给损失函数加类别权重，或者在数据管道里做按类别配额的重采样。

模型环节要抵抗住「堆深一点」的诱惑。手写单字符任务的样本量通常在几万到几十万之间，网络一深就过拟合，验证集准确率会在第 10 个 epoch 之后开始掉头。两到三层卷积加池化、后接一两个全连接层的结构，在这个任务上已经能到 98% 以上的验证准确率，再往上的收益递减得很厉害。

训练环节的核心不是循环本身，而是回调：什么时候存盘、什么时候降学习率、什么时候提前停。这三件事决定了你最后拿到的是最好的那一版模型，还是最后一版模型。推理环节的核心是「一致的预处理」——训练时怎么归一化，推理时必须一模一样，否则线下 98%、线上一片错，这是这条链路上最经典的血泪经验。

2.3 环境与依赖版本：先钉死再动手

TensorFlow 的版本兼容性是这条链路上最不讲道理的部分。2.x 的不同小版本之间，tf.data的某些行为、Keras 的保存格式、GPU 与 CUDA 的匹配关系都有变化，同一个脚本在别人机器上跑通、在自己机器上报错，八成是版本漂了。所以第一步不是写代码，是钉版本。

# 建议用虚拟环境隔离，避免和系统里的其他框架冲突 python -m venv venv source venv/bin/activate # Windows 下是 venv\Scripts\activate # 钉死主版本，避免自动升级到不兼容的小版本 pip install "tensorflow==2.15.*" # GPU 版自动包含，需匹配对应 CUDA pip install numpy==1.26.4 pillow==10.2.0 matplotlib==3.8.2 scikit-learn==1.4.0 pip freeze > requirements.txt # 把当前可用状态固化下来

这段脚本的意图很直白：先建隔离环境，再用==加通配的方式锁住主次版本，最后把实际装上的完整版本列表冻结进requirements.txt。参数上有两个注意点：tensorflow==2.15.*里的星号只放开补丁号，主次版本仍然锁定，这比完全不锁安全得多；GPU 用户要额外确认驱动和 CUDA 版本，TensorFlow 2.11 之后 Windows 原生 GPU 支持已经停止，只能走 WSL 或 Linux，这一步没确认清楚，后面所有 GPU 相关的报错都是白费功夫。

提示：把requirements.txt和源码一起交付是方案完整度的一部分。别人拿到你的包，第一条命令是pip install -r requirements.txt，而不是去猜你当时装了什么。

3. 总体架构设计：四层结构与各自的交付物

一份能讲清楚的方案，架构图不必画得花哨，但每一层要有明确的输入输出。这套手写文字识别源码案例按职责切成四层：配置层、数据层、模型层、服务层。配置层管路径和超参，数据层管读取与增强，模型层管结构与训练，服务层管加载与预测。分层的目的不是好看，而是让你在调参的时候只需要动配置层，在换模型的时候只需要动模型层，改动范围可控，方案才好维护。

3.1 目录分层与模块职责

源码案例的目录结构建议直接按功能切，而不是按文件类型切。按类型切（所有 py 放一个文件夹）在文件超过十个之后就没法看了。

这张表里最值得强调的是preprocess.py。预处理函数必须只有一份，训练脚本和推理脚本都 import 它。我见过太多项目在训练脚本里写一套归一化、在推理脚本里另写一套，前者除以 255 后者忘了除，结果模型上线后输出全是同一类，排查了半天才发现是两行代码不一致。把预处理收成一个函数，是这条链路上最便宜的一份后悔药。

配置层用 YAML 而不是硬编码常量，理由是实验要能复现。一次训练用的图像尺寸、批大小、学习率、增强开关，全部落在配置文件里，配合随机种子，别人拿到你的配置和源码就能复现出同一个结果。答辩时被问到「你这个 98.6% 是怎么来的」，你能直接翻出配置文件，这个说服力比口头解释强得多。

3.2 数据流水线：tf.data 与增强策略

数据管道用tf.data而不是自己写for循环，核心原因是它能把读取、解码、增强和批处理做成并行流水线，GPU 不会因为等数据而空转。对几万张 28×28 的小图来说，这个差别不算致命；但一旦换到手写汉字、输入提到 64×64，数据供给就会成为瓶颈，前期用对工具能省掉后面重写一遍的功夫。

import tensorflow as tf AUTOTUNE = tf.data.AUTOTUNE def build_dataset(file_paths, labels, image_size, batch_size, num_classes, training=True): """构建 tf.data 流水线：读图 -> 解码 -> 预处理 -> 增强 -> 批处理 -> 预取""" ds = tf.data.Dataset.from_tensor_slices((file_paths, labels)) def _load(path, label): raw = tf.io.read_file(path) img = tf.io.decode_image(raw, channels=1, expand_animations=False) img = tf.image.convert_image_dtype(img, tf.float32) # 归一化到 [0,1] img = tf.image.resize(img, [image_size, image_size]) # 统一尺寸 label = tf.one_hot(label, num_classes) # 转 one-hot return img, label ds = ds.map(_load, num_parallel_calls=AUTOTUNE) if training: # 轻量增强：位移与旋转，模拟书写位置与倾斜的差异 aug = tf.keras.Sequential([ tf.keras.layers.RandomTranslation(0.08, 0.08), tf.keras.layers.RandomRotation(0.06), tf.keras.layers.RandomZoom(0.08), ]) ds = ds.map(lambda x, y: (aug(x, training=True), y), num_parallel_calls=AUTOTUNE) ds = ds.shuffle(buffer_size=10000, seed=42) # 固定种子便于复现 return ds.batch(batch_size).prefetch(AUTOTUNE)

这段代码的关键在三个地方。第一，decode_image后面紧跟convert_image_dtype，把 0~255 的整型直接映射到 0~1 的浮点，避免后面手写除以 255 时漏掉某个分支。第二，增强层用 Keras 的预处理层而不是自己写 numpy 变换，好处是增强逻辑跟着模型走，导出 SavedModel 时可以把它作为模型的一部分固化进去，线上推理就不会漏做。第三，prefetch(AUTOTUNE)让 CPU 在 GPU 算当前 batch 的时候准备下一批，参数交给 TensorFlow 自己根据可用内存决定缓冲几个批次。

增强的强度要克制。位移 0.08、旋转 0.06、缩放 0.08 这三个数是在 28×28 的尺度上试出来的：再大就会把「6」转成「9」、把「一」平移出画面，模型学到的就是错标签。手写识别的增强和自然图像识别不同，翻转是绝对禁区——水平翻转会把「b」变成「d」，垂直翻转会把「6」变成「9」，这类增强不是帮忙是添乱。

3.3 模型结构：两层卷积加池化的基线网络

基线网络的设计原则是「每一层都能说清楚为什么在这」。两层卷积、两次池化、一次全局池化、一层全连接输出，参数量在十万量级，训练几分钟就能收敛，这是它作为方案基线的最大价值——你能在一顿饭的时间里跑完十组对照实验。

import tensorflow as tf def build_model(image_size=28, num_classes=10): """基线 CNN：适用于 28x28 单通道手写字符分类""" inputs = tf.keras.Input(shape=(image_size, image_size, 1), name="image") # 第一组：32 个 3x3 卷积，捕捉笔画边缘与拐角 x = tf.keras.layers.Conv2D(32, 3, padding="same", activation="relu")(inputs) x = tf.keras.layers.BatchNormalization()(x) # 稳住训练初期的分布 x = tf.keras.layers.MaxPooling2D(2)(x) # 28 -> 14 # 第二组：64 个 3x3 卷积，组合出局部结构 x = tf.keras.layers.Conv2D(64, 3, padding="same", activation="relu")(x) x = tf.keras.layers.BatchNormalization()(x) x = tf.keras.layers.MaxPooling2D(2)(x) # 14 -> 7 x = tf.keras.layers.GlobalAveragePooling2D()(x) # 7x7 -> 64 维向量 x = tf.keras.layers.Dropout(0.3)(x) # 抑制过拟合 outputs = tf.keras.layers.Dense(num_classes, activation="softmax", name="logits")(x) return tf.keras.Model(inputs, outputs, name="handwriting_cnn")

结构说明里几个参数值得逐个讲。卷积核统一用 3×3、padding="same"，保证特征图尺寸只在池化时缩小，尺寸变化一目了然，排查形状问题时少绕弯路。每层卷积后接BatchNormalization，作用是让每批数据的特征分布保持稳定，学习率可以开到 1e-3 而不用小心翼翼地从 1e-5 试起。池化用MaxPooling2D(2)而不是步长卷积，因为手写识别关心的是「这个位置有没有笔画」，最大值比加权平均更贴合这个语义。

GlobalAveragePooling2D替代了传统的Flatten + Dense(128)，这一改动把参数量砍掉一个数量级，同时也降低了过拟合风险；代价是丢掉了一部分空间位置信息，对单字符分类这种「位置不敏感」的任务没什么损失，但如果任务变成「识别一行字」，就不能这么用了。最后的Dropout(0.3)和softmax输出是标配，类别数通过num_classes参数传入，换数据集时只需改配置。

3.4 训练配置与回调：什么时候存盘、什么时候停

训练循环本身没什么可写的，真正决定成败的是三个回调。ModelCheckpoint决定你最终交付哪一版权重，ReduceLROnPlateau决定模型能不能从平台期爬出来，EarlyStopping决定你什么时候停止烧电费。

import tensorflow as tf callbacks = [ # 只保存验证集准确率最高的那一版，而不是最后一个 epoch tf.keras.callbacks.ModelCheckpoint( filepath="outputs/ckpt/best.keras", monitor="val_accuracy", save_best_only=True, mode="max", verbose=1, ), # 验证损失 5 个 epoch 不降就砍一半学习率，最多砍 3 次 tf.keras.callbacks.ReduceLROnPlateau( monitor="val_loss", factor=0.5, patience=5, min_lr=1e-5, verbose=1, ), # 验证损失 12 个 epoch 不降就提前停，并恢复到最优权重 tf.keras.callbacks.EarlyStopping( monitor="val_loss", patience=12, restore_best_weights=True, verbose=1, ), tf.keras.callbacks.TensorBoard(log_dir="outputs/logs"), ] model.compile( optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3), loss="categorical_crossentropy", metrics=["accuracy"], ) model.fit(train_ds, validation_data=val_ds, epochs=50, callbacks=callbacks)

monitor选val_accuracy还是val_loss值得说一句。存盘用准确率，因为它是你最终要汇报的指标；早停用损失，因为损失比准确率更平滑，能在准确率还没明显掉头时就发出预警。这两个指标分工不同，混用会导致早停触发得太晚。patience的取值和数据集规模相关：样本量小的时候损失波动大，patience=12可能偏短；样本量大、曲线平滑时可以降到 6~8。restore_best_weights=True这个参数千万别漏，漏了的话EarlyStopping只是停下训练，模型里留的是最后一轮的权重，前面存的best.keras就白存了。

4. 关键模块实现：预处理、训练、推理三段怎么接

结构定下来之后，真正决定这套源码能不能被别人直接用的，是三个衔接点：预处理函数是否唯一、训练产出的模型格式是否标准、推理接口是否好调用。这三点做扎实，方案就从「一份能跑的代码」变成「一套能交付的东西」。

4.1 图像预处理：从任意尺寸到 28×28 黑底白字的归一化

训练数据通常是黑底白字（类似 MNIST 的存储格式），而用户拍的照片是白底黑字。这一个反色差异，能让训练准确率 99% 的模型在现场识别率跌到 10% 以下。预处理函数必须把这件事显式处理掉。

import numpy as np from PIL import Image def preprocess_image(path_or_array, image_size=28, invert_if_needed=True): """训练与推理共用的唯一预处理入口，保证线上线下一致""" if isinstance(path_or_array, str): img = Image.open(path_or_array).convert("L") # 强制转单通道灰度 else: img = Image.fromarray(path_or_array).convert("L") arr = np.asarray(img, dtype=np.float32) if invert_if_needed: # 判断底色：四角均值偏亮说明是白底黑字，需要反色 corners = np.concatenate([arr[:5, :5].ravel(), arr[:5, -5:].ravel(), arr[-5:, :5].ravel(), arr[-5:, -5:].ravel()]) if corners.mean() > 127: arr = 255.0 - arr arr = arr / 255.0 # 归一化到 [0,1] arr = np.asarray(Image.fromarray((arr * 255).astype(np.uint8)) .resize((image_size, image_size), Image.LANCZOS), dtype=np.float32) / 255.0 return arr[..., np.newaxis] # 补通道维 -> (H, W, 1)

这段函数的逻辑顺序是有讲究的：先转灰度，再判断反色，最后才缩放。反色判断放在缩放之前，是因为缩放会把四角的像素和中心混在一起，底色判断就不准了。四角取样用 5×5 的小块而不是单个像素，是为了抗噪——照片角落偶尔有个黑点，单像素判断会误判成黑底。缩放用LANCZOS而不是默认的双线性，笔画细节保留得更好一些，代价是稍慢，对单图推理来说可以忽略。

最后补通道维这一步经常被忘。模型的输入形状是(28, 28, 1)，如果预处理返回(28, 28)，model.predict会在第一层卷积报维度错误。这个错误信息不太友好，新手容易卡在这里。函数把补维做在内部，调用方就不用关心了。

4.2 训练脚本骨架与损失函数选择

训练脚本要做的事情就是「读配置 → 建数据 → 建模型 → 编译 → 训练 → 导出」，每一步一行到几行，不要塞额外逻辑。脚本越短，别人读源码的成本越低。

import yaml, tensorflow as tf from data.dataset import build_dataset from models.cnn import build_model with open("configs/default.yaml", "r", encoding="utf-8") as f: cfg = yaml.safe_load(f) train_ds = build_dataset(cfg["train_paths"], cfg["train_labels"], cfg["image_size"], cfg["batch_size"], cfg["num_classes"], True) val_ds = build_dataset(cfg["val_paths"], cfg["val_labels"], cfg["image_size"], cfg["batch_size"], cfg["num_classes"], False) model = build_model(cfg["image_size"], cfg["num_classes"]) model.compile( optimizer=tf.keras.optimizers.Adam(cfg["lr"]), loss=tf.keras.losses.CategoricalCrossentropy(label_smoothing=0.05), metrics=["accuracy"], ) model.fit(train_ds, validation_data=val_ds, epochs=cfg["epochs"], callbacks=callbacks) # 导出为 SavedModel，推理端不需要原始模型代码 model.export("outputs/saved_model/1")

损失函数选了带label_smoothing=0.05的交叉熵，理由值得解释。手写数据里存在标注噪声——同一个潦草的字，不同标注员给出的标签可能不同。硬标签会逼模型对这些样本输出接近 1 的概率，模型只能靠记忆硬背，泛化变差。标签平滑把目标概率从 1.0 压到 0.95 左右，等于告诉模型「别太自信」，实测在小样本手写数据集上能把验证准确率提 0.3~0.8 个百分点。

导出用model.export()而不是model.save()，是因为前者产出的是标准的 SavedModel 目录，包含签名信息，可以被 TensorFlow Serving、TF.js、TFLite 转换器直接消费；后者在 Keras 3 下产出的是.keras归档，适合继续训练但不适合部署。这两个接口的差异在方案文档里要写清楚，否则接手的人会拿.keras去部署，然后在这一步卡住。

4.3 推理封装：把模型接成一个函数

推理脚本的价值不在于能跑，而在于别人能三行调用。封装成类，加载一次模型，之后反复调用，这是最基本的工程习惯。

import numpy as np, tensorflow as tf from data.preprocess import preprocess_image class HandwritingRecognizer: def __init__(self, model_dir, labels, image_size=28): self.model = tf.saved_model.load(model_dir) # 只加载一次 self.infer = self.model.signatures["serving_default"] self.labels = labels # 类别索引 -> 字符 的映射 self.image_size = image_size def predict(self, path_or_array, top_k=3): arr = preprocess_image(path_or_array, self.image_size) batch = np.expand_dims(arr, 0).astype(np.float32) # (1, H, W, 1) logits = self.infer(tf.constant(batch)) # 走签名，不依赖原始代码 probs = list(logits.values())[0].numpy()[0] top_idx = np.argsort(probs)[::-1][:top_k] return [{"label": self.labels[i], "score": float(probs[i])} for i in top_idx]

三个设计点。第一，模型在__init__里加载，不在predict里加载——每次预测都重新load会让单张推理从毫秒级变成秒级，这是最常见的性能翻车点。第二，走signatures["serving_default"]而不是直接调model(...)，这样推理端完全不依赖原始模型定义代码，模型换了结构只要签名不变，调用方一行不用改。第三，返回 top-k 而不是单个结果，前端可以展示候选让用户确认，对识别置信度低的样本特别有用——置信度低于 0.6 的样本，通常的做法是直接转人工复核，而不是硬猜。

4.4 结果可视化：混淆矩阵比总准确率更能说明问题

只报一个总体准确率，在答辩现场是撑不住的。评审老师一句「哪几类容易混」就能问住。混淆矩阵能把这个答案直接画出来，同时暴露数据集的类别不平衡问题。

import numpy as np, matplotlib.pyplot as plt from sklearn.metrics import confusion_matrix, classification_report def plot_confusion(y_true, y_pred, labels, save_path="outputs/confusion.png"): cm = confusion_matrix(y_true, y_pred, normalize="true") # 按真实类别归一化 fig, ax = plt.subplots(figsize=(8, 8)) im = ax.imshow(cm, cmap="Blues") ax.set_xticks(range(len(labels)), labels, rotation=45) ax.set_yticks(range(len(labels)), labels) ax.set_xlabel("预测类别"); ax.set_ylabel("真实类别") for i in range(len(labels)): for j in range(len(labels)): ax.text(j, i, f"{cm[i, j]:.2f}", ha="center", va="center", color="white" if cm[i, j] > 0.5 else "black", fontsize=8) fig.colorbar(im); fig.tight_layout(); fig.savefig(save_path, dpi=150) print(classification_report(y_true, y_pred, target_names=labels, digits=3))

normalize="true"这个参数是关键：按行归一化后，每一格表示「真实为 A 的样本中有多少被预测成 B」，这样即使各类样本量悬殊，矩阵也不会被多数类主导。归一化之后对角线上的数字直接就是各类召回率，比classification_report里的数字更直观。配色上用了cm[i, j] > 0.5切换文字颜色，是为了让深色格子里的数字还看得清，这种细节在答辩投影仪上很重要。

5. 常见问题排查：这套源码最容易被改坏的五个地方

5.1 训练损失不降，卡在 2.3 附近一动不动

现象是前几个 epoch 损失几乎是一条水平线，准确率贴着随机猜测的水平。原因九成是标签错位：数据清单里的文件路径和标签列对不上，或者label转 one-hot 时索引从 1 开始而模型输出从 0 开始。解决方法是先做一次极小样本过拟合测试——取 20 张图、固定不洗牌，让模型训 200 个 epoch，如果损失降不到 0.01 以下，说明数据管道本身有问题，先把管道修好再谈调参。这一步能筛掉一半的「模型不收敛」问题。

5.2 验证准确率 99%，一上真实照片就全错

现象是离线指标漂亮，换成手机拍的照片识别率不到两成。原因是域差异：训练集是规整的黑底白字，实测数据是白底黑字、有阴影、有倾斜、笔画更细。解决办法分两层，输入层用 4.1 里的反色判断和灰度归一化兜住底色差异，数据层在训练时加入亮度扰动、对比度扰动和高斯噪声，让模型见过脏数据。如果实测场景固定，最有效的做法是从真实场景采集几百张图，人工标注后混进训练集做微调，效果比任何增强策略都直接。

5.3 训练跑到一半显存爆掉

现象是前几个 epoch 正常，跑到中途报ResourceExhaustedError。原因通常是数据管道里的增强在 GPU 上做、或者prefetch的缓冲设得太大，加上验证集评估时又额外占了一块显存。解决办法是把增强层放到 CPU 上执行（with tf.device('/cpu:0')包住 map 操作），prefetch的缓冲从AUTOTUNE改成固定值 2~4，批大小从 128 降到 64 再试。显存占用是玄学，同样的代码在不同驱动版本下峰值能差 20%，所以要留出余量而不是压着上限跑。

5.4 保存的模型加载时报形状不匹配

现象是tf.saved_model.load或load_model抛出维度相关的异常。原因有两种：一是保存的是权重而非完整模型，加载时重建的网络结构和保存时不一致（比如多了一层 BN）；二是图像尺寸改了，但只改了模型的Input没改预处理里的resize目标。解决办法是统一走model.export()导出完整 SavedModel，把输入签名固定下来；同时在配置里只保留一个image_size字段，预处理和模型都从它读，杜绝两处各写一个数字。

5.5 单张推理要等两三秒

现象是服务启动后第一次预测特别慢，之后偶尔又慢一下。原因是模型在每次调用时重新加载，或者每次都重建了计算图。解决办法是把模型加载放在服务初始化的钩子里，只做一次；批量预测时把多张图堆成一个 batch 一次性送进去，比循环调用快一个数量级。如果确实需要低延迟，把 SavedModel 转成 TFLite 量化版本，在 CPU 上单张推理能压到十毫秒以内，代价是准确率掉 0.2~0.5 个百分点，这个交换在多数业务场景里是划算的。

6. 验收与答辩：怎么证明这套识别方案真的跑通了

验收这件事，最忌讳只拿一个总体准确率说话。我给自己的标准是三层：第一层跑得通，第二层指标站得住，第三层异常能被解释。三层都过，这套方案才算交付。

工程层是最容易被跳过、也最容易被问倒的一层。答辩现场如果评审老师说「你现在从零跑一遍」，能不能在十分钟内装好依赖、启动训练、导出模型、跑出一次预测，直接决定了方案的成色。我的习惯是把 README 写成一份可执行的清单：环境、数据放置、训练命令、评估命令、推理示例，每一步都附上预期输出。写完自己按清单在干净环境里走一遍，走不通就改清单，不要改完代码就默认别人也能跑。

指标层要主动交出混淆矩阵，而不是等被问。主动说明「这几类容易混，原因是笔画结构接近，我们通过增强和类别权重把最差类的召回从 88% 提到了 93%」，这个叙述比单纯报数字有说服力得多。泛化层建议现场演示：拿手机拍一张手写数字，走一遍预处理加推理，把 top-3 结果和置信度都显示出来。哪怕识别错了，只要能解释「这张图笔画粘连严重，置信度只有 0.42，按设计应该转人工」，反而是加分项——说明你想过失败路径。

性能层的数字要提前测，别在现场跑。CPU 单张推理的耗时和机器强相关，在答辩机器上现测可能得到一个难看的数字。提前在自己机器上测好 100 次的均值和中位数，说明测试环境，给一个区间而不是一个精确到小数点的承诺。

还有一个常被忽略的技巧：准备一份「可复现的最小样例」。里面只放 20 张图、一个训练 3 个 epoch 就能收敛的配置，跑完不到一分钟。当评审老师想验证你的训练流程时，用它比用完整数据集快得多，也更容易展示每一步的中间产物。我把这份最小样例放在仓库根目录的demo/下，和主流程共用同一套代码，只是配置不同——这样既证明了代码的通用性，又避免了现场等待的尴尬。

从那以后我每次交这类识别方案，都会强制自己按「干净机器跑一遍」这条走一遍，哪怕时间再紧也不省这一步。翻车往往不发生在模型上，发生在那一行忘记写进 README 的命令里。希望帮到你。

本文还有配套的精品资源，点击获取