freesolo-flash-dev 1.0.26__tar.gz → 1.0.28__tar.gz

{freesolo_flash_dev-1.0.26 → freesolo_flash_dev-1.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 1.0.26
+Version: 1.0.28
 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-1.0.26 → freesolo_flash_dev-1.0.28}/flash/engine/worker/opd_verl.py

@@ -1437,12 +1437,22 @@ def build_opd_verl_overrides(config: dict) -> list[str]:
         "data.truncation=error",
         "data.shuffle=false",
         f"data.seed={_hydra_val(config.get('seed', 42))}",
-        f"actor_rollout_ref.rollout.seed={_hydra_val(config.get('seed', 42))}",
+        # rollout engine seed. NOT `rollout.seed`: verl 0.8.0's RolloutConfig declares no such field,
+        # so a bare key fails hydra composition and a `+`/`++` prefix composes but then dies in
+        # omega_conf_to_dataclass with an unexpected-kwarg TypeError. engine_kwargs is a declared
+        # dict on both 0.8.0 and 0.9.x and is spread into the vllm engine args *after* verl's own
+        # "seed" entry, so it wins. `++` because the sub-key is absent from the composed node.
+        # per-request sampling is seeded separately by the plugin's deterministic_rollout_seed.
+        f"++actor_rollout_ref.rollout.engine_kwargs.vllm.seed={_hydra_val(config.get('seed', 42))}",
         "data.dataloader_num_workers=0",
         "data.image_key=images",
         "data.return_raw_chat=true",
         "data.return_multi_modal_inputs=false",
-        "data.apply_chat_template_kwargs={enable_thinking:" + _hydra_val(config.get("thinking", False)) + "}",
+        # `++`, not a bare key: data.apply_chat_template_kwargs exists but holds an empty struct
+        # dict, so assigning a whole dict to it is rejected as an unknown sub-key.
+        "++data.apply_chat_template_kwargs={enable_thinking:"
+        + _hydra_val(config.get("thinking", False))
+        + "}",
         f"actor_rollout_ref.model.path={_hydra_val(config['model_path'])}",
         "actor_rollout_ref.model.trust_remote_code=true",
         "actor_rollout_ref.model.use_remove_padding=true",
@@ -1473,7 +1483,9 @@ def build_opd_verl_overrides(config: dict) -> list[str]:
         "actor_rollout_ref.rollout.mode=async",
         f"actor_rollout_ref.rollout.tensor_model_parallel_size={_hydra_val(config['n_gpus_per_node'])}",
         f"actor_rollout_ref.rollout.n={_hydra_val(config['group_size'])}",
-        "actor_rollout_ref.rollout.limit_images=8",
+        # `++`, not a bare key: limit_images is a real RolloutConfig field but is absent from the
+        # composed rollout node, so hydra rejects a bare assignment.
+        "++actor_rollout_ref.rollout.limit_images=8",
         f"actor_rollout_ref.rollout.max_model_len={_hydra_val(config.get('max_model_len', 32768))}",
         f"actor_rollout_ref.rollout.temperature={_hydra_val(config.get('temperature', 1.0))}",
         f"actor_rollout_ref.rollout.top_p={_hydra_val(config.get('top_p', 1.0))}",

{freesolo_flash_dev-1.0.26 → freesolo_flash_dev-1.0.28}/flash/engine/worker/rl_verl.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import contextlib
 import json
+import math
 import os
 import random
 import re
@@ -39,6 +40,21 @@ DATA_SOURCE = "flash_env"
 # --------------------------------------------------------------------------------------------
 # pure helpers (no verl, no gpu, no network) -- unit tested directly.
 # --------------------------------------------------------------------------------------------
+def _verl_epochs_for_horizon(
+    *, epochs: int, prompt_count: int, prompts_per_step: int, steps: int
+) -> int:
+    if prompt_count <= 0:
+        raise ValueError("prompt_count must be positive")
+    if prompts_per_step <= 0:
+        raise ValueError("prompts_per_step must be positive")
+    if prompt_count < prompts_per_step:
+        raise ValueError("prompt_count must be at least prompts_per_step")
+    # verl hardcodes drop_last=True, so each epoch serves floor(prompt_count / batch_size) steps.
+    # the flag cannot be configured off, and ceil here would still under-serve the requested horizon.
+    steps_per_epoch = prompt_count // prompts_per_step
+    return max(epochs, math.ceil(steps / steps_per_epoch))
+
+
 def build_verl_dataset_rows(
     message_prompts: list[list[dict]],
     example_indices: list[int],
@@ -70,8 +86,9 @@ def build_verl_overrides(cfg: dict) -> list[str]:
     """build the hydra override list for `python -m verl.trainer.main_ppo` (grpo + lora + vllm).
 
     carries the flash grpo recipe: dr-grpo advantages (no std norm, constant-length loss), the
-    job's kl coefficient (flash default 0 = no kl term), constant lr, seed, sampling top_p,
-    num_iterations (ppo_epochs), the max-steps horizon, and the save schedule.
+    job's kl coefficient (flash default 0 = no kl term), constant lr, seed, sampling top_p, and one
+    ppo epoch so total_training_steps counts optimizer updates. unlike trl's generation-batch reuse,
+    verl samples a fresh rollout per update, so rollout volume and policy staleness still differ.
     """
     kl_on = float(cfg["kl_coef"]) > 0
     o = [
@@ -97,7 +114,13 @@ def build_verl_overrides(cfg: dict) -> list[str]:
         # thread flash's thinking mode so the rollout sees the same prompt as the trl path.
         f"+data.apply_chat_template_kwargs.enable_thinking={str(bool(cfg.get('thinking', False))).lower()}",
         f"data.seed={cfg['seed']}",
-        f"actor_rollout_ref.rollout.seed={cfg['seed']}",
+        # rollout sampling seed. NOT `rollout.seed`: verl 0.8.0's RolloutConfig declares no such
+        # field, so a bare key fails hydra composition and a `+`/`++` prefix composes but then dies
+        # in omega_conf_to_dataclass with an unexpected-kwarg TypeError. engine_kwargs is a declared
+        # dict on both 0.8.0 and 0.9.x and is spread into the vllm engine args *after* verl's own
+        # "seed" entry, so it wins. `++` because the sub-key is absent from the composed node.
+        # single replica here (tp == n_gpus, nnodes=1), so verl's replica_rank offset is always 0.
+        f"++actor_rollout_ref.rollout.engine_kwargs.vllm.seed={cfg['seed']}",
         f"actor_rollout_ref.model.path={cfg['model_id']}",
         f"actor_rollout_ref.model.lora_rank={cfg['lora_rank']}",
         f"actor_rollout_ref.model.lora_alpha={cfg['lora_alpha']}",
@@ -116,12 +139,15 @@ def build_verl_overrides(cfg: dict) -> list[str]:
             else []
         ),
         f"actor_rollout_ref.actor.optim.lr={cfg['lr']}",
+        # only the lora adapter is trainable; decaying its weights toward zero is not part of grpo.
+        "actor_rollout_ref.actor.optim.weight_decay=0.0",
         # 0 warmup -> verl's warmup+constant scheduler holds lr flat, matching the trl constant recipe.
         "actor_rollout_ref.actor.optim.lr_warmup_steps_ratio=0.0",
         f"actor_rollout_ref.actor.ppo_mini_batch_size={cfg['prompts_per_step']}",
         f"actor_rollout_ref.actor.ppo_micro_batch_size_per_gpu={cfg['micro_batch']}",
-        # num_iterations: amortize each generation batch over N optimizer passes.
-        f"actor_rollout_ref.actor.ppo_epochs={cfg['num_iterations']}",
+        # ppo_epochs multiplies verl's update loop, so its default of 1 preserves the requested update
+        # count and on-policy baseline. unlike trl reuse, verl samples a fresh rollout for every update.
+        f"actor_rollout_ref.actor.ppo_epochs={cfg['ppo_epochs']}",
         "actor_rollout_ref.rollout.name=vllm",
         f"actor_rollout_ref.rollout.n={cfg['group_size']}",
         # safetensors load format is required for lora rollout on vllm.
@@ -170,6 +196,82 @@ def build_verl_overrides(cfg: dict) -> list[str]:
     return o
 
 
+def _build_verl_training_cfg(
+    inp: dict,
+    *,
+    train_files: str,
+    val_files: str,
+    model_id: str,
+    micro_batch: int,
+    thinking: bool,
+    loggers: str,
+    fp8_kv: bool,
+    reward_path: str,
+    local_dir: str,
+) -> dict:
+    return {
+        "train_files": train_files,
+        "val_files": val_files,
+        "model_id": model_id,
+        "lora_rank": inp["lora_rank"],
+        "lora_alpha": inp["lora_alpha"],
+        "target_modules": "all-linear",
+        "lr": inp["lr"],
+        "group_size": inp["group_size"],
+        "prompts_per_step": inp["prompts_per_step"],
+        "micro_batch": micro_batch,
+        "max_prompt_len": inp["max_prompt_len"],
+        "max_completion": inp["max_completion"],
+        "temperature": inp["temperature"],
+        "top_p": inp["top_p"],
+        "kl_coef": inp["kl_coef"],
+        "thinking": thinking,
+        "loss_agg_mode": "seq-mean-token-sum-norm",
+        "seed": inp["seed"],
+        "ppo_epochs": inp["ppo_epochs"],
+        "steps": int(inp["steps"]),
+        "warmstart_adapter": inp["warmstart_adapter"],
+        "gpu_mem_util": 0.5,
+        "tp_size": 1,
+        "loggers": loggers,
+        "fp8_kv": fp8_kv,
+        "reward_path": reward_path,
+        "reward_name": "compute_score",
+        "total_epochs": inp["verl_total_epochs"],
+        "save_freq": inp["save_every"],
+        "local_dir": local_dir,
+    }
+
+
+def _build_verl_train_notes(
+    inp: dict,
+    *,
+    steps_run: int,
+    retained_prompts: int,
+    reward_history: list[float],
+    loss_curve: list[float],
+) -> dict:
+    return {
+        "backend": "verl",
+        "steps": steps_run,
+        "epochs": inp["epochs"],
+        "retained_prompts": retained_prompts,
+        "group_size": inp["group_size"],
+        "reward_history": reward_history,
+        "loss_curve": loss_curve,
+        "grpo_recipe": {
+            "kl_coef": inp["kl_coef"],
+            "temperature": inp["temperature"],
+            "top_p": inp["top_p"],
+            "ppo_epochs": inp["ppo_epochs"],
+            "verl_total_epochs": inp["verl_total_epochs"],
+            "seed": inp["seed"],
+            "loss_agg_mode": "seq-mean-token-sum-norm",
+            "norm_adv_by_std_in_grpo": False,
+        },
+    }
+
+
 def render_reward_module(url_env: str = "FLASH_VERL_REWARD_URL") -> str:
     """source for the verl custom reward module.
 
@@ -490,10 +592,11 @@ def _resolve_single_turn_inputs():
             flush=True,
         )
     # trl drops truncated (non-eos) completions from the grpo loss (mask_truncated_completions,
-    # default True); verl's vllm rollout here has no per-completion truncation-mask knob, so verl
-    # keeps them. stop_sequences (the only case that turns masking off) already fails loudly above,
-    # so this is always the default-True case. record the divergence for parity observability
-    # rather than silently ignoring it; adding verl-side masking is a tracked follow-up.
+    # default True); verl 0.8.0 cannot express this through config. its vllm server discards the
+    # finish_reason length/stop distinction, and its rollout schemas and trainer masks never apply
+    # finish-reason-dependent response-loss masking anyway. stop_sequences (the only case that turns
+    # masking off) already fails loudly above, so this is always the default-True case. a real fix needs
+    # finish-reason propagation plus explicit zeroing of the truncated response loss mask.
     if _w.grpo_mask_truncated_completions(_t):
         print(
             "[rl-verl] mask_truncated_completions=True; verl keeps truncated completions in the "
@@ -587,16 +690,15 @@ def _resolve_single_turn_inputs():
         epochs=epochs, prompt_count=len(prompts), prompts_per_step=prompts_per_step
     )
     steps = resolve_update_horizon(derived_steps, getattr(_t, "max_steps", None) if _t else None)
-    # verl stops at BOTH total_epochs and total_training_steps; when an explicit max_steps exceeds
-    # the epoch-derived count, raise epochs so the dataloader can actually serve the horizon
-    # (otherwise verl exits early at total_epochs and the run under-trains).
-    if int(steps) > int(derived_steps) and len(prompts) > 0:
-        import math as _math
-
-        # verl's dataloader drops the last partial batch: floor, not ceil, else the bumped
-        # epoch count still under-serves the requested horizon.
-        steps_per_epoch = max(1, len(prompts) // prompts_per_step)
-        epochs = max(epochs, _math.ceil(int(steps) / steps_per_epoch))
+    # verl stops at both total_epochs and total_training_steps. give its hardcoded drop_last
+    # dataloader enough epoch capacity to serve the horizon, but preserve the configured epoch count
+    # for user-facing metadata. total_training_steps prevents the capacity headroom from over-training.
+    verl_total_epochs = _verl_epochs_for_horizon(
+        epochs=epochs,
+        prompt_count=len(prompts),
+        prompts_per_step=prompts_per_step,
+        steps=int(steps),
+    )
     save_every = int(_t.save_every) if (_t and _t.save_every) else 20
 
     return {
@@ -619,10 +721,12 @@ def _resolve_single_turn_inputs():
         "lora_alpha": lora_alpha,
         "warmstart_adapter": warmstart_adapter,
         "epochs": epochs,
+        "verl_total_epochs": verl_total_epochs,
         "steps": int(steps),
         "save_every": save_every,
-        # flash amortizes each generation batch over 2 optimizer passes (num_iterations=2).
-        "num_iterations": 2,
+        # verl's default preserves the update horizon and on-policy baseline; unlike trl reuse, each
+        # update gets a fresh rollout batch.
+        "ppo_epochs": 1,
         "seed": int(backend_seed(_w.SEED)),
     }
 
@@ -736,22 +840,18 @@ def run_rl_verl():
             )
         except Exception:  # no cuda / probe failure -> conservative bf16 kv
             fp8_kv = False
-        cfg = {
-            "train_files": train_pq, "val_files": val_pq,
-            "model_id": model_path_for_verl, "lora_rank": inp["lora_rank"],
-            "lora_alpha": inp["lora_alpha"], "target_modules": "all-linear",
-            "lr": inp["lr"], "group_size": inp["group_size"],
-            "prompts_per_step": inp["prompts_per_step"], "micro_batch": micro_batch,
-            "max_prompt_len": inp["max_prompt_len"], "max_completion": inp["max_completion"],
-            "temperature": inp["temperature"], "top_p": inp["top_p"], "kl_coef": inp["kl_coef"],
-            "thinking": bool(_w.THINKING),
-            "loss_agg_mode": "seq-mean-token-sum-norm", "seed": inp["seed"],
-            "num_iterations": inp["num_iterations"], "steps": expected_steps,
-            "warmstart_adapter": inp["warmstart_adapter"],
-            "gpu_mem_util": 0.5, "tp_size": 1, "loggers": loggers, "fp8_kv": fp8_kv,
-            "reward_path": reward_py, "reward_name": "compute_score",
-            "total_epochs": inp["epochs"], "save_freq": inp["save_every"], "local_dir": local_dir,
-        }
+        cfg = _build_verl_training_cfg(
+            inp,
+            train_files=train_pq,
+            val_files=val_pq,
+            model_id=model_path_for_verl,
+            micro_batch=micro_batch,
+            thinking=bool(_w.THINKING),
+            loggers=loggers,
+            fp8_kv=fp8_kv,
+            reward_path=reward_py,
+            local_dir=local_dir,
+        )
         overrides = build_verl_overrides(cfg)
 
         setup_seconds = time.time() - t_start
@@ -867,22 +967,11 @@ def run_rl_verl():
         )
         if resp_len_history
         else 0,
-        notes={
-            "backend": "verl",
-            "steps": steps_run,
-            "epochs": inp["epochs"],
-            "retained_prompts": len(prompts),
-            "group_size": inp["group_size"],
-            "reward_history": reward_history,
-            "loss_curve": loss_curve,
-            "grpo_recipe": {
-                "kl_coef": inp["kl_coef"],
-                "temperature": inp["temperature"],
-                "top_p": inp["top_p"],
-                "num_iterations": inp["num_iterations"],
-                "seed": inp["seed"],
-                "loss_agg_mode": "seq-mean-token-sum-norm",
-                "norm_adv_by_std_in_grpo": False,
-            },
-        },
+        notes=_build_verl_train_notes(
+            inp,
+            steps_run=steps_run,
+            retained_prompts=len(prompts),
+            reward_history=reward_history,
+            loss_curve=loss_curve,
+        ),
     )

{freesolo_flash_dev-1.0.26 → freesolo_flash_dev-1.0.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.0.26"
+version = "1.0.28"
 description = "Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI"
 readme = "README.md"
 # RunPod Flash supports Python 3.11-3.12 (not 3.13 yet).
@@ -116,7 +116,7 @@ artifacts = ["flash/py.typed"]
 # auto-published by .github/workflows/publish-dev.yml: a push to `dev` whose version isn't yet on
 # PyPI publishes it; pushes that don't change it find it already published and no-op. So cutting a
 # dev-channel release = bump this (and [project].version) and merge to `dev`.
-version = "1.0.26"
+version = "1.0.28"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

{freesolo_flash_dev-1.0.26 → freesolo_flash_dev-1.0.28}/tests/test_opd_verl.py

@@ -4389,7 +4389,11 @@ def test_overrides_match_verl_0_8_sync_distillation_contract():
     assert overrides["data.image_key"] == "images"
     assert overrides["data.return_raw_chat"] == "true"
     assert overrides["data.return_multi_modal_inputs"] == "false"
-    assert overrides["actor_rollout_ref.rollout.limit_images"] == "8"
+    # `++`-prefixed: these keys are absent from the composed node, so a bare assignment would abort
+    # the run at hydra composition. see build_opd_verl_overrides for the per-key reasoning.
+    assert overrides["++actor_rollout_ref.rollout.limit_images"] == "8"
+    assert overrides["++actor_rollout_ref.rollout.engine_kwargs.vllm.seed"] == "42"
+    assert "actor_rollout_ref.rollout.seed" not in overrides
     assert "actor.engine.ulysses_sequence_parallel_size" not in overrides
     assert "ref_log_prob" not in " ".join(overrides)
     assert not any("structured_outputs_config" in key for key in overrides)

{freesolo_flash_dev-1.0.26 → freesolo_flash_dev-1.0.28}/tests/test_rl_verl.py

@@ -60,7 +60,7 @@ def _overrides_cfg(**over):
         "target_modules": "all-linear", "lr": 1e-5, "group_size": 8,
         "prompts_per_step": 16, "micro_batch": 2, "max_prompt_len": 2048,
         "max_completion": 320, "temperature": 1.0, "top_p": 0.95, "kl_coef": 0.0,
-        "loss_agg_mode": "seq-mean-token-sum-norm", "seed": 42, "num_iterations": 2,
+        "loss_agg_mode": "seq-mean-token-sum-norm", "seed": 42, "ppo_epochs": 1,
         "steps": 60, "gpu_mem_util": 0.5, "tp_size": 1, "loggers": "console", "fp8_kv": False,
         "warmstart_adapter": "", "reward_path": "/w/reward.py", "reward_name": "compute_score",
         "total_epochs": 1, "save_freq": 20, "local_dir": "/w/ckpt",
@@ -79,12 +79,16 @@ def test_build_verl_overrides_carries_dr_grpo_recipe():
     assert "actor_rollout_ref.rollout.n=8" in o
     assert "actor_rollout_ref.rollout.load_format=safetensors" in o
     assert "actor_rollout_ref.rollout.top_p=0.95" in o
-    # constant lr, num_iterations, gradient checkpointing, seed, max-steps horizon, save schedule.
+    # constant lr, on-policy updates, gradient checkpointing, seed, max-steps horizon, save schedule.
+    assert "actor_rollout_ref.actor.optim.weight_decay=0.0" in o
     assert "actor_rollout_ref.actor.optim.lr_warmup_steps_ratio=0.0" in o
-    assert "actor_rollout_ref.actor.ppo_epochs=2" in o
+    assert "actor_rollout_ref.actor.ppo_epochs=1" in o
     assert "actor_rollout_ref.model.enable_gradient_checkpointing=True" in o
     assert "data.seed=42" in o
-    assert "actor_rollout_ref.rollout.seed=42" in o
+    # the rollout engine seed rides engine_kwargs, not `rollout.seed`, which verl 0.8.0's
+    # RolloutConfig does not declare. see build_verl_overrides for the full reasoning.
+    assert "++actor_rollout_ref.rollout.engine_kwargs.vllm.seed=42" in o
+    assert "actor_rollout_ref.rollout.seed=42" not in o
     assert "trainer.total_training_steps=60" in o
     assert "trainer.save_freq=20" in o
     assert "trainer.max_actor_ckpt_to_keep=1" in o
@@ -95,6 +99,141 @@ def test_build_verl_overrides_carries_dr_grpo_recipe():
     assert "algorithm.rollout_correction.rollout_is_threshold=2.0" in o
 
 
+def test_build_verl_overrides_does_not_emit_inert_drop_last_override():
+    # this guards only against flash emitting a misleading no-op; it does not prove verl reads the key.
+    o = rl_verl.build_verl_overrides(_overrides_cfg())
+    assert not any("drop_last" in override for override in o)
+
+
+@pytest.mark.parametrize(
+    ("prompt_count", "prompts_per_step", "epochs", "max_steps", "expected_steps", "expected_epochs"),
+    [
+        pytest.param(33, 16, 2, None, 5, 3, id="partial-batch-derived-horizon"),
+        pytest.param(32, 16, 2, 7, 7, 4, id="explicit-horizon-beyond-derived"),
+        pytest.param(32, 16, 2, None, 4, 2, id="exactly-divisible"),
+    ],
+)
+def test_verl_epoch_capacity_reaches_update_horizon(
+    prompt_count, prompts_per_step, epochs, max_steps, expected_steps, expected_epochs
+):
+    derived_steps = rl_verl.on_policy_steps(
+        epochs=epochs, prompt_count=prompt_count, prompts_per_step=prompts_per_step
+    )
+    steps = rl_verl.resolve_update_horizon(derived_steps, max_steps)
+    resolved_epochs = rl_verl._verl_epochs_for_horizon(
+        epochs=epochs,
+        prompt_count=prompt_count,
+        prompts_per_step=prompts_per_step,
+        steps=steps,
+    )
+
+    assert steps == expected_steps
+    assert resolved_epochs == expected_epochs
+    assert (prompt_count // prompts_per_step) * resolved_epochs >= steps
+
+
+@pytest.mark.parametrize(
+    ("prompt_count", "prompts_per_step", "message"),
+    [
+        pytest.param(0, 16, "prompt_count must be positive", id="no-prompts"),
+        pytest.param(5, 0, "prompts_per_step must be positive", id="zero-batch"),
+        pytest.param(5, 16, "prompt_count must be at least", id="batch-exceeds-prompts"),
+    ],
+)
+def test_verl_epoch_capacity_rejects_invalid_batch_inputs(
+    prompt_count, prompts_per_step, message
+):
+    with pytest.raises(ValueError, match=message):
+        rl_verl._verl_epochs_for_horizon(
+            epochs=2,
+            prompt_count=prompt_count,
+            prompts_per_step=prompts_per_step,
+            steps=3,
+        )
+
+
+def test_verl_epoch_capacity_invariant_across_valid_inputs():
+    for prompt_count in range(1, 34):
+        for prompts_per_step in range(1, prompt_count + 1):
+            for epochs in (1, 2, 4):
+                for steps in (1, epochs, epochs + 5):
+                    resolved_epochs = rl_verl._verl_epochs_for_horizon(
+                        epochs=epochs,
+                        prompt_count=prompt_count,
+                        prompts_per_step=prompts_per_step,
+                        steps=steps,
+                    )
+                    assert (prompt_count // prompts_per_step) * resolved_epochs >= steps
+
+
+def test_verl_resolver_builds_capacity_overrides_and_configured_metadata(monkeypatch):
+    from flash.engine.worker._pkg import W
+    from flash.spec import JobSpec
+
+    class _Env:
+        multi_turn = False
+        is_tool_env = False
+
+        def dataset(self):
+            return [{"index": i} for i in range(33)]
+
+        def prompt_messages(self, ex):
+            return [{"role": "user", "content": f"question {ex['index']}"}]
+
+    class _Tokenizer:
+        pad_token = None
+        eos_token = "<eos>"
+
+        def apply_chat_template(self, messages, **kwargs):
+            return messages[0]["content"]
+
+        def __call__(self, text, **kwargs):
+            return SimpleNamespace(input_ids=[1])
+
+    spec = JobSpec.from_dict(
+        {
+            "model": "Qwen/Qwen3.5-0.8B",
+            "algorithm": "grpo",
+            "train": {"batch_size": 16, "epochs": 2},
+        }
+    )
+    monkeypatch.setattr(W, "JOB_SPEC", spec, raising=False)
+    monkeypatch.setattr(W, "SEED", 42, raising=False)
+    monkeypatch.setattr(W, "THINKING", False, raising=False)
+    monkeypatch.setattr(W, "require_active_env", lambda: _Env(), raising=False)
+    monkeypatch.setattr(W, "grpo_overrides", lambda: {}, raising=False)
+    monkeypatch.setattr(W, "grpo_mask_truncated_completions", lambda train: False, raising=False)
+    monkeypatch.setattr(W, "load_tokenizer", lambda *args, **kwargs: _Tokenizer(), raising=False)
+    monkeypatch.setattr(rl_verl, "seed_training_rngs", lambda seed: None)
+
+    inp = rl_verl._resolve_single_turn_inputs()
+    cfg = rl_verl._build_verl_training_cfg(
+        inp,
+        train_files="/w/train.parquet",
+        val_files="/w/val.parquet",
+        model_id=inp["model_id"],
+        micro_batch=1,
+        thinking=False,
+        loggers="console",
+        fp8_kv=False,
+        reward_path="/w/reward.py",
+        local_dir="/w/ckpt",
+    )
+    overrides = rl_verl.build_verl_overrides(cfg)
+    notes = rl_verl._build_verl_train_notes(
+        inp,
+        steps_run=5,
+        retained_prompts=len(inp["prompts"]),
+        reward_history=[],
+        loss_curve=[],
+    )
+
+    assert "trainer.total_training_steps=5" in overrides
+    assert "trainer.total_epochs=3" in overrides
+    assert notes["epochs"] == 2
+    assert notes["grpo_recipe"]["verl_total_epochs"] == 3
+
+
 def test_build_verl_overrides_wandb_logger_when_enabled():
     o = rl_verl.build_verl_overrides(_overrides_cfg(loggers="console,wandb"))
     assert "trainer.logger=[console,wandb]" in o

{freesolo_flash_dev-1.0.26 → freesolo_flash_dev-1.0.28}/uv.lock

@@ -1025,7 +1025,7 @@ wheels = [
 
 [[package]]
 name = "freesolo-flash"
-version = "1.0.26"
+version = "1.0.28"
 source = { editable = "." }
 
 [package.optional-dependencies]