Ways to Adapt and Share Model Learning

This page compares four learning designs by asking where model knowledge, representations, or updates are reused. Transfer learning and fine-tuning adapt an existing model to new work. Multitask learning shares representations across tasks. Federated learning aggregates updates from multiple locations without centralizing the underlying training data.[1][2][3]

What you’ll learn

• Explain the relationship between transfer learning and fine-tuning as one way to perform it
• Distinguish sharing representations across tasks from training across locations without centralizing data
• Narrow the options from available data, compute, and data location

Why “Reuse” Matters

Training a model from scratch requires large amounts of data and significant compute. However, when relevant knowledge already exists, reusing it can sometimes achieve strong performance with less data and cost.[1]

Someone who has learned English and begins French provides a useful anchor for transfer learning. Existing ways of recognizing grammar and practicing correspond to the pretrained model; adjustments for the new language correspond to adaptation for a new task. Human knowledge transfer and parameter updates in a model are not the same mechanism.

graph LR
    subgraph TL["Transfer Learning"]
        BM["Base Model\n(weights frozen)"] --> NL["New Layer\n(trained on new data)"]
    end
    subgraph FT["Fine-tuning"]
        PTM["Pre-trained\nModel (full)"] --> ND["Adjusted with\nnew data"]
    end

1. Transfer Learning

Transfer learning uses knowledge gained in one domain or task to help learn a related domain or task.[1] It includes using a frozen model as a feature extractor and updating some or all of its parameters.

Move pretrained representations to a new task

1. Prepare a base model: Obtain a model already trained on large data (e.g., an ImageNet classification model)
2. Adapt the output for the new task: Add or replace layers to match the required labels or output format
3. Choose what to update: Freeze the pretrained part, or fine-tune some or all of it

graph TD
    D1["Large training dataset\n(e.g., ImageNet)"] --> BM["Base Model\n(pre-trained)"]
    BM --> |weights frozen| FM1["Feature extraction layers\n(unchanged)"]
    FM1 --> NL["New task layer\n(trained on small dataset)"]
    D2["New task data\n(e.g., medical images)"] --> NL

When to Use It

• When the new task does not have enough suitable data to train a model from scratch
• When the original task and the new task are related (both image recognition, both text processing, etc.)

Example: adapt an image classifier

Use an image classification model trained on a large image dataset such as ImageNet to build a diagnostic model for medical X-ray images. General visual features such as edge detection and shape recognition are reused; only the judgment criteria specific to medical images are learned from scratch.[1]

2. Fine-tuning

Fine-tuning updates some or all parameters of a pretrained model with data for a new objective. It is one common way to perform transfer learning.[1]

Difference From Transfer Learning

Scroll horizontally→

	Use as a Feature Extractor	Fine-tuning
Weights updated	Mainly the new output layers	Some or all existing layers
Data requirement	Easier to try with less data	Wider updates increase overfitting risk
Compute cost	Low	Higher
Overfitting risk	Low	High if data is scarce

This table scrolls horizontally. Keyboard users can focus the table and use the left and right arrow keys.

Update existing parameters with new data

The entire pre-trained model is trained further on new data. A common effective strategy is discriminative learning rates: lower learning rates for lower layers (which learned general features) and higher learning rates for upper layers (which learned task-specific features).

Example: adapt a general language model

Fine-tune a general-purpose LLM on a company’s customer support conversation data to build a dialogue model specialized for that company’s products and services.

3. Multitask Learning

Multitask learning is a model design approach in which multiple different tasks are learned simultaneously.[2]

Share representations across several tasks

graph TD
    IN["Input Data"] --> SH["Shared Network"]
    SH --> T1["Task 1 Branch\n(e.g., sentiment analysis)"]
    SH --> T2["Task 2 Branch\n(e.g., topic classification)"]
    SH --> T3["Task 3 Branch\n(e.g., language detection)"]
    T1 --> O1["Output 1"]
    T2 --> O2["Output 2"]
    T3 --> O3["Output 3"]

• Shared network: Learns general representations common across all tasks
• Task-specific branches: Generate the output for each individual task

Benefits and conditions

• Related tasks may produce shared representations that improve generalization
• Shared layers can reduce the number of separate models that must be maintained
• Unrelated tasks can interfere with one another, so joint training does not guarantee an improvement

Example: train related language tasks together

In natural language processing, training sentiment analysis, topic classification, and language detection together in a single model allows the general language understanding learned for each task to be shared across all tasks.

4. Federated Learning

Federated learning is a technique for training a model on data distributed across many devices without centralizing that data on a single server.[3]

Aggregate model updates without centralizing data

graph TD
    C["Central Server\n(distributes and aggregates model weights)"]
    D1["Device 1\n(smartphone)\nLocal training"]
    D2["Device 2\n(smartphone)\nLocal training"]
    D3["Device 3\n(smartphone)\nLocal training"]
    C --> |distribute shared model| D1
    C --> |distribute shared model| D2
    C --> |distribute shared model| D3
    D1 --> |send weight updates only| C
    D2 --> |send weight updates only| C
    D3 --> |send weight updates only| C

1. The central server distributes the shared model to each device
2. Each device trains locally on its own data (data never leaves the device)
3. Each device sends model-update information to the server
4. The server aggregates the updates and improves the shared model
5. Steps 1–4 repeat

Benefits and limits

• Less raw-data movement: Participants can contribute to training without sending their training records to a central store
• Communication and device differences still matter: Repeated updates must account for network conditions, device capacity, and different local data distributions
• Privacy is not automatic: Model updates can leak information, so additional protections may be required[5]

Example: improve keyboard predictions across devices

The keyboard prediction feature on a smartphone. Each user’s input history (personal data) stays on the device. Only the learning results (weight updates) are aggregated to improve the shared model.[3]

Comparison of the Four Techniques

Scroll horizontally→

	Transfer Learning	Fine-tuning	Multitask Learning	Federated Learning
Primary goal	Adapting to a new task with limited data	Domain adaptation and performance gains	Simultaneous multi-task learning	Privacy-preserving distributed learning
Data requirement	Small amounts acceptable	More data preferable	Data for each task needed	Distributed data
Computation pattern	Can remain modest when the base is frozen	Grows with the portion updated	Trains shared layers and several outputs	Repeats local computation and communication
Typical use case	Repurposing an image classifier	LLM domain adaptation	Multi-purpose NLP models	Smartphones, IoT

This table scrolls horizontally. Keyboard users can focus the table and use the left and right arrow keys.

Boundaries that are easy to confuse

Q: Are transfer learning and fine-tuning separate techniques?

A: They are related but distinct. Transfer learning is the broader concept of applying knowledge from a trained model to a new task. Fine-tuning is one way to achieve this — by re-adjusting all model parameters on new data. Some texts distinguish fine-tuning (updating all layers) from transfer learning (updating only the final layer), while others treat fine-tuning as a subset of transfer learning.

Q: How much data does LLM fine-tuning require?

A: It depends on the task and quality requirements. Techniques like LoRA (Low-Rank Adaptation) can fine-tune a model while reducing the number of trainable parameters.[4]

Q: Does federated learning fully protect data privacy?

A: Not completely. Attacks that reconstruct original data from gradient updates (gradient inversion attacks) exist.[5] Stronger privacy protection requires combining federated learning with additional techniques such as differential privacy.

References

1. Sinno Jialin Pan, Qiang Yang, A Survey on Transfer Learning, 2010
2. Sebastian Ruder, An Overview of Multi-Task Learning in Deep Neural Networks, June 15, 2017
3. H. Brendan McMahan et al., Communication-Efficient Learning of Deep Networks from Decentralized Data, February 17, 2016
4. Edward J. Hu et al., LoRA: Low-Rank Adaptation of Large Language Models, June 17, 2021
5. Ligeng Zhu, Zhijian Liu, Song Han, Deep Leakage from Gradients, June 21, 2019