Transfer Learning and Pre-Trained Models

Transfer learning is a machine learning technique where a model developed for one task is reused as the starting point for a model on a second task. It exists because training a deep neural network from scratch requires enormous amounts of labeled data, computational resources, and time. For example, training a state-of-the-art image classifier on ImageNet (1.2 million images, 1000 classes) can take days or weeks on multiple GPUs. Transfer learning bypasses this by taking a pre-trained model—one already trained on a large, generic dataset—and adapting it to a new, often smaller, dataset.

In the AI-900 context, transfer learning is the engine behind Azure Custom Vision and many other Azure Cognitive Services. It allows you to train a custom image classifier with as few as 50 images per class, achieving high accuracy in minutes instead of days. The exam expects you to understand when to use transfer learning versus training from scratch, and how Azure services abstract this complexity.

Neural networks learn hierarchical features. In a convolutional neural network (CNN) for images, early layers learn low-level features like edges, corners, and colors. Middle layers learn mid-level features like shapes and textures. Later layers learn high-level features specific to the original task, such as faces, wheels, or fur.

When you apply transfer learning, you typically: 1. Remove the original classifier head (the final fully connected layers that map features to the original classes). 2. Freeze the early layers' weights so they are not updated during training on the new dataset. This preserves the general feature detectors. 3. Add a new classifier head with the number of outputs equal to your new number of classes. 4. Train the new head (and optionally fine-tune some later layers) on your new dataset.

This process is called fine-tuning. The frozen layers act as a fixed feature extractor. The new head learns to combine these features for your specific task.

Pre-trained models: Common models used for transfer learning include: - ResNet: Residual networks with variants like ResNet-18, ResNet-50, ResNet-152. Default in Azure Custom Vision (ResNet-18 for simplicity, but other backbones available). - VGG: Very deep convolutional networks (VGG-16, VGG-19). - Inception: GoogLeNet architecture with inception modules. - EfficientNet: State-of-the-art efficiency scaling.

Azure Custom Vision: When you create a custom vision project, Azure automatically downloads a pre-trained model (e.g., ResNet-18) and fine-tunes it on your images. You can choose the model domain (e.g., "General", "Food", "Landmarks") which selects an appropriate pre-trained backbone.

Training parameters: - Number of training iterations: Default is 10 in Custom Vision, but you can increase up to 100. - Learning rate: Typically 0.001 for fine-tuning, but Azure handles this automatically. - Batch size: Determined by the service; you cannot set it manually.

To use transfer learning in Azure: 1. Create a Custom Vision resource in the Azure portal. 2. Create a project and select a domain (e.g., "General" for most tasks). 3. Upload images and tag them with labels. 4. Train the model—Azure automatically performs transfer learning. 5. Evaluate using the precision, recall, and mAP metrics provided.

You can also use the Custom Vision Python SDK to programmatically train and manage models. Example:

from azure.cognitiveservices.vision.customvision.training import CustomVisionTrainingClient
from azure.cognitiveservices.vision.customvision.training.models import ImageFileCreateEntry

# Authenticate
trainer = CustomVisionTrainingClient(endpoint, training_key)

# Create project
project = trainer.create_project("My Custom Project", domain_id=domain.id)

# Upload images
image_list = [ImageFileCreateEntry(name=image_name, contents=image_data) for ...]
trainer.create_images_from_files(project.id, images=image_list)

# Train
iteration = trainer.train_project(project.id)

Transfer learning is the foundation of Azure Cognitive Services. Services like Computer Vision, Custom Vision, and Form Recognizer use pre-trained models that are fine-tuned on specific data. For example: - Computer Vision: Pre-trained on millions of images; you cannot retrain it, but you can use its features for transfer learning in Custom Vision. - Custom Vision: Allows you to fine-tune a pre-trained model on your own images. - Form Recognizer: Uses transfer learning with pre-trained layout and OCR models, then fine-tunes on your forms.

Azure Machine Learning also supports transfer learning. You can use the AutoML module to automatically select a pre-trained model and fine-tune it on your dataset. This is useful for advanced users who need more control.

Transfer learning is the practice of leveraging a pre-trained model to solve a new task faster and with less data. It works by freezing early layers (general features) and retraining later layers (specific features). Azure Cognitive Services like Custom Vision make transfer learning accessible with minimal code. Understanding when to use it and its limitations is key for AI-900 success.

A large e-commerce company needs to automatically classify product images into hundreds of categories (e.g., electronics, clothing, home goods). They have a dataset of 10,000 images per category, but many categories are new and have only 100 images. Using transfer learning, they take a pre-trained ResNet-50 model from Azure Custom Vision and fine-tune it on their product images. The model achieves 95% accuracy after 20 minutes of training. Without transfer learning, training from scratch would require millions of images and days of GPU time. In production, the model is deployed as an Azure Container Instance behind a load balancer handling 1000 requests per second. Common pitfalls: using too few images per class (below 50) leads to overfitting; the solution is to use data augmentation and a simpler model like ResNet-18.

A hospital wants to detect pneumonia from chest X-rays. They have 5,000 labeled X-rays, but training a deep network from scratch would be risky due to data scarcity and the need for high accuracy. They use transfer learning with a pre-trained DenseNet-121 model originally trained on ImageNet. The early layers are frozen, and the classifier head is replaced with a binary output (pneumonia vs. normal). Fine-tuning on the X-ray dataset takes 2 hours on a single GPU and achieves 92% sensitivity. The model is deployed via Azure Kubernetes Service with autoscaling. Key consideration: domain mismatch—natural images vs. medical images—so they unfreeze the last 20% of layers to adapt to the new domain. Misconfiguration: forgetting to normalize X-ray images to the same mean/std as the pre-trained model's training data (ImageNet statistics) can reduce accuracy by 10%.

A law firm needs to classify legal documents into categories like contracts, briefs, and memos. They use Azure Form Recognizer, which internally uses transfer learning with a pre-trained layout and OCR model. They provide 200 examples per category. The service fine-tunes the pre-trained model to recognize the document structure and text patterns. In production, the model processes 10,000 documents daily with 99% accuracy. Performance considerations: the pre-trained model is optimized for English text; for other languages, additional fine-tuning is required. Common failure: using documents with unusual layouts (e.g., handwritten notes) requires more training data and possibly a custom model built from scratch.