扩散训练换成预测原图，为什么损失不能照搬？

"""Cumulative Gaussian noise and target-loss identities; no model training."""
import json
import math
from pathlib import Path


def cumulative_schedule(betas):
    result = [1.0]  # mathematical time t=0 is clean input
    for beta in betas:
        if not math.isfinite(beta) or not 0 < beta < 1:
            raise ValueError('each beta must be finite and in (0, 1)')
        result.append(result[-1] * (1 - beta))
    return result


def coefficients(alpha_bar):
    if not math.isfinite(alpha_bar) or not 0 < alpha_bar < 1:
        raise ValueError('target conversion requires 0 < alpha_bar < 1')
    return math.sqrt(alpha_bar), math.sqrt(1-alpha_bar)


def target_case(alpha_bar, x0, epsilon, delta):
    a, b = coefficients(alpha_bar)
    xt = a*x0 + b*epsilon
    epsilon_hat = epsilon + delta
    x0_hat = (xt - b*epsilon_hat) / a
    velocity = a*epsilon - b*x0
    # Derive v_hat from the SAME x0_hat, rather than another independent error.
    velocity_hat = (a*xt - x0_hat) / b
    loss_epsilon = (epsilon_hat-epsilon)**2
    loss_x0 = (x0_hat-x0)**2
    loss_velocity = (velocity_hat-velocity)**2
    snr = alpha_bar/(1-alpha_bar)
    assert math.isclose(loss_epsilon, snr*loss_x0, rel_tol=1e-11, abs_tol=1e-12)
    assert math.isclose(loss_velocity, (snr+1)*loss_x0, rel_tol=1e-11, abs_tol=1e-12)
    assert math.isclose(a*xt-b*velocity, x0, abs_tol=1e-12)
    assert math.isclose(b*xt+a*velocity, epsilon, abs_tol=1e-12)
    # Intentionally interpret the exact v as epsilon to demonstrate mismatch.
    wrong_x0 = (xt-b*velocity)/a
    return {'alpha_bar':alpha_bar,'a':a,'b':b,'xt':xt,'epsilon':epsilon,
        'velocity':velocity,'x0_hat':x0_hat,'loss_epsilon':loss_epsilon,
        'loss_x0':loss_x0,'loss_velocity':loss_velocity,'snr':snr,
        'wrong_x0_using_v_as_epsilon':wrong_x0}


def main():
    betas, noises, x0 = [0.1, 0.2, 0.25], [0.3, -0.4, 0.2], 2.0
    bars = cumulative_schedule(betas)
    current, variance, weights = x0, 0.0, []
    rows = []
    for time, (beta, z) in enumerate(zip(betas,noises), start=1):
        alpha = 1-beta
        current = math.sqrt(alpha)*current + math.sqrt(beta)*z
        variance = alpha*variance + beta
        weights = [math.sqrt(alpha)*weight for weight in weights] + [math.sqrt(beta)]
        residual = sum(weight*noise for weight,noise in zip(weights,noises[:time]))
        a, b = coefficients(bars[time])
        effective_epsilon = residual/b
        direct = a*x0+b*effective_epsilon
        wrong_last_noise = a*x0+b*z
        assert math.isclose(current,direct,abs_tol=1e-12)
        assert math.isclose(variance,1-bars[time],abs_tol=1e-12)
        assert math.isclose(sum(w*w for w in weights),variance,abs_tol=1e-12)
        rows.append({'t':time,'beta':beta,'alpha_bar':bars[time],
            'variance':variance,'noise_weights':weights,'effective_epsilon':effective_epsilon,
            'sequential_xt':current,'direct_xt':direct,'wrong_xt_using_last_noise':wrong_last_noise})
    cases = [target_case(bar,x0,0.5,0.2) for bar in [0.9,0.5,0.1]]
    # Cross-check identities over a grid of finite interior schedules and targets.
    grid_checks = 0
    for bar in [0.01,0.1,0.5,0.9,0.99]:
        for original in [-2.0,0.0,2.0]:
            for epsilon in [-0.7,0.0,0.5]:
                for delta in [-0.3,0.0,0.2]:
                    target_case(bar,original,epsilon,delta)
                    grid_checks += 1
    rejected = 0
    for bad in [0,1,-0.1,float('nan')]:
        try:
            coefficients(bad)
        except ValueError:
            rejected += 1
    assert rejected == 4
    report={'scope':'fixed scalar Gaussian algebra; no images, reverse sampler or training',
        'betas':betas,'alpha_bar_including_clean_t0':bars,'sequential':rows,
        'target_cases':cases,'identity_grid_cases':grid_checks,
        'rejected_conversion_boundaries':rejected,'checks_passed':True}
    Path('report.json').write_text(json.dumps(report,indent=2)+'\n',encoding='utf-8')
    print('alpha_bar[t=0..3] =', [round(x,6) for x in bars])
    for row in rows:
        print('t={} variance={:.6f} xt={:.6f} effective_eps={:.6f} last-noise-xt={:.6f}'.format(
            row['t'],row['variance'],row['sequential_xt'],row['effective_epsilon'],row['wrong_xt_using_last_noise']))
    for row in cases:
        print('alpha_bar={:.1f} SNR={:.6f} L_eps={:.6f} L_x0={:.6f} L_v={:.6f}'.format(
            row['alpha_bar'],row['snr'],row['loss_epsilon'],row['loss_x0'],row['loss_velocity']))
    print('same exact v decoded as epsilon at alpha_bar=0.5: x0={:.6f}'.format(cases[1]['wrong_x0_using_v_as_epsilon']))
    print('identity_grid_cases={} boundaries_rejected={}'.format(grid_checks,rejected))
    print('checks=PASS; report.json written')


if __name__ == '__main__':
    main()