Supervised Fine-Tuning

Supervised Fine-Tuning (SFT) is a process for adapting pre-trained language models to specific tasks or domains. While pre-trained models have impressive general capabilities, they often need to be customized to excel at particular use cases. SFT bridges this gap by further training the model on relevant datasets with human-validated examples.

This page provides a step-by-step guide to fine-tuning the deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B model using the SFTTrainer. By following these steps, you can adapt the model to perform specific tasks more effectively.

When to Use SFT

Before diving into implementation, it’s important to understand when SFT is the right choice for your project. The supervised structure of the task enables models to learn specific output formats and behaviors. For example, SFT can teach a model to consistently use chat templates or follow domain-specific guidelines. The decision to use Supervised Fine-Tuning depends on two primary factors: factors:

Template Control

SFT allows precise control over the model’s output structure. This is particularly valuable when you need the model to:

1. Generate responses in a specific chat template format
2. Follow strict output schemas
3. Maintain consistent styling across responses

Domain Adaptation

When working in specialized domains, SFT helps align the model with domain-specific requirements by:

1. Teaching domain terminology and concepts
2. Enforcing professional standards
3. Handling technical queries appropriately
4. Following industry-specific guidelines

Dataset Preparation

The supervised fine-tuning process requires a task-specific dataset structured with input-output pairs. Each pair should consist of:

1. An input prompt
2. The expected model response
3. Any additional context or metadata

The quality of your training data is crucial for successful fine-tuning. Let’s look at how to prepare and validate your dataset:

Training Configuration

The success of your fine-tuning depends heavily on choosing the right training parameters. Let’s explore each important parameter and how to configure them effectively:

The SFTTrainer configuration requires consideration of several parameters that control the training process. Let’s explore each parameter and their purpose:

1. Training Duration Parameters:

   • num_train_epochs: Controls total training duration
   • max_steps: Alternative to epochs, sets maximum number of training steps
   • More epochs allow better learning but risk overfitting

2. Batch Size Parameters:

   • per_device_train_batch_size: Determines memory usage and training stability
   • gradient_accumulation_steps: Enables larger effective batch sizes
   • Larger batches provide more stable gradients but require more memory

3. Learning Rate Parameters:

   • learning_rate: Controls size of weight updates
   • warmup_ratio: Portion of training used for learning rate warmup
   • Too high can cause instability, too low results in slow learning

4. Monitoring Parameters:

   • logging_steps: Frequency of metric logging
   • eval_steps: How often to evaluate on validation data
   • save_steps: Frequency of model checkpoint saves

Implementation with TRL

Now that we understand the key components, let’s implement the training with proper validation and monitoring. We will use the SFTTrainer class from the Transformers Reinforcement Learning (TRL) library, which is built on top of the transformers library. Here’s a complete example using the TRL library:

from datasets import load_dataset
from trl import SFTConfig, SFTTrainer
import torch

# Set device
device = "cuda" if torch.cuda.is_available() else "cpu"

# Load dataset
dataset = load_dataset("HuggingFaceTB/smoltalk")

# Configure trainer
training_args = SFTConfig(
    output_dir="./sft_output",
    max_steps=1000,
    per_device_train_batch_size=4,
    learning_rate=5e-5,
    logging_steps=10,
    save_steps=100,
    evaluation_strategy="steps",
    eval_steps=50,
)

# Initialize trainer
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    tokenizer=tokenizer,
)

# Start training
trainer.train()

Monitoring Training Progress

Effective monitoring is crucial for successful fine-tuning. Let’s explore what to watch for during training:

Understanding Loss Patterns

Training loss typically follows three distinct phases:

1. Initial Sharp Drop: Rapid adaptation to new data distribution
2. Gradual Stabilization: Learning rate slows as model fine-tunes
3. Convergence: Loss values stabilize, indicating training completion

Metrics to Monitor

Effective monitoring involves tracking quantitative metrics, and evaluating qualitative metrics. Available metrics are:

• Training loss
• Validation loss
• Learning rate progression
• Gradient norms

The Path to Convergence

As training progresses, the loss curve should gradually stabilize. The key indicator of healthy training is a small gap between training and validation loss, suggesting the model is learning generalizable patterns rather than memorizing specific examples. The absolute loss values will vary depending on your task and dataset.

Monitoring Training Progress

The graph above shows a typical training progression. Notice how both training and validation loss decrease sharply at first, then gradually level off. This pattern indicates the model is learning effectively while maintaining generalization ability.

Warning Signs to Watch For

Several patterns in the loss curves can indicate potential issues. Below we illustrate common warning signs and solutions that we can consider.

If the validation loss decreases at a significantly slower rate than training loss, your model is likely overfitting to the training data. Consider:

• Reducing the training steps
• Increasing the dataset size
• Validating dataset quality and diversity

If the loss doesn’t show significant improvement, the model might be:

• Learning too slowly (try increasing the learning rate)
• Struggling with the task (check data quality and task complexity)
• Hitting architecture limitations (consider a different model)

Extremely low loss values could suggest memorization rather than learning. This is particularly concerning if:

• The model performs poorly on new, similar examples
• The outputs lack diversity
• The responses are too similar to training examples

Evaluation after SFT

In section 11.4 we will learn how to evaluate the model using benchmark datasets. For now, we will focus on the qualitative evaluation of the model.

After completing SFT, consider these follow-up actions:

1. Evaluate the model thoroughly on held-out test data
2. Validate template adherence across various inputs
3. Test domain-specific knowledge retention
4. Monitor real-world performance metrics

Quiz

1. What parameters control the training duration in SFT?

2. Which pattern in the loss curves indicates potential overfitting?

3. What is gradient_accumulation_steps used for?

4. What should you monitor during SFT training?

5. What indicates healthy convergence during training?

💐 Nice work!

You’ve learned how to fine-tune models using SFT! To continue your learning:

1. Try the notebook with different parameters
2. Experiment with other datasets
3. Contribute improvements to the course material

Additional Resources

• TRL Documentation
• SFT Examples Repository
• Fine-tuning Best Practices