Multitask Learning

Start writing here...

Great pick! Multitask Learning (MTL) is a powerful concept in machine learning, especially when tasks are related. Here’s a complete and clear breakdown of Multitask Learning—ideal for notes, teaching, or presentation slides.

🤹‍♂️ Multitask Learning (MTL)

🧠 What is Multitask Learning?

Multitask Learning is a training paradigm where a single model is trained to perform multiple related tasks simultaneously. Instead of learning tasks in isolation, MTL allows the model to leverage shared information across tasks to improve generalization.

“Train once, perform many tasks.”

🧩 Core Idea

In MTL:

• Tasks share some internal representations (like neural network layers).
• The model learns better shared features that help multiple tasks.
• Can lead to improved performance, especially when data for some tasks is limited.

🎯 Real-Life Examples

🔧 Types of MTL Architectures

1. Hard Parameter Sharing
   • Shared hidden layers
   • Task-specific output layers
   • Most common and simple approach

   Input → Shared Layers → [Task A Head, Task B Head, Task C Head]
   

2. Soft Parameter Sharing
   • Each task has its own model
   • Parameters are regularized to stay similar
   • More flexible, but computationally heavier
3. Cross-stitch Networks / Sluice Networks
   • Dynamic sharing of parameters
   • Allows learning how much to share between tasks

⚖️ Loss Function in MTL

The overall loss is typically a weighted sum of individual task losses:

Ltotal=∑i=1TλiLi\mathcal{L}_{\text{total}} = \sum_{i=1}^T \lambda_i \mathcal{L}_i

Where:

• Li\mathcal{L}_i: Loss for task ii
• λi\lambda_i: Weight (importance) for task ii

Choosing the right weights is critical and can be:

• Manually set
• Learned during training (e.g., using task uncertainty)

📈 Benefits of MTL

🧰 Example in PyTorch (Simplified)

import torch.nn as nn

class MTLModel(nn.Module):
    def __init__(self):
        super(MTLModel, self).__init__()
        self.shared = nn.Sequential(
            nn.Linear(100, 64),
            nn.ReLU()
        )
        self.task1_head = nn.Linear(64, 1)  # e.g., regression
        self.task2_head = nn.Linear(64, 3)  # e.g., classification

    def forward(self, x):
        x = self.shared(x)
        out1 = self.task1_head(x)
        out2 = self.task2_head(x)
        return out1, out2

📚 Use Cases

• Google's Multilingual Translation: One model translates between multiple languages.
• Uber’s ETA + Fare Prediction: Joint model for predicting time and cost.
• Facial analysis: Age, gender, emotion detection in one model.

🚧 Challenges

• Task balancing: Some tasks may dominate training if not balanced properly.
• Negative transfer: When learning one task hurts performance on another.
• Architecture design: How to structure shared vs task-specific parts?

🔬 Related Concepts

• Transfer Learning: Pretraining on one task, fine-tuning on another.
• Multi-label Learning: Predicting multiple labels for a single input.
• Federated Multitask Learning: Performing MTL across distributed devices.

🧠 Summary

Want visuals, a summary sheet, quiz questions, or deep dive into task weighting methods? I can help with any of that next!