整段向量一样像，逐词匹配为什么能分出差别？

"""Fixed-vector late interaction, with explicit document and query masks."""
import itertools
import json
import math
from pathlib import Path


def dot(a,b):
    if len(a) != len(b):
        raise ValueError('vector dimensions differ')
    return sum(x*y for x,y in zip(a,b))


def unit(vector):
    length = math.sqrt(dot(vector,vector))
    if not math.isfinite(length) or length <= 0:
        raise ValueError('nonzero finite vector required')
    return [x/length for x in vector]


def pooled_unit(vectors):
    return unit([sum(row[d] for row in vectors)/len(vectors) for d in range(len(vectors[0]))])


def maxsim(query, document, query_mask=None, document_mask=None):
    if not query or not document:
        raise ValueError('nonempty query and document required')
    dim = len(query[0])
    if dim == 0 or any(len(row)!=dim or not all(math.isfinite(x) for x in row)
                       for row in query+document):
        raise ValueError('finite equal-width vectors required')
    qm = [True]*len(query) if query_mask is None else query_mask
    dm = [True]*len(document) if document_mask is None else document_mask
    if len(qm)!=len(query) or len(dm)!=len(document) or not all(type(v) is bool for v in qm+dm):
        raise ValueError('one boolean mask per position required')
    if not any(qm) or not any(dm):
        raise ValueError('at least one active position on both sides required')
    matrix = [[dot(q,d) for d in document] for q in query]
    contributions = [max(value for value,active in zip(row,dm) if active)
                     for row,active_query in zip(matrix,qm) if active_query]
    return {'score':sum(contributions),'contributions':contributions,'matrix':matrix}


def main():
    e1, e2 = [1.0,0.0], [0.0,1.0]
    diagonal = unit([1.0,1.0])
    query, doc_a, doc_b = [e1,e2], [e1,e2], [diagonal,diagonal]
    a, b = maxsim(query,doc_a), maxsim(query,doc_b)
    pooled_a = dot(pooled_unit(query),pooled_unit(doc_a))
    pooled_b = dot(pooled_unit(query),pooled_unit(doc_b))
    assert math.isclose(pooled_a,1) and math.isclose(pooled_b,1)
    assert math.isclose(a['score'],2) and math.isclose(b['score'],math.sqrt(2))
    # Fixed-vector permutation and exact duplicate invariances, not raw-text claims.
    invariant_cases = 0
    for doc in [doc_a,doc_b,[[0.6,0.8],[-1.0,0.0],e2]]:
        reference = maxsim(query,doc)['score']
        for permutation in itertools.permutations(doc):
            assert math.isclose(maxsim(query,list(permutation))['score'],reference)
            invariant_cases += 1
        for token in doc:
            assert math.isclose(maxsim(query,doc+[token])['score'],reference)
            invariant_cases += 1
    duplicated_query = maxsim(query+[e1],doc_a)['score']
    forward = maxsim([e1,e1],[e1])['score']
    reverse = maxsim([e1],[e1,e1])['score']
    assert forward == 2 and reverse == 1 and duplicated_query == 3
    valid_negative = [-0.6,0.8]
    masked = maxsim([e1],[valid_negative,[0.0,0.0]],document_mask=[True,False])['score']
    bad_padding = maxsim([e1],[valid_negative,[0.0,0.0]])['score']
    assert masked == -0.6 and bad_padding == 0
    masked_query = maxsim(query+[e1],doc_a,query_mask=[True,True,False])['score']
    assert masked_query == a['score']
    assert maxsim(query+[e1],doc_a)['score'] == masked_query + 1
    rejected = 0
    for call in [lambda:maxsim(query,doc_a,document_mask=[False,False]),
                 lambda:maxsim(query,doc_a,query_mask=[False,False]),
                 lambda:maxsim(query,[[1.0]]),
                 lambda:maxsim(query,doc_a,document_mask=[True])]:
        try:
            call()
        except ValueError:
            rejected += 1
    assert rejected == 4
    report={'scope':'fixed vectors only; no text encoder, index, retrieval dataset or training',
        'query':query,'doc_a':doc_a,'doc_b':doc_b,'a':a,'b':b,
        'pooled_cosines':[pooled_a,pooled_b],'invariance_cases':invariant_cases,
        'query_duplicate_score':duplicated_query,'asymmetry_forward':forward,'asymmetry_reverse':reverse,
        'negative_valid_masked_score':masked,'incorrect_zero_padding_score':bad_padding,
        'masked_query_score':masked_query,'rejected_inputs':rejected,'checks_passed':True}
    Path('report.json').write_text(json.dumps(report,indent=2)+'\n',encoding='utf-8')
    print('pooled cosine: A={:.6f} B={:.6f}'.format(pooled_a,pooled_b))
    print('MaxSim: A={:.6f} B={:.6f}'.format(a['score'],b['score']))
    print('A token contributions =',a['contributions'])
    print('B token contributions =',[round(x,6) for x in b['contributions']])
    print('duplicate query token: score={:.6f}'.format(duplicated_query))
    print('asymmetry: S(Q,D)={:.6f} S(D,Q)={:.6f}'.format(forward,reverse))
    print('negative valid match: masked={:.6f} unmasked-zero-padding={:.6f}'.format(masked,bad_padding))
    print('invariance_cases={} rejected_inputs={}'.format(invariant_cases,rejected))
    print('checks=PASS; report.json written')


if __name__ == '__main__':
    main()