Metric Learning

Unlike standard classification that learns decision boundaries, metric learning learns a distance function directly from data. This function maps inputs to an embedding space where Euclidean or cosine distance reflects semantic similarity. The objective is to minimize intra-class distance while maximizing inter-class distance, creating tightly clustered, well-separated manifolds.

Training relies on structured loss functions that operate on pairs or triplets of samples:

• Contrastive Loss: Penalizes similar pairs that are far apart and dissimilar pairs that are too close.
• Triplet Loss: Uses an anchor, a positive sample (same class), and a negative sample (different class) to enforce a margin of separation. These losses directly shape the geometry of the embedding space.

Deep metric learning uses neural networks as non-linear embedding functions. A convolutional or transformer backbone extracts hierarchical features, transforming raw inputs (like IQ samples) into a compact vector where complex, non-linear relationships are flattened into a simple distance metric. This allows the model to learn invariances to nuisance factors like noise or channel impairments.

A defining characteristic is the ability to generalize to classes never seen during training. Because the model learns a universal similarity function rather than class-specific boundaries, it can compare a new, unlabeled query sample against a small support set of novel classes. Classification is performed by a nearest-neighbor lookup in the learned embedding space, making it foundational for few-shot learning.

To overcome the computational burden of sampling tuples from large datasets, modern approaches use proxies. A proxy is a learnable vector representing a class prototype. Losses like Proxy-NCA or Proxy-Anchor pull samples toward their class proxy and push them away from others. This reduces training complexity from O(N²) or O(N³) to O(N) while maintaining high retrieval performance.

Advanced metric learning objectives, such as ArcFace or CosFace, introduce an additive angular margin penalty in the softmax loss. By normalizing weights and features and adding a margin to the target logit, these methods enforce a stricter geodesic distance constraint on a hypersphere. This significantly enhances intra-class compactness and inter-class discrepancy, producing highly discriminative embeddings.

A learned, lower-dimensional vector representation where semantically similar inputs are mapped to nearby points. In modulation recognition, raw IQ samples are transformed into compact embeddings where signals of the same modulation scheme cluster together.

• Dimensionality Reduction: Compresses high-dimensional signal data into dense feature vectors
• Semantic Structure: Euclidean distance in this space corresponds to modulation similarity
• Visualization: t-SNE or UMAP projections reveal class separation quality

A well-trained embedding space is the prerequisite for any metric-based few-shot classifier.

A measure of similarity between two non-zero vectors computed as the cosine of the angle between them, ranging from -1 to 1. Unlike Euclidean distance, cosine similarity is magnitude-invariant, making it robust to variations in signal power.

• Formula: cos(θ) = (A·B) / (||A|| ||B||)
• Use Case: Default similarity metric in prototypical networks for comparing query embeddings to class prototypes
• Advantage: Normalizes out amplitude differences that are irrelevant to modulation identity

Often preferred over Euclidean distance when signal gain varies across captures.

A metric-based meta-learning algorithm that classifies query samples by computing their distance to a prototype representation—the mean vector of embedded support samples—for each class. The class with the nearest prototype wins.

• Prototype Calculation: c_k = (1/|S_k|) Σ f_φ(x_i) for all x_i in class k
• Distance Metric: Typically squared Euclidean distance or cosine similarity
• Training Objective: Minimize negative log-probability of correct class via softmax over distances

Simple yet highly effective for few-shot modulation recognition when combined with a strong embedding function.

The standard episodic training paradigm for few-shot learning where a model must discriminate between N novel classes given only K labeled examples per class in the support set. This explicitly simulates deployment conditions.

• 5-way 1-shot: Classify among 5 modulation types with only 1 example each
• 5-way 5-shot: Same 5 classes but with 5 labeled samples per class
• Episodic Structure: Each episode draws random classes and samples to prevent overfitting

Higher K generally improves accuracy, but metric learning aims to maximize performance even at K=1.

A loss function that trains embedding networks by pulling positive pairs (same class) together and pushing negative pairs (different classes) apart in the embedding space. This directly optimizes for the clustering behavior metric classifiers rely on.

• Siamese Networks: Twin networks process pairs with shared weights
• Triplet Loss: Uses anchor-positive-negative triplets with a margin constraint
• Supervised Contrastive Loss: Leverages full class labels for richer negative sampling

Contrastive objectives produce embeddings where simple nearest-neighbor rules achieve high accuracy.

A metric-based architecture that learns a deep nonlinear distance metric via a relation module—a small neural network—rather than using a fixed similarity function like cosine or Euclidean distance. The relation module takes a concatenated query-support pair and outputs a relation score.

• Learnable Metric: The relation module discovers complex similarity patterns
• Flexibility: Can capture non-linear relationships that fixed metrics miss
• End-to-End: Both the embedding function and the relation module are trained jointly

Particularly useful when modulation classes have subtle, non-linear distinguishing features in the embedding space.