Original: D EEP M ULTIPLE I NSTANCE L EARNING WITH G AUSSIAN W EIGHTING
Revised: D EEP M ULTIPLE I NSTANCE L EARNING WITH G AUSSIAN W EIGHTING

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: In this paper we present a deep Multiple Instance Learning (MIL) method that can be trained end-to-end to perform classiﬁcation from weak supervision.
Revised: In this paper we present a deep Multiple Instance Learning (MIL) method that can be trained end-to-end to perform classiﬁcation from weak supervision.

Original: Our MIL method is implemented as a two stream neural network, specialized in tasks of instance classiﬁcation and weighting.
Revised: Our MIL method is implemented as a two stream neural network, specialized in tasks of instance classiﬁcation and weighting.

Original: Our instance weighting stream makes use of Gaussian radial basis function to normalize the instance weights by comparing instances locally within the bag and globally across bags.
Revised: Our instance weighting stream makes use of Gaussian radial basis function to normalize the instance weights by comparing instances locally within the bag and globally across bags.

Original: The ﬁnal classiﬁcation score of the bag is an aggregate of all instance classiﬁcation scores.
Revised: The ﬁnal classiﬁcation score of the bag is an aggregate of all instance classiﬁcation scores.

Original: The instance representation is shared by both instance classiﬁcation and weighting streams.
Revised: The instance representation is shared by both instance classiﬁcation and weighting streams.

Original: The
Revised: The

Original: Gaussian instance weighting allows us to regularize the representation learning of instances such that all positive instances to be closer to each other w.r.t.
Revised: Gaussian instance weighting allows us to regularize the representation learning of instances such that all positive instances to be closer to each other w.r.t.

Original: the instance weighting function.
Revised: the instance weighting function.

Original: We evaluate our method on ﬁve standard MIL datasets and show that our method outperforms other MIL methods.
Revised: We evaluate our method on ﬁve standard MIL datasets and show that our method outperforms other MIL methods.

Original: We also evaluate our model on two datasets where all models are trained end-to-end.
Revised: We also evaluate our model on two datasets where all models are trained end-to-end.

Original: Our method obtain better bag-classiﬁcation and instance classiﬁcation results on these datasets.
Revised: Our method obtain better bag-classiﬁcation and instance classiﬁcation results on these datasets.

Original: We conduct extensive experiments to investigate the robustness of the proposed model and obtain interesting insights.
Revised: We conduct extensive experiments to investigate the robustness of the proposed model and obtain interesting insights.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Multiple instance learning (MIL) [6] is a form of weakly supervised learning that have been widely applied in drug activity prediction [6], medical imaging [12], text analysis and natural language processing [2] and computer vision [16].
Revised: Multiple instance learning (MIL) [7] is a form of weakly supervised learning that have been widely applied in drug activity prediction [7], medical imaging [14], text analysis and natural language processing [2] and computer vision [18].

Original: In contrast to the standard supervised learning where every training instance is provided with a label, in MIL, training instances are grouped in sets, called bags , and labels are provided at bag-level (i.e. one label for entire bag).
Revised: In contrast to the standard supervised learning where every training instance is provided with a label, in MIL, training instances are grouped in sets, called bags , and labels are provided at bag-level (i.e. one label for entire bag).

Original: In the case of binary classiﬁcation, a bag is labeled as positive, if there is at-least one positive sample, otherwise it is negative.
Revised: In the case of binary classiﬁcation, a bag is labeled as positive, if there is at-least one positive sample, otherwise it is negative.

Original: As the instance labels are only indirectly accessible through labels attached to bags, the ambiguity of not knowing which instances are positive makes the problem signiﬁcantly more challenging than the standard supervised classiﬁcation.
Revised: As the instance labels are only indirectly accessible through labels attached to bags, the ambiguity of not knowing which instances are positive makes the problem signiﬁcantly more challenging than the standard supervised classiﬁcation.

Original: As the ratio of negatives to the positives increases in bags, the ambiguity increases and this renders the problem of bag classiﬁcation harder.
Revised: As the ratio of negatives to the positives increases in bags, the ambiguity increases and this renders the problem of bag classiﬁcation harder.

Original: Our hypothesis is that the ability of robustly detecting positive instances in a bag is essential for successful MIL methods.
Revised: Our hypothesis is that the ability of robustly detecting positive instances in a bag is essential for successful MIL methods.

Original: There is a rich body of literature in MIL which can broadly be grouped in two main categories, bag-level [15] and instance-level approaches [1, 20].
Revised: There is a rich body of literature in MIL which can broadly be grouped in two main categories, bag-level [17] and instance-level approaches [1, 22].

Original: The ﬁrst group maps instances of a bag into a single embedding (e.g. Fisher Vector [15]) and trains bag-level predictors to classify each bag in a similar manner to the standard classiﬁcation.
Revised: The ﬁrst group maps instances of a bag into a single embedding (e.g. Fisher Vector [17]) and trains bag-level predictors to classify each bag in a similar manner to the standard classiﬁcation.

Original: The second approach learns instance-level classiﬁers and aggregates the scores of individual instances from each bag.
Revised: The second approach learns instance-level classiﬁers and aggregates the scores of individual instances from each bag.

Original: Though the former can be thought to provide a more unbiased solution to the problem of bag classiﬁcation, the instance-level approach has recently been shown to outperform the bag-level one in [14, 8] under the assumption that bag labels can be predicted from individual instances.
Revised: Though the former can be thought to provide a more unbiased solution to the problem of bag classiﬁcation, the instance-level approach has recently been shown to outperform the bag-level one in [16, 10] under the assumption that bag labels can be predicted from individual instances.

Original: However, predicting instance labels from baglevel ones is an ill-posed problem.
Revised: However, predicting instance labels from baglevel ones is an ill-posed problem.

Original: Thus, previous work proposes constrained solutions to tackle the ambiguity.
Revised: Thus, previous work proposes constrained solutions to tackle the ambiguity.

Original: Liu et al.
Revised: Liu et al.

Original: [11] propose a voting framework to capture neighborhood relationship between instances from different bags to identify key instances.
Revised: [13] propose a voting framework to capture neighborhood relationship between instances from different bags to identify key instances.

Original: To this end, the authors use the voting framework to obtain a weighted nearest neighbor (NN) classiﬁer where its weights globally generated from a kNN graph.
Revised: To this end, the authors use the voting framework to obtain a weighted nearest neighbor (NN) classiﬁer where its weights globally generated from a kNN graph.

Original: Conditional random ﬁelds (CRF) are used to model relationships between bags in [5].
Revised: Conditional random ﬁelds (CRF) are used to model relationships between bags in [6].

Original: This models bags as nodes in a CRF with instances as their states.
Revised: This models bags as nodes in a CRF with instances as their states.

Original: However, these methods are not learned end-to-end and thus relies on the feature space metric to obtain meaningful weights for each instance.
Revised: However, these methods are not learned end-to-end and thus relies on the feature space metric to obtain meaningful weights for each instance.

Original: Deep neural networks are also widely applied to solve MIL problem [13, 20, 14].
Revised: Deep neural networks are also widely applied to solve MIL problem [15, 22, 16].

Original: Zhou et
Revised: Zhou et

Original: [20] aggregate the outputs of instance level classiﬁer by the max operator to ensure that if at least one instance of a positive training bag is predicted as positive, then the concerned bag is assumed as positive.
Revised: [22] aggregate the outputs of instance level classiﬁer by the max operator to ensure that if at least one instance of a positive training bag is predicted as positive, then the concerned bag is assumed as positive.

Original: Similarly, if all instances of a negative bag are predicted as negative then the bag is negative.
Revised: Similarly, if all instances of a negative bag are predicted as negative then the bag is negative.

Original: However, this method does not explicitly model for identifying the key instances in the neural network architecture but rather hope that feature representation of the instances would adapt (network would learn) such that instance level classiﬁer can solely learn to give higher scores for positive instances from this loss function.
Revised: However, this method does not explicitly model for identifying the key instances in the neural network architecture but rather hope that feature representation of the instances would adapt (network would learn) such that instance level classiﬁer can solely learn to give higher scores for positive instances from this loss function.

Original: Ramon and De Raedt [13] introduce log-sum-exp as the convex max to calculate bag probabilities from instance probabilities.
Revised: Ramon and De Raedt [15] introduce log-sum-exp as the convex max to calculate bag probabilities from instance probabilities.

Original: Wang et al.
Revised: Wang et al.

Original: [14] introduce differential MIL pooling layer to enforce MIL constraints such as that each positive bag should have at-least one positive instance.
Revised: [16] introduce differential MIL pooling layer to enforce MIL constraints such as that each positive bag should have at-least one positive instance.

Original: Recently, attention-based deep multiple instance learning was proposed where attention is applied over the features using Softmax attention before obtaining a bag level representation [8].
Revised: Recently, attention-based deep multiple instance learning was proposed where attention is applied over the features using Softmax attention before obtaining a bag level representation [10].

Original: We also build on the idea of instance level classiﬁcation, however, we take a different approach from all these methods in three aspects: First, we propose to take a two stream approach for instance classiﬁcation and instance weighting (see ﬁg. 1).
Revised: We also build on the idea of instance level classiﬁcation, however, we take a different approach from all these methods in three aspects: First, we propose to take a two stream approach for instance classiﬁcation and instance weighting (see ﬁg. 1).

Original: Speciﬁcally, we have two dedicated paths or streams in our neural network, one dedicated for instance classiﬁcation by returning a score and the other stream dedicated for learning normalized weights.
Revised: Speciﬁcally, we have two dedicated paths or streams in our neural network, one dedicated for instance classiﬁcation by returning a score and the other stream dedicated for learning normalized weights.

Original: We show empirically that this is crucial.
Revised: We show empirically that this is crucial.

Original: Second, we do not speciﬁcally enforce any MIL constraint (e.g. number of positives in bag, certain graph structure) but rather choose a Gaussian activation function that allows us to learn a soft constraint to weight instances by comparing instances within bags and/or across bags.
Revised: Second, we do not speciﬁcally enforce any MIL constraint (e.g. number of positives in bag, certain graph structure) but rather choose a Gaussian activation function that allows us to learn a soft constraint to weight instances by comparing instances within bags and/or across bags.

Original: We investigate two variants of Gaussian activated weighting functions that employ bag-level or cross-bag statistics to assign weights to each instance.
Revised: We investigate two variants of Gaussian activated weighting functions that employ bag-level or cross-bag statistics to assign weights to each instance.

Original: By comparing instances within a bag or across bags, our Gaussian activated weighting function learns meaningful weights to detect key instances within a bag.
Revised: By comparing instances within a bag or across bags, our Gaussian activated weighting function learns meaningful weights to detect key instances within a bag.

Original: It assigns a higher weight for positive instances while assigns a small value for negative instances.
Revised: It assigns a higher weight for positive instances while assigns a small value for negative instances.

Original: In-fact, the instance weighing function assigns lower weights to the instances that are far from the mean and thus encourages positive instances to form compact clusters in the feature space.
Revised: In-fact, the instance weighing function assigns lower weights to the instances that are far from the mean and thus encourages positive instances to form compact clusters in the feature space.

Original: Enforcing similarity among the features of positive instances through a single mean per class also has a strong regularization on the feature space which implicitly enforces constraints on MIL.
Revised: Enforcing similarity among the features of positive instances through a single mean per class also has a strong regularization on the feature space which implicitly enforces constraints on MIL.

Original: Third, we simply extend our binary MIL method to a multi-class bag-classiﬁcation and our method is robust against severe ambiguity levels (very few positives in a very large bag).
Revised: Third, we simply extend our binary MIL method to a multi-class bag-classiﬁcation and our method is robust against severe ambiguity levels (very few positives in a very large bag).

Original: We demonstrate that our method obtain state-of-the-art results in the standard MIL instance learning benchmarks.
Revised: We demonstrate that our method obtain state-of-the-art results in the standard MIL instance learning benchmarks.

Original:  M ETHOD
Revised:  M ETHOD

Original: Problem deﬁnition.
Revised: Problem deﬁnition.

Original: In standard classiﬁcation, it is assumed that we are given a set of training pairs ( x
Revised: In standard classiﬁcation, it is assumed that we are given a set of training pairs ( x

Original: , y ) ∈ R d × Y with the goal of learning a predictor from inputs to labels f : R d → Y .
Revised: , y ) ∈ R d × Y with the goal of learning a predictor from inputs to labels f : R d → Y .

Original: In this paper, we focus on the more general problem of MIL and use a weaker form of supervision.
Revised: In this paper, we focus on the more general problem of MIL and use a weaker form of supervision.

Original: Input samples are now organized into bags B 1 , B 2 , ..., B m with each bag contains a variable number of samples, i.e. B I =
Revised: Input samples are now organized into bags B 1 , B 2 , ..., B m with each bag contains a variable number of samples, i.e. B I =

Original: { x i : i ∈ { 1 , · · · , | I |} where | I | is the number of instances in B I .
Revised: { x i : i ∈ { 1 , · · · , | I |} where | I | is the number of instances in B I .

Original: In this setting, individual instances do not have access to a label but each bag B I is associated with a label Y I ∈ Y .
Revised: In this setting, individual instances do not have access to a label but each bag B I is associated with a label Y I ∈ Y .

Original: We consider two settings, binary and multi-class classiﬁcation.
Revised: We consider two settings, binary and multi-class classiﬁcation.

Original: In the binary case
Revised: In the binary case

Original: Y = {− 1 , 1 } , if a bag is negative, all instances in the bag are negative.
Revised: Y = {− 1 , 1 } , if a bag is negative, all instances in the bag are negative.

Original: On the other hand, if a bag is positive, at least one of the instances is positive.
Revised: On the other hand, if a bag is positive, at least one of the instances is positive.

Original: In the multi-class case, the output space is categorical, i.e. Y = { 1 , 2 , · · · , C } where C is the number of categories.
Revised: In the multi-class case, the output space is categorical, i.e. Y = { 1 , 2 , · · · , C } where C is the number of categories.

Original: We learn a classiﬁer g : X | I | → Y that takes in a bag of instances and outputs high score only for the target class:
Revised: We learn a classiﬁer g : X | I | → Y that takes in a bag of instances and outputs high score only for the target class:

Original: [Equation]
Revised: [Equation]

Original: where ρ is a symmetric function as in [17, 8, 4] (i.e. permutation invariant to the ordering of instances x in a bag) which can be decomposed into predictions for individiual instances f ( x ) .
Revised: where ρ is a symmetric function as in [19, 10, 4] (i.e. permutation invariant to the ordering of instances x in a bag) which can be decomposed into predictions for individiual instances f ( x ) .

Original: In other words, as we do not have access to ground-truth labels y for individual samples x , instance level predictions f ( x ) are aggregated to obtain bag-level prediction g ( B ) .
Revised: In other words, as we do not have access to ground-truth labels y for individual samples x , instance level predictions f ( x ) are aggregated to obtain bag-level prediction g ( B ) .

Original: Examples of the aggregation function ρ are max operator [1], weighted sum operator [8] and log of sum of exponentials [13].
Revised: Examples of the aggregation function ρ are max operator [1], weighted sum operator [10] and log of sum of exponentials [15].

Original: As a matter of fact, we also build our MIL method on an aggregation function takes in instance level predictions, predicts the importance of each and aggregates them by taking a weighted sum to obtain a bag level prediction.
Revised: As a matter of fact, we also build our MIL method on an aggregation function takes in instance level predictions, predicts the importance of each and aggregates them by taking a weighted sum to obtain a bag level prediction.

Original: In particular, we extend the idea present in eq.
Revised: In particular, we extend the idea present in eq.

Original: (1) to weight each instance using a neural network speciﬁcally designed to select key instances [11] i.e. discriminative instances that can reliably be utilized to predict bag labels.
Revised: (1) to weight each instance using a neural network speciﬁcally designed to select key instances [13] i.e. discriminative instances that can reliably be utilized to predict bag labels.

Original: Formally we deﬁne each key instance to be positive below:
Revised: Formally we deﬁne each key instance to be positive below:

Original: Deﬁnition.
Revised: Deﬁnition.

Original: Given a bag of multiple instances, if the bag label is positive, the key instances are the instances having positive label.
Revised: Given a bag of multiple instances, if the bag label is positive, the key instances are the instances having positive label.

Original: Property.
Revised: Property.

Original: Given a bag of multiple instances, if the bag is positive, key instances are fewer than nonkey instances.
Revised: Given a bag of multiple instances, if the bag is positive, key instances are fewer than nonkey instances.

Original: A diagram of our model is depicted in ﬁg. 1 which consists of two streams, each stream contains multiple components.
Revised: A diagram of our model is depicted in ﬁg. 1 which consists of two streams, each stream contains multiple components.

Original: We describe them in the following.
Revised: We describe them in the following.

Original: Instance classiﬁer f .
Revised: Instance classiﬁer f .

Original: First we deﬁne the instance level prediction f ( x ) =
Revised: First we deﬁne the instance level prediction f ( x ) =

Original: ψ θ ψ ◦ φ θ φ as a composition of a feature extractor φ : X → H where H is latent variable space and of a classiﬁer ψ where ψ ( φ ( x ; θ φ ); θ ψ ) ∈ R C and C is the number of target categories.
Revised: ψ θ ψ ◦ φ θ φ as a composition of a feature extractor φ : X → H where H is latent variable space and of a classiﬁer ψ where ψ ( φ ( x ; θ φ ); θ ψ ) ∈ R C and C is the number of target categories.

Original: In fact, both φ and ψ are modeled as deep neural networks with learnable parameters θ φ and θ ψ respectively.
Revised: In fact, both φ and ψ are modeled as deep neural networks with learnable parameters θ φ and θ ψ respectively.

Original: Instance weighting β .
Revised: Instance weighting β .

Original: The bag classiﬁer g ( B I ) takes in the instance scores f ( x 1 ) , · · · , f ( x | I | ) for B I and outputs a weighted sum of them by using β ( · ; θ β ) :
Revised: The bag classiﬁer g ( B I ) takes in the instance scores f ( x 1 ) , · · · , f ( x | I | ) for B I and outputs a weighted sum of them by using β ( · ; θ β ) :

Original: X → [0 , 1] C where θ β are the parameters of the mapping β .
Revised: X → [0 , 1] C where θ β are the parameters of the mapping β .

Original: Equation (1) can be rewritten as follows
Revised: Equation (1) can be rewritten as follows

Original: [Equation]
Revised: [Equation]

Original: where ρ is an aggregating operator (or the pooling function) and θ β are the learnable parameters of β .
Revised: where ρ is an aggregating operator (or the pooling function) and θ β are the learnable parameters of β .

Original: The weighting function β = σ ◦ ϕ ◦ φ is also modeled as a composition of three functions.
Revised: The weighting function β = σ ◦ ϕ ◦ φ is also modeled as a composition of three functions.

Original: β shares the feature extractor φ with the instance classiﬁer f , however, applies consecutively ϕ ( · ; θ ϕ ) (drawn in green in ﬁg. 1) on the features which outputs an C dimensional unnormalized vector and followed by a univariate Gaussian radial basis normalization σ (drawn in blue in ﬁg. 1) deﬁned as follows:
Revised: β shares the feature extractor φ with the instance classiﬁer f , however, applies consecutively ϕ ( · ; θ ϕ ) (drawn in green in ﬁg. 1) on the features which outputs an C dimensional unnormalized vector and followed by a univariate Gaussian radial basis normalization σ (drawn in blue in ﬁg. 1) deﬁned as follows:

Original: [Equation]
Revised: [Equation]

Original: where µ and (cid:15) are the mean and standard deviation respectively.
Revised: where µ and (cid:15) are the mean and standard deviation respectively.

Original: We propose two ways of calculating µ and (cid:15) .
Revised: We propose two ways of calculating µ and (cid:15) .

Original: In the ﬁrst case, we ﬁt µ and (cid:15) to the scores that are extracted over B I , i.e.
Revised: In the ﬁrst case, we ﬁt µ and (cid:15) to the scores that are extracted over B I , i.e.

Original: { ϕ ( φ ( x 1 )) , · · · , ϕ ( φ ( x | I | )) } .
Revised: { ϕ ( φ ( x 1 )) , · · · , ϕ ( φ ( x | I | )) } .

Original: µ and (cid:15) are simply statistics and can be calculated by the following formulas:
Revised: µ and (cid:15) are simply statistics and can be calculated by the following formulas:

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: In other words, weights can be normalized by using the local bag statistics.
Revised: In other words, weights can be normalized by using the local bag statistics.

Original: These variants are denoted by GP0T0 and GP0T1 as explained later in the experiments.
Revised: These variants are denoted by GP0T0 and GP0T1 as explained later in the experiments.

Original: Here the intuition is that by comparing each instance with local-bag statistics, our weight learning function is able to learn to detect key instances.
Revised: Here the intuition is that by comparing each instance with local-bag statistics, our weight learning function is able to learn to detect key instances.

Original: In the second one, we set µ and (cid:15) as parameters of our network and jointly optimize them with the rest of the network parameters ( θ φ , θ ψ , θ ϕ ).
Revised: In the second one, we set µ and (cid:15) as parameters of our network and jointly optimize them with the rest of the network parameters ( θ φ , θ ψ , θ ϕ ).

Original: In this case, the parameters are not local to a bag but global, learned from the updates from all the training samples and do not necessarily correspond to a statistical mean and standard deviation of the score distribution anymore.
Revised: In this case, the parameters are not local to a bag but global, learned from the updates from all the training samples and do not necessarily correspond to a statistical mean and standard deviation of the score distribution anymore.

Original: This variant is denoted by GP1T1 .
Revised: This variant is denoted by GP1T1 .

Original: Training.
Revised: Training.

Original: In this paper we focus on two kinds of MIL tasks, binary and multi-class classiﬁcation.
Revised: In this paper we focus on two kinds of MIL tasks, binary and multi-class classiﬁcation.

Original: In the binary case, both the instance classiﬁer f and weighting function β output a scalar per instance, their outputs are simply multiplied (see eq.
Revised: In the binary case, both the instance classiﬁer f and weighting function β output a scalar per instance, their outputs are simply multiplied (see eq.

Original: Afterwards, log-sum-exponent [13] is applied over all the instances as the aggregation function ρ and ﬁnally, fed into a sigmoid function to get the[Table] probability of being positive for a bag.
Revised: Afterwards, log-sum-exponent [15] is applied over all the instances as the aggregation function ρ and ﬁnally, fed into a sigmoid function to get the probability of being positive for a bag.

Original: We use the binary cross entropy loss to train this model.
Revised: We use the binary cross entropy loss to train this model.

Original: In the multi-class case, both the instance classiﬁer f and weighting function β output a C dimensional vector, they are element-wise multiplied, then averaged over the bag and ﬁnally normalized by a softmax function over classes.
Revised: In the multi-class case, both the instance classiﬁer f and weighting function β output a C dimensional vector, they are element-wise multiplied, then averaged over the bag and ﬁnally normalized by a softmax function over classes.

Original: Here we use the cross entropy loss to optimize the model.
Revised: Here we use the cross entropy loss to optimize the model.

Original: We train all network parameters jointly by using stochastic gradient descent or Adam.
Revised: We train all network parameters jointly by using stochastic gradient descent or Adam.

Original: The implementation details are given in section 3.
Revised: The implementation details are given in section 3.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: We investigate three variants of our model by varying two design decisions in a controlled manner.
Revised: We investigate three variants of our model by varying two design decisions in a controlled manner.

Original: First we analyze whether the two stream architecture, specialized streams for instance classiﬁcation and weighting are beneﬁcial.
Revised: First we analyze whether the two stream architecture, specialized streams for instance classiﬁcation and weighting are beneﬁcial.

Original: Second, we study whether the parameters of the proposed Gaussian normalization should be calculated from bag statistics or learned along with the other parameters in the network.
Revised: Second, we study whether the parameters of the proposed Gaussian normalization should be calculated from bag statistics or learned along with the other parameters in the network.

Original: We describe three model variants in the following.
Revised: We describe three model variants in the following.

Original: GP0T0.
Revised: GP0T0.

Original: Here, we set both classiﬁer ψ ( · , θ ψ ) and instance weighting function ϕ ( · , θ ϕ ) to be the same, i.e., θ ψ = θ ϕ .
Revised: Here, we set both classiﬁer ψ ( · , θ ψ ) and instance weighting function ϕ ( · , θ ϕ ) to be the same, i.e., θ ψ = θ ϕ .

Original: This prevents the network to learn specialized functions for instance classiﬁcation and weighting and we indicate this by “T0” (two stream off).
Revised: This prevents the network to learn specialized functions for instance classiﬁcation and weighting and we indicate this by “T0” (two stream off).

Original: The Gaussian function variables µ and (cid:15) are estimated from eq.
Revised: The Gaussian function variables µ and (cid:15) are estimated from eq.

Original: (4) and this is denoted by “GP0” (Gaussian parameters not learnable).
Revised: (4) and this is denoted by “GP0” (Gaussian parameters not learnable).

Original: Hence, there are no dedicated parameters for learning the weighting function.
Revised: Hence, there are no dedicated parameters for learning the weighting function.

Original: Since µ and (cid:15) are estimated using within bag instances, prediction weights only depends on local bag information.
Revised: Since µ and (cid:15) are estimated using within bag instances, prediction weights only depends on local bag information.

Original: GP0T1 Here we use dedicated parameters for the instance weighting function ϕ ( · , θ ϕ ) and it is realized by a 2-layered neural network with Relu activation.
Revised: GP0T1 Here we use dedicated parameters for the instance weighting function ϕ ( · , θ ϕ ) and it is realized by a 2-layered neural network with Relu activation.

Original: As in the previous case, the parameters of the Gaussian normalization are estimated from eq.
Revised: As in the previous case, the parameters of the Gaussian normalization are estimated from eq.

Original: GP1T1 In this case, we keep the same settings in GP0T1 but the parameters of the Gaussian normalization ( µ and (cid:15) ) are learned through back-propagation along with the other network parameters.
Revised: GP1T1 In this case, we keep the same settings in GP0T1 but the parameters of the Gaussian normalization ( µ and (cid:15) ) are learned through back-propagation along with the other network parameters.

Original: In contrast to the setting where the Gaussian parameters are estimated locally for each bag, we learn a single global parameterization.
Revised: In contrast to the setting where the Gaussian parameters are estimated locally for each bag, we learn a single global parameterization.

Original: In the next section we report and analyze our results in different binary and multi-class classiﬁcation datasets and compare our results to the previous work.
Revised: In the next section we report and analyze our results in different binary and multi-class classiﬁcation datasets and compare our results to the previous work.

Revised: Similar to the instance weighting function ϕ , our classiﬁer (i.e. φ ) is realized by a 2-layered neural network with Relu activation.

Revised: The form of feature extractor depends on the problem.

Revised: We use LeNet model as the feature extractor for CIFAR10 and MNIST datasets.

Revised: We use a multi layered perceptron (3 fully connected layers with 256, 128 and 64 dimensions, with ReLU activation) for other MIL datasets.

Original: 3. R ESULTS FOR BINARY CLASSIFICATION .
Revised: 3. R ESULTS FOR BINARY CLASSIFICATION .

Original: First, we evaluate our method on MNIST-bags dataset [8] with the code provided by the authors.
Revised: First, we evaluate our method on MNIST-bags dataset [10] with the code provided by the authors.

Original: A bag is made up of a random number of 28 × 28 gray images taken from the MNIST dataset.
Revised: A bag is made up of a random number of 28 × 28 gray images taken from the MNIST dataset.

Original: The number of images in a bag is Gaussian-distributed and a bag is given a positive label if it contains one or more images with the label “9”.
Revised: The number of images in a bag is Gaussian-distributed and a bag is given a positive label if it contains one or more images with the label “9”.

Original: Following [8], we investigate the inﬂuence of the number of bags in the training set and compare all methods.
Revised: Following [10], we investigate the inﬂuence of the number of bags in the training set and compare all methods.

Original: During evaluation we use a ﬁxed number of 1,000 test bags.
Revised: During evaluation we use a ﬁxed number of 1,000 test bags.

Original: For all experiments a LeNet5 [10] feature extractor φ () is used.
Revised: For all experiments a LeNet5 [12] feature extractor φ () is used.

Original: We use the default training parameters that are used in [8] (mean bag length is 10, variance of the bag length is 2, etc.).
Revised: We use the default training parameters that are used in [10] (mean bag length is 10, variance of the bag length is 2, etc.).

Original: All models are trained end-to-end with the same loss function and same amount of epochs.
Revised: All models are trained end-to-end with the same loss function and same amount of epochs.

Original: The attention method ( ATT ) introduced in [8] apply Softmax over instance scores returned by an instance classiﬁer and then use those Softmax normalized scores to obtain a bag-level feature representation (or a bag embedding).
Revised: The attention method ( ATT ) introduced in [10] apply Softmax over instance scores returned by an instance classiﬁer and then use those Softmax normalized scores to obtain a bag-level feature representation (or a bag embedding).

Revised: ATT-G uses the gated mechanism of ATT where a combination of both tanh and sigmoid activations are used [10].

Original: Similarly, WSDN [3] method uses a two-stream approach like us, where one stream is used to weight regions proposals using Softmax function and the other stream is used to classify image regions to improve object detection.
Revised: Similarly, WSDN [3] method uses a two-stream approach like us, where one stream is used to weight regions proposals using Softmax function and the other stream is used to classify image regions to improve object detection.

Original: Finally, in WSDN the sum of weighted region scores are used to train the model.
Revised: Finally, in WSDN the sum of weighted region scores are used to train the model.

Original: WSDN is originally used for object detection, however here we adapt it for MIL.
Revised: WSDN is originally used for object detection, however here we adapt it for MIL.

Original: WSDN is related to this work as it also uses a two-stream approach.
Revised: WSDN is related to this work as it also uses a twostream approach.

Original: Therefore, we compare with these two models using MNIST-bags dataset [8] and results are reported in table 1. 
Revised: Therefore, we compare with these two models using MNIST-bags dataset [10] and results are reported in table 1. [Table]

Original: [Table]
Revised: [Table]

Original: From these results, we see that ATT does not perform as well as WSDN.
Revised: From these results, we see that ATT does not perform as well as WSDN.

Revised: Gated attention ATT-G, does not perform as good as ATT except in one case.

Original: Both these methods use Softmax function to identify key instances.
Revised: Both ATT and WSDN methods use Softmax function to identify key instances.

Original: However, ATT uses Softmax scores for learning an attention-based feature representation for the bag whereas WSDN uses the same information to weight instances.
Revised: However, ATT uses Softmax scores for learning an attentionbased feature representation for the bag whereas WSDN uses the same information to weight instances.

Original: This suggests that perhaps the two stream approach is much effective for multiple instance learning even-though WSDN is initially designed for object detection.
Revised: This suggests that perhaps the two stream approach is much effective for multiple instance learning even-though WSDN is initially designed for object detection.

Original: Our two stream-off GPOTO does not perform as good as WSDN or the ATT indicating perhaps the two stream approach is need.
Revised: Our two stream-off GPOTO does not perform as good as WSDN or the ATT indicating perhaps the two stream approach is need.

Original: GP0T1 method which enables two stream approach over Gaussian instance weighting obtains comparable results to ATT and WSDN.
Revised: GP0T1 method which enables two stream approach over Gaussian instance weighting obtains comparable results to ATT and WSDN.

Original: This conﬁrms the effectiveness of two-stream approach in multiple instance learning.
Revised: This conﬁrms the effectiveness of two-stream approach in multiple instance learning.

Original: Finally, we see a signiﬁcant boost in performance for GP1T1 where we learn the parameters of the Gaussian instance weighting function.
Revised: Finally, we see a signiﬁcant boost in performance for GP1T1 where we learn the parameters of the Gaussian instance weighting function.

Original: The whole idea of attention (weather it is feature attention or instance weighting) is to make use of relative comparisons.
Revised: The whole idea of attention (weather it is feature attention or instance weighting) is to make use of relative comparisons.

Original: Instances that comparatively important are highly weighted to obtain attention weights or instance weights.
Revised: Instances that comparatively important are highly weighted to obtain attention weights or instance weights.

Original: Softmax-based methods (such as ATT and WSDN) and the Gaussian-based method such as GP0T1 make local comparisons (i.e comparisons within a bag) to ﬁnd important instances.
Revised: Softmax-based methods (such as ATT and WSDN) and the Gaussian-based method such as GP0T1 make local comparisons (i.e comparisons within a bag) to ﬁnd important instances.

Original: Interestingly, all of them obtain somewhat comparable results.
Revised: Interestingly, all of them obtain somewhat comparable results.

Original: However, GP1T1 learns the Gaussian parameters using back-propagation and speciﬁc to the dataset statistics.
Revised: However, GP1T1 learns the Gaussian parameters using back-propagation and speciﬁc to the dataset statistics.

Original: Therefore, the instance comparisons are not local to the bag, but learned globally across the dataset.
Revised: Therefore, the instance comparisons are not local to the bag, but learned globally across the dataset.

Original: Perhaps this also enforces a regularization effect on the instance representation by making positive instances to form cluster (s) with respect to the instance weighting function.
Revised: Perhaps this also enforces a regularization effect on the instance representation by making positive instances to form cluster (s) with respect to the instance weighting function.

Original: Therefore, we conclude that parametric two-stream-based Gaussian instance weighting is a better strategy for multiple instance learning.
Revised: Therefore, we conclude that parametric two-stream-based Gaussian instance weighting is a better strategy for multiple instance learning.

Original: Due to it’s effectiveness, we use GP1T1 variant of our method in all other experiments.
Revised: Due to it’s effectiveness, we use GP1T1 variant of our method in all other experiments.

Original: Now we evaluate the instance detection capacity of each model using MNIST-bags dataset [8].
Revised: Now we evaluate the instance detection capacity of each model using MNIST-bags dataset [10].

Original: Speciﬁcally, the instance score is obtained by the product of instance weighting and instance classiﬁer in eq.
Revised: Speciﬁcally, the instance score is obtained by the product of instance weighting and instance classiﬁer in eq.

Original: (2), i.e., β ( x k ; θ β ) · f ( x k ) .
Revised: (2), i.e., β ( x k ; θ β ) · f ( x k ) .

Original: We use similar strategy for WSDN and ATT methods.
Revised: We use similar strategy for WSDN and ATT methods.

Original: For
Revised: For

Original: ATT [8], as done in that paper, we take the output of the attention module (attention weights returned by Softmax function) as the instance score.
Revised: ATT [10], as done in that paper, we take the output of the attention module (attention weights returned by Softmax function) as the instance score.

Original: Thereafter, by changing the mean length of the bag to 10, 20 and 30, we report the instance detection performance in average precision in table 2.
Revised: Thereafter, by changing the mean length of the bag to 10, 20 and 30, we report the instance detection performance in average precision in table 2.

Original: Average precision is used because it is widely used for other detection tasks (e.g. object detection).
Revised: Average precision is used because it is widely used for other detection tasks (e.g. object detection).

Original: We also report bag classiﬁcation performance in error rate as before.
Revised: We also report bag classiﬁcation performance in error rate as before.

Original: As it can be seen, our method obtains better instance detection performance than ATT and WSDN for two different bag lengths.
Revised: As it can be seen, our method obtains better instance detection performance than ATT and WSDN for two different bag lengths.

Original: Interestingly, when the bag length is 10, our method is quite accurate obtaining average precision of 0.931 while the second best WSDN obtains only 0.788.
Revised: Interestingly, when the bag length is 10, our method is quite accurate obtaining average precision of 0.931 while the second best WSDN obtains only 0.788.

Original: When mean bag length is increased to 20, our method still obtains slightly better instance detection performance than both ATT and WSDN.
Revised: When mean bag length is increased to 20, our method still obtains slightly better instance detection performance than both ATT and WSDN.

Original: Interestingly, WSDN outperforms both ATT and GP1T1 for instance detection when mean bag-size is 30.
Revised: Interestingly, WSDN outperforms both ATT and GP1T1 for instance detection when mean bag-size is 30.

Original: Even then, the bag classiﬁcation of GP1T1 is better than ATT and WSDN.
Revised: Even then, the bag classiﬁcation of GP1T1 is better than ATT and WSDN.

Original: Originally, WSDN is designed for object detection and has the capability to ignore most negative instances and pick only the relevant handful of positives.
Revised: Originally, WSDN is designed for object detection and has the capability to ignore most negative instances and pick only the relevant handful of positives.

Original: Therefore, when there are only a few number of positives, the WSDN is able to pick those using Softmax.
Revised: Therefore, when there are only a few number of positives, the WSDN is able to pick those using Softmax.

Original: In contrast, GP1T1 has the capacity to detect more positive instances than Softmax-based WSDN.
Revised: In contrast, GP1T1 has the capacity to detect more positive instances than Softmax-based WSDN.

Original: Therefore, GP1T1 has the capacity to obtain better
Revised: Therefore, GP1T1 has the capacity to obtain better

Original: MIL recognition performance as we will see next.
Revised: MIL recognition performance as we will see next.

Original:  Now, we evaluate on ﬁve historically important binary MIL benchmarks, MUSK 1-2 [6], Fox, Tiger and Elephant image datasets [1].
Revised: [Table] Now, we evaluate on ﬁve historically important binary MIL benchmarks, MUSK 1-2 [7], Fox, Tiger and Elephant image datasets [1].

Original: All ﬁve datasets provide only precomputed features and small number of bags.
Revised: All ﬁve datasets provide only precomputed features and small number of bags.

Original: MUSK1 and MUSK2 datasets present a real-world problem in drug activity analysis.
Revised: MUSK1 and MUSK2 datasets present a real-world problem in drug activity analysis.

Original: The goal is to predict activity of new molecules without requiring expensive process of synthesizing the most promising candidate molecules which can yield large economical savings.
Revised: The goal is to predict activity of new molecules without requiring expensive process of synthesizing the most promising candidate molecules which can yield large economical savings.

Original: Both MUSK and MUSK2, consist of descriptions of molecules using multiple low-energy conformations.
Revised: Both MUSK and MUSK2, consist of descriptions of molecules using multiple low-energy conformations.

Original: Each conformation is represented by a 166-dimensional feature vector derived from surface properties.
Revised: Each conformation is represented by a 166-dimensional feature vector derived from surface properties.

Original: MUSK1 contains on average approximately 6 conformation per molecule, while MUSK2 has on average more than 60 conformations in each bag [1].
Revised: MUSK1 contains on average approximately 6 conformation per molecule, while MUSK2 has on average more than 60 conformations in each bag [1].

Original: The goal is to learn to predict whether new molecules will be musks or non-musks.

Original: If any of conformations is classiﬁed as a musk, then the

Original: [Table]

Original: [Table]

Original: better than entire molecule is musk.

Original: Fox, Tiger and Elephant datasets contain features computed over image segments by using region descriptors.
Revised: Fox, Tiger and Elephant datasets contain features computed over image segments by using region descriptors.

Original: Each positive bag consists at least one patch from the target animal category.
Revised: Each positive bag consists at least one patch from the target animal category.

Original: Negative ones consists patches from other animals.
Revised: Negative ones consists patches from other animals.

Original: Feature dimensions arefor MUSK1 and MUSK2 and 230 for the remaining three.
Revised: Feature dimensions are 166 for MUSK1 and MUSK2 and 230 for the remaining three.

Original: The standard performance measure is average classiﬁcation accuracies (and their standard deviation) over ﬁve ten-fold validation runs.
Revised: The standard performance measure is average classiﬁcation accuracies (and their standard deviation) over ﬁve ten-fold validation runs.

Original: We follow the experimental setting in [8, 14] and use the same architecture (3 fully connected layers with 256, 128 and 64 dimensions, ReLU) as the feature extractor ψ and use SGD optimizer with batch size 1 as in [8].
Revised: We follow the experimental setting in [10, 16] and use the same architecture (3 fully connected layers with 256, 128 and 64 dimensions, ReLU) as the feature extractor ψ and use SGD optimizer with batch size 1 as in [10].

Original: We use exactly the same hyper parameters used in prior work [8, 14].
Revised: We use exactly the same hyper parameters used in prior work [10, 16].

Original: Results are reported in table 3.
Revised: Results are reported in table 3.

Original: Interestingly, our method is able to outperform some of the traditional as well as recent deep learning methods on three datasets, MUSK1, MUSK2 and more challenging Fox dataset.
Revised: Interestingly, our method is able to outperform some of the traditional as well as recent deep learning methods on three datasets, MUSK1, MUSK2 and more challenging Fox dataset.

Original: The results show that our GP1T1 variant with learnable Gaussian parameters with a two stream architecture is extremely effective even for traditional multiple instance learning tasks.
Revised: The results show that our GP1T1 variant with learnable Gaussian parameters with a two stream architecture is extremely effective even for traditional multiple instance learning tasks.

Original: Most interestingly, our method outperforms both ATT and WSDN in most cases.
Revised: Most interestingly, our method outperforms both ATT and WSDN in most cases.

Original: So far, we use the log-sum-exponent [13] as the aggregation function ρ in eq.
Revised: So far, we use the log-sum-exponent [15] as the aggregation function ρ in eq.

Original: Here we investigate the classiﬁcation performance of various pooling operators ρ () in eq.
Revised: Here we investigate the classiﬁcation performance of various pooling operators ρ () in eq.

Original: (2) and report results in table 4.
Revised: (2) and report results in table 4.

Original: Interestingly, mean pooling is as effective as the log-sum-exponent on these traditional datasets.
Revised: Interestingly, mean pooling is as effective as the log-sum-exponent on these traditional datasets.

Original: Our method is able to obtain quite good results on four datasets irrespective of the pooling operator except for Elephant dataset.
Revised: Our method is able to obtain quite good results on four datasets irrespective of the pooling operator except for Elephant dataset.

Original: Max operator seems the least effective one, perhaps due to lack of gradient information.
Revised: Max operator seems the least effective one, perhaps due to lack of gradient information.

Original: We believe that log-sum-exponent is theoretically more relevant for MIL and therefore we recommend using that even the mean pooling seems to obtain better results on this dataset.
Revised: We believe that log-sum-exponent is theoretically more relevant for MIL and therefore we recommend using that even the mean pooling seems to obtain better results on this dataset.

Original: So far we have demonstrated the effectiveness of our method on binary multiple instance learning problem for end-to-end learning (tables 1 and 2) and non-end-to-end learning (tablesand 4).
Revised: So far we have demonstrated the effectiveness of our method on binary multiple instance learning problem for end-to-end learning (tables 1 and 2) and non-end-to-end learning (tablesand 4).

Original: 3. R ESULTS FOR MULTI - CLASS CLASSIFICATION
Revised: 3. R ESULTS FOR MULTI - CLASS CLASSIFICATION

Original: Here we introduce a new dataset that contains raw input (in contrast to precomputed ones in the previous experiments) and also multiple categories.
Revised: Here we introduce a new dataset that contains raw input (in contrast to precomputed ones in the previous experiments) and also multiple categories.

Original: To evaluate our method in multi-class classiﬁcation  task, we create a new multiple-class MIL dataset from CIFAR-10 dataset [9] and call it CIFAR-10- MIL dataset .
Revised: To evaluate our method in multi-class classiﬁcation [Table] task, we create a new multiple-class MIL dataset from CIFAR-10 dataset [11] and call it CIFAR-10MIL dataset .

Original: We treat six natural object classes (“bird”, “cat”, “deer”, “dog”, “frog”, “horse”) as positive instances and rest of the object categories as negatives.
Revised: We treat six natural object classes (“bird”, “cat”, “deer”, “dog”, “frog”, “horse”) as positive instances and rest of the object categories as negatives.

Original: Each bag contains multiple negative instances from four negative classes (“automobile”, “truck”, “ship”, “air-plane”) while positive instances comes from a single positive class.
Revised: Each bag contains multiple negative instances from four negative classes (“automobile”, “truck”, “ship”, “air-plane”) while positive instances comes from a single positive class.

Original: We generate 30,000 and 6,000 bags for training and evaluation respectively.
Revised: We generate 30,000 and 6,000 bags for training and evaluation respectively.

Original: We will release the code for generating CIFAR-10-MIL dataset along with all other codes used for experimentation.
Revised: We will release the code for generating CIFAR-10-MIL dataset along with all other codes used for experimentation.

Original: An example bag is depicted in ﬁg. 2.
Revised: An example bag is depicted in ﬁg. 2.

Original: The objective is to predict the bag labels accurately.
Revised: The objective is to predict the bag labels accurately.

Original: [Figure]
Revised: [Figure]

Original: Bag generation procedure involves three parameters: bag size, minimum and maximum number of positive instances in a bag.
Revised: Bag generation procedure involves three parameters: bag size, minimum and maximum number of positive instances in a bag.

Original: This dataset allows us to change the ratio of positive/negative instances in bags by varying them and study the effect of “ambiguity”.
Revised: This dataset allows us to change the ratio of positive/negative instances in bags by varying them and study the effect of ambiguity in this task.

Original: For instance, in case of a bag of size 100 with maximum of 5 positive instances and a minimum of 1, the ambiguity varies from 95% to 99%.
Revised: For instance, in case of a bag of size 100 with maximum of 5 positive instances and a minimum of 1, the ambiguity could vary from 95% to 99%.

Original: Thus controlling the positive/negative ratio allows us to evaluate how MIL algorithms deals with certain amount of ambiguity levels within the bag.
Revised: Thus controlling the positive/negative ratio allows us to evaluate how MIL algorithms deals with certain amount of ambiguity levels within the bag.

Original: In all these experiments, we build our model on LeNet5 model [10] and use it as the feature extractor which outputs 84 dimensional feature vector for each image (instance) within the bag.
Revised: In all these experiments, we build our model on LeNet5 model [12] and use it as the feature extractor which outputs 84 dimensional feature vector for each image (instance) within the bag.

Revised: We train all the reported models end-to-end by using stochastic gradient descent with a training batch size of 128 bags 1 .

Revised: The learning rate is set to 0.1 for 150 epochs and lowered to 0.

Revised: and 0.001 after 50 epochs at each time.

Original: In the ﬁrst experiment, we use a ﬁxed bag size of 50, sample exactly N number of positive instances for each bag and vary N from 2 to 10.
Revised: In the ﬁrst experiment, we use a ﬁxed bag size of 50, sample exactly N number of positive instances for each bag and vary it from 2 to 10.

Original: In other words, we vary the amount of ambiguity in the bags used for training.
Revised: In other words, we vary the amount of ambiguity in the bags used for training.

Original: We compare our method (GP1T1) to the recent state-of-the art method ATT [8].
Revised: We compare our method (GP1T1) to the recent state-of-the art method ATT [10].

Original: Note that we use same bag size for both train and test in this experiment.
Revised: Note that we use same bag size for both train and test in this experiment.

Original: Results are depicted at multiple N values in ﬁg. 3.
Revised: Results are depicted at multiple N values in ﬁg. 3.

Original: Both methods perform better in bag classiﬁcation as the number of positives increases and ambiguity decreases.
Revised: Both methods perform better in bag classiﬁcation as the number of positives increases and ambiguity decreases.

Original: Interestingly, both methods fail to learn in the presence of extreme ambiguous level of 96% (only 2 positive instances in a bag of size 50).
Revised: Interestingly, both methods fail to learn in the presence of extreme ambiguous level of 96% (only 2 positive instances in a bag of size 50).

Original: Both methods recover (learn), when the ambiguous level is reduced to 92%.
Revised: Both methods recover (learn), when the ambiguous level is reduced to 92%.

Original: GP1T1 method outperforms ATT for all ambiguous levels indicating that GP1T1 is better than ATT even for multiple class multiple instance learning. 
Revised: GP1T1 method outperforms ATT for all ambiguous levels indicating that GP1T1 is better than ATT even for multiple class multiple instance learning. [Figure]

Original: 3. R OBUSTNESS OF END - TO - END LEARNED MIL METHODS .
Revised: 3. R OBUSTNESS OF END - TO - END LEARNED MIL METHODS .

Original: In this section, we further study the robustness characteristics of the presented methods when the ambiguity levels in train and test bags differ.
Revised: In this section [Figure] we further study the robustness characteristics of the presented methods when the ambiguity levels in train and test bags differ.

Original: To this end, we ﬁrst train each method with ﬁxed size bags, each containing 1 to 10 positives and then evaluate them on varying bag sizes, each containing only 1 positive.
Revised: To this end, we ﬁrst train each method with ﬁxed size bags, each containing 1 to 10 positives and then evaluate them on varying bag sizes, each containing only 1 positive.

Original: The average classiﬁcation accuracies of the models are depicted in ﬁg. 4.
Revised: The average classiﬁcation accuracies of the models are depicted in ﬁg. 4.

Original: In each subplot (a)-(e) we ﬁx the training bag size to a certain number (10, 20, 30, 40, 50) and depict the performance of each method for varying test bag sizes (10, 50, 100, 200, · · · , 500).
Revised: In each subplot (a)-(e) we ﬁx the training bag size to a certain number (10, 20, 30, 40, 50) and depict the performance of each method for varying test bag sizes.

Original: In ﬁg. 4.(f)
Revised: In ﬁg. 4.(f)

Original: we ﬁx the test bag size to 100 and show the results for the models that are trained with different bag sizes.
Revised: we ﬁx the test bag size toand show the results for the models that are trained with different bag sizes.

Original: Based on the results, we expect to answer the following ﬁrst two questions.
Revised: Based on the results, we expect to answer the following ﬁrst two questions.

Original: (i) How robust are the presented MIL methods against extremely ambiguous test 
Revised: How robust are the presented MIL methods against extremely ambiguous test bags?

Original: bags As we can see from ﬁg. 4.(a)-(e), our GP1T1 method consistently outperform ATT method across various train and test bag sizes.
Revised: As we can see from ﬁg. 4.(a)-(e), our GP1T1 method consistently outperform ATT method across various train and test bag sizes.

Original: Interestingly, when the train bag size is 10, both methods perform equally.
Revised: Interestingly, when the train bag size is 10, both methods perform equally.

Original: Nevertheless, when the train bag size increases, our method performs better than ATT indicating that it learns better  under  ambiguous bags.
Revised: Nevertheless, when the train bag size increases, our method stats to perform better than ATT indicating that ours can better learn under more ambiguous bags.

Original: However, both methods perform poorly as the test bag size (and ambiguity) increases.
Revised: However, both methods perform poorly as the test bag size (and ambiguity) increases.

Original: In particular when the models are ﬁrst trained on less ambiguous bags such as bag size of 10 ﬁg. 4.(a), even though the performance for test bag of size[Figure] 10 is quite good, the performance of a test bag size of 500 is very poor ( 20%).
Revised: In particular when the models are ﬁrst trained on less ambiguous bags such as bag size of 10 ﬁg. 4.(a), even though the performance for test bag of size 10 is quite good, the performance of a test bag size of 500 is very poor ( 20%).

Original: However, when the models are trained with even more ambiguous bags (ﬁg. 4 (e)), they perform better for larger test bags (e.g. 500) where the performance is around 30% for GP1T1.
Revised: However, when the models are trained with even more ambiguous bags (ﬁg. 4 (e)), they perform better for larger test bags (e.g. 500) where the performance is around 30% for GP1T1.

Original: Interestingly, our models are better than the attention based models when tested with very large bags with more ambiguous bags.
Revised: Interestingly, our models are better than the attention based models when tested with very large bags with more ambiguous bags.

Original: This indicates the robustness of our methods to varying amount of ambiguity (see ﬁg. 4 (e)). 
Revised: This indicates the robustness of our methods to varying amount of ambiguity (see ﬁg. 4 (e)). ii) How transferable

Original: (ii) How transferable are the MIL models with respect to change in ambiguity levels?
Revised: are the MIL models with respect to change in ambiguity levels

Original: Here we analyze the limits of training bag ambiguity that the MIL model can handle reasonably.
Revised: Here we analyze the limits of training bag ambiguity that the MIL model can handle reasonably.

Original: The results for the study are depicted in ﬁg. 4.(f).
Revised: The results for the study are depicted in ﬁg. 4.(f).

Original: First we observe that all the models beneﬁt from increase in the ambiguity level up to bag size of 40 and then the performance of ATT [8] degrades.
Revised: First we observe that all the models beneﬁt from increase in the ambiguity level up to bag size of 40 and then the performance of ATT [10] degrades.

Original: However, our model GP1T1 retains its performance.
Revised: However, our model GP1T1 retains its performance.

Original: Here we hypothesize that the models which can learn instance weighting accurately are more robust to changes in ambiguity ratios.
Revised: Here we hypothesize that the models which can learn instance weighting accurately are more robust to changes in ambiguity ratios.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: Our deep MIL method uses a  two stream method for instance weighting and classiﬁcation to compute the bag prediction score.
Revised: Our deep MIL method uses a novel two stream method for instance weighting and classiﬁcation to compute the bag prediction score.

Original: We evaluate our method in both binary and multi-class classiﬁcation tasks in several standard MIL benchmarks and obtain excellent results for both.
Revised: We evaluate our method in both binary and multi-class classiﬁcation tasks in several standard MIL benchmarks and obtain excellent results for both.

Original: We show thatin the presence of extreme ambiguity in training bags, the performance of the MIL methods are severely affected.
Revised: We show that presence of extreme ambiguity in training bags (low positive/negative instance ratio) hurts the performance of the MIL methods severely.

Revised: However, we also demonstrate that when the MIL methods are successfully trained with bags containing moderate ambiguity, most methods would also be able to correctly classify bags even in case of extreme ambiguity.

Original: Our method which uses a Gaussian function with dedicated learnable parameters, is able to outperform other methods under extreme presence of ambiguity while obtaining better results on traditional MIL datasets such as MUSK.
Revised: Our method which uses a Gaussian function with dedicated learnable parameters, is able to outperform other methods under extreme presence of ambiguity while obtaining better results on traditional MIL datasets such as MUSK.

Original: Interestingly, in most cases, our method can also obtain good instance detection results.
Revised: Interestingly, in most cases, our method can also obtain good instance detection results

Revised: A A PPENDIX A. L ARGE SCALE UNTRIMMED VIDEO CLASSIFICATION WITH MIL.

Original: Most related methods use Softmax function to obtain attention weights which only accounts for local caparisons (i.e. within bag comparisons).
Revised: In this section we perform a very large scale untrimmed video action classiﬁcation using four MIL approaches and show that 1. MIL in general is useful even for a large scale video classiﬁcation problem 2. our method still outperforms other competitors on this task. We select ActivityNet 1.

Original: In contrast ours is able to make global comparisons across bags and obtain weighting scores (attention scores) using
Revised: video dataset which consists of 10,000 video for training and about 5000 videos for validation [8]. We consider 32 frame video clip as an instance and the entire video as the bag.

Original: Gaussian based comparisons.
Revised: A video in ActivityNet1.3 may have one or more human actions. Our objective is to recognize the presence and absence of each action category in each video.

Original: Results suggests that this mechanism with two-stream architecture is more effective for multiple instance learning.
Revised: Therefore, the performance is measured using mean average precision. We train all methods using I3D network as the feature extractor [5].

Original: A
Revised: We use batch size of 64 videos and Adam optimizer with learning rate of 0.0005. We use a weight decay of 10 e − 5 . All models are trained with binary cross entropy loss. We report results in Table 5.

Original: [Equation]
Revised: [Table]

Original: A. A RE THE INSTANCE WEIGHTS MEANINGFUL ?
Revised: A. A RE THE INSTANCE WEIGHTS MEANINGFUL ?

Original: Here we provide some experimental results for instance detection weights using Cifar10-MIL dataset.
Revised: Here we provide some experimental results for instance detection weights using Cifar10-MIL dataset.

Original: We empirically verify that positive instances are weighted higher than the negative ones by β .
Revised: We empirically verify that positive instances are weighted higher than the negative ones by β .

Original: For GP1T1 method positive vs negative weights returned by β are 0.94 ± 0.11 vs. 0.
Revised: For GP1T1 method positive vs negative weights returned by β are 0.94 ± 0.11 vs. 0.

Original: ± 0.10 respectively.
Revised: ± 0.10 respectively.

Original: We conclude, our method learns meaningful weights for instances and can robustly detect positive instances under different test distributions from the results shown in table 2.
Revised: We conclude, our method learns meaningful weights for instances and can robustly detect positive instances under different test distributions from the results shown in table 2.