freesolo-flash-dev 1.2.39__tar.gz → 1.2.43__tar.gz

{freesolo_flash_dev-1.2.39 → freesolo_flash_dev-1.2.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.39
+Version: 1.2.43
 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.43/flash/adapters/fused_experts.py

@@ -0,0 +1,375 @@
+"""Fused-expert LoRA targeting, validation, and export normalization."""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+from collections.abc import Mapping
+from typing import Any
+
+from flash.adapters.lora_rank import (
+    _rank_for_module,
+    declared_lora_ranks,
+    lora_tensor_rank_disagrees,
+)
+from flash.core.catalog import get_model
+
+_QWEN36_MODEL_ID = "Qwen/Qwen3.6-35B-A3B"
+_QWEN36_EXPERT_TARGET_PARAMETERS = (
+    "mlp.experts.gate_up_proj",
+    "mlp.experts.down_proj",
+)
+_QWEN36_FUSED_TARGET_DIMENSIONS = {
+    "mlp.experts.gate_up_proj": (2048, 1024),
+    "mlp.experts.down_proj": (512, 2048),
+}
+_QWEN36_FUSED_TARGET_RUNGS = {
+    "mlp.experts.down_proj": "",
+    "mlp.experts.gate_up_proj": "base_layer",
+}
+_FUSED_EXPERT_SYNTHETIC_MODULES = frozenset({"experts", "base_layer"})
+_FUSED_EXPERT_WRAPPER_MODULES = ("mlp.experts", "mlp.experts.base_layer")
+_INVALID_FUSED_LOCATION = object()
+
+_LoraTensor = tuple[str, str, str, str, tuple[int, ...]]
+_LoraPair = tuple[tuple[int, ...], tuple[int, ...]]
+
+
+def lora_target_parameters(model_id: str | None) -> list[str] | None:
+    """Return direct parameter targets required by the model's fused expert layout."""
+    if model_id == _QWEN36_MODEL_ID:
+        return list(_QWEN36_EXPERT_TARGET_PARAMETERS)
+    return None
+
+
+def validate_fused_expert_adapter_config(config: Mapping[str, Any], model_id: str) -> None:
+    """Validate the exact current adapter config required by a fused-expert model."""
+    required = lora_target_parameters(model_id)
+    if not required:
+        return
+
+    targets = config.get("target_parameters")
+    if not isinstance(targets, list):
+        raise ValueError(
+            f"adapter for {model_id} omits required expert targets; "
+            "target_parameters must be a list of strings"
+        )
+    if any(not isinstance(target, str) for target in targets):
+        raise ValueError(
+            f"adapter for {model_id} must declare target_parameters as a list of strings"
+        )
+    if len(targets) != len(set(targets)):
+        raise ValueError(f"adapter for {model_id} must declare unique target_parameters")
+    if set(targets) != set(required):
+        raise ValueError(
+            f"adapter for {model_id} must declare exactly the fused expert targets {required}"
+        )
+
+    rank_pattern = config.get("rank_pattern")
+    _validate_rank_pattern(rank_pattern, model_id)
+    declared = declared_lora_ranks(config)
+    unresolved = [target for target in required if _rank_for_module(target, declared) is None]
+    if unresolved:
+        raise ValueError(
+            f"adapter for {model_id} has no resolved LoRA rank for fused targets {unresolved}"
+        )
+
+    modules = config.get("target_modules")
+    if isinstance(modules, str):
+        if modules != "all-linear":
+            raise ValueError(f"adapter for {model_id} string target_modules must be 'all-linear'")
+        # all-linear names no modules, so only a default rank can resolve every ordinary target.
+        if declared.default is None:
+            raise ValueError(
+                f"adapter for {model_id} has no resolved default LoRA rank for 'all-linear' "
+                "target_modules"
+            )
+        return
+    if (
+        not isinstance(modules, list)
+        or not modules
+        or any(not isinstance(module, str) or not module for module in modules)
+    ):
+        raise ValueError(
+            f"adapter for {model_id} target_modules must be 'all-linear' or a non-empty "
+            "list of non-empty strings"
+        )
+    synthetic = [module for module in modules if _targets_fused_expert_wrapper(module)]
+    if synthetic:
+        raise ValueError(
+            f"adapter for {model_id} contains invalid synthetic target_modules {sorted(synthetic)}"
+        )
+    unresolved = [module for module in modules if _rank_for_module(module, declared) is None]
+    if unresolved:
+        raise ValueError(
+            f"adapter for {model_id} has no resolved LoRA rank for ordinary target_modules "
+            f"{unresolved}"
+        )
+
+
+def _validate_rank_pattern(rank_pattern: Any, model_id: str) -> None:
+    """Validate positive ranks and PEFT's anchored regex pattern syntax."""
+    message = (
+        f"adapter for {model_id} rank_pattern must map valid non-empty string patterns "
+        "to positive integer ranks"
+    )
+    if rank_pattern is None:
+        return
+    if not isinstance(rank_pattern, Mapping):
+        raise ValueError(message)
+    for pattern, rank in rank_pattern.items():
+        if (
+            not isinstance(pattern, str)
+            or not pattern.strip()
+            or not isinstance(rank, int)
+            or isinstance(rank, bool)
+            or rank <= 0
+        ):
+            raise ValueError(message)
+        try:
+            re.compile(rf"(.*\.)?({pattern})$")
+        except re.error as exc:
+            raise ValueError(message) from exc
+
+
+def _targets_fused_expert_wrapper(module: str) -> bool:
+    """Return whether PEFT suffix matching binds this target to an expert wrapper."""
+    return any(
+        module == wrapper or module.endswith(f".{wrapper}") or wrapper.endswith(f".{module}")
+        for wrapper in _FUSED_EXPERT_WRAPPER_MODULES
+    )
+
+
+def normalize_verl_fused_expert_export(config: dict[str, Any], model_id: str) -> None:
+    """Write the canonical fused targets into a verl-exported adapter config."""
+    targets = lora_target_parameters(model_id)
+    if not targets:
+        return
+    config["target_parameters"] = targets
+    modules = config.get("target_modules")
+    if modules is None:
+        raise ValueError(
+            f"exported adapter for {model_id} must retain ordinary LoRA target_modules"
+        )
+    if isinstance(modules, list):
+        config["target_modules"] = [
+            module
+            for module in modules
+            if not isinstance(module, str) or module not in _FUSED_EXPERT_SYNTHETIC_MODULES
+        ]
+
+
+def has_complete_fused_expert_tensors(
+    tensors: Mapping[str, tuple[int, ...]], config: Mapping[str, Any], model_id: str
+) -> bool:
+    """Return whether fused and ordinary LoRA tensors match the declared PEFT topology."""
+    expected = _expected_fused_expert_rungs(config, model_id)
+    if expected is None:
+        return False
+    parsed = [
+        tensor
+        for key, shape in tensors.items()
+        if (tensor := _parse_lora_tensor(key, shape)) is not None
+    ]
+    if len({adapter_name for _, _, adapter_name, _, _ in parsed}) != 1:
+        return False
+    return _has_complete_fused_rungs(parsed, expected, model_id) and _has_ordinary_evidence(
+        parsed, config, expected
+    )
+
+
+def _parse_lora_tensor(key: str, shape: tuple[int, ...]) -> _LoraTensor | None:
+    """Parse one canonical PEFT LoRA tensor key."""
+    matches = [
+        (factor, infix) for factor, infix in (("A", ".lora_A."), ("B", ".lora_B.")) if infix in key
+    ]
+    if len(matches) != 1:
+        return None
+    factor, infix = matches[0]
+    module_path, _, leaf = key.partition(infix)
+    leaf_parts = leaf.split(".")
+    if not module_path or len(leaf_parts) != 2:
+        return None
+    adapter_name, parameter = leaf_parts
+    if not adapter_name or parameter != "weight":
+        return None
+    return module_path, factor, adapter_name, key, shape
+
+
+def _expected_fused_expert_rungs(
+    config: Mapping[str, Any], model_id: str
+) -> dict[str, dict[str, _LoraPair]] | None:
+    """Return the exact target-specific PEFT rung geometry for each fused owner."""
+    targets = lora_target_parameters(model_id)
+    if model_id != _QWEN36_MODEL_ID or not targets:
+        return None
+    model = get_model(model_id)
+    experts = model.lora_expert_count
+    if experts <= 0 or model.num_layers <= 0:
+        return None
+    fused_count = model.num_layers * experts
+    catalog_dimensions = Counter(
+        (input_dim, output_dim)
+        for input_dim, output_dim, count in model.lora_target_shapes
+        if count == fused_count
+    )
+    if catalog_dimensions != Counter(_QWEN36_FUSED_TARGET_DIMENSIONS.values()):
+        return None
+
+    declared = declared_lora_ranks(config)
+    expected: dict[str, dict[str, _LoraPair]] = {}
+    for target in targets:
+        rank = _rank_for_module(target, declared)
+        dimensions = _QWEN36_FUSED_TARGET_DIMENSIONS.get(target)
+        rung = _QWEN36_FUSED_TARGET_RUNGS.get(target)
+        owner, separator, _ = target.rpartition(".")
+        if rank is None or dimensions is None or rung is None or not separator or not owner:
+            return None
+        input_dim, output_dim = dimensions
+        stacked_rank = rank * experts
+        expected.setdefault(owner, {})[rung] = (
+            (stacked_rank, input_dim),
+            (output_dim, stacked_rank),
+        )
+    return expected
+
+
+def _has_complete_fused_rungs(
+    tensors: list[_LoraTensor], expected: Mapping[str, Mapping[str, _LoraPair]], model_id: str
+) -> bool:
+    """Validate every concrete fused owner, rung, namespace, and factor shape."""
+    model = get_model(model_id)
+    for owner, expected_rungs in expected.items():
+        factors: dict[str, dict[str, dict[str, dict[str, tuple[int, ...]]]]] = {}
+        for module_path, factor, adapter_name, _key, shape in tensors:
+            location = _fused_tensor_location(module_path, owner, frozenset(expected_rungs))
+            if location is _INVALID_FUSED_LOCATION:
+                return False
+            if location is None:
+                continue
+            instance, rung = location
+            factors.setdefault(instance, {}).setdefault(rung, {}).setdefault(adapter_name, {})[
+                factor
+            ] = shape
+        if not factors:
+            return False
+        for seen_rungs in factors.values():
+            if set(seen_rungs) != set(expected_rungs):
+                return False
+            for rung, expected_pair in expected_rungs.items():
+                namespaces = seen_rungs[rung]
+                if len(namespaces) != 1:
+                    return False
+                seen_factors = next(iter(namespaces.values()))
+                if _lora_pair_shapes(seen_factors) != expected_pair:
+                    return False
+        expert_layers = {
+            prefix
+            for instance in factors
+            for prefix in [_layer_prefix(instance)]
+            if prefix is not None
+        }
+        layer_roots = {prefix.rsplit(".", 1)[0] for prefix in expert_layers}
+        if len(layer_roots) != 1:
+            return False
+        layer_root = next(iter(layer_roots))
+        expected_layers = {f"{layer_root}.{index}" for index in range(model.num_layers)}
+        if expert_layers != expected_layers:
+            return False
+    return True
+
+
+def _fused_tensor_location(
+    module_path: str, owner: str, rungs: frozenset[str]
+) -> tuple[str, str] | object | None:
+    """Locate one tensor on an exact concrete fused owner rung."""
+    if module_path.endswith(f".{owner}"):
+        instance, rung = module_path[: -len(owner) - 1], ""
+    else:
+        marker = f".{owner}."
+        if marker not in module_path:
+            return None
+        instance, rung = module_path.rsplit(marker, 1)
+    if rung not in rungs:
+        return _INVALID_FUSED_LOCATION
+    layer_prefix = _layer_prefix(instance)
+    if layer_prefix is None or instance != layer_prefix:
+        return _INVALID_FUSED_LOCATION
+    return f"{instance}.{owner}", rung
+
+
+def _has_ordinary_evidence(
+    tensors: list[_LoraTensor],
+    config: Mapping[str, Any],
+    fused_rungs: Mapping[str, Mapping[str, _LoraPair]],
+) -> bool:
+    """Validate concrete ordinary target evidence with per-module ranks and namespaces."""
+    modules = config.get("target_modules")
+    all_linear = modules == "all-linear"
+    targets = () if all_linear else tuple(modules) if isinstance(modules, list) else ()
+    groups: dict[str, dict[str, dict[str, tuple[str, tuple[int, ...]]]]] = {}
+    evidence: set[str] = set()
+    for module_path, factor, adapter_name, key, shape in tensors:
+        if _is_fused_rung(module_path, fused_rungs):
+            continue
+        matched = tuple(target for target in targets if _anchored_suffix_match(module_path, target))
+        if not all_linear and not matched:
+            continue
+        evidence.update(matched)
+        groups.setdefault(module_path, {}).setdefault(adapter_name, {})[factor] = (key, shape)
+    if not groups or (not all_linear and evidence != set(targets)):
+        return False
+
+    declared = declared_lora_ranks(config)
+    for module_path, namespaces in groups.items():
+        if len(namespaces) != 1 or _rank_for_module(module_path, declared) is None:
+            return False
+        factors = next(iter(namespaces.values()))
+        if set(factors) != {"A", "B"}:
+            return False
+        for key, shape in factors.values():
+            if not _is_positive_2d(shape) or lora_tensor_rank_disagrees(key, shape, declared):
+                return False
+    return True
+
+
+def _is_fused_rung(module_path: str, fused_rungs: Mapping[str, Mapping[str, _LoraPair]]) -> bool:
+    """Return whether a module path is one of the exact fused wrapper rungs."""
+    return any(
+        _fused_tensor_location(module_path, owner, frozenset(rungs))
+        not in (None, _INVALID_FUSED_LOCATION)
+        for owner, rungs in fused_rungs.items()
+    )
+
+
+def _anchored_suffix_match(module_path: str, target: str) -> bool:
+    """Mirror PEFT list-target matching without accepting partial segment suffixes."""
+    return module_path == target or module_path.endswith(f".{target}")
+
+
+def _is_positive_2d(shape: tuple[int, ...]) -> bool:
+    """Return whether a tensor shape is positive, integral, and two-dimensional."""
+    return len(shape) == 2 and all(
+        isinstance(dimension, int) and not isinstance(dimension, bool) and dimension > 0
+        for dimension in shape
+    )
+
+
+def _lora_pair_shapes(factors: Mapping[str, tuple[int, ...]]) -> _LoraPair | None:
+    """Return one complete positive 2-D A/B shape pair."""
+    if set(factors) != {"A", "B"}:
+        return None
+    shape_a = factors["A"]
+    shape_b = factors["B"]
+    if not _is_positive_2d(shape_a) or not _is_positive_2d(shape_b):
+        return None
+    return shape_a, shape_b
+
+
+def _layer_prefix(path: str) -> str | None:
+    """Return the concrete ``...layers.N`` prefix in a tensor path, if present."""
+    segments = path.split(".")
+    for index in range(len(segments) - 2, -1, -1):
+        if segments[index] == "layers" and segments[index + 1].isdigit():
+            return ".".join(segments[: index + 2])
+    return None

{freesolo_flash_dev-1.2.39 → freesolo_flash_dev-1.2.43}/flash/engine/worker/__init__.py

@@ -17,6 +17,7 @@ import time
 import traceback
 
 from flash._internal.diagnostics import sanitize_diagnostic
+from flash.adapters.fused_experts import lora_target_parameters
 from flash.core.spec import FIXED_SEED, load_job_spec_from_env
 from flash.engine.result.accounting import RunMetrics
 from flash.engine.worker.backend_common import collect_ray_failure_logs
@@ -56,9 +57,8 @@ from flash.engine.worker.io.wandb_log import (
 )
 from flash.engine.worker.model.adapter import (
     _download_adapter,
-    lora_target_parameters,
     make_lora,
-    validate_lora_target_parameters,
+    validate_warmstart_adapter,
 )
 from flash.engine.worker.model.decoding import (
     graded_text,
@@ -503,7 +503,7 @@ __all__ = [
     "think_token_count",
     "thinking_text",
     "upload_resume_checkpoint",
-    "validate_lora_target_parameters",
+    "validate_warmstart_adapter",
     "wait_for_gpu",
     "wandb_run_name",
     "write_base_model_provenance",

{freesolo_flash_dev-1.2.39 → freesolo_flash_dev-1.2.43}/flash/engine/worker/model/adapter.py

@@ -5,7 +5,14 @@ from __future__ import annotations
 import json
 import os
 import shutil
+from collections.abc import Mapping
+from typing import Any
 
+from flash.adapters.fused_experts import (
+    has_complete_fused_expert_tensors,
+    lora_target_parameters,
+    validate_fused_expert_adapter_config,
+)
 from flash.adapters.lora_rank import resolve_adapter_ref
 from flash.engine.plan.recipe import RECIPE
 from flash.engine.worker.io.hf import (
@@ -17,35 +24,23 @@ from flash.engine.worker.io.hf import (
 )
 from flash.engine.worker.model.lora import (
     _read_adapter_tensor_keys,
+    _read_adapter_tensor_metadata,
 )
 from flash.engine.worker.runtime.pkg_proxy import W as _w
 
 _ADAPTER_DOWNLOAD_RETRIES = 4
 _ADAPTER_DOWNLOAD_BACKOFF_S = 5.0
-_QWEN35_EXPERT_TARGET_PARAMETERS = (
-    "mlp.experts.gate_up_proj",
-    "mlp.experts.down_proj",
-)
-
-
-def lora_target_parameters(model_id: str | None) -> list[str] | None:
-    """return direct parameter targets required by the model's fused expert layout."""
-    if model_id == "Qwen/Qwen3.6-35B-A3B":
-        return list(_QWEN35_EXPERT_TARGET_PARAMETERS)
-    return None
 
 
-def validate_lora_target_parameters(config: dict, model_id: str) -> None:
-    """fail closed when a warm-start adapter omits required fused expert parameters."""
-    required = set(lora_target_parameters(model_id) or ())
-    if not required:
+def validate_warmstart_adapter(config: Mapping[str, Any], model_id: str, adapter_dir: str) -> None:
+    """Validate a downloaded warm-start adapter without changing its config or files."""
+    validate_fused_expert_adapter_config(config, model_id)
+    if not lora_target_parameters(model_id):
         return
-    actual = set(config.get("target_parameters") or ())
-    missing = sorted(required - actual)
-    if missing:
+    tensors = _read_adapter_tensor_metadata(adapter_dir) or {}
+    if not has_complete_fused_expert_tensors(tensors, config, model_id):
         raise ValueError(
-            f"warm-start adapter for {model_id} omits required expert targets {missing}; "
-            "retrain the source adapter with the current Flash version"
+            f"warm-start adapter for {model_id} does not contain complete fused expert LoRA weights"
         )
 
 

freesolo_flash_dev-1.2.43/flash/engine/worker/model/lora.py

@@ -0,0 +1,157 @@
+"""read adapter tensor metadata from a downloaded adapter directory.
+
+helpers must not import ``flash.engine.worker``. heavy dependencies remain lazy so this leaf
+module has no package cycle or eager gpu stack import.
+"""
+
+from __future__ import annotations
+
+# a safetensors header is small even for huge models (a few hundred kb at most); 100 mb is a wildly
+# generous ceiling that still refuses a corrupt or hostile file declaring a multi-gb header length
+# before safetensors parses it.
+_MAX_SAFETENSORS_HEADER_BYTES = 100 * 1024 * 1024
+
+
+def _read_adapter_tensor_metadata(adir: str) -> dict[str, tuple[int, ...]] | None:
+    """return the authoritative tensor name and shape map for the representation peft loads.
+
+    safetensors is validated through ``safe_open`` and ``get_slice`` without materializing tensor
+    payloads. torch ``.bin`` files use weights-only cpu loading because their format has no separate
+    metadata header. for sharded adapters, the index ``weight_map`` must agree exactly with every
+    selected shard header; no duplicate, missing, extra, or misrouted key is accepted.
+    """
+    import os
+
+    from flash.adapters.artifacts import loadable_adapter_weight_files
+
+    try:
+        selected = loadable_adapter_weight_files(os.listdir(adir))
+    except OSError:
+        return None
+    if not selected:
+        return None
+    weight_map = _read_sharded_weight_map(adir, selected)
+    tensors: dict[str, tuple[int, ...]] = {}
+    for name in selected:
+        path = os.path.join(adir, name)
+        shard_tensors = (
+            _read_safetensors_tensor_metadata(path)
+            if name.endswith(".safetensors")
+            else _read_bin_tensor_metadata(path)
+        )
+        duplicates = tensors.keys() & shard_tensors.keys()
+        if duplicates:
+            raise ValueError(
+                f"adapter shards contain duplicate tensor keys {sorted(duplicates)[:4]}"
+            )
+        if weight_map is not None:
+            misrouted = [key for key in shard_tensors if weight_map.get(key) != name]
+            if misrouted:
+                raise ValueError(
+                    f"adapter shard {name} disagrees with weight_map for keys {misrouted[:4]}"
+                )
+        tensors.update(shard_tensors)
+    if weight_map is not None and tensors.keys() != weight_map.keys():
+        missing = sorted(weight_map.keys() - tensors.keys())[:4]
+        extra = sorted(tensors.keys() - weight_map.keys())[:4]
+        raise ValueError(
+            f"adapter shard headers disagree with weight_map; missing={missing}, extra={extra}"
+        )
+    return tensors
+
+
+def _read_adapter_tensor_keys(adir: str) -> list[str] | None:
+    """return tensor key names from adapter weights without loading safetensors payloads."""
+    tensors = _read_adapter_tensor_metadata(adir)
+    return list(tensors) if tensors is not None else None
+
+
+def _read_sharded_weight_map(adir: str, selected: list[str]) -> dict[str, str] | None:
+    """return an authoritative sharded index map, or none for a selected single-file adapter."""
+    import json
+    import os
+
+    from flash._internal.fileio import reject_duplicate_keys
+    from flash.adapters.artifacts import ADAPTER_SHARD_PREFIX
+
+    if not selected[0].startswith(ADAPTER_SHARD_PREFIX):
+        return None
+    suffix = ".safetensors" if selected[0].endswith(".safetensors") else ".bin"
+    index_path = os.path.join(adir, f"adapter_model{suffix}.index.json")
+    duplicate_guard = reject_duplicate_keys(
+        lambda key: ValueError(f"{index_path}: duplicate JSON key {key!r}")
+    )
+    try:
+        with open(index_path, encoding="utf-8") as index_file:
+            index = json.load(index_file, object_pairs_hook=duplicate_guard)
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"{index_path}: unreadable adapter weight index") from exc
+    weight_map = index.get("weight_map") if isinstance(index, dict) else None
+    if not isinstance(weight_map, dict) or any(
+        not isinstance(key, str) or not key or not isinstance(shard, str) or not shard
+        for key, shard in weight_map.items()
+    ):
+        raise ValueError(f"{index_path}: weight_map must map non-empty tensor names to shard names")
+    selected_set = set(selected)
+    referenced = set(weight_map.values())
+    if referenced != selected_set:
+        raise ValueError(
+            f"{index_path}: weight_map shards {sorted(referenced)} do not match selected shards "
+            f"{sorted(selected_set)}"
+        )
+    return weight_map
+
+
+def _read_safetensors_tensor_metadata(st_path: str) -> dict[str, tuple[int, ...]]:
+    """return names and shapes after safetensors validates the complete file structure."""
+    import os
+    import struct
+
+    file_size = os.path.getsize(st_path)
+    with open(st_path, "rb") as tensor_file:
+        length_bytes = tensor_file.read(8)
+        if len(length_bytes) < 8:
+            raise ValueError(f"{st_path}: too small to be a safetensors file")
+        (header_length,) = struct.unpack("<Q", length_bytes)
+        if header_length > file_size - 8 or header_length > _MAX_SAFETENSORS_HEADER_BYTES:
+            raise ValueError(
+                f"{st_path}: declared safetensors header length {header_length} is implausible "
+                f"(file is {file_size} bytes)"
+            )
+
+    try:
+        from safetensors import safe_open
+
+        with safe_open(st_path, framework="numpy") as tensors:
+            metadata: dict[str, tuple[int, ...]] = {}
+            tensor_keys = tensors.keys()
+            for key in tensor_keys:
+                shape = tensors.get_slice(key).get_shape()
+                if not isinstance(shape, list) or any(
+                    not isinstance(dim, int) or isinstance(dim, bool) or dim < 0 for dim in shape
+                ):
+                    raise ValueError(f"invalid tensor shape for {key!r}")
+                metadata[key] = tuple(shape)
+            return metadata
+    except Exception as exc:
+        raise ValueError(f"{st_path}: invalid safetensors structure ({exc})") from exc
+
+
+def _read_bin_tensor_metadata(bin_path: str) -> dict[str, tuple[int, ...]]:
+    """return the tensor names and shapes in one torch ``.bin`` adapter state dict."""
+    import torch
+
+    state = torch.load(bin_path, map_location="cpu", weights_only=True)
+    if not isinstance(state, dict):
+        raise ValueError(f"{bin_path}: expected a tensor state dict, got {type(state).__name__}")
+    bad = [
+        key
+        for key, value in state.items()
+        if not isinstance(key, str) or not isinstance(value, torch.Tensor)
+    ]
+    if bad:
+        raise ValueError(
+            f"{bin_path}: contains non-tensor entries (e.g. {bad[:4]}); "
+            "expected a plain PEFT adapter state dict"
+        )
+    return {key: tuple(tensor.shape) for key, tensor in state.items()}

{freesolo_flash_dev-1.2.39 → freesolo_flash_dev-1.2.43}/flash/engine/worker/sft_train.py

@@ -14,6 +14,7 @@ import sys
 import threading
 import time
 
+from flash.adapters.lora_rank import rank_from_adapter_config
 from flash.engine.worker.runtime.pkg_proxy import W as _w
 from flash.engine.worker.verl.checkpoints import resume_checkpoint_is_loadable
 from flash.engine.worker.verl.parallelism import ULYSSES_SEQUENCE_PARALLEL_SIZE
@@ -61,13 +62,13 @@ def _warmstart_adapter_path(model_id: str, model_revision: str, expected_rank: i
         raise RuntimeError("the prepared SFT warm-start adapter could not be downloaded")
     with open(os.path.join(adapter_dir, "adapter_config.json"), encoding="utf-8") as file:
         config = json.load(file)
-    rank = int(config.get("r") or 0)
+    rank = rank_from_adapter_config(config, source=os.path.join(adapter_dir, "adapter_config.json"))
     if rank != expected_rank:
         raise ValueError(
             f"SFT warm-start adapter rank {rank} does not match the prepared train.lora_rank "
             f"{expected_rank}; rank changes are not supported"
         )
-    _w.validate_lora_target_parameters(config, model_id)
+    _w.validate_warmstart_adapter(config, model_id, adapter_dir)
     base = str(config.get("base_model_name_or_path") or "").strip()
     if base and base != model_id:
         raise ValueError("SFT warm-start adapter base model does not match the target model")

{freesolo_flash_dev-1.2.39 → freesolo_flash_dev-1.2.43}/flash/engine/worker/train/rl/inputs.py

@@ -172,7 +172,7 @@ def _resolve_grpo_options(train_spec, rl, multi_turn):
 def _resolve_warmstart_config(train_spec, model_id, adapter_path, lora_rank, lora_alpha):
     with open(os.path.join(adapter_path, "adapter_config.json")) as f:
         source_config = json.load(f)
-    _w.validate_lora_target_parameters(source_config, model_id)
+    _w.validate_warmstart_adapter(source_config, model_id, adapter_path)
     # a patterned adapter trains some modules at higher rank than the base `r`; verl allocates
     # one uniform rank, so it must cover the MAXIMUM prepared rank or the load truncates.
     ranks = [int(source_config.get("r", lora_rank))]