两张图的 Dice 都算对了，平均分为什么不一样？

"""Dice aggregation and empty-target gradients; Python standard library."""
import json
import math
from pathlib import Path


def parts(pred, target):
    if not pred or len(pred) != len(target):
        raise ValueError('nonempty equal lengths required')
    if not all(math.isfinite(p) and 0 <= p <= 1 for p in pred):
        raise ValueError('predictions must be finite probabilities')
    if not all(y in (0, 1) for y in target):
        raise ValueError('binary labels required')
    return 2 * sum(p*y for p,y in zip(pred,target)), sum(pred)+sum(target)


def dice(pred, target, smooth_nr=0.0, smooth_dr=0.0):
    n,d=parts(pred,target)
    if not all(math.isfinite(s) and s >= 0 for s in (smooth_nr,smooth_dr)):
        raise ValueError('nonnegative finite smoothing required')
    if d+smooth_dr == 0:
        raise ValueError('undefined empty/empty Dice; choose a policy')
    return (n+smooth_nr)/(d+smooth_dr)


def loss_gradient(pred,target,a,b):
    n,d=parts(pred,target)
    n += a; d += b
    return [(n-2*y*d)/(d*d) for y in target]


def main():
    batch=[([1.0]*9,[1]*9),([1.0,0.0],[0,1])]
    individual=[dice(p,y) for p,y in batch]
    macro=sum(individual)/len(individual)
    sums=[parts(p,y) for p,y in batch]
    pooled=sum(n for n,d in sums)/sum(d for n,d in sums)
    weighted=sum(d*s for (n,d),s in zip(sums,individual))/sum(d for n,d in sums)
    assert macro == 0.5 and pooled == weighted == 0.9
    # A different batching policy changes the mean of batch Dice scores.
    microbatch_mean=macro
    whole_batch=pooled
    empty=[0.0,0.0]; labels=[0,0]; epsilon=1e-5
    empty_both=dice(empty,labels,epsilon,epsilon)
    empty_denominator=dice(empty,labels,0,epsilon)
    assert empty_both == 1 and empty_denominator == 0
    pred=[0.2,0.1]
    grad=loss_gradient(pred,labels,epsilon,epsilon)
    no_numerator=loss_gradient(pred,labels,0,epsilon)
    h=1e-6
    fd=[]
    for i in range(len(pred)):
        up=pred[:]; down=pred[:]; up[i]+=h; down[i]-=h
        fd.append(((1-dice(up,labels,epsilon,epsilon))-(1-dice(down,labels,epsilon,epsilon)))/(2*h))
    assert max(abs(a-b) for a,b in zip(grad,fd)) < 1e-9
    assert no_numerator == [0.0,0.0]
    rejected=[]
    for p,y in [([],[]),([1,0],[1]),([float('nan')],[0]),([0],[2])]:
        try: parts(p,y)
        except ValueError: rejected.append(True)
    try: dice(empty,labels)
    except ValueError: rejected.append(True)
    assert len(rejected)==5
    report=dict(individual=individual,macro=macro,pooled=pooled,denominator_weighted=weighted,
        microbatch_mean=microbatch_mean,whole_batch=whole_batch,empty_both_smoothed=empty_both,
        empty_denominator_only=empty_denominator,empty_target_loss_gradient=grad,
        finite_difference=fd,denominator_only_gradient=no_numerator,invalid_rejections=len(rejected),checks_passed=True)
    Path('report.json').write_text(json.dumps(report,indent=2)+'\n',encoding='utf-8')
    print('per-image Dice =',individual)
    print(f'mean of image scores={macro:.6f}; pooled score={pooled:.6f}')
    print(f'empty/empty: numerator+denominator={empty_both:.1f}; denominator-only={empty_denominator:.1f}')
    print('empty-target gradient with numerator smoothing =',[round(x,9) for x in grad])
    print('empty-target gradient with denominator-only smoothing =',no_numerator)
    print('checks=PASS; report.json written')


if __name__ == '__main__': main()