Title: DETECTING MEMORIZATION IN RELU NETWORKS

Abstract: We propose a new notion of 'non-linearity' of a network layer with respect to an input batch that is based on its proximity to a linear system, which is reflected in the non-negative rank of the activation matrix. We measure this non-linearity by applying non-negative factorization to the activation matrix. Considering batches of similar samples, we find that high non-linearity in deep layers is indicative of memorization. Furthermore, by applying our approach layer-by-layer, we find that the mechanism for memorization consists of distinct phases. We perform experiments on fully-connected and convolutional neural networks trained on several image and audio datasets. Our results demonstrate that as an indicator for memorization, our technique can be used to perform early stopping.

1. INTRODUCTION:

A fundamental challenge in machine learning is balancing the bias-variance tradeoff, where overly simple learning models underfit the data (suboptimal performance on the training data) and overly complex models are expected to overfit or memorize the data (perfect training set performance, but suboptimal test set performance). The latter direction of this tradeoff has come into question with the observation that deep neural networks do not memorize their training data despite having sufficient capacity to do so (Zhang et al., 2016) , the explanation of which is a matter of much interest.

Due to their convenient gradient properties and excellent performance in practice, rectified-linear units (ReLU) have been widely adopted and are now ubiquitous in the field of deep learning. In addition, the relative simplicity of this function (max(•, 0)) makes the analysis of ReLU networks more straight-forward than networks with other activation functions.

We propose a new notion of 'non-linearity' of a ReLU layer with respect to an input batch. We show that networks that generalize well have deep layers that are approximately linear with respect to batches of similar inputs. In contrast, networks that memorize their training data are highly nonlinear with respect to similar inputs, even in deep layers.

Our method is based on the fact that the main source of non-linearity in ReLU networks is the threshold at zero. This thresholding determines the support of the resulting activation matrix, which plays an important role in the analysis of non-negative matrices. As we discuss in Section 3, the non-negative rank of a matrix is constrained by the shape of the support, and is therefore indicative of the degree of non-linearity in a ReLU activation matrix with respect to the input.

Although computing the non-negative rank is NP-hard (Vavasis, 2009) , we can restrict it with approximate non-negative matrix factorization (NMF) (Lee & Seung, 1999) . Consequently, we propose to estimate the 'non-linearity' of a ReLU layer with respect to an input batch by performing NMF on a grid over the approximation rank k, and measuring the impact on network performance. This procedure can be seen as measuring the robustness of a neural network to increasing compression of its activations. We therefore compare our NMF-based approach to two additional dimensionality reduction techniques, namely principal component analysis (PCA) and random ablations.

We informally define memorization as the implicit learning of a rule that associates a specific sample (i.e., with index i) to a particular label (e.g., with index j). Such a rule does not benefit the network in terms of improving its performance on new data.

We show that our NMF-based approach is extremely sensitive to memorization in neural networks. We report results for a variety of neural network architectures trained on several image and audio datasets. We conduct a layer-by-layer analysis and our results reveal interesting details on the internal mechanism of memorization in neural networks. Finally, as an indicator for memorization, we use our proposed measure to perform early stopping.

2. RELATED WORK:

The study of factors involved in the bias-variance tradeoff in learning models goes back several decades. Classical results in statistical learning consider properties of learning models such as the VC-dimension (Vapnik, 1998) and Rademacher complexity (Bartlett & Mendelson, 2002) . These properties give generalization bounds in terms of the capacity model to (over)fit data. When considering the vast capacity of deep neural networks, such bounds become irrelevant and fail to explain their ability to generalize well in practice (Zhang et al., 2016; Bartlett et al., 2017) .

More direct analyses have been done with respect to a specific setting of model parameters. For instance, Bartlett (1998) showed that the number of weights in a network is less important compared to their scalar value (e.g. 2 -norm), and more recently Bartlett et al. (2017) presented a bound for deep neural networks based on the product of spectral norms of the network's weight matrices. Achille & Soatto (2017) showed that memorizing networks contain more information in their weights.

Methods to explain generalization have been proposed that examine a network's robustness to perturbations (Hochreiter & Schmidhuber, 1997; Chaudhari et al., 2016; Keskar et al., 2016; Neyshabur et al., 2017; Li et al., 2017) . These methods propose the notion of flatness of minima on the loss surface, assuming that perturbing the parameters without dramatically changing performance is an indicator of the generalization of a network. However, any reversible transformation, such as simple scaling, can arbitrarily manipulate the local flatness without affecting generalization (Dinh et al., 2017) . The procedure we propose can be viewed as applying perturbations, albeit to activations and not parameters, and must address this concern. The perturbations we apply to activations account for magnitude, since they depend on a change of rank or non-negative rank of the activation matrix, a property which is robust to rescaling and similar reversible transformations.

In contrast to the methods described thus far, which deal exclusively with the parameters of the model, methods have been developed that account for the role of the data distribution. Liang et al. (2017) proposed to use the Fisher-Rao norm, which uses the geometry of the data distribution to weigh the contribution of different model parameters. The empirical studies of Morcos et al. (2018) and Novak et al. (2018) explore robustness to specific types of noise. The former uses Gaussian noise and masking noise injected into hidden activations, while the latter interpolates between input samples to study network behavior on and off the data manifold. In both cases, robustness to noise proved a reliable indicator for good generalization. Additionally, Arora et al. (2018) derive generalization bounds in terms of robustness to noise.

Our experimental setup is reminiscent of Morcos et al. (2018) in that both methods apply a form of compression to hidden activations and test for robustness to this type of noise. Specifically, they set random axis-aligned directions in feature space to zero which can be viewed as a crude form of dimensionality reduction, i.e., by simply removing canonical dimensions. In our experiments we refer to this method as random ablations. Our results show that robustness to NMF compression is much more correlated with low memorization/high generalization than robustness to random ablations. Arpit et al. (2017) have also studied various empirical aspect of memorization.

As a dimensionality reduction technique, NMF has gained popularity due to its producing meaningful factorizations that lend themselves to qualitative interpretation across various domains such as document clustering (Xu et al., 2003) , audio source separation (Grais & Erdogan, 2011) , and face recognition (Guillamet & Vitria, 2002) . In the context of deep convolutional neural networks, Collins et al. (2018) applied NMF to the activations of an image classifier and showed that the result gives a decomposition into semantic parts, which benefits from the transformation invariance learned by the neural network. the rows of the support are identical, there is a sub-weight-matrix such that the layer is fully linear with respect to the input batch. (b, c) As the support becomes more complex, which we characterize by the increase in its rectangle cover number, the layer becomes more non-linear.

3. METHOD:

Consider a ReLU layer of a neural network, parameterized by a weight matrix W ∈ R m×q . For a batch of n inputs X ∈ R n×m , we compute the layer activation matrix A as follows:

EQUATION

where R + are the non-negative reals. We omit the bias term for notational convenience.

3.1. RELU-INDUCED SUPPORT:

The processing of a single input x by a ReLU network is equivalent to sampling a sub-network that is linear with respect to the sample (Wang et al., 2016) . This could be accomplished by simply setting to zero the columns of each W whose dot product with the input is negative (and would thus be set to zero by ReLU), and then removing the thresholding.1 

Extending this notion to a batch of several input samples to a ReLU layer, suppose the samples are sufficiently close to each other such that they all share the same ReLU mask m ∈ {0, 1} q . In this case, we may say that the layer is linear with respect to its input batch. This is because, for the entire batch, instead of using ReLU, we could zero out a subset of columns and obtain a linear system, i.e., A = XW diag(m).

For an activation matrix A (Equation 1), we consider the support M = supp(A), which we describe as a binary 0/1 matrix where M i,j = 1 where A i,j > 0. Because A is a ReLU activation matrix, the structure of M is mainly determined by the thresholding at zero. 2 Because thresholding is the main source of non-linearity in a ReLU network, the support takes on a special meaning in this case.

3.2. RECTANGLE COVER NUMBER AND NON-NEGATIVE RANK:

We want to characterize how close to being linear a layer is with respect to its input X by examining the support of the resulting activations M . If all the rows of M are identical to a unique vector m, we can say the layer is completely linear with respect to X. In general, the 'simpler' the support M , the closer to linearity the layer.

One measure that captures this idea is the rectangle cover number of a matrix, rc(M ), an important quantity in the study of communication complexity (Klauck, 2003) . Also known as the Boolean rank, rc(M ) is the smallest number r for which there exist binary matrices U B ∈ {0, 1} n×r , V B ∈ {0, 1} r×q such that their Boolean matrix multiplication satisfies M = U B V B . As a complexity measure for ReLU activations, rc(M ) = 1 means the layer is linear with respect to its input, and higher values rc(M ) imply increasing non-linearity. This is visualized in Figure 1 .

Intuitively, imagine having to fit a layer with 'ReLU switches', each of which controls a subset of weight matrix columns. In the linear case, one switch would suffice to describe the data. In the most non-linear case, we would require a switch for every column, which is also the maximal value of rc(M ).

Because computing the rectangle cover number rc(M ) is complex, several approximations and bounds to it have been studied (Fiorini et al., 2013) . For the support of a non-negative matrix, a well-known upper-bound is:

EQUATION

where rank + (A) is the non-negative rank of A (Gillis & Glineur, 2012) that is defined as the smallest number k such that there exist non-negative matrices

U + ∈ R n×k + , V + ∈ R k×q + such that A = U + V + .

Similar to the rectangle cover number, the non-negative rank is hard-constrained by the combinatorial arrangement of supp(A), but additionally accounts for the actual value in the non-zero entries of A.

While computing rank + (A) is not easier than computing rc(supp(A)), we can restrict it by performing approximate non-negative matrix factorization (NMF).

3.3. NON-NEGATIVE MATRIX FACTORIZATION:

For a given non-negative rank constraint k, NMF solves for:

EQUATION

with U + , V + as defined above. The result U + V + = Ãk ≈ A is the closest matrix to A under the Frobenius norm that has rank + at most k.

Consequently, we propose to estimate the 'linearity' of a ReLU layer with respect to a batch of similar inputs by performing NMF on a grid over the non-negative rank k, and measuring the impact on network performance by observing the change in the prediction (output layer) as we change k. This procedure also addresses the fact that in practice network activations tend to be noisy, whereas supp(A) is not robust to noise, i.e., A i,j = > 0 → M i,j = 1 even for very small .

Concretely, if we let A i be the activation matrix at layer i, during the forward pass, we replace the feature activations of one or several layers with their rank k NMF approximations:

EQUATION

For convolutional networks, we first reshape the tensor of feature maps from n × q × h × w to (n • h • w) × q, i.e., we flatten the batch (n) and spatial dimensions (h, w) to form a matrix with q columns, where q is the number of channels in that layer. We then inversely reshape the approximated features to continue forward propagation through the network.

3.4. SINGLE CLASS BATCHES:

We now characterize the input batch, with respect to which we would like to measure layer linearity.

Informally, the goal of training is to cluster together input samples that have similar (or identical) output labels,while separating them from samples of other labels. In the context of classification then, we expect therefore that from a certain depth and onward, samples of the same class will have similar activations, and thus a simpler support. In other words, while a network may exploit flexible non-linear structure to separate different classes, we expect that with respect to a single class, deep layers are approximately linear. We analyze each layer by applying NMF compression to its activation matrix with increasing rank k, while observing the impact on classification performance. In (a) and (b) we show the k vs. accuracy curves at an layers of different depth. We can immediately see that in deep layers, networks with high memorization are significantly less robust to NMF compression, indicating higher degrees of non-linearity. Furthermore, networks trained on fully randomized labels (p = 1) behave differently than networks with partial or no randomization. By summarizing each curve in (a) and (b) by its area under the curve (AuC), we show in (c) a birds-eye view over all layers. All networks with p < 1 pass through distinct phases consisting of a feature extraction phase until conv3_1, followed by a memorization phase until conv4_2, followed by a final clustering phase. Interestingly, the case p = 1 shifts the process into earlier layers, explaining why layer-by-layer it appears as an outlier.

When single-class batches are not approximately linear even in deep layers, i.e., activations are not clustered within a few linear regions, we empirically show in the next section that this behavior is indicative of memorization.

4. EXPERIMENTS:



4.1. FEATURE COMPRESSION AND MEMORIZATION:

We start by studying networks that have been forced into different levels of memorization due to label randomization applied to their training set (Zhang et al., 2016) . The level of induced memorization is controlled by setting a probability p for a training label to be randomized, i.e., p = 0 is the unmodified dataset and p = 1 gives fully random labels. Note that the capacity of these networks is sufficiently large such that the training accuracy is 1 in all cases, regardless of the value of p.

As such, we use batches of training data and observe how accuracy drop from 1 to constant prediction as we increase the level of compression. In all experiments, sampling single-class batches is done with respect to the label used for training (i.e., the random label if p > 0). We sample batches stochastically (up to the label), have found all methods discussed below to be robust to the batch size (e.g., 20-100). In all our experiments we set the batch size to 50.

We perform experimental evaluations on several image datasets, namely CIFAR-10 ( Krizhevsky & Hinton, 2009) , Fashion-MNIST (Xiao et al., 2017) , SVHN (Netzer et al., 2011), and ImageNet (Russakovsky et al., 2015) , as well as on the Urban Sounds audio classification dataset (Salamon et al., 2014) . We use a fully-connected network for Fashion-MNIST and various CNN architectures for the others, which we describe in more detail the appendix.

4.1.1. LAYER BY LAYER ANALYSIS:

We start by analyzing the layers of an 11-layer CNN trained on CIFAR-10. We sampled 10 batches (one batch per class) of 50 images, and compressed the activation matrix at each layer individually down to various values of the non-negative rank. We then measured classification accuracy of the prediction. In this analysis we report average results for 60 neural networks, ten networks (with different random initializations) trained per randomization level p.

In Figure 2 (a) and (b) we show k vs. accuracy curves of networks trained with increasing levels of label randomization, at an early layer (conv2_1) and a deep layer (conv4_1) respectively. We can immediately see that networks trained on fully randomized labels (p = 1) behave differently than networks with partial or no randomization. Furthermore, note that in deep layers, memorizing networks are significantly less robust to NMF compression, i.e., their activations posses a high nonnegative rank, which indicates high non-linearity with respect to the input, as discussed in Section 3.2. We can characterize each curve in (a) and (b) with a single number, its area under the curve (AuC). This allows us in Figure 2 (c) to generate a single figure for all layers. Networks with p < 1 display a similar feed-forward trend up until layer conv3_1. Since these networks differ from each other in no way other than the level of label randomization on the training data, we hypothesize this to be a generic feature extraction phase common to all of them. In the next phase, until conv4_2, we see a big difference between networks, such that more memorization (higher p) is correlated with lower AuC, i.e., higher non-negative rank and hence non-linearity of those layers with respect to single-class batches. We therefore localize memorization to these layers. Lastly, the phase only of conv4_3 is where samples of the same class are clustered together, right before the final 10dimensional classification layer (which is not shown). This final phase is in accordance with the premise that regardless of randomization level p, all of these networks achieve perfect training set accuracy. Interestingly, setting p = 1 shifts the process to earlier layers, explaining why layer-bylayer this case appears as an outlier.

4.1.2. COMPRESSION TECHNIQUES:

We compare different compression techniques with regards to detecting memorization. Given our choice of solving NMF under the Frobenius norm (Equation 3), a natural method to compare against is principal component analysis (PCA), which optimizes under the same norm but without the nonnegativity constraint on its factors. We also consider random ablations, i.e., setting a random subset of columns in the activation matrix to zero, since this technique has been used previously to detect memorization (Morcos et al., 2018) .

Rather than choosing a single layer, we sequentially apply compression to several layers. We target the final convolutional blocks of our CNNs, all of which contain three layers, each of which consists of 512 channels. In fully-connected networks, we applied compression to all layers. In Figure 3 we give results for the CIFAR-10 dataset, which confirm that NMF compression is indeed more sensitive to memorization, due to the properties of the non-negative rank discussed in Section 3.2. PCA, which is less constrained, is more 'efficient' at compressing the activations, but is in turn less discriminative with respect to the level of memorization. Finally, we confirm that robustness to random ablations correlates with less memorization, however less so than NMF. It should be noted that NMF does show more variance than the other two methods, and incurs a higher computational cost, as discussed in section 6.6 in the appendix.

In Figure 4 we show additional results for single-class NMF on three additional datasets and network architectures (described in the appendix), including a fully-connected network for Fashion-MNIST.

The results in (d) and (e), of applying PCA and NMF to multi-class batches, show that such batches produce activations with higher rank or non-negative rank compared to single-class batches. This is a result of the network trying to separate samples of different labels.

4.2. FEATURE COMPRESSION AND GENERALIZATION:

We have shown results for networks forced into memorization due to label randomization. In this section we show our technique is useful for predicting good generalization in a more realistic setting, without artificial noise.

In addition to the experiments below, we refer the reader to Section 6. The test loss is (in blue) starts to increase after about the 5th epochs, indicating the start of overfitting. Using our proposed singleclass NMF approach, we can detect the test loss turning point. We show the area under the curve (AuC) for the single-class NMF approach (in green) for the accuracy measures as discussed in Section 4.1.2. Similarly, we show the AuC when performing random ablations (in orange). (c) The NMF AuC curve and test loss curve consistently have near extrema, as seen over several runs.

We trained 96 CNN classifiers on CIFAR-10, over a grid of hyper-parameter values for the batch size, weight decay and optimization algorithm, SGD vs. ADAM (Kingma & Ba, 2015) . Following the same procedure as above, for each of the three methods, NMF, PCA, or random ablations, we computed the k vs. accuracy curves for each network, targeting its final convolutional block. In Figure 5 we compare the area under the curve (AuC) of each curve with the average generalization error on the test set.

While all three methods show correlation with generalization error, NMF is most correlated with a Pearson correlation of -0.82, followed by PCA with -.064 and random ablation with -0.61.

4.2.2. EARLY STOPPING:

We test whether our method can detect memorization during training. Doing so would allow us to perform early stopping, i.e., stop training as memorization begins to decrease generalization.

We trained CNNs on CIFAR-10 with the original labels. Each network was trained for 10K batches with a batch size of 100. We recorded the test set error every 250 batches, and tested the non-linearity of the deepest three convolutional layers using our NMF-based approach with a coarse grid on k.

As before, we compute the area under each k vs. accuracy curve as in Figures 3 (c ). Finally, we also computed the area under the curve produced by random ablations.

Results of two instances are shown in Figure 6 (a) and (b). In these figures we compare the test loss against our single-class NMF method and random ablations. We smooth the plots using a radius of two epochs to reduce the noise. The matching-color dashed lines mark the local minima of the test loss in as well as the location of the first local maxima of the NMF and random ablation AuC curves after smoothing has been applied. We notice that the test loss minima align almost precisely with the maximum NMF AuC. We further confirm this behavior in Figure 6 (c), where we compare the stopping times of NMF and the random ablations method against the best test loss over 10 different runs.

5. CONCLUSION:

We have introduced a notion of a ReLU layer's non-linearity with respect to an input batch, which is based on its proximity to a linear system. We measure this property indirectly via NMF applied to deep activations of single-class batches. While more analysis is required before definite guarantees could be given, we find that our approach is successful in detecting memorization and generalization across a variety of neural network architectures and datasets. NMF and PCA directions are more important for networks with inducedmemorization. Each column shows results for a specific dataset and network architecture. Compared to random ablation as in Figures 3 and 4 , where networks with induced-memorization are most robust, in all cases we see that ablation in NMF and PCA directions hurts their performance more, compared to memorizing networks.

:

This is a similar intuition to that of viewing dropout as an approximation to a model ensemble, where the dropout mask is seen to sample a sub-network(Srivastava et al.,

2014).2 The probability of an activation value being exactly zero prior to thresholding is negligible.

Figures and Tables:

Figure1: The support of the activation matrix is determined by ReLU threshold. (a) When all the rows of the support are identical, there is a sub-weight-matrix such that the layer is fully linear with respect to the input batch. (b, c) As the support becomes more complex, which we characterize by the increase in its rectangle cover number, the layer becomes more non-linear.

Figure2: Memorization mechanism of CNNs trained on CIFAR-10, with increasing level of label randomization p (i.e., p = 0 is the unmodified dataset). We analyze each layer by applying NMF compression to its activation matrix with increasing rank k, while observing the impact on classification performance. In (a) and (b) we show the k vs. accuracy curves at an layers of different depth. We can immediately see that in deep layers, networks with high memorization are significantly less robust to NMF compression, indicating higher degrees of non-linearity. Furthermore, networks trained on fully randomized labels (p = 1) behave differently than networks with partial or no randomization. By summarizing each curve in (a) and (b) by its area under the curve (AuC), we show in (c) a birds-eye view over all layers. All networks with p < 1 pass through distinct phases consisting of a feature extraction phase until conv3_1, followed by a memorization phase until conv4_2, followed by a final clustering phase. Interestingly, the case p = 1 shifts the process into earlier layers, explaining why layer-by-layer it appears as an outlier.

Figure 4: Memorization across various datasets and network architectures. We show that NMF-based compression is sensitive to memorization in diverse settings. Each column shows results for a specific dataset and network architecture. (a, b, d, e) We show that network layers are considerably more linear with respect to single-class batched than with respect to multi-class batches. (b,c,e,f) PCA and random ablations show less sensitivity to memorization compared with NMF.

Figure5: Detecting generalization via compression. While all three methods show correlation with generalization error, NMF is most correlated with a Pearson correlation of -0.82, followed by PCA with -.064 and random ablation with -0.61.

Figure 7:NMF and PCA directions are more important for networks with inducedmemorization. Each column shows results for a specific dataset and network architecture. Compared to random ablation as in Figures3 and 4, where networks with induced-memorization are most robust, in all cases we see that ablation in NMF and PCA directions hurts their performance more, compared to memorizing networks.

Detecting memorization via compression. We demonstrate this on networks trained with different levels of label randomization (p), and hence of memorization. (a) Due to its sensitivity to the non-linearity of ReLU activations, NMF successfully captures the level of memorization present in neural networks. (b) PCA compression is able to regain sufficient variance for good accuracy even with small values of k, which renders it less effective for detecting memorization. (c) Though not taking into account batch statistics, random ablations can distinguish between different levels of memorization, albeit less significantly. Compression was applied to the final three (convolutional) layers of CNNs trained on CIFAR-10.

Table content: <table><tr><td colspan="7">Under review as a conference paper at ICLR 2019</td><td/><td/><td/></tr><tr><td/><td>1.0</td><td/><td/><td>1.0</td><td/><td/><td/><td/><td/><td>1.0</td></tr><tr><td/><td>0.8</td><td/><td/><td>0.8</td><td/><td/><td/><td/><td/><td>0.8</td></tr><tr><td>Accuracy</td><td>0.6 0.2 0.4</td><td>p</td><td>0.0 0.2 0.4 0.6 0.8</td><td>0.6 0.2 0.4</td><td/><td/><td/><td>p</td><td>0.0 0.2 0.4 0.6 0.8</td><td>0.6 0.2 0.4</td><td>p</td><td>0.0 0.2 0.4 0.6 0.8</td></tr><tr><td/><td colspan="4">0 250 500 750 1000 1250 1500</td><td>0</td><td>400</td><td>800</td><td>1200</td><td colspan="2">1600</td><td>0 200 400 600 800 1000 1200 1400 1600</td></tr><tr><td/><td>Non-negative rank k</td><td/><td/><td/><td/><td colspan="2">Rank k</td><td/><td/><td>Rank k</td></tr><tr><td/><td>(a) Single-class NMF</td><td/><td/><td/><td/><td colspan="3">(b) Single-class PCA</td><td/><td>(c) Random Ablations</td></tr><tr><td colspan="2">Figure 3:</td><td/><td/><td/><td/><td/><td/><td/><td/></tr></table>

Peer review (iclr2019):
 This paper propose a new way of analyzing the robustness of neural network layers by measuring the level of "non-linearity" in the activation patterns on samples belonging to the same class, and correlate that to the level of "memorization" and generalization. More specifically, the paper argues that a good representation cluster all the samples in a class together, therefore, in higher layers, the activation pattern of samples from the same class will be almost identical. In this case, the activation matrix will have a small non-negative rank. An approximation algorithm (via non-negative matrix factorization) is then used to compute the robustness and evaluate the robustness (by replacing the activation matrix with its low rank non-negative activation) is measured in a number of experiments with different amount of random label corruptions. The experiments show that networks trained on random labels are less robust than networks trained on true labels. While the concept is interesting, I find the arguments in the paper a bit vague, and the usefulness of the algorithm might be hampered by its computation complexity, which is not discussed in the paper. First of all, the paper lacks a clear notion of "memorization". While it is generally accepted that learns on random labels can be called "memorization", the paper seem to be defining it as how well is the network clustering points from the same class. Several questions need to be addressed in order for this notion to be justified: 1. Are (well generalized) networks really clustering samples of the same class to a centroid? It would be great if some empirical verifications are shown. Because the networks are using linear classifier in the last layer to classify the samples, it seems only linearly separability would be suffice for the work, which does not necessarily imply clustering. 2. Given two networks (of the same architecture), assume somehow network-1 decides to use the first 9 layers to compute a well clustered representation, while network-2 decides to use the first 5 layers to do the same thing. Do we say network-1 is (more) memorizing in this case? 3. The notion seems to be more about the underlying task than about the networks. Given the measurement, if a task is more complicated, meaning the input samples in the class have higher variance and requiring more efforts to cluster, then it seems the network will be doing more memorization. In other words, while networks will be doing more memorization when comparing a random label task to a true label task, it might also be "doing more memorization" when comparing learning on imagenet to learning on MNIST / CIFAR. One the one hand, this does not seem to fit our "intuition" about memorization; on the other hand, the heavy dependency on the underlying data distribution makes it difficult to compare results learned on different data -- especially since the measurements are based on per-class samples, "random labels" and "true labels" have very different class-conditional distributions. I also have some questions about Figure 2(c). I will continue numbering the question for easier discussion. 4. Why for all cases, the lower layers all have higher AUC than the higher layers (except the last one)? The argument given in the paper is that the lower layers are the feature extraction phase while the upper layers are memorization phase. I think if clearly verified, this is a very interesting observation. But the paper currently do not have experiments to verify the hypothesis. Also more studies on this with different networks would be good. For example, with deeper networks, does the feature extraction phase include more layers? 5. The p=1 and p<1 curves seem to be very different. If one is to sample more densely between p=0.8 and p=1, would there still be a clear phase transition? Some other questions: 6. Can you add discussions to the computation requirements for the proposed analysis? This is especially important for the cases where the analysis is used during training as tools to help deciding early stopping. 7. For the early stopping experiment, the main text says "These include the test error (in blue)" while in the figure the label axis is "Test loss". I*m assuming it is the cross entropy loss given the values are greater than 1. In this case, can you show in parallel the same plots in error rate, as the test error is more important than the test loss and the test loss could sometimes be artificially huge due to high confident mistakes on ambiguous test examples. Some minor issues: * Please proof read the paper for typos. E.g. on the 3rd paragraph of the 1st page: "that networks that networks that". * The convention with subplots seem to be putting sub-captions under the figures, not above.