Skip to content

eval: accept bounded asynchronous training against a synchronous reference #18

Closed

Description

@FeathBow

Motivation

Staleness is part of the training algorithm, so an asynchronous run is a different run whose result has to be judged. The benefit of overlap shows in throughput and total resource use. Both need runs on CUDA with rules fixed before the results are seen.

Proposal

On CUDA, train the same workload once with d = 0 and once with d = 1 on one host with the runtime from #16; this does not wait for the remote transport. A use contract compares the d = 1 checkpoint as the candidate with the d = 0 checkpoint as the reference. The decision covers these two checkpoints and the declared use. A claim that asynchronous training does not degrade in general would need independent training runs as its units, and more evaluation prompts cannot replace repeated training.

Before either run starts, the following are fixed and retained with the runs: the training budget and whether it counts updates, tokens or time; the evaluation protocol; the checkpoint selection rule; the quality margin and its reason; the confidence settings; the basis for isolating acceptance data from training; and what happens when a run fails. The performance comparison fixes the resources on both sides, and total cost includes waiting, retries, reference scoring and artifact transfer.

Acceptance

  • Every setting listed above is fixed before the runs and retained with them.
  • The use contract returns its decision for the d = 1 checkpoint against the d = 0 checkpoint: admitted, refused or insufficient evidence, reported as it comes out.
  • Quality, throughput and total resource cost are reported for the recorded configurations under the fixed resources.
  • The documentation states that the core fixes the logical assignment and use of samples, and that identical weights additionally require evidence of the workers' numerical invariance.

Activity

  1. FeathBow commented on Oct 22, 2026

    @FeathBow
    OwnerAuthor

    Closing: the staleness results (#74) report the run this issue asked for.

    • Before training, the experiment lead confirmed a frozen record of the use, both ceilings and their reasons, the problems and their isolation, the training budget, the checkpoint selection rule and the failure and exclusivity rules. The use contract was frozen after training and before any evaluation. The records are retained with the runs.
    • The contract compared the staleness-one checkpoint with the staleness-zero checkpoint on 1255 GSM8K test problems with two paired seeds each, under a finite-domain standard. It returned admitted_under_declared_reliance: the mean reference loss was 55/502 and the mean loss increase −3/502, within the ceilings of 1/5 and 1/40. The decision holds for these problems and seeds when the declared reliance holds.
    • The frozen admission ran out of memory, because the core replayed a whole batch log for every run (fix(use): replay each batch log once when admitting its member runs #73). The admission was repeated with the revised core after both cores gave identical output on a complete earlier evaluation, and the page reports this departure from the frozen procedure.
    • Quality, wall time, token throughput, and the GPU time and memory of training, evaluation and admission are reported for both runs, which shared one allocation on one GPU in a fixed order.
    • The loop design states that the core fixes the logical assignment and use of every sample, and that identical weights additionally require evidence of the workers' numerical invariance.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions