Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

22.9 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

"""Export loads must shard across GPUs; sequential device_map stacks everything on GPU0 and OOMs."""

from __future__ import annotations

import contextlib
import sys
import types
from pathlib import Path

import pytest

_BACKEND_DIR = Path(__file__).resolve().parent.parent
if str(_BACKEND_DIR) not in sys.path:
    sys.path.insert(0, str(_BACKEND_DIR))
_TESTS_DIR = Path(__file__).resolve().parent
if str(_TESTS_DIR) not in sys.path:
    sys.path.insert(0, str(_TESTS_DIR))

from test_export_absolute_paths import (  # noqa: E402
    _install_export_backend_stubs,
    _load_module,
)


def _export_mod(monkeypatch):
    _install_export_backend_stubs(monkeypatch)
    return _load_module("test_core_export_backend_device_map", "core/export/export.py", monkeypatch)


def _stub_hardware(monkeypatch, visible, device_map):
    hw = sys.modules["utils.hardware"]
    monkeypatch.setattr(hw, "get_parent_visible_gpu_ids", lambda: visible, raising = False)
    monkeypatch.setattr(hw, "get_device_map", lambda ids: device_map, raising = False)


def test_multi_gpu_host_gets_balanced(monkeypatch):
    mod = _export_mod(monkeypatch)
    monkeypatch.setattr(mod, "_IS_MLX", False)
    _stub_hardware(monkeypatch, [0, 1, 2], "balanced")
    assert mod._multi_gpu_device_map_kwargs() == {"device_map": "balanced"}


def test_multi_gpu_cuda_host_passes_the_unsloth_planner_through(monkeypatch):
    """CUDA multi-GPU now resolves to "unsloth". A whitelist of just "balanced"
    dropped the map and left the export on the loader default, which is the
    single-GPU stacking this file exists to prevent."""
    mod = _export_mod(monkeypatch)
    monkeypatch.setattr(mod, "_IS_MLX", False)
    _stub_hardware(monkeypatch, [0, 1, 2], "unsloth_balanced")
    assert mod._multi_gpu_device_map_kwargs() == {"device_map": "unsloth_balanced"}


def test_single_gpu_host_keeps_loader_default(monkeypatch):
    mod = _export_mod(monkeypatch)
    monkeypatch.setattr(mod, "_IS_MLX", False)
    _stub_hardware(monkeypatch, [0], "sequential")
    assert mod._multi_gpu_device_map_kwargs() == {}


def test_non_balanced_resolution_keeps_loader_default(monkeypatch):
    mod = _export_mod(monkeypatch)
    monkeypatch.setattr(mod, "_IS_MLX", False)
    _stub_hardware(monkeypatch, [0, 1], "sequential")
    assert mod._multi_gpu_device_map_kwargs() == {}


def test_uuid_mig_mask_falls_back_to_count_detection(monkeypatch):
    # UUID/MIG masks resolve to no numeric ids, but get_device_map(None) still sees >1 GPU
    mod = _export_mod(monkeypatch)
    monkeypatch.setattr(mod, "_IS_MLX", False)
    hw = sys.modules["utils.hardware"]
    monkeypatch.setattr(hw, "get_parent_visible_gpu_ids", lambda: [], raising = False)
    monkeypatch.setattr(
        hw,
        "get_device_map",
        lambda ids: "balanced" if ids is None else "sequential",
        raising = False,
    )
    assert mod._multi_gpu_device_map_kwargs() == {"device_map": "balanced"}


def test_no_visible_gpus_keeps_loader_default(monkeypatch):
    mod = _export_mod(monkeypatch)
    monkeypatch.setattr(mod, "_IS_MLX", False)
    hw = sys.modules["utils.hardware"]
    monkeypatch.setattr(hw, "get_parent_visible_gpu_ids", lambda: [], raising = False)
    monkeypatch.setattr(hw, "get_device_map", lambda ids: "sequential", raising = False)
    assert mod._multi_gpu_device_map_kwargs() == {}


def test_mlx_host_keeps_loader_default(monkeypatch):
    mod = _export_mod(monkeypatch)
    _stub_hardware(monkeypatch, [0, 1], "balanced")
    assert mod._multi_gpu_device_map_kwargs() == {}


def test_hardware_probe_failure_keeps_loader_default(monkeypatch):
    mod = _export_mod(monkeypatch)
    monkeypatch.setattr(mod, "_IS_MLX", False)
    hw = sys.modules["utils.hardware"]

    def _boom():
        raise RuntimeError("no GPUs")

    monkeypatch.setattr(hw, "get_parent_visible_gpu_ids", _boom, raising = False)
    assert mod._multi_gpu_device_map_kwargs() == {}


class _RecordingLoader:
    calls: list[dict] = []

    @classmethod
    def from_pretrained(cls, **kwargs):
        cls.calls.append(kwargs)
        return types.SimpleNamespace(), types.SimpleNamespace()


def _load_text_checkpoint(monkeypatch, tmp_path, device_map_kwargs):
    mod = _export_mod(monkeypatch)
    _RecordingLoader.calls = []
    monkeypatch.setattr(mod, "FastLanguageModel", _RecordingLoader)
    monkeypatch.setattr(mod, "detect_audio_type", lambda *a, **k: None)
    monkeypatch.setattr(mod, "is_vision_model", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_hf_offline", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_offline_window_if", lambda flag: contextlib.nullcontext())
    monkeypatch.setattr(mod, "_multi_gpu_device_map_kwargs", lambda: device_map_kwargs)

    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    backend = mod.ExportBackend.__new__(mod.ExportBackend)
    backend.cleanup_memory = lambda: None
    ok, message = backend.load_checkpoint(str(checkpoint))
    assert ok, message
    assert len(_RecordingLoader.calls) == 1
    return _RecordingLoader.calls[0]


def test_load_checkpoint_forwards_balanced_device_map(monkeypatch, tmp_path):
    kwargs = _load_text_checkpoint(monkeypatch, tmp_path, {"device_map": "balanced"})
    assert kwargs["device_map"] == "balanced"


def test_load_checkpoint_omits_device_map_on_single_gpu(monkeypatch, tmp_path):
    kwargs = _load_text_checkpoint(monkeypatch, tmp_path, {})
    assert "device_map" not in kwargs


def _offload_backend(
    monkeypatch,
    loader,
    device_map_kwargs = None,
):
    mod = _export_mod(monkeypatch)
    monkeypatch.setattr(mod, "FastLanguageModel", loader)
    monkeypatch.setattr(mod, "detect_audio_type", lambda *a, **k: None)
    monkeypatch.setattr(mod, "is_vision_model", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_hf_offline", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_offline_window_if", lambda flag: contextlib.nullcontext())
    monkeypatch.setattr(mod, "_multi_gpu_device_map_kwargs", lambda: device_map_kwargs or {})
    backend = mod.ExportBackend.__new__(mod.ExportBackend)
    backend.cleanup_memory = lambda: None
    return mod, backend


def _unsloth_spill_error():
    try:
        raise ValueError(
            "Some modules are dispatched on the CPU or the disk. Make sure you have enough GPU RAM."
        )
    except ValueError as original:
        try:
            raise ValueError(
                "Unsloth: unsloth/gemma-4-E2B-it-unsloth-bnb-4bit does not fit in GPU memory "
                "(cuda:0 has 6.84 GB free), so transformers placed part of it on the CPU, "
                "which bitsandbytes cannot quantize."
            ) from original
        except ValueError as rewritten:
            return rewritten


class _SpillUnlessOffloaded:
    calls: list[dict] = []

    @classmethod
    def from_pretrained(cls, **kwargs):
        cls.calls.append(kwargs)
        if "offload_layers" not in kwargs:
            raise _unsloth_spill_error()
        return types.SimpleNamespace(), types.SimpleNamespace()


def test_load_that_fits_passes_no_offload_layers(monkeypatch, tmp_path):
    kwargs = _load_text_checkpoint(monkeypatch, tmp_path, {})
    assert "offload_layers" not in kwargs
    assert "device_map_planner_kwargs" not in kwargs


def test_is_cpu_spill_rejection_sees_through_unsloths_rewrite(monkeypatch):
    mod = _export_mod(monkeypatch)
    assert mod._is_cpu_spill_rejection(_unsloth_spill_error())
    assert not mod._is_cpu_spill_rejection(ValueError("does not fit"))


def test_single_gpu_spill_retries_with_auto_offload(monkeypatch, tmp_path):
    """#13696: the 4-bit export load spills to the CPU on an 8 GB card; retry streaming layers from host RAM."""
    _SpillUnlessOffloaded.calls = []
    mod, backend = _offload_backend(monkeypatch, _SpillUnlessOffloaded)
    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    ok, message = backend.load_checkpoint(str(checkpoint))
    assert ok, message
    calls = _SpillUnlessOffloaded.calls
    assert len(calls) == 2
    assert "offload_layers" not in calls[0]
    assert calls[1]["offload_layers"] == "auto"
    assert "device_map" not in calls[1]
    assert calls[1]["device_map_planner_kwargs"]["reserve_bytes"] == 1 << 30


def test_offload_retry_runs_once(monkeypatch, tmp_path):
    class _AlwaysSpills:
        calls: list[dict] = []

        @classmethod
        def from_pretrained(cls, **kwargs):
            cls.calls.append(kwargs)
            raise _unsloth_spill_error()

    mod, backend = _offload_backend(monkeypatch, _AlwaysSpills)
    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    ok, message = backend.load_checkpoint(str(checkpoint))
    assert not ok
    assert "does not fit in GPU memory" in message
    assert len(_AlwaysSpills.calls) == 2


def test_offload_layers_zero_disables_the_retry(monkeypatch, tmp_path):
    _SpillUnlessOffloaded.calls = []
    mod, backend = _offload_backend(monkeypatch, _SpillUnlessOffloaded)
    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    ok, message = backend.load_checkpoint(str(checkpoint), offload_layers = 0)
    assert not ok
    assert len(_SpillUnlessOffloaded.calls) == 1


def test_load_checkpoint_forwards_explicit_offload_layers(monkeypatch, tmp_path):
    _RecordingLoader.calls = []
    mod, backend = _offload_backend(monkeypatch, _RecordingLoader)
    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    ok, message = backend.load_checkpoint(str(checkpoint), offload_layers = 8)
    assert ok, message
    assert _RecordingLoader.calls[0]["offload_layers"] == 8


def test_load_checkpoint_omits_fixed_offload_on_balanced_map(monkeypatch, tmp_path):
    _RecordingLoader.calls = []
    mod, backend = _offload_backend(monkeypatch, _RecordingLoader, {"device_map": "balanced"})
    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    ok, message = backend.load_checkpoint(str(checkpoint), offload_layers = 8)
    assert ok, message
    assert "offload_layers" not in _RecordingLoader.calls[0]
    assert _RecordingLoader.calls[0]["device_map"] == "balanced"


def test_whisper_checkpoint_loads_with_its_processor_like_training(monkeypatch, tmp_path):
    mod = _export_mod(monkeypatch)
    _RecordingLoader.calls = []
    monkeypatch.setattr(sys.modules["unsloth"], "FastModel", _RecordingLoader, raising = False)
    transformers = types.ModuleType("transformers")
    transformers.WhisperForConditionalGeneration = object
    monkeypatch.setitem(sys.modules, "transformers", transformers)
    monkeypatch.setattr(mod, "detect_audio_type", lambda *a, **k: "whisper")
    monkeypatch.setattr(mod, "_hf_offline", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_offline_window_if", lambda flag: contextlib.nullcontext())
    monkeypatch.setattr(mod, "_multi_gpu_device_map_kwargs", lambda: {})

    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    backend = mod.ExportBackend.__new__(mod.ExportBackend)
    backend.cleanup_memory = lambda: None
    ok, message = backend.load_checkpoint(str(checkpoint))

    assert ok, message
    assert len(_RecordingLoader.calls) == 1
    assert _RecordingLoader.calls[0]["whisper_language"] == "English"
    assert _RecordingLoader.calls[0]["whisper_task"] == "transcribe"


def test_load_checkpoint_repairs_legacy_cache_identity_without_rewriting_adapter(
    monkeypatch, tmp_path
):
    mod = _export_mod(monkeypatch)
    snapshot = (
        tmp_path
        / "cache"
        / "models--unsloth--Llama-3.2-1B-Instruct"
        / "snapshots"
        / "0123456789abcdef"
    )
    snapshot.mkdir(parents = True)
    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    adapter_path = checkpoint / "adapter_config.json"
    original_adapter = '{"base_model_name_or_path":"' + str(snapshot) + '","r":16}\n'
    adapter_path.write_text(original_adapter, encoding = "utf-8")

    class _LegacyAdapterLoader:
        @classmethod
        def from_pretrained(cls, **_kwargs):
            model = types.SimpleNamespace(
                config = types.SimpleNamespace(_name_or_path = str(checkpoint)),
                peft_config = {
                    "default": types.SimpleNamespace(base_model_name_or_path = str(snapshot))
                },
            )
            return model, types.SimpleNamespace()

    monkeypatch.setattr(mod, "FastLanguageModel", _LegacyAdapterLoader)
    monkeypatch.setattr(mod, "get_base_model_from_lora", lambda _path: str(snapshot))
    monkeypatch.setattr(mod, "detect_audio_type", lambda *a, **k: None)
    monkeypatch.setattr(mod, "is_vision_model", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_hf_offline", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_offline_window_if", lambda flag: contextlib.nullcontext())
    monkeypatch.setattr(mod, "_multi_gpu_device_map_kwargs", lambda: {})

    backend = mod.ExportBackend.__new__(mod.ExportBackend)
    backend.cleanup_memory = lambda: None
    ok, message = backend.load_checkpoint(str(checkpoint))

    assert ok, message
    assert (
        backend.current_model.peft_config["default"].base_model_name_or_path
        == "unsloth/Llama-3.2-1B-Instruct"
    )
    assert backend.current_model.config._name_or_path == str(checkpoint)
    assert adapter_path.read_text(encoding = "utf-8") == original_adapter


def test_cpu_offloaded_modules_counts_cpu_and_disk(monkeypatch):
    mod = _export_mod(monkeypatch)
    model = types.SimpleNamespace(hf_device_map = {"a": 0, "b": "cpu", "c": 1, "d": "disk"})
    assert mod._cpu_offloaded_modules(model) == 2


def test_cpu_offloaded_modules_ignores_gpu_only_and_missing_maps(monkeypatch):
    mod = _export_mod(monkeypatch)
    assert mod._cpu_offloaded_modules(types.SimpleNamespace(hf_device_map = {"a": 0})) == 0
    assert mod._cpu_offloaded_modules(types.SimpleNamespace(hf_device_map = None)) == 0
    assert mod._cpu_offloaded_modules(types.SimpleNamespace()) == 0


class _SpillThenCleanLoader:
    """First call offloads to CPU (bf16 accepts it silently), second is clean."""

    calls: list[dict] = []

    @classmethod
    def from_pretrained(cls, **kwargs):
        cls.calls.append(kwargs)
        device_map = {"model.layers.0": 0} if len(cls.calls) > 1 else {"model.layers.0": "cpu"}
        return types.SimpleNamespace(hf_device_map = device_map), types.SimpleNamespace()


def _run_spill_loader(monkeypatch, tmp_path, device_map_kwargs):
    mod = _export_mod(monkeypatch)
    _SpillThenCleanLoader.calls = []
    monkeypatch.setattr(mod, "FastLanguageModel", _SpillThenCleanLoader)
    monkeypatch.setattr(mod, "detect_audio_type", lambda *a, **k: None)
    monkeypatch.setattr(mod, "is_vision_model", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_hf_offline", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_offline_window_if", lambda flag: contextlib.nullcontext())
    monkeypatch.setattr(mod, "_multi_gpu_device_map_kwargs", lambda: device_map_kwargs)

    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    backend = mod.ExportBackend.__new__(mod.ExportBackend)
    backend.cleanup_memory = lambda: None
    ok, message = backend.load_checkpoint(str(checkpoint))
    return ok, message, _SpillThenCleanLoader.calls


def test_successful_load_that_offloads_to_cpu_retries_single_device(monkeypatch, tmp_path):
    # nothing raises, so only hf_device_map catches params left on meta
    ok, message, calls = _run_spill_loader(monkeypatch, tmp_path, {"device_map": "balanced"})
    assert ok, message
    assert len(calls) == 2
    assert calls[0]["device_map"] == "balanced"
    # named, not omitted: an omitted map is upgraded back to the planner
    assert calls[1]["device_map"] == "sequential"


def test_single_gpu_offload_is_left_alone(monkeypatch, tmp_path):
    ok, message, calls = _run_spill_loader(monkeypatch, tmp_path, {})
    assert ok, message
    assert len(calls) == 1


def test_retry_result_is_kept_even_if_it_also_offloads(monkeypatch, tmp_path):
    mod = _export_mod(monkeypatch)

    class _AlwaysSpills:
        calls: list[dict] = []

        @classmethod
        def from_pretrained(cls, **kwargs):
            cls.calls.append(kwargs)
            return types.SimpleNamespace(hf_device_map = {"a": "cpu"}), types.SimpleNamespace()

    monkeypatch.setattr(mod, "FastLanguageModel", _AlwaysSpills)
    monkeypatch.setattr(mod, "detect_audio_type", lambda *a, **k: None)
    monkeypatch.setattr(mod, "is_vision_model", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_hf_offline", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_offline_window_if", lambda flag: contextlib.nullcontext())
    monkeypatch.setattr(
        mod,
        "_multi_gpu_device_map_kwargs",
        lambda: {"device_map": "balanced"},
    )

    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    backend = mod.ExportBackend.__new__(mod.ExportBackend)
    backend.cleanup_memory = lambda: None
    ok, message = backend.load_checkpoint(str(checkpoint))
    assert ok, message
    assert len(_AlwaysSpills.calls) == 2


def test_is_device_map_infeasible_matches_by_class_name(monkeypatch):
    mod = _export_mod(monkeypatch)

    class DeviceMapInfeasible(RuntimeError):
        pass

    assert mod._is_device_map_infeasible(DeviceMapInfeasible("needs 7.5 GiB free on cuda:0"))
    assert not mod._is_device_map_infeasible(RuntimeError("needs 7.5 GiB free on cuda:0"))


def test_planner_refusal_retries_on_the_single_device_loader(monkeypatch, tmp_path):
    """The planner budgets from memory read before this process opens a context, so other jobs on
    the cards can make it refuse a model the single-device load fits."""
    mod = _export_mod(monkeypatch)

    class DeviceMapInfeasible(RuntimeError):
        pass

    class _RefusesThenLoads:
        calls: list[dict] = []

        @classmethod
        def from_pretrained(cls, **kwargs):
            cls.calls.append(kwargs)
            if len(cls.calls) == 1:
                raise DeviceMapInfeasible("2 x 8 GiB is not enough for the head")
            return types.SimpleNamespace(
                hf_device_map = {"model.layers.0": 0}
            ), types.SimpleNamespace()

    monkeypatch.setattr(mod, "FastLanguageModel", _RefusesThenLoads)
    monkeypatch.setattr(mod, "detect_audio_type", lambda *a, **k: None)
    monkeypatch.setattr(mod, "is_vision_model", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_hf_offline", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_offline_window_if", lambda flag: contextlib.nullcontext())
    monkeypatch.setattr(
        mod, "_multi_gpu_device_map_kwargs", lambda: {"device_map": "unsloth_balanced"}
    )

    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    backend = mod.ExportBackend.__new__(mod.ExportBackend)
    backend.cleanup_memory = lambda: None
    ok, message = backend.load_checkpoint(str(checkpoint))

    assert ok, message
    assert len(_RefusesThenLoads.calls) == 2
    assert _RefusesThenLoads.calls[0]["device_map"] == "unsloth_balanced"
    assert _RefusesThenLoads.calls[1]["device_map"] == "sequential"


def test_an_unrelated_error_is_still_reported_rather_than_retried(monkeypatch, tmp_path):
    # retry only for placement: a broken checkpoint must not be loaded twice
    mod = _export_mod(monkeypatch)

    class _AlwaysBroken:
        calls: list[dict] = []

        @classmethod
        def from_pretrained(cls, **kwargs):
            cls.calls.append(kwargs)
            raise ValueError("adapter_config.json is not valid JSON")

    monkeypatch.setattr(mod, "FastLanguageModel", _AlwaysBroken)
    monkeypatch.setattr(mod, "detect_audio_type", lambda *a, **k: None)
    monkeypatch.setattr(mod, "is_vision_model", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_hf_offline", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_offline_window_if", lambda flag: contextlib.nullcontext())
    monkeypatch.setattr(
        mod, "_multi_gpu_device_map_kwargs", lambda: {"device_map": "unsloth_balanced"}
    )

    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    backend = mod.ExportBackend.__new__(mod.ExportBackend)
    backend.cleanup_memory = lambda: None
    ok, message = backend.load_checkpoint(str(checkpoint))

    assert not ok
    assert len(_AlwaysBroken.calls) == 1
    assert "not valid JSON" in message


def test_the_retry_names_sequential_rather_than_omitting_the_device_map(monkeypatch, tmp_path):
    """Omitting device_map re-runs the planner, so the retry must name sequential explicitly."""
    mod = _export_mod(monkeypatch)

    class DeviceMapInfeasible(RuntimeError):
        pass

    class _RefusesAnyPlan:
        calls: list[dict] = []

        @classmethod
        def from_pretrained(cls, **kwargs):
            cls.calls.append(kwargs)
            if (
                kwargs.get("device_map") in ("unsloth", "unsloth_balanced", None)
                or "device_map" not in kwargs
            ):
                raise DeviceMapInfeasible("needs 7.57 GiB free on cuda:0, has 4.10 GiB")
            return types.SimpleNamespace(
                hf_device_map = {"model.layers.0": 0}
            ), types.SimpleNamespace()

    monkeypatch.setattr(mod, "FastLanguageModel", _RefusesAnyPlan)
    monkeypatch.setattr(mod, "detect_audio_type", lambda *a, **k: None)
    monkeypatch.setattr(mod, "is_vision_model", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_hf_offline", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_offline_window_if", lambda flag: contextlib.nullcontext())
    monkeypatch.setattr(
        mod, "_multi_gpu_device_map_kwargs", lambda: {"device_map": "unsloth_balanced"}
    )

    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    backend = mod.ExportBackend.__new__(mod.ExportBackend)
    backend.cleanup_memory = lambda: None
    ok, message = backend.load_checkpoint(str(checkpoint))

    assert ok, message
    assert len(_RefusesAnyPlan.calls) == 2
    assert _RefusesAnyPlan.calls[0]["device_map"] == "unsloth_balanced"
    assert _RefusesAnyPlan.calls[1]["device_map"] == "sequential"


@pytest.mark.parametrize("audio_type", [None, "audio_vlm"])
def test_an_audio_input_vision_model_exports_through_the_vision_load(
    monkeypatch, tmp_path, audio_type
):
    mod = _export_mod(monkeypatch)
    _RecordingLoader.calls = []
    monkeypatch.setattr(mod, "FastVisionModel", _RecordingLoader)
    monkeypatch.setattr(
        mod, "FastLanguageModel", lambda *a, **k: pytest.fail("loaded as a text model")
    )
    monkeypatch.setattr(mod, "detect_audio_type", lambda *a, **k: audio_type)
    monkeypatch.setattr(mod, "is_vision_model", lambda *a, **k: True)
    monkeypatch.setattr(mod, "_hf_offline", lambda *a, **k: False)
    monkeypatch.setattr(mod, "_offline_window_if", lambda flag: contextlib.nullcontext())
    monkeypatch.setattr(mod, "_multi_gpu_device_map_kwargs", lambda: {})
    checkpoint = tmp_path / "checkpoint-100"
    checkpoint.mkdir()
    backend = mod.ExportBackend.__new__(mod.ExportBackend)
    backend.cleanup_memory = lambda: None

    ok, message = backend.load_checkpoint(str(checkpoint))

    assert ok, message
    assert backend.is_vision is True
    assert len(_RecordingLoader.calls) == 1