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
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.yamlindex 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: 0weight_decay: 0.001random_seed: 3407- packing: false- train_on_completions: false+ packing: true+ train_on_completions: truegradient_checkpointing: "unsloth"lora:diff --git a/studio/backend/assets/configs/lora_text.yaml b/studio/backend/assets/configs/lora_text.yamlindex 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: 0weight_decay: 0.001random_seed: 3407- packing: false- train_on_completions: false+ packing: true+ train_on_completions: truegradient_checkpointing: "unsloth"lora:diff --git a/studio/backend/assets/configs/model_defaults/default.yaml b/studio/backend/assets/configs/model_defaults/default.yamlindex 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: 30weight_decay: 0.001random_seed: 3407- packing: false+ packing: truetrain_on_completions: truegradient_checkpointing: "unsloth"optim: "adamw_8bit"diff --git a/studio/backend/assets/configs/vision_lora.yaml b/studio/backend/assets/configs/vision_lora.yamlindex 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.001random_seed: 3407packing: false- train_on_completions: false+ train_on_completions: truegradient_checkpointing: "unsloth"lora:diff --git a/studio/backend/core/training/trainer.py b/studio/backend/core/training/trainer.pyindex 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_lendrop_pct = (round(100 * dropped / original_len, 1) if original_len > 0 else 0diff --git a/studio/backend/core/training/training.py b/studio/backend/core/training/training.pyindex 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.pyindex 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 = Falseformat_type: str = "auto"custom_format_mapping: Optional[Dict[str, Any]] = None- train_on_completions: bool = False+ train_on_completions: bool = Trueis_cpt: bool = Falsemax_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.pyindex 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.pynew file mode 100644index 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 Truediff --git a/studio/backend/utils/models/training_defaults.py b/studio/backend/utils/models/training_defaults.pynew file mode 100644index 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.tsindex 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.tsxindex 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"><Checkboxid="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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 defaults16,);- 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.tsindex 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 constrainfalse,);});+++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.tsindex 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", asynassert.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 onawait 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 thassert.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 viassert.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 dassert.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 toggleassert.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 CPTawait 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.tsindex 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,