freesolo-flash-dev 1.2.129__tar.gz → 1.2.131__tar.gz

{freesolo_flash_dev-1.2.129 → freesolo_flash_dev-1.2.131}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.129
+Version: 1.2.131
 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.2.129 → freesolo_flash_dev-1.2.131}/flash/core/catalog.py

@@ -258,7 +258,7 @@ MODELS: dict[str, ModelInfo] = {
         quant="bf16",
         recommended_gpu="A100 PCIe",
         serving=ServingCapacity(
-            gpu="L40S",
+            gpu="B200",
             serve_model_id=SERVING_MODEL_REPOS["Qwen/Qwen3.5-9B"],
             max_loras=16,
             max_cpu_loras=16,
@@ -318,7 +318,7 @@ MODELS: dict[str, ModelInfo] = {
         recommended_gpu="A100 PCIe",
         min_disk_gb=160,
         serving=ServingCapacity(
-            gpu="H100",
+            gpu="B200",
             serve_model_id=SERVING_MODEL_REPOS["Qwen/Qwen3.8-27B"],
             max_loras=16,
             max_cpu_loras=16,
@@ -332,7 +332,7 @@ MODELS: dict[str, ModelInfo] = {
         thinking="hybrid",
         notes="Dense 27.781427952B multimodal VL checkpoint with image-capable bf16 LoRA training. "
         "SFT fits the 80GB A100 (~55.6GB weights); colocated GRPO needs the B200 (trainer + vLLM "
-        "rollout = two copies). Hosted serving remains pending the exact official FP8 H100 canary.",
+        "rollout = two copies). Hosted serving runs the official FP8 checkpoint on the B200.",
     ),
     "Qwen/Qwen3.6-35B-A3B": ModelInfo(
         id="Qwen/Qwen3.6-35B-A3B",
@@ -393,10 +393,10 @@ MODELS: dict[str, ModelInfo] = {
         quant="bf16",
         recommended_gpu="H200",
         serving=ServingCapacity(
-            gpu="H200",
+            gpu="B200",
             serve_model_id=SERVING_MODEL_REPOS["Qwen/Qwen3.6-35B-A3B"],
-            # bf16 on h200 is the validated full-expert lora path. six hot rank-64 adapters plus 32k
-            # fit with cuda graphs and a 679,701-token kv cache; eight hot adapters overflow the card.
+            # bf16 is the validated full-expert lora path. six hot rank-64 adapters plus 32k fit
+            # with cuda graphs; the b200 measured 49.38 GiB of kv (3,678,952 tokens) for this shape.
             max_loras=6,
             max_cpu_loras=6,
             max_lora_rank=64,

{freesolo_flash_dev-1.2.129 → freesolo_flash_dev-1.2.131}/flash/core/spec.py

@@ -20,6 +20,7 @@ detail. See their docstrings before changing either.
 from __future__ import annotations
 
 import json
+import math
 import os
 from dataclasses import asdict, dataclass, field, fields
 from typing import Any, Literal
@@ -365,6 +366,9 @@ class TrainSpec:
     hf_repo: str = ""
     # None -> worker's tuned recipe default.
     learning_rate: float | None = field(default=None, metadata={"introduced_in": "0.2.0"})
+    # sft only: none preserves a legacy persisted run's 16x optimizer. new configs freeze the
+    # recipe default at parse time; 1 uses equal adapter learning rates.
+    loraplus_ratio: float | None = field(default=None, metadata={"introduced_in": "1.2.131"})
     # sft only. the packaged-dataset estimate resolves this against the selected row count into
     # examples_per_update (packed) or pins the optimizer batch to 1 (unpacked). grpo/opd have no
     # profile, so they take prompts_per_step instead and reject this key: the two are not the same
@@ -399,6 +403,17 @@ class TrainSpec:
     )
 
     def __post_init__(self) -> None:
+        if self.loraplus_ratio is not None:
+            ratio = self.loraplus_ratio
+            if isinstance(ratio, bool) or not isinstance(ratio, (int, float)):
+                raise TypeError("train.loraplus_ratio must be a number")
+            try:
+                ratio = float(ratio)
+            except OverflowError as exc:
+                raise ValueError("train.loraplus_ratio must be a finite number >= 1") from exc
+            if not math.isfinite(ratio) or ratio < 1:
+                raise ValueError("train.loraplus_ratio must be a finite number >= 1")
+            object.__setattr__(self, "loraplus_ratio", ratio)
         if not self.lora_alpha:
             object.__setattr__(self, "lora_alpha", 2 * self.lora_rank)
         max_steps = parse_max_steps(self.max_steps)
@@ -566,6 +581,8 @@ class JobSpec:
     project: str = ""
 
     def __post_init__(self) -> None:
+        if self.train.loraplus_ratio is not None and self.algorithm != "sft":
+            raise ValueError("train.loraplus_ratio only applies to sft")
         object.__setattr__(self, "seed", parse_seed(self.seed))
         object.__setattr__(self, "model_revision", _model_revision(self.model_revision))
         for field_name in ("model_revision_auto", "model_revision_force_pin"):
@@ -681,6 +698,9 @@ class JobSpec:
         differently, so removing either pop would break existing digests.
         """
         data = asdict(self)
+        # preserve historical preparation digests when the new option was not authored.
+        if data["train"]["loraplus_ratio"] is None:
+            data["train"].pop("loraplus_ratio")
         # missing and unset are the same internal state. omitting the empty value preserves that state
         # without serializing it into an explicit empty preference, which every parser rejects.
         if not data["gpu"].get("providers"):
@@ -786,6 +806,7 @@ class JobSpec:
                 init_from_adapter_revision=str(train.get("init_from_adapter_revision") or ""),
                 hf_repo=str(train.get("hf_repo") or ""),
                 learning_rate=opt_float(train.get("learning_rate")),
+                loraplus_ratio=train.get("loraplus_ratio"),
                 batch_size=opt_int(train.get("batch_size")),
                 prompts_per_step=opt_int(train.get("prompts_per_step")),
                 max_context_tokens=opt_int(train.get("max_context_tokens")),

{freesolo_flash_dev-1.2.129 → freesolo_flash_dev-1.2.131}/flash/engine/plan/recipe.py

@@ -170,6 +170,7 @@ class SFTConfig:
     max_seq_len: int = 1024
     max_seq_len_thinking: int = 2048
     learning_rate: float = 1e-4
+    loraplus_ratio: float = 1.0
     warmup_frac: float = 0.03
     effective_batch: int = 32
     num_epochs: int = 2

{freesolo_flash_dev-1.2.129 → freesolo_flash_dev-1.2.131}/flash/engine/worker/train/entry/sft_train.py

@@ -28,7 +28,6 @@ from flash.engine.worker.verl.checkpoints import restore_verl_resume
 from flash.engine.worker.verl.parallelism import ULYSSES_SEQUENCE_PARALLEL_SIZE
 
 # todo: run the two-gpu sft smoke on the exact runpod image and command assembled below.
-_SFT_LORAPLUS_RATIO = 16.0
 # consecutive zero-grad-norm steps tolerated before the run is failed as untrainable (GRAD-001).
 # any nonzero grad norm is proof the backward graph is intact and resets the count. 2 is enough to
 # separate a one-off fully-masked batch from a severed graph, and keeps the wasted spend to a couple
@@ -488,6 +487,7 @@ def _write_sft_result(options, data, model, child, progress, verified, outputs)
             "device_peak_gpu_gb": device_peak_gpu_gb,
             "loraplus_optim": _VERL_OPTIMIZER_NAME,
             "loraplus_applied": progress.loraplus_applied,
+            "loraplus_ratio": options.loraplus_ratio,
             "verl_backend": "fsdp2",
             # sft shards by DATA -- see ULYSSES_SEQUENCE_PARALLEL_SIZE for why. fsdp splits the batch
             # across the ranks actually LAUNCHED, which is the allocated card count only when the
@@ -585,7 +585,7 @@ def run_sft_train(spec=None) -> None:
     child = _prepare_sft_child(
         options, data, model, capabilities, use_remove_padding, gdn_reset_arch
     )
-    child_progress = _prepare_sft_progress(data, model, child)
+    child_progress = _prepare_sft_progress(options, data, model, child)
     progress = child_progress.values
 
     def on_line(line: str) -> None:

{freesolo_flash_dev-1.2.129 → freesolo_flash_dev-1.2.131}/flash/engine/worker/train/entry/sft_train_runner.py

@@ -33,7 +33,6 @@ from flash.providers.core.base import rentable_gpu_counts
 
 RECIPE = _sft_train.RECIPE
 _MAX_ZERO_GRAD_STEPS = _sft_train._MAX_ZERO_GRAD_STEPS
-_SFT_LORAPLUS_RATIO = _sft_train._SFT_LORAPLUS_RATIO
 _LORAPLUS_READY_MARKER = _sft_train._LORAPLUS_READY_MARKER
 _VERL_OPTIMIZER_IMPL = _sft_train._VERL_OPTIMIZER_IMPL
 _VERL_OPTIMIZER_NAME = _sft_train._VERL_OPTIMIZER_NAME
@@ -70,6 +69,7 @@ class _SftOptions:
     model_revision: str
     epochs: int
     learning_rate: float
+    loraplus_ratio: float
     effective_batch: int
     max_steps: int
     save_at_steps: tuple[int, ...]
@@ -147,6 +147,7 @@ class _SftProgress:
     loss_curve: list[float]
     train_tokens: int
     loraplus_applied: bool
+    loraplus_ratio: float
     wandb_link: dict[str, str | None]
     # what the child plugin must prove applied; verified at the first optimizer step and again at
     # child exit.
@@ -187,6 +188,9 @@ def _resolve_sft_options(spec) -> _SftOptions:
     model_id = spec.model if spec else RECIPE.hf_model_id
     model_revision = getattr(spec, "model_revision", "") if spec else ""
     train_spec = spec.train if spec else None
+    # new authored sft specs persist their ratio. an unset stored value predates the option and
+    # must retain the 16x optimizer groups used by its checkpoint, including across further retries.
+    default_loraplus_ratio = 16.0 if train_spec is not None else RECIPE.sft.loraplus_ratio
 
     def train_opt(name, default):
         value = getattr(train_spec, name, None) if train_spec else None
@@ -215,6 +219,7 @@ def _resolve_sft_options(spec) -> _SftOptions:
         model_revision=model_revision,
         epochs=int(train_opt("epochs", RECIPE.sft.num_epochs)),
         learning_rate=float(train_opt("learning_rate", RECIPE.sft.learning_rate)),
+        loraplus_ratio=float(train_opt("loraplus_ratio", default_loraplus_ratio)),
         effective_batch=int(train_opt("batch_size", RECIPE.sft.effective_batch)),
         max_steps=int(train_opt("max_steps", 0) or 0),
         save_at_steps=tuple(getattr(train_spec, "save_at_steps", ()) or ()),
@@ -588,7 +593,7 @@ def _write_sft_child_shims(
         {
             "marker_file": shim_markers,
             "seed": int(seed),
-            "loraplus_ratio": float(_SFT_LORAPLUS_RATIO),
+            "loraplus_ratio": options.loraplus_ratio,
             "loraplus_ready_marker": _LORAPLUS_READY_MARKER,
             "save_at_steps": list(options.save_at_steps),
             "total_steps": int(model.update_horizon),
@@ -758,7 +763,9 @@ def _prepare_sft_child(
     )
 
 
-def _prepare_sft_progress(data: _SftData, model: _SftModelSetup, child: _SftChild) -> _SftProgress:
+def _prepare_sft_progress(
+    options: _SftOptions, data: _SftData, model: _SftModelSetup, child: _SftChild
+) -> _SftProgress:
     resume_step = child.resume_step
     progress = {"step": resume_step, "loss": None, "grad_norm": None, "lr": None}
     # consecutive steps seen with grad_norm == 0.0 at a nonzero lr. one step can legitimately be
@@ -785,7 +792,8 @@ def _prepare_sft_progress(data: _SftData, model: _SftModelSetup, child: _SftChil
         observed_grad_norms=observed_grad_norms,
         loss_curve=[],
         train_tokens=train_tokens,
-        loraplus_applied=resume_step >= model.update_horizon,
+        loraplus_applied=options.loraplus_ratio > 1 and resume_step >= model.update_horizon,
+        loraplus_ratio=options.loraplus_ratio,
         wandb_link={},
         shim_markers=child.shim_markers,
         expected_shims=child.expected_shims,
@@ -846,7 +854,7 @@ def _consume_sft_marker_line(progress: _SftProgress, line: str) -> bool:
     if progress.expected_shims and not progress.shims_verified:
         verify_applied_shim_markers(progress.shim_markers, progress.expected_shims)
         progress.shims_verified = True
-    if _SFT_LORAPLUS_RATIO > 1 and not progress.loraplus_applied:
+    if progress.loraplus_ratio > 1 and not progress.loraplus_applied:
         raise RuntimeError(
             "verl reached an optimizer step before the required lora+ shim succeeded"
         )
@@ -914,7 +922,7 @@ def _finish_sft_child(
     if progress.expected_shims and not progress.shims_verified:
         verify_applied_shim_markers(progress.shim_markers, progress.expected_shims)
         progress.shims_verified = True
-    if _SFT_LORAPLUS_RATIO > 1 and not progress.loraplus_applied:
+    if progress.loraplus_ratio > 1 and not progress.loraplus_applied:
         raise RuntimeError("required lora+ shim did not emit its success marker")
     return train_wall, device_peak_gpu_gb
 

{freesolo_flash_dev-1.2.129 → freesolo_flash_dev-1.2.131}/flash/schema/__init__.py

@@ -25,6 +25,7 @@ from flash.core.spec import (
     parse_seed,
     require_project_id,
 )
+from flash.engine.plan.recipe import RECIPE
 from flash.providers.core.base import (
     UnsupportedGpuError,
     authored_gpu_ceiling,
@@ -297,6 +298,8 @@ def validate_train_keys_for_algorithm(train_raw: Mapping[str, Any], algorithm: s
     every spec fail to reparse its own output and break resubmit, warm-start and server reparse.
     A null is the absence of an authored value, which is exactly what the user is being asked for.
     """
+    if train_raw.get("loraplus_ratio") is not None and algorithm != "sft":
+        raise ConfigError("train.loraplus_ratio only applies to sft")
     for key, allowed in _ALGORITHM_ONLY_TRAIN_KEYS.items():
         if train_raw.get(key) is None or algorithm in allowed:
             continue
@@ -678,6 +681,10 @@ def spec_from_dict(
     )
     wandb_spec = _validate_wandb_section(raw)
 
+    loraplus_ratio = _train_float(train_raw, "loraplus_ratio", minimum=1.0)
+    if algorithm == "sft" and loraplus_ratio is None:
+        # freeze the new default; an absent persisted value identifies the legacy 16x optimizer.
+        loraplus_ratio = RECIPE.sft.loraplus_ratio
     try:
         train_spec = TrainSpec(
             epochs=_train_int(train_raw, "epochs", minimum=1),
@@ -686,6 +693,7 @@ def spec_from_dict(
             init_from_adapter=init_from_adapter,
             hf_repo="",  # assigned server-side; see submit_job._assign_managed_hf_repo
             learning_rate=_train_float(train_raw, "learning_rate", minimum=0.0, exclusive=True),
+            loraplus_ratio=loraplus_ratio,
             batch_size=_train_int(train_raw, "batch_size", minimum=1),
             prompts_per_step=_train_int(train_raw, "prompts_per_step", minimum=1),
             max_context_tokens=_train_int(train_raw, "max_context_tokens", minimum=1),

{freesolo_flash_dev-1.2.129 → freesolo_flash_dev-1.2.131}/flash/schema/fields.py

@@ -65,7 +65,10 @@ def _train_float(
         return None
     if isinstance(v, bool) or not isinstance(v, (int, float)):
         raise ConfigError(f"train.{key} must be a number")
-    v = float(v)
+    try:
+        v = float(v)
+    except OverflowError as exc:
+        raise ConfigError(f"train.{key} must be a finite number") from exc
     # nan/inf slip past range checks (nan compares false, inf passes any minimum).
     if not math.isfinite(v):
         raise ConfigError(f"train.{key} must be a finite number")

{freesolo_flash_dev-1.2.129 → freesolo_flash_dev-1.2.131}/flash/serve/deployment/profiles.py

@@ -385,9 +385,15 @@ def _require_catalog_agreement(profile: ServingProfile) -> None:
                 f"{profile.model_id} serving profile {name}={actual!r} disagrees with the "
                 f"catalog capacity {expected!r}"
             )
+    # NB: modal_gpu is deliberately NOT checked against serving.gpu. They describe different
+    # planes: serving.gpu is the card the freesolo-owned hosted plane runs on, while modal_gpu is
+    # the card THIS customer-owned profile was live-qualified on (modal_live_qualified). The hosted
+    # plane moved to B200; the customer profiles stay on their qualified cards until a customer-owned
+    # B200 qualification runs. Engine SHAPE still has to agree -- see _CATALOG_CHECKED_FIELDS, which
+    # is what stops a profile serving a longer context or higher lora rank than the catalog
+    # advertises. The card is placement, not shape.
     for label, expected, actual in (
         ("served_model", serving.serve_model_id, profile.served_model),
-        ("modal gpu", serving.gpu, profile.modal_gpu),
     ):
         if expected != actual:
             raise ProfileError(

{freesolo_flash_dev-1.2.129 → freesolo_flash_dev-1.2.131}/flash/serving/app/modal_app.py

@@ -93,10 +93,11 @@ HOSTING_CACHE_MOUNT = "/vol/hosting-cache"
 # below — HF/internal key, backend + Supabase URLs — stays env-configured because it is per-deploy
 # credentials, not tuning.)
 TIMEOUT_SECONDS = 600
-# 2700s (45 min): the 35B bf16/H200 cold boot takes ~1010s of engine init alone (67 GiB load +
-# ~377s torch.compile + graph capture + warmup) on top of image pull, which blows past the old 1200s
-# ceiling — Modal SIGTERMs the container mid-warmup and it cold-cycles forever. A higher ceiling is
-# harmless for the fast tiers (they still boot in a minute; this is only a kill-if-stuck bound).
+# 2700s (45 min): the slowest MEASURED cold boot on the shipped B200 tiers is the 27B at 1821s
+# (a cold torch.compile cache alone costs ~354s of Dynamo), on top of image pull. The old 1200s
+# ceiling was already blown by the 35B's ~1010s of engine init — Modal SIGTERMs the container
+# mid-warmup and it cold-cycles forever. 2700s leaves ~880s of margin over the worst measurement,
+# and a higher ceiling is harmless for the fast tiers: this is only a kill-if-stuck bound.
 STARTUP_TIMEOUT_SECONDS = 2700
 # The router awaits the engine call, which on a cold base model includes vLLM startup, so its
 # timeout must cover startup + a request (else it's killed mid cold-start).
@@ -126,10 +127,14 @@ SCALEDOWN_WINDOW_SECONDS_BY_GPU: dict[str, int] = {
     # ~1010s cold boot (35B bf16, 67 GiB + ~377s torch.compile). Break-even AND a ~17-min
     # user-visible stall on a miss both argue for keeping the full window here.
     "H200": 1800,
-    # Blackwell. No cold-boot canary has run on either card yet, so both hold the H200's window as a
-    # placeholder: it is the longest we ship, and a too-long hold overpays for idle rather than
-    # cold-cycling a user request. Replace each with its measured boot time when the canary runs.
-    "B200": 1800,
+    # B200 now carries all three tiers. Measured cold boots (2026-08-30/31, this card): 9B 723s,
+    # 35B 488s, 27B 1821s. The 27B dominates because a cold torch.compile cache costs ~354s of
+    # Dynamo alone; warm-cache boots of the same tiers run 153-473s. Sized to the slowest MEASURED
+    # cold boot rather than the warm case, so a scale-out replacement is not cycled mid-boot.
+    "B200": 2100,
+    # B300 has no shipped tier. It also wedges intermittently serving above max_num_seqs (sm 10.3;
+    # B200 served 20/20 on the same workload), so it is not a deployment target yet -- the window
+    # stays a placeholder rather than a measurement.
     "B300": 1800,
 }
 # The tiers this app is allowed to run an engine on. `gpu` in the serving catalog is a plain string,
@@ -275,7 +280,7 @@ image = (
             # artifacts to VLLM_CACHE_ROOT/torch_compile_cache/<hash>/ (vllm/compilation/backends.py),
             # plus modelinfos/ and the GPU p2p cache. With MIN_CONTAINERS = 0 and a 30-minute
             # scaledown window that cost is paid on every cold start — it is the torch.compile +
-            # graph-capture portion of the ~1010s 35B engine init measured for STARTUP_TIMEOUT_SECONDS.
+            # graph-capture portion of the cold boots measured for STARTUP_TIMEOUT_SECONDS.
             # vLLM's own startup benchmark DEFINES a cold start this way (benchmarks/startup.py
             # cold_startup() points VLLM_CACHE_ROOT at a fresh mkdtemp), so leaving it unset on
             # ephemeral storage reproduces that worst case involuntarily.

{freesolo_flash_dev-1.2.129 → freesolo_flash_dev-1.2.131}/flash/serving/src/accounting/usage.py

@@ -41,9 +41,16 @@ _USD_PER_MTOK_DIVISOR = Decimal("1000000")
 @dataclass(frozen=True)
 class AuthorizedTraffic:
     principal: ServingTrafficPrincipal
-    openrouter_request_id: str | None = None
-    openrouter_generation_id: str | None = None
-    upstream_id: str | None = None
+
+
+@dataclass(frozen=True)
+class TrustedInternalAuthorization:
+    """A trusted server-to-server caller that has not yet been attributed to an organization."""
+
+    org_id: str | None = None
+
+
+InferenceAuthorization = AuthorizedTraffic | TrustedInternalAuthorization
 
 
 @dataclass(frozen=True)
@@ -104,7 +111,6 @@ def new_request_identity(
     request: Request,
     *,
     openai_completion_id: str | None = None,
-    traffic: AuthorizedTraffic | None = None,
 ) -> RequestIdentity:
     request_id = new_generation_id()
     supplied_correlation = _bounded_header(request, "X-Correlation-ID")
@@ -113,9 +119,6 @@ def new_request_identity(
         request_id=request_id,
         correlation_id=correlation_id,
         openai_completion_id=openai_completion_id,
-        openrouter_request_id=traffic.openrouter_request_id if traffic else None,
-        openrouter_generation_id=traffic.openrouter_generation_id if traffic else None,
-        upstream_id=traffic.upstream_id if traffic else None,
     )
 
 
@@ -131,29 +134,13 @@ def build_usage_session(
     serving_release: str,
     captured_at: datetime,
 ) -> UsageSession:
-    public_model_id = (
-        principal.publicModelId if principal.kind == "openrouter" else requested.adapter_id
-    )
     immutable_target = ImmutableTarget(
-        public_model_id=public_model_id,
+        public_model_id=requested.adapter_id,
         base_model=target.base_model,
         checkpoint_id=target.adapter_id if target.is_checkpoint else None,
         artifact_fingerprint=target.artifact_fingerprint,
     )
-    price = (
-        CapturedPrice(
-            source="openrouter_admission",
-            version=principal.providerCatalogDigest,
-            snapshot=principal.acceptedPriceSnapshot.model_dump(mode="json"),
-        )
-        if principal.kind == "openrouter"
-        else freesolo_price(target.base_model)
-    )
-    if principal.kind == "trusted_internal" and target.org_id is not None:
-        principal = TrustedInternalTrafficPrincipal(
-            orgId=target.org_id,
-            billingAttributionExplicit=True,
-        )
+    price = freesolo_price(target.base_model)
     return UsageSession(
         store=store,
         identity=identity,
@@ -191,11 +178,8 @@ def principal_for_external_org(org_id: str) -> FreesoloOrgTrafficPrincipal:
     return FreesoloOrgTrafficPrincipal(orgId=org_id)
 
 
-def principal_for_trusted_internal(org_id: str | None = None) -> TrustedInternalTrafficPrincipal:
-    return TrustedInternalTrafficPrincipal(
-        orgId=org_id,
-        billingAttributionExplicit=org_id is not None,
-    )
+def principal_for_trusted_internal(org_id: str) -> TrustedInternalTrafficPrincipal:
+    return TrustedInternalTrafficPrincipal(orgId=org_id)
 
 
 def captured_now() -> datetime: