两条都是正确资料，为什么一种损失还会压低其中一条？

"""Compare single-positive and two multi-positive score-level objectives."""
import math


def objective(scores, positives, mode):
    if (not scores or not positives or len(set(positives)) != len(positives)
            or any(i < 0 or i >= len(scores) for i in positives)
            or any(not math.isfinite(x) for x in scores)):
        raise ValueError("finite scores and unique, valid positive indices required")
    # Keep losses and probabilities centered; adding back a huge max loses log(n).
    high = max(scores)
    shifted = [s - high for s in scores]
    if any(not math.isfinite(value) for value in shifted):
        raise ValueError("score difference exceeds finite floating-point range")
    weights = [math.exp(s) for s in shifted]
    total = math.fsum(weights)
    log_z = math.log(total)
    probability = [weight / total for weight in weights]
    gradient = probability.copy()
    if mode == "single":
        chosen = positives[0]
        loss = log_z - shifted[chosen]
        gradient[chosen] -= 1
    elif mode == "outside_mean":
        loss = math.fsum((log_z - shifted[i]) / len(positives) for i in positives)
        for i in positives:
            gradient[i] -= 1 / len(positives)
    elif mode in ("positive_mass", "inside_mean"):
        # Positive-only normalization needs its own max, even after global centering.
        positive_high = max(shifted[i] for i in positives)
        positive_weights = [math.exp(shifted[i] - positive_high) for i in positives]
        positive_total = math.fsum(positive_weights)
        loss = (log_z - positive_high) - math.log(positive_total)
        for i, weight in zip(positives, positive_weights):
            gradient[i] -= weight / positive_total
        if mode == "inside_mean":
            loss += math.log(len(positives))
    else:
        raise ValueError("unknown objective")
    return loss, gradient, probability


def main():
    scores, positives = [4.0, 0.0, -1.0], (0, 1)
    modes = ("single", "positive_mass", "inside_mean", "outside_mean")
    results = {mode: objective(scores, positives, mode) for mode in modes}
    checks = {}
    for mode in modes:
        loss, gradient, _ = results[mode]
        checks[mode + "_finite"] = math.isfinite(loss)
        checks[mode + "_gradient_sum_zero"] = abs(sum(gradient)) < 1e-12
        h = 1e-5
        for i in range(len(scores)):
            high, low = scores.copy(), scores.copy()
            high[i] += h
            low[i] -= h
            numerical = (objective(high, positives, mode)[0]
                         - objective(low, positives, mode)[0]) / (2 * h)
            checks[f"{mode}_finite_difference_{i}"] = math.isclose(numerical, gradient[i], abs_tol=1e-9)
    checks["single_pushes_down_unmarked_positive"] = results["single"][1][1] > 0
    checks["mass_pushes_up_strong_positive"] = results["positive_mass"][1][0] < 0
    checks["outside_pushes_down_strong_positive"] = results["outside_mean"][1][0] > 0
    checks["outside_pushes_up_weak_positive"] = results["outside_mean"][1][1] < 0
    checks["inside_constant_difference"] = math.isclose(results["inside_mean"][0] - results["positive_mass"][0], math.log(2))
    checks["inside_same_gradient_as_mass"] = results["inside_mean"][1] == results["positive_mass"][1]
    checks["one_positive_same_objective"] = all(math.isclose(objective(scores, (0,), mode)[0], results["single"][0]) for mode in modes)
    checks["all_positive_mass_zero"] = abs(objective(scores, (0, 1, 2), "positive_mass")[0]) < 1e-12
    checks["constant_shift_invariant"] = all(math.isclose(objective([s + 1000 for s in scores], positives, mode)[0], results[mode][0], abs_tol=1e-12) for mode in modes)
    equal = {mode: objective([0.0, 0.0, 0.0], positives, mode) for mode in modes}
    huge = {mode: objective([1e16, 1e16, 1e16], positives, mode) for mode in modes}
    checks["huge_equal_losses"] = all(math.isclose(huge[mode][0], equal[mode][0], abs_tol=1e-12) for mode in modes)
    checks["huge_equal_gradients"] = all(huge[mode][1] == equal[mode][1] for mode in modes)
    checks["huge_equal_probabilities"] = all(huge[mode][2] == [1 / 3] * 3 for mode in modes)
    checks["huge_negative_equal_scores"] = all(objective([-1e16] * 3, positives, mode) == equal[mode] for mode in modes)
    distant = objective([0.0, -1e16, -1e16], (1, 2), "positive_mass")
    checks["distant_positive_cluster"] = distant[1] == [1.0, -0.5, -0.5]
    all_huge = objective([1e16] * 3, (0, 1, 2), "positive_mass")
    checks["huge_all_positive_zero"] = all_huge[0] == 0.0 and all_huge[1] == [0.0] * 3
    assert all(checks.values()), checks
    print("scores=[4, 0, -1]; positives=[0, 1]; scores already include temperature")
    print("probabilities=[" + ", ".join(f"{x:.6f}" for x in results['single'][2]) + "]")
    for mode in modes:
        loss, gradient, _ = results[mode]
        print(f"{mode}: loss={loss:.6f} gradient=[" + ", ".join(f"{g:.6f}" for g in gradient) + "]")
    print(f"inside_minus_mass=ln(2)={math.log(2):.6f}")
    print(f"PASS {len(checks)} checks; free-score derivatives only, no encoder training")


if __name__ == "__main__":
    main()