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: train a structured column's conversation as a multi-turn chat (#13940)
Nilayf75efb9d8ee7
diff --git a/studio/backend/hub/utils/dataset_format.py b/studio/backend/hub/utils/dataset_format.pyindex 656be159e46..9268490d4a8 100644--- a/studio/backend/hub/utils/dataset_format.py+++ b/studio/backend/hub/utils/dataset_format.py@@ -6,7 +6,7 @@ from __future__ import annotationsimport refrom typing import Any, Optional-from utils.datasets.cells import text_cell_check+from utils.datasets.cells import text_cell_check, unwrap_message_columnfrom utils.datasets.format_detection import detect_dataset_format, has_message_prompt_completionfrom utils.datasets.pretokenized import PRETOKENIZED_FORMAT, is_pretokenized_dataset@@ -882,12 +882,14 @@ def _standardize_sharegpt_row(row: dict[str, Any], chat_column: str) -> dict[strdef format_dataset_preview(dataset):detected = detect_dataset_format(dataset)- if detected.get("format") != "sharegpt":- return datasetchat_column = detected.get("chat_column")- if not isinstance(chat_column, str):+ if (+ detected.get("format") not in ("chatml", "sharegpt")+ or not isinstance(chat_column, str)+ or not hasattr(dataset, "map")+ ):return dataset-- if hasattr(dataset, "map"):+ dataset = unwrap_message_column(dataset, chat_column)+ if detected["format"] == "sharegpt":return dataset.map(lambda row: _standardize_sharegpt_row(row, chat_column))return datasetdiff --git a/studio/backend/tests/test_dataset_check_chat_column.py b/studio/backend/tests/test_dataset_check_chat_column.pyindex 34df3489b72..c5ffeab6f61 100644--- a/studio/backend/tests/test_dataset_check_chat_column.py+++ b/studio/backend/tests/test_dataset_check_chat_column.py@@ -33,6 +33,12 @@ _CASES = [pytest.param([{"messages": []}, {"messages": _CHATML}], "chatml", "messages", id = "empty-first-row"),+ pytest.param(+ [{"dialog": _CHATML, "output_format": {"conversation": _SHAREGPT}}],+ "chatml",+ "dialog",+ id = "plain-over-wrapped",+ ),]diff --git a/studio/backend/tests/test_nested_conversation_column.py b/studio/backend/tests/test_nested_conversation_column.pynew file mode 100644index 00000000000..f56df116a53--- /dev/null+++ b/studio/backend/tests/test_nested_conversation_column.py@@ -0,0 +1,111 @@+# 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 json++import pytest+from datasets import Dataset, IterableDataset, load_dataset++from hub.utils.dataset_format import check_dataset_format, format_dataset_preview+from utils.datasets import format_dataset++_CONVERSATION = [+ {"role": "user", "content": "Help me budget."},+ {"role": "assistant", "content": "What is your monthly income?"},+ {"role": "user", "content": "3000, rent is 1000."},+ {"role": "assistant", "content": "Save 600 and keep 1400 for the rest."},+]+_SHAREGPT = [+ {"from": "human" if turn["role"] == "user" else "gpt", "value": turn["content"]}+ for turn in _CONVERSATION+]+_WRAPPERS = pytest.mark.parametrize(+ "wrapped",+ [{"conversation": _CONVERSATION}, {"messages": _SHAREGPT}],+ ids = ["role_content", "from_value"],+)+++def _recipe_output(wrapped):+ return Dataset.from_list([{"user_goal": "Plan a monthly budget.", "output_format": wrapped}])+++ "wrapped, expected",+ [({"conversation": _CONVERSATION}, "chatml"), ({"messages": _SHAREGPT}, "sharegpt")],+ ids = ["role_content", "from_value"],+)+def test_check_detects_a_conversation_wrapped_in_a_structured_column(wrapped, expected):+ result = check_dataset_format(_recipe_output(wrapped))++ assert result["detected_format"] == expected+ assert result["chat_column"] == "output_format"+ assert result["suggested_mapping"] is None+++@_WRAPPERS+def test_wrapped_conversation_trains_as_its_turns(wrapped):+ result = format_dataset(_recipe_output(wrapped))++ assert result["chat_column"] == "output_format"+ assert result["dataset"][0]["output_format"] == _CONVERSATION+++@_WRAPPERS+def test_streamed_wrapped_conversation_trains_as_its_turns(wrapped):+ rows = [{"user_goal": "Plan a monthly budget.", "output_format": wrapped}]+ result = format_dataset(IterableDataset.from_generator(lambda: iter(rows)))++ assert next(iter(result["dataset"]))["output_format"] == _CONVERSATION+++@_WRAPPERS+def test_mapped_wrapped_conversation_trains_as_its_turns(wrapped):+ result = format_dataset(+ _recipe_output(wrapped), custom_format_mapping = {"output_format": "assistant"}+ )++ assert result["dataset"][0]["conversations"] == _CONVERSATION+++def test_single_field_object_without_messages_still_trains_as_json():+ row = {"question": "Name two colors.", "answer": {"colors": ["red", "blue"]}}+ result = format_dataset(Dataset.from_list([row]))++ assert result["dataset"][0]["conversations"][-1]["content"] == '{"colors": ["red", "blue"]}'++[email protected]("batch_size", [1000, 1])+def test_empty_wrapped_conversation_does_not_break_the_dataset(tmp_path, batch_size):+ rows = [+ {"user_goal": "Nothing came back.", "output_format": {}},+ {"user_goal": "Plan a monthly budget.", "output_format": {"conversation": _CONVERSATION}},+ ]+ path = tmp_path / "recipe.jsonl"+ path.write_text("\n".join(json.dumps(row) for row in rows))+ dataset = load_dataset("json", data_files = str(path), split = "train")++ result = format_dataset(dataset, batch_size = batch_size)++ assert result["chat_column"] == "output_format"+ assert result["dataset"]["output_format"] == [None, _CONVERSATION]+++@_WRAPPERS+def test_preview_shows_the_wrapped_conversation_as_its_turns(wrapped):+ preview = format_dataset_preview(_recipe_output(wrapped))++ assert preview[0]["output_format"] == _CONVERSATION++[email protected]("empty", [[], None])+def test_mapped_empty_wrapped_conversation_adds_no_turns(empty):+ rows = [+ {"output_format": {"conversation": _CONVERSATION}},+ {"output_format": {"conversation": empty}},+ ]+ result = format_dataset(+ Dataset.from_list(rows), custom_format_mapping = {"output_format": "assistant"}+ )++ assert result["dataset"]["conversations"] == [_CONVERSATION, []]diff --git a/studio/backend/utils/datasets/cells.py b/studio/backend/utils/datasets/cells.pyindex 7afbfbb1ccd..3cd8c01156c 100644--- a/studio/backend/utils/datasets/cells.py+++ b/studio/backend/utils/datasets/cells.py@@ -71,10 +71,41 @@ def _message(turn):return None+def wrapped_messages(value):+ if isinstance(value, dict) and len(value) == 1:+ (inner,) = value.values()+ if inner is None or isinstance(inner, list):+ return inner+ return value+++def unwrap_message_column(+ dataset,+ column,+ batch_size = 1000,+):+ features = getattr(dataset, "features", None)+ feature = features.get(column) if features else None+ if column is None or (features and not (isinstance(feature, dict) and len(feature) == 1)):+ return dataset+ if features:+ from datasets import Features+ (inner,) = feature.values()+ features = Features({**features, column: inner})+ return dataset.map(+ lambda batch: {column: [wrapped_messages(value) for value in batch[column]]},+ batched = True,+ batch_size = batch_size,+ features = features,+ )++def message_list_columns(dataset):features = getattr(dataset, "features", None) or {}columns = set()for column, feature in features.items():+ if isinstance(feature, dict) and len(feature) == 1:+ (feature,) = feature.values()item = getattr(feature, "feature", None)if item is None and isinstance(feature, list) and len(feature) == 1:item = feature[0]@@ -90,7 +121,10 @@ def cell_turns(role,empty_is_messages = False,):- messages = [_message(turn) for turn in value] if isinstance(value, list) else [None]+ turns = wrapped_messages(value)+ if turns is None and value is not None and empty_is_messages:+ turns = []+ messages = [_message(turn) for turn in turns] if isinstance(turns, list) else [None]if (messages or empty_is_messages) and all(message is not None for message in messages):return [messagediff --git a/studio/backend/utils/datasets/dataset_utils.py b/studio/backend/utils/datasets/dataset_utils.pyindex 77bee72f0ec..b853403c6fd 100644--- a/studio/backend/utils/datasets/dataset_utils.py+++ b/studio/backend/utils/datasets/dataset_utils.py@@ -26,7 +26,7 @@ from .chat_templates import (get_tokenizer_chat_template,DEFAULT_ALPACA_TEMPLATE,)-from .cells import cell_text, cell_turns, message_list_columns+from .cells import cell_text, cell_turns, message_list_columns, unwrap_message_columnfrom .raw_text import prepare_raw_text_datasetfrom .pretokenized import PRETOKENIZED_FORMAT, is_pretokenized_datasetfrom .vlm_processing import generate_smart_vlm_instruction@@ -488,6 +488,7 @@ def _format_dataset(}detected = detect_dataset_format(dataset)+ dataset = unwrap_message_column(dataset, detected["chat_column"], batch_size)warnings = []if multimodal_info["is_image"]:diff --git a/studio/backend/utils/datasets/format_detection.py b/studio/backend/utils/datasets/format_detection.pyindex fbc237704b6..fe29b161f86 100644--- a/studio/backend/utils/datasets/format_detection.py+++ b/studio/backend/utils/datasets/format_detection.py@@ -5,6 +5,8 @@import re+from .cells import wrapped_messages+def _keyword_in_column(keyword: str, col_name: str) -> bool:"""Word-boundary keyword match to avoid false positives like 'pic' in 'topic'."""@@ -44,7 +46,11 @@ def _is_trace_conversation_name(column_name: str) -> bool:return column_name.lower().endswith(_TRACE_SUFFIXES)-def _inspect_conversation_column(rows: list[dict], column_name: str) -> dict | None:+def _inspect_conversation_column(+ rows: list[dict],+ column_name: str,+ unwrap: bool = False,+) -> dict | None:turn_keys: set[str] = set()has_chatml = Falsehas_sharegpt = False@@ -52,7 +58,7 @@ def _inspect_conversation_column(rows: list[dict], column_name: str) -> dict | Nfor row in rows:if not isinstance(row, dict) or column_name not in row:continue- chat_data = row[column_name]+ chat_data = wrapped_messages(row[column_name]) if unwrap else row[column_name]if not isinstance(chat_data, list) or len(chat_data) == 0:continuefor turn in chat_data:@@ -89,11 +95,15 @@ def _inspect_conversation_column(rows: list[dict], column_name: str) -> dict | Nreturn None-def _has_message_prompt_completion(rows: list[dict], column_names: list[str]) -> bool:+def _has_message_prompt_completion(+ rows: list[dict],+ column_names: list[str],+ unwrap: bool = False,+) -> bool:if not {"prompt", "completion"} <= set(column_names):return Falsefor column_name in ("prompt", "completion"):- inspected = _inspect_conversation_column(rows, column_name)+ inspected = _inspect_conversation_column(rows, column_name, unwrap)if inspected and inspected["format"] in {"sharegpt", "chatml"}:return Truereturn False@@ -102,20 +112,24 @@ def _has_message_prompt_completion(rows: list[dict], column_names: list[str]) ->def has_message_prompt_completion(dataset) -> bool:rows = _sample_dataset_rows(dataset)return bool(rows) and _has_message_prompt_completion(- rows, _get_dataset_column_names(dataset, rows[0])+ rows, _get_dataset_column_names(dataset, rows[0]), unwrap = True)-def _detect_conversation_column(rows: list[dict], column_names: list[str]) -> dict | None:+def _detect_conversation_column(+ rows: list[dict],+ column_names: list[str],+ unwrap: bool = False,+) -> dict | None:column_name_set = set(column_names)- if _has_message_prompt_completion(rows, column_names):+ if _has_message_prompt_completion(rows, column_names, unwrap):return Noneunknown_exact = Nonefor column_name in CONVERSATION_COLUMNS:if column_name not in column_name_set:continue- inspected = _inspect_conversation_column(rows, column_name)+ inspected = _inspect_conversation_column(rows, column_name, unwrap)if inspected and inspected["format"] in {"sharegpt", "chatml"}:return inspectedif inspected and unknown_exact is None:@@ -125,7 +139,7 @@ def _detect_conversation_column(rows: list[dict], column_names: list[str]) -> difor column_name in column_names:if column_name in CONVERSATION_COLUMNS:continue- inspected = _inspect_conversation_column(rows, column_name)+ inspected = _inspect_conversation_column(rows, column_name, unwrap)if inspected and inspected["format"] in {"sharegpt", "chatml"}:structural_candidates.append(inspected)@@ -169,6 +183,11 @@ def detect_dataset_format(dataset):}conversation = _detect_conversation_column(sample_rows, column_names)+ if conversation is None or conversation["format"] == "unknown":+ # A chat wrapped in a one-field object counts only when no plain chat column does.+ wrapped = _detect_conversation_column(sample_rows, column_names, unwrap = True)+ if wrapped and wrapped["format"] != "unknown":+ conversation = wrappedif conversation:return conversationdiff --git a/tests/studio/test_pdf_qa_recipe_contract.py b/tests/studio/test_pdf_qa_recipe_contract.pyindex 7b715c1adc0..5b3b2bfba85 100644--- a/tests/studio/test_pdf_qa_recipe_contract.py+++ b/tests/studio/test_pdf_qa_recipe_contract.py@@ -12,6 +12,7 @@ import osimport reimport sysimport threading+import typesfrom http.server import BaseHTTPRequestHandler, ThreadingHTTPServerfrom pathlib import Path@@ -123,8 +124,14 @@ def test_pdf_qa_fields_match_studio_alpaca_mapping():assert 'return roles.has("instruction") && roles.has("output");' in manual_mapping-def test_pdf_qa_fields_are_detected_as_alpaca():- spec = importlib.util.spec_from_file_location("_pdf_qa_format_detection", FORMAT_DETECTION_PATH)+def test_pdf_qa_fields_are_detected_as_alpaca(monkeypatch):+ # A bare package resolves format_detection's sibling imports without running utils.datasets.+ package = types.ModuleType("_pdf_qa_datasets")+ package.__path__ = [str(FORMAT_DETECTION_PATH.parent)]+ monkeypatch.setitem(sys.modules, package.__name__, package)+ spec = importlib.util.spec_from_file_location(+ "_pdf_qa_datasets.format_detection", FORMAT_DETECTION_PATH+ )assert spec and spec.loadermodule = importlib.util.module_from_spec(spec)spec.loader.exec_module(module)