简介：基于深度学习的自动图像着色项目是一套可直接用于本科毕业设计或课程设计的完整源码包，面向计算机、人工智能、自动化等专业学生，侧重CNN卷积神经网络在图像修复与着色任务中的落地实现。项目共28个文件，压缩包仅3.36MB，除8个Python核心脚本（训练、推理、数据切分）外，还有4个YAML环境配置、6个TXT场景数据列表、3个Markdown说明文档、示例效果图与Jupyter笔记，覆盖模型训练、数据集准备、推理着色、环境依赖等完整流程，目录分层清晰，便于定位修改。所有代码均已测试通过，下载后按说明配置即可运行，无需额外调试，能够支撑答辩展示或课程汇报。目前已有44人浏览学习，适合需要快速搭建图像着色演示项目的初学者或时间紧张的应届生作为起步模板。
1. 自动图像着色：一个能快速出成果、又足够写深度的毕设方向
如果你手头有一个深度学习相关的毕业设计或课程设计，时间紧、又希望答辩时有直观的演示效果，那「基于深度学习的自动图像着色」属于性价比很高的方向。它做的事情很直接：输入一张灰度图，模型输出一张彩色图。视觉效果一眼就能看出来，评审老师不需要听太多背景就能理解你在做什么。这套方案的技术链路也足够完整，从数据处理、模型搭建到训练和推理，每一环都能在论文里写出内容。
我见过不少同学选这个方向，但翻车的也不少。最常见的不是模型跑不起来，而是跑起来了但颜色灰蒙蒙、轮廓糊成一团，或者训练到一半显存爆掉。这篇文章把我自己做这个方向时验证过的路线写清楚，从选型、数据、训练、部署到避坑，照着做下来，至少能拿到一个稳定出彩色结果的版本。
2. 先选对方案：为什么毕设首选 U-Net 回归，而不是 GAN 或扩散模型
2.1 三种着色路线对比，各自代价在哪里
自动图像着色在深度学习领域主要有三条技术路线。第一条是把着色当成回归问题：输入灰度图，直接预测每个像素的颜色值，典型结构是 U-Net，损失函数用 L1 或 L2。第二条是生成对抗式，典型结构是 pix2pix 那种 U-Net 加判别器，用对抗损失让颜色更逼真。第三条是扩散模型，先加噪再逐步去噪，效果目前最好，但训练和推理代价也最大。
对毕设来说，我一般会直接建议选第一条路线，原因不是它最先进，而是它最稳。回归模型的训练过程非常可控，损失曲线和输出结果高度相关，出了问题容易排查。GAN 路线的问题是训练不稳定，判别器和生成器互相博弈，经常出现损失上下震荡但图像完全没变化的情况，这对时间有限的毕设来说是灾难。扩散模型的问题更明显，一张 256×256 的图跑一次推理需要迭代几十步，没有好显卡时一张图要等半分钟以上，单是「演示流畅」这一条就很难满足。
另外还要考虑论文工作量。回归路线的损失函数设计、颜色空间选择、感知损失加权都是现成的写作素材，答辩时能讲清楚每一个设计决策。GAN 路线如果只套一个现成模型，论文里能写的东西反而更少。
2.2 Lab 颜色空间与 U-Net 结构：着色问题的标准拆解方式
着色任务的难点在于输入的灰度图和输出的彩色图之间存在一对多的映射关系，同样一张灰度图，天空可能被涂成蓝色，也可能被涂成夕阳的橙红色，模型很难确定哪一种是对的。为了让模型更容易学习，常见做法是把图像转换到 Lab 颜色空间，L 通道表示亮度，a 和 b 通道表示颜色。训练时把 L 通道作为输入，让模型预测 a、b 两个通道，最后再把预测结果和输入的 L 合并回彩色图。
为什么不用 RGB 空间直接回归？因为 RGB 三个通道之间存在强相关性，模型需要同时学会三个通道的分布，而 Lab 空间把亮度信息单独分开，模型只需要专注颜色预测，难度会明显下降。我自己的实验里，同样一套 U-Net，RGB 直接回归出来的图总有偏色，而 Lab 空间下颜色更干净。
模型结构上，U-Net 是这类任务的主力。它由编码器和解码器组成，编码器逐层下采样提取语义特征，解码器逐层上采样恢复图像尺寸，中间用 skip connection 把编码器每一层的信息直接拼到解码器对应层上。这个设计的价值在于，图像着色既要全局语义（这张图是天空，应该偏蓝），也要局部细节（同一张图里树叶的纹理不能糊），skip connection 能保证小结构信息不丢失。
2.3 效果排序：从 L1 到感知损失，哪些改动对颜色影响最大
模型输出的颜色质量和损失函数的关系最直接。我按投入产出比排序，第一个必加的是 L1 损失，也就是预测值和真实值之间绝对误差的均值。L1 比 L2 更适合图像生成，因为 L2 对像素偏差求平方，会把大误差放大，模型为了降低损失倾向于输出模糊的平均色，L1 则能保留更多锐利边缘。
第二个值得加的是感知损失，做法是把预测图和真实图同时送进一个预训练好的 VGG 网络，在中间层特征图上计算 L1 距离。它衡量的是两张图在高层语义上像不像，而不是逐个像素对不对。加了感知损失后，图像的纹理和物体边界会自然很多，颜色块的边缘不会像水彩晕染。第三个可选的是总变差正则，用来抑制颜色噪点，但作用没有前两个明显。
GAN 路线里的判别器可以作为高阶选项，它能让颜色更鲜艳，但代价是训练时间翻倍、稳定性下降。我的建议是先把 U-Net 加 L1 加感知损失这条组合跑通，如果出图质量已经符合预期，就不需要再上 GAN；如果评审老师关心颜色真实性，再在模型后面挂一个判别器做消融对比。
3. 数据与训练：从图片集到能出彩色图的完整流程
3.1 数据从哪里来，怎么预处理成 Lab 格式
训练数据的选择直接影响最终效果。你不需要专门去找「灰度-彩色」配对数据集，因为所有普通彩色图片都可以作为训练数据，只要在读取时主动丢弃颜色信息生成灰度版本就行。常见做法是收集一到两个公开的图片数据集，或者自己整理一批高清照片，内容最好覆盖风景、人物、建筑、动物等常见类别，让模型见过足够多的颜色分布。
数据量上，我自己的经验是两万张以上就能有明显效果，三五万张效果比较均衡。太少的话模型会把所有图都涂成一种色调，太多的话训练时间会拉长到没法接受。图片统一缩放到 256×256 再训练，这个分辨率下模型能看清华丽的细节，显存占用也还能接受。
预处理分三步走：第一步读图、缩放、去归一化；第二步把 RGB 转成 Lab；第三步拆分 L 和 ab 通道。所有图片都读取后统一转成张量，L 通道作为模型输入，ab 通道作为回归目标。下面这段是数据读取和预处理的核心逻辑：
import cv2 import numpy as np import torch from torch.utils.data import Dataset class ColorizationDataset(Dataset): def __init__(self, img_paths, size=256, split="train"): self.img_paths = img_paths self.size = size self.split = split def __len__(self): return len(self.img_paths) def __getitem__(self, idx): img = cv2.imread(self.img_paths[idx]) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img = cv2.resize(img, (self.size, self.size), interpolation=cv2.INTER_LINEAR) # 归一化到 [0, 1] 再转 Lab，Lab 范围变化比 RGB 更温和 img = img.astype(np.float32) / 255.0 lab = cv2.cvtColor(img, cv2.COLOR_RGB2Lab) L = lab[:, :, 0] # 亮度通道，唯一输入 ab = lab[:, :, 1:] # 颜色通道，预测目标 L = torch.from_numpy(L).unsqueeze(0) # 加通道维，形状 (1, 256, 256) ab = torch.from_numpy(ab).permute(2, 0, 1) # 形状 (2, 256, 256) # 数据增强：水平翻转，对颜色任务有效且实现简单 if self.split == "train" and np.random.rand() > 0.5: L = torch.flip(L, dims=[2]) ab = torch.flip(ab, dims=[2]) return L, ab这段代码的关键点有三个：一是先归一化到 [0,1] 再转 Lab，因为 OpenCV 在输入浮点数时对 Lab 通道的数值范围有不同要求，顺序反了会出现通道值扭曲；二是 L 通道直接作为输入，不需要再减均值归一化，它本身就在合理范围；三是只有训练集做数据增强，验证集保持原始方向，否则验证结果会和训练时的图像分布不一致。
3.2 U-Net 模型搭建：一份足以跑通的袖珍结构
完整版 U-Net 代码量在两百行左右，适合毕设直接写在论文附录里。这里给一个精简但完整的版本，去掉了 BN 层调参，保留了核心的卷积块，训练和推理都能直接用。编码器四层下采样，解码器四层上采样，最底层为 512 通道，输出层用 Tanh 把预测值映射到 Lab 的 a、b 通道范围。
import torch import torch.nn as nn class DoubleConv(nn.Module): def __init__(self, in_ch, out_ch): super().__init__() self.conv = nn.Sequential( nn.Conv2d(in_ch, out_ch, 3, padding=1), nn.BatchNorm2d(out_ch), nn.ReLU(inplace=True), nn.Conv2d(out_ch, out_ch, 3, padding=1), nn.BatchNorm2d(out_ch), nn.ReLU(inplace=True), ) def forward(self, x): return self.conv(x) class UNet(nn.Module): def __init__(self, in_ch=1, out_ch=2): super().__init__() # 编码器，通道数逐层翻倍 self.enc1 = DoubleConv(in_ch, 64) self.enc2 = DoubleConv(64, 128) self.enc3 = DoubleConv(128, 256) self.enc4 = DoubleConv(256, 512) # 编码器每层之后接一个最大池化，完成下采样 self.pool = nn.MaxPool2d(2) # 瓶颈层 self.bottleneck = DoubleConv(512, 512) # 解码器，每层先把特征图上采样，再拼接对应编码器输出 self.up4 = nn.ConvTranspose2d(512, 256, kernel_size=2, stride=2) self.dec4 = DoubleConv(512, 256) self.up3 = nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2) self.dec3 = DoubleConv(256, 128) self.up2 = nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2) self.dec2 = DoubleConv(128, 64) self.up1 = nn.ConvTranspose2d(64, 32, kernel_size=2, stride=2) self.dec1 = DoubleConv(64, 32) # 输出层，Tanh 将输出约束在 [-1, 1]，方便映射回 ab 通道 self.out = nn.Conv2d(32, out_ch, 1) self.tanh = nn.Tanh() def forward(self, x): e1 = self.enc1(x) e2 = self.enc2(self.pool(e1)) e3 = self.enc3(self.pool(e2)) e4 = self.enc4(self.pool(e3)) b = self.bottleneck(self.pool(e4)) d4 = torch.cat([self.up4(b), e4], dim=1) d4 = self.dec4(d4) d3 = torch.cat([self.up3(d4), e3], dim=1) d3 = self.dec3(d3) d2 = torch.cat([self.up2(d3), e2], dim=1) d2 = self.dec2(d2) d1 = torch.cat([self.up1(d2), e1], dim=1) d1 = self.dec1(d1) return self.tanh(self.out(d1))这份模型里能动手调的设计点有三个：通道数从 64 起步，显存不够时改成 32 可以把显存占用降到四分之一；上采样用了转置卷积，也可以换成双线性插值加普通卷积，后者棋盘格伪影会轻一些，但训练稍慢；输出用了 Tanh，范围是 [-1,1]，后面做损失计算时要把真实 ab 通道归一化到同一范围，两边范围不一致是新手最容易犯的错。
模型训练前还需要一个感知损失的网络，做法是加载一个在 ImageNet 上预训练好的 VGG16，截取前面几个卷积层的输出做特征比较。注意 VGG 需要先冻结参数，它只作为特征提取器，不再参与梯度更新。
3.3 训练脚本与参数设定：照搬能跑，改参有依据
训练脚本的主体就是标准的 PyTorch 循环：前向传播、算损失、反向传播、更新参数。这里把 L1 损失和感知损失组合在一起，总损失等于 color_loss 加上 weight 倍的 perceptual_loss。感知损失的 weight 设在 0.1 到 0.5 之间比较合理，太高会让模型过度关注纹理而忽略颜色，太低则加了等于没加。
import torch import torch.nn as nn from torch.utils.data import DataLoader from torchvision import models def perceptual_loss(pred, target, vgg): # 输入范围必须是 ImageNet 归一化后的分布，vgg 才能正确提取特征 mean = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1).to(pred.device) std = torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1).to(pred.device) # 把单通道复制成三通道，灰度图在语义上等价于三通道相同值 pred_rgb = pred.repeat(1, 3, 1, 1) target_rgb = target.repeat(1, 3, 1, 1) pred_norm = (pred_rgb - mean) / std target_norm = (target_rgb - mean) / std # 取 relu1_2 和 relu2_2 两个中间层特征 features_pred = vgg(pred_norm) features_target = vgg(target_norm) return nn.functional.l1_loss(features_pred, features_target) # 参数设置 LEARNING_RATE = 1e-4 BATCH_SIZE = 16 EPOCHS = 30 PERCEPTUAL_WEIGHT = 0.1 model = UNet().cuda() vgg = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1).features[:17].eval().cuda() # 冻结 vgg，不参与训练 for param in vgg.parameters(): param.requires_grad = False optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5) # ab 通道经 tanh 输出后范围是 [-1, 1]，真实值也做同样的归一化处理 def normalize_ab(ab_tensor): return (ab_tensor / 110.0) # Lab 的 a、b 范围约为 [-110, 110]，缩放到 [-1, 1]训练参数不是越大越好。学习率设在 1e-4 是个稳妥值，超过 5e-4 常遇到损失值跳到 NaN；batch size 取决于显存，16 需要 8GB 以上显存，6GB 显存就改成 8，4GB 显存改成 4。训练轮次 30 轮是一个经验值，通常跑到第 25 轮附近验证损失就基本平稳了，再往下练容易过拟合到训练集特有的色调。每训练完一个 epoch 保存一次 checkpoint，文件名带上 epoch 编号，这样如果后面跑了过了头还能回退到效果更好的中间版本，这是你少有的后悔药。
学习率调度器用固定步长衰减即可，每 10 轮减半。这种简单策略比余弦退火更好用，因为它行为可预期，论文里也容易描述。训练过程中建议每 5 个 epoch 手动拿一两张验证图看一眼输出，只看损失曲线不看图，是新手最常见的盲区，很多翻车损失曲线看着正常，实际颜色已经糊了。
4. 推理与部署：从 checkpoint 到能双击运行的着色工具
4.1 推理脚本：载入模型、跑前向、拼回彩色图
训练完成后，你需要一个干净的推理脚本。它的逻辑和训练时的预处理正好相反：读灰度图，转成 Lab 取 L 通道，过模型得到 ab 预测，再把 L 和 ab 拼接回 Lab，转成 RGB 保存。这里有个关键细节：推理时输入的灰度图是用户给的，它可能是单通道的纯灰度图，也可能是三通道但看起来是黑白的图，两种情况都要先统一转成三通道再走流程。
import cv2 import numpy as np import torch from model import UNet def colorize(gray_img_path, model_path, output_path, device="cuda"): # 读取灰度图，无论原图是单通道还是三通道都统一转 RGB img = cv2.imread(gray_img_path) if img is None: raise ValueError("图片路径无效，请检查文件是否存在") if len(img.shape) == 2: img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB) else: img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # 预处理：缩放、归一化、转 Lab、取 L 通道 img = cv2.resize(img, (256, 256), interpolation=cv2.INTER_LINEAR) img = img.astype(np.float32) / 255.0 lab = cv2.cvtColor(img, cv2.COLOR_RGB2Lab) L = lab[:, :, 0] L_tensor = torch.from_numpy(L).unsqueeze(0).unsqueeze(0).to(device) # 加载模型权重，必须先实例化再 load，否则参数名对不上 model = UNet().to(device) state_dict = torch.load(model_path, map_location=device) if "state_dict" in state_dict: state_dict = state_dict["state_dict"] # 去掉 DataParallel 带来的 module 前缀，防止键名不匹配 state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()} model.load_state_dict(state_dict) model.eval() with torch.no_grad(): pred_ab = model(L_tensor).squeeze(0).cpu().numpy() # (2, 256, 256) # 反归一化并拼回 L 通道 pred_ab = pred_ab * 110.0 L = lab[:, :, 0] pred_lab = np.concatenate([L[:, :, np.newaxis], pred_ab.transpose(1, 2, 0)], axis=-1) pred_rgb = cv2.cvtColor(pred_lab.astype(np.float32), cv2.COLOR_Lab2RGB) pred_rgb = (np.clip(pred_rgb, 0, 1) * 255).astype(np.uint8) pred_bgr = cv2.cvtColor(pred_rgb, cv2.COLOR_RGB2BGR) cv2.imwrite(output_path, pred_bgr) print(f"着色完成，结果已保存到 {output_path}")推理脚本里最值得注意的就是模型的加载方式。训练时如果用了 CUDA 和多卡，保存的 checkpoint 键名里会带module.前缀，直接 load 会报 missing key 的错误。上面代码里做了两次容错：先取 state_dict 字段，再做键名清理，这套处理在大多数开源工程里都适用。推理时务必开启torch.no_grad()，否则显存和耗时都会翻倍，没有任何额外收益。
4.2 交互界面：开发调试用 Gradio，离线演示用 Tkinter
如果你希望老师或同学能直接拖图片进来看效果，而不是在命令行里敲路径，那就要加一个图形界面。开发阶段我建议用 Gradio，它写起来最短，启动后浏览器里就能交互，还自带一个上传控件，适合快速验证模型效果。
import gradio as gr import numpy as np from colorize import colorize def gradio_predict(input_img): # Gradio 传入的是 RGB 格式的 numpy 数组，保存成临时文件再走统一流程 temp_path = "temp_input.png" cv2.imwrite(temp_path, cv2.cvtColor(input_img, cv2.COLOR_RGB2BGR)) output_path = colorize(temp_path, "best_model.pth", "temp_output.png", device="cuda") return cv2.cvtColor(cv2.imread(output_path), cv2.COLOR_BGR2RGB) gr.Interface( fn=gradio_predict, inputs=gr.Image(label="上传灰度图"), outputs=gr.Image(label="着色结果"), title="自动图像着色 Demo", ).launch()Gradio 的上限是开发环境，到了答辩现场如果网络不稳定、浏览器打不开，就会非常被动。所以我还留了一手：用 Tkinter 写一个纯本地窗口应用，不依赖浏览器。Tkinter 是 Python 自带的 GUI 库，双击启动不需要额外服务，打包也方便。界面就一个按钮一个显示区，点击选择图片，模型跑完把结果显示在窗口右侧。
4.3 打包成可执行程序：PyInstaller 实测能过的一套配置
标题里写了「简单部署即可运行」，那最理想的交付物就是一个 exe 或可执行文件。用 PyInstaller 打包 PyTorch 程序的坑不算少，但都有解。先说打包命令，常用的是一句话命令加若干参数：--hidden-import用来兜住 PyTorch 运行时的动态导入模块，--add-data用来把模型权重文件打进包里。
实际打包时，我建议先打包成目录模式--onedir，不要一开始就打包成单文件--onefile。目录模式启动快、排错容易，单文件模式每次启动都要解压临时文件，模型加载时间会多好几秒，而且一旦报错很难定位。答辩场景下，把目录打包成 zip 发给别人解压使用，体验完全够。None
还有一个必踩的坑是 cv2 在打包后可能报找不到视频解码器的错，这是 OpenCV 包体积太大导致 PyInstaller 漏绑组件。解决办法是显式加入 opencv 的 dll 目录，或者在代码里引入一句import cv2后再单独做一次from cv2 import *这类强制导入。我一般直接在 spec 文件里把 cv2 的特定二进制文件路径加进 binaries，这样最干净。
如果希望部署更轻量，可以先把模型导出为 ONNX 格式，然后用 ONNX Runtime 做推理。这样整个部署包能缩小一半以上，因为不再需要带着完整的 Torch 库。导出时要注意 U-Net 里的转置卷积在 ONNX 里的输出 shape 和 PyTorch 略有差异，用 opset 版本 15 以上做导出在我验证过的范围内是稳定的。但如果你的目标环境是偶尔跑一下看看效果，不追求极致体积，那直接带 Torch 打包反而省事，不用担心算子兼容问题。
5. 自动图像着色的常见坑与排查：训练不收敛、颜色偏灰、显存不够的完整处理
5.1 损失正常下降，但输出图片全是灰蒙蒙一片
这个现象在着色任务里非常典型。你看着训练损失在稳步下降，但拿一张验证图出来，整张图就是不同深浅的灰色，几乎看不到彩色。原因是模型发现了一个作弊解：把所有像素的颜色都预测成接近零，即输出接近灰色，此时 L1 损失已经足够低，因为灰色是每种颜色的平均值。
应对方法有两个角度。第一是检查输出层的激活函数和真实值的范围是否匹配，如果模型输出用了 Tanh 而真实 ab 通道没有归一化到 [-1,1] 范围，损失值会被拉得很大，模型为了降低损失只能往中间值 0 靠。第二是检查训练数据本身，如果数据里黑白图片、灰暗图片占比过多，模型学到的颜色分布就会整体偏移。我自己的做法是把训练集里明显过暗的图片筛掉，再把 L 通道做了随机亮度扰动，让模型不能只靠猜测灰度值赚钱。
如果上面两条都排查过还是灰，就考虑把感知损失的权重提高。感知损失对纯灰图像和真实彩色图像的特征响应有明显差异，权重提高后模型会被迫产出更有色彩变化的结果，但这个值不能高于 1.0，否则会出现色彩过饱和的噪点。
5.2 训练集上颜色鲜艳，测试图却偏色严重
训练集效果好、测试集效果差，说明模型过拟合了训练集里的色彩分布。图像着色模型很容易记住训练集统计特征，比如如果训练集里大量图片是绿色植物和蓝天，模型看到浅灰色就倾向于涂绿色或蓝色，遇到不常见的灰度分布时颜色就会跑偏。
解决思路是扩充训练集类别多样性，并加强颜色相关的数据增强。我自己验证过有用的一条是给 ab 通道加随机抖动，做法是在训练时对 gt ab 数值乘一个 0.9 到 1.1 之间的随机缩放，再叠加一个很小的随机平移。这样模型看到的颜色分布更宽，不会对特定色调过拟合。正则化也要跟上，权重衰减从 0 调到 1e-5 能把偏色问题缓解一些，但幅度有限。
5.3 显存不够：batch size 调低后效果为什么又变差
6GB 显存跑 256×256、batch size 16 的 U-Net 是会爆显存的。把 batch size 从 16 调成 4 以后，常见问题是训练变慢且效果变差。这不是玄学，而是 batch size 太小导致 BatchNorm 的统计量不准，模型训练过程变得不稳定。
解决方式是模型中间层的 BatchNorm 换成 GroupNorm，GroupNorm 不依赖 batch 维度，batch size 是 1 也能稳定训练。再把优化器的 betas 参数默认值保持即可。还有一个折中做法是保持 batch size 16，但把混合精度训练打开，显存能省下一半左右，PyTorch 自带的自动混合精度能让 6GB 显存跑下来，速度还更快。
5.4 加载 checkpoint 报 missing keys 或 unexpected keys
这个坑在换机器、换代码版本时几乎人人都遇到。报错信息会很长，核心就一句话：state_dict 的键和模型的键对不上。常见原因有几个：训练时用了DataParallel，键名多了module.前缀；第二个是用旧格式保存了optimizer等额外内容，加载时没取 model 字段；第三个是模型代码改过层结构，比如通道数从 64 改成 32，旧权重当然匹配不上。
我的固定处理流程是先打印两边的键名，前 20 条对比一下，再决定用load_state_dict(..., strict=False)还是做前缀清理。如果缺的键集中在最后输出层，说明只是输出通道数改了，其他层权重还能用，这种情况用 strict=False 加载后继续微调，效果比从零训练好得多。
5.5 CPU 推理太慢，演示现场等半分钟不出图
如果你拿到一台没有独显的笔记本做演示，一张 256×256 的图用纯 CPU 跑 U-Net 可能要十几秒到半分钟，现场体验非常尴尬。两个办法改善：一是把输入分辨率降到 192×192 甚至 160×160，推理速度能提升一倍以上，视觉差异不大；二是开启半精度推理，前提是 CPU 支持 AVX512 或较新的指令集，PyTorch 在 CPU 上跑半精度能有一定加速。如果还嫌慢，只能接受减少模型通道数，用第 3 章里提到的 32 通道版本，效果损失在可接受范围内。
6. 让毕设从「能跑」到「能答辩」：量化评估指标与论文配图生成
答辩时老师一定会问「效果怎么评估」。只给两张对比图不够，还需要数字指标。图像着色任务里常用的量化指标有三个：PSNR 评价颜色还原的像素级精度，SSIM 评价结构相似度，颜色直方图熵评价色彩丰富度。前两个用现成库就能算，第三个需要自己写。
import cv2 import numpy as np from skimage.metrics import peak_signal_noise_ratio, structural_similarity def evaluate_colorization(pred_path, gt_path): pred = cv2.imread(pred_path) gt = cv2.imread(gt_path) # 直接计算像素级误差 psnr = peak_signal_noise_ratio(gt, pred, data_range=255) # 转灰度后计算结构相似度 pred_gray = cv2.cvtColor(pred, cv2.COLOR_BGR2GRAY) gt_gray = cv2.cvtColor(gt, cv2.COLOR_BGR2GRAY) ssim = structural_similarity(pred_gray, gt_gray, data_range=255) # 色彩丰富度：计算颜色直方图的熵，熵越高说明颜色越多样 hist_pred = cv2.calcHist([pred], [0], None, [256], [0, 256]).flatten() hist_pred = hist_pred / hist_pred.sum() + 1e-8 # 归一化并防零 entropy = -np.sum(hist_pred * np.log(hist_pred)) return psnr, ssim, entropy这三个指标在论文里怎么解释，比怎么算更重要。PSNR 反映的是像素级还原能力，理想情况应该高于 30dB；SSIM 反映的是结构保留能力，应该高于 0.9；熵是一个相对值，要拿你的模型输出、输入灰度图、真实彩色图三个熵做对比，说明模型让色彩多样性从灰度图的低熵提升到了接近真实彩色图的水平。
消融实验是答辩加分项。你可以出三组对比：只用 L1 损失、L1 加感知损失、再加数据增强。每组跑同样的 epoch 数，收集验证集上的指标做一张表格。哪怕最后结论只是「感知损失提升了 0.5dB，色彩熵提升明显」，这也是真实有效的实验结论。比堆砌模型结构更有说服力。
我还习惯生成一张带错误热力图的对比演示：把模型输出和真实图逐像素求差，取绝对值后映射成热力图，查看哪些区域是模型着色的薄弱点。通常会发现颜色的错误集中在物体边缘和低纹理区域，这也是论文里可以展开分析的方向。
做完这些，你手头就有一组数据、一套模型、一个界面和一份完整的评估报告。答辩时被问到「哪里还能改进」，可以指着热力图说边缘区域的颜色衔接可以引入局部注意力或者条件随机场做后处理。这句话比空泛的「未来可以做更深模型」真诚得多。我自己当年就是靠这套流程，从选定方案到交付整个演示，前后不到四周。中间也遇到过一整个周末调不出颜色的灰暗时刻，后来发现只是忘了归一化真实 ab 值，一根筋地调了一整天网络结构。希望帮到你，少走那一步弯路。
本文还有配套的精品资源，点击获取
