Prototypical Networks

Each class prototype is computed as the mean vector of its support set embeddings in the learned metric space. For a class k with support samples S_k, the prototype c_k is:

• c_k = (1/|S_k|) Σ f_φ(x_i) for all x_i in S_k

where f_φ is the embedding function (typically a CNN or transformer backbone). This simple averaging operation makes the method computationally efficient and analytically tractable, unlike more complex aggregation schemes. The prototype serves as a compact summary statistic for the entire class.

Query samples are classified by computing their distance to each class prototype and applying a softmax over distances. The probability of query x belonging to class k is:

• p(y=k|x) = exp(-d(f_φ(x), c_k)) / Σ exp(-d(f_φ(x), c_k'))

This formulation assumes classes form unimodal clusters in embedding space. The choice of distance metric—typically Euclidean distance or cosine similarity—significantly impacts performance. Euclidean distance is the default and works well when embeddings are properly normalized.

Training uses an episodic paradigm that explicitly simulates few-shot test scenarios. Each episode:

• Samples N classes from the training set (the 'way')
• Selects K support examples and Q query examples per class (the 'shot')
• Computes prototypes from support, classifies queries, and backpropagates loss

This train-test alignment is critical—the model learns to perform the exact task it will face at inference. Episodes are constructed randomly, exposing the model to thousands of unique classification problems during training.

Prototypical Networks are theoretically grounded in Bregman divergences. The use of squared Euclidean distance as the distance metric is not arbitrary—it corresponds to the assumption that class-conditional distributions are exponential family distributions with spherical covariance.

• If a different distance metric is desired, the embedding function must produce representations that satisfy the corresponding Bregman divergence properties
• This theoretical framework explains why linear class boundaries emerge in the embedding space
• The prototype-as-mean interpretation holds only when the distance is a Bregman divergence

Prototypical Networks naturally extend to zero-shot learning by replacing learned prototypes with semantic vectors. Instead of computing prototypes from support examples:

• Class prototypes are derived from attribute vectors or word embeddings of class names
• The same distance-based classification mechanism applies unchanged

For RF applications, this enables recognition of emitter types described only by textual metadata or technical specifications, without any IQ samples. The embedding space must be aligned with the semantic space during training.

In signal intelligence contexts, Prototypical Networks enable rapid adaptation to new emitters or modulation schemes with only 1-5 labeled IQ captures. The architecture is adapted as:

• Backbone: A complex-valued CNN or transformer processes raw IQ samples into embeddings
• Support Set: A handful of labeled signal captures from each known or newly encountered emitter
• Query: An unlabeled signal capture is classified by nearest prototype

This approach is particularly valuable when adversaries rapidly change transmission parameters or when collecting large labeled datasets of novel signals is operationally infeasible.

The downstream task that prototypical networks are designed to solve: classifying radio signal modulation types (BPSK, QPSK, 16QAM, etc.) using only 1 to 5 labeled examples per class. Traditional deep learning requires thousands of labeled IQ samples per modulation scheme, which is impractical in dynamic spectrum environments where new emitters appear constantly. Prototypical networks enable rapid adaptation by computing class prototypes from the limited support set and classifying query samples based on embedding space proximity.

The episodic training paradigm splits each training episode into two disjoint sets:

• Support Set: A small number of labeled examples (k shots) per class used to compute the class prototype as the mean embedding vector
• Query Set: Unlabeled examples used to evaluate classification performance by measuring distance to each prototype This mirrors the test-time scenario where only a few labeled examples are available. The model learns to learn from limited data rather than memorizing specific classes.

The standard distance function used in prototypical networks to compare query embeddings against class prototypes. For a query embedding f(x) and prototype c_k, the distance is computed as:

• d(f(x), c_k) = ||f(x) - c_k||² The query is assigned to the class with the minimum distance. While cosine similarity is sometimes used, Euclidean distance is preferred because it forms a proper Bregman divergence and works naturally with the squared error loss used during training.

The meta-learning training strategy where the model sees many mini-datasets (episodes) rather than a single large dataset. Each episode simulates a few-shot learning scenario:

• Randomly sample N classes from the training set
• Select K support examples and Q query examples per class
• Compute prototypes from support, classify queries, update via backpropagation This teaches the network to generalize across tasks rather than overfit to specific classes, enabling zero-shot transfer to entirely new modulation types at test time.

A closely related twin-branch architecture that learns pairwise similarity functions between signal samples. Unlike prototypical networks which compare queries to class prototypes, Siamese networks directly compare two inputs and output a similarity score. In RF applications, Siamese networks excel at:

• One-shot emitter identification: verifying if two signals come from the same transmitter
• Signal verification: confirming whether a received signal matches a known reference Both architectures share the core principle of learning an embedding space where distance corresponds to semantic similarity.