变换:模型实际看到的是什么?
跟踪一个已知样本穿过预处理,验证结构、数值解释、语义、关系与来源,在第一个坏掉的表示边界诊断合法但错误的变换、缩放、归一化、增强与目标对齐。
这里有两次训练运行。同样模型、同样数据、同样优化器、同样种子、同样 epoch。预处理流水线差一个关键字参数,两条都不抛。
scale=True range=[ -1.09, 1.45] first_epoch_loss= 0.5222 last=0.0032 val_acc=1.000
scale=False range=[ 259.89, 886.36] first_epoch_loss=28.5556 last=0.6938 val_acc=0.400
第二条流水线产出的张量形状对、dtype 对、设备对、无非有限值。第 2 章每个检查过。第 5 章每个检查过。batch 准时到达,第 6 章教的东西全验证了。而模型从完美掉到比瞎猜还差。
参数是 ToDtype 上的 scale。默认值 False:
ToDtype(dtype, scale: bool = False)
所以坏流水线就是写 obvious 东西得到的。v2.ToDtype(torch.float32) 把 8 位图像值转浮点,留在 0.0 ... 255.0,因为转换 dtype 与重解释数值尺度是两件事,PyTorch 不猜你要哪个。
现在换一件与预处理无关的事。SGD 换 Adam,两条流水线再跑:
optimizer=adam lr=0.01
scale=True range=[ -1.09, 1.45] first_epoch_loss=0.2304 last=0.0000 val_acc=1.000
scale=False range=[ 259.89, 886.36] first_epoch_loss=0.7134 last=0.0000 val_acc=1.000
bug 还在。模型面对的值仍是意图范围的几百倍。而 headline 指标里看不见了:精度相同、末损失四舍五入相同、训练曲线没 obvious。Adam 自适应更新归一化让这个实验里优化对输入重缩放远不如朴素 SGD 敏感。那是优化器 robustness,不是表示正确的证据。
这个对比就是本章存在的理由。
表示 bug 的严重程度取决于与表示无关的东西。看训得多好看不出模型看到了什么。
得直接看表示。
我们在哪
第 6 章把输入供给变成可观测系统。有东西产出样本,有东西整理 batch,worker 进程可能并发准备未来 work,训练循环消费。在每边界测等待,说出哪个阶段跟不上。
但第 6 章故意把每 batch 当有大小、到达时间与生产代价的对象。那章 Producer 返回 torch.randn(128) 与随机标签,内容与何时到无关。
真实样本不是随机数。它们是解码过的文件、转成浮点的整数、resize 过的数组、对着某处算的统计归一过的张量,这 epoch 与上 epoch 增强可能不同的图像。每步都是数字含义的决定。
所以本章的问题:
模型到底看到了什么,表示第一次在哪不再是我们想要的意思?
底层的事实简单,容易忘:
模型从不在你抽象的原始样本上训练。它在预处理流水线产出的东西上训练。
这让预处理成为模型定义的一部分,而不是周围脚手架。流水线一换,学习问题就换了,模型代码逐行相同也一样。
第 6 章拥有供给。第 7 章拥有表示。
环境
本章每个数值结果都由下面环境里跑出的实验产出。listing 展示研究的机制;遮挡被测变换的重复训练 harness 代码略去。
PyTorch 2.13.0
TorchVision 0.28.0
Python 3.12.3
OS Linux, CPU only
TorchVision 变换 API 比 PyTorch 大多部分变得多,下面有些行为版本敏感。到处都说清并展示怎么查,不让你信常量。
变换能改的五件事
剥掉库,变换没什么 exotic:
def scale_to_unit_interval(x):
return x.float() / 255.0
输入,输出,完。变换值得一章不是因为机器,而是它能独立改的东西多——而其中只有一样进形状。
模型面对的样本有五类属性,本章按它们组织,因为每类失败不同、每类要的证据不同:
样本走的路长这样:
raw source
↓ decode
representation conversion
↓ deterministic preprocessing
resize / scale / tokenize
↓ stochastic augmentation
crop / flip / jitter
↓ normalization
model-facing tensor
每箭头都是样本可能不再满足心里契约的边界,五类里任何一类。本章剩下是找到第一个,以及没有单仪器找全五个的事实。
技术:跟踪一样本,找到第一次分歧
本书每章加一种调查法。第 2 章要第一个错的张量而不是第一个不合法的。第 3 章要参数到损失第一条断边。第 5 章问四套结构哪套对归属不一致。第 6 章问有用功在哪停止流动。
第 7 章加:
找到样本第一次不再满足预期输入契约的变换边界。
问题从来不只是“哪个变换抛了”——抛的变换已告诉你它在哪。问题是数据第一次在保持完全合法的同时语义错了的位置。
可执行化约二十行。
import torch
from dataclasses import dataclass
@dataclass(frozen=True)
class Stage:
name: str; kind: str; shape: tuple; dtype: str
minimum: float; maximum: float; mean: float; std: float; finite: bool
def describe(name, x):
if not torch.is_tensor(x):
raise TypeError(
f"{name}: stage reporter expects a Tensor or TVTensor, got {type(x).__name__}"
)
xf = x.float()
return Stage(
name, type(x).__name__, tuple(x.shape), str(x.dtype),
float(xf.min()), float(xf.max()), float(xf.mean()), float(xf.std()),
bool(torch.isfinite(xf).all()),
)
def trace(sample, stages):
"""Run a pipeline one stage at a time, describing the sample after each."""
x, rows = sample, [describe("raw", sample)]
for name, t in stages:
x = t(x)
rows.append(describe(name, x))
return x, rows
def report(rows):
print(f"{'stage':<22}{'kind':<8}{'shape':<16}{'dtype':<10}"
f"{'min':>9}{'max':>10}{'mean':>9}{'std':>8}")
for r in rows:
print(f"{r.name:<22}{r.kind:<8}{str(r.shape):<16}"
f"{r.dtype.replace('torch.',''):<10}"
f"{r.minimum:9.3f}{r.maximum:10.3f}{r.mean:9.3f}{r.std:8.3f}")
关键动作是 trace 把流水线拆开。调 Compose 通常只给输入与终输出,中间不暴露。变换本身可检查;中间张量不自动报告。stages 分开传,每边界可观测。
在同样样本上跑开篇两条流水线。
from torchvision.transforms import v2
torch.manual_seed(0)
raw = torch.randint(0, 256, (3, 96, 96), dtype=torch.uint8)
MEAN, STD = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]
good = [("ToImage", v2.ToImage()),
("Resize(64)", v2.Resize((64, 64), antialias=True)),
("ToDtype(f32,scale)", v2.ToDtype(torch.float32, scale=True)),
("Normalize", v2.Normalize(MEAN, STD))]
broken = [("ToImage", v2.ToImage()),
("Resize(64)", v2.Resize((64, 64), antialias=True)),
("ToDtype(f32)", v2.ToDtype(torch.float32, scale=False)),
("Normalize", v2.Normalize(MEAN, STD))]
report(trace(raw, good)[1])
report(trace(raw, broken)[1])
=== intended pipeline ===
stage kind shape dtype min max mean std
raw Tensor (3, 96, 96) uint8 0.000 255.000 127.747 73.759
ToImage Image (3, 96, 96) uint8 0.000 255.000 127.747 73.759
Resize(64) Image (3, 64, 64) uint8 23.000 225.000 127.750 32.216
ToDtype(f32,scale) Image (3, 64, 64) float32 0.090 0.882 0.501 0.126
Normalize Image (3, 64, 64) float32 -1.724 2.117 0.231 0.580
=== same pipeline, scale=False ===
stage kind shape dtype min max mean std
raw Tensor (3, 96, 96) uint8 0.000 255.000 127.747 73.759
ToImage Image (3, 96, 96) uint8 0.000 255.000 127.747 73.759
Resize(64) Image (3, 64, 64) uint8 23.000 225.000 127.750 32.216
ToDtype(f32) Image (3, 64, 64) float32 23.000 225.000 127.750 32.216
Normalize Image (3, 64, 64) float32 98.319 998.196 563.338 142.736
两跑前三行相同,第四行分歧。该行就是诊断。之后一切——巨大的归一化范围、开篇 28.6 的损失、0.400 精度——都是下游症状。
注意分歧的样子。dtype 列两边都对。float32 正是要的,正是模型要的。唯一露问题的列是值范围,还得知道该阶段本该产出什么范围。
阶段报告是关于表示的证据。只有写下每阶段本该产出什么,它才成诊断。
这个仪器看得见什么,看不见什么
对刚建的工具诚实,因为本章剩下全从它的局限跟出。
1 STRUCTURE stage report type, shape, axis count
2 NUMERIC INTERPRETATION stage report dtype, min, max, mean, std
+ a written-down expectation for each
3 SEMANTICS NOT VISIBLE needs a probe you write,
or a known sample you look at
4 RELATIONSHIPS NOT VISIBLE needs paired types and
explicit target assertions
5 PROVENANCE NOT VISIBLE needs a record: which split,
saved with which checkpoint
阶段报告覆盖五类之二,即使这两类也要配期待。张量说不出通道顺序错了、增强图像与标签矛盾了、掩码描述了图的镜像、归一化常数在验证集上拟合了。那些都不是张量的属性。都是张量与外面东西关系的属性。
这不是这个 reporter 的弱点。是问题的形状,本章才有四节仪器而不是一个。
类别 1 与 2:表示与数值解释
ToImage 与 ToDtype 是两个变换而不是一个的原因是它们回答不同问题——第一个是类别 1,第二个是类别 2。
img = torch.randint(0, 256, (3, 8, 8), dtype=torch.uint8)
a = v2.ToImage()(img)
b = v2.ToDtype(torch.float32, scale=True)(a)
c = v2.ToDtype(torch.float32, scale=False)(a)
raw: Tensor torch.uint8 0 252
ToImage: Image torch.uint8 0 252 (3, 8, 8)
ToDtype(scale=True): Image torch.float32 0.0 0.988
ToDtype(scale=False): Image torch.float32 0.0 252.0
ToImage 改了类型别无其他——同样 dtype、同样值、同样形状。产出的是 tv_tensors.Image,张量子类,带着“这些数是图像”的信息。标签让后面变换对图像、掩码、框行为不同,类别 4 里 essential。
ToDtype 改了数。对这个 uint8 -> float32 转换,scale=True 实现与除 255 相同的 [0,255] -> [0,1] 尺度约定,浮点精度同意而不是每中间值逐比特:
别背“缩放就是除 255”。TorchVision 给图像 dtype 定义期待数值范围,scale=True 在这些约定间转换。这里用的 uint8 → float32 把 [0, 255] 映到 [0, 1],效果除 255。别的 dtype 对各有规则——浮转整涉及缩放,浮转浮不涉及。任一 dtype 变,查文档转换而不是把 /255 规则类推。
有个不对称值得知道,因为它解释这个 bug 为何活到生产。顺序错了响亮:
v2.Normalize(MEAN, STD)(a) # a is still uint8
TypeError: Input tensor should be a float tensor. Got torch.uint8.
尺度错了静默。Normalize 验证机器可查的 dtype 要求——输入浮点。它验证不了数值契约的语义部分——这些浮点是不是它统计假设的尺度——因为 float32 张量里没记录哪个约定产出它们。
PyTorch 强制看得见的属性。值尺度约定不在其中。
归一化是坐标变换
归一化名声是 vaguely 有益的步骤,心智模型错了。它精确算这个,每通道:
x' = (x - mean) / std
不多不少。与变换对过:
manual = (x - torch.tensor(MEAN)[:, None, None]) / torch.tensor(STD)[:, None, None]
torch.allclose(v2.Normalize(MEAN, STD)(x), manual, atol=1e-6) # True
归一化没让图像更好。它把图像以不同坐标系递给模型,定义坐标系的两数属于数据的特定表示。
这就是开篇失败重述。0.485 是值住 [0, 1] 的图像 plausible 红通道均值。用到住 [0, 255] 的值上,减了几乎没有,再除 0.229,一切乘约 4.4:
normalize(scaled) min= -2.118 max= 2.640 mean= 0.231 std= 1.289
normalize(unscaled) min= -2.118 max= 1136.357 mean= 563.325 std=326.478
两算子都合法,都产出有限 float32。一个递出意图坐标系,一个产出比意图大几百倍的值。
一句澄清坑人。用数据集统计归一化后,单张图像不会零均值单位方差。上面跟踪里归一化图像均值 0.231、std 0.580,不是 0 与 1。这是对的行为:Normalize 施固定参照统计,不是每图像重算统计。逐图像标准化是回答不同问题的不同变换,搞混会去“修”本来没坏的流水线。
类别 3:语义,张量属性装不下
到此失败都是数值的——数不再是下阶段 assumed 的意思,阶段报告抓住了。现在更难的类别:张量保持完全合法,不再描绘标签说的东西。
顺序是程序,不是风格
每变换对之前到来 assume 些东西,流水线是有序程序。通常教法——“变换不可交换”——对,但传不出区别藏得多 quiet。
两条流水线,同样算子,相反顺序,用在中心偏左有小物体的图像上:
img = tv_tensors.Image(torch.zeros(3, 64, 128, dtype=torch.uint8))
img[:, 20:28, 24:32] = 255 # small object, left of centre
A = v2.Compose([v2.Resize((48, 48)), v2.CenterCrop((32, 32))])
B = v2.Compose([v2.CenterCrop((48, 48)), v2.Resize((32, 32))])
resize -> centercrop shape=(3, 32, 32) dtype=torch.uint8 max=255 lit_pixels=120
centercrop -> resize shape=(3, 32, 32) dtype=torch.uint8 max= 0 lit_pixels=0
outputs identical: False
同样形状,同样 dtype。一个有物体,一个是空图。先裁剪丢了 resize 会带进裁剪窗的区域,物体正在那区域。
阶段报告 flag 不了这个,因为空图是完全合法、范围完全合理的图像。flag 它的是每边界问阶段 assume 收到什么、必须保留什么。CenterCrop assume 有意思的内容在中心附近。宽图上不是,假设就是 bug。
从上往下读流水线,问每阶段 assume 收到的表示是什么。“顺序重要”真正的意思就是这个。
增强是对不变性的断言
裁剪顺序例子丢了内容。类别 3 更锋利的版本是变换什么都不丢还让样本变假:输入自己完全有意义,与目标的关系成谎。
考虑按箭头指向分类箭头。
def arrow(direction):
"""A 1x32x32 uint8 arrow. direction: 'left' (class 0) or 'right' (class 1)."""
a = torch.zeros(1, 32, 32, dtype=torch.uint8)
a[:, 15:17, 6:26] = 255 # shaft
for k in range(8): # head: widens toward the tip
if direction == "right":
a[:, 16 - k: 17 + k, 25 - k] = 255
else:
a[:, 16 - k: 17 + k, 6 + k] = 255
return a
def arrow_direction(x):
"""Semantic probe: the head is the end with the greater vertical extent."""
height = (x[0] > 0).float().sum(0)
lit = height.nonzero().flatten()
left_mass = height[lit[:len(lit) // 3]].mean()
right_mass = height[lit[-(len(lit) // 3):]].mean()
return "right" if right_mass > left_mass else "left"
probe on known arrows: left right
现在把计算机视觉最标准的增强用在标类别 0 的左箭头上:
img = tv_tensors.Image(arrow("left"))
out = v2.RandomHorizontalFlip(p=1.0)(img)
after RandomHorizontalFlip(p=1.0):
type : Image
shape : (1, 32, 32) dtype: torch.uint8
min/max: 0 255
finite : True
label : 0 (still 'left')
image now depicts: right
阶段报告打印的每行都对。变换成功。训练样本现在是右箭头的图,标“左”。
这不是 hypothetical 伤害。同样小分类器三种训法:
no flip val_acc = 1.000
RandomHorizontalFlip(p=0.5) val_acc = 0.458
RandomHorizontalFlip(p=1.0) val_acc = 0.000
p=0.5 行是人们预期的:约半数标签错了,两类几乎不可分,模型落在瞎猜附近。
p=1.0 行更有意思,值得坐一会儿。零。不是瞎猜——完美错。模型把任务学得完美;它从每图镜像的训练集学,学了想要映射的精确反,验证(不翻转)每个预测全错。持续 mislabel 问题的成功学习长这样,训练损失曲线全程漂亮。
教训不是“别用水平翻转”。水平翻转对大量物体摄影真 valid。教训是施加它断言了什么:
施加增强
T断言meaning(x) ≈ meaning(T(x))对目标依赖的每方面成立。这个断言关于你的任务,变换库替你检查不了。
标签依赖被改属性时断言假——方向、手性、文字、解剖方向,镜像是不同东西的任何处。不 obvious 处也假:去掉小物体的增强对检测任务破断言,对同样图像的场景分类仍成立。
注意 arrow_direction 是什么。它是类别 3 的仪器,建它就是全部动作。有些语义属性可算,能算时“这个增强保标签吗”不再是判断题,是能进测试套件的断言。算不了时 fallback 是已知样本的小 gallery 与自己的眼睛——不是认输,是剩下的唯一仪器。
类别 4:对象间关系
箭头是标量目标的关系失败。两种形式值得建仪器。
目标也有契约
容易当目标的表示 obvious。数据集常暴露两钩子,split 正如看起来:
dataset = SomeDataset(..., transform=input_transform, target_transform=target_transform)
有用的纪律是目标表示由目标函数定,不由惯例或抄的例子定。一看有 target_transform 槽、one-hot 看起来 tidy 就伸手拿 one-hot 容易。先查损失到底要什么。
对 cross_entropy,它要的比 folklore 灵活:
logits = torch.randn(4, 3)
idx = torch.tensor([0, 2, 1, 0])
one_hot = F.one_hot(idx, num_classes=3).float()
soft_targets = 0.8 * one_hot + 0.2 / 3
class indices : 1.082031011581421 torch.int64
class probs : 1.082031011581421 torch.float32
soft targets : 1.1632474660873413
float 1-D target: RuntimeError expected target dtype to be Long or Byte, but got Float
所以“交叉熵要整数类别下标”不对。它接受类别下标或逐类概率,one-hot 概率与对应下标的损失浮点误差内相同。第二种形式正是 label smoothing、蒸馏、mixup 得以表达的原因。
概率目标形式有个很第 7 章的坑。PyTorch 不验证那些浮点目标真是概率分布:
non-distribution float target still returns a loss: 0.6805554032325745
负值、不和一的行产出完全普通的数。形状对,dtype 对,损失跑,语义 invalid。选概率目标形式,验证分布是你的责任。
递一维浮点张量——忘了 reshape 的 one-hot,或手滑 cast 的下标——它抛,因为一维浮点目标两契约都不对。
目标变换必须产出所选目标函数要的表示。读损失函数的契约,别从例子推测。
普通类别下标表示,机器可查的契约两行:
assert labels.dtype == torch.int64
assert bool(((0 <= labels) & (labels < num_classes)).all())
损失故意用 ignore_index,范围检查排除那些位置。第二行抓住整类 bug——1 起始标签、有 gap 的类别映射、过滤子集没 remap 的 ID——在它变成三十层外的索引错之前。
共享几何的对象必须共享几何决定
检测、分割、关键点任务加分类没有的要求:目标自己含几何。裁剪、resize、翻转必须用同样 sampled 变换同时更新输入与几何目标。
失败模式是变换调两次:
f = v2.RandomHorizontalFlip(p=0.5)
a, b = f(img), f(mask) # two independent random draws
independent calls: image and mask disagreed in 99/200 trials
structured call : image and mask disagreed in 0/200 trials
半数样本的掩码描述了所附图的镜像。两张量都合法,形状都对。数据集现在半噪声,不一致计数就是说这个的仪器。
修复是让变换知道这些对象属于一起,tv_tensors 类型正为这个:
from torchvision import tv_tensors
img = tv_tensors.Image(torch.zeros(3, 32, 32, dtype=torch.uint8))
img[:, 4:12, 20:28] = 255
mask = tv_tensors.Mask(torch.zeros(32, 32, dtype=torch.uint8))
mask[4:12, 20:28] = 1
boxes = tv_tensors.BoundingBoxes(
torch.tensor([[20, 4, 28, 12]]), format="XYXY", canvas_size=(32, 32))
flipped_img, flipped_mask, flipped_boxes = v2.RandomHorizontalFlip(p=1.0)(img, mask, boxes)
image bright cols: [4, 5, 6, 7, 8, 9, 10, 11]
mask cols : [4, 5, 6, 7, 8, 9, 10, 11]
boxes : [[4, 4, 12, 12]]
一调,一 sampled 决定,三对象一致更新。框从 x [20, 28] 到 [4, 12],32 宽 canvas 的精确镜像,掩码列与图像列对上。
分发按类型,不按位置,变换对类型区别对待而不是统一:
pipe = v2.Compose([v2.RandomHorizontalFlip(p=1.0),
v2.ToDtype(torch.float32, scale=True),
v2.Normalize([0.5]*3, [0.25]*3)])
i2, m2 = pipe(img, mask)
image: Image torch.float32 range=[-2.00, 2.00]
mask : Mask torch.uint8 unique=[0, 1]
图像翻转、转换、归一化。掩码只翻转其余不动——仍 uint8 值 {0, 1},因为归一化类别下标掩码 meaningless。这就是 ToImage 存在、它贴的标签重要的原因:裸张量说不出“我是分割掩码,别 rescale 我”。
共享几何的东西必须共享几何决定。用类型表达关系让变换 honor,而不是指望两次随机调用 agree。
原则活过 API。无论什么库问题一样:这是一 sampled 变换一致施加,还是几个独立变换 hopeful 施加?
随机变换要分布,不要样本
随机横切类别而不是自成一类,它 defeat 到此建的每仪器的方式相同:随机变换跑一次几乎什么都不说。变换不是值,是值上的分布,在乎的属性是分布的属性。
拿顺序例子的小物体,问随机裁剪多久保住它:
img = tv_tensors.Image(torch.zeros(3, 64, 128, dtype=torch.uint8))
img[:, 8:14, 10:16] = 255
for scale in [(0.08, 1.0), (0.5, 1.0), (0.9, 1.0)]:
rrc = v2.RandomResizedCrop(size=(32, 32), scale=scale, antialias=True)
kept = sum(float((rrc(img) > 0).any()) for _ in range(500))
print(f"scale={scale} object retained in {kept/500:.1%} of crops")
scale=(0.08, 1.0) object retained in 16.8% of crops
scale=(0.5, 1.0) object retained in 16.6% of crops
scale=(0.9, 1.0) object retained in 0.0% of crops
两发现,第二个没人预测对。
第一:默认设置下这图 80% 训练 view 无物体。标签说“有物体”,五增强样本四与之矛盾——箭头失败换门进来。
第二:最温和的设置物体保留零。反直觉,得解释而不是耸肩。RandomResizedCrop 采样面积比与长宽比,有界次数重试采样框装不下就 fallback 确定性中心裁剪。默认长宽比范围 (3/4, 4/3) 下,覆盖 64×128 图像 90% 的裁剪装不进 64 像素高:最宽允许比也不够宽。每个随机 proposal invalid,fallback 成确定。检查 sampled 参数而不只输出,直接看见:
for scale in [(0.08, 1.0), (0.5, 1.0), (0.9, 1.0)]:
rrc = v2.RandomResizedCrop(size=(32, 32), scale=scale)
boxes = [tuple(rrc.make_params([img]).values()) for _ in range(300)]
print(scale, "distinct crops:", len(set(boxes)))
(0.08, 1.0) distinct crops: 300
(0.5, 1.0) distinct crops: 186
(0.9, 1.0) distinct crops: 1
scale=(0.9, 1.0) 的“随机”变换三百次产出一裁剪。它没增强任何东西,永远排除物体在的角。
参数名推理不到这个。采样变换看分布得到——输出的分布,API 暴露时参数的分布。
随机变换跑很多次在已知样本上检查,问分布里多大比例仍满足契约。“跑一次看着 fine”不是证据。
样本故意选。看已知样本,选你知道必须活的:最小物体、稀有类、裁剪边界的样本、标签依赖文字的图像。大数据集随机样本几乎永远碰不到 break 的情形。
类别 5:来源
最后类别完全无张量签名。两数可以完全正确,还因从哪来而是坏实验的证据。
拟合预处理是实验 state
有时归一化统计来自预训练模型的契约。有时自己从数据算——一算,变换就有了从数据派生的 state,性质变了。
def channel_stats(u8_batch):
"""Population channel mean/std over a [N,C,H,W] uint8 stack, in [0,1] units."""
x = v2.ToDtype(torch.float32, scale=True)(v2.ToImage()(u8_batch))
return (x.mean(dim=(0, 2, 3)).tolist(),
x.std(dim=(0, 2, 3), correction=0).tolist())
训练数据一光照收集,验证稍后更亮下收集——完全 ordinary:
fitted on train only mean= [0.3706, 0.3709, 0.3707] std= [0.0792, 0.0792, 0.0793]
fitted on train+val mean= [0.4488, 0.4491, 0.4490] std= [0.1468, 0.1470, 0.1470]
shift in channel-0 mean : 0.0782
全文件都在就全拟合,统计动了近八个百分点。训练流程现在依赖验证分布的 summary。验证集对预处理选择不再独立:它的指标度量了被允许用同一评估 split 派生信息的流水线。
deliberately 定义的实验里 transductive 设计可以合法。它不是干净的留出验证 protocol。什么都不抛,leak 在模型收到的每张量里不可见——这正是来源自成一类的原因。
预处理 state 从数据估计,只用训练流程允许知道的数据拟合。
同样形状出现在预处理带拟合 state 的所有处:表格 scaler、类别词表、词元词表、量化校准。都从某 split 估计,都从错 split 估计就 leak。
原则后半同样重要。拟合变换是实验的一部分,得活下来:
state = {"scale": "unit_interval", "mean": m_tr, "std": s_tr, "fit_split": "train"}
{"scale": "unit_interval", "mean": [0.3706091344356537, ...], "std": [0.0792376846...
随检查点存,或记下精确重建办法。一预处理 state 下训、另一 state 下 serve 的模型不是同一系统,权重载得多干净也一样。
预训练权重与预处理是一份契约
有种情形不该随手拿自己数据的统计换预处理:从预训练权重出发。那些权重在特定输入表示下优化,ship 的预处理是复现发表行为的正确契约。
微调可以故意改表示,模型可能适应。但那是对迁移学习 setup 的实验改动,不是可互换的细节。测而不是 assumed 数据集统计自动更好。
值得养成的习惯是别从博客抄常量。TorchVision 把预处理随权重 ship:
from torchvision.models import ResNet50_Weights, Inception_V3_Weights
print(ResNet50_Weights.IMAGENET1K_V1.transforms())
ResNet50_Weights.IMAGENET1K_V1 ResNet50_Weights.IMAGENET1K_V2
ImageClassification( ImageClassification(
crop_size=[224] crop_size=[224]
resize_size=[256] resize_size=[232]
mean=[0.485, 0.456, 0.406] mean=[0.485, 0.456, 0.406]
std=[0.229, 0.224, 0.225] std=[0.229, 0.224, 0.225]
interpolation=BILINEAR interpolation=BILINEAR
) )
Inception_V3_Weights.IMAGENET1K_V1
ImageClassification(
crop_size=[299] resize_size=[342]
mean=[0.485, 0.456, 0.406] std=[0.229, 0.224, 0.225]
)
前两行合读。同样结构,同样归一化常数,resize_size 不同:V1 256,V2 232。一个模型两套权重,预处理契约不同。
背“ResNet50 用 mean [0.485, 0.456, 0.406]、resize 256、crop 224”的人,常量对,一半 checkpoint 的 resize 错。后果可测:
V1 preset: (3, 224, 224) torch.float32 mean=0.2286
V2 preset: (3, 224, 224) torch.float32 mean=0.2276
identical: False max abs diff: 2.941176414489746
同样形状,同样 dtype,均值几乎相同——单个值在归一化空间差近三,因为两 preset 从不同源尺度重采样。
Inception 行讲第二点:299 与 342,不是 224 与 256。没有通用图像尺寸,正如没有通用归一化常数。
模型权重与模型预处理是一份兼容契约。检查点可以每个键匹配而推理悄悄坏掉。
元数据不够的证明
每类别都演示过了。这里是说明 split 必要的实验,而不是为分类而分类。
模型在类别由哪个颜色通道亮决定的任务上训到完美。serving 代码做 serving 代码做的事——用返回 BGR 通道的库读图:
load_state_dict: <All keys matched successfully>
serving uses RGB (as trained) shape=(300, 3, 16, 16) dtype=torch.float32 range=[-0.69, 0.80] val_acc=1.000
serving uses BGR shape=(300, 3, 16, 16) dtype=torch.float32 range=[-0.69, 0.80] val_acc=0.000
同样形状,同样 dtype,范围到两位小数相同。阶段报告打印的每个字段相同。精度 1.000 与 0.000。
再多 metadata 检查也分不开这两张量,因为区别是哪个通道下标表示红绿蓝。这个约定不在普通张量里记录:两张量暴露同样通道轴、形状、dtype 与数值范围。这是第 2 章的课——合法不等于正确——blast radius 大得多地到来。
放宽,因为有意思的是别的同类 drift 会怎样:
matching preprocessing range=[ -0.69, 0.80] val_acc=1.000
channel-swapped (BGR) range=[ -0.69, 0.80] val_acc=0.000
forgot to scale range=[ 79.00, 457.00] val_acc=1.000
different normalization range=[ -1.43, 2.19] val_acc=1.000
三 mismatch 只有一个致命,正是阶段报告看不见的那个。范围列会 flag 的两个在这个合成任务的这个模型上恰好活下来。别把这个观察变成通用不变断言:不同学到的权重、非线性、归一化层、通道相关变换能让同样数值漂移致命。
别当排名读。它不是说尺度 bug 无害——本章开篇 SGD 下一个 60 点精度。意思是表示 bug 的严重程度与表示 bug 的可见程度无关,开篇从反方向讲的同一句话。
所以契约分两层,诚实说清哪个是哪个:
| Examples | Checkable | |
|---|---|---|
| Machine-checkable | shape, dtype, finiteness, value range, label ID range, mask/image spatial agreement, train-vs-validation contract equality | yes, in an assertion |
| Semantic | channel order, what each axis depicts, whether the augmented image still shows what the label claims, whether the tokenizer matches the one used in training | only via a probe you write, a known sample, or human inspection |
机器可查的一半写成代码,因为免费,在第一个优化器步前抓住巨类错误:
def require_model_image(x, size=(3, 224, 224), value_bounds=(-5.0, 5.0)):
if tuple(x.shape) != size:
raise ValueError(f"expected {size}, got {tuple(x.shape)}")
if x.dtype != torch.float32:
raise TypeError(f"expected float32, got {x.dtype}")
if not torch.isfinite(x).all():
raise ValueError("non-finite values in image")
low, high = value_bounds
if not (low < float(x.min()) and float(x.max()) < high):
raise ValueError(
f"values outside expected range {value_bounds}: "
f"[{x.min():.2f}, {x.max():.2f}]"
)
最后一查正是抓住开篇失败的,也是人们漏掉的。它编码关于数值解释而非结构的期待。是 heuristic,不是证明——但它在 [98, 998] 上响,在 [-2.1, 2.6] 上静,正是我们否则自动做不出的区分。界属于这个 ImageNet 风格归一化契约,不是归一化张量的通用界。
语义一半,属性可算处写探针(arrow_direction 是一个),否则留已知样本的小 gallery 看。
流水线归一化,建显示拷贝而不是看训练张量,反解归一化:
def denormalize(x, mean=MEAN, std=STD):
m = torch.tensor(mean, device=x.device)[:, None, None]
s = torch.tensor(std, device=x.device)[:, None, None]
return (x * s + m).clamp(0, 1)
round-trip max error vs pre-normalized: 5.960464477539063e-08
往返浮点精度恢复归一化前图像,看的是实际样本而不是近似。注意 clamp:只为显示,施到训练张量会悄悄丢掉模型该看的值。
测试流水线
两层区分决定测试能断言什么,常见错是对随机变换测确定性变换才有的属性。
确定性流水线该可复现,值得断言,因为有人把增强加错列表时这个属性 broken:
a, b = val_tf(raw), val_tf(raw)
torch.testing.assert_close(a, b) # val_tf deterministic: True
随机流水线不能这样测。输出本该不同;不该不同的是不变量:
train_tf identical across draws: False
train_tf shape invariant: {(3, 64, 64)}
train_tf dtype invariant: {torch.float32}
train_tf all finite: True
值变,契约不变。这就是好的增强测试的形状:多次抽样断言结构、dtype、有限、目标 valid、配对几何对齐全成立,值本身什么都不s断言。
第三种测试是人们从不写的:同样样本跑两条流水线,直接比契约。
train_tf (scale=True) train=((3, 64, 64), torch.float32, -1.8, 2.2)
val =((3, 64, 64), torch.float32, -1.7, 2.1)
shape/dtype agree: True magnitudes comparable: True
train_tf (scale=False) train=((3, 64, 64), torch.float32, 72.1, 1024.8)
val =((3, 64, 64), torch.float32, -1.7, 2.1)
shape/dtype agree: True magnitudes comparable: False
第一断言两种情形都过。结构从不是问题,只查形状 dtype 的测试会无 complaint 签掉开篇失败。
第二断言抓住这两条流水线之间的 drift。它不确立任一条对。训练验证不小心都用 scale=False,量级 agree,这个比较过而两边都违反模型契约。
所以跨流水线比较管一致,每条流水线独立对模型期待的显式表示比。Agree 必要,不充分。
三条流水线,一份契约
项目通常三条预处理路,纪律是知道哪可不同。
may differ must agree
training stochastic augmentation final model-facing representation
validation deterministic final model-facing representation
inference deterministic final model-facing representation
训练可注入随机,因为 variation 是它学习的东西的一部分。验证通常确定,因为它的工作是稳定测量仪器——benchmark 每次变,指标移动分不出模型更好还是测量不同。这是默认不是法律:test-time augmentation 是合法技术。原则是评估随机必须 deliberate 并当评估流程的一部分解释,而不是有人把 train_transform 传给两数据集 accident 继承的。
三条必须 agree 的是终表示:通道数与顺序、dtype、值尺度、归一化 state、模型为之建的空间契约。
推理路最容易烂,因为通常住不同文件,常不同仓库,有时不同语言。第 5 章展示每键匹配载入、拿回 worthless 模型的检查点。这是同样失败,state 搬到检查点外:权重完美,输入约定不对。
remedy 是把确定性预处理定义当模型 artifact 的一部分——随权重序列化,或从记录配置重建——而不是训练脚本里恰好存在的代码。TorchVision 的 weights.transforms() 正是发表模型上这个思想,自己的模型值得抄。
变换跑在哪,简短说
Dataset.__getitem__ 里的变换是样本生产的一部分。num_workers > 0 时在 worker 进程里跑,变换代价就是第 6 章测的生产者代价。连接就这些,故意简短因为测量归第 6 章。
两后果值得说。
确定性与随机 work 放置经济学不同。 输出只依赖稳定输入与稳定配置的确定性预处理是预计算或缓存的候选。新鲜随机 variation 是训练设计的一部分,缓存边界之后留那阶段——能缓存预生成的增强 view,但那把训练分布从新鲜抽样变成固定有限集:
raw → expensive deterministic preprocessing → CACHE → random augmentation → model
缓存失效变成正确性问题,还是类别 5:变换定义一改,stale 缓存悄悄保留旧行为,改代码都修不好的表示 bug。缓存版本化或 deliberate 重建。
调流水线前先调一样本。 东西看起来不对,别从八 worker、预取、随机变换、整理、设备传输全交互开始:
raw = dataset_without_transform[index]
x = transform(raw)
一样本,一进程,无 batch。第 6 章为不同原因说过同样的话——num_workers=0 暴露 worker traceback——这里原因更强:worker 进程里的随机变换难隔离难复现,直接调在选定一样本上去掉几处无关复杂度。随机性控到可复现失败:seed generator,或把随机换固定(箭头实验里 p=1.0 而不是 p=0.5)。复现不了的变换调不了。
同样的模型,图像之外
图像主导本章因为语义失败看得见——看得出箭头指反。五类别不限图像。
| Domain | Raw | Deterministic preprocessing | Fitted state | Stochastic |
|---|---|---|---|---|
| Image | compressed bytes | decode, resize, scale, normalize | dataset or pretrained statistics | crop, flip, jitter |
| Text | Unicode string | tokenize, map to IDs, truncate, pad | tokenizer / vocabulary state | token masking, span corruption |
| Tabular | strings, nulls, categories | parse, encode, impute, scale | scaler statistics, category vocabulary | noise, feature dropout |
| Audio | encoded file | decode, resample, feature transform | normalization statistics | time shift, noise, spec masking |
每行同样列,本章每失败每行都有 analogue。padding 词元当真词元是掩码错位的文本版——类别 4。train+test 上拟合词表是 leaked 归一化统计的文本版——类别 5。训练 serving 分词器不同是推理 BGR 的文本版——类别 3,形状 dtype 完全 valid 的词元 ID 表示了文本到模型输入的不同映射。
每个模型收到的都是有序预处理程序产出的表示。domain 换算子,不换问题。
在变换流水线上用 AI
问助手变换流水线对不对,可能得到只看代码的流利答案。但代码常不够,因为缺的事实包括原始数据表示什么、目标什么意思、模型在哪个预处理契约下训的——类别 3、4、5,源码里都没有。
动作还是本书那个:先刻画再重写。
Here is a PyTorch transform pipeline and a description of one known raw sample.
Do not rewrite the pipeline and do not propose fixes yet.
First, build a table with one row per transform:
- the input representation it assumes (type, shape, dtype, value scale);
- the output representation it should produce;
- which properties it intentionally changes;
- which properties must remain invariant;
- whether it introduces randomness;
- whether it changes geometry;
- whether the target must change with it.
I will then give you the observed type, shape, dtype, min, max, mean and std
after every stage, plus the label and what the sample depicts.
Identify the FIRST stage at which the observed representation becomes
inconsistent with the contract in your table.
Then answer separately:
1. Is the failure structural, numerical, semantic, relational or provenance?
2. Which of those can my stage report detect, and which cannot?
3. What is the smallest experiment that would confirm that diagnosis rather
than the two most likely alternatives?
4. What measurement should change after the repair?
5. What measurement must NOT change after the repair?
Only after I report the result of that experiment should you propose a change.
问题 5 留着。它拦住修复变重写:修值尺度 bug 还改了输出空间尺寸,说明换了不该换的东西。
有个 specific 弱点值得利用。助手擅长变换 catalogue,弱在你的任务语义,因为语义不在代码里。所以别问“RandomHorizontalFlip 这里合适吗”。问:
My labels are: 0 = arrow points left, 1 = arrow points right.
For each transform in this pipeline, state whether it can change the property
that determines the label, and give me a probe I can run on one sample to
check whether it did.
这个问题有可检查的答案,探针比 opinion 值钱。
让 AI 先刻画流水线,再让它重写流水线。
变换调试序列
1. Choose ONE known raw sample — one where you know what the answer
should be. Prefer an edge case: the small object, the rare class,
the directional one.
2. Bypass concurrency. No DataLoader, no workers, no batching.
raw = dataset_without_transform[i]; x = transform(raw)
3. Write down the intended final contract BEFORE looking at anything:
shape, dtype, channel order and meaning, value scale,
normalization state.
4. Run the pipeline one stage at a time and describe each output:
type, shape, dtype, min, max, mean, std, finite. cat 1-2
5. Compare each stage against what it was supposed to produce.
The FIRST divergence is the diagnosis; everything after is symptom.
6. If nothing diverged, the failure is in a category the report
cannot see. Go to steps 7-10 rather than concluding it is fine.
7. Verify the target still describes the transformed input.
Use a probe if the property is computable; look at it if not. cat 3
8. Check paired objects: mask, boxes, keypoints, second modality.
Measure the disagreement rate over many draws. cat 4
9. If the stage is stochastic, run it many times on the same sample
and inspect the DISTRIBUTION, including sampled parameters. cat 3-4
10. Check the provenance of any fitted state: which split produced it,
and is it saved with the model? cat 5
11. Compare the final contracts of train, validation and inference.
They may differ in randomness. They must agree in representation.
12. Only now reintroduce batching, workers and performance measurement,
and hand any remaining slowness back to Chapter 6.
步骤 1 到 5故意便宜。步骤 6 最要紧:全绿的阶段报告不是健康证明,是五类之二的健康证明。
你现在应该能回答什么
这里有会被递到手里的流水线。它跑。先自己走一遍再往下读。
MEAN, STD = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]
train_tf = v2.Compose([
v2.ToImage(),
v2.RandomResizedCrop((224, 224), scale=(0.8, 1.0)),
v2.RandomHorizontalFlip(p=0.5),
v2.ToDtype(torch.float32),
v2.Normalize(MEAN, STD),
])
val_tf = v2.Compose([
v2.ToImage(),
v2.Resize((256, 256)),
v2.CenterCrop((224, 224)),
v2.ToDtype(torch.float32, scale=True),
v2.Normalize(MEAN, STD),
])
weights = ResNet50_Weights.IMAGENET1K_V2
# ArrowDataset returns three-channel RGB images and labels: 0 = left, 1 = right.
train_ds = ArrowDataset(train_paths, transform=train_tf)
val_ds = ArrowDataset(val_paths, transform=val_tf)
model = resnet50(weights=weights)
model.fc = nn.Linear(model.fc.in_features, 2)
train_tf 第一次分歧在哪,哪类? 在 ToDtype(torch.float32)。scale 默认 False,产出 [0, 255] 的 float32,后面的 Normalize 施了错坐标系。类别 2,阶段报告显示值范围约 [98, 998],意图 [-2.1, 2.6]。dtype 列全程正确,这就是没人注意的原因。
只有这个问题吗? 不是,这正是技术的要点。修了第一次分歧调查不结束;它让你检查下一份契约。剩下的问题阶段报告不全看得见:翻转是语义,预训练 resize 是来源/兼容,随机裁剪在说安全前还要分布层测试。
翻转错在哪? 标签编码方向,meaning(x) 与 meaning(flip(x)) 是不同类。类别 3。p=0.5 下约半数训练样本矛盾;本章测得后果是验证精度从 1.000 到 0.458。什么都不抛,训练损失曲线 unremarkable。
验证预处理与预训练权重的契约差在哪? ResNet50_Weights.IMAGENET1K_V2 用 resize_size=232,而 val_tf 用 256。类别 5。想复现发表评估行为,用 weights.transforms() 而不是手重建契约。模型在故意改的 regime 下微调过,区别不自动是 bug——是验证与推理流水线必须 agree、效果该测量的实验选择。
两条流水线终表示兼容吗? scale bug 修后,是:都是 [3, 224, 224] float32 同统计归一化。修前不是——训练看到约 [98, 998],验证看到 [-2.1, 2.6],验证指标在模型从没训过的输入上度模型。用每 loader 一 batch 的两行断言可查。
scale=(0.8, 1.0) 在这里安全增强吗? 从代码 unknown,要分布检查而不是 opinion。已知样本跑几百次裁剪,数箭头头部活多少。本章发现 scale=(0.9, 1.0) 塌成单确定性裁剪,所以 sampled 参数也看,不只输出。
目标是掩码或框而不是类别标签,还坏什么? 几何变换得用同样 sampled 参数施到目标。类别 4:图像目标分开调用,p=0.5 下 200 trial 99 不一致。修复是目标包恰当 tv_tensors 类型,一调传入两者。
模型训到 99%,生产预测 nonsense,先看哪? 不是模型。推理预处理与训练契约逐字段比:通道顺序、resize 策略、值尺度、归一化统计。本章 BGR 实验形状、dtype、值范围相同,精度 1.000 到 0.000,所以比的是契约,不是张量 metadata。
什么证据证明预处理修复 work? 不是损失降了——开篇坏流水线 Adam 下损失归零。每行对上意图契约的阶段报告、训练 batch 与验证 batch 终表示 agree、探针确认目标仍描述变换后输入、留出集端到端精度,留出集从没用来拟合任何预处理 state。
练习
- 跟踪并分歧。 建阶段 reporter,四阶段流水线跑一遍。逐个引入:丢
scale=True、归一化两次、归一化后 resize、先转浮点再 resize,记哪行先分歧。每个说哪五类,报告看不看得见。 - 优化器掩盖 bug。 SGD 与 Adam 下都复现开篇对比。记四组合的首 epoch 损失、末损失、验证精度,解释同样表示 bug 可见性差这么多。
- 验证缩放。 确认
uint8上ToDtype(torch.float32, scale=True)与除 255 同[0,255] -> [0,1]约定浮点精度同意,再看它对int16与已在[0, 1]的float32输入做什么。跑前先预测。 - 建语义探针。 写
arrow_direction,已知左右箭头验证,再当测试用:断言 proposed 增强保方向。找一个过的增强、一个挂的。 - 分布,不是样本。 任选随机变换,已知样本 500 抽,报告满足契约的比例。再看 sampled 参数,找变换 effectively 确定的设置。
- 弄坏配对。 图像掩码两独立调用变换,测不一致率。
tv_tensors修确认归零。框同样做,手算镜像验证坐标。 - 错 split 拟合。 两 split 不同的数据上 train-only 与 train+val 各算归一化统计。报告 shift,再论证验证指标现在什么意思。
- drift 按类排序。 颜色决定类别的小模型训好存下,四预处理变体评估:正确、通道换、没缩放、不同归一化。记每种形状、dtype、范围、精度。认出阶段报告抓住哪些 mismatch、哪个真致命,注意两集合不是同一集合。
下一步:模型里面
表示现在是可盘问而不是 assumed 的东西。变换是有五类契约的函数,流水线是每阶段对上一阶段产出 assume 些东西的有序程序,流水线 misbehave 时动作是在已知样本上逐阶段跟踪,找到输出第一次不满足契约的边界。
五类别值得成套带走,因为每类要了不同仪器:
1 STRUCTURE stage report shape, type, axis count
2 NUMERIC INTERPRETATION stage report + expected the scale bug
range
3 SEMANTICS a probe, or your eyes the arrow, the crop
order, BGR at serving
4 RELATIONSHIPS paired types, target mask and image
assertions, disagreement disagreeing 99/200
counts over many draws
5 PROVENANCE a record of which split statistics fitted on
and which checkpoint train+val; resize 232
vs 256
只有前两类在张量本身留下直接可检查的证据,即使类别 2 也要观测数与期待数值契约比才有用。这个区分解释本章首尾两结果:SGD 下 catastrophic、Adam 藏住的尺度 bug,普通张量 metadata 区分不了的致命 serving drift。
阶段报告验证你选测的张量属性。它证明不了张量是你想要的意思。语义、关系、来源要故意建的仪器。
这走完从存储字节到模型边界的路:
raw source → decode → representation → augmentation → normalization → batch → model
第 6 章验证 batch 准时到。第 7 章验证里面张量是我们想要的意思。两章止于同一位置——model(x) 被调的时刻。
所以模型边界的张量现在有强得多的证据:[B, 3, 224, 224]、float32、可陈述可测试的契约下归一化、轴含义显式、metadata 不够处加了语义检查。第 4 章建的网吃扁平特征向量,第 5 章组织了它。两者都没用两轴是空间的事实——像素 (h, w) 与 (h, w+1) 相邻的方式,扁平向量里像素 300 与 301 相邻的方式不是。
卷积网是认真对待相邻的结构,它以完全机械、完全容易错的方式变换通道与空间轴。下一章问 [B, C, H, W] 跨过模型边界后发生什么:卷积对通道几何做什么,输出尺寸如何确定而不是猜,为什么通道数错误可能源于空间或轴解释错。
进网。