File size: 8,315 Bytes
211f0bb | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 | """Optional chalk GPU kernels (the ``freesolo-chalk`` package).
Chalk holds Freesolo's hand-written Triton/CUDA kernels that complement Liger
(fused GEMMs, the LoRA-delta matmuls, the QKV norm+RoPE epilogue, embedding gather,
FP8 frozen-base GEMMs).
Chalk follows the **install-on-call** model (mirroring Liger's
``apply_liger_kernel_to_qwen3``): chalk reads NO env vars — *calling* an installer IS
the opt-in. Each installer then arch-gates itself, runs a numeric self-test on install,
patches only frozen ``nn.Linear`` layers, and silently falls back to the eager / Liger
path (a no-op on CPU / the control plane) on any failure.
Because chalk no longer gates itself, the FLASH WORKER must decide *which* installers to
call. :func:`install_chalk_kernels` reads per-kernel ``FLASH_*`` selection flags (set by
the operator, forwarded to the worker by ``providers.runpod.train.build_worker_env``) and
calls ONLY the selected chalk installers. With NO flags set (the default) it calls
nothing, so it is always safe to invoke; and if ``freesolo-chalk`` isn't installed at all
(e.g. on the control plane, or a worker without a chalk spec) the whole module degrades to
a no-op.
"""
from __future__ import annotations
import os
from flash._logging import get_logger
log = get_logger(__name__)
def _truthy(name: str) -> bool:
"""A FLASH_* flag counts as ON when set to a non-empty, non-false value."""
v = os.environ.get(name)
return v is not None and v.strip().lower() not in ("", "0", "false", "no", "off")
def _int_env(name: str, default: int) -> int:
raw = os.environ.get(name)
if raw is None or not raw.strip():
return default
try:
return int(raw.strip())
except ValueError:
log.warning("ignoring non-integer %s=%r (using %d)", name, raw, default)
return default
def _selected_installers() -> list[tuple[str, bool, dict]]:
"""The chalk installers the operator selected via ``FLASH_*`` flags.
Returns ``(installer_name, needs_model, kwargs)`` for each ENABLED kernel. ``needs_model``
marks the instance-level installers (they patch the materialized ``nn.Module`` and must be
skipped when no model is available yet); the class/function-level ones install with no model.
Default (no flags set) is an empty list -> :func:`install_chalk_kernels` calls nothing.
"""
selected: list[tuple[str, bool, dict]] = []
# Class/function-level kernels (patch the model class / a global fn; no model arg needed).
# chalk signatures: install_qwen35_mlp(model=None), install_qwen35_qkv(model=None),
# install_lora() [no model param], install_qwen35_rope() [no model param].
if _truthy("FLASH_MLP_KERNEL"):
selected.append(("install_qwen35_mlp", False, {}))
if _truthy("FLASH_QKV_KERNEL"):
selected.append(("install_qwen35_qkv", False, {}))
if _truthy("FLASH_TRITON_LORA"):
selected.append(("install_lora", False, {}))
if _truthy("FLASH_ROPE_KERNEL"):
selected.append(("install_qwen35_rope", False, {}))
# Instance-level kernels (need the built nn.Module).
# chalk signatures: install_qwen35_mlp_fp8(model, *, down=True),
# install_fp8_base(model, *, attn=True, mlp=True, min_k=256),
# install_qwen35_embedding(model).
if _truthy("FLASH_MLP_FP8"):
# FLASH_MLP_FP8_DOWN selects whether the down-projection is fused too (chalk default True).
down = os.environ.get("FLASH_MLP_FP8_DOWN")
kwargs = {} if down is None else {"down": _truthy("FLASH_MLP_FP8_DOWN")}
selected.append(("install_qwen35_mlp_fp8", True, kwargs))
if _truthy("FLASH_FP8_BASE"):
# Per-kernel scope knobs mirror chalk's install_fp8_base kwargs; only forward the ones the
# operator set so chalk's own defaults (attn=True, mlp=True, min_k=256) apply otherwise.
kwargs = {}
if os.environ.get("FLASH_FP8_BASE_ATTN") is not None:
kwargs["attn"] = _truthy("FLASH_FP8_BASE_ATTN")
if os.environ.get("FLASH_FP8_BASE_MLP") is not None:
kwargs["mlp"] = _truthy("FLASH_FP8_BASE_MLP")
if os.environ.get("FLASH_FP8_BASE_MIN_K") is not None:
kwargs["min_k"] = _int_env("FLASH_FP8_BASE_MIN_K", 256)
selected.append(("install_fp8_base", True, kwargs))
if _truthy("FLASH_EMBED_KERNEL"):
selected.append(("install_qwen35_embedding", True, {}))
return selected
def install_chalk_kernels(model=None) -> dict:
"""Install the chalk kernels the operator selected via ``FLASH_*`` flags.
chalk reads NO env vars (install-on-call), so the WORKER decides which installers to call:
each enabled ``FLASH_*`` flag maps to one chalk installer (see :func:`_selected_installers`).
With no flags set this calls nothing and returns ``{}``.
Call this TWICE per training run — exactly the two passes the worker makes — and each kernel
installs on the ONE pass it belongs to (never twice):
* ``install_chalk_kernels()`` (``model is None``, the PRE-build pass) installs only the
class/function-level kernels (LoRA delta, fused MLP/QKV, RoPE) — global monkeypatches that
must be in place before the trainer builds the model. Instance-level kernels are skipped (no
module yet).
* ``install_chalk_kernels(trainer.model)`` (``model is not None``, the POST-build pass) installs
only the instance-level kernels (FP8 base, embedding, FP8 MLP) against the materialized
module. The class/function-level monkeypatches were already applied on the pre-build pass, so
re-running them here would double-patch — they are deliberately NOT re-run.
Returns a ``{installer_name: result}`` map for the installers that ran ON THIS PASS (``{}`` when
no flag is set, chalk isn't installed, or no selected kernel belongs to this pass).
"""
selected = _selected_installers()
if not selected:
# No FLASH_* kernel flag set -> the operator opted into nothing. Don't even import chalk.
return {}
try:
import chalk.transformers as ck
except ImportError:
# A FLASH_* flag is set but chalk isn't installed (control plane, or a worker without a
# chalk spec in FLASH_CHALK_SPEC/extra_pip). Documented as always safe — warn and no-op.
log.warning(
"FLASH_* chalk kernel(s) requested but freesolo-chalk is not installed "
"(set FLASH_CHALK_SPEC to an installable spec on the worker); skipping."
)
return {}
except Exception as e:
# A partially-installed / version-incompatible chalk can raise non-ImportError errors at
# import time (e.g. a Triton/torch mismatch surfaced on import of a kernel module). This
# hook is documented as always safe and must never abort training, so degrade to a no-op.
log.warning("chalk import failed (ignored, kernels disabled): %s", e)
return {}
results: dict[str, object] = {}
for name, needs_model, kwargs in selected:
# Each kernel installs on exactly ONE of the two passes, so the second call never
# re-applies what the first already installed:
# * class/function-level (needs_model=False): global monkeypatches -> PRE-build pass only
# (model is None). Skipping them when a model is present avoids re-installing the global
# patch the pre-build call already applied (double-patch).
# * instance-level (needs_model=True): patch the built nn.Module -> POST-build pass only
# (model is not None); there is no module to patch on the pre-build pass.
if needs_model != (model is not None):
continue
fn = getattr(ck, name, None)
if fn is None:
log.warning("chalk has no installer %s (skipping)", name)
continue
try:
results[name] = fn(model, **kwargs) if needs_model else fn(**kwargs)
except Exception as e: # never block training on an optional kernel
log.warning("chalk %s failed (ignored): %s", name, e)
results[name] = f"error: {e}"
enabled = {k: v for k, v in results.items() if v not in (False, None) and not str(v).startswith("error")}
if enabled:
log.info("chalk kernels active: %s", ", ".join(enabled))
return results
|