Add metric comparison helpers for FT tests - #1410
Conversation
There was a problem hiding this comment.
Code Review
This pull request introduces metric comparison utilities and associated unit tests to compare baseline and target metric events, handling fault-tolerance retries by filtering out earlier failed attempts. The feedback highlights two key improvements: optimizing the event filtering logic from O(N^2) to O(N) to prevent performance degradation on large logs, and removing a fragile dependency on an internal module of the external sglang library by rendering the Polars DataFrame directly.
Important
The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.
| def _keep_only_final_attempt(events: list[MetricEvent]) -> list[MetricEvent]: | ||
| """Keep only events from the highest-attempt for each rollout_id. | ||
|
|
||
| During FT healing, a crashed rollout is retried at attempt+1; events from | ||
| the failed attempt are partial and should be discarded for comparison. | ||
|
|
||
| Rollout-side metrics (e.g. RolloutManager log_rollout_metrics) have | ||
| attempt=None — they are not part of the FT retry stream, so we treat them | ||
| as a single attempt (normalized to 0). | ||
| """ | ||
|
|
||
| def _attempt(e: MetricEvent) -> int: | ||
| return e.attempt if e.attempt is not None else 0 | ||
|
|
||
| max_attempt_by_rollout: dict[int, int] = { | ||
| rollout_id: max(_attempt(e) for e in events if e.rollout_id == rollout_id) | ||
| for rollout_id in {e.rollout_id for e in events} | ||
| } | ||
| return [e for e in events if _attempt(e) == max_attempt_by_rollout[e.rollout_id]] |
There was a problem hiding this comment.
The current implementation of _keep_only_final_attempt has an rollout_id. For large training logs with thousands of events, this can significantly slow down test execution. We can optimize this to rollout_id.
def _keep_only_final_attempt(events: list[MetricEvent]) -> list[MetricEvent]:
"""Keep only events from the highest-attempt for each rollout_id.
During FT healing, a crashed rollout is retried at attempt+1; events from
the failed attempt are partial and should be discarded for comparison.
Rollout-side metrics (e.g. RolloutManager log_rollout_metrics) have
attempt=None — they are not part of the FT retry stream, so we treat them
as a single attempt (normalized to 0).
"""
def _attempt(e: MetricEvent) -> int:
return e.attempt if e.attempt is not None else 0
max_attempt_by_rollout: dict[int | None, int] = {}
for e in events:
rid = e.rollout_id
att = _attempt(e)
if rid not in max_attempt_by_rollout or att > max_attempt_by_rollout[rid]:
max_attempt_by_rollout[rid] = att
return [e for e in events if _attempt(e) == max_attempt_by_rollout[e.rollout_id]]7a8fac2 to
19ae254
Compare
7ba952e to
313936b
Compare
19ae254 to
bf5b210
Compare
313936b to
ef8a783
Compare
bf5b210 to
12dce7d
Compare
ef8a783 to
857c2cb
Compare
| *, | ||
| exclude_keys: list[str] | None = None, | ||
| ) -> None: | ||
| import polars as pl |
There was a problem hiding this comment.
Please hoist this import to the beginning
12dce7d to
7b20e3b
Compare
857c2cb to
b36be10
Compare
7b20e3b to
387780b
Compare
b36be10 to
781e9f0
Compare
Add a `deterministic_random` reward that hashes the sample tokens + response to produce a stable pseudo-random 0/1 reward, used for reproducible fault-tolerance / CI tests. - rm_hub/__init__.py (+ test).
Add `inplace_modify_args`, a context manager that temporarily overrides args attributes and restores them on exit (asserting they weren't clobbered), used to scope per-attempt argument overrides in the fault-tolerant trainer. - argparse_utils.py (+ test).
Small shared-utility additions used by the fault-tolerant trainer: hash non-contiguous tensors safely (reshape before viewing as bytes), an `enable_experimental_ft_trainer` env flag, forward NCCL_DEBUG/NCCL_DEBUG_FILE to worker environments, and a `filter_keys` helper. - ci_utils.py / environ.py / external_utils/command_utils.py / misc.py.
Thread the original backend through ReloadableProcessGroup so that, when a process group is rebuilt (e.g. after a reconfigure/heal), it is recreated with the same backend instead of hard-coding NCCL. - reloadable_process_group.py: carry `backend` in the reload group info.
Add small foundation utilities used across the fault-tolerance trainer: a strict pydantic base model, a retry helper, a tensor checksum helper, a per-cell megatron world-size computation, the TrainStepOutcome enum, and the IndepDPInfo dataclass describing a cell's independent-DP identity. - pydantic_utils.py / retry_utils.py / checksum_utils.py / megatron_args_utils.py / types.py / indep_dp.py and tests.
Add a `log_structured` helper that emits logfmt-style key/value log lines, used by the fault-tolerance components for greppable structured logs. - structured_log.py (+ test).
Add a small `Clock` interface (`RealClock` plus a controllable fake clock) so time-dependent fault-tolerance code (health checks, heartbeats) can be driven deterministically in tests. - miles/utils/clock.py and tests.
Add a fault-injector test utility used to deterministically exercise fault-tolerance code paths. - miles/utils/test_utils/fault_injector.py.
Add the shared data models for the fault-tolerance control server (e.g. the `TriState` health value), used by the health checker and later by the HTTP control server. - miles/utils/control_server/models.py.
Add the periodic health checker (debounced TriState status driven by a Clock) and heartbeat utilities used to monitor train-cell liveness. - miles/utils/health_checker.py, miles/utils/heartbeat_utils.py and tests.
Add the nvidia-resiliency-ext dependency, the "ft" CI test label, the FT test fixtures in the rollout conftest, and route startup logging through configure_logger_raw. The fault-tolerance CLI arguments themselves now live with the features that consume them (distributed across the per-feature commits).
Unconditionally disconnect-then-reconnect the model-update process group when (re)connecting rollout engines, guarding the destroy against a missing group, so a reconfigured/healed engine set can rebuild the NCCL group from scratch. - broadcast.py: drop the "only disconnect if group exists" short-circuit; guard `destroy_process_group` against None.
Expose an `inject_fault` Ray method on TrainRayActor (in its own concurrency group) that triggers a configured failure mode via the fault injector, so fault-tolerance tests can crash/hang specific actors on demand. - train_actor.py: `inject_fault` RPC.
Extract the DP split into a witness-aware split_train_data_by_dp_raw helper (with unit tests; the key list also carries seq_witness_ids) and use it to split the training data on the actor side when delay_split_train_data_by_dp is set, deferring the DP split from the rollout side to actor-side processing. split_train_data_by_dp stays a thin wrapper that ray.puts each partition. - miles/ray/rollout/train_data_conversion.py (+ tests), miles/utils/data.py, actor_group.py, rollout_manager.py.
Add an opt-in deterministic NCCL process-group backend (`--debug-deterministic-collective`) that folds order-sensitive SUM/AVG reductions into a fixed order so training collectives are bit-reproducible, registering it as the training world's distributed backend and requiring synchronous grad sync. - det_process_group.py (+ GPU test, dist test helper). - train_actor.py: register the backend and select it when enabled. - initialize.py: assert synchronous grad reduce under the deterministic backend.
Add a per-process identity helper that uniquely keys each training process, used to attribute structured fault-tolerance events to their originating process. - miles/utils/process_identity.py and tests.
Add the structured event models (Event / EventBase hierarchy) for the fault-tolerance event log, each tagged with the originating ProcessIdentity. - miles/utils/event_logger/models.py and tests.
Add the structured event logger that records typed events keyed by per-process identity, wire it through the logging helper and CLI argument, and start it from the train entrypoints. - miles/utils/event_logger/logger.py, logging_utils.py, arguments.py and entrypoint wiring, with tests.
Add snapshot/restore for the structured event log so the event history survives cell restarts during fault-tolerant training. - miles/utils/event_logger/checkpoint.py and tests.
Add the `MetricEvent` model (a discriminated-union member) and emit every
tracking metric into the structured event log: `tracking_utils.log` now forwards
`{metrics}` to `get_event_logger().log(MetricEvent, ...)` when the event logger
is initialized.
Add the witness id allocator and `WitnessInfo` carrier used to assign and track witness ids for fault-tolerance verification. - miles/utils/witness/allocator.py and tests.
Thread witness ids through the model by injecting witness parameters, so the event log can later verify they propagate correctly. - miles/utils/witness/module.py, model_provider.py and tests.
Add the first event-analyzer rules that replay the structured event log and flag
weight-checksum inconsistencies: a `checksum_compare` helper (flatten nested
dicts, diff flat checksum maps) plus two rules built on it — cross-replica weight
checksum consistency and inference-engine weight checksum consistency — with unit
tests.
- miles/utils/event_analyzer/rules/{checksum_compare,cross_replica_weight_checksum,inference_engine_weight_checksum_consistency}.py and tests.
Add the witness-tracing rule for the event analyzer: it follows witness ids through the replayed event log to verify they are propagated correctly across the training pipeline, with unit tests. - miles/utils/event_analyzer/rules/witness.py and tests.
Add the analyzer that replays the structured event log and applies the analysis rules (checksum-consistency and witness tracing) to verify fault-tolerance behaviour offline, with unit tests. - miles/utils/event_analyzer/analyzer.py and tests.
Add comparison helpers used by fault-tolerance tests to compare dumped tensors and
inference-engine checksums offline (generic comparators, dump comparison, and an
inference-engine checksum comparison built on the event-analyzer checksum rule).
- miles/utils/test_utils/comparisons/{comparators,dumps,inference_engine_checksums}.py and tests.
Add the metric comparison helpers used by fault-tolerance tests to compare logged training metrics offline. - miles/utils/test_utils/comparisons/metrics.py.
387780b to
81b95c4
Compare
781e9f0 to
71d38e2
Compare
…ft/dev_revert_reversed/add-metric-comparison-helpers-for-ft-tests
Add the metric comparison helpers used by fault-tolerance tests to compare logged
training metrics offline.