ProtoPNet: Interpretable Prototype Networks

• ProtoPNet is an interpretable neural network that uses learned class-specific prototypes to provide 'this looks like that' visual explanations.
• It leverages a convolutional backbone and a prototype layer that computes similarity via cosine or log-Euclidean metrics to map image patches to prototypes.
• The Proto-RSet framework enables rapid, precise prototype editing by allowing real-time adjustments within a computed Rashomon ellipsoid, reducing retraining time.

Prototypical Part Networks (ProtoPNets) are a class of intrinsically interpretable neural architectures designed for image classification settings where transparency of reasoning is crucial. The central paradigm is to learn class-specific prototypes—feature vectors representing prototypical parts—such that classification decisions are literal aggregations of similarities between an input image’s latent patches and these prototypes. The resulting “this looks like that” explanations allow direct inspection of model decision cues: for each prediction, the model identifies which part of the input resembles which prototype, with explicit pointers back to training examples. This family of models has driven research in interpretable machine learning, and has seen widespread application in computer vision, particularly in fine-grained domains and high-stakes user-facing tasks.

1. Architectural Foundation and Training Dynamics

A ProtoPNet consists of a backbone convolutional network $$f: \mathbb{R}^{c \times h \times w} \rightarrow \mathbb{R}^{c' \times h' \times w'}$$, commonly instantiated as VGG, ResNet, or DenseNet, mapping raw images into latent spatial feature maps. The prototype layer $g$ contains $m$ learnable prototypes $p_j \in \mathbb{R}^{c'}$—each a feature vector aligned with the backbone output channel structure. For input $X_i$, the model computes a similarity activation for each prototype: $$g_j(f(X_i)) = \max_{a,b} \operatorname{sim}(p_j, f(X_i)_{:,a,b})$$ where $(a,b)$ indexes spatial locations in the latent map, and $\operatorname{sim}$ is typically cosine similarity or log-Euclidean distance.

A linear head $h: \mathbb{R}^m \rightarrow \mathbb{R}^t$ produces class logits as: $$\hat y_i = \operatorname{softmax}(W_h \cdot g(f(X_i)) + b)$$ Here, $W_h \in \mathbb{R}^{t \times m}$, and $b \in \mathbb{R}^{t}$. At inference, case-based explanations are provided by displaying the top-activated image patches corresponding to prototypes with highest $W_h[c, j] \cdot g_j(f(X_i))$.

ProtoPNet training optimizes a composite loss: $$L_{\text{total}} = L_{\text{CE}} + \lambda_{\text{clst}} L_{\text{clst}} + \lambda_{\text{sep}} L_{\text{sep}} + \lambda_{\text{ortho}} L_{\text{ortho}} + \lambda_{\ell_1} \|W_h\|_1$$ where:

• $L_{\text{CE}}$ is standard classification cross-entropy,
• $L_{\text{clst}}$ encourages prototypes to be close to some patch of their own class,
• $L_{\text{sep}}$ pushes prototypes away from patches of other classes,
• $L_{\text{ortho}}$ optionally enforces prototype orthogonality,
• $L_{\ell_1}$ penalizes off-class weights in the head.

Training typically interleaves “warm-up” (training only prototypes and head), “joint” optimization, “projection” (hard assignment of prototypes to nearest in-class patches), and “last-layer only” fine-tuning of $W_h$ with frozen prototypes and backbone.

2. The Interaction Bottleneck: Editability Constraints

ProtoPNet’s direct explanations permit expert users to identify undesirable prototypes—such as those attending to confounders, spurious artifacts, or background regions. However, correction of these flaws conventionally requires retraining the model with new loss terms or constraints to remove or modify inappropriate prototypes. Each retraining cycle can span hours to days, and often necessitates repeated collaboration between domain experts and ML practitioners. This slow iteration impedes practical model development and hinders the adoption of interpretable models in high-stakes workflows (Donnelly et al., 3 Mar 2025).

3. The Rashomon Set and Real-Time Editable ProtoPNets (Proto-RSet)

To address editability, the Proto-RSet framework introduces a tractable Rashomon set approximation for ProtoPNets. The Rashomon set $$R(D; \theta) = \{(w_f, w_g, w_h): L(f, g, h; D) \leq \theta \}$$ is the set of all models close in empirical risk to a reference solution. As exact characterization is intractable, Proto-RSet fixes the backbone and prototype layer to a reference parameterization and considers the set of linear heads $w_h$ such that the regularized training loss remains below threshold $\theta$.

A second-order Taylor expansion around the optimal linear head $w_h^*$ defines an ellipsoidal surrogate: $$\bar{L}(w_h) \approx \bar{L}(w_h^*) + \frac{1}{2} (w_h - w_h^*)^{\top} H (w_h - w_h^*)$$ where $H$ is the Hessian of the loss at $w_h^*$.

The Rashomon set is thus approximated as

$$\bar{R}(D; \theta) = \left\{ w_h: \frac{1}{2} (w_h - w_h^*)^{\top} H (w_h - w_h^*) \leq \theta - \bar{L}(w_h^*) \right\}$$

For “positive-only” ProtoPNets (each prototype feeds a single class), $W_h$ can be block-diagonal, yielding a smaller $m \times m$ Hessian.

Proto-RSet enables:

• Sampling alternative heads within the Rashomon set ellipsoid,
• Removal (projection onto $e_j^{\top} w_h = 0$ hyperplane) or requirement ($e_j^{\top} w_h \geq \alpha$ via QP) of prototypes with closed-form guarantees,
• Swift intersection and updates of ellipsoidal constraints ($O(m^2)$ to $O(m^3)$ complexity).

All editing is performed on $W_h$, with no modification of $f$ or $g$, producing new models and explanations in seconds—enabling real-time, non-ML expert editability.

4. Quantitative and Qualitative Impact

Empirical comparisons against baseline retrain/removal approaches demonstrate strong quantitative advantages:

• Construction time for Rashomon set (Proto-RSet) is $\leq20$ minutes, compared to tens of GPU-hours for backbone training,
• Prototype removal (up to 100 per model) using Proto-RSet preserves or slightly improves test accuracy across CUB-200, Stanford Cars/Dogs, and multiple backbones,
• Removal takes $<2$ seconds per prototype; retraining baselines require tens of seconds to minutes; ProtoPDebug requires tens of minutes,
• Proto-RSet exactly guarantees removed-prototype weights are zero, whereas retraining cannot.

In a user paper on synthetic color-patch bias removal (CUB-200), 31 crowd-workers removed patch-based prototypes with Proto-RSet in an average of 2.1 min, with median accuracy drop $-0.5\%$. This compares to 93.7 min (ProtoPDebug, $\Delta \text{accuracy} +0.8\%$), 8.4 min (naive retrain, $-0.6\%$), and “instantaneous” naive removal ($-6.4\%$ degradation).

A medical use case—skin cancer (HAM10000)—saw 10 duplicate/irrelevant prototypes flagged by domain experts; Proto-RSet removed 9 and strictly refused the 10th (its loss would drop accuracy from 70.4% to 57.9%), leading to a refined 12-prototype model at 71.0% accuracy.

5. Interactive Editing Workflow and Deployment

Proto-RSet brings real-time interactive editing to ProtoPNets. The Rashomon ellipsoid is precomputed after backbone/prototype training, and domain experts interact with the model via UI: clicking to remove/require prototypes triggers low-latency ellipsoid projections or QP constraints, producing new $W_h$ and corresponding explanations immediately. Impossible removals/requirements are reported with theoretical certainty. This paradigm eliminates domain-expert/ML-expert “ping-pong” and empowers domain experts to steer prototype editing under explicit empirical risk bounds.

Proto-RSet can optionally augment the prototype bank with new candidate prototypes by random sampling in latent space, recalculating the Rashomon ellipsoid and reapplying all constraints.

6. Significance, Limitations, and Theoretical Guarantees

ProtoPNets, despite their interpretability, have historically suffered from the “interaction bottleneck”; Proto-RSet overcomes this by reducing the cost of model correction to seconds-long manipulations, preserving high classification accuracy and interpretability. All edits are guaranteed to remain within a specified empirical risk window, and constraints are enforced exactly. However, this approach relies on fixing $f$ and $g$; substantial changes to the feature extractor or latent space require retraining the initial backbone. The ellipsoidal Rashomon approximation is well-posed for the final linear head, but does not capture richer nonlinear reparameterizations. Nevertheless, in high-stakes settings where explanation-correctness and fast turnaround are mandatory, Proto-RSet marks a fundamental advance in the practical utility and editability of interpretable prototype-based classifiers.

7. Connections to Broader Research and Future Directions

The Rashomon set principle reflects a growing trend in interpretable ML: replacing expensive full-model retraining with tractable, constraint-satisfying post hoc modification of model parameters. Proto-RSet’s innovation builds on the “this looks like that” paradigm (Chen et al., 2018), integrating concepts from robust optimization and convex geometry to produce an actionable, real-time, end-user-facing interpretability workflow. This approach complements other interactive debugging tools such as ProtoPDebug (Bontempelli et al., 2022), reward-guided prototype refinement (Li et al., 2023), and concept-personalization schemes (Michalski et al., 5 Jun 2025). Future extensions may generalize Rashomon set optimization to nonlinear heads, structure-aware prototype layers, or apply similar methods to vision transformer-based prototype architectures (Xue et al., 2022).

In summary, ProtoPNet architectures and the Proto-RSet framework combine rigorous mathematical structure with operational editability—grounding prototype-based neural classification in workflows suited for transparent, ensemble-level decision making and domain-expert-centric model correction.