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.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
Repair RoPE for plain transformers loads after an Unsloth load (reward models in Online DPO / GRPO) (#13055)
Daniel Han113d5ef23172
diff --git a/tests/test_plain_load_after_unsloth_rope.py b/tests/test_plain_load_after_unsloth_rope.pynew file mode 100644index 00000000000..94b97bd5bdc--- /dev/null+++ b/tests/test_plain_load_after_unsloth_rope.py@@ -0,0 +1,90 @@+# SPDX-License-Identifier: AGPL-3.0-only+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved.++"""A plain transformers from_pretrained after Unsloth patched Llama (TRL loading a reward model by name, #1494) must get a valid RoPE."""++import inspect+import subprocess+import sys++import pytest+import torch+from packaging.version import Version+import transformers+++def _has_real_gpu():+ try:+ torch.zeros(1).to("cuda")+ return True+ except Exception:+ return False+++pytestmark = [+ pytest.mark.skipif(+ not _has_real_gpu(), reason = "Unsloth's rotary classes build CUDA caches in __init__"+ ),+ pytest.mark.skipif(+ Version(transformers.__version__) < Version("5.0.0"),+ reason = "only transformers v5 blanks non-persistent buffers on load",+ ),+]+++# Subprocess: pre_patch swaps Llama classes process-wide, which would leak into later tests.+_CHECK = """+import sys, torch+import unsloth+from transformers import AutoModelForSequenceClassification, LlamaConfig, LlamaForSequenceClassification+from unsloth.models.llama import FastLlamaModel, LlamaRotaryEmbedding++FastLlamaModel.pre_patch()+config = LlamaConfig(+ vocab_size = 128, hidden_size = 64, intermediate_size = 128, num_hidden_layers = 2,+ num_attention_heads = 4, num_key_value_heads = 2, max_position_embeddings = 256,+ rope_theta = 500000.0, num_labels = 1, pad_token_id = 0,+)+torch.manual_seed(0)+LlamaForSequenceClassification(config).save_pretrained(sys.argv[1])+model = AutoModelForSequenceClassification.from_pretrained(+ sys.argv[1], num_labels = 1, output_loading_info = sys.argv[2] == "1"+)+if sys.argv[2] == "1":+ model, info = model+ assert isinstance(info, dict)+rotary = model.model.rotary_emb+assert isinstance(rotary, LlamaRotaryEmbedding), type(rotary)+expected = rotary._unsloth_recompute_inv_freq().float()+torch.testing.assert_close(rotary.inv_freq.detach().cpu().float(), expected)+cos = rotary.multi_gpu_cos_cached[torch.cuda.current_device()].float().cpu()+freqs = torch.outer(torch.arange(cos.shape[0], dtype = torch.float32), expected)+torch.testing.assert_close(cos, torch.cat((freqs, freqs), -1).cos(), atol = 1e-3, rtol = 0)+"""++[email protected]("output_loading_info", ["0", "1"])+def test_plain_from_pretrained_after_pre_patch_gets_valid_rope(tmp_path, output_loading_info):+ result = subprocess.run(+ [sys.executable, "-c", _CHECK, str(tmp_path / "tiny_rm"), output_loading_info],+ capture_output = True,+ text = True,+ timeout = 600,+ )+ assert result.returncode == 0, result.stderr[-4000:]+++def test_wrap_is_idempotent_and_keeps_transformers_source():+ from transformers import PreTrainedModel++ from unsloth.models import loader+ from unsloth.models.modelopt_fp8 import _from_pretrained_own_kwargs++ first = PreTrainedModel.from_pretrained.__func__+ loader._patch_from_pretrained_rope_fix()+ assert PreTrainedModel.from_pretrained.__func__ is first+ assert first._unsloth_rope_fix+ assert not getattr(first.__wrapped__, "_unsloth_rope_fix", False)+ # Names transformers only reads via kwargs.pop; a scan of the wrapper's source would miss them.+ assert {"dtype", "device_map", "subfolder"} <= _from_pretrained_own_kwargs()+ assert "kwargs.pop" in inspect.getsource(inspect.unwrap(PreTrainedModel.from_pretrained))diff --git a/unsloth/models/loader.py b/unsloth/models/loader.pyindex 3f571f4ebf2..7c84fddb687 100644--- a/unsloth/models/loader.py+++ b/unsloth/models/loader.py@@ -876,6 +876,31 @@ def _fix_rope_inv_freq(model):return model+def _patch_from_pretrained_rope_fix():+ """pre_patch swaps Unsloth's rotary classes into transformers, so a plain from_pretrained after an Unsloth load (a reward model TRL loads by name) also gets the corrupted inv_freq (#1494)."""+ if not _NEEDS_ROPE_FIX:+ return+ import functools+ from transformers import PreTrainedModel++ original = PreTrainedModel.from_pretrained.__func__+ if getattr(original, "_unsloth_rope_fix", False):+ return++ @functools.wraps(original)+ def wrapped(cls, *args, **kwargs):+ output = original(cls, *args, **kwargs)+ # output_loading_info = True returns (model, info).+ _fix_rope_inv_freq(output[0] if isinstance(output, tuple) else output)+ return output++ wrapped._unsloth_rope_fix = True+ PreTrainedModel.from_pretrained = classmethod(wrapped)+++_patch_from_pretrained_rope_fix()++def _vllm_unavailable_error():# vLLM installed but disabled at import (ABI break, needs transformers 5) is not "not installed".from unsloth import import_fixesdiff --git a/unsloth/models/modelopt_fp8.py b/unsloth/models/modelopt_fp8.pyindex 2bdc387d34a..2b6e311c546 100644--- a/unsloth/models/modelopt_fp8.py+++ b/unsloth/models/modelopt_fp8.py@@ -448,7 +448,8 @@ def keep_fp8_scale_names_on_save(model) -> None:def _from_pretrained_own_kwargs() -> frozenset:from transformers import PreTrainedModel- fn = PreTrainedModel.from_pretrained+ # unwrap: loader.py wraps from_pretrained, and the kwargs.pop scan needs transformers' source.+ fn = inspect.unwrap(PreTrainedModel.from_pretrained)names = set(inspect.signature(fn).parameters)try:names |= set(re.findall(r"kwargs\.pop\(\s*[\"'](\w+)[\"']", inspect.getsource(fn)))