Ling-Ting-SFT-Augment

An augmented supervised fine-tuning dataset for Ling-3.0-tiny composite payment experiments. Given an order, payment channel balances, and promotions, the model calculates the payment plan for the selected channel and recommends the feasible option with the largest discount, returning a structured JSON result.

The release packages the fixed data used in the completed experiments: 1,115 training examples, 100 validation examples, and 500 test cases. Its fields follow AsystemAReno/Ling-Tiny-SFT, with additional messages and source fields for chat-template training and provenance tracking.

This release preserves the original experiment data. Training and validation messages, example order, and test inputs and answers are unchanged. Packaging adds publication metadata without splitting, cleaning, or generating additional examples. The added fields change the file SHA-256 checksums; manifest.json records checksums for both the original inputs and the published files.

All examples are generated programmatically and contain no real transaction records. Training targets contain <think>...</think> followed by the final JSON. The reasoning text is produced from deterministic payment-service traces and compression rules, without LLM distillation.

Known data issues: the original reasoning compressor extracts an incorrect amount for the payable= label. Among successful examples where this label can be checked, all 1,049 training examples and 86 validation examples disagree with the payable amount in the final JSON. These texts are retained to preserve the experiment data. All 1,715 final JSON answers have been checked against the original reference payment service and match its outputs. In addition, five test cases share business inputs with training examples; evaluation should report results on both the full 500-case set and the 495 cases without training-input overlap.

Files and Splits

Ling-Ting-SFT-Augment/
├── README.md
├── train.jsonl          # 1,115 examples: train
├── valid.jsonl          # 100 examples: validation
├── eval500.jsonl        # 500 cases: test
├── system_prompt.txt    # Shared rules, already included in each example
└── manifest.json        # Provenance, statistics, checksums, and data audits

Split	Examples	Source and purpose
train	1,115	763 base examples plus 352 targeted augmentation examples, used for parameter updates
validation	100	Held out from the compact base data for development-time validation
test	500	Separately generated fixed evaluation cases; 495 have no training-input overlap

These splits differ from the original public dataset's 1,400/100 split. The original public splits cannot be substituted directly for this release.

Data Fields

All three JSONL files use the same fields, with one JSON object per line:

Field	Type	Description
case_id	string	Original SFT_* ID for base examples, AUG_* ID for augmentation, or original CASE_* ID for test cases
source_line	integer	One-based original source line, augmentation attempt number, or evaluation-file line number, depending on source
source	string	base_sft, hard_augmentation, or generated_eval
bucket	string	Scenario label assigned by the original generator
request_fingerprint	string	SHA-256 of the business input after removing input.order.order_id, used to check duplicates
input	object	Order, available channels, promotions, and selected channel
ground_truth	object	Final business JSON computed by the reference payment service
prompt	string	Shared rules followed by Request JSON: and the request JSON, without model chat-template tokens
response	string	Original reasoning plus JSON for train/validation; answer JSON only for test, without reference reasoning
messages	list	System, user, and assistant messages for train/validation; system and user messages only for test, with no answer

Augmentation IDs identify the original attempts among 750 generation attempts. The original preprocessing filtered out overlength examples, so AUG_* IDs contain gaps.

The fingerprint follows the reference public dataset's convention: remove only the order ID, serialize with sort_keys=True, separators=(",", ":"), ensure_ascii=False, and compute SHA-256 over the UTF-8 bytes. Channel and promotion list order is preserved.

Loading the Data

Load the local files without downloading a model or installing AReno:

from datasets import load_dataset

dataset = load_dataset(
    "json",
    data_files={
        "train": "Ling-Ting-SFT-Augment/train.jsonl",
        "validation": "Ling-Ting-SFT-Augment/valid.jsonl",
        "test": "Ling-Ting-SFT-Augment/eval500.jsonl",
    },
)
print(dataset)
print(dataset["train"][0]["messages"])

Alternatively, use the Python standard library:

import json
from pathlib import Path

data_dir = Path("Ling-Ting-SFT-Augment")
train = [json.loads(line) for line in (data_dir / "train.jsonl").read_text().splitlines()]
validation = [json.loads(line) for line in (data_dir / "valid.jsonl").read_text().splitlines()]
test = [json.loads(line) for line in (data_dir / "eval500.jsonl").read_text().splitlines()]

Download the published dataset from Hugging Face:

hf download AsystemAReno/Ling-Ting-SFT-Augment \
  --repo-type dataset --local-dir Ling-Ting-SFT-Augment

For a ModelScope mirror containing the same files, replace YOUR_NAMESPACE with the mirror's namespace after publication:

modelscope download --dataset YOUR_NAMESPACE/Ling-Ting-SFT-Augment \
  --local-dir Ling-Ting-SFT-Augment

You can also load the three splits configured in this dataset card directly from Hugging Face:

dataset = load_dataset("AsystemAReno/Ling-Ting-SFT-Augment")

Training and Evaluation

Use messages to reproduce the original experiments. The assistant message in each training or validation example is identical to response. Apply the Ling chat template once to the complete conversation and mask system/user tokens from the training loss. The system message already contains the shared rules; do not append system_prompt.txt again.

Tools that accept plain-text input/output pairs can use prompt and response. This convenient text view is not guaranteed to produce the same token sequence as the multi-role chat template used in the original experiment.

For evaluation, pass only the test case's messages to the model and keep thinking enabled. Do not pass response or ground_truth as input. Extract the final JSON after </think> and compare it strictly with ground_truth: fields, values, numeric types, and list order must match. Reject duplicate JSON keys and NaN/Infinity. Truncated generations, invalid JSON, and mismatched fields count as failures.

Build the test subset without training-input overlap as follows:

import json
from pathlib import Path

manifest = json.loads(Path("Ling-Ting-SFT-Augment/manifest.json").read_text())
overlap = set(manifest["overlap_audit"]["train_test_case_ids"])
test_495 = dataset["test"].filter(lambda row: row["case_id"] not in overlap)
assert len(test_495) == 495

The overlapping cases are CASE_000008, CASE_000225, CASE_000263, CASE_000274, and CASE_000317; all overlap with augmented training examples. No business inputs overlap between training and validation or between validation and test. There are also no duplicate business inputs within any split. These checks use the fingerprint definition above, not approximate semantic deduplication.

Data Preparation

1. Start with the 1,500 examples from AsystemAReno/Ling-Tiny-SFT, pinned to revision bef344521b1751374d3ff9da3b9f4f61706d5c8d.
2. Restore the original source_line order and convert the rules, requests, and reasoning into the compact format. The historical Ling-tokenizer filter retained 863 examples within a 1,024-token budget. The last 100 became the validation set; the remaining 763 became the base training set.
3. Make 750 targeted generation attempts with seed 42 and sampling weights of 45% split payment, 35% recommendation switch, 10% exclusive versus stackable promotions, and 10% rounding boundaries. Length filtering retained 352 examples, which were combined with the base training set to form the experiment's 1,115 training examples.
4. Generate a separate 500-case evaluation set using the original generator and compute its answers with the reference service. Separate generation does not guarantee disjoint business inputs, so the five overlapping cases are identified explicitly.

The historical length filter applied tokenizer.apply_chat_template(..., tokenize=False) followed by tokenizer.encode(...). Lengths may exceed 1,024 tokens with a different tokenizer or chat template. Packaging this release did not apply another length filter.

Scenario Distribution

Scenario label	train	validation	test
SPLIT_PAYMENT	403	26	138
RECOMMEND_SWITCH	123	6	102
EXCLUSIVE_VS_STACK	33	3	62
ROUND_HALF_UP_BOUNDARY	247	19	78
SINGLE_CHANNEL_NORMAL	111	14	42
TIE_BREAKER	132	18	53
INSUFFICIENT_FUNDS	40	8	12
CHANNEL_NOT_FOUND	26	6	13
Total	1115	100	500

Labels describe the generator's sampling intent rather than a new classification of the final payment outcome. For example, a case labeled as split payment may ultimately require only one channel after discounts.

Version

Version 1.0.0, prepared on 2026-10-26. manifest.json records the original sources, published-file checksums, scenario and source counts, overlapping-case mappings, and the reasoning-amount audit.

This version corresponds to the existing experiments. Correcting reasoning text, removing overlapping cases, or changing splits should produce a new data version with separately identified experiment results.