Original: P ROTO A TTEND : A TTENTION -B ASED P ROTOTYPICAL L EARNING
Revised: P ROTO A TTEND : A TTENTION -B ASED P ROTOTYPICAL L EARNING

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: We propose a novel inherently interpretable machine learning method that bases decisions on few relevant examples that we call prototypes .
Revised: We propose a novel inherently interpretable machine learning method that bases decisions on few relevant examples that we call prototypes .

Original: Our method, ProtoAttend, can be integrated into a wide range of neural network architectures including pre-trained models.
Revised: Our method, ProtoAttend, can be integrated into a wide range of neural network architectures including pre-trained models.

Original: It utilizes an attention mechanism that relates the encoded representations to samples in order to determine prototypes.
Revised: It utilizes an attention mechanism that relates the encoded representations to samples in order to determine prototypes.

Original: The resulting model outperforms state of the art in three high impact problems without sacriﬁcing accuracy of the original model: (1) it enables high-quality interpretability that outputs samples most relevant to the decision-making (i.e. a sample-based interpretability method); (2) it achieves state of the art conﬁdence estimation by quantifying the mismatch across prototype labels; and (3) it obtains state of the art in distribution mismatch detection.
Revised: The resulting model outperforms state of the art in three high impact problems without sacriﬁcing accuracy of the original model: (1) it enables high-quality interpretability that outputs samples most relevant to the decision-making (i.e. a sample-based interpretability method); (2) it achieves state of the art conﬁdence estimation by quantifying the mismatch across prototype labels; and (3) it obtains state of the art in distribution mismatch detection.

Original: All this can be achieved with minimal additional test time and a practically viable training time computational cost.
Revised: All this can be achieved with minimal additional test time and a practically viable training time computational cost.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Deep neural networks have been pushing the frontiers of artiﬁcial intelligence (AI) by yielding excellent performance in numerous tasks, from understanding images (He et al., 2016) to text (Conneau et al., 2016).
Revised: Deep neural networks have been pushing the frontiers of artiﬁcial intelligence (AI) by yielding excellent performance in numerous tasks, from understanding images (He et al., 2016) to text (Conneau et al., 2016).

Original: Yet, high performance is not always a sufﬁcient factor - as some realworld deployment scenarios might necessitate that an ideal AI system is ‘interpretable’, such that it builds trust by explaining rationales behind decisions, allow detection of common failure cases and biases, and refrains from making decisions without sufﬁcient conﬁdence.
Revised: Yet, high performance is not always a sufﬁcient factor - as some realworld deployment scenarios might necessitate that an ideal AI system is ‘interpretable’, such that it builds trust by explaining rationales behind decisions, allow detection of common failure cases and biases, and refrains from making decisions without sufﬁcient conﬁdence.

Original: In their conventional form, deep neural networks are considered as black-box models – they are controlled by complex nonlinear interactions between many parameters that are difﬁcult to understand.
Revised: In their conventional form, deep neural networks are considered as black-box models – they are controlled by complex nonlinear interactions between many parameters that are difﬁcult to understand.

Original: There are numerous approaches, (Kim et al., 2018;
Revised: There are numerous approaches, (Kim et al., 2018;

Original: Erhan et al., 2009; Zeiler & Fergus, 2013; Simonyan et al., 2013), that bring post-hoc explainability of decisions to already-trained models.
Revised: Erhan et al., 2009; Zeiler & Fergus, 2013; Simonyan et al., 2013), that bring post-hoc explainability of decisions to already-trained models.

Original: Yet, these have the fundamental limitation that the models are not designed for interpretability.
Revised: Yet, these have the fundamental limitation that the models are not designed for interpretability.

Original: There are also approaches on the redesign of neural networks towards making them inherently-interpretable, as in this paper.
Revised: There are also approaches on the redesign of neural networks towards making them inherently-interpretable, as in this paper.

Original: Some notable ones include sequential attention (Bahdanau et al., 2015), capsule networks (Sabour et al., 2017), and interpretable convolutional ﬁlters (Zhang et al., 2018).
Revised: Some notable ones include sequential attention (Bahdanau et al., 2015), capsule networks (Sabour et al., 2017), and interpretable convolutional ﬁlters (Zhang et al., 2018).

Original: [Figure]
Revised: [Figure]

Original: We focus on inherently-interpretable deep neural network modeling with the foundations of prototypical learning .
Revised: We focus on inherently-interpretable deep neural network modeling with the foundations of prototypical learning .

Original: Prototypical learning decomposes decision making into known samples (see
Revised: Prototypical learning decomposes decision making into known samples (see

Original: Fig. 1), referred here as prototypes.
Revised: Fig. 1), referred here as prototypes.

Original: We base our method on the principle that prototypes should constitute a minimal subset of samples with high interpretable value that can serve as a distillation or condensed view of a dataset (Bien & Tibshirani, 2012).
Revised: We base our method on the principle that prototypes should constitute a minimal subset of samples with high interpretable value that can serve as a distillation or condensed view of a dataset (Bien & Tibshirani, 2012).

Original: Given that the number of objects a human can interpret is limited (Miller, 1956), outputting few prototypes can be an effective approach for humans to understand the AI model behavior.
Revised: Given that the number of objects a human can interpret is limited (Miller, 1956), outputting few prototypes can be an effective approach for humans to understand the AI model behavior.

Original: In addition to such interpretability, prototypical learning:
Revised: In addition to such interpretability, prototypical learning:

Original: (1) provides an efﬁcient conﬁdence metric by measuring mismatches in prototype labels, allowing performance to be improved by refraining from making predictions in the absence of sufﬁcient conﬁdence, (2) helps detect deviations in the test distribution by measuring mismatches in prototype labels that represent the support of the training dataset, and (3) enables performance in the high label noise regime to be improved by controlling the number of selected prototypes.
Revised: (1) provides an efﬁcient conﬁdence metric by measuring mismatches in prototype labels, allowing performance to be improved by refraining from making predictions in the absence of sufﬁcient conﬁdence, (2) helps detect deviations in the test distribution by measuring mismatches in prototype labels that represent the support of the training dataset, and (3) enables performance in the high label noise regime to be improved by controlling the number of selected prototypes.

Original: Given these motivations, prototypes should be controllable in number, and should be perceptually relevant to the input in explaining the decision making task.
Revised: Given these motivations, prototypes should be controllable in number, and should be perceptually relevant to the input in explaining the decision making task.

Original: Prototype selection in its naive form is computationally expensive and perceptually challenging (Bien & Tibshirani, 2012).
Revised: Prototype selection in its naive form is computationally expensive and perceptually challenging (Bien & Tibshirani, 2012).

Original: We design ProtoAttend to address this problem in an efﬁcient way.
Revised: We design ProtoAttend to address this problem in an efﬁcient way.

Original: Our contributions can be summarized as follows:
Revised: Our contributions can be summarized as follows:

Original: We present principles that can be guiding for the design of inherently-interpretable models based on sample-based interpretability.
Revised: We present principles that can be guiding for the design of inherently-interpretable models based on sample-based interpretability.

Original: We propose a novel method, ProtoAttend, for selecting input-dependent prototypes based on an attention mechanism between the input and prototype candidates.
Revised: We propose a novel method, ProtoAttend, for selecting input-dependent prototypes based on an attention mechanism between the input and prototype candidates.

Original: ProtoAttend is model-agnostic and can even be integrated with pre-trained models.
Revised: ProtoAttend is model-agnostic and can even be integrated with pre-trained models.

Original: ProtoAttend allows interpreting the contribution of each prototype via the attention outputs.
Revised: ProtoAttend allows interpreting the contribution of each prototype via the attention outputs.

Original: For a ‘condensed view’, we demonstrate that sparsity in weights can be efﬁciently imposed via the choice of the attention normalization and additional regularization.
Revised: For a ‘condensed view’, we demonstrate that sparsity in weights can be efﬁciently imposed via the choice of the attention normalization and additional regularization.

Original: On image, text and tabular data, we demonstrate the four key beneﬁts of ProtoAttend: interpretability, conﬁdence control, diagnosis of distribution mismatch, and robustness against label noise.
Revised: On image, text and tabular data, we demonstrate the four key beneﬁts of ProtoAttend: interpretability, conﬁdence control, diagnosis of distribution mismatch, and robustness against label noise.

Original: ProtoAttend yields superior quality for sample-based interpretability, better-calibrated conﬁdence scoring, and more sensitive out-of-distribution detection compared to alternative approaches.
Revised: ProtoAttend yields superior quality for sample-based interpretability, better-calibrated conﬁdence scoring, and more sensitive out-of-distribution detection compared to alternative approaches.

Original: ProtoAttend enables all these beneﬁts via the same architecture and method, while maintaining comparable overall accuracy.
Revised: ProtoAttend enables all these beneﬁts via the same architecture and method, while maintaining comparable overall accuracy.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Prototypical learning: The principles of ProtoAttend are inspired by (Bien & Tibshirani, 2012).
Revised: Prototypical learning: The principles of ProtoAttend are inspired by (Bien & Tibshirani, 2012).

Original: They formulate prototype selection as an integer program and solve it using a greedy approach with linear program relaxation.
Revised: They formulate prototype selection as an integer program and solve it using a greedy approach with linear program relaxation.

Original: It seems unclear whether such approaches can be efﬁciently adopted to deep learning.
Revised: It seems unclear whether such approaches can be efﬁciently adopted to deep learning.

Original: (Chen et al., 2018) and (Li et al., 2018) introduce a prototype layer for interpretability by replacing the conventional inner product with a distance computation for perceptual similarity.
Revised: (Chen et al., 2018) and (Li et al., 2018) introduce a prototype layer for interpretability by replacing the conventional inner product with a distance computation for perceptual similarity.

Original: In contrast, our method uses an attention mechanism to quantify perceptual similarity and can choose input-dependent prototypes from a large-scale candidate database.
Revised: In contrast, our method uses an attention mechanism to quantify perceptual similarity and can choose input-dependent prototypes from a large-scale candidate database.

Original: (Yeh et al., 2018) decomposes the prediction into a linear combination of activations of training points for interpretability using representer values.
Revised: (Yeh et al., 2018) decomposes the prediction into a linear combination of activations of training points for interpretability using representer values.

Original: The linear decomposition idea also exists in ProtoAttend, but the weights are learned via an attention mechanism and sparsity is encouraged in the decomposition.
Revised: The linear decomposition idea also exists in ProtoAttend, but the weights are learned via an attention mechanism and sparsity is encouraged in the decomposition.

Original: In (Koh &
Revised: In (Koh &

Original: Liang, 2017), the training points that are the most responsible for a given prediction are identiﬁed using inﬂuence functions via oracle access to gradients and Hessian-vector products.
Revised: Liang, 2017), the training points that are the most responsible for a given prediction are identiﬁed using inﬂuence functions via oracle access to gradients and Hessian-vector products.

Original: Metric learning: Metric learning aims to ﬁnd an embedding representation of the data where similar data points are close and dissimilar data pointers are far from each other.
Revised: Metric learning: Metric learning aims to ﬁnd an embedding representation of the data where similar data points are close and dissimilar data pointers are far from each other.

Original: ProtoAttend is motivated by efﬁcient learning of such an embedding space which can be used to decompose decisions.
Revised: ProtoAttend is motivated by efﬁcient learning of such an embedding space which can be used to decompose decisions.

Original: Metric learning for deep neural networks is typically based on modiﬁcations to the objective function, such as using triplet loss and N-pair loss (Sohn, 2016; Cui et al., 2016; Hoffer & Ailon, 2014).
Revised: Metric learning for deep neural networks is typically based on modiﬁcations to the objective function, such as using triplet loss and N-pair loss (Sohn, 2016; Cui et al., 2016; Hoffer & Ailon, 2014).

Original: These yield perceptually meaningful embedding spaces yet typically require a large subset of nearest neighbors to avoid degradation in performance (Cui et al., 2016).
Revised: These yield perceptually meaningful embedding spaces yet typically require a large subset of nearest neighbors to avoid degradation in performance (Cui et al., 2016).

Original: (Kim et al., 2018) proposes a deep metric learning framework which employs an attention-based ensemble with a divergence loss so that each learner can attend to different parts of the object.
Revised: (Kim et al., 2018) proposes a deep metric learning framework which employs an attention-based ensemble with a divergence loss so that each learner can attend to different parts of the object.

Original: Our method has metric learning capabilities like relating similar data points, but also performs well on the ultimate supervised learning task.
Revised: Our method has metric learning capabilities like relating similar data points, but also performs well on the ultimate supervised learning task.

Original: Attention-based few-shot learning: Some of our inspirations are based on recent advances in attention-based few-shot learning.
Revised: Attention-based few-shot learning: Some of our inspirations are based on recent advances in attention-based few-shot learning.

Original: In (Vinyals et al., 2016), an attention mechanism is used to relate an example with candidate examples from a support set using a weighted nearest-neighbor classiﬁer applied within an embedding space.
Revised: In (Vinyals et al., 2016), an attention mechanism is used to relate an example with candidate examples from a support set using a weighted nearest-neighbor classiﬁer applied within an embedding space.

Original: In (Ren et al., 2018), incremental few-shot learning is implemented using an attention attractor network on the encoded and support sets.
Revised: In (Ren et al., 2018), incremental few-shot learning is implemented using an attention attractor network on the encoded and support sets.

Original: In (Snell et al., 2017), a non-linear mapping is learned to determine the prototype of a class as the mean of its support set in the embedding space.
Revised: In (Snell et al., 2017), a non-linear mapping is learned to determine the prototype of a class as the mean of its support set in the embedding space.

Original: During training, the support set is randomly sampled to mimic the inference task.
Revised: During training, the support set is randomly sampled to mimic the inference task.

Original: Overall, the attention mechanism in our method follows related principles but fundamentally differs in that few-shot learning aims for generalization to unseen classes whereas the goal of our method is robust and interpretable learning for seen classes.
Revised: Overall, the attention mechanism in our method follows related principles but fundamentally differs in that few-shot learning aims for generalization to unseen classes whereas the goal of our method is robust and interpretable learning for seen classes.

Original: Uncertainty and conﬁdence estimation: ProtoAttend takes a novel perspective on the perennial problem of quantifying how much deep neural networks’ predictions can be trusted.
Revised: Uncertainty and conﬁdence estimation: ProtoAttend takes a novel perspective on the perennial problem of quantifying how much deep neural networks’ predictions can be trusted.

Original: Common approaches are based on using the scores from the prediction model, such as the probabilities from the softmax layer of a neural network, yet it has been shown that the raw conﬁdence values are typically poorly calibrated (Guo et al., 2017).
Revised: Common approaches are based on using the scores from the prediction model, such as the probabilities from the softmax layer of a neural network, yet it has been shown that the raw conﬁdence values are typically poorly calibrated (Guo et al., 2017).

Original: Ensemble of models (Lakshminarayanan et al., 2017) is one of the simplest and most efﬁcient approaches, but signiﬁcantly increases complexity and decreased interpretability.
Revised: Ensemble of models (Lakshminarayanan et al., 2017) is one of the simplest and most efﬁcient approaches, but signiﬁcantly increases complexity and decreased interpretability.

Original: In (Papernot & McDaniel, 2018), the intermediate representations of the network are used to deﬁne a distance metric, and a conﬁdence metric is proposed based on the conformity of the neighbors.
Revised: In (Papernot & McDaniel, 2018), the intermediate representations of the network are used to deﬁne a distance metric, and a conﬁdence metric is proposed based on the conformity of the neighbors.

Original: (Jiang et al., 2018), proposes a conﬁdence metric based on the agreement between the classiﬁer and a modiﬁed nearest-neighbor classiﬁer on the test sample.
Revised: (Jiang et al., 2018), proposes a conﬁdence metric based on the agreement between the classiﬁer and a modiﬁed nearest-neighbor classiﬁer on the test sample.

Original: In (DeVries & Taylor, 2018), direct inference of conﬁdence output is considered with a modiﬁed loss.
Revised: In (DeVries & Taylor, 2018), direct inference of conﬁdence output is considered with a modiﬁed loss.

Original: Another direction of uncertainty and conﬁdence estimation is Bayesian neural networks that return a distribution over the outputs (Kendall & Gal, 2017b)
Revised: Another direction of uncertainty and conﬁdence estimation is Bayesian neural networks that return a distribution over the outputs (Kendall & Gal, 2017b)

Original: (Mullachery et al., 2018)
Revised: (Mullachery et al., 2018)

Original: (Kendall & Gal, 2017a).
Revised: (Kendall & Gal, 2017a).

Original:  P ROTO A TTEND : A TTENTION - BASED P ROTOTYPICAL L EARNING
Revised:  P ROTO A TTEND : A TTENTION - BASED P ROTOTYPICAL L EARNING

Original: Consider a training set with samples, T = { x i , y i } .
Revised: Consider a training set with samples, T = { x i , y i } .

Original: Conventional supervised learning aims to learn a model s ( x i ; S ) that minimizes a predeﬁned loss 1 /B · (cid:80)
Revised: Conventional supervised learning aims to learn a model s ( x i ; S ) that minimizes a predeﬁned loss 1 /B · (cid:80)

Original: Bi
Revised: Bi

Original: =1 L ( y i , ˆ y i
Revised: =1 L ( y i , ˆ y i

Original: =
Revised: =

Original: s ( x i ; S )) 1 at each iteration, where B is the batch size for training.
Revised: s ( x i ; S )) 1 at each iteration, where B is the batch size for training.

Original: Our goal is to impose that decision making should be based on only a small number of training examples, i.e. prototypes , such that their linear superposition in an embedding space can yield the overall decision and the superposition weights correspond to their importance.
Revised: Our goal is to impose that decision making should be based on only a small number of training examples, i.e. prototypes , such that their linear superposition in an embedding space can yield the overall decision and the superposition weights correspond to their importance.

Original: Towards this goal, we propose deﬁning a solution to prototypical learning with the following six principles
Revised: Towards this goal, we propose deﬁning a solution to prototypical learning with the following six principles

Original: : i. v i = f
Revised: : i. v i = f

Original: ( x i ; θ ) encodes all relevant information of x i for the ﬁnal decision.
Revised: ( x i ; θ ) encodes all relevant information of x i for the ﬁnal decision.

Original: f () considers the global distribution of the samples, i.e. learns from all { x i , y i } .
Revised: f () considers the global distribution of the samples, i.e. learns from all { x i , y i } .

Original: Although all the information in training dataset is embodied in the weights of the encoder 2 , we construct the learning method in such a way that decision is dominated by the prototypes with high weights.
Revised: Although all the information in training dataset is embodied in the weights of the encoder 2 , we construct the learning method in such a way that decision is dominated by the prototypes with high weights.

Original: ii.
Revised: ii.

Original: From the encoded information, we can ﬁnd a decision function so that the mapping g ( v i ; η ) is close to the ground truth y i , in a consistent way with conventional supervised learning.
Revised: From the encoded information, we can ﬁnd a decision function so that the mapping g ( v i ; η ) is close to the ground truth y i , in a consistent way with conventional supervised learning.

Original: iii.
Revised: iii.

Original: Given candidates x ( c ) j to select the prototypes from, there exists weights p i,j (where p i,j ≥and (cid:80) Dj =1 p
Revised: Given candidates x ( c ) j to select the prototypes from, there exists weights p i,j (where p i,j ≥and (cid:80) Dj =1 p

Original: i,j = 1 ), such that the decision g ( (cid:80) Dj =1 p i,j v ( c ) j ; η ) (where v ( c ) j = f ( x ( c ) j ; θ ) ) is close to the ground truth y i .
Revised: i,j = 1 ), such that the decision g ( (cid:80) Dj =1 p i,j v ( c ) j ; η ) (where v ( c ) j = f ( x ( c ) j ; θ ) ) is close to the ground truth y i .

Original: iv.
Revised: iv.

Original: When the linear combination (cid:80) Dj =1 p i,j v ( c ) j is considered, prototypes with higher weights p
Revised: When the linear combination (cid:80) Dj =1 p i,j v ( c ) j is considered, prototypes with higher weights p

Original: i,j have higher contribution in the decision g ( (cid:80) Dj =1 p
Revised: i,j have higher contribution in the decision g ( (cid:80) Dj =1 p

Original: i,j v ( c ) j ; η ) .
Revised: i,j v ( c ) j ; η ) .

Original: v. The weights should be sparse – only a controllable amount of weights p
Revised: v. The weights should be sparse – only a controllable amount of weights p

Original: i,j should be nonzero.
Revised: i,j should be nonzero.

Original: Ideally, there exists an efﬁcient mechanism for outputting p i,j to control the sparsity without signiﬁcantly affecting performance.
Revised: Ideally, there exists an efﬁcient mechanism for outputting p i,j to control the sparsity without signiﬁcantly affecting performance.

Original: vi.
Revised: vi.

Original: The weights p i,j depend on the relation between input and the candidate samples, p i,j = r ( x i , x ( c ) j ; Γ ) , based on their perceptual relation for decision making.
Revised: The weights p i,j depend on the relation between input and the candidate samples, p i,j = r ( x i , x ( c ) j ; Γ ) , based on their perceptual relation for decision making.

Original: We do not introduce any heuristic relatedness metric such as distances in the representation space, but we allow the model to learn the relation function that helps the overall performance.
Revised: We do not introduce any heuristic relatedness metric such as distances in the representation space, but we allow the model to learn the relation function that helps the overall performance.

Original: Learning involves optimization of the parameters θ, Γ , η of
Revised: Learning involves optimization of the parameters θ, Γ , η of

Original: the corresponding
Revised: the corresponding

Original: functions.
Revised: functions.

Original: If
Revised: If

Original: the proposed principles (such as reasoning from the linear combination of embeddings or assigning relevance to the weights) are not imposed during training but only at inference, a high performance cannot be obtained due to the train-test mismatch, as the intermediate representations can be learned in an arbitrary way without any necessities to satisfy them.
Revised: the proposed principles (such as reasoning from the linear combination of embeddings or assigning relevance to the weights) are not imposed during training but only at inference, a high performance cannot be obtained due to the train-test mismatch, as the intermediate representations can be learned in an arbitrary way without any necessities to satisfy them.

Original: The subsequent section presents
Revised: The subsequent section presents

Original: ProtoAttend and training procedure to implement it.
Revised: ProtoAttend and training procedure to implement it.

Original: 3. N ETWORK ARCHITECTURE AND TRAINING
Revised: 3. N ETWORK ARCHITECTURE AND TRAINING

Original: The principles above are conditioned on efﬁcient learning of an encoding function to encode the relevant information for decision making, a relation function to determine the prototype weights, and 1 S represents the trainable parameters for s (; S ) and is sometimes not show for notation convenience.
Revised: The principles above are conditioned on efﬁcient learning of an encoding function to encode the relevant information for decision making, a relation function to determine the prototype weights, and 1 S represents the trainable parameters for s (; S ) and is sometimes not show for notation convenience.

Original: Training of f () may also involve initializing with pre-trained models or transfer learning.
Revised: Training of f () may also involve initializing with pre-trained models or transfer learning.

Original: For example, commonly-used distance metrics in the representation spaces fail at determining perceptual relevance between samples when the model is trained in a vanilla way (Sitawarin & Wagner, 2019).
Revised: For example, commonly-used distance metrics in the representation spaces fail at determining perceptual relevance between samples when the model is trained in a vanilla way (Sitawarin & Wagner, 2019).

Original: a ﬁnal decision making block to return the output.
Revised: a ﬁnal decision making block to return the output.

Original: Conventional supervised learning comprises the encoding and decision blocks.
Revised: Conventional supervised learning comprises the encoding and decision blocks.

Original: On the other hand, it is challenging to design a learning method with a relation function with a reasonable complexity.
Revised: On the other hand, it is challenging to design a learning method with a relation function with a reasonable complexity.

Original: To this end, we adapt the idea of attention (Corbetta & Shulman, 2002; Vaswani et al., 2017), where the model focuses on an adaptive small portion of input while making the decision.
Revised: To this end, we adapt the idea of attention (Corbetta & Shulman, 2002; Vaswani et al., 2017), where the model focuses on an adaptive small portion of input while making the decision.

Original: Different from conventional employment of attention in sequence or visual learning, we propose to use attention at sample level, such that the attention mechanism is used to determine the prototype weights by relating the input and the candidate samples via alignment of their keys and queries.
Revised: Different from conventional employment of attention in sequence or visual learning, we propose to use attention at sample level, such that the attention mechanism is used to determine the prototype weights by relating the input and the candidate samples via alignment of their keys and queries.

Original: Fig.
Revised: Fig.

Original: 2 shows the proposed architecture for training and inference.
Revised: 2 shows the proposed architecture for training and inference.

Original: The three main blocks are described below:
Revised: The three main blocks are described below:

Original: [Figure]
Revised: [Figure]

Original: Encoder:
Revised: Encoder:

Original: A trainable encoder is employed to transform B input samples (note that B may be 1 at inference) and D samples from the database of prototype candidates (note that D may be as large as the entire training dataset at inference) into keys, queries and values.
Revised: A trainable encoder is employed to transform B input samples (note that B may be 1 at inference) and D samples from the database of prototype candidates (note that D may be as large as the entire training dataset at inference) into keys, queries and values.

Original: The encoder is shared and jointly updated for the input samples and prototype candidate database, to learn a common representation space for the values.
Revised: The encoder is shared and jointly updated for the input samples and prototype candidate database, to learn a common representation space for the values.

Original: The encoder architecture can be based on any trainable discriminative feature mapping function, e.g. ResNet (He et al., 2016) for images, with the modiﬁcation of generating three types of embeddings.
Revised: The encoder architecture can be based on any trainable discriminative feature mapping function, e.g. ResNet (He et al., 2016) for images, with the modiﬁcation of generating three types of embeddings.

Original: For mapping of the last encoder layer to key, query and value embeddings, we simply use a single fully-connected layer with a nonlinearity, separately for each.
Revised: For mapping of the last encoder layer to key, query and value embeddings, we simply use a single fully-connected layer with a nonlinearity, separately for each.

Original: 4 For input samples, V ∈ (cid:60) B × d out and Q ∈ (cid:60) B ×
Revised: 4 For input samples, V ∈ (cid:60) B × d out and Q ∈ (cid:60) B ×

Original: d att denote the values and queries, and for candidate database samples K ( c ) ∈ (cid:60) D × d att and V ( c ) ∈ (cid:60) D
Revised: d att denote the values and queries, and for candidate database samples K ( c ) ∈ (cid:60) D × d att and V ( c ) ∈ (cid:60) D

Original: × d out denote the keys and values.
Revised: × d out denote the keys and values.

Original: For keys and queries, we use separate representations as the entire system is not symmetric, there are a lot of candidate samples and the model may prefer to learn the keys to arrange the representation space such that it is meaningful when their inner products with a single query are considered.
Revised: For keys and queries, we use separate representations as the entire system is not symmetric, there are a lot of candidate samples and the model may prefer to learn the keys to arrange the representation space such that it is meaningful when their inner products with a single query are considered.

Original: Relational attention:
Revised: Relational attention:

Original: The relational attention yields the weight between the i th sample and j th candidate, p i,j , via alignment of the corresponding key and query in dot-product attention form 5 :
Revised: The relational attention yields the weight between the i th sample and j th candidate, p i,j , via alignment of the corresponding key and query in dot-product attention form 5 :

Original: [Equation]
Revised: [Equation]

Original: where n () is a normalization function to satisfy p i,j ≥ 0 and (cid:80) Dj =1 p i,j = 1 for which we consider softmax and sparsemax (Martins & Astudillo, 2016) 6 .
Revised: where n () is a normalization function to satisfy p i,j ≥ 0 and (cid:80) Dj =1 p i,j = 1 for which we consider softmax and sparsemax (Martins & Astudillo, 2016) 6 .

Original: The choice of the normalization function is an efﬁcient mechanism to control the sparsity of the prototype weights, as demonstrated in experiments.
Revised: The choice of the normalization function is an efﬁcient mechanism to control the sparsity of the prototype weights, as demonstrated in experiments.

Original: Note that the relational attention mechanism does not introduce any extra trainable parameters.
Revised: Note that the relational attention mechanism does not introduce any extra trainable parameters.

Original: Decision making: The ﬁnal decision block simply consists of a linear mapping from a convex combination of values that results in the output y i .
Revised: Decision making: The ﬁnal decision block simply consists of a linear mapping from a convex combination of values that results in the output y i .

Original: Consider the convex combination of value embeddings, parameterized by α :
Revised: Consider the convex combination of value embeddings, parameterized by α :

Original: [Equation]
Revised: [Equation]

Original: For α = 0 , L ( y i , ˆ y i (0)) is the conventional supervised learning loss (ignoring the relational attention mechanism) that can only impose principles (i) and (ii), but not the principles (iii)-(vi).
Revised: For α = 0 , L ( y i , ˆ y i (0)) is the conventional supervised learning loss (ignoring the relational attention mechanism) that can only impose principles (i) and (ii), but not the principles (iii)-(vi).

Original: A high accuracy for ˆ y i (0) merely indicates that the value embedding space represents each input sample accurately.
Revised: A high accuracy for ˆ y i (0) merely indicates that the value embedding space represents each input sample accurately.

Original: For α = 1 , L ( y i , ˆ y i (1)) encourages the principles (i), (iii)-(iv), but not the principles (ii) and (vi).
Revised: For α = 1 , L ( y i , ˆ y i (1)) encourages the principles (i), (iii)-(iv), but not the principles (ii) and (vi).

Original: 7 A high accuracy for ˆ y i (1) indicates that the linear combination of value embeddings accurately maps to the decision.
Revised: 7 A high accuracy for ˆ y i (1) indicates that the linear combination of value embeddings accurately maps to the decision.

Original: For (vi), we propose that there should be a similar output mapping for the input and prototypes, for which we encourage high accuracy for both ˆ y i (0) and ˆ y i (1) with a loss term that is a mixture of L ( y i , ˆ y i (0)) and L ( y i , ˆ y i (1)) or guidance with an intermediate term, as ˆ y i (0 . 5) , is required.
Revised: For (vi), we propose that there should be a similar output mapping for the input and prototypes, for which we encourage high accuracy for both ˆ y i (0) and ˆ y i (1) with a loss term that is a mixture of L ( y i , ˆ y i (0)) and L ( y i , ˆ y i (1)) or guidance with an intermediate term, as ˆ y i (0 . 5) , is required.

Original: Lastly, when α ≤ 0 . 5 , we obtain the condition that the input sample itself has the largest contribution in the linear combination.
Revised: Lastly, when α ≤ 0 . 5 , we obtain the condition that the input sample itself has the largest contribution in the linear combination.

Original: Intuitively, the sample itself should be more relevant for the output compared to other samples, so the principles (iii) and (iv) can be encouraged.
Revised: Intuitively, the sample itself should be more relevant for the output compared to other samples, so the principles (iii) and (iv) can be encouraged.

Original: We propose and compare different training objective functions in Table 1.
Revised: We propose and compare different training objective functions in Table 1.

Original: We observe that the last four are all viable options as the training objective, with similar performance.
Revised: We observe that the last four are all viable options as the training objective, with similar performance.

Original: We choose the last one for the rest of the experiments, as in some cases, slightly better prototypes are observed qualitatively (see Sect.
Revised: We choose the last one for the rest of the experiments, as in some cases, slightly better prototypes are observed qualitatively (see Sect.

Original: 5.2 for further discussion).
Revised: 5.2 for further discussion).

Original: [Table]
Revised: [Table]

Original: ˆ y i (0)) 94.
Revised: ˆ y i (0)) 94.

Original: L ( y i , ˆ y i (1)) 10.
Revised: L ( y i , ˆ y i (1)) 10.

Original: L ( y i , ˆ y i (0 . 5)) 94.
Revised: L ( y i , ˆ y i (0 . 5)) 94.

Original: L ( y i , ˆ y i (0))
Revised: L ( y i , ˆ y i (0))

Original: + L ( y i , ˆ y i (1)) 94.
Revised: + L ( y i , ˆ y i (1)) 94.

Original: (1 − i/N t ) ·
Revised: (1 − i/N t ) ·

Original: L ( y i , ˆ y i (0))
Revised: L ( y i , ˆ y i (0))

Original: + ( i/N t ) ·
Revised: + ( i/N t ) ·

Original: L ( y i , ˆ y i (1)) 94.
Revised: L ( y i , ˆ y i (1)) 94.

Original: L ( y i , ˆ y i (0))
Revised: L ( y i , ˆ y i (0))

Original: + L ( y i , ˆ y i (1))
Revised: + L ( y i , ˆ y i (1))

Original: +
Revised: +

Original: L ( y i , ˆ y i (0 . 5)) 94.
Revised: L ( y i , ˆ y i (0 . 5)) 94.

Original: To control the sparsity of the weights (beyond the choice of the attention operation), we also propose a sparsity regularization term with a coefﬁcient λ sparse in the form of entropy, L sparse ( p ) = − 1 /B (cid:80) Bi
Revised: To control the sparsity of the weights (beyond the choice of the attention operation), we also propose a sparsity regularization term with a coefﬁcient λ sparse in the form of entropy, L sparse ( p ) = − 1 /B (cid:80) Bi

Original: =1 (cid:80) Dj =1 p
Revised: =1 (cid:80) Dj =1 p

Original: i,j log( p i,j + (cid:15) ) , where (cid:15) is a small number for numerical stability.
Revised: i,j log( p i,j + (cid:15) ) , where (cid:15) is a small number for numerical stability.

Original: L sparse ( p ) is minimized when p has only 1 non-zero value.
Revised: L sparse ( p ) is minimized when p has only 1 non-zero value.

Original: 3. C ONFIDENCE SCORING USING PROTOTYPES
Revised: 3. C ONFIDENCE SCORING USING PROTOTYPES

Original: ProtoAttend provides a linear decomposition (via value embeddings) of the decision into prototypes that have known labels.
Revised: ProtoAttend provides a linear decomposition (via value embeddings) of the decision into prototypes that have known labels.

Original: Ideally, labels of the prototypes should all be the same as the labels of the simply assigning non-zero weights to another predetermined class, prototypical learning method can obtain perfect accuracy, but the assignment of predetermined class would be arbitrary.
Revised: Ideally, labels of the prototypes should all be the same as the labels of the simply assigning non-zero weights to another predetermined class, prototypical learning method can obtain perfect accuracy, but the assignment of predetermined class would be arbitrary.

Original: input.
Revised: input.

Original: When prototypes with high weights belong to the same class, the model shall be more conﬁdent and a correct classiﬁcation result is expected, whereas in the cases of disagreement between prototype labels, the model shall be less conﬁdent and the likelihood of a wrong prediction is higher.
Revised: When prototypes with high weights belong to the same class, the model shall be more conﬁdent and a correct classiﬁcation result is expected, whereas in the cases of disagreement between prototype labels, the model shall be less conﬁdent and the likelihood of a wrong prediction is higher.

Original: With the motivation of separating correct vs. incorrect decisions via its value, we propose a conﬁdence score based on the agreement between the prototypes:
Revised: With the motivation of separating correct vs. incorrect decisions via its value, we propose a conﬁdence score based on the agreement between the prototypes:

Original: [Equation]
Revised: [Equation]

Original: where I () is the indicator function.
Revised: where I () is the indicator function.

Original: Table 1 shows the signiﬁcant difference of the average conﬁdence metric between correct vs. incorrect classiﬁcation cases for the test dataset, as desired.
Revised: Table 1 shows the signiﬁcant difference of the average conﬁdence metric between correct vs. incorrect classiﬁcation cases for the test dataset, as desired.

Original: In Fig.
Revised: In Fig.

Original: 3, the impact of conﬁdence on accuracy is further analyzed with the reliability diagram as in (Papernot &
Revised: 3, the impact of conﬁdence on accuracy is further analyzed with the reliability diagram as in (Papernot &

Original: McDaniel, 2018).
Revised: McDaniel, 2018).

Original: When test samples are binned according to their conﬁdence, it is observed that the bins with higher conﬁdence yield much higher accuracy.
Revised: When test samples are binned according to their conﬁdence, it is observed that the bins with higher conﬁdence yield much higher accuracy.

Original: There are small number of samples in the bins with lower conﬁdence, and those tend to be the incorrect classiﬁcation cases.
Revised: There are small number of samples in the bins with lower conﬁdence, and those tend to be the incorrect classiﬁcation cases.

Original: In Section 4.4, the efﬁcacy of conﬁdence score in separating correct vs. incorrect classiﬁcation is experimented in conﬁdence-controlled prediction setting, demonstrating how much the prediction accuracy can be improved by refraining from small number of samples with low conﬁdence at test time.
Revised: In Section 4.4, the efﬁcacy of conﬁdence score in separating correct vs. incorrect classiﬁcation is experimented in conﬁdence-controlled prediction setting, demonstrating how much the prediction accuracy can be improved by refraining from small number of samples with low conﬁdence at test time.

Original: To further encourage conﬁdence during training, we also consider a regularization term L conf ( p ) = − 1 /B (cid:80) Bi
Revised: To further encourage conﬁdence during training, we also consider a regularization term L conf ( p ) = − 1 /B (cid:80) Bi

Original: =1 (cid:80) Dj =1 p
Revised: =1 (cid:80) Dj =1 p

Original: i,j · I ( y ( c ) j = y i ) with a coefﬁcient λ conf .
Revised: i,j · I ( y ( c ) j = y i ) with a coefﬁcient λ conf .

Original: L conf is minimized when all prototypes with p i,j > 0 are from the same ground truth class with output y i .
Revised: L conf is minimized when all prototypes with p i,j > 0 are from the same ground truth class with output y i .

Original:  E XPERIMENTS 4. S ETUP
Revised:  E XPERIMENTS 4. S ETUP

Original: We demonstrate the results of ProtoAttend for image, text and tabular data classiﬁcation problems with different encoder architectures (see Supplementary Material for details).
Revised: We demonstrate the results of ProtoAttend for image, text and tabular data classiﬁcation problems with different encoder architectures (see Supplementary Material for details).

Original: Outputs of the encoders are mapped to queries, keys and values using a fully-connected layer followed by ReLU.
Revised: Outputs of the encoders are mapped to queries, keys and values using a fully-connected layer followed by ReLU.

Original: For values, layer normalization (Lei Ba et al., 2016) is employed for more stable training.
Revised: For values, layer normalization (Lei Ba et al., 2016) is employed for more stable training.

Original: A fully-connected layer is used in the decision making block, yielding logits for determining the estimated class.
Revised: A fully-connected layer is used in the decision making block, yielding logits for determining the estimated class.

Original: Softmax cross entropy loss is used as L () .
Revised: Softmax cross entropy loss is used as L () .

Original: Adam optimization algorithm is employed (Kingma & Ba, 2014) with exponential learning rate decay (with parameters optimized on a validation set).
Revised: Adam optimization algorithm is employed (Kingma & Ba, 2014) with exponential learning rate decay (with parameters optimized on a validation set).

Original: For image encoding, unless speciﬁed, we use the standard ResNet model (He et al., 2016).
Revised: For image encoding, unless speciﬁed, we use the standard ResNet model (He et al., 2016).

Original: For text encoding, we use the very deep convolutional neural network (VDCNN) (Conneau et al., 2016) model, inputting sequence of raw characters.
Revised: For text encoding, we use the very deep convolutional neural network (VDCNN) (Conneau et al., 2016) model, inputting sequence of raw characters.

Original: For tabular data encoding, we use an LSTM model (Hochreiter &
Revised: For tabular data encoding, we use an LSTM model (Hochreiter &

Original: Schmidhuber, 1997), which inputs the feature embeddings at every timestep.
Revised: Schmidhuber, 1997), which inputs the feature embeddings at every timestep.

Original: See Supplementary
Revised: See Supplementary

Original: Material for implementation details, additional results and discussions.
Revised: Material for implementation details, additional results and discussions.

Original: 4. S PARSE EXPLANATIONS OF DECISIONS
Revised: 4. S PARSE EXPLANATIONS OF DECISIONS

Original: We foremost demonstrate that our inherently-interpretable model design does not cause signiﬁcant degradation in performance.
Revised: We foremost demonstrate that our inherently-interpretable model design does not cause signiﬁcant degradation in performance.

Original: Table 2 shows the accuracy and the median number of prototypes required to add up to a particular portion of the decision 9 for different prototypical learning cases.
Revised: Table 2 shows the accuracy and the median number of prototypes required to add up to a particular portion of the decision 9 for different prototypical learning cases.

Original: In all cases, very small accuracy gap is observed with the baseline encoder that is trained in conventional supervised learning way.
Revised: In all cases, very small accuracy gap is observed with the baseline encoder that is trained in conventional supervised learning way.

Original: The attention normalization function and sparsity regularization are efﬁcient mechanisms to control the sparsity – the number of prototypes required is much lower with sparsemax attention compared to softmax attention and can be further reduced with sparsity regularization (see
Revised: The attention normalization function and sparsity regularization are efﬁcient mechanisms to control the sparsity – the number of prototypes required is much lower with sparsemax attention compared to softmax attention and can be further reduced with sparsity regularization (see

Original: Supplementary Material for details).
Revised: Supplementary Material for details).

Original: With a small decrease in performance, the number of prototypes can be reduced to just a handful.
Revised: With a small decrease in performance, the number of prototypes can be reduced to just a handful.

Original: 10 There is difference between datasets, as intuitively expected from the discrepancy in the degree of similarity between the intra-class samples.
Revised: 10 There is difference between datasets, as intuitively expected from the discrepancy in the degree of similarity between the intra-class samples.

Original: [Table]
Revised: [Table]

Original: [Figure] 
Revised: [Figure] [Figure] [Table] [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Original: [Figure] 
Revised: [Figure] [Table] [Figure] [Table]

Revised: [Figure]

Original: [Table] 
Revised: [Table] [Figure] [Table] [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Original: [Figure] [Table] 
Revised: [Figure] [Table] [Figure]

Original: [Figure]

Original: [Table][Figure] [Table] [Figure]
Revised: [Table]

Original: [Table]

Original: [Figure][Table] [Figure] [Table]
Revised: [Figure]

Original: [Figure]

Original: [Table][Figure] [Table] [Figure]
Revised: [Table]

Original: [Table]

Original: [Figure][Table] [Figure] [Table]
Revised: [Figure]

Original: [Figure]

Original: [Table][Figure] [Table] [Figure]
Revised: [Table]

Original: [Table]

Original: [Figure][Table] [Figure] [Table]
Revised: [Figure]

Original: [Figure][Table] [Figure] [Table]
Revised: [Figure]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table] [Figure] [Figure] Figs. 4, 5 and 6 exemplify prototypes for image, text and tabular data.
Revised: Figs. 4, 5 and 6 exemplify prototypes for image, text and tabular data.

Original: In general, perceptually-similar samples are chosen as the prototypes with the largest weights.
Revised: In general, perceptually-similar samples are chosen as the prototypes with the largest weights.

Original: We also compare the relevant samples found by ProtoAttend with the methods of representer point selection (Yeh et al., 2018) and
Revised: We also compare the relevant samples found by ProtoAttend with the methods of representer point selection (Yeh et al., 2018) and

Original: inﬂuence functions
Revised: inﬂuence functions

Original: Koh & Liang, 2017)
Revised: Koh & Liang, 2017)

Original: (see Supplementary Material for details) on Animals with Attributes dataset.
Revised: (see Supplementary Material for details) on Animals with Attributes dataset.

Original: As shown in Fig.
Revised: As shown in Fig.

Original: 7, our method ﬁnds qualitatively more relevant samples.
Revised: 7, our method ﬁnds qualitatively more relevant samples.

Original: This case also exempliﬁes the potential of our method for integration into pre-trained models by addition of simple layers for key, query and value generation.
Revised: This case also exempliﬁes the potential of our method for integration into pre-trained models by addition of simple layers for key, query and value generation.

Original: [Figure]
Revised: [Figure]

Original: 4. R OBUSTNESS TO LABEL NOISE
Revised: 4. R OBUSTNESS TO LABEL NOISE

Original: [Table]
Revised: [Table]

Original: As prototypical learning with sparsemax attention aims to extract decision-making information from a small subset of training samples, it can be used to improve performance when the training dataset contains noisy labels (see Table 3).
Revised: As prototypical learning with sparsemax attention aims to extract decision-making information from a small subset of training samples, it can be used to improve performance when the training dataset contains noisy labels (see Table 3).

Original: The optimal value 11 of λ sparse increases with higher noisy label ratios, underlining the increasing importance of sparse learning.
Revised: The optimal value 11 of λ sparse increases with higher noisy label ratios, underlining the increasing importance of sparse learning.

Original: 4. C ONFIDENCE - CONTROLLED PREDICTION
Revised: 4. C ONFIDENCE - CONTROLLED PREDICTION

Original: [Figure]
Revised: [Figure]

Original: By varying the threshold for the conﬁdence metric, a trade-off can be obtained for what ratio of the test samples that the model makes a prediction for vs. the overall accuracy it obtains on the samples above that threshold.
Revised: By varying the threshold for the conﬁdence metric, a trade-off can be obtained for what ratio of the test samples that the model makes a prediction for vs. the overall accuracy it obtains on the samples above that threshold.

Original: 12 Figs. 8(a) and 8(b) demonstrate this trade-off and compare it to alternative methods.
Revised: 12 Figs. 8(a) and 8(b) demonstrate this trade-off and compare it to alternative methods.

Original: The sharper slope of the plots show that our method is superior to dkNN (Papernot &
Revised: The sharper slope of the plots show that our method is superior to dkNN (Papernot &

Original: McDaniel, 2018) and trust score (Jiang et al., 2018), the methods based on quantifying the mismatch with nearest-neighbor samples, in terms of ﬁnding related samples.
Revised: McDaniel, 2018) and trust score (Jiang et al., 2018), the methods based on quantifying the mismatch with nearest-neighbor samples, in terms of ﬁnding related samples.

Original: Although the baseline accuracy is higher with 4 ensemble networks obtained via deep ensemble (Lakshminarayanan et al., 2017), our method utilizes a single network and the additional accuracy gains by refraining from uncertain predictions is similar to our approach as shown by the similar slopes of the curves
Revised: Although the baseline accuracy is higher with 4 ensemble networks obtained via deep ensemble (Lakshminarayanan et al., 2017), our method utilizes a single network and the additional accuracy gains by refraining from uncertain predictions is similar to our approach as shown by the similar slopes of the curves

Original: Overall, the baseline accuracy can be signiﬁcantly improved by making less predictions.
Revised: Overall, the baseline accuracy can be signiﬁcantly improved by making less predictions.

Original: Compared to the state of the art models, our canonical method with simple and small models shows similar accuracy by making slightly fewer predictions – e.g. for MNIST, (Wan et al., 2013) achieves 0.21% error rate, that is obtained by our method refraining from only 0.45% of predictions using ResNetand for DBpedia, (Sachan & Petuum, 2018) achieves 0.91% error, that is obtained by our method refraining from 3% of predictions using 9-layer VDCNN.
Revised: Compared to the state of the art models, our canonical method with simple and small models shows similar accuracy by making slightly fewer predictions – e.g. for MNIST, (Wan et al., 2013) achieves 0.21% error rate, that is obtained by our method refraining from only 0.45% of predictions using ResNetand for DBpedia, (Sachan & Petuum, 2018) achieves 0.91% error, that is obtained by our method refraining from 3% of predictions using 9-layer VDCNN.

Original: In general, the smaller the number of prototypes, the smaller the trade-off space.
Revised: In general, the smaller the number of prototypes, the smaller the trade-off space.

Original: Thus, softmax attention (which normally results in more prototypes) is better suited for conﬁdence-controlled prediction compared to sparsemax (see
Revised: Thus, softmax attention (which normally results in more prototypes) is better suited for conﬁdence-controlled prediction compared to sparsemax (see

Original: Supplementary Material for more comparisons).
Revised: Supplementary Material for more comparisons).

Original: 4. O UT - OF - DISTRIBUTION SAMPLES
Revised: 4. O UT - OF - DISTRIBUTION SAMPLES

Original: Well-calibrated conﬁdence scores at inference can be used to detect deviations from the training dataset.
Revised: Well-calibrated conﬁdence scores at inference can be used to detect deviations from the training dataset.

Original: As the test distribution deviates from the training distribution, prototype weights tend to mismatch more and yield lower conﬁdence scores.
Revised: As the test distribution deviates from the training distribution, prototype weights tend to mismatch more and yield lower conﬁdence scores.

Original: Fig.
Revised: Fig.

Original: 9 (a) shows the ratio of samples above a certain conﬁdence level as the test dataset deviates.
Revised: 9 (a) shows the ratio of samples above a certain conﬁdence level as the test dataset deviates.

Original: Rotations deviate the distribution of test images from the training images, and cause signiﬁcant degradation in conﬁdence scores, as well as the overall accuracy.
Revised: Rotations deviate the distribution of test images from the training images, and cause signiﬁcant degradation in conﬁdence scores, as well as the overall accuracy.

Original: On the other hand, using test image from a different dataset, degrade them even further.
Revised: On the other hand, using test image from a different dataset, degrade them even further.

Original: Next, Fig. 9 (b) shows quantiﬁcation of out-of-distribution detection with prototypical learning, using the method from (Hendrycks & Gimpel, 2016).
Revised: Next, Fig. 9 (b) shows quantiﬁcation of out-of-distribution detection with prototypical learning, using the method from (Hendrycks & Gimpel, 2016).

Original: ProtoAttend yields an AUC of 0.838, being on par with the-state of the art approaches (Hendrycks et al.).
Revised: ProtoAttend yields an AUC of 0.838, being on par with the-state of the art approaches (Hendrycks et al.).

Original: [Figure]
Revised: [Figure]

Original:  C OMPUTATIONAL C OST
Revised:  C OMPUTATIONAL C OST

Original: ProtoAttend requires only a very small increase in the number of learning parameters (merely two extra small matrices for the fully-connected layers to obtain queries and keys).
Revised: ProtoAttend requires only a very small increase in the number of learning parameters (merely two extra small matrices for the fully-connected layers to obtain queries and keys).

Original: However, it does require a longer training time and has higher memory requirements to process the candidate database.
Revised: However, it does require a longer training time and has higher memory requirements to process the candidate database.

Original: At inference, keys and values for the candidate database can be computed only once and integrated into the model.
Revised: At inference, keys and values for the candidate database can be computed only once and integrated into the model.

Original: Thus, the overhead merely becomes the computation of attention outputs (e.g. for CIFAR-10 model, the attention overhead at inference is less than 0.6 MFLOPs, orders of magnitude lower than the computational complexity of a ResNet model).
Revised: Thus, the overhead merely becomes the computation of attention outputs (e.g. for CIFAR-10 model, the attention overhead at inference is less than 0.6 MFLOPs, orders of magnitude lower than the computational complexity of a ResNet model).

Original: During training on the other hand, both forward and backward propagation steps for the encoder need to be computed for all candidate samples and the total time is higher (e.g. 4.45 times slower to train until convergence for
Revised: During training on the other hand, both forward and backward propagation steps for the encoder need to be computed for all candidate samples and the total time is higher (e.g. 4.45 times slower to train until convergence for

Original: CIFAR-10 compared to the conventional supervised learning).
Revised: CIFAR-10 compared to the conventional supervised learning).

Original: The size of the candidate database is limited by the memory of the processor, so in practice we sample different candidate databases randomly from the training dataset at each iteration.
Revised: The size of the candidate database is limited by the memory of the processor, so in practice we sample different candidate databases randomly from the training dataset at each iteration.

Original: For faster training, data and model parallelism approaches are straightforward to implement – e.g., different processors can focus on different samples, or they can focus on different parts of the convolution or inner product operations.
Revised: For faster training, data and model parallelism approaches are straightforward to implement – e.g., different processors can focus on different samples, or they can focus on different parts of the convolution or inner product operations.

Original: Further computationally-efﬁcient approaches may involve less frequent updates for candidate queries and values.
Revised: Further computationally-efﬁcient approaches may involve less frequent updates for candidate queries and values.

Original:  C ONCLUSIONS
Revised:  C ONCLUSIONS

Original: We propose an attention-based prototypical learning method, ProtoAttend, and demonstrate its usefulness for a wide range of problems on image, text and tabular data.
Revised: We propose an attention-based prototypical learning method, ProtoAttend, and demonstrate its usefulness for a wide range of problems on image, text and tabular data.

Original: By adding a relational attention mechanism to an encoder, prototypical learning enables novel capabilities.
Revised: By adding a relational attention mechanism to an encoder, prototypical learning enables novel capabilities.

Original: With sparsemax attention, it can base the learning on a few relevant samples that can be returned at inference for interpretability, and can also improve robustness to label noise.
Revised: With sparsemax attention, it can base the learning on a few relevant samples that can be returned at inference for interpretability, and can also improve robustness to label noise.

Original: With softmax attention, it enables conﬁdence-controlled prediction that can outperform state of the art results with simple architectures by simply making slightly fewer predictions, as well as enables detecting deviations from the training data.
Revised: With softmax attention, it enables conﬁdence-controlled prediction that can outperform state of the art results with simple architectures by simply making slightly fewer predictions, as well as enables detecting deviations from the training data.

Original: All these capabilities are achieved without sacriﬁcing overall accuracy of the base model.
Revised: All these capabilities are achieved without sacriﬁcing overall accuracy of the base model.

Original: A P SEUDO CODE FOR TRAINING
Revised: A P SEUDO CODE FOR TRAINING

Original: 1: Inputs: Training dataset T , encoder model h ( x ; θ ) , classiﬁer model h ( v ; φ ) , normalization function n , input batch size B , candidate batch size D , attention dimension d att , α values to be used for loss: (0, 0.5, 1), task-speciﬁc loss function L , ADAM learning rate r , and exponential decay rate parameters β β2: Initialize Trainable encoder parameters θ and classiﬁer layer parameters φ 3: while until convergence do 4:
Revised: 1: Inputs: Training dataset T , encoder model h ( x ; θ ) , classiﬁer model h ( v ; φ ) , normalization function n , input batch size B , candidate batch size D , attention dimension d att , α values to be used for loss: (0, 0.5, 1), task-speciﬁc loss function L , ADAM learning rate r , and exponential decay rate parameters β β2: Initialize Trainable encoder parameters θ and classiﬁer layer parameters φ 3: while until convergence do 4:

Original: Sample a mini-batch from the training dataset for the inputs: ( x i , y i )
Revised: Sample a mini-batch from the training dataset for the inputs: ( x i , y i )

Original: Bi =1 ∼ T 5:
Revised: Bi =1 ∼ T 5:

Original: Sample a mini-batch from the training dataset for the prototypes: ( x ( c ) j , y c ) j ) Dj =1 ∼ T 6: for i = 1 , ..., B do 7:
Revised: Sample a mini-batch from the training dataset for the prototypes: ( x ( c ) j , y c ) j ) Dj =1 ∼ T 6: for i = 1 , ..., B do 7:

Original: Obtain queries and values for the input:
Revised: Obtain queries and values for the input:

Original: Q i , V i ← h ( x ; θ ) 8: for j = 1 , ..., D do 9:
Revised: Q i , V i ← h ( x ; θ ) 8: for j = 1 , ..., D do 9:

Original: Obtain keys and values for the prototypes:
Revised: Obtain keys and values for the prototypes:

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: ( c
Revised: ( c

Original: [Equation]
Revised: [Equation]

Original: ) 10: for i = 1 , ..., B do 11: for j = 1 , ..., D do 12:
Revised: ) 10: for i = 1 , ..., B do 11: for j = 1 , ..., D do 12:

Original: Estimate the relational attention coefﬁcients:
Revised: Estimate the relational attention coefﬁcients:

Original: [Equation]
Revised: [Equation]

Original: Obtain the predictions 14: for i = 1 , ..., B do ˆ y
Revised: Obtain the predictions 14: for i = 1 , ..., B do ˆ y

Original: [Equation]
Revised: [Equation]

Original: ( α = 0) ← g ( v i ; φ ) ˆ y
Revised: ( α = 0) ← g ( v i ; φ ) ˆ y

Original: [Equation]
Revised: [Equation]

Original: ( α = 0 . 5)
Revised: ( α = 0 . 5)

Original: ← g (cid:18)
Revised: ← g (cid:18)

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: 5 (cid:88)
Revised: 5 (cid:88)

Original: [Equation]
Revised: [Equation]

Original: p
Revised: p

Original: [Equation]
Revised: [Equation]

Original: v ( c )
Revised: v ( c )

Original: [Equation]
Revised: [Equation]

Original: φ (cid:19)
Revised: φ (cid:19)

Original: ˆ y i ( α = 1) ← g (cid:18)(cid:88) D j
Revised: ˆ y i ( α = 1) ← g (cid:18)(cid:88) D j

Original: [Equation]
Revised: [Equation]

Original: Estimate the total loss function
Revised: Estimate the total loss function

Original: [Equation]
Revised: [Equation]

Original: Update the encoder model and the classiﬁer layer
Revised: Update the encoder model and the classiﬁer layer

Original: [Equation]
Revised: [Equation]

Original: B R ELATION TO I NFLUENCE F UNCTIONS
Revised: B R ELATION TO I NFLUENCE F UNCTIONS

Original: Here we clarify the relationship of our work to inﬂuence functions from a theoretical perspective.
Revised: Here we clarify the relationship of our work to inﬂuence functions from a theoretical perspective.

Original: Inﬂuence functions quantify how a model’s predictions would change if we did not have a particular training point.
Revised: Inﬂuence functions quantify how a model’s predictions would change if we did not have a particular training point.

Original: For the purpose of sample-based explainability, (Koh & Liang, 2017) proposes that the relation between an input sample x i and the candidate samples 13 x ( c ) j can be obtained by quantifying the inﬂuence of upweighting ( x ( c ) j , y ( c ) j ) on the loss at a query point ( x i , y i ) :
Revised: For the purpose of sample-based explainability, (Koh & Liang, 2017) proposes that the relation between an input sample x i and the candidate samples 13 x ( c ) j can be obtained by quantifying the inﬂuence of upweighting ( x ( c ) j , y ( c ) j ) on the loss at a query point ( x i , y i ) :

Original: [Equation]
Revised: [Equation]

Original: where H ( ˆ θ, ˆ φ ) is the Hessian and is positive deﬁnite by assumption.
Revised: where H ( ˆ θ, ˆ φ ) is the Hessian and is positive deﬁnite by assumption.

Original: Let’s consider the singular value decomposition ( H − 1 ( ˆ θ, ˆ φ ) ) =
Revised: Let’s consider the singular value decomposition ( H − 1 ( ˆ θ, ˆ φ ) ) =

Original: Ξ · Σ · Ψ T and also deﬁne the function k ( x , y )
Revised: Ξ · Σ · Ψ T and also deﬁne the function k ( x , y )

Original: =
Revised: =

Original: ∇ ( θ,φ ) L ( y ) .
Revised: ∇ ( θ,φ ) L ( y ) .

Original: Then, Eq.
Revised: Then, Eq.

Original: 4 can be written as:
Revised: 4 can be written as:

Original: [Equation]
Revised: [Equation]

Original: We can observe that I i,j is in the form of an inner product between two functions applied on ( x i , y i ) and ( x ( c ) j , y ( c ) j ) .
Revised: We can observe that I i,j is in the form of an inner product between two functions applied on ( x i , y i ) and ( x ( c ) j , y ( c ) j ) .

Original: These two functions are composed of a shared (and potentially complex) function, followed by a linear mapping with non-shared parameters.
Revised: These two functions are composed of a shared (and potentially complex) function, followed by a linear mapping with non-shared parameters.

Original: This expression is indeed in a similar form with the argument of the normalization function for attention in Eq.
Revised: This expression is indeed in a similar form with the argument of the normalization function for attention in Eq.

Original: 1, where the queries and keys are obtained by a shared encoder except the last layer.
Revised: 1, where the queries and keys are obtained by a shared encoder except the last layer.

Original: The only notable difference is that ProtoAttend encoder functions merely input x i and x ( c ) j , not the ground truth labels.
Revised: The only notable difference is that ProtoAttend encoder functions merely input x i and x ( c ) j , not the ground truth labels.

Original: Instead of relying on ground truth labels or complex Hessian estimations, ProtoAttend infers the encoded representations for the queries and keys directly in a feedforward way, by learning from the entire training dataset.
Revised: Instead of relying on ground truth labels or complex Hessian estimations, ProtoAttend infers the encoded representations for the queries and keys directly in a feedforward way, by learning from the entire training dataset.

Original: Note that
Revised: Note that

Original: ProtoAttend does not use a separate encoder for values, and obtains a high performance by sharing the vast majority of the parameters while obtaining the keys, queries and values.
Revised: ProtoAttend does not use a separate encoder for values, and obtains a high performance by sharing the vast majority of the parameters while obtaining the keys, queries and values.

Original: In (Koh & Liang, 2017), Inﬂuence Functions are also related to nearest neighbor search-based relevant point determination approaches, for sample-based explainability.
Revised: In (Koh & Liang, 2017), Inﬂuence Functions are also related to nearest neighbor search-based relevant point determination approaches, for sample-based explainability.

Original: When Euclidean space is considered for distances, with the assumption that all points have the same norm, the inner product between the representations correspond to their similarity.
Revised: When Euclidean space is considered for distances, with the assumption that all points have the same norm, the inner product between the representations correspond to their similarity.

Original: This scenario is the special case of ProtoAttend when we use the same representation for keys, queries and values, and when we train with only α =loss term although we would use p i,j for similarity determination.
Revised: This scenario is the special case of ProtoAttend when we use the same representation for keys, queries and values, and when we train with only α =loss term although we would use p i,j for similarity determination.

Original: As studied in (Koh & Liang, 2017), nearest neighbor-based methods are far less accurate in capturing the effect of model training, compared to Inﬂuence Functions.
Revised: As studied in (Koh & Liang, 2017), nearest neighbor-based methods are far less accurate in capturing the effect of model training, compared to Inﬂuence Functions.

Original: Our empirical results in Figs.
Revised: Our empirical results in Figs.

Original: 7 and 13 show superior performance of ProtoAttend compared to Inﬂuence Functions in ﬁnding perceptually more similar samples.
Revised: 7 and 13 show superior performance of ProtoAttend compared to Inﬂuence Functions in ﬁnding perceptually more similar samples.

Original: Overall, unlike Inﬂuence Functions, ProtoAttend modiﬁes the model training for the desired goals, that fundamentally yields more degrees of freedom to optimize while achieving superior prototype learning quality effectively.
Revised: Overall, unlike Inﬂuence Functions, ProtoAttend modiﬁes the model training for the desired goals, that fundamentally yields more degrees of freedom to optimize while achieving superior prototype learning quality effectively.

Original: C T RAINING DETAILS
Revised: C T RAINING DETAILS

Original: Different candidate databases are sampled randomly from the training dataset at each iteration.
Revised: Different candidate databases are sampled randomly from the training dataset at each iteration.

Original: Training database size is chosen to ﬁt the model to the memory of a single GPU.
Revised: Training database size is chosen to ﬁt the model to the memory of a single GPU.

Original: D at inference is chosen sufﬁciently large to obtain high accuracy.
Revised: D at inference is chosen sufﬁciently large to obtain high accuracy.

Original: Table 4 shows the database size D for the datasets used in the experiments.
Revised: Table 4 shows the database size D for the datasets used in the experiments.

Original: The size of the prototype candidate database should be sufﬁciently large such that the model can attend to reasonable prototypes with high coefﬁcients (separately for each input).
Revised: The size of the prototype candidate database should be sufﬁciently large such that the model can attend to reasonable prototypes with high coefﬁcients (separately for each input).

Revised: With appropriate sparsity mechanisms, we normally only end up with a few prototypes with large coefﬁcients.

Revised: Indeed, most of the coefﬁcients would be zero with sparsemax activation and sparsity regularization.

Original: [Table]
Revised: [Table]

Original: C. I MAGE DATA C.1. MNIST DATASET
Revised: C. I MAGE DATA C.1. MNIST DATASET

Original: We apply random cropping after padding each side by 2 pixels and per image standardization.
Revised: We apply random cropping after padding each side by 2 pixels and per image standardization.

Original: The base encoder uses a standard 32 layer ResNet architecture.
Revised: The base encoder uses a standard 32 layer ResNet architecture.

Original: The number of ﬁlters is initially 16 and doubled every 5 blocks.
Revised: The number of ﬁlters is initially 16 and doubled every 5 blocks.

Original: In each block, two 3 × 3 convolutional layers are used to transform the input, and the transformed output is added to the input after a 1 × 1 convolution.
Revised: In each block, two 3 × 3 convolutional layers are used to transform the input, and the transformed output is added to the input after a 1 × 1 convolution.

Original: 4 × downsampling is applied by choosing the stride as 2 after 5 th and 10 th blocks.
Revised: 4 × downsampling is applied by choosing the stride as 2 after 5 th and 10 th blocks.

Original: Each convolution is followed by batch normalization and ReLU nonlinearity.
Revised: Each convolution is followed by batch normalization and ReLU nonlinearity.

Original: After the last convolution, 7 × 7 average pooling is applied.
Revised: After the last convolution, 7 × 7 average pooling is applied.

Original: The output is followed by a fully-connected layer of 256 units and ReLU nonlinearity, followed by layer normalization (Lei Ba et al., 2016).
Revised: The output is followed by a fully-connected layer of 256 units and ReLU nonlinearity, followed by layer normalization (Lei Ba et al., 2016).

Original: Keys and queries are mapped from the output using a fully-connected layer followed by ReLU nonlinearity, where the attention size is d att =16.
Revised: Keys and queries are mapped from the output using a fully-connected layer followed by ReLU nonlinearity, where the attention size is d att =16.

Original: Values are mapped from the output using a fully-connected layer of d out =64 units and ReLU nonlinearity, followed by layer normalization.
Revised: Values are mapped from the output using a fully-connected layer of d out =64 units and ReLU nonlinearity, followed by layer normalization.

Original: For the baseline encoder, the initial learning rate is chosen as 0.
Revised: For the baseline encoder, the initial learning rate is chosen as 0.

Original: and exponential decay is applied with a rate of 0.9 applied every 6k iterations.
Revised: and exponential decay is applied with a rate of 0.9 applied every 6k iterations.

Original: The model is trained for 84k iterations.
Revised: The model is trained for 84k iterations.

Original: For prototypical learning model with softmax attention, the initial learning rate is chosen as 0.002 and exponential decay is applied with a rate of 0.8 applied every 8k iterations.
Revised: For prototypical learning model with softmax attention, the initial learning rate is chosen as 0.002 and exponential decay is applied with a rate of 0.8 applied every 8k iterations.

Original: The model is trained for 228k iterations.
Revised: The model is trained for 228k iterations.

Original: For prototypical learning model with sparsemax attention, the initial learning rate is chosen as 0.001 and exponential decay is applied with a rate of 0.93 applied every 6k iterations.
Revised: For prototypical learning model with sparsemax attention, the initial learning rate is chosen as 0.001 and exponential decay is applied with a rate of 0.93 applied every 6k iterations.

Original: The model is trained for 228k iterations.
Revised: The model is trained for 228k iterations.

Original: All models use a batch size of 128 and gradient clipping above 20.
Revised: All models use a batch size of 128 and gradient clipping above 20.

Original: C.1. F ASHION -MNIST DATASET
Revised: C.1. F ASHION -MNIST DATASET

Original: We apply random cropping after padding each side by 2 pixels, random horizontal ﬂipping, and per image standardization.
Revised: We apply random cropping after padding each side by 2 pixels, random horizontal ﬂipping, and per image standardization.

Original: The base encoder uses a standard 32 layer ResNet architecture, similar to our MNIST experiments.
Revised: The base encoder uses a standard 32 layer ResNet architecture, similar to our MNIST experiments.

Original: For the baseline encoder, the initial learning rate is chosen as 0.0015 and exponential decay is applied with a rate of 0.9 applied every 10k iterations.
Revised: For the baseline encoder, the initial learning rate is chosen as 0.0015 and exponential decay is applied with a rate of 0.9 applied every 10k iterations.

Original: The model is trained for 332k iterations.
Revised: The model is trained for 332k iterations.

Original: For prototypical learning with softmax attention, the initial learning rate is chosen as 0.0007 and exponential decay is applied with a rate of 0.92 applied every 8k iterations.
Revised: For prototypical learning with softmax attention, the initial learning rate is chosen as 0.0007 and exponential decay is applied with a rate of 0.92 applied every 8k iterations.

Original: The model is trained for 450k iterations.
Revised: The model is trained for 450k iterations.

Original: For prototypical learning with sparsemax attention, the initial learning rate is chosen as 0.001 and exponential decay is applied with a rate of 0.9 applied every 8k iterations.
Revised: For prototypical learning with sparsemax attention, the initial learning rate is chosen as 0.001 and exponential decay is applied with a rate of 0.9 applied every 8k iterations.

Original: The model is trained for 392k iterations.
Revised: The model is trained for 392k iterations.

Original: For prototypical learning with sparsemax attention and sparsity regularization (with λ sparse = 0 . 0003 ), the initial learning rate is chosen as 0.001 and exponential decay is applied with a rate of 0.94 applied every 8k iterations.
Revised: For prototypical learning with sparsemax attention and sparsity regularization (with λ sparse = 0 . 0003 ), the initial learning rate is chosen as 0.001 and exponential decay is applied with a rate of 0.94 applied every 8k iterations.

Original: λ conf = 0 .is chosen when conﬁdence regularization is applied.
Revised: λ conf = 0 .is chosen when conﬁdence regularization is applied.

Original: The model is trained for 440k iterations.
Revised: The model is trained for 440k iterations.

Original: All models use a batch size of 128 and gradient clipping above 20.
Revised: All models use a batch size of 128 and gradient clipping above 20.

Original: C.1. CIFAR-10 DATASET
Revised: C.1. CIFAR-10 DATASET

Original: We apply random cropping after padding each side by 3 pixels, random horizontal ﬂipping, random vertical ﬂipping and per image standardization.
Revised: We apply random cropping after padding each side by 3 pixels, random horizontal ﬂipping, random vertical ﬂipping and per image standardization.

Original: The base encoder uses a standard 50 layer ResNet architecture.
Revised: The base encoder uses a standard 50 layer ResNet architecture.

Original: The number of ﬁlters is initially 16 and doubled every 8 blocks.
Revised: The number of ﬁlters is initially 16 and doubled every 8 blocks.

Original: In each block, two 3 ×convolutional layers are used to transform the input, and the transformed output is added to the input after a 1 × 1 convolution.
Revised: In each block, two 3 ×convolutional layers are used to transform the input, and the transformed output is added to the input after a 1 × 1 convolution.

Original: 4 × downsampling is applied by choosing the stride as 2 after 8 th and 16 th blocks.
Revised: 4 × downsampling is applied by choosing the stride as 2 after 8 th and 16 th blocks.

Original: Each convolution is followed by batch normalization and the ReLU nonlinearity.
Revised: Each convolution is followed by batch normalization and the ReLU nonlinearity.

Original: After the last convolution, 8 × 8 average pooling is applied.
Revised: After the last convolution, 8 × 8 average pooling is applied.

Original: The output is followed by a fully-connected layer of 256 units and the ReLU nonlinearity, followed by layer normalization (Lei Ba et al., 2016).
Revised: The output is followed by a fully-connected layer of 256 units and the ReLU nonlinearity, followed by layer normalization (Lei Ba et al., 2016).

Original: Keys and queries are mapped from the output using a fully-connected layer followed by the ReLU nonlinearity, where the attention size is d att =16.
Revised: Keys and queries are mapped from the output using a fully-connected layer followed by the ReLU nonlinearity, where the attention size is d att =16.

Original: Values are mapped from the output using a fully-connected layer of d out =128 units and the ReLU nonlinearity, followed by layer normalization.
Revised: Values are mapped from the output using a fully-connected layer of d out =128 units and the ReLU nonlinearity, followed by layer normalization.

Original: For the baseline encoder, the initial learning rate is chosen as 0.002 and exponential decay is applied with a rate of 0.95 applied every 10k iterations.
Revised: For the baseline encoder, the initial learning rate is chosen as 0.002 and exponential decay is applied with a rate of 0.95 applied every 10k iterations.

Original: The model is trained for 940k iterations.
Revised: The model is trained for 940k iterations.

Original: For prototypical learning with softmax attention, the initial learning rate is chosen as 0.0035 and exponential decay is applied with a rate of 0.95 applied every 10k iterations.
Revised: For prototypical learning with softmax attention, the initial learning rate is chosen as 0.0035 and exponential decay is applied with a rate of 0.95 applied every 10k iterations.

Original: The model is trained for 625k iterations.
Revised: The model is trained for 625k iterations.

Original: For prototypical learning with sparsemax attention, the initial learning rate is chosen as 0.0015 and exponential decay is applied with a rate of 0.95 applied every 10k iterations.
Revised: For prototypical learning with sparsemax attention, the initial learning rate is chosen as 0.0015 and exponential decay is applied with a rate of 0.95 applied every 10k iterations.

Original: The model is trained for 905k iterations.
Revised: The model is trained for 905k iterations.

Original: For prototypical learning with sparsemax attention and sparsity regularization
Revised: For prototypical learning with sparsemax attention and sparsity regularization

Original: (with λ sparse = 0 . 00008 ), the initial learning rate is chosen as 0.0015 and exponential decay is applied with a rate of 0.95 applied every 12k iterations.
Revised: (with λ sparse = 0 . 00008 ), the initial learning rate is chosen as 0.0015 and exponential decay is applied with a rate of 0.95 applied every 12k iterations.

Original: λ conf = 0 .
Revised: λ conf = 0 .

Original: 1 is chosen when conﬁdence regularization is applied.
Revised: 1 is chosen when conﬁdence regularization is applied.

Original: The model is trained for 450k iterations.
Revised: The model is trained for 450k iterations.

Original: All models use a batch size ofand gradient clipping above 20.
Revised: All models use a batch size ofand gradient clipping above 20.

Original: CIFAR-10 experiments with noisy labels.
Revised: CIFAR-10 experiments with noisy labels.

Original: For CIFAR-10 experiments with noisy labels for the base encoder we only optimize the learning parameters.
Revised: For CIFAR-10 experiments with noisy labels for the base encoder we only optimize the learning parameters.

Original: Noisy labels are sampled uniformly from the set of labels excluding the correct one.
Revised: Noisy labels are sampled uniformly from the set of labels excluding the correct one.

Original: The baseline model with noisy label ratio of 0.8 uses an initial learning rate of 0.001, decayed with a rate of 0.92 every 6k iterations, and is trained for 15k iterations.
Revised: The baseline model with noisy label ratio of 0.8 uses an initial learning rate of 0.001, decayed with a rate of 0.92 every 6k iterations, and is trained for 15k iterations.

Original: For the dropout approach, dropout with a rate of 0.1 is applied, and the model uses an initial learning rate of 0.002, decayed with a rate of 0.85 every 8k iterations, and is trained for 24k iterations.
Revised: For the dropout approach, dropout with a rate of 0.1 is applied, and the model uses an initial learning rate of 0.002, decayed with a rate of 0.85 every 8k iterations, and is trained for 24k iterations.

Original: The baseline model with noisy label ratio of 0.6 uses an initial learning rate of 0.002, decayed with a rate of 0.92 every 6k iterations, and is trained for 12k iterations.
Revised: The baseline model with noisy label ratio of 0.6 uses an initial learning rate of 0.002, decayed with a rate of 0.92 every 6k iterations, and is trained for 12k iterations.

Original: For the dropout approach, dropout with a rate of 0.3 is applied, and the model uses an initial learning rate of 0.002, decayed with a rate of 0.92 every 8k iterations, and is trained for 18k iterations.
Revised: For the dropout approach, dropout with a rate of 0.3 is applied, and the model uses an initial learning rate of 0.002, decayed with a rate of 0.92 every 8k iterations, and is trained for 18k iterations.

Original: The baseline model with noisy label ratio of 0.4 uses an initial learning rate of 0.002, decayed with a rate of 0.92 every 6k iterations, and is trained for 15k iterations.
Revised: The baseline model with noisy label ratio of 0.4 uses an initial learning rate of 0.002, decayed with a rate of 0.92 every 6k iterations, and is trained for 15k iterations.

Original: For the dropout approach, dropout with a rate of 0.5 is applied, and the model uses an initial learning rate of 0.002, decayed with a rate of 0.92 every 6k iterations, and is trained for 18k iterations.
Revised: For the dropout approach, dropout with a rate of 0.5 is applied, and the model uses an initial learning rate of 0.002, decayed with a rate of 0.92 every 6k iterations, and is trained for 18k iterations.

Original: For experiments for the prototypical learning model with sparsemax attention, we optimize the learning parameters and λ sparse .
Revised: For experiments for the prototypical learning model with sparsemax attention, we optimize the learning parameters and λ sparse .

Original: For the model with noisy label ratio of 0.8, λ sparse = 0 . 0015 , initial learning rate is chosen as 0.0006 and exponential decay is applied with a rate of 0.95 applied every 8k iterations.
Revised: For the model with noisy label ratio of 0.8, λ sparse = 0 . 0015 , initial learning rate is chosen as 0.0006 and exponential decay is applied with a rate of 0.95 applied every 8k iterations.

Original: The model is trained for 108k iterations.
Revised: The model is trained for 108k iterations.

Original: For the model with noisy label ratio of 0.6, λ sparse = 0 .
Revised: For the model with noisy label ratio of 0.6, λ sparse = 0 .

Original: 0005 , initial learning rate is chosen as 0.001 and exponential decay is applied with a rate of 0.9 applied every 8k iterations.
Revised: 0005 , initial learning rate is chosen as 0.001 and exponential decay is applied with a rate of 0.9 applied every 8k iterations.

Original: The model is trained for 92k iterations.
Revised: The model is trained for 92k iterations.

Original: For the model with noisy label ratio of 0.4, λ sparse = 0 .
Revised: For the model with noisy label ratio of 0.4, λ sparse = 0 .

Original: 0003 , initial learning rate is chosen as 0.001 and exponential decay is applied with a rate of 0.9 applied every 6k iterations.
Revised: 0003 , initial learning rate is chosen as 0.001 and exponential decay is applied with a rate of 0.9 applied every 6k iterations.

Original: The model is trained for 122k iterations.
Revised: The model is trained for 122k iterations.

Original: C.1. F RUITS DATASET
Revised: C.1. F RUITS DATASET

Original: We apply random cropping after padding each side by 5 pixels, random horizontal ﬂipping, random vertical ﬂipping and per image standardization.
Revised: We apply random cropping after padding each side by 5 pixels, random horizontal ﬂipping, random vertical ﬂipping and per image standardization.

Original: In the encoder, ﬁrst, a downsampling with a convolutional layer is applied with a stride of 2, and using 16 ﬁlters, followed by a downsampling with max-pooling with a stride of 2.
Revised: In the encoder, ﬁrst, a downsampling with a convolutional layer is applied with a stride of 2, and using 16 ﬁlters, followed by a downsampling with max-pooling with a stride of 2.

Original: After obtaining the 25 × 25 inputs, a standard 32 layer ResNet architecture (similar to MNIST) is used, followed by a fully-connected layer of 128 units and the
Revised: After obtaining the 25 × 25 inputs, a standard 32 layer ResNet architecture (similar to MNIST) is used, followed by a fully-connected layer of 128 units and the

Original: ReLU nonlinearity, followed by layer normalization (Lei Ba et al., 2016).
Revised: ReLU nonlinearity, followed by layer normalization (Lei Ba et al., 2016).

Original: Keys and queries are mapped from the output using a fully-connected layer followed by the ReLU nonlinearity, where the attention size is d att =16.
Revised: Keys and queries are mapped from the output using a fully-connected layer followed by the ReLU nonlinearity, where the attention size is d att =16.

Original: Values are mapped from the output using a fully-connected layer of d out =64 units and the ReLU nonlinearity, followed by layer normalization.
Revised: Values are mapped from the output using a fully-connected layer of d out =64 units and the ReLU nonlinearity, followed by layer normalization.

Original: W eight decay with a factor of 0.0001 is applied for the convolutional ﬁlters.
Revised: W eight decay with a factor of 0.0001 is applied for the convolutional ﬁlters.

Original: The model uses a batch size of 128 and gradient clipping above 20.
Revised: The model uses a batch size of 128 and gradient clipping above 20.

Original: C.1. ISIC M ELANOMA DATASET
Revised: C.1. ISIC M ELANOMA DATASET

Original: The ISIC Melanoma dataset is formed from the ISIC Archive (ISIC, 2016) that contains over 13k dermoscopic images collected from leading clinical centers internationally and acquired from a variety of devices within each center.
Revised: The ISIC Melanoma dataset is formed from the ISIC Archive (ISIC, 2016) that contains over 13k dermoscopic images collected from leading clinical centers internationally and acquired from a variety of devices within each center.

Original: The dataset consists of skin images with labels denoting whether they contain melanoma or are benign.
Revised: The dataset consists of skin images with labels denoting whether they contain melanoma or are benign.

Original: We construct the training and validation dataset using 15122 images (13511 benign and 1611 melanoma cases), and the evaluation dataset using 3203 images (2867 benign and 336 melanoma).
Revised: We construct the training and validation dataset using 15122 images (13511 benign and 1611 melanoma cases), and the evaluation dataset using 3203 images (2867 benign and 336 melanoma).

Original: While training, benign cases are undersampled in each batch to have 0.6 ratio including candidate database sets at training and inference.
Revised: While training, benign cases are undersampled in each batch to have 0.6 ratio including candidate database sets at training and inference.

Original: All images are resized to 128 × 128 pixels.
Revised: All images are resized to 128 × 128 pixels.

Original: We apply random cropping after padding each side by 8 pixels, random horizontal ﬂipping, random vertical ﬂipping and per image standardization.
Revised: We apply random cropping after padding each side by 8 pixels, random horizontal ﬂipping, random vertical ﬂipping and per image standardization.

Original: In the encoder, ﬁrst, a downsampling with a convolutional layer is applied with a stride of 2, and using 16 ﬁlters, followed by a downsampling with max-pooling with a stride of 2.
Revised: In the encoder, ﬁrst, a downsampling with a convolutional layer is applied with a stride of 2, and using 16 ﬁlters, followed by a downsampling with max-pooling with a stride of 2.

Original: After obtaining the 32 × 32 inputs, the base encoder uses a standard 50 layer ResNet architecture (similar to CIFAR10), followed by a fully-connected layer of 128 units and the ReLU nonlinearity, followed by layer normalization (Lei Ba et al., 2016).
Revised: After obtaining the 32 × 32 inputs, the base encoder uses a standard 50 layer ResNet architecture (similar to CIFAR10), followed by a fully-connected layer of 128 units and the ReLU nonlinearity, followed by layer normalization (Lei Ba et al., 2016).

Original: Keys and queries are mapped from the output using a fully-connected layer followed by the ReLU nonlinearity, where the attention size is d att =16.
Revised: Keys and queries are mapped from the output using a fully-connected layer followed by the ReLU nonlinearity, where the attention size is d att =16.

Original: Values are mapped from the output using a fully-connected layer of d out =64 units and the ReLU nonlinearity, followed by layer normalization.
Revised: Values are mapped from the output using a fully-connected layer of d out =64 units and the ReLU nonlinearity, followed by layer normalization.

Original: For the baseline encoder, the initial learning rate is chosen as 0.002 and exponential decay is applied with a rate of 0.9 applied every 3k iterations.
Revised: For the baseline encoder, the initial learning rate is chosen as 0.002 and exponential decay is applied with a rate of 0.9 applied every 3k iterations.

Original: The model is trained for 220k iterations.
Revised: The model is trained for 220k iterations.

Original: For prototypical learning with softmax attention, the initial learning rate is chosen as 0.0006 and exponential decay is applied with a rate of 0.9 applied every 3k iterations.
Revised: For prototypical learning with softmax attention, the initial learning rate is chosen as 0.0006 and exponential decay is applied with a rate of 0.9 applied every 3k iterations.

Original: The model is trained for 147k iterations.
Revised: The model is trained for 147k iterations.

Original: For prototypical learning with sparsemax attention, the initial learning rate is chosen as 0.0006 and exponential decay is applied with a rate of 0.9 applied every 4k iterations.
Revised: For prototypical learning with sparsemax attention, the initial learning rate is chosen as 0.0006 and exponential decay is applied with a rate of 0.9 applied every 4k iterations.

Original: The model is trained for 166k iterations.
Revised: The model is trained for 166k iterations.

Original: All models use a batch size of 128 and gradient clipping above 20.
Revised: All models use a batch size of 128 and gradient clipping above 20.

Original: C.1. A NIMALS WITH A TTRIBUTES DATASET
Revised: C.1. A NIMALS WITH A TTRIBUTES DATASET

Original: We train ProtoAttend with sparsemax attention using the features from a pre-trained ResNetas provided in (Yeh et al., 2018).
Revised: We train ProtoAttend with sparsemax attention using the features from a pre-trained ResNetas provided in (Yeh et al., 2018).

Original: To map the pre-trained features, we simply insert a single fullyconnected layer with 256 units with ReLU nonlinearity and layer normalization, followed by the individual fully-connected layers of keys, queries and values (16, 16 and 64 units respectively with
Revised: To map the pre-trained features, we simply insert a single fullyconnected layer with 256 units with ReLU nonlinearity and layer normalization, followed by the individual fully-connected layers of keys, queries and values (16, 16 and 64 units respectively with

Original: ReLU nonlinearity).
Revised: ReLU nonlinearity).

Original: Sparsity regularization is applied with λ sparse = 0 . 000001 .
Revised: Sparsity regularization is applied with λ sparse = 0 . 000001 .

Original: We train the model for 70k iterations.
Revised: We train the model for 70k iterations.

Original: The initial learning rate is chosen as 0.0006 and exponential decay is applied with a rate of 0.8 applied every 10k iterations.
Revised: The initial learning rate is chosen as 0.0006 and exponential decay is applied with a rate of 0.8 applied every 10k iterations.

Original: A classiﬁcation accuracy above 91% is obtained for the test set.
Revised: A classiﬁcation accuracy above 91% is obtained for the test set.

Original: C. T EXT DATA C.2. DBP EDIA DATASET
Revised: C. T EXT DATA C.2. DBP EDIA DATASET

Original: There are 14 output classes: Company, Educational Institution, Artist, Athlete, Ofﬁce Holder, Mean
Revised: There are 14 output classes: Company, Educational Institution, Artist, Athlete, Ofﬁce Holder, Mean

Original: Of Transportation, Building, Natural Place, Village, Animal, Plant, Album, Film, Written Work.
Revised: Of Transportation, Building, Natural Place, Village, Animal, Plant, Album, Film, Written Work.

Original: As the input, 16-dimensional trainable embeddings are mapped from the dictionary of 69 raw characters (Conneau et al., 2016).
Revised: As the input, 16-dimensional trainable embeddings are mapped from the dictionary of 69 raw characters (Conneau et al., 2016).

Original: The maximum length is set to 448 and longer inputs are truncated while the shorter inputs are padded.
Revised: The maximum length is set to 448 and longer inputs are truncated while the shorter inputs are padded.

Original: The input embeddings are ﬁrst transformed with a 1-D convolutional block consisting 64 ﬁlters with kernel width of 3 and stride of 2.
Revised: The input embeddings are ﬁrst transformed with a 1-D convolutional block consisting 64 ﬁlters with kernel width of 3 and stride of 2.

Original: Then, 8 convolution blocks as in (Conneau et al., 2016) are applied, with 64, 64, 128, 128, 256, 256, 512 and 512 ﬁlters respectively.
Revised: Then, 8 convolution blocks as in (Conneau et al., 2016) are applied, with 64, 64, 128, 128, 256, 256, 512 and 512 ﬁlters respectively.

Original: All use the kernel width of 3, and after each two layers, max pooling is applied with kernel width of 3 and a stride of 2.
Revised: All use the kernel width of 3, and after each two layers, max pooling is applied with kernel width of 3 and a stride of 2.

Original: All convolutions are followed by batch normalization and the ReLU nonlinearity.
Revised: All convolutions are followed by batch normalization and the ReLU nonlinearity.

Original: Convolutional ﬁlters use weight normalization with parameter 0.00001.
Revised: Convolutional ﬁlters use weight normalization with parameter 0.00001.

Original: The last convolution block is followed by k-max pooling with k =

Revised: The last convolution block is followed by k-max pooling with k =

Original: (Conneau et al., 2016).
Revised: (Conneau et al., 2016).

Original: Finally, we apply two fully-connected layers with 1024 hidden units.
Revised: Finally, we apply two fully-connected layers with 1024 hidden units.

Original: In contrast to (Conneau et al., 2016), we also use layer normalization (Lei Ba et al., 2016) after fully-connected layers as we observe this leads to more stable training behavior.
Revised: In contrast to (Conneau et al., 2016), we also use layer normalization (Lei Ba et al., 2016) after fully-connected layers as we observe this leads to more stable training behavior.

Original: Keys and queries are mapped from the output using a fully-connected layer followed by the ReLU nonlinearity, where the attention size is d att =16.
Revised: Keys and queries are mapped from the output using a fully-connected layer followed by the ReLU nonlinearity, where the attention size is d att =16.

Original: Values are mapped from the output using a fully-connected layer of d out =64 units and the ReLU nonlinearity, followed by layer normalization.
Revised: Values are mapped from the output using a fully-connected layer of d out =64 units and the ReLU nonlinearity, followed by layer normalization.

Original: For the baseline encoder, initial learning rate is chosen as 0.0008 and exponential decay is applied with a rate of 0.9 applied every 8k iterations.
Revised: For the baseline encoder, initial learning rate is chosen as 0.0008 and exponential decay is applied with a rate of 0.9 applied every 8k iterations.

Original: The model is trained for 212k iterations.
Revised: The model is trained for 212k iterations.

Original: For prototypical learning model with softmax attention, the initial learning rate is chosen as 0.0008 and exponential decay is applied with a rate of 0.9 applied every 8k iterations.
Revised: For prototypical learning model with softmax attention, the initial learning rate is chosen as 0.0008 and exponential decay is applied with a rate of 0.9 applied every 8k iterations.

Original: The model is trained for 146k iterations.
Revised: The model is trained for 146k iterations.

Original: For prototypical learning model with sparsemax attention, the initial learning rate is chosen as 0.
Revised: For prototypical learning model with sparsemax attention, the initial learning rate is chosen as 0.

Original: and exponential decay is applied with a rate of 0.82 applied every 8k iterations.
Revised: and exponential decay is applied with a rate of 0.82 applied every 8k iterations.

Original: The model is trained for 270k iterations.
Revised: The model is trained for 270k iterations.

Original: All models use a batch size of 128 and gradient clipping above 20.
Revised: All models use a batch size of 128 and gradient clipping above 20.

Original: We do not apply any data augmentation.
Revised: We do not apply any data augmentation.

Original: C. 
Revised: C.

Original: T ABULAR
Revised: T ABULAR

Original: DATA C.3. A DULT C ENSUS I NCOME
Revised: DATA C.3. A DULT C ENSUS I NCOME

Original: There are two output classes: whether or not the annual income is above $50k.
Revised: There are two output classes: whether or not the annual income is above $50k.

Original: Categorical categories such as the ‘marital-status’ are mapped to multi-hot representations.
Revised: Categorical categories such as the ‘marital-status’ are mapped to multi-hot representations.

Original: Continuous variables are used after a ﬁxed normalization transformation.
Revised: Continuous variables are used after a ﬁxed normalization transformation.

Original: For ‘age’, the transformation ﬁrst subtracts 50 and then divides by 30.
Revised: For ‘age’, the transformation ﬁrst subtracts 50 and then divides by 30.

Original: For ‘fnlwgt’, the transformation ﬁrst takes the log, and then subtracts 9, and then divides by 3.
Revised: For ‘fnlwgt’, the transformation ﬁrst takes the log, and then subtracts 9, and then divides by 3.

Original: For ‘education-num’, the transformation ﬁrst subtracts 6 and then divides by 6.
Revised: For ‘education-num’, the transformation ﬁrst subtracts 6 and then divides by 6.

Original: For ‘hours-per-week’, the transformation ﬁrst subtracts 50 and then divides by 50.
Revised: For ‘hours-per-week’, the transformation ﬁrst subtracts 50 and then divides by 50.

Original: For ‘capital-gain’ and ‘capital-loss’, the normalization takes the log, and then subtracts 5, and then divides by 5.
Revised: For ‘capital-gain’ and ‘capital-loss’, the normalization takes the log, and then subtracts 5, and then divides by 5.

Original: The concatenated features are then mapped to a 64 dimensional vector using a fully-connected layer, followed by the ReLU nonlinearity.
Revised: The concatenated features are then mapped to a 64 dimensional vector using a fully-connected layer, followed by the ReLU nonlinearity.

Original: The base encoder uses an LSTM architecture, with 4 timesteps.
Revised: The base encoder uses an LSTM architecture, with 4 timesteps.

Original: At each timestep, 64-dimensional inputs are applied after a dropout with rate 0.5.
Revised: At each timestep, 64-dimensional inputs are applied after a dropout with rate 0.5.

Original: The output of the last timestep is used after applying a dropout with rate 0.5.
Revised: The output of the last timestep is used after applying a dropout with rate 0.5.

Original: Keys and queries are mapped from this output using a fully-connected layer followed by the ReLU nonlinearity, where the attention size is d att =16.
Revised: Keys and queries are mapped from this output using a fully-connected layer followed by the ReLU nonlinearity, where the attention size is d att =16.

Original: Values are mapped from the output using a fully-connected layer of d out =16 units and the ReLU nonlinearity, followed by layer normalization.
Revised: Values are mapped from the output using a fully-connected layer of d out =16 units and the ReLU nonlinearity, followed by layer normalization.

Original: For the baseline encoder, the initial learning rate is chosen as 0.002 and exponential decay is applied with a rate of 0.9 applied every 2k iterations.
Revised: For the baseline encoder, the initial learning rate is chosen as 0.002 and exponential decay is applied with a rate of 0.9 applied every 2k iterations.

Original: The model is trained for 4.5k iterations.
Revised: The model is trained for 4.5k iterations.

Original: For the models with attention in prototypical learning framework, the initial learning rate is chosen as 0.0005 and exponential decay is applied with a rate of 0.92 applied every 2k iterations.
Revised: For the models with attention in prototypical learning framework, the initial learning rate is chosen as 0.0005 and exponential decay is applied with a rate of 0.92 applied every 2k iterations.

Original: The softmax attention model is trained for 13.5k iterations and the sparsemax attention model is trained for 11.5k iterations.
Revised: The softmax attention model is trained for 13.5k iterations and the sparsemax attention model is trained for 11.5k iterations.

Original: For the model with sparsity regularization, the initial learning rate is 0.003 and exponential decay is applied with a rate of 0.7 applied every 2k iterations, and the model is trained for 7k iterations.
Revised: For the model with sparsity regularization, the initial learning rate is 0.003 and exponential decay is applied with a rate of 0.7 applied every 2k iterations, and the model is trained for 7k iterations.

Original: All models use a batch size of 128 and gradient clipping above 20.
Revised: All models use a batch size of 128 and gradient clipping above 20.

Original: We do not apply any data augmentation.
Revised: We do not apply any data augmentation.

Original: D A DDITIONAL PROTOTYPE EXAMPLES
Revised: D A DDITIONAL PROTOTYPE EXAMPLES

Original: Fig.
Revised: Fig.

Original: 10 exemplify prototypes for CIFAR-10.
Revised: 10 exemplify prototypes for CIFAR-10.

Original: For most cases, we observe the similarity of discriminative features between inputs and prototypes.
Revised: For most cases, we observe the similarity of discriminative features between inputs and prototypes.

Original: For example, the body ﬁgures of birds, the shape of tires, the face patterns of dogs, the body ﬁgures of frogs, the appearance of the background sky for planes, are among the features apparent in examples.
Revised: For example, the body ﬁgures of birds, the shape of tires, the face patterns of dogs, the body ﬁgures of frogs, the appearance of the background sky for planes, are among the features apparent in examples.

Original: Fig.
Revised: Fig.

Original: 11 shows additional prototype examples for DBPedia dataset.
Revised: 11 shows additional prototype examples for DBPedia dataset.

Original: Prototypes have very similar sentence structure, words and concepts, while categorizing the sentences into ontologies.
Revised: Prototypes have very similar sentence structure, words and concepts, while categorizing the sentences into ontologies.

Original: Fig.
Revised: Fig.

Original: 12 shows example prototypes for ISIC Melanoma.
Revised: 12 shows example prototypes for ISIC Melanoma.

Original: In some cases, we observe the commonalities between input and prototypes that distinguish melanoma cases such as the non-circular geometry or irregularly-notched borders (Jerant et al., 2000).
Revised: In some cases, we observe the commonalities between input and prototypes that distinguish melanoma cases such as the non-circular geometry or irregularly-notched borders (Jerant et al., 2000).

Original: Compared to other datasets, ISIC Melonama dataset yields lower interpretable prototype quality on average.
Revised: Compared to other datasets, ISIC Melonama dataset yields lower interpretable prototype quality on average.

Original: We hypothesize this to be due to the perceptual difﬁculty of the problem as well as the insufﬁcient encoder performance shown by the lower classiﬁcation accuracy (despite the acceptable AUC).
Revised: We hypothesize this to be due to the perceptual difﬁculty of the problem as well as the insufﬁcient encoder performance shown by the lower classiﬁcation accuracy (despite the acceptable AUC).

Original: Fig.
Revised: Fig.

Original: 13 shows more comparison examples for prototypical learning framework with sparsemax attention vs. representer point selection (Yeh et al., 2018) on Animals with Attributes dataset.
Revised: 13 shows more comparison examples for prototypical learning framework with sparsemax attention vs. representer point selection (Yeh et al., 2018) on Animals with Attributes dataset.

Original: For some cases, including chimpanzee, zebra, dalmatian and tiger, ProtoAttend yields perceptually very similar samples.
Revised: For some cases, including chimpanzee, zebra, dalmatian and tiger, ProtoAttend yields perceptually very similar samples.

Original: The similarity of the chimpanzee body form and the background, zebra patterns, dalmatian pattern on the grass, and tiger pattern and head pose, are prominent.
Revised: The similarity of the chimpanzee body form and the background, zebra patterns, dalmatian pattern on the grass, and tiger pattern and head pose, are prominent.

Original: Representer point selection fails to capture such similarity features as effectively.
Revised: Representer point selection fails to capture such similarity features as effectively.

Original: On the other hand, for bat, otter and wolf, the results are somewhat less satisfying.
Revised: On the other hand, for bat, otter and wolf, the results are somewhat less satisfying.

Original: The wing part of the bat, multiple count of the otters with the background, and the color and furry head of the wolf seem to be captured, but with less apparent similarity than some other possible samples from the dataset.
Revised: The wing part of the bat, multiple count of the otters with the background, and the color and furry head of the wolf seem to be captured, but with less apparent similarity than some other possible samples from the dataset.

Original: Representer point selection method also cannot be claimed to be successful in these cases.
Revised: Representer point selection method also cannot be claimed to be successful in these cases.

Original: Lastly, for leopard, ProtoAttend only yields one non-zero prototype (which is indeed statistically rare given the model and sparsity choices).
Revised: Lastly, for leopard, ProtoAttend only yields one non-zero prototype (which is indeed statistically rare given the model and sparsity choices).

Original: The pattern of the leopard image seems relevant, but it is also not fully satisfying to observe a single prototype that is not perceptually more similar.
Revised: The pattern of the leopard image seems relevant, but it is also not fully satisfying to observe a single prototype that is not perceptually more similar.

Original: All of the test examples in Fig.
Revised: All of the test examples in Fig.

Original: 13 are classiﬁed correctly with our framework and all of the shown prototypes are also from the correct classes.
Revised: 13 are classiﬁed correctly with our framework and all of the shown prototypes are also from the correct classes.

Original: E C OMPARISON OF CONFIDENCE - CONTROLLED PREDICTION FOR SOFTMAX VS . SPARSEMAX
Revised: E C OMPARISON OF CONFIDENCE - CONTROLLED PREDICTION FOR SOFTMAX VS . SPARSEMAX

Original: Figs.
Revised: Figs.

Original: 14 and 15 show the accuracy vs. ratio of samples for softmax vs. sparsemax attention without conﬁdence regularization.
Revised: 14 and 15 show the accuracy vs. ratio of samples for softmax vs. sparsemax attention without conﬁdence regularization.

Original: The baseline accuracy (at 100% prediction ratio) is higher for softmax attention for some datasets, whereas higher for sparsemax for some others.
Revised: The baseline accuracy (at 100% prediction ratio) is higher for softmax attention for some datasets, whereas higher for sparsemax for some others.

Original: On the other hand, higher number of prototypes yielded by softmax attention results in a wider range for conﬁdence-controlled prediction trade-off.
Revised: On the other hand, higher number of prototypes yielded by softmax attention results in a wider range for conﬁdence-controlled prediction trade-off.

Original: [Figure]
Revised: [Figure]

Original: I n p u t
Revised: I n p u t

Original: P r o t o t y p
Revised: P r o t o t y p

Original: e s
Revised: e s

Original: [Table] [Table]
Revised: [Table] [Table]

Original: payback is a hindi thriller film directed by sachin p. karande and produced by sarosh khan.
Revised: payback is a hindi thriller film directed by sachin p. karande and produced by sarosh khan.

Original: the film released on 17 december 2010 under the archangel entertainment banner.
Revised: the film released on 17 december 2010 under the archangel entertainment banner.

Original: hush... hush sweet charlotte is a 1964 american thriller film directed and produced by robert aldrich and starring bette davis olivia de havilland joseph cotten and agnes moorehead as well as mary astor in her final film.the movie was adapted for the screen by henry farrell and lukas heller from farrell's unpublished short story what ever happened to cousin charlotte?
Revised: hush... hush sweet charlotte is a 1964 american thriller film directed and produced by robert aldrich and starring bette davis olivia de havilland joseph cotten and agnes moorehead as well as mary astor in her final film.the movie was adapted for the screen by henry farrell and lukas heller from farrell's unpublished short story what ever happened to cousin charlotte?

Original: it received seven academy award nominations.
Revised: it received seven academy award nominations.

Original: nammal is a blockbuster malayalam movie released in 2002.
Revised: nammal is a blockbuster malayalam movie released in 2002.

Original: it is directed by the notable director kamal and produced by david kachapalli.
Revised: it is directed by the notable director kamal and produced by david kachapalli.

Original: the movie stars jishnu siddharth renuka menon and bhavana.
Revised: the movie stars jishnu siddharth renuka menon and bhavana.

Original: it is best known for its award winning song sukamanee nilavu sung by vidhu prathap and jyotsana.
Revised: it is best known for its award winning song sukamanee nilavu sung by vidhu prathap and jyotsana.

Original: the movie was shot in the campus of government engineering college thrissur and holy trinity school palakkad.other members of the cast i
Revised: the movie was shot in the campus of government engineering college thrissur and holy trinity school palakkad.other members of the cast i

Original: I n p u t
Revised: I n p u t

Original: P r o t o t y p
Revised: P r o t o t y p

Original: e s
Revised: e s

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: hazen high school is an accredited public secondary school located in rural distant community of hazen arkansas united states.
Revised: hazen high school is an accredited public secondary school located in rural distant community of hazen arkansas united states.

Original: the school provides comprehensive education to more than
Revised: the school provides comprehensive education to more than

Original: [Table]
Revised: [Table]

Original: annually in grades nine through twelve.
Revised: annually in grades nine through twelve.

Original: hazen high school is one of two public high schools in prairie county and is the sole high school administered by the hazen school district.
Revised: hazen high school is one of two public high schools in prairie county and is the sole high school administered by the hazen school district.

Original: the vivien t. thomas medical arts academy (vttmaa) is a public high school located in baltimore maryland.
Revised: the vivien t. thomas medical arts academy (vttmaa) is a public high school located in baltimore maryland.

Original: liceo requnoa
Revised: liceo requnoa

Original: (english:
Revised: (english:

Original: [Table]
Revised: [Table]

Original: high school) is a chilean high school located in requnoa cachapoal province chile.
Revised: high school) is a chilean high school located in requnoa cachapoal province chile.

Original: iranshahr high school is a high school in yazd iran.
Revised: iranshahr high school is a high school in yazd iran.

Original: [Table]
Revised: [Table]

Original: n
Revised: n

Original: [Table] [Table]
Revised: [Table] [Table]

Original: viettesia infuscata is a moth in the arctiidae family.
Revised: viettesia infuscata is a moth in the arctiidae family.

Original: it was described by de toulgot in 1959.
Revised: it was described by de toulgot in 1959.

Original: it is found in madagascar.
Revised: it is found in madagascar.

Original: bellulia antemediana
Revised: bellulia antemediana

Original: [Table]
Revised: [Table]

Original: [Figure] [Figure][Figure]
Revised: [Figure] [Figure]

Original: [Figure]
Revised: [Figure]

Original: As an impactful case study

Original: [Figure]
Revised: [Figure]

Original:  we consider melanoma detection problem with ISIC dataset (ISIC, 2016) in Supplementary Material.
Revised: As an impactful case study, we consider melanoma detection problem with ISIC dataset (ISIC, 2016) in Supplementary Material.

Original: In medical diagnosis, it is strongly desired to maintain a sufﬁciently-high prediction performance, potentially by verifying the decisions of an AI system by medical experts in the cases where the AI models are not conﬁdent.
Revised: In medical diagnosis, it is strongly desired to maintain a sufﬁciently-high prediction performance, potentially by verifying the decisions of an AI system by medical experts in the cases where the AI models are not conﬁdent.

Original: By refraining from some predictions, as shown in Fig.
Revised: By refraining from some predictions, as shown in Fig.

Original: [Figure] we demonstrate unprecedentedly high AUC values without using transfer learning or highly-customized models (Haenssle et al., 2018).
Revised: 16, we demonstrate unprecedentedly high AUC values without using transfer learning or highly-customized models (Haenssle et al., 2018).

Revised: F H UMAN USER STUDY ON THE USEFULNESS OF PROTOTYPES

Revised: We perform a user study by asking humans how much an extra image helps in explaining the guessed class of the input, after showing what the trained network predicts for that input.

Revised: We consider the Animals with Attributes dataset (exempliﬁed in Fig. 13).

Revised: We randomly pick test samples and assess how much showing the top prototype makes a difference.

Revised: The results in Table 5 shows that

Original: F C ONTROLLING SPARSITY VIA REGULARIZATION
Revised: ProtoAttend picks [Table] G C ONTROLLING SPARSITY VIA REGULARIZATION

Original: [Figure]
Revised: [Figure]

Original: Fig.
Revised: Fig.

Original: 17 shows the impact of sparsity regularization coefﬁcient on training.
Revised: 17 shows the impact of sparsity regularization coefﬁcient on training.

Original: By varying the value of λ sparse , the number of prototypes can be efﬁciently controlled.
Revised: By varying the value of λ sparse , the number of prototypes can be efﬁciently controlled.

Original: For high values of sparsity regularization coefﬁcient, the model gets stuck at a point where it is forced to make decision from a low number of prototypes before the encoder model is properly learned, hence typically yields considerably lower performance.
Revised: For high values of sparsity regularization coefﬁcient, the model gets stuck at a point where it is forced to make decision from a low number of prototypes before the encoder model is properly learned, hence typically yields considerably lower performance.

Original: We also observe sparsity mechanism via sparsemax attention to yield better performance than softmax attention with high sparsity regularization [Figure]
Revised: We also observe sparsity mechanism via sparsemax attention to yield better performance than softmax attention with high sparsity regularization.

Original: G P ROTOTYPE QUALITY
Revised: H P ROTOTYPE QUALITY

Original: In general, the following scenarios may yield low prototype quality:
Revised: In general, the following scenarios may yield low prototype quality:

Original: Lack of related samples in the candidate database.
Revised: Lack of related samples in the candidate database.

Original: Perceptual difference between humans and encoders in determining discriminative features.
Revised: Perceptual difference between humans and encoders in determining discriminative features.

Original: High intra-class variability that makes training difﬁcult.
Revised: High intra-class variability that makes training difﬁcult.

Original: Imperfect encoder that cannot yield fully accurate representations of the input.
Revised: Imperfect encoder that cannot yield fully accurate representations of the input.

Original: Insufﬁciency of relational attention to determine weights from queries and keys.
Revised: Insufﬁciency of relational attention to determine weights from queries and keys.

Revised: Inefﬁcient decoupling between encoder & attention blocks and the ﬁnal decision block.

Original: There can be problem-dependent fundamental limitations on (1)-(3), whereas (4)-(6) are raised by choices of models and losses and can be further improved.
Revised: There can be problem-dependent fundamental limitations on (1)-(3), whereas (4)-(6) are raised by choices of models and losses and can be further improved.

Original: We leave the quantiﬁcation of prototype quality using information-theoretic metrics or discriminative neural networks to future work.
Revised: We leave the quantiﬁcation of prototype quality using information-theoretic metrics or discriminative neural networks to future work.

Original: H U NDERSTANDING MISCLASSIFICATION CASES
Revised: I U NDERSTANDING MISCLASSIFICATION CASES

Original: One of the beneﬁts of prototypical learning is insights into wrong decision cases.
Revised: One of the beneﬁts of prototypical learning is insights into wrong decision cases.

Original: Fig.
Revised: Fig.

Original: 18 exempliﬁes prototypes with wrong labels, that give insights about why the model is confused about a particular input (e.g. due to similarity of the visual patterns).
Revised: 18 exempliﬁes prototypes with wrong labels, that give insights about why the model is confused about a particular input (e.g. due to similarity of the visual patterns).

Original: Such insights can be actionable to improve the model performance, such as adding more training samples for the confusing classes or modifying the loss functions.
Revised: Such insights can be actionable to improve the model performance, such as adding more training samples for the confusing classes or modifying the loss functions.

Original: [Figure]
Revised: [Figure]