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.

6.4 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

from __future__ import annotations

import sys
from pathlib import Path

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

import importlib  # noqa: E402
import types  # noqa: E402
from unittest.mock import MagicMock  # noqa: E402

import pytest  # noqa: E402

_STUBBED: list[str] = []


def _stub_if_missing(name, attrs):
    if name in sys.modules:
        return
    try:
        importlib.import_module(name)
        return
    except Exception:  # noqa: BLE001 - stub unusable imports
        pass
    _STUBBED.append(name)
    mod = types.ModuleType(name)
    mod.__spec__ = None
    for attr in attrs:
        setattr(mod, attr, MagicMock())
    sys.modules[name] = mod
    parent, _, child = name.rpartition(".")
    if parent and parent in sys.modules:
        setattr(sys.modules[parent], child, mod)


_stub_if_missing("unsloth", ("FastLanguageModel", "FastVisionModel", "is_bfloat16_supported"))
_stub_if_missing("unsloth.chat_templates", ("get_chat_template",))
_stub_if_missing("trl", ("SFTTrainer", "SFTConfig"))

from core.training import trainer as _trainer  # noqa: E402,F401
from core.training import worker  # noqa: E402

for _name in reversed(_STUBBED):
    sys.modules.pop(_name, None)


def _module(name, **attrs):
    mod = types.ModuleType(name)
    mod.__spec__ = None
    mod.__dict__.update(attrs)
    return mod


@pytest.fixture
def run_embedding(monkeypatch, tmp_path):
    trained = {}

    class Trainer:
        def __init__(self, **kwargs):
            trained.update(kwargs)

        def remove_callback(self, callback):
            pass

        def train(self, **kwargs):
            pass

    monkeypatch.setitem(
        sys.modules,
        "unsloth",
        _module(
            "unsloth",
            FastSentenceTransformer = MagicMock(),
            is_bfloat16_supported = lambda: False,
        ),
    )
    monkeypatch.setitem(
        sys.modules,
        "sentence_transformers",
        _module(
            "sentence_transformers",
            SentenceTransformerTrainer = Trainer,
            SentenceTransformerTrainingArguments = MagicMock(),
        ),
    )
    monkeypatch.setitem(
        sys.modules,
        "sentence_transformers.losses",
        _module("sentence_transformers.losses", MultipleNegativesRankingLoss = MagicMock()),
    )
    monkeypatch.setitem(
        sys.modules,
        "sentence_transformers.training_args",
        _module("sentence_transformers.training_args", BatchSamplers = MagicMock()),
    )
    monkeypatch.setattr(worker, "_model_load_security_error", lambda *a, **k: None)
    monkeypatch.setattr(worker, "_start_worker_stop_poller", lambda *a, **k: None)
    monkeypatch.setattr(worker, "_emit_resource_provenance", lambda *a, **k: True)

    def run(
        csv_text,
        error = None,
        **config,
    ):
        path = tmp_path / "pairs.csv"
        path.write_text(csv_text)
        events = []
        worker._run_embedding_training(
            types.SimpleNamespace(put = events.append),
            None,
            {
                "model_name": "unsloth/all-MiniLM-L6-v2",
                "training_type": "Full Finetuning",
                "local_datasets": [str(path)],
                "output_dir": "embedding-csv-cells",
                "max_steps": 1,
                **config,
            },
        )
        errors = [event["error"] for event in events if event["type"] == "error"]
        assert errors == ([error] if error else [])
        warnings = [event["message"] for event in events if event["type"] == "warning"]
        return trained.get("train_dataset"), warnings

    return run


def test_uploaded_csv_trains_embedding_pairs_as_written(run_embedding):
    dataset, warnings = run_embedding(
        "query,answer\n"
        "Zip code of Holtsville NY?,00501\n"
        "Price for item 7?,NA\n"
        "What does the API return on a miss?,None\n"
        "Say nothing.,\n"
        "Zip code of Schenectady NY?,12345\n"
    )

    assert dataset.to_list() == [
        {"query": "Zip code of Holtsville NY?", "answer": "00501"},
        {"query": "Price for item 7?", "answer": "NA"},
        {"query": "What does the API return on a miss?", "answer": "None"},
        {"query": "Zip code of Schenectady NY?", "answer": "12345"},
    ]
    assert warnings == ["Dropped 1 of 5 rows because a text cell was empty."]


def test_embedding_csv_score_column_still_reaches_the_trainer_as_numbers(run_embedding):
    dataset, warnings = run_embedding(
        "sentence1,sentence2,score\nA cat sits.,A cat is sitting.,0.9\nA dog runs.,Rain falls.,0\n"
    )

    assert dataset.to_list() == [
        {"sentence1": "A cat sits.", "sentence2": "A cat is sitting.", "score": 0.9},
        {"sentence1": "A dog runs.", "sentence2": "Rain falls.", "score": 0.0},
    ]
    assert warnings == []


def test_embedding_csv_label_columns_parse_like_pandas(run_embedding):
    dataset, _ = run_embedding("s1,s2,label,score\naa,bb,True, 0.5\ncc,dd,False,0.25 \n")

    assert dataset.to_list() == [
        {"s1": "aa", "s2": "bb", "label": 1.0, "score": 0.5},
        {"s1": "cc", "s2": "dd", "label": 0.0, "score": 0.25},
    ]


def test_embedding_csv_with_no_text_left_fails_instead_of_training_nothing(run_embedding):
    run_embedding(
        "s1,s2,\naa,bb,\ncc,dd,\n",
        error = "Failed to load dataset: All 2 rows have an empty text cell.",
    )


def test_embedding_csv_slice_counts_rows_of_the_file(run_embedding):
    dataset, warnings = run_embedding(
        "q,a\nq0,a0\nq1,\nq2,a2\nq3,a3\nq4,a4\n",
        dataset_slice_start = 1,
        dataset_slice_end = 3,
    )

    assert dataset.to_list() == [{"q": "q2", "a": "a2"}, {"q": "q3", "a": "a3"}]
    assert warnings == ["Dropped 1 of 3 rows because a text cell was empty."]


def test_embedding_slice_start_past_the_last_row_is_refused(run_embedding):
    run_embedding(
        "q,a\nq0,a0\nq1,a1\n",
        error = "Failed to load dataset: Train Split Start 5 is past the last row of this "
        "dataset (2 rows).",
        dataset_slice_start = 5,
    )


def test_embedding_csv_score_na_marker_outside_the_slice_still_trains(run_embedding):
    dataset, _ = run_embedding(
        "s1,s2,score\naa,bb,0.5\ncc,dd,NA\n",
        dataset_slice_end = 0,
    )

    assert dataset.to_list() == [{"s1": "aa", "s2": "bb", "score": 0.5}]