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
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
import assert from "node:assert/strict";
import test from "node:test";
import type { TrainingConfigState } from "../src/features/training/types/config.ts";
import { registerBundlerResolver } from "./helpers/kit.ts";
registerBundlerResolver();
const { validateS3Source, validateTrainingConfig } = await import(
"../src/features/training/lib/validation.ts"
);
const validConfig = {
selectedModel: "org/model",
modelKnownCached: false,
modelLocalPath: null,
modelFormat: null,
learningRate: 0.0002,
embeddingLearningRate: null,
datasetSource: "huggingface" as const,
dataset: "org/dataset",
datasetSplit: "train",
manualDatasetOptionsValid: true,
uploadedFile: null,
s3Config: null,
modelType: "text" as const,
isVisionModel: false,
isEmbeddingModel: false,
isAudioModel: false,
isDatasetAudio: false,
loraVariant: "rslora" as const,
trainingMethod: "qlora" as const,
} as TrainingConfigState;
test("training validation rejects non-positive learning rates", () => {
assert.deepEqual(
validateTrainingConfig({ ...validConfig, learningRate: 0 }),
{
ok: false,
errorKey: "studio.training.validation.learningRatePositive",
},
);
assert.deepEqual(
validateTrainingConfig({ ...validConfig, learningRate: Number.NaN }),
{
ok: false,
errorKey: "studio.training.validation.learningRatePositive",
},
);
});
test("training validation accepts a positive learning rate", () => {
assert.deepEqual(
validateTrainingConfig({ ...validConfig, learningRate: 0.0002 }),
{ ok: true, errorKey: null },
);
});
test("training validation requires an explicit split for local cached datasets", () => {
assert.deepEqual(
validateTrainingConfig({
...validConfig,
datasetKnownCached: true,
datasetStreaming: false,
datasetSplit: null,
}),
{
ok: false,
errorKey: "studio.training.validation.hfDatasetSplitRequired",
},
);
assert.deepEqual(
validateTrainingConfig({
...validConfig,
datasetKnownCached: true,
datasetStreaming: false,
datasetSplit: "validation",
}),
{ ok: true, errorKey: null },
);
assert.deepEqual(
validateTrainingConfig({
...validConfig,
datasetKnownCached: false,
datasetSplit: null,
}),
{ ok: true, errorKey: null },
);
assert.deepEqual(
validateTrainingConfig({
...validConfig,
datasetKnownCached: true,
datasetStreaming: true,
datasetSplit: null,
}),
{ ok: true, errorKey: null },
);
});
test("training validation blocks an invalid uncommitted manual dataset option", () => {
assert.deepEqual(
validateTrainingConfig({
...validConfig,
manualDatasetOptionsValid: false,
}),
{
ok: false,
errorKey: "studio.dataset.selectors.manualInvalid",
},
);
});
test("training validation rejects committed split instructions in streaming mode", () => {
assert.deepEqual(
validateTrainingConfig({
...validConfig,
datasetStreaming: true,
datasetSplit: "train + validation",
}),
{
ok: false,
errorKey: "studio.dataset.selectors.manualInvalid",
},
);
assert.deepEqual(
validateTrainingConfig({
...validConfig,
datasetStreaming: true,
datasetSplit: "train",
}),
{ ok: true, errorKey: null },
);
});
test("training validation enforces the CPT embedding learning-rate range", () => {
for (const embeddingLearningRate of [0, 1, -0.0001, Number.NaN]) {
assert.deepEqual(
validateTrainingConfig({
...validConfig,
trainingMethod: "cpt",
embeddingLearningRate,
}),
{
ok: false,
errorKey: "studio.training.validation.embeddingLearningRateRange",
},
);
}
assert.deepEqual(
validateTrainingConfig({
...validConfig,
trainingMethod: "cpt",
embeddingLearningRate: 0.00002,
}),
{ ok: true, errorKey: null },
);
assert.deepEqual(
validateTrainingConfig({
...validConfig,
trainingMethod: "qlora",
embeddingLearningRate: 0,
}),
{ ok: true, errorKey: null },
);
});
test("training validation keeps local dataset paths out of Hub ID validation", () => {
assert.deepEqual(
validateTrainingConfig({
...validConfig,
datasetSource: "upload",
dataset: null,
uploadedFile: "/datasets/team data/train.jsonl",
}),
{ ok: true, errorKey: null },
);
});
test("training validation rejects Hub IDs that backend preflight rejects", () => {
assert.deepEqual(
validateTrainingConfig({
...validConfig,
selectedModel: "org/team/model",
}),
{
ok: false,
errorKey: "studio.modelPicker.reasonInvalidHubId",
},
);
assert.deepEqual(
validateTrainingConfig({
...validConfig,
dataset: "owner/dataset--v2",
}),
{
ok: false,
errorKey: "studio.datasetPicker.reasonInvalidHubId",
},
);
});
test("training validation rejects MLX-incompatible training modes", () => {
assert.deepEqual(
validateTrainingConfig(
{ ...validConfig, modelType: "embeddings", isEmbeddingModel: true },
"mac",
),
{
ok: false,
errorKey: "studio.params.notSupportedAppleSilicon",
},
);
});
test("training validation rejects non-VLM audio training on MLX", () => {
assert.deepEqual(
validateTrainingConfig(
{
...validConfig,
modelType: "audio",
isAudioModel: true,
isDatasetAudio: true,
},
"mac",
),
{
ok: false,
errorKey: "studio.params.notSupportedAppleSilicon",
},
);
assert.deepEqual(
validateTrainingConfig({ ...validConfig, isDatasetAudio: true }, "mac"),
{
ok: false,
errorKey: "studio.params.notSupportedAppleSilicon",
},
);
});
test("training validation allows audio-capable vision models on MLX with audio data", () => {
assert.deepEqual(
validateTrainingConfig(
{
...validConfig,
modelType: "vision",
isVisionModel: true,
isAudioModel: true,
isDatasetAudio: true,
},
"mac",
),
{ ok: true, errorKey: null },
);
});
test("training validation allows audio-capable vision models on MLX with image data", () => {
assert.deepEqual(
validateTrainingConfig(
{
...validConfig,
modelType: "vision",
isVisionModel: true,
isAudioModel: true,
},
"mac",
),
{ ok: true, errorKey: null },
);
});
test("training validation rejects unsupported LoRA variants on MLX", () => {
assert.deepEqual(
validateTrainingConfig({ ...validConfig, loraVariant: "loftq" }, "mac"),
{
ok: false,
errorKey: "studio.params.notSupportedAppleSilicon",
},
);
assert.deepEqual(
validateTrainingConfig({ ...validConfig, loraVariant: "loftq" }, "linux"),
{ ok: true, errorKey: null },
);
assert.deepEqual(
validateTrainingConfig(
{ ...validConfig, trainingMethod: "full", loraVariant: "dora" },
"mac",
),
{ ok: true, errorKey: null },
);
});
test("training validation accepts DoRA on MLX under an adapter method", () => {
for (const trainingMethod of ["lora", "qlora", "cpt"] as const) {
assert.deepEqual(
validateTrainingConfig(
{ ...validConfig, trainingMethod, loraVariant: "dora" },
"mac",
),
{ ok: true, errorKey: null },
);
}
});
test("training validation keeps CPT on every device and embedding training off MLX", () => {
for (const deviceType of ["linux", "mac"]) {
assert.deepEqual(
validateTrainingConfig({ ...validConfig, trainingMethod: "cpt" }, deviceType),
{ ok: true, errorKey: null },
);
}
assert.deepEqual(
validateTrainingConfig(
{ ...validConfig, modelType: "embeddings", isEmbeddingModel: true },
"linux",
),
{ ok: true, errorKey: null },
);
assert.deepEqual(
validateTrainingConfig(
{
...validConfig,
modelType: "audio",
isAudioModel: true,
isDatasetAudio: true,
},
"linux",
),
{ ok: true, errorKey: null },
);
});
const s3Config = {
...validConfig,
datasetSource: "s3" as const,
s3Config: { bucket: "my-bucket", region: "us-east-1", useIamRole: true },
};
test("an audio model can start from S3 (#4539: the audio is downloaded beside its manifest)", () => {
assert.deepEqual(
validateS3Source({ ...s3Config, modelType: "audio", isAudioModel: true }),
{ ok: true, errorKey: null },
);
});
test("a vision model still cannot start from S3", () => {
assert.deepEqual(
validateS3Source({ ...s3Config, modelType: "vision", isVisionModel: true }),
{
ok: false,
errorKey: "studio.training.validation.s3MultimodalUnsupported",
},
);
});
test("training validation lets LoRA and CPT continue from a saved adapter (#13140)", () => {
const adapter = {
...validConfig,
selectedModel: "/outputs/run/checkpoint-30",
modelFormat: "adapter" as const,
};
for (const trainingMethod of ["lora", "qlora", "cpt"] as const) {
assert.deepEqual(
validateTrainingConfig({ ...adapter, trainingMethod } as never, "linux"),
{ ok: true, errorKey: null },
);
}
for (const trainingMethod of ["lora", "qlora", "cpt"] as const) {
assert.deepEqual(
validateTrainingConfig({ ...adapter, trainingMethod } as never, "mac"),
{ ok: true, errorKey: null },
);
}
});
test("training validation refuses an adapter where a fresh adapter would be built", () => {
const adapter = {
...validConfig,
selectedModel: "/outputs/run/checkpoint-30",
modelFormat: "adapter" as const,
};
const refused = { ok: false, errorKey: "studio.modelPicker.reasonAdapter" };
assert.deepEqual(
validateTrainingConfig(
{ ...adapter, trainingMethod: "full" } as never,
"linux",
),
refused,
);
assert.deepEqual(
validateTrainingConfig(
{ ...adapter, modelType: "decision" } as never,
"linux",
),
refused,
);
assert.deepEqual(
validateTrainingConfig(
{ ...adapter, isEmbeddingModel: true } as never,
"linux",
),
refused,
);
});
test("training validation refuses continuing a Hub adapter repo", () => {
assert.deepEqual(
validateTrainingConfig(
{
...validConfig,
selectedModel: "org/adapter",
modelFormat: "adapter",
} as never,
"linux",
),
{ ok: false, errorKey: "studio.modelPicker.reasonAdapter" },
);
});