Agentic Design

Patterns
👨‍🏫

Supervised Learning for Agents(SLA)

Learning from labeled examples to improve agent decision-making and task performance

Complexity: mediumLearning and Adaptation

🎯 30-Second Overview

Pattern: Adapt pre-trained models to specific tasks through supervised training on labeled target domain data

Why: Leverages existing model knowledge while specializing for target tasks, achieving high performance with reasonable training costs

Key Insight: Transfer learning from pre-trained models combined with task-specific supervision provides optimal balance of generalization and specialization

⚡ Quick Implementation

1Collect:Gather task-specific labeled training examples
2Preprocess:Format data for target domain and task requirements
3Fine-tune:Adapt pre-trained model with supervised objectives
4Validate:Test performance on held-out validation set
5Deploy:Apply adapted model to target task environment
Example: pretrained_model + labeled_data → supervised_fine_tuning → task_adapted_model

📋 Do's & Don'ts

✅Use high-quality, representative labeled datasets for target domain
✅Implement proper train/validation/test splits to prevent overfitting
✅Apply appropriate regularization techniques (dropout, weight decay)
✅Monitor for distribution shift between training and deployment
✅Use transfer learning from relevant pre-trained models
✅Implement early stopping based on validation performance
❌Train on insufficient or biased labeled data
❌Ignore data quality issues and label noise
❌Overfit to training data without proper validation
❌Apply without considering computational constraints
❌Neglect hyperparameter tuning and model selection

🚦 When to Use

Use When

  • • High-quality labeled data is available for target task
  • • Task has clear input-output relationships
  • • Performance requirements justify supervised training costs
  • • Domain-specific adaptation is needed from general models
  • • Evaluation metrics can be clearly defined

Avoid When

  • • Labeled data is scarce, expensive, or low quality
  • • Task requires real-time learning from minimal examples
  • • Unsupervised or self-supervised approaches are sufficient
  • • Privacy constraints prevent data collection
  • • Deployment environment changes frequently

📊 Key Metrics

Task Accuracy
Performance on target task vs baseline models
Training Efficiency
Convergence speed and computational cost
Generalization
Performance on unseen test data
Transfer Quality
Knowledge retention from pre-training
Data Efficiency
Performance per labeled training example
Robustness
Performance under distribution shift

💡 Top Use Cases

Domain-Specific Classification: Adapt general classifiers to specialized domains (medical, legal, scientific)
Custom Entity Recognition: Train NER models for domain-specific entities and relationships
Task-Specific Generation: Fine-tune language models for specific writing styles or formats
Sentiment Analysis Adaptation: Customize sentiment models for specific industries or contexts
Code Generation Specialization: Adapt code models for specific programming languages or frameworks
Question Answering Systems: Train QA models on domain-specific knowledge bases

References & Further Reading

Deepen your understanding with these curated resources

Foundational Papers

Fine-Tuning Pre-trained Language Models: Weight Initializations, Data Orders, and Early Stopping (Dodge et al., 2020)

How to Fine-Tune BERT for Text Classification? (Sun et al., 2019)

Universal Language Model Fine-tuning for Text Classification (Howard & Ruder, 2018)

Attention Is All You Need (Vaswani et al., 2017)

Transfer Learning & Pre-training

BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding (Devlin et al., 2018)

Language Models are Few-Shot Learners (Brown et al., 2020)

T5: Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer (Raffel et al., 2019)

RoBERTa: A Robustly Optimized BERT Pretraining Approach (Liu et al., 2019)

Fine-Tuning Methodologies

LoRA: Low-Rank Adaptation of Large Language Models (Hu et al., 2021)

Prefix-Tuning: Optimizing Continuous Prompts for Generation (Li & Liang, 2021)

The Power of Scale for Parameter-Efficient Prompt Tuning (Lester et al., 2021)

AdaLoRA: Adaptive Budget Allocation for Parameter-Efficient Fine-Tuning (Zhang et al., 2023)

Domain Adaptation Techniques

Domain-Adversarial Training of Neural Networks (Ganin et al., 2016)

Deep Domain Confusion: Maximizing for Domain Invariance (Tzeng et al., 2014)

Unsupervised Domain Adaptation by Backpropagation (Ganin & Lempitsky, 2015)

AdaBound: Adaptive Gradient Methods with Bound for Domain Adaptation (Luo et al., 2019)

Recent Advances (2023-2024)

QLoRA: Efficient Finetuning of Quantized LLMs (Dettmers et al., 2023)

LLaMA-Adapter: Efficient Fine-tuning of Language Models with Zero-init Attention (Zhang et al., 2023)

Instruction Tuning for Large Language Models: A Survey (Zhang et al., 2023)

DoRA: Weight-Decomposed Low-Rank Adaptation (Liu et al., 2024)

Data Efficiency & Few-Shot Learning

Few-Shot Learning with Language Models (Brown et al., 2020)

Making Pre-trained Language Models Better Few-shot Learners (Gao et al., 2021)

What Makes Good In-Context Examples for GPT-3? (Liu et al., 2021)

SetFit: Efficient Few-Shot Learning Without Prompts (Tunstall et al., 2022)

Evaluation & Benchmarking

GLUE: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding (Wang et al., 2018)

SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems (Wang et al., 2019)

BIG-bench: Beyond the Imitation Game Benchmark (Srivastava et al., 2022)

HELM: Holistic Evaluation of Language Models (Liang et al., 2022)

Implementation Resources

Hugging Face Transformers - Fine-tuning Tutorial

PEFT: Parameter-Efficient Fine-Tuning Library

LoRA Implementation and Best Practices

Adapter Hub: Pre-trained Adapters Repository

Training Frameworks & Tools

PyTorch Lightning: Simplified Training Framework

Accelerate: Distributed Training Library

DeepSpeed: Optimization Library for Large Models

FairScale: PyTorch Extensions for Research

Domain-Specific Applications

BioBERT: Biomedical Text Mining with BERT (Lee et al., 2020)

FinBERT: Financial Sentiment Analysis (Araci, 2019)

LegalBERT: Legal Domain Language Model (Chalkidis et al., 2020)

CodeBERT: A Pre-Trained Model for Programming Languages (Feng et al., 2020)

Production Deployment

Model Optimization for Production: ONNX and TensorRT

TorchServe: PyTorch Model Serving Framework

MLflow: Machine Learning Lifecycle Management

Weights & Biases: Experiment Tracking and Model Management

Best Practices & Guidelines

Fine-Tuning Best Practices (Google AI)

Efficient Training of Large Language Models (OpenAI)

Parameter-Efficient Fine-Tuning Survey (Ding et al., 2022)

Transfer Learning in Natural Language Processing (Kenton & Toutanova, 2019)

Contribute to this collection

Know a great resource? Submit a pull request to add it.

Contribute

Patterns

closed

Loading...

Built by Kortexya