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.

Studio: enable packing and assistant-only training defaults where supported (#15478)

Daniel Hane047171b24cb
diff --git a/studio/backend/assets/configs/full_finetune.yaml b/studio/backend/assets/configs/full_finetune.yaml
index 98c45dd8510..20fb392e6e7 100644
--- a/studio/backend/assets/configs/full_finetune.yaml
+++ b/studio/backend/assets/configs/full_finetune.yaml
@@ -18,8 +18,8 @@ training:
save_steps: 0
weight_decay: 0.001
random_seed: 3407
- packing: false
- train_on_completions: false
+ packing: true
+ train_on_completions: true
gradient_checkpointing: "unsloth"
lora:
diff --git a/studio/backend/assets/configs/lora_text.yaml b/studio/backend/assets/configs/lora_text.yaml
index 6c6a4d88395..d08d4ac0fb1 100644
--- a/studio/backend/assets/configs/lora_text.yaml
+++ b/studio/backend/assets/configs/lora_text.yaml
@@ -18,8 +18,8 @@ training:
save_steps: 0
weight_decay: 0.001
random_seed: 3407
- packing: false
- train_on_completions: false
+ packing: true
+ train_on_completions: true
gradient_checkpointing: "unsloth"
lora:
diff --git a/studio/backend/assets/configs/model_defaults/default.yaml b/studio/backend/assets/configs/model_defaults/default.yaml
index fa6826d7afe..d433f5f8da0 100644
--- a/studio/backend/assets/configs/model_defaults/default.yaml
+++ b/studio/backend/assets/configs/model_defaults/default.yaml
@@ -10,7 +10,7 @@ training:
save_steps: 30
weight_decay: 0.001
random_seed: 3407
- packing: false
+ packing: true
train_on_completions: true
gradient_checkpointing: "unsloth"
optim: "adamw_8bit"
diff --git a/studio/backend/assets/configs/vision_lora.yaml b/studio/backend/assets/configs/vision_lora.yaml
index a06f971523d..cf0b5583cd3 100644
--- a/studio/backend/assets/configs/vision_lora.yaml
+++ b/studio/backend/assets/configs/vision_lora.yaml
@@ -19,7 +19,7 @@ training:
weight_decay: 0.001
random_seed: 3407
packing: false
- train_on_completions: false
+ train_on_completions: true
gradient_checkpointing: "unsloth"
lora:
diff --git a/studio/backend/core/training/trainer.py b/studio/backend/core/training/trainer.py
index 7899fe63998..744a7c50862 100644
--- a/studio/backend/core/training/trainer.py
+++ b/studio/backend/core/training/trainer.py
@@ -3989,8 +3989,8 @@ class UnslothTrainer:
save_steps: int = 0,
weight_decay: float = 0.001,
random_seed: int = 3407,
- packing: bool = False,
- train_on_completions: bool = False,
+ packing: bool = True,
+ train_on_completions: bool = True,
enable_wandb: bool = False,
wandb_project: str = "unsloth-training",
wandb_token: str = None,
@@ -5034,6 +5034,14 @@ class UnslothTrainer:
else:
logger.info(f"{message}\n")
+ # Rows as the trainer holds them (packed when packing is on), so the drop check counts masking only.
+ pre_mask_dataset = self.trainer.train_dataset
+ pre_mask_len = (
+ None
+ if pre_mask_dataset is None or detect_streaming_dataset(pre_mask_dataset)
+ else len(pre_mask_dataset)
+ )
+
# No try/except: an exception here is a real masking failure.
self.trainer, masking_applied = apply_completion_masking(
self.trainer,
@@ -5054,10 +5062,12 @@ class UnslothTrainer:
logger.info("Skipping post-filter length check for streaming dataset\n")
else:
filtered_len = len(self.trainer.train_dataset)
- original_dataset_obj = (
- dataset["dataset"] if isinstance(dataset, dict) else dataset
- )
- original_len = len(original_dataset_obj)
+ original_len = pre_mask_len
+ if original_len is None:
+ original_dataset_obj = (
+ dataset["dataset"] if isinstance(dataset, dict) else dataset
+ )
+ original_len = len(original_dataset_obj)
dropped = original_len - filtered_len
drop_pct = (
round(100 * dropped / original_len, 1) if original_len > 0 else 0
diff --git a/studio/backend/core/training/training.py b/studio/backend/core/training/training.py
index 2813f1c7b47..c0659ddd232 100644
--- a/studio/backend/core/training/training.py
+++ b/studio/backend/core/training/training.py
@@ -324,7 +324,9 @@ def _build_training_worker_config(values: dict[str, Any]) -> dict[str, Any]:
values.get("cast_norm_output_to_input_dtype"), True
),
"random_seed": _coerce_seed(values.get("random_seed")),
- "packing": values.get("packing", False),
+ "packing": values.get(
+ "packing", not (values.get("is_embedding") or values.get("is_decision"))
+ ),
"optim": optimizer,
"lr_scheduler_type": values.get("lr_scheduler_type", "linear"),
"use_lora": values.get("use_lora", True),
@@ -340,7 +342,16 @@ def _build_training_worker_config(values: dict[str, Any]) -> dict[str, Any]:
"use_rslora": values.get("use_rslora", False),
"use_loftq": values.get("use_loftq", False),
"use_dora": values.get("use_dora", False),
- "train_on_completions": values.get("train_on_completions", False),
+ "train_on_completions": values.get(
+ "train_on_completions",
+ not (
+ values.get("is_embedding")
+ or values.get("is_decision")
+ or values.get("dataset_streaming")
+ or values.get("training_type") == "Continued Pretraining"
+ or values.get("format_type") in ("raw", "raw_text")
+ ),
+ ),
"finetune_vision_layers": values.get("finetune_vision_layers", True),
"finetune_language_layers": values.get("finetune_language_layers", True),
"finetune_attention_modules": values.get("finetune_attention_modules", True),
diff --git a/studio/backend/models/training.py b/studio/backend/models/training.py
index da4d1dd5ca1..0381f644812 100644
--- a/studio/backend/models/training.py
+++ b/studio/backend/models/training.py
@@ -603,7 +603,7 @@ class TrainingStartRequest(BaseModel):
"and unsloth's historical recommended value."
),
)
- packing: bool = Field(False, description = "Enable sequence packing")
+ packing: bool = Field(True, description = "Enable sequence packing where supported")
optim: str = Field("adamw_8bit", description = "Optimizer")
lr_scheduler_type: str = Field("linear", description = "Learning rate scheduler type")
embedding_learning_rate: Optional[float] = Field(
@@ -646,7 +646,9 @@ class TrainingStartRequest(BaseModel):
use_rslora: bool = Field(False, description = "Use RSLoRA")
use_loftq: bool = Field(False, description = "Use LoftQ")
use_dora: bool = Field(False, description = "Use DoRA")
- train_on_completions: bool = Field(False, description = "Train on completions only")
+ train_on_completions: bool = Field(
+ True, description = "Train on assistant completions where supported"
+ )
finetune_vision_layers: bool = Field(False, description = "Finetune vision layers")
finetune_language_layers: bool = Field(True, description = "Finetune language layers")
@@ -706,6 +708,21 @@ class TrainingStartRequest(BaseModel):
# Sanitized non-LoRA history stores the unused value as null; treat it as an omitted list.
return [] if value is None else value
+ @model_validator(mode = "after")
+ def _default_training_objective_toggles(self) -> "TrainingStartRequest":
+ # getattr: validate_assignment on a model_construct() instance lacks required fields.
+ non_chat = getattr(self, "is_embedding", False) or getattr(self, "is_decision", False)
+ if "packing" not in self.model_fields_set and non_chat:
+ self.packing = False
+ if "train_on_completions" not in self.model_fields_set and (
+ non_chat
+ or getattr(self, "dataset_streaming", False)
+ or getattr(self, "training_type", None) == "Continued Pretraining"
+ or getattr(self, "format_type", None) in ("raw", "raw_text")
+ ):
+ self.train_on_completions = False
+ return self
+
@model_validator(mode = "after")
def _validate_streaming_splits(self) -> "TrainingStartRequest":
# Streaming load_dataset rejects HF slice syntax ("Bad split").
@@ -803,7 +820,7 @@ class TokenPreviewRequest(BaseModel):
dataset_known_cached: bool = False
format_type: str = "auto"
custom_format_mapping: Optional[Dict[str, Any]] = None
- train_on_completions: bool = False
+ train_on_completions: bool = True
is_cpt: bool = False
max_seq_length: int = Field(2048, ge = 1, le = 1_048_576)
num_samples: int = Field(3, ge = 1, le = 8)
diff --git a/studio/backend/routes/models.py b/studio/backend/routes/models.py
index eb738f8daaf..833743f8376 100644
--- a/studio/backend/routes/models.py
+++ b/studio/backend/routes/models.py
@@ -2509,6 +2509,15 @@ async def get_model_config(
is_decision, layout = True, "llm"
config_dict = load_llm_decision_defaults()
+ from utils.models.training_defaults import model_training_recommendations
+
+ config_dict = model_training_recommendations(
+ config_dict,
+ is_vision = is_vision,
+ is_audio = audio_type is not None,
+ is_embedding = is_embedding,
+ is_decision = is_decision,
+ )
logger.info(
f"Model config result for {model_name}: is_vision={is_vision}, is_embedding={is_embedding}, audio_type={audio_type}, audio_type_known={audio_type_definitive}, is_lora={is_lora}, max_position_embeddings={max_position_embeddings}"
)
diff --git a/studio/backend/tests/test_training_toggle_defaults.py b/studio/backend/tests/test_training_toggle_defaults.py
new file mode 100644
index 00000000000..d5cf7cb8f8f
--- /dev/null
+++ b/studio/backend/tests/test_training_toggle_defaults.py
@@ -0,0 +1,102 @@
+# 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
+
+from models.training import TrainingStartRequest, TokenPreviewRequest
+from utils.models.training_defaults import model_training_recommendations
+
+
+def test_training_and_token_preview_default_to_assistant_targets_and_packing():
+ start = TrainingStartRequest(
+ model_name = "unlisted/model", training_type = "LoRA/QLoRA", format_type = "auto"
+ )
+ preview = TokenPreviewRequest(model_name = "unlisted/model")
+ assert start.packing is True
+ assert start.train_on_completions is True
+ assert preview.train_on_completions is True
+
+
[email protected]("value", [True, False])
+def test_worker_config_preserves_explicit_training_toggles(monkeypatch, value):
+ from core.training import training
+
+ monkeypatch.setattr(training, "get_device", lambda: SimpleNamespace(value = "cuda"))
+ request = TrainingStartRequest(
+ model_name = "unlisted/model",
+ training_type = "LoRA/QLoRA",
+ format_type = "auto",
+ packing = value,
+ train_on_completions = value,
+ )
+ config = training._build_training_worker_config(request.model_dump())
+ assert config["packing"] is value
+ assert config["train_on_completions"] is value
+
+
+def test_internal_worker_config_defaults_match_api_defaults(monkeypatch):
+ from core.training import training
+
+ monkeypatch.setattr(training, "get_device", lambda: SimpleNamespace(value = "cuda"))
+ config = training._build_training_worker_config({"model_name": "unlisted/model"})
+ assert config["packing"] is True
+ assert config["train_on_completions"] is True
+
+
+ "flags, enabled",
+ [
+ ({}, True),
+ ({"is_vision": True}, True),
+ ({"is_vision": True, "is_audio": True}, True),
+ ({"is_audio": True}, False),
+ ({"is_embedding": True}, False),
+ ({"is_decision": True}, False),
+ ],
+)
+def test_recommendations_ignore_legacy_recipe_opt_outs_but_respect_training_objective(
+ flags, enabled
+):
+ config = {"training": {"packing": False, "train_on_completions": False, "batch_size": 2}}
+ defaults = {"is_vision": False, "is_audio": False, "is_embedding": False, "is_decision": False}
+ result = model_training_recommendations(config, **{**defaults, **flags})
+ assert result["training"]["packing"] is enabled
+ assert result["training"]["train_on_completions"] is enabled
+ assert result["training"]["batch_size"] == 2
+ # Imported YAML stays literal; only the model-recommendation response is normalized.
+ assert config["training"]["packing"] is False
+ assert config["training"]["train_on_completions"] is False
+
+
+def test_vision_and_text_diffusion_packing_guards_remain_effective():
+ from core.training.dataset_bounds import effective_packing
+ from core.training.worker import _apply_diffusion_lm_overrides
+
+ assert effective_packing({"packing": True}, branch_never_packs = True) is False
+ config = {"packing": True}
+ _apply_diffusion_lm_overrides(SimpleNamespace(diffusion_lm_profile = "dream"), config)
+ assert config["packing"] is False
+
+
+ "overrides",
+ [
+ {"dataset_streaming": True, "max_steps": 2},
+ {"training_type": "Continued Pretraining"},
+ {"format_type": "raw"},
+ {"is_decision": True},
+ {"is_embedding": True},
+ ],
+)
+def test_unsupported_objectives_do_not_enable_an_omitted_completion_option(overrides):
+ values = {
+ "model_name": "unlisted/model",
+ "training_type": "LoRA/QLoRA",
+ "format_type": "auto",
+ **overrides,
+ }
+ assert TrainingStartRequest(**values).train_on_completions is False
+ # Explicit values are preserved; the existing route/trainer checks remain authoritative.
+ assert TrainingStartRequest(**values, train_on_completions = True).train_on_completions is True
diff --git a/studio/backend/utils/models/training_defaults.py b/studio/backend/utils/models/training_defaults.py
new file mode 100644
index 00000000000..545a95516e1
--- /dev/null
+++ b/studio/backend/utils/models/training_defaults.py
@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+
+def model_training_recommendations(
+ config: dict, *, is_vision: bool, is_audio: bool, is_embedding: bool, is_decision: bool
+) -> dict:
+ # Model-picker recommendations, not user opt-outs; data/objective restrictions apply later.
+ chat = not (is_embedding or is_decision or (is_audio and not is_vision))
+ return {
+ **config,
+ "training": {
+ **(config.get("training") or {}),
+ "packing": chat,
+ "train_on_completions": chat,
+ },
+ }
diff --git a/studio/frontend/src/config/training.ts b/studio/frontend/src/config/training.ts
index cdc981ea343..b0f02719c5e 100644
--- a/studio/frontend/src/config/training.ts
+++ b/studio/frontend/src/config/training.ts
@@ -171,8 +171,8 @@ export const DEFAULT_HYPERPARAMS = {
drafterEpochs: 1,
drafterLearningRate: null as number | null,
drafterDraftSteps: 3,
- packing: false,
- trainOnCompletions: false,
+ packing: true,
+ trainOnCompletions: true,
gradientCheckpointing: "unsloth" as const,
offloadLayers: 0 as number | "auto",
offloadVramGb: null as number | null,
diff --git a/studio/frontend/src/features/studio/sections/training-memory-params.tsx b/studio/frontend/src/features/studio/sections/training-memory-params.tsx
index 8e8513eeceb..64b60c1187f 100644
--- a/studio/frontend/src/features/studio/sections/training-memory-params.tsx
+++ b/studio/frontend/src/features/studio/sections/training-memory-params.tsx
@@ -47,7 +47,7 @@ function PackingOption({
<div className="flex items-center gap-2">
<Checkbox
id="packing"
- checked={checked}
+ checked={checked && !isMac}
disabled={isMac}
onCheckedChange={(value) => onChange(!!value)}
/>
diff --git a/studio/frontend/src/features/studio/wizard/advanced-settings-summary.ts b/studio/frontend/src/features/studio/wizard/advanced-settings-summary.ts
index 16dbb1ae6d3..cb112663ec0 100644
--- a/studio/frontend/src/features/studio/wizard/advanced-settings-summary.ts
+++ b/studio/frontend/src/features/studio/wizard/advanced-settings-summary.ts
@@ -10,13 +10,26 @@ import type {
AdvancedSettingsBaseline,
TrainingConfigState,
} from "@/features/training";
+import { trainingToggleDefaults } from "@/features/training/stores/training-config-policy";
import { isAdapterMethod } from "@/types/training";
type AdvancedSettingsState = Pick<
TrainingConfigState,
"trainingMethod" | keyof AdvancedSettingsBaseline
> &
- Partial<Pick<TrainingConfigState, "modelType">>;
+ Partial<
+ Pick<
+ TrainingConfigState,
+ | "modelType"
+ | "isVisionModel"
+ | "isAudioModel"
+ | "isEmbeddingModel"
+ | "isDatasetImage"
+ | "isDatasetAudio"
+ | "datasetStreaming"
+ | "datasetFormat"
+ >
+ >;
const SCALAR_DEFAULTS = {
optimizerType: DEFAULT_HYPERPARAMS.optimizerType,
@@ -79,14 +92,26 @@ function countNonDefaultScalarSettings(
state: AdvancedSettingsState,
baseline: AdvancedSettingsBaseline | null,
): number {
+ // Objective/data restrictions turn these off automatically; that is not a user change.
+ const automaticToggles = trainingToggleDefaults({
+ isVisionModel: state.isVisionModel ?? false,
+ isAudioModel: state.isAudioModel ?? false,
+ isEmbeddingModel: state.isEmbeddingModel ?? false,
+ isDatasetImage: state.isDatasetImage ?? null,
+ isDatasetAudio: state.isDatasetAudio ?? false,
+ modelType: state.modelType ?? null,
+ datasetStreaming: state.datasetStreaming ?? false,
+ datasetFormat: state.datasetFormat ?? "auto",
+ trainingMethod: state.trainingMethod,
+ });
return Object.entries(SCALAR_DEFAULTS).reduce((total, [rawKey, value]) => {
const key = rawKey as keyof typeof SCALAR_DEFAULTS;
if (isIgnored(state, key)) {
return total;
}
const expected =
- key === "trainOnCompletions" && state.trainingMethod === "cpt"
- ? false
+ key === "packing" || key === "trainOnCompletions"
+ ? baselineValue(baseline, key, value as boolean) && automaticToggles[key]
: baselineValue(baseline, key, value);
return state[key] === expected ? total : total + 1;
}, 0);
diff --git a/studio/frontend/src/features/training/stores/training-config-persistence.ts b/studio/frontend/src/features/training/stores/training-config-persistence.ts
index d141fadb16b..4373499fe8c 100644
--- a/studio/frontend/src/features/training/stores/training-config-persistence.ts
+++ b/studio/frontend/src/features/training/stores/training-config-persistence.ts
@@ -27,7 +27,7 @@ import {
} from "./training-config-policy";
export const TRAINING_CONFIG_PERSISTENCE_NAME = "unsloth_training_config_v1";
-export const TRAINING_CONFIG_PERSISTENCE_VERSION = 23;
+export const TRAINING_CONFIG_PERSISTENCE_VERSION = 24;
const NON_PERSISTED_STATE_KEYS: ReadonlySet<keyof TrainingConfigState> =
new Set([
@@ -450,11 +450,22 @@ export function mergeTrainingConfig(
baselineTrainOnCompletions === undefined
? modelDefaultsAppliedFor
: null;
+ const choices = persistedState.trainingToggleChoices;
+ const trainingToggleChoices: TrainingConfigState["trainingToggleChoices"] = {};
+ for (const key of ["packing", "trainOnCompletions"] as const) {
+ const explicit = choices?.[key];
+ if (typeof explicit === "boolean") trainingToggleChoices[key] = explicit;
+ // Older drafts did not record provenance. Preserve saved booleans instead of guessing away an opt-out.
+ else if (choices === undefined && typeof persistedState[key] === "boolean") {
+ trainingToggleChoices[key] = persistedState[key];
+ }
+ }
const merged: TrainingConfigStore = {
...current,
...persistedState,
wandbToken: current.wandbToken,
trainOnCompletions,
+ trainingToggleChoices,
modelDefaultsAppliedFor,
advancedSettingsBaseline,
trainOnCompletionsDefaultPendingFor,
diff --git a/studio/frontend/src/features/training/stores/training-config-policy.ts b/studio/frontend/src/features/training/stores/training-config-policy.ts
index 5ba7811ab1d..d5624ea3c08 100644
--- a/studio/frontend/src/features/training/stores/training-config-policy.ts
+++ b/studio/frontend/src/features/training/stores/training-config-policy.ts
@@ -105,6 +105,7 @@ export const initialTrainingConfigState: TrainingConfigState = {
modelDefaultsAppliedFor: null,
advancedSettingsBaseline: null,
trainOnCompletionsDefaultPendingFor: null,
+ trainingToggleChoices: {},
isCheckingDataset: false,
isDatasetImage: null,
isDatasetAudio: false,
@@ -198,3 +199,32 @@ export function formatStreamingDisabledOptions(
type: "conjunction",
}).format(options);
}
+
+
+/** Capabilities and training objectives decide these defaults, never a model-family whitelist. */
+export function trainingToggleDefaults(state: Pick<TrainingConfigState,
+ "isVisionModel" | "isAudioModel" | "isEmbeddingModel" | "isDatasetImage" |
+ "isDatasetAudio" | "modelType" | "datasetStreaming" | "datasetFormat" | "trainingMethod"
+>): { packing: boolean; trainOnCompletions: boolean } {
+ const decisionOrEmbedding = state.isEmbeddingModel || state.modelType === "decision";
+ const standaloneAudio = state.isAudioModel && !state.isVisionModel;
+ return {
+ // The image/audio collators consume examples directly; they do not use text sequence packing.
+ packing: !decisionOrEmbedding && !standaloneAudio &&
+ !(state.isVisionModel && (state.isDatasetImage === true || state.isDatasetAudio)),
+ trainOnCompletions: !decisionOrEmbedding && !standaloneAudio &&
+ !state.datasetStreaming && state.trainingMethod !== "cpt" &&
+ !isRawTextDatasetFormat(state.datasetFormat),
+ };
+}
+
+export function resolveTrainingToggleDefaults(state: Parameters<typeof trainingToggleDefaults>[0] &
+ Pick<TrainingConfigState, "trainingToggleChoices">
+): { packing: boolean; trainOnCompletions: boolean } {
+ const defaults = trainingToggleDefaults(state);
+ return {
+ packing: defaults.packing && (state.trainingToggleChoices?.packing ?? true),
+ trainOnCompletions: defaults.trainOnCompletions &&
+ (state.trainingToggleChoices?.trainOnCompletions ?? true),
+ };
+}
diff --git a/studio/frontend/src/features/training/stores/training-config-store.ts b/studio/frontend/src/features/training/stores/training-config-store.ts
index b4ae97c2bbb..6ff5c7542be 100644
--- a/studio/frontend/src/features/training/stores/training-config-store.ts
+++ b/studio/frontend/src/features/training/stores/training-config-store.ts
@@ -70,6 +70,8 @@ import {
hasSeparateStreamingEvalSplit,
initialTrainingConfigState,
resolveDeferredTrainOnCompletionsDefault,
+ resolveTrainingToggleDefaults,
+ trainingToggleDefaults,
streamingCompatiblePatch,
} from "./training-config-policy";
import { selectTrainingMethodForHardware } from "./training-method-hardware-policy";
@@ -408,7 +410,6 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
const modelDefaultsPatch = mapBackendModelConfigToTrainingPatch(
modelDetails.config,
);
- const patch = shouldApplyTrainingDefaults ? modelDefaultsPatch : {};
// A model-config LR is authoritative so async auto-select won't overwrite it.
const modelConfigHasLR =
@@ -423,18 +424,7 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
: LR_DEFAULT_FULL;
}
- if (modelDetails.is_vision && get().isDatasetImage === true) {
- modelDefaultsPatch.trainOnCompletions = false;
- }
-
const isAudio = !!modelDetails.is_audio;
- if (isAudio && !modelDetails.is_vision) {
- modelDefaultsPatch.trainOnCompletions = false;
- }
- if (isAudio && modelDetails.is_vision && get().isDatasetAudio) {
- modelDefaultsPatch.trainOnCompletions = false;
- }
-
const isEmbedding = !!modelDetails.is_embedding;
const inferredModelType = resolveTrainingModelType({
modelType: modelDetails.model_type,
@@ -443,6 +433,21 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
isVision: modelDetails.is_vision,
isAudio: modelDetails.is_audio,
});
+ const toggleState = {
+ ...get(),
+ isVisionModel: modelDetails.is_vision,
+ isAudioModel: isAudio,
+ isEmbeddingModel: isEmbedding,
+ modelType: inferredModelType,
+ };
+ // Shipped model recipes are recommendations, not an explicit user opting out.
+ Object.assign(modelDefaultsPatch, trainingToggleDefaults({
+ ...toggleState, trainingMethod: "qlora", datasetFormat: "auto", datasetStreaming: false,
+ }));
+ const patch: ModelDefaultsPatch = shouldApplyTrainingDefaults ? {
+ ...modelDefaultsPatch,
+ ...resolveTrainingToggleDefaults(toggleState),
+ } : {};
const decisionCheckpoints = isDecision
? (modelDetails.decision_checkpoints ?? null)
: null;
@@ -811,15 +816,9 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
};
if (!_trainOnCompletionsManuallySet) {
const { isVisionModel, isAudioModel } = current;
- if (isVisionModel && isImage) {
- updates.trainOnCompletions = false;
- }
if (isAudioModel && !isVisionModel) {
updates.trainOnCompletions = false;
}
- if (isAudioModel && isVisionModel && isAudio) {
- updates.trainOnCompletions = false;
- }
if (updates.trainOnCompletions === false) {
updates.trainingMethodProvenance = {
...current.trainingMethodProvenance,
@@ -827,6 +826,7 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
};
}
}
+ Object.assign(updates, resolveTrainingToggleDefaults({ ...current, ...updates }));
set(updates);
if (streamingDisabled) {
toast.info(
@@ -1085,6 +1085,9 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
modelDefaultsAppliedFor?: string | null;
advancedSettingsBaseline?: null;
trainOnCompletionsDefaultPendingFor?: null;
+ trainingToggleChoices?: TrainingConfigState["trainingToggleChoices"];
+ packing?: boolean;
+ trainOnCompletions?: boolean;
trainingMethodProvenance?: TrainingConfigState["trainingMethodProvenance"];
} = {
selectedModel,
@@ -1099,6 +1102,7 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
patch.modelType = effectiveModelType;
}
if (selectionChanged) {
+ patch.trainingToggleChoices = selectedModel !== previousModel ? {} : currentState.trainingToggleChoices;
patch.visionImageSize = DEFAULT_HYPERPARAMS.visionImageSize;
patch.trustRemoteCode = false;
patch.approvedRemoteCodeFingerprint = null;
@@ -1117,6 +1121,7 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
trainOnCompletionsBeforeCpt: null,
};
}
+ if (selectionChanged) Object.assign(patch, resolveTrainingToggleDefaults({ ...currentState, ...patch }));
setUserEdit(patch);
if (!selectedModel) {
@@ -1318,7 +1323,7 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
datasetFormat,
trainOnCompletions: isRawTextDatasetFormat(datasetFormat)
? false
- : state.trainOnCompletions,
+ : resolveTrainingToggleDefaults({ ...state, datasetFormat }).trainOnCompletions,
...(isRawTextDatasetFormat(datasetFormat)
? { trainOnCompletionsDefaultPendingFor: null }
: {}),
@@ -1451,6 +1456,7 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
}
setUserEdit({
datasetStreaming: false,
+ ...resolveTrainingToggleDefaults({ ...state, datasetStreaming: false }),
...(changed
? {
isDatasetImage: null,
@@ -1613,12 +1619,16 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
setUserEdit({ drafterDraftSteps }),
setDrafterCapability: (drafterCapability) =>
set({ drafterCapability }),
- setPacking: (packing) => setUserEdit({ packing }),
+ setPacking: (packing) => setUserEdit((state) => ({
+ packing,
+ trainingToggleChoices: { ...state.trainingToggleChoices, packing },
+ })),
setTrainOnCompletions: (trainOnCompletions) => {
_trainOnCompletionsManuallySet = true;
_trainOnCompletionsExplicitModel = get().selectedModel;
setUserEdit({
trainOnCompletions,
+ trainingToggleChoices: { ...get().trainingToggleChoices, trainOnCompletions },
trainOnCompletionsDefaultPendingFor: null,
...(trainOnCompletions ? { datasetStreaming: false } : {}),
});
@@ -1670,6 +1680,10 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
_trainOnCompletionsExplicitModel = selections.selectedModel;
setUserEdit({
...hyperparameters,
+ trainingToggleChoices: {
+ ...(typeof config.packing === "boolean" ? { packing: config.packing } : {}),
+ ...(typeof config.train_on_completions === "boolean" ? { trainOnCompletions: config.train_on_completions } : {}),
+ },
...selections,
earlyStoppingPatience: earlyStoppingPatienceFrom(
config.early_stopping_patience,
@@ -1700,6 +1714,7 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
setUserEdit({
modelDefaultsAppliedFor: null,
advancedSettingsBaseline: null,
+ trainingToggleChoices: {},
visionImageSize: DEFAULT_HYPERPARAMS.visionImageSize,
});
loadAndApplyModelDefaults(selectedModel, {
@@ -1728,6 +1743,15 @@ export const useTrainingConfigStore = create<TrainingConfigStore>()(
patch.trainOnCompletions !== undefined;
return {
...patch,
+ ...(patch.packing !== undefined || patch.trainOnCompletions !== undefined
+ ? {
+ trainingToggleChoices: {
+ ...state.trainingToggleChoices,
+ ...(patch.packing !== undefined ? { packing: patch.packing } : {}),
+ ...(patch.trainOnCompletions !== undefined ? { trainOnCompletions: patch.trainOnCompletions } : {}),
+ },
+ }
+ : {}),
...(importsPatience
? {
earlyStoppingPatience: earlyStoppingPatienceFrom(
diff --git a/studio/frontend/src/features/training/stores/training-method-transition.ts b/studio/frontend/src/features/training/stores/training-method-transition.ts
index e281919f559..26719c73243 100644
--- a/studio/frontend/src/features/training/stores/training-method-transition.ts
+++ b/studio/frontend/src/features/training/stores/training-method-transition.ts
@@ -109,8 +109,7 @@ function completionsAllowedOnExit(
>,
): boolean {
if (state.datasetStreaming || state.isEmbeddingModel) return false;
- if (state.isVisionModel && state.isDatasetImage === true) return false;
- if (state.isAudioModel && (!state.isVisionModel || state.isDatasetAudio)) {
+ if (state.isAudioModel && !state.isVisionModel) {
return false;
}
return true;
diff --git a/studio/frontend/src/features/training/types/config.ts b/studio/frontend/src/features/training/types/config.ts
index 613bf9004e8..de96df0fef5 100644
--- a/studio/frontend/src/features/training/types/config.ts
+++ b/studio/frontend/src/features/training/types/config.ts
@@ -143,6 +143,8 @@ export interface TrainingConfigState {
drafterCapability: DrafterCapability | null;
packing: boolean;
trainOnCompletions: boolean;
+ /** Explicit user/YAML choices, separate from automatic model and dataset defaults. */
+ trainingToggleChoices: { packing?: boolean; trainOnCompletions?: boolean };
gradientCheckpointing: GradientCheckpointing;
offloadLayers: OffloadLayers;
offloadVramGb: number | null;
diff --git a/studio/frontend/tests/advanced-settings-summary.test.ts b/studio/frontend/tests/advanced-settings-summary.test.ts
index 6ce37b51edc..c61cec32736 100644
--- a/studio/frontend/tests/advanced-settings-summary.test.ts
+++ b/studio/frontend/tests/advanced-settings-summary.test.ts
@@ -64,6 +64,7 @@ test("advanced settings summary uses method-aware LoRA defaults", () => {
countNonDefaultAdvancedSettings({
...defaultState,
trainingMethod: "cpt",
+ trainOnCompletions: false,
loraRank: 128,
loraAlpha: 32,
loraVariant: "rslora",
@@ -102,3 +103,27 @@ test("advanced settings summary distinguishes duplicate target modules", () => {
1,
);
});
+
+test("advanced settings summary does not count automatic packing and assistant-only restrictions", () => {
+ assert.equal(
+ countNonDefaultAdvancedSettings({
+ ...defaultState,
+ isVisionModel: true,
+ isDatasetImage: true,
+ packing: false,
+ }),
+ 0,
+ );
+ assert.equal(
+ countNonDefaultAdvancedSettings({
+ ...defaultState,
+ datasetStreaming: true,
+ trainOnCompletions: false,
+ }),
+ 0,
+ );
+ assert.equal(
+ countNonDefaultAdvancedSettings({ ...defaultState, packing: false }),
+ 1,
+ );
+});
diff --git a/studio/frontend/tests/training-config-persistence.test.ts b/studio/frontend/tests/training-config-persistence.test.ts
index a66b64df9c5..af4e467897a 100644
--- a/studio/frontend/tests/training-config-persistence.test.ts
+++ b/studio/frontend/tests/training-config-persistence.test.ts
@@ -68,7 +68,7 @@ test("migration preserves tuned values while protecting them from model defaults
16,
);
- assert.equal(TRAINING_CONFIG_PERSISTENCE_VERSION, 23);
+ assert.equal(TRAINING_CONFIG_PERSISTENCE_VERSION, 24);
assert.equal(migrated.learningRate, 0.000031);
assert.equal(migrated.loraRank, 48);
assert.equal(migrated.modelDefaultsAppliedFor, "org/model");
@@ -417,3 +417,33 @@ test("a baseline left over from another model is not used as pre-CPT params", ()
assert.equal(migrated.trainingMethodProvenance.loraRankBeforeCpt, undefined);
});
+
+
+test("explicit false training toggle choices survive persistence and hydration", () => {
+ const stored = {
+ packing: false, trainOnCompletions: false,
+ trainingToggleChoices: { packing: false, trainOnCompletions: false },
+ };
+ const merged = mergeTrainingConfig(stored, {
+ trainingMethod: "qlora", packing: true, trainOnCompletions: true,
+ } as never);
+ assert.deepEqual(merged.trainingToggleChoices, stored.trainingToggleChoices);
+ assert.equal(merged.packing, false);
+ assert.equal(merged.trainOnCompletions, false);
+ const again = partializeTrainingConfig(merged);
+ assert.deepEqual(again.trainingToggleChoices, stored.trainingToggleChoices);
+});
+
+test("legacy saved false values remain opt-outs when their provenance is unknown", () => {
+ const merged = mergeTrainingConfig({ packing: false, trainOnCompletions: false }, {
+ trainingMethod: "qlora", packing: true, trainOnCompletions: true,
+ } as never);
+ assert.deepEqual(merged.trainingToggleChoices, { packing: false, trainOnCompletions: false });
+});
+
+test("automatic disabled values are not promoted into explicit choices", () => {
+ const merged = mergeTrainingConfig({
+ packing: false, trainOnCompletions: false, trainingToggleChoices: {},
+ }, { trainingMethod: "qlora", packing: true, trainOnCompletions: true } as never);
+ assert.deepEqual(merged.trainingToggleChoices, {});
+});
diff --git a/studio/frontend/tests/training-config-policy.test.ts b/studio/frontend/tests/training-config-policy.test.ts
index d80efa5c9ce..3f435a82763 100644
--- a/studio/frontend/tests/training-config-policy.test.ts
+++ b/studio/frontend/tests/training-config-policy.test.ts
@@ -14,6 +14,8 @@ const {
datasetSourceInvariantPatch,
initialTrainingConfigState,
resolveDeferredTrainOnCompletionsDefault,
+ trainingToggleDefaults,
+ resolveTrainingToggleDefaults,
} = await import("../src/features/training/stores/training-config-policy.ts");
test("selecting an on-device Hub dataset disables streaming", () => {
@@ -121,3 +123,18 @@ test("resolves deferred completion defaults without violating training constrain
false,
);
});
+
+
+test("training objectives and data capabilities constrain enabled defaults", () => {
+ const base = { ...initialTrainingConfigState, modelType: "text" as const };
+ assert.deepEqual(trainingToggleDefaults(base), { packing: true, trainOnCompletions: true });
+ assert.deepEqual(trainingToggleDefaults({ ...base, isVisionModel: true }), { packing: true, trainOnCompletions: true });
+ assert.deepEqual(trainingToggleDefaults({ ...base, isVisionModel: true, isDatasetImage: true }), { packing: false, trainOnCompletions: true });
+ for (const patch of [{ isEmbeddingModel: true }, { modelType: "decision" as const }, { isAudioModel: true }]) {
+ assert.deepEqual(trainingToggleDefaults({ ...base, ...patch }), { packing: false, trainOnCompletions: false });
+ }
+ for (const patch of [{ datasetStreaming: true }, { datasetFormat: "raw" as const }, { trainingMethod: "cpt" as const }]) {
+ assert.equal(trainingToggleDefaults({ ...base, ...patch }).trainOnCompletions, false);
+ }
+ assert.deepEqual(resolveTrainingToggleDefaults({ ...base, trainingToggleChoices: { packing: false, trainOnCompletions: false } }), { packing: false, trainOnCompletions: false });
+});
diff --git a/studio/frontend/tests/training-cpt-model-switch.test.ts b/studio/frontend/tests/training-cpt-model-switch.test.ts
index dba72e8173e..15d57ca10ba 100644
--- a/studio/frontend/tests/training-cpt-model-switch.test.ts
+++ b/studio/frontend/tests/training-cpt-model-switch.test.ts
@@ -632,7 +632,9 @@ test("an empty model config does not invent a modified target-modules setting",
}),
),
);
- useTrainingConfigStore.getState().selectTrainingModel("org/no-defaults", "text");
+ useTrainingConfigStore
+ .getState()
+ .selectTrainingModel("org/no-defaults", "text");
await waitForModelDefaults("org/no-defaults");
const inCpt = useTrainingConfigStore.getState();
@@ -820,7 +822,7 @@ test("a reload inside CPT keeps the pre-CPT LoRA params the session saved", asyn
assert.equal(state.loraVariant, "dora");
});
-test("leaving CPT after a model switch does not restore the old model's train on completions", async () => {
+test("a new model recipe opt-out does not override the assistant-only default on CPT exit", async () => {
useTrainingConfigStore.getState().reset();
const defaultsWith = (id: string, trainOnCompletions: boolean) => () =>
Promise.resolve(
@@ -848,7 +850,7 @@ test("leaving CPT after a model switch does not restore the old model's train on
await waitForModelDefaults("new/model");
useTrainingConfigStore.getState().setTrainingMethod("qlora");
- assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, true);
});
test("leaving CPT after switching to a model whose default is on turns train on completions back on", async () => {
@@ -909,7 +911,7 @@ test("leaving CPT while the new model's defaults are loading does not restore th
assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
});
-test("an image dataset picked inside CPT keeps train on completions off for a vision model", async () => {
+test("an image dataset picked inside CPT restores assistant-only training for a vision model", async () => {
useTrainingConfigStore.getState().reset();
setAuthFetchHandler((input, init) => {
if (input === "/api/hub/datasets/check-format") {
@@ -954,7 +956,7 @@ test("an image dataset picked inside CPT keeps train on completions off for a vi
assert.equal(useTrainingConfigStore.getState().isDatasetImage, true);
useTrainingConfigStore.getState().setTrainingMethod("qlora");
- assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, true);
});
const completionDefaults = (id: string, isAudio: boolean) =>
@@ -1152,7 +1154,7 @@ async function settleStore(): Promise<void> {
throw new Error("store did not settle");
}
-test("a model found to be vision inside CPT keeps completions off for an image dataset", async () => {
+test("a model found to be vision inside CPT restores completions for an image dataset", async () => {
useTrainingConfigStore.getState().reset();
let isVision = false;
setAuthFetchHandler((input) =>
@@ -1178,7 +1180,7 @@ test("a model found to be vision inside CPT keeps completions off for an image d
assert.equal(useTrainingConfigStore.getState().isVisionModel, true);
useTrainingConfigStore.getState().setTrainingMethod("qlora");
- assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, true);
});
test("an opt-out made while defaults load survives a CPT round trip", async () => {
@@ -1203,7 +1205,7 @@ test("an opt-out made while defaults load survives a CPT round trip", async () =
assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
});
-test("an image split picked inside CPT keeps completions off after manual toggles", async () => {
+test("an image split picked inside CPT preserves the assistant-only choice after manual toggles", async () => {
useTrainingConfigStore.getState().reset();
setAuthFetchHandler((input, init) =>
input === "/api/hub/datasets/check-format"
@@ -1223,7 +1225,7 @@ test("an image split picked inside CPT keeps completions off after manual toggle
assert.equal(useTrainingConfigStore.getState().isDatasetImage, true);
useTrainingConfigStore.getState().setTrainingMethod("qlora");
- assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, true);
});
test("a manual toggle on the previous model does not decide the next model's CPT restore", async () => {
@@ -1260,7 +1262,7 @@ test("a manual toggle on the previous model does not decide the next model's CPT
await settleStore();
useTrainingConfigStore.getState().setTrainingMethod("qlora");
- assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, true);
});
test("a config imported while defaults load survives entering and leaving CPT", async () => {
@@ -1283,3 +1285,116 @@ test("a config imported while defaults load survives entering and leaving CPT",
useTrainingConfigStore.getState().setTrainingMethod("qlora");
assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
});
+
+test("image and audio VLM datasets keep assistant-only defaults for arbitrary model families", async () => {
+ for (const modality of ["image", "audio"] as const) {
+ for (const datasetFirst of [true, false]) {
+ useTrainingConfigStore.getState().reset();
+ setAuthFetchHandler((input) =>
+ input === "/api/hub/datasets/check-format"
+ ? Response.json({
+ columns: ["messages"],
+ detected_format: "chatml",
+ is_audio: modality === "audio",
+ is_image: modality === "image",
+ requires_manual_mapping: false,
+ })
+ : Response.json({
+ id: "custom/new-architecture",
+ config: { training: { train_on_completions: true } },
+ is_vision: true,
+ is_audio: modality === "audio",
+ audio_type_known: true,
+ model_type: "vision",
+ }),
+ );
+ if (datasetFirst) {
+ useTrainingConfigStore.getState().setDataset("custom/conversations");
+ for (let attempt = 0; attempt < 100; attempt += 1) {
+ if (!useTrainingConfigStore.getState().isCheckingDataset) break;
+ await new Promise((resolve) => setTimeout(resolve, 5));
+ }
+ }
+ useTrainingConfigStore
+ .getState()
+ .selectTrainingModel("custom/new-architecture", "vision");
+ await settleStore();
+ if (!datasetFirst) {
+ useTrainingConfigStore.getState().setDataset("custom/conversations");
+ await settleStore();
+ }
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, true);
+
+ // Explicit choices win over modality detection and repeated model probes.
+ useTrainingConfigStore.getState().setTrainOnCompletions(false);
+ useTrainingConfigStore
+ .getState()
+ .setDataset("custom/other-conversations");
+ await settleStore();
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
+ useTrainingConfigStore.getState().applyConfigPatch({
+ training: { train_on_completions: false },
+ });
+ useTrainingConfigStore
+ .getState()
+ .setDataset("custom/imported-conversations");
+ await settleStore();
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
+ }
+ }
+});
+
+
+test("fresh and recommended defaults enable packing and assistant-only training for any chat model", async () => {
+ useTrainingConfigStore.getState().reset();
+ assert.equal(useTrainingConfigStore.getState().packing, true);
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, true);
+ setAuthFetchHandler(() => Response.json({
+ id: "new-organization/unlisted-chat-architecture",
+ config: { training: { packing: false, train_on_completions: false } },
+ is_vision: false, is_embedding: false, is_audio: false, audio_type_known: true,
+ is_lora: false, model_type: "text", model_size_bytes: null,
+ }));
+ useTrainingConfigStore.getState().selectTrainingModel("new-organization/unlisted-chat-architecture", "text");
+ await waitForModelDefaults("new-organization/unlisted-chat-architecture");
+ assert.equal(useTrainingConfigStore.getState().packing, true);
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, true);
+ assert.deepEqual(useTrainingConfigStore.getState().trainingToggleChoices, {});
+});
+
+test("user opt-outs survive capability refresh and reset returns to enabled defaults", async () => {
+ useTrainingConfigStore.getState().reset();
+ setAuthFetchHandler(() => completionModel("example/chat", false));
+ useTrainingConfigStore.getState().selectTrainingModel("example/chat", "text");
+ await waitForModelDefaults("example/chat");
+ useTrainingConfigStore.getState().setPacking(false);
+ useTrainingConfigStore.getState().setTrainOnCompletions(false);
+ useTrainingConfigStore.getState().setSelectedModelCacheReference("example/chat", { modelFormat: null, localPath: "/cache/model" });
+ await settleStore();
+ assert.equal(useTrainingConfigStore.getState().packing, false);
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
+ useTrainingConfigStore.getState().resetToModelDefaults();
+ await waitForModelDefaults("example/chat");
+ assert.equal(useTrainingConfigStore.getState().packing, true);
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, true);
+});
+
+test("YAML opt-outs survive a raw-text or streaming round trip", async () => {
+ useTrainingConfigStore.getState().reset();
+ useTrainingConfigStore.getState().applyConfigPatch({ training: { packing: false, train_on_completions: false } });
+ useTrainingConfigStore.getState().setDatasetFormat("raw");
+ useTrainingConfigStore.getState().setDatasetFormat("chatml");
+ useTrainingConfigStore.getState().setDatasetStreaming(true);
+ useTrainingConfigStore.getState().setDatasetStreaming(false);
+ assert.equal(useTrainingConfigStore.getState().packing, false);
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
+ assert.deepEqual(useTrainingConfigStore.getState().trainingToggleChoices, { packing: false, trainOnCompletions: false });
+});
+
+test("an unanswered assistant-only default returns when leaving raw text", () => {
+ useTrainingConfigStore.getState().reset();
+ useTrainingConfigStore.getState().setDatasetFormat("raw");
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, false);
+ useTrainingConfigStore.getState().setDatasetFormat("chatml");
+ assert.equal(useTrainingConfigStore.getState().trainOnCompletions, true);
+});
diff --git a/studio/frontend/tests/training-start-payload-drafter.test.ts b/studio/frontend/tests/training-start-payload-drafter.test.ts
index d1dbee0d2a3..65f73c86dfc 100644
--- a/studio/frontend/tests/training-start-payload-drafter.test.ts
+++ b/studio/frontend/tests/training-start-payload-drafter.test.ts
@@ -166,7 +166,7 @@ test("half-typed fields are clamped into the backend's bounds", () => {
});
test("persisted state from before drafter training migrates to the feature off", () => {
- assert.equal(TRAINING_CONFIG_PERSISTENCE_VERSION, 23);
+ assert.equal(TRAINING_CONFIG_PERSISTENCE_VERSION, 24);
const migrated = migrateTrainingConfig(
{ selectedModel: MODEL, trainingMethod: "lora" },
22,