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: 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.py
index 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 annotations
import re
from typing import Any, Optional
-from utils.datasets.cells import text_cell_check
+from utils.datasets.cells import text_cell_check, unwrap_message_column
from utils.datasets.format_detection import detect_dataset_format, has_message_prompt_completion
from 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[str
def format_dataset_preview(dataset):
detected = detect_dataset_format(dataset)
- if detected.get("format") != "sharegpt":
- return dataset
chat_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 dataset
diff --git a/studio/backend/tests/test_dataset_check_chat_column.py b/studio/backend/tests/test_dataset_check_chat_column.py
index 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.py
new file mode 100644
index 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.py
index 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 [
message
diff --git a/studio/backend/utils/datasets/dataset_utils.py b/studio/backend/utils/datasets/dataset_utils.py
index 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_column
from .raw_text import prepare_raw_text_dataset
from .pretokenized import PRETOKENIZED_FORMAT, is_pretokenized_dataset
from .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.py
index 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 = False
has_sharegpt = False
@@ -52,7 +58,7 @@ def _inspect_conversation_column(rows: list[dict], column_name: str) -> dict | N
for 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:
continue
for turn in chat_data:
@@ -89,11 +95,15 @@ def _inspect_conversation_column(rows: list[dict], column_name: str) -> dict | N
return 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 False
for 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 True
return 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 None
unknown_exact = None
for 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 inspected
if inspected and unknown_exact is None:
@@ -125,7 +139,7 @@ def _detect_conversation_column(rows: list[dict], column_names: list[str]) -> di
for 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 = wrapped
if conversation:
return conversation
diff --git a/tests/studio/test_pdf_qa_recipe_contract.py b/tests/studio/test_pdf_qa_recipe_contract.py
index 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 os
import re
import sys
import threading
+import types
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from 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.loader
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)