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.

3.4 KB
Raw Blame
# Copyright 2023-present Daniel Han-Chen & the Unsloth team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""CUDA enables a float32 autocast instead of rejecting it, so float32 models need enabled=False."""

import ast
import sys
from pathlib import Path

import pytest
from real_accelerator import (
    has_real_cuda,
)  # tests/_shared, on sys.path via tests/conftest.py
import torch

REPO_ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO_ROOT))

VISION = REPO_ROOT / "unsloth" / "models" / "vision.py"
SRC = VISION.read_text(encoding = "utf-8")


def _the_autocaster_call():
    """Found by AST shape, so an edit above cannot retarget the UNSLOTH_FORCE_FLOAT32 autocaster."""
    for node in ast.walk(ast.parse(SRC)):
        if not isinstance(node, ast.Assign):
            continue
        if not (
            len(node.targets) == 1
            and isinstance(node.targets[0], ast.Name)
            and node.targets[0].id == "autocaster"
        ):
            continue
        call = node.value
        if not isinstance(call, ast.Call):
            continue
        kwargs = {k.arg: k.value for k in call.keywords}
        if isinstance(kwargs.get("dtype"), ast.Name) and kwargs["dtype"].id == "dtype":
            return kwargs
    raise AssertionError("no autocaster assignment forwarding `dtype` found")


def test_the_generate_autocaster_is_gated_on_a_dtype_it_can_use():
    kwargs = _the_autocaster_call()
    assert "enabled" in kwargs, "autocast is entered unconditionally"
    expression = ast.unparse(kwargs["enabled"])
    assert "float16" in expression and "bfloat16" in expression, expression


def test_the_forced_float16_branch_is_left_alone():
    """UNSLOTH_FORCE_FLOAT32 builds a float16 autocaster on purpose."""
    assert "dtype = torch.float16)" in SRC


@pytest.mark.parametrize(
    "dtype,expected",
    [
        (torch.float32, False),
        (torch.float16, True),
        (torch.bfloat16, True),
    ],
)
def test_the_gate_by_execution(dtype, expected):
    assert (dtype in (torch.float16, torch.bfloat16)) is expected


@pytest.mark.skipif(not has_real_cuda(), reason = "needs a CUDA device")
def test_cuda_really_does_accept_float32_as_an_autocast_dtype():
    """The premise: if torch ever rejects or ignores float32 as an autocast dtype, the fix above is
    no longer load-bearing and this test says so."""
    with torch.autocast(device_type = "cuda", dtype = torch.float32):
        assert torch.is_autocast_enabled("cuda") is True
        assert torch.get_autocast_dtype("cuda") == torch.float32


@pytest.mark.skipif(not has_real_cuda(), reason = "needs a CUDA device")
def test_the_gate_turns_that_into_a_no_op():
    dtype = torch.float32
    with torch.autocast(
        device_type = "cuda", dtype = dtype, enabled = dtype in (torch.float16, torch.bfloat16)
    ):
        assert torch.is_autocast_enabled("cuda") is False


if __name__ == "__main__":
    raise SystemExit(pytest.main([__file__, "-q"]))