This section provides practical guidance on implementing Prototypical Networks, specifically leveraging the powerful representations learned by large foundation models. Building on the theoretical discussion of metric-based meta-learning, we'll focus on using pre-computed embeddings from a foundation model as the input features for constructing prototypes and classifying query instances in a few-shot setting. This approach bypasses the need for end-to-end meta-training of the entire network, making it computationally efficient and often surprisingly effective.

Prerequisites and Setup

Before proceeding, ensure you have the following components ready:

Foundation Model Embeddings: Access to a pre-trained foundation model capable of generating meaningful embeddings for your data modality (e.g., ViT for images, BERT for text). You can either load the model itself or, more efficiently, pre-compute and store embeddings for your few-shot dataset. For this exercise, we assume the embeddings are fixed (i.e., the foundation model's weights are frozen).
Few-Shot Dataset: A dataset structured into N-way K-shot classification tasks. Each task should consist of:
- A support set $S = \{(x_1, y_1), ..., (x_{N \times K}, y_{N \times K})\}$ , containing $K$ labeled examples for each of the $N$ classes.
- A query set $Q = \{(x^*_1, y^*_1), ..., (x^*_{N \times Q'}, y^*_{N \times Q'}) \}$ , containing $Q'$ new examples for each of the $N$ classes, used for evaluation.
Environment: A Python environment with standard scientific computing libraries (numpy, torch or tensorflow). We'll use PyTorch-like syntax for illustration.

Core Implementation Steps

The core idea is to map both support and query examples into the embedding space provided by the foundation model and then perform nearest-prototype classification within that space.

Embedding Extraction: Pass the support set examples $x_i \in S$ and query set examples $x^*_j \in Q$ through the (frozen) foundation model $f_\phi(\cdot)$ to obtain their respective embeddings:

Support embeddings: $e_i = f_\phi(x_i)$ for all $(x_i, y_i) \in S$ .
Query embeddings: $e^*_j = f_\phi(x^*_j)$ for all $(x^*_j, y^*_j) \in Q$ .

Since the foundation model is large, batch processing and potentially caching these embeddings is important for efficiency, especially during meta-testing or if the same examples appear in multiple tasks.

# Conceptual: Function to get embeddings
import torch

@torch.no_grad() # Ensure gradients are not computed
def get_embeddings(foundation_model, data_loader, device):
    foundation_model.eval() # Set model to evaluation mode
    all_embeddings = []
    all_labels = []
    for inputs, labels in data_loader:
        inputs = inputs.to(device)
        # Assuming foundation_model outputs embeddings directly or after a projection layer
        embeddings = foundation_model(inputs)
        all_embeddings.append(embeddings.cpu())
        all_labels.append(labels.cpu())
    return torch.cat(all_embeddings), torch.cat(all_labels)

# Example usage within a task loop:
# support_loader = # DataLoader for support set (N*K samples)
# query_loader = # DataLoader for query set (N*Q' samples)
# support_embeddings, support_labels = get_embeddings(model, support_loader, device)
# query_embeddings, query_labels = get_embeddings(model, query_loader, device)

Prototype Calculation: For each class $k$ present in the support set, calculate its prototype $c_k$ by averaging the embeddings of its $K$ support examples:

c_k = \frac{1}{|S_k|} \sum_{(x_i, y_i) \in S_k} f_\phi(x_i) = \frac{1}{K} \sum_{i: y_i=k} e_i

This results in $N$ prototype vectors, each representing the central point of a class in the embedding space.

# Conceptual: Calculate prototypes
def calculate_prototypes(support_embeddings, support_labels, classes):
    # classes: A list or tensor containing the unique class labels for the task
    num_classes = len(classes)
    embedding_dim = support_embeddings.size(1)
    prototypes = torch.zeros(num_classes, embedding_dim, device=support_embeddings.device)

    for i, k in enumerate(classes):
        # Select embeddings belonging to class k
        class_mask = (support_labels == k)
        class_embeddings = support_embeddings[class_mask]
        # Calculate the mean embedding
        prototypes[i] = class_embeddings.mean(dim=0)
    return prototypes

Query Classification: Classify each query embedding $e^*_j$ by finding the prototype $c_k$ that is closest according to a chosen distance metric $d(\cdot, \cdot)$ . The predicted class $\hat{y}^*_j$ for query example $x^*_j$ is:
$\hat{y}^*_j = \underset{k \in \{1, ..., N\}}{\operatorname{argmin}} \; d(e^*_j, c_k)$
Common choices for $d$ include the squared Euclidean distance or cosine distance. Squared Euclidean distance is often preferred for its computational simplicity (avoiding square roots) and its equivalence to Euclidean distance for argmin operations.
```
# Conceptual: Classify query points
def classify_queries(query_embeddings, prototypes):
    # Using squared Euclidean distance: ||a - b||^2
    # `torch.cdist` computes pairwise distances.
    # query_embeddings shape: [num_query, embedding_dim]
    # prototypes shape: [num_classes, embedding_dim]
    # dists shape: [num_query, num_classes]
    dists = torch.cdist(query_embeddings, prototypes.unsqueeze(0)).squeeze(0) ** 2 # Use broadcasting for efficiency

    # Find the index (class) with the minimum distance for each query
    # predictions shape: [num_query]
    predictions = torch.argmin(dists, dim=1)
    return predictions # These are indices relative to the 'prototypes' tensor
```
Remember to map the predicted indices back to the original class labels if necessary.

Considerations for Foundation Model Embeddings

Dimensionality: Foundation model embeddings are typically high-dimensional (e.g., 768, 1024, or more). While Prototypical Networks handle this naturally, be mindful of the computational cost of distance calculations.
Normalization: It's often beneficial to L2-normalize both the support and query embeddings before calculating prototypes and distances. This makes the classification rely on the angle (cosine similarity) rather than magnitude, which can be advantageous in high dimensions where magnitudes might vary significantly. If using cosine similarity, normalization is inherent. For Euclidean distance, normalization turns it into a function of cosine similarity: $||u-v||^2_2 = 2 - 2 u \cdot v$ for normalized vectors $u, v$ .
Metric Choice: While Euclidean distance is standard, cosine distance (or similarity) might be more appropriate if the angular separation between class clusters is more informative than their positions in the embedding space, especially after normalization. Experimentation is key.

Visualizing the Process

The following diagram illustrates the core workflow for a single few-shot task:

Flow diagram illustrating the Prototypical Network process using pre-computed foundation model embeddings for a single N-way K-shot task. Support and query examples are embedded, prototypes are computed from support embeddings, and query embeddings are classified based on proximity to prototypes.

Evaluation and Next Steps

Evaluate the performance by calculating the accuracy (or other relevant metrics) of the predictions made on the query sets across multiple held-out tasks (meta-testing).

This practical implementation demonstrates the effectiveness of combining powerful pre-trained representations with the simple, yet effective, logic of Prototypical Networks. While we used fixed embeddings here, more advanced approaches might involve meta-learning the embedding function itself or fine-tuning parts of the foundation model during the meta-training phase, topics explored in other parts of this course. Comparing the results obtained with different distance metrics or normalization strategies can provide further insights into the geometry of the foundation model's embedding space for few-shot learning.