freesolo-flash-dev 0.2.50__tar.gz → 0.2.54__tar.gz

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 0.2.50
+Version: 0.2.54
 Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.54}/flash/engine/multiturn_rollout.py

@@ -227,12 +227,12 @@ def rollout_one_records(
 
     - ``generate(prefix_ids, max_new)`` returns an OBJECT (opaque here) exposing ``completion_ids``
       (``list[int] | None``), ``completion_text`` (``str``), ``truncated`` (``bool``) and ``skip``
-      (``bool``) — OPD passes its ``_GenResult`` from ``_generate_one`` (termination/trim/U+FFFD gates
-      already applied), so the record drops straight into the existing teacher-scoring + gkd-loss path.
+      (``bool``) — OPD passes its ``_GenResult`` after termination/trim/U+FFFD gates have already been
+      applied, so the record drops straight into the existing teacher-scoring + batched-loss path.
     - Every turn (including a truncated/empty one) is recorded so the caller counts it; a
       truncated/skip turn ENDS the episode (a student that didn't terminate its turn, or emitted an
       empty/invalid completion, can't meaningfully continue — and its bad turn is skipped, not
-      distilled, by the caller's ``_resolve_sample``).
+      distilled, by the caller's no-loss sample handling).
     - ``on_turn_generated`` (optional) fires AFTER each turn's generation to refresh the worker stall
       clock and advance the sample counter — a many-turn episode is a long serial stretch of GPU
       generates + teacher-less env steps that would otherwise emit no progress ping.

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.54}/flash/engine/vram.py

@@ -366,11 +366,12 @@ def estimate_vram_gb(
         # OPD recipe default (thinking uses the longer max_completion_len_thinking). A GRPO-style
         # min(seq_len, 1024) fallback would UNDER-budget a thinking opd job (1536-token completions).
         completion = opd_completion_len(max_tokens, thinking)
-        # run_opd backprops ONE completion at a time (_train_one), so the activations + dense logits
-        # are SINGLE-sequence — NOT sft_per_device(batch_size). The batch-size activation term
-        # over-budgeted opd and bumped the GPU tier unnecessarily (reported by codex[bot]).
+        # run_opd backprops a small loss microbatch, but OPD's placement budget stays conservative by
+        # treating activations + dense logits as SINGLE-sequence — NOT sft_per_device(batch_size). The
+        # batch-size activation term over-budgeted opd and bumped the GPU tier unnecessarily (reported by
+        # codex[bot]).
         activations = _ACT_COEF * (seq_len / 1024.0) * width
-        # Dense-logit peak spans BOTH the forward and the loss BACKWARD (gkd_loss has no fused CE):
+        # Dense-logit peak spans BOTH the forward and the loss BACKWARD (OPD has no fused CE):
         #   - forward:  bf16 full-sequence logits [seq, vocab]        (seq * 2)
         #               fp32 completion rows [completion, vocab] for logsumexp, saved for backward
         #                                                             (completion * 4)
@@ -380,7 +381,7 @@ def estimate_vram_gb(
         #                                                             (seq * 2)
         # All four coexist at the backward peak. The old formula counted only the two FORWARD buffers,
         # so a long-completion / large-vocab (248k) opd job under-budgeted the loss backward by
-        # ~(completion*4 + seq*2)*vocab bytes and could route to a GPU that OOMs in gkd_loss.backward
+        # ~(completion*4 + seq*2)*vocab bytes and could route to a GPU that OOMs in OPD loss backward
         # (codex[bot]). Mirror the SFT dense-logit sizing by budgeting the backward buffers too.
         logits_fwd = (seq_len * 2 + completion * 4) * vocab
         logits_bwd = (seq_len * 2 + completion * 4) * vocab