papers/generator-augmented-flows/sau.json

{
  "paper_id": "generator-augmented-flows",
  "paper_title": "Improving Consistency Models with Generator-Augmented Flows",
  "D1": [
    {
      "id": "generator-augmented-flows-D1-001",
      "claim": "EDM noise schedule (Karras et al. 2022): rho=7, sigma_0=0.002 (min noise, p_0≈data), sigma_1=80 (max noise, p_T≈N(0,σ_T²I)), exponential discretization N(k)=min(s0·2^{k/K'}, s1)+1 with s0=10, s1=1280",
      "source": "Section 3.1, Appendix B"
    },
    {
      "id": "generator-augmented-flows-D1-002",
      "claim": "Log-normal timestep sampling: P_mean=-1.1, P_std=2.0; p(σ_i) ∝ erf((log(σ_{i+1})-P_mean)/(√2·P_std)) - erf((log(σ_i)-P_mean)/(√2·P_std))",
      "source": "Section 3.2"
    },
    {
      "id": "generator-augmented-flows-D1-003",
      "claim": "Joint learning factor (iCT-GC): μ_default=0.5 (GC probability per sample via Bernoulli), μ_ect=0.3 (ECT setting), effective range μ∈[0.3,0.7] on CIFAR-10 improves convergence speed and FID",
      "source": "Section 4.2"
    },
    {
      "id": "generator-augmented-flows-D1-004",
      "claim": "Evaluation protocol: FID computed on 50,000 generated images vs 50,000 training reference images; confidence intervals from 5 independent runs (each re-samples training reference set)",
      "source": "Section 4.1"
    },
    {
      "id": "generator-augmented-flows-D1-005",
      "claim": "Data preprocessing: pixel values scaled to [-1,1] for all datasets; images resized (smaller side), center-cropped, then linearly scaled",
      "source": "Section 4.1"
    },
    {
      "id": "generator-augmented-flows-D1-006",
      "claim": "CIFAR-10 training: batch_size=512, resolution=32, steps=100K, optimizer=Lion (Chen et al. 2023), lr∈{1e-4,3e-5} per-model grid search, dropout∈{0.0,0.3} per-model grid search",
      "source": "Section 4.1, Table 1"
    },
    {
      "id": "generator-augmented-flows-D1-007",
      "claim": "CIFAR-10 SongUNet: model_channels=128, num_blocks=3, channel_mult=[1,2,2], attn_resolutions=[] (no self-attention)",
      "source": "Section 4.1, Table 1"
    },
    {
      "id": "generator-augmented-flows-D1-008",
      "claim": "ImageNet 32×32 training: batch_size=512, resolution=32, steps=150K, lr=8e-5 (Lion), dropout∈{0.0, [0.0,0.0,0.2,0.2]} per-model grid search",
      "source": "Section 4.1, Table 1"
    },
    {
      "id": "generator-augmented-flows-D1-009",
      "claim": "ImageNet 32×32 SongUNet: model_channels=128, num_blocks=[3,5,7], channel_mult=[1,1,2], attn_resolutions=[16] (self-attention at 16×16)",
      "source": "Section 4.1, Table 1"
    },
    {
      "id": "generator-augmented-flows-D1-010",
      "claim": "CelebA 64×64 and LSUN Church 64×64 training: batch_size=128, resolution=64, steps=150K, lr=8e-5 (Lion), dropout∈{0.0, [0.0,0.0,0.2,0.2]} per-model grid search",
      "source": "Section 4.1, Table 1"
    },
    {
      "id": "generator-augmented-flows-D1-011",
      "claim": "CelebA/LSUN 64×64 SongUNet: model_channels=128, num_blocks=[3,3,4,5], channel_mult=[1,2,2,2], attn_resolutions=[] (no self-attention)",
      "source": "Section 4.1, Table 1"
    },
    {
      "id": "generator-augmented-flows-D1-012",
      "claim": "ECT experiment: short=4000 iterations (~1 GPU-hour A100 40GB), long=100000 iterations (~1 GPU-day A100 40GB)",
      "source": "Section 5.1"
    },
    {
      "id": "generator-augmented-flows-D1-013",
      "claim": "GC pre-training: endpoint predictor g_ϕ trained as iCT-IC for full=100K steps (strong) or partial=20K steps (weak), then frozen during GC training",
      "source": "Section 5.2"
    },
    {
      "id": "generator-augmented-flows-D1-014",
      "claim": "Infrastructure: NVIDIA A100 40GB GPU for all image experiments; SongUNet (NCSN++ from Karras et al. 2022) with positional encoding for noise level embedding",
      "source": "Section 4.1, Appendix C"
    }
  ],
  "D2": [
    {
      "id": "generator-augmented-flows-D2-001",
      "claim": "DiffusionForwardProcess: x_t = x_star + sigma_t * z, where x_star ~ p_star is a data sample and z ~ p_z is Gaussian noise. sigma_t is monotonically increasing for t in [0, T] with sigma_0 small (p_0 ≈ p_star) and sigma_T large (p_T ≈ N(0, sigma_T^2 * I)). Discrete form: x_{t_i} = x_star + sigma_{t_i} * z with t_0=0, t_N=T.",
      "source": "Section 1 Notation, Section 2.1"
    },
    {
      "id": "generator-augmented-flows-D2-002",
      "claim": "SamplePathDerivative: dot_x_t = d(x_star + sigma_t * z) / dt = dot_sigma_t * z, representing the single-sample Monte Carlo estimate of the velocity field (used in consistency training).",
      "source": "Section 2.1"
    },
    {
      "id": "generator-augmented-flows-D2-003",
      "claim": "VelocityFieldScoreForm: v_t(x) = -dot_sigma_t * sigma_t * grad_x log p_t(x), the velocity field of the probability flow ODE expressed via the score function.",
      "source": "Section 2.1"
    },
    {
      "id": "generator-augmented-flows-D2-004",
      "claim": "VelocityFieldEDMForm: v_t(x) = -t * grad_x log p_t(x), the EDM (Karras et al. 2022) special case where sigma_t = t and dot_sigma_t = 1.",
      "source": "Section 2.1"
    },
    {
      "id": "generator-augmented-flows-D2-005",
      "claim": "VelocityFieldDenoiserForm: v_t(x_t) = (1/t) * (x_t - D_star(x_t, t)), where D_star(x_t, t) = E[x_star | x_t] is the optimal denoiser (minimum MSE estimator of clean data given noisy observation).",
      "source": "Section 2.1, Section 4.2.1"
    },
    {
      "id": "generator-augmented-flows-D2-006",
      "claim": "VelocityFieldGeneralDenoiserForm: v_t(x) = (dot_sigma_t / sigma_t) * (x - D(x, sigma_t)), the general relationship between the velocity field and a denoiser D for arbitrary monotonic sigma_t.",
      "source": "Appendix A.2, Lemma 2"
    },
    {
      "id": "generator-augmented-flows-D2-007",
      "claim": "VelocityFieldApproximationWithDenoiser: dot_x_t - v_t(x_t) ≈ z - (1/t) * (x_t - D_phi(x_t, t)), where D_phi is a trained denoiser network. In the EDM setting, this approximates the discrepancy between the sample path derivative and the true velocity field.",
      "source": "Section 4.2.1"
    },
    {
      "id": "generator-augmented-flows-D2-008",
      "claim": "ConsistencyModelParametrization: f_theta(x_{t_i}, sigma_{t_i}) = c_skip(sigma_{t_i}) * x_{t_i} + c_out(sigma_{t_i}) * F_theta(x_{t_i}, sigma_{t_i}), where F_theta is a neural network (SongUNet). This parametrization enforces the boundary condition f_theta(x_0, sigma_0) = x_0 since c_skip(0)=1 and c_out(0)=0.",
      "source": "Section 2.2, Eq 3"
    },
    {
      "id": "generator-augmented-flows-D2-009",
      "claim": "SkipCoefficient: c_skip(sigma) = sigma_d^2 / (sigma_d^2 + (sigma - sigma_0)^2), where sigma_d^2 is the variance of the data distribution.",
      "source": "Section 2.2, Eq 3"
    },
    {
      "id": "generator-augmented-flows-D2-010",
      "claim": "OutCoefficient: c_out(sigma) = sigma * sqrt(d) * (sigma - sigma_0) / sqrt(sigma_d^2 + sigma^2), where d is the data dimensionality and sigma_d^2 is the data variance.",
      "source": "Section 2.2, Eq 3"
    },
    {
      "id": "generator-augmented-flows-D2-011",
      "claim": "EulerDiscretizationStep: x_{t_i}^Phi = Phi(x_{t_{i+1}}, t_{i+1}) = x_{t_{i+1}} + (t_i - t_{i+1}) * v_{t_{i+1}}(x_{t_{i+1}}), used in consistency distillation to advance one step backward along the PF-ODE. Note that t_i < t_{i+1} but sigma increases with t, so this is a backward Euler step in time.",
      "source": "Section 2.2, Eq 5"
    },
    {
      "id": "generator-augmented-flows-D2-012",
      "claim": "ConsistencyDistillationLoss: L_CD(theta) = E_{q_I(x_star, z), p(x_{t_{i+1}} | x_star, z)} [ lambda(sigma_{t_i}) * D( sg(f_theta(x_{t_i}^Phi, sigma_{t_i})), f_theta(x_{t_{i+1}}, sigma_{t_{i+1}}) ) ], where x_{t_i}^Phi is from the Euler discretization step using a pre-trained score/velocity model, sg is stop-gradient, and D is a distance function (typically squared L2 or Huber).",
      "source": "Section 2.2, Eq 4"
    },
    {
      "id": "generator-augmented-flows-D2-013",
      "claim": "ConsistencyTrainingLoss: L_CT(theta) = E_{q_I(x_star, z), p(x_{t_i}, x_{t_{i+1}} | x_star, z)} [ lambda(sigma_{t_i}) * D( sg(f_theta(x_{t_i}, sigma_{t_i})), f_theta(x_{t_{i+1}}, sigma_{t_{i+1}}) ) ], where x_{t_i} = x_star + sigma_{t_i} * z and x_{t_{i+1}} = x_star + sigma_{t_{i+1}} * z replace x_{t_i}^Phi from distillation — using the single-sample Monte Carlo estimate dot_x_t instead of the true v_t. This is the IC (independent coupling) baseline loss.",
      "source": "Section 2.2, Eq 6"
    },
    {
      "id": "generator-augmented-flows-D2-014",
      "claim": "GCIntermediateSampling: Step 1 of generator-augmented coupling — (x_star, z) ~ q_I (independent coupling); x_{t_i} = x_star + sigma_{t_i} * z (IC intermediate point); x_hat_{t_i} = sg(f_hat(x_{t_i}, sigma_{t_i})) (endpoint prediction via consistency model with stop-gradient, where f_hat is the predictor model).",
      "source": "Section 4.1, Eq 13"
    },
    {
      "id": "generator-augmented-flows-D2-015",
      "claim": "GCIntermediatePoints: Step 2 of generator-augmented coupling — reuse the same noise z with the predicted endpoint: (x_hat_{t_i}, z) ~ q (GC coupling); x_tilde_{t_i} = x_hat_{t_i} + sigma_{t_i} * z; x_tilde_{t_{i+1}} = x_hat_{t_i} + sigma_{t_{i+1}} * z. Boundary conditions: p(x_tilde_0) ≈ p_star (due to consistency model boundary condition), p(x_tilde_T) ≈ p(sigma_T * z) (noise dominates at large t).",
      "source": "Section 4.1, Eq 14"
    },
    {
      "id": "generator-augmented-flows-D2-016",
      "claim": "GCConsistencyTrainingLoss: L_GC(theta) = E_{q(x_hat_{t_i}, z), p(x_tilde_{t_i}, x_tilde_{t_{i+1}} | x_hat_{t_i}, z)} [ lambda(sigma_{t_i}) * D( sg(f_theta(x_tilde_{t_i}, sigma_{t_i})), f_theta(x_tilde_{t_{i+1}}, sigma_{t_{i+1}}) ) ], where x_tilde_{t_i} and x_tilde_{t_{i+1}} are constructed via GC coupling. Note the velocity term is dot_sigma_t * z (not dot_x_tilde_t) because x_tilde_{t_{i+1}} - x_tilde_{t_i} = (sigma_{t_{i+1}} - sigma_{t_i}) * z.",
      "source": "Section 4.1, Eq 15"
    },
    {
      "id": "generator-augmented-flows-D2-017",
      "claim": "JointLearningLoss: L_GC-mu(theta) = mu * L_GC(theta) + (1 - mu) * L_CT(theta), where mu in [0, 1] is the joint learning factor. At each training step, a per-sample binomial mask m_j ~ Binomial(mu) determines which samples use GC trajectories (m_j=1: use x_hat_{t_i} as endpoint; m_j=0: use x_star as endpoint for IC). mu=0 recovers iCT-IC, mu=1 is pure GC (not recommended).",
      "source": "Section 5.2, Eq 18, Algorithm 1"
    },
    {
      "id": "generator-augmented-flows-D2-018",
      "claim": "ProxyRegularizer: R_tilde_t = E[ || dot_x_t - v_t(x_t) ||^2 ], measures expected squared distance between the true velocity field and its one-sample Monte Carlo estimate dot_x_t. This is a proxy for the discrepancy regularizer R(theta) identified in Theorem 1 for the alpha=2 case.",
      "source": "Section 4.2.1, Eq 16"
    },
    {
      "id": "generator-augmented-flows-D2-019",
      "claim": "TransportCost: c(t) = E_{q_I(x_star, z)}[ || f_ring(x_t, sigma_t) - z ||^2 ], the expected quadratic distance between the noise z and the consistency model output f_ring(x_t, sigma_t) (predicted endpoint). c(0) = E[||x_star - z||^2] is the IC transport cost; c(t) for t>0 represents the GC transport cost.",
      "source": "Section 4.2.2, Eq 17"
    },
    {
      "id": "generator-augmented-flows-D2-020",
      "claim": "ProxyRegularizerIC: R_tilde_{t,IC} = (dot_sigma_t / sigma_t)^2 * E[ || x_star - D(x_t, sigma_t) ||^2 ], where D(x_t, sigma_t) = E[x_star | x_t] is the optimal denoiser. Derived from dot_x_t - v_t(x_t) = -(dot_sigma_t / sigma_t) * (x_star - D(x_t, sigma_t)).",
      "source": "Appendix A.2, Eq 63"
    },
    {
      "id": "generator-augmented-flows-D2-021",
      "claim": "ProxyRegularizerGC: R_tilde_{t,GC} = (dot_sigma_t / sigma_t)^2 * E[ || x_hat_t - E[x_hat_t | x_tilde_t] ||^2 ]. Unlike IC, as t → infinity, x_hat_t is approximately a deterministic function of x_tilde_t (both dominated by z), so E[x_hat_t | x_tilde_t] ≈ x_hat_t, making R_tilde_{t,GC} decay faster than R_tilde_{t,IC}.",
      "source": "Appendix A.2, Eq 67"
    },
    {
      "id": "generator-augmented-flows-D2-022",
      "claim": "NoiseScheduleKarras: sigma_i = (sigma_0^{1/rho} + (i/N) * (sigma_N^{1/rho} - sigma_0^{1/rho}))^rho, where rho=7, sigma_0=0.002, sigma_N=80 (and sigma_1=80). This is the Karras et al. 2022 noise schedule used for constructing the discrete timestep grid {sigma_i}_{i=0}^N.",
      "source": "Appendix D"
    },
    {
      "id": "generator-augmented-flows-D2-023",
      "claim": "LossWeighting: lambda(sigma_i) = 1 / (sigma_{i+1} - sigma_i). Combined with the Karras noise schedule, this weighting emphasizes consistency at low-noise timesteps (where sigma_i differences are smaller).",
      "source": "Appendix D"
    },
    {
      "id": "generator-augmented-flows-D2-024",
      "claim": "DiscretizationSchedule: N(k) = min(s0 * 2^{floor(k / K')}, s1) + 1, where K' = floor(K / (log2(s1 / s0) + 1)), s0=10, s1=1280, K is total training steps, and k is the current training step. This exponential schedule progressively increases the number of timesteps N during training (from Song and Dhariwal 2024).",
      "source": "Appendix D"
    },
    {
      "id": "generator-augmented-flows-D2-025",
      "claim": "TimestepSamplingDistribution: p(sigma_i) proportional to erf((log(sigma_{i+1}) - P_mean) / (sqrt(2) * P_std)) - erf((log(sigma_i) - P_mean) / (sqrt(2) * P_std)), with P_mean=-1.1, P_std=2.0. This discrete distribution approximates the continuous log-normal sampling from Karras et al. 2022, as recommended by Song and Dhariwal 2024.",
      "source": "Appendix D"
    },
    {
      "id": "generator-augmented-flows-D2-026",
      "claim": "JointLearningAlgorithm (Algorithm 1): Input: randomly initialized consistency model f_theta, N, sigma schedule, loss weighting lambda, learning rate eta, distance D, noise distribution p_z, joint learning parameter mu. Per iteration: (1) Sample x_star ~ p_star, z ~ p_z; (2) Sample timestep index i ~ multinomial(p(sigma)); (3) Sample per-sample mask m_j ~ Binomial(mu) for batch_size elements; (4) Compute IC intermediate x_{t_i} = x_star + sigma_{t_i} * z; (5) Predict endpoint x_hat_{t_i} = sg(f_theta(x_{t_i}, sigma_{t_i})); (6) Mix: x_hat_{t_i} = m * x_hat_{t_i} + (1-m) * x_star (GC elements use predicted endpoint, IC keep original); (7) Construct shifted GC points: x_tilde_{t_i} = x_hat_{t_i} + sigma_{t_i} * z, x_tilde_{t_{i+1}} = x_hat_{t_i} + sigma_{t_{i+1}} * z; (8) Compute loss L = lambda(sigma_{t_i}) * D(sg(f_theta(x_tilde_{t_i}, sigma_{t_i})), f_theta(x_tilde_{t_{i+1}}, sigma_{t_{i+1}})); (9) Update theta = theta - eta * grad_theta L. Progressively increase N(k) during training via exponential schedule.",
      "source": "Appendix B, Algorithm 1"
    }
  ],
  "D3": [
    {
      "id": "generator-augmented-flows-D3-001",
      "claim": "Main Benchmark Experiment (iCT-IC, iCT-OT, iCT-GC). Purpose: Compare the proposed GC joint learning method against IC and batch-OT baselines for improved consistency training. Datasets: CIFAR-10 (32x32), ImageNet (32x32), CelebA (64x64), LSUN Church (64x64). Baselines: (a) iCT-IC: improved consistency training with independent coupling (Song and Dhariwal 2024); (b) iCT-OT: iCT with minibatch optimal transport coupling using Hungarian/Sinkhorn solvers (Pooladian et al. 2023; Dou et al. 2024). Method: iCT-GC with joint learning factor mu=0.5 (chosen from CIFAR-10 grid search, kept fixed for other datasets). All methods use the same SongUNet architecture, training steps, and hyperparameter search spaces. Metrics: FID, KID (x10^2), IS with confidence intervals from 5 runs. Results reported in Table 1.",
      "source": "Section 5.2, Table 1"
    },
    {
      "id": "generator-augmented-flows-D3-002",
      "claim": "ECT Experiment (ECT-IC, ECT-GC). Purpose: Evaluate GC in the Easy Consistency Tuning setting (Geng et al. 2024), where consistency models are fine-tuned from a pre-trained diffusion model. Datasets: CIFAR-10 (32x32), FFHQ (64x64), ImageNet (64x64 conditional). Baselines: ECT-IC (Geng et al. 2024 defaults). Method: ECT-GC with mu=0.3 (recommended smaller values for ECT). Two training regimes: short (4k steps, ~1 GPU-hour) and long (100k steps, ~1 GPU-day). All hyperparameters follow Geng et al. 2024 defaults. Metrics: FID with confidence intervals. Results reported in Table 2.",
      "source": "Section 5.3, Table 2"
    },
    {
      "id": "generator-augmented-flows-D3-003",
      "claim": "iCT-GC with Frozen Pre-Trained Predictor. Purpose: Validate that GC training works with a separately pre-trained endpoint predictor (as assumed in the theory of Section 4). Dataset: CIFAR-10. Protocol: (1) Pre-train an iCT-IC model g_phi as endpoint predictor for either 100k steps (full) or 20k steps (partial/weak); (2) Freeze g_phi; (3) Train a new consistency model f_theta from scratch using only GC trajectories (mu=1) with the frozen predictor: x_hat_{t_i} = sg(g_phi(x_{t_i}, sigma_{t_i})). Metrics: FID during training. Key finding: Performance of GC model depends on predictor quality on IC trajectories. Results in Figure 4.",
      "source": "Section 5.1, Figure 4"
    },
    {
      "id": "generator-augmented-flows-D3-004",
      "claim": "Joint Learning Factor mu Ablation on CIFAR-10. Purpose: Determine optimal mu range and validate the interpolation phenomenon between IC (mu=0) and GC (mu=1). Dataset: CIFAR-10. Protocol: Train iCT-GC models with varying mu values (grid from 0 to 1) using the joint learning Algorithm 1. All other hyperparameters fixed. Metrics: FID during training trajectory. Key finding: For 0.3 <= mu <= 0.7, convergence speed and final FID are improved over both IC and batch-OT. mu=1 diverges after early fast progress due to distribution shift between IC and GC trajectories. Results in Figure 5.",
      "source": "Section 5.2, Figure 5"
    },
    {
      "id": "generator-augmented-flows-D3-005",
      "claim": "GC-Only Training Failure Analysis (mu=1). Purpose: Diagnose why pure GC training (mu=1) fails despite fast initial progress. Dataset: CIFAR-10. Protocol: (1) Train model with mu=1 (only GC trajectories); (2) Compare with and without timestep scheduling (increasing N vs fixed N); (3) Evaluate the GC-trained model on both IC and GC trajectories per timestep; (4) Compare FID along trajectories against standard IC-trained model on IC trajectories. Metrics: FID per timestep, overall FID curves. Key finding: Distribution shift — GC models degrade on IC trajectories at intermediate timesteps, making them poor endpoint predictors for their own GC training (Equation 13). Results in Figure 7.",
      "source": "Appendix C.1, Figure 7"
    },
    {
      "id": "generator-augmented-flows-D3-006",
      "claim": "Iso-Time, Dropout, and EMA Ablation on CIFAR-10. Purpose: Isolate effects of (a) wall-clock training time, (b) dropout regularization, and (c) EMA for endpoint prediction. Dataset: CIFAR-10. Protocol: (1) Iso-time: train iCT-GC (mu=0.5) for the same wall-clock duration as standard iCT-IC (accounting for ~20% overhead per GC step due to extra forward pass); (2) Dropout: train iCT-GC (mu=0.5) with dropout enabled; (3) No-EMA: train iCT-GC (mu=0.5) without EMA on endpoint predictions. Baselines: standard iCT-IC and iCT-GC (mu=0.5) with default settings. Metrics: FID. Key findings: (a) GC still outperforms IC under iso-time; (b) Dropout degrades GC performance (opposite to Song and Dhariwal 2024 findings for IC); (c) Removing EMA worsens GC scores. Results in Table 3.",
      "source": "Appendix C.1, Table 3"
    },
    {
      "id": "generator-augmented-flows-D3-007",
      "claim": "Mu Sensitivity on ImageNet-32. Purpose: Validate that mu sensitivity observed on CIFAR-10 generalizes to larger datasets. Dataset: ImageNet 32x32. Protocol: Train iCT-GC models with mu values {0.3, 0.5, 0.7, 1.0} using the same joint learning Algorithm 1 and hyperparameters from Table 6. Metrics: FID during training. Key finding: mu = {0.3, 0.5} both outperform iCT-IC baseline, confirming the CIFAR-10 trend. Results in Figure 9.",
      "source": "Appendix C.1, Figure 9"
    },
    {
      "id": "generator-augmented-flows-D3-008",
      "claim": "Regularizer Proxy Comparison (R_tilde). Purpose: Empirically compare the proxy regularizer R_tilde_t values for IC, batch-OT, and GC couplings to validate Theorem 2 (GC reduces velocity field estimation discrepancy). Dataset: CIFAR-10. Protocol: (1) Train a separate denoiser D_phi for each coupling type (IC, batch-OT, GC); (2) For each noise level sigma_t, compute R_tilde using the approximation: dot_x_t - v_t(x_t) ≈ z - (1/t)(x_t - D_phi(x_t, t)); (3) Average over samples. Metrics: R_tilde_t as a function of sigma_t. Key finding: R_tilde_{t,GC} < R_tilde_{t,batch-OT} < R_tilde_{t,IC}, with gap increasing with t, corroborating Theorem 2. Results in Figure 2.",
      "source": "Section 4.2.1, Figure 2"
    },
    {
      "id": "generator-augmented-flows-D3-009",
      "claim": "Transport Cost Comparison. Purpose: Compare quadratic transport cost between noise z and predicted endpoint x_hat for IC, batch-OT, and GC couplings. Datasets: CIFAR-10 and toy 2D-Diracs. Protocol: (1) For each coupling, compute c(t) = E[||f_ring(x_t, sigma_t) - z||^2] or c(0) = E[||x_star - z||^2] for IC; (2) For batch-OT, compute transport cost using minibatch Hungarian matching; (3) For GC, compute c(t) using a trained consistency model as predictor. Metrics: Expected squared L2 distance between noise and predicted endpoint. Key finding: GC reduces transport cost more than batch-OT because batch-OT is tied to batch data points whereas GC predictions are not. Results in Figures 3 and 6.",
      "source": "Section 4.2.2, Figures 3, 6"
    },
    {
      "id": "generator-augmented-flows-D3-010",
      "claim": "Toy 2D-Dirac Experiment for Transport Cost and Flow Visualization. Purpose: Visualize probability paths, ODE trajectories, and transport costs on a minimal tractable example. Dataset: Mixture of two 2D Dirac delta functions as data distribution, standard Gaussian noise. Protocol: (1) Compute closed-form PF-ODE and consistency model for this toy setting; (2) Visualize IC and GC sample paths, ODE trajectories, and probability densities; (3) Compute and compare transport costs c(t) for IC, batch-OT, and GC. Metrics: Visual alignment of sample paths with velocity field, transport cost c(t). Results in Figures 1 and 6 (left panel).",
      "source": "Section 4.2.2, Appendix A.3, Figures 1, 6"
    },
    {
      "id": "generator-augmented-flows-D3-011",
      "claim": "Evaluation Protocol. Metrics: Frechet Inception Distance (FID) from Heusel et al. 2017, Kernel Inception Distance (KID) from Binkowski et al. 2018, and Inception Score (IS) from Salimans et al. 2016, all implemented via TorchMetrics (Skafte Detlefsen et al. 2022). Procedure: Compare 50,000 generated images against 50,000 training images (standard practice, e.g. Song and Dhariwal 2024). Confidence intervals: 5 independent evaluation runs on the same trained model; each run samples a new set of 50k training images (for reference distribution) and generates 50k new images with a different random seed.",
      "source": "Appendix D"
    },
    {
      "id": "generator-augmented-flows-D3-012",
      "claim": "Data Preprocessing and Hyperparameter Grid Search. Preprocessing: Resize smaller image side to target resolution, apply center crop, linearly scale pixel values to [-1, 1]. Hyperparameter search: For each model type (iCT-IC, iCT-OT, iCT-GC), per-dataset grid search over learning rates (CIFAR-10: {1e-4, 3e-5}; others: 8e-5 fixed) and dropout rates (search spaces specified per dataset in Tables 4-6). Optimizer: Lion (Chen et al. 2023) from github.com/lucidrains/lion-pytorch. Architecture: SongUNet / NCSN++ (Song et al. 2021) from github.com/NVlabs/edm (Karras et al. 2022). EMA used for all models except the ablation study. Timestep scheduling: progressive increase N from s0=10 to s1=1280 via exponential schedule during training. Noise schedule: Karras et al. 2022 with rho=7, sigma_0=0.002, sigma_1=80. Loss weighting: lambda(sigma_i) = 1/(sigma_{i+1} - sigma_i). Timestep sampling: log-normal distribution with P_mean=-1.1, P_std=2.0.",
      "source": "Appendix D, Tables 4-6"
    }
  ],
  "D4": [
    {
      "id": "generator-augmented-flows-D4-001",
      "claim": "Overall Training Pipeline (9 steps): (1) Initialize consistency model f_theta with SongUNet architecture and the parametrization f_theta(x, sigma) = c_skip(sigma) * x + c_out(sigma) * F_theta(x, sigma); (2) Set noise schedule sigma_i via Karras formula with rho=7, sigma_0=0.002, sigma_N=80; (3) At each training step, sample a batch of (x_star, z) pairs via independent coupling q_I; (4) Sample timestep index i from discrete log-normal distribution p(sigma_i); (5) Compute IC intermediate point x_{t_i} = x_star + sigma_{t_i} * z; (6) Predict endpoint x_hat_{t_i} = sg(f_theta(x_{t_i}, sigma_{t_i})) using the model itself with stop-gradient; (7) Apply per-sample binomial mask m_j ~ Binomial(mu) to mix: GC samples use x_hat_{t_i} as endpoint, IC samples use original x_star; (8) Construct shifted GC points and compute consistency loss L(theta) = lambda(sigma_{t_i}) * D(sg(f_theta(x_tilde_{t_i})), f_theta(x_tilde_{t_{i+1}})); (9) Update theta = theta - eta * grad_theta L(theta). During training, progressively increase N from s0=10 to s1=1280 via exponential schedule N(k). Evaluate FID/KID/IS on 50k generated vs 50k training images using 5 independent runs.",
      "source": "Sections 4.1, 5.2, Appendix B Algorithm 1, Appendix D"
    },
    {
      "id": "generator-augmented-flows-D4-002",
      "claim": "GC Coupling Step Ordering within Each Iteration (must follow this sequence): (a) Sample (x_star, z) via IC first — this is required because the endpoint predictor f_theta is only trained on IC trajectories and needs IC points as input; (b) Compute IC intermediate x_{t_i} BEFORE predicting x_hat_{t_i} — the prediction depends on the IC intermediate point; (c) Predict x_hat_{t_i} = sg(f_theta(x_{t_i})) with stop-gradient — gradient must NOT flow through the endpoint prediction to the predictor; (d) Apply binomial mask m to mix x_hat_{t_i} and x_star — this determines per-sample whether GC or IC trajectory is used; (e) Reuse the SAME noise z to construct x_tilde points — the GC coupling preserves the same z so that x_tilde_{t_{i+1}} - x_tilde_{t_i} = (sigma_{t_{i+1}} - sigma_{t_i}) * z; (f) Compute loss on (x_tilde_{t_i}, x_tilde_{t_{i+1}}) — both GC and (effectively) IC pairs are evaluated through the same loss because for IC elements (m_j=0), x_hat_{t_i} = x_star, so x_tilde points reduce to standard IC points.",
      "source": "Section 4.1, Algorithm 1"
    }
  ]
}