Fine-Tuning Qwen3-14B Reasoning and Conversational Modes with Unsloth

Step 1: Model Loading & 4-bit LoRA Configuration

from __future__ import annotations

import torch
from unsloth import FastLanguageModel

max_seq_length = 2048

# Load Qwen3-14B in 4-bit NF4 precision
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Qwen3-14B",
    max_seq_length=max_seq_length,
    dtype=None,             # Auto-selects FP16 on T4, BF16 on Ampere+/Hopper
    load_in_4bit=True,      # 4-bit NF4 quantization reduces base weights to ~9.0 GB
    load_in_8bit=False,
    full_finetuning=False,
)

# Attach LoRA adapters to all attention and feed-forward linear layers
lora_rank = 32
model = FastLanguageModel.get_peft_model(
    model,
    r=lora_rank,
    lora_alpha=lora_rank,   # Scaling alpha = r gives multiplier of 1.0
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_dropout=0.0,       # Optimized for Unsloth kernel fusion
    bias="none",
    use_gradient_checkpointing="unsloth", # Saves ~30% VRAM
    random_state=3407,
)

model.print_trainable_parameters()
# Trainable params: 128,450,560 / 14,000,000,000 (0.92% trained)

Step 2: 75/25 Mixed-Dataset Preparation

from __future__ import annotations

import pandas as pd
from datasets import Dataset, load_dataset
from unsloth.chat_templates import standardize_sharegpt
from model_init import tokenizer

# 1. Load 75% Reasoning Dataset (DeepSeek-R1 Math Traces)
reasoning_raw = load_dataset("unsloth/OpenMathReasoning-mini", split="cot")


def format_reasoning_sample(examples: dict) -> dict:
    conversations = [
        [
            {"role": "user", "content": prob},
            {"role": "assistant", "content": sol},
        ]
        for prob, sol in zip(examples["problem"], examples["generated_solution"])
    ]
    return {"conversations": conversations}


reasoning_formatted = reasoning_raw.map(
    format_reasoning_sample,
    batched=True,
    remove_columns=reasoning_raw.column_names,
)
reasoning_texts = tokenizer.apply_chat_template(
    list(reasoning_formatted["conversations"]),
    tokenize=False,
)

# 2. Load 25% Conversational Dataset (General Dialogue)
chat_raw = load_dataset("mlabonne/FineTome-100k", split="train")
chat_standardized = standardize_sharegpt(chat_raw)
chat_texts = tokenizer.apply_chat_template(
    list(chat_standardized["conversations"]),
    tokenize=False,
)

# 3. Calibrated Dataset Blending (75/25 Ratio)
chat_fraction = 0.25
n_reasoning = len(reasoning_texts)
n_chat = int(n_reasoning * (chat_fraction / (1.0 - chat_fraction)))

chat_subset = pd.Series(chat_texts).sample(n_chat, random_state=2407)
combined_series = pd.concat([pd.Series(reasoning_texts), chat_subset], ignore_index=True)

combined_dataset = Dataset.from_pandas(pd.DataFrame({"text": combined_series})).shuffle(seed=3407)
print(f"Total training tokens ready: {len(combined_dataset)} samples (75% reasoning, 25% chat)")

Step 3: Supervised Fine-Tuning Execution

from trl import SFTConfig, SFTTrainer
from model_init import model, tokenizer
from dataset_prep import combined_dataset

FastLanguageModel.for_training(model)

training_args = SFTConfig(
    output_dir="outputs/qwen3_14b_dual_mode",
    dataset_text_field="text",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,      # Effective batch size = 8
    warmup_steps=5,
    max_steps=60,                       # Calibration run; set num_train_epochs=1 for full epoch
    learning_rate=2e-4,
    fp16=not torch.cuda.is_bf16_supported(),
    bf16=torch.cuda.is_bf16_supported(),
    logging_steps=1,
    optim="adamw_8bit",
    weight_decay=0.001,
    lr_scheduler_type="linear",
    seed=3407,
    report_to="none",
    max_length=2048,
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=combined_dataset,
    args=training_args,
)

trainer.train()

Step Convergence & Loss Trajectory

Step 4: Dual-Mode Runtime Inference

from transformers import TextStreamer
from unsloth import FastLanguageModel

FastLanguageModel.for_inference(model)

prompt_math = "Solve for positive x: sqrt(x^2 + 165) - sqrt(x^2 - 52) = 7"
prompt_chat = "Explain the difference between TCP and UDP in two concise paragraphs."

# Mode 1: Deliberative Reasoning (enable_thinking=True)
messages_math = [{"role": "user", "content": prompt_math}]
tokens_math = tokenizer.apply_chat_template(
    messages_math,
    tokenize=True,
    add_generation_prompt=True,
    enable_thinking=True,              # Activates <think>...</think> chain
    return_tensors="pt",
).to("cuda")

print("--- Reasoning Mode Output ---")
_ = model.generate(
    tokens_math,
    max_new_tokens=1024,
    temperature=0.6,                    # Sampling temperature prevents repetitive loops
    top_p=0.95,
    top_k=20,
    streamer=TextStreamer(tokenizer, skip_prompt=True),
)

# Mode 2: Direct Conversational (enable_thinking=False)
messages_chat = [{"role": "user", "content": prompt_chat}]
tokens_chat = tokenizer.apply_chat_template(
    messages_chat,
    tokenize=True,
    add_generation_prompt=True,
    enable_thinking=False,             # Bypasses reasoning tags for direct response
    return_tensors="pt",
).to("cuda")

print("\n--- Conversational Mode Output ---")
_ = model.generate(
    tokens_chat,
    max_new_tokens=512,
    temperature=0.7,
    top_p=0.90,
    streamer=TextStreamer(tokenizer, skip_prompt=True),
)

Step 5: Checkpoint Export & Production Serving

# 1. Save LoRA Adapter (~200 MB)
model.save_pretrained("outputs/qwen3_14b_dual_mode_lora")
tokenizer.save_pretrained("outputs/qwen3_14b_dual_mode_lora")

# 2. Merge into FP16 precision for vLLM deployment (~28 GB)
model.save_pretrained_merged(
    "outputs/qwen3_14b_dual_mode_16bit",
    tokenizer,
    save_method="merged_16bit",
)

# 3. Export to GGUF format for llama.cpp / Ollama local execution
model.save_pretrained_gguf(
    "outputs/qwen3_14b_dual_mode_gguf",
    tokenizer,
    quantization_method="q4_k_m",      # ~8.2 GB quantized size
)

Empirical Benchmark Evaluation

We evaluated Qwen3-14B across mathematical reasoning and multi-turn conversational benchmarks:

Troubleshooting Common Synthesis Faults

1. Repetition Loops inside <think> Blocks

• Symptom: Model repeats equations cyclically during deliberative mode.
• Remedy: Avoid greedy decoding (do_sample=False). Enforce temperature=0.6, top_p=0.95, and top_k=20 during inference.

2. Spurious Empty <think> Delimiters in Casual Chat

• Symptom: Conversational inputs return <think>\n</think> before answering.
• Remedy: Ensure conversational data comprises at least 20–25% of the training mixture and verify enable_thinking=False is passed to apply_chat_template.

3. Out of Memory on 16GB GPUs

• Symptom: CUDA OOM error during forward/backward pass.
• Remedy: Maintain per_device_train_batch_size=2 with gradient_accumulation_steps=4, and ensure use_gradient_checkpointing="unsloth" is enabled.