| """Force the lalamo attention implementation when the GPU cannot run Pallas. |
| |
| lalamo's inference config defaults to the Pallas-Triton flash attention kernel |
| (``MixerForwardPassConfig.for_inference``). Pallas-Triton needs a Triton backend |
| that T4 (compute capability 7.5) does not provide, so the first forward fails |
| during XLA compilation even with ``--xla_gpu_enable_triton_gemm=false``. |
| |
| ``UZU_ATTENTION_IMPL=xla`` switches the mixer config to the plain XLA path. |
| ``pallas`` forces the default back. Anything else (including unset) keeps the |
| config as-is. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import os |
| import subprocess |
|
|
| ENV_VAR = "UZU_ATTENTION_IMPL" |
| |
| |
| |
| BF16_MIN_CAPABILITY = 8.0 |
|
|
|
|
| def gpu_capabilities() -> list[float]: |
| """Return the compute capability of every visible GPU (empty off-GPU).""" |
| try: |
| result = subprocess.run( |
| ["nvidia-smi", "--query-gpu=compute_cap", "--format=csv,noheader"], |
| text=True, |
| capture_output=True, |
| check=False, |
| timeout=20, |
| ) |
| except (OSError, subprocess.TimeoutExpired): |
| return [] |
| caps = [] |
| if result.returncode != 0: |
| return caps |
| for line in (result.stdout or "").splitlines(): |
| try: |
| caps.append(float(line.strip())) |
| except ValueError: |
| continue |
| return caps |
|
|
|
|
| def bf16_block_reason(dtype: str, capabilities: list[float]) -> str | None: |
| """Return why this dtype cannot run here, or None when it can.""" |
| if dtype != "bfloat16" or not capabilities: |
| return None |
| old = [capability for capability in capabilities if capability < BF16_MIN_CAPABILITY] |
| if not old: |
| return None |
| return ( |
| f"GPU compute capability {old[0]:.1f} has no BF16 matmul " |
| "(ALG_DOT_BF16_BF16_F32 is unimplemented); use float32. " |
| "UZU_ATTENTION_IMPL=xla does not help: it only avoids Pallas-Triton." |
| ) |
|
|
|
|
|
|
| def enter_mesh(sharding): |
| """Activate the sharding mesh for the rest of the process. |
| |
| With ``--parallel tensor`` the mesh has 2 devices, and any ``jax.jit`` |
| launched outside a mesh context fails with "Length of device assignment 1 |
| is not equal to the size of the mesh 2; enter your jit into a mesh context |
| via jax.set_mesh". A single-device mesh never raises, which is why CPU |
| lanes never showed this. |
| """ |
| mesh = getattr(sharding, "mesh", None) |
| if mesh is None or getattr(mesh, "empty", False): |
| return None |
| import jax |
|
|
| manager = jax.set_mesh(mesh) |
| manager.__enter__() |
| return manager |
|
|
|
|
| def requested() -> str | None: |
| """Explicit env wins; otherwise pick xla automatically on pre-Ampere. |
| |
| Pallas-Triton needs cc >= 8.0. Scripts that do not go through run_lane |
| (Modal jobs, make_qad_dataset -> yaqa_calibration) used to fall back to |
| Pallas and die at the first forward, so the device decides for them. |
| """ |
| value = os.environ.get(ENV_VAR, "").strip().lower() |
| if value in ("xla", "pallas"): |
| return value |
| capabilities = gpu_capabilities() |
| if any(capability < BF16_MIN_CAPABILITY for capability in capabilities): |
| return "xla" |
| return None |
|
|
|
|
| def force_float32_activations(config): |
| """Use f32 activations on GPUs without BF16 tensor cores. |
| |
| ``Model.load(..., dtype=float32)`` only fixes the weights: the embedding |
| forward config still defaults to ``activation_dtype=bfloat16``, so the |
| residual stream (and therefore attention's q/k/v) stays bf16 and the dot |
| lowers to ALG_DOT_BF16_BF16_F32, which Turing does not implement. |
| """ |
| capabilities = gpu_capabilities() |
| if not capabilities or not any(capability < BF16_MIN_CAPABILITY for capability in capabilities): |
| return config |
|
|
| from dataclasses import replace |
|
|
| import jax.numpy as jnp |
|
|
| embedding = config.embedding_forward_pass_config |
| if embedding.activation_dtype == jnp.float32: |
| return config |
| return replace( |
| config, |
| embedding_forward_pass_config=replace(embedding, activation_dtype=jnp.float32), |
| ) |
|
|
|
|
| def apply_attention_env(config): |
| """Return config with the attention implementation overridden, if requested.""" |
| mode = requested() |
| if mode is None: |
| return config |
|
|
| from dataclasses import replace |
|
|
| from lalamo.modules import AttentionImplementation |
|
|
| target = AttentionImplementation.XLA if mode == "xla" else AttentionImplementation.PALLAS |
| transformer = config.transformer_forward_pass_config |
| mixer = transformer.mixer_forward_pass_config |
| if getattr(mixer, "attention_implementation", None) == target: |
| return config |
| return replace( |
| config, |
| transformer_forward_pass_config=replace( |
| transformer, |
| mixer_forward_pass_config=replace(mixer, attention_implementation=target), |
| ), |
| ) |
|
|
|
|
| def describe() -> str: |
| mode = requested() |
| return f"attention={mode or 'default'}" |
|
|
