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.

Load path: read an adapter's base config through the probe memo, skip the remote mapper for unknown LoRA bases in Studio (#16793)

Daniel Han90e1e733c483
diff --git a/studio/backend/core/inference/worker.py b/studio/backend/core/inference/worker.py
index bd7438e785c..0f92414c73c 100644
--- a/studio/backend/core/inference/worker.py
+++ b/studio/backend/core/inference/worker.py
@@ -594,15 +594,23 @@ def _load_download_repos(
mapped = mlx_bnb_base_repo(str(base))
else:
try:
- from unsloth.models import loader
- from unsloth.models.loader_utils import get_model_name
+ from unsloth.models import loader, loader_utils
quantized = (
load_in_4bit
and not getattr(mc, "is_audio", False)
and getattr(loader, "ALLOW_BITSANDBYTES", True)
)
- mapped = get_model_name(str(base), load_in_4bit = quantized)
+ # Unknown names resolve to themselves; get_model_name would fetch the remote mapper for nothing.
+ mapped = str(base)
+ name = mapped.lower()
+ tables = (
+ loader_utils.FLOAT_TO_INT_MAPPER,
+ loader_utils.INT_TO_FLOAT_MAPPER,
+ loader_utils.MAP_TO_UNSLOTH_16bit,
+ )
+ if name in loader_utils.BAD_MAPPINGS or any(name in t for t in tables):
+ mapped = loader_utils.get_model_name(str(base), load_in_4bit = quantized)
if mapped and not getattr(loader, "ALLOW_PREQUANTIZED_MODELS", True):
mapped = loader._strip_unsloth_bnb_4bit_suffix(mapped)
except Exception:
diff --git a/studio/backend/tests/test_load_download_repos_mapper.py b/studio/backend/tests/test_load_download_repos_mapper.py
new file mode 100644
index 00000000000..06d57f8bd12
--- /dev/null
+++ b/studio/backend/tests/test_load_download_repos_mapper.py
@@ -0,0 +1,65 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+from types import SimpleNamespace
+
+import pytest
+
+
+def test_unmapped_lora_base_skips_the_remote_mapper(monkeypatch):
+ pytest.importorskip("unsloth")
+ from unsloth.models import loader_utils
+ from core.inference import worker
+
+ fetches = []
+
+ def _fetch():
+ fetches.append(1)
+ return ({}, {}, {}, {}, {})
+
+ monkeypatch.setattr(loader_utils, "_get_new_mapper", _fetch)
+ monkeypatch.setattr(loader_utils, "_env_says_offline", lambda: False)
+ cuda = SimpleNamespace(device = "cuda")
+
+ unmapped = SimpleNamespace(identifier = "owner/adapter", base_model = "owner/unmapped-base")
+ for flag in (True, False):
+ assert worker._load_download_repos(unmapped, flag, cuda) == [
+ "owner/adapter",
+ "owner/unmapped-base",
+ ]
+ assert fetches == []
+
+ monkeypatch.setattr(
+ loader_utils, "_get_new_mapper", lambda: ({}, {"owner/unmapped-base": "x/y"}, {}, {}, {})
+ )
+ assert worker._load_download_repos(unmapped, True, cuda) == [
+ "owner/adapter",
+ "owner/unmapped-base",
+ ]
+
+ name = next(iter(loader_utils.FLOAT_TO_INT_MAPPER))
+ mapped = SimpleNamespace(identifier = "owner/adapter", base_model = name)
+ from unsloth.models import loader
+
+ expected = loader_utils.get_model_name(name, load_in_4bit = loader.ALLOW_BITSANDBYTES)
+ if not loader.ALLOW_PREQUANTIZED_MODELS:
+ expected = loader._strip_unsloth_bnb_4bit_suffix(expected)
+ assert worker._load_download_repos(mapped, True, cuda) == list(
+ dict.fromkeys(["owner/adapter", name, expected])
+ )
+ assert fetches == []
+
+
+def test_unmapped_prequantized_base_still_lists_the_stripped_repo(monkeypatch):
+ pytest.importorskip("unsloth")
+ from unsloth.models import loader, loader_utils
+ from core.inference import worker
+
+ monkeypatch.setattr(loader_utils, "_get_new_mapper", lambda: ({}, {}, {}, {}, {}))
+ monkeypatch.setattr(loader, "ALLOW_PREQUANTIZED_MODELS", False)
+ mc = SimpleNamespace(identifier = "owner/adapter", base_model = "owner/unmapped-bnb-4bit")
+ assert worker._load_download_repos(mc, True, SimpleNamespace(device = "cuda")) == [
+ "owner/adapter",
+ "owner/unmapped-bnb-4bit",
+ "owner/unmapped",
+ ]
diff --git a/studio/backend/tests/test_load_downloads.py b/studio/backend/tests/test_load_downloads.py
index 662a2799ca4..e2301e5c0da 100644
--- a/studio/backend/tests/test_load_downloads.py
+++ b/studio/backend/tests/test_load_downloads.py
@@ -167,6 +167,10 @@ def test_the_worker_reports_the_repos_a_lora_load_fetches(monkeypatch):
loader_utils.get_model_name = (
lambda name, load_in_4bit = True: "unsloth/base-bnb-4bit" if load_in_4bit else name
)
+ loader_utils.FLOAT_TO_INT_MAPPER = {"owner/base": "unsloth/base-bnb-4bit"}
+ loader_utils.INT_TO_FLOAT_MAPPER = {}
+ loader_utils.MAP_TO_UNSLOTH_16bit = {}
+ loader_utils.BAD_MAPPINGS = {}
loader = types.ModuleType("unsloth.models.loader")
loader.ALLOW_PREQUANTIZED_MODELS = True
loader.ALLOW_BITSANDBYTES = True
diff --git a/tests/python/test_load_probe_memo.py b/tests/python/test_load_probe_memo.py
index db596e8ff65..5d78b645bfc 100644
--- a/tests/python/test_load_probe_memo.py
+++ b/tests/python/test_load_probe_memo.py
@@ -272,3 +272,62 @@ def test_memoized_config_equals_a_fresh_load(tmp_path, name, config):
assert type(got) is type(fresh)
assert json.loads(got.to_json_string()) == json.loads(fresh.to_json_string())
assert sorted(vars(got)) == sorted(vars(fresh))
+
+
+ getattr(unsloth, "_IS_MLX", False), reason = "the MLX loader needs real safetensors"
+)
[email protected]("token", ["hf_unused_for_local_dirs", False])
+def test_fastmodel_adapter_load_probes_base_config_once(tmp_path, monkeypatch, token):
+ import sys
+
+ from unsloth import FastModel
+
+ config = dict(_tiny_configs())["gemma3"]
+ base = _save_tiny(tmp_path, "gemma3_base", config)
+ adapter = tmp_path / "adapter"
+ peft.LoraConfig(r = 4, target_modules = ["q_proj"], base_model_name_or_path = base).save_pretrained(
+ str(adapter)
+ )
+ adapter = str(adapter)
+ calls = _count_probes(monkeypatch)
+ counted = transformers.AutoConfig.from_pretrained.__func__
+ loader_calls = []
+
+ # unsloth_zoo's model-type lookup reads the base config on its own; count the loader's probes.
+ def _autoconfig(cls, name, *args, **kwargs):
+ caller = sys._getframe(1).f_code.co_filename.replace("\\", "/")
+ if "/unsloth/models/" in caller:
+ loader_calls.append(str(name))
+ return counted(cls, name, *args, **kwargs)
+
+ monkeypatch.setattr(transformers.AutoConfig, "from_pretrained", classmethod(_autoconfig))
+ resolved = []
+ with pytest.raises(_ReachedWeights):
+ FastModel.from_pretrained(
+ adapter,
+ max_seq_length = 64,
+ load_in_4bit = False,
+ token = token,
+ on_model_resolved = resolved.append,
+ )
+ assert loader_calls.count(base) == 1, (loader_calls, calls)
+ assert resolved[-1] == base
+
+
+ getattr(unsloth, "_IS_MLX", False), reason = "the MLX loader needs real safetensors"
+)
+def test_fastmodel_adapter_on_a_missing_base_raises_the_same_error(tmp_path, monkeypatch):
+ from unsloth import FastModel
+
+ adapter = tmp_path / "adapter"
+ missing = str(tmp_path / "no_such_base")
+ peft.LoraConfig(
+ r = 4, target_modules = ["q_proj"], base_model_name_or_path = missing
+ ).save_pretrained(str(adapter))
+ calls = _count_probes(monkeypatch)
+ with pytest.raises(Exception) as excinfo:
+ FastModel.from_pretrained(str(adapter), max_seq_length = 64, load_in_4bit = False)
+ assert not isinstance(excinfo.value, _ReachedWeights)
+ assert calls["autoconfig"].count(missing) == 1, calls
diff --git a/unsloth/models/loader.py b/unsloth/models/loader.py
index 9b84f8f449a..5db938280da 100644
--- a/unsloth/models/loader.py
+++ b/unsloth/models/loader.py
@@ -2753,7 +2753,8 @@ class FastModel(FastBaseModel):
diffusion_config = model_config
if diffusion_config is None and peft_config is not None:
try:
- diffusion_config = AutoConfig.from_pretrained(
+ diffusion_config = _memo_config_probe(
+ AutoConfig.from_pretrained,
peft_config.base_model_name_or_path,
token = token,
trust_remote_code = trust_remote_code,