Format Fine-Tuning Datasets: ShareGPT vs Alpaca Compared 2026

{
  "instruction": "Summarize the following customer complaint in one sentence.",
  "input": "I ordered a laptop on March 1st and it still hasn't arrived...",
  "output": "Customer placed an order on March 1st and has not received it after 10 days."
}

{
  "instruction": "Write a Python function that returns the Fibonacci sequence up to n.",
  "input": "",
  "output": "def fibonacci(n):\n    a, b = 0, 1\n    result = []\n    while a < n:\n        result.append(a)\n        a, b = b, a + b\n    return result"
}

{
  "conversations": [
    {
      "from": "system",
      "value": "You are a senior Python developer. Be concise and correct."
    },
    {
      "from": "human",
      "value": "Write a Python function that returns the Fibonacci sequence up to n."
    },
    {
      "from": "gpt",
      "value": "def fibonacci(n):\n    a, b = 0, 1\n    result = []\n    while a < n:\n        result.append(a)\n        a, b = b, a + b\n    return result"
    }
  ]
}

{
  "conversations": [
    {"from": "system", "value": "You are a helpful coding assistant."},
    {"from": "human", "value": "What does `__slots__` do in Python?"},
    {"from": "gpt", "value": "`__slots__` restricts instance attributes to a fixed set, reducing memory overhead per object."},
    {"from": "human", "value": "Give me an example with a dataclass comparison."},
    {"from": "gpt", "value": "class Point:\n    __slots__ = ('x', 'y')\n    def __init__(self, x, y):\n        self.x = x\n        self.y = y\n\n# vs @dataclass which uses __dict__ by default"}
  ]
}

# convert_alpaca_to_sharegpt.py
# Converts an Alpaca JSONL dataset to ShareGPT format.
# Tested on Python 3.12, datasets==2.19, transformers==4.41

import json
from pathlib import Path


def alpaca_to_sharegpt(record: dict) -> dict:
    instruction = record.get("instruction", "").strip()
    input_text = record.get("input", "").strip()
    output = record.get("output", "").strip()

    # Merge instruction + input when both are present
    human_turn = f"{instruction}\n\n{input_text}" if input_text else instruction

    return {
        "conversations": [
            {"from": "human", "value": human_turn},
            {"from": "gpt", "value": output},
        ]
    }


def convert_file(src: str, dst: str) -> None:
    src_path = Path(src)
    dst_path = Path(dst)

    converted = []
    with src_path.open() as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            record = json.loads(line)
            converted.append(alpaca_to_sharegpt(record))

    with dst_path.open("w") as f:
        for item in converted:
            f.write(json.dumps(item, ensure_ascii=False) + "\n")

    print(f"Converted {len(converted)} records → {dst_path}")


if __name__ == "__main__":
    convert_file("train_alpaca.jsonl", "train_sharegpt.jsonl")

# load_datasets.py
# Shows how to load both formats for inspection before training.

from datasets import load_dataset

# Alpaca — flat JSON keys
alpaca_ds = load_dataset("json", data_files="train_alpaca.jsonl", split="train")
print(alpaca_ds[0].keys())  # dict_keys(['instruction', 'input', 'output'])

# ShareGPT — nested conversations list
sharegpt_ds = load_dataset("json", data_files="train_sharegpt.jsonl", split="train")
print(sharegpt_ds[0]["conversations"][0])  # {'from': 'human', 'value': '...'}

# unsloth_sharegpt_train.py
# Fine-tune Llama 3.3 8B on a ShareGPT dataset with Unsloth.
# Requires: unsloth[colab-new], datasets, trl

from unsloth import FastLanguageModel
from unsloth.chat_templates import get_chat_template, standardize_sharegpt
from datasets import load_dataset
from trl import SFTTrainer, SFTConfig

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.3-8B-Instruct",
    max_seq_length=4096,
    load_in_4bit=True,
)

tokenizer = get_chat_template(tokenizer, chat_template="llama-3.1")

dataset = load_dataset("json", data_files="train_sharegpt.jsonl", split="train")

# Normalize 'user'/'assistant' → 'human'/'gpt' and validate structure
dataset = standardize_sharegpt(dataset)


def apply_template(examples):
    # apply_chat_template expects a list of conversation dicts
    texts = [
        tokenizer.apply_chat_template(
            convo,
            tokenize=False,       # Return strings; SFTTrainer tokenizes internally
            add_generation_prompt=False,  # Don't append assistant prefix during training
        )
        for convo in examples["conversations"]
    ]
    return {"text": texts}


dataset = dataset.map(apply_template, batched=True)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    args=SFTConfig(
        dataset_text_field="text",   # Must match the key set in apply_template above
        max_seq_length=4096,
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        num_train_epochs=3,
        learning_rate=2e-4,
        output_dir="./outputs",
    ),
)

trainer.train()

# axolotl_alpaca_config.yaml
base_model: mistralai/Mistral-Small-3.1-24B-Instruct
model_type: MistralForCausalLM

datasets:
  - path: train_alpaca.jsonl
    ds_type: json
    type: alpaca           # Axolotl's built-in Alpaca formatter

sequence_len: 2048
val_set_size: 0.02

output_dir: ./axolotl-output
num_epochs: 3
learning_rate: 2e-5
micro_batch_size: 2
gradient_accumulation_steps: 4

datasets:
  - path: train_sharegpt.jsonl
    ds_type: json
    type: sharegpt
    conversation: llama-3   # Maps roles to Llama 3's chat template tokens

# validate_sharegpt.py
# Checks every record in a ShareGPT JSONL for required keys and role ordering.

import json
import sys
from pathlib import Path

VALID_ROLES = {"human", "gpt", "system", "user", "assistant", "model"}


def validate_record(record: dict, idx: int) -> list[str]:
    errors = []
    if "conversations" not in record:
        errors.append(f"[{idx}] Missing 'conversations' key")
        return errors

    convos = record["conversations"]
    if not isinstance(convos, list) or len(convos) == 0:
        errors.append(f"[{idx}] 'conversations' must be a non-empty list")
        return errors

    for turn_idx, turn in enumerate(convos):
        if "from" not in turn:
            errors.append(f"[{idx}] Turn {turn_idx} missing 'from'")
        elif turn["from"] not in VALID_ROLES:
            errors.append(f"[{idx}] Turn {turn_idx} unknown role: {turn['from']}")
        if "value" not in turn or not isinstance(turn["value"], str):
            errors.append(f"[{idx}] Turn {turn_idx} missing or non-string 'value'")

    return errors


def validate_file(path: str) -> None:
    total = 0
    all_errors = []
    with Path(path).open() as f:
        for idx, line in enumerate(f):
            line = line.strip()
            if not line:
                continue
            try:
                record = json.loads(line)
            except json.JSONDecodeError as e:
                all_errors.append(f"[{idx}] JSON parse error: {e}")
                continue
            all_errors.extend(validate_record(record, idx))
            total += 1

    if all_errors:
        print(f"Found {len(all_errors)} errors in {total} records:")
        for err in all_errors[:20]:   # Show first 20 to avoid wall of text
            print(" ", err)
        sys.exit(1)
    else:
        print(f"✅ {total} records valid")


if __name__ == "__main__":
    validate_file(sys.argv[1])

python validate_sharegpt.py train_sharegpt.jsonl
# ✅ 52002 records valid