多模态人工智能

运行一个完整示例 · 01

查表并汇总两个词元

小型英文例子只使用列表与字典，其表示原理适用于任何语言。

text = "red kite"
tokens = text.split()
vocabulary = {"red": 0, "kite": 1}
embedding_table = [[1.0, 0.0], [0.0, 2.0]]
ids = [vocabulary[token] for token in tokens]
vectors = [embedding_table[token_id] for token_id in ids]
pooled = [sum(vector[j] for vector in vectors) / len(vectors) for j in range(2)]
print("tokens:", tokens)
print("IDs:", ids)
print("pooled:", pooled)

python tokens-embeddings-toy-token-table.py

tokens: ['red', 'kite']
IDs: [0, 1]
pooled: [0.5, 1.0]

逐步读懂代码

split 按空白分开。字典把每个词元转为 ID；方括号查询键或列表位置。下一推导式取得每个特征列表。range(2) 遍历特征位置 0、1，sum 累加同位置元素，len 给出两个词元。这是手设查表与均值池化，不是训练文本编码器。

运行一个完整示例 · 01

比较两条说明

手设特征列表只用于说明余弦相似度，并非训练编码器输出。

import math
def unit(values):
    length = math.sqrt(sum(x * x for x in values))
    if length == 0:
        raise ValueError("A zero vector has no direction")
    return [x / length for x in values]
image = unit([3, 4])
for name, values in [("A", [0, 2]), ("B", [2, 0])]:
    text = unit(values)
    similarity = sum(a * b for a, b in zip(image, text))
    print(f"{name}: {similarity:.2f}")

python modalities-alignment-cosine-alignment.py

A: 0.80
B: 0.60

逐步读懂代码

def 定义可复用函数。sum 累加平方，math.sqrt 得到长度。if 防止除以零。列表推导式将每项除以长度。循环测试两条带名称的说明。zip 配对对应项，相乘相加得到 0.80、0.60。这些是排序分数，不是正确概率。

运行一个完整示例 · 01

只组合可用证据

使用两个给定分数，并处理一个缺失模态。

scores = {"image": 0.8, "audio": 0.4}
weights = {"image": 0.75, "audio": 0.25}
def fuse(available):
    total = sum(weights[name] for name in available)
    return sum(weights[name] * score for name, score in available.items()) / total
print(f"both={fuse(scores):.2f}")
print(f"image only={fuse({'image': 0.8}):.2f}")
print("early feature list:", [0.2, 0.9] + [0.6, 0.1])

python early-late-fusion-weighted-fusion.py

both=0.70
image only=0.80
early feature list: [0.2, 0.9, 0.6, 0.1]

逐步读懂代码

字典为分数或权重命名。fuse 只累加存在键的权重。items 提供名称与分数对，用于加权和，再除以 total 使可用权重和为一。最后的 + 连接列表，表示拼接而非数值相加。例子假设至少有一项证据且总权重为正。这是规则，不是训练多模态模型。

运行一个完整示例 · 01

匹配前检查时间

统计采样点，比较给定单位嵌入。

duration = 4
original_rate = 48000
new_rate = 16000
original_count = duration * original_rate
new_count = duration * new_rate
print("counts:", original_count, new_count)
print("wrong relabelled duration:", original_count / new_rate)
audio = [0.8, 0.6]
text = [0.6, 0.8]
print(f"similarity={sum(a * b for a, b in zip(audio, text)):.2f}")

python audio-text-alignment-audio-duration.py

counts: 192000 64000
wrong relabelled duration: 12.0
similarity=0.96

逐步读懂代码

乘法得到原采样点 192000、新采样率所需点数 64000。旧点数除以新采样率，暴露错误的 12 秒解释。zip 配对单位嵌入项，0.48 与 0.48 相加得 0.96。代码没有真正重采样波形，也没有运行 Whisper 或 CLAP，只检查时间与评分计算。

运行一个完整示例 · 01

双向给正确伙伴评分

用两对相似度表计算所述损失。

import math
similarity = [[0.8, 0.2], [0.1, 0.7]]
temperature = 0.2
scores = [[x / temperature for x in row] for row in similarity]
def loss(row, correct):
    weights = [math.exp(x - max(row)) for x in row]
    probability = weights[correct] / sum(weights)
    return -math.log(probability)
row_loss = sum(loss(row, i) for i, row in enumerate(scores)) / 2
columns = list(zip(*scores))
column_loss = sum(loss(column, i) for i, column in enumerate(columns)) / 2
print(f"image to text={row_loss:.4f}")
print(f"text to image={column_loss:.4f}")
print(f"combined={(row_loss + column_loss) / 2:.4f}")

python clip-contrastive-contrastive-table.py

image to text=0.0486
text to image=0.0543
combined=0.0515

逐步读懂代码

嵌套列表推导式将每个表项除以温度。loss 先减最大值再取 exp，使计算稳定，然后取正确份额及负对数。enumerate 提供每个对角索引。zip(*scores) 按列分组：星号把每行作为独立参数传入 zip。竞争项不同，所以两个均值不同。代码只对虚构分数算损失，没有训练 CLIP。

运行一个完整示例 · 01

让查询混合两个值

查询、键、值均为手设列表，只计算一次注意力。

import math
query = [1, 0]
keys = [[2, 0], [0, 2]]
values = [[10, 0], [0, 4]]
scores = [sum(q * k for q, k in zip(query, key)) / math.sqrt(2) for key in keys]
weights = [math.exp(s - max(scores)) for s in scores]
weights = [w / sum(weights) for w in weights]
output = [sum(weight * value[j] for weight, value in zip(weights, values)) for j in range(2)]
print("weights:", [round(w, 4) for w in weights])
print("output:", [round(x, 4) for x in output])

python cross-attention-fusion-attention-mix.py

weights: [0.8044, 0.1956]
output: [8.0443, 0.7823]

逐步读懂代码

第一个推导式为每个键计算缩放点积分数。取指数再除以总和得到和为一的权重。输出推导式的 j 依次选坐标 0、1，zip 配对权重与值列表。每个输出坐标是加权和。结果 [8.0443,0.7823] 不是复制的图像块或物体标签。未运行训练好的 Transformer。

运行一个完整示例 · 01

查找并检查前二项

使用三个给定单位嵌入与独立核实的相关性。

query = [1.0, 0.0]
images = {"kite": [0.8, 0.6], "umbrella": [1.0, 0.0], "kite-detail": [0.6, 0.8]}
scores = {name: sum(q * x for q, x in zip(query, vector)) for name, vector in images.items()}
ranked = sorted(scores, key=scores.get, reverse=True)
top_two = ranked[:2]
relevant = {"kite", "kite-detail"}
recall = len(set(top_two) & relevant) / len(relevant)
print("ranking:", ranked)
print(f"Recall@2={recall:.2f}")

python image-text-search-search-ranking.py

ranking: ['umbrella', 'kite', 'kite-detail']
Recall@2=0.50

逐步读懂代码

字典推导式为每图计算点积。sorted 按名称对应分数排列，reverse=True 将高分放前。[:2] 取前二。set 去除重复名称，& 找到返回项中相关者，len 计数。即使首位高分，召回率仍是 0.50。这是排序计算，不是训练图像搜索服务。

运行一个完整示例 · 02

评估每条查询有多个正确结果的检索任务

米娜用短文本搜索图像库。一条查询有两张正确图片，另一条只有一张，第三条在库中没有标注匹配。排序结果还出现了重复图片编号。她先去重，明确 recall 的具体定义，并单独报告不能评分的查询，而不是悄悄把它们隐藏。

from math import isclose

def retrieval_report(queries, k):
    if k <= 0:
        raise ValueError("positive k required")
    recalls, hits, reciprocal = [], [], []
    found_total = relevant_total = unscored = 0
    for ranked, relevant in queries:
        ranked = list(dict.fromkeys(ranked))  # Preserve the first occurrence.
        relevant = set(relevant)
        if not relevant:
            unscored += 1
            continue
        found = len(set(ranked[:k]) & relevant)
        recalls.append(found / len(relevant))
        hits.append(int(found > 0))
        first = next((i for i, item in enumerate(ranked, 1) if item in relevant), None)
        reciprocal.append(1 / first if first is not None else 0.0)
        found_total += found
        relevant_total += len(relevant)
    count = len(recalls)
    if not count:
        return {"scored": 0, "unscored": unscored, "macro_recall": None,
                "micro_recall": None, "hit_rate": None, "mrr": None}
    return {"scored": count, "unscored": unscored,
            "macro_recall": sum(recalls) / count,
            "micro_recall": found_total / relevant_total,
            "hit_rate": sum(hits) / count,
            "mrr": sum(reciprocal) / count}

queries = [(["a", "a", "x", "b"], {"a", "b"}),
           (["z", "c", "d"], {"c"}),
           (["x", "z"], set())]
report = retrieval_report(queries, 2)
assert isclose(report["macro_recall"], 0.75)
assert isclose(report["micro_recall"], 2 / 3)
assert report["hit_rate"] == 1.0 and report["mrr"] == 0.75
assert retrieval_report([([], {"a"})], 2)["mrr"] == 0.0
assert retrieval_report([([], set())], 2)["macro_recall"] is None
print(f"scored: {report['scored']}; unscored: {report['unscored']}")
for metric in ["macro_recall", "micro_recall", "hit_rate", "mrr"]:
    print(f"{metric}: {report[metric]:.6f}")

python image-text-search-multi-query-retrieval-report.py

scored: 2; unscored: 1
macro_recall: 0.750000
micro_recall: 0.666667
hit_rate: 1.000000
mrr: 0.750000

按执行顺序理解

1. 本规则先去重，再截取前 k 个；同一图片不能占两个结果位置。

2. 第一条查询的前两个不同结果是 a、x，只找到两张正确图片中的一张。

3. 第二条在第 2 名找到唯一正确图片；召回率为 1，倒数排名为 1/2。

4. 没有标注正确结果的查询计为未评分；单独报告覆盖情况，避免除以零。

逐步读懂代码

对查询 q，R_q 是正确结果集合，T_q 是前 k 个不重复结果。比例召回率为 |T_q∩R_q|/|R_q|。宏平均召回率对 Q 条可评分查询的比例等权平均；微平均召回率用找到的正确结果总数除以正确结果总数。本例宏平均=(1/2+1)/2=0.75，微平均=(1+1)/(2+1)=2/3。

Hit@k 统计“至少找到一个正确结果”的查询比例，本例为 1。MRR 对 1/r_q 求平均，其中 r_q 是完整输入排序去重后首个正确结果的名次；没有找到则记零。本例 MRR=(1+1/2)/2=0.75。一些图文检索基准把前 k 名命中率称为 Recall@k；每条只有一个正例时，它与比例召回率相同，多正例时未必相同，必须公开定义。

三条查询中两条可评分。第三条可能暴露标注缺失，或库中确实没有答案。排除它并不表示测过正确拒答能力；拒答需要包含已知无答案查询的独立规则。相似度只负责排序，不能证明相关性。比较系统时应固定语料库、去重方式、标注和截断位置。在哈希操作平均常数时间的假设下，成本与输入排序列表及相关集合总大小线性相关。

运行一个完整示例 · 01

比较两种可能回答

用给定条件概率单独说明序列评分，不加载文本或图像模型。

import math
correct = [0.4, 0.5, 0.9]
incorrect = [0.5, 0.7, 0.9]
probability = math.prod(correct)
mean_loss = -sum(math.log(p) for p in correct) / len(correct)
print(f"correct probability={probability:.3f}")
print(f"incorrect probability={math.prod(incorrect):.3f}")
print(f"mean loss={mean_loss:.4f}")

python conditional-generation-response-probability.py

correct probability=0.180
incorrect probability=0.315
mean loss=0.5716

逐步读懂代码

math.prod 将全部元素相乘。生成式对每个正确词元概率取自然对数，sum 相加，len 给出词元数三。负平均为 0.5716。错误回答的概率为 0.315，高于正确回答的 0.180。手设数值说明模型似然与视觉事实需要分别检查。

运行一个完整示例 · 01

让文字保留行关系

每个元组保存文字和像素坐标框。

words = [("Friday", (10, 40, 80, 60)), ("Room 3", (100, 40, 170, 60)), ("Room 8", (100, 80, 170, 100))]
target_y = 50
selected = []
for text, box in words:
    centre_y = (box[1] + box[3]) / 2
    if abs(centre_y - target_y) <= 5:
        selected.append((box[0], text))
selected.sort()
print("row:", [text for left, text in selected])
print("normalized x:", 1000 * 100 / 500)

python document-ocr-qa-document-row.py

row: ['Friday', 'Room 3']
normalized x: 200.0

逐步读懂代码

循环解包文字与框。索引 1、3 选择上下边，平均得行中心。abs 与 <= 检查垂直距离。append 保存通过项的左边坐标与文字。sort 按左边坐标排序，最后推导式只打印文字。该行为 Friday、Room 3。框是给定的，不是 OCR 预测。

运行一个完整示例 · 01

统计一个词的变化

从人工核实的一次替换例子开始。

reference = "bring the new box".split()
substitutions, deletions, insertions = 1, 0, 0
wer = (substitutions + deletions + insertions) / len(reference)
print("reference words:", len(reference))
print(f"WER={wer:.2f}")
short_reference_count = 2
print(f"three insertions WER={3 / short_reference_count:.2f}")

python speech-tasks-word-error-rate.py

reference words: 4
WER=0.25
three insertions WER=1.50

逐步读懂代码

split 生成四词参考列表，len 计数。下一行给出已核实编辑次数。先将编辑次数相加，再除以参考长度。最后例子为 1.50，因为插入数不受参考长度限制。这些计算没有实现语音识别或通用编辑距离算法。

运行一个完整示例 · 01

寻找延迟拍手

用二值事件位置代替真实音画特征。

visual = [0, 1, 0, 0, 0]
audio = [0, 0, 1, 0, 0]
scores = {}
for shift in [-1, 0, 1]:
    total = 0
    for t in range(len(visual)):
        j = t + shift
        if 0 <= j < len(audio):
            total += visual[t] * audio[j]
    scores[shift] = total
best_shift = max(scores, key=scores.get)
print("shift scores:", scores)
print(f"audio delay seconds={best_shift * 0.1:.1f}")

python audio-video-sync-sync-offset.py

shift scores: {-1: 0, 0: 0, 1: 1}
audio delay seconds=0.1

逐步读懂代码

外循环测试三个偏移，内循环遍历视频位置。j 为要比较的音频位置。连续比较先检查范围，再索引。相乘统计同时为一的事件对，+= 累加。max 选择最高分偏移，得到 +1，即延迟 0.1 秒。代码没有运行 SyncNet 或修改媒体文件。

运行一个完整示例 · 02

用时间戳、偏移和容差对齐事件

米娜核对视频与音频事件日志。视频帧间隔不完全相等，音频时钟比视频时钟快 20 毫秒。用时间乘猜测的帧率，会匹配错帧。她先把音频时间转换到视频时钟，再查找最近的实际帧，距离太远的事件保留为未匹配。

from bisect import bisect_left
from math import isclose

def nearest_frame(timestamps, event_time, offset, tolerance):
    if tolerance < 0 or not timestamps:
        raise ValueError("nonempty timestamps and nonnegative tolerance required")
    if any(a >= b for a, b in zip(timestamps, timestamps[1:])):
        raise ValueError("frame timestamps must be strictly increasing")
    target = event_time - offset  # audio_time = video_time + offset
    insertion = bisect_left(timestamps, target)
    candidates = [i for i in (insertion - 1, insertion) if 0 <= i < len(timestamps)]
    best = min(candidates, key=lambda i: (abs(timestamps[i] - target), i))
    error = abs(timestamps[best] - target)
    return (best, error) if error <= tolerance else None

video = [0.0, 0.041, 0.083, 0.126, 0.168]
events = [0.061, 0.104, 0.300]
matches = [nearest_frame(video, event, 0.020, 0.010) for event in events]
assert matches[0][0] == 1 and isclose(matches[0][1], 0.0, abs_tol=1e-12)
assert matches[1][0] == 2 and isclose(matches[1][1], 0.001)
assert matches[2] is None
assert nearest_frame([0.0, 2.0], 1.0, 0.0, 1.0)[0] == 0
for event, match in zip(events, matches):
    if match is None:
        print(f"audio {event:.3f}: unmatched")
    else:
        index, error = match
        print(f"audio {event:.3f}: frame {index}, error {error:.3f} s")

python audio-video-sync-timestamp-nearest-alignment.py

audio 0.061: frame 1, error 0.000 s
audio 0.104: frame 2, error 0.001 s
audio 0.300: unmatched

按执行顺序理解

1. 先明确时钟关系：音频时间=视频时间+0.020 秒，因此换算时要减去偏移。

2. 二分查找定位插入点，只有紧邻它的前后两帧可能最近。

3. 选择距离较小者；距离完全相同时选较早帧。

4. 拒绝最后事件：0.300-0.020=0.280，与最后一帧相差 0.112 秒。

逐步读懂代码

设音频时间为 a，已知时钟偏移为 delta，实际视频帧时间为 v_i。寻找 i_star=argmin_i |v_i-(a-delta)|，只有最小距离不超过容差 tau 才接受。这里 tau=0.010 秒，前两个校正后事件为 0.041、0.084，与帧相差 0、0.001 秒。

delta 的正负取决于先声明的时钟方程，不能靠猜。所有量必须使用相同单位。帧间隔不同时，帧编号本身并不等于呈现时间。本程序假设有限数值时间戳与已知恒定偏移；若时钟有漂移，还可能需要标定比例，例如 audio_time=scale×video_time+offset。

每次调用先用 O(F) 检查排序，再做 O(log F) 搜索，所以完整函数为 O(F)。实际索引可以只检查一次，后续每次查询 O(log F)。这是最近点匹配，不是插值、一对一分配，也不是学习式音画同步。有些任务应匹配时间区间；时间相近也不能证明声音与画面事件具有相同成因。

运行一个完整示例 · 01

采样视频并比较区间

只用时间戳，不需要视频文件。

timestamps = list(range(0, 12, 2))
short_event = (5.2, 5.7)
seen = any(short_event[0] <= t <= short_event[1] for t in timestamps)
predicted = (5, 9)
reference = (4, 8)
intersection = max(0, min(predicted[1], reference[1]) - max(predicted[0], reference[0]))
union = (predicted[1] - predicted[0]) + (reference[1] - reference[0]) - intersection
print("sample times:", timestamps)
print("short event sampled:", seen)
print(f"temporal IoU={intersection / union:.2f}")

python video-temporal-grounding-temporal-overlap.py

sample times: [0, 2, 4, 6, 8, 10]
short event sampled: False
temporal IoU=0.60

逐步读懂代码

range 从零开始，每次加二，到 12 之前停止。any 在至少一个时间戳落入短事件时为 True，这里没有。终点取 min、起点取 max 找共享区间。再与零取 max 防止负时长。两区间长度相加减重叠，得并集五。代码评估给定区间，不运行视频模型。

运行一个完整示例 · 01

调整连接器，保留特征

不使用微积分或模型库，尝试两个权重。

fixed_feature = 2.0
target = 1.0
for weight in [1.0, 0.75]:
    output = weight * fixed_feature
    error = output - target
    loss = error ** 2 / 2
    print(f"weight={weight:.2f}; feature={fixed_feature:.1f}; loss={loss:.3f}")

python visual-instruction-tuning-frozen-feature.py

weight=1.00; feature=2.0; loss=0.500
weight=0.75; feature=2.0; loss=0.125

逐步读懂代码

特征与目标只赋值一次。for 循环测试两个连接权重。乘法得到输出，相减得到有符号误差，**2 平方后除以二。特征不变时，损失从 0.500 降至 0.125。这只是尝试比较，不是梯度训练或完整视觉指令模型。

运行一个完整示例 · 01

返回答案及证据 ID

用小字典代替真实文档库与训练生成器。

query = set("model opening upward".split())
records = [
    {"id": "sheet-A", "terms": "model opening upward arrow", "answer": "arrow-marked opening", "page": 2, "region": "diagram-A"},
    {"id": "sheet-B", "terms": "model paint dry", "answer": None, "page": 3, "region": "paragraph-B"},
]
def overlap(record):
    return len(query & set(record["terms"].split()))
best = max(records, key=overlap)
print("retrieval score:", overlap(best))
if best["answer"] is not None:
    print("answer:", best["answer"])
    print("evidence:", best["id"], "page", best["page"], best["region"])
else:
    print("No checked answer in the retrieved evidence")

python multimodal-rag-retrieve-cite.py

retrieval score: 3
answer: arrow-marked opening
evidence: sheet-A page 2 diagram-A

逐步读懂代码

split 切分词，set 保留不同词。& 找共同词，len 计数。max 对每条记录调用 overlap，选择最高分。if 要求存在核实答案字段后才打印。引用保留记录、页码、区域。本例仅传递给定证据，没有实现 MuRAG，也不证明词重合必然相关。

运行一个完整示例 · 01

统计无依据提及与覆盖

使用虚构且已核实的审查计数。

mentions, unsupported = 40, 6
captions, captions_with_error = 10, 4
correct_distinct, target_objects = 34, 50
print(f"unsupported mention rate={unsupported / mentions:.2f}")
print(f"captions with errors={captions_with_error / captions:.2f}")
print(f"target coverage={correct_distinct / target_objects:.2f}")
print(f"short revision coverage={19 / target_objects:.2f}")

python evaluation-hallucination-claim-audit.py

unsupported mention rate=0.15
captions with errors=0.40
target coverage=0.68
short revision coverage=0.38

逐步读懂代码

前三行分别命名提及数、描述数、不同目标物体数三种总体。每个除法使用相应分母，结果为 0.15、0.40、0.68。最后一行显示只提及 19 个正确目标时覆盖为 0.38。这些是核实计数的比值，代码无法自行判断图像证据或实现完整标注协议。

运行一个完整示例 · 01

比较全量处理与候选列表

使用假设成本单位与简单证据预算。

candidate_count = 100
cheap_cost, expensive_cost = 1, 10
shortlist_size = 5
full_cost = candidate_count * expensive_cost
cascade_cost = candidate_count * cheap_cost + shortlist_size * expensive_cost
print("costs:", full_cost, cascade_cost)
print(f"saved fraction={1 - cascade_cost / full_cost:.2f}")
evidence_tokens = [80, 60, 90]
budget = 150
used = 0
kept = []
for index, count in enumerate(evidence_tokens):
    if used + count <= budget:
        kept.append(index)
        used += count
print("kept evidence indices:", kept, "tokens:", used)

python efficient-evidence-systems-cascade-budget.py

costs: 1000 150
saved fraction=0.85
kept evidence indices: [0, 1] tokens: 140

逐步读懂代码

先用算术比较假设逐项成本。enumerate 给每个证据条目索引与词元数。if 检查加入后是否仍在预算内。append 记录接受的索引，+= 更新已用数。条目 0、1 使用 140 词元，所以条目 2 被丢弃。这个贪心预算规则不判断相关性，也不运行模型，被删证据可能很关键。