计算机视觉：从像素到感知

运行一个完整示例 · 01

追踪一个通道

用列表表示一个已知蓝色像素，不需要图像文件或训练模型。

bgr = [255, 0, 0]
rgb = list(reversed(bgr))
value = 153
scaled = value / 255
standardized = (scaled - 0.5) / 0.25
print("RGB:", rgb)
print(f"scaled={scaled:.1f}; standardized={standardized:.1f}")
print("stored numbers:", 4 * 6 * 3)

python pixels-contracts-pixel-scale.py

RGB: [0, 0, 255]
scaled=0.6; standardized=0.4
stored numbers: 72

逐步读懂代码

第一行按蓝、绿、红存储。reversed 改变顺序，list 保存结果。接着三行把 153 缩放，减 0.5，再除以 0.25。f 字符串保留一位小数。最后的乘法得到 72 个通道数值，不是 72 个像素。这是在检查数据约定，并没有识别物体。

运行一个完整示例 · 01

测试三种已知颜色

用普通 RGB 元组和透明规则。

pixels = {"marker": (200, 40, 30), "paper": (220, 220, 220), "shade": (60, 20, 20)}
for name, (red, green, blue) in pixels.items():
    margin = red - max(green, blue)
    print(name, "margin:", margin, "selected:", margin > 50)

python colour-channels-red-channel-rule.py

marker margin: 160 selected: True
paper margin: 0 selected: False
shade margin: 40 selected: False

逐步读懂代码

字典把名称对应到三个通道值。items 返回名称与数值对，解包给通道命名。max 选较强竞争通道，相减得到差距，>50 返回 True 或 False。这是手设颜色筛选器，不是训练好的检测器，也未实现完整 HSV 转换。

运行一个完整示例 · 01

求小块均值

观察亮点与有正负号的边缘响应。这是手写滤波器，不是学习模型。

patch = [10, 10, 10, 10, 19, 10, 10, 10, 10]
mean = sum(patch) / len(patch)
row = [2, 5, 8]
weights = [-1, 0, 1]
response = sum(value * weight for value, weight in zip(row, weights))
print(f"mean={mean:.1f}")
print("edge response:", response)

python filters-neighborhoods-local-filter.py

mean=11.0
edge response: 6

逐步读懂代码

sum 累加九个数，len 计数，得到 99/9 = 11。zip 把每个像素和权重配对。生成式逐对相乘，sum 将 −2、0、8 加起来得到 6。例子只计算一个邻居齐全的位置，因此暂时不涉及填充。

运行一个完整示例 · 01

移除孤立噪点

使用零填充与三个位置的邻域。

mask = [0, 1, 0, 0, 1, 1, 1, 0]
def local_rule(values, operation):
    padded = [0] + values + [0]
    return [operation(padded[i:i + 3]) for i in range(len(values))]
eroded = local_rule(mask, min)
opened = local_rule(eroded, max)
print("eroded:", eroded)
print("opened:", opened)

python edges-morphology-binary-opening.py

eroded: [0, 0, 0, 0, 0, 1, 0, 0]
opened: [0, 0, 0, 0, 1, 1, 1, 0]

逐步读懂代码

def 定义可复用函数。列表相加在首尾各补一个零。range 遍历原位置；切片 i:i+3 取三个数，不包括终点索引。传入 min 做腐蚀，传入 max 做膨胀。开运算把腐蚀结果用作下一步输入。这是准确的小型形态学规则，不是学习图像系统。

运行一个完整示例 · 01

移动框的两个角

只用普通数字，先缩放再平移。

corners = [(10, 20), (30, 50)]
moved = [(2 * x + 5, 2 * y - 3) for x, y in corners]
(x1, y1), (x2, y2) = moved
print("corners:", moved)
print("area:", (x2 - x1) * (y2 - y1))
print("clipped bottom:", min(y2, 80))

python geometry-augmentation-move-box.py

corners: [(25, 37), (65, 97)]
area: 2400
clipped bottom: 80

逐步读懂代码

列表保存两个坐标对。列表推导式对每一对使用同样两个公式。解包为四个新坐标命名。相减得到宽 40、高 60，相乘得面积 2400。min 把底边限制在 80，但真实流程还要更新可见比例规则。本例变换标注，没有对图像像素重新采样。

运行一个完整示例 · 01

比较两个图块描述

从手工描述子计算距离。

import math
query = (1, 2)
candidates = {"A": (1, 3), "B": (4, 6)}
def distance(a, b):
    return math.sqrt(sum((x - y) ** 2 for x, y in zip(a, b)))
ranked = sorted((distance(query, value), name) for name, value in candidates.items())
ratio = ranked[0][0] / ranked[1][0]
print("ranked:", ranked)
print(f"ratio={ratio:.2f}; accept={ratio < 0.8}")

python classical-features-descriptor-distance.py

ranked: [(1.0, 'A'), (5.0, 'B')]
ratio=0.20; accept=True

逐步读懂代码

zip 配对元素，**2 把差平方，sum 相加，math.sqrt 开方。sorted 按距离从小到大排列 (距离,名称) 对。ranked[0][0] 取第一对的距离，ranked[1][0] 取下一对。比值为 0.20。代码匹配手设描述子，没有寻找图像关键点，也没有实现 SIFT。

运行一个完整示例 · 01

把特征变成三个分数

手工特征让我们单独观察预测头。这不是训练好的图像分类器。

import math
features = [1, 2]
weights = [[1, 0], [0, 1], [0, 0]]
scores = [sum(w * h for w, h in zip(row, features)) for row in weights]
exp_scores = [math.exp(s - max(scores)) for s in scores]
probabilities = [v / sum(exp_scores) for v in exp_scores]
print("scores:", scores)
print("probabilities:", [round(p, 4) for p in probabilities])
print(f"loss={-math.log(probabilities[1]):.4f}")

python recognition-transfer-classification-head.py

scores: [1, 2, 0]
probabilities: [0.2447, 0.6652, 0.09]
loss=0.4076

逐步读懂代码

每行权重通过乘法与加法得到一个类别分数。在 exp 前减最大分数可缩小数值，同时保持 softmax 不变。除以总和得到约 0.2447、0.6652、0.0900。索引 1 取第二类。math.log 求自然对数，负号使损失成为 0.4076。本代码没有训练主干。

运行一个完整示例 · 01

测量两个候选框

为两个同类框计算一次抑制判断。

a = (0, 0, 4, 4)
b = (1, 1, 5, 5)
width = max(0, min(a[2], b[2]) - max(a[0], b[0]))
height = max(0, min(a[3], b[3]) - max(a[1], b[1]))
intersection = width * height
area_a = (a[2] - a[0]) * (a[3] - a[1])
area_b = (b[2] - b[0]) * (b[3] - b[1])
iou = intersection / (area_a + area_b - intersection)
print(f"intersection={intersection}; IoU={iou:.4f}")
for threshold in [0.3, 0.5]:
    print(threshold, "suppress B" if iou > threshold else "keep B")

python detection-overlap-box-overlap.py

intersection=9; IoU=0.3913
0.3 suppress B
0.5 keep B

逐步读懂代码

索引 0、2 是左右边，1、3 是上下边。min、max 找到共享部分。接着算两个面积，将共享面积减一次，再相除。for 循环测试两个阈值，行内 if 选择消息。假设 A 分数较高。例子从已有框开始，并没有从像素检测物体。

运行一个完整示例 · 01

读取三条排序检测

输入是已检查的匹配结果，不是原始框。

matches = [True, False, True]
reference_count = 2
found = 0
ap = 0.0
for rank, correct in enumerate(matches, start=1):
    found += int(correct)
    precision = found / rank
    recall = found / reference_count
    if correct:
        ap += precision / reference_count
    print(f"rank={rank}: precision={precision:.4f}, recall={recall:.4f}")
print(f"toy AP={ap:.4f}")

python detection-average-precision-ranked-ap.py

rank=1: precision=1.0000, recall=0.5000
rank=2: precision=0.5000, recall=0.5000
rank=3: precision=0.6667, recall=1.0000
toy AP=0.8333

逐步读懂代码

enumerate 提供排名及对应结果。int 把 True 变成 1、False 变成 0。found 累计匹配数。每次正确匹配使召回率增加 1/reference_count，因此贡献是 precision/reference_count。+= 加入累计值。打印的 0.8333 仅是上述教学 AP，不是完整 COCO 指标。

运行一个完整示例 · 01

统计前景重叠

用小型二值列表代替展平后的掩码。

prediction = [1, 1, 1, 0, 0, 0]
reference = [0, 1, 1, 1, 0, 0]
shared = sum(p == 1 and g == 1 for p, g in zip(prediction, reference))
union = sum(p == 1 or g == 1 for p, g in zip(prediction, reference))
iou = shared / union
dice = 2 * shared / (sum(prediction) + sum(reference))
print("shared:", shared, "union:", union)
print(f"IoU={iou:.4f}; Dice={dice:.4f}")

python segmentation-regions-mask-counts.py

shared: 2 union: 4
IoU=0.5000; Dice=0.6667

逐步读懂代码

zip 遍历对应位置。and 只在两个掩码都选中时计数；or 在任一掩码选中时计数。Python 累加时把 True 当 1、False 当 0。共享像素为二，并集为四。每个列表选中三个像素，因此 Dice 为 4/6。本例评估已有掩码，没有学习或预测掩码。

运行一个完整示例 · 02

排除忽略像素，计算分割 IoU

道路相机区分背景、道路和小物体。有些像素没有可靠标注。米娜起初把所有像素都计入，分数因此失真。她排除忽略像素，建立混淆矩阵，再从行列读取每个类别。这样，小物体有了自己的分数，不会淹没在大量背景像素中。

from math import isclose

def segmentation_report(truth, prediction, classes, ignore=255):
    if len(truth) != len(prediction) or classes <= 0:
        raise ValueError("aligned arrays and positive class count required")
    matrix = [[0] * classes for _ in range(classes)]
    for actual, predicted in zip(truth, prediction):
        if actual == ignore:
            continue
        if not (0 <= actual < classes and 0 <= predicted < classes):
            raise ValueError("unknown class")
        matrix[actual][predicted] += 1
    ious = []
    for c in range(classes):
        tp = matrix[c][c]
        actual_total = sum(matrix[c])
        predicted_total = sum(row[c] for row in matrix)
        union = actual_total + predicted_total - tp
        ious.append(tp / union if union else None)
    defined = [value for value in ious if value is not None]
    mean = sum(defined) / len(defined) if defined else None
    total = sum(map(sum, matrix))
    accuracy = sum(matrix[c][c] for c in range(classes)) / total if total else None
    return matrix, ious, mean, accuracy

truth = [0, 0, 0, 1, 1, 2, 2, 255]
prediction = [0, 0, 1, 1, 2, 2, 0, 1]
matrix, ious, mean, accuracy = segmentation_report(truth, prediction, 3)
assert matrix == [[2, 1, 0], [0, 1, 1], [1, 0, 1]]
assert isclose(mean, 7 / 18) and isclose(accuracy, 4 / 7)
assert segmentation_report([255], [1], 3)[2] is None
assert segmentation_report([0], [0], 3)[1] == [1.0, None, None]
print("rows = truth; columns = prediction:")
for row in matrix:
    print(row)
print("class IoU:", [round(value, 6) for value in ious])
print(f"mean IoU: {mean:.6f}")
print(f"pixel accuracy: {accuracy:.6f}")

python segmentation-regions-confusion-matrix-miou.py

rows = truth; columns = prediction:
[2, 1, 0]
[0, 1, 1]
[1, 0, 1]
class IoU: [0.5, 0.333333, 0.333333]
mean IoU: 0.388889
pixel accuracy: 0.571429

按执行顺序理解

1. 看到真值为忽略标签时，直接跳过；该位置的预测也不进入任何行列。

2. 对角线是 TP；行总数是真实像素数，列总数是预测像素数。

3. 并集=真实总数+预测总数-TP，减法避免交集重复计数。

4. 对有定义的类别 IoU 等权平均；若真值和预测都没有该类，则返回 None。

逐步读懂代码

IoU_c=TP_c/(TP_c+FP_c+FN_c)。背景类 TP=2、FP=1、FN=1，因此 IoU=2/4=0.5；道路和物体均为 1/3。平均 IoU=(1/2+1/3+1/3)/3=7/18，约 0.388889；像素准确率则是 4/7，它们回答的问题不同。

本混淆矩阵汇总所有参与评估的像素。先汇总全部图像再算 IoU，与先逐图算 IoU 再平均，结果可能不同，必须说明采用哪种方式。本实现只在并集为零时排除类别；真值没有某类，但模型预测过它，该类并集非零，IoU 应为零。不同基准可能采用不同缺失类别规则。

全是忽略像素的图像没有有效分数，并不表示完美预测。P 个像素、C 个类别时，本直观实现花费 O(P+C²) 时间、O(C²) 空间。比较模型时，应固定忽略掩码、类别映射、汇总方式与缩放方法。离散标签掩码不能用会产生小数类别编号的方式缩放。

运行一个完整示例 · 01

预测一条轨迹并设门限

使用等时间间隔帧中的一辆车。

previous, current = 2, 5
velocity = current - previous
predicted = current + velocity
detections = [8, 15]
nearest = min(detections, key=lambda x: abs(x - predicted))
accepted = abs(nearest - predicted) <= 2
print("predicted:", predicted)
print("nearest:", nearest, "accepted:", accepted)

python tracking-identity-track-gate.py

predicted: 8
nearest: 8 accepted: True

逐步读懂代码

相减估计速度，相加预测下一个中心。min 搜索列表。key 是一个返回距预测绝对距离的 lambda 小函数，因此选的是最小距离而非最小坐标。<= 检查门限。结果接受 8。这是单轨迹关联示例，不是训练好的跟踪器。

运行一个完整示例 · 01

统计符号差异

比较虚构二值符号图案；不是 Tesseract，也不是训练 OCR 模型。

templates = {"H": [1, 0, 1, 1, 1, 0, 1], "I": [0, 1, 0, 1, 0, 1, 0]}
observed = [1, 0, 1, 1, 1, 0, 0]
distances = {}
for label, template in templates.items():
    distances[label] = sum(a != b for a, b in zip(observed, template))
print("distances:", distances)
print("closest:", min(distances, key=distances.get))

python ocr-reading-ocr-template.py

distances: {'H': 1, 'I': 5}
closest: H

逐步读懂代码

字典为每个标签保存列表。循环用 zip 配对观察值与模板位置；不等时 != 返回 True，sum 统计 True。distances.get 将每个标签的距离提供给 min，最终选 H。这里假定长度相等，真实输入应检查。未实现文字区域检测。

运行一个完整示例 · 01

统计图像块与比较次数

先比较两种块大小，再考虑完整模型。

height, width, channels = 32, 32, 3
for patch_size in [8, 4]:
    patches = (height // patch_size) * (width // patch_size)
    values = patch_size * patch_size * channels
    tokens = patches + 1
    print(f"P={patch_size}: patches={patches}, values={values}, pairs={tokens ** 2}")

python visual-tokens-patch-budget.py

P=8: patches=16, values=192, pairs=289
P=4: patches=64, values=48, pairs=4225

逐步读懂代码

第一行给三个尺寸变量赋值。循环对边长 8 与 4 重复计算。// 是整数除法，这里尺寸都能整除。加一是类别汇总词元。**2 表示词元数乘自身。得到 289、4225 对；并未实现注意力、学习投影或训练好的 Transformer。

运行一个完整示例 · 01

找到最大变化

用四位置窄条单独说明差异图。

reference = [10, 10, 10, 10]
observed = [11, 9, 25, 10]
differences = [abs(x - r) for x, r in zip(observed, reference)]
flagged = [i for i, value in enumerate(differences) if value > 5]
print("differences:", differences)
print("flagged positions:", flagged)
print("image score:", max(differences))

python defect-inspection-difference-inspection.py

differences: [1, 1, 15, 0]
flagged positions: [2]
image score: 15

逐步读懂代码

zip 配对对齐位置。abs 去掉差值符号。第二个列表推导式用 enumerate 保留位置编号，用 if 仅留下大于 5 的值。max 得分 15。高差异只表明复核候选，不证明存在缺陷。这是使用手设参考的未训练基线。

运行一个完整示例 · 01

统计警报与漏检

从一个留出组的明确计数计算指标。

true_positive, false_positive, false_negative = 15, 10, 5
precision = true_positive / (true_positive + false_positive)
recall = true_positive / (true_positive + false_negative)
f1 = 2 * true_positive / (2 * true_positive + false_positive + false_negative)
print(f"precision={precision:.2f}; recall={recall:.2f}; F1={f1:.4f}")
sessions = {"train": {"morning-A", "evening-A"}, "test": {"morning-B"}}
print("shared sessions:", len(sessions["train"] & sessions["test"]))

python evaluation-shift-evaluate-alerts.py

precision=0.60; recall=0.75; F1=0.6667
shared sessions: 0

逐步读懂代码

第一行设置三种计数。每个除法使用该指标对应的总体。字典将划分名称映射到拍摄场次集合。& 求集合交集，len 报告共享场次为零。这只检查一种分组规则，不能排除所有可能的泄漏。这里没有模型训练。

运行一个完整示例 · 01

检查舍入与总延迟

使用明确的假设时间，并非实测。

values = [0.12, 0.26, 0.91]
step = 0.1
encoded = [round(value / step) for value in values]
restored = [number * step for number in encoded]
errors = [abs(a - b) for a, b in zip(values, restored)]
print("encoded:", encoded)
print("restored:", [round(x, 2) for x in restored])
print(f"largest error={max(errors):.2f}")
print("serial latency ms:", sum([4, 7, 2]))

python inference-pipelines-pipeline-budget.py

encoded: [1, 3, 9]
restored: [0.1, 0.3, 0.9]
largest error=0.04
serial latency ms: 13

逐步读懂代码

第一个推导式把每个数除以间隔再舍入。第二个通过乘法重建近似数。zip 将原值和重建值配对，abs 测误差。显示时保留两位小数只影响展示。sum 累加三个假设阶段时间。这个教学量化器没有转换或运行训练模型。

运行一个完整示例 · 02

把检测框还原到原始图像

米娜把宽幅相机图像放入正方形模型输入：先缩放，再补边。模型找到了物体，可直接把模型坐标画回原图时，框却错位了。她记录实际缩放尺寸和补边量，按相反顺序还原坐标，并先做往返测试，再相信显示结果。

from math import isclose

def metadata(width, height, side):
    if min(width, height, side) <= 0:
        raise ValueError("positive dimensions required")
    nominal = min(side / width, side / height)
    rw, rh = max(1, round(width * nominal)), max(1, round(height * nominal))
    return rw / width, rh / height, (side - rw) // 2, (side - rh) // 2

def forward(box, meta):
    sx, sy, px, py = meta
    x1, y1, x2, y2 = box
    return [sx * x1 + px, sy * y1 + py, sx * x2 + px, sy * y2 + py]

def restore(box, meta, width, height):
    sx, sy, px, py = meta
    x1, y1, x2, y2 = box
    restored = [(x1 - px) / sx, (y1 - py) / sy,
                (x2 - px) / sx, (y2 - py) / sy]
    clipped = [min(max(v, 0.0), limit)
               for v, limit in zip(restored, [width, height, width, height])]
    return clipped if clipped[0] < clipped[2] and clipped[1] < clipped[3] else None

original = [100.0, 50.0, 500.0, 300.0]
meta = metadata(800, 400, 640)
model_box = forward(original, meta)
restored = restore(model_box, meta, 800, 400)
assert all(isclose(a, b) for a, b in zip(original, restored))
odd_meta = metadata(853, 480, 640)
odd_back = restore(forward(original, odd_meta), odd_meta, 853, 480)
assert all(isclose(a, b) for a, b in zip(original, odd_back))
assert odd_meta[0] != odd_meta[1]  # Rounded height changes the actual y scale.
assert restore([0, 0, 20, 20], meta, 800, 400) is None
print("scale and padding:", meta)
print("model box:", model_box)
print("original box:", restored)
print("rounded-size round trip:", all(isclose(a, b) for a, b in zip(original, odd_back)))

python inference-pipelines-letterbox-coordinate-roundtrip.py

scale and padding: (0.8, 0.8, 0, 160)
model box: [80.0, 200.0, 400.0, 400.0]
original box: [100.0, 50.0, 500.0, 300.0]
rounded-size round trip: True

按执行顺序理解

1. 800×400 的图像变成 640×320，上下各补 160 像素。

2. 映射两个角点：[100,50,500,300] 变为 [80,200,400,400]。

3. 先减补边，再除缩放比例，最后裁剪到原图的连续边界。

4. 用 853×480 再测一次。取整后的实际尺寸可能导致横纵缩放比例略有不同。完全落在补边中、裁剪后面积为零的框应丢弃。

逐步读懂代码

连续框边界满足 x_prime=s_x×x+p_x、y_prime=s_y×y+p_y。s_x 和 s_y 分别是实际缩放后宽度/原宽度、实际缩放后高度/原高度。p_x、p_y 是左侧和顶部补边量。逆变换为 x=(x_prime-p_x)/s_x、y=(y_prime-p_y)/s_y。

第一张图的两个比例都是 0.8。模型中的 y=200 对应原图 (200-160)/0.8=50。853×480 取整后变成 640×360，此时 s_x=640/853，s_y=360/480。两个方向都用名义比例，会引入小误差。应保存预处理实际使用的变换。

本例使用 [0,width]、[0,height] 内的连续框边界，不是最大索引为 width-1、height-1 的整数像素坐标。实际库的像素中心和插值约定可能不同；裁剪、旋转或其他补边规则也需要记录对应变换。往返测试检验坐标记录是否自洽，不能证明检测模型准确。